commit 173d38e68805780b22322d8cba9f80538c98846d
Author: wehub-resource-sync <resource-sync@wehub.local>
Date:   Mon Jul 13 13:09:14 2026 +0800

    chore: import upstream snapshot with attribution

diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 0000000..c7ddd21
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,21 @@
+# === Optional build speed-ups (add to your ~/.zshrc or ~/.bashrc; do NOT commit) ===
+#
+# 1. sccache — compile cache, skips recompiling unchanged deps
+#    cargo install sccache
+#    export RUSTC_WRAPPER=sccache
+#
+# 2. lld — LLVM linker, 2-3x faster linking than the system default
+#    macOS:  brew install lld
+#            export CARGO_TARGET_AARCH64_APPLE_DARWIN_LINKER=/opt/homebrew/bin/lld
+#    Linux:  apt install lld
+#            export CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER=lld
+#
+# Skip DuckDB during development: cargo check --no-default-features
+# ===================================================================================
+
+[env]
+# Enable SQLite's built-in math functions for rusqlite's bundled libsqlite3.
+LIBSQLITE3_FLAGS = "SQLITE_ENABLE_MATH_FUNCTIONS"
+
+[target.x86_64-pc-windows-msvc]
+linker = "rust-lld"
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..c89d144
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,13 @@
+# Keep formatter-sensitive source files consistent across platforms.
+apps/desktop/src/**/*.ts text eol=lf
+apps/desktop/src/**/*.vue text eol=lf
+
+# Keep tests available for review and CI without counting them as shipped code
+# in GitHub's repository language breakdown.
+packages/app-tests/** linguist-vendored
+apps/desktop/src/**/__tests__/** linguist-vendored
+apps/desktop/src/**/*.spec.ts linguist-vendored
+apps/desktop/src/**/*.test.ts linguist-vendored
+packages/**/tests/** linguist-vendored
+packages/**/*.spec.ts linguist-vendored
+packages/**/*.test.ts linguist-vendored
diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
new file mode 100644
index 0000000..1254569
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -0,0 +1,64 @@
+name: "🐞 Bug Report / 问题反馈"
+description: Crashes, connection failures, query errors, display bugs, or other reproducible issues. / 程序崩溃、连接失败、查询异常、界面显示错误或其他可复现问题。
+title: "[Bug] "
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        感谢反馈。涉及敏感信息请脱敏。请尽量提供数据库类型、版本、复现步骤、截图和错误日志。
+        DBX 版本、运行环境、操作系统和系统架构可在应用内通过“设置 → 关于我们 → 复制支持信息”一键复制。
+
+  - type: input
+    id: database
+    attributes:
+      label: 数据库类型和版本
+      description: 例如 PostgreSQL 16、MySQL 8.0、Redis 7.2。
+      placeholder: "例如：PostgreSQL 16.2"
+    validations:
+      required: true
+
+  - type: textarea
+    id: description
+    attributes:
+      label: 问题描述
+      description: 请按下面的清单逐项填写，截图和错误日志尤其重要。
+      placeholder: |
+        1. 复现步骤：新建连接 → 填写信息 → 点击保存
+        2. 期望结果：能正常展开 schema
+        3. 实际结果：一直 loading，无错误提示
+        4. 最好附上截图和错误日志（设置 → 外观 → 启用"启用调试日志" → 复现问题 → 点击"下载日志"，将内容粘贴到这里）
+    validations:
+      required: true
+
+  - type: textarea
+    id: support-info
+    attributes:
+      label: 支持信息
+      description: 打开 DBX 的“设置 → 关于我们”，点击“复制支持信息”，然后粘贴到这里。如无法打开应用，请说明原因。
+      placeholder: |
+        DBX 版本：v0.5.52
+        运行环境：桌面端
+        操作系统：macOS 26.4
+        系统架构：aarch64
+    validations:
+      required: true
+
+  - type: dropdown
+    id: priority
+    attributes:
+      label: 优先级（是否紧急）
+      description: 紧急 = 希望下个版本优先修。维护者可根据实际情况调整。
+      options:
+        - "🔴 P0 紧急 · 下个版本必须修"
+        - "🟠 P1 重要 · 尽快处理"
+        - "🟡 P2 普通 · 按排期处理"
+        - "🟢 P3 低优 · 有空再修"
+    validations:
+      required: true
+
+  - type: textarea
+    id: extra
+    attributes:
+      label: 补充信息
+      description: 截图、SQL 样例、连接方式、特殊环境等。
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 0000000..5e562b5
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Documentation / 文档
+    url: https://dbxio.com/cn/docs/what-is-dbx
+    about: Check the docs before submitting an issue. / 提交 issue 前可先查看文档。
diff --git a/.github/ISSUE_TEMPLATE/database_compatibility.yml b/.github/ISSUE_TEMPLATE/database_compatibility.yml
new file mode 100644
index 0000000..7a4f60d
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/database_compatibility.yml
@@ -0,0 +1,55 @@
+name: "🔀 Compatibility Issue / 数据库兼容性问题"
+description: A specific database, version, or SQL dialect incompatibility. / 某个数据库、版本或 SQL 方言不兼容。
+title: "[Compatibility] "
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        用于收集数据库兼容性细节，例如连接失败、schema 读取不完整、字段类型显示错误等。请脱敏。
+        DBX 版本、运行环境、操作系统和系统架构可在应用内通过“设置 → 关于我们 → 复制支持信息”一键复制。
+
+  - type: input
+    id: database
+    attributes:
+      label: 数据库类型和版本
+      description: 也请注明发行版，如 MariaDB、AWS RDS、TiDB 等。
+      placeholder: "例如：MariaDB 10.11"
+    validations:
+      required: true
+
+  - type: textarea
+    id: description
+    attributes:
+      label: 问题描述
+      description: 什么操作，出了什么错，期望怎样？
+      placeholder: "例如：展开 schema 时报错 'unknown type'，期望能正常显示字段。"
+    validations:
+      required: true
+
+  - type: textarea
+    id: error
+    attributes:
+      label: 错误信息
+      render: shell
+    validations:
+      required: true
+
+  - type: textarea
+    id: support-info
+    attributes:
+      label: 支持信息
+      description: 打开 DBX 的“设置 → 关于我们”，点击“复制支持信息”，然后粘贴到这里。如无法打开应用，请说明原因。
+      placeholder: |
+        DBX 版本：v0.5.52
+        运行环境：桌面端
+        操作系统：macOS 26.4
+        系统架构：aarch64
+    validations:
+      required: true
+
+  - type: textarea
+    id: extra
+    attributes:
+      label: 补充信息
+      description: 表结构、SQL 样例、截图、部署方式（Docker/云/自建）等。
diff --git a/.github/ISSUE_TEMPLATE/feature_request.yml b/.github/ISSUE_TEMPLATE/feature_request.yml
new file mode 100644
index 0000000..d968ee2
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.yml
@@ -0,0 +1,69 @@
+name: "💡 Feature Request / 功能建议"
+description: Propose a new feature, interaction improvement, or enhancement. / 提议新功能、交互改进或现有功能增强。
+title: "[Feature] "
+labels: ["enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        好的建议最好说明使用场景、数据库类型和期望效果。请尽量避免只写“支持 X”。
+        DBX 版本、运行环境、操作系统和系统架构可在应用内通过“设置 → 关于我们 → 复制支持信息”一键复制。
+
+  - type: input
+    id: database
+    attributes:
+      label: 数据库类型和版本
+      description: 如果是通用功能，请填写“通用”。如果只影响特定数据源，请注明数据库类型、版本或发行版。
+      placeholder: "例如：PostgreSQL 16.2 / MySQL 8.0 / Redis 7.2 / 通用"
+    validations:
+      required: true
+
+  - type: textarea
+    id: support-info
+    attributes:
+      label: 支持信息
+      description: 打开 DBX 的“设置 → 关于我们”，点击“复制支持信息”，然后粘贴到这里。如无法打开应用，请说明原因。
+      placeholder: |
+        DBX 版本：v0.5.52
+        运行环境：桌面端
+        操作系统：macOS 26.4
+        系统架构：aarch64
+    validations:
+      required: true
+
+  - type: textarea
+    id: problem
+    attributes:
+      label: 当前痛点
+      description: 现在做这件事有什么不方便？
+      placeholder: "例如：每次查询后都要手动复制结果再转成 Markdown。"
+    validations:
+      required: true
+
+  - type: textarea
+    id: proposal
+    attributes:
+      label: 期望方案
+      description: 希望怎么支持？
+      placeholder: "例如：在查询结果右上角增加导出 Markdown 按钮。"
+    validations:
+      required: true
+
+  - type: dropdown
+    id: priority
+    attributes:
+      label: 优先级（是否紧急）
+      description: 紧急 = 希望下个版本优先做。维护者可根据实际情况调整。
+      options:
+        - "🔴 P0 紧急 · 下个版本必须做"
+        - "🟠 P1 重要 · 尽快处理"
+        - "🟡 P2 普通 · 按排期处理"
+        - "🟢 P3 低优 · 有空再做"
+    validations:
+      required: true
+
+  - type: textarea
+    id: extra
+    attributes:
+      label: 补充信息
+      description: 参考截图、替代方案、特殊环境等。
diff --git a/.github/ISSUE_TEMPLATE/question.yml b/.github/ISSUE_TEMPLATE/question.yml
new file mode 100644
index 0000000..c03f4da
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/question.yml
@@ -0,0 +1,44 @@
+name: "❓ Question / 问题咨询"
+description: Usage questions, configuration issues, or feedback you're not sure is a bug. / 使用疑问、配置问题或不确定是否为 bug 的反馈。
+title: "[Question] "
+labels: ["question"]
+body:
+  - type: input
+    id: database
+    attributes:
+      label: 数据库类型和版本
+      description: 如果问题与数据库无关，请填写“无关”。否则请注明数据库类型、版本或发行版。
+      placeholder: "例如：PostgreSQL 16.2 / MySQL 8.0 / Redis 7.2 / 无关"
+    validations:
+      required: true
+
+  - type: textarea
+    id: support-info
+    attributes:
+      label: 支持信息
+      description: 打开 DBX 的“设置 → 关于我们”，点击“复制支持信息”，然后粘贴到这里。如无法打开应用，请说明原因。
+      placeholder: |
+        DBX 版本：v0.5.52
+        运行环境：桌面端
+        操作系统：macOS 26.4
+        系统架构：aarch64
+    validations:
+      required: true
+
+  - type: textarea
+    id: goal
+    attributes:
+      label: 描述
+      description: 你想完成什么？已经尝试了什么？
+      placeholder: "例如：我想通过 SSH 隧道连接内网 PostgreSQL，已确认本机 psql 可以连接，但 DBX 中测试连接提示..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: context
+    attributes:
+      label: 环境信息
+      description: 连接方式、特殊环境、已尝试的排查方式等。
+      placeholder: |
+        连接方式：
+        补充环境：
diff --git a/.github/scripts/augment-latest-json-jdbc-plugin.mjs b/.github/scripts/augment-latest-json-jdbc-plugin.mjs
new file mode 100644
index 0000000..9a95298
--- /dev/null
+++ b/.github/scripts/augment-latest-json-jdbc-plugin.mjs
@@ -0,0 +1,31 @@
+import { readFileSync, writeFileSync } from "node:fs";
+
+export function augmentLatestJsonWithJdbcPlugin({ latestJson, jdbcVersion, protocolVersion, url }) {
+  const data = JSON.parse(latestJson);
+  data.jdbc_plugin = {
+    version: jdbcVersion,
+    protocol_version: Number(protocolVersion),
+    url,
+  };
+  return `${JSON.stringify(data, null, 2)}\n`;
+}
+
+function main() {
+  const [latestJsonPath, jdbcVersion, protocolVersion, url] = process.argv.slice(2);
+  if (!latestJsonPath || !jdbcVersion || !protocolVersion || !url) {
+    console.error("Usage: augment-latest-json-jdbc-plugin.mjs <latest.json> <jdbc-version> <protocol-version> <url>");
+    process.exit(1);
+  }
+
+  const updated = augmentLatestJsonWithJdbcPlugin({
+    latestJson: readFileSync(latestJsonPath, "utf8"),
+    jdbcVersion,
+    protocolVersion,
+    url,
+  });
+  writeFileSync(latestJsonPath, updated);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
diff --git a/.github/scripts/bump-agent-versions.mjs b/.github/scripts/bump-agent-versions.mjs
new file mode 100644
index 0000000..a61dd5d
--- /dev/null
+++ b/.github/scripts/bump-agent-versions.mjs
@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+
+const VERSIONS_PATH = "agents/versions.json";
+
+function bumpPatchVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(.*)$/.exec(version);
+  if (!match) {
+    throw new Error(`Agent version '${version}' is not a patchable semver version.`);
+  }
+  return `${match[1]}.${match[2]}.${Number(match[3]) + 1}${match[4]}`;
+}
+
+function pathChanged(changedFiles, pathPrefix) {
+  const normalized = pathPrefix.endsWith("/") ? pathPrefix : `${pathPrefix}/`;
+  return changedFiles.some((file) => file === pathPrefix || file.startsWith(normalized));
+}
+
+function isCommonRuntimeChange(file) {
+  return file === "agents/common/build.gradle" || file.startsWith("agents/common/src/main/");
+}
+
+function parseLegacyStandaloneProjects(buildGradle) {
+  const match = /legacyStandaloneProjects\s*=\s*\[([^\]]*)\]/m.exec(buildGradle);
+  if (!match) return new Set();
+
+  return new Set(
+    [...match[1].matchAll(/['"]([^'"]+)['"]/g)]
+      .map((entry) => entry[1])
+      .filter(Boolean),
+  );
+}
+
+function fileContainsCommonDependency(path, moduleExists, readModuleFile) {
+  if (!moduleExists(path)) return false;
+  const source = readModuleFile(path);
+  return /project\(\s*['"]:common['"]\s*\)/.test(source);
+}
+
+function resolveAgentModule(moduleName, { legacyStandaloneModules, moduleExists, readModuleFile }) {
+  let checkDir = null;
+  if (moduleName === "oracle" && moduleExists("agents/drivers/oracle-go")) {
+    checkDir = "drivers/oracle-go";
+  } else if (moduleExists(`agents/drivers/${moduleName}`)) {
+    checkDir = `drivers/${moduleName}`;
+  } else if (moduleExists(`agents/${moduleName}`) || moduleName === "common") {
+    checkDir = moduleName;
+  }
+
+  if (!checkDir) return null;
+
+  const modulePath = `agents/${checkDir}`;
+  const buildGradlePath = `${modulePath}/build.gradle`;
+  const hasBuildGradle = moduleExists(buildGradlePath);
+  const explicitlyDependsOnCommon = fileContainsCommonDependency(buildGradlePath, moduleExists, readModuleFile);
+
+  return {
+    checkDir,
+    modulePath,
+    commonDependent: hasBuildGradle && (explicitlyDependsOnCommon || !legacyStandaloneModules.has(moduleName)),
+  };
+}
+
+export function evaluateAgentVersionBump({
+  versions,
+  prevVersions = versions,
+  changedFiles,
+  legacyStandaloneModules = new Set(),
+  moduleExists = existsSync,
+  readModuleFile = (path) => readFileSync(path, "utf8"),
+  skipBump = false,
+  manualVersionsChanged = changedFiles.includes(VERSIONS_PATH),
+}) {
+  const nextVersions = { ...versions };
+  const logs = [];
+  let changed = false;
+
+  if (manualVersionsChanged && !skipBump) {
+    logs.push("Manual agents/versions.json changes detected; preserving manually changed module versions and auto-bumping the rest.");
+  }
+
+  if (skipBump) {
+    logs.push("Skipping automatic module version bump for migrated first release; versions.json was carried over from dbx-agents.");
+    return { changed, versions: nextVersions, prevVersions, logs };
+  }
+
+  const commonChanged = changedFiles.some(isCommonRuntimeChange);
+  if (commonChanged) {
+    logs.push("Common agent runtime changes detected; common-triggered bumps are limited to modules that package agents/common.");
+  }
+
+  for (const moduleName of Object.keys(versions)) {
+    const module = resolveAgentModule(moduleName, { legacyStandaloneModules, moduleExists, readModuleFile });
+    if (!module) continue;
+
+    const moduleChanged = pathChanged(changedFiles, module.modulePath);
+    // Only modules that package agents/common need installer-visible updates
+    // for shared Java runtime changes; native and standalone agents do not.
+    const commonAffectsModule = commonChanged && module.commonDependent;
+    const oldVersion = nextVersions[moduleName] ?? "0.1.0";
+    const prevVersion = prevVersions[moduleName] ?? "";
+    const manuallyVersioned = manualVersionsChanged && (!prevVersion || prevVersion !== oldVersion);
+
+    if (!moduleChanged && !commonAffectsModule) {
+      logs.push(`  ${moduleName}: no changes`);
+    } else if (manuallyVersioned) {
+      if (!prevVersion) {
+        logs.push(`  ${moduleName}: CHANGED, new module version kept at ${oldVersion}`);
+      } else {
+        logs.push(`  ${moduleName}: CHANGED, manual version ${prevVersion} -> ${oldVersion}`);
+      }
+    } else {
+      const newVersion = bumpPatchVersion(oldVersion);
+      nextVersions[moduleName] = newVersion;
+      changed = true;
+      logs.push(`  ${moduleName}: CHANGED`);
+      logs.push(`  ${moduleName}: ${oldVersion} -> ${newVersion}`);
+    }
+  }
+
+  return { changed, versions: nextVersions, prevVersions, logs };
+}
+
+function git(args) {
+  return execFileSync("git", args, { encoding: "utf8" }).trim();
+}
+
+function parseArgs(argv) {
+  const options = {
+    migratedFirstRelease: false,
+    prevTag: "",
+    prevVersionsFile: "",
+    skipBump: false,
+    write: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--write") {
+      options.write = true;
+    } else if (arg === "--skip-bump") {
+      options.skipBump = true;
+    } else if (arg === "--prev-tag") {
+      options.prevTag = argv[++index] ?? "";
+    } else if (arg === "--prev-versions-file") {
+      options.prevVersionsFile = argv[++index] ?? "";
+    } else if (arg === "--migrated-first-release") {
+      options.migratedFirstRelease = (argv[++index] ?? "") === "true";
+    } else {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+  }
+
+  if (!options.prevTag) {
+    throw new Error("--prev-tag is required.");
+  }
+  return options;
+}
+
+function outputStepValues(result, prevTag, migratedFirstRelease) {
+  const outputPath = process.env.GITHUB_OUTPUT;
+  if (!outputPath) return;
+
+  appendFileSync(
+    outputPath,
+    [
+      `versions=${JSON.stringify(result.versions)}`,
+      `prev_versions=${JSON.stringify(result.prevVersions)}`,
+      `prev_tag=${prevTag}`,
+      `migrated_first_release=${migratedFirstRelease}`,
+      "",
+    ].join("\n"),
+  );
+}
+
+function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const versions = JSON.parse(readFileSync(VERSIONS_PATH, "utf8"));
+  const legacyStandaloneModules = parseLegacyStandaloneProjects(readFileSync("agents/build.gradle", "utf8"));
+  const changedFiles = options.skipBump ? [] : git(["diff", "--name-only", `${options.prevTag}..HEAD`]).split("\n").filter(Boolean);
+  const manualVersionsChanged = changedFiles.includes(VERSIONS_PATH);
+  const prevVersions = options.prevVersionsFile
+    ? JSON.parse(readFileSync(options.prevVersionsFile, "utf8"))
+    : manualVersionsChanged
+      ? JSON.parse(git(["show", `${options.prevTag}:${VERSIONS_PATH}`]))
+      : versions;
+
+  const result = evaluateAgentVersionBump({
+    versions,
+    prevVersions,
+    changedFiles,
+    legacyStandaloneModules,
+    skipBump: options.skipBump,
+    manualVersionsChanged,
+  });
+
+  for (const line of result.logs) {
+    console.log(line);
+  }
+
+  const versionsJson = `${JSON.stringify(result.versions, null, 2)}\n`;
+  if (options.write) {
+    writeFileSync(VERSIONS_PATH, versionsJson);
+  }
+  console.log(versionsJson);
+  outputStepValues(result, options.prevTag, options.migratedFirstRelease);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
diff --git a/.github/scripts/bump-jdbc-plugin-version.mjs b/.github/scripts/bump-jdbc-plugin-version.mjs
new file mode 100644
index 0000000..c072bd9
--- /dev/null
+++ b/.github/scripts/bump-jdbc-plugin-version.mjs
@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+
+const POM_PATH = "plugins/jdbc/pom.xml";
+const MANIFEST_PATH = "plugins/jdbc/manifest.json";
+
+function firstProjectVersion(pomXml) {
+  const match = pomXml.match(/<project[\s\S]*?<version>([^<]+)<\/version>/);
+  return match?.[1]?.trim() ?? "";
+}
+
+function manifestVersion(manifestJson) {
+  return JSON.parse(manifestJson).version ?? "";
+}
+
+function bumpPatchVersion(version) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
+  if (!match) {
+    throw new Error(`JDBC plugin version '${version}' is not a patchable semver version.`);
+  }
+  return `${match[1]}.${match[2]}.${Number(match[3]) + 1}${match[4]}`;
+}
+
+function isReleaseBumpRelevantJdbcPluginChange(file) {
+  if (file.startsWith("plugins/jdbc/src/") || file.startsWith("plugins/jdbc/bin/")) return true;
+  if (!file.startsWith("plugins/jdbc/")) return false;
+  if (file.startsWith("plugins/jdbc/dist/") || file.startsWith("plugins/jdbc/target/")) return false;
+  if (file === "plugins/jdbc/README.md" || file === "plugins/jdbc/package.sh") return false;
+  if (file === POM_PATH || file === MANIFEST_PATH) return false;
+  return true;
+}
+
+function hasJdbcPluginVersionChange(file) {
+  return file === POM_PATH || file === MANIFEST_PATH;
+}
+
+function updatePomVersion(pomXml, version) {
+  return pomXml.replace(/(<project[\s\S]*?<version>)([^<]+)(<\/version>)/, `$1${version}$3`);
+}
+
+function updateManifestVersion(manifestJson, version) {
+  const manifest = JSON.parse(manifestJson);
+  manifest.version = version;
+  return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+
+export function evaluateJdbcPluginReleaseBump({ changedFiles, pomXml, manifestJson }) {
+  const pomVersion = firstProjectVersion(pomXml);
+  const currentManifestVersion = manifestVersion(manifestJson);
+  if (pomVersion !== currentManifestVersion) {
+    throw new Error(`JDBC plugin version mismatch: pom.xml is ${pomVersion} but manifest.json is ${currentManifestVersion}.`);
+  }
+
+  const shouldBump = changedFiles.some(isReleaseBumpRelevantJdbcPluginChange) && !changedFiles.some(hasJdbcPluginVersionChange);
+  const newVersion = shouldBump ? bumpPatchVersion(pomVersion) : pomVersion;
+  return {
+    changed: shouldBump,
+    oldVersion: pomVersion,
+    newVersion,
+    pomXml: shouldBump ? updatePomVersion(pomXml, newVersion) : pomXml,
+    manifestJson: shouldBump ? updateManifestVersion(manifestJson, newVersion) : manifestJson,
+  };
+}
+
+function git(args) {
+  return execFileSync("git", args, { encoding: "utf8" }).trim();
+}
+
+function main() {
+  const [baseRef = "HEAD~1", headRef = "HEAD", ...flags] = process.argv.slice(2);
+  const write = flags.includes("--write");
+  const changedFiles = git(["diff", "--name-only", baseRef, headRef]).split("\n").filter(Boolean);
+  const result = evaluateJdbcPluginReleaseBump({
+    changedFiles,
+    pomXml: readFileSync(POM_PATH, "utf8"),
+    manifestJson: readFileSync(MANIFEST_PATH, "utf8"),
+  });
+
+  if (write && result.changed) {
+    writeFileSync(POM_PATH, result.pomXml);
+    writeFileSync(MANIFEST_PATH, result.manifestJson);
+  }
+
+  console.log(`changed=${result.changed}`);
+  console.log(`old_version=${result.oldVersion}`);
+  console.log(`new_version=${result.newVersion}`);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
diff --git a/.github/scripts/check-jdbc-plugin-version.mjs b/.github/scripts/check-jdbc-plugin-version.mjs
new file mode 100644
index 0000000..538b201
--- /dev/null
+++ b/.github/scripts/check-jdbc-plugin-version.mjs
@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+
+const POM_PATH = "plugins/jdbc/pom.xml";
+const MANIFEST_PATH = "plugins/jdbc/manifest.json";
+
+function firstProjectVersion(pomXml) {
+  const match = pomXml.match(/<project[\s\S]*?<version>([^<]+)<\/version>/);
+  return match?.[1]?.trim() ?? "";
+}
+
+function manifestVersion(manifestJson) {
+  return JSON.parse(manifestJson).version ?? "";
+}
+
+export function evaluateJdbcPluginVersionChange({ headPomVersion, headManifestVersion }) {
+  const errors = [];
+  if (headPomVersion !== headManifestVersion) {
+    errors.push(`JDBC plugin version mismatch: pom.xml is ${headPomVersion} but manifest.json is ${headManifestVersion}.`);
+    return errors;
+  }
+  return errors;
+}
+
+function git(args) {
+  return execFileSync("git", args, { encoding: "utf8" }).trim();
+}
+
+function readFileAt(ref, path) {
+  return git(["show", `${ref}:${path}`]);
+}
+
+function main() {
+  const [, headRef = "HEAD"] = process.argv.slice(2);
+  const headPomVersion = firstProjectVersion(readFileAt(headRef, POM_PATH));
+  const headManifestVersion = manifestVersion(readFileAt(headRef, MANIFEST_PATH));
+  const errors = evaluateJdbcPluginVersionChange({
+    headPomVersion,
+    headManifestVersion,
+  });
+
+  if (errors.length) {
+    for (const error of errors) {
+      console.error(`::error::${error}`);
+    }
+    process.exit(1);
+  }
+  console.log(`JDBC plugin version check passed (${headPomVersion}).`);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
diff --git a/.github/scripts/i18n-autofill.mjs b/.github/scripts/i18n-autofill.mjs
new file mode 100644
index 0000000..9ec2e4c
--- /dev/null
+++ b/.github/scripts/i18n-autofill.mjs
@@ -0,0 +1,544 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+const LOCALES_DIR = "apps/desktop/src/i18n/locales";
+const SOURCE_LOCALE = "zh-CN";
+const TARGET_LOCALES = ["en", "es", "it", "ja", "pt-BR", "zh-TW"];
+const TARGET_LABELS = {
+  en: "English",
+  es: "Spanish",
+  it: "Italian",
+  ja: "Japanese",
+  "pt-BR": "Brazilian Portuguese",
+  "zh-TW": "Traditional Chinese used in Taiwan",
+};
+
+const args = new Set(process.argv.slice(2));
+const dryRun = args.has("--dry-run") || !args.has("--write");
+const mockTranslations = args.has("--mock-translations") || process.env.I18N_MOCK_TRANSLATIONS === "1";
+const baseRef = valueArg("--base-ref") || process.env.I18N_BASE_REF || "origin/main";
+const apiKey = process.env.DEEPSEEK_API_KEY || "";
+const apiUrl = process.env.DEEPSEEK_API_URL || "https://api.deepseek.com/chat/completions";
+const model = process.env.DEEPSEEK_MODEL || "deepseek-v4-pro";
+
+async function main() {
+  const sourcePath = localePath(SOURCE_LOCALE);
+  const baseSourceText = readBaseFile(sourcePath);
+  const headSource = parseLocaleFile(readFileSync(sourcePath, "utf8"), sourcePath);
+  const baseSource = parseLocaleFile(baseSourceText, `${baseRef}:${sourcePath}`);
+
+  // Only PR-new Chinese source keys are eligible for auto-fill; historical
+  // locale gaps intentionally stay untouched to keep bot patches scoped.
+  const baseLeaves = flattenLeaves(baseSource.root);
+  const headLeaves = flattenLeaves(headSource.root);
+  const newSourceKeys = [...headLeaves.keys()].filter((key) => !baseLeaves.has(key));
+
+  if (newSourceKeys.length === 0) {
+    console.log(`No new ${SOURCE_LOCALE} i18n keys compared with ${baseRef}`);
+    return;
+  }
+
+  console.log(`Found ${newSourceKeys.length} new ${SOURCE_LOCALE} i18n key(s):`);
+  for (const key of newSourceKeys) console.log(`- ${key}`);
+
+  let patchedFiles = 0;
+  const summary = {
+    sourceLocale: SOURCE_LOCALE,
+    newKeys: newSourceKeys,
+    updatedLocales: [],
+  };
+
+  for (const locale of TARGET_LOCALES) {
+    const path = localePath(locale);
+    if (!existsSync(path)) throw new Error(`Missing locale file: ${path}`);
+
+    const text = readFileSync(path, "utf8");
+    const parsed = parseLocaleFile(text, path);
+    const targetLeaves = flattenLeaves(parsed.root);
+    const missingKeys = newSourceKeys.filter((key) => !targetLeaves.has(key));
+
+    if (missingKeys.length === 0) {
+      console.log(`${locale}: all new keys already present`);
+      continue;
+    }
+
+    console.log(`${locale}: missing ${missingKeys.length} new key(s)`);
+    for (const key of missingKeys) console.log(`  - ${key}`);
+
+    const translations = await translateMissing(locale, missingKeys, headLeaves);
+    const updated = patchLocaleText(text, parsed, missingKeys, translations, headSource.root);
+
+    if (updated === text) {
+      throw new Error(`${path}: expected changes for missing keys, but patch was empty`);
+    }
+
+    parseLocaleFile(updated, path);
+    if (!dryRun) writeFileSync(path, updated);
+    patchedFiles += 1;
+    summary.updatedLocales.push({ locale, count: missingKeys.length });
+  }
+
+  if (patchedFiles === 0) {
+    console.log("No locale files needed changes");
+  } else if (dryRun) {
+    console.log(`Dry run completed; ${patchedFiles} locale file(s) would be patched`);
+  } else {
+    console.log(`Patched ${patchedFiles} locale file(s)`);
+  }
+
+  writeSummary(summary);
+}
+
+function valueArg(name) {
+  const index = process.argv.indexOf(name);
+  if (index === -1) return null;
+  const value = process.argv[index + 1];
+  if (!value || value.startsWith("--")) throw new Error(`${name} requires a value`);
+  return value;
+}
+
+function localePath(locale) {
+  return join(LOCALES_DIR, `${locale}.ts`);
+}
+
+function readBaseFile(path) {
+  try {
+    return execFileSync("git", ["show", `${baseRef}:${path}`], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+  } catch (error) {
+    throw new Error(`Unable to read ${path} from ${baseRef}: ${error.message}`);
+  }
+}
+
+function writeSummary(summary) {
+  const path = process.env.I18N_SUMMARY_FILE;
+  if (!path) return;
+  writeFileSync(path, `${JSON.stringify(summary, null, 2)}\n`);
+}
+
+async function translateMissing(locale, keys, sourceLeaves) {
+  if (mockTranslations) {
+    return Object.fromEntries(keys.map((key) => [key, `[${locale}] ${sourceLeaves.get(key)}`]));
+  }
+
+  if (!apiKey) {
+    throw new Error(`DEEPSEEK_API_KEY is required to translate ${keys.length} missing ${locale} i18n key(s)`);
+  }
+
+  const items = keys.map((key) => ({ key, source: sourceLeaves.get(key) }));
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      model,
+      response_format: { type: "json_object" },
+      temperature: 0.1,
+      max_tokens: Math.max(1024, keys.length * 120),
+      messages: [
+        {
+          role: "system",
+          content: [
+            `Translate DBX UI i18n strings from Simplified Chinese to ${TARGET_LABELS[locale]}.`,
+            'Return strict JSON only in this exact shape: {"translations":{"path.to.key":"translated text"}}.',
+            "Keep i18n placeholders such as {count}, {message}, and {name} exactly unchanged.",
+            "Keep product names, database names, SQL keywords, file extensions, shortcuts, and code-like terms unchanged unless the target language convention clearly translates them.",
+            "Do not add keys, remove keys, or translate key names.",
+          ].join(" "),
+        },
+        {
+          role: "user",
+          content: JSON.stringify({ targetLocale: locale, items }),
+        },
+      ],
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`DeepSeek API failed for ${locale}: HTTP ${response.status} ${await response.text()}`);
+  }
+
+  const data = await response.json();
+  const content = data?.choices?.[0]?.message?.content;
+  if (typeof content !== "string" || !content.trim()) {
+    throw new Error(`DeepSeek API returned no translation content for ${locale}`);
+  }
+
+  const parsed = parseJsonContent(content);
+  const translations = parsed.translations;
+  if (!translations || typeof translations !== "object" || Array.isArray(translations)) {
+    throw new Error(`DeepSeek response for ${locale} must contain a translations object`);
+  }
+
+  for (const key of keys) {
+    if (typeof translations[key] !== "string" || !translations[key].trim()) {
+      throw new Error(`DeepSeek response for ${locale} is missing translation for ${key}`);
+    }
+    assertSamePlaceholders(key, sourceLeaves.get(key), translations[key], locale);
+  }
+
+  return translations;
+}
+
+function parseJsonContent(content) {
+  const trimmed = content.trim();
+  const withoutFence = trimmed
+    .replace(/^```(?:json)?\s*/i, "")
+    .replace(/\s*```$/i, "")
+    .trim();
+  try {
+    return JSON.parse(withoutFence);
+  } catch (error) {
+    throw new Error(`Unable to parse DeepSeek JSON response: ${error.message}\n${content}`);
+  }
+}
+
+function assertSamePlaceholders(key, source, translated, locale) {
+  const sourcePlaceholders = placeholders(source);
+  const translatedPlaceholders = placeholders(translated);
+  if (sourcePlaceholders.join("\0") !== translatedPlaceholders.join("\0")) {
+    throw new Error(
+      `${locale}:${key} placeholder mismatch: expected [${sourcePlaceholders.join(", ")}], got [${translatedPlaceholders.join(", ")}]`,
+    );
+  }
+}
+
+function placeholders(value) {
+  return [...String(value).matchAll(/\{[^{}]+\}/g)].map((match) => match[0]).sort();
+}
+
+function patchLocaleText(text, parsed, missingKeys, translations, sourceRoot) {
+  const groups = groupMissingKeys(parsed.root, missingKeys, translations, sourceRoot);
+  const edits = [];
+
+  for (const group of groups) {
+    const insertText = buildInsertion(text, group.objectNode, group.entries, group.sourceObjectNode);
+    edits.push({ index: lineStartBefore(text, group.objectNode.closeBrace), text: insertText });
+  }
+
+  return applyEdits(text, edits);
+}
+
+function groupMissingKeys(targetRoot, missingKeys, translations, sourceRoot) {
+  const byParent = new Map();
+
+  for (const key of missingKeys) {
+    const segments = key.split(".");
+    const { node: parentNode, path: parentPath, remaining } = findInsertionParent(targetRoot, segments);
+    const parentKey = parentPath.join(".");
+    const sourceParent = findObjectNode(sourceRoot, parentPath);
+    if (!sourceParent) throw new Error(`${key}: insertion parent is missing in ${SOURCE_LOCALE}`);
+
+    const sourceOrder = sourceParent.properties.map((property) => property.key);
+    const entry = {
+      path: remaining,
+      value: translations[key],
+      order: sourceOrder.indexOf(remaining[0]),
+    };
+
+    if (!byParent.has(parentKey)) byParent.set(parentKey, { objectNode: parentNode, sourceObjectNode: sourceParent, entries: [] });
+    byParent.get(parentKey).entries.push(entry);
+  }
+
+  return [...byParent.values()].map((group) => ({
+    ...group,
+    entries: group.entries.sort((left, right) => left.order - right.order || left.path.join(".").localeCompare(right.path.join("."))),
+  }));
+}
+
+function findInsertionParent(root, fullPath) {
+  let current = root;
+  const existingPath = [];
+
+  for (const segment of fullPath.slice(0, -1)) {
+    const property = current.properties.find((candidate) => candidate.key === segment);
+    if (!property) break;
+    if (property.value.type !== "object") {
+      throw new Error(`${fullPath.join(".")}: cannot insert under non-object locale key ${[...existingPath, segment].join(".")}`);
+    }
+    current = property.value;
+    existingPath.push(segment);
+  }
+
+  return { node: current, path: existingPath, remaining: fullPath.slice(existingPath.length) };
+}
+
+function findObjectNode(root, path) {
+  let current = root;
+  for (const segment of path) {
+    const property = current.properties.find((candidate) => candidate.key === segment);
+    if (!property || property.value.type !== "object") return null;
+    current = property.value;
+  }
+  return current;
+}
+
+function buildInsertion(text, objectNode, entries, sourceObjectNode) {
+  const parentIndent = lineIndentBefore(text, objectNode.closeBrace);
+  const childIndent = objectNode.properties.length > 0 ? lineIndentBefore(text, objectNode.properties[0].start) : `${parentIndent}  `;
+  const lines = renderEntryTree(buildEntryTree(entries), sourceObjectNode, childIndent);
+
+  return `${lines.join("\n")}\n`;
+}
+
+function buildEntryTree(entries) {
+  const root = { children: new Map(), value: undefined };
+  for (const entry of entries) {
+    let current = root;
+    for (const segment of entry.path) {
+      if (!current.children.has(segment)) current.children.set(segment, { children: new Map(), value: undefined });
+      current = current.children.get(segment);
+    }
+    current.value = entry.value;
+  }
+  return root;
+}
+
+function renderEntryTree(tree, sourceObjectNode, indent) {
+  const lines = [];
+  const entries = [...tree.children.entries()].sort(([left], [right]) => compareSourceOrder(sourceObjectNode, left, right));
+
+  for (const [key, child] of entries) {
+    if (child.children.size === 0) {
+      lines.push(`${indent}${formatKey(key)}: ${JSON.stringify(child.value)},`);
+      continue;
+    }
+
+    const childSourceObject = sourceObjectNode?.properties.find((property) => property.key === key && property.value.type === "object")?.value;
+    lines.push(`${indent}${formatKey(key)}: {`);
+    lines.push(...renderEntryTree(child, childSourceObject, `${indent}  `));
+    lines.push(`${indent}},`);
+  }
+
+  return lines;
+}
+
+function compareSourceOrder(sourceObjectNode, left, right) {
+  const order = sourceObjectNode?.properties.map((property) => property.key) || [];
+  const leftIndex = order.indexOf(left);
+  const rightIndex = order.indexOf(right);
+  if (leftIndex !== -1 || rightIndex !== -1) {
+    if (leftIndex === -1) return 1;
+    if (rightIndex === -1) return -1;
+    return leftIndex - rightIndex;
+  }
+  return left.localeCompare(right);
+}
+
+function formatKey(key) {
+  return /^[A-Za-z_$][\w$]*$/.test(key) ? key : JSON.stringify(key);
+}
+
+function lineIndentBefore(text, index) {
+  const lineStart = lineStartBefore(text, index);
+  const match = text.slice(lineStart, index).match(/^[ \t]*/);
+  return match ? match[0] : "";
+}
+
+function lineStartBefore(text, index) {
+  return text.lastIndexOf("\n", Math.max(0, index - 1)) + 1;
+}
+
+function applyEdits(text, edits) {
+  let updated = text;
+  for (const edit of edits.sort((left, right) => right.index - left.index)) {
+    updated = `${updated.slice(0, edit.index)}${edit.text}${updated.slice(edit.index)}`;
+  }
+  return updated;
+}
+
+function flattenLeaves(root) {
+  const result = new Map();
+  flattenNode(root, [], result);
+  return result;
+}
+
+function flattenNode(node, path, result) {
+  for (const property of node.properties) {
+    const nextPath = [...path, property.key];
+    if (property.value.type === "object") {
+      flattenNode(property.value, nextPath, result);
+    } else {
+      result.set(nextPath.join("."), property.value.value);
+    }
+  }
+}
+
+function parseLocaleFile(text, file) {
+  const parser = new Parser(text, file);
+  const root = parser.parseLocaleRoot();
+  return { root };
+}
+
+class Parser {
+  constructor(text, file) {
+    this.text = text;
+    this.file = file;
+    this.index = 0;
+  }
+
+  parseLocaleRoot() {
+    const exportIndex = this.text.indexOf("export default");
+    if (exportIndex === -1) this.fail("Missing export default");
+    this.index = exportIndex + "export default".length;
+    this.skipSpace();
+
+    if (this.peek() === "{") return this.parseObject();
+
+    const callee = this.parseIdentifier();
+    this.skipSpace();
+    if (!callee || this.peek() !== "(") this.fail("Expected object literal or wrapper call after export default");
+    this.index += 1;
+    this.skipSpace();
+    const object = this.parseObject();
+    this.skipSpace();
+    if (this.peek() !== ")") this.fail("Expected closing wrapper call parenthesis");
+    return object;
+  }
+
+  parseObject() {
+    this.expect("{");
+    const openBrace = this.index - 1;
+    const properties = [];
+
+    while (true) {
+      this.skipSpace();
+      if (this.peek() === "}") {
+        const closeBrace = this.index;
+        this.index += 1;
+        return { type: "object", openBrace, closeBrace, end: this.index, properties };
+      }
+
+      const start = this.index;
+      const key = this.parseKey();
+      this.skipSpace();
+      this.expect(":");
+      this.skipSpace();
+      const value = this.parseValue();
+      this.skipSpace();
+
+      let hasComma = false;
+      if (this.peek() === ",") {
+        hasComma = true;
+        this.index += 1;
+      }
+
+      properties.push({ key, start, end: this.index, hasComma, value });
+    }
+  }
+
+  parseValue() {
+    const char = this.peek();
+    if (char === "{") return this.parseObject();
+    if (char === '"' || char === "'") {
+      const start = this.index;
+      const value = this.parseString();
+      return { type: "string", start, end: this.index, value };
+    }
+    this.fail(`Unsupported locale value starting with ${JSON.stringify(char)}`);
+  }
+
+  parseKey() {
+    const char = this.peek();
+    if (char === '"' || char === "'") return this.parseString();
+    const key = this.parseIdentifier();
+    if (!key) this.fail("Expected property key");
+    return key;
+  }
+
+  parseIdentifier() {
+    const match = /^[A-Za-z_$][\w$-]*/.exec(this.text.slice(this.index));
+    if (!match) return "";
+    this.index += match[0].length;
+    return match[0];
+  }
+
+  parseString() {
+    const quote = this.peek();
+    this.index += 1;
+    let value = "";
+    while (this.index < this.text.length) {
+      const char = this.text[this.index];
+      if (char === "\\") {
+        const escaped = this.text[this.index + 1];
+        if (!escaped) this.fail("Unterminated string literal");
+        this.index += 2;
+        if (escaped === "n") value += "\n";
+        else if (escaped === "r") value += "\r";
+        else if (escaped === "t") value += "\t";
+        else if (escaped === "b") value += "\b";
+        else if (escaped === "f") value += "\f";
+        else if (escaped === "v") value += "\v";
+        else if (escaped === "0") value += "\0";
+        else if (escaped === "u") {
+          const hex = this.text.slice(this.index, this.index + 4);
+          if (!/^[0-9a-fA-F]{4}$/.test(hex)) this.fail("Invalid unicode escape");
+          value += String.fromCharCode(Number.parseInt(hex, 16));
+          this.index += 4;
+        } else {
+          value += escaped;
+        }
+        continue;
+      }
+      if (char === quote) {
+        this.index += 1;
+        return value;
+      }
+      if (char === "\n" || char === "\r") this.fail("Unterminated string literal");
+      value += char;
+      this.index += 1;
+    }
+    this.fail("Unterminated string literal");
+  }
+
+  skipSpace() {
+    while (this.index < this.text.length) {
+      const char = this.text[this.index];
+      if (/\s/.test(char)) {
+        this.index += 1;
+        continue;
+      }
+      if (this.text.startsWith("//", this.index)) {
+        const next = this.text.indexOf("\n", this.index + 2);
+        this.index = next === -1 ? this.text.length : next + 1;
+        continue;
+      }
+      if (this.text.startsWith("/*", this.index)) {
+        const next = this.text.indexOf("*/", this.index + 2);
+        if (next === -1) this.fail("Unterminated block comment");
+        this.index = next + 2;
+        continue;
+      }
+      break;
+    }
+  }
+
+  expect(expected) {
+    if (this.peek() !== expected) this.fail(`Expected ${expected}`);
+    this.index += expected.length;
+  }
+
+  peek() {
+    return this.text[this.index] || "";
+  }
+
+  fail(message) {
+    const location = this.location();
+    throw new Error(`${this.file}:${location.line}:${location.column}: ${message}`);
+  }
+
+  location() {
+    const before = this.text.slice(0, this.index);
+    const lines = before.split(/\r?\n/);
+    return { line: lines.length, column: lines[lines.length - 1].length + 1 };
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});
diff --git a/.github/scripts/issue-claim.mjs b/.github/scripts/issue-claim.mjs
new file mode 100644
index 0000000..7e8b9ad
--- /dev/null
+++ b/.github/scripts/issue-claim.mjs
@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+const issueNumber = process.env.ISSUE_NUMBER;
+const commentBody = process.env.COMMENT_BODY || "";
+const commentUser = process.env.COMMENT_USER || "";
+const commentUserType = process.env.COMMENT_USER_TYPE || "";
+
+// Only handle /claim as a standalone word
+if (!/(?:^|\s)\/claim(?:\s|$)/.test(commentBody)) {
+  process.exit(0);
+}
+
+// Don't let bots claim
+if (commentUserType === "Bot") {
+  console.log("Commenter is a bot, skipping");
+  process.exit(0);
+}
+
+console.log(`/claim from @${commentUser} on #${issueNumber}`);
+
+async function gh(args) {
+  const { stdout } = await execFileAsync("gh", args, { maxBuffer: 1024 * 1024 });
+  return stdout.trim();
+}
+
+async function ghJson(args) {
+  const out = await gh(args);
+  return JSON.parse(out);
+}
+
+// Check current assignees
+const assignees = await ghJson([
+  "issue", "view", issueNumber,
+  "--json", "assignees",
+  "-q", ".assignees",
+]);
+
+if (assignees.length > 0) {
+  const names = assignees.map((a) => `@${a.login}`).join(", ");
+  await gh([
+    "issue", "comment", issueNumber,
+    "--body", `❌ @${commentUser} 这个 issue 已经有人认领了：${names}`,
+  ]);
+  process.exit(0);
+}
+
+// Assign
+await gh(["issue", "edit", issueNumber, "--add-assignee", commentUser]);
+
+// Confirm
+await gh([
+  "issue", "comment", issueNumber,
+  "--body", `✅ @${commentUser} 已认领 #${issueNumber}，开始处理吧！`,
+]);
+
+console.log(`Assigned @${commentUser} to #${issueNumber}`);
diff --git a/.github/scripts/label-issue-database.mjs b/.github/scripts/label-issue-database.mjs
new file mode 100644
index 0000000..2187cd3
--- /dev/null
+++ b/.github/scripts/label-issue-database.mjs
@@ -0,0 +1,570 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+
+const LABEL_PREFIX = "db/";
+const USER_PRIORITY_PREFIX = "user-priority/";
+const API_VERSION = "2022-11-28";
+const dryRun = process.env.DRY_RUN === "1" || process.env.DRY_RUN === "true";
+
+const USER_PRIORITY_LABELS = {
+  P0: { color: "b60205", description: "User-reported priority: urgent" },
+  P1: { color: "d93f0b", description: "User-reported priority: important" },
+  P2: { color: "fbca04", description: "User-reported priority: normal" },
+  P3: { color: "bfd4f2", description: "User-reported priority: low" },
+};
+
+const LABEL_PALETTE = [
+  "0e8a16",
+  "1d76db",
+  "5319e7",
+  "c2e0c6",
+  "bfd4f2",
+  "d4c5f9",
+  "fef2c0",
+  "fbca04",
+  "f9d0c4",
+  "e99695",
+  "f29513",
+  "c5def5",
+];
+
+const extraAliases = {
+  mysql: ["mariadb", "percona", "tidb"],
+  postgres: ["postgresql", "postgres", "pgsql", "pg", "hologres"],
+  sqlite: ["sqlite3", "sql lite"],
+  clickhouse: ["click house", "ch"],
+  sqlserver: ["sql server", "mssql", "microsoft sql server", "sqlservice"],
+  mongodb: ["mongo", "mongodb"],
+  oracle: ["oracle database"],
+  elasticsearch: ["elastic search"],
+  chromadb: ["chroma"],
+  manticoresearch: ["manticore"],
+  dameng: ["dm8", "dameng", "达梦"],
+  kingbase: ["kingbasees", "kingbase", "人大金仓", "金仓"],
+  highgo: ["瀚高"],
+  yashandb: ["yashan", "崖山"],
+  saphana: ["hana", "sap hana"],
+  opengauss: ["open gauss"],
+  "oceanbase-oracle": ["oceanbase", "oceanbase oracle"],
+  gbase: ["gbase 8a", "gbase8a", "gbase 8s", "gbase8s"],
+  access: ["microsoft access", "ms access"],
+  vastbase: ["vastbase g", "vastbaseg"],
+  prestosql: ["presto", "presto sql"],
+  hive: ["apache hive"],
+  db2: ["ibm db2"],
+  informix: ["ibm informix"],
+  bigquery: ["google bigquery"],
+  kylin: ["apache kylin"],
+  oscar: ["shentong", "oscar", "神通"],
+  xugu: ["xugudb", "xugu", "虚谷"],
+  zookeeper: ["zoo keeper", "apache zookeeper"],
+  mq: ["message queue", "kafka", "rabbitmq", "rocketmq"],
+  iotdb: ["apache iotdb"],
+  iris: ["intersystems iris", "intersystems cache", "intersystems caché", "cache", "caché", "ensemble"],
+  spark: ["apache spark"],
+};
+
+const globallyAmbiguousAliases = new Set([
+  "access",
+  "ch",
+  "h2",
+  "iris",
+  "jdbc",
+  "mq",
+  "pg",
+  "spark",
+]);
+
+const genericDatabaseValues = [
+  "general",
+  "generic",
+  "global",
+  "all",
+  "any",
+  "none",
+  "n/a",
+  "na",
+  "通用",
+  "全部",
+  "所有",
+  "无",
+  "不适用",
+];
+
+const manifestUrl = new URL("../../crates/dbx-core/assets/database-drivers.manifest.json", import.meta.url);
+const manifest = JSON.parse(fs.readFileSync(manifestUrl, "utf8"));
+const drivers = manifest.drivers.map((driver) => ({
+  dbType: driver.dbType,
+  label: driver.label,
+  aliases: [...new Set([driver.dbType, driver.label, ...(extraAliases[driver.dbType] || [])])],
+}));
+const exactAsciiAliases = new Set(
+  drivers.flatMap((driver) => driver.aliases.map((alias) => compactAscii(alias)).filter((alias) => alias.length >= 5)),
+);
+
+function loadIssue() {
+  if (process.env.GITHUB_EVENT_PATH && fs.existsSync(process.env.GITHUB_EVENT_PATH)) {
+    const event = JSON.parse(fs.readFileSync(process.env.GITHUB_EVENT_PATH, "utf8"));
+    return event.issue || {};
+  }
+
+  return {
+    number: process.env.ISSUE_NUMBER,
+    title: process.env.ISSUE_TITLE || "",
+    body: process.env.ISSUE_BODY || "",
+    labels: process.env.ISSUE_LABELS ? JSON.parse(process.env.ISSUE_LABELS) : [],
+  };
+}
+
+function labelNames(labels) {
+  return (labels || []).map((label) => (typeof label === "string" ? label : label.name)).filter(Boolean);
+}
+
+function stablePaletteColor(value) {
+  let hash = 0;
+  for (const char of value) {
+    hash = (hash * 31 + char.codePointAt(0)) >>> 0;
+  }
+  return LABEL_PALETTE[hash % LABEL_PALETTE.length];
+}
+
+function extractIssueFormSection(body, predicate) {
+  const matches = [...String(body || "").matchAll(/^###\s+(.+?)\s*$/gm)];
+  for (const [index, match] of matches.entries()) {
+    const heading = match[1].trim();
+    if (!predicate(heading)) continue;
+
+    const start = match.index + match[0].length;
+    const end = matches[index + 1]?.index ?? body.length;
+    return body.slice(start, end).trim();
+  }
+
+  return "";
+}
+
+function extractDatabaseField(body) {
+  return extractIssueFormSection(body, (heading) => (
+    heading.includes("数据库类型") ||
+    heading.toLowerCase().includes("database type") ||
+    /^database$/i.test(heading)
+  ));
+}
+
+function extractPriorityField(body) {
+  return extractIssueFormSection(body, (heading) => (
+    heading.includes("优先级") ||
+    heading.toLowerCase().includes("priority")
+  ));
+}
+
+function extractTitleSummaryField(body) {
+  const headingPredicates = [
+    (heading) => heading.includes("问题描述") || heading.toLowerCase().includes("description"),
+    (heading) => heading.includes("当前痛点") || heading.toLowerCase().includes("problem"),
+    (heading) => heading.includes("期望方案") || heading.toLowerCase().includes("proposal"),
+    (heading) => heading === "描述" || heading.toLowerCase() === "description",
+  ];
+
+  for (const predicate of headingPredicates) {
+    const section = extractIssueFormSection(body, predicate);
+    if (section) return section;
+  }
+
+  return "";
+}
+
+function matchPriorityLabel(value) {
+  const match = String(value || "").normalize("NFKC").match(/\bP([0-3])\b/i);
+  return match ? `P${match[1]}` : null;
+}
+
+function genericIssueTitlePrefix(title) {
+  const normalized = String(title || "").normalize("NFKC").trim().replace(/\s+/g, " ");
+  const bracketMatch = normalized.match(/^([\[【][^\]】]*(?:bug|feature|feat|compatibility|question)[^\]】]*[\]】])$/i);
+  if (bracketMatch) return bracketMatch[1];
+
+  const bareMatch = normalized.match(/^(bug|feature|feat|compatibility|question):?$/i);
+  if (!bareMatch) return null;
+
+  const normalizedPrefix = bareMatch[1].toLowerCase() === "feat" ? "Feat" : (
+    bareMatch[1].charAt(0).toUpperCase() + bareMatch[1].slice(1).toLowerCase()
+  );
+  return `[${normalizedPrefix}]`;
+}
+
+function cleanTitleSummaryLine(line) {
+  return String(line || "")
+    .replace(/<img\b[^>]*>/gi, "")
+    .replace(/<[^>]+>/g, "")
+    .replace(/^>\s*/, "")
+    .replace(/^[-*]\s+/, "")
+    .replace(/^\d+[.)、]\s*/, "")
+    .replace(/!\[[^\]]*?\]\([^)]*?\)/g, "")
+    .replace(/\[[^\]]*?\]\([^)]*?\)/g, "")
+    .replace(/[`*_~]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function isSkippableTitleSummaryLine(line) {
+  return (
+    /^DBX debug log$/i.test(line) ||
+    /^(Exported|User agent|Platform|Timezone):/i.test(line) ||
+    /^(Native|Tauri) log dir:/i.test(line) ||
+    /^=+.*logs?.*=+$/i.test(line) ||
+    /^\[\d{4}-\d{2}-\d{2}(?:T|\])/.test(line) ||
+    /^\[(DEBUG|INFO|WARN|ERROR|LOG|STARTUP)\]/i.test(line)
+  );
+}
+
+function firstSentence(value) {
+  const withoutCodeBlocks = String(value || "").replace(/```[\s\S]*?```/g, "\n");
+  const lines = withoutCodeBlocks
+    .split(/\r?\n/)
+    .map(cleanTitleSummaryLine)
+    .filter((line) => !isSkippableTitleSummaryLine(line))
+    .filter((line) => /[\p{L}\p{N}\u3400-\u9fff]/u.test(line));
+
+  for (const line of lines) {
+    const sentenceMatch = line.match(/^(.{4,120}?[。！？!?]|.{12,120}?\.(?=\s|$))/u);
+    const sentence = (sentenceMatch ? sentenceMatch[1] : line)
+      .replace(/[。！？!?.]+$/u, "")
+      .trim();
+    if (sentence.length >= 4) {
+      return sentence.length > 90 ? `${sentence.slice(0, 89)}…` : sentence;
+    }
+  }
+
+  return "";
+}
+
+function inferIssueTitle(title, body) {
+  const prefix = genericIssueTitlePrefix(title);
+  if (!prefix) return null;
+
+  const summary = firstSentence(extractTitleSummaryField(body));
+  if (!summary) return null;
+
+  return `${prefix} ${summary}`;
+}
+
+function normalizeText(value) {
+  return String(value || "")
+    .normalize("NFKC")
+    .toLowerCase()
+    .replace(/[·，。；：、]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function containsCjk(value) {
+  return /[\u3400-\u9fff]/u.test(value);
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function compactAscii(value) {
+  return normalizeText(value).replace(/[^a-z0-9]/g, "");
+}
+
+function levenshteinDistance(left, right) {
+  if (left === right) return 0;
+  if (!left) return right.length;
+  if (!right) return left.length;
+
+  let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+  for (let leftIndex = 0; leftIndex < left.length; leftIndex += 1) {
+    const current = [leftIndex + 1];
+    for (let rightIndex = 0; rightIndex < right.length; rightIndex += 1) {
+      const substitutionCost = left[leftIndex] === right[rightIndex] ? 0 : 1;
+      current[rightIndex + 1] = Math.min(
+        current[rightIndex] + 1,
+        previous[rightIndex + 1] + 1,
+        previous[rightIndex] + substitutionCost,
+      );
+    }
+    previous = current;
+  }
+
+  return previous[right.length];
+}
+
+function fuzzyThreshold(length) {
+  if (length < 6) return 0;
+  if (length <= 8) return 1;
+  return 2;
+}
+
+function candidateTokens(text) {
+  const normalized = normalizeText(text);
+  const tokens = new Set();
+
+  for (const match of normalized.matchAll(/[a-z][a-z0-9._-]*/g)) {
+    const compact = compactAscii(match[0]);
+    if (!compact) continue;
+
+    tokens.add(compact);
+
+    // User reports often write database names directly followed by versions,
+    // for example mysql5.7, Oracle19c, or postgresql18.
+    const withoutVersion = compact.replace(/(?:v?\d[\da-z.]*)$/i, "");
+    if (withoutVersion && withoutVersion !== compact) tokens.add(withoutVersion);
+  }
+
+  return [...tokens].filter((token) => token.length >= 5);
+}
+
+function fuzzyAliasMatches(text, alias) {
+  const normalizedAlias = normalizeText(alias);
+  if (containsCjk(normalizedAlias)) return false;
+  if (globallyAmbiguousAliases.has(normalizedAlias)) return false;
+
+  const compactAlias = compactAscii(normalizedAlias);
+  const threshold = fuzzyThreshold(compactAlias.length);
+  if (!threshold) return false;
+
+  return candidateTokens(text).some((token) => {
+    if (token !== compactAlias && exactAsciiAliases.has(token)) return false;
+    if (Math.abs(token.length - compactAlias.length) > threshold) return false;
+    return levenshteinDistance(token, compactAlias) <= threshold;
+  });
+}
+
+function aliasMatches(text, alias) {
+  const normalizedText = normalizeText(text);
+  const normalizedAlias = normalizeText(alias);
+  if (!normalizedAlias) return false;
+
+  if (containsCjk(normalizedAlias)) {
+    return normalizedText.includes(normalizedAlias);
+  }
+
+  const flexibleAlias = normalizedAlias
+    .split(/[\s._/-]+/)
+    .filter(Boolean)
+    .map(escapeRegExp)
+    .join("[\\s._/-]*");
+  const trailingBoundary = /[0-9]$/.test(normalizedAlias)
+    ? "(?:[^a-z0-9]|$)"
+    : "(?:[^a-z0-9]|$|(?=v?\\d))";
+  const pattern = new RegExp(`(^|[^a-z0-9])${flexibleAlias}${trailingBoundary}`, "i");
+  return pattern.test(normalizedText);
+}
+
+function isGenericDatabaseValue(value) {
+  const normalized = normalizeText(value);
+  const parts = normalized
+    .split(/[,\n/|;，、]+/)
+    .map((part) => part.trim())
+    .filter(Boolean);
+
+  return (
+    parts.length > 0 &&
+    parts.every((part) => genericDatabaseValues.some((generic) => aliasMatches(part, generic)))
+  );
+}
+
+function matchDrivers(text, { allowAmbiguous }) {
+  const matches = [];
+
+  for (const driver of drivers) {
+    const matchedAlias = driver.aliases.find((alias) => {
+      const normalizedAlias = normalizeText(alias);
+      if (!allowAmbiguous && globallyAmbiguousAliases.has(normalizedAlias)) return false;
+      return aliasMatches(text, alias) || fuzzyAliasMatches(text, alias);
+    });
+
+    if (matchedAlias) {
+      matches.push({ ...driver, matchedAlias });
+    }
+  }
+
+  return matches;
+}
+
+function uniqueByDbType(matches) {
+  const seen = new Set();
+  return matches.filter((match) => {
+    if (seen.has(match.dbType)) return false;
+    seen.add(match.dbType);
+    return true;
+  });
+}
+
+async function githubRequest(method, path, body) {
+  const token = process.env.GITHUB_TOKEN;
+  const repository = process.env.GITHUB_REPOSITORY;
+  if (!token) throw new Error("GITHUB_TOKEN is required");
+  if (!repository) throw new Error("GITHUB_REPOSITORY is required");
+
+  const response = await fetch(`https://api.github.com/repos/${repository}${path}`, {
+    method,
+    headers: {
+      Accept: "application/vnd.github+json",
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "X-GitHub-Api-Version": API_VERSION,
+    },
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  const text = await response.text();
+  const payload = text ? JSON.parse(text) : null;
+  if (!response.ok) {
+    const message = payload?.message || response.statusText;
+    const error = new Error(`${method} ${path} failed: ${response.status} ${message}`);
+    error.status = response.status;
+    error.payload = payload;
+    throw error;
+  }
+  return payload;
+}
+
+async function ensureLabel(name, description, color) {
+  try {
+    const dbType = name.startsWith(LABEL_PREFIX) ? name.slice(LABEL_PREFIX.length) : name;
+    await githubRequest("POST", "/labels", { name, color: color || stablePaletteColor(dbType), description });
+    console.log(`Created label ${name}`);
+  } catch (error) {
+    // GitHub returns 422 when the label already exists; that is the common path
+    // after the first issue for a database type has been triaged.
+    if (error.status === 422) {
+      console.log(`Label ${name} already exists`);
+      return;
+    }
+    throw error;
+  }
+}
+
+async function addLabels(issueNumber, names) {
+  await githubRequest("POST", `/issues/${issueNumber}/labels`, { labels: names });
+}
+
+async function removeLabel(issueNumber, name) {
+  try {
+    await githubRequest("DELETE", `/issues/${issueNumber}/labels/${encodeURIComponent(name)}`);
+    console.log(`Removed stale label ${name}`);
+  } catch (error) {
+    if (error.status === 404) return;
+    throw error;
+  }
+}
+
+async function updateIssueTitle(issueNumber, title) {
+  await githubRequest("PATCH", `/issues/${issueNumber}`, { title });
+}
+
+const issue = loadIssue();
+if (issue.pull_request) {
+  console.log("Skipping pull request event");
+  process.exit(0);
+}
+
+if (!issue.number) {
+  throw new Error("Issue number is required");
+}
+
+const databaseField = extractDatabaseField(issue.body || "");
+const hasDatabaseField = databaseField.length > 0;
+const fieldIsGeneric = hasDatabaseField && isGenericDatabaseValue(databaseField);
+// Free-form bodies often mention comparison databases or examples; the title
+// and issue-form database field are the reliable labeling sources.
+const sourceText = hasDatabaseField ? databaseField : issue.title || "";
+const matchedDrivers = isGenericDatabaseValue(sourceText)
+  ? []
+  : uniqueByDbType(matchDrivers(sourceText, { allowAmbiguous: hasDatabaseField }));
+const titleMatchedDrivers = uniqueByDbType(matchDrivers(issue.title || "", { allowAmbiguous: false }));
+if (hasDatabaseField && titleMatchedDrivers.length > 0) {
+  matchedDrivers.push(...titleMatchedDrivers);
+}
+if (hasDatabaseField && matchedDrivers.length === 0 && !fieldIsGeneric) {
+  // Some issue forms contain only a version in the database field and put the
+  // actual database name in the title; keep that fallback conservative.
+  matchedDrivers.push(
+    ...uniqueByDbType(matchDrivers(`${issue.title || ""}\n${databaseField}`, { allowAmbiguous: false })),
+  );
+}
+const uniqueMatchedDrivers = uniqueByDbType(matchedDrivers);
+const targetLabels = uniqueMatchedDrivers.map((driver) => `${LABEL_PREFIX}${driver.dbType}`);
+const targetLabelColors = Object.fromEntries(
+  uniqueMatchedDrivers.map((driver) => [`${LABEL_PREFIX}${driver.dbType}`, stablePaletteColor(driver.dbType)]),
+);
+const priorityField = extractPriorityField(issue.body || "");
+const targetPriorityValue = matchPriorityLabel(priorityField);
+const targetPriorityLabel = targetPriorityValue ? `${USER_PRIORITY_PREFIX}${targetPriorityValue}` : null;
+if (targetPriorityValue) {
+  targetLabelColors[targetPriorityLabel] = USER_PRIORITY_LABELS[targetPriorityValue].color;
+}
+const existingLabels = labelNames(issue.labels);
+const titleToUpdate = inferIssueTitle(issue.title || "", issue.body || "");
+const existingDatabaseLabels = existingLabels.filter((name) => name.startsWith(LABEL_PREFIX));
+const staleDatabaseLabels = hasDatabaseField
+  ? existingDatabaseLabels.filter((name) => !targetLabels.includes(name))
+  : [];
+const existingPriorityLabels = existingLabels.filter((name) => name.startsWith(USER_PRIORITY_PREFIX));
+const stalePriorityLabels = targetPriorityLabel
+  ? existingPriorityLabels.filter((name) => name !== targetPriorityLabel)
+  : [];
+const labelsToAdd = [...targetLabels, targetPriorityLabel].filter(Boolean).filter((name) => !existingLabels.includes(name));
+const labelSpecs = [
+  ...uniqueMatchedDrivers.map((driver) => ({
+    name: `${LABEL_PREFIX}${driver.dbType}`,
+    description: `Database: ${driver.label}`,
+    color: stablePaletteColor(driver.dbType),
+  })),
+  ...(targetPriorityValue
+    ? [{ name: targetPriorityLabel, ...USER_PRIORITY_LABELS[targetPriorityValue] }]
+    : []),
+];
+
+console.log(
+  JSON.stringify(
+    {
+      issue: issue.number,
+      databaseField: hasDatabaseField ? databaseField : null,
+      titleMatched: titleMatchedDrivers.map(({ dbType, label, matchedAlias }) => ({ dbType, label, matchedAlias })),
+      matched: uniqueMatchedDrivers.map(({ dbType, label, matchedAlias }) => ({ dbType, label, matchedAlias })),
+      priorityField: priorityField || null,
+      priorityLabel: targetPriorityLabel,
+      priorityValue: targetPriorityValue,
+      titleToUpdate,
+      labelsToAdd,
+      targetLabelColors,
+      staleDatabaseLabels,
+      stalePriorityLabels,
+    },
+    null,
+    2,
+  ),
+);
+
+if (dryRun) {
+  console.log("Dry run enabled; no GitHub API calls were made");
+  process.exit(0);
+}
+
+for (const labelSpec of labelSpecs) {
+  await ensureLabel(labelSpec.name, labelSpec.description, labelSpec.color);
+}
+
+if (labelsToAdd.length > 0) {
+  await addLabels(issue.number, labelsToAdd);
+  console.log(`Added labels: ${labelsToAdd.join(", ")}`);
+} else {
+  console.log("No database labels to add");
+}
+
+for (const label of staleDatabaseLabels) {
+  await removeLabel(issue.number, label);
+}
+
+for (const label of stalePriorityLabels) {
+  await removeLabel(issue.number, label);
+}
+
+if (titleToUpdate) {
+  await updateIssueTitle(issue.number, titleToUpdate);
+  console.log(`Updated title: ${titleToUpdate}`);
+}
diff --git a/.github/scripts/sync-atomgit-release.mjs b/.github/scripts/sync-atomgit-release.mjs
new file mode 100644
index 0000000..e7be13e
--- /dev/null
+++ b/.github/scripts/sync-atomgit-release.mjs
@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+
+import { basename, join } from "node:path";
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { spawn } from "node:child_process";
+
+const DEFAULT_API_BASE = "https://api.atomgit.com/api/v5";
+const DEFAULT_REPOSITORY = "t8y2/dbx";
+const DEFAULT_CONCURRENCY = 3;
+
+function parseArgs(argv) {
+  const args = {
+    apiBase: process.env.ATOMGIT_API_BASE || DEFAULT_API_BASE,
+    repository: process.env.ATOMGIT_REPOSITORY || DEFAULT_REPOSITORY,
+    token: process.env.ATOMGIT_TOKEN || "",
+    githubReleasePath: "",
+    assetsDir: "",
+    skipExistingAssets: true,
+    concurrency: Number.parseInt(process.env.ATOMGIT_UPLOAD_CONCURRENCY || `${DEFAULT_CONCURRENCY}`, 10),
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--github-release") {
+      args.githubReleasePath = argv[++i];
+    } else if (arg === "--assets-dir") {
+      args.assetsDir = argv[++i];
+    } else if (arg === "--repository") {
+      args.repository = argv[++i];
+    } else if (arg === "--api-base") {
+      args.apiBase = argv[++i];
+    } else if (arg === "--replace-assets") {
+      args.skipExistingAssets = false;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  if (!args.token) {
+    throw new Error("ATOMGIT_TOKEN is required.");
+  }
+  if (!args.githubReleasePath || !args.assetsDir) {
+    throw new Error("Usage: sync-atomgit-release.mjs --github-release <release.json> --assets-dir <dir>");
+  }
+  if (!args.repository.includes("/")) {
+    throw new Error(`Invalid AtomGit repository: ${args.repository}`);
+  }
+  if (!Number.isInteger(args.concurrency) || args.concurrency < 1) {
+    throw new Error("ATOMGIT_UPLOAD_CONCURRENCY must be a positive integer.");
+  }
+  return args;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const [owner, repo] = args.repository.split("/", 2);
+  const release = JSON.parse(readFileSync(args.githubReleasePath, "utf8"));
+  const tag = release.tagName || release.tag_name;
+  if (!tag) {
+    throw new Error("GitHub release JSON is missing tagName.");
+  }
+
+  const client = new AtomGitClient({ apiBase: args.apiBase, token: args.token, owner, repo });
+  const atomRelease = await ensureRelease(client, release);
+  const existingAssets = atomGitAssetNames(atomRelease);
+  const assets = localAssets(args.assetsDir);
+  if (assets.length === 0) {
+    console.log("No release assets found to sync.");
+    return;
+  }
+
+  const pendingAssets = assets.filter((assetPath) => {
+    const name = basename(assetPath);
+    if (args.skipExistingAssets && existingAssets.has(name)) {
+      console.log(`Skipping existing AtomGit asset: ${name}`);
+      return false;
+    }
+    return true;
+  });
+
+  console.log(`Uploading ${pendingAssets.length} asset(s) with concurrency ${args.concurrency}.`);
+  await mapWithConcurrency(pendingAssets, args.concurrency, (assetPath) => uploadAsset(client, tag, assetPath));
+}
+
+async function ensureRelease(client, githubRelease) {
+  const tag = githubRelease.tagName || githubRelease.tag_name;
+  const payload = {
+    tag_name: tag,
+    name: githubRelease.name || tag,
+    body: githubRelease.body || "",
+    target_commitish: githubRelease.targetCommitish || githubRelease.target_commitish || "",
+    prerelease: Boolean(githubRelease.isPrerelease || githubRelease.prerelease),
+  };
+
+  const existing = await client.getRelease(tag);
+  if (existing) {
+    console.log(`Updating existing AtomGit release: ${tag}`);
+    return client.updateRelease(tag, payload);
+  }
+
+  console.log(`Creating AtomGit release: ${tag}`);
+  return client.createRelease(payload);
+}
+
+async function uploadAsset(client, tag, filePath) {
+  const name = basename(filePath);
+  const size = statSync(filePath).size;
+  console.log(`Uploading ${name} (${size} bytes)`);
+  const uploadTarget = await client.getUploadTarget(tag, name);
+  const contentType = contentTypeFor(name);
+  const uploadHeaders = uploadTarget.headers.length > 0
+    ? uploadTarget.headers
+    : [
+        ["Authorization", `Bearer ${client.token}`],
+        ["X-Api-Version", "2023-02-21"],
+      ];
+  const contentTypeHeader = headerValue(uploadHeaders, "Content-Type") || contentType;
+  const curlHeaders = uploadHeaders
+    .filter(([key]) => key.toLowerCase() !== "content-type")
+    .flatMap(([key, value]) => ["--header", `${key}: ${value}`]);
+
+  // AtomGit returns a per-file upload URL plus required upload headers.
+  // Try raw PUT first and fall back to multipart POST for API-compatible deployments.
+  const putStatus = await runCurl([
+    "--fail-with-body",
+    "--location",
+    "--show-error",
+    "--retry",
+    "3",
+    "--retry-delay",
+    "5",
+    "--request",
+    "PUT",
+    ...curlHeaders,
+    "--header",
+    `Content-Type: ${contentTypeHeader}`,
+    "--upload-file",
+    filePath,
+    uploadTarget.url,
+  ]);
+  if (putStatus === 0) {
+    return;
+  }
+
+  console.warn(`PUT upload failed for ${name}; retrying as multipart POST.`);
+  const postStatus = await runCurl([
+    "--fail-with-body",
+    "--location",
+    "--show-error",
+    "--retry",
+    "3",
+    "--retry-delay",
+    "5",
+    "--request",
+    "POST",
+    ...curlHeaders,
+    "--form",
+    `file=@${filePath};filename=${name};type=${contentTypeHeader}`,
+    uploadTarget.url,
+  ]);
+  if (postStatus !== 0) {
+    throw new Error(`Failed to upload ${name} to AtomGit.`);
+  }
+}
+
+function runCurl(args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn("curl", args, { stdio: "inherit" });
+    child.once("error", reject);
+    child.once("close", (code) => resolve(code ?? 1));
+  });
+}
+
+async function mapWithConcurrency(items, concurrency, worker) {
+  let nextIndex = 0;
+  async function runWorker() {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      await worker(items[index]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, runWorker));
+}
+
+function localAssets(dir) {
+  return readdirSync(dir)
+    .map((name) => join(dir, name))
+    .filter((path) => statSync(path).isFile())
+    .sort((a, b) => statSync(a).size - statSync(b).size || basename(a).localeCompare(basename(b)));
+}
+
+function atomGitAssetNames(release) {
+  const names = new Set();
+  const groups = [
+    release?.assets,
+    release?.attach_files,
+    release?.attachFiles,
+    release?.files,
+    release?.attachments,
+  ];
+  for (const group of groups) {
+    if (!Array.isArray(group)) {
+      continue;
+    }
+    for (const item of group) {
+      const name = item?.name || item?.file_name || item?.filename || item?.title;
+      if (name) {
+        names.add(name);
+      }
+    }
+  }
+  return names;
+}
+
+function contentTypeFor(name) {
+  if (name.endsWith(".json")) return "application/json";
+  if (name.endsWith(".zip")) return "application/zip";
+  if (name.endsWith(".gz") || name.endsWith(".tgz")) return "application/gzip";
+  if (name.endsWith(".dmg")) return "application/x-apple-diskimage";
+  if (name.endsWith(".exe") || name.endsWith(".msi")) return "application/octet-stream";
+  if (name.endsWith(".deb")) return "application/vnd.debian.binary-package";
+  if (name.endsWith(".rpm")) return "application/x-rpm";
+  if (name.endsWith(".AppImage")) return "application/octet-stream";
+  return "application/octet-stream";
+}
+
+function headerValue(headers, name) {
+  const normalizedName = name.toLowerCase();
+  const entry = headers.find(([key]) => key.toLowerCase() === normalizedName);
+  return entry ? entry[1] : "";
+}
+
+class AtomGitClient {
+  constructor({ apiBase, token, owner, repo }) {
+    this.apiBase = apiBase.replace(/\/+$/, "");
+    this.token = token;
+    this.owner = owner;
+    this.repo = repo;
+  }
+
+  async getRelease(tag) {
+    const res = await this.request("GET", `/repos/${this.owner}/${this.repo}/releases/${encodeURIComponent(tag)}`, null, {
+      allow404: true,
+    });
+    if (res.status === 404) {
+      return null;
+    }
+    return parseJsonResponse(res);
+  }
+
+  async createRelease(payload) {
+    const res = await this.request("POST", `/repos/${this.owner}/${this.repo}/releases`, payload, {
+      acceptStatuses: [409, 422],
+    });
+    if (res.status === 409 || res.status === 422) {
+      return this.updateRelease(payload.tag_name, payload);
+    }
+    return parseJsonResponse(res);
+  }
+
+  async updateRelease(tag, payload) {
+    const res = await this.request("PATCH", `/repos/${this.owner}/${this.repo}/releases/${encodeURIComponent(tag)}`, payload);
+    return parseJsonResponse(res);
+  }
+
+  async getUploadTarget(tag, fileName) {
+    const params = new URLSearchParams({ file_name: fileName });
+    const res = await this.request("GET", `/repos/${this.owner}/${this.repo}/releases/${encodeURIComponent(tag)}/upload_url?${params}`);
+    const body = await parseJsonResponse(res);
+    if (body && typeof body === "object" && !Array.isArray(body)) {
+      console.log(`AtomGit upload_url response keys: ${Object.keys(body).sort().join(", ")}`);
+      if (body.headers && typeof body.headers === "object") {
+        console.log(`AtomGit upload header keys: ${Object.keys(body.headers).sort().join(", ")}`);
+      }
+    }
+    const uploadUrl = typeof body === "string" ? body : body.url || body.upload_url || body.uploadUrl;
+    if (!uploadUrl) {
+      throw new Error(`AtomGit upload_url response did not include an upload URL: ${JSON.stringify(body)}`);
+    }
+    console.log(`AtomGit upload target: ${sanitizeUrlForLog(uploadUrl)}`);
+    return {
+      url: uploadUrl,
+      headers: normalizeUploadHeaders(typeof body === "string" ? null : body.headers),
+    };
+  }
+
+  async request(method, path, body = null, requestOptions = {}) {
+    const headers = {
+      Accept: "application/json",
+      Authorization: `Bearer ${this.token}`,
+      "X-Api-Version": "2023-02-21",
+    };
+    const fetchOptions = { method, headers };
+    if (body) {
+      const cleanBody = Object.fromEntries(Object.entries(body).filter(([, value]) => value !== ""));
+      headers["Content-Type"] = "application/json";
+      fetchOptions.body = JSON.stringify(cleanBody);
+    }
+
+    const res = await fetch(`${this.apiBase}${path}`, fetchOptions);
+    const acceptedStatus = requestOptions.acceptStatuses?.includes(res.status);
+    if (!res.ok && !(requestOptions.allow404 && res.status === 404) && !acceptedStatus) {
+      const text = await res.text();
+      throw new Error(`AtomGit API ${method} ${path} failed with ${res.status}: ${text}`);
+    }
+    return res;
+  }
+}
+
+async function parseJsonResponse(res) {
+  const text = await res.text();
+  if (!text.trim()) {
+    return {};
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+function normalizeUploadHeaders(headers) {
+  if (!headers || typeof headers !== "object" || Array.isArray(headers)) {
+    return [];
+  }
+  return Object.entries(headers)
+    .filter(([key, value]) => key && value !== null && value !== undefined && value !== "")
+    .map(([key, value]) => [key, String(value)]);
+}
+
+function sanitizeUrlForLog(value) {
+  try {
+    const url = new URL(value);
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return "<invalid upload URL>";
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
diff --git a/.github/scripts/sync-changelog.mjs b/.github/scripts/sync-changelog.mjs
new file mode 100644
index 0000000..0676312
--- /dev/null
+++ b/.github/scripts/sync-changelog.mjs
@@ -0,0 +1,292 @@
+#!/usr/bin/env node
+
+import { createHash } from "node:crypto";
+import { writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const REPO = "t8y2/dbx";
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN || "";
+const DEEPSEEK_API_KEY = process.env.DEEPSEEK_API_KEY || "";
+const OUT_CN = "releases-cn.json";
+const OUT_EN = "releases-en.json";
+const LATEST_EN_OUT = "latest-en.json";
+const EN_CACHE_URL = process.env.CHANGELOG_EN_CACHE_URL || "https://dl.dbxio.com/changelog/releases-en.json";
+
+const SECTION_MAP = {
+  新功能: "added",
+  Added: "added",
+  改进: "improved",
+  Improved: "improved",
+  修复: "fixed",
+  Fixed: "fixed",
+  变更: "changed",
+  Changed: "changed",
+  移除: "removed",
+  Removed: "removed",
+};
+
+export async function fetchAllReleases() {
+  const releases = [];
+  let page = 1;
+  while (true) {
+    const res = await fetch(`https://api.github.com/repos/${REPO}/releases?per_page=100&page=${page}`, { headers: { Authorization: `token ${GITHUB_TOKEN}`, Accept: "application/vnd.github+json" } });
+    if (!res.ok) throw new Error(`GitHub API ${res.status}: ${await res.text()}`);
+    const data = await res.json();
+    if (data.length === 0) break;
+    releases.push(...data);
+    page++;
+  }
+  return releases;
+}
+
+export function stripDownloadSection(body) {
+  const markers = ["### 下载安装", "### Download", "### 系统要求", "### System Requirements"];
+  let idx = body.length;
+  for (const m of markers) {
+    const i = body.indexOf(m);
+    if (i !== -1 && i < idx) idx = i;
+  }
+  return body.slice(0, idx).trim();
+}
+
+// 剥离 release notes 里的 issue 引用 (closes #xxx)，保留贡献者署名 (contributed by @xxx)。
+// 同时处理纯 closes 括号和混在 contributed by 括号里的 closes 片段。
+function stripIssueRefs(text) {
+  return text
+    // 纯 closes 括号整体去掉，如 (closes #123) 或 (closes #123, closes #456)
+    .replace(/\s*\(closes #\d+(?:,\s*closes #\d+)*\)/g, "")
+    // closes 在前、contributed by 在后，如 (closes #88, contributed by @xxx) → (contributed by @xxx)
+    .replace(/\(closes #\d+,\s*/g, "(")
+    // contributed by 在前、closes 在后，如 (contributed by @xxx, closes #123) → (contributed by @xxx)
+    .replace(/,\s*closes #\d+/g, "");
+}
+
+// 对整份 releases JSON 统一剥离 closes # 引用。cache 复用的英文翻译来自 R2，
+// 可能是旧版脚本生成的（desc 仍含 closes #），在写文件前统一清理一次。
+function stripIssueRefsInReleases(json) {
+  for (const release of json.releases || []) {
+    for (const section of release.sections || []) {
+      for (const item of section.items || []) {
+        if (item.desc) item.desc = stripIssueRefs(item.desc);
+      }
+    }
+  }
+  return json;
+}
+
+export function parseBody(body) {
+  const cleaned = stripDownloadSection(body);
+  const sections = [];
+  let current = null;
+
+  for (const line of cleaned.split("\n")) {
+    const headerMatch = line.match(/^###\s+(.+)/);
+    if (headerMatch) {
+      const title = headerMatch[1].trim();
+      const type = SECTION_MAP[title] || "other";
+      current = { type, title, items: [] };
+      sections.push(current);
+      continue;
+    }
+
+    if (!current) continue;
+
+    const itemMatch = line.match(/^-\s+\*\*(.+?)\*\*\s*[—–-]\s*(.+)/);
+    if (itemMatch) {
+      current.items.push({ title: itemMatch[1].trim(), desc: stripIssueRefs(itemMatch[2].trim()) });
+      continue;
+    }
+
+    const plainMatch = line.match(/^-\s+(.+)/);
+    if (plainMatch) {
+      current.items.push({ title: plainMatch[1].trim(), desc: "" });
+    }
+  }
+
+  return sections.filter((s) => s.items.length > 0);
+}
+
+export function buildReleaseSourceHash(release) {
+  return createHash("sha256")
+    .update(
+      JSON.stringify({
+        tag: release.tag_name,
+        name: release.name || release.tag_name,
+        publishedAt: release.published_at || "",
+        body: release.body || "",
+      }),
+    )
+    .digest("hex");
+}
+
+export function buildReleasesJson(releases, now = new Date()) {
+  return {
+    updatedAt: now.toISOString(),
+    releases: releases
+      .filter((r) => !r.draft && !r.prerelease && !r.tag_name.startsWith("agents-"))
+      .sort((a, b) => new Date(b.published_at) - new Date(a.published_at))
+      .map((r) => ({
+        tag: r.tag_name,
+        name: r.name || r.tag_name,
+        date: r.published_at.slice(0, 10),
+        _sourceHash: buildReleaseSourceHash(r),
+        sections: parseBody(r.body || ""),
+      })),
+  };
+}
+
+function releaseToMarkdown(release) {
+  return release.sections
+    .map((s) => {
+      const items = s.items.map((i) => (i.desc ? `- **${i.title}** — ${i.desc}` : `- ${i.title}`)).join("\n");
+      return `### ${s.title}\n${items}`;
+    })
+    .join("\n\n");
+}
+
+// 给应用内更新提示用的英文 notes：只取最新一条版本（releases 已按 published_at 降序），
+// 转成 md。version 用 tag（如 v0.5.47），应用端 normalize_version 后与 latest.json 的 version 校验。
+function buildLatestEnNotes(enReleasesJson) {
+  const latest = enReleasesJson.releases?.[0];
+  if (!latest) return null;
+  return {
+    version: latest.tag,
+    notes: releaseToMarkdown(latest),
+  };
+}
+
+export async function fetchCachedEnglish({ cacheUrl = EN_CACHE_URL, fetchImpl = fetch } = {}) {
+  try {
+    const res = await fetchImpl(cacheUrl, { headers: { Accept: "application/json" } });
+    if (!res.ok) {
+      console.warn(`English changelog cache unavailable: ${res.status}`);
+      return null;
+    }
+    return await res.json();
+  } catch (err) {
+    console.warn(`English changelog cache unavailable: ${err.message}`);
+    return null;
+  }
+}
+
+export async function translateToEnglish(cnJson, { cachedEnJson = null, deepseekApiKey = DEEPSEEK_API_KEY, fetchImpl = fetch, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
+  const cachedByTag = new Map((cachedEnJson?.releases || []).map((release) => [release.tag, release]));
+  const enReleases = [];
+  let reusedCount = 0;
+  let translatedCount = 0;
+  let skippedCount = 0;
+
+  // 无 API key：仅复用 R2 上的英文缓存，未命中的条目回退中文以保证文件完整。
+  // 这样本地（无 key）只要 R2 缓存新鲜也能产出英文 CHANGELOG；CI 有 key 时走正常翻译流程。
+  if (!deepseekApiKey) {
+    console.warn("DEEPSEEK_API_KEY not set, falling back to cached English translations only");
+    for (const release of cnJson.releases) {
+      const cachedRelease = cachedByTag.get(release.tag);
+      if (cachedRelease?._sourceHash === release._sourceHash) {
+        enReleases.push({ ...cachedRelease, name: release.name, date: release.date, _sourceHash: release._sourceHash });
+        reusedCount++;
+      } else {
+        enReleases.push(release);
+        skippedCount++;
+      }
+    }
+    console.log(`English changelog cache reused ${reusedCount}, skipped ${skippedCount} (no API key)`);
+    return { updatedAt: cnJson.updatedAt, releases: enReleases };
+  }
+
+  for (const release of cnJson.releases) {
+    const cachedRelease = cachedByTag.get(release.tag);
+    if (cachedRelease?._sourceHash === release._sourceHash) {
+      enReleases.push({
+        ...cachedRelease,
+        name: release.name,
+        date: release.date,
+        _sourceHash: release._sourceHash,
+      });
+      reusedCount++;
+      continue;
+    }
+
+    const sectionsText = releaseToMarkdown(release);
+
+    if (!sectionsText.trim()) {
+      enReleases.push({ ...release, sections: [] });
+      continue;
+    }
+
+    const res = await fetchImpl("https://api.deepseek.com/chat/completions", {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${deepseekApiKey}` },
+      body: JSON.stringify({
+        model: "deepseek-chat",
+        messages: [
+          {
+            role: "system",
+            content:
+              "You are a technical translator. Translate the following Chinese software changelog to English. Keep the exact markdown format (### headers, - bullet points, **bold** titles, — dashes). Only translate, do not add or remove content. Keep technical terms, product names, and contributor names unchanged.",
+          },
+          { role: "user", content: sectionsText },
+        ],
+        temperature: 0.1,
+      }),
+    });
+
+    if (!res.ok) {
+      console.error(`DeepSeek API error for ${release.tag}: ${res.status}`);
+      enReleases.push(release);
+      continue;
+    }
+
+    const data = await res.json();
+    const translated = data.choices?.[0]?.message?.content || "";
+    const enSections = parseBody(translated);
+    enReleases.push({ ...release, sections: enSections.length > 0 ? enSections : release.sections });
+    translatedCount++;
+
+    await sleep(200);
+  }
+
+  console.log(`English changelog cache reused ${reusedCount} release(s), translated ${translatedCount} release(s)`);
+  return { updatedAt: cnJson.updatedAt, releases: enReleases };
+}
+
+async function main() {
+  console.log("Fetching releases from GitHub...");
+  const releases = await fetchAllReleases();
+  console.log(`Found ${releases.length} releases`);
+
+  const cnJson = buildReleasesJson(releases);
+  console.log(`Processed ${cnJson.releases.length} non-draft releases`);
+
+  writeFileSync(OUT_CN, JSON.stringify(cnJson, null, 2));
+  console.log(`Wrote ${OUT_CN}`);
+
+  console.log("Fetching cached English changelog...");
+  const cachedEnJson = await fetchCachedEnglish();
+
+  console.log("Translating to English...");
+  const enJson = await translateToEnglish(cnJson, { cachedEnJson });
+  if (enJson) {
+    // cache 复用的英文翻译可能来自旧版 R2 数据（desc 含 closes # 引用），统一剥离一次
+    stripIssueRefsInReleases(enJson);
+    writeFileSync(OUT_EN, JSON.stringify(enJson, null, 2));
+    console.log(`Wrote ${OUT_EN}`);
+
+    // 应用内更新提示用的英文 notes（单条最新版本）
+    const latestEn = buildLatestEnNotes(enJson);
+    if (latestEn) {
+      writeFileSync(LATEST_EN_OUT, JSON.stringify(latestEn, null, 2));
+      console.log(`Wrote ${LATEST_EN_OUT}`);
+    }
+  }
+
+  console.log("Done!");
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1])) {
+  main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+  });
+}
diff --git a/.github/scripts/sync-cnb-release.mjs b/.github/scripts/sync-cnb-release.mjs
new file mode 100644
index 0000000..52c355d
--- /dev/null
+++ b/.github/scripts/sync-cnb-release.mjs
@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+
+import { createReadStream, readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, join } from "node:path";
+
+const DEFAULT_API_BASE = "https://api.cnb.cool";
+const DEFAULT_REPOSITORY = "dbxio.com/dbx";
+const DEFAULT_CONCURRENCY = 3;
+const MAX_ATTEMPTS = 4;
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const githubRelease = JSON.parse(readFileSync(args.githubReleasePath, "utf8"));
+  const tag = githubRelease.tagName || githubRelease.tag_name;
+  if (!tag) throw new Error("GitHub release JSON is missing tagName.");
+
+  const client = new CnbClient(args);
+  const release = await client.ensureRelease(tag, githubRelease);
+  const existingAssets = new Set((release.assets || []).map((asset) => asset.name));
+  const assets = localAssets(args.assetsDir).filter((assetPath) => {
+    const name = basename(assetPath);
+    if (existingAssets.has(name)) {
+      console.log(`Skipping existing CNB asset: ${name}`);
+      return false;
+    }
+    return true;
+  });
+
+  console.log(`Uploading ${assets.length} CNB asset(s) with concurrency ${args.concurrency}.`);
+  await mapWithConcurrency(assets, args.concurrency, (assetPath) => uploadWithRetry(client, release.id, assetPath));
+}
+
+function parseArgs(argv) {
+  const args = {
+    apiBase: process.env.CNB_API_BASE || DEFAULT_API_BASE,
+    repository: process.env.CNB_REPOSITORY || DEFAULT_REPOSITORY,
+    token: process.env.CNB_TOKEN || "",
+    concurrency: Number.parseInt(process.env.CNB_UPLOAD_CONCURRENCY || `${DEFAULT_CONCURRENCY}`, 10),
+    githubReleasePath: "",
+    assetsDir: "",
+  };
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    if (arg === "--github-release") args.githubReleasePath = argv[++index];
+    else if (arg === "--assets-dir") args.assetsDir = argv[++index];
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+  if (!args.token) throw new Error("CNB_TOKEN is required.");
+  if (!args.githubReleasePath || !args.assetsDir) {
+    throw new Error("Usage: sync-cnb-release.mjs --github-release <release.json> --assets-dir <dir>");
+  }
+  if (!Number.isInteger(args.concurrency) || args.concurrency < 1) {
+    throw new Error("CNB_UPLOAD_CONCURRENCY must be a positive integer.");
+  }
+  return args;
+}
+
+async function uploadWithRetry(client, releaseId, filePath) {
+  const name = basename(filePath);
+  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+    try {
+      console.log(`Uploading ${name}, attempt ${attempt}/${MAX_ATTEMPTS}.`);
+      await client.uploadAsset(releaseId, filePath);
+      console.log(`Uploaded ${name}.`);
+      return;
+    } catch (error) {
+      if (attempt === MAX_ATTEMPTS) throw error;
+      const delayMs = 2 ** (attempt - 1) * 5000;
+      console.warn(`Upload failed for ${name}: ${error.message}; retrying in ${delayMs / 1000}s.`);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+}
+
+class CnbClient {
+  constructor({ apiBase, repository, token }) {
+    this.apiBase = apiBase.replace(/\/+$/, "");
+    this.repository = repository;
+    this.token = token;
+  }
+
+  async ensureRelease(tag, githubRelease) {
+    const payload = {
+      tag_name: tag,
+      name: githubRelease.name || tag,
+      body: githubRelease.body || "",
+      prerelease: Boolean(githubRelease.isPrerelease || githubRelease.prerelease),
+      target_commitish: githubRelease.targetCommitish || githubRelease.target_commitish || "",
+    };
+    const existing = await this.request("GET", `/${this.repository}/-/releases/tags/${encodeURIComponent(tag)}`, null, true);
+    if (!existing) return this.request("POST", `/${this.repository}/-/releases`, payload);
+
+    // Keep release metadata aligned while preserving the existing asset list used for resumable uploads.
+    await this.request("PATCH", `/${this.repository}/-/releases/${existing.id}`, {
+      name: payload.name,
+      body: payload.body,
+    });
+    return existing;
+  }
+
+  async uploadAsset(releaseId, filePath) {
+    const size = statSync(filePath).size;
+    const target = await this.request("POST", `/${this.repository}/-/releases/${releaseId}/asset-upload-url`, {
+      asset_name: basename(filePath),
+      size,
+      overwrite: false,
+    });
+    const uploadResponse = await fetch(target.upload_url, {
+      method: "PUT",
+      headers: { "Content-Type": "application/octet-stream", "Content-Length": `${size}` },
+      body: createReadStream(filePath),
+      duplex: "half",
+    });
+    if (!uploadResponse.ok) {
+      throw new Error(`CNB object upload failed with ${uploadResponse.status}: ${await uploadResponse.text()}`);
+    }
+    const verifyResponse = await fetch(decodeURIComponent(target.verify_url), {
+      method: "POST",
+      headers: this.headers(),
+    });
+    if (!verifyResponse.ok) {
+      throw new Error(`CNB upload confirmation failed with ${verifyResponse.status}: ${await verifyResponse.text()}`);
+    }
+  }
+
+  async request(method, path, body = null, allow404 = false) {
+    const response = await fetch(`${this.apiBase}${path}`, {
+      method,
+      headers: this.headers(body !== null),
+      body: body === null ? undefined : JSON.stringify(body),
+    });
+    if (allow404 && response.status === 404) return null;
+    if (!response.ok) throw new Error(`CNB API ${method} ${path} failed with ${response.status}: ${await response.text()}`);
+    return response.status === 204 ? null : response.json();
+  }
+
+  headers(json = false) {
+    return {
+      Accept: "application/vnd.cnb.api+json",
+      Authorization: `Bearer ${this.token}`,
+      ...(json ? { "Content-Type": "application/json" } : {}),
+    };
+  }
+}
+
+function localAssets(dir) {
+  return readdirSync(dir)
+    .map((name) => join(dir, name))
+    .filter((path) => statSync(path).isFile())
+    .sort((left, right) => statSync(right).size - statSync(left).size || basename(left).localeCompare(basename(right)));
+}
+
+async function mapWithConcurrency(items, concurrency, worker) {
+  let nextIndex = 0;
+  async function runWorker() {
+    while (nextIndex < items.length) {
+      const index = nextIndex++;
+      await worker(items[index]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, runWorker));
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});
diff --git a/.github/scripts/sync-project-triage.mjs b/.github/scripts/sync-project-triage.mjs
new file mode 100644
index 0000000..29ece77
--- /dev/null
+++ b/.github/scripts/sync-project-triage.mjs
@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+
+const DEFAULT_PROJECT_OWNER = "t8y2";
+const DEFAULT_PROJECT_NUMBER = 1;
+const DEFAULT_REPO = "t8y2/dbx";
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith("--")) continue;
+    const key = arg.slice(2);
+    const next = argv[i + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = "true";
+      continue;
+    }
+    args[key] = next;
+    i++;
+  }
+  return args;
+}
+
+const args = parseArgs(process.argv.slice(2));
+// PROJECT_TOKEN is a PAT with project scope; GH_TOKEN / GITHUB_TOKEN (auto-generated) handles repo access
+const projectToken = process.env.PROJECT_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN || "";
+const repoTokens = [process.env.GH_TOKEN, process.env.GITHUB_TOKEN, process.env.PROJECT_TOKEN].filter(Boolean);
+const repoToken = repoTokens[0] || "";
+const projectOwner = args["project-owner"] || process.env.PROJECT_OWNER || DEFAULT_PROJECT_OWNER;
+const projectNumber = Number(args["project-number"] || process.env.PROJECT_NUMBER || DEFAULT_PROJECT_NUMBER);
+const repo = args.repo || process.env.GITHUB_REPOSITORY || DEFAULT_REPO;
+const [repoOwner, repoName] = repo.split("/");
+const issueNumber = args["issue-number"] ? Number(args["issue-number"]) : null;
+const mode = args.backfill === "true" ? "backfill" : "issue";
+const eventAction = args["event-action"] || process.env.ISSUE_EVENT_ACTION || "";
+
+if (!projectToken) {
+  throw new Error("PROJECT_TOKEN, GH_TOKEN, or GITHUB_TOKEN is required");
+}
+if (!repoToken) {
+  throw new Error("GH_TOKEN or GITHUB_TOKEN is required for repository access");
+}
+
+if (!repoOwner || !repoName) {
+  throw new Error(`Invalid repo: ${repo}`);
+}
+
+if (mode === "issue" && !issueNumber) {
+  throw new Error("--issue-number is required unless --backfill true is set");
+}
+
+function gqlString(value) {
+  return JSON.stringify(value);
+}
+
+function gqlNumber(value) {
+  return Number(value);
+}
+
+function gqlNullableString(value) {
+  return value == null ? "null" : JSON.stringify(value);
+}
+
+async function graphql(query, token) {
+  const t = token || repoTokens[0];
+  const resp = await fetch("https://api.github.com/graphql", {
+    method: "POST",
+    headers: {
+      Authorization: `bearer ${t}`,
+      "Content-Type": "application/json",
+      "User-Agent": "dbx-project-triage/1.0",
+    },
+    body: JSON.stringify({ query }),
+  });
+
+  const payload = await resp.json();
+  if (payload.errors) {
+    throw new Error(`GraphQL request failed: ${JSON.stringify(payload.errors)}`);
+  }
+  if (!resp.ok) {
+    throw new Error(`GraphQL request failed: HTTP ${resp.status} ${resp.statusText}`);
+  }
+  return payload.data;
+}
+
+function triageName(issue) {
+  const labels = new Set(issue.labels.nodes.map((label) => label.name));
+  if (labels.has("question")) return "Needs Info";
+  if (issue.assignees.nodes.length > 0) return "Ready";
+  return "Inbox";
+}
+
+function singleSelectOptionsByName(field) {
+  return Object.fromEntries((field?.options || []).map((option) => [option.name, option.id]));
+}
+
+function singleSelectOptionId(options, name) {
+  const exact = options[name];
+  if (exact) return exact;
+  const target = name.toLowerCase();
+  const entry = Object.entries(options).find(([optionName]) => optionName.toLowerCase() === target);
+  return entry?.[1];
+}
+
+async function getProjectConfig() {
+  const query = `
+    query {
+      user(login: ${gqlString(projectOwner)}) {
+        projectV2(number: ${gqlNumber(projectNumber)}) {
+          id
+          title
+          fields(first: 50) {
+            nodes {
+              ... on ProjectV2Field {
+                id
+                name
+                dataType
+              }
+              ... on ProjectV2SingleSelectField {
+                id
+                name
+                options {
+                  id
+                  name
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  `;
+
+  const data = await graphql(query, projectToken);
+  const project = data.user?.projectV2;
+  if (!project) {
+    throw new Error(`Project ${projectOwner}#${projectNumber} not found`);
+  }
+
+  const triageField = project.fields.nodes.find((field) => field.name === "Triage");
+  if (!triageField) {
+    throw new Error(`Project ${project.title} is missing a Triage field`);
+  }
+  const statusField = project.fields.nodes.find((field) => field.name === "Status");
+
+  return {
+    id: project.id,
+    title: project.title,
+    triageFieldId: triageField.id,
+    triageOptions: singleSelectOptionsByName(triageField),
+    statusFieldId: statusField?.id || "",
+    statusOptions: singleSelectOptionsByName(statusField),
+  };
+}
+
+async function fetchIssue(number) {
+  const query = `
+    query {
+      repository(owner: ${gqlString(repoOwner)}, name: ${gqlString(repoName)}) {
+        issue(number: ${gqlNumber(number)}) {
+          id
+          number
+          title
+          url
+          state
+          assignees(first: 20) {
+            nodes {
+              login
+            }
+          }
+          labels(first: 50) {
+            nodes {
+              name
+            }
+          }
+          projectItems(first: 50) {
+            nodes {
+              id
+              project {
+                id
+                number
+                title
+                owner {
+                  __typename
+                  ... on User {
+                    login
+                  }
+                  ... on Organization {
+                    login
+                  }
+                }
+              }
+              fieldValueByName(name: "Triage") {
+                ... on ProjectV2ItemFieldSingleSelectValue {
+                  name
+                  optionId
+                }
+              }
+              statusValue: fieldValueByName(name: "Status") {
+                ... on ProjectV2ItemFieldSingleSelectValue {
+                  name
+                  optionId
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  `;
+
+  const data = await graphql(query, repoToken);
+  const issue = data.repository?.issue;
+  if (!issue) {
+    throw new Error(`Issue #${number} not found in ${repo}`);
+  }
+  return issue;
+}
+
+async function addItemToProject(projectId, contentId) {
+  const mutation = `
+    mutation {
+      addProjectV2ItemById(input: { projectId: ${gqlString(projectId)}, contentId: ${gqlString(contentId)} }) {
+        item {
+          id
+        }
+      }
+    }
+  `;
+
+  const data = await graphql(mutation, projectToken);
+
+  return data.addProjectV2ItemById.item.id;
+}
+
+async function updateTriage({ projectId, itemId, fieldId, optionId }) {
+  const mutation = `
+    mutation {
+      updateProjectV2ItemFieldValue(
+        input: {
+          projectId: ${gqlString(projectId)}
+          itemId: ${gqlString(itemId)}
+          fieldId: ${gqlString(fieldId)}
+          value: { singleSelectOptionId: ${gqlString(optionId)} }
+        }
+      ) {
+        projectV2Item {
+          id
+        }
+      }
+    }
+  `;
+
+  await graphql(mutation, projectToken);
+}
+
+async function updateSingleSelectField({ projectId, itemId, fieldId, optionId }) {
+  const mutation = `
+    mutation {
+      updateProjectV2ItemFieldValue(
+        input: {
+          projectId: ${gqlString(projectId)}
+          itemId: ${gqlString(itemId)}
+          fieldId: ${gqlString(fieldId)}
+          value: { singleSelectOptionId: ${gqlString(optionId)} }
+        }
+      ) {
+        projectV2Item {
+          id
+        }
+      }
+    }
+  `;
+
+  await graphql(mutation, projectToken);
+}
+
+async function syncIssue(projectConfig, number) {
+  const issue = await fetchIssue(number);
+  const targetTriage = triageName(issue);
+  const optionId = projectConfig.triageOptions[targetTriage];
+  if (!optionId) {
+    throw new Error(`Missing Triage option: ${targetTriage}`);
+  }
+
+  let projectItem = issue.projectItems.nodes.find(
+    (item) =>
+      item.project.id === projectConfig.id ||
+      (item.project.number === projectNumber && item.project.owner?.login === projectOwner),
+  );
+
+  if (!projectItem) {
+    // 只有被 assign 的 issue 才进入 project 看板；未分配的留在 issue 列表，
+    // 等 assigned 事件触发后再纳入。已在 project 里的 issue 仍随 label/assign 变化同步。
+    if (issue.assignees.nodes.length === 0) {
+      console.log(`Issue #${issue.number} has no assignee, skip adding to project`);
+      return;
+    }
+    const itemId = await addItemToProject(projectConfig.id, issue.id);
+    projectItem = {
+      id: itemId,
+      fieldValueByName: null,
+      statusValue: null,
+    };
+    console.log(`Added issue #${issue.number} to ${projectConfig.title}`);
+  }
+
+  const currentOptionId = projectItem.fieldValueByName?.optionId || "";
+  if (currentOptionId !== optionId) {
+    await updateTriage({
+      projectId: projectConfig.id,
+      itemId: projectItem.id,
+      fieldId: projectConfig.triageFieldId,
+      optionId,
+    });
+    console.log(`Set issue #${issue.number} triage to ${targetTriage}`);
+  } else {
+    console.log(`Issue #${issue.number} triage already ${targetTriage}`);
+  }
+
+  if (eventAction === "assigned" && issue.state === "OPEN") {
+    const targetStatus = "In Progress";
+    const statusOptionId = singleSelectOptionId(projectConfig.statusOptions, targetStatus);
+    if (!projectConfig.statusFieldId) {
+      throw new Error(`Project ${projectConfig.title} is missing a Status field`);
+    }
+    if (!statusOptionId) {
+      throw new Error(`Missing Status option: ${targetStatus}`);
+    }
+
+    const currentStatusOptionId = projectItem.statusValue?.optionId || "";
+    if (currentStatusOptionId !== statusOptionId) {
+      await updateSingleSelectField({
+        projectId: projectConfig.id,
+        itemId: projectItem.id,
+        fieldId: projectConfig.statusFieldId,
+        optionId: statusOptionId,
+      });
+      console.log(`Set issue #${issue.number} status to ${targetStatus}`);
+    } else {
+      console.log(`Issue #${issue.number} status already ${targetStatus}`);
+    }
+  }
+}
+
+async function fetchOpenIssueNumbers() {
+  const numbers = [];
+  let cursor = null;
+  while (true) {
+    const query = `
+      query {
+        repository(owner: ${gqlString(repoOwner)}, name: ${gqlString(repoName)}) {
+          issues(first: 100, after: ${gqlNullableString(cursor)}, states: OPEN, orderBy: { field: CREATED_AT, direction: ASC }) {
+            nodes {
+              number
+            }
+            pageInfo {
+              endCursor
+              hasNextPage
+            }
+          }
+        }
+      }
+    `;
+    const data = await graphql(query, repoToken);
+    const issues = data.repository?.issues;
+    if (!issues) break;
+    numbers.push(...issues.nodes.map((issue) => issue.number));
+    if (!issues.pageInfo.hasNextPage) break;
+    cursor = issues.pageInfo.endCursor;
+  }
+  return numbers;
+}
+
+async function main() {
+  const projectConfig = await getProjectConfig();
+  if (mode === "backfill") {
+    const numbers = await fetchOpenIssueNumbers();
+    console.log(`Backfilling ${numbers.length} open issues into ${projectConfig.title}`);
+    for (const number of numbers) {
+      await syncIssue(projectConfig, number);
+    }
+    return;
+  }
+
+  await syncIssue(projectConfig, issueNumber);
+}
+
+await main();
diff --git a/.github/workflows/1panel-appstore.yml b/.github/workflows/1panel-appstore.yml
new file mode 100644
index 0000000..213864e
--- /dev/null
+++ b/.github/workflows/1panel-appstore.yml
@@ -0,0 +1,59 @@
+name: 1Panel App Store
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version to submit (e.g. 0.5.3)"
+        required: true
+
+jobs:
+  submit:
+    runs-on: ubuntu-latest
+    env:
+      REPO_OWNER: t8y2
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Submit to 1Panel App Store
+        env:
+          TAP_GITHUB_TOKEN: ${{ secrets.TAP_GITHUB_TOKEN }}
+          GH_TOKEN: ${{ secrets.TAP_GITHUB_TOKEN }}
+        run: |
+          VERSION="${{ github.event.inputs.version }}"
+
+          git clone --depth 1 -b localApps \
+            "https://x-access-token:${TAP_GITHUB_TOKEN}@github.com/${REPO_OWNER}/appstore-1panel.git" \
+            appstore
+          cd appstore
+
+          APP_DIR="apps/dbx"
+          mkdir -p "${APP_DIR}/latest"
+
+          cp "${{ github.workspace }}/deploy/1panel/data.yml" "${APP_DIR}/data.yml"
+          cp "${{ github.workspace }}/deploy/1panel/README.md" "${APP_DIR}/README.md"
+          if [ -f "${{ github.workspace }}/deploy/1panel/logo.png" ]; then
+            cp "${{ github.workspace }}/deploy/1panel/logo.png" "${APP_DIR}/logo.png"
+          fi
+          cp -r "${{ github.workspace }}/deploy/1panel/latest/." "${APP_DIR}/latest/"
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+          BRANCH="app/dbx-${VERSION}"
+          git checkout -b "${BRANCH}"
+          git add "${APP_DIR}"
+
+          if git diff --cached --quiet; then
+            echo "1Panel app store is already up to date."
+          else
+            git commit -m "feat(dbx): release ${VERSION}"
+            git push origin "${BRANCH}"
+            gh pr create \
+              --repo "okxlin/appstore" \
+              --head "${REPO_OWNER}:${BRANCH}" \
+              --title "feat(dbx): release ${VERSION}" \
+              --body "Automated release of DBX v${VERSION}" \
+              --base localApps
+            echo "::notice::1Panel App Store PR created for ${VERSION}"
+          fi
diff --git a/.github/workflows/agents-release.yml b/.github/workflows/agents-release.yml
new file mode 100644
index 0000000..dfab86c
--- /dev/null
+++ b/.github/workflows/agents-release.yml
@@ -0,0 +1,620 @@
+name: Agents Release
+
+on:
+  push:
+    tags: ["agents-v*"]
+
+permissions:
+  contents: write
+
+concurrency:
+  group: dbx-release-main
+  cancel-in-progress: false
+
+jobs:
+  bump-versions:
+    runs-on: ubuntu-latest
+    outputs:
+      versions: ${{ steps.bump.outputs.versions }}
+      prev_versions: ${{ steps.bump.outputs.prev_versions }}
+      prev_tag: ${{ steps.bump.outputs.prev_tag }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Detect changes and bump versions
+        id: bump
+        shell: bash
+        run: |
+          LEGACY_REPO="https://github.com/t8y2/dbx-agents.git"
+          LEGACY_BASE_TAG="v0.2.33"
+          PREV_TAG=$(git tag --sort=-creatordate | grep '^agents-v' | sed -n '2p')
+          SKIP_BUMP=false
+          MIGRATED_FIRST_RELEASE=false
+          PREV_VERSIONS_FILE=""
+
+          if [ -z "$PREV_TAG" ]; then
+            echo "No previous agents-v tag found; treating this as the first migrated agents release"
+            PREV_TAG=$(git rev-list --max-parents=0 HEAD)
+
+            TMP_LEGACY="$(mktemp -d)"
+            git clone --depth 1 --branch "$LEGACY_BASE_TAG" "$LEGACY_REPO" "$TMP_LEGACY"
+            PREV_VERSIONS_FILE="$(mktemp)"
+            cp "$TMP_LEGACY/versions.json" "$PREV_VERSIONS_FILE"
+            rm -rf "$TMP_LEGACY"
+
+            SKIP_BUMP=true
+            MIGRATED_FIRST_RELEASE=true
+          fi
+          echo "Comparing $PREV_TAG..HEAD"
+
+          ARGS=(--prev-tag "$PREV_TAG" --migrated-first-release "$MIGRATED_FIRST_RELEASE" --write)
+          if [ "$SKIP_BUMP" = "true" ]; then
+            ARGS+=(--skip-bump)
+          fi
+          if [ -n "$PREV_VERSIONS_FILE" ]; then
+            ARGS+=(--prev-versions-file "$PREV_VERSIONS_FILE")
+          fi
+
+          node .github/scripts/bump-agent-versions.mjs "${ARGS[@]}"
+
+          if ! git diff --quiet -- agents/versions.json; then
+            git config user.name "github-actions[bot]"
+            git config user.email "github-actions[bot]@users.noreply.github.com"
+            git add agents/versions.json
+            git commit -m "chore: bump module versions [skip ci]"
+            git fetch origin main --no-tags
+            git rebase origin/main
+            git push origin HEAD:main
+          fi
+
+  build-agents:
+    needs: [bump-versions]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: |
+            8
+            21
+      - uses: gradle/actions/setup-gradle@v4
+      - run: ./gradlew shadowJar --parallel
+        working-directory: agents
+      - run: python3 scripts/validate_agent_jars.py
+        working-directory: agents
+      - uses: actions/upload-artifact@v4
+        with:
+          name: agent-jars
+          path: "agents/drivers/*/build/libs/dbx-agent-*.jar"
+
+  build-oracle-native:
+    needs: [bump-versions]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22.x"
+      - name: Test Oracle native agent
+        working-directory: agents/drivers/oracle-go
+        run: go test ./...
+      - name: Cross-compile Oracle native agent
+        shell: bash
+        run: |
+          mkdir -p release-native
+          cd agents/drivers/oracle-go
+          declare -A TARGETS=(
+            ["macos-aarch64"]="darwin/arm64"
+            ["macos-x64"]="darwin/amd64"
+            ["linux-aarch64"]="linux/arm64"
+            ["linux-x64"]="linux/amd64"
+            ["windows-aarch64"]="windows/arm64"
+            ["windows-x64"]="windows/amd64"
+          )
+          for platform in "${!TARGETS[@]}"; do
+            IFS=/ read -r goos goarch <<< "${TARGETS[$platform]}"
+            output="../../../release-native/dbx-agent-oracle-${platform}"
+            if [[ "$goos" == "windows" ]]; then
+              output="${output}.exe"
+            fi
+            echo "Building $platform ($goos/$goarch)"
+            CGO_ENABLED=0 GOOS="$goos" GOARCH="$goarch" go build -trimpath -ldflags="-s -w" -o "$output" .
+          done
+          ls -lh ../../../release-native
+      - uses: actions/upload-artifact@v4
+        with:
+          name: oracle-native
+          path: "release-native/dbx-agent-oracle-*"
+
+  build-xugu-native:
+    needs: [bump-versions]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: "1.22.x"
+      - name: Test Xugu native agent
+        working-directory: agents/drivers/xugu
+        run: GONOSUMDB=gitee.com/XuguDB/go-xugu-driver go test ./...
+      - name: Cross-compile Xugu native agent
+        shell: bash
+        run: |
+          mkdir -p release-native
+          cd agents/drivers/xugu
+          declare -A TARGETS=(
+            ["macos-aarch64"]="darwin/arm64"
+            ["macos-x64"]="darwin/amd64"
+            ["linux-aarch64"]="linux/arm64"
+            ["linux-x64"]="linux/amd64"
+            ["windows-aarch64"]="windows/arm64"
+            ["windows-x64"]="windows/amd64"
+          )
+          for platform in "${!TARGETS[@]}"; do
+            IFS=/ read -r goos goarch <<< "${TARGETS[$platform]}"
+            output="../../../release-native/dbx-agent-xugu-${platform}"
+            if [[ "$goos" == "windows" ]]; then
+              output="${output}.exe"
+            fi
+            echo "Building $platform ($goos/$goarch)"
+            GONOSUMDB=gitee.com/XuguDB/go-xugu-driver CGO_ENABLED=0 GOOS="$goos" GOARCH="$goarch" go build -trimpath -ldflags="-s -w" -o "$output" .
+          done
+          ls -lh ../../../release-native
+      - uses: actions/upload-artifact@v4
+        with:
+          name: xugu-native
+          path: "release-native/dbx-agent-xugu-*"
+
+  build-jre:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - jre-key: "21"
+            java-version: "21"
+            modules: "java.base,java.sql,java.sql.rowset,java.naming,java.management,java.desktop,java.security.jgss,java.security.sasl,jdk.security.auth,jdk.security.jgss,jdk.charsets,jdk.unsupported,java.scripting,java.compiler"
+    steps:
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: ${{ matrix.java-version }}
+      - name: Build JRE for all platforms
+        shell: bash
+        run: |
+          MODULES="${{ matrix.modules }}"
+          JLINK_OPTS="--strip-debug --no-header-files --no-man-pages --compress=zip-6"
+          JRE_KEY="${{ matrix.jre-key }}"
+
+          jlink --add-modules $MODULES $JLINK_OPTS --output dbx-jre
+          tar czf dbx-jre-${JRE_KEY}-linux-x64.tar.gz dbx-jre
+          rm -rf dbx-jre
+
+          ADOPTIUM="https://api.adoptium.net/v3/binary/latest/${{ matrix.java-version }}/ga"
+          declare -A PLATFORMS=(
+            ["macos-aarch64"]="mac/aarch64"
+            ["macos-x64"]="mac/x64"
+            ["linux-aarch64"]="linux/aarch64"
+            ["windows-x64"]="windows/x64"
+          )
+          for platform in "${!PLATFORMS[@]}"; do
+            os_arch="${PLATFORMS[$platform]}"
+            echo "=== Downloading JDK for $platform ($os_arch) ==="
+            if [[ "$platform" == windows-* ]]; then
+              curl -L -o jdk-$platform.zip "$ADOPTIUM/$os_arch/jdk/hotspot/normal/eclipse?project=jdk"
+              mkdir -p jdk-$platform
+              unzip -q jdk-$platform.zip -d jdk-$platform-tmp
+              mv jdk-$platform-tmp/*/* jdk-$platform/ || mv jdk-$platform-tmp/* jdk-$platform/
+              rm -rf jdk-$platform-tmp jdk-$platform.zip
+            else
+              curl -L -o jdk-$platform.tar.gz "$ADOPTIUM/$os_arch/jdk/hotspot/normal/eclipse?project=jdk"
+              mkdir -p jdk-$platform
+              tar xzf jdk-$platform.tar.gz -C jdk-$platform --strip-components=1
+              rm -f jdk-$platform.tar.gz
+            fi
+            JAVA_HOME_CROSS="jdk-$platform"
+            if [ -d "$JAVA_HOME_CROSS/Contents/Home/jmods" ]; then
+              JMODS="$JAVA_HOME_CROSS/Contents/Home/jmods"
+            else
+              JMODS="$JAVA_HOME_CROSS/jmods"
+            fi
+            LLVM_OBJCOPY=$(ls /usr/bin/llvm-objcopy-* 2>/dev/null | sort -V | tail -1)
+            if [ -z "$LLVM_OBJCOPY" ]; then LLVM_OBJCOPY=$(which llvm-objcopy 2>/dev/null || true); fi
+            CROSS_OPTS=""
+            if [ -n "$LLVM_OBJCOPY" ]; then
+              CROSS_OPTS="--strip-native-debug-symbols=objcopy=$LLVM_OBJCOPY"
+            else
+              CROSS_OPTS="--disable-plugin strip-native-debug-symbols"
+            fi
+            jlink --module-path "$JMODS" --add-modules $MODULES $JLINK_OPTS $CROSS_OPTS --output dbx-jre
+            tar czf dbx-jre-${JRE_KEY}-$platform.tar.gz dbx-jre
+            rm -rf dbx-jre jdk-$platform
+          done
+
+          ls -lh dbx-jre-*.tar.gz
+      - uses: actions/upload-artifact@v4
+        with:
+          name: jre-${{ matrix.jre-key }}
+          path: "dbx-jre-*.tar.gz"
+
+  release:
+    needs: [bump-versions, build-agents, build-oracle-native, build-xugu-native, build-jre]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+
+      - name: Flatten artifacts
+        run: |
+          mkdir -p release
+          find artifacts/agent-jars -name '*.jar' -exec cp {} release/ \;
+          find artifacts/oracle-native -type f -name 'dbx-agent-oracle-*' -exec cp {} release/ \;
+          find artifacts/xugu-native -type f -name 'dbx-agent-xugu-*' -exec cp {} release/ \;
+          find artifacts -name 'dbx-jre-*.tar.gz' -exec cp {} release/ \;
+          ls -lh release/
+
+      - name: Generate agent-registry.json
+        env:
+          MODULE_VERSIONS: ${{ needs.bump-versions.outputs.versions }}
+        run: |
+          TAG="${GITHUB_REF_NAME}"
+          REPO="${GITHUB_REPOSITORY}"
+          RELEASE_VERSION="${TAG#agents-v}"
+
+          get_module_version() {
+            local name="$1"
+            echo "$MODULE_VERSIONS" | python3 -c "import sys,json; print(json.load(sys.stdin).get('$name','${RELEASE_VERSION}'))"
+          }
+
+          generate_jar_entry() {
+            local name="$1" label="$2" file="$3" jre_key="$4" version="$5" external_driver="$6" native_json="$7"
+            local sha256=$(sha256sum "$file" | cut -d' ' -f1)
+            local size=$(stat -c%s "$file")
+            local url="https://github.com/${REPO}/releases/download/${TAG}/$(basename $file)"
+            local native_line=""
+            if [ -n "$native_json" ]; then
+              native_line="                \"native\": {${native_json}
+                },"
+            fi
+            cat <<ENTRY
+              "${name}": {
+                "version": "${version}",
+                "label": "${label}",
+                "min_app_version": "0.6.0",
+                "jre": "${jre_key}",
+                "external_driver_required": ${external_driver},
+                ${native_line}
+                "jar": { "url": "${url}", "sha256": "${sha256}", "size": ${size} }
+              }
+          ENTRY
+          }
+
+          generate_native_entry() {
+            local name="$1" label="$2" jre_key="$3" version="$4" native_json="$5"
+            local legacy_jar_url="https://github.com/${REPO}/releases/download/${TAG}/dbx-agent-${name}-legacy-placeholder.jar"
+            cat <<ENTRY
+              "${name}": {
+                "version": "${version}",
+                "label": "${label}",
+                "min_app_version": "0.6.0",
+                "jre": "${jre_key}",
+                "external_driver_required": false,
+                "native": {${native_json}
+                },
+                "jar": { "url": "${legacy_jar_url}", "sha256": "", "size": 0 }
+              }
+          ENTRY
+          }
+
+          native_only_label() {
+            local name="$1"
+            case "$name" in
+              xugu) echo "虚谷 XuguDB" ;;
+              *) echo "$name" ;;
+            esac
+          }
+
+          generate_jre_platforms() {
+            local jre_key="$1"
+            local PLATFORMS=""
+            for f in release/dbx-jre-${jre_key}-*.tar.gz; do
+              [ ! -f "$f" ] && continue
+              p=$(basename "$f" .tar.gz | sed "s/dbx-jre-${jre_key}-//")
+              sha256=$(sha256sum "$f" | cut -d' ' -f1)
+              size=$(stat -c%s "$f")
+              url="https://github.com/${REPO}/releases/download/${TAG}/$(basename $f)"
+              [ -n "$PLATFORMS" ] && PLATFORMS="${PLATFORMS},"$'\n'
+              PLATFORMS="${PLATFORMS}              \"${p}\": { \"url\": \"${url}\", \"sha256\": \"${sha256}\", \"size\": ${size} }"
+            done
+            echo "$PLATFORMS"
+          }
+
+          generate_native_platforms() {
+            local name="$1"
+            local PLATFORMS=""
+            for f in release/dbx-agent-${name}-*; do
+              [ ! -f "$f" ] && continue
+              [[ "$f" != *.jar ]] || continue
+              p=$(basename "$f" | sed "s/dbx-agent-${name}-//; s/\\.exe$//")
+              sha256=$(sha256sum "$f" | cut -d' ' -f1)
+              size=$(stat -c%s "$f")
+              url="https://github.com/${REPO}/releases/download/${TAG}/$(basename $f)"
+              [ -n "$PLATFORMS" ] && PLATFORMS="${PLATFORMS},"$'\n'
+              PLATFORMS="${PLATFORMS}"$'\n'"                  \"${p}\": { \"url\": \"${url}\", \"sha256\": \"${sha256}\", \"size\": ${size} }"
+            done
+            echo "$PLATFORMS"
+          }
+
+          detect_jre_key() {
+            local name="$1"
+            case "$name" in
+              *) echo "21" ;;
+            esac
+          }
+
+          JRE21_PLATFORMS=$(generate_jre_platforms "21")
+
+          DRIVERS=""
+          for f in release/dbx-agent-*.jar; do
+            name=$(basename "$f" .jar | sed 's/dbx-agent-//')
+            label=$(unzip -p "$f" META-INF/MANIFEST.MF | awk -F': ' 'BEGIN{IGNORECASE=1} /^Agent-Label:/ {sub(/\r$/, "", $2); print $2; exit}' || echo "$name")
+            [ -z "$label" ] && label="$name"
+            external_driver=$(unzip -p "$f" META-INF/MANIFEST.MF | awk -F': ' 'BEGIN{IGNORECASE=1} /^Agent-External-Driver:/ {sub(/\r$/, "", $2); print tolower($2); exit}' || true)
+            [ "$external_driver" = "true" ] || external_driver="false"
+            jre_key=$(detect_jre_key "$name")
+            version=$(get_module_version "$name")
+            native_json=$(generate_native_platforms "$name")
+            [ -n "$DRIVERS" ] && DRIVERS="${DRIVERS},"$'\n'
+            DRIVERS="${DRIVERS}$(generate_jar_entry "$name" "$label" "$f" "$jre_key" "$version" "$external_driver" "$native_json")"
+          done
+          for name in oracle xugu; do
+            [ -f "release/dbx-agent-${name}.jar" ] && continue
+            native_json=$(generate_native_platforms "$name")
+            [ -z "$native_json" ] && continue
+            label=$(native_only_label "$name")
+            jre_key=$(detect_jre_key "$name")
+            version=$(get_module_version "$name")
+            [ -n "$DRIVERS" ] && DRIVERS="${DRIVERS},"$'\n'
+            DRIVERS="${DRIVERS}$(generate_native_entry "$name" "$label" "$jre_key" "$version" "$native_json")"
+          done
+
+          cat > release/agent-registry.json <<EOF
+          {
+            "jres": {
+              "21": {
+                "version": "21.0.12+kerberos.1",
+                "platforms": {
+          ${JRE21_PLATFORMS}
+                }
+              }
+            },
+            "drivers": {
+          ${DRIVERS}
+            }
+          }
+          EOF
+
+          python3 -m json.tool release/agent-registry.json > /dev/null
+          echo "=== agent-registry.json ==="
+          cat release/agent-registry.json
+
+      - name: Build offline ZIP bundles
+        run: bash agents/scripts/build_offline_zip.sh release
+
+      - name: Generate release notes
+        env:
+          MODULE_VERSIONS: ${{ needs.bump-versions.outputs.versions }}
+          PREV_VERSIONS: ${{ needs.bump-versions.outputs.prev_versions }}
+          PREV_TAG: ${{ needs.bump-versions.outputs.prev_tag }}
+        run: |
+          NOTES=""
+          DRIVER_NAMES=()
+          for f in release/dbx-agent-*.jar; do
+            DRIVER_NAMES+=("$(basename "$f" .jar | sed 's/dbx-agent-//')")
+          done
+          for name in oracle xugu; do
+            [ -f "release/dbx-agent-${name}.jar" ] && continue
+            compgen -G "release/dbx-agent-${name}-*" > /dev/null && DRIVER_NAMES+=("$name")
+          done
+
+          native_only_label() {
+            local name="$1"
+            case "$name" in
+              oracle) echo "Oracle" ;;
+              xugu) echo "虚谷 XuguDB" ;;
+              *) echo "$name" ;;
+            esac
+          }
+
+          for name in "${DRIVER_NAMES[@]}"; do
+            old_ver=$(echo "$PREV_VERSIONS" | python3 -c "import sys,json; print(json.load(sys.stdin).get('$name',''))")
+            new_ver=$(echo "$MODULE_VERSIONS" | python3 -c "import sys,json; print(json.load(sys.stdin).get('$name',''))")
+            [ "$old_ver" = "$new_ver" ] && continue
+
+            jar_file="release/dbx-agent-${name}.jar"
+            if [ -f "$jar_file" ]; then
+              label=$(unzip -p "$jar_file" META-INF/MANIFEST.MF | awk -F': ' 'BEGIN{IGNORECASE=1} /^Agent-Label:/ {sub(/\r$/, "", $2); print $2; exit}' || echo "$name")
+              [ -z "$label" ] && label="$name"
+            else
+              label=$(native_only_label "$name")
+            fi
+
+            NOTES="${NOTES}### ${label} (${old_ver} → ${new_ver})"$'\n'
+            if [ "$name" = "oracle" ]; then
+              LOG_PATH="agents/drivers/oracle-go/"
+            elif [ -d "agents/drivers/$name" ]; then
+              LOG_PATH="agents/drivers/$name/"
+            else
+              LOG_PATH="agents/$name/"
+            fi
+            LOG_PATHS=("$LOG_PATH")
+            while IFS= read -r line; do
+              [ -n "$line" ] && NOTES="${NOTES}- ${line}"$'\n'
+            done < <(git log --oneline "$PREV_TAG"..HEAD -- "${LOG_PATHS[@]}" | sed 's/^[0-9a-f]* //')
+
+            # include common changes if any
+            while IFS= read -r line; do
+              [ -n "$line" ] && NOTES="${NOTES}- ${line}"$'\n'
+            done < <(git log --oneline "$PREV_TAG"..HEAD -- agents/common/ | sed 's/^[0-9a-f]* //')
+            NOTES="${NOTES}"$'\n'
+          done
+
+          if [ -z "$NOTES" ]; then
+            NOTES="Routine rebuild, no agent-specific changes."$'\n'
+          fi
+
+          printf "## 更新内容\n\n%s" "$NOTES" > RELEASE_NOTES.md
+          echo "=== Release Notes ==="
+          cat RELEASE_NOTES.md
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: release/*
+          body_path: RELEASE_NOTES.md
+          make_latest: false
+
+      - name: Update agents-latest GitHub release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          git tag -f agents-latest "$GITHUB_SHA"
+          git push origin refs/tags/agents-latest --force
+
+          if gh release view agents-latest --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
+            gh release upload agents-latest release/* --repo "$GITHUB_REPOSITORY" --clobber
+            gh release edit agents-latest \
+              --repo "$GITHUB_REPOSITORY" \
+              --title "Agents latest" \
+              --notes "Moving release for the latest DBX agent registry, driver artifacts, managed JRE archives, and offline bundles." \
+              --latest=false
+          else
+            gh release create agents-latest release/* \
+              --repo "$GITHUB_REPOSITORY" \
+              --title "Agents latest" \
+              --notes "Moving release for the latest DBX agent registry, driver artifacts, managed JRE archives, and offline bundles." \
+              --latest=false
+          fi
+
+      - name: Upload to R2
+        env:
+          MODULE_VERSIONS: ${{ needs.bump-versions.outputs.versions }}
+          PREV_VERSIONS: ${{ needs.bump-versions.outputs.prev_versions }}
+          AWS_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
+          R2_ENDPOINT: "https://${{ secrets.R2_ACCOUNT_ID }}.r2.cloudflarestorage.com"
+          R2_BUCKET: "s3://${{ secrets.R2_BUCKET_NAME }}"
+        run: |
+          # Always upload agent-registry.json
+          aws s3 cp release/agent-registry.json \
+            "$R2_BUCKET/agents/agent-registry.json" \
+            --endpoint-url "$R2_ENDPOINT"
+          echo "Uploaded agent-registry.json"
+
+          # Upload only changed driver JARs
+          UPLOADED=0
+          SKIPPED=0
+          for f in release/dbx-agent-*.jar; do
+            [ ! -f "$f" ] && continue
+            name=$(basename "$f" .jar | sed 's/dbx-agent-//')
+            old_ver=$(echo "$PREV_VERSIONS" | python3 -c "import sys,json; print(json.load(sys.stdin).get('$name',''))" 2>/dev/null)
+            new_ver=$(echo "$MODULE_VERSIONS" | python3 -c "import sys,json; print(json.load(sys.stdin).get('$name',''))" 2>/dev/null)
+            if [ "$old_ver" = "$new_ver" ] && [ -n "$old_ver" ]; then
+              echo "Skip $(basename $f) (unchanged $old_ver)"
+              SKIPPED=$((SKIPPED + 1))
+              continue
+            fi
+            aws s3 cp "$f" \
+              "$R2_BUCKET/agents/drivers/$(basename $f)" \
+              --endpoint-url "$R2_ENDPOINT"
+            echo "Uploaded $(basename $f) ($old_ver → $new_ver)"
+            UPLOADED=$((UPLOADED + 1))
+          done
+          echo "Drivers: $UPLOADED uploaded, $SKIPPED skipped"
+
+          for f in release/dbx-agent-*; do
+            [ -f "$f" ] || continue
+            [[ "$f" != *.jar ]] || continue
+            aws s3 cp "$f" \
+              "$R2_BUCKET/agents/drivers/$(basename $f)" \
+              --endpoint-url "$R2_ENDPOINT"
+            echo "Uploaded $(basename $f)"
+          done
+
+          # Upload JRE — always overwrite to ensure latest modules
+          for f in release/dbx-jre-*.tar.gz; do
+            [ ! -f "$f" ] && continue
+            key="agents/jre/$(basename $f)"
+            aws s3 cp "$f" "$R2_BUCKET/$key" --endpoint-url "$R2_ENDPOINT"
+            echo "Uploaded $(basename $f)"
+          done
+
+  sync-release-to-cnb:
+    name: Sync agents releases to CNB
+    needs: release
+    if: ${{ always() && needs.release.result == 'success' }}
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    strategy:
+      fail-fast: false
+      matrix:
+        tag: ["${{ github.ref_name }}", "agents-latest"]
+    steps:
+      - name: Sync release assets to CNB
+        env:
+          TAG_NAME: ${{ matrix.tag }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          GITHUB_USERNAME: ${{ github.repository_owner }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CNB_REPOSITORY: dbxio.com/dbx
+          CNB_USERNAME: cnb
+          CNB_TOKEN: ${{ secrets.CNB_TOKEN }}
+        run: |
+          set -euo pipefail
+          wget -q https://cnb.cool/znb/mpgrm/-/releases/download/v0.1.0/mpgrm_linux_amd64.tar.gz
+          tar -xf mpgrm_linux_amd64.tar.gz
+          chmod +x mpgrm
+          ./mpgrm releases sync \
+            --repo "https://github.com/${GITHUB_REPOSITORY}.git" \
+            --target-repo "https://cnb.cool/${CNB_REPOSITORY}.git" \
+            --tags "${TAG_NAME}"
+
+  sync-release-to-atomgit:
+    name: Sync agents releases to AtomGit
+    needs: release
+    if: ${{ always() && needs.release.result == 'success' }}
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    strategy:
+      fail-fast: false
+      matrix:
+        tag: ["${{ github.ref_name }}", "agents-latest"]
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+      - name: Sync release assets to AtomGit
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG_NAME: ${{ matrix.tag }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          ATOMGIT_TOKEN: ${{ secrets.ATOMGIT_TOKEN }}
+          ATOMGIT_REPOSITORY: t8y2/dbx
+        run: |
+          set -euo pipefail
+          git fetch origin "refs/tags/${TAG_NAME}:refs/tags/${TAG_NAME}" --force
+          git remote add atomgit "https://t8y2:${ATOMGIT_TOKEN}@atomgit.com/t8y2/dbx.git"
+          git push atomgit "refs/tags/${TAG_NAME}:refs/tags/${TAG_NAME}" --force
+          mkdir -p "$RUNNER_TEMP/github-release" "$RUNNER_TEMP/release-assets"
+          gh release view "$TAG_NAME" --repo "$GITHUB_REPOSITORY" \
+            --json tagName,name,body,targetCommitish,isPrerelease,isDraft,assets \
+            > "$RUNNER_TEMP/github-release/release.json"
+          gh release download "$TAG_NAME" --repo "$GITHUB_REPOSITORY" \
+            --dir "$RUNNER_TEMP/release-assets" --clobber
+          node .github/scripts/sync-atomgit-release.mjs \
+            --github-release "$RUNNER_TEMP/github-release/release.json" \
+            --assets-dir "$RUNNER_TEMP/release-assets" \
+            ${{ matrix.tag == 'agents-latest' && '--replace-assets' || '' }}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..5fa41de
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,248 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  RUSTFLAGS: -C debuginfo=line-tables-only
+
+jobs:
+  frontend:
+    needs: changes
+    if: needs.changes.outputs.frontend == 'true'
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v6
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22.13.0
+          cache: pnpm
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libssl-dev libsecret-1-dev
+
+      - name: Install frontend dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Frontend check
+        run: pnpm check
+
+      - name: Node package tests
+        run: pnpm test:packages
+
+      - name: Node package publish dry run
+        run: pnpm publish:dry-run
+
+  rust-fmt-clippy:
+    needs: changes
+    if: needs.changes.outputs.rust == 'true'
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Free disk space
+        run: |
+          sudo rm -rf /usr/share/dotnet /opt/ghc /usr/local/lib/android /usr/local/.ghcup || true
+          docker system prune -af || true
+          df -h
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libssl-dev libsecret-1-dev
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy, rustfmt
+
+      - name: Rust cache
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: "./ -> target"
+          shared-key: ci-rust-fmt-clippy-x86_64-unknown-linux-gnu
+
+      - name: Cargo fmt check
+        run: cargo fmt --check
+
+      - name: Cargo clippy
+        run: cargo clippy --workspace --locked --all-targets
+
+  rust-test:
+    needs: changes
+    if: needs.changes.outputs.rust == 'true'
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Free disk space
+        run: |
+          sudo rm -rf /usr/share/dotnet /opt/ghc /usr/local/lib/android /usr/local/.ghcup || true
+          docker system prune -af || true
+          df -h
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf libssl-dev libsecret-1-dev
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Rust cache
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: "./ -> target"
+          shared-key: ci-rust-test-x86_64-unknown-linux-gnu
+
+      - name: Cargo test
+        run: cargo test --workspace --locked
+
+  rust:
+    needs: [changes, rust-fmt-clippy, rust-test]
+    if: always() && needs.changes.outputs.rust == 'true'
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check Rust jobs
+        run: |
+          if [ "${{ needs.rust-fmt-clippy.result }}" != "success" ]; then
+            echo "rust-fmt-clippy result: ${{ needs.rust-fmt-clippy.result }}"
+            exit 1
+          fi
+          if [ "${{ needs.rust-test.result }}" != "success" ]; then
+            echo "rust-test result: ${{ needs.rust-test.result }}"
+            exit 1
+          fi
+
+  jdbc:
+    needs: changes
+    if: needs.changes.outputs.jdbc == 'true'
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Setup Java
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: "17"
+          cache: maven
+
+      - name: JDBC plugin version guard
+        env:
+          BASE_SHA: ${{ github.event_name == 'pull_request' && github.event.pull_request.base.sha || github.event.before }}
+        run: |
+          if [ -z "$BASE_SHA" ] || echo "$BASE_SHA" | grep -Eq '^0+$'; then
+            BASE_SHA="HEAD~1"
+          fi
+          node .github/scripts/check-jdbc-plugin-version.mjs "$BASE_SHA" HEAD
+
+      - name: JDBC plugin package check
+        run: ./plugins/jdbc/package.sh
+
+  changes:
+    runs-on: ubuntu-22.04
+    outputs:
+      frontend: ${{ steps.filter.outputs.frontend }}
+      rust: ${{ steps.filter.outputs.rust }}
+      jdbc: ${{ steps.filter.outputs.jdbc }}
+      agents: ${{ steps.filter.outputs.agents }}
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Detect changed areas
+        uses: dorny/paths-filter@v3
+        id: filter
+        with:
+          filters: |
+            frontend:
+              - 'apps/desktop/**'
+              - 'packages/**'
+              - 'pnpm-lock.yaml'
+              - 'package.json'
+              - '.oxfmtrc.json'
+              - 'scripts/run-check.mjs'
+              - '.github/workflows/ci.yml'
+            rust:
+              - 'crates/**'
+              - 'src-tauri/**'
+              - 'Cargo.toml'
+              - 'Cargo.lock'
+              - 'rust-toolchain*'
+              - '.github/workflows/ci.yml'
+            jdbc:
+              - 'plugins/jdbc/**'
+            agents:
+              - 'agents/**'
+
+  agents:
+    needs: changes
+    if: needs.changes.outputs.agents == 'true'
+    runs-on: ubuntu-22.04
+    defaults:
+      run:
+        working-directory: agents
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Setup Java
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: |
+            8
+            21
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: "1.22.x"
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Agent script tests
+        run: python3 -m unittest discover -s scripts -p '*_test.py'
+
+      - name: Agent validation
+        run: python3 scripts/validate_agents.py
+
+      - name: Oracle native agent tests
+        run: go test ./...
+        working-directory: agents/drivers/oracle-go
+
+      - name: Xugu native agent tests
+        run: GONOSUMDB=gitee.com/XuguDB/go-xugu-driver go test ./...
+        working-directory: agents/drivers/xugu
+
+      - name: Oracle native agent build
+        run: CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -trimpath -ldflags="-s -w" -o /tmp/dbx-agent-oracle-linux-x64 .
+        working-directory: agents/drivers/oracle-go
+
+      - name: Xugu native agent build
+        run: GONOSUMDB=gitee.com/XuguDB/go-xugu-driver CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -trimpath -ldflags="-s -w" -o /tmp/dbx-agent-xugu-linux-x64 .
+        working-directory: agents/drivers/xugu
+
+      - name: Java agent tests and packages
+        run: ./gradlew test shadowJar --continue
+
+      - name: Agent jar validation
+        run: python3 scripts/validate_agent_jars.py
diff --git a/.github/workflows/docker-dev.yml b/.github/workflows/docker-dev.yml
new file mode 100644
index 0000000..2aa9958
--- /dev/null
+++ b/.github/workflows/docker-dev.yml
@@ -0,0 +1,126 @@
+name: Docker Dev
+
+on:
+  workflow_dispatch:
+
+env:
+  CNB_REPOSITORY: "dbxio.com/dbx"
+  CNB_REGISTRY: "docker.cnb.cool"
+
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [linux/amd64, linux/arm64]
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to CNB Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.CNB_REGISTRY }}
+          username: cnb
+          password: ${{ secrets.CNB_TOKEN }}
+
+      - name: Build and push Docker Hub by digest
+        id: build-dockerhub
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: deploy/Dockerfile
+          platforms: ${{ matrix.platform }}
+          outputs: type=image,name=${{ secrets.DOCKERHUB_USERNAME }}/dbx,push-by-digest=true,name-canonical=true,push=true
+          cache-from: type=gha,scope=${{ matrix.platform }}-dev
+          cache-to: type=gha,scope=${{ matrix.platform }}-dev,mode=max
+
+      - name: Build and push CNB by digest
+        id: build-cnb
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: deploy/Dockerfile
+          platforms: ${{ matrix.platform }}
+          outputs: type=image,name=${{ env.CNB_REGISTRY }}/${{ env.CNB_REPOSITORY }},push-by-digest=true,name-canonical=true,push=true
+          cache-from: type=gha,scope=${{ matrix.platform }}-dev
+
+      - name: Export digests
+        run: |
+          mkdir -p /tmp/digests/dockerhub /tmp/digests/cnb
+          dockerhub_digest="${{ steps.build-dockerhub.outputs.digest }}"
+          cnb_digest="${{ steps.build-cnb.outputs.digest }}"
+          touch "/tmp/digests/dockerhub/${dockerhub_digest#sha256:}"
+          touch "/tmp/digests/cnb/${cnb_digest#sha256:}"
+
+      - name: Upload Docker Hub digest
+        uses: actions/upload-artifact@v7
+        with:
+          name: dockerhub-digests-${{ matrix.platform == 'linux/amd64' && 'amd64' || 'arm64' }}
+          path: /tmp/digests/dockerhub/*
+          if-no-files-found: error
+          retention-days: 1
+
+      - name: Upload CNB digest
+        uses: actions/upload-artifact@v7
+        with:
+          name: cnb-digests-${{ matrix.platform == 'linux/amd64' && 'amd64' || 'arm64' }}
+          path: /tmp/digests/cnb/*
+          if-no-files-found: error
+          retention-days: 1
+
+  docker-manifest:
+    needs: docker
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download Docker Hub digests
+        uses: actions/download-artifact@v8
+        with:
+          path: /tmp/digests/dockerhub
+          pattern: dockerhub-digests-*
+          merge-multiple: true
+
+      - name: Download CNB digests
+        uses: actions/download-artifact@v8
+        with:
+          path: /tmp/digests/cnb
+          pattern: cnb-digests-*
+          merge-multiple: true
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to CNB Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.CNB_REGISTRY }}
+          username: cnb
+          password: ${{ secrets.CNB_TOKEN }}
+
+      - name: Create manifest list and push
+        run: |
+          docker buildx imagetools create \
+            -t ${{ secrets.DOCKERHUB_USERNAME }}/dbx:dev \
+            $(cd /tmp/digests/dockerhub && printf '${{ secrets.DOCKERHUB_USERNAME }}/dbx@sha256:%s ' *)
+
+          docker buildx imagetools create \
+            -t ${{ env.CNB_REGISTRY }}/${{ env.CNB_REPOSITORY }}:dev \
+            $(cd /tmp/digests/cnb && printf '${{ env.CNB_REGISTRY }}/${{ env.CNB_REPOSITORY }}@sha256:%s ' *)
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000..352bab3
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,35 @@
+name: Deploy Docs
+
+on:
+  push:
+    branches: [main]
+    paths: ["docs/**"]
+  workflow_run:
+    workflows: ["Publish Packages"]
+    types: [completed]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: pages
+  cancel-in-progress: true
+
+jobs:
+  build:
+    if: github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 22
+      - uses: pnpm/action-setup@v6
+      - run: cd docs && pnpm install --frozen-lockfile --ignore-workspace && pnpm build
+      - name: Deploy to Cloudflare Workers
+        working-directory: docs
+        run: pnpm dlx wrangler@4 deploy
+        env:
+          CLOUDFLARE_ACCOUNT_ID: ${{ secrets.R2_ACCOUNT_ID }}
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
diff --git a/.github/workflows/i18n-autofill.yml b/.github/workflows/i18n-autofill.yml
new file mode 100644
index 0000000..198cbd4
--- /dev/null
+++ b/.github/workflows/i18n-autofill.yml
@@ -0,0 +1,154 @@
+name: I18n Autofill
+
+on:
+  pull_request_target:
+    types: [opened, synchronize, reopened, ready_for_review]
+    paths:
+      - "apps/desktop/src/i18n/locales/**"
+      - ".github/scripts/i18n-autofill.mjs"
+      - ".github/workflows/i18n-autofill.yml"
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: read
+
+concurrency:
+  group: i18n-autofill-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  autofill:
+    if: github.event.pull_request.draft == false
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Checkout trusted base script
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ github.event.pull_request.base.sha }}
+
+      - name: Copy trusted script
+        run: cp .github/scripts/i18n-autofill.mjs "$RUNNER_TEMP/i18n-autofill.mjs"
+
+      - name: Checkout pull request branch
+        uses: actions/checkout@v5
+        with:
+          repository: ${{ github.event.pull_request.head.repo.full_name }}
+          ref: ${{ github.event.pull_request.head.sha }}
+          token: ${{ secrets.I18N_BOT_TOKEN || secrets.GITHUB_TOKEN }}
+          fetch-depth: 0
+
+      - name: Fetch base branch
+        env:
+          BASE_REF: ${{ github.event.pull_request.base.ref }}
+        run: |
+          git remote add base "https://github.com/${{ github.repository }}.git"
+          git fetch --no-tags --depth=1 base "${BASE_REF}"
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22.13.0
+
+      - name: Autofill missing i18n entries
+        env:
+          DEEPSEEK_API_KEY: ${{ secrets.DEEPSEEK_API_KEY }}
+          DEEPSEEK_MODEL: ${{ vars.DEEPSEEK_MODEL || 'deepseek-v4-pro' }}
+          I18N_BASE_REF: base/${{ github.event.pull_request.base.ref }}
+          I18N_SUMMARY_FILE: ${{ runner.temp }}/i18n-summary.json
+        run: node "$RUNNER_TEMP/i18n-autofill.mjs" --write
+
+      - name: Commit and push translation patch
+        id: patch
+        env:
+          PR_HEAD_REF: ${{ github.event.pull_request.head.ref }}
+        run: |
+          if git diff --quiet -- apps/desktop/src/i18n/locales; then
+            echo "No i18n autofill changes to commit"
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          git config user.name "dbx-i18n-bot"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add apps/desktop/src/i18n/locales
+          git commit -m "chore(i18n): autofill new translations"
+          if git push origin "HEAD:${PR_HEAD_REF}"; then
+            echo "push_failed=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "push_failed=true" >> "$GITHUB_OUTPUT"
+            git diff HEAD~1 HEAD -- apps/desktop/src/i18n/locales > "$RUNNER_TEMP/i18n-autofill.patch"
+          fi
+          echo "changed=true" >> "$GITHUB_OUTPUT"
+
+      - name: Comment autofill result
+        if: steps.patch.outputs.changed == 'true' && steps.patch.outputs.push_failed != 'true'
+        env:
+          GH_TOKEN: ${{ secrets.I18N_BOT_TOKEN || secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          SUMMARY_FILE: ${{ runner.temp }}/i18n-summary.json
+          BODY_FILE: ${{ runner.temp }}/i18n-autofill-comment.md
+        run: |
+          node <<'NODE'
+          const fs = require("node:fs");
+
+          const summary = JSON.parse(fs.readFileSync(process.env.SUMMARY_FILE, "utf8"));
+          const keyCount = summary.newKeys.length;
+          const localeRows = summary.updatedLocales
+            .map(({ locale, count }) => `| \`${locale}\` | ${count} |`)
+            .join("\n");
+          const body = [
+            "### 🌐 I18n autofill completed",
+            "",
+            `✅ Added translations for **${keyCount}** new \`${summary.sourceLocale}\` i18n ${keyCount === 1 ? "key" : "keys"}.`,
+            "",
+            "| Locale | Added entries |",
+            "| --- | ---: |",
+            localeRows,
+          ].join("\n");
+
+          fs.writeFileSync(process.env.BODY_FILE, `${body}\n`);
+          NODE
+
+          gh pr comment "$PR_NUMBER" --repo "$GITHUB_REPOSITORY" --body-file "$BODY_FILE"
+
+      - name: Comment push failure
+        if: steps.patch.outputs.changed == 'true' && steps.patch.outputs.push_failed == 'true'
+        env:
+          GH_TOKEN: ${{ secrets.I18N_BOT_TOKEN || secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          SUMMARY_FILE: ${{ runner.temp }}/i18n-summary.json
+          PATCH_FILE: ${{ runner.temp }}/i18n-autofill.patch
+          BODY_FILE: ${{ runner.temp }}/i18n-autofill-push-failed.md
+        run: |
+          node <<'NODE'
+          const fs = require("node:fs");
+
+          const summary = JSON.parse(fs.readFileSync(process.env.SUMMARY_FILE, "utf8"));
+          const patch = fs.readFileSync(process.env.PATCH_FILE, "utf8");
+          const keyCount = summary.newKeys.length;
+          const localeRows = summary.updatedLocales
+            .map(({ locale, count }) => `| \`${locale}\` | ${count} |`)
+            .join("\n");
+          const patchPreview = patch.length > 60000
+            ? `${patch.slice(0, 60000)}\n\n[Patch truncated in comment. Please check the workflow artifact/log for the full diff.]`
+            : patch;
+          const body = [
+            "### ⚠️ I18n autofill needs manual apply",
+            "",
+            `I generated translations for **${keyCount}** new \`${summary.sourceLocale}\` i18n ${keyCount === 1 ? "key" : "keys"}, but could not push a patch to this PR branch.`,
+            "",
+            "| Locale | Missing entries |",
+            "| --- | ---: |",
+            localeRows,
+            "",
+            "#### Patch preview",
+            "```diff",
+            patchPreview,
+            "```",
+          ].join("\n");
+
+          fs.writeFileSync(process.env.BODY_FILE, `${body}\n`);
+          NODE
+
+          gh pr comment "$PR_NUMBER" --repo "$GITHUB_REPOSITORY" --body-file "$BODY_FILE"
diff --git a/.github/workflows/issue-claim.yml b/.github/workflows/issue-claim.yml
new file mode 100644
index 0000000..6ba9c0e
--- /dev/null
+++ b/.github/workflows/issue-claim.yml
@@ -0,0 +1,30 @@
+name: Issue Claim
+
+on:
+  issue_comment:
+    types: [created]
+
+concurrency:
+  group: issue-claim-${{ github.event.issue.number }}
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+  issues: write
+
+jobs:
+  claim:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.issue.pull_request }}
+    env:
+      GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Handle /claim command
+        run: node .github/scripts/issue-claim.mjs
+        env:
+          ISSUE_NUMBER: ${{ github.event.issue.number }}
+          COMMENT_BODY: ${{ github.event.comment.body }}
+          COMMENT_USER: ${{ github.event.comment.user.login }}
+          COMMENT_USER_TYPE: ${{ github.event.comment.user.type }}
diff --git a/.github/workflows/issue-database-label.yml b/.github/workflows/issue-database-label.yml
new file mode 100644
index 0000000..df17320
--- /dev/null
+++ b/.github/workflows/issue-database-label.yml
@@ -0,0 +1,30 @@
+name: Issue Triage Labels
+
+on:
+  issues:
+    types: [opened, edited, reopened]
+
+concurrency:
+  group: issue-database-label-${{ github.event.issue.number }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  issues: write
+
+jobs:
+  label:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.issue.pull_request }}
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22.13.0
+
+      - name: Triage issue labels and title
+        run: node .github/scripts/label-issue-database.mjs
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/mcp-release.yml b/.github/workflows/mcp-release.yml
new file mode 100644
index 0000000..f758a6a
--- /dev/null
+++ b/.github/workflows/mcp-release.yml
@@ -0,0 +1,342 @@
+name: Node Packages Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Package version to publish, for example 0.4.4"
+        required: true
+
+permissions:
+  contents: write
+  id-token: write
+
+concurrency:
+  group: dbx-release-main
+  cancel-in-progress: false
+
+jobs:
+  prepare:
+    name: Prepare package release
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+      tag: ${{ steps.version.outputs.tag }}
+
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v6
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22.13.0
+          registry-url: https://registry.npmjs.org
+          cache: pnpm
+          cache-dependency-path: pnpm-lock.yaml
+
+      - name: Check npm token
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: |
+          if [ -z "${NODE_AUTH_TOKEN}" ]; then
+            echo "::error::NPM_TOKEN secret is required to publish DBX Node packages."
+            exit 1
+          fi
+
+      - name: Install native build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libsecret-1-dev
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Set package versions
+        id: version
+        env:
+          VERSION: ${{ github.event.inputs.version }}
+        run: |
+          node <<'NODE'
+          const fs = require("fs");
+
+          const version = process.env.VERSION.trim();
+          if (!/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/.test(version)) {
+            throw new Error(`Invalid semver version: ${version}`);
+          }
+
+          const readJson = (path) => JSON.parse(fs.readFileSync(path, "utf8"));
+          const writeJson = (path, data) => fs.writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`);
+
+          for (const path of [
+            "packages/node-core/package.json",
+            "packages/cli/package.json",
+            "packages/mcp-server/package.json",
+          ]) {
+            const pkg = readJson(path);
+            pkg.version = version;
+            writeJson(path, pkg);
+          }
+
+          const serverPath = "packages/mcp-server/server.json";
+          const server = readJson(serverPath);
+          server.version = version;
+          for (const packageInfo of server.packages ?? []) {
+            if (packageInfo.registryType === "npm" && packageInfo.identifier === "@dbx-app/mcp-server") {
+              packageInfo.version = version;
+            }
+          }
+          writeJson(serverPath, server);
+
+          fs.appendFileSync(process.env.GITHUB_OUTPUT, `version=${version}\n`);
+          fs.appendFileSync(process.env.GITHUB_OUTPUT, `tag=packages-v${version}\n`);
+          NODE
+
+      - name: Run package tests
+        run: pnpm test:packages
+
+      - name: Build and pack packages
+        run: pnpm publish:dry-run
+
+      - name: Configure git author
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+
+      - name: Commit package release version
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          git add packages/node-core/package.json packages/cli/package.json packages/mcp-server/package.json packages/mcp-server/server.json
+          if git diff --cached --quiet; then
+            echo "Package versions already committed for ${VERSION}."
+          else
+            git commit -m "chore(packages): release ${VERSION} [skip node-packages-release]"
+          fi
+
+      - name: Rebase package release commit and push
+        env:
+          RELEASE_TOKEN: ${{ secrets.MCP_RELEASE_TOKEN }}
+        run: |
+          TAG="${{ steps.version.outputs.tag }}"
+          if [ -n "${RELEASE_TOKEN}" ]; then
+            git remote set-url origin "https://x-access-token:${RELEASE_TOKEN}@github.com/${GITHUB_REPOSITORY}.git"
+          fi
+          git fetch origin main --no-tags
+          git rebase origin/main
+          REMOTE_TAG_SHA="$(git ls-remote --tags origin "refs/tags/${TAG}" | awk '{print $1}')"
+          HEAD_SHA="$(git rev-parse HEAD)"
+          if [ -n "${REMOTE_TAG_SHA}" ]; then
+            if [ "${REMOTE_TAG_SHA}" != "${HEAD_SHA}" ]; then
+              echo "::error::Remote tag ${TAG} already exists at ${REMOTE_TAG_SHA}, expected ${HEAD_SHA}."
+              exit 1
+            fi
+            echo "Remote tag ${TAG} already points at ${HEAD_SHA}."
+          else
+            git tag -f "${TAG}" "${HEAD_SHA}"
+          fi
+          git push origin HEAD:main
+          if [ -z "${REMOTE_TAG_SHA}" ]; then
+            git push origin "refs/tags/${TAG}:refs/tags/${TAG}"
+          fi
+
+  publish-node-core:
+    name: Publish node-core
+    runs-on: ubuntu-latest
+    needs: prepare
+    outputs:
+      published-or-existing: ${{ steps.publish.outputs.published_or_existing }}
+
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ needs.prepare.outputs.tag }}
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v6
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22.13.0
+          registry-url: https://registry.npmjs.org
+          cache: pnpm
+          cache-dependency-path: pnpm-lock.yaml
+
+      - name: Install native build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libsecret-1-dev
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Publish Node core
+        id: publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          VERSION: ${{ needs.prepare.outputs.version }}
+        run: |
+          if npm view "@dbx-app/node-core@${VERSION}" version >/dev/null 2>&1; then
+            echo "@dbx-app/node-core@${VERSION} already exists on npm; skipping."
+            echo "published_or_existing=true" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+          pnpm --filter @dbx-app/node-core publish --access public --provenance --no-git-checks
+          echo "published_or_existing=true" >> "$GITHUB_OUTPUT"
+
+  publish-leaf-packages:
+    name: Publish ${{ matrix.package-name }}
+    runs-on: ubuntu-latest
+    needs: [prepare, publish-node-core]
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - package-name: "@dbx-app/cli"
+            filter: "@dbx-app/cli"
+          - package-name: "@dbx-app/mcp-server"
+            filter: "@dbx-app/mcp-server"
+
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ needs.prepare.outputs.tag }}
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v6
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22.13.0
+          registry-url: https://registry.npmjs.org
+          cache: pnpm
+          cache-dependency-path: pnpm-lock.yaml
+
+      - name: Install native build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libsecret-1-dev
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Build workspace dependencies
+        run: pnpm --filter @dbx-app/node-core build
+
+      - name: Publish package
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          VERSION: ${{ needs.prepare.outputs.version }}
+          PACKAGE_NAME: ${{ matrix.package-name }}
+          PACKAGE_FILTER: ${{ matrix.filter }}
+        run: |
+          if npm view "${PACKAGE_NAME}@${VERSION}" version >/dev/null 2>&1; then
+            echo "${PACKAGE_NAME}@${VERSION} already exists on npm; skipping."
+            exit 0
+          fi
+          pnpm --filter "${PACKAGE_FILTER}" publish --access public --provenance --no-git-checks
+
+  publish-homebrew-formula:
+    name: Publish Homebrew formula
+    runs-on: ubuntu-latest
+    needs: [prepare, publish-leaf-packages]
+    steps:
+      - name: Download CLI npm tarball and compute SHA256
+        id: cli-hash
+        env:
+          VERSION: ${{ needs.prepare.outputs.version }}
+        run: |
+          VERSION="${VERSION}"
+          NPM_TARBALL="cli-${VERSION}.tgz"
+          NPM_URL="https://registry.npmjs.org/@dbx-app/cli/-/${NPM_TARBALL}"
+
+          # Poll npm until the package is available (CDN propagation delay)
+          for i in $(seq 1 12); do
+            if curl -fsSLI "${NPM_URL}" >/dev/null 2>&1; then
+              echo "Package found on attempt ${i}"
+              break
+            fi
+            echo "Waiting for npm CDN (attempt ${i}/12)..."
+            sleep 10
+          done
+
+          curl -fsSL -o "${NPM_TARBALL}" "${NPM_URL}"
+          CLI_SHA256=$(sha256sum "${NPM_TARBALL}" | cut -d ' ' -f 1)
+          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
+          echo "sha256=${CLI_SHA256}" >> "$GITHUB_OUTPUT"
+          echo "  cli version: ${VERSION}"
+          echo "  sha256: ${CLI_SHA256}"
+
+      - name: Push formula to homebrew-tap
+        env:
+          TAP_GITHUB_TOKEN: ${{ secrets.TAP_GITHUB_TOKEN }}
+          CLI_VERSION: ${{ steps.cli-hash.outputs.version }}
+          CLI_SHA256: ${{ steps.cli-hash.outputs.sha256 }}
+        run: |
+          git clone --depth 1 \
+            "https://x-access-token:${TAP_GITHUB_TOKEN}@github.com/t8y2/homebrew-tap.git" \
+            homebrew-tap
+          cd homebrew-tap
+          mkdir -p Formula
+
+          cat > Formula/dbx-cli.rb <<'RUBY_EOF'
+          class DbxCli < Formula
+            desc "Command-line interface for DBX database connections, schema, and safe queries"
+            homepage "https://github.com/t8y2/dbx"
+            url "https://registry.npmjs.org/@dbx-app/cli/-/cli-__CLI_VERSION__.tgz"
+            sha256 "__CLI_SHA256__"
+            license "Apache-2.0"
+
+            depends_on "node"
+
+            on_linux do
+              depends_on "pkgconf" => :build
+              depends_on "libsecret"
+            end
+
+            def install
+              system "npm", "install", *std_npm_args
+              bin.install_symlink libexec.glob("bin/*")
+
+              # Rebuild better-sqlite3 and keytar native bindings for the current platform.
+              # prebuild-install is blocked by the Homebrew sandbox during npm install,
+              # so we must rebuild them explicitly via node-gyp.
+              node_modules = libexec/"lib/node_modules/@dbx-app/cli/node_modules"
+
+              cd node_modules/"better-sqlite3" do
+                system "npm", "run", "build-release"
+              end
+
+              cd node_modules/"keytar" do
+                rm_r "prebuilds" if File.directory?("prebuilds")
+                system "npm", "run", "build"
+              end
+            end
+
+            test do
+              assert_path_exists bin/"dbx"
+              system bin/"dbx", "doctor"
+            end
+          end
+          RUBY_EOF
+
+          sed -i 's/^          //' Formula/dbx-cli.rb
+          sed -i "s/__CLI_VERSION__/${CLI_VERSION}/g" Formula/dbx-cli.rb
+          sed -i "s/__CLI_SHA256__/${CLI_SHA256}/g" Formula/dbx-cli.rb
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add Formula/dbx-cli.rb
+
+          if git diff --cached --quiet; then
+            echo "CLI Homebrew formula is already up to date."
+          else
+            git commit -m "dbx-cli ${CLI_VERSION}"
+            git push
+            echo "::notice::CLI Homebrew formula updated to ${CLI_VERSION}"
+          fi
diff --git a/.github/workflows/notify.yml b/.github/workflows/notify.yml
new file mode 100644
index 0000000..12649a2
--- /dev/null
+++ b/.github/workflows/notify.yml
@@ -0,0 +1,200 @@
+name: Notifications
+
+on:
+  # issues:
+  #   types: [opened]
+  pull_request_target:
+    types: [opened, closed]
+  release:
+    types: [published, released]
+
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name != 'release' || (!github.event.release.draft && !github.event.release.prerelease) }}
+    steps:
+      - name: Build message
+        id: msg
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          EVENT_ACTION: ${{ github.event.action }}
+          # ISSUE_TITLE: ${{ github.event.issue.title }}
+          # ISSUE_URL: ${{ github.event.issue.html_url }}
+          # ISSUE_USER: ${{ github.event.issue.user.login }}
+          # ISSUE_BODY: ${{ github.event.issue.body }}
+          PR_TITLE: ${{ github.event.pull_request.title }}
+          PR_URL: ${{ github.event.pull_request.html_url }}
+          PR_USER: ${{ github.event.pull_request.user.login }}
+          PR_MERGED: ${{ github.event.pull_request.merged }}
+          PR_MERGED_BY: ${{ github.event.pull_request.merged_by.login }}
+          RELEASE_TAG: ${{ github.event.release.tag_name }}
+          RELEASE_NAME: ${{ github.event.release.name }}
+          RELEASE_URL: ${{ github.event.release.html_url }}
+          RELEASE_BODY: ${{ github.event.release.body }}
+        run: |
+          python3 - <<'PYEOF'
+          import os
+
+          event = os.environ["EVENT_NAME"]
+          action = os.environ.get("EVENT_ACTION", "")
+          msg = None
+
+          # if event == "issues":
+          #     title = os.environ["ISSUE_TITLE"]
+          #     url = os.environ["ISSUE_URL"]
+          #     user = os.environ["ISSUE_USER"]
+          #     msg = "\n".join([
+          #         "📋 新 Issue",
+          #         f"标题: {title}",
+          #         f"提交者: {user}",
+          #         f"链接: {url}",
+          #     ])
+          #
+          # elif event == "release":
+          if event == "release":
+              tag = os.environ["RELEASE_TAG"]
+              name = os.environ["RELEASE_NAME"]
+              url = os.environ["RELEASE_URL"]
+              body = os.environ.get("RELEASE_BODY", "")[:800]
+
+              import re
+              body = re.sub(r'#{1,6}\s*', '', body)
+              body = re.sub(r'\*\*(.+?)\*\*', r'\1', body)
+              body = re.sub(r'\*(.+?)\*', r'\1', body)
+              body = re.sub(r'`(.+?)`', r'\1', body)
+              body = re.sub(r'\[(.+?)\]\(.+?\)', r'\1', body)
+              body = re.sub(r'\n{3,}', '\n\n', body)
+              body = body.strip()
+
+              msg = "\n".join([
+                  f"🚀 新版本发布 {tag}",
+                  "",
+                  body,
+                  "",
+                  f"下载: {url}",
+              ])
+
+          elif event in ("pull_request", "pull_request_target"):
+              title = os.environ["PR_TITLE"]
+              url = os.environ["PR_URL"]
+              if action == "opened":
+                  user = os.environ["PR_USER"]
+                  msg = "\n".join([
+                      "🔀 新 Pull Request",
+                      f"标题: {title}",
+                      f"提交者: {user}",
+                      f"链接: {url}",
+                  ])
+              elif action == "closed" and os.environ.get("PR_MERGED") == "true":
+                  user = os.environ.get("PR_MERGED_BY", "unknown")
+                  msg = "\n".join([
+                      "✅ PR 已合并",
+                      f"标题: {title}",
+                      f"合并者: {user}",
+                      f"链接: {url}",
+                  ])
+
+          with open(os.environ["GITHUB_OUTPUT"], "a") as f:
+              if msg:
+                  f.write(f"skip=false\n")
+                  delim = "EOF_MSG"
+                  f.write(f"msg<<{delim}\n{msg}\n{delim}\n")
+              else:
+                  f.write(f"skip=true\n")
+          PYEOF
+
+      # - name: AI Analysis for Issue
+      #   id: ai
+      #   if: ${{ github.event_name == 'issues' && steps.msg.outputs.skip != 'true' }}
+      #   env:
+      #     ISSUE_TITLE: ${{ github.event.issue.title }}
+      #     ISSUE_BODY: ${{ github.event.issue.body }}
+      #     ISSUE_USER: ${{ github.event.issue.user.login }}
+      #     DEEPSEEK_API_KEY: ${{ secrets.DEEPSEEK_API_KEY }}
+      #   run: |
+      #     python3 - <<'PYEOF'
+      #     import os, json, urllib.request
+      #
+      #     title = os.environ["ISSUE_TITLE"]
+      #     body = (os.environ.get("ISSUE_BODY") or "(无描述)")[:800]
+      #     user = os.environ.get("ISSUE_USER", "unknown")
+      #     api_key = os.environ.get("DEEPSEEK_API_KEY", "")
+      #
+      #     if not api_key:
+      #         with open(os.environ["GITHUB_OUTPUT"], "a") as f:
+      #             f.write("analysis=\n")
+      #         exit(0)
+      #
+      #     prompt = f"""分析这个 GitHub Issue，用中文回复。格式要求（严格遵守，不要多余内容）：
+      #
+      #     总结: [一句话概括核心问题]
+      #     优先级: [P0紧急/P1重要/P2普通/P3低优]
+      #     合理性: [有效问题/重复报告/信息不足/不是bug]
+      #     建议: [一句话给出处理建议或关联方向]
+      #
+      #     ---
+      #     标题: {title}
+      #     提交者: {user}
+      #     内容: {body}"""
+      #
+      #     req = urllib.request.Request(
+      #         "https://api.deepseek.com/v1/chat/completions",
+      #         data=json.dumps({
+      #             "model": "deepseek-v4-pro",
+      #             "max_tokens": 300,
+      #             "messages": [{"role": "user", "content": prompt}],
+      #         }).encode(),
+      #         headers={
+      #             "Authorization": f"Bearer {api_key}",
+      #             "Content-Type": "application/json",
+      #         },
+      #     )
+      #
+      #     try:
+      #         resp = urllib.request.urlopen(req, timeout=20)
+      #         data = json.loads(resp.read())
+      #         text = data["choices"][0]["message"]["content"]
+      #     except Exception as e:
+      #         text = f"(AI 分析暂时不可用: {e})"
+      #
+      #     with open(os.environ["GITHUB_OUTPUT"], "a") as f:
+      #         delim = "EOF_ANALYSIS"
+      #         f.write(f"analysis<<{delim}\n{text}\n{delim}\n")
+      #     PYEOF
+
+      - name: Send to Feishu
+        if: ${{ steps.msg.outputs.skip != 'true' && github.event_name != 'release' }}
+        env:
+          FEISHU_WEBHOOK_URL: ${{ secrets.FEISHU_WEBHOOK_URL }}
+          MSG_CONTENT: ${{ steps.msg.outputs.msg }}
+        run: |
+          curl -s -X POST "$FEISHU_WEBHOOK_URL" \
+            -H 'Content-Type: application/json' \
+            -d "$(jq -n --arg text "$MSG_CONTENT" '{msg_type: "text", content: {text: $text}}')"
+
+      - name: Send to QQ group
+        if: steps.msg.outputs.skip != 'true'
+        env:
+          SSH_KEY: ${{ secrets.DEPLOY_SSH_KEY }}
+          HOST: ${{ secrets.DEPLOY_HOST }}
+          ASTRBOT_API_KEY: ${{ secrets.ASTRBOT_API_KEY }}
+          MSG_CONTENT: ${{ steps.msg.outputs.msg }}
+          # AI_ANALYSIS: ${{ steps.ai.outputs.analysis }}
+        run: |
+          mkdir -p ~/.ssh
+          echo "$SSH_KEY" > ~/.ssh/id_ed25519
+          chmod 600 ~/.ssh/id_ed25519
+          ssh-keyscan -H "$HOST" >> ~/.ssh/known_hosts 2>/dev/null
+
+          # if [ -n "$AI_ANALYSIS" ]; then
+          #   MSG_CONTENT="${MSG_CONTENT}
+          #
+          # 🤖 AI 分析:
+          # ${AI_ANALYSIS}"
+          # fi
+
+          MSG=$(echo "$MSG_CONTENT" | jq -Rs .)
+          ssh "root@${HOST}" "curl -s -X POST http://localhost:6185/api/v1/im/message \
+            -H 'Authorization: Bearer ${ASTRBOT_API_KEY}' \
+            -H 'Content-Type: application/json' \
+            -d '{\"umo\": \"default:GroupMessage:1087880322\", \"message\": ${MSG}}'"
diff --git a/.github/workflows/project-triage.yml b/.github/workflows/project-triage.yml
new file mode 100644
index 0000000..cd95e2a
--- /dev/null
+++ b/.github/workflows/project-triage.yml
@@ -0,0 +1,48 @@
+name: Project Triage
+
+on:
+  issues:
+    types: [opened, reopened, labeled, unlabeled, assigned, unassigned]
+  workflow_dispatch:
+    inputs:
+      backfill:
+        description: Sync all open issues into DBX Issue Triage
+        required: false
+        default: "false"
+
+permissions:
+  contents: read
+  issues: read
+
+jobs:
+  sync-project-triage:
+    runs-on: ubuntu-latest
+    env:
+      PROJECT_TOKEN: ${{ secrets.PROJECT_AUTOMATION_TOKEN }}
+      PROJECT_OWNER: t8y2
+      PROJECT_NUMBER: "1"
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22.13.0
+
+      - name: Validate project token
+        run: |
+          if [ -z "$PROJECT_TOKEN" ]; then
+            echo "Missing PROJECT_AUTOMATION_TOKEN secret"
+            exit 1
+          fi
+
+      - name: Sync current issue
+        if: ${{ github.event_name == 'issues' }}
+        env:
+          ISSUE_NUMBER: ${{ github.event.issue.number }}
+          ISSUE_EVENT_ACTION: ${{ github.event.action }}
+        run: node .github/scripts/sync-project-triage.mjs --issue-number "$ISSUE_NUMBER" --event-action "$ISSUE_EVENT_ACTION"
+
+      - name: Backfill open issues
+        if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.backfill == 'true' }}
+        run: node .github/scripts/sync-project-triage.mjs --backfill true
diff --git a/.github/workflows/publish-packages.yml b/.github/workflows/publish-packages.yml
new file mode 100644
index 0000000..ece7a22
--- /dev/null
+++ b/.github/workflows/publish-packages.yml
@@ -0,0 +1,382 @@
+name: Publish Packages
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release tag (e.g. v0.3.10)"
+        required: true
+
+permissions:
+  contents: write
+
+env:
+  APP_NAME: dbx
+  PRODUCT_NAME: DBX
+  REPO_OWNER: t8y2
+
+jobs:
+  publish:
+    name: Publish to Homebrew & Scoop
+    runs-on: ubuntu-latest
+    steps:
+      - name: Extract version from tag
+        id: version
+        run: |
+          TAG="${{ github.event.inputs.tag }}"
+          TAG="$(echo "${TAG}" | xargs)"
+          VERSION="${TAG#v}"
+          if [[ ! "${VERSION}" =~ ^[0-9]+\.[0-9]+\.[0-9]+ ]]; then
+            echo "::error::Tag '${TAG}' does not look like a semver version."
+            exit 1
+          fi
+          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
+          echo "tag=${TAG}" >> "$GITHUB_OUTPUT"
+
+      - name: Download release assets
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          mkdir -p artifacts
+          VERSION="${{ steps.version.outputs.version }}"
+          TAG="${{ steps.version.outputs.tag }}"
+
+          ASSETS=(
+            "${PRODUCT_NAME}_${VERSION}_aarch64.dmg"
+            "${PRODUCT_NAME}_${VERSION}_x64.dmg"
+            "${PRODUCT_NAME}_${VERSION}_x64-setup.exe"
+            "${PRODUCT_NAME}_${VERSION}_arm64-setup.exe"
+          )
+
+          for ASSET in "${ASSETS[@]}"; do
+            echo "::group::Downloading ${ASSET}"
+            gh release download "${TAG}" \
+              --repo "${{ github.repository }}" \
+              --pattern "${ASSET}" \
+              --dir artifacts \
+              --clobber
+            echo "::endgroup::"
+          done
+
+          ls -lh artifacts/
+
+      - name: Compute SHA256 hashes
+        id: hashes
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+
+          compute_hash() {
+            local file="$1" name="$2"
+            if [[ ! -f "${file}" ]]; then
+              echo "::error::Missing artifact: ${file}"
+              exit 1
+            fi
+            local hash
+            hash=$(sha256sum "${file}" | cut -d ' ' -f 1)
+            echo "${name}=${hash}" >> "$GITHUB_OUTPUT"
+            echo "  ${name}: ${hash}"
+          }
+
+          echo "SHA256 hashes:"
+          compute_hash "artifacts/${PRODUCT_NAME}_${VERSION}_aarch64.dmg" "sha_dmg_arm64"
+          compute_hash "artifacts/${PRODUCT_NAME}_${VERSION}_x64.dmg" "sha_dmg_x64"
+          compute_hash "artifacts/${PRODUCT_NAME}_${VERSION}_x64-setup.exe" "sha_exe_x64"
+          compute_hash "artifacts/${PRODUCT_NAME}_${VERSION}_arm64-setup.exe" "sha_exe_arm64"
+
+      - name: Publish Homebrew Cask
+        env:
+          TAP_GITHUB_TOKEN: ${{ secrets.TAP_GITHUB_TOKEN }}
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          SHA_ARM64="${{ steps.hashes.outputs.sha_dmg_arm64 }}"
+          SHA_X64="${{ steps.hashes.outputs.sha_dmg_x64 }}"
+
+          git clone --depth 1 \
+            "https://x-access-token:${TAP_GITHUB_TOKEN}@github.com/${REPO_OWNER}/homebrew-tap.git" \
+            homebrew-tap
+          cd homebrew-tap
+          mkdir -p Casks
+
+          cat > Casks/dbx.rb <<'RUBY_EOF'
+          cask "dbx" do
+            arch arm: "aarch64", intel: "x64"
+
+            version "__VERSION__"
+            sha256 arm:   "__SHA_ARM64__",
+                   intel: "__SHA_X64__"
+
+            url "https://github.com/__OWNER__/__APP__/releases/download/v#{version}/__PRODUCT___#{version}_#{arch}.dmg",
+                verified: "github.com/__OWNER__/__APP__/"
+            name "DBX"
+            desc "Database management tool"
+            homepage "https://dbxio.com/"
+
+            depends_on macos: :big_sur
+
+            app "DBX.app"
+
+            zap trash: [
+              "~/Library/Application Support/com.dbx.app",
+              "~/Library/Caches/com.dbx.app",
+              "~/Library/Logs/com.dbx.app",
+              "~/Library/Preferences/com.dbx.app.plist",
+            ]
+          end
+          RUBY_EOF
+
+          sed -i 's/^          //' Casks/dbx.rb
+
+          sed -i "s/__VERSION__/${VERSION}/g" Casks/dbx.rb
+          sed -i "s/__OWNER__/${REPO_OWNER}/g" Casks/dbx.rb
+          sed -i "s/__APP__/${APP_NAME}/g" Casks/dbx.rb
+          sed -i "s/__PRODUCT__/${PRODUCT_NAME}/g" Casks/dbx.rb
+          sed -i "s/__SHA_ARM64__/${SHA_ARM64}/g" Casks/dbx.rb
+          sed -i "s/__SHA_X64__/${SHA_X64}/g" Casks/dbx.rb
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add Casks/dbx.rb
+
+          if git diff --cached --quiet; then
+            echo "Homebrew Cask is already up to date."
+          else
+            git commit -m "dbx ${VERSION}"
+            git push
+            echo "::notice::Homebrew Cask updated to ${VERSION}"
+          fi
+
+      - name: Publish Scoop manifest
+        env:
+          TAP_GITHUB_TOKEN: ${{ secrets.TAP_GITHUB_TOKEN }}
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          SHA_EXE_X64="${{ steps.hashes.outputs.sha_exe_x64 }}"
+          SHA_EXE_ARM64="${{ steps.hashes.outputs.sha_exe_arm64 }}"
+
+          git clone --depth 1 \
+            "https://x-access-token:${TAP_GITHUB_TOKEN}@github.com/${REPO_OWNER}/scoop-bucket.git" \
+            scoop-bucket
+          cd scoop-bucket
+
+          cat > dbx.json <<JSON_EOF
+          {
+              "version": "${VERSION}",
+              "description": "Open-source database management tool",
+              "homepage": "https://github.com/${REPO_OWNER}/${APP_NAME}",
+              "license": "Apache-2.0",
+              "architecture": {
+                  "64bit": {
+                      "url": "https://github.com/${REPO_OWNER}/${APP_NAME}/releases/download/v${VERSION}/${PRODUCT_NAME}_${VERSION}_x64-setup.exe",
+                      "hash": "${SHA_EXE_X64}"
+                  },
+                  "arm64": {
+                      "url": "https://github.com/${REPO_OWNER}/${APP_NAME}/releases/download/v${VERSION}/${PRODUCT_NAME}_${VERSION}_arm64-setup.exe",
+                      "hash": "${SHA_EXE_ARM64}"
+                  }
+              },
+              "innosetup": false,
+              "installer": {
+                  "args": ["/S", "/D=\$dir"]
+              },
+              "uninstaller": {
+                  "file": "uninstall.exe",
+                  "args": ["/S"]
+              },
+              "checkver": {
+                  "github": "https://github.com/${REPO_OWNER}/${APP_NAME}"
+              },
+              "autoupdate": {
+                  "architecture": {
+                      "64bit": {
+                          "url": "https://github.com/${REPO_OWNER}/${APP_NAME}/releases/download/v\$version/${PRODUCT_NAME}_\$version_x64-setup.exe"
+                      },
+                      "arm64": {
+                          "url": "https://github.com/${REPO_OWNER}/${APP_NAME}/releases/download/v\$version/${PRODUCT_NAME}_\$version_arm64-setup.exe"
+                      }
+                  }
+              }
+          }
+          JSON_EOF
+
+          sed -i 's/^          //' dbx.json
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add dbx.json
+
+          if git diff --cached --quiet; then
+            echo "Scoop manifest is already up to date."
+          else
+            git commit -m "dbx ${VERSION}"
+            git push
+            echo "::notice::Scoop manifest updated to ${VERSION}"
+          fi
+
+  upload-r2:
+    name: Upload to R2
+    runs-on: ubuntu-latest
+    steps:
+      - name: Extract version from tag
+        id: version
+        run: |
+          TAG="${{ github.event.inputs.tag }}"
+          TAG="$(echo "${TAG}" | xargs)"
+          echo "tag=${TAG}" >> "$GITHUB_OUTPUT"
+
+      - name: Download release assets
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          mkdir -p assets
+          gh release download "${{ steps.version.outputs.tag }}" \
+            --repo "${{ github.repository }}" \
+            --dir assets \
+            --clobber
+          ls -lh assets/
+
+      - name: Rewrite latest.json download URLs to R2 CDN
+        run: |
+          TAG="${{ steps.version.outputs.tag }}"
+          LATEST_JSON="assets/latest.json"
+          if [ ! -f "$LATEST_JSON" ]; then
+            echo "::warning::latest.json not found, skipping URL rewrite"
+            exit 0
+          fi
+          echo "Before:"
+          jq '.platforms[]?.url // empty' "$LATEST_JSON"
+          jq --arg tag "$TAG" '
+            (.platforms[]?.url?) |= (
+              sub("https://github\\.com/t8y2/dbx/releases/download/" + $tag + "/"; "https://dl.dbxio.com/releases/latest/")
+              + "?v=" + $tag
+            )
+          ' "$LATEST_JSON" > "$LATEST_JSON.tmp"
+          mv "$LATEST_JSON.tmp" "$LATEST_JSON"
+          echo "After:"
+          jq '.platforms[]?.url // empty' "$LATEST_JSON"
+
+      - name: Upload to R2 (versioned)
+        run: |
+          aws s3 sync ./assets "s3://${{ secrets.R2_BUCKET_NAME }}/releases/${{ steps.version.outputs.tag }}/" \
+            --endpoint-url "https://${{ secrets.R2_ACCOUNT_ID }}.r2.cloudflarestorage.com"
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
+
+      - name: Upload to R2 (latest)
+        run: |
+          aws s3 sync ./assets "s3://${{ secrets.R2_BUCKET_NAME }}/releases/latest/" \
+            --endpoint-url "https://${{ secrets.R2_ACCOUNT_ID }}.r2.cloudflarestorage.com" \
+            --cache-control "no-cache" \
+            --delete
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
+
+      - name: Purge Cloudflare cache
+        run: |
+          set -euo pipefail
+          zone_id="${CLOUDFLARE_ZONE_ID:-}"
+          if [ -z "$zone_id" ]; then
+            zone_id="$(curl -fsSL \
+              -H "Authorization: Bearer ${CLOUDFLARE_API_TOKEN}" \
+              -H "Content-Type: application/json" \
+              "https://api.cloudflare.com/client/v4/zones?name=dbxio.com" \
+              | jq -r '.result[0].id // empty')"
+          fi
+
+          if [ -z "$zone_id" ]; then
+            echo "::error::Cloudflare zone dbxio.com not found. Set CLOUDFLARE_ZONE_ID or grant Zone:Read to CLOUDFLARE_API_TOKEN."
+            exit 1
+          fi
+
+          curl -fsSL -X POST \
+            -H "Authorization: Bearer ${CLOUDFLARE_API_TOKEN}" \
+            -H "Content-Type: application/json" \
+            --data '{"purge_everything":true}' \
+            "https://api.cloudflare.com/client/v4/zones/${zone_id}/purge_cache" \
+            | jq -e '.success == true'
+        env:
+          CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          CLOUDFLARE_ZONE_ID: ${{ secrets.CLOUDFLARE_ZONE_ID }}
+
+  promote-release:
+    name: Promote to Release
+    needs: [publish, upload-r2]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Promote prerelease to release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          TAG="${{ github.event.inputs.tag }}"
+          gh release edit "${TAG}" \
+            --repo "${{ github.repository }}" \
+            --prerelease=false \
+            --latest
+          echo "::notice::Release ${TAG} promoted from prerelease to latest release"
+
+  notify-qq:
+    name: QQ Notify
+    needs: [promote-release]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Build message
+        id: msg
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ github.event.inputs.tag }}
+        run: |
+          RELEASE_JSON=$(gh release view "${TAG}" --repo "${{ github.repository }}" --json tagName,name,url,body)
+          export RELEASE_TAG=$(echo "$RELEASE_JSON" | jq -r '.tagName')
+          export RELEASE_URL=$(echo "$RELEASE_JSON" | jq -r '.url')
+          export RELEASE_BODY=$(echo "$RELEASE_JSON" | jq -r '.body')
+
+          python3 - <<'PYEOF'
+          import os, re
+
+          tag = os.environ["RELEASE_TAG"]
+          url = os.environ["RELEASE_URL"]
+          body = os.environ.get("RELEASE_BODY", "")[:800]
+
+          body = re.sub(r'#{1,6}\s*', '', body)
+          body = re.sub(r'\*\*(.+?)\*\*', r'\1', body)
+          body = re.sub(r'\*(.+?)\*', r'\1', body)
+          body = re.sub(r'`(.+?)`', r'\1', body)
+          body = re.sub(r'\[(.+?)\]\(.+?\)', r'\1', body)
+          body = re.sub(r'\n{3,}', '\n\n', body)
+          body = body.strip()
+
+          msg = "\n".join([
+              "━━━━━━━━━━━━━━━",
+              f"🚀 新版本发布  {tag}",
+              "━━━━━━━━━━━━━━━",
+              "",
+              body,
+              "",
+              f"下载: {url}",
+              "━━━━━━━━━━━━━━━",
+          ])
+
+          with open(os.environ["GITHUB_OUTPUT"], "a") as f:
+              delim = "EOF_MSG"
+              f.write(f"msg<<{delim}\n{msg}\n{delim}\n")
+          PYEOF
+
+      - name: Send to QQ group
+        env:
+          SSH_KEY: ${{ secrets.DEPLOY_SSH_KEY }}
+          HOST: ${{ secrets.DEPLOY_HOST }}
+          ASTRBOT_API_KEY: ${{ secrets.ASTRBOT_API_KEY }}
+          MSG_CONTENT: ${{ steps.msg.outputs.msg }}
+        run: |
+          mkdir -p ~/.ssh
+          echo "$SSH_KEY" > ~/.ssh/id_ed25519
+          chmod 600 ~/.ssh/id_ed25519
+          ssh-keyscan -H "$HOST" >> ~/.ssh/known_hosts 2>/dev/null
+
+          PAYLOAD=$(jq -nc --arg msg "$MSG_CONTENT" \
+            '{"umo": "default:GroupMessage:1087880322", "message": $msg}')
+          printf '%s' "$PAYLOAD" | ssh "root@${HOST}" "curl -fsS -X POST http://localhost:6185/api/v1/im/message \
+            -H 'Authorization: Bearer ${ASTRBOT_API_KEY}' \
+            -H 'Content-Type: application/json' \
+            --data-binary @-"
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..789e415
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,557 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+
+env:
+  CNB_REPOSITORY: "dbxio.com/dbx"
+  CNB_USERNAME: "cnb"
+  CNB_REGISTRY: "docker.cnb.cool"
+
+jobs:
+  bump-jdbc-plugin-version:
+    runs-on: ubuntu-latest
+    outputs:
+      changed: ${{ steps.bump.outputs.changed }}
+      old_version: ${{ steps.bump.outputs.old_version }}
+      new_version: ${{ steps.bump.outputs.new_version }}
+      prev_tag: ${{ steps.prev-tag.outputs.prev_tag }}
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Find previous release tag
+        id: prev-tag
+        shell: bash
+        run: |
+          PREV_TAG=$(git tag --sort=-creatordate | grep '^v' | sed -n '2p')
+          if [ -z "$PREV_TAG" ]; then
+            PREV_TAG=$(git rev-list --max-parents=0 HEAD)
+          fi
+          echo "prev_tag=${PREV_TAG}" >> "$GITHUB_OUTPUT"
+          echo "Comparing ${PREV_TAG}..HEAD"
+
+      - name: Detect JDBC plugin changes and bump version
+        id: bump
+        shell: bash
+        run: |
+          BUMP_OUTPUT="$(node .github/scripts/bump-jdbc-plugin-version.mjs "${{ steps.prev-tag.outputs.prev_tag }}" HEAD --write)"
+          echo "$BUMP_OUTPUT"
+          echo "$BUMP_OUTPUT" >> "$GITHUB_OUTPUT"
+
+      - name: Commit JDBC plugin version bump
+        if: steps.bump.outputs.changed == 'true'
+        shell: bash
+        run: |
+          TMP_DIR="$(mktemp -d)"
+          cp plugins/jdbc/pom.xml "$TMP_DIR/pom.xml"
+          cp plugins/jdbc/manifest.json "$TMP_DIR/manifest.json"
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git fetch origin main
+          git switch -C jdbc-plugin-version-bump origin/main
+          cp "$TMP_DIR/pom.xml" plugins/jdbc/pom.xml
+          cp "$TMP_DIR/manifest.json" plugins/jdbc/manifest.json
+          git add plugins/jdbc/pom.xml plugins/jdbc/manifest.json
+          if git diff --cached --quiet; then
+            echo "JDBC plugin version ${{ steps.bump.outputs.new_version }} is already on main."
+            exit 0
+          fi
+          git commit -m "chore(jdbc): bump plugin version [skip ci]"
+          git push origin HEAD:main
+
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: macos-latest
+            target: aarch64-apple-darwin
+          - platform: macos-15-intel
+            target: x86_64-apple-darwin
+          - platform: ubuntu-22.04
+            target: x86_64-unknown-linux-gnu
+          - platform: ubuntu-22.04-arm
+            target: aarch64-unknown-linux-gnu
+          - platform: windows-2022
+            target: x86_64-pc-windows-msvc
+            arch: x64
+          - platform: windows-2022
+            target: aarch64-pc-windows-msvc
+            arch: arm64
+
+    runs-on: ${{ matrix.platform }}
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v6
+
+      - name: Install frontend dependencies
+        run: pnpm install
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Compute Rust dependency hash
+        id: deps-hash
+        shell: bash
+        run: |
+          {
+            find . -name Cargo.toml -not -path './target/*' -print0 \
+              | sort -z \
+              | xargs -0 sed -E '/^version = /d'
+            grep -v '^version = ' Cargo.lock
+          } | sha256sum | cut -d' ' -f1 | {
+            read -r hash
+            echo "hash=${hash:0:20}" >> "$GITHUB_OUTPUT"
+          }
+
+      - name: Rust cache
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: "./ -> target"
+          shared-key: release-${{ matrix.target }}-${{ steps.deps-hash.outputs.hash }}
+          add-rust-environment-hash-key: false
+          cache-on-failure: true
+
+      - name: Install Apple certificate (macOS)
+        if: startsWith(matrix.platform, 'macos')
+        env:
+          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
+          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+        run: |
+          CERTIFICATE_PATH=$RUNNER_TEMP/certificate.p12
+          KEYCHAIN_PATH=$RUNNER_TEMP/app-signing.keychain-db
+          echo -n "$APPLE_CERTIFICATE" | base64 --decode -o $CERTIFICATE_PATH
+          security create-keychain -p "" $KEYCHAIN_PATH
+          security set-keychain-settings -lut 21600 $KEYCHAIN_PATH
+          security unlock-keychain -p "" $KEYCHAIN_PATH
+          security import $CERTIFICATE_PATH -P "$APPLE_CERTIFICATE_PASSWORD" -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
+          security set-key-partition-list -S apple-tool:,apple: -k "" $KEYCHAIN_PATH
+          security list-keychains -d user -s $KEYCHAIN_PATH login.keychain-db
+
+      - name: Install system dependencies (Linux)
+        if: startsWith(matrix.platform, 'ubuntu')
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libgtk-3-dev libappindicator3-dev librsvg2-dev patchelf libssl-dev xdg-utils
+
+      - name: Setup Tauri signing key
+        shell: bash
+        run: |
+          echo "${{ secrets.TAURI_SIGNING_PRIVATE_KEY_BASE64 }}" | base64 --decode > "$RUNNER_TEMP/updater.key"
+          KEY_B64=$(base64 < "$RUNNER_TEMP/updater.key" | tr -d '\r\n')
+          echo "TAURI_SIGNING_PRIVATE_KEY=$KEY_B64" >> "$GITHUB_ENV"
+          if [ -n "${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}" ]; then
+            echo "TAURI_SIGNING_PRIVATE_KEY_PASSWORD=${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}" >> "$GITHUB_ENV"
+          fi
+
+      - name: Generate release notes
+        id: release-notes
+        shell: bash
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          BODY="$(gh api "repos/${GITHUB_REPOSITORY}/releases/generate-notes" \
+            -f tag_name="${GITHUB_REF_NAME}" \
+            --jq '.body')"
+          if [ -z "$BODY" ]; then
+            BODY="DBX ${GITHUB_REF_NAME}"
+          fi
+          DELIM="RELEASE_NOTES_$(date +%s%N)"
+          {
+            echo "body<<$DELIM"
+            printf '%s\n' "$BODY"
+            echo "$DELIM"
+          } >> "$GITHUB_OUTPUT"
+
+      - name: Build Tauri app
+        uses: tauri-apps/tauri-action@v0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          APPLE_SIGNING_IDENTITY: ${{ startsWith(matrix.platform, 'macos') && secrets.APPLE_SIGNING_IDENTITY || '' }}
+          APPLE_ID: ${{ startsWith(matrix.platform, 'macos') && secrets.APPLE_ID || '' }}
+          APPLE_PASSWORD: ${{ startsWith(matrix.platform, 'macos') && secrets.APPLE_PASSWORD || '' }}
+          APPLE_TEAM_ID: ${{ startsWith(matrix.platform, 'macos') && secrets.APPLE_TEAM_ID || '' }}
+        with:
+          tagName: ${{ github.ref_name }}
+          releaseName: "DBX ${{ github.ref_name }}"
+          releaseBody: ${{ steps.release-notes.outputs.body }}
+          releaseDraft: true
+          prerelease: false
+          args: --target ${{ matrix.target }}
+
+      - name: Upload Windows portable ZIP
+        if: matrix.arch == 'x64' || matrix.arch == 'arm64'
+        shell: pwsh
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          $version = "${env:GITHUB_REF_NAME}".TrimStart("v")
+          $arch = "${{ matrix.arch }}"
+          $portableRoot = "portable"
+          $portableDir = Join-Path $portableRoot "DBX_${version}_${arch}"
+          $zipName = "DBX_${version}_${arch}-portable.zip"
+          $exePath = "target/${{ matrix.target }}/release/dbx.exe"
+
+          if (!(Test-Path $exePath)) {
+            Write-Error "Missing Windows executable: $exePath"
+            exit 1
+          }
+
+          New-Item -ItemType Directory -Force -Path $portableDir | Out-Null
+          Copy-Item $exePath (Join-Path $portableDir "DBX.exe") -Force
+          Copy-Item "LICENSE" (Join-Path $portableDir "LICENSE") -Force
+          Copy-Item "README.md" (Join-Path $portableDir "README.md") -Force
+          Set-Content -Path (Join-Path $portableDir "portable.dbx") -Value "" -NoNewline
+
+          Compress-Archive -Path (Join-Path $portableDir "*") -DestinationPath $zipName -Force
+          gh release upload "${env:GITHUB_REF_NAME}" $zipName --repo "${env:GITHUB_REPOSITORY}" --clobber
+
+      - name: Upload Windows WebView2 offline installer
+        if: matrix.arch == 'x64' || matrix.arch == 'arm64'
+        shell: pwsh
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          $version = "${env:GITHUB_REF_NAME}".TrimStart("v")
+          $arch = "${{ matrix.arch }}"
+          $bundleDir = "target/${{ matrix.target }}/release/bundle/nsis"
+          $offlineName = "DBX_${version}_${arch}-webview2-offline-setup.exe"
+          $before = @{}
+
+          if (Test-Path $bundleDir) {
+            Get-ChildItem $bundleDir -Filter "*.exe" | ForEach-Object { $before[$_.FullName] = $_.LastWriteTimeUtc }
+          }
+
+          pnpm tauri bundle --bundles nsis --target ${{ matrix.target }} --config src-tauri/tauri.webview2-offline.conf.json
+
+          $installer = Get-ChildItem $bundleDir -Filter "*.exe" |
+            Where-Object { !$before.ContainsKey($_.FullName) -or $_.LastWriteTimeUtc -gt $before[$_.FullName] } |
+            Sort-Object LastWriteTimeUtc -Descending |
+            Select-Object -First 1
+
+          if (!$installer) {
+            Write-Error "Missing WebView2 offline installer in ${bundleDir}"
+            exit 1
+          }
+
+          Copy-Item $installer.FullName $offlineName -Force
+          gh release upload "${env:GITHUB_REF_NAME}" $offlineName --repo "${env:GITHUB_REPOSITORY}" --clobber
+
+  cleanup-release-signatures:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Remove standalone updater signature assets
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          mapfile -t SIG_ASSETS < <(
+            gh release view "${GITHUB_REF_NAME}" \
+              --repo "${GITHUB_REPOSITORY}" \
+              --json assets \
+              --jq '.assets[].name | select(endswith(".sig"))'
+          )
+
+          if [ "${#SIG_ASSETS[@]}" -eq 0 ]; then
+            echo "No standalone .sig release assets found."
+            exit 0
+          fi
+
+          for ASSET in "${SIG_ASSETS[@]}"; do
+            echo "Deleting release asset: ${ASSET}"
+            gh release delete-asset "${GITHUB_REF_NAME}" "${ASSET}" \
+              --repo "${GITHUB_REPOSITORY}" \
+              --yes
+          done
+
+  jdbc-plugin:
+    needs: [cleanup-release-signatures, bump-jdbc-plugin-version]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Setup Java
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: "17"
+          cache: maven
+
+      - name: Apply automatic JDBC plugin version bump
+        shell: bash
+        run: node .github/scripts/bump-jdbc-plugin-version.mjs "${{ needs.bump-jdbc-plugin-version.outputs.prev_tag }}" HEAD --write
+
+      - name: Read JDBC plugin version
+        id: jdbc-plugin
+        shell: bash
+        run: |
+          VERSION="$(grep -m1 '<version>' plugins/jdbc/pom.xml | sed -E 's/.*<version>([^<]+)<.*/\1/')"
+          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
+
+      - name: Package JDBC plugin
+        run: ./plugins/jdbc/package.sh
+
+      - name: Upload JDBC plugin asset
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release upload "${GITHUB_REF_NAME}" \
+            "plugins/jdbc/dist/dbx-jdbc-plugin-${{ steps.jdbc-plugin.outputs.version }}.zip" \
+            "plugins/jdbc/dist/dbx-jdbc-plugin-latest.zip" \
+            --repo "${GITHUB_REPOSITORY}" \
+            --clobber
+
+      - name: Add JDBC plugin metadata to latest.json
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          mkdir -p "$RUNNER_TEMP/latest-json"
+          gh release download "${GITHUB_REF_NAME}" \
+            --repo "${GITHUB_REPOSITORY}" \
+            --pattern latest.json \
+            --dir "$RUNNER_TEMP/latest-json"
+          node .github/scripts/augment-latest-json-jdbc-plugin.mjs \
+            "$RUNNER_TEMP/latest-json/latest.json" \
+            "${{ steps.jdbc-plugin.outputs.version }}" \
+            "1" \
+            "https://github.com/t8y2/dbx/releases/latest/download/dbx-jdbc-plugin-latest.zip"
+          gh release upload "${GITHUB_REF_NAME}" \
+            "$RUNNER_TEMP/latest-json/latest.json" \
+            --repo "${GITHUB_REPOSITORY}" \
+            --clobber
+
+  publish:
+    needs: [cleanup-release-signatures, docker-manifest, jdbc-plugin]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Publish draft release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh release edit ${{ github.ref_name }} --repo ${{ github.repository }} --draft=false --prerelease
+
+  sync-release-to-cnb:
+    name: Sync release to CNB
+    needs: publish
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+
+      - name: Download GitHub release assets
+        env:
+          TAG_NAME: ${{ github.ref_name }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          set -euo pipefail
+          mkdir -p "$RUNNER_TEMP/github-release" "$RUNNER_TEMP/release-assets"
+          gh release view "$TAG_NAME" \
+            --repo "$GITHUB_REPOSITORY" \
+            --json tagName,name,body,targetCommitish,isPrerelease,isDraft,assets \
+            > "$RUNNER_TEMP/github-release/release.json"
+          gh release download "$TAG_NAME" \
+            --repo "$GITHUB_REPOSITORY" \
+            --dir "$RUNNER_TEMP/release-assets" \
+            --clobber
+
+      - name: Sync release assets to CNB
+        env:
+          CNB_TOKEN: ${{ secrets.CNB_TOKEN }}
+          CNB_UPLOAD_CONCURRENCY: "3"
+        run: |
+          node .github/scripts/sync-cnb-release.mjs \
+            --github-release "$RUNNER_TEMP/github-release/release.json" \
+            --assets-dir "$RUNNER_TEMP/release-assets"
+
+  sync-release-to-atomgit:
+    name: Sync release to AtomGit
+    needs: publish
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Ensure AtomGit tag exists
+        env:
+          TAG_NAME: ${{ github.ref_name }}
+          ATOMGIT_TOKEN: ${{ secrets.ATOMGIT_TOKEN }}
+        run: |
+          set -euo pipefail
+          git fetch origin "refs/tags/${TAG_NAME}:refs/tags/${TAG_NAME}" --force
+          git remote add atomgit "https://t8y2:${ATOMGIT_TOKEN}@atomgit.com/t8y2/dbx.git"
+          git push atomgit "refs/tags/${TAG_NAME}:refs/tags/${TAG_NAME}" --force
+
+      - name: Download GitHub release assets
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG_NAME: ${{ github.ref_name }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+        run: |
+          set -euo pipefail
+          mkdir -p "$RUNNER_TEMP/github-release" "$RUNNER_TEMP/release-assets"
+          gh release view "$TAG_NAME" \
+            --repo "$GITHUB_REPOSITORY" \
+            --json tagName,name,body,targetCommitish,isPrerelease,isDraft,assets \
+            > "$RUNNER_TEMP/github-release/release.json"
+          gh release download "$TAG_NAME" \
+            --repo "$GITHUB_REPOSITORY" \
+            --dir "$RUNNER_TEMP/release-assets" \
+            --clobber
+
+      - name: Sync release assets to AtomGit
+        env:
+          ATOMGIT_TOKEN: ${{ secrets.ATOMGIT_TOKEN }}
+          ATOMGIT_REPOSITORY: "t8y2/dbx"
+          # AtomGit throttles concurrent large-asset uploads, which can expire their temporary upload URLs.
+          ATOMGIT_UPLOAD_CONCURRENCY: "1"
+        run: |
+          set -euo pipefail
+          node .github/scripts/sync-atomgit-release.mjs \
+            --github-release "$RUNNER_TEMP/github-release/release.json" \
+            --assets-dir "$RUNNER_TEMP/release-assets"
+
+  docker:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [linux/amd64, linux/arm64]
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to CNB Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.CNB_REGISTRY }}
+          username: cnb
+          password: ${{ secrets.CNB_TOKEN }}
+
+      - name: Build and push Docker Hub by digest
+        id: build-dockerhub
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: deploy/Dockerfile
+          platforms: ${{ matrix.platform }}
+          outputs: type=image,name=${{ secrets.DOCKERHUB_USERNAME }}/dbx,push-by-digest=true,name-canonical=true,push=true
+          cache-from: type=gha,scope=${{ matrix.platform }}
+          cache-to: type=gha,scope=${{ matrix.platform }},mode=max
+
+      - name: Build and push CNB by digest
+        id: build-cnb
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: deploy/Dockerfile
+          platforms: ${{ matrix.platform }}
+          outputs: type=image,name=${{ env.CNB_REGISTRY }}/${{ env.CNB_REPOSITORY }},push-by-digest=true,name-canonical=true,push=true
+          cache-from: type=gha,scope=${{ matrix.platform }}
+
+      - name: Export digests
+        run: |
+          mkdir -p /tmp/digests/dockerhub /tmp/digests/cnb
+          dockerhub_digest="${{ steps.build-dockerhub.outputs.digest }}"
+          cnb_digest="${{ steps.build-cnb.outputs.digest }}"
+          touch "/tmp/digests/dockerhub/${dockerhub_digest#sha256:}"
+          touch "/tmp/digests/cnb/${cnb_digest#sha256:}"
+
+      - name: Upload Docker Hub digest
+        uses: actions/upload-artifact@v7
+        with:
+          name: dockerhub-digests-${{ matrix.platform == 'linux/amd64' && 'amd64' || 'arm64' }}
+          path: /tmp/digests/dockerhub/*
+          if-no-files-found: error
+          retention-days: 1
+
+      - name: Upload CNB digest
+        uses: actions/upload-artifact@v7
+        with:
+          name: cnb-digests-${{ matrix.platform == 'linux/amd64' && 'amd64' || 'arm64' }}
+          path: /tmp/digests/cnb/*
+          if-no-files-found: error
+          retention-days: 1
+
+  docker-manifest:
+    needs: docker
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download Docker Hub digests
+        uses: actions/download-artifact@v8
+        with:
+          path: /tmp/digests/dockerhub
+          pattern: dockerhub-digests-*
+          merge-multiple: true
+
+      - name: Download CNB digests
+        uses: actions/download-artifact@v8
+        with:
+          path: /tmp/digests/cnb
+          pattern: cnb-digests-*
+          merge-multiple: true
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to CNB Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.CNB_REGISTRY }}
+          username: cnb
+          password: ${{ secrets.CNB_TOKEN }}
+
+      - name: Extract version from tag
+        id: version
+        run: echo "version=${GITHUB_REF_NAME#v}" >> "$GITHUB_OUTPUT"
+
+      - name: Create manifest list and push
+        run: |
+          docker buildx imagetools create \
+            -t ${{ secrets.DOCKERHUB_USERNAME }}/dbx:${{ steps.version.outputs.version }} \
+            -t ${{ secrets.DOCKERHUB_USERNAME }}/dbx:latest \
+            $(cd /tmp/digests/dockerhub && printf '${{ secrets.DOCKERHUB_USERNAME }}/dbx@sha256:%s ' *)
+
+          docker buildx imagetools create \
+            -t ${{ env.CNB_REGISTRY }}/${{ env.CNB_REPOSITORY }}:${{ steps.version.outputs.version }} \
+            -t ${{ env.CNB_REGISTRY }}/${{ env.CNB_REPOSITORY }}:latest \
+            $(cd /tmp/digests/cnb && printf '${{ env.CNB_REGISTRY }}/${{ env.CNB_REPOSITORY }}@sha256:%s ' *)
diff --git a/.github/workflows/spam-comment-guard.yml b/.github/workflows/spam-comment-guard.yml
new file mode 100644
index 0000000..0567844
--- /dev/null
+++ b/.github/workflows/spam-comment-guard.yml
@@ -0,0 +1,41 @@
+name: Spam Comment Guard
+
+on:
+  issue_comment:
+    types: [created]
+
+# 用 PROJECT_AUTOMATION_TOKEN（owner PAT）调 DELETE，GITHUB_TOKEN 本身无需写权限
+permissions:
+  contents: read
+
+jobs:
+  delete-malicious-link:
+    runs-on: ubuntu-latest
+    # 跳过机器人与仓库 owner，避免误删维护者的正当评论
+    if: ${{ github.event.comment.user.type != 'Bot' && github.event.comment.user.login != github.repository_owner }}
+    env:
+      # owner PAT：GITHUB_TOKEN 非 admin 删不掉别人的评论，必须用 owner 令牌
+      GH_TOKEN: ${{ secrets.PROJECT_AUTOMATION_TOKEN }}
+      COMMENT_ID: ${{ github.event.comment.id }}
+      COMMENT_BODY: ${{ github.event.comment.body }}
+      COMMENT_USER: ${{ github.event.comment.user.login }}
+      ISSUE_URL: ${{ github.event.issue.html_url }}
+      REPO: ${{ github.repository }}
+    steps:
+      - name: Delete comment containing malicious attachment link
+        run: |
+          set -euo pipefail
+
+          # 命中外部恶意附件链接即删除评论。两条分支：
+          #   1) 外部 http(s) 直链 .zip（排除 GitHub 自有域名的 release/archive/raw/attachments）
+          #   2) markdown 链接文本以 .zip/.exe/.scr/.7z 结尾且指向外部域名——
+          #      规避手法常把 .zip 放链接文本、URL 用 // 协议相对或 %2E 编码域名
+          # 如需扩展扩展名，修改下方两处列表即可。
+          if ! printf '%s' "$COMMENT_BODY" | grep -qiP 'https?://(?!(?:github\.com|[^/]*\.githubusercontent\.com)/)[^[:space:]<>"]+\.zip([?#][^[:space:]<>"]*)?|\[[^\]]*\.(zip|7z|exe|scr)\]\((?!(?:https?:)?//(?:github\.com|[^/]*\.githubusercontent\.com)/)[^)]*\)'; then
+            echo "No malicious attachment link detected, skipping"
+            exit 0
+          fi
+
+          echo "Detected malicious attachment link in comment by @$COMMENT_USER on $ISSUE_URL — deleting"
+          # 物理删除评论，内容对所有人不可见。DELETE 返回 204 无响应体。
+          gh api -X DELETE "repos/${REPO}/issues/comments/${COMMENT_ID}"
diff --git a/.github/workflows/sync-atomgit-release-assets.yml b/.github/workflows/sync-atomgit-release-assets.yml
new file mode 100644
index 0000000..4c6e87c
--- /dev/null
+++ b/.github/workflows/sync-atomgit-release-assets.yml
@@ -0,0 +1,62 @@
+name: Sync AtomGit Release Assets
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release tag to sync"
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+env:
+  ATOMGIT_REPOSITORY: "t8y2/dbx"
+
+jobs:
+  sync-release-to-atomgit:
+    name: Sync release to AtomGit
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Ensure AtomGit tag exists
+        env:
+          TAG_NAME: ${{ inputs.tag }}
+          ATOMGIT_TOKEN: ${{ secrets.ATOMGIT_TOKEN }}
+        run: |
+          set -euo pipefail
+          git fetch origin "refs/tags/${TAG_NAME}:refs/tags/${TAG_NAME}" --force
+          git remote add atomgit "https://t8y2:${ATOMGIT_TOKEN}@atomgit.com/t8y2/dbx.git"
+          git push atomgit "refs/tags/${TAG_NAME}:refs/tags/${TAG_NAME}" --force
+
+      - name: Download GitHub release assets
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG_NAME: ${{ inputs.tag }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+        run: |
+          set -euo pipefail
+          mkdir -p "$RUNNER_TEMP/github-release" "$RUNNER_TEMP/release-assets"
+          gh release view "$TAG_NAME" \
+            --repo "$GITHUB_REPOSITORY" \
+            --json tagName,name,body,targetCommitish,isPrerelease,isDraft,assets \
+            > "$RUNNER_TEMP/github-release/release.json"
+          gh release download "$TAG_NAME" \
+            --repo "$GITHUB_REPOSITORY" \
+            --dir "$RUNNER_TEMP/release-assets" \
+            --clobber
+
+      - name: Sync release assets to AtomGit
+        env:
+          ATOMGIT_TOKEN: ${{ secrets.ATOMGIT_TOKEN }}
+          ATOMGIT_REPOSITORY: ${{ env.ATOMGIT_REPOSITORY }}
+        run: |
+          set -euo pipefail
+          node .github/scripts/sync-atomgit-release.mjs \
+            --github-release "$RUNNER_TEMP/github-release/release.json" \
+            --assets-dir "$RUNNER_TEMP/release-assets"
diff --git a/.github/workflows/sync-changelog.yml b/.github/workflows/sync-changelog.yml
new file mode 100644
index 0000000..009d02d
--- /dev/null
+++ b/.github/workflows/sync-changelog.yml
@@ -0,0 +1,46 @@
+name: Sync Changelog to R2
+
+on:
+  workflow_run:
+    workflows: ["Publish Packages"]
+    types: [completed]
+  workflow_dispatch:
+
+jobs:
+  sync:
+    if: github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 22
+
+      - name: Generate changelog JSON
+        run: node .github/scripts/sync-changelog.mjs
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          DEEPSEEK_API_KEY: ${{ secrets.DEEPSEEK_API_KEY }}
+
+      - name: Upload to R2
+        run: |
+          pip install awscli --quiet
+          aws s3 cp releases-cn.json "s3://${R2_BUCKET_NAME}/changelog/releases-cn.json" \
+            --endpoint-url "https://${R2_ACCOUNT_ID}.r2.cloudflarestorage.com" \
+            --content-type application/json
+          if [ -f releases-en.json ]; then
+            aws s3 cp releases-en.json "s3://${R2_BUCKET_NAME}/changelog/releases-en.json" \
+              --endpoint-url "https://${R2_ACCOUNT_ID}.r2.cloudflarestorage.com" \
+              --content-type application/json
+          fi
+          if [ -f latest-en.json ]; then
+            aws s3 cp latest-en.json "s3://${R2_BUCKET_NAME}/changelog/latest-en.json" \
+              --endpoint-url "https://${R2_ACCOUNT_ID}.r2.cloudflarestorage.com" \
+              --content-type application/json
+          fi
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.R2_ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.R2_SECRET_ACCESS_KEY }}
+          R2_ACCOUNT_ID: ${{ secrets.R2_ACCOUNT_ID }}
+          R2_BUCKET_NAME: ${{ secrets.R2_BUCKET_NAME }}
diff --git a/.github/workflows/sync-cnb-release-assets.yml b/.github/workflows/sync-cnb-release-assets.yml
new file mode 100644
index 0000000..ddea29b
--- /dev/null
+++ b/.github/workflows/sync-cnb-release-assets.yml
@@ -0,0 +1,40 @@
+name: Sync CNB Release Assets
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release tag to sync"
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+env:
+  CNB_REPOSITORY: "dbxio.com/dbx"
+
+jobs:
+  sync-release-to-cnb:
+    name: Sync release to CNB
+    runs-on: ubuntu-latest
+    steps:
+      - name: Sync release assets to CNB
+        env:
+          TAG_NAME: ${{ inputs.tag }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          GITHUB_USERNAME: ${{ github.repository_owner }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          CNB_USERNAME: cnb
+          CNB_TOKEN: ${{ secrets.CNB_TOKEN }}
+        run: |
+          set -euo pipefail
+
+          wget -q https://cnb.cool/znb/mpgrm/-/releases/download/v0.1.0/mpgrm_linux_amd64.tar.gz
+          tar -xf mpgrm_linux_amd64.tar.gz
+          chmod +x mpgrm
+
+          ./mpgrm releases sync \
+            --repo "https://github.com/${GITHUB_REPOSITORY}.git" \
+            --target-repo "https://cnb.cool/${CNB_REPOSITORY}.git" \
+            --tags "${TAG_NAME}"
diff --git a/.github/workflows/sync-mirrors.yml b/.github/workflows/sync-mirrors.yml
new file mode 100644
index 0000000..3dfd21e
--- /dev/null
+++ b/.github/workflows/sync-mirrors.yml
@@ -0,0 +1,80 @@
+name: Sync Mirrors
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - "**"
+  delete:
+  workflow_dispatch:
+
+# Mirror providers reject concurrent forced updates to the same ref. Serialize all
+# branch, tag, and delete events so rapid GitHub pushes cannot race each other.
+concurrency:
+  group: sync-mirrors
+  cancel-in-progress: false
+
+jobs:
+  sync-cnb:
+    name: Sync to CNB
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Push to CNB
+        env:
+          CNB_TOKEN: ${{ secrets.CNB_TOKEN }}
+        run: |
+          set -euo pipefail
+          git remote add cnb "https://cnb:${CNB_TOKEN}@cnb.cool/dbxio.com/dbx.git"
+          git push cnb --all --force
+          if [ "${GITHUB_REF_TYPE}" = "tag" ]; then
+            git push cnb ":refs/tags/${GITHUB_REF_NAME}" || true
+          fi
+          git push cnb --tags --force
+
+  sync-atomgit:
+    name: Sync to AtomGit
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Push to AtomGit
+        env:
+          ATOMGIT_TOKEN: ${{ secrets.ATOMGIT_TOKEN }}
+        run: |
+          set -euo pipefail
+          git remote add atomgit "https://t8y2:${ATOMGIT_TOKEN}@atomgit.com/t8y2/dbx.git"
+          git push atomgit --all --force
+          if [ "${GITHUB_REF_TYPE}" = "tag" ]; then
+            git push atomgit ":refs/tags/${GITHUB_REF_NAME}" || true
+          fi
+          git push atomgit --tags --force
+
+  sync-gitee:
+    name: Sync to Gitee
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Push to Gitee
+        env:
+          GITEE_TOKEN: ${{ secrets.GITEE_TOKEN }}
+        run: |
+          set -euo pipefail
+          git remote add gitee "https://codetty:${GITEE_TOKEN}@gitee.com/codetty/dbx.git"
+          git push gitee --all --force
+          if [ "${GITHUB_REF_TYPE}" = "tag" ]; then
+            git push gitee ":refs/tags/${GITHUB_REF_NAME}" || true
+          fi
+          git push gitee --tags --force
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..880af71
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,66 @@
+# Dependencies
+node_modules/
+.claude/
+.codex/
+.superpowers/
+.trellis/
+.worktrees/
+openspec/
+.mcp.json
+AGENTS.md
+CLAUDE.md
+
+# Build output
+dist/
+coverage/
+/target/
+plugins/jdbc/target/
+plugins/jdbc/dependency-reduced-pom.xml
+plugins/jdbc/lib/*.jar
+plugins/jdbc/dist/
+docs/.next/
+docs/out/
+docs/.source/
+docs/superpowers/
+src-tauri/*.dylib
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Editor
+*.swp
+*.swo
+*~
+.vscode/
+.idea/
+
+# GitHub (keep workflows)
+.github/*
+!.github/workflows/
+!.github/scripts/
+!.github/ISSUE_TEMPLATE/
+
+# Env
+.env
+.env.*
+!.env.example
+
+# Temp
+tmp/
+
+# Logs
+*.log
+
+
+# Generated changelog data
+releases-*.json
+latest-en.json
+
+test.pdb
+portable/
+DBX_*_x64-portable.zip
+.agents/skills
+.pnpm-store/*
+.dbx-web
+_dev
diff --git a/.husky/pre-commit b/.husky/pre-commit
new file mode 100755
index 0000000..a8d5342
--- /dev/null
+++ b/.husky/pre-commit
@@ -0,0 +1,20 @@
+pnpm exec lint-staged
+
+# Only format and re-add Rust files that are already staged
+TOPLEVEL=$(git rev-parse --show-toplevel)
+
+format_staged_rust() {
+  dir="$1"
+  staged=$(git diff --staged --name-only --diff-filter=ACM -- "$dir" | grep '\.rs$' || true)
+  if [ -n "$staged" ]; then
+    echo "Formatting staged Rust files in $dir"
+    cargo fmt --manifest-path "$TOPLEVEL/$dir/Cargo.toml"
+    echo "$staged" | while IFS= read -r f; do
+      git add "$TOPLEVEL/$f" 2>/dev/null || true
+    done
+  fi
+}
+
+format_staged_rust "src-tauri"
+format_staged_rust "crates/dbx-core"
+format_staged_rust "crates/dbx-web"
diff --git a/.nvmrc b/.nvmrc
new file mode 100644
index 0000000..6fa8dec
--- /dev/null
+++ b/.nvmrc
@@ -0,0 +1 @@
+22.13.0
diff --git a/.oxfmtrc.json b/.oxfmtrc.json
new file mode 100644
index 0000000..660b096
--- /dev/null
+++ b/.oxfmtrc.json
@@ -0,0 +1,9 @@
+{
+  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+  "printWidth": 300,
+  "tabWidth": 2,
+  "singleQuote": false,
+  "trailingComma": "all",
+  "bracketSpacing": true,
+  "arrowParens": "always"
+}
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..959b663
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,143 @@
+# Contributing to DBX
+
+Thanks for taking a look at DBX. Whether you fix a typo, improve docs, or tackle a database-specific bug, every PR helps.
+
+## Where to Start
+
+1. Browse [open issues](https://github.com/t8y2/dbx/issues). Good first targets are labeled `documentation`, `good first issue`, or issues in a database you already use.
+2. Comment on the issue you want to work on. Say what you plan to do so others do not duplicate the effort. For community issues, you can also comment `/claim` when that workflow is enabled.
+3. Fork the repo, create a branch, and open a PR against `main`.
+
+If you are not sure what to pick, documentation and small UX fixes are a solid first contribution. See [examples/](examples/) and the [official docs](https://dbxio.com/en/docs/what-is-dbx) for the current structure.
+
+## Development Setup
+
+### Prerequisites
+
+- Node.js >= 22.13.0
+- pnpm 10.27.0
+- Rust >= 1.77
+- Make
+
+Linux desktop builds also need WebKit/GTK packages. See [README.md](README.md#getting-started) for the exact commands.
+
+### Run Locally
+
+```bash
+git clone https://github.com/t8y2/dbx.git
+cd dbx
+make
+```
+
+`make` installs dependencies when needed and starts the Tauri desktop dev environment.
+
+Useful shortcuts:
+
+```bash
+make dev-fast          # skip DuckDB during local dev
+make dev-web           # frontend only
+make dev-backend       # web backend only
+make docs              # preview the documentation site
+make cargo-check-fast  # fast Rust checks
+```
+
+### JDBC Agent Drivers
+
+Agent driver projects live under `agents/`. Java/JDBC driver builds and tests require JDK 21; Gradle can auto-download the toolchain when available.
+
+```bash
+cd agents
+./gradlew test
+```
+
+## Project Layout
+
+| Path | Purpose |
+| --- | --- |
+| `src/` | Vue frontend |
+| `src-tauri/` | Tauri desktop shell and command layer |
+| `crates/dbx-core/` | Shared Rust database logic |
+| `crates/dbx-web/` | Docker / Web HTTP backend |
+| `packages/cli/` | `@dbx-app/cli` |
+| `packages/mcp-server/` | `@dbx-app/mcp-server` |
+| `packages/node-core/` | Shared Node.js bridge and direct-query logic |
+| `docs/` | Official documentation site |
+| `examples/` | Sample configs and automation scripts |
+| `agents/` | JDBC agent driver projects |
+
+## Making Changes
+
+### Branch Naming
+
+Use a short descriptive branch name, for example:
+
+- `docs/web-api-reference`
+- `fix/mysql-connection-timeout`
+- `feat/redis-key-search`
+
+### Scope
+
+Keep PRs focused. A docs-only PR should not include unrelated code changes. A bug fix should not also refactor nearby modules unless that refactor is required for the fix.
+
+### Commits
+
+Write commit messages in plain language:
+
+- `docs: add web API reference for Docker deployments`
+- `fix(redis): handle empty scan cursor`
+- `feat(schema): show catalog info for Doris`
+
+### Tests
+
+Run the checks that match your change:
+
+```bash
+make cargo-check-fast
+make cargo-test-fast
+pnpm test
+```
+
+For frontend or package changes, run the relevant package tests under `packages/` or `packages/app-tests/`.
+
+### Documentation
+
+User-facing docs live in two places:
+
+- Repository docs: `README.md`, `CONTRIBUTING.md`, package READMEs, and `examples/`
+- Website docs: `docs/content/docs/`
+
+If you add a new docs page under `docs/content/docs/`, register it in:
+
+- `docs/content/docs/meta.json`
+- `docs/content/docs/meta.cn.json`
+
+Preview locally with:
+
+```bash
+make docs
+```
+
+## Pull Requests
+
+1. Push your branch to your fork.
+2. Open a PR against `https://github.com/t8y2/dbx` `main`.
+3. Link the related issue in the PR description.
+4. Explain what changed, how you tested it, and any screenshots if the UI changed.
+
+Small PRs are easier to review and merge.
+
+## What We Are Looking For
+
+- Documentation improvements and translations
+- Reproducible bug fixes with clear before/after behavior
+- Database-specific fixes where you can verify against a real instance
+- Tests for non-trivial logic changes
+- Examples that show CLI, MCP, Docker, or Web API usage
+
+## Community
+
+- [Discord](https://discord.gg/W7NyVDRt6a)
+- [GitHub Issues](https://github.com/t8y2/dbx/issues)
+- [Official docs](https://dbxio.com/en/docs/what-is-dbx)
+
+Merged contributors appear on the [DBX contributors wall](https://dbxio.com/en/community).
diff --git a/CONTRIBUTING.zh-CN.md b/CONTRIBUTING.zh-CN.md
new file mode 100644
index 0000000..29f398a
--- /dev/null
+++ b/CONTRIBUTING.zh-CN.md
@@ -0,0 +1,143 @@
+# 参与 DBX 贡献
+
+感谢你愿意花时间了解 DBX。不管是改一个错别字、补文档，还是修某个数据库相关的问题，都很有价值。
+
+## 从哪里开始
+
+1. 浏览 [Issues](https://github.com/t8y2/dbx/issues)。优先看 `documentation`、`good first issue`，或者你手头正好有测试环境的数据库相关问题。
+2. 在 Issue 下留言说明你想做什么，避免重复劳动。部分社区 Issue 也支持评论 `/claim` 来认领。
+3. Fork 仓库，新建分支开发，然后向 `main` 提 PR。
+
+如果暂时不确定做什么，文档和小体验修复很适合第一次贡献。可以先看 [examples/](examples/) 和[官方文档](https://dbxio.com/cn/docs/what-is-dbx) 熟悉项目结构。
+
+## 开发环境
+
+### 环境要求
+
+- Node.js >= 22.13.0
+- pnpm 10.27.0
+- Rust >= 1.77
+- Make
+
+Linux 桌面端还需要 WebKit/GTK 相关依赖，具体命令见 [README.zh-CN.md](README.zh-CN.md#快速开始)。
+
+### 本地运行
+
+```bash
+git clone https://github.com/t8y2/dbx.git
+cd dbx
+make
+```
+
+`make` 会在需要时安装依赖，并启动 Tauri 桌面端开发环境。
+
+常用命令：
+
+```bash
+make dev-fast          # 本地开发跳过 DuckDB
+make dev-web           # 只启动前端
+make dev-backend       # 只启动 Web 后端
+make docs              # 本地预览文档站
+make cargo-check-fast  # 快速 Rust 检查
+```
+
+### JDBC Agent 驱动
+
+Agent 驱动工程在 `agents/` 目录。Java/JDBC 驱动构建和测试需要 JDK 21；环境允许时 Gradle 可以自动下载对应 toolchain。
+
+```bash
+cd agents
+./gradlew test
+```
+
+## 项目结构
+
+| 路径 | 说明 |
+| --- | --- |
+| `src/` | Vue 前端 |
+| `src-tauri/` | Tauri 桌面端壳层与命令层 |
+| `crates/dbx-core/` | 共享 Rust 数据库逻辑 |
+| `crates/dbx-web/` | Docker / Web HTTP 后端 |
+| `packages/cli/` | `@dbx-app/cli` |
+| `packages/mcp-server/` | `@dbx-app/mcp-server` |
+| `packages/node-core/` | Node.js bridge 与直连查询逻辑 |
+| `docs/` | 官方文档站 |
+| `examples/` | 配置与自动化示例 |
+| `agents/` | JDBC Agent 驱动工程 |
+
+## 开发约定
+
+### 分支命名
+
+分支名尽量简短明确，例如：
+
+- `docs/web-api-reference`
+- `fix/mysql-connection-timeout`
+- `feat/redis-key-search`
+
+### 控制改动范围
+
+一个 PR 只做一类事。文档 PR 不要夹带无关代码；修 Bug 时也不要顺手大重构，除非重构是修复所必需的。
+
+### 提交说明
+
+提交信息用自然语言写清楚即可：
+
+- `docs: add web API reference for Docker deployments`
+- `fix(redis): handle empty scan cursor`
+- `feat(schema): show catalog info for Doris`
+
+### 测试
+
+按改动范围跑对应检查：
+
+```bash
+make cargo-check-fast
+make cargo-test-fast
+pnpm test
+```
+
+如果改的是前端或某个 package，再补跑对应目录下的测试。
+
+### 文档
+
+用户文档主要分两块：
+
+- 仓库内文档：`README.md`、`CONTRIBUTING.md`、各 package README、`examples/`
+- 官网文档：`docs/content/docs/`
+
+如果在 `docs/content/docs/` 新增页面，记得同步更新：
+
+- `docs/content/docs/meta.json`
+- `docs/content/docs/meta.cn.json`
+
+本地预览：
+
+```bash
+make docs
+```
+
+## 提 PR
+
+1. 把分支推到你自己的 Fork。
+2. 向 `https://github.com/t8y2/dbx` 的 `main` 提 PR。
+3. 在 PR 描述里关联相关 Issue。
+4. 写清楚改了什么、怎么验证的；如果涉及 UI，附上截图。
+
+改动越小，越容易 review 和合并。
+
+## 欢迎的贡献类型
+
+- 文档改进与翻译
+- 可复现、行为清晰的 Bug 修复
+- 你有真实测试环境的数据库专项修复
+- 非平凡逻辑的测试补充
+- CLI、MCP、Docker、Web API 的使用示例
+
+## 社区
+
+- [Discord](https://discord.gg/W7NyVDRt6a)
+- [GitHub Issues](https://github.com/t8y2/dbx/issues)
+- [官方文档](https://dbxio.com/cn/docs/what-is-dbx)
+
+合并后的贡献者会出现在 [DBX 贡献墙](https://dbxio.com/cn/community)。
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..10c7ac6
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,10781 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common 0.1.7",
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "aead"
+version = "0.6.0-rc.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b657e772794c6b04730ea897b66a058ccd866c16d1967da05eeeecec39043fe"
+dependencies = [
+ "crypto-common 0.2.2",
+ "inout 0.2.2",
+]
+
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher 0.4.4",
+ "cpufeatures 0.2.17",
+]
+
+[[package]]
+name = "aes"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66bd29a732b644c0431c6140f370d097879203d79b80c94a6747ba0872adaef8"
+dependencies = [
+ "cipher 0.5.2",
+ "cpubits",
+ "cpufeatures 0.3.0",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
+dependencies = [
+ "aead 0.5.2",
+ "aes 0.8.4",
+ "cipher 0.4.4",
+ "ctr 0.9.2",
+ "ghash 0.5.1",
+ "subtle",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.11.0-rc.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22c0c90bbe8d4f77c3ca9ddabe41a1f8382d6fc1f7cea89459d0f320371f972"
+dependencies = [
+ "aead 0.6.0-rc.10",
+ "aes 0.9.0",
+ "cipher 0.5.2",
+ "ctr 0.10.1",
+ "ghash 0.6.0",
+ "subtle",
+]
+
+[[package]]
+name = "ahash"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
+dependencies = [
+ "getrandom 0.2.17",
+ "once_cell",
+ "version_check",
+]
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "const-random",
+ "getrandom 0.3.4",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "android_log-sys"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84521a3cf562bc62942e294181d9eef17eb38ceb8c68677bc49f144e4c3d4f8d"
+
+[[package]]
+name = "android_logger"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbb4e440d04be07da1f1bf44fb4495ebd58669372fe0cffa6e48595ac5bd88a3"
+dependencies = [
+ "android_log-sys",
+ "env_filter",
+ "log",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "ar_archive_writer"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7eb93bbb63b9c227414f6eb3a0adfddca591a8ce1e9b60661bb08969b87e340b"
+dependencies = [
+ "object",
+]
+
+[[package]]
+name = "arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+dependencies = [
+ "derive_arbitrary",
+]
+
+[[package]]
+name = "arboard"
+version = "3.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0348a1c054491f4bfe6ab86a7b6ab1e44e45d899005de92f58b3df180b36ddaf"
+dependencies = [
+ "clipboard-win",
+ "image",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "parking_lot",
+ "percent-encoding",
+ "windows-sys 0.60.2",
+ "wl-clipboard-rs",
+ "x11rb",
+]
+
+[[package]]
+name = "argon2"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c3610892ee6e0cbce8ae2700349fcf8f98adb0dbfbee85aec3c9179d29cc072"
+dependencies = [
+ "base64ct",
+ "blake2",
+ "cpufeatures 0.2.17",
+ "password-hash",
+]
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "arrow"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "378530e55cd479eda3c14eb345310799717e6f76d0c332041e8487022166b471"
+dependencies = [
+ "arrow-arith",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-data",
+ "arrow-ord",
+ "arrow-row",
+ "arrow-schema",
+ "arrow-select",
+ "arrow-string",
+]
+
+[[package]]
+name = "arrow-arith"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0ab212d2c1886e802f51c5212d78ebbcbb0bec980fff9dadc1eb8d45cd0b738"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-array"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfd33d3e92f207444098c75b42de99d329562be0cf686b307b097cc52b4e999e"
+dependencies = [
+ "ahash 0.8.12",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "half",
+ "hashbrown 0.17.1",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-buffer"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c6cd424c2693bcdbc150d843dc9d4d137dd2de4782ce6df491ad11a3a0416c0"
+dependencies = [
+ "bytes",
+ "half",
+ "num-bigint",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-cast"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c5aefb56a2c02e9e2b30746241058b85f8983f0fcff2ba0c6d09006e1cded7f"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-ord",
+ "arrow-schema",
+ "arrow-select",
+ "atoi",
+ "base64 0.22.1",
+ "chrono",
+ "comfy-table",
+ "half",
+ "lexical-core",
+ "num-traits",
+ "ryu",
+]
+
+[[package]]
+name = "arrow-data"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c88210023a2bfee1896af366309a3028fc3bcbd6515fa29a7990ee1baa08ee0"
+dependencies = [
+ "arrow-buffer",
+ "arrow-schema",
+ "half",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-ord"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bffd8fd2579286a5d63bac898159873e5094a79009940bcb42bbfce4f19f1d0"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+]
+
+[[package]]
+name = "arrow-row"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bab5994731204603c73ba69267616c50f80780774c6bb0476f1f830625115e0c"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "half",
+]
+
+[[package]]
+name = "arrow-schema"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f633dbfdf39c039ada1bf9e34c694816eb71fbb7dc78f613993b7245e078a1ed"
+dependencies = [
+ "bitflags 2.11.1",
+]
+
+[[package]]
+name = "arrow-select"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cd065c54172ac787cf3f2f8d4107e0d3fdc26edba76fdf4f4cc170258942222"
+dependencies = [
+ "ahash 0.8.12",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-string"
+version = "58.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29dd7cda3ab9692f43a2e4acc444d760cc17b12bb6d8232ddf64e9bab7c06b42"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+ "memchr",
+ "num-traits",
+ "regex",
+ "regex-syntax",
+]
+
+[[package]]
+name = "async-broadcast"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
+dependencies = [
+ "event-listener",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-channel"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
+dependencies = [
+ "concurrent-queue",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-compression"
+version = "0.4.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e79b3f8a79cccc2898f31920fc69f304859b3bd567490f75ebf51ae1c792a9ac"
+dependencies = [
+ "compression-codecs",
+ "compression-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "async-executor"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c96bf972d85afc50bf5ab8fe2d54d1586b4e0b46c97c50a0c9e71e2f7bcd812a"
+dependencies = [
+ "async-task",
+ "concurrent-queue",
+ "fastrand",
+ "futures-lite",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "async-io"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "concurrent-queue",
+ "futures-io",
+ "futures-lite",
+ "parking",
+ "polling",
+ "rustix 1.1.4",
+ "slab",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "async-lock"
+version = "3.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"
+dependencies = [
+ "event-listener",
+ "event-listener-strategy",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-process"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"
+dependencies = [
+ "async-channel",
+ "async-io",
+ "async-lock",
+ "async-signal",
+ "async-task",
+ "blocking",
+ "cfg-if",
+ "event-listener",
+ "futures-lite",
+ "rustix 1.1.4",
+]
+
+[[package]]
+name = "async-recursion"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "async-signal"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485"
+dependencies = [
+ "async-io",
+ "async-lock",
+ "atomic-waker",
+ "cfg-if",
+ "futures-core",
+ "futures-io",
+ "rustix 1.1.4",
+ "signal-hook-registry",
+ "slab",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "async-stream"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "async-task"
+version = "4.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
+
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "asynchronous-codec"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4057f2c32adbb2fc158e22fb38433c8e9bbf76b75a4732c7c0cbaf695fb65568"
+dependencies = [
+ "bytes",
+ "futures-sink",
+ "futures-util",
+ "memchr",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "atk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "241b621213072e993be4f6f3a9e4b45f65b7e6faad43001be957184b7bb1824b"
+dependencies = [
+ "atk-sys",
+ "glib",
+ "libc",
+]
+
+[[package]]
+name = "atk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e48b684b0ca77d2bbadeef17424c2ea3c897d44d566a1617e7e8f30614d086"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "atoi"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "atoi_simd"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a49e05797ca52e312a0c658938b7d00693ef037799ef7187678f212d7684cf"
+dependencies = [
+ "debug_unsafe",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "aws-lc-rs"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ec2f1fc3ec205783a5da9a7e6c1509cc69dedf09a1949e412c1e18469326d00"
+dependencies = [
+ "aws-lc-sys",
+ "untrusted 0.7.1",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-lc-sys"
+version = "0.41.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a2f9779ce85b93ab6170dd940ad0169b5766ff848247aff13bb788b832fe3f4"
+dependencies = [
+ "cc",
+ "cmake",
+ "dunce",
+ "fs_extra",
+]
+
+[[package]]
+name = "axum"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "31b698c5f9a010f6573133b09e0de5408834d0c82f8d7475a89fc1867a71cd90"
+dependencies = [
+ "axum-core",
+ "base64 0.22.1",
+ "bytes",
+ "form_urlencoded",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "itoa",
+ "matchit",
+ "memchr",
+ "mime",
+ "multer",
+ "percent-encoding",
+ "pin-project-lite",
+ "serde_core",
+ "serde_json",
+ "serde_path_to_error",
+ "serde_urlencoded",
+ "sha1 0.10.6",
+ "sync_wrapper",
+ "tokio",
+ "tokio-tungstenite",
+ "tower",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "axum-core"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08c78f31d7b1291f7ee735c1c6780ccde7785daae9a9206026862dab7d8792d1"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "http-body-util",
+ "mime",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "base16ct"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd307490d624467aa6f74b0eabb77633d1f758a7b25f12bceb0b22e08d9726f6"
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "base64ct"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
+
+[[package]]
+name = "bcrypt-pbkdf"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6aeac2e1fe888769f34f05ac343bbef98b14d1ffb292ab69d4608b3abc86f2a2"
+dependencies = [
+ "blowfish",
+ "pbkdf2 0.12.2",
+ "sha2 0.10.9",
+]
+
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "710f1dd022ef4e93f8a438b4ba958de7f64308434fa6a87104481645cc30068b"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "block2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
+dependencies = [
+ "objc2",
+]
+
+[[package]]
+name = "blocking"
+version = "1.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
+dependencies = [
+ "async-channel",
+ "async-task",
+ "futures-io",
+ "futures-lite",
+ "piper",
+]
+
+[[package]]
+name = "blowfish"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e412e2cd0f2b2d93e02543ceae7917b3c70331573df19ee046bcbc35e45e87d7"
+dependencies = [
+ "byteorder",
+ "cipher 0.4.4",
+]
+
+[[package]]
+name = "borsh"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a"
+dependencies = [
+ "borsh-derive",
+ "bytes",
+ "cfg_aliases",
+]
+
+[[package]]
+name = "borsh-derive"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfcfdc083699101d5a7965e49925975f2f55060f94f9a05e7187be95d530ca59"
+dependencies = [
+ "once_cell",
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "brotli"
+version = "8.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "bs58"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "bson"
+version = "2.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969a9ba84b0ff843813e7249eed1678d9b6607ce5a3b8f0a47af3fcf7978e6e"
+dependencies = [
+ "ahash 0.8.12",
+ "base64 0.22.1",
+ "bitvec",
+ "getrandom 0.2.17",
+ "getrandom 0.3.4",
+ "hex",
+ "indexmap 2.14.0",
+ "js-sys",
+ "once_cell",
+ "rand 0.9.4",
+ "serde",
+ "serde_bytes",
+ "serde_json",
+ "time",
+ "uuid",
+]
+
+[[package]]
+name = "btoi"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd6407f73a9b8b6162d8a2ef999fe6afd7cc15902ebf42c5cd296addf17e0ad"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
+
+[[package]]
+name = "byte-unit"
+version = "5.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c6d47a4e2961fb8721bcfc54feae6455f2f64e7054f9bc67e875f0e77f4c58d"
+dependencies = [
+ "rust_decimal",
+ "schemars 1.2.1",
+ "serde",
+ "utf8-width",
+]
+
+[[package]]
+name = "bytecheck"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2"
+dependencies = [
+ "bytecheck_derive",
+ "ptr_meta",
+ "simdutf8",
+]
+
+[[package]]
+name = "bytecheck_derive"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3db406d29fbcd95542e92559bed4d8ad92636d1ca8b3b72ede10b4bcc010e659"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "byteorder-lite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f1fe948ff07f4bd06c30984e69f5b4899c516a3ef74f34df92a2df2ab535495"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "bzip2"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3a53fac24f34a81bc9954b5d6cfce0c21e18ec6959f44f56e8e90e4bb7c346c"
+dependencies = [
+ "libbz2-rs-sys",
+]
+
+[[package]]
+name = "cairo-rs"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ca26ef0159422fb77631dc9d17b102f253b876fe1586b03b803e63a309b4ee2"
+dependencies = [
+ "bitflags 2.11.1",
+ "cairo-sys-rs",
+ "glib",
+ "libc",
+ "once_cell",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "cairo-sys-rs"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "685c9fa8e590b8b3d678873528d83411db17242a73fccaed827770ea0fedda51"
+dependencies = [
+ "glib-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "calamine"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1a9acfeb1555aa8def91fe8ff208aadaea850c109968ec35ac965edbe7d210b"
+dependencies = [
+ "atoi_simd",
+ "byteorder",
+ "codepage",
+ "encoding_rs",
+ "fast-float2",
+ "log",
+ "quick-xml 0.37.5",
+ "serde",
+ "zip 4.6.1",
+]
+
+[[package]]
+name = "camino"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e629a66d692cb9ff1a1c664e41771b3dcaf961985a9774c0eb0bd1b51cf60a48"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "cargo-platform"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
+dependencies = [
+ "camino",
+ "cargo-platform",
+ "semver",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "cargo_toml"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "374b7c592d9c00c1f4972ea58390ac6b18cbb6ab79011f3bdc90a0b82ca06b77"
+dependencies = [
+ "serde",
+ "toml 0.9.12+spec-1.1.0",
+]
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher 0.4.4",
+]
+
+[[package]]
+name = "cbc"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce2dc9ee5f88d11e0beb842c88b33c8a5cf0d1329c4b19494af42b07dbfe8896"
+dependencies = [
+ "cipher 0.5.2",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.62"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98"
+dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cfb"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38f2da7a0a2c4ccf0065be06397cc26a81f4e528be095826eee9d4adbb8c60f"
+dependencies = [
+ "byteorder",
+ "fnv",
+ "uuid",
+]
+
+[[package]]
+name = "cfg-expr"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
+dependencies = [
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "chacha20"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
+dependencies = [
+ "cfg-if",
+ "cipher 0.4.4",
+ "cpufeatures 0.2.17",
+]
+
+[[package]]
+name = "chacha20"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "serde",
+ "wasm-bindgen",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common 0.1.7",
+ "inout 0.1.4",
+]
+
+[[package]]
+name = "cipher"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8cf2a2c93cd704877c0858356ed03480ff301ee950b43f1cbe4573b088bfa6c"
+dependencies = [
+ "block-buffer 0.12.0",
+ "crypto-common 0.2.2",
+ "inout 0.2.2",
+]
+
+[[package]]
+name = "clipboard-win"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bde03770d3df201d4fb868f2c9c59e66a3e4e2bd06692a0fe701e7103c7e84d4"
+dependencies = [
+ "error-code",
+]
+
+[[package]]
+name = "cmake"
+version = "0.1.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "cmov"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f88a43d011fc4a6876cb7344703e297c71dda42494fee094d5f7c76bf13f746"
+
+[[package]]
+name = "codepage"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48f68d061bc2828ae826206326e61251aca94c1e4a5305cf52d9138639c918b4"
+dependencies = [
+ "encoding_rs",
+]
+
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "memchr",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "comfy-table"
+version = "7.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a65ebfec4fb190b6f90e944a817d60499ee0744e582530e2c9900a22e591d9a"
+dependencies = [
+ "crossterm",
+ "unicode-segmentation",
+ "unicode-width",
+]
+
+[[package]]
+name = "compression-codecs"
+version = "0.4.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce2548391e9c1929c21bf6aa2680af86fe4c1b33e6cea9ac1cfeec0bd11218cf"
+dependencies = [
+ "compression-core",
+ "flate2",
+ "memchr",
+]
+
+[[package]]
+name = "compression-core"
+version = "0.4.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc14f565cf027a105f7a44ccf9e5b424348421a1d8952a8fc9d499d313107789"
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "connection-string"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "510ca239cf13b7f8d16a2b48f263de7b4f8c566f0af58d901031473c76afb1e3"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
+[[package]]
+name = "const-random"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
+dependencies = [
+ "const-random-macro",
+]
+
+[[package]]
+name = "const-random-macro"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
+dependencies = [
+ "getrandom 0.2.17",
+ "once_cell",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6"
+
+[[package]]
+name = "convert_case"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "cookie"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
+dependencies = [
+ "time",
+ "version_check",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "core-graphics"
+version = "0.23.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation 0.9.4",
+ "core-graphics-types 0.1.3",
+ "foreign-types 0.5.0",
+ "libc",
+]
+
+[[package]]
+name = "core-graphics"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.10.1",
+ "core-graphics-types 0.2.0",
+ "foreign-types 0.5.0",
+ "libc",
+]
+
+[[package]]
+name = "core-graphics-types"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"
+dependencies = [
+ "bitflags 1.3.2",
+ "core-foundation 0.9.4",
+ "libc",
+]
+
+[[package]]
+name = "core-graphics-types"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.10.1",
+ "libc",
+]
+
+[[package]]
+name = "core-text"
+version = "20.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9d2790b5c08465d49f8dc05c8bcae9fea467855947db39b0f8145c091aaced5"
+dependencies = [
+ "core-foundation 0.9.4",
+ "core-graphics 0.23.2",
+ "foreign-types 0.5.0",
+ "libc",
+]
+
+[[package]]
+name = "cpubits"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15b85f9c39137c3a891689859392b1bd49812121d0d61c9caf00d46ed5ce06ae"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc16"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "338089f42c427b86394a5ee60ff321da23a5c89c9d89514c829687b26359fcff"
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "critical-section"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crossterm"
+version = "0.28.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
+dependencies = [
+ "bitflags 2.11.1",
+ "crossterm_winapi",
+ "parking_lot",
+ "rustix 0.38.44",
+ "winapi",
+]
+
+[[package]]
+name = "crossterm_winapi"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "crypto-bigint"
+version = "0.7.0-rc.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96dacf199529fb801ae62a9aafdc01b189e9504c0d1ee1512a4c16bcd8666a93"
+dependencies = [
+ "cpubits",
+ "ctutils",
+ "getrandom 0.4.2",
+ "hybrid-array",
+ "num-traits",
+ "rand_core 0.10.1",
+ "serdect",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array 0.14.7",
+ "rand_core 0.6.4",
+ "typenum",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
+dependencies = [
+ "getrandom 0.4.2",
+ "hybrid-array",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "crypto-primes"
+version = "0.7.0-pre.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6081ce8b60c0e533e2bba42771b94eb6149052115f4179744d5779883dc98583"
+dependencies = [
+ "crypto-bigint",
+ "libm",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "cssparser"
+version = "0.36.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dae61cf9c0abb83bd659dab65b7e4e38d8236824c85f0f804f173567bda257d2"
+dependencies = [
+ "cssparser-macros",
+ "dtoa-short",
+ "itoa",
+ "phf",
+ "smallvec",
+]
+
+[[package]]
+name = "cssparser-macros"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13b588ba4ac1a99f7f2964d24b3d896ddc6bf847ee3855dbd4366f058cfcd331"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "csv"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde_core",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ctor"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "352d39c2f7bef1d6ad73db6f5160efcaed66d94ef8c6c573a8410c00bf909a98"
+dependencies = [
+ "ctor-proc-macro",
+ "dtor",
+]
+
+[[package]]
+name = "ctor-proc-macro"
+version = "0.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52560adf09603e58c9a7ee1fe1dcb95a16927b17c127f0ac02d6e768a0e25bc1"
+
+[[package]]
+name = "ctr"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
+dependencies = [
+ "cipher 0.4.4",
+]
+
+[[package]]
+name = "ctr"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baaca1c4b237092596f64d571e9db6ce4109c4ef9742e27590f1709594461f21"
+dependencies = [
+ "cipher 0.5.2",
+]
+
+[[package]]
+name = "ctutils"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5515a3834141de9eafb9717ad39eea8247b5674e6066c404e8c4b365d2a29e"
+dependencies = [
+ "cmov",
+ "subtle",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "4.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97fb8b7c4503de7d6ae7b42ab72a5a59857b4c937ec27a3d4539dba95b5ab2be"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "curve25519-dalek-derive",
+ "fiat-crypto 0.2.9",
+ "rustc_version",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "5.0.0-pre.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335f1947f241137a14106b6f5acc5918a5ede29c9d71d3f2cb1678d5075d9fc3"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "curve25519-dalek-derive",
+ "digest 0.11.3",
+ "fiat-crypto 0.3.0",
+ "rustc_version",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "curve25519-dalek-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "darling"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
+dependencies = [
+ "darling_core 0.20.11",
+ "darling_macro 0.20.11",
+]
+
+[[package]]
+name = "darling"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d"
+dependencies = [
+ "darling_core 0.23.0",
+ "darling_macro 0.23.0",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0"
+dependencies = [
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
+dependencies = [
+ "darling_core 0.20.11",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
+dependencies = [
+ "darling_core 0.23.0",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"
+
+[[package]]
+name = "dbus"
+version = "0.9.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b942602992bb7acfd1f51c49811c58a610ef9181b6e66f3e519d79b540a3bf73"
+dependencies = [
+ "libc",
+ "libdbus-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dbx"
+version = "0.5.55"
+dependencies = [
+ "anyhow",
+ "axum",
+ "base64 0.22.1",
+ "calamine",
+ "chrono",
+ "csv",
+ "dbx-core",
+ "deadpool-postgres",
+ "duckdb",
+ "font-kit",
+ "futures",
+ "libloading 0.8.9",
+ "log",
+ "mongodb",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "percent-encoding",
+ "portpicker",
+ "redis",
+ "reqwest 0.12.28",
+ "russh",
+ "rust_decimal",
+ "rustls 0.23.40",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-build",
+ "tauri-plugin-clipboard-manager",
+ "tauri-plugin-deep-link",
+ "tauri-plugin-dialog",
+ "tauri-plugin-fs",
+ "tauri-plugin-log",
+ "tauri-plugin-process",
+ "tauri-plugin-shell",
+ "tauri-plugin-single-instance",
+ "tauri-plugin-updater",
+ "tauri-plugin-window-state",
+ "tiberius",
+ "tokio",
+ "tokio-postgres",
+ "tokio-util",
+ "uuid",
+ "zip 4.6.1",
+]
+
+[[package]]
+name = "dbx-core"
+version = "0.1.0"
+dependencies = [
+ "aes-gcm 0.10.3",
+ "anyhow",
+ "argon2",
+ "async-trait",
+ "base64 0.22.1",
+ "bytes",
+ "calamine",
+ "chrono",
+ "csv",
+ "deadpool-postgres",
+ "duckdb",
+ "encoding_rs",
+ "font-kit",
+ "futures",
+ "iana-time-zone",
+ "jsonwebtoken",
+ "log",
+ "mongodb",
+ "mysql_async",
+ "pageant",
+ "percent-encoding",
+ "portpicker",
+ "rayon",
+ "redis",
+ "regex",
+ "reqwest 0.12.28",
+ "rusqlite",
+ "russh",
+ "rust_decimal",
+ "rustls 0.23.40",
+ "rustls-pemfile 2.2.0",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+ "sqlparser",
+ "sysinfo",
+ "tiberius",
+ "tokio",
+ "tokio-postgres",
+ "tokio-postgres-rustls",
+ "tokio-util",
+ "uuid",
+ "webpki-roots 0.26.11",
+ "zip 4.6.1",
+]
+
+[[package]]
+name = "dbx-web"
+version = "0.5.55"
+dependencies = [
+ "aes-gcm 0.10.3",
+ "argon2",
+ "async-stream",
+ "axum",
+ "base64 0.22.1",
+ "chrono",
+ "dbx-core",
+ "futures",
+ "log",
+ "pbkdf2 0.12.2",
+ "redis",
+ "reqwest 0.12.28",
+ "rustls 0.23.40",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+ "tokio",
+ "tokio-util",
+ "tower-http",
+ "tracing",
+ "tracing-subscriber",
+ "uuid",
+]
+
+[[package]]
+name = "deadpool"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0be2b1d1d6ec8d846f05e137292d0b89133caf95ef33695424c09568bdd39b1b"
+dependencies = [
+ "deadpool-runtime",
+ "lazy_static",
+ "num_cpus",
+ "tokio",
+]
+
+[[package]]
+name = "deadpool-postgres"
+version = "0.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d697d376cbfa018c23eb4caab1fd1883dd9c906a8c034e8d9a3cb06a7e0bef9"
+dependencies = [
+ "async-trait",
+ "deadpool",
+ "getrandom 0.2.17",
+ "tokio",
+ "tokio-postgres",
+ "tracing",
+]
+
+[[package]]
+name = "deadpool-runtime"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "092966b41edc516079bdf31ec78a2e0588d1d0c08f78b91d8307215928642b2b"
+dependencies = [
+ "tokio",
+]
+
+[[package]]
+name = "debug_unsafe"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7eed2c4702fa172d1ce21078faa7c5203e69f5394d48cc436d25928394a867a2"
+
+[[package]]
+name = "deflate64"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac6b926516df9c60bfa16e107b21086399f8285a44ca9711344b9e553c5146e2"
+
+[[package]]
+name = "delegate"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "780eb241654bf097afb00fc5f054a09b687dad862e485fdcf8399bb056565370"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "der"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+dependencies = [
+ "const-oid 0.9.6",
+ "der_derive",
+ "flagset",
+ "zeroize",
+]
+
+[[package]]
+name = "der"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71fd89660b2dc699704064e59e9dba0147b903e85319429e131620d022be411b"
+dependencies = [
+ "const-oid 0.10.2",
+ "pem-rfc7468 1.0.0",
+ "zeroize",
+]
+
+[[package]]
+name = "der_derive"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8034092389675178f570469e6c3b0465d3d30b4505c294a6550db47f3c17ad18"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+dependencies = [
+ "powerfmt",
+ "serde_core",
+]
+
+[[package]]
+name = "derive-syn-parse"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d65d7ce8132b7c0e54497a4d9a55a1c2a0912a0d786cf894472ba818fba45762"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "derive-where"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d08b3a0bcc0d079199cd476b2cae8435016ec11d1c0986c6901c5ac223041534"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "derive_arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn 2.0.117",
+ "unicode-xid",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer 0.10.4",
+ "const-oid 0.9.6",
+ "crypto-common 0.1.7",
+ "subtle",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer 0.12.0",
+ "const-oid 0.10.2",
+ "crypto-common 0.2.2",
+ "ctutils",
+]
+
+[[package]]
+name = "dirs"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dispatch2"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "libc",
+ "objc2",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dlib"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab8ecd87370524b461f8557c119c405552c396ed91fc0a8eec68679eab26f94a"
+dependencies = [
+ "libloading 0.8.9",
+]
+
+[[package]]
+name = "dlopen2"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e2c5bd4158e66d1e215c49b837e11d62f3267b30c92f1d171c4d3105e3dc4d4"
+dependencies = [
+ "dlopen2_derive",
+ "libc",
+ "once_cell",
+ "winapi",
+]
+
+[[package]]
+name = "dlopen2_derive"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fbbb781877580993a8707ec48672673ec7b81eeba04cfd2310bd28c08e47c8f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dlv-list"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "442039f5147480ba31067cb00ada1adae6892028e40e45fc5de7b7df6dcc1b5f"
+dependencies = [
+ "const-random",
+]
+
+[[package]]
+name = "dom_query"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521e380c0c8afb8d9a1e83a1822ee03556fc3e3e7dbc1fd30be14e37f9cb3f89"
+dependencies = [
+ "bit-set",
+ "cssparser",
+ "foldhash 0.2.0",
+ "html5ever",
+ "precomputed-hash",
+ "selectors",
+ "tendril",
+]
+
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
+[[package]]
+name = "dpi"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "dtoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c3cf4824e2d5f025c7b531afcb2325364084a16806f6d47fbc1f5fbd9960590"
+
+[[package]]
+name = "dtoa-short"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd1511a7b6a56299bd043a9c167a6d2bfb37bf84a6dfceaba651168adfb43c87"
+dependencies = [
+ "dtoa",
+]
+
+[[package]]
+name = "dtor"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1057d6c64987086ff8ed0fd3fbf377a6b7d205cc7715868cd401705f715cbe4"
+dependencies = [
+ "dtor-proc-macro",
+]
+
+[[package]]
+name = "dtor-proc-macro"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f678cf4a922c215c63e0de95eb1ff08a958a81d47e485cf9da1e27bf6305cfa5"
+
+[[package]]
+name = "duckdb"
+version = "1.10503.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cb42b21e3be42ef14acda15ce8dc99c125ce5376b87c8016a432cf14ae65de1"
+dependencies = [
+ "arrow",
+ "cast",
+ "comfy-table",
+ "fallible-iterator 0.3.0",
+ "fallible-streaming-iterator",
+ "hashlink 0.10.0",
+ "libduckdb-sys",
+ "num-integer",
+ "rust_decimal",
+ "strum",
+]
+
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
+[[package]]
+name = "dwrote"
+version = "0.11.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b35532432acc8b19ceed096e35dfa088d3ea037fe4f3c085f1f97f33b4d02"
+dependencies = [
+ "lazy_static",
+ "libc",
+ "winapi",
+ "wio",
+]
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
+[[package]]
+name = "ecdsa"
+version = "0.17.0-rc.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91bbdd377139884fafcad8dc43a760a3e1e681aa26db910257fa6535b70e1829"
+dependencies = [
+ "der 0.8.0",
+ "digest 0.11.3",
+ "elliptic-curve",
+ "rfc6979",
+ "signature",
+ "spki 0.8.0-rc.4",
+ "zeroize",
+]
+
+[[package]]
+name = "ed25519"
+version = "3.0.0-rc.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6e914c7c52decb085cea910552e24c63ac019e3ab8bf001ff736da9a9d9d890"
+dependencies = [
+ "pkcs8",
+ "signature",
+]
+
+[[package]]
+name = "ed25519-dalek"
+version = "3.0.0-pre.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053618a4c3d3bc24f188aa660ae75a46eeab74ef07fb415c61431e5e7cd4749b"
+dependencies = [
+ "curve25519-dalek 5.0.0-pre.6",
+ "ed25519",
+ "rand_core 0.10.1",
+ "serde",
+ "sha2 0.11.0",
+ "signature",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "either"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
+
+[[package]]
+name = "elliptic-curve"
+version = "0.14.0-rc.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bde7860544606d222fd6bd6d9f9a0773321bf78072a637e1d560a058c0031978"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "crypto-common 0.2.2",
+ "digest 0.11.3",
+ "hkdf",
+ "hybrid-array",
+ "once_cell",
+ "pem-rfc7468 1.0.0",
+ "pkcs8",
+ "rand_core 0.10.1",
+ "rustcrypto-ff",
+ "rustcrypto-group",
+ "sec1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "embed-resource"
+version = "3.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31a88c8d26de40ed18fe748c547845aa39de1db3afd958f8cb91579f3644bcb"
+dependencies = [
+ "cc",
+ "memchr",
+ "rustc_version",
+ "toml 1.1.2+spec-1.1.0",
+ "vswhom",
+ "winreg",
+]
+
+[[package]]
+name = "embed_plist"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "endi"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
+
+[[package]]
+name = "enum_dispatch"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"
+dependencies = [
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "enumflags2"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
+dependencies = [
+ "enumflags2_derive",
+ "serde",
+]
+
+[[package]]
+name = "enumflags2_derive"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "env_filter"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf3c259d255ca70051b30e2e95b5446cdb8949ac4cd22c0d7fd634d89f568e2"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "erased-serde"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2add8a07dd6a8d93ff627029c51de145e12686fbc36ecb298ac22e74cf02dec"
+dependencies = [
+ "serde",
+ "serde_core",
+ "typeid",
+]
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "error-code"
+version = "3.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dea2df4cf52843e0452895c455a1a2cfbb842a1e7329671acf418fdc53ed4c59"
+
+[[package]]
+name = "event-listener"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+dependencies = [
+ "event-listener",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "fallible-iterator"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
+
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
+[[package]]
+name = "fast-float2"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8eb564c5c7423d25c886fb561d1e4ee69f72354d16918afa32c08811f6b6a55"
+
+[[package]]
+name = "fastrand"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
+[[package]]
+name = "fax"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caf1079563223d5d59d83c85886a56e586cfd5c1a26292e971a0fa266531ac5a"
+
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "fern"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4316185f709b23713e41e3195f90edef7fb00c3ed4adc79769cf09cc762a3b29"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "fiat-crypto"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28dea519a9695b9977216879a3ebfddf92f1c08c05d984f8996aecd6ecdc811d"
+
+[[package]]
+name = "fiat-crypto"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64cd1e32ddd350061ae6edb1b082d7c54915b5c672c389143b9a63403a109f24"
+
+[[package]]
+name = "field-offset"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f"
+dependencies = [
+ "memoffset",
+ "rustc_version",
+]
+
+[[package]]
+name = "filetime"
+version = "0.2.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759"
+dependencies = [
+ "cfg-if",
+ "libc",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "fixedbitset"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
+
+[[package]]
+name = "flagset"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7ac824320a75a52197e8f2d787f6a38b6718bb6897a35142d749af3c0e8f4fe"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+ "zlib-rs",
+]
+
+[[package]]
+name = "float-ord"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ce81f49ae8a0482e4c55ea62ebbd7e5a686af544c00b9d090bba3ff9be97b3d"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "font-kit"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c7e611d49285d4c4b2e1727b72cf05353558885cc5252f93707b845dfcaf3d3"
+dependencies = [
+ "bitflags 2.11.1",
+ "byteorder",
+ "core-foundation 0.9.4",
+ "core-graphics 0.23.2",
+ "core-text",
+ "dirs",
+ "dwrote",
+ "float-ord",
+ "freetype-sys",
+ "lazy_static",
+ "libc",
+ "log",
+ "pathfinder_geometry",
+ "pathfinder_simd",
+ "walkdir",
+ "winapi",
+ "yeslogic-fontconfig-sys",
+]
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared 0.1.1",
+]
+
+[[package]]
+name = "foreign-types"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
+dependencies = [
+ "foreign-types-macros",
+ "foreign-types-shared 0.3.1",
+]
+
+[[package]]
+name = "foreign-types-macros"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "freetype-sys"
+version = "0.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e7edc5b9669349acfda99533e9e0bcf26a51862ab43b08ee7745c55d28eb134"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-lite"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "gdk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9f245958c627ac99d8e529166f9823fb3b838d1d41fd2b297af3075093c2691"
+dependencies = [
+ "cairo-rs",
+ "gdk-pixbuf",
+ "gdk-sys",
+ "gio",
+ "glib",
+ "libc",
+ "pango",
+]
+
+[[package]]
+name = "gdk-pixbuf"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50e1f5f1b0bfb830d6ccc8066d18db35c487b1b2b1e8589b5dfe9f07e8defaec"
+dependencies = [
+ "gdk-pixbuf-sys",
+ "gio",
+ "glib",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "gdk-pixbuf-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9839ea644ed9c97a34d129ad56d38a25e6756f99f3a88e15cd39c20629caf7"
+dependencies = [
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gdk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c2d13f38594ac1e66619e188c6d5a1adb98d11b2fcf7894fc416ad76aa2f3f7"
+dependencies = [
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "pkg-config",
+ "system-deps",
+]
+
+[[package]]
+name = "gdkwayland-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "140071d506d223f7572b9f09b5e155afbd77428cd5cc7af8f2694c41d98dfe69"
+dependencies = [
+ "gdk-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pkg-config",
+ "system-deps",
+]
+
+[[package]]
+name = "gdkx11"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3caa00e14351bebbc8183b3c36690327eb77c49abc2268dd4bd36b856db3fbfe"
+dependencies = [
+ "gdk",
+ "gdkx11-sys",
+ "gio",
+ "glib",
+ "libc",
+ "x11",
+]
+
+[[package]]
+name = "gdkx11-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e7445fe01ac26f11601db260dd8608fe172514eb63b3b5e261ea6b0f4428d"
+dependencies = [
+ "gdk-sys",
+ "glib-sys",
+ "libc",
+ "system-deps",
+ "x11",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "generic-array"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dab9e9188e97a93276e1fe7b56401b851e2b45a46d045ca658100c1303ada649"
+dependencies = [
+ "generic-array 0.14.7",
+ "rustversion",
+ "typenum",
+]
+
+[[package]]
+name = "gethostname"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8"
+dependencies = [
+ "rustix 1.1.4",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+ "rand_core 0.10.1",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "ghash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"
+dependencies = [
+ "opaque-debug",
+ "polyval 0.6.2",
+]
+
+[[package]]
+name = "ghash"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5"
+dependencies = [
+ "polyval 0.7.1",
+]
+
+[[package]]
+name = "gio"
+version = "0.18.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4fc8f532f87b79cbc51a79748f16a6828fb784be93145a322fa14d06d354c73"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "gio-sys",
+ "glib",
+ "libc",
+ "once_cell",
+ "pin-project-lite",
+ "smallvec",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "gio-sys"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37566df850baf5e4cb0dfb78af2e4b9898d817ed9263d1090a2df958c64737d2"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+ "winapi",
+]
+
+[[package]]
+name = "glib"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233daaf6e83ae6a12a52055f568f9d7cf4671dabb78ff9560ab6da230ce00ee5"
+dependencies = [
+ "bitflags 2.11.1",
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-task",
+ "futures-util",
+ "gio-sys",
+ "glib-macros",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "memchr",
+ "once_cell",
+ "smallvec",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "glib-macros"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bb0228f477c0900c880fd78c8759b95c7636dbd7842707f49e132378aa2acdc"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro-crate 2.0.2",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "glib-sys"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "063ce2eb6a8d0ea93d2bf8ba1957e78dbab6be1c2220dd3daca57d5a9d869898"
+dependencies = [
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "gobject-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0850127b514d1c4a4654ead6dedadb18198999985908e6ffe4436f53c785ce44"
+dependencies = [
+ "glib-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gtk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd56fb197bfc42bd5d2751f4f017d44ff59fbb58140c6b49f9b3b2bdab08506a"
+dependencies = [
+ "atk",
+ "cairo-rs",
+ "field-offset",
+ "futures-channel",
+ "gdk",
+ "gdk-pixbuf",
+ "gio",
+ "glib",
+ "gtk-sys",
+ "gtk3-macros",
+ "libc",
+ "pango",
+ "pkg-config",
+]
+
+[[package]]
+name = "gtk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f29a1c21c59553eb7dd40e918be54dccd60c52b049b75119d5d96ce6b624414"
+dependencies = [
+ "atk-sys",
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gdk-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "system-deps",
+]
+
+[[package]]
+name = "gtk3-macros"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ff3c5b21f14f0736fed6dcfc0bfb4225ebf5725f3c0209edeec181e4d73e9d"
+dependencies = [
+ "proc-macro-crate 1.3.1",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "h2"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "171fefbc92fe4a4de27e0698d6a5b392d6a0e333506bc49133760b3bcf948733"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http",
+ "indexmap 2.14.0",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "num-traits",
+ "zerocopy",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+dependencies = [
+ "ahash 0.7.8",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+dependencies = [
+ "ahash 0.8.12",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash 0.1.5",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.2.0",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "hashlink"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ba4ff7128dee98c7dc9794b6a411377e1404dba1c97deb8d1a55297bd25d8af"
+dependencies = [
+ "hashbrown 0.14.5",
+]
+
+[[package]]
+name = "hashlink"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
+dependencies = [
+ "hashbrown 0.15.5",
+]
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hex-literal"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e712f64ec3850b98572bffac52e2c6f282b29fe6c5fa6d42334b30be438d95c1"
+
+[[package]]
+name = "hickory-net"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2295ed2f9c31e471e1428a8f88a3f0e1f4b27c15049592138d1eebe9c35b183"
+dependencies = [
+ "async-trait",
+ "cfg-if",
+ "data-encoding",
+ "futures-channel",
+ "futures-io",
+ "futures-util",
+ "hickory-proto",
+ "idna",
+ "ipnet",
+ "jni 0.22.4",
+ "rand 0.10.1",
+ "thiserror 2.0.18",
+ "tinyvec",
+ "tokio",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "hickory-proto"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bab31817bfb44672a252e97fe81cd0c18d1b2cf892108922f6818820df8c643"
+dependencies = [
+ "data-encoding",
+ "idna",
+ "ipnet",
+ "jni 0.22.4",
+ "once_cell",
+ "prefix-trie",
+ "rand 0.10.1",
+ "ring",
+ "thiserror 2.0.18",
+ "tinyvec",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "hickory-resolver"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0d58d28879ceecde6607729660c2667a081ccdc082e082675042793960f178c"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "hickory-net",
+ "hickory-proto",
+ "ipconfig",
+ "ipnet",
+ "jni 0.22.4",
+ "moka",
+ "ndk-context",
+ "once_cell",
+ "parking_lot",
+ "rand 0.10.1",
+ "resolv-conf",
+ "smallvec",
+ "system-configuration",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "hkdf"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4aaa26c720c68b866f2c96ef5c1264b3e6f473fe5d4ce61cd44bbe913e553018"
+dependencies = [
+ "hmac 0.13.0",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "hmac"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f"
+dependencies = [
+ "digest 0.11.3",
+]
+
+[[package]]
+name = "html5ever"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1054432bae2f14e0061e33d23402fbaa67a921d319d56adc6bcf887ddad1cbc2"
+dependencies = [
+ "log",
+ "markup5ever",
+]
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "http-range-header"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9171a2ea8a68358193d15dd5d70c1c10a2afc3e7e4c5bc92bc9f025cebd7359c"
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "hybrid-array"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9155a582abd142abc056962c29e3ce5ff2ad5469f4246b537ed42c5deba857da"
+dependencies = [
+ "ctutils",
+ "subtle",
+ "typenum",
+ "zeroize",
+]
+
+[[package]]
+name = "hyper"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6299f016b246a94207e63da54dbe807655bf9e00044f73ded42c3ac5305fbcca"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "h2",
+ "http",
+ "http-body",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.27.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f"
+dependencies = [
+ "http",
+ "hyper",
+ "hyper-util",
+ "rustls 0.23.40",
+ "tokio",
+ "tokio-rustls 0.26.4",
+ "tower-service",
+ "webpki-roots 1.0.7",
+]
+
+[[package]]
+name = "hyper-tls"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
+dependencies = [
+ "bytes",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+ "tower-service",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
+ "pin-project-lite",
+ "socket2 0.6.3",
+ "system-configuration",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "windows-registry 0.6.1",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core 0.62.2",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "ico"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e795dff5605e0f04bff85ca41b51a96b83e80b281e96231bcaaf1ac35103371"
+dependencies = [
+ "byteorder",
+ "png 0.17.16",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "utf8_iter",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38"
+
+[[package]]
+name = "icu_properties"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14"
+
+[[package]]
+name = "icu_provider"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "image"
+version = "0.25.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85ab80394333c02fe689eaf900ab500fbd0c2213da414687ebf995a65d5a6104"
+dependencies = [
+ "bytemuck",
+ "byteorder-lite",
+ "moxcms",
+ "num-traits",
+ "png 0.18.1",
+ "tiff",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "infer"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a588916bfdfd92e71cacef98a63d9b1f0d74d6599980d11894290e7ddefffcf7"
+dependencies = [
+ "cfb",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "block-padding 0.3.3",
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "inout"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7"
+dependencies = [
+ "block-padding 0.4.2",
+ "hybrid-array",
+]
+
+[[package]]
+name = "internal-russh-forked-ssh-key"
+version = "0.6.18+upstream-0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25f8a978272e3cbdf4768f7363eb1c8e1e6ba63c52a3ed05e29e222da4aec7cb"
+dependencies = [
+ "argon2",
+ "bcrypt-pbkdf",
+ "crypto-bigint",
+ "ecdsa",
+ "ed25519-dalek",
+ "hex",
+ "hmac 0.13.0",
+ "num-bigint-dig",
+ "p256",
+ "p384",
+ "p521",
+ "rand_core 0.10.1",
+ "rsa",
+ "sec1",
+ "sha1 0.11.0",
+ "sha2 0.11.0",
+ "signature",
+ "ssh-cipher",
+ "ssh-encoding",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "internal-russh-num-bigint"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae8e22120c32fb4d19ec55fba35015f57095cd95a2e3b732e44457f5915b2ee8"
+dependencies = [
+ "num-integer",
+ "num-traits",
+ "rand 0.10.1",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "ipconfig"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d40460c0ce33d6ce4b0630ad68ff63d6661961c48b6dba35e5a4d81cfb48222"
+dependencies = [
+ "socket2 0.6.3",
+ "widestring",
+ "windows-registry 0.6.1",
+ "windows-result 0.4.1",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "is-docker"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "is-wsl"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5"
+dependencies = [
+ "is-docker",
+ "once_cell",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "javascriptcore-rs"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca5671e9ffce8ffba57afc24070e906da7fc4b1ba66f2cabebf61bf2ea257fcc"
+dependencies = [
+ "bitflags 1.3.2",
+ "glib",
+ "javascriptcore-rs-sys",
+]
+
+[[package]]
+name = "javascriptcore-rs-sys"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af1be78d14ffa4b75b66df31840478fef72b51f8c2465d4ca7c194da9f7a5124"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys 0.3.1",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498"
+dependencies = [
+ "cfg-if",
+ "combine",
+ "jni-macros",
+ "jni-sys 0.4.1",
+ "log",
+ "simd_cesu8",
+ "thiserror 2.0.18",
+ "walkdir",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "jni-macros"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "simd_cesu8",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258"
+dependencies = [
+ "jni-sys 0.4.1",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"
+dependencies = [
+ "jni-sys-macros",
+]
+
+[[package]]
+name = "jni-sys-macros"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.4",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "142bc4740e452c1e57ade0cbc129f139c9093e354346f0872ef985f4f5cf5f11"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "json-patch"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "863726d7afb6bc2590eeff7135d923545e5e964f004c2ccf8716c25e70a86f08"
+dependencies = [
+ "jsonptr",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "jsonptr"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dea2b27dd239b2556ed7a25ba842fe47fd602e7fc7433c2a8d6106d4d9edd70"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "jsonwebtoken"
+version = "9.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a87cc7a48537badeae96744432de36f4be2b4a34a05a5ef32e9dd8a1c169dde"
+dependencies = [
+ "base64 0.22.1",
+ "js-sys",
+ "pem",
+ "ring",
+ "serde",
+ "serde_json",
+ "simple_asn1",
+]
+
+[[package]]
+name = "keccak"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e24a010dd405bd7ed803e5253182815b41bf2e6a80cc3bfc066658e03a198aa"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+]
+
+[[package]]
+name = "kem"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01737161ba802849cfd486b5bd209d38ba4943494c249a8126005170c7621edd"
+dependencies = [
+ "crypto-common 0.2.2",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "keyboard-types"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b750dcadc39a09dbadd74e118f6dd6598df77fa01df0cfcdc52c28dece74528a"
+dependencies = [
+ "bitflags 2.11.1",
+ "serde",
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "keyed_priority_queue"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ee7893dab2e44ae5f9d0173f26ff4aa327c10b01b06a72b52dd9405b628640d"
+dependencies = [
+ "indexmap 2.14.0",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+dependencies = [
+ "spin",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "lexical-core"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594"
+dependencies = [
+ "lexical-parse-float",
+ "lexical-parse-integer",
+ "lexical-util",
+ "lexical-write-float",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-parse-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56"
+dependencies = [
+ "lexical-parse-integer",
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-parse-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34"
+dependencies = [
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-util"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17"
+
+[[package]]
+name = "lexical-write-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361"
+dependencies = [
+ "lexical-util",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-write-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df"
+dependencies = [
+ "lexical-util",
+]
+
+[[package]]
+name = "libappindicator"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03589b9607c868cc7ae54c0b2a22c8dc03dd41692d48f2d7df73615c6a95dc0a"
+dependencies = [
+ "glib",
+ "gtk",
+ "gtk-sys",
+ "libappindicator-sys",
+ "log",
+]
+
+[[package]]
+name = "libappindicator-sys"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e9ec52138abedcc58dc17a7c6c0c00a2bdb4f3427c7f63fa97fd0d859155caf"
+dependencies = [
+ "gtk-sys",
+ "libloading 0.7.4",
+ "once_cell",
+]
+
+[[package]]
+name = "libbz2-rs-sys"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34b357333733e8260735ba5894eb928c02ecc69c78715f01a8019e7fa7f2db4c"
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "libdbus-sys"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "328c4789d42200f1eeec05bd86c9c13c7f091d2ba9a6ea35acdf51f31bc0f043"
+dependencies = [
+ "pkg-config",
+]
+
+[[package]]
+name = "libduckdb-sys"
+version = "1.10503.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9a4389c243e7afa0fbc8d8471031335ddc8a2dac4534f3290c9c2ba3edabab5"
+dependencies = [
+ "cc",
+ "flate2",
+ "pkg-config",
+ "reqwest 0.12.28",
+ "serde",
+ "serde_json",
+ "tar",
+ "vcpkg",
+ "zip 6.0.0",
+]
+
+[[package]]
+name = "libloading"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
+
+[[package]]
+name = "libloading"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
+dependencies = [
+ "cfg-if",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "liblzma"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6033b77c21d1f56deeae8014eb9fbe7bdf1765185a6c508b5ca82eeaed7f899"
+dependencies = [
+ "liblzma-sys",
+]
+
+[[package]]
+name = "liblzma-sys"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a60851d15cd8c5346eca4ab8babff585be2ae4bc8097c067291d3ffe2add3b6"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "libredox"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "libsqlite3-sys"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
+dependencies = [
+ "cc",
+ "openssl-sys",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litemap"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616ec5685824bcc94416c6d4a7a446eea774a31efd7062c8480ba6fd06d7a6e5"
+dependencies = [
+ "value-bag",
+]
+
+[[package]]
+name = "lru"
+version = "0.16.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f66e8d5d03f609abc3a39e6f08e4164ebf1447a732906d39eb9b99b7919ef39"
+dependencies = [
+ "hashbrown 0.16.1",
+]
+
+[[package]]
+name = "lru-slab"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+
+[[package]]
+name = "macro_magic"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc33f9f0351468d26fbc53d9ce00a096c8522ecb42f19b50f34f2c422f76d21d"
+dependencies = [
+ "macro_magic_core",
+ "macro_magic_macros",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "macro_magic_core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1687dc887e42f352865a393acae7cf79d98fab6351cde1f58e9e057da89bf150"
+dependencies = [
+ "const-random",
+ "derive-syn-parse",
+ "macro_magic_core_macros",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "macro_magic_core_macros"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b02abfe41815b5bd98dbd4260173db2c116dda171dc0fe7838cb206333b83308"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "macro_magic_macros"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ea28ee64b88876bf45277ed9a5817c1817df061a74f2b988971a12570e5869"
+dependencies = [
+ "macro_magic_core",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "markup5ever"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8983d30f2915feeaaab2d6babdd6bc7e9ed1a00b66b5e6d74df19aa9c0e91862"
+dependencies = [
+ "log",
+ "tendril",
+ "web_atoms",
+]
+
+[[package]]
+name = "matchers"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
+dependencies = [
+ "regex-automata",
+]
+
+[[package]]
+name = "matchit"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3"
+
+[[package]]
+name = "md-5"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
+dependencies = [
+ "cfg-if",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "md-5"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69b6441f590336821bb897fb28fc622898ccceb1d6cea3fde5ea86b090c4de98"
+dependencies = [
+ "cfg-if",
+ "digest 0.11.3",
+]
+
+[[package]]
+name = "md5"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
+[[package]]
+name = "minisign-verify"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22f9645cb765ea72b8111f36c522475d2daa0d22c957a9826437e97534bc4e9e"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
+dependencies = [
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "ml-kem"
+version = "0.3.0-rc.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8198b5db27ac9773534c371751a59dc18aec8b80aa141e69abfdd1dec2e3f78c"
+dependencies = [
+ "hybrid-array",
+ "kem",
+ "module-lattice",
+ "rand_core 0.10.1",
+ "sha3",
+]
+
+[[package]]
+name = "module-lattice"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c61b87c9683ab7cb1c6871d261ad5479b6b10ceb52c4352aaca3b5d35a8febe"
+dependencies = [
+ "ctutils",
+ "hybrid-array",
+ "num-traits",
+]
+
+[[package]]
+name = "moka"
+version = "0.12.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "957228ad12042ee839f93c8f257b62b4c0ab5eaae1d4fa60de53b27c9d7c5046"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "equivalent",
+ "parking_lot",
+ "portable-atomic",
+ "smallvec",
+ "tagptr",
+ "uuid",
+]
+
+[[package]]
+name = "mongocrypt"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8da0cd419a51a5fb44819e290fbdb0665a54f21dead8923446a799c7f4d26ad9"
+dependencies = [
+ "bson",
+ "mongocrypt-sys",
+ "once_cell",
+ "serde",
+]
+
+[[package]]
+name = "mongocrypt-sys"
+version = "0.1.5+1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224484c5d09285a7b8cb0a0c117e847ebd14cb6e4470ecf68cdb89c503b0edb9"
+
+[[package]]
+name = "mongodb"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "276ba0cd571553d1f6936c6f180964776ece6ab7507dc8765f8a9c9c49d8cd00"
+dependencies = [
+ "base64 0.22.1",
+ "bitflags 2.11.1",
+ "bson",
+ "derive-where",
+ "derive_more",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "hex",
+ "hickory-net",
+ "hickory-proto",
+ "hickory-resolver",
+ "hmac 0.12.1",
+ "macro_magic",
+ "md-5 0.10.6",
+ "mongocrypt",
+ "mongodb-internal-macros",
+ "pbkdf2 0.12.2",
+ "percent-encoding",
+ "rand 0.9.4",
+ "rustc_version_runtime",
+ "rustls 0.23.40",
+ "serde",
+ "serde_bytes",
+ "serde_with",
+ "sha1 0.10.6",
+ "sha2 0.10.9",
+ "socket2 0.6.3",
+ "stringprep",
+ "strsim",
+ "take_mut",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-rustls 0.26.4",
+ "tokio-util",
+ "typed-builder",
+ "uuid",
+ "webpki-roots 1.0.7",
+]
+
+[[package]]
+name = "mongodb-internal-macros"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99ceb1a9a1018e470077ec94cf3a8c2d0e6da542b2c05ea95a59a0a627147375"
+dependencies = [
+ "macro_magic",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "moxcms"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb85c154ba489f01b25c0d36ae69a87e4a1c73a72631fc6c0eb6dde34a73e44b"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
+[[package]]
+name = "muda"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47a2e3dff89cd322c66647942668faee0a2b1f88ea6cbb4d374b4a8d7e92528c"
+dependencies = [
+ "crossbeam-channel",
+ "dpi",
+ "gtk",
+ "keyboard-types",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "once_cell",
+ "png 0.18.1",
+ "serde",
+ "thiserror 2.0.18",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "multer"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83e87776546dc87511aa5ee218730c92b666d7264ab6ed41f9d215af9cd5224b"
+dependencies = [
+ "bytes",
+ "encoding_rs",
+ "futures-util",
+ "http",
+ "httparse",
+ "memchr",
+ "mime",
+ "spin",
+ "version_check",
+]
+
+[[package]]
+name = "mysql-common-derive"
+version = "0.32.1"
+source = "git+https://github.com/t8y2/rust_mysql_common.git?rev=5b30d4912ebb23728f1196b2b9eb928eebb73f92#5b30d4912ebb23728f1196b2b9eb928eebb73f92"
+dependencies = [
+ "darling 0.20.11",
+ "heck 0.5.0",
+ "num-bigint",
+ "proc-macro-crate 3.5.0",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "termcolor",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "mysql_async"
+version = "0.36.2"
+source = "git+https://github.com/t8y2/mysql_async.git?rev=7b565fbe76a168828189f7b98fe3b1989344c54e#7b565fbe76a168828189f7b98fe3b1989344c54e"
+dependencies = [
+ "bytes",
+ "crossbeam-queue",
+ "flate2",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "keyed_priority_queue",
+ "lru",
+ "mysql_common",
+ "pem",
+ "percent-encoding",
+ "rand 0.9.4",
+ "rustls 0.23.40",
+ "rustls-pemfile 2.2.0",
+ "serde",
+ "serde_json",
+ "socket2 0.5.10",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-rustls 0.26.4",
+ "tokio-util",
+ "twox-hash",
+ "url",
+ "webpki-roots 0.26.11",
+]
+
+[[package]]
+name = "mysql_common"
+version = "0.35.5"
+source = "git+https://github.com/t8y2/rust_mysql_common.git?rev=5b30d4912ebb23728f1196b2b9eb928eebb73f92#5b30d4912ebb23728f1196b2b9eb928eebb73f92"
+dependencies = [
+ "base64 0.22.1",
+ "bitflags 2.11.1",
+ "btoi",
+ "byteorder",
+ "bytes",
+ "chrono",
+ "crc32fast",
+ "curve25519-dalek 4.1.3",
+ "flate2",
+ "getrandom 0.3.4",
+ "mysql-common-derive",
+ "num-bigint",
+ "num-traits",
+ "regex",
+ "rust_decimal",
+ "saturating",
+ "serde",
+ "serde_json",
+ "sha1 0.10.6",
+ "sha2 0.10.9",
+ "thiserror 2.0.18",
+ "uuid",
+]
+
+[[package]]
+name = "native-tls"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "465500e14ea162429d264d44189adc38b199b62b1c21eea9f69e4b73cb03bbf2"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe 0.2.1",
+ "openssl-sys",
+ "schannel",
+ "security-framework 3.7.0",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "ndk"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4"
+dependencies = [
+ "bitflags 2.11.1",
+ "jni-sys 0.3.1",
+ "log",
+ "ndk-sys",
+ "num_enum",
+ "raw-window-handle",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "ndk-context"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27b02d87554356db9e9a873add8782d4ea6e3e58ea071a9adb9a2e8ddb884a8b"
+
+[[package]]
+name = "ndk-sys"
+version = "0.6.0+11769913"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873"
+dependencies = [
+ "jni-sys 0.3.1",
+]
+
+[[package]]
+name = "new_debug_unreachable"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
+
+[[package]]
+name = "nix"
+version = "0.31.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d"
+dependencies = [
+ "bitflags 2.11.1",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ntapi"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3b335231dfd352ffb0f8017f3b6027a4917f7df785ea2143d8af2adc66980ae"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "nu-ansi-term"
+version = "0.50.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint-dig"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e661dda6640fad38e827a6d4a310ff4763082116fe217f279885c97f511bb0b7"
+dependencies = [
+ "lazy_static",
+ "libm",
+ "num-integer",
+ "num-iter",
+ "num-traits",
+ "rand 0.8.6",
+ "serde",
+ "smallvec",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441"
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "num_threads"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "objc2"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
+dependencies = [
+ "objc2-encode",
+ "objc2-exception-helper",
+]
+
+[[package]]
+name = "objc2-app-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-cloud-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-data"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
+dependencies = [
+ "bitflags 2.11.1",
+ "dispatch2",
+ "objc2",
+]
+
+[[package]]
+name = "objc2-core-graphics"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
+dependencies = [
+ "bitflags 2.11.1",
+ "dispatch2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-io-surface",
+]
+
+[[package]]
+name = "objc2-core-image"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-location"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca347214e24bc973fc025fd0d36ebb179ff30536ed1f80252706db19ee452009"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-text"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
+[[package]]
+name = "objc2-exception-helper"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7a1c5fbb72d7735b076bb47b578523aedc40f3c439bea6dfd595c089d79d98a"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "objc2-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "libc",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-io-surface"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-osa-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f112d1746737b0da274ef79a23aac283376f335f4095a083a267a082f21db0c0"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-quartz-core"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-system-configuration"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7216bd11cbda54ccabcab84d523dc93b858ec75ecfb3a7d89513fa22464da396"
+dependencies = [
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-ui-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "objc2",
+ "objc2-cloud-kit",
+ "objc2-core-data",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-core-image",
+ "objc2-core-location",
+ "objc2-core-text",
+ "objc2-foundation",
+ "objc2-quartz-core",
+ "objc2-user-notifications",
+]
+
+[[package]]
+name = "objc2-user-notifications"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9df9128cbbfef73cda168416ccf7f837b62737d748333bfe9ab71c245d76613e"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-web-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2e5aaab980c433cf470df9d7af96a7b46a9d892d521a2cbbb2f8a4c16751e7f"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "object"
+version = "0.37.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+dependencies = [
+ "critical-section",
+ "portable-atomic",
+]
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "open"
+version = "5.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fbaa89d2ddc8473c78a3adf69eea8cffa28c483b8e02a971ef31527cd0fc92c"
+dependencies = [
+ "dunce",
+ "is-wsl",
+ "libc",
+ "pathdiff",
+]
+
+[[package]]
+name = "openssl"
+version = "0.10.80"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a45fa2aa886c42762255da344f0a0d313e254066c46aad76f300c3d3da62d967"
+dependencies = [
+ "bitflags 2.11.1",
+ "cfg-if",
+ "foreign-types 0.3.2",
+ "libc",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
+
+[[package]]
+name = "openssl-src"
+version = "300.6.1+3.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46eb8fb9fb3b61ce1c0f8a026c4c1a0714d3a9e138e7fbde78753ce2babc3846"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.116"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28a22dc7140cda5f096e5e7724a6962ca81a7f8bfd2979f9b18c11af56318c4"
+dependencies = [
+ "cc",
+ "libc",
+ "openssl-src",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "ordered-multimap"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49203cdcae0030493bad186b28da2fa25645fa276a51b6fec8010d281e02ef79"
+dependencies = [
+ "dlv-list",
+ "hashbrown 0.14.5",
+]
+
+[[package]]
+name = "ordered-stream"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "os_pipe"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "osakit"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "732c71caeaa72c065bb69d7ea08717bd3f4863a4f451402fc9513e29dbd5261b"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+ "objc2-osa-kit",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "p256"
+version = "0.14.0-rc.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "018bfbb86e05fd70a83e985921241035ee09fcd369c4a2c3680b389a01d2ad28"
+dependencies = [
+ "ecdsa",
+ "elliptic-curve",
+ "primefield",
+ "primeorder",
+ "sha2 0.11.0",
+]
+
+[[package]]
+name = "p384"
+version = "0.14.0-rc.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c91df688211f5957dbe2ab599dcbcaade8d6d3cdc15c5b350d350d7d07ce423"
+dependencies = [
+ "ecdsa",
+ "elliptic-curve",
+ "fiat-crypto 0.3.0",
+ "primefield",
+ "primeorder",
+ "sha2 0.11.0",
+]
+
+[[package]]
+name = "p521"
+version = "0.14.0-rc.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de6cd9451de522549d36cc78a1b45a699a3d55a872e8ea0c8f0318e502d99e2c"
+dependencies = [
+ "base16ct",
+ "ecdsa",
+ "elliptic-curve",
+ "primefield",
+ "primeorder",
+ "sha2 0.11.0",
+]
+
+[[package]]
+name = "pageant"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f3a5ae18f65a85c67a77d18d42d3606c07948e3c17c1e5f74852b26589e88a5"
+dependencies = [
+ "base16ct",
+ "byteorder",
+ "bytes",
+ "delegate",
+ "futures",
+ "log",
+ "rand 0.10.1",
+ "sha2 0.11.0",
+ "thiserror 2.0.18",
+ "tokio",
+ "windows 0.62.2",
+ "windows-strings 0.5.1",
+]
+
+[[package]]
+name = "pango"
+version = "0.18.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ca27ec1eb0457ab26f3036ea52229edbdb74dee1edd29063f5b9b010e7ebee4"
+dependencies = [
+ "gio",
+ "glib",
+ "libc",
+ "once_cell",
+ "pango-sys",
+]
+
+[[package]]
+name = "pango-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436737e391a843e5933d6d9aa102cb126d501e815b83601365a948a518555dc5"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "parking"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "password-hash"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
+dependencies = [
+ "base64ct",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "pathdiff"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
+
+[[package]]
+name = "pathfinder_geometry"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b7e7b4ea703700ce73ebf128e1450eb69c3a8329199ffbfb9b2a0418e5ad3"
+dependencies = [
+ "log",
+ "pathfinder_simd",
+]
+
+[[package]]
+name = "pathfinder_simd"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4500030c302e4af1d423f36f3b958d1aecb6c04184356ed5a833bf6b60435777"
+dependencies = [
+ "rustc_version",
+]
+
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest 0.10.7",
+ "hmac 0.12.1",
+]
+
+[[package]]
+name = "pbkdf2"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "112d82ceb8c5bf524d9af484d4e4970c9fd5a0cc15ba14ad93dccd28873b0629"
+dependencies = [
+ "digest 0.11.3",
+ "hmac 0.13.0",
+]
+
+[[package]]
+name = "pem"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d30c53c26bc5b31a98cd02d20f25a7c8567146caf63ed593a9d87b2775291be"
+dependencies = [
+ "base64 0.22.1",
+ "serde_core",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6305423e0e7738146434843d1694d621cce767262b2a86910beab705e4493d9"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "petgraph"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
+dependencies = [
+ "fixedbitset",
+ "hashbrown 0.15.5",
+ "indexmap 2.14.0",
+]
+
+[[package]]
+name = "phf"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
+dependencies = [
+ "phf_macros",
+ "phf_shared",
+ "serde",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49aa7f9d80421bca176ca8dbfebe668cc7a2684708594ec9f3c0db0805d5d6e1"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"
+dependencies = [
+ "fastrand",
+ "phf_shared",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "piper"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"
+dependencies = [
+ "atomic-waker",
+ "fastrand",
+ "futures-io",
+]
+
+[[package]]
+name = "pkcs1"
+version = "0.8.0-rc.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "986d2e952779af96ea048f160fd9194e1751b4faea78bcf3ceb456efe008088e"
+dependencies = [
+ "der 0.8.0",
+ "spki 0.8.0-rc.4",
+]
+
+[[package]]
+name = "pkcs5"
+version = "0.8.0-rc.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5a777c6e26664bc9504b3ce3f6133f8f20d9071f130a4f9fcbd3186959d8dd6"
+dependencies = [
+ "aes 0.9.0",
+ "aes-gcm 0.11.0-rc.3",
+ "cbc 0.2.1",
+ "der 0.8.0",
+ "pbkdf2 0.13.0",
+ "rand_core 0.10.1",
+ "scrypt",
+ "sha2 0.11.0",
+ "spki 0.8.0-rc.4",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.11.0-rc.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12922b6296c06eb741b02d7b5161e3aaa22864af38dfa025a1a3ba3f68c84577"
+dependencies = [
+ "der 0.8.0",
+ "pkcs5",
+ "rand_core 0.10.1",
+ "spki 0.8.0-rc.4",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
+
+[[package]]
+name = "plist"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "092791278e026273c1b65bbdcfbba3a300f2994c896bd01ab01da613c29c46f1"
+dependencies = [
+ "base64 0.22.1",
+ "indexmap 2.14.0",
+ "quick-xml 0.39.4",
+ "serde",
+ "time",
+]
+
+[[package]]
+name = "png"
+version = "0.17.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526"
+dependencies = [
+ "bitflags 1.3.2",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "png"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+dependencies = [
+ "bitflags 2.11.1",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "polling"
+version = "3.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
+dependencies = [
+ "cfg-if",
+ "concurrent-queue",
+ "hermit-abi",
+ "pin-project-lite",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "poly1305"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
+dependencies = [
+ "cpufeatures 0.2.17",
+ "opaque-debug",
+ "universal-hash 0.5.1",
+]
+
+[[package]]
+name = "polyval"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "opaque-debug",
+ "universal-hash 0.5.1",
+]
+
+[[package]]
+name = "polyval"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dfc63250416fea14f5749b90725916a6c903f599d51cb635aa7a52bfd03eede"
+dependencies = [
+ "cpubits",
+ "cpufeatures 0.3.0",
+ "universal-hash 0.6.1",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "portpicker"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be97d76faf1bfab666e1375477b23fde79eccf0276e9b63b92a39d676a889ba9"
+dependencies = [
+ "rand 0.8.6",
+]
+
+[[package]]
+name = "postgres-protocol"
+version = "0.6.11"
+source = "git+https://github.com/t8y2/tokio-postgres-gaussdb.git?branch=master#8d50befeee7cdeb8ecdb97c7b790c91010971063"
+dependencies = [
+ "base64 0.22.1",
+ "byteorder",
+ "bytes",
+ "fallible-iterator 0.2.0",
+ "hmac 0.13.0",
+ "md-5 0.11.0",
+ "memchr",
+ "pbkdf2 0.12.2",
+ "rand 0.10.1",
+ "sha1 0.10.6",
+ "sha2 0.11.0",
+ "stringprep",
+]
+
+[[package]]
+name = "postgres-types"
+version = "0.2.13"
+source = "git+https://github.com/t8y2/tokio-postgres-gaussdb.git?branch=master#8d50befeee7cdeb8ecdb97c7b790c91010971063"
+dependencies = [
+ "bytes",
+ "chrono",
+ "fallible-iterator 0.2.0",
+ "postgres-protocol",
+ "serde_core",
+ "serde_json",
+ "uuid",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppmd-rust"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efca4c95a19a79d1c98f791f10aebd5c1363b473244630bb7dbde1dc98455a24"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "precomputed-hash"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
+[[package]]
+name = "prefix-trie"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cf6e3177f0684016a5c209b00882e15f8bdd3f3bb48f0491df10cd102d0c6e7"
+dependencies = [
+ "either",
+ "ipnet",
+ "num-traits",
+]
+
+[[package]]
+name = "pretty-hex"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6fa0831dd7cc608c38a5e323422a0077678fa5744aa2be4ad91c4ece8eec8d5"
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "primefield"
+version = "0.14.0-rc.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93401c13cc7ff24684571cfca9d3cf9ebabfaf3d4b7b9963ade41ec54da196b5"
+dependencies = [
+ "crypto-bigint",
+ "crypto-common 0.2.2",
+ "rand_core 0.10.1",
+ "rustcrypto-ff",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "primeorder"
+version = "0.14.0-rc.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0c5c8a39bcd764bfedf456e8d55e115fe86dda3e0f555371849f2a41cbc9706"
+dependencies = [
+ "elliptic-curve",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
+dependencies = [
+ "once_cell",
+ "toml_edit 0.19.15",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b00f26d3400549137f92511a46ac1cd8ce37cb5598a96d382381458b992a5d24"
+dependencies = [
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
+dependencies = [
+ "toml_edit 0.25.11+spec-1.1.0",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "proc-macro-error2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11ec05c52be0a07b08061f7dd003e7d7092e0472bc731b4af7bb1ef876109802"
+dependencies = [
+ "proc-macro-error-attr2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "psm"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645dbe486e346d9b5de3ef16ede18c26e6c70ad97418f4874b8b1889d6e761ea"
+dependencies = [
+ "ar_archive_writer",
+ "cc",
+]
+
+[[package]]
+name = "ptr_meta"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
+dependencies = [
+ "ptr_meta_derive",
+]
+
+[[package]]
+name = "ptr_meta_derive"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "pxfm"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e0c5ccf5294c6ccd63a74f1565028353830a9c2f5eb0c682c355c471726a6e3f"
+
+[[package]]
+name = "quick-error"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
+
+[[package]]
+name = "quick-xml"
+version = "0.37.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
+dependencies = [
+ "encoding_rs",
+ "memchr",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.39.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdcc8dd4e2f670d309a5f0e83fe36dfdc05af317008fea29144da1a2ac858e5e"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quinn"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
+dependencies = [
+ "bytes",
+ "cfg_aliases",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash",
+ "rustls 0.23.40",
+ "socket2 0.6.3",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
+dependencies = [
+ "bytes",
+ "getrandom 0.3.4",
+ "lru-slab",
+ "rand 0.9.4",
+ "ring",
+ "rustc-hash",
+ "rustls 0.23.40",
+ "rustls-pki-types",
+ "slab",
+ "thiserror 2.0.18",
+ "tinyvec",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
+dependencies = [
+ "cfg_aliases",
+ "libc",
+ "once_cell",
+ "socket2 0.6.3",
+ "tracing",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
+dependencies = [
+ "chacha20 0.10.0",
+ "getrandom 0.4.2",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.17",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
+[[package]]
+name = "raw-window-handle"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
+
+[[package]]
+name = "rayon"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "recursive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0786a43debb760f491b1bc0269fe5e84155353c67482b9e60d0cfb596054b43e"
+dependencies = [
+ "recursive-proc-macro-impl",
+ "stacker",
+]
+
+[[package]]
+name = "recursive-proc-macro-impl"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76009fbe0614077fc1a2ce255e3a1881a2e3a3527097d5dc6d8212c585e7e38b"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "redis"
+version = "0.32.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "014cc767fefab6a3e798ca45112bccad9c6e0e218fbd49720042716c73cfef44"
+dependencies = [
+ "bytes",
+ "cfg-if",
+ "combine",
+ "crc16",
+ "futures-sink",
+ "futures-util",
+ "itoa",
+ "log",
+ "num-bigint",
+ "percent-encoding",
+ "pin-project-lite",
+ "rand 0.9.4",
+ "rustls 0.23.40",
+ "rustls-native-certs 0.8.3",
+ "ryu",
+ "sha1_smol",
+ "socket2 0.6.3",
+ "tokio",
+ "tokio-rustls 0.26.4",
+ "tokio-util",
+ "url",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.11.1",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "ref-cast"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+
+[[package]]
+name = "rend"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71fe3824f5629716b1589be05dacd749f6aa084c87e00e016714a8cdfccc997c"
+dependencies = [
+ "bytecheck",
+]
+
+[[package]]
+name = "reqwest"
+version = "0.12.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "encoding_rs",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-tls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "mime",
+ "native-tls",
+ "percent-encoding",
+ "pin-project-lite",
+ "quinn",
+ "rustls 0.23.40",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tokio-native-tls",
+ "tokio-rustls 0.26.4",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams 0.4.2",
+ "web-sys",
+ "webpki-roots 1.0.7",
+]
+
+[[package]]
+name = "reqwest"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62e0021ea2c22aed41653bc7e1419abb2c97e038ff2c33d0e1309e49a97deec0"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls 0.23.40",
+ "rustls-pki-types",
+ "rustls-platform-verifier",
+ "serde",
+ "serde_json",
+ "sync_wrapper",
+ "tokio",
+ "tokio-rustls 0.26.4",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams 0.5.0",
+ "web-sys",
+]
+
+[[package]]
+name = "resolv-conf"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e061d1b48cb8d38042de4ae0a7a6401009d6143dc80d2e2d6f31f0bdd6470c7"
+
+[[package]]
+name = "rfc6979"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5236ce872cac07e0fb3969b0cbf468c7d2f37d432f1b627dcb7b8d34563fb0c3"
+dependencies = [
+ "hmac 0.13.0",
+ "subtle",
+]
+
+[[package]]
+name = "rfd"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a15ad77d9e70a92437d8f74c35d99b4e4691128df018833e99f90bcd36152672"
+dependencies = [
+ "block2",
+ "dispatch2",
+ "glib-sys",
+ "gobject-sys",
+ "gtk-sys",
+ "js-sys",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "raw-window-handle",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted 0.9.0",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rkyv"
+version = "0.7.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2297bf9c81a3f0dc96bc9521370b88f054168c29826a75e89c55ff196e7ed6a1"
+dependencies = [
+ "bitvec",
+ "bytecheck",
+ "bytes",
+ "hashbrown 0.12.3",
+ "ptr_meta",
+ "rend",
+ "rkyv_derive",
+ "seahash",
+ "tinyvec",
+ "uuid",
+]
+
+[[package]]
+name = "rkyv_derive"
+version = "0.7.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84d7b42d4b8d06048d3ac8db0eb31bcb942cbeb709f0b5f2b2ebde398d3038f5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "rsa"
+version = "0.10.0-rc.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fb9fd8c1edd9e6a2693623baf0fe77ff05ce022a5d7746900ffc38a15c233de"
+dependencies = [
+ "const-oid 0.10.2",
+ "crypto-bigint",
+ "crypto-primes",
+ "digest 0.11.3",
+ "pkcs1",
+ "pkcs8",
+ "rand_core 0.10.1",
+ "sha2 0.11.0",
+ "signature",
+ "spki 0.8.0-rc.4",
+ "zeroize",
+]
+
+[[package]]
+name = "rusqlite"
+version = "0.32.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7753b721174eb8ff87a9a0e799e2d7bc3749323e773db92e0984debb00019d6e"
+dependencies = [
+ "bitflags 2.11.1",
+ "fallible-iterator 0.3.0",
+ "fallible-streaming-iterator",
+ "hashlink 0.9.1",
+ "libsqlite3-sys",
+ "smallvec",
+]
+
+[[package]]
+name = "russh"
+version = "0.60.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "324b92f459d3e42da294e14e8eb150d2215fcfb7c966838bc1127cd68bc05a0d"
+dependencies = [
+ "aead 0.6.0-rc.10",
+ "aes 0.8.4",
+ "aes 0.9.0",
+ "aes-gcm 0.11.0-rc.3",
+ "aws-lc-rs",
+ "bitflags 2.11.1",
+ "block-padding 0.3.3",
+ "byteorder",
+ "bytes",
+ "cbc 0.1.2",
+ "cbc 0.2.1",
+ "cipher 0.5.2",
+ "crypto-bigint",
+ "ctr 0.10.1",
+ "ctr 0.9.2",
+ "curve25519-dalek 5.0.0-pre.6",
+ "data-encoding",
+ "delegate",
+ "der 0.8.0",
+ "digest 0.10.7",
+ "ecdsa",
+ "ed25519-dalek",
+ "elliptic-curve",
+ "enum_dispatch",
+ "flate2",
+ "futures",
+ "generic-array 1.4.1",
+ "getrandom 0.2.17",
+ "ghash 0.6.0",
+ "hex-literal",
+ "hkdf",
+ "hmac 0.12.1",
+ "hmac 0.13.0",
+ "inout 0.1.4",
+ "internal-russh-forked-ssh-key",
+ "internal-russh-num-bigint",
+ "keccak",
+ "log",
+ "md5",
+ "ml-kem",
+ "module-lattice",
+ "num-bigint",
+ "p256",
+ "p384",
+ "p521",
+ "pageant",
+ "pbkdf2 0.12.2",
+ "pbkdf2 0.13.0",
+ "pkcs1",
+ "pkcs5",
+ "pkcs8",
+ "polyval 0.7.1",
+ "rand 0.10.1",
+ "rand_core 0.10.1",
+ "rsa",
+ "russh-cryptovec",
+ "russh-util",
+ "salsa20",
+ "scrypt",
+ "sec1",
+ "sha1 0.10.6",
+ "sha1 0.11.0",
+ "sha2 0.10.9",
+ "sha2 0.11.0",
+ "sha3",
+ "signature",
+ "spki 0.8.0-rc.4",
+ "ssh-encoding",
+ "subtle",
+ "thiserror 2.0.18",
+ "tokio",
+ "typenum",
+ "universal-hash 0.6.1",
+ "zeroize",
+]
+
+[[package]]
+name = "russh-cryptovec"
+version = "0.60.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37cb4d0360bdd8935392a306d8b5edb539cc455b30e8bf13dd213a0cf7879b40"
+dependencies = [
+ "log",
+ "nix",
+ "ssh-encoding",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "russh-util"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "668424a5dde0bcb45b55ba7de8476b93831b4aa2fa6947e145f3b053e22c60b6"
+dependencies = [
+ "chrono",
+ "tokio",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+]
+
+[[package]]
+name = "rust-ini"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "796e8d2b6696392a43bea58116b667fb4c29727dc5abd27d6acf338bb4f688c7"
+dependencies = [
+ "cfg-if",
+ "ordered-multimap",
+]
+
+[[package]]
+name = "rust_decimal"
+version = "1.42.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c5108e3d4d903e21aac27f12ba5377b6b34f9f44b325e4894c7924169d06995"
+dependencies = [
+ "arrayvec",
+ "borsh",
+ "bytes",
+ "num-traits",
+ "postgres-types",
+ "rand 0.8.6",
+ "rkyv",
+ "serde",
+ "serde_json",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustc_version_runtime"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dd18cd2bae1820af0b6ad5e54f4a51d0f3fcc53b05f845675074efcc7af071d"
+dependencies = [
+ "rustc_version",
+ "semver",
+]
+
+[[package]]
+name = "rustcrypto-ff"
+version = "0.14.0-rc.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd2a8adb347447693cd2ba0d218c4b66c62da9b0a5672b17b981e4291ec65ff6"
+dependencies = [
+ "rand_core 0.10.1",
+ "subtle",
+]
+
+[[package]]
+name = "rustcrypto-group"
+version = "0.14.0-rc.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "369f9b61aa45933c062c9f6b5c3c50ab710687eca83dd3802653b140b43f85ed"
+dependencies = [
+ "rand_core 0.10.1",
+ "rustcrypto-ff",
+ "subtle",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
+dependencies = [
+ "bitflags 2.11.1",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.15",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags 2.11.1",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.12.1",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls"
+version = "0.21.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
+dependencies = [
+ "log",
+ "ring",
+ "rustls-webpki 0.101.7",
+ "sct",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef86cd5876211988985292b91c96a8f2d298df24e75989a43a3c73f2d4d8168b"
+dependencies = [
+ "aws-lc-rs",
+ "log",
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki 0.103.13",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9aace74cb666635c918e9c12bc0d348266037aa8eb599b5cba565709a8dff00"
+dependencies = [
+ "openssl-probe 0.1.6",
+ "rustls-pemfile 1.0.4",
+ "schannel",
+ "security-framework 2.11.1",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
+dependencies = [
+ "openssl-probe 0.2.1",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework 3.7.0",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
+dependencies = [
+ "base64 0.21.7",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30a7197ae7eb376e574fe940d068c30fe0462554a3ddbe4eca7838e049c937a9"
+dependencies = [
+ "web-time",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d1e2536ce4f35f4846aa13bff16bd0ff40157cdb14cc056c7b14ba41233ba0"
+dependencies = [
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "jni 0.22.4",
+ "log",
+ "once_cell",
+ "rustls 0.23.40",
+ "rustls-native-certs 0.8.3",
+ "rustls-platform-verifier-android",
+ "rustls-webpki 0.103.13",
+ "security-framework 3.7.0",
+ "security-framework-sys",
+ "webpki-root-certs",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.101.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
+dependencies = [
+ "ring",
+ "untrusted 0.9.0",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
+dependencies = [
+ "aws-lc-rs",
+ "ring",
+ "rustls-pki-types",
+ "untrusted 0.9.0",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "salsa20"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f874456e72520ff1375a06c588eaf074b0f01f9e9e1aada45bd9b7954a6e42c"
+dependencies = [
+ "cfg-if",
+ "cipher 0.5.2",
+]
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "saturating"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ece8e78b2f38ec51c51f5d475df0a7187ba5111b2a28bdc761ee05b075d40a71"
+
+[[package]]
+name = "schannel"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "schemars"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
+dependencies = [
+ "dyn-clone",
+ "indexmap 1.9.3",
+ "schemars_derive",
+ "serde",
+ "serde_json",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "schemars"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars_derive"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "scrypt"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d87af57419b594aa23fa95f09f0e06d80d84ba01c26148c43844cad6ff4485f0"
+dependencies = [
+ "cfg-if",
+ "pbkdf2 0.13.0",
+ "salsa20",
+ "sha2 0.11.0",
+]
+
+[[package]]
+name = "sct"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
+dependencies = [
+ "ring",
+ "untrusted 0.9.0",
+]
+
+[[package]]
+name = "seahash"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
+
+[[package]]
+name = "sec1"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d56d437c2f19203ce5f7122e507831de96f3d2d4d3be5af44a0b0a09d8a80e4d"
+dependencies = [
+ "base16ct",
+ "ctutils",
+ "der 0.8.0",
+ "hybrid-array",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "security-framework"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "selectors"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5d9c0c92a92d33f08817311cf3f2c29a3538a8240e94a6a3c622ce652d7e00c"
+dependencies = [
+ "bitflags 2.11.1",
+ "cssparser",
+ "derive_more",
+ "log",
+ "new_debug_unreachable",
+ "phf",
+ "phf_codegen",
+ "precomputed-hash",
+ "rustc-hash",
+ "servo_arc",
+ "smallvec",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-untagged"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9faf48a4a2d2693be24c6289dbe26552776eb7737074e6722891fadbe6c5058"
+dependencies = [
+ "erased-serde",
+ "serde",
+ "serde_core",
+ "typeid",
+]
+
+[[package]]
+name = "serde_bytes"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_derive_internals"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.150"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
+dependencies = [
+ "indexmap 2.14.0",
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_path_to_error"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "10a9ff822e371bb5403e391ecd83e182e0e77ba7f6fe0160b795797109d1b457"
+dependencies = [
+ "itoa",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde_repr"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_with"
+version = "3.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e72c1c2cb7b223fafb600a619537a871c2818583d619401b785e7c0b746ccde2"
+dependencies = [
+ "base64 0.22.1",
+ "bs58",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.14.0",
+ "schemars 0.9.0",
+ "schemars 1.2.1",
+ "serde_core",
+ "serde_json",
+ "serde_with_macros",
+ "time",
+]
+
+[[package]]
+name = "serde_with_macros"
+version = "3.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b90c488738ecb4fb0262f41f43bc40efc5868d9fb744319ddf5f5317f417bfac"
+dependencies = [
+ "darling 0.23.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serdect"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66cf8fedced2fcf12406bcb34223dffb92eaf34908ede12fed414c82b7f00b3e"
+dependencies = [
+ "base16ct",
+ "serde",
+]
+
+[[package]]
+name = "serialize-to-javascript"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04f3666a07a197cdb77cdf306c32be9b7f598d7060d50cfd4d5aa04bfd92f6c5"
+dependencies = [
+ "serde",
+ "serde_json",
+ "serialize-to-javascript-impl",
+]
+
+[[package]]
+name = "serialize-to-javascript-impl"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "772ee033c0916d670af7860b6e1ef7d658a4629a6d0b4c8c3e67f09b3765b75d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "servo_arc"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "170fb83ab34de17dc69aa7c67482b22218ddb85da56546f9bd6b929e32a05930"
+dependencies = [
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha1"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "digest 0.11.3",
+]
+
+[[package]]
+name = "sha1_smol"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d"
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha2"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "digest 0.11.3",
+]
+
+[[package]]
+name = "sha3"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be176f1a57ce4e3d31c1a166222d9768de5954f811601fb7ca06fc8203905ce1"
+dependencies = [
+ "digest 0.11.3",
+ "keccak",
+]
+
+[[package]]
+name = "sharded-slab"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+dependencies = [
+ "lazy_static",
+]
+
+[[package]]
+name = "shared_child"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e362d9935bc50f019969e2f9ecd66786612daae13e8f277be7bfb66e8bed3f7"
+dependencies = [
+ "libc",
+ "sigchld",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "sigchld"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47106eded3c154e70176fc83df9737335c94ce22f821c32d17ed1db1f83badb1"
+dependencies = [
+ "libc",
+ "os_pipe",
+ "signal-hook",
+]
+
+[[package]]
+name = "signal-hook"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
+dependencies = [
+ "libc",
+ "signal-hook-registry",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "signature"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d567dcbaf0049cb8ac2608a76cd95ff9e4412e1899d389ee400918ca7537f5"
+dependencies = [
+ "digest 0.11.3",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
+[[package]]
+name = "simd_cesu8"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94f90157bb87cddf702797c5dadfa0be7d266cdf49e22da2fcaa32eff75b2c33"
+dependencies = [
+ "rustc_version",
+ "simdutf8",
+]
+
+[[package]]
+name = "simdutf8"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
+
+[[package]]
+name = "simple_asn1"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d585997b0ac10be3c5ee635f1bab02d512760d14b7c468801ac8a01d9ae5f1d"
+dependencies = [
+ "num-bigint",
+ "num-traits",
+ "thiserror 2.0.18",
+ "time",
+]
+
+[[package]]
+name = "siphasher"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ee5873ec9cce0195efcb7a4e9507a04cd49aec9c83d0389df45b1ef7ba2e649"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "socket2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "socket2"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "softbuffer"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aac18da81ebbf05109ab275b157c22a653bb3c12cf884450179942f81bcbf6c3"
+dependencies = [
+ "bytemuck",
+ "js-sys",
+ "ndk",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "objc2-quartz-core",
+ "raw-window-handle",
+ "redox_syscall",
+ "tracing",
+ "wasm-bindgen",
+ "web-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "soup3"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "471f924a40f31251afc77450e781cb26d55c0b650842efafc9c6cbd2f7cc4f9f"
+dependencies = [
+ "futures-channel",
+ "gio",
+ "glib",
+ "libc",
+ "soup3-sys",
+]
+
+[[package]]
+name = "soup3-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ebe8950a680a12f24f15ebe1bf70db7af98ad242d9db43596ad3108aab86c27"
+dependencies = [
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der 0.7.10",
+]
+
+[[package]]
+name = "spki"
+version = "0.8.0-rc.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8baeff88f34ed0691978ec34440140e1572b68c7dd4a495fd14a3dc1944daa80"
+dependencies = [
+ "base64ct",
+ "der 0.8.0",
+]
+
+[[package]]
+name = "sqlparser"
+version = "0.62.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c6d1b651dc4edf07eead2a0c6c78016ce971bc2c10da5266861b13f25e7cec"
+dependencies = [
+ "log",
+ "recursive",
+ "sqlparser_derive",
+]
+
+[[package]]
+name = "sqlparser_derive"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6dd45d8fc1c79299bfbb7190e42ccbbdf6a5f52e4a6ad98d92357ea965bd289"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "ssh-cipher"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caac132742f0d33c3af65bfcde7f6aa8f62f0e991d80db99149eb9d44708784f"
+dependencies = [
+ "aes 0.8.4",
+ "aes-gcm 0.10.3",
+ "cbc 0.1.2",
+ "chacha20 0.9.1",
+ "cipher 0.4.4",
+ "ctr 0.9.2",
+ "poly1305",
+ "ssh-encoding",
+ "subtle",
+]
+
+[[package]]
+name = "ssh-encoding"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9242b9ef4108a78e8cd1a2c98e193ef372437f8c22be363075233321dd4a15"
+dependencies = [
+ "base64ct",
+ "bytes",
+ "pem-rfc7468 0.7.0",
+ "sha2 0.10.9",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "stacker"
+version = "0.1.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "640c8cdd92b6b12f5bcb1803ca3bbf5ab96e5e6b6b96b9ab77dabe9e880b3190"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "libc",
+ "psm",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "string_cache"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a18596f8c785a729f2819c0f6a7eae6ebeebdfffbfe4214ae6b087f690e31901"
+dependencies = [
+ "new_debug_unreachable",
+ "parking_lot",
+ "phf_shared",
+ "precomputed-hash",
+]
+
+[[package]]
+name = "string_cache_codegen"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "585635e46db231059f76c5849798146164652513eb9e8ab2685939dd90f29b69"
+dependencies = [
+ "phf_generator",
+ "phf_shared",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "stringprep"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+ "unicode-properties",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "strum"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "swift-rs"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4057c98e2e852d51fdcfca832aac7b571f6b351ad159f9eda5db1655f8d0c4d7"
+dependencies = [
+ "base64 0.21.7",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "sysinfo"
+version = "0.32.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c33cd241af0f2e9e3b5c32163b873b29956890b5342e6745b917ce9d490f4af"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+ "memchr",
+ "ntapi",
+ "rayon",
+ "windows 0.57.0",
+]
+
+[[package]]
+name = "system-configuration"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.9.4",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "system-deps"
+version = "6.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
+dependencies = [
+ "cfg-expr",
+ "heck 0.5.0",
+ "pkg-config",
+ "toml 0.8.2",
+ "version-compare",
+]
+
+[[package]]
+name = "tagptr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
+
+[[package]]
+name = "take_mut"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60"
+
+[[package]]
+name = "tao"
+version = "0.35.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1c93047acf68669466a34690ac58cca7010bd1b201e1ec86f1fd0a75d3dd4a9"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "core-foundation 0.10.1",
+ "core-graphics 0.25.0",
+ "crossbeam-channel",
+ "dbus",
+ "dispatch2",
+ "dlopen2",
+ "dpi",
+ "gdkwayland-sys",
+ "gdkx11-sys",
+ "gtk",
+ "jni 0.21.1",
+ "libc",
+ "log",
+ "ndk",
+ "ndk-sys",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "once_cell",
+ "parking_lot",
+ "percent-encoding",
+ "raw-window-handle",
+ "tao-macros",
+ "unicode-segmentation",
+ "url",
+ "windows 0.61.3",
+ "windows-core 0.61.2",
+ "windows-version",
+ "x11-dl",
+]
+
+[[package]]
+name = "tao-macros"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4e16beb8b2ac17db28eab8bca40e62dbfbb34c0fcdc6d9826b11b7b5d047dfd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "tar"
+version = "0.4.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "tauri"
+version = "2.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "437404997acf375d85f1177afa7e11bb971f274ed6a7b83a2a3e339015f4cc28"
+dependencies = [
+ "anyhow",
+ "bytes",
+ "cookie",
+ "dirs",
+ "dunce",
+ "embed_plist",
+ "getrandom 0.3.4",
+ "glob",
+ "gtk",
+ "heck 0.5.0",
+ "http",
+ "jni 0.21.1",
+ "libc",
+ "log",
+ "mime",
+ "muda",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "percent-encoding",
+ "plist",
+ "raw-window-handle",
+ "reqwest 0.13.3",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "serialize-to-javascript",
+ "swift-rs",
+ "tauri-build",
+ "tauri-macros",
+ "tauri-runtime",
+ "tauri-runtime-wry",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "tokio",
+ "tray-icon",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "window-vibrancy",
+ "windows 0.61.3",
+]
+
+[[package]]
+name = "tauri-build"
+version = "2.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4aa1f9055fc23919a54e4e125052bed16ed04aef0487086e758fe01a67b451c7"
+dependencies = [
+ "anyhow",
+ "cargo_toml",
+ "dirs",
+ "glob",
+ "heck 0.5.0",
+ "json-patch",
+ "schemars 0.8.22",
+ "semver",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "tauri-winres",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-codegen"
+version = "2.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4a0319528a025a38c4078e7dae2c446f4e63620ddb0659a643ede1cb38f90e9"
+dependencies = [
+ "base64 0.22.1",
+ "brotli",
+ "ico",
+ "json-patch",
+ "plist",
+ "png 0.17.16",
+ "proc-macro2",
+ "quote",
+ "semver",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+ "syn 2.0.117",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "time",
+ "url",
+ "uuid",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-macros"
+version = "2.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae6cb4e3896c21d2f6da5b31251d2faea0153bba56ed0e970f918115dbee4924"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "tauri-codegen",
+ "tauri-utils",
+]
+
+[[package]]
+name = "tauri-plugin"
+version = "2.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e126abc9e84e35cdfd01596140a73a1850cdb0df0a23acf0185776c30b469a6e"
+dependencies = [
+ "anyhow",
+ "glob",
+ "plist",
+ "schemars 0.8.22",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-plugin-clipboard-manager"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "206dc20af4ed210748ba945c2774e60fd0acd52b9a73a028402caf809e9b6ecf"
+dependencies = [
+ "arboard",
+ "log",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "tauri-plugin-deep-link"
+version = "2.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70ee75bc5627f77bfdf40c913255ebc258117b10ebe2b2239a1a1cf40b0b58aa"
+dependencies = [
+ "dunce",
+ "plist",
+ "rust-ini",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "tracing",
+ "url",
+ "windows-registry 0.5.3",
+ "windows-result 0.3.4",
+]
+
+[[package]]
+name = "tauri-plugin-dialog"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65981abb771e74e571a38196c3baa11c459379164791eba0e67abc1a5fac9884"
+dependencies = [
+ "log",
+ "raw-window-handle",
+ "rfd",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "tauri-plugin-fs",
+ "thiserror 2.0.18",
+ "url",
+]
+
+[[package]]
+name = "tauri-plugin-fs"
+version = "2.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7ecc274121aca0c036a2b42d1cbe83d368d348f54e0bb8a735c2b1548e8f371"
+dependencies = [
+ "anyhow",
+ "dunce",
+ "glob",
+ "log",
+ "objc2-foundation",
+ "percent-encoding",
+ "schemars 0.8.22",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "tauri",
+ "tauri-plugin",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "toml 1.1.2+spec-1.1.0",
+ "url",
+]
+
+[[package]]
+name = "tauri-plugin-log"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7545bd67f070a4500432c826e2e0682146a1d6712aee22a2786490156b574d93"
+dependencies = [
+ "android_logger",
+ "byte-unit",
+ "fern",
+ "log",
+ "objc2",
+ "objc2-foundation",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "swift-rs",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.18",
+ "time",
+]
+
+[[package]]
+name = "tauri-plugin-process"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d55511a7bf6cd70c8767b02c97bf8134fa434daf3926cfc1be0a0f94132d165a"
+dependencies = [
+ "tauri",
+ "tauri-plugin",
+]
+
+[[package]]
+name = "tauri-plugin-shell"
+version = "2.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8457dbf9e2bab1edd8df22bb2c20857a59a9868e79cb3eac5ed639eec4d0c73b"
+dependencies = [
+ "encoding_rs",
+ "log",
+ "open",
+ "os_pipe",
+ "regex",
+ "schemars 0.8.22",
+ "serde",
+ "serde_json",
+ "shared_child",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.18",
+ "tokio",
+]
+
+[[package]]
+name = "tauri-plugin-single-instance"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c8f29386f5e9fdc699182388a33ee80a56de436d91b67459e86afef426282af"
+dependencies = [
+ "serde",
+ "serde_json",
+ "tauri",
+ "thiserror 2.0.18",
+ "tracing",
+ "windows-sys 0.60.2",
+ "zbus",
+]
+
+[[package]]
+name = "tauri-plugin-updater"
+version = "2.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "806d9dac662c2e4594ff03c647a552f2c9bd544e7d0f683ec58f872f952ce4af"
+dependencies = [
+ "base64 0.22.1",
+ "dirs",
+ "flate2",
+ "futures-util",
+ "http",
+ "infer",
+ "log",
+ "minisign-verify",
+ "osakit",
+ "percent-encoding",
+ "reqwest 0.13.3",
+ "rustls 0.23.40",
+ "semver",
+ "serde",
+ "serde_json",
+ "tar",
+ "tauri",
+ "tauri-plugin",
+ "tempfile",
+ "thiserror 2.0.18",
+ "time",
+ "tokio",
+ "url",
+ "windows-sys 0.60.2",
+ "zip 4.6.1",
+]
+
+[[package]]
+name = "tauri-plugin-window-state"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73736611e14142408d15353e21e3cca2f12a3cfb523ad0ce85999b6d2ef1a704"
+dependencies = [
+ "bitflags 2.11.1",
+ "log",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "tauri-runtime"
+version = "2.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48222d7116c8807eaa6fe2f372e023fae125084e61e6eca6d70b7961cdf129ef"
+dependencies = [
+ "cookie",
+ "dpi",
+ "gtk",
+ "http",
+ "jni 0.21.1",
+ "objc2",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "raw-window-handle",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "windows 0.61.3",
+]
+
+[[package]]
+name = "tauri-runtime-wry"
+version = "2.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b83849ee63ecb27a8e8d0fe51915ca215076914aca43f96db1179f0f415f6cd9"
+dependencies = [
+ "gtk",
+ "http",
+ "jni 0.21.1",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "once_cell",
+ "percent-encoding",
+ "raw-window-handle",
+ "softbuffer",
+ "tao",
+ "tauri-runtime",
+ "tauri-utils",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "windows 0.61.3",
+ "wry",
+]
+
+[[package]]
+name = "tauri-utils"
+version = "2.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "092379df9a707631978e6c56b1bc2401d387f01e2d4a3c123360d167bbb9aa95"
+dependencies = [
+ "anyhow",
+ "brotli",
+ "cargo_metadata",
+ "ctor",
+ "dom_query",
+ "dunce",
+ "glob",
+ "http",
+ "infer",
+ "json-patch",
+ "log",
+ "memchr",
+ "phf",
+ "plist",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "schemars 0.8.22",
+ "semver",
+ "serde",
+ "serde-untagged",
+ "serde_json",
+ "serde_with",
+ "swift-rs",
+ "thiserror 2.0.18",
+ "toml 1.1.2+spec-1.1.0",
+ "url",
+ "urlpattern",
+ "uuid",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-winres"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc65d45c68858bfe420dd29e834b5d15dbecf8a07a8a16cf4d532c7b1f69d4b6"
+dependencies = [
+ "dunce",
+ "embed-resource",
+ "toml 1.1.2+spec-1.1.0",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.2",
+ "once_cell",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tendril"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4790fc369d5a530f4b544b094e31388b9b3a37c0f4652ade4505945f5660d24"
+dependencies = [
+ "new_debug_unreachable",
+ "utf-8",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "tiberius"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1446cb4198848d1562301a3340424b4f425ef79f35ef9ee034769a9dd92c10d"
+dependencies = [
+ "async-trait",
+ "asynchronous-codec",
+ "byteorder",
+ "bytes",
+ "chrono",
+ "connection-string",
+ "encoding_rs",
+ "enumflags2",
+ "futures-util",
+ "num-traits",
+ "once_cell",
+ "pin-project-lite",
+ "pretty-hex",
+ "rust_decimal",
+ "rustls-native-certs 0.6.3",
+ "rustls-pemfile 1.0.4",
+ "thiserror 1.0.69",
+ "tokio",
+ "tokio-rustls 0.24.1",
+ "tokio-util",
+ "tracing",
+ "uuid",
+]
+
+[[package]]
+name = "tiff"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b63feaf3343d35b6ca4d50483f94843803b0f51634937cc2ec519fc32232bc52"
+dependencies = [
+ "fax",
+ "flate2",
+ "half",
+ "quick-error",
+ "weezl",
+ "zune-jpeg",
+]
+
+[[package]]
+name = "time"
+version = "0.3.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
+dependencies = [
+ "deranged",
+ "itoa",
+ "libc",
+ "num-conv",
+ "num_threads",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
+
+[[package]]
+name = "time-macros"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tls_codec"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de2e01245e2bb89d6f05801c564fa27624dbd7b1846859876c7dad82e90bf6b"
+dependencies = [
+ "tls_codec_derive",
+ "zeroize",
+]
+
+[[package]]
+name = "tls_codec_derive"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d2e76690929402faae40aebdda620a2c0e25dd6d3b9afe48867dfd95991f4bd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tokio"
+version = "1.52.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2 0.6.3",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-postgres"
+version = "0.7.17"
+source = "git+https://github.com/t8y2/tokio-postgres-gaussdb.git?branch=master#8d50befeee7cdeb8ecdb97c7b790c91010971063"
+dependencies = [
+ "async-trait",
+ "byteorder",
+ "bytes",
+ "fallible-iterator 0.2.0",
+ "futures-channel",
+ "futures-util",
+ "log",
+ "parking_lot",
+ "percent-encoding",
+ "phf",
+ "pin-project-lite",
+ "postgres-protocol",
+ "postgres-types",
+ "rand 0.10.1",
+ "socket2 0.6.3",
+ "tokio",
+ "tokio-util",
+ "whoami",
+]
+
+[[package]]
+name = "tokio-postgres-rustls"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27d684bad428a0f2481f42241f821db42c54e2dc81d8c00db8536c506b0a0144"
+dependencies = [
+ "const-oid 0.9.6",
+ "ring",
+ "rustls 0.23.40",
+ "tokio",
+ "tokio-postgres",
+ "tokio-rustls 0.26.4",
+ "x509-cert",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
+dependencies = [
+ "rustls 0.21.12",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
+dependencies = [
+ "rustls 0.23.40",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-tungstenite"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f72a05e828585856dacd553fba484c242c46e391fb0e58917c942ee9202915c"
+dependencies = [
+ "futures-util",
+ "log",
+ "tokio",
+ "tungstenite",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-io",
+ "futures-sink",
+ "futures-util",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "185d8ab0dfbb35cf1399a6344d8484209c088f75f8f68230da55d48d95d43e3d"
+dependencies = [
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
+]
+
+[[package]]
+name = "toml"
+version = "0.9.12+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
+dependencies = [
+ "indexmap 2.14.0",
+ "serde_core",
+ "serde_spanned 1.1.1",
+ "toml_datetime 0.7.5+spec-1.1.0",
+ "toml_parser",
+ "toml_writer",
+ "winnow 0.7.15",
+]
+
+[[package]]
+name = "toml"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81f3d15e84cbcd896376e6730314d59fb5a87f31e4b038454184435cd57defee"
+dependencies = [
+ "indexmap 2.14.0",
+ "serde_core",
+ "serde_spanned 1.1.1",
+ "toml_datetime 1.1.1+spec-1.1.0",
+ "toml_parser",
+ "toml_writer",
+ "winnow 1.0.3",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.19.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
+dependencies = [
+ "indexmap 2.14.0",
+ "toml_datetime 0.6.3",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "396e4d48bbb2b7554c944bde63101b5ae446cff6ec4a24227428f15eb72ef338"
+dependencies = [
+ "indexmap 2.14.0",
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.3",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.25.11+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
+dependencies = [
+ "indexmap 2.14.0",
+ "toml_datetime 1.1.1+spec-1.1.0",
+ "toml_parser",
+ "winnow 1.0.3",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
+dependencies = [
+ "winnow 1.0.3",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db"
+
+[[package]]
+name = "tower"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.6.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840"
+dependencies = [
+ "async-compression",
+ "bitflags 2.11.1",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "http-range-header",
+ "httpdate",
+ "mime",
+ "mime_guess",
+ "percent-encoding",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+ "tower",
+ "tower-layer",
+ "tower-service",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "log",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+ "valuable",
+]
+
+[[package]]
+name = "tracing-log"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+dependencies = [
+ "log",
+ "once_cell",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-subscriber"
+version = "0.3.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
+dependencies = [
+ "matchers",
+ "nu-ansi-term",
+ "once_cell",
+ "regex-automata",
+ "sharded-slab",
+ "smallvec",
+ "thread_local",
+ "tracing",
+ "tracing-core",
+ "tracing-log",
+]
+
+[[package]]
+name = "tray-icon"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15edbb0d80583e85ee8df283410038e17314df5cba30da2087a54a85216c0773"
+dependencies = [
+ "crossbeam-channel",
+ "dirs",
+ "libappindicator",
+ "muda",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "once_cell",
+ "png 0.18.1",
+ "serde",
+ "thiserror 2.0.18",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tree_magic_mini"
+version = "3.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8765b90061cba6c22b5831f675da109ae5561588290f9fa2317adab2714d5a6"
+dependencies = [
+ "memchr",
+ "nom",
+ "petgraph",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "tungstenite"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c01152af293afb9c7c2a57e4b559c5620b421f6d133261c60dd2d0cdb38e6b8"
+dependencies = [
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "rand 0.9.4",
+ "sha1 0.10.6",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "twox-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+
+[[package]]
+name = "typed-builder"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "398a3a3c918c96de527dc11e6e846cd549d4508030b8a33e1da12789c856b81a"
+dependencies = [
+ "typed-builder-macro",
+]
+
+[[package]]
+name = "typed-builder-macro"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e48cea23f68d1f78eb7bc092881b6bb88d3d6b5b7e6234f6f9c911da1ffb221"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+
+[[package]]
+name = "typenum"
+version = "1.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
+
+[[package]]
+name = "uds_windows"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
+dependencies = [
+ "memoffset",
+ "tempfile",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "unic-char-property"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8c57a407d9b6fa02b4795eb81c5b6652060a15a7903ea981f3d723e6c0be221"
+dependencies = [
+ "unic-char-range",
+]
+
+[[package]]
+name = "unic-char-range"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0398022d5f700414f6b899e10b8348231abf9173fa93144cbc1a43b9793c1fbc"
+
+[[package]]
+name = "unic-common"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80d7ff825a6a654ee85a63e80f92f054f904f21e7d12da4e22f9834a4aaa35bc"
+
+[[package]]
+name = "unic-ucd-ident"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e230a37c0381caa9219d67cf063aa3a375ffed5bf541a452db16e744bdab6987"
+dependencies = [
+ "unic-char-property",
+ "unic-char-range",
+ "unic-ucd-version",
+]
+
+[[package]]
+name = "unic-ucd-version"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96bd2f2237fe450fcd0a1d2f5f4e91711124f7857ba2e964247776ebeeb7b0c4"
+dependencies = [
+ "unic-common",
+]
+
+[[package]]
+name = "unicase"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-properties"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common 0.1.7",
+ "subtle",
+]
+
+[[package]]
+name = "universal-hash"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4987bdc12753382e0bec4a65c50738ffaabc998b9cdd1f952fb5f39b0048a96"
+dependencies = [
+ "crypto-common 0.2.2",
+ "ctutils",
+]
+
+[[package]]
+name = "untrusted"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "urlpattern"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70acd30e3aa1450bc2eece896ce2ad0d178e9c079493819301573dae3c37ba6d"
+dependencies = [
+ "regex",
+ "serde",
+ "unic-ucd-ident",
+ "url",
+]
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8-width"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1292c0d970b54115d14f2492fe0170adf21d68a1de108eebc51c1df4f346a091"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "uuid"
+version = "1.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd74a9687298c6858e9b88ec8935ec45d22e8fd5e6394fa1bd4e99a87789c76"
+dependencies = [
+ "getrandom 0.4.2",
+ "js-sys",
+ "serde_core",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "valuable"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
+
+[[package]]
+name = "value-bag"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ba6f5989077681266825251a52748b8c1d8a4ad098cc37e440103d0ea717fc0"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version-compare"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "vswhom"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be979b7f07507105799e854203b470ff7c78a1639e330a58f183b5fea574608b"
+dependencies = [
+ "libc",
+ "vswhom-sys",
+]
+
+[[package]]
+name = "vswhom-sys"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb067e4cbd1ff067d1df46c9194b5de0e98efd2810bbc95c5d5e5f25a3231150"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasi"
+version = "0.14.7+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "883478de20367e224c0090af9cf5f9fa85bed63a95c1abf3afc5c083ebc06e8c"
+dependencies = [
+ "wasip2",
+]
+
+[[package]]
+name = "wasip2"
+version = "1.0.3+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6"
+dependencies = [
+ "wit-bindgen 0.57.1",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen 0.51.0",
+]
+
+[[package]]
+name = "wasite"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66fe902b4a6b8028a753d5424909b764ccf79b7a209eac9bf97e59cda9f71a42"
+dependencies = [
+ "wasi 0.14.7+wasi-0.2.4",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.122"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ed04576f974d2b2fba0f38c51dbc5518011e38c36bf1143164be765528fd409"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "serde",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.72"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9473dbd2991ae90b6291c3c32c30c6187ac49aa32f9905d1cce280ec1e110b0f"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.122"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "916151b09da36bd82f6615cbf3a419e2f0ba23a03c6160e8e92eb6bd4aa1dec6"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.122"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "299047362ccbfce148b67ab7e73349f77748e00c8296f9542adfad2ad82c5c5e"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.122"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a929b2c61f11ba3e9bc35b50c1f25cb38e0e892c0c231ae2b8cf78d5dad4437"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap 2.14.0",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-streams"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-streams"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.11.1",
+ "hashbrown 0.15.5",
+ "indexmap 2.14.0",
+ "semver",
+]
+
+[[package]]
+name = "wayland-backend"
+version = "0.3.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2857dd20b54e916ec7253b3d6b4d5c4d7d4ca2c33c2e11c6c76a99bd8744755d"
+dependencies = [
+ "cc",
+ "downcast-rs",
+ "rustix 1.1.4",
+ "smallvec",
+ "wayland-sys",
+]
+
+[[package]]
+name = "wayland-client"
+version = "0.31.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645c7c96bb74690c3189b5c9cb4ca1627062bb23693a4fad9d8c3de958260144"
+dependencies = [
+ "bitflags 2.11.1",
+ "rustix 1.1.4",
+ "wayland-backend",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols"
+version = "0.32.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "563a85523cade2429938e790815fd7319062103b9f4a2dc806e9b53b95982d8f"
+dependencies = [
+ "bitflags 2.11.1",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-protocols-wlr"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb04e52f7836d7c7976c78ca0250d61e33873c34156a2a1fc9474828ec268234"
+dependencies = [
+ "bitflags 2.11.1",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-scanner",
+]
+
+[[package]]
+name = "wayland-scanner"
+version = "0.31.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c324a910fd86ebdc364a3e61ec1f11737d3b1d6c273c0239ee8ff4bc0d24b4a"
+dependencies = [
+ "proc-macro2",
+ "quick-xml 0.39.4",
+ "quote",
+]
+
+[[package]]
+name = "wayland-sys"
+version = "0.31.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8eab23fefc9e41f8e841df4a9c707e8a8c4ed26e944ef69297184de2785e3be"
+dependencies = [
+ "pkg-config",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d621441cfc37b84979402712047321980c178f299193a3589d05b99e8763436"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web_atoms"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7cff6eef815df1834fd250e3a2ff436044d82a9f1bc1980ca1dbdf07effc538"
+dependencies = [
+ "phf",
+ "phf_codegen",
+ "string_cache",
+ "string_cache_codegen",
+]
+
+[[package]]
+name = "webkit2gtk"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1027150013530fb2eaf806408df88461ae4815a45c541c8975e61d6f2fc4793"
+dependencies = [
+ "bitflags 1.3.2",
+ "cairo-rs",
+ "gdk",
+ "gdk-sys",
+ "gio",
+ "gio-sys",
+ "glib",
+ "glib-sys",
+ "gobject-sys",
+ "gtk",
+ "gtk-sys",
+ "javascriptcore-rs",
+ "libc",
+ "once_cell",
+ "soup3",
+ "webkit2gtk-sys",
+]
+
+[[package]]
+name = "webkit2gtk-sys"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "916a5f65c2ef0dfe12fff695960a2ec3d4565359fdbb2e9943c974e06c734ea5"
+dependencies = [
+ "bitflags 1.3.2",
+ "cairo-sys-rs",
+ "gdk-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "gtk-sys",
+ "javascriptcore-rs-sys",
+ "libc",
+ "pkg-config",
+ "soup3-sys",
+ "system-deps",
+]
+
+[[package]]
+name = "webpki-root-certs"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31141ce3fc3e300ae89b78c0dd67f9708061d1d2eda54b8209346fd6be9a92c"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.7",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52f5ee44c96cf55f1b349600768e3ece3a8f26010c05265ab73f945bb1a2eb9d"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "webview2-com"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7130243a7a5b33c54a444e54842e6a9e133de08b5ad7b5861cd8ed9a6a5bc96a"
+dependencies = [
+ "webview2-com-macros",
+ "webview2-com-sys",
+ "windows 0.61.3",
+ "windows-core 0.61.2",
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
+]
+
+[[package]]
+name = "webview2-com-macros"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67a921c1b6914c367b2b823cd4cde6f96beec77d30a939c8199bb377cf9b9b54"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "webview2-com-sys"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "381336cfffd772377d291702245447a5251a2ffa5bad679c99e61bc48bacbf9c"
+dependencies = [
+ "thiserror 2.0.18",
+ "windows 0.61.3",
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "weezl"
+version = "0.1.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
+
+[[package]]
+name = "whoami"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "998767ef88740d1f5b0682a9c53c24431453923962269c2db68ee43788c5a40d"
+dependencies = [
+ "libc",
+ "libredox",
+ "objc2-system-configuration",
+ "wasite",
+ "web-sys",
+]
+
+[[package]]
+name = "widestring"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "window-vibrancy"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9bec5a31f3f9362f2258fd0e9c9dd61a9ca432e7306cc78c444258f0dce9a9c"
+dependencies = [
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "raw-window-handle",
+ "windows-sys 0.59.0",
+ "windows-version",
+]
+
+[[package]]
+name = "windows"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12342cb4d8e3b046f3d80effd474a7a02447231330ef77d71daa6fbc40681143"
+dependencies = [
+ "windows-core 0.57.0",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows"
+version = "0.61.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+dependencies = [
+ "windows-collections 0.2.0",
+ "windows-core 0.61.2",
+ "windows-future 0.2.1",
+ "windows-link 0.1.3",
+ "windows-numerics 0.2.0",
+]
+
+[[package]]
+name = "windows"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"
+dependencies = [
+ "windows-collections 0.3.2",
+ "windows-core 0.62.2",
+ "windows-future 0.3.2",
+ "windows-numerics 0.3.1",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"
+dependencies = [
+ "windows-core 0.62.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2ed2439a290666cd67ecce2b0ffaad89c2a56b976b736e6ece670297897832d"
+dependencies = [
+ "windows-implement 0.57.0",
+ "windows-interface 0.57.0",
+ "windows-result 0.1.2",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
+ "windows-link 0.1.3",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+ "windows-threading 0.1.0",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
+dependencies = [
+ "windows-core 0.62.2",
+ "windows-link 0.2.1",
+ "windows-threading 0.2.1",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9107ddc059d5b6fbfbffdfa7a7fe3e22a226def0b2608f72e9d552763d3e1ad7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29bee4b38ea3cde66011baa44dba677c432a78593e202392d1e9070cf2a7fca7"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-numerics"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
+dependencies = [
+ "windows-core 0.62.2",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-registry"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b8a9ed28765efc97bbc954883f4e6796c33a06546ebafacbabee9696967499e"
+dependencies = [
+ "windows-link 0.1.3",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
+]
+
+[[package]]
+name = "windows-registry"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
+dependencies = [
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e383302e8ec8515204254685643de10811af0ed97ea37210dc26fb0032647f8"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link 0.2.1",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-threading"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-version"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4060a1da109b9d0326b7262c8e12c84df67cc0dbc9e33cf49e01ccc2eb63631"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winnow"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
+
+[[package]]
+name = "winnow"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winreg"
+version = "0.55.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb5a765337c50e9ec252c2069be9bf91c7df47afb103b642ba3a53bf8101be97"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "wio"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d129932f4644ac2396cb456385cbf9e63b5b30c6e8dc4820bdca4eb082037a5"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap 2.14.0",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.1",
+ "indexmap 2.14.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.14.0",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "wl-clipboard-rs"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9651471a32e87d96ef3a127715382b2d11cc7c8bb9822ded8a7cc94072eb0a3"
+dependencies = [
+ "libc",
+ "log",
+ "os_pipe",
+ "rustix 1.1.4",
+ "thiserror 2.0.18",
+ "tree_magic_mini",
+ "wayland-backend",
+ "wayland-client",
+ "wayland-protocols",
+ "wayland-protocols-wlr",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
+
+[[package]]
+name = "wry"
+version = "0.55.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "186f9871daa55fd9c016578b810d149de58367113db7fb72b462d2323ce19514"
+dependencies = [
+ "base64 0.22.1",
+ "block2",
+ "cookie",
+ "crossbeam-channel",
+ "dirs",
+ "dom_query",
+ "dpi",
+ "dunce",
+ "gdkx11",
+ "gtk",
+ "http",
+ "javascriptcore-rs",
+ "jni 0.21.1",
+ "libc",
+ "ndk",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "once_cell",
+ "percent-encoding",
+ "raw-window-handle",
+ "sha2 0.10.9",
+ "soup3",
+ "tao-macros",
+ "thiserror 2.0.18",
+ "url",
+ "webkit2gtk",
+ "webkit2gtk-sys",
+ "webview2-com",
+ "windows 0.61.3",
+ "windows-core 0.61.2",
+ "windows-version",
+ "x11-dl",
+]
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "x11"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "502da5464ccd04011667b11c435cb992822c2c0dbde1770c988480d312a0db2e"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "x11-dl"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f"
+dependencies = [
+ "libc",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "x11rb"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414"
+dependencies = [
+ "gethostname",
+ "rustix 1.1.4",
+ "x11rb-protocol",
+]
+
+[[package]]
+name = "x11rb-protocol"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
+
+[[package]]
+name = "x509-cert"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1301e935010a701ae5f8655edc0ad17c44bad3ac5ce8c39185f75453b720ae94"
+dependencies = [
+ "const-oid 0.9.6",
+ "der 0.7.10",
+ "spki 0.7.3",
+ "tls_codec",
+]
+
+[[package]]
+name = "xattr"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
+dependencies = [
+ "libc",
+ "rustix 1.1.4",
+]
+
+[[package]]
+name = "yeslogic-fontconfig-sys"
+version = "6.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d8b8abf912b9a29ff112e1671c97c33636903d13a69712037190e6805af4f76"
+dependencies = [
+ "dlib",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "yoke"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zbus"
+version = "5.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3bcbf15c8708d7fc1be0c993622e0a5cbd5e8b52bfa40afa4c3e0cd8d724ac1"
+dependencies = [
+ "async-broadcast",
+ "async-executor",
+ "async-io",
+ "async-lock",
+ "async-process",
+ "async-recursion",
+ "async-task",
+ "async-trait",
+ "blocking",
+ "enumflags2",
+ "event-listener",
+ "futures-core",
+ "futures-lite",
+ "hex",
+ "libc",
+ "ordered-stream",
+ "rustix 1.1.4",
+ "serde",
+ "serde_repr",
+ "tracing",
+ "uds_windows",
+ "uuid",
+ "windows-sys 0.61.2",
+ "winnow 1.0.3",
+ "zbus_macros",
+ "zbus_names",
+ "zvariant",
+]
+
+[[package]]
+name = "zbus_macros"
+version = "5.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51fa5406ad9175a8c825a931f8cf347116b531b3634fcb0b627c290f1f2516ff"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "zbus_names",
+ "zvariant",
+ "zvariant_utils",
+]
+
+[[package]]
+name = "zbus_names"
+version = "4.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7074f3e50b894eac91750142016d30d0a89be8e67dbfd9704fb875825760e52d"
+dependencies = [
+ "serde",
+ "winnow 1.0.3",
+ "zvariant",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zip"
+version = "4.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caa8cd6af31c3b31c6631b8f483848b91589021b28fffe50adada48d4f4d2ed1"
+dependencies = [
+ "aes 0.8.4",
+ "arbitrary",
+ "bzip2",
+ "constant_time_eq",
+ "crc32fast",
+ "deflate64",
+ "flate2",
+ "getrandom 0.3.4",
+ "hmac 0.12.1",
+ "indexmap 2.14.0",
+ "liblzma",
+ "memchr",
+ "pbkdf2 0.12.2",
+ "ppmd-rust",
+ "sha1 0.10.6",
+ "time",
+ "zeroize",
+ "zopfli",
+ "zstd",
+]
+
+[[package]]
+name = "zip"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb2a05c7c36fde6c09b08576c9f7fb4cda705990f73b58fe011abf7dfb24168b"
+dependencies = [
+ "arbitrary",
+ "crc32fast",
+ "flate2",
+ "indexmap 2.14.0",
+ "memchr",
+ "zopfli",
+]
+
+[[package]]
+name = "zlib-rs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3be3d40e40a133f9c916ee3f9f4fa2d9d63435b5fbe1bfc6d9dae0aa0ada1513"
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[package]]
+name = "zopfli"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249"
+dependencies = [
+ "bumpalo",
+ "crc32fast",
+ "log",
+ "simd-adler32",
+]
+
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.16+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
+
+[[package]]
+name = "zune-core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb8a0807f7c01457d0379ba880ba6322660448ddebc890ce29bb64da71fb40f9"
+
+[[package]]
+name = "zune-jpeg"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27bc9d5b815bc103f142aa054f561d9187d191692ec7c2d1e2b4737f8dbd7296"
+dependencies = [
+ "zune-core",
+]
+
+[[package]]
+name = "zvariant"
+version = "5.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c1567a6ec68df868cbbfde844cfc6d81649fe5109a62b116b19fabd53e618ee"
+dependencies = [
+ "endi",
+ "enumflags2",
+ "serde",
+ "winnow 1.0.3",
+ "zvariant_derive",
+ "zvariant_utils",
+]
+
+[[package]]
+name = "zvariant_derive"
+version = "5.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7d5b780599bbde114e39d9a0799577fad1ced5105d38515745f7b3099d8ceda"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "zvariant_utils",
+]
+
+[[package]]
+name = "zvariant_utils"
+version = "3.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d464f5733ffa07a3164d656f18533caace9d0638596721355d73256a410d691"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde",
+ "syn 2.0.117",
+ "winnow 1.0.3",
+]
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..8b323eb
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,19 @@
+[workspace]
+resolver = "2"
+members = ["src-tauri", "crates/dbx-core", "crates/dbx-web"]
+
+[patch.crates-io]
+tokio-postgres = { git = "https://github.com/t8y2/tokio-postgres-gaussdb.git", branch = "master" }
+postgres-types = { git = "https://github.com/t8y2/tokio-postgres-gaussdb.git", branch = "master" }
+postgres-protocol = { git = "https://github.com/t8y2/tokio-postgres-gaussdb.git", branch = "master" }
+# Temporary compatibility patch for MySQL accounts using the deprecated
+# sha256_password auth plugin. Remove after upstream support lands.
+mysql_async = { git = "https://github.com/t8y2/mysql_async.git", rev = "7b565fbe76a168828189f7b98fe3b1989344c54e" }
+mysql_common = { git = "https://github.com/t8y2/rust_mysql_common.git", rev = "5b30d4912ebb23728f1196b2b9eb928eebb73f92" }
+
+[profile.release]
+panic = "abort"
+strip = true
+lto = true
+codegen-units = 1
+opt-level = "s"
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..620a5e3
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,90 @@
+.DEFAULT_GOAL := dev
+
+PNPM ?= pnpm
+TAURI_DEV_PORT ?= 1420
+
+.PHONY: help install docs-install check-tauri-dev-port dev dev-fast dev-web dev-backend build package docs docs-build check test cargo-check-fast cargo-test-fast
+
+node_modules/.modules.yaml: package.json pnpm-lock.yaml
+	$(PNPM) install --frozen-lockfile
+
+docs/node_modules/.modules.yaml: docs/package.json docs/pnpm-lock.yaml
+	cd docs && $(PNPM) install --frozen-lockfile --ignore-workspace
+
+help:
+	@printf '%s\n' 'DBX development targets:'
+	@printf '%s\n' ''
+	@printf '%s\n' 'App:'
+	@printf '  %-23s %s\n' 'make' 'Start the local desktop development environment'
+	@printf '  %-23s %s\n' 'make dev' 'Start the local desktop development environment'
+	@printf '  %-23s %s\n' 'make dev-fast' 'Start Tauri dev without default Rust features'
+	@printf '  %-23s %s\n' 'make dev-web' 'Start the web frontend development server'
+	@printf '  %-23s %s\n' 'make dev-backend' 'Start the web backend development server'
+	@printf '  %-23s %s\n' 'make build' 'Run type checks and build the desktop frontend'
+	@printf '  %-23s %s\n' 'make package' 'Build the desktop app package'
+	@printf '%s\n' ''
+	@printf '%s\n' 'Docs:'
+	@printf '  %-23s %s\n' 'make docs' 'Start the documentation site development server'
+	@printf '  %-23s %s\n' 'make docs-build' 'Build the documentation site'
+	@printf '  %-23s %s\n' 'make docs-install' 'Install documentation site dependencies'
+	@printf '%s\n' ''
+	@printf '%s\n' 'Checks:'
+	@printf '  %-23s %s\n' 'make check' 'Run project checks'
+	@printf '  %-23s %s\n' 'make test' 'Run project tests'
+	@printf '  %-23s %s\n' 'make cargo-check-fast' 'Run Rust check without default features'
+	@printf '  %-23s %s\n' 'make cargo-test-fast' 'Run Rust tests without default features'
+	@printf '%s\n' ''
+	@printf '%s\n' 'Setup:'
+	@printf '  %-23s %s\n' 'make install' 'Install root project dependencies'
+
+install:
+	$(PNPM) install --frozen-lockfile
+
+docs-install:
+	cd docs && $(PNPM) install --frozen-lockfile --ignore-workspace
+
+check-tauri-dev-port:
+	@if lsof -nP -iTCP:$(TAURI_DEV_PORT) -sTCP:LISTEN >/dev/null 2>&1; then \
+		echo "Port $(TAURI_DEV_PORT) is already in use. DBX Tauri dev requires http://localhost:$(TAURI_DEV_PORT)."; \
+		echo ""; \
+		lsof -nP -iTCP:$(TAURI_DEV_PORT) -sTCP:LISTEN; \
+		echo ""; \
+		echo "Stop the process above, then run make dev again. Example: kill <PID>"; \
+		exit 1; \
+	fi
+
+dev: node_modules/.modules.yaml check-tauri-dev-port
+	$(PNPM) dev:tauri
+
+dev-fast: node_modules/.modules.yaml check-tauri-dev-port
+	$(PNPM) tauri dev -- --no-default-features
+
+dev-web: node_modules/.modules.yaml
+	$(PNPM) dev:web
+
+dev-backend: node_modules/.modules.yaml
+	$(PNPM) dev:backend
+
+build: node_modules/.modules.yaml
+	$(PNPM) build:checked
+
+package: node_modules/.modules.yaml
+	$(PNPM) tauri build
+
+docs: docs/node_modules/.modules.yaml
+	cd docs && ./node_modules/.bin/next dev --hostname 127.0.0.1
+
+docs-build: docs/node_modules/.modules.yaml
+	cd docs && ./node_modules/.bin/next build && node scripts/generate-sitemap.mjs
+
+check: node_modules/.modules.yaml
+	$(PNPM) check
+
+test: node_modules/.modules.yaml
+	$(PNPM) test
+
+cargo-check-fast:
+	cargo check --no-default-features
+
+cargo-test-fast:
+	cargo test --no-default-features
diff --git a/README-NIX.md b/README-NIX.md
new file mode 100644
index 0000000..99d1ed5
--- /dev/null
+++ b/README-NIX.md
@@ -0,0 +1,172 @@
+##  Add to NixOS system configuration
+
+Add DBX as a flake input and include the package in `environment.systemPackages`.
+
+### `flake.nix`
+
+```nix
+{
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+    dbx = {
+      url = "github:t8y2/dbx";
+      inputs.nixpkgs.follows = "nixpkgs"; # optional
+    };
+  };
+
+  outputs = { self, nixpkgs, dbx, ... }: {
+    nixosConfigurations.my-machine = nixpkgs.lib.nixosSystem {
+      system = "x86_64-linux";
+      modules = [
+        ./configuration.nix
+        {
+          environment.systemPackages = [
+            dbx.packages.x86_64-linux.dbx-desktop
+          ];
+        }
+      ];
+    };
+  };
+}
+```
+
+### Apply
+
+```bash
+sudo nixos-rebuild switch --flake .#my-machine
+```
+
+---
+
+## Add via Home Manager
+
+This method installs DBX for a specific user through [Home Manager](https://github.com/nix-community/home-manager).
+
+> [!NOTE]
+> The `inputs.nixpkgs.follows = "nixpkgs"` line is **optional**.
+> It prevents Nix from downloading a second copy of nixpkgs, but it also makes
+> DBX ineligible for the upstream binary cache (it will be built locally).
+> Remove that line if you prefer to download a pre-built binary.
+
+### `flake.nix` (standalone Home Manager)
+
+```nix
+{
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+    home-manager = {
+      url = "github:nix-community/home-manager";
+      inputs.nixpkgs.follows = "nixpkgs"; 
+    };
+
+    dbx = {
+      url = "github:t8y2/dbx";
+      inputs.nixpkgs.follows = "nixpkgs"; # optional
+    };
+  };
+
+  outputs = { self, nixpkgs, home-manager, dbx, ... }: {
+    homeConfigurations."youruser" = home-manager.lib.homeManagerConfiguration {
+      pkgs = nixpkgs.legacyPackages.x86_64-linux;
+      system = "x86_64-linux";
+      modules = [
+        {
+          home.packages = [
+            dbx.packages.x86_64-linux.dbx-desktop
+          ];
+        }
+      ];
+    };
+  };
+}
+```
+
+### `flake.nix` (NixOS + Home Manager as a NixOS module)
+
+```nix
+{
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+    home-manager = {
+      url = "github:nix-community/home-manager";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+
+    dbx = {
+      url = "github:t8y2/dbx";
+      inputs.nixpkgs.follows = "nixpkgs"; # optional
+    };
+  };
+
+  outputs = { self, nixpkgs, home-manager, dbx, ... }: {
+    nixosConfigurations.my-machine = nixpkgs.lib.nixosSystem {
+      system = "x86_64-linux";
+      modules = [
+        ./configuration.nix
+        home-manager.nixosModules.home-manager
+        {
+          home-manager.users.youruser = {
+            home.packages = [
+              dbx.packages.x86_64-linux.dbx-desktop
+            ];
+          };
+        }
+      ];
+    };
+  };
+}
+```
+
+> Replace `youruser` with your actual Linux username and `my-machine` with your hostname.
+
+### Apply (standalone)
+
+```bash
+home-manager switch --flake .#youruser
+```
+
+### Apply (NixOS module)
+
+```bash
+sudo nixos-rebuild switch --flake .#my-machine
+```
+
+---
+
+## Development Shell
+
+If you are contributing to DBX or building it from a local clone, the flake provides a fully configured development shell with Rust, Node.js, pnpm, and all GTK/WebKit system libraries:
+
+```bash
+git clone https://github.com/t8y2/dbx
+cd dbx
+nix develop
+```
+
+Inside the shell:
+
+| Task | Command |
+|---|---|
+| Desktop app (Tauri) | `pnpm install && pnpm dev:tauri` |
+| Web frontend only | `pnpm dev:web` |
+| Web backend only | `pnpm dev:backend` |
+| Release build | `pnpm tauri build` |
+
+---
+
+## Building from Source
+
+Build the `dbx-desktop` package directly from the flake:
+
+```bash
+nix build github:t8y2/dbx#dbx-desktop
+# or, from a local clone:
+nix build .#dbx-desktop
+```
+
+The resulting binary is available at `./result/bin/dbx`.
+
+---
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..36c99fc
--- /dev/null
+++ b/README.md
@@ -0,0 +1,433 @@
+<div align="center">
+  <p style="font-size: 18px; white-space: nowrap;"><strong>60+ databases in 20 MB. Desktop & Docker self-hosting, with built-in AI assistant.</strong></p>
+
+  <p>
+    <img src="https://dl.dbxio.com/assets/readme-hero-20260707.png" alt="DBX screenshot" width="820" />
+  </p>
+
+  <p>
+    <a href="https://github.com/t8y2/dbx/releases"><img src="https://img.shields.io/github/downloads/t8y2/dbx/total?style=for-the-badge&color=blue" /></a>
+    <a href="https://github.com/t8y2/dbx/graphs/contributors"><img src="https://img.shields.io/github/contributors/t8y2/dbx?style=for-the-badge" /></a>
+    <a href="https://qm.qq.com/cgi-bin/qm/qr?k=&group_code=1087880322"><img src="https://img.shields.io/badge/QQ_群-1087880322-EB1923?style=for-the-badge&logo=data:image/svg%2bxml;base64,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" alt="Join QQ Group" /></a>
+    <a href="https://docs.qq.com/doc/DVVhMY0h1ekJqc0tz" target="_blank"><img src="https://img.shields.io/badge/微信群-Join-07C160?style=for-the-badge&logo=wechat&logoColor=white" alt="Join WeChat Group" /></a>
+    <a href="https://discord.gg/W7NyVDRt6a"><img src="https://dcbadge.limes.pink/api/server/W7NyVDRt6a" alt="Join Discord" /></a>
+	  </p>
+  <p>
+		<a href="https://trendshift.io/repositories/26775?utm_source=trendshift-badge&amp;utm_medium=badge&amp;utm_campaign=badge-trendshift-26775" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/trendshift/repositories/26775/daily?language=Rust" alt="t8y2%2Fdbx | Trendshift" width="250" height="55"/></a>
+    <a href="https://hellogithub.com/repository/t8y2/dbx" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=7f74ffda697241bf996e17e1b0900a21&claim_uid=p0UjnC1TLtyvWSx" alt="Featured｜HelloGitHub" style="width: 250px; height: 54px;" width="250" height="54" /></a>
+	<a href="https://www.producthunt.com/products/dbx/launches/dbx?embed=true&amp;utm_source=badge-featured&amp;utm_medium=badge&amp;utm_campaign=badge-dbx" target="_blank" rel="noopener noreferrer"><img alt="DBX - Lightweight open-source database manager built with Rust | Product Hunt" width="250" height="54" src="https://api.producthunt.com/widgets/embed-image/v1/featured.svg?post_id=1136811&amp;theme=light&amp;t=1780979717555"></a>
+	  </p>
+	  <p>
+    <img src="https://img.shields.io/badge/MySQL-4479A1?logo=mysql&logoColor=white" />
+    <img src="https://img.shields.io/badge/PostgreSQL-4169E1?logo=postgresql&logoColor=white" />
+    <img src="https://img.shields.io/badge/SQLite-003B57?logo=sqlite&logoColor=white" />
+    <img src="https://img.shields.io/badge/Redis-DC382D?logo=redis&logoColor=white" />
+    <img src="https://img.shields.io/badge/MongoDB-47A248?logo=mongodb&logoColor=white" />
+    <img src="https://img.shields.io/badge/DuckDB-FFF000?logo=duckdb&logoColor=black" />
+    <img src="https://img.shields.io/badge/ClickHouse-FFCC01?logo=clickhouse&logoColor=black" />
+    <img src="https://img.shields.io/badge/SQL%20Server-CC2927?logo=microsoftsqlserver&logoColor=white" />
+    <img src="https://img.shields.io/badge/Oracle-F80000?logo=oracle&logoColor=white" />
+    <img src="https://img.shields.io/badge/Elasticsearch-005571?logo=elasticsearch&logoColor=white" />
+    <img src="https://img.shields.io/badge/MariaDB-003545?logo=mariadb&logoColor=white" />
+    <img src="https://img.shields.io/badge/TiDB-DC150B?logo=tidb&logoColor=white" />
+    <img src="https://img.shields.io/badge/Doris-0052CC?logoColor=white" />
+    <img src="https://img.shields.io/badge/SelectDB-22C1C3?logoColor=white" />
+    <img src="https://img.shields.io/badge/StarRocks-5C2D91?logoColor=white" />
+    <img src="https://img.shields.io/badge/Redshift-8C4FFF?logo=amazonredshift&logoColor=white" />
+    <img src="https://img.shields.io/badge/DM-3857FF?logoColor=white" />
+    <img src="https://img.shields.io/badge/OceanBase-006AFF?logoColor=white" />
+    <img src="https://img.shields.io/badge/openGauss-2B7BD9?logoColor=white" />
+    <img src="https://img.shields.io/badge/GaussDB-E60012?logoColor=white" />
+    <img src="https://img.shields.io/badge/KWDB-1c60e0?logoColor=white" />
+    <img src="https://img.shields.io/badge/KingBase-003B8E?logoColor=white" />
+    <img src="https://img.shields.io/badge/TDengine-2F6FFF?logoColor=white" />
+    <img src="https://img.shields.io/badge/CockroachDB-6933FF?logoColor=white" />
+    <img src="https://img.shields.io/badge/InfluxDB-d30971?logo=influxdb&logoColor=white" />
+    <img src="https://img.shields.io/badge/JDBC-4B5563?logoColor=white" />
+    <img src="https://img.shields.io/badge/and%20more...-555555?logoColor=white" />
+    <a href="https://atomgit.com/t8y2/dbx"><img src="https://atomgit.com/t8y2/dbx/star/badge.svg" alt="AtomGit Stars" /></a>
+    <a href="https://cnb.cool/dbxio.com/dbx"><img src="https://img.shields.io/badge/CNB-dbx-F76945?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAppJREFUOE9tk01rE1EUhs+5H5lJ0iQT3FRX2Yi4avoLkv4CWxBcNt11oZiuFKGmXQhFN6kuRESSgitXKf6A5g+I6cqFLiKCiptOkraZ5H4cuZOkH9oLw+UO8z7nvGfei3DFohoEQLAKCGWyGJCSbQZsD3ei7r+f45WATV6xmjdISyAlYLaDliveux+ti5ozwLAaFPhIlk6G6f18sxuO7l9bBiWbVoncDGCMWMl++PI/gJ7IohkmD0zkBxT5oRn5LTpN7ULqBByEtFywWvRyHz8Fx3dvN0UwuMPyR0uJFycddH7tKPHZRn7BjnwwkQcUud0HO/K7oOENcTYPRCEAFERmsCpyfZDZfpdnBosOUKGx13BC60QTIdjpmSzrEWDR+UagjsgMciLXAwfhc4MNpKfQtOPE6mVh0gEOaeTXtWXXEdADpJAR/GaZ/rrM9Us82wORPd5zHbRp7JVcyxR5PRP5LTPy6uo0HXIlG9awMgLuEUABkBYI7VLyxs+yyPW3+Nyg4zqoG+UV7TDRlMBbWA/D43u3qlbLGmgRWM2BjFxjQjWQGQBuu4bYYvrm14JMnQSXcjBcny9A5DXIiDJp9/8FWCXAAOaFUEfILTgIcttOvf+2NJnLdI0fBFUyskZKBGTEJEAmBuzr9LCSUDwGQAwwgMzu+m9/VWOAeZSsk+YP48C4li/sRok1nlBd5PogBjgxNw70PfHyqBADyEVXicasZXCVpxYiLfO+HxVZDHCVYwvu2ebPT7fOLNAm65AWLnEAzvsEcOi9/lPU1aACXDfOLdhD9kxNszGdweQGYstqXgItJwDFNxKvwrp57G8h0zVwldHuA0IFt8El83yIs2FSDcpgxDJpUUTwK7gTduN3AK5iG7ehc/E2/gUPD3q3eY4awwAAAABJRU5ErkJggg==" alt="CNB" /></a>
+  </p>
+	  <p>
+    English | <a href="README.zh-CN.md">前往中文版本</a>
+  </p>
+
+  <p>
+    <a href="https://dl.dbxio.com/assets/screenshot-light.png"><img src="https://dl.dbxio.com/assets/screenshot-light.png" width="395" /></a>
+    <a href="https://dl.dbxio.com/assets/screenshot-dark.png"><img src="https://dl.dbxio.com/assets/screenshot-dark.png" width="395" /></a>
+  </p>
+  <p>
+    <a href="https://dl.dbxio.com/assets/screenshot-er.png"><img src="https://dl.dbxio.com/assets/screenshot-er.png" width="395" /></a>
+    <a href="https://dl.dbxio.com/assets/screenshot-grid.png"><img src="https://dl.dbxio.com/assets/screenshot-grid.png" width="395" /></a>
+  </p>
+</div>
+
+## Why DBX?
+
+<table>
+  <tr>
+    <td width="50%">
+      <h3>🪶 20 MB, zero runtime bloat</h3>
+      <p>No Java JRE. No Python venv. No bundled Chromium. DBX ships as a single small binary — download, install, connect. DBeaver needs Java; TablePlus is macOS-only. DBX runs everywhere with nothing extra.</p>
+    </td>
+    <td width="50%">
+      <h3>🤖 AI that lives in your editor</h3>
+      <p>Highlight a table, describe what you want, get SQL back — no copy-paste between tools. Works with Claude, OpenAI, or local models via Ollama. Built-in safety checks review AI-generated SQL before it runs.</p>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <h3>🔌 MCP: your databases, AI-ready</h3>
+      <p>DBX speaks the Model Context Protocol. Claude Code, Cursor, Windsurf, and other AI coding agents can query your databases through connections you already set up. One config, everywhere.</p>
+    </td>
+    <td>
+      <h3>🌐 Desktop + Docker + Web</h3>
+      <p>Native app on macOS, Windows, and Linux. Self-host via Docker for team access. Web version for browser-only environments. Same feature set. Same connections.</p>
+    </td>
+  </tr>
+</table>
+
+## Features
+
+### 60+ Databases, One Tool
+
+MySQL, PostgreSQL, SQLite, Cloudflare D1, Redis, MongoDB, DuckDB, ClickHouse, SQL Server, Oracle, Elasticsearch, Qdrant, Milvus, Weaviate, MariaDB, TiDB, OceanBase, openGauss, GaussDB, KWDB, KingBase, Vastbase, GoldenDB, Doris, SelectDB, StarRocks, Manticore Search, Redshift, DM, TDengine, XuguDB, CockroachDB, Access, HighGo, and more. Agent/JDBC-oriented profiles extend DBX to H2, Snowflake, Trino, PrestoSQL, Hive, DB2, Informix, Neo4j, Cassandra, BigQuery, Kylin, SunDB, and custom JDBC connections. New native and agent-driven drivers also cover Databricks, SAP HANA, Teradata, Vertica, Firebird, Exasol, YashanDB, GBase 8a/8s, Databend, RQLite, Turso, InfluxDB, QuestDB, IoTDB, etcd, ZooKeeper, Nacos, IRIS, and more. Message queue admin is also available for Pulsar, Kafka, and RocketMQ. All in a single ~20 MB app. No bundled Chromium.
+
+### Query Editor
+
+CodeMirror 6 with SQL syntax highlighting, metadata-aware autocomplete, `Cmd+Enter` execution, selected SQL execution, SQL formatting, diagnostics, and 9 editor themes. Persistent query history, saved SQL snippets, tab restore, and SQL file execution keep repeat work close at hand.
+
+### AI SQL Assistant
+
+Describe what you want in plain language — get SQL back. DBX can explain queries, optimize SQL, fix errors, and run AI-generated SQL through built-in safety checks. Works with Claude, OpenAI, local models, or any OpenAI-compatible endpoint.
+
+### Data Grid
+
+Virtual-scrolled table that handles large result sets. Inline editing, SQL preview before save, WHERE / ORDER BY controls, DataGrip-style filters, LIKE / NOT LIKE context filters, sorting, full-text search, pagination, column resize, auto-fit, row numbers, zebra stripes, and full cell details. Export or copy as CSV, JSON, Markdown, XLSX, or INSERT statements.
+
+### Schema Tools
+
+- **Schema browser** — databases, schemas, tables, columns, indexes, foreign keys, triggers, with sidebar search & pin
+- **Object browser** — grouped procedures, functions, views, and source editing where supported
+- **Table structure editor** — reviewable column and index changes for supported engines
+- **ER diagram** — visualize table relationships
+- **Schema diff** — compare structures across connections
+- **Explain plan** — visual query execution plan
+- **Field lineage** — column-level lineage analysis
+- **Database search** — find objects across large schemas
+
+### Data Operations
+
+- **Table import** — CSV, Excel
+- **Data transfer** — migrate between databases
+- **Database export** — full database dump
+- **Data compare** — compare table data and review synchronization output
+- **SQL file execution** — run `.sql` files directly
+- **File preview** — drag & drop Parquet, CSV, JSON to preview instantly (powered by DuckDB)
+- **Connection import** — bring connection profiles from DBeaver or Navicat
+
+### Specialized Browsers
+
+- **Redis** — key pattern search, batch key operations, command runner, TTL editing, and all data types (String, Hash, List, Set, ZSet, Stream)
+- **MongoDB** — document CRUD with pagination, Atlas & replica set URL connection
+
+### Safety & Connectivity
+
+SSH tunnel (key & password) · database and AI proxy settings · auto-reconnect on connection loss · confirmation dialogs for destructive operations · encrypted config export/import · color-coded connections · driver store and optional JDBC plugin
+
+### Polished UI
+
+Dark mode with native title bar sync · 9 editor themes · English, 简体中文 & Español · layout preferences · built-in auto-update
+
+## AI Agent Integration (MCP)
+
+DBX provides an [MCP server](packages/mcp-server/) that lets AI coding agents query your databases using connections already configured in DBX.
+
+```bash
+npx @dbx-app/mcp-server
+```
+
+Add to your `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "dbx": { "command": "npx", "args": ["-y", "@dbx-app/mcp-server"] }
+  }
+}
+```
+
+Windows portable builds need `DBX_DATA_DIR` in the MCP config, pointing to the `data` directory next to `DBX.exe` (the folder that contains `dbx.db`).
+
+For DBX Web or Docker deployments, point the MCP server at the Web backend API. If the Web login page requires a password, set `DBX_WEB_PASSWORD` to the same password used there:
+
+```json
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "npx",
+      "args": ["-y", "@dbx-app/mcp-server"],
+      "env": {
+        "DBX_WEB_URL": "http://localhost:4224",
+        "DBX_WEB_PASSWORD": "your-web-login-password"
+      }
+    }
+  }
+}
+```
+
+Works with Claude Code, Cursor, Windsurf, and any MCP-compatible agent. Supports listing connections, browsing tables, executing SQL, and opening tables directly in DBX's UI.
+
+DBX also provides a dedicated CLI package for terminal, script, and Codex workflows:
+
+```bash
+npm install -g @dbx-app/cli
+# or via Homebrew
+brew tap t8y2/dbx && brew install dbx-cli
+dbx connections list --json
+dbx query local "select 1" --json
+```
+
+See the [MCP server README](packages/mcp-server/README.md) and [CLI README](packages/cli/README.md) for details.
+
+## Install
+
+Download the latest release from the [Releases](https://github.com/t8y2/dbx/releases/latest) page.
+
+**Homebrew (macOS):**
+
+```bash
+brew install --cask dbx
+```
+
+**Scoop (Windows):**
+
+```bash
+scoop bucket add dbx https://github.com/t8y2/scoop-bucket
+scoop install dbx
+```
+
+**WinGet (Windows):**
+
+```
+winget install t8y2.dbx
+```
+
+**Flatpak (Linux):**
+
+```bash
+flatpak remote-add --if-not-exists flatpark https://dl.flatpark.org/flatpark.flatpakrepo
+flatpak install flatpark com.dbxio.dbx
+```
+
+Updates then arrive through the regular `flatpak update`. See the [DBX page on FlatPark](https://flatpark.org/apps/com.dbxio.dbx/) for details.
+
+## Self-Hosted (Docker)
+
+DBX provides a web version that can be deployed via Docker. The examples use
+the `latest` tag to pull the current release.
+
+```bash
+docker run -d --pull=always --name dbx -p 4224:4224 -v dbx-data:/app/data t8y2/dbx:latest
+```
+
+This uses the cross-platform `dbx-data` named volume. Users in China can use
+the CNB image, `docker.cnb.cool/dbxio.com/dbx:latest`, for faster pulls.
+
+For Docker Compose, `deploy/docker-compose.yml` remains the source-build
+configuration. To deploy a published image, use
+`deploy/docker-compose.release.yml`:
+
+```bash
+docker compose -f deploy/docker-compose.release.yml up -d
+```
+
+```yaml
+services:
+  dbx:
+    image: t8y2/dbx:latest
+    # For faster pulls in China, use the CNB image instead:
+    # image: docker.cnb.cool/dbxio.com/dbx:latest
+    pull_policy: always
+    ports:
+      - "4224:4224"
+    volumes:
+      - dbx-data:/app/data
+    restart: unless-stopped
+
+volumes:
+  dbx-data:
+```
+
+Open `http://localhost:4224` in your browser. Multi-arch images (amd64 / arm64) are available.
+
+To publish DBX under a reverse-proxy context path such as `/dbx`, set the
+runtime base path and proxy the same prefix to the container:
+
+```yaml
+environment:
+  - DBX_PUBLIC_BASE_PATH=/dbx
+```
+
+When building the frontend yourself with an absolute asset base, set
+`VITE_DBX_BASE_PATH=/dbx/` before `pnpm build`.
+
+## Getting Started
+
+### Prerequisites
+
+- [Node.js](https://nodejs.org/) >= 18
+- [pnpm](https://pnpm.io/)
+- [Rust](https://www.rust-lang.org/tools/install) >= 1.77
+
+#### System Dependencies
+
+**macOS:**
+
+No additional dependencies required.
+
+**Linux (Ubuntu/Debian):**
+
+```bash
+sudo apt-get install -y libwebkit2gtk-4.1-dev libgtk-3-dev libappindicator3-dev librsvg2-dev patchelf libssl-dev
+```
+
+**NIXOS/NIX :** 
+
+<a href="README-NIX.md">See README-NIX.md</a>
+
+**Windows:**
+
+No additional dependencies required.
+
+### Development
+
+```bash
+make
+```
+
+`make` installs root dependencies when needed and starts the local Tauri desktop development environment.
+
+> [!TIP]
+> DuckDB compilation takes a while. If you're not working on DuckDB features,
+> skip it to speed up local builds:
+>
+> ```bash
+> # Fast checks (skip DuckDB)
+> make cargo-check-fast
+> make cargo-test-fast
+>
+> # Tauri dev without DuckDB
+> make dev-fast
+> ```
+>
+> The `--no-default-features` flag only affects local development.
+> Release builds (`pnpm tauri build`) always include DuckDB.
+
+Web version:
+
+```bash
+make dev-web       # frontend
+make dev-backend   # backend
+```
+
+Documentation site:
+
+```bash
+make docs
+```
+
+The official DBX documentation site lives in `docs/`. If you want to improve the website content or documentation pages, edit the files under `docs/` and run `make docs` to preview the site locally.
+
+JDBC agent driver development projects live in `agents/`:
+
+```bash
+cd agents
+./gradlew test
+```
+
+Build artifacts from `agents/drivers/<db-type>/build/libs/` are picked up by local driver install flows when available.
+
+### Build
+
+```bash
+make package
+```
+
+The installer will be in `src-tauri/target/release/bundle/`.
+
+## Tech Stack
+
+| Layer     | Technology                                                                                                                                                                                                       |
+| --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Framework | [Tauri 2](https://tauri.app/)                                                                                                                                                                                    |
+| Frontend  | [Vue 3](https://vuejs.org/) + TypeScript                                                                                                                                                                         |
+| UI        | [shadcn-vue](https://www.shadcn-vue.com/) + Tailwind CSS                                                                                                                                                         |
+| Editor    | [CodeMirror 6](https://codemirror.net/)                                                                                                                                                                          |
+| Backend   | Rust + [sqlx](https://github.com/launchbadge/sqlx) / [tiberius](https://github.com/prisma/tiberius) / [redis-rs](https://github.com/redis-rs/redis-rs) / [mongodb](https://github.com/mongodb/mongo-rust-driver) |
+
+## Documentation
+
+- [Official docs](https://dbxio.com/en/docs/what-is-dbx) — feature guides and tutorials
+- [Contributing](CONTRIBUTING.md) — how to pick up issues and open PRs
+- [Web API reference](docs/content/docs/web-api.mdx) — HTTP API for Docker/Web deployments
+- [Examples](examples/) — CLI, MCP, Docker, and API samples
+
+## Community
+
+<a href="https://discord.gg/W7NyVDRt6a" target="_blank"><img src="https://img.shields.io/badge/Discord-Join-5865F2?logo=discord&logoColor=white" alt="Discord" /></a>
+<a href="https://qm.qq.com/q/1087880322" target="_blank"><img src="https://img.shields.io/badge/QQ%20群-1087880322-EB1923?logo=tencentqq&logoColor=white" alt="QQ Group" /></a>
+<a href="https://docs.qq.com/doc/DVVhMY0h1ekJqc0tz" target="_blank"><img src="https://img.shields.io/badge/微信群-Join-07C160?logo=wechat&logoColor=white" alt="WeChat Group" /></a>
+[![LINUX DO](https://img.shields.io/badge/LINUX%20DO-Community-blue)](https://linux.do)
+
+## FAQ
+
+<details>
+<summary><strong>Is DBX free?</strong></summary>
+Yes. DBX is open source under Apache-2.0. All features are free.
+</details>
+
+<details>
+<summary><strong>Does DBX phone home?</strong></summary>
+No. DBX does not collect telemetry. The auto-update feature checks GitHub Releases for new versions — you can disable it in settings.
+</details>
+
+<details>
+<summary><strong>Can I use DBX without an internet connection?</strong></summary>
+Yes. The desktop app works fully offline. For air-gapped driver installs, download offline driver packages from the [Offline Drivers page](https://dbxio.com/en/drivers) on an internet-connected machine, transfer them to the offline machine, then import them in DBX from Settings > Driver Manager. AI features need network access to the model endpoint (or a local model via Ollama).
+</details>
+
+<details>
+<summary><strong>How is DBX different from DBeaver / TablePlus / Beekeeper Studio?</strong></summary>
+DBX is 20 MB with no runtime dependencies (no Java, no Python). It includes AI and MCP natively — not as plugins. It supports 60+ databases across desktop, Docker, and web from a single codebase.
+</details>
+
+<details>
+<summary><strong>What databases are supported?</strong></summary>
+MySQL, PostgreSQL, SQLite, Cloudflare D1, Redis, MongoDB, DuckDB, ClickHouse, SQL Server, Oracle, Elasticsearch, Qdrant, Milvus, Weaviate, MariaDB, TiDB, OceanBase, openGauss, GaussDB, KWDB, KingBase, Vastbase, GoldenDB, Doris, SelectDB, StarRocks, Manticore Search, Redshift, DM, TDengine, XuguDB, CockroachDB, Access, HighGo, and more. Agent/JDBC-oriented profiles extend support to H2, Snowflake, Trino, PrestoSQL, Hive, DB2, Informix, Neo4j, Cassandra, BigQuery, Kylin, SunDB, Databricks, SAP HANA, Teradata, Vertica, Firebird, Exasol, YashanDB, GBase 8a/8s, Databend, RQLite, Turso, InfluxDB, QuestDB, IoTDB, etcd, ZooKeeper, Nacos, IRIS, and custom JDBC connections. Message queue admin (Pulsar, Kafka, RocketMQ) is also supported.
+</details>
+
+<details>
+<summary><strong>How do I report a bug or request a feature?</strong></summary>
+Open an issue on <a href="https://github.com/t8y2/dbx/issues">GitHub Issues</a>.
+</details>
+
+## Contributors
+
+<a href="https://github.com/t8y2/dbx/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=t8y2/dbx" />
+</a>
+
+## Star History
+
+<a href="https://www.star-history.com/?repos=t8y2%2Fdbx&type=date&legend=top-left">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=t8y2/dbx&type=date&theme=dark&legend=top-left" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=t8y2/dbx&type=date&legend=top-left" />
+   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=t8y2/dbx&type=date&legend=top-left" />
+ </picture>
+</a>
+
+## License
+
+[Apache-2.0](LICENSE)
diff --git a/README.wehub.md b/README.wehub.md
new file mode 100644
index 0000000..db2551e
--- /dev/null
+++ b/README.wehub.md
@@ -0,0 +1,7 @@
+# WeHub 来源说明
+
+- 原始项目：`t8y2/dbx`
+- 原始仓库：https://github.com/t8y2/dbx
+- 导入方式：上游默认分支的最新快照
+- 原作者、版权和许可证信息以原始仓库及本仓库 LICENSE 为准
+- 本文件仅用于记录来源，不代表 WeHub 是原项目作者
diff --git a/README.zh-CN.md b/README.zh-CN.md
new file mode 100644
index 0000000..8dc73a6
--- /dev/null
+++ b/README.zh-CN.md
@@ -0,0 +1,427 @@
+<div align="center">
+  <p style="font-size: 18px; white-space: nowrap;"><strong>20 MB 驾驭 60+ 种数据库。桌面端 & Docker 自托管，内置 AI 助手。</strong></p>
+
+  <p>
+    <img src="https://dl.dbxio.com/assets/readme-hero-20260707.png" alt="DBX 截图" width="820" />
+  </p>
+
+  <p>
+    <a href="https://github.com/t8y2/dbx/releases"><img src="https://img.shields.io/github/downloads/t8y2/dbx/total?style=for-the-badge&color=blue" /></a>
+    <a href="https://github.com/t8y2/dbx/graphs/contributors"><img src="https://img.shields.io/github/contributors/t8y2/dbx?style=for-the-badge" /></a>
+    <a href="https://qm.qq.com/cgi-bin/qm/qr?k=&group_code=1087880322"><img src="https://img.shields.io/badge/QQ_群-1087880322-EB1923?style=for-the-badge&logo=data:image/svg%2bxml;base64,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" alt="加入 QQ 群" /></a>
+    <a href="https://docs.qq.com/doc/DVVhMY0h1ekJqc0tz" target="_blank"><img src="https://img.shields.io/badge/微信交流群-点击加入-07C160?style=for-the-badge&logo=wechat&logoColor=white" alt="加入微信交流群" /></a>
+    <a href="https://discord.gg/W7NyVDRt6a"><img src="https://dcbadge.limes.pink/api/server/W7NyVDRt6a" alt="加入 Discord" /></a>
+  </p>
+  <p>
+		<a href="https://trendshift.io/repositories/26775?utm_source=trendshift-badge&amp;utm_medium=badge&amp;utm_campaign=badge-trendshift-26775" target="_blank" rel="noopener noreferrer"><img src="https://trendshift.io/api/badge/trendshift/repositories/26775/daily?language=Rust" alt="t8y2%2Fdbx | Trendshift" width="250" height="55"/></a>
+    <a href="https://hellogithub.com/repository/t8y2/dbx" target="_blank"><img src="https://api.hellogithub.com/v1/widgets/recommend.svg?rid=7f74ffda697241bf996e17e1b0900a21&claim_uid=p0UjnC1TLtyvWSx" alt="Featured｜HelloGitHub" style="width: 250px; height: 54px;" width="250" height="54" /></a>
+	<a href="https://www.producthunt.com/products/dbx/launches/dbx?embed=true&amp;utm_source=badge-featured&amp;utm_medium=badge&amp;utm_campaign=badge-dbx" target="_blank" rel="noopener noreferrer"><img alt="DBX - Lightweight open-source database manager built with Rust | Product Hunt" width="250" height="54" src="https://api.producthunt.com/widgets/embed-image/v1/featured.svg?post_id=1136811&amp;theme=light&amp;t=1780979717555"></a>
+	  </p>
+  <p>
+    <img src="https://img.shields.io/badge/MySQL-4479A1?logo=mysql&logoColor=white" />
+    <img src="https://img.shields.io/badge/PostgreSQL-4169E1?logo=postgresql&logoColor=white" />
+    <img src="https://img.shields.io/badge/SQLite-003B57?logo=sqlite&logoColor=white" />
+    <img src="https://img.shields.io/badge/Redis-DC382D?logo=redis&logoColor=white" />
+    <img src="https://img.shields.io/badge/MongoDB-47A248?logo=mongodb&logoColor=white" />
+    <img src="https://img.shields.io/badge/DuckDB-FFF000?logo=duckdb&logoColor=black" />
+    <img src="https://img.shields.io/badge/ClickHouse-FFCC01?logo=clickhouse&logoColor=black" />
+    <img src="https://img.shields.io/badge/SQL%20Server-CC2927?logo=microsoftsqlserver&logoColor=white" />
+    <img src="https://img.shields.io/badge/Oracle-F80000?logo=oracle&logoColor=white" />
+    <img src="https://img.shields.io/badge/Elasticsearch-005571?logo=elasticsearch&logoColor=white" />
+    <img src="https://img.shields.io/badge/MariaDB-003545?logo=mariadb&logoColor=white" />
+    <img src="https://img.shields.io/badge/TiDB-DC150B?logo=tidb&logoColor=white" />
+    <img src="https://img.shields.io/badge/Doris-0052CC?logoColor=white" />
+    <img src="https://img.shields.io/badge/SelectDB-22C1C3?logoColor=white" />
+    <img src="https://img.shields.io/badge/StarRocks-5C2D91?logoColor=white" />
+    <img src="https://img.shields.io/badge/Redshift-8C4FFF?logo=amazonredshift&logoColor=white" />
+    <img src="https://img.shields.io/badge/DM-3857FF?logoColor=white" />
+    <img src="https://img.shields.io/badge/OceanBase-006AFF?logoColor=white" />
+    <img src="https://img.shields.io/badge/openGauss-2B7BD9?logoColor=white" />
+    <img src="https://img.shields.io/badge/GaussDB-E60012?logoColor=white" />
+    <img src="https://img.shields.io/badge/KWDB-1c60e0?logoColor=white" />
+    <img src="https://img.shields.io/badge/KingBase-003B8E?logoColor=white" />
+    <img src="https://img.shields.io/badge/TDengine-2F6FFF?logoColor=white" />
+    <img src="https://img.shields.io/badge/CockroachDB-6933FF?logoColor=white" />
+    <img src="https://img.shields.io/badge/InfluxDB-d30971?logo=influxdb&logoColor=white" />
+    <img src="https://img.shields.io/badge/JDBC-4B5563?logoColor=white" />
+    <img src="https://img.shields.io/badge/and%20more...-555555?logoColor=white" />
+    <a href="https://atomgit.com/t8y2/dbx"><img src="https://atomgit.com/t8y2/dbx/star/badge.svg" alt="AtomGit Stars" /></a>
+    <a href="https://cnb.cool/dbxio.com/dbx"><img src="https://img.shields.io/badge/CNB-dbx-F76945?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAAXNSR0IArs4c6QAAAppJREFUOE9tk01rE1EUhs+5H5lJ0iQT3FRX2Yi4avoLkv4CWxBcNt11oZiuFKGmXQhFN6kuRESSgitXKf6A5g+I6cqFLiKCiptOkraZ5H4cuZOkH9oLw+UO8z7nvGfei3DFohoEQLAKCGWyGJCSbQZsD3ei7r+f45WATV6xmjdISyAlYLaDliveux+ti5ozwLAaFPhIlk6G6f18sxuO7l9bBiWbVoncDGCMWMl++PI/gJ7IohkmD0zkBxT5oRn5LTpN7ULqBByEtFywWvRyHz8Fx3dvN0UwuMPyR0uJFycddH7tKPHZRn7BjnwwkQcUud0HO/K7oOENcTYPRCEAFERmsCpyfZDZfpdnBosOUKGx13BC60QTIdjpmSzrEWDR+UagjsgMciLXAwfhc4MNpKfQtOPE6mVh0gEOaeTXtWXXEdADpJAR/GaZ/rrM9Us82wORPd5zHbRp7JVcyxR5PRP5LTPy6uo0HXIlG9awMgLuEUABkBYI7VLyxs+yyPW3+Nyg4zqoG+UV7TDRlMBbWA/D43u3qlbLGmgRWM2BjFxjQjWQGQBuu4bYYvrm14JMnQSXcjBcny9A5DXIiDJp9/8FWCXAAOaFUEfILTgIcttOvf+2NJnLdI0fBFUyskZKBGTEJEAmBuzr9LCSUDwGQAwwgMzu+m9/VWOAeZSsk+YP48C4li/sRok1nlBd5PogBjgxNw70PfHyqBADyEVXicasZXCVpxYiLfO+HxVZDHCVYwvu2ebPT7fOLNAm65AWLnEAzvsEcOi9/lPU1aACXDfOLdhD9kxNszGdweQGYstqXgItJwDFNxKvwrp57G8h0zVwldHuA0IFt8El83yIs2FSDcpgxDJpUUTwK7gTduN3AK5iG7ehc/E2/gUPD3q3eY4awwAAAABJRU5ErkJggg==" alt="CNB" /></a>
+  </p>
+	  <p>
+    <a href="README.md">English</a> | 简体中文
+  </p>
+
+  <p>
+    <a href="https://dl.dbxio.com/assets/screenshot-light.png"><img src="https://dl.dbxio.com/assets/screenshot-light.png" width="395" /></a>
+    <a href="https://dl.dbxio.com/assets/screenshot-dark.png"><img src="https://dl.dbxio.com/assets/screenshot-dark.png" width="395" /></a>
+  </p>
+  <p>
+    <a href="https://dl.dbxio.com/assets/screenshot-er.png"><img src="https://dl.dbxio.com/assets/screenshot-er.png" width="395" /></a>
+    <a href="https://dl.dbxio.com/assets/screenshot-grid.png"><img src="https://dl.dbxio.com/assets/screenshot-grid.png" width="395" /></a>
+  </p>
+</div>
+
+## 为什么选择 DBX？
+
+<table>
+  <tr>
+    <td width="50%">
+      <h3>🪶 20 MB，极致轻量</h3>
+      <p>无需 Java 运行环境，无需 Python 虚拟环境，不内嵌 Chromium。DBX 是单个小巧的二进制文件——下载、安装、连接。DBeaver 依赖 Java；TablePlus 仅限 macOS。DBX 全平台可用，无需额外运行时。</p>
+    </td>
+    <td width="50%">
+      <h3>🤖 AI 原生集成在编辑器里</h3>
+      <p>选中一张表，描述你想要什么，直接得到 SQL——无需在工具之间复制粘贴。支持 Claude、OpenAI，或通过 Ollama 使用本地模型。内置安全检查会在执行前审查 AI 生成的 SQL。</p>
+    </td>
+  </tr>
+  <tr>
+    <td>
+      <h3>🔌 MCP 协议：你的数据库，AI 就绪</h3>
+      <p>DBX 原生支持 Model Context Protocol。Claude Code、Cursor、Windsurf 等 AI 编程助手可以直接通过你已配置的数据库连接查询数据。一次配置，处处可用。</p>
+    </td>
+    <td>
+      <h3>🌐 桌面端 + Docker + Web</h3>
+      <p>macOS、Windows、Linux 原生应用。通过 Docker 自托管供团队访问。Web 版本适配纯浏览器环境。同样的功能，同样的连接配置。</p>
+    </td>
+  </tr>
+</table>
+
+## 功能特性
+
+### 60+ 种数据库，一个工具搞定
+
+MySQL、PostgreSQL、SQLite、Cloudflare D1、Redis、MongoDB、DuckDB、ClickHouse、SQL Server、Oracle、Elasticsearch、MariaDB、TiDB、OceanBase、openGauss、GaussDB、KWDB、KingBase、Vastbase、GoldenDB、Doris、SelectDB、StarRocks、Manticore Search、Redshift、DM、TDengine、虚谷 XuguDB、CockroachDB、Access、HighGo 等数据库都能直接连接。Agent/JDBC 方向的配置还可扩展到 H2、Snowflake、Trino、Hive、DB2、Informix、Neo4j、Cassandra、BigQuery、Kylin、SunDB 和自定义 JDBC。新增的原生与 Agent 驱动还覆盖了 Databricks、SAP HANA、Teradata、Vertica、Firebird、Exasol、崖山 YashanDB、GBase、Databend、RQLite、Turso、InfluxDB、QuestDB、IoTDB、etcd、IRIS 等。全部装进约 20 MB 的应用里，不内嵌 Chromium。
+
+### 查询编辑器
+
+CodeMirror 6 语法高亮、元数据感知自动补全、`Cmd+Enter` 执行、选中 SQL 执行、SQL 格式化、诊断提示，9 种编辑器主题。查询历史、常用 SQL 片段、标签页恢复和 SQL 文件执行让重复工作更顺手。
+
+### AI SQL 助手
+
+用自然语言描述你的需求，直接生成 SQL。还能解释查询、优化 SQL、修复错误，并通过内置安全检查执行 AI 生成的 SQL。支持 Claude、OpenAI、本地模型或任何 OpenAI 兼容端点。
+
+### 数据表格
+
+虚拟滚动，轻松应对大型结果集。行内编辑、保存前 SQL 预览、WHERE / ORDER BY 控件、DataGrip 风格过滤器、LIKE / NOT LIKE 右键过滤、排序、全文搜索、分页、列宽调整、自动列宽、行号、斑马纹和完整单元格详情。支持导出或复制为 CSV、JSON、Markdown、XLSX、INSERT 语句。
+
+### Schema 工具
+
+- **结构浏览** — 数据库、Schema、表、字段、索引、外键、触发器，支持侧边栏搜索和置顶
+- **对象浏览** — 按类型分组查看过程、函数、视图，并在支持的数据库中编辑源码
+- **表结构编辑器** — 对支持的数据库执行可审查的字段和索引变更
+- **ER 关系图** — 可视化表间关联
+- **Schema 对比** — 跨连接对比表结构差异
+- **执行计划** — 可视化查询执行计划
+- **字段血缘** — 字段级血缘分析
+- **数据库搜索** — 在大型 Schema 中快速查找对象
+
+### 数据操作
+
+- **数据导入** — CSV、Excel
+- **数据迁移** — 在数据库之间迁移数据
+- **数据库导出** — 完整数据库导出
+- **数据对比** — 对比表数据并审查同步结果
+- **SQL 文件执行** — 直接执行 `.sql` 文件
+- **文件预览** — 拖入 Parquet、CSV、JSON 即时预览（基于 DuckDB）
+- **连接导入** — 从 DBeaver 或 Navicat 导入连接配置
+
+### 专项浏览器
+
+- **Redis** — 模式匹配搜索、批量键操作、命令执行器、TTL 编辑，全数据类型支持（String、Hash、List、Set、ZSet、Stream）
+- **MongoDB** — 文档增删改查、分页浏览，支持 Atlas 和副本集 URL 直连
+
+### 安全与连接
+
+SSH 隧道（密钥和密码认证）· 数据库和 AI 代理设置 · 断线自动重连 · 危险操作确认对话框 · 加密导出/导入连接配置 · 连接颜色标记 · 驱动商店与可选 JDBC 插件
+
+### 精致 UI
+
+深色模式原生标题栏同步 · 9 种编辑器主题 · English、简体中文、Español · 布局偏好设置 · 内置自动更新
+
+## AI 编程助手集成 (MCP)
+
+DBX 提供 [MCP Server](packages/mcp-server/)，让 AI 编程助手直接使用 DBX 中已配置的数据库连接查询数据。
+
+```bash
+npx @dbx-app/mcp-server
+```
+
+在 `.mcp.json` 中添加：
+
+```json
+{
+  "mcpServers": {
+    "dbx": { "command": "npx", "args": ["-y", "@dbx-app/mcp-server"] }
+  }
+}
+```
+
+Windows 便携版需要在 MCP 配置中设置 `DBX_DATA_DIR`，指向 `DBX.exe` 同级的 `data` 目录（即包含 `dbx.db` 的文件夹）。
+
+如果连接的是 DBX Web 或 Docker 部署，请让 MCP Server 指向 Web 后端 API。如果 Web 登录页需要密码，`DBX_WEB_PASSWORD` 填写同一个 Web 登录密码：
+
+```json
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "npx",
+      "args": ["-y", "@dbx-app/mcp-server"],
+      "env": {
+        "DBX_WEB_URL": "http://localhost:4224",
+        "DBX_WEB_PASSWORD": "你的 Web 登录密码"
+      }
+    }
+  }
+}
+```
+
+支持 Claude Code、Cursor、Windsurf 等 MCP 兼容的 AI 助手。可列出连接、浏览表、执行 SQL，还能直接在 DBX 界面中打开表。
+
+DBX 也提供独立 CLI 包，适合终端、脚本和 Codex 工作流：
+
+```bash
+npm install -g @dbx-app/cli
+# 或通过 Homebrew
+brew tap t8y2/dbx && brew install dbx-cli
+dbx connections list --json
+dbx query local "select 1" --json
+```
+
+详见 [MCP Server 说明](packages/mcp-server/README.md) 和 [CLI 说明](packages/cli/README.md)。
+
+## 安装
+
+从 [Releases](https://github.com/t8y2/dbx/releases/latest) 页面下载最新版本。
+
+**Homebrew (macOS)：**
+
+```bash
+brew install --cask dbx
+```
+
+**Scoop (Windows)：**
+
+```bash
+scoop bucket add dbx https://github.com/t8y2/scoop-bucket
+scoop install dbx
+```
+
+**WinGet (Windows):**
+
+```
+winget install t8y2.dbx
+```
+
+**Flatpak (Linux)：**
+
+```bash
+flatpak remote-add --if-not-exists flatpark https://dl.flatpark.org/flatpark.flatpakrepo
+flatpak install flatpark com.dbxio.dbx
+```
+
+之后通过常规的 `flatpak update` 即可获取更新。详见 [FlatPark 上的 DBX 页面](https://flatpark.org/apps/com.dbxio.dbx/)。
+
+## 自托管 (Docker)
+
+DBX 提供 Web 版本，可通过 Docker 部署。示例使用 `latest` 标签以拉取当前发布版本。
+
+```bash
+docker run -d --pull=always --name dbx -p 4224:4224 -v dbx-data:/app/data t8y2/dbx:latest
+```
+
+这里使用跨平台的 `dbx-data` 命名卷。中国大陆用户可选用 CNB 镜像
+`docker.cnb.cool/dbxio.com/dbx:latest`，以获得更快的拉取速度。
+
+使用 Docker Compose 时，`deploy/docker-compose.yml` 保留为源码构建配置。
+如需部署已发布的镜像，请使用 `deploy/docker-compose.release.yml`：
+
+```bash
+docker compose -f deploy/docker-compose.release.yml up -d
+```
+
+```yaml
+services:
+  dbx:
+    image: t8y2/dbx:latest
+    # 中国大陆用户可改用 CNB 镜像，以加快拉取速度：
+    # image: docker.cnb.cool/dbxio.com/dbx:latest
+    pull_policy: always
+    ports:
+      - "4224:4224"
+    volumes:
+      - dbx-data:/app/data
+    restart: unless-stopped
+
+volumes:
+  dbx-data:
+```
+
+如需通过 nginx 等反向代理发布到 `/dbx` 这类子路径下，设置运行时上下文路径，并将同一前缀代理到容器：
+
+```yaml
+environment:
+  - DBX_PUBLIC_BASE_PATH=/dbx
+```
+
+如果自行从源码构建前端并希望使用绝对资源路径，可在 `pnpm build` 前设置 `VITE_DBX_BASE_PATH=/dbx/`。
+
+浏览器访问 `http://localhost:4224`。支持 amd64 / arm64 双架构镜像。
+
+## 快速开始
+
+### 环境要求
+
+- [Node.js](https://nodejs.org/) >= 18
+- [pnpm](https://pnpm.io/)
+- [Rust](https://www.rust-lang.org/tools/install) >= 1.77
+
+#### 系统依赖
+
+**macOS：**
+
+无需额外安装。
+
+**Linux (Ubuntu/Debian)：**
+
+```bash
+sudo apt-get install -y libwebkit2gtk-4.1-dev libgtk-3-dev libappindicator3-dev librsvg2-dev patchelf libssl-dev
+```
+
+**NIXOS/NIX :** 
+
+<a href="README-NIX.md">查看 README-NIX.md</a>
+
+**Windows：**
+
+无需额外安装。
+
+### 开发
+
+```bash
+make
+```
+
+`make` 会在需要时安装根目录依赖，并启动本地 Tauri 桌面端开发环境。
+
+> [!TIP]
+> DuckDB 从源码编译较慢。如果不涉及 DuckDB 功能，可以跳过以加速本地构建：
+>
+> ```bash
+> # 快速检查（跳过 DuckDB）
+> make cargo-check-fast
+> make cargo-test-fast
+>
+> # Tauri 开发模式跳过 DuckDB
+> make dev-fast
+> ```
+>
+> `--no-default-features` 仅影响本地开发，发布构建（`pnpm tauri build`）始终包含 DuckDB。
+
+Web 版本：
+
+```bash
+make dev-web       # 前端
+make dev-backend   # 后端
+```
+
+文档站：
+
+```bash
+make docs
+```
+
+DBX 官网文档位于 `docs/` 目录。如果你想贡献官网内容或文档页面，请修改 `docs/` 下的文件，并运行 `make docs` 在本地预览文档站。
+
+JDBC Agent 驱动开发工程位于 `agents/` 目录：
+
+```bash
+cd agents
+./gradlew test
+```
+
+本地驱动安装流程会优先查找 `agents/drivers/<db-type>/build/libs/` 下的构建产物。
+
+### 构建
+
+```bash
+make package
+```
+
+安装包输出在 `src-tauri/target/release/bundle/` 目录。
+
+## 技术栈
+
+| 层级   | 技术                                                                                                                                                                                                             |
+| ------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 框架   | [Tauri 2](https://tauri.app/)                                                                                                                                                                                    |
+| 前端   | [Vue 3](https://vuejs.org/) + TypeScript                                                                                                                                                                         |
+| UI     | [shadcn-vue](https://www.shadcn-vue.com/) + Tailwind CSS                                                                                                                                                         |
+| 编辑器 | [CodeMirror 6](https://codemirror.net/)                                                                                                                                                                          |
+| 后端   | Rust + [sqlx](https://github.com/launchbadge/sqlx) / [tiberius](https://github.com/prisma/tiberius) / [redis-rs](https://github.com/redis-rs/redis-rs) / [mongodb](https://github.com/mongodb/mongo-rust-driver) |
+
+## 文档
+
+- [官方文档](https://dbxio.com/cn/docs/what-is-dbx) — 功能说明与使用教程
+- [贡献指南](CONTRIBUTING.zh-CN.md) — 如何认领 Issue 并提交 PR
+- [Web API 参考](docs/content/docs/web-api.cn.mdx) — Docker/Web 部署的 HTTP API
+- [示例代码](examples/) — CLI、MCP、Docker 与 API 示例
+
+## 社区
+
+<a href="https://discord.gg/W7NyVDRt6a" target="_blank"><img src="https://img.shields.io/badge/Discord-加入-5865F2?logo=discord&logoColor=white" alt="Discord" /></a>
+<a href="https://qm.qq.com/q/1087880322" target="_blank"><img src="https://img.shields.io/badge/QQ%20群-1087880322-EB1923?logo=tencentqq&logoColor=white" alt="QQ 群" /></a>
+<a href="https://docs.qq.com/doc/DVVhMY0h1ekJqc0tz" target="_blank"><img src="https://img.shields.io/badge/微信交流群-点击加入-07C160?logo=wechat&logoColor=white" alt="微信交流群" /></a>
+[![LINUX DO](https://img.shields.io/badge/LINUX%20DO-社区-blue)](https://linux.do)
+
+## 常见问题
+
+<details>
+<summary><strong>DBX 是免费的吗？</strong></summary>
+是的。DBX 基于 Apache-2.0 协议开源，所有功能均免费使用。
+</details>
+
+<details>
+<summary><strong>DBX 会收集用户数据吗？</strong></summary>
+不会。DBX 不收集任何遥测数据。自动更新功能仅检查 GitHub Releases 获取新版本——你可以在设置中禁用它。
+</details>
+
+<details>
+<summary><strong>可以离线使用吗？</strong></summary>
+可以。桌面端完全支持离线使用。内网环境安装驱动时，可在有网机器打开[离线驱动下载页](https://dbxio.com/cn/drivers)下载离线驱动包，传输到内网机器后，在 DBX 的「设置 > 驱动管理」中导入。AI 功能需要网络访问模型端点（或通过 Ollama 使用本地模型）。
+</details>
+
+<details>
+<summary><strong>DBX 和 DBeaver / TablePlus / Beekeeper Studio 有什么区别？</strong></summary>
+DBX 仅 20 MB，无需运行时依赖（无需 Java、无需 Python）。AI 和 MCP 是原生内置功能，不是插件。单一代码库同时支持 60+ 数据库、桌面端、Docker 和 Web。
+</details>
+
+<details>
+<summary><strong>支持哪些数据库？</strong></summary>
+MySQL、PostgreSQL、SQLite、Cloudflare D1、Redis、MongoDB、DuckDB、ClickHouse、SQL Server、Oracle、Elasticsearch、Qdrant、Milvus、Weaviate、MariaDB、TiDB、OceanBase、openGauss、GaussDB、KWDB、KingBase、Vastbase、GoldenDB、Doris、SelectDB、StarRocks、Manticore Search、Redshift、DM、TDengine、虚谷 XuguDB、CockroachDB、Access、HighGo 等。JDBC 方向配置可扩展到 H2、Snowflake、Trino、PrestoSQL、Hive、DB2、Informix、Neo4j、Cassandra、BigQuery、Kylin、SunDB、Databricks、SAP HANA、Teradata、Vertica、Firebird、Exasol、崖山 YashanDB、GBase 8a/8s、Databend、RQLite、Turso、InfluxDB、QuestDB、IoTDB、etcd、ZooKeeper、Nacos、IRIS 及自定义 JDBC 连接，并支持消息队列管理（Pulsar、Kafka、RocketMQ）。
+</details>
+
+<details>
+<summary><strong>如何报告 Bug 或请求新功能？</strong></summary>
+在 <a href="https://github.com/t8y2/dbx/issues">GitHub Issues</a> 提交 Issue。
+</details>
+
+## 贡献者
+
+<a href="https://github.com/t8y2/dbx/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=t8y2/dbx" />
+</a>
+
+## Star History
+
+<a href="https://www.star-history.com/?repos=t8y2%2Fdbx&type=date&legend=top-left">
+ <picture>
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=t8y2/dbx&type=date&theme=dark&legend=top-left" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=t8y2/dbx&type=date&legend=top-left" />
+   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=t8y2/dbx&type=date&legend=top-left" />
+ </picture>
+</a>
+
+## 开源协议
+
+[Apache-2.0](LICENSE)
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000..31abe6d
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,30 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please do not report security vulnerabilities in public GitHub issues.
+
+Use GitHub's private vulnerability reporting for this repository when available. If that is not available to you, open a minimal GitHub issue asking for a private security contact without including exploit details, credentials, tokens, connection strings, database dumps, or screenshots containing secrets.
+
+## What to Include
+
+Helpful reports include:
+
+- Affected DBX version or commit.
+- Operating system and installation method.
+- The impacted component, such as desktop app, Docker service, CLI, MCP server, or JDBC plugin.
+- Steps to reproduce in a safe test environment.
+- Impact assessment and any known workaround.
+
+## Scope
+
+Security-sensitive areas include:
+
+- Connection storage, config import/export, and encryption.
+- Database credential handling.
+- SSH tunnel and proxy handling.
+- AI provider keys and OpenAI-compatible endpoint configuration.
+- MCP and CLI access to local DBX connections.
+- Docker web service authentication and data directory handling.
+
+Please avoid testing against systems you do not own or have explicit permission to assess.
diff --git a/agents/.gitignore b/agents/.gitignore
new file mode 100644
index 0000000..e1afb2a
--- /dev/null
+++ b/agents/.gitignore
@@ -0,0 +1,8 @@
+**/libs/*.jar
+!drivers/oscar/libs/oscarJDBC8.jar
+gradle.properties
+build/
+*/bin/
+.gradle/
+.DS_Store
+openspec
diff --git a/agents/README.md b/agents/README.md
new file mode 100644
index 0000000..51aa7e2
--- /dev/null
+++ b/agents/README.md
@@ -0,0 +1,114 @@
+# DBX Agents
+
+English | [简体中文](README.zh-CN.md)
+
+Agent drivers for [DBX](https://github.com/t8y2/dbx) — database support via JDBC and native database drivers.
+
+Each agent runs as a standalone process and communicates with DBX via stdin/stdout JSON-RPC 2.0.
+
+## Supported Databases
+
+| Agent | Database | JDBC Driver |
+|-------|----------|-------------|
+| access | Microsoft Access | UCanAccess |
+| dameng | 达梦 DM8 | DM JDBC |
+| kingbase | 人大金仓 KingbaseES | KingbaseES JDBC |
+| vastbase | Vastbase | Vastbase JDBC |
+| goldendb | GoldenDB | MySQL Connector/J |
+| databend | Databend | Databend JDBC |
+| databricks | Databricks SQL | Databricks JDBC |
+| saphana | SAP HANA | SAP HANA JDBC |
+| teradata | Teradata | Teradata JDBC |
+| vertica | Vertica | Vertica JDBC |
+| firebird | Firebird | Jaybird JDBC |
+| exasol | Exasol | Exasol JDBC |
+| oceanbase-oracle | OceanBase Oracle Mode | OceanBase JDBC |
+| gbase8a | GBase 8a | External GBase 8a JDBC |
+| gbase8s | GBase 8s | External GBase 8s JDBC |
+| oracle | Oracle 10g+ | go-ora native agent |
+| h2 | H2 | H2 JDBC |
+| snowflake | Snowflake | Snowflake JDBC |
+| trino | Trino (Presto) | Trino JDBC |
+| hive | Apache Hive | Hive JDBC |
+| db2 | IBM DB2 | DB2 JDBC |
+| informix | IBM Informix | Informix JDBC |
+| neo4j | Neo4j | Neo4j JDBC |
+| cassandra | Apache Cassandra | Cassandra JDBC |
+| bigquery | Google BigQuery | BigQuery JDBC |
+| kylin | Apache Kylin | Kylin JDBC |
+| sundb | SunDB | SunDB JDBC |
+| tdengine | TDengine | taos-jdbcdriver (WebSocket, REST fallback) |
+| yashandb | 崖山 YashanDB | YashanDB JDBC |
+| xugu | 虚谷 XuguDB | XuguDB Go native agent |
+| iotdb | Apache IoTDB | IoTDB JDBC |
+| etcd | etcd | jetcd |
+| zookeeper | Apache ZooKeeper | Apache Curator |
+
+
+## Multi-JRE Support
+
+Most Java agents target JRE 21. Native agents, such as `oracle` and `xugu`, do not require a JRE. DBX downloads and manages the JRE 21 installation automatically for Java agents.
+
+## Choosing a Driver Language
+
+For new agents, prefer a **native (Go or Rust) driver** over a Java/JDBC agent whenever a mature, license-compatible native driver is available. Native agents ship as a single self-contained executable with no JRE, which significantly reduces memory footprint and startup time — the JVM baseline that every Java agent pays even when idle is avoided entirely.
+
+- **Native (Go/Rust)** — preferred when a usable native driver exists. See `drivers/oracle-go` (go-ora) and `drivers/xugu` as reference implementations. No JRE download or management is needed.
+- **Java/JDBC** — the default fallback when only a JDBC driver exists for the database, or when the native driver is immature or unmaintained. Most agents still fall in this category.
+
+Native agents implement the same JSON-RPC contract and `versions.json` registration as Java agents; they ship an `agent` executable instead of `agent.jar`. If both a native and a Java path exist for the same database, default DBX to the native one and keep the Java variant only as a compatibility fallback — see how `oracle` (go-ora native) coexists with `oracle-legacy` / `oracle-10g`.
+
+## Build
+
+Requires JDK 21 (Gradle toolchain auto-downloads if needed).
+
+```bash
+./gradlew shadowJar
+(cd drivers/oracle-go && go build -o agent .)
+(cd drivers/xugu && go build -o agent .)
+```
+
+Output JARs are in `drivers/{module}/build/libs/`. Native agents build from `drivers/oracle-go` and `drivers/xugu`.
+
+### Local DBX Runtime Test
+
+When changing a Java agent under `agents/drivers/<db_type>/` or shared Java agent protocol code, rebuild the target agent and replace the runtime JAR used by the local DBX app:
+
+```bash
+./gradlew :<db_type>:shadowJar
+cp ~/.dbx/agents/drivers/<db_type>/agent.jar ~/.dbx/agents/drivers/<db_type>/agent.jar.bak
+cp agents/drivers/<db_type>/build/libs/*-all.jar ~/.dbx/agents/drivers/<db_type>/agent.jar
+```
+
+Restart DBX or disconnect and reconnect the database so the new agent process loads the replacement JAR.
+
+Native agents such as `oracle` and `xugu` use the `agent` executable in the driver directory instead of `agent.jar`.
+
+## Versioning
+
+Agent module versions are tracked in [`versions.json`](versions.json).
+
+- **Changing an existing driver** — do not edit `versions.json` manually. The release CI diffs each `drivers/<module>/` directory against the previous tag and auto-bumps the patch version for every changed module (see [`bump-agent-versions.mjs`](../.github/scripts/bump-agent-versions.mjs)). A change to the shared `agents/common` runtime bumps every module that packages it.
+- **Adding a new driver** — add an entry to `versions.json`, e.g. `"rabbitmq": "0.1.0"`. The CI only bumps keys already present in the file, so a new module is invisible to versioning until it is registered here. In the same change, also add the module to `settings.gradle` and the support table above — `versions.json` keys must match the agent modules declared in `settings.gradle`, excluding the infrastructure modules `common` and `test-support`.
+
+## Development
+
+- Agent authoring guide: [docs/agent-authoring.md](docs/agent-authoring.md)
+- JDBC agent template: [docs/examples/jdbc-agent-template](docs/examples/jdbc-agent-template)
+- Release checklist: [docs/release-checklist.md](docs/release-checklist.md)
+
+## Architecture
+
+```
+DBX Main Process (Rust/Tauri)
+    │ stdin/stdout (JSON-RPC 2.0)
+    ▼
+agent / java -jar dbx-agent-{type}.jar
+    │
+    ▼
+Native driver / JDBC → Database
+```
+
+## License
+
+[AGPL-3.0](https://github.com/t8y2/dbx/blob/main/LICENSE)
diff --git a/agents/README.zh-CN.md b/agents/README.zh-CN.md
new file mode 100644
index 0000000..ef12499
--- /dev/null
+++ b/agents/README.zh-CN.md
@@ -0,0 +1,114 @@
+# DBX Agents
+
+[English](README.md) | 简体中文
+
+DBX 的 Agent 驱动 —— 通过 JDBC 和原生数据库驱动支持各种数据库。
+
+每个 agent 作为独立进程运行，通过 stdin/stdout 与 DBX 进行 JSON-RPC 2.0 通信。
+
+## 支持的数据库
+
+| Agent | 数据库 | JDBC 驱动 |
+|-------|----------|-------------|
+| access | Microsoft Access | UCanAccess |
+| dameng | 达梦 DM8 | DM JDBC |
+| kingbase | 人大金仓 KingbaseES | KingbaseES JDBC |
+| vastbase | Vastbase | Vastbase JDBC |
+| goldendb | GoldenDB | MySQL Connector/J |
+| databend | Databend | Databend JDBC |
+| databricks | Databricks SQL | Databricks JDBC |
+| saphana | SAP HANA | SAP HANA JDBC |
+| teradata | Teradata | Teradata JDBC |
+| vertica | Vertica | Vertica JDBC |
+| firebird | Firebird | Jaybird JDBC |
+| exasol | Exasol | Exasol JDBC |
+| oceanbase-oracle | OceanBase Oracle 模式 | OceanBase JDBC |
+| gbase8a | GBase 8a | 外部 GBase 8a JDBC |
+| gbase8s | GBase 8s | 外部 GBase 8s JDBC |
+| oracle | Oracle 10g+ | go-ora 原生 agent |
+| h2 | H2 | H2 JDBC |
+| snowflake | Snowflake | Snowflake JDBC |
+| trino | Trino (Presto) | Trino JDBC |
+| hive | Apache Hive | Hive JDBC |
+| db2 | IBM DB2 | DB2 JDBC |
+| informix | IBM Informix | Informix JDBC |
+| neo4j | Neo4j | Neo4j JDBC |
+| cassandra | Apache Cassandra | Cassandra JDBC |
+| bigquery | Google BigQuery | BigQuery JDBC |
+| kylin | Apache Kylin | Kylin JDBC |
+| sundb | SunDB | SunDB JDBC |
+| tdengine | TDengine | taos-jdbcdriver（WebSocket，REST 兜底） |
+| yashandb | 崖山 YashanDB | YashanDB JDBC |
+| xugu | 虚谷 XuguDB | XuguDB Go 原生 agent |
+| iotdb | Apache IoTDB | IoTDB JDBC |
+| etcd | etcd | jetcd |
+| zookeeper | Apache ZooKeeper | Apache Curator |
+
+
+## 多 JRE 支持
+
+多数 Java agent 以 JRE 21 为目标。原生 agent（如 `oracle` 和 `xugu`）不需要 JRE。对 Java agent，DBX 会自动下载并管理 JRE 21 安装。
+
+## 选择驱动实现语言
+
+对于新 agent，只要存在成熟、许可证兼容的原生驱动，优先选择**原生（Go 或 Rust）驱动**而非 Java/JDBC agent。原生 agent 以单一自包含可执行文件发布，无需 JRE，可显著降低内存占用和启动时间 —— 完全避开 Java agent 即便空闲也要付出的 JVM 基线开销。
+
+- **原生（Go/Rust）** —— 存在可用原生驱动时首选。参考 `drivers/oracle-go`（go-ora）和 `drivers/xugu`。无需 JRE 下载与管理。
+- **Java/JDBC** —— 当某数据库只有 JDBC 驱动，或原生驱动不成熟、缺乏维护时的默认兜底方案。多数 agent 仍属此类。
+
+原生 agent 实现与 Java agent 相同的 JSON-RPC 契约和 `versions.json` 登记；它发布的是 `agent` 可执行文件而非 `agent.jar`。若同一数据库同时存在原生和 Java 路径，DBX 默认使用原生方案，仅将 Java 变体作为兼容兜底保留 —— 参见 `oracle`（go-ora 原生）与 `oracle-legacy` / `oracle-10g` 的共存方式。
+
+## 构建
+
+需要 JDK 21（Gradle toolchain 会自动下载）。
+
+```bash
+./gradlew shadowJar
+(cd drivers/oracle-go && go build -o agent .)
+(cd drivers/xugu && go build -o agent .)
+```
+
+产物 JAR 在 `drivers/{module}/build/libs/`。原生 agent 从 `drivers/oracle-go` 和 `drivers/xugu` 构建。
+
+### 本地 DBX 运行时测试
+
+修改 `agents/drivers/<db_type>/` 下的 Java agent 或共享 Java agent 协议代码后，需重新构建目标 agent 并替换本地 DBX 应用使用的运行时 JAR：
+
+```bash
+./gradlew :<db_type>:shadowJar
+cp ~/.dbx/agents/drivers/<db_type>/agent.jar ~/.dbx/agents/drivers/<db_type>/agent.jar.bak
+cp agents/drivers/<db_type>/build/libs/*-all.jar ~/.dbx/agents/drivers/<db_type>/agent.jar
+```
+
+重启 DBX 或断开重连数据库，使新 agent 进程加载替换后的 JAR。
+
+`oracle` 和 `xugu` 等原生 agent 使用驱动目录下的 `agent` 可执行文件而非 `agent.jar`。
+
+## 版本管理
+
+Agent 模块的版本记录在 [`versions.json`](versions.json) 中，遵循以下规则：
+
+- **修改现有驱动**：无需手动编辑 `versions.json`。发版 CI 会把每个 `drivers/<module>/` 目录与上一个 tag 做对比，对有变更的模块自动 bump patch 版本号（见 [`bump-agent-versions.mjs`](../.github/scripts/bump-agent-versions.mjs)）。若改动的是共享运行时 `agents/common`，所有依赖它的模块会一并 bump。
+- **新增驱动**：在 `versions.json` 中新增一行，例如 `"rabbitmq": "0.1.0"`。CI 只 bump 文件里已存在的 key，所以新模块在登记到这里之前对版本管理完全不可见。同一次改动中，还要把模块加进 `settings.gradle` 并更新上方的支持表 —— `versions.json` 的 key 必须与 `settings.gradle` 声明的 agent 模块一致（不含 `common`、`test-support` 这类基础设施模块）。
+
+## 开发
+
+- Agent 编写指南：[docs/agent-authoring.md](docs/agent-authoring.md)
+- JDBC agent 模板：[docs/examples/jdbc-agent-template](docs/examples/jdbc-agent-template)
+- 发布检查清单：[docs/release-checklist.md](docs/release-checklist.md)
+
+## 架构
+
+```
+DBX 主进程 (Rust/Tauri)
+    │ stdin/stdout (JSON-RPC 2.0)
+    ▼
+agent / java -jar dbx-agent-{type}.jar
+    │
+    ▼
+原生驱动 / JDBC → 数据库
+```
+
+## 许可证
+
+[AGPL-3.0](https://github.com/t8y2/dbx/blob/main/LICENSE)
diff --git a/agents/build.gradle b/agents/build.gradle
new file mode 100644
index 0000000..5c9ca37
--- /dev/null
+++ b/agents/build.gradle
@@ -0,0 +1,54 @@
+plugins {
+    id 'com.gradleup.shadow' version '9.0.0-beta12' apply false
+}
+
+def java8Projects = ['common', 'test-support'] as Set
+def infrastructureProjects = ['common', 'test-support'] as Set
+def legacyStandaloneProjects = ['mongodb', 'kafka'] as Set
+def agentProjects = subprojects.findAll { !infrastructureProjects.contains(it.name) }
+def jdbcAgentProjects = agentProjects.findAll { !legacyStandaloneProjects.contains(it.name) }
+
+allprojects {
+    repositories {
+        mavenCentral()
+    }
+}
+
+subprojects {
+    if (name == 'test-support') {
+        apply plugin: 'java-library'
+    } else {
+        apply plugin: 'java'
+    }
+
+    java {
+        toolchain {
+            languageVersion = JavaLanguageVersion.of(java8Projects.contains(name) ? 8 : 21)
+        }
+    }
+
+    dependencies {
+        testImplementation 'org.junit.jupiter:junit-jupiter:5.11.4'
+        testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.11.4'
+    }
+
+    tasks.withType(Test).configureEach {
+        useJUnitPlatform()
+    }
+}
+
+configure(agentProjects) {
+    apply plugin: 'com.gradleup.shadow'
+
+    tasks.named('shadowJar') {
+        archiveBaseName = "dbx-agent-${project.name}"
+        archiveClassifier = ''
+    }
+}
+
+configure(jdbcAgentProjects) {
+    dependencies {
+        implementation project(':common')
+        testImplementation project(':test-support')
+    }
+}
diff --git a/agents/common/build.gradle b/agents/common/build.gradle
new file mode 100644
index 0000000..ee0d25b
--- /dev/null
+++ b/agents/common/build.gradle
@@ -0,0 +1,3 @@
+dependencies {
+    implementation 'com.google.code.gson:gson:2.12.1'
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.java b/agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.java
new file mode 100644
index 0000000..190db0d
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/AbstractJdbcAgent.java
@@ -0,0 +1,240 @@
+package com.dbx.agent;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Paths;
+import java.sql.Connection;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class AbstractJdbcAgent extends BaseDatabaseAgent {
+    private Connection connection;
+    private String configuredDatabase = "";
+
+    @Override
+    public final Connection getConnection() {
+        return connection;
+    }
+
+    @Override
+    public final void connect(ConnectParams params) {
+        uncheckedVoid(() -> {
+            loadDriver(params);
+            connection = openConnection(params);
+            configuredDatabase = params.getDatabase();
+            afterConnect(params, connection);
+        });
+    }
+
+    @Override
+    public final boolean testConnection(ConnectParams params) {
+        return unchecked(() -> {
+            loadDriver(params);
+            try (Connection conn = openConnection(params)) {
+                return conn.isValid(5);
+            }
+        });
+    }
+
+    private void loadDriver(ConnectParams params) throws Exception {
+        List<String> driverPaths = params.getJdbc_driver_paths();
+        String driverClass = params.getJdbc_driver_class();
+        if (driverClass == null || driverClass.isEmpty()) {
+            driverClass = driverClass();
+        }
+        if (driverPaths != null && !driverPaths.isEmpty()) {
+            List<URL> urls = new ArrayList<>();
+            for (String path : driverPaths) {
+                urls.add(Paths.get(path).toUri().toURL());
+            }
+            URLClassLoader loader = new URLClassLoader(urls.toArray(new URL[0]), getClass().getClassLoader());
+            Driver driver = (Driver) Class.forName(driverClass, true, loader).getDeclaredConstructor().newInstance();
+            DriverManager.registerDriver(new DriverShim(driver));
+        } else {
+            Class.forName(driverClass);
+        }
+    }
+
+    private static final class DriverShim implements Driver {
+        private final Driver driver;
+
+        DriverShim(Driver driver) {
+            this.driver = driver;
+        }
+
+        @Override
+        public Connection connect(String url, java.util.Properties info) throws java.sql.SQLException {
+            return driver.connect(url, info);
+        }
+
+        @Override
+        public boolean acceptsURL(String url) throws java.sql.SQLException {
+            return driver.acceptsURL(url);
+        }
+
+        @Override
+        public java.sql.DriverPropertyInfo[] getPropertyInfo(String url, java.util.Properties info) throws java.sql.SQLException {
+            return driver.getPropertyInfo(url, info);
+        }
+
+        @Override
+        public int getMajorVersion() {
+            return driver.getMajorVersion();
+        }
+
+        @Override
+        public int getMinorVersion() {
+            return driver.getMinorVersion();
+        }
+
+        @Override
+        public boolean jdbcCompliant() {
+            return driver.jdbcCompliant();
+        }
+
+        @Override
+        public java.util.logging.Logger getParentLogger() throws java.sql.SQLFeatureNotSupportedException {
+            return driver.getParentLogger();
+        }
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        Connection conn = requireConnected();
+        uncheckedVoid(() -> beforeQueryExecution(conn, options.getTimeoutSecs()));
+        return JdbcExecutor.INSTANCE.execute(
+            conn,
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options.getMaxRows(),
+            options.getFetchSize(),
+            options.getTimeoutSecs(),
+            resultValueReader()
+        );
+    }
+
+    @Override
+    public QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {
+        Connection conn = requireConnected();
+        uncheckedVoid(() -> beforeQueryExecution(conn, options.getTimeoutSecs()));
+        return JdbcExecutor.INSTANCE.executePage(
+            conn,
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            resultValueReader()
+        );
+    }
+
+    @Override
+    public QueryPageResult fetchQueryPage(String sessionId, int pageSize) {
+        return JdbcExecutor.INSTANCE.fetchPage(sessionId, pageSize);
+    }
+
+    @Override
+    public boolean closeQuerySession(String sessionId) {
+        return JdbcExecutor.INSTANCE.closeQuerySession(sessionId);
+    }
+
+    @Override
+    public QueryPageResult startTableRead(String sql, String schema, QueryPageOptions options) {
+        Connection conn = requireConnected();
+        uncheckedVoid(() -> beforeQueryExecution(conn, options.getTimeoutSecs()));
+        return JdbcExecutor.INSTANCE.startTableRead(
+            conn,
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            resultValueReader()
+        );
+    }
+
+    @Override
+    public QueryPageResult fetchTableReadPage(String sessionId, int pageSize) {
+        return JdbcExecutor.INSTANCE.fetchTableReadPage(sessionId, pageSize);
+    }
+
+    @Override
+    public boolean closeTableReadSession(String sessionId) {
+        return JdbcExecutor.INSTANCE.closeTableReadSession(sessionId);
+    }
+
+    @Override
+    public QueryResult executeTransaction(List<String> statements, String schema) {
+        return TransactionExecutor.executeUpdateStatements(requireConnected(), statements, schema, this::setSchemaSQL);
+    }
+
+    @Override
+    public void disconnect() {
+        uncheckedVoid(() -> {
+            if (connection != null) {
+                connection.close();
+            }
+            connection = null;
+        });
+    }
+
+    protected abstract String driverClass();
+
+    protected abstract String buildJdbcUrl(ConnectParams params);
+
+    protected Connection openConnection(ConnectParams params) throws Exception {
+        return DriverManager.getConnection(buildJdbcUrl(params), params.getUsername(), params.getPassword());
+    }
+
+    protected void afterConnect(ConnectParams params, Connection connection) throws Exception {
+    }
+
+    protected void beforeQueryExecution(Connection connection, int timeoutSecs) throws Exception {
+    }
+
+    protected String getConfiguredDatabase() {
+        return configuredDatabase;
+    }
+
+    protected Object resultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value;
+            switch (sqlType) {
+                case Types.BIGINT:
+                    value = rs.getLong(index);
+                    break;
+                case Types.INTEGER:
+                case Types.SMALLINT:
+                case Types.TINYINT:
+                    value = rs.getInt(index);
+                    break;
+                case Types.FLOAT:
+                case Types.REAL:
+                    value = rs.getFloat(index);
+                    break;
+                case Types.DOUBLE:
+                    value = rs.getDouble(index);
+                    break;
+                case Types.DECIMAL:
+                case Types.NUMERIC:
+                    value = rs.getBigDecimal(index);
+                    break;
+                case Types.BOOLEAN:
+                case Types.BIT:
+                    value = rs.getBoolean(index);
+                    break;
+                default:
+                    value = rs.getString(index);
+                    break;
+            }
+            return rs.wasNull() ? null : value;
+        });
+    }
+
+    protected JdbcExecutor.ResultValueReader resultValueReader() {
+        return this::resultValue;
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/AgentProtocol.java b/agents/common/src/main/java/com/dbx/agent/AgentProtocol.java
new file mode 100644
index 0000000..2dc6724
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/AgentProtocol.java
@@ -0,0 +1,163 @@
+package com.dbx.agent;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public final class AgentProtocol {
+    public static final int PROTOCOL_VERSION = 1;
+
+    public static final String METHOD_HANDSHAKE = "handshake";
+    public static final String METHOD_CONNECT = "connect";
+    public static final String METHOD_TEST_CONNECTION = "test_connection";
+    public static final String METHOD_VALIDATE_CONNECTION = "validate_connection";
+    public static final String METHOD_LIST_DATABASES = "list_databases";
+    public static final String METHOD_LIST_SCHEMAS = "list_schemas";
+    public static final String METHOD_LIST_TABLES = "list_tables";
+    public static final String METHOD_LIST_OBJECTS = "list_objects";
+    public static final String METHOD_LIST_DATA_TYPES = "list_data_types";
+    public static final String METHOD_COMPLETION_ASSISTANT_SEARCH_V1 = "completion_assistant_search_v1";
+    public static final String METHOD_GET_OBJECT_SOURCE = "get_object_source";
+    public static final String METHOD_GET_TABLE_DDL = "get_table_ddl";
+    public static final String METHOD_GET_COLUMNS = "get_columns";
+    public static final String METHOD_LIST_INDEXES = "list_indexes";
+    public static final String METHOD_LIST_FOREIGN_KEYS = "list_foreign_keys";
+    public static final String METHOD_LIST_TRIGGERS = "list_triggers";
+    public static final String METHOD_EXECUTE_QUERY = "execute_query";
+    public static final String METHOD_EXECUTE_QUERY_PAGE = "execute_query_page";
+    public static final String METHOD_FETCH_QUERY_PAGE = "fetch_query_page";
+    public static final String METHOD_CLOSE_QUERY_SESSION = "close_query_session";
+    public static final String METHOD_START_TABLE_READ = "start_table_read";
+    public static final String METHOD_FETCH_TABLE_READ_PAGE = "fetch_table_read_page";
+    public static final String METHOD_CLOSE_TABLE_READ_SESSION = "close_table_read_session";
+    public static final String METHOD_GET_EXPLAIN_INFO = "get_explain_info";
+    public static final String METHOD_EXECUTE_BATCH = "execute_batch";
+    public static final String METHOD_EXECUTE_TRANSACTION = "execute_transaction";
+    public static final String METHOD_DISCONNECT = "disconnect";
+    public static final String METHOD_SHUTDOWN = "shutdown";
+
+    public static final String MONGO_METHOD_LIST_DATABASES = "list_databases";
+    public static final String MONGO_METHOD_LIST_COLLECTIONS = "list_collections";
+    public static final String MONGO_METHOD_FIND_DOCUMENTS = "find_documents";
+    /**
+     * MongoDB read path that returns documents as relaxed Extended JSON for transfer.
+     */
+    public static final String MONGO_METHOD_FIND_DOCUMENTS_EXTENDED_JSON = "find_documents_extended_json";
+    public static final String MONGO_METHOD_SERVER_VERSION = "server_version";
+    public static final String MONGO_METHOD_CREATE_INDEX = "create_index";
+    public static final String MONGO_METHOD_DROP_INDEXES = "drop_indexes";
+    public static final String MONGO_METHOD_DROP_COLLECTION = "drop_collection";
+    public static final String MONGO_METHOD_INSERT_DOCUMENT = "insert_document";
+    public static final String MONGO_METHOD_UPDATE_DOCUMENT = "update_document";
+    public static final String MONGO_METHOD_UPDATE_DOCUMENTS = "update_documents";
+    public static final String MONGO_METHOD_DELETE_DOCUMENT = "delete_document";
+    public static final String MONGO_METHOD_DELETE_DOCUMENTS = "delete_documents";
+
+    public static final String KV_METHOD_LIST_PREFIX = "kv_list_prefix";
+    public static final String KV_METHOD_GET = "kv_get";
+    public static final String KV_METHOD_PUT = "kv_put";
+    public static final String KV_METHOD_DELETE = "kv_delete";
+
+    public static final String CAPABILITY_CONNECT = "connect";
+    public static final String CAPABILITY_TEST_CONNECTION = "test_connection";
+    public static final String CAPABILITY_METADATA = "metadata";
+    public static final String CAPABILITY_QUERY = "query";
+    public static final String CAPABILITY_PAGED_QUERY = "paged_query";
+    public static final String CAPABILITY_TRANSACTION = "transaction";
+    public static final String CAPABILITY_DDL = "ddl";
+    public static final String CAPABILITY_KV = "kv";
+
+    public static final List<String> CAPABILITIES = Collections.unmodifiableList(Arrays.asList(
+        CAPABILITY_CONNECT,
+        CAPABILITY_TEST_CONNECTION,
+        CAPABILITY_METADATA,
+        CAPABILITY_QUERY,
+        CAPABILITY_PAGED_QUERY,
+        CAPABILITY_TRANSACTION,
+        CAPABILITY_DDL
+    ));
+
+    public static final List<String> ALL_CAPABILITIES = Collections.unmodifiableList(Arrays.asList(
+        CAPABILITY_CONNECT,
+        CAPABILITY_TEST_CONNECTION,
+        CAPABILITY_METADATA,
+        CAPABILITY_QUERY,
+        CAPABILITY_PAGED_QUERY,
+        CAPABILITY_TRANSACTION,
+        CAPABILITY_DDL,
+        CAPABILITY_KV
+    ));
+
+    public static final List<String> COMMON_METHODS = Collections.unmodifiableList(Arrays.asList(
+        METHOD_HANDSHAKE,
+        METHOD_CONNECT,
+        METHOD_TEST_CONNECTION,
+        METHOD_VALIDATE_CONNECTION,
+        METHOD_LIST_DATABASES,
+        METHOD_LIST_SCHEMAS,
+        METHOD_LIST_TABLES,
+        METHOD_LIST_OBJECTS,
+        METHOD_LIST_DATA_TYPES,
+        METHOD_COMPLETION_ASSISTANT_SEARCH_V1,
+        METHOD_GET_OBJECT_SOURCE,
+        METHOD_GET_TABLE_DDL,
+        METHOD_GET_COLUMNS,
+        METHOD_LIST_INDEXES,
+        METHOD_LIST_FOREIGN_KEYS,
+        METHOD_LIST_TRIGGERS,
+        METHOD_EXECUTE_QUERY,
+        METHOD_EXECUTE_QUERY_PAGE,
+        METHOD_FETCH_QUERY_PAGE,
+        METHOD_CLOSE_QUERY_SESSION,
+        METHOD_START_TABLE_READ,
+        METHOD_FETCH_TABLE_READ_PAGE,
+        METHOD_CLOSE_TABLE_READ_SESSION,
+        METHOD_GET_EXPLAIN_INFO,
+        METHOD_EXECUTE_BATCH,
+        METHOD_EXECUTE_TRANSACTION,
+        METHOD_DISCONNECT,
+        METHOD_SHUTDOWN
+    ));
+
+    public static final List<String> MONGO_LEGACY_METHODS = Collections.unmodifiableList(Arrays.asList(
+        MONGO_METHOD_LIST_DATABASES,
+        MONGO_METHOD_LIST_COLLECTIONS,
+        MONGO_METHOD_FIND_DOCUMENTS,
+        MONGO_METHOD_FIND_DOCUMENTS_EXTENDED_JSON,
+        MONGO_METHOD_SERVER_VERSION,
+        MONGO_METHOD_CREATE_INDEX,
+        MONGO_METHOD_DROP_INDEXES,
+        MONGO_METHOD_DROP_COLLECTION,
+        MONGO_METHOD_INSERT_DOCUMENT,
+        MONGO_METHOD_UPDATE_DOCUMENT,
+        MONGO_METHOD_UPDATE_DOCUMENTS,
+        MONGO_METHOD_DELETE_DOCUMENT,
+        MONGO_METHOD_DELETE_DOCUMENTS
+    ));
+
+    public static final List<String> KV_METHODS = Collections.unmodifiableList(Arrays.asList(
+        KV_METHOD_LIST_PREFIX,
+        KV_METHOD_GET,
+        KV_METHOD_PUT,
+        KV_METHOD_DELETE
+    ));
+
+    private AgentProtocol() {
+    }
+
+    public static HandshakeResult handshakeResult() {
+        return new HandshakeResult(PROTOCOL_VERSION, PROTOCOL_VERSION, CAPABILITIES);
+    }
+
+    public static final class HandshakeResult {
+        private final int protocolVersion;
+        private final int agentProtocolVersion;
+        private final List<String> capabilities;
+
+        private HandshakeResult(int protocolVersion, int agentProtocolVersion, List<String> capabilities) {
+            this.protocolVersion = protocolVersion;
+            this.agentProtocolVersion = agentProtocolVersion;
+            this.capabilities = capabilities;
+        }
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/BaseDatabaseAgent.java b/agents/common/src/main/java/com/dbx/agent/BaseDatabaseAgent.java
new file mode 100644
index 0000000..13b3531
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/BaseDatabaseAgent.java
@@ -0,0 +1,134 @@
+package com.dbx.agent;
+
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public abstract class BaseDatabaseAgent implements DatabaseAgent {
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        List<ObjectInfo> result = new ArrayList<>();
+        for (TableInfo table : listTables(schema)) {
+            result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+        }
+        return result;
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        throw new UnsupportedOperationException("Object source is not supported");
+    }
+
+    @Override
+    public CompletionAssistantResponse completionAssistantSearch(CompletionAssistantRequest request) {
+        throw new UnsupportedOperationException("Completion assistant search is not supported by this agent");
+    }
+
+    @Override
+    public String getTableDdl(String schema, String table) {
+        List<IndexInfo> indexes;
+        try {
+            indexes = listIndexes(schema, table);
+        } catch (RuntimeException e) {
+            indexes = Collections.emptyList();
+        }
+
+        List<ForeignKeyInfo> foreignKeys;
+        try {
+            foreignKeys = listForeignKeys(schema, table);
+        } catch (RuntimeException e) {
+            foreignKeys = Collections.emptyList();
+        }
+
+        return DatabaseAgent.buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys);
+    }
+
+    @Override
+    public QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {
+        Connection conn = requireConnected();
+        return JdbcExecutor.INSTANCE.executePage(
+            conn,
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            JdbcExecutor.INSTANCE::defaultResultValue
+        );
+    }
+
+    @Override
+    public QueryPageResult fetchQueryPage(String sessionId, int pageSize) {
+        return JdbcExecutor.INSTANCE.fetchPage(sessionId, pageSize);
+    }
+
+    @Override
+    public boolean closeQuerySession(String sessionId) {
+        return JdbcExecutor.INSTANCE.closeQuerySession(sessionId);
+    }
+
+    @Override
+    public QueryPageResult startTableRead(String sql, String schema, QueryPageOptions options) {
+        return JdbcExecutor.INSTANCE.startTableRead(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            JdbcExecutor.INSTANCE::defaultResultValue
+        );
+    }
+
+    @Override
+    public QueryPageResult fetchTableReadPage(String sessionId, int pageSize) {
+        return JdbcExecutor.INSTANCE.fetchTableReadPage(sessionId, pageSize);
+    }
+
+    @Override
+    public boolean closeTableReadSession(String sessionId) {
+        return JdbcExecutor.INSTANCE.closeTableReadSession(sessionId);
+    }
+
+    @Override
+    public QueryResult executeTransaction(List<String> statements, String schema) {
+        return TransactionExecutor.executeUpdateStatements(requireConnected(), statements, schema, this::setSchemaSQL);
+    }
+
+    @Override
+    public QueryResult executeBatch(List<String> statements, String schema) {
+        return BatchExecutor.executeBatchStatements(requireConnected(), statements, schema, this::setSchemaSQL);
+    }
+
+    protected Connection requireConnected() {
+        Connection conn = getConnection();
+        if (conn == null) {
+            throw new IllegalStateException("Not connected");
+        }
+        return conn;
+    }
+
+    protected static <T> T unchecked(ThrowingSupplier<T> supplier) {
+        try {
+            return supplier.get();
+        } catch (RuntimeException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    protected static void uncheckedVoid(ThrowingRunnable runnable) {
+        unchecked(() -> {
+            runnable.run();
+            return null;
+        });
+    }
+
+    protected interface ThrowingSupplier<T> {
+        T get() throws Exception;
+    }
+
+    protected interface ThrowingRunnable {
+        void run() throws Exception;
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/BatchExecutor.java b/agents/common/src/main/java/com/dbx/agent/BatchExecutor.java
new file mode 100644
index 0000000..134ada0
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/BatchExecutor.java
@@ -0,0 +1,98 @@
+package com.dbx.agent;
+
+import java.sql.BatchUpdateException;
+import java.sql.Connection;
+import java.sql.SQLFeatureNotSupportedException;
+import java.sql.Statement;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+
+public final class BatchExecutor {
+    private BatchExecutor() {
+    }
+
+    public static QueryResult executeBatchStatements(
+        Connection conn,
+        List<String> statements,
+        String schema,
+        Function<String, String> setSchemaSql
+    ) {
+        return unchecked(() -> {
+            long start = System.currentTimeMillis();
+            applySchema(conn, schema, setSchemaSql);
+            long totalAffected = 0;
+            int statementCount = 0;
+            try (Statement stmt = conn.createStatement()) {
+                for (String statement : statements) {
+                    String trimmed = JdbcExecutor.trimSql(statement);
+                    if (trimmed.isEmpty()) {
+                        continue;
+                    }
+                    stmt.addBatch(trimmed);
+                    statementCount++;
+                }
+                if (statementCount > 0) {
+                    totalAffected = affectedRows(executeBatch(stmt));
+                }
+            } catch (BatchUpdateException e) {
+                long[] counts = e.getLargeUpdateCounts();
+                int failedIndex = counts == null ? 1 : counts.length + 1;
+                throw new RuntimeException("Statement " + failedIndex + " failed: " + e.getMessage(), e);
+            }
+            return new QueryResult(
+                Collections.emptyList(),
+                Collections.emptyList(),
+                totalAffected,
+                System.currentTimeMillis() - start,
+                false
+            );
+        });
+    }
+
+    private static long affectedRows(long[] updateCounts) {
+        long total = 0;
+        if (updateCounts == null) {
+            return total;
+        }
+        for (long count : updateCounts) {
+            if (count >= 0) {
+                total += count;
+            } else if (count == Statement.SUCCESS_NO_INFO) {
+                total += 1;
+            }
+        }
+        return total;
+    }
+
+    private static long[] executeBatch(Statement stmt) throws Exception {
+        try {
+            return stmt.executeLargeBatch();
+        } catch (SQLFeatureNotSupportedException | UnsupportedOperationException | AbstractMethodError e) {
+            int[] counts = stmt.executeBatch();
+            long[] largeCounts = new long[counts.length];
+            for (int i = 0; i < counts.length; i++) {
+                largeCounts[i] = counts[i];
+            }
+            return largeCounts;
+        }
+    }
+
+    private static void applySchema(Connection conn, String schema, Function<String, String> setSchemaSql) throws Exception {
+        JdbcSchemaSwitcher.apply(conn, schema, setSchemaSql);
+    }
+
+    private static <T> T unchecked(ThrowingSupplier<T> supplier) {
+        try {
+            return supplier.get();
+        } catch (RuntimeException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private interface ThrowingSupplier<T> {
+        T get() throws Exception;
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/CheckConstraintInfo.java b/agents/common/src/main/java/com/dbx/agent/CheckConstraintInfo.java
new file mode 100644
index 0000000..a38d7f6
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/CheckConstraintInfo.java
@@ -0,0 +1,19 @@
+package com.dbx.agent;
+
+public final class CheckConstraintInfo {
+    private final String name;
+    private final String definition;
+
+    public CheckConstraintInfo(String name, String definition) {
+        this.name = name;
+        this.definition = definition;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getDefinition() {
+        return definition;
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/ColumnInfo.java b/agents/common/src/main/java/com/dbx/agent/ColumnInfo.java
new file mode 100644
index 0000000..d65df3b
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/ColumnInfo.java
@@ -0,0 +1,176 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class ColumnInfo {
+    private String name;
+    private String data_type;
+    private boolean is_nullable;
+    private String column_default;
+    private boolean is_primary_key;
+    private String extra;
+    private String comment;
+    private Integer numeric_precision;
+    private Integer numeric_scale;
+    private Integer character_maximum_length;
+
+    public ColumnInfo() {
+        this("", "", true, null, false);
+    }
+
+    public ColumnInfo(String name, String data_type, boolean is_nullable, String column_default, boolean is_primary_key) {
+        this(name, data_type, is_nullable, column_default, is_primary_key, null, null, null, null, null);
+    }
+
+    public ColumnInfo(
+        String name,
+        String data_type,
+        boolean is_nullable,
+        String column_default,
+        boolean is_primary_key,
+        String extra,
+        String comment,
+        Integer numeric_precision,
+        Integer numeric_scale,
+        Integer character_maximum_length
+    ) {
+        this.name = name;
+        this.data_type = data_type;
+        this.is_nullable = is_nullable;
+        this.column_default = column_default;
+        this.is_primary_key = is_primary_key;
+        this.extra = extra;
+        this.comment = comment;
+        this.numeric_precision = numeric_precision;
+        this.numeric_scale = numeric_scale;
+        this.character_maximum_length = character_maximum_length;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getData_type() {
+        return data_type;
+    }
+
+    public boolean getIs_nullable() {
+        return is_nullable;
+    }
+
+    public String getColumn_default() {
+        return column_default;
+    }
+
+    public boolean getIs_primary_key() {
+        return is_primary_key;
+    }
+
+    public String getExtra() {
+        return extra;
+    }
+
+    public String getComment() {
+        return comment;
+    }
+
+    public Integer getNumeric_precision() {
+        return numeric_precision;
+    }
+
+    public Integer getNumeric_scale() {
+        return numeric_scale;
+    }
+
+    public Integer getCharacter_maximum_length() {
+        return character_maximum_length;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setData_type(String data_type) {
+        this.data_type = data_type;
+    }
+
+    public void setIs_nullable(boolean is_nullable) {
+        this.is_nullable = is_nullable;
+    }
+
+    public void setColumn_default(String column_default) {
+        this.column_default = column_default;
+    }
+
+    public void setIs_primary_key(boolean is_primary_key) {
+        this.is_primary_key = is_primary_key;
+    }
+
+    public void setExtra(String extra) {
+        this.extra = extra;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
+    public void setNumeric_precision(Integer numeric_precision) {
+        this.numeric_precision = numeric_precision;
+    }
+
+    public void setNumeric_scale(Integer numeric_scale) {
+        this.numeric_scale = numeric_scale;
+    }
+
+    public void setCharacter_maximum_length(Integer character_maximum_length) {
+        this.character_maximum_length = character_maximum_length;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof ColumnInfo)) return false;
+        ColumnInfo that = (ColumnInfo) other;
+        return is_nullable == that.is_nullable
+            && is_primary_key == that.is_primary_key
+            && Objects.equals(name, that.name)
+            && Objects.equals(data_type, that.data_type)
+            && Objects.equals(column_default, that.column_default)
+            && Objects.equals(extra, that.extra)
+            && Objects.equals(comment, that.comment)
+            && Objects.equals(numeric_precision, that.numeric_precision)
+            && Objects.equals(numeric_scale, that.numeric_scale)
+            && Objects.equals(character_maximum_length, that.character_maximum_length);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(
+            name,
+            data_type,
+            is_nullable,
+            column_default,
+            is_primary_key,
+            extra,
+            comment,
+            numeric_precision,
+            numeric_scale,
+            character_maximum_length
+        );
+    }
+
+    @Override
+    public String toString() {
+        return "ColumnInfo(name=" + name
+            + ", data_type=" + data_type
+            + ", is_nullable=" + is_nullable
+            + ", column_default=" + column_default
+            + ", is_primary_key=" + is_primary_key
+            + ", extra=" + extra
+            + ", comment=" + comment
+            + ", numeric_precision=" + numeric_precision
+            + ", numeric_scale=" + numeric_scale
+            + ", character_maximum_length=" + character_maximum_length
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/CompletionAssistantCandidate.java b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantCandidate.java
new file mode 100644
index 0000000..d541a49
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantCandidate.java
@@ -0,0 +1,41 @@
+package com.dbx.agent;
+
+public final class CompletionAssistantCandidate {
+    private final String name;
+    private final CompletionAssistantCandidateKind kind;
+    private final String database;
+    private final String schema;
+    private final String parent_schema;
+    private final String parent_name;
+    private final String comment;
+    private final String data_type;
+
+    public CompletionAssistantCandidate(
+        String name,
+        CompletionAssistantCandidateKind kind,
+        String database,
+        String schema,
+        String parentSchema,
+        String parentName,
+        String comment,
+        String dataType
+    ) {
+        this.name = name;
+        this.kind = kind;
+        this.database = database;
+        this.schema = schema;
+        this.parent_schema = parentSchema;
+        this.parent_name = parentName;
+        this.comment = comment;
+        this.data_type = dataType;
+    }
+
+    public String getName() { return name; }
+    public CompletionAssistantCandidateKind getKind() { return kind; }
+    public String getDatabase() { return database; }
+    public String getSchema() { return schema; }
+    public String getParent_schema() { return parent_schema; }
+    public String getParent_name() { return parent_name; }
+    public String getComment() { return comment; }
+    public String getData_type() { return data_type; }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/CompletionAssistantCandidateKind.java b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantCandidateKind.java
new file mode 100644
index 0000000..9e2a02d
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantCandidateKind.java
@@ -0,0 +1,22 @@
+package com.dbx.agent;
+
+import com.google.gson.annotations.SerializedName;
+
+public enum CompletionAssistantCandidateKind {
+    @SerializedName("database")
+    DATABASE,
+    @SerializedName("schema")
+    SCHEMA,
+    @SerializedName("table")
+    TABLE,
+    @SerializedName("view")
+    VIEW,
+    @SerializedName("procedure")
+    PROCEDURE,
+    @SerializedName("function")
+    FUNCTION,
+    @SerializedName("column")
+    COLUMN,
+    @SerializedName("object")
+    OBJECT
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/CompletionAssistantMatchMode.java b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantMatchMode.java
new file mode 100644
index 0000000..6f44850
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantMatchMode.java
@@ -0,0 +1,10 @@
+package com.dbx.agent;
+
+import com.google.gson.annotations.SerializedName;
+
+public enum CompletionAssistantMatchMode {
+    @SerializedName("prefix")
+    PREFIX,
+    @SerializedName("contains")
+    CONTAINS
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/CompletionAssistantObjectKind.java b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantObjectKind.java
new file mode 100644
index 0000000..ec7bbd3
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantObjectKind.java
@@ -0,0 +1,22 @@
+package com.dbx.agent;
+
+import com.google.gson.annotations.SerializedName;
+
+public enum CompletionAssistantObjectKind {
+    @SerializedName("database")
+    DATABASE,
+    @SerializedName("schema")
+    SCHEMA,
+    @SerializedName("table")
+    TABLE,
+    @SerializedName("view")
+    VIEW,
+    @SerializedName("routine")
+    ROUTINE,
+    @SerializedName("procedure")
+    PROCEDURE,
+    @SerializedName("function")
+    FUNCTION,
+    @SerializedName("column")
+    COLUMN
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/CompletionAssistantRequest.java b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantRequest.java
new file mode 100644
index 0000000..a304f51
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantRequest.java
@@ -0,0 +1,34 @@
+package com.dbx.agent;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class CompletionAssistantRequest {
+    private String connection_id;
+    private String database;
+    private String schema;
+    private List<CompletionAssistantObjectKind> object_kinds = new ArrayList<>();
+    private String mask = "";
+    private boolean case_sensitive;
+    private boolean global_search;
+    private Integer max_results;
+    private boolean search_in_comments;
+    private boolean search_in_definitions;
+    private String parent_schema;
+    private String parent_name;
+    private CompletionAssistantMatchMode match_mode;
+
+    public String getConnection_id() { return connection_id; }
+    public String getDatabase() { return database == null ? "" : database; }
+    public String getSchema() { return schema; }
+    public List<CompletionAssistantObjectKind> getObject_kinds() { return object_kinds == null ? new ArrayList<>() : object_kinds; }
+    public String getMask() { return mask == null ? "" : mask; }
+    public boolean getCase_sensitive() { return case_sensitive; }
+    public boolean getGlobal_search() { return global_search; }
+    public Integer getMax_results() { return max_results; }
+    public boolean getSearch_in_comments() { return search_in_comments; }
+    public boolean getSearch_in_definitions() { return search_in_definitions; }
+    public String getParent_schema() { return parent_schema; }
+    public String getParent_name() { return parent_name; }
+    public CompletionAssistantMatchMode getMatch_mode() { return match_mode; }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/CompletionAssistantResponse.java b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantResponse.java
new file mode 100644
index 0000000..c20c540
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/CompletionAssistantResponse.java
@@ -0,0 +1,19 @@
+package com.dbx.agent;
+
+import java.util.List;
+
+public final class CompletionAssistantResponse {
+    private final List<CompletionAssistantCandidate> candidates;
+    private final boolean incomplete;
+    private final boolean fallback_used;
+
+    public CompletionAssistantResponse(List<CompletionAssistantCandidate> candidates, boolean incomplete, boolean fallbackUsed) {
+        this.candidates = candidates;
+        this.incomplete = incomplete;
+        this.fallback_used = fallbackUsed;
+    }
+
+    public List<CompletionAssistantCandidate> getCandidates() { return candidates; }
+    public boolean getIncomplete() { return incomplete; }
+    public boolean getFallback_used() { return fallback_used; }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/ConfiguredJdbcAgent.java b/agents/common/src/main/java/com/dbx/agent/ConfiguredJdbcAgent.java
new file mode 100644
index 0000000..7d75e41
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/ConfiguredJdbcAgent.java
@@ -0,0 +1,222 @@
+package com.dbx.agent;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+public abstract class ConfiguredJdbcAgent extends AbstractJdbcAgent {
+    private final JdbcAgentProfile profile;
+    private String configuredDatabase = "";
+
+    protected ConfiguredJdbcAgent(JdbcAgentProfile profile) {
+        this.profile = profile;
+    }
+
+    public JdbcAgentProfile getProfile() {
+        return profile;
+    }
+
+    @Override
+    protected String driverClass() {
+        return profile.getDriverClass();
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return profile.buildUrl(params);
+    }
+
+    @Override
+    protected void afterConnect(ConnectParams params, Connection connection) {
+        configuredDatabase = params.getDatabase();
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return StandardJdbcMetadata.INSTANCE.listDatabases(requireConnection(), configuredDatabase);
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return StandardJdbcMetadata.INSTANCE.listSchemas(requireConnection(), profile);
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return StandardJdbcMetadata.INSTANCE.listTables(requireConnection(), profile, configuredDatabase, schema);
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, List<String> objectTypes) {
+        return listTables(schema, new MetadataListConstraints(null, null, null, objectTypes));
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        return StandardJdbcMetadata.INSTANCE.listTables(
+            requireConnection(),
+            profile,
+            configuredDatabase,
+            schema,
+            constraints
+        );
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return StandardJdbcMetadata.INSTANCE.listObjects(
+            requireConnection(),
+            profile,
+            configuredDatabase,
+            schema,
+            MetadataListConstraints.NONE
+        );
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        return StandardJdbcMetadata.INSTANCE.listObjects(
+            requireConnection(),
+            profile,
+            configuredDatabase,
+            schema,
+            constraints
+        );
+    }
+
+    @Override
+    public List<String> listDataTypes() {
+        return StandardJdbcMetadata.INSTANCE.listDataTypes(requireConnection());
+    }
+
+    @Override
+    public CompletionAssistantResponse completionAssistantSearch(CompletionAssistantRequest request) {
+        return StandardJdbcMetadata.INSTANCE.completionAssistantSearch(requireConnection(), profile, configuredDatabase, request);
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        throw new UnsupportedOperationException("Object source is not supported");
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return StandardJdbcMetadata.INSTANCE.getColumns(requireConnection(), profile, configuredDatabase, schema, table);
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return StandardJdbcMetadata.INSTANCE.listIndexes(requireConnection(), schema, table);
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return StandardJdbcMetadata.INSTANCE.listForeignKeys(requireConnection(), schema, table);
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return StandardJdbcMetadata.INSTANCE.listTriggers(schema, table);
+    }
+
+    @Override
+    public String getTableDdl(String schema, String table) {
+        List<IndexInfo> indexes;
+        try {
+            indexes = listIndexes(schema, table);
+        } catch (RuntimeException e) {
+            indexes = Collections.emptyList();
+        }
+
+        List<ForeignKeyInfo> foreignKeys;
+        try {
+            foreignKeys = listForeignKeys(schema, table);
+        } catch (RuntimeException e) {
+            foreignKeys = Collections.emptyList();
+        }
+
+        return DatabaseAgent.buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys);
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        if (profile.getSkipExecutionContext()) {
+            return "";
+        }
+        return StandardJdbcMetadata.schemaSwitchSql(requireConnection(), profile, schema);
+    }
+
+    protected Connection requireConnection() {
+        return requireConnected();
+    }
+
+    @Override
+    protected Object resultValue(ResultSet rs, int index, int sqlType) {
+        return super.resultValue(rs, index, sqlType);
+    }
+
+    private static String normalizeTableType(String type) {
+        if (type == null || type.trim().isEmpty()) {
+            return "TABLE";
+        }
+        if ("BASE TABLE".equals(type.toUpperCase(Locale.ROOT))) {
+            return "TABLE";
+        }
+        return type;
+    }
+
+    private static Integer intOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    private static Integer characterLength(ResultSet rs) throws Exception {
+        String typeName = rs.getString("TYPE_NAME");
+        if (typeName == null) {
+            return null;
+        }
+        String normalized = typeName.toLowerCase(Locale.ROOT);
+        if (!normalized.contains("char") && !normalized.contains("text")) {
+            return null;
+        }
+        return intOrNull(rs, "COLUMN_SIZE");
+    }
+
+    private static String blankToNull(String value) {
+        return value == null || value.trim().isEmpty() ? null : value;
+    }
+
+    private static void addNonBlank(Set<String> values, String value) {
+        if (value != null && !value.trim().isEmpty()) {
+            values.add(value);
+        }
+    }
+
+    private static final class IndexColumn {
+        private final int ordinal;
+        private final String name;
+
+        private IndexColumn(int ordinal, String name) {
+            this.ordinal = ordinal;
+            this.name = name;
+        }
+
+        private int getOrdinal() {
+            return ordinal;
+        }
+
+        private String getName() {
+            return name;
+        }
+    }
+
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/ConnectParams.java b/agents/common/src/main/java/com/dbx/agent/ConnectParams.java
new file mode 100644
index 0000000..3e4639a
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/ConnectParams.java
@@ -0,0 +1,243 @@
+package com.dbx.agent;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public final class ConnectParams {
+    private String host;
+    private int port;
+    private String database;
+    private String username;
+    private String password;
+    private String url_params;
+    private String connection_string;
+    private boolean mysql_compat_mode;
+    private String jdbc_driver_class;
+    private List<String> jdbc_driver_paths;
+    private boolean ssl;
+    private String ca_cert_path;
+    private String client_cert_path;
+    private String client_key_path;
+    private String gbase_server;
+    private String informix_server;
+
+    public ConnectParams() {
+        this("", 0, "", "", "", "", "", false, "", Collections.emptyList());
+    }
+
+    public ConnectParams(
+        String host,
+        int port,
+        String database,
+        String username,
+        String password,
+        String url_params,
+        String connection_string,
+        boolean mysql_compat_mode
+    ) {
+        this(host, port, database, username, password, url_params, connection_string, mysql_compat_mode, "", Collections.emptyList());
+    }
+
+    public ConnectParams(
+        String host,
+        int port,
+        String database,
+        String username,
+        String password,
+        String url_params,
+        String connection_string,
+        boolean mysql_compat_mode,
+        String jdbc_driver_class,
+        List<String> jdbc_driver_paths
+    ) {
+        this.host = host;
+        this.port = port;
+        this.database = database;
+        this.username = username;
+        this.password = password;
+        this.url_params = url_params;
+        this.connection_string = connection_string;
+        this.mysql_compat_mode = mysql_compat_mode;
+        this.jdbc_driver_class = jdbc_driver_class;
+        this.jdbc_driver_paths = jdbc_driver_paths;
+    }
+
+    public String getHost() {
+        return host;
+    }
+
+    public int getPort() {
+        return port;
+    }
+
+    public String getDatabase() {
+        return database;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public String getUrl_params() {
+        return url_params;
+    }
+
+    public String getConnection_string() {
+        return connection_string;
+    }
+
+    public void setHost(String host) {
+        this.host = host;
+    }
+
+    public void setPort(int port) {
+        this.port = port;
+    }
+
+    public void setDatabase(String database) {
+        this.database = database;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public void setUrl_params(String url_params) {
+        this.url_params = url_params;
+    }
+
+    public void setConnection_string(String connection_string) {
+        this.connection_string = connection_string;
+    }
+
+    public boolean isMysql_compat_mode() {
+        return mysql_compat_mode;
+    }
+
+    public void setMysql_compat_mode(boolean mysql_compat_mode) {
+        this.mysql_compat_mode = mysql_compat_mode;
+    }
+
+    public String getJdbc_driver_class() {
+        return jdbc_driver_class;
+    }
+
+    public void setJdbc_driver_class(String jdbc_driver_class) {
+        this.jdbc_driver_class = jdbc_driver_class;
+    }
+
+    public List<String> getJdbc_driver_paths() {
+        return jdbc_driver_paths;
+    }
+
+    public void setJdbc_driver_paths(List<String> jdbc_driver_paths) {
+        this.jdbc_driver_paths = jdbc_driver_paths;
+    }
+
+    public boolean isSsl() {
+        return ssl;
+    }
+
+    public void setSsl(boolean ssl) {
+        this.ssl = ssl;
+    }
+
+    public String getCa_cert_path() {
+        return ca_cert_path;
+    }
+
+    public void setCa_cert_path(String ca_cert_path) {
+        this.ca_cert_path = ca_cert_path;
+    }
+
+    public String getClient_cert_path() {
+        return client_cert_path;
+    }
+
+    public void setClient_cert_path(String client_cert_path) {
+        this.client_cert_path = client_cert_path;
+    }
+
+    public String getClient_key_path() {
+        return client_key_path;
+    }
+
+    public void setClient_key_path(String client_key_path) {
+        this.client_key_path = client_key_path;
+    }
+
+    public String getGbase_server() {
+        return gbase_server;
+    }
+
+    public void setGbase_server(String gbase_server) {
+        this.gbase_server = gbase_server;
+    }
+
+    public String getInformix_server() {
+        return informix_server;
+    }
+
+    public void setInformix_server(String informix_server) {
+        this.informix_server = informix_server;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof ConnectParams)) return false;
+        ConnectParams that = (ConnectParams) other;
+        return port == that.port
+            && Objects.equals(host, that.host)
+            && Objects.equals(database, that.database)
+            && Objects.equals(username, that.username)
+            && Objects.equals(password, that.password)
+            && Objects.equals(url_params, that.url_params)
+            && Objects.equals(connection_string, that.connection_string)
+            && mysql_compat_mode == that.mysql_compat_mode
+            && Objects.equals(jdbc_driver_class, that.jdbc_driver_class)
+            && Objects.equals(jdbc_driver_paths, that.jdbc_driver_paths)
+            && ssl == that.ssl
+            && Objects.equals(ca_cert_path, that.ca_cert_path)
+            && Objects.equals(client_cert_path, that.client_cert_path)
+            && Objects.equals(client_key_path, that.client_key_path)
+            && Objects.equals(gbase_server, that.gbase_server)
+            && Objects.equals(informix_server, that.informix_server);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(host, port, database, username, password, url_params, connection_string,
+            mysql_compat_mode, jdbc_driver_class, jdbc_driver_paths, ssl, ca_cert_path, client_cert_path, client_key_path, gbase_server, informix_server);
+    }
+
+    @Override
+    public String toString() {
+        return "ConnectParams(host=" + host
+            + ", port=" + port
+            + ", database=" + database
+            + ", username=" + username
+            + ", password=" + password
+            + ", url_params=" + url_params
+            + ", connection_string=" + connection_string
+            + ", mysql_compat_mode=" + mysql_compat_mode
+            + ", jdbc_driver_class=" + jdbc_driver_class
+            + ", jdbc_driver_paths=" + jdbc_driver_paths
+            + ", ssl=" + ssl
+            + ", ca_cert_path=" + ca_cert_path
+            + ", client_cert_path=" + client_cert_path
+            + ", client_key_path=" + client_key_path
+            + ", gbase_server=" + gbase_server
+            + ", informix_server=" + informix_server
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/DatabaseAgent.java b/agents/common/src/main/java/com/dbx/agent/DatabaseAgent.java
new file mode 100644
index 0000000..5e1b9a8
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/DatabaseAgent.java
@@ -0,0 +1,211 @@
+package com.dbx.agent;
+
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public interface DatabaseAgent {
+    void connect(ConnectParams params);
+
+    boolean testConnection(ConnectParams params);
+
+    List<DatabaseInfo> listDatabases();
+
+    List<String> listSchemas();
+
+    default List<String> listSchemas(List<String> visibleSchemas) {
+        if (visibleSchemas == null) {
+            return listSchemas();
+        }
+        Set<String> visible = new HashSet<>(visibleSchemas);
+        return listSchemas().stream().filter(visible::contains).collect(Collectors.toList());
+    }
+
+    List<TableInfo> listTables(String schema);
+
+    default List<TableInfo> listTables(String schema, List<String> objectTypes) {
+        return listTables(schema);
+    }
+
+    default List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        // Keep old driver overrides for object type filtering, then apply the new optional constraints locally.
+        return normalized.filterTables(listTables(schema, normalized.getObjectTypes()));
+    }
+
+    default List<ObjectInfo> listObjects(String schema) {
+        List<ObjectInfo> result = new ArrayList<>();
+        for (TableInfo table : listTables(schema)) {
+            result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+        }
+        return result;
+    }
+
+    default List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        return MetadataListConstraints.orNone(constraints).filterObjects(listObjects(schema));
+    }
+
+    default List<String> listDataTypes() {
+        return Collections.emptyList();
+    }
+
+    default CompletionAssistantResponse completionAssistantSearch(CompletionAssistantRequest request) {
+        throw new UnsupportedOperationException("Completion assistant search is not supported by this agent");
+    }
+
+    List<ColumnInfo> getColumns(String schema, String table);
+
+    default ObjectSource getObjectSource(String schema, String name, String objectType) {
+        throw new UnsupportedOperationException("Object source is not supported");
+    }
+
+    default String getTableDdl(String schema, String table) {
+        List<IndexInfo> indexes;
+        try {
+            indexes = listIndexes(schema, table);
+        } catch (RuntimeException e) {
+            indexes = Collections.emptyList();
+        }
+
+        List<ForeignKeyInfo> foreignKeys;
+        try {
+            foreignKeys = listForeignKeys(schema, table);
+        } catch (RuntimeException e) {
+            foreignKeys = Collections.emptyList();
+        }
+
+        return buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys);
+    }
+
+    List<IndexInfo> listIndexes(String schema, String table);
+
+    List<ForeignKeyInfo> listForeignKeys(String schema, String table);
+
+    List<TriggerInfo> listTriggers(String schema, String table);
+
+    default QueryResult executeQuery(String sql, String schema) {
+        return executeQuery(sql, schema, new ExecuteQueryOptions());
+    }
+
+    QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options);
+
+    default QueryPageResult executeQueryPage(String sql, String schema) {
+        return executeQueryPage(sql, schema, new QueryPageOptions());
+    }
+
+    default QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {
+        Connection conn = getConnection();
+        if (conn == null) {
+            throw new IllegalStateException("Not connected");
+        }
+        return JdbcExecutor.INSTANCE.executePage(
+            conn,
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            JdbcExecutor.INSTANCE::defaultResultValue
+        );
+    }
+
+    default QueryPageResult fetchQueryPage(String sessionId, int pageSize) {
+        return JdbcExecutor.INSTANCE.fetchPage(sessionId, pageSize);
+    }
+
+    default boolean closeQuerySession(String sessionId) {
+        return JdbcExecutor.INSTANCE.closeQuerySession(sessionId);
+    }
+
+    default QueryPageResult startTableRead(String sql, String schema, QueryPageOptions options) {
+        Connection conn = getConnection();
+        if (conn == null) {
+            throw new IllegalStateException("Not connected");
+        }
+        return JdbcExecutor.INSTANCE.startTableRead(
+            conn,
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            JdbcExecutor.INSTANCE::defaultResultValue
+        );
+    }
+
+    default QueryPageResult fetchTableReadPage(String sessionId, int pageSize) {
+        return JdbcExecutor.INSTANCE.fetchTableReadPage(sessionId, pageSize);
+    }
+
+    default boolean closeTableReadSession(String sessionId) {
+        return JdbcExecutor.INSTANCE.closeTableReadSession(sessionId);
+    }
+
+    /**
+     * Get DM execution plan. Supports two modes:
+     *   mode="explain" (default) — direct plan, no execution
+     *   mode="autotrace"         — enable MONITOR_SQL_EXEC, execute SQL, then get plan with actual stats
+     * @return plan text
+     */
+    default String getExplainInfo(String sql, String database, String schema, int timeoutSecs, String mode) {
+        throw new UnsupportedOperationException("getExplainInfo is not supported by this agent");
+    }
+
+    void disconnect();
+
+    Connection getConnection();
+
+    default QueryResult executeTransaction(List<String> statements, String schema) {
+        Connection conn = getConnection();
+        if (conn == null) {
+            throw new IllegalStateException("Not connected");
+        }
+        return TransactionExecutor.executeUpdateStatements(conn, statements, schema, this::setSchemaSQL);
+    }
+
+    default QueryResult executeBatch(List<String> statements, String schema) {
+        Connection conn = getConnection();
+        if (conn == null) {
+            throw new IllegalStateException("Not connected");
+        }
+        return BatchExecutor.executeBatchStatements(conn, statements, schema, this::setSchemaSQL);
+    }
+
+    default String setSchemaSQL(String schema) {
+        return "SET SCHEMA " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
+    }
+
+    static String buildTableDdl(
+        String schema,
+        String table,
+        List<ColumnInfo> columns,
+        List<IndexInfo> indexes,
+        List<ForeignKeyInfo> foreignKeys
+    ) {
+        return DdlBuilder.buildTableDdl(schema, table, columns, indexes, foreignKeys);
+    }
+
+    static String trimSql(String sql) {
+        String trimmed = sql.trim();
+        while (trimmed.endsWith(";")) {
+            trimmed = trimmed.substring(0, trimmed.length() - 1).trim();
+        }
+        return trimmed;
+    }
+
+    static <T> T unchecked(ThrowingSupplier<T> supplier) {
+        try {
+            return supplier.get();
+        } catch (RuntimeException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    interface ThrowingSupplier<T> {
+        T get() throws Exception;
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/DatabaseInfo.java b/agents/common/src/main/java/com/dbx/agent/DatabaseInfo.java
new file mode 100644
index 0000000..e2c2f12
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/DatabaseInfo.java
@@ -0,0 +1,41 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class DatabaseInfo {
+    private String name;
+
+    public DatabaseInfo() {
+        this("");
+    }
+
+    public DatabaseInfo(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof DatabaseInfo)) return false;
+        DatabaseInfo that = (DatabaseInfo) other;
+        return Objects.equals(name, that.name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name);
+    }
+
+    @Override
+    public String toString() {
+        return "DatabaseInfo(name=" + name + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/DdlBuilder.java b/agents/common/src/main/java/com/dbx/agent/DdlBuilder.java
new file mode 100644
index 0000000..b03ef7e
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/DdlBuilder.java
@@ -0,0 +1,228 @@
+package com.dbx.agent;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+public final class DdlBuilder {
+    private DdlBuilder() {
+    }
+
+    public static String buildTableDdl(
+        String schema,
+        String table,
+        List<ColumnInfo> columns,
+        List<IndexInfo> indexes,
+        List<ForeignKeyInfo> foreignKeys
+    ) {
+        return buildTableDdl(schema, table, columns, indexes, foreignKeys, false, false);
+    }
+
+    public static String buildTableDdl(
+        String schema,
+        String table,
+        List<ColumnInfo> columns,
+        List<IndexInfo> indexes,
+        List<ForeignKeyInfo> foreignKeys,
+        boolean useBacktick
+    ) {
+        return buildTableDdl(schema, table, columns, indexes, foreignKeys, useBacktick, false);
+    }
+
+    public static String buildTableDdl(
+        String schema,
+        String table,
+        List<ColumnInfo> columns,
+        List<IndexInfo> indexes,
+        List<ForeignKeyInfo> foreignKeys,
+        boolean useBacktick,
+        boolean includeColumnComments
+    ) {
+        return buildTableDdl(
+            schema,
+            table,
+            columns,
+            indexes,
+            foreignKeys,
+            Collections.emptyList(),
+            useBacktick,
+            includeColumnComments
+        );
+    }
+
+    public static String buildTableDdl(
+        String schema,
+        String table,
+        List<ColumnInfo> columns,
+        List<IndexInfo> indexes,
+        List<ForeignKeyInfo> foreignKeys,
+        List<CheckConstraintInfo> checkConstraints,
+        boolean useBacktick,
+        boolean includeColumnComments
+    ) {
+        String tableRef = qualifiedName(schema, table, useBacktick);
+        List<String> columnLines = new ArrayList<>();
+        for (ColumnInfo column : columns) {
+            StringBuilder line = new StringBuilder();
+            line.append("  ");
+            line.append(quoteIdent(column.getName(), useBacktick));
+            line.append(" ");
+            line.append(columnTypeSql(column));
+            if (!column.getIs_nullable()) {
+                line.append(" NOT NULL");
+            }
+            if (notBlank(column.getColumn_default())) {
+                line.append(" DEFAULT ");
+                line.append(column.getColumn_default());
+            }
+            columnLines.add(line.toString());
+        }
+
+        List<String> primaryKeys = new ArrayList<>();
+        for (ColumnInfo column : columns) {
+            if (column.getIs_primary_key()) {
+                primaryKeys.add(quoteIdent(column.getName(), useBacktick));
+            }
+        }
+        if (!primaryKeys.isEmpty()) {
+            columnLines.add("  PRIMARY KEY (" + join(primaryKeys, ", ") + ")");
+        }
+
+        for (ForeignKeyInfo fk : foreignKeys) {
+            columnLines.add(
+                "  CONSTRAINT " + quoteIdent(fk.getName(), useBacktick)
+                    + " FOREIGN KEY (" + quoteIdent(fk.getColumn(), useBacktick) + ") "
+                    + "REFERENCES " + quoteIdent(fk.getRef_table(), useBacktick) + "(" + quoteIdent(fk.getRef_column(), useBacktick) + ")"
+            );
+        }
+
+        for (CheckConstraintInfo constraint : checkConstraints) {
+            if (!notBlank(constraint.getDefinition())) {
+                continue;
+            }
+            String name = notBlank(constraint.getName())
+                ? "CONSTRAINT " + quoteIdent(constraint.getName(), useBacktick) + " "
+                : "";
+            columnLines.add("  " + name + constraint.getDefinition());
+        }
+
+        StringBuilder ddl = new StringBuilder();
+        ddl.append("CREATE TABLE ");
+        ddl.append(tableRef);
+        ddl.append(" (\n");
+        ddl.append(join(columnLines, ",\n"));
+        ddl.append("\n);\n");
+
+        if (includeColumnComments) {
+            for (ColumnInfo column : columns) {
+                if (!notBlank(column.getComment())) {
+                    continue;
+                }
+                ddl.append("\nCOMMENT ON COLUMN ");
+                ddl.append(tableRef);
+                ddl.append(".");
+                ddl.append(quoteIdent(column.getName(), useBacktick));
+                ddl.append(" IS '");
+                ddl.append(sqlStringBody(column.getComment()));
+                ddl.append("';");
+            }
+        }
+
+        for (IndexInfo index : indexes) {
+            if (index.getIs_primary()) {
+                continue;
+            }
+            String unique = index.getIs_unique() ? "UNIQUE " : "";
+            String using = notBlank(index.getIndex_type()) ? " USING " + index.getIndex_type() : "";
+            List<String> quotedColumns = new ArrayList<>();
+            for (String column : index.getColumns()) {
+                quotedColumns.add(quoteIdent(column, useBacktick));
+            }
+            String filter = notBlank(index.getFilter()) ? " WHERE " + index.getFilter() : "";
+            ddl.append("\nCREATE ");
+            ddl.append(unique);
+            ddl.append("INDEX ");
+            ddl.append(quoteIdent(index.getName(), useBacktick));
+            ddl.append(" ON ");
+            ddl.append(tableRef);
+            ddl.append(using);
+            ddl.append(" (");
+            ddl.append(join(quotedColumns, ", "));
+            ddl.append(")");
+            ddl.append(filter);
+            ddl.append(";");
+            if (notBlank(index.getComment())) {
+                ddl.append("\nCOMMENT ON INDEX ");
+                if (notBlank(schema)) {
+                    ddl.append(quoteIdent(schema, useBacktick));
+                    ddl.append(".");
+                }
+                ddl.append(quoteIdent(index.getName(), useBacktick));
+                ddl.append(" IS '");
+                ddl.append(sqlStringBody(index.getComment()));
+                ddl.append("';");
+            }
+        }
+
+        return ddl.toString();
+    }
+
+    private static String quoteIdent(String identifier, boolean useBacktick) {
+        return useBacktick
+            ? JdbcIdentifiers.INSTANCE.backtick(identifier)
+            : JdbcIdentifiers.INSTANCE.doubleQuote(identifier);
+    }
+
+    private static String qualifiedName(String schema, String name, boolean useBacktick) {
+        if (!notBlank(schema)) {
+            return quoteIdent(name, useBacktick);
+        }
+        return quoteIdent(schema, useBacktick) + "." + quoteIdent(name, useBacktick);
+    }
+
+    private static String columnTypeSql(ColumnInfo column) {
+        String type = column.getData_type();
+        String normalized = type.toLowerCase(Locale.ROOT);
+        if (isCharacterType(normalized) && column.getCharacter_maximum_length() != null) {
+            return type + "(" + column.getCharacter_maximum_length() + ")";
+        }
+        if (isNumericType(normalized) && column.getNumeric_precision() != null) {
+            if (column.getNumeric_scale() != null) {
+                return type + "(" + column.getNumeric_precision() + ", " + column.getNumeric_scale() + ")";
+            }
+            return type + "(" + column.getNumeric_precision() + ")";
+        }
+        return type;
+    }
+
+    private static boolean isCharacterType(String normalized) {
+        return "character varying".equals(normalized)
+            || "varchar".equals(normalized)
+            || "char".equals(normalized)
+            || "character".equals(normalized);
+    }
+
+    private static boolean isNumericType(String normalized) {
+        return "numeric".equals(normalized) || "decimal".equals(normalized);
+    }
+
+    private static boolean notBlank(String value) {
+        return value != null && !value.trim().isEmpty();
+    }
+
+    private static String sqlStringBody(String value) {
+        return value.replace("'", "''");
+    }
+
+    private static String join(List<String> values, String separator) {
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < values.size(); i++) {
+            if (i > 0) {
+                builder.append(separator);
+            }
+            builder.append(values.get(i));
+        }
+        return builder.toString();
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/EwkbWktDecoder.java b/agents/common/src/main/java/com/dbx/agent/EwkbWktDecoder.java
new file mode 100644
index 0000000..96af67a
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/EwkbWktDecoder.java
@@ -0,0 +1,671 @@
+package com.dbx.agent;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Decode PostGIS EWKB / WKB byte streams (and PGgeometry / hex strings) into
+ * OGC Well-Known Text. Behaves identically to the Rust implementation in
+ * {@code crates/dbx-core/src/db/postgres.rs::ewkb_to_wkt}, including the
+ * {@code Z} / {@code M} / {@code ZM} dimension suffixes and {@code EMPTY}
+ * geometries. Used by the JDBC agent layer so that PostgresLike databases
+ * such as HighGo / KingBase / Vastbase / openGauss / GaussDB return WKT for
+ * {@code geometry}/{@code geography} columns instead of opaque hex blobs.
+ *
+ * <p>The decoder is permissive: any unrecognized payload (truncated bytes,
+ * unsupported geometry kind, non-hex strings, etc.) falls back to a hex
+ * representation prefixed with {@code 0x} so the cell remains visible.
+ */
+public final class EwkbWktDecoder {
+    /** Reflectively-detected PGgeometry classes that expose getValue() returning EWKT text. */
+    private static final String[] PGGEOMETRY_CLASS_NAMES = new String[]{
+        "org.postgis.PGgeometry",            // legacy PostGIS-JDBC
+        "net.postgis.jdbc.PGgeometry",       // modern PostGIS-JDBC (>= 2024 release)
+        "com.highgo.jdbc.geometry.PGgeometry"
+    };
+
+    /**
+     * Generic {@code org.postgresql.util.PGobject}-shaped classes. Their
+     * {@code getValue()} returns the textual representation the driver got off
+     * the wire. For PostGIS columns on HighGo / KingBase / Vastbase that text
+     * is the EWKB hex (e.g. {@code 0101000020E61000...}) — we still need to run
+     * it through the EWKB hex parser.
+     */
+    private static final String[] PGOBJECT_CLASS_NAMES = new String[]{
+        "org.postgresql.util.PGobject",
+        "com.highgo.jdbc.util.PGobject",
+        "org.postgresql.geometric.PGobject"
+    };
+
+    private EwkbWktDecoder() {
+    }
+
+    /**
+     * Decode a JDBC-returned object from a {@code geometry} / {@code geography}
+     * column into a textual representation, preferring WKT.
+     *
+     * <p>Accepted inputs:
+     * <ul>
+     *   <li>{@code null} — returned as-is.</li>
+     *   <li>{@code byte[]} — interpreted as raw EWKB.</li>
+     *   <li>A {@code PGgeometry}-like object exposing {@code getValue()} — the
+     *       returned string is taken verbatim (already EWKT/WKT).</li>
+     *   <li>{@link String} — if it looks like hex EWKB (with optional
+     *       {@code 0x}/{@code \\x} prefix and a leading endian byte of
+     *       {@code 00}/{@code 01}), it is decoded; otherwise returned as-is.</li>
+     * </ul>
+     *
+     * @param value raw column value
+     * @return decoded WKT, or a {@code 0x}-prefixed hex fallback, or {@code null}
+     */
+    public static Object decode(Object value) {
+        if (value == null) {
+            return null;
+        }
+        if (value instanceof byte[]) {
+            return decodeBytes((byte[]) value);
+        }
+        if (value instanceof String) {
+            return decodeString((String) value);
+        }
+        // PGgeometry / PGobject and friends — pull out their getValue() text
+        // and run it through the same string path. For PostGIS-JDBC types
+        // getValue() yields EWKT (passes through unchanged); for the generic
+        // PGobject driver returns EWKB hex, which decodeString() decodes.
+        String pgValue = tryReflectiveGetValue(value);
+        if (pgValue != null) {
+            return decodeString(pgValue);
+        }
+        // Last resort: rely on toString() / underlying value.
+        return value.toString();
+    }
+
+    /** Decode a raw EWKB byte sequence; returns hex {@code 0x..} on failure. */
+    static String decodeBytes(byte[] raw) {
+        if (raw == null) {
+            return null;
+        }
+        String wkt = parseEwkb(raw);
+        if (wkt != null) {
+            return wkt;
+        }
+        return bytesToHexWithPrefix(raw);
+    }
+
+    /**
+     * Decode a string column. If the text matches an EWKB hex layout the bytes
+     * are decoded; otherwise (already WKT, ST_AsText output, etc.) returned
+     * unchanged.
+     */
+    static String decodeString(String value) {
+        if (value == null) {
+            return null;
+        }
+        byte[] bytes = tryParseHex(value);
+        if (bytes == null) {
+            return value;
+        }
+        String wkt = parseEwkb(bytes);
+        if (wkt != null) {
+            return wkt;
+        }
+        // looked like hex but couldn't be parsed — preserve hex form.
+        return ensureHexPrefix(value);
+    }
+
+    /**
+     * Try to extract textual value from PGgeometry / PGobject-like objects via
+     * {@code getValue()}. Returns {@code null} if the class doesn't match any
+     * known PostGIS / PostgreSQL JDBC type (or the call fails reflectively).
+     */
+    private static String tryReflectiveGetValue(Object value) {
+        Class<?> cls = value.getClass();
+        if (!matchesAnyClassName(cls, PGGEOMETRY_CLASS_NAMES)
+            && !matchesAnyClassName(cls, PGOBJECT_CLASS_NAMES)) {
+            return null;
+        }
+        try {
+            Method getValue = cls.getMethod("getValue");
+            Object result = getValue.invoke(value);
+            if (result instanceof String) {
+                return (String) result;
+            }
+        } catch (ReflectiveOperationException ignored) {
+            // fall through
+        }
+        return null;
+    }
+
+    private static boolean matchesAnyClassName(Class<?> cls, String[] names) {
+        Class<?> current = cls;
+        while (current != null) {
+            for (String name : names) {
+                if (current.getName().equals(name)) {
+                    return true;
+                }
+                for (Class<?> iface : current.getInterfaces()) {
+                    if (iface.getName().equals(name)) {
+                        return true;
+                    }
+                }
+            }
+            current = current.getSuperclass();
+        }
+        return false;
+    }
+
+    /** @return parsed bytes, or {@code null} if {@code value} is not hex EWKB. */
+    static byte[] tryParseHex(String value) {
+        String s = value;
+        if (s.length() >= 2 && (s.startsWith("0x") || s.startsWith("0X"))) {
+            s = s.substring(2);
+        } else if (s.length() >= 2 && (s.startsWith("\\x") || s.startsWith("\\X"))) {
+            s = s.substring(2);
+        }
+        if (s.length() < 10 || (s.length() & 1) != 0) {
+            return null;
+        }
+        // First byte must be the WKB endian marker (00 = big, 01 = little)
+        char e0 = s.charAt(0);
+        char e1 = s.charAt(1);
+        if (!((e0 == '0') && (e1 == '0' || e1 == '1'))) {
+            return null;
+        }
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) {
+                return null;
+            }
+        }
+        byte[] out = new byte[s.length() / 2];
+        for (int i = 0; i < out.length; i++) {
+            int hi = Character.digit(s.charAt(i * 2), 16);
+            int lo = Character.digit(s.charAt(i * 2 + 1), 16);
+            out[i] = (byte) ((hi << 4) | lo);
+        }
+        return out;
+    }
+
+    private static String ensureHexPrefix(String value) {
+        if (value.startsWith("0x") || value.startsWith("0X")) {
+            return value;
+        }
+        return "0x" + value;
+    }
+
+    static String bytesToHexWithPrefix(byte[] bytes) {
+        StringBuilder sb = new StringBuilder(bytes.length * 2 + 2);
+        sb.append("0x");
+        for (byte b : bytes) {
+            sb.append(Character.forDigit((b >> 4) & 0xF, 16));
+            sb.append(Character.forDigit(b & 0xF, 16));
+        }
+        return sb.toString();
+    }
+
+    // ── EWKB parser ────────────────────────────────────────────────────────
+
+    private static String parseEwkb(byte[] raw) {
+        if (raw == null || raw.length == 0) {
+            return null;
+        }
+        Reader reader = new Reader(raw);
+        Geometry g = parseGeometry(reader);
+        if (g == null || reader.pos != raw.length) {
+            return null;
+        }
+        return geometryToWkt(g);
+    }
+
+    private static Geometry parseGeometry(Reader reader) {
+        Integer endian = reader.readU8();
+        if (endian == null) {
+            return null;
+        }
+        boolean little;
+        if (endian == 0) {
+            little = false;
+        } else if (endian == 1) {
+            little = true;
+        } else {
+            return null;
+        }
+        Long typeWordBoxed = reader.readU32(little);
+        if (typeWordBoxed == null) {
+            return null;
+        }
+        long typeWord = typeWordBoxed;
+        Dims parsed = parseDimensions(typeWord);
+        long baseType = parsed.baseType;
+        if (parsed.hasSrid) {
+            if (reader.readU32(little) == null) {
+                return null;
+            }
+        }
+        Dimensions dims = parsed.dims;
+        switch ((int) baseType) {
+            case 1: { // Point
+                int len = dims.coordinateLen();
+                List<Double> coords = new ArrayList<>(len);
+                for (int i = 0; i < len; i++) {
+                    Double v = reader.readF64(little);
+                    if (v == null) {
+                        return null;
+                    }
+                    coords.add(v);
+                }
+                boolean allNan = true;
+                for (Double v : coords) {
+                    if (!Double.isNaN(v)) {
+                        allNan = false;
+                        break;
+                    }
+                }
+                return new Geometry(GeomKind.POINT, dims, allNan ? null : coords, null, null, null, null, null);
+            }
+            case 2: { // LineString
+                List<List<Double>> points = parsePoints(reader, little, dims);
+                if (points == null) return null;
+                return new Geometry(GeomKind.LINESTRING, dims, null, points, null, null, null, null);
+            }
+            case 3: { // Polygon
+                Long ringCount = reader.readU32(little);
+                if (ringCount == null) return null;
+                List<List<List<Double>>> rings = new ArrayList<>();
+                for (int i = 0; i < ringCount; i++) {
+                    List<List<Double>> ring = parsePoints(reader, little, dims);
+                    if (ring == null) return null;
+                    rings.add(ring);
+                }
+                return new Geometry(GeomKind.POLYGON, dims, null, null, rings, null, null, null);
+            }
+            case 4: { // MultiPoint
+                Long count = reader.readU32(little);
+                if (count == null) return null;
+                List<List<Double>> mpoints = new ArrayList<>();
+                for (int i = 0; i < count; i++) {
+                    List<Double> coords = readPointCoords(reader, dims);
+                    if (coords == null) {
+                        // sub-point parse failure (returning null != EMPTY); abort.
+                        return null;
+                    }
+                    boolean allNan = true;
+                    for (Double v : coords) {
+                        if (!Double.isNaN(v)) {
+                            allNan = false;
+                            break;
+                        }
+                    }
+                    mpoints.add(allNan ? null : coords);
+                }
+                return new Geometry(GeomKind.MULTIPOINT, dims, null, null, null, mpoints, null, null);
+            }
+            case 5: { // MultiLineString
+                Long count = reader.readU32(little);
+                if (count == null) return null;
+                List<List<List<Double>>> lines = new ArrayList<>();
+                for (int i = 0; i < count; i++) {
+                    Geometry sub = parseGeometry(reader);
+                    if (sub == null || sub.kind != GeomKind.LINESTRING) return null;
+                    lines.add(sub.points);
+                }
+                return new Geometry(GeomKind.MULTILINESTRING, dims, null, null, lines, null, null, null);
+            }
+            case 6: { // MultiPolygon
+                Long count = reader.readU32(little);
+                if (count == null) return null;
+                List<List<List<List<Double>>>> polys = new ArrayList<>();
+                for (int i = 0; i < count; i++) {
+                    Geometry sub = parseGeometry(reader);
+                    if (sub == null || sub.kind != GeomKind.POLYGON) return null;
+                    polys.add(sub.rings);
+                }
+                return new Geometry(GeomKind.MULTIPOLYGON, dims, null, null, null, null, polys, null);
+            }
+            case 7: { // GeometryCollection
+                Long count = reader.readU32(little);
+                if (count == null) return null;
+                List<Geometry> children = new ArrayList<>();
+                for (int i = 0; i < count; i++) {
+                    Geometry sub = parseGeometry(reader);
+                    if (sub == null) return null;
+                    children.add(sub);
+                }
+                return new Geometry(GeomKind.GEOMETRYCOLLECTION, dims, null, null, null, null, null, children);
+            }
+            default:
+                return null;
+        }
+    }
+
+    private static List<List<Double>> parsePoints(Reader reader, boolean little, Dimensions dims) {
+        Long count = reader.readU32(little);
+        if (count == null) return null;
+        int dim = dims.coordinateLen();
+        List<List<Double>> result = new ArrayList<>();
+        for (int i = 0; i < count; i++) {
+            List<Double> coords = new ArrayList<>(dim);
+            for (int j = 0; j < dim; j++) {
+                Double v = reader.readF64(little);
+                if (v == null) return null;
+                coords.add(v);
+            }
+            result.add(coords);
+        }
+        return result;
+    }
+
+    private static List<Double> readPointCoords(Reader reader, Dimensions parentDims) {
+        Integer endian = reader.readU8();
+        if (endian == null) return null;
+        boolean little;
+        if (endian == 0) {
+            little = false;
+        } else if (endian == 1) {
+            little = true;
+        } else {
+            return null;
+        }
+        Long typeWord = reader.readU32(little);
+        if (typeWord == null) return null;
+        Dims parsed = parseDimensions(typeWord);
+        if (parsed.baseType != 1 || !parsed.dims.equals(parentDims)) {
+            return null;
+        }
+        if (parsed.hasSrid) {
+            if (reader.readU32(little) == null) return null;
+        }
+        int dim = parsed.dims.coordinateLen();
+        List<Double> coords = new ArrayList<>(dim);
+        for (int i = 0; i < dim; i++) {
+            Double v = reader.readF64(little);
+            if (v == null) return null;
+            coords.add(v);
+        }
+        return coords;
+    }
+
+    private static Dims parseDimensions(long typeWord) {
+        long baseType = typeWord & 0x1FFF_FFFFL;
+        boolean hasZ = (typeWord & 0x8000_0000L) != 0;
+        boolean hasM = (typeWord & 0x4000_0000L) != 0;
+        boolean hasSrid = (typeWord & 0x2000_0000L) != 0;
+        if (baseType >= 3000) {
+            hasZ = true;
+            hasM = true;
+            baseType -= 3000;
+        } else if (baseType >= 2000) {
+            hasM = true;
+            baseType -= 2000;
+        } else if (baseType >= 1000) {
+            hasZ = true;
+            baseType -= 1000;
+        }
+        return new Dims(baseType, new Dimensions(hasZ, hasM), hasSrid);
+    }
+
+    // ── WKT formatting ─────────────────────────────────────────────────────
+
+    private static String geometryToWkt(Geometry g) {
+        String suffix = g.dims.suffix();
+        switch (g.kind) {
+            case POINT:
+                if (g.coords == null) {
+                    return "POINT" + suffix + " EMPTY";
+                }
+                return "POINT" + suffix + "(" + formatCoord(g.coords) + ")";
+            case LINESTRING:
+                if (g.points == null || g.points.isEmpty()) {
+                    return "LINESTRING" + suffix + " EMPTY";
+                }
+                return "LINESTRING" + suffix + "(" + formatCoordSeq(g.points) + ")";
+            case POLYGON:
+                if (g.rings == null || g.rings.isEmpty()) {
+                    return "POLYGON" + suffix + " EMPTY";
+                }
+                return "POLYGON" + suffix + "(" + joinRings(g.rings) + ")";
+            case MULTIPOINT:
+                if (g.multiPoints == null || g.multiPoints.isEmpty()) {
+                    return "MULTIPOINT" + suffix + " EMPTY";
+                }
+                return "MULTIPOINT" + suffix + "(" + joinMultiPoints(g.multiPoints) + ")";
+            case MULTILINESTRING:
+                if (g.rings == null || g.rings.isEmpty()) {
+                    return "MULTILINESTRING" + suffix + " EMPTY";
+                }
+                return "MULTILINESTRING" + suffix + "(" + joinRings(g.rings) + ")";
+            case MULTIPOLYGON:
+                if (g.polygons == null || g.polygons.isEmpty()) {
+                    return "MULTIPOLYGON" + suffix + " EMPTY";
+                }
+                return "MULTIPOLYGON" + suffix + "(" + joinPolygons(g.polygons) + ")";
+            case GEOMETRYCOLLECTION:
+                if (g.children == null || g.children.isEmpty()) {
+                    return "GEOMETRYCOLLECTION" + suffix + " EMPTY";
+                }
+                StringBuilder sb = new StringBuilder("GEOMETRYCOLLECTION").append(suffix).append("(");
+                for (int i = 0; i < g.children.size(); i++) {
+                    if (i > 0) sb.append(',');
+                    sb.append(geometryToWkt(g.children.get(i)));
+                }
+                sb.append(')');
+                return sb.toString();
+            default:
+                throw new IllegalStateException("unknown geometry kind: " + g.kind);
+        }
+    }
+
+    private static String formatCoord(List<Double> coords) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < coords.size(); i++) {
+            if (i > 0) sb.append(' ');
+            sb.append(formatDouble(coords.get(i)));
+        }
+        return sb.toString();
+    }
+
+    private static String formatCoordSeq(List<List<Double>> points) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < points.size(); i++) {
+            if (i > 0) sb.append(',');
+            sb.append(formatCoord(points.get(i)));
+        }
+        return sb.toString();
+    }
+
+    private static String joinRings(List<List<List<Double>>> rings) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < rings.size(); i++) {
+            if (i > 0) sb.append(',');
+            sb.append('(').append(formatCoordSeq(rings.get(i))).append(')');
+        }
+        return sb.toString();
+    }
+
+    private static String joinMultiPoints(List<List<Double>> mpoints) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < mpoints.size(); i++) {
+            if (i > 0) sb.append(',');
+            List<Double> p = mpoints.get(i);
+            if (p == null) {
+                sb.append("EMPTY");
+            } else {
+                sb.append('(').append(formatCoord(p)).append(')');
+            }
+        }
+        return sb.toString();
+    }
+
+    private static String joinPolygons(List<List<List<List<Double>>>> polys) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < polys.size(); i++) {
+            if (i > 0) sb.append(',');
+            sb.append('(').append(joinRings(polys.get(i))).append(')');
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Format a double the same way Rust's {@code f64::Display} does — shortest
+     * round-trippable decimal, trailing {@code .0} stripped (so {@code 116.0}
+     * becomes {@code "116"}, not {@code "116.0"}).
+     */
+    static String formatDouble(double value) {
+        if (Double.isNaN(value)) {
+            return "NaN";
+        }
+        if (Double.isInfinite(value)) {
+            return value > 0 ? "inf" : "-inf";
+        }
+        String s = Double.toString(value);
+        // Strip trailing ".0" for whole-number doubles so output matches Rust.
+        if (s.endsWith(".0")) {
+            return s.substring(0, s.length() - 2);
+        }
+        return s;
+    }
+
+    // ── helper structs ─────────────────────────────────────────────────────
+
+    private enum GeomKind {
+        POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING, MULTIPOLYGON, GEOMETRYCOLLECTION
+    }
+
+    private static final class Geometry {
+        final GeomKind kind;
+        final Dimensions dims;
+        final List<Double> coords;            // POINT
+        final List<List<Double>> points;      // LINESTRING
+        final List<List<List<Double>>> rings; // POLYGON / MULTILINESTRING (lines == rings shape-wise)
+        final List<List<Double>> multiPoints; // MULTIPOINT (null entry = EMPTY)
+        final List<List<List<List<Double>>>> polygons; // MULTIPOLYGON
+        final List<Geometry> children;        // GEOMETRYCOLLECTION
+
+        Geometry(
+            GeomKind kind,
+            Dimensions dims,
+            List<Double> coords,
+            List<List<Double>> points,
+            List<List<List<Double>>> rings,
+            List<List<Double>> multiPoints,
+            List<List<List<List<Double>>>> polygons,
+            List<Geometry> children
+        ) {
+            this.kind = kind;
+            this.dims = dims;
+            this.coords = coords;
+            this.points = points;
+            this.rings = rings;
+            this.multiPoints = multiPoints;
+            this.polygons = polygons;
+            this.children = children;
+        }
+    }
+
+    private static final class Dimensions {
+        final boolean hasZ;
+        final boolean hasM;
+
+        Dimensions(boolean hasZ, boolean hasM) {
+            this.hasZ = hasZ;
+            this.hasM = hasM;
+        }
+
+        String suffix() {
+            if (hasZ && hasM) return " ZM";
+            if (hasZ) return " Z";
+            if (hasM) return " M";
+            return "";
+        }
+
+        int coordinateLen() {
+            return 2 + (hasZ ? 1 : 0) + (hasM ? 1 : 0);
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (!(o instanceof Dimensions)) return false;
+            Dimensions d = (Dimensions) o;
+            return hasZ == d.hasZ && hasM == d.hasM;
+        }
+
+        @Override
+        public int hashCode() {
+            return (hasZ ? 1 : 0) * 31 + (hasM ? 1 : 0);
+        }
+    }
+
+    private static final class Dims {
+        final long baseType;
+        final Dimensions dims;
+        final boolean hasSrid;
+
+        Dims(long baseType, Dimensions dims, boolean hasSrid) {
+            this.baseType = baseType;
+            this.dims = dims;
+            this.hasSrid = hasSrid;
+        }
+    }
+
+    private static final class Reader {
+        final byte[] raw;
+        int pos;
+
+        Reader(byte[] raw) {
+            this.raw = raw;
+        }
+
+        Integer readU8() {
+            if (pos >= raw.length) return null;
+            int v = raw[pos] & 0xFF;
+            pos += 1;
+            return v;
+        }
+
+        Long readU32(boolean little) {
+            if (pos + 4 > raw.length) return null;
+            long v;
+            if (little) {
+                v = ((long) (raw[pos] & 0xFF))
+                    | ((long) (raw[pos + 1] & 0xFF) << 8)
+                    | ((long) (raw[pos + 2] & 0xFF) << 16)
+                    | ((long) (raw[pos + 3] & 0xFF) << 24);
+            } else {
+                v = ((long) (raw[pos] & 0xFF) << 24)
+                    | ((long) (raw[pos + 1] & 0xFF) << 16)
+                    | ((long) (raw[pos + 2] & 0xFF) << 8)
+                    | ((long) (raw[pos + 3] & 0xFF));
+            }
+            pos += 4;
+            return v & 0xFFFF_FFFFL;
+        }
+
+        Double readF64(boolean little) {
+            if (pos + 8 > raw.length) return null;
+            long bits;
+            if (little) {
+                bits = ((long) (raw[pos] & 0xFF))
+                    | ((long) (raw[pos + 1] & 0xFF) << 8)
+                    | ((long) (raw[pos + 2] & 0xFF) << 16)
+                    | ((long) (raw[pos + 3] & 0xFF) << 24)
+                    | ((long) (raw[pos + 4] & 0xFF) << 32)
+                    | ((long) (raw[pos + 5] & 0xFF) << 40)
+                    | ((long) (raw[pos + 6] & 0xFF) << 48)
+                    | ((long) (raw[pos + 7] & 0xFF) << 56);
+            } else {
+                bits = ((long) (raw[pos] & 0xFF) << 56)
+                    | ((long) (raw[pos + 1] & 0xFF) << 48)
+                    | ((long) (raw[pos + 2] & 0xFF) << 40)
+                    | ((long) (raw[pos + 3] & 0xFF) << 32)
+                    | ((long) (raw[pos + 4] & 0xFF) << 24)
+                    | ((long) (raw[pos + 5] & 0xFF) << 16)
+                    | ((long) (raw[pos + 6] & 0xFF) << 8)
+                    | ((long) (raw[pos + 7] & 0xFF));
+            }
+            pos += 8;
+            return Double.longBitsToDouble(bits);
+        }
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/ExecuteQueryOptions.java b/agents/common/src/main/java/com/dbx/agent/ExecuteQueryOptions.java
new file mode 100644
index 0000000..ae33923
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/ExecuteQueryOptions.java
@@ -0,0 +1,67 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class ExecuteQueryOptions {
+    private int maxRows;
+    private Integer fetchSize;
+    private int timeoutSecs;
+
+    public ExecuteQueryOptions() {
+        this(JdbcExecutor.DEFAULT_MAX_ROWS, null, 0);
+    }
+
+    public ExecuteQueryOptions(int maxRows, Integer fetchSize) {
+        this(maxRows, fetchSize, 0);
+    }
+
+    public ExecuteQueryOptions(int maxRows, Integer fetchSize, int timeoutSecs) {
+        this.maxRows = maxRows;
+        this.fetchSize = fetchSize;
+        this.timeoutSecs = timeoutSecs;
+    }
+
+    public int getMaxRows() {
+        return maxRows;
+    }
+
+    public Integer getFetchSize() {
+        return fetchSize;
+    }
+
+    public int getTimeoutSecs() {
+        return timeoutSecs;
+    }
+
+    public void setMaxRows(int maxRows) {
+        this.maxRows = maxRows;
+    }
+
+    public void setFetchSize(Integer fetchSize) {
+        this.fetchSize = fetchSize;
+    }
+
+    public void setTimeoutSecs(int timeoutSecs) {
+        this.timeoutSecs = timeoutSecs;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof ExecuteQueryOptions)) return false;
+        ExecuteQueryOptions that = (ExecuteQueryOptions) other;
+        return maxRows == that.maxRows
+            && timeoutSecs == that.timeoutSecs
+            && Objects.equals(fetchSize, that.fetchSize);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(maxRows, fetchSize, timeoutSecs);
+    }
+
+    @Override
+    public String toString() {
+        return "ExecuteQueryOptions(maxRows=" + maxRows + ", fetchSize=" + fetchSize + ", timeoutSecs=" + timeoutSecs + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/ExecuteQueryParams.java b/agents/common/src/main/java/com/dbx/agent/ExecuteQueryParams.java
new file mode 100644
index 0000000..0f96201
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/ExecuteQueryParams.java
@@ -0,0 +1,78 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class ExecuteQueryParams {
+    private String sql;
+    private String schema;
+    private Integer maxRows;
+    private Integer fetchSize;
+
+    public ExecuteQueryParams() {
+        this("", null, null, null);
+    }
+
+    public ExecuteQueryParams(String sql, String schema, Integer maxRows, Integer fetchSize) {
+        this.sql = sql;
+        this.schema = schema;
+        this.maxRows = maxRows;
+        this.fetchSize = fetchSize;
+    }
+
+    public String getSql() {
+        return sql;
+    }
+
+    public String getSchema() {
+        return schema;
+    }
+
+    public Integer getMaxRows() {
+        return maxRows;
+    }
+
+    public Integer getFetchSize() {
+        return fetchSize;
+    }
+
+    public void setSql(String sql) {
+        this.sql = sql;
+    }
+
+    public void setSchema(String schema) {
+        this.schema = schema;
+    }
+
+    public void setMaxRows(Integer maxRows) {
+        this.maxRows = maxRows;
+    }
+
+    public void setFetchSize(Integer fetchSize) {
+        this.fetchSize = fetchSize;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof ExecuteQueryParams)) return false;
+        ExecuteQueryParams that = (ExecuteQueryParams) other;
+        return Objects.equals(sql, that.sql)
+            && Objects.equals(schema, that.schema)
+            && Objects.equals(maxRows, that.maxRows)
+            && Objects.equals(fetchSize, that.fetchSize);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(sql, schema, maxRows, fetchSize);
+    }
+
+    @Override
+    public String toString() {
+        return "ExecuteQueryParams(sql=" + sql
+            + ", schema=" + schema
+            + ", maxRows=" + maxRows
+            + ", fetchSize=" + fetchSize
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/ForeignKeyInfo.java b/agents/common/src/main/java/com/dbx/agent/ForeignKeyInfo.java
new file mode 100644
index 0000000..de018df
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/ForeignKeyInfo.java
@@ -0,0 +1,78 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class ForeignKeyInfo {
+    private String name;
+    private String column;
+    private String ref_table;
+    private String ref_column;
+
+    public ForeignKeyInfo() {
+        this("", "", "", "");
+    }
+
+    public ForeignKeyInfo(String name, String column, String ref_table, String ref_column) {
+        this.name = name;
+        this.column = column;
+        this.ref_table = ref_table;
+        this.ref_column = ref_column;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getColumn() {
+        return column;
+    }
+
+    public String getRef_table() {
+        return ref_table;
+    }
+
+    public String getRef_column() {
+        return ref_column;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setColumn(String column) {
+        this.column = column;
+    }
+
+    public void setRef_table(String ref_table) {
+        this.ref_table = ref_table;
+    }
+
+    public void setRef_column(String ref_column) {
+        this.ref_column = ref_column;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof ForeignKeyInfo)) return false;
+        ForeignKeyInfo that = (ForeignKeyInfo) other;
+        return Objects.equals(name, that.name)
+            && Objects.equals(column, that.column)
+            && Objects.equals(ref_table, that.ref_table)
+            && Objects.equals(ref_column, that.ref_column);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, column, ref_table, ref_column);
+    }
+
+    @Override
+    public String toString() {
+        return "ForeignKeyInfo(name=" + name
+            + ", column=" + column
+            + ", ref_table=" + ref_table
+            + ", ref_column=" + ref_column
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/IndexInfo.java b/agents/common/src/main/java/com/dbx/agent/IndexInfo.java
new file mode 100644
index 0000000..ea38747
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/IndexInfo.java
@@ -0,0 +1,141 @@
+package com.dbx.agent;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public final class IndexInfo {
+    private String name;
+    private List<String> columns;
+    private boolean is_unique;
+    private boolean is_primary;
+    private String filter;
+    private String index_type;
+    private List<String> included_columns;
+    private String comment;
+
+    public IndexInfo() {
+        this("", Collections.emptyList(), false, false);
+    }
+
+    public IndexInfo(String name, List<String> columns, boolean is_unique, boolean is_primary) {
+        this(name, columns, is_unique, is_primary, null, null, null, null);
+    }
+
+    public IndexInfo(
+        String name,
+        List<String> columns,
+        boolean is_unique,
+        boolean is_primary,
+        String filter,
+        String index_type,
+        List<String> included_columns,
+        String comment
+    ) {
+        this.name = name;
+        this.columns = columns == null ? Collections.emptyList() : columns;
+        this.is_unique = is_unique;
+        this.is_primary = is_primary;
+        this.filter = filter;
+        this.index_type = index_type;
+        this.included_columns = included_columns;
+        this.comment = comment;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public List<String> getColumns() {
+        return columns;
+    }
+
+    public boolean getIs_unique() {
+        return is_unique;
+    }
+
+    public boolean getIs_primary() {
+        return is_primary;
+    }
+
+    public String getFilter() {
+        return filter;
+    }
+
+    public String getIndex_type() {
+        return index_type;
+    }
+
+    public List<String> getIncluded_columns() {
+        return included_columns;
+    }
+
+    public String getComment() {
+        return comment;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setColumns(List<String> columns) {
+        this.columns = columns;
+    }
+
+    public void setIs_unique(boolean is_unique) {
+        this.is_unique = is_unique;
+    }
+
+    public void setIs_primary(boolean is_primary) {
+        this.is_primary = is_primary;
+    }
+
+    public void setFilter(String filter) {
+        this.filter = filter;
+    }
+
+    public void setIndex_type(String index_type) {
+        this.index_type = index_type;
+    }
+
+    public void setIncluded_columns(List<String> included_columns) {
+        this.included_columns = included_columns;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof IndexInfo)) return false;
+        IndexInfo that = (IndexInfo) other;
+        return is_unique == that.is_unique
+            && is_primary == that.is_primary
+            && Objects.equals(name, that.name)
+            && Objects.equals(columns, that.columns)
+            && Objects.equals(filter, that.filter)
+            && Objects.equals(index_type, that.index_type)
+            && Objects.equals(included_columns, that.included_columns)
+            && Objects.equals(comment, that.comment);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, columns, is_unique, is_primary, filter, index_type, included_columns, comment);
+    }
+
+    @Override
+    public String toString() {
+        return "IndexInfo(name=" + name
+            + ", columns=" + columns
+            + ", is_unique=" + is_unique
+            + ", is_primary=" + is_primary
+            + ", filter=" + filter
+            + ", index_type=" + index_type
+            + ", included_columns=" + included_columns
+            + ", comment=" + comment
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/JdbcAgentProfile.java b/agents/common/src/main/java/com/dbx/agent/JdbcAgentProfile.java
new file mode 100644
index 0000000..433f817
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/JdbcAgentProfile.java
@@ -0,0 +1,223 @@
+package com.dbx.agent;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+public class JdbcAgentProfile {
+    private final String driverClass;
+    private final String urlTemplate;
+    private final int defaultPort;
+    private final boolean skipExecutionContext;
+    private final Set<String> excludedSchemas;
+    private final List<String> tableTypes;
+    private final String identifierQuote;
+    private final String schemaSwitchPrefix;
+    private final boolean catalogFallbackEnabled;
+    private final boolean nativeTableDdlSupported;
+    private final boolean objectSourceSupported;
+    private final boolean triggersSupported;
+
+    public JdbcAgentProfile(String driverClass, String urlTemplate) {
+        this(driverClass, urlTemplate, 0);
+    }
+
+    public JdbcAgentProfile(String driverClass, String urlTemplate, int defaultPort) {
+        this(driverClass, urlTemplate, defaultPort, false);
+    }
+
+    public JdbcAgentProfile(String driverClass, String urlTemplate, int defaultPort, boolean skipExecutionContext) {
+        this(
+            driverClass,
+            urlTemplate,
+            defaultPort,
+            skipExecutionContext,
+            Collections.emptySet(),
+            Arrays.asList("TABLE", "VIEW", "BASE TABLE", "MATERIALIZED VIEW", "SYSTEM TABLE", "SYSTEM VIEW")
+        );
+    }
+
+    public JdbcAgentProfile(
+        String driverClass,
+        String urlTemplate,
+        int defaultPort,
+        boolean skipExecutionContext,
+        Set<String> excludedSchemas,
+        List<String> tableTypes
+    ) {
+        this(
+            driverClass,
+            urlTemplate,
+            defaultPort,
+            skipExecutionContext,
+            excludedSchemas,
+            tableTypes,
+            "\"",
+            "SET SCHEMA",
+            true,
+            false,
+            false,
+            false
+        );
+    }
+
+    public JdbcAgentProfile(
+        String driverClass,
+        String urlTemplate,
+        int defaultPort,
+        boolean skipExecutionContext,
+        Set<String> excludedSchemas,
+        List<String> tableTypes,
+        String identifierQuote,
+        String schemaSwitchPrefix,
+        boolean catalogFallbackEnabled,
+        boolean nativeTableDdlSupported,
+        boolean objectSourceSupported,
+        boolean triggersSupported
+    ) {
+        this.driverClass = driverClass;
+        this.urlTemplate = urlTemplate;
+        this.defaultPort = defaultPort;
+        this.skipExecutionContext = skipExecutionContext;
+        this.excludedSchemas = excludedSchemas;
+        this.tableTypes = tableTypes;
+        this.identifierQuote = identifierQuote;
+        this.schemaSwitchPrefix = schemaSwitchPrefix;
+        this.catalogFallbackEnabled = catalogFallbackEnabled;
+        this.nativeTableDdlSupported = nativeTableDdlSupported;
+        this.objectSourceSupported = objectSourceSupported;
+        this.triggersSupported = triggersSupported;
+    }
+
+    public String getDriverClass() {
+        return driverClass;
+    }
+
+    public String getUrlTemplate() {
+        return urlTemplate;
+    }
+
+    public int getDefaultPort() {
+        return defaultPort;
+    }
+
+    public boolean getSkipExecutionContext() {
+        return skipExecutionContext;
+    }
+
+    public Set<String> getExcludedSchemas() {
+        return excludedSchemas;
+    }
+
+    public List<String> getTableTypes() {
+        return tableTypes;
+    }
+
+    public String getIdentifierQuote() {
+        return identifierQuote;
+    }
+
+    public String getSchemaSwitchPrefix() {
+        return schemaSwitchPrefix;
+    }
+
+    public boolean getCatalogFallbackEnabled() {
+        return catalogFallbackEnabled;
+    }
+
+    public boolean getNativeTableDdlSupported() {
+        return nativeTableDdlSupported;
+    }
+
+    public boolean getObjectSourceSupported() {
+        return objectSourceSupported;
+    }
+
+    public boolean getTriggersSupported() {
+        return triggersSupported;
+    }
+
+    public String buildUrl(ConnectParams params) {
+        if (!params.getConnection_string().trim().isEmpty()) {
+            return params.getConnection_string();
+        }
+        int port = params.getPort() > 0 ? params.getPort() : defaultPort;
+        String base = urlTemplate
+            .replace("{host}", params.getHost())
+            .replace("{port}", Integer.toString(port))
+            .replace("{database}", params.getDatabase());
+        return appendUrlParams(base, params.getUrl_params());
+    }
+
+    public String quoteIdentifier(String identifier) {
+        return identifierQuote + identifier.replace(identifierQuote, identifierQuote + identifierQuote) + identifierQuote;
+    }
+
+    public String schemaSwitchSql(String schema) {
+        return schemaSwitchSql(schema, identifierQuote);
+    }
+
+    public String schemaSwitchSql(String schema, String quote) {
+        if (skipExecutionContext) {
+            return "";
+        }
+        return schemaSwitchPrefix + " " + quote + schema.replace(quote, quote + quote) + quote;
+    }
+
+    private static String appendUrlParams(String url, String urlParams) {
+        String params = trimUrlParams(urlParams);
+        if (params.isEmpty()) {
+            return url;
+        }
+        if (usesColonProperties(url) && !params.endsWith(";")) {
+            params = params + ";";
+        }
+        String separator = urlParamSeparator(url);
+        return url + separator + params;
+    }
+
+    private static String trimUrlParams(String urlParams) {
+        String value = urlParams == null ? "" : urlParams.trim();
+        while (value.startsWith("?") || value.startsWith("&") || value.startsWith(";") || value.startsWith(":") || value.startsWith(",")) {
+            value = value.substring(1);
+        }
+        return value;
+    }
+
+    private static String urlParamSeparator(String url) {
+        if (startsWithIgnoreCase(url, "jdbc:sqlserver:") || startsWithIgnoreCase(url, "jdbc:exa:")) {
+            return url.endsWith(";") ? "" : ";";
+        }
+        if (startsWithIgnoreCase(url, "jdbc:teradata:")) {
+            return url.endsWith(",") ? "" : ",";
+        }
+        if (usesColonProperties(url)) {
+            if (url.endsWith(":") || url.endsWith(";")) {
+                return "";
+            }
+            return hasColonProperties(url) ? ";" : ":";
+        }
+        return url.contains("?") ? "&" : "?";
+    }
+
+    private static boolean usesColonProperties(String url) {
+        return startsWithIgnoreCase(url, "jdbc:db2:") || startsWithIgnoreCase(url, "jdbc:informix-sqli:");
+    }
+
+    private static boolean hasColonProperties(String url) {
+        int schemeEnd = url.indexOf("://");
+        if (schemeEnd < 0) {
+            return false;
+        }
+        int pathStart = url.indexOf('/', schemeEnd + 3);
+        if (pathStart < 0) {
+            return false;
+        }
+        return url.indexOf(':', pathStart + 1) >= 0;
+    }
+
+    private static boolean startsWithIgnoreCase(String value, String prefix) {
+        return value.regionMatches(true, 0, prefix, 0, prefix.length());
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java b/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java
new file mode 100644
index 0000000..cbd77dc
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java
@@ -0,0 +1,706 @@
+package com.dbx.agent;
+
+import java.sql.Connection;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.SQLXML;
+import java.sql.Statement;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+
+public final class JdbcExecutor {
+    public static final JdbcExecutor INSTANCE = new JdbcExecutor();
+    public static final int DEFAULT_MAX_ROWS = 10000;
+    public static final long QUERY_SESSION_IDLE_TIMEOUT_MILLIS = 10 * 60 * 1000L;
+
+    private final ConcurrentHashMap<String, QuerySession> sessions = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<String, QuerySession> tableReadSessions = new ConcurrentHashMap<>();
+
+    private JdbcExecutor() {
+    }
+
+    public QueryResult execute(Connection conn, String sql, String schema, Function<String, String> setSchemaSql) {
+        return execute(conn, sql, schema, setSchemaSql, DEFAULT_MAX_ROWS, null, this::defaultResultValue);
+    }
+
+    public QueryResult execute(
+        Connection conn,
+        String sql,
+        String schema,
+        Function<String, String> setSchemaSql,
+        int maxRows,
+        Integer fetchSize
+    ) {
+        return execute(conn, sql, schema, setSchemaSql, maxRows, fetchSize, this::defaultResultValue);
+    }
+
+    public QueryResult execute(
+        Connection conn,
+        String sql,
+        String schema,
+        Function<String, String> setSchemaSql,
+        int maxRows,
+        Integer fetchSize,
+        ResultValueReader valueReader
+    ) {
+        return execute(conn, sql, schema, setSchemaSql, maxRows, fetchSize, 0, valueReader);
+    }
+
+    public QueryResult execute(
+        Connection conn,
+        String sql,
+        String schema,
+        Function<String, String> setSchemaSql,
+        int maxRows,
+        Integer fetchSize,
+        int timeoutSecs,
+        ResultValueReader valueReader
+    ) {
+        return unchecked(() -> {
+            String trimmedSql = trimSql(sql);
+            long start = System.currentTimeMillis();
+
+            applySchema(conn, schema, setSchemaSql);
+
+            try (Statement stmt = conn.createStatement()) {
+                int effectiveMaxRows = Math.max(maxRows, 1);
+                stmt.setMaxRows(effectiveMaxRows + 1);
+                applyQueryTimeout(stmt, timeoutSecs);
+                if (fetchSize != null && fetchSize > 0) {
+                    stmt.setFetchSize(fetchSize);
+                }
+                // SQL dumps often contain BEGIN/COMMIT/ROLLBACK as executable statements.
+                // Do not translate them to Connection.commit(), which requires autoCommit=false.
+                boolean hasResultSet = stmt.execute(trimmedSql);
+                long elapsed = System.currentTimeMillis() - start;
+                if (hasResultSet) {
+                    try (ResultSet rs = stmt.getResultSet()) {
+                        return readResultSet(rs, elapsed, effectiveMaxRows, valueReader);
+                    }
+                }
+
+                int updateCount = stmt.getUpdateCount();
+                return new QueryResult(
+                    Collections.emptyList(),
+                    Collections.emptyList(),
+                    updateCount >= 0 ? updateCount : 0,
+                    elapsed,
+                    false
+                );
+            }
+        });
+    }
+
+    public QueryResult readResultSet(ResultSet rs, long executionTimeMs) {
+        return readResultSet(rs, executionTimeMs, DEFAULT_MAX_ROWS, this::defaultResultValue);
+    }
+
+    public QueryResult readResultSet(
+        ResultSet rs,
+        long executionTimeMs,
+        int maxRows,
+        ResultValueReader valueReader
+    ) {
+        return unchecked(() -> {
+            ResultSetMetaData meta = rs.getMetaData();
+            int colCount = meta.getColumnCount();
+            List<String> columns = new ArrayList<>(colCount);
+            List<String> columnTypes = new ArrayList<>(colCount);
+            // Cache JDBC column metadata once; some drivers resolve it lazily,
+            // and row reading is the hot path.
+            int[] sqlTypeByIndex = new int[colCount];
+            String[] typeNameByIndex = new String[colCount];
+            for (int i = 1; i <= colCount; i++) {
+                columns.add(meta.getColumnLabel(i));
+                sqlTypeByIndex[i - 1] = safeColumnSqlType(meta, i);
+                String typeName = safeColumnTypeName(meta, i);
+                columnTypes.add(typeName);
+                typeNameByIndex[i - 1] = typeName;
+            }
+
+            List<List<Object>> rows = new ArrayList<>(initialRowCapacity(maxRows));
+            boolean truncated = false;
+            while (rs.next()) {
+                if (rows.size() >= maxRows) {
+                    truncated = true;
+                    break;
+                }
+                rows.add(rowValues(rs, valueReader, sqlTypeByIndex, typeNameByIndex));
+            }
+
+            return new QueryResult(columns, columnTypes, rows, 0L, executionTimeMs, truncated);
+        });
+    }
+
+    public QueryPageResult executePage(
+        Connection conn,
+        String sql,
+        String schema,
+        Function<String, String> setSchemaSql
+    ) {
+        return executePage(conn, sql, schema, setSchemaSql, new QueryPageOptions(), this::defaultResultValue);
+    }
+
+    public QueryPageResult executePage(
+        Connection conn,
+        String sql,
+        String schema,
+        Function<String, String> setSchemaSql,
+        QueryPageOptions options
+    ) {
+        return executePage(conn, sql, schema, setSchemaSql, options, this::defaultResultValue);
+    }
+
+    public QueryPageResult executePage(
+        Connection conn,
+        String sql,
+        String schema,
+        Function<String, String> setSchemaSql,
+        QueryPageOptions options,
+        ResultValueReader valueReader
+    ) {
+        return executePage(conn, sql, schema, setSchemaSql, options, valueReader, sessions);
+    }
+
+    public QueryPageResult startTableRead(
+        Connection conn,
+        String sql,
+        String schema,
+        Function<String, String> setSchemaSql,
+        QueryPageOptions options,
+        ResultValueReader valueReader
+    ) {
+        return executePage(conn, sql, schema, setSchemaSql, options, valueReader, tableReadSessions);
+    }
+
+    private QueryPageResult executePage(
+        Connection conn,
+        String sql,
+        String schema,
+        Function<String, String> setSchemaSql,
+        QueryPageOptions options,
+        ResultValueReader valueReader,
+        ConcurrentHashMap<String, QuerySession> targetSessions
+    ) {
+        return unchecked(() -> {
+            expireIdleSessions(targetSessions, System.currentTimeMillis(), QUERY_SESSION_IDLE_TIMEOUT_MILLIS);
+            String trimmedSql = trimSql(sql);
+            long start = System.currentTimeMillis();
+
+            applySchema(conn, schema, setSchemaSql);
+
+            Statement stmt = conn.createStatement();
+            try {
+                applyQueryTimeout(stmt, options.getTimeoutSecs());
+                if (options.getFetchSize() != null && options.getFetchSize() > 0) {
+                    stmt.setFetchSize(options.getFetchSize());
+                }
+                // Keep script transaction-control statements in the SQL stream.
+                // JDBC transaction APIs are reserved for executeTransaction.
+                boolean hasResultSet = stmt.execute(trimmedSql);
+                long elapsed = System.currentTimeMillis() - start;
+                if (!hasResultSet) {
+                    int updateCount = stmt.getUpdateCount();
+                    stmt.close();
+                    return new QueryPageResult(
+                        Collections.emptyList(),
+                        Collections.emptyList(),
+                        updateCount >= 0 ? updateCount : 0,
+                        elapsed
+                    );
+                }
+
+                ResultSet rs = stmt.getResultSet();
+                ResultSetMetaData meta = rs.getMetaData();
+                String sessionId = UUID.randomUUID().toString();
+                int colCount = meta.getColumnCount();
+                List<String> columns = new ArrayList<>(colCount);
+                List<String> columnTypes = new ArrayList<>(colCount);
+                // Cache JDBC column metadata once; fetching a page should only read row values.
+                int[] sqlTypeByIndex = new int[colCount];
+                String[] typeNameByIndex = new String[colCount];
+                for (int i = 1; i <= colCount; i++) {
+                    columns.add(meta.getColumnLabel(i));
+                    sqlTypeByIndex[i - 1] = safeColumnSqlType(meta, i);
+                    String typeName = safeColumnTypeName(meta, i);
+                    columnTypes.add(typeName);
+                    typeNameByIndex[i - 1] = typeName;
+                }
+                QuerySession session = new QuerySession(
+                    sessionId,
+                    stmt,
+                    rs,
+                    columns,
+                    columnTypes,
+                    sqlTypeByIndex,
+                    typeNameByIndex,
+                    Math.max(options.getMaxRows(), 1),
+                    valueReader
+                );
+                targetSessions.put(sessionId, session);
+                return readSessionPage(targetSessions, session, options.getPageSize(), elapsed);
+            } catch (Exception e) {
+                try {
+                    stmt.close();
+                } catch (Exception ignored) {
+                }
+                throw e;
+            }
+        });
+    }
+
+    public QueryPageResult fetchPage(String sessionId, int pageSize) {
+        expireIdleQuerySessions();
+        return fetchSessionPage(sessions, sessionId, pageSize, "Query session not found");
+    }
+
+    public boolean closeQuerySession(String sessionId) {
+        return closeSession(sessions, sessionId);
+    }
+
+    public QueryPageResult fetchTableReadPage(String sessionId, int pageSize) {
+        expireIdleTableReadSessions();
+        return fetchSessionPage(tableReadSessions, sessionId, pageSize, "Table read session not found");
+    }
+
+    public boolean closeTableReadSession(String sessionId) {
+        return closeSession(tableReadSessions, sessionId);
+    }
+
+    public void closeAllQuerySessions() {
+        closeAllSessions(sessions);
+    }
+
+    public void closeAllTableReadSessions() {
+        closeAllSessions(tableReadSessions);
+    }
+
+    public int expireIdleQuerySessions() {
+        return expireIdleQuerySessions(System.currentTimeMillis(), QUERY_SESSION_IDLE_TIMEOUT_MILLIS);
+    }
+
+    public int expireIdleQuerySessions(long nowMillis, long idleTimeoutMillis) {
+        return expireIdleSessions(sessions, nowMillis, idleTimeoutMillis);
+    }
+
+    public int expireIdleTableReadSessions() {
+        return expireIdleTableReadSessions(System.currentTimeMillis(), QUERY_SESSION_IDLE_TIMEOUT_MILLIS);
+    }
+
+    public int expireIdleTableReadSessions(long nowMillis, long idleTimeoutMillis) {
+        return expireIdleSessions(tableReadSessions, nowMillis, idleTimeoutMillis);
+    }
+
+    private int expireIdleSessions(
+        ConcurrentHashMap<String, QuerySession> targetSessions,
+        long nowMillis,
+        long idleTimeoutMillis
+    ) {
+        if (idleTimeoutMillis < 0) {
+            return 0;
+        }
+        int closed = 0;
+        List<QuerySession> snapshot = new ArrayList<>(targetSessions.values());
+        for (QuerySession session : snapshot) {
+            boolean expired;
+            synchronized (session) {
+                expired = nowMillis - session.lastAccessedAtMillis >= idleTimeoutMillis;
+            }
+            if (expired && closeSession(targetSessions, session.id)) {
+                closed += 1;
+            }
+        }
+        return closed;
+    }
+
+    public Object defaultResultValue(ResultSet rs, int index, int sqlType) throws SQLException {
+        Object value;
+        switch (sqlType) {
+            case Types.BIGINT:
+                value = rs.getLong(index);
+                break;
+            case Types.INTEGER:
+            case Types.SMALLINT:
+            case Types.TINYINT:
+                value = rs.getInt(index);
+                break;
+            case Types.FLOAT:
+            case Types.REAL:
+                value = rs.getFloat(index);
+                break;
+            case Types.DOUBLE:
+                value = rs.getDouble(index);
+                break;
+            case Types.DECIMAL:
+            case Types.NUMERIC:
+                value = rs.getBigDecimal(index);
+                break;
+            case Types.BOOLEAN:
+            case Types.BIT:
+                value = rs.getBoolean(index);
+                break;
+            case Types.CHAR:
+            case Types.VARCHAR:
+            case Types.LONGVARCHAR:
+            case Types.NCHAR:
+            case Types.NVARCHAR:
+            case Types.LONGNVARCHAR:
+            case Types.CLOB:
+            case Types.NCLOB:
+                value = rs.getString(index);
+                break;
+            case Types.BINARY:
+            case Types.VARBINARY:
+            case Types.LONGVARBINARY:
+            case Types.BLOB:
+                value = bytesToHex(rs.getBytes(index));
+                break;
+            case Types.SQLXML:
+                value = sqlXmlToString(rs.getSQLXML(index));
+                break;
+            default:
+                value = normalizeResultValue(rs.getObject(index));
+                break;
+        }
+        return rs.wasNull() ? null : value;
+    }
+
+    public static Object stringResultValue(ResultSet rs, int index, int sqlType) throws SQLException {
+        Object value;
+        switch (sqlType) {
+            case Types.BINARY:
+            case Types.VARBINARY:
+            case Types.LONGVARBINARY:
+            case Types.BLOB:
+                value = bytesToHex(rs.getBytes(index));
+                break;
+            case Types.SQLXML:
+                value = sqlXmlToString(rs.getSQLXML(index));
+                break;
+            default:
+                value = rs.getString(index);
+                break;
+        }
+        return rs.wasNull() ? null : value;
+    }
+
+    public static Object normalizeResultValue(Object value) throws SQLException {
+        if (value == null) {
+            return null;
+        }
+        if (value instanceof Clob) {
+            Clob clob = (Clob) value;
+            return clob.getSubString(1, Math.toIntExact(clob.length()));
+        }
+        if (value instanceof Blob) {
+            Blob blob = (Blob) value;
+            return bytesToHex(blob.getBytes(1, Math.toIntExact(blob.length())));
+        }
+        if (value instanceof SQLXML) {
+            SQLXML sqlxml = (SQLXML) value;
+            return sqlxml.getString();
+        }
+        if (value instanceof byte[]) {
+            byte[] bytes = (byte[]) value;
+            return bytesToHex(bytes);
+        }
+        return value instanceof Number || value instanceof Boolean ? value : value.toString();
+    }
+
+    public static String bytesToHex(byte[] bytes) {
+        if (bytes == null) {
+            return null;
+        }
+        StringBuilder result = new StringBuilder(bytes.length * 2 + 2);
+        result.append("0x");
+        for (byte b : bytes) {
+            result.append(Character.forDigit((b >> 4) & 0xF, 16));
+            result.append(Character.forDigit(b & 0xF, 16));
+        }
+        return result.toString();
+    }
+
+    private static String sqlXmlToString(SQLXML value) throws SQLException {
+        return value == null ? null : value.getString();
+    }
+
+    private QueryPageResult fetchSessionPage(
+        ConcurrentHashMap<String, QuerySession> targetSessions,
+        String sessionId,
+        int pageSize,
+        String missingMessage
+    ) {
+        QuerySession session = targetSessions.get(sessionId);
+        if (session == null) {
+            throw new IllegalArgumentException(missingMessage);
+        }
+        synchronized (session) {
+            return readSessionPage(targetSessions, session, pageSize, 0L);
+        }
+    }
+
+    private QueryPageResult readSessionPage(
+        ConcurrentHashMap<String, QuerySession> targetSessions,
+        QuerySession session,
+        int pageSize,
+        long executionTimeMs
+    ) {
+        return unchecked(() -> {
+            session.lastAccessedAtMillis = System.currentTimeMillis();
+            int effectivePageSize = Math.max(pageSize, 1);
+            List<List<Object>> rows = new ArrayList<>(initialRowCapacity(effectivePageSize));
+
+            if (session.pendingRow != null) {
+                rows.add(session.pendingRow);
+                session.pendingRow = null;
+            }
+
+            while (rows.size() < effectivePageSize && session.rowsRead < session.maxRows) {
+                if (!session.resultSet.next()) {
+                    closeSession(targetSessions, session.id);
+                    return new QueryPageResult(session.columns, session.columnTypes, rows, 0L, executionTimeMs, false, null, false);
+                }
+                rows.add(rowValues(session.resultSet, session.valueReader, session.sqlTypeByIndex, session.typeNameByIndex));
+                session.rowsRead += 1;
+            }
+
+            if (session.rowsRead >= session.maxRows) {
+                boolean truncated = session.resultSet.next();
+                closeSession(targetSessions, session.id);
+                return new QueryPageResult(session.columns, session.columnTypes, rows, 0L, executionTimeMs, truncated, null, false);
+            }
+
+            boolean hasMore = session.resultSet.next();
+            if (!hasMore) {
+                closeSession(targetSessions, session.id);
+                return new QueryPageResult(session.columns, session.columnTypes, rows, 0L, executionTimeMs, false, null, false);
+            }
+
+            session.pendingRow = rowValues(session.resultSet, session.valueReader, session.sqlTypeByIndex, session.typeNameByIndex);
+            session.rowsRead += 1;
+            return new QueryPageResult(session.columns, session.columnTypes, rows, 0L, executionTimeMs, false, session.id, true);
+        });
+    }
+
+    private void closeAllSessions(ConcurrentHashMap<String, QuerySession> targetSessions) {
+        List<String> ids = new ArrayList<>(targetSessions.keySet());
+        for (String id : ids) {
+            closeSession(targetSessions, id);
+        }
+    }
+
+    private boolean closeSession(ConcurrentHashMap<String, QuerySession> targetSessions, String sessionId) {
+        QuerySession session = targetSessions.remove(sessionId);
+        if (session == null) {
+            return false;
+        }
+        synchronized (session) {
+            try {
+                session.resultSet.close();
+            } catch (Exception ignored) {
+            }
+            try {
+                session.statement.close();
+            } catch (Exception ignored) {
+            }
+        }
+        return true;
+    }
+
+    static String safeColumnTypeName(ResultSetMetaData meta, int columnIndex) {
+        try {
+            String name = meta.getColumnTypeName(columnIndex);
+            return name == null ? "" : name;
+        } catch (SQLException ignored) {
+            return "";
+        }
+    }
+
+    static int safeColumnSqlType(ResultSetMetaData meta, int columnIndex) {
+        try {
+            return meta.getColumnType(columnIndex);
+        } catch (SQLException ignored) {
+            return Types.OTHER;
+        }
+    }
+
+    private List<Object> rowValues(
+        ResultSet rs,
+        ResultValueReader valueReader,
+        int[] sqlTypeByIndex,
+        String[] typeNameByIndex
+    ) throws SQLException {
+        int colCount = sqlTypeByIndex.length;
+        List<Object> row = new ArrayList<>(colCount);
+        for (int i = 1; i <= colCount; i++) {
+            int sqlType = sqlTypeByIndex[i - 1];
+            Object value;
+            if (valueReader instanceof ColumnAwareResultValueReader) {
+                String typeName = typeNameByIndex != null && i - 1 < typeNameByIndex.length
+                    ? typeNameByIndex[i - 1]
+                    : "";
+                value = ((ColumnAwareResultValueReader) valueReader).read(rs, i, sqlType, typeName);
+            } else {
+                value = valueReader.read(rs, i, sqlType);
+            }
+            row.add(value);
+        }
+        return row;
+    }
+
+    private static int initialRowCapacity(int requestedRows) {
+        if (requestedRows <= 0) {
+            return 0;
+        }
+        return Math.min(requestedRows, 1024);
+    }
+
+    private void applySchema(Connection conn, String schema, Function<String, String> setSchemaSql) throws SQLException {
+        try {
+            JdbcSchemaSwitcher.apply(conn, schema, setSchemaSql);
+        } catch (SQLException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new SQLException(e);
+        }
+    }
+
+    private static void applyQueryTimeout(Statement stmt, int timeoutSecs) throws SQLException {
+        if (timeoutSecs > 0) {
+            stmt.setQueryTimeout(timeoutSecs);
+        }
+    }
+
+    private QueryResult emptyQueryResult(long start) {
+        return new QueryResult(
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0L,
+            System.currentTimeMillis() - start
+        );
+    }
+
+    private QueryPageResult emptyQueryPageResult(long start) {
+        return new QueryPageResult(
+            Collections.emptyList(),
+            Collections.emptyList(),
+            0L,
+            System.currentTimeMillis() - start
+        );
+    }
+
+    static String trimSql(String sql) {
+        String trimmed = stripTrailingSlashDelimiter(sql.trim());
+        if (isPlSqlBlock(trimmed)) {
+            return trimmed;
+        }
+        while (trimmed.endsWith(";")) {
+            trimmed = trimmed.substring(0, trimmed.length() - 1).trim();
+        }
+        return trimmed;
+    }
+
+    private static String stripTrailingSlashDelimiter(String sql) {
+        String trimmed = sql.trim();
+        if (!trimmed.endsWith("/")) {
+            return trimmed;
+        }
+        int slashStart = trimmed.length() - 1;
+        int lineStart = trimmed.lastIndexOf('\n', slashStart - 1) + 1;
+        if (!trimmed.substring(lineStart, slashStart).trim().isEmpty()) {
+            return trimmed;
+        }
+        String beforeSlash = trimmed.substring(0, lineStart).trim();
+        return isPlSqlBlock(beforeSlash) ? beforeSlash : trimmed;
+    }
+
+    private static boolean isPlSqlBlock(String sql) {
+        String upperSql = sql.toUpperCase(Locale.ROOT).trim();
+        if (!upperSql.startsWith("DECLARE") && !upperSql.startsWith("BEGIN")) {
+            return false;
+        }
+        return upperSql.matches("(?s).*\\bEND\\s+(?!IF\\b|LOOP\\b|CASE\\b)[A-Z0-9_$#]+\\s*;\\s*$")
+            || upperSql.matches("(?s).*\\bEND\\s*;\\s*$");
+    }
+
+    private static <T> T unchecked(ThrowingSupplier<T> supplier) {
+        try {
+            return supplier.get();
+        } catch (RuntimeException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @FunctionalInterface
+    public interface ResultValueReader {
+        Object read(ResultSet rs, int index, int sqlType) throws SQLException;
+    }
+
+    /**
+     * Optional extension of {@link ResultValueReader} that exposes the JDBC
+     * {@code getColumnTypeName} alongside the SQL type code, allowing per-driver
+     * agents to convert vendor-specific column types (e.g. PostGIS
+     * {@code geometry}) without re-querying the metadata.
+     */
+    public interface ColumnAwareResultValueReader extends ResultValueReader {
+        Object read(ResultSet rs, int index, int sqlType, String columnTypeName) throws SQLException;
+
+        @Override
+        default Object read(ResultSet rs, int index, int sqlType) throws SQLException {
+            return read(rs, index, sqlType, safeColumnTypeName(rs.getMetaData(), index));
+        }
+    }
+
+    private interface ThrowingSupplier<T> {
+        T get() throws Exception;
+    }
+
+    private static final class QuerySession {
+        private final String id;
+        private final Statement statement;
+        private final ResultSet resultSet;
+        private final List<String> columns;
+        private final List<String> columnTypes;
+        private final int[] sqlTypeByIndex;
+        private final String[] typeNameByIndex;
+        private final int maxRows;
+        private final ResultValueReader valueReader;
+        private int rowsRead;
+        private List<Object> pendingRow;
+        private long lastAccessedAtMillis;
+
+        private QuerySession(
+            String id,
+            Statement statement,
+            ResultSet resultSet,
+            List<String> columns,
+            List<String> columnTypes,
+            int[] sqlTypeByIndex,
+            String[] typeNameByIndex,
+            int maxRows,
+            ResultValueReader valueReader
+        ) {
+            this.id = id;
+            this.statement = statement;
+            this.resultSet = resultSet;
+            this.columns = columns;
+            this.columnTypes = columnTypes;
+            this.sqlTypeByIndex = sqlTypeByIndex;
+            this.typeNameByIndex = typeNameByIndex;
+            this.maxRows = maxRows;
+            this.valueReader = valueReader;
+            this.lastAccessedAtMillis = System.currentTimeMillis();
+        }
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/JdbcIdentifiers.java b/agents/common/src/main/java/com/dbx/agent/JdbcIdentifiers.java
new file mode 100644
index 0000000..92f34ec
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/JdbcIdentifiers.java
@@ -0,0 +1,16 @@
+package com.dbx.agent;
+
+public final class JdbcIdentifiers {
+    public static final JdbcIdentifiers INSTANCE = new JdbcIdentifiers();
+
+    private JdbcIdentifiers() {
+    }
+
+    public String doubleQuote(String identifier) {
+        return "\"" + identifier.replace("\"", "\"\"") + "\"";
+    }
+
+    public String backtick(String identifier) {
+        return "`" + identifier.replace("`", "``") + "`";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/JdbcSchemaSwitcher.java b/agents/common/src/main/java/com/dbx/agent/JdbcSchemaSwitcher.java
new file mode 100644
index 0000000..76ffa5a
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/JdbcSchemaSwitcher.java
@@ -0,0 +1,68 @@
+package com.dbx.agent;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.function.Function;
+
+final class JdbcSchemaSwitcher {
+    private JdbcSchemaSwitcher() {
+    }
+
+    static void apply(Connection conn, String schema, Function<String, String> setSchemaSql) throws Exception {
+        if (schema == null || schema.trim().isEmpty()) {
+            return;
+        }
+
+        SchemaSqlResult schemaSqlResult = applySchemaSql(conn, schema, setSchemaSql);
+        Exception schemaSqlError = schemaSqlResult.error;
+        if (schemaSqlError == null) {
+            return;
+        }
+
+        try {
+            conn.setSchema(schema);
+            return;
+        } catch (SQLException | AbstractMethodError ignored) {
+            // Some JDBC drivers only expose schema switching through SQL.
+        }
+        try {
+            conn.setCatalog(schema);
+            return;
+        } catch (SQLException | AbstractMethodError ignored) {
+            // Last fallback failed as well; surface the SQL-switch error below.
+        }
+
+        if (schemaSqlResult.attempted) {
+            throw schemaSqlError;
+        }
+    }
+
+    private static SchemaSqlResult applySchemaSql(Connection conn, String schema, Function<String, String> setSchemaSql) {
+        String schemaSql;
+        try {
+            schemaSql = setSchemaSql.apply(schema);
+        } catch (RuntimeException e) {
+            return new SchemaSqlResult(true, e);
+        }
+        if (schemaSql == null || schemaSql.trim().isEmpty()) {
+            return new SchemaSqlResult(false, new SQLException("No schema switch SQL provided"));
+        }
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute(schemaSql);
+            return new SchemaSqlResult(true, null);
+        } catch (SQLException | AbstractMethodError e) {
+            return new SchemaSqlResult(true, e instanceof SQLException ? (SQLException) e : new SQLException(e));
+        }
+    }
+
+    private static final class SchemaSqlResult {
+        private final boolean attempted;
+        private final Exception error;
+
+        private SchemaSqlResult(boolean attempted, Exception error) {
+            this.attempted = attempted;
+            this.error = error;
+        }
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/JsonRpcServer.java b/agents/common/src/main/java/com/dbx/agent/JsonRpcServer.java
new file mode 100644
index 0000000..b978a90
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/JsonRpcServer.java
@@ -0,0 +1,373 @@
+package com.dbx.agent;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonNull;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.JsonSerializer;
+import com.google.gson.reflect.TypeToken;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.lang.reflect.Type;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.sql.Connection;
+import java.util.Collections;
+import java.util.List;
+
+public final class JsonRpcServer {
+    private static final long CONNECTION_VALIDATION_INTERVAL_MILLIS = 5_000L;
+
+    private final DatabaseAgent agent;
+    private final Gson gson = new GsonBuilder()
+        // JDBC DECIMAL/NUMERIC values can exceed JavaScript Number precision after JSON-RPC parsing.
+        .registerTypeAdapter(
+            BigDecimal.class,
+            (JsonSerializer<BigDecimal>) (value, type, context) -> new JsonPrimitive(value.toPlainString())
+        )
+        .registerTypeAdapter(
+            BigInteger.class,
+            (JsonSerializer<BigInteger>) (value, type, context) -> new JsonPrimitive(value.toString())
+        )
+        .create();
+    private ConnectParams lastConnectParams;
+    private long lastConnectionValidationTimeMillis;
+
+    public JsonRpcServer(DatabaseAgent agent) {
+        this.agent = agent;
+    }
+
+    public void run() {
+        System.out.println("{\"ready\":true}");
+        System.out.flush();
+
+        try {
+            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+            while (true) {
+                String line = reader.readLine();
+                if (line == null) {
+                    break;
+                }
+                String response = handleRequest(line);
+                System.out.println(response);
+                System.out.flush();
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    String handleRequest(String line) {
+        JsonObject req = JsonParser.parseString(line).getAsJsonObject();
+        JsonElement id = req.get("id");
+        String method = req.get("method").getAsString();
+        JsonObject params = paramsObject(req);
+
+        JsonObject response = new JsonObject();
+        response.addProperty("jsonrpc", "2.0");
+        response.add("id", id);
+
+        try {
+            Object result = dispatch(method, params);
+            response.add("result", gson.toJsonTree(result));
+            return gson.toJson(response);
+        } catch (Throwable e) {
+            JsonObject error = new JsonObject();
+            error.addProperty("code", -1);
+            error.addProperty("message", e.getMessage() == null ? e.toString() : e.getMessage());
+            response.add("error", error);
+            return gson.toJson(response);
+        }
+    }
+
+    private Object dispatch(String method, JsonObject params) throws Exception {
+        if (AgentProtocol.METHOD_HANDSHAKE.equals(method)) {
+            return AgentProtocol.handshakeResult();
+        }
+        if (AgentProtocol.METHOD_CONNECT.equals(method)) {
+            lastConnectParams = gson.fromJson(params, ConnectParams.class);
+            agent.connect(lastConnectParams);
+            lastConnectionValidationTimeMillis = 0L;
+            return Collections.singletonMap("ok", true);
+        }
+        if (AgentProtocol.METHOD_TEST_CONNECTION.equals(method)) {
+            if (!agent.testConnection(gson.fromJson(params, ConnectParams.class))) {
+                throw new RuntimeException("Connection failed");
+            }
+            return Collections.singletonMap("ok", true);
+        }
+        if (AgentProtocol.METHOD_VALIDATE_CONNECTION.equals(method)) {
+            Connection conn = agent.getConnection();
+            boolean valid = false;
+            if (conn != null) {
+                try {
+                    valid = !conn.isClosed() && conn.isValid(2);
+                } catch (Exception ignored) {
+                }
+            }
+            if (!valid) {
+                throw new IllegalStateException("Connection is not valid");
+            }
+            return Collections.singletonMap("ok", true);
+        }
+        ensureLiveConnection(method);
+        if (AgentProtocol.METHOD_LIST_DATABASES.equals(method)) {
+            return agent.listDatabases();
+        }
+        if (AgentProtocol.METHOD_LIST_SCHEMAS.equals(method)) {
+            switchCatalog(params);
+            return agent.listSchemas(stringListOrNull(params, "visible_schemas"));
+        }
+        if (AgentProtocol.METHOD_LIST_TABLES.equals(method)) {
+            switchCatalog(params);
+            return agent.listTables(params.get("schema").getAsString(), metadataListConstraints(params));
+        }
+        if (AgentProtocol.METHOD_LIST_OBJECTS.equals(method)) {
+            switchCatalog(params);
+            return agent.listObjects(params.get("schema").getAsString(), metadataListConstraints(params));
+        }
+        if (AgentProtocol.METHOD_LIST_DATA_TYPES.equals(method)) {
+            switchCatalog(params);
+            return agent.listDataTypes();
+        }
+        if (AgentProtocol.METHOD_COMPLETION_ASSISTANT_SEARCH_V1.equals(method)) {
+            switchCatalog(params);
+            return agent.completionAssistantSearch(gson.fromJson(params, CompletionAssistantRequest.class));
+        }
+        if (AgentProtocol.METHOD_GET_OBJECT_SOURCE.equals(method)) {
+            switchCatalog(params);
+            return agent.getObjectSource(
+                params.get("schema").getAsString(),
+                params.get("name").getAsString(),
+                params.get("object_type").getAsString()
+            );
+        }
+        if (AgentProtocol.METHOD_GET_TABLE_DDL.equals(method)) {
+            switchCatalog(params);
+            return agent.getTableDdl(params.get("schema").getAsString(), params.get("table").getAsString());
+        }
+        if (AgentProtocol.METHOD_GET_COLUMNS.equals(method)) {
+            switchCatalog(params);
+            return agent.getColumns(params.get("schema").getAsString(), params.get("table").getAsString());
+        }
+        if (AgentProtocol.METHOD_LIST_INDEXES.equals(method)) {
+            switchCatalog(params);
+            return agent.listIndexes(params.get("schema").getAsString(), params.get("table").getAsString());
+        }
+        if (AgentProtocol.METHOD_LIST_FOREIGN_KEYS.equals(method)) {
+            switchCatalog(params);
+            return agent.listForeignKeys(params.get("schema").getAsString(), params.get("table").getAsString());
+        }
+        if (AgentProtocol.METHOD_LIST_TRIGGERS.equals(method)) {
+            switchCatalog(params);
+            return agent.listTriggers(params.get("schema").getAsString(), params.get("table").getAsString());
+        }
+        if (AgentProtocol.METHOD_EXECUTE_QUERY.equals(method)) {
+            return agent.executeQuery(
+                params.get("sql").getAsString(),
+                stringOrNull(params, "schema"),
+                new ExecuteQueryOptions(
+                    intOrDefault(params, "maxRows", JdbcExecutor.DEFAULT_MAX_ROWS),
+                    intOrNull(params, "fetchSize"),
+                    intOrDefault(params, "timeoutSecs", 0)
+                )
+            );
+        }
+        if (AgentProtocol.METHOD_EXECUTE_QUERY_PAGE.equals(method)) {
+            return agent.executeQueryPage(
+                params.get("sql").getAsString(),
+                stringOrNull(params, "schema"),
+                new QueryPageOptions(
+                    intOrDefault(params, "pageSize", 100),
+                    intOrNull(params, "fetchSize"),
+                    intOrDefault(params, "maxRows", JdbcExecutor.DEFAULT_MAX_ROWS),
+                    intOrDefault(params, "timeoutSecs", 0)
+                )
+            );
+        }
+        if (AgentProtocol.METHOD_FETCH_QUERY_PAGE.equals(method)) {
+            return agent.fetchQueryPage(
+                params.get("sessionId").getAsString(),
+                intOrDefault(params, "pageSize", 100)
+            );
+        }
+        if (AgentProtocol.METHOD_CLOSE_QUERY_SESSION.equals(method)) {
+            return agent.closeQuerySession(params.get("sessionId").getAsString());
+        }
+        if (AgentProtocol.METHOD_START_TABLE_READ.equals(method)) {
+            return agent.startTableRead(
+                params.get("sql").getAsString(),
+                stringOrNull(params, "schema"),
+                new QueryPageOptions(
+                    intOrDefault(params, "pageSize", 100),
+                    intOrNull(params, "fetchSize"),
+                    intOrDefault(params, "maxRows", JdbcExecutor.DEFAULT_MAX_ROWS),
+                    intOrDefault(params, "timeoutSecs", 0)
+                )
+            );
+        }
+        if (AgentProtocol.METHOD_FETCH_TABLE_READ_PAGE.equals(method)) {
+            return agent.fetchTableReadPage(
+                params.get("sessionId").getAsString(),
+                intOrDefault(params, "pageSize", 100)
+            );
+        }
+        if (AgentProtocol.METHOD_CLOSE_TABLE_READ_SESSION.equals(method)) {
+            return agent.closeTableReadSession(params.get("sessionId").getAsString());
+        }
+        if (AgentProtocol.METHOD_GET_EXPLAIN_INFO.equals(method)) {
+            String plan = agent.getExplainInfo(
+                params.get("sql").getAsString(),
+                stringOrNull(params, "database"),
+                stringOrNull(params, "schema"),
+                intOrDefault(params, "timeoutSecs", -1),
+                stringOrNull(params, "mode")
+            );
+            java.util.HashMap<String, Object> result = new java.util.HashMap<>();
+            result.put("plan", plan);
+            result.put("has_actual_stats", "autotrace".equals(stringOrNull(params, "mode")));
+            return result;
+        }
+        if (AgentProtocol.METHOD_EXECUTE_TRANSACTION.equals(method)) {
+            Type statementsType = new TypeToken<List<String>>() {}.getType();
+            List<String> statements = gson.fromJson(params.get("statements"), statementsType);
+            return agent.executeTransaction(statements, stringOrNull(params, "schema"));
+        }
+        if (AgentProtocol.METHOD_EXECUTE_BATCH.equals(method)) {
+            Type statementsType = new TypeToken<List<String>>() {}.getType();
+            List<String> statements = gson.fromJson(params.get("statements"), statementsType);
+            return agent.executeBatch(statements, stringOrNull(params, "schema"));
+        }
+        if (AgentProtocol.METHOD_DISCONNECT.equals(method)) {
+            JdbcExecutor.INSTANCE.closeAllQuerySessions();
+            JdbcExecutor.INSTANCE.closeAllTableReadSessions();
+            agent.disconnect();
+            lastConnectParams = null;
+            return Collections.singletonMap("ok", true);
+        }
+        if (AgentProtocol.METHOD_SHUTDOWN.equals(method)) {
+            JdbcExecutor.INSTANCE.closeAllQuerySessions();
+            JdbcExecutor.INSTANCE.closeAllTableReadSessions();
+            agent.disconnect();
+            lastConnectParams = null;
+            System.exit(0);
+            return Collections.singletonMap("ok", true);
+        }
+        throw new IllegalArgumentException("Unknown method: " + method);
+    }
+
+    private void switchCatalog(JsonObject params) throws Exception {
+        String database = stringOrNull(params, "database");
+        if (database != null && !database.trim().isEmpty() && agent.getConnection() != null) {
+            String currentCatalog = null;
+            try {
+                currentCatalog = agent.getConnection().getCatalog();
+            } catch (Exception ignored) {
+            }
+            if (currentCatalog == null || !currentCatalog.trim().equalsIgnoreCase(database.trim())) {
+                try {
+                    agent.getConnection().setCatalog(database);
+                } catch (Exception ignored) {
+                }
+            }
+        }
+    }
+
+    private void ensureLiveConnection(String method) {
+        if (lastConnectParams == null || !shouldValidateConnection(method)) {
+            return;
+        }
+        Connection conn = agent.getConnection();
+        if (conn == null) {
+            return;
+        }
+        long now = System.currentTimeMillis();
+        if (lastConnectionValidationTimeMillis > 0
+            && now - lastConnectionValidationTimeMillis < CONNECTION_VALIDATION_INTERVAL_MILLIS) {
+            return;
+        }
+        boolean valid = false;
+        try {
+            valid = !conn.isClosed() && conn.isValid(2);
+        } catch (Exception ignored) {
+        }
+        if (valid) {
+            lastConnectionValidationTimeMillis = now;
+            return;
+        }
+
+        JdbcExecutor.INSTANCE.closeAllQuerySessions();
+        JdbcExecutor.INSTANCE.closeAllTableReadSessions();
+        try {
+            agent.disconnect();
+        } catch (Exception ignored) {
+        }
+        agent.connect(lastConnectParams);
+        lastConnectionValidationTimeMillis = System.currentTimeMillis();
+    }
+
+    private static boolean shouldValidateConnection(String method) {
+        return !AgentProtocol.METHOD_HANDSHAKE.equals(method)
+            && !AgentProtocol.METHOD_CONNECT.equals(method)
+            && !AgentProtocol.METHOD_TEST_CONNECTION.equals(method)
+            && !AgentProtocol.METHOD_VALIDATE_CONNECTION.equals(method)
+            && !AgentProtocol.METHOD_FETCH_QUERY_PAGE.equals(method)
+            && !AgentProtocol.METHOD_CLOSE_QUERY_SESSION.equals(method)
+            && !AgentProtocol.METHOD_FETCH_TABLE_READ_PAGE.equals(method)
+            && !AgentProtocol.METHOD_CLOSE_TABLE_READ_SESSION.equals(method)
+            && !AgentProtocol.METHOD_DISCONNECT.equals(method)
+            && !AgentProtocol.METHOD_SHUTDOWN.equals(method);
+    }
+
+    private static JsonObject paramsObject(JsonObject req) {
+        JsonElement params = req.get("params");
+        if (params == null || params instanceof JsonNull || !params.isJsonObject()) {
+            return new JsonObject();
+        }
+        return params.getAsJsonObject();
+    }
+
+    private static String stringOrNull(JsonObject object, String key) {
+        JsonElement element = object.get(key);
+        if (element == null || element instanceof JsonNull) {
+            return null;
+        }
+        return element.getAsString();
+    }
+
+    private List<String> stringListOrNull(JsonObject object, String key) {
+        JsonElement element = object.get(key);
+        if (element == null || element instanceof JsonNull) {
+            return null;
+        }
+        Type listType = new TypeToken<List<String>>() {}.getType();
+        return gson.fromJson(element, listType);
+    }
+
+    private static Integer intOrNull(JsonObject object, String key) {
+        JsonElement element = object.get(key);
+        if (element == null || element instanceof JsonNull) {
+            return null;
+        }
+        return element.getAsInt();
+    }
+
+    private MetadataListConstraints metadataListConstraints(JsonObject params) {
+        return new MetadataListConstraints(
+            stringOrNull(params, "filter"),
+            intOrNull(params, "limit"),
+            intOrNull(params, "offset"),
+            stringListOrNull(params, "object_types")
+        );
+    }
+
+    private static int intOrDefault(JsonObject object, String key, int defaultValue) {
+        Integer value = intOrNull(object, key);
+        return value == null ? defaultValue : value;
+    }
+
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/MetadataListConstraints.java b/agents/common/src/main/java/com/dbx/agent/MetadataListConstraints.java
new file mode 100644
index 0000000..9e8b4f0
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/MetadataListConstraints.java
@@ -0,0 +1,221 @@
+package com.dbx.agent;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+public final class MetadataListConstraints {
+    public static final MetadataListConstraints NONE = new MetadataListConstraints(null, null, null, null);
+
+    private final String filter;
+    private final Integer limit;
+    private final Integer offset;
+    private final List<String> objectTypes;
+
+    public MetadataListConstraints(String filter, Integer limit, Integer offset, List<String> objectTypes) {
+        this.filter = normalizeFilter(filter);
+        this.limit = limit == null || limit <= 0 ? null : limit;
+        this.offset = offset == null || offset <= 0 ? null : offset;
+        this.objectTypes = normalizeObjectTypes(objectTypes);
+    }
+
+    public static MetadataListConstraints orNone(MetadataListConstraints constraints) {
+        return constraints == null ? NONE : constraints;
+    }
+
+    public String getFilter() {
+        return filter;
+    }
+
+    public Integer getLimit() {
+        return limit;
+    }
+
+    public Integer getOffset() {
+        return offset;
+    }
+
+    public List<String> getObjectTypes() {
+        return objectTypes.isEmpty() ? null : objectTypes;
+    }
+
+    public boolean hasFilter() {
+        return !filter.isEmpty();
+    }
+
+    public boolean hasLimit() {
+        return limit != null;
+    }
+
+    public boolean hasOffset() {
+        return offset != null;
+    }
+
+    public boolean hasObjectTypes() {
+        return !objectTypes.isEmpty();
+    }
+
+    public MetadataListConstraints withoutPaging() {
+        return new MetadataListConstraints(filter, null, null, objectTypes);
+    }
+
+    public String fuzzyLikePattern() {
+        if (filter.isEmpty()) {
+            return "%%";
+        }
+        StringBuilder builder = new StringBuilder(filter.length() * 2 + 2);
+        builder.append('%');
+        for (int i = 0; i < filter.length(); i++) {
+            char ch = filter.charAt(i);
+            if (ch == '\\' || ch == '%' || ch == '_') {
+                builder.append('\\');
+            }
+            builder.append(ch);
+            builder.append('%');
+        }
+        return builder.toString();
+    }
+
+    public boolean includesTableLikeTypes() {
+        if (objectTypes.isEmpty()) {
+            return true;
+        }
+        return objectTypes.contains("TABLE")
+            || objectTypes.contains("VIEW")
+            || objectTypes.contains("MATERIALIZED_VIEW");
+    }
+
+    public boolean tableTypeAllowed(String tableType) {
+        if (objectTypes.isEmpty()) {
+            return true;
+        }
+        return objectTypes.contains(normalizeTableType(tableType));
+    }
+
+    public boolean objectTypeAllowed(String objectType) {
+        if (objectTypes.isEmpty()) {
+            return true;
+        }
+        String normalized = normalizeObjectType(objectType);
+        return !normalized.isEmpty() && objectTypes.contains(normalized);
+    }
+
+    public boolean nameMatches(String name) {
+        return textMatches(name);
+    }
+
+    public boolean nameOrCommentMatches(String name, String comment) {
+        return textMatches(name) || textMatches(comment);
+    }
+
+    private boolean textMatches(String text) {
+        if (filter.isEmpty()) {
+            return true;
+        }
+        if (text == null) {
+            return false;
+        }
+        String candidate = text.toLowerCase(Locale.ROOT);
+        return candidate.contains(filter) || (filter.length() >= 2 && fuzzySubsequenceMatches(candidate, filter));
+    }
+
+    public List<TableInfo> filterTables(List<TableInfo> tables) {
+        List<TableInfo> result = new ArrayList<>();
+        int skipped = 0;
+        int max = limit == null ? Integer.MAX_VALUE : limit;
+        int start = offset == null ? 0 : offset;
+        for (TableInfo table : tables) {
+            if (!nameOrCommentMatches(table.getName(), table.getComment())
+                || !tableTypeAllowed(table.getTable_type())) {
+                continue;
+            }
+            if (skipped++ < start) {
+                continue;
+            }
+            if (result.size() >= max) {
+                break;
+            }
+            result.add(table);
+        }
+        return result;
+    }
+
+    public List<ObjectInfo> filterObjects(List<ObjectInfo> objects) {
+        List<ObjectInfo> result = new ArrayList<>();
+        int skipped = 0;
+        int max = limit == null ? Integer.MAX_VALUE : limit;
+        int start = offset == null ? 0 : offset;
+        for (ObjectInfo object : objects) {
+            if (!nameOrCommentMatches(object.getName(), object.getComment())
+                || !objectTypeAllowed(object.getObject_type())) {
+                continue;
+            }
+            if (skipped++ < start) {
+                continue;
+            }
+            if (result.size() >= max) {
+                break;
+            }
+            result.add(object);
+        }
+        return result;
+    }
+
+    private static String normalizeFilter(String value) {
+        if (value == null) {
+            return "";
+        }
+        return value.trim().toLowerCase(Locale.ROOT);
+    }
+
+    private static List<String> normalizeObjectTypes(List<String> values) {
+        if (values == null || values.isEmpty()) {
+            return Collections.emptyList();
+        }
+        List<String> result = new ArrayList<>();
+        for (String value : values) {
+            String normalized = normalizeObjectType(value);
+            if (!normalized.isEmpty() && !result.contains(normalized)) {
+                result.add(normalized);
+            }
+        }
+        Collections.sort(result);
+        return Collections.unmodifiableList(result);
+    }
+
+    private static String normalizeTableType(String value) {
+        String normalized = normalizeObjectType(value);
+        return normalized.isEmpty() ? "TABLE" : normalized;
+    }
+
+    private static String normalizeObjectType(String value) {
+        if (value == null || value.trim().isEmpty()) {
+            return "";
+        }
+        String upper = value.trim().toUpperCase(Locale.ROOT).replace(' ', '_');
+        if (upper.contains("MATERIALIZED") && upper.contains("VIEW")) {
+            return "MATERIALIZED_VIEW";
+        }
+        if (upper.equals("STABLE") || upper.equals("BASE_TABLE") || upper.contains("TABLE")) {
+            return "TABLE";
+        }
+        if (upper.contains("VIEW")) {
+            return "VIEW";
+        }
+        return upper;
+    }
+
+    private static boolean fuzzySubsequenceMatches(String candidate, String expected) {
+        int cursor = 0;
+        for (int i = 0; i < expected.length(); i++) {
+            char ch = expected.charAt(i);
+            cursor = candidate.indexOf(ch, cursor);
+            if (cursor < 0) {
+                return false;
+            }
+            cursor++;
+        }
+        return true;
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/MetadataSqlSupport.java b/agents/common/src/main/java/com/dbx/agent/MetadataSqlSupport.java
new file mode 100644
index 0000000..c5c85e0
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/MetadataSqlSupport.java
@@ -0,0 +1,95 @@
+package com.dbx.agent;
+
+import java.sql.PreparedStatement;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+public final class MetadataSqlSupport {
+    private MetadataSqlSupport() {
+    }
+
+    public static void appendNameFilter(StringBuilder sql, List<Object> args, String column, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (!normalized.hasFilter()) {
+            return;
+        }
+        sql.append(" AND UPPER(").append(column).append(") LIKE ? ESCAPE '\\\\'");
+        args.add(normalized.fuzzyLikePattern().toUpperCase(Locale.ROOT));
+    }
+
+    public static void appendLimitOffset(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (!normalized.hasLimit()) {
+            return;
+        }
+        sql.append(" LIMIT ?");
+        args.add(normalized.getLimit());
+        if (normalized.hasOffset()) {
+            sql.append(" OFFSET ?");
+            args.add(normalized.getOffset());
+        }
+    }
+
+    public static void appendOffsetFetch(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (normalized.hasOffset()) {
+            sql.append(" OFFSET ? ROWS");
+            args.add(normalized.getOffset());
+        }
+        if (normalized.hasLimit()) {
+            sql.append(normalized.hasOffset() ? " FETCH NEXT ? ROWS ONLY" : " FETCH FIRST ? ROWS ONLY");
+            args.add(normalized.getLimit());
+        }
+    }
+
+    public static void appendLiteralLimitOffset(StringBuilder sql, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (!normalized.hasLimit()) {
+            return;
+        }
+        sql.append(" LIMIT ").append(normalized.getLimit());
+        if (normalized.hasOffset()) {
+            sql.append(" OFFSET ").append(normalized.getOffset());
+        }
+    }
+
+    public static void appendLiteralOffsetFetch(StringBuilder sql, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (normalized.hasOffset()) {
+            sql.append(" OFFSET ").append(normalized.getOffset()).append(" ROWS");
+        }
+        if (normalized.hasLimit()) {
+            sql.append(normalized.hasOffset() ? " FETCH NEXT " : " FETCH FIRST ")
+                .append(normalized.getLimit())
+                .append(" ROWS ONLY");
+        }
+    }
+
+    public static void appendLiteralSkipFirst(StringBuilder sql, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (normalized.hasOffset()) {
+            sql.append("SKIP ").append(normalized.getOffset()).append(' ');
+        }
+        if (normalized.hasLimit()) {
+            sql.append("FIRST ").append(normalized.getLimit()).append(' ');
+        }
+    }
+
+    public static String placeholders(int count) {
+        return String.join(", ", Collections.nCopies(count, "?"));
+    }
+
+    public static void bind(PreparedStatement stmt, List<Object> args) throws Exception {
+        for (int index = 0; index < args.size(); index += 1) {
+            Object arg = args.get(index);
+            if (arg instanceof Integer) {
+                stmt.setInt(index + 1, (Integer) arg);
+            } else if (arg == null) {
+                stmt.setObject(index + 1, null);
+            } else {
+                stmt.setString(index + 1, String.valueOf(arg));
+            }
+        }
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/ObjectInfo.java b/agents/common/src/main/java/com/dbx/agent/ObjectInfo.java
new file mode 100644
index 0000000..00b2639
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/ObjectInfo.java
@@ -0,0 +1,82 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class ObjectInfo {
+    private String name;
+    private String object_type;
+    private String schema;
+    private String comment;
+
+    public ObjectInfo() {
+        this("", "", null, null);
+    }
+
+    public ObjectInfo(String name, String object_type) {
+        this(name, object_type, null, null);
+    }
+
+    public ObjectInfo(String name, String object_type, String schema, String comment) {
+        this.name = name;
+        this.object_type = object_type;
+        this.schema = schema;
+        this.comment = comment;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getObject_type() {
+        return object_type;
+    }
+
+    public String getSchema() {
+        return schema;
+    }
+
+    public String getComment() {
+        return comment;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setObject_type(String object_type) {
+        this.object_type = object_type;
+    }
+
+    public void setSchema(String schema) {
+        this.schema = schema;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof ObjectInfo)) return false;
+        ObjectInfo that = (ObjectInfo) other;
+        return Objects.equals(name, that.name)
+            && Objects.equals(object_type, that.object_type)
+            && Objects.equals(schema, that.schema)
+            && Objects.equals(comment, that.comment);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, object_type, schema, comment);
+    }
+
+    @Override
+    public String toString() {
+        return "ObjectInfo(name=" + name
+            + ", object_type=" + object_type
+            + ", schema=" + schema
+            + ", comment=" + comment
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/ObjectSource.java b/agents/common/src/main/java/com/dbx/agent/ObjectSource.java
new file mode 100644
index 0000000..13e9d25
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/ObjectSource.java
@@ -0,0 +1,98 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class ObjectSource {
+    private String name;
+    private String object_type;
+    private String schema;
+    private String source;
+    private boolean editable;
+
+    public ObjectSource() {
+        this("", "", null, "", true);
+    }
+
+    public ObjectSource(String name, String object_type, String source) {
+        this(name, object_type, null, source, true);
+    }
+
+    public ObjectSource(String name, String object_type, String schema, String source) {
+        this(name, object_type, schema, source, true);
+    }
+
+    public ObjectSource(String name, String object_type, String schema, String source, boolean editable) {
+        this.name = name;
+        this.object_type = object_type;
+        this.schema = schema;
+        this.source = source;
+        this.editable = editable;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getObject_type() {
+        return object_type;
+    }
+
+    public String getSchema() {
+        return schema;
+    }
+
+    public String getSource() {
+        return source;
+    }
+
+    public boolean isEditable() {
+        return editable;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setObject_type(String object_type) {
+        this.object_type = object_type;
+    }
+
+    public void setSchema(String schema) {
+        this.schema = schema;
+    }
+
+    public void setSource(String source) {
+        this.source = source;
+    }
+
+    public void setEditable(boolean editable) {
+        this.editable = editable;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof ObjectSource)) return false;
+        ObjectSource that = (ObjectSource) other;
+        return Objects.equals(name, that.name)
+            && Objects.equals(object_type, that.object_type)
+            && Objects.equals(schema, that.schema)
+            && Objects.equals(source, that.source)
+            && editable == that.editable;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, object_type, schema, source, editable);
+    }
+
+    @Override
+    public String toString() {
+        return "ObjectSource(name=" + name
+            + ", object_type=" + object_type
+            + ", schema=" + schema
+            + ", source=" + source
+            + ", editable=" + editable
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgent.java b/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgent.java
new file mode 100644
index 0000000..fa3bd15
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgent.java
@@ -0,0 +1,554 @@
+package com.dbx.agent;
+
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+public abstract class PostgresLikeAgent extends AbstractJdbcAgent {
+    private final PostgresLikeAgentProfile profile;
+    private boolean mysqlCompatMode = false;
+
+    protected PostgresLikeAgent(PostgresLikeAgentProfile profile) {
+        this.profile = profile;
+    }
+
+    public PostgresLikeAgentProfile getProfile() {
+        return profile;
+    }
+
+    public void setMysqlCompatMode(boolean mysqlCompatMode) {
+        this.mysqlCompatMode = mysqlCompatMode;
+    }
+
+    public boolean isMysqlCompatMode() {
+        return mysqlCompatMode;
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        return JdbcExecutor.INSTANCE.execute(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options.getMaxRows(),
+            options.getFetchSize(),
+            options.getTimeoutSecs(),
+            geometryAwareResolver()
+        );
+    }
+
+    @Override
+    public QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {
+        return JdbcExecutor.INSTANCE.executePage(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            geometryAwareResolver()
+        );
+    }
+
+    @Override
+    public QueryPageResult startTableRead(String sql, String schema, QueryPageOptions options) {
+        return JdbcExecutor.INSTANCE.startTableRead(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            geometryAwareResolver()
+        );
+    }
+
+    /**
+     * Wrap {@link AbstractJdbcAgent#resultValue} so PostGIS-style {@code geometry}
+     * and {@code geography} columns are decoded into WKT (matching the native
+     * tokio_postgres path in {@code crates/dbx-core/src/db/postgres.rs}).
+     */
+    private JdbcExecutor.ColumnAwareResultValueReader geometryAwareResolver() {
+        return (rs, index, sqlType, columnTypeName) -> {
+            if (isPostgisGeometryTypeName(columnTypeName)) {
+                Object raw = rs.getObject(index);
+                if (rs.wasNull() || raw == null) {
+                    return null;
+                }
+                return EwkbWktDecoder.decode(raw);
+            }
+            return resultValue(rs, index, sqlType, columnTypeName);
+        };
+    }
+
+    protected Object resultValue(ResultSet rs, int index, int sqlType, String columnTypeName) {
+        return resultValue(rs, index, sqlType);
+    }
+
+    static boolean isPostgisGeometryTypeName(String columnTypeName) {
+        if (columnTypeName == null) {
+            return false;
+        }
+        String trimmed = columnTypeName.trim().toLowerCase(Locale.ROOT);
+        if (trimmed.isEmpty()) {
+            return false;
+        }
+        // Strip optional schema prefix (e.g. "public.geometry") or "(srid,type)" suffix.
+        int dot = trimmed.lastIndexOf('.');
+        if (dot >= 0 && dot < trimmed.length() - 1) {
+            trimmed = trimmed.substring(dot + 1);
+        }
+        int paren = trimmed.indexOf('(');
+        if (paren >= 0) {
+            trimmed = trimmed.substring(0, paren);
+        }
+        return "geometry".equals(trimmed) || "geography".equals(trimmed);
+    }
+
+    private String quoteIdentifier(String identifier) {
+        return mysqlCompatMode
+            ? JdbcIdentifiers.INSTANCE.backtick(identifier)
+            : JdbcIdentifiers.INSTANCE.doubleQuote(identifier);
+    }
+
+    @Override
+    protected String driverClass() {
+        return profile.getDriverClass();
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return profile.buildUrl(params);
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement("SELECT datname FROM pg_database WHERE datistemplate = false ORDER BY datname");
+                 ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString("datname")));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return unchecked(() -> {
+            List<String> result = new ArrayList<>();
+            try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(
+                "SELECT n.nspname AS schema_name " +
+                "FROM pg_catalog.pg_namespace n " +
+                "WHERE n.nspname NOT IN ('pg_catalog','information_schema','pg_toast') " +
+                "AND n.nspname NOT LIKE 'pg_toast_temp_%' " +
+                "AND n.nspname NOT LIKE 'pg_temp_%' " +
+                "ORDER BY n.nspname"
+            ); ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    result.add(rs.getString("schema_name"));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(
+                "SELECT c.relname AS table_name, " +
+                "CASE c.relkind " +
+                "WHEN 'r' THEN 'TABLE' " +
+                "WHEN 'p' THEN 'TABLE' " +
+                "WHEN 'v' THEN 'VIEW' " +
+                "WHEN 'm' THEN 'MATERIALIZED VIEW' " +
+                "WHEN 'f' THEN 'FOREIGN TABLE' " +
+                "ELSE 'TABLE' END AS table_type, " +
+                "obj_description(c.oid) AS table_comment " +
+                "FROM pg_catalog.pg_class c " +
+                "JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace " +
+                "WHERE n.nspname = ? AND c.relkind IN ('r','p','v','m','f') " +
+                "ORDER BY c.relname"
+            )) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String tableType = normalizeTableType(rs.getString("table_type"));
+                        result.add(new TableInfo(rs.getString("table_name"), tableType, rs.getString("table_comment")));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            for (TableInfo table : listTables(schema)) {
+                result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+            }
+            try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(
+                "SELECT p.proname AS routine_name, " +
+                "CASE p.prokind WHEN 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END AS routine_type " +
+                "FROM pg_catalog.pg_proc p " +
+                "JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace " +
+                "WHERE n.nspname = ? AND p.prokind IN ('p','f') " +
+                "ORDER BY p.proname"
+            )) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1), rs.getString(2), schema, null));
+                    }
+                }
+            }
+            try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(
+                "SELECT c.relname AS sequence_name, 'SEQUENCE' AS object_type " +
+                "FROM pg_catalog.pg_class c " +
+                "JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace " +
+                "WHERE n.nspname = ? AND c.relkind = 'S' " +
+                "ORDER BY c.relname"
+            )) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1), rs.getString(2), schema, null));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public String getTableDdl(String schema, String table) {
+        List<IndexInfo> indexes;
+        try {
+            indexes = listIndexes(schema, table);
+        } catch (RuntimeException e) {
+            indexes = Collections.emptyList();
+        }
+
+        List<ForeignKeyInfo> foreignKeys;
+        try {
+            foreignKeys = listForeignKeys(schema, table);
+        } catch (RuntimeException e) {
+            foreignKeys = Collections.emptyList();
+        }
+
+        List<CheckConstraintInfo> checkConstraints;
+        try {
+            checkConstraints = listCheckConstraints(schema, table);
+        } catch (RuntimeException e) {
+            // Some PostgreSQL-compatible databases expose incomplete catalog APIs.
+            // DDL generation should still succeed with columns, indexes, and foreign keys.
+            checkConstraints = Collections.emptyList();
+        }
+
+        return DdlBuilder.buildTableDdl(
+            schema,
+            table,
+            getColumns(schema, table),
+            indexes,
+            foreignKeys,
+            checkConstraints,
+            mysqlCompatMode,
+            true
+        );
+    }
+
+    protected List<CheckConstraintInfo> listCheckConstraints(String schema, String table) {
+        return unchecked(() -> {
+            List<CheckConstraintInfo> result = new ArrayList<>();
+            String sql = "SELECT co.conname AS constraint_name, pg_catalog.pg_get_constraintdef(co.oid, true) AS constraint_definition " +
+                "FROM pg_catalog.pg_constraint co " +
+                "JOIN pg_catalog.pg_class c ON c.oid = co.conrelid " +
+                "JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace " +
+                "WHERE co.contype = 'c' AND n.nspname = ? AND c.relname = ? " +
+                "ORDER BY co.conname";
+            try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new CheckConstraintInfo(
+                            rs.getString("constraint_name"),
+                            rs.getString("constraint_definition")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        return unchecked(() -> {
+            String upperType = objectType.toUpperCase();
+            String sql;
+            if ("VIEW".equals(upperType) || "MATERIALIZED VIEW".equals(upperType)) {
+                sql = "SELECT pg_get_viewdef(to_regclass(?), true)";
+            } else if ("FUNCTION".equals(upperType)) {
+                sql = "SELECT pg_get_functiondef(p.oid)\n" +
+                    "FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace\n" +
+                    "WHERE n.nspname = ? AND p.proname = ? AND p.prokind = 'f'\n" +
+                    "ORDER BY p.oid LIMIT 1";
+            } else if ("PROCEDURE".equals(upperType)) {
+                sql = "SELECT pg_get_functiondef(p.oid)\n" +
+                    "FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace\n" +
+                    "WHERE n.nspname = ? AND p.proname = ? AND p.prokind = 'p'\n" +
+                    "ORDER BY p.oid LIMIT 1";
+            } else {
+                throw new IllegalArgumentException("Unsupported object type: " + objectType);
+            }
+
+            String source;
+            if ("VIEW".equals(upperType) || "MATERIALIZED VIEW".equals(upperType)) {
+                try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(sql)) {
+                    stmt.setString(1, quoteQualifiedIdentifier(schema, name));
+                    try (ResultSet rs = stmt.executeQuery()) {
+                        source = rs.next() ? coalesce(rs.getString(1)) : "";
+                    }
+                }
+            } else {
+                try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(sql)) {
+                    stmt.setString(1, schema);
+                    stmt.setString(2, name);
+                    try (ResultSet rs = stmt.executeQuery()) {
+                        source = rs.next() ? coalesce(rs.getString(1)) : "";
+                    }
+                }
+            }
+            return new ObjectSource(name, objectType, schema, source);
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            Set<String> primaryKeys = primaryKeys(schema, table);
+            List<ColumnInfo> result = new ArrayList<>();
+            String sql = "SELECT a.attname AS column_name, " +
+                "format_type(a.atttypid, a.atttypmod) AS data_type, " +
+                "NOT a.attnotnull AS is_nullable, " +
+                "pg_get_expr(ad.adbin, ad.adrelid) AS column_default, " +
+                "col_description(a.attrelid, a.attnum) AS column_comment, " +
+                "CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 " +
+                "THEN ((a.atttypmod - 4) >> 16) & 65535 ELSE NULL END AS numeric_precision, " +
+                "CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 " +
+                "THEN (a.atttypmod - 4) & 65535 ELSE NULL END AS numeric_scale, " +
+                "CASE WHEN t.typname IN ('varchar', 'bpchar') AND a.atttypmod > 0 " +
+                "THEN a.atttypmod - 4 ELSE NULL END AS character_maximum_length " +
+                "FROM pg_catalog.pg_attribute a " +
+                "JOIN pg_catalog.pg_type t ON t.oid = a.atttypid " +
+                "JOIN pg_catalog.pg_class c ON c.oid = a.attrelid " +
+                "JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace " +
+                "LEFT JOIN pg_catalog.pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum " +
+                "WHERE n.nspname = ? AND c.relname = ? " +
+                "AND a.attnum > 0 AND NOT a.attisdropped " +
+                "ORDER BY a.attnum";
+            try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String colName = rs.getString("column_name");
+                        result.add(new ColumnInfo(
+                            colName,
+                            rs.getString("data_type"),
+                            rs.getBoolean("is_nullable"),
+                            rs.getString("column_default"),
+                            primaryKeys.contains(colName),
+                            null,
+                            rs.getString("column_comment"),
+                            intObject(rs, "numeric_precision"),
+                            intObject(rs, "numeric_scale"),
+                            intObject(rs, "character_maximum_length")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    private Set<String> primaryKeys(String schema, String table) {
+        return unchecked(() -> {
+            Set<String> primaryKeys = new LinkedHashSet<>();
+            String sql = "SELECT a.attname AS column_name " +
+                "FROM pg_catalog.pg_constraint co " +
+                "JOIN pg_catalog.pg_class c ON c.oid = co.conrelid " +
+                "JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace " +
+                "JOIN LATERAL (SELECT unnest(co.conkey) AS attnum, generate_series(1, array_length(co.conkey, 1)) AS ord) AS pk_cols ON true " +
+                "JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid AND a.attnum = pk_cols.attnum " +
+                "WHERE co.contype = 'p' " +
+                "AND n.nspname = ? " +
+                "AND c.relname = ? " +
+                "ORDER BY pk_cols.ord";
+            try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        primaryKeys.add(rs.getString("column_name"));
+                    }
+                }
+            }
+            return primaryKeys;
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return unchecked(() -> {
+            List<IndexInfo> result = new ArrayList<>();
+            String sql = "SELECT i.relname AS index_name, am.amname AS index_type, " +
+                "ix.indisunique AS is_unique, ix.indisprimary AS is_primary, " +
+                "array_agg(a.attname ORDER BY k.n) AS columns " +
+                "FROM pg_index ix " +
+                "JOIN pg_class t ON t.oid = ix.indrelid " +
+                "JOIN pg_class i ON i.oid = ix.indexrelid " +
+                "JOIN pg_namespace n ON n.oid = t.relnamespace " +
+                "JOIN pg_am am ON am.oid = i.relam " +
+                "JOIN LATERAL (SELECT unnest(ix.indkey) AS attnum, generate_series(1, array_length(ix.indkey, 1)) AS n) AS k ON true " +
+                "JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum " +
+                "WHERE n.nspname = ? AND t.relname = ? " +
+                "GROUP BY i.relname, am.amname, ix.indisunique, ix.indisprimary " +
+                "ORDER BY i.relname";
+            try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        Object[] columnArray = (Object[]) rs.getArray("columns").getArray();
+                        List<String> columns = new ArrayList<>();
+                        for (Object column : columnArray) {
+                            columns.add(String.valueOf(column));
+                        }
+                        result.add(new IndexInfo(
+                            rs.getString("index_name"),
+                            columns,
+                            rs.getBoolean("is_unique"),
+                            rs.getBoolean("is_primary"),
+                            null,
+                            rs.getString("index_type"),
+                            null,
+                            null
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return unchecked(() -> {
+            List<ForeignKeyInfo> result = new ArrayList<>();
+            String sql = "SELECT co.conname AS constraint_name, " +
+                "a.attname AS column_name, " +
+                "rc.relname AS ref_table, " +
+                "ra.attname AS ref_column " +
+                "FROM pg_catalog.pg_constraint co " +
+                "JOIN pg_catalog.pg_class c ON c.oid = co.conrelid " +
+                "JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace " +
+                "JOIN pg_catalog.pg_class rc ON rc.oid = co.confrelid " +
+                "JOIN LATERAL (SELECT unnest(co.conkey) AS attnum, generate_series(1, array_length(co.conkey, 1)) AS ord) AS fk ON true " +
+                "JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid AND a.attnum = fk.attnum " +
+                "JOIN LATERAL (SELECT unnest(co.confkey) AS attnum, generate_series(1, array_length(co.confkey, 1)) AS ord) AS pk ON pk.ord = fk.ord " +
+                "JOIN pg_catalog.pg_attribute ra ON ra.attrelid = rc.oid AND ra.attnum = pk.attnum " +
+                "WHERE co.contype = 'f' " +
+                "AND n.nspname = ? " +
+                "AND c.relname = ? " +
+                "ORDER BY co.conname, fk.ord";
+            try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ForeignKeyInfo(
+                            rs.getString("constraint_name"),
+                            rs.getString("column_name"),
+                            rs.getString("ref_table"),
+                            rs.getString("ref_column")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return unchecked(() -> {
+            List<TriggerInfo> result = new ArrayList<>();
+            String sql = "SELECT tg.tgname AS trigger_name, " +
+                "trim(trailing ',' FROM (" +
+                "CASE WHEN (tg.tgtype & 4) <> 0 THEN 'INSERT,' ELSE '' END || " +
+                "CASE WHEN (tg.tgtype & 8) <> 0 THEN 'DELETE,' ELSE '' END || " +
+                "CASE WHEN (tg.tgtype & 16) <> 0 THEN 'UPDATE,' ELSE '' END || " +
+                "CASE WHEN (tg.tgtype & 32) <> 0 THEN 'TRUNCATE,' ELSE '' END" +
+                ")) AS event_manipulation, " +
+                "CASE WHEN (tg.tgtype & 2) <> 0 THEN 'BEFORE' ELSE 'AFTER' END AS action_timing " +
+                "FROM pg_catalog.pg_trigger tg " +
+                "JOIN pg_catalog.pg_class c ON c.oid = tg.tgrelid " +
+                "JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace " +
+                "WHERE n.nspname = ? AND c.relname = ? AND NOT tg.tgisinternal " +
+                "ORDER BY tg.tgname";
+            try (java.sql.PreparedStatement stmt = requireConnection().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TriggerInfo(
+                            rs.getString("trigger_name"),
+                            rs.getString("event_manipulation"),
+                            rs.getString("action_timing")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "SET search_path TO " + quoteIdentifier(schema);
+    }
+
+    private java.sql.Connection requireConnection() {
+        return requireConnected();
+    }
+
+    private static String normalizeTableType(String type) {
+        if (type == null || type.trim().isEmpty()) return "TABLE";
+        if ("BASE TABLE".equals(type)) return "TABLE";
+        return type;
+    }
+
+    private static String coalesce(String value) {
+        return value == null ? "" : value;
+    }
+
+    private String quoteQualifiedIdentifier(String schema, String name) {
+        return quoteIdentifier(schema) + "." + quoteIdentifier(name);
+    }
+
+    private static Integer intObject(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgentProfile.java b/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgentProfile.java
new file mode 100644
index 0000000..f4ba2a8
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgentProfile.java
@@ -0,0 +1,30 @@
+package com.dbx.agent;
+
+public final class PostgresLikeAgentProfile {
+    private final String driverClass;
+    private final String urlTemplate;
+
+    public PostgresLikeAgentProfile(String driverClass, String urlTemplate) {
+        this.driverClass = driverClass;
+        this.urlTemplate = urlTemplate;
+    }
+
+    public String getDriverClass() {
+        return driverClass;
+    }
+
+    public String getUrlTemplate() {
+        return urlTemplate;
+    }
+
+    public String buildUrl(ConnectParams params) {
+        return new JdbcAgentProfile(
+            driverClass,
+            urlTemplate,
+            0,
+            false,
+            java.util.Collections.emptySet(),
+            java.util.Arrays.asList("TABLE", "VIEW", "MATERIALIZED VIEW", "SYSTEM TABLE", "SYSTEM VIEW")
+        ).buildUrl(params);
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/QueryPageOptions.java b/agents/common/src/main/java/com/dbx/agent/QueryPageOptions.java
new file mode 100644
index 0000000..293c7aa
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/QueryPageOptions.java
@@ -0,0 +1,82 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class QueryPageOptions {
+    private int pageSize;
+    private Integer fetchSize;
+    private int maxRows;
+    private int timeoutSecs;
+
+    public QueryPageOptions() {
+        this(100, null, JdbcExecutor.DEFAULT_MAX_ROWS, 0);
+    }
+
+    public QueryPageOptions(int pageSize, Integer fetchSize, int maxRows) {
+        this(pageSize, fetchSize, maxRows, 0);
+    }
+
+    public QueryPageOptions(int pageSize, Integer fetchSize, int maxRows, int timeoutSecs) {
+        this.pageSize = pageSize;
+        this.fetchSize = fetchSize;
+        this.maxRows = maxRows;
+        this.timeoutSecs = timeoutSecs;
+    }
+
+    public int getPageSize() {
+        return pageSize;
+    }
+
+    public Integer getFetchSize() {
+        return fetchSize;
+    }
+
+    public int getMaxRows() {
+        return maxRows;
+    }
+
+    public int getTimeoutSecs() {
+        return timeoutSecs;
+    }
+
+    public void setPageSize(int pageSize) {
+        this.pageSize = pageSize;
+    }
+
+    public void setFetchSize(Integer fetchSize) {
+        this.fetchSize = fetchSize;
+    }
+
+    public void setMaxRows(int maxRows) {
+        this.maxRows = maxRows;
+    }
+
+    public void setTimeoutSecs(int timeoutSecs) {
+        this.timeoutSecs = timeoutSecs;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof QueryPageOptions)) return false;
+        QueryPageOptions that = (QueryPageOptions) other;
+        return pageSize == that.pageSize
+            && maxRows == that.maxRows
+            && timeoutSecs == that.timeoutSecs
+            && Objects.equals(fetchSize, that.fetchSize);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(pageSize, fetchSize, maxRows, timeoutSecs);
+    }
+
+    @Override
+    public String toString() {
+        return "QueryPageOptions(pageSize=" + pageSize
+            + ", fetchSize=" + fetchSize
+            + ", maxRows=" + maxRows
+            + ", timeoutSecs=" + timeoutSecs
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/QueryPageParams.java b/agents/common/src/main/java/com/dbx/agent/QueryPageParams.java
new file mode 100644
index 0000000..a0ab76b
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/QueryPageParams.java
@@ -0,0 +1,90 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class QueryPageParams {
+    private String sql;
+    private String schema;
+    private Integer pageSize;
+    private Integer fetchSize;
+    private Integer maxRows;
+
+    public QueryPageParams() {
+        this("", null, null, null, null);
+    }
+
+    public QueryPageParams(String sql, String schema, Integer pageSize, Integer fetchSize, Integer maxRows) {
+        this.sql = sql;
+        this.schema = schema;
+        this.pageSize = pageSize;
+        this.fetchSize = fetchSize;
+        this.maxRows = maxRows;
+    }
+
+    public String getSql() {
+        return sql;
+    }
+
+    public String getSchema() {
+        return schema;
+    }
+
+    public Integer getPageSize() {
+        return pageSize;
+    }
+
+    public Integer getFetchSize() {
+        return fetchSize;
+    }
+
+    public Integer getMaxRows() {
+        return maxRows;
+    }
+
+    public void setSql(String sql) {
+        this.sql = sql;
+    }
+
+    public void setSchema(String schema) {
+        this.schema = schema;
+    }
+
+    public void setPageSize(Integer pageSize) {
+        this.pageSize = pageSize;
+    }
+
+    public void setFetchSize(Integer fetchSize) {
+        this.fetchSize = fetchSize;
+    }
+
+    public void setMaxRows(Integer maxRows) {
+        this.maxRows = maxRows;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof QueryPageParams)) return false;
+        QueryPageParams that = (QueryPageParams) other;
+        return Objects.equals(sql, that.sql)
+            && Objects.equals(schema, that.schema)
+            && Objects.equals(pageSize, that.pageSize)
+            && Objects.equals(fetchSize, that.fetchSize)
+            && Objects.equals(maxRows, that.maxRows);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(sql, schema, pageSize, fetchSize, maxRows);
+    }
+
+    @Override
+    public String toString() {
+        return "QueryPageParams(sql=" + sql
+            + ", schema=" + schema
+            + ", pageSize=" + pageSize
+            + ", fetchSize=" + fetchSize
+            + ", maxRows=" + maxRows
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/QueryPageResult.java b/agents/common/src/main/java/com/dbx/agent/QueryPageResult.java
new file mode 100644
index 0000000..051cb0a
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/QueryPageResult.java
@@ -0,0 +1,163 @@
+package com.dbx.agent;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public final class QueryPageResult {
+    private List<String> columns;
+    private List<String> column_types;
+    private List<List<Object>> rows;
+    private long affected_rows;
+    private long execution_time_ms;
+    private boolean truncated;
+    private String session_id;
+    private boolean has_more;
+
+    public QueryPageResult() {
+        this(Collections.emptyList(), Collections.emptyList(), 0L, 0L, false, null, false);
+    }
+
+    public QueryPageResult(List<String> columns, List<? extends List<?>> rows, long affected_rows, long execution_time_ms) {
+        this(columns, rows, affected_rows, execution_time_ms, false, null, false);
+    }
+
+    public QueryPageResult(
+        List<String> columns,
+        List<? extends List<?>> rows,
+        long affected_rows,
+        long execution_time_ms,
+        boolean truncated
+    ) {
+        this(columns, rows, affected_rows, execution_time_ms, truncated, null, false);
+    }
+
+    public QueryPageResult(
+        List<String> columns,
+        List<? extends List<?>> rows,
+        long affected_rows,
+        long execution_time_ms,
+        boolean truncated,
+        String session_id,
+        boolean has_more
+    ) {
+        this(columns, null, rows, affected_rows, execution_time_ms, truncated, session_id, has_more);
+    }
+
+    public QueryPageResult(
+        List<String> columns,
+        List<String> column_types,
+        List<? extends List<?>> rows,
+        long affected_rows,
+        long execution_time_ms,
+        boolean truncated,
+        String session_id,
+        boolean has_more
+    ) {
+        this.columns = columns == null ? Collections.emptyList() : columns;
+        this.column_types = column_types == null ? Collections.emptyList() : column_types;
+        this.rows = QueryResult.normalizeRows(rows);
+        this.affected_rows = affected_rows;
+        this.execution_time_ms = execution_time_ms;
+        this.truncated = truncated;
+        this.session_id = session_id;
+        this.has_more = has_more;
+    }
+
+    public List<String> getColumns() {
+        return columns;
+    }
+
+    public List<String> getColumn_types() {
+        return column_types;
+    }
+
+    public List<List<Object>> getRows() {
+        return rows;
+    }
+
+    public long getAffected_rows() {
+        return affected_rows;
+    }
+
+    public long getExecution_time_ms() {
+        return execution_time_ms;
+    }
+
+    public boolean getTruncated() {
+        return truncated;
+    }
+
+    public String getSession_id() {
+        return session_id;
+    }
+
+    public boolean getHas_more() {
+        return has_more;
+    }
+
+    public void setColumns(List<String> columns) {
+        this.columns = columns;
+    }
+
+    public void setColumn_types(List<String> column_types) {
+        this.column_types = column_types;
+    }
+
+    public void setRows(List<List<Object>> rows) {
+        this.rows = rows;
+    }
+
+    public void setAffected_rows(long affected_rows) {
+        this.affected_rows = affected_rows;
+    }
+
+    public void setExecution_time_ms(long execution_time_ms) {
+        this.execution_time_ms = execution_time_ms;
+    }
+
+    public void setTruncated(boolean truncated) {
+        this.truncated = truncated;
+    }
+
+    public void setSession_id(String session_id) {
+        this.session_id = session_id;
+    }
+
+    public void setHas_more(boolean has_more) {
+        this.has_more = has_more;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof QueryPageResult)) return false;
+        QueryPageResult that = (QueryPageResult) other;
+        return affected_rows == that.affected_rows
+            && execution_time_ms == that.execution_time_ms
+            && truncated == that.truncated
+            && has_more == that.has_more
+            && Objects.equals(columns, that.columns)
+            && Objects.equals(column_types, that.column_types)
+            && Objects.equals(rows, that.rows)
+            && Objects.equals(session_id, that.session_id);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(columns, column_types, rows, affected_rows, execution_time_ms, truncated, session_id, has_more);
+    }
+
+    @Override
+    public String toString() {
+        return "QueryPageResult(columns=" + columns
+            + ", column_types=" + column_types
+            + ", rows=" + rows
+            + ", affected_rows=" + affected_rows
+            + ", execution_time_ms=" + execution_time_ms
+            + ", truncated=" + truncated
+            + ", session_id=" + session_id
+            + ", has_more=" + has_more
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/QueryResult.java b/agents/common/src/main/java/com/dbx/agent/QueryResult.java
new file mode 100644
index 0000000..c38881a
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/QueryResult.java
@@ -0,0 +1,137 @@
+package com.dbx.agent;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+public final class QueryResult {
+    private List<String> columns;
+    private List<String> column_types;
+    private List<List<Object>> rows;
+    private long affected_rows;
+    private long execution_time_ms;
+    private boolean truncated;
+
+    public QueryResult() {
+        this(Collections.emptyList(), Collections.emptyList(), 0L, 0L, false);
+    }
+
+    public QueryResult(List<String> columns, List<? extends List<?>> rows, long affected_rows, long execution_time_ms) {
+        this(columns, rows, affected_rows, execution_time_ms, false);
+    }
+
+    public QueryResult(
+        List<String> columns,
+        List<? extends List<?>> rows,
+        long affected_rows,
+        long execution_time_ms,
+        boolean truncated
+    ) {
+        this(columns, null, rows, affected_rows, execution_time_ms, truncated);
+    }
+
+    public QueryResult(
+        List<String> columns,
+        List<String> column_types,
+        List<? extends List<?>> rows,
+        long affected_rows,
+        long execution_time_ms,
+        boolean truncated
+    ) {
+        this.columns = columns == null ? Collections.emptyList() : columns;
+        this.column_types = column_types == null ? Collections.emptyList() : column_types;
+        this.rows = normalizeRows(rows);
+        this.affected_rows = affected_rows;
+        this.execution_time_ms = execution_time_ms;
+        this.truncated = truncated;
+    }
+
+    public List<String> getColumns() {
+        return columns;
+    }
+
+    public List<String> getColumn_types() {
+        return column_types;
+    }
+
+    public List<List<Object>> getRows() {
+        return rows;
+    }
+
+    public long getAffected_rows() {
+        return affected_rows;
+    }
+
+    public long getExecution_time_ms() {
+        return execution_time_ms;
+    }
+
+    public boolean getTruncated() {
+        return truncated;
+    }
+
+    public void setColumns(List<String> columns) {
+        this.columns = columns;
+    }
+
+    public void setColumn_types(List<String> column_types) {
+        this.column_types = column_types;
+    }
+
+    public void setRows(List<List<Object>> rows) {
+        this.rows = rows;
+    }
+
+    public void setAffected_rows(long affected_rows) {
+        this.affected_rows = affected_rows;
+    }
+
+    public void setExecution_time_ms(long execution_time_ms) {
+        this.execution_time_ms = execution_time_ms;
+    }
+
+    public void setTruncated(boolean truncated) {
+        this.truncated = truncated;
+    }
+
+    static List<List<Object>> normalizeRows(List<? extends List<?>> input) {
+        if (input == null) {
+            return Collections.emptyList();
+        }
+        List<List<Object>> normalized = new ArrayList<>(input.size());
+        for (List<?> row : input) {
+            normalized.add(row == null ? Collections.emptyList() : new ArrayList<Object>(row));
+        }
+        return normalized;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof QueryResult)) return false;
+        QueryResult that = (QueryResult) other;
+        return affected_rows == that.affected_rows
+            && execution_time_ms == that.execution_time_ms
+            && truncated == that.truncated
+            && Objects.equals(columns, that.columns)
+            && Objects.equals(column_types, that.column_types)
+            && Objects.equals(rows, that.rows);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(columns, column_types, rows, affected_rows, execution_time_ms, truncated);
+    }
+
+    @Override
+    public String toString() {
+        return "QueryResult(columns=" + columns
+            + ", column_types=" + column_types
+            + ", rows=" + rows
+            + ", affected_rows=" + affected_rows
+            + ", execution_time_ms=" + execution_time_ms
+            + ", truncated=" + truncated
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/SchemaTableParams.java b/agents/common/src/main/java/com/dbx/agent/SchemaTableParams.java
new file mode 100644
index 0000000..fc389c6
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/SchemaTableParams.java
@@ -0,0 +1,51 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class SchemaTableParams {
+    private String schema;
+    private String table;
+
+    public SchemaTableParams() {
+        this("", "");
+    }
+
+    public SchemaTableParams(String schema, String table) {
+        this.schema = schema;
+        this.table = table;
+    }
+
+    public String getSchema() {
+        return schema;
+    }
+
+    public String getTable() {
+        return table;
+    }
+
+    public void setSchema(String schema) {
+        this.schema = schema;
+    }
+
+    public void setTable(String table) {
+        this.table = table;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof SchemaTableParams)) return false;
+        SchemaTableParams that = (SchemaTableParams) other;
+        return Objects.equals(schema, that.schema) && Objects.equals(table, that.table);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(schema, table);
+    }
+
+    @Override
+    public String toString() {
+        return "SchemaTableParams(schema=" + schema + ", table=" + table + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/StandardJdbcMetadata.java b/agents/common/src/main/java/com/dbx/agent/StandardJdbcMetadata.java
new file mode 100644
index 0000000..9a6eada
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/StandardJdbcMetadata.java
@@ -0,0 +1,716 @@
+package com.dbx.agent;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+public final class StandardJdbcMetadata {
+    public static final StandardJdbcMetadata INSTANCE = new StandardJdbcMetadata();
+
+    private StandardJdbcMetadata() {
+    }
+
+    public List<DatabaseInfo> listDatabases(Connection conn, String configuredDatabase) {
+        return unchecked(() -> {
+            Set<String> names = new LinkedHashSet<>();
+            try {
+                try (ResultSet rs = conn.getMetaData().getCatalogs()) {
+                    while (rs.next()) {
+                        addNonBlank(names, rs.getString("TABLE_CAT"));
+                    }
+                }
+            } catch (Exception ignored) {
+            }
+            addNonBlank(names, configuredDatabase);
+            addNonBlank(names, conn.getCatalog());
+
+            List<DatabaseInfo> result = new ArrayList<>();
+            for (String name : names) {
+                result.add(new DatabaseInfo(name));
+            }
+            return result;
+        });
+    }
+
+    public List<String> listSchemas(Connection conn, JdbcAgentProfile profile) {
+        return unchecked(() -> {
+            Set<String> names = new LinkedHashSet<>();
+            DatabaseMetaData meta = conn.getMetaData();
+            try {
+                appendSchemas(names, meta.getSchemas(null, null));
+            } catch (Exception | AbstractMethodError first) {
+                try {
+                    appendSchemas(names, meta.getSchemas());
+                } catch (Exception | AbstractMethodError ignored) {
+                }
+            }
+            try {
+                addNonBlank(names, conn.getSchema());
+            } catch (Exception | AbstractMethodError ignored) {
+            }
+
+            List<String> result = new ArrayList<>();
+            for (String name : names) {
+                if (!profile.getExcludedSchemas().contains(name.toUpperCase(Locale.ROOT))) {
+                    result.add(name);
+                }
+            }
+            Collections.sort(result);
+            return result;
+        });
+    }
+
+    public List<TableInfo> listTables(Connection conn, JdbcAgentProfile profile, String configuredDatabase, String schema) {
+        return listTables(conn, profile, configuredDatabase, schema, MetadataListConstraints.NONE);
+    }
+
+    public List<TableInfo> listTables(
+        Connection conn,
+        JdbcAgentProfile profile,
+        String configuredDatabase,
+        String schema,
+        MetadataListConstraints constraints
+    ) {
+        return unchecked(() -> {
+            MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+            if (!normalized.includesTableLikeTypes()) {
+                return Collections.emptyList();
+            }
+            DatabaseMetaData meta = conn.getMetaData();
+            List<TableInfo> result = new ArrayList<>();
+            appendTables(result, meta, profile, null, schema, normalized);
+            if (result.isEmpty() && profile.getCatalogFallbackEnabled() && !configuredDatabase.trim().isEmpty()) {
+                appendTables(result, meta, profile, configuredDatabase, schema, normalized);
+            }
+            result.sort(Comparator.comparing(TableInfo::getName));
+            return normalized.filterTables(result);
+        });
+    }
+
+    public List<ObjectInfo> listObjects(List<TableInfo> tables, String schema) {
+        return listObjects(tables, schema, MetadataListConstraints.NONE);
+    }
+
+    public List<ObjectInfo> listObjects(List<TableInfo> tables, String schema, MetadataListConstraints constraints) {
+        List<ObjectInfo> result = new ArrayList<>();
+        for (TableInfo table : tables) {
+            result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+        }
+        return MetadataListConstraints.orNone(constraints).filterObjects(result);
+    }
+
+    public List<ObjectInfo> listObjects(
+        Connection conn,
+        JdbcAgentProfile profile,
+        String configuredDatabase,
+        String schema,
+        MetadataListConstraints constraints
+    ) {
+        return unchecked(() -> {
+            MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+            MetadataListConstraints tableConstraints =
+                new MetadataListConstraints(normalized.getFilter(), null, null, normalized.getObjectTypes());
+            List<ObjectInfo> result = new ArrayList<>(
+                listObjects(listTables(conn, profile, configuredDatabase, schema, tableConstraints), schema)
+            );
+            DatabaseMetaData meta = conn.getMetaData();
+            appendRoutines(result, meta, null, blankToNull(schema), schema);
+            if (!containsRoutine(result)
+                && profile.getCatalogFallbackEnabled()
+                && configuredDatabase != null
+                && !configuredDatabase.trim().isEmpty()) {
+                appendRoutines(result, meta, configuredDatabase, blankToNull(schema), schema);
+            }
+            result.sort(Comparator.comparing(ObjectInfo::getName));
+            return normalized.filterObjects(result);
+        });
+    }
+
+    public List<String> listDataTypes(Connection conn) {
+        return unchecked(() -> {
+            Set<String> seen = new LinkedHashSet<>();
+            List<String> names = new ArrayList<>();
+            try (ResultSet rs = conn.getMetaData().getTypeInfo()) {
+                while (rs.next()) {
+                    String name = rs.getString("TYPE_NAME");
+                    if (name == null || name.trim().isEmpty()) {
+                        continue;
+                    }
+                    String trimmed = name.trim();
+                    if (seen.add(trimmed.toLowerCase(Locale.ROOT))) {
+                        names.add(trimmed);
+                    }
+                }
+            }
+            return names;
+        });
+    }
+
+    public CompletionAssistantResponse completionAssistantSearch(
+        Connection conn,
+        JdbcAgentProfile profile,
+        String configuredDatabase,
+        CompletionAssistantRequest request
+    ) {
+        return unchecked(() -> {
+            int limit = boundedLimit(request.getMax_results());
+            List<CompletionAssistantCandidate> candidates = new ArrayList<>();
+            List<CompletionAssistantObjectKind> kinds = normalizedObjectKinds(request);
+            DatabaseMetaData meta = conn.getMetaData();
+            String catalog = blankToNull(request.getDatabase());
+            String schema = completionSchema(request);
+
+            if (containsKind(kinds, CompletionAssistantObjectKind.SCHEMA)) {
+                appendCompletionSchemas(candidates, meta, profile, request, limit);
+            }
+            if (candidates.size() < limit && containsTableLike(kinds)) {
+                appendCompletionTables(candidates, meta, profile, catalog, schema, request, kinds, limit);
+                if (candidates.isEmpty() && profile.getCatalogFallbackEnabled() && configuredDatabase != null && !configuredDatabase.trim().isEmpty()) {
+                    appendCompletionTables(candidates, meta, profile, configuredDatabase, schema, request, kinds, limit);
+                }
+            }
+            if (candidates.size() < limit && containsKind(kinds, CompletionAssistantObjectKind.COLUMN)) {
+                appendCompletionColumns(candidates, meta, catalog, schema, request, limit);
+                if (candidates.isEmpty() && profile.getCatalogFallbackEnabled() && configuredDatabase != null && !configuredDatabase.trim().isEmpty()) {
+                    appendCompletionColumns(candidates, meta, configuredDatabase, schema, request, limit);
+                }
+            }
+
+            return new CompletionAssistantResponse(candidates, candidates.size() >= limit, false);
+        });
+    }
+
+    public List<ColumnInfo> getColumns(Connection conn, JdbcAgentProfile profile, String configuredDatabase, String schema, String table) {
+        return unchecked(() -> {
+            DatabaseMetaData meta = conn.getMetaData();
+            Set<String> primaryKeys = primaryKeys(meta, null, schema, table);
+            List<ColumnInfo> result = new ArrayList<>();
+            appendColumns(result, meta, null, schema, table, primaryKeys);
+            if (!result.isEmpty() && primaryKeys.isEmpty() && profile.getCatalogFallbackEnabled() && hasConfiguredDatabase(configuredDatabase)) {
+                Set<String> fallbackPrimaryKeys = primaryKeys(meta, configuredDatabase, schema, table);
+                markPrimaryKeys(result, fallbackPrimaryKeys);
+            }
+            if (result.isEmpty() && profile.getCatalogFallbackEnabled() && hasConfiguredDatabase(configuredDatabase)) {
+                Set<String> fallbackPrimaryKeys = primaryKeys(meta, configuredDatabase, schema, table);
+                appendColumns(result, meta, configuredDatabase, schema, table, fallbackPrimaryKeys);
+            }
+            return result;
+        });
+    }
+
+    public List<IndexInfo> listIndexes(Connection conn, String schema, String table) {
+        return unchecked(() -> {
+            DatabaseMetaData meta = conn.getMetaData();
+            Map<String, List<IndexColumn>> indexes = new LinkedHashMap<>();
+            Map<String, Boolean> unique = new LinkedHashMap<>();
+            try (ResultSet rs = meta.getIndexInfo(null, blankToNull(schema), table, false, false)) {
+                while (rs.next()) {
+                    String name = rs.getString("INDEX_NAME");
+                    String column = rs.getString("COLUMN_NAME");
+                    if (name == null || column == null) {
+                        continue;
+                    }
+                    indexes.computeIfAbsent(name, ignored -> new ArrayList<>()).add(
+                        new IndexColumn(rs.getShort("ORDINAL_POSITION"), column)
+                    );
+                    unique.put(name, !rs.getBoolean("NON_UNIQUE"));
+                }
+            }
+
+            List<IndexInfo> result = new ArrayList<>();
+            for (Map.Entry<String, List<IndexColumn>> entry : indexes.entrySet()) {
+                List<IndexColumn> orderedColumns = entry.getValue();
+                orderedColumns.sort(Comparator.comparingInt(IndexColumn::getOrdinal));
+                List<String> columns = new ArrayList<>();
+                for (IndexColumn column : orderedColumns) {
+                    columns.add(column.getName());
+                }
+                String name = entry.getKey();
+                result.add(new IndexInfo(
+                    name,
+                    columns,
+                    Boolean.TRUE.equals(unique.get(name)),
+                    "PRIMARY".equalsIgnoreCase(name),
+                    null,
+                    null,
+                    null,
+                    null
+                ));
+            }
+            return result;
+        });
+    }
+
+    public List<ForeignKeyInfo> listForeignKeys(Connection conn, String schema, String table) {
+        return unchecked(() -> {
+            DatabaseMetaData meta = conn.getMetaData();
+            List<ForeignKeyInfo> result = new ArrayList<>();
+            try (ResultSet rs = meta.getImportedKeys(null, blankToNull(schema), table)) {
+                while (rs.next()) {
+                    String name = rs.getString("FK_NAME");
+                    result.add(new ForeignKeyInfo(
+                        name == null ? "" : name,
+                        rs.getString("FKCOLUMN_NAME"),
+                        rs.getString("PKTABLE_NAME"),
+                        rs.getString("PKCOLUMN_NAME")
+                    ));
+                }
+            }
+            return result;
+        });
+    }
+
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    private static String[] getDriverTableTypes(DatabaseMetaData meta, JdbcAgentProfile profile) throws Exception {
+        Set<String> configuredTypes = new LinkedHashSet<>();
+        for (String type : profile.getTableTypes()) {
+            if (type != null) {
+                configuredTypes.add(type.toUpperCase(Locale.ROOT));
+            }
+        }
+        try (ResultSet rs = meta.getTableTypes()) {
+            List<String> types = new ArrayList<>();
+            while (rs.next()) {
+                String type = rs.getString("TABLE_TYPE");
+                if (type != null && configuredTypes.contains(type.toUpperCase(Locale.ROOT))) {
+                    types.add(type);
+                }
+            }
+            if (!types.isEmpty()) {
+                return types.toArray(new String[0]);
+            }
+        } catch (Exception ignored) {
+        }
+        return profile.getTableTypes().toArray(new String[profile.getTableTypes().size()]);
+    }
+
+    public static String getIdentifierQuote(Connection conn, JdbcAgentProfile profile) {
+        try {
+            String quote = conn.getMetaData().getIdentifierQuoteString();
+            if (quote != null && !quote.trim().isEmpty()) {
+                return quote.trim();
+            }
+        } catch (Exception ignored) {
+        }
+        return profile.getIdentifierQuote();
+    }
+
+    public static String quoteIdentifier(String identifier, String quote) {
+        return quote + identifier.replace(quote, quote + quote) + quote;
+    }
+
+    public static String schemaSwitchSql(Connection conn, JdbcAgentProfile profile, String schema) {
+        if (profile.getSkipExecutionContext()) {
+            return profile.schemaSwitchSql(schema);
+        }
+        String quote = getIdentifierQuote(conn, profile);
+        return profile.schemaSwitchSql(schema, quote);
+    }
+
+    private void appendTables(
+        List<TableInfo> result,
+        DatabaseMetaData meta,
+        JdbcAgentProfile profile,
+        String catalog,
+        String schema,
+        MetadataListConstraints constraints
+    ) throws Exception {
+        String[] tableTypes = constrainedTableTypes(getDriverTableTypes(meta, profile), constraints);
+        if (tableTypes.length == 0) {
+            return;
+        }
+        // JDBC has no portable metadata limit/offset. Use table types for safe pushdown and filter/page locally.
+        try (ResultSet rs = meta.getTables(catalog, blankToNull(schema), "%", tableTypes)) {
+            while (rs.next()) {
+                result.add(new TableInfo(
+                    rs.getString("TABLE_NAME"),
+                    normalizeTableType(rs.getString("TABLE_TYPE")),
+                    rs.getString("REMARKS")
+                ));
+            }
+        }
+    }
+
+    private static String[] constrainedTableTypes(String[] tableTypes, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (!normalized.hasObjectTypes()) {
+            return tableTypes;
+        }
+        List<String> result = new ArrayList<>();
+        for (String tableType : tableTypes) {
+            if (normalized.tableTypeAllowed(tableType)) {
+                result.add(tableType);
+            }
+        }
+        return result.toArray(new String[0]);
+    }
+
+    private void appendCompletionSchemas(
+        List<CompletionAssistantCandidate> result,
+        DatabaseMetaData meta,
+        JdbcAgentProfile profile,
+        CompletionAssistantRequest request,
+        int limit
+    ) throws Exception {
+        Set<String> names = new LinkedHashSet<>();
+        try {
+            appendSchemas(names, meta.getSchemas(null, null));
+        } catch (Exception | AbstractMethodError first) {
+            try {
+                appendSchemas(names, meta.getSchemas());
+            } catch (Exception | AbstractMethodError ignored) {
+            }
+        }
+        List<String> sorted = new ArrayList<>(names);
+        Collections.sort(sorted);
+        for (String name : sorted) {
+            if (result.size() >= limit) {
+                return;
+            }
+            if (profile.getExcludedSchemas().contains(name.toUpperCase(Locale.ROOT)) || !completionNameMatches(name, request)) {
+                continue;
+            }
+            result.add(new CompletionAssistantCandidate(
+                name,
+                CompletionAssistantCandidateKind.SCHEMA,
+                request.getDatabase(),
+                name,
+                null,
+                null,
+                null,
+                null
+            ));
+        }
+    }
+
+    private void appendCompletionTables(
+        List<CompletionAssistantCandidate> result,
+        DatabaseMetaData meta,
+        JdbcAgentProfile profile,
+        String catalog,
+        String schema,
+        CompletionAssistantRequest request,
+        List<CompletionAssistantObjectKind> kinds,
+        int limit
+    ) throws Exception {
+        String[] tableTypes = getDriverTableTypes(meta, profile);
+        try (ResultSet rs = meta.getTables(catalog, blankToNull(schema), completionPattern(request), tableTypes)) {
+            while (rs.next() && result.size() < limit) {
+                String name = rs.getString("TABLE_NAME");
+                String type = normalizeTableType(rs.getString("TABLE_TYPE"));
+                CompletionAssistantCandidateKind kind = completionTableKind(type);
+                if (!completionTableKindAllowed(kind, kinds) || !completionNameMatches(name, request)) {
+                    continue;
+                }
+                result.add(new CompletionAssistantCandidate(
+                    name,
+                    kind,
+                    request.getDatabase(),
+                    schema,
+                    null,
+                    null,
+                    rs.getString("REMARKS"),
+                    null
+                ));
+            }
+        }
+        result.sort(Comparator.comparing(CompletionAssistantCandidate::getName));
+    }
+
+    private void appendCompletionColumns(
+        List<CompletionAssistantCandidate> result,
+        DatabaseMetaData meta,
+        String catalog,
+        String schema,
+        CompletionAssistantRequest request,
+        int limit
+    ) throws Exception {
+        String table = request.getParent_name();
+        if (table == null || table.trim().isEmpty()) {
+            return;
+        }
+        try (ResultSet rs = meta.getColumns(catalog, blankToNull(schema), table, completionPattern(request))) {
+            while (rs.next() && result.size() < limit) {
+                String name = rs.getString("COLUMN_NAME");
+                if (!completionNameMatches(name, request)) {
+                    continue;
+                }
+                result.add(new CompletionAssistantCandidate(
+                    name,
+                    CompletionAssistantCandidateKind.COLUMN,
+                    request.getDatabase(),
+                    schema,
+                    schema,
+                    table,
+                    rs.getString("REMARKS"),
+                    rs.getString("TYPE_NAME")
+                ));
+            }
+        }
+    }
+
+    private static List<CompletionAssistantObjectKind> normalizedObjectKinds(CompletionAssistantRequest request) {
+        List<CompletionAssistantObjectKind> kinds = request.getObject_kinds();
+        if (kinds.isEmpty()) {
+            kinds = new ArrayList<>();
+            kinds.add(CompletionAssistantObjectKind.TABLE);
+            kinds.add(CompletionAssistantObjectKind.VIEW);
+        }
+        return kinds;
+    }
+
+    private static String completionSchema(CompletionAssistantRequest request) {
+        String parentSchema = request.getParent_schema();
+        if (parentSchema != null && !parentSchema.trim().isEmpty()) {
+            return parentSchema;
+        }
+        return request.getSchema();
+    }
+
+    private static String completionPattern(CompletionAssistantRequest request) {
+        String mask = request.getMask();
+        if (mask.trim().isEmpty()) {
+            return "%";
+        }
+        String escaped = mask.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_");
+        if (request.getMatch_mode() == CompletionAssistantMatchMode.CONTAINS) {
+            return "%" + escaped + "%";
+        }
+        return escaped + "%";
+    }
+
+    private static boolean completionNameMatches(String name, CompletionAssistantRequest request) {
+        if (name == null) {
+            return false;
+        }
+        String mask = request.getMask();
+        if (mask.trim().isEmpty()) {
+            return true;
+        }
+        String candidate = request.getCase_sensitive() ? name : name.toLowerCase(Locale.ROOT);
+        String expected = request.getCase_sensitive() ? mask : mask.toLowerCase(Locale.ROOT);
+        if (request.getMatch_mode() == CompletionAssistantMatchMode.CONTAINS) {
+            return candidate.contains(expected);
+        }
+        return candidate.startsWith(expected);
+    }
+
+    private static int boundedLimit(Integer requested) {
+        if (requested == null) {
+            return 100;
+        }
+        return Math.max(1, Math.min(1000, requested));
+    }
+
+    private static boolean containsKind(List<CompletionAssistantObjectKind> kinds, CompletionAssistantObjectKind kind) {
+        return kinds.contains(kind);
+    }
+
+    private static boolean containsTableLike(List<CompletionAssistantObjectKind> kinds) {
+        return kinds.contains(CompletionAssistantObjectKind.TABLE) || kinds.contains(CompletionAssistantObjectKind.VIEW);
+    }
+
+    private static CompletionAssistantCandidateKind completionTableKind(String type) {
+        if ("VIEW".equalsIgnoreCase(type)) {
+            return CompletionAssistantCandidateKind.VIEW;
+        }
+        return CompletionAssistantCandidateKind.TABLE;
+    }
+
+    private static boolean completionTableKindAllowed(
+        CompletionAssistantCandidateKind kind,
+        List<CompletionAssistantObjectKind> requestedKinds
+    ) {
+        if (kind == CompletionAssistantCandidateKind.VIEW) {
+            return requestedKinds.contains(CompletionAssistantObjectKind.VIEW);
+        }
+        return requestedKinds.contains(CompletionAssistantObjectKind.TABLE);
+    }
+
+    private Set<String> primaryKeys(DatabaseMetaData meta, String catalog, String schema, String table) {
+        Set<String> keys = new LinkedHashSet<>();
+        try (ResultSet rs = meta.getPrimaryKeys(catalog, blankToNull(schema), table)) {
+            while (rs.next()) {
+                String name = rs.getString("COLUMN_NAME");
+                if (name != null) {
+                    keys.add(name);
+                }
+            }
+        } catch (Exception ignored) {
+        }
+        return keys;
+    }
+
+    private static boolean hasConfiguredDatabase(String configuredDatabase) {
+        return configuredDatabase != null && !configuredDatabase.trim().isEmpty();
+    }
+
+    private static void markPrimaryKeys(List<ColumnInfo> columns, Set<String> primaryKeys) {
+        if (primaryKeys.isEmpty()) {
+            return;
+        }
+        for (ColumnInfo column : columns) {
+            if (primaryKeys.contains(column.getName())) {
+                column.setIs_primary_key(true);
+            }
+        }
+    }
+
+    private static void appendSchemas(Set<String> names, ResultSet rs) throws Exception {
+        try (ResultSet closeable = rs) {
+            while (closeable.next()) {
+                addNonBlank(names, closeable.getString("TABLE_SCHEM"));
+            }
+        }
+    }
+
+    private void appendColumns(
+        List<ColumnInfo> result,
+        DatabaseMetaData meta,
+        String catalog,
+        String schema,
+        String table,
+        Set<String> primaryKeys
+    ) throws Exception {
+        try (ResultSet rs = meta.getColumns(catalog, blankToNull(schema), table, "%")) {
+            while (rs.next()) {
+                String name = rs.getString("COLUMN_NAME");
+                result.add(new ColumnInfo(
+                    name,
+                    rs.getString("TYPE_NAME"),
+                    rs.getInt("NULLABLE") != DatabaseMetaData.columnNoNulls,
+                    rs.getString("COLUMN_DEF"),
+                    primaryKeys.contains(name),
+                    null,
+                    rs.getString("REMARKS"),
+                    intOrNull(rs, "COLUMN_SIZE"),
+                    intOrNull(rs, "DECIMAL_DIGITS"),
+                    characterLength(rs)
+                ));
+            }
+        }
+    }
+
+    private static String normalizeTableType(String type) {
+        if (type == null || type.trim().isEmpty()) {
+            return "TABLE";
+        }
+        String normalized = type.toUpperCase(Locale.ROOT);
+        if ("BASE TABLE".equals(normalized) || "COLUMN TABLE".equals(normalized) || "ROW TABLE".equals(normalized)) {
+            return "TABLE";
+        }
+        return type;
+    }
+
+    private static void appendRoutines(
+        List<ObjectInfo> result,
+        DatabaseMetaData meta,
+        String catalog,
+        String schemaPattern,
+        String schema
+    ) {
+        Set<String> procedureNames = new LinkedHashSet<>();
+        try (ResultSet rs = meta.getProcedures(catalog, schemaPattern, "%")) {
+            while (rs.next()) {
+                String name = rs.getString("PROCEDURE_NAME");
+                if (name != null && !name.trim().isEmpty()) {
+                    procedureNames.add(name);
+                    result.add(new ObjectInfo(name, "PROCEDURE", schema, rs.getString("REMARKS")));
+                }
+            }
+        } catch (Exception | AbstractMethodError ignored) {
+            // Some JDBC drivers don't implement routine metadata.
+        }
+        try (ResultSet rs = meta.getFunctions(catalog, schemaPattern, "%")) {
+            while (rs.next()) {
+                String name = rs.getString("FUNCTION_NAME");
+                if (name != null && !name.trim().isEmpty() && !procedureNames.contains(name)) {
+                    result.add(new ObjectInfo(name, "FUNCTION", schema, rs.getString("REMARKS")));
+                }
+            }
+        } catch (Exception | AbstractMethodError ignored) {
+            // Some JDBC drivers don't implement function metadata separately.
+        }
+    }
+
+    private static boolean containsRoutine(List<ObjectInfo> objects) {
+        for (ObjectInfo object : objects) {
+            if ("PROCEDURE".equalsIgnoreCase(object.getObject_type())
+                || "FUNCTION".equalsIgnoreCase(object.getObject_type())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static Integer intOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    private static Integer characterLength(ResultSet rs) throws Exception {
+        String typeName = rs.getString("TYPE_NAME");
+        if (typeName == null) {
+            return null;
+        }
+        String normalized = typeName.toLowerCase(Locale.ROOT);
+        if (!normalized.contains("char") && !normalized.contains("text")) {
+            return null;
+        }
+        return intOrNull(rs, "COLUMN_SIZE");
+    }
+
+    private static String blankToNull(String value) {
+        return value == null || value.trim().isEmpty() ? null : value;
+    }
+
+    private static void addNonBlank(Set<String> values, String value) {
+        if (value != null && !value.trim().isEmpty()) {
+            values.add(value);
+        }
+    }
+
+    private static <T> T unchecked(ThrowingSupplier<T> supplier) {
+        try {
+            return supplier.get();
+        } catch (RuntimeException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static final class IndexColumn {
+        private final int ordinal;
+        private final String name;
+
+        private IndexColumn(int ordinal, String name) {
+            this.ordinal = ordinal;
+            this.name = name;
+        }
+
+        private int getOrdinal() {
+            return ordinal;
+        }
+
+        private String getName() {
+            return name;
+        }
+    }
+
+    private interface ThrowingSupplier<T> {
+        T get() throws Exception;
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/TableInfo.java b/agents/common/src/main/java/com/dbx/agent/TableInfo.java
new file mode 100644
index 0000000..0b38595
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/TableInfo.java
@@ -0,0 +1,98 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class TableInfo {
+    private String name;
+    private String table_type;
+    private String comment;
+    private String parent_schema;
+    private String parent_name;
+
+    public TableInfo() {
+        this("", "", null);
+    }
+
+    public TableInfo(String name, String table_type) {
+        this(name, table_type, null);
+    }
+
+    public TableInfo(String name, String table_type, String comment) {
+        this(name, table_type, comment, null, null);
+    }
+
+    public TableInfo(String name, String table_type, String comment, String parent_schema, String parent_name) {
+        this.name = name;
+        this.table_type = table_type;
+        this.comment = comment;
+        this.parent_schema = parent_schema;
+        this.parent_name = parent_name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getTable_type() {
+        return table_type;
+    }
+
+    public String getComment() {
+        return comment;
+    }
+
+    public String getParent_schema() {
+        return parent_schema;
+    }
+
+    public String getParent_name() {
+        return parent_name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setTable_type(String table_type) {
+        this.table_type = table_type;
+    }
+
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
+    public void setParent_schema(String parent_schema) {
+        this.parent_schema = parent_schema;
+    }
+
+    public void setParent_name(String parent_name) {
+        this.parent_name = parent_name;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof TableInfo)) return false;
+        TableInfo that = (TableInfo) other;
+        return Objects.equals(name, that.name)
+            && Objects.equals(table_type, that.table_type)
+            && Objects.equals(comment, that.comment)
+            && Objects.equals(parent_schema, that.parent_schema)
+            && Objects.equals(parent_name, that.parent_name);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, table_type, comment, parent_schema, parent_name);
+    }
+
+    @Override
+    public String toString() {
+        return "TableInfo(name=" + name
+            + ", table_type=" + table_type
+            + ", comment=" + comment
+            + ", parent_schema=" + parent_schema
+            + ", parent_name=" + parent_name
+            + ")";
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/TransactionExecutor.java b/agents/common/src/main/java/com/dbx/agent/TransactionExecutor.java
new file mode 100644
index 0000000..2bd12ed
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/TransactionExecutor.java
@@ -0,0 +1,112 @@
+package com.dbx.agent;
+
+import java.sql.Connection;
+import java.sql.Statement;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+
+public final class TransactionExecutor {
+    private TransactionExecutor() {
+    }
+
+    public static QueryResult executeUpdateStatements(
+        Connection conn,
+        List<String> statements,
+        String schema,
+        Function<String, String> setSchemaSql
+    ) {
+        return executeStatements(conn, statements, schema, setSchemaSql, new StatementRunner() {
+            @Override
+            public long run(Statement stmt, String sql) throws Exception {
+                return stmt.executeUpdate(sql);
+            }
+        });
+    }
+
+    public static QueryResult executeStatements(
+        Connection conn,
+        List<String> statements,
+        String schema,
+        Function<String, String> setSchemaSql,
+        StatementRunner runner
+    ) {
+        return unchecked(() -> {
+            long start = System.currentTimeMillis();
+            if (!supportsTransactions(conn)) {
+                long totalAffected = executeAll(conn, statements, schema, setSchemaSql, runner);
+                return result(totalAffected, start);
+            }
+
+            boolean savedAutoCommit = conn.getAutoCommit();
+            conn.setAutoCommit(false);
+            try {
+                long totalAffected = executeAll(conn, statements, schema, setSchemaSql, runner);
+                conn.commit();
+                return result(totalAffected, start);
+            } catch (Exception e) {
+                conn.rollback();
+                throw e;
+            } finally {
+                conn.setAutoCommit(savedAutoCommit);
+            }
+        });
+    }
+
+    private static long executeAll(
+        Connection conn,
+        List<String> statements,
+        String schema,
+        Function<String, String> setSchemaSql,
+        StatementRunner runner
+    ) throws Exception {
+        applySchema(conn, schema, setSchemaSql);
+        long totalAffected = 0;
+        for (String statement : statements) {
+            try (Statement stmt = conn.createStatement()) {
+                totalAffected += runner.run(stmt, JdbcExecutor.trimSql(statement));
+            }
+        }
+        return totalAffected;
+    }
+
+    private static void applySchema(Connection conn, String schema, Function<String, String> setSchemaSql) throws Exception {
+        JdbcSchemaSwitcher.apply(conn, schema, setSchemaSql);
+    }
+
+    private static boolean supportsTransactions(Connection conn) {
+        try {
+            return conn.getMetaData().supportsTransactions();
+        } catch (Exception ignored) {
+            return true;
+        }
+    }
+
+    private static QueryResult result(long totalAffected, long start) {
+        return new QueryResult(
+            Collections.emptyList(),
+            Collections.emptyList(),
+            totalAffected,
+            System.currentTimeMillis() - start,
+            false
+        );
+    }
+
+    private static <T> T unchecked(ThrowingSupplier<T> supplier) {
+        try {
+            return supplier.get();
+        } catch (RuntimeException e) {
+            throw e;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public interface StatementRunner {
+        long run(Statement stmt, String sql) throws Exception;
+    }
+
+    private interface ThrowingSupplier<T> {
+        T get() throws Exception;
+    }
+}
diff --git a/agents/common/src/main/java/com/dbx/agent/TriggerInfo.java b/agents/common/src/main/java/com/dbx/agent/TriggerInfo.java
new file mode 100644
index 0000000..490b55a
--- /dev/null
+++ b/agents/common/src/main/java/com/dbx/agent/TriggerInfo.java
@@ -0,0 +1,63 @@
+package com.dbx.agent;
+
+import java.util.Objects;
+
+public final class TriggerInfo {
+    private String name;
+    private String event;
+    private String timing;
+
+    public TriggerInfo() {
+        this("", "", "");
+    }
+
+    public TriggerInfo(String name, String event, String timing) {
+        this.name = name;
+        this.event = event;
+        this.timing = timing;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getEvent() {
+        return event;
+    }
+
+    public String getTiming() {
+        return timing;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public void setEvent(String event) {
+        this.event = event;
+    }
+
+    public void setTiming(String timing) {
+        this.timing = timing;
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        if (this == other) return true;
+        if (!(other instanceof TriggerInfo)) return false;
+        TriggerInfo that = (TriggerInfo) other;
+        return Objects.equals(name, that.name)
+            && Objects.equals(event, that.event)
+            && Objects.equals(timing, that.timing);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, event, timing);
+    }
+
+    @Override
+    public String toString() {
+        return "TriggerInfo(name=" + name + ", event=" + event + ", timing=" + timing + ")";
+    }
+}
diff --git a/agents/common/src/main/resources/agent-protocol-v1.json b/agents/common/src/main/resources/agent-protocol-v1.json
new file mode 100644
index 0000000..c108483
--- /dev/null
+++ b/agents/common/src/main/resources/agent-protocol-v1.json
@@ -0,0 +1,88 @@
+{
+  "protocolVersion": 1,
+  "handshakeMethod": "handshake",
+  "handshakeResponseFields": [
+    "protocolVersion",
+    "agentProtocolVersion",
+    "capabilities"
+  ],
+  "allCapabilities": [
+    "connect",
+    "test_connection",
+    "metadata",
+    "query",
+    "paged_query",
+    "transaction",
+    "ddl",
+    "kv"
+  ],
+  "capabilities": [
+    "connect",
+    "test_connection",
+    "metadata",
+    "query",
+    "paged_query",
+    "transaction",
+    "ddl"
+  ],
+  "defaultSqlCapabilities": [
+    "connect",
+    "test_connection",
+    "metadata",
+    "query",
+    "paged_query",
+    "transaction",
+    "ddl"
+  ],
+  "commonMethods": [
+    "handshake",
+    "connect",
+    "test_connection",
+    "validate_connection",
+    "list_databases",
+    "list_schemas",
+    "list_tables",
+    "list_objects",
+    "list_data_types",
+    "completion_assistant_search_v1",
+    "get_object_source",
+    "get_table_ddl",
+    "get_columns",
+    "list_indexes",
+    "list_foreign_keys",
+    "list_triggers",
+    "execute_query",
+    "execute_query_page",
+    "fetch_query_page",
+    "close_query_session",
+    "start_table_read",
+    "fetch_table_read_page",
+    "close_table_read_session",
+    "get_explain_info",
+    "execute_batch",
+    "execute_transaction",
+    "disconnect",
+    "shutdown"
+  ],
+  "mongoLegacyMethods": [
+    "list_databases",
+    "list_collections",
+    "find_documents",
+    "find_documents_extended_json",
+    "server_version",
+    "create_index",
+    "drop_indexes",
+    "drop_collection",
+    "insert_document",
+    "update_document",
+    "update_documents",
+    "delete_document",
+    "delete_documents"
+  ],
+  "kvMethods": [
+    "kv_list_prefix",
+    "kv_get",
+    "kv_put",
+    "kv_delete"
+  ]
+}
diff --git a/agents/common/src/test/java/com/dbx/agent/AbstractJdbcAgentTest.java b/agents/common/src/test/java/com/dbx/agent/AbstractJdbcAgentTest.java
new file mode 100644
index 0000000..2043c63
--- /dev/null
+++ b/agents/common/src/test/java/com/dbx/agent/AbstractJdbcAgentTest.java
@@ -0,0 +1,481 @@
+package com.dbx.agent;
+
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Statement;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class AbstractJdbcAgentTest {
+    @Test
+    void ownsConnectionLifecycleAndConnectedState() {
+        TrackingConnection tracking = new TrackingConnection();
+        TestAgent agent = new TestAgent(tracking);
+
+        assertThrows(IllegalStateException.class, () -> agent.executeQuery("SELECT 1", null, new ExecuteQueryOptions()));
+
+        agent.connect(new ConnectParams("localhost", 0, "demo", "user", "secret", "", "", false));
+
+        assertNotNull(agent.getConnection());
+        assertEquals("demo", agent.database());
+        assertEquals(1, tracking.openCount);
+        assertEquals(1, agent.afterConnectCount);
+
+        agent.disconnect();
+
+        assertNull(agent.getConnection());
+        assertEquals(1, tracking.closeCount);
+    }
+
+    @Test
+    void testsConnectionsThroughSharedLifecycle() {
+        TrackingConnection tracking = new TrackingConnection();
+        TestAgent agent = new TestAgent(tracking);
+
+        assertTrue(agent.testConnection(new ConnectParams()));
+
+        assertEquals(1, tracking.openCount);
+        assertEquals(1, tracking.isValidCount);
+        assertEquals(1, tracking.closeCount);
+    }
+
+    @Test
+    void delegatesQueryExecutionWithSchemaAndValueReader() {
+        TrackingConnection tracking = new TrackingConnection();
+        TestAgent agent = new TestAgent(tracking);
+        agent.connect(new ConnectParams());
+
+        QueryResult result = agent.executeQuery("SELECT VALUE", "APP", new ExecuteQueryOptions(25, 7));
+
+        assertEquals(Collections.singletonList("VALUE"), result.getColumns());
+        assertEquals(Collections.singletonList(Collections.<Object>singletonList("row-value")), result.getRows());
+        assertFalse(result.getTruncated());
+        assertEquals(Arrays.asList("execute:USE APP", "setMaxRows:26", "setFetchSize:7", "execute:SELECT VALUE"), tracking.calls);
+    }
+
+    @Test
+    void delegatesQueryTimeoutToStatement() {
+        TrackingConnection tracking = new TrackingConnection();
+        TestAgent agent = new TestAgent(tracking);
+        agent.connect(new ConnectParams());
+
+        agent.executeQuery("SELECT VALUE", null, new ExecuteQueryOptions(25, 7, 12));
+
+        assertEquals(Arrays.asList("setMaxRows:26", "setQueryTimeout:12", "setFetchSize:7", "execute:SELECT VALUE"), tracking.calls);
+    }
+
+    @Test
+    void delegatesPagedQueryTimeoutToStatement() {
+        TrackingConnection tracking = new TrackingConnection();
+        TestAgent agent = new TestAgent(tracking);
+        agent.connect(new ConnectParams());
+
+        agent.executeQueryPage("SELECT VALUE", null, new QueryPageOptions(10, 7, 25, 12));
+
+        assertEquals(Arrays.asList("setQueryTimeout:12", "setFetchSize:7", "execute:SELECT VALUE"), tracking.calls);
+    }
+
+    @Test
+    void preservesPlSqlBlockTerminatorDuringQueryExecution() {
+        TrackingConnection tracking = new TrackingConnection();
+        TestAgent agent = new TestAgent(tracking);
+        agent.connect(new ConnectParams());
+
+        agent.executeQuery("BEGIN\n  NULL;\nEND;\n/", null, new ExecuteQueryOptions());
+
+        assertEquals(Arrays.asList("setMaxRows:10001", "execute:BEGIN\n  NULL;\nEND;"), tracking.calls);
+    }
+
+    @Test
+    void executesTransactionControlSqlThroughStatements() {
+        TrackingConnection tracking = new TrackingConnection();
+        TestAgent agent = new TestAgent(tracking);
+        agent.connect(new ConnectParams());
+
+        // Dump files can contain explicit transaction SQL while the JDBC connection is in auto-commit mode.
+        agent.executeQuery("BEGIN;", null, new ExecuteQueryOptions());
+        agent.executeQuery("BEGIN TRANSACTION;", null, new ExecuteQueryOptions());
+        agent.executeQuery("COMMIT;", null, new ExecuteQueryOptions());
+        agent.executeQuery("ROLLBACK;", null, new ExecuteQueryOptions());
+
+        assertEquals(
+            Arrays.asList(
+                "setMaxRows:10001",
+                "execute:BEGIN",
+                "setMaxRows:10001",
+                "execute:BEGIN TRANSACTION",
+                "setMaxRows:10001",
+                "execute:COMMIT",
+                "setMaxRows:10001",
+                "execute:ROLLBACK"
+            ),
+            tracking.calls
+        );
+    }
+
+    @Test
+    void executesPagedTransactionControlSqlThroughStatements() {
+        TrackingConnection tracking = new TrackingConnection();
+        TestAgent agent = new TestAgent(tracking);
+        agent.connect(new ConnectParams());
+
+        agent.executeQueryPage("COMMIT;", null, new QueryPageOptions());
+
+        assertEquals(Collections.singletonList("execute:COMMIT"), tracking.calls);
+    }
+
+    @Test
+    void delegatesTransactionsThroughSharedFoundation() {
+        TrackingConnection tracking = new TrackingConnection();
+        TestAgent agent = new TestAgent(tracking);
+        agent.connect(new ConnectParams());
+
+        QueryResult result = agent.executeTransaction(Arrays.asList("UPDATE A;", "UPDATE B"), "APP");
+
+        assertEquals(2L, result.getAffected_rows());
+        assertEquals(
+            Arrays.asList(
+                "setAutoCommit:false",
+                "execute:USE APP",
+                "executeUpdate:UPDATE A",
+                "executeUpdate:UPDATE B",
+                "commit",
+                "setAutoCommit:true"
+            ),
+            tracking.calls
+        );
+    }
+
+    @Test
+    void preservesPlSqlBlockTerminatorDuringTransactionExecution() {
+        TrackingConnection tracking = new TrackingConnection();
+        TestAgent agent = new TestAgent(tracking);
+        agent.connect(new ConnectParams());
+
+        agent.executeTransaction(Collections.singletonList("DECLARE\n  v NUMBER;\nBEGIN\n  NULL;\nEND;"), null);
+
+        assertEquals(
+            Arrays.asList(
+                "setAutoCommit:false",
+                "executeUpdate:DECLARE\n  v NUMBER;\nBEGIN\n  NULL;\nEND;",
+                "commit",
+                "setAutoCommit:true"
+            ),
+            tracking.calls
+        );
+    }
+
+    @Test
+    void inheritedDdlFallbackToleratesMissingOptionalMetadata() {
+        TestAgent agent = new TestAgent(new TrackingConnection()) {
+            @Override
+            public List<ColumnInfo> getColumns(String schema, String table) {
+                return Collections.singletonList(new ColumnInfo("ID", "INTEGER", false, null, true));
+            }
+
+            @Override
+            public List<IndexInfo> listIndexes(String schema, String table) {
+                throw new RuntimeException("indexes unavailable");
+            }
+
+            @Override
+            public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+                throw new RuntimeException("foreign keys unavailable");
+            }
+        };
+
+        assertEquals(
+            "CREATE TABLE \"APP\".\"ORDERS\" (\n" +
+                "  \"ID\" INTEGER NOT NULL,\n" +
+                "  PRIMARY KEY (\"ID\")\n" +
+                ");\n",
+            agent.getTableDdl("APP", "ORDERS")
+        );
+    }
+
+    private static class TestAgent extends AbstractJdbcAgent {
+        private final TrackingConnection tracking;
+        private int afterConnectCount;
+
+        private TestAgent(TrackingConnection tracking) {
+            this.tracking = tracking;
+        }
+
+        @Override
+        protected String driverClass() {
+            return TestAgent.class.getName();
+        }
+
+        @Override
+        protected String buildJdbcUrl(ConnectParams params) {
+            return "jdbc:test";
+        }
+
+        @Override
+        protected Connection openConnection(ConnectParams params) {
+            tracking.openCount += 1;
+            return tracking.connection();
+        }
+
+        @Override
+        protected void afterConnect(ConnectParams params, Connection connection) {
+            afterConnectCount += 1;
+        }
+
+        @Override
+        public List<DatabaseInfo> listDatabases() {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<String> listSchemas() {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<TableInfo> listTables(String schema) {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<ColumnInfo> getColumns(String schema, String table) {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<IndexInfo> listIndexes(String schema, String table) {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<TriggerInfo> listTriggers(String schema, String table) {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public String setSchemaSQL(String schema) {
+            return "USE " + schema;
+        }
+
+        private String database() {
+            return getConfiguredDatabase();
+        }
+    }
+
+    private static final class TrackingConnection {
+        private final List<String> calls = new ArrayList<String>();
+        private int openCount;
+        private int closeCount;
+        private int isValidCount;
+        private boolean autoCommit = true;
+
+        private Connection connection() {
+            return proxy(Connection.class, new MethodHandler() {
+                @Override
+                public Object handle(Method method, Object[] args) {
+                    String name = method.getName();
+                    if ("createStatement".equals(name)) {
+                        return statement();
+                    }
+                    if ("getMetaData".equals(name)) {
+                        return databaseMetaData();
+                    }
+                    if ("isValid".equals(name)) {
+                        isValidCount += 1;
+                        return true;
+                    }
+                    if ("close".equals(name)) {
+                        closeCount += 1;
+                        return null;
+                    }
+                    if ("getAutoCommit".equals(name)) {
+                        return autoCommit;
+                    }
+                    if ("setSchema".equals(name)) {
+                        calls.add("setSchema:" + args[0]);
+                        return null;
+                    }
+                    if ("setCatalog".equals(name)) {
+                        calls.add("setCatalog:" + args[0]);
+                        return null;
+                    }
+                    if ("setAutoCommit".equals(name)) {
+                        autoCommit = (Boolean) args[0];
+                        calls.add("setAutoCommit:" + args[0]);
+                        return null;
+                    }
+                    if ("commit".equals(name)) {
+                        calls.add("commit");
+                        return null;
+                    }
+                    if ("rollback".equals(name)) {
+                        calls.add("rollback");
+                        return null;
+                    }
+                    return defaultValue(method.getReturnType());
+                }
+            });
+        }
+
+        private DatabaseMetaData databaseMetaData() {
+            return proxy(DatabaseMetaData.class, new MethodHandler() {
+                @Override
+                public Object handle(Method method, Object[] args) {
+                    if ("supportsTransactions".equals(method.getName())) {
+                        return true;
+                    }
+                    return defaultValue(method.getReturnType());
+                }
+            });
+        }
+
+        private Statement statement() {
+            return proxy(Statement.class, new MethodHandler() {
+                @Override
+                public Object handle(Method method, Object[] args) {
+                    String name = method.getName();
+                    if ("execute".equals(name)) {
+                        calls.add("execute:" + args[0]);
+                        return true;
+                    }
+                    if ("getResultSet".equals(name)) {
+                        return resultSet();
+                    }
+                    if ("getUpdateCount".equals(name)) {
+                        return 1;
+                    }
+                    if ("executeUpdate".equals(name)) {
+                        calls.add("executeUpdate:" + args[0]);
+                        return 1;
+                    }
+                    if ("setMaxRows".equals(name)) {
+                        calls.add("setMaxRows:" + args[0]);
+                        return null;
+                    }
+                    if ("setFetchSize".equals(name)) {
+                        calls.add("setFetchSize:" + args[0]);
+                        return null;
+                    }
+                    if ("setQueryTimeout".equals(name)) {
+                        calls.add("setQueryTimeout:" + args[0]);
+                        return null;
+                    }
+                    if ("close".equals(name)) {
+                        return null;
+                    }
+                    return defaultValue(method.getReturnType());
+                }
+            });
+        }
+
+        private ResultSet resultSet() {
+            final int[] index = {-1};
+            return proxy(ResultSet.class, new MethodHandler() {
+                @Override
+                public Object handle(Method method, Object[] args) {
+                    String name = method.getName();
+                    if ("next".equals(name)) {
+                        index[0] += 1;
+                        return index[0] == 0;
+                    }
+                    if ("getMetaData".equals(name)) {
+                        return resultSetMetaData();
+                    }
+                    if ("getString".equals(name)) {
+                        return "row-value";
+                    }
+                    if ("wasNull".equals(name)) {
+                        return false;
+                    }
+                    if ("close".equals(name)) {
+                        return null;
+                    }
+                    return defaultValue(method.getReturnType());
+                }
+            });
+        }
+
+        private ResultSetMetaData resultSetMetaData() {
+            return proxy(ResultSetMetaData.class, new MethodHandler() {
+                @Override
+                public Object handle(Method method, Object[] args) {
+                    String name = method.getName();
+                    if ("getColumnCount".equals(name)) {
+                        return 1;
+                    }
+                    if ("getColumnLabel".equals(name)) {
+                        return "VALUE";
+                    }
+                    if ("getColumnType".equals(name)) {
+                        return Types.VARCHAR;
+                    }
+                    return defaultValue(method.getReturnType());
+                }
+            });
+        }
+    }
+
+    private static <T> T proxy(Class<T> type, final MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) {
+                return handler.handle(method, args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Byte.TYPE.equals(type)) {
+            return (byte) 0;
+        }
+        if (Short.TYPE.equals(type)) {
+            return (short) 0;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        if (Long.TYPE.equals(type)) {
+            return 0L;
+        }
+        if (Float.TYPE.equals(type)) {
+            return 0f;
+        }
+        if (Double.TYPE.equals(type)) {
+            return 0.0d;
+        }
+        if (Character.TYPE.equals(type)) {
+            return '\0';
+        }
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args);
+    }
+}
diff --git a/agents/common/src/test/java/com/dbx/agent/BatchExecutorTest.java b/agents/common/src/test/java/com/dbx/agent/BatchExecutorTest.java
new file mode 100644
index 0000000..4500e34
--- /dev/null
+++ b/agents/common/src/test/java/com/dbx/agent/BatchExecutorTest.java
@@ -0,0 +1,100 @@
+package com.dbx.agent;
+
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class BatchExecutorTest {
+    @Test
+    void executeBatchStatementsUsesJdbcBatch() {
+        List<String> batchedSql = new ArrayList<>();
+        AtomicInteger executeLargeBatchCalls = new AtomicInteger();
+        AtomicInteger executeUpdateCalls = new AtomicInteger();
+
+        Statement statement = statementProxy(batchedSql, executeLargeBatchCalls, executeUpdateCalls);
+        Connection connection = connectionProxy(statement);
+
+        QueryResult result = BatchExecutor.executeBatchStatements(
+            connection,
+            Arrays.asList(" INSERT INTO items VALUES (1); ", "UPDATE items SET name = 'Ada' WHERE id = 1;"),
+            null,
+            schema -> null
+        );
+
+        assertEquals(Arrays.asList("INSERT INTO items VALUES (1)", "UPDATE items SET name = 'Ada' WHERE id = 1"), batchedSql);
+        assertEquals(1, executeLargeBatchCalls.get());
+        assertEquals(0, executeUpdateCalls.get());
+        assertEquals(2L, result.getAffected_rows());
+    }
+
+    private static Statement statementProxy(
+        List<String> batchedSql,
+        AtomicInteger executeLargeBatchCalls,
+        AtomicInteger executeUpdateCalls
+    ) {
+        InvocationHandler handler = (Object unused, Method method, Object[] args) -> {
+            switch (method.getName()) {
+                case "addBatch":
+                    batchedSql.add((String) args[0]);
+                    return null;
+                case "executeLargeBatch":
+                    executeLargeBatchCalls.incrementAndGet();
+                    return new long[]{1L, Statement.SUCCESS_NO_INFO};
+                case "executeUpdate":
+                    executeUpdateCalls.incrementAndGet();
+                    throw new AssertionError("executeBatchStatements must not execute statements one by one");
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        };
+        return (Statement) Proxy.newProxyInstance(Statement.class.getClassLoader(), new Class<?>[]{Statement.class}, handler);
+    }
+
+    private static Connection connectionProxy(Statement statement) {
+        InvocationHandler handler = (Object unused, Method method, Object[] args) -> {
+            if ("createStatement".equals(method.getName())) {
+                return statement;
+            }
+            return defaultValue(method.getReturnType());
+        };
+        return (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), new Class<?>[]{Connection.class}, handler);
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (type == Boolean.TYPE) {
+            return false;
+        }
+        if (type == Byte.TYPE) {
+            return (byte) 0;
+        }
+        if (type == Short.TYPE) {
+            return (short) 0;
+        }
+        if (type == Integer.TYPE) {
+            return 0;
+        }
+        if (type == Long.TYPE) {
+            return 0L;
+        }
+        if (type == Float.TYPE) {
+            return 0f;
+        }
+        if (type == Double.TYPE) {
+            return 0.0d;
+        }
+        if (type == Character.TYPE) {
+            return '\0';
+        }
+        return null;
+    }
+}
diff --git a/agents/common/src/test/java/com/dbx/agent/CommonJavaCompatibilityTest.java b/agents/common/src/test/java/com/dbx/agent/CommonJavaCompatibilityTest.java
new file mode 100644
index 0000000..c2bc612
--- /dev/null
+++ b/agents/common/src/test/java/com/dbx/agent/CommonJavaCompatibilityTest.java
@@ -0,0 +1,764 @@
+package com.dbx.agent;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import org.junit.jupiter.api.Test;
+
+import java.sql.Connection;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class CommonJavaCompatibilityTest {
+    @Test
+    void definesSharedAgentProtocolContract() {
+        assertEquals("handshake", AgentProtocol.METHOD_HANDSHAKE);
+        assertEquals(1, AgentProtocol.PROTOCOL_VERSION);
+        assertTrue(AgentProtocol.CAPABILITIES.contains(AgentProtocol.CAPABILITY_CONNECT));
+        assertTrue(AgentProtocol.CAPABILITIES.contains(AgentProtocol.CAPABILITY_QUERY));
+        assertTrue(AgentProtocol.CAPABILITIES.contains(AgentProtocol.CAPABILITY_METADATA));
+    }
+
+    @Test
+    void agentProtocolMatchesContractResource() {
+        JsonObject contract = protocolContract();
+
+        assertEquals(AgentProtocol.PROTOCOL_VERSION, contract.get("protocolVersion").getAsInt());
+        assertEquals(AgentProtocol.METHOD_HANDSHAKE, contract.get("handshakeMethod").getAsString());
+        assertEquals(
+            Arrays.asList("protocolVersion", "agentProtocolVersion", "capabilities"),
+            strings(contract.getAsJsonArray("handshakeResponseFields"))
+        );
+        assertEquals(AgentProtocol.ALL_CAPABILITIES, strings(contract.getAsJsonArray("allCapabilities")));
+        assertEquals(AgentProtocol.CAPABILITIES, strings(contract.getAsJsonArray("capabilities")));
+        assertEquals(AgentProtocol.CAPABILITIES, strings(contract.getAsJsonArray("defaultSqlCapabilities")));
+        assertEquals(AgentProtocol.COMMON_METHODS, strings(contract.getAsJsonArray("commonMethods")));
+        assertEquals(AgentProtocol.MONGO_LEGACY_METHODS, strings(contract.getAsJsonArray("mongoLegacyMethods")));
+        assertEquals(AgentProtocol.KV_METHODS, strings(contract.getAsJsonArray("kvMethods")));
+    }
+
+    @Test
+    void jsonRpcServerExposesProtocolHandshake() {
+        JsonRpcServer server = new JsonRpcServer(new MinimalAgent());
+
+        String response = server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":7,\"method\":\"" + AgentProtocol.METHOD_HANDSHAKE + "\",\"params\":{\"appVersion\":\"0.5.13\",\"supportedProtocolVersions\":[1]}}"
+        );
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        JsonObject result = json.getAsJsonObject("result");
+        assertEquals("2.0", json.get("jsonrpc").getAsString());
+        assertEquals(7, json.get("id").getAsInt());
+        assertEquals(1, result.get("protocolVersion").getAsInt());
+        assertEquals(1, result.get("agentProtocolVersion").getAsInt());
+        assertTrue(containsCapability(result.getAsJsonArray("capabilities"), "connect"));
+        assertTrue(containsCapability(result.getAsJsonArray("capabilities"), "query"));
+        assertTrue(containsCapability(result.getAsJsonArray("capabilities"), "metadata"));
+    }
+
+    @Test
+    void jsonRpcServerSerializesArbitraryPrecisionNumbersAsStrings() {
+        JsonRpcServer server = new JsonRpcServer(new PreciseNumberAgent());
+
+        String response = server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":8,\"method\":\"" + AgentProtocol.METHOD_EXECUTE_QUERY + "\",\"params\":{\"sql\":\"select n from t\"}}"
+        );
+
+        JsonArray row = JsonParser.parseString(response)
+            .getAsJsonObject()
+            .getAsJsonObject("result")
+            .getAsJsonArray("rows")
+            .get(0)
+            .getAsJsonArray();
+        assertEquals("12345678901234567890.1234", row.get(0).getAsString());
+        assertTrue(row.get(0).getAsJsonPrimitive().isString());
+        assertEquals("12345678901234567890", row.get(1).getAsString());
+        assertTrue(row.get(1).getAsJsonPrimitive().isString());
+        assertEquals(42, row.get(2).getAsInt());
+        assertTrue(row.get(2).getAsJsonPrimitive().isNumber());
+    }
+
+    @Test
+    void jsonRpcServerReconnectsWhenStoredJdbcConnectionIsStale() {
+        ReconnectingAgent agent = new ReconnectingAgent();
+        JsonRpcServer server = new JsonRpcServer(agent);
+
+        server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"connect\",\"params\":{\"host\":\"db.example.com\",\"port\":1521,\"database\":\"ORCL\",\"username\":\"u\",\"password\":\"p\"}}"
+        );
+        String response = server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"list_databases\",\"params\":{}}"
+        );
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        assertTrue(json.has("result"));
+        assertEquals(2, agent.connectCount);
+        assertEquals(1, agent.disconnectCount);
+        assertEquals(1, agent.firstConnectionValidChecks);
+    }
+
+    @Test
+    void jsonRpcServerValidatesCurrentJdbcConnection() {
+        ReconnectingAgent agent = new ReconnectingAgent();
+        JsonRpcServer server = new JsonRpcServer(agent);
+
+        server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"connect\",\"params\":{\"host\":\"db.example.com\",\"port\":1521,\"database\":\"ORCL\",\"username\":\"u\",\"password\":\"p\"}}"
+        );
+        String response = server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"" + AgentProtocol.METHOD_VALIDATE_CONNECTION + "\",\"params\":{}}"
+        );
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        assertTrue(json.has("error"));
+        assertEquals(1, agent.connectCount);
+        assertEquals(1, agent.firstConnectionValidChecks);
+    }
+
+    @Test
+    void jsonRpcServerSwitchesCatalogBeforeMetadataCalls() {
+        CatalogSwitchAgent agent = new CatalogSwitchAgent();
+        JsonRpcServer server = new JsonRpcServer(agent);
+
+        String response = server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"" + AgentProtocol.METHOD_LIST_TABLES + "\",\"params\":{\"database\":\"sales\",\"schema\":\"app\"}}"
+        );
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        assertTrue(json.has("result"));
+        assertEquals("sales", agent.catalogs.get(0));
+        assertEquals("app", agent.lastSchema);
+    }
+
+    @Test
+    void jsonRpcServerAppliesConstrainedTableMetadataRequests() {
+        MetadataConstraintAgent agent = new MetadataConstraintAgent();
+        JsonRpcServer server = new JsonRpcServer(agent);
+
+        String response = server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":4,\"method\":\"" + AgentProtocol.METHOD_LIST_TABLES + "\",\"params\":{\"schema\":\"app\",\"filter\":\"us\",\"limit\":1,\"offset\":1,\"object_types\":[\"TABLE\"]}}"
+        );
+
+        JsonArray result = JsonParser.parseString(response).getAsJsonObject().getAsJsonArray("result");
+        assertEquals(1, result.size());
+        assertEquals("user_settings", result.get(0).getAsJsonObject().get("name").getAsString());
+        assertEquals("app", agent.lastSchema);
+    }
+
+    @Test
+    void jsonRpcServerAppliesConstrainedObjectMetadataRequests() {
+        MetadataConstraintAgent agent = new MetadataConstraintAgent();
+        JsonRpcServer server = new JsonRpcServer(agent);
+
+        String response = server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":5,\"method\":\"" + AgentProtocol.METHOD_LIST_OBJECTS + "\",\"params\":{\"schema\":\"app\",\"filter\":\"fn\",\"limit\":1,\"offset\":1,\"object_types\":[\"FUNCTION\"]}}"
+        );
+
+        JsonArray result = JsonParser.parseString(response).getAsJsonObject().getAsJsonArray("result");
+        assertEquals(1, result.size());
+        assertEquals("fetch_name", result.get(0).getAsJsonObject().get("name").getAsString());
+        assertEquals("FUNCTION", result.get(0).getAsJsonObject().get("object_type").getAsString());
+    }
+
+    @Test
+    void jsonRpcServerDispatchesTableReadSessionMethods() {
+        TableReadDispatchAgent agent = new TableReadDispatchAgent();
+        JsonRpcServer server = new JsonRpcServer(agent);
+
+        String startResponse = server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":11,\"method\":\"" + AgentProtocol.METHOD_START_TABLE_READ + "\",\"params\":{\"sql\":\"select * from orders\",\"schema\":\"public\",\"pageSize\":2,\"fetchSize\":8,\"maxRows\":20,\"timeoutSecs\":3}}"
+        );
+        JsonObject startJson = JsonParser.parseString(startResponse).getAsJsonObject();
+
+        assertTrue(startJson.has("result"));
+        assertEquals("select * from orders", agent.lastSql);
+        assertEquals("public", agent.lastSchema);
+        assertEquals(new QueryPageOptions(2, 8, 20, 3), agent.lastOptions);
+        assertEquals("table-session", startJson.getAsJsonObject("result").get("session_id").getAsString());
+
+        String fetchResponse = server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":12,\"method\":\"" + AgentProtocol.METHOD_FETCH_TABLE_READ_PAGE + "\",\"params\":{\"sessionId\":\"table-session\",\"pageSize\":4}}"
+        );
+        JsonObject fetchJson = JsonParser.parseString(fetchResponse).getAsJsonObject();
+
+        assertTrue(fetchJson.has("result"));
+        assertEquals("table-session", agent.fetchedSessionId);
+        assertEquals(4, agent.fetchedPageSize);
+        assertFalse(fetchJson.getAsJsonObject("result").get("has_more").getAsBoolean());
+
+        String closeResponse = server.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":13,\"method\":\"" + AgentProtocol.METHOD_CLOSE_TABLE_READ_SESSION + "\",\"params\":{\"sessionId\":\"table-session\"}}"
+        );
+        JsonObject closeJson = JsonParser.parseString(closeResponse).getAsJsonObject();
+
+        assertTrue(closeJson.get("result").getAsBoolean());
+        assertEquals("table-session", agent.closedSessionId);
+    }
+
+
+    @Test
+    void exposesJavaFriendlyDefaultsAndModels() {
+        ConnectParams params = new ConnectParams("localhost", 5432, "demo", "user", "secret", "ssl=false", "", false);
+        assertEquals("localhost", params.getHost());
+        assertEquals("ssl=false", params.getUrl_params());
+
+        TableInfo table = new TableInfo("orders", "TABLE");
+        assertEquals("TABLE", table.getTable_type());
+
+        QueryResult result = new QueryResult(
+            Collections.singletonList("id"),
+            Collections.singletonList(Collections.singletonList(1)),
+            2L,
+            3L
+        );
+        assertEquals(2L, result.getAffected_rows());
+        assertEquals(3L, result.getExecution_time_ms());
+        assertFalse(result.getTruncated());
+
+        QueryPageResult page = new QueryPageResult(
+            Collections.singletonList("id"),
+            Collections.emptyList(),
+            0L,
+            1L,
+            false,
+            "session-1",
+            true
+        );
+        assertEquals("session-1", page.getSession_id());
+        assertEquals(true, page.getHas_more());
+
+        assertEquals(JdbcExecutor.DEFAULT_MAX_ROWS, new ExecuteQueryOptions().getMaxRows());
+        assertEquals(100, new QueryPageOptions().getPageSize());
+        assertNotNull(JdbcExecutor.INSTANCE);
+    }
+
+    @Test
+    void exposesDatabaseAgentDefaultMethodsToJavaImplementors() {
+        DatabaseAgent agent = new MinimalAgent();
+
+        assertEquals(1, agent.listObjects("public").size());
+        assertThrows(UnsupportedOperationException.class, () ->
+            agent.getObjectSource("public", "orders", "TABLE")
+        );
+        assertEquals("SET SCHEMA \"public\"", agent.setSchemaSQL("public"));
+        assertThrows(IllegalStateException.class, () ->
+            agent.executeQueryPage("select 1", "public")
+        );
+        assertThrows(IllegalStateException.class, () ->
+            agent.startTableRead("select 1", "public", new QueryPageOptions())
+        );
+        assertEquals(0L, agent.executeQuery("select 1", "public").getAffected_rows());
+
+        String ddl = DatabaseAgent.buildTableDdl(
+            "public",
+            "orders",
+            Collections.singletonList(new ColumnInfo("id", "integer", false, null, true)),
+            Collections.singletonList(new IndexInfo("orders_name_idx", Collections.singletonList("name"), false, false)),
+            Collections.singletonList(new ForeignKeyInfo("orders_customer_fk", "customer_id", "customers", "id"))
+        );
+        assertEquals(
+            "CREATE TABLE \"public\".\"orders\" (\n" +
+                "  \"id\" integer NOT NULL,\n" +
+                "  PRIMARY KEY (\"id\"),\n" +
+                "  CONSTRAINT \"orders_customer_fk\" FOREIGN KEY (\"customer_id\") REFERENCES \"customers\"(\"id\")\n" +
+                ");\n\n" +
+                "CREATE INDEX \"orders_name_idx\" ON \"public\".\"orders\" (\"name\");",
+            ddl
+        );
+    }
+
+    @Test
+    void databaseAgentDefaultConstraintsFilterLegacyMetadataOverrides() {
+        DatabaseAgent agent = new LegacyObjectTypeAgent();
+
+        List<TableInfo> tables = agent.listTables(
+            "public",
+            new MetadataListConstraints("us", 1, 1, Collections.singletonList("TABLE"))
+        );
+        assertEquals(1, tables.size());
+        assertEquals("user_settings", tables.get(0).getName());
+
+        List<ObjectInfo> objects = agent.listObjects(
+            "public",
+            new MetadataListConstraints("us", 1, 0, Collections.singletonList("VIEW"))
+        );
+        assertEquals(1, objects.size());
+        assertEquals("usage_view", objects.get(0).getName());
+    }
+
+    @Test
+    void metadataConstraintsTreatTdengineStableAsTable() {
+        MetadataListConstraints constraints =
+            new MetadataListConstraints(null, null, null, Collections.singletonList("TABLE"));
+        TableInfo stable = new TableInfo("meters", "STABLE", null, null, null);
+
+        List<TableInfo> tables = constraints.filterTables(Collections.singletonList(stable));
+
+        assertEquals(Collections.singletonList(stable), tables);
+    }
+
+    @Test
+    void metadataConstraintsMatchTableAndObjectComments() {
+        MetadataListConstraints tableConstraints =
+            new MetadataListConstraints("account", null, null, Collections.singletonList("TABLE"));
+        List<TableInfo> tables = tableConstraints.filterTables(Arrays.asList(
+            new TableInfo("orders", "TABLE", "sales archive"),
+            new TableInfo("profile", "TABLE", "customer account data"),
+            new TableInfo("account_view", "VIEW", "ignored by type")
+        ));
+        assertEquals(1, tables.size());
+        assertEquals("profile", tables.get(0).getName());
+
+        MetadataListConstraints objectConstraints =
+            new MetadataListConstraints("revenue", null, null, Collections.singletonList("VIEW"));
+        List<ObjectInfo> objects = objectConstraints.filterObjects(Arrays.asList(
+            new ObjectInfo("order_view", "VIEW", "public", "monthly revenue summary"),
+            new ObjectInfo("sync_user", "PROCEDURE", "public", "sync revenue data"),
+            new ObjectInfo("audit_log", "TABLE", "public", "audit records")
+        ));
+        assertEquals(1, objects.size());
+        assertEquals("order_view", objects.get(0).getName());
+    }
+
+    @Test
+    void executesTransactionsOneByOneWhenJdbcDriverDoesNotSupportTransactions() {
+        List<String> calls = new ArrayList<>();
+        DatabaseAgent agent = new TransactionAgent(nonTransactionalConnection(calls));
+
+        QueryResult result = agent.executeTransaction(Arrays.asList("UPDATE A SET ID = 1", "UPDATE B SET ID = 2"), "APP");
+
+        assertEquals(2L, result.getAffected_rows());
+        assertEquals(
+            Arrays.asList("supportsTransactions", "execute:SET SCHEMA \"APP\"", "executeUpdate:UPDATE A SET ID = 1", "executeUpdate:UPDATE B SET ID = 2"),
+            calls
+        );
+    }
+
+    @Test
+    void buildsTableDdlWithoutSchemaQualifierWhenSchemaIsBlank() {
+        String ddl = DatabaseAgent.buildTableDdl(
+            "",
+            "orders",
+            Collections.singletonList(new ColumnInfo("id", "integer", false, null, true)),
+            Collections.emptyList(),
+            Collections.emptyList()
+        );
+
+        assertEquals(
+                "CREATE TABLE \"orders\" (\n" +
+                "  \"id\" integer NOT NULL,\n" +
+                "  PRIMARY KEY (\"id\")\n" +
+                ");\n",
+            ddl
+        );
+    }
+
+    @Test
+    void buildsTableDdlWithColumnComments() {
+        String ddl = DdlBuilder.buildTableDdl(
+            "public",
+            "orders",
+            Collections.singletonList(new ColumnInfo(
+                "display_name",
+                "varchar",
+                true,
+                null,
+                false,
+                null,
+                "User's display name",
+                null,
+                null,
+                64
+            )),
+            Collections.emptyList(),
+            Collections.emptyList(),
+            false,
+            true
+        );
+
+        assertEquals(
+            "CREATE TABLE \"public\".\"orders\" (\n" +
+                "  \"display_name\" varchar(64)\n" +
+                ");\n\n" +
+                "COMMENT ON COLUMN \"public\".\"orders\".\"display_name\" IS 'User''s display name';",
+            ddl
+        );
+    }
+
+    private static class MinimalAgent implements DatabaseAgent {
+        @Override
+        public void connect(ConnectParams params) {
+        }
+
+        @Override
+        public boolean testConnection(ConnectParams params) {
+            return true;
+        }
+
+        @Override
+        public List<DatabaseInfo> listDatabases() {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<String> listSchemas() {
+            return Collections.singletonList("public");
+        }
+
+        @Override
+        public List<TableInfo> listTables(String schema) {
+            return Collections.singletonList(new TableInfo("orders", "TABLE"));
+        }
+
+        @Override
+        public List<ColumnInfo> getColumns(String schema, String table) {
+            return Arrays.asList(
+                new ColumnInfo("id", "integer", false, null, true),
+                new ColumnInfo("name", "character varying", true, null, false, null, null, null, null, 255)
+            );
+        }
+
+        @Override
+        public List<IndexInfo> listIndexes(String schema, String table) {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public List<TriggerInfo> listTriggers(String schema, String table) {
+            return Collections.emptyList();
+        }
+
+        @Override
+        public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+            return new QueryResult(Collections.emptyList(), Collections.emptyList(), 0L, 0L);
+        }
+
+        @Override
+        public void disconnect() {
+        }
+
+        @Override
+        public Connection getConnection() {
+            return null;
+        }
+    }
+
+    private static final class TransactionAgent extends MinimalAgent {
+        private final Connection connection;
+
+        private TransactionAgent(Connection connection) {
+            this.connection = connection;
+        }
+
+        @Override
+        public Connection getConnection() {
+            return connection;
+        }
+    }
+
+    private static final class LegacyObjectTypeAgent extends MinimalAgent {
+        @Override
+        public List<TableInfo> listTables(String schema) {
+            return Arrays.asList(
+                new TableInfo("orders", "TABLE"),
+                new TableInfo("usage_view", "VIEW"),
+                new TableInfo("users", "TABLE"),
+                new TableInfo("user_settings", "TABLE")
+            );
+        }
+
+        @Override
+        public List<TableInfo> listTables(String schema, List<String> objectTypes) {
+            List<TableInfo> result = listTables(schema);
+            if (objectTypes == null || objectTypes.isEmpty()) {
+                return result;
+            }
+            List<TableInfo> filtered = new ArrayList<>();
+            for (TableInfo table : result) {
+                if (objectTypes.contains(table.getTable_type())) {
+                    filtered.add(table);
+                }
+            }
+            return filtered;
+        }
+    }
+
+    private static final class PreciseNumberAgent extends MinimalAgent {
+        @Override
+        public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+            return new QueryResult(
+                Arrays.asList("decimal_value", "integer_value", "safe_int"),
+                Collections.singletonList(Arrays.asList(
+                    new BigDecimal("12345678901234567890.1234"),
+                    new BigInteger("12345678901234567890"),
+                    42
+                )),
+                0L,
+                0L
+            );
+        }
+    }
+
+    private static final class ReconnectingAgent extends MinimalAgent {
+        private int connectCount;
+        private int disconnectCount;
+        private int firstConnectionValidChecks;
+        private Connection connection;
+
+        @Override
+        public void connect(ConnectParams params) {
+            connectCount += 1;
+            final int connectionNumber = connectCount;
+            connection = proxy(Connection.class, (method, args) -> {
+                String name = method.getName();
+                if ("isClosed".equals(name)) {
+                    return false;
+                }
+                if ("isValid".equals(name)) {
+                    if (connectionNumber == 1) {
+                        firstConnectionValidChecks += 1;
+                        return false;
+                    }
+                    return true;
+                }
+                if ("close".equals(name)) {
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            });
+        }
+
+        @Override
+        public void disconnect() {
+            disconnectCount += 1;
+        }
+
+        @Override
+        public Connection getConnection() {
+            return connection;
+        }
+    }
+
+    private static final class CatalogSwitchAgent extends MinimalAgent {
+        private final List<String> catalogs = new ArrayList<>();
+        private String lastSchema = "";
+
+        @Override
+        public Connection getConnection() {
+            return proxy(Connection.class, (method, args) -> {
+                if ("setCatalog".equals(method.getName())) {
+                    catalogs.add(String.valueOf(args[0]));
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            });
+        }
+
+        @Override
+        public List<TableInfo> listTables(String schema) {
+            lastSchema = schema;
+            return super.listTables(schema);
+        }
+    }
+
+    private static final class MetadataConstraintAgent extends MinimalAgent {
+        private String lastSchema = "";
+
+        @Override
+        public Connection getConnection() {
+            return proxy(Connection.class, (method, args) -> {
+                if ("isClosed".equals(method.getName())) {
+                    return false;
+                }
+                if ("isValid".equals(method.getName())) {
+                    return true;
+                }
+                return defaultValue(method.getReturnType());
+            });
+        }
+
+        @Override
+        public List<TableInfo> listTables(String schema) {
+            lastSchema = schema;
+            return Arrays.asList(
+                new TableInfo("orders", "TABLE"),
+                new TableInfo("users", "TABLE"),
+                new TableInfo("usage_view", "VIEW"),
+                new TableInfo("user_settings", "TABLE")
+            );
+        }
+
+        @Override
+        public List<ObjectInfo> listObjects(String schema) {
+            return Arrays.asList(
+                new ObjectInfo("orders", "TABLE", schema, null),
+                new ObjectInfo("find_user", "FUNCTION", schema, null),
+                new ObjectInfo("fetch_name", "FUNCTION", schema, null),
+                new ObjectInfo("cleanup_user", "PROCEDURE", schema, null)
+            );
+        }
+    }
+
+    private static final class TableReadDispatchAgent extends MinimalAgent {
+        private String lastSql;
+        private String lastSchema;
+        private QueryPageOptions lastOptions;
+        private String fetchedSessionId;
+        private int fetchedPageSize;
+        private String closedSessionId;
+
+        @Override
+        public QueryPageResult startTableRead(String sql, String schema, QueryPageOptions options) {
+            lastSql = sql;
+            lastSchema = schema;
+            lastOptions = options;
+            return new QueryPageResult(
+                Collections.singletonList("id"),
+                Collections.singletonList(Collections.singletonList(1)),
+                0L,
+                5L,
+                false,
+                "table-session",
+                true
+            );
+        }
+
+        @Override
+        public QueryPageResult fetchTableReadPage(String sessionId, int pageSize) {
+            fetchedSessionId = sessionId;
+            fetchedPageSize = pageSize;
+            return new QueryPageResult(
+                Collections.singletonList("id"),
+                Collections.singletonList(Collections.singletonList(2)),
+                0L,
+                0L,
+                false,
+                null,
+                false
+            );
+        }
+
+        @Override
+        public boolean closeTableReadSession(String sessionId) {
+            closedSessionId = sessionId;
+            return "table-session".equals(sessionId);
+        }
+    }
+
+    private static Connection nonTransactionalConnection(List<String> calls) {
+        return proxy(Connection.class, (method, args) -> {
+            String name = method.getName();
+            if ("getMetaData".equals(name)) {
+                return proxy(java.sql.DatabaseMetaData.class, (metaMethod, metaArgs) -> {
+                    if ("supportsTransactions".equals(metaMethod.getName())) {
+                        calls.add("supportsTransactions");
+                        return false;
+                    }
+                    return defaultValue(metaMethod.getReturnType());
+                });
+            }
+            if ("createStatement".equals(name)) {
+                return proxy(java.sql.Statement.class, (stmtMethod, stmtArgs) -> {
+                    if ("execute".equals(stmtMethod.getName())) {
+                        calls.add("execute:" + stmtArgs[0]);
+                        return false;
+                    }
+                    if ("executeUpdate".equals(stmtMethod.getName())) {
+                        calls.add("executeUpdate:" + stmtArgs[0]);
+                        return 1;
+                    }
+                    return defaultValue(stmtMethod.getReturnType());
+                });
+            }
+            if ("setSchema".equals(name)) {
+                calls.add("setSchema:" + args[0]);
+                return null;
+            }
+            if ("setCatalog".equals(name)) {
+                calls.add("setCatalog:" + args[0]);
+                return null;
+            }
+            if ("setAutoCommit".equals(name) || "commit".equals(name) || "rollback".equals(name)) {
+                calls.add(name);
+                return null;
+            }
+            if ("getAutoCommit".equals(name)) {
+                return true;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static <T> T proxy(Class<T> type, MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) {
+                return handler.handle(method, args == null ? new Object[0] : args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        if (Long.TYPE.equals(type)) {
+            return 0L;
+        }
+        return null;
+    }
+
+    private static boolean containsCapability(JsonArray capabilities, String expected) {
+        for (int i = 0; i < capabilities.size(); i++) {
+            if (expected.equals(capabilities.get(i).getAsString())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static JsonObject protocolContract() {
+        InputStream stream = CommonJavaCompatibilityTest.class.getResourceAsStream("/agent-protocol-v1.json");
+        if (stream == null) {
+            throw new AssertionError("agent-protocol-v1.json resource missing");
+        }
+        return JsonParser.parseReader(new InputStreamReader(stream, StandardCharsets.UTF_8)).getAsJsonObject();
+    }
+
+    private static List<String> strings(JsonArray array) {
+        List<String> result = new ArrayList<>();
+        for (int i = 0; i < array.size(); i++) {
+            result.add(array.get(i).getAsString());
+        }
+        return result;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args);
+    }
+}
diff --git a/agents/common/src/test/java/com/dbx/agent/ConfiguredJdbcAgentTest.java b/agents/common/src/test/java/com/dbx/agent/ConfiguredJdbcAgentTest.java
new file mode 100644
index 0000000..7a24343
--- /dev/null
+++ b/agents/common/src/test/java/com/dbx/agent/ConfiguredJdbcAgentTest.java
@@ -0,0 +1,91 @@
+package com.dbx.agent;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class ConfiguredJdbcAgentTest {
+    @Test
+    void buildsJdbcUrlFromProfileTemplateAndUrlParams() {
+        JdbcAgentProfile profile = new JdbcAgentProfile(
+            "com.example.Driver",
+            "jdbc:example://{host}:{port}/{database}"
+        );
+
+        String url = profile.buildUrl(
+            new ConnectParams(
+                "127.0.0.1",
+                1234,
+                "demo",
+                "",
+                "",
+                "ssl=false",
+                "",
+                false
+            )
+        );
+
+        assertEquals("jdbc:example://127.0.0.1:1234/demo?ssl=false", url);
+    }
+
+    @Test
+    void usesExplicitConnectionStringBeforeTemplate() {
+        JdbcAgentProfile profile = new JdbcAgentProfile(
+            "com.example.Driver",
+            "jdbc:example://{host}:{port}/{database}"
+        );
+
+        String url = profile.buildUrl(
+            new ConnectParams(
+                "127.0.0.1",
+                1234,
+                "demo",
+                "",
+                "",
+                "",
+                "jdbc:example://server:4321/prod",
+                false
+            )
+        );
+
+        assertEquals("jdbc:example://server:4321/prod", url);
+    }
+
+    @Test
+    void usesDefaultPortWhenParamsOmitPort() {
+        JdbcAgentProfile profile = new JdbcAgentProfile(
+            "com.example.Driver",
+            "jdbc:example://{host}:{port}/{database}",
+            9999
+        );
+
+        String url = profile.buildUrl(
+            new ConnectParams(
+                "127.0.0.1",
+                0,
+                "demo",
+                "",
+                "",
+                "",
+                "",
+                false
+            )
+        );
+
+        assertEquals("jdbc:example://127.0.0.1:9999/demo", url);
+    }
+
+    @Test
+    void canDisableSchemaSwitchingForDriversThatDoNotSupportContextChanges() {
+        ConfiguredJdbcAgent agent = new ConfiguredJdbcAgent(
+            new JdbcAgentProfile(
+                "com.example.Driver",
+                "jdbc:example://{host}:{port}/{database}",
+                0,
+                true
+            )
+        ) {};
+
+        assertEquals("", agent.setSchemaSQL("APP"));
+    }
+}
diff --git a/agents/common/src/test/java/com/dbx/agent/EwkbWktDecoderTest.java b/agents/common/src/test/java/com/dbx/agent/EwkbWktDecoderTest.java
new file mode 100644
index 0000000..3be5431
--- /dev/null
+++ b/agents/common/src/test/java/com/dbx/agent/EwkbWktDecoderTest.java
@@ -0,0 +1,163 @@
+package com.dbx.agent;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class EwkbWktDecoderTest {
+
+    private static byte[] hex(String s) {
+        s = s.replace(" ", "");
+        if (s.startsWith("0x") || s.startsWith("0X")) s = s.substring(2);
+        byte[] out = new byte[s.length() / 2];
+        for (int i = 0; i < out.length; i++) {
+            int hi = Character.digit(s.charAt(i * 2), 16);
+            int lo = Character.digit(s.charAt(i * 2 + 1), 16);
+            out[i] = (byte) ((hi << 4) | lo);
+        }
+        return out;
+    }
+
+    // ──────────────────────────────────────────────────────────────────────
+    // Cross-checked against the Rust ewkb_to_wkt tests in
+    // crates/dbx-core/src/db/postgres.rs (same hex inputs, same expected WKT).
+    // ──────────────────────────────────────────────────────────────────────
+
+    @Test
+    void decodesPointWithSridFromRustFixture() {
+        byte[] raw = hex("0101000020E6100000C520B07268195D404E62105839F44340");
+        assertEquals("POINT(116.397 39.908)", EwkbWktDecoder.decode(raw));
+    }
+
+    @Test
+    void decodesMultiPolygonFromRustFixture() {
+        byte[] raw = hex(
+            "0106000020E610000002000000010300000001000000050000000000000000005D40000000000000444000000000"
+                + "00405D4000000000000044400000000000405D4000000000008044400000000000005D40000000000080444000"
+                + "00000000005D400000000000004440010300000001000000050000000000000000805D40000000000080434000"
+                + "00000000C05D4000000000008043400000000000C05D4000000000000044400000000000805D40000000000000"
+                + "44400000000000805D400000000000804340"
+        );
+        assertEquals(
+            "MULTIPOLYGON(((116 40,117 40,117 41,116 41,116 40)),((118 39,119 39,119 40,118 40,118 39)))",
+            EwkbWktDecoder.decode(raw)
+        );
+    }
+
+    @Test
+    void decodesGeometryCollectionFromRustFixture() {
+        byte[] raw = hex(
+            "0107000020E61000000200000001010000000000000000005D40000000000000444001020000000200000000000000"
+                + "00405D4000000000008044400000000000805D400000000000004540"
+        );
+        assertEquals(
+            "GEOMETRYCOLLECTION(POINT(116 40),LINESTRING(117 41,118 42))",
+            EwkbWktDecoder.decode(raw)
+        );
+    }
+
+    @Test
+    void decodesHexStringWithoutPrefix() {
+        String hex = "0101000020E6100000C520B07268195D404E62105839F44340";
+        assertEquals("POINT(116.397 39.908)", EwkbWktDecoder.decode(hex));
+    }
+
+    @Test
+    void decodesHexStringWith0xPrefix() {
+        String hex = "0x0101000020E6100000C520B07268195D404E62105839F44340";
+        assertEquals("POINT(116.397 39.908)", EwkbWktDecoder.decode(hex));
+    }
+
+    @Test
+    void preservesAlreadyWktTextFromStAsText() {
+        String wkt = "POINT(116.397 39.908)";
+        assertEquals(wkt, EwkbWktDecoder.decode(wkt));
+    }
+
+    @Test
+    void preservesAlreadyEwktTextWithSrid() {
+        String ewkt = "SRID=4326;POINT(116.397 39.908)";
+        assertEquals(ewkt, EwkbWktDecoder.decode(ewkt));
+    }
+
+    @Test
+    void truncatedBytesFallBackToHex() {
+        // First few bytes of a valid point but truncated mid-coordinate.
+        byte[] raw = hex("0101000020E6100000C520B072");
+        Object decoded = EwkbWktDecoder.decode(raw);
+        assertTrue(decoded instanceof String);
+        String s = (String) decoded;
+        assertTrue(s.startsWith("0x"), "expected hex fallback, got: " + s);
+        assertEquals("0x0101000020e6100000c520b072", s);
+    }
+
+    @Test
+    void unparseableHexStringPreservedWithHexPrefix() {
+        // Looks like hex (even, leading 01), but bytes are not valid EWKB.
+        String mostly = "0123456789ABCDEF";
+        Object decoded = EwkbWktDecoder.decode(mostly);
+        assertTrue(decoded instanceof String);
+        // Shape A: parseEwkb returns null, so we re-emit the input ensuring 0x prefix.
+        assertTrue(((String) decoded).toLowerCase().startsWith("0x"), decoded.toString());
+    }
+
+    @Test
+    void nullInputReturnsNull() {
+        assertNull(EwkbWktDecoder.decode(null));
+    }
+
+    @Test
+    void formatsWholeNumberDoublesWithoutTrailingDot() {
+        // Ensure POINT(116 40) is "116 40", not "116.0 40.0" — matches Rust f64 Display.
+        byte[] raw = hex("0101000020E61000000000000000005D400000000000004440");
+        assertEquals("POINT(116 40)", EwkbWktDecoder.decode(raw));
+    }
+
+    @Test
+    void emptyPointBecomesPointEmpty() {
+        // A 2D point with both coordinates = NaN encodes as "POINT EMPTY" in the decoder.
+        // EWKB: little-endian Point with SRID=0 omitted; type=1, then two NaN doubles.
+        byte[] raw = hex("0101000000" + nanLe() + nanLe());
+        assertEquals("POINT EMPTY", EwkbWktDecoder.decode(raw));
+    }
+
+    private static String nanLe() {
+        // IEEE 754 quiet NaN, little-endian — same value Rust's f64::NAN encodes to.
+        long bits = Double.doubleToRawLongBits(Double.NaN);
+        StringBuilder sb = new StringBuilder(16);
+        for (int i = 0; i < 8; i++) {
+            int b = (int) ((bits >>> (i * 8)) & 0xFF);
+            sb.append(String.format("%02x", b));
+        }
+        return sb.toString();
+    }
+
+    @Test
+    void pgGeometryReflectiveDecodeReturnsValueText() {
+        // Synthetic stand-in for org.postgis.PGgeometry — same shape: getValue() returns EWKT.
+        Object pgGeom = new FakePGgeometry("SRID=4326;POINT(116.397 39.908)");
+        assertEquals("SRID=4326;POINT(116.397 39.908)", EwkbWktDecoder.decode(pgGeom));
+    }
+
+    @SuppressWarnings("unused")
+    public static final class FakePGgeometry {
+        private final String value;
+
+        public FakePGgeometry(String value) {
+            this.value = value;
+        }
+
+        // Class name won't match the reflective list so this falls through to toString();
+        // we keep it here purely to assert the toString() fallback also works (no NPE).
+        public String getValue() {
+            return value;
+        }
+
+        @Override
+        public String toString() {
+            return value;
+        }
+    }
+}
diff --git a/agents/common/src/test/java/com/dbx/agent/JdbcAgentProfileExtendedTest.java b/agents/common/src/test/java/com/dbx/agent/JdbcAgentProfileExtendedTest.java
new file mode 100644
index 0000000..e8848f2
--- /dev/null
+++ b/agents/common/src/test/java/com/dbx/agent/JdbcAgentProfileExtendedTest.java
@@ -0,0 +1,109 @@
+package com.dbx.agent;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class JdbcAgentProfileExtendedTest {
+    @Test
+    void appendsQueryParamsToJdbcUrlTemplates() {
+        JdbcAgentProfile profile = new JdbcAgentProfile(
+            "example.Driver",
+            "jdbc:example://{host}:{port}/{database}",
+            1234
+        );
+        ConnectParams params = new ConnectParams();
+        params.setHost("db.example.com");
+        params.setPort(0);
+        params.setDatabase("analytics");
+        params.setUrl_params("ssl=true");
+
+        assertEquals("jdbc:example://db.example.com:1234/analytics?ssl=true", profile.buildUrl(params));
+    }
+
+    @Test
+    void appendsSemicolonParamsToSemicolonJdbcUrlTemplates() {
+        JdbcAgentProfile profile = new JdbcAgentProfile(
+            "example.Driver",
+            "jdbc:exa:{host}:{port};schema={database}",
+            8563
+        );
+        ConnectParams params = new ConnectParams();
+        params.setHost("db.example.com");
+        params.setPort(0);
+        params.setDatabase("analytics");
+        params.setUrl_params("encryption=1");
+
+        assertEquals("jdbc:exa:db.example.com:8563;schema=analytics;encryption=1", profile.buildUrl(params));
+    }
+
+    @Test
+    void appendsCommaParamsToTeradataJdbcUrlTemplates() {
+        JdbcAgentProfile profile = new JdbcAgentProfile(
+            "example.Driver",
+            "jdbc:teradata://{host}/DBS_PORT={port},DATABASE={database}",
+            1025
+        );
+        ConnectParams params = new ConnectParams();
+        params.setHost("db.example.com");
+        params.setPort(0);
+        params.setDatabase("analytics");
+        params.setUrl_params("LOGMECH=LDAP");
+
+        assertEquals("jdbc:teradata://db.example.com/DBS_PORT=1025,DATABASE=analytics,LOGMECH=LDAP", profile.buildUrl(params));
+    }
+
+    @Test
+    void appendsColonPropertiesToDb2JdbcUrlTemplates() {
+        JdbcAgentProfile profile = new JdbcAgentProfile(
+            "example.Driver",
+            "jdbc:db2://{host}:{port}/{database}",
+            50000
+        );
+        ConnectParams params = new ConnectParams();
+        params.setHost("db.example.com");
+        params.setPort(0);
+        params.setDatabase("analytics");
+        params.setUrl_params("sslConnection=true");
+
+        assertEquals("jdbc:db2://db.example.com:50000/analytics:sslConnection=true;", profile.buildUrl(params));
+    }
+
+    @Test
+    void preservesExplicitConnectionStringForVendorSpecificUrls() {
+        JdbcAgentProfile profile = new JdbcAgentProfile(
+            "example.Driver",
+            "jdbc:example://{host}:{port}/{database}",
+            1234
+        );
+        ConnectParams params = new ConnectParams();
+        params.setConnection_string("jdbc:example:special://host/path;token=secret");
+
+        assertEquals("jdbc:example:special://host/path;token=secret", profile.buildUrl(params));
+    }
+
+    @Test
+    void exposesDialectProfileOptions() {
+        JdbcAgentProfile profile = new JdbcAgentProfile(
+            "example.Driver",
+            "jdbc:example://{host}:{port}/{database}",
+            1234,
+            false,
+            java.util.Collections.singleton("SYS"),
+            java.util.Arrays.asList("TABLE", "VIEW"),
+            "`",
+            "USE",
+            false,
+            true,
+            true,
+            true
+        );
+
+        assertEquals("USE `analytics``prod`", profile.schemaSwitchSql("analytics`prod"));
+        assertEquals("`orders`", profile.quoteIdentifier("orders"));
+        assertEquals(false, profile.getCatalogFallbackEnabled());
+        assertEquals(true, profile.getNativeTableDdlSupported());
+        assertEquals(true, profile.getObjectSourceSupported());
+        assertEquals(true, profile.getTriggersSupported());
+    }
+}
diff --git a/agents/common/src/test/java/com/dbx/agent/JdbcExecutorTest.java b/agents/common/src/test/java/com/dbx/agent/JdbcExecutorTest.java
new file mode 100644
index 0000000..6d54dfc
--- /dev/null
+++ b/agents/common/src/test/java/com/dbx/agent/JdbcExecutorTest.java
@@ -0,0 +1,265 @@
+package com.dbx.agent;
+
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import javax.sql.rowset.serial.SerialBlob;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class JdbcExecutorTest {
+    @Test
+    void stringResultValueFormatsBlobWithoutUsingStringConversion() throws Exception {
+        ResultSet rs = resultSet(
+            new byte[]{0x01, 0x2A, (byte) 0xFF},
+            () -> {
+                throw new AssertionError("BLOB columns should not be read with getString");
+            }
+        );
+
+        assertEquals("0x012aff", JdbcExecutor.stringResultValue(rs, 1, Types.BLOB));
+    }
+
+    @Test
+    void defaultResultValueReadsClobColumnsAsText() throws Exception {
+        ResultSet rs = resultSet(null, () -> "hello clob");
+
+        assertEquals("hello clob", JdbcExecutor.INSTANCE.defaultResultValue(rs, 1, Types.CLOB));
+    }
+
+    @Test
+    void defaultResultValueNormalizesBlobObjectsFromFallbackTypes() throws Exception {
+        ResultSet rs = resultSet(new SerialBlob(new byte[]{0x0A, 0x0B}), null, false);
+
+        assertEquals("0x0a0b", JdbcExecutor.INSTANCE.defaultResultValue(rs, 1, Types.OTHER));
+    }
+
+    @Test
+    void readResultSetCachesColumnTypeMetadataAcrossRows() {
+        CountingResultSetFixture fixture = countingResultSet(new Object[][]{
+            {1, "Ada"},
+            {2, "Grace"}
+        });
+
+        QueryResult result = JdbcExecutor.INSTANCE.readResultSet(
+            fixture.resultSet(),
+            12L,
+            10,
+            JdbcExecutor.INSTANCE::defaultResultValue
+        );
+
+        assertEquals(Arrays.asList("id", "name"), result.getColumns());
+        assertEquals(Arrays.asList("INTEGER", "VARCHAR"), result.getColumn_types());
+        assertEquals(Arrays.asList(Arrays.asList(1, "Ada"), Arrays.asList(2, "Grace")), result.getRows());
+        assertEquals(1, fixture.getMetaDataCalls());
+        assertEquals(2, fixture.getColumnTypeCalls());
+    }
+
+    @Test
+    void schemaSwitcherPrefersDriverSpecificSql() throws Exception {
+        List<String> calls = new ArrayList<>();
+
+        JdbcSchemaSwitcher.apply(schemaConnection(calls, false), "APP", schema -> "USE " + schema);
+
+        assertEquals(Arrays.asList("execute:USE APP"), calls);
+    }
+
+    @Test
+    void schemaSwitcherFallsBackToSetSchemaWhenSqlFails() throws Exception {
+        List<String> calls = new ArrayList<>();
+
+        JdbcSchemaSwitcher.apply(schemaConnection(calls, true), "APP", schema -> "USE " + schema);
+
+        assertEquals(Arrays.asList("execute:USE APP", "setSchema:APP"), calls);
+    }
+
+    private static ResultSet resultSet(byte[] bytes, StringSupplier stringSupplier) {
+        return resultSet(bytes, stringSupplier, false);
+    }
+
+    private static Connection schemaConnection(List<String> calls, boolean failSchemaSql) {
+        InvocationHandler handler = (Object unused, Method method, Object[] args) -> {
+            switch (method.getName()) {
+                case "createStatement":
+                    return schemaStatement(calls, failSchemaSql);
+                case "setSchema":
+                    calls.add("setSchema:" + args[0]);
+                    return null;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        };
+        return (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), new Class<?>[]{Connection.class}, handler);
+    }
+
+    private static Statement schemaStatement(List<String> calls, boolean failSchemaSql) {
+        InvocationHandler handler = (Object unused, Method method, Object[] args) -> {
+            switch (method.getName()) {
+                case "execute":
+                    calls.add("execute:" + args[0]);
+                    if (failSchemaSql) {
+                        throw new SQLException("unsupported schema SQL");
+                    }
+                    return false;
+                case "close":
+                    return null;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        };
+        return (Statement) Proxy.newProxyInstance(Statement.class.getClassLoader(), new Class<?>[]{Statement.class}, handler);
+    }
+
+    private static CountingResultSetFixture countingResultSet(Object[][] rows) {
+        String[] labels = {"id", "name"};
+        int[] sqlTypes = {Types.INTEGER, Types.VARCHAR};
+        String[] typeNames = {"INTEGER", "VARCHAR"};
+        AtomicInteger cursor = new AtomicInteger(-1);
+        AtomicInteger getMetaDataCalls = new AtomicInteger();
+        AtomicInteger getColumnTypeCalls = new AtomicInteger();
+
+        InvocationHandler metaHandler = (Object unused, Method method, Object[] args) -> {
+            switch (method.getName()) {
+                case "getColumnCount":
+                    return labels.length;
+                case "getColumnLabel":
+                    return labels[(Integer) args[0] - 1];
+                case "getColumnType":
+                    getColumnTypeCalls.incrementAndGet();
+                    return sqlTypes[(Integer) args[0] - 1];
+                case "getColumnTypeName":
+                    return typeNames[(Integer) args[0] - 1];
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        };
+        ResultSetMetaData metadata = (ResultSetMetaData) Proxy.newProxyInstance(
+            ResultSetMetaData.class.getClassLoader(),
+            new Class<?>[]{ResultSetMetaData.class},
+            metaHandler
+        );
+
+        InvocationHandler resultSetHandler = (Object unused, Method method, Object[] args) -> {
+            switch (method.getName()) {
+                case "getMetaData":
+                    getMetaDataCalls.incrementAndGet();
+                    return metadata;
+                case "next":
+                    return cursor.incrementAndGet() < rows.length;
+                case "getInt":
+                    return ((Number) currentCell(rows, cursor.get(), (Integer) args[0])).intValue();
+                case "getString":
+                    Object value = currentCell(rows, cursor.get(), (Integer) args[0]);
+                    return value == null ? null : value.toString();
+                case "wasNull":
+                    return false;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        };
+        ResultSet resultSet = (ResultSet) Proxy.newProxyInstance(
+            ResultSet.class.getClassLoader(),
+            new Class<?>[]{ResultSet.class},
+            resultSetHandler
+        );
+        return new CountingResultSetFixture(resultSet, getMetaDataCalls, getColumnTypeCalls);
+    }
+
+    private static Object currentCell(Object[][] rows, int rowIndex, int columnIndex) {
+        return rows[rowIndex][columnIndex - 1];
+    }
+
+    private static ResultSet resultSet(Object objectValue, StringSupplier stringSupplier, boolean wasNull) {
+        InvocationHandler handler = (Object unused, Method method, Object[] args) -> {
+            switch (method.getName()) {
+                case "getObject":
+                    return objectValue;
+                case "getBytes":
+                    return objectValue instanceof byte[] ? objectValue : null;
+                case "getString":
+                    return stringSupplier == null ? null : stringSupplier.get();
+                case "wasNull":
+                    return wasNull;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        };
+        return (ResultSet) Proxy.newProxyInstance(
+            ResultSet.class.getClassLoader(),
+            new Class<?>[]{ResultSet.class},
+            handler
+        );
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (type == Boolean.TYPE) {
+            return false;
+        }
+        if (type == Byte.TYPE) {
+            return (byte) 0;
+        }
+        if (type == Short.TYPE) {
+            return (short) 0;
+        }
+        if (type == Integer.TYPE) {
+            return 0;
+        }
+        if (type == Long.TYPE) {
+            return 0L;
+        }
+        if (type == Float.TYPE) {
+            return 0f;
+        }
+        if (type == Double.TYPE) {
+            return 0.0d;
+        }
+        if (type == Character.TYPE) {
+            return '\0';
+        }
+        return null;
+    }
+
+    private interface StringSupplier {
+        String get() throws Exception;
+    }
+
+    private static final class CountingResultSetFixture {
+        private final ResultSet resultSet;
+        private final AtomicInteger getMetaDataCalls;
+        private final AtomicInteger getColumnTypeCalls;
+
+        private CountingResultSetFixture(
+            ResultSet resultSet,
+            AtomicInteger getMetaDataCalls,
+            AtomicInteger getColumnTypeCalls
+        ) {
+            this.resultSet = resultSet;
+            this.getMetaDataCalls = getMetaDataCalls;
+            this.getColumnTypeCalls = getColumnTypeCalls;
+        }
+
+        private ResultSet resultSet() {
+            return resultSet;
+        }
+
+        private int getMetaDataCalls() {
+            return getMetaDataCalls.get();
+        }
+
+        private int getColumnTypeCalls() {
+            return getColumnTypeCalls.get();
+        }
+    }
+}
diff --git a/agents/common/src/test/java/com/dbx/agent/MetadataConstraintCoverageTest.java b/agents/common/src/test/java/com/dbx/agent/MetadataConstraintCoverageTest.java
new file mode 100644
index 0000000..be84980
--- /dev/null
+++ b/agents/common/src/test/java/com/dbx/agent/MetadataConstraintCoverageTest.java
@@ -0,0 +1,114 @@
+package com.dbx.agent;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class MetadataConstraintCoverageTest {
+    private static final Pattern JAVA_METADATA_OVERRIDE = Pattern.compile(
+        "public\\s+List\\s*<\\s*(?:TableInfo|ObjectInfo)\\s*>\\s+list(?:Tables|Objects)\\s*\\(\\s*String\\s+schema"
+    );
+    private static final Set<String> VALID_STRATEGIES = new HashSet<>(Arrays.asList(
+        "native-pushdown",
+        "shared-fallback",
+        "intentional-fallback"
+    ));
+
+    @Test
+    void everyCustomMetadataDriverIsListedInCoverageMatrix() throws Exception {
+        Path agentsRoot = agentsRoot();
+        Map<String, String> coverage = readCoverageMatrix(agentsRoot.resolve("metadata-constraint-coverage.tsv"));
+        Set<String> discovered = discoverCustomMetadataDrivers(agentsRoot.resolve("drivers"));
+
+        assertEquals(discovered, coverage.keySet());
+    }
+
+    @Test
+    void coverageMatrixUsesKnownStrategiesAndReasons() throws Exception {
+        Path agentsRoot = agentsRoot();
+        Path matrix = agentsRoot.resolve("metadata-constraint-coverage.tsv");
+        for (String line : Files.readAllLines(matrix, StandardCharsets.UTF_8)) {
+            if (line.startsWith("driver\t") || line.trim().isEmpty()) {
+                continue;
+            }
+            String[] parts = line.split("\t", -1);
+            assertEquals(4, parts.length, line);
+            assertTrue(VALID_STRATEGIES.contains(parts[1]), line);
+            assertFalse(parts[3].trim().isEmpty(), line);
+        }
+    }
+
+    private static Set<String> discoverCustomMetadataDrivers(Path driversRoot) throws IOException {
+        Set<String> result = new HashSet<>();
+        try (Stream<Path> files = Files.walk(driversRoot)) {
+            files.filter(Files::isRegularFile).forEach(file -> {
+                String fileName = file.getFileName().toString();
+                if (fileName.endsWith(".java") && hasJavaMetadataOverride(file)) {
+                    result.add(driversRoot.relativize(file).getName(0).toString());
+                } else if ("main.go".equals(fileName) && hasGoMetadataDispatcher(file)) {
+                    result.add(driversRoot.relativize(file).getName(0).toString());
+                }
+            });
+        }
+        return result;
+    }
+
+    private static boolean hasJavaMetadataOverride(Path file) {
+        try {
+            return JAVA_METADATA_OVERRIDE.matcher(readUtf8(file)).find();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static boolean hasGoMetadataDispatcher(Path file) {
+        try {
+            String source = readUtf8(file);
+            return source.contains("\"list_tables\"") || source.contains("\"list_objects\"");
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static Map<String, String> readCoverageMatrix(Path matrix) throws IOException {
+        Map<String, String> result = new HashMap<>();
+        for (String line : Files.readAllLines(matrix, StandardCharsets.UTF_8)) {
+            if (line.startsWith("driver\t") || line.trim().isEmpty()) {
+                continue;
+            }
+            String[] parts = line.split("\t", -1);
+            result.put(parts[0], parts[1]);
+        }
+        return result;
+    }
+
+    private static String readUtf8(Path file) throws IOException {
+        return new String(Files.readAllBytes(file), StandardCharsets.UTF_8);
+    }
+
+    private static Path agentsRoot() {
+        Path current = Paths.get("").toAbsolutePath();
+        while (current != null) {
+            if (Files.isDirectory(current.resolve("drivers")) && Files.isDirectory(current.resolve("common"))) {
+                return current;
+            }
+            current = current.getParent();
+        }
+        throw new IllegalStateException("Unable to locate agents root");
+    }
+}
diff --git a/agents/common/src/test/java/com/dbx/agent/PostgresLikeAgentTest.java b/agents/common/src/test/java/com/dbx/agent/PostgresLikeAgentTest.java
new file mode 100644
index 0000000..f3d4279
--- /dev/null
+++ b/agents/common/src/test/java/com/dbx/agent/PostgresLikeAgentTest.java
@@ -0,0 +1,524 @@
+package com.dbx.agent;
+
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class PostgresLikeAgentTest {
+    @Test
+    void metadataQueriesUsePgCatalogInsteadOfInformationSchema() {
+        TestPostgresLikeAgent agent = new TestPostgresLikeAgent();
+        agent.connect(new ConnectParams());
+
+        agent.listSchemas();
+        agent.listTables("app");
+        agent.listObjects("app");
+        agent.getColumns("app", "orders");
+        agent.listCheckConstraintsForTest("app", "orders");
+        agent.listForeignKeys("app", "orders");
+        agent.listTriggers("app", "orders");
+
+        String sql = String.join("\n", MetadataSqlFake.statements);
+
+        assertFalse(sql.contains("FROM information_schema"), sql);
+        assertFalse(sql.contains("JOIN information_schema"), sql);
+        assertTrue(sql.contains("pg_catalog.pg_namespace"), sql);
+        assertTrue(sql.contains("pg_catalog.pg_class"), sql);
+        assertTrue(sql.contains("pg_catalog.pg_proc"), sql);
+        assertTrue(sql.contains("pg_catalog.pg_attribute"), sql);
+        assertTrue(sql.contains("pg_catalog.pg_constraint"), sql);
+        assertTrue(sql.contains("pg_catalog.pg_get_constraintdef"), sql);
+        assertTrue(sql.contains("pg_catalog.pg_trigger"), sql);
+        assertFalse(sql.contains(" AS key "), sql);
+        assertFalse(sql.contains(" key."), sql);
+    }
+
+    @Test
+    void mapsPgCatalogBooleanNullableValues() {
+        TestPostgresLikeAgent agent = new TestPostgresLikeAgent(preparedConnection(
+            resultSet(
+                new String[]{"column_name"},
+                new Object[][]{{"id"}}
+            ),
+            resultSet(
+                new String[]{
+                    "column_name",
+                    "data_type",
+                    "is_nullable",
+                    "column_default",
+                    "column_comment",
+                    "numeric_precision",
+                    "numeric_scale",
+                    "character_maximum_length"
+                },
+                new Object[][]{
+                    {"id", "integer", false, null, null, null, null, null},
+                    {"name", "character varying(255)", true, null, "display name", null, null, 255}
+                }
+            )
+        ));
+        agent.connect(new ConnectParams());
+
+        List<ColumnInfo> columns = agent.getColumns("public", "base_airspace");
+
+        assertEquals(2, columns.size());
+        assertTrue(columns.get(0).getIs_primary_key());
+        assertFalse(columns.get(0).getIs_nullable());
+        assertEquals("name", columns.get(1).getName());
+        assertTrue(columns.get(1).getIs_nullable());
+        assertEquals(Integer.valueOf(255), columns.get(1).getCharacter_maximum_length());
+    }
+
+    @Test
+    void tableDdlIncludesNamedCheckConstraints() {
+        ConstraintDdlAgent agent = new ConstraintDdlAgent();
+
+        String ddl = agent.getTableDdl("public", "orders");
+
+        assertTrue(
+            ddl.contains("CONSTRAINT \"chk_balance_status\" CHECK (status = ANY (ARRAY['PLAN'::text, 'EXECUTION'::text]))"),
+            ddl
+        );
+    }
+
+    @Test
+    void tableDdlFallsBackWhenCheckConstraintCatalogIsUnavailable() {
+        ConstraintDdlAgent agent = new ConstraintDdlAgent(true);
+
+        String ddl = agent.getTableDdl("public", "orders");
+
+        assertTrue(ddl.startsWith("CREATE TABLE \"public\".\"orders\""), ddl);
+        assertFalse(ddl.contains("CHECK"), ddl);
+    }
+
+    @Test
+    void postgisGeometryTypeNameDetection() {
+        assertTrue(PostgresLikeAgent.isPostgisGeometryTypeName("geometry"));
+        assertTrue(PostgresLikeAgent.isPostgisGeometryTypeName("GEOMETRY"));
+        assertTrue(PostgresLikeAgent.isPostgisGeometryTypeName(" Geography "));
+        assertTrue(PostgresLikeAgent.isPostgisGeometryTypeName("public.geometry"));
+        assertTrue(PostgresLikeAgent.isPostgisGeometryTypeName("geometry(Point,4326)"));
+        assertFalse(PostgresLikeAgent.isPostgisGeometryTypeName(""));
+        assertFalse(PostgresLikeAgent.isPostgisGeometryTypeName(null));
+        assertFalse(PostgresLikeAgent.isPostgisGeometryTypeName("text"));
+        assertFalse(PostgresLikeAgent.isPostgisGeometryTypeName("vector"));
+    }
+
+    @Test
+    void executeQueryDecodesGeometryColumnsToWktAndReportsColumnTypes() {
+        TestPostgresLikeAgent agent = new TestPostgresLikeAgent();
+        agent.connect(new ConnectParams());
+
+        QueryResult result = JdbcExecutor.INSTANCE.readResultSet(
+            GeometryResultSet.create(),
+            5L,
+            JdbcExecutor.DEFAULT_MAX_ROWS,
+            agent.geometryAwareResolverForTest()
+        );
+
+        assertEquals(2, result.getColumns().size());
+        assertEquals("id", result.getColumns().get(0));
+        assertEquals("geom", result.getColumns().get(1));
+
+        // column_types is reported via JDBC getColumnTypeName
+        assertEquals(2, result.getColumn_types().size());
+        assertEquals("int4", result.getColumn_types().get(0));
+        assertEquals("geometry", result.getColumn_types().get(1));
+
+        // The geometry cell is decoded to WKT (matches Rust ewkb_to_wkt fixture).
+        assertEquals(1, result.getRows().size());
+        assertEquals(1, result.getRows().get(0).get(0));
+        assertEquals("POINT(116.397 39.908)", result.getRows().get(0).get(1));
+    }
+
+    private static final class TestPostgresLikeAgent extends PostgresLikeAgent {
+        private final Connection connection;
+
+        private TestPostgresLikeAgent() {
+            this(null);
+        }
+
+        private TestPostgresLikeAgent(Connection connection) {
+            super(new PostgresLikeAgentProfile(
+                PostgresLikeAgentTest.class.getName(),
+                "jdbc:test://{host}:{port}/{database}"
+            ));
+            this.connection = connection;
+        }
+
+        @Override
+        protected Connection openConnection(ConnectParams params) {
+            if (connection != null) {
+                return connection;
+            }
+            return MetadataSqlFake.connection();
+        }
+
+        JdbcExecutor.ColumnAwareResultValueReader geometryAwareResolverForTest() {
+            return (rs, index, sqlType, columnTypeName) -> {
+                if (PostgresLikeAgent.isPostgisGeometryTypeName(columnTypeName)) {
+                    Object raw = rs.getObject(index);
+                    if (rs.wasNull() || raw == null) {
+                        return null;
+                    }
+                    return EwkbWktDecoder.decode(raw);
+                }
+                if (sqlType == Types.INTEGER) {
+                    return rs.getInt(index);
+                }
+                return rs.getObject(index);
+            };
+        }
+
+        List<CheckConstraintInfo> listCheckConstraintsForTest(String schema, String table) {
+            return listCheckConstraints(schema, table);
+        }
+    }
+
+    private static final class ConstraintDdlAgent extends PostgresLikeAgent {
+        private final boolean failCheckConstraintLookup;
+
+        private ConstraintDdlAgent() {
+            this(false);
+        }
+
+        private ConstraintDdlAgent(boolean failCheckConstraintLookup) {
+            super(new PostgresLikeAgentProfile(
+                PostgresLikeAgentTest.class.getName(),
+                "jdbc:test://{host}:{port}/{database}"
+            ));
+            this.failCheckConstraintLookup = failCheckConstraintLookup;
+        }
+
+        @Override
+        public List<ColumnInfo> getColumns(String schema, String table) {
+            return java.util.Arrays.asList(
+                new ColumnInfo("id", "bigint", false, null, true),
+                new ColumnInfo("status", "character varying", false, "'PLAN'::character varying", false)
+            );
+        }
+
+        @Override
+        public List<IndexInfo> listIndexes(String schema, String table) {
+            return java.util.Collections.emptyList();
+        }
+
+        @Override
+        public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+            return java.util.Collections.emptyList();
+        }
+
+        @Override
+        protected List<CheckConstraintInfo> listCheckConstraints(String schema, String table) {
+            if (failCheckConstraintLookup) {
+                throw new RuntimeException("pg_get_constraintdef is unavailable");
+            }
+            return java.util.Collections.singletonList(new CheckConstraintInfo(
+                "chk_balance_status",
+                "CHECK (status = ANY (ARRAY['PLAN'::text, 'EXECUTION'::text]))"
+            ));
+        }
+    }
+
+    private static Connection preparedConnection(ResultSet... resultSets) {
+        int[] resultSetIndex = {0};
+        return proxy(Connection.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("prepareStatement".equals(name)) {
+                    return proxy(PreparedStatement.class, new MethodHandler() {
+                        @Override
+                        public Object handle(Method method, Object[] args) {
+                            String name = method.getName();
+                            if ("executeQuery".equals(name)) {
+                                int current = Math.min(resultSetIndex[0], resultSets.length - 1);
+                                resultSetIndex[0] += 1;
+                                return resultSets[current];
+                            }
+                            if ("setString".equals(name) || "close".equals(name)) {
+                                return null;
+                            }
+                            return defaultValue(method.getReturnType());
+                        }
+                    });
+                }
+                if ("isClosed".equals(name)) {
+                    return false;
+                }
+                if ("close".equals(name)) {
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static ResultSet resultSet(String[] columns, Object[][] rows) {
+        int[] index = {-1};
+        boolean[] wasNull = {false};
+        return proxy(ResultSet.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("next".equals(name)) {
+                    index[0] += 1;
+                    return index[0] < rows.length;
+                }
+                if ("getString".equals(name)) {
+                    Object value = columnValue(columns, rows[index[0]], args[0]);
+                    wasNull[0] = value == null;
+                    return value == null ? null : String.valueOf(value);
+                }
+                if ("getBoolean".equals(name)) {
+                    Object value = columnValue(columns, rows[index[0]], args[0]);
+                    wasNull[0] = value == null;
+                    if (value instanceof Boolean) {
+                        return value;
+                    }
+                    if (value instanceof Number) {
+                        return ((Number) value).intValue() != 0;
+                    }
+                    String text = String.valueOf(value);
+                    return "1".equals(text)
+                        || "t".equalsIgnoreCase(text)
+                        || "true".equalsIgnoreCase(text)
+                        || "yes".equalsIgnoreCase(text);
+                }
+                if ("getInt".equals(name)) {
+                    Object value = columnValue(columns, rows[index[0]], args[0]);
+                    wasNull[0] = value == null;
+                    if (value instanceof Number) {
+                        return ((Number) value).intValue();
+                    }
+                    return value == null ? 0 : Integer.parseInt(String.valueOf(value));
+                }
+                if ("getObject".equals(name)) {
+                    Object value = columnValue(columns, rows[index[0]], args[0]);
+                    wasNull[0] = value == null;
+                    return value;
+                }
+                if ("wasNull".equals(name)) {
+                    return wasNull[0];
+                }
+                if ("close".equals(name)) {
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Object columnValue(String[] columns, Object[] row, Object key) {
+        if (key instanceof Number) {
+            return row[((Number) key).intValue() - 1];
+        }
+        for (int i = 0; i < columns.length; i++) {
+            if (columns[i].equalsIgnoreCase(String.valueOf(key))) {
+                return row[i];
+            }
+        }
+        return null;
+    }
+
+    private static <T> T proxy(Class<T> type, final MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) {
+                return handler.handle(method, args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Byte.TYPE.equals(type)) {
+            return (byte) 0;
+        }
+        if (Short.TYPE.equals(type)) {
+            return (short) 0;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        if (Long.TYPE.equals(type)) {
+            return 0L;
+        }
+        if (Float.TYPE.equals(type)) {
+            return 0f;
+        }
+        if (Double.TYPE.equals(type)) {
+            return 0.0d;
+        }
+        if (Character.TYPE.equals(type)) {
+            return '\0';
+        }
+        return null;
+    }
+
+    private static final class GeometryResultSet {
+        static ResultSet create() {
+            ResultSetMetaData meta = (ResultSetMetaData) Proxy.newProxyInstance(
+                GeometryResultSet.class.getClassLoader(),
+                new Class<?>[]{ResultSetMetaData.class},
+                (proxy, method, args) -> {
+                    switch (method.getName()) {
+                        case "getColumnCount":
+                            return 2;
+                        case "getColumnLabel":
+                        case "getColumnName":
+                            return ((Integer) args[0]) == 1 ? "id" : "geom";
+                        case "getColumnType":
+                            return ((Integer) args[0]) == 1 ? Types.INTEGER : Types.OTHER;
+                        case "getColumnTypeName":
+                            return ((Integer) args[0]) == 1 ? "int4" : "geometry";
+                        default:
+                            return null;
+                    }
+                }
+            );
+
+            // POINT(116.397 39.908) with SRID=4326, little-endian.
+            String hex = "0101000020E6100000C520B07268195D404E62105839F44340";
+            byte[] geomBytes = parseHex(hex);
+
+            int[] cursor = new int[]{0}; // 0 = before first row
+            return (ResultSet) Proxy.newProxyInstance(
+                GeometryResultSet.class.getClassLoader(),
+                new Class<?>[]{ResultSet.class},
+                (proxy, method, args) -> {
+                    String name = method.getName();
+                    switch (name) {
+                        case "getMetaData":
+                            return meta;
+                        case "next":
+                            cursor[0] += 1;
+                            return cursor[0] == 1;
+                        case "getInt":
+                            return cursor[0] == 1 ? 1 : 0;
+                        case "getObject":
+                            return ((Integer) args[0]) == 2 ? geomBytes : 1;
+                        case "wasNull":
+                            return false;
+                        case "close":
+                            return null;
+                        default:
+                            return defaultPrimitive(method.getReturnType());
+                    }
+                }
+            );
+        }
+
+        private static byte[] parseHex(String s) {
+            byte[] out = new byte[s.length() / 2];
+            for (int i = 0; i < out.length; i++) {
+                int hi = Character.digit(s.charAt(i * 2), 16);
+                int lo = Character.digit(s.charAt(i * 2 + 1), 16);
+                out[i] = (byte) ((hi << 4) | lo);
+            }
+            return out;
+        }
+
+        private static Object defaultPrimitive(Class<?> t) {
+            if (Boolean.TYPE.equals(t)) return false;
+            if (Integer.TYPE.equals(t)) return 0;
+            if (Long.TYPE.equals(t)) return 0L;
+            if (Double.TYPE.equals(t)) return 0.0;
+            return null;
+        }
+    }
+
+    private static final class MetadataSqlFake {
+        private static final List<String> statements = new ArrayList<String>();
+
+        private static Connection connection() {
+            statements.clear();
+            return proxy(Connection.class, new MethodHandler() {
+                @Override
+                public Object handle(Method method, Object[] args) {
+                    String name = method.getName();
+                    if ("prepareStatement".equals(name)) {
+                        statements.add((String) args[0]);
+                        return preparedStatement();
+                    }
+                    if ("isClosed".equals(name)) {
+                        return false;
+                    }
+                    if ("close".equals(name)) {
+                        return null;
+                    }
+                    return defaultValue(method.getReturnType());
+                }
+            });
+        }
+
+        private static PreparedStatement preparedStatement() {
+            final ResultSet resultSet = emptyResultSet();
+            return proxy(PreparedStatement.class, new MethodHandler() {
+                @Override
+                public Object handle(Method method, Object[] args) {
+                    String name = method.getName();
+                    if ("executeQuery".equals(name)) {
+                        return resultSet;
+                    }
+                    if ("setString".equals(name)) {
+                        statements.add("param:" + args[0] + "=" + args[1]);
+                        return null;
+                    }
+                    if ("close".equals(name)) {
+                        return null;
+                    }
+                    return defaultValue(method.getReturnType());
+                }
+            });
+        }
+
+        private static ResultSet emptyResultSet() {
+            final ResultSetMetaData metadata = proxy(ResultSetMetaData.class, new MethodHandler() {
+                @Override
+                public Object handle(Method method, Object[] args) {
+                    if ("getColumnCount".equals(method.getName())) {
+                        return 0;
+                    }
+                    return defaultValue(method.getReturnType());
+                }
+            });
+            return proxy(ResultSet.class, new MethodHandler() {
+                @Override
+                public Object handle(Method method, Object[] args) {
+                    String name = method.getName();
+                    if ("next".equals(name)) {
+                        return false;
+                    }
+                    if ("getMetaData".equals(name)) {
+                        return metadata;
+                    }
+                    if ("close".equals(name)) {
+                        return null;
+                    }
+                    return defaultValue(method.getReturnType());
+                }
+            });
+        }
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args);
+    }
+}
diff --git a/agents/common/src/test/java/com/dbx/agent/StandardJdbcMetadataTest.java b/agents/common/src/test/java/com/dbx/agent/StandardJdbcMetadataTest.java
new file mode 100644
index 0000000..1ae5e8d
--- /dev/null
+++ b/agents/common/src/test/java/com/dbx/agent/StandardJdbcMetadataTest.java
@@ -0,0 +1,776 @@
+package com.dbx.agent;
+
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class StandardJdbcMetadataTest {
+    private final JdbcAgentProfile profile = new JdbcAgentProfile(
+        "example.Driver",
+        "jdbc:example://{host}:{port}/{database}",
+        0,
+        false,
+        Collections.singleton("SYS"),
+        Arrays.asList("TABLE", "VIEW", "BASE TABLE")
+    );
+
+    @Test
+    void listsSchemasWithFilteringAndStableOrdering() {
+        Connection conn = connection(
+            rows(row("TABLE_SCHEM", "APP"), row("TABLE_SCHEM", "SYS"), row("TABLE_SCHEM", "PUBLIC")),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows()
+        );
+
+        assertEquals(Arrays.asList("APP", "PUBLIC"), StandardJdbcMetadata.INSTANCE.listSchemas(conn, profile));
+    }
+
+    @Test
+    void listsSchemasWhenConnectionGetSchemaIsUnsupported() {
+        Connection conn = connection(
+            rows(row("TABLE_SCHEM", "APP"), row("TABLE_SCHEM", "PUBLIC")),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            true
+        );
+
+        assertEquals(Arrays.asList("APP", "PUBLIC"), StandardJdbcMetadata.INSTANCE.listSchemas(conn, profile));
+    }
+
+    @Test
+    void listsSchemasWhenConnectionGetSchemaThrowsAbstractMethodError() {
+        Connection conn = connection(
+            rows(row("TABLE_SCHEM", "APP"), row("TABLE_SCHEM", "PUBLIC")),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            UnsupportedSchemaCall.ABSTRACT_METHOD_ERROR
+        );
+
+        assertEquals(Arrays.asList("APP", "PUBLIC"), StandardJdbcMetadata.INSTANCE.listSchemas(conn, profile));
+    }
+
+    @Test
+    void listsSchemasWithEmptyResultWhenDriverSchemaMetadataIsUnsupported() {
+        Connection conn = connection(
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            UnsupportedSchemaCall.METADATA_AND_CONNECTION_ABSTRACT_METHOD_ERROR
+        );
+
+        assertEquals(Collections.emptyList(), StandardJdbcMetadata.INSTANCE.listSchemas(conn, profile));
+    }
+
+    @Test
+    void listsTablesWithNormalizedTypesAndStableOrdering() {
+        Connection conn = connection(
+            rows(),
+            rows(row("TABLE_NAME", "ZETA", "TABLE_TYPE", "BASE TABLE", "REMARKS", "last"),
+                row("TABLE_NAME", "ALPHA", "TABLE_TYPE", "VIEW", "REMARKS", "first")),
+            rows(),
+            rows(),
+            rows(),
+            rows()
+        );
+
+        List<TableInfo> tables = StandardJdbcMetadata.INSTANCE.listTables(conn, profile, "", "APP");
+
+        assertEquals("ALPHA", tables.get(0).getName());
+        assertEquals("VIEW", tables.get(0).getTable_type());
+        assertEquals("ZETA", tables.get(1).getName());
+        assertEquals("TABLE", tables.get(1).getTable_type());
+    }
+
+    @Test
+    void listsProceduresAndFunctionsFromJdbcRoutineMetadata() {
+        Connection conn = routineConnection(
+            rows(
+                row("PROCEDURE_NAME", "PROCESS_ORDER", "REMARKS", "processes an order"),
+                row("PROCEDURE_NAME", "SHARED_ROUTINE", "REMARKS", null)
+            ),
+            rows(
+                row("FUNCTION_NAME", "CALCULATE_TOTAL", "REMARKS", "calculates a total"),
+                row("FUNCTION_NAME", "SHARED_ROUTINE", "REMARKS", null)
+            )
+        );
+        MetadataListConstraints constraints =
+            new MetadataListConstraints(null, null, null, Collections.singletonList("PROCEDURE"));
+
+        List<ObjectInfo> objects = StandardJdbcMetadata.INSTANCE.listObjects(conn, profile, "", "APP", constraints);
+
+        assertEquals(2, objects.size());
+        assertEquals("PROCESS_ORDER", objects.get(0).getName());
+        assertEquals("PROCEDURE", objects.get(0).getObject_type());
+        assertEquals("SHARED_ROUTINE", objects.get(1).getName());
+        assertEquals("PROCEDURE", objects.get(1).getObject_type());
+    }
+
+    @Test
+    void listsDataTypesFromJdbcTypeInfo() {
+        Connection conn = connection(
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            UnsupportedSchemaCall.NONE,
+            null,
+            null,
+            null,
+            null,
+            rows(row("TYPE_NAME", "INTEGER"), row("TYPE_NAME", "VARCHAR"), row("TYPE_NAME", "integer"))
+        );
+
+        assertEquals(Arrays.asList("INTEGER", "VARCHAR"), StandardJdbcMetadata.INSTANCE.listDataTypes(conn));
+    }
+
+    @Test
+    void listTablesUsesDriverTableTypesWithinProfileAllowList() {
+        AtomicReference<String[]> capturedTypes = new AtomicReference<>();
+        Connection conn = connection(
+            rows(),
+            rows(row("TABLE_NAME", "ORDERS", "TABLE_TYPE", "TABLE", "REMARKS", null)),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows(
+                row("TABLE_TYPE", "TABLE"),
+                row("TABLE_TYPE", "LOCAL TEMPORARY"),
+                row("TABLE_TYPE", "BASE TABLE")
+            ),
+            capturedTypes
+        );
+
+        StandardJdbcMetadata.INSTANCE.listTables(conn, profile, "", "APP");
+
+        assertEquals(Arrays.asList("TABLE", "BASE TABLE"), Arrays.asList(capturedTypes.get()));
+    }
+
+    @Test
+    void listTablesAllowsHanaColumnAndRowTables() {
+        JdbcAgentProfile hanaProfile = new JdbcAgentProfile(
+            "com.sap.db.jdbc.Driver",
+            "jdbc:sap://{host}:{port}/?databaseName={database}",
+            30015,
+            false,
+            Collections.emptySet(),
+            Arrays.asList("COLUMN TABLE", "ROW TABLE", "TABLE", "VIEW")
+        );
+        AtomicReference<String[]> capturedTypes = new AtomicReference<>();
+        Connection conn = connection(
+            rows(),
+            rows(
+                row("TABLE_NAME", "ORDERS", "TABLE_TYPE", "COLUMN TABLE", "REMARKS", null),
+                row("TABLE_NAME", "AUDIT_LOG", "TABLE_TYPE", "ROW TABLE", "REMARKS", null),
+                row("TABLE_NAME", "ACTIVE_ORDERS", "TABLE_TYPE", "VIEW", "REMARKS", null)
+            ),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows(
+                row("TABLE_TYPE", "COLUMN TABLE"),
+                row("TABLE_TYPE", "ROW TABLE"),
+                row("TABLE_TYPE", "VIEW")
+            ),
+            capturedTypes
+        );
+
+        List<TableInfo> tables = StandardJdbcMetadata.INSTANCE.listTables(conn, hanaProfile, "", "APP");
+
+        assertEquals(Arrays.asList("COLUMN TABLE", "ROW TABLE", "VIEW"), Arrays.asList(capturedTypes.get()));
+        assertEquals(Arrays.asList("ACTIVE_ORDERS", "AUDIT_LOG", "ORDERS"), Arrays.asList(
+            tables.get(0).getName(),
+            tables.get(1).getName(),
+            tables.get(2).getName()
+        ));
+        assertEquals("VIEW", tables.get(0).getTable_type());
+        assertEquals("TABLE", tables.get(1).getTable_type());
+        assertEquals("TABLE", tables.get(2).getTable_type());
+    }
+
+    @Test
+    void mapsColumnsWithPrimaryKeysAndLengths() {
+        Connection conn = connection(
+            rows(),
+            rows(),
+            rows(row("COLUMN_NAME", "ID")),
+            rows(row(
+                "COLUMN_NAME", "ID",
+                "TYPE_NAME", "INTEGER",
+                "NULLABLE", DatabaseMetaData.columnNoNulls,
+                "COLUMN_DEF", null,
+                "REMARKS", "identifier",
+                "COLUMN_SIZE", 10,
+                "DECIMAL_DIGITS", 0
+            ), row(
+                "COLUMN_NAME", "NAME",
+                "TYPE_NAME", "VARCHAR",
+                "NULLABLE", DatabaseMetaData.columnNullable,
+                "COLUMN_DEF", null,
+                "REMARKS", null,
+                "COLUMN_SIZE", 64,
+                "DECIMAL_DIGITS", 0
+            )),
+            rows(),
+            rows()
+        );
+
+        List<ColumnInfo> columns = StandardJdbcMetadata.INSTANCE.getColumns(conn, profile, "", "APP", "ORDERS");
+
+        assertEquals("ID", columns.get(0).getName());
+        assertTrue(columns.get(0).getIs_primary_key());
+        assertFalse(columns.get(0).getIs_nullable());
+        assertEquals("NAME", columns.get(1).getName());
+        assertEquals(Integer.valueOf(64), columns.get(1).getCharacter_maximum_length());
+    }
+
+    @Test
+    void marksPrimaryKeysFromConfiguredCatalogWhenColumnsAlreadyLoaded() {
+        Connection conn = catalogPrimaryKeyFallbackConnection(
+            "TENANTDB",
+            rows(),
+            rows(row("COLUMN_NAME", "ID")),
+            orderColumns()
+        );
+
+        List<ColumnInfo> columns = StandardJdbcMetadata.INSTANCE.getColumns(conn, profile, "TENANTDB", "APP", "ORDERS");
+
+        assertEquals("ID", columns.get(0).getName());
+        assertTrue(columns.get(0).getIs_primary_key());
+        assertFalse(columns.get(0).getIs_nullable());
+        assertEquals("NAME", columns.get(1).getName());
+        assertFalse(columns.get(1).getIs_primary_key());
+        assertEquals(Integer.valueOf(64), columns.get(1).getCharacter_maximum_length());
+    }
+
+    @Test
+    void doesNotMarkPrimaryKeysFromConfiguredCatalogWhenFallbackUnavailable() {
+        JdbcAgentProfile fallbackDisabledProfile = new JdbcAgentProfile(
+            "example.Driver",
+            "jdbc:example://{host}:{port}/{database}",
+            0,
+            false,
+            Collections.emptySet(),
+            Collections.singletonList("TABLE"),
+            "\"",
+            "SET SCHEMA",
+            false,
+            false,
+            false,
+            false
+        );
+        Connection disabledConn = catalogPrimaryKeyFallbackConnection(
+            "TENANTDB",
+            rows(),
+            rows(row("COLUMN_NAME", "ID")),
+            orderColumns()
+        );
+
+        List<ColumnInfo> disabledColumns = StandardJdbcMetadata.INSTANCE.getColumns(disabledConn, fallbackDisabledProfile, "TENANTDB", "APP", "ORDERS");
+
+        assertFalse(disabledColumns.get(0).getIs_primary_key());
+
+        Connection emptyCatalogConn = catalogPrimaryKeyFallbackConnection(
+            "TENANTDB",
+            rows(),
+            rows(row("COLUMN_NAME", "ID")),
+            orderColumns()
+        );
+
+        List<ColumnInfo> emptyCatalogColumns = StandardJdbcMetadata.INSTANCE.getColumns(emptyCatalogConn, profile, " ", "APP", "ORDERS");
+
+        assertFalse(emptyCatalogColumns.get(0).getIs_primary_key());
+    }
+
+    @Test
+    void groupsIndexColumnsInOrdinalOrder() {
+        Connection conn = connection(
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows(row("INDEX_NAME", "IDX_ORDERS", "COLUMN_NAME", "B", "ORDINAL_POSITION", (short) 2, "NON_UNIQUE", true),
+                row("INDEX_NAME", "IDX_ORDERS", "COLUMN_NAME", "A", "ORDINAL_POSITION", (short) 1, "NON_UNIQUE", true)),
+            rows()
+        );
+
+        List<IndexInfo> indexes = StandardJdbcMetadata.INSTANCE.listIndexes(conn, "APP", "ORDERS");
+
+        assertEquals(1, indexes.size());
+        assertEquals(Arrays.asList("A", "B"), indexes.get(0).getColumns());
+        assertFalse(indexes.get(0).getIs_unique());
+    }
+
+    @Test
+    void mapsForeignKeysAndEmptyTriggers() {
+        Connection conn = connection(
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows(),
+            rows(row("FK_NAME", null, "FKCOLUMN_NAME", "CUSTOMER_ID", "PKTABLE_NAME", "CUSTOMERS", "PKCOLUMN_NAME", "ID"))
+        );
+
+        List<ForeignKeyInfo> foreignKeys = StandardJdbcMetadata.INSTANCE.listForeignKeys(conn, "APP", "ORDERS");
+
+        assertEquals("", foreignKeys.get(0).getName());
+        assertEquals("CUSTOMER_ID", foreignKeys.get(0).getColumn());
+        assertEquals(Collections.emptyList(), StandardJdbcMetadata.INSTANCE.listTriggers("APP", "ORDERS"));
+    }
+
+    @Test
+    void completionAssistantSearchesTablesAndColumnsWithServerSideMasks() {
+        AtomicReference<Object[]> capturedTableArgs = new AtomicReference<>();
+        AtomicReference<Object[]> capturedColumnArgs = new AtomicReference<>();
+        Connection conn = connection(
+            rows(),
+            rows(
+                row("TABLE_NAME", "ACCOUNTS", "TABLE_TYPE", "TABLE", "REMARKS", "account table"),
+                row("TABLE_NAME", "ACCOUNT_VIEW", "TABLE_TYPE", "VIEW", "REMARKS", null)
+            ),
+            rows(),
+            rows(row("COLUMN_NAME", "DISPLAY_NAME", "TYPE_NAME", "VARCHAR", "NULLABLE", DatabaseMetaData.columnNullable, "COLUMN_DEF", null, "REMARKS", "display")),
+            rows(),
+            rows(),
+            UnsupportedSchemaCall.NONE,
+            rows(row("TABLE_TYPE", "TABLE"), row("TABLE_TYPE", "VIEW")),
+            null,
+            capturedTableArgs,
+            capturedColumnArgs
+        );
+
+        CompletionAssistantRequest tablesRequest = request("sales", "APP", "ACC", Arrays.asList(CompletionAssistantObjectKind.TABLE, CompletionAssistantObjectKind.VIEW), null);
+        CompletionAssistantResponse tables = StandardJdbcMetadata.INSTANCE.completionAssistantSearch(conn, profile, "sales", tablesRequest);
+
+        assertEquals(2, tables.getCandidates().size());
+        assertEquals(CompletionAssistantCandidateKind.TABLE, tables.getCandidates().get(0).getKind());
+        assertEquals("ACC%", capturedTableArgs.get()[2]);
+
+        CompletionAssistantRequest columnsRequest = request("sales", "APP", "DISPLAY", Collections.singletonList(CompletionAssistantObjectKind.COLUMN), "ACCOUNTS");
+        CompletionAssistantResponse columns = StandardJdbcMetadata.INSTANCE.completionAssistantSearch(conn, profile, "sales", columnsRequest);
+
+        assertEquals(1, columns.getCandidates().size());
+        assertEquals("DISPLAY_NAME", columns.getCandidates().get(0).getName());
+        assertEquals("VARCHAR", columns.getCandidates().get(0).getData_type());
+        assertEquals("ACCOUNTS", capturedColumnArgs.get()[2]);
+        assertEquals("DISPLAY%", capturedColumnArgs.get()[3]);
+    }
+
+    private static Connection connection(
+        ResultSet schemas,
+        ResultSet tables,
+        ResultSet primaryKeys,
+        ResultSet columns,
+        ResultSet indexes,
+        ResultSet foreignKeys
+    ) {
+        return connection(schemas, tables, primaryKeys, columns, indexes, foreignKeys, false);
+    }
+
+    private static Connection connection(
+        ResultSet schemas,
+        ResultSet tables,
+        ResultSet primaryKeys,
+        ResultSet columns,
+        ResultSet indexes,
+        ResultSet foreignKeys,
+        boolean unsupportedGetSchema
+    ) {
+        return connection(
+            schemas,
+            tables,
+            primaryKeys,
+            columns,
+            indexes,
+            foreignKeys,
+            unsupportedGetSchema ? UnsupportedSchemaCall.RUNTIME_EXCEPTION : UnsupportedSchemaCall.NONE,
+            null,
+            null
+        );
+    }
+
+    private static Connection connection(
+        ResultSet schemas,
+        ResultSet tables,
+        ResultSet primaryKeys,
+        ResultSet columns,
+        ResultSet indexes,
+        ResultSet foreignKeys,
+        UnsupportedSchemaCall unsupportedSchemaCall
+    ) {
+        return connection(schemas, tables, primaryKeys, columns, indexes, foreignKeys, unsupportedSchemaCall, null, null);
+    }
+
+    private static Connection connection(
+        ResultSet schemas,
+        ResultSet tables,
+        ResultSet primaryKeys,
+        ResultSet columns,
+        ResultSet indexes,
+        ResultSet foreignKeys,
+        ResultSet tableTypes,
+        AtomicReference<String[]> capturedTableTypes
+    ) {
+        return connection(schemas, tables, primaryKeys, columns, indexes, foreignKeys, UnsupportedSchemaCall.NONE, tableTypes, capturedTableTypes);
+    }
+
+    private static Connection connection(
+        ResultSet schemas,
+        ResultSet tables,
+        ResultSet primaryKeys,
+        ResultSet columns,
+        ResultSet indexes,
+        ResultSet foreignKeys,
+        UnsupportedSchemaCall unsupportedSchemaCall,
+        ResultSet tableTypes,
+        AtomicReference<String[]> capturedTableTypes
+    ) {
+        return connection(schemas, tables, primaryKeys, columns, indexes, foreignKeys, unsupportedSchemaCall, tableTypes, capturedTableTypes, null, null);
+    }
+
+    private static Connection connection(
+        ResultSet schemas,
+        ResultSet tables,
+        ResultSet primaryKeys,
+        ResultSet columns,
+        ResultSet indexes,
+        ResultSet foreignKeys,
+        UnsupportedSchemaCall unsupportedSchemaCall,
+        ResultSet tableTypes,
+        AtomicReference<String[]> capturedTableTypes,
+        AtomicReference<Object[]> capturedTableArgs,
+        AtomicReference<Object[]> capturedColumnArgs
+    ) {
+        return connection(
+            schemas,
+            tables,
+            primaryKeys,
+            columns,
+            indexes,
+            foreignKeys,
+            unsupportedSchemaCall,
+            tableTypes,
+            capturedTableTypes,
+            capturedTableArgs,
+            capturedColumnArgs,
+            null
+        );
+    }
+
+    private static Connection connection(
+        ResultSet schemas,
+        ResultSet tables,
+        ResultSet primaryKeys,
+        ResultSet columns,
+        ResultSet indexes,
+        ResultSet foreignKeys,
+        UnsupportedSchemaCall unsupportedSchemaCall,
+        ResultSet tableTypes,
+        AtomicReference<String[]> capturedTableTypes,
+        AtomicReference<Object[]> capturedTableArgs,
+        AtomicReference<Object[]> capturedColumnArgs,
+        ResultSet dataTypes
+    ) {
+        DatabaseMetaData meta = proxy(DatabaseMetaData.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("getSchemas".equals(name)) {
+                    if (unsupportedSchemaCall == UnsupportedSchemaCall.METADATA_AND_CONNECTION_ABSTRACT_METHOD_ERROR) {
+                        throw new AbstractMethodError("Unimplemented method: getSchemas()");
+                    }
+                    return schemas;
+                }
+                if ("getTables".equals(name)) {
+                    if (capturedTableArgs != null) {
+                        capturedTableArgs.set(args);
+                    }
+                    if (capturedTableTypes != null && args != null && args.length > 3) {
+                        capturedTableTypes.set((String[]) args[3]);
+                    }
+                    return tables;
+                }
+                if ("getTableTypes".equals(name) && tableTypes != null) {
+                    return tableTypes;
+                }
+                if ("getTypeInfo".equals(name) && dataTypes != null) {
+                    return dataTypes;
+                }
+                if ("getPrimaryKeys".equals(name)) {
+                    return primaryKeys;
+                }
+                if ("getColumns".equals(name)) {
+                    if (capturedColumnArgs != null) {
+                        capturedColumnArgs.set(args);
+                    }
+                    return columns;
+                }
+                if ("getIndexInfo".equals(name)) {
+                    return indexes;
+                }
+                if ("getImportedKeys".equals(name)) {
+                    return foreignKeys;
+                }
+                if ("getCatalogs".equals(name)) {
+                    return rows();
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+        return proxy(Connection.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                if ("getMetaData".equals(method.getName())) {
+                    return meta;
+                }
+                if ("getSchema".equals(method.getName())) {
+                    if (unsupportedSchemaCall == UnsupportedSchemaCall.RUNTIME_EXCEPTION) {
+                        throw new RuntimeException("Unimplemented method: getSchema()");
+                    }
+                    if (unsupportedSchemaCall == UnsupportedSchemaCall.ABSTRACT_METHOD_ERROR
+                        || unsupportedSchemaCall == UnsupportedSchemaCall.METADATA_AND_CONNECTION_ABSTRACT_METHOD_ERROR) {
+                        throw new AbstractMethodError("Unimplemented method: getSchema()");
+                    }
+                    return null;
+                }
+                if ("getCatalog".equals(method.getName())) {
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Connection catalogPrimaryKeyFallbackConnection(
+        String fallbackCatalog,
+        ResultSet defaultPrimaryKeys,
+        ResultSet fallbackPrimaryKeys,
+        ResultSet columns
+    ) {
+        DatabaseMetaData meta = proxy(DatabaseMetaData.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("getPrimaryKeys".equals(name)) {
+                    return fallbackCatalog.equals(args[0]) ? fallbackPrimaryKeys : defaultPrimaryKeys;
+                }
+                if ("getColumns".equals(name)) {
+                    return columns;
+                }
+                if ("getCatalogs".equals(name)) {
+                    return rows();
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+        return proxy(Connection.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                if ("getMetaData".equals(method.getName())) {
+                    return meta;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Connection routineConnection(ResultSet procedures, ResultSet functions) {
+        DatabaseMetaData meta = proxy(DatabaseMetaData.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("getTables".equals(name) || "getTableTypes".equals(name)) {
+                    return rows();
+                }
+                if ("getProcedures".equals(name)) {
+                    return procedures;
+                }
+                if ("getFunctions".equals(name)) {
+                    return functions;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+        return proxy(Connection.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                if ("getMetaData".equals(method.getName())) {
+                    return meta;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static ResultSet orderColumns() {
+        return rows(row(
+            "COLUMN_NAME", "ID",
+            "TYPE_NAME", "INTEGER",
+            "NULLABLE", DatabaseMetaData.columnNoNulls,
+            "COLUMN_DEF", null,
+            "REMARKS", "identifier",
+            "COLUMN_SIZE", 10,
+            "DECIMAL_DIGITS", 0
+        ), row(
+            "COLUMN_NAME", "NAME",
+            "TYPE_NAME", "VARCHAR",
+            "NULLABLE", DatabaseMetaData.columnNullable,
+            "COLUMN_DEF", null,
+            "REMARKS", null,
+            "COLUMN_SIZE", 64,
+            "DECIMAL_DIGITS", 0
+        ));
+    }
+
+    private static ResultSet rows(Map<String, Object>... rows) {
+        return proxy(ResultSet.class, new MethodHandler() {
+            private int index = -1;
+
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("next".equals(name)) {
+                    index += 1;
+                    return index < rows.length;
+                }
+                if ("close".equals(name)) {
+                    return null;
+                }
+                Object value = rows[index].get(args[0]);
+                if ("getString".equals(name)) {
+                    return value == null ? null : String.valueOf(value);
+                }
+                if ("getObject".equals(name)) {
+                    return value;
+                }
+                if ("getInt".equals(name)) {
+                    return value instanceof Number ? ((Number) value).intValue() : 0;
+                }
+                if ("getShort".equals(name)) {
+                    return value instanceof Number ? ((Number) value).shortValue() : 0;
+                }
+                if ("getBoolean".equals(name)) {
+                    return value instanceof Boolean && (Boolean) value;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Map<String, Object> row(Object... values) {
+        Map<String, Object> row = new LinkedHashMap<>();
+        for (int i = 0; i < values.length; i += 2) {
+            row.put(String.valueOf(values[i]), values[i + 1]);
+        }
+        return row;
+    }
+
+    private static CompletionAssistantRequest request(
+        String database,
+        String schema,
+        String mask,
+        List<CompletionAssistantObjectKind> kinds,
+        String parentName
+    ) {
+        CompletionAssistantRequest request = new CompletionAssistantRequest();
+        setField(request, "database", database);
+        setField(request, "schema", schema);
+        setField(request, "mask", mask);
+        setField(request, "object_kinds", kinds);
+        setField(request, "parent_schema", schema);
+        setField(request, "parent_name", parentName);
+        setField(request, "max_results", 10);
+        setField(request, "match_mode", CompletionAssistantMatchMode.PREFIX);
+        return request;
+    }
+
+    private static void setField(Object target, String name, Object value) {
+        try {
+            java.lang.reflect.Field field = target.getClass().getDeclaredField(name);
+            field.setAccessible(true);
+            field.set(target, value);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static <T> T proxy(Class<T> type, final MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) {
+                return handler.handle(method, args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Byte.TYPE.equals(type)) {
+            return (byte) 0;
+        }
+        if (Short.TYPE.equals(type)) {
+            return (short) 0;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        if (Long.TYPE.equals(type)) {
+            return 0L;
+        }
+        if (Float.TYPE.equals(type)) {
+            return 0f;
+        }
+        if (Double.TYPE.equals(type)) {
+            return 0.0d;
+        }
+        if (Character.TYPE.equals(type)) {
+            return '\0';
+        }
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args);
+    }
+
+    private enum UnsupportedSchemaCall {
+        NONE,
+        RUNTIME_EXCEPTION,
+        ABSTRACT_METHOD_ERROR,
+        METADATA_AND_CONNECTION_ABSTRACT_METHOD_ERROR
+    }
+}
diff --git a/agents/docs/agent-authoring.md b/agents/docs/agent-authoring.md
new file mode 100644
index 0000000..5aecf95
--- /dev/null
+++ b/agents/docs/agent-authoring.md
@@ -0,0 +1,318 @@
+# Agent Authoring Guide
+
+This guide defines the expected shape of a DBX agent. Treat it as the checklist for adding or reviewing an agent.
+
+## Agent Contract
+
+Every agent is a standalone JVM process that:
+
+- Implements `com.dbx.agent.DatabaseAgent`.
+- Prefer extending `com.dbx.agent.ConfiguredJdbcAgent` for standard JDBC agents.
+- Extend `com.dbx.agent.AbstractJdbcAgent` when the database needs custom metadata SQL but can still share lifecycle and execution behavior.
+- Starts with `new JsonRpcServer(new <Agent>()).run()` in its `main` method.
+- Talks to DBX over stdin/stdout JSON-RPC 2.0.
+- Uses JDBC for database access unless the module is explicitly designed around a non-JDBC protocol.
+- Produces one shadow JAR named `dbx-agent-<agent-name>.jar`.
+
+The public behavior should be consistent across agents even when each database has different SQL dialects.
+
+## Required Methods
+
+Each agent must implement these capabilities:
+
+- `connect(params)`: handled by the shared JDBC foundation for JDBC agents.
+- `testConnection(params)`: handled by the shared JDBC foundation for JDBC agents.
+- `listDatabases()`: return visible catalogs/databases when the database supports them; otherwise return one sensible default database.
+- `listSchemas()`: return schemas in stable order.
+- `listTables(schema)`: return table-like objects for the selected schema, with normalized `type` values where possible.
+- `getColumns(schema, table)`: return column metadata, nullability, defaults, key flags, numeric precision/scale, character length, and comments when available.
+- `listIndexes(schema, table)`: return one `IndexInfo` per index, preserving column order.
+- `listForeignKeys(schema, table)`: return outbound foreign keys when available.
+- `listTriggers(schema, table)`: return triggers when available; return an empty list if the database has no trigger metadata.
+- `executeQuery(sql, schema, options)`: inherited from the shared JDBC foundation unless the agent has a documented custom execution behavior.
+- `disconnect()`: inherited from the shared JDBC foundation.
+- `getConnection()`: inherited from the shared JDBC foundation.
+
+Throw `IllegalStateException("Not connected")` when a method requires a connection and none exists.
+
+## SQL Execution Rules
+
+Do not classify statements by SQL prefix inside individual agents.
+
+For most JDBC agents, inherit this from `AbstractJdbcAgent` or `ConfiguredJdbcAgent`. Do not copy the execution method into the agent class. If a custom value reader is required, override `resultValue(...)`:
+
+```java
+@Override
+protected Object resultValue(ResultSet rs, int index, int sqlType) {
+    return unchecked(() -> rs.getString(index));
+}
+```
+
+For simple standard JDBC metadata agents, start with a profile:
+
+```java
+public final class ExampleAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile EXAMPLE_PROFILE = new JdbcAgentProfile(
+        "com.example.Driver",
+        "jdbc:example://{host}:{port}/{database}",
+        1234
+    );
+
+    public ExampleAgent() {
+        super(EXAMPLE_PROFILE);
+    }
+}
+```
+
+`JdbcExecutor` owns these behaviors:
+
+- Trims a trailing semicolon before execution.
+- Handles `BEGIN`, `COMMIT`, and `ROLLBACK`.
+- Runs schema switching SQL before the user statement.
+- Executes statements with `Statement.execute(...)`.
+- Reads `ResultSet` output for any statement type, not only `SELECT`.
+- Returns update counts for update statements.
+- Caps result rows at `options.maxRows`, defaulting to `JdbcExecutor.DEFAULT_MAX_ROWS`.
+- Applies `options.fetchSize` to the JDBC statement when provided.
+- Marks `truncated = true` only when more rows exist beyond the cap.
+
+An agent must not reintroduce local copies of:
+
+- `QUERY_PREFIXES`
+- `MAX_ROWS`
+- `executeUpdate(trimmedSql)` in `executeQuery`
+- result truncation based on `rows.size >= MAX_ROWS`
+- `Class.forName(...)` / `DriverManager.getConnection(...)` lifecycle boilerplate outside shared foundation extension points
+- local `disconnect()` copies for JDBC agents
+- local `JdbcExecutor.INSTANCE.execute(...)` copies for standard query execution
+
+## Schema And Identifier Rules
+
+Override `setSchemaSQL(schema)` for the database dialect, or configure the profile dialect options when standard quoting is enough.
+
+Use `JdbcIdentifiers` helpers when quoting identifiers:
+
+```java
+@Override
+public String setSchemaSQL(String schema) {
+    return "SET SCHEMA " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
+}
+```
+
+If the database does not support a schema switching statement, return an empty string:
+
+```java
+@Override
+public String setSchemaSQL(String schema) {
+    return "";
+}
+```
+
+Never concatenate unquoted user-provided schema names into schema-switching SQL unless the target database requires unquoted identifiers and the value has already been validated.
+
+For metadata queries, prefer prepared statements for `schema`, `table`, and other user-controlled values.
+
+## Shared JDBC Foundation
+
+Use the smallest shared base that matches the database:
+
+- `ConfiguredJdbcAgent`: standard JDBC lifecycle, execution, and standard `DatabaseMetaData`-based metadata.
+- `PostgresLikeAgent`: PostgreSQL-family metadata with shared lifecycle and execution.
+- `AbstractJdbcAgent`: custom metadata SQL with shared lifecycle, execution, paging, transactions, result conversion, and DDL fallback.
+
+If a database cannot yet use the shared foundation, add it to the validation allowlist with a specific reason and tests covering the custom behavior. Remove the allowlist entry when the module migrates.
+
+## Driver Packaging
+
+Each module chooses one of two driver modes.
+
+### Bundled Driver
+
+Use this when the driver is redistributable from Maven Central or another permitted repository:
+
+```groovy
+dependencies {
+    implementation 'com.example:example-jdbc:1.2.3'
+}
+```
+
+The root Gradle convention supplies `project(':common')`, `project(':test-support')`, JUnit, Java toolchains, the Shadow plugin, and the `dbx-agent-<module>` archive name for included agent modules.
+
+No manifest flag is needed.
+
+### External Driver
+
+Use this when the driver cannot be redistributed or must be supplied by the user:
+
+```groovy
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes(
+            'Agent-Label': 'Example DB',
+            'Agent-External-Driver': 'true',
+            'Main-Class': 'com.dbx.agent.example.ExampleAgent'
+        )
+    }
+}
+```
+
+The release workflow reads `Agent-External-Driver: true` and emits `external_driver_required: true` in `agent-registry.json`.
+
+## Module Registration
+
+When adding an agent named `exampledb`:
+
+- Create the module under `drivers/exampledb`.
+- Add `exampledb` to `driverModules` in `settings.gradle`.
+- Add `"exampledb": "0.1.0"` to `versions.json`.
+- Set `Agent-Label` to the user-facing database name.
+- Set `Main-Class` to the Java agent class, usually `com.dbx.agent.exampledb.ExampledbAgent`.
+- Add the database to the README support table.
+
+The root `build.gradle` convention derives the archive name from the module name, so `exampledb` builds `dbx-agent-exampledb.jar` without per-module archive configuration.
+
+`versions.json` must contain only modules included in `settings.gradle`, excluding infrastructure modules such as `common` and `test-support`.
+
+## Runtime Selection
+
+Default to:
+
+```groovy
+def java8Projects = ['common', 'test-support'] as Set
+
+subprojects {
+    java {
+        toolchain {
+            languageVersion = JavaLanguageVersion.of(java8Projects.contains(name) ? 8 : 21)
+        }
+    }
+}
+```
+
+Most agents use JRE 21. If an agent needs a special runtime, update the root Gradle convention, the release workflow JRE detection logic, and document the reason in the module.
+
+## Tests
+
+Every JDBC agent should have at least one execution-path regression test.
+
+For agents that can run with an embedded or in-memory database, prefer both shared behavior contracts:
+
+```java
+import java.util.List;
+
+class H2ExecutionBehaviorTest extends JdbcExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createConnectedAgent(String databaseName) {
+        return H2AgentFixtures.createConnectedAgent(databaseName);
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL 42";
+    }
+
+    @Override
+    protected List<String> expectedResultSetColumns() {
+        return List.of("42");
+    }
+
+    @Override
+    protected List<List<Object>> expectedResultSetRows() {
+        return List.of(List.of(42));
+    }
+
+    @Override
+    protected String rowsSql(int rowCount) {
+        return "SELECT X FROM SYSTEM_RANGE(1, " + rowCount + ")";
+    }
+}
+
+class H2MetadataBehaviorTest extends JdbcMetadataBehaviorTest {
+    @Override
+    protected DatabaseAgent createConnectedAgent(String databaseName) {
+        return H2AgentFixtures.createConnectedAgent(databaseName);
+    }
+
+    @Override
+    protected List<String> metadataFixtureSql() {
+        return List.of(
+            "CREATE TABLE BETA_TABLE (ID INT PRIMARY KEY)",
+            "CREATE TABLE ALPHA_TABLE (ID INT PRIMARY KEY)",
+            "CREATE TABLE COLUMN_ORDER_SAMPLE (ID INT PRIMARY KEY, NAME VARCHAR(64), CREATED_AT TIMESTAMP)"
+        );
+    }
+
+    @Override
+    protected String metadataSchema() {
+        return "PUBLIC";
+    }
+
+    @Override
+    protected List<String> expectedTablesInOrder() {
+        return List.of("ALPHA_TABLE", "BETA_TABLE", "COLUMN_ORDER_SAMPLE");
+    }
+
+    @Override
+    protected String metadataColumnsTable() {
+        return "COLUMN_ORDER_SAMPLE";
+    }
+
+    @Override
+    protected List<String> expectedColumnsInOrder() {
+        return List.of("ID", "NAME", "CREATED_AT");
+    }
+}
+
+final class H2AgentFixtures {
+    private H2AgentFixtures() {
+    }
+
+    static DatabaseAgent createConnectedAgent(String databaseName) {
+        H2Agent agent = new H2Agent();
+        agent.connect(new ConnectParams("mem:" + databaseName + ";DB_CLOSE_DELAY=-1"));
+        return agent;
+    }
+}
+```
+
+`JdbcExecutionBehaviorTest` verifies non-`SELECT` result set execution, max-row truncation boundaries, and transaction control statements. `JdbcMetadataBehaviorTest` verifies stable metadata ordering. Agents with limited local test infrastructure can adopt the execution contract first and add the metadata contract later.
+
+For agents that need unavailable commercial or external drivers, use the fake execution contract:
+
+```java
+class ExampleAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new ExampleAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "SHOW TABLES";
+    }
+}
+```
+
+`JdbcFakeExecutionBehaviorTest` injects a fake JDBC connection and verifies that `executeQuery` uses `Statement.execute`, reads the returned `ResultSet`, and does not fall back to `executeQuery` or `executeUpdate`. Use `testImplementation project(':test-support')` for this contract.
+
+## Review Checklist
+
+Before opening a PR or release:
+
+- `executeQuery` delegates to `JdbcExecutor.execute`.
+- No local SQL-prefix classifier exists.
+- No local result row cap exists unless there is a database-specific reason documented in code.
+- Metadata methods use prepared statements for user-controlled schema/table inputs.
+- `setSchemaSQL` quotes identifiers or returns an empty string.
+- `disconnect` closes and clears the connection.
+- `testConnection` closes its temporary connection.
+- Root `build.gradle` conventions cover Java plugin, toolchain, JUnit, common/test-support dependencies, Shadow plugin, and archive name.
+- Module `build.gradle` has correct driver dependencies, `Agent-Label`, `Main-Class`, and external driver flag.
+- `settings.gradle`, `versions.json`, and README are updated together.
+- At least one execution-path regression test exists.
+- `python3 scripts/validate_agents.py` passes.
+- `./gradlew test shadowJar --continue` passes.
diff --git a/agents/docs/examples/jdbc-agent-template/README.md b/agents/docs/examples/jdbc-agent-template/README.md
new file mode 100644
index 0000000..18c8152
--- /dev/null
+++ b/agents/docs/examples/jdbc-agent-template/README.md
@@ -0,0 +1,20 @@
+# JDBC Agent Template
+
+Copy this directory when adding a new JDBC-based DBX agent.
+
+Recommended flow:
+
+1. Rename `template` paths, package names, class names, and artifact names to the new agent name.
+2. Replace the driver class and JDBC URL builder.
+3. Implement metadata SQL using the target database system catalogs or `DatabaseMetaData`.
+4. Keep `executeQuery` delegated to `JdbcExecutor`.
+5. Place the module under `drivers/`, then add it to `settings.gradle`, `versions.json`, and the root README support table.
+6. Run `./gradlew :<agent>:test :<agent>:shadowJar`.
+
+To verify this template before copying it, run:
+
+```bash
+./gradlew -p docs/examples/jdbc-agent-template clean test shadowJar
+```
+
+See `docs/agent-authoring.md` for the full checklist.
diff --git a/agents/docs/examples/jdbc-agent-template/build.gradle b/agents/docs/examples/jdbc-agent-template/build.gradle
new file mode 100644
index 0000000..45bec3a
--- /dev/null
+++ b/agents/docs/examples/jdbc-agent-template/build.gradle
@@ -0,0 +1,64 @@
+plugins {
+    id 'java'
+    id 'com.gradleup.shadow'
+}
+
+configure([project(':common'), project(':test-support')]) {
+    if (name == 'test-support') {
+        apply plugin: 'java-library'
+    } else {
+        apply plugin: 'java'
+    }
+
+    java {
+        toolchain {
+            languageVersion = JavaLanguageVersion.of(8)
+        }
+    }
+
+    dependencies {
+        testImplementation 'org.junit.jupiter:junit-jupiter:5.11.4'
+        testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.11.4'
+    }
+
+    tasks.withType(Test).configureEach {
+        useJUnitPlatform()
+    }
+}
+
+dependencies {
+    implementation project(':common')
+
+    // Bundled driver example:
+    // implementation 'com.example:example-jdbc:1.2.3'
+
+    // External driver example:
+    // implementation fileTree(dir: 'libs', include: ['*.jar'])
+
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.11.4'
+    testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.11.4'
+    testImplementation project(':test-support')
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(21)
+    }
+}
+
+tasks.named('shadowJar') {
+    archiveBaseName = 'dbx-agent-template'
+    archiveClassifier = ''
+    manifest {
+        attributes(
+            'Agent-Label': 'Template DB',
+            // Add this only when users must provide the JDBC driver jar:
+            // 'Agent-External-Driver': 'true',
+            'Main-Class': 'com.dbx.agent.template.TemplateAgent'
+        )
+    }
+}
+
+tasks.named('test') {
+    useJUnitPlatform()
+}
diff --git a/agents/docs/examples/jdbc-agent-template/settings.gradle b/agents/docs/examples/jdbc-agent-template/settings.gradle
new file mode 100644
index 0000000..0a2ac70
--- /dev/null
+++ b/agents/docs/examples/jdbc-agent-template/settings.gradle
@@ -0,0 +1,21 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        mavenCentral()
+    }
+    plugins {
+        id 'com.gradleup.shadow' version '9.0.0-beta12'
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        mavenCentral()
+    }
+}
+
+rootProject.name = 'jdbc-agent-template'
+include 'common', 'test-support'
+project(':common').projectDir = file('../../../common')
+project(':test-support').projectDir = file('../../../test-support')
diff --git a/agents/docs/examples/jdbc-agent-template/src/main/java/com/dbx/agent/template/TemplateAgent.java b/agents/docs/examples/jdbc-agent-template/src/main/java/com/dbx/agent/template/TemplateAgent.java
new file mode 100644
index 0000000..bca4d45
--- /dev/null
+++ b/agents/docs/examples/jdbc-agent-template/src/main/java/com/dbx/agent/template/TemplateAgent.java
@@ -0,0 +1,27 @@
+package com.dbx.agent.template;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+
+public final class TemplateAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile TEMPLATE_PROFILE = new JdbcAgentProfile(
+        "com.example.jdbc.TemplateDriver",
+        "jdbc:template://{host}:{port}/{database}",
+        1234
+    );
+
+    public TemplateAgent() {
+        super(TEMPLATE_PROFILE);
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "SET SCHEMA " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new TemplateAgent()).run();
+    }
+}
diff --git a/agents/docs/examples/jdbc-agent-template/src/test/java/com/dbx/agent/template/TemplateAgentTest.java b/agents/docs/examples/jdbc-agent-template/src/test/java/com/dbx/agent/template/TemplateAgentTest.java
new file mode 100644
index 0000000..d074e67
--- /dev/null
+++ b/agents/docs/examples/jdbc-agent-template/src/test/java/com/dbx/agent/template/TemplateAgentTest.java
@@ -0,0 +1,23 @@
+package com.dbx.agent.template;
+
+import com.dbx.agent.test.TestSupport;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.test.JdbcAgentFake;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class TemplateAgentTest {
+    @Test
+    void executeQueryUsesStatementExecute() {
+        TemplateAgent agent = new TemplateAgent();
+        TestSupport.setPrivateConnection(agent, JdbcAgentFake.connection());
+
+        agent.executeQuery("SHOW TABLES", null, new ExecuteQueryOptions());
+
+        Assertions.assertEquals(
+            List.of("setMaxRows:10001", "execute"),
+            JdbcAgentFake.calls
+        );
+    }
+}
diff --git a/agents/docs/release-checklist.md b/agents/docs/release-checklist.md
new file mode 100644
index 0000000..f84b33a
--- /dev/null
+++ b/agents/docs/release-checklist.md
@@ -0,0 +1,193 @@
+# Release Checklist
+
+Use this checklist before pushing release tags or publishing DBX agent jars.
+
+## 1. Confirm Scope
+
+- Review the recent commits:
+
+```bash
+git log --oneline -10
+```
+
+- Confirm the working tree is clean before tagging:
+
+```bash
+git status --short
+```
+
+- Check that each intended agent change touches the right module directory, `common`, `test-support`, docs, or workflows.
+- Avoid mixing unrelated driver updates, behavior changes, and release-only edits in the same commit.
+
+## 2. Local Verification
+
+On this workspace, use the local JDKs under `/private/tmp`:
+
+```bash
+env JAVA_HOME=/private/tmp/dbx-jdk/jdk-21.0.11+10/Contents/Home \
+  ./gradlew \
+  -Dorg.gradle.java.installations.paths=/private/tmp/dbx-jdk/jdk-21.0.11+10/Contents/Home,/private/tmp/dbx-jdk8/jdk8/Contents/Home \
+  test shadowJar --continue
+```
+
+Also run the lightweight validation gates:
+
+```bash
+python3 -m unittest discover -s scripts -p '*_test.py'
+python3 scripts/validate_agents.py
+python3 scripts/validate_agent_jars.py
+git diff --check
+```
+
+Expected result:
+
+- Python script tests pass.
+- `Agent validation passed`.
+- `Agent jar validation passed` after `shadowJar` has produced jars.
+- `git diff --check` prints nothing.
+- Gradle finishes with `BUILD SUCCESSFUL`.
+
+## 3. Agent Contract Checks
+
+For changed agent modules:
+
+- `executeQuery` delegates to `JdbcExecutor.execute`.
+- No module-local SQL prefix classifier is present.
+- No module-local result row cap is present.
+- `Statement.execute(...)` is used for arbitrary user SQL.
+- Metadata methods return stable ordering for schemas, tables, columns, indexes, foreign keys, and triggers.
+- User-controlled schema and table names are passed through prepared statements or quoted with `JdbcIdentifiers`.
+- `connect` stores one connection, `disconnect` closes and clears it, and `testConnection` closes its temporary connection.
+- A behavior test exists:
+  - Use `JdbcExecutionBehaviorTest` and `JdbcMetadataBehaviorTest` for agents with a local/embedded test database.
+  - Use `JdbcFakeExecutionBehaviorTest` for agents that require unavailable external drivers.
+  - Use targeted `JdbcMetadataSqlFake` tests for metadata SQL that must interpolate quoted identifiers.
+
+## 4. Registry And Module Checks
+
+Run:
+
+```bash
+python3 scripts/validate_agents.py
+```
+
+This checks:
+
+- `versions.json` keys match included agent modules in `settings.gradle`.
+- Root Gradle conventions define agent archive names.
+- Agent manifests define `Agent-Label`.
+- Agent manifests define `Main-Class`.
+- Agent `Main-Class` source exists and the built jar contains the matching `.class`.
+- Forbidden legacy execution patterns are absent.
+- Disallowed JVM source/build DSL residue is absent outside Gradle output directories.
+
+When adding or removing an agent, update these files together:
+
+- `settings.gradle`
+- `versions.json`
+- `README.md`
+- Agent module `build.gradle` for driver dependencies and manifest attributes
+- Root `build.gradle` only when the module needs non-standard shared build behavior
+
+## 5. Driver Packaging
+
+For bundled drivers:
+
+- Verify the dependency is redistributable.
+- Prefer Maven dependencies over checked-in jars.
+
+For external drivers:
+
+- Use `implementation fileTree(dir: 'libs', include: ['*.jar'])`.
+- Set the manifest attribute:
+
+```groovy
+attributes(
+    'Agent-External-Driver': 'true'
+)
+```
+
+- Confirm release registry generation emits `external_driver_required: true`.
+
+Current external-driver agents include BigQuery and SunDB.
+
+## 6. JRE Selection
+
+Java agents are built for the default JRE key `21`, backed by JDK 21 in the release workflow. Native agents do not require a JRE.
+
+If another agent needs a different runtime, update the release workflow JRE detection logic.
+- Document why in the module or release notes.
+- Verify DBX can download the matching runtime artifact.
+
+## 7. CI Expectations
+
+The CI workflow runs on `main` and pull requests:
+
+```bash
+python3 -m unittest discover -s scripts -p '*_test.py'
+python3 scripts/validate_agents.py
+./gradlew test shadowJar --continue
+python3 scripts/validate_agent_jars.py
+```
+
+Do not tag a release while CI is failing on `main`.
+
+## 8. Release Tag Flow
+
+Release workflow runs on tags matching `agents-v*`.
+
+Before tagging:
+
+```bash
+git status --short
+git log --oneline -5
+git tag --list 'agents-v*' --sort=-creatordate | head
+```
+
+Choose a new tag that does not already exist locally or on GitHub. For example:
+
+```bash
+RELEASE_TAG=agents-v0.3.0
+git tag --list "$RELEASE_TAG"
+git ls-remote --tags origin "$RELEASE_TAG"
+```
+
+Both commands should print nothing before you create the tag.
+
+Create and push the tag:
+
+```bash
+git tag "$RELEASE_TAG"
+git push origin main
+git push origin "$RELEASE_TAG"
+```
+
+The release workflow will:
+
+- Bump changed module versions in `versions.json`.
+- Build all agent shadow jars.
+- Build/download JRE artifacts.
+- Generate `agent-registry.json`.
+- Create a GitHub release with jars, JRE archives, and registry.
+
+## 9. Post-Release Verification
+
+After the GitHub release finishes:
+
+- Download or inspect `agent-registry.json`.
+- Confirm every expected agent appears under `drivers`.
+- Confirm labels preserve spaces, for example `Google BigQuery`.
+- Confirm Java agents use JRE key `21`.
+- Confirm `external_driver_required` is correct.
+- Confirm every jar URL, sha256, and size is present.
+- Spot-check at least one agent jar manifest:
+
+```bash
+unzip -p dbx-agent-h2.jar META-INF/MANIFEST.MF
+```
+
+## 10. Known Follow-Ups
+
+- Gradle currently reports deprecated features that will be incompatible with Gradle 10. Use `--warning-mode all` in a separate cleanup task.
+- Commercial or external-driver agents still need manual smoke tests with real driver jars and databases.
+- Add real containerized smoke tests only one database family at a time.
diff --git a/agents/drivers/access/build.gradle b/agents/drivers/access/build.gradle
new file mode 100644
index 0000000..946b6f9
--- /dev/null
+++ b/agents/drivers/access/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation 'io.github.spannm:ucanaccess:5.1.5'
+    implementation 'io.github.spannm:jackcess-encrypt:5.1.0'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Microsoft Access', 'Main-Class': 'com.dbx.agent.access.AccessAgent')
+    }
+}
diff --git a/agents/drivers/access/src/main/java/com/dbx/agent/access/AccessAgent.java b/agents/drivers/access/src/main/java/com/dbx/agent/access/AccessAgent.java
new file mode 100644
index 0000000..90311ca
--- /dev/null
+++ b/agents/drivers/access/src/main/java/com/dbx/agent/access/AccessAgent.java
@@ -0,0 +1,372 @@
+package com.dbx.agent.access;
+
+import com.dbx.agent.BaseDatabaseAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcExecutor;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+public final class AccessAgent extends BaseDatabaseAgent {
+    private static final String ENCRYPTED_ACCESS_OPENER = EncryptedAccessOpener.class.getName();
+    private Connection connection;
+    private String databaseFile = "";
+
+    @Override
+    public Connection getConnection() {
+        return connection;
+    }
+
+    @Override
+    public void connect(ConnectParams params) {
+        uncheckedVoid(() -> {
+            Class.forName("net.ucanaccess.jdbc.UcanaccessDriver");
+            String file = databasePath(params);
+            String url = jdbcUrl(params, true);
+            connection = DriverManager.getConnection(url, params.getUsername(), params.getPassword());
+            databaseFile = file;
+        });
+    }
+
+    @Override
+    public boolean testConnection(ConnectParams params) {
+        return unchecked(() -> {
+            Class.forName("net.ucanaccess.jdbc.UcanaccessDriver");
+            String file = databasePath(params);
+            if (file.isBlank() || !Files.exists(Path.of(file))) {
+                return false;
+            }
+            try (Connection conn = DriverManager.getConnection(jdbcUrl(params, false), params.getUsername(), params.getPassword())) {
+                return conn.isValid(5);
+            }
+        });
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        String name = "default";
+        if (!databaseFile.isBlank()) {
+            Path fileName = Path.of(databaseFile).getFileName();
+            if (fileName != null && !fileName.toString().isBlank()) {
+                name = fileName.toString();
+            }
+        }
+        return Collections.singletonList(new DatabaseInfo(name));
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            DatabaseMetaData meta = requireConnected().getMetaData();
+            List<TableInfo> result = new ArrayList<>();
+            try (ResultSet rs = meta.getTables(null, null, "%", new String[]{"TABLE", "VIEW"})) {
+                while (rs.next()) {
+                    String name = rs.getString("TABLE_NAME");
+                    if (name == null || startsWithIgnoreCase(name, "MSys")) {
+                        continue;
+                    }
+                    result.add(new TableInfo(name, normalizeTableType(rs.getString("TABLE_TYPE")), null));
+                }
+            }
+            result.sort(Comparator.comparing(table -> table.getName().toLowerCase(Locale.ROOT)));
+            return result;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        List<ObjectInfo> result = new ArrayList<>();
+        for (TableInfo table : listTables(schema)) {
+            result.add(new ObjectInfo(table.getName(), table.getTable_type(), null, table.getComment()));
+        }
+        return result;
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            DatabaseMetaData meta = requireConnected().getMetaData();
+            Set<String> primaryKeys = primaryKeyColumns(meta, table);
+            List<ColumnInfo> result = new ArrayList<>();
+            try (ResultSet rs = meta.getColumns(null, null, table, "%")) {
+                while (rs.next()) {
+                    String name = rs.getString("COLUMN_NAME");
+                    result.add(new ColumnInfo(
+                        name,
+                        typeName(rs),
+                        rs.getInt("NULLABLE") != DatabaseMetaData.columnNoNulls,
+                        rs.getString("COLUMN_DEF"),
+                        primaryKeys.contains(name),
+                        null,
+                        rs.getString("REMARKS"),
+                        intObject(rs, "COLUMN_SIZE"),
+                        intObject(rs, "DECIMAL_DIGITS"),
+                        intObject(rs, "COLUMN_SIZE")
+                    ));
+                }
+            }
+            result.sort(Comparator.comparingInt(column -> columnOrder(meta, table, column.getName())));
+            return result;
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return unchecked(() -> {
+            DatabaseMetaData meta = requireConnected().getMetaData();
+            Set<String> primaryKeys = primaryKeyColumns(meta, table);
+            Map<String, List<OrdinalColumn>> columnsByIndex = new LinkedHashMap<>();
+            Map<String, Boolean> uniqueByIndex = new LinkedHashMap<>();
+            Map<String, Boolean> primaryByIndex = new LinkedHashMap<>();
+            Map<String, String> typeByIndex = new LinkedHashMap<>();
+
+            try (ResultSet rs = meta.getIndexInfo(null, null, table, false, false)) {
+                while (rs.next()) {
+                    if (rs.getShort("TYPE") == DatabaseMetaData.tableIndexStatistic) {
+                        continue;
+                    }
+                    String indexName = rs.getString("INDEX_NAME");
+                    String columnName = rs.getString("COLUMN_NAME");
+                    if (indexName == null || columnName == null) {
+                        continue;
+                    }
+                    short ordinal = rs.getShort("ORDINAL_POSITION");
+
+                    columnsByIndex.computeIfAbsent(indexName, ignored -> new ArrayList<>()).add(new OrdinalColumn(ordinal, columnName));
+                    uniqueByIndex.put(indexName, !rs.getBoolean("NON_UNIQUE"));
+                    primaryByIndex.put(indexName, primaryKeys.contains(columnName) || indexName.equalsIgnoreCase("PrimaryKey"));
+                    typeByIndex.put(indexName, indexTypeName(rs.getShort("TYPE")));
+                }
+            }
+
+            List<IndexInfo> result = new ArrayList<>();
+            for (Map.Entry<String, List<OrdinalColumn>> entry : columnsByIndex.entrySet()) {
+                String name = entry.getKey();
+                List<OrdinalColumn> pairs = entry.getValue();
+                pairs.sort(Comparator.comparingInt(pair -> pair.ordinal));
+                List<String> columns = new ArrayList<>();
+                for (OrdinalColumn pair : pairs) {
+                    columns.add(pair.column);
+                }
+                result.add(new IndexInfo(
+                    name,
+                    columns,
+                    uniqueByIndex.getOrDefault(name, false),
+                    primaryByIndex.getOrDefault(name, false),
+                    null,
+                    typeByIndex.get(name),
+                    null,
+                    null
+                ));
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return unchecked(() -> {
+            DatabaseMetaData meta = requireConnected().getMetaData();
+            List<ForeignKeyInfo> result = new ArrayList<>();
+            try (ResultSet rs = meta.getImportedKeys(null, null, table)) {
+                while (rs.next()) {
+                    String name = rs.getString("FK_NAME");
+                    result.add(new ForeignKeyInfo(
+                        name == null ? "" : name,
+                        rs.getString("FKCOLUMN_NAME"),
+                        rs.getString("PKTABLE_NAME"),
+                        rs.getString("PKCOLUMN_NAME")
+                    ));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        return JdbcExecutor.INSTANCE.execute(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options.getMaxRows(),
+            options.getFetchSize(),
+            options.getTimeoutSecs(),
+            JdbcExecutor.INSTANCE::defaultResultValue
+        );
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "";
+    }
+
+    @Override
+    public void disconnect() {
+        uncheckedVoid(() -> {
+            if (connection != null) {
+                connection.close();
+            }
+            connection = null;
+        });
+    }
+
+    private Set<String> primaryKeyColumns(DatabaseMetaData meta, String table) throws Exception {
+        Set<String> result = new LinkedHashSet<>();
+        try (ResultSet rs = meta.getPrimaryKeys(null, null, table)) {
+            while (rs.next()) {
+                result.add(rs.getString("COLUMN_NAME"));
+            }
+        }
+        return result;
+    }
+
+    private int columnOrder(DatabaseMetaData meta, String table, String column) {
+        return unchecked(() -> {
+            try (ResultSet rs = meta.getColumns(null, null, table, column)) {
+                return rs.next() ? rs.getInt("ORDINAL_POSITION") : Integer.MAX_VALUE;
+            }
+        });
+    }
+
+    private static String databasePath(ConnectParams params) {
+        if (startsWithIgnoreCase(params.getConnection_string(), "jdbc:ucanaccess:")) {
+            return stripJdbcPrefix(params.getConnection_string());
+        }
+        if (startsWithIgnoreCase(params.getDatabase(), "jdbc:ucanaccess:")) {
+            return stripJdbcPrefix(params.getDatabase());
+        }
+        if (!params.getHost().isBlank()) {
+            return params.getHost();
+        }
+        return params.getDatabase();
+    }
+
+    static String jdbcUrl(ConnectParams params, boolean createIfMissing) {
+        String rawUrl;
+        if (startsWithIgnoreCase(params.getConnection_string(), "jdbc:ucanaccess:")) {
+            rawUrl = params.getConnection_string();
+        } else if (startsWithIgnoreCase(params.getDatabase(), "jdbc:ucanaccess:")) {
+            rawUrl = params.getDatabase();
+        } else {
+            rawUrl = "jdbc:ucanaccess://" + databasePath(params);
+        }
+        rawUrl = appendUCanAccessParams(rawUrl, params.getUrl_params());
+
+        // The codec opener is safe for regular files and enables encrypted Access files when a password is supplied.
+        if (!containsIgnoreCase(rawUrl, "jackcessOpener=")) {
+            rawUrl += (rawUrl.endsWith(";") ? "" : ";") + "jackcessOpener=" + ENCRYPTED_ACCESS_OPENER;
+        }
+
+        if (!createIfMissing || Files.exists(Path.of(databasePath(params)))) {
+            return rawUrl;
+        }
+        if (containsIgnoreCase(rawUrl, "newDatabaseVersion=")) {
+            return rawUrl;
+        }
+        return rawUrl + ";newDatabaseVersion=V2010";
+    }
+
+    private static String appendUCanAccessParams(String url, String urlParams) {
+        String params = trimUCanAccessParams(urlParams);
+        if (params.isEmpty()) {
+            return url;
+        }
+        return url + (url.endsWith(";") ? "" : ";") + params;
+    }
+
+    private static String trimUCanAccessParams(String urlParams) {
+        String value = urlParams == null ? "" : urlParams.trim();
+        while (value.startsWith("?") || value.startsWith("&") || value.startsWith(";")) {
+            value = value.substring(1);
+        }
+        return value;
+    }
+
+    private static String normalizeTableType(String value) {
+        if (value != null && value.toUpperCase(Locale.ROOT).equals("BASE TABLE")) {
+            return "TABLE";
+        }
+        return value == null ? "TABLE" : value;
+    }
+
+    private static String indexTypeName(short value) {
+        if (value == DatabaseMetaData.tableIndexClustered) {
+            return "CLUSTERED";
+        }
+        if (value == DatabaseMetaData.tableIndexHashed) {
+            return "HASHED";
+        }
+        if (value == DatabaseMetaData.tableIndexOther) {
+            return "OTHER";
+        }
+        return "";
+    }
+
+    private static String typeName(ResultSet rs) throws Exception {
+        String value = rs.getString("TYPE_NAME");
+        return value == null ? Integer.toString(rs.getInt("DATA_TYPE")) : value;
+    }
+
+    private static Integer intObject(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number number ? number.intValue() : null;
+    }
+
+    private static String stripJdbcPrefix(String value) {
+        return substringBefore(value.replaceFirst("(?i)^jdbc:ucanaccess://", ""), ';');
+    }
+
+    private static String substringBefore(String value, char delimiter) {
+        int index = value.indexOf(delimiter);
+        return index >= 0 ? value.substring(0, index) : value;
+    }
+
+    private static boolean startsWithIgnoreCase(String value, String prefix) {
+        return value.regionMatches(true, 0, prefix, 0, prefix.length());
+    }
+
+    private static boolean containsIgnoreCase(String value, String needle) {
+        return value.toLowerCase(Locale.ROOT).contains(needle.toLowerCase(Locale.ROOT));
+    }
+
+    private record OrdinalColumn(short ordinal, String column) {
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new AccessAgent()).run();
+    }
+}
diff --git a/agents/drivers/access/src/main/java/com/dbx/agent/access/EncryptedAccessOpener.java b/agents/drivers/access/src/main/java/com/dbx/agent/access/EncryptedAccessOpener.java
new file mode 100644
index 0000000..b298f45
--- /dev/null
+++ b/agents/drivers/access/src/main/java/com/dbx/agent/access/EncryptedAccessOpener.java
@@ -0,0 +1,20 @@
+package com.dbx.agent.access;
+
+import io.github.spannm.jackcess.Database;
+import io.github.spannm.jackcess.DatabaseBuilder;
+import io.github.spannm.jackcess.encrypt.CryptCodecProvider;
+import java.io.File;
+import java.io.IOException;
+import net.ucanaccess.jdbc.IJackcessOpenerInterface;
+
+public final class EncryptedAccessOpener implements IJackcessOpenerInterface {
+    @Override
+    public Database open(File file, String password) throws IOException {
+        DatabaseBuilder builder = new DatabaseBuilder(file);
+        // UCanAccess flushes changes at transaction boundaries, so Jackcess auto-sync is unnecessary overhead.
+        builder.withAutoSync(false);
+        builder.withCodecProvider(new CryptCodecProvider(password));
+        builder.withReadOnly(false);
+        return builder.open();
+    }
+}
diff --git a/agents/drivers/access/src/test/java/com/dbx/agent/access/AccessAgentTest.java b/agents/drivers/access/src/test/java/com/dbx/agent/access/AccessAgentTest.java
new file mode 100644
index 0000000..1ef554a
--- /dev/null
+++ b/agents/drivers/access/src/test/java/com/dbx/agent/access/AccessAgentTest.java
@@ -0,0 +1,155 @@
+package com.dbx.agent.access;
+
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.QueryPageOptions;
+import com.dbx.agent.test.JdbcConnectedAgentTest;
+import java.nio.file.Path;
+import java.nio.file.Files;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class AccessAgentTest extends JdbcConnectedAgentTest {
+    @TempDir
+    Path tempDir;
+
+    @Override
+    protected DatabaseAgent createConnectedAgent(String databaseName) {
+        Path file = tempDir.resolve(databaseName + ".accdb");
+        AccessAgent agent = new AccessAgent();
+        agent.connect(new ConnectParams("", 0, file.toString(), "", "", "", "", false));
+        return agent;
+    }
+
+    @Test
+    void connectsToAnAccessFileAndReturnsTableMetadata() {
+        withAgent("metadata", agent -> {
+            agent.executeQuery(
+                "CREATE TABLE People (ID COUNTER PRIMARY KEY, Name TEXT(64), Active YESNO)",
+                null,
+                new ExecuteQueryOptions()
+            );
+            agent.executeQuery("INSERT INTO People (Name, Active) VALUES ('Ada', TRUE)", null, new ExecuteQueryOptions());
+
+            var tables = agent.listTables("");
+            var columns = agent.getColumns("", "People");
+            var result = agent.executeQuery("SELECT Name, Active FROM People", null, new ExecuteQueryOptions());
+
+            Assertions.assertTrue(tables.stream().anyMatch(table -> table.getName().equals("People")));
+            Assertions.assertEquals(List.of("ID", "Name", "Active"), columns.stream().map(column -> column.getName()).toList());
+            Assertions.assertTrue(columns.stream()
+                .filter(column -> column.getName().equals("ID"))
+                .findFirst()
+                .orElseThrow()
+                .getIs_primary_key());
+            Assertions.assertEquals(List.of("Name", "Active"), result.getColumns());
+            Assertions.assertEquals("Ada", result.getRows().get(0).get(0));
+            Assertions.assertEquals(true, result.getRows().get(0).get(1));
+        });
+    }
+
+    @Test
+    void returnsEmptySchemaListForAccessFiles() {
+        withAgent("schemas", agent -> {
+            Assertions.assertEquals(List.of(), agent.listSchemas());
+            Assertions.assertFalse(agent.testConnection(
+                new ConnectParams("", 0, tempDir.resolve("missing.accdb").toString(), "", "", "", "", false)
+            ));
+        });
+    }
+
+    @Test
+    void appendsUcanaccessUrlParams() {
+        Path file = tempDir.resolve("params.accdb");
+        ConnectParams params = new ConnectParams("", 0, file.toString(), "", "", "memory=false;ignoreCase=true", "", false);
+
+        Assertions.assertEquals(
+            "jdbc:ucanaccess://" + file + ";memory=false;ignoreCase=true;jackcessOpener=com.dbx.agent.access.EncryptedAccessOpener;newDatabaseVersion=V2010",
+            AccessAgent.jdbcUrl(params, true)
+        );
+    }
+
+    @Test
+    void trimsUcanaccessUrlParamSeparators() {
+        Path file = tempDir.resolve("params-existing.accdb");
+        ConnectParams params = new ConnectParams("", 0, "jdbc:ucanaccess://" + file + ";", "", "", ";memory=false", "", false);
+
+        Assertions.assertEquals(
+            "jdbc:ucanaccess://" + file + ";memory=false;jackcessOpener=com.dbx.agent.access.EncryptedAccessOpener;newDatabaseVersion=V2010",
+            AccessAgent.jdbcUrl(params, true)
+        );
+    }
+
+    @Test
+    void preservesCustomJackcessOpener() {
+        Path file = tempDir.resolve("custom-opener.accdb");
+        ConnectParams params = new ConnectParams(
+            "", 0, file.toString(), "", "", "jackcessOpener=example.CustomOpener", "", false
+        );
+
+        Assertions.assertEquals(
+            "jdbc:ucanaccess://" + file + ";jackcessOpener=example.CustomOpener;newDatabaseVersion=V2010",
+            AccessAgent.jdbcUrl(params, true)
+        );
+    }
+
+    @Test
+    void connectsToEncryptedAccessFile() throws Exception {
+        Path source = Path.of(getClass().getResource("/db2007-enc.accdb").toURI());
+        Path file = tempDir.resolve("encrypted.accdb");
+        Files.copy(source, file);
+        AccessAgent agent = new AccessAgent();
+
+        try {
+            agent.connect(new ConnectParams("", 0, file.toString(), "", "Test123", "", "", false));
+            Assertions.assertFalse(agent.listTables("").isEmpty());
+        } finally {
+            agent.disconnect();
+        }
+    }
+
+    @Test
+    void rejectsIncorrectEncryptedAccessPassword() throws Exception {
+        Path source = Path.of(getClass().getResource("/db2007-enc.accdb").toURI());
+        Path file = tempDir.resolve("encrypted-wrong-password.accdb");
+        Files.copy(source, file);
+        AccessAgent agent = new AccessAgent();
+
+        RuntimeException error = Assertions.assertThrows(RuntimeException.class, () ->
+            agent.connect(new ConnectParams("", 0, file.toString(), "", "wrong", "", "", false))
+        );
+        Assertions.assertTrue(error.getMessage().contains("Incorrect password provided"));
+    }
+
+    @Test
+    void supportsLimitOffsetSqlAndCursorResultPages() {
+        withAgent("pages", agent -> {
+            agent.executeQuery("CREATE TABLE Items (ID COUNTER PRIMARY KEY, Value INTEGER)", null, new ExecuteQueryOptions());
+            for (int i = 1; i <= 5; i++) {
+                agent.executeQuery("INSERT INTO Items (Value) VALUES (" + i + ")", null, new ExecuteQueryOptions());
+            }
+
+            var limited = agent.executeQuery(
+                "SELECT [Value] FROM [Items] ORDER BY [ID] LIMIT 2 OFFSET 1",
+                null,
+                new ExecuteQueryOptions()
+            );
+            var firstPage = agent.executeQueryPage(
+                "SELECT Value FROM Items ORDER BY ID",
+                null,
+                new QueryPageOptions(2, null, 5)
+            );
+            String sessionId = firstPage.getSession_id();
+            Assertions.assertNotNull(sessionId);
+            var secondPage = agent.fetchQueryPage(sessionId, 2);
+
+            Assertions.assertEquals(List.of(2, 3), limited.getRows().stream().map(row -> row.get(0)).toList());
+            Assertions.assertEquals(List.of(1, 2), firstPage.getRows().stream().map(row -> row.get(0)).toList());
+            Assertions.assertEquals(true, firstPage.getHas_more());
+            Assertions.assertEquals(List.of(3, 4), secondPage.getRows().stream().map(row -> row.get(0)).toList());
+        });
+    }
+}
diff --git a/agents/drivers/access/src/test/resources/db2007-enc.accdb b/agents/drivers/access/src/test/resources/db2007-enc.accdb
new file mode 100644
index 0000000..3707e94
Binary files /dev/null and b/agents/drivers/access/src/test/resources/db2007-enc.accdb differ
diff --git a/agents/drivers/bigquery/build.gradle b/agents/drivers/bigquery/build.gradle
new file mode 100644
index 0000000..ae0da1b
--- /dev/null
+++ b/agents/drivers/bigquery/build.gradle
@@ -0,0 +1,13 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes(
+            'Agent-Label': 'Google BigQuery',
+            'Agent-External-Driver': 'true',
+            'Main-Class': 'com.dbx.agent.bigquery.BigQueryAgent'
+        )
+    }
+}
diff --git a/agents/drivers/bigquery/src/main/java/com/dbx/agent/bigquery/BigQueryAgent.java b/agents/drivers/bigquery/src/main/java/com/dbx/agent/bigquery/BigQueryAgent.java
new file mode 100644
index 0000000..71d64bf
--- /dev/null
+++ b/agents/drivers/bigquery/src/main/java/com/dbx/agent/bigquery/BigQueryAgent.java
@@ -0,0 +1,234 @@
+package com.dbx.agent.bigquery;
+
+import com.dbx.agent.AbstractJdbcAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.MetadataSqlSupport;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+
+public final class BigQueryAgent extends AbstractJdbcAgent {
+
+    @Override
+    protected String driverClass() {
+        return "com.simba.googlebigquery.jdbc.Driver";
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return buildUrl(params);
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SELECT schema_name FROM INFORMATION_SCHEMA.SCHEMATA ORDER BY schema_name")) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString(1)));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        List<String> result = new ArrayList<>();
+        for (DatabaseInfo database : listDatabases()) {
+            result.add(database.getName());
+        }
+        return result;
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            String quotedSchema = JdbcIdentifiers.INSTANCE.backtick(schema);
+            String sql = "SELECT table_name, table_type FROM " + quotedSchema + ".INFORMATION_SCHEMA.TABLES ORDER BY table_name";
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql);
+                 ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    result.add(new TableInfo(
+                        rs.getString("table_name"),
+                        normalizeTableType(rs.getString("table_type")),
+                        null
+                    ));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listTables(schema);
+        }
+        if (!normalized.includesTableLikeTypes()) {
+            return List.of();
+        }
+        if (hasLikeWildcard(normalized.getFilter())) {
+            return normalized.filterTables(listTables(schema));
+        }
+        try {
+            return queryConstrainedTables(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterTables(listTables(schema));
+        }
+    }
+
+    private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            String quotedSchema = JdbcIdentifiers.INSTANCE.backtick(schema);
+            StringBuilder sql = new StringBuilder("SELECT table_name, table_type FROM ")
+                .append(quotedSchema)
+                .append(".INFORMATION_SCHEMA.TABLES WHERE 1 = 1");
+            appendBigQueryTableTypePredicate(sql, args, constraints);
+            if (constraints.hasFilter()) {
+                sql.append(" AND UPPER(table_name) LIKE ?");
+                args.add(constraints.fuzzyLikePattern().toUpperCase(Locale.ROOT));
+            }
+            sql.append(" ORDER BY table_name");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(
+                            rs.getString("table_name"),
+                            normalizeTableType(rs.getString("table_type")),
+                            null
+                        ));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterTables(result);
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            List<ColumnInfo> result = new ArrayList<>();
+            String quotedSchema = JdbcIdentifiers.INSTANCE.backtick(schema);
+            String sql = "SELECT column_name, data_type, is_nullable " +
+                "FROM " + quotedSchema + ".INFORMATION_SCHEMA.COLUMNS " +
+                "WHERE table_name = ? " +
+                "ORDER BY ordinal_position";
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ColumnInfo(
+                            rs.getString("column_name"),
+                            rs.getString("data_type"),
+                            "YES".equals(rs.getString("is_nullable")),
+                            null,
+                            false,
+                            null,
+                            null,
+                            null,
+                            null,
+                            null
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "";
+    }
+
+    static String buildUrl(ConnectParams params) {
+        String url = "jdbc:bigquery://" + params.getHost() + ":" + params.getPort() + ";ProjectId=" + params.getDatabase();
+        String extraParams = trimSemicolons(params.getUrl_params());
+        return extraParams.isBlank() ? url : url + ";" + extraParams;
+    }
+
+    private static String trimSemicolons(String value) {
+        if (value == null) {
+            return "";
+        }
+        return value.trim().replaceAll("^;+", "").replaceAll(";+\\s*$", "");
+    }
+
+    private static String normalizeTableType(String type) {
+        if ("BASE TABLE".equals(type)) {
+            return "TABLE";
+        }
+        if ("MATERIALIZED VIEW".equals(type)) {
+            return "MATERIALIZED_VIEW";
+        }
+        return type;
+    }
+
+    private static boolean isUnconstrained(MetadataListConstraints constraints) {
+        return !constraints.hasFilter() && !constraints.hasLimit() && !constraints.hasOffset() && !constraints.hasObjectTypes();
+    }
+
+    private static void appendBigQueryTableTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> types = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            types.add("BASE TABLE");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            types.add("VIEW");
+        }
+        if (constraints.tableTypeAllowed("MATERIALIZED_VIEW")) {
+            types.add("MATERIALIZED VIEW");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND table_type IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
+        args.addAll(types);
+    }
+
+    private static boolean hasLikeWildcard(String value) {
+        return value != null && (value.contains("%") || value.contains("_") || value.contains("\\"));
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new BigQueryAgent()).run();
+    }
+}
diff --git a/agents/drivers/bigquery/src/test/java/com/dbx/agent/bigquery/BigQueryAgentMetadataTest.java b/agents/drivers/bigquery/src/test/java/com/dbx/agent/bigquery/BigQueryAgentMetadataTest.java
new file mode 100644
index 0000000..5a6e80d
--- /dev/null
+++ b/agents/drivers/bigquery/src/test/java/com/dbx/agent/bigquery/BigQueryAgentMetadataTest.java
@@ -0,0 +1,65 @@
+package com.dbx.agent.bigquery;
+
+import com.dbx.agent.test.TestSupport;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.test.JdbcAgentFake;
+import com.dbx.agent.test.JdbcMetadataSqlFake;
+import java.sql.Connection;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class BigQueryAgentMetadataTest {
+    @Test
+    void quotesSchemaIdentifiersInMetadataSql() {
+        BigQueryAgent agent = new BigQueryAgent();
+        Connection fake = JdbcMetadataSqlFake.connection();
+        TestSupport.setPrivateConnection(agent, fake);
+
+        agent.listTables("bad`schema");
+        agent.getColumns("bad`schema", "sample");
+
+        Assertions.assertTrue(
+            JdbcMetadataSqlFake.statements.stream()
+                .anyMatch(statement -> statement.contains("FROM `bad``schema`.INFORMATION_SCHEMA.TABLES"))
+        );
+        Assertions.assertTrue(
+            JdbcMetadataSqlFake.statements.stream()
+                .anyMatch(statement -> statement.contains("FROM `bad``schema`.INFORMATION_SCHEMA.COLUMNS"))
+        );
+    }
+
+    @Test
+    void buildUrlAppendsAuthenticationUrlParams() {
+        ConnectParams params = new ConnectParams(
+            "https://www.googleapis.com/bigquery/v2",
+            443,
+            "demo-project",
+            "",
+            "",
+            "OAuthType=0;OAuthServiceAcctEmail=svc@demo.iam.gserviceaccount.com;OAuthPvtKeyPath=C:\\keys\\demo.json",
+            "",
+            false
+        );
+
+        Assertions.assertEquals(
+            "jdbc:bigquery://https://www.googleapis.com/bigquery/v2:443;ProjectId=demo-project;OAuthType=0;OAuthServiceAcctEmail=svc@demo.iam.gserviceaccount.com;OAuthPvtKeyPath=C:\\keys\\demo.json",
+            BigQueryAgent.buildUrl(params)
+        );
+    }
+
+    @Test
+    void constrainedTableMetadataPushesFilterTypesAndPaging() {
+        BigQueryAgent agent = new BigQueryAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listTables("demo`dataset", new MetadataListConstraints("ord", 25, 50, List.of("TABLE", "VIEW")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        Assertions.assertTrue(sql.contains("FROM `demo``dataset`.INFORMATION_SCHEMA.TABLES"), sql);
+        Assertions.assertTrue(sql.contains("table_type IN (?, ?)"), sql);
+        Assertions.assertTrue(sql.contains("UPPER(table_name) LIKE ?"), sql);
+        Assertions.assertTrue(sql.endsWith("LIMIT 25 OFFSET 50"), sql);
+    }
+}
diff --git a/agents/drivers/bigquery/src/test/java/com/dbx/agent/bigquery/BigQueryAgentTest.java b/agents/drivers/bigquery/src/test/java/com/dbx/agent/bigquery/BigQueryAgentTest.java
new file mode 100644
index 0000000..147d1f6
--- /dev/null
+++ b/agents/drivers/bigquery/src/test/java/com/dbx/agent/bigquery/BigQueryAgentTest.java
@@ -0,0 +1,16 @@
+package com.dbx.agent.bigquery;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+
+class BigQueryAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new BigQueryAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL dataset.proc()";
+    }
+}
diff --git a/agents/drivers/cassandra/build.gradle b/agents/drivers/cassandra/build.gradle
new file mode 100644
index 0000000..38a8d6f
--- /dev/null
+++ b/agents/drivers/cassandra/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.ing.data:cassandra-jdbc-wrapper:4.12.0'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Apache Cassandra', 'Main-Class': 'com.dbx.agent.cassandra.CassandraAgent')
+    }
+}
diff --git a/agents/drivers/cassandra/src/main/java/com/dbx/agent/cassandra/CassandraAgent.java b/agents/drivers/cassandra/src/main/java/com/dbx/agent/cassandra/CassandraAgent.java
new file mode 100644
index 0000000..6ef9f34
--- /dev/null
+++ b/agents/drivers/cassandra/src/main/java/com/dbx/agent/cassandra/CassandraAgent.java
@@ -0,0 +1,194 @@
+package com.dbx.agent.cassandra;
+
+import com.dbx.agent.AbstractJdbcAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public final class CassandraAgent extends AbstractJdbcAgent {
+    private static final Pattern TARGET_PATTERN = Pattern.compile("target[\"']?\\s*[:=]\\s*[\"']?([\\w]+)");
+
+    @Override
+    protected String driverClass() {
+        return "com.ing.data.cassandra.jdbc.CassandraDriver";
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return buildUrl(params);
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "USE " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            String sql = "SELECT keyspace_name FROM system_schema.keyspaces";
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(sql)) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString(1)));
+                }
+            }
+            result.sort(Comparator.comparing(DatabaseInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        List<String> result = new ArrayList<>();
+        for (DatabaseInfo database : listDatabases()) {
+            result.add(database.getName());
+        }
+        return result;
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            String sql = "SELECT table_name FROM system_schema.tables WHERE keyspace_name = ?";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(rs.getString(1), "TABLE", null));
+                    }
+                }
+            }
+            result.sort(Comparator.comparing(TableInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            List<ColumnInfo> result = new ArrayList<>();
+            String sql = "SELECT column_name, type, kind FROM system_schema.columns WHERE keyspace_name = ? AND table_name = ?";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String kind = coalesce(rs.getString("kind"));
+                        boolean isPrimaryKey = "partition_key".equals(kind) || "clustering".equals(kind);
+                        result.add(new ColumnInfo(
+                            rs.getString("column_name"),
+                            coalesce(rs.getString("type"), "unknown"),
+                            !isPrimaryKey,
+                            null,
+                            isPrimaryKey,
+                            kind.trim().isEmpty() ? null : kind,
+                            null,
+                            null,
+                            null,
+                            null
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return unchecked(() -> {
+            List<IndexInfo> result = new ArrayList<>();
+            String sql = "SELECT index_name, options FROM system_schema.indexes WHERE keyspace_name = ? AND table_name = ?";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String indexName = coalesce(rs.getString("index_name"));
+                        String options = coalesce(rs.getString("options"));
+                        result.add(new IndexInfo(
+                            indexName,
+                            targetColumns(options),
+                            false,
+                            false,
+                            null,
+                            null,
+                            null,
+                            null
+                        ));
+                    }
+                }
+            }
+            result.sort(Comparator.comparing(IndexInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    protected Object resultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value = rs.getObject(index);
+            return rs.wasNull() ? null : value == null ? null : value.toString();
+        });
+    }
+
+    static String buildUrl(ConnectParams params) {
+        String baseUrl = "jdbc:cassandra://" + params.getHost() + ":" + params.getPort();
+        String keyspace = coalesce(params.getDatabase()).trim();
+        // Cassandra rejects an empty keyspace path; omit it so DBX can connect first and list keyspaces.
+        String url = keyspace.isEmpty() ? baseUrl : baseUrl + "/" + keyspace;
+        // Multi-DC clusters require localdatacenter=<dc>
+        String extraParams = coalesce(params.getUrl_params()).trim();
+        while (extraParams.startsWith("?") || extraParams.startsWith("&")) {
+            extraParams = extraParams.substring(1);
+        }
+        return extraParams.isEmpty() ? url : url + "?" + extraParams;
+    }
+
+    private static List<String> targetColumns(String options) {
+        Matcher matcher = TARGET_PATTERN.matcher(options);
+        if (!matcher.find()) {
+            return Collections.emptyList();
+        }
+        return Collections.singletonList(matcher.group(1));
+    }
+
+    private static String coalesce(String value) {
+        return value == null ? "" : value;
+    }
+
+    private static String coalesce(String value, String fallback) {
+        return value == null ? fallback : value;
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new CassandraAgent()).run();
+    }
+}
diff --git a/agents/drivers/cassandra/src/test/java/com/dbx/agent/cassandra/CassandraAgentTest.java b/agents/drivers/cassandra/src/test/java/com/dbx/agent/cassandra/CassandraAgentTest.java
new file mode 100644
index 0000000..4eb9e6b
--- /dev/null
+++ b/agents/drivers/cassandra/src/test/java/com/dbx/agent/cassandra/CassandraAgentTest.java
@@ -0,0 +1,52 @@
+package com.dbx.agent.cassandra;
+
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class CassandraAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new CassandraAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "LIST ROLES";
+    }
+
+    @Test
+    void buildsServerUrlWhenKeyspaceIsEmpty() {
+        ConnectParams params = new ConnectParams("127.0.0.1", 9042, "", "cassandra", "cassandra", "", "", false);
+
+        assertEquals("jdbc:cassandra://127.0.0.1:9042", CassandraAgent.buildUrl(params));
+    }
+
+    @Test
+    void buildsKeyspaceUrlWhenKeyspaceIsSet() {
+        ConnectParams params = new ConnectParams("127.0.0.1", 9042, "app_keyspace", "cassandra", "cassandra", "", "", false);
+
+        assertEquals("jdbc:cassandra://127.0.0.1:9042/app_keyspace", CassandraAgent.buildUrl(params));
+    }
+
+    @Test
+    void appendsUrlParamsForMultiDcLocalDatacenter() {
+        ConnectParams params = new ConnectParams(
+            "127.0.0.1", 9042, "app_keyspace", "cassandra", "cassandra", "localdatacenter=dc1", "", false
+        );
+
+        assertEquals("jdbc:cassandra://127.0.0.1:9042/app_keyspace?localdatacenter=dc1", CassandraAgent.buildUrl(params));
+    }
+
+    @Test
+    void stripsLeadingQuestionMarkFromUrlParams() {
+        ConnectParams params = new ConnectParams(
+            "127.0.0.1", 9042, "", "cassandra", "cassandra", "?localdatacenter=dc1", "", false
+        );
+
+        assertEquals("jdbc:cassandra://127.0.0.1:9042?localdatacenter=dc1", CassandraAgent.buildUrl(params));
+    }
+}
diff --git a/agents/drivers/dameng/build.gradle b/agents/drivers/dameng/build.gradle
new file mode 100644
index 0000000..6a80eb9
--- /dev/null
+++ b/agents/drivers/dameng/build.gradle
@@ -0,0 +1,13 @@
+dependencies {
+    // Local override: place a newer DmJdbcDriver*.jar in libs/ for versions
+    // not yet published to Maven Central (the fileTree takes priority over Maven).
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    // DmJdbcDriver8 supports JDK 8+ (compatible with JRE 21 used by DAMENG agent).
+    implementation 'com.dameng:DmJdbcDriver8:8.1.5.45'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': '达梦 DM8', 'Main-Class': 'com.dbx.agent.dameng.DamengAgent')
+    }
+}
diff --git a/agents/drivers/dameng/libs/.gitkeep b/agents/drivers/dameng/libs/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/agents/drivers/dameng/src/main/java/com/dbx/agent/dameng/DamengAgent.java b/agents/drivers/dameng/src/main/java/com/dbx/agent/dameng/DamengAgent.java
new file mode 100644
index 0000000..103b206
--- /dev/null
+++ b/agents/drivers/dameng/src/main/java/com/dbx/agent/dameng/DamengAgent.java
@@ -0,0 +1,1327 @@
+package com.dbx.agent.dameng;
+
+import com.dbx.agent.BaseDatabaseAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcExecutor;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.QueryPageOptions;
+import com.dbx.agent.QueryPageResult;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.io.PrintStream;
+import java.io.Reader;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLXML;
+import java.sql.Statement;
+import java.sql.Types;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+public final class DamengAgent extends BaseDatabaseAgent {
+    private static final String AGENT_VERSION = "9999.06.04.1-fix-default";
+    private static final Set<String> SYSTEM_USERS = Set.of(
+        "SYS", "SYSAUDITOR", "SYSSSO", "CTISYS",
+        "SYS_DBA", "_SYS_STATISTICS", "SYS_PHM"
+    );
+
+    private Connection connection;
+    private String connectedUsername;
+
+    @Override
+    public Connection getConnection() {
+        return connection;
+    }
+
+    @Override
+    public void connect(ConnectParams params) {
+        uncheckedVoid(() -> {
+            withSuppressedStdout(() -> {
+                Class.forName("dm.jdbc.driver.DmDriver");
+                connection = DriverManager.getConnection(buildUrl(params), params.getUsername(), params.getPassword());
+                connectedUsername = params.getUsername();
+            });
+        });
+    }
+
+    @Override
+    public boolean testConnection(ConnectParams params) {
+        return unchecked(() -> {
+            return withSuppressedStdout(() -> {
+                Class.forName("dm.jdbc.driver.DmDriver");
+                try (Connection conn = DriverManager.getConnection(buildUrl(params), params.getUsername(), params.getPassword())) {
+                    return conn.isValid(5);
+                }
+            });
+        });
+    }
+
+    /**
+     * The DM JDBC driver writes a banner to {@code System.out} during
+     * {@code Class.forName} / driver initialization.  This corrupts the
+     * JSON-RPC stdout protocol.  Temporarily redirect {@code System.out}
+     * to {@code System.err} so driver output lands on stderr instead.
+     */
+    private static <T> T withSuppressedStdout(ThrowingSupplier<T> action) throws Exception {
+        PrintStream originalOut = System.out;
+        try {
+            System.setOut(System.err);
+            return action.get();
+        } finally {
+            System.setOut(originalOut);
+        }
+    }
+
+    private static void withSuppressedStdout(ThrowingRunnable action) throws Exception {
+        PrintStream originalOut = System.out;
+        try {
+            System.setOut(System.err);
+            action.run();
+        } finally {
+            System.setOut(originalOut);
+        }
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> listVisibleUsers().stream().map(DatabaseInfo::new).toList());
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return unchecked(this::listVisibleSchemas);
+    }
+
+    private List<String> listVisibleUsers() throws Exception {
+        List<String> result = new ArrayList<>();
+        String placeholders = String.join(",", SYSTEM_USERS.stream().map(user -> "?").toList());
+        String sql = "SELECT USERNAME FROM ALL_USERS WHERE USERNAME NOT IN (" + placeholders + ") ORDER BY USERNAME";
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+            int index = 1;
+            for (String user : SYSTEM_USERS) {
+                stmt.setString(index++, user);
+            }
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    result.add(rs.getString(1));
+                }
+            }
+        }
+        return result;
+    }
+
+    private List<String> listVisibleSchemas() throws Exception {
+        List<String> result = new ArrayList<>();
+        String placeholders = String.join(",", SYSTEM_USERS.stream().map(user -> "?").toList());
+        String sql = "SELECT NAME FROM SYS.SYSOBJECTS WHERE TYPE$ = 'SCH' AND NAME NOT IN (" + placeholders + ") ORDER BY NAME";
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+            int index = 1;
+            for (String user : SYSTEM_USERS) {
+                stmt.setString(index++, user);
+            }
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    result.add(rs.getString(1));
+                }
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        // Keep this call on the legacy object-type overload; the common agent
+        // also exposes a constraints overload for paged metadata listing.
+        return listTables(schema, (List<String>) null);
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, List<String> objectTypes) {
+        return unchecked(() -> {
+            Map<String, TableInfo> tablesByName = new LinkedHashMap<>();
+            if (objectTypesInclude(objectTypes, "TABLE")) {
+                loadTableOrView(schema, "TABLE", tablesByName);
+            }
+            if (objectTypesInclude(objectTypes, "VIEW")) {
+                loadTableOrView(schema, "VIEW", tablesByName);
+            }
+            if (objectTypesInclude(objectTypes, "MATERIALIZED_VIEW")) {
+                loadMaterializedViews(schema, tablesByName);
+            }
+            List<TableInfo> result = new ArrayList<>(tablesByName.values());
+            result.sort(Comparator.comparing(TableInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listTables(schema);
+        }
+        return queryConstrainedTables(schema, normalized);
+    }
+
+    private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
+        if (!constraints.includesTableLikeTypes()) {
+            return List.of();
+        }
+        try {
+            return unchecked(() -> {
+                MetadataQuery query = buildConstrainedTablesQuery(schema, constraints);
+                List<TableInfo> result = new ArrayList<>();
+                try (PreparedStatement stmt = requireConnected().prepareStatement(query.sql())) {
+                    bind(stmt, query.args());
+                    try (ResultSet rs = stmt.executeQuery()) {
+                        while (rs.next()) {
+                            result.add(new TableInfo(rs.getString("TABLE_NAME"), normalizeObjectType(rs.getString("TABLE_TYPE")), rs.getString("COMMENTS")));
+                        }
+                    }
+                }
+                return constraints.withoutPaging().filterTables(result);
+            });
+        } catch (RuntimeException e) {
+            // Restricted Dameng catalog views vary by version; fall back to the
+            // legacy metadata path so browsing still works when pushdown fails.
+            return constraints.filterTables(listTables(schema));
+        }
+    }
+
+    static MetadataQuery buildConstrainedTablesQuery(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        List<Object> args = new ArrayList<>();
+        StringBuilder sql = new StringBuilder("""
+            SELECT o.OBJECT_NAME AS TABLE_NAME,
+                   CASE WHEN o.OBJECT_TYPE = 'MATERIALIZED VIEW' THEN 'MATERIALIZED_VIEW' ELSE o.OBJECT_TYPE END AS TABLE_TYPE,
+                   c.COMMENTS
+            FROM ALL_OBJECTS o
+            LEFT JOIN ALL_TAB_COMMENTS c ON c.OWNER = o.OWNER AND c.TABLE_NAME = o.OBJECT_NAME
+            WHERE o.OWNER = ?
+            """.stripIndent().trim());
+        args.add(schema);
+        appendDamengObjectTypePredicate(sql, args, normalized, true);
+        sql.append(" AND (o.OBJECT_TYPE <> 'TABLE' OR o.OBJECT_NAME NOT LIKE 'MTAB$_%')");
+        appendNameFilter(sql, args, "o.OBJECT_NAME", normalized);
+        sql.append(" ORDER BY o.OBJECT_NAME");
+        appendLimitOffset(sql, args, normalized);
+        return new MetadataQuery(sql.toString(), args);
+    }
+
+    private void loadTableOrView(String schema, String tableType, Map<String, TableInfo> tablesByName) {
+        if (!loadTableOrViewFromAllObjects(schema, tableType, tablesByName)) {
+            loadTableOrViewFromComments(schema, tableType, tablesByName);
+        }
+        if ("VIEW".equals(tableType)) {
+            removeMaterializedViewsFromRegularViews(schema, tablesByName);
+        }
+    }
+
+    private boolean loadTableOrViewFromAllObjects(String schema, String tableType, Map<String, TableInfo> tablesByName) {
+        String sql = ("""
+            SELECT o.OBJECT_NAME AS TABLE_NAME, c.COMMENTS
+            FROM ALL_OBJECTS o
+            LEFT JOIN ALL_TAB_COMMENTS c ON c.OWNER = o.OWNER AND c.TABLE_NAME = o.OBJECT_NAME
+            WHERE o.OWNER = ? AND o.OBJECT_TYPE = '%s' AND ( (o.OBJECT_TYPE = 'TABLE' AND o.OBJECT_NAME NOT LIKE 'MTAB$_%%') OR o.OBJECT_TYPE = 'VIEW')
+            ORDER BY o.OBJECT_NAME
+            """).formatted(tableType).stripIndent().trim();
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+            stmt.setString(1, schema);
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    addTableInfo(tablesByName, rs.getString(1), tableType, rs.getString(2));
+                }
+            }
+            return true;
+        } catch (Exception ignored) {
+            return false;
+        }
+    }
+
+    private void loadTableOrViewFromComments(String schema, String tableType, Map<String, TableInfo> tablesByName) {
+        String tableNameFilter = "TABLE".equals(tableType) ? " AND TABLE_NAME NOT LIKE 'MTAB$_%'" : "";
+        String sql = ("""
+            SELECT TABLE_NAME, COMMENTS
+            FROM ALL_TAB_COMMENTS
+            WHERE OWNER = ? AND TABLE_TYPE = '%s'%s
+            ORDER BY TABLE_NAME
+            """).formatted(tableType, tableNameFilter).stripIndent().trim();
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+            stmt.setString(1, schema);
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    addTableInfo(tablesByName, rs.getString(1), tableType, rs.getString(2));
+                }
+            }
+        } catch (Exception ignored) {
+            // Keep metadata browsing usable even when optional catalog views are restricted.
+        }
+    }
+
+    private void loadMaterializedViews(String schema, Map<String, TableInfo> tablesByName) {
+        loadMaterializedViewsFromAllObjects(schema, tablesByName);
+    }
+
+    private void loadMaterializedViewsFromAllObjects(String schema, Map<String, TableInfo> tablesByName) {
+        String sql = """
+            SELECT m.MVIEW_NAME AS TABLE_NAME, c.COMMENTS
+			FROM USER_MVIEWS m LEFT JOIN ALL_OBJECTS o ON m.SCHID = o.OBJECT_ID
+			LEFT JOIN ALL_TAB_COMMENTS c ON c.OWNER = o.OWNER AND c.TABLE_NAME = m.MVIEW_NAME
+			WHERE o.OWNER = ?
+			ORDER BY TABLE_NAME
+            """.stripIndent().trim();
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+            stmt.setString(1, schema);
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    addTableInfo(tablesByName, rs.getString(1), "MATERIALIZED_VIEW", rs.getString(2));
+                }
+            }
+        } catch (Exception ignored) {
+            // Older or restricted Dameng catalogs may not expose this object type.
+        }
+    }
+
+    private void loadMaterializedViewsFromUserMviews(String schema, Map<String, TableInfo> tablesByName) {
+        if (!schemaMatchesConnectedUser(schema)) {
+            return;
+        }
+        loadUserMviews("SELECT MVIEW_NAME FROM USER_MVIEWS", tablesByName);
+    }
+
+    private boolean loadUserMviews(String sql, Map<String, TableInfo> tablesByName) {
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql);
+             ResultSet rs = stmt.executeQuery()) {
+            while (rs.next()) {
+                addTableInfo(tablesByName, rs.getString(1), "MATERIALIZED_VIEW", null);
+            }
+            return true;
+        } catch (Exception ignored) {
+            return false;
+        }
+    }
+
+    private void removeMaterializedViewsFromRegularViews(String schema, Map<String, TableInfo> tablesByName) {
+        /*if (!schemaMatchesConnectedUser(schema)) {
+            return;
+        }*/
+        for (String name : listUserMviewNames()) {
+            tablesByName.remove(name);
+        }
+    }
+
+    private Set<String> listUserMviewNames() {
+        Set<String> names = new java.util.HashSet<>();
+        String sql = "SELECT MVIEW_NAME FROM USER_MVIEWS";
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql);
+             ResultSet rs = stmt.executeQuery()) {
+            while (rs.next()) {
+                String key = metadataNameKey(rs.getString(1));
+                if (!key.isEmpty()) {
+                    names.add(key);
+                }
+            }
+        } catch (Exception ignored) {
+            // Some Dameng versions or users do not expose USER_MVIEWS.
+        }
+        return names;
+    }
+
+    private boolean schemaMatchesConnectedUser(String schema) {
+        return connectedUsername != null
+            && schema != null
+            && !connectedUsername.isBlank()
+            && schema.equalsIgnoreCase(connectedUsername);
+    }
+
+    private static void addTableInfo(Map<String, TableInfo> tablesByName, String name, String tableType, String comment) {
+        String key = metadataNameKey(name);
+        if (!key.isEmpty()) {
+            tablesByName.put(key, new TableInfo(name, tableType, comment));
+        }
+    }
+
+    private static boolean objectTypesInclude(List<String> objectTypes, String expectedType) {
+        if (objectTypes == null || objectTypes.isEmpty()) {
+            return true;
+        }
+        for (String objectType : objectTypes) {
+            if (expectedType.equals(normalizeObjectType(objectType))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean isUnconstrained(MetadataListConstraints constraints) {
+        return !constraints.hasFilter() && !constraints.hasLimit() && !constraints.hasOffset() && !constraints.hasObjectTypes();
+    }
+
+    private static boolean includesSupportedObjectTypes(MetadataListConstraints constraints) {
+        return constraints.includesTableLikeTypes()
+            || constraints.objectTypeAllowed("PROCEDURE")
+            || constraints.objectTypeAllowed("FUNCTION");
+    }
+
+    private static void appendDamengObjectTypePredicate(
+        StringBuilder sql,
+        List<Object> args,
+        MetadataListConstraints constraints,
+        boolean tableOnly
+    ) {
+        List<String> objectTypes = tableOnly ? damengTableObjectTypes(constraints) : damengObjectTypes(constraints);
+        if (objectTypes.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND o.OBJECT_TYPE IN (").append(placeholders(objectTypes.size())).append(")");
+        args.addAll(objectTypes);
+    }
+
+    private static List<String> damengTableObjectTypes(MetadataListConstraints constraints) {
+        List<String> result = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            result.add("TABLE");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            result.add("VIEW");
+        }
+        if (constraints.tableTypeAllowed("MATERIALIZED_VIEW")) {
+            result.add("MATERIALIZED VIEW");
+        }
+        return result;
+    }
+
+    private static List<String> damengObjectTypes(MetadataListConstraints constraints) {
+        List<String> result = damengTableObjectTypes(constraints);
+        if (constraints.objectTypeAllowed("PROCEDURE")) {
+            result.add("PROCEDURE");
+        }
+        if (constraints.objectTypeAllowed("FUNCTION")) {
+            result.add("FUNCTION");
+        }
+        return result;
+    }
+
+    private static void appendNameFilter(StringBuilder sql, List<Object> args, String column, MetadataListConstraints constraints) {
+        if (!constraints.hasFilter()) {
+            return;
+        }
+        sql.append(" AND UPPER(").append(column).append(") LIKE ? ESCAPE '\\\\'");
+        args.add(constraints.fuzzyLikePattern().toUpperCase(Locale.ROOT));
+    }
+
+    private static void appendLimitOffset(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasLimit()) {
+            return;
+        }
+        sql.append(" LIMIT ?");
+        args.add(constraints.getLimit());
+        if (constraints.hasOffset()) {
+            sql.append(" OFFSET ?");
+            args.add(constraints.getOffset());
+        }
+    }
+
+    private static String placeholders(int count) {
+        return String.join(", ", java.util.Collections.nCopies(count, "?"));
+    }
+
+    private static void bind(PreparedStatement stmt, List<Object> args) throws Exception {
+        for (int index = 0; index < args.size(); index += 1) {
+            Object arg = args.get(index);
+            if (arg instanceof Integer) {
+                stmt.setInt(index + 1, (Integer) arg);
+            } else if (arg == null) {
+                stmt.setObject(index + 1, null);
+            } else {
+                stmt.setString(index + 1, String.valueOf(arg));
+            }
+        }
+    }
+
+    static final class MetadataQuery {
+        private final String sql;
+        private final List<Object> args;
+
+        MetadataQuery(String sql, List<Object> args) {
+            this.sql = sql;
+            this.args = args;
+        }
+
+        String sql() {
+            return sql;
+        }
+
+        List<Object> args() {
+            return args;
+        }
+    }
+
+    private static String normalizeObjectType(String value) {
+        String upper = value == null ? "" : value.trim().toUpperCase(Locale.ROOT).replace(' ', '_').replace('-', '_');
+        if (upper.contains("MATERIALIZED") && upper.contains("VIEW")) {
+            return "MATERIALIZED_VIEW";
+        }
+        if (upper.contains("VIEW")) {
+            return "VIEW";
+        }
+        if (upper.contains("TABLE")) {
+            return "TABLE";
+        }
+        return upper;
+    }
+
+    private static String metadataNameKey(String value) {
+        return value == null ? "" : value.trim().toUpperCase(Locale.ROOT);
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            for (TableInfo table : listTables(schema)) {
+                result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+            }
+            String sql = """
+                SELECT OBJECT_NAME, OBJECT_TYPE FROM ALL_OBJECTS
+                WHERE OWNER = ? AND OBJECT_TYPE IN ('PROCEDURE', 'FUNCTION')
+                ORDER BY CASE OBJECT_TYPE WHEN 'PROCEDURE' THEN 0 ELSE 1 END, OBJECT_NAME
+                """.stripIndent().trim();
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1), rs.getString(2), schema, null));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listObjects(schema);
+        }
+        return queryConstrainedObjects(schema, normalized);
+    }
+
+    private List<ObjectInfo> queryConstrainedObjects(String schema, MetadataListConstraints constraints) {
+        if (!includesSupportedObjectTypes(constraints)) {
+            return List.of();
+        }
+        try {
+            return unchecked(() -> {
+                MetadataQuery query = buildConstrainedObjectsQuery(schema, constraints);
+                List<ObjectInfo> result = new ArrayList<>();
+                try (PreparedStatement stmt = requireConnected().prepareStatement(query.sql())) {
+                    bind(stmt, query.args());
+                    try (ResultSet rs = stmt.executeQuery()) {
+                        while (rs.next()) {
+                            result.add(new ObjectInfo(
+                                rs.getString("OBJECT_NAME"),
+                                normalizeObjectType(rs.getString("OBJECT_TYPE")),
+                                schema,
+                                rs.getString("COMMENTS")
+                            ));
+                        }
+                    }
+                }
+                return constraints.withoutPaging().filterObjects(result);
+            });
+        } catch (RuntimeException e) {
+            // Keep restricted/older Dameng catalogs usable even if SQL pushdown
+            // is unavailable for a specific connection.
+            return constraints.filterObjects(listObjects(schema));
+        }
+    }
+
+    static MetadataQuery buildConstrainedObjectsQuery(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        List<Object> args = new ArrayList<>();
+        StringBuilder sql = new StringBuilder("""
+            SELECT o.OBJECT_NAME,
+                   CASE WHEN o.OBJECT_TYPE = 'MATERIALIZED VIEW' THEN 'MATERIALIZED_VIEW' ELSE o.OBJECT_TYPE END AS OBJECT_TYPE,
+                   c.COMMENTS
+            FROM ALL_OBJECTS o
+            LEFT JOIN ALL_TAB_COMMENTS c ON c.OWNER = o.OWNER AND c.TABLE_NAME = o.OBJECT_NAME
+            WHERE o.OWNER = ?
+            """.stripIndent().trim());
+        args.add(schema);
+        appendDamengObjectTypePredicate(sql, args, normalized, false);
+        sql.append(" AND (o.OBJECT_TYPE <> 'TABLE' OR o.OBJECT_NAME NOT LIKE 'MTAB$_%')");
+        appendNameFilter(sql, args, "o.OBJECT_NAME", normalized);
+        sql.append(" ORDER BY CASE o.OBJECT_TYPE")
+            .append(" WHEN 'TABLE' THEN 0")
+            .append(" WHEN 'VIEW' THEN 1")
+            .append(" WHEN 'MATERIALIZED VIEW' THEN 2")
+            .append(" WHEN 'PROCEDURE' THEN 3")
+            .append(" WHEN 'FUNCTION' THEN 4")
+            .append(" ELSE 9 END, o.OBJECT_NAME");
+        appendLimitOffset(sql, args, normalized);
+        return new MetadataQuery(sql.toString(), args);
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        return unchecked(() -> {
+            String dbmsType = switch (objectType.toUpperCase(Locale.ROOT)) {
+                case "VIEW" -> "VIEW";
+                case "MATERIALIZED_VIEW", "MATERIALIZED VIEW" -> "MATERIALIZED_VIEW";
+                case "PROCEDURE" -> "PROCEDURE";
+                case "FUNCTION" -> "FUNCTION";
+                default -> throw new IllegalArgumentException("Unsupported object type: " + objectType);
+            };
+            String source;
+            String sql = "SELECT DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, dbmsType);
+                stmt.setString(2, name);
+                stmt.setString(3, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    source = rs.next() ? coalesce(readTextColumn(rs, 1)) : "";
+                }
+            }
+            return new ObjectSource(name, objectType, schema, source);
+        });
+    }
+
+    @Override
+    public String getTableDdl(String schema, String table) {
+        return unchecked(() -> {
+            String sql = "SELECT DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, "TABLE");
+                stmt.setString(2, table);
+                stmt.setString(3, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    if (rs.next()) {
+                        String ddl = appendTableAndColumnComments(coalesce(readTextColumn(rs, 1)), schema, table);
+                        return appendIndependentIndexDdl(ddl, schema, table);
+                    }
+                }
+            }
+            throw new IllegalArgumentException("Table not found: " + schema + "." + table);
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            Set<String> pkColumns = new java.util.HashSet<>();
+            String pkSql = """
+                SELECT cols.COLUMN_NAME FROM ALL_CONS_COLUMNS cols
+                JOIN ALL_CONSTRAINTS cons ON cols.CONSTRAINT_NAME = cons.CONSTRAINT_NAME AND cols.OWNER = cons.OWNER
+                WHERE cons.CONSTRAINT_TYPE = 'P' AND cons.OWNER = ? AND cons.TABLE_NAME = ?
+                """.stripIndent().trim();
+            try (PreparedStatement stmt = requireConnected().prepareStatement(pkSql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        pkColumns.add(rs.getString(1));
+                    }
+                }
+            }
+
+            Set<String> identityColumns = identityColumns(schema, table);
+            List<ColumnInfo> result = new ArrayList<>();
+            // DATA_DEFAULT is a LONG column — it must be selected first and read first
+            // in JDBC, otherwise the data is truncated.
+            String colSql = """
+                SELECT c.DATA_DEFAULT,
+                    c.COLUMN_NAME,
+                    c.DATA_TYPE,
+                    c.NULLABLE,
+                    c.DATA_PRECISION,
+                    c.DATA_SCALE,
+                    c.DATA_LENGTH,
+                    c.CHAR_LENGTH,
+                    cc.COMMENTS
+                FROM ALL_TAB_COLUMNS c
+                LEFT JOIN ALL_COL_COMMENTS cc
+                    ON cc.OWNER = c.OWNER
+                    AND cc.TABLE_NAME = c.TABLE_NAME
+                    AND cc.COLUMN_NAME = c.COLUMN_NAME
+                WHERE c.OWNER = ? AND c.TABLE_NAME = ?
+                ORDER BY c.COLUMN_ID
+                """.stripIndent().trim();
+            try (PreparedStatement stmt = requireConnected().prepareStatement(colSql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        // DATA_DEFAULT is a LONG — must be read first, before all other columns.
+                        String dataDefault = readLongColumn(rs, "DATA_DEFAULT");
+                        String name = rs.getString("COLUMN_NAME");
+                        String baseType = rs.getString("DATA_TYPE");
+                        Integer numPrec = intObject(rs, "DATA_PRECISION");
+                        Integer numScale = intObject(rs, "DATA_SCALE");
+                        Integer dataLen = intObject(rs, "DATA_LENGTH");
+                        Integer charLen = intObject(rs, "CHAR_LENGTH");
+                        String dataType = formatDataType(baseType, numPrec, numScale, dataLen, charLen);
+
+                        result.add(new ColumnInfo(
+                            name,
+                            dataType,
+                            "Y".equals(rs.getString("NULLABLE")),
+                            dataDefault,
+                            pkColumns.contains(name),
+                            identityColumns.contains(name) ? "identity" : null,
+                            rs.getString("COMMENTS"),
+                            numPrec,
+                            numScale,
+                            charLen
+                        ));
+                    }
+                }
+            }
+            fillMissingColumnComments(schema, table, result);
+            return result;
+        });
+    }
+
+    private Set<String> identityColumns(String schema, String table) {
+        Set<String> result = new java.util.HashSet<>();
+        String sql = """
+            SELECT c.NAME
+            FROM SYS.SYSCOLUMNS c
+            JOIN SYS.SYSOBJECTS t ON c.ID = t.ID
+            JOIN SYS.SYSOBJECTS s ON t.SCHID = s.ID
+            WHERE s.NAME = ? AND t.NAME = ? AND (c.INFO2 & 0x01) = 0x01
+            """.stripIndent().trim();
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+            stmt.setString(1, schema);
+            stmt.setString(2, table);
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    String column = rs.getString(1);
+                    if (notBlank(column)) {
+                        result.add(column);
+                    }
+                }
+            }
+        } catch (Exception ignored) {
+            // Some Dameng versions or users do not expose SYS.SYSCOLUMNS.
+        }
+        return result;
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return unchecked(() -> {
+            List<IndexInfo> result = new ArrayList<>();
+            String sql = """
+                SELECT i.INDEX_NAME,
+                    LISTAGG(ic.COLUMN_NAME, ',') WITHIN GROUP (ORDER BY ic.COLUMN_POSITION) AS COLUMNS,
+                    i.UNIQUENESS,
+                    CASE WHEN c.CONSTRAINT_TYPE = 'P' THEN 1 ELSE 0 END AS IS_PK,
+                    i.INDEX_TYPE
+                FROM ALL_INDEXES i
+                JOIN ALL_IND_COLUMNS ic ON i.INDEX_NAME = ic.INDEX_NAME AND i.OWNER = ic.INDEX_OWNER AND i.TABLE_OWNER = ic.TABLE_OWNER
+                LEFT JOIN ALL_CONSTRAINTS c ON i.INDEX_NAME = c.INDEX_NAME AND i.TABLE_OWNER = c.OWNER
+                    AND c.CONSTRAINT_TYPE = 'P'
+                WHERE i.TABLE_OWNER = ? AND i.TABLE_NAME = ?
+                GROUP BY i.INDEX_NAME, i.UNIQUENESS, c.CONSTRAINT_TYPE, i.INDEX_TYPE
+                ORDER BY i.INDEX_NAME
+                """.stripIndent().trim();
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new IndexInfo(
+                            rs.getString(1),
+                            splitNonEmpty(coalesce(rs.getString(2)), ","),
+                            "UNIQUE".equals(rs.getString(3)),
+                            "1".equals(rs.getString(4)),
+                            null,
+                            rs.getString(5),
+                            null,
+                            null
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return unchecked(() -> {
+            List<ForeignKeyInfo> result = new ArrayList<>();
+            String sql = """
+                SELECT c.CONSTRAINT_NAME, cc.COLUMN_NAME, rc.TABLE_NAME, rcc.COLUMN_NAME
+                FROM ALL_CONSTRAINTS c
+                JOIN ALL_CONS_COLUMNS cc ON c.CONSTRAINT_NAME = cc.CONSTRAINT_NAME AND c.OWNER = cc.OWNER
+                JOIN ALL_CONSTRAINTS rc ON c.R_CONSTRAINT_NAME = rc.CONSTRAINT_NAME AND c.R_OWNER = rc.OWNER
+                JOIN ALL_CONS_COLUMNS rcc ON rc.CONSTRAINT_NAME = rcc.CONSTRAINT_NAME AND rc.OWNER = rcc.OWNER
+                WHERE c.CONSTRAINT_TYPE = 'R' AND c.OWNER = ? AND c.TABLE_NAME = ?
+                ORDER BY c.CONSTRAINT_NAME
+                """.stripIndent().trim();
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ForeignKeyInfo(
+                            rs.getString(1),
+                            rs.getString(2),
+                            rs.getString(3),
+                            rs.getString(4)
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return unchecked(() -> {
+            List<TriggerInfo> result = new ArrayList<>();
+            String sql = """
+                SELECT TRIGGER_NAME, TRIGGERING_EVENT, '' AS TRIGGER_TYPE
+                FROM ALL_TRIGGERS
+                WHERE OWNER = ? AND TABLE_NAME = ?
+                ORDER BY TRIGGER_NAME
+                """.stripIndent().trim();
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TriggerInfo(rs.getString(1), rs.getString(2), rs.getString(3)));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        return JdbcExecutor.INSTANCE.execute(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options.getMaxRows(),
+            options.getFetchSize(),
+            options.getTimeoutSecs(),
+            this::stringResultValue
+        );
+    }
+
+    @Override
+    public QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {
+        return JdbcExecutor.INSTANCE.executePage(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            this::stringResultValue
+        );
+    }
+
+    @Override
+    public QueryPageResult startTableRead(String sql, String schema, QueryPageOptions options) {
+        return JdbcExecutor.INSTANCE.startTableRead(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            this::stringResultValue
+        );
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "SET SCHEMA " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
+    }
+
+    @Override
+    public void disconnect() {
+        uncheckedVoid(() -> {
+            if (connection != null) {
+                connection.close();
+            }
+            connection = null;
+        });
+    }
+
+    private Object stringResultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value = switch (sqlType) {
+                case Types.BIGINT -> rs.getLong(index);
+                case Types.INTEGER, Types.SMALLINT, Types.TINYINT -> rs.getInt(index);
+                case Types.FLOAT, Types.REAL -> rs.getFloat(index);
+                case Types.DOUBLE -> rs.getDouble(index);
+                case Types.DECIMAL, Types.NUMERIC -> rs.getBigDecimal(index);
+                case Types.BOOLEAN, Types.BIT -> rs.getBoolean(index);
+                case Types.CHAR, Types.VARCHAR, Types.LONGVARCHAR,
+                    Types.NCHAR, Types.NVARCHAR, Types.LONGNVARCHAR,
+                    Types.CLOB, Types.NCLOB -> rs.getString(index);
+                case Types.BINARY, Types.VARBINARY, Types.LONGVARBINARY,
+                    Types.BLOB -> bytesToHex(rs.getBytes(index));
+                case Types.SQLXML -> sqlXmlToString(rs.getSQLXML(index));
+                default -> normalizeResultValue(rs.getObject(index));
+            };
+            return rs.wasNull() ? null : value;
+        });
+    }
+
+    private static Object normalizeResultValue(Object value) {
+        if (value == null) return null;
+        if (value instanceof Clob) {
+            Clob clob = (Clob) value;
+            return unchecked(() -> clob.getSubString(1, Math.toIntExact(clob.length())));
+        }
+        if (value instanceof Blob) {
+            Blob blob = (Blob) value;
+            return unchecked(() -> bytesToHex(blob.getBytes(1, Math.toIntExact(blob.length()))));
+        }
+        if (value instanceof SQLXML) {
+            SQLXML sqlxml = (SQLXML) value;
+            return unchecked(sqlxml::getString);
+        }
+        if (value instanceof byte[]) {
+            return bytesToHex((byte[]) value);
+        }
+        return value instanceof Number || value instanceof Boolean ? value : value.toString();
+    }
+
+    private static String sqlXmlToString(SQLXML value) {
+        return value == null ? null : unchecked(value::getString);
+    }
+
+    private static String readTextColumn(ResultSet rs, int columnIndex) throws Exception {
+        try (Reader reader = rs.getCharacterStream(columnIndex)) {
+            String value = readAll(reader);
+            if (value != null) {
+                return value;
+            }
+        } catch (Exception ignored) {
+        }
+        try {
+            Clob clob = rs.getClob(columnIndex);
+            if (clob != null) {
+                return clob.getSubString(1, Math.toIntExact(clob.length()));
+            }
+        } catch (Exception ignored) {
+        }
+        return rs.getString(columnIndex);
+    }
+
+    private static String bytesToHex(byte[] bytes) {
+        if (bytes == null) {
+            return null;
+        }
+        StringBuilder result = new StringBuilder(bytes.length * 2 + 2);
+        result.append("0x");
+        for (byte b : bytes) {
+            result.append(Character.forDigit((b >> 4) & 0xF, 16));
+            result.append(Character.forDigit(b & 0xF, 16));
+        }
+        return result.toString();
+    }
+
+    private static String buildUrl(ConnectParams params) {
+        String database = params.getDatabase() == null ? "" : params.getDatabase().trim();
+        String suffix = database.isEmpty() ? "" : "/" + database;
+        return "jdbc:dm://" + params.getHost() + ":" + params.getPort() + suffix;
+    }
+
+    private static String formatDataType(String base, Integer numPrec, Integer numScale, Integer dataLen, Integer charLen) {
+        return switch (base.toUpperCase(Locale.ROOT)) {
+            case "VARCHAR2", "NVARCHAR2", "VARCHAR", "CHAR", "NCHAR" -> {
+                Integer length = charLen != null ? charLen : dataLen;
+                yield length != null ? base + "(" + length + ")" : base;
+            }
+            case "NUMBER", "NUMERIC", "DECIMAL" -> {
+                if (numPrec != null && numScale != null && numScale > 0) {
+                    yield base + "(" + numPrec + "," + numScale + ")";
+                }
+                yield numPrec != null && numPrec > 0 ? base + "(" + numPrec + ")" : base;
+            }
+            case "RAW" -> dataLen != null ? "RAW(" + dataLen + ")" : "RAW";
+            default -> base;
+        };
+    }
+
+    private static Integer intObject(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value == null ? null : ((Number) value).intValue();
+    }
+
+    // DATA_DEFAULT is stored as a LONG column in Oracle/Dameng. JDBC requires LONG
+    // columns to be read before other columns. We also try getCharacterStream as a
+    // fallback because some drivers don't support getString on LONG columns.
+    private static String readLongColumn(ResultSet rs, String column) throws Exception {
+        try {
+            String value = rs.getString(column);
+            if (value != null) {
+                return value;
+            }
+        } catch (Exception ignored) {
+        }
+        try (Reader reader = rs.getCharacterStream(column)) {
+            return readAll(reader);
+        }
+    }
+
+    private static String readAll(Reader reader) throws Exception {
+        if (reader == null) {
+            return null;
+        }
+        StringBuilder sb = new StringBuilder();
+        char[] buf = new char[4096];
+        int n;
+        while ((n = reader.read(buf)) != -1) {
+            sb.append(buf, 0, n);
+        }
+        return sb.toString();
+    }
+
+    private static List<String> splitNonEmpty(String value, String delimiter) {
+        List<String> result = new ArrayList<>();
+        Arrays.stream(value.split(delimiter))
+            .filter(part -> !part.isEmpty())
+            .forEach(result::add);
+        return result;
+    }
+
+    private static String coalesce(String value) {
+        return value == null ? "" : value;
+    }
+
+    private void fillMissingColumnComments(String schema, String table, List<ColumnInfo> columns) {
+        if (columns.stream().noneMatch(column -> !notBlank(column.getComment()))) {
+            return;
+        }
+        Map<String, String> comments = new HashMap<>();
+        queryColumnComments(
+            comments,
+            "SELECT COLUMN_NAME, COMMENTS FROM USER_COL_COMMENTS WHERE TABLE_NAME = ?",
+            table
+        );
+        queryColumnComments(
+            comments,
+            "SELECT COLNAME, COMMENT$ FROM SYS.SYSCOLUMNCOMMENTS WHERE SCHNAME = ? AND TVNAME = ?",
+            schema,
+            table
+        );
+        queryColumnComments(
+            comments,
+            "SELECT COLUMN_NAME, COMMENTS FROM ALL_COL_COMMENTS WHERE UPPER(OWNER) = UPPER(?) AND UPPER(TABLE_NAME) = UPPER(?)",
+            schema,
+            table
+        );
+        for (ColumnInfo column : columns) {
+            if (notBlank(column.getComment())) {
+                continue;
+            }
+            String comment = comments.get(column.getName().toUpperCase(Locale.ROOT));
+            if (notBlank(comment)) {
+                column.setComment(comment);
+            }
+        }
+    }
+
+    private void queryColumnComments(Map<String, String> comments, String sql, String... params) {
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+            for (int i = 0; i < params.length; i++) {
+                stmt.setString(i + 1, params[i]);
+            }
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    String column = rs.getString(1);
+                    String comment = rs.getString(2);
+                    if (notBlank(column) && notBlank(comment)) {
+                        comments.putIfAbsent(column.toUpperCase(Locale.ROOT), comment);
+                    }
+                }
+            }
+        } catch (Exception ignored) {
+            // Some Dameng versions or users do not expose every comment view.
+        }
+    }
+
+    private String appendTableAndColumnComments(String ddl, String schema, String table) throws Exception {
+        StringBuilder result = new StringBuilder(ddl == null ? "" : ddl.trim());
+        String tableRef = qualifiedName(schema, table);
+        String tableComment = tableComment(schema, table);
+        if (notBlank(tableComment) && !containsCommentOnTable(result.toString(), schema, table)) {
+            appendCommentStatement(result, "COMMENT ON TABLE " + tableRef + " IS '" + sqlStringBody(tableComment) + "';");
+        }
+        for (ColumnInfo column : getColumns(schema, table)) {
+            if (!notBlank(column.getComment()) || containsCommentOnColumn(result.toString(), schema, table, column.getName())) {
+                continue;
+            }
+            appendCommentStatement(result, "COMMENT ON COLUMN " + tableRef + "." + JdbcIdentifiers.INSTANCE.doubleQuote(column.getName()) + " IS '" + sqlStringBody(column.getComment()) + "';");
+        }
+        return result.toString();
+    }
+
+    private String appendIndependentIndexDdl(String ddl, String schema, String table) throws Exception {
+        StringBuilder result = new StringBuilder(ddl == null ? "" : ddl.trim());
+        for (IndexInfo index : independentIndexes(schema, table)) {
+            String indexName = index.getName();
+            if (isInternalIndexMetadata(index) || index.getColumns().isEmpty()) {
+                continue;
+            }
+            if (containsCreateIndex(result.toString(), schema, indexName)) {
+                continue;
+            }
+            appendDdlStatement(result, indexDdl(schema, table, index));
+        }
+        return result.toString();
+    }
+
+    private List<IndexInfo> independentIndexes(String schema, String table) throws Exception {
+        List<IndexInfo> result = new ArrayList<>();
+        // Primary-key and unique-constraint backing indexes are already represented in table DDL.
+        String sql = """
+            SELECT i.INDEX_NAME,
+                LISTAGG(ic.COLUMN_NAME, ',') WITHIN GROUP (ORDER BY ic.COLUMN_POSITION) AS COLUMNS,
+                i.UNIQUENESS,
+                i.INDEX_TYPE
+            FROM ALL_INDEXES i
+            JOIN ALL_IND_COLUMNS ic ON i.INDEX_NAME = ic.INDEX_NAME AND i.OWNER = ic.INDEX_OWNER AND i.TABLE_OWNER = ic.TABLE_OWNER
+            WHERE i.TABLE_OWNER = ? AND i.TABLE_NAME = ?
+                AND NOT EXISTS (
+                    SELECT 1
+                    FROM ALL_CONSTRAINTS c
+                    WHERE c.OWNER = i.TABLE_OWNER
+                        AND c.TABLE_NAME = i.TABLE_NAME
+                        AND c.INDEX_NAME = i.INDEX_NAME
+                        AND c.CONSTRAINT_TYPE IN ('P', 'U')
+                )
+            GROUP BY i.INDEX_NAME, i.UNIQUENESS, i.INDEX_TYPE
+            ORDER BY i.INDEX_NAME
+            """.stripIndent().trim();
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+            stmt.setString(1, schema);
+            stmt.setString(2, table);
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    String indexName = rs.getString(1);
+                    if (notBlank(indexName)) {
+                        result.add(new IndexInfo(
+                            indexName,
+                            splitNonEmpty(coalesce(rs.getString(2)), ","),
+                            "UNIQUE".equals(rs.getString(3)),
+                            false,
+                            null,
+                            rs.getString(4),
+                            null,
+                            null
+                        ));
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    private static String indexDdl(String schema, String table, IndexInfo index) {
+        StringBuilder ddl = new StringBuilder("CREATE ");
+        if (index.getIs_unique()) {
+            ddl.append("UNIQUE ");
+        }
+        ddl.append("INDEX ")
+            .append(qualifiedName(schema, index.getName()))
+            .append(" ON ")
+            .append(qualifiedName(schema, table))
+            .append(" (");
+        for (int i = 0; i < index.getColumns().size(); i++) {
+            if (i > 0) {
+                ddl.append(", ");
+            }
+            ddl.append(JdbcIdentifiers.INSTANCE.doubleQuote(index.getColumns().get(i)));
+        }
+        ddl.append(");");
+        return ddl.toString();
+    }
+
+    private static boolean isInternalIndexMetadata(IndexInfo index) {
+        String indexType = coalesce(index.getIndex_type()).toUpperCase(Locale.ROOT);
+        return indexType.contains("INNER") || indexType.contains("INTERNAL");
+    }
+
+    private String tableComment(String schema, String table) throws Exception {
+        String sql = """
+            SELECT COMMENTS
+            FROM ALL_TAB_COMMENTS
+            WHERE OWNER = ? AND TABLE_NAME = ?
+            """.stripIndent().trim();
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+            stmt.setString(1, schema);
+            stmt.setString(2, table);
+            try (ResultSet rs = stmt.executeQuery()) {
+                return rs.next() ? rs.getString(1) : null;
+            }
+        }
+    }
+
+    private static void appendCommentStatement(StringBuilder ddl, String statement) {
+        appendDdlStatement(ddl, statement);
+    }
+
+    private static void appendDdlStatement(StringBuilder ddl, String statement) {
+        if (!ddl.isEmpty()) {
+            if (ddl.charAt(ddl.length() - 1) != '\n') {
+                ddl.append("\n");
+            }
+            ddl.append("\n");
+        }
+        ddl.append(statement);
+    }
+
+    private static String ensureStatementTerminator(String statement) {
+        String trimmed = coalesce(statement).trim();
+        if (trimmed.isEmpty() || trimmed.endsWith(";")) {
+            return trimmed;
+        }
+        return trimmed + ";";
+    }
+
+    private static boolean containsCommentOnTable(String ddl, String schema, String table) {
+        return normalizedDdl(ddl).contains("COMMENT ON TABLE " + normalizedQualifiedName(schema, table));
+    }
+
+    private static boolean containsCommentOnColumn(String ddl, String schema, String table, String column) {
+        return normalizedDdl(ddl).contains("COMMENT ON COLUMN " + normalizedQualifiedName(schema, table) + "." + normalizedIdentifier(column));
+    }
+
+    private static boolean containsCreateIndex(String ddl, String schema, String indexName) {
+        String normalized = normalizedDdl(ddl);
+        return normalized.contains(" INDEX " + normalizedQualifiedName(schema, indexName) + " ")
+            || normalized.contains(" INDEX " + normalizedIdentifier(indexName) + " ");
+    }
+
+    private static String qualifiedName(String schema, String name) {
+        if (!notBlank(schema)) {
+            return JdbcIdentifiers.INSTANCE.doubleQuote(name);
+        }
+        return JdbcIdentifiers.INSTANCE.doubleQuote(schema) + "." + JdbcIdentifiers.INSTANCE.doubleQuote(name);
+    }
+
+    private static String normalizedQualifiedName(String schema, String name) {
+        if (!notBlank(schema)) {
+            return normalizedIdentifier(name);
+        }
+        return normalizedIdentifier(schema) + "." + normalizedIdentifier(name);
+    }
+
+    private static String normalizedIdentifier(String value) {
+        return JdbcIdentifiers.INSTANCE.doubleQuote(value).toUpperCase(Locale.ROOT);
+    }
+
+    private static String normalizedDdl(String ddl) {
+        return coalesce(ddl).toUpperCase(Locale.ROOT).replaceAll("\\s+", " ");
+    }
+
+    private static boolean notBlank(String value) {
+        return value != null && !value.trim().isEmpty();
+    }
+
+    private static String sqlStringBody(String value) {
+        return value.replace("'", "''");
+    }
+
+    @Override
+    public String getExplainInfo(String sql, String database, String schema, int timeoutSecs, String mode) {
+        return unchecked(() -> {
+            Connection conn = requireConnected();
+            boolean autotrace = "autotrace".equalsIgnoreCase(mode);
+            String planText = null;
+
+            if (autotrace) {
+                boolean monitorEnabled = false;
+                try (Statement s = conn.createStatement()) {
+                    s.execute("SF_SET_SESSION_PARA_VALUE('MONITOR_SQL_EXEC', 1)");
+                    monitorEnabled = true;
+                } catch (Exception ignored) {}
+
+                try (Statement stmt = conn.createStatement()) {
+                    if (timeoutSecs >= 0) {
+                        try { stmt.setQueryTimeout(timeoutSecs); } catch (Exception ignored) {}
+                    }
+                    boolean hasResultSet = stmt.execute(sql);
+                    if (hasResultSet) {
+                        try (ResultSet rs = stmt.getResultSet()) {
+                            while (rs.next()) { /* consume all rows */ }
+                        }
+                    }
+                    try {
+                        Class<?> dmConnClass = Class.forName("dm.jdbc.driver.DmdbConnection");
+                        if (dmConnClass.isInstance(conn)) {
+                            Method m = dmConnClass.getMethod("getExplainInfo", Statement.class);
+                            planText = (String) m.invoke(dmConnClass.cast(conn), stmt);
+                        }
+                    } catch (Exception ignored) {}
+                } finally {
+                    if (monitorEnabled) {
+                        try (Statement s = conn.createStatement()) {
+                            s.execute("SF_SET_SESSION_PARA_VALUE('MONITOR_SQL_EXEC', 0)");
+                        } catch (Exception ignored) {}
+                    }
+                }
+            } else {
+                try {
+                    Class<?> dmConnClass = Class.forName("dm.jdbc.driver.DmdbConnection");
+                    if (dmConnClass.isInstance(conn)) {
+                        Method m = dmConnClass.getMethod("getExplainInfo", String.class);
+                        planText = (String) m.invoke(dmConnClass.cast(conn), sql);
+                    }
+                } catch (Exception ignored) {}
+            }
+
+            if (planText == null || planText.trim().isEmpty()) {
+                try (Statement explainStmt = conn.createStatement();
+                     ResultSet rs = explainStmt.executeQuery("EXPLAIN " + sql)) {
+                    StringBuilder sb = new StringBuilder();
+                    while (rs.next()) {
+                        sb.append(rs.getString(1)).append("\n");
+                    }
+                    planText = sb.toString().trim();
+                } catch (Exception ignored) {}
+            }
+            return planText != null ? planText : "";
+        });
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new DamengAgent()).run();
+    }
+}
diff --git a/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentMetadataTest.java b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentMetadataTest.java
new file mode 100644
index 0000000..2358890
--- /dev/null
+++ b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentMetadataTest.java
@@ -0,0 +1,596 @@
+package com.dbx.agent.dameng;
+
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.test.JdbcMetadataSqlFake;
+import com.dbx.agent.test.TestSupport;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.io.StringReader;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class DamengAgentMetadataTest {
+    @Test
+    void usesColumnCommentsMetadataQuery() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.getColumns("APP", "USERS");
+
+        String columnsSql = JdbcMetadataSqlFake.statements.stream()
+            .filter(sql -> sql.contains("ALL_TAB_COLUMNS"))
+            .findFirst()
+            .orElseThrow();
+        Assertions.assertTrue(columnsSql.contains("LEFT JOIN ALL_COL_COMMENTS"), columnsSql);
+    }
+
+    @Test
+    void usesTableCommentsMetadataQuery() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listTables("APP");
+
+        String tablesSql = JdbcMetadataSqlFake.statements.stream()
+            .filter(sql -> sql.contains("ALL_TAB_COMMENTS"))
+            .findFirst()
+            .orElseThrow();
+        String allTablesSql = String.join("\n", JdbcMetadataSqlFake.statements);
+        Assertions.assertTrue(tablesSql.contains("COMMENTS"), tablesSql);
+        Assertions.assertTrue(allTablesSql.contains("ALL_OBJECTS"), allTablesSql);
+        Assertions.assertTrue(allTablesSql.contains("USER_MVIEWS"), allTablesSql);
+        Assertions.assertFalse(allTablesSql.contains("ALL_MVIEWS"), allTablesSql);
+        Assertions.assertFalse(tablesSql.contains("ALL_TABLES"), tablesSql);
+        Assertions.assertFalse(tablesSql.contains("ALL_VIEWS"), tablesSql);
+    }
+
+    @Test
+    void mapsTableCommentFromMetadata() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(agent, metadataConnection());
+
+        List<TableInfo> tables = agent.listTables("APP");
+
+        Assertions.assertEquals(1, tables.size());
+        Assertions.assertEquals("USERS", tables.get(0).getName());
+        Assertions.assertEquals("用户示例表", tables.get(0).getComment());
+    }
+
+    @Test
+    void mapsTableCommentToObjectMetadata() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(agent, metadataConnection());
+
+        List<ObjectInfo> objects = agent.listObjects("APP");
+
+        Assertions.assertEquals(1, objects.size());
+        Assertions.assertEquals("USERS", objects.get(0).getName());
+        Assertions.assertEquals("用户示例表", objects.get(0).getComment());
+    }
+
+    @Test
+    void listSchemasIncludesSchemaObjectsWithoutChildren() {
+        DamengAgent agent = new DamengAgent();
+        List<String> sqls = new ArrayList<>();
+        TestSupport.setPrivateConnection(agent, metadataConnection("id comment", null, false, List.of(), sqls, ""));
+
+        List<String> schemas = agent.listSchemas();
+
+        Assertions.assertEquals(List.of("APP", "EMPTY_SCHEMA"), schemas);
+        Assertions.assertTrue(sqls.stream().anyMatch(sql -> sql.contains("SYS.SYSOBJECTS") && sql.contains("TYPE$ = 'SCH'")), String.join("\n", sqls));
+        Assertions.assertTrue(sqls.stream().noneMatch(sql -> sql.contains("ALL_USERS")), String.join("\n", sqls));
+        Assertions.assertTrue(sqls.stream().noneMatch(sql -> sql.contains("ALL_OBJECTS")), String.join("\n", sqls));
+    }
+
+    @Test
+    void mapsMaterializedViewsFromMetadata() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(agent, metadataConnection("id comment", null, true));
+
+        List<TableInfo> tables = agent.listTables("APP");
+        List<ObjectInfo> objects = agent.listObjects("APP");
+
+        Assertions.assertTrue(tables.stream().anyMatch(table ->
+            "USER_SUMMARY_MV".equals(table.getName()) && "MATERIALIZED_VIEW".equals(table.getTable_type())
+        ));
+        Assertions.assertFalse(tables.stream().anyMatch(table ->
+            "USER_SUMMARY_MV".equals(table.getName()) && "VIEW".equals(table.getTable_type())
+        ));
+        Assertions.assertTrue(objects.stream().anyMatch(object ->
+            "USER_SUMMARY_MV".equals(object.getName()) && "MATERIALIZED_VIEW".equals(object.getObject_type())
+        ));
+    }
+
+    @Test
+    void filtersTableListingByRequestedObjectTypes() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(agent, metadataConnection("id comment", null, true));
+        setConnectedUsername(agent, "APP");
+
+        List<TableInfo> views = agent.listTables("APP", List.of("VIEW"));
+        List<TableInfo> materializedViews = agent.listTables("APP", List.of("MATERIALIZED_VIEW"));
+
+        Assertions.assertTrue(views.stream().noneMatch(table -> "MATERIALIZED_VIEW".equals(table.getTable_type())));
+        Assertions.assertTrue(views.stream().noneMatch(table -> "USER_SUMMARY_MV".equals(table.getName())));
+        Assertions.assertEquals(List.of("USER_SUMMARY_MV"), materializedViews.stream().map(TableInfo::getName).toList());
+    }
+
+    @Test
+    void readsMaterializedViewSourceWithDbmsMetadataType() {
+        DamengAgent agent = new DamengAgent();
+        List<String> params = new ArrayList<>();
+        TestSupport.setPrivateConnection(
+            agent,
+            objectSourceConnection(params, "CREATE MATERIALIZED VIEW \"APP\".\"USER_SUMMARY_MV\" AS SELECT 1 AS ID FROM DUAL")
+        );
+
+        ObjectSource source = agent.getObjectSource("APP", "USER_SUMMARY_MV", "MATERIALIZED_VIEW");
+
+        Assertions.assertEquals(List.of("MATERIALIZED_VIEW", "USER_SUMMARY_MV", "APP"), params);
+        Assertions.assertEquals("MATERIALIZED_VIEW", source.getObject_type());
+        Assertions.assertTrue(source.getSource().contains("CREATE MATERIALIZED VIEW"), source.getSource());
+    }
+
+    @Test
+    void triggerMetadataDoesNotRequireOracleTriggerTypeColumn() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listTriggers("APP", "USERS");
+
+        String triggersSql = JdbcMetadataSqlFake.statements.stream()
+            .filter(sql -> sql.contains("ALL_TRIGGERS"))
+            .findFirst()
+            .orElseThrow();
+        Assertions.assertFalse(triggersSql.contains("TRIGGERING_EVENT, TRIGGER_TYPE"), triggersSql);
+        Assertions.assertTrue(triggersSql.contains("'' AS TRIGGER_TYPE"), triggersSql);
+    }
+
+    @Test
+    void mapsColumnCommentFromMetadata() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(agent, metadataConnection());
+
+        List<ColumnInfo> columns = agent.getColumns("APP", "USERS");
+
+        Assertions.assertEquals(1, columns.size());
+        Assertions.assertEquals("id comment", columns.get(0).getComment());
+    }
+
+    @Test
+    void mapsColumnCommentFromFallbackMetadataViews() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(agent, metadataConnection(null, "fallback id comment"));
+
+        List<ColumnInfo> columns = agent.getColumns("APP", "USERS");
+
+        Assertions.assertEquals(1, columns.size());
+        Assertions.assertEquals("fallback id comment", columns.get(0).getComment());
+    }
+
+    @Test
+    void mapsIdentityColumnExtraFromSysColumns() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(agent, metadataConnection());
+
+        List<ColumnInfo> columns = agent.getColumns("APP", "USERS");
+
+        Assertions.assertEquals(1, columns.size());
+        Assertions.assertEquals("identity", columns.get(0).getExtra());
+    }
+
+    @Test
+    void appendsTableAndColumnCommentsToTableDdl() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(agent, metadataConnection());
+
+        String ddl = agent.getTableDdl("APP", "USERS");
+
+        Assertions.assertTrue(ddl.contains("CREATE TABLE \"APP\".\"USERS\""), ddl);
+        Assertions.assertTrue(ddl.contains("COMMENT ON TABLE \"APP\".\"USERS\" IS '用户示例表';"), ddl);
+        Assertions.assertTrue(ddl.contains("COMMENT ON COLUMN \"APP\".\"USERS\".\"ID\" IS 'id comment';"), ddl);
+    }
+
+    @Test
+    void readsFullTableDdlFromCharacterStreamWhenGetStringIsTruncated() {
+        DamengAgent agent = new DamengAgent();
+        String fullDdl = "CREATE TABLE \"APP\".\"USERS\" (\n  \"ID\" NUMBER,\n  \"PAYLOAD\" VARCHAR2(2000)\n);\n-- "
+            + "x".repeat(5000)
+            + "\n-- DBX_FULL_DDL_END";
+        TestSupport.setPrivateConnection(agent, metadataConnection(
+            "id comment",
+            null,
+            false,
+            List.of(),
+            null,
+            fullDdl
+        ));
+
+        String ddl = agent.getTableDdl("APP", "USERS");
+
+        Assertions.assertTrue(ddl.contains("DBX_FULL_DDL_END"), ddl);
+    }
+
+    @Test
+    void appendsIndependentIndexesToTableDdl() {
+        DamengAgent agent = new DamengAgent();
+        List<String> sqls = new ArrayList<>();
+        TestSupport.setPrivateConnection(agent, metadataConnectionWithIndexes(sqls));
+
+        String ddl = agent.getTableDdl("APP", "USERS");
+
+        Assertions.assertTrue(
+            ddl.contains("CREATE INDEX \"APP\".\"IDX_USERS_NAME\" ON \"APP\".\"USERS\" (\"NAME\");"),
+            ddl
+        );
+        Assertions.assertTrue(
+            ddl.contains("CREATE UNIQUE INDEX \"APP\".\"UX_USERS_EMAIL\" ON \"APP\".\"USERS\" (\"EMAIL\");"),
+            ddl
+        );
+        Assertions.assertFalse(ddl.contains("PK_USERS"), ddl);
+        String indexSql = sqls.stream().filter(sql -> sql.contains("ALL_INDEXES")).findFirst().orElseThrow();
+        Assertions.assertTrue(indexSql.contains("CONSTRAINT_TYPE IN ('P', 'U')"), indexSql);
+        long dbmsMetadataCalls = sqls.stream().filter(sql -> sql.contains("DBMS_METADATA.GET_DDL")).count();
+        Assertions.assertEquals(1, dbmsMetadataCalls);
+    }
+
+    @Test
+    void skipsDamengInternalIndexesWhenAppendingTableDdl() {
+        DamengAgent agent = new DamengAgent();
+        List<String> sqls = new ArrayList<>();
+        TestSupport.setPrivateConnection(agent, metadataConnection(
+            "id comment",
+            null,
+            false,
+            List.of(
+                indexRow("IDX_USERS_NAME", "NAME", "NONUNIQUE", "NORMAL"),
+                indexRow("SYS_INTERNAL_DDL", "ID", "NONUNIQUE", "INNER CLUSTER INDEX")
+            ),
+            sqls
+        ));
+
+        String ddl = agent.getTableDdl("APP", "USERS");
+
+        Assertions.assertTrue(
+            ddl.contains("CREATE INDEX \"APP\".\"IDX_USERS_NAME\" ON \"APP\".\"USERS\" (\"NAME\");"),
+            ddl
+        );
+        Assertions.assertFalse(ddl.contains("SYS_INTERNAL_DDL"), ddl);
+        Assertions.assertFalse(ddl.contains("INNER CLUSTER INDEX"), ddl);
+        long dbmsMetadataCalls = sqls.stream().filter(sql -> sql.contains("DBMS_METADATA.GET_DDL")).count();
+        Assertions.assertEquals(1, dbmsMetadataCalls);
+    }
+
+    private static Connection metadataConnection() {
+        return metadataConnection("id comment", null);
+    }
+
+    private static Connection metadataConnection(String allColumnComment, String fallbackColumnComment) {
+        return metadataConnection(allColumnComment, fallbackColumnComment, false);
+    }
+
+    private static Connection metadataConnection(String allColumnComment, String fallbackColumnComment, boolean includeMaterializedView) {
+        return metadataConnection(allColumnComment, fallbackColumnComment, includeMaterializedView, List.of(), null);
+    }
+
+    private static Connection metadataConnectionWithIndexes(List<String> sqls) {
+        return metadataConnection(
+            "id comment",
+            null,
+            false,
+            List.of(
+                indexRow("IDX_USERS_NAME", "NAME", "NONUNIQUE", "NORMAL"),
+                indexRow("UX_USERS_EMAIL", "EMAIL", "UNIQUE", "NORMAL")
+            ),
+            sqls
+        );
+    }
+
+    private static Connection metadataConnection(
+        String allColumnComment,
+        String fallbackColumnComment,
+        boolean includeMaterializedView,
+        List<List<Object>> independentIndexes,
+        List<String> sqls
+    ) {
+        return metadataConnection(allColumnComment, fallbackColumnComment, includeMaterializedView, independentIndexes, sqls, "CREATE TABLE \"APP\".\"USERS\" (\n  \"ID\" NUMBER\n);");
+    }
+
+    private static Connection metadataConnection(
+        String allColumnComment,
+        String fallbackColumnComment,
+        boolean includeMaterializedView,
+        List<List<Object>> independentIndexes,
+        List<String> sqls,
+        String dbmsMetadataDdl
+    ) {
+        return proxy(Connection.class, (method, args) -> {
+            String name = method.getName();
+            if ("prepareStatement".equals(name)) {
+                String sql = (String) args[0];
+                if (sqls != null) {
+                    sqls.add(sql);
+                }
+                if (sql.contains("DBMS_METADATA.GET_DDL")) {
+                    return dbmsMetadataStatement(dbmsMetadataDdl);
+                }
+                if (sql.contains("SYS.SYSOBJECTS") && sql.contains("TYPE$ = 'SCH'")) {
+                    return metadataStatement(List.of(List.of("APP"), List.of("EMPTY_SCHEMA")));
+                }
+                if (sql.contains("ALL_CONS_COLUMNS")) {
+                    return metadataStatement(List.of(List.of("ID")));
+                }
+                if (sql.contains("SYS.SYSCOLUMNS")) {
+                    return metadataStatement(List.of(List.of("ID")));
+                }
+                if (sql.startsWith("SELECT COMMENTS")) {
+                    return metadataStatement(List.of(List.of("用户示例表")));
+                }
+                if (sql.contains("USER_COL_COMMENTS")) {
+                    return metadataStatement(fallbackColumnComment == null ? List.of() : List.of(List.of("ID", fallbackColumnComment)));
+                }
+                if (sql.contains("SYSCOLUMNCOMMENTS")) {
+                    return metadataStatement(List.of());
+                }
+                if (sql.contains("ALL_OBJECTS") && sql.contains("OBJECT_TYPE = 'TABLE'")) {
+                    return metadataStatement(List.of(List.of("USERS", "用户示例表")));
+                }
+                if (sql.contains("ALL_OBJECTS") && sql.contains("OBJECT_TYPE = 'VIEW'")) {
+                    return metadataStatement(
+                        includeMaterializedView
+                            ? List.of(Arrays.asList("USER_SUMMARY_MV", "mv comment"))
+                            : List.of()
+                    );
+                }
+                if (sql.contains("USER_MVIEWS") && sql.contains("ALL_OBJECTS")) {
+                    return metadataStatement(
+                        includeMaterializedView ? List.of(Arrays.asList("USER_SUMMARY_MV", "mv comment")) : List.of()
+                    );
+                }
+                if (sql.contains("ALL_OBJECTS")) {
+                    return metadataStatement(List.of());
+                }
+                if (sql.contains("ALL_INDEXES")) {
+                    return metadataStatement(independentIndexes);
+                }
+                if (sql.contains("ALL_TAB_COMMENTS")) {
+                    List<List<Object>> rows = new ArrayList<>();
+                    rows.add(List.of("USERS", "TABLE", "用户示例表"));
+                    if (includeMaterializedView) {
+                        rows.add(Arrays.asList("USER_SUMMARY_MV", "VIEW", "mv comment"));
+                    }
+                    return metadataStatement(rows);
+                }
+                if (sql.contains("USER_MVIEWS")) {
+                    return metadataStatement(
+                        includeMaterializedView
+                            ? List.of(List.of("USER_SUMMARY_MV"))
+                            : List.of()
+                    );
+                }
+                if (sql.contains("ALL_COL_COMMENTS") && !sql.contains("ALL_TAB_COLUMNS")) {
+                    return metadataStatement(List.of());
+                }
+                if (sql.contains("ALL_TAB_COLUMNS")) {
+                    return metadataStatement(List.of(Arrays.asList(
+                        "ID",
+                        "NUMBER",
+                        "N",
+                        Integer.valueOf(10),
+                        Integer.valueOf(0),
+                        Integer.valueOf(22),
+                        Integer.valueOf(10),
+                        allColumnComment
+                    )));
+                }
+            }
+            if ("close".equals(name)) {
+                return null;
+            }
+            if ("isClosed".equals(name)) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static List<Object> indexRow(String name, String columns, String uniqueness, String indexType) {
+        return List.of(name, columns, uniqueness, indexType);
+    }
+
+    private static PreparedStatement dbmsMetadataStatement(String ddl) {
+        List<String> params = new ArrayList<>();
+        return proxy(PreparedStatement.class, (method, args) -> {
+            String name = method.getName();
+            if ("executeQuery".equals(name)) {
+                String objectType = params.isEmpty() ? "" : params.get(0);
+                if ("INDEX".equals(objectType)) {
+                    throw new AssertionError("Dameng table DDL should generate index DDL from metadata");
+                }
+                return metadataResultSet(List.of(List.of(new LongText(ddl, ddl.substring(0, Math.min(ddl.length(), 64))))));
+            }
+            if ("setString".equals(name)) {
+                int index = ((Integer) args[0]) - 1;
+                while (params.size() <= index) {
+                    params.add("");
+                }
+                params.set(index, String.valueOf(args[1]));
+                return null;
+            }
+            if ("close".equals(name)) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static void setConnectedUsername(DamengAgent agent, String username) {
+        try {
+            Field field = DamengAgent.class.getDeclaredField("connectedUsername");
+            field.setAccessible(true);
+            field.set(agent, username);
+        } catch (ReflectiveOperationException e) {
+            throw new IllegalStateException("Unable to set connected username", e);
+        }
+    }
+
+    private static Connection objectSourceConnection(List<String> params, String source) {
+        return proxy(Connection.class, (method, args) -> {
+            String name = method.getName();
+            if ("prepareStatement".equals(name)) {
+                return metadataStatement(List.of(List.of(source)), params);
+            }
+            if ("close".equals(name)) {
+                return null;
+            }
+            if ("isClosed".equals(name)) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static PreparedStatement metadataStatement(List<List<Object>> rows) {
+        return metadataStatement(rows, null);
+    }
+
+    private static PreparedStatement metadataStatement(List<List<Object>> rows, List<String> params) {
+        return proxy(PreparedStatement.class, (method, args) -> {
+            String name = method.getName();
+            if ("executeQuery".equals(name)) {
+                return metadataResultSet(rows);
+            }
+            if ("setString".equals(name)) {
+                if (params != null) {
+                    params.add(String.valueOf(args[1]));
+                }
+                return null;
+            }
+            if ("close".equals(name)) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSet metadataResultSet(List<List<Object>> rows) {
+        int[] index = {-1};
+        return proxy(ResultSet.class, (method, args) -> {
+            String name = method.getName();
+            if ("next".equals(name)) {
+                index[0] += 1;
+                return index[0] < rows.size();
+            }
+            if ("getString".equals(name)) {
+                if (args[0] instanceof Integer columnIndex) {
+                    Object value = rows.get(index[0]).get(columnIndex - 1);
+                    if (value instanceof LongText longText) {
+                        return longText.truncated;
+                    }
+                    return value == null ? null : value.toString();
+                }
+                return switch (((String) args[0]).toUpperCase()) {
+                    case "COLUMN_NAME" -> string(rows, index[0], 0);
+                    case "DATA_TYPE" -> string(rows, index[0], 1);
+                    case "NULLABLE" -> string(rows, index[0], 2);
+                    case "DATA_DEFAULT" -> null;
+                    case "COMMENTS", "COMMENT$" -> string(rows, index[0], rows.get(index[0]).size() - 1);
+                    case "COLNAME" -> string(rows, index[0], 0);
+                    default -> null;
+                };
+            }
+            if ("getCharacterStream".equals(name) && args[0] instanceof Integer columnIndex) {
+                Object value = rows.get(index[0]).get(columnIndex - 1);
+                if (value instanceof LongText longText) {
+                    return new StringReader(longText.full);
+                }
+            }
+            if ("getObject".equals(name)) {
+                return switch (((String) args[0]).toUpperCase()) {
+                    case "DATA_PRECISION" -> rows.get(index[0]).get(3);
+                    case "DATA_SCALE" -> rows.get(index[0]).get(4);
+                    case "DATA_LENGTH" -> rows.get(index[0]).get(5);
+                    case "CHAR_LENGTH" -> rows.get(index[0]).get(6);
+                    default -> null;
+                };
+            }
+            if ("close".equals(name)) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static String string(List<List<Object>> rows, int rowIndex, int columnIndex) {
+        Object value = rows.get(rowIndex).get(columnIndex);
+        if (value instanceof LongText longText) {
+            return longText.full;
+        }
+        return value == null ? null : value.toString();
+    }
+
+    private static final class LongText {
+        private final String full;
+        private final String truncated;
+
+        private LongText(String full, String truncated) {
+            this.full = full;
+            this.truncated = truncated;
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> T proxy(Class<T> type, MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                return handler.handle(method, args);
+            }
+        };
+        return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler);
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Byte.TYPE.equals(type)) {
+            return (byte) 0;
+        }
+        if (Short.TYPE.equals(type)) {
+            return (short) 0;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        if (Long.TYPE.equals(type)) {
+            return 0L;
+        }
+        if (Float.TYPE.equals(type)) {
+            return 0f;
+        }
+        if (Double.TYPE.equals(type)) {
+            return 0.0d;
+        }
+        if (Character.TYPE.equals(type)) {
+            return '\0';
+        }
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args) throws Throwable;
+    }
+}
diff --git a/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentPagingTest.java b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentPagingTest.java
new file mode 100644
index 0000000..bca5f6b
--- /dev/null
+++ b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentPagingTest.java
@@ -0,0 +1,277 @@
+package com.dbx.agent.dameng;
+
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.test.TestSupport;
+import dm.jdbc.driver.DmdbTimestamp;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Statement;
+import java.sql.Types;
+import javax.sql.rowset.serial.SerialBlob;
+import javax.sql.rowset.serial.SerialClob;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class DamengAgentPagingTest {
+    @Test
+    void executeQueryPageStringifiesTimestampValuesBeforeJsonRpcSerialization() {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(
+            agent,
+            singleValueConnection(
+                "CURRENT_TIMESTAMP",
+                Types.TIMESTAMP,
+                DmdbTimestamp.valueOf("2026-05-20 12:34:56.123456789"),
+                null,
+                null
+            )
+        );
+        JsonRpcServer server = new JsonRpcServer(agent);
+
+        String response = handleRequest(server, """
+            {
+              "jsonrpc": "2.0",
+              "id": 1,
+              "method": "execute_query_page",
+              "params": {
+                "sql": "SELECT CURRENT_TIMESTAMP",
+                "schema": "SYS",
+                "pageSize": 100
+              }
+            }
+            """);
+
+        assertFalse(response.contains("\"error\""), response);
+        assertTrue(response.contains("2026-05-20 12:34:56.123456"), response);
+    }
+
+    @Test
+    void executeQueryPageReadsClobValuesAsText() throws Exception {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(
+            agent,
+            singleValueConnection(
+                "content",
+                Types.CLOB,
+                new SerialClob("真实文本".toCharArray()),
+                "真实文本",
+                null
+            )
+        );
+        JsonRpcServer server = new JsonRpcServer(agent);
+
+        String response = handleRequest(server, """
+            {
+              "jsonrpc": "2.0",
+              "id": 1,
+              "method": "execute_query_page",
+              "params": {
+                "sql": "SELECT content FROM sample",
+                "schema": "SYS",
+                "pageSize": 100
+              }
+            }
+            """);
+
+        assertFalse(response.contains("\"error\""), response);
+        assertTrue(response.contains("真实文本"), response);
+        assertFalse(response.contains("SerialClob"), response);
+    }
+
+    @Test
+    void executeQueryPageFormatsBlobValuesAsHexText() throws Exception {
+        DamengAgent agent = new DamengAgent();
+        TestSupport.setPrivateConnection(
+            agent,
+            singleValueConnection(
+                "payload",
+                Types.BLOB,
+                new SerialBlob(new byte[]{0x01, 0x2A, (byte) 0xFF}),
+                null,
+                new byte[]{0x01, 0x2A, (byte) 0xFF}
+            )
+        );
+        JsonRpcServer server = new JsonRpcServer(agent);
+
+        String response = handleRequest(server, """
+            {
+              "jsonrpc": "2.0",
+              "id": 1,
+              "method": "execute_query_page",
+              "params": {
+                "sql": "SELECT payload FROM sample",
+                "schema": "SYS",
+                "pageSize": 100
+              }
+            }
+            """);
+
+        assertFalse(response.contains("\"error\""), response);
+        assertTrue(response.contains("0x012aff"), response);
+        assertFalse(response.contains("SerialBlob"), response);
+    }
+
+    private static Connection singleValueConnection(
+        String columnLabel,
+        int sqlType,
+        Object objectValue,
+        String stringValue,
+        byte[] bytesValue
+    ) {
+        Statement statement = singleValueStatement(columnLabel, sqlType, objectValue, stringValue, bytesValue);
+        return proxy(Connection.class, (method, args) -> {
+            String name = method.getName();
+            if ("createStatement".equals(name)) {
+                return statement;
+            }
+            if ("getAutoCommit".equals(name)) {
+                return true;
+            }
+            if ("setAutoCommit".equals(name) || "commit".equals(name) || "rollback".equals(name) || "close".equals(name)) {
+                return null;
+            }
+            if ("isClosed".equals(name)) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static Statement singleValueStatement(
+        String columnLabel,
+        int sqlType,
+        Object objectValue,
+        String stringValue,
+        byte[] bytesValue
+    ) {
+        ResultSet resultSet = singleValueResultSet(columnLabel, sqlType, objectValue, stringValue, bytesValue);
+        return proxy(Statement.class, (method, args) -> {
+            String name = method.getName();
+            if ("execute".equals(name)) {
+                return true;
+            }
+            if ("getResultSet".equals(name)) {
+                return resultSet;
+            }
+            if ("getUpdateCount".equals(name)) {
+                return 0;
+            }
+            if ("setMaxRows".equals(name) || "setFetchSize".equals(name) || "close".equals(name)) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSet singleValueResultSet(
+        String columnLabel,
+        int sqlType,
+        Object objectValue,
+        String stringValue,
+        byte[] bytesValue
+    ) {
+        final int[] index = {-1};
+        ResultSetMetaData metadata = singleValueMetadata(columnLabel, sqlType);
+        return proxy(ResultSet.class, (method, args) -> {
+            String name = method.getName();
+            if ("next".equals(name)) {
+                index[0] += 1;
+                return index[0] == 0;
+            }
+            if ("getMetaData".equals(name)) {
+                return metadata;
+            }
+            if ("getObject".equals(name)) {
+                return objectValue;
+            }
+            if ("getString".equals(name)) {
+                return stringValue;
+            }
+            if ("getBytes".equals(name)) {
+                return bytesValue;
+            }
+            if ("wasNull".equals(name)) {
+                return false;
+            }
+            if ("close".equals(name)) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSetMetaData singleValueMetadata(String columnLabel, int sqlType) {
+        return proxy(ResultSetMetaData.class, (method, args) -> {
+            String name = method.getName();
+            if ("getColumnCount".equals(name)) {
+                return 1;
+            }
+            if ("getColumnLabel".equals(name)) {
+                return columnLabel;
+            }
+            if ("getColumnType".equals(name)) {
+                return sqlType;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static String handleRequest(JsonRpcServer server, String request) {
+        try {
+            Method method = JsonRpcServer.class.getDeclaredMethod("handleRequest", String.class);
+            method.setAccessible(true);
+            return (String) method.invoke(server, request);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static <T> T proxy(Class<T> type, MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) {
+                return handler.handle(method, args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Byte.TYPE.equals(type)) {
+            return (byte) 0;
+        }
+        if (Short.TYPE.equals(type)) {
+            return (short) 0;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        if (Long.TYPE.equals(type)) {
+            return 0L;
+        }
+        if (Float.TYPE.equals(type)) {
+            return 0f;
+        }
+        if (Double.TYPE.equals(type)) {
+            return 0.0d;
+        }
+        if (Character.TYPE.equals(type)) {
+            return '\0';
+        }
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args);
+    }
+}
diff --git a/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentTest.java b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentTest.java
new file mode 100644
index 0000000..afa21b7
--- /dev/null
+++ b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentTest.java
@@ -0,0 +1,61 @@
+package com.dbx.agent.dameng;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class DamengAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new DamengAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL SP_SAMPLE()";
+    }
+
+    @Test
+    void constrainedTableQueryPushesFilterTypeAndPagingToDameng() {
+        DamengAgent.MetadataQuery query = DamengAgent.buildConstrainedTablesQuery(
+            "APP",
+            new MetadataListConstraints("ord", 50, 100, List.of("TABLE", "VIEW"))
+        );
+
+        assertTrue(query.sql().contains("FROM ALL_OBJECTS o"));
+        assertTrue(query.sql().contains("o.OBJECT_TYPE IN (?, ?)"));
+        assertTrue(query.sql().contains("UPPER(o.OBJECT_NAME) LIKE ? ESCAPE '\\\\'"));
+        assertTrue(query.sql().endsWith("LIMIT ? OFFSET ?"));
+        assertEquals(List.of("APP", "TABLE", "VIEW", "%O%R%D%", 50, 100), query.args());
+    }
+
+    @Test
+    void constrainedTableQueryMapsMaterializedViewTypeToDamengCatalogName() {
+        DamengAgent.MetadataQuery query = DamengAgent.buildConstrainedTablesQuery(
+            "APP",
+            new MetadataListConstraints(null, 20, null, List.of("MATERIALIZED_VIEW"))
+        );
+
+        assertTrue(query.sql().contains("MATERIALIZED_VIEW"));
+        assertEquals(List.of("APP", "MATERIALIZED VIEW", 20), query.args());
+    }
+
+    @Test
+    void constrainedObjectQueryPushesRoutineOnlySearchToDameng() {
+        DamengAgent.MetadataQuery query = DamengAgent.buildConstrainedObjectsQuery(
+            "APP",
+            new MetadataListConstraints("sync", 20, null, List.of("PROCEDURE", "FUNCTION"))
+        );
+
+        assertTrue(query.sql().contains("o.OBJECT_TYPE IN (?, ?)"));
+        assertTrue(query.sql().contains("WHEN 'PROCEDURE' THEN 3"));
+        assertTrue(query.sql().endsWith("LIMIT ?"));
+        assertEquals(List.of("APP", "PROCEDURE", "FUNCTION", "%S%Y%N%C%", 20), query.args());
+    }
+}
diff --git a/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentUrlTest.java b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentUrlTest.java
new file mode 100644
index 0000000..c1d72a8
--- /dev/null
+++ b/agents/drivers/dameng/src/test/java/com/dbx/agent/dameng/DamengAgentUrlTest.java
@@ -0,0 +1,29 @@
+package com.dbx.agent.dameng;
+
+import com.dbx.agent.ConnectParams;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Method;
+
+class DamengAgentUrlTest {
+    @Test
+    void omitsDatabasePathWhenDatabaseIsBlank() throws Exception {
+        String url = invokeBuildUrl(new ConnectParams("127.0.0.1", 5236, "", "SYSDBA", "pwd", "", "", false));
+
+        Assertions.assertEquals("jdbc:dm://127.0.0.1:5236", url);
+    }
+
+    @Test
+    void appendsDatabasePathWhenDatabaseIsProvided() throws Exception {
+        String url = invokeBuildUrl(new ConnectParams("127.0.0.1", 5236, "MAIN", "SYSDBA", "pwd", "", "", false));
+
+        Assertions.assertEquals("jdbc:dm://127.0.0.1:5236/MAIN", url);
+    }
+
+    private static String invokeBuildUrl(ConnectParams params) throws Exception {
+        Method method = DamengAgent.class.getDeclaredMethod("buildUrl", ConnectParams.class);
+        method.setAccessible(true);
+        return (String) method.invoke(null, params);
+    }
+}
diff --git a/agents/drivers/databend/build.gradle b/agents/drivers/databend/build.gradle
new file mode 100644
index 0000000..a1db92d
--- /dev/null
+++ b/agents/drivers/databend/build.gradle
@@ -0,0 +1,9 @@
+dependencies {
+    implementation 'com.databend:databend-jdbc:0.4.6'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Databend', 'Main-Class': 'com.dbx.agent.databend.DatabendAgent')
+    }
+}
diff --git a/agents/drivers/databend/src/main/java/com/dbx/agent/databend/DatabendAgent.java b/agents/drivers/databend/src/main/java/com/dbx/agent/databend/DatabendAgent.java
new file mode 100644
index 0000000..48c00e4
--- /dev/null
+++ b/agents/drivers/databend/src/main/java/com/dbx/agent/databend/DatabendAgent.java
@@ -0,0 +1,299 @@
+package com.dbx.agent.databend;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.PreparedStatement;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+public final class DatabendAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile DATABEND_PROFILE = new JdbcAgentProfile(
+        "com.databend.jdbc.DatabendDriver",
+        "jdbc:databend://{host}:{port}/{database}",
+        8000,
+        false,
+        Collections.singleton("INFORMATION_SCHEMA"),
+        Arrays.asList("TABLE", "VIEW", "BASE TABLE", "MATERIALIZED VIEW", "SYSTEM TABLE", "SYSTEM VIEW"),
+        "\"",
+        "USE",
+        true,
+        false,
+        false,
+        false
+    );
+
+    public DatabendAgent() {
+        super(DATABEND_PROFILE);
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>(super.listObjects(schema));
+            try {
+                useSchema(schema);
+                try (java.sql.Statement stmt = requireConnected().createStatement();
+                     ResultSet rs = stmt.executeQuery("SHOW PROCEDURES")) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString("name"), "PROCEDURE", schema, rs.getString("comment")));
+                    }
+                }
+            } catch (Exception ignored) {
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        boolean includeTables = normalized.includesTableLikeTypes();
+        boolean includeProcedures = includesProcedures(normalized);
+        if (includeProcedures && !includeTables) {
+            return listProcedures(schema, normalized);
+        }
+        if (includeTables && !includeProcedures) {
+            return super.listObjects(schema, normalized);
+        }
+        if (!includeTables && !includeProcedures) {
+            return List.of();
+        }
+        return normalized.filterObjects(listObjects(schema));
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        if (!"PROCEDURE".equalsIgnoreCase(objectType)) {
+            return super.getObjectSource(schema, name, objectType);
+        }
+        return unchecked(() -> {
+            useSchema(schema);
+            ProcedureMetadata procedure = findProcedure(name);
+            if (procedure == null) {
+                throw new IllegalArgumentException("Procedure not found: " + name);
+            }
+            Map<String, String> properties = describeProcedure(name, procedure.inputTypes);
+            String source = buildProcedureSource(name, procedure, properties);
+            return new ObjectSource(name, objectType, schema, source);
+        });
+    }
+
+    private void useSchema(String schema) throws SQLException {
+        if (schema == null || schema.trim().isEmpty()) {
+            return;
+        }
+        try (java.sql.Statement stmt = requireConnected().createStatement()) {
+            stmt.execute(DATABEND_PROFILE.schemaSwitchSql(schema.trim()));
+        }
+    }
+
+    private List<ObjectInfo> listProcedures(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            useSchema(schema);
+            List<ObjectInfo> result = new ArrayList<>();
+            StringBuilder sql = new StringBuilder("SELECT name, comment FROM system.procedures");
+            List<Object> args = new ArrayList<>();
+            if (constraints.hasFilter()) {
+                sql.append(" WHERE UPPER(name) LIKE ? ESCAPE '\\\\'");
+                args.add(constraints.fuzzyLikePattern().toUpperCase(Locale.ROOT));
+            }
+            sql.append(" ORDER BY name");
+            if (constraints.hasLimit()) {
+                sql.append(" LIMIT ?");
+                args.add(constraints.getLimit());
+                if (constraints.hasOffset()) {
+                    sql.append(" OFFSET ?");
+                    args.add(constraints.getOffset());
+                }
+            }
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString("name"), "PROCEDURE", schema, rs.getString("comment")));
+                    }
+                }
+            }
+            MetadataListConstraints guard = constraints.hasLimit() ? constraints.withoutPaging() : constraints;
+            return guard.filterObjects(result);
+        });
+    }
+
+    private static boolean includesProcedures(MetadataListConstraints constraints) {
+        return !constraints.hasObjectTypes() || constraints.objectTypeAllowed("PROCEDURE");
+    }
+
+    private static void bind(PreparedStatement stmt, List<Object> args) throws SQLException {
+        for (int index = 0; index < args.size(); index += 1) {
+            Object arg = args.get(index);
+            if (arg instanceof Integer) {
+                stmt.setInt(index + 1, (Integer) arg);
+            } else {
+                stmt.setString(index + 1, String.valueOf(arg));
+            }
+        }
+    }
+
+    private ProcedureMetadata findProcedure(String name) throws SQLException {
+        try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(
+            "SELECT arguments, comment FROM system.procedures WHERE name = ? ORDER BY procedure_id LIMIT 1"
+        )) {
+            stmt.setString(1, name);
+            try (ResultSet rs = stmt.executeQuery()) {
+                if (!rs.next()) {
+                    return null;
+                }
+                return new ProcedureMetadata(
+                    rs.getString("comment"),
+                    inputTypesFromArguments(rs.getString("arguments"))
+                );
+            }
+        }
+    }
+
+    private Map<String, String> describeProcedure(String name, List<String> inputTypes) throws SQLException {
+        Map<String, String> result = new LinkedHashMap<>();
+        try (java.sql.Statement stmt = requireConnected().createStatement();
+             ResultSet rs = stmt.executeQuery("DESC PROCEDURE " + simpleProcedureName(name) + "(" + String.join(", ", inputTypes) + ")")) {
+            while (rs.next()) {
+                result.put(rs.getString("Property").toLowerCase(Locale.ROOT), rs.getString("Value"));
+            }
+        }
+        return result;
+    }
+
+    private static String buildProcedureSource(String name, ProcedureMetadata procedure, Map<String, String> properties) {
+        List<String> names = signatureNames(properties.get("signature"));
+        List<String> arguments = new ArrayList<>();
+        for (int index = 0; index < procedure.inputTypes.size(); index += 1) {
+            String argumentName = index < names.size() && !names.get(index).isEmpty() ? names.get(index) : "arg" + (index + 1);
+            arguments.add(argumentName + " " + procedure.inputTypes.get(index));
+        }
+
+        String returns = trimOuterParens(properties.getOrDefault("returns", ""));
+        String language = properties.getOrDefault("language", "SQL");
+        String body = properties.getOrDefault("body", "").trim();
+        StringBuilder source = new StringBuilder();
+        source.append("CREATE PROCEDURE ").append(simpleProcedureName(name)).append("(").append(String.join(", ", arguments)).append(")");
+        if (!returns.isEmpty()) {
+            source.append("\nRETURNS ").append(returns);
+        }
+        source.append("\nLANGUAGE ").append(language);
+        if (procedure.comment != null && !procedure.comment.isEmpty()) {
+            source.append("\nCOMMENT = '").append(procedure.comment.replace("'", "''")).append("'");
+        }
+        source.append("\nAS $$\n").append(body).append("\n$$;");
+        return source.toString();
+    }
+
+    private static String simpleProcedureName(String name) {
+        if (name != null && name.matches("[A-Za-z_][A-Za-z0-9_]*")) {
+            return name;
+        }
+        throw new IllegalArgumentException("Databend procedure names with special characters are not supported: " + name);
+    }
+
+    private static List<String> inputTypesFromArguments(String arguments) {
+        if (arguments == null) {
+            return Collections.emptyList();
+        }
+        int open = arguments.indexOf('(');
+        if (open < 0) {
+            return Collections.emptyList();
+        }
+        int close = matchingParen(arguments, open);
+        if (close < 0) {
+            return Collections.emptyList();
+        }
+        return splitTopLevel(arguments.substring(open + 1, close));
+    }
+
+    private static List<String> signatureNames(String signature) {
+        if (signature == null) {
+            return Collections.emptyList();
+        }
+        String trimmed = trimOuterParens(signature);
+        return splitTopLevel(trimmed);
+    }
+
+    private static List<String> splitTopLevel(String value) {
+        if (value == null || value.trim().isEmpty()) {
+            return Collections.emptyList();
+        }
+        List<String> result = new ArrayList<>();
+        StringBuilder current = new StringBuilder();
+        int depth = 0;
+        for (int index = 0; index < value.length(); index += 1) {
+            char ch = value.charAt(index);
+            if (ch == '(') {
+                depth += 1;
+            } else if (ch == ')') {
+                depth = Math.max(0, depth - 1);
+            } else if (ch == ',' && depth == 0) {
+                addTrimmed(result, current.toString());
+                current.setLength(0);
+                continue;
+            }
+            current.append(ch);
+        }
+        addTrimmed(result, current.toString());
+        return result;
+    }
+
+    private static void addTrimmed(List<String> result, String value) {
+        String trimmed = value.trim();
+        if (!trimmed.isEmpty()) {
+            result.add(trimmed);
+        }
+    }
+
+    private static int matchingParen(String value, int open) {
+        int depth = 0;
+        for (int index = open; index < value.length(); index += 1) {
+            char ch = value.charAt(index);
+            if (ch == '(') {
+                depth += 1;
+            } else if (ch == ')') {
+                depth -= 1;
+                if (depth == 0) {
+                    return index;
+                }
+            }
+        }
+        return -1;
+    }
+
+    private static String trimOuterParens(String value) {
+        String trimmed = value == null ? "" : value.trim();
+        if (trimmed.startsWith("(") && trimmed.endsWith(")") && matchingParen(trimmed, 0) == trimmed.length() - 1) {
+            return trimmed.substring(1, trimmed.length() - 1).trim();
+        }
+        return trimmed;
+    }
+
+    private static final class ProcedureMetadata {
+        private final String comment;
+        private final List<String> inputTypes;
+
+        ProcedureMetadata(String comment, List<String> inputTypes) {
+            this.comment = comment;
+            this.inputTypes = inputTypes;
+        }
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new DatabendAgent()).run();
+    }
+}
diff --git a/agents/drivers/databend/src/test/java/com/dbx/agent/databend/DatabendAgentTest.java b/agents/drivers/databend/src/test/java/com/dbx/agent/databend/DatabendAgentTest.java
new file mode 100644
index 0000000..d875129
--- /dev/null
+++ b/agents/drivers/databend/src/test/java/com/dbx/agent/databend/DatabendAgentTest.java
@@ -0,0 +1,196 @@
+package com.dbx.agent.databend;
+
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import com.dbx.agent.test.TestSupport;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+class DatabendAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new DatabendAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "SELECT 1";
+    }
+
+    @Test
+    void buildsDefaultJdbcUrl() {
+        ConnectParams params = new ConnectParams();
+        params.setHost("db.example.com");
+        params.setPort(0);
+        params.setDatabase("default");
+
+        Assertions.assertEquals(
+            "jdbc:databend://db.example.com:8000/default",
+            DatabendAgent.DATABEND_PROFILE.buildUrl(params)
+        );
+    }
+
+    @Test
+    void appendsQueryParametersToJdbcUrl() {
+        ConnectParams params = new ConnectParams();
+        params.setHost("db.example.com");
+        params.setPort(20080);
+        params.setDatabase("default");
+        params.setUrl_params("sslmode=disable");
+
+        Assertions.assertEquals(
+            "jdbc:databend://db.example.com:20080/default?sslmode=disable",
+            DatabendAgent.DATABEND_PROFILE.buildUrl(params)
+        );
+    }
+
+    @Test
+    void usesDoubleQuotedDatabaseAsExecutionContext() {
+        Assertions.assertEquals(
+            "USE \"analytics\"\"prod\"",
+            DatabendAgent.DATABEND_PROFILE.schemaSwitchSql("analytics\"prod")
+        );
+    }
+
+    @Test
+    void constrainedListObjectsKeepsDatabendProcedures() {
+        List<String> sql = new ArrayList<>();
+        DatabendAgent agent = new DatabendAgent();
+        TestSupport.setPrivateConnection(agent, databendMetadataConnection(sql, resultSet(
+            new String[]{"name", "comment"},
+            new Object[][]{
+                {"refresh_orders", "proc comment"},
+                {"format_order", null}
+            }
+        )));
+
+        List<ObjectInfo> objects = agent.listObjects(
+            "default",
+            new MetadataListConstraints("format", 1, null, List.of("PROCEDURE"))
+        );
+
+        Assertions.assertEquals(1, objects.size());
+        Assertions.assertEquals("format_order", objects.get(0).getName());
+        Assertions.assertEquals("PROCEDURE", objects.get(0).getObject_type());
+        Assertions.assertTrue(sql.stream().anyMatch(value -> value.contains("FROM system.procedures")), sql.toString());
+        Assertions.assertTrue(sql.stream().anyMatch(value -> value.contains("UPPER(name) LIKE ?")), sql.toString());
+        Assertions.assertTrue(sql.stream().anyMatch(value -> value.contains("LIMIT ?")), sql.toString());
+    }
+
+    private static Connection databendMetadataConnection(List<String> sql, ResultSet procedures) {
+        DatabaseMetaData metadata = proxy(DatabaseMetaData.class, (method, args) -> {
+            if ("getTableTypes".equals(method.getName()) || "getTables".equals(method.getName())) {
+                return emptyResultSet();
+            }
+            return defaultValue(method.getReturnType());
+        });
+        Statement statement = proxy(Statement.class, (method, args) -> {
+            if ("execute".equals(method.getName()) || "close".equals(method.getName())) {
+                return "execute".equals(method.getName()) ? false : null;
+            }
+            if ("executeQuery".equals(method.getName())) {
+                return procedures;
+            }
+            return defaultValue(method.getReturnType());
+        });
+        PreparedStatement preparedStatement = proxy(PreparedStatement.class, (method, args) -> {
+            if ("executeQuery".equals(method.getName())) {
+                return procedures;
+            }
+            if ("setString".equals(method.getName()) || "setInt".equals(method.getName()) || "close".equals(method.getName())) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+        return proxy(Connection.class, (method, args) -> {
+            if ("getMetaData".equals(method.getName())) {
+                return metadata;
+            }
+            if ("createStatement".equals(method.getName())) {
+                return statement;
+            }
+            if ("prepareStatement".equals(method.getName())) {
+                sql.add(String.valueOf(args[0]));
+                return preparedStatement;
+            }
+            if ("isClosed".equals(method.getName())) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSet emptyResultSet() {
+        return resultSet(new String[]{"VALUE"}, new Object[][]{});
+    }
+
+    private static ResultSet resultSet(String[] columns, Object[][] rows) {
+        int[] index = {-1};
+        return proxy(ResultSet.class, (method, args) -> {
+            switch (method.getName()) {
+                case "next":
+                    index[0] += 1;
+                    return index[0] < rows.length;
+                case "getString":
+                    Object value = columnValue(columns, rows[index[0]], args[0]);
+                    return value == null ? null : String.valueOf(value);
+                case "close":
+                    return null;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Object columnValue(String[] columns, Object[] row, Object key) {
+        if (key instanceof Number) {
+            return row[((Number) key).intValue() - 1];
+        }
+        for (int i = 0; i < columns.length; i++) {
+            if (columns[i].equalsIgnoreCase(String.valueOf(key))) {
+                return row[i];
+            }
+        }
+        return null;
+    }
+
+    private static <T> T proxy(Class<T> type, MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                return handler.handle(method, args == null ? new Object[0] : args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (type == Boolean.TYPE) return false;
+        if (type == Byte.TYPE) return (byte) 0;
+        if (type == Short.TYPE) return (short) 0;
+        if (type == Integer.TYPE) return 0;
+        if (type == Long.TYPE) return 0L;
+        if (type == Float.TYPE) return 0f;
+        if (type == Double.TYPE) return 0d;
+        if (type == Character.TYPE) return (char) 0;
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args) throws Throwable;
+    }
+}
diff --git a/agents/drivers/databricks/build.gradle b/agents/drivers/databricks/build.gradle
new file mode 100644
index 0000000..f6675d8
--- /dev/null
+++ b/agents/drivers/databricks/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.databricks:databricks-jdbc:3.3.3'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Databricks SQL', 'Main-Class': 'com.dbx.agent.databricks.DatabricksAgent')
+    }
+}
diff --git a/agents/drivers/databricks/src/main/java/com/dbx/agent/databricks/DatabricksAgent.java b/agents/drivers/databricks/src/main/java/com/dbx/agent/databricks/DatabricksAgent.java
new file mode 100644
index 0000000..5b5ef6b
--- /dev/null
+++ b/agents/drivers/databricks/src/main/java/com/dbx/agent/databricks/DatabricksAgent.java
@@ -0,0 +1,41 @@
+package com.dbx.agent.databricks;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+
+public final class DatabricksAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile DATABRICKS_PROFILE = new DatabricksProfile();
+
+    public DatabricksAgent() {
+        super(DATABRICKS_PROFILE);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new DatabricksAgent()).run();
+    }
+
+    private static final class DatabricksProfile extends JdbcAgentProfile {
+        private DatabricksProfile() {
+            super("com.databricks.client.jdbc.Driver", "jdbc:databricks://{host}:{port}/{database}", 443, true);
+        }
+
+        @Override
+        public String buildUrl(ConnectParams params) {
+            if (!params.getConnection_string().trim().isEmpty()) {
+                return params.getConnection_string();
+            }
+            int port = params.getPort() > 0 ? params.getPort() : getDefaultPort();
+            String base = getUrlTemplate()
+                .replace("{host}", params.getHost())
+                .replace("{port}", Integer.toString(port))
+                .replace("{database}", params.getDatabase());
+            String urlParams = params.getUrl_params() == null ? "" : params.getUrl_params().trim();
+            while (urlParams.startsWith(";") || urlParams.startsWith("?") || urlParams.startsWith("&")) {
+                urlParams = urlParams.substring(1);
+            }
+            return urlParams.isEmpty() ? base : base + ";" + urlParams;
+        }
+    }
+}
diff --git a/agents/drivers/databricks/src/test/java/com/dbx/agent/databricks/DatabricksAgentTest.java b/agents/drivers/databricks/src/test/java/com/dbx/agent/databricks/DatabricksAgentTest.java
new file mode 100644
index 0000000..80f5bcb
--- /dev/null
+++ b/agents/drivers/databricks/src/test/java/com/dbx/agent/databricks/DatabricksAgentTest.java
@@ -0,0 +1,22 @@
+package com.dbx.agent.databricks;
+
+import com.dbx.agent.ConnectParams;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class DatabricksAgentTest {
+    @Test
+    void buildsHttpPathUrl() {
+        ConnectParams params = new ConnectParams();
+        params.setHost("adb-123.azuredatabricks.net");
+        params.setPort(443);
+        params.setDatabase("default");
+        params.setUrl_params("httpPath=/sql/1.0/warehouses/abc;AuthMech=3");
+
+        assertEquals(
+            "jdbc:databricks://adb-123.azuredatabricks.net:443/default;httpPath=/sql/1.0/warehouses/abc;AuthMech=3",
+            DatabricksAgent.DATABRICKS_PROFILE.buildUrl(params)
+        );
+    }
+}
diff --git a/agents/drivers/db2/build.gradle b/agents/drivers/db2/build.gradle
new file mode 100644
index 0000000..d9af1aa
--- /dev/null
+++ b/agents/drivers/db2/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.ibm.db2:jcc:11.5.9.0'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'IBM DB2', 'Main-Class': 'com.dbx.agent.db2.Db2Agent')
+    }
+}
diff --git a/agents/drivers/db2/src/main/java/com/dbx/agent/db2/Db2Agent.java b/agents/drivers/db2/src/main/java/com/dbx/agent/db2/Db2Agent.java
new file mode 100644
index 0000000..047b11c
--- /dev/null
+++ b/agents/drivers/db2/src/main/java/com/dbx/agent/db2/Db2Agent.java
@@ -0,0 +1,515 @@
+package com.dbx.agent.db2;
+
+import com.dbx.agent.BaseDatabaseAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcExecutor;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.MetadataSqlSupport;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+public final class Db2Agent extends BaseDatabaseAgent {
+    private static final Set<String> NUMERIC_PRECISION_TYPES = Set.of(
+        "DECIMAL", "NUMERIC", "INTEGER", "SMALLINT", "BIGINT", "REAL", "DOUBLE", "FLOAT"
+    );
+    private static final Set<String> NUMERIC_SCALE_TYPES = Set.of("DECIMAL", "NUMERIC");
+    private static final Set<String> CHARACTER_LENGTH_TYPES = Set.of("VARCHAR", "CHAR", "CLOB", "GRAPHIC", "VARGRAPHIC");
+
+    private Connection connection;
+
+    @Override
+    public Connection getConnection() {
+        return connection;
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "SET SCHEMA " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
+    }
+
+    @Override
+    public void connect(ConnectParams params) {
+        uncheckedVoid(() -> {
+            Class.forName("com.ibm.db2.jcc.DB2Driver");
+            connection = DriverManager.getConnection(buildUrl(params), params.getUsername(), params.getPassword());
+        });
+    }
+
+    @Override
+    public boolean testConnection(ConnectParams params) {
+        return unchecked(() -> {
+            Class.forName("com.ibm.db2.jcc.DB2Driver");
+            try (Connection conn = DriverManager.getConnection(buildUrl(params), params.getUsername(), params.getPassword())) {
+                return conn.isValid(5);
+            }
+        });
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            String sql = "SELECT CURRENT_SERVER FROM SYSIBM.SYSDUMMY1";
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(sql)) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString(1).trim()));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return unchecked(() -> {
+            List<String> result = new ArrayList<>();
+            String sql = "SELECT SCHEMANAME FROM SYSCAT.SCHEMATA ORDER BY SCHEMANAME";
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(sql)) {
+                while (rs.next()) {
+                    result.add(rs.getString(1).trim());
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            String sql = "SELECT TABNAME, TYPE FROM SYSCAT.TABLES WHERE TABSCHEMA = ? AND TYPE IN ('T','V') ORDER BY TABNAME";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String db2Type = rs.getString(2).trim();
+                        String type = switch (db2Type) {
+                            case "T" -> "TABLE";
+                            case "V" -> "VIEW";
+                            default -> db2Type;
+                        };
+                        result.add(new TableInfo(rs.getString(1).trim(), type, null));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listTables(schema);
+        }
+        if (!normalized.includesTableLikeTypes()) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedTables(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterTables(listTables(schema));
+        }
+    }
+
+    private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            StringBuilder sql = new StringBuilder("SELECT TABNAME, TYPE FROM SYSCAT.TABLES WHERE TABSCHEMA = ?");
+            args.add(schema);
+            appendDb2TableTypePredicate(sql, args, constraints);
+            MetadataSqlSupport.appendNameFilter(sql, args, "TABNAME", constraints);
+            sql.append(" ORDER BY TABNAME");
+            MetadataSqlSupport.appendLiteralOffsetFetch(sql, constraints);
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(rs.getString(1).trim(), db2TableType(rs.getString(2)), null));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterTables(result);
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            for (TableInfo table : listTables(schema)) {
+                result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+            }
+
+            String sql = "SELECT PROCNAME, 'PROCEDURE' FROM SYSCAT.PROCEDURES WHERE PROCSCHEMA = ? ORDER BY PROCNAME";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1).trim(), rs.getString(2), schema, null));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listObjects(schema);
+        }
+        if (!includesSupportedObjects(normalized)) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedObjects(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterObjects(listObjects(schema));
+        }
+    }
+
+    private List<ObjectInfo> queryConstrainedObjects(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            List<String> branches = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            if (constraints.includesTableLikeTypes()) {
+                StringBuilder tableSql = new StringBuilder(
+                    "SELECT TABNAME AS OBJECT_NAME, CASE TYPE WHEN 'T' THEN 'TABLE' WHEN 'V' THEN 'VIEW' ELSE TYPE END AS OBJECT_TYPE FROM SYSCAT.TABLES WHERE TABSCHEMA = ?"
+                );
+                args.add(schema);
+                appendDb2TableTypePredicate(tableSql, args, constraints);
+                MetadataSqlSupport.appendNameFilter(tableSql, args, "TABNAME", constraints);
+                branches.add(tableSql.toString());
+            }
+            if (constraints.objectTypeAllowed("PROCEDURE")) {
+                StringBuilder procedureSql = new StringBuilder(
+                    "SELECT PROCNAME AS OBJECT_NAME, 'PROCEDURE' AS OBJECT_TYPE FROM SYSCAT.PROCEDURES WHERE PROCSCHEMA = ?"
+                );
+                args.add(schema);
+                MetadataSqlSupport.appendNameFilter(procedureSql, args, "PROCNAME", constraints);
+                branches.add(procedureSql.toString());
+            }
+            if (branches.isEmpty()) {
+                return List.of();
+            }
+            StringBuilder sql = new StringBuilder("SELECT OBJECT_NAME, OBJECT_TYPE FROM (")
+                .append(String.join(" UNION ALL ", branches))
+                .append(") metadata_objects ORDER BY CASE OBJECT_TYPE WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 WHEN 'PROCEDURE' THEN 2 ELSE 9 END, OBJECT_NAME");
+            MetadataSqlSupport.appendLiteralOffsetFetch(sql, constraints);
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1).trim(), rs.getString(2), schema, null));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterObjects(result);
+        });
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        return unchecked(() -> {
+            String sql = "SELECT TEXT FROM SYSCAT.ROUTINES WHERE ROUTINESCHEMA = ? AND ROUTINENAME = ?";
+            String source;
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, name);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    source = rs.next() ? coalesce(rs.getString(1)) : "";
+                }
+            }
+            return new ObjectSource(name, objectType, schema, source);
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            Set<String> pkColumns = new java.util.HashSet<>();
+            String pkSql = """
+                SELECT kc.COLNAME FROM SYSCAT.KEYCOLUSE kc
+                JOIN SYSCAT.TABCONST tc ON kc.CONSTNAME = tc.CONSTNAME AND kc.TABSCHEMA = tc.TABSCHEMA AND kc.TABNAME = tc.TABNAME
+                WHERE tc.TYPE = 'P' AND tc.TABSCHEMA = ? AND tc.TABNAME = ?
+                """.stripIndent().trim();
+            try (PreparedStatement stmt = requireConnected().prepareStatement(pkSql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        pkColumns.add(rs.getString(1).trim());
+                    }
+                }
+            }
+
+            List<ColumnInfo> result = new ArrayList<>();
+            String colSql = """
+                SELECT COLNAME, TYPENAME, NULLS, DEFAULT, LENGTH, SCALE
+                FROM SYSCAT.COLUMNS
+                WHERE TABSCHEMA = ? AND TABNAME = ?
+                ORDER BY COLNO
+                """.stripIndent().trim();
+            try (PreparedStatement stmt = requireConnected().prepareStatement(colSql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String name = rs.getString("COLNAME").trim();
+                        String typeName = rs.getString("TYPENAME").trim();
+                        Integer length = intObject(rs, "LENGTH");
+                        Integer scale = intObject(rs, "SCALE");
+                        String dataType = formatDataType(typeName, length, scale);
+
+                        result.add(new ColumnInfo(
+                            name,
+                            dataType,
+                            "Y".equals(rs.getString("NULLS").trim()),
+                            trimNullable(rs.getString("DEFAULT")),
+                            pkColumns.contains(name),
+                            null,
+                            null,
+                            NUMERIC_PRECISION_TYPES.contains(typeName) ? length : null,
+                            NUMERIC_SCALE_TYPES.contains(typeName) ? scale : null,
+                            CHARACTER_LENGTH_TYPES.contains(typeName) ? length : null
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return unchecked(() -> {
+            List<IndexInfo> result = new ArrayList<>();
+            String sql = "SELECT INDNAME, COLNAMES, UNIQUERULE FROM SYSCAT.INDEXES WHERE TABSCHEMA = ? AND TABNAME = ? ORDER BY INDNAME";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String colNames = trimToEmpty(rs.getString(2));
+                        List<String> columns = splitColumns(colNames, "[+-]");
+                        String uniqueRule = trimToEmpty(rs.getString(3));
+                        result.add(new IndexInfo(
+                            rs.getString(1).trim(),
+                            columns,
+                            "U".equals(uniqueRule) || "P".equals(uniqueRule),
+                            "P".equals(uniqueRule),
+                            null,
+                            null,
+                            null,
+                            null
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return unchecked(() -> {
+            List<ForeignKeyInfo> result = new ArrayList<>();
+            String sql = "SELECT CONSTNAME, FK_COLNAMES, REFTABNAME, PK_COLNAMES FROM SYSCAT.REFERENCES WHERE TABSCHEMA = ? AND TABNAME = ? ORDER BY CONSTNAME";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        List<String> fkColList = splitColumns(trimToEmpty(rs.getString(2)), "\\s+");
+                        List<String> pkColList = splitColumns(trimToEmpty(rs.getString(4)), "\\s+");
+                        String refTable = rs.getString(3).trim();
+                        String constName = rs.getString(1).trim();
+                        for (int i = 0; i < fkColList.size(); i++) {
+                            result.add(new ForeignKeyInfo(
+                                constName,
+                                fkColList.get(i),
+                                refTable,
+                                i < pkColList.size() ? pkColList.get(i) : ""
+                            ));
+                        }
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return unchecked(() -> {
+            List<TriggerInfo> result = new ArrayList<>();
+            String sql = "SELECT TRIGNAME, TRIGEVENT, TRIGTIME FROM SYSCAT.TRIGGERS WHERE TABSCHEMA = ? AND TABNAME = ? ORDER BY TRIGNAME";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TriggerInfo(
+                            rs.getString(1).trim(),
+                            rs.getString(2).trim(),
+                            rs.getString(3).trim()
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        return JdbcExecutor.INSTANCE.execute(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options.getMaxRows(),
+            options.getFetchSize(),
+            options.getTimeoutSecs(),
+            this::stringResultValue
+        );
+    }
+
+    @Override
+    public void disconnect() {
+        uncheckedVoid(() -> {
+            if (connection != null) {
+                connection.close();
+            }
+            connection = null;
+        });
+    }
+
+    private Object stringResultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value = rs.getObject(index);
+            return rs.wasNull() ? null : value == null ? null : value.toString();
+        });
+    }
+
+    static String buildUrl(ConnectParams params) {
+        if (!params.getConnection_string().trim().isEmpty()) {
+            return params.getConnection_string();
+        }
+        String url = "jdbc:db2://" + params.getHost() + ":" + params.getPort() + "/" + params.getDatabase();
+        String extraParams = trimDb2UrlParams(params.getUrl_params());
+        if (extraParams.isEmpty()) {
+            return url;
+        }
+        return url + ":" + extraParams + (extraParams.endsWith(";") ? "" : ";");
+    }
+
+    private static boolean isUnconstrained(MetadataListConstraints constraints) {
+        return !constraints.hasFilter() && !constraints.hasLimit() && !constraints.hasOffset() && !constraints.hasObjectTypes();
+    }
+
+    private static boolean includesSupportedObjects(MetadataListConstraints constraints) {
+        return constraints.includesTableLikeTypes() || constraints.objectTypeAllowed("PROCEDURE");
+    }
+
+    private static void appendDb2TableTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        List<String> types = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            types.add("T");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            types.add("V");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND TYPE IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
+        args.addAll(types);
+    }
+
+    private static String db2TableType(String value) {
+        String db2Type = value == null ? "" : value.trim();
+        return switch (db2Type) {
+            case "T" -> "TABLE";
+            case "V" -> "VIEW";
+            default -> db2Type;
+        };
+    }
+
+    private static String trimDb2UrlParams(String urlParams) {
+        String value = urlParams == null ? "" : urlParams.trim();
+        while (value.startsWith("?") || value.startsWith("&") || value.startsWith(":") || value.startsWith(";")) {
+            value = value.substring(1);
+        }
+        return value;
+    }
+
+    private static String formatDataType(String typeName, Integer length, Integer scale) {
+        return switch (typeName.toUpperCase(Locale.ROOT)) {
+            case "VARCHAR", "CHAR", "CLOB", "GRAPHIC", "VARGRAPHIC" -> length != null ? typeName + "(" + length + ")" : typeName;
+            case "DECIMAL", "NUMERIC" -> {
+                if (length != null && scale != null && scale > 0) {
+                    yield typeName + "(" + length + "," + scale + ")";
+                }
+                yield length != null ? typeName + "(" + length + ")" : typeName;
+            }
+            default -> typeName;
+        };
+    }
+
+    private static Integer intObject(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value == null ? null : ((Number) value).intValue();
+    }
+
+    private static List<String> splitColumns(String value, String regex) {
+        List<String> result = new ArrayList<>();
+        for (String part : value.split(regex)) {
+            if (!part.isBlank()) {
+                result.add(part);
+            }
+        }
+        return result;
+    }
+
+    private static String trimNullable(String value) {
+        return value == null ? null : value.trim();
+    }
+
+    private static String trimToEmpty(String value) {
+        return value == null ? "" : value.trim();
+    }
+
+    private static String coalesce(String value) {
+        return value == null ? "" : value;
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new Db2Agent()).run();
+    }
+}
diff --git a/agents/drivers/db2/src/test/java/com/dbx/agent/db2/Db2AgentTest.java b/agents/drivers/db2/src/test/java/com/dbx/agent/db2/Db2AgentTest.java
new file mode 100644
index 0000000..1eeb38d
--- /dev/null
+++ b/agents/drivers/db2/src/test/java/com/dbx/agent/db2/Db2AgentTest.java
@@ -0,0 +1,195 @@
+package com.dbx.agent.db2;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import com.dbx.agent.test.JdbcMetadataSqlFake;
+import com.dbx.agent.test.TestSupport;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class Db2AgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new Db2Agent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL ADMIN_CMD('list applications')";
+    }
+
+    @Test
+    void buildsJdbcUrlWithDb2PropertySuffix() {
+        ConnectParams params = new ConnectParams();
+        params.setHost("db.example.com");
+        params.setPort(50000);
+        params.setDatabase("SAMPLE");
+        params.setUrl_params("sslConnection=true");
+
+        assertEquals("jdbc:db2://db.example.com:50000/SAMPLE:sslConnection=true;", Db2Agent.buildUrl(params));
+    }
+
+    @Test
+    void listsAllCatalogSchemasWithoutOwnerTypeFiltering() {
+        Db2Agent agent = new Db2Agent();
+        AtomicReference<String> executedSql = new AtomicReference<>();
+        TestSupport.setPrivateConnection(agent, connection(
+            executedSql,
+            rows(row("SCHEMANAME", "APP"), row("SCHEMANAME", "SZ"), row("SCHEMANAME", "TOOLS"))
+        ));
+
+        List<String> schemas = agent.listSchemas();
+
+        assertEquals(Arrays.asList("APP", "SZ", "TOOLS"), schemas);
+        assertEquals("SELECT SCHEMANAME FROM SYSCAT.SCHEMATA ORDER BY SCHEMANAME", executedSql.get());
+        assertFalse(executedSql.get().contains("OWNERTYPE"));
+    }
+
+    @Test
+    void constrainedTableMetadataUsesDb2CatalogPushdown() {
+        Db2Agent agent = new Db2Agent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listTables("APP", new MetadataListConstraints("ord", 25, 50, List.of("TABLE")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        assertTrue(sql.contains("FROM SYSCAT.TABLES"));
+        assertTrue(sql.contains("TYPE IN (?)"));
+        assertTrue(sql.contains("UPPER(TABNAME) LIKE ? ESCAPE '\\\\'"));
+        assertTrue(sql.endsWith("OFFSET 50 ROWS FETCH NEXT 25 ROWS ONLY"));
+        assertEquals(Arrays.asList("param:1=APP", "param:2=T", "param:3=%O%R%D%"), JdbcMetadataSqlFake.statements.subList(1, 4));
+    }
+
+    @Test
+    void constrainedObjectMetadataUsesDb2CatalogPushdown() {
+        Db2Agent agent = new Db2Agent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listObjects("APP", new MetadataListConstraints("sync", 10, null, List.of("PROCEDURE")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        assertTrue(sql.contains("FROM SYSCAT.PROCEDURES"));
+        assertTrue(sql.contains("ORDER BY CASE OBJECT_TYPE"));
+        assertTrue(sql.endsWith("FETCH FIRST 10 ROWS ONLY"));
+        assertEquals(Arrays.asList("param:1=APP", "param:2=%S%Y%N%C%"), JdbcMetadataSqlFake.statements.subList(1, 3));
+    }
+
+    private static Connection connection(AtomicReference<String> executedSql, ResultSet resultSet) {
+        Statement statement = proxy(Statement.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                if ("executeQuery".equals(method.getName())) {
+                    executedSql.set(String.valueOf(args[0]));
+                    return resultSet;
+                }
+                if ("close".equals(method.getName())) {
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+        return proxy(Connection.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                if ("createStatement".equals(method.getName())) {
+                    return statement;
+                }
+                if ("isClosed".equals(method.getName())) {
+                    return false;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static ResultSet rows(Map<String, Object>... rows) {
+        return proxy(ResultSet.class, new MethodHandler() {
+            private int index = -1;
+
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("next".equals(name)) {
+                    index += 1;
+                    return index < rows.length;
+                }
+                if ("getString".equals(name)) {
+                    Object key = args[0] instanceof Number ? rows[index].keySet().iterator().next() : args[0];
+                    Object value = rows[index].get(key);
+                    return value == null ? null : String.valueOf(value);
+                }
+                if ("close".equals(name)) {
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Map<String, Object> row(Object... values) {
+        Map<String, Object> row = new LinkedHashMap<>();
+        for (int i = 0; i < values.length; i += 2) {
+            row.put(String.valueOf(values[i]), values[i + 1]);
+        }
+        return row;
+    }
+
+    private static <T> T proxy(Class<T> type, final MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) {
+                return handler.handle(method, args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Byte.TYPE.equals(type)) {
+            return (byte) 0;
+        }
+        if (Short.TYPE.equals(type)) {
+            return (short) 0;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        if (Long.TYPE.equals(type)) {
+            return 0L;
+        }
+        if (Float.TYPE.equals(type)) {
+            return 0f;
+        }
+        if (Double.TYPE.equals(type)) {
+            return 0.0d;
+        }
+        if (Character.TYPE.equals(type)) {
+            return '\0';
+        }
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args);
+    }
+}
diff --git a/agents/drivers/etcd/build.gradle b/agents/drivers/etcd/build.gradle
new file mode 100644
index 0000000..d37a950
--- /dev/null
+++ b/agents/drivers/etcd/build.gradle
@@ -0,0 +1,11 @@
+dependencies {
+    implementation 'com.google.code.gson:gson:2.12.1'
+    implementation 'io.etcd:jetcd-core:0.8.6'
+}
+
+tasks.named('shadowJar') {
+    mergeServiceFiles()
+    manifest {
+        attributes('Agent-Label': 'etcd', 'Main-Class': 'com.dbx.agent.etcd.EtcdAgent')
+    }
+}
diff --git a/agents/drivers/etcd/src/main/java/com/dbx/agent/etcd/EtcdAgent.java b/agents/drivers/etcd/src/main/java/com/dbx/agent/etcd/EtcdAgent.java
new file mode 100644
index 0000000..c29286f
--- /dev/null
+++ b/agents/drivers/etcd/src/main/java/com/dbx/agent/etcd/EtcdAgent.java
@@ -0,0 +1,420 @@
+package com.dbx.agent.etcd;
+
+import com.dbx.agent.AgentProtocol;
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import io.grpc.netty.GrpcSslContexts;
+import io.etcd.jetcd.ByteSequence;
+import io.etcd.jetcd.Client;
+import io.etcd.jetcd.ClientBuilder;
+import io.etcd.jetcd.KV;
+import io.etcd.jetcd.KeyValue;
+import io.etcd.jetcd.kv.DeleteResponse;
+import io.etcd.jetcd.kv.GetResponse;
+import io.etcd.jetcd.kv.PutResponse;
+import io.etcd.jetcd.options.GetOption;
+import io.etcd.jetcd.options.PutOption;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.InputStreamReader;
+import java.nio.ByteBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CodingErrorAction;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+public final class EtcdAgent {
+    private static final Gson GSON = new Gson();
+    private static final int DEFAULT_LIMIT = 100;
+    private static final int RPC_TIMEOUT_SECONDS = 30;
+    private static final List<String> CAPABILITIES = Collections.unmodifiableList(Arrays.asList(
+        AgentProtocol.CAPABILITY_CONNECT,
+        AgentProtocol.CAPABILITY_TEST_CONNECTION,
+        AgentProtocol.CAPABILITY_KV
+    ));
+    private static Client client;
+    private static KV kv;
+
+    private EtcdAgent() {
+    }
+
+    private static Object handshakeResult() {
+        return new HandshakeResult(AgentProtocol.PROTOCOL_VERSION, AgentProtocol.PROTOCOL_VERSION, CAPABILITIES);
+    }
+
+    private static Object connect(JsonObject params) throws Exception {
+        JsonObject connection = connectionObject(params);
+        Client nextClient = buildClient(connection);
+        nextClient.getKVClient().get(byteSequence("\0")).get(RPC_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+        closeClient();
+        client = nextClient;
+        kv = client.getKVClient();
+        return Collections.singletonMap("ok", true);
+    }
+
+    static Client buildClient(JsonObject connection) throws Exception {
+        List<String> endpoints = endpoints(connection);
+        ClientBuilder builder = Client.builder().endpoints(endpoints.toArray(String[]::new));
+        String username = stringOrEmpty(connection, "username");
+        String password = stringOrEmpty(connection, "password");
+        if (!username.isBlank()) {
+            builder.user(byteSequence(username));
+            builder.password(byteSequence(password));
+        }
+        if (boolOrDefault(connection, "ssl", false)) {
+            builder.sslContext(sslContext(connection));
+        }
+        return builder.build();
+    }
+
+    static List<String> endpoints(JsonObject connection) {
+        String configured = firstNonBlank(
+            stringOrNull(connection, "etcd_endpoints"),
+            stringOrNull(connection, "endpoints"),
+            stringOrNull(connection, "connection_string")
+        );
+        List<String> result = new ArrayList<>();
+        if (configured != null) {
+            for (String endpoint : configured.split("[,\\n]")) {
+                String normalized = normalizeEndpoint(endpoint.trim(), boolOrDefault(connection, "ssl", false));
+                if (!normalized.isBlank()) {
+                    result.add(normalized);
+                }
+            }
+        }
+        if (result.isEmpty()) {
+            String host = stringOrDefault(connection, "host", "127.0.0.1");
+            int port = intOrDefault(connection, "port", 2379);
+            result.add(normalizeEndpoint(host + ":" + port, boolOrDefault(connection, "ssl", false)));
+        }
+        return result;
+    }
+
+    private static String normalizeEndpoint(String endpoint, boolean tls) {
+        if (endpoint.isBlank()) {
+            return "";
+        }
+        if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
+            return endpoint;
+        }
+        return (tls ? "https://" : "http://") + endpoint;
+    }
+
+    private static SslContext sslContext(JsonObject connection) throws Exception {
+        SslContextBuilder builder = GrpcSslContexts.forClient();
+        String ca = stringOrEmpty(connection, "ca_cert_path");
+        if (!ca.isBlank()) {
+            builder.trustManager(new File(ca));
+        }
+        String cert = firstNonBlank(stringOrNull(connection, "client_cert_path"), stringOrNull(connection, "cert_path"));
+        String key = firstNonBlank(stringOrNull(connection, "client_key_path"), stringOrNull(connection, "key_path"));
+        if ((cert == null) != (key == null)) {
+            throw new IllegalArgumentException("Client certificate and key must be provided together");
+        }
+        if (cert != null) {
+            builder.keyManager(new File(cert), new File(key));
+        }
+        return builder.build();
+    }
+
+    private static Object listPrefix(JsonObject params) throws Exception {
+        KV active = requireKv();
+        String prefix = stringOrDefault(params, "prefix", "");
+        int limit = intOrDefault(params, "limit", DEFAULT_LIMIT);
+        String continuation = stringOrNull(params, "continuation");
+        ByteSequence start = continuation == null || continuation.isBlank()
+            ? prefixStart(prefix)
+            : ByteSequence.from(Base64.getDecoder().decode(continuation));
+        GetOption option = GetOption.newBuilder()
+            .withRange(prefixEnd(byteSequence(prefix)))
+            .withLimit(Math.max(1, limit))
+            .withSortField(GetOption.SortTarget.KEY)
+            .withSortOrder(GetOption.SortOrder.ASCEND)
+            .build();
+        GetResponse response = active.get(start, option).get(RPC_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+
+        List<Map<String, Object>> keys = new ArrayList<>();
+        List<KeyValue> kvs = response.getKvs();
+        for (KeyValue item : kvs) {
+            Map<String, Object> row = metadata(item);
+            row.put("key", displayBytes(item.getKey().getBytes()));
+            keys.add(row);
+        }
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("keys", keys);
+        result.put("continuation", response.isMore() && !kvs.isEmpty() ? nextContinuation(kvs.get(kvs.size() - 1)) : null);
+        result.put("revision", response.getHeader().getRevision());
+        return result;
+    }
+
+    private static Object get(JsonObject params) throws Exception {
+        KV active = requireKv();
+        String key = params.get("key").getAsString();
+        GetResponse response = active.get(byteSequence(key)).get(RPC_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+        Map<String, Object> result = new LinkedHashMap<>();
+        if (response.getKvs().isEmpty()) {
+            result.put("found", false);
+            result.put("key", null);
+            result.put("value", null);
+            result.put("metadata", null);
+            return result;
+        }
+        KeyValue item = response.getKvs().get(0);
+        result.put("found", true);
+        result.put("key", displayBytes(item.getKey().getBytes()));
+        result.put("value", valueObject(item.getValue().getBytes()));
+        result.put("metadata", metadata(item));
+        return result;
+    }
+
+    private static Object put(JsonObject params) throws Exception {
+        KV active = requireKv();
+        String key = params.get("key").getAsString();
+        byte[] value = parseValue(params.getAsJsonObject("value"));
+        JsonElement leaseElement = params.get("lease");
+        PutResponse response;
+        if (leaseElement != null && !leaseElement.isJsonNull()) {
+            PutOption option = PutOption.newBuilder().withLeaseId(leaseElement.getAsLong()).build();
+            response = active.put(byteSequence(key), ByteSequence.from(value), option).get(RPC_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+        } else {
+            response = active.put(byteSequence(key), ByteSequence.from(value)).get(RPC_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+        }
+        return Collections.singletonMap("revision", response.getHeader().getRevision());
+    }
+
+    private static Object delete(JsonObject params) throws Exception {
+        KV active = requireKv();
+        DeleteResponse response =
+            active.delete(byteSequence(params.get("key").getAsString())).get(RPC_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("deleted", response.getDeleted());
+        result.put("revision", response.getHeader().getRevision());
+        return result;
+    }
+
+    private static Object dispatch(String method, JsonObject params) throws Exception {
+        return switch (method) {
+            case AgentProtocol.METHOD_HANDSHAKE -> handshakeResult();
+            case AgentProtocol.METHOD_CONNECT, AgentProtocol.METHOD_TEST_CONNECTION -> connect(params);
+            case AgentProtocol.KV_METHOD_LIST_PREFIX -> listPrefix(params);
+            case AgentProtocol.KV_METHOD_GET -> get(params);
+            case AgentProtocol.KV_METHOD_PUT -> put(params);
+            case AgentProtocol.KV_METHOD_DELETE -> delete(params);
+            case AgentProtocol.METHOD_DISCONNECT -> {
+                closeClient();
+                yield Collections.singletonMap("ok", true);
+            }
+            case AgentProtocol.METHOD_SHUTDOWN -> {
+                closeClient();
+                System.exit(0);
+                yield Collections.singletonMap("ok", true);
+            }
+            default -> throw new IllegalArgumentException("Unknown method: " + method);
+        };
+    }
+
+    static String handleRequest(String line) {
+        JsonObject req = JsonParser.parseString(line).getAsJsonObject();
+        JsonElement id = req.get("id");
+        String method = req.get("method").getAsString();
+        JsonObject params = req.has("params") && req.get("params").isJsonObject()
+            ? req.getAsJsonObject("params")
+            : new JsonObject();
+
+        JsonObject response = new JsonObject();
+        response.addProperty("jsonrpc", "2.0");
+        response.add("id", id);
+
+        try {
+            Object result = dispatch(method, params);
+            response.add("result", GSON.toJsonTree(result));
+        } catch (Exception e) {
+            JsonObject error = new JsonObject();
+            error.addProperty("code", -1);
+            error.addProperty("message", e.getMessage() == null ? "Unknown error" : e.getMessage());
+            response.add("error", error);
+        }
+
+        return GSON.toJson(response);
+    }
+
+    private static JsonObject connectionObject(JsonObject params) {
+        JsonElement connection = params.get("connection");
+        return connection != null && connection.isJsonObject() ? connection.getAsJsonObject() : params;
+    }
+
+    private static KV requireKv() {
+        if (kv == null) {
+            throw new IllegalStateException("Not connected");
+        }
+        return kv;
+    }
+
+    private static void closeClient() {
+        if (kv != null) {
+            kv.close();
+            kv = null;
+        }
+        if (client != null) {
+            client.close();
+            client = null;
+        }
+    }
+
+    private static ByteSequence byteSequence(String value) {
+        return ByteSequence.from(value, java.nio.charset.StandardCharsets.UTF_8);
+    }
+
+    private static ByteSequence prefixEnd(ByteSequence prefix) {
+        byte[] bytes = prefix.getBytes();
+        if (bytes.length == 0) {
+            return ByteSequence.from(new byte[] {0});
+        }
+        byte[] end = Arrays.copyOf(bytes, bytes.length);
+        for (int i = end.length - 1; i >= 0; i--) {
+            if ((end[i] & 0xff) < 0xff) {
+                end[i]++;
+                return ByteSequence.from(Arrays.copyOf(end, i + 1));
+            }
+        }
+        return ByteSequence.from(new byte[] {0});
+    }
+
+    private static ByteSequence prefixStart(String prefix) {
+        if (prefix.isEmpty()) {
+            return ByteSequence.from(new byte[] {0});
+        }
+        return byteSequence(prefix);
+    }
+
+    private static String nextContinuation(KeyValue item) {
+        byte[] key = item.getKey().getBytes();
+        byte[] next = Arrays.copyOf(key, key.length + 1);
+        next[next.length - 1] = 0;
+        return Base64.getEncoder().encodeToString(next);
+    }
+
+    private static Map<String, Object> metadata(KeyValue item) {
+        Map<String, Object> metadata = new LinkedHashMap<>();
+        metadata.put("createRevision", item.getCreateRevision());
+        metadata.put("modRevision", item.getModRevision());
+        metadata.put("version", item.getVersion());
+        metadata.put("lease", item.getLease());
+        metadata.put("valueSize", item.getValue().size());
+        return metadata;
+    }
+
+    private static Map<String, Object> valueObject(byte[] bytes) {
+        Map<String, Object> value = new LinkedHashMap<>();
+        String utf8 = strictUtf8(bytes);
+        if (utf8 != null) {
+            value.put("encoding", "utf8");
+            value.put("data", utf8);
+        } else {
+            value.put("encoding", "base64");
+            value.put("data", Base64.getEncoder().encodeToString(bytes));
+        }
+        return value;
+    }
+
+    private static byte[] parseValue(JsonObject value) {
+        String encoding = stringOrDefault(value, "encoding", "utf8");
+        String data = stringOrDefault(value, "data", "");
+        if ("base64".equals(encoding)) {
+            return Base64.getDecoder().decode(data);
+        }
+        if (!"utf8".equals(encoding)) {
+            throw new IllegalArgumentException("Unsupported value encoding: " + encoding);
+        }
+        return data.getBytes(java.nio.charset.StandardCharsets.UTF_8);
+    }
+
+    private static String displayBytes(byte[] bytes) {
+        String utf8 = strictUtf8(bytes);
+        return utf8 == null ? Base64.getEncoder().encodeToString(bytes) : utf8;
+    }
+
+    private static String strictUtf8(byte[] bytes) {
+        CharsetDecoder decoder = java.nio.charset.StandardCharsets.UTF_8.newDecoder()
+            .onMalformedInput(CodingErrorAction.REPORT)
+            .onUnmappableCharacter(CodingErrorAction.REPORT);
+        try {
+            return decoder.decode(ByteBuffer.wrap(bytes)).toString();
+        } catch (CharacterCodingException e) {
+            return null;
+        }
+    }
+
+    private static String stringOrNull(JsonObject object, String key) {
+        JsonElement element = object.get(key);
+        return element == null || element.isJsonNull() ? null : element.getAsString();
+    }
+
+    private static String stringOrEmpty(JsonObject object, String key) {
+        return stringOrDefault(object, key, "");
+    }
+
+    private static String stringOrDefault(JsonObject object, String key, String fallback) {
+        String value = stringOrNull(object, key);
+        return value == null ? fallback : value;
+    }
+
+    private static int intOrDefault(JsonObject object, String key, int fallback) {
+        JsonElement element = object.get(key);
+        return element == null || element.isJsonNull() ? fallback : element.getAsInt();
+    }
+
+    private static boolean boolOrDefault(JsonObject object, String key, boolean fallback) {
+        JsonElement element = object.get(key);
+        return element == null || element.isJsonNull() ? fallback : element.getAsBoolean();
+    }
+
+    private static String firstNonBlank(String... values) {
+        for (String value : values) {
+            if (value != null && !value.isBlank()) {
+                return value;
+            }
+        }
+        return null;
+    }
+
+    public static void main(String[] args) throws Exception {
+        System.out.println("{\"ready\":true}");
+        System.out.flush();
+
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        while (true) {
+            String line = reader.readLine();
+            if (line == null) {
+                break;
+            }
+
+            System.out.println(handleRequest(line));
+            System.out.flush();
+        }
+    }
+
+    private static final class HandshakeResult {
+        private final int protocolVersion;
+        private final int agentProtocolVersion;
+        private final List<String> capabilities;
+
+        private HandshakeResult(int protocolVersion, int agentProtocolVersion, List<String> capabilities) {
+            this.protocolVersion = protocolVersion;
+            this.agentProtocolVersion = agentProtocolVersion;
+            this.capabilities = capabilities;
+        }
+    }
+}
diff --git a/agents/drivers/etcd/src/test/java/com/dbx/agent/etcd/EtcdAgentTest.java b/agents/drivers/etcd/src/test/java/com/dbx/agent/etcd/EtcdAgentTest.java
new file mode 100644
index 0000000..65c205d
--- /dev/null
+++ b/agents/drivers/etcd/src/test/java/com/dbx/agent/etcd/EtcdAgentTest.java
@@ -0,0 +1,55 @@
+package com.dbx.agent.etcd;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+final class EtcdAgentTest {
+    @Test
+    void handshakeAdvertisesKvCapability() {
+        String response = EtcdAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"handshake\",\"params\":{}}"
+        );
+
+        JsonObject result = JsonParser.parseString(response).getAsJsonObject().getAsJsonObject("result");
+
+        Assertions.assertEquals(1, result.get("protocolVersion").getAsInt());
+        Assertions.assertTrue(result.getAsJsonArray("capabilities").contains(JsonParser.parseString("\"kv\"")));
+        Assertions.assertTrue(result.getAsJsonArray("capabilities").contains(JsonParser.parseString("\"connect\"")));
+    }
+
+    @Test
+    void endpointsUseConfiguredListAndScheme() {
+        JsonObject connection = JsonParser.parseString(
+            "{\"endpoints\":\"etcd-1:2379,https://etcd-2:2379\",\"ssl\":true}"
+        ).getAsJsonObject();
+
+        Assertions.assertEquals(
+            List.of("https://etcd-1:2379", "https://etcd-2:2379"),
+            EtcdAgent.endpoints(connection)
+        );
+    }
+
+    @Test
+    void endpointsFallbackToHostPort() {
+        JsonObject connection = JsonParser.parseString(
+            "{\"host\":\"127.0.0.1\",\"port\":2379}"
+        ).getAsJsonObject();
+
+        Assertions.assertEquals(List.of("http://127.0.0.1:2379"), EtcdAgent.endpoints(connection));
+    }
+
+    @Test
+    void kvMethodDispatchReturnsJsonRpcErrorWhenDisconnected() {
+        String response = EtcdAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"kv_get\",\"params\":{\"key\":\"/app/name\"}}"
+        );
+
+        JsonObject error = JsonParser.parseString(response).getAsJsonObject().getAsJsonObject("error");
+
+        Assertions.assertEquals(-1, error.get("code").getAsInt());
+        Assertions.assertEquals("Not connected", error.get("message").getAsString());
+    }
+}
diff --git a/agents/drivers/exasol/build.gradle b/agents/drivers/exasol/build.gradle
new file mode 100644
index 0000000..71dda62
--- /dev/null
+++ b/agents/drivers/exasol/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.exasol:exasol-jdbc:26.2.7'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Exasol', 'Main-Class': 'com.dbx.agent.exasol.ExasolAgent')
+    }
+}
diff --git a/agents/drivers/exasol/src/main/java/com/dbx/agent/exasol/ExasolAgent.java b/agents/drivers/exasol/src/main/java/com/dbx/agent/exasol/ExasolAgent.java
new file mode 100644
index 0000000..8dd7bdd
--- /dev/null
+++ b/agents/drivers/exasol/src/main/java/com/dbx/agent/exasol/ExasolAgent.java
@@ -0,0 +1,22 @@
+package com.dbx.agent.exasol;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+
+public final class ExasolAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile EXASOL_PROFILE = new JdbcAgentProfile(
+        "com.exasol.jdbc.EXADriver",
+        "jdbc:exa:{host}:{port};schema={database}",
+        8563,
+        true
+    );
+
+    public ExasolAgent() {
+        super(EXASOL_PROFILE);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new ExasolAgent()).run();
+    }
+}
diff --git a/agents/drivers/firebird/build.gradle b/agents/drivers/firebird/build.gradle
new file mode 100644
index 0000000..701aad5
--- /dev/null
+++ b/agents/drivers/firebird/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'org.firebirdsql.jdbc:jaybird:6.0.5'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Firebird', 'Main-Class': 'com.dbx.agent.firebird.FirebirdAgent')
+    }
+}
diff --git a/agents/drivers/firebird/src/main/java/com/dbx/agent/firebird/FirebirdAgent.java b/agents/drivers/firebird/src/main/java/com/dbx/agent/firebird/FirebirdAgent.java
new file mode 100644
index 0000000..ed57d29
--- /dev/null
+++ b/agents/drivers/firebird/src/main/java/com/dbx/agent/firebird/FirebirdAgent.java
@@ -0,0 +1,22 @@
+package com.dbx.agent.firebird;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+
+public final class FirebirdAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile FIREBIRD_PROFILE = new JdbcAgentProfile(
+        "org.firebirdsql.jdbc.FBDriver",
+        "jdbc:firebirdsql://{host}:{port}/{database}",
+        3050,
+        true
+    );
+
+    public FirebirdAgent() {
+        super(FIREBIRD_PROFILE);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new FirebirdAgent()).run();
+    }
+}
diff --git a/agents/drivers/gbase8a/build.gradle b/agents/drivers/gbase8a/build.gradle
new file mode 100644
index 0000000..a066170
--- /dev/null
+++ b/agents/drivers/gbase8a/build.gradle
@@ -0,0 +1,12 @@
+dependencies {
+    implementation files('libs/gbase-connector-java-9.5.0.10-build1-bin.jar')
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes(
+            'Agent-Label': 'GBase 8a',
+            'Main-Class': 'com.dbx.agent.gbase8a.Gbase8aAgent'
+        )
+    }
+}
diff --git a/agents/drivers/gbase8a/src/main/java/com/dbx/agent/gbase8a/Gbase8aAgent.java b/agents/drivers/gbase8a/src/main/java/com/dbx/agent/gbase8a/Gbase8aAgent.java
new file mode 100644
index 0000000..92ba7cc
--- /dev/null
+++ b/agents/drivers/gbase8a/src/main/java/com/dbx/agent/gbase8a/Gbase8aAgent.java
@@ -0,0 +1,345 @@
+package com.dbx.agent.gbase8a;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.QueryPageOptions;
+import com.dbx.agent.QueryPageResult;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.StandardJdbcMetadata;
+import com.dbx.agent.TableInfo;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+
+public final class Gbase8aAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile GBASE8A_PROFILE = new JdbcAgentProfile(
+        "com.gbase.jdbc.Driver",
+        "jdbc:gbase://{host}:{port}/{database}?useSSL=false",
+        5258,
+        false,
+        java.util.Collections.emptySet(),
+        java.util.Arrays.asList("TABLE", "VIEW", "BASE TABLE"),
+        "`",
+        "USE",
+        true,
+        false,
+        true,
+        false
+    );
+
+    public Gbase8aAgent() {
+        super(GBASE8A_PROFILE);
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        return super.executeQuery(sql, schema, withoutFetchSize(options));
+    }
+
+    @Override
+    public QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {
+        return super.executeQueryPage(sql, schema, withoutFetchSize(options));
+    }
+
+    @Override
+    public QueryPageResult startTableRead(String sql, String schema, QueryPageOptions options) {
+        return super.startTableRead(sql, schema, withoutFetchSize(options));
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return queryTables(schema, MetadataListConstraints.NONE);
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        return queryTables(schema, MetadataListConstraints.orNone(constraints));
+    }
+
+    private List<TableInfo> queryTables(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            if (!constraints.includesTableLikeTypes()) {
+                return List.of();
+            }
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            StringBuilder sql = new StringBuilder("SELECT TABLE_NAME, TABLE_TYPE FROM information_schema.TABLES WHERE ");
+            if (hasSchema(schema)) {
+                sql.append("TABLE_SCHEMA = ?");
+                args.add(schema);
+            } else {
+                sql.append("TABLE_SCHEMA NOT IN ('information_schema', 'performance_schema', 'gclusterdb', 'gctmpdb')");
+            }
+            appendGbase8aTableTypePredicate(sql, args, constraints);
+            appendNameFilter(sql, args, "TABLE_NAME", constraints);
+            sql.append(hasSchema(schema) ? " ORDER BY TABLE_NAME" : " ORDER BY TABLE_SCHEMA, TABLE_NAME");
+            appendLimitOffset(sql, args, constraints);
+            try (PreparedStatement stmt = requireConnection().prepareStatement(sql.toString())) {
+                bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String tableType = rs.getString("TABLE_TYPE");
+                        if ("BASE TABLE".equals(tableType)) {
+                            tableType = "TABLE";
+                        }
+                        result.add(new TableInfo(rs.getString("TABLE_NAME"), tableType, null));
+                    }
+                }
+            }
+            result.sort(Comparator.comparing(TableInfo::getName));
+            MetadataListConstraints guard = constraints.hasLimit() ? constraints.withoutPaging() : constraints;
+            return guard.filterTables(result);
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return queryObjects(schema, MetadataListConstraints.NONE);
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        return queryObjects(schema, MetadataListConstraints.orNone(constraints));
+    }
+
+    private List<ObjectInfo> queryObjects(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            boolean includeTables = constraints.includesTableLikeTypes();
+            boolean includeRoutines = includesRoutineTypes(constraints);
+            if (!includeTables && !includeRoutines) {
+                return List.of();
+            }
+            List<ObjectInfo> result = new ArrayList<>();
+            if (includeTables) {
+                MetadataListConstraints tableConstraints = includeRoutines
+                    ? new MetadataListConstraints(constraints.getFilter(), null, null, tableLikeObjectTypes(constraints))
+                    : constraints;
+                result.addAll(StandardJdbcMetadata.INSTANCE.listObjects(queryTables(schema, tableConstraints), schema));
+            }
+            if (includeRoutines) {
+                MetadataListConstraints routineConstraints = includeTables
+                    ? new MetadataListConstraints(constraints.getFilter(), null, null, routineObjectTypes(constraints))
+                    : constraints;
+                appendRoutines(result, schema, routineConstraints);
+            }
+            boolean singlePagedSource = includeTables != includeRoutines && constraints.hasLimit();
+            MetadataListConstraints guard = singlePagedSource ? constraints.withoutPaging() : constraints;
+            return guard.filterObjects(result);
+        });
+    }
+
+    private void appendRoutines(List<ObjectInfo> result, String schema, MetadataListConstraints constraints) throws Exception {
+        StringBuilder sql = new StringBuilder();
+        List<Object> args = new ArrayList<>();
+        boolean hasSchema = hasSchema(schema);
+        if (hasSchema) {
+            sql.append("SELECT ROUTINE_NAME, ROUTINE_TYPE, ROUTINE_COMMENT FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ?");
+            args.add(schema);
+        } else {
+            sql.append("SELECT ROUTINE_SCHEMA, ROUTINE_NAME, ROUTINE_TYPE, ROUTINE_COMMENT FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA NOT IN ('information_schema', 'performance_schema', 'gclusterdb', 'gctmpdb')");
+        }
+        appendGbase8aRoutineTypePredicate(sql, args, constraints);
+        appendNameFilter(sql, args, "ROUTINE_NAME", constraints);
+        sql.append(hasSchema ? " ORDER BY ROUTINE_NAME" : " ORDER BY ROUTINE_SCHEMA, ROUTINE_NAME");
+        appendLimitOffset(sql, args, constraints);
+        try (PreparedStatement stmt = requireConnection().prepareStatement(sql.toString())) {
+            bind(stmt, args);
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    String routineSchema = hasSchema ? schema : rs.getString("ROUTINE_SCHEMA");
+                    result.add(new ObjectInfo(
+                        rs.getString("ROUTINE_NAME"),
+                        normalizeRoutineType(rs.getString("ROUTINE_TYPE")),
+                        routineSchema,
+                        rs.getString("ROUTINE_COMMENT")
+                    ));
+                }
+            }
+        }
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        return unchecked(() -> {
+            String normalizedType = objectType.toUpperCase(Locale.ROOT);
+            String sql = switch (normalizedType) {
+                case "VIEW" -> "SHOW CREATE VIEW ";
+                case "PROCEDURE" -> "SHOW CREATE PROCEDURE ";
+                case "FUNCTION" -> "SHOW CREATE FUNCTION ";
+                default -> throw new IllegalArgumentException("Unsupported object type: " + objectType);
+            };
+            String qualifiedName = hasSchema(schema)
+                ? JdbcIdentifiers.INSTANCE.backtick(schema) + "." + JdbcIdentifiers.INSTANCE.backtick(name)
+                : JdbcIdentifiers.INSTANCE.backtick(name);
+
+            String source = "";
+            try (Statement stmt = requireConnection().createStatement();
+                 ResultSet rs = stmt.executeQuery(sql + qualifiedName)) {
+                if (rs.next()) {
+                    // SHOW CREATE result layouts vary by GBase driver version, so locate the definition column by label.
+                    ResultSetMetaData metadata = rs.getMetaData();
+                    for (int index = 1; index <= metadata.getColumnCount(); index++) {
+                        String label = metadata.getColumnLabel(index);
+                        if (label != null && label.toUpperCase(Locale.ROOT).startsWith("CREATE ")) {
+                            String value = rs.getString(index);
+                            source = value == null ? "" : value;
+                            break;
+                        }
+                    }
+                }
+            }
+            return new ObjectSource(name, normalizedType, schema, source);
+        });
+    }
+
+    private static void appendGbase8aTableTypePredicate(
+        StringBuilder sql,
+        List<Object> args,
+        MetadataListConstraints constraints
+    ) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> tableTypes = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            tableTypes.add("BASE TABLE");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            tableTypes.add("VIEW");
+        }
+        if (tableTypes.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND TABLE_TYPE IN (").append(placeholders(tableTypes.size())).append(")");
+        args.addAll(tableTypes);
+    }
+
+    private static void appendGbase8aRoutineTypePredicate(
+        StringBuilder sql,
+        List<Object> args,
+        MetadataListConstraints constraints
+    ) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> routineTypes = new ArrayList<>();
+        if (constraints.objectTypeAllowed("PROCEDURE")) {
+            routineTypes.add("PROCEDURE");
+        }
+        if (constraints.objectTypeAllowed("FUNCTION")) {
+            routineTypes.add("FUNCTION");
+        }
+        if (routineTypes.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND ROUTINE_TYPE IN (").append(placeholders(routineTypes.size())).append(")");
+        args.addAll(routineTypes);
+    }
+
+    private static void appendNameFilter(StringBuilder sql, List<Object> args, String column, MetadataListConstraints constraints) {
+        if (!constraints.hasFilter()) {
+            return;
+        }
+        sql.append(" AND UPPER(").append(column).append(") LIKE ? ESCAPE '\\\\'");
+        args.add(constraints.fuzzyLikePattern().toUpperCase(Locale.ROOT));
+    }
+
+    private static void appendLimitOffset(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasLimit()) {
+            return;
+        }
+        sql.append(" LIMIT ?");
+        args.add(constraints.getLimit());
+        if (constraints.hasOffset()) {
+            sql.append(" OFFSET ?");
+            args.add(constraints.getOffset());
+        }
+    }
+
+    private static boolean hasSchema(String schema) {
+        return schema != null && !schema.trim().isEmpty();
+    }
+
+    private static boolean includesRoutineTypes(MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return true;
+        }
+        return constraints.objectTypeAllowed("PROCEDURE") || constraints.objectTypeAllowed("FUNCTION");
+    }
+
+    private static List<String> tableLikeObjectTypes(MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return null;
+        }
+        List<String> result = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            result.add("TABLE");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            result.add("VIEW");
+        }
+        return result;
+    }
+
+    private static List<String> routineObjectTypes(MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return null;
+        }
+        List<String> result = new ArrayList<>();
+        if (constraints.objectTypeAllowed("PROCEDURE")) {
+            result.add("PROCEDURE");
+        }
+        if (constraints.objectTypeAllowed("FUNCTION")) {
+            result.add("FUNCTION");
+        }
+        return result;
+    }
+
+    private static String placeholders(int count) {
+        return String.join(", ", java.util.Collections.nCopies(count, "?"));
+    }
+
+    private static void bind(PreparedStatement stmt, List<Object> args) throws Exception {
+        for (int index = 0; index < args.size(); index += 1) {
+            Object arg = args.get(index);
+            if (arg instanceof Integer) {
+                stmt.setInt(index + 1, (Integer) arg);
+            } else {
+                stmt.setString(index + 1, String.valueOf(arg));
+            }
+        }
+    }
+
+    private static String normalizeRoutineType(String routineType) {
+        if (routineType == null || routineType.trim().isEmpty()) {
+            return "PROCEDURE";
+        }
+        return routineType.trim().toUpperCase(Locale.ROOT);
+    }
+
+    private static ExecuteQueryOptions withoutFetchSize(ExecuteQueryOptions options) {
+        return new ExecuteQueryOptions(options.getMaxRows(), null, options.getTimeoutSecs());
+    }
+
+    private static QueryPageOptions withoutFetchSize(QueryPageOptions options) {
+        return new QueryPageOptions(options.getPageSize(), null, options.getMaxRows(), options.getTimeoutSecs());
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new Gbase8aAgent()).run();
+    }
+}
diff --git a/agents/drivers/gbase8a/src/test/java/com/dbx/agent/gbase8a/Gbase8aAgentTest.java b/agents/drivers/gbase8a/src/test/java/com/dbx/agent/gbase8a/Gbase8aAgentTest.java
new file mode 100644
index 0000000..e17769d
--- /dev/null
+++ b/agents/drivers/gbase8a/src/test/java/com/dbx/agent/gbase8a/Gbase8aAgentTest.java
@@ -0,0 +1,265 @@
+package com.dbx.agent.gbase8a;
+
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.test.TestSupport;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+class Gbase8aAgentTest {
+    @Test
+    void listObjectsIncludesRoutinesFromInformationSchema() {
+        List<String> sql = new ArrayList<>();
+        Gbase8aAgent agent = new Gbase8aAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql,
+            resultSet(
+                new String[]{"TABLE_NAME", "TABLE_TYPE"},
+                new Object[][]{{"orders", "BASE TABLE"}}
+            ),
+            resultSet(
+                new String[]{"ROUTINE_NAME", "ROUTINE_TYPE", "ROUTINE_COMMENT"},
+                new Object[][]{{"refresh_orders", "PROCEDURE", "proc comment"}, {"format_order", "FUNCTION", null}}
+            )
+        ));
+
+        List<ObjectInfo> objects = agent.listObjects("app");
+
+        Assertions.assertEquals(3, objects.size());
+        Assertions.assertEquals("orders", objects.get(0).getName());
+        Assertions.assertEquals("TABLE", objects.get(0).getObject_type());
+        Assertions.assertEquals("refresh_orders", objects.get(1).getName());
+        Assertions.assertEquals("PROCEDURE", objects.get(1).getObject_type());
+        Assertions.assertEquals("app", objects.get(1).getSchema());
+        Assertions.assertEquals("proc comment", objects.get(1).getComment());
+        Assertions.assertEquals("format_order", objects.get(2).getName());
+        Assertions.assertEquals("FUNCTION", objects.get(2).getObject_type());
+        Assertions.assertEquals("app", objects.get(2).getSchema());
+        Assertions.assertTrue(sql.get(1).contains("FROM information_schema.ROUTINES"), sql.get(1));
+        Assertions.assertTrue(sql.get(1).contains("ROUTINE_SCHEMA = ?"), sql.get(1));
+    }
+
+    @Test
+    void constrainedListTablesPushesFilterTypeAndLimit() {
+        List<String> sql = new ArrayList<>();
+        Gbase8aAgent agent = new Gbase8aAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql,
+            resultSet(
+                new String[]{"TABLE_NAME", "TABLE_TYPE"},
+                new Object[][]{{"user_order", "BASE TABLE"}}
+            )
+        ));
+
+        List<TableInfo> tables = agent.listTables(
+            "app",
+            new MetadataListConstraints("user", 1, 1, List.of("TABLE"))
+        );
+
+        Assertions.assertEquals(1, tables.size());
+        Assertions.assertEquals("user_order", tables.get(0).getName());
+        Assertions.assertTrue(sql.get(0).contains("TABLE_TYPE IN (?)"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("UPPER(TABLE_NAME) LIKE ?"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("LIMIT ?"), sql.get(0));
+    }
+
+    @Test
+    void constrainedListObjectsKeepsCustomRoutineMetadata() {
+        List<String> sql = new ArrayList<>();
+        Gbase8aAgent agent = new Gbase8aAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql,
+            resultSet(
+                new String[]{"ROUTINE_NAME", "ROUTINE_TYPE", "ROUTINE_COMMENT"},
+                new Object[][]{{"refresh_orders", "PROCEDURE", "proc comment"}, {"format_order", "FUNCTION", null}}
+            )
+        ));
+
+        List<ObjectInfo> objects = agent.listObjects(
+            "app",
+            new MetadataListConstraints("format", 1, null, List.of("FUNCTION"))
+        );
+
+        Assertions.assertEquals(1, objects.size());
+        Assertions.assertEquals("format_order", objects.get(0).getName());
+        Assertions.assertEquals("FUNCTION", objects.get(0).getObject_type());
+        Assertions.assertTrue(sql.get(0).contains("ROUTINE_TYPE IN (?)"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("UPPER(ROUTINE_NAME) LIKE ?"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("LIMIT ?"), sql.get(0));
+    }
+
+    @Test
+    void getObjectSourceUsesShowCreateForRoutines() {
+        List<String> sql = new ArrayList<>();
+        Gbase8aAgent agent = new Gbase8aAgent();
+        TestSupport.setPrivateConnection(agent, statementConnection(sql, resultSet(
+            new String[]{"Procedure", "sql_mode", "Create Procedure"},
+            new Object[][]{{"refresh_orders", "", "CREATE PROCEDURE `refresh_orders`() SELECT 1"}}
+        )));
+
+        ObjectSource source = agent.getObjectSource("app", "refresh_orders", "procedure");
+
+        Assertions.assertEquals("PROCEDURE", source.getObject_type());
+        Assertions.assertEquals("app", source.getSchema());
+        Assertions.assertEquals("CREATE PROCEDURE `refresh_orders`() SELECT 1", source.getSource());
+        Assertions.assertEquals("SHOW CREATE PROCEDURE `app`.`refresh_orders`", sql.get(0));
+    }
+
+    @Test
+    void getObjectSourceFindsDefinitionAcrossDriverResultLayouts() {
+        List<String> sql = new ArrayList<>();
+        Gbase8aAgent agent = new Gbase8aAgent();
+        TestSupport.setPrivateConnection(agent, statementConnection(sql, resultSet(
+            new String[]{"Function", "Create Function", "character_set_client", "Database Collation"},
+            new Object[][]{{"format_order", "CREATE FUNCTION `format_order`() RETURNS INT RETURN 1", "utf8", "utf8_bin"}}
+        )));
+
+        ObjectSource source = agent.getObjectSource("app`prod", "format`order", "FUNCTION");
+
+        Assertions.assertEquals("CREATE FUNCTION `format_order`() RETURNS INT RETURN 1", source.getSource());
+        Assertions.assertEquals("SHOW CREATE FUNCTION `app``prod`.`format``order`", sql.get(0));
+    }
+
+    @Test
+    void getObjectSourceSupportsViewsAndRejectsOtherObjectTypes() {
+        List<String> sql = new ArrayList<>();
+        Gbase8aAgent agent = new Gbase8aAgent();
+        TestSupport.setPrivateConnection(agent, statementConnection(sql, resultSet(
+            new String[]{"View", "Create View"},
+            new Object[][]{{"active_orders", "CREATE VIEW `active_orders` AS SELECT 1"}}
+        )));
+
+        ObjectSource source = agent.getObjectSource("app", "active_orders", "VIEW");
+
+        Assertions.assertEquals("CREATE VIEW `active_orders` AS SELECT 1", source.getSource());
+        Assertions.assertEquals("SHOW CREATE VIEW `app`.`active_orders`", sql.get(0));
+        Assertions.assertThrows(
+            IllegalArgumentException.class,
+            () -> agent.getObjectSource("app", "orders", "TABLE")
+        );
+    }
+
+    private static Connection preparedConnection(List<String> sql, ResultSet... resultSets) {
+        int[] resultSetIndex = {0};
+        PreparedStatement statement = proxy(PreparedStatement.class, (method, args) -> {
+            if ("executeQuery".equals(method.getName())) {
+                int current = Math.min(resultSetIndex[0], resultSets.length - 1);
+                resultSetIndex[0] += 1;
+                return resultSets[current];
+            }
+            if ("setString".equals(method.getName()) || "setInt".equals(method.getName()) || "close".equals(method.getName())) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+        return proxy(Connection.class, (method, args) -> {
+            if ("prepareStatement".equals(method.getName())) {
+                sql.add(String.valueOf(args[0]));
+                return statement;
+            }
+            if ("isClosed".equals(method.getName())) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static Connection statementConnection(List<String> sql, ResultSet resultSet) {
+        Statement statement = proxy(Statement.class, (method, args) -> {
+            if ("executeQuery".equals(method.getName())) {
+                sql.add(String.valueOf(args[0]));
+                return resultSet;
+            }
+            if ("close".equals(method.getName())) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+        return proxy(Connection.class, (method, args) -> {
+            if ("createStatement".equals(method.getName())) {
+                return statement;
+            }
+            if ("isClosed".equals(method.getName())) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSet resultSet(String[] columns, Object[][] rows) {
+        int[] index = {-1};
+        ResultSetMetaData metadata = proxy(ResultSetMetaData.class, (method, args) -> {
+            if ("getColumnCount".equals(method.getName())) {
+                return columns.length;
+            }
+            if ("getColumnLabel".equals(method.getName())) {
+                return columns[((Number) args[0]).intValue() - 1];
+            }
+            return defaultValue(method.getReturnType());
+        });
+        return proxy(ResultSet.class, (method, args) -> {
+            switch (method.getName()) {
+                case "next":
+                    index[0] += 1;
+                    return index[0] < rows.length;
+                case "getString":
+                    Object value = columnValue(columns, rows[index[0]], args[0]);
+                    return value == null ? null : String.valueOf(value);
+                case "getMetaData":
+                    return metadata;
+                case "close":
+                    return null;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Object columnValue(String[] columns, Object[] row, Object key) {
+        if (key instanceof Number) {
+            return row[((Number) key).intValue() - 1];
+        }
+        for (int i = 0; i < columns.length; i++) {
+            if (columns[i].equalsIgnoreCase(String.valueOf(key))) {
+                return row[i];
+            }
+        }
+        return null;
+    }
+
+    private static <T> T proxy(Class<T> type, MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                return handler.handle(method, args == null ? new Object[0] : args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (type == Boolean.TYPE) return false;
+        if (type == Byte.TYPE) return (byte) 0;
+        if (type == Short.TYPE) return (short) 0;
+        if (type == Integer.TYPE) return 0;
+        if (type == Long.TYPE) return 0L;
+        if (type == Float.TYPE) return 0f;
+        if (type == Double.TYPE) return 0d;
+        if (type == Character.TYPE) return (char) 0;
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args) throws Throwable;
+    }
+}
diff --git a/agents/drivers/gbase8s/build.gradle b/agents/drivers/gbase8s/build.gradle
new file mode 100644
index 0000000..bc2f0fd
--- /dev/null
+++ b/agents/drivers/gbase8s/build.gradle
@@ -0,0 +1,12 @@
+dependencies {
+    implementation 'com.gbasedbt:jdbc:3.6.3.2'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes(
+            'Agent-Label': 'GBase 8s',
+            'Main-Class': 'com.dbx.agent.gbase8s.Gbase8sAgent'
+        )
+    }
+}
diff --git a/agents/drivers/gbase8s/src/main/java/com/dbx/agent/gbase8s/Gbase8sAgent.java b/agents/drivers/gbase8s/src/main/java/com/dbx/agent/gbase8s/Gbase8sAgent.java
new file mode 100644
index 0000000..52cdd7c
--- /dev/null
+++ b/agents/drivers/gbase8s/src/main/java/com/dbx/agent/gbase8s/Gbase8sAgent.java
@@ -0,0 +1,859 @@
+package com.dbx.agent.gbase8s;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.TableInfo;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+public final class Gbase8sAgent extends ConfiguredJdbcAgent {
+    private static final long METADATA_CACHE_TTL_MILLIS = 10_000L;
+
+    public static final JdbcAgentProfile GBASE8S_PROFILE = new JdbcAgentProfile(
+        "com.gbasedbt.jdbc.Driver",
+        "jdbc:gbasedbt-sqli://{host}:{port}/{database}:GBASEDBTSERVER=gbase8s",
+        9088,
+        true
+    );
+
+    private final Object metadataCacheLock = new Object();
+    private long databaseCacheTimeMillis;
+    private List<DatabaseInfo> databaseCache = Collections.emptyList();
+    private String schemaCacheCatalog = "";
+    private long schemaCacheTimeMillis;
+    private List<String> schemaCache = Collections.emptyList();
+    private String tableCacheCatalog = "";
+    private String tableCacheSchema = "";
+    private long tableCacheTimeMillis;
+    private List<TableInfo> tableCache = Collections.emptyList();
+
+    public Gbase8sAgent() {
+        super(GBASE8S_PROFILE);
+    }
+
+    public static String buildUrl(ConnectParams params) {
+        if (!params.getConnection_string().trim().isEmpty()) {
+            return params.getConnection_string();
+        }
+        String extraParams = trimEnd(trimStart(params.getUrl_params().trim(), ':', ';'), ';');
+        String database = params.getDatabase().trim().isEmpty() ? "sysmaster" : params.getDatabase().trim();
+        String serverParam = containsIgnoreCase(extraParams, "GBASEDBTSERVER=")
+            ? ""
+            : "GBASEDBTSERVER=" + getGbaseServer(params);
+        List<String> jdbcParams = new ArrayList<>();
+        if (!serverParam.isBlank()) {
+            jdbcParams.add(serverParam);
+        }
+        if (!extraParams.isBlank()) {
+            jdbcParams.add(extraParams);
+        }
+        return "jdbc:gbasedbt-sqli://" + params.getHost() + ":" + port(params) + "/" + database + ":"
+            + String.join(";", jdbcParams);
+    }
+
+    private static String getGbaseServer(ConnectParams params) {
+        if (params.getGbase_server() != null && !params.getGbase_server().trim().isEmpty()) {
+            return params.getGbase_server().trim();
+        }
+        return defaultGbaseServer(params.getHost());
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return buildUrl(params);
+    }
+
+    @Override
+    protected void afterConnect(ConnectParams params, Connection connection) {
+        super.afterConnect(params, connection);
+        clearMetadataCache();
+    }
+
+    @Override
+    public void disconnect() {
+        clearMetadataCache();
+        super.disconnect();
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        QueryResult result = super.executeQuery(sql, schema, options);
+        if (mayChangeMetadata(sql)) {
+            clearMetadataCache();
+        }
+        return result;
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        List<DatabaseInfo> cached = cachedDatabases();
+        if (cached != null) {
+            return cached;
+        }
+        List<String> names = queryDatabaseNamesInCatalog("sysmaster", "SELECT name FROM sysdatabases ORDER BY name");
+        if (names.isEmpty()) {
+            names = queryDatabaseNames("SELECT name FROM sysmaster:sysdatabases ORDER BY name");
+        }
+        if (names.isEmpty()) {
+            names = queryDatabaseNames("SELECT name FROM sysdatabases ORDER BY name");
+        }
+        if (names.isEmpty()) {
+            return super.listDatabases();
+        }
+        List<DatabaseInfo> result = new ArrayList<>();
+        for (String name : names) {
+            result.add(new DatabaseInfo(name));
+        }
+        cacheDatabases(result);
+        return result;
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        try {
+            String catalog = currentCatalog();
+            List<String> cached = cachedSchemas(catalog);
+            if (cached != null) {
+                return cached;
+            }
+            Set<String> schemas = new LinkedHashSet<>();
+            try (PreparedStatement stmt = requireConnection().prepareStatement(
+                "SELECT DISTINCT owner FROM systables WHERE tabid >= 100 AND tabtype IN ('T', 'V') ORDER BY owner"
+            ); ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    String owner = trim(rs.getString("owner"));
+                    if (!owner.isEmpty()) {
+                        schemas.add(owner);
+                    }
+                }
+            }
+            List<String> result = new ArrayList<>(schemas);
+            Collections.sort(result);
+            cacheSchemas(catalog, result);
+            return result;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        try {
+            String catalog = currentCatalog();
+            List<TableInfo> cached = cachedTables(catalog, schema);
+            if (cached != null) {
+                return cached;
+            }
+            List<TableInfo> result = new ArrayList<>();
+            String owner = trim(schema);
+            String sql = """
+                SELECT t.tabname, t.tabtype, c.comments
+                FROM systables t
+                LEFT JOIN syscomms c ON c.tabid = t.tabid
+                WHERE t.tabid >= 100 AND t.tabtype IN ('T', 'V')
+                """.stripIndent().trim();
+            if (!owner.isEmpty()) {
+                sql += " AND t.owner = ?";
+            }
+            sql += " ORDER BY tabname";
+            try (PreparedStatement stmt = requireConnection().prepareStatement(sql)) {
+                if (!owner.isEmpty()) {
+                    stmt.setString(1, owner);
+                }
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(
+                            trim(rs.getString("tabname")),
+                            tableType(rs.getString("tabtype")),
+                            emptyToNull(trim(rs.getString("comments")))
+                        ));
+                    }
+                }
+            }
+            result.sort(Comparator.comparing(TableInfo::getName));
+            cacheTables(catalog, schema, result);
+            return result;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listTables(schema);
+        }
+        return queryConstrainedTables(schema, normalized);
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        try {
+            Connection conn = requireConnection();
+            String owner = trim(schema);
+            Set<Integer> primaryKeyColumns = getPrimaryKeyColumnNumbers(conn, owner, table);
+            List<Object> args = new ArrayList<>();
+            args.add(table);
+            StringBuilder sql = new StringBuilder("""
+                SELECT c.colname, c.coltype, c.colno, c.collength, cc.comments
+                FROM syscolumns c
+                JOIN systables t ON t.tabid = c.tabid
+                LEFT JOIN syscolcomms cc ON cc.tabid = c.tabid AND cc.colno = c.colno
+                WHERE t.tabid >= 100 AND t.tabname = ?
+                """.stripIndent().trim());
+            if (!owner.isEmpty()) {
+                sql.append(" AND t.owner = ?");
+                args.add(owner);
+            }
+            sql.append(" ORDER BY c.colno");
+
+            List<ColumnInfo> result = new ArrayList<>();
+            try (PreparedStatement stmt = conn.prepareStatement(sql.toString())) {
+                bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String name = trim(rs.getString("colname"));
+                        int coltype = rs.getInt("coltype");
+                        int baseType = baseColType(coltype);
+                        int length = rs.getInt("collength");
+                        result.add(new ColumnInfo(
+                            name,
+                            mapColType(baseType),
+                            (coltype & 256) == 0,
+                            null,
+                            primaryKeyColumns.contains(rs.getInt("colno")),
+                            null,
+                            emptyToNull(trim(rs.getString("comments"))),
+                            numericPrecision(baseType, length),
+                            numericScale(baseType, length),
+                            characterMaximumLength(baseType, length)
+                        ));
+                    }
+                }
+            }
+            return result;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        try {
+            String owner = trim(schema);
+            List<Object> args = new ArrayList<>();
+            args.add(table);
+            StringBuilder sql = new StringBuilder("""
+                SELECT i.idxname, i.idxtype, c.constrtype,
+                       i.part1, i.part2, i.part3, i.part4, i.part5, i.part6, i.part7, i.part8,
+                       i.part9, i.part10, i.part11, i.part12, i.part13, i.part14, i.part15, i.part16
+                FROM sysindexes i
+                JOIN systables t ON t.tabid = i.tabid
+                LEFT JOIN sysconstraints c ON c.tabid = i.tabid AND c.idxname = i.idxname
+                WHERE t.tabid >= 100 AND t.tabname = ?
+                """.stripIndent().trim());
+            if (!owner.isEmpty()) {
+                sql.append(" AND t.owner = ?");
+                args.add(owner);
+            }
+            sql.append(" ORDER BY i.idxname");
+
+            Map<Integer, String> columnNames = loadColumnNamesByNumber(owner, table);
+            List<IndexInfo> result = new ArrayList<>();
+            try (PreparedStatement stmt = requireConnection().prepareStatement(sql.toString())) {
+                bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String name = trim(rs.getString("idxname"));
+                        if (name.isEmpty()) {
+                            continue;
+                        }
+                        List<Integer> parts = readIndexParts(rs);
+                        List<String> columns = resolveIndexColumns(parts, columnNames);
+                        String indexType = trim(rs.getString("idxtype"));
+                        String constraintType = trim(rs.getString("constrtype"));
+                        result.add(new IndexInfo(
+                            name,
+                            columns,
+                            indexType.toUpperCase(Locale.ROOT).startsWith("U"),
+                            "P".equalsIgnoreCase(constraintType),
+                            null,
+                            indexType,
+                            null,
+                            null
+                        ));
+                    }
+                }
+            }
+            return result;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        String normalizedType = objectType == null ? "" : objectType.trim().toUpperCase(Locale.ROOT);
+        if (!"VIEW".equals(normalizedType)) {
+            throw new UnsupportedOperationException("Object source is not supported");
+        }
+        return new ObjectSource(name, "VIEW", emptyToNull(trim(schema)), viewSource(schema, name), isEditableView(schema, name));
+    }
+
+    @Override
+    public String getTableDdl(String schema, String table) {
+        if ("VIEW".equals(tableType(schema, table))) {
+            return viewSource(schema, table);
+        }
+        return super.getTableDdl(schema, table);
+    }
+
+    private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
+        if (!constraints.includesTableLikeTypes()) {
+            return List.of();
+        }
+        try {
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            String owner = trim(schema);
+            // GBase 8s follows Informix-style SKIP/FIRST pagination in the SELECT list.
+            StringBuilder sql = new StringBuilder("SELECT ");
+            if (constraints.hasOffset()) {
+                sql.append("SKIP ").append(constraints.getOffset()).append(' ');
+            }
+            if (constraints.hasLimit()) {
+                sql.append("FIRST ").append(constraints.getLimit()).append(' ');
+            }
+            sql.append("t.tabname, t.tabtype, c.comments FROM systables t LEFT JOIN syscomms c ON c.tabid = t.tabid WHERE t.tabid >= 100");
+            appendGbase8sTableTypePredicate(sql, constraints);
+            if (!owner.isEmpty()) {
+                sql.append(" AND t.owner = ?");
+                args.add(owner);
+            }
+            if (constraints.hasFilter()) {
+                sql.append(" AND UPPER(t.tabname) LIKE ? ESCAPE '\\\\'");
+                args.add(constraints.fuzzyLikePattern().toUpperCase(Locale.ROOT));
+            }
+            sql.append(" ORDER BY t.tabname");
+            try (PreparedStatement stmt = requireConnection().prepareStatement(sql.toString())) {
+                bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(
+                            trim(rs.getString("tabname")),
+                            tableType(rs.getString("tabtype")),
+                            emptyToNull(trim(rs.getString("comments")))
+                        ));
+                    }
+                }
+            }
+            result.sort(Comparator.comparing(TableInfo::getName));
+            return constraints.withoutPaging().filterTables(result);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new Gbase8sAgent()).run();
+    }
+
+    private static int port(ConnectParams params) {
+        return params.getPort() > 0 ? params.getPort() : GBASE8S_PROFILE.getDefaultPort();
+    }
+
+    private static String defaultGbaseServer(String host) {
+        return isIpAddress(host) ? "gbase8s" : host;
+    }
+
+    private static boolean isIpAddress(String host) {
+        return host.matches("\\d{1,3}(\\.\\d{1,3}){3}") || host.contains(":");
+    }
+
+    private static String trimStart(String value, char... chars) {
+        int start = 0;
+        while (start < value.length() && contains(chars, value.charAt(start))) {
+            start++;
+        }
+        return value.substring(start);
+    }
+
+    private static String trimEnd(String value, char... chars) {
+        int end = value.length();
+        while (end > 0 && contains(chars, value.charAt(end - 1))) {
+            end--;
+        }
+        return value.substring(0, end);
+    }
+
+    private static boolean contains(char[] chars, char value) {
+        for (char ch : chars) {
+            if (ch == value) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean containsIgnoreCase(String value, String needle) {
+        return value.toLowerCase(Locale.ROOT).contains(needle.toLowerCase(Locale.ROOT));
+    }
+
+    private List<String> queryDatabaseNames(String sql) {
+        try {
+            return queryDatabaseNames(requireConnection(), sql);
+        } catch (Exception ignored) {
+            return Collections.emptyList();
+        }
+    }
+
+    private List<String> queryDatabaseNamesInCatalog(String catalog, String sql) {
+        try {
+            Connection connection = requireConnection();
+            String previousCatalog = "";
+            try {
+                previousCatalog = trim(connection.getCatalog());
+            } catch (Exception ignored) {
+            }
+            connection.setCatalog(catalog);
+            try {
+                return queryDatabaseNames(connection, sql);
+            } finally {
+                if (!previousCatalog.isEmpty()) {
+                    try {
+                        connection.setCatalog(previousCatalog);
+                    } catch (Exception ignored) {
+                    }
+                }
+            }
+        } catch (Exception ignored) {
+            return Collections.emptyList();
+        }
+    }
+
+    private static List<String> queryDatabaseNames(Connection connection, String sql) throws Exception {
+        Set<String> names = new LinkedHashSet<>();
+        try (PreparedStatement stmt = connection.prepareStatement(sql); ResultSet rs = stmt.executeQuery()) {
+            while (rs.next()) {
+                String name = trim(rs.getString(1));
+                if (!name.isEmpty()) {
+                    names.add(name);
+                }
+            }
+        }
+        List<String> result = new ArrayList<>(names);
+        Collections.sort(result);
+        return result;
+    }
+
+    private static String tableType(String tabtype) {
+        return "V".equalsIgnoreCase(trim(tabtype)) ? "VIEW" : "TABLE";
+    }
+
+    private String tableType(String schema, String table) {
+        try {
+            String owner = trim(schema);
+            List<Object> args = new ArrayList<>();
+            args.add(table);
+            StringBuilder sql = new StringBuilder("SELECT tabtype FROM systables WHERE tabid >= 100 AND tabname = ?");
+            if (!owner.isEmpty()) {
+                sql.append(" AND owner = ?");
+                args.add(owner);
+            }
+            try (PreparedStatement stmt = requireConnection().prepareStatement(sql.toString())) {
+                bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    return rs.next() ? tableType(rs.getString("tabtype")) : "";
+                }
+            }
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private String viewSource(String schema, String name) {
+        try {
+            String owner = trim(schema);
+            List<Object> args = new ArrayList<>();
+            args.add(name);
+            StringBuilder sql = new StringBuilder("""
+                SELECT v.viewtext
+                FROM sysviews v
+                JOIN systables t ON t.tabid = v.tabid
+                WHERE t.tabname = ?
+                """.stripIndent().trim());
+            if (!owner.isEmpty()) {
+                sql.append(" AND t.owner = ?");
+                args.add(owner);
+            }
+            sql.append(" ORDER BY v.seqno");
+            StringBuilder source = new StringBuilder();
+            try (PreparedStatement stmt = requireConnection().prepareStatement(sql.toString())) {
+                bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String chunk = rs.getString("viewtext");
+                        source.append(chunk == null ? "" : chunk);
+                    }
+                }
+            }
+            String result = stripTrailing(source.toString());
+            if (result.isEmpty()) {
+                throw new IllegalArgumentException("View source not found: " + name);
+            }
+            return result;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private boolean isEditableView(String schema, String name) {
+        try {
+            String owner = trim(schema);
+            List<Object> args = new ArrayList<>();
+            args.add(name);
+            StringBuilder sql = new StringBuilder("""
+                SELECT t.tabid, t.owner,
+                       (SELECT v.tabid FROM systables v WHERE UPPER(TRIM(v.tabname)) = 'VERSION') AS system_boundary_tabid
+                FROM systables t
+                WHERE t.tabtype = 'V' AND t.tabname = ?
+                """.stripIndent().trim());
+            if (!owner.isEmpty()) {
+                sql.append(" AND t.owner = ?");
+                args.add(owner);
+            }
+            try (PreparedStatement stmt = requireConnection().prepareStatement(sql.toString())) {
+                bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    if (!rs.next()) {
+                        return true;
+                    }
+                    int systemBoundaryTabid = rs.getInt("system_boundary_tabid");
+                    Integer boundary = rs.wasNull() ? null : systemBoundaryTabid;
+                    return !isSystemCatalogView(rs.getInt("tabid"), rs.getString("owner"), boundary);
+                }
+            }
+        } catch (Exception ignored) {
+            return true;
+        }
+    }
+
+    private static boolean isSystemCatalogView(int tabid, String owner, Integer systemBoundaryTabid) {
+        if (!"gbasedbt".equalsIgnoreCase(trim(owner))) {
+            return false;
+        }
+        // GBase 8s marks system catalog tables before/at VERSION; avoid a fixed tabid threshold
+        // so ordinary gbasedbt-owned user views are still editable.
+        if (systemBoundaryTabid != null && systemBoundaryTabid > 0) {
+            return tabid <= systemBoundaryTabid;
+        }
+        return tabid < 100;
+    }
+
+    public static String mapColType(int coltype) {
+        return switch (baseColType(coltype)) {
+            case 0 -> "CHAR";
+            case 1 -> "SMALLINT";
+            case 2 -> "INTEGER";
+            case 3 -> "FLOAT";
+            case 4 -> "SMALLFLOAT";
+            case 5 -> "DECIMAL";
+            case 6 -> "SERIAL";
+            case 7 -> "DATE";
+            case 8 -> "MONEY";
+            case 9 -> "NULL";
+            case 10 -> "DATETIME";
+            case 11 -> "BYTE";
+            case 12 -> "TEXT";
+            case 13 -> "VARCHAR";
+            case 14 -> "INTERVAL";
+            case 15 -> "NCHAR";
+            case 16 -> "NVARCHAR";
+            case 17 -> "INT8";
+            case 18 -> "SERIAL8";
+            case 19 -> "SET";
+            case 20 -> "MULTISET";
+            case 21 -> "LIST";
+            case 22 -> "ROW";
+            case 23 -> "COLLECTION";
+            case 40 -> "LVARCHAR";
+            case 41 -> "BOOLEAN";
+            case 43, 52 -> "BIGINT";
+            case 44, 53 -> "BIGSERIAL";
+            default -> "UNKNOWN(" + baseColType(coltype) + ")";
+        };
+    }
+
+    public static Set<Integer> primaryKeyColumnNumbers(List<Integer> parts) {
+        Set<Integer> result = new HashSet<>();
+        for (Integer part : parts) {
+            if (part == null) {
+                continue;
+            }
+            int value = Math.abs(part);
+            if (value > 0) {
+                result.add(value);
+            }
+        }
+        return result;
+    }
+
+    static List<String> resolveIndexColumns(List<Integer> parts, Map<Integer, String> columnNames) {
+        List<String> result = new ArrayList<>();
+        for (Integer part : parts) {
+            if (part == null || part == 0) {
+                continue;
+            }
+            // Informix-compatible catalogs encode descending index columns as negative column numbers.
+            String columnName = columnNames.get(Math.abs(part));
+            if (columnName != null && !columnName.isEmpty()) {
+                result.add(columnName);
+            }
+        }
+        return result;
+    }
+
+    private Map<Integer, String> loadColumnNamesByNumber(String owner, String table) throws Exception {
+        List<Object> args = new ArrayList<>();
+        args.add(table);
+        StringBuilder sql = new StringBuilder("""
+            SELECT c.colno, c.colname
+            FROM syscolumns c
+            JOIN systables t ON t.tabid = c.tabid
+            WHERE t.tabid >= 100 AND t.tabname = ?
+            """.stripIndent().trim());
+        if (!owner.isEmpty()) {
+            sql.append(" AND t.owner = ?");
+            args.add(owner);
+        }
+
+        Map<Integer, String> result = new LinkedHashMap<>();
+        try (PreparedStatement stmt = requireConnection().prepareStatement(sql.toString())) {
+            bind(stmt, args);
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    result.put(rs.getInt("colno"), trim(rs.getString("colname")));
+                }
+            }
+        }
+        return result;
+    }
+
+    private static List<Integer> readIndexParts(ResultSet rs) throws Exception {
+        List<Integer> parts = new ArrayList<>();
+        for (int index = 1; index <= 16; index += 1) {
+            int value = rs.getInt("part" + index);
+            parts.add(rs.wasNull() ? null : value);
+        }
+        return parts;
+    }
+
+    private Set<Integer> getPrimaryKeyColumnNumbers(Connection conn, String owner, String table) throws Exception {
+        List<Object> args = new ArrayList<>();
+        args.add(table);
+        StringBuilder sql = new StringBuilder("""
+            SELECT i.part1, i.part2, i.part3, i.part4, i.part5, i.part6, i.part7, i.part8,
+                   i.part9, i.part10, i.part11, i.part12, i.part13, i.part14, i.part15, i.part16
+            FROM sysconstraints c
+            JOIN sysindexes i ON i.idxname = c.idxname AND i.tabid = c.tabid
+            JOIN systables t ON t.tabid = c.tabid
+            WHERE t.tabname = ? AND c.constrtype = 'P'
+            """.stripIndent().trim());
+        if (!owner.isEmpty()) {
+            sql.append(" AND t.owner = ?");
+            args.add(owner);
+        }
+
+        try (PreparedStatement stmt = conn.prepareStatement(sql.toString())) {
+            bind(stmt, args);
+            try (ResultSet rs = stmt.executeQuery()) {
+                if (!rs.next()) {
+                    return Collections.emptySet();
+                }
+                List<Integer> parts = new ArrayList<>();
+                for (int index = 1; index <= 16; index += 1) {
+                    int value = rs.getInt(index);
+                    parts.add(rs.wasNull() ? null : value);
+                }
+                return primaryKeyColumnNumbers(parts);
+            }
+        }
+    }
+
+    private static int baseColType(int coltype) {
+        return coltype % 256;
+    }
+
+    private static Integer numericPrecision(int baseType, int length) {
+        if (baseType == 5 || baseType == 8) {
+            return (length >> 8) & 0xff;
+        }
+        return null;
+    }
+
+    private static Integer numericScale(int baseType, int length) {
+        if (baseType == 5 || baseType == 8) {
+            return length & 0xff;
+        }
+        return null;
+    }
+
+    private static Integer characterMaximumLength(int baseType, int length) {
+        return switch (baseType) {
+            case 0, 13, 15, 16, 40 -> length;
+            default -> null;
+        };
+    }
+
+    private static void appendGbase8sTableTypePredicate(StringBuilder sql, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            sql.append(" AND tabtype IN ('T', 'V')");
+            return;
+        }
+        List<String> tabTypes = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            tabTypes.add("'T'");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            tabTypes.add("'V'");
+        }
+        if (tabTypes.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND tabtype IN (").append(String.join(", ", tabTypes)).append(")");
+    }
+
+    private static void bind(PreparedStatement stmt, List<Object> args) throws Exception {
+        for (int index = 0; index < args.size(); index += 1) {
+            stmt.setString(index + 1, String.valueOf(args.get(index)));
+        }
+    }
+
+    private static boolean isUnconstrained(MetadataListConstraints constraints) {
+        return !constraints.hasFilter()
+            && !constraints.hasLimit()
+            && !constraints.hasOffset()
+            && !constraints.hasObjectTypes();
+    }
+
+    private static String trim(String value) {
+        return value == null ? "" : value.trim();
+    }
+
+    private static String emptyToNull(String value) {
+        return value.isEmpty() ? null : value;
+    }
+
+    private static String stripTrailing(String value) {
+        return value == null ? "" : value.stripTrailing();
+    }
+
+    private String currentCatalog() {
+        try {
+            return trim(requireConnection().getCatalog());
+        } catch (Exception ignored) {
+            return "";
+        }
+    }
+
+    private List<DatabaseInfo> cachedDatabases() {
+        synchronized (metadataCacheLock) {
+            if (cacheFresh(databaseCacheTimeMillis) && !databaseCache.isEmpty()) {
+                return new ArrayList<>(databaseCache);
+            }
+        }
+        return null;
+    }
+
+    private void cacheDatabases(List<DatabaseInfo> databases) {
+        synchronized (metadataCacheLock) {
+            databaseCache = new ArrayList<>(databases);
+            databaseCacheTimeMillis = System.currentTimeMillis();
+        }
+    }
+
+    private List<String> cachedSchemas(String catalog) {
+        synchronized (metadataCacheLock) {
+            if (cacheFresh(schemaCacheTimeMillis) && schemaCacheCatalog.equals(catalog)) {
+                return new ArrayList<>(schemaCache);
+            }
+        }
+        return null;
+    }
+
+    private void cacheSchemas(String catalog, List<String> schemas) {
+        synchronized (metadataCacheLock) {
+            schemaCacheCatalog = catalog;
+            schemaCache = new ArrayList<>(schemas);
+            schemaCacheTimeMillis = System.currentTimeMillis();
+        }
+    }
+
+    private List<TableInfo> cachedTables(String catalog, String schema) {
+        String owner = trim(schema);
+        synchronized (metadataCacheLock) {
+            if (cacheFresh(tableCacheTimeMillis) && tableCacheCatalog.equals(catalog) && tableCacheSchema.equals(owner)) {
+                return new ArrayList<>(tableCache);
+            }
+        }
+        return null;
+    }
+
+    private void cacheTables(String catalog, String schema, List<TableInfo> tables) {
+        synchronized (metadataCacheLock) {
+            tableCacheCatalog = catalog;
+            tableCacheSchema = trim(schema);
+            tableCache = new ArrayList<>(tables);
+            tableCacheTimeMillis = System.currentTimeMillis();
+        }
+    }
+
+    private boolean cacheFresh(long timeMillis) {
+        return timeMillis > 0 && System.currentTimeMillis() - timeMillis <= METADATA_CACHE_TTL_MILLIS;
+    }
+
+    private void clearMetadataCache() {
+        synchronized (metadataCacheLock) {
+            databaseCacheTimeMillis = 0;
+            databaseCache = Collections.emptyList();
+            schemaCacheCatalog = "";
+            schemaCacheTimeMillis = 0;
+            schemaCache = Collections.emptyList();
+            tableCacheCatalog = "";
+            tableCacheSchema = "";
+            tableCacheTimeMillis = 0;
+            tableCache = Collections.emptyList();
+        }
+    }
+
+    private static boolean mayChangeMetadata(String sql) {
+        String normalized = trim(sql).toLowerCase(Locale.ROOT);
+        return normalized.startsWith("create ")
+            || normalized.startsWith("drop ")
+            || normalized.startsWith("alter ")
+            || normalized.startsWith("rename ")
+            || normalized.startsWith("truncate ");
+    }
+}
diff --git a/agents/drivers/gbase8s/src/test/java/com/dbx/agent/gbase8s/Gbase8sAgentTest.java b/agents/drivers/gbase8s/src/test/java/com/dbx/agent/gbase8s/Gbase8sAgentTest.java
new file mode 100644
index 0000000..2b3e6d7
--- /dev/null
+++ b/agents/drivers/gbase8s/src/test/java/com/dbx/agent/gbase8s/Gbase8sAgentTest.java
@@ -0,0 +1,439 @@
+package com.dbx.agent.gbase8s;
+
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.test.TestSupport;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+class Gbase8sAgentTest {
+    @Test
+    void declaresGbase8sProfile() {
+        Gbase8sAgent agent = new Gbase8sAgent();
+
+        Assertions.assertEquals("com.gbasedbt.jdbc.Driver", agent.getProfile().getDriverClass());
+        Assertions.assertEquals("jdbc:gbasedbt-sqli://{host}:{port}/{database}:GBASEDBTSERVER=gbase8s", agent.getProfile().getUrlTemplate());
+        Assertions.assertEquals(9088, agent.getProfile().getDefaultPort());
+        Assertions.assertTrue(agent.getProfile().getSkipExecutionContext());
+    }
+
+    @Test
+    void buildsGbase8sJdbcUrlWithExplicitServerAndLocaleParameters() {
+        String url = Gbase8sAgent.buildUrl(
+            new ConnectParams(
+                "172.26.128.159",
+                20013,
+                "testdb",
+                "",
+                "",
+                "GBASEDBTSERVER=gbase01;CLIENT_LOCALE=zh_cn.utf8;DB_LOCALE=zh_cn.utf8",
+                "",
+                false
+            )
+        );
+
+        Assertions.assertEquals(
+            "jdbc:gbasedbt-sqli://172.26.128.159:20013/testdb:GBASEDBTSERVER=gbase01;CLIENT_LOCALE=zh_cn.utf8;DB_LOCALE=zh_cn.utf8",
+            url
+        );
+    }
+
+    @Test
+    void fallsBackToHostAsGbaseServerWhenNoExplicitServerIsConfigured() {
+        String url = Gbase8sAgent.buildUrl(
+            new ConnectParams(
+                "gbase-host",
+                9088,
+                "sysmaster",
+                "",
+                "",
+                "",
+                "",
+                false
+            )
+        );
+
+        Assertions.assertEquals(
+            "jdbc:gbasedbt-sqli://gbase-host:9088/sysmaster:GBASEDBTSERVER=gbase-host",
+            url
+        );
+    }
+
+    @Test
+    void fallsBackToGbaseServerNameWhenHostIsAnIpAddress() {
+        String url = Gbase8sAgent.buildUrl(
+            new ConnectParams(
+                "172.26.128.159",
+                0,
+                "sysmaster",
+                "",
+                "",
+                "",
+                "",
+                false
+            )
+        );
+
+        Assertions.assertEquals(
+            "jdbc:gbasedbt-sqli://172.26.128.159:9088/sysmaster:GBASEDBTSERVER=gbase8s",
+            url
+        );
+    }
+
+    @Test
+    void usesConnectionStringWhenConfigured() {
+        String url = Gbase8sAgent.buildUrl(
+            new ConnectParams(
+                "ignored",
+                0,
+                "",
+                "",
+                "",
+                "",
+                "jdbc:gbasedbt-sqli://db.example.com:20013/app:GBASEDBTSERVER=gbase01",
+                false
+            )
+        );
+
+        Assertions.assertEquals("jdbc:gbasedbt-sqli://db.example.com:20013/app:GBASEDBTSERVER=gbase01", url);
+    }
+
+    @Test
+    void constrainedListTablesUsesGbase8sSystemTableQuery() {
+        List<String> sql = new ArrayList<>();
+        Gbase8sAgent agent = new Gbase8sAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"tabname", "tabtype"},
+            new Object[][]{
+                {"user_order", "T"}
+            }
+        )));
+
+        List<TableInfo> tables = agent.listTables(
+            "app",
+            new MetadataListConstraints("user", 1, 1, List.of("TABLE"))
+        );
+
+        Assertions.assertEquals(1, tables.size());
+        Assertions.assertEquals("user_order", tables.get(0).getName());
+        Assertions.assertTrue(sql.get(0).contains("FROM systables"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("SELECT SKIP 1 FIRST 1"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("UPPER(t.tabname) LIKE ?"), sql.get(0));
+    }
+
+    @Test
+    void listTablesLoadsGbase8sTableComments() {
+        List<String> sql = new ArrayList<>();
+        Gbase8sAgent agent = new Gbase8sAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"tabname", "tabtype", "comments"},
+            new Object[][]{
+                {"products", "T", "Product catalog"}
+            }
+        )));
+
+        List<TableInfo> tables = agent.listTables("root");
+
+        Assertions.assertEquals("Product catalog", tables.get(0).getComment());
+        Assertions.assertTrue(sql.get(0).contains("LEFT JOIN syscomms"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("t.owner = ?"), sql.get(0));
+    }
+
+    @Test
+    void extractsPrimaryKeyColumnNumbersFromGbase8sIndexParts() {
+        Assertions.assertEquals(
+            Set.of(1, 3, 5),
+            Gbase8sAgent.primaryKeyColumnNumbers(Arrays.asList(1, -3, 0, 5, null))
+        );
+    }
+
+    @Test
+    void getColumnsUsesGbase8sSystemCatalog() {
+        List<String> sql = new ArrayList<>();
+        Gbase8sAgent agent = new Gbase8sAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(
+            sql,
+            resultSet(
+                new String[]{"part1", "part2", "part3", "part4", "part5", "part6", "part7", "part8", "part9", "part10", "part11", "part12", "part13", "part14", "part15", "part16"},
+                new Object[][]{
+                    {1, 0, null, null, null, null, null, null, null, null, null, null, null, null, null, null}
+                }
+            ),
+            resultSet(
+                new String[]{"colname", "coltype", "colno", "collength", "comments"},
+                new Object[][]{
+                    {"product_id", 258, 1, 4, "Product identifier"},
+                    {"sku", 13, 2, 40, null},
+                    {"price", 5, 3, 3074, "Unit price"}
+                }
+            )
+        ));
+
+        List<ColumnInfo> columns = agent.getColumns("root", "products");
+
+        Assertions.assertEquals(2, sql.size());
+        Assertions.assertTrue(sql.get(0).contains("FROM sysconstraints"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("t.owner = ?"), sql.get(0));
+        Assertions.assertTrue(sql.get(1).contains("FROM syscolumns"), sql.get(1));
+        Assertions.assertTrue(sql.get(1).contains("t.owner = ?"), sql.get(1));
+        Assertions.assertEquals(3, columns.size());
+        Assertions.assertEquals("product_id", columns.get(0).getName());
+        Assertions.assertEquals("INTEGER", columns.get(0).getData_type());
+        Assertions.assertFalse(columns.get(0).getIs_nullable());
+        Assertions.assertTrue(columns.get(0).getIs_primary_key());
+        Assertions.assertEquals("VARCHAR", columns.get(1).getData_type());
+        Assertions.assertEquals(40, columns.get(1).getCharacter_maximum_length());
+        Assertions.assertEquals("DECIMAL", columns.get(2).getData_type());
+        Assertions.assertEquals(12, columns.get(2).getNumeric_precision());
+        Assertions.assertEquals(2, columns.get(2).getNumeric_scale());
+        Assertions.assertEquals("Product identifier", columns.get(0).getComment());
+        Assertions.assertEquals("Unit price", columns.get(2).getComment());
+        Assertions.assertTrue(sql.get(1).contains("LEFT JOIN syscolcomms"), sql.get(1));
+    }
+
+    @Test
+    void listIndexesLoadsGbase8sSystemCatalogIndexes() {
+        List<String> sql = new ArrayList<>();
+        Gbase8sAgent agent = new Gbase8sAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(
+            sql,
+            resultSet(
+                new String[]{"colno", "colname"},
+                new Object[][]{
+                    {1, "product_id"},
+                    {2, "sku"},
+                    {3, "created_at"}
+                }
+            ),
+            resultSet(
+                new String[]{"idxname", "idxtype", "constrtype", "part1", "part2", "part3", "part4", "part5", "part6", "part7", "part8", "part9", "part10", "part11", "part12", "part13", "part14", "part15", "part16"},
+                new Object[][]{
+                    {"products_pk", "U", "P", 1, 0, null, null, null, null, null, null, null, null, null, null, null, null, null, null},
+                    {"products_sku_created", "D", null, 2, -3, 0, null, null, null, null, null, null, null, null, null, null, null, null, null}
+                }
+            )
+        ));
+
+        List<IndexInfo> indexes = agent.listIndexes("root", "products");
+
+        Assertions.assertEquals(2, indexes.size());
+        Assertions.assertEquals(List.of("product_id"), indexes.get(0).getColumns());
+        Assertions.assertTrue(indexes.get(0).getIs_unique());
+        Assertions.assertTrue(indexes.get(0).getIs_primary());
+        Assertions.assertEquals(List.of("sku", "created_at"), indexes.get(1).getColumns());
+        Assertions.assertFalse(indexes.get(1).getIs_unique());
+        Assertions.assertFalse(indexes.get(1).getIs_primary());
+        Assertions.assertTrue(sql.get(0).contains("FROM syscolumns"), sql.get(0));
+        Assertions.assertTrue(sql.get(1).contains("FROM sysindexes"), sql.get(1));
+        Assertions.assertTrue(sql.get(1).contains("LEFT JOIN sysconstraints"), sql.get(1));
+    }
+
+    @Test
+    void resolvesGbase8sIndexPartsInDeclaredOrder() {
+        Assertions.assertEquals(
+            List.of("sku", "created_at"),
+            Gbase8sAgent.resolveIndexColumns(List.of(2, -3, 0), Map.of(2, "sku", 3, "created_at"))
+        );
+    }
+
+    @Test
+    void getObjectSourceUsesGbase8sViewCatalog() {
+        List<String> sql = new ArrayList<>();
+        Gbase8sAgent agent = new Gbase8sAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(
+            sql,
+            resultSet(
+                new String[]{"viewtext"},
+                new Object[][]{
+                    {"create view \"gbasedbt\".demo_view as select "},
+                    {"* from products;   "}
+                }
+            ),
+            resultSet(
+                new String[]{"tabid", "owner", "system_boundary_tabid"},
+                new Object[][]{
+                    {1000, "gbasedbt", 614}
+                }
+            )
+        ));
+
+        ObjectSource source = agent.getObjectSource("gbasedbt", "demo_view", "VIEW");
+
+        Assertions.assertEquals("demo_view", source.getName());
+        Assertions.assertEquals("VIEW", source.getObject_type());
+        Assertions.assertEquals("gbasedbt", source.getSchema());
+        Assertions.assertEquals("create view \"gbasedbt\".demo_view as select * from products;", source.getSource());
+        Assertions.assertTrue(source.isEditable());
+        Assertions.assertEquals(2, sql.size());
+        Assertions.assertTrue(sql.get(0).contains("FROM sysviews"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("t.owner = ?"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("ORDER BY v.seqno"), sql.get(0));
+        Assertions.assertTrue(sql.get(1).contains("system_boundary_tabid"), sql.get(1));
+    }
+
+    @Test
+    void getObjectSourceMarksGbase8sSystemViewsReadOnly() {
+        Gbase8sAgent agent = new Gbase8sAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(
+            new ArrayList<>(),
+            resultSet(
+                new String[]{"viewtext"},
+                new Object[][]{
+                    {"create view \"gbasedbt\".dba_db_links as select * from user_db_links;"}
+                }
+            ),
+            resultSet(
+                new String[]{"tabid", "owner", "system_boundary_tabid"},
+                new Object[][]{
+                    {614, "gbasedbt", 614}
+                }
+            )
+        ));
+
+        ObjectSource source = agent.getObjectSource("gbasedbt", "dba_db_links", "VIEW");
+
+        Assertions.assertFalse(source.isEditable());
+    }
+
+    @Test
+    void getTableDdlReturnsViewSourceForGbase8sViews() {
+        List<String> sql = new ArrayList<>();
+        Gbase8sAgent agent = new Gbase8sAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(
+            sql,
+            resultSet(
+                new String[]{"tabtype"},
+                new Object[][]{
+                    {"V"}
+                }
+            ),
+            resultSet(
+                new String[]{"viewtext"},
+                new Object[][]{
+                    {"create view demo_view as select 1 as id;   "}
+                }
+            )
+        ));
+
+        String ddl = agent.getTableDdl("gbasedbt", "demo_view");
+
+        Assertions.assertEquals("create view demo_view as select 1 as id;", ddl);
+        Assertions.assertEquals(2, sql.size());
+        Assertions.assertTrue(sql.get(0).contains("SELECT tabtype FROM systables"), sql.get(0));
+        Assertions.assertTrue(sql.get(1).contains("FROM sysviews"), sql.get(1));
+    }
+
+    private static Connection preparedConnection(List<String> sql, ResultSet... resultSets) {
+        int[] resultIndex = {0};
+        PreparedStatement statement = proxy(PreparedStatement.class, (method, args) -> {
+            if ("executeQuery".equals(method.getName())) {
+                int index = Math.min(resultIndex[0], resultSets.length - 1);
+                resultIndex[0] += 1;
+                return resultSets[index];
+            }
+            if ("setString".equals(method.getName()) || "close".equals(method.getName())) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+        return proxy(Connection.class, (method, args) -> {
+            if ("getCatalog".equals(method.getName())) {
+                return "appdb";
+            }
+            if ("prepareStatement".equals(method.getName())) {
+                sql.add(String.valueOf(args[0]));
+                return statement;
+            }
+            if ("isClosed".equals(method.getName())) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSet resultSet(String[] columns, Object[][] rows) {
+        int[] index = {-1};
+        Object[] lastValue = {null};
+        return proxy(ResultSet.class, (method, args) -> {
+            switch (method.getName()) {
+                case "next":
+                    index[0] += 1;
+                    return index[0] < rows.length;
+                case "getString":
+                    Object value = columnValue(columns, rows[index[0]], args[0]);
+                    lastValue[0] = value;
+                    return value == null ? null : String.valueOf(value);
+                case "getInt":
+                    Object intValue = columnValue(columns, rows[index[0]], args[0]);
+                    lastValue[0] = intValue;
+                    if (intValue == null) {
+                        return 0;
+                    }
+                    if (intValue instanceof Number) {
+                        return ((Number) intValue).intValue();
+                    }
+                    return Integer.parseInt(String.valueOf(intValue));
+                case "wasNull":
+                    return lastValue[0] == null;
+                case "close":
+                    return null;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Object columnValue(String[] columns, Object[] row, Object key) {
+        if (key instanceof Number) {
+            return row[((Number) key).intValue() - 1];
+        }
+        for (int i = 0; i < columns.length; i++) {
+            if (columns[i].equalsIgnoreCase(String.valueOf(key))) {
+                return row[i];
+            }
+        }
+        return null;
+    }
+
+    private static <T> T proxy(Class<T> type, MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                return handler.handle(method, args == null ? new Object[0] : args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (type == Boolean.TYPE) return false;
+        if (type == Byte.TYPE) return (byte) 0;
+        if (type == Short.TYPE) return (short) 0;
+        if (type == Integer.TYPE) return 0;
+        if (type == Long.TYPE) return 0L;
+        if (type == Float.TYPE) return 0f;
+        if (type == Double.TYPE) return 0d;
+        if (type == Character.TYPE) return (char) 0;
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args) throws Throwable;
+    }
+}
diff --git a/agents/drivers/goldendb/build.gradle b/agents/drivers/goldendb/build.gradle
new file mode 100644
index 0000000..a200788
--- /dev/null
+++ b/agents/drivers/goldendb/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.mysql:mysql-connector-j:9.2.0'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'GoldenDB', 'Main-Class': 'com.dbx.agent.goldendb.GoldendbAgent')
+    }
+}
diff --git a/agents/drivers/goldendb/libs/.gitkeep b/agents/drivers/goldendb/libs/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/agents/drivers/goldendb/src/main/java/com/dbx/agent/goldendb/GoldendbAgent.java b/agents/drivers/goldendb/src/main/java/com/dbx/agent/goldendb/GoldendbAgent.java
new file mode 100644
index 0000000..4f7596f
--- /dev/null
+++ b/agents/drivers/goldendb/src/main/java/com/dbx/agent/goldendb/GoldendbAgent.java
@@ -0,0 +1,555 @@
+package com.dbx.agent.goldendb;
+
+import com.dbx.agent.BaseDatabaseAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcExecutor;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.MetadataSqlSupport;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.HashSet;
+
+public final class GoldendbAgent extends BaseDatabaseAgent {
+    private Connection connection;
+
+    @Override
+    public Connection getConnection() {
+        return connection;
+    }
+
+    @Override
+    public void connect(ConnectParams params) {
+        uncheckedVoid(() -> {
+            Class.forName("com.mysql.cj.jdbc.Driver");
+            connection = DriverManager.getConnection(buildUrl(params), params.getUsername(), params.getPassword());
+        });
+    }
+
+    @Override
+    public boolean testConnection(ConnectParams params) {
+        return unchecked(() -> {
+            Class.forName("com.mysql.cj.jdbc.Driver");
+            try (Connection conn = DriverManager.getConnection(buildUrl(params), params.getUsername(), params.getPassword())) {
+                return conn.isValid(5);
+            }
+        });
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW DATABASES")) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString(1)));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        List<String> result = new ArrayList<>();
+        for (DatabaseInfo database : listDatabases()) {
+            result.add(database.getName());
+        }
+        return result;
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(
+                "SELECT TABLE_NAME, TABLE_TYPE, TABLE_COMMENT FROM information_schema.TABLES WHERE TABLE_SCHEMA = ? ORDER BY TABLE_NAME"
+            )) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String tableType = rs.getString("TABLE_TYPE");
+                        if ("BASE TABLE".equals(tableType)) {
+                            tableType = "TABLE";
+                        }
+                        result.add(new TableInfo(rs.getString("TABLE_NAME"), tableType, emptyToNull(rs.getString("TABLE_COMMENT"))));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listTables(schema);
+        }
+        if (!normalized.includesTableLikeTypes()) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedTables(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterTables(listTables(schema));
+        }
+    }
+
+    private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            StringBuilder sql = new StringBuilder("SELECT TABLE_NAME, TABLE_TYPE, TABLE_COMMENT FROM information_schema.TABLES WHERE TABLE_SCHEMA = ?");
+            args.add(schema);
+            appendInformationSchemaTableTypePredicate(sql, args, constraints);
+            MetadataSqlSupport.appendNameFilter(sql, args, "TABLE_NAME", constraints);
+            sql.append(" ORDER BY TABLE_NAME");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(rs.getString("TABLE_NAME"), normalizeTableType(rs.getString("TABLE_TYPE")), emptyToNull(rs.getString("TABLE_COMMENT"))));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterTables(result);
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            for (TableInfo table : listTables(schema)) {
+                result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+            }
+
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(
+                "SELECT ROUTINE_NAME, ROUTINE_TYPE FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ? ORDER BY ROUTINE_NAME"
+            )) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1), rs.getString(2), schema, null));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listObjects(schema);
+        }
+        if (!includesSupportedObjects(normalized)) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedObjects(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterObjects(listObjects(schema));
+        }
+    }
+
+    private List<ObjectInfo> queryConstrainedObjects(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            List<String> branches = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            if (constraints.includesTableLikeTypes()) {
+                StringBuilder tableSql = new StringBuilder("SELECT TABLE_NAME AS OBJECT_NAME, TABLE_TYPE AS OBJECT_TYPE, TABLE_COMMENT AS OBJECT_COMMENT FROM information_schema.TABLES WHERE TABLE_SCHEMA = ?");
+                args.add(schema);
+                appendInformationSchemaTableTypePredicate(tableSql, args, constraints);
+                MetadataSqlSupport.appendNameFilter(tableSql, args, "TABLE_NAME", constraints);
+                branches.add(tableSql.toString());
+            }
+            if (constraints.objectTypeAllowed("PROCEDURE") || constraints.objectTypeAllowed("FUNCTION")) {
+                StringBuilder routineSql = new StringBuilder("SELECT ROUTINE_NAME AS OBJECT_NAME, ROUTINE_TYPE AS OBJECT_TYPE, NULL AS OBJECT_COMMENT FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ?");
+                args.add(schema);
+                appendRoutineTypePredicate(routineSql, args, constraints);
+                MetadataSqlSupport.appendNameFilter(routineSql, args, "ROUTINE_NAME", constraints);
+                branches.add(routineSql.toString());
+            }
+            if (branches.isEmpty()) {
+                return List.of();
+            }
+            StringBuilder sql = new StringBuilder("SELECT OBJECT_NAME, OBJECT_TYPE, OBJECT_COMMENT FROM (")
+                .append(String.join(" UNION ALL ", branches))
+                .append(") metadata_objects ORDER BY CASE OBJECT_TYPE WHEN 'BASE TABLE' THEN 0 WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 WHEN 'PROCEDURE' THEN 2 WHEN 'FUNCTION' THEN 3 ELSE 9 END, OBJECT_NAME");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString("OBJECT_NAME"), normalizeTableType(rs.getString("OBJECT_TYPE")), schema, emptyToNull(rs.getString("OBJECT_COMMENT"))));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterObjects(result);
+        });
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        return unchecked(() -> {
+            String quotedName = JdbcIdentifiers.INSTANCE.backtick(name);
+            String sql = switch (objectType.toUpperCase(Locale.ROOT)) {
+                case "VIEW" -> "SHOW CREATE VIEW " + quotedName;
+                case "PROCEDURE" -> "SHOW CREATE PROCEDURE " + quotedName;
+                case "FUNCTION" -> "SHOW CREATE FUNCTION " + quotedName;
+                default -> throw new IllegalArgumentException("Unsupported object type: " + objectType);
+            };
+
+            String source = "";
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(sql)) {
+                if (rs.next()) {
+                    int sourceIndex = "VIEW".equals(objectType.toUpperCase(Locale.ROOT)) ? 2 : 3;
+                    String value = rs.getString(sourceIndex);
+                    source = value == null ? "" : value;
+                }
+            }
+            return new ObjectSource(name, objectType, schema, source);
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            Set<String> primaryKeys = new HashSet<>();
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(
+                """
+                SELECT COLUMN_NAME
+                FROM information_schema.KEY_COLUMN_USAGE
+                WHERE TABLE_SCHEMA = ?
+                    AND TABLE_NAME = ?
+                    AND CONSTRAINT_NAME = 'PRIMARY'
+                """
+            )) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        primaryKeys.add(rs.getString("COLUMN_NAME"));
+                    }
+                }
+            }
+
+            List<ColumnInfo> result = new ArrayList<>();
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(
+                """
+                SELECT COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_DEFAULT, EXTRA, COLUMN_COMMENT,
+                       NUMERIC_PRECISION, NUMERIC_SCALE, CHARACTER_MAXIMUM_LENGTH
+                FROM information_schema.COLUMNS
+                WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+                ORDER BY ORDINAL_POSITION
+                """
+            )) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String columnName = rs.getString("COLUMN_NAME");
+                        result.add(new ColumnInfo(
+                            columnName,
+                            rs.getString("COLUMN_TYPE"),
+                            "YES".equals(rs.getString("IS_NULLABLE")),
+                            rs.getString("COLUMN_DEFAULT"),
+                            primaryKeys.contains(columnName),
+                            rs.getString("EXTRA"),
+                            emptyToNull(rs.getString("COLUMN_COMMENT")),
+                            integerOrNull(rs, "NUMERIC_PRECISION"),
+                            integerOrNull(rs, "NUMERIC_SCALE"),
+                            numberToIntOrNull(rs, "CHARACTER_MAXIMUM_LENGTH")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return unchecked(() -> {
+            Map<String, List<IndexColumn>> indexMap = new TreeMap<>();
+            Map<String, Boolean> uniqueMap = new HashMap<>();
+            Map<String, String> typeMap = new HashMap<>();
+            String quotedTable = JdbcIdentifiers.INSTANCE.backtick(table);
+            String quotedSchema = JdbcIdentifiers.INSTANCE.backtick(schema);
+
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW INDEX FROM " + quotedTable + " FROM " + quotedSchema)) {
+                while (rs.next()) {
+                    String indexName = rs.getString("Key_name");
+                    String columnName = rs.getString("Column_name");
+                    int seqInIndex = rs.getInt("Seq_in_index");
+                    int nonUnique = rs.getInt("Non_unique");
+                    String indexType = rs.getString("Index_type");
+
+                    indexMap.computeIfAbsent(indexName, ignored -> new ArrayList<>())
+                        .add(new IndexColumn(seqInIndex, columnName));
+                    uniqueMap.put(indexName, nonUnique == 0);
+                    typeMap.put(indexName, indexType);
+                }
+            }
+
+            List<IndexInfo> result = new ArrayList<>();
+            for (Map.Entry<String, List<IndexColumn>> entry : indexMap.entrySet()) {
+                List<IndexColumn> columns = entry.getValue();
+                columns.sort((left, right) -> Integer.compare(left.ordinal, right.ordinal));
+                List<String> columnNames = new ArrayList<>();
+                for (IndexColumn column : columns) {
+                    columnNames.add(column.name);
+                }
+
+                String indexName = entry.getKey();
+                result.add(new IndexInfo(
+                    indexName,
+                    columnNames,
+                    Boolean.TRUE.equals(uniqueMap.get(indexName)),
+                    "PRIMARY".equals(indexName),
+                    null,
+                    typeMap.get(indexName),
+                    null,
+                    null
+                ));
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return unchecked(() -> {
+            List<ForeignKeyInfo> result = new ArrayList<>();
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(
+                """
+                SELECT CONSTRAINT_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+                FROM information_schema.KEY_COLUMN_USAGE
+                WHERE TABLE_SCHEMA = ?
+                    AND TABLE_NAME = ?
+                    AND REFERENCED_TABLE_NAME IS NOT NULL
+                ORDER BY CONSTRAINT_NAME
+                """
+            )) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ForeignKeyInfo(
+                            rs.getString("CONSTRAINT_NAME"),
+                            rs.getString("COLUMN_NAME"),
+                            rs.getString("REFERENCED_TABLE_NAME"),
+                            rs.getString("REFERENCED_COLUMN_NAME")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return unchecked(() -> {
+            List<TriggerInfo> result = new ArrayList<>();
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(
+                """
+                SELECT TRIGGER_NAME, EVENT_MANIPULATION, ACTION_TIMING
+                FROM information_schema.TRIGGERS
+                WHERE TRIGGER_SCHEMA = ? AND EVENT_OBJECT_TABLE = ?
+                ORDER BY TRIGGER_NAME
+                """
+            )) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TriggerInfo(
+                            rs.getString("TRIGGER_NAME"),
+                            rs.getString("EVENT_MANIPULATION"),
+                            rs.getString("ACTION_TIMING")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        return JdbcExecutor.INSTANCE.execute(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options.getMaxRows(),
+            options.getFetchSize(),
+            options.getTimeoutSecs(),
+            this::resultValue
+        );
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "USE " + JdbcIdentifiers.INSTANCE.backtick(schema);
+    }
+
+    @Override
+    public void disconnect() {
+        uncheckedVoid(() -> {
+            if (connection != null) {
+                connection.close();
+            }
+            connection = null;
+        });
+    }
+
+    private Object resultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value;
+            switch (sqlType) {
+                case Types.BIGINT:
+                    value = rs.getLong(index);
+                    break;
+                case Types.INTEGER:
+                case Types.SMALLINT:
+                case Types.TINYINT:
+                    value = rs.getInt(index);
+                    break;
+                case Types.FLOAT:
+                case Types.REAL:
+                    value = rs.getFloat(index);
+                    break;
+                case Types.DOUBLE:
+                    value = rs.getDouble(index);
+                    break;
+                case Types.DECIMAL:
+                case Types.NUMERIC:
+                    value = rs.getBigDecimal(index);
+                    break;
+                case Types.BOOLEAN:
+                case Types.BIT:
+                    value = rs.getBoolean(index);
+                    break;
+                default:
+                    value = rs.getString(index);
+                    break;
+            }
+            return rs.wasNull() ? null : value;
+        });
+    }
+
+    private static String buildUrl(ConnectParams params) {
+        return "jdbc:mysql://" + params.getHost() + ":" + params.getPort() + "/" + params.getDatabase()
+            + "?useSSL=false&allowPublicKeyRetrieval=true";
+    }
+
+    private static boolean isUnconstrained(MetadataListConstraints constraints) {
+        return !constraints.hasFilter() && !constraints.hasLimit() && !constraints.hasOffset() && !constraints.hasObjectTypes();
+    }
+
+    private static boolean includesSupportedObjects(MetadataListConstraints constraints) {
+        return constraints.includesTableLikeTypes()
+            || constraints.objectTypeAllowed("PROCEDURE")
+            || constraints.objectTypeAllowed("FUNCTION");
+    }
+
+    private static void appendInformationSchemaTableTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> types = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            types.add("BASE TABLE");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            types.add("VIEW");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND TABLE_TYPE IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
+        args.addAll(types);
+    }
+
+    private static void appendRoutineTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> types = new ArrayList<>();
+        if (constraints.objectTypeAllowed("PROCEDURE")) {
+            types.add("PROCEDURE");
+        }
+        if (constraints.objectTypeAllowed("FUNCTION")) {
+            types.add("FUNCTION");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND ROUTINE_TYPE IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
+        args.addAll(types);
+    }
+
+    private static String normalizeTableType(String tableType) {
+        return "BASE TABLE".equals(tableType) ? "TABLE" : tableType;
+    }
+
+    private static String emptyToNull(String value) {
+        return value == null || value.isEmpty() ? null : value;
+    }
+
+    private static Integer integerOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Integer ? (Integer) value : null;
+    }
+
+    private static Integer numberToIntOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    private static final class IndexColumn {
+        private final int ordinal;
+        private final String name;
+
+        private IndexColumn(int ordinal, String name) {
+            this.ordinal = ordinal;
+            this.name = name;
+        }
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new GoldendbAgent()).run();
+    }
+}
diff --git a/agents/drivers/goldendb/src/test/java/com/dbx/agent/goldendb/GoldendbAgentMetadataTest.java b/agents/drivers/goldendb/src/test/java/com/dbx/agent/goldendb/GoldendbAgentMetadataTest.java
new file mode 100644
index 0000000..6ec7a08
--- /dev/null
+++ b/agents/drivers/goldendb/src/test/java/com/dbx/agent/goldendb/GoldendbAgentMetadataTest.java
@@ -0,0 +1,54 @@
+package com.dbx.agent.goldendb;
+
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.test.TestSupport;
+import com.dbx.agent.test.JdbcAgentFake;
+import com.dbx.agent.test.JdbcMetadataSqlFake;
+import java.sql.Connection;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class GoldendbAgentMetadataTest {
+    @Test
+    void quotesSchemaAndTableIdentifiersInIndexMetadataSql() {
+        GoldendbAgent agent = new GoldendbAgent();
+        Connection fake = JdbcMetadataSqlFake.connection();
+        TestSupport.setPrivateConnection(agent, fake);
+
+        agent.listIndexes("bad`schema", "bad`table");
+
+        Assertions.assertEquals(
+            List.of("SHOW INDEX FROM `bad``table` FROM `bad``schema`"),
+            JdbcMetadataSqlFake.statements
+        );
+    }
+
+    @Test
+    void constrainedTableMetadataPushesFilterTypesAndPaging() {
+        GoldendbAgent agent = new GoldendbAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listTables("app", new MetadataListConstraints("ord", 25, 50, List.of("TABLE", "VIEW")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        Assertions.assertTrue(sql.contains("FROM information_schema.TABLES"), sql);
+        Assertions.assertTrue(sql.contains("TABLE_TYPE IN (?, ?)"), sql);
+        Assertions.assertTrue(sql.contains("UPPER(TABLE_NAME) LIKE ? ESCAPE '\\\\'"), sql);
+        Assertions.assertTrue(sql.endsWith("LIMIT 25 OFFSET 50"), sql);
+    }
+
+    @Test
+    void constrainedObjectMetadataPushesRoutineTypesAndPaging() {
+        GoldendbAgent agent = new GoldendbAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listObjects("app", new MetadataListConstraints("sync", 10, null, List.of("PROCEDURE", "FUNCTION")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        Assertions.assertTrue(sql.contains("FROM information_schema.ROUTINES"), sql);
+        Assertions.assertTrue(sql.contains("ROUTINE_TYPE IN (?, ?)"), sql);
+        Assertions.assertTrue(sql.contains("ORDER BY CASE OBJECT_TYPE"), sql);
+        Assertions.assertTrue(sql.endsWith("LIMIT 10"), sql);
+    }
+}
diff --git a/agents/drivers/goldendb/src/test/java/com/dbx/agent/goldendb/GoldendbAgentTest.java b/agents/drivers/goldendb/src/test/java/com/dbx/agent/goldendb/GoldendbAgentTest.java
new file mode 100644
index 0000000..c22fa1d
--- /dev/null
+++ b/agents/drivers/goldendb/src/test/java/com/dbx/agent/goldendb/GoldendbAgentTest.java
@@ -0,0 +1,16 @@
+package com.dbx.agent.goldendb;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+
+class GoldendbAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new GoldendbAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL sample_proc()";
+    }
+}
diff --git a/agents/drivers/h2-legacy/build.gradle b/agents/drivers/h2-legacy/build.gradle
new file mode 100644
index 0000000..bed8682
--- /dev/null
+++ b/agents/drivers/h2-legacy/build.gradle
@@ -0,0 +1,13 @@
+sourceSets {
+    main.java.srcDirs = ['src/main/java', '../h2/src/main/java']
+}
+
+dependencies {
+    implementation 'com.h2database:h2:2.1.214'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'H2 2.1 Legacy', 'Main-Class': 'com.dbx.agent.h2legacy.H2LegacyAgent')
+    }
+}
diff --git a/agents/drivers/h2-legacy/src/main/java/com/dbx/agent/h2legacy/H2LegacyAgent.java b/agents/drivers/h2-legacy/src/main/java/com/dbx/agent/h2legacy/H2LegacyAgent.java
new file mode 100644
index 0000000..18c65dd
--- /dev/null
+++ b/agents/drivers/h2-legacy/src/main/java/com/dbx/agent/h2legacy/H2LegacyAgent.java
@@ -0,0 +1,10 @@
+package com.dbx.agent.h2legacy;
+
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.h2.H2Agent;
+
+public final class H2LegacyAgent extends H2Agent {
+    public static void main(String[] args) {
+        new JsonRpcServer(new H2LegacyAgent()).run();
+    }
+}
diff --git a/agents/drivers/h2/build.gradle b/agents/drivers/h2/build.gradle
new file mode 100644
index 0000000..070380f
--- /dev/null
+++ b/agents/drivers/h2/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.h2database:h2:2.3.232'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'H2', 'Main-Class': 'com.dbx.agent.h2.H2Agent')
+    }
+}
diff --git a/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2Agent.java b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2Agent.java
new file mode 100644
index 0000000..19fd1a1
--- /dev/null
+++ b/agents/drivers/h2/src/main/java/com/dbx/agent/h2/H2Agent.java
@@ -0,0 +1,516 @@
+package com.dbx.agent.h2;
+
+import com.dbx.agent.AbstractJdbcAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcExecutor;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.MetadataSqlSupport;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+
+import java.nio.charset.StandardCharsets;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+public class H2Agent extends AbstractJdbcAgent {
+    private String databaseName = "";
+
+    @Override
+    protected String driverClass() {
+        return "org.h2.Driver";
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return buildUrl(params);
+    }
+
+    @Override
+    protected void afterConnect(ConnectParams params, Connection connection) {
+        databaseName = params.getDatabase();
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return List.of(new DatabaseInfo(databaseName.isBlank() ? "default" : databaseName));
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return unchecked(() -> {
+            List<String> result = new ArrayList<>();
+            try (var stmt = requireConnected().prepareStatement(
+                "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA ORDER BY SCHEMA_NAME"
+            );
+                 ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    result.add(rs.getString(1));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            String effectiveSchema = resolveSchema(schema);
+            List<TableInfo> result = new ArrayList<>();
+            try (var stmt = requireConnected().prepareStatement(
+                """
+                SELECT TABLE_NAME, TABLE_TYPE
+                FROM INFORMATION_SCHEMA.TABLES
+                WHERE TABLE_SCHEMA = ?
+                ORDER BY TABLE_NAME
+                """
+            )) {
+                stmt.setString(1, effectiveSchema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String tableType = rs.getString("TABLE_TYPE");
+                        if ("BASE TABLE".equals(tableType)) {
+                            tableType = "TABLE";
+                        }
+                        result.add(new TableInfo(rs.getString("TABLE_NAME"), tableType, null));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listTables(schema);
+        }
+        if (!normalized.includesTableLikeTypes()) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedTables(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterTables(listTables(schema));
+        }
+    }
+
+    private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            String effectiveSchema = resolveSchema(schema);
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            StringBuilder sql = new StringBuilder("SELECT TABLE_NAME, TABLE_TYPE FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ?");
+            args.add(effectiveSchema);
+            appendH2TableTypePredicate(sql, args, constraints);
+            MetadataSqlSupport.appendNameFilter(sql, args, "TABLE_NAME", constraints);
+            sql.append(" ORDER BY TABLE_NAME");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (var stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(rs.getString("TABLE_NAME"), normalizeTableType(rs.getString("TABLE_TYPE")), null));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterTables(result);
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return unchecked(() -> {
+            String effectiveSchema = resolveSchema(schema);
+            List<ObjectInfo> result = new ArrayList<>();
+            for (TableInfo table : listTables(schema)) {
+                result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+            }
+
+            try (var stmt = requireConnected().prepareStatement(
+                "SELECT ROUTINE_NAME, ROUTINE_TYPE FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA = ? ORDER BY ROUTINE_NAME"
+            )) {
+                stmt.setString(1, effectiveSchema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1), rs.getString(2), schema, null));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listObjects(schema);
+        }
+        if (!includesSupportedObjects(normalized)) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedObjects(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterObjects(listObjects(schema));
+        }
+    }
+
+    private List<ObjectInfo> queryConstrainedObjects(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            String effectiveSchema = resolveSchema(schema);
+            List<ObjectInfo> result = new ArrayList<>();
+            List<String> branches = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            if (constraints.includesTableLikeTypes()) {
+                StringBuilder tableSql = new StringBuilder("SELECT TABLE_NAME AS OBJECT_NAME, TABLE_TYPE AS OBJECT_TYPE FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ?");
+                args.add(effectiveSchema);
+                appendH2TableTypePredicate(tableSql, args, constraints);
+                MetadataSqlSupport.appendNameFilter(tableSql, args, "TABLE_NAME", constraints);
+                branches.add(tableSql.toString());
+            }
+            if (constraints.objectTypeAllowed("PROCEDURE") || constraints.objectTypeAllowed("FUNCTION")) {
+                StringBuilder routineSql = new StringBuilder("SELECT ROUTINE_NAME AS OBJECT_NAME, ROUTINE_TYPE AS OBJECT_TYPE FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA = ?");
+                args.add(effectiveSchema);
+                appendRoutineTypePredicate(routineSql, args, constraints);
+                MetadataSqlSupport.appendNameFilter(routineSql, args, "ROUTINE_NAME", constraints);
+                branches.add(routineSql.toString());
+            }
+            if (branches.isEmpty()) {
+                return List.of();
+            }
+            StringBuilder sql = new StringBuilder("SELECT OBJECT_NAME, OBJECT_TYPE FROM (")
+                .append(String.join(" UNION ALL ", branches))
+                .append(") metadata_objects ORDER BY CASE OBJECT_TYPE WHEN 'BASE TABLE' THEN 0 WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 WHEN 'PROCEDURE' THEN 2 WHEN 'FUNCTION' THEN 3 ELSE 9 END, OBJECT_NAME");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (var stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1), normalizeTableType(rs.getString(2)), schema, null));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterObjects(result);
+        });
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        return unchecked(() -> {
+            String effectiveSchema = resolveSchema(schema);
+            String sql = switch (objectType.toUpperCase(Locale.ROOT)) {
+                case "VIEW" -> "SELECT VIEW_DEFINITION FROM INFORMATION_SCHEMA.VIEWS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?";
+                case "FUNCTION", "PROCEDURE" -> "SELECT ROUTINE_DEFINITION FROM INFORMATION_SCHEMA.ROUTINES WHERE ROUTINE_SCHEMA = ? AND ROUTINE_NAME = ?";
+                default -> throw new IllegalArgumentException("Unsupported object type: " + objectType);
+            };
+
+            String source = "";
+            try (var stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, effectiveSchema);
+                stmt.setString(2, name);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    if (rs.next()) {
+                        String value = rs.getString(1);
+                        source = value == null ? "" : value;
+                    }
+                }
+            }
+            return new ObjectSource(name, objectType, schema, source);
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            String effectiveSchema = resolveSchema(schema);
+            Set<String> primaryKeys = new HashSet<>();
+            try (var stmt = requireConnected().prepareStatement(
+                """
+                SELECT ic.COLUMN_NAME
+                FROM INFORMATION_SCHEMA.INDEX_COLUMNS ic
+                JOIN INFORMATION_SCHEMA.INDEXES i
+                  ON ic.INDEX_SCHEMA = i.INDEX_SCHEMA AND ic.INDEX_NAME = i.INDEX_NAME
+                WHERE ic.TABLE_SCHEMA = ? AND ic.TABLE_NAME = ?
+                  AND i.INDEX_TYPE_NAME = 'PRIMARY KEY'
+                """
+            )) {
+                stmt.setString(1, effectiveSchema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        primaryKeys.add(rs.getString("COLUMN_NAME"));
+                    }
+                }
+            }
+
+            List<ColumnInfo> result = new ArrayList<>();
+            try (var stmt = requireConnected().prepareStatement(
+                """
+                SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT,
+                       NUMERIC_PRECISION, NUMERIC_SCALE, CHARACTER_MAXIMUM_LENGTH
+                FROM INFORMATION_SCHEMA.COLUMNS
+                WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+                ORDER BY ORDINAL_POSITION
+                """
+            )) {
+                stmt.setString(1, effectiveSchema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String columnName = rs.getString("COLUMN_NAME");
+                        result.add(new ColumnInfo(
+                            columnName,
+                            rs.getString("DATA_TYPE"),
+                            "YES".equals(rs.getString("IS_NULLABLE")),
+                            rs.getString("COLUMN_DEFAULT"),
+                            primaryKeys.contains(columnName),
+                            null,
+                            null,
+                            intOrNull(rs, "NUMERIC_PRECISION"),
+                            intOrNull(rs, "NUMERIC_SCALE"),
+                            intOrNull(rs, "CHARACTER_MAXIMUM_LENGTH")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return unchecked(() -> {
+            String effectiveSchema = resolveSchema(schema);
+            Map<String, List<String>> indexMap = new LinkedHashMap<>();
+            Map<String, Boolean> uniqueMap = new HashMap<>();
+            Map<String, Boolean> primaryMap = new HashMap<>();
+            Map<String, String> typeMap = new HashMap<>();
+
+            try (var stmt = requireConnected().prepareStatement(
+                """
+                SELECT i.INDEX_NAME, ic.COLUMN_NAME, ic.IS_UNIQUE, i.INDEX_TYPE_NAME
+                FROM INFORMATION_SCHEMA.INDEX_COLUMNS ic
+                JOIN INFORMATION_SCHEMA.INDEXES i
+                  ON ic.INDEX_SCHEMA = i.INDEX_SCHEMA AND ic.INDEX_NAME = i.INDEX_NAME
+                WHERE ic.TABLE_SCHEMA = ? AND ic.TABLE_NAME = ?
+                ORDER BY i.INDEX_NAME, ic.ORDINAL_POSITION
+                """
+            )) {
+                stmt.setString(1, effectiveSchema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String indexName = rs.getString("INDEX_NAME");
+                        String columnName = rs.getString("COLUMN_NAME");
+                        String indexType = rs.getString("INDEX_TYPE_NAME");
+
+                        indexMap.computeIfAbsent(indexName, ignored -> new ArrayList<>()).add(columnName);
+                        uniqueMap.put(indexName, rs.getBoolean("IS_UNIQUE"));
+                        primaryMap.put(indexName, "PRIMARY KEY".equals(indexType));
+                        typeMap.put(indexName, indexType == null ? "" : indexType);
+                    }
+                }
+            }
+
+            List<IndexInfo> result = new ArrayList<>();
+            for (Map.Entry<String, List<String>> entry : indexMap.entrySet()) {
+                String name = entry.getKey();
+                result.add(new IndexInfo(
+                    name,
+                    entry.getValue(),
+                    uniqueMap.getOrDefault(name, false),
+                    primaryMap.getOrDefault(name, false),
+                    null,
+                    typeMap.get(name),
+                    null,
+                    null
+                ));
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return unchecked(() -> {
+            String effectiveSchema = resolveSchema(schema);
+            List<ForeignKeyInfo> result = new ArrayList<>();
+            try (var stmt = requireConnected().prepareStatement(
+                """
+                SELECT FK_NAME, FKCOLUMN_NAME, PKTABLE_NAME, PKCOLUMN_NAME
+                FROM INFORMATION_SCHEMA.CROSS_REFERENCES
+                WHERE FKTABLE_SCHEMA = ? AND FKTABLE_NAME = ?
+                ORDER BY FK_NAME
+                """
+            )) {
+                stmt.setString(1, effectiveSchema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ForeignKeyInfo(
+                            rs.getString("FK_NAME"),
+                            rs.getString("FKCOLUMN_NAME"),
+                            rs.getString("PKTABLE_NAME"),
+                            rs.getString("PKCOLUMN_NAME")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return unchecked(() -> {
+            String effectiveSchema = resolveSchema(schema);
+            List<TriggerInfo> result = new ArrayList<>();
+            try (var stmt = requireConnected().prepareStatement(
+                """
+                SELECT TRIGGER_NAME, EVENT_MANIPULATION, ACTION_TIMING
+                FROM INFORMATION_SCHEMA.TRIGGERS
+                WHERE TRIGGER_SCHEMA = ? AND EVENT_OBJECT_TABLE = ?
+                ORDER BY TRIGGER_NAME
+                """
+            )) {
+                stmt.setString(1, effectiveSchema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TriggerInfo(
+                            rs.getString("TRIGGER_NAME"),
+                            rs.getString("EVENT_MANIPULATION"),
+                            rs.getString("ACTION_TIMING")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "SET SCHEMA " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
+    }
+
+    @Override
+    protected Object resultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> JdbcExecutor.INSTANCE.defaultResultValue(rs, index, sqlType));
+    }
+
+    @Override
+    protected JdbcExecutor.ColumnAwareResultValueReader resultValueReader() {
+        return (rs, index, sqlType, columnTypeName) -> {
+            if (isJsonType(columnTypeName)) {
+                byte[] bytes = rs.getBytes(index);
+                // H2 stores JSON as UTF-8 bytes and getString/default JDBC
+                // handling exposes a hex literal such as 0x5b5d. Decode only
+                // JSON columns so real binary data keeps the existing hex view.
+                return rs.wasNull() || bytes == null ? null : new String(bytes, StandardCharsets.UTF_8);
+            }
+            return resultValue(rs, index, sqlType);
+        };
+    }
+
+    static String buildUrl(ConnectParams params) {
+        String connectionString = params.getConnection_string();
+        if (connectionString != null && !connectionString.trim().isEmpty()) {
+            return connectionString.trim();
+        }
+        if (params.getHost().isBlank()) {
+            return "jdbc:h2:" + params.getDatabase();
+        }
+        return "jdbc:h2:tcp://" + params.getHost() + ":" + params.getPort() + "/" + params.getDatabase();
+    }
+
+    private static boolean isUnconstrained(MetadataListConstraints constraints) {
+        return !constraints.hasFilter() && !constraints.hasLimit() && !constraints.hasOffset() && !constraints.hasObjectTypes();
+    }
+
+    private static boolean includesSupportedObjects(MetadataListConstraints constraints) {
+        return constraints.includesTableLikeTypes()
+            || constraints.objectTypeAllowed("PROCEDURE")
+            || constraints.objectTypeAllowed("FUNCTION");
+    }
+
+    private static void appendH2TableTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> types = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            types.add("BASE TABLE");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            types.add("VIEW");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND TABLE_TYPE IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
+        args.addAll(types);
+    }
+
+    private static void appendRoutineTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> types = new ArrayList<>();
+        if (constraints.objectTypeAllowed("PROCEDURE")) {
+            types.add("PROCEDURE");
+        }
+        if (constraints.objectTypeAllowed("FUNCTION")) {
+            types.add("FUNCTION");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND ROUTINE_TYPE IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
+        args.addAll(types);
+    }
+
+    private static String normalizeTableType(String tableType) {
+        return "BASE TABLE".equals(tableType) ? "TABLE" : tableType;
+    }
+
+    private static String resolveSchema(String schema) {
+        if ("PUBLIC".equalsIgnoreCase(schema) || "INFORMATION_SCHEMA".equalsIgnoreCase(schema)) {
+            return schema.toUpperCase(Locale.ROOT);
+        }
+        return "PUBLIC";
+    }
+
+    private static Integer intOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    private static boolean isJsonType(String columnTypeName) {
+        return columnTypeName != null && "JSON".equals(columnTypeName.trim().toUpperCase(Locale.ROOT));
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new H2Agent()).run();
+    }
+}
diff --git a/agents/drivers/h2/src/test/java/com/dbx/agent/h2/H2AgentTest.java b/agents/drivers/h2/src/test/java/com/dbx/agent/h2/H2AgentTest.java
new file mode 100644
index 0000000..350b168
--- /dev/null
+++ b/agents/drivers/h2/src/test/java/com/dbx/agent/h2/H2AgentTest.java
@@ -0,0 +1,165 @@
+package com.dbx.agent.h2;
+
+import com.dbx.agent.BaseDatabaseAgent;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.test.JdbcExecutionBehaviorTest;
+import com.dbx.agent.test.JdbcMetadataBehaviorTest;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class H2AgentMigrationTest {
+    @Test
+    void agentExtendsBaseDatabaseAgent() {
+        Assertions.assertTrue(BaseDatabaseAgent.class.isAssignableFrom(H2Agent.class));
+    }
+
+    @Test
+    void buildUrlUsesExplicitConnectionString() {
+        ConnectParams params = new ConnectParams(
+            "127.0.0.1",
+            9092,
+            "test",
+            "sa",
+            "",
+            "",
+            "jdbc:h2:file:/tmp/dbx-h2-test;AUTO_SERVER=TRUE",
+            false
+        );
+
+        Assertions.assertEquals("jdbc:h2:file:/tmp/dbx-h2-test;AUTO_SERVER=TRUE", H2Agent.buildUrl(params));
+    }
+
+    @Test
+    void buildUrlKeepsTcpModeWhenNoConnectionString() {
+        ConnectParams params = new ConnectParams("127.0.0.1", 9092, "test", "sa", "", "", "", false);
+
+        Assertions.assertEquals("jdbc:h2:tcp://127.0.0.1:9092/test", H2Agent.buildUrl(params));
+    }
+}
+
+class H2ExecutionBehaviorTest extends JdbcExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createConnectedAgent(String databaseName) {
+        return H2AgentTestSupport.createH2Agent(databaseName);
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL 42";
+    }
+
+    @Override
+    protected List<String> expectedResultSetColumns() {
+        return List.of("42");
+    }
+
+    @Override
+    protected List<List<Object>> expectedResultSetRows() {
+        return List.of(List.<Object>of(42));
+    }
+
+    @Override
+    protected String rowsSql(int rowCount) {
+        return "SELECT X FROM SYSTEM_RANGE(1, " + rowCount + ")";
+    }
+
+    @Test
+    void displaysJsonColumnsAsText() {
+        withAgent("dbx-agent-h2-json", agent -> {
+            agent.executeQuery(
+                "CREATE TABLE EVENTS (ID INT PRIMARY KEY, ACTION_PARAMS JSON, RAW_BYTES VARBINARY)",
+                null,
+                new ExecuteQueryOptions()
+            );
+            agent.executeQuery(
+                "INSERT INTO EVENTS VALUES (1, JSON '[]', X'5B5D'), (2, JSON '[{\"type\":\"ACCESS_CONTROL\"}]', X'00FF')",
+                null,
+                new ExecuteQueryOptions()
+            );
+
+            QueryResult result = agent.executeQuery(
+                "SELECT ACTION_PARAMS, RAW_BYTES FROM EVENTS ORDER BY ID",
+                null,
+                new ExecuteQueryOptions()
+            );
+
+            Assertions.assertEquals(
+                List.of(
+                    List.of("[]", "0x5b5d"),
+                    List.of("[{\"type\":\"ACCESS_CONTROL\"}]", "0x00ff")
+                ),
+                result.getRows()
+            );
+        });
+    }
+}
+
+class H2MetadataBehaviorTest extends JdbcMetadataBehaviorTest {
+    @Override
+    protected DatabaseAgent createConnectedAgent(String databaseName) {
+        return H2AgentTestSupport.createH2Agent(databaseName);
+    }
+
+    @Override
+    protected List<String> metadataFixtureSql() {
+        return List.of(
+            "CREATE TABLE BETA_TABLE (ID INT PRIMARY KEY)",
+            "CREATE TABLE ALPHA_TABLE (ID INT PRIMARY KEY)",
+            "CREATE TABLE COLUMN_ORDER_SAMPLE (ID INT PRIMARY KEY, NAME VARCHAR(64), CREATED_AT TIMESTAMP)"
+        );
+    }
+
+    @Override
+    protected String metadataSchema() {
+        return "PUBLIC";
+    }
+
+    @Override
+    protected List<String> expectedTablesInOrder() {
+        return List.of("ALPHA_TABLE", "BETA_TABLE", "COLUMN_ORDER_SAMPLE");
+    }
+
+    @Override
+    protected String metadataColumnsTable() {
+        return "COLUMN_ORDER_SAMPLE";
+    }
+
+    @Override
+    protected List<String> expectedColumnsInOrder() {
+        return List.of("ID", "NAME", "CREATED_AT");
+    }
+
+    @Test
+    void constrainedTableMetadataFiltersTypesAndPages() {
+        withAgent("dbx-agent-h2-constrained-metadata", agent -> {
+            for (String sql : metadataFixtureSql()) {
+                agent.executeQuery(sql, null, new ExecuteQueryOptions());
+            }
+
+            List<TableInfo> tables = agent.listTables(
+                metadataSchema(),
+                new MetadataListConstraints("table", 1, 1, List.of("TABLE"))
+            );
+
+            Assertions.assertEquals(1, tables.size());
+            Assertions.assertEquals("BETA_TABLE", tables.get(0).getName());
+        });
+    }
+}
+
+final class H2AgentTestSupport {
+    private H2AgentTestSupport() {
+    }
+
+    static DatabaseAgent createH2Agent(String databaseName) {
+        H2Agent agent = new H2Agent();
+        agent.connect(new ConnectParams("", 0, "mem:" + databaseName + ";DB_CLOSE_DELAY=-1", "", "", "", "", false));
+        return agent;
+    }
+}
diff --git a/agents/drivers/highgo/build.gradle b/agents/drivers/highgo/build.gradle
new file mode 100644
index 0000000..1b944ab
--- /dev/null
+++ b/agents/drivers/highgo/build.gradle
@@ -0,0 +1,16 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.highgo:HgdbJdbc:6.2.4'
+    // PostGIS JDBC is optional: EwkbWktDecoder reflectively probes for
+    // org.postgis.PGgeometry / net.postgis.jdbc.PGgeometry and falls back to
+    // its own EWKB parser when the class is absent. compileOnly keeps the
+    // shadowJar small while still letting users drop the jar into their
+    // user-driver path if they prefer the upstream parser.
+    compileOnly 'net.postgis:postgis-jdbc:2024.1.0'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': '瀚高 HighGo', 'Main-Class': 'com.dbx.agent.highgo.HighgoAgent')
+    }
+}
diff --git a/agents/drivers/highgo/src/main/java/com/dbx/agent/highgo/HighgoAgent.java b/agents/drivers/highgo/src/main/java/com/dbx/agent/highgo/HighgoAgent.java
new file mode 100644
index 0000000..ee9e6b1
--- /dev/null
+++ b/agents/drivers/highgo/src/main/java/com/dbx/agent/highgo/HighgoAgent.java
@@ -0,0 +1,20 @@
+package com.dbx.agent.highgo;
+
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.PostgresLikeAgent;
+import com.dbx.agent.PostgresLikeAgentProfile;
+
+public final class HighgoAgent extends PostgresLikeAgent {
+    public static final PostgresLikeAgentProfile HIGHGO_PROFILE = new PostgresLikeAgentProfile(
+        "com.highgo.jdbc.Driver",
+        "jdbc:highgo://{host}:{port}/{database}"
+    );
+
+    public HighgoAgent() {
+        super(HIGHGO_PROFILE);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new HighgoAgent()).run();
+    }
+}
diff --git a/agents/drivers/highgo/src/test/java/com/dbx/agent/highgo/HighgoAgentTest.java b/agents/drivers/highgo/src/test/java/com/dbx/agent/highgo/HighgoAgentTest.java
new file mode 100644
index 0000000..2186312
--- /dev/null
+++ b/agents/drivers/highgo/src/test/java/com/dbx/agent/highgo/HighgoAgentTest.java
@@ -0,0 +1,46 @@
+package com.dbx.agent.highgo;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import com.dbx.agent.test.JdbcMetadataSqlFake;
+import com.dbx.agent.test.TestSupport;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+
+class HighgoAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new HighgoAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL sample_proc()";
+    }
+
+    @Test
+    void declaresHighgoPostgresLikeProfile() {
+        HighgoAgent agent = new HighgoAgent();
+
+        Assertions.assertEquals("com.highgo.jdbc.Driver", agent.getProfile().getDriverClass());
+        Assertions.assertEquals("jdbc:highgo://{host}:{port}/{database}", agent.getProfile().getUrlTemplate());
+    }
+
+    @Test
+    void readsViewSourceWithQuotedRegclassParameter() {
+        HighgoAgent agent = new HighgoAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.getObjectSource("bad\"schema", "view's name", "VIEW");
+
+        Assertions.assertEquals(
+            Arrays.asList(
+                "SELECT pg_get_viewdef(to_regclass(?), true)",
+                "param:1=\"bad\"\"schema\".\"view's name\""
+            ),
+            JdbcMetadataSqlFake.statements
+        );
+    }
+}
diff --git a/agents/drivers/hive/build.gradle b/agents/drivers/hive/build.gradle
new file mode 100644
index 0000000..8787dd7
--- /dev/null
+++ b/agents/drivers/hive/build.gradle
@@ -0,0 +1,11 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'org.apache.hive:hive-jdbc:4.0.1:standalone'
+    implementation 'org.slf4j:slf4j-nop:1.7.30'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Apache Hive', 'Main-Class': 'com.dbx.agent.hive.HiveAgent')
+    }
+}
diff --git a/agents/drivers/hive/src/main/java/com/dbx/agent/hive/HiveAgent.java b/agents/drivers/hive/src/main/java/com/dbx/agent/hive/HiveAgent.java
new file mode 100644
index 0000000..c4cef21
--- /dev/null
+++ b/agents/drivers/hive/src/main/java/com/dbx/agent/hive/HiveAgent.java
@@ -0,0 +1,274 @@
+package com.dbx.agent.hive;
+
+import com.dbx.agent.AbstractJdbcAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.QueryPageOptions;
+import com.dbx.agent.QueryPageResult;
+import com.dbx.agent.QueryResult;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+
+public final class HiveAgent extends AbstractJdbcAgent {
+
+    @Override
+    protected String driverClass() {
+        return "org.apache.hive.jdbc.HiveDriver";
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return buildUrl(params);
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW DATABASES")) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString(1)));
+                }
+            }
+            result.sort(Comparator.comparing(DatabaseInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        List<String> result = new ArrayList<>();
+        for (DatabaseInfo database : listDatabases()) {
+            result.add(database.getName());
+        }
+        return result;
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            useSchema(schema);
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW TABLES")) {
+                while (rs.next()) {
+                    result.add(new TableInfo(rs.getString(1), "TABLE", null));
+                }
+            }
+            result.sort(Comparator.comparing(TableInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            try {
+                return getColumnsFromDescribe(schema, table);
+            } catch (Exception ignored) {
+                return getColumnsFromMetadata(requireConnected(), schema, table);
+            }
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "USE " + JdbcIdentifiers.INSTANCE.backtick(schema);
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        // Hive JDBC fetches rows via Thrift FetchResults in batches controlled
+        // by fetchSize. A large fetchSize can fail with "Error retrieving next
+        // row" when the result contains large binary/struct columns. Use a
+        // small fetchSize (50) so each Thrift batch stays within limits.
+        return super.executeQuery(sql, schema, new ExecuteQueryOptions(
+            options.getMaxRows(),
+            50,
+            options.getTimeoutSecs()
+        ));
+    }
+
+    @Override
+    public QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {
+        return super.executeQueryPage(sql, schema, withSmallFetchSize(options));
+    }
+
+    @Override
+    public QueryPageResult startTableRead(String sql, String schema, QueryPageOptions options) {
+        return super.startTableRead(sql, schema, withSmallFetchSize(options));
+    }
+
+    private static QueryPageOptions withSmallFetchSize(QueryPageOptions options) {
+        return new QueryPageOptions(
+            options.getPageSize(), 50, options.getMaxRows(), options.getTimeoutSecs()
+        );
+    }
+
+    @Override
+    protected Object resultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value = rs.getObject(index);
+            return rs.wasNull() ? null : value == null ? null : value.toString();
+        });
+    }
+
+    private void useSchema(String schema) throws Exception {
+        try (java.sql.Statement stmt = requireConnected().createStatement()) {
+            stmt.execute(setSchemaSQL(schema));
+        }
+    }
+
+    private List<ColumnInfo> getColumnsFromDescribe(String schema, String table) throws Exception {
+        List<ColumnInfo> result = new ArrayList<>();
+        useSchema(schema);
+        try (java.sql.Statement stmt = requireConnected().createStatement();
+             ResultSet rs = stmt.executeQuery("DESCRIBE " + JdbcIdentifiers.INSTANCE.backtick(table))) {
+            while (rs.next()) {
+                String colName = trimToNull(rs.getString(1));
+                if (colName == null || colName.startsWith("#")) {
+                    continue;
+                }
+                result.add(new ColumnInfo(
+                    colName,
+                    trimToEmpty(rs.getString(2)),
+                    true,
+                    null,
+                    false,
+                    null,
+                    optionalComment(rs),
+                    null,
+                    null,
+                    null
+                ));
+            }
+        }
+        return result;
+    }
+
+    private static List<ColumnInfo> getColumnsFromMetadata(Connection conn, String schema, String table) throws Exception {
+        List<ColumnInfo> result = new ArrayList<>();
+        DatabaseMetaData meta = conn.getMetaData();
+        try (ResultSet rs = meta.getColumns(null, trimToNull(schema), table, "%")) {
+            while (rs.next()) {
+                String name = rs.getString("COLUMN_NAME");
+                if (trimToNull(name) == null) {
+                    continue;
+                }
+                result.add(new ColumnInfo(
+                    name,
+                    trimToEmpty(rs.getString("TYPE_NAME")),
+                    rs.getInt("NULLABLE") != DatabaseMetaData.columnNoNulls,
+                    rs.getString("COLUMN_DEF"),
+                    false,
+                    null,
+                    rs.getString("REMARKS"),
+                    intOrNull(rs, "COLUMN_SIZE"),
+                    intOrNull(rs, "DECIMAL_DIGITS"),
+                    characterLength(rs)
+                ));
+            }
+        }
+        return result;
+    }
+
+    static String buildUrl(ConnectParams params) {
+        String connectionString = trimToEmpty(params.getConnection_string());
+        if (!connectionString.isEmpty()) {
+            return connectionString;
+        }
+        String url = "jdbc:hive2://" + params.getHost() + ":" + params.getPort() + "/" + params.getDatabase();
+        return appendHiveUrlParams(url, params.getUrl_params());
+    }
+
+    private static String appendHiveUrlParams(String url, String urlParams) {
+        String params = trimHiveUrlParams(urlParams);
+        if (params.isEmpty()) {
+            return url;
+        }
+        // Hive JDBC authentication options use semicolon-separated URL properties.
+        return url + (url.endsWith(";") ? "" : ";") + params;
+    }
+
+    private static String trimHiveUrlParams(String urlParams) {
+        String value = trimToEmpty(urlParams);
+        while (value.startsWith("?") || value.startsWith("&") || value.startsWith(";")) {
+            value = value.substring(1);
+        }
+        return value;
+    }
+
+    private static String trimToNull(String value) {
+        if (value == null) {
+            return null;
+        }
+        String trimmed = value.trim();
+        return trimmed.isEmpty() ? null : trimmed;
+    }
+
+    private static String trimToEmpty(String value) {
+        return value == null ? "" : value.trim();
+    }
+
+    private static Integer intOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    private static Integer characterLength(ResultSet rs) throws Exception {
+        String typeName = rs.getString("TYPE_NAME");
+        if (typeName == null) {
+            return null;
+        }
+        String normalized = typeName.toLowerCase(Locale.ROOT);
+        if (!normalized.contains("char") && !normalized.contains("text") && !normalized.contains("string")) {
+            return null;
+        }
+        return intOrNull(rs, "COLUMN_SIZE");
+    }
+
+    private static String optionalComment(ResultSet rs) {
+        return unchecked(() -> {
+            try {
+                String comment = trimToNull(rs.getString(3));
+                return comment;
+            } catch (Exception e) {
+                return null;
+            }
+        });
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new HiveAgent()).run();
+    }
+}
diff --git a/agents/drivers/hive/src/test/java/com/dbx/agent/hive/HiveAgentExecutionTest.java b/agents/drivers/hive/src/test/java/com/dbx/agent/hive/HiveAgentExecutionTest.java
new file mode 100644
index 0000000..3e7e2c5
--- /dev/null
+++ b/agents/drivers/hive/src/test/java/com/dbx/agent/hive/HiveAgentExecutionTest.java
@@ -0,0 +1,77 @@
+package com.dbx.agent.hive;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.QueryPageOptions;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.test.JdbcAgentFake;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import com.dbx.agent.test.TestSupport;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class HiveAgentExecutionTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new HiveAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "MSCK REPAIR TABLE sample";
+    }
+
+    // Override: HiveAgent.executeQuery forces fetchSize=50 to keep Thrift
+    // FetchResults batches small (prevents "Error retrieving next row" on
+    // tables with large binary/struct columns).
+    @Override
+    @Test
+    protected void executesNonSelectStatementsThatReturnResultSets() {
+        DatabaseAgent agent = createAgent();
+        TestSupport.setPrivateConnection(agent, JdbcAgentFake.connection());
+
+        QueryResult result = agent.executeQuery(resultSetSql(), null, new ExecuteQueryOptions());
+
+        assertEquals(Collections.singletonList("VALUE"), result.getColumns());
+        assertEquals(Collections.singletonList(Collections.singletonList("row-value")), result.getRows());
+        assertEquals(Arrays.asList("setMaxRows:10001", "setFetchSize:50", "execute"), JdbcAgentFake.calls);
+    }
+
+    @Override
+    @Test
+    protected void appliesExecutionRowAndFetchLimitsToJdbcStatements() {
+        DatabaseAgent agent = createAgent();
+        TestSupport.setPrivateConnection(agent, JdbcAgentFake.connection());
+
+        QueryResult result = agent.executeQuery(resultSetSql(), null, new ExecuteQueryOptions(1, 25));
+
+        assertEquals(Collections.singletonList(Collections.singletonList("row-value")), result.getRows());
+        assertEquals(Arrays.asList("setMaxRows:2", "setFetchSize:50", "execute"), JdbcAgentFake.calls);
+    }
+
+    @Override
+    @Test
+    protected void pagedQueryExecutionPassesCallerFetchSizeToStatement() {
+        DatabaseAgent agent = createAgent();
+        TestSupport.setPrivateConnection(agent, JdbcAgentFake.connection());
+
+        agent.executeQueryPage(resultSetSql(), null, new QueryPageOptions(100, 500, 1000));
+
+        assertEquals(Arrays.asList("setFetchSize:50", "execute"), JdbcAgentFake.calls);
+    }
+
+    @Override
+    @Test
+    protected void tableReadPassesCallerFetchSizeToStatement() {
+        DatabaseAgent agent = createAgent();
+        TestSupport.setPrivateConnection(agent, JdbcAgentFake.connection());
+
+        agent.startTableRead(resultSetSql(), null, new QueryPageOptions(100, 500, 1000));
+
+        assertEquals(Arrays.asList("setFetchSize:50", "execute"), JdbcAgentFake.calls);
+    }
+}
diff --git a/agents/drivers/hive/src/test/java/com/dbx/agent/hive/HiveAgentMetadataTest.java b/agents/drivers/hive/src/test/java/com/dbx/agent/hive/HiveAgentMetadataTest.java
new file mode 100644
index 0000000..0ec4fa8
--- /dev/null
+++ b/agents/drivers/hive/src/test/java/com/dbx/agent/hive/HiveAgentMetadataTest.java
@@ -0,0 +1,186 @@
+package com.dbx.agent.hive;
+
+import com.dbx.agent.test.TestSupport;
+import com.dbx.agent.test.JdbcMetadataSqlFake;
+import com.dbx.agent.ColumnInfo;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.util.List;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class HiveAgentMetadataTest {
+    @Test
+    void quotesSchemaAndTableIdentifiersInMetadataSql() {
+        HiveAgent agent = new HiveAgent();
+        Connection fake = JdbcMetadataSqlFake.connection();
+        TestSupport.setPrivateConnection(agent, fake);
+
+        agent.listTables("bad`schema");
+        agent.getColumns("bad`schema", "bad`table");
+
+        Assertions.assertEquals(
+            List.of(
+                "USE `bad``schema`",
+                "SHOW TABLES",
+                "USE `bad``schema`",
+                "DESCRIBE `bad``table`"
+            ),
+            JdbcMetadataSqlFake.statements
+        );
+    }
+
+    @Test
+    void fallsBackToJdbcMetadataWhenDescribeCannotCreateResultSet() {
+        HiveAgent agent = new HiveAgent();
+        Connection fake = describeFailingMetadataConnection();
+        TestSupport.setPrivateConnection(agent, fake);
+
+        List<ColumnInfo> columns = agent.getColumns("default", "events");
+
+        Assertions.assertEquals(2, columns.size());
+        Assertions.assertEquals("id", columns.get(0).getName());
+        Assertions.assertEquals("bigint", columns.get(0).getData_type());
+        Assertions.assertFalse(columns.get(0).getIs_nullable());
+        Assertions.assertEquals("name", columns.get(1).getName());
+        Assertions.assertEquals("string", columns.get(1).getData_type());
+        Assertions.assertEquals(Integer.valueOf(255), columns.get(1).getCharacter_maximum_length());
+    }
+
+    private static Connection describeFailingMetadataConnection() {
+        DatabaseMetaData meta = proxy(DatabaseMetaData.class, (method, args) -> {
+            if ("getColumns".equals(method.getName())) {
+                return rows(
+                    row(
+                        "COLUMN_NAME", "id",
+                        "TYPE_NAME", "bigint",
+                        "NULLABLE", DatabaseMetaData.columnNoNulls,
+                        "COLUMN_DEF", null,
+                        "REMARKS", "identifier",
+                        "COLUMN_SIZE", 19,
+                        "DECIMAL_DIGITS", 0
+                    ),
+                    row(
+                        "COLUMN_NAME", "name",
+                        "TYPE_NAME", "string",
+                        "NULLABLE", DatabaseMetaData.columnNullable,
+                        "COLUMN_DEF", null,
+                        "REMARKS", null,
+                        "COLUMN_SIZE", 255,
+                        "DECIMAL_DIGITS", 0
+                    )
+                );
+            }
+            return defaultValue(method.getReturnType());
+        });
+        return proxy(Connection.class, (method, args) -> {
+            String name = method.getName();
+            if ("createStatement".equals(name)) {
+                return describeFailingStatement();
+            }
+            if ("getMetaData".equals(name)) {
+                return meta;
+            }
+            if ("isClosed".equals(name)) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static Statement describeFailingStatement() {
+        return proxy(Statement.class, (method, args) -> {
+            String name = method.getName();
+            if ("execute".equals(name)) {
+                return false;
+            }
+            if ("executeQuery".equals(name)) {
+                throw new SQLException("Could not create ResultSet: Required field 'type' is unset! Struct:TPrimitiveTypeEntry(type:null)");
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    @SafeVarargs
+    private static ResultSet rows(Map<String, Object>... rows) {
+        return proxy(ResultSet.class, new MethodHandler() {
+            private int index = -1;
+
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("next".equals(name)) {
+                    index += 1;
+                    return index < rows.length;
+                }
+                if ("close".equals(name)) {
+                    return null;
+                }
+                Object value = rows[index].get(args[0]);
+                if ("getString".equals(name)) {
+                    return value == null ? null : String.valueOf(value);
+                }
+                if ("getObject".equals(name)) {
+                    return value;
+                }
+                if ("getInt".equals(name)) {
+                    return value instanceof Number ? ((Number) value).intValue() : 0;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Map<String, Object> row(Object... values) {
+        Map<String, Object> row = new LinkedHashMap<>();
+        for (int i = 0; i < values.length; i += 2) {
+            row.put(String.valueOf(values[i]), values[i + 1]);
+        }
+        return row;
+    }
+
+    private static <T> T proxy(Class<T> type, MethodHandler handler) {
+        InvocationHandler invocationHandler = (proxy, method, args) -> handler.handle(method, args);
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Byte.TYPE.equals(type)) {
+            return (byte) 0;
+        }
+        if (Short.TYPE.equals(type)) {
+            return (short) 0;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        if (Long.TYPE.equals(type)) {
+            return 0L;
+        }
+        if (Float.TYPE.equals(type)) {
+            return 0f;
+        }
+        if (Double.TYPE.equals(type)) {
+            return 0.0d;
+        }
+        if (Character.TYPE.equals(type)) {
+            return '\0';
+        }
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args) throws Throwable;
+    }
+}
diff --git a/agents/drivers/hive/src/test/java/com/dbx/agent/hive/HiveAgentTest.java b/agents/drivers/hive/src/test/java/com/dbx/agent/hive/HiveAgentTest.java
new file mode 100644
index 0000000..f3496cd
--- /dev/null
+++ b/agents/drivers/hive/src/test/java/com/dbx/agent/hive/HiveAgentTest.java
@@ -0,0 +1,42 @@
+package com.dbx.agent.hive;
+
+import com.dbx.agent.ConnectParams;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class HiveAgentTest {
+    @Test
+    void hiveJdbcStandaloneRuntimeClassesAreAvailable() throws ClassNotFoundException {
+        Class.forName("org.apache.hive.jdbc.HiveDriver");
+        Class.forName("org.apache.hive.org.apache.thrift.protocol.TProtocol");
+    }
+
+    @Test
+    void buildUrlAppendsKerberosUrlParams() {
+        ConnectParams params = new ConnectParams();
+        params.setHost("hive.example.com");
+        params.setPort(10000);
+        params.setDatabase("default");
+        params.setUrl_params(";principal=hive/hive.example.com@EXAMPLE.COM;auth=kerberos");
+
+        assertEquals(
+            "jdbc:hive2://hive.example.com:10000/default;principal=hive/hive.example.com@EXAMPLE.COM;auth=kerberos",
+            HiveAgent.buildUrl(params)
+        );
+    }
+
+    @Test
+    void buildUrlUsesCustomJdbcUrlAsIs() {
+        ConnectParams params = new ConnectParams();
+        params.setConnection_string(
+            "jdbc:hive2://zk1.example.com,zk2.example.com/default;serviceDiscoveryMode=zooKeeper;zooKeeperNamespace=hiveserver2;principal=hive/_HOST@EXAMPLE.COM"
+        );
+        params.setUrl_params("principal=hive/ignored@EXAMPLE.COM");
+
+        assertEquals(
+            "jdbc:hive2://zk1.example.com,zk2.example.com/default;serviceDiscoveryMode=zooKeeper;zooKeeperNamespace=hiveserver2;principal=hive/_HOST@EXAMPLE.COM",
+            HiveAgent.buildUrl(params)
+        );
+    }
+}
diff --git a/agents/drivers/informix/build.gradle b/agents/drivers/informix/build.gradle
new file mode 100644
index 0000000..1b38423
--- /dev/null
+++ b/agents/drivers/informix/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.ibm.informix:jdbc:4.50.10'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'IBM Informix', 'Main-Class': 'com.dbx.agent.informix.InformixAgent')
+    }
+}
diff --git a/agents/drivers/informix/src/main/java/com/dbx/agent/informix/InformixAgent.java b/agents/drivers/informix/src/main/java/com/dbx/agent/informix/InformixAgent.java
new file mode 100644
index 0000000..e8a5f5c
--- /dev/null
+++ b/agents/drivers/informix/src/main/java/com/dbx/agent/informix/InformixAgent.java
@@ -0,0 +1,556 @@
+package com.dbx.agent.informix;
+
+import com.dbx.agent.BaseDatabaseAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcExecutor;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.MetadataSqlSupport;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+public final class InformixAgent extends BaseDatabaseAgent {
+    private Connection connection;
+
+    @Override
+    public Connection getConnection() {
+        return connection;
+    }
+
+    public static String buildJdbcUrl(ConnectParams params) {
+        String rawUrlParams = params.getUrl_params();
+        String extraParams = rawUrlParams == null ? "" : trimEnd(trimStart(rawUrlParams.trim(), ':', ';'), ';');
+        String rawDatabase = params.getDatabase();
+        String database = rawDatabase == null || rawDatabase.trim().isEmpty()
+            ? "sysmaster" : rawDatabase.trim();
+
+        // Determine INFORMIXSERVER: from dedicated field, url_params, or default
+        String informixServer = params.getInformix_server();
+        informixServer = informixServer == null ? "" : informixServer.trim();
+        if (informixServer.isEmpty()) {
+            informixServer = containsIgnoreCase(extraParams, "INFORMIXSERVER=") ? "" : defaultInformixServer(params.getHost());
+        }
+        String serverParam = informixServer.isEmpty() ? "" : "INFORMIXSERVER=" + informixServer;
+
+        // Add CLIENT_LOCALE and DB_LOCALE defaults if not already specified
+        if (!containsIgnoreCase(extraParams, "CLIENT_LOCALE=")) {
+            String localeParam = "CLIENT_LOCALE=en_US.utf8";
+            extraParams = extraParams.isEmpty() ? localeParam : extraParams + ";" + localeParam;
+        }
+        if (!containsIgnoreCase(extraParams, "DB_LOCALE=")) {
+            String localeParam = "DB_LOCALE=en_US.utf8";
+            extraParams = extraParams.isEmpty() ? localeParam : extraParams + ";" + localeParam;
+        }
+
+        List<String> jdbcParams = new ArrayList<>();
+        if (!serverParam.isEmpty()) {
+            jdbcParams.add(serverParam);
+        }
+        if (!extraParams.isEmpty()) {
+            jdbcParams.add(extraParams);
+        }
+        return "jdbc:informix-sqli://" + params.getHost() + ":" + params.getPort() + "/" + database + ":"
+            + String.join(";", jdbcParams);
+    }
+
+    private static String defaultInformixServer(String host) {
+        return isIpAddress(host) ? "informix" : host;
+    }
+
+    private static boolean isIpAddress(String host) {
+        return host.matches("\\d{1,3}(\\.\\d{1,3}){3}") || host.contains(":");
+    }
+
+    /**
+     * Map Informix coltype integer codes to type names.
+     * See Informix documentation for coltype values.
+     */
+    public static String mapColType(int coltype) {
+        int baseType = coltype % 256;
+        return switch (baseType) {
+            case 0 -> "CHAR";
+            case 1 -> "SMALLINT";
+            case 2 -> "INTEGER";
+            case 3 -> "FLOAT";
+            case 4 -> "SMALLFLOAT";
+            case 5 -> "DECIMAL";
+            case 6 -> "SERIAL";
+            case 7 -> "DATE";
+            case 8 -> "MONEY";
+            case 9 -> "NULL";
+            case 10 -> "DATETIME";
+            case 11 -> "BYTE";
+            case 12 -> "TEXT";
+            case 13 -> "VARCHAR";
+            case 14 -> "INTERVAL";
+            case 15 -> "NCHAR";
+            case 16 -> "NVARCHAR";
+            case 17 -> "INT8";
+            case 18 -> "SERIAL8";
+            case 19 -> "SET";
+            case 20 -> "MULTISET";
+            case 21 -> "LIST";
+            case 22 -> "ROW";
+            case 23 -> "COLLECTION";
+            case 40 -> "LVARCHAR";
+            case 41 -> "BOOLEAN";
+            case 43, 52 -> "BIGINT";
+            case 44, 53 -> "BIGSERIAL";
+            default -> "UNKNOWN(" + baseType + ")";
+        };
+    }
+
+    public static Set<Integer> primaryKeyColumnNumbers(List<Integer> parts) {
+        Set<Integer> result = new HashSet<>();
+        for (Integer part : parts) {
+            if (part == null) {
+                continue;
+            }
+            int value = Math.abs(part);
+            if (value > 0) {
+                result.add(value);
+            }
+        }
+        return result;
+    }
+
+    public static String databaseCatalogSql() {
+        return "SELECT name FROM sysmaster:sysdatabases ORDER BY name";
+    }
+
+    @Override
+    public void connect(ConnectParams params) {
+        String url = buildJdbcUrl(params);
+        uncheckedVoid(() -> {
+            Class.forName("com.informix.jdbc.IfxDriver");
+            try {
+                connection = DriverManager.getConnection(url, params.getUsername(), params.getPassword());
+            } catch (SQLException e) {
+                throw new SQLException(
+                    "Informix connection failed.\nURL: " + url.replaceAll("//[^@]+@", "//***@") + "\nError: " + e.getMessage(),
+                    e.getSQLState(), e.getErrorCode()
+                );
+            }
+        });
+    }
+
+    @Override
+    public boolean testConnection(ConnectParams params) {
+        String url = buildJdbcUrl(params);
+        return unchecked(() -> {
+            Class.forName("com.informix.jdbc.IfxDriver");
+            try (Connection conn = DriverManager.getConnection(url, params.getUsername(), params.getPassword())) {
+                return conn.isValid(5);
+            }
+        });
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(databaseCatalogSql())) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString(1).trim()));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        List<String> result = new ArrayList<>();
+        for (DatabaseInfo database : listDatabases()) {
+            result.add(database.getName());
+        }
+        return result;
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            String sql = """
+                SELECT tabname,
+                    CASE tabtype WHEN 'T' THEN 'TABLE' WHEN 'V' THEN 'VIEW' ELSE tabtype END
+                FROM systables
+                WHERE tabid >= 100
+                ORDER BY tabname
+                """;
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(sql.stripIndent().trim())) {
+                while (rs.next()) {
+                    result.add(new TableInfo(rs.getString(1).trim(), rs.getString(2).trim(), null));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listTables(schema);
+        }
+        if (!normalized.includesTableLikeTypes()) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedTables(normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterTables(listTables(schema));
+        }
+    }
+
+    private List<TableInfo> queryConstrainedTables(MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            StringBuilder sql = new StringBuilder("SELECT ");
+            MetadataSqlSupport.appendLiteralSkipFirst(sql, constraints);
+            sql.append("tabname, CASE tabtype WHEN 'T' THEN 'TABLE' WHEN 'V' THEN 'VIEW' ELSE tabtype END ")
+                .append("FROM systables WHERE tabid >= 100");
+            appendInformixTableTypePredicate(sql, constraints);
+            MetadataSqlSupport.appendNameFilter(sql, args, "tabname", constraints);
+            sql.append(" ORDER BY tabname");
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(rs.getString(1).trim(), rs.getString(2).trim(), null));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterTables(result);
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            for (TableInfo table : listTables(schema)) {
+                result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+            }
+
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(
+                     "SELECT procname FROM sysprocedures WHERE owner != 'informix' AND isproc = 'f' ORDER BY procname"
+                 )) {
+                while (rs.next()) {
+                    result.add(new ObjectInfo(rs.getString(1).trim(), "FUNCTION", schema, null));
+                }
+            }
+
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(
+                     "SELECT procname FROM sysprocedures WHERE owner != 'informix' AND isproc = 't' ORDER BY procname"
+                 )) {
+                while (rs.next()) {
+                    result.add(new ObjectInfo(rs.getString(1).trim(), "PROCEDURE", schema, null));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listObjects(schema);
+        }
+        if (!includesSupportedObjects(normalized)) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedObjects(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterObjects(listObjects(schema));
+        }
+    }
+
+    private List<ObjectInfo> queryConstrainedObjects(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            List<String> branches = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            if (constraints.includesTableLikeTypes()) {
+                StringBuilder tableSql = new StringBuilder("SELECT tabname AS object_name, CASE tabtype WHEN 'T' THEN 'TABLE' WHEN 'V' THEN 'VIEW' ELSE tabtype END AS object_type, 0 AS object_order FROM systables WHERE tabid >= 100");
+                appendInformixTableTypePredicate(tableSql, constraints);
+                MetadataSqlSupport.appendNameFilter(tableSql, args, "tabname", constraints);
+                branches.add(tableSql.toString());
+            }
+            if (constraints.objectTypeAllowed("FUNCTION")) {
+                StringBuilder functionSql = new StringBuilder("SELECT procname AS object_name, 'FUNCTION' AS object_type, 1 AS object_order FROM sysprocedures WHERE owner != 'informix' AND isproc = 'f'");
+                MetadataSqlSupport.appendNameFilter(functionSql, args, "procname", constraints);
+                branches.add(functionSql.toString());
+            }
+            if (constraints.objectTypeAllowed("PROCEDURE")) {
+                StringBuilder procedureSql = new StringBuilder("SELECT procname AS object_name, 'PROCEDURE' AS object_type, 2 AS object_order FROM sysprocedures WHERE owner != 'informix' AND isproc = 't'");
+                MetadataSqlSupport.appendNameFilter(procedureSql, args, "procname", constraints);
+                branches.add(procedureSql.toString());
+            }
+            if (branches.isEmpty()) {
+                return List.of();
+            }
+            StringBuilder sql = new StringBuilder("SELECT ");
+            MetadataSqlSupport.appendLiteralSkipFirst(sql, constraints);
+            sql.append("object_name, object_type FROM (")
+                .append(String.join(" UNION ALL ", branches))
+                .append(") metadata_objects ORDER BY object_order, object_name");
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1).trim(), rs.getString(2).trim(), schema, null));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterObjects(result);
+        });
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        return unchecked(() -> {
+            String sql = """
+                SELECT b.data FROM sysprocbody b
+                JOIN sysprocedures p ON b.procid = p.procid
+                WHERE p.procname = ? AND b.datakey = 'T'
+                ORDER BY b.seqno
+                """;
+            StringBuilder sb = new StringBuilder();
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql.stripIndent().trim())) {
+                stmt.setString(1, name);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String value = rs.getString(1);
+                        sb.append(value == null ? "" : value);
+                    }
+                }
+            }
+            return new ObjectSource(name, objectType, schema, sb.toString());
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            Connection conn = requireConnected();
+            Set<Integer> primaryKeyColumns = getPrimaryKeyColumnNumbers(conn, table);
+            List<ColumnInfo> result = new ArrayList<>();
+            String sql = """
+                SELECT c.colname, c.coltype, c.colno
+                FROM syscolumns c
+                WHERE c.tabid = (SELECT tabid FROM systables WHERE tabname = ?)
+                ORDER BY c.colno
+                """;
+            try (java.sql.PreparedStatement stmt = conn.prepareStatement(sql.stripIndent().trim())) {
+                stmt.setString(1, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String colname = rs.getString(1).trim();
+                        int coltype = rs.getInt(2);
+                        result.add(new ColumnInfo(
+                            colname,
+                            mapColType(coltype),
+                            (coltype & 256) == 0,
+                            null,
+                            primaryKeyColumns.contains(rs.getInt(3)),
+                            null,
+                            null,
+                            null,
+                            null,
+                            null
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    private Set<Integer> getPrimaryKeyColumnNumbers(Connection conn, String table) throws SQLException {
+        String sql = """
+            SELECT i.part1, i.part2, i.part3, i.part4, i.part5, i.part6, i.part7, i.part8,
+                   i.part9, i.part10, i.part11, i.part12, i.part13, i.part14, i.part15, i.part16
+            FROM sysconstraints c
+            JOIN sysindexes i ON i.idxname = c.idxname AND i.tabid = c.tabid
+            JOIN systables t ON t.tabid = c.tabid
+            WHERE t.tabname = ? AND c.constrtype = 'P'
+            """;
+
+        try (java.sql.PreparedStatement stmt = conn.prepareStatement(sql.stripIndent().trim())) {
+            stmt.setString(1, table);
+            try (ResultSet rs = stmt.executeQuery()) {
+                if (!rs.next()) {
+                    return Collections.emptySet();
+                }
+                List<Integer> parts = new ArrayList<>();
+                for (int index = 1; index <= 16; index++) {
+                    int value = rs.getInt(index);
+                    parts.add(rs.wasNull() ? null : value);
+                }
+                return primaryKeyColumnNumbers(parts);
+            }
+        }
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return unchecked(() -> {
+            List<TriggerInfo> result = new ArrayList<>();
+            String sql = """
+                SELECT t.trigname, t.event, 'TRIGGER'
+                FROM systriggers t
+                JOIN systables s ON t.tabid = s.tabid
+                WHERE s.tabname = ?
+                """;
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql.stripIndent().trim())) {
+                stmt.setString(1, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TriggerInfo(rs.getString(1).trim(), rs.getString(2).trim(), rs.getString(3).trim()));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        String normalizedSql = switch (trimEnd(sql.trim(), ';').toUpperCase(Locale.ROOT)) {
+            case "BEGIN WORK" -> "BEGIN";
+            case "COMMIT WORK" -> "COMMIT";
+            case "ROLLBACK WORK" -> "ROLLBACK";
+            default -> sql;
+        };
+        return JdbcExecutor.INSTANCE.execute(
+            requireConnected(),
+            normalizedSql,
+            schema,
+            this::setSchemaSQL,
+            options.getMaxRows(),
+            options.getFetchSize(),
+            options.getTimeoutSecs(),
+            this::stringResultValue
+        );
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "";
+    }
+
+    @Override
+    public void disconnect() {
+        uncheckedVoid(() -> {
+            if (connection != null) {
+                connection.close();
+            }
+            connection = null;
+        });
+    }
+
+    private Object stringResultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value = rs.getObject(index);
+            return rs.wasNull() ? null : value == null ? null : value.toString();
+        });
+    }
+
+    private static boolean isUnconstrained(MetadataListConstraints constraints) {
+        return !constraints.hasFilter() && !constraints.hasLimit() && !constraints.hasOffset() && !constraints.hasObjectTypes();
+    }
+
+    private static boolean includesSupportedObjects(MetadataListConstraints constraints) {
+        return constraints.includesTableLikeTypes()
+            || constraints.objectTypeAllowed("PROCEDURE")
+            || constraints.objectTypeAllowed("FUNCTION");
+    }
+
+    private static void appendInformixTableTypePredicate(StringBuilder sql, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> types = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            types.add("'T'");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            types.add("'V'");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND tabtype IN (").append(String.join(", ", types)).append(")");
+    }
+
+    private static String trimStart(String value, char... chars) {
+        int index = 0;
+        while (index < value.length() && contains(chars, value.charAt(index))) {
+            index++;
+        }
+        return value.substring(index);
+    }
+
+    private static String trimEnd(String value, char... chars) {
+        int end = value.length();
+        while (end > 0 && contains(chars, value.charAt(end - 1))) {
+            end--;
+        }
+        return value.substring(0, end);
+    }
+
+    private static boolean contains(char[] chars, char value) {
+        for (char candidate : chars) {
+            if (candidate == value) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean containsIgnoreCase(String value, String needle) {
+        return value.toLowerCase(Locale.ROOT).contains(needle.toLowerCase(Locale.ROOT));
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new InformixAgent()).run();
+    }
+}
diff --git a/agents/drivers/informix/src/test/java/com/dbx/agent/informix/InformixAgentExecutionTest.java b/agents/drivers/informix/src/test/java/com/dbx/agent/informix/InformixAgentExecutionTest.java
new file mode 100644
index 0000000..32364b5
--- /dev/null
+++ b/agents/drivers/informix/src/test/java/com/dbx/agent/informix/InformixAgentExecutionTest.java
@@ -0,0 +1,16 @@
+package com.dbx.agent.informix;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+
+class InformixAgentExecutionTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new InformixAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "EXECUTE PROCEDURE sample_proc()";
+    }
+}
diff --git a/agents/drivers/informix/src/test/java/com/dbx/agent/informix/InformixAgentTest.java b/agents/drivers/informix/src/test/java/com/dbx/agent/informix/InformixAgentTest.java
new file mode 100644
index 0000000..ea99fbb
--- /dev/null
+++ b/agents/drivers/informix/src/test/java/com/dbx/agent/informix/InformixAgentTest.java
@@ -0,0 +1,161 @@
+package com.dbx.agent.informix;
+
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.test.JdbcMetadataSqlFake;
+import com.dbx.agent.test.TestSupport;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class InformixAgentTest {
+    @Test
+    void buildsJdbcUrlWithExplicitInformixServerAndLocaleParameters() {
+        String url = InformixAgent.buildJdbcUrl(
+            new ConnectParams(
+                "172.26.128.159",
+                20013,
+                "testdb",
+                "",
+                "",
+                "INFORMIXSERVER=informix;CLIENT_LOCALE=en_US.utf8;DB_LOCALE=en_US.utf8",
+                "",
+                false
+            )
+        );
+
+        Assertions.assertEquals(
+            "jdbc:informix-sqli://172.26.128.159:20013/testdb:INFORMIXSERVER=informix;CLIENT_LOCALE=en_US.utf8;DB_LOCALE=en_US.utf8",
+            url
+        );
+    }
+
+    @Test
+    void fallsBackToHostAsInformixServerWhenNoExplicitServerIsConfigured() {
+        String url = InformixAgent.buildJdbcUrl(
+            new ConnectParams(
+                "informix-host",
+                9088,
+                "sysmaster",
+                "",
+                "",
+                "",
+                "",
+                false
+            )
+        );
+
+        Assertions.assertEquals(
+            "jdbc:informix-sqli://informix-host:9088/sysmaster:INFORMIXSERVER=informix-host;CLIENT_LOCALE=en_US.utf8;DB_LOCALE=en_US.utf8",
+            url
+        );
+    }
+
+    @Test
+    void fallsBackToInformixServerNameWhenHostIsAnIpAddress() {
+        String url = InformixAgent.buildJdbcUrl(
+            new ConnectParams(
+                "172.26.128.159",
+                20013,
+                "sysmaster",
+                "",
+                "",
+                "",
+                "",
+                false
+            )
+        );
+
+        Assertions.assertEquals(
+            "jdbc:informix-sqli://172.26.128.159:20013/sysmaster:INFORMIXSERVER=informix;CLIENT_LOCALE=en_US.utf8;DB_LOCALE=en_US.utf8",
+            url
+        );
+    }
+
+    @Test
+    void usesInformixServerFromDedicatedFieldWhenProvided() {
+        ConnectParams params = new ConnectParams(
+            "172.26.128.159",
+            20013,
+            "testdb",
+            "",
+            "",
+            "CLIENT_LOCALE=en_US.utf8",
+            "",
+            false
+        );
+        params.setInformix_server("ol_informix1410");
+
+        String url = InformixAgent.buildJdbcUrl(params);
+
+        Assertions.assertEquals(
+            "jdbc:informix-sqli://172.26.128.159:20013/testdb:INFORMIXSERVER=ol_informix1410;CLIENT_LOCALE=en_US.utf8;DB_LOCALE=en_US.utf8",
+            url
+        );
+    }
+
+    @Test
+    void usesSysmasterWhenDatabaseIsBlank() {
+        String url = InformixAgent.buildJdbcUrl(
+            new ConnectParams(
+                "informix-host",
+                9088,
+                "",
+                "",
+                "",
+                "INFORMIXSERVER=informix",
+                "",
+                false
+            )
+        );
+
+        Assertions.assertEquals(
+            "jdbc:informix-sqli://informix-host:9088/sysmaster:INFORMIXSERVER=informix;CLIENT_LOCALE=en_US.utf8;DB_LOCALE=en_US.utf8",
+            url
+        );
+    }
+
+    @Test
+    void extractsPrimaryKeyColumnNumbersFromInformixIndexParts() {
+        Assertions.assertEquals(
+            Set.of(1, 3, 5),
+            InformixAgent.primaryKeyColumnNumbers(Arrays.asList(1, -3, 0, 5, null))
+        );
+    }
+
+    @Test
+    void listsDatabasesFromSysmasterCatalog() {
+        Assertions.assertEquals("SELECT name FROM sysmaster:sysdatabases ORDER BY name", InformixAgent.databaseCatalogSql());
+    }
+
+    @Test
+    void constrainedTableMetadataUsesInformixSkipFirstPushdown() {
+        InformixAgent agent = new InformixAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listTables("stores", new MetadataListConstraints("ord", 25, 50, List.of("TABLE")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        Assertions.assertTrue(sql.startsWith("SELECT SKIP 50 FIRST 25 tabname"), sql);
+        Assertions.assertTrue(sql.contains("tabtype IN ('T')"), sql);
+        Assertions.assertTrue(sql.contains("UPPER(tabname) LIKE ? ESCAPE '\\\\'"), sql);
+        Assertions.assertTrue(sql.endsWith("ORDER BY tabname"), sql);
+    }
+
+    @Test
+    void constrainedObjectMetadataUsesInformixUnionPushdown() {
+        InformixAgent agent = new InformixAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listObjects("stores", new MetadataListConstraints("sync", 10, null, List.of("PROCEDURE", "FUNCTION")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        Assertions.assertTrue(sql.startsWith("SELECT FIRST 10 object_name, object_type FROM ("), sql);
+        Assertions.assertTrue(sql.contains("FROM sysprocedures"), sql);
+        Assertions.assertTrue(sql.contains("isproc = 'f'"), sql);
+        Assertions.assertTrue(sql.contains("isproc = 't'"), sql);
+        Assertions.assertTrue(sql.endsWith("ORDER BY object_order, object_name"), sql);
+    }
+}
diff --git a/agents/drivers/iotdb/build.gradle b/agents/drivers/iotdb/build.gradle
new file mode 100644
index 0000000..adaf4bf
--- /dev/null
+++ b/agents/drivers/iotdb/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation 'org.apache.iotdb:iotdb-jdbc:2.0.8'
+    implementation 'org.slf4j:slf4j-nop:2.0.16'
+}
+
+tasks.named('jar') {
+    manifest {
+        attributes('Agent-Label': 'Apache IoTDB', 'Main-Class': 'com.dbx.agent.iotdb.IoTDBAgent')
+    }
+}
diff --git a/agents/drivers/iotdb/src/main/java/com/dbx/agent/iotdb/IoTDBAgent.java b/agents/drivers/iotdb/src/main/java/com/dbx/agent/iotdb/IoTDBAgent.java
new file mode 100644
index 0000000..37bd326
--- /dev/null
+++ b/agents/drivers/iotdb/src/main/java/com/dbx/agent/iotdb/IoTDBAgent.java
@@ -0,0 +1,46 @@
+package com.dbx.agent.iotdb;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class IoTDBAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile IOTDB_PROFILE = new JdbcAgentProfile(
+        "org.apache.iotdb.jdbc.IoTDBDriver",
+        "jdbc:iotdb://{host}:{port}/",
+        6667,
+        true
+    );
+
+    public IoTDBAgent() {
+        super(IOTDB_PROFILE);
+    }
+
+    // IoTDB 的 database 是 `root.xxx` 路径前缀；JDBC metadata 会把同一路径同时投影成 catalog/schema。
+    // 这里使用 IoTDB 原生语句作为 database 列表来源，避免依赖驱动的关系型兼容层。
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (Statement stmt = requireConnection().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW DATABASES")) {
+                while (rs.next()) {
+                    String name = rs.getString(1);
+                    if (name != null && !name.trim().isEmpty()) {
+                        result.add(new DatabaseInfo(name.trim()));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new IoTDBAgent()).run();
+    }
+}
diff --git a/agents/drivers/iotdb/src/test/java/com/dbx/agent/iotdb/IoTDBAgentTest.java b/agents/drivers/iotdb/src/test/java/com/dbx/agent/iotdb/IoTDBAgentTest.java
new file mode 100644
index 0000000..acfc62f
--- /dev/null
+++ b/agents/drivers/iotdb/src/test/java/com/dbx/agent/iotdb/IoTDBAgentTest.java
@@ -0,0 +1,32 @@
+package com.dbx.agent.iotdb;
+
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class IoTDBAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new IoTDBAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "SELECT * FROM sample_table";
+    }
+
+    @Test
+    void buildsOfficialJdbcUrl() {
+        ConnectParams params = new ConnectParams();
+        params.setHost("iotdb.example.com");
+        params.setPort(6667);
+        params.setUrl_params("sql_dialect=table&useSSL=false");
+
+        Assertions.assertEquals(
+            "jdbc:iotdb://iotdb.example.com:6667/?sql_dialect=table&useSSL=false",
+            IoTDBAgent.IOTDB_PROFILE.buildUrl(params)
+        );
+    }
+}
diff --git a/agents/drivers/iris/build.gradle b/agents/drivers/iris/build.gradle
new file mode 100644
index 0000000..0bcd80d
--- /dev/null
+++ b/agents/drivers/iris/build.gradle
@@ -0,0 +1,9 @@
+dependencies {
+    implementation 'com.intersystems:intersystems-jdbc:3.10.5'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'IRIS', 'Main-Class': 'com.dbx.agent.iris.IrisAgent')
+    }
+}
diff --git a/agents/drivers/iris/src/main/java/com/dbx/agent/iris/IrisAgent.java b/agents/drivers/iris/src/main/java/com/dbx/agent/iris/IrisAgent.java
new file mode 100644
index 0000000..380ea62
--- /dev/null
+++ b/agents/drivers/iris/src/main/java/com/dbx/agent/iris/IrisAgent.java
@@ -0,0 +1,159 @@
+package com.dbx.agent.iris;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.StandardJdbcMetadata;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+public final class IrisAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile IRIS_PROFILE = new JdbcAgentProfile(
+        "com.intersystems.jdbc.IRISDriver",
+        "jdbc:IRIS://{host}:{port}/{database}",
+        1972,
+        true
+    );
+
+    public IrisAgent() {
+        super(IRIS_PROFILE);
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return dedupeCaseInsensitiveSchemas(StandardJdbcMetadata.INSTANCE.listSchemas(requireConnection(), IRIS_PROFILE));
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return irisColumns(requireConnection(), schema, table);
+    }
+
+    static List<ColumnInfo> irisColumns(Connection conn, String schema, String table) {
+        return unchecked(() -> {
+            Set<String> primaryKeys = irisPrimaryKeys(conn, schema, table);
+            List<ColumnInfo> columns = new ArrayList<>();
+            try (PreparedStatement stmt = conn.prepareStatement(columnSql(schema))) {
+                int index = 1;
+                if (!isBlank(schema)) {
+                    stmt.setString(index++, schema.trim());
+                }
+                stmt.setString(index, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String name = rs.getString("COLUMN_NAME");
+                        if (isBlank(name)) {
+                            continue;
+                        }
+                        columns.add(new ColumnInfo(
+                            name,
+                            stringOrDefault(rs, "DATA_TYPE", "Unknown"),
+                            !"NO".equalsIgnoreCase(stringOrNull(rs, "IS_NULLABLE")),
+                            stringOrNull(rs, "COLUMN_DEFAULT"),
+                            primaryKeys.contains(name.toUpperCase(Locale.ROOT)),
+                            null,
+                            null,
+                            intOrNull(rs, "NUMERIC_PRECISION"),
+                            intOrNull(rs, "NUMERIC_SCALE"),
+                            intOrNull(rs, "CHARACTER_MAXIMUM_LENGTH")
+                        ));
+                    }
+                }
+            }
+            return columns;
+        });
+    }
+
+    static List<String> dedupeCaseInsensitiveSchemas(List<String> schemas) {
+        Map<String, String> byNormalizedName = new LinkedHashMap<>();
+        for (String schema : schemas) {
+            if (schema == null || schema.trim().isEmpty()) {
+                continue;
+            }
+            String name = schema.trim();
+            byNormalizedName.putIfAbsent(name.toUpperCase(Locale.ROOT), name);
+        }
+        return new ArrayList<>(byNormalizedName.values());
+    }
+
+    private static Set<String> irisPrimaryKeys(Connection conn, String schema, String table) {
+        Set<String> keys = new LinkedHashSet<>();
+        try (PreparedStatement stmt = conn.prepareStatement(primaryKeySql(schema))) {
+            int index = 1;
+            if (!isBlank(schema)) {
+                stmt.setString(index++, schema.trim());
+            }
+            stmt.setString(index, table);
+            try (ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    String column = rs.getString("COLUMN_NAME");
+                    if (!isBlank(column)) {
+                        keys.add(column.toUpperCase(Locale.ROOT));
+                    }
+                }
+            }
+        } catch (Exception ignored) {
+            // Primary key metadata is optional for display; column listing must keep working.
+        }
+        return keys;
+    }
+
+    private static String columnSql(String schema) {
+        StringBuilder sql = new StringBuilder(
+            "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT, "
+                + "NUMERIC_PRECISION, NUMERIC_SCALE, CHARACTER_MAXIMUM_LENGTH "
+                + "FROM INFORMATION_SCHEMA.COLUMNS WHERE "
+        );
+        if (!isBlank(schema)) {
+            sql.append("UPPER(TABLE_SCHEMA) = UPPER(?) AND ");
+        }
+        sql.append("UPPER(TABLE_NAME) = UPPER(?) ORDER BY ORDINAL_POSITION");
+        return sql.toString();
+    }
+
+    private static String primaryKeySql(String schema) {
+        StringBuilder sql = new StringBuilder(
+            "SELECT k.COLUMN_NAME "
+                + "FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE k "
+                + "WHERE k.CONSTRAINT_TYPE = 'PRIMARY KEY' AND "
+        );
+        if (!isBlank(schema)) {
+            sql.append("UPPER(k.TABLE_SCHEMA) = UPPER(?) AND ");
+        }
+        sql.append("UPPER(k.TABLE_NAME) = UPPER(?) ORDER BY k.ORDINAL_POSITION");
+        return sql.toString();
+    }
+
+    private static String stringOrDefault(ResultSet rs, String column, String fallback) throws Exception {
+        String value = stringOrNull(rs, column);
+        return isBlank(value) ? fallback : value;
+    }
+
+    private static String stringOrNull(ResultSet rs, String column) throws Exception {
+        String value = rs.getString(column);
+        return rs.wasNull() ? null : value;
+    }
+
+    private static Integer intOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    private static boolean isBlank(String value) {
+        return value == null || value.trim().isEmpty();
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new IrisAgent()).run();
+    }
+}
diff --git a/agents/drivers/iris/src/test/java/com/dbx/agent/iris/IrisAgentTest.java b/agents/drivers/iris/src/test/java/com/dbx/agent/iris/IrisAgentTest.java
new file mode 100644
index 0000000..d2aa319
--- /dev/null
+++ b/agents/drivers/iris/src/test/java/com/dbx/agent/iris/IrisAgentTest.java
@@ -0,0 +1,154 @@
+package com.dbx.agent.iris;
+
+import com.dbx.agent.ColumnInfo;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class IrisAgentTest {
+    @Test
+    void skipsSchemaSwitchingBecauseIrisRejectsSetSchemaContext() {
+        IrisAgent agent = new IrisAgent();
+
+        assertEquals("", agent.setSchemaSQL("Ens"));
+    }
+
+    @Test
+    void dedupesSchemasCaseInsensitively() {
+        assertEquals(
+            Arrays.asList("APP", "SQLUSER", "z_user"),
+            IrisAgent.dedupeCaseInsensitiveSchemas(Arrays.asList("APP", "SQLUSER", "SQLUser", "app", "z_user"))
+        );
+    }
+
+    @Test
+    void ignoresBlankSchemasWhenDeduping() {
+        assertEquals(
+            Collections.singletonList("SQLUSER"),
+            IrisAgent.dedupeCaseInsensitiveSchemas(Arrays.asList("", " ", null, "SQLUSER"))
+        );
+    }
+
+    @Test
+    void readsColumnsWithNativeInformationSchemaQueries() {
+        List<String> sql = new ArrayList<>();
+        Connection conn = fakeConnection(sql);
+
+        List<ColumnInfo> columns = IrisAgent.irisColumns(conn, "SQLUser", "People");
+
+        assertEquals(2, columns.size());
+        assertEquals("ID", columns.get(0).getName());
+        assertEquals("INTEGER", columns.get(0).getData_type());
+        assertFalse(columns.get(0).getIs_nullable());
+        assertTrue(columns.get(0).getIs_primary_key());
+        assertEquals("NAME", columns.get(1).getName());
+        assertEquals(Integer.valueOf(64), columns.get(1).getCharacter_maximum_length());
+        assertFalse(sql.get(0).contains("LIMIT"));
+        assertTrue(sql.get(0).contains("INFORMATION_SCHEMA.KEY_COLUMN_USAGE"));
+        assertTrue(sql.get(1).contains("INFORMATION_SCHEMA.COLUMNS"));
+    }
+
+    private static Connection fakeConnection(List<String> sqlLog) {
+        return proxy(Connection.class, (method, args) -> {
+            if ("prepareStatement".equals(method.getName())) {
+                String sql = (String) args[0];
+                sqlLog.add(sql);
+                return fakeStatement(sql);
+            }
+            if ("getMetaData".equals(method.getName())) {
+                throw new AssertionError("IRIS columns must not use JDBC DatabaseMetaData.getColumns()");
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static PreparedStatement fakeStatement(String sql) {
+        return proxy(PreparedStatement.class, (method, args) -> {
+            if ("executeQuery".equals(method.getName())) {
+                if (sql.contains("KEY_COLUMN_USAGE")) {
+                    return fakeResultSet(List.of(Map.of("COLUMN_NAME", "ID")));
+                }
+                return fakeResultSet(List.of(
+                    Map.of(
+                        "COLUMN_NAME", "ID",
+                        "DATA_TYPE", "INTEGER",
+                        "IS_NULLABLE", "NO",
+                        "NUMERIC_PRECISION", 10
+                    ),
+                    Map.of(
+                        "COLUMN_NAME", "NAME",
+                        "DATA_TYPE", "VARCHAR",
+                        "IS_NULLABLE", "YES",
+                        "CHARACTER_MAXIMUM_LENGTH", 64
+                    )
+                ));
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSet fakeResultSet(List<Map<String, Object>> rows) {
+        final int[] index = {-1};
+        final boolean[] wasNull = {false};
+        return proxy(ResultSet.class, (method, args) -> {
+            String name = method.getName();
+            if ("next".equals(name)) {
+                index[0] += 1;
+                return index[0] < rows.size();
+            }
+            if ("getString".equals(name)) {
+                Object value = rows.get(index[0]).get((String) args[0]);
+                wasNull[0] = value == null;
+                return value == null ? null : String.valueOf(value);
+            }
+            if ("getObject".equals(name)) {
+                Object value = rows.get(index[0]).get((String) args[0]);
+                wasNull[0] = value == null;
+                return value;
+            }
+            if ("wasNull".equals(name)) {
+                return wasNull[0];
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> T proxy(Class<T> type, MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                return handler.handle(method, args == null ? new Object[0] : args);
+            }
+        };
+        return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler);
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args) throws Throwable;
+    }
+}
diff --git a/agents/drivers/kafka/build.gradle b/agents/drivers/kafka/build.gradle
new file mode 100644
index 0000000..63f5e38
--- /dev/null
+++ b/agents/drivers/kafka/build.gradle
@@ -0,0 +1,12 @@
+dependencies {
+    implementation 'com.google.code.gson:gson:2.12.1'
+    implementation 'org.apache.kafka:kafka-clients:3.9.0'
+    runtimeOnly 'org.slf4j:slf4j-simple:1.7.36'
+}
+
+tasks.named('shadowJar') {
+    mergeServiceFiles()
+    manifest {
+        attributes('Agent-Label': 'Apache Kafka', 'Main-Class': 'com.dbx.agent.kafka.KafkaAgent')
+    }
+}
diff --git a/agents/drivers/kafka/src/main/java/com/dbx/agent/kafka/KafkaAgent.java b/agents/drivers/kafka/src/main/java/com/dbx/agent/kafka/KafkaAgent.java
new file mode 100644
index 0000000..ed732e0
--- /dev/null
+++ b/agents/drivers/kafka/src/main/java/com/dbx/agent/kafka/KafkaAgent.java
@@ -0,0 +1,1262 @@
+package com.dbx.agent.kafka;
+
+import com.google.gson.*;
+import org.apache.kafka.clients.admin.*;
+import org.apache.kafka.clients.consumer.*;
+import org.apache.kafka.clients.producer.*;
+import org.apache.kafka.common.*;
+import org.apache.kafka.common.acl.*;
+import org.apache.kafka.common.config.ConfigResource;
+import org.apache.kafka.common.errors.*;
+import org.apache.kafka.common.header.internals.RecordHeader;
+import org.apache.kafka.common.resource.PatternType;
+import org.apache.kafka.common.resource.ResourcePattern;
+import org.apache.kafka.common.resource.ResourcePatternFilter;
+import org.apache.kafka.common.resource.ResourceType;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
+
+/**
+ * Kafka admin agent for DBX. Communicates with the Rust bridge via JSON-RPC
+ * over stdin/stdout. Uses kafka-clients AdminClient for admin operations and
+ * KafkaProducer for message production.
+ */
+public final class KafkaAgent {
+
+    private static final Gson GSON = new GsonBuilder().serializeNulls().create();
+    private static final int DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+    private static final int DEFAULT_SESSION_TIMEOUT_MS = 30_000;
+    private static final Set<String> KERBEROS_SYSTEM_PROPERTY_KEYS = Set.of(
+        "java.security.krb5.conf",
+        "sun.security.krb5.debug",
+        "javax.security.auth.useSubjectCredsOnly"
+    );
+    private static final Map<String, String> BASELINE_KERBEROS_SYSTEM_PROPERTIES =
+        snapshotKerberosSystemProperties();
+
+    private static final List<String> CAPABILITIES = Collections.unmodifiableList(Arrays.asList(
+        "mq_connect", "mq_test_connection", "mq_topics", "mq_consumer_groups",
+        "mq_messages", "mq_acl", "mq_config", "mq_monitoring"
+    ));
+
+    private static AdminClient adminClient;
+    private static KafkaProducer<String, byte[]> producer;
+    private static volatile boolean shutdownRequested;
+
+    private KafkaAgent() {}
+
+    // -----------------------------------------------------------------------
+    // Entry point
+    // -----------------------------------------------------------------------
+
+    public static void main(String[] args) throws Exception {
+        System.setProperty("org.slf4j.simpleLogger.logFile", "System.err");
+        System.out.println("{\"ready\":true}");
+        System.out.flush();
+
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        while (true) {
+            String line = reader.readLine();
+            if (line == null) break;
+            String response = handleRequest(line);
+            System.out.println(response);
+            System.out.flush();
+            if (shutdownRequested) {
+                System.exit(0);
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // JSON-RPC dispatch
+    // -----------------------------------------------------------------------
+
+    static String handleRequest(String line) {
+        JsonObject req = JsonParser.parseString(line).getAsJsonObject();
+        JsonElement id = req.get("id");
+        String method = req.get("method").getAsString();
+        JsonObject params = req.has("params") && req.get("params").isJsonObject()
+            ? req.getAsJsonObject("params") : new JsonObject();
+
+        JsonObject response = new JsonObject();
+        response.addProperty("jsonrpc", "2.0");
+        response.add("id", id);
+
+        try {
+            Object result = dispatch(method, params);
+            response.add("result", GSON.toJsonTree(result));
+        } catch (Exception e) {
+            JsonObject error = new JsonObject();
+            error.addProperty("code", -1);
+            error.addProperty("message", normalizeErrorMessage(e));
+            response.add("error", error);
+        }
+        return GSON.toJson(response);
+    }
+
+    private static Object dispatch(String method, JsonObject params) throws Exception {
+        return switch (method) {
+            case "handshake" -> handshakeResult();
+            case "connect" -> connect(params);
+            case "test_connection" -> testConnection(params);
+            case "disconnect" -> { closeClients(); yield Collections.singletonMap("ok", true); }
+            case "shutdown" -> { closeClients(); shutdownRequested = true; yield Collections.singletonMap("ok", true); }
+            // Topic management
+            case "mq_list_topics" -> listTopics(params);
+            case "mq_create_topic" -> createTopic(params);
+            case "mq_delete_topic" -> deleteTopic(params);
+            case "mq_update_partitions" -> updatePartitions(params);
+            case "mq_get_topic_stats" -> getTopicStats(params);
+            case "mq_get_topic_config" -> getTopicConfig(params);
+            case "mq_alter_topic_config" -> alterTopicConfig(params);
+            // Consumer groups
+            case "mq_list_consumer_groups" -> listConsumerGroups(params);
+            case "mq_describe_consumer_group" -> describeConsumerGroup(params);
+            case "mq_delete_consumer_group" -> deleteConsumerGroup(params);
+            case "mq_reset_consumer_group_offsets" -> resetConsumerGroupOffsets(params);
+            case "mq_list_producers" -> listProducers(params);
+            // Messages
+            case "mq_peek_messages" -> peekMessages(params);
+            case "mq_send_message" -> sendMessage(params);
+            // ACLs
+            case "mq_list_acls" -> listAcls(params);
+            case "mq_create_acls" -> createAcls(params);
+            case "mq_delete_acls" -> deleteAcls(params);
+            // Cluster / monitoring
+            case "mq_describe_cluster" -> describeCluster(params);
+            case "mq_get_consumer_lag" -> getConsumerLag(params);
+            default -> throw new IllegalArgumentException("Unknown method: " + method);
+        };
+    }
+
+    // -----------------------------------------------------------------------
+    // Lifecycle
+    // -----------------------------------------------------------------------
+
+    private static Object handshakeResult() {
+        return new HandshakeResult(1, 1, CAPABILITIES);
+    }
+
+    private static Object connect(JsonObject params) throws Exception {
+        JsonObject conn = connectionObject(params);
+        Map<String, String> previousKerberosSystemProperties = applyKerberosSystemProperties(conn);
+        AdminClient nextAdmin = null;
+        KafkaProducer<String, byte[]> nextProducer = null;
+        try {
+            nextAdmin = buildAdminClient(conn);
+            // Verify connectivity
+            nextAdmin.describeCluster().clusterId().get(
+                intOrDefault(conn, "request_timeout_ms", DEFAULT_REQUEST_TIMEOUT_MS), TimeUnit.MILLISECONDS);
+            nextProducer = buildProducer(conn);
+            closeClients();
+            applyKerberosSystemProperties(conn);
+            adminClient = nextAdmin;
+            producer = nextProducer;
+            return Collections.singletonMap("ok", true);
+        } catch (Exception e) {
+            if (nextAdmin != null) {
+                nextAdmin.close(Duration.ofSeconds(5));
+            }
+            if (nextProducer != null) {
+                nextProducer.close(Duration.ofSeconds(5));
+            }
+            restoreKerberosSystemProperties(previousKerberosSystemProperties);
+            throw e;
+        }
+    }
+
+    private static Object testConnection(JsonObject params) throws Exception {
+        JsonObject conn = connectionObject(params);
+        Map<String, String> previousKerberosSystemProperties = applyKerberosSystemProperties(conn);
+        AdminClient probe = null;
+        try {
+            probe = buildAdminClient(conn);
+            int timeout = intOrDefault(conn, "request_timeout_ms", DEFAULT_REQUEST_TIMEOUT_MS);
+            DescribeClusterResult cluster = probe.describeCluster();
+            String clusterId = cluster.clusterId().get(timeout, TimeUnit.MILLISECONDS);
+            Node controller = cluster.controller().get(timeout, TimeUnit.MILLISECONDS);
+            Collection<Node> brokers = cluster.nodes().get(timeout, TimeUnit.MILLISECONDS);
+
+            // Probe ACL support: try a describe operation and catch security errors.
+            boolean aclEnabled = true;
+            try {
+                probe.describeAcls(AclBindingFilter.ANY)
+                    .values().get(timeout, TimeUnit.MILLISECONDS);
+            } catch (Exception aclEx) {
+                Throwable cause = aclEx;
+                while (cause != null) {
+                    if (cause.getClass().getSimpleName().contains("SecurityDisabled")
+                        || (cause.getMessage() != null && cause.getMessage().contains("No Authorizer"))) {
+                        aclEnabled = false;
+                        break;
+                    }
+                    cause = cause.getCause();
+                }
+            }
+
+            Map<String, Object> result = new LinkedHashMap<>();
+            result.put("ok", true);
+            result.put("clusterId", clusterId);
+            result.put("controller", controller != null ? nodeToMap(controller) : null);
+            result.put("aclEnabled", aclEnabled);
+            List<Map<String, Object>> brokerList = new ArrayList<>();
+            for (Node node : brokers) {
+                brokerList.add(nodeToMap(node));
+            }
+            result.put("brokers", brokerList);
+            return result;
+        } finally {
+            if (probe != null) {
+                probe.close(Duration.ofSeconds(5));
+            }
+            restoreKerberosSystemProperties(previousKerberosSystemProperties);
+        }
+    }
+
+    private static void closeClients() {
+        if (adminClient != null) {
+            adminClient.close(Duration.ofSeconds(5));
+            adminClient = null;
+        }
+        if (producer != null) {
+            producer.close(Duration.ofSeconds(5));
+            producer = null;
+        }
+        restoreKerberosSystemProperties(BASELINE_KERBEROS_SYSTEM_PROPERTIES);
+    }
+
+    // -----------------------------------------------------------------------
+    // Client builders
+    // -----------------------------------------------------------------------
+
+    static AdminClient buildAdminClient(JsonObject conn) {
+        Properties props = new Properties();
+        props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers(conn));
+        props.put(AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG,
+            intOrDefault(conn, "request_timeout_ms", DEFAULT_REQUEST_TIMEOUT_MS));
+        props.put(AdminClientConfig.DEFAULT_API_TIMEOUT_MS_CONFIG,
+            intOrDefault(conn, "request_timeout_ms", DEFAULT_REQUEST_TIMEOUT_MS));
+        applyConnectionProperties(conn, props);
+        return AdminClient.create(props);
+    }
+
+    private static KafkaProducer<String, byte[]> buildProducer(JsonObject conn) {
+        Properties props = new Properties();
+        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers(conn));
+        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
+            "org.apache.kafka.common.serialization.StringSerializer");
+        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
+            "org.apache.kafka.common.serialization.ByteArraySerializer");
+        props.put(ProducerConfig.ACKS_CONFIG, "all");
+        applyConnectionProperties(conn, props);
+        return new KafkaProducer<>(props);
+    }
+
+    private static String bootstrapServers(JsonObject conn) {
+        String servers = stringOrEmpty(conn, "bootstrap_servers");
+        if (servers.isBlank()) {
+            servers = stringOrEmpty(conn, "bootstrapServers");
+        }
+        if (servers.isBlank()) {
+            throw new IllegalArgumentException("bootstrap_servers is required");
+        }
+        return servers;
+    }
+
+    static void applySecurityProperties(JsonObject conn, Properties props) {
+        String securityProtocol = stringOrEmpty(conn, "security_protocol");
+        if (securityProtocol.isBlank()) {
+            securityProtocol = stringOrEmpty(conn, "securityProtocol");
+        }
+        if (securityProtocol.isBlank()) {
+            securityProtocol = "PLAINTEXT";
+        }
+        props.put("security.protocol", securityProtocol);
+
+        String saslMechanism = stringOrEmpty(conn, "sasl_mechanism");
+        if (saslMechanism.isBlank()) {
+            saslMechanism = stringOrEmpty(conn, "saslMechanism");
+        }
+        if (!saslMechanism.isBlank()) {
+            props.put("sasl.mechanism", saslMechanism);
+        }
+
+        String saslUsername = stringOrEmpty(conn, "sasl_username");
+        if (saslUsername.isBlank()) saslUsername = stringOrEmpty(conn, "saslUsername");
+        String saslPassword = stringOrEmpty(conn, "sasl_password");
+        if (saslPassword.isBlank()) saslPassword = stringOrEmpty(conn, "saslPassword");
+
+        if (!saslUsername.isBlank() && !saslMechanism.isBlank()) {
+            String jaasTemplate = switch (saslMechanism.toUpperCase()) {
+                case "PLAIN" -> "org.apache.kafka.common.security.plain.PlainLoginModule required "
+                    + "username=\"%s\" password=\"%s\";";
+                case "SCRAM-SHA-256", "SCRAM-SHA-512" ->
+                    "org.apache.kafka.common.security.scram.ScramLoginModule required "
+                    + "username=\"%s\" password=\"%s\";";
+                default -> null;
+            };
+            if (jaasTemplate != null) {
+                props.put("sasl.jaas.config", String.format(jaasTemplate, jaasValue(saslUsername), jaasValue(saslPassword)));
+            }
+        }
+
+        JsonObject tls = conn.has("tls") && conn.get("tls").isJsonObject()
+            ? conn.getAsJsonObject("tls") : null;
+        boolean skipVerify = boolOrDefault(conn, "tls_skip_verify", false)
+            || boolOrDefault(conn, "tlsSkipVerify", false)
+            || (tls != null && boolOrDefault(tls, "skip_verify", false));
+        if (skipVerify) {
+            props.put("ssl.endpoint.identification.algorithm", "");
+        }
+
+        // TLS properties
+        if (tls != null) {
+            String truststorePath = stringOrEmpty(tls, "truststore_path");
+            if (!truststorePath.isBlank()) {
+                props.put("ssl.truststore.location", truststorePath);
+                String truststorePassword = stringOrEmpty(tls, "truststore_password");
+                if (!truststorePassword.isBlank()) {
+                    props.put("ssl.truststore.password", truststorePassword);
+                }
+            }
+            String keystorePath = stringOrEmpty(tls, "keystore_path");
+            if (!keystorePath.isBlank()) {
+                props.put("ssl.keystore.location", keystorePath);
+                String keystorePassword = stringOrEmpty(tls, "keystore_password");
+                if (!keystorePassword.isBlank()) {
+                    props.put("ssl.keystore.password", keystorePassword);
+                }
+            }
+        }
+    }
+
+    static void applyConnectionProperties(JsonObject conn, Properties props) {
+        applySecurityProperties(conn, props);
+        applyExtraProperties(conn, props);
+    }
+
+    static String jaasValue(String value) {
+        return value.replace("\\", "\\\\").replace("\"", "\\\"");
+    }
+
+    @SuppressWarnings("unchecked")
+    private static void applyExtraProperties(JsonObject conn, Properties props) {
+        JsonObject properties = conn.has("properties") && conn.get("properties").isJsonObject()
+            ? conn.getAsJsonObject("properties") : null;
+        if (properties != null) {
+            for (Map.Entry<String, JsonElement> entry : properties.entrySet()) {
+                if (entry.getValue().isJsonPrimitive()) {
+                    String key = entry.getKey();
+                    String value = entry.getValue().getAsString();
+                    props.put(key, value);
+                }
+            }
+        }
+    }
+
+    static Map<String, String> applyKerberosSystemProperties(JsonObject conn) {
+        Map<String, String> previous = snapshotKerberosSystemProperties();
+        JsonObject properties = connectionProperties(conn);
+        for (String key : KERBEROS_SYSTEM_PROPERTY_KEYS) {
+            String value = stringProperty(properties, key);
+            if (value == null || value.isBlank()) {
+                value = BASELINE_KERBEROS_SYSTEM_PROPERTIES.get(key);
+            }
+            setOrClearSystemProperty(key, value);
+        }
+        return previous;
+    }
+
+    static void restoreKerberosSystemProperties(Map<String, String> values) {
+        for (String key : KERBEROS_SYSTEM_PROPERTY_KEYS) {
+            setOrClearSystemProperty(key, values.get(key));
+        }
+    }
+
+    private static Map<String, String> snapshotKerberosSystemProperties() {
+        Map<String, String> values = new LinkedHashMap<>();
+        for (String key : KERBEROS_SYSTEM_PROPERTY_KEYS) {
+            values.put(key, System.getProperty(key));
+        }
+        return values;
+    }
+
+    private static JsonObject connectionProperties(JsonObject conn) {
+        return conn.has("properties") && conn.get("properties").isJsonObject()
+            ? conn.getAsJsonObject("properties") : null;
+    }
+
+    private static String stringProperty(JsonObject properties, String key) {
+        if (properties == null || !properties.has(key) || !properties.get(key).isJsonPrimitive()) {
+            return null;
+        }
+        return properties.get(key).getAsString();
+    }
+
+    private static void setOrClearSystemProperty(String key, String value) {
+        if (value == null || value.isBlank()) {
+            System.clearProperty(key);
+        } else {
+            System.setProperty(key, value);
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Topic management
+    // -----------------------------------------------------------------------
+
+    private static Object listTopics(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        Set<String> names = admin.listTopics(new ListTopicsOptions().timeoutMs(timeout))
+            .names().get(timeout, TimeUnit.MILLISECONDS);
+        if (names.isEmpty()) {
+            return Collections.singletonMap("topics", Collections.emptyList());
+        }
+
+        Map<String, TopicDescription> descriptions = admin.describeTopics(names)
+            .allTopicNames().get(timeout, TimeUnit.MILLISECONDS);
+
+        List<Map<String, Object>> topics = new ArrayList<>();
+        for (Map.Entry<String, TopicDescription> entry : descriptions.entrySet()) {
+            TopicDescription desc = entry.getValue();
+            Map<String, Object> topic = new LinkedHashMap<>();
+            topic.put("name", desc.name());
+            topic.put("partitions", desc.partitions().size());
+            topic.put("replicationFactor", desc.partitions().isEmpty() ? 0
+                : desc.partitions().get(0).replicas().size());
+            topic.put("internal", desc.isInternal());
+            topics.add(topic);
+        }
+        topics.sort(Comparator.comparing(m -> (String) m.get("name")));
+        return Collections.singletonMap("topics", topics);
+    }
+
+    private static Object createTopic(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        String name = stringOrEmpty(params, "name");
+        int partitions = intOrDefault(params, "partitions", 1);
+        short replicationFactor = (short) intOrDefault(params, "replicationFactor", 1);
+
+        NewTopic newTopic = new NewTopic(name, partitions, replicationFactor);
+
+        // Optional configs
+        JsonObject configs = params.has("configs") && params.get("configs").isJsonObject()
+            ? params.getAsJsonObject("configs") : null;
+        if (configs != null) {
+            Map<String, String> configMap = new HashMap<>();
+            for (Map.Entry<String, JsonElement> entry : configs.entrySet()) {
+                configMap.put(entry.getKey(), entry.getValue().getAsString());
+            }
+            newTopic.configs(configMap);
+        }
+
+        admin.createTopics(Collections.singletonList(newTopic))
+            .all().get(timeout, TimeUnit.MILLISECONDS);
+        return Collections.singletonMap("ok", true);
+    }
+
+    private static Object deleteTopic(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        String name = stringOrEmpty(params, "name");
+        admin.deleteTopics(Collections.singletonList(name))
+            .all().get(timeout, TimeUnit.MILLISECONDS);
+        return Collections.singletonMap("ok", true);
+    }
+
+    private static Object updatePartitions(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        String name = stringOrEmpty(params, "name");
+        int totalPartitions = intOrDefault(params, "totalPartitions", 1);
+        admin.createPartitions(Collections.singletonMap(name, NewPartitions.increaseTo(totalPartitions)))
+            .all().get(timeout, TimeUnit.MILLISECONDS);
+        return Collections.singletonMap("ok", true);
+    }
+
+    private static Object getTopicStats(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        String name = stringOrEmpty(params, "name");
+
+        TopicDescription desc = admin.describeTopics(Collections.singletonList(name))
+            .allTopicNames().get(timeout, TimeUnit.MILLISECONDS).get(name);
+
+        // Collect offsets for size estimation
+        Map<TopicPartition, ListOffsetsResult.ListOffsetsResultInfo> endOffsets = new LinkedHashMap<>();
+        Map<TopicPartition, ListOffsetsResult.ListOffsetsResultInfo> beginOffsets = new LinkedHashMap<>();
+        for (TopicPartitionInfo pi : desc.partitions()) {
+            TopicPartition tp = new TopicPartition(name, pi.partition());
+            endOffsets.put(tp, admin.listOffsets(Collections.singletonMap(tp, OffsetSpec.latest()))
+                .all().get(timeout, TimeUnit.MILLISECONDS).get(tp));
+            beginOffsets.put(tp, admin.listOffsets(Collections.singletonMap(tp, OffsetSpec.earliest()))
+                .all().get(timeout, TimeUnit.MILLISECONDS).get(tp));
+        }
+
+        long totalMessages = 0;
+        List<Map<String, Object>> partitionStats = new ArrayList<>();
+        for (TopicPartitionInfo pi : desc.partitions()) {
+            TopicPartition tp = new TopicPartition(name, pi.partition());
+            long end = endOffsets.get(tp).offset();
+            long begin = beginOffsets.get(tp).offset();
+            long count = end - begin;
+            totalMessages += count;
+
+            Map<String, Object> ps = new LinkedHashMap<>();
+            ps.put("partition", pi.partition());
+            ps.put("leader", pi.leader() != null ? pi.leader().id() : -1);
+            ps.put("replicas", pi.replicas().stream().map(Node::id).collect(Collectors.toList()));
+            ps.put("isr", pi.isr().stream().map(Node::id).collect(Collectors.toList()));
+            ps.put("beginOffset", begin);
+            ps.put("endOffset", end);
+            ps.put("messageCount", count);
+            partitionStats.add(ps);
+        }
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("name", name);
+        result.put("partitions", desc.partitions().size());
+        result.put("replicationFactor", desc.partitions().isEmpty() ? 0
+            : desc.partitions().get(0).replicas().size());
+        result.put("totalMessages", totalMessages);
+        result.put("partitionStats", partitionStats);
+        return result;
+    }
+
+    private static Object getTopicConfig(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        String name = stringOrEmpty(params, "name");
+
+        ConfigResource resource = new ConfigResource(ConfigResource.Type.TOPIC, name);
+        Config config = admin.describeConfigs(Collections.singletonList(resource))
+            .all().get(timeout, TimeUnit.MILLISECONDS).get(resource);
+
+        Map<String, Object> configs = new LinkedHashMap<>();
+        for (ConfigEntry entry : config.entries()) {
+            Map<String, Object> entryMap = new LinkedHashMap<>();
+            entryMap.put("value", entry.value());
+            entryMap.put("source", entry.source().name());
+            entryMap.put("isSensitive", entry.isSensitive());
+            entryMap.put("isReadOnly", entry.isReadOnly());
+            entryMap.put("isDefault", entry.isDefault());
+            configs.put(entry.name(), entryMap);
+        }
+        return Collections.singletonMap("configs", configs);
+    }
+
+    private static Object alterTopicConfig(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        String name = stringOrEmpty(params, "name");
+
+        JsonArray entries = params.has("configs") && params.get("configs").isJsonArray()
+            ? params.getAsJsonArray("configs") : new JsonArray();
+
+        List<AlterConfigOp> ops = new ArrayList<>();
+        for (JsonElement el : entries) {
+            JsonObject entry = el.getAsJsonObject();
+            String key = entry.get("key").getAsString();
+            String value = entry.has("value") && !entry.get("value").isJsonNull()
+                ? entry.get("value").getAsString() : null;
+            String opStr = stringOrDefault(entry, "op", "set");
+            AlterConfigOp.OpType opType = switch (opStr.toLowerCase()) {
+                case "delete" -> AlterConfigOp.OpType.DELETE;
+                case "append" -> AlterConfigOp.OpType.APPEND;
+                case "subtract" -> AlterConfigOp.OpType.SUBTRACT;
+                default -> AlterConfigOp.OpType.SET;
+            };
+            ops.add(new AlterConfigOp(new ConfigEntry(key, value), opType));
+        }
+
+        ConfigResource resource = new ConfigResource(ConfigResource.Type.TOPIC, name);
+        admin.incrementalAlterConfigs(Collections.singletonMap(resource, ops))
+            .all().get(timeout, TimeUnit.MILLISECONDS);
+        return Collections.singletonMap("ok", true);
+    }
+
+    // -----------------------------------------------------------------------
+    // Consumer groups
+    // -----------------------------------------------------------------------
+
+    private static Object listConsumerGroups(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        Collection<ConsumerGroupListing> groups = admin.listConsumerGroups(
+                new ListConsumerGroupsOptions().timeoutMs(timeout))
+            .all().get(timeout, TimeUnit.MILLISECONDS);
+
+        List<Map<String, Object>> result = new ArrayList<>();
+        for (ConsumerGroupListing group : groups) {
+            Map<String, Object> g = new LinkedHashMap<>();
+            g.put("groupId", group.groupId());
+            g.put("state", group.state().map(Enum::name).orElse("UNKNOWN"));
+            g.put("simpleGroup", group.isSimpleConsumerGroup());
+            result.add(g);
+        }
+        result.sort(Comparator.comparing(m -> (String) m.get("groupId")));
+        return Collections.singletonMap("groups", result);
+    }
+
+    private static Object describeConsumerGroup(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        String groupId = stringOrEmpty(params, "groupId");
+
+        ConsumerGroupDescription desc = admin.describeConsumerGroups(Collections.singletonList(groupId))
+            .all().get(timeout, TimeUnit.MILLISECONDS).get(groupId);
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("groupId", desc.groupId());
+        result.put("state", desc.state().name());
+        result.put("coordinator", nodeToMap(desc.coordinator()));
+        result.put("partitionAssignor", desc.partitionAssignor());
+
+        List<Map<String, Object>> members = new ArrayList<>();
+        for (MemberDescription member : desc.members()) {
+            Map<String, Object> m = new LinkedHashMap<>();
+            m.put("memberId", member.consumerId());
+            m.put("clientId", member.clientId());
+            m.put("host", member.host());
+            List<Map<String, Object>> assignments = new ArrayList<>();
+            for (TopicPartition tp : member.assignment().topicPartitions()) {
+                Map<String, Object> a = new LinkedHashMap<>();
+                a.put("topic", tp.topic());
+                a.put("partition", tp.partition());
+                assignments.add(a);
+            }
+            m.put("assignments", assignments);
+            members.add(m);
+        }
+        result.put("members", members);
+        return result;
+    }
+
+    private static Object listProducers(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        String topic = stringOrEmpty(params, "topic");
+
+        try {
+            TopicDescription desc = admin.describeTopics(Collections.singletonList(topic))
+                .allTopicNames().get(timeout, TimeUnit.MILLISECONDS).get(topic);
+            List<TopicPartition> partitions = desc.partitions().stream()
+                .map(pi -> new TopicPartition(topic, pi.partition()))
+                .collect(Collectors.toList());
+
+            DescribeProducersResult described = admin.describeProducers(
+                partitions,
+                new DescribeProducersOptions().timeoutMs(timeout));
+
+            Map<Long, Map<String, Object>> byProducer = new LinkedHashMap<>();
+            for (TopicPartition tp : partitions) {
+                DescribeProducersResult.PartitionProducerState state =
+                    described.partitionResult(tp).get(timeout, TimeUnit.MILLISECONDS);
+                for (ProducerState producerState : state.activeProducers()) {
+                    long producerId = producerState.producerId();
+                    Map<String, Object> producer = byProducer.computeIfAbsent(producerId, id -> {
+                        Map<String, Object> p = new LinkedHashMap<>();
+                        p.put("producerId", id);
+                        p.put("producerName", "producer-" + id);
+                        p.put("msgRateIn", 0.0);
+                        p.put("msgThroughputIn", 0.0);
+                        p.put("clientVersion", "Kafka producer");
+                        p.put("partitions", new ArrayList<Integer>());
+                        p.put("lastTimestamp", producerState.lastTimestamp());
+                        return p;
+                    });
+                    @SuppressWarnings("unchecked")
+                    List<Integer> producerPartitions = (List<Integer>) producer.get("partitions");
+                    producerPartitions.add(tp.partition());
+                    long currentLastTimestamp = (long) producer.get("lastTimestamp");
+                    if (producerState.lastTimestamp() > currentLastTimestamp) {
+                        producer.put("lastTimestamp", producerState.lastTimestamp());
+                    }
+                }
+            }
+
+            for (Map<String, Object> producer : byProducer.values()) {
+                @SuppressWarnings("unchecked")
+                List<Integer> producerPartitions = (List<Integer>) producer.get("partitions");
+                producerPartitions.sort(Integer::compareTo);
+                producer.put(
+                    "address",
+                    producerPartitions.size() == 1
+                        ? "partition " + producerPartitions.get(0)
+                        : "partitions " + producerPartitions.stream().map(String::valueOf).collect(Collectors.joining(", "))
+                );
+            }
+
+            return Collections.singletonMap("producers", new ArrayList<>(byProducer.values()));
+        } catch (Exception e) {
+            if (isUnsupportedVersionError(e)) {
+                return Collections.singletonMap("producers", Collections.emptyList());
+            }
+            throw e;
+        }
+    }
+
+    private static Object deleteConsumerGroup(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        String groupId = stringOrEmpty(params, "groupId");
+        admin.deleteConsumerGroups(Collections.singletonList(groupId))
+            .all().get(timeout, TimeUnit.MILLISECONDS);
+        return Collections.singletonMap("ok", true);
+    }
+
+    private static Object resetConsumerGroupOffsets(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        String groupId = stringOrEmpty(params, "groupId");
+        String topic = stringOrEmpty(params, "topic");
+
+        Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
+        JsonArray offsetArray = params.has("offsets") && params.get("offsets").isJsonArray()
+            ? params.getAsJsonArray("offsets") : new JsonArray();
+
+        for (JsonElement el : offsetArray) {
+            JsonObject offsetObj = el.getAsJsonObject();
+            int partition = offsetObj.get("partition").getAsInt();
+            long offset = offsetObj.get("offset").getAsLong();
+            offsets.put(new TopicPartition(topic, partition), new OffsetAndMetadata(offset));
+        }
+
+        // If no explicit offsets, check for a "position" parameter.
+        if (offsets.isEmpty()) {
+            String position = stringOrDefault(params, "position", "latest");
+            Long timestampMs = params.has("timestampMs") && !params.get("timestampMs").isJsonNull()
+                ? params.get("timestampMs").getAsLong() : null;
+            TopicDescription desc = admin.describeTopics(Collections.singletonList(topic))
+                .allTopicNames().get(timeout, TimeUnit.MILLISECONDS).get(topic);
+
+            Map<TopicPartition, OffsetSpec> specMap = new HashMap<>();
+            for (TopicPartitionInfo pi : desc.partitions()) {
+                TopicPartition tp = new TopicPartition(topic, pi.partition());
+                specMap.put(tp, offsetSpecForPosition(position, timestampMs));
+            }
+            Map<TopicPartition, ListOffsetsResult.ListOffsetsResultInfo> resolved =
+                admin.listOffsets(specMap).all().get(timeout, TimeUnit.MILLISECONDS);
+            List<TopicPartition> unresolvedTimestampPartitions = new ArrayList<>();
+            for (Map.Entry<TopicPartition, ListOffsetsResult.ListOffsetsResultInfo> entry : resolved.entrySet()) {
+                long offset = entry.getValue().offset();
+                if (offset >= 0) {
+                    offsets.put(entry.getKey(), new OffsetAndMetadata(offset));
+                } else {
+                    unresolvedTimestampPartitions.add(entry.getKey());
+                }
+            }
+            if (!unresolvedTimestampPartitions.isEmpty()) {
+                Map<TopicPartition, OffsetSpec> latestSpecs = new HashMap<>();
+                for (TopicPartition tp : unresolvedTimestampPartitions) {
+                    latestSpecs.put(tp, OffsetSpec.latest());
+                }
+                Map<TopicPartition, ListOffsetsResult.ListOffsetsResultInfo> latest =
+                    admin.listOffsets(latestSpecs).all().get(timeout, TimeUnit.MILLISECONDS);
+                for (Map.Entry<TopicPartition, ListOffsetsResult.ListOffsetsResultInfo> entry : latest.entrySet()) {
+                    offsets.put(entry.getKey(), new OffsetAndMetadata(entry.getValue().offset()));
+                }
+            }
+        }
+
+        admin.alterConsumerGroupOffsets(groupId, offsets)
+            .all().get(timeout, TimeUnit.MILLISECONDS);
+        return Collections.singletonMap("ok", true);
+    }
+
+    static OffsetSpec offsetSpecForPosition(String position, Long timestampMs) {
+        String normalized = position == null ? "latest" : position.trim().toLowerCase(Locale.ROOT);
+        return switch (normalized) {
+            case "earliest" -> OffsetSpec.earliest();
+            case "latest", "" -> OffsetSpec.latest();
+            case "timestamp" -> {
+                if (timestampMs == null) {
+                    throw new IllegalArgumentException("timestampMs is required when position is timestamp");
+                }
+                yield OffsetSpec.forTimestamp(timestampMs);
+            }
+            default -> throw new IllegalArgumentException("Unsupported reset position: " + position);
+        };
+    }
+
+    // -----------------------------------------------------------------------
+    // Messages
+    // -----------------------------------------------------------------------
+
+    private static Object peekMessages(JsonObject params) throws Exception {
+        String topic = stringOrEmpty(params, "topic");
+        int partition = intOrDefault(params, "partition", 0);
+        long offset = longOrDefault(params, "offset", 0);
+        int count = intOrDefault(params, "count", 10);
+
+        // Build a temporary consumer for peeking (no commit)
+        Properties props = new Properties();
+        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
+            adminClient != null ? adminClient.describeCluster().clusterId()
+                .get(5, TimeUnit.SECONDS) : "localhost:9092");
+        // Reuse the admin's bootstrap servers
+        JsonObject conn = params.has("connection") && params.get("connection").isJsonObject()
+            ? params.getAsJsonObject("connection") : null;
+        if (conn != null) {
+            props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers(conn));
+            applyConnectionProperties(conn, props);
+        }
+        props.put(ConsumerConfig.GROUP_ID_CONFIG, "dbx-peek-" + UUID.randomUUID());
+        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
+            "org.apache.kafka.common.serialization.StringDeserializer");
+        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
+            "org.apache.kafka.common.serialization.ByteArrayDeserializer");
+        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
+        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "none");
+        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, count);
+
+        TopicPartition tp = new TopicPartition(topic, partition);
+        try (KafkaConsumer<String, byte[]> consumer = new KafkaConsumer<>(props)) {
+            consumer.assign(Collections.singletonList(tp));
+            Map<TopicPartition, Long> beginningOffsets =
+                consumer.beginningOffsets(Collections.singletonList(tp), Duration.ofSeconds(5));
+            Map<TopicPartition, Long> endOffsets =
+                consumer.endOffsets(Collections.singletonList(tp), Duration.ofSeconds(5));
+            long beginningOffset = beginningOffsets.getOrDefault(tp, 0L);
+            long endOffset = endOffsets.getOrDefault(tp, beginningOffset);
+            Long seekOffset = normalizePeekOffset(offset, beginningOffset, endOffset);
+            if (seekOffset == null) {
+                return Collections.singletonMap("messages", Collections.emptyList());
+            }
+            consumer.seek(tp, seekOffset);
+
+            List<Map<String, Object>> messages = new ArrayList<>();
+            ConsumerRecords<String, byte[]> records = consumer.poll(Duration.ofSeconds(5));
+            for (ConsumerRecord<String, byte[]> record : records) {
+                if (messages.size() >= count) break;
+                Map<String, Object> msg = new LinkedHashMap<>();
+                msg.put("topic", record.topic());
+                msg.put("partition", record.partition());
+                msg.put("offset", record.offset());
+                msg.put("timestamp", record.timestamp());
+                msg.put("key", record.key());
+                // Headers
+                Map<String, String> headers = new LinkedHashMap<>();
+                record.headers().forEach(h ->
+                    headers.put(h.key(), new String(h.value(), StandardCharsets.UTF_8)));
+                msg.put("headers", headers);
+                // Payload
+                if (record.value() != null) {
+                    msg.put("payloadBase64", Base64.getEncoder().encodeToString(record.value()));
+                    String text = tryDecodeUtf8(record.value());
+                    if (text != null) {
+                        msg.put("payloadText", text);
+                    }
+                } else {
+                    msg.put("payloadBase64", "");
+                }
+                messages.add(msg);
+            }
+            return Collections.singletonMap("messages", messages);
+        }
+    }
+
+    private static Object sendMessage(JsonObject params) throws Exception {
+        if (producer == null) {
+            throw new IllegalStateException("Producer is not initialized. Call connect first.");
+        }
+
+        String topic = stringOrEmpty(params, "topic");
+        String key = params.has("key") && !params.get("key").isJsonNull()
+            ? params.get("key").getAsString() : null;
+
+        // Decode payload from base64
+        String payloadBase64 = stringOrEmpty(params, "payloadBase64");
+        byte[] value = payloadBase64.isEmpty() ? new byte[0] : Base64.getDecoder().decode(payloadBase64);
+
+        // Build the record
+        Integer partition = params.has("partition") && !params.get("partition").isJsonNull()
+            ? params.get("partition").getAsInt() : null;
+
+        ProducerRecord<String, byte[]> record;
+        if (partition != null) {
+            record = new ProducerRecord<>(topic, partition, key, value);
+        } else {
+            record = new ProducerRecord<>(topic, key, value);
+        }
+
+        // Add headers
+        JsonObject headers = params.has("headers") && params.get("headers").isJsonObject()
+            ? params.getAsJsonObject("headers") : null;
+        if (headers != null) {
+            for (Map.Entry<String, JsonElement> entry : headers.entrySet()) {
+                record.headers().add(new RecordHeader(
+                    entry.getKey(),
+                    entry.getValue().getAsString().getBytes(StandardCharsets.UTF_8)));
+            }
+        }
+
+        RecordMetadata metadata = producer.send(record).get(30, TimeUnit.SECONDS);
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("ok", true);
+        result.put("topic", metadata.topic());
+        result.put("partition", metadata.partition());
+        result.put("offset", metadata.offset());
+        result.put("timestamp", metadata.timestamp());
+        return result;
+    }
+
+    // -----------------------------------------------------------------------
+    // ACLs
+    // -----------------------------------------------------------------------
+
+    private static Object listAcls(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+
+        AclBindingFilter filter = buildAclFilter(params);
+        Collection<AclBinding> bindings = admin.describeAcls(filter)
+            .values().get(timeout, TimeUnit.MILLISECONDS);
+
+        List<Map<String, Object>> acls = new ArrayList<>();
+        for (AclBinding binding : bindings) {
+            Map<String, Object> acl = new LinkedHashMap<>();
+            acl.put("resourceType", binding.pattern().resourceType().name());
+            acl.put("resourceName", binding.pattern().name());
+            acl.put("patternType", binding.pattern().patternType().name());
+            acl.put("principal", binding.entry().principal());
+            acl.put("host", binding.entry().host());
+            acl.put("operation", binding.entry().operation().name());
+            acl.put("permissionType", binding.entry().permissionType().name());
+            acls.add(acl);
+        }
+        return Collections.singletonMap("acls", acls);
+    }
+
+    private static Object createAcls(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        JsonArray aclsArray = params.has("acls") && params.get("acls").isJsonArray()
+            ? params.getAsJsonArray("acls") : new JsonArray();
+
+        List<AclBinding> bindings = new ArrayList<>();
+        for (JsonElement el : aclsArray) {
+            JsonObject acl = el.getAsJsonObject();
+            ResourceType resourceType = ResourceType.valueOf(stringOrDefault(acl, "resourceType", "TOPIC"));
+            String resourceName = stringOrEmpty(acl, "resourceName");
+            PatternType patternType = PatternType.valueOf(stringOrDefault(acl, "patternType", "LITERAL"));
+            String principal = stringOrEmpty(acl, "principal");
+            String host = stringOrDefault(acl, "host", "*");
+            AclOperation operation = AclOperation.valueOf(stringOrDefault(acl, "operation", "ALL"));
+            AclPermissionType permissionType = AclPermissionType.valueOf(
+                stringOrDefault(acl, "permissionType", "ALLOW"));
+
+            ResourcePattern pattern = new ResourcePattern(resourceType, resourceName, patternType);
+            AccessControlEntry entry = new AccessControlEntry(principal, host, operation, permissionType);
+            bindings.add(new AclBinding(pattern, entry));
+        }
+
+        admin.createAcls(bindings).all().get(timeout, TimeUnit.MILLISECONDS);
+        return Collections.singletonMap("ok", true);
+    }
+
+    private static Object deleteAcls(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        JsonArray filtersArray = params.has("filters") && params.get("filters").isJsonArray()
+            ? params.getAsJsonArray("filters") : new JsonArray();
+
+        List<AclBindingFilter> filters = new ArrayList<>();
+        for (JsonElement el : filtersArray) {
+            filters.add(buildAclFilter(el.getAsJsonObject()));
+        }
+        if (filters.isEmpty()) {
+            filters.add(AclBindingFilter.ANY);
+        }
+
+        Collection<AclBinding> deletedBindings = admin.deleteAcls(filters).all().get(timeout, TimeUnit.MILLISECONDS);
+        int deleted = deletedAclCount(deletedBindings);
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("ok", true);
+        result.put("deleted", deleted);
+        return result;
+    }
+
+    static int deletedAclCount(Collection<AclBinding> deletedBindings) {
+        return deletedBindings == null ? 0 : deletedBindings.size();
+    }
+
+    private static AclBindingFilter buildAclFilter(JsonObject params) {
+        ResourceType resourceType = params.has("resourceType")
+            ? ResourceType.valueOf(params.get("resourceType").getAsString()) : ResourceType.ANY;
+        String resourceName = params.has("resourceName") && !params.get("resourceName").isJsonNull()
+            ? params.get("resourceName").getAsString() : null;
+        PatternType patternType = params.has("patternType")
+            ? PatternType.valueOf(params.get("patternType").getAsString()) : PatternType.ANY;
+
+        ResourcePatternFilter patternFilter = new ResourcePatternFilter(
+            resourceType, resourceName, patternType);
+
+        String principal = params.has("principal") && !params.get("principal").isJsonNull()
+            ? params.get("principal").getAsString() : null;
+        String host = params.has("host") && !params.get("host").isJsonNull()
+            ? params.get("host").getAsString() : null;
+        AclOperation operation = params.has("operation")
+            ? AclOperation.valueOf(params.get("operation").getAsString()) : AclOperation.ANY;
+        AclPermissionType permissionType = params.has("permissionType")
+            ? AclPermissionType.valueOf(params.get("permissionType").getAsString()) : AclPermissionType.ANY;
+
+        AccessControlEntryFilter entryFilter = new AccessControlEntryFilter(
+            principal, host, operation, permissionType);
+        return new AclBindingFilter(patternFilter, entryFilter);
+    }
+
+    // -----------------------------------------------------------------------
+    // Cluster / monitoring
+    // -----------------------------------------------------------------------
+
+    private static Object describeCluster(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+
+        DescribeClusterResult cluster = admin.describeCluster();
+        String clusterId = cluster.clusterId().get(timeout, TimeUnit.MILLISECONDS);
+        Node controller = cluster.controller().get(timeout, TimeUnit.MILLISECONDS);
+        Collection<Node> nodes = cluster.nodes().get(timeout, TimeUnit.MILLISECONDS);
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("clusterId", clusterId);
+        result.put("controller", controller != null ? nodeToMap(controller) : null);
+        List<Map<String, Object>> brokerList = new ArrayList<>();
+        for (Node node : nodes) {
+            brokerList.add(nodeToMap(node));
+        }
+        result.put("brokers", brokerList);
+        result.put("nodeCount", nodes.size());
+        return result;
+    }
+
+    private static Object getConsumerLag(JsonObject params) throws Exception {
+        AdminClient admin = requireAdmin();
+        int timeout = requestTimeout(params);
+        String groupId = stringOrEmpty(params, "groupId");
+        String topic = stringOrEmpty(params, "topic");
+
+        // Get committed offsets for the consumer group
+        Map<TopicPartition, OffsetAndMetadata> committed = admin.listConsumerGroupOffsets(groupId)
+            .partitionsToOffsetAndMetadata().get(timeout, TimeUnit.MILLISECONDS);
+
+        // Filter to the requested topic
+        Map<TopicPartition, OffsetAndMetadata> topicCommitted = committed.entrySet().stream()
+            .filter(e -> e.getKey().topic().equals(topic))
+            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+
+        if (topicCommitted.isEmpty()) {
+            return Collections.singletonMap("partitions", Collections.emptyList());
+        }
+
+        // Get end offsets
+        Map<TopicPartition, OffsetSpec> specMap = new HashMap<>();
+        for (TopicPartition tp : topicCommitted.keySet()) {
+            specMap.put(tp, OffsetSpec.latest());
+        }
+        Map<TopicPartition, ListOffsetsResult.ListOffsetsResultInfo> endOffsets =
+            admin.listOffsets(specMap).all().get(timeout, TimeUnit.MILLISECONDS);
+
+        List<Map<String, Object>> partitions = new ArrayList<>();
+        long totalLag = 0;
+        for (Map.Entry<TopicPartition, OffsetAndMetadata> entry : topicCommitted.entrySet()) {
+            TopicPartition tp = entry.getKey();
+            long currentOffset = entry.getValue().offset();
+            ListOffsetsResult.ListOffsetsResultInfo endInfo = endOffsets.get(tp);
+            long endOffset = endInfo != null ? endInfo.offset() : -1;
+            long lag = endOffset >= 0 ? Math.max(0, endOffset - currentOffset) : -1;
+            totalLag += Math.max(0, lag);
+
+            Map<String, Object> p = new LinkedHashMap<>();
+            p.put("partition", tp.partition());
+            p.put("currentOffset", currentOffset);
+            p.put("endOffset", endOffset);
+            p.put("lag", lag);
+            partitions.add(p);
+        }
+        partitions.sort(Comparator.comparingInt(a -> (int) a.get("partition")));
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("partitions", partitions);
+        result.put("totalLag", totalLag);
+        return result;
+    }
+
+    // -----------------------------------------------------------------------
+    // Helpers
+    // -----------------------------------------------------------------------
+
+    private static String normalizeErrorMessage(Exception e) {
+        String message = e.getMessage() == null || e.getMessage().isBlank()
+            ? e.getClass().getName()
+            : e.getMessage();
+        Throwable root = rootCause(e);
+        if (root != e && root.getMessage() != null && !root.getMessage().isBlank()
+            && !message.contains(root.getMessage())) {
+            message = message + ": " + root.getMessage();
+        }
+        if (isSslHandshakeError(e)) {
+            message = message
+                + ". Hint: SSL handshake failed. Check the Kafka security protocol. "
+                + "Use PLAINTEXT for a PLAINTEXT broker listener, SSL for SSL, "
+                + "SASL_PLAINTEXT for SASL without TLS, or SASL_SSL for SASL with TLS. "
+                + "For older Kafka/JDK TLS setups, also check truststore settings, certificates, "
+                + "hostname verification, and enabled TLS protocol versions.";
+        }
+        return message;
+    }
+
+    private static boolean isSslHandshakeError(Throwable error) {
+        for (Throwable current : causeChain(error)) {
+            String className = current.getClass().getName();
+            String message = current.getMessage() == null ? "" : current.getMessage().toLowerCase(Locale.ROOT);
+            if (className.contains("SslAuthenticationException")
+                || className.contains("SSLHandshakeException")
+                || message.contains("ssl handshake failed")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean isUnsupportedVersionError(Throwable error) {
+        for (Throwable current : causeChain(error)) {
+            String className = current.getClass().getName();
+            String message = current.getMessage() == null ? "" : current.getMessage().toLowerCase(Locale.ROOT);
+            if (className.contains("UnsupportedVersionException")
+                || message.contains("unsupported version")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static Throwable rootCause(Throwable error) {
+        Throwable current = null;
+        for (Throwable cause : causeChain(error)) {
+            current = cause;
+        }
+        return current == null ? error : current;
+    }
+
+    private static List<Throwable> causeChain(Throwable error) {
+        List<Throwable> chain = new ArrayList<>();
+        Set<Throwable> seen = Collections.newSetFromMap(new IdentityHashMap<>());
+        Throwable current = error;
+        for (int depth = 0; current != null && depth < 32 && seen.add(current); depth++) {
+            chain.add(current);
+            Throwable next = current.getCause();
+            if (next == current) {
+                break;
+            }
+            current = next;
+        }
+        return chain;
+    }
+
+    private static AdminClient requireAdmin() {
+        if (adminClient == null) {
+            throw new IllegalStateException("Not connected. Call connect first.");
+        }
+        return adminClient;
+    }
+
+    private static JsonObject connectionObject(JsonObject params) {
+        JsonElement connection = params.get("connection");
+        return connection != null && connection.isJsonObject()
+            ? connection.getAsJsonObject() : params;
+    }
+
+    private static int requestTimeout(JsonObject params) {
+        return intOrDefault(params, "timeout_ms", DEFAULT_REQUEST_TIMEOUT_MS);
+    }
+
+    private static Map<String, Object> nodeToMap(Node node) {
+        Map<String, Object> m = new LinkedHashMap<>();
+        m.put("id", node.id());
+        m.put("host", node.host());
+        m.put("port", node.port());
+        m.put("rack", node.rack());
+        return m;
+    }
+
+    private static String tryDecodeUtf8(byte[] bytes) {
+        try {
+            String text = new String(bytes, StandardCharsets.UTF_8);
+            // Verify round-trip
+            byte[] reEncoded = text.getBytes(StandardCharsets.UTF_8);
+            if (Arrays.equals(bytes, reEncoded)) {
+                return text;
+            }
+        } catch (Exception ignored) {}
+        return null;
+    }
+
+    static Long normalizePeekOffset(long requestedOffset, long beginningOffset, long endOffset) {
+        if (endOffset <= beginningOffset) {
+            return null;
+        }
+        if (requestedOffset < beginningOffset) {
+            return beginningOffset;
+        }
+        if (requestedOffset >= endOffset) {
+            return null;
+        }
+        return requestedOffset;
+    }
+
+    private static String stringOrNull(JsonObject object, String key) {
+        JsonElement element = object.get(key);
+        return element == null || element.isJsonNull() ? null : element.getAsString();
+    }
+
+    private static String stringOrEmpty(JsonObject object, String key) {
+        return stringOrDefault(object, key, "");
+    }
+
+    private static String stringOrDefault(JsonObject object, String key, String fallback) {
+        String value = stringOrNull(object, key);
+        return value == null ? fallback : value;
+    }
+
+    private static int intOrDefault(JsonObject object, String key, int fallback) {
+        JsonElement element = object.get(key);
+        return element == null || element.isJsonNull() ? fallback : element.getAsInt();
+    }
+
+    private static long longOrDefault(JsonObject object, String key, long fallback) {
+        JsonElement element = object.get(key);
+        return element == null || element.isJsonNull() ? fallback : element.getAsLong();
+    }
+
+    private static boolean boolOrDefault(JsonObject object, String key, boolean fallback) {
+        JsonElement element = object.get(key);
+        return element == null || element.isJsonNull() ? fallback : element.getAsBoolean();
+    }
+
+    // -----------------------------------------------------------------------
+    // Inner types
+    // -----------------------------------------------------------------------
+
+    private static final class HandshakeResult {
+        private final int protocolVersion;
+        private final int agentProtocolVersion;
+        private final List<String> capabilities;
+
+        private HandshakeResult(int protocolVersion, int agentProtocolVersion, List<String> capabilities) {
+            this.protocolVersion = protocolVersion;
+            this.agentProtocolVersion = agentProtocolVersion;
+            this.capabilities = capabilities;
+        }
+    }
+}
diff --git a/agents/drivers/kafka/src/test/java/com/dbx/agent/kafka/KafkaAgentTest.java b/agents/drivers/kafka/src/test/java/com/dbx/agent/kafka/KafkaAgentTest.java
new file mode 100644
index 0000000..1b4ad46
--- /dev/null
+++ b/agents/drivers/kafka/src/test/java/com/dbx/agent/kafka/KafkaAgentTest.java
@@ -0,0 +1,141 @@
+package com.dbx.agent.kafka;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+import com.google.gson.JsonParser;
+import java.util.Map;
+import java.util.Properties;
+import org.junit.jupiter.api.Test;
+
+class KafkaAgentTest {
+    @Test
+    void normalizesPeekOffsetToEarliestAvailableOffset() {
+        assertEquals(5L, KafkaAgent.normalizePeekOffset(0, 5, 10));
+    }
+
+    @Test
+    void normalizesNegativePeekOffsetToEarliestAvailableOffset() {
+        assertEquals(0L, KafkaAgent.normalizePeekOffset(-1, 0, 10));
+    }
+
+    @Test
+    void keepsPeekOffsetWhenItIsWithinAvailableRange() {
+        assertEquals(7L, KafkaAgent.normalizePeekOffset(7, 5, 10));
+    }
+
+    @Test
+    void returnsNoSeekOffsetWhenRequestedOffsetIsAtOrAfterEnd() {
+        assertNull(KafkaAgent.normalizePeekOffset(10, 5, 10));
+    }
+
+    @Test
+    void returnsNoSeekOffsetWhenTopicHasNoReadableMessages() {
+        assertNull(KafkaAgent.normalizePeekOffset(0, 5, 5));
+    }
+
+    @Test
+    void appliesKerberosKafkaProperties() {
+        Properties props = new Properties();
+        KafkaAgent.applyConnectionProperties(JsonParser.parseString("""
+            {
+              "security_protocol": "SASL_SSL",
+              "sasl_mechanism": "GSSAPI",
+              "properties": {
+                "sasl.jaas.config": "com.sun.security.auth.module.Krb5LoginModule required useKeyTab=true keyTab=\\"/tmp/user.keytab\\" principal=\\"user@EXAMPLE.COM\\";",
+                "sasl.kerberos.service.name": "kafka"
+              }
+            }
+            """).getAsJsonObject(), props);
+
+        assertEquals("SASL_SSL", props.getProperty("security.protocol"));
+        assertEquals("GSSAPI", props.getProperty("sasl.mechanism"));
+        assertEquals("kafka", props.getProperty("sasl.kerberos.service.name"));
+        assertEquals(
+            "com.sun.security.auth.module.Krb5LoginModule required useKeyTab=true keyTab=\"/tmp/user.keytab\" principal=\"user@EXAMPLE.COM\";",
+            props.getProperty("sasl.jaas.config")
+        );
+    }
+
+    @Test
+    void appliesAllowedKerberosSystemPropertiesFromConnectionProperties() {
+        Map<String, String> previous = KafkaAgent.applyKerberosSystemProperties(JsonParser.parseString("""
+            {
+              "properties": {
+                "java.security.krb5.conf": "/tmp/krb5.conf",
+                "sun.security.krb5.debug": "true",
+                "custom.system.property": "should-not-leak"
+              }
+            }
+            """).getAsJsonObject());
+        try {
+            assertEquals("/tmp/krb5.conf", System.getProperty("java.security.krb5.conf"));
+            assertEquals("true", System.getProperty("sun.security.krb5.debug"));
+            assertNull(System.getProperty("custom.system.property"));
+        } finally {
+            KafkaAgent.restoreKerberosSystemProperties(previous);
+        }
+    }
+
+    @Test
+    void clearsPreviousKerberosSystemPropertiesForNextConnection() {
+        String baseline = System.getProperty("java.security.krb5.conf");
+        Map<String, String> previous = KafkaAgent.applyKerberosSystemProperties(JsonParser.parseString("""
+            {
+              "properties": {
+                "java.security.krb5.conf": "/tmp/cluster-a.krb5.conf"
+              }
+            }
+            """).getAsJsonObject());
+        try {
+            assertEquals("/tmp/cluster-a.krb5.conf", System.getProperty("java.security.krb5.conf"));
+
+            Map<String, String> beforeSecondConnection = KafkaAgent.applyKerberosSystemProperties(JsonParser.parseString("""
+                {
+                  "properties": {
+                    "sasl.kerberos.service.name": "kafka"
+                  }
+                }
+                """).getAsJsonObject());
+            try {
+                assertEquals(baseline, System.getProperty("java.security.krb5.conf"));
+            } finally {
+                KafkaAgent.restoreKerberosSystemProperties(beforeSecondConnection);
+            }
+        } finally {
+            KafkaAgent.restoreKerberosSystemProperties(previous);
+        }
+    }
+
+    @Test
+    void restoresKerberosSystemPropertiesWhenTestConnectionClientConstructionFails() {
+        String previous = System.getProperty("java.security.krb5.conf");
+        try {
+            String response = KafkaAgent.handleRequest("""
+                {
+                  "jsonrpc": "2.0",
+                  "id": 42,
+                  "method": "test_connection",
+                  "params": {
+                    "connection": {
+                      "bootstrap_servers": "",
+                      "properties": {
+                        "java.security.krb5.conf": "/tmp/leaked-test-connection.krb5.conf"
+                      }
+                    }
+                  }
+                }
+                """);
+
+            assertEquals(-1, JsonParser.parseString(response).getAsJsonObject()
+                .getAsJsonObject("error").get("code").getAsInt());
+            assertEquals(previous, System.getProperty("java.security.krb5.conf"));
+        } finally {
+            if (previous == null) {
+                System.clearProperty("java.security.krb5.conf");
+            } else {
+                System.setProperty("java.security.krb5.conf", previous);
+            }
+        }
+    }
+}
diff --git a/agents/drivers/kingbase/build.gradle b/agents/drivers/kingbase/build.gradle
new file mode 100644
index 0000000..7c9eef1
--- /dev/null
+++ b/agents/drivers/kingbase/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'cn.com.kingbase:kingbase8:9.0.1.jre7'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': '人大金仓 KingbaseES', 'Main-Class': 'com.dbx.agent.kingbase.KingbaseAgent')
+    }
+}
diff --git a/agents/drivers/kingbase/libs/.gitkeep b/agents/drivers/kingbase/libs/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/agents/drivers/kingbase/src/main/java/com/dbx/agent/kingbase/KingbaseAgent.java b/agents/drivers/kingbase/src/main/java/com/dbx/agent/kingbase/KingbaseAgent.java
new file mode 100644
index 0000000..94b0d79
--- /dev/null
+++ b/agents/drivers/kingbase/src/main/java/com/dbx/agent/kingbase/KingbaseAgent.java
@@ -0,0 +1,839 @@
+package com.dbx.agent.kingbase;
+
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.MetadataSqlSupport;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.PostgresLikeAgent;
+import com.dbx.agent.PostgresLikeAgentProfile;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+public final class KingbaseAgent extends PostgresLikeAgent {
+    private static final int KINGBASE_VOID_TYPE_OID = 2278;
+    private static final String KINGBASE_REL_NAME = "CAST(c.relname AS varchar(256))";
+    private static final String KINGBASE_REL_OID = "CAST(c.oid AS varchar(64))";
+    private static final String KINGBASE_REL_NAMESPACE = "CAST(c.relnamespace AS varchar(64))";
+    private static final String KINGBASE_SCHEMA_NAME = "CAST(n.nspname AS varchar(256))";
+    private static final String KINGBASE_NAMESPACE_OID = "CAST(n.oid AS varchar(64))";
+    private static final String KINGBASE_DESCRIPTION = "CAST(d.description AS varchar(4000))";
+    private static final String KINGBASE_ROUTINE_NAME = "CAST(p.proname AS varchar(256))";
+    private static final String KINGBASE_ROUTINE_OID = "CAST(p.oid AS varchar(64))";
+    private static final String KINGBASE_ROUTINE_NAMESPACE = "CAST(p.pronamespace AS varchar(64))";
+    private static final String KINGBASE_VIEW_NAME = "CAST(v.viewname AS varchar(256))";
+    private static final String KINGBASE_VIEW_SCHEMA = "CAST(v.schemaname AS varchar(256))";
+    private static final String KINGBASE_MATVIEW_NAME = "CAST(mv.matviewname AS varchar(256))";
+    private static final String KINGBASE_MATVIEW_SCHEMA = "CAST(mv.schemaname AS varchar(256))";
+    private boolean postgresCatalogMode;
+
+    public static final PostgresLikeAgentProfile KINGBASE_PROFILE = new PostgresLikeAgentProfile(
+        "com.kingbase8.Driver",
+        "jdbc:kingbase8://{host}:{port}/{database}"
+    );
+
+    public KingbaseAgent() {
+        super(KINGBASE_PROFILE);
+    }
+
+    @Override
+    protected void afterConnect(ConnectParams params, Connection connection) {
+        postgresCatalogMode = false;
+        if (params.isMysql_compat_mode()) {
+            setMysqlCompatMode(true);
+            return;
+        }
+        postgresCatalogMode = !catalogExists(connection, "sys_catalog.sys_namespace")
+            && catalogExists(connection, "pg_catalog.pg_namespace");
+    }
+
+    private static boolean catalogExists(Connection connection, String catalog) {
+        try (Statement stmt = connection.createStatement();
+             ResultSet ignored = stmt.executeQuery("SELECT 1 FROM " + catalog + " WHERE 1 = 0")) {
+            return true;
+        } catch (Exception ignored) {
+            // Kingbase compatibility modes expose different catalog families.
+            return false;
+        }
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        if (postgresCatalogMode) return super.listDatabases();
+        return unchecked(() -> {
+            if (isMysqlCompatMode()) {
+                List<DatabaseInfo> result = queryDatabases("SELECT current_database() AS database_name");
+                if (!result.isEmpty()) return result;
+            }
+            for (String sql : List.of(
+                "SELECT datname AS database_name FROM sys_catalog.sys_database WHERE datistemplate = false ORDER BY datname",
+                "SELECT datname AS database_name FROM pg_database WHERE datistemplate = false ORDER BY datname"
+            )) {
+                try {
+                    List<DatabaseInfo> result = queryDatabases(sql);
+                    if (!result.isEmpty()) return result;
+                } catch (Exception ignored) {
+                    // Kingbase catalog names differ across compatibility modes and versions.
+                }
+            }
+            return Collections.singletonList(new DatabaseInfo(getConfiguredDatabase()));
+        });
+    }
+
+    private List<DatabaseInfo> queryDatabases(String sql) throws Exception {
+        try (PreparedStatement stmt = requireConnected().prepareStatement(sql);
+             ResultSet rs = stmt.executeQuery()) {
+            List<DatabaseInfo> result = new ArrayList<>();
+            while (rs.next()) {
+                result.add(new DatabaseInfo(rs.getString("database_name")));
+            }
+            return result;
+        }
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        if (postgresCatalogMode) return super.listSchemas();
+        return unchecked(() -> {
+            List<String> result = new ArrayList<>();
+            String sql = isMysqlCompatMode()
+                ? "SELECT schema_name " +
+                    "FROM information_schema.schemata " +
+                    "WHERE UPPER(schema_name) <> 'INFORMATION_SCHEMA' " +
+                    "AND UPPER(schema_name) NOT LIKE 'SYS%' " +
+                    "AND UPPER(schema_name) NOT LIKE 'XLOG%' " +
+                    "ORDER BY schema_name"
+                : "SELECT nspname AS schema_name " +
+                    "FROM sys_namespace " +
+                    "WHERE nspname NOT LIKE 'sys_temp_%' " +
+                    "AND nspname NOT LIKE 'sys_toast_temp_%' " +
+                    "ORDER BY nspname";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql);
+                 ResultSet rs = stmt.executeQuery()) {
+                while (rs.next()) {
+                    result.add(rs.getString("schema_name"));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        if (postgresCatalogMode) return super.listTables(schema);
+        if (isMysqlCompatMode()) {
+            return listTables(schema, "table_type IN ('BASE TABLE', 'VIEW')");
+        }
+        return queryRegularTables(schema, MetadataListConstraints.NONE);
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        if (postgresCatalogMode) return super.listTables(schema, constraints);
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listTables(schema);
+        }
+        if (!normalized.includesTableLikeTypes()) {
+            return List.of();
+        }
+        try {
+            return isMysqlCompatMode()
+                ? queryMysqlCompatTables(schema, normalized)
+                : queryRegularTables(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterTables(listTables(schema));
+        }
+    }
+
+    private List<TableInfo> queryRegularTables(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            List<String> branches = new ArrayList<>();
+            addRegularRelationBranches(branches, args, effectiveSchema(schema), constraints, "table_name", "table_type", "table_comment");
+            if (branches.isEmpty()) {
+                return List.of();
+            }
+            StringBuilder sql = new StringBuilder("SELECT table_name, table_type, table_comment FROM (")
+                .append(String.join(" UNION ALL ", branches))
+                .append(") metadata_tables ORDER BY table_name");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(
+                            rs.getString("table_name"),
+                            normalizeTableType(rs.getString("table_type")),
+                            rs.getString("table_comment")
+                        ));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterTables(result);
+        });
+    }
+
+    private List<TableInfo> queryMysqlCompatTables(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            StringBuilder sql = new StringBuilder("SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = ?");
+            args.add(effectiveSchema(schema));
+            appendMysqlCompatTableTypePredicate(sql, args, constraints);
+            MetadataSqlSupport.appendNameFilter(sql, args, "table_name", constraints);
+            sql.append(" ORDER BY table_name");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(rs.getString(1), normalizeTableType(rs.getString(2))));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterTables(result);
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        if (postgresCatalogMode) return super.listObjects(schema);
+        return unchecked(() -> {
+            String effectiveSchema = effectiveSchema(schema);
+            List<ObjectInfo> result = new ArrayList<>();
+            for (TableInfo table : listTables(effectiveSchema)) {
+                result.add(new ObjectInfo(table.getName(), table.getTable_type(), effectiveSchema, table.getComment()));
+            }
+            if (isMysqlCompatMode()) {
+                return result;
+            }
+
+            String sql = "SELECT " + KINGBASE_ROUTINE_NAME + " AS routine_name, " +
+                "CASE WHEN p.prorettype = " + KINGBASE_VOID_TYPE_OID + " THEN 'PROCEDURE' ELSE 'FUNCTION' END AS routine_type, " +
+                KINGBASE_DESCRIPTION + " AS routine_comment " +
+                "FROM sys_catalog.sys_proc p " +
+                "JOIN sys_catalog.sys_namespace n ON " + KINGBASE_NAMESPACE_OID + " = " + KINGBASE_ROUTINE_NAMESPACE + " " +
+                "LEFT JOIN sys_catalog.sys_description d ON CAST(d.objoid AS varchar(64)) = " + KINGBASE_ROUTINE_OID + " AND d.objsubid = 0 " +
+                "WHERE " + KINGBASE_SCHEMA_NAME + " = " + sqlString(effectiveSchema) + " " +
+                "ORDER BY " + KINGBASE_ROUTINE_NAME;
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(
+                            rs.getString("routine_name"),
+                            rs.getString("routine_type"),
+                            effectiveSchema,
+                            rs.getString("routine_comment")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        if (postgresCatalogMode) return super.listObjects(schema, constraints);
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listObjects(schema);
+        }
+        if (!includesSupportedObjects(normalized)) {
+            return List.of();
+        }
+        try {
+            return isMysqlCompatMode()
+                ? normalized.filterObjects(toObjects(queryMysqlCompatTables(schema, normalized), effectiveSchema(schema)))
+                : queryRegularObjects(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterObjects(listObjects(schema));
+        }
+    }
+
+    private List<ObjectInfo> queryRegularObjects(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            String effectiveSchema = effectiveSchema(schema);
+            List<ObjectInfo> result = new ArrayList<>();
+            List<String> branches = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            if (constraints.includesTableLikeTypes()) {
+                addRegularRelationBranches(branches, args, effectiveSchema, constraints, "object_name", "object_type", "object_comment");
+            }
+            if (constraints.objectTypeAllowed("PROCEDURE") || constraints.objectTypeAllowed("FUNCTION")) {
+                StringBuilder routineSql = new StringBuilder("SELECT ")
+                    .append(KINGBASE_ROUTINE_NAME).append(" AS object_name, ")
+                    .append("CASE WHEN p.prorettype = ").append(KINGBASE_VOID_TYPE_OID).append(" THEN 'PROCEDURE' ELSE 'FUNCTION' END AS object_type, ")
+                    .append(KINGBASE_DESCRIPTION).append(" AS object_comment ")
+                    .append("FROM sys_catalog.sys_proc p ")
+                    .append("JOIN sys_catalog.sys_namespace n ON ").append(KINGBASE_NAMESPACE_OID).append(" = ").append(KINGBASE_ROUTINE_NAMESPACE).append(' ')
+                    .append("LEFT JOIN sys_catalog.sys_description d ON CAST(d.objoid AS varchar(64)) = ").append(KINGBASE_ROUTINE_OID).append(" AND d.objsubid = 0 ")
+                    .append("WHERE ").append(KINGBASE_SCHEMA_NAME).append(" = ").append(sqlString(effectiveSchema));
+                appendRoutineKindPredicate(routineSql, args, constraints);
+                MetadataSqlSupport.appendNameFilter(routineSql, args, KINGBASE_ROUTINE_NAME, constraints);
+                branches.add(routineSql.toString());
+            }
+            if (branches.isEmpty()) {
+                return List.of();
+            }
+            StringBuilder sql = new StringBuilder("SELECT object_name, object_type, object_comment FROM (")
+                .append(String.join(" UNION ALL ", branches))
+                .append(") metadata_objects ORDER BY CASE object_type WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 WHEN 'MATERIALIZED_VIEW' THEN 2 WHEN 'FOREIGN_TABLE' THEN 3 WHEN 'PROCEDURE' THEN 4 WHEN 'FUNCTION' THEN 5 ELSE 9 END, object_name");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(
+                            rs.getString("object_name"),
+                            rs.getString("object_type"),
+                            effectiveSchema,
+                            rs.getString("object_comment")
+                        ));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterObjects(result);
+        });
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        if (postgresCatalogMode) return super.getObjectSource(schema, name, objectType);
+        if ("FUNCTION".equalsIgnoreCase(objectType) || "PROCEDURE".equalsIgnoreCase(objectType)) {
+            return routineSource(schema, name, objectType);
+        }
+        if (!"VIEW".equalsIgnoreCase(objectType) && !"MATERIALIZED_VIEW".equalsIgnoreCase(objectType)) {
+            return new ObjectSource(name, objectType, effectiveSchema(schema), "");
+        }
+        return unchecked(() -> {
+            String source = "";
+            String sql = "SELECT view_definition " +
+                "FROM information_schema.views " +
+                "WHERE table_schema = " + sqlString(effectiveSchema(schema)) +
+                " AND table_name = " + sqlString(name);
+            if (!isMysqlCompatMode()) {
+                sql = "SELECT sys_get_viewdef(c.oid) AS view_definition " +
+                    "FROM sys_catalog.sys_class c " +
+                    "JOIN sys_catalog.sys_namespace n ON " + KINGBASE_NAMESPACE_OID + " = " + KINGBASE_REL_NAMESPACE + " " +
+                    "WHERE " + KINGBASE_SCHEMA_NAME + " = " + sqlString(effectiveSchema(schema)) +
+                    " AND " + KINGBASE_REL_NAME + " = " + sqlString(name) +
+                    " LIMIT 1";
+            }
+            try (Statement stmt = requireConnected().createStatement()) {
+                try (ResultSet rs = stmt.executeQuery(sql)) {
+                    if (rs.next()) {
+                        source = coalesce(rs.getString("view_definition"));
+                    }
+                }
+            }
+            return new ObjectSource(name, objectType, effectiveSchema(schema), source);
+        });
+    }
+
+    private ObjectSource routineSource(String schema, String name, String objectType) {
+        return unchecked(() -> {
+            String source = "";
+            String sql = "SELECT sys_get_functiondef(p.oid) AS source " +
+                "FROM sys_catalog.sys_proc p " +
+                "JOIN sys_catalog.sys_namespace n ON " + KINGBASE_NAMESPACE_OID + " = " + KINGBASE_ROUTINE_NAMESPACE + " " +
+                "WHERE " + KINGBASE_SCHEMA_NAME + " = " + sqlString(effectiveSchema(schema)) +
+                " AND " + KINGBASE_ROUTINE_NAME + " = " + sqlString(name) + " " +
+                "ORDER BY CASE WHEN p.prorettype = " + KINGBASE_VOID_TYPE_OID + " THEN " +
+                ("PROCEDURE".equalsIgnoreCase(objectType) ? "0 ELSE 1" : "1 ELSE 0") +
+                " END, p.oid LIMIT 1";
+            try (PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                try (ResultSet rs = stmt.executeQuery()) {
+                    if (rs.next()) {
+                        source = coalesce(rs.getString("source"));
+                    }
+                }
+            }
+            return new ObjectSource(name, objectType, effectiveSchema(schema), source);
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        if (postgresCatalogMode) return super.getColumns(schema, table);
+        return unchecked(() -> {
+            Set<String> primaryKeys = primaryKeys(schema, table);
+            if (!isMysqlCompatMode()) {
+                return getRegularColumns(schema, table, primaryKeys);
+            }
+            return getInformationSchemaColumns(schema, table, primaryKeys);
+        });
+    }
+
+    private List<ColumnInfo> getRegularColumns(String schema, String table, Set<String> primaryKeys) {
+        return unchecked(() -> {
+            List<ColumnInfo> result = new ArrayList<>();
+            String sql = "SELECT a.attname AS column_name, " +
+                "format_type(a.atttypid, a.atttypmod) AS data_type, " +
+                "NOT a.attnotnull AS is_nullable, " +
+                "sys_get_expr(ad.adbin, ad.adrelid) AS column_default, " +
+                "d.description AS column_comment, " +
+                "CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 " +
+                "THEN ((a.atttypmod - 4) >> 16) & 65535 ELSE NULL END AS numeric_precision, " +
+                "CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 " +
+                "THEN (a.atttypmod - 4) & 65535 ELSE NULL END AS numeric_scale, " +
+                "CASE WHEN t.typname IN ('varchar', 'bpchar') AND a.atttypmod > 0 " +
+                "THEN a.atttypmod - 4 ELSE NULL END AS character_maximum_length " +
+                "FROM sys_catalog.sys_attribute a " +
+                "JOIN sys_catalog.sys_type t ON t.oid = a.atttypid " +
+                "JOIN sys_catalog.sys_class c ON c.oid = a.attrelid " +
+                "JOIN sys_catalog.sys_namespace n ON n.oid = c.relnamespace " +
+                "LEFT JOIN sys_catalog.sys_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum " +
+                "LEFT JOIN sys_catalog.sys_description d ON d.objoid = a.attrelid AND d.objsubid = a.attnum " +
+                "WHERE n.nspname = " + sqlString(effectiveSchema(schema)) +
+                " AND c.relname = " + sqlString(table) + " " +
+                "AND a.attnum > 0 AND NOT a.attisdropped " +
+                "ORDER BY a.attnum";
+            try (Statement stmt = requireConnected().createStatement()) {
+                try (ResultSet rs = stmt.executeQuery(sql)) {
+                    while (rs.next()) {
+                        String columnName = rs.getString("column_name");
+                        result.add(new ColumnInfo(
+                            columnName,
+                            rs.getString("data_type"),
+                            rs.getBoolean("is_nullable"),
+                            rs.getString("column_default"),
+                            primaryKeys.contains(columnName),
+                            null,
+                            rs.getString("column_comment"),
+                            intObject(rs, "numeric_precision"),
+                            intObject(rs, "numeric_scale"),
+                            intObject(rs, "character_maximum_length")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    private List<ColumnInfo> getInformationSchemaColumns(String schema, String table, Set<String> primaryKeys) {
+        return unchecked(() -> {
+            List<ColumnInfo> result = new ArrayList<>();
+            String sql = "SELECT column_name, data_type, is_nullable, column_default, " +
+                "numeric_precision, numeric_scale, character_maximum_length " +
+                "FROM information_schema.columns " +
+                "WHERE table_schema = " + sqlString(effectiveSchema(schema)) +
+                " AND table_name = " + sqlString(table) + " " +
+                "ORDER BY ordinal_position";
+            try (Statement stmt = requireConnected().createStatement()) {
+                try (ResultSet rs = stmt.executeQuery(sql)) {
+                    while (rs.next()) {
+                        String columnName = rs.getString("column_name");
+                        result.add(new ColumnInfo(
+                            columnName,
+                            rs.getString("data_type"),
+                            "YES".equalsIgnoreCase(coalesce(rs.getString("is_nullable"))),
+                            rs.getString("column_default"),
+                            primaryKeys.contains(columnName),
+                            null,
+                            null,
+                            intObject(rs, "numeric_precision"),
+                            intObject(rs, "numeric_scale"),
+                            intObject(rs, "character_maximum_length")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        if (postgresCatalogMode) return super.listIndexes(schema, table);
+        return unchecked(() -> {
+            Map<String, CatalogIndexBuilder> indexes = new LinkedHashMap<>();
+            String sql = "SELECT i.relname AS index_name, am.amname AS index_type, " +
+                "ix.indisunique AS is_unique, ix.indisprimary AS is_primary, " +
+                "a.attname AS column_name, pos.n AS ordinal_position " +
+                "FROM SYS_CATALOG.SYS_INDEX ix " +
+                "JOIN SYS_CATALOG.SYS_CLASS t ON t.oid = ix.indrelid " +
+                "JOIN SYS_CATALOG.SYS_CLASS i ON i.oid = ix.indexrelid " +
+                "JOIN SYS_CATALOG.SYS_NAMESPACE n ON n.oid = t.relnamespace " +
+                "JOIN SYS_CATALOG.SYS_AM am ON am.oid = i.relam " +
+                "JOIN generate_series(1, 64) AS pos(n) ON pos.n <= array_length(string_to_array(ix.indkey::text, ' '), 1) " +
+                "JOIN SYS_CATALOG.SYS_ATTRIBUTE a ON a.attrelid = t.oid AND a.attnum = (string_to_array(ix.indkey::text, ' '))[pos.n]::int2 " +
+                "WHERE n.nspname = " + sqlString(effectiveSchema(schema)) +
+                " AND t.relname = " + sqlString(table) + " " +
+                "ORDER BY i.relname, pos.n";
+            try (Statement stmt = requireConnected().createStatement()) {
+                try (ResultSet rs = stmt.executeQuery(sql)) {
+                    while (rs.next()) {
+                        String name = rs.getString("index_name");
+                        CatalogIndexBuilder builder = indexes.get(name);
+                        if (builder == null) {
+                            builder = new CatalogIndexBuilder(
+                                name,
+                                rs.getBoolean("is_unique"),
+                                rs.getBoolean("is_primary"),
+                                rs.getString("index_type")
+                            );
+                            indexes.put(name, builder);
+                        }
+                        builder.columns.add(rs.getString("column_name"));
+                    }
+                }
+            }
+            List<IndexInfo> result = new ArrayList<>();
+            for (CatalogIndexBuilder index : indexes.values()) {
+                result.add(new IndexInfo(index.name, index.columns, index.unique, index.primary, null, index.indexType, null, null));
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        if (postgresCatalogMode) return super.listForeignKeys(schema, table);
+        return unchecked(() -> {
+            List<ForeignKeyInfo> result = new ArrayList<>();
+            String sql = "SELECT fk.constraint_name, fk.column_name, pk.table_name AS ref_table, pk.column_name AS ref_column " +
+                "FROM information_schema.table_constraints tc " +
+                "JOIN information_schema.key_column_usage fk " +
+                "ON fk.constraint_schema = tc.constraint_schema " +
+                "AND fk.constraint_name = tc.constraint_name " +
+                "AND fk.table_schema = tc.table_schema " +
+                "AND fk.table_name = tc.table_name " +
+                "JOIN information_schema.referential_constraints rc " +
+                "ON rc.constraint_schema = tc.constraint_schema " +
+                "AND rc.constraint_name = tc.constraint_name " +
+                "JOIN information_schema.key_column_usage pk " +
+                "ON pk.constraint_schema = rc.unique_constraint_schema " +
+                "AND pk.constraint_name = rc.unique_constraint_name " +
+                "AND pk.ordinal_position = fk.position_in_unique_constraint " +
+                "WHERE tc.table_schema = " + sqlString(effectiveSchema(schema)) +
+                " AND tc.table_name = " + sqlString(table) + " " +
+                "AND tc.constraint_type = 'FOREIGN KEY' " +
+                "ORDER BY fk.constraint_name, fk.ordinal_position";
+            try (Statement stmt = requireConnected().createStatement()) {
+                try (ResultSet rs = stmt.executeQuery(sql)) {
+                    while (rs.next()) {
+                        result.add(new ForeignKeyInfo(
+                            rs.getString("constraint_name"),
+                            rs.getString("column_name"),
+                            rs.getString("ref_table"),
+                            rs.getString("ref_column")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        if (postgresCatalogMode) return super.listTriggers(schema, table);
+        return Collections.emptyList();
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        if (postgresCatalogMode) return super.setSchemaSQL(schema);
+        // Kingbase searches sys_catalog implicitly before user schemas unless it
+        // is listed explicitly. Put it after the selected schema so business
+        // tables named like system tables (for example sys_config) win.
+        return "SET search_path TO " + JdbcIdentifiers.INSTANCE.doubleQuote(effectiveSchema(schema)) + ", sys_catalog";
+    }
+
+    @Override
+    protected Object resultValue(ResultSet rs, int index, int sqlType, String columnTypeName) {
+        if (isTemporalType(sqlType, columnTypeName)) {
+            return unchecked(() -> {
+                Object value = rs.getTimestamp(index);
+                return rs.wasNull() ? null : value.toString();
+            });
+        }
+        return super.resultValue(rs, index, sqlType, columnTypeName);
+    }
+
+    private static boolean isTemporalType(int sqlType, String columnTypeName) {
+        switch (sqlType) {
+            case Types.DATE:
+            case Types.TIME:
+            case Types.TIME_WITH_TIMEZONE:
+            case Types.TIMESTAMP:
+            case Types.TIMESTAMP_WITH_TIMEZONE:
+                return true;
+            default:
+                break;
+        }
+        if (columnTypeName == null) {
+            return false;
+        }
+        String normalized = columnTypeName.trim().toLowerCase(Locale.ROOT);
+        return normalized.equals("date")
+            || normalized.equals("time")
+            || normalized.equals("datetime")
+            || normalized.startsWith("timestamp");
+    }
+
+    private Set<String> primaryKeys(String schema, String table) {
+        return unchecked(() -> {
+            Set<String> primaryKeys = new LinkedHashSet<>();
+            String sql = "SELECT kcu.column_name " +
+                "FROM information_schema.table_constraints tc " +
+                "JOIN information_schema.key_column_usage kcu " +
+                "ON kcu.constraint_schema = tc.constraint_schema " +
+                "AND kcu.constraint_name = tc.constraint_name " +
+                "AND kcu.table_schema = tc.table_schema " +
+                "AND kcu.table_name = tc.table_name " +
+                "WHERE tc.table_schema = " + sqlString(effectiveSchema(schema)) +
+                " AND tc.table_name = " + sqlString(table) + " " +
+                "AND tc.constraint_type = 'PRIMARY KEY' " +
+                "ORDER BY kcu.ordinal_position";
+            try (Statement stmt = requireConnected().createStatement()) {
+                try (ResultSet rs = stmt.executeQuery(sql)) {
+                    while (rs.next()) {
+                        primaryKeys.add(rs.getString("column_name"));
+                    }
+                }
+            }
+            return primaryKeys;
+        });
+    }
+
+    private List<TableInfo> listTables(String schema, String tableTypePredicate) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            String sql = "SELECT table_name, table_type " +
+                "FROM information_schema.tables " +
+                "WHERE table_schema = " + sqlString(effectiveSchema(schema)) + " AND " + tableTypePredicate + " " +
+                "ORDER BY table_name";
+            try (Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(sql)) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(rs.getString(1), normalizeTableType(rs.getString(2))));
+                    }
+            }
+            return result;
+        });
+    }
+
+    private static boolean isUnconstrained(MetadataListConstraints constraints) {
+        return !constraints.hasFilter() && !constraints.hasLimit() && !constraints.hasOffset() && !constraints.hasObjectTypes();
+    }
+
+    private static boolean includesSupportedObjects(MetadataListConstraints constraints) {
+        return constraints.includesTableLikeTypes()
+            || constraints.objectTypeAllowed("PROCEDURE")
+            || constraints.objectTypeAllowed("FUNCTION");
+    }
+
+    private static void addRegularRelationBranches(
+        List<String> branches,
+        List<Object> args,
+        String schema,
+        MetadataListConstraints constraints,
+        String nameAlias,
+        String typeAlias,
+        String commentAlias
+    ) {
+        if (constraints.tableTypeAllowed("TABLE")) {
+            branches.add(regularRelationBranch(schema, args, constraints, nameAlias, typeAlias, commentAlias, "TABLE"));
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            branches.add(regularViewBranch(schema, args, constraints, nameAlias, typeAlias, commentAlias));
+        }
+        if (constraints.tableTypeAllowed("MATERIALIZED_VIEW")) {
+            branches.add(regularMaterializedViewBranch(schema, args, constraints, nameAlias, typeAlias, commentAlias));
+        }
+    }
+
+    private static String regularRelationBranch(
+        String schema,
+        List<Object> args,
+        MetadataListConstraints constraints,
+        String nameAlias,
+        String typeAlias,
+        String commentAlias,
+        String objectType
+    ) {
+        StringBuilder sql = new StringBuilder("SELECT ")
+            .append(KINGBASE_REL_NAME).append(" AS ").append(nameAlias).append(", '")
+            .append(objectType).append("' AS ").append(typeAlias).append(", ")
+            .append(KINGBASE_DESCRIPTION).append(" AS ").append(commentAlias).append(' ')
+            .append("FROM sys_catalog.sys_class c ")
+            .append("JOIN sys_catalog.sys_namespace n ON ").append(KINGBASE_NAMESPACE_OID).append(" = ").append(KINGBASE_REL_NAMESPACE).append(' ')
+            .append("LEFT JOIN sys_catalog.sys_description d ON CAST(d.objoid AS varchar(64)) = ").append(KINGBASE_REL_OID).append(" AND d.objsubid = 0 ")
+            .append("WHERE ").append(KINGBASE_SCHEMA_NAME).append(" = ").append(sqlString(schema));
+        appendRegularTablePredicate(sql);
+        MetadataSqlSupport.appendNameFilter(sql, args, KINGBASE_REL_NAME, constraints);
+        return sql.toString();
+    }
+
+    private static String regularViewBranch(
+        String schema,
+        List<Object> args,
+        MetadataListConstraints constraints,
+        String nameAlias,
+        String typeAlias,
+        String commentAlias
+    ) {
+        // sys_views/sys_matviews avoid relkind while preserving the sidebar's
+        // separate VIEW and MATERIALIZED_VIEW groups.
+        StringBuilder sql = new StringBuilder("SELECT ")
+            .append(KINGBASE_VIEW_NAME).append(" AS ").append(nameAlias).append(", 'VIEW' AS ").append(typeAlias).append(", ")
+            .append(KINGBASE_DESCRIPTION).append(" AS ").append(commentAlias).append(' ')
+            .append("FROM sys_catalog.sys_views v ")
+            .append("JOIN sys_catalog.sys_namespace n ON ").append(KINGBASE_SCHEMA_NAME).append(" = ").append(KINGBASE_VIEW_SCHEMA).append(' ')
+            .append("JOIN sys_catalog.sys_class c ON ").append(KINGBASE_REL_NAMESPACE).append(" = ").append(KINGBASE_NAMESPACE_OID)
+            .append(" AND ").append(KINGBASE_REL_NAME).append(" = ").append(KINGBASE_VIEW_NAME).append(' ')
+            .append("LEFT JOIN sys_catalog.sys_description d ON CAST(d.objoid AS varchar(64)) = ").append(KINGBASE_REL_OID).append(" AND d.objsubid = 0 ")
+            .append("WHERE ").append(KINGBASE_VIEW_SCHEMA).append(" = ").append(sqlString(schema));
+        MetadataSqlSupport.appendNameFilter(sql, args, KINGBASE_VIEW_NAME, constraints);
+        return sql.toString();
+    }
+
+    private static String regularMaterializedViewBranch(
+        String schema,
+        List<Object> args,
+        MetadataListConstraints constraints,
+        String nameAlias,
+        String typeAlias,
+        String commentAlias
+    ) {
+        StringBuilder sql = new StringBuilder("SELECT ")
+            .append(KINGBASE_MATVIEW_NAME).append(" AS ").append(nameAlias).append(", 'MATERIALIZED_VIEW' AS ").append(typeAlias).append(", ")
+            .append(KINGBASE_DESCRIPTION).append(" AS ").append(commentAlias).append(' ')
+            .append("FROM sys_catalog.sys_matviews mv ")
+            .append("JOIN sys_catalog.sys_namespace n ON ").append(KINGBASE_SCHEMA_NAME).append(" = ").append(KINGBASE_MATVIEW_SCHEMA).append(' ')
+            .append("JOIN sys_catalog.sys_class c ON ").append(KINGBASE_REL_NAMESPACE).append(" = ").append(KINGBASE_NAMESPACE_OID)
+            .append(" AND ").append(KINGBASE_REL_NAME).append(" = ").append(KINGBASE_MATVIEW_NAME).append(' ')
+            .append("LEFT JOIN sys_catalog.sys_description d ON CAST(d.objoid AS varchar(64)) = ").append(KINGBASE_REL_OID).append(" AND d.objsubid = 0 ")
+            .append("WHERE ").append(KINGBASE_MATVIEW_SCHEMA).append(" = ").append(sqlString(schema));
+        MetadataSqlSupport.appendNameFilter(sql, args, KINGBASE_MATVIEW_NAME, constraints);
+        return sql.toString();
+    }
+
+    private static void appendRegularTablePredicate(StringBuilder sql) {
+        sql.append(" AND NOT EXISTS (SELECT 1 FROM sys_catalog.sys_rewrite r ")
+            .append("WHERE CAST(r.ev_class AS varchar(64)) = ").append(KINGBASE_REL_OID)
+            .append(" AND CAST(r.rulename AS varchar(256)) = '_RETURN')")
+            .append(" AND NOT EXISTS (SELECT 1 FROM sys_catalog.sys_index ix ")
+            .append("WHERE CAST(ix.indexrelid AS varchar(64)) = ").append(KINGBASE_REL_OID).append(')')
+            .append(" AND NOT EXISTS (SELECT 1 FROM sys_catalog.sys_attribute sa1 ")
+            .append("JOIN sys_catalog.sys_attribute sa2 ON CAST(sa2.attrelid AS varchar(64)) = CAST(sa1.attrelid AS varchar(64)) ")
+            .append("WHERE CAST(sa1.attrelid AS varchar(64)) = ").append(KINGBASE_REL_OID)
+            .append(" AND CAST(sa1.attname AS varchar(256)) = 'last_value'")
+            .append(" AND CAST(sa2.attname AS varchar(256)) = 'log_cnt')");
+    }
+
+    private static void appendMysqlCompatTableTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            sql.append(" AND table_type IN ('BASE TABLE', 'VIEW')");
+            return;
+        }
+        List<String> types = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            types.add("BASE TABLE");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            types.add("VIEW");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND table_type IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
+        args.addAll(types);
+    }
+
+    private static void appendRoutineKindPredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        boolean includeProcedures = constraints.objectTypeAllowed("PROCEDURE");
+        boolean includeFunctions = constraints.objectTypeAllowed("FUNCTION");
+        if (includeProcedures && includeFunctions) {
+            return;
+        }
+        if (!includeProcedures && !includeFunctions) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(includeProcedures
+            ? " AND p.prorettype = " + KINGBASE_VOID_TYPE_OID
+            : " AND p.prorettype <> " + KINGBASE_VOID_TYPE_OID);
+    }
+
+    private static List<ObjectInfo> toObjects(List<TableInfo> tables, String schema) {
+        List<ObjectInfo> result = new ArrayList<>();
+        for (TableInfo table : tables) {
+            result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+        }
+        return result;
+    }
+
+    private String effectiveSchema(String schema) {
+        if (schema != null && !schema.trim().isEmpty()) {
+            return schema;
+        }
+        return "PUBLIC";
+    }
+
+    private static Integer intObject(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    private static String normalizeTableType(String type) {
+        if (type == null || type.trim().isEmpty()) return "TABLE";
+        if ("BASE TABLE".equalsIgnoreCase(type)) return "TABLE";
+        return type;
+    }
+
+    private static String coalesce(String value) {
+        return value == null ? "" : value;
+    }
+
+    private static String sqlString(String value) {
+        return "'" + coalesce(value).replace("'", "''") + "'";
+    }
+
+    private static final class CatalogIndexBuilder {
+        final String name;
+        final boolean unique;
+        final boolean primary;
+        final String indexType;
+        final List<String> columns = new ArrayList<>();
+
+        CatalogIndexBuilder(String name, boolean unique, boolean primary, String indexType) {
+            this.name = name;
+            this.unique = unique;
+            this.primary = primary;
+            this.indexType = indexType;
+        }
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new KingbaseAgent()).run();
+    }
+}
diff --git a/agents/drivers/kingbase/src/test/java/com/dbx/agent/kingbase/KingbaseAgentTest.java b/agents/drivers/kingbase/src/test/java/com/dbx/agent/kingbase/KingbaseAgentTest.java
new file mode 100644
index 0000000..0e7a55b
--- /dev/null
+++ b/agents/drivers/kingbase/src/test/java/com/dbx/agent/kingbase/KingbaseAgentTest.java
@@ -0,0 +1,603 @@
+package com.dbx.agent.kingbase;
+
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import com.dbx.agent.test.TestSupport;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class KingbaseAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new KingbaseAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL sample_proc()";
+    }
+
+    @Test
+    void declaresKingbasePostgresLikeProfile() {
+        KingbaseAgent agent = new KingbaseAgent();
+
+        Assertions.assertEquals("com.kingbase8.Driver", agent.getProfile().getDriverClass());
+        Assertions.assertEquals("jdbc:kingbase8://{host}:{port}/{database}", agent.getProfile().getUrlTemplate());
+    }
+
+    @Test
+    void schemaSwitchPlacesSysCatalogAfterSelectedSchema() {
+        KingbaseAgent agent = new KingbaseAgent();
+
+        Assertions.assertEquals("SET search_path TO \"app\", sys_catalog", agent.setSchemaSQL("app"));
+        Assertions.assertEquals("SET search_path TO \"app\"\"prod\", sys_catalog", agent.setSchemaSQL("app\"prod"));
+    }
+
+    @Test
+    void mysqlCompatListDatabasesUsesCurrentDatabase() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        agent.setMysqlCompatMode(true);
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"database_name"},
+            new Object[][]{{"TEST"}}
+        )));
+
+        Assertions.assertEquals("TEST", agent.listDatabases().get(0).getName());
+        Assertions.assertEquals("SELECT current_database() AS database_name", sql.get(0));
+    }
+
+    @Test
+    void regularListDatabasesUsesKingbaseCatalog() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"database_name"},
+            new Object[][]{{"app"}, {"analytics"}}
+        )));
+
+        List<DatabaseInfo> databases = agent.listDatabases();
+        Assertions.assertEquals(2, databases.size());
+        Assertions.assertEquals("app", databases.get(0).getName());
+        Assertions.assertEquals("analytics", databases.get(1).getName());
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_database"), sql.get(0));
+    }
+
+    @Test
+    void regularListDatabasesFallsBackToPostgresCatalog() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnectionWithFailure(sql, "sys_catalog.sys_database", resultSet(
+            new String[]{"database_name"},
+            new Object[][]{{"test"}}
+        )));
+
+        List<DatabaseInfo> databases = agent.listDatabases();
+
+        Assertions.assertEquals(1, databases.size());
+        Assertions.assertEquals("test", databases.get(0).getName());
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_database"), sql.get(0));
+        Assertions.assertTrue(sql.get(1).contains("FROM pg_database"), sql.get(1));
+    }
+
+    @Test
+    void regularListSchemasKeepsKingbaseSystemSchemas() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"schema_name"},
+            new Object[][]{{"public"}, {"sys_catalog"}}
+        )));
+
+        Assertions.assertEquals(Arrays.asList("public", "sys_catalog"), agent.listSchemas());
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_namespace"), sql.get(0));
+        Assertions.assertFalse(sql.get(0).contains("SYS%"), sql.get(0));
+    }
+
+    @Test
+    void postgresCompatModeUsesPostgresCatalogForMetadata() throws Exception {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        Connection connection = postgresCatalogConnection(sql, resultSet(
+            new String[]{"schema_name"},
+            new Object[][]{{"public"}}
+        ));
+
+        Method afterConnect = KingbaseAgent.class.getDeclaredMethod("afterConnect", ConnectParams.class, Connection.class);
+        afterConnect.setAccessible(true);
+        afterConnect.invoke(agent, new ConnectParams(), connection);
+        TestSupport.setPrivateConnection(agent, connection);
+
+        Assertions.assertEquals(List.of("public"), agent.listSchemas());
+        Assertions.assertEquals("SELECT 1 FROM sys_catalog.sys_namespace WHERE 1 = 0", sql.get(0));
+        Assertions.assertEquals("SELECT 1 FROM pg_catalog.pg_namespace WHERE 1 = 0", sql.get(1));
+        Assertions.assertTrue(sql.get(2).contains("FROM pg_catalog.pg_namespace"), sql.get(2));
+        Assertions.assertEquals("SET search_path TO \"app\"", agent.setSchemaSQL("app"));
+    }
+
+    @Test
+    void mysqlCompatListTablesUsesInformationSchema() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        agent.setMysqlCompatMode(true);
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"table_name", "table_type"},
+            new Object[][]{{"test_timestamps", "BASE TABLE"}}
+        )));
+
+        Assertions.assertEquals("test_timestamps", agent.listTables("PUBLIC").get(0).getName());
+        Assertions.assertTrue(sql.get(0).contains("FROM information_schema.tables"));
+        Assertions.assertFalse(sql.get(0).contains("SHOW"));
+    }
+
+    @Test
+    void regularListTablesUsesKingbaseCatalogAndIncludesViews() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"table_name", "table_type", "table_comment"},
+            new Object[][]{{"app_table", "TABLE", "table comment"}, {"app_view", "VIEW", "view comment"}}
+        )));
+
+        List<TableInfo> tables = agent.listTables("public");
+
+        Assertions.assertEquals(2, tables.size());
+        Assertions.assertEquals("app_table", tables.get(0).getName());
+        Assertions.assertEquals("TABLE", tables.get(0).getTable_type());
+        Assertions.assertEquals("app_view", tables.get(1).getName());
+        Assertions.assertEquals("VIEW", tables.get(1).getTable_type());
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_class"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_rewrite"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_index"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_views"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_matviews"), sql.get(0));
+        Assertions.assertFalse(sql.get(0).contains("relkind"), sql.get(0));
+    }
+
+    @Test
+    void regularListObjectsIncludesKingbaseViewsProceduresAndFunctions() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql,
+            resultSet(
+                new String[]{"table_name", "table_type", "table_comment"},
+                new Object[][]{{"app_table", "TABLE", null}, {"app_view", "VIEW", "view comment"}}
+            ),
+            resultSet(
+                new String[]{"routine_name", "routine_type", "routine_comment"},
+                new Object[][]{{"refresh_stats", "PROCEDURE", "proc comment"}, {"format_name", "FUNCTION", "fn comment"}}
+            )
+        ));
+
+        List<ObjectInfo> objects = agent.listObjects("public");
+
+        Assertions.assertEquals(4, objects.size());
+        Assertions.assertEquals("app_table", objects.get(0).getName());
+        Assertions.assertEquals("TABLE", objects.get(0).getObject_type());
+        Assertions.assertEquals("app_view", objects.get(1).getName());
+        Assertions.assertEquals("VIEW", objects.get(1).getObject_type());
+        Assertions.assertEquals("refresh_stats", objects.get(2).getName());
+        Assertions.assertEquals("PROCEDURE", objects.get(2).getObject_type());
+        Assertions.assertEquals("format_name", objects.get(3).getName());
+        Assertions.assertEquals("FUNCTION", objects.get(3).getObject_type());
+        Assertions.assertTrue(sql.get(1).contains("FROM sys_catalog.sys_proc"), sql.get(1));
+        Assertions.assertTrue(sql.get(1).contains("p.prorettype = 2278"), sql.get(1));
+        Assertions.assertFalse(sql.get(1).contains("prokind"), sql.get(1));
+    }
+
+    @Test
+    void constrainedRegularTableMetadataPushesFilterTypesAndPaging() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"table_name", "table_type", "table_comment"},
+            new Object[][]{}
+        )));
+
+        agent.listTables("public", new MetadataListConstraints("ord", 30, 60, List.of("TABLE", "VIEW")));
+
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_class"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_views"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("UNION ALL"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("UPPER(CAST(c.relname AS varchar(256))) LIKE ? ESCAPE '\\\\'"), sql.get(0));
+        Assertions.assertFalse(sql.get(0).contains("relkind"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).endsWith("LIMIT 30 OFFSET 60"), sql.get(0));
+    }
+
+    @Test
+    void constrainedRegularMaterializedViewMetadataUsesMatviewCatalog() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"table_name", "table_type", "table_comment"},
+            new Object[][]{{"mv_sales", "MATERIALIZED_VIEW", "cached sales"}}
+        )));
+
+        List<TableInfo> tables = agent.listTables("public", new MetadataListConstraints("sales", 10, null, List.of("MATERIALIZED_VIEW")));
+
+        Assertions.assertEquals(1, tables.size());
+        Assertions.assertEquals("mv_sales", tables.get(0).getName());
+        Assertions.assertEquals("MATERIALIZED_VIEW", tables.get(0).getTable_type());
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_matviews"), sql.get(0));
+        Assertions.assertFalse(sql.get(0).contains("FROM sys_catalog.sys_views"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("UPPER(CAST(mv.matviewname AS varchar(256))) LIKE ? ESCAPE '\\\\'"), sql.get(0));
+        Assertions.assertFalse(sql.get(0).contains("relkind"), sql.get(0));
+    }
+
+    @Test
+    void constrainedRegularObjectMetadataPushesRoutineTypesAndPaging() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"object_name", "object_type", "object_comment"},
+            new Object[][]{}
+        )));
+
+        agent.listObjects("public", new MetadataListConstraints("sync", 10, null, List.of("PROCEDURE", "FUNCTION")));
+
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_proc"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("p.prorettype = 2278"), sql.get(0));
+        Assertions.assertFalse(sql.get(0).contains("prokind"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("ORDER BY CASE object_type"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).endsWith("LIMIT 10"), sql.get(0));
+    }
+
+    @Test
+    void constrainedMysqlCompatTableMetadataPushesInformationSchemaPaging() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        agent.setMysqlCompatMode(true);
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"table_name", "table_type"},
+            new Object[][]{}
+        )));
+
+        agent.listTables("PUBLIC", new MetadataListConstraints("ord", 20, 40, List.of("VIEW")));
+
+        Assertions.assertTrue(sql.get(0).contains("FROM information_schema.tables"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("table_type IN (?)"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("UPPER(table_name) LIKE ? ESCAPE '\\\\'"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).endsWith("LIMIT 20 OFFSET 40"), sql.get(0));
+    }
+
+    @Test
+    void regularRoutineSourceUsesKingbaseFunctionDefinition() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"source"},
+            new Object[][]{{"CREATE FUNCTION public.format_name() RETURNS text AS $$ SELECT 'x'; $$"}}
+        )));
+
+        ObjectSource source = agent.getObjectSource("public", "format_name", "FUNCTION");
+
+        Assertions.assertTrue(source.getSource().startsWith("CREATE FUNCTION public.format_name()"), source.getSource());
+        Assertions.assertTrue(sql.get(0).contains("SELECT sys_get_functiondef(p.oid) AS source"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("FROM sys_catalog.sys_proc"), sql.get(0));
+        Assertions.assertFalse(sql.get(0).contains("prokind"), sql.get(0));
+    }
+
+    @Test
+    void regularGetColumnsUsesFormattedCatalogTypes() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql,
+            resultSet(
+                new String[]{"column_name"},
+                new Object[][]{{"id"}}
+            ),
+            resultSet(
+                new String[]{
+                    "column_name",
+                    "data_type",
+                    "is_nullable",
+                    "column_default",
+                    "column_comment",
+                    "numeric_precision",
+                    "numeric_scale",
+                    "character_maximum_length"
+                },
+                new Object[][]{
+                    {"id", "integer", false, "nextval('orders_id_seq'::regclass)", "identifier", 32, 0, null},
+                    {"create_time", "timestamp with time zone", true, null, null, null, null, null},
+                    {"name", "character varying(64)", true, null, "display name", null, null, 64}
+                }
+            )
+        ));
+
+        List<ColumnInfo> columns = agent.getColumns("public", "orders");
+
+        Assertions.assertEquals(3, columns.size());
+        Assertions.assertEquals("integer", columns.get(0).getData_type());
+        Assertions.assertTrue(columns.get(0).getIs_primary_key());
+        Assertions.assertFalse(columns.get(0).getIs_nullable());
+        Assertions.assertEquals("timestamp with time zone", columns.get(1).getData_type());
+        Assertions.assertNotEquals("USER-DEFINED", columns.get(1).getData_type());
+        Assertions.assertEquals(Integer.valueOf(64), columns.get(2).getCharacter_maximum_length());
+        Assertions.assertTrue(sql.get(1).contains("format_type(a.atttypid, a.atttypmod) AS data_type"), sql.get(1));
+        Assertions.assertTrue(sql.get(1).contains("FROM sys_catalog.sys_attribute"), sql.get(1));
+        Assertions.assertFalse(sql.get(1).contains("information_schema.columns"), sql.get(1));
+    }
+
+    @Test
+    void mysqlCompatGetColumnsKeepsInformationSchemaPath() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        agent.setMysqlCompatMode(true);
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql,
+            resultSet(
+                new String[]{"column_name"},
+                new Object[][]{{"id"}}
+            ),
+            resultSet(
+                new String[]{
+                    "column_name",
+                    "data_type",
+                    "is_nullable",
+                    "column_default",
+                    "numeric_precision",
+                    "numeric_scale",
+                    "character_maximum_length"
+                },
+                new Object[][]{{"id", "int", "NO", null, 32, 0, null}}
+            )
+        ));
+
+        List<ColumnInfo> columns = agent.getColumns("PUBLIC", "orders");
+
+        Assertions.assertEquals("int", columns.get(0).getData_type());
+        Assertions.assertTrue(sql.get(1).contains("FROM information_schema.columns"), sql.get(1));
+    }
+
+    @Test
+    void regularListIndexesIncludesPrimaryUniqueAndSecondaryIndexes() {
+        List<String> sql = new ArrayList<>();
+        KingbaseAgent agent = new KingbaseAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"index_name", "index_type", "is_unique", "is_primary", "column_name", "ordinal_position"},
+            new Object[][]{
+                {"orders_pkey", "btree", true, true, "id", 1},
+                {"idx_orders_created", "btree", false, false, "created", 1},
+                {"idx_orders_name_created", "btree", false, false, "name", 1},
+                {"idx_orders_name_created", "btree", false, false, "created", 2}
+            }
+        )));
+
+        List<IndexInfo> indexes = agent.listIndexes("public", "orders");
+
+        Assertions.assertEquals(3, indexes.size());
+        Assertions.assertEquals("orders_pkey", indexes.get(0).getName());
+        Assertions.assertEquals(Arrays.asList("id"), indexes.get(0).getColumns());
+        Assertions.assertTrue(indexes.get(0).getIs_unique());
+        Assertions.assertTrue(indexes.get(0).getIs_primary());
+        Assertions.assertEquals("idx_orders_created", indexes.get(1).getName());
+        Assertions.assertEquals(Arrays.asList("created"), indexes.get(1).getColumns());
+        Assertions.assertFalse(indexes.get(1).getIs_unique());
+        Assertions.assertFalse(indexes.get(1).getIs_primary());
+        Assertions.assertEquals(Arrays.asList("name", "created"), indexes.get(2).getColumns());
+        Assertions.assertTrue(sql.get(0).contains("FROM SYS_CATALOG.SYS_INDEX"), sql.get(0));
+        Assertions.assertFalse(sql.get(0).contains("information_schema.table_constraints"), sql.get(0));
+    }
+
+    @Test
+    void mysqlCompatTimestampTypeNameIsReadAsTimestampText() throws Exception {
+        Timestamp timestamp = Timestamp.valueOf("2026-06-22 11:29:00");
+        KingbaseAgent agent = new KingbaseAgent();
+        agent.setMysqlCompatMode(true);
+
+        Object value = readResultValue(agent, timestampResultSet(timestamp), Types.BINARY, "timestamp");
+
+        Assertions.assertEquals("2026-06-22 11:29:00.0", value);
+    }
+
+    private static Connection preparedConnection(List<String> sql, ResultSet rs) {
+        return preparedConnection(sql, new ResultSet[]{rs});
+    }
+
+    private static Connection preparedConnection(List<String> sql, ResultSet... resultSets) {
+        int[] resultSetIndex = {0};
+        PreparedStatement statement = proxy(PreparedStatement.class, (method, args) -> {
+            if ("executeQuery".equals(method.getName())) {
+                int current = Math.min(resultSetIndex[0], resultSets.length - 1);
+                resultSetIndex[0] += 1;
+                return resultSets[current];
+            }
+            if ("setString".equals(method.getName())) {
+                return null;
+            }
+            if ("close".equals(method.getName())) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+        Statement plainStatement = proxy(Statement.class, (method, args) -> {
+            if ("executeQuery".equals(method.getName())) {
+                sql.add(String.valueOf(args[0]));
+                int current = Math.min(resultSetIndex[0], resultSets.length - 1);
+                resultSetIndex[0] += 1;
+                return resultSets[current];
+            }
+            if ("close".equals(method.getName())) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+        return proxy(Connection.class, (method, args) -> {
+            if ("prepareStatement".equals(method.getName())) {
+                sql.add(String.valueOf(args[0]));
+                return statement;
+            }
+            if ("createStatement".equals(method.getName())) {
+                return plainStatement;
+            }
+            if ("isClosed".equals(method.getName())) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static Connection preparedConnectionWithFailure(List<String> sql, String failingSqlFragment, ResultSet fallback) {
+        return proxy(Connection.class, (method, args) -> {
+            if ("prepareStatement".equals(method.getName())) {
+                String preparedSql = String.valueOf(args[0]);
+                sql.add(preparedSql);
+                return proxy(PreparedStatement.class, (statementMethod, statementArgs) -> {
+                    if ("executeQuery".equals(statementMethod.getName())) {
+                        if (preparedSql.contains(failingSqlFragment)) {
+                            throw new SQLException("relation does not exist: " + failingSqlFragment);
+                        }
+                        return fallback;
+                    }
+                    if ("close".equals(statementMethod.getName())) {
+                        return null;
+                    }
+                    return defaultValue(statementMethod.getReturnType());
+                });
+            }
+            if ("isClosed".equals(method.getName())) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static Connection postgresCatalogConnection(List<String> sql, ResultSet metadataResult) {
+        return proxy(Connection.class, (method, args) -> {
+            if ("createStatement".equals(method.getName())) {
+                return proxy(Statement.class, (statementMethod, statementArgs) -> {
+                    if ("executeQuery".equals(statementMethod.getName())) {
+                        String query = String.valueOf(statementArgs[0]);
+                        sql.add(query);
+                        if (query.contains("sys_catalog.sys_namespace")) {
+                            throw new SQLException("relation does not exist: sys_catalog.sys_namespace");
+                        }
+                        return resultSet(new String[]{"probe"}, new Object[][]{});
+                    }
+                    return defaultValue(statementMethod.getReturnType());
+                });
+            }
+            if ("prepareStatement".equals(method.getName())) {
+                String query = String.valueOf(args[0]);
+                sql.add(query);
+                return proxy(PreparedStatement.class, (statementMethod, statementArgs) -> {
+                    if ("executeQuery".equals(statementMethod.getName())) return metadataResult;
+                    return defaultValue(statementMethod.getReturnType());
+                });
+            }
+            if ("isClosed".equals(method.getName())) return false;
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSet resultSet(String[] columns, Object[][] rows) {
+        int[] index = {-1};
+        return proxy(ResultSet.class, (method, args) -> {
+            switch (method.getName()) {
+                case "next":
+                    index[0] += 1;
+                    return index[0] < rows.length;
+                case "getString":
+                    Object key = args[0];
+                    if (key instanceof Number) {
+                        return rows[index[0]][((Number) key).intValue() - 1];
+                    }
+                    for (int i = 0; i < columns.length; i++) {
+                        if (columns[i].equalsIgnoreCase(String.valueOf(key))) {
+                            return rows[index[0]][i];
+                        }
+                    }
+                    return null;
+                case "getBoolean":
+                    Object booleanValue = columnValue(columns, rows[index[0]], args[0]);
+                    if (booleanValue instanceof Boolean) return booleanValue;
+                    if (booleanValue instanceof Number) return ((Number) booleanValue).intValue() != 0;
+                    return Boolean.parseBoolean(String.valueOf(booleanValue));
+                case "getObject":
+                    return columnValue(columns, rows[index[0]], args[0]);
+                case "wasNull":
+                    return false;
+                case "close":
+                    return null;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Object columnValue(String[] columns, Object[] row, Object key) {
+        if (key instanceof Number) {
+            return row[((Number) key).intValue() - 1];
+        }
+        for (int i = 0; i < columns.length; i++) {
+            if (columns[i].equalsIgnoreCase(String.valueOf(key))) {
+                return row[i];
+            }
+        }
+        return null;
+    }
+
+    private static ResultSet timestampResultSet(Timestamp timestamp) {
+        return proxy(ResultSet.class, (method, args) -> {
+            switch (method.getName()) {
+                case "getTimestamp":
+                    return timestamp;
+                case "getBytes":
+                    throw new AssertionError("timestamp should not be read as bytes");
+                case "wasNull":
+                    return false;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static <T> T proxy(Class<T> type, MethodHandler handler) {
+        InvocationHandler invocationHandler = (Object unused, Method method, Object[] args) -> handler.handle(method, args);
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) return false;
+        if (Byte.TYPE.equals(type)) return (byte) 0;
+        if (Short.TYPE.equals(type)) return (short) 0;
+        if (Integer.TYPE.equals(type)) return 0;
+        if (Long.TYPE.equals(type)) return 0L;
+        if (Float.TYPE.equals(type)) return 0f;
+        if (Double.TYPE.equals(type)) return 0.0d;
+        if (Character.TYPE.equals(type)) return '\0';
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args) throws Throwable;
+    }
+
+    private static Object readResultValue(KingbaseAgent agent, ResultSet rs, int sqlType, String columnTypeName) throws Exception {
+        Method method = KingbaseAgent.class.getDeclaredMethod("resultValue", ResultSet.class, int.class, int.class, String.class);
+        method.setAccessible(true);
+        return method.invoke(agent, rs, 1, sqlType, columnTypeName);
+    }
+}
diff --git a/agents/drivers/kylin/build.gradle b/agents/drivers/kylin/build.gradle
new file mode 100644
index 0000000..7ec3cd6
--- /dev/null
+++ b/agents/drivers/kylin/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'org.apache.kylin:kylin-jdbc:5.0.0'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Apache Kylin', 'Main-Class': 'com.dbx.agent.kylin.KylinAgent')
+    }
+}
diff --git a/agents/drivers/kylin/src/main/java/com/dbx/agent/kylin/KylinAgent.java b/agents/drivers/kylin/src/main/java/com/dbx/agent/kylin/KylinAgent.java
new file mode 100644
index 0000000..8af270c
--- /dev/null
+++ b/agents/drivers/kylin/src/main/java/com/dbx/agent/kylin/KylinAgent.java
@@ -0,0 +1,144 @@
+package com.dbx.agent.kylin;
+
+import com.dbx.agent.AbstractJdbcAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+public final class KylinAgent extends AbstractJdbcAgent {
+
+    @Override
+    protected String driverClass() {
+        return "org.apache.kylin.jdbc.Driver";
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return buildUrl(params);
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (ResultSet rs = requireConnected().getMetaData().getCatalogs()) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString("TABLE_CAT")));
+                }
+            }
+            result.sort(Comparator.comparing(DatabaseInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            try (ResultSet rs = requireConnected().getMetaData().getTables(null, schema, null, null)) {
+                while (rs.next()) {
+                    result.add(new TableInfo(
+                        rs.getString("TABLE_NAME"),
+                        normalizeTableType(rs.getString("TABLE_TYPE")),
+                        null
+                    ));
+                }
+            }
+            result.sort(Comparator.comparing(TableInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            Set<String> primaryKeys = new LinkedHashSet<>();
+            try (ResultSet rs = requireConnected().getMetaData().getPrimaryKeys(null, schema, table)) {
+                while (rs.next()) {
+                    primaryKeys.add(rs.getString("COLUMN_NAME"));
+                }
+            }
+
+            List<ColumnInfo> result = new ArrayList<>();
+            try (ResultSet rs = requireConnected().getMetaData().getColumns(null, schema, table, null)) {
+                while (rs.next()) {
+                    String colName = rs.getString("COLUMN_NAME");
+                    result.add(new ColumnInfo(
+                        colName,
+                        rs.getString("TYPE_NAME"),
+                        "YES".equals(rs.getString("IS_NULLABLE")),
+                        rs.getString("COLUMN_DEF"),
+                        primaryKeys.contains(colName),
+                        null,
+                        emptyToNull(rs.getString("REMARKS")),
+                        intOrNull(rs, "COLUMN_SIZE"),
+                        intOrNull(rs, "DECIMAL_DIGITS"),
+                        null
+                    ));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "";
+    }
+
+    private static String buildUrl(ConnectParams params) {
+        return "jdbc:kylin://" + params.getHost() + ":" + params.getPort() + "/" + params.getDatabase();
+    }
+
+    private static String normalizeTableType(String type) {
+        if ("BASE TABLE".equals(type)) {
+            return "TABLE";
+        }
+        return type;
+    }
+
+    private static Integer intOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    private static String emptyToNull(String value) {
+        return value == null || value.isEmpty() ? null : value;
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new KylinAgent()).run();
+    }
+}
diff --git a/agents/drivers/kylin/src/test/java/com/dbx/agent/kylin/KylinAgentTest.java b/agents/drivers/kylin/src/test/java/com/dbx/agent/kylin/KylinAgentTest.java
new file mode 100644
index 0000000..4c3e88b
--- /dev/null
+++ b/agents/drivers/kylin/src/test/java/com/dbx/agent/kylin/KylinAgentTest.java
@@ -0,0 +1,16 @@
+package com.dbx.agent.kylin;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+
+class KylinAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new KylinAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL sample_proc()";
+    }
+}
diff --git a/agents/drivers/mongodb/build.gradle b/agents/drivers/mongodb/build.gradle
new file mode 100644
index 0000000..125b760
--- /dev/null
+++ b/agents/drivers/mongodb/build.gradle
@@ -0,0 +1,11 @@
+dependencies {
+    implementation project(':common')
+    implementation 'org.mongodb:mongodb-driver-sync:3.12.14'
+    implementation 'com.google.code.gson:gson:2.11.0'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'MongoDB (Legacy)', 'Main-Class': 'com.dbx.agent.mongodb.MongoAgent')
+    }
+}
diff --git a/agents/drivers/mongodb/src/main/java/com/dbx/agent/mongodb/MongoAgent.java b/agents/drivers/mongodb/src/main/java/com/dbx/agent/mongodb/MongoAgent.java
new file mode 100644
index 0000000..b5b883f
--- /dev/null
+++ b/agents/drivers/mongodb/src/main/java/com/dbx/agent/mongodb/MongoAgent.java
@@ -0,0 +1,927 @@
+package com.dbx.agent.mongodb;
+
+import com.dbx.agent.AgentProtocol;
+import com.dbx.agent.IndexInfo;
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonNull;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.mongodb.ConnectionString;
+import com.mongodb.MongoCredential;
+import com.mongodb.MongoClientSettings;
+import com.mongodb.ServerAddress;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.client.model.UpdateOptions;
+import java.io.BufferedReader;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.security.KeyFactory;
+import java.security.KeyStore;
+import java.security.PrivateKey;
+import java.security.SecureRandom;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateFactory;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.time.Instant;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.net.ssl.KeyManager;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import org.bson.Document;
+import org.bson.json.JsonMode;
+import org.bson.json.JsonWriterSettings;
+import org.bson.types.ObjectId;
+
+public final class MongoAgent {
+    private static final Gson GSON = new Gson();
+    private static final DateTimeFormatter DATE_FORMAT = DateTimeFormatter.ISO_INSTANT.withZone(ZoneOffset.UTC);
+    private static final long JS_MAX_SAFE_INTEGER = 9_007_199_254_740_991L;
+    private static final JsonWriterSettings EXTENDED_JSON_SETTINGS = JsonWriterSettings.builder()
+        .outputMode(JsonMode.RELAXED)
+        .build();
+    private static MongoClient client;
+
+    private MongoAgent() {
+    }
+
+    private static String stringOrNull(JsonObject object, String key) {
+        JsonElement element = object.get(key);
+        return element == null || element instanceof JsonNull ? null : element.getAsString();
+    }
+
+    static Document documentOrNull(JsonObject object, String key) {
+        String json = stringOrNull(object, key);
+        return json == null || json.isBlank() ? null : Document.parse(json);
+    }
+
+    static MongoClientSettings.Builder configureBuilder(JsonObject connObj) {
+        String host = connObj.has("host") ? connObj.get("host").getAsString() : "127.0.0.1";
+        int port = connObj.has("port") ? connObj.get("port").getAsInt() : 27017;
+        String username = coalesce(stringOrNull(connObj, "username"));
+        String password = coalesce(stringOrNull(connObj, "password"));
+        String authDatabase = authenticationDatabase(connObj);
+        String connectionString = stringOrNull(connObj, "connection_string");
+        boolean ssl = connObj.has("ssl") && !connObj.get("ssl").isJsonNull() && connObj.get("ssl").getAsBoolean();
+        String caCertPath = stringOrNull(connObj, "ca_cert_path");
+        String clientCertPath = firstNonBlank(
+            stringOrNull(connObj, "client_cert_path"), stringOrNull(connObj, "cert_path"));
+        String clientKeyPath = firstNonBlank(
+            stringOrNull(connObj, "client_key_path"), stringOrNull(connObj, "key_path"));
+
+        if ((clientCertPath == null) != (clientKeyPath == null)) {
+            throw new IllegalArgumentException("Client certificate and key must be provided together");
+        }
+
+        MongoClientSettings.Builder builder = MongoClientSettings.builder();
+        if (connectionString != null && !connectionString.isBlank()) {
+            builder.applyConnectionString(new ConnectionString(connectionString));
+        } else {
+            builder.applyToClusterSettings(
+                settings -> settings.hosts(Collections.singletonList(new ServerAddress(host, port))));
+            if (!username.isBlank()) {
+                builder.credential(MongoCredential.createCredential(username, authDatabase, password.toCharArray()));
+            }
+        }
+
+        if (ssl) {
+            applyTlsSettings(builder, caCertPath, clientCertPath, clientKeyPath);
+        }
+
+        return builder;
+    }
+
+    private static Object connect(JsonObject params) {
+        JsonObject connObj = params.has("connection") && params.get("connection").isJsonObject()
+            ? params.getAsJsonObject("connection")
+            : params;
+        String database = defaultString(stringOrNull(connObj, "database"), "admin");
+
+        MongoClientSettings.Builder builder = configureBuilder(connObj);
+
+        if (client != null) {
+            client.close();
+        }
+        client = MongoClients.create(builder.build());
+        client.getDatabase(database).runCommand(new Document("ping", 1));
+        return Collections.singletonMap("ok", true);
+    }
+
+    private static void applyTlsSettings(MongoClientSettings.Builder builder,
+        String caCertPath, String clientCertPath, String clientKeyPath) {
+        builder.applyToSslSettings(sslBuilder -> {
+            sslBuilder.enabled(true);
+            if (caCertPath != null && !caCertPath.isBlank()
+                || clientCertPath != null && !clientCertPath.isBlank()) {
+                try {
+                    sslBuilder.context(createTlsSslContext(caCertPath, clientCertPath, clientKeyPath));
+                } catch (Exception e) {
+                    throw new RuntimeException("Failed to configure TLS: " + e.getMessage(), e);
+                }
+            }
+        });
+    }
+
+    static SSLContext createTlsSslContext(String caCertPath, String clientCertPath, String clientKeyPath)
+        throws Exception {
+        TrustManager[] trustManagers = null;
+        if (caCertPath != null && !caCertPath.isBlank()) {
+            trustManagers = loadTrustManagersFromPem(caCertPath);
+        }
+
+        KeyManager[] keyManagers = null;
+        if (clientCertPath != null && !clientCertPath.isBlank()
+            && clientKeyPath != null && !clientKeyPath.isBlank()) {
+            keyManagers = loadKeyManagersFromPem(clientCertPath, clientKeyPath);
+        }
+
+        SSLContext ctx = SSLContext.getInstance("TLS");
+        ctx.init(keyManagers, trustManagers, new SecureRandom());
+        return ctx;
+    }
+
+    static TrustManager[] loadTrustManagersFromPem(String caCertPath) throws Exception {
+        CertificateFactory cf = CertificateFactory.getInstance("X.509");
+        KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
+        trustStore.load(null, null);
+        int i = 0;
+        try (InputStream is = new FileInputStream(caCertPath)) {
+            for (Certificate cert : (Collection<? extends Certificate>) cf.generateCertificates(is)) {
+                trustStore.setCertificateEntry("ca-" + i, cert);
+                i++;
+            }
+        }
+        TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+        tmf.init(trustStore);
+        return tmf.getTrustManagers();
+    }
+
+    static KeyManager[] loadKeyManagersFromPem(String certPath, String keyPath) throws Exception {
+        CertificateFactory cf = CertificateFactory.getInstance("X.509");
+        Certificate cert;
+        try (InputStream is = new FileInputStream(certPath)) {
+            cert = cf.generateCertificate(is);
+        }
+
+        PrivateKey key = loadPrivateKeyFromPem(keyPath);
+
+        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
+        keyStore.load(null, null);
+        keyStore.setCertificateEntry("client", cert);
+        keyStore.setKeyEntry("client", key, new char[0], new Certificate[] {cert});
+
+        KeyManagerFactory kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+        kmf.init(keyStore, new char[0]);
+        return kmf.getKeyManagers();
+    }
+
+    static PrivateKey loadPrivateKeyFromPem(String keyPath) throws Exception {
+        String content = new String(Files.readAllBytes(Paths.get(keyPath)), StandardCharsets.UTF_8);
+        content = content.replace("-----BEGIN PRIVATE KEY-----", "")
+            .replace("-----END PRIVATE KEY-----", "")
+            .replace("-----BEGIN RSA PRIVATE KEY-----", "")
+            .replace("-----END RSA PRIVATE KEY-----", "")
+            .replace("-----BEGIN EC PRIVATE KEY-----", "")
+            .replace("-----END EC PRIVATE KEY-----", "");
+        byte[] keyBytes = Base64.getDecoder().decode(content.replaceAll("\\s", ""));
+
+        // PKCS#8 (standard format, "-----BEGIN PRIVATE KEY-----")
+        try {
+            return KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(keyBytes));
+        } catch (Exception e) {
+            // ignore — try next format
+        }
+        try {
+            return KeyFactory.getInstance("EC").generatePrivate(new PKCS8EncodedKeySpec(keyBytes));
+        } catch (Exception e) {
+            // ignore — try next format
+        }
+
+        // PKCS#1 RSA — add PKCS#8 AlgorithmIdentifier prefix
+        // The prefix is: SEQUENCE { INTEGER 0, SEQUENCE { OID 1.2.840.113549.1.1.1, NULL }, OCTET STRING }
+        try {
+            byte[] pkcs8Header = {
+                0x30, (byte) 0x82, 0, 0,  // SEQUENCE (length filled in below)
+                0x02, 0x01, 0x00,          // INTEGER 0
+                0x30, 0x0d,                // SEQUENCE (AlgorithmIdentifier)
+                0x06, 0x09, 0x2a, (byte) 0x86, 0x48, (byte) 0x86, (byte) 0xf7, 0x0d, 0x01, 0x01, 0x01,  // OID 1.2.840.113549.1.1.1
+                0x05, 0x00,                // NULL
+                0x04                       // OCTET STRING (length filled in below)
+            };
+            int totalLen = pkcs8Header.length + keyBytes.length - 4;  // subtract placeholder SEQUENCE length
+            pkcs8Header[2] = (byte) ((totalLen >> 8) & 0xff);
+            pkcs8Header[3] = (byte) (totalLen & 0xff);
+            // OCTET STRING length
+            int octetLen = keyBytes.length;
+            byte[] octetLenBytes;
+            if (octetLen < 128) {
+                octetLenBytes = new byte[] {(byte) octetLen};
+            } else if (octetLen < 256) {
+                octetLenBytes = new byte[] {(byte) 0x81, (byte) octetLen};
+            } else {
+                octetLenBytes = new byte[] {(byte) 0x82, (byte) (octetLen >> 8), (byte) (octetLen & 0xff)};
+            }
+            byte[] pkcs8Key = new byte[pkcs8Header.length + octetLenBytes.length - 1 + keyBytes.length];
+            int pos = 0;
+            System.arraycopy(pkcs8Header, 0, pkcs8Key, pos, pkcs8Header.length - 1);  // exclude placeholder OCTET STRING length
+            pos += pkcs8Header.length - 1;
+            System.arraycopy(octetLenBytes, 0, pkcs8Key, pos, octetLenBytes.length);
+            pos += octetLenBytes.length;
+            System.arraycopy(keyBytes, 0, pkcs8Key, pos, keyBytes.length);
+            return KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(pkcs8Key));
+        } catch (Exception e) {
+            throw new IllegalArgumentException(
+                "Unsupported private key format in " + keyPath
+                    + ". Use PKCS#8 (-----BEGIN PRIVATE KEY-----) or PKCS#1 RSA (-----BEGIN RSA PRIVATE KEY-----).",
+                e);
+        }
+    }
+
+    static String firstNonBlank(String... values) {
+        for (String value : values) {
+            if (value != null && !value.isBlank()) {
+                return value;
+            }
+        }
+        return null;
+    }
+
+    static String authenticationDatabase(JsonObject connObj) {
+        String authSource = urlParam(stringOrNull(connObj, "url_params"), "authSource");
+        if (authSource != null && !authSource.isBlank()) {
+            return authSource;
+        }
+        return "admin";
+    }
+
+    private static String urlParam(String urlParams, String key) {
+        if (urlParams == null || urlParams.isBlank()) {
+            return null;
+        }
+        String normalized = urlParams.startsWith("?") ? urlParams.substring(1) : urlParams;
+        for (String pair : normalized.split("&")) {
+            if (pair.isBlank()) continue;
+            String[] parts = pair.split("=", 2);
+            if (decode(parts[0]).equals(key)) {
+                return parts.length > 1 ? decode(parts[1]) : "";
+            }
+        }
+        return null;
+    }
+
+    private static String decode(String value) {
+        return URLDecoder.decode(value, StandardCharsets.UTF_8);
+    }
+
+    private static Object listDatabases() {
+        MongoClient c = requireClient();
+        List<Map<String, String>> result = new ArrayList<>();
+        for (String name : c.listDatabaseNames()) {
+            result.add(Collections.singletonMap("name", name));
+        }
+        return result;
+    }
+
+    private static Object listCollections(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        List<String> result = new ArrayList<>();
+        for (String name : c.getDatabase(database).listCollectionNames()) {
+            result.add(name);
+        }
+        return result;
+    }
+
+    private static Object listIndexes(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        String collection = params.get("table").getAsString();
+        List<IndexInfo> result = new ArrayList<>();
+        for (Document index : c.getDatabase(database).getCollection(collection).listIndexes()) {
+            result.add(indexInfoFromDocument(index));
+        }
+        return result;
+    }
+
+    static IndexInfo indexInfoFromDocument(Document index) {
+        Document keys = index.get("key") instanceof Document document ? document : new Document();
+        String name = index.getString("name");
+        if (name == null || name.isBlank()) {
+            List<String> parts = new ArrayList<>();
+            for (Map.Entry<String, Object> entry : keys.entrySet()) {
+                parts.add(entry.getKey() + "_" + String.valueOf(entry.getValue()));
+            }
+            name = String.join("_", parts);
+        }
+
+        List<String> columns = new ArrayList<>(keys.keySet());
+        String indexType = null;
+        if (!keys.isEmpty()) {
+            List<String> parts = new ArrayList<>();
+            for (Map.Entry<String, Object> entry : keys.entrySet()) {
+                parts.add(entry.getKey() + ": " + String.valueOf(entry.getValue()));
+            }
+            indexType = String.join(", ", parts);
+        }
+
+        Object unique = index.get("unique");
+        Document filter = index.get("partialFilterExpression") instanceof Document document ? document : null;
+        return new IndexInfo(
+            name,
+            columns,
+            unique instanceof Boolean && (Boolean) unique,
+            "_id_".equals(name),
+            filter == null ? null : filter.toJson(),
+            indexType,
+            null,
+            null
+        );
+    }
+
+    private static Object findDocuments(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        String collection = params.get("collection").getAsString();
+        long skip = params.has("skip") ? params.get("skip").getAsLong() : 0;
+        int limit = params.has("limit") ? params.get("limit").getAsInt() : 50;
+        Document filterDoc = documentOrNull(params, "filter");
+        Document projectionDoc = documentOrNull(params, "projection");
+        Document sortDoc = documentOrNull(params, "sort");
+
+        var col = c.getDatabase(database).getCollection(collection);
+        if (filterDoc == null) {
+            filterDoc = new Document();
+        }
+        long total = col.countDocuments(filterDoc);
+
+        var iterable = col.find(filterDoc).skip((int) skip).limit(limit);
+        if (projectionDoc != null) {
+            iterable = iterable.projection(projectionDoc);
+        }
+        if (sortDoc != null) {
+            iterable = iterable.sort(sortDoc);
+        }
+
+        List<Map<String, Object>> documents = new ArrayList<>();
+        for (Document document : iterable) {
+            documents.add(bsonToJson(document));
+        }
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("documents", documents);
+        result.put("total", total);
+        return result;
+    }
+
+    /**
+     * MongoDB Extended JSON read path for transfer; output follows the driver's
+     * relaxed Extended JSON representation rather than the UI display format.
+     */
+    private static Object findDocumentsExtendedJson(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        String collection = params.get("collection").getAsString();
+        long skip = params.has("skip") ? params.get("skip").getAsLong() : 0;
+        int limit = params.has("limit") ? params.get("limit").getAsInt() : 50;
+        Document filterDoc = documentOrNull(params, "filter");
+        Document projectionDoc = documentOrNull(params, "projection");
+        Document sortDoc = documentOrNull(params, "sort");
+
+        var col = c.getDatabase(database).getCollection(collection);
+        if (filterDoc == null) {
+            filterDoc = new Document();
+        }
+        long total = col.countDocuments(filterDoc);
+
+        var iterable = col.find(filterDoc).skip((int) skip).limit(limit);
+        if (projectionDoc != null) {
+            iterable = iterable.projection(projectionDoc);
+        }
+        if (sortDoc != null) {
+            iterable = iterable.sort(sortDoc);
+        }
+
+        List<JsonObject> documents = new ArrayList<>();
+        for (Document document : iterable) {
+            documents.add(bsonToExtendedJson(document));
+        }
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("documents", documents);
+        result.put("total", total);
+        return result;
+    }
+
+    private static Object serverVersion(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = defaultString(stringOrNull(params, "database"), "admin");
+        Document buildInfo = c.getDatabase(database).runCommand(new Document("buildInfo", 1));
+        return serverVersionFromBuildInfo(buildInfo);
+    }
+
+    static String serverVersionFromBuildInfo(Document buildInfo) {
+        String version = buildInfo.getString("version");
+        if (version == null || version.isBlank()) {
+            throw new IllegalStateException("MongoDB server version not found");
+        }
+        return version;
+    }
+
+    private static Object createIndex(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        String collection = params.get("collection").getAsString();
+        Document keys = requiredDocument(params, "keys_json", "Index keys");
+        if (keys.isEmpty()) {
+            throw new IllegalArgumentException("Index keys are required");
+        }
+
+        Document index = new Document("key", keys);
+        Document options = documentOrNull(params, "options_json");
+        if (options != null) {
+            index.putAll(options);
+        }
+        String name = index.getString("name");
+        if (name == null || name.isBlank()) {
+            name = defaultIndexName(keys);
+            index.put("name", name);
+        }
+
+        c.getDatabase(database).runCommand(
+            new Document("createIndexes", collection)
+                .append("indexes", Collections.singletonList(index))
+        );
+        return Collections.singletonMap("name", name);
+    }
+
+    private static Document requiredDocument(JsonObject params, String key, String label) {
+        Document document = documentOrNull(params, key);
+        if (document == null) {
+            throw new IllegalArgumentException(label + " are required");
+        }
+        return document;
+    }
+
+    private static String defaultIndexName(Document keys) {
+        List<String> parts = new ArrayList<>();
+        for (Map.Entry<String, Object> entry : keys.entrySet()) {
+            parts.add(entry.getKey() + "_" + String.valueOf(entry.getValue()));
+        }
+        return String.join("_", parts);
+    }
+
+    private static Object dropIndexes(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        String collection = params.get("collection").getAsString();
+        String indexesJson = stringOrNull(params, "indexes_json");
+        boolean single = params.has("single") && !params.get("single").isJsonNull() && params.get("single").getAsBoolean();
+        Object index = parseDropIndexesValue(indexesJson, single);
+
+        List<IndexInfo> before = listIndexInfos(c, database, collection);
+        c.getDatabase(database).runCommand(new Document("dropIndexes", collection).append("index", index));
+        List<IndexInfo> after = listIndexInfos(c, database, collection);
+        List<String> droppedNames = diffDroppedIndexNames(before, after);
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("dropped_names", droppedNames);
+        result.put("affected_rows", droppedNames.size());
+        return result;
+    }
+
+    private static Object dropCollection(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        String collection = params.get("collection").getAsString();
+        c.getDatabase(database).getCollection(collection).drop();
+        return Collections.singletonMap("ok", true);
+    }
+
+    private static Object parseDropIndexesValue(String indexesJson, boolean single) {
+        if (indexesJson == null || indexesJson.isBlank()) {
+            if (single) {
+                throw new IllegalArgumentException("dropIndex requires a string index name or JSON document");
+            }
+            return "*";
+        }
+
+        JsonElement value = JsonParser.parseString(indexesJson);
+        if (value.isJsonPrimitive() && value.getAsJsonPrimitive().isString()) {
+            String name = value.getAsString();
+            if (name.isBlank()) {
+                throw new IllegalArgumentException("Index name is required");
+            }
+            if (single && "*".equals(name)) {
+                throw new IllegalArgumentException("dropIndex does not accept \"*\"; use dropIndexes() or dropIndexes(\"*\") instead");
+            }
+            return name;
+        }
+        if (value.isJsonObject()) {
+            JsonObject object = value.getAsJsonObject();
+            if (object.size() == 0) {
+                throw new IllegalArgumentException("Index specification is required");
+            }
+            return Document.parse(indexesJson);
+        }
+        if (value.isJsonArray()) {
+            if (single) {
+                throw new IllegalArgumentException("dropIndex only accepts a string index name or JSON document; arrays are not supported");
+            }
+            List<String> names = new ArrayList<>();
+            value.getAsJsonArray().forEach(item -> {
+                if (!item.isJsonPrimitive() || !item.getAsJsonPrimitive().isString() || item.getAsString().isBlank()) {
+                    throw new IllegalArgumentException("dropIndexes only accepts arrays of string index names");
+                }
+                names.add(item.getAsString());
+            });
+            if (names.isEmpty()) {
+                throw new IllegalArgumentException("dropIndexes only accepts non-empty string arrays");
+            }
+            return names;
+        }
+        if (single) {
+            throw new IllegalArgumentException("dropIndex only accepts a string index name or JSON document");
+        }
+        throw new IllegalArgumentException("dropIndexes only accepts a string index name, JSON document, or string array");
+    }
+
+    private static List<IndexInfo> listIndexInfos(MongoClient c, String database, String collection) {
+        List<IndexInfo> result = new ArrayList<>();
+        for (Document index : c.getDatabase(database).getCollection(collection).listIndexes()) {
+            result.add(indexInfoFromDocument(index));
+        }
+        return result;
+    }
+
+    private static List<String> diffDroppedIndexNames(List<IndexInfo> before, List<IndexInfo> after) {
+        Set<String> remaining = new HashSet<>();
+        for (IndexInfo index : after) {
+            remaining.add(index.getName());
+        }
+        List<String> droppedNames = new ArrayList<>();
+        for (IndexInfo index : before) {
+            if (!remaining.contains(index.getName())) {
+                droppedNames.add(index.getName());
+            }
+        }
+        return droppedNames;
+    }
+
+    private static Object insertDocument(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        String collection = params.get("collection").getAsString();
+        String docJson = params.get("doc_json").getAsString();
+
+        Document doc = Document.parse(docJson);
+        c.getDatabase(database).getCollection(collection).insertOne(doc);
+        Object insertedId = convertValue(doc.get("_id"));
+        return Collections.singletonMap("inserted_id", insertedId);
+    }
+
+    private static Object parseId(String id) {
+        try {
+            return new ObjectId(id);
+        } catch (Exception e) {
+            return id;
+        }
+    }
+
+    private static Object updateDocument(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        String collection = params.get("collection").getAsString();
+        String id = params.get("id").getAsString();
+        String docJson = params.get("doc_json").getAsString();
+
+        var col = c.getDatabase(database).getCollection(collection);
+        Document newDoc = documentForWrite(docJson);
+        var filter = new Document("_id", parseId(id));
+        var result = isUpdateOperatorDocument(newDoc)
+            ? col.updateOne(filter, newDoc)
+            : col.replaceOne(filter, replacementDocument(newDoc));
+        return Collections.singletonMap("modified_count", result.getModifiedCount());
+    }
+
+    private static Object updateDocuments(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        String collection = params.get("collection").getAsString();
+        String filterJson = params.get("filter_json").getAsString();
+        String updateJson = params.get("update_json").getAsString();
+        boolean many = params.get("many").getAsBoolean();
+        String optionsJson = params.has("options_json") && !params.get("options_json").isJsonNull()
+            ? params.get("options_json").getAsString()
+            : null;
+
+        var col = c.getDatabase(database).getCollection(collection);
+        Document filter = documentForWrite(filterJson);
+        Document update = documentForWrite(updateJson);
+        requireBulkUpdateOperatorDocument(update);
+        UpdateOptions options = updateOptionsForWrite(optionsJson);
+        var result = many ? col.updateMany(filter, update, options) : col.updateOne(filter, update, options);
+        return Collections.singletonMap("modified_count", result.getModifiedCount());
+    }
+
+    static UpdateOptions updateOptionsForWrite(String optionsJson) {
+        UpdateOptions result = new UpdateOptions();
+        if (optionsJson == null || optionsJson.trim().isEmpty()) {
+            return result;
+        }
+        Document options = Document.parse(optionsJson);
+        for (String key : options.keySet()) {
+            if (!"arrayFilters".equals(key)) {
+                throw new IllegalArgumentException("Unsupported update option: " + key);
+            }
+        }
+        Object rawFilters = options.get("arrayFilters");
+        if (rawFilters == null) {
+            return result;
+        }
+        if (!(rawFilters instanceof List<?>)) {
+            throw new IllegalArgumentException("arrayFilters must be an array");
+        }
+        List<Document> filters = new ArrayList<>();
+        for (Object filter : (List<?>) rawFilters) {
+            if (!(filter instanceof Document)) {
+                throw new IllegalArgumentException("Each arrayFilters entry must be an object");
+            }
+            filters.add((Document) filter);
+        }
+        return result.arrayFilters(filters);
+    }
+
+    static Document documentForWrite(String docJson) {
+        Document doc = Document.parse(docJson);
+        convertMongoShellDates(doc);
+        return doc;
+    }
+
+    private static Document replacementDocument(Document doc) {
+        Document replacement = new Document(doc);
+        replacement.remove("_id");
+        return replacement;
+    }
+
+    static boolean isUpdateOperatorDocument(Document doc) {
+        if (doc.isEmpty()) {
+            return false;
+        }
+        for (String key : doc.keySet()) {
+            if (!key.startsWith("$")) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    static void requireBulkUpdateOperatorDocument(Document doc) {
+        if (!isUpdateOperatorDocument(doc)) {
+            // updateOne/updateMany are shell-style bulk updates here; replacements stay on the
+            // single-document save path so a broad filter cannot replace many documents by accident.
+            throw new IllegalArgumentException("Bulk update requires update operators such as $set");
+        }
+    }
+
+    private static Object deleteDocument(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        String collection = params.get("collection").getAsString();
+        String id = params.get("id").getAsString();
+
+        var col = c.getDatabase(database).getCollection(collection);
+        var result = col.deleteOne(new Document("_id", parseId(id)));
+        return Collections.singletonMap("deleted_count", result.getDeletedCount());
+    }
+
+    private static Object deleteDocuments(JsonObject params) {
+        MongoClient c = requireClient();
+        String database = params.get("database").getAsString();
+        String collection = params.get("collection").getAsString();
+        String filterJson = params.get("filter_json").getAsString();
+        boolean many = params.get("many").getAsBoolean();
+
+        var col = c.getDatabase(database).getCollection(collection);
+        Document filter = documentForWrite(filterJson);
+        // Shell deleteOne/deleteMany use a filter document, unlike the row-view
+        // delete path which always targets a single _id.
+        var result = many ? col.deleteMany(filter) : col.deleteOne(filter);
+        return Collections.singletonMap("deleted_count", result.getDeletedCount());
+    }
+
+    private static Map<String, Object> bsonToJson(Document doc) {
+        Map<String, Object> result = new LinkedHashMap<>();
+        for (Map.Entry<String, Object> entry : doc.entrySet()) {
+            result.put(entry.getKey(), convertValue(entry.getValue()));
+        }
+        return result;
+    }
+
+    static JsonObject bsonToExtendedJson(Document doc) {
+        return JsonParser.parseString(doc.toJson(EXTENDED_JSON_SETTINGS)).getAsJsonObject();
+    }
+
+    static Object convertValue(Object value) {
+        if (value == null) {
+            return null;
+        }
+        if (value instanceof ObjectId objectId) {
+            return objectId.toHexString();
+        }
+        if (value instanceof Document document) {
+            return bsonToJson(document);
+        }
+        if (value instanceof List<?> values) {
+            List<Object> result = new ArrayList<>();
+            for (Object item : values) {
+                result.add(convertValue(item));
+            }
+            return result;
+        }
+        if (value instanceof java.util.Date date) {
+            Instant instant = Instant.ofEpochMilli(date.getTime());
+            return "ISODate(\"" + DATE_FORMAT.format(instant) + "\")";
+        }
+        if (value instanceof Long longValue) {
+            return longValue < -JS_MAX_SAFE_INTEGER || longValue > JS_MAX_SAFE_INTEGER ? longValue.toString() : longValue;
+        }
+        if (value instanceof Boolean || value instanceof Integer || value instanceof Double || value instanceof String) {
+            return value;
+        }
+        return value.toString();
+    }
+
+    @SuppressWarnings("unchecked")
+    private static Object convertMongoShellDates(Object value) {
+        if (value instanceof Document document) {
+            for (String key : new ArrayList<>(document.keySet())) {
+                document.put(key, convertMongoShellDates(document.get(key)));
+            }
+            return document;
+        }
+        if (value instanceof List<?> values) {
+            List<Object> converted = (List<Object>) values;
+            for (int i = 0; i < converted.size(); i++) {
+                converted.set(i, convertMongoShellDates(converted.get(i)));
+            }
+            return converted;
+        }
+        if (value instanceof String text) {
+            Date date = parseMongoShellDate(text);
+            if (date == null) {
+                date = parseLegacyDateDisplay(text);
+            }
+            return date == null ? value : date;
+        }
+        return value;
+    }
+
+    static Date parseMongoShellDate(String value) {
+        String trimmed = value.trim();
+        String inner = null;
+        if (trimmed.startsWith("ISODate(") && trimmed.endsWith(")")) {
+            inner = trimmed.substring("ISODate(".length(), trimmed.length() - 1).trim();
+        } else if (trimmed.startsWith("new Date(") && trimmed.endsWith(")")) {
+            inner = trimmed.substring("new Date(".length(), trimmed.length() - 1).trim();
+        }
+        if (inner == null || inner.length() < 2) {
+            return null;
+        }
+        char quote = inner.charAt(0);
+        if ((quote != '"' && quote != '\'') || inner.charAt(inner.length() - 1) != quote) {
+            return null;
+        }
+        try {
+            Instant instant = Instant.parse(inner.substring(1, inner.length() - 1));
+            return Date.from(instant);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    static Date parseLegacyDateDisplay(String value) {
+        String trimmed = value.trim();
+        if (!trimmed.matches("\\d{4}-\\d{2}-\\d{2}[ T]\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,3})?")) {
+            return null;
+        }
+        String normalized = trimmed.replace(' ', 'T');
+        int dot = normalized.indexOf('.');
+        if (dot < 0) {
+            normalized = normalized + ".000";
+        } else {
+            int millisStart = dot + 1;
+            int millisEnd = normalized.length();
+            normalized = normalized.substring(0, millisStart)
+                + String.format("%-3s", normalized.substring(millisStart, millisEnd)).replace(' ', '0');
+        }
+        try {
+            return Date.from(Instant.parse(normalized + "Z"));
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    private static Object dispatch(String method, JsonObject params) {
+        return switch (method) {
+            case AgentProtocol.METHOD_HANDSHAKE -> AgentProtocol.handshakeResult();
+            case AgentProtocol.METHOD_CONNECT -> connect(params);
+            case AgentProtocol.MONGO_METHOD_LIST_DATABASES -> listDatabases();
+            case AgentProtocol.MONGO_METHOD_LIST_COLLECTIONS -> listCollections(params);
+            case AgentProtocol.METHOD_LIST_INDEXES -> listIndexes(params);
+            case AgentProtocol.MONGO_METHOD_FIND_DOCUMENTS -> findDocuments(params);
+            case AgentProtocol.MONGO_METHOD_FIND_DOCUMENTS_EXTENDED_JSON -> findDocumentsExtendedJson(params);
+            case AgentProtocol.MONGO_METHOD_SERVER_VERSION -> serverVersion(params);
+            case AgentProtocol.MONGO_METHOD_CREATE_INDEX -> createIndex(params);
+            case AgentProtocol.MONGO_METHOD_DROP_INDEXES -> dropIndexes(params);
+            case AgentProtocol.MONGO_METHOD_DROP_COLLECTION -> dropCollection(params);
+            case AgentProtocol.MONGO_METHOD_INSERT_DOCUMENT -> insertDocument(params);
+            case AgentProtocol.MONGO_METHOD_UPDATE_DOCUMENT -> updateDocument(params);
+            case AgentProtocol.MONGO_METHOD_UPDATE_DOCUMENTS -> updateDocuments(params);
+            case AgentProtocol.MONGO_METHOD_DELETE_DOCUMENT -> deleteDocument(params);
+            case AgentProtocol.MONGO_METHOD_DELETE_DOCUMENTS -> deleteDocuments(params);
+            case AgentProtocol.METHOD_DISCONNECT, AgentProtocol.METHOD_SHUTDOWN -> {
+                if (client != null) {
+                    client.close();
+                    client = null;
+                }
+                if (AgentProtocol.METHOD_SHUTDOWN.equals(method)) {
+                    System.exit(0);
+                }
+                yield Collections.singletonMap("ok", true);
+            }
+            default -> throw new IllegalArgumentException("Unknown method: " + method);
+        };
+    }
+
+    private static MongoClient requireClient() {
+        if (client == null) {
+            throw new IllegalStateException("Not connected");
+        }
+        return client;
+    }
+
+    private static String coalesce(String value) {
+        return value == null ? "" : value;
+    }
+
+    private static String defaultString(String value, String fallback) {
+        return value == null ? fallback : value;
+    }
+
+    static String handleRequest(String line) {
+        JsonObject req = JsonParser.parseString(line).getAsJsonObject();
+        JsonElement id = req.get("id");
+        String method = req.get("method").getAsString();
+        JsonObject params = req.has("params") && req.get("params").isJsonObject()
+            ? req.getAsJsonObject("params")
+            : new JsonObject();
+
+        JsonObject response = new JsonObject();
+        response.addProperty("jsonrpc", "2.0");
+        response.add("id", id);
+
+        try {
+            Object result = dispatch(method, params);
+            response.add("result", GSON.toJsonTree(result));
+        } catch (Exception e) {
+            JsonObject error = new JsonObject();
+            error.addProperty("code", -1);
+            error.addProperty("message", e.getMessage() == null ? "Unknown error" : e.getMessage());
+            response.add("error", error);
+        }
+
+        return GSON.toJson(response);
+    }
+
+    public static void main(String[] args) throws Exception {
+        System.out.println("{\"ready\":true}");
+        System.out.flush();
+
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        while (true) {
+            String line = reader.readLine();
+            if (line == null) {
+                break;
+            }
+
+            System.out.println(handleRequest(line));
+            System.out.flush();
+        }
+    }
+}
diff --git a/agents/drivers/mongodb/src/test/java/com/dbx/agent/mongodb/MongoAgentTest.java b/agents/drivers/mongodb/src/test/java/com/dbx/agent/mongodb/MongoAgentTest.java
new file mode 100644
index 0000000..a90406c
--- /dev/null
+++ b/agents/drivers/mongodb/src/test/java/com/dbx/agent/mongodb/MongoAgentTest.java
@@ -0,0 +1,517 @@
+package com.dbx.agent.mongodb;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.dbx.agent.AgentProtocol;
+import com.dbx.agent.IndexInfo;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.mongodb.MongoClientSettings;
+import com.mongodb.client.model.UpdateOptions;
+import java.io.FileInputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.KeyStore;
+import java.security.PrivateKey;
+import java.util.Base64;
+import java.util.Date;
+import org.bson.Document;
+import org.bson.types.ObjectId;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+class MongoAgentTest {
+    @TempDir
+    static Path tempDir;
+
+    private static Path caPemPath;
+    private static Path clientPemPath;
+    private static Path clientKeyPath;
+
+    @BeforeAll
+    static void setUpCerts() throws Exception {
+        Path keystore = tempDir.resolve("keystore.jks");
+        caPemPath = tempDir.resolve("ca.pem");
+        clientPemPath = tempDir.resolve("client.pem");
+        clientKeyPath = tempDir.resolve("client-key.pem");
+
+        // Generate a key pair in a JKS keystore using keytool
+        ProcessBuilder pb = new ProcessBuilder(
+            "keytool", "-genkeypair", "-alias", "test", "-keyalg", "RSA", "-keysize", "2048",
+            "-keystore", keystore.toString(), "-storepass", "pass123", "-keypass", "pass123",
+            "-dname", "CN=Test TLS Cert", "-validity", "365"
+        );
+        pb.inheritIO();
+        int rc = pb.start().waitFor();
+        if (rc != 0) {
+            throw new RuntimeException("keytool -genkeypair failed with exit code " + rc);
+        }
+
+        // Export the certificate as PEM (for ca_cert_path / client_cert_path)
+        for (Path pem : new Path[] {caPemPath, clientPemPath}) {
+            ProcessBuilder exportPb = new ProcessBuilder(
+                "keytool", "-exportcert", "-alias", "test",
+                "-keystore", keystore.toString(), "-storepass", "pass123", "-rfc"
+            );
+            exportPb.redirectOutput(pem.toFile());
+            exportPb.redirectError(ProcessBuilder.Redirect.INHERIT);
+            int exportRc = exportPb.start().waitFor();
+            if (exportRc != 0) {
+                throw new RuntimeException("keytool -exportcert failed with exit code " + exportRc);
+            }
+        }
+
+        // Extract the private key as PKCS#8 PEM
+        KeyStore ks = KeyStore.getInstance("JKS");
+        try (FileInputStream fis = new FileInputStream(keystore.toFile())) {
+            ks.load(fis, "pass123".toCharArray());
+        }
+        PrivateKey pk = (PrivateKey) ks.getKey("test", "pass123".toCharArray());
+        String pkcs8Pem = "-----BEGIN PRIVATE KEY-----\n"
+            + Base64.getEncoder().encodeToString(pk.getEncoded())
+            + "\n-----END PRIVATE KEY-----\n";
+        Files.writeString(clientKeyPath, pkcs8Pem);
+    }
+
+    // ─── existing tests ───
+
+    @Test
+    void exposesProtocolHandshakeOverJsonRpc() {
+        String response = MongoAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":7,\"method\":\"handshake\","
+                + "\"params\":{\"appVersion\":\"0.5.13\",\"supportedProtocolVersions\":[1]}}");
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        JsonObject result = json.getAsJsonObject("result");
+        assertEquals("2.0", json.get("jsonrpc").getAsString());
+        assertEquals(7, json.get("id").getAsInt());
+        assertEquals(AgentProtocol.PROTOCOL_VERSION, result.get("protocolVersion").getAsInt());
+        assertEquals(AgentProtocol.PROTOCOL_VERSION, result.get("agentProtocolVersion").getAsInt());
+        assertTrue(containsCapability(result.getAsJsonArray("capabilities"), AgentProtocol.CAPABILITY_CONNECT));
+        assertTrue(containsCapability(result.getAsJsonArray("capabilities"), AgentProtocol.CAPABILITY_QUERY));
+        assertTrue(containsCapability(result.getAsJsonArray("capabilities"), AgentProtocol.CAPABILITY_METADATA));
+    }
+
+    @Test
+    void listIndexesMethodIsRecognizedOverJsonRpc() {
+        String response = MongoAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":8,\"method\":\"list_indexes\","
+                + "\"params\":{\"database\":\"app\",\"schema\":\"\",\"table\":\"orders\"}}");
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        assertEquals(8, json.get("id").getAsInt());
+        assertEquals("Not connected", json.getAsJsonObject("error").get("message").getAsString());
+        assertFalse(json.getAsJsonObject("error").get("message").getAsString().contains("Unknown method"));
+    }
+
+    @Test
+    void parsesOptionalDocumentParameters() {
+        JsonObject params = new JsonObject();
+        params.addProperty("projection", "{\"title\":1,\"_id\":0}");
+        params.addProperty("filter", "");
+
+        Document projection = MongoAgent.documentOrNull(params, "projection");
+
+        assertNotNull(projection);
+        assertEquals(1, projection.get("title"));
+        assertEquals(0, projection.get("_id"));
+        assertEquals(null, MongoAgent.documentOrNull(params, "filter"));
+        assertEquals(null, MongoAgent.documentOrNull(params, "sort"));
+    }
+
+    @Test
+    void documentParametersParseExtendedJsonLongFilters() {
+        JsonObject params = new JsonObject();
+        params.addProperty("filter", "{\"processInfoId\":{\"$numberLong\":\"2048938405781032962\"},\"snowflake\":{\"$numberLong\":\"9007199254740993\"}}");
+
+        Document filter = MongoAgent.documentOrNull(params, "filter");
+
+        assertNotNull(filter);
+        assertEquals(2_048_938_405_781_032_962L, filter.get("processInfoId"));
+        assertEquals(9_007_199_254_740_993L, filter.get("snowflake"));
+    }
+
+    @Test
+    void serverVersionMethodIsRecognizedOverJsonRpc() {
+        String response = MongoAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":9,\"method\":\"server_version\","
+                + "\"params\":{\"database\":\"admin\"}}");
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        assertEquals(9, json.get("id").getAsInt());
+        assertEquals("Not connected", json.getAsJsonObject("error").get("message").getAsString());
+        assertFalse(json.getAsJsonObject("error").get("message").getAsString().contains("Unknown method"));
+    }
+
+    @Test
+    void createIndexMethodIsRecognizedOverJsonRpc() {
+        String response = MongoAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":12,\"method\":\"create_index\","
+                + "\"params\":{\"database\":\"app\",\"collection\":\"orders\","
+                + "\"keys_json\":\"{\\\"email\\\":1}\",\"options_json\":\"{\\\"name\\\":\\\"email_1\\\",\\\"background\\\":true}\"}}");
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        assertEquals(12, json.get("id").getAsInt());
+        assertEquals("Not connected", json.getAsJsonObject("error").get("message").getAsString());
+        assertFalse(json.getAsJsonObject("error").get("message").getAsString().contains("Unknown method"));
+        assertTrue(AgentProtocol.MONGO_LEGACY_METHODS.contains(AgentProtocol.MONGO_METHOD_CREATE_INDEX));
+    }
+
+    @Test
+    void dropIndexesMethodIsRecognizedOverJsonRpc() {
+        String response = MongoAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":13,\"method\":\"drop_indexes\","
+                + "\"params\":{\"database\":\"app\",\"collection\":\"orders\","
+                + "\"indexes_json\":\"\\\"email_1\\\"\",\"single\":true}}");
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        assertEquals(13, json.get("id").getAsInt());
+        assertEquals("Not connected", json.getAsJsonObject("error").get("message").getAsString());
+        assertFalse(json.getAsJsonObject("error").get("message").getAsString().contains("Unknown method"));
+        assertTrue(AgentProtocol.MONGO_LEGACY_METHODS.contains(AgentProtocol.MONGO_METHOD_DROP_INDEXES));
+    }
+
+    @Test
+    void dropCollectionMethodIsRecognizedOverJsonRpc() {
+        String response = MongoAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":14,\"method\":\"drop_collection\","
+                + "\"params\":{\"database\":\"app\",\"collection\":\"orders\"}}");
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        assertEquals(14, json.get("id").getAsInt());
+        assertEquals("Not connected", json.getAsJsonObject("error").get("message").getAsString());
+        assertFalse(json.getAsJsonObject("error").get("message").getAsString().contains("Unknown method"));
+        assertTrue(AgentProtocol.MONGO_LEGACY_METHODS.contains(AgentProtocol.MONGO_METHOD_DROP_COLLECTION));
+    }
+
+    @Test
+    void updateDocumentsMethodIsRecognizedOverJsonRpc() {
+        String response = MongoAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":10,\"method\":\"update_documents\","
+                + "\"params\":{\"database\":\"app\",\"collection\":\"orders\",\"filter_json\":\"{}\","
+                + "\"update_json\":\"{\\\"$set\\\":{\\\"data\\\":null}}\",\"many\":true}}");
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        assertEquals(10, json.get("id").getAsInt());
+        assertEquals("Not connected", json.getAsJsonObject("error").get("message").getAsString());
+        assertFalse(json.getAsJsonObject("error").get("message").getAsString().contains("Unknown method"));
+    }
+
+    @Test
+    void parsesArrayFiltersUpdateOption() {
+        UpdateOptions options = MongoAgent.updateOptionsForWrite(
+            "{\"arrayFilters\":[{\"item.id\":322678}]}"
+        );
+
+        assertEquals(1, options.getArrayFilters().size());
+        assertEquals(322678, ((Document) options.getArrayFilters().get(0)).getInteger("item.id"));
+    }
+
+    @Test
+    void rejectsUnsupportedUpdateOptions() {
+        IllegalArgumentException error = assertThrows(
+            IllegalArgumentException.class,
+            () -> MongoAgent.updateOptionsForWrite("{\"upsert\":true}")
+        );
+        assertEquals("Unsupported update option: upsert", error.getMessage());
+    }
+
+    @Test
+    void deleteDocumentsMethodIsRecognizedOverJsonRpc() {
+        String response = MongoAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":11,\"method\":\"delete_documents\","
+                + "\"params\":{\"database\":\"app\",\"collection\":\"orders\","
+                + "\"filter_json\":\"{\\\"status\\\":\\\"draft\\\"}\",\"many\":true}}");
+
+        JsonObject json = JsonParser.parseString(response).getAsJsonObject();
+        assertEquals(11, json.get("id").getAsInt());
+        assertEquals("Not connected", json.getAsJsonObject("error").get("message").getAsString());
+        assertFalse(json.getAsJsonObject("error").get("message").getAsString().contains("Unknown method"));
+        assertTrue(AgentProtocol.MONGO_LEGACY_METHODS.contains(AgentProtocol.MONGO_METHOD_DELETE_DOCUMENTS));
+    }
+
+    @Test
+    void extractsServerVersionFromBuildInfo() {
+        assertEquals("4.4.29", MongoAgent.serverVersionFromBuildInfo(new Document("version", "4.4.29")));
+        assertThrows(IllegalStateException.class, () -> MongoAgent.serverVersionFromBuildInfo(new Document("ok", 1)));
+    }
+
+    @Test
+    void convertsMongoIndexDocumentToIndexInfo() {
+        Document index = new Document("name", "idx_user_status")
+            .append("key", new Document("user_id", 1).append("status", -1))
+            .append("unique", true)
+            .append("partialFilterExpression", new Document("deleted", false));
+
+        IndexInfo info = MongoAgent.indexInfoFromDocument(index);
+
+        assertEquals("idx_user_status", info.getName());
+        assertEquals(java.util.List.of("user_id", "status"), info.getColumns());
+        assertEquals(true, info.getIs_unique());
+        assertEquals(false, info.getIs_primary());
+        assertEquals("user_id: 1, status: -1", info.getIndex_type());
+        assertTrue(info.getFilter().contains("\"deleted\""));
+    }
+
+    @Test
+    void usesAuthSourceFromUrlParamsAsAuthenticationDatabase() {
+        JsonObject connection = new JsonObject();
+        connection.addProperty("database", "gray_lite_twin_fat");
+        connection.addProperty("url_params", "authSource=admin&authMechanism=SCRAM-SHA-1");
+
+        assertEquals("admin", MongoAgent.authenticationDatabase(connection));
+    }
+
+    @Test
+    void fallsBackToAdminWhenAuthSourceIsMissing() {
+        JsonObject connection = new JsonObject();
+        connection.addProperty("database", "gray_lite_twin_fat");
+
+        assertEquals("admin", MongoAgent.authenticationDatabase(connection));
+    }
+
+    // ─── TLS: configureBuilder JSON parsing ───
+
+    @Test
+    void sslTrueFromConnectionObject() {
+        JsonObject connection = minimalConnection();
+        connection.addProperty("ssl", true);
+
+        MongoClientSettings.Builder builder = MongoAgent.configureBuilder(connection);
+
+        assertNotNull(builder);
+    }
+
+    @Test
+    void sslFalseByDefault() {
+        JsonObject connection = minimalConnection();
+        // ssl is not set — should default to false
+
+        MongoClientSettings.Builder builder = MongoAgent.configureBuilder(connection);
+
+        assertNotNull(builder);
+    }
+
+    @Test
+    void sslTrueFromTopLevelParams() {
+        JsonObject connObj = minimalConnection();
+        connObj.addProperty("ssl", true);
+        JsonObject params = new JsonObject();
+        params.add("connection", connObj);
+
+        // connect() unwraps the connection sub-object; verify configureBuilder reads ssl from it
+        JsonObject extracted = params.has("connection") && params.get("connection").isJsonObject()
+            ? params.getAsJsonObject("connection")
+            : params;
+        assertEquals(true, extracted.get("ssl").getAsBoolean());
+    }
+
+    @Test
+    void readsCaCertPathFromConnection() {
+        JsonObject connection = minimalConnection();
+        connection.addProperty("ssl", true);
+        connection.addProperty("ca_cert_path", caPemPath.toString());
+
+        MongoClientSettings.Builder builder = MongoAgent.configureBuilder(connection);
+
+        assertNotNull(builder);
+    }
+
+    @Test
+    void readsClientCertAndKeyPathsFromConnection() {
+        JsonObject connection = minimalConnection();
+        connection.addProperty("ssl", true);
+        connection.addProperty("client_cert_path", clientPemPath.toString());
+        connection.addProperty("client_key_path", clientKeyPath.toString());
+
+        MongoClientSettings.Builder builder = MongoAgent.configureBuilder(connection);
+
+        assertNotNull(builder);
+    }
+
+    @Test
+    void certPathAndKeyPathFallbackNames() {
+        JsonObject connection = minimalConnection();
+        connection.addProperty("ssl", true);
+        connection.addProperty("cert_path", clientPemPath.toString());
+        connection.addProperty("key_path", clientKeyPath.toString());
+
+        // Should not throw — cert_path/key_path are fallback names for client_cert_path/client_key_path
+        MongoClientSettings.Builder builder = MongoAgent.configureBuilder(connection);
+
+        assertNotNull(builder);
+    }
+
+    @Test
+    void rejectsMismatchedClientCertAndKey() {
+        JsonObject connection = minimalConnection();
+        connection.addProperty("ssl", true);
+        connection.addProperty("client_cert_path", clientPemPath.toString());
+        // client_key_path is missing
+
+        assertThrows(IllegalArgumentException.class, () -> MongoAgent.configureBuilder(connection));
+    }
+
+    // ─── TLS: SSLContext creation ───
+
+    @Test
+    void createsSslContextWithCaCert() throws Exception {
+        var ctx = MongoAgent.createTlsSslContext(caPemPath.toString(), null, null);
+
+        assertNotNull(ctx);
+    }
+
+    @Test
+    void createsSslContextWithClientCertAndKey() throws Exception {
+        var ctx = MongoAgent.createTlsSslContext(null, clientPemPath.toString(), clientKeyPath.toString());
+
+        assertNotNull(ctx);
+    }
+
+    @Test
+    void createsSslContextWithAllCertPaths() throws Exception {
+        var ctx = MongoAgent.createTlsSslContext(
+            caPemPath.toString(), clientPemPath.toString(), clientKeyPath.toString());
+
+        assertNotNull(ctx);
+    }
+
+    // ─── TLS: trust manager loading ───
+
+    @Test
+    void loadsTrustManagersFromPemFile() throws Exception {
+        var trustManagers = MongoAgent.loadTrustManagersFromPem(caPemPath.toString());
+
+        assertNotNull(trustManagers);
+        assertTrue(trustManagers.length > 0);
+    }
+
+    // ─── TLS: key manager loading ───
+
+    @Test
+    void loadsKeyManagersFromPemFiles() throws Exception {
+        var keyManagers = MongoAgent.loadKeyManagersFromPem(
+            clientPemPath.toString(), clientKeyPath.toString());
+
+        assertNotNull(keyManagers);
+        assertTrue(keyManagers.length > 0);
+    }
+
+    // ─── TLS: private key format support ───
+
+    @Test
+    void loadsPkcs8PrivateKeyFromPem() throws Exception {
+        var key = MongoAgent.loadPrivateKeyFromPem(clientKeyPath.toString());
+
+        assertNotNull(key);
+        assertEquals("RSA", key.getAlgorithm());
+    }
+
+    // ─── utility ───
+
+    @Test
+    void firstNonBlankReturnsFirstNonBlankValue() {
+        assertEquals("b", MongoAgent.firstNonBlank(null, "", "b", "c"));
+        assertEquals("a", MongoAgent.firstNonBlank("a", "b"));
+    }
+
+    @Test
+    void firstNonBlankReturnsNullWhenAllBlank() {
+        assertEquals(null, MongoAgent.firstNonBlank(null, "", "  "));
+    }
+
+    @Test
+    void convertValuePreservesUnsafeLongForJsonClients() {
+        assertEquals("2326645729978441729", MongoAgent.convertValue(2_326_645_729_978_441_729L));
+        assertEquals("-2326645729978441729", MongoAgent.convertValue(-2_326_645_729_978_441_729L));
+    }
+
+    @Test
+    void convertValueKeepsSafeLongAsNumber() {
+        assertEquals(42L, MongoAgent.convertValue(42L));
+    }
+
+    @Test
+    void convertValueFormatsDatesAsMongoShellIsoDate() {
+        assertEquals("ISODate(\"2026-06-10T13:59:31.287Z\")", MongoAgent.convertValue(Date.from(java.time.Instant.parse("2026-06-10T13:59:31.287Z"))));
+    }
+
+    @Test
+    void convertValueKeepsObjectIdAsStringByDefault() {
+        assertEquals(
+            "507f1f77bcf86cd799439011",
+            MongoAgent.convertValue(new ObjectId("507f1f77bcf86cd799439011"))
+        );
+    }
+
+    @Test
+    void bsonToExtendedJsonUsesMongoExtendedJson() {
+        Document doc = new Document("_id", new ObjectId("507f1f77bcf86cd799439011"))
+            .append("created_at", Date.from(java.time.Instant.parse("2026-06-10T13:59:31.287Z")));
+
+        assertEquals(
+            "{\"_id\":{\"$oid\":\"507f1f77bcf86cd799439011\"},\"created_at\":{\"$date\":\"2026-06-10T13:59:31.287Z\"}}",
+            new com.google.gson.Gson().toJson(MongoAgent.bsonToExtendedJson(doc))
+        );
+    }
+
+    @Test
+    void documentForWriteParsesMongoShellIsoDateStrings() {
+        Document doc = MongoAgent.documentForWrite("{\"$set\":{\"CreateDate\":\"ISODate(\\\"2026-06-10T13:59:31.287Z\\\")\"}}");
+
+        assertTrue(MongoAgent.isUpdateOperatorDocument(doc));
+        Document set = (Document) doc.get("$set");
+        assertTrue(set.get("CreateDate") instanceof Date);
+    }
+
+    @Test
+    void documentForWriteParsesNestedMongoShellIsoDateStrings() {
+        Document doc = MongoAgent.documentForWrite("{\"items\":[{\"created\":\"new Date(\\\"2026-06-10T13:59:31.287Z\\\")\"}]}");
+
+        assertTrue(((Document) ((java.util.List<?>) doc.get("items")).get(0)).get("created") instanceof Date);
+    }
+
+    @Test
+    void documentForWriteParsesLegacyDateDisplayStrings() {
+        Document doc = MongoAgent.documentForWrite("{\"$set\":{\"CreateDate\":\"2025-08-14 02:25:43.718\"}}");
+
+        Document set = (Document) doc.get("$set");
+        assertTrue(set.get("CreateDate") instanceof Date);
+        assertEquals(1_755_138_343_718L, ((Date) set.get("CreateDate")).getTime());
+    }
+
+    @Test
+    void bulkUpdateRequiresOperatorDocument() {
+        Document update = MongoAgent.documentForWrite("{\"$set\":{\"data\":null}}");
+        MongoAgent.requireBulkUpdateOperatorDocument(update);
+
+        assertThrows(
+            IllegalArgumentException.class,
+            () -> MongoAgent.requireBulkUpdateOperatorDocument(MongoAgent.documentForWrite("{\"data\":null}"))
+        );
+    }
+
+    // ─── helpers ───
+
+    private static JsonObject minimalConnection() {
+        JsonObject conn = new JsonObject();
+        conn.addProperty("host", "127.0.0.1");
+        conn.addProperty("port", 27017);
+        return conn;
+    }
+
+    private static boolean containsCapability(JsonArray capabilities, String expected) {
+        for (int i = 0; i < capabilities.size(); i++) {
+            if (expected.equals(capabilities.get(i).getAsString())) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/agents/drivers/neo4j/build.gradle b/agents/drivers/neo4j/build.gradle
new file mode 100644
index 0000000..232f595
--- /dev/null
+++ b/agents/drivers/neo4j/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'org.neo4j:neo4j-jdbc-full-bundle:6.10.0'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Neo4j', 'Main-Class': 'com.dbx.agent.neo4j.Neo4jAgent')
+    }
+}
diff --git a/agents/drivers/neo4j/src/main/java/com/dbx/agent/neo4j/Neo4jAgent.java b/agents/drivers/neo4j/src/main/java/com/dbx/agent/neo4j/Neo4jAgent.java
new file mode 100644
index 0000000..9447b38
--- /dev/null
+++ b/agents/drivers/neo4j/src/main/java/com/dbx/agent/neo4j/Neo4jAgent.java
@@ -0,0 +1,350 @@
+package com.dbx.agent.neo4j;
+
+import com.dbx.agent.BaseDatabaseAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcExecutor;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TransactionExecutor;
+import com.dbx.agent.TriggerInfo;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+
+public class Neo4jAgent extends BaseDatabaseAgent {
+    private Connection connection;
+
+    @Override
+    public Connection getConnection() {
+        return connection;
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "";
+    }
+
+    @Override
+    public void connect(ConnectParams params) {
+        uncheckedVoid(() -> {
+            Class.forName("org.neo4j.jdbc.Neo4jDriver");
+            String url = buildNeo4jUrl(params);
+            connection = DriverManager.getConnection(url, params.getUsername(), params.getPassword());
+        });
+    }
+
+    @Override
+    public boolean testConnection(ConnectParams params) {
+        return unchecked(() -> {
+            Class.forName("org.neo4j.jdbc.Neo4jDriver");
+            String url = buildNeo4jUrl(params);
+            try (Connection conn = DriverManager.getConnection(url, params.getUsername(), params.getPassword())) {
+                return conn.isValid(5);
+            }
+        });
+    }
+
+    private static String buildNeo4jUrl(ConnectParams params) {
+        StringBuilder url = new StringBuilder();
+        url.append("jdbc:neo4j://").append(params.getHost()).append(":").append(params.getPort());
+        String database = params.getDatabase();
+        if (database != null && !database.trim().isEmpty()) {
+            url.append("?database=").append(database.trim());
+        }
+        return url.toString();
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            Connection conn = requireConnected();
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (Statement stmt = conn.createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW DATABASES")) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString("name")));
+                }
+            }
+            result.sort(Comparator.comparing(DatabaseInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            Connection conn = requireConnected();
+            // Try JDBC metadata first — the driver handles version compatibility.
+            List<TableInfo> result = new ArrayList<>();
+            DatabaseMetaData meta = conn.getMetaData();
+            try (ResultSet rs = meta.getTables(null, blankToNull(schema), "%", new String[]{"TABLE", "VIEW"})) {
+                while (rs.next()) {
+                    String name = rs.getString("TABLE_NAME");
+                    String type = rs.getString("TABLE_TYPE");
+                    String comment = getStringOrNull(rs, "REMARKS");
+                    if (name != null && !name.isEmpty()) {
+                        result.add(new TableInfo(name, type, comment));
+                    }
+                }
+            } catch (Exception ignored) {
+                // Fall through to Cypher fallback
+            }
+            // Fallback: use Cypher for drivers that don't implement getTables().
+            if (result.isEmpty()) {
+                try (Statement stmt = conn.createStatement();
+                     ResultSet rs = stmt.executeQuery("CALL db.labels()")) {
+                    while (rs.next()) {
+                        String label = getStringOrDefault(rs, "label", "");
+                        if (label.isEmpty()) {
+                            label = rs.getString(1);
+                        }
+                        if (label != null && !label.isEmpty()) {
+                            result.add(new TableInfo(label, "TABLE", null));
+                        }
+                    }
+                } catch (Exception ignored) {
+                    // Cypher fallback also failed
+                }
+            }
+            result.sort(Comparator.comparing(TableInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            Connection conn = requireConnected();
+            List<ColumnInfo> result = new ArrayList<>();
+            // Try JDBC metadata first.
+            DatabaseMetaData meta = conn.getMetaData();
+            Set<String> primaryKeys = new LinkedHashSet<>();
+            try (ResultSet rs = meta.getPrimaryKeys(null, blankToNull(schema), table)) {
+                while (rs.next()) {
+                    String pkColumn = rs.getString("COLUMN_NAME");
+                    if (pkColumn != null) {
+                        primaryKeys.add(pkColumn);
+                    }
+                }
+            } catch (Exception ignored) {
+                // Fall through
+            }
+            try (ResultSet rs = meta.getColumns(null, blankToNull(schema), table, "%")) {
+                while (rs.next()) {
+                    String name = rs.getString("COLUMN_NAME");
+                    if (name == null || name.isEmpty()) {
+                        continue;
+                    }
+                    String type = rs.getString("TYPE_NAME");
+                    if (type == null) {
+                        type = "Unknown";
+                    }
+                    boolean nullable = true;
+                    try {
+                        nullable = "YES".equals(rs.getString("IS_NULLABLE"));
+                    } catch (Exception ignored) {
+                        // keep default
+                    }
+                    String defaultValue = getStringOrNull(rs, "COLUMN_DEF");
+                    String comment = getStringOrNull(rs, "REMARKS");
+                    result.add(new ColumnInfo(
+                        name, type, nullable, defaultValue,
+                        primaryKeys.contains(name),
+                        comment, null, null, null, null
+                    ));
+                }
+            } catch (Exception ignored) {
+                // Fall through to Cypher fallback
+            }
+            // Fallback: use Cypher for drivers that don't implement getColumns().
+            if (result.isEmpty()) {
+                try (Statement stmt = conn.createStatement();
+                     ResultSet rs = stmt.executeQuery("CALL db.schema.nodeTypeProperties()")) {
+                    while (rs.next()) {
+                        String nodeLabels = rs.getString("nodeLabels");
+                        if (nodeLabels == null) {
+                            nodeLabels = "";
+                        }
+                        if (!nodeLabels.contains(table)) {
+                            continue;
+                        }
+                        String propertyName = rs.getString("propertyName");
+                        if (propertyName == null) {
+                            continue;
+                        }
+                        String propertyTypes = rs.getString("propertyTypes");
+                        if (propertyTypes == null) {
+                            propertyTypes = "Unknown";
+                        }
+                        boolean isNullable;
+                        try {
+                            isNullable = !rs.getBoolean("mandatory");
+                        } catch (Exception ignored) {
+                            isNullable = true;
+                        }
+                        result.add(new ColumnInfo(
+                            propertyName, propertyTypes, isNullable,
+                            null, false, null, null, null, null, null
+                        ));
+                    }
+                } catch (Exception ignored) {
+                    // Cypher fallback also failed
+                }
+            }
+            result.sort(Comparator.comparing(ColumnInfo::getName));
+            return result;
+        });
+    }
+
+    private static String blankToNull(String value) {
+        if (value == null) return null;
+        String trimmed = value.trim();
+        return trimmed.isEmpty() ? null : trimmed;
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return unchecked(() -> {
+            Connection conn = requireConnected();
+            List<IndexInfo> result = new ArrayList<>();
+            try (Statement stmt = conn.createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW INDEXES")) {
+                while (rs.next()) {
+                    String labelsOrTypes = getStringOrDefault(rs, "labelsOrTypes", "");
+                    if (!labelsOrTypes.contains(table)) {
+                        continue;
+                    }
+
+                    String properties = getStringOrDefault(rs, "properties", "");
+                    String uniqueness = getStringOrDefault(rs, "uniqueness", "");
+                    result.add(new IndexInfo(
+                        getStringOrDefault(rs, "name", ""),
+                        parseProperties(properties),
+                        "UNIQUE".equals(uniqueness.toUpperCase(Locale.ROOT)),
+                        false,
+                        null,
+                        getStringOrNull(rs, "type"),
+                        null,
+                        null
+                    ));
+                }
+            }
+            result.sort(Comparator.comparing(IndexInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public QueryResult executeTransaction(List<String> statements, String schema) {
+        return TransactionExecutor.executeStatements(requireConnected(), statements, schema, this::setSchemaSQL, (stmt, sql) -> {
+            stmt.execute(sql);
+            return Math.max(stmt.getUpdateCount(), 0);
+        });
+    }
+
+    public QueryResult executeQuery(String sql, String schema) {
+        return executeQuery(sql, schema, new ExecuteQueryOptions());
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        return JdbcExecutor.INSTANCE.execute(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options.getMaxRows(),
+            options.getFetchSize(),
+            options.getTimeoutSecs(),
+            this::stringResultValue
+        );
+    }
+
+    @Override
+    public void disconnect() {
+        uncheckedVoid(() -> {
+            if (connection != null) {
+                connection.close();
+            }
+            connection = null;
+        });
+    }
+
+    private Object stringResultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value = rs.getObject(index);
+            return rs.wasNull() ? null : value == null ? null : value.toString();
+        });
+    }
+
+    private static List<String> parseProperties(String properties) {
+        String trimmed = properties;
+        if (trimmed.startsWith("[") && trimmed.endsWith("]") && trimmed.length() >= 2) {
+            trimmed = trimmed.substring(1, trimmed.length() - 1);
+        }
+
+        List<String> result = new ArrayList<>();
+        for (String property : trimmed.split(",")) {
+            String value = property.trim();
+            if (value.startsWith("\"") && value.endsWith("\"") && value.length() >= 2) {
+                value = value.substring(1, value.length() - 1);
+            }
+            if (!value.isEmpty()) {
+                result.add(value);
+            }
+        }
+        return result;
+    }
+
+    private static String getStringOrDefault(ResultSet rs, String column, String defaultValue) {
+        try {
+            String value = rs.getString(column);
+            return value == null ? defaultValue : value;
+        } catch (Exception ignored) {
+            return defaultValue;
+        }
+    }
+
+    private static String getStringOrNull(ResultSet rs, String column) {
+        try {
+            return rs.getString(column);
+        } catch (Exception ignored) {
+            return null;
+        }
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new Neo4jAgent()).run();
+    }
+}
diff --git a/agents/drivers/neo4j/src/test/java/com/dbx/agent/neo4j/Neo4jAgentTest.java b/agents/drivers/neo4j/src/test/java/com/dbx/agent/neo4j/Neo4jAgentTest.java
new file mode 100644
index 0000000..0573ea3
--- /dev/null
+++ b/agents/drivers/neo4j/src/test/java/com/dbx/agent/neo4j/Neo4jAgentTest.java
@@ -0,0 +1,183 @@
+package com.dbx.agent.neo4j;
+
+import com.dbx.agent.QueryResult;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class Neo4jAgentTest {
+    @Test
+    void executesCypherWritesWithReturnThroughStatementExecute() throws Exception {
+        Neo4jAgent agent = new Neo4jAgent();
+        List<String> calls = new ArrayList<>();
+        setConnectionForTest(agent, fakeConnection(calls));
+
+        QueryResult result = agent.executeQuery("CREATE (n:Person {name: 'Ada'}) RETURN n", null);
+
+        Assertions.assertEquals(Collections.singletonList("n"), result.getColumns());
+        Assertions.assertEquals(
+            Collections.singletonList(Collections.singletonList("(:Person {name: Ada})")),
+            result.getRows()
+        );
+        Assertions.assertTrue(calls.contains("execute"));
+        Assertions.assertFalse(calls.contains("executeUpdate"));
+    }
+
+    @Test
+    void executesTransactionsThroughStatementExecute() throws Exception {
+        Neo4jAgent agent = new Neo4jAgent();
+        List<String> calls = new ArrayList<>();
+        setConnectionForTest(agent, fakeConnection(calls));
+
+        QueryResult result = agent.executeTransaction(
+            Arrays.asList(
+                "MATCH (n:Employee) WHERE elementId(n) = '4:abc:7' SET n.name = 'Grace'",
+                "CREATE (n:Employee {name: 'Linus'})"
+            ),
+            null
+        );
+
+        Assertions.assertEquals(0L, result.getAffected_rows());
+        Assertions.assertEquals(
+            Arrays.asList("setAutoCommit:false", "execute", "execute", "commit", "setAutoCommit:true"),
+            calls
+        );
+        Assertions.assertFalse(calls.contains("executeUpdate"));
+    }
+
+    private static void setConnectionForTest(Neo4jAgent agent, Connection connection) throws Exception {
+        java.lang.reflect.Field field = Neo4jAgent.class.getDeclaredField("connection");
+        field.setAccessible(true);
+        field.set(agent, connection);
+    }
+
+    private static Connection fakeConnection(List<String> calls) {
+        Statement statement = fakeStatement(calls);
+        return proxy(Connection.class, (unused, method, args) -> {
+            switch (method.getName()) {
+                case "createStatement":
+                    return statement;
+                case "setAutoCommit":
+                    calls.add("setAutoCommit:" + args[0]);
+                    return null;
+                case "getAutoCommit":
+                    return true;
+                case "commit":
+                    calls.add("commit");
+                    return null;
+                case "rollback":
+                    calls.add("rollback");
+                    return null;
+                case "close":
+                    return null;
+                case "isClosed":
+                    return false;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Statement fakeStatement(List<String> calls) {
+        ResultSet resultSet = fakeResultSet();
+        return proxy(Statement.class, (unused, method, args) -> {
+            switch (method.getName()) {
+                case "execute":
+                    calls.add("execute");
+                    return true;
+                case "executeUpdate":
+                    calls.add("executeUpdate");
+                    throw new SQLException("syntax error or access rule violation - invalid syntax");
+                case "executeQuery":
+                    calls.add("executeQuery");
+                    return resultSet;
+                case "getResultSet":
+                    return resultSet;
+                case "getUpdateCount":
+                    return 0;
+                case "close":
+                    return null;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static ResultSet fakeResultSet() {
+        int[] index = {-1};
+        ResultSetMetaData metadata = fakeMetadata();
+        return proxy(ResultSet.class, (unused, method, args) -> {
+            switch (method.getName()) {
+                case "next":
+                    index[0] += 1;
+                    return index[0] == 0;
+                case "getMetaData":
+                    return metadata;
+                case "getObject":
+                    return "(:Person {name: Ada})";
+                case "wasNull":
+                    return false;
+                case "close":
+                    return null;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static ResultSetMetaData fakeMetadata() {
+        return proxy(ResultSetMetaData.class, (unused, method, args) -> {
+            switch (method.getName()) {
+                case "getColumnCount":
+                    return 1;
+                case "getColumnLabel":
+                    return "n";
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T> T proxy(Class<T> type, InvocationHandler handler) {
+        return (T) Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, handler);
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (type == Boolean.TYPE) {
+            return false;
+        }
+        if (type == Byte.TYPE) {
+            return (byte) 0;
+        }
+        if (type == Short.TYPE) {
+            return (short) 0;
+        }
+        if (type == Integer.TYPE) {
+            return 0;
+        }
+        if (type == Long.TYPE) {
+            return 0L;
+        }
+        if (type == Float.TYPE) {
+            return 0F;
+        }
+        if (type == Double.TYPE) {
+            return 0.0D;
+        }
+        if (type == Character.TYPE) {
+            return '\0';
+        }
+        return null;
+    }
+}
diff --git a/agents/drivers/oceanbase-oracle/build.gradle b/agents/drivers/oceanbase-oracle/build.gradle
new file mode 100644
index 0000000..ef3e6f3
--- /dev/null
+++ b/agents/drivers/oceanbase-oracle/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.oceanbase:oceanbase-client:2.4.18'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'OceanBase Oracle Mode', 'Main-Class': 'com.dbx.agent.oceanbaseoracle.OceanBaseOracleAgent')
+    }
+}
diff --git a/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java b/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java
new file mode 100644
index 0000000..18d4964
--- /dev/null
+++ b/agents/drivers/oceanbase-oracle/src/main/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgent.java
@@ -0,0 +1,623 @@
+package com.dbx.agent.oceanbaseoracle;
+
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.DdlBuilder;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public final class OceanBaseOracleAgent extends ConfiguredJdbcAgent {
+    private static final long MICROS_PER_SECOND = 1_000_000L;
+    private static final String COMPATIBLE_OJDBC_VERSION = "compatibleOjdbcVersion";
+    private static final String DEFAULT_COMPATIBLE_OJDBC_VERSION = "compatibleOjdbcVersion=8";
+    private static final Set<String> SYSTEM_SCHEMAS = Set.of(
+        "SYS", "SYSTEM", "SYSMAN", "DBSNMP", "SYSBACKUP", "SYSDG", "SYSKM", "OUTLN",
+        "AUDSYS", "LBACSYS", "DVF", "DVSYS", "APPQOSSYS", "CTXSYS", "MDSYS", "MDDATA",
+        "ORDSYS", "ORDDATA", "ORDPLUGINS", "XDB", "ANONYMOUS", "DIP", "EXFSYS",
+        "GSMADMIN_INTERNAL", "GSMCATUSER", "GSMUSER", "OJVMSYS", "OLAPSYS",
+        "ORACLE_OCM", "SI_INFORMTN_SCHEMA", "WMSYS", "XS$NULL", "DBSFWUSER",
+        "REMOTE_SCHEDULER_AGENT", "PDBADMIN", "DGPDB_INT", "OPS$ORACLE",
+        "GGSYS", "FLOWS_FILES", "APEX_PUBLIC_USER", "GSMROOTUSER", "SYSRAC"
+    );
+
+    public static final JdbcAgentProfile OCEANBASE_ORACLE_PROFILE = new JdbcAgentProfile(
+        "com.oceanbase.jdbc.Driver",
+        "jdbc:oceanbase://{host}:{port}/{database}",
+        2883,
+        false,
+        SYSTEM_SCHEMAS,
+        List.of("TABLE", "VIEW", "BASE TABLE")
+    ) {
+        @Override
+        public String schemaSwitchSql(String schema, String quote) {
+            return "ALTER SESSION SET CURRENT_SCHEMA = " + quote + schema.replace(quote, quote + quote) + quote;
+        }
+    };
+
+    public OceanBaseOracleAgent() {
+        super(OCEANBASE_ORACLE_PROFILE);
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return buildUrl(params);
+    }
+
+    static String buildUrl(ConnectParams params) {
+        return appendDefaultCompatibilityOption(OCEANBASE_ORACLE_PROFILE.buildUrl(params));
+    }
+
+    @Override
+    protected void beforeQueryExecution(Connection connection, int timeoutSecs) throws SQLException {
+        // Connector/J's Statement timeout does not update OceanBase's stricter
+        // session variable, so synchronize both limits before every execution.
+        try (var stmt = connection.createStatement()) {
+            stmt.execute(queryTimeoutSql(timeoutSecs));
+        }
+    }
+
+    static String queryTimeoutSql(int timeoutSecs) {
+        if (timeoutSecs < 0) {
+            throw new IllegalArgumentException("Query timeout cannot be negative: " + timeoutSecs);
+        }
+        return "ALTER SESSION SET ob_query_timeout = " + timeoutSecs * MICROS_PER_SECOND;
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            for (String schema : querySchemas()) {
+                result.add(new DatabaseInfo(schema));
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return unchecked(this::querySchemas);
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return queryTables(schema, MetadataListConstraints.NONE);
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        return queryTables(schema, MetadataListConstraints.orNone(constraints));
+    }
+
+    private List<TableInfo> queryTables(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            String owner = normalizeSchema(schema);
+            List<String> objectTypes = oceanBaseTableTypes(constraints);
+            if (objectTypes.isEmpty()) {
+                return List.of();
+            }
+            String baseSql = """
+                SELECT o.OBJECT_NAME,
+                    CASE o.OBJECT_TYPE WHEN 'VIEW' THEN 'VIEW' ELSE 'TABLE' END AS TABLE_TYPE,
+                    c.COMMENTS
+                FROM ALL_OBJECTS o
+                LEFT JOIN ALL_TAB_COMMENTS c ON c.OWNER = o.OWNER AND c.TABLE_NAME = o.OBJECT_NAME
+                WHERE o.OWNER = ? AND o.OBJECT_TYPE IN (%s)
+                """.stripIndent().trim();
+            MetadataSql query = oceanBaseMetadataSql(
+                String.format(baseSql, placeholders(objectTypes.size())),
+                "OBJECT_NAME, TABLE_TYPE, COMMENTS",
+                "o.OBJECT_NAME",
+                "ORDER BY OBJECT_NAME",
+                owner,
+                objectTypes,
+                constraints
+            );
+
+            List<TableInfo> result = new ArrayList<>();
+            try (var stmt = requireConnection().prepareStatement(query.sql)) {
+                bind(stmt, query.args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(rs.getString(1), rs.getString(2), rs.getString(3)));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterTables(result);
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return queryObjects(schema, MetadataListConstraints.NONE);
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        return queryObjects(schema, MetadataListConstraints.orNone(constraints));
+    }
+
+    private List<ObjectInfo> queryObjects(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            String owner = normalizeSchema(schema);
+            List<String> objectTypes = oceanBaseObjectTypes(constraints);
+            if (objectTypes.isEmpty()) {
+                return List.of();
+            }
+            String baseSql = """
+                SELECT OBJECT_NAME, OBJECT_TYPE
+                FROM ALL_OBJECTS
+                WHERE OWNER = ? AND OBJECT_TYPE IN (%s)
+                """.stripIndent().trim();
+            MetadataSql query = oceanBaseMetadataSql(
+                String.format(baseSql, placeholders(objectTypes.size())),
+                "OBJECT_NAME, OBJECT_TYPE",
+                "OBJECT_NAME",
+                """
+                ORDER BY CASE OBJECT_TYPE
+                    WHEN 'TABLE' THEN 0
+                    WHEN 'VIEW' THEN 1
+                    WHEN 'PROCEDURE' THEN 2
+                    WHEN 'FUNCTION' THEN 3
+                    WHEN 'PACKAGE' THEN 4
+                    WHEN 'SEQUENCE' THEN 5
+                    ELSE 6
+                END, OBJECT_NAME
+                """.stripIndent().trim(),
+                owner,
+                objectTypes,
+                constraints
+            );
+
+            List<ObjectInfo> result = new ArrayList<>();
+            try (var stmt = requireConnection().prepareStatement(query.sql)) {
+                bind(stmt, query.args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1), rs.getString(2), owner, null));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterObjects(result);
+        });
+    }
+
+    private static MetadataSql oceanBaseMetadataSql(
+        String baseSql,
+        String selectList,
+        String nameColumn,
+        String orderSql,
+        String owner,
+        List<String> objectTypes,
+        MetadataListConstraints constraints
+    ) {
+        List<Object> args = new ArrayList<>();
+        args.add(owner);
+        args.addAll(objectTypes);
+        String sql = baseSql;
+        if (constraints.hasFilter()) {
+            sql += " AND UPPER(" + nameColumn + ") LIKE ? ESCAPE '\\'";
+            args.add(constraints.fuzzyLikePattern().toUpperCase(Locale.ROOT));
+        }
+        sql += "\n" + orderSql;
+        if (constraints.hasLimit()) {
+            // OceanBase Oracle mode is safest with the classic ordered ROWNUM wrapper for paged metadata.
+            int offset = constraints.getOffset() == null ? 0 : constraints.getOffset();
+            sql = "SELECT " + selectList + "\nFROM (\n  SELECT DBX_Q.*, ROWNUM AS DBX_RN\n  FROM (\n"
+                + sql
+                + "\n  ) DBX_Q\n  WHERE ROWNUM <= ?\n)\nWHERE DBX_RN > ?";
+            args.add(offset + constraints.getLimit());
+            args.add(offset);
+        } else if (constraints.hasOffset()) {
+            sql = "SELECT " + selectList + "\nFROM (\n  SELECT DBX_Q.*, ROWNUM AS DBX_RN\n  FROM (\n"
+                + sql
+                + "\n  ) DBX_Q\n)\nWHERE DBX_RN > ?";
+            args.add(constraints.getOffset());
+        }
+        return new MetadataSql(sql, args);
+    }
+
+    private static List<String> oceanBaseTableTypes(MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return List.of("TABLE", "VIEW");
+        }
+        List<String> result = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            result.add("TABLE");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            result.add("VIEW");
+        }
+        return result;
+    }
+
+    private static List<String> oceanBaseObjectTypes(MetadataListConstraints constraints) {
+        List<String> supported = List.of("TABLE", "VIEW", "PROCEDURE", "FUNCTION", "PACKAGE", "SEQUENCE", "SYNONYM");
+        if (!constraints.hasObjectTypes()) {
+            return supported;
+        }
+        List<String> result = new ArrayList<>();
+        for (String objectType : supported) {
+            if (constraints.objectTypeAllowed(objectType)) {
+                result.add(objectType);
+            }
+        }
+        return result;
+    }
+
+    private static String placeholders(int count) {
+        return String.join(", ", java.util.Collections.nCopies(count, "?"));
+    }
+
+    private static void bind(java.sql.PreparedStatement stmt, List<Object> args) throws SQLException {
+        for (int index = 0; index < args.size(); index += 1) {
+            Object arg = args.get(index);
+            if (arg instanceof Integer) {
+                stmt.setInt(index + 1, (Integer) arg);
+            } else {
+                stmt.setString(index + 1, String.valueOf(arg));
+            }
+        }
+    }
+
+    private static final class MetadataSql {
+        private final String sql;
+        private final List<Object> args;
+
+        private MetadataSql(String sql, List<Object> args) {
+            this.sql = sql;
+            this.args = args;
+        }
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            String owner = normalizeSchema(schema);
+            String sql = """
+                SELECT c.COLUMN_NAME, c.DATA_TYPE, c.NULLABLE, c.DATA_PRECISION, c.DATA_SCALE,
+                    c.DATA_LENGTH, c.CHAR_LENGTH, c.DATA_DEFAULT, cc.COMMENTS,
+                    CASE WHEN pk.COLUMN_NAME IS NULL THEN 0 ELSE 1 END AS IS_PK
+                FROM ALL_TAB_COLUMNS c
+                LEFT JOIN ALL_COL_COMMENTS cc
+                    ON cc.OWNER = c.OWNER AND cc.TABLE_NAME = c.TABLE_NAME AND cc.COLUMN_NAME = c.COLUMN_NAME
+                LEFT JOIN (
+                    SELECT cols.COLUMN_NAME
+                    FROM ALL_CONS_COLUMNS cols
+                    JOIN ALL_CONSTRAINTS cons
+                        ON cols.CONSTRAINT_NAME = cons.CONSTRAINT_NAME AND cols.OWNER = cons.OWNER
+                    WHERE cons.CONSTRAINT_TYPE = 'P' AND cons.OWNER = ? AND cons.TABLE_NAME = ?
+                ) pk ON pk.COLUMN_NAME = c.COLUMN_NAME
+                WHERE c.OWNER = ? AND c.TABLE_NAME = ?
+                ORDER BY c.COLUMN_ID
+                """.stripIndent().trim();
+
+            List<ColumnInfo> result = new ArrayList<>();
+            try (var stmt = requireConnection().prepareStatement(sql)) {
+                stmt.setString(1, owner);
+                stmt.setString(2, table);
+                stmt.setString(3, owner);
+                stmt.setString(4, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        // Oracle-compatible DATA_DEFAULT is LONG-like; read it before other metadata fields.
+                        String defaultValue = rs.getString("DATA_DEFAULT");
+                        String name = rs.getString("COLUMN_NAME");
+                        String baseType = rs.getString("DATA_TYPE");
+                        Integer numPrec = intOrNull(rs, "DATA_PRECISION");
+                        Integer numScale = intOrNull(rs, "DATA_SCALE");
+                        Integer dataLen = intOrNull(rs, "DATA_LENGTH");
+                        Integer charLen = intOrNull(rs, "CHAR_LENGTH");
+                        result.add(new ColumnInfo(
+                            name,
+                            formatDataType(baseType, numPrec, numScale, dataLen, charLen),
+                            "Y".equalsIgnoreCase(rs.getString("NULLABLE")),
+                            defaultValue,
+                            rs.getInt("IS_PK") == 1,
+                            null,
+                            rs.getString("COMMENTS"),
+                            numPrec,
+                            numScale,
+                            charLen
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public String getTableDdl(String schema, String table) {
+        List<IndexInfo> indexes;
+        try {
+            indexes = listIndexes(schema, table);
+        } catch (RuntimeException e) {
+            indexes = Collections.emptyList();
+        }
+
+        List<ForeignKeyInfo> foreignKeys;
+        try {
+            foreignKeys = listForeignKeys(schema, table);
+        } catch (RuntimeException e) {
+            foreignKeys = Collections.emptyList();
+        }
+
+        return DdlBuilder.buildTableDdl(schema, table, getColumns(schema, table), indexes, foreignKeys, false, true);
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return unchecked(() -> {
+            String owner = normalizeSchema(schema);
+            String sql = """
+                SELECT i.INDEX_NAME, ic.COLUMN_NAME, ic.COLUMN_POSITION, i.UNIQUENESS,
+                    c.CONSTRAINT_TYPE, i.INDEX_TYPE
+                FROM ALL_INDEXES i
+                JOIN ALL_IND_COLUMNS ic
+                    ON i.INDEX_NAME = ic.INDEX_NAME
+                    AND i.OWNER = ic.INDEX_OWNER
+                    AND i.TABLE_OWNER = ic.TABLE_OWNER
+                    AND i.TABLE_NAME = ic.TABLE_NAME
+                LEFT JOIN ALL_CONSTRAINTS c
+                    ON i.INDEX_NAME = c.INDEX_NAME
+                    AND i.TABLE_OWNER = c.OWNER
+                    AND i.TABLE_NAME = c.TABLE_NAME
+                    AND c.CONSTRAINT_TYPE = 'P'
+                WHERE i.TABLE_OWNER = ? AND i.TABLE_NAME = ?
+                ORDER BY i.INDEX_NAME, ic.COLUMN_POSITION
+                """.stripIndent().trim();
+
+            Map<String, List<String>> columnsByIndex = new LinkedHashMap<>();
+            Map<String, Boolean> uniqueByIndex = new LinkedHashMap<>();
+            Map<String, Boolean> primaryByIndex = new LinkedHashMap<>();
+            Map<String, String> typeByIndex = new LinkedHashMap<>();
+            try (var stmt = requireConnection().prepareStatement(sql)) {
+                stmt.setString(1, owner);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String indexName = rs.getString("INDEX_NAME");
+                        columnsByIndex.computeIfAbsent(indexName, ignored -> new ArrayList<>()).add(rs.getString("COLUMN_NAME"));
+                        uniqueByIndex.put(indexName, "UNIQUE".equalsIgnoreCase(rs.getString("UNIQUENESS")));
+                        primaryByIndex.put(indexName, "P".equalsIgnoreCase(rs.getString("CONSTRAINT_TYPE")));
+                        typeByIndex.put(indexName, rs.getString("INDEX_TYPE"));
+                    }
+                }
+            }
+
+            List<IndexInfo> result = new ArrayList<>();
+            for (Map.Entry<String, List<String>> entry : columnsByIndex.entrySet()) {
+                String name = entry.getKey();
+                result.add(new IndexInfo(
+                    name,
+                    entry.getValue(),
+                    Boolean.TRUE.equals(uniqueByIndex.get(name)),
+                    Boolean.TRUE.equals(primaryByIndex.get(name)),
+                    null,
+                    typeByIndex.get(name),
+                    null,
+                    null
+                ));
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return unchecked(() -> {
+            String owner = normalizeSchema(schema);
+            String sql = """
+                SELECT c.CONSTRAINT_NAME, cc.COLUMN_NAME, rc.TABLE_NAME, rcc.COLUMN_NAME
+                FROM ALL_CONSTRAINTS c
+                JOIN ALL_CONS_COLUMNS cc ON c.CONSTRAINT_NAME = cc.CONSTRAINT_NAME AND c.OWNER = cc.OWNER
+                JOIN ALL_CONSTRAINTS rc ON c.R_CONSTRAINT_NAME = rc.CONSTRAINT_NAME AND c.R_OWNER = rc.OWNER
+                JOIN ALL_CONS_COLUMNS rcc
+                    ON rc.CONSTRAINT_NAME = rcc.CONSTRAINT_NAME
+                    AND rc.OWNER = rcc.OWNER
+                    AND cc.POSITION = rcc.POSITION
+                WHERE c.CONSTRAINT_TYPE = 'R' AND c.OWNER = ? AND c.TABLE_NAME = ?
+                ORDER BY c.CONSTRAINT_NAME, cc.POSITION
+                """.stripIndent().trim();
+
+            List<ForeignKeyInfo> result = new ArrayList<>();
+            try (var stmt = requireConnection().prepareStatement(sql)) {
+                stmt.setString(1, owner);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ForeignKeyInfo(
+                            rs.getString(1),
+                            rs.getString(2),
+                            rs.getString(3),
+                            rs.getString(4)
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return unchecked(() -> {
+            String owner = normalizeSchema(schema);
+            String sql = """
+                SELECT TRIGGER_NAME, TRIGGERING_EVENT, TRIGGER_TYPE
+                FROM ALL_TRIGGERS
+                WHERE OWNER = ? AND TABLE_NAME = ?
+                ORDER BY TRIGGER_NAME
+                """.stripIndent().trim();
+
+            List<TriggerInfo> result = new ArrayList<>();
+            try (var stmt = requireConnection().prepareStatement(sql)) {
+                stmt.setString(1, owner);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TriggerInfo(rs.getString(1), rs.getString(2), rs.getString(3)));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "ALTER SESSION SET CURRENT_SCHEMA = " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
+    }
+
+    private List<String> querySchemas() throws SQLException {
+        try {
+            return querySchemaNames();
+        } catch (SQLException primaryError) {
+            String current;
+            try {
+                current = currentSchema();
+            } catch (SQLException ignored) {
+                throw primaryError;
+            }
+            if (current == null || current.isBlank()) {
+                throw primaryError;
+            }
+            return List.of(current);
+        }
+    }
+
+    private List<String> querySchemaNames() throws SQLException {
+        String placeholders = SYSTEM_SCHEMAS.stream()
+            .map(schema -> "'" + schema + "'")
+            .collect(Collectors.joining(","));
+        String sql = """
+            SELECT username
+            FROM ALL_USERS
+            WHERE username IS NOT NULL
+              AND username NOT IN (%s)
+              AND username NOT LIKE 'APEX_%%'
+              AND username NOT LIKE 'FLOWS_%%'
+              AND username NOT LIKE '%%$%%'
+            ORDER BY CASE
+                WHEN username = SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') THEN 0
+                WHEN username = SYS_CONTEXT('USERENV', 'SESSION_USER') THEN 1
+                ELSE 2
+            END, username
+            """.formatted(placeholders).stripIndent().trim();
+
+        List<String> result = new ArrayList<>();
+        try (var stmt = requireConnection().createStatement();
+             ResultSet rs = stmt.executeQuery(sql)) {
+            while (rs.next()) {
+                String schema = rs.getString(1);
+                if (schema != null && !schema.isBlank()) {
+                    result.add(schema);
+                }
+            }
+        }
+        return result;
+    }
+
+    private String normalizeSchema(String schema) throws SQLException {
+        String value = schema == null ? "" : schema.trim();
+        return value.isEmpty() ? currentSchema() : value;
+    }
+
+    private String currentSchema() throws SQLException {
+        try (var stmt = requireConnection().createStatement();
+             ResultSet rs = stmt.executeQuery("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') FROM DUAL")) {
+            if (rs.next()) {
+                String schema = rs.getString(1);
+                if (schema != null && !schema.isBlank()) {
+                    return schema;
+                }
+            }
+        }
+        return "";
+    }
+
+    private static String appendDefaultCompatibilityOption(String url) {
+        if (hasQueryKey(url, COMPATIBLE_OJDBC_VERSION)) {
+            return url;
+        }
+        return url + (url.contains("?") ? "&" : "?") + DEFAULT_COMPATIBLE_OJDBC_VERSION;
+    }
+
+    private static boolean hasQueryKey(String url, String key) {
+        int queryStart = url.indexOf('?');
+        if (queryStart < 0) {
+            return false;
+        }
+        String query = url.substring(queryStart + 1);
+        int fragmentStart = query.indexOf('#');
+        if (fragmentStart >= 0) {
+            query = query.substring(0, fragmentStart);
+        }
+        for (String part : query.split("[&;]")) {
+            String normalized = part.trim();
+            if (normalized.isEmpty()) {
+                continue;
+            }
+            int equals = normalized.indexOf('=');
+            String paramKey = equals >= 0 ? normalized.substring(0, equals) : normalized;
+            if (paramKey.trim().equalsIgnoreCase(key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static String formatDataType(String base, Integer numPrec, Integer numScale, Integer dataLen, Integer charLen) {
+        if (base == null || base.isBlank()) {
+            return "";
+        }
+        return switch (base.toUpperCase(Locale.ROOT)) {
+            case "VARCHAR2", "NVARCHAR2", "CHAR", "NCHAR" -> {
+                Integer len = charLen == null ? dataLen : charLen;
+                yield len == null ? base : base + "(" + len + ")";
+            }
+            case "NUMBER" -> {
+                if (numPrec != null && numScale != null && numScale > 0) {
+                    yield base + "(" + numPrec + "," + numScale + ")";
+                }
+                if (numPrec != null && numPrec > 0) {
+                    yield base + "(" + numPrec + ")";
+                }
+                yield base;
+            }
+            case "RAW" -> dataLen == null ? "RAW" : "RAW(" + dataLen + ")";
+            default -> base;
+        };
+    }
+
+    private static Integer intOrNull(ResultSet rs, String column) throws SQLException {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new OceanBaseOracleAgent()).run();
+    }
+}
diff --git a/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgentTest.java b/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgentTest.java
new file mode 100644
index 0000000..0530b5c
--- /dev/null
+++ b/agents/drivers/oceanbase-oracle/src/test/java/com/dbx/agent/oceanbaseoracle/OceanBaseOracleAgentTest.java
@@ -0,0 +1,352 @@
+package com.dbx.agent.oceanbaseoracle;
+
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.QueryPageOptions;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.test.TestSupport;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+class OceanBaseOracleAgentTest {
+    @Test
+    void buildsOceanBaseJdbcUrl() {
+        ConnectParams params = new ConnectParams();
+        params.setHost("oceanbase.example.com");
+        params.setPort(0);
+        params.setDatabase("sys");
+
+        Assertions.assertEquals(
+            "jdbc:oceanbase://oceanbase.example.com:2883/sys?compatibleOjdbcVersion=8",
+            OceanBaseOracleAgent.buildUrl(params)
+        );
+    }
+
+    @Test
+    void appendsQueryParametersToJdbcUrl() {
+        ConnectParams params = new ConnectParams();
+        params.setHost("oceanbase.example.com");
+        params.setPort(2881);
+        params.setDatabase("sys");
+        params.setUrl_params("useSSL=false");
+
+        Assertions.assertEquals(
+            "jdbc:oceanbase://oceanbase.example.com:2881/sys?useSSL=false&compatibleOjdbcVersion=8",
+            OceanBaseOracleAgent.buildUrl(params)
+        );
+    }
+
+    @Test
+    void keepsExplicitCompatibleOjdbcVersion() {
+        ConnectParams params = new ConnectParams();
+        params.setHost("oceanbase.example.com");
+        params.setPort(2881);
+        params.setDatabase("sys");
+        params.setUrl_params("compatibleOjdbcVersion=6&useSSL=false");
+
+        Assertions.assertEquals(
+            "jdbc:oceanbase://oceanbase.example.com:2881/sys?compatibleOjdbcVersion=6&useSSL=false",
+            OceanBaseOracleAgent.buildUrl(params)
+        );
+    }
+
+    @Test
+    void appendsCompatibleOjdbcVersionToCustomJdbcUrl() {
+        ConnectParams params = new ConnectParams();
+        params.setConnection_string("jdbc:oceanbase://custom-host:2881/sys?useSSL=false");
+
+        Assertions.assertEquals(
+            "jdbc:oceanbase://custom-host:2881/sys?useSSL=false&compatibleOjdbcVersion=8",
+            OceanBaseOracleAgent.buildUrl(params)
+        );
+    }
+
+    @Test
+    void convertsQueryTimeoutToOceanBaseSessionMicroseconds() {
+        Assertions.assertEquals(
+            "ALTER SESSION SET ob_query_timeout = 300000000",
+            OceanBaseOracleAgent.queryTimeoutSql(300)
+        );
+        Assertions.assertEquals(
+            "ALTER SESSION SET ob_query_timeout = 0",
+            OceanBaseOracleAgent.queryTimeoutSql(0)
+        );
+        Assertions.assertEquals(
+            "ALTER SESSION SET ob_query_timeout = 2147483647000000",
+            OceanBaseOracleAgent.queryTimeoutSql(Integer.MAX_VALUE)
+        );
+    }
+
+    @Test
+    void rejectsNegativeQueryTimeout() {
+        Assertions.assertThrows(IllegalArgumentException.class, () -> OceanBaseOracleAgent.queryTimeoutSql(-1));
+    }
+
+    @Test
+    void synchronizesSessionTimeoutForEveryQueryEntryPoint() {
+        List<String> sql = new ArrayList<>();
+        OceanBaseOracleAgent agent = new OceanBaseOracleAgent();
+        TestSupport.setPrivateConnection(agent, executionConnection(sql));
+
+        agent.executeQuery("SELECT 1 FROM DUAL", null, new ExecuteQueryOptions(10, null, 12));
+        agent.executeQueryPage("SELECT 2 FROM DUAL", null, new QueryPageOptions(10, null, 10, 13));
+        agent.startTableRead("SELECT 3 FROM DUAL", null, new QueryPageOptions(10, null, 10, 14));
+
+        Assertions.assertEquals(List.of(
+            "ALTER SESSION SET ob_query_timeout = 12000000",
+            "SELECT 1 FROM DUAL",
+            "ALTER SESSION SET ob_query_timeout = 13000000",
+            "SELECT 2 FROM DUAL",
+            "ALTER SESSION SET ob_query_timeout = 14000000",
+            "SELECT 3 FROM DUAL"
+        ), sql);
+    }
+
+    @Test
+    void constrainedListTablesUsesOceanBaseOracleMetadataSql() {
+        List<String> sql = new ArrayList<>();
+        OceanBaseOracleAgent agent = new OceanBaseOracleAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"OBJECT_NAME", "TABLE_TYPE", "COMMENTS"},
+            new Object[][]{
+                {"USER_SETTINGS", "TABLE", null}
+            }
+        )));
+
+        List<TableInfo> tables = agent.listTables(
+            "APP",
+            new MetadataListConstraints("user", 1, 1, List.of("TABLE"))
+        );
+
+        Assertions.assertEquals(1, tables.size());
+        Assertions.assertEquals("USER_SETTINGS", tables.get(0).getName());
+        Assertions.assertTrue(sql.get(0).contains("ALL_OBJECTS"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("UPPER(o.OBJECT_NAME) LIKE ?"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("ROWNUM <= ?"), sql.get(0));
+    }
+
+    @Test
+    void constrainedListObjectsUsesOceanBaseOracleMetadataSql() {
+        List<String> sql = new ArrayList<>();
+        OceanBaseOracleAgent agent = new OceanBaseOracleAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, resultSet(
+            new String[]{"OBJECT_NAME", "OBJECT_TYPE"},
+            new Object[][]{
+                {"FORMAT_USER", "FUNCTION"}
+            }
+        )));
+
+        List<ObjectInfo> objects = agent.listObjects(
+            "APP",
+            new MetadataListConstraints("user", 1, 1, List.of("FUNCTION"))
+        );
+
+        Assertions.assertEquals(1, objects.size());
+        Assertions.assertEquals("FORMAT_USER", objects.get(0).getName());
+        Assertions.assertEquals("FUNCTION", objects.get(0).getObject_type());
+        Assertions.assertTrue(sql.get(0).contains("OBJECT_TYPE IN (?)"), sql.get(0));
+        Assertions.assertTrue(sql.get(0).contains("ROWNUM <= ?"), sql.get(0));
+    }
+
+    @Test
+    void getColumnsIncludesDefaultAndCommentMetadata() {
+        List<String> sql = new ArrayList<>();
+        OceanBaseOracleAgent agent = new OceanBaseOracleAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(sql, columnResultSet(
+            new Object[][]{
+                {"DISPLAY_NAME", "VARCHAR2", "Y", null, null, 64, 64, "'anonymous'", "User's display name", 0}
+            }
+        )));
+
+        List<ColumnInfo> columns = agent.getColumns("APP", "USERS");
+
+        Assertions.assertEquals(1, columns.size());
+        ColumnInfo column = columns.get(0);
+        Assertions.assertEquals("DISPLAY_NAME", column.getName());
+        Assertions.assertEquals("VARCHAR2(64)", column.getData_type());
+        Assertions.assertTrue(column.getIs_nullable());
+        Assertions.assertEquals("'anonymous'", column.getColumn_default());
+        Assertions.assertFalse(column.getIs_primary_key());
+        Assertions.assertEquals("User's display name", column.getComment());
+        Assertions.assertEquals(64, column.getCharacter_maximum_length());
+        Assertions.assertTrue(sql.get(0).contains("c.DATA_DEFAULT"), sql.get(0));
+    }
+
+    @Test
+    void tableDdlIncludesDefaultsAndOnlyNonBlankColumnComments() {
+        OceanBaseOracleAgent agent = new OceanBaseOracleAgent();
+        TestSupport.setPrivateConnection(agent, preparedConnection(new ArrayList<>(),
+            resultSet(
+                new String[]{"INDEX_NAME", "COLUMN_NAME", "COLUMN_POSITION", "UNIQUENESS", "CONSTRAINT_TYPE", "INDEX_TYPE"},
+                new Object[][]{}
+            ),
+            resultSet(
+                new String[]{"CONSTRAINT_NAME", "COLUMN_NAME", "TABLE_NAME", "REF_COLUMN_NAME"},
+                new Object[][]{}
+            ),
+            columnResultSet(new Object[][]{
+                {"CREATED_AT", "TIMESTAMP", "N", null, null, null, null, "SYSDATE", "Created timestamp", 0},
+                {"INTERNAL_NOTE", "VARCHAR2", "Y", null, null, 100, 100, null, "   ", 0}
+            })
+        ));
+
+        String ddl = agent.getTableDdl("APP", "AUDIT_LOG");
+
+        Assertions.assertTrue(ddl.contains("\"CREATED_AT\" TIMESTAMP NOT NULL DEFAULT SYSDATE"), ddl);
+        Assertions.assertTrue(
+            ddl.contains("COMMENT ON COLUMN \"APP\".\"AUDIT_LOG\".\"CREATED_AT\" IS 'Created timestamp';"),
+            ddl
+        );
+        Assertions.assertTrue(ddl.contains("\"INTERNAL_NOTE\" VARCHAR2(100)"), ddl);
+        Assertions.assertFalse(ddl.contains("\"INTERNAL_NOTE\" IS"), ddl);
+    }
+
+    private static ResultSet columnResultSet(Object[][] rows) {
+        return resultSet(
+            new String[]{
+                "COLUMN_NAME",
+                "DATA_TYPE",
+                "NULLABLE",
+                "DATA_PRECISION",
+                "DATA_SCALE",
+                "DATA_LENGTH",
+                "CHAR_LENGTH",
+                "DATA_DEFAULT",
+                "COMMENTS",
+                "IS_PK"
+            },
+            rows
+        );
+    }
+
+    private static Connection preparedConnection(List<String> sql, ResultSet... resultSets) {
+        int[] resultSetIndex = {0};
+        PreparedStatement statement = proxy(PreparedStatement.class, (method, args) -> {
+            if ("executeQuery".equals(method.getName())) {
+                int current = Math.min(resultSetIndex[0], resultSets.length - 1);
+                resultSetIndex[0] += 1;
+                return resultSets[current];
+            }
+            if ("setString".equals(method.getName()) || "setInt".equals(method.getName()) || "close".equals(method.getName())) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+        return proxy(Connection.class, (method, args) -> {
+            if ("prepareStatement".equals(method.getName())) {
+                sql.add(String.valueOf(args[0]));
+                return statement;
+            }
+            if ("isClosed".equals(method.getName())) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static Connection executionConnection(List<String> sql) {
+        Statement statement = proxy(Statement.class, (method, args) -> {
+            if ("execute".equals(method.getName())) {
+                sql.add(String.valueOf(args[0]));
+                return false;
+            }
+            if ("getUpdateCount".equals(method.getName())) {
+                return 0;
+            }
+            if ("close".equals(method.getName()) || "setMaxRows".equals(method.getName())
+                || "setFetchSize".equals(method.getName()) || "setQueryTimeout".equals(method.getName())) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+        return proxy(Connection.class, (method, args) -> {
+            if ("createStatement".equals(method.getName())) {
+                return statement;
+            }
+            if ("isClosed".equals(method.getName())) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSet resultSet(String[] columns, Object[][] rows) {
+        int[] index = {-1};
+        return proxy(ResultSet.class, (method, args) -> {
+            switch (method.getName()) {
+                case "next":
+                    index[0] += 1;
+                    return index[0] < rows.length;
+                case "getString":
+                    Object value = columnValue(columns, rows[index[0]], args[0]);
+                    return value == null ? null : String.valueOf(value);
+                case "getObject":
+                    return columnValue(columns, rows[index[0]], args[0]);
+                case "getInt":
+                    Object intValue = columnValue(columns, rows[index[0]], args[0]);
+                    if (intValue instanceof Number) {
+                        return ((Number) intValue).intValue();
+                    }
+                    if (intValue == null) {
+                        return 0;
+                    }
+                    return Integer.parseInt(String.valueOf(intValue));
+                case "close":
+                    return null;
+                default:
+                    return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static Object columnValue(String[] columns, Object[] row, Object key) {
+        if (key instanceof Number) {
+            return row[((Number) key).intValue() - 1];
+        }
+        for (int i = 0; i < columns.length; i++) {
+            if (columns[i].equalsIgnoreCase(String.valueOf(key))) {
+                return row[i];
+            }
+        }
+        return null;
+    }
+
+    private static <T> T proxy(Class<T> type, MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                return handler.handle(method, args == null ? new Object[0] : args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (type == Boolean.TYPE) return false;
+        if (type == Byte.TYPE) return (byte) 0;
+        if (type == Short.TYPE) return (short) 0;
+        if (type == Integer.TYPE) return 0;
+        if (type == Long.TYPE) return 0L;
+        if (type == Float.TYPE) return 0f;
+        if (type == Double.TYPE) return 0d;
+        if (type == Character.TYPE) return (char) 0;
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args) throws Throwable;
+    }
+}
diff --git a/agents/drivers/oracle-go/.gitignore b/agents/drivers/oracle-go/.gitignore
new file mode 100644
index 0000000..8aa3c07
--- /dev/null
+++ b/agents/drivers/oracle-go/.gitignore
@@ -0,0 +1,2 @@
+agent
+agent.exe
diff --git a/agents/drivers/oracle-go/README.md b/agents/drivers/oracle-go/README.md
new file mode 100644
index 0000000..847b78d
--- /dev/null
+++ b/agents/drivers/oracle-go/README.md
@@ -0,0 +1,36 @@
+# DBX Oracle Go Agent
+
+Experimental native Oracle agent for DBX using `github.com/sijms/go-ora/v2`.
+
+## Build
+
+```bash
+go build -o agent .
+```
+
+Cross-compile release builds use pure Go output:
+
+```bash
+CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -trimpath -ldflags="-s -w" -o dbx-agent-oracle-linux-x64 .
+CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -trimpath -ldflags="-s -w" -o dbx-agent-oracle-macos-aarch64 .
+CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -trimpath -ldflags="-s -w" -o dbx-agent-oracle-windows-x64.exe .
+```
+
+## Local DBX Test
+
+Build the binary, then copy it into DBX's installed Oracle driver directory:
+
+```bash
+mkdir -p ~/.dbx/agents/drivers/oracle
+cp agent ~/.dbx/agents/drivers/oracle/agent
+chmod +x ~/.dbx/agents/drivers/oracle/agent
+```
+
+DBX prefers `agent` over `agent.jar`, so Oracle connections will use this Go
+agent until the file is removed.
+
+To restore the Java agent:
+
+```bash
+rm ~/.dbx/agents/drivers/oracle/agent
+```
diff --git a/agents/drivers/oracle-go/go.mod b/agents/drivers/oracle-go/go.mod
new file mode 100644
index 0000000..9d4188c
--- /dev/null
+++ b/agents/drivers/oracle-go/go.mod
@@ -0,0 +1,7 @@
+module github.com/t8y2/dbx/agents/drivers/oracle-go
+
+go 1.22
+
+require github.com/sijms/go-ora/v2 v2.9.0
+
+require golang.org/x/text v0.22.0
diff --git a/agents/drivers/oracle-go/go.sum b/agents/drivers/oracle-go/go.sum
new file mode 100644
index 0000000..a0fd27b
--- /dev/null
+++ b/agents/drivers/oracle-go/go.sum
@@ -0,0 +1,4 @@
+github.com/sijms/go-ora/v2 v2.9.0 h1:+iQbUeTeCOFMb5BsOMgUhV8KWyrv9yjKpcK4x7+MFrg=
+github.com/sijms/go-ora/v2 v2.9.0/go.mod h1:QgFInVi3ZWyqAiJwzBQA+nbKYKH77tdp1PYoCqhR2dU=
+golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
+golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
diff --git a/agents/drivers/oracle-go/main.go b/agents/drivers/oracle-go/main.go
new file mode 100644
index 0000000..c3fff0e
--- /dev/null
+++ b/agents/drivers/oracle-go/main.go
@@ -0,0 +1,2902 @@
+package main
+
+import (
+	"bufio"
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/url"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	_ "github.com/sijms/go-ora/v2"
+	go_ora "github.com/sijms/go-ora/v2"
+	"github.com/sijms/go-ora/v2/converters"
+	"golang.org/x/text/encoding/simplifiedchinese"
+	"golang.org/x/text/transform"
+)
+
+const protocolVersion = 1
+const defaultMaxRows = 1000
+const oracleCharsetZHS32GB18030 = 854
+
+var (
+	oraclePlSQLBlockStartRegexp          = regexp.MustCompile(`(?is)^\s*(?:DECLARE|BEGIN|CREATE\s+(?:OR\s+REPLACE\s+)?(?:(?:EDITIONABLE|NONEDITIONABLE)\s+)?(?:FUNCTION|PROCEDURE|TRIGGER|PACKAGE(?:\s+BODY)?|TYPE(?:\s+BODY)?))\b`)
+	oraclePlSQLBlockEndRegexp            = regexp.MustCompile(`(?is)\bEND\s*;\s*$`)
+	oracleNamedPlSQLBlockEndRegexp       = regexp.MustCompile(`(?is)\bEND\s+([A-Z0-9_$#]+)\s*;\s*$`)
+	oracleUnsupportedServerCharsetRegexp = regexp.MustCompile(`server use charset with id: ([0-9]+).*not supported by the driver`)
+	oracleStringConverters               = map[int]converters.IStringConverter{
+		oracleCharsetZHS32GB18030: oracleGB18030Converter{},
+	}
+)
+
+const oracleListDatabasesSQL = `
+SELECT username AS owner
+FROM all_users
+WHERE username IS NOT NULL
+  AND username NOT IN (
+    'SYS','SYSTEM','SYSMAN','DBSNMP','SYSBACKUP','SYSDG','SYSKM','SYSRAC','OUTLN',
+    'AUDSYS','LBACSYS','DVF','DVSYS','APPQOSSYS','CTXSYS','MDSYS','MDDATA',
+    'ORDSYS','ORDDATA','ORDPLUGINS','XDB','ANONYMOUS','DIP','EXFSYS',
+    'GSMADMIN_INTERNAL','GSMCATUSER','GSMROOTUSER','GSMUSER','OJVMSYS','OLAPSYS',
+    'ORACLE_OCM','SI_INFORMTN_SCHEMA','WMSYS','XS$NULL','DBSFWUSER',
+    'REMOTE_SCHEDULER_AGENT','PDBADMIN','DGPDB_INT','OPS$ORACLE',
+    'GGSYS','FLOWS_FILES','APEX_PUBLIC_USER'
+  )
+  AND username NOT LIKE 'APEX_%'
+  AND username NOT LIKE 'FLOWS_%'
+  AND username NOT LIKE '%$%'
+ORDER BY CASE
+  WHEN username = SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') THEN 0
+  WHEN username = SYS_CONTEXT('USERENV', 'SESSION_USER') THEN 1
+  ELSE 2
+END, username`
+const oracleListTablesBaseSQL = `
+SELECT OBJECT_NAME, TABLE_TYPE, COMMENTS
+FROM (
+SELECT t.TABLE_NAME AS OBJECT_NAME,
+       'TABLE' AS TABLE_TYPE,
+       CAST(NULL AS VARCHAR2(4000)) AS COMMENTS
+FROM ALL_TABLES t
+WHERE t.OWNER = :1
+  AND t.NESTED = 'NO'
+UNION ALL
+SELECT o.OBJECT_NAME,
+       'VIEW' AS TABLE_TYPE,
+       CAST(NULL AS VARCHAR2(4000)) AS COMMENTS
+FROM ALL_OBJECTS o
+WHERE o.OWNER = :2
+  AND o.OBJECT_TYPE = 'VIEW'
+)`
+const oracleListTablesSessionUserBaseSQL = `
+SELECT OBJECT_NAME, TABLE_TYPE, COMMENTS
+FROM (
+SELECT t.TABLE_NAME AS OBJECT_NAME,
+       'TABLE' AS TABLE_TYPE,
+       CAST(NULL AS VARCHAR2(4000)) AS COMMENTS
+FROM USER_TABLES t
+WHERE t.NESTED = 'NO'
+UNION ALL
+SELECT o.OBJECT_NAME,
+       'VIEW' AS TABLE_TYPE,
+       CAST(NULL AS VARCHAR2(4000)) AS COMMENTS
+FROM USER_OBJECTS o
+WHERE o.OBJECT_TYPE = 'VIEW'
+)`
+const oracleListTablesOrderSQL = `ORDER BY OBJECT_NAME`
+const oracleListTablesSQL = oracleListTablesBaseSQL + "\n" + oracleListTablesOrderSQL
+const oracleListObjectsBaseSQL = `
+SELECT OBJECT_NAME, OBJECT_TYPE, COMMENTS
+FROM (
+SELECT t.TABLE_NAME AS OBJECT_NAME,
+       'TABLE' AS OBJECT_TYPE,
+       CAST(NULL AS VARCHAR2(4000)) AS COMMENTS
+FROM ALL_TABLES t
+WHERE t.OWNER = :1
+  AND t.NESTED = 'NO'
+UNION ALL
+SELECT o.OBJECT_NAME,
+       CASE o.OBJECT_TYPE WHEN 'PACKAGE BODY' THEN 'PACKAGE_BODY' ELSE o.OBJECT_TYPE END AS OBJECT_TYPE,
+       CAST(NULL AS VARCHAR2(4000)) AS COMMENTS
+FROM ALL_OBJECTS o
+WHERE o.OWNER = :2
+  AND o.OBJECT_TYPE IN ('VIEW', 'PROCEDURE', 'FUNCTION', 'PACKAGE', 'PACKAGE BODY')
+)`
+const oracleListObjectsSessionUserBaseSQL = `
+SELECT OBJECT_NAME, OBJECT_TYPE, COMMENTS
+FROM (
+SELECT t.TABLE_NAME AS OBJECT_NAME,
+       'TABLE' AS OBJECT_TYPE,
+       CAST(NULL AS VARCHAR2(4000)) AS COMMENTS
+FROM USER_TABLES t
+WHERE t.NESTED = 'NO'
+UNION ALL
+SELECT o.OBJECT_NAME,
+       CASE o.OBJECT_TYPE WHEN 'PACKAGE BODY' THEN 'PACKAGE_BODY' ELSE o.OBJECT_TYPE END AS OBJECT_TYPE,
+       CAST(NULL AS VARCHAR2(4000)) AS COMMENTS
+FROM USER_OBJECTS o
+WHERE o.OBJECT_TYPE IN ('VIEW', 'PROCEDURE', 'FUNCTION', 'PACKAGE', 'PACKAGE BODY')
+)`
+const oracleListObjectsOrderSQL = `ORDER BY CASE OBJECT_TYPE
+  WHEN 'TABLE' THEN 0
+  WHEN 'VIEW' THEN 1
+  WHEN 'PROCEDURE' THEN 2
+  WHEN 'FUNCTION' THEN 3
+  WHEN 'PACKAGE' THEN 4
+  ELSE 5
+END, OBJECT_NAME`
+const oracleListObjectsSQL = oracleListObjectsBaseSQL + "\n" + oracleListObjectsOrderSQL
+
+type request struct {
+	ID     json.RawMessage            `json:"id"`
+	Method string                     `json:"method"`
+	Params map[string]json.RawMessage `json:"params"`
+}
+
+type response struct {
+	JSONRPC string          `json:"jsonrpc,omitempty"`
+	ID      json.RawMessage `json:"id,omitempty"`
+	Result  any             `json:"result,omitempty"`
+	Error   *rpcError       `json:"error,omitempty"`
+}
+
+type rpcError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+type connectParams struct {
+	Host             string `json:"host"`
+	Port             int    `json:"port"`
+	Database         string `json:"database"`
+	Username         string `json:"username"`
+	Password         string `json:"password"`
+	SysDBA           bool   `json:"sysdba"`
+	URLParams        string `json:"url_params"`
+	ConnectionString string `json:"connection_string"`
+}
+
+type queryOptions struct {
+	SQL       string `json:"sql"`
+	Database  string `json:"database"`
+	Schema    string `json:"schema"`
+	MaxRows   int    `json:"maxRows"`
+	FetchSize int    `json:"fetchSize"`
+}
+
+type queryResult struct {
+	Columns         []string `json:"columns"`
+	ColumnTypes     []string `json:"column_types"`
+	Rows            [][]any  `json:"rows"`
+	AffectedRows    int64    `json:"affected_rows"`
+	ExecutionTimeMS int64    `json:"execution_time_ms"`
+	Truncated       bool     `json:"truncated"`
+}
+
+func (r queryResult) MarshalJSON() ([]byte, error) {
+	type alias queryResult
+	value := alias(r)
+	if value.Columns == nil {
+		value.Columns = []string{}
+	}
+	if value.ColumnTypes == nil {
+		value.ColumnTypes = []string{}
+	}
+	if value.Rows == nil {
+		value.Rows = [][]any{}
+	}
+	return json.Marshal(value)
+}
+
+type queryPageResult struct {
+	Columns         []string `json:"columns"`
+	ColumnTypes     []string `json:"column_types"`
+	Rows            [][]any  `json:"rows"`
+	AffectedRows    int64    `json:"affected_rows"`
+	ExecutionTimeMS int64    `json:"execution_time_ms"`
+	Truncated       bool     `json:"truncated"`
+	SessionID       *string  `json:"session_id"`
+	HasMore         bool     `json:"has_more"`
+}
+
+func (r queryPageResult) MarshalJSON() ([]byte, error) {
+	type alias queryPageResult
+	value := alias(r)
+	if value.Columns == nil {
+		value.Columns = []string{}
+	}
+	if value.ColumnTypes == nil {
+		value.ColumnTypes = []string{}
+	}
+	if value.Rows == nil {
+		value.Rows = [][]any{}
+	}
+	return json.Marshal(value)
+}
+
+type querySession struct {
+	rows        *sql.Rows
+	columns     []string
+	columnTypes []string
+	pending     []any
+	remaining   int
+}
+
+type oracleColumnMeta struct {
+	Name     string
+	DataType string
+}
+
+type oracleColumnMetaLoader func(schema, table string) ([]oracleColumnMeta, error)
+
+type databaseInfo struct {
+	Name string `json:"name"`
+}
+
+type tableInfo struct {
+	Name      string  `json:"name"`
+	TableType string  `json:"table_type"`
+	Comment   *string `json:"comment"`
+}
+
+type metadataListConstraints struct {
+	Filter      string
+	Limit       int
+	Offset      int
+	ObjectTypes []string
+}
+
+type objectInfo struct {
+	Name       string  `json:"name"`
+	ObjectType string  `json:"object_type"`
+	Schema     string  `json:"schema"`
+	Comment    *string `json:"comment"`
+}
+
+type columnInfo struct {
+	Name                   string  `json:"name"`
+	DataType               string  `json:"data_type"`
+	IsNullable             bool    `json:"is_nullable"`
+	ColumnDefault          *string `json:"column_default"`
+	IsPrimaryKey           bool    `json:"is_primary_key"`
+	Extra                  *string `json:"extra"`
+	Comment                *string `json:"comment"`
+	NumericPrecision       *int    `json:"numeric_precision"`
+	NumericScale           *int    `json:"numeric_scale"`
+	CharacterMaximumLength *int    `json:"character_maximum_length"`
+}
+
+type indexInfo struct {
+	Name            string   `json:"name"`
+	Columns         []string `json:"columns"`
+	IsUnique        bool     `json:"is_unique"`
+	IsPrimary       bool     `json:"is_primary"`
+	Filter          *string  `json:"filter"`
+	IndexType       *string  `json:"index_type"`
+	IncludedColumns []string `json:"included_columns"`
+	Comment         *string  `json:"comment"`
+}
+
+func (i indexInfo) MarshalJSON() ([]byte, error) {
+	type alias indexInfo
+	value := alias(i)
+	if value.Columns == nil {
+		value.Columns = []string{}
+	}
+	if value.IncludedColumns == nil {
+		value.IncludedColumns = []string{}
+	}
+	return json.Marshal(value)
+}
+
+type foreignKeyInfo struct {
+	Name      string `json:"name"`
+	Column    string `json:"column"`
+	RefTable  string `json:"ref_table"`
+	RefColumn string `json:"ref_column"`
+}
+
+type triggerInfo struct {
+	Name   string `json:"name"`
+	Event  string `json:"event"`
+	Timing string `json:"timing"`
+}
+
+type server struct {
+	db                     *sql.DB
+	params                 connectParams
+	sessions               map[string]*querySession
+	tableReadSessions      map[string]*querySession
+	nextSessionID          int64
+	nextTableReadSessionID int64
+}
+
+func main() {
+	s := newServer()
+	encoder := json.NewEncoder(os.Stdout)
+	fmt.Fprintln(os.Stdout, `{"ready":true}`)
+
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Buffer(make([]byte, 0, 64*1024), 512*1024*1024)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+		resp, shutdown := s.handleLine(line)
+		if err := encoder.Encode(resp); err != nil {
+			fmt.Fprintf(os.Stderr, "failed to write response: %v\n", err)
+			return
+		}
+		if shutdown {
+			return
+		}
+	}
+	if err := scanner.Err(); err != nil && !errors.Is(err, io.EOF) {
+		fmt.Fprintf(os.Stderr, "failed to read stdin: %v\n", err)
+	}
+}
+
+func newServer() *server {
+	return &server{sessions: map[string]*querySession{}, tableReadSessions: map[string]*querySession{}}
+}
+
+func (s *server) handleLine(line string) (response, bool) {
+	var req request
+	if err := json.Unmarshal([]byte(line), &req); err != nil {
+		return errorResponse(nil, err), false
+	}
+	if len(req.ID) == 0 {
+		req.ID = json.RawMessage("1")
+	}
+	result, shutdown, err := s.dispatch(req.Method, req.Params)
+	if err != nil {
+		return errorResponse(req.ID, err), false
+	}
+	return response{JSONRPC: "2.0", ID: req.ID, Result: result}, shutdown
+}
+
+func (s *server) dispatch(method string, params map[string]json.RawMessage) (any, bool, error) {
+	switch method {
+	case "handshake":
+		return map[string]any{
+			"protocolVersion":      protocolVersion,
+			"agentProtocolVersion": protocolVersion,
+			"capabilities":         []string{"connect", "test_connection", "metadata", "query", "ddl"},
+		}, false, nil
+	case "connect":
+		var cp connectParams
+		if err := decodeParams(params, &cp); err != nil {
+			return nil, false, err
+		}
+		return map[string]bool{"ok": true}, false, s.connect(cp)
+	case "test_connection":
+		var cp connectParams
+		if err := decodeParams(params, &cp); err != nil {
+			return nil, false, err
+		}
+		db, err := openAndPingDB(cp, 5*time.Second)
+		if err != nil {
+			return nil, false, err
+		}
+		defer db.Close()
+		return map[string]bool{"ok": true}, false, nil
+	case "list_databases":
+		result, err := s.listDatabases()
+		return result, false, err
+	case "list_schemas":
+		result, err := s.listSchemas(stringSliceParam(params, "visible_schemas"))
+		return result, false, err
+	case "list_tables":
+		schema := stringParam(params, "schema")
+		result, err := s.listTables(schema, metadataListConstraintsFromParams(params))
+		return result, false, err
+	case "list_objects":
+		schema := stringParam(params, "schema")
+		result, err := s.listObjects(schema, metadataListConstraintsFromParams(params))
+		return result, false, err
+	case "get_columns":
+		schema := stringParam(params, "schema")
+		table := stringParam(params, "table")
+		result, err := s.getColumns(schema, table)
+		return result, false, err
+	case "get_object_source":
+		schema := stringParam(params, "schema")
+		name := stringParam(params, "name")
+		objectType := stringParam(params, "object_type")
+		source, err := s.getObjectSource(schema, name, objectType)
+		return source, false, err
+	case "get_table_ddl":
+		schema := stringParam(params, "schema")
+		table := stringParam(params, "table")
+		objectType := stringParam(params, "object_type")
+		ddl, err := s.getTableDDL(schema, table, objectType)
+		return ddl, false, err
+	case "execute_query":
+		var opts queryOptions
+		if err := decodeParams(params, &opts); err != nil {
+			return nil, false, err
+		}
+		result, err := s.executeQuery(opts)
+		return result, false, err
+	case "execute_query_page":
+		var opts queryOptions
+		if err := decodeParams(params, &opts); err != nil {
+			return nil, false, err
+		}
+		result, err := s.executeQueryPage(opts, intParam(params, "pageSize"))
+		return result, false, err
+	case "fetch_query_page":
+		result, err := s.fetchQueryPage(stringParam(params, "sessionId"), intParam(params, "pageSize"))
+		return result, false, err
+	case "close_query_session":
+		return s.closeQuerySession(stringParam(params, "sessionId")), false, nil
+	case "start_table_read":
+		var opts queryOptions
+		if err := decodeParams(params, &opts); err != nil {
+			return nil, false, err
+		}
+		result, err := s.startTableRead(opts, intParam(params, "pageSize"))
+		return result, false, err
+	case "fetch_table_read_page":
+		result, err := s.fetchTableReadPage(stringParam(params, "sessionId"), intParam(params, "pageSize"))
+		return result, false, err
+	case "close_table_read_session":
+		return s.closeTableReadSession(stringParam(params, "sessionId")), false, nil
+	case "list_indexes":
+		schema := stringParam(params, "schema")
+		table := stringParam(params, "table")
+		result, err := s.listIndexes(schema, table)
+		return result, false, err
+	case "list_foreign_keys":
+		schema := stringParam(params, "schema")
+		table := stringParam(params, "table")
+		result, err := s.listForeignKeys(schema, table)
+		return result, false, err
+	case "list_triggers":
+		schema := stringParam(params, "schema")
+		table := stringParam(params, "table")
+		result, err := s.listTriggers(schema, table)
+		return result, false, err
+	case "get_explain_info":
+		sqlText := stringParam(params, "sql")
+		plan, err := s.getExplainInfo(
+			sqlText,
+			stringParam(params, "database"),
+			stringParam(params, "schema"),
+			intParam(params, "timeoutSecs"),
+		)
+		return map[string]any{"plan": plan, "has_actual_stats": false}, false, err
+	case "execute_transaction":
+		result, err := s.executeTransaction(params)
+		return result, false, err
+	case "disconnect":
+		return map[string]bool{"ok": true}, false, s.disconnect()
+	case "shutdown":
+		_ = s.disconnect()
+		return map[string]bool{"ok": true}, true, nil
+	default:
+		return nil, false, fmt.Errorf("unknown method: %s", method)
+	}
+}
+
+func (s *server) connect(params connectParams) error {
+	_ = s.disconnect()
+	db, err := openAndPingDB(params, 15*time.Second)
+	if err != nil {
+		return err
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+	if _, err := db.ExecContext(ctx, "ALTER SESSION SET NLS_LANGUAGE='AMERICAN'"); err != nil {
+		db.Close()
+		return err
+	}
+	s.db = db
+	s.params = params
+	return nil
+}
+
+func (s *server) disconnect() error {
+	s.closeAllQuerySessions()
+	if s.db == nil {
+		return nil
+	}
+	err := s.db.Close()
+	s.db = nil
+	return err
+}
+
+func openDB(params connectParams) (*sql.DB, error) {
+	return openDBWithStringConverter(params, nil)
+}
+
+func openDBWithStringConverter(params connectParams, stringConverter converters.IStringConverter) (*sql.DB, error) {
+	dsn := buildDSN(params)
+	var db *sql.DB
+	if stringConverter == nil {
+		var err error
+		db, err = sql.Open("oracle", dsn)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		connector := go_ora.NewConnector(dsn)
+		go_ora.SetStringConverter(connector, stringConverter, nil)
+		db = sql.OpenDB(connector)
+	}
+	db.SetMaxOpenConns(4)
+	db.SetMaxIdleConns(1)
+	db.SetConnMaxLifetime(30 * time.Minute)
+	return db, nil
+}
+
+func openAndPingDB(params connectParams, timeout time.Duration) (*sql.DB, error) {
+	db, err := openDB(params)
+	if err != nil {
+		return nil, err
+	}
+	if err := pingDB(db, timeout); err != nil {
+		db.Close()
+		stringConverter, ok := oracleStringConverterForUnsupportedCharsetError(err)
+		if !ok {
+			return nil, err
+		}
+		// Retry only charsets with explicit converters. Guessing a converter
+		// can make the connection succeed while silently corrupting text.
+		db, err = openDBWithStringConverter(params, stringConverter)
+		if err != nil {
+			return nil, err
+		}
+		if retryErr := pingDB(db, timeout); retryErr != nil {
+			db.Close()
+			return nil, retryErr
+		}
+	}
+	return db, nil
+}
+
+func pingDB(db *sql.DB, timeout time.Duration) error {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	return db.PingContext(ctx)
+}
+
+func oracleStringConverterForUnsupportedCharsetError(err error) (converters.IStringConverter, bool) {
+	charsetID, ok := unsupportedOracleServerCharsetID(err)
+	if !ok {
+		return nil, false
+	}
+	stringConverter, ok := oracleStringConverters[charsetID]
+	return stringConverter, ok
+}
+
+func unsupportedOracleServerCharsetID(err error) (int, bool) {
+	if err == nil {
+		return 0, false
+	}
+	match := oracleUnsupportedServerCharsetRegexp.FindStringSubmatch(err.Error())
+	if len(match) != 2 {
+		return 0, false
+	}
+	charsetID, parseErr := strconv.Atoi(match[1])
+	if parseErr != nil {
+		return 0, false
+	}
+	return charsetID, true
+}
+
+type oracleGB18030Converter struct{}
+
+func (oracleGB18030Converter) Encode(input string) []byte {
+	output, _, err := transform.String(simplifiedchinese.GB18030.NewEncoder(), input)
+	if err != nil {
+		return []byte(input)
+	}
+	return []byte(output)
+}
+
+func (oracleGB18030Converter) Decode(input []byte) string {
+	output, _, err := transform.Bytes(simplifiedchinese.GB18030.NewDecoder(), input)
+	if err != nil {
+		return string(input)
+	}
+	return string(output)
+}
+
+func (oracleGB18030Converter) GetLangID() int {
+	return oracleCharsetZHS32GB18030
+}
+
+func (oracleGB18030Converter) Clone() converters.IStringConverter {
+	return oracleGB18030Converter{}
+}
+
+func buildDSN(params connectParams) string {
+	connectionString := strings.TrimSpace(params.ConnectionString)
+	if strings.HasPrefix(strings.ToLower(connectionString), "oracle://") {
+		return connectionString
+	}
+	username := params.Username
+	options := parseURLParams(params.URLParams)
+	if params.SysDBA {
+		options["AUTH TYPE"] = "SYSDBA"
+	}
+
+	if jdbc := parseOracleJDBCURL(connectionString); jdbc.Kind != "" {
+		if jdbc.Descriptor != "" {
+			return buildGoOraJDBC(username, params.Password, jdbc.Descriptor, options)
+		}
+		host := jdbc.Host
+		port := jdbc.Port
+		if port == 0 {
+			port = 1521
+		}
+		if jdbc.Kind == "sid" {
+			options["SID"] = jdbc.Database
+			return buildGoOraURL(host, port, "", username, params.Password, options)
+		}
+		return buildGoOraURL(host, port, jdbc.Database, username, params.Password, options)
+	}
+
+	service := strings.TrimSpace(params.Database)
+	if strings.HasPrefix(strings.ToUpper(service), "SYSDBA:") {
+		service = strings.TrimSpace(service[len("SYSDBA:"):])
+	}
+	port := params.Port
+	if port == 0 {
+		port = 1521
+	}
+	return buildGoOraURL(params.Host, port, service, username, params.Password, options)
+}
+
+func buildGoOraJDBC(user, password, connStr string, options map[string]string) string {
+	if options == nil {
+		options = make(map[string]string)
+	}
+	options["connStr"] = connStr
+	return buildGoOraURL("", 0, "", user, password, options)
+}
+
+func buildGoOraURL(server string, port int, service, user, password string, options map[string]string) string {
+	// go-ora v2.9.0 uses path escaping for user/password, leaving ':' unescaped.
+	// Userinfo escaping keeps bastion usernames such as 9008888:reader intact
+	// without changing their authentication semantics.
+	ret := fmt.Sprintf(
+		"oracle://%s@%s/%s",
+		url.UserPassword(user, password).String(),
+		net.JoinHostPort(server, strconv.Itoa(port)),
+		url.PathEscape(service),
+	)
+	if options != nil {
+		ret += "?"
+		for key, val := range options {
+			val = strings.TrimSpace(val)
+			for _, temp := range strings.Split(val, ",") {
+				temp = strings.TrimSpace(temp)
+				if strings.ToUpper(key) == "SERVER" {
+					ret += fmt.Sprintf("%s=%s&", key, temp)
+				} else {
+					ret += fmt.Sprintf("%s=%s&", key, url.QueryEscape(temp))
+				}
+			}
+		}
+		ret = strings.TrimRight(ret, "&")
+	}
+	return ret
+}
+
+type jdbcURLInfo struct {
+	Kind       string
+	Host       string
+	Port       int
+	Database   string
+	Descriptor string
+}
+
+var (
+	oracleJDBCServiceRegexp = regexp.MustCompile(`(?i)^jdbc:oracle:thin:@//([^/:]+):([0-9]+)/([^?]+)`)
+	oracleJDBCSIDRegexp     = regexp.MustCompile(`(?i)^jdbc:oracle:thin:@([^/:]+):([0-9]+):([^?]+)`)
+	oracleJDBCLegacyRegexp  = regexp.MustCompile(`(?i)^jdbc:oracle:thin:@([^/:]+):([0-9]+)/([^?]+)`)
+)
+
+func parseOracleJDBCURL(value string) jdbcURLInfo {
+	value = strings.TrimSpace(value)
+	lower := strings.ToLower(value)
+	if !strings.HasPrefix(lower, "jdbc:oracle:thin:@") {
+		return jdbcURLInfo{}
+	}
+	descriptor := strings.TrimSpace(value[len("jdbc:oracle:thin:@"):])
+	if strings.HasPrefix(descriptor, "(") {
+		return jdbcURLInfo{Kind: "descriptor", Descriptor: descriptor}
+	}
+	if match := oracleJDBCServiceRegexp.FindStringSubmatch(value); len(match) == 4 {
+		return jdbcURLInfo{Kind: "service", Host: match[1], Port: parsePort(match[2]), Database: match[3]}
+	}
+	if match := oracleJDBCSIDRegexp.FindStringSubmatch(value); len(match) == 4 {
+		return jdbcURLInfo{Kind: "sid", Host: match[1], Port: parsePort(match[2]), Database: match[3]}
+	}
+	if match := oracleJDBCLegacyRegexp.FindStringSubmatch(value); len(match) == 4 {
+		return jdbcURLInfo{Kind: "service", Host: match[1], Port: parsePort(match[2]), Database: match[3]}
+	}
+	return jdbcURLInfo{}
+}
+
+func parsePort(value string) int {
+	port, _ := strconv.Atoi(value)
+	return port
+}
+
+func (s *server) requireDB() (*sql.DB, error) {
+	if s.db == nil {
+		return nil, errors.New("agent is not connected")
+	}
+	return s.db, nil
+}
+
+func (s *server) listDatabases() ([]databaseInfo, error) {
+	rows, err := s.queryRows(oracleListDatabasesSQL, nil)
+	if err != nil {
+		if isOraclePGALimitError(err) {
+			return s.currentSchemaDatabase()
+		}
+		return nil, err
+	}
+	defer rows.Close()
+	var result []databaseInfo
+	for rows.Next() {
+		var name string
+		if err := rows.Scan(&name); err != nil {
+			return nil, err
+		}
+		result = append(result, databaseInfo{Name: name})
+	}
+	if err := rows.Err(); err != nil {
+		if isOraclePGALimitError(err) {
+			return s.currentSchemaDatabase()
+		}
+		return nil, err
+	}
+	return emptyIfNil(result), nil
+}
+
+func isOraclePGALimitError(err error) bool {
+	return err != nil && strings.Contains(strings.ToUpper(err.Error()), "ORA-04036")
+}
+
+func (s *server) currentSchemaDatabase() ([]databaseInfo, error) {
+	schema, err := s.currentSchema()
+	if err != nil {
+		return nil, err
+	}
+	if strings.TrimSpace(schema) == "" {
+		return []databaseInfo{}, nil
+	}
+	return []databaseInfo{{Name: schema}}, nil
+}
+
+func (s *server) listSchemas(visibleSchemas []string) ([]string, error) {
+	if visibleSchemas != nil && len(visibleSchemas) == 0 {
+		return []string{}, nil
+	}
+	databases, err := s.listDatabasesFiltered(visibleSchemas)
+	if err != nil {
+		return nil, err
+	}
+	result := make([]string, 0, len(databases))
+	for _, database := range databases {
+		result = append(result, database.Name)
+	}
+	return emptyIfNil(result), nil
+}
+
+func (s *server) listDatabasesFiltered(visibleSchemas []string) ([]databaseInfo, error) {
+	if visibleSchemas == nil {
+		return s.listDatabases()
+	}
+	sqlText, args := oracleListDatabasesSQLWithVisibleSchemas(visibleSchemas)
+	rows, err := s.queryRows(sqlText, args)
+	if err != nil {
+		if isOraclePGALimitError(err) {
+			return s.currentSchemaDatabase()
+		}
+		return nil, err
+	}
+	defer rows.Close()
+	var result []databaseInfo
+	for rows.Next() {
+		var name string
+		if err := rows.Scan(&name); err != nil {
+			return nil, err
+		}
+		result = append(result, databaseInfo{Name: name})
+	}
+	if err := rows.Err(); err != nil {
+		if isOraclePGALimitError(err) {
+			return s.currentSchemaDatabase()
+		}
+		return nil, err
+	}
+	return emptyIfNil(result), nil
+}
+
+func oracleListDatabasesSQLWithVisibleSchemas(visibleSchemas []string) (string, []any) {
+	if len(visibleSchemas) == 0 {
+		return oracleListDatabasesSQL, nil
+	}
+	placeholders := make([]string, 0, len(visibleSchemas))
+	args := make([]any, 0, len(visibleSchemas))
+	for i, schema := range visibleSchemas {
+		placeholders = append(placeholders, fmt.Sprintf(":%d", i+1))
+		args = append(args, schema)
+	}
+	sqlText := strings.Replace(
+		oracleListDatabasesSQL,
+		"\nORDER BY CASE",
+		"\n  AND username IN ("+strings.Join(placeholders, ",")+")\nORDER BY CASE",
+		1,
+	)
+	return sqlText, args
+}
+
+func (s *server) currentSchema() (string, error) {
+	db, err := s.requireDB()
+	if err != nil {
+		return "", err
+	}
+	var schema string
+	if err := db.QueryRow("SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') FROM DUAL").Scan(&schema); err != nil {
+		return "", err
+	}
+	return strings.ToUpper(schema), nil
+}
+
+func (s *server) normalizeSchema(schema string) (string, error) {
+	schema = strings.TrimSpace(schema)
+	if schema == "" {
+		return s.currentSchema()
+	}
+	return strings.ToUpper(schema), nil
+}
+
+func (s *server) sessionUser() (string, error) {
+	db, err := s.requireDB()
+	if err != nil {
+		return "", err
+	}
+	var username string
+	if err := db.QueryRow("SELECT SYS_CONTEXT('USERENV', 'SESSION_USER') FROM DUAL").Scan(&username); err != nil {
+		return "", err
+	}
+	return strings.ToUpper(username), nil
+}
+
+func (s *server) schemaIsSessionUser(schema string) bool {
+	username, err := s.sessionUser()
+	return err == nil && strings.EqualFold(schema, username)
+}
+
+type oracleMetadataListQuery struct {
+	SQL  string
+	Args []any
+}
+
+func metadataListConstraintsFromParams(params map[string]json.RawMessage) metadataListConstraints {
+	objectTypes := stringSliceParam(params, "object_types")
+	if len(objectTypes) == 0 {
+		objectTypes = stringSliceParam(params, "objectTypes")
+	}
+	limit := intParam(params, "limit")
+	offset := intParam(params, "offset")
+	if limit < 0 {
+		limit = 0
+	}
+	if offset < 0 {
+		offset = 0
+	}
+	return metadataListConstraints{
+		Filter:      stringParam(params, "filter"),
+		Limit:       limit,
+		Offset:      offset,
+		ObjectTypes: objectTypes,
+	}
+}
+
+func oracleListTablesQuery(schema string, constraints metadataListConstraints) oracleMetadataListQuery {
+	return oracleConstrainedMetadataListQuery(
+		oracleListTablesBaseSQL,
+		"OBJECT_NAME, TABLE_TYPE, COMMENTS",
+		"TABLE_TYPE",
+		oracleListTablesOrderSQL,
+		[]any{schema, schema},
+		constraints,
+	)
+}
+
+func oracleListSessionUserTablesQuery(constraints metadataListConstraints) oracleMetadataListQuery {
+	return oracleConstrainedMetadataListQuery(
+		oracleListTablesSessionUserBaseSQL,
+		"OBJECT_NAME, TABLE_TYPE, COMMENTS",
+		"TABLE_TYPE",
+		oracleListTablesOrderSQL,
+		nil,
+		constraints,
+	)
+}
+
+func oracleListObjectsQuery(schema string, constraints metadataListConstraints) oracleMetadataListQuery {
+	return oracleConstrainedMetadataListQuery(
+		oracleListObjectsBaseSQL,
+		"OBJECT_NAME, OBJECT_TYPE, COMMENTS",
+		"OBJECT_TYPE",
+		oracleListObjectsOrderSQL,
+		[]any{schema, schema},
+		constraints,
+	)
+}
+
+func oracleListSessionUserObjectsQuery(constraints metadataListConstraints) oracleMetadataListQuery {
+	return oracleConstrainedMetadataListQuery(
+		oracleListObjectsSessionUserBaseSQL,
+		"OBJECT_NAME, OBJECT_TYPE, COMMENTS",
+		"OBJECT_TYPE",
+		oracleListObjectsOrderSQL,
+		nil,
+		constraints,
+	)
+}
+
+func oracleConstrainedMetadataListQuery(baseSQL, selectList, typeColumn, orderSQL string, baseArgs []any, constraints metadataListConstraints) oracleMetadataListQuery {
+	args := append([]any{}, baseArgs...)
+	where := make([]string, 0, 2)
+	if filter := strings.TrimSpace(constraints.Filter); filter != "" {
+		args = append(args, strings.ToUpper(oracleFuzzyLikePattern(filter)))
+		where = append(where, fmt.Sprintf("UPPER(OBJECT_NAME) LIKE :%d ESCAPE '\\'", len(args)))
+	}
+	if objectTypes := normalizedMetadataObjectTypes(constraints.ObjectTypes); len(objectTypes) > 0 {
+		placeholders := make([]string, 0, len(objectTypes))
+		for _, objectType := range objectTypes {
+			args = append(args, objectType)
+			placeholders = append(placeholders, fmt.Sprintf(":%d", len(args)))
+		}
+		where = append(where, fmt.Sprintf("%s IN (%s)", typeColumn, strings.Join(placeholders, ",")))
+	}
+
+	sqlText := fmt.Sprintf("SELECT %s\nFROM (\n%s\n)", selectList, baseSQL)
+	if len(where) > 0 {
+		sqlText += "\nWHERE " + strings.Join(where, " AND ")
+	}
+	sqlText += "\n" + orderSQL
+
+	if constraints.Limit > 0 {
+		args = append(args, constraints.Offset+constraints.Limit)
+		maxRowParam := len(args)
+		args = append(args, constraints.Offset)
+		offsetParam := len(args)
+		sqlText = fmt.Sprintf(
+			"SELECT %s\nFROM (\n  SELECT DBX_Q.*, ROWNUM AS DBX_RN\n  FROM (\n%s\n  ) DBX_Q\n  WHERE ROWNUM <= :%d\n)\nWHERE DBX_RN > :%d",
+			selectList,
+			sqlText,
+			maxRowParam,
+			offsetParam,
+		)
+	} else if constraints.Offset > 0 {
+		args = append(args, constraints.Offset)
+		offsetParam := len(args)
+		sqlText = fmt.Sprintf(
+			"SELECT %s\nFROM (\n  SELECT DBX_Q.*, ROWNUM AS DBX_RN\n  FROM (\n%s\n  ) DBX_Q\n)\nWHERE DBX_RN > :%d",
+			selectList,
+			sqlText,
+			offsetParam,
+		)
+	}
+
+	return oracleMetadataListQuery{SQL: sqlText, Args: args}
+}
+
+func normalizedMetadataObjectTypes(values []string) []string {
+	seen := map[string]bool{}
+	result := make([]string, 0, len(values))
+	for _, value := range values {
+		normalized := strings.ToUpper(strings.TrimSpace(value))
+		normalized = strings.ReplaceAll(normalized, "-", "_")
+		normalized = strings.ReplaceAll(normalized, " ", "_")
+		if normalized == "" || seen[normalized] {
+			continue
+		}
+		seen[normalized] = true
+		result = append(result, normalized)
+	}
+	sort.Strings(result)
+	return result
+}
+
+func oracleFuzzyLikePattern(value string) string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return "%%"
+	}
+	var builder strings.Builder
+	builder.Grow(len(value)*2 + 2)
+	builder.WriteByte('%')
+	for _, ch := range value {
+		switch ch {
+		case '\\', '%', '_':
+			builder.WriteByte('\\')
+		}
+		builder.WriteRune(ch)
+		builder.WriteByte('%')
+	}
+	return builder.String()
+}
+
+func (s *server) listTables(schema string, constraints metadataListConstraints) ([]tableInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	query := oracleListTablesQuery(schema, constraints)
+	if s.schemaIsSessionUser(schema) {
+		query = oracleListSessionUserTablesQuery(constraints)
+	}
+	rows, err := s.queryRows(query.SQL, query.Args)
+	if err != nil {
+		if isOraclePGALimitError(err) {
+			return []tableInfo{}, nil
+		}
+		return nil, err
+	}
+	defer rows.Close()
+	var result []tableInfo
+	for rows.Next() {
+		var item tableInfo
+		if err := rows.Scan(&item.Name, &item.TableType, &item.Comment); err != nil {
+			return nil, err
+		}
+		result = append(result, item)
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func (s *server) listObjects(schema string, constraints metadataListConstraints) ([]objectInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	query := oracleListObjectsQuery(schema, constraints)
+	if s.schemaIsSessionUser(schema) {
+		query = oracleListSessionUserObjectsQuery(constraints)
+	}
+	rows, err := s.queryRows(query.SQL, query.Args)
+	if err != nil {
+		if isOraclePGALimitError(err) {
+			return []objectInfo{}, nil
+		}
+		return nil, err
+	}
+	defer rows.Close()
+	var result []objectInfo
+	for rows.Next() {
+		var item objectInfo
+		item.Schema = schema
+		if err := rows.Scan(&item.Name, &item.ObjectType, &item.Comment); err != nil {
+			return nil, err
+		}
+		result = append(result, item)
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func (s *server) getColumns(schema, table string) ([]columnInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	table = strings.ToUpper(strings.TrimSpace(table))
+	rows, err := s.queryRows(`
+SELECT c.COLUMN_NAME,
+       c.DATA_TYPE,
+       c.NULLABLE,
+       c.DATA_DEFAULT,
+       CASE WHEN pk.COLUMN_NAME IS NULL THEN 0 ELSE 1 END AS IS_PRIMARY_KEY,
+       cc.COMMENTS,
+       c.DATA_PRECISION,
+       c.DATA_SCALE,
+       c.CHAR_LENGTH
+FROM ALL_TAB_COLUMNS c
+LEFT JOIN (
+  SELECT acc.OWNER, acc.TABLE_NAME, acc.COLUMN_NAME
+  FROM ALL_CONSTRAINTS ac
+  JOIN ALL_CONS_COLUMNS acc ON acc.OWNER = ac.OWNER AND acc.CONSTRAINT_NAME = ac.CONSTRAINT_NAME
+  WHERE ac.CONSTRAINT_TYPE = 'P'
+) pk ON pk.OWNER = c.OWNER AND pk.TABLE_NAME = c.TABLE_NAME AND pk.COLUMN_NAME = c.COLUMN_NAME
+LEFT JOIN ALL_COL_COMMENTS cc ON cc.OWNER = c.OWNER AND cc.TABLE_NAME = c.TABLE_NAME AND cc.COLUMN_NAME = c.COLUMN_NAME
+WHERE c.OWNER = :1 AND c.TABLE_NAME = :2
+ORDER BY c.COLUMN_ID`, []any{schema, table})
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var result []columnInfo
+	for rows.Next() {
+		var item columnInfo
+		var nullable string
+		var primary int
+		if err := rows.Scan(
+			&item.Name,
+			&item.DataType,
+			&nullable,
+			&item.ColumnDefault,
+			&primary,
+			&item.Comment,
+			&item.NumericPrecision,
+			&item.NumericScale,
+			&item.CharacterMaximumLength,
+		); err != nil {
+			return nil, err
+		}
+		item.IsNullable = nullable == "Y"
+		item.IsPrimaryKey = primary != 0
+		item.DataType = oracleColumnTypeDDL(item)
+		result = append(result, item)
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func (s *server) loadOracleColumnMeta(schema, table string) ([]oracleColumnMeta, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	table = strings.ToUpper(strings.TrimSpace(table))
+	rows, err := s.queryRows(`
+SELECT COLUMN_NAME, DATA_TYPE
+FROM ALL_TAB_COLUMNS
+WHERE OWNER = :1 AND TABLE_NAME = :2
+ORDER BY COLUMN_ID`, []any{schema, table})
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var result []oracleColumnMeta
+	for rows.Next() {
+		var item oracleColumnMeta
+		if err := rows.Scan(&item.Name, &item.DataType); err != nil {
+			return nil, err
+		}
+		result = append(result, item)
+	}
+	return result, rows.Err()
+}
+
+func (s *server) listIndexes(schema, table string) ([]indexInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	table = strings.ToUpper(strings.TrimSpace(table))
+	rows, err := s.queryRows(`
+SELECT i.INDEX_NAME,
+       ic.COLUMN_NAME,
+       i.UNIQUENESS,
+       CASE WHEN pk.CONSTRAINT_NAME IS NULL THEN 0 ELSE 1 END AS IS_PRIMARY,
+       i.INDEX_TYPE,
+       ic.COLUMN_POSITION
+FROM ALL_INDEXES i
+JOIN ALL_IND_COLUMNS ic ON ic.INDEX_OWNER = i.OWNER AND ic.INDEX_NAME = i.INDEX_NAME
+LEFT JOIN ALL_CONSTRAINTS pk ON pk.OWNER = i.TABLE_OWNER
+  AND pk.TABLE_NAME = i.TABLE_NAME
+  AND pk.CONSTRAINT_TYPE = 'P'
+  AND pk.INDEX_NAME = i.INDEX_NAME
+WHERE i.TABLE_OWNER = :1 AND i.TABLE_NAME = :2
+ORDER BY i.INDEX_NAME, ic.COLUMN_POSITION`, []any{schema, table})
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	byName := map[string]*indexInfo{}
+	order := []string{}
+	for rows.Next() {
+		var name, column, uniqueness, indexType string
+		var primary int
+		var position int
+		if err := rows.Scan(&name, &column, &uniqueness, &primary, &indexType, &position); err != nil {
+			return nil, err
+		}
+		item := byName[name]
+		if item == nil {
+			item = &indexInfo{
+				Name:            name,
+				Columns:         []string{},
+				IsUnique:        uniqueness == "UNIQUE",
+				IsPrimary:       primary != 0,
+				IndexType:       &indexType,
+				IncludedColumns: []string{},
+			}
+			byName[name] = item
+			order = append(order, name)
+		}
+		item.Columns = append(item.Columns, column)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	result := make([]indexInfo, 0, len(order))
+	for _, name := range order {
+		result = append(result, *byName[name])
+	}
+	return emptyIfNil(result), nil
+}
+
+func (s *server) listForeignKeys(schema, table string) ([]foreignKeyInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	table = strings.ToUpper(strings.TrimSpace(table))
+	rows, err := s.queryRows(`
+SELECT ac.CONSTRAINT_NAME,
+       acc.COLUMN_NAME,
+       rcc.TABLE_NAME AS REF_TABLE,
+       rcc.COLUMN_NAME AS REF_COLUMN
+FROM ALL_CONSTRAINTS ac
+JOIN ALL_CONS_COLUMNS acc ON acc.OWNER = ac.OWNER AND acc.CONSTRAINT_NAME = ac.CONSTRAINT_NAME
+JOIN ALL_CONS_COLUMNS rcc ON rcc.OWNER = ac.R_OWNER AND rcc.CONSTRAINT_NAME = ac.R_CONSTRAINT_NAME
+  AND rcc.POSITION = acc.POSITION
+WHERE ac.OWNER = :1
+  AND ac.TABLE_NAME = :2
+  AND ac.CONSTRAINT_TYPE = 'R'
+ORDER BY ac.CONSTRAINT_NAME, acc.POSITION`, []any{schema, table})
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var result []foreignKeyInfo
+	for rows.Next() {
+		var item foreignKeyInfo
+		if err := rows.Scan(&item.Name, &item.Column, &item.RefTable, &item.RefColumn); err != nil {
+			return nil, err
+		}
+		result = append(result, item)
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func (s *server) listTriggers(schema, table string) ([]triggerInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	table = strings.ToUpper(strings.TrimSpace(table))
+	rows, err := s.queryRows(`
+SELECT TRIGGER_NAME, TRIGGERING_EVENT, TRIGGER_TYPE
+FROM ALL_TRIGGERS
+WHERE OWNER = :1 AND TABLE_NAME = :2
+ORDER BY TRIGGER_NAME`, []any{schema, table})
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var result []triggerInfo
+	for rows.Next() {
+		var item triggerInfo
+		if err := rows.Scan(&item.Name, &item.Event, &item.Timing); err != nil {
+			return nil, err
+		}
+		result = append(result, item)
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func (s *server) getObjectSource(schema, name, objectType string) (map[string]any, error) {
+	var err error
+	schema, err = s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	upperType := strings.ToUpper(objectType)
+	if upperType == "VIEW" {
+		// ALL_VIEWS.TEXT for views — ALL_SOURCE doesn't contain views, and
+		// DBMS_METADATA.GET_DDL fails on XE editions.
+		var source string
+		err = s.db.QueryRow(
+			"SELECT TEXT FROM ALL_VIEWS WHERE OWNER = :1 AND VIEW_NAME = :2",
+			schema, strings.ToUpper(name),
+		).Scan(&source)
+		if errors.Is(err, sql.ErrNoRows) {
+			return map[string]any{"name": name, "object_type": objectType, "schema": schema, "source": ""}, nil
+		}
+		if err != nil {
+			return nil, err
+		}
+		return map[string]any{"name": name, "object_type": objectType, "schema": schema, "source": source}, nil
+	}
+
+	rows, err := s.queryRows(`
+SELECT TEXT
+FROM ALL_SOURCE
+WHERE OWNER = :1 AND NAME = :2 AND TYPE = :3
+ORDER BY LINE`, []any{schema, strings.ToUpper(name), upperType})
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var builder strings.Builder
+	for rows.Next() {
+		var line string
+		if err := rows.Scan(&line); err != nil {
+			return nil, err
+		}
+		builder.WriteString(line)
+	}
+	return map[string]any{"name": name, "object_type": objectType, "schema": schema, "source": builder.String()}, rows.Err()
+}
+
+func (s *server) getTableDDL(schema, table, objectType string) (string, error) {
+	var err error
+	schema, err = s.normalizeSchema(schema)
+	if err != nil {
+		return "", err
+	}
+	db, err := s.requireDB()
+	if err != nil {
+		return "", err
+	}
+	objectType, err = s.resolveDDLObjectType(schema, table, objectType)
+	if err != nil {
+		return "", err
+	}
+	if objectType == "VIEW" {
+		return s.buildViewDDL(schema, table)
+	}
+	var ddl string
+	err = db.QueryRow("SELECT DBMS_METADATA.GET_DDL(:1, :2, :3) FROM DUAL", objectType, strings.ToUpper(table), schema).Scan(&ddl)
+	if err == nil && strings.TrimSpace(ddl) != "" {
+		return ddl, nil
+	}
+	if objectType == "TABLE" {
+		return s.buildTableDDL(schema, table)
+	}
+	return "", err
+}
+
+func (s *server) resolveDDLObjectType(schema, name, requested string) (string, error) {
+	objectType := normalizeDDLObjectType(requested)
+	if objectType != "" {
+		return objectType, nil
+	}
+	db, err := s.requireDB()
+	if err != nil {
+		return "", err
+	}
+	err = db.QueryRow(`
+SELECT OBJECT_TYPE
+FROM (
+  SELECT OBJECT_TYPE
+  FROM ALL_OBJECTS
+  WHERE OWNER = :1
+    AND OBJECT_NAME = :2
+    AND OBJECT_TYPE IN ('TABLE', 'VIEW', 'MATERIALIZED VIEW')
+  ORDER BY CASE OBJECT_TYPE WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 ELSE 2 END
+)
+WHERE ROWNUM = 1`, schema, strings.ToUpper(name)).Scan(&objectType)
+	if errors.Is(err, sql.ErrNoRows) {
+		return "", fmt.Errorf("object not found: %s.%s", schema, name)
+	}
+	if err != nil {
+		return "", err
+	}
+	return normalizeDDLObjectType(objectType), nil
+}
+
+func normalizeDDLObjectType(value string) string {
+	switch strings.ToUpper(strings.ReplaceAll(strings.TrimSpace(value), " ", "_")) {
+	case "TABLE":
+		return "TABLE"
+	case "VIEW":
+		return "VIEW"
+	case "MATERIALIZED_VIEW":
+		return "MATERIALIZED_VIEW"
+	default:
+		return ""
+	}
+}
+
+func (s *server) buildViewDDL(schema, name string) (string, error) {
+	db, err := s.requireDB()
+	if err != nil {
+		return "", err
+	}
+	var source string
+	err = db.QueryRow(
+		"SELECT TEXT FROM ALL_VIEWS WHERE OWNER = :1 AND VIEW_NAME = :2",
+		schema, strings.ToUpper(name),
+	).Scan(&source)
+	if errors.Is(err, sql.ErrNoRows) {
+		return "", fmt.Errorf("view not found: %s.%s", schema, name)
+	}
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("CREATE OR REPLACE VIEW %s.%s AS\n%s", quoteIdentifier(schema), quoteIdentifier(name), strings.TrimSpace(source)), nil
+}
+
+func (s *server) buildTableDDL(schema, table string) (string, error) {
+	columns, err := s.getColumns(schema, table)
+	if err != nil {
+		return "", err
+	}
+	if len(columns) == 0 {
+		return "", fmt.Errorf("table not found: %s.%s", schema, table)
+	}
+	var builder strings.Builder
+	builder.WriteString("CREATE TABLE ")
+	builder.WriteString(quoteIdentifier(schema))
+	builder.WriteByte('.')
+	builder.WriteString(quoteIdentifier(table))
+	builder.WriteString(" (\n")
+	for i, column := range columns {
+		if i > 0 {
+			builder.WriteString(",\n")
+		}
+		builder.WriteString("  ")
+		builder.WriteString(quoteIdentifier(column.Name))
+		builder.WriteByte(' ')
+		builder.WriteString(oracleColumnTypeDDL(column))
+		if column.ColumnDefault != nil && strings.TrimSpace(*column.ColumnDefault) != "" {
+			builder.WriteString(" DEFAULT ")
+			builder.WriteString(strings.TrimSpace(*column.ColumnDefault))
+		}
+		if !column.IsNullable {
+			builder.WriteString(" NOT NULL")
+		}
+	}
+	primary := make([]string, 0)
+	for _, column := range columns {
+		if column.IsPrimaryKey {
+			primary = append(primary, quoteIdentifier(column.Name))
+		}
+	}
+	if len(primary) > 0 {
+		builder.WriteString(",\n  PRIMARY KEY (")
+		builder.WriteString(strings.Join(primary, ", "))
+		builder.WriteByte(')')
+	}
+	builder.WriteString("\n)")
+	return builder.String(), nil
+}
+
+func oracleColumnTypeDDL(column columnInfo) string {
+	dataType := strings.ToUpper(strings.TrimSpace(column.DataType))
+	if dataType == "" {
+		return "VARCHAR2(4000)"
+	}
+	if strings.Contains(dataType, "(") {
+		return dataType
+	}
+	if isOracleCharacterType(dataType) && column.CharacterMaximumLength != nil && *column.CharacterMaximumLength > 0 {
+		return fmt.Sprintf("%s(%d)", dataType, *column.CharacterMaximumLength)
+	}
+	if dataType == "NUMBER" {
+		if column.NumericPrecision != nil && *column.NumericPrecision > 0 {
+			if column.NumericScale != nil && *column.NumericScale != 0 {
+				return fmt.Sprintf("NUMBER(%d,%d)", *column.NumericPrecision, *column.NumericScale)
+			}
+			return fmt.Sprintf("NUMBER(%d)", *column.NumericPrecision)
+		}
+		return "NUMBER"
+	}
+	if (dataType == "FLOAT" || dataType == "BINARY_FLOAT" || dataType == "BINARY_DOUBLE") &&
+		column.NumericPrecision != nil && *column.NumericPrecision > 0 {
+		return fmt.Sprintf("%s(%d)", dataType, *column.NumericPrecision)
+	}
+	return dataType
+}
+
+func isOracleCharacterType(dataType string) bool {
+	switch dataType {
+	case "CHAR", "VARCHAR2", "VARCHAR", "NCHAR", "NVARCHAR2", "RAW":
+		return true
+	default:
+		return false
+	}
+}
+
+func (s *server) getExplainInfo(sqlText, database, schema string, timeoutSecs int) (string, error) {
+	if strings.TrimSpace(sqlText) == "" {
+		return "", errors.New("sql is required")
+	}
+	db, err := s.requireDB()
+	if err != nil {
+		return "", err
+	}
+
+	ctx := context.Background()
+	var cancel context.CancelFunc
+	if timeoutSecs > 0 {
+		ctx, cancel = context.WithTimeout(ctx, time.Duration(timeoutSecs)*time.Second)
+	} else {
+		ctx, cancel = context.WithCancel(ctx)
+	}
+	defer cancel()
+
+	conn, err := db.Conn(ctx)
+	if err != nil {
+		return "", err
+	}
+	defer conn.Close()
+
+	targetSchema := strings.TrimSpace(schema)
+	if targetSchema == "" && !strings.EqualFold(strings.TrimSpace(database), strings.TrimSpace(s.params.Database)) {
+		targetSchema = strings.TrimSpace(database)
+	}
+	if targetSchema != "" {
+		var originalSchema string
+		if err := conn.QueryRowContext(ctx, "SELECT SYS_CONTEXT('USERENV', 'CURRENT_SCHEMA') FROM DUAL").Scan(&originalSchema); err != nil {
+			return "", err
+		}
+		if !strings.EqualFold(originalSchema, targetSchema) {
+			if _, err := conn.ExecContext(ctx, "ALTER SESSION SET CURRENT_SCHEMA = "+quoteIdentifier(targetSchema)); err != nil {
+				return "", err
+			}
+			defer restoreOracleCurrentSchema(conn, originalSchema)
+		}
+	}
+
+	statementID := "DBX_" + strings.ToUpper(strconv.FormatInt(time.Now().UnixNano(), 36))
+	defer cleanupOracleExplainPlan(conn, statementID)
+	statementSQL := trimStatementSQL(sqlText)
+	explainArgs := oracleExplainPlanBindArgs(statementSQL)
+	if _, err := conn.ExecContext(ctx, "EXPLAIN PLAN SET STATEMENT_ID = '"+statementID+"' FOR "+statementSQL, explainArgs...); err != nil {
+		return "", err
+	}
+	planRows, err := conn.QueryContext(
+		ctx,
+		"SELECT PLAN_TABLE_OUTPUT FROM TABLE(DBMS_XPLAN.DISPLAY('PLAN_TABLE', :1, 'TYPICAL +PREDICATE'))",
+		statementID,
+	)
+	if err != nil {
+		return "", err
+	}
+	defer planRows.Close()
+	var builder strings.Builder
+	for planRows.Next() {
+		var line string
+		if err := planRows.Scan(&line); err != nil {
+			return "", err
+		}
+		builder.WriteString(line)
+		builder.WriteByte('\n')
+	}
+	return strings.TrimSpace(builder.String()), planRows.Err()
+}
+
+func cleanupOracleExplainPlan(conn *sql.Conn, statementID string) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	_, _ = conn.ExecContext(ctx, "DELETE FROM PLAN_TABLE WHERE STATEMENT_ID = :1", statementID)
+}
+
+type oracleBindParam struct {
+	Name       string
+	Positional bool
+}
+
+func oracleExplainPlanBindArgs(sqlText string) []any {
+	params := oracleExplainPlanBindParams(sqlText)
+	args := make([]any, 0, len(params))
+	for _, param := range params {
+		if param.Positional {
+			args = append(args, nil)
+			continue
+		}
+		args = append(args, sql.Named(param.Name, nil))
+	}
+	return args
+}
+
+func oracleExplainPlanBindParams(sqlText string) []oracleBindParam {
+	params := make([]oracleBindParam, 0)
+	seenNamed := map[string]bool{}
+	for pos := 0; pos < len(sqlText); pos++ {
+		switch sqlText[pos] {
+		case '\'':
+			pos = skipSingleQuotedSQL(sqlText, pos)
+		case '"':
+			pos = skipDoubleQuotedSQL(sqlText, pos)
+		case 'q', 'Q':
+			if end, ok := skipOracleAlternativeQuotedSQL(sqlText, pos); ok {
+				pos = end
+			}
+		case '-':
+			if pos+1 < len(sqlText) && sqlText[pos+1] == '-' {
+				pos = skipLineCommentSQL(sqlText, pos)
+			}
+		case '/':
+			if pos+1 < len(sqlText) && sqlText[pos+1] == '*' {
+				pos = skipBlockCommentSQL(sqlText, pos)
+			}
+		case ':':
+			param, end, ok := readOracleBindParam(sqlText, pos)
+			if !ok {
+				continue
+			}
+			if param.Positional {
+				params = append(params, param)
+			} else if key := strings.ToUpper(param.Name); !seenNamed[key] {
+				seenNamed[key] = true
+				params = append(params, param)
+			}
+			pos = end - 1
+		}
+	}
+	return params
+}
+
+func readOracleBindParam(sqlText string, pos int) (oracleBindParam, int, bool) {
+	if pos < 0 || pos+1 >= len(sqlText) || sqlText[pos] != ':' {
+		return oracleBindParam{}, pos, false
+	}
+	if pos > 0 && sqlText[pos-1] == ':' {
+		return oracleBindParam{}, pos, false
+	}
+	next := sqlText[pos+1]
+	if next >= '0' && next <= '9' {
+		end := pos + 2
+		for end < len(sqlText) && sqlText[end] >= '0' && sqlText[end] <= '9' {
+			end++
+		}
+		return oracleBindParam{Name: sqlText[pos+1 : end], Positional: true}, end, true
+	}
+	if !isOracleIdentifierStart(next) {
+		return oracleBindParam{}, pos, false
+	}
+	end := pos + 2
+	for end < len(sqlText) && isOracleIdentifierPart(sqlText[end]) {
+		end++
+	}
+	return oracleBindParam{Name: sqlText[pos+1 : end]}, end, true
+}
+
+func restoreOracleCurrentSchema(conn *sql.Conn, schema string) {
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+	_, _ = conn.ExecContext(ctx, "ALTER SESSION SET CURRENT_SCHEMA = "+quoteIdentifier(schema))
+}
+
+func (s *server) executeTransaction(params map[string]json.RawMessage) (queryResult, error) {
+	var payload struct {
+		Statements []string `json:"statements"`
+		Schema     string   `json:"schema"`
+	}
+	if err := decodeParams(params, &payload); err != nil {
+		return queryResult{}, err
+	}
+	db, err := s.requireDB()
+	if err != nil {
+		return queryResult{}, err
+	}
+	tx, err := db.Begin()
+	if err != nil {
+		return queryResult{}, err
+	}
+	if strings.TrimSpace(payload.Schema) != "" {
+		if _, err := tx.Exec("ALTER SESSION SET CURRENT_SCHEMA = " + quoteIdentifier(payload.Schema)); err != nil {
+			tx.Rollback()
+			return queryResult{}, err
+		}
+	}
+	var affected int64
+	start := time.Now()
+	for _, statement := range payload.Statements {
+		statement = trimStatementSQL(statement)
+		if statement == "" {
+			continue
+		}
+		result, err := tx.Exec(statement)
+		if err != nil {
+			tx.Rollback()
+			return queryResult{}, err
+		}
+		count, _ := result.RowsAffected()
+		affected += count
+	}
+	if err := tx.Commit(); err != nil {
+		return queryResult{}, err
+	}
+	return queryResult{
+		Columns:         []string{},
+		Rows:            [][]any{},
+		AffectedRows:    affected,
+		ExecutionTimeMS: time.Since(start).Milliseconds(),
+	}, nil
+}
+
+func (s *server) executeQueryPage(opts queryOptions, pageSize int) (queryPageResult, error) {
+	start := time.Now()
+	if strings.TrimSpace(opts.Schema) != "" {
+		if err := s.setSchema(opts.Schema); err != nil {
+			return queryPageResult{}, err
+		}
+	}
+	sqlText := trimStatementSQL(opts.SQL)
+	if !isQuerySQL(sqlText) {
+		result, err := s.executeQuery(opts)
+		return queryPageResult{
+			Columns:         result.Columns,
+			ColumnTypes:     result.ColumnTypes,
+			Rows:            result.Rows,
+			AffectedRows:    result.AffectedRows,
+			ExecutionTimeMS: result.ExecutionTimeMS,
+			Truncated:       result.Truncated,
+			SessionID:       nil,
+			HasMore:         false,
+		}, err
+	}
+	rows, err := s.queryRowsWithXMLTypeRewriteIfNeeded(sqlText)
+	if err != nil {
+		return queryPageResult{}, err
+	}
+	columns, err := rows.Columns()
+	if err != nil {
+		rows.Close()
+		return queryPageResult{}, err
+	}
+	columnTypes := columnTypeNames(rows)
+	maxRows := opts.MaxRows
+	if maxRows <= 0 {
+		maxRows = defaultMaxRows
+	}
+	session := &querySession{rows: rows, columns: columns, columnTypes: columnTypes, remaining: maxRows}
+	result, err := readQuerySessionPage(session, pageSize)
+	result.ExecutionTimeMS = time.Since(start).Milliseconds()
+	if err != nil {
+		rows.Close()
+		return queryPageResult{}, err
+	}
+	if result.HasMore {
+		sessionID := s.storeQuerySession(session)
+		result.SessionID = &sessionID
+	} else {
+		rows.Close()
+	}
+	return result, nil
+}
+
+func (s *server) fetchQueryPage(sessionID string, pageSize int) (queryPageResult, error) {
+	session := s.sessions[sessionID]
+	if session == nil {
+		return queryPageResult{Columns: []string{}, ColumnTypes: []string{}, Rows: [][]any{}, SessionID: nil, HasMore: false}, nil
+	}
+	result, err := readQuerySessionPage(session, pageSize)
+	if err != nil {
+		s.closeQuerySession(sessionID)
+		return queryPageResult{}, err
+	}
+	if result.HasMore {
+		result.SessionID = &sessionID
+	} else {
+		s.closeQuerySession(sessionID)
+	}
+	return result, nil
+}
+
+func (s *server) storeQuerySession(session *querySession) string {
+	s.nextSessionID++
+	sessionID := fmt.Sprintf("oracle-go-%d", s.nextSessionID)
+	s.sessions[sessionID] = session
+	return sessionID
+}
+
+func (s *server) startTableRead(opts queryOptions, pageSize int) (queryPageResult, error) {
+	start := time.Now()
+	if strings.TrimSpace(opts.Schema) != "" {
+		if err := s.setSchema(opts.Schema); err != nil {
+			return queryPageResult{}, err
+		}
+	}
+	sqlText := trimStatementSQL(opts.SQL)
+	if !isQuerySQL(sqlText) {
+		return queryPageResult{}, errors.New("table read requires a SELECT query")
+	}
+	rows, err := s.queryRowsWithXMLTypeRewriteIfNeeded(sqlText)
+	if err != nil {
+		return queryPageResult{}, err
+	}
+	columns, err := rows.Columns()
+	if err != nil {
+		rows.Close()
+		return queryPageResult{}, err
+	}
+	columnTypes := columnTypeNames(rows)
+	maxRows := opts.MaxRows
+	if maxRows <= 0 {
+		maxRows = defaultMaxRows
+	}
+	session := &querySession{rows: rows, columns: columns, columnTypes: columnTypes, remaining: maxRows}
+	result, err := readQuerySessionPage(session, pageSize)
+	result.ExecutionTimeMS = time.Since(start).Milliseconds()
+	if err != nil {
+		rows.Close()
+		return queryPageResult{}, err
+	}
+	if result.HasMore {
+		sessionID := s.storeTableReadSession(session)
+		result.SessionID = &sessionID
+	} else {
+		rows.Close()
+	}
+	return result, nil
+}
+
+func (s *server) fetchTableReadPage(sessionID string, pageSize int) (queryPageResult, error) {
+	session := s.tableReadSessions[sessionID]
+	if session == nil {
+		return queryPageResult{Columns: []string{}, ColumnTypes: []string{}, Rows: [][]any{}, SessionID: nil, HasMore: false}, nil
+	}
+	result, err := readQuerySessionPage(session, pageSize)
+	if err != nil {
+		s.closeTableReadSession(sessionID)
+		return queryPageResult{}, err
+	}
+	if result.HasMore {
+		result.SessionID = &sessionID
+	} else {
+		s.closeTableReadSession(sessionID)
+	}
+	return result, nil
+}
+
+func (s *server) storeTableReadSession(session *querySession) string {
+	s.nextTableReadSessionID++
+	sessionID := fmt.Sprintf("oracle-go-table-%d", s.nextTableReadSessionID)
+	s.tableReadSessions[sessionID] = session
+	return sessionID
+}
+
+func (s *server) closeQuerySession(sessionID string) bool {
+	session := s.sessions[sessionID]
+	if session == nil {
+		return false
+	}
+	session.rows.Close()
+	delete(s.sessions, sessionID)
+	return true
+}
+
+func (s *server) closeTableReadSession(sessionID string) bool {
+	session := s.tableReadSessions[sessionID]
+	if session == nil {
+		return false
+	}
+	session.rows.Close()
+	delete(s.tableReadSessions, sessionID)
+	return true
+}
+
+func (s *server) closeAllQuerySessions() {
+	for sessionID := range s.sessions {
+		s.closeQuerySession(sessionID)
+	}
+	for sessionID := range s.tableReadSessions {
+		s.closeTableReadSession(sessionID)
+	}
+}
+
+func readQuerySessionPage(session *querySession, pageSize int) (queryPageResult, error) {
+	if pageSize <= 0 {
+		pageSize = defaultMaxRows
+	}
+	result := queryPageResult{Columns: session.columns, ColumnTypes: session.columnTypes, Rows: [][]any{}, SessionID: nil, HasMore: false}
+	for len(result.Rows) < pageSize && session.remaining > 0 {
+		if session.pending != nil {
+			result.Rows = append(result.Rows, session.pending)
+			session.pending = nil
+			session.remaining--
+			continue
+		}
+		if !session.rows.Next() {
+			return result, session.rows.Err()
+		}
+		row, err := scanRow(session.rows, len(session.columns), session.columnTypes)
+		if err != nil {
+			return queryPageResult{}, err
+		}
+		result.Rows = append(result.Rows, row)
+		session.remaining--
+	}
+	if session.remaining <= 0 {
+		result.Truncated = true
+		return result, nil
+	}
+	if session.rows.Next() {
+		row, err := scanRow(session.rows, len(session.columns), session.columnTypes)
+		if err != nil {
+			return queryPageResult{}, err
+		}
+		session.pending = row
+		result.HasMore = true
+		return result, nil
+	}
+	return result, session.rows.Err()
+}
+
+func (s *server) executeQuery(opts queryOptions) (queryResult, error) {
+	start := time.Now()
+	if strings.TrimSpace(opts.Schema) != "" {
+		if err := s.setSchema(opts.Schema); err != nil {
+			return queryResult{}, err
+		}
+	}
+	sqlText := trimStatementSQL(opts.SQL)
+	maxRows := opts.MaxRows
+	if maxRows <= 0 {
+		maxRows = defaultMaxRows
+	}
+	if isQuerySQL(sqlText) {
+		result, err := s.executeSelect(sqlText, maxRows)
+		result.ExecutionTimeMS = time.Since(start).Milliseconds()
+		return result, err
+	}
+	db, err := s.requireDB()
+	if err != nil {
+		return queryResult{}, err
+	}
+	execResult, err := db.Exec(sqlText)
+	if err != nil {
+		return queryResult{}, err
+	}
+	affected, _ := execResult.RowsAffected()
+	return queryResult{Columns: []string{}, ColumnTypes: []string{}, Rows: [][]any{}, AffectedRows: affected, ExecutionTimeMS: time.Since(start).Milliseconds()}, nil
+}
+
+func (s *server) executeSelect(sqlText string, maxRows int) (queryResult, error) {
+	rows, err := s.queryRowsWithXMLTypeRewriteIfNeeded(sqlText)
+	if err != nil {
+		return queryResult{}, err
+	}
+	defer rows.Close()
+	columns, err := rows.Columns()
+	if err != nil {
+		return queryResult{}, err
+	}
+	columnTypes := columnTypeNames(rows)
+	result := queryResult{Columns: columns, ColumnTypes: columnTypes, Rows: [][]any{}}
+	for rows.Next() {
+		if len(result.Rows) >= maxRows {
+			result.Truncated = true
+			break
+		}
+		values, err := scanRow(rows, len(columns), columnTypes)
+		if err != nil {
+			return queryResult{}, err
+		}
+		result.Rows = append(result.Rows, values)
+	}
+	return result, rows.Err()
+}
+
+func scanRow(rows *sql.Rows, columnCount int, columnTypes []string) ([]any, error) {
+	values := make([]any, columnCount)
+	scanTargets := make([]any, columnCount)
+	for i := range values {
+		scanTargets[i] = &values[i]
+	}
+	if err := rows.Scan(scanTargets...); err != nil {
+		return nil, err
+	}
+	for i, value := range values {
+		values[i] = normalizeValue(value, columnTypeAt(columnTypes, i))
+	}
+	return values, nil
+}
+
+func columnTypeAt(columnTypes []string, index int) string {
+	if index < 0 || index >= len(columnTypes) {
+		return ""
+	}
+	return columnTypes[index]
+}
+
+func columnTypeNames(rows *sql.Rows) []string {
+	types, err := rows.ColumnTypes()
+	if err != nil {
+		return []string{}
+	}
+	result := make([]string, 0, len(types))
+	for _, columnType := range types {
+		result = append(result, columnType.DatabaseTypeName())
+	}
+	return result
+}
+
+func (s *server) queryRowsWithXMLTypeRewriteIfNeeded(sqlText string) (*sql.Rows, error) {
+	rows, err := s.queryRows(sqlText, nil)
+	if err != nil {
+		return nil, err
+	}
+	if !rowsContainOracleXMLType(rows) {
+		return rows, nil
+	}
+	rewritten, err := s.rewriteXMLTypeSelectSQL(sqlText)
+	if err != nil {
+		rows.Close()
+		return nil, err
+	}
+	if rewritten == sqlText {
+		return rows, nil
+	}
+	// Only pay the ALL_TAB_COLUMNS rewrite cost when the result metadata shows
+	// XMLTYPE. Ordinary Oracle queries should not run dictionary probes first.
+	rows.Close()
+	return s.queryRows(rewritten, nil)
+}
+
+func rowsContainOracleXMLType(rows *sql.Rows) bool {
+	types, err := rows.ColumnTypes()
+	if err != nil {
+		return false
+	}
+	typeNames := make([]string, 0, len(types))
+	for _, columnType := range types {
+		typeNames = append(typeNames, columnType.DatabaseTypeName())
+	}
+	return oracleColumnTypeNamesContainXMLType(typeNames)
+}
+
+func oracleColumnTypeNamesContainXMLType(typeNames []string) bool {
+	for _, typeName := range typeNames {
+		if isOracleXMLType(typeName) {
+			return true
+		}
+	}
+	return false
+}
+
+func (s *server) rewriteXMLTypeSelectSQL(sqlText string) (string, error) {
+	return rewriteOracleXMLTypeSelectSQL(sqlText, s.loadOracleColumnMeta)
+}
+
+func rewriteOracleXMLTypeSelectSQL(sqlText string, loadColumns oracleColumnMetaLoader) (string, error) {
+	rewritten, _, err := rewriteOracleXMLTypeSelectSQLDepth(sqlText, loadColumns, 0)
+	return rewritten, err
+}
+
+func rewriteOracleXMLTypeSelectSQLDepth(sqlText string, loadColumns oracleColumnMetaLoader, depth int) (string, bool, error) {
+	if depth > 8 {
+		return sqlText, false, nil
+	}
+	if rewritten, changed, handled, err := rewriteDirectOracleXMLTypeSelectSQL(sqlText, loadColumns); handled || err != nil {
+		return rewritten, changed, err
+	}
+	rewritten, changed, err := rewriteNestedOracleSelects(sqlText, loadColumns, depth)
+	return rewritten, changed, err
+}
+
+func rewriteNestedOracleSelects(sqlText string, loadColumns oracleColumnMetaLoader, depth int) (string, bool, error) {
+	var builder strings.Builder
+	changed := false
+	last := 0
+	for pos := 0; pos < len(sqlText); pos++ {
+		switch sqlText[pos] {
+		case '\'':
+			pos = skipSingleQuotedSQL(sqlText, pos)
+		case '"':
+			pos = skipDoubleQuotedSQL(sqlText, pos)
+		case '-':
+			if pos+1 < len(sqlText) && sqlText[pos+1] == '-' {
+				pos = skipLineCommentSQL(sqlText, pos)
+			}
+		case '/':
+			if pos+1 < len(sqlText) && sqlText[pos+1] == '*' {
+				pos = skipBlockCommentSQL(sqlText, pos)
+			}
+		case '(':
+			end := findMatchingSQLParen(sqlText, pos)
+			if end < 0 {
+				return sqlText, false, nil
+			}
+			inner := sqlText[pos+1 : end]
+			if startsWithSQLKeyword(trimLeadingSQLComments(inner), "select") {
+				rewrittenInner, innerChanged, err := rewriteOracleXMLTypeSelectSQLDepth(inner, loadColumns, depth+1)
+				if err != nil {
+					return "", false, err
+				}
+				if innerChanged {
+					builder.WriteString(sqlText[last : pos+1])
+					builder.WriteString(rewrittenInner)
+					last = end
+					changed = true
+				}
+			}
+			pos = end
+		}
+	}
+	if !changed {
+		return sqlText, false, nil
+	}
+	builder.WriteString(sqlText[last:])
+	return builder.String(), true, nil
+}
+
+func rewriteDirectOracleXMLTypeSelectSQL(sqlText string, loadColumns oracleColumnMetaLoader) (string, bool, bool, error) {
+	selectStart := leadingSQLSelectListStart(sqlText)
+	if selectStart < 0 {
+		return sqlText, false, false, nil
+	}
+	fromIdx := findTopLevelSQLKeyword(sqlText, selectStart, "from")
+	if fromIdx < 0 {
+		return sqlText, false, false, nil
+	}
+	selectListPrefix, selectList := splitOracleSelectListModifier(sqlText[selectStart:fromIdx])
+	tableRef, ok := parseSingleOracleTableRef(sqlText[fromIdx+len("from"):])
+	if !ok {
+		return sqlText, false, false, nil
+	}
+	items := splitTopLevelSQLList(selectList)
+	if len(items) == 0 || !oracleSelectListMayReferenceXMLType(items) {
+		return sqlText, false, true, nil
+	}
+	columns, err := loadColumns(tableRef.Schema, tableRef.Table)
+	if err != nil {
+		return "", false, true, err
+	}
+	if !oracleColumnsHaveXMLType(columns) {
+		return sqlText, false, true, nil
+	}
+	rewrittenItems, changed := rewriteOracleSelectItemsForXMLType(items, columns, tableRef)
+	if !changed {
+		return sqlText, false, true, nil
+	}
+	var builder strings.Builder
+	builder.WriteString(sqlText[:selectStart])
+	builder.WriteString(selectListPrefix)
+	builder.WriteString(strings.Join(rewrittenItems, ", "))
+	builder.WriteByte(' ')
+	builder.WriteString(sqlText[fromIdx:])
+	return builder.String(), true, true, nil
+}
+
+type oracleTableRef struct {
+	Schema    string
+	Table     string
+	Alias     string
+	AliasText string
+}
+
+type oracleIdentifierToken struct {
+	Name   string
+	Text   string
+	Quoted bool
+}
+
+func parseSingleOracleTableRef(fromSQL string) (oracleTableRef, bool) {
+	pos := skipSQLWhitespace(fromSQL, 0)
+	if pos >= len(fromSQL) || fromSQL[pos] == '(' {
+		return oracleTableRef{}, false
+	}
+	first, next, ok := readOracleIdentifierToken(fromSQL, pos)
+	if !ok {
+		return oracleTableRef{}, false
+	}
+	ref := oracleTableRef{Table: first.Name}
+	pos = skipSQLWhitespace(fromSQL, next)
+	if pos < len(fromSQL) && fromSQL[pos] == '.' {
+		second, afterSecond, ok := readOracleIdentifierToken(fromSQL, skipSQLWhitespace(fromSQL, pos+1))
+		if !ok {
+			return oracleTableRef{}, false
+		}
+		ref.Schema = first.Name
+		ref.Table = second.Name
+		pos = skipSQLWhitespace(fromSQL, afterSecond)
+	}
+	if pos < len(fromSQL) {
+		if strings.HasPrefix(strings.TrimLeft(fromSQL[pos:], " \t\r\n"), ",") {
+			return oracleTableRef{}, false
+		}
+		if nextKeywordIsOracleClause(fromSQL[pos:]) {
+			return ref, true
+		}
+		if startsWithSQLKeyword(fromSQL[pos:], "join") ||
+			startsWithSQLKeyword(fromSQL[pos:], "inner") ||
+			startsWithSQLKeyword(fromSQL[pos:], "left") ||
+			startsWithSQLKeyword(fromSQL[pos:], "right") ||
+			startsWithSQLKeyword(fromSQL[pos:], "full") ||
+			startsWithSQLKeyword(fromSQL[pos:], "cross") {
+			return oracleTableRef{}, false
+		}
+		alias, afterAlias, ok := readOracleIdentifierToken(fromSQL, pos)
+		if ok && !oracleIdentifierIsClause(alias.Name) {
+			ref.Alias = alias.Name
+			ref.AliasText = alias.Text
+			pos = skipSQLWhitespace(fromSQL, afterAlias)
+		}
+		if strings.HasPrefix(strings.TrimLeft(fromSQL[pos:], " \t\r\n"), ",") ||
+			startsWithSQLKeyword(fromSQL[pos:], "join") ||
+			startsWithSQLKeyword(fromSQL[pos:], "inner") ||
+			startsWithSQLKeyword(fromSQL[pos:], "left") ||
+			startsWithSQLKeyword(fromSQL[pos:], "right") ||
+			startsWithSQLKeyword(fromSQL[pos:], "full") ||
+			startsWithSQLKeyword(fromSQL[pos:], "cross") {
+			return oracleTableRef{}, false
+		}
+	}
+	return ref, true
+}
+
+func splitOracleSelectListModifier(selectList string) (string, string) {
+	trimmedLeft := strings.TrimLeft(selectList, " \t\r\n")
+	prefixLen := len(selectList) - len(trimmedLeft)
+	for _, keyword := range []string{"distinct", "all"} {
+		if startsWithSQLKeyword(trimmedLeft, keyword) {
+			modifierEnd := prefixLen + len(keyword)
+			for modifierEnd < len(selectList) && isSQLWhitespace(selectList[modifierEnd]) {
+				modifierEnd++
+			}
+			return selectList[:modifierEnd], selectList[modifierEnd:]
+		}
+	}
+	return selectList[:prefixLen], selectList[prefixLen:]
+}
+
+func oracleSelectListMayReferenceXMLType(items []string) bool {
+	for _, item := range items {
+		if _, ok := parseOracleStarSelectItem(item); ok {
+			return true
+		}
+		if _, _, _, ok := parseOracleColumnSelectItem(item); ok {
+			return true
+		}
+	}
+	return false
+}
+
+func rewriteOracleSelectItemsForXMLType(items []string, columns []oracleColumnMeta, tableRef oracleTableRef) ([]string, bool) {
+	xmlColumns := map[string]oracleColumnMeta{}
+	for _, column := range columns {
+		if isOracleXMLType(column.DataType) {
+			xmlColumns[oracleIdentifierKey(column.Name)] = column
+		}
+	}
+	rewritten := make([]string, 0, len(items))
+	changed := false
+	for _, item := range items {
+		if qualifier, ok := parseOracleStarSelectItem(item); ok && oracleQualifierMatchesTable(qualifier, tableRef) {
+			for _, column := range columns {
+				rewritten = append(rewritten, oracleSelectExpressionForColumn(column, tableRef, xmlColumns))
+			}
+			changed = true
+			continue
+		}
+		qualifier, column, alias, ok := parseOracleColumnSelectItem(item)
+		if ok && oracleQualifierMatchesTable(qualifier, tableRef) {
+			if meta, isXML := xmlColumns[oracleIdentifierKey(column.Name)]; isXML {
+				outputAlias := alias
+				if outputAlias == "" {
+					outputAlias = quoteIdentifier(meta.Name)
+				}
+				rewritten = append(rewritten, oracleXMLSerializeExpression(oracleColumnRef(qualifier, meta.Name), outputAlias))
+				changed = true
+				continue
+			}
+		}
+		rewritten = append(rewritten, item)
+	}
+	return rewritten, changed
+}
+
+func oracleSelectExpressionForColumn(column oracleColumnMeta, tableRef oracleTableRef, xmlColumns map[string]oracleColumnMeta) string {
+	qualifier := ""
+	if tableRef.AliasText != "" {
+		qualifier = tableRef.AliasText
+	}
+	if _, isXML := xmlColumns[oracleIdentifierKey(column.Name)]; isXML {
+		return oracleXMLSerializeExpression(oracleColumnRef(qualifier, column.Name), quoteIdentifier(column.Name))
+	}
+	return oracleColumnRef(qualifier, column.Name)
+}
+
+func oracleXMLSerializeExpression(columnRef, alias string) string {
+	// go-ora v2.9.0 does not fully decode Oracle XMLTYPE result payloads,
+	// especially when 11g switches larger values to locator-based transfer.
+	return fmt.Sprintf("XMLSERIALIZE(CONTENT %s AS CLOB) AS %s", columnRef, alias)
+}
+
+func oracleColumnRef(qualifier, column string) string {
+	if strings.TrimSpace(qualifier) == "" {
+		return quoteIdentifier(column)
+	}
+	return qualifier + "." + quoteIdentifier(column)
+}
+
+func parseOracleStarSelectItem(item string) (string, bool) {
+	trimmed := strings.TrimSpace(item)
+	if trimmed == "*" {
+		return "", true
+	}
+	qualifier, pos, ok := readOracleIdentifierToken(trimmed, 0)
+	if !ok {
+		return "", false
+	}
+	pos = skipSQLWhitespace(trimmed, pos)
+	if pos >= len(trimmed) || trimmed[pos] != '.' {
+		return "", false
+	}
+	pos = skipSQLWhitespace(trimmed, pos+1)
+	if pos < len(trimmed) && trimmed[pos] == '*' && strings.TrimSpace(trimmed[pos+1:]) == "" {
+		return qualifier.Text, true
+	}
+	return "", false
+}
+
+func parseOracleColumnSelectItem(item string) (qualifier string, column oracleIdentifierToken, alias string, ok bool) {
+	trimmed := strings.TrimSpace(item)
+	first, pos, ok := readOracleIdentifierToken(trimmed, 0)
+	if !ok {
+		return "", oracleIdentifierToken{}, "", false
+	}
+	column = first
+	pos = skipSQLWhitespace(trimmed, pos)
+	if pos < len(trimmed) && trimmed[pos] == '.' {
+		second, afterSecond, ok := readOracleIdentifierToken(trimmed, skipSQLWhitespace(trimmed, pos+1))
+		if !ok {
+			return "", oracleIdentifierToken{}, "", false
+		}
+		qualifier = first.Text
+		column = second
+		pos = skipSQLWhitespace(trimmed, afterSecond)
+	}
+	if pos >= len(trimmed) {
+		return qualifier, column, "", true
+	}
+	if startsWithSQLKeyword(trimmed[pos:], "as") {
+		aliasToken, afterAlias, ok := readOracleIdentifierToken(trimmed, skipSQLWhitespace(trimmed, pos+len("as")))
+		if !ok || strings.TrimSpace(trimmed[afterAlias:]) != "" {
+			return "", oracleIdentifierToken{}, "", false
+		}
+		return qualifier, column, aliasToken.Text, true
+	}
+	aliasToken, afterAlias, ok := readOracleIdentifierToken(trimmed, pos)
+	if !ok || strings.TrimSpace(trimmed[afterAlias:]) != "" {
+		return "", oracleIdentifierToken{}, "", false
+	}
+	return qualifier, column, aliasToken.Text, true
+}
+
+func oracleQualifierMatchesTable(qualifier string, tableRef oracleTableRef) bool {
+	if strings.TrimSpace(qualifier) == "" {
+		return true
+	}
+	key := oracleIdentifierKey(unquoteOracleIdentifierText(qualifier))
+	if tableRef.Alias != "" && key == oracleIdentifierKey(tableRef.Alias) {
+		return true
+	}
+	return key == oracleIdentifierKey(tableRef.Table)
+}
+
+func oracleColumnsHaveXMLType(columns []oracleColumnMeta) bool {
+	for _, column := range columns {
+		if isOracleXMLType(column.DataType) {
+			return true
+		}
+	}
+	return false
+}
+
+func isOracleXMLType(dataType string) bool {
+	normalized := strings.ToUpper(strings.TrimSpace(dataType))
+	return normalized == "XMLTYPE" || normalized == "SYS.XMLTYPE"
+}
+
+func leadingSQLSelectListStart(sqlText string) int {
+	trimmed := trimLeadingSQLComments(sqlText)
+	prefixLen := len(sqlText) - len(trimmed)
+	if !startsWithSQLKeyword(trimmed, "select") {
+		return -1
+	}
+	return prefixLen + len("select")
+}
+
+func splitTopLevelSQLList(value string) []string {
+	var result []string
+	start := 0
+	depth := 0
+	for pos := 0; pos < len(value); pos++ {
+		switch value[pos] {
+		case '\'':
+			pos = skipSingleQuotedSQL(value, pos)
+		case '"':
+			pos = skipDoubleQuotedSQL(value, pos)
+		case '-':
+			if pos+1 < len(value) && value[pos+1] == '-' {
+				pos = skipLineCommentSQL(value, pos)
+			}
+		case '/':
+			if pos+1 < len(value) && value[pos+1] == '*' {
+				pos = skipBlockCommentSQL(value, pos)
+			}
+		case '(':
+			depth++
+		case ')':
+			if depth > 0 {
+				depth--
+			}
+		case ',':
+			if depth == 0 {
+				result = append(result, strings.TrimSpace(value[start:pos]))
+				start = pos + 1
+			}
+		}
+	}
+	tail := strings.TrimSpace(value[start:])
+	if tail != "" {
+		result = append(result, tail)
+	}
+	return result
+}
+
+func findTopLevelSQLKeyword(sqlText string, start int, keyword string) int {
+	depth := 0
+	for pos := start; pos < len(sqlText); pos++ {
+		switch sqlText[pos] {
+		case '\'':
+			pos = skipSingleQuotedSQL(sqlText, pos)
+		case '"':
+			pos = skipDoubleQuotedSQL(sqlText, pos)
+		case '-':
+			if pos+1 < len(sqlText) && sqlText[pos+1] == '-' {
+				pos = skipLineCommentSQL(sqlText, pos)
+			}
+		case '/':
+			if pos+1 < len(sqlText) && sqlText[pos+1] == '*' {
+				pos = skipBlockCommentSQL(sqlText, pos)
+			}
+		case '(':
+			depth++
+		case ')':
+			if depth > 0 {
+				depth--
+			}
+		default:
+			if depth == 0 && sqlKeywordAt(sqlText, pos, keyword) {
+				return pos
+			}
+		}
+	}
+	return -1
+}
+
+func findMatchingSQLParen(sqlText string, open int) int {
+	depth := 0
+	for pos := open; pos < len(sqlText); pos++ {
+		switch sqlText[pos] {
+		case '\'':
+			pos = skipSingleQuotedSQL(sqlText, pos)
+		case '"':
+			pos = skipDoubleQuotedSQL(sqlText, pos)
+		case '-':
+			if pos+1 < len(sqlText) && sqlText[pos+1] == '-' {
+				pos = skipLineCommentSQL(sqlText, pos)
+			}
+		case '/':
+			if pos+1 < len(sqlText) && sqlText[pos+1] == '*' {
+				pos = skipBlockCommentSQL(sqlText, pos)
+			}
+		case '(':
+			depth++
+		case ')':
+			depth--
+			if depth == 0 {
+				return pos
+			}
+		}
+	}
+	return -1
+}
+
+func readOracleIdentifierToken(value string, pos int) (oracleIdentifierToken, int, bool) {
+	pos = skipSQLWhitespace(value, pos)
+	if pos >= len(value) {
+		return oracleIdentifierToken{}, pos, false
+	}
+	if value[pos] == '"' {
+		end := pos + 1
+		var builder strings.Builder
+		for end < len(value) {
+			if value[end] == '"' {
+				if end+1 < len(value) && value[end+1] == '"' {
+					builder.WriteByte('"')
+					end += 2
+					continue
+				}
+				return oracleIdentifierToken{Name: builder.String(), Text: value[pos : end+1], Quoted: true}, end + 1, true
+			}
+			builder.WriteByte(value[end])
+			end++
+		}
+		return oracleIdentifierToken{}, pos, false
+	}
+	if !isOracleIdentifierStart(value[pos]) {
+		return oracleIdentifierToken{}, pos, false
+	}
+	end := pos + 1
+	for end < len(value) && isOracleIdentifierPart(value[end]) {
+		end++
+	}
+	text := value[pos:end]
+	return oracleIdentifierToken{Name: strings.ToUpper(text), Text: text}, end, true
+}
+
+func unquoteOracleIdentifierText(value string) string {
+	value = strings.TrimSpace(value)
+	if len(value) >= 2 && value[0] == '"' && value[len(value)-1] == '"' {
+		return strings.ReplaceAll(value[1:len(value)-1], `""`, `"`)
+	}
+	return strings.ToUpper(value)
+}
+
+func oracleIdentifierKey(value string) string {
+	return strings.ToUpper(strings.TrimSpace(value))
+}
+
+func oracleIdentifierIsClause(value string) bool {
+	switch oracleIdentifierKey(value) {
+	case "WHERE", "GROUP", "ORDER", "HAVING", "CONNECT", "START", "MODEL", "FETCH", "OFFSET", "UNION", "MINUS", "INTERSECT":
+		return true
+	default:
+		return false
+	}
+}
+
+func nextKeywordIsOracleClause(value string) bool {
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return true
+	}
+	token, _, ok := readOracleIdentifierToken(trimmed, 0)
+	return ok && oracleIdentifierIsClause(token.Name)
+}
+
+func isOracleIdentifierStart(ch byte) bool {
+	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_' || ch == '$' || ch == '#'
+}
+
+func isOracleIdentifierPart(ch byte) bool {
+	return isOracleIdentifierStart(ch) || (ch >= '0' && ch <= '9')
+}
+
+func skipSQLWhitespace(value string, pos int) int {
+	for pos < len(value) && isSQLWhitespace(value[pos]) {
+		pos++
+	}
+	return pos
+}
+
+func isSQLWhitespace(ch byte) bool {
+	return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n'
+}
+
+func skipSingleQuotedSQL(value string, pos int) int {
+	pos++
+	for pos < len(value) {
+		if value[pos] == '\'' {
+			if pos+1 < len(value) && value[pos+1] == '\'' {
+				pos += 2
+				continue
+			}
+			return pos
+		}
+		pos++
+	}
+	return len(value) - 1
+}
+
+func skipOracleAlternativeQuotedSQL(value string, pos int) (int, bool) {
+	if pos+2 >= len(value) || (value[pos] != 'q' && value[pos] != 'Q') || value[pos+1] != '\'' {
+		return pos, false
+	}
+	open := value[pos+2]
+	close := open
+	switch open {
+	case '[':
+		close = ']'
+	case '{':
+		close = '}'
+	case '(':
+		close = ')'
+	case '<':
+		close = '>'
+	}
+	for end := pos + 3; end+1 < len(value); end++ {
+		if value[end] == close && value[end+1] == '\'' {
+			return end + 1, true
+		}
+	}
+	return len(value) - 1, true
+}
+
+func skipDoubleQuotedSQL(value string, pos int) int {
+	pos++
+	for pos < len(value) {
+		if value[pos] == '"' {
+			if pos+1 < len(value) && value[pos+1] == '"' {
+				pos += 2
+				continue
+			}
+			return pos
+		}
+		pos++
+	}
+	return len(value) - 1
+}
+
+func skipLineCommentSQL(value string, pos int) int {
+	for pos < len(value) {
+		if value[pos] == '\n' || value[pos] == '\r' {
+			return pos
+		}
+		pos++
+	}
+	return len(value) - 1
+}
+
+func skipBlockCommentSQL(value string, pos int) int {
+	end := strings.Index(value[pos+2:], "*/")
+	if end < 0 {
+		return len(value) - 1
+	}
+	return pos + end + 3
+}
+
+func (s *server) setSchema(schema string) error {
+	db, err := s.requireDB()
+	if err != nil {
+		return err
+	}
+	_, err = db.Exec("ALTER SESSION SET CURRENT_SCHEMA = " + quoteIdentifier(schema))
+	return err
+}
+
+func (s *server) queryRows(sqlText string, args []any) (*sql.Rows, error) {
+	db, err := s.requireDB()
+	if err != nil {
+		return nil, err
+	}
+	if len(args) == 0 {
+		return db.Query(sqlText)
+	}
+	return db.Query(sqlText, args...)
+}
+
+func decodeParams(params map[string]json.RawMessage, target any) error {
+	if params == nil {
+		params = map[string]json.RawMessage{}
+	}
+	data, err := json.Marshal(params)
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(data, target)
+}
+
+func stringParam(params map[string]json.RawMessage, key string) string {
+	if params == nil || len(params[key]) == 0 {
+		return ""
+	}
+	var value string
+	_ = json.Unmarshal(params[key], &value)
+	return value
+}
+
+func stringSliceParam(params map[string]json.RawMessage, key string) []string {
+	if params == nil || len(params[key]) == 0 {
+		return nil
+	}
+	var value []string
+	if err := json.Unmarshal(params[key], &value); err != nil {
+		return nil
+	}
+	return value
+}
+
+func intParam(params map[string]json.RawMessage, key string) int {
+	if params == nil || len(params[key]) == 0 {
+		return 0
+	}
+	var value int
+	_ = json.Unmarshal(params[key], &value)
+	return value
+}
+
+func errorResponse(id json.RawMessage, err error) response {
+	return response{JSONRPC: "2.0", ID: id, Error: &rpcError{Code: -1, Message: err.Error()}}
+}
+
+func parseURLParams(raw string) map[string]string {
+	result := map[string]string{}
+	values, err := url.ParseQuery(raw)
+	if err != nil {
+		return result
+	}
+	for key, items := range values {
+		if len(items) > 0 {
+			result[key] = items[len(items)-1]
+		}
+	}
+	return result
+}
+
+func trimStatementSQL(sqlText string) string {
+	trimmed := stripTrailingSlashDelimiter(strings.TrimSpace(sqlText))
+	if isOraclePlSQLBlock(trimmed) {
+		return trimmed
+	}
+	return strings.TrimRight(trimmed, "; \t\r\n")
+}
+
+func stripTrailingSlashDelimiter(sqlText string) string {
+	trimmed := strings.TrimSpace(sqlText)
+	if !strings.HasSuffix(trimmed, "/") {
+		return trimmed
+	}
+	slashStart := len(trimmed) - 1
+	lineStart := strings.LastIndex(trimmed[:slashStart], "\n") + 1
+	if strings.TrimSpace(trimmed[lineStart:slashStart]) != "" {
+		return trimmed
+	}
+	beforeSlash := strings.TrimSpace(trimmed[:lineStart])
+	// SQL*Plus uses a standalone slash to execute PL/SQL blocks; go-ora needs
+	// only the block text and not that client-side delimiter.
+	if isOraclePlSQLBlock(beforeSlash) {
+		return beforeSlash
+	}
+	return trimmed
+}
+
+func isOraclePlSQLBlock(sqlText string) bool {
+	trimmed := strings.TrimSpace(sqlText)
+	start := trimLeadingSQLComments(trimmed)
+	if !oraclePlSQLBlockStartRegexp.MatchString(start) {
+		return false
+	}
+	upper := strings.ToUpper(trimmed)
+	if oraclePlSQLBlockEndRegexp.MatchString(upper) {
+		return true
+	}
+	matches := oracleNamedPlSQLBlockEndRegexp.FindStringSubmatch(upper)
+	if len(matches) != 2 {
+		return false
+	}
+	switch matches[1] {
+	case "IF", "LOOP", "CASE":
+		return false
+	default:
+		return true
+	}
+}
+
+func isQuerySQL(sqlText string) bool {
+	executable := trimLeadingSQLComments(sqlText)
+	return startsWithSQLKeyword(executable, "select") || startsWithSQLKeyword(executable, "with")
+}
+
+func trimLeadingSQLComments(sqlText string) string {
+	remaining := strings.TrimSpace(sqlText)
+	for {
+		switch {
+		case strings.HasPrefix(remaining, "--"):
+			lineEnd := strings.IndexAny(remaining, "\r\n")
+			if lineEnd < 0 {
+				return ""
+			}
+			remaining = strings.TrimSpace(remaining[lineEnd+1:])
+		case strings.HasPrefix(remaining, "/*"):
+			commentEnd := strings.Index(remaining[2:], "*/")
+			if commentEnd < 0 {
+				return ""
+			}
+			remaining = strings.TrimSpace(remaining[commentEnd+4:])
+		default:
+			return remaining
+		}
+	}
+}
+
+func startsWithSQLKeyword(sqlText, keyword string) bool {
+	sqlText = strings.TrimSpace(sqlText)
+	if len(sqlText) < len(keyword) || !strings.EqualFold(sqlText[:len(keyword)], keyword) {
+		return false
+	}
+	if len(sqlText) == len(keyword) {
+		return true
+	}
+	next := sqlText[len(keyword)]
+	return !((next >= 'a' && next <= 'z') || (next >= 'A' && next <= 'Z') || (next >= '0' && next <= '9') || next == '_' || next == '$')
+}
+
+func sqlKeywordAt(sqlText string, pos int, keyword string) bool {
+	if pos < 0 || pos+len(keyword) > len(sqlText) || !strings.EqualFold(sqlText[pos:pos+len(keyword)], keyword) {
+		return false
+	}
+	if pos > 0 && isOracleIdentifierPart(sqlText[pos-1]) {
+		return false
+	}
+	if pos+len(keyword) >= len(sqlText) {
+		return true
+	}
+	return !isOracleIdentifierPart(sqlText[pos+len(keyword)])
+}
+
+func quoteIdentifier(value string) string {
+	return `"` + strings.ReplaceAll(value, `"`, `""`) + `"`
+}
+
+func normalizeValue(value any, columnTypeName string) any {
+	switch v := value.(type) {
+	case nil:
+		return nil
+	case []byte:
+		// Oracle RAW-like columns are binary data; decoding them as text produces mojibake.
+		if isOracleBinaryColumnType(columnTypeName) {
+			return bytesToHex(v)
+		}
+		return string(v)
+	case time.Time:
+		return v.Format(time.RFC3339Nano)
+	case int64, float64, bool, string:
+		return v
+	case fmt.Stringer:
+		return v.String()
+	default:
+		return fmt.Sprint(v)
+	}
+}
+
+func isOracleBinaryColumnType(columnTypeName string) bool {
+	normalized := strings.ToUpper(strings.ReplaceAll(strings.TrimSpace(columnTypeName), " ", ""))
+	switch normalized {
+	case "RAW", "VARRAW", "LONGRAW", "LONGVARRAW", "BLOB", "BFILE", "OCIBLOBLOCATOR", "OCIFILELOCATOR":
+		return true
+	default:
+		return false
+	}
+}
+
+func bytesToHex(bytes []byte) string {
+	const digits = "0123456789abcdef"
+	result := make([]byte, 2+len(bytes)*2)
+	result[0] = '0'
+	result[1] = 'x'
+	for i, b := range bytes {
+		result[2+i*2] = digits[b>>4]
+		result[3+i*2] = digits[b&0x0f]
+	}
+	return string(result)
+}
+
+func emptyIfNil[T any](values []T) []T {
+	if values == nil {
+		return []T{}
+	}
+	return values
+}
+
+func intPtrFromString(value string) *int {
+	if value == "" {
+		return nil
+	}
+	parsed, err := strconv.Atoi(value)
+	if err != nil {
+		return nil
+	}
+	return &parsed
+}
diff --git a/agents/drivers/oracle-go/main_test.go b/agents/drivers/oracle-go/main_test.go
new file mode 100644
index 0000000..dfc1287
--- /dev/null
+++ b/agents/drivers/oracle-go/main_test.go
@@ -0,0 +1,865 @@
+package main
+
+import (
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"net/url"
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestHandshakeResponse(t *testing.T) {
+	s := newServer()
+	resp, shutdown := s.handleLine(`{"jsonrpc":"2.0","id":7,"method":"handshake","params":{"appVersion":"dev"}}`)
+	if shutdown {
+		t.Fatal("handshake should not shut down the server")
+	}
+	if resp.Error != nil {
+		t.Fatalf("unexpected error: %v", resp.Error)
+	}
+	data, err := json.Marshal(resp.Result)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var result struct {
+		ProtocolVersion      int      `json:"protocolVersion"`
+		AgentProtocolVersion int      `json:"agentProtocolVersion"`
+		Capabilities         []string `json:"capabilities"`
+	}
+	if err := json.Unmarshal(data, &result); err != nil {
+		t.Fatal(err)
+	}
+	if result.ProtocolVersion != 1 || result.AgentProtocolVersion != 1 {
+		t.Fatalf("unexpected protocol versions: %+v", result)
+	}
+	contract := protocolContract(t)
+	if result.ProtocolVersion != contract.ProtocolVersion || result.AgentProtocolVersion != contract.ProtocolVersion {
+		t.Fatalf("handshake protocol versions do not match contract: result=%+v contract=%+v", result, contract)
+	}
+	for _, capability := range result.Capabilities {
+		if !contains(contract.AllCapabilities, capability) {
+			t.Fatalf("handshake returned capability %q outside protocol contract %v", capability, contract.AllCapabilities)
+		}
+	}
+	if !contains(result.Capabilities, "query") || !contains(result.Capabilities, "metadata") {
+		t.Fatalf("expected query and metadata capabilities, got %v", result.Capabilities)
+	}
+}
+
+func TestCloseMissingQuerySessionReturnsFalse(t *testing.T) {
+	s := newServer()
+	resp, shutdown := s.handleLine(`{"jsonrpc":"2.0","id":8,"method":"close_query_session","params":{"sessionId":"missing"}}`)
+	if shutdown {
+		t.Fatal("close_query_session should not shut down the server")
+	}
+	if resp.Error != nil {
+		t.Fatalf("unexpected error: %v", resp.Error)
+	}
+	if resp.Result != false {
+		t.Fatalf("expected false result, got %#v", resp.Result)
+	}
+}
+
+func TestMissingTableReadSessionMethodsReturnEmptyOrFalse(t *testing.T) {
+	s := newServer()
+
+	fetchResp, shutdown := s.handleLine(`{"jsonrpc":"2.0","id":9,"method":"fetch_table_read_page","params":{"sessionId":"missing","pageSize":10}}`)
+	if shutdown {
+		t.Fatal("fetch_table_read_page should not shut down the server")
+	}
+	if fetchResp.Error != nil {
+		t.Fatalf("unexpected fetch error: %v", fetchResp.Error)
+	}
+	data, err := json.Marshal(fetchResp.Result)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var page queryPageResult
+	if err := json.Unmarshal(data, &page); err != nil {
+		t.Fatal(err)
+	}
+	if len(page.Columns) != 0 || len(page.ColumnTypes) != 0 || len(page.Rows) != 0 || page.HasMore || page.SessionID != nil {
+		t.Fatalf("missing table read session should return empty page, got %+v", page)
+	}
+
+	closeResp, shutdown := s.handleLine(`{"jsonrpc":"2.0","id":10,"method":"close_table_read_session","params":{"sessionId":"missing"}}`)
+	if shutdown {
+		t.Fatal("close_table_read_session should not shut down the server")
+	}
+	if closeResp.Error != nil {
+		t.Fatalf("unexpected close error: %v", closeResp.Error)
+	}
+	if closeResp.Result != false {
+		t.Fatalf("expected false result, got %#v", closeResp.Result)
+	}
+}
+
+func TestEmptyResultSlicesMarshalAsArrays(t *testing.T) {
+	data, err := json.Marshal(queryResult{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(data)
+	if strings.Contains(text, `"columns":null`) || strings.Contains(text, `"column_types":null`) || strings.Contains(text, `"rows":null`) {
+		t.Fatalf("query result should marshal nil slices as arrays: %s", text)
+	}
+	if !strings.Contains(text, `"column_types":[]`) {
+		t.Fatalf("query result should marshal empty column types array: %s", text)
+	}
+
+	data, err = json.Marshal(indexInfo{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	text = string(data)
+	if strings.Contains(text, `"columns":null`) || strings.Contains(text, `"included_columns":null`) {
+		t.Fatalf("index info should marshal nil slices as arrays: %s", text)
+	}
+}
+
+func TestGetTableDDLResultMarshalsAsString(t *testing.T) {
+	data, err := json.Marshal("CREATE TABLE HR.ORDERS (ID NUMBER)")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var ddl string
+	if err := json.Unmarshal(data, &ddl); err != nil {
+		t.Fatalf("get_table_ddl result must deserialize as a string: %v", err)
+	}
+}
+
+func TestNormalizeValueFormatsOracleBinaryColumnsAsHex(t *testing.T) {
+	tests := map[string]string{
+		"RAW":            "0x000f10ff",
+		"raw":            "0x000f10ff",
+		"LongRaw":        "0x000f10ff",
+		"LONG RAW":       "0x000f10ff",
+		"LongVarRaw":     "0x000f10ff",
+		"OCIBlobLocator": "0x000f10ff",
+	}
+
+	for columnType, want := range tests {
+		if got := normalizeValue([]byte{0x00, 0x0f, 0x10, 0xff}, columnType); got != want {
+			t.Fatalf("normalizeValue RAW bytes for %q = %#v, want %q", columnType, got, want)
+		}
+	}
+}
+
+func TestNormalizeValueKeepsNonBinaryBytesAsText(t *testing.T) {
+	if got := normalizeValue([]byte("hello"), "VARCHAR2"); got != "hello" {
+		t.Fatalf("normalizeValue text bytes = %#v, want %q", got, "hello")
+	}
+	if got := normalizeValue([]byte("legacy"), ""); got != "legacy" {
+		t.Fatalf("normalizeValue bytes without metadata = %#v, want %q", got, "legacy")
+	}
+}
+
+func TestNormalizeDDLObjectType(t *testing.T) {
+	tests := map[string]string{
+		"":                  "",
+		"table":             "TABLE",
+		"VIEW":              "VIEW",
+		"materialized view": "MATERIALIZED_VIEW",
+		"MATERIALIZED_VIEW": "MATERIALIZED_VIEW",
+		"procedure":         "",
+	}
+	for input, want := range tests {
+		if got := normalizeDDLObjectType(input); got != want {
+			t.Fatalf("normalizeDDLObjectType(%q) = %q, want %q", input, got, want)
+		}
+	}
+}
+
+func TestIsQuerySQLSkipsLeadingComments(t *testing.T) {
+	tests := []string{
+		"-- 测试\nSELECT * FROM (SELECT * FROM \"DBX_TEST\".\"ORDERS_10K\") WHERE ROWNUM <= 100",
+		"/* explain */\nSELECT * FROM dual",
+		"-- comment\r\nWITH rows AS (SELECT 1 FROM dual) SELECT * FROM rows",
+	}
+	for _, sqlText := range tests {
+		if !isQuerySQL(sqlText) {
+			t.Fatalf("expected SQL to be treated as query: %s", sqlText)
+		}
+	}
+}
+
+func TestIsQuerySQLRequiresKeywordBoundary(t *testing.T) {
+	tests := []string{
+		"-- comment only",
+		"selectivity FROM stats",
+		"withdraw FROM account",
+		"/* unterminated comment",
+	}
+	for _, sqlText := range tests {
+		if isQuerySQL(sqlText) {
+			t.Fatalf("expected SQL not to be treated as query: %s", sqlText)
+		}
+	}
+}
+
+func TestTrimStatementSQLPreservesAnonymousPLSQLBlockTerminator(t *testing.T) {
+	sqlText := `DECLARE
+   PRE_TRD_DATE   INTEGER ;
+BEGIN
+   SELECT 1 + 2 INTO PRE_TRD_DATE FROM DUAL;
+END;`
+
+	if got := trimStatementSQL(sqlText); got != sqlText {
+		t.Fatalf("trimStatementSQL() = %q, want full PL/SQL block %q", got, sqlText)
+	}
+}
+
+func TestTrimStatementSQLStripsSlashDelimiterAfterPLSQLBlock(t *testing.T) {
+	sqlText := "BEGIN\n  NULL;\nEND;\n/"
+	want := "BEGIN\n  NULL;\nEND;"
+
+	if got := trimStatementSQL(sqlText); got != want {
+		t.Fatalf("trimStatementSQL() = %q, want %q", got, want)
+	}
+}
+
+func TestTrimStatementSQLPreservesCreatePLSQLObjectTerminator(t *testing.T) {
+	tests := []string{
+		"CREATE OR REPLACE PROCEDURE p AS\nBEGIN\n  NULL;\nEND;",
+		"CREATE OR REPLACE FUNCTION f RETURN NUMBER AS\nBEGIN\n  RETURN 1;\nEND;",
+		"CREATE OR REPLACE PACKAGE pkg_utils AS\n  FUNCTION get_version RETURN VARCHAR2;\nEND pkg_utils;",
+	}
+	for _, sqlText := range tests {
+		if got := trimStatementSQL(sqlText); got != sqlText {
+			t.Fatalf("trimStatementSQL() = %q, want full PL/SQL object %q", got, sqlText)
+		}
+	}
+}
+
+func TestTrimStatementSQLStripsSlashDelimiterAfterCreatePLSQLObject(t *testing.T) {
+	sqlText := "CREATE OR REPLACE PROCEDURE p AS\nBEGIN\n  NULL;\nEND;\n/"
+	want := "CREATE OR REPLACE PROCEDURE p AS\nBEGIN\n  NULL;\nEND;"
+
+	if got := trimStatementSQL(sqlText); got != want {
+		t.Fatalf("trimStatementSQL() = %q, want %q", got, want)
+	}
+}
+
+func TestTrimStatementSQLRemovesRegularStatementSemicolon(t *testing.T) {
+	if got := trimStatementSQL("SELECT 1 FROM DUAL;"); got != "SELECT 1 FROM DUAL" {
+		t.Fatalf("trimStatementSQL() = %q, want regular statement without semicolon", got)
+	}
+}
+
+func TestOracleExplainPlanBindParamsIncludesNamedParameters(t *testing.T) {
+	sqlText := `
+SELECT *
+FROM orders
+WHERE id = :id
+  AND status = :status
+  AND parent_id = :id`
+
+	want := []oracleBindParam{
+		{Name: "id"},
+		{Name: "status"},
+	}
+	if got := oracleExplainPlanBindParams(sqlText); !reflect.DeepEqual(got, want) {
+		t.Fatalf("oracleExplainPlanBindParams() = %#v, want %#v", got, want)
+	}
+}
+
+func TestOracleExplainPlanBindParamsSkipsQuotedTextAndComments(t *testing.T) {
+	sqlText := `
+SELECT ':literal' AS literal_value,
+       q'[not :q_param]' AS q_literal,
+       "COL:NAME" AS quoted_identifier
+FROM orders
+WHERE id = :id
+  -- ignored :comment_param
+  AND note <> 'escaped '' :text_param'
+  /* ignored :block_param */`
+
+	want := []oracleBindParam{{Name: "id"}}
+	if got := oracleExplainPlanBindParams(sqlText); !reflect.DeepEqual(got, want) {
+		t.Fatalf("oracleExplainPlanBindParams() = %#v, want %#v", got, want)
+	}
+}
+
+func TestOracleExplainPlanBindParamsIncludesPositionalParameters(t *testing.T) {
+	sqlText := "SELECT * FROM orders WHERE id = :1 AND status = :status"
+
+	want := []oracleBindParam{
+		{Name: "1", Positional: true},
+		{Name: "status"},
+	}
+	if got := oracleExplainPlanBindParams(sqlText); !reflect.DeepEqual(got, want) {
+		t.Fatalf("oracleExplainPlanBindParams() = %#v, want %#v", got, want)
+	}
+}
+
+func TestOracleExplainPlanBindArgsUsesNamedArguments(t *testing.T) {
+	args := oracleExplainPlanBindArgs("SELECT * FROM orders WHERE id = :id")
+
+	if len(args) != 1 {
+		t.Fatalf("expected one bind argument, got %#v", args)
+	}
+	named, ok := args[0].(sql.NamedArg)
+	if !ok {
+		t.Fatalf("expected sql.NamedArg, got %#v", args[0])
+	}
+	if named.Name != "id" || named.Value != nil {
+		t.Fatalf("unexpected named bind argument: %#v", named)
+	}
+}
+
+func protocolContract(t *testing.T) struct {
+	ProtocolVersion int      `json:"protocolVersion"`
+	AllCapabilities []string `json:"allCapabilities"`
+} {
+	t.Helper()
+	data, err := os.ReadFile("../../common/src/main/resources/agent-protocol-v1.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var contract struct {
+		ProtocolVersion int      `json:"protocolVersion"`
+		AllCapabilities []string `json:"allCapabilities"`
+	}
+	if err := json.Unmarshal(data, &contract); err != nil {
+		t.Fatal(err)
+	}
+	return contract
+}
+
+func TestOracleColumnTypeDDL(t *testing.T) {
+	charLen := 64
+	precision := 10
+	scale := 2
+	zeroScale := 0
+
+	tests := []struct {
+		name   string
+		column columnInfo
+		want   string
+	}{
+		{name: "varchar", column: columnInfo{DataType: "VARCHAR2", CharacterMaximumLength: &charLen}, want: "VARCHAR2(64)"},
+		{name: "number scale", column: columnInfo{DataType: "NUMBER", NumericPrecision: &precision, NumericScale: &scale}, want: "NUMBER(10,2)"},
+		{name: "number zero scale", column: columnInfo{DataType: "NUMBER", NumericPrecision: &precision, NumericScale: &zeroScale}, want: "NUMBER(10)"},
+		{name: "timestamp preserves precision", column: columnInfo{DataType: "TIMESTAMP(6)"}, want: "TIMESTAMP(6)"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := oracleColumnTypeDDL(tt.column); got != tt.want {
+				t.Fatalf("oracleColumnTypeDDL() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestBuildDSNUsesConnectionStringWhenProvided(t *testing.T) {
+	dsn := buildDSN(connectParams{ConnectionString: "oracle://scott:tiger@db.example.com:1521/ORCLPDB1"})
+
+	if dsn != "oracle://scott:tiger@db.example.com:1521/ORCLPDB1" {
+		t.Fatalf("unexpected dsn: %s", dsn)
+	}
+}
+
+func TestBuildDSNPreservesBastionUsernameAndEncodesCredentials(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Host:     "db.example.com",
+		Port:     1521,
+		Database: "XE",
+		Username: "9008888:reader",
+		Password: "dbx:pass",
+	})
+
+	parsed, err := url.Parse(dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	password, _ := parsed.User.Password()
+	if parsed.User.Username() != "9008888:reader" || password != "dbx:pass" {
+		t.Fatalf("credentials should survive URL parsing, dsn=%s username=%q password=%q", dsn, parsed.User.Username(), password)
+	}
+	if !strings.HasPrefix(parsed.User.String(), "9008888%3Areader:") {
+		t.Fatalf("bastion username should be escaped without being quoted, dsn=%s", dsn)
+	}
+}
+
+func TestBuildDSNEncodesColonInCredentialsFromJDBCServiceURL(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Username:         "9008888:reader",
+		Password:         "dbx:pass",
+		ConnectionString: "jdbc:oracle:thin:@//db.example.com:1521/XE",
+	})
+
+	parsed, err := url.Parse(dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	password, _ := parsed.User.Password()
+	if parsed.User.Username() != "9008888:reader" || password != "dbx:pass" {
+		t.Fatalf("credentials should survive JDBC URL conversion, dsn=%s username=%q password=%q", dsn, parsed.User.Username(), password)
+	}
+	if parsed.Host != "db.example.com:1521" || strings.TrimPrefix(parsed.Path, "/") != "XE" {
+		t.Fatalf("JDBC host/service should survive conversion, dsn=%s", dsn)
+	}
+}
+
+func TestBuildDSNPreservesExplicitlyQuotedUsername(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Host:     "db.example.com",
+		Port:     1521,
+		Database: "XE",
+		Username: `"abc:def"`,
+		Password: "dbx:pass",
+	})
+
+	parsed, err := url.Parse(dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if parsed.User.Username() != `"abc:def"` {
+		t.Fatalf("explicitly quoted username should remain unchanged, dsn=%s username=%q", dsn, parsed.User.Username())
+	}
+}
+
+func TestBuildDSNUsesJdbcServiceHostAndPort(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Host:             "127.0.0.1",
+		Port:             11521,
+		Database:         "ORCLPDB1",
+		Username:         "scott",
+		Password:         "tiger",
+		ConnectionString: "jdbc:oracle:thin:@//oracle.example.com:1521/ORCLPDB1",
+	})
+
+	if strings.Contains(strings.ToLower(dsn), "jdbc:") {
+		t.Fatalf("dsn should be go-ora format, got: %s", dsn)
+	}
+	if !strings.Contains(dsn, "oracle.example.com:1521") || !strings.Contains(dsn, "ORCLPDB1") {
+		t.Fatalf("dsn should use JDBC host/port/database fields, got: %s", dsn)
+	}
+}
+
+func TestBuildDSNUsesRewrittenJdbcServiceHostAndPort(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Host:             "127.0.0.1",
+		Port:             11521,
+		Database:         "ORCLPDB1",
+		Username:         "scott",
+		Password:         "tiger",
+		ConnectionString: "jdbc:oracle:thin:@//127.0.0.1:11521/ORCLPDB1",
+	})
+
+	if strings.Contains(strings.ToLower(dsn), "jdbc:") {
+		t.Fatalf("dsn should be go-ora format, got: %s", dsn)
+	}
+	if !strings.Contains(dsn, "127.0.0.1:11521") || !strings.Contains(dsn, "ORCLPDB1") {
+		t.Fatalf("dsn should use rewritten JDBC host/port/database fields, got: %s", dsn)
+	}
+}
+
+func TestBuildDSNConvertsJdbcSID(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Host:             "127.0.0.1",
+		Port:             11521,
+		Database:         "ORCL",
+		Username:         "scott",
+		Password:         "tiger",
+		ConnectionString: "jdbc:oracle:thin:@oracle.example.com:1521:ORCL",
+	})
+
+	if strings.Contains(strings.ToLower(dsn), "jdbc:") {
+		t.Fatalf("dsn should be go-ora format, got: %s", dsn)
+	}
+	upperDSN := strings.ToUpper(dsn)
+	if !strings.Contains(dsn, "oracle.example.com:1521") || !strings.Contains(upperDSN, "SID=ORCL") {
+		t.Fatalf("dsn should use JDBC host/port and SID option, got: %s", dsn)
+	}
+}
+
+func TestBuildDSNConvertsJdbcDescriptor(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Username:         "scott",
+		Password:         "tiger",
+		ConnectionString: "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=db.example.com)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=ORCLPDB1)))",
+	})
+
+	if !strings.HasPrefix(dsn, "oracle://scott:tiger@") {
+		t.Fatalf("descriptor should become go-ora url, got: %s", dsn)
+	}
+	if !strings.Contains(dsn, "connStr=") {
+		t.Fatalf("descriptor should be passed via connStr option, got: %s", dsn)
+	}
+}
+
+func TestBuildDSNAddsSysDbaOption(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Host:      "127.0.0.1",
+		Port:      1521,
+		Database:  "SYSDBA:ORCLPDB1",
+		Username:  "sys",
+		Password:  "secret",
+		SysDBA:    true,
+		URLParams: "TRACE FILE=trace.log",
+	})
+
+	if strings.Contains(dsn, "SYSDBA:") {
+		t.Fatalf("dsn should strip SYSDBA prefix: %s", dsn)
+	}
+	if !strings.Contains(dsn, "ORCLPDB1") {
+		t.Fatalf("dsn should include service name: %s", dsn)
+	}
+	upperDSN := strings.ToUpper(dsn)
+	if !strings.Contains(upperDSN, "AUTH TYPE=SYSDBA") &&
+		!strings.Contains(upperDSN, "AUTH+TYPE=SYSDBA") &&
+		!strings.Contains(upperDSN, "AUTH%20TYPE=SYSDBA") {
+		t.Fatalf("dsn should include SYSDBA auth option: %s", dsn)
+	}
+}
+
+func TestOracleGB18030ConverterRoundTrip(t *testing.T) {
+	converter := oracleGB18030Converter{}
+	input := "DBX \u4e2d\u6587 \U00020000"
+
+	encoded := converter.Encode(input)
+	if string(encoded) == input {
+		t.Fatalf("GB18030 converter should encode non-ASCII text away from UTF-8 bytes")
+	}
+	if decoded := converter.Decode(encoded); decoded != input {
+		t.Fatalf("GB18030 round trip = %q, want %q", decoded, input)
+	}
+	if converter.GetLangID() != oracleCharsetZHS32GB18030 {
+		t.Fatalf("GB18030 converter lang id = %d, want %d", converter.GetLangID(), oracleCharsetZHS32GB18030)
+	}
+	if clone := converter.Clone(); clone.GetLangID() != oracleCharsetZHS32GB18030 {
+		t.Fatalf("GB18030 converter clone lang id = %d, want %d", clone.GetLangID(), oracleCharsetZHS32GB18030)
+	}
+}
+
+func TestOracleStringConverterForUnsupportedCharsetError(t *testing.T) {
+	err := errors.New("the server use charset with id: 854 which is not supported by the driver")
+	converter, ok := oracleStringConverterForUnsupportedCharsetError(err)
+	if !ok {
+		t.Fatalf("expected GB18030 server charset error to have a converter")
+	}
+	if converter.GetLangID() != oracleCharsetZHS32GB18030 {
+		t.Fatalf("converter lang id = %d, want %d", converter.GetLangID(), oracleCharsetZHS32GB18030)
+	}
+	ncharsetErr := errors.New("the server use ncharset with id: 854 which is not supported by the driver")
+	if _, ok := oracleStringConverterForUnsupportedCharsetError(ncharsetErr); ok {
+		t.Fatalf("ncharset errors should not have a server charset converter")
+	}
+	otherCharsetErr := errors.New("the server use charset with id: 852 which is not supported by the driver")
+	if charsetID, ok := unsupportedOracleServerCharsetID(otherCharsetErr); !ok || charsetID != 852 {
+		t.Fatalf("other server charset should still be parsed, got id=%d ok=%v", charsetID, ok)
+	}
+	if _, ok := oracleStringConverterForUnsupportedCharsetError(otherCharsetErr); ok {
+		t.Fatalf("unknown charset ids should not get a guessed converter")
+	}
+}
+
+func TestListDatabasesSQLUsesUserDictionaryInsteadOfObjectDictionary(t *testing.T) {
+	sqlText := strings.ToUpper(oracleListDatabasesSQL)
+
+	if !strings.Contains(sqlText, "ALL_USERS") {
+		t.Fatalf("schema listing should query ALL_USERS, got: %s", oracleListDatabasesSQL)
+	}
+	if strings.Contains(sqlText, "ALL_TABLES") || strings.Contains(sqlText, "ALL_VIEWS") {
+		t.Fatalf("schema listing should not scan object dictionaries, got: %s", oracleListDatabasesSQL)
+	}
+}
+
+func TestListDatabasesSQLCanApplyVisibleSchemaFilter(t *testing.T) {
+	sqlText, args := oracleListDatabasesSQLWithVisibleSchemas([]string{"APP", "REPORTING"})
+	upperSQL := strings.ToUpper(sqlText)
+
+	if !strings.Contains(upperSQL, "ALL_USERS") {
+		t.Fatalf("schema listing should query ALL_USERS, got: %s", sqlText)
+	}
+	if !strings.Contains(upperSQL, "USERNAME IN (:1,:2)") {
+		t.Fatalf("schema listing should apply visible schema filter, got: %s", sqlText)
+	}
+	if len(args) != 2 || args[0] != "APP" || args[1] != "REPORTING" {
+		t.Fatalf("visible schema args were not preserved: %#v", args)
+	}
+	if strings.Contains(upperSQL, "ALL_TABLES") || strings.Contains(upperSQL, "ALL_VIEWS") {
+		t.Fatalf("schema listing should not scan object dictionaries, got: %s", sqlText)
+	}
+}
+
+func TestListTablesSQLUsesSplitDictionaryQuery(t *testing.T) {
+	sqlText := strings.ToUpper(oracleListTablesSQL)
+
+	if !strings.Contains(sqlText, "ALL_TABLES") || !strings.Contains(sqlText, "ALL_OBJECTS") {
+		t.Fatalf("table listing should split tables and views, got: %s", oracleListTablesSQL)
+	}
+	if !strings.Contains(sqlText, "UNION ALL") {
+		t.Fatalf("table listing should union table and view metadata, got: %s", oracleListTablesSQL)
+	}
+	if strings.Contains(sqlText, "ALL_TAB_COMMENTS") {
+		t.Fatalf("table listing should not load comments during refresh, got: %s", oracleListTablesSQL)
+	}
+}
+
+func TestListTablesQueryAppliesMetadataConstraints(t *testing.T) {
+	query := oracleListTablesQuery("APP", metadataListConstraints{
+		Filter:      "u_r",
+		Limit:       501,
+		Offset:      10,
+		ObjectTypes: []string{"view", "TABLE", "TABLE"},
+	})
+	sqlText := strings.ToUpper(query.SQL)
+
+	if !strings.Contains(sqlText, "UPPER(OBJECT_NAME) LIKE :3 ESCAPE '\\'") {
+		t.Fatalf("table listing should push filter predicate, got: %s", query.SQL)
+	}
+	if !strings.Contains(sqlText, "TABLE_TYPE IN (:4,:5)") {
+		t.Fatalf("table listing should push table type predicate, got: %s", query.SQL)
+	}
+	if !strings.Contains(sqlText, "ROWNUM <= :6") || !strings.Contains(sqlText, "DBX_RN > :7") {
+		t.Fatalf("table listing should use rownum pagination, got: %s", query.SQL)
+	}
+	if len(query.Args) != 7 {
+		t.Fatalf("unexpected args: %#v", query.Args)
+	}
+	if query.Args[0] != "APP" || query.Args[1] != "APP" || query.Args[2] != "%U%\\_%R%" || query.Args[3] != "TABLE" || query.Args[4] != "VIEW" || query.Args[5] != 511 || query.Args[6] != 10 {
+		t.Fatalf("constraints args were not normalized: %#v", query.Args)
+	}
+}
+
+func TestListSessionUserTablesQueryUsesUserDictionary(t *testing.T) {
+	query := oracleListSessionUserTablesQuery(metadataListConstraints{
+		Filter:      "u_r",
+		Limit:       501,
+		Offset:      10,
+		ObjectTypes: []string{"view", "TABLE", "TABLE"},
+	})
+	sqlText := strings.ToUpper(query.SQL)
+
+	if !strings.Contains(sqlText, "USER_TABLES") || !strings.Contains(sqlText, "USER_OBJECTS") {
+		t.Fatalf("session-user table listing should use USER_* dictionaries, got: %s", query.SQL)
+	}
+	if strings.Contains(sqlText, "ALL_TABLES") || strings.Contains(sqlText, "ALL_OBJECTS") {
+		t.Fatalf("session-user table listing should avoid ALL_* dictionaries, got: %s", query.SQL)
+	}
+	if strings.Contains(sqlText, "OWNER =") {
+		t.Fatalf("session-user table listing should not add owner predicates, got: %s", query.SQL)
+	}
+	if !strings.Contains(sqlText, "UPPER(OBJECT_NAME) LIKE :1 ESCAPE '\\'") {
+		t.Fatalf("table listing should push filter predicate, got: %s", query.SQL)
+	}
+	if !strings.Contains(sqlText, "TABLE_TYPE IN (:2,:3)") {
+		t.Fatalf("table listing should push table type predicate, got: %s", query.SQL)
+	}
+	if !strings.Contains(sqlText, "ROWNUM <= :4") || !strings.Contains(sqlText, "DBX_RN > :5") {
+		t.Fatalf("table listing should use rownum pagination, got: %s", query.SQL)
+	}
+	if len(query.Args) != 5 {
+		t.Fatalf("unexpected args: %#v", query.Args)
+	}
+	if query.Args[0] != "%U%\\_%R%" || query.Args[1] != "TABLE" || query.Args[2] != "VIEW" || query.Args[3] != 511 || query.Args[4] != 10 {
+		t.Fatalf("constraints args were not normalized: %#v", query.Args)
+	}
+}
+
+func TestListObjectsSQLUsesSplitDictionaryQuery(t *testing.T) {
+	sqlText := strings.ToUpper(oracleListObjectsSQL)
+
+	if !strings.Contains(sqlText, "ALL_TABLES") || !strings.Contains(sqlText, "ALL_OBJECTS") {
+		t.Fatalf("object listing should split tables from other objects, got: %s", oracleListObjectsSQL)
+	}
+	if !strings.Contains(sqlText, "UNION ALL") {
+		t.Fatalf("object listing should union object metadata, got: %s", oracleListObjectsSQL)
+	}
+	if strings.Contains(sqlText, "ALL_TAB_COMMENTS") {
+		t.Fatalf("object listing should not load comments during refresh, got: %s", oracleListObjectsSQL)
+	}
+	if !strings.Contains(sqlText, "'PACKAGE BODY'") || !strings.Contains(sqlText, "PACKAGE_BODY") {
+		t.Fatalf("object listing should include package bodies with normalized type, got: %s", oracleListObjectsSQL)
+	}
+}
+
+func TestListObjectsQueryAppliesMetadataConstraints(t *testing.T) {
+	query := oracleListObjectsQuery("APP", metadataListConstraints{
+		Filter:      "pkg%",
+		Limit:       25,
+		ObjectTypes: []string{"FUNCTION", "package"},
+	})
+	sqlText := strings.ToUpper(query.SQL)
+
+	if !strings.Contains(sqlText, "UPPER(OBJECT_NAME) LIKE :3 ESCAPE '\\'") {
+		t.Fatalf("object listing should push filter predicate, got: %s", query.SQL)
+	}
+	if !strings.Contains(sqlText, "OBJECT_TYPE IN (:4,:5)") {
+		t.Fatalf("object listing should push object type predicate, got: %s", query.SQL)
+	}
+	if !strings.Contains(sqlText, "ROWNUM <= :6") || !strings.Contains(sqlText, "DBX_RN > :7") {
+		t.Fatalf("object listing should use rownum pagination, got: %s", query.SQL)
+	}
+	if len(query.Args) != 7 {
+		t.Fatalf("unexpected args: %#v", query.Args)
+	}
+	if query.Args[2] != "%P%K%G%\\%%" || query.Args[3] != "FUNCTION" || query.Args[4] != "PACKAGE" || query.Args[5] != 25 || query.Args[6] != 0 {
+		t.Fatalf("object constraints args were not normalized: %#v", query.Args)
+	}
+}
+
+func TestListSessionUserObjectsQueryUsesUserDictionary(t *testing.T) {
+	query := oracleListSessionUserObjectsQuery(metadataListConstraints{
+		Filter:      "pkg%",
+		Limit:       25,
+		ObjectTypes: []string{"FUNCTION", "package"},
+	})
+	sqlText := strings.ToUpper(query.SQL)
+
+	if !strings.Contains(sqlText, "USER_TABLES") || !strings.Contains(sqlText, "USER_OBJECTS") {
+		t.Fatalf("session-user object listing should use USER_* dictionaries, got: %s", query.SQL)
+	}
+	if strings.Contains(sqlText, "ALL_TABLES") || strings.Contains(sqlText, "ALL_OBJECTS") {
+		t.Fatalf("session-user object listing should avoid ALL_* dictionaries, got: %s", query.SQL)
+	}
+	if strings.Contains(sqlText, "OWNER =") {
+		t.Fatalf("session-user object listing should not add owner predicates, got: %s", query.SQL)
+	}
+	if !strings.Contains(sqlText, "UPPER(OBJECT_NAME) LIKE :1 ESCAPE '\\'") {
+		t.Fatalf("object listing should push filter predicate, got: %s", query.SQL)
+	}
+	if !strings.Contains(sqlText, "OBJECT_TYPE IN (:2,:3)") {
+		t.Fatalf("object listing should push object type predicate, got: %s", query.SQL)
+	}
+	if !strings.Contains(sqlText, "ROWNUM <= :4") || !strings.Contains(sqlText, "DBX_RN > :5") {
+		t.Fatalf("object listing should use rownum pagination, got: %s", query.SQL)
+	}
+	if len(query.Args) != 5 {
+		t.Fatalf("unexpected args: %#v", query.Args)
+	}
+	if query.Args[0] != "%P%K%G%\\%%" || query.Args[1] != "FUNCTION" || query.Args[2] != "PACKAGE" || query.Args[3] != 25 || query.Args[4] != 0 {
+		t.Fatalf("object constraints args were not normalized: %#v", query.Args)
+	}
+}
+
+func TestOracleFuzzyLikePatternEscapesSpecialCharacters(t *testing.T) {
+	got := oracleFuzzyLikePattern(`a_%\b`)
+	want := `%a%\_%\%%\\%b%`
+	if got != want {
+		t.Fatalf("oracleFuzzyLikePattern() = %q, want %q", got, want)
+	}
+}
+
+func TestIsOraclePGALimitError(t *testing.T) {
+	if !isOraclePGALimitError(errors.New("ORA-04036: PGA memory used by the instance exceeds PGA_AGGREGATE_LIMIT")) {
+		t.Fatal("expected ORA-04036 to be detected")
+	}
+	if isOraclePGALimitError(errors.New("ORA-00942: table or view does not exist")) {
+		t.Fatal("unexpected ORA-00942 match")
+	}
+}
+
+func TestRewriteOracleXMLTypeSelectStar(t *testing.T) {
+	sqlText, err := rewriteOracleXMLTypeSelectSQL(
+		`SELECT * FROM TEST_LOBS`,
+		fakeOracleColumnLoader([]oracleColumnMeta{
+			{Name: "ID", DataType: "NUMBER"},
+			{Name: "XML_CONTENT", DataType: "XMLTYPE"},
+			{Name: "TEST_NAME", DataType: "VARCHAR2"},
+		}),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := `SELECT "ID", XMLSERIALIZE(CONTENT "XML_CONTENT" AS CLOB) AS "XML_CONTENT", "TEST_NAME" FROM TEST_LOBS`
+	if sqlText != want {
+		t.Fatalf("rewriteOracleXMLTypeSelectSQL() = %s, want %s", sqlText, want)
+	}
+}
+
+func TestRewriteOracleXMLTypeExplicitColumn(t *testing.T) {
+	sqlText, err := rewriteOracleXMLTypeSelectSQL(
+		`SELECT t.ID, t.XML_CONTENT AS xml_doc FROM TEST_LOBS t WHERE t.ID = 1`,
+		fakeOracleColumnLoader([]oracleColumnMeta{
+			{Name: "ID", DataType: "NUMBER"},
+			{Name: "XML_CONTENT", DataType: "SYS.XMLTYPE"},
+		}),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := `SELECT t.ID, XMLSERIALIZE(CONTENT t."XML_CONTENT" AS CLOB) AS xml_doc FROM TEST_LOBS t WHERE t.ID = 1`
+	if sqlText != want {
+		t.Fatalf("rewriteOracleXMLTypeSelectSQL() = %s, want %s", sqlText, want)
+	}
+}
+
+func TestRewriteOracleXMLTypeNestedRownumQuery(t *testing.T) {
+	sqlText, err := rewriteOracleXMLTypeSelectSQL(
+		`SELECT * FROM (SELECT "ID", "XML_CONTENT" FROM "DBX"."TEST_LOBS") WHERE ROWNUM <= 100`,
+		fakeOracleColumnLoader([]oracleColumnMeta{
+			{Name: "ID", DataType: "NUMBER"},
+			{Name: "XML_CONTENT", DataType: "XMLTYPE"},
+		}),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(sqlText, `XMLSERIALIZE(CONTENT "XML_CONTENT" AS CLOB) AS "XML_CONTENT"`) {
+		t.Fatalf("expected nested XMLTYPE column to be serialized, got: %s", sqlText)
+	}
+}
+
+func TestRewriteOracleXMLTypeSkipsJoins(t *testing.T) {
+	called := false
+	sqlText, err := rewriteOracleXMLTypeSelectSQL(
+		`SELECT * FROM TEST_LOBS l JOIN OTHER_TABLE o ON o.ID = l.ID`,
+		func(schema, table string) ([]oracleColumnMeta, error) {
+			called = true
+			return nil, nil
+		},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if called {
+		t.Fatal("join query should not load table metadata")
+	}
+	if sqlText != `SELECT * FROM TEST_LOBS l JOIN OTHER_TABLE o ON o.ID = l.ID` {
+		t.Fatalf("join query should not be rewritten, got: %s", sqlText)
+	}
+}
+
+func TestOracleColumnTypeNamesContainXMLType(t *testing.T) {
+	tests := []struct {
+		name      string
+		typeNames []string
+		want      bool
+	}{
+		{name: "plain xmltype", typeNames: []string{"NUMBER", "XMLTYPE"}, want: true},
+		{name: "qualified xmltype", typeNames: []string{"SYS.XMLTYPE"}, want: true},
+		{name: "case and spaces", typeNames: []string{" varchar2 ", "sys.xmltype"}, want: true},
+		{name: "ordinary columns", typeNames: []string{"NUMBER", "VARCHAR2", "DATE"}, want: false},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := oracleColumnTypeNamesContainXMLType(tt.typeNames); got != tt.want {
+				t.Fatalf("oracleColumnTypeNamesContainXMLType(%v) = %v, want %v", tt.typeNames, got, tt.want)
+			}
+		})
+	}
+}
+
+func fakeOracleColumnLoader(columns []oracleColumnMeta) oracleColumnMetaLoader {
+	return func(schema, table string) ([]oracleColumnMeta, error) {
+		if strings.ToUpper(table) != "TEST_LOBS" {
+			return nil, nil
+		}
+		return columns, nil
+	}
+}
+
+func contains(values []string, target string) bool {
+	for _, value := range values {
+		if value == target {
+			return true
+		}
+	}
+	return false
+}
diff --git a/agents/drivers/oscar/build.gradle b/agents/drivers/oscar/build.gradle
new file mode 100644
index 0000000..88d88c8
--- /dev/null
+++ b/agents/drivers/oscar/build.gradle
@@ -0,0 +1,12 @@
+dependencies {
+    implementation files('libs/oscarJDBC8.jar')
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes(
+            'Agent-Label': '\u795e\u901a OSCAR',
+            'Main-Class': 'com.dbx.agent.oscar.OscarAgent'
+        )
+    }
+}
diff --git a/agents/drivers/oscar/libs/oscarJDBC8.jar b/agents/drivers/oscar/libs/oscarJDBC8.jar
new file mode 100644
index 0000000..7d1a6c4
Binary files /dev/null and b/agents/drivers/oscar/libs/oscarJDBC8.jar differ
diff --git a/agents/drivers/oscar/src/main/java/com/dbx/agent/oscar/OscarAgent.java b/agents/drivers/oscar/src/main/java/com/dbx/agent/oscar/OscarAgent.java
new file mode 100644
index 0000000..ea247c8
--- /dev/null
+++ b/agents/drivers/oscar/src/main/java/com/dbx/agent/oscar/OscarAgent.java
@@ -0,0 +1,21 @@
+package com.dbx.agent.oscar;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+
+public final class OscarAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile OSCAR_PROFILE = new JdbcAgentProfile(
+        "com.oscar.Driver",
+        "jdbc:oscar://{host}:{port}/{database}",
+        2003
+    );
+
+    public OscarAgent() {
+        super(OSCAR_PROFILE);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new OscarAgent()).run();
+    }
+}
diff --git a/agents/drivers/oscar/src/test/java/com/dbx/agent/oscar/OscarAgentTest.java b/agents/drivers/oscar/src/test/java/com/dbx/agent/oscar/OscarAgentTest.java
new file mode 100644
index 0000000..953e991
--- /dev/null
+++ b/agents/drivers/oscar/src/test/java/com/dbx/agent/oscar/OscarAgentTest.java
@@ -0,0 +1,16 @@
+package com.dbx.agent.oscar;
+
+import com.dbx.agent.JdbcAgentProfile;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class OscarAgentTest {
+    @Test
+    void declaresOscarJdbcProfile() {
+        JdbcAgentProfile profile = OscarAgent.OSCAR_PROFILE;
+
+        Assertions.assertEquals("com.oscar.Driver", profile.getDriverClass());
+        Assertions.assertEquals("jdbc:oscar://{host}:{port}/{database}", profile.getUrlTemplate());
+        Assertions.assertEquals(2003, profile.getDefaultPort());
+    }
+}
diff --git a/agents/drivers/saphana/build.gradle b/agents/drivers/saphana/build.gradle
new file mode 100644
index 0000000..112aff5
--- /dev/null
+++ b/agents/drivers/saphana/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.sap.cloud.db.jdbc:ngdbc:2.28.7'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'SAP HANA', 'Main-Class': 'com.dbx.agent.saphana.SapHanaAgent')
+    }
+}
diff --git a/agents/drivers/saphana/src/main/java/com/dbx/agent/saphana/SapHanaAgent.java b/agents/drivers/saphana/src/main/java/com/dbx/agent/saphana/SapHanaAgent.java
new file mode 100644
index 0000000..269b2fd
--- /dev/null
+++ b/agents/drivers/saphana/src/main/java/com/dbx/agent/saphana/SapHanaAgent.java
@@ -0,0 +1,26 @@
+package com.dbx.agent.saphana;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+import java.util.Arrays;
+import java.util.Collections;
+
+public final class SapHanaAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile SAPHANA_PROFILE = new JdbcAgentProfile(
+        "com.sap.db.jdbc.Driver",
+        "jdbc:sap://{host}:{port}/?databaseName={database}",
+        30015,
+        false,
+        Collections.emptySet(),
+        Arrays.asList("COLUMN TABLE", "ROW TABLE", "TABLE", "VIEW")
+    );
+
+    public SapHanaAgent() {
+        super(SAPHANA_PROFILE);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new SapHanaAgent()).run();
+    }
+}
diff --git a/agents/drivers/snowflake/build.gradle b/agents/drivers/snowflake/build.gradle
new file mode 100644
index 0000000..7ba1819
--- /dev/null
+++ b/agents/drivers/snowflake/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'net.snowflake:snowflake-jdbc:3.22.0'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Snowflake', 'Main-Class': 'com.dbx.agent.snowflake.SnowflakeAgent')
+    }
+}
diff --git a/agents/drivers/snowflake/src/main/java/com/dbx/agent/snowflake/SnowflakeAgent.java b/agents/drivers/snowflake/src/main/java/com/dbx/agent/snowflake/SnowflakeAgent.java
new file mode 100644
index 0000000..608ff57
--- /dev/null
+++ b/agents/drivers/snowflake/src/main/java/com/dbx/agent/snowflake/SnowflakeAgent.java
@@ -0,0 +1,381 @@
+package com.dbx.agent.snowflake;
+
+import com.dbx.agent.AbstractJdbcAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.MetadataSqlSupport;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+
+public final class SnowflakeAgent extends AbstractJdbcAgent {
+
+    @Override
+    protected String driverClass() {
+        return "net.snowflake.client.jdbc.SnowflakeDriver";
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return buildUrl(params);
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW DATABASES")) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString("name")));
+                }
+            }
+            result.sort(Comparator.comparing(DatabaseInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return unchecked(() -> {
+            List<String> result = new ArrayList<>();
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW SCHEMAS")) {
+                while (rs.next()) {
+                    result.add(rs.getString("name"));
+                }
+            }
+            Collections.sort(result);
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            String sql = "SELECT TABLE_NAME, TABLE_TYPE " +
+                "FROM INFORMATION_SCHEMA.TABLES " +
+                "WHERE TABLE_SCHEMA = ? " +
+                "ORDER BY TABLE_NAME";
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(
+                            rs.getString("TABLE_NAME"),
+                            normalizeTableType(rs.getString("TABLE_TYPE")),
+                            null
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listTables(schema);
+        }
+        if (!normalized.includesTableLikeTypes()) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedTables(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterTables(listTables(schema));
+        }
+    }
+
+    private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            StringBuilder sql = new StringBuilder("SELECT TABLE_NAME, TABLE_TYPE FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ?");
+            args.add(schema);
+            appendSnowflakeTableTypePredicate(sql, args, constraints);
+            MetadataSqlSupport.appendNameFilter(sql, args, "TABLE_NAME", constraints);
+            sql.append(" ORDER BY TABLE_NAME");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(
+                            rs.getString("TABLE_NAME"),
+                            normalizeTableType(rs.getString("TABLE_TYPE")),
+                            null
+                        ));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterTables(result);
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            for (TableInfo table : listTables(schema)) {
+                result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+            }
+
+            String sql = "SELECT PROCEDURE_NAME, 'PROCEDURE' " +
+                "FROM INFORMATION_SCHEMA.PROCEDURES " +
+                "WHERE PROCEDURE_SCHEMA = ? " +
+                "ORDER BY PROCEDURE_NAME";
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1), rs.getString(2), schema, null));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listObjects(schema);
+        }
+        if (!includesSupportedObjects(normalized)) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedObjects(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterObjects(listObjects(schema));
+        }
+    }
+
+    private List<ObjectInfo> queryConstrainedObjects(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            List<String> branches = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            if (constraints.includesTableLikeTypes()) {
+                StringBuilder tableSql = new StringBuilder("SELECT TABLE_NAME AS OBJECT_NAME, TABLE_TYPE AS OBJECT_TYPE FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ?");
+                args.add(schema);
+                appendSnowflakeTableTypePredicate(tableSql, args, constraints);
+                MetadataSqlSupport.appendNameFilter(tableSql, args, "TABLE_NAME", constraints);
+                branches.add(tableSql.toString());
+            }
+            if (constraints.objectTypeAllowed("PROCEDURE")) {
+                StringBuilder procedureSql = new StringBuilder("SELECT PROCEDURE_NAME AS OBJECT_NAME, 'PROCEDURE' AS OBJECT_TYPE FROM INFORMATION_SCHEMA.PROCEDURES WHERE PROCEDURE_SCHEMA = ?");
+                args.add(schema);
+                MetadataSqlSupport.appendNameFilter(procedureSql, args, "PROCEDURE_NAME", constraints);
+                branches.add(procedureSql.toString());
+            }
+            if (branches.isEmpty()) {
+                return List.of();
+            }
+            StringBuilder sql = new StringBuilder("SELECT OBJECT_NAME, OBJECT_TYPE FROM (")
+                .append(String.join(" UNION ALL ", branches))
+                .append(") metadata_objects ORDER BY CASE OBJECT_TYPE WHEN 'BASE TABLE' THEN 0 WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 WHEN 'MATERIALIZED VIEW' THEN 2 WHEN 'PROCEDURE' THEN 3 ELSE 9 END, OBJECT_NAME");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(
+                            rs.getString("OBJECT_NAME"),
+                            normalizeTableType(rs.getString("OBJECT_TYPE")),
+                            schema,
+                            null
+                        ));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterObjects(result);
+        });
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        return unchecked(() -> {
+            String ddlType = objectType.toUpperCase(Locale.ROOT);
+            String sql = "SELECT GET_DDL('" + ddlType + "', '\"" + schema + "\".\"" + name + "\"')";
+            String source = "";
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(sql)) {
+                if (rs.next()) {
+                    String value = rs.getString(1);
+                    source = value == null ? "" : value;
+                }
+            }
+            return new ObjectSource(name, objectType, schema, source);
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            Connection conn = requireConnected();
+            List<String> primaryKeys = new ArrayList<>();
+            try (java.sql.Statement stmt = conn.createStatement()) {
+                String qualifiedTable = JdbcIdentifiers.INSTANCE.doubleQuote(schema) + "." + JdbcIdentifiers.INSTANCE.doubleQuote(table);
+                try (ResultSet rs = stmt.executeQuery("SHOW PRIMARY KEYS IN TABLE " + qualifiedTable)) {
+                    while (rs.next()) {
+                        primaryKeys.add(rs.getString("column_name"));
+                    }
+                }
+            } catch (Exception ignored) {
+                // Snowflake may not return primary key metadata for every object.
+            }
+
+            List<ColumnInfo> result = new ArrayList<>();
+            String sql = "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT, " +
+                "NUMERIC_PRECISION, NUMERIC_SCALE, CHARACTER_MAXIMUM_LENGTH, COMMENT " +
+                "FROM INFORMATION_SCHEMA.COLUMNS " +
+                "WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? " +
+                "ORDER BY ORDINAL_POSITION";
+            try (java.sql.PreparedStatement stmt = conn.prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String colName = rs.getString("COLUMN_NAME");
+                        result.add(new ColumnInfo(
+                            colName,
+                            rs.getString("DATA_TYPE"),
+                            "YES".equals(rs.getString("IS_NULLABLE")),
+                            rs.getString("COLUMN_DEFAULT"),
+                            primaryKeys.contains(colName),
+                            null,
+                            blankToNull(rs.getString("COMMENT")),
+                            intOrNull(rs, "NUMERIC_PRECISION"),
+                            intOrNull(rs, "NUMERIC_SCALE"),
+                            intOrNull(rs, "CHARACTER_MAXIMUM_LENGTH")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return unchecked(() -> {
+            try (java.sql.Statement stmt = requireConnected().createStatement()) {
+                String qualifiedTable = JdbcIdentifiers.INSTANCE.doubleQuote(schema) + "." + JdbcIdentifiers.INSTANCE.doubleQuote(table);
+                try (ResultSet rs = stmt.executeQuery("SHOW IMPORTED KEYS IN TABLE " + qualifiedTable)) {
+                    List<ForeignKeyInfo> result = new ArrayList<>();
+                    while (rs.next()) {
+                        result.add(new ForeignKeyInfo(
+                            rs.getString("fk_name"),
+                            rs.getString("fk_column_name"),
+                            rs.getString("pk_table_name"),
+                            rs.getString("pk_column_name")
+                        ));
+                    }
+                    return result;
+                }
+            } catch (Exception ignored) {
+                return Collections.emptyList();
+            }
+        });
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "USE SCHEMA " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
+    }
+
+    @Override
+    protected Object resultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value = rs.getObject(index);
+            return rs.wasNull() ? null : value == null ? null : value.toString();
+        });
+    }
+
+    private static String buildUrl(ConnectParams params) {
+        return "jdbc:snowflake://" + params.getHost() + ":" + params.getPort() + "/?db=" + params.getDatabase();
+    }
+
+    private static boolean isUnconstrained(MetadataListConstraints constraints) {
+        return !constraints.hasFilter() && !constraints.hasLimit() && !constraints.hasOffset() && !constraints.hasObjectTypes();
+    }
+
+    private static boolean includesSupportedObjects(MetadataListConstraints constraints) {
+        return constraints.includesTableLikeTypes() || constraints.objectTypeAllowed("PROCEDURE");
+    }
+
+    private static void appendSnowflakeTableTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> types = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            types.add("BASE TABLE");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            types.add("VIEW");
+        }
+        if (constraints.tableTypeAllowed("MATERIALIZED_VIEW")) {
+            types.add("MATERIALIZED VIEW");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND TABLE_TYPE IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
+        args.addAll(types);
+    }
+
+    private static String normalizeTableType(String tableType) {
+        if ("BASE TABLE".equals(tableType)) {
+            return "TABLE";
+        }
+        if ("MATERIALIZED VIEW".equals(tableType)) {
+            return "MATERIALIZED_VIEW";
+        }
+        return tableType;
+    }
+
+    private static String blankToNull(String value) {
+        return value == null || value.isEmpty() ? null : value;
+    }
+
+    private static Integer intOrNull(ResultSet rs, String column) throws java.sql.SQLException {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new SnowflakeAgent()).run();
+    }
+}
diff --git a/agents/drivers/snowflake/src/test/java/com/dbx/agent/snowflake/SnowflakeAgentMetadataTest.java b/agents/drivers/snowflake/src/test/java/com/dbx/agent/snowflake/SnowflakeAgentMetadataTest.java
new file mode 100644
index 0000000..8708a7f
--- /dev/null
+++ b/agents/drivers/snowflake/src/test/java/com/dbx/agent/snowflake/SnowflakeAgentMetadataTest.java
@@ -0,0 +1,59 @@
+package com.dbx.agent.snowflake;
+
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.test.TestSupport;
+import com.dbx.agent.test.JdbcAgentFake;
+import com.dbx.agent.test.JdbcMetadataSqlFake;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class SnowflakeAgentMetadataTest {
+    @Test
+    void quotesSchemaAndTableIdentifiersInKeyMetadataSql() {
+        SnowflakeAgent agent = new SnowflakeAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.getColumns("bad\"schema", "bad\"table");
+        agent.listForeignKeys("bad\"schema", "bad\"table");
+
+        Assertions.assertTrue(
+            JdbcMetadataSqlFake.statements.contains(
+                "SHOW PRIMARY KEYS IN TABLE \"bad\"\"schema\".\"bad\"\"table\""
+            )
+        );
+        Assertions.assertTrue(
+            JdbcMetadataSqlFake.statements.contains(
+                "SHOW IMPORTED KEYS IN TABLE \"bad\"\"schema\".\"bad\"\"table\""
+            )
+        );
+    }
+
+    @Test
+    void constrainedTableMetadataPushesFilterTypesAndPaging() {
+        SnowflakeAgent agent = new SnowflakeAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listTables("PUBLIC", new MetadataListConstraints("ord", 25, 50, List.of("TABLE", "VIEW")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        Assertions.assertTrue(sql.contains("FROM INFORMATION_SCHEMA.TABLES"), sql);
+        Assertions.assertTrue(sql.contains("TABLE_TYPE IN (?, ?)"), sql);
+        Assertions.assertTrue(sql.contains("UPPER(TABLE_NAME) LIKE ? ESCAPE '\\\\'"), sql);
+        Assertions.assertTrue(sql.endsWith("LIMIT 25 OFFSET 50"), sql);
+    }
+
+    @Test
+    void constrainedObjectMetadataPushesProcedureSearchAndPaging() {
+        SnowflakeAgent agent = new SnowflakeAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listObjects("PUBLIC", new MetadataListConstraints("sync", 10, null, List.of("PROCEDURE")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        Assertions.assertTrue(sql.contains("FROM INFORMATION_SCHEMA.PROCEDURES"), sql);
+        Assertions.assertTrue(sql.contains("UPPER(PROCEDURE_NAME) LIKE ? ESCAPE '\\\\'"), sql);
+        Assertions.assertTrue(sql.contains("ORDER BY CASE OBJECT_TYPE"), sql);
+        Assertions.assertTrue(sql.endsWith("LIMIT 10"), sql);
+    }
+}
diff --git a/agents/drivers/snowflake/src/test/java/com/dbx/agent/snowflake/SnowflakeAgentTest.java b/agents/drivers/snowflake/src/test/java/com/dbx/agent/snowflake/SnowflakeAgentTest.java
new file mode 100644
index 0000000..11af6e4
--- /dev/null
+++ b/agents/drivers/snowflake/src/test/java/com/dbx/agent/snowflake/SnowflakeAgentTest.java
@@ -0,0 +1,16 @@
+package com.dbx.agent.snowflake;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+
+class SnowflakeAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new SnowflakeAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL sample_proc()";
+    }
+}
diff --git a/agents/drivers/spark/build.gradle b/agents/drivers/spark/build.gradle
new file mode 100644
index 0000000..868be72
--- /dev/null
+++ b/agents/drivers/spark/build.gradle
@@ -0,0 +1,11 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'org.apache.hive:hive-jdbc:4.0.1:standalone'
+    implementation 'org.slf4j:slf4j-nop:1.7.30'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Apache Spark', 'Main-Class': 'com.dbx.agent.spark.SparkAgent')
+    }
+}
diff --git a/agents/drivers/spark/src/main/java/com/dbx/agent/spark/SparkAgent.java b/agents/drivers/spark/src/main/java/com/dbx/agent/spark/SparkAgent.java
new file mode 100644
index 0000000..bbe1570
--- /dev/null
+++ b/agents/drivers/spark/src/main/java/com/dbx/agent/spark/SparkAgent.java
@@ -0,0 +1,341 @@
+package com.dbx.agent.spark;
+
+import com.dbx.agent.AbstractJdbcAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.QueryPageOptions;
+import com.dbx.agent.QueryPageResult;
+import com.dbx.agent.QueryResult;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
+
+// Spark Thrift Server speaks the HiveServer2 protocol, so the Spark agent reuses
+// the Hive JDBC driver and mirrors the Hive agent's metadata queries (SHOW
+// DATABASES / SHOW TABLES / DESCRIBE), which Spark SQL supports as well.
+//
+// Spark 3.4+ supports multiple catalogs (Paimon, Lance, Iceberg, ...). When the
+// user supplies `catalog=<name>` in url_params, the agent switches to that catalog
+// after connecting and uses `SHOW TABLES IN <catalog>` for listing — which works
+// uniformly for catalogs that have databases (Paimon) and those that expose tables
+// at the catalog root with no databases (Lance). Mirrors the StarRocks catalog flow.
+public final class SparkAgent extends AbstractJdbcAgent {
+    private String configuredCatalog;
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        // Hive JDBC fetches rows via Thrift FetchResults in batches controlled
+        // by fetchSize. A large fetchSize can fail with "Error retrieving next
+        // row" when the result contains large binary/struct columns. Use a
+        // small fetchSize (50) so each Thrift batch stays within limits.
+        return super.executeQuery(sql, schema, new ExecuteQueryOptions(
+            options.getMaxRows(),
+            50,
+            options.getTimeoutSecs()
+        ));
+    }
+
+    @Override
+    public QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {
+        return super.executeQueryPage(sql, schema, withSmallFetchSize(options));
+    }
+
+    @Override
+    public QueryPageResult startTableRead(String sql, String schema, QueryPageOptions options) {
+        return super.startTableRead(sql, schema, withSmallFetchSize(options));
+    }
+
+    private static QueryPageOptions withSmallFetchSize(QueryPageOptions options) {
+        return new QueryPageOptions(
+            options.getPageSize(), 50, options.getMaxRows(), options.getTimeoutSecs()
+        );
+    }
+
+    @Override
+    protected String driverClass() {
+        return "org.apache.hive.jdbc.HiveDriver";
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return "jdbc:hive2://" + params.getHost() + ":" + params.getPort() + "/";
+    }
+
+    @Override
+    protected void afterConnect(ConnectParams params, Connection connection) throws Exception {
+        String catalog = extractCatalogParam(params.getUrl_params());
+        configuredCatalog = catalog;
+        if (catalog != null && !catalog.isEmpty()) {
+            try (java.sql.Statement stmt = connection.createStatement()) {
+                stmt.execute("USE " + JdbcIdentifiers.INSTANCE.backtick(catalog));
+            }
+        }
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW DATABASES")) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString(1)));
+                }
+            }
+            // Catalogs like Lance expose tables at the catalog root with no
+            // databases — SHOW DATABASES returns nothing. Return the catalog
+            // name itself as the database node so the sidebar can drill in.
+            if (result.isEmpty() && configuredCatalog != null && !configuredCatalog.isEmpty()) {
+                result.add(new DatabaseInfo(configuredCatalog));
+            }
+            result.sort(Comparator.comparing(DatabaseInfo::getName));
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        List<String> result = new ArrayList<>();
+        for (DatabaseInfo database : listDatabases()) {
+            result.add(database.getName());
+        }
+        return result;
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            String sql = buildShowTablesSql(schema);
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(sql)) {
+                while (rs.next()) {
+                    String name = readTableName(rs);
+                    if (name != null && !name.isEmpty()) {
+                        result.add(new TableInfo(name, "TABLE", null));
+                    }
+                }
+            }
+            result.sort(Comparator.comparing(TableInfo::getName));
+            return result;
+        });
+    }
+
+    // With a catalog configured, use `SHOW TABLES IN <catalog>[.<schema>]` which
+    // works for both catalog-root tables (Lance) and catalog.schema tables (Paimon).
+    // Without a catalog, fall back to the Hive-style `USE <schema>` + SHOW TABLES.
+    private String buildShowTablesSql(String schema) throws Exception {
+        if (configuredCatalog != null && !configuredCatalog.isEmpty()) {
+            String target = JdbcIdentifiers.INSTANCE.backtick(configuredCatalog);
+            if (schema != null && !schema.isEmpty() && !schema.equals(configuredCatalog)) {
+                target += "." + JdbcIdentifiers.INSTANCE.backtick(schema);
+            }
+            return "SHOW TABLES IN " + target;
+        }
+        useSchema(schema);
+        return "SHOW TABLES";
+    }
+
+    // `SHOW TABLES` (Hive style) returns a single tabName column, while
+    // `SHOW TABLES IN <catalog>` (Spark SQL) returns (database, tableName,
+    // isTemporary). Pick tableName from whichever column it lives in.
+    private static String readTableName(ResultSet rs) throws Exception {
+        int columns = rs.getMetaData().getColumnCount();
+        return columns > 1 ? rs.getString(2) : rs.getString(1);
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            try {
+                return getColumnsFromDescribe(schema, table);
+            } catch (Exception ignored) {
+                return getColumnsFromMetadata(requireConnected(), schema, table);
+            }
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        // When a catalog is configured, qualify the USE statement with the
+        // catalog so switching schemas does not reset the catalog back to the
+        // default (spark_catalog).
+        if (configuredCatalog != null && !configuredCatalog.isEmpty()) {
+            if (schema == null || schema.isEmpty() || schema.equals(configuredCatalog)) {
+                return "USE " + JdbcIdentifiers.INSTANCE.backtick(configuredCatalog);
+            }
+            return "USE " + JdbcIdentifiers.INSTANCE.backtick(configuredCatalog)
+                + "." + JdbcIdentifiers.INSTANCE.backtick(schema);
+        }
+        return "USE " + JdbcIdentifiers.INSTANCE.backtick(schema);
+    }
+
+    private static String extractCatalogParam(String urlParams) {
+        if (urlParams == null || urlParams.isEmpty()) {
+            return null;
+        }
+        for (String segment : urlParams.split("&")) {
+            int eq = segment.indexOf('=');
+            if (eq <= 0) {
+                continue;
+            }
+            if (segment.substring(0, eq).trim().equalsIgnoreCase("catalog")) {
+                String value = segment.substring(eq + 1).trim();
+                return value.isEmpty() ? null : value;
+            }
+        }
+        return null;
+    }
+
+    @Override
+    protected Object resultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value = rs.getObject(index);
+            return rs.wasNull() ? null : value == null ? null : value.toString();
+        });
+    }
+
+    private void useSchema(String schema) throws Exception {
+        try (java.sql.Statement stmt = requireConnected().createStatement()) {
+            stmt.execute(setSchemaSQL(schema));
+        }
+    }
+
+    private List<ColumnInfo> getColumnsFromDescribe(String schema, String table) throws Exception {
+        List<ColumnInfo> result = new ArrayList<>();
+        // Use catalog-qualified DESCRIBE when a catalog is configured, avoiding
+        // USE <schema> which would generate USE `catalog`.`catalog` when the
+        // sidebar passes the catalog name as the schema (Lance case).
+        String describeTarget;
+        if (configuredCatalog != null && !configuredCatalog.isEmpty()) {
+            describeTarget = JdbcIdentifiers.INSTANCE.backtick(configuredCatalog);
+            if (schema != null && !schema.isEmpty() && !schema.equals(configuredCatalog)) {
+                describeTarget += "." + JdbcIdentifiers.INSTANCE.backtick(schema);
+            }
+            describeTarget += "." + JdbcIdentifiers.INSTANCE.backtick(table);
+        } else {
+            useSchema(schema);
+            describeTarget = JdbcIdentifiers.INSTANCE.backtick(table);
+        }
+        try (java.sql.Statement stmt = requireConnected().createStatement();
+             ResultSet rs = stmt.executeQuery("DESCRIBE " + describeTarget)) {
+            while (rs.next()) {
+                String colName = trimToNull(rs.getString(1));
+                if (colName == null || colName.startsWith("#")) {
+                    continue;
+                }
+                result.add(new ColumnInfo(
+                    colName,
+                    trimToEmpty(rs.getString(2)),
+                    true,
+                    null,
+                    false,
+                    null,
+                    optionalComment(rs),
+                    null,
+                    null,
+                    null
+                ));
+            }
+        }
+        return result;
+    }
+
+    private static List<ColumnInfo> getColumnsFromMetadata(Connection conn, String schema, String table) throws Exception {
+        List<ColumnInfo> result = new ArrayList<>();
+        DatabaseMetaData meta = conn.getMetaData();
+        try (ResultSet rs = meta.getColumns(null, trimToNull(schema), table, "%")) {
+            while (rs.next()) {
+                String name = rs.getString("COLUMN_NAME");
+                if (trimToNull(name) == null) {
+                    continue;
+                }
+                result.add(new ColumnInfo(
+                    name,
+                    trimToEmpty(rs.getString("TYPE_NAME")),
+                    rs.getInt("NULLABLE") != DatabaseMetaData.columnNoNulls,
+                    rs.getString("COLUMN_DEF"),
+                    false,
+                    null,
+                    rs.getString("REMARKS"),
+                    intOrNull(rs, "COLUMN_SIZE"),
+                    intOrNull(rs, "DECIMAL_DIGITS"),
+                    characterLength(rs)
+                ));
+            }
+        }
+        return result;
+    }
+
+    private static String trimToNull(String value) {
+        if (value == null) {
+            return null;
+        }
+        String trimmed = value.trim();
+        return trimmed.isEmpty() ? null : trimmed;
+    }
+
+    private static String trimToEmpty(String value) {
+        return value == null ? "" : value.trim();
+    }
+
+    private static Integer intOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    private static Integer characterLength(ResultSet rs) throws Exception {
+        String typeName = rs.getString("TYPE_NAME");
+        if (typeName == null) {
+            return null;
+        }
+        String normalized = typeName.toLowerCase(Locale.ROOT);
+        if (!normalized.contains("char") && !normalized.contains("text") && !normalized.contains("string")) {
+            return null;
+        }
+        return intOrNull(rs, "COLUMN_SIZE");
+    }
+
+    private static String optionalComment(ResultSet rs) {
+        return unchecked(() -> {
+            try {
+                String comment = trimToNull(rs.getString(3));
+                return comment;
+            } catch (Exception e) {
+                return null;
+            }
+        });
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new SparkAgent()).run();
+    }
+}
diff --git a/agents/drivers/sqlserver-legacy/build.gradle b/agents/drivers/sqlserver-legacy/build.gradle
new file mode 100644
index 0000000..6930022
--- /dev/null
+++ b/agents/drivers/sqlserver-legacy/build.gradle
@@ -0,0 +1,12 @@
+dependencies {
+    implementation 'com.microsoft.sqlserver:mssql-jdbc:13.2.0.jre11'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes(
+            'Agent-Label': 'SQL Server legacy compatibility component',
+            'Main-Class': 'com.dbx.agent.sqlserverlegacy.SqlServerLegacyAgent'
+        )
+    }
+}
diff --git a/agents/drivers/sqlserver-legacy/src/main/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgent.java b/agents/drivers/sqlserver-legacy/src/main/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgent.java
new file mode 100644
index 0000000..eac8b40
--- /dev/null
+++ b/agents/drivers/sqlserver-legacy/src/main/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgent.java
@@ -0,0 +1,264 @@
+package com.dbx.agent.sqlserverlegacy;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+
+import java.security.Security;
+import java.sql.Connection;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+public final class SqlServerLegacyAgent extends ConfiguredJdbcAgent {
+    private static final String TLS_DISABLED_ALGORITHMS_KEY = "jdk.tls.disabledAlgorithms";
+    private static final Set<String> LEGACY_TLS_ALGORITHMS_TO_ALLOW = Set.of(
+        "TLSV1",
+        "TLSV1.1",
+        "DTLSV1.0",
+        "3DES_EDE_CBC",
+        "RC4",
+        "DES",
+        "MD5WITHRSA",
+        "DH KEYSIZE < 1024",
+        "RSA KEYSIZE < 1024"
+    );
+    private static final Set<String> INTERNAL_URL_PARAMS = Set.of(
+        "SQLSERVERENCRYPTION",
+        "ENCRYPT",
+        "TRUSTSERVERCERTIFICATE",
+        "SSLPROTOCOL"
+    );
+    private static final JdbcAgentProfile PROFILE = new JdbcAgentProfile(
+        "com.microsoft.sqlserver.jdbc.SQLServerDriver",
+        "jdbc:sqlserver://{host}:{port};databaseName={database};",
+        1433,
+        true,
+        Set.of("INFORMATION_SCHEMA", "SYS"),
+        Arrays.asList("TABLE", "VIEW", "SYSTEM TABLE")
+    );
+
+    public SqlServerLegacyAgent() {
+        super(PROFILE);
+        // AbstractJdbcAgent loads the JDBC driver before building the URL, so relax
+        // the legacy TLS policy here before the driver can initialize JSSE.
+        enableLegacyTlsAlgorithms();
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return legacyTlsUrl(params);
+    }
+
+    @Override
+    protected Connection openConnection(ConnectParams params) throws Exception {
+        try {
+            return super.openConnection(params);
+        } catch (SQLException error) {
+            throw withLegacyTlsDiagnostics(error);
+        }
+    }
+
+    static String legacyTlsUrl(ConnectParams params) {
+        Map<String, String> properties = baseConnectionProperties(params);
+        properties.put("encrypt", "true");
+        properties.put("trustServerCertificate", "true");
+        properties.put("sslProtocol", "TLSv1");
+        return appendProperties(baseJdbcUrl(params), properties);
+    }
+
+    static String relaxedDisabledAlgorithms(String current) {
+        if (current == null || current.trim().isEmpty()) {
+            return "";
+        }
+
+        List<String> kept = new ArrayList<>();
+        for (String rawPart : current.split(",")) {
+            String part = rawPart.trim();
+            if (part.isEmpty()) {
+                continue;
+            }
+            if (!LEGACY_TLS_ALGORITHMS_TO_ALLOW.contains(part.toUpperCase(Locale.ROOT))) {
+                kept.add(part);
+            }
+        }
+        return String.join(", ", kept);
+    }
+
+    static String legacyTlsDiagnostics() {
+        String disabledAlgorithms = Security.getProperty(TLS_DISABLED_ALGORITHMS_KEY);
+        return "DBX SQL Server legacy TLS diagnostics: java=" + System.getProperty("java.version", "unknown")
+            + ", javaVendor=" + System.getProperty("java.vendor", "unknown")
+            + ", jdbc=" + jdbcDriverVersion()
+            + ", sslProtocol=TLSv1"
+            + ", tlsV1Disabled=" + isDisabled(disabledAlgorithms, "TLSV1")
+            + ", 3desDisabled=" + isDisabled(disabledAlgorithms, "3DES_EDE_CBC")
+            + ", rc4Disabled=" + isDisabled(disabledAlgorithms, "RC4");
+    }
+
+    static SQLException withLegacyTlsDiagnostics(SQLException error) {
+        String message = error.getMessage() == null ? error.toString() : error.getMessage();
+        return new SQLException(
+            message + "\n\n" + legacyTlsDiagnostics(),
+            error.getSQLState(),
+            error.getErrorCode(),
+            error
+        );
+    }
+
+    private static boolean isDisabled(String disabledAlgorithms, String algorithm) {
+        if (disabledAlgorithms == null || disabledAlgorithms.trim().isEmpty()) {
+            return false;
+        }
+        for (String rawPart : disabledAlgorithms.split(",")) {
+            if (algorithm.equals(rawPart.trim().toUpperCase(Locale.ROOT))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static String jdbcDriverVersion() {
+        try {
+            Driver driver = DriverManager.getDriver("jdbc:sqlserver://localhost");
+            Package driverPackage = driver.getClass().getPackage();
+            String implementationVersion = driverPackage == null ? null : driverPackage.getImplementationVersion();
+            if (implementationVersion != null && !implementationVersion.trim().isEmpty()) {
+                return implementationVersion;
+            }
+            return driver.getMajorVersion() + "." + driver.getMinorVersion();
+        } catch (SQLException ignored) {
+            return "unknown";
+        }
+    }
+
+    private static void enableLegacyTlsAlgorithms() {
+        String current = Security.getProperty(TLS_DISABLED_ALGORITHMS_KEY);
+        String relaxed = relaxedDisabledAlgorithms(current);
+        if (!Objects.equals(current, relaxed)) {
+            Security.setProperty(TLS_DISABLED_ALGORITHMS_KEY, relaxed);
+        }
+    }
+
+    private static String baseJdbcUrl(ConnectParams params) {
+        String connectionString = params.getConnection_string();
+        if (connectionString != null && !connectionString.trim().isEmpty()) {
+            return sanitizeSqlServerUrl(connectionString.trim());
+        }
+
+        String host = normalizedSqlServerHost(params.getHost());
+        StringBuilder url = new StringBuilder("jdbc:sqlserver://")
+            .append(host);
+        if (!usesNamedInstance(host)) {
+            int port = params.getPort() > 0 ? params.getPort() : PROFILE.getDefaultPort();
+            url.append(":").append(port);
+        }
+        if (params.getDatabase() != null && !params.getDatabase().trim().isEmpty()) {
+            url.append(";databaseName=").append(params.getDatabase().trim());
+        }
+        return trimSqlServerUrl(url.toString());
+    }
+
+    private static String normalizedSqlServerHost(String value) {
+        String host = value == null ? "" : value.trim();
+        int separator = host.indexOf('\\');
+        if (separator <= 0 || separator >= host.length() - 1) {
+            return host;
+        }
+
+        String server = host.substring(0, separator).trim();
+        String instance = host.substring(separator + 1).trim();
+        if (server.isEmpty() || instance.isEmpty()) {
+            return host;
+        }
+        return server + "\\" + instance;
+    }
+
+    private static boolean usesNamedInstance(String host) {
+        int separator = host.indexOf('\\');
+        return separator > 0 && separator < host.length() - 1;
+    }
+
+    private static String sanitizeSqlServerUrl(String value) {
+        String trimmed = trimSqlServerUrl(value);
+        String[] parts = trimmed.split(";");
+        if (parts.length <= 1) {
+            return trimmed;
+        }
+        StringBuilder result = new StringBuilder(parts[0].trim());
+        for (int i = 1; i < parts.length; i++) {
+            String part = parts[i].trim();
+            if (part.isEmpty()) {
+                continue;
+            }
+            int separator = part.indexOf('=');
+            if (separator <= 0) {
+                result.append(";").append(part);
+                continue;
+            }
+            String key = part.substring(0, separator).trim();
+            if (!INTERNAL_URL_PARAMS.contains(key.toUpperCase(Locale.ROOT))) {
+                result.append(";").append(part);
+            }
+        }
+        return result.toString();
+    }
+
+    private static Map<String, String> baseConnectionProperties(ConnectParams params) {
+        Map<String, String> properties = new LinkedHashMap<>();
+        String urlParams = params.getUrl_params();
+        if (urlParams == null || urlParams.trim().isEmpty()) {
+            return properties;
+        }
+
+        for (String pair : urlParams.trim().split("[&;]")) {
+            String value = pair.trim();
+            while (value.startsWith("?") || value.startsWith("&") || value.startsWith(";")) {
+                value = value.substring(1).trim();
+            }
+            if (value.isEmpty()) {
+                continue;
+            }
+            int separator = value.indexOf('=');
+            if (separator <= 0) {
+                continue;
+            }
+            String key = value.substring(0, separator).trim();
+            String normalizedKey = key.toUpperCase(Locale.ROOT);
+            if (key.isEmpty() || INTERNAL_URL_PARAMS.contains(normalizedKey)) {
+                continue;
+            }
+            properties.put(key, value.substring(separator + 1).trim());
+        }
+        return properties;
+    }
+
+    private static String appendProperties(String base, Map<String, String> properties) {
+        StringBuilder url = new StringBuilder(trimSqlServerUrl(base));
+        for (Map.Entry<String, String> entry : properties.entrySet()) {
+            url.append(";").append(entry.getKey()).append("=").append(entry.getValue());
+        }
+        return url.toString();
+    }
+
+    private static String trimSqlServerUrl(String value) {
+        String trimmed = value.trim();
+        while (trimmed.endsWith(";") || trimmed.endsWith("&") || trimmed.endsWith("?")) {
+            trimmed = trimmed.substring(0, trimmed.length() - 1).trim();
+        }
+        return trimmed;
+    }
+
+    public static void main(String[] args) throws Exception {
+        new JsonRpcServer(new SqlServerLegacyAgent()).run();
+    }
+}
diff --git a/agents/drivers/sqlserver-legacy/src/test/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgentTest.java b/agents/drivers/sqlserver-legacy/src/test/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgentTest.java
new file mode 100644
index 0000000..2f3249f
--- /dev/null
+++ b/agents/drivers/sqlserver-legacy/src/test/java/com/dbx/agent/sqlserverlegacy/SqlServerLegacyAgentTest.java
@@ -0,0 +1,111 @@
+package com.dbx.agent.sqlserverlegacy;
+
+import com.dbx.agent.ConnectParams;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.security.Security;
+import java.sql.SQLException;
+
+class SqlServerLegacyAgentTest {
+    @Test
+    void constructorRelaxesLegacyTlsPolicyBeforeDriverLoading() {
+        String key = "jdk.tls.disabledAlgorithms";
+        String original = Security.getProperty(key);
+        try {
+            Security.setProperty(key, "TLSv1, TLSv1.1, 3DES_EDE_CBC, EC keySize < 224");
+
+            new SqlServerLegacyAgent();
+
+            Assertions.assertEquals("EC keySize < 224", Security.getProperty(key));
+            String diagnostics = SqlServerLegacyAgent.legacyTlsDiagnostics();
+            Assertions.assertTrue(diagnostics.contains("sslProtocol=TLSv1"));
+            Assertions.assertTrue(diagnostics.contains("tlsV1Disabled=false"));
+            Assertions.assertTrue(diagnostics.contains("3desDisabled=false"));
+            Assertions.assertTrue(diagnostics.contains("rc4Disabled=false"));
+        } finally {
+            Security.setProperty(key, original == null ? "" : original);
+        }
+    }
+
+    @Test
+    void connectionErrorsPreserveDetailsAndIncludeRuntimeDiagnostics() {
+        SQLException original = new SQLException("TLS handshake failed", "08001", 1234);
+
+        SQLException error = SqlServerLegacyAgent.withLegacyTlsDiagnostics(original);
+
+        Assertions.assertEquals("08001", error.getSQLState());
+        Assertions.assertEquals(1234, error.getErrorCode());
+        Assertions.assertSame(original, error.getCause());
+        Assertions.assertTrue(error.getMessage().contains("TLS handshake failed"));
+        Assertions.assertTrue(error.getMessage().contains("DBX SQL Server legacy TLS diagnostics:"));
+    }
+
+    @Test
+    void legacyTlsUrlUsesSqlServerTlsV1Properties() {
+        ConnectParams params = new ConnectParams(
+            "db.example.com",
+            14330,
+            "appdb",
+            "sa",
+            "secret",
+            "applicationName=dbx;sqlserverEncryption=disabled;encrypt=false;trustServerCertificate=false;sslProtocol=TLSv1.2",
+            "",
+            false
+        );
+
+        Assertions.assertEquals(
+            "jdbc:sqlserver://db.example.com:14330;databaseName=appdb;applicationName=dbx;encrypt=true;trustServerCertificate=true;sslProtocol=TLSv1",
+            SqlServerLegacyAgent.legacyTlsUrl(params)
+        );
+    }
+
+    @Test
+    void legacyTlsUrlKeepsNamedInstanceWithoutPort() {
+        ConnectParams params = new ConnectParams(
+            "db.example.com\\SQLEXPRESS",
+            1433,
+            "appdb",
+            "sa",
+            "secret",
+            "applicationName=dbx",
+            "",
+            false
+        );
+
+        Assertions.assertEquals(
+            "jdbc:sqlserver://db.example.com\\SQLEXPRESS;databaseName=appdb;applicationName=dbx;encrypt=true;trustServerCertificate=true;sslProtocol=TLSv1",
+            SqlServerLegacyAgent.legacyTlsUrl(params)
+        );
+    }
+
+    @Test
+    void legacyTlsUrlNormalizesExplicitConnectionString() {
+        ConnectParams params = new ConnectParams(
+            "ignored",
+            0,
+            "",
+            "sa",
+            "secret",
+            "applicationName=dbx",
+            "jdbc:sqlserver://db.example.com:1433;encrypt=false;databaseName=custom;trustServerCertificate=false;sslProtocol=TLSv1.2;",
+            false
+        );
+
+        Assertions.assertEquals(
+            "jdbc:sqlserver://db.example.com:1433;databaseName=custom;applicationName=dbx;encrypt=true;trustServerCertificate=true;sslProtocol=TLSv1",
+            SqlServerLegacyAgent.legacyTlsUrl(params)
+        );
+    }
+
+    @Test
+    void relaxedDisabledAlgorithmsRemovesOnlyLegacyTlsEntries() {
+        String current =
+            "SSLv3, TLSv1, TLSv1.1, DTLSv1.0, RC4, DES, MD5withRSA, DH keySize < 1024, EC keySize < 224, 3DES_EDE_CBC, anon, NULL";
+
+        Assertions.assertEquals(
+            "SSLv3, EC keySize < 224, anon, NULL",
+            SqlServerLegacyAgent.relaxedDisabledAlgorithms(current)
+        );
+    }
+}
diff --git a/agents/drivers/sundb/build.gradle b/agents/drivers/sundb/build.gradle
new file mode 100644
index 0000000..ef14a73
--- /dev/null
+++ b/agents/drivers/sundb/build.gradle
@@ -0,0 +1,13 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes(
+            'Agent-Label': 'SunDB',
+            'Agent-External-Driver': 'true',
+            'Main-Class': 'com.dbx.agent.sundb.SundbAgent'
+        )
+    }
+}
diff --git a/agents/drivers/sundb/src/main/java/com/dbx/agent/sundb/SundbAgent.java b/agents/drivers/sundb/src/main/java/com/dbx/agent/sundb/SundbAgent.java
new file mode 100644
index 0000000..e36620f
--- /dev/null
+++ b/agents/drivers/sundb/src/main/java/com/dbx/agent/sundb/SundbAgent.java
@@ -0,0 +1,530 @@
+package com.dbx.agent.sundb;
+
+import com.dbx.agent.BaseDatabaseAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcExecutor;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.MetadataSqlSupport;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+public final class SundbAgent extends BaseDatabaseAgent {
+    private Connection connection;
+
+    @Override
+    public Connection getConnection() {
+        return connection;
+    }
+
+    @Override
+    public void connect(ConnectParams params) {
+        uncheckedVoid(() -> {
+            Class.forName("com.sundb.jdbc.SundbDriver");
+            String url = buildUrl(params);
+            connection = DriverManager.getConnection(url, params.getUsername(), params.getPassword());
+        });
+    }
+
+    @Override
+    public boolean testConnection(ConnectParams params) {
+        return unchecked(() -> {
+            Class.forName("com.sundb.jdbc.SundbDriver");
+            String url = buildUrl(params);
+            try (Connection conn = DriverManager.getConnection(url, params.getUsername(), params.getPassword())) {
+                return conn.isValid(5);
+            }
+        });
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (var stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW DATABASES")) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString(1)));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        List<String> result = new ArrayList<>();
+        for (DatabaseInfo database : listDatabases()) {
+            result.add(database.getName());
+        }
+        return result;
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            try (var stmt = requireConnected().prepareStatement(
+                "SELECT TABLE_NAME, TABLE_TYPE FROM information_schema.TABLES WHERE TABLE_SCHEMA = ? ORDER BY TABLE_NAME"
+            )) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String tableType = rs.getString("TABLE_TYPE");
+                        if ("BASE TABLE".equals(tableType)) {
+                            tableType = "TABLE";
+                        }
+                        result.add(new TableInfo(rs.getString("TABLE_NAME"), tableType, null));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listTables(schema);
+        }
+        if (!normalized.includesTableLikeTypes()) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedTables(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterTables(listTables(schema));
+        }
+    }
+
+    private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            StringBuilder sql = new StringBuilder("SELECT TABLE_NAME, TABLE_TYPE FROM information_schema.TABLES WHERE TABLE_SCHEMA = ?");
+            args.add(schema);
+            appendInformationSchemaTableTypePredicate(sql, args, constraints);
+            MetadataSqlSupport.appendNameFilter(sql, args, "TABLE_NAME", constraints);
+            sql.append(" ORDER BY TABLE_NAME");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (var stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(rs.getString("TABLE_NAME"), normalizeTableType(rs.getString("TABLE_TYPE")), null));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterTables(result);
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            for (TableInfo table : listTables(schema)) {
+                result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+            }
+
+            try (var stmt = requireConnected().prepareStatement(
+                "SELECT ROUTINE_NAME, ROUTINE_TYPE FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ? ORDER BY ROUTINE_NAME"
+            )) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1), rs.getString(2), schema, null));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listObjects(schema);
+        }
+        if (!includesSupportedObjects(normalized)) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedObjects(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterObjects(listObjects(schema));
+        }
+    }
+
+    private List<ObjectInfo> queryConstrainedObjects(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<ObjectInfo> result = new ArrayList<>();
+            List<String> branches = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            if (constraints.includesTableLikeTypes()) {
+                StringBuilder tableSql = new StringBuilder("SELECT TABLE_NAME AS OBJECT_NAME, TABLE_TYPE AS OBJECT_TYPE FROM information_schema.TABLES WHERE TABLE_SCHEMA = ?");
+                args.add(schema);
+                appendInformationSchemaTableTypePredicate(tableSql, args, constraints);
+                MetadataSqlSupport.appendNameFilter(tableSql, args, "TABLE_NAME", constraints);
+                branches.add(tableSql.toString());
+            }
+            if (constraints.objectTypeAllowed("PROCEDURE") || constraints.objectTypeAllowed("FUNCTION")) {
+                StringBuilder routineSql = new StringBuilder("SELECT ROUTINE_NAME AS OBJECT_NAME, ROUTINE_TYPE AS OBJECT_TYPE FROM information_schema.ROUTINES WHERE ROUTINE_SCHEMA = ?");
+                args.add(schema);
+                appendRoutineTypePredicate(routineSql, args, constraints);
+                MetadataSqlSupport.appendNameFilter(routineSql, args, "ROUTINE_NAME", constraints);
+                branches.add(routineSql.toString());
+            }
+            if (branches.isEmpty()) {
+                return List.of();
+            }
+            StringBuilder sql = new StringBuilder("SELECT OBJECT_NAME, OBJECT_TYPE FROM (")
+                .append(String.join(" UNION ALL ", branches))
+                .append(") metadata_objects ORDER BY CASE OBJECT_TYPE WHEN 'BASE TABLE' THEN 0 WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 WHEN 'PROCEDURE' THEN 2 WHEN 'FUNCTION' THEN 3 ELSE 9 END, OBJECT_NAME");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (var stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ObjectInfo(rs.getString(1), normalizeTableType(rs.getString(2)), schema, null));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterObjects(result);
+        });
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        return unchecked(() -> {
+            String sql = switch (objectType.toUpperCase(Locale.ROOT)) {
+                case "VIEW" -> "SHOW CREATE VIEW `" + name.replace("`", "``") + "`";
+                case "PROCEDURE" -> "SHOW CREATE PROCEDURE `" + name.replace("`", "``") + "`";
+                case "FUNCTION" -> "SHOW CREATE FUNCTION `" + name.replace("`", "``") + "`";
+                default -> throw new IllegalArgumentException("Unsupported object type: " + objectType);
+            };
+
+            String source = "";
+            try (var stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(sql)) {
+                if (rs.next()) {
+                    int index = "VIEW".equals(objectType.toUpperCase(Locale.ROOT)) ? 1 : 2;
+                    String value = rs.getString(index + 1);
+                    source = value == null ? "" : value;
+                }
+            }
+            return new ObjectSource(name, objectType, schema, source);
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            Set<String> primaryKeys = new HashSet<>();
+            try (var stmt = requireConnected().prepareStatement(
+                """
+                SELECT COLUMN_NAME
+                FROM information_schema.KEY_COLUMN_USAGE
+                WHERE TABLE_SCHEMA = ?
+                    AND TABLE_NAME = ?
+                    AND CONSTRAINT_NAME = 'PRIMARY'
+                """
+            )) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        primaryKeys.add(rs.getString("COLUMN_NAME"));
+                    }
+                }
+            }
+
+            List<ColumnInfo> result = new ArrayList<>();
+            try (var stmt = requireConnected().prepareStatement(
+                """
+                SELECT COLUMN_NAME, COLUMN_TYPE, IS_NULLABLE, COLUMN_DEFAULT, EXTRA, COLUMN_COMMENT,
+                       NUMERIC_PRECISION, NUMERIC_SCALE, CHARACTER_MAXIMUM_LENGTH
+                FROM information_schema.COLUMNS
+                WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?
+                ORDER BY ORDINAL_POSITION
+                """
+            )) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        String columnName = rs.getString("COLUMN_NAME");
+                        result.add(new ColumnInfo(
+                            columnName,
+                            rs.getString("COLUMN_TYPE"),
+                            "YES".equals(rs.getString("IS_NULLABLE")),
+                            rs.getString("COLUMN_DEFAULT"),
+                            primaryKeys.contains(columnName),
+                            rs.getString("EXTRA"),
+                            emptyToNull(rs.getString("COLUMN_COMMENT")),
+                            integerOrNull(rs, "NUMERIC_PRECISION"),
+                            integerOrNull(rs, "NUMERIC_SCALE"),
+                            numberToIntOrNull(rs, "CHARACTER_MAXIMUM_LENGTH")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return unchecked(() -> {
+            try (var stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery(
+                     "SHOW INDEX FROM " + JdbcIdentifiers.INSTANCE.backtick(table)
+                         + " FROM " + JdbcIdentifiers.INSTANCE.backtick(schema)
+                 )) {
+                Map<String, List<IndexColumn>> indexMap = new LinkedHashMap<>();
+                Map<String, Boolean> uniqueMap = new HashMap<>();
+                Map<String, String> typeMap = new HashMap<>();
+
+                while (rs.next()) {
+                    String indexName = rs.getString("Key_name");
+                    String columnName = rs.getString("Column_name");
+                    int sequence = rs.getInt("Seq_in_index");
+                    int nonUnique = rs.getInt("Non_unique");
+                    String indexType = rs.getString("Index_type");
+
+                    indexMap.computeIfAbsent(indexName, ignored -> new ArrayList<>())
+                        .add(new IndexColumn(sequence, columnName));
+                    uniqueMap.put(indexName, nonUnique == 0);
+                    typeMap.put(indexName, indexType);
+                }
+
+                List<IndexInfo> result = new ArrayList<>();
+                for (Map.Entry<String, List<IndexColumn>> entry : indexMap.entrySet()) {
+                    String name = entry.getKey();
+                    List<String> columns = entry.getValue().stream()
+                        .sorted(Comparator.comparingInt(IndexColumn::sequence))
+                        .map(IndexColumn::name)
+                        .toList();
+                    result.add(new IndexInfo(
+                        name,
+                        columns,
+                        uniqueMap.getOrDefault(name, false),
+                        "PRIMARY".equals(name),
+                        null,
+                        typeMap.get(name),
+                        null,
+                        null
+                    ));
+                }
+                return result;
+            }
+        });
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return unchecked(() -> {
+            List<ForeignKeyInfo> result = new ArrayList<>();
+            try (var stmt = requireConnected().prepareStatement(
+                """
+                SELECT CONSTRAINT_NAME, COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+                FROM information_schema.KEY_COLUMN_USAGE
+                WHERE TABLE_SCHEMA = ?
+                    AND TABLE_NAME = ?
+                    AND REFERENCED_TABLE_NAME IS NOT NULL
+                ORDER BY CONSTRAINT_NAME
+                """
+            )) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new ForeignKeyInfo(
+                            rs.getString("CONSTRAINT_NAME"),
+                            rs.getString("COLUMN_NAME"),
+                            rs.getString("REFERENCED_TABLE_NAME"),
+                            rs.getString("REFERENCED_COLUMN_NAME")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return unchecked(() -> {
+            List<TriggerInfo> result = new ArrayList<>();
+            try (var stmt = requireConnected().prepareStatement(
+                """
+                SELECT TRIGGER_NAME, EVENT_MANIPULATION, ACTION_TIMING
+                FROM information_schema.TRIGGERS
+                WHERE TRIGGER_SCHEMA = ? AND EVENT_OBJECT_TABLE = ?
+                ORDER BY TRIGGER_NAME
+                """
+            )) {
+                stmt.setString(1, schema);
+                stmt.setString(2, table);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TriggerInfo(
+                            rs.getString("TRIGGER_NAME"),
+                            rs.getString("EVENT_MANIPULATION"),
+                            rs.getString("ACTION_TIMING")
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        return JdbcExecutor.INSTANCE.execute(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options.getMaxRows(),
+            options.getFetchSize(),
+            options.getTimeoutSecs(),
+            this::getResultValue
+        );
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "USE " + JdbcIdentifiers.INSTANCE.backtick(schema);
+    }
+
+    @Override
+    public void disconnect() {
+        uncheckedVoid(() -> {
+            if (connection != null) {
+                connection.close();
+            }
+            connection = null;
+        });
+    }
+
+    private static String buildUrl(ConnectParams params) {
+        return "jdbc:sundb://" + params.getHost() + ":" + params.getPort() + "/" + params.getDatabase();
+    }
+
+    private static boolean isUnconstrained(MetadataListConstraints constraints) {
+        return !constraints.hasFilter() && !constraints.hasLimit() && !constraints.hasOffset() && !constraints.hasObjectTypes();
+    }
+
+    private static boolean includesSupportedObjects(MetadataListConstraints constraints) {
+        return constraints.includesTableLikeTypes()
+            || constraints.objectTypeAllowed("PROCEDURE")
+            || constraints.objectTypeAllowed("FUNCTION");
+    }
+
+    private static void appendInformationSchemaTableTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> types = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            types.add("BASE TABLE");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            types.add("VIEW");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND TABLE_TYPE IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
+        args.addAll(types);
+    }
+
+    private static void appendRoutineTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> types = new ArrayList<>();
+        if (constraints.objectTypeAllowed("PROCEDURE")) {
+            types.add("PROCEDURE");
+        }
+        if (constraints.objectTypeAllowed("FUNCTION")) {
+            types.add("FUNCTION");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND ROUTINE_TYPE IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
+        args.addAll(types);
+    }
+
+    private static String normalizeTableType(String tableType) {
+        return "BASE TABLE".equals(tableType) ? "TABLE" : tableType;
+    }
+
+    private static Integer integerOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Integer ? (Integer) value : null;
+    }
+
+    private static Integer numberToIntOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    private static String emptyToNull(String value) {
+        return value == null || value.isEmpty() ? null : value;
+    }
+
+    private Object getResultValue(ResultSet rs, int index, int sqlType) {
+        try {
+            Object value = switch (sqlType) {
+                case Types.BIGINT -> rs.getLong(index);
+                case Types.INTEGER, Types.SMALLINT, Types.TINYINT -> rs.getInt(index);
+                case Types.FLOAT, Types.REAL -> rs.getFloat(index);
+                case Types.DOUBLE -> rs.getDouble(index);
+                case Types.DECIMAL, Types.NUMERIC -> rs.getBigDecimal(index);
+                case Types.BOOLEAN, Types.BIT -> rs.getBoolean(index);
+                default -> rs.getString(index);
+            };
+            return rs.wasNull() ? null : value;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private record IndexColumn(int sequence, String name) {
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new SundbAgent()).run();
+    }
+}
diff --git a/agents/drivers/sundb/src/test/java/com/dbx/agent/sundb/SundbAgentMetadataTest.java b/agents/drivers/sundb/src/test/java/com/dbx/agent/sundb/SundbAgentMetadataTest.java
new file mode 100644
index 0000000..2fd7c91
--- /dev/null
+++ b/agents/drivers/sundb/src/test/java/com/dbx/agent/sundb/SundbAgentMetadataTest.java
@@ -0,0 +1,53 @@
+package com.dbx.agent.sundb;
+
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.test.TestSupport;
+import com.dbx.agent.test.JdbcAgentFake;
+import com.dbx.agent.test.JdbcMetadataSqlFake;
+import java.util.Collections;
+import java.util.List;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class SundbAgentMetadataTest {
+    @Test
+    void quotesSchemaAndTableIdentifiersInIndexMetadataSql() {
+        SundbAgent agent = new SundbAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listIndexes("bad`schema", "bad`table");
+
+        Assertions.assertEquals(
+            Collections.singletonList("SHOW INDEX FROM `bad``table` FROM `bad``schema`"),
+            JdbcMetadataSqlFake.statements
+        );
+    }
+
+    @Test
+    void constrainedTableMetadataPushesFilterTypesAndPaging() {
+        SundbAgent agent = new SundbAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listTables("app", new MetadataListConstraints("ord", 25, 50, List.of("TABLE", "VIEW")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        Assertions.assertTrue(sql.contains("FROM information_schema.TABLES"), sql);
+        Assertions.assertTrue(sql.contains("TABLE_TYPE IN (?, ?)"), sql);
+        Assertions.assertTrue(sql.contains("UPPER(TABLE_NAME) LIKE ? ESCAPE '\\\\'"), sql);
+        Assertions.assertTrue(sql.endsWith("LIMIT 25 OFFSET 50"), sql);
+    }
+
+    @Test
+    void constrainedObjectMetadataPushesRoutineTypesAndPaging() {
+        SundbAgent agent = new SundbAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listObjects("app", new MetadataListConstraints("sync", 10, null, List.of("PROCEDURE", "FUNCTION")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        Assertions.assertTrue(sql.contains("FROM information_schema.ROUTINES"), sql);
+        Assertions.assertTrue(sql.contains("ROUTINE_TYPE IN (?, ?)"), sql);
+        Assertions.assertTrue(sql.contains("ORDER BY CASE OBJECT_TYPE"), sql);
+        Assertions.assertTrue(sql.endsWith("LIMIT 10"), sql);
+    }
+}
diff --git a/agents/drivers/sundb/src/test/java/com/dbx/agent/sundb/SundbAgentTest.java b/agents/drivers/sundb/src/test/java/com/dbx/agent/sundb/SundbAgentTest.java
new file mode 100644
index 0000000..1a56380
--- /dev/null
+++ b/agents/drivers/sundb/src/test/java/com/dbx/agent/sundb/SundbAgentTest.java
@@ -0,0 +1,16 @@
+package com.dbx.agent.sundb;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+
+class SundbAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new SundbAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL sample_proc()";
+    }
+}
diff --git a/agents/drivers/tdengine/build.gradle b/agents/drivers/tdengine/build.gradle
new file mode 100644
index 0000000..3d53791
--- /dev/null
+++ b/agents/drivers/tdengine/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.taosdata.jdbc:taos-jdbcdriver:3.6.3'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'TDengine', 'Main-Class': 'com.dbx.agent.tdengine.TDengineAgent')
+    }
+}
diff --git a/agents/drivers/tdengine/src/main/java/com/dbx/agent/tdengine/TDengineAgent.java b/agents/drivers/tdengine/src/main/java/com/dbx/agent/tdengine/TDengineAgent.java
new file mode 100644
index 0000000..f9cb2e2
--- /dev/null
+++ b/agents/drivers/tdengine/src/main/java/com/dbx/agent/tdengine/TDengineAgent.java
@@ -0,0 +1,743 @@
+package com.dbx.agent.tdengine;
+
+import com.dbx.agent.BaseDatabaseAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcExecutor;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.MetadataSqlSupport;
+import com.dbx.agent.ObjectInfo;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.QueryPageOptions;
+import com.dbx.agent.QueryPageResult;
+import com.dbx.agent.QueryResult;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.nio.charset.StandardCharsets;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public final class TDengineAgent extends BaseDatabaseAgent {
+    private static final DateTimeFormatter TDENGINE_TIMESTAMP_FORMAT =
+        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
+    private static final Pattern NUMERIC_PRECISION_PATTERN =
+        Pattern.compile("(?i)^(decimal|numeric)\\((\\d+)(?:,\\s*\\d+)?\\)");
+    private static final Pattern NUMERIC_SCALE_PATTERN =
+        Pattern.compile("(?i)^(decimal|numeric)\\(\\d+,\\s*(\\d+)\\)");
+    private static final Pattern CHARACTER_LENGTH_PATTERN =
+        Pattern.compile("(?i)^(binary|nchar|varchar|varbinary)\\((\\d+)\\)");
+    private static final Pattern COMPOSITE_KEY_PATTERN =
+        Pattern.compile("(?i)\\bCOMPOSITE\\s+KEY\\b");
+
+    private Connection connection;
+
+    @Override
+    public Connection getConnection() {
+        return connection;
+    }
+
+    @Override
+    public void connect(ConnectParams params) {
+        uncheckedVoid(() -> {
+            connection = TDengineConnectionFactory.open(params);
+        });
+    }
+
+    @Override
+    public boolean testConnection(ConnectParams params) {
+        return unchecked(() -> {
+            try (Connection conn = TDengineConnectionFactory.open(params)) {
+                return conn.isValid(5);
+            }
+        });
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW DATABASES")) {
+                while (rs.next()) {
+                    String name = rs.getString(1);
+                    if (!isSystemDatabase(name)) {
+                        result.add(new DatabaseInfo(name));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return listTables(schema, MetadataListConstraints.NONE);
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (!normalized.tableTypeAllowed("TABLE")) {
+            return Collections.emptyList();
+        }
+        try {
+            return queryConstrainedTables(schema, normalized);
+        } catch (RuntimeException ignored) {
+            // TDengine 2.x does not expose information_schema.ins_stables/ins_tables.
+            return normalized.filterTables(listTablesLegacy(schema));
+        }
+    }
+
+    private List<TableInfo> listTablesLegacy(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            result.addAll(queryTables("SHOW " + quoteQualifiedPrefix(schema) + "STABLES", "STABLE"));
+            result.addAll(queryTables("SHOW " + quoteQualifiedPrefix(schema) + "TABLES", "TABLE"));
+
+            Map<String, TableInfo> distinct = new LinkedHashMap<>();
+            for (TableInfo table : result) {
+                distinct.putIfAbsent(table.getTable_type() + ":" + table.getName(), table);
+            }
+            List<TableInfo> sorted = new ArrayList<>(distinct.values());
+            sortTablesForHierarchy(sorted);
+            return sorted;
+        });
+    }
+
+    @Override
+    public List<ObjectInfo> listObjects(String schema) {
+        List<ObjectInfo> result = new ArrayList<>();
+        for (TableInfo table : listTables(schema)) {
+            result.add(new ObjectInfo(table.getName(), table.getTable_type(), schema, table.getComment()));
+        }
+        return result;
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        return unchecked(() -> {
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("DESCRIBE " + qualifiedName(schema, table))) {
+                return readDescribeColumns(rs);
+            }
+        });
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        String source = getCreateSql(schema, name, objectType);
+        if (source.isBlank()) {
+            source = getTableDdl(schema, name);
+        }
+        return new ObjectSource(name, objectType, schema, source);
+    }
+
+    @Override
+    public String getTableDdl(String schema, String table) {
+        String source = getCreateSql(schema, table, "STABLE");
+        if (source.isBlank()) {
+            source = getCreateSql(schema, table, "TABLE");
+        }
+        if (source.isBlank()) {
+            return super.getTableDdl(schema, table);
+        }
+        return source;
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public QueryResult executeQuery(String sql, String schema, ExecuteQueryOptions options) {
+        return JdbcExecutor.INSTANCE.execute(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options.getMaxRows(),
+            options.getFetchSize(),
+            options.getTimeoutSecs(),
+            this::tdengineResultValue
+        );
+    }
+
+    @Override
+    public QueryPageResult executeQueryPage(String sql, String schema, QueryPageOptions options) {
+        return JdbcExecutor.INSTANCE.executePage(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            this::tdengineResultValue
+        );
+    }
+
+    @Override
+    public QueryPageResult startTableRead(String sql, String schema, QueryPageOptions options) {
+        return JdbcExecutor.INSTANCE.startTableRead(
+            requireConnected(),
+            sql,
+            schema,
+            this::setSchemaSQL,
+            options,
+            this::tdengineResultValue
+        );
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "USE " + quoteIdentifier(schema);
+    }
+
+    @Override
+    public void disconnect() {
+        uncheckedVoid(() -> {
+            if (connection != null) {
+                connection.close();
+            }
+            connection = null;
+        });
+    }
+
+    private List<TableInfo> queryTables(String sql, String tableType) throws Exception {
+        List<TableInfo> result = new ArrayList<>();
+        try (java.sql.Statement stmt = requireConnected().createStatement();
+             ResultSet rs = stmt.executeQuery(sql)) {
+            while (rs.next()) {
+                result.add(new TableInfo(rs.getString(1), tableType, null));
+            }
+        }
+        return result;
+    }
+
+    private List<TableInfo> queryConstrainedTables(String database, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            TableMetadataQuery query = buildTableMetadataQuery(database, constraints);
+            List<TableInfo> result = new ArrayList<>();
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(query.sql())) {
+                MetadataSqlSupport.bind(stmt, query.args());
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(
+                            rs.getString(1),
+                            rs.getString(2),
+                            optionalString(rs, 3),
+                            null,
+                            optionalString(rs, 4)
+                        ));
+                    }
+                }
+            }
+            MetadataListConstraints postFilter = constraints.hasLimit() ? constraints.withoutPaging() : constraints;
+            return postFilter.filterTables(result);
+        });
+    }
+
+    static TableMetadataQuery buildTableMetadataQuery(String database, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        List<Object> args = new ArrayList<>();
+        StringBuilder sql = new StringBuilder("""
+            SELECT table_name, table_type, table_comment, parent_name
+            FROM (
+                SELECT stable_name AS table_name,
+                       'STABLE' AS table_type,
+                       table_comment,
+                       CAST(NULL AS VARCHAR(192)) AS parent_name,
+                       stable_name AS hierarchy_name,
+                       0 AS hierarchy_rank
+                FROM information_schema.ins_stables
+                WHERE db_name = ?
+                UNION ALL
+                SELECT table_name,
+                       'TABLE' AS table_type,
+                       table_comment,
+                       stable_name AS parent_name,
+                       CASE WHEN stable_name IS NULL THEN table_name ELSE stable_name END AS hierarchy_name,
+                       1 AS hierarchy_rank
+                FROM information_schema.ins_tables
+                WHERE db_name = ?
+            ) metadata
+            WHERE 1 = 1
+            """.stripIndent().trim());
+        args.add(database);
+        args.add(database);
+        if (normalized.hasFilter()) {
+            String pattern = normalized.fuzzyLikePattern();
+            sql.append(" AND (table_name LIKE ? OR table_comment LIKE ?)");
+            args.add(pattern);
+            args.add(pattern);
+        }
+        sql.append(" ORDER BY hierarchy_name, hierarchy_rank, table_name");
+        MetadataSqlSupport.appendLiteralLimitOffset(sql, normalized);
+        return new TableMetadataQuery(sql.toString(), args);
+    }
+
+    static final class TableMetadataQuery {
+        private final String sql;
+        private final List<Object> args;
+
+        TableMetadataQuery(String sql, List<Object> args) {
+            this.sql = sql;
+            this.args = args;
+        }
+
+        String sql() {
+            return sql;
+        }
+
+        List<Object> args() {
+            return args;
+        }
+    }
+
+    static void sortTablesForHierarchy(List<TableInfo> tables) {
+        tables.sort((left, right) -> {
+            String leftGroup = hierarchyGroupName(left);
+            String rightGroup = hierarchyGroupName(right);
+            int groupCompared = leftGroup.compareTo(rightGroup);
+            if (groupCompared != 0) {
+                return groupCompared;
+            }
+
+            boolean leftIsParent = left.getParent_name() == null;
+            boolean rightIsParent = right.getParent_name() == null;
+            if (leftIsParent != rightIsParent) {
+                return leftIsParent ? -1 : 1;
+            }
+            return left.getName().toLowerCase(Locale.ROOT).compareTo(right.getName().toLowerCase(Locale.ROOT));
+        });
+    }
+
+    private static String hierarchyGroupName(TableInfo table) {
+        String parentName = table.getParent_name();
+        String groupName = parentName == null || parentName.trim().isEmpty() ? table.getName() : parentName;
+        return groupName.toLowerCase(Locale.ROOT);
+    }
+
+    static List<ColumnInfo> readDescribeColumns(ResultSet rs) throws Exception {
+        List<ColumnInfo> result = new ArrayList<>();
+        int ordinal = 0;
+        while (rs.next()) {
+            ordinal += 1;
+            String name = rs.getString(1);
+            String dataType = coalesce(rs.getString(2));
+            String note = optionalString(rs, 4);
+            boolean isTag = note != null && note.toUpperCase(Locale.ROOT).contains("TAG");
+            boolean isPrimaryKey = !isTag && (ordinal == 1 || (note != null && COMPOSITE_KEY_PATTERN.matcher(note).find()));
+            result.add(new ColumnInfo(
+                name,
+                dataType,
+                !isPrimaryKey,
+                null,
+                isPrimaryKey,
+                note,
+                isTag ? "TAG" : null,
+                parseNumericPrecision(dataType),
+                parseNumericScale(dataType),
+                parseCharacterMaximumLength(dataType)
+            ));
+        }
+        return result;
+    }
+
+    private String getCreateSql(String schema, String name, String objectType) {
+        String showType = switch (objectType.toUpperCase(Locale.ROOT)) {
+            case "STABLE", "SUPER TABLE", "SUPERTABLE" -> "STABLE";
+            case "TABLE", "BASE TABLE", "CHILD TABLE" -> "TABLE";
+            default -> null;
+        };
+        if (showType == null) {
+            return "";
+        }
+
+        try (java.sql.Statement stmt = requireConnected().createStatement();
+             ResultSet rs = stmt.executeQuery("SHOW CREATE " + showType + " " + qualifiedName(schema, name))) {
+            if (!rs.next()) {
+                return "";
+            }
+            int columnCount = rs.getMetaData().getColumnCount();
+            for (int i = 2; i <= columnCount; i++) {
+                String value = rs.getString(i);
+                if (value != null && value.toUpperCase(Locale.ROOT).contains("CREATE")) {
+                    return value;
+                }
+            }
+            String value = rs.getString(columnCount);
+            return value == null ? "" : value;
+        } catch (Exception e) {
+            return "";
+        }
+    }
+
+    private Object tdengineResultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value = switch (sqlType) {
+                case Types.BIGINT -> rs.getLong(index);
+                case Types.INTEGER, Types.SMALLINT, Types.TINYINT -> rs.getInt(index);
+                case Types.FLOAT, Types.REAL -> rs.getFloat(index);
+                case Types.DOUBLE -> rs.getDouble(index);
+                case Types.DECIMAL, Types.NUMERIC -> rs.getBigDecimal(index);
+                case Types.BOOLEAN, Types.BIT -> rs.getBoolean(index);
+                default -> rs.getObject(index);
+            };
+            return rs.wasNull() ? null : decodeTdengineValue(value);
+        });
+    }
+
+    public static Object decodeTdengineValue(Object value) {
+        if (value instanceof byte[] bytes) {
+            return new String(bytes, StandardCharsets.UTF_8);
+        }
+        if (value instanceof Timestamp timestamp) {
+            return TDENGINE_TIMESTAMP_FORMAT.format(timestamp.toLocalDateTime());
+        }
+        return value;
+    }
+
+    private static String quoteQualifiedPrefix(String schema) {
+        String trimmed = schema.trim();
+        return trimmed.isEmpty() ? "" : quoteIdentifier(trimmed) + ".";
+    }
+
+    private static String qualifiedName(String schema, String name) {
+        String table = quoteIdentifier(name);
+        String trimmed = schema.trim();
+        return trimmed.isEmpty() ? table : quoteIdentifier(trimmed) + "." + table;
+    }
+
+    private static String quoteIdentifier(String identifier) {
+        return "`" + identifier.replace("`", "``") + "`";
+    }
+
+    private static boolean isSystemDatabase(String name) {
+        if (name == null) {
+            return false;
+        }
+        String normalized = name.trim().toLowerCase(Locale.ROOT);
+        return "information_schema".equals(normalized) || "performance_schema".equals(normalized);
+    }
+
+    private static Integer parseNumericPrecision(String dataType) {
+        return parseIntGroup(NUMERIC_PRECISION_PATTERN, dataType, 2);
+    }
+
+    private static Integer parseNumericScale(String dataType) {
+        return parseIntGroup(NUMERIC_SCALE_PATTERN, dataType, 2);
+    }
+
+    private static Integer parseCharacterMaximumLength(String dataType) {
+        return parseIntGroup(CHARACTER_LENGTH_PATTERN, dataType, 2);
+    }
+
+    private static Integer parseIntGroup(Pattern pattern, String value, int group) {
+        Matcher matcher = pattern.matcher(value);
+        if (!matcher.find()) {
+            return null;
+        }
+        try {
+            return Integer.valueOf(matcher.group(group));
+        } catch (NumberFormatException e) {
+            return null;
+        }
+    }
+
+    private static String optionalString(ResultSet rs, int index) {
+        try {
+            return rs.getString(index);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    private static String coalesce(String value) {
+        return value == null ? "" : value;
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new TDengineAgent()).run();
+    }
+}
+
+final class TDengineJdbcUrl {
+    enum TransportPreference {
+        AUTO,
+        WEBSOCKET,
+        REST
+    }
+
+    private static final String PARAM_TRANSPORT = "transport";
+    private static final String PARAM_DBX_TRANSPORT = "dbx.transport";
+
+    private TDengineJdbcUrl() {
+    }
+
+    static String from(ConnectParams params) {
+        TransportPreference preference = transportPreference(params.getUrl_params());
+        if (preference == TransportPreference.REST) {
+            return from(params, TDengineTransport.REST);
+        }
+        String host = params.getHost().isBlank() ? "localhost" : params.getHost();
+        int port = params.getPort() > 0 ? params.getPort() : 6041;
+        String database = params.getDatabase().trim();
+        String path = database.isBlank() ? "/" : "/" + database;
+        String query = normalizeQueryString(params.getUrl_params());
+        String suffix = query.isBlank() ? "" : "?" + query;
+        return "jdbc:TAOS-WS://" + host + ":" + port + path + suffix;
+    }
+
+    static String from(ConnectParams params, TDengineTransport transport) {
+        String host = params.getHost().isBlank() ? "localhost" : params.getHost();
+        int port = params.getPort() > 0 ? params.getPort() : 6041;
+        String database = params.getDatabase().trim();
+        String path = database.isBlank() ? "/" : "/" + database;
+        String query = normalizeQueryString(params.getUrl_params());
+        String suffix = query.isBlank() ? "" : "?" + query;
+        return transport.urlPrefix() + host + ":" + port + path + suffix;
+    }
+
+    static String sanitizeConnectionString(String connectionString) {
+        if (connectionString == null || connectionString.isBlank()) {
+            return "";
+        }
+        int queryIndex = connectionString.indexOf('?');
+        if (queryIndex < 0) {
+            return connectionString;
+        }
+        String base = connectionString.substring(0, queryIndex);
+        String rawQuery = connectionString.substring(queryIndex + 1);
+        int fragmentIndex = rawQuery.indexOf('#');
+        String fragment = "";
+        if (fragmentIndex >= 0) {
+            fragment = rawQuery.substring(fragmentIndex);
+            rawQuery = rawQuery.substring(0, fragmentIndex);
+        }
+        String query = normalizeQueryString(rawQuery);
+        if (query.isBlank()) {
+            return base + fragment;
+        }
+        return base + "?" + query + fragment;
+    }
+
+    static TransportPreference transportPreference(String rawQuery) {
+        String query = rawQuery == null ? "" : rawQuery.trim();
+        if (query.startsWith("?")) {
+            query = query.substring(1);
+        }
+        if (query.isBlank()) {
+            return TransportPreference.AUTO;
+        }
+        String[] parts = query.split("&");
+        for (String part : parts) {
+            if (part == null || part.isBlank()) {
+                continue;
+            }
+            int index = part.indexOf('=');
+            String key = index < 0 ? part.trim() : part.substring(0, index).trim();
+            if (!PARAM_TRANSPORT.equalsIgnoreCase(key) && !PARAM_DBX_TRANSPORT.equalsIgnoreCase(key)) {
+                continue;
+            }
+            String value = index < 0 ? "" : part.substring(index + 1).trim();
+            if ("rest".equalsIgnoreCase(value) || "rs".equalsIgnoreCase(value)) {
+                return TransportPreference.REST;
+            }
+            if ("ws".equalsIgnoreCase(value) || "websocket".equalsIgnoreCase(value)) {
+                return TransportPreference.WEBSOCKET;
+            }
+        }
+        return TransportPreference.AUTO;
+    }
+
+    private static String normalizeQueryString(String rawQuery) {
+        String query = rawQuery == null ? "" : rawQuery.trim();
+        if (query.startsWith("?")) {
+            query = query.substring(1);
+        }
+        if (query.isBlank()) {
+            return "";
+        }
+        String[] parts = query.split("&");
+        List<String> kept = new ArrayList<>();
+        for (String part : parts) {
+            if (part == null || part.isBlank()) {
+                continue;
+            }
+            int index = part.indexOf('=');
+            String key = index < 0 ? part.trim() : part.substring(0, index).trim();
+            if (PARAM_TRANSPORT.equalsIgnoreCase(key) || PARAM_DBX_TRANSPORT.equalsIgnoreCase(key)) {
+                continue;
+            }
+            kept.add(part);
+        }
+        return String.join("&", kept);
+    }
+}
+
+enum TDengineTransport {
+    WEBSOCKET("jdbc:TAOS-WS://", "com.taosdata.jdbc.ws.WebSocketDriver"),
+    REST("jdbc:TAOS-RS://", "com.taosdata.jdbc.rs.RestfulDriver");
+
+    private final String urlPrefix;
+    private final String driverClass;
+
+    TDengineTransport(String urlPrefix, String driverClass) {
+        this.urlPrefix = urlPrefix;
+        this.driverClass = driverClass;
+    }
+
+    String urlPrefix() {
+        return urlPrefix;
+    }
+
+    String driverClass() {
+        return driverClass;
+    }
+}
+
+final class TDengineConnectionFactory {
+    private static final int AUTO_TRANSPORT_ATTEMPT_TIMEOUT_SECONDS = 8;
+
+    private TDengineConnectionFactory() {
+    }
+
+    static Connection open(ConnectParams params) throws Exception {
+        String explicitConnectionString = params.getConnection_string() == null ? "" : params.getConnection_string().trim();
+        if (!explicitConnectionString.isBlank()) {
+            String sanitizedConnectionString = TDengineJdbcUrl.sanitizeConnectionString(explicitConnectionString);
+            Class.forName(driverClassFromConnectionString(sanitizedConnectionString));
+            return DriverManager.getConnection(sanitizedConnectionString, params.getUsername(), params.getPassword());
+        }
+
+        TDengineJdbcUrl.TransportPreference preference = TDengineJdbcUrl.transportPreference(params.getUrl_params());
+        TDengineTransport[] candidates = transportsFor(preference);
+        Exception firstError = null;
+        for (TDengineTransport transport : candidates) {
+            try {
+                Connection connection = preference == TDengineJdbcUrl.TransportPreference.AUTO
+                    ? openWithAttemptTimeout(params, transport)
+                    : openDirect(params, transport);
+                return connection;
+            } catch (Exception e) {
+                if (firstError == null) {
+                    firstError = e;
+                } else {
+                    firstError.addSuppressed(e);
+                }
+            }
+        }
+        if (firstError != null) {
+            throw new RuntimeException("Failed to connect TDengine using transports: " + candidateNames(candidates), firstError);
+        }
+        throw new IllegalStateException("No TDengine transport available.");
+    }
+
+    private static Connection openDirect(ConnectParams params, TDengineTransport transport) throws Exception {
+        Class.forName(transport.driverClass());
+        String url = TDengineJdbcUrl.from(params, transport);
+        return DriverManager.getConnection(url, params.getUsername(), params.getPassword());
+    }
+
+    private static Connection openWithAttemptTimeout(ConnectParams params, TDengineTransport transport) throws Exception {
+        String threadName = "tdengine-connect-" + transport.name().toLowerCase(Locale.ROOT);
+        ThreadFactory factory = runnable -> {
+            Thread thread = new Thread(runnable, threadName);
+            thread.setDaemon(true);
+            return thread;
+        };
+        ExecutorService executor = Executors.newSingleThreadExecutor(factory);
+        try {
+            Future<Connection> future = executor.submit(new Callable<Connection>() {
+                @Override
+                public Connection call() throws Exception {
+                    return openDirect(params, transport);
+                }
+            });
+            return future.get(AUTO_TRANSPORT_ATTEMPT_TIMEOUT_SECONDS, TimeUnit.SECONDS);
+        } catch (TimeoutException e) {
+            throw new RuntimeException(
+                "TDengine " + transport.name().toLowerCase(Locale.ROOT)
+                    + " transport connect timed out after " + AUTO_TRANSPORT_ATTEMPT_TIMEOUT_SECONDS + "s",
+                e
+            );
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new RuntimeException("Interrupted while connecting TDengine via " + transport.name().toLowerCase(Locale.ROOT), e);
+        } catch (ExecutionException e) {
+            Throwable cause = e.getCause();
+            if (cause instanceof Exception exception) {
+                throw exception;
+            }
+            throw new RuntimeException(cause);
+        } finally {
+            executor.shutdownNow();
+        }
+    }
+
+    private static TDengineTransport[] transportsFor(TDengineJdbcUrl.TransportPreference preference) {
+        return switch (preference) {
+            case REST -> new TDengineTransport[] {TDengineTransport.REST};
+            case WEBSOCKET -> new TDengineTransport[] {TDengineTransport.WEBSOCKET};
+            case AUTO -> new TDengineTransport[] {TDengineTransport.WEBSOCKET, TDengineTransport.REST};
+        };
+    }
+
+    private static String candidateNames(TDengineTransport[] candidates) {
+        List<String> names = new ArrayList<>();
+        for (TDengineTransport candidate : candidates) {
+            names.add(candidate.name().toLowerCase(Locale.ROOT));
+        }
+        return String.join(" -> ", names);
+    }
+
+    private static String driverClassFromConnectionString(String connectionString) {
+        if (connectionString.regionMatches(true, 0, TDengineTransport.REST.urlPrefix(), 0, TDengineTransport.REST.urlPrefix().length())) {
+            return TDengineTransport.REST.driverClass();
+        }
+        if (connectionString.regionMatches(true, 0, TDengineTransport.WEBSOCKET.urlPrefix(), 0, TDengineTransport.WEBSOCKET.urlPrefix().length())) {
+            return TDengineTransport.WEBSOCKET.driverClass();
+        }
+        return TDengineTransport.WEBSOCKET.driverClass();
+    }
+}
diff --git a/agents/drivers/tdengine/src/test/java/com/dbx/agent/tdengine/TDengineAgentPagingTest.java b/agents/drivers/tdengine/src/test/java/com/dbx/agent/tdengine/TDengineAgentPagingTest.java
new file mode 100644
index 0000000..91ef0b9
--- /dev/null
+++ b/agents/drivers/tdengine/src/test/java/com/dbx/agent/tdengine/TDengineAgentPagingTest.java
@@ -0,0 +1,178 @@
+package com.dbx.agent.tdengine;
+
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.test.TestSupport;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.nio.charset.StandardCharsets;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Statement;
+import java.sql.Types;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class TDengineAgentPagingTest {
+    @Test
+    void executeQueryPageDecodesBinaryVarcharValuesAsStrings() {
+        TDengineAgent agent = new TDengineAgent();
+        TestSupport.setPrivateConnection(agent, binaryVarcharConnection());
+        JsonRpcServer server = new JsonRpcServer(agent);
+
+        String response = handleRequest(server, """
+            {
+              "jsonrpc": "2.0",
+              "id": 1,
+              "method": "execute_query_page",
+              "params": {
+                "sql": "SELECT v FROM sample",
+                "schema": "power",
+                "pageSize": 100
+              }
+            }
+            """);
+
+        assertFalse(response.contains("\"error\""), response);
+        assertTrue(response.contains("\"hello\""), response);
+        assertFalse(response.contains("[104,101,108,108,111]"), response);
+    }
+
+    private static Connection binaryVarcharConnection() {
+        Statement statement = binaryVarcharStatement();
+        return proxy(Connection.class, (method, args) -> {
+            String name = method.getName();
+            if ("createStatement".equals(name)) {
+                return statement;
+            }
+            if ("getAutoCommit".equals(name)) {
+                return true;
+            }
+            if ("setAutoCommit".equals(name) || "commit".equals(name) || "rollback".equals(name) || "close".equals(name)) {
+                return null;
+            }
+            if ("isClosed".equals(name)) {
+                return false;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static Statement binaryVarcharStatement() {
+        ResultSet resultSet = binaryVarcharResultSet();
+        return proxy(Statement.class, (method, args) -> {
+            String name = method.getName();
+            if ("execute".equals(name)) {
+                return true;
+            }
+            if ("getResultSet".equals(name)) {
+                return resultSet;
+            }
+            if ("getUpdateCount".equals(name)) {
+                return 0;
+            }
+            if ("setMaxRows".equals(name) || "setFetchSize".equals(name) || "close".equals(name)) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSet binaryVarcharResultSet() {
+        final int[] index = {-1};
+        ResultSetMetaData metadata = binaryVarcharMetadata();
+        byte[] value = "hello".getBytes(StandardCharsets.UTF_8);
+        return proxy(ResultSet.class, (method, args) -> {
+            String name = method.getName();
+            if ("next".equals(name)) {
+                index[0] += 1;
+                return index[0] == 0;
+            }
+            if ("getMetaData".equals(name)) {
+                return metadata;
+            }
+            if ("getObject".equals(name)) {
+                return value;
+            }
+            if ("wasNull".equals(name)) {
+                return false;
+            }
+            if ("close".equals(name)) {
+                return null;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSetMetaData binaryVarcharMetadata() {
+        return proxy(ResultSetMetaData.class, (method, args) -> {
+            String name = method.getName();
+            if ("getColumnCount".equals(name)) {
+                return 1;
+            }
+            if ("getColumnLabel".equals(name)) {
+                return "v";
+            }
+            if ("getColumnType".equals(name)) {
+                return Types.VARCHAR;
+            }
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static String handleRequest(JsonRpcServer server, String request) {
+        try {
+            Method method = JsonRpcServer.class.getDeclaredMethod("handleRequest", String.class);
+            method.setAccessible(true);
+            return (String) method.invoke(server, request);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static <T> T proxy(Class<T> type, MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) {
+                return handler.handle(method, args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Byte.TYPE.equals(type)) {
+            return (byte) 0;
+        }
+        if (Short.TYPE.equals(type)) {
+            return (short) 0;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        if (Long.TYPE.equals(type)) {
+            return 0L;
+        }
+        if (Float.TYPE.equals(type)) {
+            return 0f;
+        }
+        if (Double.TYPE.equals(type)) {
+            return 0.0d;
+        }
+        if (Character.TYPE.equals(type)) {
+            return '\0';
+        }
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args);
+    }
+}
diff --git a/agents/drivers/tdengine/src/test/java/com/dbx/agent/tdengine/TDengineAgentTest.java b/agents/drivers/tdengine/src/test/java/com/dbx/agent/tdengine/TDengineAgentTest.java
new file mode 100644
index 0000000..b606577
--- /dev/null
+++ b/agents/drivers/tdengine/src/test/java/com/dbx/agent/tdengine/TDengineAgentTest.java
@@ -0,0 +1,347 @@
+package com.dbx.agent.tdengine;
+
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.test.JdbcAgentFake;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import com.dbx.agent.test.JdbcMetadataSqlFake;
+import com.dbx.agent.test.TestSupport;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Proxy;
+import java.nio.charset.StandardCharsets;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class TDengineAgentExecutionTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new TDengineAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "SHOW DATABASES";
+    }
+}
+
+class TDengineAgentMetadataTest {
+    @Test
+    void buildsWebsocketJdbcUrlWithDefaultPortAndDatabase() {
+        String url = TDengineJdbcUrl.from(
+            new ConnectParams("127.0.0.1", 0, "meters", "root", "taosdata", "", "", false)
+        );
+
+        Assertions.assertEquals("jdbc:TAOS-WS://127.0.0.1:6041/meters", url);
+    }
+
+    @Test
+    void preservesCustomWebsocketPortAndUrlParams() {
+        String url = TDengineJdbcUrl.from(
+            new ConnectParams("td.local", 6042, "", "", "", "timezone=UTC&charset=UTF-8", "", false)
+        );
+
+        Assertions.assertEquals("jdbc:TAOS-WS://td.local:6042/?timezone=UTC&charset=UTF-8", url);
+    }
+
+    @Test
+    void supportsRestTransportViaCompatibilityUrlParam() {
+        String url = TDengineJdbcUrl.from(
+            new ConnectParams("127.0.0.1", 0, "testdb", "", "", "dbx.transport=rest&charset=UTF-8", "", false)
+        );
+
+        Assertions.assertEquals("jdbc:TAOS-RS://127.0.0.1:6041/testdb?charset=UTF-8", url);
+    }
+
+    @Test
+    void stripsTransportControlParamFromJdbcQuery() {
+        String url = TDengineJdbcUrl.from(
+            new ConnectParams("127.0.0.1", 6041, "", "", "", "transport=ws&timezone=UTC", "", false)
+        );
+
+        Assertions.assertEquals("jdbc:TAOS-WS://127.0.0.1:6041/?timezone=UTC", url);
+    }
+
+    @Test
+    void usesTdengineMetadataStatements() {
+        TDengineAgent agent = new TDengineAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listDatabases();
+        agent.listTables("power");
+        agent.getColumns("power", "meters");
+
+        Assertions.assertEquals("SHOW DATABASES", JdbcMetadataSqlFake.statements.get(0));
+        Assertions.assertTrue(JdbcMetadataSqlFake.statements.get(1).contains("FROM information_schema.ins_stables"));
+        Assertions.assertTrue(JdbcMetadataSqlFake.statements.get(1).contains("FROM information_schema.ins_tables"));
+        Assertions.assertEquals("param:1=power", JdbcMetadataSqlFake.statements.get(2));
+        Assertions.assertEquals("param:2=power", JdbcMetadataSqlFake.statements.get(3));
+        Assertions.assertEquals("DESCRIBE `power`.`meters`", JdbcMetadataSqlFake.statements.get(4));
+    }
+
+    @Test
+    void constrainedMetadataUsesRequestedDatabaseAndPushesFilterAndPaging() {
+        TDengineAgent agent = new TDengineAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listTables(
+            "dbx_alpha",
+            new MetadataListConstraints("ord", 25, 50, List.of("TABLE"))
+        );
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        Assertions.assertFalse(sql.contains("DATABASE()"), sql);
+        Assertions.assertTrue(sql.contains("FROM information_schema.ins_stables"), sql);
+        Assertions.assertTrue(sql.contains("FROM information_schema.ins_tables"), sql);
+        Assertions.assertTrue(sql.contains("WHERE db_name = ?"), sql);
+        Assertions.assertTrue(sql.contains("table_name LIKE ? OR table_comment LIKE ?"), sql);
+        Assertions.assertTrue(sql.contains("ORDER BY hierarchy_name, hierarchy_rank, table_name"), sql);
+        Assertions.assertTrue(sql.endsWith("LIMIT 25 OFFSET 50"), sql);
+        Assertions.assertEquals(
+            List.of(
+                "param:1=dbx_alpha",
+                "param:2=dbx_alpha",
+                "param:3=%o%r%d%",
+                "param:4=%o%r%d%"
+            ),
+            JdbcMetadataSqlFake.statements.subList(1, 5)
+        );
+    }
+
+    @Test
+    void constrainedMetadataPagesDoNotRepeatOrSkipTables() {
+        List<TableInfo> metadata = List.of(
+            new TableInfo("meters", "STABLE", null),
+            new TableInfo("device_a", "TABLE", null, null, "meters"),
+            new TableInfo("device_b", "TABLE", null, null, "meters"),
+            new TableInfo("standalone", "TABLE", null),
+            new TableInfo("weather", "STABLE", null)
+        );
+        List<String> statements = new ArrayList<>();
+        TDengineAgent agent = new TDengineAgent();
+        TestSupport.setPrivateConnection(agent, pagedMetadataConnection(metadata, statements));
+
+        List<TableInfo> combined = new ArrayList<>();
+        combined.addAll(agent.listTables("dbx_alpha", new MetadataListConstraints(null, 2, null, List.of("TABLE"))));
+        combined.addAll(agent.listTables("dbx_alpha", new MetadataListConstraints(null, 2, 2, List.of("TABLE"))));
+        combined.addAll(agent.listTables("dbx_alpha", new MetadataListConstraints(null, 2, 4, List.of("TABLE"))));
+
+        Assertions.assertEquals(metadata.stream().map(TableInfo::getName).toList(), combined.stream().map(TableInfo::getName).toList());
+        Set<String> distinctNames = new HashSet<>(combined.stream().map(TableInfo::getName).toList());
+        Assertions.assertEquals(metadata.size(), distinctNames.size());
+        Assertions.assertTrue(statements.get(0).endsWith("LIMIT 2"), statements.get(0));
+        Assertions.assertTrue(statements.get(1).endsWith("LIMIT 2 OFFSET 2"), statements.get(1));
+        Assertions.assertTrue(statements.get(2).endsWith("LIMIT 2 OFFSET 4"), statements.get(2));
+    }
+
+    @Test
+    void sortsSupertablesBeforeTheirChildTables() {
+        List<TableInfo> tables = new ArrayList<>(Arrays.asList(
+            new TableInfo("device_b", "TABLE", null, null, "meters"),
+            new TableInfo("standalone", "TABLE", null),
+            new TableInfo("meters", "STABLE", null),
+            new TableInfo("device_a", "TABLE", null, null, "meters")
+        ));
+
+        TDengineAgent.sortTablesForHierarchy(tables);
+
+        Assertions.assertEquals(
+            Arrays.asList("meters", "device_a", "device_b", "standalone"),
+            tables.stream().map(TableInfo::getName).toList()
+        );
+        Assertions.assertEquals("meters", tables.get(1).getParent_name());
+    }
+
+    @Test
+    void marksTimestampAndCompositeKeyDescribeColumnsAsPrimaryKeys() throws Exception {
+        ResultSet resultSet = describeResultSet(new String[][] {
+            {"ts", "TIMESTAMP", "8", ""},
+            {"seq", "INT", "4", "COMPOSITE KEY"},
+            {"voltage", "FLOAT", "4", ""},
+            {"site", "VARCHAR(32)", "32", "TAG"}
+        });
+
+        List<ColumnInfo> columns = TDengineAgent.readDescribeColumns(resultSet);
+
+        Assertions.assertTrue(columns.get(0).getIs_primary_key());
+        Assertions.assertFalse(columns.get(0).getIs_nullable());
+        Assertions.assertTrue(columns.get(1).getIs_primary_key());
+        Assertions.assertFalse(columns.get(1).getIs_nullable());
+        Assertions.assertFalse(columns.get(2).getIs_primary_key());
+        Assertions.assertFalse(columns.get(3).getIs_primary_key());
+        Assertions.assertEquals("TAG", columns.get(3).getExtra());
+    }
+
+    @Test
+    void doesNotExposeDatabasesAsSchemas() {
+        TDengineAgent agent = new TDengineAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        Assertions.assertTrue(agent.listSchemas().isEmpty());
+        Assertions.assertTrue(JdbcMetadataSqlFake.statements.isEmpty());
+    }
+
+    private static Connection pagedMetadataConnection(List<TableInfo> metadata, List<String> statements) {
+        return proxy(Connection.class, (proxy, method, args) -> {
+            String name = method.getName();
+            if ("prepareStatement".equals(name)) {
+                String sql = (String) args[0];
+                statements.add(sql);
+                return pagedMetadataStatement(sql, metadata);
+            }
+            if ("isClosed".equals(name)) return false;
+            if ("close".equals(name)) return null;
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static PreparedStatement pagedMetadataStatement(String sql, List<TableInfo> metadata) {
+        return proxy(PreparedStatement.class, (proxy, method, args) -> {
+            String name = method.getName();
+            if ("executeQuery".equals(name)) {
+                int limit = sqlClauseValue(sql, "LIMIT", metadata.size());
+                int offset = sqlClauseValue(sql, "OFFSET", 0);
+                int from = Math.min(offset, metadata.size());
+                int to = Math.min(from + limit, metadata.size());
+                return tableInfoResultSet(metadata.subList(from, to));
+            }
+            if ("setString".equals(name) || "setInt".equals(name) || "setObject".equals(name) || "close".equals(name)) return null;
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static ResultSet tableInfoResultSet(List<TableInfo> tables) {
+        int[] index = {-1};
+        return proxy(ResultSet.class, (proxy, method, args) -> {
+            String name = method.getName();
+            if ("next".equals(name)) {
+                index[0] += 1;
+                return index[0] < tables.size();
+            }
+            if ("getString".equals(name)) {
+                TableInfo table = tables.get(index[0]);
+                int column = (Integer) args[0];
+                if (column == 1) return table.getName();
+                if (column == 2) return table.getTable_type();
+                if (column == 3) return table.getComment();
+                if (column == 4) return table.getParent_name();
+            }
+            if ("close".equals(name)) return null;
+            return defaultValue(method.getReturnType());
+        });
+    }
+
+    private static int sqlClauseValue(String sql, String clause, int fallback) {
+        Matcher matcher = Pattern.compile("\\b" + clause + "\\s+(\\d+)").matcher(sql);
+        return matcher.find() ? Integer.parseInt(matcher.group(1)) : fallback;
+    }
+
+    private static <T> T proxy(Class<T> type, InvocationHandler handler) {
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, handler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) return false;
+        if (Integer.TYPE.equals(type)) return 0;
+        if (Long.TYPE.equals(type)) return 0L;
+        if (Double.TYPE.equals(type)) return 0.0d;
+        if (Float.TYPE.equals(type)) return 0.0f;
+        if (Short.TYPE.equals(type)) return (short) 0;
+        if (Byte.TYPE.equals(type)) return (byte) 0;
+        if (Character.TYPE.equals(type)) return '\0';
+        return null;
+    }
+
+    @Test
+    void setsDatabaseBeforeExecutionWhenSchemaIsProvided() {
+        TDengineAgent agent = new TDengineAgent();
+        TestSupport.setPrivateConnection(agent, JdbcAgentFake.connection());
+
+        agent.executeQuery("SELECT 1", "power", new ExecuteQueryOptions());
+
+        // JdbcSchemaSwitcher executes the USE statement (recorded as "execute")
+        // before the query runs, so the database is switched prior to execution.
+        Assertions.assertEquals(
+            Arrays.asList("execute", "setMaxRows:10001", "execute"),
+            JdbcAgentFake.calls
+        );
+    }
+
+    @Test
+    void decodesTdengineByteArrayTextValues() {
+        Assertions.assertEquals(
+            "d1001",
+            TDengineAgent.decodeTdengineValue("d1001".getBytes(StandardCharsets.UTF_8))
+        );
+    }
+
+    @Test
+    void formatsTdengineTimestampsAsSqlLiterals() {
+        Assertions.assertEquals(
+            "2026-05-16 09:35:58.123",
+            TDengineAgent.decodeTdengineValue(Timestamp.valueOf("2026-05-16 09:35:58.123"))
+        );
+    }
+
+    @Test
+    void unknownTransportValueDefaultsToWebsocketAndKeepsOtherParams() {
+        String url = TDengineJdbcUrl.from(
+            new ConnectParams("127.0.0.1", 6041, "", "", "", "transport=foo&timezone=UTC", "", false)
+        );
+
+        Assertions.assertEquals("jdbc:TAOS-WS://127.0.0.1:6041/?timezone=UTC", url);
+    }
+
+    @Test
+    void sanitizeConnectionStringStripsTransportControlParams() {
+        String sanitized = TDengineJdbcUrl.sanitizeConnectionString(
+            "jdbc:TAOS-WS://127.0.0.1:6041/db?dbx.transport=rest&charset=UTF-8&transport=ws"
+        );
+
+        Assertions.assertEquals("jdbc:TAOS-WS://127.0.0.1:6041/db?charset=UTF-8", sanitized);
+    }
+
+    @Test
+    void sanitizeConnectionStringKeepsFragmentAndNonControlParams() {
+        String sanitized = TDengineJdbcUrl.sanitizeConnectionString(
+            "jdbc:TAOS-RS://127.0.0.1:6041/db?timezone=UTC&dbx.transport=rest#anchor"
+        );
+
+        Assertions.assertEquals("jdbc:TAOS-RS://127.0.0.1:6041/db?timezone=UTC#anchor", sanitized);
+    }
+
+    private static ResultSet describeResultSet(String[][] rows) {
+        int[] rowIndex = {-1};
+        return (ResultSet) Proxy.newProxyInstance(
+            ResultSet.class.getClassLoader(),
+            new Class<?>[] {ResultSet.class},
+            (proxy, method, args) -> {
+                if ("next".equals(method.getName())) {
+                    rowIndex[0] += 1;
+                    return rowIndex[0] < rows.length;
+                }
+                if ("getString".equals(method.getName())) {
+                    return rows[rowIndex[0]][((Integer) args[0]) - 1];
+                }
+                if ("close".equals(method.getName())) {
+                    return null;
+                }
+                throw new UnsupportedOperationException(method.getName());
+            }
+        );
+    }
+}
diff --git a/agents/drivers/teradata/build.gradle b/agents/drivers/teradata/build.gradle
new file mode 100644
index 0000000..73c6bad
--- /dev/null
+++ b/agents/drivers/teradata/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.teradata.jdbc:terajdbc:20.00.00.56'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Teradata', 'Main-Class': 'com.dbx.agent.teradata.TeradataAgent')
+    }
+}
diff --git a/agents/drivers/teradata/src/main/java/com/dbx/agent/teradata/TeradataAgent.java b/agents/drivers/teradata/src/main/java/com/dbx/agent/teradata/TeradataAgent.java
new file mode 100644
index 0000000..f24aafc
--- /dev/null
+++ b/agents/drivers/teradata/src/main/java/com/dbx/agent/teradata/TeradataAgent.java
@@ -0,0 +1,21 @@
+package com.dbx.agent.teradata;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+
+public final class TeradataAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile TERADATA_PROFILE = new JdbcAgentProfile(
+        "com.teradata.jdbc.TeraDriver",
+        "jdbc:teradata://{host}/DBS_PORT={port},DATABASE={database}",
+        1025
+    );
+
+    public TeradataAgent() {
+        super(TERADATA_PROFILE);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new TeradataAgent()).run();
+    }
+}
diff --git a/agents/drivers/trino/build.gradle b/agents/drivers/trino/build.gradle
new file mode 100644
index 0000000..28b6cd8
--- /dev/null
+++ b/agents/drivers/trino/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'io.trino:trino-jdbc:471'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Trino (Presto)', 'Main-Class': 'com.dbx.agent.trino.TrinoAgent')
+    }
+}
diff --git a/agents/drivers/trino/src/main/java/com/dbx/agent/trino/TrinoAgent.java b/agents/drivers/trino/src/main/java/com/dbx/agent/trino/TrinoAgent.java
new file mode 100644
index 0000000..e0e348a
--- /dev/null
+++ b/agents/drivers/trino/src/main/java/com/dbx/agent/trino/TrinoAgent.java
@@ -0,0 +1,345 @@
+package com.dbx.agent.trino;
+
+import com.dbx.agent.AbstractJdbcAgent;
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.ConnectParams;
+import com.dbx.agent.DatabaseInfo;
+import com.dbx.agent.ForeignKeyInfo;
+import com.dbx.agent.IndexInfo;
+import com.dbx.agent.JdbcIdentifiers;
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.MetadataSqlSupport;
+import com.dbx.agent.TableInfo;
+import com.dbx.agent.TriggerInfo;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public final class TrinoAgent extends AbstractJdbcAgent {
+    private static final Pattern NUMERIC_PRECISION_PATTERN = Pattern.compile("(?i)^(decimal|numeric)\\((\\d+)(?:,\\s*\\d+)?\\)");
+    private static final Pattern NUMERIC_SCALE_PATTERN = Pattern.compile("(?i)^(decimal|numeric)\\(\\d+,\\s*(\\d+)\\)");
+    private static final Pattern CHARACTER_LENGTH_PATTERN = Pattern.compile("(?i)^(char|varchar)\\((\\d+)\\)");
+
+    @Override
+    protected String driverClass() {
+        return "io.trino.jdbc.TrinoDriver";
+    }
+
+    @Override
+    protected String buildJdbcUrl(ConnectParams params) {
+        return buildUrl(params);
+    }
+
+    @Override
+    public List<DatabaseInfo> listDatabases() {
+        return unchecked(() -> {
+            List<DatabaseInfo> result = new ArrayList<>();
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW CATALOGS")) {
+                while (rs.next()) {
+                    result.add(new DatabaseInfo(rs.getString(1)));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<String> listSchemas() {
+        return unchecked(() -> {
+            List<String> result = new ArrayList<>();
+            try (java.sql.Statement stmt = requireConnected().createStatement();
+                 ResultSet rs = stmt.executeQuery("SHOW SCHEMAS")) {
+                while (rs.next()) {
+                    result.add(rs.getString(1));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            String sql = "SELECT table_name, table_type " +
+                "FROM information_schema.tables " +
+                "WHERE table_schema = ? " +
+                "ORDER BY table_name";
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql)) {
+                stmt.setString(1, schema);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(
+                            rs.getString("table_name"),
+                            normalizeTableType(rs.getString("table_type")),
+                            null
+                        ));
+                    }
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    public List<TableInfo> listTables(String schema, MetadataListConstraints constraints) {
+        MetadataListConstraints normalized = MetadataListConstraints.orNone(constraints);
+        if (isUnconstrained(normalized)) {
+            return listTables(schema);
+        }
+        if (!normalized.includesTableLikeTypes()) {
+            return List.of();
+        }
+        try {
+            return queryConstrainedTables(schema, normalized);
+        } catch (RuntimeException e) {
+            return normalized.filterTables(listTables(schema));
+        }
+    }
+
+    private List<TableInfo> queryConstrainedTables(String schema, MetadataListConstraints constraints) {
+        return unchecked(() -> {
+            List<TableInfo> result = new ArrayList<>();
+            List<Object> args = new ArrayList<>();
+            StringBuilder sql = new StringBuilder("SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = ?");
+            args.add(schema);
+            appendTrinoTableTypePredicate(sql, args, constraints);
+            MetadataSqlSupport.appendNameFilter(sql, args, "table_name", constraints);
+            sql.append(" ORDER BY table_name");
+            MetadataSqlSupport.appendLiteralLimitOffset(sql, constraints);
+            try (java.sql.PreparedStatement stmt = requireConnected().prepareStatement(sql.toString())) {
+                MetadataSqlSupport.bind(stmt, args);
+                try (ResultSet rs = stmt.executeQuery()) {
+                    while (rs.next()) {
+                        result.add(new TableInfo(
+                            rs.getString("table_name"),
+                            normalizeTableType(rs.getString("table_type")),
+                            null
+                        ));
+                    }
+                }
+            }
+            return constraints.withoutPaging().filterTables(result);
+        });
+    }
+
+    @Override
+    public List<ColumnInfo> getColumns(String schema, String table) {
+        Connection conn = requireConnected();
+        List<ColumnInfo> metadataColumns;
+        try {
+            metadataColumns = getColumnsFromMetadata(conn, schema, table);
+        } catch (RuntimeException e) {
+            metadataColumns = Collections.emptyList();
+        }
+        return metadataColumns.isEmpty() ? getColumnsFromDescribe(conn, schema, table) : metadataColumns;
+    }
+
+    @Override
+    public List<IndexInfo> listIndexes(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<ForeignKeyInfo> listForeignKeys(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public List<TriggerInfo> listTriggers(String schema, String table) {
+        return Collections.emptyList();
+    }
+
+    @Override
+    public String setSchemaSQL(String schema) {
+        return "USE " + JdbcIdentifiers.INSTANCE.doubleQuote(schema);
+    }
+
+    private List<ColumnInfo> getColumnsFromMetadata(Connection conn, String schema, String table) {
+        return unchecked(() -> {
+            List<ColumnInfo> result = new ArrayList<>();
+            String catalog = blankToNull(conn.getCatalog());
+            try (ResultSet rs = conn.getMetaData().getColumns(catalog, schema, table, null)) {
+                while (rs.next()) {
+                    int sqlType = rs.getInt("DATA_TYPE");
+                    Integer size = intOrNull(rs, "COLUMN_SIZE");
+                    Integer scale = intOrNull(rs, "DECIMAL_DIGITS");
+                    result.add(new ColumnInfo(
+                        rs.getString("COLUMN_NAME"),
+                        coalesce(rs.getString("TYPE_NAME")),
+                        rs.getInt("NULLABLE") != DatabaseMetaData.columnNoNulls,
+                        rs.getString("COLUMN_DEF"),
+                        false,
+                        null,
+                        rs.getString("REMARKS"),
+                        isNumericType(sqlType) ? size : null,
+                        isNumericType(sqlType) ? scale : null,
+                        isCharacterType(sqlType) ? size : null
+                    ));
+                }
+            }
+            return result;
+        });
+    }
+
+    private List<ColumnInfo> getColumnsFromDescribe(Connection conn, String schema, String table) {
+        return unchecked(() -> {
+            List<ColumnInfo> result = new ArrayList<>();
+            String sql = "DESCRIBE " + quoteIdentifier(schema) + "." + quoteIdentifier(table);
+            try (java.sql.Statement stmt = conn.createStatement();
+                 ResultSet rs = stmt.executeQuery(sql)) {
+                while (rs.next()) {
+                    String dataType = rs.getString(2);
+                    String extra = rs.getString(3);
+                    result.add(new ColumnInfo(
+                        rs.getString(1),
+                        dataType,
+                        !coalesce(extra).toLowerCase(java.util.Locale.ROOT).contains("not null"),
+                        null,
+                        false,
+                        extra,
+                        rs.getString(4),
+                        parseNumericPrecision(dataType),
+                        parseNumericScale(dataType),
+                        parseCharacterMaximumLength(dataType)
+                    ));
+                }
+            }
+            return result;
+        });
+    }
+
+    @Override
+    protected Object resultValue(ResultSet rs, int index, int sqlType) {
+        return unchecked(() -> {
+            Object value = rs.getObject(index);
+            return rs.wasNull() ? null : value == null ? null : value.toString();
+        });
+    }
+
+    private static String buildUrl(ConnectParams params) {
+        if (params.getConnection_string() != null && !params.getConnection_string().isBlank()) {
+            return params.getConnection_string();
+        }
+        return "jdbc:trino://" + params.getHost() + ":" + params.getPort() + "/" + params.getDatabase();
+    }
+
+    private static boolean isUnconstrained(MetadataListConstraints constraints) {
+        return !constraints.hasFilter() && !constraints.hasLimit() && !constraints.hasOffset() && !constraints.hasObjectTypes();
+    }
+
+    private static void appendTrinoTableTypePredicate(StringBuilder sql, List<Object> args, MetadataListConstraints constraints) {
+        if (!constraints.hasObjectTypes()) {
+            return;
+        }
+        List<String> types = new ArrayList<>();
+        if (constraints.tableTypeAllowed("TABLE")) {
+            types.add("BASE TABLE");
+        }
+        if (constraints.tableTypeAllowed("VIEW")) {
+            types.add("VIEW");
+        }
+        if (constraints.tableTypeAllowed("MATERIALIZED_VIEW")) {
+            types.add("MATERIALIZED VIEW");
+        }
+        if (types.isEmpty()) {
+            sql.append(" AND 1 = 0");
+            return;
+        }
+        sql.append(" AND table_type IN (").append(MetadataSqlSupport.placeholders(types.size())).append(")");
+        args.addAll(types);
+    }
+
+    private static String quoteIdentifier(String identifier) {
+        return "\"" + identifier.replace("\"", "\"\"") + "\"";
+    }
+
+    private static boolean isNumericType(int sqlType) {
+        switch (sqlType) {
+            case Types.BIGINT:
+            case Types.DECIMAL:
+            case Types.DOUBLE:
+            case Types.FLOAT:
+            case Types.INTEGER:
+            case Types.NUMERIC:
+            case Types.REAL:
+            case Types.SMALLINT:
+            case Types.TINYINT:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private static boolean isCharacterType(int sqlType) {
+        switch (sqlType) {
+            case Types.CHAR:
+            case Types.LONGNVARCHAR:
+            case Types.LONGVARCHAR:
+            case Types.NCHAR:
+            case Types.NVARCHAR:
+            case Types.VARCHAR:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    private static Integer parseNumericPrecision(String dataType) {
+        return firstIntGroup(NUMERIC_PRECISION_PATTERN, dataType, 2);
+    }
+
+    private static Integer parseNumericScale(String dataType) {
+        return firstIntGroup(NUMERIC_SCALE_PATTERN, dataType, 1);
+    }
+
+    private static Integer parseCharacterMaximumLength(String dataType) {
+        return firstIntGroup(CHARACTER_LENGTH_PATTERN, dataType, 2);
+    }
+
+    private static Integer firstIntGroup(Pattern pattern, String value, int group) {
+        if (value == null) {
+            return null;
+        }
+        Matcher matcher = pattern.matcher(value);
+        if (!matcher.find()) {
+            return null;
+        }
+        return Integer.valueOf(matcher.group(group));
+    }
+
+    private static Integer intOrNull(ResultSet rs, String column) throws Exception {
+        Object value = rs.getObject(column);
+        return value instanceof Number ? ((Number) value).intValue() : null;
+    }
+
+    private static String normalizeTableType(String type) {
+        if ("BASE TABLE".equals(type)) {
+            return "TABLE";
+        }
+        if ("MATERIALIZED VIEW".equals(type)) {
+            return "MATERIALIZED_VIEW";
+        }
+        return type;
+    }
+
+    private static String blankToNull(String value) {
+        return value == null || value.trim().isEmpty() ? null : value;
+    }
+
+    private static String coalesce(String value) {
+        return value == null ? "" : value;
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new TrinoAgent()).run();
+    }
+}
diff --git a/agents/drivers/trino/src/test/java/com/dbx/agent/trino/TrinoAgentTest.java b/agents/drivers/trino/src/test/java/com/dbx/agent/trino/TrinoAgentTest.java
new file mode 100644
index 0000000..9b8943d
--- /dev/null
+++ b/agents/drivers/trino/src/test/java/com/dbx/agent/trino/TrinoAgentTest.java
@@ -0,0 +1,37 @@
+package com.dbx.agent.trino;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.MetadataListConstraints;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import com.dbx.agent.test.JdbcMetadataSqlFake;
+import com.dbx.agent.test.TestSupport;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+class TrinoAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new TrinoAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL system.runtime.nodes()";
+    }
+
+    @Test
+    void constrainedTableMetadataPushesFilterTypesAndPaging() {
+        TrinoAgent agent = new TrinoAgent();
+        TestSupport.setPrivateConnection(agent, JdbcMetadataSqlFake.connection());
+
+        agent.listTables("public", new MetadataListConstraints("ord", 25, 50, List.of("TABLE", "VIEW")));
+
+        String sql = JdbcMetadataSqlFake.statements.get(0);
+        Assertions.assertTrue(sql.contains("FROM information_schema.tables"), sql);
+        Assertions.assertTrue(sql.contains("table_type IN (?, ?)"), sql);
+        Assertions.assertTrue(sql.contains("UPPER(table_name) LIKE ? ESCAPE '\\\\'"), sql);
+        Assertions.assertTrue(sql.endsWith("LIMIT 25 OFFSET 50"), sql);
+    }
+}
diff --git a/agents/drivers/vastbase/build.gradle b/agents/drivers/vastbase/build.gradle
new file mode 100644
index 0000000..11ece4a
--- /dev/null
+++ b/agents/drivers/vastbase/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'cn.com.vastdata:vastbase-jdbc:2.11v'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Vastbase', 'Main-Class': 'com.dbx.agent.vastbase.VastbaseAgent')
+    }
+}
diff --git a/agents/drivers/vastbase/libs/.gitkeep b/agents/drivers/vastbase/libs/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/agents/drivers/vastbase/src/main/java/com/dbx/agent/vastbase/VastbaseAgent.java b/agents/drivers/vastbase/src/main/java/com/dbx/agent/vastbase/VastbaseAgent.java
new file mode 100644
index 0000000..920db9b
--- /dev/null
+++ b/agents/drivers/vastbase/src/main/java/com/dbx/agent/vastbase/VastbaseAgent.java
@@ -0,0 +1,61 @@
+package com.dbx.agent.vastbase;
+
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.ObjectSource;
+import com.dbx.agent.PostgresLikeAgent;
+import com.dbx.agent.PostgresLikeAgentProfile;
+
+public final class VastbaseAgent extends PostgresLikeAgent {
+    public static final PostgresLikeAgentProfile VASTBASE_PROFILE = new PostgresLikeAgentProfile(
+        "cn.com.vastbase.Driver",
+        "jdbc:vastbase://{host}:{port}/{database}"
+    );
+
+    public VastbaseAgent() {
+        super(VASTBASE_PROFILE);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new VastbaseAgent()).run();
+    }
+
+    @Override
+    public ObjectSource getObjectSource(String schema, String name, String objectType) {
+        ObjectSource result = super.getObjectSource(schema, name, objectType);
+        String source = unwrapRecordText(result.getSource());
+        return new ObjectSource(result.getName(), result.getObject_type(), result.getSchema(), source);
+    }
+
+    /**
+     * Vastbase 的 pg_get_functiondef 在 SQL Server 兼容模式下返回的是
+     * PostgreSQL 行记录文本格式 {@code (1,"source text")} 而非纯文本。
+     * 此方法剥离行记录包装，提取实际的源码内容。
+     */
+    static String unwrapRecordText(String source) {
+        if (source == null || source.isEmpty()) {
+            return source;
+        }
+        String trimmed = source.trim();
+        if (!trimmed.startsWith("(") || !trimmed.endsWith(")")) {
+            return source;
+        }
+        // 格式: (field1,field2,...)，第一个字段通常是整数，第二个是源码文本
+        String inner = trimmed.substring(1, trimmed.length() - 1);
+        int commaIdx = inner.indexOf(',');
+        if (commaIdx <= 0) {
+            // 单字段行记录: (source_text)
+            return unquoteRecordField(inner);
+        }
+        // 多字段行记录: 跳过第一个字段，提取第二个字段及之后的内容
+        String rest = inner.substring(commaIdx + 1);
+        return unquoteRecordField(rest);
+    }
+
+    private static String unquoteRecordField(String value) {
+        String trimmed = value.trim();
+        if (trimmed.startsWith("\"") && trimmed.endsWith("\"")) {
+            return trimmed.substring(1, trimmed.length() - 1).replace("\"\"", "\"");
+        }
+        return trimmed;
+    }
+}
diff --git a/agents/drivers/vastbase/src/test/java/com/dbx/agent/vastbase/VastbaseAgentTest.java b/agents/drivers/vastbase/src/test/java/com/dbx/agent/vastbase/VastbaseAgentTest.java
new file mode 100644
index 0000000..ab8cb9a
--- /dev/null
+++ b/agents/drivers/vastbase/src/test/java/com/dbx/agent/vastbase/VastbaseAgentTest.java
@@ -0,0 +1,26 @@
+package com.dbx.agent.vastbase;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class VastbaseAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new VastbaseAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "CALL sample_proc()";
+    }
+
+    @Test
+    void declaresVastbasePostgresLikeProfile() {
+        VastbaseAgent agent = new VastbaseAgent();
+
+        Assertions.assertEquals("cn.com.vastbase.Driver", agent.getProfile().getDriverClass());
+        Assertions.assertEquals("jdbc:vastbase://{host}:{port}/{database}", agent.getProfile().getUrlTemplate());
+    }
+}
diff --git a/agents/drivers/vertica/build.gradle b/agents/drivers/vertica/build.gradle
new file mode 100644
index 0000000..fc1e0cf
--- /dev/null
+++ b/agents/drivers/vertica/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'com.vertica.jdbc:vertica-jdbc:25.3.0-0'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'Vertica', 'Main-Class': 'com.dbx.agent.vertica.VerticaAgent')
+    }
+}
diff --git a/agents/drivers/vertica/src/main/java/com/dbx/agent/vertica/VerticaAgent.java b/agents/drivers/vertica/src/main/java/com/dbx/agent/vertica/VerticaAgent.java
new file mode 100644
index 0000000..05cef7a
--- /dev/null
+++ b/agents/drivers/vertica/src/main/java/com/dbx/agent/vertica/VerticaAgent.java
@@ -0,0 +1,21 @@
+package com.dbx.agent.vertica;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+
+public final class VerticaAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile VERTICA_PROFILE = new JdbcAgentProfile(
+        "com.vertica.jdbc.Driver",
+        "jdbc:vertica://{host}:{port}/{database}",
+        5433
+    );
+
+    public VerticaAgent() {
+        super(VERTICA_PROFILE);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new VerticaAgent()).run();
+    }
+}
diff --git a/agents/drivers/xugu/README.md b/agents/drivers/xugu/README.md
new file mode 100644
index 0000000..09631c3
--- /dev/null
+++ b/agents/drivers/xugu/README.md
@@ -0,0 +1,36 @@
+# DBX Xugu Agent
+
+Native XuguDB agent for DBX using `gitee.com/XuguDB/go-xugu-driver`.
+
+## Build
+
+```bash
+go build -o agent .
+```
+
+Cross-compile release builds use pure Go output:
+
+```bash
+CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -trimpath -ldflags="-s -w" -o dbx-agent-xugu-linux-x64 .
+CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -trimpath -ldflags="-s -w" -o dbx-agent-xugu-macos-aarch64 .
+CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -trimpath -ldflags="-s -w" -o dbx-agent-xugu-windows-x64.exe .
+```
+
+## Local DBX Test
+
+Build the binary, then copy it into DBX's installed XuguDB driver directory:
+
+```bash
+mkdir -p ~/.dbx/agents/drivers/xugu
+cp agent ~/.dbx/agents/drivers/xugu/agent
+chmod +x ~/.dbx/agents/drivers/xugu/agent
+```
+
+DBX prefers `agent` over `agent.jar`, so XuguDB connections will use this Go
+agent until the file is removed.
+
+To restore the Java/JDBC agent:
+
+```bash
+rm ~/.dbx/agents/drivers/xugu/agent
+```
diff --git a/agents/drivers/xugu/go.mod b/agents/drivers/xugu/go.mod
new file mode 100644
index 0000000..acc7048
--- /dev/null
+++ b/agents/drivers/xugu/go.mod
@@ -0,0 +1,5 @@
+module github.com/t8y2/dbx/agents/drivers/xugu
+
+go 1.22
+
+require gitee.com/XuguDB/go-xugu-driver v1.0.12
diff --git a/agents/drivers/xugu/go.sum b/agents/drivers/xugu/go.sum
new file mode 100644
index 0000000..7b5f9a2
--- /dev/null
+++ b/agents/drivers/xugu/go.sum
@@ -0,0 +1,2 @@
+gitee.com/XuguDB/go-xugu-driver v1.0.12 h1:Le49iCI5YJBmQDJUUWx2SHHR3aYio0CTFjNx5O8m2Ew=
+gitee.com/XuguDB/go-xugu-driver v1.0.12/go.mod h1:VJlSyp+6BjYL1US00cVb4traVISlm8iGywYe3viLPbE=
diff --git a/agents/drivers/xugu/main.go b/agents/drivers/xugu/main.go
new file mode 100644
index 0000000..3ee35ef
--- /dev/null
+++ b/agents/drivers/xugu/main.go
@@ -0,0 +1,2052 @@
+package main
+
+import (
+	"bufio"
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	_ "gitee.com/XuguDB/go-xugu-driver"
+)
+
+const protocolVersion = 1
+const defaultMaxRows = 1000
+const defaultXuguPort = 5138
+const xuguListDatabasesSQL = `
+SELECT DB_NAME
+FROM ALL_DATABASES
+ORDER BY DB_NAME`
+const xuguListSchemasSQL = `
+SELECT SCHEMA_NAME
+FROM ALL_SCHEMAS
+ORDER BY SCHEMA_NAME`
+const xuguPrimaryKeyColumnsSQL = `
+SELECT c.DEFINE
+FROM ALL_CONSTRAINTS c
+JOIN ALL_TABLES t ON t.DB_ID = c.DB_ID AND t.TABLE_ID = c.TABLE_ID
+JOIN ALL_SCHEMAS s ON s.DB_ID = t.DB_ID AND s.SCHEMA_ID = t.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?)
+  AND UPPER(t.TABLE_NAME) = UPPER(?)
+  AND c.CONS_TYPE = 'P'`
+const xuguListColumnsSQL = `
+SELECT c.COL_NAME, c.TYPE_NAME, c.NOT_NULL, c.DEF_VAL, c.COMMENTS, c.SCALE, c."VARYING"
+FROM ALL_COLUMNS c
+JOIN ALL_TABLES t ON t.DB_ID = c.DB_ID AND t.TABLE_ID = c.TABLE_ID
+JOIN ALL_SCHEMAS s ON s.DB_ID = t.DB_ID AND s.SCHEMA_ID = t.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?)
+  AND UPPER(t.TABLE_NAME) = UPPER(?)
+  AND (c.IS_HIDE IS NULL OR c.IS_HIDE = FALSE)
+ORDER BY c.COL_NO`
+const xuguListIndexesSQL = `
+SELECT i.INDEX_NAME, i.KEYS, i.IS_UNIQUE, i.IS_PRIMARY, i.INDEX_TYPE, i.FILTER
+FROM ALL_INDEXES i
+JOIN ALL_TABLES t ON t.DB_ID = i.DB_ID AND t.TABLE_ID = i.TABLE_ID
+JOIN ALL_SCHEMAS s ON s.DB_ID = t.DB_ID AND s.SCHEMA_ID = t.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?)
+  AND UPPER(t.TABLE_NAME) = UPPER(?)
+ORDER BY i.INDEX_NAME`
+
+var xuguDataTypes = []string{
+	"BOOLEAN",
+	"INTEGER",
+	"SMALLINT",
+	"BIGINT",
+	"FLOAT",
+	"NUMERIC",
+	"CHAR",
+	"VARCHAR",
+	"CLOB",
+	"DATE",
+	"TIME",
+	"TIMESTAMP",
+	"BINARY",
+	"VARBINARY",
+	"BLOB",
+	"XML",
+	"BOOL",
+	"INT",
+	"SHORT",
+	"LONGINT",
+	"LONG",
+	"REAL",
+	"DECIMAL",
+	"TEXT",
+	"NCHAR",
+	"NVARCHAR",
+	"NVARCHAR2",
+}
+
+type request struct {
+	ID     json.RawMessage            `json:"id"`
+	Method string                     `json:"method"`
+	Params map[string]json.RawMessage `json:"params"`
+}
+
+type response struct {
+	JSONRPC string          `json:"jsonrpc,omitempty"`
+	ID      json.RawMessage `json:"id,omitempty"`
+	Result  any             `json:"result,omitempty"`
+	Error   *rpcError       `json:"error,omitempty"`
+}
+
+type rpcError struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+}
+
+type connectParams struct {
+	Host             string `json:"host"`
+	Port             int    `json:"port"`
+	Database         string `json:"database"`
+	Username         string `json:"username"`
+	Password         string `json:"password"`
+	SysDBA           bool   `json:"sysdba"`
+	URLParams        string `json:"url_params"`
+	ConnectionString string `json:"connection_string"`
+}
+
+type queryOptions struct {
+	SQL       string `json:"sql"`
+	Database  string `json:"database"`
+	Schema    string `json:"schema"`
+	MaxRows   int    `json:"maxRows"`
+	FetchSize int    `json:"fetchSize"`
+}
+
+type queryResult struct {
+	Columns         []string `json:"columns"`
+	ColumnTypes     []string `json:"column_types"`
+	Rows            [][]any  `json:"rows"`
+	AffectedRows    int64    `json:"affected_rows"`
+	ExecutionTimeMS int64    `json:"execution_time_ms"`
+	Truncated       bool     `json:"truncated"`
+}
+
+func (r queryResult) MarshalJSON() ([]byte, error) {
+	type alias queryResult
+	value := alias(r)
+	if value.Columns == nil {
+		value.Columns = []string{}
+	}
+	if value.ColumnTypes == nil {
+		value.ColumnTypes = []string{}
+	}
+	if value.Rows == nil {
+		value.Rows = [][]any{}
+	}
+	return json.Marshal(value)
+}
+
+type queryPageResult struct {
+	Columns         []string `json:"columns"`
+	ColumnTypes     []string `json:"column_types"`
+	Rows            [][]any  `json:"rows"`
+	AffectedRows    int64    `json:"affected_rows"`
+	ExecutionTimeMS int64    `json:"execution_time_ms"`
+	Truncated       bool     `json:"truncated"`
+	SessionID       *string  `json:"session_id"`
+	HasMore         bool     `json:"has_more"`
+}
+
+func (r queryPageResult) MarshalJSON() ([]byte, error) {
+	type alias queryPageResult
+	value := alias(r)
+	if value.Columns == nil {
+		value.Columns = []string{}
+	}
+	if value.ColumnTypes == nil {
+		value.ColumnTypes = []string{}
+	}
+	if value.Rows == nil {
+		value.Rows = [][]any{}
+	}
+	return json.Marshal(value)
+}
+
+type querySession struct {
+	rows        *sql.Rows
+	columns     []string
+	columnTypes []string
+	pending     []any
+	remaining   int
+}
+
+type databaseInfo struct {
+	Name string `json:"name"`
+}
+
+type tableInfo struct {
+	Name      string  `json:"name"`
+	TableType string  `json:"table_type"`
+	Comment   *string `json:"comment"`
+}
+
+type objectInfo struct {
+	Name       string  `json:"name"`
+	ObjectType string  `json:"object_type"`
+	Schema     string  `json:"schema"`
+	Comment    *string `json:"comment"`
+}
+
+type metadataListConstraints struct {
+	Filter      string
+	Limit       int
+	Offset      int
+	ObjectTypes []string
+}
+
+type xuguMetadataListQuery struct {
+	SQL  string
+	Args []any
+}
+
+type columnInfo struct {
+	Name                   string  `json:"name"`
+	DataType               string  `json:"data_type"`
+	IsNullable             bool    `json:"is_nullable"`
+	ColumnDefault          *string `json:"column_default"`
+	IsPrimaryKey           bool    `json:"is_primary_key"`
+	Extra                  *string `json:"extra"`
+	Comment                *string `json:"comment"`
+	NumericPrecision       *int    `json:"numeric_precision"`
+	NumericScale           *int    `json:"numeric_scale"`
+	CharacterMaximumLength *int    `json:"character_maximum_length"`
+}
+
+type indexInfo struct {
+	Name            string   `json:"name"`
+	Columns         []string `json:"columns"`
+	IsUnique        bool     `json:"is_unique"`
+	IsPrimary       bool     `json:"is_primary"`
+	Filter          *string  `json:"filter"`
+	IndexType       *string  `json:"index_type"`
+	IncludedColumns []string `json:"included_columns"`
+	Comment         *string  `json:"comment"`
+}
+
+func (i indexInfo) MarshalJSON() ([]byte, error) {
+	type alias indexInfo
+	value := alias(i)
+	if value.Columns == nil {
+		value.Columns = []string{}
+	}
+	if value.IncludedColumns == nil {
+		value.IncludedColumns = []string{}
+	}
+	return json.Marshal(value)
+}
+
+type foreignKeyInfo struct {
+	Name      string `json:"name"`
+	Column    string `json:"column"`
+	RefTable  string `json:"ref_table"`
+	RefColumn string `json:"ref_column"`
+}
+
+type triggerInfo struct {
+	Name   string `json:"name"`
+	Event  string `json:"event"`
+	Timing string `json:"timing"`
+}
+
+type server struct {
+	db            *sql.DB
+	params        connectParams
+	sessions      map[string]*querySession
+	nextSessionID int64
+}
+
+func main() {
+	s := newServer()
+	encoder := json.NewEncoder(os.Stdout)
+	fmt.Fprintln(os.Stdout, `{"ready":true}`)
+
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Buffer(make([]byte, 0, 64*1024), 512*1024*1024)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+		resp, shutdown := s.handleLine(line)
+		if err := encoder.Encode(resp); err != nil {
+			fmt.Fprintf(os.Stderr, "failed to write response: %v\n", err)
+			return
+		}
+		if shutdown {
+			return
+		}
+	}
+	if err := scanner.Err(); err != nil && !errors.Is(err, io.EOF) {
+		fmt.Fprintf(os.Stderr, "failed to read stdin: %v\n", err)
+	}
+}
+
+func newServer() *server {
+	return &server{sessions: map[string]*querySession{}}
+}
+
+func (s *server) handleLine(line string) (response, bool) {
+	var req request
+	if err := json.Unmarshal([]byte(line), &req); err != nil {
+		return errorResponse(nil, err), false
+	}
+	if len(req.ID) == 0 {
+		req.ID = json.RawMessage("1")
+	}
+	result, shutdown, err := s.dispatch(req.Method, req.Params)
+	if err != nil {
+		return errorResponse(req.ID, err), false
+	}
+	return response{JSONRPC: "2.0", ID: req.ID, Result: result}, shutdown
+}
+
+func (s *server) dispatch(method string, params map[string]json.RawMessage) (any, bool, error) {
+	switch method {
+	case "handshake":
+		return map[string]any{
+			"protocolVersion":      protocolVersion,
+			"agentProtocolVersion": protocolVersion,
+			"capabilities":         []string{"connect", "test_connection", "metadata", "query", "ddl"},
+		}, false, nil
+	case "connect":
+		var cp connectParams
+		if err := decodeParams(params, &cp); err != nil {
+			return nil, false, err
+		}
+		return map[string]bool{"ok": true}, false, s.connect(cp)
+	case "test_connection":
+		var cp connectParams
+		if err := decodeParams(params, &cp); err != nil {
+			return nil, false, err
+		}
+		db, err := openDB(cp)
+		if err != nil {
+			return nil, false, err
+		}
+		defer db.Close()
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		if err := db.PingContext(ctx); err != nil {
+			return nil, false, err
+		}
+		return map[string]bool{"ok": true}, false, nil
+	case "list_databases":
+		result, err := s.listDatabases()
+		return result, false, err
+	case "list_schemas":
+		if err := s.useDatabase(stringParam(params, "database")); err != nil {
+			return nil, false, err
+		}
+		result, err := s.listSchemas()
+		return result, false, err
+	case "list_tables":
+		if err := s.useDatabase(stringParam(params, "database")); err != nil {
+			return nil, false, err
+		}
+		schema := stringParam(params, "schema")
+		result, err := s.listTables(schema, metadataListConstraintsFromParams(params))
+		return result, false, err
+	case "list_objects":
+		if err := s.useDatabase(stringParam(params, "database")); err != nil {
+			return nil, false, err
+		}
+		schema := stringParam(params, "schema")
+		result, err := s.listObjects(schema, metadataListConstraintsFromParams(params))
+		return result, false, err
+	case "list_data_types":
+		return xuguDataTypes, false, nil
+	case "get_columns":
+		if err := s.useDatabase(stringParam(params, "database")); err != nil {
+			return nil, false, err
+		}
+		schema := stringParam(params, "schema")
+		table := stringParam(params, "table")
+		result, err := s.getColumns(schema, table)
+		return result, false, err
+	case "get_object_source":
+		if err := s.useDatabase(stringParam(params, "database")); err != nil {
+			return nil, false, err
+		}
+		schema := stringParam(params, "schema")
+		name := stringParam(params, "name")
+		objectType := stringParam(params, "object_type")
+		source, err := s.getObjectSource(schema, name, objectType)
+		return source, false, err
+	case "get_table_ddl":
+		if err := s.useDatabase(stringParam(params, "database")); err != nil {
+			return nil, false, err
+		}
+		schema := stringParam(params, "schema")
+		table := stringParam(params, "table")
+		ddl, err := s.getTableDDL(schema, table)
+		return ddl, false, err
+	case "execute_query":
+		var opts queryOptions
+		if err := decodeParams(params, &opts); err != nil {
+			return nil, false, err
+		}
+		result, err := s.executeQuery(opts)
+		return result, false, err
+	case "execute_query_page":
+		var opts queryOptions
+		if err := decodeParams(params, &opts); err != nil {
+			return nil, false, err
+		}
+		result, err := s.executeQueryPage(opts, intParam(params, "pageSize"))
+		return result, false, err
+	case "fetch_query_page":
+		result, err := s.fetchQueryPage(stringParam(params, "sessionId"), intParam(params, "pageSize"))
+		return result, false, err
+	case "close_query_session":
+		return s.closeQuerySession(stringParam(params, "sessionId")), false, nil
+	case "list_indexes":
+		if err := s.useDatabase(stringParam(params, "database")); err != nil {
+			return nil, false, err
+		}
+		schema := stringParam(params, "schema")
+		table := stringParam(params, "table")
+		result, err := s.listIndexes(schema, table)
+		return result, false, err
+	case "list_foreign_keys":
+		if err := s.useDatabase(stringParam(params, "database")); err != nil {
+			return nil, false, err
+		}
+		schema := stringParam(params, "schema")
+		table := stringParam(params, "table")
+		result, err := s.listForeignKeys(schema, table)
+		return result, false, err
+	case "list_triggers":
+		if err := s.useDatabase(stringParam(params, "database")); err != nil {
+			return nil, false, err
+		}
+		schema := stringParam(params, "schema")
+		table := stringParam(params, "table")
+		result, err := s.listTriggers(schema, table)
+		return result, false, err
+	case "get_explain_info":
+		sqlText := stringParam(params, "sql")
+		plan, err := s.getExplainInfo(sqlText)
+		return map[string]any{"plan": plan, "has_actual_stats": false}, false, err
+	case "execute_transaction":
+		result, err := s.executeTransaction(params)
+		return result, false, err
+	case "disconnect":
+		return map[string]bool{"ok": true}, false, s.disconnect()
+	case "shutdown":
+		_ = s.disconnect()
+		return map[string]bool{"ok": true}, true, nil
+	default:
+		return nil, false, fmt.Errorf("unknown method: %s", method)
+	}
+}
+
+func (s *server) connect(params connectParams) error {
+	_ = s.disconnect()
+	db, err := openDB(params)
+	if err != nil {
+		return err
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+	if err := db.PingContext(ctx); err != nil {
+		db.Close()
+		return err
+	}
+	s.db = db
+	s.params = params
+	return nil
+}
+
+func (s *server) disconnect() error {
+	s.closeAllQuerySessions()
+	if s.db == nil {
+		return nil
+	}
+	err := s.db.Close()
+	s.db = nil
+	return err
+}
+
+func openDB(params connectParams) (*sql.DB, error) {
+	dsn := buildDSN(params)
+	db, err := sql.Open("xugu", dsn)
+	if err != nil {
+		return nil, err
+	}
+	db.SetMaxOpenConns(4)
+	db.SetMaxIdleConns(1)
+	db.SetConnMaxLifetime(30 * time.Minute)
+	return db, nil
+}
+
+func buildDSN(params connectParams) string {
+	connectionString := strings.TrimSpace(params.ConnectionString)
+	if looksLikeXuguDSN(connectionString) {
+		return connectionString
+	}
+	if parsed := parseXuguURL(connectionString); parsed.Host != "" {
+		if parsed.Database == "" {
+			parsed.Database = params.Database
+		}
+		if parsed.Username == "" {
+			parsed.Username = params.Username
+		}
+		if parsed.Password == "" {
+			parsed.Password = params.Password
+		}
+		return buildXuguDSN(parsed.Host, parsed.Port, parsed.Database, parsed.Username, parsed.Password, params.URLParams)
+	}
+
+	if jdbc := parseXuguJDBCURL(connectionString); jdbc.Host != "" {
+		return buildXuguDSN(jdbc.Host, jdbc.Port, jdbc.Database, params.Username, params.Password, params.URLParams)
+	}
+
+	return buildXuguDSN(params.Host, params.Port, params.Database, params.Username, params.Password, params.URLParams)
+}
+
+func looksLikeXuguDSN(value string) bool {
+	upper := strings.ToUpper(value)
+	return strings.Contains(upper, "IP=") && strings.Contains(upper, "DB=") && strings.Contains(upper, "USER=")
+}
+
+type xuguURLInfo struct {
+	Host     string
+	Port     int
+	Database string
+	Username string
+	Password string
+}
+
+var xuguJDBCRegexp = regexp.MustCompile(`(?i)^jdbc:xugu://([^/:]+)(?::([0-9]+))?/([^?;]+)`)
+
+func parseXuguJDBCURL(value string) xuguURLInfo {
+	value = strings.TrimSpace(value)
+	match := xuguJDBCRegexp.FindStringSubmatch(value)
+	if len(match) != 4 {
+		return xuguURLInfo{}
+	}
+	return xuguURLInfo{Host: match[1], Port: parsePort(match[2]), Database: match[3]}
+}
+
+func parseXuguURL(value string) xuguURLInfo {
+	value = strings.TrimSpace(value)
+	if !strings.HasPrefix(strings.ToLower(value), "xugu://") {
+		return xuguURLInfo{}
+	}
+	withoutScheme := value[len("xugu://"):]
+	var userInfo string
+	hostPart := withoutScheme
+	if at := strings.LastIndex(hostPart, "@"); at >= 0 {
+		userInfo = hostPart[:at]
+		hostPart = hostPart[at+1:]
+	}
+	if slash := strings.IndexAny(hostPart, "/?"); slash >= 0 {
+		databasePart := strings.TrimLeft(hostPart[slash:], "/")
+		hostPart = hostPart[:slash]
+		if q := strings.Index(databasePart, "?"); q >= 0 {
+			databasePart = databasePart[:q]
+		}
+		info := parseHostPort(hostPart)
+		info.Database = databasePart
+		if userInfo != "" {
+			info.Username, info.Password = splitUserInfo(userInfo)
+		}
+		return info
+	}
+	info := parseHostPort(hostPart)
+	if userInfo != "" {
+		info.Username, info.Password = splitUserInfo(userInfo)
+	}
+	return info
+}
+
+func parseHostPort(value string) xuguURLInfo {
+	host := strings.TrimSpace(value)
+	port := 0
+	if idx := strings.LastIndex(host, ":"); idx > 0 {
+		port = parsePort(host[idx+1:])
+		host = host[:idx]
+	}
+	return xuguURLInfo{Host: host, Port: port}
+}
+
+func splitUserInfo(value string) (string, string) {
+	if idx := strings.Index(value, ":"); idx >= 0 {
+		return value[:idx], value[idx+1:]
+	}
+	return value, ""
+}
+
+func buildXuguDSN(host string, port int, database, username, password, urlParams string) string {
+	if port <= 0 {
+		port = defaultXuguPort
+	}
+	parts := []string{
+		"IP=" + host,
+		"DB=" + strings.TrimSpace(database),
+		"User=" + strings.TrimSpace(username),
+		"PWD=" + strings.TrimSpace(password),
+		"Port=" + strconv.Itoa(port),
+	}
+	if !hasDSNParam(urlParams, "CHAR_SET") && !hasDSNParam(urlParams, "CHARSET") {
+		parts = append(parts, "CHAR_SET=UTF8")
+	}
+	for _, param := range splitDSNParams(urlParams) {
+		parts = append(parts, param)
+	}
+	return strings.Join(parts, ";")
+}
+
+func hasDSNParam(raw, key string) bool {
+	key = strings.ToUpper(strings.TrimSpace(key))
+	for _, param := range splitDSNParams(raw) {
+		name, _, _ := strings.Cut(param, "=")
+		if strings.ToUpper(strings.TrimSpace(name)) == key {
+			return true
+		}
+	}
+	return false
+}
+
+func splitDSNParams(raw string) []string {
+	raw = strings.TrimSpace(strings.Trim(raw, ";"))
+	if raw == "" {
+		return nil
+	}
+	if strings.Contains(raw, ";") {
+		items := strings.Split(raw, ";")
+		result := make([]string, 0, len(items))
+		for _, item := range items {
+			item = strings.TrimSpace(item)
+			if item != "" {
+				result = append(result, item)
+			}
+		}
+		return result
+	}
+	if strings.Contains(raw, "&") {
+		items := strings.Split(raw, "&")
+		result := make([]string, 0, len(items))
+		for _, item := range items {
+			item = strings.TrimSpace(item)
+			if item != "" {
+				result = append(result, item)
+			}
+		}
+		return result
+	}
+	return []string{raw}
+}
+
+func parsePort(value string) int {
+	port, _ := strconv.Atoi(value)
+	return port
+}
+
+func (s *server) requireDB() (*sql.DB, error) {
+	if s.db == nil {
+		return nil, errors.New("agent is not connected")
+	}
+	return s.db, nil
+}
+
+func (s *server) useDatabase(database string) error {
+	database = strings.TrimSpace(database)
+	if database == "" {
+		return nil
+	}
+	if strings.EqualFold(database, configuredDatabaseName(s.params)) {
+		return nil
+	}
+	db, err := s.requireDB()
+	if err != nil {
+		return err
+	}
+	_, err = db.Exec("USE " + quoteIdentifier(database))
+	return err
+}
+
+func (s *server) listDatabases() ([]databaseInfo, error) {
+	rows, err := s.queryRows(xuguListDatabasesSQL, nil)
+	if err != nil {
+		if fallback := fallbackDatabasesFromParams(s.params); len(fallback) > 0 && isXuguMetadataAccessError(err) {
+			return fallback, nil
+		}
+		return nil, err
+	}
+	defer rows.Close()
+	var result []databaseInfo
+	for rows.Next() {
+		var name string
+		if err := rows.Scan(&name); err != nil {
+			return nil, err
+		}
+		result = append(result, databaseInfo{Name: name})
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func fallbackDatabasesFromParams(params connectParams) []databaseInfo {
+	if name := configuredDatabaseName(params); name != "" {
+		return []databaseInfo{{Name: name}}
+	}
+	return nil
+}
+
+func configuredDatabaseName(params connectParams) string {
+	if name := strings.TrimSpace(params.Database); name != "" {
+		return name
+	}
+	connectionString := strings.TrimSpace(params.ConnectionString)
+	if parsed := parseXuguURL(connectionString); parsed.Database != "" {
+		return parsed.Database
+	}
+	if jdbc := parseXuguJDBCURL(connectionString); jdbc.Database != "" {
+		return jdbc.Database
+	}
+	if value := xuguDSNValue(connectionString, "DB"); value != "" {
+		return value
+	}
+	return ""
+}
+
+func isXuguMetadataAccessError(err error) bool {
+	message := strings.ToUpper(err.Error())
+	return strings.Contains(message, "E18012") ||
+		strings.Contains(message, "权限不够") ||
+		strings.Contains(message, "ALL_DATABASES") ||
+		strings.Contains(message, "SYS_DATABASES") ||
+		strings.Contains(message, "ALL_SCHEMAS") ||
+		strings.Contains(message, "SYS_SCHEMAS") ||
+		strings.Contains(message, "ALL_TABLES") ||
+		strings.Contains(message, "SYS_TABLES") ||
+		strings.Contains(message, "ALL_VIEWS") ||
+		strings.Contains(message, "SYS_VIEWS") ||
+		strings.Contains(message, "ALL_COLUMNS") ||
+		strings.Contains(message, "ALL_CONSTRAINTS") ||
+		strings.Contains(message, "ALL_INDEXES") ||
+		strings.Contains(message, "SYS_COLUMNS") ||
+		strings.Contains(message, "SYS_CONSTRAINTS") ||
+		strings.Contains(message, "SYS_INDEXES") ||
+		strings.Contains(message, "SYS_TRIGGERS")
+}
+
+func xuguDSNValue(dsn string, key string) string {
+	for _, part := range strings.Split(dsn, ";") {
+		name, value, ok := strings.Cut(part, "=")
+		if ok && strings.EqualFold(strings.TrimSpace(name), key) {
+			return strings.TrimSpace(value)
+		}
+	}
+	return ""
+}
+
+func (s *server) listSchemas() ([]string, error) {
+	rows, err := s.queryRows(xuguListSchemasSQL, nil)
+	if err != nil {
+		if fallback := strings.ToUpper(strings.TrimSpace(s.params.Username)); fallback != "" && isXuguMetadataAccessError(err) {
+			return []string{fallback}, nil
+		}
+		return nil, err
+	}
+	defer rows.Close()
+	var result []string
+	for rows.Next() {
+		var schema string
+		if err := rows.Scan(&schema); err != nil {
+			return nil, err
+		}
+		result = append(result, schema)
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func (s *server) currentSchema() (string, error) {
+	rows, err := s.queryRows(`
+SELECT s.SCHEMA_NAME
+FROM SYS_SCHEMAS s
+JOIN SYS_USERS u ON u.DB_ID = s.DB_ID AND u.USER_ID = s.USER_ID
+WHERE UPPER(u.USER_NAME) = UPPER(?)
+ORDER BY CASE WHEN UPPER(s.SCHEMA_NAME) = UPPER(?) THEN 0 ELSE 1 END, s.SCHEMA_NAME`, []any{s.params.Username, s.params.Username})
+	if err != nil {
+		if fallback := strings.ToUpper(strings.TrimSpace(s.params.Username)); fallback != "" && isXuguMetadataAccessError(err) {
+			return fallback, nil
+		}
+		return "", err
+	}
+	defer rows.Close()
+	if rows.Next() {
+		var schema string
+		if err := rows.Scan(&schema); err != nil {
+			return "", err
+		}
+		return strings.ToUpper(schema), nil
+	}
+	if err := rows.Err(); err != nil {
+		return "", err
+	}
+	return strings.ToUpper(strings.TrimSpace(s.params.Username)), nil
+}
+
+func (s *server) normalizeSchema(schema string) (string, error) {
+	schema = strings.TrimSpace(schema)
+	if schema == "" {
+		return s.currentSchema()
+	}
+	return strings.ToUpper(schema), nil
+}
+
+func (s *server) listTables(schema string, constraints metadataListConstraints) ([]tableInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	query := xuguListTablesQuery(schema, constraints)
+	rows, err := s.queryRows(query.SQL, query.Args)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var result []tableInfo
+	for rows.Next() {
+		var item tableInfo
+		if err := rows.Scan(&item.Name, &item.TableType, &item.Comment); err != nil {
+			return nil, err
+		}
+		result = append(result, item)
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func (s *server) listObjects(schema string, constraints metadataListConstraints) ([]objectInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	query := xuguListObjectsQuery(schema, constraints)
+	rows, err := s.queryRows(query.SQL, query.Args)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var result []objectInfo
+	for rows.Next() {
+		var item objectInfo
+		item.Schema = schema
+		if err := rows.Scan(&item.Name, &item.ObjectType, &item.Comment); err != nil {
+			return nil, err
+		}
+		result = append(result, item)
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func metadataListConstraintsFromParams(params map[string]json.RawMessage) metadataListConstraints {
+	objectTypes := stringSliceParam(params, "object_types")
+	if len(objectTypes) == 0 {
+		objectTypes = stringSliceParam(params, "objectTypes")
+	}
+	limit := intParam(params, "limit")
+	offset := intParam(params, "offset")
+	if limit < 0 {
+		limit = 0
+	}
+	if offset < 0 {
+		offset = 0
+	}
+	return metadataListConstraints{
+		Filter:      stringParam(params, "filter"),
+		Limit:       limit,
+		Offset:      offset,
+		ObjectTypes: objectTypes,
+	}
+}
+
+func xuguListTablesQuery(schema string, constraints metadataListConstraints) xuguMetadataListQuery {
+	return xuguConstrainedMetadataListQuery(
+		`
+SELECT t.TABLE_NAME, 'TABLE' AS TABLE_TYPE, t.COMMENTS
+FROM ALL_TABLES t
+JOIN ALL_SCHEMAS s ON s.DB_ID = t.DB_ID AND s.SCHEMA_ID = t.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?)
+UNION ALL
+SELECT v.VIEW_NAME, 'VIEW' AS TABLE_TYPE, v.COMMENTS
+FROM ALL_VIEWS v
+JOIN ALL_SCHEMAS s ON s.DB_ID = v.DB_ID AND s.SCHEMA_ID = v.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?)`,
+		"TABLE_NAME, TABLE_TYPE, COMMENTS",
+		"TABLE_NAME",
+		"TABLE_TYPE",
+		[]any{schema, schema},
+		constraints,
+	)
+}
+
+func xuguListObjectsQuery(schema string, constraints metadataListConstraints) xuguMetadataListQuery {
+	return xuguConstrainedMetadataListQuery(
+		`
+SELECT t.TABLE_NAME AS OBJECT_NAME, 'TABLE' AS OBJECT_TYPE, t.COMMENTS
+FROM ALL_TABLES t
+JOIN ALL_SCHEMAS s ON s.DB_ID = t.DB_ID AND s.SCHEMA_ID = t.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?)
+UNION ALL
+SELECT v.VIEW_NAME AS OBJECT_NAME, 'VIEW' AS OBJECT_TYPE, v.COMMENTS
+FROM ALL_VIEWS v
+JOIN ALL_SCHEMAS s ON s.DB_ID = v.DB_ID AND s.SCHEMA_ID = v.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?)`,
+		"OBJECT_NAME, OBJECT_TYPE, COMMENTS",
+		"OBJECT_NAME",
+		"OBJECT_TYPE",
+		[]any{schema, schema},
+		constraints,
+	)
+}
+
+func xuguConstrainedMetadataListQuery(baseSQL, selectList, nameColumn, typeColumn string, baseArgs []any, constraints metadataListConstraints) xuguMetadataListQuery {
+	args := append([]any{}, baseArgs...)
+	where := make([]string, 0, 2)
+	if filter := strings.TrimSpace(constraints.Filter); filter != "" {
+		args = append(args, strings.ToUpper(xuguFuzzyLikePattern(filter)))
+		where = append(where, fmt.Sprintf("UPPER(%s) LIKE ? ESCAPE '\\'", nameColumn))
+	}
+	if len(constraints.ObjectTypes) > 0 {
+		objectTypes := normalizedXuguObjectTypes(constraints.ObjectTypes)
+		if len(objectTypes) == 0 {
+			where = append(where, "1 = 0")
+		} else {
+			placeholders := make([]string, 0, len(objectTypes))
+			for _, objectType := range objectTypes {
+				args = append(args, objectType)
+				placeholders = append(placeholders, "?")
+			}
+			where = append(where, fmt.Sprintf("%s IN (%s)", typeColumn, strings.Join(placeholders, ",")))
+		}
+	}
+
+	sqlText := fmt.Sprintf("SELECT %s\nFROM (\n%s\n)", selectList, baseSQL)
+	if len(where) > 0 {
+		sqlText += "\nWHERE " + strings.Join(where, " AND ")
+	}
+	sqlText += fmt.Sprintf("\nORDER BY %s, %s", typeColumn, nameColumn)
+
+	// Xugu documents ROWNUM as the safe pagination path when ORDER BY belongs
+	// to an inner query; LIMIT is not portable for this UNION metadata query.
+	if constraints.Limit > 0 {
+		args = append(args, constraints.Offset+constraints.Limit, constraints.Offset)
+		sqlText = fmt.Sprintf(
+			"SELECT %s\nFROM (\n  SELECT DBX_Q.*, ROWNUM AS DBX_RN\n  FROM (\n%s\n  ) DBX_Q\n  WHERE ROWNUM <= ?\n)\nWHERE DBX_RN > ?",
+			selectList,
+			sqlText,
+		)
+	} else if constraints.Offset > 0 {
+		args = append(args, constraints.Offset)
+		sqlText = fmt.Sprintf(
+			"SELECT %s\nFROM (\n  SELECT DBX_Q.*, ROWNUM AS DBX_RN\n  FROM (\n%s\n  ) DBX_Q\n)\nWHERE DBX_RN > ?",
+			selectList,
+			sqlText,
+		)
+	}
+
+	return xuguMetadataListQuery{SQL: sqlText, Args: args}
+}
+
+func normalizedXuguObjectTypes(values []string) []string {
+	seen := map[string]bool{}
+	result := make([]string, 0, len(values))
+	for _, value := range values {
+		normalized := strings.ToUpper(strings.TrimSpace(value))
+		normalized = strings.ReplaceAll(normalized, "-", "_")
+		normalized = strings.ReplaceAll(normalized, " ", "_")
+		switch normalized {
+		case "TABLE", "BASE_TABLE":
+			normalized = "TABLE"
+		case "VIEW":
+			normalized = "VIEW"
+		default:
+			continue
+		}
+		if seen[normalized] {
+			continue
+		}
+		seen[normalized] = true
+		result = append(result, normalized)
+	}
+	sort.Strings(result)
+	return result
+}
+
+func xuguFuzzyLikePattern(value string) string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return "%%"
+	}
+	var builder strings.Builder
+	builder.Grow(len(value)*2 + 2)
+	builder.WriteByte('%')
+	for _, ch := range value {
+		switch ch {
+		case '\\', '%', '_':
+			builder.WriteByte('\\')
+		}
+		builder.WriteRune(ch)
+		builder.WriteByte('%')
+	}
+	return builder.String()
+}
+
+func (s *server) getColumns(schema, table string) ([]columnInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	table = strings.ToUpper(strings.TrimSpace(table))
+	primaryKeys, err := s.primaryKeyColumns(schema, table)
+	if err != nil {
+		return nil, err
+	}
+	rows, err := s.queryRows(xuguListColumnsSQL, []any{schema, table})
+	if err != nil {
+		if isXuguMetadataAccessError(err) {
+			return s.columnsFromSelect(schema, table, primaryKeys)
+		}
+		return nil, err
+	}
+	defer rows.Close()
+	var result []columnInfo
+	for rows.Next() {
+		var item columnInfo
+		var notNull any
+		var scale *int
+		var varying any
+		if err := rows.Scan(
+			&item.Name,
+			&item.DataType,
+			&notNull,
+			&item.ColumnDefault,
+			&item.Comment,
+			&scale,
+			&varying,
+		); err != nil {
+			return nil, err
+		}
+		item.DataType = normalizeXuguColumnType(item.DataType, varying)
+		item.IsNullable = !truthy(notNull)
+		item.IsPrimaryKey = primaryKeys[strings.ToUpper(item.Name)]
+		item.NumericPrecision, item.NumericScale, item.CharacterMaximumLength = decodeXuguScale(item.DataType, scale)
+		result = append(result, item)
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func (s *server) columnsFromSelect(schema, table string, primaryKeys map[string]bool) ([]columnInfo, error) {
+	rows, err := s.queryRows(
+		"SELECT * FROM "+quoteIdentifier(schema)+"."+quoteIdentifier(table)+" WHERE 1 = 0",
+		nil,
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	types, err := rows.ColumnTypes()
+	if err != nil {
+		return nil, err
+	}
+	result := make([]columnInfo, 0, len(types))
+	for _, columnType := range types {
+		item := columnInfo{
+			Name:         columnType.Name(),
+			DataType:     columnType.DatabaseTypeName(),
+			IsPrimaryKey: primaryKeys[strings.ToUpper(columnType.Name())],
+		}
+		if nullable, ok := columnType.Nullable(); ok {
+			item.IsNullable = nullable
+		} else {
+			item.IsNullable = true
+		}
+		if length, ok := columnType.Length(); ok {
+			value := int(length)
+			item.CharacterMaximumLength = &value
+		}
+		result = append(result, item)
+	}
+	return emptyIfNil(result), nil
+}
+
+func (s *server) primaryKeyColumns(schema, table string) (map[string]bool, error) {
+	rows, err := s.queryRows(xuguPrimaryKeyColumnsSQL, []any{schema, table})
+	if err != nil {
+		if isXuguMetadataAccessError(err) {
+			return map[string]bool{}, nil
+		}
+		return nil, err
+	}
+	defer rows.Close()
+	result := map[string]bool{}
+	for rows.Next() {
+		var define string
+		if err := rows.Scan(&define); err != nil {
+			return nil, err
+		}
+		for _, column := range parseQuotedIdentifiers(define) {
+			result[strings.ToUpper(column)] = true
+		}
+	}
+	return result, rows.Err()
+}
+
+func (s *server) listIndexes(schema, table string) ([]indexInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	table = strings.ToUpper(strings.TrimSpace(table))
+	rows, err := s.queryRows(xuguListIndexesSQL, []any{schema, table})
+	if err != nil {
+		if isXuguMetadataAccessError(err) {
+			return []indexInfo{}, nil
+		}
+		return nil, err
+	}
+	defer rows.Close()
+
+	var result []indexInfo
+	for rows.Next() {
+		var item indexInfo
+		var keys string
+		var unique, primary any
+		var indexType any
+		if err := rows.Scan(&item.Name, &keys, &unique, &primary, &indexType, &item.Filter); err != nil {
+			return nil, err
+		}
+		item.Columns = parseIndexKeys(keys)
+		item.IsUnique = truthy(unique)
+		item.IsPrimary = truthy(primary)
+		item.IndexType = stringPtr(indexTypeName(indexType))
+		item.IncludedColumns = []string{}
+		result = append(result, item)
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func (s *server) listForeignKeys(schema, table string) ([]foreignKeyInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	table = strings.ToUpper(strings.TrimSpace(table))
+	rows, err := s.queryRows(`
+SELECT c.CONS_NAME, c.DEFINE, rt.TABLE_NAME
+FROM SYS_CONSTRAINTS c
+JOIN SYS_TABLES t ON t.DB_ID = c.DB_ID AND t.TABLE_ID = c.TABLE_ID
+JOIN SYS_TABLES rt ON rt.DB_ID = c.DB_ID AND rt.TABLE_ID = c.REF_TABLE_ID
+JOIN SYS_SCHEMAS s ON s.DB_ID = t.DB_ID AND s.SCHEMA_ID = t.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?)
+  AND UPPER(t.TABLE_NAME) = UPPER(?)
+  AND c.CONS_TYPE = 'F'
+ORDER BY c.CONS_NAME`, []any{schema, table})
+	if err != nil {
+		if isXuguMetadataAccessError(err) {
+			return []foreignKeyInfo{}, nil
+		}
+		return nil, err
+	}
+	defer rows.Close()
+	var result []foreignKeyInfo
+	for rows.Next() {
+		var name, define, refTable string
+		if err := rows.Scan(&name, &define, &refTable); err != nil {
+			return nil, err
+		}
+		local, ref := parseForeignKeyColumns(define)
+		for i, column := range local {
+			item := foreignKeyInfo{Name: name, Column: column, RefTable: refTable}
+			if i < len(ref) {
+				item.RefColumn = ref[i]
+			}
+			result = append(result, item)
+		}
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func (s *server) listTriggers(schema, table string) ([]triggerInfo, error) {
+	schema, err := s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	table = strings.ToUpper(strings.TrimSpace(table))
+	rows, err := s.queryRows(`
+SELECT tr.TRIG_NAME, tr.TRIG_EVENT, tr.TRIG_TIME
+FROM SYS_TRIGGERS tr
+JOIN SYS_TABLES t ON t.DB_ID = tr.DB_ID AND t.TABLE_ID = tr.OBJ_ID
+JOIN SYS_SCHEMAS s ON s.DB_ID = t.DB_ID AND s.SCHEMA_ID = t.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?)
+  AND UPPER(t.TABLE_NAME) = UPPER(?)
+ORDER BY tr.TRIG_NAME`, []any{schema, table})
+	if err != nil {
+		if isXuguMetadataAccessError(err) {
+			return []triggerInfo{}, nil
+		}
+		return nil, err
+	}
+	defer rows.Close()
+	var result []triggerInfo
+	for rows.Next() {
+		var item triggerInfo
+		var event, timing any
+		if err := rows.Scan(&item.Name, &event, &timing); err != nil {
+			return nil, err
+		}
+		item.Event = triggerEventName(event)
+		item.Timing = triggerTimingName(timing)
+		result = append(result, item)
+	}
+	return emptyIfNil(result), rows.Err()
+}
+
+func (s *server) getObjectSource(schema, name, objectType string) (map[string]any, error) {
+	var err error
+	schema, err = s.normalizeSchema(schema)
+	if err != nil {
+		return nil, err
+	}
+	sourceSQL, args, err := objectSourceQuery(schema, name, objectType)
+	if err != nil {
+		return nil, err
+	}
+	rows, err := s.queryRows(sourceSQL, args)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var builder strings.Builder
+	for rows.Next() {
+		var line string
+		if err := rows.Scan(&line); err != nil {
+			return nil, err
+		}
+		builder.WriteString(line)
+	}
+	return map[string]any{"name": name, "object_type": objectType, "schema": schema, "source": builder.String()}, rows.Err()
+}
+
+func (s *server) getTableDDL(schema, table string) (string, error) {
+	var err error
+	schema, err = s.normalizeSchema(schema)
+	if err != nil {
+		return "", err
+	}
+	var ddl string
+	rows, err := s.queryRows("SELECT TO_CHAR(DBMS_METADATA.GET_DDL('TABLE', ?, ?)) FROM DUAL", []any{strings.ToUpper(table), schema})
+	if err == nil {
+		defer rows.Close()
+		if rows.Next() {
+			if scanErr := rows.Scan(&ddl); scanErr == nil && strings.TrimSpace(ddl) != "" {
+				if err := rows.Err(); err != nil {
+					return "", err
+				}
+				return s.appendTableIndexDDL(schema, table, ddl), nil
+			}
+		}
+	}
+	ddl, err = s.buildTableDDL(schema, table)
+	if err != nil {
+		return "", err
+	}
+	return s.appendTableIndexDDL(schema, table, ddl), nil
+}
+
+func (s *server) getExplainInfo(sqlText string) (string, error) {
+	if strings.TrimSpace(sqlText) == "" {
+		return "", errors.New("sql is required")
+	}
+	rows, err := s.queryRows("EXPLAIN "+trimStatementSQL(sqlText), nil)
+	if err != nil {
+		return "", err
+	}
+	defer rows.Close()
+	columns, err := rows.Columns()
+	if err != nil {
+		return "", err
+	}
+	var builder strings.Builder
+	for rows.Next() {
+		values, err := scanRow(rows, len(columns))
+		if err != nil {
+			return "", err
+		}
+		builder.WriteString(joinValues(values, "\t"))
+		builder.WriteByte('\n')
+	}
+	return strings.TrimSpace(builder.String()), rows.Err()
+}
+
+func (s *server) executeTransaction(params map[string]json.RawMessage) (queryResult, error) {
+	var payload struct {
+		Statements []string `json:"statements"`
+		Schema     string   `json:"schema"`
+	}
+	if err := decodeParams(params, &payload); err != nil {
+		return queryResult{}, err
+	}
+	db, err := s.requireDB()
+	if err != nil {
+		return queryResult{}, err
+	}
+	tx, err := db.Begin()
+	if err != nil {
+		return queryResult{}, err
+	}
+	if strings.TrimSpace(payload.Schema) != "" {
+		if _, err := tx.Exec("SET SCHEMA " + quoteIdentifier(payload.Schema)); err != nil {
+			tx.Rollback()
+			return queryResult{}, err
+		}
+	}
+	var affected int64
+	start := time.Now()
+	for _, statement := range payload.Statements {
+		statement = trimStatementSQL(statement)
+		if statement == "" {
+			continue
+		}
+		result, err := tx.Exec(statement)
+		if err != nil {
+			tx.Rollback()
+			return queryResult{}, err
+		}
+		count, _ := result.RowsAffected()
+		affected += count
+	}
+	if err := tx.Commit(); err != nil {
+		return queryResult{}, err
+	}
+	return queryResult{
+		Columns:         []string{},
+		ColumnTypes:     []string{},
+		Rows:            [][]any{},
+		AffectedRows:    affected,
+		ExecutionTimeMS: time.Since(start).Milliseconds(),
+	}, nil
+}
+
+func (s *server) executeQueryPage(opts queryOptions, pageSize int) (queryPageResult, error) {
+	start := time.Now()
+	if err := s.useDatabase(opts.Database); err != nil {
+		return queryPageResult{}, err
+	}
+	if strings.TrimSpace(opts.Schema) != "" {
+		if err := s.setSchema(opts.Schema); err != nil {
+			return queryPageResult{}, err
+		}
+	}
+	sqlText := trimStatementSQL(opts.SQL)
+	if !isQuerySQL(sqlText) {
+		result, err := s.executeQuery(opts)
+		return queryPageResult{
+			Columns:         result.Columns,
+			ColumnTypes:     result.ColumnTypes,
+			Rows:            result.Rows,
+			AffectedRows:    result.AffectedRows,
+			ExecutionTimeMS: result.ExecutionTimeMS,
+			Truncated:       result.Truncated,
+			SessionID:       nil,
+			HasMore:         false,
+		}, err
+	}
+	rows, err := s.queryRows(sqlText, nil)
+	if err != nil {
+		return queryPageResult{}, err
+	}
+	columns, err := rows.Columns()
+	if err != nil {
+		rows.Close()
+		return queryPageResult{}, err
+	}
+	columnTypes := columnTypeNames(rows)
+	maxRows := opts.MaxRows
+	if maxRows <= 0 {
+		maxRows = defaultMaxRows
+	}
+	session := &querySession{rows: rows, columns: columns, columnTypes: columnTypes, remaining: maxRows}
+	result, err := readQuerySessionPage(session, pageSize)
+	result.ExecutionTimeMS = time.Since(start).Milliseconds()
+	if err != nil {
+		rows.Close()
+		return queryPageResult{}, err
+	}
+	if result.HasMore {
+		sessionID := s.storeQuerySession(session)
+		result.SessionID = &sessionID
+	} else {
+		rows.Close()
+	}
+	return result, nil
+}
+
+func (s *server) fetchQueryPage(sessionID string, pageSize int) (queryPageResult, error) {
+	session := s.sessions[sessionID]
+	if session == nil {
+		return queryPageResult{Columns: []string{}, ColumnTypes: []string{}, Rows: [][]any{}, SessionID: nil, HasMore: false}, nil
+	}
+	result, err := readQuerySessionPage(session, pageSize)
+	if err != nil {
+		s.closeQuerySession(sessionID)
+		return queryPageResult{}, err
+	}
+	if result.HasMore {
+		result.SessionID = &sessionID
+	} else {
+		s.closeQuerySession(sessionID)
+	}
+	return result, nil
+}
+
+func (s *server) storeQuerySession(session *querySession) string {
+	s.nextSessionID++
+	sessionID := fmt.Sprintf("xugu-%d", s.nextSessionID)
+	s.sessions[sessionID] = session
+	return sessionID
+}
+
+func (s *server) closeQuerySession(sessionID string) bool {
+	session := s.sessions[sessionID]
+	if session == nil {
+		return false
+	}
+	session.rows.Close()
+	delete(s.sessions, sessionID)
+	return true
+}
+
+func (s *server) closeAllQuerySessions() {
+	for sessionID := range s.sessions {
+		s.closeQuerySession(sessionID)
+	}
+}
+
+func readQuerySessionPage(session *querySession, pageSize int) (queryPageResult, error) {
+	if pageSize <= 0 {
+		pageSize = defaultMaxRows
+	}
+	result := queryPageResult{Columns: session.columns, ColumnTypes: session.columnTypes, Rows: [][]any{}, SessionID: nil, HasMore: false}
+	for len(result.Rows) < pageSize && session.remaining > 0 {
+		if session.pending != nil {
+			result.Rows = append(result.Rows, session.pending)
+			session.pending = nil
+			session.remaining--
+			continue
+		}
+		if !session.rows.Next() {
+			return result, session.rows.Err()
+		}
+		row, err := scanRow(session.rows, len(session.columns))
+		if err != nil {
+			return queryPageResult{}, err
+		}
+		result.Rows = append(result.Rows, row)
+		session.remaining--
+	}
+	if session.remaining <= 0 {
+		result.Truncated = true
+		return result, nil
+	}
+	if session.rows.Next() {
+		row, err := scanRow(session.rows, len(session.columns))
+		if err != nil {
+			return queryPageResult{}, err
+		}
+		session.pending = row
+		result.HasMore = true
+		return result, nil
+	}
+	return result, session.rows.Err()
+}
+
+func (s *server) executeQuery(opts queryOptions) (queryResult, error) {
+	start := time.Now()
+	if err := s.useDatabase(opts.Database); err != nil {
+		return queryResult{}, err
+	}
+	if strings.TrimSpace(opts.Schema) != "" {
+		if err := s.setSchema(opts.Schema); err != nil {
+			return queryResult{}, err
+		}
+	}
+	sqlText := trimStatementSQL(opts.SQL)
+	maxRows := opts.MaxRows
+	if maxRows <= 0 {
+		maxRows = defaultMaxRows
+	}
+	if isQuerySQL(sqlText) {
+		result, err := s.executeSelect(sqlText, maxRows)
+		result.ExecutionTimeMS = time.Since(start).Milliseconds()
+		return result, err
+	}
+	db, err := s.requireDB()
+	if err != nil {
+		return queryResult{}, err
+	}
+	execResult, err := db.Exec(sqlText)
+	if err != nil {
+		return queryResult{}, err
+	}
+	affected, _ := execResult.RowsAffected()
+	return queryResult{Columns: []string{}, ColumnTypes: []string{}, Rows: [][]any{}, AffectedRows: affected, ExecutionTimeMS: time.Since(start).Milliseconds()}, nil
+}
+
+func (s *server) executeSelect(sqlText string, maxRows int) (queryResult, error) {
+	rows, err := s.queryRows(sqlText, nil)
+	if err != nil {
+		return queryResult{}, err
+	}
+	defer rows.Close()
+	columns, err := rows.Columns()
+	if err != nil {
+		return queryResult{}, err
+	}
+	result := queryResult{Columns: columns, ColumnTypes: columnTypeNames(rows), Rows: [][]any{}}
+	for rows.Next() {
+		if len(result.Rows) >= maxRows {
+			result.Truncated = true
+			break
+		}
+		values, err := scanRow(rows, len(columns))
+		if err != nil {
+			return queryResult{}, err
+		}
+		result.Rows = append(result.Rows, values)
+	}
+	return result, rows.Err()
+}
+
+func scanRow(rows *sql.Rows, columnCount int) ([]any, error) {
+	values := make([]any, columnCount)
+	scanTargets := make([]any, columnCount)
+	for i := range values {
+		scanTargets[i] = &values[i]
+	}
+	if err := rows.Scan(scanTargets...); err != nil {
+		return nil, err
+	}
+	for i, value := range values {
+		values[i] = normalizeValue(value)
+	}
+	return values, nil
+}
+
+func columnTypeNames(rows *sql.Rows) []string {
+	types, err := rows.ColumnTypes()
+	if err != nil {
+		return []string{}
+	}
+	result := make([]string, 0, len(types))
+	for _, columnType := range types {
+		result = append(result, columnType.DatabaseTypeName())
+	}
+	return result
+}
+
+func (s *server) setSchema(schema string) error {
+	db, err := s.requireDB()
+	if err != nil {
+		return err
+	}
+	_, err = db.Exec("SET SCHEMA " + quoteIdentifier(schema))
+	return err
+}
+
+func (s *server) queryRows(sqlText string, args []any) (*sql.Rows, error) {
+	db, err := s.requireDB()
+	if err != nil {
+		return nil, err
+	}
+	if len(args) == 0 {
+		return db.Query(sqlText)
+	}
+	return db.Query(sqlText, args...)
+}
+
+func objectSourceQuery(schema, name, objectType string) (string, []any, error) {
+	objectType = strings.ToUpper(strings.TrimSpace(objectType))
+	name = strings.ToUpper(strings.TrimSpace(name))
+	switch objectType {
+	case "VIEW":
+		return `
+SELECT TO_CHAR(v.DEFINE)
+FROM SYS_VIEWS v
+JOIN SYS_SCHEMAS s ON s.DB_ID = v.DB_ID AND s.SCHEMA_ID = v.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?) AND UPPER(v.VIEW_NAME) = UPPER(?)`, []any{schema, name}, nil
+	case "TRIGGER":
+		return `
+SELECT TO_CHAR(t.DEFINE)
+FROM SYS_TRIGGERS t
+JOIN SYS_SCHEMAS s ON s.DB_ID = t.DB_ID AND s.SCHEMA_ID = t.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?) AND UPPER(t.TRIG_NAME) = UPPER(?)`, []any{schema, name}, nil
+	case "PROCEDURE", "FUNCTION":
+		return `
+SELECT TO_CHAR(p.DEFINE)
+FROM SYS_PROCEDURES p
+JOIN SYS_SCHEMAS s ON s.DB_ID = p.DB_ID AND s.SCHEMA_ID = p.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?) AND UPPER(p.PROC_NAME) = UPPER(?)`, []any{schema, name}, nil
+	case "PACKAGE", "PACKAGE BODY":
+		return `
+SELECT COALESCE(TO_CHAR(k.SPEC), '') || COALESCE(TO_CHAR(k.BODY), '')
+FROM SYS_PACKAGES k
+JOIN SYS_SCHEMAS s ON s.DB_ID = k.DB_ID AND s.SCHEMA_ID = k.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?) AND UPPER(k.PACK_NAME) = UPPER(?)`, []any{schema, name}, nil
+	default:
+		return "", nil, fmt.Errorf("object source is not supported for %s", objectType)
+	}
+}
+
+func (s *server) buildTableDDL(schema, table string) (string, error) {
+	columns, err := s.getColumns(schema, table)
+	if err != nil {
+		return "", err
+	}
+	if len(columns) == 0 {
+		return "", fmt.Errorf("table not found: %s.%s", schema, table)
+	}
+	var builder strings.Builder
+	builder.WriteString("CREATE TABLE ")
+	builder.WriteString(quoteIdentifier(schema))
+	builder.WriteByte('.')
+	builder.WriteString(quoteIdentifier(table))
+	builder.WriteString(" (\n")
+	for i, column := range columns {
+		if i > 0 {
+			builder.WriteString(",\n")
+		}
+		builder.WriteString("  ")
+		builder.WriteString(quoteIdentifier(column.Name))
+		builder.WriteByte(' ')
+		builder.WriteString(columnTypeDDL(column))
+		if column.ColumnDefault != nil && strings.TrimSpace(*column.ColumnDefault) != "" {
+			builder.WriteString(" DEFAULT ")
+			builder.WriteString(strings.TrimSpace(*column.ColumnDefault))
+		}
+		if !column.IsNullable {
+			builder.WriteString(" NOT NULL")
+		}
+		if column.Comment != nil && strings.TrimSpace(*column.Comment) != "" {
+			builder.WriteString(" COMMENT ")
+			builder.WriteString(quoteStringLiteral(strings.TrimSpace(*column.Comment)))
+		}
+	}
+	primary := make([]string, 0)
+	for _, column := range columns {
+		if column.IsPrimaryKey {
+			primary = append(primary, quoteIdentifier(column.Name))
+		}
+	}
+	if len(primary) > 0 {
+		builder.WriteString(",\n  PRIMARY KEY (")
+		builder.WriteString(strings.Join(primary, ", "))
+		builder.WriteByte(')')
+	}
+	builder.WriteString("\n)")
+	if comment, err := s.tableComment(schema, table); err == nil && strings.TrimSpace(comment) != "" {
+		builder.WriteString("\nCOMMENT ")
+		builder.WriteString(quoteStringLiteral(strings.TrimSpace(comment)))
+	}
+	return builder.String(), nil
+}
+
+func (s *server) appendTableIndexDDL(schema, table, ddl string) string {
+	indexDDL, err := s.tableIndexDDL(schema, table)
+	if err == nil && strings.TrimSpace(indexDDL) != "" {
+		return appendDDLStatement(ddl, indexDDL)
+	}
+	indexes, err := s.listIndexes(schema, table)
+	if err != nil || len(indexes) == 0 {
+		return ddl
+	}
+	var builder strings.Builder
+	for _, index := range indexes {
+		if index.IsPrimary || len(index.Columns) == 0 {
+			continue
+		}
+		if builder.Len() > 0 {
+			builder.WriteString("\n")
+		}
+		if index.IsUnique {
+			builder.WriteString("CREATE UNIQUE INDEX ")
+		} else {
+			builder.WriteString("CREATE INDEX ")
+		}
+		builder.WriteString(quoteIdentifier(index.Name))
+		builder.WriteString(" ON ")
+		builder.WriteString(quoteIdentifier(schema))
+		builder.WriteByte('.')
+		builder.WriteString(quoteIdentifier(table))
+		builder.WriteByte('(')
+		for i, column := range index.Columns {
+			if i > 0 {
+				builder.WriteString(", ")
+			}
+			builder.WriteString(quoteIdentifier(column))
+		}
+		builder.WriteByte(')')
+		if index.IndexType != nil && strings.TrimSpace(*index.IndexType) != "" {
+			builder.WriteString(" INDEXTYPE IS ")
+			builder.WriteString(strings.TrimSpace(*index.IndexType))
+		}
+		builder.WriteByte(';')
+	}
+	if builder.Len() == 0 {
+		return ddl
+	}
+	return appendDDLStatement(ddl, builder.String())
+}
+
+func (s *server) tableIndexDDL(schema, table string) (string, error) {
+	rows, err := s.queryRows(
+		"SELECT TO_CHAR(DBMS_METADATA.GET_DDL('INDEX', ?, ?)) FROM DUAL",
+		[]any{strings.ToUpper(strings.TrimSpace(table)), schema},
+	)
+	if err != nil {
+		return "", err
+	}
+	defer rows.Close()
+	var ddl string
+	if rows.Next() {
+		if err := rows.Scan(&ddl); err != nil {
+			return "", err
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return "", err
+	}
+	return ddl, nil
+}
+
+func (s *server) tableComment(schema, table string) (string, error) {
+	rows, err := s.queryRows(`
+SELECT t.COMMENTS
+FROM ALL_TABLES t
+JOIN ALL_SCHEMAS s ON s.DB_ID = t.DB_ID AND s.SCHEMA_ID = t.SCHEMA_ID
+WHERE UPPER(s.SCHEMA_NAME) = UPPER(?)
+  AND UPPER(t.TABLE_NAME) = UPPER(?)`, []any{schema, table})
+	if err != nil {
+		return "", err
+	}
+	defer rows.Close()
+	var comment *string
+	if rows.Next() {
+		if err := rows.Scan(&comment); err != nil {
+			return "", err
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return "", err
+	}
+	if comment == nil {
+		return "", nil
+	}
+	return *comment, nil
+}
+
+func appendDDLStatement(ddl, extra string) string {
+	ddl = strings.TrimRight(ddl, "\r\n\t ")
+	extra = strings.TrimSpace(extra)
+	if extra == "" {
+		return ddl
+	}
+	if !strings.HasSuffix(ddl, ";") {
+		ddl += ";"
+	}
+	return ddl + "\n\n" + extra
+}
+
+func columnTypeDDL(column columnInfo) string {
+	dataType := strings.ToUpper(strings.TrimSpace(column.DataType))
+	if column.CharacterMaximumLength != nil {
+		return fmt.Sprintf("%s(%d)", dataType, *column.CharacterMaximumLength)
+	}
+	if column.NumericPrecision != nil && column.NumericScale != nil {
+		return fmt.Sprintf("%s(%d,%d)", dataType, *column.NumericPrecision, *column.NumericScale)
+	}
+	return dataType
+}
+
+func decodeXuguScale(dataType string, scale *int) (*int, *int, *int) {
+	if scale == nil || *scale < 0 {
+		return nil, nil, nil
+	}
+	upper := strings.ToUpper(dataType)
+	if strings.Contains(upper, "CHAR") || strings.Contains(upper, "BINARY") {
+		length := *scale
+		return nil, nil, &length
+	}
+	if strings.Contains(upper, "NUM") || strings.Contains(upper, "DECIMAL") {
+		precision := *scale / 65536
+		numericScale := *scale % 65536
+		return &precision, &numericScale, nil
+	}
+	return nil, nil, nil
+}
+
+func normalizeXuguColumnType(dataType string, varying any) string {
+	upper := strings.ToUpper(strings.TrimSpace(dataType))
+	if !truthy(varying) {
+		return dataType
+	}
+	switch upper {
+	case "CHAR":
+		return "VARCHAR"
+	case "BINARY":
+		return "VARBINARY"
+	default:
+		return dataType
+	}
+}
+
+var quotedIdentifierRegexp = regexp.MustCompile(`"([^"]+)"`)
+
+func parseQuotedIdentifiers(value string) []string {
+	matches := quotedIdentifierRegexp.FindAllStringSubmatch(value, -1)
+	result := make([]string, 0, len(matches))
+	for _, match := range matches {
+		if len(match) == 2 {
+			result = append(result, match[1])
+		}
+	}
+	return result
+}
+
+func parseIndexKeys(value string) []string {
+	quoted := parseQuotedIdentifiers(value)
+	if len(quoted) > 0 {
+		return quoted
+	}
+	parts := strings.Split(value, ",")
+	result := make([]string, 0, len(parts))
+	for _, part := range parts {
+		part = strings.Trim(strings.TrimSpace(part), `"`)
+		if part != "" {
+			result = append(result, part)
+		}
+	}
+	return result
+}
+
+func parseForeignKeyColumns(define string) ([]string, []string) {
+	groups := regexp.MustCompile(`\(([^()]*)\)`).FindAllStringSubmatch(define, -1)
+	if len(groups) < 2 {
+		columns := parseQuotedIdentifiers(define)
+		if len(columns)%2 == 0 {
+			mid := len(columns) / 2
+			return columns[:mid], columns[mid:]
+		}
+		return columns, nil
+	}
+	return parseQuotedIdentifiers(groups[0][1]), parseQuotedIdentifiers(groups[1][1])
+}
+
+func truthy(value any) bool {
+	switch v := normalizeValue(value).(type) {
+	case bool:
+		return v
+	case int64:
+		return v != 0
+	case float64:
+		return v != 0
+	case string:
+		upper := strings.ToUpper(strings.TrimSpace(v))
+		return upper == "T" || upper == "TRUE" || upper == "1" || upper == "Y" || upper == "YES"
+	default:
+		return false
+	}
+}
+
+func stringPtr(value string) *string {
+	if strings.TrimSpace(value) == "" {
+		return nil
+	}
+	return &value
+}
+
+func quoteStringLiteral(value string) string {
+	return "'" + strings.ReplaceAll(value, "'", "''") + "'"
+}
+
+func indexTypeName(value any) string {
+	switch fmt.Sprint(normalizeValue(value)) {
+	case "0":
+		return "BTREE"
+	case "1":
+		return "RTREE"
+	case "2":
+		return "FULLTEXT"
+	case "3":
+		return "BITMAP"
+	default:
+		return fmt.Sprint(normalizeValue(value))
+	}
+}
+
+func triggerEventName(value any) string {
+	switch fmt.Sprint(normalizeValue(value)) {
+	case "1":
+		return "INSERT"
+	case "2":
+		return "UPDATE"
+	case "3":
+		return "INSERT OR UPDATE"
+	case "4":
+		return "DELETE"
+	case "5":
+		return "INSERT OR DELETE"
+	case "6":
+		return "UPDATE OR DELETE"
+	case "7":
+		return "INSERT OR UPDATE OR DELETE"
+	case "8":
+		return "LOGON"
+	default:
+		return fmt.Sprint(normalizeValue(value))
+	}
+}
+
+func triggerTimingName(value any) string {
+	switch fmt.Sprint(normalizeValue(value)) {
+	case "1":
+		return "BEFORE"
+	case "2":
+		return "INSTEAD"
+	case "4":
+		return "AFTER"
+	default:
+		return fmt.Sprint(normalizeValue(value))
+	}
+}
+
+func joinValues(values []any, sep string) string {
+	parts := make([]string, len(values))
+	for i, value := range values {
+		if value == nil {
+			parts[i] = ""
+		} else {
+			parts[i] = fmt.Sprint(value)
+		}
+	}
+	return strings.Join(parts, sep)
+}
+
+func decodeParams(params map[string]json.RawMessage, target any) error {
+	if params == nil {
+		params = map[string]json.RawMessage{}
+	}
+	data, err := json.Marshal(params)
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(data, target)
+}
+
+func stringParam(params map[string]json.RawMessage, key string) string {
+	if params == nil || len(params[key]) == 0 {
+		return ""
+	}
+	var value string
+	_ = json.Unmarshal(params[key], &value)
+	return value
+}
+
+func intParam(params map[string]json.RawMessage, key string) int {
+	if params == nil || len(params[key]) == 0 {
+		return 0
+	}
+	var value int
+	_ = json.Unmarshal(params[key], &value)
+	return value
+}
+
+func stringSliceParam(params map[string]json.RawMessage, key string) []string {
+	if params == nil || len(params[key]) == 0 {
+		return nil
+	}
+	var values []string
+	if err := json.Unmarshal(params[key], &values); err == nil {
+		return values
+	}
+	var single string
+	if err := json.Unmarshal(params[key], &single); err == nil && strings.TrimSpace(single) != "" {
+		return []string{single}
+	}
+	return nil
+}
+
+func errorResponse(id json.RawMessage, err error) response {
+	return response{JSONRPC: "2.0", ID: id, Error: &rpcError{Code: -1, Message: err.Error()}}
+}
+
+func trimStatementSQL(sqlText string) string {
+	return strings.TrimRight(strings.TrimSpace(sqlText), "; \t\r\n")
+}
+
+func isQuerySQL(sqlText string) bool {
+	lower := strings.ToLower(strings.TrimSpace(sqlText))
+	return strings.HasPrefix(lower, "select") || strings.HasPrefix(lower, "with")
+}
+
+func quoteIdentifier(value string) string {
+	return `"` + strings.ReplaceAll(value, `"`, `""`) + `"`
+}
+
+func normalizeValue(value any) any {
+	switch v := value.(type) {
+	case nil:
+		return nil
+	case []byte:
+		return string(v)
+	case time.Time:
+		return v.Format(time.RFC3339Nano)
+	case int:
+		return int64(v)
+	case int8:
+		return int64(v)
+	case int16:
+		return int64(v)
+	case int32:
+		return int64(v)
+	case int64:
+		return v
+	case uint:
+		return uint64(v)
+	case uint8:
+		return uint64(v)
+	case uint16:
+		return uint64(v)
+	case uint32:
+		return uint64(v)
+	case uint64:
+		return v
+	case float32:
+		return float64(v)
+	case float64, bool, string:
+		return v
+	case fmt.Stringer:
+		return v.String()
+	default:
+		return fmt.Sprint(v)
+	}
+}
+
+func emptyIfNil[T any](values []T) []T {
+	if values == nil {
+		return []T{}
+	}
+	return values
+}
diff --git a/agents/drivers/xugu/main_test.go b/agents/drivers/xugu/main_test.go
new file mode 100644
index 0000000..89f3f41
--- /dev/null
+++ b/agents/drivers/xugu/main_test.go
@@ -0,0 +1,529 @@
+package main
+
+import (
+	"encoding/json"
+	"errors"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestHandshakeResponse(t *testing.T) {
+	s := newServer()
+	resp, shutdown := s.handleLine(`{"jsonrpc":"2.0","id":7,"method":"handshake","params":{"appVersion":"dev"}}`)
+	if shutdown {
+		t.Fatal("handshake should not shut down the server")
+	}
+	if resp.Error != nil {
+		t.Fatalf("unexpected error: %v", resp.Error)
+	}
+	data, err := json.Marshal(resp.Result)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var result struct {
+		ProtocolVersion      int      `json:"protocolVersion"`
+		AgentProtocolVersion int      `json:"agentProtocolVersion"`
+		Capabilities         []string `json:"capabilities"`
+	}
+	if err := json.Unmarshal(data, &result); err != nil {
+		t.Fatal(err)
+	}
+	if result.ProtocolVersion != 1 || result.AgentProtocolVersion != 1 {
+		t.Fatalf("unexpected protocol versions: %+v", result)
+	}
+	contract := protocolContract(t)
+	if result.ProtocolVersion != contract.ProtocolVersion || result.AgentProtocolVersion != contract.ProtocolVersion {
+		t.Fatalf("handshake protocol versions do not match contract: result=%+v contract=%+v", result, contract)
+	}
+	for _, capability := range result.Capabilities {
+		if !contains(contract.AllCapabilities, capability) {
+			t.Fatalf("handshake returned capability %q outside protocol contract %v", capability, contract.AllCapabilities)
+		}
+	}
+	if !contains(result.Capabilities, "query") || !contains(result.Capabilities, "metadata") {
+		t.Fatalf("expected query and metadata capabilities, got %v", result.Capabilities)
+	}
+}
+
+func TestCloseMissingQuerySessionReturnsFalse(t *testing.T) {
+	s := newServer()
+	resp, shutdown := s.handleLine(`{"jsonrpc":"2.0","id":8,"method":"close_query_session","params":{"sessionId":"missing"}}`)
+	if shutdown {
+		t.Fatal("close_query_session should not shut down the server")
+	}
+	if resp.Error != nil {
+		t.Fatalf("unexpected error: %v", resp.Error)
+	}
+	if resp.Result != false {
+		t.Fatalf("expected false result, got %#v", resp.Result)
+	}
+}
+
+func TestListDataTypesReturnsXuguTypes(t *testing.T) {
+	s := newServer()
+	resp, shutdown := s.handleLine(`{"jsonrpc":"2.0","id":9,"method":"list_data_types","params":{"database":"demo"}}`)
+	if shutdown {
+		t.Fatal("list_data_types should not shut down the server")
+	}
+	if resp.Error != nil {
+		t.Fatalf("unexpected error: %v", resp.Error)
+	}
+	data, err := json.Marshal(resp.Result)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var result []string
+	if err := json.Unmarshal(data, &result); err != nil {
+		t.Fatal(err)
+	}
+	for _, want := range []string{"INTEGER", "VARCHAR", "NUMERIC", "INT"} {
+		if !contains(result, want) {
+			t.Fatalf("expected data type %q in %v", want, result)
+		}
+	}
+}
+
+func TestEmptyResultSlicesMarshalAsArrays(t *testing.T) {
+	data, err := json.Marshal(queryResult{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(data)
+	if strings.Contains(text, `"columns":null`) || strings.Contains(text, `"column_types":null`) || strings.Contains(text, `"rows":null`) {
+		t.Fatalf("query result should marshal nil slices as arrays: %s", text)
+	}
+
+	data, err = json.Marshal(indexInfo{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	text = string(data)
+	if strings.Contains(text, `"columns":null`) || strings.Contains(text, `"included_columns":null`) {
+		t.Fatalf("index info should marshal nil slices as arrays: %s", text)
+	}
+}
+
+func TestGetTableDDLResultMarshalsAsString(t *testing.T) {
+	data, err := json.Marshal("CREATE TABLE SYSDBA.ORDERS (ID INT)")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var ddl string
+	if err := json.Unmarshal(data, &ddl); err != nil {
+		t.Fatalf("get_table_ddl result must deserialize as a string: %v", err)
+	}
+}
+
+func TestBuildDSNUsesConnectionStringWhenProvided(t *testing.T) {
+	dsn := buildDSN(connectParams{ConnectionString: "IP=db.example.com;DB=SYSTEM;User=SYSDBA;PWD=secret;Port=5138"})
+
+	if dsn != "IP=db.example.com;DB=SYSTEM;User=SYSDBA;PWD=secret;Port=5138" {
+		t.Fatalf("unexpected dsn: %s", dsn)
+	}
+}
+
+func protocolContract(t *testing.T) struct {
+	ProtocolVersion int      `json:"protocolVersion"`
+	AllCapabilities []string `json:"allCapabilities"`
+} {
+	t.Helper()
+	data, err := os.ReadFile("../../common/src/main/resources/agent-protocol-v1.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var contract struct {
+		ProtocolVersion int      `json:"protocolVersion"`
+		AllCapabilities []string `json:"allCapabilities"`
+	}
+	if err := json.Unmarshal(data, &contract); err != nil {
+		t.Fatal(err)
+	}
+	return contract
+}
+
+func TestBuildDSNUsesConnectionFields(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Host:     "db.example.com",
+		Port:     15138,
+		Database: "demo",
+		Username: "sysdba",
+		Password: "secret",
+	})
+
+	for _, part := range []string{"IP=db.example.com", "DB=demo", "User=sysdba", "PWD=secret", "Port=15138"} {
+		if !strings.Contains(dsn, part) {
+			t.Fatalf("dsn should contain %s, got: %s", part, dsn)
+		}
+	}
+}
+
+func TestBuildDSNUsesDefaultPort(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Host:     "db.example.com",
+		Database: "demo",
+		Username: "sysdba",
+		Password: "secret",
+	})
+
+	if !strings.Contains(dsn, "Port=5138") {
+		t.Fatalf("dsn should default to Xugu port, got: %s", dsn)
+	}
+}
+
+func TestBuildDSNParsesJdbcURL(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Username:         "sysdba",
+		Password:         "secret",
+		ConnectionString: "jdbc:xugu://db.example.com:15138/demo",
+	})
+
+	for _, part := range []string{"IP=db.example.com", "DB=demo", "User=sysdba", "PWD=secret", "Port=15138"} {
+		if !strings.Contains(dsn, part) {
+			t.Fatalf("dsn should contain %s, got: %s", part, dsn)
+		}
+	}
+}
+
+func TestBuildDSNParsesDBXURL(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		ConnectionString: "xugu://sysdba:secret@db.example.com:15138/demo",
+	})
+
+	for _, part := range []string{"IP=db.example.com", "DB=demo", "User=sysdba", "PWD=secret", "Port=15138"} {
+		if !strings.Contains(dsn, part) {
+			t.Fatalf("dsn should contain %s, got: %s", part, dsn)
+		}
+	}
+}
+
+func TestBuildDSNAppendsURLParams(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Host:      "db.example.com",
+		Database:  "demo",
+		Username:  "sysdba",
+		Password:  "secret",
+		URLParams: "AUTO_COMMIT=on;CHAR_SET=UTF8",
+	})
+
+	for _, part := range []string{"AUTO_COMMIT=on", "CHAR_SET=UTF8"} {
+		if !strings.Contains(dsn, part) {
+			t.Fatalf("dsn should contain %s, got: %s", part, dsn)
+		}
+	}
+}
+
+func TestBuildDSNDefaultsToUTF8(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Host:     "db.example.com",
+		Database: "demo",
+		Username: "sysdba",
+		Password: "secret",
+	})
+
+	if !strings.Contains(dsn, "CHAR_SET=UTF8") {
+		t.Fatalf("dsn should default to UTF8, got: %s", dsn)
+	}
+}
+
+func TestBuildDSNRespectsExplicitCharset(t *testing.T) {
+	dsn := buildDSN(connectParams{
+		Host:      "db.example.com",
+		Database:  "demo",
+		Username:  "sysdba",
+		Password:  "secret",
+		URLParams: "CHAR_SET=GBK",
+	})
+
+	if strings.Contains(dsn, "CHAR_SET=UTF8") || !strings.Contains(dsn, "CHAR_SET=GBK") {
+		t.Fatalf("dsn should respect explicit charset, got: %s", dsn)
+	}
+}
+
+func TestListDatabasesSQLUsesXuguDictionary(t *testing.T) {
+	sqlText := strings.ToUpper(xuguListDatabasesSQL)
+
+	if !strings.Contains(sqlText, "ALL_DATABASES") || strings.Contains(sqlText, "SYS_DATABASES") {
+		t.Fatalf("database listing should query low-privilege ALL_DATABASES, got: %s", xuguListDatabasesSQL)
+	}
+}
+
+func TestFallbackDatabasesFromParams(t *testing.T) {
+	cases := []struct {
+		name   string
+		params connectParams
+		want   string
+	}{
+		{
+			name: "database field",
+			params: connectParams{
+				Database: "LOWPRIV",
+			},
+			want: "LOWPRIV",
+		},
+		{
+			name: "dbx url",
+			params: connectParams{
+				ConnectionString: "xugu://user:secret@db.example.com:5138/demo",
+			},
+			want: "demo",
+		},
+		{
+			name: "jdbc url",
+			params: connectParams{
+				ConnectionString: "jdbc:xugu://db.example.com:5138/reporting",
+			},
+			want: "reporting",
+		},
+		{
+			name: "native dsn",
+			params: connectParams{
+				ConnectionString: "IP=db.example.com;DB=SYSTEM;User=SYSDBA;PWD=secret;Port=5138",
+			},
+			want: "SYSTEM",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := fallbackDatabasesFromParams(tc.params)
+			if len(got) != 1 || got[0].Name != tc.want {
+				t.Fatalf("unexpected fallback databases: got=%v want=%s", got, tc.want)
+			}
+		})
+	}
+}
+
+func TestUseDatabaseSkipsConfiguredDatabase(t *testing.T) {
+	s := newServer()
+	s.params = connectParams{Database: "SYSTEM"}
+
+	if err := s.useDatabase("system"); err != nil {
+		t.Fatalf("expected configured database USE to be skipped, got: %v", err)
+	}
+}
+
+func TestConfiguredDatabaseName(t *testing.T) {
+	cases := []struct {
+		params connectParams
+		want   string
+	}{
+		{params: connectParams{Database: "SYSTEM"}, want: "SYSTEM"},
+		{params: connectParams{ConnectionString: "xugu://user:secret@db.example.com:5138/demo"}, want: "demo"},
+		{params: connectParams{ConnectionString: "jdbc:xugu://db.example.com:5138/reporting"}, want: "reporting"},
+		{params: connectParams{ConnectionString: "IP=db.example.com;DB=SYSTEM;User=SYSDBA;PWD=secret"}, want: "SYSTEM"},
+	}
+
+	for _, tc := range cases {
+		if got := configuredDatabaseName(tc.params); got != tc.want {
+			t.Fatalf("configuredDatabaseName(%+v) = %q, want %q", tc.params, got, tc.want)
+		}
+	}
+}
+
+func TestSchemaListingSQLUsesLowPrivilegeDictionary(t *testing.T) {
+	sqlText := strings.ToUpper(xuguListSchemasSQL)
+
+	if !strings.Contains(sqlText, "ALL_SCHEMAS") || strings.Contains(sqlText, "SYS_SCHEMAS") {
+		t.Fatalf("schema listing should query low-privilege ALL_SCHEMAS, got: %s", xuguListSchemasSQL)
+	}
+}
+
+func TestPrimaryKeySQLUsesLowPrivilegeDictionary(t *testing.T) {
+	sqlText := strings.ToUpper(xuguPrimaryKeyColumnsSQL)
+
+	for _, want := range []string{"ALL_CONSTRAINTS", "ALL_TABLES", "ALL_SCHEMAS"} {
+		if !strings.Contains(sqlText, want) {
+			t.Fatalf("primary key listing should query %s, got: %s", want, xuguPrimaryKeyColumnsSQL)
+		}
+	}
+	for _, forbidden := range []string{"SYS_CONSTRAINTS", "SYS_TABLES", "SYS_SCHEMAS"} {
+		if strings.Contains(sqlText, forbidden) {
+			t.Fatalf("primary key listing should not query %s, got: %s", forbidden, xuguPrimaryKeyColumnsSQL)
+		}
+	}
+}
+
+func TestColumnSQLUsesLowPrivilegeDictionary(t *testing.T) {
+	sqlText := strings.ToUpper(xuguListColumnsSQL)
+
+	for _, want := range []string{"ALL_COLUMNS", "ALL_TABLES", "ALL_SCHEMAS", "COMMENTS", `"VARYING"`} {
+		if !strings.Contains(sqlText, want) {
+			t.Fatalf("column listing should query %s, got: %s", want, xuguListColumnsSQL)
+		}
+	}
+	for _, forbidden := range []string{"SYS_COLUMNS", "SYS_TABLES", "SYS_SCHEMAS"} {
+		if strings.Contains(sqlText, forbidden) {
+			t.Fatalf("column listing should not query %s, got: %s", forbidden, xuguListColumnsSQL)
+		}
+	}
+}
+
+func TestIndexSQLUsesLowPrivilegeDictionary(t *testing.T) {
+	sqlText := strings.ToUpper(xuguListIndexesSQL)
+
+	for _, want := range []string{"ALL_INDEXES", "ALL_TABLES", "ALL_SCHEMAS", "KEYS"} {
+		if !strings.Contains(sqlText, want) {
+			t.Fatalf("index listing should query %s, got: %s", want, xuguListIndexesSQL)
+		}
+	}
+	for _, forbidden := range []string{"SYS_INDEXES", "SYS_TABLES", "SYS_SCHEMAS"} {
+		if strings.Contains(sqlText, forbidden) {
+			t.Fatalf("index listing should not query %s, got: %s", forbidden, xuguListIndexesSQL)
+		}
+	}
+}
+
+func TestXuguMetadataAccessErrorDetection(t *testing.T) {
+	if !isXuguMetadataAccessError(errors.New("[E18012] 权限不够")) {
+		t.Fatal("expected E18012 permission error to be treated as metadata access error")
+	}
+	if isXuguMetadataAccessError(errors.New("network timeout")) {
+		t.Fatal("network errors should not trigger database-list fallback")
+	}
+}
+
+func TestXuguListTablesQueryAppliesMetadataConstraints(t *testing.T) {
+	query := xuguListTablesQuery("APP", metadataListConstraints{
+		Filter:      "ord_",
+		ObjectTypes: []string{"view", "table", "VIEW"},
+		Limit:       25,
+		Offset:      50,
+	})
+
+	for _, want := range []string{
+		"UPPER(TABLE_NAME) LIKE ? ESCAPE '\\'",
+		"TABLE_TYPE IN (?,?)",
+		"ORDER BY TABLE_TYPE, TABLE_NAME",
+		"ROWNUM <= ?",
+		"DBX_RN > ?",
+	} {
+		if !strings.Contains(query.SQL, want) {
+			t.Fatalf("expected SQL to contain %q:\n%s", want, query.SQL)
+		}
+	}
+
+	wantArgs := []any{"APP", "APP", `%O%R%D%\_%`, "TABLE", "VIEW", 75, 50}
+	assertArgs(t, query.Args, wantArgs)
+}
+
+func TestXuguListObjectsQueryRejectsUnsupportedObjectTypes(t *testing.T) {
+	query := xuguListObjectsQuery("APP", metadataListConstraints{
+		ObjectTypes: []string{"INDEX"},
+		Limit:       10,
+	})
+
+	if !strings.Contains(query.SQL, "1 = 0") {
+		t.Fatalf("unsupported object type should produce empty-result predicate:\n%s", query.SQL)
+	}
+
+	wantArgs := []any{"APP", "APP", 10, 0}
+	assertArgs(t, query.Args, wantArgs)
+}
+
+func TestMetadataListConstraintsFromParams(t *testing.T) {
+	params := map[string]json.RawMessage{
+		"filter":       json.RawMessage(`"tab"`),
+		"limit":        json.RawMessage(`30`),
+		"offset":       json.RawMessage(`5`),
+		"object_types": json.RawMessage(`["TABLE","VIEW"]`),
+	}
+
+	constraints := metadataListConstraintsFromParams(params)
+	if constraints.Filter != "tab" || constraints.Limit != 30 || constraints.Offset != 5 {
+		t.Fatalf("unexpected constraints: %+v", constraints)
+	}
+	if len(constraints.ObjectTypes) != 2 || constraints.ObjectTypes[0] != "TABLE" || constraints.ObjectTypes[1] != "VIEW" {
+		t.Fatalf("unexpected object types: %+v", constraints.ObjectTypes)
+	}
+}
+
+func assertArgs(t *testing.T, got []any, want []any) {
+	t.Helper()
+	if len(got) != len(want) {
+		t.Fatalf("args length = %d, want %d: got=%#v want=%#v", len(got), len(want), got, want)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("arg %d = %#v, want %#v; args=%#v", i, got[i], want[i], got)
+		}
+	}
+}
+
+func TestParseForeignKeyColumns(t *testing.T) {
+	local, ref := parseForeignKeyColumns(`("C1","C2")("ID1","ID2")`)
+
+	if strings.Join(local, ",") != "C1,C2" || strings.Join(ref, ",") != "ID1,ID2" {
+		t.Fatalf("unexpected foreign key columns: local=%v ref=%v", local, ref)
+	}
+}
+
+func TestDecodeXuguScale(t *testing.T) {
+	numericScale := 32*65536 + 6
+	precision, scale, length := decodeXuguScale("NUMERIC", &numericScale)
+	if precision == nil || *precision != 32 || scale == nil || *scale != 6 || length != nil {
+		t.Fatalf("unexpected numeric scale decode: precision=%v scale=%v length=%v", precision, scale, length)
+	}
+
+	charScale := 128
+	precision, scale, length = decodeXuguScale("VARCHAR", &charScale)
+	if precision != nil || scale != nil || length == nil || *length != 128 {
+		t.Fatalf("unexpected char scale decode: precision=%v scale=%v length=%v", precision, scale, length)
+	}
+}
+
+func TestNormalizeXuguColumnTypeUsesVaryingFlag(t *testing.T) {
+	tests := []struct {
+		name     string
+		dataType string
+		varying  any
+		want     string
+	}{
+		{name: "varying char", dataType: "CHAR", varying: true, want: "VARCHAR"},
+		{name: "fixed char", dataType: "CHAR", varying: false, want: "CHAR"},
+		{name: "varying binary", dataType: "BINARY", varying: true, want: "VARBINARY"},
+		{name: "fixed binary", dataType: "BINARY", varying: false, want: "BINARY"},
+		{name: "other varying type", dataType: "NUMERIC", varying: true, want: "NUMERIC"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := normalizeXuguColumnType(tt.dataType, tt.varying); got != tt.want {
+				t.Fatalf("normalizeXuguColumnType(%q, %v) = %q, want %q", tt.dataType, tt.varying, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestAppendDDLStatement(t *testing.T) {
+	got := appendDDLStatement("CREATE TABLE \"T\" (\"ID\" INT)\n", "CREATE INDEX \"IDX\" ON \"T\"(\"ID\");")
+	want := "CREATE TABLE \"T\" (\"ID\" INT);\n\nCREATE INDEX \"IDX\" ON \"T\"(\"ID\");"
+
+	if got != want {
+		t.Fatalf("unexpected DDL append:\ngot:  %q\nwant: %q", got, want)
+	}
+}
+
+func TestQuoteStringLiteralEscapesSingleQuotes(t *testing.T) {
+	if got := quoteStringLiteral("owner's note"); got != "'owner''s note'" {
+		t.Fatalf("unexpected quoted string: %s", got)
+	}
+}
+
+func TestNormalizeValuePreservesDriverNumericTypes(t *testing.T) {
+	if value := normalizeValue(int32(7)); value != int64(7) {
+		t.Fatalf("expected int32 to normalize to int64, got %#v", value)
+	}
+	if value := normalizeValue(float32(1.25)); value != float64(float32(1.25)) {
+		t.Fatalf("expected float32 to normalize to float64, got %#v", value)
+	}
+}
+
+func contains(values []string, target string) bool {
+	for _, value := range values {
+		if value == target {
+			return true
+		}
+	}
+	return false
+}
diff --git a/agents/drivers/yashandb/build.gradle b/agents/drivers/yashandb/build.gradle
new file mode 100644
index 0000000..5a80412
--- /dev/null
+++ b/agents/drivers/yashandb/build.gradle
@@ -0,0 +1,9 @@
+dependencies {
+    implementation 'com.yashandb:yashandb-jdbc:1.9.27'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': '崖山 YashanDB', 'Main-Class': 'com.dbx.agent.yashandb.YashandbAgent')
+    }
+}
diff --git a/agents/drivers/yashandb/src/main/java/com/dbx/agent/yashandb/YashandbAgent.java b/agents/drivers/yashandb/src/main/java/com/dbx/agent/yashandb/YashandbAgent.java
new file mode 100644
index 0000000..cf11cc0
--- /dev/null
+++ b/agents/drivers/yashandb/src/main/java/com/dbx/agent/yashandb/YashandbAgent.java
@@ -0,0 +1,22 @@
+package com.dbx.agent.yashandb;
+
+import com.dbx.agent.ConfiguredJdbcAgent;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.JsonRpcServer;
+
+public final class YashandbAgent extends ConfiguredJdbcAgent {
+    public static final JdbcAgentProfile YASHANDB_PROFILE = new JdbcAgentProfile(
+        "com.yashandb.jdbc.Driver",
+        "jdbc:yasdb://{host}:{port}/{database}",
+        1688,
+        true
+    );
+
+    public YashandbAgent() {
+        super(YASHANDB_PROFILE);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new YashandbAgent()).run();
+    }
+}
diff --git a/agents/drivers/yashandb/src/test/java/com/dbx/agent/yashandb/YashandbAgentTest.java b/agents/drivers/yashandb/src/test/java/com/dbx/agent/yashandb/YashandbAgentTest.java
new file mode 100644
index 0000000..0ae5c64
--- /dev/null
+++ b/agents/drivers/yashandb/src/test/java/com/dbx/agent/yashandb/YashandbAgentTest.java
@@ -0,0 +1,30 @@
+package com.dbx.agent.yashandb;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.JdbcAgentProfile;
+import com.dbx.agent.test.JdbcFakeExecutionBehaviorTest;
+import java.util.Collections;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class YashandbAgentTest extends JdbcFakeExecutionBehaviorTest {
+    @Override
+    protected DatabaseAgent createAgent() {
+        return new YashandbAgent();
+    }
+
+    @Override
+    protected String resultSetSql() {
+        return "SELECT 1 FROM DUAL";
+    }
+
+    @Test
+    void declaresYashandbJdbcProfile() {
+        JdbcAgentProfile profile = YashandbAgent.YASHANDB_PROFILE;
+
+        Assertions.assertEquals("com.yashandb.jdbc.Driver", profile.getDriverClass());
+        Assertions.assertEquals("jdbc:yasdb://{host}:{port}/{database}", profile.getUrlTemplate());
+        Assertions.assertTrue(profile.getSkipExecutionContext());
+        Assertions.assertEquals(Collections.emptySet(), profile.getExcludedSchemas());
+    }
+}
diff --git a/agents/drivers/zookeeper/build.gradle b/agents/drivers/zookeeper/build.gradle
new file mode 100644
index 0000000..f679c11
--- /dev/null
+++ b/agents/drivers/zookeeper/build.gradle
@@ -0,0 +1,13 @@
+dependencies {
+    implementation 'com.google.code.gson:gson:2.12.1'
+    implementation 'org.apache.curator:curator-framework:5.9.0'
+    runtimeOnly 'org.slf4j:slf4j-simple:1.7.36'
+    testImplementation 'org.apache.curator:curator-test:5.9.0'
+}
+
+tasks.named('shadowJar') {
+    mergeServiceFiles()
+    manifest {
+        attributes('Agent-Label': 'Apache ZooKeeper', 'Main-Class': 'com.dbx.agent.zookeeper.ZooKeeperAgent')
+    }
+}
diff --git a/agents/drivers/zookeeper/src/main/java/com/dbx/agent/zookeeper/ZooKeeperAgent.java b/agents/drivers/zookeeper/src/main/java/com/dbx/agent/zookeeper/ZooKeeperAgent.java
new file mode 100644
index 0000000..72b4329
--- /dev/null
+++ b/agents/drivers/zookeeper/src/main/java/com/dbx/agent/zookeeper/ZooKeeperAgent.java
@@ -0,0 +1,664 @@
+package com.dbx.agent.zookeeper;
+
+import com.dbx.agent.AgentProtocol;
+import com.google.gson.*;
+import org.apache.curator.framework.CuratorFramework;
+import org.apache.curator.framework.CuratorFrameworkFactory;
+import org.apache.curator.retry.ExponentialBackoffRetry;
+import org.apache.zookeeper.CreateMode;
+import org.apache.zookeeper.KeeperException;
+import org.apache.zookeeper.data.Stat;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.nio.ByteBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CodingErrorAction;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public final class ZooKeeperAgent {
+    private static final Gson GSON = new GsonBuilder().serializeNulls().create();
+    private static final int DEFAULT_LIMIT = 100;
+    private static final int DEFAULT_SESSION_TIMEOUT_MS = 30000;
+    private static final int DEFAULT_CONNECTION_TIMEOUT_MS = 15000;
+    private static final int DEFAULT_BASE_SLEEP_TIME_MS = 1000;
+    private static final int DEFAULT_MAX_RETRIES = 3;
+    private static final String STAT_LOOKUP_CONCURRENCY_PROPERTY = "dbx.zookeeper.statLookupConcurrency";
+    private static final String STAT_LOOKUP_CONCURRENCY_ENV = "DBX_ZOOKEEPER_STAT_LOOKUP_CONCURRENCY";
+    private static final int DEFAULT_STAT_LOOKUP_CONCURRENCY = 16;
+    private static final int MIN_STAT_LOOKUP_CONCURRENCY = 1;
+    private static final int MAX_STAT_LOOKUP_CONCURRENCY = 64;
+    private static final int STAT_LOOKUP_CONCURRENCY = configuredStatLookupConcurrency();
+    private static final ExecutorService STAT_LOOKUP_EXECUTOR = Executors.newFixedThreadPool(
+        STAT_LOOKUP_CONCURRENCY,
+        daemonThreadFactory("dbx-zookeeper-stat-lookup-")
+    );
+    private static final List<String> CAPABILITIES = Collections.unmodifiableList(Arrays.asList(
+        AgentProtocol.CAPABILITY_CONNECT,
+        AgentProtocol.CAPABILITY_TEST_CONNECTION,
+        AgentProtocol.CAPABILITY_KV
+    ));
+    private static CuratorFramework client;
+
+    private ZooKeeperAgent() {
+    }
+
+    private static Object handshakeResult() {
+        return new HandshakeResult(AgentProtocol.PROTOCOL_VERSION, AgentProtocol.PROTOCOL_VERSION, CAPABILITIES);
+    }
+
+    private static Object connect(JsonObject params) throws Exception {
+        JsonObject connection = connectionObject(params);
+        CuratorFramework nextClient = buildClient(connection);
+        try {
+            startAndVerify(nextClient, connection);
+            closeClient();
+            client = nextClient;
+            return Collections.singletonMap("ok", true);
+        } catch (Exception e) {
+            nextClient.close();
+            throw e;
+        }
+    }
+
+    private static Object testConnection(JsonObject params) throws Exception {
+        JsonObject connection = connectionObject(params);
+        CuratorFramework probe = buildClient(connection);
+        try {
+            startAndVerify(probe, connection);
+            return Collections.singletonMap("ok", true);
+        } finally {
+            probe.close();
+        }
+    }
+
+    static CuratorFramework buildClient(JsonObject connection) {
+        if (hasTlsOptions(connection)) {
+            throw new IllegalArgumentException("ZooKeeper TLS is not supported");
+        }
+
+        int baseSleepTimeMs = intOrDefault(connection, "base_sleep_time_ms", DEFAULT_BASE_SLEEP_TIME_MS);
+        int maxRetries = intOrDefault(connection, "max_retries", DEFAULT_MAX_RETRIES);
+        CuratorFrameworkFactory.Builder builder = CuratorFrameworkFactory.builder()
+            .connectString(connectString(connection))
+            .sessionTimeoutMs(intOrDefault(connection, "session_timeout_ms", DEFAULT_SESSION_TIMEOUT_MS))
+            .connectionTimeoutMs(intOrDefault(connection, "connection_timeout_ms", DEFAULT_CONNECTION_TIMEOUT_MS))
+            .retryPolicy(new ExponentialBackoffRetry(baseSleepTimeMs, maxRetries));
+
+        String namespace = trimSlashes(stringOrEmpty(connection, "namespace"));
+        if (!namespace.isBlank()) {
+            builder.namespace(namespace);
+        }
+
+        String username = stringOrEmpty(connection, "username");
+        String password = stringOrEmpty(connection, "password");
+        if (!username.isBlank()) {
+            builder.authorization("digest", (username + ":" + password).getBytes(StandardCharsets.UTF_8));
+        }
+
+        return builder.build();
+    }
+
+    static String connectString(JsonObject connection) {
+        String configured = firstNonBlank(
+            stringOrNull(connection, "zookeeper_connect_string"),
+            stringOrNull(connection, "connect_string"),
+            stringOrNull(connection, "connection_string")
+        );
+        if (configured != null) {
+            return configured;
+        }
+        return stringOrDefault(connection, "host", "127.0.0.1") + ":"
+            + intOrDefault(connection, "port", 2181);
+    }
+
+    private static void startAndVerify(CuratorFramework active, JsonObject connection) throws Exception {
+        active.start();
+        int timeoutMs = intOrDefault(connection, "connection_timeout_ms", DEFAULT_CONNECTION_TIMEOUT_MS);
+        if (!active.blockUntilConnected(timeoutMs, TimeUnit.MILLISECONDS)) {
+            throw new IllegalStateException("Connection timed out");
+        }
+        if (active.checkExists().forPath("/") == null) {
+            throw new IllegalStateException("Root znode is not readable");
+        }
+    }
+
+    private static Object listPrefix(JsonObject params) throws Exception {
+        CuratorFramework active = requireClient();
+        String root = normalizePath(stringOrDefault(params, "prefix", "/"));
+        boolean recursive = boolOrDefault(params, "recursive", true);
+        int limit = Math.max(1, intOrDefault(params, "limit", DEFAULT_LIMIT));
+        Cursor cursor = null;
+        String continuation = stringOrNull(params, "continuation");
+        if (continuation != null && !continuation.isBlank()) {
+            cursor = decodeCursor(continuation);
+            if (!root.equals(cursor.root) || recursive != cursor.recursive) {
+                throw new IllegalArgumentException("Continuation does not match request");
+            }
+        }
+
+        Map<String, Object> result = new LinkedHashMap<>();
+        List<Map<String, Object>> keys = new ArrayList<>();
+        Stat rootStat = active.checkExists().forPath(root);
+        if (rootStat == null) {
+            result.put("keys", keys);
+            result.put("continuation", null);
+            return result;
+        }
+
+        List<String> paths = recursive ? listRecursive(active, root) : listDirectChildren(active, root);
+        Collections.sort(paths);
+        int offset = cursor == null ? 0 : Math.max(0, cursor.offset);
+        int end = Math.min(paths.size(), offset + limit);
+        keys.addAll(listRowsWithMetadata(active, paths.subList(offset, end)));
+
+        result.put("keys", keys);
+        result.put("continuation", end < paths.size() ? encodeCursor(new Cursor(root, recursive, end)) : null);
+        return result;
+    }
+
+    private static Object get(JsonObject params) throws Exception {
+        CuratorFramework active = requireClient();
+        String path = normalizePath(stringOrDefault(params, "key", ""));
+        Map<String, Object> result = new LinkedHashMap<>();
+        Stat exists = active.checkExists().forPath(path);
+        if (exists == null) {
+            result.put("found", false);
+            result.put("key", path);
+            result.put("value", null);
+            result.put("metadata", null);
+            return result;
+        }
+
+        Stat stat = new Stat();
+        byte[] bytes = active.getData().storingStatIn(stat).forPath(path);
+        result.put("found", true);
+        result.put("key", path);
+        result.put("value", valueObject(bytes));
+        result.put("metadata", statMetadata(stat));
+        return result;
+    }
+
+    private static Object put(JsonObject params) throws Exception {
+        CuratorFramework active = requireClient();
+        String path = normalizePath(stringOrDefault(params, "key", ""));
+        requireMutablePath(path, "modified");
+        byte[] bytes = parseValue(params.getAsJsonObject("value"));
+
+        String writeMode = stringOrDefault(params, "writeMode", "upsert");
+        return switch (writeMode) {
+            case "create" -> create(active, path, bytes, createMode(params));
+            case "update" -> update(active, path, bytes);
+            case "upsert" -> upsert(active, path, bytes);
+            default -> throw new IllegalArgumentException("Unsupported writeMode: " + writeMode);
+        };
+    }
+
+    private static Object upsert(CuratorFramework active, String path, byte[] bytes) throws Exception {
+        Stat stat = active.checkExists().forPath(path);
+        if (stat == null) {
+            active.create().creatingParentsIfNeeded().forPath(path, bytes);
+            stat = active.checkExists().forPath(path);
+        } else {
+            stat = active.setData().forPath(path, bytes);
+        }
+        return putResult(stat);
+    }
+
+    private static Object create(CuratorFramework active, String path, byte[] bytes, CreateMode createMode) throws Exception {
+        String createdPath = active.create()
+            .creatingParentsIfNeeded()
+            .withMode(createMode)
+            .forPath(path, bytes);
+        Stat stat = active.checkExists().forPath(createdPath);
+        Map<String, Object> result = putResult(stat);
+        result.put("key", createdPath);
+        result.put("createdKey", createdPath);
+        return result;
+    }
+
+    private static Object update(CuratorFramework active, String path, byte[] bytes) throws Exception {
+        return putResult(active.setData().forPath(path, bytes));
+    }
+
+    private static Map<String, Object> putResult(Stat stat) {
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("version", stat.getVersion());
+        result.put("mtime", stat.getMtime());
+        return result;
+    }
+
+    private static CreateMode createMode(JsonObject params) {
+        String createMode = stringOrDefault(params, "createMode", "persistent");
+        return switch (createMode) {
+            case "persistent" -> CreateMode.PERSISTENT;
+            case "ephemeral" -> CreateMode.EPHEMERAL;
+            case "persistent_sequential" -> CreateMode.PERSISTENT_SEQUENTIAL;
+            case "ephemeral_sequential" -> CreateMode.EPHEMERAL_SEQUENTIAL;
+            default -> throw new IllegalArgumentException("Unsupported createMode: " + createMode);
+        };
+    }
+
+    private static Object delete(JsonObject params) throws Exception {
+        CuratorFramework active = requireClient();
+        String path = normalizePath(stringOrDefault(params, "key", ""));
+        requireMutablePath(path, "deleted");
+        boolean recursive = boolOrDefault(params, "recursive", false);
+        int deleted;
+        try {
+            if (active.checkExists().forPath(path) == null) {
+                deleted = 0;
+            } else if (recursive) {
+                deleted = countSubtree(active, path);
+                active.delete().deletingChildrenIfNeeded().forPath(path);
+            } else {
+                active.delete().forPath(path);
+                deleted = 1;
+            }
+        } catch (KeeperException.NoNodeException e) {
+            deleted = 0;
+        }
+        return Collections.singletonMap("deleted", deleted);
+    }
+
+    private static Object dispatch(String method, JsonObject params) throws Exception {
+        return switch (method) {
+            case AgentProtocol.METHOD_HANDSHAKE -> handshakeResult();
+            case AgentProtocol.METHOD_CONNECT -> connect(params);
+            case AgentProtocol.METHOD_TEST_CONNECTION -> testConnection(params);
+            case AgentProtocol.KV_METHOD_LIST_PREFIX -> listPrefix(params);
+            case AgentProtocol.KV_METHOD_GET -> get(params);
+            case AgentProtocol.KV_METHOD_PUT -> put(params);
+            case AgentProtocol.KV_METHOD_DELETE -> delete(params);
+            case AgentProtocol.METHOD_DISCONNECT -> {
+                closeClient();
+                yield Collections.singletonMap("ok", true);
+            }
+            case AgentProtocol.METHOD_SHUTDOWN -> {
+                closeClient();
+                STAT_LOOKUP_EXECUTOR.shutdownNow();
+                System.exit(0);
+                yield Collections.singletonMap("ok", true);
+            }
+            default -> throw new IllegalArgumentException("Unknown method: " + method);
+        };
+    }
+
+    static String handleRequest(String line) {
+        JsonObject req = JsonParser.parseString(line).getAsJsonObject();
+        JsonElement id = req.get("id");
+        String method = req.get("method").getAsString();
+        JsonObject params = req.has("params") && req.get("params").isJsonObject()
+            ? req.getAsJsonObject("params")
+            : new JsonObject();
+
+        JsonObject response = new JsonObject();
+        response.addProperty("jsonrpc", "2.0");
+        response.add("id", id);
+
+        try {
+            Object result = dispatch(method, params);
+            response.add("result", GSON.toJsonTree(result));
+        } catch (Exception e) {
+            JsonObject error = new JsonObject();
+            error.addProperty("code", -1);
+            error.addProperty("message", e.getMessage() == null ? "Unknown error" : e.getMessage());
+            response.add("error", error);
+        }
+
+        return GSON.toJson(response);
+    }
+
+    private static JsonObject connectionObject(JsonObject params) {
+        JsonElement connection = params.get("connection");
+        return connection != null && connection.isJsonObject() ? connection.getAsJsonObject() : params;
+    }
+
+    private static CuratorFramework requireClient() {
+        if (client == null) {
+            throw new IllegalStateException("Not connected");
+        }
+        return client;
+    }
+
+    private static void closeClient() {
+        if (client != null) {
+            client.close();
+            client = null;
+        }
+    }
+
+    static String normalizePath(String path) {
+        String normalized = path == null ? "" : path;
+        if (normalized.isEmpty() || "/".equals(normalized)) {
+            return "/";
+        }
+        if (!normalized.startsWith("/")) {
+            normalized = "/" + normalized;
+        }
+        while (normalized.length() > 1 && normalized.endsWith("/")) {
+            normalized = normalized.substring(0, normalized.length() - 1);
+        }
+        return normalized;
+    }
+
+    private static String childPath(String parent, String child) {
+        return "/".equals(parent) ? "/" + child : parent + "/" + child;
+    }
+
+    private static void requireMutablePath(String path, String action) {
+        if ("/".equals(path)) {
+            throw new IllegalArgumentException("Root znode cannot be " + action);
+        }
+    }
+
+    private static Map<String, Object> statMetadata(Stat stat) {
+        Map<String, Object> metadata = new LinkedHashMap<>();
+        long czxid = stat.getCzxid();
+        long mzxid = stat.getMzxid();
+        long pzxid = stat.getPzxid();
+        int dataLength = stat.getDataLength();
+        metadata.put("czxid", czxid);
+        metadata.put("mzxid", mzxid);
+        metadata.put("pzxid", pzxid);
+        metadata.put("ctime", stat.getCtime());
+        metadata.put("mtime", stat.getMtime());
+        metadata.put("version", stat.getVersion());
+        metadata.put("cversion", stat.getCversion());
+        metadata.put("aversion", stat.getAversion());
+        metadata.put("ephemeralOwner", stat.getEphemeralOwner());
+        metadata.put("dataLength", dataLength);
+        metadata.put("numChildren", stat.getNumChildren());
+        metadata.put("createRevision", czxid);
+        metadata.put("modRevision", mzxid);
+        metadata.put("valueSize", dataLength);
+        return metadata;
+    }
+
+    private static Map<String, Object> valueObject(byte[] bytes) {
+        Map<String, Object> value = new LinkedHashMap<>();
+        String utf8 = strictUtf8(bytes);
+        if (utf8 != null) {
+            value.put("encoding", "utf8");
+            value.put("data", utf8);
+        } else {
+            value.put("encoding", "base64");
+            value.put("data", Base64.getEncoder().encodeToString(bytes));
+        }
+        return value;
+    }
+
+    private static byte[] parseValue(JsonObject value) {
+        if (value == null) {
+            return new byte[0];
+        }
+        String encoding = stringOrDefault(value, "encoding", "utf8");
+        String data = stringOrDefault(value, "data", "");
+        if ("base64".equals(encoding)) {
+            return Base64.getDecoder().decode(data);
+        }
+        if (!"utf8".equals(encoding)) {
+            throw new IllegalArgumentException("Unsupported value encoding: " + encoding);
+        }
+        return data.getBytes(StandardCharsets.UTF_8);
+    }
+
+    private static String strictUtf8(byte[] bytes) {
+        CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder()
+            .onMalformedInput(CodingErrorAction.REPORT)
+            .onUnmappableCharacter(CodingErrorAction.REPORT);
+        try {
+            return decoder.decode(ByteBuffer.wrap(bytes)).toString();
+        } catch (CharacterCodingException e) {
+            return null;
+        }
+    }
+
+    private static String encodeCursor(Cursor cursor) {
+        JsonObject object = new JsonObject();
+        object.addProperty("root", cursor.root);
+        object.addProperty("recursive", cursor.recursive);
+        object.addProperty("offset", cursor.offset);
+        return Base64.getEncoder().encodeToString(GSON.toJson(object).getBytes(StandardCharsets.UTF_8));
+    }
+
+    private static Cursor decodeCursor(String continuation) {
+        String json = new String(Base64.getDecoder().decode(continuation), StandardCharsets.UTF_8);
+        JsonObject object = JsonParser.parseString(json).getAsJsonObject();
+        return new Cursor(
+            object.get("root").getAsString(),
+            object.get("recursive").getAsBoolean(),
+            object.get("offset").getAsInt()
+        );
+    }
+
+    private static List<String> listDirectChildren(CuratorFramework active, String root) throws Exception {
+        List<String> paths = new ArrayList<>();
+        List<String> children = new ArrayList<>(active.getChildren().forPath(root));
+        Collections.sort(children);
+        for (String child : children) {
+            paths.add(childPath(root, child));
+        }
+        return paths;
+    }
+
+    private static List<String> listRecursive(CuratorFramework active, String root) throws Exception {
+        List<String> result = new ArrayList<>();
+        collectRecursive(active, root, result);
+        return result;
+    }
+
+    private static List<Map<String, Object>> listRowsWithMetadata(CuratorFramework active, List<String> paths) throws Exception {
+        if (paths.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        try {
+            List<Future<Map<String, Object>>> futures = new ArrayList<>();
+            for (String path : paths) {
+                futures.add(STAT_LOOKUP_EXECUTOR.submit(() -> rowWithMetadata(active, path)));
+            }
+
+            List<Map<String, Object>> rows = new ArrayList<>();
+            for (Future<Map<String, Object>> future : futures) {
+                Map<String, Object> row = future.get();
+                if (row != null) {
+                    rows.add(row);
+                }
+            }
+            return rows;
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw e;
+        } catch (ExecutionException e) {
+            Throwable cause = e.getCause();
+            if (cause instanceof Exception exception) {
+                throw exception;
+            }
+            if (cause instanceof Error error) {
+                throw error;
+            }
+            throw new RuntimeException(cause);
+        }
+    }
+
+    private static Map<String, Object> rowWithMetadata(CuratorFramework active, String path) throws Exception {
+        try {
+            Stat stat = active.checkExists().forPath(path);
+            if (stat == null) {
+                return null;
+            }
+            Map<String, Object> row = new LinkedHashMap<>();
+            row.put("key", path);
+            row.putAll(statMetadata(stat));
+            return row;
+        } catch (KeeperException.NoNodeException e) {
+            return null;
+        }
+    }
+
+    private static void collectRecursive(CuratorFramework active, String path, List<String> result) throws Exception {
+        List<String> children;
+        try {
+            children = new ArrayList<>(active.getChildren().forPath(path));
+        } catch (KeeperException.NoNodeException e) {
+            return;
+        }
+        Collections.sort(children);
+        for (String child : children) {
+            String childPath = childPath(path, child);
+            result.add(childPath);
+            collectRecursive(active, childPath, result);
+        }
+    }
+
+    private static int countSubtree(CuratorFramework active, String path) throws Exception {
+        try {
+            if (active.checkExists().forPath(path) == null) {
+                return 0;
+            }
+            int count = 1;
+            for (String child : active.getChildren().forPath(path)) {
+                count += countSubtree(active, childPath(path, child));
+            }
+            return count;
+        } catch (KeeperException.NoNodeException e) {
+            return 0;
+        }
+    }
+
+    private static boolean hasTlsOptions(JsonObject connection) {
+        return boolOrDefault(connection, "ssl", false)
+            || firstNonBlank(
+                stringOrNull(connection, "ca_cert_path"),
+                stringOrNull(connection, "client_cert_path"),
+                stringOrNull(connection, "client_key_path"),
+                stringOrNull(connection, "cert_path"),
+                stringOrNull(connection, "key_path")
+            ) != null;
+    }
+
+    private static String trimSlashes(String value) {
+        String trimmed = value.trim();
+        while (trimmed.startsWith("/")) {
+            trimmed = trimmed.substring(1);
+        }
+        while (trimmed.endsWith("/")) {
+            trimmed = trimmed.substring(0, trimmed.length() - 1);
+        }
+        return trimmed;
+    }
+
+    private static String stringOrNull(JsonObject object, String key) {
+        JsonElement element = object.get(key);
+        return element == null || element.isJsonNull() ? null : element.getAsString();
+    }
+
+    private static String stringOrEmpty(JsonObject object, String key) {
+        return stringOrDefault(object, key, "");
+    }
+
+    private static String stringOrDefault(JsonObject object, String key, String fallback) {
+        String value = stringOrNull(object, key);
+        return value == null ? fallback : value;
+    }
+
+    private static int intOrDefault(JsonObject object, String key, int fallback) {
+        JsonElement element = object.get(key);
+        return element == null || element.isJsonNull() ? fallback : element.getAsInt();
+    }
+
+    private static boolean boolOrDefault(JsonObject object, String key, boolean fallback) {
+        JsonElement element = object.get(key);
+        return element == null || element.isJsonNull() ? fallback : element.getAsBoolean();
+    }
+
+    static int configuredStatLookupConcurrency(String propertyValue, String envValue) {
+        String configured = firstNonBlank(propertyValue, envValue);
+        if (configured == null) {
+            return DEFAULT_STAT_LOOKUP_CONCURRENCY;
+        }
+        try {
+            int parsed = Integer.parseInt(configured.trim());
+            return Math.max(MIN_STAT_LOOKUP_CONCURRENCY, Math.min(MAX_STAT_LOOKUP_CONCURRENCY, parsed));
+        } catch (NumberFormatException e) {
+            return DEFAULT_STAT_LOOKUP_CONCURRENCY;
+        }
+    }
+
+    private static int configuredStatLookupConcurrency() {
+        return configuredStatLookupConcurrency(
+            System.getProperty(STAT_LOOKUP_CONCURRENCY_PROPERTY),
+            System.getenv(STAT_LOOKUP_CONCURRENCY_ENV)
+        );
+    }
+
+    private static ThreadFactory daemonThreadFactory(String prefix) {
+        AtomicInteger sequence = new AtomicInteger(1);
+        return runnable -> {
+            Thread thread = new Thread(runnable, prefix + sequence.getAndIncrement());
+            thread.setDaemon(true);
+            return thread;
+        };
+    }
+
+    private static String firstNonBlank(String... values) {
+        for (String value : values) {
+            if (value != null && !value.isBlank()) {
+                return value;
+            }
+        }
+        return null;
+    }
+
+    public static void main(String[] args) throws Exception {
+        // Entry point for the standalone DBX agent process.
+        System.setProperty("org.slf4j.simpleLogger.logFile", "System.err");
+        System.out.println("{\"ready\":true}");
+        System.out.flush();
+
+        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+        while (true) {
+            String line = reader.readLine();
+            if (line == null) {
+                break;
+            }
+
+            System.out.println(handleRequest(line));
+            System.out.flush();
+        }
+    }
+
+    private static final class Cursor {
+        private final String root;
+        private final boolean recursive;
+        private final int offset;
+
+        private Cursor(String root, boolean recursive, int offset) {
+            this.root = root;
+            this.recursive = recursive;
+            this.offset = offset;
+        }
+    }
+
+    private static final class HandshakeResult {
+        private final int protocolVersion;
+        private final int agentProtocolVersion;
+        private final List<String> capabilities;
+
+        private HandshakeResult(int protocolVersion, int agentProtocolVersion, List<String> capabilities) {
+            this.protocolVersion = protocolVersion;
+            this.agentProtocolVersion = agentProtocolVersion;
+            this.capabilities = capabilities;
+        }
+    }
+}
diff --git a/agents/drivers/zookeeper/src/test/java/com/dbx/agent/zookeeper/ZooKeeperAgentTest.java b/agents/drivers/zookeeper/src/test/java/com/dbx/agent/zookeeper/ZooKeeperAgentTest.java
new file mode 100644
index 0000000..c50f351
--- /dev/null
+++ b/agents/drivers/zookeeper/src/test/java/com/dbx/agent/zookeeper/ZooKeeperAgentTest.java
@@ -0,0 +1,596 @@
+package com.dbx.agent.zookeeper;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import org.apache.curator.test.TestingServer;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+final class ZooKeeperAgentTest {
+    @AfterEach
+    void disconnect() {
+        ZooKeeperAgent.handleRequest("{\"jsonrpc\":\"2.0\",\"id\":999,\"method\":\"disconnect\",\"params\":{}}");
+    }
+
+    @Test
+    void handshakeAdvertisesKvCapability() {
+        String response = ZooKeeperAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"handshake\",\"params\":{}}"
+        );
+
+        JsonObject result = JsonParser.parseString(response).getAsJsonObject().getAsJsonObject("result");
+
+        Assertions.assertEquals(1, result.get("protocolVersion").getAsInt());
+        Assertions.assertTrue(result.getAsJsonArray("capabilities").contains(JsonParser.parseString("\"kv\"")));
+        Assertions.assertTrue(result.getAsJsonArray("capabilities").contains(JsonParser.parseString("\"connect\"")));
+        Assertions.assertTrue(result.getAsJsonArray("capabilities").contains(JsonParser.parseString("\"test_connection\"")));
+    }
+
+    @Test
+    void kvMethodDispatchReturnsJsonRpcErrorWhenDisconnected() {
+        String response = ZooKeeperAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"kv_get\",\"params\":{\"key\":\"/app/name\"}}"
+        );
+
+        JsonObject error = JsonParser.parseString(response).getAsJsonObject().getAsJsonObject("error");
+
+        Assertions.assertEquals(-1, error.get("code").getAsInt());
+        Assertions.assertEquals("Not connected", error.get("message").getAsString());
+    }
+
+    @Test
+    void unknownMethodReturnsJsonRpcError() {
+        String response = ZooKeeperAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"missing_method\",\"params\":{}}"
+        );
+
+        JsonObject error = JsonParser.parseString(response).getAsJsonObject().getAsJsonObject("error");
+
+        Assertions.assertEquals(-1, error.get("code").getAsInt());
+        Assertions.assertEquals("Unknown method: missing_method", error.get("message").getAsString());
+    }
+
+    @Test
+    void connectStringUsesConfiguredValuesAndHostPortFallback() {
+        Assertions.assertEquals(
+            "zk-1:2181,zk-2:2181",
+            ZooKeeperAgent.connectString(
+                JsonParser.parseString("{\"connect_string\":\"zk-1:2181,zk-2:2181\"}").getAsJsonObject()
+            )
+        );
+        Assertions.assertEquals(
+            "zk-main:2181",
+            ZooKeeperAgent.connectString(
+                JsonParser.parseString("{\"zookeeper_connect_string\":\"zk-main:2181\"}").getAsJsonObject()
+            )
+        );
+        Assertions.assertEquals(
+            "127.0.0.1:2181",
+            ZooKeeperAgent.connectString(JsonParser.parseString("{}").getAsJsonObject())
+        );
+        Assertions.assertEquals(
+            "zk.local:2281",
+            ZooKeeperAgent.connectString(JsonParser.parseString("{\"host\":\"zk.local\",\"port\":2281}").getAsJsonObject())
+        );
+    }
+
+    @Test
+    void buildClientRejectsTlsOptionsUntilTlsIsSupported() {
+        JsonObject connection = JsonParser.parseString(
+            "{\"ssl\":true,\"ca_cert_path\":\"ca.pem\",\"client_cert_path\":\"client.pem\",\"client_key_path\":\"client.key\"}"
+        ).getAsJsonObject();
+
+        IllegalArgumentException error = Assertions.assertThrows(
+            IllegalArgumentException.class,
+            () -> ZooKeeperAgent.buildClient(connection)
+        );
+
+        Assertions.assertEquals("ZooKeeper TLS is not supported", error.getMessage());
+    }
+
+    @Test
+    void normalizePathStandardizesPublicPaths() {
+        Assertions.assertEquals("/", ZooKeeperAgent.normalizePath(""));
+        Assertions.assertEquals("/", ZooKeeperAgent.normalizePath("/"));
+        Assertions.assertEquals("/app", ZooKeeperAgent.normalizePath("app"));
+        Assertions.assertEquals("/app", ZooKeeperAgent.normalizePath("/app/"));
+        Assertions.assertEquals("/app/name", ZooKeeperAgent.normalizePath("/app/name"));
+    }
+
+    @Test
+    void statLookupConcurrencyUsesConservativeDefaultsAndOverrides() {
+        Assertions.assertEquals(16, ZooKeeperAgent.configuredStatLookupConcurrency(null, null));
+        Assertions.assertEquals(20, ZooKeeperAgent.configuredStatLookupConcurrency("20", "12"));
+        Assertions.assertEquals(12, ZooKeeperAgent.configuredStatLookupConcurrency(null, "12"));
+        Assertions.assertEquals(1, ZooKeeperAgent.configuredStatLookupConcurrency("0", null));
+        Assertions.assertEquals(64, ZooKeeperAgent.configuredStatLookupConcurrency("128", null));
+        Assertions.assertEquals(16, ZooKeeperAgent.configuredStatLookupConcurrency("not-a-number", null));
+    }
+
+    @Test
+    void connectAndTestConnectionWorkAgainstTestingServer() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            JsonObject connect = result(request(
+                1,
+                "connect",
+                "{\"connection\":{\"connect_string\":\"" + server.getConnectString() + "\"}}"
+            ));
+            Assertions.assertTrue(connect.get("ok").getAsBoolean());
+
+            JsonObject test = result(request(
+                2,
+                "test_connection",
+                "{\"connection\":{\"connect_string\":\"" + server.getConnectString() + "\"}}"
+            ));
+            Assertions.assertTrue(test.get("ok").getAsBoolean());
+        }
+    }
+
+    @Test
+    void testConnectionDoesNotReplaceActiveClient() throws Exception {
+        try (TestingServer active = new TestingServer(); TestingServer probe = new TestingServer()) {
+            result(request(1, "connect", "{\"connection\":{\"connect_string\":\"" + active.getConnectString() + "\"}}"));
+            result(request(
+                2,
+                "kv_put",
+                "{\"key\":\"/active\",\"value\":{\"encoding\":\"utf8\",\"data\":\"still-here\"}}"
+            ));
+
+            result(request(3, "test_connection", "{\"connection\":{\"connect_string\":\"" + probe.getConnectString() + "\"}}"));
+
+            JsonObject get = result(request(4, "kv_get", "{\"key\":\"/active\"}"));
+            Assertions.assertTrue(get.get("found").getAsBoolean());
+            Assertions.assertEquals("still-here", get.getAsJsonObject("value").get("data").getAsString());
+        }
+    }
+
+    @Test
+    void kvPutCreatesMissingParentsAndGetReadsUtf8Value() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            JsonObject put = result(request(
+                2,
+                "kv_put",
+                "{\"key\":\"/app/name\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx\"}}"
+            ));
+            Assertions.assertTrue(put.has("version"));
+
+            JsonObject get = result(request(3, "kv_get", "{\"key\":\"/app/name\"}"));
+
+            Assertions.assertTrue(get.get("found").getAsBoolean());
+            Assertions.assertEquals("utf8", get.getAsJsonObject("value").get("encoding").getAsString());
+            Assertions.assertEquals("dbx", get.getAsJsonObject("value").get("data").getAsString());
+            JsonObject metadata = get.getAsJsonObject("metadata");
+            Assertions.assertEquals(0, metadata.get("numChildren").getAsInt());
+            Assertions.assertEquals(metadata.get("czxid").getAsLong(), metadata.get("createRevision").getAsLong());
+            Assertions.assertEquals(metadata.get("mzxid").getAsLong(), metadata.get("modRevision").getAsLong());
+            Assertions.assertEquals(metadata.get("dataLength").getAsInt(), metadata.get("valueSize").getAsInt());
+        }
+    }
+
+    @Test
+    void kvPutUpdatesExistingZnode() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            result(request(2, "kv_put", "{\"key\":\"/app/name\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx\"}}"));
+            result(request(
+                3,
+                "kv_put",
+                "{\"key\":\"/app/name\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx-updated\"}}"
+            ));
+
+            JsonObject value = result(request(4, "kv_get", "{\"key\":\"/app/name\"}")).getAsJsonObject("value");
+            Assertions.assertEquals("dbx-updated", value.get("data").getAsString());
+        }
+    }
+
+    @Test
+    void kvPutCreatePersistentCreatesOnlyMissingZnode() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            JsonObject created = result(request(
+                2,
+                "kv_put",
+                "{\"key\":\"/app/created\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx\"},"
+                    + "\"writeMode\":\"create\",\"createMode\":\"persistent\"}"
+            ));
+            JsonObject get = result(request(3, "kv_get", "{\"key\":\"/app/created\"}"));
+            JsonObject duplicate = error(request(
+                4,
+                "kv_put",
+                "{\"key\":\"/app/created\",\"value\":{\"encoding\":\"utf8\",\"data\":\"again\"},"
+                    + "\"writeMode\":\"create\",\"createMode\":\"persistent\"}"
+            ));
+
+            Assertions.assertEquals("/app/created", requiredString(created, "key"));
+            Assertions.assertEquals("/app/created", requiredString(created, "createdKey"));
+            Assertions.assertEquals("dbx", get.getAsJsonObject("value").get("data").getAsString());
+            Assertions.assertTrue(duplicate.get("message").getAsString().contains("NodeExists"));
+        }
+    }
+
+    @Test
+    void kvPutCreateEphemeralCreatesEphemeralZnode() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            JsonObject created = result(request(
+                2,
+                "kv_put",
+                "{\"key\":\"/session/node\",\"value\":{\"encoding\":\"utf8\",\"data\":\"temporary\"},"
+                    + "\"writeMode\":\"create\",\"createMode\":\"ephemeral\"}"
+            ));
+            JsonObject get = result(request(3, "kv_get", "{\"key\":\"/session/node\"}"));
+
+            Assertions.assertEquals("/session/node", requiredString(created, "createdKey"));
+            Assertions.assertEquals("temporary", get.getAsJsonObject("value").get("data").getAsString());
+            Assertions.assertTrue(get.getAsJsonObject("metadata").get("ephemeralOwner").getAsLong() > 0);
+        }
+    }
+
+    @Test
+    void kvPutCreatePersistentSequentialReturnsGeneratedPath() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            JsonObject created = result(request(
+                2,
+                "kv_put",
+                "{\"key\":\"/jobs/job-\",\"value\":{\"encoding\":\"utf8\",\"data\":\"one\"},"
+                    + "\"writeMode\":\"create\",\"createMode\":\"persistent_sequential\"}"
+            ));
+            String createdKey = requiredString(created, "createdKey");
+            JsonObject get = result(request(3, "kv_get", "{\"key\":\"" + createdKey + "\"}"));
+
+            Assertions.assertEquals(createdKey, requiredString(created, "key"));
+            Assertions.assertTrue(createdKey.startsWith("/jobs/job-"));
+            Assertions.assertTrue(createdKey.length() > "/jobs/job-".length());
+            Assertions.assertEquals("one", get.getAsJsonObject("value").get("data").getAsString());
+            Assertions.assertEquals(0, get.getAsJsonObject("metadata").get("ephemeralOwner").getAsLong());
+        }
+    }
+
+    @Test
+    void kvPutCreateEphemeralSequentialReturnsGeneratedEphemeralPath() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            JsonObject created = result(request(
+                2,
+                "kv_put",
+                "{\"key\":\"/sessions/member-\",\"value\":{\"encoding\":\"utf8\",\"data\":\"online\"},"
+                    + "\"writeMode\":\"create\",\"createMode\":\"ephemeral_sequential\"}"
+            ));
+            String createdKey = requiredString(created, "createdKey");
+            JsonObject get = result(request(3, "kv_get", "{\"key\":\"" + createdKey + "\"}"));
+
+            Assertions.assertEquals(createdKey, requiredString(created, "key"));
+            Assertions.assertTrue(createdKey.startsWith("/sessions/member-"));
+            Assertions.assertEquals("online", get.getAsJsonObject("value").get("data").getAsString());
+            Assertions.assertTrue(get.getAsJsonObject("metadata").get("ephemeralOwner").getAsLong() > 0);
+        }
+    }
+
+    @Test
+    void kvPutUpdateOnlyUpdatesExistingZnode() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            JsonObject missing = error(request(
+                2,
+                "kv_put",
+                "{\"key\":\"/app/missing\",\"value\":{\"encoding\":\"utf8\",\"data\":\"x\"},\"writeMode\":\"update\"}"
+            ));
+            result(request(
+                3,
+                "kv_put",
+                "{\"key\":\"/app/name\",\"value\":{\"encoding\":\"utf8\",\"data\":\"before\"},\"writeMode\":\"create\"}"
+            ));
+            JsonObject updated = result(request(
+                4,
+                "kv_put",
+                "{\"key\":\"/app/name\",\"value\":{\"encoding\":\"utf8\",\"data\":\"after\"},\"writeMode\":\"update\"}"
+            ));
+            JsonObject value = result(request(5, "kv_get", "{\"key\":\"/app/name\"}")).getAsJsonObject("value");
+
+            Assertions.assertTrue(missing.get("message").getAsString().contains("NoNode"));
+            Assertions.assertTrue(updated.get("version").getAsInt() > 0);
+            Assertions.assertEquals("after", value.get("data").getAsString());
+        }
+    }
+
+    @Test
+    void kvGetReturnsBase64ForBinaryData() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            result(request(2, "kv_put", "{\"key\":\"/bin\",\"value\":{\"encoding\":\"base64\",\"data\":\"/wAB\"}}"));
+
+            JsonObject value = result(request(3, "kv_get", "{\"key\":\"/bin\"}")).getAsJsonObject("value");
+            Assertions.assertEquals("base64", value.get("encoding").getAsString());
+            Assertions.assertEquals("/wAB", value.get("data").getAsString());
+        }
+    }
+
+    @Test
+    void kvPutRejectsRootZnode() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            JsonObject error = error(request(
+                2,
+                "kv_put",
+                "{\"key\":\"/\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx\"}}"
+            ));
+
+            Assertions.assertEquals("Root znode cannot be modified", error.get("message").getAsString());
+        }
+    }
+
+    @Test
+    void kvDeleteReturnsZeroForMissingZnode() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            JsonObject delete = result(request(4, "kv_delete", "{\"key\":\"/missing\"}"));
+
+            Assertions.assertEquals(0, delete.get("deleted").getAsInt());
+        }
+    }
+
+    @Test
+    void kvDeleteRemovesLeafZnode() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+            result(request(2, "kv_put", "{\"key\":\"/leaf\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx\"}}"));
+
+            JsonObject delete = result(request(3, "kv_delete", "{\"key\":\"/leaf\"}"));
+            JsonObject get = result(request(4, "kv_get", "{\"key\":\"/leaf\"}"));
+
+            Assertions.assertEquals(1, delete.get("deleted").getAsInt());
+            Assertions.assertFalse(get.get("found").getAsBoolean());
+        }
+    }
+
+    @Test
+    void kvDeleteRejectsNonRecursiveDeleteOfNonEmptyZnode() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+            result(request(2, "kv_put", "{\"key\":\"/app/name\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx\"}}"));
+
+            JsonObject error = error(request(3, "kv_delete", "{\"key\":\"/app\"}"));
+
+            Assertions.assertTrue(error.get("message").getAsString().contains("not empty"));
+        }
+    }
+
+    @Test
+    void kvDeleteRecursiveDeletesFullSubtreeAndCountsZnodes() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+            result(request(2, "kv_put", "{\"key\":\"/app/name\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx\"}}"));
+            result(request(3, "kv_put", "{\"key\":\"/app/config\",\"value\":{\"encoding\":\"utf8\",\"data\":\"cfg\"}}"));
+
+            JsonObject delete = result(request(4, "kv_delete", "{\"key\":\"/app\",\"recursive\":true}"));
+            JsonObject get = result(request(5, "kv_get", "{\"key\":\"/app/name\"}"));
+
+            Assertions.assertEquals(3, delete.get("deleted").getAsInt());
+            Assertions.assertFalse(get.get("found").getAsBoolean());
+        }
+    }
+
+    @Test
+    void kvDeleteRejectsRootZnode() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            JsonObject error = error(request(2, "kv_delete", "{\"key\":\"/\",\"recursive\":true}"));
+
+            Assertions.assertEquals("Root znode cannot be deleted", error.get("message").getAsString());
+        }
+    }
+
+    @Test
+    void listPrefixListsDirectChildrenOfRootWhenRecursiveIsFalse() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+            result(request(2, "kv_put", "{\"key\":\"/app/name\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx\"}}"));
+            result(request(3, "kv_put", "{\"key\":\"/config\",\"value\":{\"encoding\":\"utf8\",\"data\":\"cfg\"}}"));
+
+            JsonObject list = result(request(5, "kv_list_prefix", "{\"prefix\":\"/\",\"recursive\":false}"));
+
+            Assertions.assertEquals(List.of("/app", "/config", "/zookeeper"), listedKeys(list));
+            Assertions.assertTrue(list.get("continuation").isJsonNull());
+        }
+    }
+
+    @Test
+    void listPrefixKeepsDirectChildMetadataForLazyExpansion() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+            result(request(2, "kv_put", "{\"key\":\"/app/name\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx\"}}"));
+            result(request(3, "kv_put", "{\"key\":\"/config\",\"value\":{\"encoding\":\"utf8\",\"data\":\"cfg\"}}"));
+
+            JsonObject list = result(request(5, "kv_list_prefix", "{\"prefix\":\"/\",\"recursive\":false}"));
+            JsonObject app = listedRow(list, "/app");
+            JsonObject config = listedRow(list, "/config");
+
+            Assertions.assertEquals(1, app.get("numChildren").getAsInt());
+            Assertions.assertEquals(0, config.get("numChildren").getAsInt());
+            Assertions.assertEquals(3, config.get("dataLength").getAsInt());
+        }
+    }
+
+    @Test
+    void listPrefixDefaultsToRecursiveForDbxKvBrowser() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+            result(request(2, "kv_put", "{\"key\":\"/app/name\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx\"}}"));
+            result(request(3, "kv_put", "{\"key\":\"/config\",\"value\":{\"encoding\":\"utf8\",\"data\":\"cfg\"}}"));
+
+            JsonObject list = result(request(5, "kv_list_prefix", "{\"prefix\":\"/\"}"));
+
+            Assertions.assertEquals(
+                List.of("/app", "/app/name", "/config", "/zookeeper", "/zookeeper/config", "/zookeeper/quota"),
+                listedKeys(list)
+            );
+            Assertions.assertTrue(list.get("continuation").isJsonNull());
+        }
+    }
+
+    @Test
+    void listPrefixListsRecursiveDescendantsOfRoot() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+            result(request(2, "kv_put", "{\"key\":\"/app/name\",\"value\":{\"encoding\":\"utf8\",\"data\":\"dbx\"}}"));
+            result(request(3, "kv_put", "{\"key\":\"/config\",\"value\":{\"encoding\":\"utf8\",\"data\":\"cfg\"}}"));
+
+            JsonObject list = result(request(6, "kv_list_prefix", "{\"prefix\":\"/\",\"recursive\":true}"));
+
+            Assertions.assertEquals(
+                List.of("/app", "/app/name", "/config", "/zookeeper", "/zookeeper/config", "/zookeeper/quota"),
+                listedKeys(list)
+            );
+        }
+    }
+
+    @Test
+    void listPrefixReturnsEmptyResultForMissingPrefix() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+
+            JsonObject list = result(request(7, "kv_list_prefix", "{\"prefix\":\"/missing\"}"));
+
+            Assertions.assertEquals(List.of(), listedKeys(list));
+            Assertions.assertTrue(list.get("continuation").isJsonNull());
+        }
+    }
+
+    @Test
+    void listPrefixPaginatesBySortedPath() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+            result(request(2, "kv_put", "{\"key\":\"/c\",\"value\":{\"encoding\":\"utf8\",\"data\":\"c\"}}"));
+            result(request(3, "kv_put", "{\"key\":\"/a\",\"value\":{\"encoding\":\"utf8\",\"data\":\"a\"}}"));
+            result(request(4, "kv_put", "{\"key\":\"/b\",\"value\":{\"encoding\":\"utf8\",\"data\":\"b\"}}"));
+
+            JsonObject first = result(request(5, "kv_list_prefix", "{\"prefix\":\"/\",\"limit\":2}"));
+            String continuation = first.get("continuation").getAsString();
+            JsonObject second = result(request(
+                6,
+                "kv_list_prefix",
+                "{\"prefix\":\"/\",\"limit\":2,\"continuation\":\"" + continuation + "\"}"
+            ));
+            String secondContinuation = second.get("continuation").getAsString();
+            JsonObject third = result(request(
+                7,
+                "kv_list_prefix",
+                "{\"prefix\":\"/\",\"limit\":2,\"continuation\":\"" + secondContinuation + "\"}"
+            ));
+
+            Assertions.assertEquals(List.of("/a", "/b"), listedKeys(first));
+            Assertions.assertFalse(continuation.isBlank());
+            Assertions.assertEquals(List.of("/c", "/zookeeper"), listedKeys(second));
+            Assertions.assertFalse(secondContinuation.isBlank());
+            Assertions.assertEquals(List.of("/zookeeper/config", "/zookeeper/quota"), listedKeys(third));
+            Assertions.assertTrue(third.get("continuation").isJsonNull());
+        }
+    }
+
+    @Test
+    void listPrefixPaginatesDirectChildrenWhenRecursiveIsFalse() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+            result(request(2, "kv_put", "{\"key\":\"/app/c/deep\",\"value\":{\"encoding\":\"utf8\",\"data\":\"c\"}}"));
+            result(request(3, "kv_put", "{\"key\":\"/app/a/deep\",\"value\":{\"encoding\":\"utf8\",\"data\":\"a\"}}"));
+            result(request(4, "kv_put", "{\"key\":\"/app/b/deep\",\"value\":{\"encoding\":\"utf8\",\"data\":\"b\"}}"));
+
+            JsonObject first = result(request(5, "kv_list_prefix", "{\"prefix\":\"/app\",\"recursive\":false,\"limit\":2}"));
+            String continuation = first.get("continuation").getAsString();
+            JsonObject second = result(request(
+                6,
+                "kv_list_prefix",
+                "{\"prefix\":\"/app\",\"recursive\":false,\"limit\":2,\"continuation\":\"" + continuation + "\"}"
+            ));
+
+            Assertions.assertEquals(List.of("/app/a", "/app/b"), listedKeys(first));
+            Assertions.assertFalse(continuation.isBlank());
+            Assertions.assertEquals(List.of("/app/c"), listedKeys(second));
+            Assertions.assertTrue(second.get("continuation").isJsonNull());
+        }
+    }
+
+    @Test
+    void listPrefixRejectsContinuationForDifferentRequest() throws Exception {
+        try (TestingServer server = new TestingServer()) {
+            connect(server);
+            result(request(2, "kv_put", "{\"key\":\"/app/a\",\"value\":{\"encoding\":\"utf8\",\"data\":\"a\"}}"));
+            result(request(3, "kv_put", "{\"key\":\"/app/b\",\"value\":{\"encoding\":\"utf8\",\"data\":\"b\"}}"));
+
+            JsonObject first = result(request(4, "kv_list_prefix", "{\"prefix\":\"/app\",\"limit\":1}"));
+            String continuation = first.get("continuation").getAsString();
+            JsonObject error = error(request(
+                5,
+                "kv_list_prefix",
+                "{\"prefix\":\"/\",\"limit\":1,\"continuation\":\"" + continuation + "\"}"
+            ));
+
+            Assertions.assertEquals("Continuation does not match request", error.get("message").getAsString());
+        }
+    }
+
+    private static JsonObject connect(TestingServer server) {
+        return result(request(1, "connect", "{\"connection\":{\"connect_string\":\"" + server.getConnectString() + "\"}}"));
+    }
+
+    private static String request(int id, String method, String params) {
+        return ZooKeeperAgent.handleRequest(
+            "{\"jsonrpc\":\"2.0\",\"id\":" + id + ",\"method\":\"" + method + "\",\"params\":" + params + "}"
+        );
+    }
+
+    private static JsonObject result(String response) {
+        return JsonParser.parseString(response).getAsJsonObject().getAsJsonObject("result");
+    }
+
+    private static JsonObject error(String response) {
+        JsonObject object = JsonParser.parseString(response).getAsJsonObject();
+        Assertions.assertTrue(object.has("error"), "expected JSON-RPC error but got " + response);
+        return object.getAsJsonObject("error");
+    }
+
+    private static String requiredString(JsonObject object, String key) {
+        Assertions.assertTrue(object.has(key), "expected result to contain " + key);
+        return object.get(key).getAsString();
+    }
+
+    private static List<String> listedKeys(JsonObject listResult) {
+        List<String> keys = new ArrayList<>();
+        JsonArray rows = listResult.getAsJsonArray("keys");
+        for (JsonElement row : rows) {
+            keys.add(row.getAsJsonObject().get("key").getAsString());
+        }
+        return keys;
+    }
+
+    private static JsonObject listedRow(JsonObject listResult, String key) {
+        JsonArray rows = listResult.getAsJsonArray("keys");
+        for (JsonElement row : rows) {
+            JsonObject object = row.getAsJsonObject();
+            if (key.equals(object.get("key").getAsString())) {
+                return object;
+            }
+        }
+        Assertions.fail("expected listed row for " + key);
+        return new JsonObject();
+    }
+}
diff --git a/agents/gradle/wrapper/gradle-wrapper.jar b/agents/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..b1b8ef5
Binary files /dev/null and b/agents/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/agents/gradle/wrapper/gradle-wrapper.properties b/agents/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..b52fb7e
--- /dev/null
+++ b/agents/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,9 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.0-bin.zip
+networkTimeout=10000
+retries=0
+retryBackOffMs=500
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
diff --git a/agents/gradlew b/agents/gradlew
new file mode 100755
index 0000000..b9bb139
--- /dev/null
+++ b/agents/gradlew
@@ -0,0 +1,248 @@
+#!/bin/sh
+
+#
+# Copyright © 2015 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"
diff --git a/agents/gradlew.bat b/agents/gradlew.bat
new file mode 100644
index 0000000..aa5f10b
--- /dev/null
+++ b/agents/gradlew.bat
@@ -0,0 +1,82 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables, and ensure extensions are enabled
+setlocal EnableExtensions
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+"%COMSPEC%" /c exit 1
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+"%COMSPEC%" /c exit 1
+
+:execute
+@rem Setup the command line
+
+
+
+@rem Execute Gradle
+@rem endlocal doesn't take effect until after the line is parsed and variables are expanded
+@rem which allows us to clear the local environment before executing the java command
+endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel
+
+:exitWithErrorLevel
+@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
+"%COMSPEC%" /c exit %ERRORLEVEL%
diff --git a/agents/metadata-constraint-coverage.tsv b/agents/metadata-constraint-coverage.tsv
new file mode 100644
index 0000000..e8b59c4
--- /dev/null
+++ b/agents/metadata-constraint-coverage.tsv
@@ -0,0 +1,24 @@
+driver	strategy	scope	reason
+access	intentional-fallback	java-jdbc-metadata	Uses Access JDBC metadata; no portable stable server-side paging API, common constraints filter locally.
+bigquery	native-pushdown	java-sql	Uses dataset INFORMATION_SCHEMA.TABLES with type, normal-name filter, stable order, and literal LIMIT/OFFSET.
+cassandra	intentional-fallback	java-cql	Uses Cassandra system_schema; portable LIKE/fuzzy paging is not safe across versions, common constraints filter locally.
+dameng	native-pushdown	java-sql	Uses ALL_OBJECTS with type, filter, stable order, and LIMIT/OFFSET with legacy fallback.
+databend	native-pushdown	java-sql	Uses system procedures for routine pushdown and shared table metadata constraints for table-like objects.
+db2	native-pushdown	java-sql	Uses SYSCAT metadata with type, filter, stable order, and OFFSET/FETCH.
+gbase8a	native-pushdown	java-sql	Uses information_schema with type, filter, stable order, and LIMIT/OFFSET.
+gbase8s	native-pushdown	java-sql	Uses systables with type, filter, stable order, and SKIP/FIRST.
+goldendb	native-pushdown	java-sql	Uses information_schema with type, filter, stable order, and LIMIT/OFFSET.
+h2	native-pushdown	java-sql	Uses INFORMATION_SCHEMA with type, filter, stable order, and LIMIT/OFFSET.
+hive	intentional-fallback	java-sql	Uses Hive metadata paths where stable server-side fuzzy paging is not portable, common constraints filter locally.
+informix	native-pushdown	java-sql	Uses systables/sysprocedures with type, filter, stable order, and SKIP/FIRST.
+kingbase	native-pushdown	java-sql	Uses sys_catalog/information_schema with type, filter, stable order, and LIMIT/OFFSET for both compatibility modes.
+kylin	intentional-fallback	java-jdbc-metadata	Uses JDBC metadata from Kylin driver; no portable server-side paging API, common constraints filter locally.
+neo4j	intentional-fallback	java-graph-metadata	Uses JDBC metadata with Cypher fallback; label discovery cannot guarantee relational-style filtered paging, common constraints filter locally.
+oceanbase-oracle	native-pushdown	java-sql	Uses Oracle-compatible metadata SQL with type, filter, stable order, and ROWNUM paging.
+oracle-go	native-pushdown	native-go	Uses Oracle-compatible metadata SQL with type, filter, stable order, and ROWNUM paging, with legacy profile guard.
+snowflake	native-pushdown	java-sql	Uses INFORMATION_SCHEMA with type, filter, stable order, and literal LIMIT/OFFSET.
+spark	intentional-fallback	java-show-metadata	Uses SHOW TABLES/SHOW DATABASES; stable server-side fuzzy paging is not portable, common constraints filter locally.
+sundb	native-pushdown	java-sql	Uses information_schema with type, filter, stable order, and LIMIT/OFFSET.
+tdengine	intentional-fallback	java-show-metadata	Uses SHOW STABLES/TABLES; stable server-side fuzzy paging is not portable, common constraints filter locally.
+trino	native-pushdown	java-sql	Uses information_schema.tables with type, filter, stable order, and literal LIMIT/OFFSET.
+xugu	native-pushdown	native-go	Uses ALL_TABLES/ALL_VIEWS metadata with type, filter, stable order, and ROWNUM paging.
diff --git a/agents/opengauss/build.gradle b/agents/opengauss/build.gradle
new file mode 100644
index 0000000..b8b3af7
--- /dev/null
+++ b/agents/opengauss/build.gradle
@@ -0,0 +1,10 @@
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation 'org.opengauss:opengauss-jdbc:7.0.0-RC3-og'
+}
+
+tasks.named('shadowJar') {
+    manifest {
+        attributes('Agent-Label': 'openGauss', 'Main-Class': 'com.dbx.agent.opengauss.OpenGaussAgent')
+    }
+}
diff --git a/agents/opengauss/src/main/java/com/dbx/agent/opengauss/OpenGaussAgent.java b/agents/opengauss/src/main/java/com/dbx/agent/opengauss/OpenGaussAgent.java
new file mode 100644
index 0000000..985b964
--- /dev/null
+++ b/agents/opengauss/src/main/java/com/dbx/agent/opengauss/OpenGaussAgent.java
@@ -0,0 +1,20 @@
+package com.dbx.agent.opengauss;
+
+import com.dbx.agent.JsonRpcServer;
+import com.dbx.agent.PostgresLikeAgent;
+import com.dbx.agent.PostgresLikeAgentProfile;
+
+public final class OpenGaussAgent extends PostgresLikeAgent {
+    public static final PostgresLikeAgentProfile OPENGAUSS_PROFILE = new PostgresLikeAgentProfile(
+        "org.opengauss.Driver",
+        "jdbc:opengauss://{host}:{port}/{database}"
+    );
+
+    public OpenGaussAgent() {
+        super(OPENGAUSS_PROFILE);
+    }
+
+    public static void main(String[] args) {
+        new JsonRpcServer(new OpenGaussAgent()).run();
+    }
+}
diff --git a/agents/opengauss/src/test/java/com/dbx/agent/opengauss/OpenGaussAgentTest.java b/agents/opengauss/src/test/java/com/dbx/agent/opengauss/OpenGaussAgentTest.java
new file mode 100644
index 0000000..8b8452d
--- /dev/null
+++ b/agents/opengauss/src/test/java/com/dbx/agent/opengauss/OpenGaussAgentTest.java
@@ -0,0 +1,21 @@
+package com.dbx.agent.opengauss;
+
+import com.dbx.agent.ConnectParams;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class OpenGaussAgentTest {
+    @Test
+    void buildsOpenGaussUrl() {
+        ConnectParams params = new ConnectParams();
+        params.setHost("db.example.com");
+        params.setPort(15432);
+        params.setDatabase("postgres");
+
+        assertEquals(
+            "jdbc:opengauss://db.example.com:15432/postgres",
+            OpenGaussAgent.OPENGAUSS_PROFILE.buildUrl(params)
+        );
+    }
+}
diff --git a/agents/scripts/build_offline_zip.sh b/agents/scripts/build_offline_zip.sh
new file mode 100755
index 0000000..9039324
--- /dev/null
+++ b/agents/scripts/build_offline_zip.sh
@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Build offline ZIP bundles for each platform.
+# Usage: ./scripts/build_offline_zip.sh <release-dir>
+# The release-dir must contain agent-registry.json, dbx-agent-*.jar, and dbx-jre-*.tar.gz
+
+RELEASE_DIR="$(cd "${1:?Usage: build_offline_zip.sh <release-dir>}" && pwd)"
+
+if [ ! -f "$RELEASE_DIR/agent-registry.json" ]; then
+  echo "ERROR: agent-registry.json not found in $RELEASE_DIR"
+  exit 1
+fi
+
+PLATFORMS=(
+  "macos-aarch64"
+  "macos-x64"
+  "linux-x64"
+  "linux-aarch64"
+  "windows-x64"
+  "windows-aarch64"
+)
+
+STAGING=$(mktemp -d)
+trap 'rm -rf "$STAGING"' EXIT
+
+for platform in "${PLATFORMS[@]}"; do
+  WORK="$STAGING/$platform"
+  mkdir -p "$WORK/jre" "$WORK/drivers"
+
+  cp "$RELEASE_DIR/agent-registry.json" "$WORK/"
+
+  # Copy all JRE archives for this platform
+  JRE_COUNT=0
+  for jre_file in "$RELEASE_DIR"/dbx-jre-*-"$platform".tar.gz; do
+    [ -f "$jre_file" ] || continue
+    cp "$jre_file" "$WORK/jre/"
+    JRE_COUNT=$((JRE_COUNT + 1))
+  done
+
+  if [ "$JRE_COUNT" -eq 0 ]; then
+    echo "SKIP $platform (no JRE found)"
+    rm -rf "$WORK"
+    continue
+  fi
+
+  # Copy all driver JARs (platform-independent)
+  for jar_file in "$RELEASE_DIR"/dbx-agent-*.jar; do
+    [ -f "$jar_file" ] || continue
+    cp "$jar_file" "$WORK/drivers/"
+  done
+
+  for native_file in "$RELEASE_DIR"/dbx-agent-*-"$platform" "$RELEASE_DIR"/dbx-agent-*-"$platform".exe; do
+    [ -f "$native_file" ] || continue
+    cp "$native_file" "$WORK/drivers/"
+  done
+
+  ZIP_NAME="dbx-agents-offline-${platform}.zip"
+  (cd "$WORK" && zip -r "$RELEASE_DIR/$ZIP_NAME" agent-registry.json jre/ drivers/)
+  SIZE=$(du -h "$RELEASE_DIR/$ZIP_NAME" | cut -f1)
+  echo "Created $ZIP_NAME ($SIZE)"
+done
+
+echo "Done."
diff --git a/agents/scripts/release.sh b/agents/scripts/release.sh
new file mode 100755
index 0000000..2c261ba
--- /dev/null
+++ b/agents/scripts/release.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ROOT_DIR="$(cd "${SCRIPT_DIR}/../.." && pwd)"
+
+cd "${ROOT_DIR}"
+exec node scripts/release.mjs agents "$@"
diff --git a/agents/scripts/validate_agent_jars.py b/agents/scripts/validate_agent_jars.py
new file mode 100644
index 0000000..a51e329
--- /dev/null
+++ b/agents/scripts/validate_agent_jars.py
@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+import sys
+import zipfile
+from email.parser import Parser
+from pathlib import Path
+
+
+def agent_modules(root: Path) -> list[str]:
+    return sorted(
+        path.parents[2].name
+        for path in list(root.glob("*/build/libs/dbx-agent-*.jar"))
+        + list(root.glob("drivers/*/build/libs/dbx-agent-*.jar"))
+        if path.is_file()
+    )
+
+
+def module_dir(root: Path, module: str) -> Path:
+    nested = root / "drivers" / module
+    if nested.exists():
+        return nested
+    return root / module
+
+
+def validate_agent_jars(root: Path) -> list[str]:
+    problems: list[str] = []
+    for module in agent_modules(root):
+        jar = module_dir(root, module) / "build/libs" / f"dbx-agent-{module}.jar"
+        relative = jar.relative_to(root)
+        try:
+            with zipfile.ZipFile(jar) as archive:
+                manifest = read_manifest(archive)
+                main_class = manifest.get("Main-Class")
+                if not main_class:
+                    problems.append(f"{relative}: missing Main-Class manifest attribute")
+                    continue
+                class_entry = main_class.replace(".", "/") + ".class"
+                if class_entry not in archive.namelist():
+                    problems.append(f"{relative}: Main-Class class not found: {class_entry}")
+                if not manifest.get("Agent-Label"):
+                    problems.append(f"{relative}: missing Agent-Label manifest attribute")
+        except zipfile.BadZipFile:
+            problems.append(f"{relative}: invalid jar")
+    return problems
+
+
+def read_manifest(archive: zipfile.ZipFile) -> dict[str, str]:
+    try:
+        raw = archive.read("META-INF/MANIFEST.MF").decode("utf-8")
+    except KeyError:
+        return {}
+    return dict(Parser().parsestr(raw))
+
+
+def main() -> int:
+    root = Path.cwd()
+    problems = validate_agent_jars(root)
+    if problems:
+        print("Agent jar validation failed:")
+        for problem in problems:
+            print(f"- {problem}")
+        return 1
+
+    print("Agent jar validation passed")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/agents/scripts/validate_agents.py b/agents/scripts/validate_agents.py
new file mode 100644
index 0000000..33b1758
--- /dev/null
+++ b/agents/scripts/validate_agents.py
@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Optional
+
+
+INFRA_MODULES = {"common", "test-support"}
+SOURCE_GLOBS = ("*/src/main/**/*.java", "drivers/*/src/main/**/*.java")
+KOTLIN_FILE_SUFFIXES = (".kt", ".kts")
+KOTLIN_SCAN_EXCLUDED_PARTS = {".git", ".gradle", "build"}
+DEFAULT_AGENT_JRE_KEY = "21"
+NON_JDBC_AGENT_MODULES = {"mongodb", "etcd", "zookeeper", "kafka"}
+NATIVE_ONLY_AGENT_MODULES = {
+    "oracle": "drivers/oracle-go",
+    "xugu": "drivers/xugu",
+}
+JDBC_ARCHITECTURE_ALLOWLIST = {
+    "h2-legacy": "reuses the H2 agent implementation with an isolated legacy driver version",
+    "access": "custom Access metadata and URL behavior pending migration",
+    "dameng": "custom Dameng metadata and DDL pending migration",
+    "db2": "custom DB2 metadata pending migration",
+    "gbase8s": "custom GBase 8s metadata pending migration",
+    "goldendb": "custom GoldenDB metadata pending migration",
+    "informix": "custom Informix metadata pending migration",
+    "neo4j": "custom Neo4j transaction/query behavior pending migration",
+    "sundb": "custom SunDB metadata pending migration",
+    "tdengine": "custom TDengine WebSocket JDBC behavior pending migration",
+}
+APPROVED_JDBC_BASES = {
+    "AbstractJdbcAgent",
+    "ConfiguredJdbcAgent",
+    "PostgresLikeAgent",
+}
+
+FORBIDDEN_PATTERNS = [
+    (re.compile(r"private\s+val\s+QUERY_PREFIXES"), "forbidden local SQL prefix classifier"),
+    (re.compile(r"private\s+const\s+val\s+MAX_ROWS"), "forbidden local result row cap"),
+    (re.compile(r"executeUpdate\s*\(\s*trimmedSql\s*\)"), "forbidden executeUpdate(trimmedSql) in query execution"),
+    (re.compile(r"truncated\s*=\s*rows\.size\s*>=\s*MAX_ROWS"), "forbidden inclusive truncation check"),
+    (re.compile(r"val\s+truncated\s*=\s*rs\.next\s*\(\s*\)"), "forbidden extra ResultSet next() truncation probe"),
+]
+
+COPIED_JDBC_INFRASTRUCTURE_PATTERNS = [
+    (re.compile(r"\bClass\.forName\s*\("), "copied driver loading"),
+    (re.compile(r"\bDriverManager\.getConnection\s*\("), "copied JDBC connection creation"),
+    (re.compile(r"public\s+void\s+disconnect\s*\("), "copied JDBC disconnect lifecycle"),
+    (re.compile(r"JdbcExecutor\.INSTANCE\.execute\s*\("), "copied JDBC query execution"),
+    (re.compile(r"private\s+Object\s+(?:getResultValue|resultValue|stringResultValue)\s*\("), "copied result value reader"),
+]
+
+
+def included_agent_modules(root: Path) -> set[str]:
+    settings = (root / "settings.gradle").read_text(encoding="utf-8")
+    include_args = "\n".join(
+        parenthesized or bare
+        for parenthesized, bare in re.findall(
+            r"\binclude\b\s*(?:\((.*?)\)|([^\n]+))", settings, flags=re.S
+        )
+    )
+    included = set(re.findall(r"""['"]([^'"]+)['"]""", include_args))
+    for variable in ("infrastructureModules", "driverModules"):
+        match = re.search(rf"\bdef\s+{variable}\s*=\s*\[(.*?)\]", settings, flags=re.S)
+        if match:
+            included.update(re.findall(r"""['"]([^'"]+)['"]""", match.group(1)))
+    return included - INFRA_MODULES
+
+
+def agent_modules(root: Path) -> set[str]:
+    native = {name for name, path in NATIVE_ONLY_AGENT_MODULES.items() if (root / path).exists()}
+    return included_agent_modules(root) | native
+
+
+def module_dir(root: Path, module: str) -> Path:
+    if module in NATIVE_ONLY_AGENT_MODULES:
+        return root / NATIVE_ONLY_AGENT_MODULES[module]
+    nested = root / "drivers" / module
+    if nested.exists():
+        return nested
+    return root / module
+
+
+def module_relative_path(root: Path, module: str, *parts: str) -> Path:
+    return module_dir(root, module).joinpath(*parts)
+
+
+def validate_versions(root: Path) -> list[str]:
+    included = agent_modules(root)
+    versions = set(json.loads((root / "versions.json").read_text(encoding="utf-8")))
+    return (
+        [f"included module missing version: {name}" for name in sorted(included - versions)]
+        + [f"versions key not included: {name}" for name in sorted(versions - included)]
+    )
+
+
+def validate_source_patterns(root: Path) -> list[str]:
+    problems: list[str] = []
+    sources = sorted(source for glob in SOURCE_GLOBS for source in root.glob(glob))
+    for source in sources:
+        relative = source.relative_to(root)
+        text = source.read_text(encoding="utf-8")
+        for line_number, line in enumerate(text.splitlines(), start=1):
+            for pattern, message in FORBIDDEN_PATTERNS:
+                if pattern.search(line):
+                    problems.append(f"{relative}:{line_number}: {message}")
+    return problems
+
+
+def validate_no_kotlin_residue(root: Path) -> list[str]:
+    problems: list[str] = []
+    for path in sorted(root.rglob("*")):
+        if not path.is_file():
+            continue
+        relative = path.relative_to(root)
+        if any(part in KOTLIN_SCAN_EXCLUDED_PARTS for part in relative.parts):
+            continue
+        if path.suffix in KOTLIN_FILE_SUFFIXES:
+            problems.append(f"{relative}: forbidden Kotlin file")
+    return problems
+
+
+def validate_manifest_fields(root: Path, modules: set[str]) -> list[str]:
+    problems: list[str] = []
+    root_build_text = (root / "build.gradle").read_text(encoding="utf-8") if (root / "build.gradle").exists() else ""
+    archive_convention = re.search(
+        r"archiveBaseName\s*=\s*['\"]dbx-agent-\$\{project\.name\}['\"]",
+        root_build_text,
+    )
+    for module in sorted(modules):
+        if module in NATIVE_ONLY_AGENT_MODULES:
+            continue
+        build_file = module_relative_path(root, module, "build.gradle")
+        relative = build_file.relative_to(root)
+        if not build_file.exists():
+            problems.append(f"{module}: missing build.gradle")
+            continue
+
+        text = build_file.read_text(encoding="utf-8")
+        expected_archive = f"archiveBaseName = 'dbx-agent-{module}'"
+        archive_pattern = re.compile(
+            rf"archiveBaseName\s*=\s*['\"]dbx-agent-{re.escape(module)}['\"]"
+        )
+        if not archive_convention and not archive_pattern.search(text):
+            problems.append(f"{relative}: missing {expected_archive}")
+        attrs = manifest_attributes(text)
+        if "Agent-Label" not in attrs:
+            problems.append(f"{relative}: missing Agent-Label manifest attribute")
+        main_class = attrs.get("Main-Class")
+        if main_class is None:
+            problems.append(f"{relative}: missing Main-Class manifest attribute")
+        else:
+            main_source = module_relative_path(
+                root,
+                module,
+                "src/main/java",
+                str(Path(*main_class.split(".")).with_suffix(".java")),
+            )
+            if not main_source.exists():
+                problems.append(f"{relative}: Main-Class source not found: {main_source.relative_to(root)}")
+    return problems
+
+
+def validate_jdbc_architecture(root: Path, modules: set[str]) -> list[str]:
+    problems: list[str] = []
+    for module in sorted(modules - NON_JDBC_AGENT_MODULES - set(NATIVE_ONLY_AGENT_MODULES)):
+        source = main_class_source(root, module)
+        if source is None or not source.exists():
+            continue
+        text = source.read_text(encoding="utf-8")
+        base_match = re.search(r"\bextends\s+([A-Za-z0-9_]+)", text)
+        base = base_match.group(1) if base_match else ""
+        if module not in JDBC_ARCHITECTURE_ALLOWLIST and base not in APPROVED_JDBC_BASES:
+            problems.append(
+                f"{source.relative_to(root)}: JDBC agents must extend AbstractJdbcAgent, ConfiguredJdbcAgent, or PostgresLikeAgent"
+            )
+        if module in JDBC_ARCHITECTURE_ALLOWLIST:
+            continue
+        for line_number, line in enumerate(text.splitlines(), start=1):
+            for pattern, message in COPIED_JDBC_INFRASTRUCTURE_PATTERNS:
+                if pattern.search(line):
+                    problems.append(f"{source.relative_to(root)}:{line_number}: {message}; use shared JDBC foundation")
+    return problems
+
+
+def validate_authoring_template(root: Path) -> list[str]:
+    template = root / "docs/examples/jdbc-agent-template/src/main/java/com/dbx/agent/template/TemplateAgent.java"
+    if not template.exists():
+        return []
+    text = template.read_text(encoding="utf-8")
+    problems: list[str] = []
+    if "extends BaseDatabaseAgent" in text:
+        problems.append(f"{template.relative_to(root)}: template must use shared JDBC foundation")
+    for pattern, message in COPIED_JDBC_INFRASTRUCTURE_PATTERNS:
+        if pattern.search(text):
+            problems.append(f"{template.relative_to(root)}: template contains {message}")
+    return problems
+
+
+def main_class_source(root: Path, module: str) -> Optional[Path]:
+    build_file = module_relative_path(root, module, "build.gradle")
+    if not build_file.exists():
+        return None
+    attrs = manifest_attributes(build_file.read_text(encoding="utf-8"))
+    main_class = attrs.get("Main-Class")
+    if main_class is None:
+        return None
+    return module_relative_path(root, module, "src/main/java", str(Path(*main_class.split(".")).with_suffix(".java")))
+
+
+def validate_release_runtime_keys(root: Path) -> list[str]:
+    workflow_candidates = [
+        root.parent / ".github/workflows/agents-release.yml",
+        root / ".github/workflows/agents-release.yml",
+        root / ".github/workflows/release.yml",
+    ]
+    workflow = next((candidate for candidate in workflow_candidates if candidate.exists()), workflow_candidates[-1])
+    if not workflow.exists():
+        return []
+    text = workflow.read_text(encoding="utf-8")
+    problems: list[str] = []
+    required_patterns = [
+        (
+            rf'jre-key:\s*"{DEFAULT_AGENT_JRE_KEY}"',
+            f"release workflow must build the default JRE with key {DEFAULT_AGENT_JRE_KEY}",
+        ),
+        (
+            rf'java-version:\s*"{DEFAULT_AGENT_JRE_KEY}"',
+            f"release workflow must build the default JRE from Java {DEFAULT_AGENT_JRE_KEY}",
+        ),
+        (
+            rf'\*\)\s*echo\s*"{DEFAULT_AGENT_JRE_KEY}"',
+            f"agents must use JRE key {DEFAULT_AGENT_JRE_KEY}",
+        ),
+        (
+            rf'"{DEFAULT_AGENT_JRE_KEY}":\s*\{{\s*"version":\s*"{DEFAULT_AGENT_JRE_KEY}\.',
+            f"registry must publish Java {DEFAULT_AGENT_JRE_KEY} under JRE key {DEFAULT_AGENT_JRE_KEY}",
+        ),
+        (
+            r"jdk\.security\.auth",
+            "release workflow JRE must include jdk.security.auth for Kafka Kerberos LoginModule support",
+        ),
+        (
+            r"jdk\.security\.jgss",
+            "release workflow JRE must include jdk.security.jgss for Kafka GSSAPI SASL support",
+        ),
+        (
+            r"legacy-placeholder\.jar",
+            "native-only registry entries must publish a legacy jar placeholder for older DBX clients",
+        ),
+    ]
+    for pattern, message in required_patterns:
+        if not re.search(pattern, text, flags=re.S):
+            problems.append(message)
+    forbidden_patterns = [
+        (r'jre-key:\s*"17"', "release workflow must not build Java 21 under JRE key 17"),
+        (r'\*\)\s*echo\s*"17"', "agents must not use JRE key 17"),
+        (r'"17":\s*\{\s*"version":\s*"21\.', "registry must not publish Java 21 under JRE key 17"),
+    ]
+    for pattern, message in forbidden_patterns:
+        if re.search(pattern, text, flags=re.S):
+            problems.append(message)
+    return problems
+
+
+def manifest_attributes(build_text: str) -> dict[str, str]:
+    attrs: dict[str, str] = {}
+    for key, value in re.findall(
+        r"['\"]([^'\"]+)['\"]\s*:\s*['\"]([^'\"]+)['\"]",
+        build_text,
+    ):
+        attrs[key] = value
+    return attrs
+
+
+def validate(root: Path) -> list[str]:
+    modules = agent_modules(root)
+    return (
+        validate_versions(root)
+        + validate_source_patterns(root)
+        + validate_manifest_fields(root, modules)
+        + validate_jdbc_architecture(root, modules)
+        + validate_authoring_template(root)
+        + validate_release_runtime_keys(root)
+        + validate_no_kotlin_residue(root)
+    )
+
+
+def main() -> int:
+    root = Path.cwd()
+    problems = validate(root)
+    if problems:
+        print("Agent validation failed:")
+        for problem in problems:
+            print(f"- {problem}")
+        return 1
+
+    print("Agent validation passed")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/agents/scripts/validate_agents_test.py b/agents/scripts/validate_agents_test.py
new file mode 100644
index 0000000..9354375
--- /dev/null
+++ b/agents/scripts/validate_agents_test.py
@@ -0,0 +1,427 @@
+import json
+import tempfile
+import textwrap
+import unittest
+import zipfile
+from pathlib import Path
+
+import validate_agents
+import validate_agent_jars
+
+
+class ValidateAgentsTest(unittest.TestCase):
+    def test_versions_must_match_included_agent_modules(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            (root / "settings.gradle").write_text(
+                "include 'common', 'test-support', 'h2', 'oracle'\n",
+                encoding="utf-8",
+            )
+            (root / "versions.json").write_text(
+                json.dumps({"h2": "0.1.0", "mongodb": "0.1.0"}),
+                encoding="utf-8",
+            )
+
+            problems = validate_agents.validate_versions(root)
+
+            self.assertEqual(
+                [
+                    "included module missing version: oracle",
+                    "versions key not included: mongodb",
+                ],
+                problems,
+            )
+
+    def test_versions_support_driver_modules_variable(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            (root / "settings.gradle").write_text(
+                "def infrastructureModules = ['common', 'test-support']\n"
+                "def driverModules = ['h2', 'oracle']\n"
+                "include(*(infrastructureModules + driverModules))\n",
+                encoding="utf-8",
+            )
+            (root / "versions.json").write_text(
+                json.dumps({"h2": "0.1.0", "oracle": "0.1.0"}),
+                encoding="utf-8",
+            )
+
+            self.assertEqual([], validate_agents.validate_versions(root))
+
+    def test_source_scan_rejects_old_execute_query_patterns(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            source = root / "h2/src/main/java/com/dbx/agent/h2/H2Agent.java"
+            source.parent.mkdir(parents=True)
+            source.write_text(
+                textwrap.dedent(
+                    """
+                    private val QUERY_PREFIXES = listOf("SELECT")
+                    fun executeQuery(sql: String) {
+                        val trimmedSql = sql.trim()
+                        stmt.executeUpdate(trimmedSql)
+                    }
+                    """
+                ),
+                encoding="utf-8",
+            )
+
+            problems = validate_agents.validate_source_patterns(root)
+
+            self.assertEqual(
+                [
+                    "h2/src/main/java/com/dbx/agent/h2/H2Agent.java:2: forbidden local SQL prefix classifier",
+                    "h2/src/main/java/com/dbx/agent/h2/H2Agent.java:5: forbidden executeUpdate(trimmedSql) in query execution",
+                ],
+                problems,
+            )
+
+    def test_jdbc_architecture_requires_shared_base_for_new_agents(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            module = root / "example"
+            source = module / "src/main/java/com/dbx/agent/example/ExampleAgent.java"
+            source.parent.mkdir(parents=True)
+            (module / "build.gradle").write_text(
+                textwrap.dedent(
+                    """
+                    tasks.named('shadowJar') {
+                        manifest {
+                            attributes(
+                                'Agent-Label': 'Example',
+                                'Main-Class': 'com.dbx.agent.example.ExampleAgent'
+                            )
+                        }
+                    }
+                    """
+                ),
+                encoding="utf-8",
+            )
+            source.write_text(
+                textwrap.dedent(
+                    """
+                    package com.dbx.agent.example;
+
+                    import com.dbx.agent.BaseDatabaseAgent;
+                    import java.sql.DriverManager;
+
+                    public final class ExampleAgent extends BaseDatabaseAgent {
+                        public void connect() throws Exception {
+                            Class.forName("example.Driver");
+                            DriverManager.getConnection("jdbc:example");
+                        }
+                    }
+                    """
+                ),
+                encoding="utf-8",
+            )
+
+            problems = validate_agents.validate_jdbc_architecture(root, {"example"})
+
+            self.assertEqual(
+                [
+                    "example/src/main/java/com/dbx/agent/example/ExampleAgent.java: JDBC agents must extend AbstractJdbcAgent, ConfiguredJdbcAgent, or PostgresLikeAgent",
+                    "example/src/main/java/com/dbx/agent/example/ExampleAgent.java:9: copied driver loading; use shared JDBC foundation",
+                    "example/src/main/java/com/dbx/agent/example/ExampleAgent.java:10: copied JDBC connection creation; use shared JDBC foundation",
+                ],
+                problems,
+            )
+
+    def test_versions_include_native_only_modules(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            (root / "settings.gradle").write_text(
+                "def infrastructureModules = ['common', 'test-support']\n"
+                "def driverModules = ['h2']\n"
+                "include(*(infrastructureModules + driverModules))\n",
+                encoding="utf-8",
+            )
+            (root / "drivers/oracle-go").mkdir(parents=True)
+            (root / "versions.json").write_text(
+                json.dumps({"h2": "0.1.0", "oracle": "0.1.0"}),
+                encoding="utf-8",
+            )
+
+            self.assertEqual([], validate_agents.validate_versions(root))
+
+    def test_authoring_template_must_use_shared_foundation(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            template = root / "docs/examples/jdbc-agent-template/src/main/java/com/dbx/agent/template/TemplateAgent.java"
+            template.parent.mkdir(parents=True)
+            template.write_text(
+                textwrap.dedent(
+                    """
+                    package com.dbx.agent.template;
+                    import com.dbx.agent.BaseDatabaseAgent;
+                    import java.sql.DriverManager;
+                    public final class TemplateAgent extends BaseDatabaseAgent {
+                        void connect() throws Exception {
+                            DriverManager.getConnection("jdbc:template");
+                        }
+                    }
+                    """
+                ),
+                encoding="utf-8",
+            )
+
+            self.assertEqual(
+                [
+                    "docs/examples/jdbc-agent-template/src/main/java/com/dbx/agent/template/TemplateAgent.java: template must use shared JDBC foundation",
+                    "docs/examples/jdbc-agent-template/src/main/java/com/dbx/agent/template/TemplateAgent.java: template contains copied JDBC connection creation",
+                ],
+                validate_agents.validate_authoring_template(root),
+            )
+
+    def test_manifest_validation_requires_registry_fields(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            module = root / "h2"
+            module.mkdir()
+            (root / "build.gradle").write_text(
+                textwrap.dedent(
+                    """
+                    configure(agentProjects) {
+                        tasks.named('shadowJar') {
+                            archiveBaseName = "dbx-agent-${project.name}"
+                        }
+                    }
+                    """
+                ),
+                encoding="utf-8",
+            )
+            (module / "build.gradle").write_text(
+                textwrap.dedent(
+                    """
+                    tasks.named('shadowJar') {
+                        manifest {
+                            attributes(
+                                'Agent-Label': 'H2'
+                            )
+                        }
+                    }
+                    """
+                ),
+                encoding="utf-8",
+            )
+
+            problems = validate_agents.validate_manifest_fields(root, {"h2"})
+
+            self.assertEqual(
+                ["h2/build.gradle: missing Main-Class manifest attribute"],
+                problems,
+            )
+
+    def test_manifest_validation_requires_main_class_source(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            module = root / "h2"
+            module.mkdir()
+            (root / "build.gradle").write_text(
+                'archiveBaseName = "dbx-agent-${project.name}"\n',
+                encoding="utf-8",
+            )
+            (module / "build.gradle").write_text(
+                textwrap.dedent(
+                    """
+                    tasks.named('shadowJar') {
+                        manifest {
+                            attributes(
+                                'Agent-Label': 'H2',
+                                'Main-Class': 'com.dbx.agent.h2.H2Agent'
+                            )
+                        }
+                    }
+                    """
+                ),
+                encoding="utf-8",
+            )
+
+            problems = validate_agents.validate_manifest_fields(root, {"h2"})
+
+            self.assertEqual(
+                ["h2/build.gradle: Main-Class source not found: h2/src/main/java/com/dbx/agent/h2/H2Agent.java"],
+                problems,
+            )
+
+            source = module / "src/main/java/com/dbx/agent/h2/H2Agent.java"
+            source.parent.mkdir(parents=True)
+            source.write_text("package com.dbx.agent.h2; public final class H2Agent {}", encoding="utf-8")
+
+            self.assertEqual([], validate_agents.validate_manifest_fields(root, {"h2"}))
+
+    def test_manifest_validation_supports_drivers_directory(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            module = root / "drivers/h2"
+            source = module / "src/main/java/com/dbx/agent/h2/H2Agent.java"
+            source.parent.mkdir(parents=True)
+            source.write_text("package com.dbx.agent.h2; public final class H2Agent {}", encoding="utf-8")
+            (root / "build.gradle").write_text(
+                'archiveBaseName = "dbx-agent-${project.name}"\n',
+                encoding="utf-8",
+            )
+            (module / "build.gradle").write_text(
+                textwrap.dedent(
+                    """
+                    tasks.named('shadowJar') {
+                        manifest {
+                            attributes(
+                                'Agent-Label': 'H2',
+                                'Main-Class': 'com.dbx.agent.h2.H2Agent'
+                            )
+                        }
+                    }
+                    """
+                ),
+                encoding="utf-8",
+            )
+
+            self.assertEqual([], validate_agents.validate_manifest_fields(root, {"h2"}))
+
+    def test_kotlin_residue_scan_rejects_kt_and_kts_files_outside_build_dirs(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            forbidden_source = root / "h2/src/main/kotlin/com/dbx/agent/h2/H2Agent.kt"
+            forbidden_build = root / "settings.gradle.kts"
+            ignored_build_output = root / "h2/build/tmp/Generated.kt"
+            ignored_gradle_cache = root / ".gradle/caches/init.gradle.kts"
+            for path in (
+                forbidden_source,
+                forbidden_build,
+                ignored_build_output,
+                ignored_gradle_cache,
+            ):
+                path.parent.mkdir(parents=True, exist_ok=True)
+                path.write_text("", encoding="utf-8")
+
+            problems = validate_agents.validate_no_kotlin_residue(root)
+
+            self.assertEqual(
+                [
+                    "h2/src/main/kotlin/com/dbx/agent/h2/H2Agent.kt: forbidden Kotlin file",
+                    "settings.gradle.kts: forbidden Kotlin file",
+                ],
+                problems,
+            )
+
+    def test_release_runtime_keys_match_java_21_default(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            workflow = root / ".github/workflows/release.yml"
+            workflow.parent.mkdir(parents=True)
+            workflow.write_text(
+                textwrap.dedent(
+                    '''
+                    strategy:
+                      matrix:
+                        include:
+                          - jre-key: "21"
+                            java-version: "21"
+                            modules: "java.base,jdk.security.auth,jdk.security.jgss"
+                    detect_jre_key() {
+                      case "$name" in
+                        *) echo "21" ;;
+                      esac
+                    }
+                    cat > release/agent-registry.json <<EOF
+                    {
+                      "jres": {
+                        "21": {
+                          "version": "21.0.11"
+                        }
+                      }
+                    }
+                    EOF
+                    legacy_jar_url="https://github.com/${REPO}/releases/download/${TAG}/dbx-agent-${name}-legacy-placeholder.jar"
+                    '''
+                ),
+                encoding="utf-8",
+            )
+
+            self.assertEqual([], validate_agents.validate_release_runtime_keys(root))
+
+            workflow.write_text(
+                textwrap.dedent(
+                    '''
+                    strategy:
+                      matrix:
+                        include:
+                          - jre-key: "17"
+                            java-version: "21"
+                    detect_jre_key() {
+                      case "$name" in
+                        *) echo "17" ;;
+                      esac
+                    }
+                    cat > release/agent-registry.json <<EOF
+                    {
+                      "jres": {
+                        "17": {
+                          "version": "21.0.11"
+                        }
+                      }
+                    }
+                    EOF
+                    '''
+                ),
+                encoding="utf-8",
+            )
+
+            self.assertEqual(
+                [
+                    "release workflow must build the default JRE with key 21",
+                    "agents must use JRE key 21",
+                    "registry must publish Java 21 under JRE key 21",
+                    "release workflow JRE must include jdk.security.auth for Kafka Kerberos LoginModule support",
+                    "release workflow JRE must include jdk.security.jgss for Kafka GSSAPI SASL support",
+                    "native-only registry entries must publish a legacy jar placeholder for older DBX clients",
+                    "release workflow must not build Java 21 under JRE key 17",
+                    "agents must not use JRE key 17",
+                    "registry must not publish Java 21 under JRE key 17",
+                ],
+                validate_agents.validate_release_runtime_keys(root),
+            )
+
+    def test_agent_jar_validation_requires_main_class_entry(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            jar = root / "h2/build/libs/dbx-agent-h2.jar"
+            jar.parent.mkdir(parents=True)
+            with zipfile.ZipFile(jar, "w") as archive:
+                archive.writestr(
+                    "META-INF/MANIFEST.MF",
+                    "Manifest-Version: 1.0\n"
+                    "Agent-Label: H2\n"
+                    "Main-Class: com.dbx.agent.h2.H2Agent\n\n",
+                )
+
+            self.assertEqual(
+                ["h2/build/libs/dbx-agent-h2.jar: Main-Class class not found: com/dbx/agent/h2/H2Agent.class"],
+                validate_agent_jars.validate_agent_jars(root),
+            )
+
+            with zipfile.ZipFile(jar, "a") as archive:
+                archive.writestr("com/dbx/agent/h2/H2Agent.class", b"class-bytes")
+
+            self.assertEqual([], validate_agent_jars.validate_agent_jars(root))
+
+    def test_agent_jar_validation_supports_drivers_directory(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            root = Path(tmp)
+            jar = root / "drivers/h2/build/libs/dbx-agent-h2.jar"
+            jar.parent.mkdir(parents=True)
+            with zipfile.ZipFile(jar, "w") as archive:
+                archive.writestr(
+                    "META-INF/MANIFEST.MF",
+                    "Manifest-Version: 1.0\n"
+                    "Agent-Label: H2\n"
+                    "Main-Class: com.dbx.agent.h2.H2Agent\n\n",
+                )
+                archive.writestr("com/dbx/agent/h2/H2Agent.class", b"class-bytes")
+
+            self.assertEqual([], validate_agent_jars.validate_agent_jars(root))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/agents/settings.gradle b/agents/settings.gradle
new file mode 100644
index 0000000..3d20ccf
--- /dev/null
+++ b/agents/settings.gradle
@@ -0,0 +1,16 @@
+rootProject.name = 'dbx-agents'
+
+def infrastructureModules = ['common', 'test-support']
+def driverModules = [
+    'access', 'dameng', 'kingbase', 'vastbase', 'goldendb', 'databend', 'databricks', 'saphana',
+    'teradata', 'vertica', 'firebird', 'exasol', 'oceanbase-oracle', 'gbase8a', 'gbase8s',
+    'bigquery', 'kylin', 'sundb', 'h2', 'h2-legacy', 'snowflake', 'trino', 'hive', 'spark',
+    'db2', 'informix', 'neo4j', 'cassandra', 'mongodb', 'highgo', 'tdengine', 'yashandb', 'oscar',
+    'iris', 'iotdb', 'etcd', 'zookeeper', 'kafka', 'sqlserver-legacy'
+]
+
+include(*(infrastructureModules + driverModules))
+
+driverModules.each { name ->
+    project(":${name}").projectDir = file("drivers/${name}")
+}
diff --git a/agents/test-support/build.gradle b/agents/test-support/build.gradle
new file mode 100644
index 0000000..0769fc7
--- /dev/null
+++ b/agents/test-support/build.gradle
@@ -0,0 +1,4 @@
+dependencies {
+    api 'org.junit.jupiter:junit-jupiter-api:5.11.4'
+    implementation project(':common')
+}
diff --git a/agents/test-support/src/main/java/com/dbx/agent/test/JdbcAgentFake.java b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcAgentFake.java
new file mode 100644
index 0000000..7665fea
--- /dev/null
+++ b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcAgentFake.java
@@ -0,0 +1,177 @@
+package com.dbx.agent.test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Statement;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class JdbcAgentFake {
+    public static final JdbcAgentFake INSTANCE = new JdbcAgentFake();
+    public static final List<String> calls = new ArrayList<String>();
+
+    private JdbcAgentFake() {
+    }
+
+    public static Connection connection() {
+        calls.clear();
+        Statement statement = statement();
+        return proxy(Connection.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("createStatement".equals(name)) {
+                    return statement;
+                }
+                if ("getAutoCommit".equals(name)) {
+                    return true;
+                }
+                if ("setAutoCommit".equals(name) || "commit".equals(name) || "rollback".equals(name) || "close".equals(name)) {
+                    return null;
+                }
+                if ("isClosed".equals(name)) {
+                    return false;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    public List<String> getCalls() {
+        return calls;
+    }
+
+    private static Statement statement() {
+        ResultSet resultSet = resultSet();
+        return proxy(Statement.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("execute".equals(name)) {
+                    calls.add("execute");
+                    return true;
+                }
+                if ("executeQuery".equals(name)) {
+                    calls.add("executeQuery");
+                    return resultSet;
+                }
+                if ("executeUpdate".equals(name)) {
+                    calls.add("executeUpdate");
+                    return 0;
+                }
+                if ("getResultSet".equals(name)) {
+                    return resultSet;
+                }
+                if ("getUpdateCount".equals(name)) {
+                    return 0;
+                }
+                if ("setMaxRows".equals(name)) {
+                    calls.add("setMaxRows:" + args[0]);
+                    return null;
+                }
+                if ("setFetchSize".equals(name)) {
+                    calls.add("setFetchSize:" + args[0]);
+                    return null;
+                }
+                if ("close".equals(name)) {
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static ResultSet resultSet() {
+        final int[] index = {-1};
+        ResultSetMetaData metadata = metadata();
+        return proxy(ResultSet.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("next".equals(name)) {
+                    index[0] += 1;
+                    return index[0] == 0;
+                }
+                if ("getMetaData".equals(name)) {
+                    return metadata;
+                }
+                if ("getObject".equals(name) || "getString".equals(name)) {
+                    return "row-value";
+                }
+                if ("wasNull".equals(name)) {
+                    return false;
+                }
+                if ("close".equals(name)) {
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static ResultSetMetaData metadata() {
+        return proxy(ResultSetMetaData.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("getColumnCount".equals(name)) {
+                    return 1;
+                }
+                if ("getColumnLabel".equals(name)) {
+                    return "VALUE";
+                }
+                if ("getColumnType".equals(name)) {
+                    return Types.VARCHAR;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static <T> T proxy(Class<T> type, final MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) {
+                return handler.handle(method, args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Byte.TYPE.equals(type)) {
+            return (byte) 0;
+        }
+        if (Short.TYPE.equals(type)) {
+            return (short) 0;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        if (Long.TYPE.equals(type)) {
+            return 0L;
+        }
+        if (Float.TYPE.equals(type)) {
+            return 0f;
+        }
+        if (Double.TYPE.equals(type)) {
+            return 0.0d;
+        }
+        if (Character.TYPE.equals(type)) {
+            return '\0';
+        }
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args);
+    }
+}
diff --git a/agents/test-support/src/main/java/com/dbx/agent/test/JdbcConnectedAgentTest.java b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcConnectedAgentTest.java
new file mode 100644
index 0000000..664e3cb
--- /dev/null
+++ b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcConnectedAgentTest.java
@@ -0,0 +1,18 @@
+package com.dbx.agent.test;
+
+import com.dbx.agent.DatabaseAgent;
+
+import java.util.function.Consumer;
+
+public abstract class JdbcConnectedAgentTest {
+    protected abstract DatabaseAgent createConnectedAgent(String databaseName);
+
+    protected void withAgent(String databaseName, Consumer<DatabaseAgent> block) {
+        DatabaseAgent agent = createConnectedAgent(databaseName);
+        try {
+            block.accept(agent);
+        } finally {
+            agent.disconnect();
+        }
+    }
+}
diff --git a/agents/test-support/src/main/java/com/dbx/agent/test/JdbcExecutionBehaviorTest.java b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcExecutionBehaviorTest.java
new file mode 100644
index 0000000..6764a5f
--- /dev/null
+++ b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcExecutionBehaviorTest.java
@@ -0,0 +1,174 @@
+package com.dbx.agent.test;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.JdbcExecutor;
+import com.dbx.agent.QueryPageOptions;
+import com.dbx.agent.QueryPageResult;
+import com.dbx.agent.QueryResult;
+import org.junit.jupiter.api.Test;
+
+import java.sql.Connection;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public abstract class JdbcExecutionBehaviorTest extends JdbcConnectedAgentTest {
+    protected abstract String resultSetSql();
+
+    protected abstract List<String> expectedResultSetColumns();
+
+    protected abstract List<List<Object>> expectedResultSetRows();
+
+    protected abstract String rowsSql(int rowCount);
+
+    @Test
+    void executesStatementsThatReturnResultSetsWithoutSelectPrefix() {
+        withAgent("dbx-agent-result-set", agent -> {
+            QueryResult result = agent.executeQuery(resultSetSql(), null, new ExecuteQueryOptions());
+
+            assertEquals(expectedResultSetColumns(), result.getColumns());
+            assertEquals(expectedResultSetRows(), result.getRows());
+            assertEquals(0, result.getAffected_rows());
+            assertFalse(result.getTruncated());
+        });
+    }
+
+    @Test
+    void doesNotMarkExactlyMaxRowsAsTruncated() {
+        withAgent("dbx-agent-limit", agent -> {
+            QueryResult result = agent.executeQuery(rowsSql(JdbcExecutor.DEFAULT_MAX_ROWS), null, new ExecuteQueryOptions());
+
+            assertEquals(JdbcExecutor.DEFAULT_MAX_ROWS, result.getRows().size());
+            assertFalse(result.getTruncated());
+        });
+    }
+
+    @Test
+    void marksResultsBeyondMaxRowsAsTruncated() {
+        withAgent("dbx-agent-truncated", agent -> {
+            QueryResult result = agent.executeQuery(rowsSql(JdbcExecutor.DEFAULT_MAX_ROWS + 1), null, new ExecuteQueryOptions());
+
+            assertEquals(JdbcExecutor.DEFAULT_MAX_ROWS, result.getRows().size());
+            assertTrue(result.getTruncated());
+        });
+    }
+
+    @Test
+    void fetchesSubsequentResultPagesFromTheSameJdbcSession() {
+        withAgent("dbx-agent-session-pages", agent -> {
+            QueryPageResult first = agent.executeQueryPage(rowsSql(5), null, new QueryPageOptions(2, 2, 10));
+
+            assertEquals(Arrays.asList(Collections.singletonList(1L), Collections.singletonList(2L)), first.getRows());
+            assertTrue(first.getHas_more());
+            assertFalse(first.getTruncated());
+            String sessionId = first.getSession_id();
+            assertNotNull(sessionId);
+
+            QueryPageResult second = agent.fetchQueryPage(sessionId, 2);
+
+            assertEquals(Arrays.asList(Collections.singletonList(3L), Collections.singletonList(4L)), second.getRows());
+            assertTrue(second.getHas_more());
+            assertFalse(second.getTruncated());
+
+            QueryPageResult third = agent.fetchQueryPage(sessionId, 2);
+
+            assertEquals(Collections.singletonList(Collections.singletonList(5L)), third.getRows());
+            assertFalse(third.getHas_more());
+            assertFalse(third.getTruncated());
+        });
+    }
+
+    @Test
+    void fetchesTableReadPagesFromTheSameJdbcSession() {
+        withAgent("dbx-agent-table-read-session-pages", agent -> {
+            QueryPageResult first = agent.startTableRead(rowsSql(5), null, new QueryPageOptions(2, 2, 10));
+
+            assertEquals(Arrays.asList(Collections.singletonList(1L), Collections.singletonList(2L)), first.getRows());
+            assertTrue(first.getHas_more());
+            assertFalse(first.getTruncated());
+            String sessionId = first.getSession_id();
+            assertNotNull(sessionId);
+
+            QueryPageResult second = agent.fetchTableReadPage(sessionId, 2);
+
+            assertEquals(Arrays.asList(Collections.singletonList(3L), Collections.singletonList(4L)), second.getRows());
+            assertTrue(second.getHas_more());
+            assertFalse(second.getTruncated());
+
+            QueryPageResult third = agent.fetchTableReadPage(sessionId, 2);
+
+            assertEquals(Collections.singletonList(Collections.singletonList(5L)), third.getRows());
+            assertFalse(third.getHas_more());
+            assertFalse(third.getTruncated());
+            assertFalse(agent.closeTableReadSession(sessionId));
+        });
+    }
+
+    @Test
+    void closesJdbcResultSessionsExplicitly() {
+        withAgent("dbx-agent-session-close", agent -> {
+            QueryPageResult first = agent.executeQueryPage(rowsSql(5), null, new QueryPageOptions(2, 2, 10));
+            String sessionId = first.getSession_id();
+            assertNotNull(sessionId);
+
+            assertTrue(agent.closeQuerySession(sessionId));
+            assertFalse(agent.closeQuerySession(sessionId));
+            assertThrows(IllegalArgumentException.class, () -> agent.fetchQueryPage(sessionId, 2));
+        });
+    }
+
+    @Test
+    void expiresIdleJdbcResultSessions() {
+        withAgent("dbx-agent-session-expiry", agent -> {
+            QueryPageResult first = agent.executeQueryPage(rowsSql(5), null, new QueryPageOptions(2, 2, 10));
+            String sessionId = first.getSession_id();
+            assertNotNull(sessionId);
+
+            assertEquals(1, JdbcExecutor.INSTANCE.expireIdleQuerySessions(System.currentTimeMillis(), 0L));
+            assertThrows(IllegalArgumentException.class, () -> agent.fetchQueryPage(sessionId, 2));
+        });
+    }
+
+    @Test
+    void handlesTransactionControlStatementsConsistently() {
+        withAgent("dbx-agent-transaction", agent -> {
+            Connection connection = agent.getConnection();
+            assertNotNull(connection);
+
+            try {
+                QueryResult begin = agent.executeQuery("BEGIN", null, new ExecuteQueryOptions());
+                assertFalse(connection.getAutoCommit());
+                assertEquals(Collections.emptyList(), begin.getColumns());
+                assertEquals(Collections.emptyList(), begin.getRows());
+                assertEquals(0, begin.getAffected_rows());
+                assertFalse(begin.getTruncated());
+
+                QueryResult commit = agent.executeQuery("COMMIT", null, new ExecuteQueryOptions());
+                assertTrue(connection.getAutoCommit());
+                assertEquals(Collections.emptyList(), commit.getColumns());
+                assertEquals(Collections.emptyList(), commit.getRows());
+                assertEquals(0, commit.getAffected_rows());
+                assertFalse(commit.getTruncated());
+
+                agent.executeQuery("BEGIN", null, new ExecuteQueryOptions());
+                assertFalse(connection.getAutoCommit());
+
+                QueryResult rollback = agent.executeQuery("ROLLBACK", null, new ExecuteQueryOptions());
+                assertTrue(connection.getAutoCommit());
+                assertEquals(Collections.emptyList(), rollback.getColumns());
+                assertEquals(Collections.emptyList(), rollback.getRows());
+                assertEquals(0, rollback.getAffected_rows());
+                assertFalse(rollback.getTruncated());
+            } catch (Exception e) {
+                throw new AssertionError(e);
+            }
+        });
+    }
+}
diff --git a/agents/test-support/src/main/java/com/dbx/agent/test/JdbcFakeExecutionBehaviorTest.java b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcFakeExecutionBehaviorTest.java
new file mode 100644
index 0000000..18f554d
--- /dev/null
+++ b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcFakeExecutionBehaviorTest.java
@@ -0,0 +1,69 @@
+package com.dbx.agent.test;
+
+import com.dbx.agent.DatabaseAgent;
+import com.dbx.agent.ExecuteQueryOptions;
+import com.dbx.agent.QueryPageOptions;
+import com.dbx.agent.QueryPageResult;
+import com.dbx.agent.QueryResult;
+import org.junit.jupiter.api.Test;
+
+import java.util.Collections;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public abstract class JdbcFakeExecutionBehaviorTest {
+    protected abstract DatabaseAgent createAgent();
+
+    protected abstract String resultSetSql();
+
+    @Test
+    protected void executesNonSelectStatementsThatReturnResultSets() {
+        DatabaseAgent agent = createAgent();
+        TestSupport.setPrivateConnection(agent, JdbcAgentFake.connection());
+
+        QueryResult result = agent.executeQuery(resultSetSql(), null, new ExecuteQueryOptions());
+
+        assertEquals(Collections.singletonList("VALUE"), result.getColumns());
+        assertEquals(Collections.singletonList(Collections.singletonList("row-value")), result.getRows());
+        assertEquals(asList("setMaxRows:10001", "execute"), JdbcAgentFake.calls);
+    }
+
+    @Test
+    protected void appliesExecutionRowAndFetchLimitsToJdbcStatements() {
+        DatabaseAgent agent = createAgent();
+        TestSupport.setPrivateConnection(agent, JdbcAgentFake.connection());
+
+        QueryResult result = agent.executeQuery(resultSetSql(), null, new ExecuteQueryOptions(1, 25));
+
+        assertEquals(Collections.singletonList(Collections.singletonList("row-value")), result.getRows());
+        assertEquals(asList("setMaxRows:2", "setFetchSize:25", "execute"), JdbcAgentFake.calls);
+    }
+
+    @Test
+    protected void pagedQueryExecutionPassesCallerFetchSizeToStatement() {
+        DatabaseAgent agent = createAgent();
+        TestSupport.setPrivateConnection(agent, JdbcAgentFake.connection());
+
+        agent.executeQueryPage(resultSetSql(), null, new QueryPageOptions(100, 500, 1000));
+
+        assertEquals(asList("setFetchSize:500", "execute"), JdbcAgentFake.calls);
+    }
+
+    @Test
+    protected void tableReadPassesCallerFetchSizeToStatement() {
+        DatabaseAgent agent = createAgent();
+        TestSupport.setPrivateConnection(agent, JdbcAgentFake.connection());
+
+        agent.startTableRead(resultSetSql(), null, new QueryPageOptions(100, 500, 1000));
+
+        assertEquals(asList("setFetchSize:500", "execute"), JdbcAgentFake.calls);
+    }
+
+    protected static java.util.List<String> asList(String first, String second) {
+        return java.util.Arrays.asList(first, second);
+    }
+
+    protected static java.util.List<String> asList(String first, String second, String third) {
+        return java.util.Arrays.asList(first, second, third);
+    }
+}
diff --git a/agents/test-support/src/main/java/com/dbx/agent/test/JdbcMetadataBehaviorTest.java b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcMetadataBehaviorTest.java
new file mode 100644
index 0000000..9ef0b26
--- /dev/null
+++ b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcMetadataBehaviorTest.java
@@ -0,0 +1,67 @@
+package com.dbx.agent.test;
+
+import com.dbx.agent.ColumnInfo;
+import com.dbx.agent.TableInfo;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public abstract class JdbcMetadataBehaviorTest extends JdbcConnectedAgentTest {
+    protected abstract List<String> metadataFixtureSql();
+
+    protected abstract String metadataSchema();
+
+    protected abstract List<String> expectedTablesInOrder();
+
+    protected abstract String metadataColumnsTable();
+
+    protected abstract List<String> expectedColumnsInOrder();
+
+    @Test
+    void returnsMetadataInStableOrder() {
+        withAgent("dbx-agent-metadata", agent -> {
+            for (String sql : metadataFixtureSql()) {
+                agent.executeQuery(sql, metadataSchema(), new com.dbx.agent.ExecuteQueryOptions());
+            }
+
+            List<String> expectedTables = expectedTablesInOrder();
+            List<String> tableNames = new ArrayList<String>();
+            for (TableInfo table : agent.listTables(metadataSchema())) {
+                if (expectedTables.contains(table.getName())) {
+                    tableNames.add(table.getName());
+                }
+            }
+            assertEquals(expectedTables, tableNames);
+
+            List<String> expectedColumns = expectedColumnsInOrder();
+            List<String> columnNames = new ArrayList<String>();
+            for (ColumnInfo column : agent.getColumns(metadataSchema(), metadataColumnsTable())) {
+                if (expectedColumns.contains(column.getName())) {
+                    columnNames.add(column.getName());
+                }
+            }
+            assertEquals(expectedColumns, columnNames);
+        });
+    }
+
+    @Test
+    void buildsTableDdlFromMetadata() {
+        withAgent("dbx-agent-ddl", agent -> {
+            for (String sql : metadataFixtureSql()) {
+                agent.executeQuery(sql, metadataSchema(), new com.dbx.agent.ExecuteQueryOptions());
+            }
+
+            String ddl = agent.getTableDdl(metadataSchema(), metadataColumnsTable());
+
+            for (String column : expectedColumnsInOrder()) {
+                assertTrue(ddl.contains("\"" + column + "\""), "DDL should include column " + column + ": " + ddl);
+            }
+            assertTrue(ddl.contains("CREATE TABLE"), "DDL should include CREATE TABLE: " + ddl);
+            assertTrue(ddl.contains(metadataColumnsTable()), "DDL should include table name: " + ddl);
+        });
+    }
+}
diff --git a/agents/test-support/src/main/java/com/dbx/agent/test/JdbcMetadataSqlFake.java b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcMetadataSqlFake.java
new file mode 100644
index 0000000..3482872
--- /dev/null
+++ b/agents/test-support/src/main/java/com/dbx/agent/test/JdbcMetadataSqlFake.java
@@ -0,0 +1,172 @@
+package com.dbx.agent.test;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class JdbcMetadataSqlFake {
+    public static final JdbcMetadataSqlFake INSTANCE = new JdbcMetadataSqlFake();
+    public static final List<String> statements = new ArrayList<String>();
+
+    private JdbcMetadataSqlFake() {
+    }
+
+    public static Connection connection() {
+        statements.clear();
+        return proxy(Connection.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("createStatement".equals(name)) {
+                    return statement();
+                }
+                if ("prepareStatement".equals(name)) {
+                    statements.add((String) args[0]);
+                    return preparedStatement();
+                }
+                if ("getAutoCommit".equals(name)) {
+                    return true;
+                }
+                if ("setAutoCommit".equals(name) || "commit".equals(name) || "rollback".equals(name) || "close".equals(name)) {
+                    return null;
+                }
+                if ("isClosed".equals(name)) {
+                    return false;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    public List<String> getStatements() {
+        return statements;
+    }
+
+    private static Statement statement() {
+        ResultSet resultSet = emptyResultSet();
+        return proxy(Statement.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("execute".equals(name) || "executeQuery".equals(name)) {
+                    statements.add((String) args[0]);
+                    return "execute".equals(name) ? false : resultSet;
+                }
+                if ("getResultSet".equals(name)) {
+                    return resultSet;
+                }
+                if ("getUpdateCount".equals(name)) {
+                    return 0;
+                }
+                if ("setMaxRows".equals(name) || "close".equals(name)) {
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static PreparedStatement preparedStatement() {
+        ResultSet resultSet = emptyResultSet();
+        return proxy(PreparedStatement.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("execute".equals(name) || "executeQuery".equals(name)) {
+                    return "execute".equals(name) ? false : resultSet;
+                }
+                if ("getResultSet".equals(name)) {
+                    return resultSet;
+                }
+                if ("getUpdateCount".equals(name)) {
+                    return 0;
+                }
+                if ("setString".equals(name) || "setInt".equals(name) || "setObject".equals(name)) {
+                    statements.add("param:" + args[0] + "=" + args[1]);
+                    return null;
+                }
+                if ("setMaxRows".equals(name) || "close".equals(name)) {
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static ResultSet emptyResultSet() {
+        ResultSetMetaData metadata = proxy(ResultSetMetaData.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                if ("getColumnCount".equals(method.getName())) {
+                    return 0;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+        return proxy(ResultSet.class, new MethodHandler() {
+            @Override
+            public Object handle(Method method, Object[] args) {
+                String name = method.getName();
+                if ("next".equals(name)) {
+                    return false;
+                }
+                if ("getMetaData".equals(name)) {
+                    return metadata;
+                }
+                if ("close".equals(name)) {
+                    return null;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        });
+    }
+
+    private static <T> T proxy(Class<T> type, final MethodHandler handler) {
+        InvocationHandler invocationHandler = new InvocationHandler() {
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) {
+                return handler.handle(method, args);
+            }
+        };
+        return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
+    }
+
+    private static Object defaultValue(Class<?> type) {
+        if (Boolean.TYPE.equals(type)) {
+            return false;
+        }
+        if (Byte.TYPE.equals(type)) {
+            return (byte) 0;
+        }
+        if (Short.TYPE.equals(type)) {
+            return (short) 0;
+        }
+        if (Integer.TYPE.equals(type)) {
+            return 0;
+        }
+        if (Long.TYPE.equals(type)) {
+            return 0L;
+        }
+        if (Float.TYPE.equals(type)) {
+            return 0f;
+        }
+        if (Double.TYPE.equals(type)) {
+            return 0.0d;
+        }
+        if (Character.TYPE.equals(type)) {
+            return '\0';
+        }
+        return null;
+    }
+
+    private interface MethodHandler {
+        Object handle(Method method, Object[] args);
+    }
+}
diff --git a/agents/test-support/src/main/java/com/dbx/agent/test/TestSupport.java b/agents/test-support/src/main/java/com/dbx/agent/test/TestSupport.java
new file mode 100644
index 0000000..aaddefa
--- /dev/null
+++ b/agents/test-support/src/main/java/com/dbx/agent/test/TestSupport.java
@@ -0,0 +1,31 @@
+package com.dbx.agent.test;
+
+import java.lang.reflect.Field;
+import java.sql.Connection;
+
+public final class TestSupport {
+    private TestSupport() {
+    }
+
+    public static void setPrivateConnection(Object target, Connection connection) {
+        Field field = findConnectionField(target.getClass());
+        field.setAccessible(true);
+        try {
+            field.set(target, connection);
+        } catch (IllegalAccessException e) {
+            throw new IllegalStateException("Unable to set connection", e);
+        }
+    }
+
+    private static Field findConnectionField(Class<?> type) {
+        Class<?> current = type;
+        while (current != null) {
+            try {
+                return current.getDeclaredField("connection");
+            } catch (NoSuchFieldException ignored) {
+                current = current.getSuperclass();
+            }
+        }
+        throw new IllegalStateException(new NoSuchFieldException("connection"));
+    }
+}
diff --git a/agents/versions.json b/agents/versions.json
new file mode 100644
index 0000000..960219b
--- /dev/null
+++ b/agents/versions.json
@@ -0,0 +1,43 @@
+{
+  "access": "0.1.27",
+  "bigquery": "0.1.31",
+  "cassandra": "0.1.30",
+  "dameng": "0.1.33",
+  "databend": "0.1.18",
+  "databricks": "0.1.25",
+  "db2": "0.1.30",
+  "exasol": "0.1.25",
+  "firebird": "0.1.25",
+  "gbase8a": "0.1.25",
+  "gbase8s": "0.1.19",
+  "goldendb": "0.1.30",
+  "h2": "0.1.31",
+  "h2-legacy": "0.1.0",
+  "hive": "0.1.30",
+  "spark": "0.1.2",
+  "informix": "0.1.31",
+  "kingbase": "0.1.31",
+  "kylin": "0.1.30",
+  "neo4j": "0.1.30",
+  "oceanbase-oracle": "0.1.25",
+  "oracle": "0.1.34",
+  "snowflake": "0.1.30",
+  "saphana": "0.1.25",
+  "sundb": "0.1.30",
+  "teradata": "0.1.25",
+  "tdengine": "0.1.29",
+  "trino": "0.1.30",
+  "vastbase": "0.1.30",
+  "vertica": "0.1.25",
+  "mongodb": "0.1.31",
+  "highgo": "0.1.28",
+  "yashandb": "0.1.26",
+  "oscar": "0.1.5",
+  "xugu": "0.1.18",
+  "iris": "0.1.21",
+  "iotdb": "0.1.18",
+  "etcd": "0.1.18",
+  "zookeeper": "0.1.8",
+  "kafka": "0.1.3",
+  "sqlserver-legacy": "0.1.1"
+}
diff --git a/apps/README.md b/apps/README.md
new file mode 100644
index 0000000..9b720a1
--- /dev/null
+++ b/apps/README.md
@@ -0,0 +1,9 @@
+# Apps
+
+Runnable DBX applications live here.
+
+## Directories
+
+- `desktop/` - the Vue frontend used by the Tauri desktop app and the Docker/web build.
+
+The Tauri native shell remains in `src-tauri/` because that is the conventional Tauri project location used by the existing build and release tooling.
diff --git a/apps/desktop/components.json b/apps/desktop/components.json
new file mode 100644
index 0000000..d2f0350
--- /dev/null
+++ b/apps/desktop/components.json
@@ -0,0 +1,25 @@
+{
+  "$schema": "https://shadcn-vue.com/schema.json",
+  "style": "reka-nova",
+  "font": "geist-sans",
+  "typescript": true,
+  "tailwind": {
+    "config": "",
+    "css": "apps/desktop/src/styles/globals.css",
+    "baseColor": "neutral",
+    "cssVariables": true,
+    "prefix": ""
+  },
+  "iconLibrary": "lucide",
+  "rtl": false,
+  "aliases": {
+    "components": "@/components",
+    "utils": "@/lib/common/utils",
+    "ui": "@/components/ui",
+    "lib": "@/lib",
+    "composables": "@/composables"
+  },
+  "menuColor": "default",
+  "menuAccent": "subtle",
+  "registries": {}
+}
diff --git a/apps/desktop/index.html b/apps/desktop/index.html
new file mode 100644
index 0000000..a68bf9c
--- /dev/null
+++ b/apps/desktop/index.html
@@ -0,0 +1,28 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/png" href="/favicon.png" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>DBX</title>
+  </head>
+  <body>
+    <div id="root">
+      <style>
+        #root:empty {
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          height: 100vh;
+          font-family: system-ui, sans-serif;
+          color: #888;
+          font-size: 13px;
+        }
+        #root:empty::after {
+          content: "Loading…";
+        }
+      </style>
+    </div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
diff --git a/apps/desktop/public/favicon.png b/apps/desktop/public/favicon.png
new file mode 100644
index 0000000..407755f
Binary files /dev/null and b/apps/desktop/public/favicon.png differ
diff --git a/apps/desktop/public/fonts/Geist-LICENSE.txt b/apps/desktop/public/fonts/Geist-LICENSE.txt
new file mode 100644
index 0000000..98835ac
--- /dev/null
+++ b/apps/desktop/public/fonts/Geist-LICENSE.txt
@@ -0,0 +1,93 @@
+Copyright 2024 The Geist Project Authors (https://github.com/vercel/geist-font) Geist-Italic[wght].ttf: Copyright 2024 The Geist Project Authors (https://github.com/vercel/geist-font)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/apps/desktop/public/fonts/geist-latin-ext-wght-normal.woff2 b/apps/desktop/public/fonts/geist-latin-ext-wght-normal.woff2
new file mode 100644
index 0000000..ba90e20
Binary files /dev/null and b/apps/desktop/public/fonts/geist-latin-ext-wght-normal.woff2 differ
diff --git a/apps/desktop/public/fonts/geist-latin-wght-normal.woff2 b/apps/desktop/public/fonts/geist-latin-wght-normal.woff2
new file mode 100644
index 0000000..991445d
Binary files /dev/null and b/apps/desktop/public/fonts/geist-latin-wght-normal.woff2 differ
diff --git a/apps/desktop/public/icon-preview-black.png b/apps/desktop/public/icon-preview-black.png
new file mode 100644
index 0000000..fec2510
Binary files /dev/null and b/apps/desktop/public/icon-preview-black.png differ
diff --git a/apps/desktop/public/icon-preview-default.png b/apps/desktop/public/icon-preview-default.png
new file mode 100644
index 0000000..e4ccc40
Binary files /dev/null and b/apps/desktop/public/icon-preview-default.png differ
diff --git a/apps/desktop/public/icons/ai/alibabacloud.svg b/apps/desktop/public/icons/ai/alibabacloud.svg
new file mode 100644
index 0000000..c1d8e4f
--- /dev/null
+++ b/apps/desktop/public/icons/ai/alibabacloud.svg
@@ -0,0 +1 @@
+<svg fill="#FF6A00" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Alibaba Cloud</title><path d="M3.996 4.517h5.291L8.01 6.324 4.153 7.506a1.668 1.668 0 0 0-1.165 1.601v5.786a1.668 1.668 0 0 0 1.165 1.6l3.857 1.183 1.277 1.807H3.996A3.996 3.996 0 0 1 0 15.487V8.513a3.996 3.996 0 0 1 3.996-3.996m16.008 0h-5.291l1.277 1.807 3.857 1.182c.715.227 1.17.889 1.165 1.601v5.786a1.668 1.668 0 0 1-1.165 1.6l-3.857 1.183-1.277 1.807h5.291A3.996 3.996 0 0 0 24 15.487V8.513a3.996 3.996 0 0 0-3.996-3.996m-4.007 8.345H8.002v-1.804h7.995Z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/ai/anthropic.svg b/apps/desktop/public/icons/ai/anthropic.svg
new file mode 100644
index 0000000..88dc745
--- /dev/null
+++ b/apps/desktop/public/icons/ai/anthropic.svg
@@ -0,0 +1 @@
+<svg fill="#191919" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Anthropic</title><path d="M17.3041 3.541h-3.6718l6.696 16.918H24Zm-10.6082 0L0 20.459h3.7442l1.3693-3.5527h7.0052l1.3693 3.5528h3.7442L10.5363 3.5409Zm-.3712 10.2232 2.2914-5.9456 2.2914 5.9456Z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/ai/codex.svg b/apps/desktop/public/icons/ai/codex.svg
new file mode 100644
index 0000000..c77ccfd
--- /dev/null
+++ b/apps/desktop/public/icons/ai/codex.svg
@@ -0,0 +1 @@
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Codex</title><path d="M19.503 0H4.496A4.496 4.496 0 000 4.496v15.007A4.496 4.496 0 004.496 24h15.007A4.496 4.496 0 0024 19.503V4.496A4.496 4.496 0 0019.503 0z" fill="#fff"></path><path d="M9.064 3.344a4.578 4.578 0 012.285-.312c1 .115 1.891.54 2.673 1.275.01.01.024.017.037.021a.09.09 0 00.043 0 4.55 4.55 0 013.046.275l.047.022.116.057a4.581 4.581 0 012.188 2.399c.209.51.313 1.041.315 1.595a4.24 4.24 0 01-.134 1.223.123.123 0 00.03.115c.594.607.988 1.33 1.183 2.17.289 1.425-.007 2.71-.887 3.854l-.136.166a4.548 4.548 0 01-2.201 1.388.123.123 0 00-.081.076c-.191.551-.383 1.023-.74 1.494-.9 1.187-2.222 1.846-3.711 1.838-1.187-.006-2.239-.44-3.157-1.302a.107.107 0 00-.105-.024c-.388.125-.78.143-1.204.138a4.441 4.441 0 01-1.945-.466 4.544 4.544 0 01-1.61-1.335c-.152-.202-.303-.392-.414-.617a5.81 5.81 0 01-.37-.961 4.582 4.582 0 01-.014-2.298.124.124 0 00.006-.056.085.085 0 00-.027-.048 4.467 4.467 0 01-1.034-1.651 3.896 3.896 0 01-.251-1.192 5.189 5.189 0 01.141-1.6c.337-1.112.982-1.985 1.933-2.618.212-.141.413-.251.601-.33.215-.089.43-.164.646-.227a.098.098 0 00.065-.066 4.51 4.51 0 01.829-1.615 4.535 4.535 0 011.837-1.388zm3.482 10.565a.637.637 0 000 1.272h3.636a.637.637 0 100-1.272h-3.636zM8.462 9.23a.637.637 0 00-1.106.631l1.272 2.224-1.266 2.136a.636.636 0 101.095.649l1.454-2.455a.636.636 0 00.005-.64L8.462 9.23z" fill="url(#lobe-icons-codex-_R_0_)"></path><defs><linearGradient gradientUnits="userSpaceOnUse" id="lobe-icons-codex-_R_0_" x1="12" x2="12" y1="3" y2="21"><stop stop-color="#B1A7FF"></stop><stop offset=".5" stop-color="#7A9DFF"></stop><stop offset="1" stop-color="#3941FF"></stop></linearGradient></defs></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/ai/deepseek.svg b/apps/desktop/public/icons/ai/deepseek.svg
new file mode 100644
index 0000000..185c108
--- /dev/null
+++ b/apps/desktop/public/icons/ai/deepseek.svg
@@ -0,0 +1 @@
+<svg fill="#5786FE" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>DeepSeek</title><path d="M23.748 4.651c-.254-.124-.364.113-.512.233-.051.04-.094.09-.137.137-.372.397-.806.657-1.373.626-.829-.046-1.537.214-2.163.848-.133-.782-.575-1.248-1.247-1.548-.352-.155-.708-.311-.955-.65-.172-.24-.219-.509-.305-.774-.055-.16-.11-.323-.293-.35-.2-.031-.278.136-.356.276-.313.572-.434 1.202-.422 1.84.027 1.436.633 2.58 1.838 3.393.137.094.172.187.129.323-.082.28-.18.553-.266.833-.055.179-.137.218-.328.14a5.5 5.5 0 0 1-1.737-1.179c-.857-.828-1.631-1.743-2.597-2.46a12 12 0 0 0-.689-.47c-.985-.957.13-1.743.387-1.836.27-.098.094-.433-.778-.428-.872.003-1.67.295-2.687.685a3 3 0 0 1-.465.136 9.6 9.6 0 0 0-2.883-.101c-1.885.21-3.39 1.1-4.497 2.622C.082 8.776-.231 10.854.152 13.02c.403 2.284 1.568 4.175 3.36 5.653 1.857 1.533 3.997 2.284 6.438 2.14 1.482-.085 3.132-.284 4.994-1.86.47.234.962.328 1.78.398.629.058 1.235-.031 1.705-.129.735-.155.684-.836.418-.961-2.155-1.004-1.682-.595-2.112-.926 1.095-1.295 2.768-3.598 3.284-6.733.05-.346.115-.834.108-1.114-.004-.171.035-.238.23-.257a4.2 4.2 0 0 0 1.545-.475c1.397-.763 1.96-2.016 2.093-3.517.02-.23-.004-.467-.247-.588M11.58 18.168c-2.088-1.642-3.101-2.183-3.52-2.16-.39.024-.32.472-.234.763.09.288.207.487.371.74.114.167.192.416-.113.603-.673.416-1.842-.14-1.897-.168-1.361-.801-2.5-1.86-3.301-3.306-.775-1.393-1.225-2.888-1.299-4.482-.02-.385.094-.522.477-.592a4.7 4.7 0 0 1 1.53-.038c2.131.311 3.946 1.264 5.467 2.774.868.86 1.525 1.887 2.202 2.89.72 1.066 1.494 2.082 2.48 2.915.348.291.626.513.892.677-.802.09-2.14.109-3.055-.615zm1.001-6.44a.306.306 0 0 1 .415-.287.3.3 0 0 1 .113.074.3.3 0 0 1 .086.214c0 .17-.136.307-.308.307a.303.303 0 0 1-.306-.307m3.11 1.596c-.2.081-.4.151-.591.16a1.25 1.25 0 0 1-.798-.254c-.274-.23-.47-.358-.551-.758a1.7 1.7 0 0 1 .015-.588c.07-.327-.007-.537-.238-.727-.188-.156-.426-.199-.689-.199a.6.6 0 0 1-.254-.078.253.253 0 0 1-.114-.358 1 1 0 0 1 .192-.21c.356-.202.767-.136 1.146.016.352.144.618.408 1.001.782.392.451.462.576.685.915.176.264.336.536.446.848.066.194-.02.353-.25.45"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/ai/googlegemini.svg b/apps/desktop/public/icons/ai/googlegemini.svg
new file mode 100644
index 0000000..e15e53c
--- /dev/null
+++ b/apps/desktop/public/icons/ai/googlegemini.svg
@@ -0,0 +1 @@
+<svg fill="#8E75B2" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Google Gemini</title><path d="M11.04 19.32Q12 21.51 12 24q0-2.49.93-4.68.96-2.19 2.58-3.81t3.81-2.55Q21.51 12 24 12q-2.49 0-4.68-.93a12.3 12.3 0 0 1-3.81-2.58 12.3 12.3 0 0 1-2.58-3.81Q12 2.49 12 0q0 2.49-.96 4.68-.93 2.19-2.55 3.81a12.3 12.3 0 0 1-3.81 2.58Q2.49 12 0 12q2.49 0 4.68.96 2.19.93 3.81 2.55t2.55 3.81"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/ai/ollama.svg b/apps/desktop/public/icons/ai/ollama.svg
new file mode 100644
index 0000000..432f73e
--- /dev/null
+++ b/apps/desktop/public/icons/ai/ollama.svg
@@ -0,0 +1 @@
+<svg fill="#000000" role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><title>Ollama</title><path d="M16.361 10.26a.894.894 0 0 0-.558.47l-.072.148.001.207c0 .193.004.217.059.353.076.193.152.312.291.448.24.238.51.3.872.205a.86.86 0 0 0 .517-.436.752.752 0 0 0 .08-.498c-.064-.453-.33-.782-.724-.897a1.06 1.06 0 0 0-.466 0zm-9.203.005c-.305.096-.533.32-.65.639a1.187 1.187 0 0 0-.06.52c.057.309.31.59.598.667.362.095.632.033.872-.205.14-.136.215-.255.291-.448.055-.136.059-.16.059-.353l.001-.207-.072-.148a.894.894 0 0 0-.565-.472 1.02 1.02 0 0 0-.474.007Zm4.184 2c-.131.071-.223.25-.195.383.031.143.157.288.353.407.105.063.112.072.117.136.004.038-.01.146-.029.243-.02.094-.036.194-.036.222.002.074.07.195.143.253.064.052.076.054.255.059.164.005.198.001.264-.03.169-.082.212-.234.15-.525-.052-.243-.042-.28.087-.355.137-.08.281-.219.324-.314a.365.365 0 0 0-.175-.48.394.394 0 0 0-.181-.033c-.126 0-.207.03-.355.124l-.085.053-.053-.032c-.219-.13-.259-.145-.391-.143a.396.396 0 0 0-.193.032zm.39-2.195c-.373.036-.475.05-.654.086-.291.06-.68.195-.951.328-.94.46-1.589 1.226-1.787 2.114-.04.176-.045.234-.045.53 0 .294.005.357.043.524.264 1.16 1.332 2.017 2.714 2.173.3.033 1.596.033 1.896 0 1.11-.125 2.064-.727 2.493-1.571.114-.226.169-.372.22-.602.039-.167.044-.23.044-.523 0-.297-.005-.355-.045-.531-.288-1.29-1.539-2.304-3.072-2.497a6.873 6.873 0 0 0-.855-.031zm.645.937a3.283 3.283 0 0 1 1.44.514c.223.148.537.458.671.662.166.251.26.508.303.82.02.143.01.251-.043.482-.08.345-.332.705-.672.957a3.115 3.115 0 0 1-.689.348c-.382.122-.632.144-1.525.138-.582-.006-.686-.01-.853-.042-.57-.107-1.022-.334-1.35-.68-.264-.28-.385-.535-.45-.946-.03-.192.025-.509.137-.776.136-.326.488-.73.836-.963.403-.269.934-.46 1.422-.512.187-.02.586-.02.773-.002zm-5.503-11a1.653 1.653 0 0 0-.683.298C5.617.74 5.173 1.666 4.985 2.819c-.07.436-.119 1.04-.119 1.503 0 .544.064 1.24.155 1.721.02.107.031.202.023.208a8.12 8.12 0 0 1-.187.152 5.324 5.324 0 0 0-.949 1.02 5.49 5.49 0 0 0-.94 2.339 6.625 6.625 0 0 0-.023 1.357c.091.78.325 1.438.727 2.04l.13.195-.037.064c-.269.452-.498 1.105-.605 1.732-.084.496-.095.629-.095 1.294 0 .67.009.803.088 1.266.095.555.288 1.143.503 1.534.071.128.243.393.264.407.007.003-.014.067-.046.141a7.405 7.405 0 0 0-.548 1.873c-.062.417-.071.552-.071.991 0 .56.031.832.148 1.279L3.42 24h1.478l-.05-.091c-.297-.552-.325-1.575-.068-2.597.117-.472.25-.819.498-1.296l.148-.29v-.177c0-.165-.003-.184-.057-.293a.915.915 0 0 0-.194-.25 1.74 1.74 0 0 1-.385-.543c-.424-.92-.506-2.286-.208-3.451.124-.486.329-.918.544-1.154a.787.787 0 0 0 .223-.531c0-.195-.07-.355-.224-.522a3.136 3.136 0 0 1-.817-1.729c-.14-.96.114-2.005.69-2.834.563-.814 1.353-1.336 2.237-1.475.199-.033.57-.028.776.01.226.04.367.028.512-.041.179-.085.268-.19.374-.431.093-.215.165-.333.36-.576.234-.29.46-.489.822-.729.413-.27.884-.467 1.352-.561.17-.035.25-.04.569-.04.319 0 .398.005.569.04a4.07 4.07 0 0 1 1.914.997c.117.109.398.457.488.602.034.057.095.177.132.267.105.241.195.346.374.43.14.068.286.082.503.045.343-.058.607-.053.943.016 1.144.23 2.14 1.173 2.581 2.437.385 1.108.276 2.267-.296 3.153-.097.15-.193.27-.333.419-.301.322-.301.722-.001 1.053.493.539.801 1.866.708 3.036-.062.772-.26 1.463-.533 1.854a2.096 2.096 0 0 1-.224.258.916.916 0 0 0-.194.25c-.054.109-.057.128-.057.293v.178l.148.29c.248.476.38.823.498 1.295.253 1.008.231 2.01-.059 2.581a.845.845 0 0 0-.044.098c0 .006.329.009.732.009h.73l.02-.074.036-.134c.019-.076.057-.3.088-.516.029-.217.029-1.016 0-1.258-.11-.875-.295-1.57-.597-2.226-.032-.074-.053-.138-.046-.141.008-.005.057-.074.108-.152.376-.569.607-1.284.724-2.228.031-.26.031-1.378 0-1.628-.083-.645-.182-1.082-.348-1.525a6.083 6.083 0 0 0-.329-.7l-.038-.064.131-.194c.402-.604.636-1.262.727-2.04a6.625 6.625 0 0 0-.024-1.358 5.512 5.512 0 0 0-.939-2.339 5.325 5.325 0 0 0-.95-1.02 8.097 8.097 0 0 1-.186-.152.692.692 0 0 1 .023-.208c.208-1.087.201-2.443-.017-3.503-.19-.924-.535-1.658-.98-2.082-.354-.338-.716-.482-1.15-.455-.996.059-1.8 1.205-2.116 3.01a6.805 6.805 0 0 0-.097.726c0 .036-.007.066-.015.066a.96.96 0 0 1-.149-.078A4.857 4.857 0 0 0 12 3.03c-.832 0-1.687.243-2.456.698a.958.958 0 0 1-.148.078c-.008 0-.015-.03-.015-.066a6.71 6.71 0 0 0-.097-.725C8.997 1.392 8.337.319 7.46.048a2.096 2.096 0 0 0-.585-.041Zm.293 1.402c.248.197.523.759.682 1.388.03.113.06.244.069.292.007.047.026.152.041.233.067.365.098.76.102 1.24l.002.475-.12.175-.118.178h-.278c-.324 0-.646.041-.954.124l-.238.06c-.033.007-.038-.003-.057-.144a8.438 8.438 0 0 1 .016-2.323c.124-.788.413-1.501.696-1.711.067-.05.079-.049.157.013zm9.825-.012c.17.126.358.46.498.888.28.854.36 2.028.212 3.145-.019.14-.024.151-.057.144l-.238-.06a3.693 3.693 0 0 0-.954-.124h-.278l-.119-.178-.119-.175.002-.474c.004-.669.066-1.19.214-1.772.157-.623.434-1.185.68-1.382.078-.062.09-.063.159-.012z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/ai/openai.svg b/apps/desktop/public/icons/ai/openai.svg
new file mode 100644
index 0000000..2dd8be2
--- /dev/null
+++ b/apps/desktop/public/icons/ai/openai.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 0 24 24"><path fill="#000000" d="M22.282 9.821a6 6 0 0 0-.516-4.91a6.05 6.05 0 0 0-6.51-2.9A6.065 6.065 0 0 0 4.981 4.18a6 6 0 0 0-3.998 2.9a6.05 6.05 0 0 0 .743 7.097a5.98 5.98 0 0 0 .51 4.911a6.05 6.05 0 0 0 6.515 2.9A6 6 0 0 0 13.26 24a6.06 6.06 0 0 0 5.772-4.206a6 6 0 0 0 3.997-2.9a6.06 6.06 0 0 0-.747-7.073M13.26 22.43a4.48 4.48 0 0 1-2.876-1.04l.141-.081l4.779-2.758a.8.8 0 0 0 .392-.681v-6.737l2.02 1.168a.07.07 0 0 1 .038.052v5.583a4.504 4.504 0 0 1-4.494 4.494M3.6 18.304a4.47 4.47 0 0 1-.535-3.014l.142.085l4.783 2.759a.77.77 0 0 0 .78 0l5.843-3.369v2.332a.08.08 0 0 1-.033.062L9.74 19.95a4.5 4.5 0 0 1-6.14-1.646M2.34 7.896a4.5 4.5 0 0 1 2.366-1.973V11.6a.77.77 0 0 0 .388.677l5.815 3.354l-2.02 1.168a.08.08 0 0 1-.071 0l-4.83-2.786A4.504 4.504 0 0 1 2.34 7.872zm16.597 3.855l-5.833-3.387L15.119 7.2a.08.08 0 0 1 .071 0l4.83 2.791a4.494 4.494 0 0 1-.676 8.105v-5.678a.79.79 0 0 0-.407-.667m2.01-3.023l-.141-.085l-4.774-2.782a.78.78 0 0 0-.785 0L9.409 9.23V6.897a.07.07 0 0 1 .028-.061l4.83-2.787a4.5 4.5 0 0 1 6.68 4.66zm-12.64 4.135l-2.02-1.164a.08.08 0 0 1-.038-.057V6.075a4.5 4.5 0 0 1 7.375-3.453l-.142.08L8.704 5.46a.8.8 0 0 0-.393.681zm1.097-2.365l2.602-1.5l2.607 1.5v2.999l-2.597 1.5l-2.607-1.5Z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/access.png b/apps/desktop/public/icons/database/access.png
new file mode 100644
index 0000000..44138a1
Binary files /dev/null and b/apps/desktop/public/icons/database/access.png differ
diff --git a/apps/desktop/public/icons/database/apache_kylin.svg b/apps/desktop/public/icons/database/apache_kylin.svg
new file mode 100644
index 0000000..7a15a5a
--- /dev/null
+++ b/apps/desktop/public/icons/database/apache_kylin.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="190.51" class="icon" viewBox="0 0 1075 1024"><path fill="#f09d13" d="M556.032 909.312a375 375 0 0 1-86.886-17.408c-79.31-26.01-146.637-78.336-195.84-151.91-13.62-20.43-18.79-32.461-19.559-45.568-.512-9.216.41-13.415 4.352-19.252a19.56 19.56 0 0 1 8.807-7.27c5.632-2.867 6.45-3.072 14.336-2.97 18.227.103 32.614 8.96 49.05 30.106 3.122 3.994 11.878 16.282 19.455 27.29 15.565 22.732 27.392 38.707 37.888 51.353 9.319 11.06 26.112 27.904 35.43 35.328 15.156 12.135 50.996 31.283 76.8 41.114 84.122 32.051 170.394 29.03 256.308-8.96a382.5 382.5 0 0 0 118.63-82.33c10.752-11.264 14.49-14.131 16.487-12.441 1.74 1.382 1.382 6.4-.717 10.496-4.455 8.704-18.79 25.6-36.557 42.905a350.3 350.3 0 0 1-96.973 68.301c-57.753 28.518-115.302 42.086-176.64 41.626-11.52-.103-22.528-.256-24.422-.461zm-57.037-272.538c-7.782-1.382-6.502-9.216 2.816-17.356 7.68-6.656 25.549-15.156 47.309-22.375 14.694-4.864 16.435-6.246 16.384-13.056-.102-10.496-8.55-20.787-31.642-38.4a63.334 63.334 0 0 1-15.564-81.1c9.42-15.617 26.47-28.365 43.417-32.513 29.184-7.116 51.917 1.178 62.464 22.784 4.045 8.192 6.656 17.255 5.837 20.43s-3.38 2.56-9.882-2.407c-9.37-7.168-15.718-9.83-24.73-10.189-9.215-.358-15.052 1.331-20.018 5.786-5.735 5.17-7.168 8.908-7.168 18.432-.052 7.577.204 8.806 2.764 14.233 13.67 28.877 57.959 34.458 88.935 11.162 10.086-7.578 22.528-28.57 26.265-44.083 1.536-6.554 1.792-9.728 1.434-19.15a50.5 50.5 0 0 0-2.97-18.84c-5.632-16.129-12.441-24.833-24.37-31.028-18.228-9.42-41.063-11.93-72.09-7.987-26.42 3.379-54.221 2.15-70.759-3.072-7.219-2.304-9.779-4.147-9.779-7.066 0-2.406.82-2.662 10.906-3.379 15.462-1.126 32.46-5.325 59.852-14.848 9.012-3.072 20.173-6.605 24.832-7.782 28.365-7.168 58.317-9.114 80.384-5.274 9.421 1.638 20.788 7.27 29.44 14.592 25.19 21.3 49.613 64.563 69.376 122.88 6.144 18.074 11.725 30.464 18.33 40.55 14.95 22.733 34.816 36.608 59.904 41.882 2.867.614 10.086 1.075 16.077 1.024a79.36 79.36 0 0 0 36.352-8.5c22.016-10.444 35.43-26.828 42.137-51.609 2.51-9.062 2.765-30.822.512-39.424-5.222-19.558-17.817-32.46-37.632-38.349-8.704-2.56-28.057-3.328-34.201-1.28A31.8 31.8 0 0 0 864.46 450.1c-1.587 3.994-1.997 6.759-2.048 14.49 0 8.601.205 10.086 2.304 14.54 6.297 13.466 18.278 19.815 37.376 19.866 9.42 0 10.905.768 9.933 5.12-1.024 4.864-6.4 8.141-15.872 9.575a60.47 60.47 0 0 1-35.738-4.71 54.73 54.73 0 0 1-26.112-30.311 52.74 52.74 0 0 1-.768-27.546c1.946-7.68 8.243-20.224 13.363-26.521 14.439-17.92 38.451-27.085 64.41-24.679 36.352 3.328 64.512 23.143 76.902 54.17 10.087 25.139 10.445 65.177.768 90.163-13.005 33.792-44.339 59.136-87.04 70.4-34.099 8.96-61.645 8.858-89.241-.307a156.7 156.7 0 0 1-51.508-30.464c-7.987-7.475-10.65-8.397-10.65-3.584 0 2.457 1.23 4.557 6.554 11.11 8.346 10.343 12.135 17.715 11.418 22.272-.717 4.455-3.738 6.912-9.472 7.578-6.707.819-92.262.153-94.003-.717-3.789-1.843.41-11.264 7.321-16.282a39.7 39.7 0 0 1 17.87-7.27c6.655-1.229 8.96-2.714 8.96-5.683 0-.768-1.998-5.274-4.404-10.087a94.4 94.4 0 0 1-8.294-26.214c-.87-4.66-6.4-2.611-11.572 4.25-8.96 12.032-15.155 31.027-19.25 58.88-1.998 13.67-3.073 16.64-6.503 18.227-1.741.768-20.275 1.024-75.162.921a3784 3784 0 0 1-75.059-.512zM201.216 635.7c-66.048-.41-71.168-.563-73.318-1.997-3.072-1.996-3.072-4.966-.103-10.956 8.141-16.23 28.263-27.597 60.826-34.15 20.838-4.25 33.229-9.166 44.595-17.716 13.568-10.189 15.155-19.456 4.3-25.037a91.4 91.4 0 0 1-31.436-28.467c-10.7-16.23-17.869-42.138-17.869-64.512 0-11.622 6.144-34.048 13.056-47.974 10.24-20.48 24.679-34.919 44.851-44.8 13.62-6.656 31.079-10.752 45.364-10.752 3.072 0 5.12-.512 6.45-1.639 1.793-1.433 1.895-1.843.922-4.71-1.433-4.301-7.475-9.626-13.516-11.879-5.632-2.15-12.032-3.072-29.287-4.403a113 113 0 0 1-16.077-2.201 28.57 28.57 0 0 1-14.899-10.138c-2.048-3.072-2.457-4.608-2.457-9.42 0-5.07.41-6.452 3.584-12.238 3.328-6.092 4.71-9.728 7.219-18.944.87-3.072 1.382-3.686 3.277-3.686 1.228 0 3.635 1.126 5.376 2.509 10.598 8.345 42.854 19.251 56.985 19.251 8.909 0 13.107-1.28 16.384-5.069 2.355-2.662 2.611-3.43 2.15-6.605a37.53 37.53 0 0 0-9.727-18.176c-5.12-5.068-15.463-10.342-25.19-12.902a69.5 69.5 0 0 0-18.28-1.946c-12.44-.153-13.465.154-20.377 5.888-5.734 4.813-7.629 4.404-14.029-3.174-15.974-18.944-23.398-38.656-18.79-49.715 1.536-3.584 3.482-4.403 16.947-6.656 5.94-1.024 18.074-3.328 26.983-5.223 35.02-7.321 54.323-9.728 78.49-9.625 20.377 0 21.247-.256 26.726-8.397 7.168-10.752 9.83-21.248 9.83-39.424 0-14.746.666-16.538 5.888-16.538 4.096 0 10.035 2.868 12.954 6.35 5.785 6.86 8.038 15.922 9.01 36.71.615 12.8 1.28 18.432 2.92 24.883 3.378 13.21 5.324 16.179 19.711 30.361 17.869 17.664 23.245 26.164 26.522 42.087 2.611 12.749 1.126 27.853-3.891 39.373-6.247 14.233-20.992 30.617-37.479 41.625-12.749 8.448-27.443 15.463-83.507 39.783-10.752 4.608-22.118 9.728-25.242 11.315-20.275 10.24-39.219 29.593-46.54 47.462-2.048 5.12-2.56 7.68-2.868 16.077-.614 15.616 2.714 26.112 12.288 38.86 6.605 8.705 19.2 18.433 28.672 21.966 11.776 4.352 28.16 4.608 41.882.563 13.414-3.891 28.928-13.107 27.136-16.026-.973-1.536-2.918-1.126-8.909 1.741-22.733 10.854-47.77 12.493-62.003 4.096a74.1 74.1 0 0 1-19.968-20.02c-8.243-13.977-10.854-33.791-6.246-47.257a41.2 41.2 0 0 1 11.315-16.998c8.704-8.448 36.045-22.375 89.241-45.568 31.488-13.824 37.684-16.896 48.64-24.167a134.81 134.81 0 0 0 60.57-113.664 32.3 32.3 0 0 1 .82-9.83c1.023 0 6.86 7.834 11.314 15.104 22.733 37.171 30.567 86.938 19.559 124.826-10.24 35.481-34.355 63.18-64.154 73.728-10.803 3.89-18.995 5.17-31.897 5.12a93.1 93.1 0 0 1-30.925-4.71c-16.896-4.916-29.491-5.377-43.213-1.588-12.493 3.43-18.79 8.5-21.3 17.05a24.83 24.83 0 0 0 2.92 18.739c3.122 5.785 5.99 7.833 11.724 8.294 8.448.666 19.814-5.273 19.814-10.393 0-1.127-2.56-6.452-5.632-11.828a52.7 52.7 0 0 1-5.632-11.93c0-3.225 3.021-4.812 9.063-4.812 7.936 0 13.005 2.765 19.149 10.291 5.734 7.168 10.905 10.855 17.05 12.34 7.474 1.791 8.55 5.734 4.71 17.254-6.35 18.944-22.528 41.113-51.815 71.117a315 315 0 0 0-21.606 23.91 157.4 157.4 0 0 0-20.48 44.39c-3.175 11.11-5.99 13.927-14.848 14.95-1.434.154-34.56.103-73.626-.153zm128.256-17.817c-5.018-2.202-4.608-9.575.82-15.77 4.76-5.478 6.4-5.888 23.602-6.451 14.03-.41 15.616-.615 16.743-2.15a6.86 6.86 0 0 0 1.229-3.482c0-2.919-3.738-11.008-7.68-16.896-6.4-9.319-7.476-12.493-7.527-22.016 0-9.319.87-11.52 6.4-15.258 9.165-6.246 33.946-3.584 58.931 6.298 24.32 9.625 48.18 13.414 83.764 13.414 18.432 0 21.196.205 21.657 1.383.666 1.74-2.048 5.427-5.837 7.987-9.574 6.553-36.966 9.728-69.376 7.987-19.814-1.024-21.76-.666-23.142 4.096-1.536 5.274 1.229 11.52 8.5 19.456 9.778 10.65 10.546 16.18 2.764 20.326-3.584 1.895-3.891 1.895-55.808 2.1-43.52.153-52.736 0-55.04-1.024m566.886-262.656a35.5 35.5 0 0 1-18.432-9.78 880 880 0 0 1-24.37-28.364c-47.463-56.679-62.823-72.807-87.194-91.239a313 313 0 0 0-67.328-37.888c-65.997-25.805-143.002-29.184-221.39-9.625-17.92 4.505-17.407 2.457 1.127-4.762a387.4 387.4 0 0 1 186.368-23.142c95.488 12.185 177.306 60.57 228.25 134.912 18.073 26.419 25.344 41.472 25.395 52.633 0 12.544-8.755 19.303-22.426 17.306z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/bigquery.svg b/apps/desktop/public/icons/database/bigquery.svg
new file mode 100644
index 0000000..a9a42f0
--- /dev/null
+++ b/apps/desktop/public/icons/database/bigquery.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#aecbfa" d="M328.704 465.306v95.385c15.053 25.907 36.352 47.616 62.054 63.079V465.306z"/><path fill="#669df6" d="M443.29 377.549v273.05c13.312 1.689 26.777 2.457 40.243 2.201q18.124 1.076 36.25 0V377.549z"/><path fill="#aecbfa" d="M579.277 502.63v119.296a181.4 181.4 0 0 0 61.645-65.996v-53.248h-61.645z"/><path fill="#4285f4" d="m727.962 664.371-51.508 51.507a15.31 15.31 0 0 0 0 21.76l128.41 128.359a15.206 15.206 0 0 0 21.402 0l51.814-51.866a15.26 15.26 0 0 0 0-21.401L749.722 664.37a15.26 15.26 0 0 0-21.76 0"/><path fill="#669df6" d="M483.533 145.05a326.4 326.4 0 1 0 0 652.8 326.4 326.4 0 0 0 0-652.8m0 568.985a242.278 242.278 0 1 1 .768-484.505 242.278 242.278 0 0 1-.768 484.505"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/cassandra.svg b/apps/desktop/public/icons/database/cassandra.svg
new file mode 100644
index 0000000..fbeedb1
--- /dev/null
+++ b/apps/desktop/public/icons/database/cassandra.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#bae6fa" d="M522.65 317.645c-87.45 1.945-176.384 28.877-277.044 84.582-18.278 21.146-27.699 44.032-25.702 67.277 6.758 78.95 142.029 131.84 302.08 118.118 160.102-13.721 284.365-88.883 277.555-167.833a79.46 79.46 0 0 0-16.691-41.472c-91.597-41.011-175.206-62.618-260.198-60.672"/><path fill="#fff" d="M533.965 317.491c-71.168-.102-142.95 16.077-220.98 50.842a154 154 0 0 0-5.017 39.014c0 93.696 84.582 169.626 188.928 169.626 104.294 0 188.928-75.981 188.928-169.626 0-25.241-6.246-49.152-17.254-70.707a512.5 512.5 0 0 0-134.656-19.149z" opacity=".35"/><path fill="#fff" d="M496.896 310.886c-33.792-2.048-92.109 15.565-140.646 33.178a144.2 144.2 0 0 0-11.52 56.474c0 82.073 74.444 148.633 153.139 148.633 78.182 0 147.405-66.662 153.139-148.633 1.894-26.676-7.322-51.815-20.07-73.524a1317 1317 0 0 0-134.042-16.128"/><path fill="#6a6a6a" d="M410.112 389.786c4.147-9.216 10.445-13.722 16.538-21.402a48 48 0 0 1-2.202-9.882 16.69 16.69 0 0 1 22.886-15.513 121.8 121.8 0 0 1 110.592-19.456c-36.198-4.967-77.004 7.833-104.704 30.208.82 2.048 3.175 7.68 3.175 10.035 0 9.216-5.99 11.469-15.207 11.469a16.9 16.9 0 0 1-5.939-1.127 169.2 169.2 0 0 0-17.715 34.458c15.36 13.722 29.184 18.688 47.258 25.446 0-.819.614-1.638.614-2.56 0-27.801 24.525-50.38 52.326-50.38a50.33 50.33 0 0 1 49.664 41.932c12.442-7.936 24.474-14.028 33.639-25.753a29.7 29.7 0 0 1-4.455-13.62 15.155 15.155 0 0 1 18.637-14.745c4.608-9.626 8.192-19.712 10.394-30.208-43.52-32.205-127.744-27.802-127.744-27.802s-67.021-3.481-112.384 18.637c3.072 21.863 11.776 42.65 24.627 60.263"/><path fill="#6a6a6a" d="M618.138 377.19c3.072 2.765 4.761 5.223 6.092 7.578 4.096 7.322-4.096 14.029-12.441 14.029a15 15 0 0 1-2.56-.256c-9.421 14.745-25.907 33.638-40.602 43.161 22.528 3.738 43.725 12.698 60.621 26.624 12.288-22.016 21.76-53.862 21.76-80.896 0-20.582-9.114-35.635-22.784-46.694-.717 11.008-6.656 26.42-10.086 36.454M435.354 516.813c7.526-20.685 26.01-36.762 43.468-50.893a96 96 0 0 1-7.987-16.23 122.16 122.16 0 0 1-54.784-34.663 110.4 110.4 0 0 0-2.201 38.144 21.965 21.965 0 0 1 17.92 21.555c0 6.4-5.632 15.616-9.933 19.661 4.71 10.138 7.885 15.053 13.568 22.426"/><path fill="#6a6a6a" d="M434.074 534.22c-8.96-8.908-15.156-26.623-20.992-37.785a21 21 0 0 1-3.328.307c-12.135 0-24.832-10.24-21.965-22.016 1.587-6.502 6.144-10.752 13.414-14.336-1.638-13.516-2.099-32.921 1.024-47.001.922-3.994 2.816-5.888 4.096-9.728a128.87 128.87 0 0 1-22.067-70.81l.051-2.765c-22.63 11.367-39.577 29.184-39.577 57.344 0 62.26 35.84 123.392 89.19 147.303zm131.174-86.067a50.38 50.38 0 0 1-78.592 22.886c-17.664 13.773-33.69 37.888-41.83 58.88 3.635 3.942 6.144 7.168 10.29 10.7 12.34 3.226 29.39 0 42.753 0 53.76 0 101.427-23.96 128.768-65.945-18.176-12.544-39.629-24.525-61.389-26.521"/><path fill="#1185b0" d="M408.73 397.056c4.096-9.062 9.267-17.613 15.462-25.395a16.742 16.742 0 0 1 21.811-21.402 121.86 121.86 0 0 1 110.541-19.456 134.14 134.14 0 0 0-101.325 28.519 16.742 16.742 0 0 1-21.35 22.067 112.7 112.7 0 0 0-15.155 27.75c13.21 14.183 29.337 25.447 47.41 32.154-.05-.82-.153-1.69-.153-2.56a50.38 50.38 0 0 1 100.045-8.448 131.5 131.5 0 0 0 32.666-29.85 15.155 15.155 0 0 1 15.155-24.269c4.659-9.574 8.192-19.712 10.393-30.208-43.52-32.204-127.744-27.801-127.744-27.801s-67.02-3.482-112.384 18.637c3.072 21.862 11.776 42.65 24.628 60.262"/><path fill="#1185b0" d="M620.493 379.7a15 15 0 0 1 .614 21.913 15.2 15.2 0 0 1-13.21 4.198 122.7 122.7 0 0 1-36.659 36.864 122.34 122.34 0 0 1 59.034 26.522 152.85 152.85 0 0 0 19.354-74.445c0-20.634-9.114-35.686-22.836-46.746a121.8 121.8 0 0 1-6.297 31.693M437.709 521.83c7.526-20.992 20.685-39.424 37.99-53.452a50.2 50.2 0 0 1-6.297-11.418 122.16 122.16 0 0 1-54.682-34.662l-.307 1.382a110.1 110.1 0 0 0-1.895 36.762 21.965 21.965 0 0 1 10.804 37.683c3.993 8.397 8.806 16.333 14.438 23.705z"/><path fill="#1185b0" d="M433.971 534.016a122.1 122.1 0 0 1-22.22-30.31 21.6 21.6 0 0 1-18.945-6.144 22.016 22.016 0 0 1 6.042-35.328 121.55 121.55 0 0 1 5.274-53.3 121.55 121.55 0 0 1-21.248-68.812l.05-2.765c-22.63 11.315-39.577 29.184-39.577 57.344 0 62.31 37.171 115.814 90.522 139.776l.102-.512zm129.895-78.592a50.38 50.38 0 0 1-78.592 22.886 124.8 124.8 0 0 0-39.168 53.504c3.686 3.943 7.577 7.68 11.673 11.11a152.99 152.99 0 0 0 167.117-64.818 128.5 128.5 0 0 0-61.03-22.682"/><path fill="#fff" d="m502.17 395.776-26.42-47.104 14.336 50.022-42.803-31.078 33.485 42.086-53.094-19.507 41.881 30.976-53.76 1.69 54.989 14.182-54.989 11.879 54.272 3.942-45.773 29.338 47.104-17.101-32.665 41.472 41.318-33.383-14.848 55.604 31.898-45.261-4.506 53.453 18.125-48.436 15.462 50.893 3.738-51.046 22.886 43.52-13.516-49.767 41.881 32.41-27.033-41.37 45.977 17.92-35.174-34.56 47.104 3.687-46.387-17.818 46.592-11.059-46.746-2.406 37.99-29.082-43.161 15.462 29.337-40.652-40.448 26.93 14.132-47.564-27.853 39.22-.615-49.562-18.33 44.134-15.206-44.646.82 52.633z"/><path fill="#6a6a6a" d="M69.99 531.558C214.374 387.174 329.728 342.58 434.38 322.202c13.825-2.714 16.436-32.973 16.436-32.973s1.946 22.323 11.622 25.241c9.728 2.868 22.324-34.918 22.324-34.918s-11.623 33.946 0 35.84c11.622 1.946 32.921-32.922 32.921-32.922s-8.704 30.055-2.867 31.95c5.786 1.945 34.816-43.572 34.816-43.572s-17.408 30.054-.922 32.922c16.487 2.918 40.5-20.48 40.5-20.48s-18.893 21.401-10.445 24.37c35.84 12.596 64.87-33.996 64.87-33.996s-6.758 20.48-24.166 42.7c37.785 9.729 65.843-47.206 65.843-47.206l-28.058 56.935c14.541 7.731 72.704-59.136 72.704-59.136s-30.054 52.326-47.513 62.976c9.728 7.782 44.544-23.245 44.544-23.245s-28.058 34.867-17.408 36.864c15.513 12.544 72.704-64.973 72.704-64.973s-22.323 45.568-55.296 81.408c27.545 13.824 95.949-74.598 95.949-74.598s-1.946 28.109-51.354 72.704c36.864-4.864 84.326-74.65 84.326-74.65s-17.408 52.327-59.136 89.14c36.199-3.738 94.004-93.031 94.004-93.031s-22.272 62.003-67.84 97.894c50.432 11.162 123.084-64 123.084-64s-28.518 53.402-65.894 75.162c41.677 15.974 98.816-49.92 98.816-49.92s-57.14 88.166-148.224 84.326c-29.9-1.28-120.32-90.726-314.01-83.353-255.795 9.728-310.067 118.22-446.72 191.897" opacity=".35"/><path fill="#6a6a6a" d="M735.846 256s-58.163 66.867-72.704 59.136l28.11-56.986s-28.11 56.935-65.895 47.258c17.408-22.272 24.166-42.7 24.166-42.7s-28.979 46.591-64.87 33.996c-8.397-2.97 10.496-24.371 10.496-24.371s-24.064 23.398-40.5 20.48c-16.486-2.919.922-32.922.922-32.922s-29.03 45.568-34.867 43.571c-5.837-1.894 2.918-31.948 2.918-31.948s-21.299 34.867-32.972 32.921c-11.623-1.945 0-35.84 0-35.84s-12.596 37.786-22.272 34.867c-9.728-2.867-11.623-25.19-11.623-25.19s-2.611 30.26-16.486 32.973C335.616 331.57 220.314 376.166 75.879 520.55c136.703-73.574 190.924-182.118 446.77-191.846 193.69-7.373 284.11 82.022 313.959 83.302 91.136 3.892 148.275-84.326 148.275-84.326s-57.139 65.894-98.816 49.92c37.274-21.811 65.895-75.11 65.895-75.11s-72.704 75.11-123.085 64c45.568-35.84 67.84-97.895 67.84-97.895s-57.856 89.293-94.003 93.03c41.676-36.812 59.084-89.139 59.084-89.139s-47.462 69.786-84.275 74.599c49.408-44.544 51.354-72.704 51.354-72.704s-68.403 88.422-95.949 74.65c32.922-35.84 55.245-81.409 55.245-81.409s-57.19 77.517-72.704 64.922c-10.65-1.946 17.459-36.813 17.459-36.813s-34.867 31.027-44.544 23.245C705.792 308.326 735.846 256 735.846 256m92.98 162.97c-9.728-.615-18.33 3.02-22.733 14.95-45.056 85.76-139.52 133.734-250.01 149.76-110.49 15.974-191.897-7.27-258.765-26.112-87.91-24.78-157.696 19.302-233.984-18.944 17.613 13.926 37.786 27.597 95.898 27.75 19.712.103 82.842-3.072 94.464 7.117 11.674 10.138-39.22 58.112-39.22 58.112s86.068-72.755 94.465-47.974c5.222 15.462-24.679 56.73-24.679 56.73s30.004-40.756 52.327-49.46c15.309-5.939 28.211-5.222 39.219 10.24 7.27 10.138-34.816 59.546-34.816 59.546s56.627-55.245 66.816-52.327c10.189 2.919 0 52.327 0 52.327s20.838-50.074 31.949-53.76c15.257-5.12-34.867 116.224-34.867 116.224s61.235-112.23 72.704-114.79c19.61-4.353 32.716 78.489 32.716 78.489s-9.574-72.346.717-77.005c65.024-29.491 27.648 124.98 27.648 124.98s42.496-104.807 16.384-128.052c69.018 45.773 60.621 128.051 60.621 128.051s18.125-39.168-32.768-135.526c27.648-1.434 69.12 71.578 69.12 71.578s-45.056-79.924-14.54-81.408c60.62-2.868 66.866 106.137 66.866 106.137s18.125-15.257-30.515-122.112c30.976-19.865 106.087 98.816 106.087 98.816s-69.274-115.763-58.164-123.545c11.162-7.732 51.866 36.864 51.866 36.864s-30.976-42.65-22.784-47.002c8.243-4.403 90.624 84.787 90.624 84.787s-72.704-87.245-60.109-97.894c7.475-6.298 29.082 5.376 45.568 15.974-23.091-16.537-56.32-42.445-45.568-48.025 22.323-11.572 85.811 27.648 85.811 27.648s-38.297-31.437-32-39.22c6.298-7.73 81.408 49.408 81.408 49.408s-66.406-52.326-69.785-65.382c-3.38-13.107 52.326 4.352 52.326 4.352s-61.542-28.57-62.464-36.864c-1.024-8.192 40.653 9.216 40.653 9.216s-27.034-22.17-48.486-23.654M826.93 541.49c6.656 4.762 13.517 9.472 20.327 14.08 0 0-8.96-6.81-20.327-14.131z"/><path fill="#6a6a6a" d="M66.202 547.328c76.288 38.298 146.073-5.837 234.035 18.944 66.867 18.842 148.275 42.086 258.713 26.112 110.49-15.974 205.005-64 250.061-149.709 14.029-38.297 71.22 8.704 71.22 8.704s-41.677-17.408-40.705-9.216c1.024 8.243 62.464 36.864 62.464 36.864s-55.705-17.459-52.275-4.403c3.38 13.107 69.735 65.434 69.735 65.434s-75.06-57.19-81.408-49.46c-6.247 7.783 32 39.27 32 39.27s-63.488-39.27-85.76-27.647c-16.026 8.294 65.894 62.054 65.894 62.054s-53.248-40.704-65.894-30.054c-12.596 10.7 60.108 97.894 60.108 97.894s-82.432-89.139-90.624-84.787c-8.243 4.352 22.784 47.002 22.784 47.002s-40.704-44.544-51.865-36.864c-11.11 7.782 58.163 123.596 58.163 123.596s-75.11-118.732-106.138-98.816c48.692 106.804 30.516 122.061 30.516 122.061s-6.144-109.005-66.868-106.137c-30.515 1.484 14.541 81.408 14.541 81.408s-41.472-73.012-69.12-71.527c50.944 96.307 32.768 135.475 32.768 135.475s8.448-82.227-60.62-128c26.163 23.245-16.385 128-16.385 128s37.428-154.419-27.648-124.928c-10.24 4.608-.716 77.005-.716 77.005s-13.108-82.893-32.717-78.49c-11.418 2.56-72.704 114.791-72.704 114.791s50.176-121.344 34.918-116.224c-11.11 3.686-31.949 53.76-31.949 53.76s10.138-49.408 0-52.326c-10.24-2.919-66.918 52.326-66.918 52.326s42.189-49.408 34.918-59.597c-11.008-15.411-23.961-16.179-39.27-10.24-22.272 8.704-52.326 49.46-52.326 49.46s29.952-41.268 24.73-56.679c-8.398-24.832-94.465 47.974-94.465 47.974s50.842-47.974 39.22-58.163-74.753-7.014-94.465-7.065c-58.163-.205-78.336-13.824-95.948-27.802" opacity=".35"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/chromadb.svg b/apps/desktop/public/icons/database/chromadb.svg
new file mode 100644
index 0000000..59f5f59
--- /dev/null
+++ b/apps/desktop/public/icons/database/chromadb.svg
@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="1em" height="1em" viewBox="0 -46 256 256">
+	<path d="M0 -46h256v256H0z" fill="none" />
+	<ellipse cx="170.667" cy="81.92" fill="#ffde2d" rx="85.333" ry="81.92" />
+	<ellipse cx="85.333" cy="81.92" fill="#327eff" rx="85.333" ry="81.92" />
+	<path fill="#ff6446" d="M170.667 81.92c0 45.243-38.206 81.92-85.334 81.92V81.92zm-85.334 0C85.333 36.677 123.538 0 170.667 0v81.92z" />
+</svg>
diff --git a/apps/desktop/public/icons/database/clickhouse.svg b/apps/desktop/public/icons/database/clickhouse.svg
new file mode 100644
index 0000000..7c0e072
--- /dev/null
+++ b/apps/desktop/public/icons/database/clickhouse.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="red" d="M102.4 808.192h105.318v98.765H102.4z"/><path fill="#fc0" d="M192.614 204.8h79.616v537.6h-79.616zm159.232 0h79.668v614.4h-79.616V204.8zm159.335 0h79.667v614.4H511.13V204.8zm159.283 0h79.667v614.4h-79.667zm159.283 249.6h79.667v115.2h-79.667z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/cloudflare-d1.svg b/apps/desktop/public/icons/database/cloudflare-d1.svg
new file mode 100644
index 0000000..d3d97d3
--- /dev/null
+++ b/apps/desktop/public/icons/database/cloudflare-d1.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="54 3 50 23">
+  <path fill="#f48120" d="M88.1 24c.3-1 .2-2-.3-2.6-.5-.6-1.2-1-2.1-1.1l-17.4-.2c-.1 0-.2-.1-.3-.1-.1-.1-.1-.2 0-.3.1-.2.2-.3.4-.3l17.5-.2c2.1-.1 4.3-1.8 5.1-3.8l1-2.6c0-.1.1-.2 0-.3-1.1-5.1-5.7-8.9-11.1-8.9-5 0-9.3 3.2-10.8 7.7-1-.7-2.2-1.1-3.6-1-2.4.2-4.3 2.2-4.6 4.6-.1.6 0 1.2.1 1.8-3.9.1-7.1 3.3-7.1 7.3 0 .4 0 .7.1 1.1 0 .2.2.3.3.3h32.1c.2 0 .4-.1.4-.3l.3-1.1z" />
+  <path fill="#faad3f" d="M93.6 12.8h-.5c-.1 0-.2.1-.3.2l-.7 2.4c-.3 1-.2 2 .3 2.6.5.6 1.2 1 2.1 1.1l3.7.2c.1 0 .2.1.3.1.1.1.1.2 0 .3-.1.2-.2.3-.4.3l-3.8.2c-2.1.1-4.3 1.8-5.1 3.8l-.2.9c-.1.1 0 .3.2.3h13.2c.2 0 .3-.1.3-.3.2-.8.4-1.7.4-2.6 0-5.2-4.3-9.5-9.5-9.5" />
+</svg>
diff --git a/apps/desktop/public/icons/database/cockroachdb.svg b/apps/desktop/public/icons/database/cockroachdb.svg
new file mode 100644
index 0000000..862e86f
--- /dev/null
+++ b/apps/desktop/public/icons/database/cockroachdb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="190.51" class="icon" viewBox="0 0 1075 1024"><path fill="#6646fe" d="M675.123 629.658A368.44 368.44 0 0 0 548.301 253.44a328.96 328.96 0 0 1 164.659-43.776c21.914 0 43.725 2.1 65.229 6.4l9.062-36.352a370.7 370.7 0 0 0-74.342-7.475 366.1 366.1 0 0 0-197.632 57.446 366.2 366.2 0 0 0-197.632-57.446 370 370 0 0 0-74.291 7.526l9.01 36.301c21.505-4.3 43.367-6.4 65.332-6.4a329.6 329.6 0 0 1 164.71 43.725 368.384 368.384 0 0 0 22.426 591.104l10.598 7.27 10.548-7.27a368.9 368.9 0 0 0 149.248-214.835zM496.59 791.04a330.91 330.91 0 0 1-99.533-349.286 370.4 370.4 0 0 0 69.632 84.275 90.62 90.62 0 0 1 29.9 67.481zm18.739-273.408a331.9 331.9 0 0 1-66.355-65.536 91.44 91.44 0 0 1 0-110.797c18.944-25.088 41.267-47.309 66.457-66.048 25.498 18.944 48.026 41.523 67.072 66.97a90.52 90.52 0 0 1 0 108.544 334.5 334.5 0 0 1-67.174 66.867m18.637 273.408V593.51a90.62 90.62 0 0 1 30.003-67.481 369 369 0 0 0 69.53-84.275 331.16 331.16 0 0 1-99.533 349.286"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/databend.svg b/apps/desktop/public/icons/database/databend.svg
new file mode 100644
index 0000000..ab3b974
--- /dev/null
+++ b/apps/desktop/public/icons/database/databend.svg
@@ -0,0 +1,16 @@
+<svg width="48" height="48" viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_9_11)">
+<path d="M46.8741 35.0248C46.5214 35.3778 45.1611 34.1675 44.695 33.4741C44.7832 34.3188 44.4683 36.0207 44.0526 36.0081C43.2591 35.9829 42.7427 33.6884 43.045 32.1504C38.0696 29.2886 33.0061 31.7848 33.0061 31.7848H33.0313C33.6485 31.873 35.1222 32.0243 35.0844 32.6799C35.0592 33.1085 33.1698 34.407 27.2372 33.928C25.373 35.5038 17.8407 38.8951 11.1775 37.7857C6.34069 36.6511 3.74595 34.407 2.39819 32.0874C3.63259 32.9572 8.80948 35.882 18.9869 32.6547C30.7262 28.9356 34.4672 26.8933 44.1912 29.4273C44.1912 29.4273 44.1912 29.4399 44.1912 29.4525C44.6194 30.4863 44.7328 31.1418 44.7328 31.1418C46.3577 32.1756 47.3401 34.5709 46.8741 35.0374V35.0248Z" fill="#B3DFFF"/>
+<path d="M42.0625 25.7965C43.1331 27.1832 43.7881 28.4565 44.1912 29.4273C34.4672 26.8933 30.7136 28.9356 18.9869 32.6546C8.82206 35.882 3.63257 32.9572 2.39818 32.0873C2.39818 32.0873 2.39818 32.0747 2.39818 32.0621C0.231694 28.3305 1.22677 24.3845 1.22677 24.3845C1.44089 24.1576 1.69281 23.918 1.96992 23.6659C3.07835 24.6744 8.53235 28.8852 19.138 26.2251C19.138 26.2251 35.7646 22.0144 42.0625 25.7713V25.7965Z" fill="#52A6FF"/>
+<path d="M36.5202 20.9302C39.0646 22.4556 40.8406 24.1954 42.075 25.7839C35.7771 22.0144 19.1505 26.2377 19.1505 26.2377C8.54485 28.8978 3.09086 24.6871 1.98242 23.6785C3.83401 22.027 7.10893 19.8712 11.5049 18.4592C12.3614 18.8753 15.46 20.1738 19.6922 19.5686C24.6423 18.8627 30.4868 18.7492 36.5076 20.9302H36.5202Z" fill="#0175EE"/>
+<path d="M34.1774 19.6947C35.0213 20.0855 35.8023 20.5016 36.5076 20.9302C30.4868 18.7492 24.6424 18.8627 19.6922 19.5687C15.46 20.1738 12.3488 18.8753 11.4923 18.4592C16.4425 16.8582 22.8412 16.19 30.2349 18.2323C31.6834 18.661 32.9934 19.1652 34.1648 19.7073L34.1774 19.6947Z" fill="#015BC7"/>
+<path d="M19.201 11.1977C19.201 11.6894 18.8987 12.118 18.4704 12.3071C17.4628 12.8114 16.644 13.6182 16.1528 14.6268C16.0772 14.2738 16.0394 13.9082 16.0394 13.5426C16.0394 12.4332 16.3921 11.412 16.9841 10.5799C17.0219 10.5169 17.0723 10.4539 17.1227 10.4034C17.3368 10.1639 17.6517 10.0126 18.0044 10.0126C18.672 10.0126 19.201 10.5421 19.201 11.2103V11.1977Z" fill="#015BC7"/>
+<path d="M15.0569 15.837C15.0569 16.0261 15.0569 16.2152 15.0317 16.3917C14.4523 15.7992 13.7344 15.358 12.9282 15.1058C12.9156 15.1058 12.8904 15.1058 12.8653 15.0932C12.3488 14.9293 11.9709 14.4503 11.9709 13.8703C11.9709 13.1644 12.5378 12.597 13.2431 12.597C13.7218 12.597 14.15 12.8744 14.3642 13.2652C14.805 14.0216 15.0569 14.9041 15.0569 15.8244V15.837Z" fill="#015BC7"/>
+<path d="M20.0701 33.5119C20.6753 33.5119 21.1659 33.0209 21.1659 32.4151C21.1659 31.8094 20.6753 31.3183 20.0701 31.3183C19.4649 31.3183 18.9742 31.8094 18.9742 32.4151C18.9742 33.0209 19.4649 33.5119 20.0701 33.5119Z" fill="#0175EE"/>
+</g>
+<defs>
+<clipPath id="clip0_9_11">
+<rect width="46" height="28" fill="white" transform="translate(1 10)"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/apps/desktop/public/icons/database/databricks.webp b/apps/desktop/public/icons/database/databricks.webp
new file mode 100644
index 0000000..0a74319
Binary files /dev/null and b/apps/desktop/public/icons/database/databricks.webp differ
diff --git a/apps/desktop/public/icons/database/db2.svg b/apps/desktop/public/icons/database/db2.svg
new file mode 100644
index 0000000..728876a
--- /dev/null
+++ b/apps/desktop/public/icons/database/db2.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path d="M559.309 379.085H51.2v237.568h508.109z"/><path fill="#093" d="M972.8 379.085H569.549v237.568H972.8z"/><path fill="#fff" d="M130.355 427.827v9.472h67.943v-9.472zm77.824 0v9.472h97.024s-9.881-9.472-22.937-9.472zm115.815 0v9.472h58.675l-3.38-9.472zm100.864 0-3.43 9.472h58.111v-9.472zm-294.503 18.586v9.472h67.943v-9.421h-67.943zm77.824.205v9.472h108.237s-1.331-7.373-3.43-9.472zm115.815 0v9.472h65.126l-3.226-9.472zm93.798 0-3.226 9.472h64.768v-9.472zM149.914 465.05v9.472h29.44v-9.524h-29.44zm77.824 0v9.472h29.44v-9.524h-29.44zm58.112 0v9.472h29.44s1.894-5.12 1.894-9.524H285.85zm57.702 0v9.472h52.224l-3.43-9.524h-48.794zm67.789 0-3.43 9.472h52.633v-9.524h-49.152zm-261.427 18.79v9.472h29.44v-9.472zm77.824 0v9.472h75.212s6.247-4.915 8.346-9.472zm115.814 0v9.472h29.44v-5.325l1.894 5.325h54.17l2.048-5.325v5.325h29.491v-9.472H405.3l-2.816 8.14-3.072-8.191h-55.859zm-193.638 18.586v9.472h29.44v-9.472zm77.824 0v9.472h83.558c-2.048-4.557-8.346-9.472-8.346-9.472zm115.814 0v9.472h29.44v-9.472zm34.97 0 3.584 9.472h40.448l3.43-9.472zm52.377 0v9.472h29.44v-9.472zm-280.985 18.432v9.472h29.44v-9.472zm77.824 0v9.472h29.44v-9.472zm58.112 0v9.472h31.334c0-4.557-1.894-9.472-1.894-9.472zm57.702 0v9.472h29.44v-9.472zm41.574 0 3.43 9.472h27.137l3.43-9.472zm45.773 0v9.472h29.44v-9.472zm-299.98 18.585v9.523h67.993v-9.523zm77.311 0v9.523h104.756c2.304-2.304 3.43-9.523 3.43-9.523H208.179zm116.378 0v9.523h48.384v-9.523zm67.174 0 3.584 9.523h13.876l3.43-9.523zm39.117 0v9.523h48.999v-9.523zm-299.98 18.79v9.524h67.993v-9.523zm77.311 0v9.524h73.83a36.86 36.86 0 0 0 22.99-9.523h-96.87zm116.378 0v9.524h48.384v-9.523zm74.035 0 3.43 9.524h.513l3.43-9.523zm32.256 0v9.524h48.999v-9.523zm224.256-17.459v-90.982h15.77c14.438 0 17.459 11.98 17.459 42.342 0 37.223-1.331 48.436-22.784 48.436h-10.445zm20.327 18.79a35.84 35.84 0 0 0 17.817-3.43c19.763-11.417 19.763-40.806 19.763-66.048 0-21.299-1.536-35.532-7.014-44.441a29.9 29.9 0 0 0-24.883-14.643H631.04v128.512h44.442zm83.148-18.738v-38.912h9.268c15.052 0 17.715 5.888 17.715 19.763 0 6.451-1.024 15.001-7.424 17.817-4.352 1.895-9.472 1.332-14.439 1.332zm0-57.703v-33.229h11.213c11.008.359 13.107 5.12 13.107 14.848 0 6.042-.41 10.599-2.662 13.824-3.84 4.762-11.418 4.352-17.1 4.352h-4.609v.205zm18.432 76.493c17.05 0 26.368-6.81 31.488-23.142 1.332-5.12 1.741-10.445 1.741-15.77 0-16.691-5.12-27.904-18.637-29.798v-.359c13.108-4.761 15.36-15.77 15.36-26.982 0-8.704-.921-16.128-6.246-23.143-6.81-8.755-16.896-9.523-27.34-9.523H734.72v128.512h42.342zm119.194 0v-18.79h-44.8c.154-8.704 7.578-17.101 12.493-22.221l18.79-19.559c9.882-10.035 15.207-20.89 15.207-35.123 0-20.48-14.234-33.024-34.304-33.229-37.07-.358-36.506 28.519-36.506 39.68v3.584h22.426c.153-6.041-.615-12.492 1.894-18.176 1.69-4.761 6.042-6.297 11.213-6.297 6.81 0 11.366 3.584 11.366 15.206 0 12.135-4.198 16.333-11.776 24.679l-11.571 12.339c-14.848 15.565-21.094 27.34-22.58 36.096a209 209 0 0 0-2.098 21.811zm33.024 6.195c9.728 0 17.664-7.987 17.664-17.664a17.613 17.613 0 1 0-17.664 17.664m0-3.225a14.44 14.44 0 0 1-14.387-14.439c0-7.936 6.451-14.233 14.438-14.233 7.936 0 14.234 6.45 14.234 14.233a14.13 14.13 0 0 1-14.234 14.439zm4.198-12.903c3.43-.205 5.325-1.69 5.325-5.12 0-1.894-.563-3.789-2.253-4.966-1.536-.922-3.635-.922-5.12-.922h-9.318v19.149h3.789v-8.14h3.789l4.147 8.191h4.403zm-7.577-2.867v-5.325h4.557c1.894 0 4.556 0 4.556 2.509 0 2.458-1.536 2.816-3.584 2.816z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/dm.svg b/apps/desktop/public/icons/database/dm.svg
new file mode 100644
index 0000000..5315156
--- /dev/null
+++ b/apps/desktop/public/icons/database/dm.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#ea4646" d="M295.526 392.14c19.456-16.486 40.704-33.177 62.67-47.615-16.692 55.04-19.866 173.568 106.905 193.536 95.232 15.001 119.296 45.21 108.083 195.942-19.558 9.216-39.014 16.896-58.88 24.064 12.544-62.464 26.47-174.592-64.307-192.819-110.541-22.272-167.936-36.864-154.47-173.107"/><path fill="#ea4646" d="M373.248 334.643a889 889 0 0 1 58.368-33.536c-21.504 100.864-14.336 188.416 103.782 206.848 69.99 10.957 124.263 36.25 110.234 186.368a714 714 0 0 1-54.374 31.027c10.393-59.904 10.65-180.838-72.192-193.587-124.57-19.2-162.253-53.248-145.818-197.12"/><path fill="#ea4646" d="M449.075 292.71c19.61-8.755 47.053-20.48 57.856-23.552-21.35 75.93-10.496 195.994 86.835 211.968 90.983 14.9 132.813 65.69 123.188 162.356-18.484 14.694-35.482 27.238-54.426 39.936 16.128-93.082-18.432-172.237-82.79-181.556-138.138-20.07-153.6-77.875-130.663-209.152"/><path fill="#1a2781" d="M267.008 418.918c-89.702 84.685-137.78 197.786-100.915 280.064 41.984 93.799 195.891 111.002 315.494 68.71 25.395-110.796 38.298-172.338-63.488-191.897-148.173-28.57-149.913-87.193-151.091-156.877m484.3 193.536c87.758-85.81 148.583-202.547 104.346-289.075-50.022-97.792-207.974-100.454-316.006-64.46-31.744 86.527-23.04 194.355 65.946 207.308 129.228 18.74 134.348 72.858 145.715 146.227"/><path fill="#de1a1b" d="M295.526 392.09c19.456-16.538 40.704-33.178 62.67-47.668-16.692 55.092-19.866 173.62 106.905 193.536 95.232 15.053 119.296 45.261 108.083 195.994-19.558 9.216-39.014 16.896-58.88 24.064 12.544-62.515 26.47-174.592-64.307-192.87-110.541-22.221-167.936-36.864-154.47-173.056"/><path fill="#de1a1b" d="M373.248 334.643c18.842-11.98 37.427-22.323 58.368-33.536-21.504 100.864-14.336 188.416 103.782 206.848 69.99 10.957 124.263 36.25 110.234 186.368-18.534 11.879-35.533 21.095-54.374 31.027 10.393-59.904 10.65-180.838-72.192-193.587-124.57-19.2-162.253-53.248-145.818-197.12"/><path fill="#de1a1b" d="M449.075 292.71c19.61-8.755 47.053-20.48 57.856-23.552-21.35 75.93-10.496 195.994 86.835 211.968 90.983 14.9 132.813 65.69 123.188 162.407-18.484 14.592-35.482 27.136-54.426 39.885 16.128-93.03-18.432-172.237-82.79-181.556-138.138-20.07-153.6-77.875-130.663-209.152"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/doris.svg b/apps/desktop/public/icons/database/doris.svg
new file mode 100644
index 0000000..e18c60e
--- /dev/null
+++ b/apps/desktop/public/icons/database/doris.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#52c9a3" d="M398.848 872.858c-36.813-8.704-69.99-47.616-76.698-89.856-3.84-24.372.41-44.442 14.08-66.458 4.096-6.554 69.018-74.086 151.757-157.798 84.48-85.504 147.61-151.143 151.86-158.004 8.601-13.824 17.51-35.174 19.763-47.36.921-4.812 2.816-9.216 4.25-9.728 3.122-1.228 85.094 81.05 100.351 100.762 28.365 36.096 32.103 51.814 32.256 69.786-.102 27.392-11.776 39.372-25.241 59.801-9.216 13.875-274.944 277.709-290.1 287.898-5.376 3.635-14.95 8.192-21.196 10.035-12.493 3.738-47.104 4.25-61.133.922z"/><path fill="#14a8c9" d="M419.328 389.018c-70.4-71.066-79.462-81.05-85.606-94.31-19.047-40.96-11.264-87.348 19.712-117.044 7.27-7.014 18.33-15.36 24.576-18.483 31.334-16.026 74.65-13.005 103.782 7.168 5.58 3.84 32.256 29.389 59.392 56.78 42.7 43.111 50.38 51.917 57.19 65.793 14.285 29.184 12.698 56.473-5.222 91.238-6.707 12.954-15.565 23.552-43.725 52.275-32.358 33.024-35.993 36.045-43.315 35.994-7.526 0-13.005-5.018-86.784-79.411"/><path fill="#5369a9" d="m256.666 698.624-4.967-5.325V327.526c0-7.372 11.776-9.881 18.33-9.932 7.27 0 14.336 6.553 100.352 93.184 80.793 81.254 92.672 88.012 92.62 99.993 0 11.981-11.775 18.688-92.62 99.994-87.347 87.859-93.03 93.133-100.71 93.133a16.64 16.64 0 0 1-13.057-5.274z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/dremio.svg b/apps/desktop/public/icons/database/dremio.svg
new file mode 100644
index 0000000..f209f46
--- /dev/null
+++ b/apps/desktop/public/icons/database/dremio.svg
@@ -0,0 +1,44 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 42 41">
+  <path
+    fill="#383c42"
+    fill-rule="evenodd"
+    d="M9.327 25.504c-1.25.57-3.69 1.84-3.46 3.22.32.85 1.31 0 1.68-.4a6.783 6.783 0 0 0 1.78-2.77v-.05Zm7.48-2.99c-.83 2.17-3.25 3.2-3.92 2.83-.34-.18 0-.87 0-1.34-.49.19-1.3.55-1.79.75a5 5 0 0 1 0 7.59c2 3 1 5.58-1.79 7.59l-.11.07-.06-.2a9.488 9.488 0 0 0-1.92-3.77c-.49-.57-1.05-1.09-1.6-1.61-.72-.68-1.42-1.38-2.07-2.12-2.75-2.88-3.84-7.95-3.48-11.87a15.6 15.6 0 0 1 1.74-5.75 17.628 17.628 0 0 1 2.8-3.91 21.806 21.806 0 0 1 9.07-5.67 15.038 15.038 0 0 1 9.32.43c.541.287 1.057.622 1.54 1l.71.67.08.08 13.37-6.85c1.1-.55 1.93-.55 2.3-.15.37.4-.15 1.43-.93 2l-11.5 8.31c.137.793-.099 1.604-.64 2.2 1.53.53.18 2.77-.49 3.57-1.92 2.27-5.43 4.05-8.56 5.35-.84.36-1.32.51-2.07.79v.01Z"
+  />
+  <path
+    fill="#31d3db"
+    fill-rule="evenodd"
+    d="M27.297 14.664c.86-1.08.26-1.7-.34-1.1a5.06 5.06 0 0 1-4.57 1.36c-2.35-.39-2.46-.75-2.06-1.1 2.728.918 5.734-.102 7.34-2.49.58-.83-1.36-1.49-2.5-3-5.48-7.44-22.64-.99-24.28 11.94-.54 4.036.647 8.114 3.27 11.23 2 2.269 4.18 3.22 5.41 6.79 2.4-2.06 2-4.39.27-6.43 1.258-.638 2.086-1.892 2.181-3.3.094-1.407-.559-2.759-1.721-3.56-1 3.61-4.51 6.28-5.33 3.72-.53-2.61 3.77-4.34 10.65-7 5.76-2.16 9.48-3.94 11.68-7.12"
+  />
+  <path
+    fill="#fff"
+    fill-rule="evenodd"
+    d="M27.296 14.664c.86-1.08.26-1.7-.34-1.1a5.06 5.06 0 0 1-3.96 1.44c-2.37-.17-4.26-.64-6-.45a17.199 17.199 0 0 0-8.52 4.32c-3 3.08-6.32 9.479-3 10.72a1.06 1.06 0 0 1-.48-.86c-.53-2.61 3.77-4.341 10.65-7.001 5.76-2.16 9.48-3.94 11.68-7.12"
+    opacity=".92"
+  />
+  <path
+    fill="#31d3db"
+    fill-rule="evenodd"
+    d="M12.546 19.714c1.77.87 1.42 3.91 1.16 4.67 3.36-1 2.36-5.93 3.92-7.45-2-.06-5.62 1.91-5.08 2.78"
+  />
+  <path
+    fill="#383c42"
+    fill-rule="evenodd"
+    d="M18.226 10.694a1 1 0 1 1 1.31 1.51 1 1 0 0 1-1.31-1.51"
+  />
+  <path
+    fill="#31d3db"
+    fill-rule="evenodd"
+    d="M26.386 11.104 39.876 1.714c.38-.27.88-.85.67-1.13-.21-.28-.79-.13-1.29.1l-14.58 7.88c-.47 1 .48 3.05 1.72 2.54"
+  />
+  <path
+    fill="#fff"
+    fill-rule="evenodd"
+    d="m25.176 9.254 14.09-8.25c.364-.248.79-.387 1.23-.4-.21-.24-.79-.1-1.27.13l-14.58 7.83c-.294.941.069 1.964.89 2.51a3.583 3.583 0 0 1-.36-1.84"
+    opacity=".92"
+  />
+  <path
+    fill="#21aaad"
+    fill-rule="evenodd"
+    d="M3.266 13.354a.94.94 0 1 1 1.15 1.46.94.94 0 0 1-1.15-1.46m2.82-3.008a.83.83 0 1 1 1.08 1.26.83.83 0 0 1-1.08-1.26m8.6-3.99a.86.86 0 1 1 1.62.57.86.86 0 0 1-1.62-.57m2.61-.415a.7.7 0 1 1 1.26.62.7.7 0 0 1-1.26-.62m-10.452 6.29a.55.55 0 1 1 .64.89.55.55 0 0 1-.64-.89m-4.291 3.52a.58.58 0 1 1 .69.94.58.58 0 0 1-.69-.94M27.537 6.684l-.63.32a2.95 2.95 0 0 0 1.34 2.21 4.08 4.08 0 0 1-.71-2.53Zm3.31-1.82-.55.3a2.5 2.5 0 0 0 1.13 1.84 3.6 3.6 0 0 1-.53-2.14h-.05Zm3.32-1.8-.42.23c0 .54.39 1.35.83 1.46a2.58 2.58 0 0 1-.36-1.69h-.05Zm3.2-1.72-.37.2c.09.441.326.839.67 1.13a3.3 3.3 0 0 1-.3-1.33Z"
+  />
+</svg>
diff --git a/apps/desktop/public/icons/database/duckdb.svg b/apps/desktop/public/icons/database/duckdb.svg
new file mode 100644
index 0000000..14dc392
--- /dev/null
+++ b/apps/desktop/public/icons/database/duckdb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path d="M512 921.6A409.09 409.09 0 0 1 102.4 512c0-226.611 182.989-409.6 409.6-409.6S921.6 285.389 921.6 512c0 226.355-182.989 409.6-409.6 409.6"/><path fill="#fff100" d="M731.034 450.765H650.65v121.241h80.384c33.536 0 60.979-27.648 60.979-60.979 0-33.28-27.443-60.262-60.98-60.262m-474.061 60.979a169.984 169.984 0 0 0 169.779 169.78 169.984 169.984 0 0 0 169.78-169.78 169.984 169.984 0 0 0-169.78-169.728 169.984 169.984 0 0 0-169.78 169.78z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/elasticsearch.svg b/apps/desktop/public/icons/database/elasticsearch.svg
new file mode 100644
index 0000000..48ef8a3
--- /dev/null
+++ b/apps/desktop/public/icons/database/elasticsearch.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#343741" d="M177.152 512c0 33.69 4.762 66.202 12.8 97.382h474.01a97.382 97.382 0 0 0 0-194.764h-474.01a388 388 0 0 0-12.8 97.382"/><path fill="#fec514" d="M832.512 309.043c13.62-12.544 26.317-26.06 37.888-40.448a388.6 388.6 0 0 0-303.77-146.022c-153.856 0-286.208 89.497-349.44 219.033h532.224a122.3 122.3 0 0 0 83.098-32.563"/><path fill="#00bfb3" d="M749.466 682.394H217.242c63.18 129.536 195.584 219.033 349.388 219.033A388.6 388.6 0 0 0 870.4 755.405a372 372 0 0 0-37.888-40.448 122.52 122.52 0 0 0-83.046-32.563"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/etcd.svg b/apps/desktop/public/icons/database/etcd.svg
new file mode 100644
index 0000000..a36ae07
--- /dev/null
+++ b/apps/desktop/public/icons/database/etcd.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" role="img" viewBox="-6.31 3.69 510.12 493.62">
+  <path fill="#419eda" d="M228.175 224.684a31.994 31.994 0 1 1-32.007-31.986 32.011 32.011 0 0 1 32.007 31.986zm41.37 0a32.007 32.007 0 1 0 32.007-31.986 31.988 31.988 0 0 0-32.007 31.986z"/>
+  <path fill="#419eda" d="M487.371 259.399a87.82 87.82 0 0 1-7.07.267 92.362 92.362 0 0 1-40.621-9.455 377.209 377.209 0 0 0 5.47-71.86 371.808 371.808 0 0 0-46.507-55.11 92.396 92.396 0 0 1 32.772-35.102l6.016-3.729-4.695-5.3a244.906 244.906 0 0 0-85.524-62.377l-6.507-2.828-1.654 6.862a92.144 92.144 0 0 1-23.19 42.096 371.928 371.928 0 0 0-67.006-27.602 370.624 370.624 0 0 0-66.908 27.558 91.915 91.915 0 0 1-23.098-42.003l-1.681-6.884-6.486 2.817a247.232 247.232 0 0 0-85.518 64.359l-4.689 5.3 6.005 3.724a92.249 92.249 0 0 1 32.695 34.917 374.63 374.63 0 0 0-46.425 54.908 376.956 376.956 0 0 0 5.328 72.334 92.115 92.115 0 0 1-40.376 9.374 86.36 86.36 0 0 1-7.086-.268l-7.053-.551.655 7.042a243.413 243.413 0 0 0 32.897 100.678l3.581 6.098 5.372-4.575a92.052 92.052 0 0 1 43.592-20.406 373.97 373.97 0 0 0 37.308 60.76 377.717 377.717 0 0 0 70.69 17.382 91.87 91.87 0 0 1-5.885 48.232l-2.686 6.54 6.9 1.529a246.355 246.355 0 0 0 52.966 5.857l52.954-5.857 6.906-1.529-2.675-6.54a91.755 91.755 0 0 1-5.869-48.286 377.784 377.784 0 0 0 70.407-17.328 372.3 372.3 0 0 0 37.335-60.815 92.233 92.233 0 0 1 43.81 20.428l5.377 4.553 3.587-6.049a242.844 242.844 0 0 0 32.859-100.672l.655-7.037zM324.644 345.45a285.884 285.884 0 0 1-151.628 0 290.124 290.124 0 0 1-46.141-143.385 288.675 288.675 0 0 1 54.957-52.315 293.065 293.065 0 0 1 67.028-36.462 293.976 293.976 0 0 1 66.891 36.364 290.886 290.886 0 0 1 55.198 52.675 292.253 292.253 0 0 1-13.817 74.682 293.726 293.726 0 0 1-32.488 68.441z"/>
+</svg>
diff --git a/apps/desktop/public/icons/database/exasol.webp b/apps/desktop/public/icons/database/exasol.webp
new file mode 100644
index 0000000..00b340d
Binary files /dev/null and b/apps/desktop/public/icons/database/exasol.webp differ
diff --git a/apps/desktop/public/icons/database/firebird.webp b/apps/desktop/public/icons/database/firebird.webp
new file mode 100644
index 0000000..fd84e6f
Binary files /dev/null and b/apps/desktop/public/icons/database/firebird.webp differ
diff --git a/apps/desktop/public/icons/database/gaussdb.svg b/apps/desktop/public/icons/database/gaussdb.svg
new file mode 100644
index 0000000..f115a85
--- /dev/null
+++ b/apps/desktop/public/icons/database/gaussdb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#9f53e6" d="M170.24 333.005a20.5 20.5 0 0 0-3.84 8.601h-.205v84.122a19.87 19.87 0 0 0 11.367 16.691l269.363 158.26a136.45 136.45 0 0 0 125.542 0l269.517-157.697a19.87 19.87 0 0 0 11.366-16.742l1.024-83.968-217.241-116.838-160.461 92.979a19.35 19.35 0 0 0-11.315 16.691v83.814c2.048 5.888 6.093 10.957 11.315 14.336 2.56-35.84 42.496-58.265 42.496-58.265l116.94-66.765 152.577 82.893-216.218 128.307a137.47 137.47 0 0 1-125.491 0l-226.509-133.58 226.407-133.53a126.5 126.5 0 0 1 62.873-15.207V153.6a126.8 126.8 0 0 0-62.873 15.155l-269.21 158.31a20.5 20.5 0 0 0-7.373 5.94zm679.22 236.851a19.9 19.9 0 0 0 3.378-9.882l-.307-83.302a19.87 19.87 0 0 1-11.366 16.691L572.109 651.571a136.5 136.5 0 0 1-125.491 0L177.05 492.75a19.87 19.87 0 0 1-11.367-16.691v83.456a19.87 19.87 0 0 0 11.367 16.69l269.568 158.414a137.42 137.42 0 0 0 125.49 0l269.364-157.901a19.97 19.97 0 0 0 7.987-6.81zm3.378 119.654a19.92 19.92 0 0 1-11.366 16.692L572.109 863.949a136.5 136.5 0 0 1-125.491 0L177.05 705.74a19.87 19.87 0 0 1-11.367-16.743v-83.456a19.71 19.71 0 0 0 11.367 16.692l269.568 158.412a137.47 137.47 0 0 0 125.49 0l269.057-157.9a19.56 19.56 0 0 0 11.366-16.692z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/gbase.webp b/apps/desktop/public/icons/database/gbase.webp
new file mode 100644
index 0000000..6a4bb56
Binary files /dev/null and b/apps/desktop/public/icons/database/gbase.webp differ
diff --git a/apps/desktop/public/icons/database/goldendb.png b/apps/desktop/public/icons/database/goldendb.png
new file mode 100644
index 0000000..b635a72
Binary files /dev/null and b/apps/desktop/public/icons/database/goldendb.png differ
diff --git a/apps/desktop/public/icons/database/greatsql.webp b/apps/desktop/public/icons/database/greatsql.webp
new file mode 100644
index 0000000..c7bd056
Binary files /dev/null and b/apps/desktop/public/icons/database/greatsql.webp differ
diff --git a/apps/desktop/public/icons/database/h2.svg b/apps/desktop/public/icons/database/h2.svg
new file mode 100644
index 0000000..56820c8
--- /dev/null
+++ b/apps/desktop/public/icons/database/h2.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#1021ff" d="M887.091 296.329H107.622v427.468h779.47v-427.52z"/><path fill="#0c08d5" d="M887.091 360.43c-365.568 45.21-688.23 165.787-770.56 363.367h770.56z"/><path fill="#fff" d="M531.354 477.32h44.441v72.602h39.424v-72.601h44.34v195.686h-44.442v-81.254h-39.424v81.254H531.2V477.32zm210.176 72.602h-42.957c0-14.643.563-26.112 1.74-34.457s3.84-15.719 7.68-22.016a40 40 0 0 1 17.716-15.36c7.936-3.84 17.459-5.735 28.313-5.735 18.023 0 32 4.66 41.677 14.234 9.677 9.523 14.49 23.142 14.49 41.062 0 9.216-1.895 19.047-5.581 29.645-3.635 10.547-9.216 22.272-16.691 34.867l-24.064 41.114h39.424v39.885H691.814l64-109.159c7.732-13.056 11.725-24.934 11.725-35.789a22.53 22.53 0 0 0-3.584-13.21c-2.304-3.378-5.222-5.12-8.755-5.12-5.58 0-9.216 2.202-10.854 6.606-1.741 4.403-2.51 13.21-2.51 26.265v7.168z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/highgo.png b/apps/desktop/public/icons/database/highgo.png
new file mode 100644
index 0000000..c1c434b
Binary files /dev/null and b/apps/desktop/public/icons/database/highgo.png differ
diff --git a/apps/desktop/public/icons/database/hive.svg b/apps/desktop/public/icons/database/hive.svg
new file mode 100644
index 0000000..4c95973
--- /dev/null
+++ b/apps/desktop/public/icons/database/hive.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#fdee21" d="M570.112 218.624c-7.066-19.354-250.266-113.92-253.389-103.526-44.646 11.622-62.822 63.13-93.542 95.744l-68.25-3.994c-30.003 38.656-45.773 78.131-35.072 119.194 38.554 52.172 83.251 96.563 111.104 162.099 2.202 30.925 133.735 3.225 161.895-2.867-38.503 27.545-72.039 70.297-57.6 193.33 13.158 57.806 22.118 122.318 138.803 187.649 15.36 8.601 47.155 18.534 66.816 25.805 18.79 8.601 40.755 12.134 102.758-6.81 35.84-15.462 74.599-24.78 109.722-40.192l-42.189 1.946c-58.112 1.28-102.963 5.632-116.838-10.599l-53.453-92.365 31.18-60.518c43.162 4.403 57.498 39.424 95.489 52.736l44.85-33.229c130.202 76.851 182.017-48.691 196.865-146.483-1.587-39.834-86.17 12.442-81.05-6.144 1.997-42.803-32.87-98.765-55.398-142.336L798.925 307.2c11.776-10.547-54.784-122.778-109.21-136.755-47.667-12.288-119.603 48.128-119.603 48.128z"/><path fill="#c8c037" d="M784.077 432.998c.46 10.804.41 24.013 1.433 32.256-.153 6.247-4.864 6.503-8.755 7.783l25.344 9.267c5.018 8.5 9.063 16.896 13.159 25.395 4.71 20.839 1.177 21.453-1.946 22.938-9.216.102-18.38.153-26.931-1.69 3.84 2.048 4.659 3.533 5.12 6.144.717 4.71-2.355 11.264-7.424 17.562 7.475 4.147 21.145 8.192 31.283 12.083l11.571-25.754c-5.222-37.888-21.145-72.704-42.854-105.984m47.257 126.976c14.08 5.837 33.485 4.096 60.416-9.728 3.994-2.867 7.68-1.177.512 3.482-35.276 31.693-52.172 15.872-60.928 6.195z"/><path fill="#c8c037" d="M894.464 546.048c4.096 7.987 1.587 14.49.205 21.248a180.2 180.2 0 0 1-36.045 89.856c-68.3 109.824-137.267 41.114-192.256-3.584l-22.733 56.934c-1.229 5.018-6.246 8.91 29.287 24.576l36.198-25.6c137.933 104.96 235.725-146.944 185.293-163.43zm-211.456 98.15c-9.318.615-37.018 10.036-38.246 15.514l12.8-18.995zm-18.074-116.48c1.69 0 9.882 2.202 9.012 1.741-1.28-.717-.154 11.469 2.406 17.818l-9.984 21.709c19.149-22.016 49.408-20.583 77.466-23.399l-13.364-8.345c2.304-7.732-.41-13.876-1.74-20.48zm47.002-65.433c-20.531 6.297-40.192 16.589-53.35 38.502 10.035-36.147 12.083-34.765 15.36-36.557 14.028-6.297 25.6-2.355 37.99-1.945"/><path fill="#fcf6a0" d="M602.266 885.76c-24.832 27.34-80.23-2.1-126.208-17.152-116.89-74.291-139.725-144.282-141.312-212.94-6.042-98.305 24.166-155.444 62.361-168.96-25.293 48.742-37.069 136.191-25.344 201.215 9.472 36.199 9.677 97.229 70.195 129.895 29.696 16.64 21.607 29.696 41.677 45.312 21.965 17.1 83.2 33.382 118.63 22.579zm37.068-454.451c-41.984-59.597-101.12-81.92-167.782-84.378 13.312-4.352 26.726-6.656 40.09-13.056 3.225-3.43 2.201-9.523.972-15.667-64.204-16.742-104.652-37.427-155.955-56.627l138.394 33.229c93.44 3.532 85.453 26.624 144.281 136.499m45.005-28.723c-31.078-44.34-61.184-98.15-102.041-132.352-98.714-44.544-196.352-77.67-310.784-107.776l36.505-46.95c121.447 27.698 235.52 74.086 337.664 150.527 17.255 43.725 28.775 87.552 38.656 136.55m62.618-78.336s-17.408-39.066-25.907-54.016c-19.661-21.76-29.594-62.362-69.888-81.51 12.8 3.43 21.504-.666 47.462 22.886l40.96 77.721zm21.657 67.686c3.994-33.894 11.623-88.166 2.868-109.568l-73.37-97.792c-4.096-3.789-7.014-8.96-10.189-12.954 34.509 8.96 70.503 32.922 119.04 127.59l-38.349 92.673z"/><path d="M623.616 395.93c-13.722-10.855-25.958-49.101-46.797-57.037-19.251-1.587-26.317-7.68-51.66-2.509 9.215-4.608 17.92-10.496 27.647-13.62 6.656-1.586 12.8.154 19.15 1.025 1.535-.768 2.56-1.639 2.2-3.072-25.497-15.719-77.823-15.975-113.151-24.935 40.96 1.332 86.323-.921 117.145 8.96 24.781 22.016 32.768 63.386 45.466 91.136zm75.11-184.423c5.684.512 36.352 48.896 37.735 56.986 2.56 17.613 8.806 37.376 10.496 55.808-5.018-17.715-10.496-35.38-17.408-53.043-1.997-4.864-7.066-15.872-21.146-31.437-6.605-10.957-7.987-19.61-9.677-28.314m103.732 263.68H789.35l14.49 3.789zm-89.344-13.107a118.3 118.3 0 0 0-39.834 1.075c-5.376 7.168-5.734 14.541-8.09 21.3 16.026-17.613 22.375-18.689 47.924-22.375m179.558 91.034c-7.322 5.836-8.038 11.366-29.696 17.92-15.82 3.788-24.73-2.56-32.154-11.06 11.264 3.226 13.056 11.725 43.316 2.202zm-65.638 3.686c-5.274 14.49-10.957 29.184-16.692 42.752-13.67 15.974-7.833 6.86-28.262 31.744 6.554-10.086 15.053-19.814 19.456-30.31 3.174-6.912 7.066-14.234 8.755-20.378-5.376-2.714-16.486-2.918-17.971-1.946-18.176 10.701-21.504 22.016-32.154 33.076 7.732-12.39 14.336-25.959 23.399-37.12 1.024-1.434 7.68-1.741 11.776-2.56-6.4-1.127-18.176-3.38-19.098-3.277-11.878 2.816-18.483 13.158-27.29 19.968 6.4-9.216 12.289-18.893 20.48-26.829.769-.922 22.785 1.024 34.202 5.53l.205 4.556 6.502 2.612 4.864-12.186 11.776-5.632zm-143.719 87.398c-2.97-1.024-28.774-4.3-28.774-3.532-9.933 7.065-11.418 13.824-11.213 19.66 16.486-16.23 15.872-16.281 39.936-16.128zm-19.66-116.736s18.636-2.713 18.278-.972c-1.331 6.502 2.304 22.22 2.662 20.019l-10.445 8.55c21.914-11.008 45.056-8.806 68.455-10.496 0 0-19.712-5.427-18.535-5.632 4.404-.614-1.177-20.531-2.662-20.992 3.738-1.229 7.424-2.201 11.213-3.174-28.211-7.373-44.544-3.021-68.967 12.697"/><path d="m824.986 541.389-4.096 2.048c-.615-12.135-13.67-11.264-24.679-11.367l-8.96-2.15c2.714 2.56 11.213 2.304 7.783 7.782-2.868 1.536-4.199 8.192-5.837 13.67l-4.915.257 26.112 10.24 5.58.87 13.364-7.168z"/><path fill="#fff" d="M701.44 533.197c-2.048-4.147-12.646-3.584-14.9-.87-1.842 2.201-.153 16.179 2.254 13.823a18.07 18.07 0 0 1 13.312-4.044 16.2 16.2 0 0 0-.666-8.91m101.222 20.838c.973-.717 3.072-7.68 2.407-9.83-1.383-4.967-11.213-3.891-11.213-3.891-2.406 1.382-4.506 9.113-3.584 11.673.41 2.15 10.752 2.816 12.39 2.048"/><path d="m383.078 796.262 6.144.615c36.762 18.022 97.28 44.8 184.832 30.413l13.824 21.606c-38.604 18.74-80.128 14.438-118.988 15.77zM330.342 653.62l18.381 77.312c49.255 30.771 133.427 66.048 203.623 63.232l-15.514-35.584c-146.432-31.13-158.874-70.451-206.54-104.96zm45.773-158.259c8.96 59.904 20.992 105.267 73.063 143.309 31.948 22.937 63.59 45.773 102.144 64.665 0 0-3.38 17.562-6.196 17.255C430.438 707.84 346.47 612.762 336.333 569.344c9.83-33.28 23.961-54.118 39.782-73.984m55.091-33.946c15.31 66.356 51.712 133.632 87.962 194.56 13.312 16.896 16.742 24.32 37.222 34.56 27.648 8.704 47.207 6.503 67.277 5.172-5.53-10.138-10.393-20.788-16.691-30.362-44.954-35.533-24.218-67.891-12.288-88.422-24.986-6.298-58.06-19.712-62.618-37.376-7.372-57.088-3.635-75.264 3.687-104.55-33.792 7.167-68.096 14.233-104.5 26.418z"/><path d="M307.046 108.851c-11.11 7.27-21.862 17.664-33.382 29.44-19.098 19.815-31.846 39.117-51.302 53.402-3.892 3.379-14.797 8.755-28.519 9.574-6.451.307-10.7 1.383-22.528-.102-10.496-5.632-20.48-1.997-30.208 9.625-10.65 15.36-24.115 44.39-29.696 62.72-11.571 46.695 17.92 85.197 46.131 114.842 25.19 24.576 39.68 39.936 50.023 62.464 7.782 14.643 13.619 34.662 19.865 48.742 2.253 4.455 1.792 4.404 7.885 5.786 13.159 2.765 31.386 2.816 47.616 4.198 7.015.103 16.64-.153 25.805-1.126 12.595-2.355 27.392-4.71 39.782-8.96 12.135-3.02 22.887-7.168 32.615-10.957-1.229 4.301-10.496 8.397-13.978 13.824-32.973 47.155-41.984 89.19-36.3 155.495 3.276 29.388 10.035 53.76 20.172 81.612 4.66 12.75 14.592 32.922 24.064 46.336 28.263 39.936 91.392 91.136 179.354 110.848 15.36 2.1 32.768 1.024 49.152-3.379 43.366-13.158 131.789-44.237 131.789-44.237s-78.49 6.503-114.432 2.919c-8.346-1.28-17.51-1.741-23.296-7.424-1.024-1.229-4.506-8.346-2.253-8.448 3.123-.051 12.083-3.789 25.856-5.018-29.44-3.174-29.03-3.072-31.181-8.499a337 337 0 0 0-13.722-29.696c12.954 1.126 41.626 2.714 51.303-7.322 0 0-16.896 1.946-31.949.205a92 92 0 0 1-16.23-4.608c-6.708-2.611-12.288-3.43-13.517-5.12-2.355-5.99-3.943-7.936-6.759-15.923-3.84-10.547-4.096-22.323-4.864-33.075 9.78 12.083 22.324 22.22 38.861 27.443.205-.46 21.453 9.216 36.864 4.25l3.226-1.024c0 .256-10.24.87-13.978-.973-31.385-13.312-36.096-24.986-41.165-30.823l-13.568-20.275c4.096-8.192 6.452-8.55 11.93-8.601 16.486 1.843 23.706 3.225 33.792.819 6.758 13.977 8.602 28.006 24.064 38.195 51.507 15.309 62.669-4.557 75.162-22.016 37.068 27.136 97.382 35.533 139.264.41 53.248-61.594 70.144-158.772 65.433-164.352-6.656-11.264-15.36-22.887-22.886-21.3-26.727 7.322-36.557 20.839-63.027 17.767 3.174-.205 8.448-.256 8.499-.563 2.048-22.426-.154-33.28-1.178-35.124-7.987-17.715-18.534-36.352-25.907-50.33-1.894-2.918-7.475-24.882-16.794-33.586-3.993-3.43-13.824-12.442-13.824-12.442l-.819 9.574s3.84.564 5.325 6.503c5.53 22.528 33.638 75.622 35.686 78.182 9.984 16.128 1.024 36.147 8.602 47.411.717 1.383 15.462-.153 26.88.512 18.74-3.993 17.92-12.288 34.202-13.516 10.905-.82 12.032 19.66 11.878 21.248-2.048 22.681-8.96 48.998-19.456 73.062-21.965 42.24-46.54 80.18-81.357 85.504-42.496 7.424-64.512-11.162-87.552-22.989l-8.857 7.527c-29.901 29.798-65.434 27.136-79.975-11.776-7.219-15.104-16.64-24.372-24.73-37.376l-42.803 30.873c-3.584 7.322-7.987 18.842-13.312 31.744a105.5 105.5 0 0 0-6.604 37.069c-5.479 9.318 19.046 47.258 34.508 70.298l13.364 19.456c3.072 7.936 9.83 15.001 10.24 15.872 28.672 37.478-36.25 28.825-49.664 26.572-26.522-4.198-52.43-15.308-76.8-30.054l-4.199-2.611a444.3 444.3 0 0 1-78.182-64.615c-13.466-15.257-26.317-46.592-35.84-68.812-14.183-53.402-34.611-145.92 20.685-216.064 3.481-3.994 7.27-10.701 10.496-12.032 16.435-11.11 34.304-18.688 53.452-22.887l-1.945-12.441a358.6 358.6 0 0 0-50.944 18.944c-20.736 5.99-37.94 12.288-64.41 18.944-8.601 1.024-17.05 1.024-25.293-.103-18.995-2.56-51.404-.256-53.504-2.201-12.85-17.92-16.384-50.125-28.16-67.328l-.102-.205-.154-.154c-6.86-9.216-14.848-16.691-22.732-24.525-28.16-27.955-52.224-55.04-58.983-83.712-1.69-8.448-6.041-17.203-3.737-42.24v-.153l.102-.103c6.758-23.398 17.766-42.496 36.454-61.593 19.456.307 38.759.768 53.76 3.584 6.861 1.177 21.197 3.072 35.994 8.55 37.427 13.978 86.886 36.864 86.886 36.864-37.12-20.377-78.643-46.848-104.857-52.224-3.891-.512-6.298-2.304-7.424-5.427 39.424-23.142 46.592-50.432 72.55-74.906 11.879-5.12 16.487-7.782 26.573-8.857 93.133 14.694 151.757 51.814 198.144 76.595 18.842 10.24 35.942 17.971 52.275 27.34 14.336 4.711 57.549 37.377 70.247 54.938 12.8 27.136 22.22 56.423 30.77 84.736 6.145 28.775 11.52 40.448 11.52 40.448s-5.222-24.064-4.351-28.416c5.427 2.048 18.227 6.042 23.552 5.428 0 0-23.706-12.288-26.829-23.04-9.933-34.765-19.968-88.781-22.63-91.597-7.578-9.523-39.22-33.792-58.624-44.954-7.322-4.25-11.264-6.86-11.623-8.704 6.195-6.297 13.824-14.592 20.736-19.814 6.554-5.069 12.544-10.752 21.76-14.183 40.295-18.124 63.335 7.015 68.813 1.895 0 0-8.704-9.933-4.813-8.295 3.943 2.15 16.794 4.66 18.227 5.99 14.695 11.47 53.095 53.454 76.237 97.793 5.581 10.854 7.834 18.022 5.223 31.078-2.56 13.107-4.608 20.275-7.373 29.03-2.56 5.837-16.999 45.825-16.896 51.2-2.919 21.965 9.37 49.46 9.37 49.46.153-7.475-.461-11.469.255-16.794l.82-9.523s-.512-2.56-.461-3.584c.665-6.554 2.253-12.083 2.713-15.872 4.608-28.672 12.698-49.306 21.812-74.445 2.713-6.349 6.246-9.881 6.092-14.694.154-8.602-7.526-20.07-13.056-31.335-5.632-11.366-12.288-24.064-21.094-37.376-19.968-28.774-37.069-51.302-68.3-65.382-8.705-3.84-43.111-7.578-54.99-5.376-14.387 3.02-26.777 5.99-36.659 12.288-15.565 9.984-27.75 25.395-42.086 34.458-31.744-15.872-47.002-27.7-49.869-29.338-18.842-10.086-41.472-21.811-65.74-32.922-11.674-10.905-84.122-36.864-150.426-42.086h-.052zm405.402 591.104c-19.558-15.257-35.994-31.027-46.848-47.155-3.533 18.995-16.384 32.563-26.317 45.875-1.945 3.123-3.379 7.424 6.349 20.992 2.611 3.635 12.134 4.25 18.534 3.943-6.502-4.967-16.435-10.138-18.022-14.695 11.469 7.834 22.016 10.087 31.642 8.807 2.201-.256 4.915-2.56 7.014-6.144 4.3-9.216 7.68-11.418 11.008-13.876l7.834 9.728z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/influxdb.svg b/apps/desktop/public/icons/database/influxdb.svg
new file mode 100644
index 0000000..18239a1
--- /dev/null
+++ b/apps/desktop/public/icons/database/influxdb.svg
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg width="154" height="156" viewBox="0 0 154 156" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path fill-rule="evenodd" clip-rule="evenodd" d="m 111.76244,105.55719 33.75203,-7.710196 c 0.51964,-0.104857 1.01231,-0.316521 1.4455,-0.621423 0.43411,-0.304901 0.7985,-0.696439 1.0718,-1.149608 0.27329,-0.453077 0.44899,-0.958023 0.51591,-1.482398 0.066,-0.524375 0.0223,-1.056837 -0.12921,-1.563456 l -14.3536,-62.024578 c -0.25936,-1.023558 -0.91564,-1.902939 -1.82477,-2.445254 -0.90912,-0.542316 -1.99673,-0.703319 -3.02484,-0.447685 l -33.738648,7.709824 c -1.021327,0.261025 -1.897268,0.914332 -2.43633,1.817045 -0.538969,0.902713 -0.697276,1.981302 -0.440062,2.99984 l 14.31261,62.025039 c 0.25936,1.02347 0.91471,1.90285 1.82383,2.44479 0.90913,0.54195 1.99767,0.70369 3.02578,0.44806 z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="m 100.13156,143.8846 40.92187,-37.74642 c 1.5431,-1.55054 1.15361,-2.50522 -0.97234,-1.74389 l -28.12437,6.36667 c -1.1629,0.28631 -2.2347,0.85986 -3.11687,1.6686 -0.88124,0.8078 -1.54403,1.82383 -1.92702,2.95512 l -8.532589,27.35097 c -0.58331,2.11757 0.195211,2.69856 1.751319,1.14895 z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="m 25.47096,131.56491 61.279242,18.86671 c 1.046984,0.19428 2.129198,0.0111 3.053291,-0.51685 0.924,-0.52707 1.629642,-1.36462 1.990783,-2.36205 l 10.268954,-32.74995 c 0.14873,-0.51034 0.19428,-1.04578 0.13479,-1.57378 -0.0586,-0.52893 -0.22217,-1.04019 -0.4806,-1.50591 -0.25842,-0.46572 -0.60608,-0.87566 -1.02346,-1.20752 -0.41738,-0.33093 -0.897043,-0.57727 -1.41017,-0.72322 L 38.004733,91.105883 c -1.037315,-0.295606 -2.149927,-0.170392 -3.095028,0.34822 -0.945009,0.518704 -1.645632,1.388696 -1.949046,2.420155 L 22.761334,126.55449 c -0.302949,1.02253 -0.188147,2.12222 0.31931,3.0611 0.507549,0.93794 1.366665,1.63884 2.390316,1.94932 z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="m 5.6834977,64.52991 12.4226043,54.1901 c 0.389028,2.11758 1.389533,2.11758 1.931477,0 l 8.531849,-27.35115 c 0.290772,-1.165411 0.30267,-2.3826 0.03477,-3.553403 C 28.33629,86.644654 27.796019,85.552772 27.02698,84.628028 L 7.4343376,63.560918 C 6.0725724,61.969203 5.0581988,62.412053 5.6834977,64.52991 Z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M 53.595516,6.602436 6.6564671,49.885345 c -0.7530573,0.714101 -1.1951843,1.693783 -1.2315519,2.728775 -0.036368,1.035084 0.3359197,2.043118 1.0370099,2.807882 L 29.931445,80.710788 c 0.723304,0.764299 1.72009,1.213378 2.773859,1.249632 1.05377,0.03635 2.079373,-0.343107 2.853897,-1.055815 l 46.92517,-43.352152 c 0.759558,-0.710384 1.206313,-1.691181 1.242752,-2.728404 0.03644,-1.037222 -0.340411,-2.046744 -1.048285,-2.808254 L 59.250973,6.7408501 C 58.890669,6.3587779 58.457672,6.0518109 57.977266,5.8377701 57.496767,5.6237302 56.978435,5.5068801 56.452294,5.4940029 55.926153,5.4811258 55.402708,5.5724784 54.912263,5.7627578 54.42191,5.9530368 53.974319,6.2384524 53.595516,6.602436 Z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="m 98.964945,104.58764 c 2.139885,0.58192 3.487775,-0.56704 2.917945,-2.76828 L 88.30678,43.269262 C 87.723098,41.151498 85.972332,40.57014 84.429884,42.106546 L 40.214339,83.022555 c -1.556299,1.536406 -1.167177,3.266629 0.958767,3.847986 z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M 122.0445,22.922017 68.519141,6.6026591 C 66.393197,6.0213059 66.004075,6.7964388 67.740991,8.5266523 L 87.333698,29.524435 c 0.878916,0.818493 1.941981,1.415188 3.099956,1.740262 1.158067,0.325166 2.377394,0.369135 3.556006,0.128374 l 28.12456,-6.353291 c 2.07017,-0.581357 2.07017,-1.550256 -0.0697,-2.117763 z" fill="#d30971" />
+</svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/informix.svg b/apps/desktop/public/icons/database/informix.svg
new file mode 100644
index 0000000..60426de
--- /dev/null
+++ b/apps/desktop/public/icons/database/informix.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#fff" d="M551.629 505.907a49.7 49.7 0 0 0-21.248-3.993c-21.76 0-33.28 17.766-33.28 37.888v70.45h-33.792V472.116H497.1v15.463c7.475-12.032 21.248-17.204 31.59-17.767a42.96 42.96 0 0 1 22.938 3.43zm-539.546-93.44h35.021v197.786h-35.02zm291.84 88.883H266.65v108.954h-33.792V501.35h-17.204v-29.235h17.204v-11.469c0-29.235 20.633-48.128 53.862-48.128h17.203v29.184h-9.216c-22.886 0-28.057 8.602-28.057 27.546v2.867h37.273zm138.752 39.578c0 40.704-25.241 72.192-67.635 72.192-43.008 0-68.25-31.488-68.25-72.192 0-41.318 25.242-71.117 68.25-71.117 42.394 0 67.635 29.799 67.635 71.117m-33.28 0c0-22.374-9.165-42.445-34.355-42.445-25.805 0-34.97 20.634-34.97 42.445 0 22.886 8.602 43.008 34.97 43.008 25.805 0 34.406-20.122 34.406-43.008zm-208.077 69.325h-33.894v-75.674c0-20.07-6.912-33.792-27.546-33.229-17.766 0-29.184 11.47-29.184 34.407v74.547H76.851v-138.24h33.792v10.342c9.728-8.601 24.064-12.595 37.274-12.595 32.717 0 53.35 21.811 53.35 54.477v86.016zm398.439 0v-81.92c0-15.514 2.304-26.983 17.203-26.983 9.216 0 14.336 4.608 14.336 21.76v87.194h33.792v-82.022c0-15.463 2.355-26.932 17.254-26.932 9.165 0 14.336 4.608 14.336 21.76v87.194h33.792V509.952a39.58 39.58 0 0 0-10.29-28.672 41.98 41.98 0 0 0-30.977-11.469 50.7 50.7 0 0 0-32.102 10.906c-9.165-8.602-17.767-10.906-29.235-10.906a39.94 39.94 0 0 0-28.11 11.469v-9.216h-33.791v138.24h33.792z"/><path fill="#d35d35" d="M819.354 450.867c12.032 0 21.196-9.165 21.196-20.633a20.685 20.685 0 0 0-21.196-20.634 20.582 20.582 0 1 0 0 41.267m.563 55.04-26.931 70.554a81 81 0 0 0-3.43 10.905c-1.127 5.12 1.74 5.735 5.12 3.994 9.778-4.045 21.247-21.197 26.418-27.546l4.608 2.304c-10.342 18.944-29.85 47.616-53.913 47.616-10.906 0-17.203-7.475-17.767-17.203-.614-8.601 2.868-16.64 5.12-24.064l25.805-66.56a276 276 0 0 0 4.045-11.469c.512-4.608-2.304-5.12-5.734-3.43-9.728 4.045-21.248 21.248-26.368 27.546l-4.608-2.304c10.905-18.944 30.412-47.616 54.476-47.616 10.292 0 15.463 4.608 17.204 12.646 1.126 5.734 0 13.773-4.045 24.627"/><path fill="#3b68af" d="m825.702 610.304 67.584-10.906-55.552-4.044 65.895-10.292-55.603-5.17 65.945-9.729-55.603-5.171 66.509-9.216-56.218-6.86 66.56-7.425-65.997-8.038 56.218-6.912-65.946-8.602 56.167-5.683-65.895-9.728 55.604-4.608-65.383-10.342 55.655-3.994-67.072-11.469h76.236l25.805 39.527 25.19-39.527h43.623l-48.18 68.813 52.174 69.325h-43.572l-29.235-42.394-29.85 42.394h-75.059zm190.31-139.93h3.994c3.482 0 4.608-1.126 4.608-2.867s-1.126-2.304-3.993-2.304h-4.608zm5.12-6.86c4.097 0 6.35 1.126 6.35 3.993 0 1.741-.564 2.304-2.304 3.43l.614.564.512 1.177c.614.564.614 1.127.614 2.304v1.127l.564.563v1.74h-2.304c-.512-.562-.512-.562-.512-2.303 0-3.43-.615-3.994-4.608-3.994h-4.045v6.298h-2.253v-14.9h7.475zm-13.72 7.424c0 6.912 5.734 12.646 13.209 12.646a12.75 12.75 0 0 0 12.595-12.646 12.29 12.29 0 0 0-12.595-12.032c-7.475 0-13.21 5.17-13.21 12.032m28.671 0c0 8.038-6.86 14.336-15.462 14.336s-15.514-6.298-15.514-14.336c0-7.988 6.912-14.336 15.514-14.336s15.462 6.348 15.462 14.336"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/iotdb.svg b/apps/desktop/public/icons/database/iotdb.svg
new file mode 100644
index 0000000..d742630
--- /dev/null
+++ b/apps/desktop/public/icons/database/iotdb.svg
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 24.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1"
+	 id="Õ_xBA__x2264__x201E__1" xmlns:cc="http://creativecommons.org/ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:svg="http://www.w3.org/2000/svg"
+	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 107.7 107.7"
+	 style="enable-background:new 0 0 107.7 107.7;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill-rule:evenodd;clip-rule:evenodd;fill:#9E2878;}
+</style>
+<g>
+	<g id="g1133" transform="translate(-244.51235,-228.78793)">
+		<path id="path1119" class="st0" d="M340.8,253.8c2.6-1,5.5,0.4,6.2,3c0.7,2.6-1.1,5.7-3.7,6.4c-3.2,0.6-6.2-1.4-9.3,0.2
+			c-3.1,1.7-4,5.2-4.7,8.3c-1.4,5-8.5,7.3-12.1,4.2c-3.3-2.4-3.4-7.8-0.2-11c2.2-2.5,5.9-3.3,8.8-2c2.7,1.2,6,1.7,8.6-0.4
+			C337.5,260.1,336.7,255.1,340.8,253.8L340.8,253.8z"/>
+		<path id="path1121" class="st0" d="M280.5,244.7c4.2-2.2,9.5,1.5,8.2,6.1c-1.4,5.4-0.7,11.5,2.9,15.5c3.4,4,9.8,4.8,14.6,1.9
+			c3.7-2.1,6-5.8,7.4-9.6c1-3.1,0.6-6.2,1.1-9.3c1-3.8,5.8-6,9.1-4.2c3.2,1.4,4,5.9,1.7,8.8c-1.4,2.2-4.2,2.7-6.3,3.8
+			c-3.6,1.9-6.5,4.9-8.4,8.6c-1.2,2.1-1.1,4.5-1.7,6.7c-0.9,1.9-3,2.7-4.8,2.9c-4.8,0.6-9.5,3-13,6.7c-1.7,1.7-3.1,4.2-5.6,4.2
+			c-2.7-0.2-4.7-2.6-7.4-2.7c-4.9-0.7-10.2,0.7-14.4,4c-3.7,3.1-9.4,0.8-9.6-3.7c-0.9-5.1,6.2-9.5,10.1-6.2c4.3,4,10.8,5.6,16.9,3.7
+			c5.6-1.9,9.7-8.3,8.6-14c-0.9-4.9-4.2-9.3-8.6-11.4c-1.7-0.8-3.6-1.6-4.2-3.5C275.6,250.2,277.3,246.2,280.5,244.7L280.5,244.7z"
+			/>
+		<path id="path1123" class="st0" d="M277.8,235.9c2.2-0.8,4.2,1.3,3.3,3.4c-0.6,2.1-3.7,2.7-4.8,1.1
+			C275,238.9,276,236.4,277.8,235.9z"/>
+		<path id="path1125" class="st0" d="M246.9,278.8c2.2-0.8,4.2,1.2,3.3,3.4c-0.6,2.1-3.7,2.7-4.8,1C244,281.9,245,279.3,246.9,278.8
+			L246.9,278.8z"/>
+		<path id="path1127" class="st0" d="M328.2,236.2c2.2-0.7,4.2,1.3,3.3,3.5c-0.6,2-3.7,2.7-4.8,1
+			C325.4,239.2,326.3,236.8,328.2,236.2z"/>
+		<path id="path1129" class="st0" d="M253.6,257.7c0.4-3.7,5.5-5.9,8.1-3.6c1.9,1.1,1.6,3.6,2.2,5.4c0.4,2.4,2.7,4.3,5.2,4.3
+			c3.2,0.3,6.4-2.3,9.5-1.2c4.8,1.2,6.5,7.5,3.2,11.5c-2.9,4.1-9.3,4.5-12,0.7c-2.4-2.8-0.5-7.1-2.7-10.1c-1.7-2.9-5.4-2.7-8.3-1.9
+			C255.8,263.8,253,260.7,253.6,257.7L253.6,257.7z"/>
+		<path id="path1131" class="st0" d="M300.8,230c3.3-1.9,7.5,0.9,6.7,4.6c0,2.3-2.2,3.6-3.5,5.2c-1.9,1.9-2.3,4.9-1.2,7
+			c1.3,2.9,4.9,4,5.5,7.2c1.2,4.8-3.3,10.1-8.2,9.8c-4.8,0.1-8.3-5-6.3-9.5c1.2-3.8,5.8-4.9,7.2-8.5c1.7-3.2-0.4-6.1-2.4-8.1
+			C296.7,235.6,297.9,231.4,300.8,230z"/>
+	</g>
+	<g id="g1149" transform="translate(-244.51235,-228.78793)">
+		<path id="path1135" class="st0" d="M256,311.5c-2.6,1-5.5-0.4-6.2-3c-0.7-2.6,1.1-5.7,3.7-6.4c3.2-0.6,6.2,1.4,9.3-0.2
+			c3.1-1.6,4-5.1,4.7-8.2c1.4-5,8.5-7.3,12.1-4.2c3.3,2.4,3.4,7.8,0.2,10.9c-2.2,2.5-5.9,3.3-8.8,2c-2.7-1.2-6-1.7-8.6,0.4
+			C259.1,305,259.9,310.2,256,311.5L256,311.5z"/>
+		<path id="path1137" class="st0" d="M316.1,320.5c-4.2,2.2-9.5-1.5-8.2-6c1.4-5.4,0.7-11.6-2.9-15.6c-3.4-4-9.8-4.7-14.6-1.9
+			c-3.7,2-6,5.7-7.4,9.5c-1,3.1-0.6,6.2-1.1,9.3c-1,3.8-5.8,6-9.1,4.3c-3.2-1.4-4-5.9-1.7-8.9c1.4-2.2,4.2-2.7,6.3-3.8
+			c3.6-1.9,6.5-4.9,8.4-8.6c1.2-2,1.1-4.5,1.7-6.6c0.9-1.9,3-2.7,4.8-2.9c4.8-0.6,9.5-3,13-6.7c1.7-1.6,3.1-4.2,5.6-4.1
+			c2.7,0.1,4.7,2.5,7.4,2.7c4.9,0.6,10.2-0.8,14.4-4c3.7-3.2,9.4-0.9,9.6,3.6c0.9,5.1-6.2,9.5-10.1,6.2c-4.3-4-10.8-5.6-16.9-3.7
+			c-5.6,1.9-9.7,8.3-8.6,14c0.9,4.8,4.2,9.3,8.6,11.3c1.7,0.8,3.6,1.6,4.2,3.5C321.2,314.9,319.4,319.1,316.1,320.5L316.1,320.5z"/>
+		<path id="path1139" class="st0" d="M318.9,329.4c-2.2,0.8-4.2-1.3-3.3-3.4c0.6-2.1,3.7-2.7,4.8-1.1
+			C321.7,326.3,320.7,328.8,318.9,329.4z"/>
+		<path id="path1141" class="st0" d="M349.9,286.5c-2.2,0.7-4.2-1.3-3.3-3.5c0.6-2.1,3.7-2.7,4.8-1
+			C352.8,283.5,351.8,285.9,349.9,286.5z"/>
+		<path id="path1143" class="st0" d="M268.5,329c-2.2,0.7-4.2-1.3-3.3-3.5c0.6-2,3.7-2.7,4.8-1C271.3,325.9,270.3,328.5,268.5,329z"
+			/>
+		<path id="path1145" class="st0" d="M343.1,307.4c-0.4,3.7-5.5,5.9-8.1,3.6c-1.9-1.1-1.6-3.6-2.2-5.4c-0.4-2.4-2.7-4.3-5.2-4.3
+			c-3.2-0.3-6.4,2.3-9.5,1.2c-4.8-1.2-6.5-7.5-3.2-11.5c2.9-4.1,9.3-4.5,12-0.7c2.4,2.8,0.5,7,2.7,10c1.7,2.9,5.4,2.7,8.3,1.9
+			C341,301.4,343.8,304.4,343.1,307.4L343.1,307.4z"/>
+		<path id="path1147" class="st0" d="M295.8,335.2c-3.3,2-7.5-0.9-6.7-4.6c0-2.3,2.2-3.6,3.5-5.2c1.9-1.9,2.3-4.9,1.2-7
+			c-1.3-2.9-4.9-4-5.5-7.2c-1.2-4.8,3.3-10.1,8.2-9.8c4.8-0.1,8.3,5,6.3,9.6c-1.2,3.7-5.8,4.8-7.2,8.4c-1.7,3.2,0.4,6.1,2.4,8.2
+			C300,329.6,298.8,333.8,295.8,335.2L295.8,335.2z"/>
+	</g>
+</g>
+</svg>
diff --git a/apps/desktop/public/icons/database/iris.png b/apps/desktop/public/icons/database/iris.png
new file mode 100644
index 0000000..e4be5d9
Binary files /dev/null and b/apps/desktop/public/icons/database/iris.png differ
diff --git a/apps/desktop/public/icons/database/kafka.svg b/apps/desktop/public/icons/database/kafka.svg
new file mode 100644
index 0000000..a25ab74
--- /dev/null
+++ b/apps/desktop/public/icons/database/kafka.svg
@@ -0,0 +1,26 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="48" height="48" viewBox="0 0 48 48" fill="none">
+  <!-- Kafka network topology icon (symbol only, no text) -->
+  <!-- Central node (larger) -->
+  <circle cx="24" cy="24" r="5" fill="#231F20" stroke="#F8FAFC" stroke-width="2"/>
+  <!-- Top node -->
+  <circle cx="24" cy="6" r="3.5" fill="#231F20" stroke="#F8FAFC" stroke-width="2"/>
+  <!-- Bottom node -->
+  <circle cx="24" cy="42" r="3.5" fill="#231F20" stroke="#F8FAFC" stroke-width="2"/>
+  <!-- Upper-left node -->
+  <circle cx="8" cy="14" r="3.5" fill="#231F20" stroke="#F8FAFC" stroke-width="2"/>
+  <!-- Lower-left node -->
+  <circle cx="8" cy="34" r="3.5" fill="#231F20" stroke="#F8FAFC" stroke-width="2"/>
+  <!-- Right node -->
+  <circle cx="40" cy="24" r="3.5" fill="#231F20" stroke="#F8FAFC" stroke-width="2"/>
+  <!-- Connecting lines -->
+  <line x1="24" y1="19" x2="24" y2="9.5" stroke="#F8FAFC" stroke-width="4" stroke-linecap="round"/>
+  <line x1="24" y1="19" x2="24" y2="9.5" stroke="#231F20" stroke-width="1.5"/>
+  <line x1="24" y1="29" x2="24" y2="38.5" stroke="#F8FAFC" stroke-width="4" stroke-linecap="round"/>
+  <line x1="24" y1="29" x2="24" y2="38.5" stroke="#231F20" stroke-width="1.5"/>
+  <line x1="20.5" y1="21.5" x2="11" y2="16" stroke="#F8FAFC" stroke-width="4" stroke-linecap="round"/>
+  <line x1="20.5" y1="21.5" x2="11" y2="16" stroke="#231F20" stroke-width="1.5"/>
+  <line x1="20.5" y1="26.5" x2="11" y2="32" stroke="#F8FAFC" stroke-width="4" stroke-linecap="round"/>
+  <line x1="20.5" y1="26.5" x2="11" y2="32" stroke="#231F20" stroke-width="1.5"/>
+  <line x1="29" y1="24" x2="36.5" y2="24" stroke="#F8FAFC" stroke-width="4" stroke-linecap="round"/>
+  <line x1="29" y1="24" x2="36.5" y2="24" stroke="#231F20" stroke-width="1.5"/>
+</svg>
diff --git a/apps/desktop/public/icons/database/kingbase.svg b/apps/desktop/public/icons/database/kingbase.svg
new file mode 100644
index 0000000..9d7f076
--- /dev/null
+++ b/apps/desktop/public/icons/database/kingbase.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#c9151e" d="M339.2 204.8v236.083l-148.531 73.421 148.48 69.99v239.104h130.457V650.342L833.28 823.398V687.872L469.606 514.304 833.28 338.381V209.05L469.606 377.702V204.8z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/kwdb.svg b/apps/desktop/public/icons/database/kwdb.svg
new file mode 100644
index 0000000..4877759
--- /dev/null
+++ b/apps/desktop/public/icons/database/kwdb.svg
@@ -0,0 +1 @@
+<svg id="图层_1" data-name="图层 1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 371.33 401.04"><defs><style>.cls-1{fill:none;}.cls-2{clip-path:url(#clip-path);}.cls-3{fill:#002db2;}.cls-4{fill:#012eb2;}.cls-5{fill:#012fb2;}.cls-6{fill:#0230b2;}.cls-7{fill:#0231b3;}.cls-8{fill:#0332b3;}.cls-9{fill:#0433b3;}.cls-10{fill:#0434b3;}.cls-11{fill:#0535b3;}.cls-12{fill:#0636b3;}.cls-13{fill:#0637b3;}.cls-14{fill:#0738b3;}.cls-15{fill:#0739b4;}.cls-16{fill:#083ab4;}.cls-17{fill:#093bb4;}.cls-18{fill:#093cb4;}.cls-19{fill:#0a3db4;}.cls-20{fill:#0b3eb4;}.cls-21{fill:#0b3fb4;}.cls-22{fill:#0c40b5;}.cls-23{fill:#0c41b5;}.cls-24{fill:#0d42b5;}.cls-25{fill:#0e43b5;}.cls-26{fill:#0e44b5;}.cls-27{fill:#0f45b5;}.cls-28{fill:#1046b5;}.cls-29{fill:#1047b5;}.cls-30{fill:#1148b6;}.cls-31{fill:#1149b6;}.cls-32{fill:#124ab6;}.cls-33{fill:#134bb6;}.cls-34{fill:#134cb6;}.cls-35{fill:#144db6;}.cls-36{fill:#144eb6;}.cls-37{fill:#154fb7;}.cls-38{fill:#1650b7;}.cls-39{fill:#1651b7;}.cls-40{fill:#1752b7;}.cls-41{fill:#1853b7;}.cls-42{fill:#1854b7;}.cls-43{fill:#1955b7;}.cls-44{fill:#1956b7;}.cls-45{fill:#1a57b8;}.cls-46{fill:#1b58b8;}.cls-47{fill:#1b59b8;}.cls-48{fill:#1c5ab8;}.cls-49{fill:#1d5bb8;}.cls-50{fill:#1d5cb8;}.cls-51{fill:#1e5db8;}.cls-52{fill:#1e5eb8;}.cls-53{fill:#1f5fb9;}.cls-54{fill:#2060b9;}.cls-55{fill:#2061b9;}.cls-56{fill:#2162b9;}.cls-57{fill:#2263b9;}.cls-58{fill:#2264b9;}.cls-59{fill:#2365b9;}.cls-60{fill:#2366ba;}.cls-61{fill:#2467ba;}.cls-62{fill:#2568ba;}.cls-63{fill:#2569ba;}.cls-64{fill:#266aba;}.cls-65{fill:#266bba;}.cls-66{fill:#276cba;}.cls-67{fill:#286dba;}.cls-68{fill:#286ebb;}.cls-69{fill:#296fbb;}.cls-70{fill:#2a70bb;}.cls-71{fill:#2a71bb;}.cls-72{fill:#2b72bb;}.cls-73{fill:#2b73bb;}.cls-74{fill:#2c74bb;}.cls-75{fill:#2d75bc;}.cls-76{fill:#2d76bc;}.cls-77{fill:#2e77bc;}.cls-78{fill:#2f78bc;}.cls-79{fill:#2f79bc;}.cls-80{fill:#307abc;}.cls-81{fill:#307bbc;}.cls-82{fill:#317cbc;}.cls-83{fill:#327dbd;}.cls-84{fill:#327ebd;}.cls-85{fill:#337fbd;}.cls-86{fill:#3380bd;}.cls-87{fill:#3482bd;}.cls-88{fill:#3583bd;}.cls-89{fill:#3584bd;}.cls-90{fill:#3685be;}.cls-91{fill:#3786be;}.cls-92{fill:#3787be;}.cls-93{fill:#3888be;}.cls-94{fill:#3889be;}.cls-95{fill:#398abe;}.cls-96{fill:#3a8bbe;}.cls-97{fill:#3a8cbe;}.cls-98{fill:#3b8dbf;}.cls-99{fill:#3c8ebf;}.cls-100{fill:#3c8fbf;}.cls-101{fill:#3d90bf;}.cls-102{fill:#3d91bf;}.cls-103{fill:#3e92bf;}.cls-104{fill:#3f93bf;}.cls-105{fill:#3f94c0;}.cls-106{fill:#4095c0;}.cls-107{fill:#4196c0;}.cls-108{fill:#4197c0;}.cls-109{fill:#4298c0;}.cls-110{fill:#4299c0;}.cls-111{fill:#439ac0;}.cls-112{fill:#449bc0;}.cls-113{fill:#449cc1;}.cls-114{fill:#459dc1;}.cls-115{fill:#459ec1;}.cls-116{fill:#469fc1;}.cls-117{fill:#47a0c1;}.cls-118{fill:#47a1c1;}.cls-119{fill:#48a2c1;}.cls-120{fill:#49a3c2;}.cls-121{fill:#49a4c2;}.cls-122{fill:#4aa5c2;}.cls-123{fill:#4aa6c2;}.cls-124{fill:#4ba7c2;}.cls-125{fill:#4ca8c2;}.cls-126{fill:#4ca9c2;}.cls-127{fill:#4daac2;}.cls-128{fill:#4eabc3;}.cls-129{fill:#4eacc3;}.cls-130{fill:#4fadc3;}.cls-131{fill:#4faec3;}.cls-132{fill:#50afc3;}.cls-133{fill:#51b0c3;}.cls-134{fill:#51b1c3;}.cls-135{fill:#52b2c3;}.cls-136{fill:#53b3c4;}.cls-137{fill:#53b4c4;}.cls-138{fill:#54b5c4;}.cls-139{fill:#54b6c4;}.cls-140{fill:#55b7c4;}.cls-141{fill:#56b8c4;}.cls-142{fill:#56b9c4;}.cls-143{fill:#57bac5;}.cls-144{fill:#57bbc5;}.cls-145{fill:#58bcc5;}.cls-146{fill:#59bdc5;}.cls-147{fill:#59bec5;}.cls-148{fill:#5abfc5;}.cls-149{fill:#5bc0c5;}.cls-150{fill:#5bc1c5;}.cls-151{fill:#5cc2c6;}.cls-152{fill:#5cc3c6;}.cls-153{fill:#5dc4c6;}.cls-154{fill:#5ec5c6;}.cls-155{fill:#5ec6c6;}.cls-156{fill:#5fc7c6;}.cls-157{fill:#60c8c6;}.cls-158{fill:#60c9c7;}.cls-159{fill:#61cac7;}.cls-160{fill:#61cbc7;}.cls-161{fill:#62ccc7;}.cls-162{fill:#63cdc7;}.cls-163{fill:#63cec7;}.cls-164{fill:#64cfc7;}.cls-165{fill:#65d0c7;}.cls-166{fill:#65d1c8;}.cls-167{fill:#66d2c8;}.cls-168{fill:#66d3c8;}.cls-169{fill:#67d4c8;}.cls-170{clip-path:url(#clip-path-2);}.cls-171{fill:#66d3c9;}.cls-172{fill:#66d2c9;}.cls-173{fill:#65d1ca;}.cls-174{fill:#64d0cb;}.cls-175{fill:#64cfcb;}.cls-176{fill:#63cecc;}.cls-177{fill:#62cdcd;}.cls-178{fill:#62cccd;}.cls-179{fill:#61cbce;}.cls-180{fill:#60cacf;}.cls-181{fill:#60c9cf;}.cls-182{fill:#5fc8d0;}.cls-183{fill:#5ec7d1;}.cls-184{fill:#5ec6d1;}.cls-185{fill:#5dc5d2;}.cls-186{fill:#5cc4d3;}.cls-187{fill:#5cc3d3;}.cls-188{fill:#5bc2d4;}.cls-189{fill:#5ac1d5;}.cls-190{fill:#59bfd6;}.cls-191{fill:#59bed6;}.cls-192{fill:#58bdd7;}.cls-193{fill:#57bcd8;}.cls-194{fill:#57bbd8;}.cls-195{fill:#56bad9;}.cls-196{fill:#55b9da;}.cls-197{fill:#55b8da;}.cls-198{fill:#54b7db;}.cls-199{fill:#53b6dc;}.cls-200{fill:#53b5dc;}.cls-201{fill:#52b4dd;}.cls-202{fill:#51b3de;}.cls-203{fill:#51b2de;}.cls-204{fill:#50b1df;}.cls-205{fill:#4fb0e0;}.cls-206{fill:#4fafe0;}.cls-207{fill:#4eaee1;}.cls-208{fill:#4dade2;}.cls-209{fill:#4dace2;}.cls-210{fill:#4cabe3;}.cls-211{fill:#4baae4;}.cls-212{fill:#4ba9e4;}.cls-213{fill:#4aa8e5;}.cls-214{fill:#49a7e6;}.cls-215{fill:#48a6e7;}.cls-216{fill:#48a5e7;}.cls-217{fill:#47a4e8;}.cls-218{fill:#46a3e9;}.cls-219{fill:#46a2e9;}.cls-220{fill:#45a1ea;}.cls-221{fill:#44a0eb;}.cls-222{fill:#449feb;}.cls-223{fill:#439eec;}.cls-224{fill:#429ded;}.cls-225{fill:#419cee;}.cls-226{fill:#419bee;}.cls-227{fill:#409aef;}.cls-228{fill:#3f99f0;}.cls-229{fill:#3f98f0;}.cls-230{fill:#3e96f1;}.cls-231{fill:#3d95f2;}.cls-232{fill:#3d94f2;}.cls-233{fill:#3c93f3;}.cls-234{fill:#3b92f4;}.cls-235{fill:#3a91f5;}.cls-236{fill:#3a90f5;}.cls-237{fill:#398ff6;}.cls-238{fill:#388ef7;}.cls-239{fill:#388df7;}.cls-240{fill:#378cf8;}.cls-241{fill:#368bf9;}.cls-242{fill:#368af9;}.cls-243{fill:#3589fa;}.cls-244{fill:#3488fb;}.cls-245{fill:#3387fc;}.cls-246{fill:#3386fc;}.cls-247{fill:#3285fd;}.cls-248{fill:#3184fe;}.cls-249{fill:#3183fe;}.cls-250{fill:#3082ff;}.cls-251{clip-path:url(#clip-path-3);}.cls-252{fill:#012eb3;}.cls-253{fill:#012fb4;}.cls-254{fill:#0230b5;}.cls-255{fill:#0231b6;}.cls-256{fill:#0332b7;}.cls-257{fill:#0333b8;}.cls-258{fill:#0434b8;}.cls-259{fill:#0535b9;}.cls-260{fill:#0536ba;}.cls-261{fill:#0637bb;}.cls-262{fill:#0638bc;}.cls-263{fill:#0739bd;}.cls-264{fill:#073abe;}.cls-265{fill:#083bbf;}.cls-266{fill:#093cc0;}.cls-267{fill:#093dc1;}.cls-268{fill:#0a3ec2;}.cls-269{fill:#0a3fc3;}.cls-270{fill:#0b40c4;}.cls-271{fill:#0c42c5;}.cls-272{fill:#0c43c5;}.cls-273{fill:#0d44c6;}.cls-274{fill:#0d45c7;}.cls-275{fill:#0e46c8;}.cls-276{fill:#0e47c9;}.cls-277{fill:#0f48ca;}.cls-278{fill:#1049cb;}.cls-279{fill:#104acc;}.cls-280{fill:#114bcd;}.cls-281{fill:#114cce;}.cls-282{fill:#124dcf;}.cls-283{fill:#124ed0;}.cls-284{fill:#134fd1;}.cls-285{fill:#1450d1;}.cls-286{fill:#1451d2;}.cls-287{fill:#1552d3;}.cls-288{fill:#1553d4;}.cls-289{fill:#1654d5;}.cls-290{fill:#1655d6;}.cls-291{fill:#1756d7;}.cls-292{clip-path:url(#clip-path-4);}.cls-293{fill:#0331b3;}.cls-294{fill:#0738b4;}.cls-295{fill:#0839b4;}.cls-296{fill:#0b3fb5;}.cls-297{fill:#0d41b5;}.cls-298{fill:#0f44b5;}.cls-299{fill:#1047b6;}.cls-300{fill:#1249b6;}.cls-301{fill:#144cb6;}.cls-302{fill:#154eb7;}.cls-303{fill:#164fb7;}.cls-304{fill:#1751b7;}.cls-305{fill:#1954b7;}.cls-306{fill:#1956b8;}.cls-307{fill:#1c5bb8;}.cls-308{fill:#1e5db9;}.cls-309{fill:#1e5eb9;}.cls-310{fill:#2264ba;}.cls-311{fill:#2365ba;}.cls-312{fill:#276bba;}.cls-313{fill:#276cbb;}.cls-314{fill:#286dbb;}.cls-315{fill:#296ebb;}.cls-316{fill:#2c73bc;}.cls-317{fill:#2c74bc;}.cls-318{fill:#2e76bc;}.cls-319{fill:#307abd;}.cls-320{fill:#317bbd;}.cls-321{fill:#317cbd;}.cls-322{clip-path:url(#clip-path-5);}.cls-323{fill:#1857d8;}.cls-324{fill:#1858d9;}.cls-325{fill:#1959da;}.cls-326{fill:#195adb;}.cls-327{fill:#1a5bdc;}.cls-328{fill:#1a5cdd;}.cls-329{fill:#1b5dde;}.cls-330{fill:#1c5ede;}.cls-331{fill:#1c5fdf;}.cls-332{fill:#1d60e0;}.cls-333{fill:#1d61e1;}.cls-334{fill:#1e62e2;}.cls-335{fill:#1f63e3;}.cls-336{fill:#1f64e4;}.cls-337{fill:#2065e5;}.cls-338{fill:#2066e6;}.cls-339{fill:#2167e7;}.cls-340{fill:#2168e8;}.cls-341{fill:#2269e9;}.cls-342{fill:#236aea;}.cls-343{fill:#236beb;}.cls-344{fill:#246deb;}.cls-345{fill:#246eec;}.cls-346{fill:#256fed;}.cls-347{fill:#2670ee;}.cls-348{fill:#2671ef;}.cls-349{fill:#2772f0;}.cls-350{fill:#2773f1;}.cls-351{fill:#2874f2;}.cls-352{fill:#2875f3;}.cls-353{fill:#2976f4;}.cls-354{fill:#2a77f5;}.cls-355{fill:#2a78f6;}.cls-356{fill:#2b79f7;}.cls-357{fill:#2b7af8;}.cls-358{fill:#2c7bf8;}.cls-359{fill:#2d7cf9;}.cls-360{fill:#2d7dfa;}.cls-361{fill:#2e7efb;}.cls-362{fill:#2e7ffc;}.cls-363{fill:#2f80fd;}.cls-364{fill:#2f81fe;}.cls-365{clip-path:url(#clip-path-6);}.cls-366{fill:#49a6e7;}.cls-367{fill:#429cee;}.cls-368{fill:#3e97f1;}.cls-369{fill:#3b91f5;}.cls-370{fill:#3487fc;}</style><clipPath id="clip-path"><path class="cls-1" d="M280.66,283.79,31,304.28c-19.95,1.64-31-12.78-24.78-32.2l37-114.6c6.26-19.41,27.51-36.48,47.45-38.12L340.28,98.87c20-1.64,31.05,12.78,24.78,32.2L328.12,245.66C321.85,265.08,300.61,282.15,280.66,283.79Z"/></clipPath><clipPath id="clip-path-2"><path class="cls-1" d="M152.8,327,16.52,125.8C5.63,109.72,13,92.46,32.87,87.25L150.44,56.47c19.92-5.21,44.9,3.59,55.79,19.67L342.51,277.35c10.89,16.07,3.56,33.34-16.36,38.55L208.59,346.68C188.67,351.89,163.69,343.09,152.8,327Z"/></clipPath><clipPath id="clip-path-3"><path class="cls-1" d="M307.73,164.43,199,381.77c-8.69,17.37-27.24,19.27-41.44,4.25L73.78,297.37c-14.2-15-18.66-41.28-10-58.65L172.52,21.38C181.21,4,199.76,2.11,214,17.13l83.79,88.65C312,120.81,316.42,147.06,307.73,164.43Z"/></clipPath><clipPath id="clip-path-4"><path class="cls-1" d="M43.21,158.33,6.26,272.93C0,292.35,11.09,306.76,31,305.13l100.76-8.27h0L76.21,214.78l113.65-12.36,38-93.48h0L90.66,120.21C70.72,121.84,49.47,138.91,43.21,158.33Z"/></clipPath><clipPath id="clip-path-5"><path class="cls-1" d="M215,15c-14.2-15-32.76-13.12-41.44,4.25l-48.66,97.28,102.94-8.45-38,93.47,56.78,85h0l62.15-124.26c8.69-17.37,4.22-43.62-10-58.65Z"/></clipPath><clipPath id="clip-path-6"><path class="cls-1" d="M290,199.85l-43.38,86.73-56.78-85L76.74,214.72,152.8,327c10.89,16.08,35.87,24.88,55.79,19.67L326.15,315.9c19.92-5.21,27.25-22.48,16.36-38.55Z"/></clipPath></defs><g class="cls-2"><polygon class="cls-3" points="139.5 97.23 33.17 305.92 7.09 305.92 0 302.31 0 97.23 139.5 97.23"/><polygon class="cls-3" points="140.69 97.23 34.36 305.92 33.17 305.92 139.5 97.23 140.69 97.23"/><polygon class="cls-4" points="141.88 97.23 35.55 305.92 34.36 305.92 140.69 97.23 141.88 97.23"/><polygon class="cls-5" points="143.07 97.23 36.74 305.92 35.55 305.92 141.88 97.23 143.07 97.23"/><polygon class="cls-6" points="144.26 97.23 37.93 305.92 36.74 305.92 143.07 97.23 144.26 97.23"/><polygon class="cls-7" points="145.45 97.23 39.12 305.92 37.93 305.92 144.26 97.23 145.45 97.23"/><polygon class="cls-8" points="146.64 97.23 40.31 305.92 39.12 305.92 145.45 97.23 146.64 97.23"/><polygon class="cls-9" points="147.83 97.23 41.5 305.92 40.31 305.92 146.64 97.23 147.83 97.23"/><polygon class="cls-10" points="149.02 97.23 42.69 305.92 41.5 305.92 147.83 97.23 149.02 97.23"/><polygon class="cls-11" points="150.21 97.23 43.88 305.92 42.69 305.92 149.02 97.23 150.21 97.23"/><polygon class="cls-12" points="151.4 97.23 45.07 305.92 43.88 305.92 150.21 97.23 151.4 97.23"/><polygon class="cls-13" points="152.59 97.23 46.26 305.92 45.07 305.92 151.4 97.23 152.59 97.23"/><polygon class="cls-14" points="153.78 97.23 47.45 305.92 46.26 305.92 152.59 97.23 153.78 97.23"/><polygon class="cls-15" points="154.97 97.23 48.64 305.92 47.45 305.92 153.78 97.23 154.97 97.23"/><polygon class="cls-16" points="156.15 97.23 49.83 305.92 48.64 305.92 154.97 97.23 156.15 97.23"/><polygon class="cls-17" points="157.34 97.23 51.02 305.92 49.83 305.92 156.15 97.23 157.34 97.23"/><polygon class="cls-18" points="158.53 97.23 52.2 305.92 51.02 305.92 157.34 97.23 158.53 97.23"/><polygon class="cls-19" points="159.72 97.23 53.39 305.92 52.2 305.92 158.53 97.23 159.72 97.23"/><polygon class="cls-20" points="160.91 97.23 54.58 305.92 53.39 305.92 159.72 97.23 160.91 97.23"/><polygon class="cls-21" points="162.1 97.23 55.77 305.92 54.58 305.92 160.91 97.23 162.1 97.23"/><polygon class="cls-22" points="163.29 97.23 56.96 305.92 55.77 305.92 162.1 97.23 163.29 97.23"/><polygon class="cls-23" points="164.48 97.23 58.15 305.92 56.96 305.92 163.29 97.23 164.48 97.23"/><polygon class="cls-24" points="165.67 97.23 59.34 305.92 58.15 305.92 164.48 97.23 165.67 97.23"/><polygon class="cls-25" points="166.86 97.23 60.53 305.92 59.34 305.92 165.67 97.23 166.86 97.23"/><polygon class="cls-26" points="168.05 97.23 61.72 305.92 60.53 305.92 166.86 97.23 168.05 97.23"/><polygon class="cls-27" points="169.24 97.23 62.91 305.92 61.72 305.92 168.05 97.23 169.24 97.23"/><polygon class="cls-28" points="170.43 97.23 64.1 305.92 62.91 305.92 169.24 97.23 170.43 97.23"/><polygon class="cls-29" points="171.62 97.23 65.29 305.92 64.1 305.92 170.43 97.23 171.62 97.23"/><polygon class="cls-30" points="172.81 97.23 66.48 305.92 65.29 305.92 171.62 97.23 172.81 97.23"/><polygon class="cls-31" points="174 97.23 67.67 305.92 66.48 305.92 172.81 97.23 174 97.23"/><polygon class="cls-32" points="175.19 97.23 68.86 305.92 67.67 305.92 174 97.23 175.19 97.23"/><polygon class="cls-33" points="176.38 97.23 70.05 305.92 68.86 305.92 175.19 97.23 176.38 97.23"/><polygon class="cls-34" points="177.57 97.23 71.24 305.92 70.05 305.92 176.38 97.23 177.57 97.23"/><polygon class="cls-35" points="178.76 97.23 72.43 305.92 71.24 305.92 177.57 97.23 178.76 97.23"/><polygon class="cls-36" points="179.94 97.23 73.62 305.92 72.43 305.92 178.76 97.23 179.94 97.23"/><polygon class="cls-37" points="181.13 97.23 74.81 305.92 73.62 305.92 179.94 97.23 181.13 97.23"/><polygon class="cls-38" points="182.32 97.23 76 305.92 74.81 305.92 181.13 97.23 182.32 97.23"/><polygon class="cls-39" points="183.51 97.23 77.19 305.92 76 305.92 182.32 97.23 183.51 97.23"/><polygon class="cls-40" points="184.7 97.23 78.37 305.92 77.19 305.92 183.51 97.23 184.7 97.23"/><polygon class="cls-41" points="185.89 97.23 79.56 305.92 78.37 305.92 184.7 97.23 185.89 97.23"/><polygon class="cls-42" points="187.08 97.23 80.75 305.92 79.56 305.92 185.89 97.23 187.08 97.23"/><polygon class="cls-43" points="188.27 97.23 81.94 305.92 80.75 305.92 187.08 97.23 188.27 97.23"/><polygon class="cls-44" points="189.46 97.23 83.13 305.92 81.94 305.92 188.27 97.23 189.46 97.23"/><polygon class="cls-45" points="190.65 97.23 84.32 305.92 83.13 305.92 189.46 97.23 190.65 97.23"/><polygon class="cls-46" points="191.84 97.23 85.51 305.92 84.32 305.92 190.65 97.23 191.84 97.23"/><polygon class="cls-47" points="193.03 97.23 86.7 305.92 85.51 305.92 191.84 97.23 193.03 97.23"/><polygon class="cls-48" points="194.22 97.23 87.89 305.92 86.7 305.92 193.03 97.23 194.22 97.23"/><polygon class="cls-49" points="195.41 97.23 89.08 305.92 87.89 305.92 194.22 97.23 195.41 97.23"/><polygon class="cls-50" points="196.6 97.23 90.27 305.92 89.08 305.92 195.41 97.23 196.6 97.23"/><polygon class="cls-51" points="197.79 97.23 91.46 305.92 90.27 305.92 196.6 97.23 197.79 97.23"/><polygon class="cls-52" points="198.98 97.23 92.65 305.92 91.46 305.92 197.79 97.23 198.98 97.23"/><polygon class="cls-53" points="200.17 97.23 93.84 305.92 92.65 305.92 198.98 97.23 200.17 97.23"/><polygon class="cls-54" points="201.36 97.23 95.03 305.92 93.84 305.92 200.17 97.23 201.36 97.23"/><polygon class="cls-55" points="202.55 97.23 96.22 305.92 95.03 305.92 201.36 97.23 202.55 97.23"/><polygon class="cls-56" points="203.74 97.23 97.41 305.92 96.22 305.92 202.55 97.23 203.74 97.23"/><polygon class="cls-57" points="204.93 97.23 98.6 305.92 97.41 305.92 203.74 97.23 204.93 97.23"/><polygon class="cls-58" points="206.12 97.23 99.79 305.92 98.6 305.92 204.93 97.23 206.12 97.23"/><polygon class="cls-59" points="207.31 97.23 100.97 305.92 99.79 305.92 206.12 97.23 207.31 97.23"/><polygon class="cls-60" points="208.49 97.23 102.17 305.92 100.97 305.92 207.31 97.23 208.49 97.23"/><polygon class="cls-61" points="209.68 97.23 103.35 305.92 102.17 305.92 208.49 97.23 209.68 97.23"/><polygon class="cls-62" points="210.87 97.23 104.54 305.92 103.35 305.92 209.68 97.23 210.87 97.23"/><polygon class="cls-63" points="212.06 97.23 105.73 305.92 104.54 305.92 210.87 97.23 212.06 97.23"/><polygon class="cls-64" points="213.25 97.23 106.92 305.92 105.73 305.92 212.06 97.23 213.25 97.23"/><polygon class="cls-65" points="214.44 97.23 108.11 305.92 106.92 305.92 213.25 97.23 214.44 97.23"/><polygon class="cls-66" points="215.63 97.23 109.3 305.92 108.11 305.92 214.44 97.23 215.63 97.23"/><polygon class="cls-67" points="216.82 97.23 110.49 305.92 109.3 305.92 215.63 97.23 216.82 97.23"/><polygon class="cls-68" points="218.01 97.23 111.68 305.92 110.49 305.92 216.82 97.23 218.01 97.23"/><polygon class="cls-69" points="219.2 97.23 112.87 305.92 111.68 305.92 218.01 97.23 219.2 97.23"/><polygon class="cls-70" points="220.39 97.23 114.06 305.92 112.87 305.92 219.2 97.23 220.39 97.23"/><polygon class="cls-71" points="221.58 97.23 115.25 305.92 114.06 305.92 220.39 97.23 221.58 97.23"/><polygon class="cls-72" points="222.77 97.23 116.44 305.92 115.25 305.92 221.58 97.23 222.77 97.23"/><polygon class="cls-73" points="223.96 97.23 117.63 305.92 116.44 305.92 222.77 97.23 223.96 97.23"/><polygon class="cls-74" points="225.15 97.23 118.82 305.92 117.63 305.92 223.96 97.23 225.15 97.23"/><polygon class="cls-75" points="226.34 97.23 120.01 305.92 118.82 305.92 225.15 97.23 226.34 97.23"/><polygon class="cls-76" points="227.53 97.23 121.2 305.92 120.01 305.92 226.34 97.23 227.53 97.23"/><polygon class="cls-77" points="228.72 97.23 122.39 305.92 121.2 305.92 227.53 97.23 228.72 97.23"/><polygon class="cls-78" points="229.91 97.23 123.58 305.92 122.39 305.92 228.72 97.23 229.91 97.23"/><polygon class="cls-79" points="231.1 97.23 124.77 305.92 123.58 305.92 229.91 97.23 231.1 97.23"/><polygon class="cls-80" points="232.28 97.23 125.96 305.92 124.77 305.92 231.1 97.23 232.28 97.23"/><polygon class="cls-81" points="233.47 97.23 127.14 305.92 125.96 305.92 232.28 97.23 233.47 97.23"/><polygon class="cls-82" points="234.66 97.23 128.34 305.92 127.14 305.92 233.47 97.23 234.66 97.23"/><polygon class="cls-83" points="235.85 97.23 129.52 305.92 128.34 305.92 234.66 97.23 235.85 97.23"/><polygon class="cls-84" points="237.04 97.23 130.71 305.92 129.52 305.92 235.85 97.23 237.04 97.23"/><polygon class="cls-85" points="238.23 97.23 131.9 305.92 130.71 305.92 237.04 97.23 238.23 97.23"/><polygon class="cls-86" points="239.42 97.23 133.09 305.92 131.9 305.92 238.23 97.23 239.42 97.23"/><polygon class="cls-87" points="240.61 97.23 134.28 305.92 133.09 305.92 239.42 97.23 240.61 97.23"/><polygon class="cls-88" points="241.8 97.23 135.47 305.92 134.28 305.92 240.61 97.23 241.8 97.23"/><polygon class="cls-89" points="242.99 97.23 136.66 305.92 135.47 305.92 241.8 97.23 242.99 97.23"/><polygon class="cls-90" points="244.18 97.23 137.85 305.92 136.66 305.92 242.99 97.23 244.18 97.23"/><polygon class="cls-91" points="245.37 97.23 139.04 305.92 137.85 305.92 244.18 97.23 245.37 97.23"/><polygon class="cls-92" points="246.56 97.23 140.23 305.92 139.04 305.92 245.37 97.23 246.56 97.23"/><polygon class="cls-93" points="247.75 97.23 141.42 305.92 140.23 305.92 246.56 97.23 247.75 97.23"/><polygon class="cls-94" points="248.94 97.23 142.61 305.92 141.42 305.92 247.75 97.23 248.94 97.23"/><polygon class="cls-95" points="250.13 97.23 143.8 305.92 142.61 305.92 248.94 97.23 250.13 97.23"/><polygon class="cls-96" points="251.32 97.23 144.99 305.92 143.8 305.92 250.13 97.23 251.32 97.23"/><polygon class="cls-97" points="252.51 97.23 146.18 305.92 144.99 305.92 251.32 97.23 252.51 97.23"/><polygon class="cls-98" points="253.7 97.23 147.37 305.92 146.18 305.92 252.51 97.23 253.7 97.23"/><polygon class="cls-99" points="254.89 97.23 148.56 305.92 147.37 305.92 253.7 97.23 254.89 97.23"/><polygon class="cls-100" points="256.08 97.23 149.75 305.92 148.56 305.92 254.89 97.23 256.08 97.23"/><polygon class="cls-101" points="257.26 97.23 150.94 305.92 149.75 305.92 256.08 97.23 257.26 97.23"/><polygon class="cls-102" points="258.45 97.23 152.13 305.92 150.94 305.92 257.26 97.23 258.45 97.23"/><polygon class="cls-103" points="259.64 97.23 153.31 305.92 152.13 305.92 258.45 97.23 259.64 97.23"/><polygon class="cls-104" points="260.83 97.23 154.5 305.92 153.31 305.92 259.64 97.23 260.83 97.23"/><polygon class="cls-105" points="262.02 97.23 155.69 305.92 154.5 305.92 260.83 97.23 262.02 97.23"/><polygon class="cls-106" points="263.21 97.23 156.88 305.92 155.69 305.92 262.02 97.23 263.21 97.23"/><polygon class="cls-107" points="264.4 97.23 158.07 305.92 156.88 305.92 263.21 97.23 264.4 97.23"/><polygon class="cls-108" points="265.59 97.23 159.26 305.92 158.07 305.92 264.4 97.23 265.59 97.23"/><polygon class="cls-109" points="266.78 97.23 160.45 305.92 159.26 305.92 265.59 97.23 266.78 97.23"/><polygon class="cls-110" points="267.97 97.23 161.64 305.92 160.45 305.92 266.78 97.23 267.97 97.23"/><polygon class="cls-111" points="269.16 97.23 162.83 305.92 161.64 305.92 267.97 97.23 269.16 97.23"/><polygon class="cls-112" points="270.35 97.23 164.02 305.92 162.83 305.92 269.16 97.23 270.35 97.23"/><polygon class="cls-113" points="271.54 97.23 165.21 305.92 164.02 305.92 270.35 97.23 271.54 97.23"/><polygon class="cls-114" points="272.73 97.23 166.4 305.92 165.21 305.92 271.54 97.23 272.73 97.23"/><polygon class="cls-115" points="273.92 97.23 167.59 305.92 166.4 305.92 272.73 97.23 273.92 97.23"/><polygon class="cls-116" points="275.11 97.23 168.78 305.92 167.59 305.92 273.92 97.23 275.11 97.23"/><polygon class="cls-117" points="276.3 97.23 169.97 305.92 168.78 305.92 275.11 97.23 276.3 97.23"/><polygon class="cls-118" points="277.49 97.23 171.16 305.92 169.97 305.92 276.3 97.23 277.49 97.23"/><polygon class="cls-119" points="278.68 97.23 172.35 305.92 171.16 305.92 277.49 97.23 278.68 97.23"/><polygon class="cls-120" points="279.87 97.23 173.54 305.92 172.35 305.92 278.68 97.23 279.87 97.23"/><polygon class="cls-121" points="281.06 97.23 174.73 305.92 173.54 305.92 279.87 97.23 281.06 97.23"/><polygon class="cls-122" points="282.25 97.23 175.92 305.92 174.73 305.92 281.06 97.23 282.25 97.23"/><polygon class="cls-123" points="283.44 97.23 177.11 305.92 175.92 305.92 282.25 97.23 283.44 97.23"/><polygon class="cls-124" points="284.63 97.23 178.29 305.92 177.11 305.92 283.44 97.23 284.63 97.23"/><polygon class="cls-125" points="285.81 97.23 179.49 305.92 178.29 305.92 284.63 97.23 285.81 97.23"/><polygon class="cls-126" points="287 97.23 180.68 305.92 179.49 305.92 285.81 97.23 287 97.23"/><polygon class="cls-127" points="288.19 97.23 181.86 305.92 180.68 305.92 287 97.23 288.19 97.23"/><polygon class="cls-128" points="289.38 97.23 183.05 305.92 181.86 305.92 288.19 97.23 289.38 97.23"/><polygon class="cls-129" points="290.57 97.23 184.24 305.92 183.05 305.92 289.38 97.23 290.57 97.23"/><polygon class="cls-130" points="291.76 97.23 185.43 305.92 184.24 305.92 290.57 97.23 291.76 97.23"/><polygon class="cls-131" points="292.95 97.23 186.62 305.92 185.43 305.92 291.76 97.23 292.95 97.23"/><polygon class="cls-132" points="294.14 97.23 187.81 305.92 186.62 305.92 292.95 97.23 294.14 97.23"/><polygon class="cls-133" points="295.33 97.23 189 305.92 187.81 305.92 294.14 97.23 295.33 97.23"/><polygon class="cls-134" points="296.52 97.23 190.19 305.92 189 305.92 295.33 97.23 296.52 97.23"/><polygon class="cls-135" points="297.71 97.23 191.38 305.92 190.19 305.92 296.52 97.23 297.71 97.23"/><polygon class="cls-136" points="298.9 97.23 192.57 305.92 191.38 305.92 297.71 97.23 298.9 97.23"/><polygon class="cls-137" points="300.09 97.23 193.76 305.92 192.57 305.92 298.9 97.23 300.09 97.23"/><polygon class="cls-138" points="301.28 97.23 194.95 305.92 193.76 305.92 300.09 97.23 301.28 97.23"/><polygon class="cls-139" points="302.47 97.23 196.14 305.92 194.95 305.92 301.28 97.23 302.47 97.23"/><polygon class="cls-140" points="303.66 97.23 197.33 305.92 196.14 305.92 302.47 97.23 303.66 97.23"/><polygon class="cls-141" points="304.85 97.23 198.52 305.92 197.33 305.92 303.66 97.23 304.85 97.23"/><polygon class="cls-142" points="306.04 97.23 199.71 305.92 198.52 305.92 304.85 97.23 306.04 97.23"/><polygon class="cls-143" points="307.23 97.23 200.9 305.92 199.71 305.92 306.04 97.23 307.23 97.23"/><polygon class="cls-144" points="308.42 97.23 202.09 305.92 200.9 305.92 307.23 97.23 308.42 97.23"/><polygon class="cls-145" points="309.61 97.23 203.28 305.92 202.09 305.92 308.42 97.23 309.61 97.23"/><polygon class="cls-146" points="310.8 97.23 204.47 305.92 203.28 305.92 309.61 97.23 310.8 97.23"/><polygon class="cls-147" points="311.98 97.23 205.66 305.92 204.47 305.92 310.8 97.23 311.98 97.23"/><polygon class="cls-148" points="313.17 97.23 206.84 305.92 205.66 305.92 311.98 97.23 313.17 97.23"/><polygon class="cls-149" points="314.36 97.23 208.03 305.92 206.84 305.92 313.17 97.23 314.36 97.23"/><polygon class="cls-150" points="315.55 97.23 209.22 305.92 208.03 305.92 314.36 97.23 315.55 97.23"/><polygon class="cls-151" points="316.74 97.23 210.41 305.92 209.22 305.92 315.55 97.23 316.74 97.23"/><polygon class="cls-152" points="317.93 97.23 211.6 305.92 210.41 305.92 316.74 97.23 317.93 97.23"/><polygon class="cls-153" points="319.12 97.23 212.79 305.92 211.6 305.92 317.93 97.23 319.12 97.23"/><polygon class="cls-154" points="320.31 97.23 213.98 305.92 212.79 305.92 319.12 97.23 320.31 97.23"/><polygon class="cls-155" points="321.5 97.23 215.17 305.92 213.98 305.92 320.31 97.23 321.5 97.23"/><polygon class="cls-156" points="322.69 97.23 216.36 305.92 215.17 305.92 321.5 97.23 322.69 97.23"/><polygon class="cls-157" points="323.88 97.23 217.55 305.92 216.36 305.92 322.69 97.23 323.88 97.23"/><polygon class="cls-158" points="325.07 97.23 218.74 305.92 217.55 305.92 323.88 97.23 325.07 97.23"/><polygon class="cls-159" points="326.26 97.23 219.93 305.92 218.74 305.92 325.07 97.23 326.26 97.23"/><polygon class="cls-160" points="327.45 97.23 221.12 305.92 219.93 305.92 326.26 97.23 327.45 97.23"/><polygon class="cls-161" points="328.64 97.23 222.31 305.92 221.12 305.92 327.45 97.23 328.64 97.23"/><polygon class="cls-162" points="329.83 97.23 223.5 305.92 222.31 305.92 328.64 97.23 329.83 97.23"/><polygon class="cls-163" points="331.02 97.23 224.69 305.92 223.5 305.92 329.83 97.23 331.02 97.23"/><polygon class="cls-164" points="332.21 97.23 225.88 305.92 224.69 305.92 331.02 97.23 332.21 97.23"/><polygon class="cls-165" points="333.4 97.23 227.07 305.92 225.88 305.92 332.21 97.23 333.4 97.23"/><polygon class="cls-166" points="334.58 97.23 228.26 305.92 227.07 305.92 333.4 97.23 334.58 97.23"/><polygon class="cls-167" points="335.77 97.23 229.45 305.92 228.26 305.92 334.58 97.23 335.77 97.23"/><polygon class="cls-168" points="336.96 97.23 230.63 305.92 229.45 305.92 335.77 97.23 336.96 97.23"/><polygon class="cls-169" points="338.15 97.23 231.82 305.92 230.63 305.92 336.96 97.23 338.15 97.23"/><polygon class="cls-169" points="364.24 97.23 371.33 100.84 371.33 305.92 231.82 305.92 338.15 97.23 364.24 97.23"/></g><g class="cls-170"><polygon class="cls-169" points="312.54 51.26 316.81 75.46 7.36 130.03 5.63 120.2 5.63 51.26 312.54 51.26"/><rect class="cls-169" x="5.19" y="102.72" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -15.59, 29.76)"/><rect class="cls-171" x="5.62" y="105.17" width="314.22" height="2.49" transform="translate(-16.01 29.88) rotate(-10)"/><rect class="cls-172" x="6.06" y="107.62" width="314.22" height="2.49" transform="translate(-16.43 29.99) rotate(-10)"/><rect class="cls-173" x="6.49" y="110.07" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -16.84, 30.1)"/><rect class="cls-174" x="6.92" y="112.52" width="314.22" height="2.49" transform="translate(-17.26 30.21) rotate(-10)"/><rect class="cls-175" x="7.35" y="114.98" width="314.22" height="2.49" transform="translate(-17.68 30.32) rotate(-10)"/><rect class="cls-176" x="7.78" y="117.43" width="314.22" height="2.49" transform="translate(-18.1 30.44) rotate(-10)"/><rect class="cls-177" x="8.22" y="119.88" width="314.22" height="2.49" transform="translate(-18.52 30.55) rotate(-10)"/><rect class="cls-178" x="8.65" y="122.33" width="314.22" height="2.49" transform="translate(-18.94 30.66) rotate(-10)"/><rect class="cls-179" x="9.08" y="124.78" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -19.36, 30.77)"/><rect class="cls-180" x="9.51" y="127.23" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -19.78, 30.89)"/><rect class="cls-181" x="9.94" y="129.68" width="314.22" height="2.49" transform="translate(-20.2 31) rotate(-10)"/><rect class="cls-182" x="10.38" y="132.13" width="314.22" height="2.49" transform="translate(-20.62 31.11) rotate(-10)"/><rect class="cls-183" x="10.81" y="134.58" width="314.22" height="2.49" transform="translate(-21.03 31.22) rotate(-10)"/><rect class="cls-184" x="11.24" y="137.03" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -21.45, 31.33)"/><rect class="cls-185" x="11.67" y="139.48" width="314.22" height="2.49" transform="translate(-21.87 31.45) rotate(-10)"/><rect class="cls-186" x="12.1" y="141.93" width="314.22" height="2.49" transform="translate(-22.29 31.56) rotate(-10)"/><rect class="cls-187" x="12.54" y="144.38" width="314.22" height="2.49" transform="translate(-22.71 31.67) rotate(-10)"/><rect class="cls-188" x="12.97" y="146.83" width="314.22" height="2.49" transform="translate(-23.13 31.78) rotate(-10)"/><rect class="cls-189" x="13.4" y="149.28" width="314.22" height="2.49" transform="translate(-23.55 31.9) rotate(-10)"/><rect class="cls-190" x="13.83" y="151.73" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -23.97, 32.01)"/><rect class="cls-191" x="14.26" y="154.18" width="314.22" height="2.49" transform="translate(-24.39 32.12) rotate(-10)"/><rect class="cls-192" x="14.7" y="156.63" width="314.22" height="2.49" transform="translate(-24.8 32.23) rotate(-10)"/><rect class="cls-193" x="15.13" y="159.08" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -25.22, 32.34)"/><rect class="cls-194" x="15.56" y="161.53" width="314.22" height="2.49" transform="translate(-25.64 32.46) rotate(-10)"/><rect class="cls-195" x="15.99" y="163.98" width="314.22" height="2.49" transform="translate(-26.06 32.57) rotate(-10)"/><rect class="cls-196" x="16.43" y="166.43" width="314.22" height="2.49" transform="translate(-26.48 32.68) rotate(-10)"/><rect class="cls-197" x="16.86" y="168.88" width="314.22" height="2.49" transform="translate(-26.9 32.79) rotate(-10)"/><rect class="cls-198" x="17.29" y="171.33" width="314.22" height="2.49" transform="translate(-27.32 32.91) rotate(-10)"/><rect class="cls-199" x="17.72" y="173.78" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -27.74, 33.02)"/><rect class="cls-200" x="18.15" y="176.23" width="314.22" height="2.49" transform="translate(-28.16 33.13) rotate(-10)"/><rect class="cls-201" x="18.59" y="178.68" width="314.22" height="2.49" transform="translate(-28.57 33.24) rotate(-10)"/><rect class="cls-202" x="19.02" y="181.13" width="314.22" height="2.49" transform="translate(-28.99 33.36) rotate(-10)"/><rect class="cls-203" x="19.45" y="183.58" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -29.41, 33.47)"/><rect class="cls-204" x="19.88" y="186.03" width="314.22" height="2.49" transform="translate(-29.83 33.58) rotate(-10)"/><rect class="cls-205" x="20.31" y="188.48" width="314.22" height="2.49" transform="translate(-30.25 33.69) rotate(-10)"/><rect class="cls-206" x="20.75" y="190.93" width="314.22" height="2.49" transform="translate(-30.67 33.8) rotate(-10)"/><rect class="cls-207" x="21.18" y="193.38" width="314.22" height="2.49" transform="translate(-31.09 33.92) rotate(-10)"/><rect class="cls-208" x="21.61" y="195.83" width="314.22" height="2.49" transform="translate(-31.51 34.03) rotate(-10)"/><rect class="cls-209" x="22.04" y="198.28" width="314.22" height="2.49" transform="translate(-31.93 34.14) rotate(-10)"/><rect class="cls-210" x="22.47" y="200.73" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -32.34, 34.25)"/><rect class="cls-210" x="22.91" y="203.18" width="314.22" height="2.49" transform="translate(-32.76 34.37) rotate(-10)"/><rect class="cls-211" x="23.34" y="205.64" width="314.22" height="2.49" transform="translate(-33.18 34.48) rotate(-10)"/><rect class="cls-212" x="23.77" y="208.09" width="314.22" height="2.49" transform="translate(-33.6 34.59) rotate(-10)"/><rect class="cls-213" x="24.2" y="210.54" width="314.22" height="2.49" transform="translate(-34.02 34.7) rotate(-10)"/><rect class="cls-214" x="24.63" y="212.99" width="314.22" height="2.49" transform="translate(-34.44 34.81) rotate(-10)"/><rect class="cls-215" x="25.07" y="215.44" width="314.22" height="2.49" transform="translate(-34.86 34.93) rotate(-10)"/><rect class="cls-216" x="25.5" y="217.89" width="314.22" height="2.49" transform="translate(-35.28 35.04) rotate(-10)"/><rect class="cls-217" x="25.93" y="220.34" width="314.22" height="2.49" transform="translate(-35.7 35.15) rotate(-10)"/><rect class="cls-218" x="26.36" y="222.79" width="314.22" height="2.49" transform="translate(-36.12 35.26) rotate(-10)"/><rect class="cls-219" x="26.79" y="225.24" width="314.22" height="2.49" transform="translate(-36.53 35.38) rotate(-10)"/><rect class="cls-220" x="27.23" y="227.69" width="314.22" height="2.49" transform="translate(-36.95 35.49) rotate(-10)"/><rect class="cls-221" x="27.66" y="230.14" width="314.22" height="2.49" transform="translate(-37.37 35.6) rotate(-10)"/><rect class="cls-222" x="28.09" y="232.59" width="314.22" height="2.49" transform="translate(-37.79 35.71) rotate(-10)"/><rect class="cls-223" x="28.52" y="235.04" width="314.22" height="2.49" transform="translate(-38.21 35.82) rotate(-10)"/><rect class="cls-224" x="28.95" y="237.49" width="314.22" height="2.49" transform="translate(-38.63 35.94) rotate(-10)"/><rect class="cls-225" x="29.39" y="239.94" width="314.22" height="2.49" transform="translate(-39.05 36.05) rotate(-10)"/><rect class="cls-226" x="29.82" y="242.39" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -39.47, 36.16)"/><rect class="cls-227" x="30.25" y="244.84" width="314.22" height="2.49" transform="translate(-39.89 36.27) rotate(-10)"/><rect class="cls-228" x="30.68" y="247.29" width="314.22" height="2.49" transform="translate(-40.3 36.39) rotate(-10)"/><rect class="cls-229" x="31.11" y="249.74" width="314.22" height="2.49" transform="translate(-40.72 36.5) rotate(-10)"/><rect class="cls-230" x="31.55" y="252.19" width="314.22" height="2.49" transform="translate(-41.14 36.61) rotate(-10)"/><rect class="cls-231" x="31.98" y="254.64" width="314.22" height="2.49" transform="translate(-41.56 36.72) rotate(-10)"/><rect class="cls-232" x="32.41" y="257.09" width="314.22" height="2.49" transform="translate(-41.98 36.83) rotate(-10)"/><rect class="cls-233" x="32.84" y="259.54" width="314.22" height="2.49" transform="translate(-42.4 36.95) rotate(-10)"/><rect class="cls-234" x="33.28" y="261.99" width="314.22" height="2.49" transform="translate(-42.82 37.06) rotate(-10)"/><rect class="cls-235" x="33.71" y="264.44" width="314.22" height="2.49" transform="translate(-43.24 37.17) rotate(-10)"/><rect class="cls-236" x="34.14" y="266.89" width="314.22" height="2.49" transform="translate(-43.66 37.28) rotate(-10)"/><rect class="cls-237" x="34.57" y="269.34" width="314.22" height="2.49" transform="translate(-44.07 37.4) rotate(-10)"/><rect class="cls-238" x="35" y="271.79" width="314.22" height="2.49" transform="translate(-44.49 37.51) rotate(-10)"/><rect class="cls-239" x="35.44" y="274.24" width="314.22" height="2.49" transform="translate(-44.91 37.62) rotate(-10)"/><rect class="cls-240" x="35.87" y="276.69" width="314.22" height="2.49" transform="translate(-45.33 37.73) rotate(-10)"/><rect class="cls-241" x="36.3" y="279.14" width="314.22" height="2.49" transform="translate(-45.75 37.85) rotate(-10)"/><rect class="cls-242" x="36.73" y="281.59" width="314.22" height="2.49" transform="translate(-46.17 37.96) rotate(-10)"/><rect class="cls-243" x="37.16" y="284.04" width="314.22" height="2.49" transform="translate(-46.59 38.07) rotate(-10)"/><rect class="cls-244" x="37.6" y="286.49" width="314.22" height="2.49" transform="translate(-47.01 38.18) rotate(-10)"/><rect class="cls-245" x="38.03" y="288.94" width="314.22" height="2.49" transform="translate(-47.43 38.29) rotate(-10)"/><rect class="cls-246" x="38.46" y="291.39" width="314.22" height="2.49" transform="translate(-47.85 38.41) rotate(-10)"/><rect class="cls-247" x="38.89" y="293.84" width="314.22" height="2.49" transform="translate(-48.26 38.52) rotate(-10)"/><rect class="cls-248" x="39.32" y="296.3" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -48.68, 38.63)"/><rect class="cls-249" x="39.76" y="298.75" width="314.22" height="2.49" transform="translate(-49.1 38.74) rotate(-10)"/><rect class="cls-250" x="40.19" y="301.2" width="314.22" height="2.49" transform="translate(-49.52 38.86) rotate(-10)"/><polygon class="cls-250" points="352.24 276.38 353.4 282.95 353.4 351.89 46.48 351.89 42.79 330.95 352.24 276.38"/></g><g class="cls-251"><polygon class="cls-3" points="55.12 198.52 224.31 367.72 191 401.04 55.12 401.04 55.12 198.52"/><polygon class="cls-3" points="55.12 192.3 227.43 364.61 224.31 367.72 55.12 198.52 55.12 192.3"/><polygon class="cls-252" points="55.12 186.07 230.54 361.5 227.43 364.61 55.12 192.3 55.12 186.07"/><polygon class="cls-253" points="55.12 179.85 233.65 358.38 230.54 361.5 55.12 186.07 55.12 179.85"/><polygon class="cls-254" points="55.12 173.62 236.76 355.27 233.65 358.38 55.12 179.85 55.12 173.62"/><polygon class="cls-255" points="55.12 167.4 239.88 352.16 236.76 355.27 55.12 173.62 55.12 167.4"/><polygon class="cls-256" points="55.12 161.18 242.99 349.05 239.88 352.16 55.12 167.4 55.12 161.18"/><polygon class="cls-257" points="55.12 154.95 246.1 345.94 242.99 349.05 55.12 161.18 55.12 154.95"/><polygon class="cls-258" points="55.12 148.73 249.21 342.82 246.1 345.94 55.12 154.95 55.12 148.73"/><polygon class="cls-259" points="55.12 142.5 252.32 339.71 249.21 342.82 55.12 148.73 55.12 142.5"/><polygon class="cls-260" points="55.12 136.28 255.44 336.6 252.32 339.71 55.12 142.5 55.12 136.28"/><polygon class="cls-261" points="55.12 130.06 258.55 333.49 255.44 336.6 55.12 136.28 55.12 130.06"/><polygon class="cls-262" points="55.12 127.53 56.97 125.68 261.66 330.37 258.55 333.49 55.12 130.06 55.12 127.53"/><rect class="cls-263" x="158.67" y="81.73" width="4.4" height="289.48" transform="translate(-113.02 180.08) rotate(-45)"/><rect class="cls-264" x="161.78" y="78.62" width="4.4" height="289.48" transform="translate(-109.91 181.37) rotate(-45)"/><rect class="cls-265" x="164.89" y="75.51" width="4.4" height="289.48" transform="translate(-106.8 182.66) rotate(-45)"/><rect class="cls-266" x="168.01" y="72.39" width="4.4" height="289.48" transform="translate(-103.69 183.95) rotate(-45)"/><rect class="cls-267" x="171.12" y="69.28" width="4.4" height="289.48" transform="translate(-100.57 185.24) rotate(-45)"/><rect class="cls-268" x="174.23" y="66.17" width="4.4" height="289.48" transform="translate(-97.46 186.53) rotate(-45)"/><rect class="cls-269" x="177.34" y="63.06" width="4.4" height="289.48" transform="translate(-94.35 187.82) rotate(-45)"/><rect class="cls-270" x="180.45" y="59.95" width="4.4" height="289.48" transform="translate(-91.24 189.11) rotate(-45)"/><rect class="cls-271" x="183.57" y="56.83" width="4.4" height="289.48" transform="translate(-88.12 190.4) rotate(-45)"/><rect class="cls-272" x="186.68" y="53.72" width="4.4" height="289.48" transform="translate(-85.01 191.69) rotate(-45)"/><rect class="cls-273" x="189.79" y="50.61" width="4.4" height="289.48" transform="translate(-81.9 192.97) rotate(-45)"/><rect class="cls-274" x="192.9" y="47.5" width="4.4" height="289.48" transform="translate(-78.79 194.26) rotate(-45)"/><rect class="cls-275" x="196.01" y="44.39" width="4.4" height="289.48" transform="translate(-75.68 195.55) rotate(-45)"/><rect class="cls-276" x="199.13" y="41.27" width="4.4" height="289.48" transform="translate(-72.56 196.84) rotate(-45)"/><rect class="cls-277" x="202.24" y="38.16" width="4.4" height="289.48" transform="translate(-69.45 198.13) rotate(-45)"/><rect class="cls-278" x="205.35" y="35.05" width="4.4" height="289.48" transform="translate(-66.34 199.42) rotate(-45)"/><rect class="cls-279" x="208.46" y="31.94" width="4.4" height="289.48" transform="translate(-63.23 200.71) rotate(-45)"/><polygon class="cls-280" points="109.87 72.78 112.98 69.66 316.42 273.09 316.42 275.62 314.57 277.47 109.87 72.78"/><polygon class="cls-281" points="112.98 69.66 116.1 66.55 316.42 266.87 316.42 273.09 112.98 69.66"/><polygon class="cls-282" points="116.1 66.55 119.21 63.44 316.42 260.65 316.42 266.87 116.1 66.55"/><polygon class="cls-283" points="119.21 63.44 122.32 60.33 316.42 254.42 316.42 260.65 119.21 63.44"/><polygon class="cls-284" points="122.32 60.33 125.43 57.21 316.42 248.2 316.42 254.42 122.32 60.33"/><polygon class="cls-285" points="125.43 57.21 128.54 54.1 316.42 241.97 316.42 248.2 125.43 57.21"/><polygon class="cls-286" points="128.54 54.1 131.66 50.99 316.42 235.75 316.42 241.97 128.54 54.1"/><polygon class="cls-287" points="131.66 50.99 134.77 47.88 316.42 229.53 316.42 235.75 131.66 50.99"/><polygon class="cls-288" points="134.77 47.88 137.88 44.77 316.42 223.3 316.42 229.53 134.77 47.88"/><polygon class="cls-289" points="137.88 44.77 140.99 41.65 316.42 217.08 316.42 223.3 137.88 44.77"/><polygon class="cls-290" points="140.99 41.65 144.11 38.54 316.42 210.85 316.42 217.08 140.99 41.65"/><polygon class="cls-291" points="144.11 38.54 147.22 35.43 316.42 204.63 316.42 210.85 144.11 38.54"/><polygon class="cls-291" points="147.22 35.43 180.54 2.11 316.42 2.11 316.42 204.63 147.22 35.43"/></g><g class="cls-292"><polygon class="cls-3" points="101.7 108.94 2.18 304.26 0 303.15 0 108.94 101.7 108.94"/><polygon class="cls-3" points="103.39 108.94 3.52 304.95 2.18 304.26 101.7 108.94 103.39 108.94"/><polygon class="cls-4" points="105.09 108.94 4.87 305.63 3.52 304.95 103.39 108.94 105.09 108.94"/><polygon class="cls-5" points="106.79 108.94 6.22 306.32 4.87 305.63 105.09 108.94 106.79 108.94"/><polygon class="cls-6" points="108.49 108.94 7.69 306.76 7.09 306.76 6.22 306.32 106.79 108.94 108.49 108.94"/><polygon class="cls-293" points="110.18 108.94 9.39 306.76 7.69 306.76 108.49 108.94 110.18 108.94"/><polygon class="cls-8" points="111.88 108.94 11.09 306.76 9.39 306.76 110.18 108.94 111.88 108.94"/><polygon class="cls-9" points="113.58 108.94 12.78 306.76 11.09 306.76 111.88 108.94 113.58 108.94"/><polygon class="cls-10" points="115.28 108.94 14.48 306.76 12.78 306.76 113.58 108.94 115.28 108.94"/><polygon class="cls-11" points="116.97 108.94 16.18 306.76 14.48 306.76 115.28 108.94 116.97 108.94"/><polygon class="cls-12" points="118.67 108.94 17.88 306.76 16.18 306.76 116.97 108.94 118.67 108.94"/><polygon class="cls-13" points="120.37 108.94 19.57 306.76 17.88 306.76 118.67 108.94 120.37 108.94"/><polygon class="cls-294" points="122.06 108.94 21.27 306.76 19.57 306.76 120.37 108.94 122.06 108.94"/><polygon class="cls-295" points="123.76 108.94 22.97 306.76 21.27 306.76 122.06 108.94 123.76 108.94"/><polygon class="cls-16" points="125.46 108.94 24.67 306.76 22.97 306.76 123.76 108.94 125.46 108.94"/><polygon class="cls-17" points="127.16 108.94 26.36 306.76 24.67 306.76 125.46 108.94 127.16 108.94"/><polygon class="cls-18" points="128.85 108.94 28.06 306.76 26.36 306.76 127.16 108.94 128.85 108.94"/><polygon class="cls-19" points="130.55 108.94 29.76 306.76 28.06 306.76 128.85 108.94 130.55 108.94"/><polygon class="cls-20" points="132.25 108.94 31.46 306.76 29.76 306.76 130.55 108.94 132.25 108.94"/><polygon class="cls-296" points="133.95 108.94 33.15 306.76 31.46 306.76 132.25 108.94 133.95 108.94"/><polygon class="cls-22" points="135.65 108.94 34.85 306.76 33.15 306.76 133.95 108.94 135.65 108.94"/><polygon class="cls-297" points="137.34 108.94 36.55 306.76 34.85 306.76 135.65 108.94 137.34 108.94"/><polygon class="cls-24" points="139.04 108.94 38.24 306.76 36.55 306.76 137.34 108.94 139.04 108.94"/><polygon class="cls-25" points="140.74 108.94 39.94 306.76 38.24 306.76 139.04 108.94 140.74 108.94"/><polygon class="cls-298" points="142.43 108.94 41.64 306.76 39.94 306.76 140.74 108.94 142.43 108.94"/><polygon class="cls-27" points="144.13 108.94 43.34 306.76 41.64 306.76 142.43 108.94 144.13 108.94"/><polygon class="cls-28" points="145.83 108.94 45.03 306.76 43.34 306.76 144.13 108.94 145.83 108.94"/><polygon class="cls-299" points="147.53 108.94 46.73 306.76 45.03 306.76 145.83 108.94 147.53 108.94"/><polygon class="cls-30" points="149.22 108.94 48.43 306.76 46.73 306.76 147.53 108.94 149.22 108.94"/><polygon class="cls-300" points="150.92 108.94 50.13 306.76 48.43 306.76 149.22 108.94 150.92 108.94"/><polygon class="cls-32" points="152.62 108.94 51.83 306.76 50.13 306.76 150.92 108.94 152.62 108.94"/><polygon class="cls-33" points="154.32 108.94 53.52 306.76 51.83 306.76 152.62 108.94 154.32 108.94"/><polygon class="cls-301" points="156.01 108.94 55.22 306.76 53.52 306.76 154.32 108.94 156.01 108.94"/><polygon class="cls-35" points="157.71 108.94 56.92 306.76 55.22 306.76 156.01 108.94 157.71 108.94"/><polygon class="cls-302" points="159.41 108.94 58.61 306.76 56.92 306.76 157.71 108.94 159.41 108.94"/><polygon class="cls-303" points="161.11 108.94 60.31 306.76 58.61 306.76 159.41 108.94 161.11 108.94"/><polygon class="cls-38" points="162.8 108.94 62.01 306.76 60.31 306.76 161.11 108.94 162.8 108.94"/><polygon class="cls-304" points="164.5 108.94 63.71 306.76 62.01 306.76 162.8 108.94 164.5 108.94"/><polygon class="cls-40" points="166.2 108.94 65.4 306.76 63.71 306.76 164.5 108.94 166.2 108.94"/><polygon class="cls-41" points="167.9 108.94 67.1 306.76 65.4 306.76 166.2 108.94 167.9 108.94"/><polygon class="cls-305" points="169.59 108.94 68.8 306.76 67.1 306.76 167.9 108.94 169.59 108.94"/><polygon class="cls-306" points="171.29 108.94 70.5 306.76 68.8 306.76 169.59 108.94 171.29 108.94"/><polygon class="cls-45" points="172.99 108.94 72.19 306.76 70.5 306.76 171.29 108.94 172.99 108.94"/><polygon class="cls-46" points="174.69 108.94 73.89 306.76 72.19 306.76 172.99 108.94 174.69 108.94"/><polygon class="cls-47" points="176.38 108.94 75.59 306.76 73.89 306.76 174.69 108.94 176.38 108.94"/><polygon class="cls-48" points="178.08 108.94 77.29 306.76 75.59 306.76 176.38 108.94 178.08 108.94"/><polygon class="cls-307" points="179.78 108.94 78.98 306.76 77.29 306.76 178.08 108.94 179.78 108.94"/><polygon class="cls-50" points="181.47 108.94 80.68 306.76 78.98 306.76 179.78 108.94 181.47 108.94"/><polygon class="cls-308" points="183.17 108.94 82.38 306.76 80.68 306.76 181.47 108.94 183.17 108.94"/><polygon class="cls-309" points="184.87 108.94 84.08 306.76 82.38 306.76 183.17 108.94 184.87 108.94"/><polygon class="cls-53" points="186.57 108.94 85.77 306.76 84.08 306.76 184.87 108.94 186.57 108.94"/><polygon class="cls-54" points="188.26 108.94 87.47 306.76 85.77 306.76 186.57 108.94 188.26 108.94"/><polygon class="cls-55" points="189.96 108.94 89.17 306.76 87.47 306.76 188.26 108.94 189.96 108.94"/><polygon class="cls-56" points="191.66 108.94 90.86 306.76 89.17 306.76 189.96 108.94 191.66 108.94"/><polygon class="cls-57" points="193.36 108.94 92.56 306.76 90.86 306.76 191.66 108.94 193.36 108.94"/><polygon class="cls-310" points="195.05 108.94 94.26 306.76 92.56 306.76 193.36 108.94 195.05 108.94"/><polygon class="cls-311" points="196.75 108.94 95.96 306.76 94.26 306.76 195.05 108.94 196.75 108.94"/><polygon class="cls-60" points="198.45 108.94 97.66 306.76 95.96 306.76 196.75 108.94 198.45 108.94"/><polygon class="cls-61" points="200.15 108.94 99.35 306.76 97.66 306.76 198.45 108.94 200.15 108.94"/><polygon class="cls-62" points="201.84 108.94 101.05 306.76 99.35 306.76 200.15 108.94 201.84 108.94"/><polygon class="cls-63" points="203.54 108.94 102.75 306.76 101.05 306.76 201.84 108.94 203.54 108.94"/><polygon class="cls-64" points="205.24 108.94 104.44 306.76 102.75 306.76 203.54 108.94 205.24 108.94"/><polygon class="cls-312" points="206.94 108.94 106.14 306.76 104.44 306.76 205.24 108.94 206.94 108.94"/><polygon class="cls-313" points="208.63 108.94 107.84 306.76 106.14 306.76 206.94 108.94 208.63 108.94"/><polygon class="cls-314" points="210.33 108.94 109.54 306.76 107.84 306.76 208.63 108.94 210.33 108.94"/><polygon class="cls-315" points="212.03 108.94 111.23 306.76 109.54 306.76 210.33 108.94 212.03 108.94"/><polygon class="cls-69" points="213.73 108.94 112.93 306.76 111.23 306.76 212.03 108.94 213.73 108.94"/><polygon class="cls-70" points="215.42 108.94 114.63 306.76 112.93 306.76 213.73 108.94 215.42 108.94"/><polygon class="cls-71" points="217.12 108.94 116.33 306.76 114.63 306.76 215.42 108.94 217.12 108.94"/><polygon class="cls-72" points="218.82 108.94 118.02 306.76 116.33 306.76 217.12 108.94 218.82 108.94"/><polygon class="cls-316" points="220.52 108.94 119.72 306.76 118.02 306.76 218.82 108.94 220.52 108.94"/><polygon class="cls-317" points="222.21 108.94 121.42 306.76 119.72 306.76 220.52 108.94 222.21 108.94"/><polygon class="cls-75" points="223.91 108.94 123.12 306.76 121.42 306.76 222.21 108.94 223.91 108.94"/><polygon class="cls-318" points="225.61 108.94 124.81 306.76 123.12 306.76 223.91 108.94 225.61 108.94"/><polygon class="cls-77" points="227.31 108.94 126.51 306.76 124.81 306.76 225.61 108.94 227.31 108.94"/><polygon class="cls-78" points="227.87 111.16 128.21 306.76 126.51 306.76 227.31 108.94 227.87 108.94 227.87 111.16"/><polygon class="cls-79" points="227.87 114.49 129.91 306.76 128.21 306.76 227.87 111.16 227.87 114.49"/><polygon class="cls-319" points="227.87 117.83 131.6 306.76 129.91 306.76 227.87 114.49 227.87 117.83"/><polygon class="cls-320" points="227.87 121.16 133.3 306.76 131.6 306.76 227.87 117.83 227.87 121.16"/><polygon class="cls-321" points="227.87 124.49 135 306.76 133.3 306.76 227.87 121.16 227.87 124.49"/><polygon class="cls-83" points="227.87 127.82 136.7 306.76 135 306.76 227.87 124.49 227.87 127.82"/><polygon class="cls-83" points="136.7 306.76 227.87 127.82 227.87 306.76 136.7 306.76"/></g><g class="cls-322"><polygon class="cls-291" points="124.93 164.87 246.64 286.58 124.93 286.58 124.93 164.87"/><polygon class="cls-291" points="124.93 160.51 250.1 285.69 249.21 286.58 246.64 286.58 124.93 164.87 124.93 160.51"/><polygon class="cls-323" points="124.93 156.15 252.28 283.51 250.1 285.69 124.93 160.51 124.93 156.15"/><polygon class="cls-324" points="124.93 151.78 254.47 281.32 252.28 283.51 124.93 156.15 124.93 151.78"/><polygon class="cls-325" points="124.93 147.42 256.65 279.14 254.47 281.32 124.93 151.78 124.93 147.42"/><polygon class="cls-326" points="124.93 143.06 258.83 276.96 256.65 279.14 124.93 147.42 124.93 143.06"/><polygon class="cls-327" points="124.93 138.69 261.01 274.78 258.83 276.96 124.93 143.06 124.93 138.69"/><polygon class="cls-328" points="124.93 134.33 263.19 272.6 261.01 274.78 124.93 138.69 124.93 134.33"/><polygon class="cls-329" points="124.93 129.97 265.38 270.42 263.19 272.6 124.93 134.33 124.93 129.97"/><polygon class="cls-330" points="124.93 125.61 267.56 268.24 265.38 270.42 124.93 129.97 124.93 125.61"/><polygon class="cls-331" points="124.93 121.24 269.74 266.05 267.56 268.24 124.93 125.61 124.93 121.24"/><polygon class="cls-332" points="124.93 116.88 271.92 263.87 269.74 266.05 124.93 121.24 124.93 116.88"/><polygon class="cls-333" points="124.93 112.52 274.1 261.69 271.92 263.87 124.93 116.88 124.93 112.52"/><polygon class="cls-334" points="124.93 108.15 276.28 259.51 274.1 261.69 124.93 112.52 124.93 108.15"/><polygon class="cls-335" points="124.93 103.79 278.46 257.33 276.28 259.51 124.93 108.15 124.93 103.79"/><polygon class="cls-336" points="124.93 99.43 280.65 255.15 278.46 257.33 124.93 103.79 124.93 99.43"/><polygon class="cls-337" points="124.93 95.06 282.83 252.96 280.65 255.15 124.93 99.43 124.93 95.06"/><polygon class="cls-338" points="124.93 90.7 285.01 250.78 282.83 252.96 124.93 95.06 124.93 90.7"/><polygon class="cls-339" points="124.93 86.34 287.19 248.6 285.01 250.78 124.93 90.7 124.93 86.34"/><polygon class="cls-340" points="124.93 81.97 289.37 246.42 287.19 248.6 124.93 86.34 124.93 81.97"/><polygon class="cls-341" points="124.93 77.61 291.55 244.24 289.37 246.42 124.93 81.97 124.93 77.61"/><polygon class="cls-342" points="124.93 73.25 293.74 242.06 291.55 244.24 124.93 77.61 124.93 73.25"/><polygon class="cls-343" points="124.93 68.88 295.92 239.87 293.74 242.06 124.93 73.25 124.93 68.88"/><polygon class="cls-344" points="124.93 64.52 298.1 237.69 295.92 239.87 124.93 68.88 124.93 64.52"/><polygon class="cls-345" points="124.93 60.16 300.28 235.51 298.1 237.69 124.93 64.52 124.93 60.16"/><polygon class="cls-346" points="124.93 56.68 125.37 56.23 302.46 233.33 300.28 235.51 124.93 60.16 124.93 56.68"/><rect class="cls-347" x="213.46" y="18.47" width="3.09" height="250.45" transform="translate(-38.63 194.12) rotate(-45)"/><rect class="cls-348" x="215.64" y="16.29" width="3.09" height="250.45" transform="translate(-36.45 195.02) rotate(-45)"/><rect class="cls-349" x="217.83" y="14.1" width="3.09" height="250.45" transform="translate(-34.27 195.93) rotate(-45)"/><rect class="cls-350" x="220.01" y="11.92" width="3.09" height="250.45" transform="translate(-32.09 196.83) rotate(-45)"/><rect class="cls-351" x="222.19" y="9.74" width="3.09" height="250.45" transform="translate(-29.91 197.73) rotate(-45)"/><rect class="cls-352" x="224.37" y="7.56" width="3.09" height="250.45" transform="translate(-27.72 198.64) rotate(-45)"/><polygon class="cls-353" points="138.46 43.15 140.64 40.96 317.48 217.81 317.48 218.31 315.55 220.24 138.46 43.15"/><polygon class="cls-354" points="140.64 40.96 142.82 38.78 317.48 213.44 317.48 217.81 140.64 40.96"/><polygon class="cls-355" points="142.82 38.78 145 36.6 317.48 209.08 317.48 213.44 142.82 38.78"/><polygon class="cls-356" points="145 36.6 147.18 34.42 317.48 204.72 317.48 209.08 145 36.6"/><polygon class="cls-357" points="147.18 34.42 149.37 32.24 317.48 200.35 317.48 204.72 147.18 34.42"/><polygon class="cls-358" points="149.37 32.24 151.55 30.06 317.48 195.99 317.48 200.35 149.37 32.24"/><polygon class="cls-359" points="151.55 30.06 153.73 27.88 317.48 191.63 317.48 195.99 151.55 30.06"/><polygon class="cls-360" points="153.73 27.88 155.91 25.69 317.48 187.26 317.48 191.63 153.73 27.88"/><polygon class="cls-361" points="155.91 25.69 158.09 23.51 317.48 182.9 317.48 187.26 155.91 25.69"/><polygon class="cls-362" points="158.09 23.51 160.27 21.33 317.48 178.54 317.48 182.9 158.09 23.51"/><polygon class="cls-363" points="160.27 21.33 162.45 19.15 317.48 174.18 317.48 178.54 160.27 21.33"/><polygon class="cls-364" points="162.45 19.15 164.64 16.97 317.48 169.81 317.48 174.18 162.45 19.15"/><polygon class="cls-250" points="164.64 16.97 166.82 14.79 317.48 165.45 317.48 169.81 164.64 16.97"/><polygon class="cls-250" points="166.82 14.79 181.6 0 317.48 0 317.48 165.45 166.82 14.79"/></g><g class="cls-365"><polygon class="cls-210" points="161.05 199.85 76.74 214.72 76.74 199.85 161.05 199.85"/><polygon class="cls-210" points="179.32 199.85 76.74 217.94 76.74 214.72 161.05 199.85 179.32 199.85"/><polygon class="cls-211" points="197.58 199.85 76.74 221.16 76.74 217.94 179.32 199.85 197.58 199.85"/><polygon class="cls-212" points="215.85 199.85 76.74 224.38 76.74 221.16 197.58 199.85 215.85 199.85"/><polygon class="cls-213" points="234.12 199.85 77.16 227.53 76.74 225.19 76.74 224.38 215.85 199.85 234.12 199.85"/><polygon class="cls-214" points="252.38 199.85 77.71 230.65 77.16 227.53 234.12 199.85 252.38 199.85"/><polygon class="cls-366" points="270.65 199.85 78.26 233.78 77.71 230.65 252.38 199.85 270.65 199.85"/><polygon class="cls-216" points="288.91 199.85 78.81 236.9 78.26 233.78 270.65 199.85 288.91 199.85"/><polygon class="cls-217" points="307.18 199.85 79.36 240.02 78.81 236.9 288.91 199.85 307.18 199.85"/><polygon class="cls-218" points="325.44 199.85 79.91 243.15 79.36 240.02 307.18 199.85 325.44 199.85"/><polygon class="cls-219" points="338.74 199.85 338.89 200.7 80.46 246.27 79.91 243.15 325.44 199.85 338.74 199.85"/><rect class="cls-220" x="78.74" y="223.46" width="262.42" height="3.17" transform="translate(-35.89 39.88) rotate(-10)"/><rect class="cls-221" x="79.29" y="226.59" width="262.42" height="3.17" transform="translate(-36.42 40.02) rotate(-10)"/><rect class="cls-222" x="79.84" y="229.71" width="262.42" height="3.17" transform="translate(-36.96 40.16) rotate(-10)"/><rect class="cls-223" x="80.39" y="232.83" width="262.42" height="3.17" transform="translate(-37.49 40.31) rotate(-10)"/><rect class="cls-224" x="80.95" y="235.96" width="262.42" height="3.17" transform="translate(-38.03 40.45) rotate(-10)"/><rect class="cls-367" x="81.5" y="239.08" width="262.42" height="3.17" transform="translate(-38.56 40.59) rotate(-10)"/><rect class="cls-226" x="82.05" y="242.2" width="262.42" height="3.17" transform="translate(-39.09 40.74) rotate(-10)"/><rect class="cls-227" x="82.6" y="245.33" width="262.42" height="3.17" transform="translate(-39.63 40.88) rotate(-10)"/><rect class="cls-228" x="83.15" y="248.45" width="262.42" height="3.17" transform="translate(-40.16 41.02) rotate(-10)"/><rect class="cls-229" x="83.7" y="251.58" width="262.42" height="3.17" transform="translate(-40.7 41.16) rotate(-10)"/><rect class="cls-368" x="84.25" y="254.7" width="262.42" height="3.17" transform="translate(-41.23 41.31) rotate(-10)"/><rect class="cls-231" x="84.8" y="257.82" width="262.42" height="3.17" transform="matrix(0.98, -0.17, 0.17, 0.98, -41.76, 41.45)"/><rect class="cls-232" x="85.35" y="260.95" width="262.42" height="3.17" transform="translate(-42.3 41.59) rotate(-10)"/><rect class="cls-233" x="85.9" y="264.07" width="262.42" height="3.17" transform="translate(-42.83 41.74) rotate(-10)"/><rect class="cls-234" x="86.45" y="267.19" width="262.42" height="3.17" transform="translate(-43.37 41.88) rotate(-10)"/><rect class="cls-369" x="87" y="270.32" width="262.42" height="3.17" transform="matrix(0.98, -0.17, 0.17, 0.98, -43.9, 42.02)"/><rect class="cls-236" x="87.56" y="273.44" width="262.42" height="3.17" transform="translate(-44.43 42.17) rotate(-10)"/><rect class="cls-237" x="88.11" y="276.56" width="262.42" height="3.17" transform="translate(-44.97 42.31) rotate(-10)"/><rect class="cls-238" x="88.66" y="279.69" width="262.42" height="3.17" transform="translate(-45.5 42.45) rotate(-10)"/><rect class="cls-239" x="89.21" y="282.81" width="262.42" height="3.17" transform="translate(-46.04 42.6) rotate(-10)"/><rect class="cls-240" x="89.76" y="285.94" width="262.42" height="3.17" transform="translate(-46.57 42.74) rotate(-10)"/><rect class="cls-241" x="90.31" y="289.06" width="262.42" height="3.17" transform="translate(-47.1 42.88) rotate(-10)"/><rect class="cls-242" x="90.86" y="292.18" width="262.42" height="3.17" transform="translate(-47.64 43.03) rotate(-10)"/><rect class="cls-243" x="91.41" y="295.31" width="262.42" height="3.17" transform="translate(-48.17 43.17) rotate(-10)"/><rect class="cls-244" x="91.96" y="298.43" width="262.42" height="3.17" transform="translate(-48.71 43.31) rotate(-10)"/><rect class="cls-370" x="92.51" y="301.55" width="262.42" height="3.17" transform="translate(-49.24 43.45) rotate(-10)"/><polygon class="cls-246" points="353.21 281.92 353.4 282.95 353.4 285.11 95.33 330.61 94.78 327.49 353.21 281.92"/><polygon class="cls-247" points="353.4 288.33 95.88 333.73 95.33 330.61 353.4 285.11 353.4 288.33"/><polygon class="cls-248" points="353.4 291.55 96.43 336.86 95.88 333.73 353.4 288.33 353.4 291.55"/><polygon class="cls-249" points="353.4 294.77 96.98 339.98 96.43 336.86 353.4 291.55 353.4 294.77"/><polygon class="cls-250" points="353.4 297.99 97.53 343.1 96.98 339.98 353.4 294.77 353.4 297.99"/><polygon class="cls-250" points="99.08 351.89 97.53 343.1 353.4 297.99 353.4 351.89 99.08 351.89"/></g></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/manticoresearch.png b/apps/desktop/public/icons/database/manticoresearch.png
new file mode 100644
index 0000000..420cb72
Binary files /dev/null and b/apps/desktop/public/icons/database/manticoresearch.png differ
diff --git a/apps/desktop/public/icons/database/mariadb.svg b/apps/desktop/public/icons/database/mariadb.svg
new file mode 100644
index 0000000..3153880
--- /dev/null
+++ b/apps/desktop/public/icons/database/mariadb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#157997" d="M946.761 240.884a12.34 12.34 0 0 0-8.484-2.926c-8.485 0-19.456 5.852-25.357 9.021l-2.291 1.22a78.9 78.9 0 0 1-31.696 8.191c-11.215.341-20.919 1.024-33.548 2.39-74.8 7.85-108.154 66.608-140.288 123.367-17.554 30.964-35.596 63.05-60.367 87.576a164 164 0 0 1-16.335 14.141c-25.6 19.554-57.832 33.5-82.896 43.398-24.088 9.412-50.42 17.896-75.873 26.137-23.308 7.51-45.3 14.628-65.536 22.333-9.119 3.413-16.872 6.095-23.698 8.436-18.432 6.144-31.696 10.825-51.2 24.527a331 331 0 0 0-20.285 15.311c-15.41 12.63-29.062 27.307-40.521 43.788-9.9 15.116-21.31 29.16-34.085 41.838-4.096 4.145-11.362 6.144-22.235 6.144-12.776 0-28.234-2.682-44.618-5.559-16.871-3.072-34.328-5.949-49.25-5.949-12.19 0-21.454 2-28.427 6.095 0 0-11.703 7.022-16.628 16.092l4.876 2.194a100.5 100.5 0 0 1 20.675 15.311 101.2 101.2 0 0 0 21.553 15.702 19.3 19.3 0 0 1 6.631 4.34c-2.048 3.072-5.022 7.021-8.143 11.215-17.261 23.162-27.355 37.79-21.601 45.787 2.78 1.463 5.851 2.194 8.972 2.048 37.644 0 57.88-9.996 83.48-22.674 7.412-3.706 14.97-7.46 23.894-11.362 15.018-6.68 31.11-17.261 48.176-28.477 22.382-14.92 45.739-30.232 68.413-37.644a181.3 181.3 0 0 1 57.54-8.29c23.941 0 49.151 3.268 73.435 6.486 18.09 2.39 36.864 4.876 55.296 5.949 7.119.488 13.75.683 20.187.683 8.582 0 17.213-.488 25.747-1.414l2.096-.732c12.873-8.094 18.92-25.551 24.771-42.423 3.804-10.825 6.973-20.577 11.996-26.819a8 8 0 0 1 .975-.78 1.17 1.17 0 0 1 1.463.244v.487c-3.023 65.927-28.916 107.764-55.101 145.018l-17.554 19.213s24.527 0 38.473-5.51c50.858-15.604 89.234-49.884 117.223-104.644a452 452 0 0 0 18.432-43.203c.488-1.219 4.877-3.51 4.486 2.829-.195 1.901-.292 3.998-.438 6.144 0 1.316 0 2.633-.244 3.9-.732 9.265-2.828 28.673-2.828 28.673l15.701-8.631c37.888-24.528 67.096-73.972 89.234-150.967 9.216-32.086 15.994-63.878 21.943-91.965 7.12-33.743 13.263-62.61 20.285-73.874 11.02-17.555 27.892-29.453 44.178-41.01 2.243-1.56 4.486-3.071 6.68-4.73 20.48-14.774 40.863-31.743 45.35-63.487v-.732c3.266-23.649.487-29.696-2.634-32.426"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/milvus.png b/apps/desktop/public/icons/database/milvus.png
new file mode 100644
index 0000000..4d3214c
Binary files /dev/null and b/apps/desktop/public/icons/database/milvus.png differ
diff --git a/apps/desktop/public/icons/database/mongodb.svg b/apps/desktop/public/icons/database/mongodb.svg
new file mode 100644
index 0000000..ee47003
--- /dev/null
+++ b/apps/desktop/public/icons/database/mongodb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#10aa50" d="M707.072 419.789C658.944 204.544 558.797 147.2 533.197 106.7A463 463 0 0 1 505.344 51.2c-1.382 19.098-3.84 31.18-19.866 45.67-32.153 29.082-168.704 142.03-180.224 386.612-10.7 228.044 165.172 368.64 188.416 383.18 17.92 8.91 39.63.154 50.228-8.038C628.685 799.59 744.55 642.15 707.226 419.789"/><path fill="#b8c4c2" d="M528.486 716.8c-4.454 62.26-7.628 98.406-18.944 133.99 0 0 7.424 59.239 12.647 122.01h18.432a1260 1260 0 0 1 20.121-131.43c-23.859-13.056-31.334-69.94-32.256-124.57"/><path fill="#12924f" d="M546.304 870.4c-23.706-11.469-30.618-65.28-31.642-115.405 5.837-82.688 7.578-165.632 5.12-248.473-1.228-43.52.564-402.74-10.24-455.322 7.424 17.818 15.924 35.072 25.55 51.712 25.292 41.42 124.518 99.942 172.031 319.744C744.192 649.37 630.17 809.728 546.355 870.4z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/mysql.svg b/apps/desktop/public/icons/database/mysql.svg
new file mode 100644
index 0000000..0a3adb7
--- /dev/null
+++ b/apps/desktop/public/icons/database/mysql.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#0a5af6" d="M805.274 704c-38.196-1.024-67.84 2.918-92.672 13.62-7.168 2.918-18.586 2.918-19.559 12.185 3.84 3.84 4.301 10.189 7.68 15.565 5.683 9.728 15.719 22.835 24.781 29.696 10.035 7.73 20.07 15.513 30.618 22.323 18.585 11.725 39.628 18.483 57.753 30.208 10.547 6.758 20.992 15.513 31.54 22.835 5.222 3.891 8.55 10.24 15.257 12.646v-1.484c-3.38-4.352-4.3-10.701-7.629-15.565-4.761-4.864-9.574-9.216-14.336-14.08a229.6 229.6 0 0 0-49.664-49.152c-15.309-10.752-48.742-25.293-54.937-43.264l-.973-1.024c10.547-.922 22.989-4.864 32.973-7.783 16.23-4.403 31.027-3.379 47.77-7.782 7.68-1.946 15.257-4.403 22.937-6.758v-4.506c-8.653-8.704-14.848-20.429-23.86-28.672a641.5 641.5 0 0 0-78.847-59.853c-14.848-9.728-33.895-16.025-49.664-24.32-5.735-2.918-15.258-4.352-18.637-9.216-8.55-10.752-13.363-24.832-19.559-37.478a1217 1217 0 0 1-39.168-84.685c-8.601-18.944-13.824-37.888-24.32-55.45-49.254-82.688-102.707-132.761-184.832-181.913-17.715-10.24-38.707-14.643-61.132-19.968-11.93-.512-23.86-1.485-35.84-1.946-7.68-3.43-15.31-12.646-21.965-17.05-27.239-17.51-97.383-55.449-117.453-5.324-12.902 31.641 19.098 62.771 30.054 78.848 8.141 11.161 18.637 23.808 24.372 36.454 3.328 8.243 4.3 17.05 7.68 25.805 7.577 21.402 14.745 45.21 24.78 65.178 5.274 10.24 10.957 20.94 17.664 30.156 3.84 5.376 10.496 7.783 11.981 16.538-6.656 9.728-7.168 24.32-11.008 36.506-17.203 54.988-10.547 123.084 13.824 163.43 7.68 12.186 25.805 38.912 50.176 28.672 21.504-8.704 16.691-36.454 22.887-60.774 1.433-5.837.512-9.728 3.328-13.62v1.024c6.707 13.568 13.414 26.676 19.61 40.346 14.847 23.808 40.6 48.64 62.105 65.178 11.417 8.755 20.48 23.859 34.816 29.184v-1.434h-.922c-2.867-4.403-7.168-6.349-11.008-9.728a238.3 238.3 0 0 1-24.832-29.184 625 625 0 0 1-53.453-88.576c-7.68-15.104-14.336-31.642-20.53-46.694-2.868-5.837-2.868-14.592-7.68-17.51-7.169 10.7-17.665 19.967-22.887 33.023-9.063 20.992-10.035 46.746-13.415 73.523-1.894.512-.921 0-1.894.973-15.258-3.891-20.48-19.968-26.266-33.536-14.336-34.611-16.742-90.06-4.3-129.945 3.328-10.24 17.715-42.292 11.98-52.02-2.918-9.318-12.441-14.592-17.715-21.913a193.6 193.6 0 0 1-17.152-31.13c-11.469-27.238-17.254-57.446-29.593-84.685-5.735-12.646-15.821-25.804-23.91-37.427-9.063-13.158-19.098-22.374-26.266-37.939-2.356-5.376-5.735-14.131-1.895-19.968.922-3.891 2.867-5.376 6.656-6.349 6.195-5.325 23.91 1.485 30.106 4.403 17.664 7.27 32.46 14.132 47.257 24.32 6.656 4.864 13.824 14.08 22.426 16.538h10.086c15.258 3.38 32.461.973 46.797 5.376a303 303 0 0 1 68.762 33.536 428.85 428.85 0 0 1 148.992 166.4c5.734 11.162 8.14 21.402 13.363 33.075 10.035 23.86 22.477 48.18 32.46 71.527 10.036 22.886 19.61 46.182 33.946 65.177 7.168 10.24 35.84 15.565 48.692 20.941 9.574 4.352 24.37 8.243 32.972 13.62 16.23 10.188 32.461 21.862 47.77 33.074 7.578 5.837 31.488 18.023 32.922 27.75z"/><path fill="#0a5af6" d="M321.74 277.606a5.12 5.12 0 0 0-3.583-1.536 80.3 80.3 0 0 0-20.992 2.612 5.12 5.12 0 0 0-3.789 4.966v.973a5.12 5.12 0 0 0 2.662 4.505c2.048 3.482 4.506 6.503 6.81 9.216l1.946 2.15c2.048 2.305 3.89 4.404 5.478 6.708 1.843 3.686 3.584 7.424 5.325 11.213l.205.46 5.324 11.265a5.12 5.12 0 0 0 8.244 1.382 35 35 0 0 0 .716-.768c8.192-6.144 11.776-15.667 11.776-28.16a5.12 5.12 0 0 0-1.228-3.277 16 16 0 0 1-2.56-4.454 25.75 25.75 0 0 0-10.24-12.595l-1.741-1.23c-1.843-1.28-3.226-2.252-4.352-3.43"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/nacos.png b/apps/desktop/public/icons/database/nacos.png
new file mode 100644
index 0000000..0d7626a
Binary files /dev/null and b/apps/desktop/public/icons/database/nacos.png differ
diff --git a/apps/desktop/public/icons/database/neo4j.svg b/apps/desktop/public/icons/database/neo4j.svg
new file mode 100644
index 0000000..4f0e62f
--- /dev/null
+++ b/apps/desktop/public/icons/database/neo4j.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#edf4ff" d="M626.688 204.8h1.178c-135.117 0-225.946 77.824-225.946 230.963v93.338a125.7 125.7 0 0 1 44.032-10.24 86.07 86.07 0 0 1 44.288 10.24v-93.338c0-98.611 54.58-150.63 136.96-150.63s136.909 52.019 136.909 150.63V674.51h88.371V435.712c0-153.037-91.29-230.912-225.792-230.912"/><path fill="#018bff" d="M440.934 562.893a61.85 61.85 0 0 0-44.236 15.513L313.6 524.134a54.4 54.4 0 0 0 2.714-20.838 75.315 75.315 0 1 0-75.264 75.11c16.128.922 32-4.608 44.032-15.513l83.046 57.037c-2.048 6.758-2.867 13.772-2.509 20.787-.41 7.014.461 14.08 2.56 20.787l-83.097 57.293a70.14 70.14 0 0 0-44.032-15.77 75.315 75.315 0 1 0 75.264 75.315 54.3 54.3 0 0 0-2.714-20.787l83.098-57.037c12.492 10.138 28.16 15.616 44.236 15.514a75.11 75.11 0 0 0 75.11-75.315 77.363 77.363 0 0 0-75.11-77.824"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/oceanbase.svg b/apps/desktop/public/icons/database/oceanbase.svg
new file mode 100644
index 0000000..2ace405
--- /dev/null
+++ b/apps/desktop/public/icons/database/oceanbase.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#0181fd" d="M906.598 322.509v265.113a791.9 791.9 0 0 0-333.516 39.783 1051.55 1051.55 0 0 1-418.919 54.886V416.768c96.205 9.216 195.687.82 293.53-27.034 13.21-3.788 26.726-8.09 39.936-12.39a1055 1055 0 0 1 419.225-54.886h-.256z"/><path fill="#ffa005" d="M496.589 256a591 591 0 0 1-44.851 17.05c-7.066 2.406-14.08 4.608-21.35 7.014-5.684 1.638-11.367 3.533-17.306 5.12-86.784 24.064-174.592 30.566-259.482 21.094v88.628a770.3 770.3 0 0 0 303.77-31.079l22.732-7.27a762 762 0 0 0 43.52-16.487L496.332 256z"/><path fill="#07c846" d="M563.866 748.39a616 616 0 0 1 44.902-17.05c7.014-2.406 14.029-4.607 21.35-7.014 5.632-1.587 11.316-3.481 17.255-5.12a685.6 685.6 0 0 1 259.481-21.094v-88.627a770.3 770.3 0 0 0-286.72 25.958c-5.734 1.587-11.417 3.226-17.05 5.12l-22.732 7.27a762 762 0 0 0-43.52 16.487l27.34 84.07z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/opengauss.svg b/apps/desktop/public/icons/database/opengauss.svg
new file mode 100644
index 0000000..6f46971
--- /dev/null
+++ b/apps/desktop/public/icons/database/opengauss.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#1f80c4" d="M158.208 333.005a20.5 20.5 0 0 0-3.942 8.601h-.154v84.122a19.87 19.87 0 0 0 11.366 16.691l269.364 158.26a136.45 136.45 0 0 0 125.49 0l269.569-157.697a19.92 19.92 0 0 0 11.366-16.742l1.024-83.968-217.293-116.838-160.41 92.979a19.35 19.35 0 0 0-11.366 16.691v83.814c2.1 5.888 6.144 10.957 11.367 14.336 2.56-35.84 42.496-58.265 42.496-58.265l116.94-66.765 152.577 82.893-216.27 128.307a137.47 137.47 0 0 1-125.44 0l-226.508-133.58 226.406-133.53a126.4 126.4 0 0 1 62.823-15.207V153.6a126.8 126.8 0 0 0-62.823 15.155l-269.312 158.31a20.5 20.5 0 0 0-7.321 5.94zm679.117 236.851a19.87 19.87 0 0 0 3.43-9.882l-.358-83.302a19.87 19.87 0 0 1-11.367 16.691L560.026 651.571a136.45 136.45 0 0 1-125.543 0L164.966 492.75a19.87 19.87 0 0 1-11.366-16.743v83.456a19.87 19.87 0 0 0 11.366 16.692l269.517 158.412a137.42 137.42 0 0 0 125.543 0l269.312-157.9a19.87 19.87 0 0 0 7.987-6.81m3.43 119.654a19.87 19.87 0 0 1-11.366 16.692L560.026 863.949a136.45 136.45 0 0 1-125.543 0L164.966 705.74a19.87 19.87 0 0 1-11.366-16.794v-83.456a19.71 19.71 0 0 0 11.366 16.691l269.517 158.413a137.47 137.47 0 0 0 125.543 0l269.004-157.9a19.56 19.56 0 0 0 11.367-16.692l.358 83.456z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/oracle.svg b/apps/desktop/public/icons/database/oracle.svg
new file mode 100644
index 0000000..20e98a4
--- /dev/null
+++ b/apps/desktop/public/icons/database/oracle.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#c74634" d="M363.827 761.805A251.853 251.853 0 0 1 110.95 508.877 251.853 251.853 0 0 1 363.878 256h296.295A251.853 251.853 0 0 1 913.1 508.928a251.853 251.853 0 0 1-252.928 252.877zm288.717-89.395a162.97 162.97 0 0 0 163.482-163.533 162.97 162.97 0 0 0-163.533-163.482H371.507a162.97 162.97 0 0 0-163.481 163.533c0 89.446 74.086 163.533 163.481 163.533h281.037z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/polardb.webp b/apps/desktop/public/icons/database/polardb.webp
new file mode 100644
index 0000000..7363a49
Binary files /dev/null and b/apps/desktop/public/icons/database/polardb.webp differ
diff --git a/apps/desktop/public/icons/database/postgres.svg b/apps/desktop/public/icons/database/postgres.svg
new file mode 100644
index 0000000..a24c0a6
--- /dev/null
+++ b/apps/desktop/public/icons/database/postgres.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#326690" d="M637.03 195.02c46.746-10.137 96.82-8.857 141.824 8.244a188.6 188.6 0 0 1 79.719 59.085c9.881 12.595 11.161 29.44 11.776 44.902.512 36.813-6.861 73.216-16.23 108.544-17.92 65.536-45.057 128.359-79.156 186.829a170 170 0 0 1-11.11 16.589l-1.28-6.503c4.25-11.264 10.445-21.862 12.851-33.792 8.55-33.792 1.331-68.454-1.74-102.4-3.226-32.05 7.577-63.232 7.32-95.232 1.23-15.616-4.863-30.412-10.854-44.492-21.504-48.64-55.808-91.956-99.737-121.703-10.701-7.424-22.682-12.646-33.383-20.07"/><path fill="#326690" d="M507.29 199.475a220.16 220.16 0 0 1 163.532 44.954 261.9 261.9 0 0 1 83.61 116.94c-26.675-.972-56.986-2.047-78.592 16.692-19.558 16.691-22.118 45.21-17.715 69.12 10.24 56.985 43.469 105.318 67.993 156.518 6.503 12.032 15.258 22.528 23.552 33.28-9.932 5.069-20.992 9.882-26.624 20.173-9.83 16.077-6.348 35.686-8.806 53.555-5.632 50.023-11.264 100.096-19.302 149.76-3.79 23.808-13.824 49.152-36.096 60.98-22.733 11.775-49.255 19.097-74.906 15.103-24.32-4.3-39.629-27.238-46.592-49.612-5.018-18.74-5.53-38.298-6.963-57.55a1793 1793 0 0 1-1.331-139.775c1.024-18.227-8.192-37.171-24.27-46.08-7.782-4.352-16.895-4.967-25.6-5.632 6.862-34.304 27.495-63.847 34.56-98.048 9.217-42.291 4.097-86.323-5.273-128.103-4.608-20.838-20.275-39.27-41.165-44.339-32.153-8.192-64.512 4.557-93.286 18.074 3.584-47.207 16.128-95.54 44.698-133.888a132.56 132.56 0 0 1 88.576-52.122"/><path fill="#326690" d="M262.246 203.264c51.2-9.933 103.68.614 152.781 15.77a228.7 228.7 0 0 0-48.384 83.456 340.9 340.9 0 0 0-16.384 129.126c2.048 30.72.973 61.491-3.123 92.006a125.65 125.65 0 0 0 39.68 107.47c-19.866 23.5-40.96 45.926-60.211 69.99-8.55 10.137-19.968 22.17-34.509 19.148-16.947-4.966-27.75-20.582-37.171-34.662-25.549-41.267-40.96-87.86-55.04-134.144-15.77-54.784-29.082-110.438-36.762-167.014-3.789-43.008-1.433-89.19 20.378-127.488 16.333-29.082 46.745-47.565 78.745-53.607zm437.095 198.605c-6.298 5.222.512 12.953 5.837 15.462 13.107 7.731 30.976-3.072 31.436-18.227a37.53 37.53 0 0 0-37.273 2.765m-6.963-7.168c18.841-13.466 43.468-10.445 65.228-9.114-.921 30.413-10.24 60.263-7.168 90.931 2.714 37.888 13.568 78.592-4.096 114.535-23.705-47.667-54.374-93.184-65.024-146.279-3.072-16.896-3.788-38.297 11.06-50.022z"/><path fill="#326690" d="M439.45 402.79c-3.584 1.332-7.424 3.79-6.656 8.192 2.56 15.207 22.681 24.423 35.328 15.002 5.58-3.174 11.417-11.93 5.017-17.203-9.216-7.527-22.528-9.011-33.69-5.99m-66.356 11.623c23.604-15.463 51.2-27.495 79.821-25.856a34.82 34.82 0 0 1 32.051 25.958c13.005 52.327 16.999 110.49-7.884 160-8.55 19.149-15.872 38.861-21.812 58.983-41.37.41-76.544-34.919-83.916-74.752-5.018-22.528 1.536-45.159 2.304-67.738 1.74-25.498-.052-51.098-.512-76.595zm372.941 251.29c6.144-4.609 14.848-8.756 21.965-3.79 30.106 16.026 65.126 8.193 97.178 4.301-19.61 19.252-46.695 28.263-73.37 31.181-17.664 2.1-35.994 2.765-53.043-3.174.102-9.728-.41-21.3 7.27-28.519m-303.36 37.324c17.306-9.42 24.167-30.157 40.346-40.755 17.561-2.56 30.464 23.91 17.152 36.403-26.01 35.584-77.978 42.394-115.559 23.04 18.535-8.704 40.192-8.038 58.061-18.688"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/presto.svg b/apps/desktop/public/icons/database/presto.svg
new file mode 100644
index 0000000..873883c
--- /dev/null
+++ b/apps/desktop/public/icons/database/presto.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#5d88d6" d="M572.928 238.694a36.096 36.096 0 1 0-51.098-51.046 36.096 36.096 0 0 0 51.047 51.046zM674.97 340.787a40.09 40.09 0 1 0-56.679-56.73 40.09 40.09 0 0 0 56.679 56.73M777.062 442.88a44.134 44.134 0 1 0-62.361-62.362 44.134 44.134 0 0 0 62.361 62.362m101.99 101.99a48.128 48.128 0 1 0-68.095-68.096 48.128 48.128 0 0 0 68.096 68.096"/><path fill="#32dbfc" d="M371.712 235.878a32.102 32.102 0 1 0-45.414-45.414 32.102 32.102 0 0 0 45.414 45.414M473.754 337.92a36.096 36.096 0 1 0-51.098-50.995 36.096 36.096 0 0 0 51.098 51.046zm101.99 102.042a40.09 40.09 0 1 0-56.73-56.73 40.09 40.09 0 0 0 56.73 56.73m102.042 102.041a44.134 44.134 0 1 0-62.413-62.413 44.134 44.134 0 0 0 62.413 62.413m102.092 102.093a48.128 48.128 0 1 0-68.096-67.994 48.128 48.128 0 0 0 68.096 68.045z"/><path d="M170.496 233.165a28.109 28.109 0 1 0-39.68-39.731 28.109 28.109 0 0 0 39.731 39.73zm101.99 101.939a32.102 32.102 0 1 0-45.363-45.414 32.102 32.102 0 0 0 45.363 45.414M374.58 437.248a36.096 36.096 0 1 0-51.046-51.098 36.096 36.096 0 0 0 51.046 51.098M476.672 539.29a40.09 40.09 0 1 0-56.832-56.73 40.09 40.09 0 0 0 56.73 56.678zm101.94 102.041a44.134 44.134 0 1 0-62.362-62.413 44.134 44.134 0 0 0 62.361 62.413m102.04 101.888a48.128 48.128 0 1 0-68.095-68.096 48.128 48.128 0 0 0 68.096 68.096"/><path fill="#5d88d6" d="M371.712 632.678a32.102 32.102 0 1 0-45.414-45.414 32.102 32.102 0 0 0 45.414 45.414M249.805 741.274a32.102 32.102 0 1 0 0-64.205 32.102 32.102 0 0 0 0 64.205M150.63 840.55a32.102 32.102 0 1 0 0-64.204 32.102 32.102 0 0 0 0 64.204m198.35-.05a32.102 32.102 0 1 0 0-64.206 32.102 32.102 0 0 0 0 64.205m221.132-9.37a32.102 32.102 0 1 0-45.414-45.364 32.102 32.102 0 0 0 45.414 45.364m-99.226-99.277a32.102 32.102 0 1 0-45.363-45.415 32.102 32.102 0 0 0 45.363 45.415"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/pulsar.svg b/apps/desktop/public/icons/database/pulsar.svg
new file mode 100644
index 0000000..feca270
--- /dev/null
+++ b/apps/desktop/public/icons/database/pulsar.svg
@@ -0,0 +1,3 @@
+<svg width="35" height="30" viewBox="0 0 35 30" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M34.7333 8.16353H26.2455C23.9513 3.68838 21.5234 0.21138 18.2199 0.21138C13.9192 0.21138 11.9007 4.0266 9.94695 7.74283L9.77671 8.06867H0V10.2753H5.69498C7.70544 10.2753 8.11483 10.9641 8.11483 10.9641C6.53807 13.4553 4.6411 15.9177 1.47948 15.9177H0V18.2316H1.49164C7.62032 18.2316 10.2955 13.1749 12.4438 9.11631C14.4138 5.37533 15.7879 3.11095 18.2239 3.11095C20.7532 3.11095 23.4122 8.70797 25.751 13.6492C26.0915 14.3669 26.4401 15.101 26.7927 15.8311C17.8186 16.1198 13.5423 18.2563 10.0645 20.001C7.51899 21.2755 5.50852 22.8552 2.20098 22.8552H0V25.1732H2.18071C6.16517 25.1732 8.64988 23.9235 11.2927 22.5954C14.9529 20.7641 19.1035 18.6894 28.8883 18.6894H34.5428V16.3714H31.3487C31.0852 16.392 30.8218 16.3508 30.5786 16.2477C30.3354 16.1487 30.1165 15.9919 29.9422 15.7898C29.3828 14.6886 28.8356 13.5296 28.3006 12.3706L27.5588 10.828C27.5588 10.828 28.0898 10.2506 29.5571 10.2506H34.7333V8.16353Z" fill="#188FFF"/>
+</svg>
diff --git a/apps/desktop/public/icons/database/qdrant.svg b/apps/desktop/public/icons/database/qdrant.svg
new file mode 100644
index 0000000..c10ad96
--- /dev/null
+++ b/apps/desktop/public/icons/database/qdrant.svg
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Capa_2" data-name="Capa 2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 346.42 400">
+  <defs>
+    <style>
+      .cls-1 {
+        fill: #9e0d38;
+      }
+
+      .cls-2 {
+        fill: #dc244c;
+      }
+
+      .cls-3 {
+        fill: #ff516b;
+      }
+    </style>
+  </defs>
+  <g id="Vectors">
+    <g>
+      <g>
+        <polygon class="cls-2" points="173.21 0 0 100 0 300 173.21 400 238.16 362.5 238.16 287.5 173.21 325 64.96 262.5 64.96 137.5 173.21 75 281.46 137.5 281.46 387.5 346.42 350 346.42 100 173.21 0"/>
+        <polygon class="cls-2" points="108.26 162.5 108.26 237.5 173.21 275 238.16 237.5 238.16 162.5 173.21 125 108.26 162.5"/>
+      </g>
+      <g>
+        <polygon class="cls-1" points="238.16 287.5 238.16 362.5 173.21 400 173.21 325 238.16 287.5"/>
+        <polygon class="cls-1" points="346.42 100 346.42 350 281.46 387.5 281.46 137.5 346.42 100"/>
+        <polygon class="cls-3" points="346.42 100 281.46 137.5 173.21 75 64.96 137.5 0 100 173.21 0 346.42 100"/>
+        <polygon class="cls-2" points="173.21 325 173.21 400 0 300 0 100 64.96 137.5 64.96 262.5 173.21 325"/>
+        <polygon class="cls-3" points="238.16 162.5 173.21 200 108.26 162.5 173.21 125 238.16 162.5"/>
+        <polygon class="cls-2" points="173.21 200 173.21 275 108.26 237.5 108.26 162.5 173.21 200"/>
+        <polygon class="cls-1" points="238.16 162.5 238.16 237.5 173.21 275 173.21 200 238.16 162.5"/>
+      </g>
+    </g>
+  </g>
+</svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/questdb.svg b/apps/desktop/public/icons/database/questdb.svg
new file mode 100644
index 0000000..48bff14
--- /dev/null
+++ b/apps/desktop/public/icons/database/questdb.svg
@@ -0,0 +1,25 @@
+<svg width="812" height="701" viewBox="0 0 812 701" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M133.387 350.187C133.387 228.785 233.243 130.989 357.202 130.989C401.965 130.989 443.284 143.354 477.717 165.836L574.13 72.5358C514.446 27.572 438.693 0.59375 357.202 0.59375C159.786 0.59375 0.246094 156.843 0.246094 350.187C0.246094 543.531 159.786 699.781 357.202 699.781V569.386C233.243 569.386 133.387 471.589 133.387 350.187Z" fill="url(#paint0_linear)"/>
+<path d="M581.015 350.192H714.156C714.156 258.016 677.428 173.709 617.744 110.76L523.627 202.935C559.208 242.279 581.015 293.987 581.015 350.192Z" fill="url(#paint1_linear)"/>
+<path d="M466.239 361.43H269.971L616.596 700.906L811.717 699.782L466.239 361.43Z" fill="url(#paint2_linear)"/>
+<path opacity="0.6" d="M47.3016 175.957C-38.7809 421.01 218.319 523.302 218.319 523.302C190.772 503.069 156.339 455.857 146.01 422.134C124.202 352.44 131.089 297.359 166.669 236.658" fill="url(#paint3_linear)"/>
+<defs>
+<linearGradient id="paint0_linear" x1="803.686" y1="702.01" x2="178.788" y2="54.7941" gradientUnits="userSpaceOnUse">
+<stop stop-color="#892C6C"/>
+<stop offset="1" stop-color="#D14671"/>
+</linearGradient>
+<linearGradient id="paint1_linear" x1="143.714" y1="42.0442" x2="790.93" y2="692.448" gradientUnits="userSpaceOnUse">
+<stop stop-color="#C34170"/>
+<stop offset="1" stop-color="#8B2C6C"/>
+</linearGradient>
+<linearGradient id="paint2_linear" x1="774.991" y1="686.071" x2="115.023" y2="42.0437" gradientUnits="userSpaceOnUse">
+<stop stop-color="#882B6B"/>
+<stop offset="1" stop-color="#CF4671"/>
+</linearGradient>
+<linearGradient id="paint3_linear" x1="85.9224" y1="476.222" x2="175.953" y2="220.969" gradientUnits="userSpaceOnUse">
+<stop stop-color="white" stop-opacity="0.38"/>
+<stop offset="0.8598" stop-color="white" stop-opacity="0.01"/>
+<stop offset="1" stop-color="white" stop-opacity="0"/>
+</linearGradient>
+</defs>
+</svg>
diff --git a/apps/desktop/public/icons/database/redis.svg b/apps/desktop/public/icons/database/redis.svg
new file mode 100644
index 0000000..2df1a4f
--- /dev/null
+++ b/apps/desktop/public/icons/database/redis.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#a32422" d="M844.8 724.855c-38.451 20.173-238.234 102.298-281.242 124.877-43.008 22.528-66.048 21.914-99.737 5.837-33.639-16.128-245.504-102.246-283.904-120.627-19.354-9.063-29.184-16.845-29.184-24.064v-73.114s276.685-60.057 321.382-76.237c44.647-16.179 60.109-16.588 98.048-2.662s265.421 54.989 303.002 68.608v72.038c0 7.476-8.653 14.848-28.314 25.293v.051z"/><path fill="#dc382c" d="M844.8 652.1c-38.451 20.02-238.234 102.195-281.242 124.365s-66.048 21.965-99.737 5.94c-33.69-16.078-245.504-102.196-283.904-120.423s-39.117-30.925-1.485-45.67c37.632-14.695 248.986-97.434 293.683-113.716 44.647-16.281 60.109-16.64 98.048-2.662 37.94 13.926 236.851 92.98 274.227 106.752 37.376 13.721 39.066 25.088.41 45.056z"/><path fill="#a32422" d="M844.8 605.815c-38.451 20.07-238.234 102.196-281.242 124.365-43.008 22.17-65.894 21.965-99.532 5.837-33.69-16.18-245.76-101.837-284.16-120.115-19.303-9.216-29.184-16.896-29.184-24.218v-72.806s276.736-60.263 321.433-76.442c44.647-16.179 60.109-16.64 98.048-2.56 37.94 14.131 265.421 54.784 303.002 68.506v72.09c0 7.475-8.653 15.001-28.314 25.343z"/><path fill="#dc382c" d="M844.8 532.753C806.298 552.875 606.566 635 563.507 657.17c-43.008 22.118-66.048 22.016-99.737 5.888C430.13 646.98 218.266 561.17 179.917 542.788c-38.4-18.33-39.117-30.822-1.536-45.568 37.632-14.694 249.037-97.638 293.683-113.459 44.698-15.872 60.109-16.845 98.048-3.072 37.99 13.773 236.902 93.491 274.227 106.854 37.376 13.312 39.117 25.088.512 45.056v.154z"/><path fill="#a32422" d="M844.8 482.27c-38.451 20.121-238.234 102.297-281.242 124.416-43.008 22.118-65.894 21.965-99.532 5.94-33.69-16.078-245.76-101.991-284.16-120.32-19.303-9.063-29.184-16.795-29.184-24.065v-73.114s276.736-60.057 321.433-76.185c44.647-16.128 60.109-16.64 98.048-2.714s265.319 54.99 302.9 68.71v72.04c.102 7.577-8.551 15-28.263 25.292"/><path fill="#dc382c" d="M844.8 409.31c-38.451 19.763-238.234 102.4-281.242 124.416-43.008 21.913-66.048 21.862-99.737 5.888-33.69-16.026-245.504-102.042-283.904-120.32-38.4-18.227-39.117-30.874-1.485-45.568 37.632-14.746 248.986-97.639 293.683-113.715 44.647-16.128 60.109-16.59 98.048-2.663 37.94 13.875 236.851 92.98 274.227 106.701 37.376 13.722 39.066 25.14.41 45.107z"/><path fill="#fff" d="m523.264 305.63 47.616-15.667-12.902 30.873 48.486 18.176L544 345.515l-14.08 33.792-22.63-37.684-72.295-6.502 54.016-19.456-16.281-29.9 50.483 19.865zm2.97 196.966L409.395 454.06l167.424-25.703zM364.288 357.751c49.306 0 89.446 15.565 89.446 34.56s-40.243 34.56-89.446 34.56c-49.254 0-89.549-15.564-89.549-34.56 0-18.995 40.141-34.56 89.549-34.56"/><path fill="#741113" d="m680.602 348.177 99.02 39.117-98.918 39.168-.102-78.336z"/><path fill="#ac2724" d="m680.602 348.177.102 78.285-10.752 4.147-99.02-39.117z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/redshift.svg b/apps/desktop/public/icons/database/redshift.svg
new file mode 100644
index 0000000..83b1036
--- /dev/null
+++ b/apps/desktop/public/icons/database/redshift.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#205b98" d="m518.963 719.411 262.042 63.437V290.816l-262.042 63.488V719.36z"/><path fill="#5294cf" d="m780.954 290.867 50.33 25.19v441.754l-50.33 25.14V290.917zM518.912 719.411l-261.99 63.437V290.816l261.99 63.488V719.36z"/><path fill="#205b98" d="m256.922 290.867-50.33 25.19v441.754l50.33 25.14V290.917z"/><path fill="#5294cf" d="m585.984 881.766 99.533-49.715V243.15l-99.533-49.715-31.232 327.321z"/><path fill="#205b98" d="m451.84 881.766-99.482-49.715V243.15l99.482-49.715 31.283 326.195-31.232 362.137z"/><path fill="#2d72b8" d="M585.984 193.434H451.84v688.332h134.144z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/rqlite.png b/apps/desktop/public/icons/database/rqlite.png
new file mode 100644
index 0000000..a85d121
Binary files /dev/null and b/apps/desktop/public/icons/database/rqlite.png differ
diff --git a/apps/desktop/public/icons/database/saphana.webp b/apps/desktop/public/icons/database/saphana.webp
new file mode 100644
index 0000000..ca36c34
Binary files /dev/null and b/apps/desktop/public/icons/database/saphana.webp differ
diff --git a/apps/desktop/public/icons/database/selectdb.svg b/apps/desktop/public/icons/database/selectdb.svg
new file mode 100644
index 0000000..f19f626
--- /dev/null
+++ b/apps/desktop/public/icons/database/selectdb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 400 400"><path fill="#1a6fef" d="M168 22c-3.6 1-7.8 2.3-9.5 2.9-1.6.5-6.3 1.7-10.4 2.6s-9 2.7-11 4.1c-1.9 1.3-4.6 2.4-5.8 2.4s-2.5.4-2.8 1c-.3.5-1.5 1-2.5 1-1.1 0-3.6 1.1-5.6 2.5s-4.2 2.5-4.9 2.5-1.8.7-2.5 1.4c-.6.8-2.7 2-4.6 2.6-1.9.7-5.2 2.7-7.2 4.6s-4.5 3.7-5.5 4-2.9 1.6-4.2 3c-1.3 1.3-2.9 2.4-3.6 2.4-.6 0-2 1.1-3.1 2.5S82.2 64 81.4 64s-1.4.6-1.4 1.2c0 .7-4.1 5.3-9 10.2-5 4.9-9 9.2-9 9.6 0 .3-1.3 2.2-3 4-1.6 1.8-3 3.9-3 4.6 0 .6-1.2 1.9-2.6 2.9-1.4.9-3.5 3.6-4.5 6-1.1 2.4-2.4 4.7-2.8 5-1.2.7-6.1 9.4-6.1 10.7 0 .5-1.6 4.2-3.6 8.1-3.9 7.9-6.4 14.4-6.4 16.7 0 .8-.6 2.6-1.3 4-1.9 3.6-4.3 12.3-5.9 21-1.7 10-1.8 54.6 0 65 .7 4.1 2.4 10.9 3.8 15s3.2 10.2 4.1 13.5 2.2 6.7 2.9 7.6c.8.8 1.4 2.2 1.4 2.9s.6 2.1 1.4 2.9c.7.9 2.6 4.8 4.1 8.8s3.8 8.2 5.1 9.4c1.3 1.3 2.4 3 2.4 3.9s1.8 3.6 4 6 4 4.8 4 5.3c0 1.4 4.6 6.9 12.8 15.3 3.9 4.2 7.2 7.9 7.2 8.3s3 3 6.7 5.7 8.1 6.1 9.7 7.6c1.7 1.6 3.5 2.8 4.1 2.8.7 0 2.2 1.2 3.6 2.6 1.3 1.5 4.3 3.5 6.6 4.6 2.3 1 4.5 2.3 4.8 2.8.3.4 1.9 1.1 3.6 1.5 1.6.4 3.8 1.5 4.7 2.5s3.3 2.1 5.2 2.5c2.9.5 4.3.1 8.3-2.5 2.6-1.8 4.7-3.6 4.7-4.2 0-.5 2-1.8 4.4-2.9 2.5-1.1 4.8-2.8 5.1-3.9.3-1 1.6-2.2 2.8-2.6 1.2-.3 4-2.3 6.2-4.4 2.2-2 6-5.1 8.5-6.7 2.5-1.7 6-4.5 7.7-6.2 1.8-1.7 3.8-3.1 4.4-3.1.7 0 2.7-1.8 4.6-4s3.9-4 4.5-4 3.5-2.3 6.5-5c3-2.8 5.8-5 6.2-5s1.4-1.2 2.1-2.6c.8-1.4 2.7-3.2 4.2-4 4.3-2.3 30-27 42.9-41.4 11.8-13.2 13.9-15.7 13.9-16.9 0-.6 1.7-3 3.8-5.4 2.1-2.3 4.5-5.8 5.2-7.7.8-1.9 2.5-5.3 3.9-7.5s3-7.1 3.7-11c1-6 1-7.7-.4-12-2.1-6.1-7.5-9.9-13.2-9.1-9.4 1.3-12.5 2.2-18 5.1-10.9 5.9-19.2 10.9-20.3 12.4-.6.9-2.7 2.3-4.5 3-1.8.8-4.2 2.7-5.3 4.2-1.1 1.6-2.8 2.9-3.8 2.9-.9 0-2.7.9-3.9 2s-2.7 2-3.5 2c-.7 0-2.4 1.2-3.8 2.6-1.3 1.4-4 3.4-5.9 4.4s-4.6 3-5.9 4.4c-1.4 1.4-2.9 2.6-3.4 2.6-1.9 0-12 5.4-14.5 7.7-1.4 1.3-3.1 2.3-3.8 2.3-1.2 0-10.7 4.3-15.4 6.9-3.5 2-11.8 3.1-22.6 3.1-11.6 0-18.7-1.2-21.2-3.7-.7-.7-1.8-1.3-2.3-1.3-.6 0-2-1.1-3.3-2.5s-2.8-2.5-3.3-2.5c-1 0-11.3-12.3-11.3-13.5 0-.5-.6-1.6-1.3-2.4-2.4-2.9-3.7-9.7-3.7-19.2.1-11.8 2.2-20.8 6.9-28.9.5-.8 2.7-5.3 5-10 5.2-10.6 7.3-14.2 12.2-20.6 2.1-2.8 3.9-5.8 3.9-6.7s.9-2.1 2.1-2.7c1.1-.6 3.2-3 4.7-5.4 3-4.7 9-12 14-17.1 1.7-1.8 3.2-3.6 3.2-3.9 0-.8 2.7-3.9 7.8-8.8 2.3-2.3 4.2-4.7 4.2-5.3 0-.7 2.1-3 4.8-5.1 2.6-2.1 5.1-4.5 5.6-5.4.6-.8 2.5-2.8 4.3-4.4s3.3-3.6 3.3-4.3c0-.8.8-1.7 1.8-2 .9-.4 2.9-1.5 4.4-2.6 2.1-1.6 3.6-1.8 7-1.4 9.5 1.4 19.9 4 26.8 6.6 6.5 2.5 16.3 5.1 19.2 5.1 2.1 0 8.8 3.7 8.8 4.8 0 .4-1.9 1.7-4.3 3s-5.7 3.5-7.4 5c-4.3 3.9-12 10.2-18 14.7-2.9 2.1-5.3 4.3-5.3 4.7s-1.3 1.4-2.8 2.2c-1.6.8-4.5 3-6.4 4.8s-5.9 5.3-8.7 7.8c-5.9 5-33.4 32.5-39.6 39.4-2.2 2.5-4.5 5.6-5 7-.6 1.4-2 3.5-3.2 4.8-2.4 2.6-3.8 5.8-5.9 13.6-1.8 6.9-1.8 7.9.9 13 1.7 3.4 3.1 4.7 6.2 5.8 4.8 1.7 12.9 1.8 19.3.3 5.7-1.3 5.9-1.4 9.7-3.9 3.4-2.3 3.5-2.3 9.6-4.5 2.5-.9 5.7-2.6 7-3.9 1.3-1.2 4-2.8 5.9-3.6s4.6-2.1 6-3.1c8.2-5.5 12.5-7.9 14.1-7.9.9 0 1.9-.6 2.2-1.3.2-.6 4.4-3.4 9.3-6s9.6-5.2 10.4-5.6c3.1-1.9 12-5.1 13.9-5.1 1.1 0 2.3-.5 2.7-1.1.9-1.6 7.1-4.1 12.9-5.2 6.9-1.4 29.2-1.3 33.8 0 2.2.6 4.9 2.1 6.2 3.3 1.2 1.2 4 3.1 6.2 4.3 4 2.2 12.3 10.6 12.3 12.4 0 .6.8 2.1 1.9 3.4 1 1.3 2.2 3.9 2.6 5.7s1.3 4.5 2.1 6c1.7 3.3 1.9 24.9.3 30.2-.6 1.9-1.7 6.3-2.4 9.7-.8 3.5-2.1 7.7-2.9 9.5s-2 5.1-2.7 7.3c-1.2 3.8-4 10.2-5.9 13.5-.4.8-1.6 3.3-2.6 5.5-.9 2.1-3.1 6.2-4.9 9-1.8 2.7-3.5 6.2-3.9 7.7-.3 1.5-1.9 4.2-3.5 6s-4 5.8-5.4 9c-1.4 3.1-3.5 6.2-4.6 7s-2.5 2.7-3.2 4.3c-1.4 3.3-13 19.6-16.6 23.4-1.3 1.3-2.3 3-2.3 3.7s-2.2 3.6-5 6.6c-2.7 2.9-5 5.7-5 6.1 0 .5-1.5 2.3-3.2 4.1-7.3 7.3-8.1 8.5-6.4 9.2.9.4 2.5-.1 3.5-1s3-1.6 4.5-1.6c4.2 0 11.4-2.1 16.4-4.7 2.6-1.4 6.7-3.1 9.2-4 2.5-.8 5.2-2.1 6-2.8.8-.6 4.6-2.7 8.4-4.5s8.3-4.5 10-6 5.2-3.9 7.9-5.5c2.6-1.5 5.2-3.5 5.7-4.5s2.9-2.9 5.3-4.3c2.3-1.4 4.9-3.7 5.6-5.1.8-1.3 2.6-3 4.2-3.6 1.6-.7 3.1-2.1 3.4-3.1.4-1.1 2.6-3.8 5.1-6.1 2.4-2.3 4.4-4.6 4.4-5.2s1.6-2.9 3.5-5.1c2-2.2 5-6.2 6.8-9 1.7-2.7 3.7-5.5 4.3-6 .6-.6 2.3-4.1 3.8-7.9s3.7-8.3 5-10 2.9-5.4 3.6-8.1c.7-2.8 2.6-7.6 4.2-10.7 1.5-3.2 2.8-6.6 2.8-7.8 0-1.1.4-3.9 1-6.2 3.5-15.9 5.4-41.6 4.1-55.7-2.6-26.9-5.7-43-9.2-47.6-1.1-1.5-3.9-9.8-3.9-11.7 0-.9-.6-2.3-1.3-3-2.2-2.2-8.7-15.5-8.7-17.7 0-.6-.6-1.4-1.4-1.8-.7-.4-2.5-2.7-4-5.1-1.5-2.3-3.4-5.1-4.4-6.2-2.8-3.1-3.8-4.4-6.6-8.8-1.4-2.3-3.7-4.9-5.1-5.8-1.5-.9-3.3-3-4-4.5-.8-1.5-2.8-3.6-4.4-4.5-1.6-1-3.5-2.7-4.1-3.8-.7-1.2-3.9-4.1-7.2-6.6-3.2-2.5-7.2-5.5-8.8-6.8-1.5-1.2-3.3-2.2-3.9-2.2-.7 0-2.7-1.6-4.7-3.5-1.9-1.9-4.7-3.8-6.2-4.1-1.5-.4-3.8-1.5-5.1-2.6-1.3-1-3-1.8-3.7-1.8s-1.9-.7-2.8-1.5c-.8-.9-4.1-2.4-7.3-3.4s-7.6-2.9-9.8-4.1c-3.7-2.2-6.4-3-14-4.5-3-.6-8.2-2-18.4-4.9-8.3-2.5-55.1-2.1-64.1.4"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/snowflake.svg b/apps/desktop/public/icons/database/snowflake.svg
new file mode 100644
index 0000000..e986bee
--- /dev/null
+++ b/apps/desktop/public/icons/database/snowflake.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#29b5e8" d="M395.418 524.8a43.264 43.264 0 0 0-19.968-50.688L226.61 388.608a43.88 43.88 0 0 0-59.853 16.026 43.315 43.315 0 0 0 16.026 59.545l83.2 47.821-83.149 47.718a43.52 43.52 0 0 0-16.025 59.648 43.88 43.88 0 0 0 59.852 15.872l148.736-85.504a43.37 43.37 0 0 0 19.968-24.934zm40.345 80.128a43.26 43.26 0 0 0-25.446 5.683l-148.839 85.453a43.622 43.622 0 1 0 43.776 75.571l83.456-47.872v95.693c0 24.064 19.559 43.622 43.828 43.622a43.725 43.725 0 0 0 43.776-43.622v-171.06a43.62 43.62 0 0 0-40.55-43.468m152.474-185.856a43.78 43.78 0 0 0 25.344-5.734l148.838-85.504a43.57 43.57 0 0 0 16.026-59.648 43.88 43.88 0 0 0-59.75-15.924l-83.354 47.924v-95.744a43.725 43.725 0 0 0-43.879-43.52 43.674 43.674 0 0 0-43.776 43.52v171.11c0 22.938 17.818 41.83 40.55 43.52m-326.759-91.29 148.839 85.504c8.038 4.608 16.896 6.4 25.446 5.684a43.776 43.776 0 0 0 40.55-43.52V204.442a43.725 43.725 0 0 0-43.775-43.572 43.725 43.725 0 0 0-43.879 43.52v95.744l-83.405-47.923a43.88 43.88 0 0 0-59.801 15.923 43.57 43.57 0 0 0 16.025 59.648M541.235 511.59a13 13 0 0 0-3.277-7.782l-17.92-17.766a12.7 12.7 0 0 0-7.73-3.175h-.718a12.54 12.54 0 0 0-7.68 3.175l-17.92 17.766a12.7 12.7 0 0 0-3.174 7.782v.717c0 2.458 1.382 5.888 3.174 7.68l17.92 17.767a12.54 12.54 0 0 0 7.68 3.225h.717a12.65 12.65 0 0 0 7.731-3.225l17.92-17.767a12.65 12.65 0 0 0 3.277-7.68zm49.46 17.101-61.901 61.491a12.34 12.34 0 0 1-7.732 3.277h-18.278a12.6 12.6 0 0 1-7.731-3.277l-61.85-61.49a12.4 12.4 0 0 1-3.225-7.68v-18.126c0-2.56 1.433-6.041 3.225-7.782l61.901-61.44a12.5 12.5 0 0 1 7.731-3.226h18.227c2.56 0 5.99 1.383 7.783 3.226l61.85 61.491a12.6 12.6 0 0 1 3.174 7.783v18.124a12.44 12.44 0 0 1-3.175 7.68zm171.724 167.322L613.581 610.56a43.16 43.16 0 0 0-25.344-5.632 43.62 43.62 0 0 0-40.55 43.418v171.008c0 24.115 19.558 43.673 43.775 43.673a43.725 43.725 0 0 0 43.879-43.622V723.66l83.353 47.923a43.674 43.674 0 1 0 43.776-75.571zm78.695-231.936L758.016 512l83.098 47.718a43.52 43.52 0 0 1 16.025 59.648 43.93 43.93 0 0 1-59.801 15.872l-148.89-85.504a43.26 43.26 0 0 1-21.811-39.116 43.78 43.78 0 0 1 21.862-36.455l148.839-85.504a43.93 43.93 0 0 1 59.801 15.975 43.366 43.366 0 0 1-16.025 59.545z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/spark-logo.png b/apps/desktop/public/icons/database/spark-logo.png
new file mode 100644
index 0000000..16702a9
Binary files /dev/null and b/apps/desktop/public/icons/database/spark-logo.png differ
diff --git a/apps/desktop/public/icons/database/sqlite.svg b/apps/desktop/public/icons/database/sqlite.svg
new file mode 100644
index 0000000..ebf14c3
--- /dev/null
+++ b/apps/desktop/public/icons/database/sqlite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#0f80cc" d="M691.61 187.597H211.917a58.52 58.52 0 0 0-58.317 58.368v528.793c0 32.308 26.522 58.368 58.368 58.368h315.75c-3.379-156.672 50.637-461.824 163.892-645.53"/><path fill="#003b57" d="M803.482 170.189c-32.768-29.389-72.807-17.306-111.872 17.408-5.786 5.273-11.52 11.059-17.306 16.896-67.072 71.321-129.74 203.417-148.992 304.128 7.68 15.462 13.466 34.713 17.306 49.664 1.024 3.891 1.945 7.27 2.457 10.598 1.895 7.27 2.407 12.083 2.407 12.083s-.512-2.406-2.868-9.625c-.512-1.485-1.024-2.867-1.484-4.813-.512-.973-.512-1.485-.973-2.458-4.301-10.086-16.384-31.744-21.658-40.96-4.352 13.466-8.704 26.01-12.083 37.581 15.462 27.955 24.576 76.698 24.576 76.698l-4.813-14.029c-3.379-9.626-20.736-39.526-24.576-46.746-6.758 25.6-9.625 42.906-7.168 47.258 4.762 8.192 9.575 22.17 13.415 37.58 9.216 35.226 15.462 77.671 15.462 77.671s0 2.867.512 7.168a662 662 0 0 0 1.894 87.757c2.868 36.66 8.653 67.994 15.872 84.838l4.864-2.867c-10.598-33.28-14.95-76.185-13.004-126.31 2.867-76.186 20.224-168.704 52.992-264.704 54.988-145.101 131.174-261.274 200.55-316.672-63.59 57.344-149.402 242.944-175.002 311.91-28.928 77.107-49.152 149.402-61.696 218.368 21.197-65.075 89.703-92.57 89.703-92.57s33.69-41.471 72.755-100.761c-23.603 5.325-62.208 14.438-75.162 20.275-19.302 8.192-24.166 10.547-24.166 10.547s61.747-37.58 115.251-54.937c73.728-115.712 153.344-279.143 72.807-350.976"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/sqlserver.svg b/apps/desktop/public/icons/database/sqlserver.svg
new file mode 100644
index 0000000..360df61
--- /dev/null
+++ b/apps/desktop/public/icons/database/sqlserver.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#8a8a8a" d="M703.5 221.2c58 19.5 104.2 40 138.6 61.6 34.9 21 63.6 42.1 86.7 62.1 23.1 19.5 38.5 36.4 46.2 49.8 7.7 13.3 9.2 20.5 3.6 21-118 18-245.3 49.8-382.4 93.9 2.1 5.6 4.6 13.3 7.7 24.6s6.2 34.4 9.8 69.8c3.1 35.4 3.1 72.4-.5 109.8-4.1 37.5-14.9 84.7-32.8 140.6-18.5 55.9-44.1 111.4-76.5 166.8-3.1 4.6-32.8 3.1-89.8-4.1-128.8-16.9-227.4-46.2-297.2-86.7C9 865.3 17.8 785.8 143 691.4c61.6-47.7 109.3-97 144.2-148.8s54.9-101.6 60.1-148.8c5.1-47.2-2.1-91.4-21.6-132.9-19.5-42.1-50.8-77-92.9-105.7-20.5-13.3-27.7-28.2-21-44.1C226.1 74.9 298.5 38 426.8 0c-1 0 3.6 14.4 12.8 43.1 9.2 28.2 21 58 35.9 87.8s28.7 45.2 42.6 46.7c65.8 8.7 128.4 23.6 185.4 43.6M73.7 810.9c-.5.5-.5 5.6.5 14.9 1 9.2 6.2 22.1 15.4 38.5 9.8 15.9 24.1 30.8 43.1 44.7l21-28.2c13.3-18 27.7-37.5 42.1-59 14.4-21.6 23.1-34.9 25.1-41.1.5 0-8.7 2.6-28.2 7.7s-41.1 9.8-65.2 14.9c-24 5.6-42 7.6-53.8 7.6m71.9-112.4c-16.4 13.3-28.7 26.2-38 36.4-8.7 10.9-15.4 22.1-21.6 33.4-5.6 11.8-9.2 19.5-9.8 23.6s-1.5 7.2-2.6 9.2c13.9 0 65.2-13.3 152.9-41.1-17.5-40-25.7-72.4-24.1-97-20.9 9.9-39.9 22.2-56.8 35.5m2 223.3 183.2-67.2C299 837.1 269.3 815 241 787.3l-99 126.8zm11.3 2.1c12.8 11.8 29.3 22.1 50.8 30.8 21.6 8.7 36.4 13.3 46.2 15.4 9.8 1.5 16.4 3.1 22.1 4.6l67.2-101.1zm73.9-274.1c1.5 46.2 7.2 75.4 16.9 87.8 22.6-22.6 45.7-66.7 67.7-130.9-9.1 3.6-37.4 17.9-84.6 43.1m25.7-555.4c-6.7 4.6-12.8 9.8-19 15.9s-8.2 9.8-6.2 11.8c4.1 4.6 32.8 12.8 86.7 25.1l-51.3-60.1zm-18 524.6 141.1-123.2c-33.9 14.9-65.7 35.4-93.9 62.1zm14.4 0c14.4-9.8 71.3-37 169.9-82.1.5-10.8-1-20-4.6-28.7-4.1-8.2-6.7-13.3-9.2-15.9-2.6-2.1-4.6-3.6-6.7-4.6-5.2 9.6-55 53.3-149.4 131.3m75.9-384.4-19-62.1-50.8-17c13.9 9.8 37.5 35.9 69.8 79.1m-64.1 533.2c11.8 15.9 26.7 30.8 44.1 44.1 17.5 13.3 29.8 21.6 36.4 25.1 7.2 3.6 12.8 6.2 16.4 8.2 26.2-38.5 44.7-83.1 54.9-132.9-9.6 6.3-60.5 25.2-151.8 55.5m158.1-82.6c-17.5-15.9-31.8-31.8-43.6-48.2-11.8-15.9-18.5-26.7-21-31.8s-4.1-9.2-4.6-12.8c.5 2.1 0 5.6-1.5 9.8-1.5 4.6-4.1 9.8-6.7 15.9-2.6 6.2-6.2 12.8-10.8 21s-8.7 15.4-12.8 23.1c-4.1 7.2-8.7 15.4-12.8 24.1-4.6 8.2-8.7 15.9-11.8 22.1l-11.8 20c-3.6 6.2-5.6 9.8-7.2 11.8-1.5 2.1-2.6 3.6-3.1 5.1 69.1-21.1 118.4-41.1 147.7-60.1m-3.6-577.9c-12.8-2.6-26.7-5.1-40-7.7s-28.7-6.2-46.7-9.8c-17.5-3.6-29.8-6.2-35.9-7.7-6.2-1.5-11.8-2.6-15.9-4.1 1.5 4.6 24.6 30.8 69.8 77h19l73.9-46.2c-3.2 1-11.4.5-24.2-1.5M287.7 983.9c35.9-2.1 116.5-27.2 241.7-74.9-53.4-1-106.2-12.8-158.1-34.9zM400.6 89.3c24.6 3.6 39 5.1 43.1 5.1 1-2.1 2.1-4.1 2.1-6.7s-1.5-7.7-3.6-14.9c-2.6-7.7-4.6-14.4-6.2-20-2.1-5.6-4.1-12.8-7.2-20s-5.1-12.8-6.2-14.9-1.5-4.1-1.5-5.6c-1 0-10.8 4.6-29.8 12.8-19.5 8.2-39.5 17.5-60.1 27.2-20.5 9.8-31.8 14.9-33.9 16.9-2.1 2.1 8.7 5.1 31.8 9.2 22.8 3.7 47.4 7.8 71.5 10.9m-68.7 100.1c4.6 10.8 9.8 23.6 13.9 37 4.6 12.8 7.2 22.1 7.2 26.2l84.7-63.1-112.9-16.9zm-7.2 320.8c18.5-11.8 39.5-28.2 62.1-48.2-6.2-8.2-15.4-13.9-28.7-18-1.1 7.1-11.9 29.2-33.4 66.2m208.9 411.6c-63.1 26.7-132.4 47.2-208.9 62.1 26.2 14.4 82.6 25.7 168.9 32.8 8.2-9.2 21-41 40-94.9M363.7 291.5c4.6 2.1 7.7 35.4 8.2 100.6 18.5-16.9 43.6-40.5 73.9-70.8-16.9-10.8-44.1-21-82.1-29.8m102.1 3.1c1-23.1.5-42.6-2.6-59.5s-5.6-27.7-7.7-31.8-4.1-7.2-5.1-8.2l-79 68.3c14.9 2.5 46.2 13.2 94.4 31.2m-93.9 116.5c8.7 6.2 22.6 16.9 41.1 32.8 20.5-25.1 34.9-59.5 44.1-102.7-6.7 4.7-34.9 27.8-85.2 69.9m28.2 223.3c11.8 14.4 20 23.6 25.1 27.2s9.2 6.7 12.8 8.7c7.2-18.5 11.8-38 14.4-58.5 2.1-20 2.6-33.4 1.5-40.5l-2.1-18-80.1 32.8c7.4 18 17.1 33.9 28.4 48.3m170.4 133.4c-4.1 8.7-67.2 37.5-188.9 86.7 13.9 15.9 64.7 31.8 151.9 48.2 15-18.9 27.3-63.5 37-134.9m-178.1 62.1c8.7.5 28.7-5.6 62.1-19 32.8-13.3 57-24.1 73.9-31.8 16.4-8.2 30.8-14.4 42.1-20-21.6-4.6-61.1-22.6-119.1-52.9zm65.2-707.2-61.1 37 82.1 12.8zm95 270.5c-50.8 29.8-93.4 52.4-127.8 68.8 8.2 6.2 14.9 28.7 21 68.8 6.7-9.8 42.1-56 106.8-137.6m0-24.2-73.9-39.5c.5 5.1-2.1 16.4-7.2 33.4-5.6 17.5-9.8 30.8-12.8 39.5-3.1 9.2-5.6 16.4-7.7 21.6zm-85.7-173.5 7.2 11.8c4.6 8.7 7.7 20 9.8 34.4 1.5 13.9 0 30.8-4.6 49.8l123.2-67.7zm0 474.3L492 657c16.9-8.2 35.4-16.9 54.4-27.7s30.8-18 35.4-22.6l-104.2-62.1c0 65.7-4.1 107.2-10.7 125.2m114.9 59c3.1-10.8 6.2-26.2 8.7-46.7 2.1-20.5 2.6-40 .5-58.5l-26.2 14.9c-16.9 9.8-35.4 20.5-55.9 30.8-21 10.8-34.9 16.9-42.1 19l14.9 11.8c10.8 7.7 25.1 15.4 43.6 25.1 18 9.8 34.9 15.9 50.8 20zm86.3-272c-14.4-22.6-43.6-44.1-86.7-65.2-4.1 9.8-40.5 52.4-108.8 128.8 17.9-6.6 83.1-28.2 195.5-63.6m-155.6 94.4c11.8 7.7 26.2 15.4 42.1 24.6s27.7 14.9 34.9 17.5l1-13.9q0-13.05-1.5-33.9c-1-13.9-2.6-25.7-4.6-34.9l-90.8 30.8zm114-323.8-123.7 80.1c13.9 4.1 40 16.9 79 40 29.8-50.8 44.7-90.9 44.7-120.1m15.4 0c.5 5.1-2.1 19-8.2 41.1-6.2 22.1-10.8 38.5-14.4 50.8-4.1 11.8-7.2 21-9.8 28.7 39-20 101.1-42.1 185.8-66.2-17.9-12.3-69.2-30.3-153.4-54.4m46.2 222.7c22.1-21 43.6-45.7 64.2-73.4 21-27.7 33.9-46.7 40-56.5 6.2-10.8 10.8-19 13.9-25.7-10.8.5-77 23.6-196.6 68.8 26.1 15 52.3 44.2 78.5 86.8m274-41c-4.6-10.8-19.5-26.2-44.7-47.2-25.1-20.5-44.1-35.4-57.5-44.7-12.8-9.8-24.6-16.9-33.9-23.1-10.8 30.8-46.7 81.1-106.2 149.4 30.4-11.3 111.5-23.1 242.3-34.4"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/starrocks.svg b/apps/desktop/public/icons/database/starrocks.svg
new file mode 100644
index 0000000..25d0351
--- /dev/null
+++ b/apps/desktop/public/icons/database/starrocks.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#01808f" d="M224 303.667c-.922 19.456 7.936 30.003 20.275 39.731l238.387 195.994c22.016 18.534 23.808 30.874 8.807 54.733L374.938 771.533c-15.002 22.067-28.263 25.6-52.07 12.39l-74.19-42.393c-28.21-15.872-42.342-40.602-42.342-73.268V354.918c0-17.715 4.403-33.587 17.664-51.25m671.795 418.458c5.325-20.327-4.403-30.925-16.742-40.653-79.463-65.331-158.055-129.74-236.595-195.072-25.6-21.197-27.392-31.744-9.728-59.136 37.939-58.266 76.8-116.531 114.739-174.797 15.001-22.989 29.184-25.6 52.992-12.39 24.73 14.131 49.408 28.262 73.267 42.393 28.262 15.872 41.472 39.732 41.472 72.397v314.266c.922 18.534-4.403 36.198-19.405 52.94zM712.192 572.006c5.274 3.584 152.678 124.468 154.47 126.26 21.197 19.456 19.456 36.198-5.324 51.2-63.488 36.198-235.674 134.144-257.741 147.456-28.263 16.742-56.525 16.742-84.736 0-40.653-23.86-81.255-46.797-121.856-70.656-19.456-11.47-19.456-23.86 0-34.407 96.256-54.784 191.59-110.387 287.795-165.12 22.067-12.339 37.069-25.6 27.392-54.733"/><path fill="#febd02" d="M410.266 451.994a15286 15286 0 0 1-154.522-126.26c-21.146-19.456-19.405-36.198 5.325-51.2 63.539-36.198 235.725-134.144 257.792-147.456 28.211-16.742 56.473-16.742 84.736 0 40.601 23.86 81.203 46.797 121.856 70.656 19.405 11.47 19.405 23.808 0 34.407-96.256 54.784-191.59 110.387-287.847 165.12-22.016 12.339-37.068 25.6-27.34 54.733"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/sundb.svg b/apps/desktop/public/icons/database/sundb.svg
new file mode 100644
index 0000000..8626ff8
--- /dev/null
+++ b/apps/desktop/public/icons/database/sundb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#a9303c" d="m348.826 419.84 4.864 1.638a79 79 0 0 1-.615-2.048l-1.894-4.864c-1.28-3.43-2.56-6.81-3.584-10.24a32.1 32.1 0 0 1-1.178-11.724 98.3 98.3 0 0 1 3.789-16.59 20 20 0 0 1 4.352-8.55c5.325-5.068 10.957-9.83 16.896-14.182 7.885-5.94 16.077-11.571 24.269-17.152a254 254 0 0 1 36.25-20.224 410 410 0 0 1 24.934-10.291 192.8 192.8 0 0 1 68.505-12.647 143.2 143.2 0 0 1 64.103 12.903c11.059 5.12 20.992 11.878 30.208 19.763 8.704 7.475 15.616 16.64 21.913 26.317 7.168 10.957 12.032 22.937 16.026 35.328 1.28 4.045 2.048 8.192 2.867 12.441l.973 4.762 1.946 9.83.87 4.455c.358 1.945 1.382 2.765 3.533 2.765h50.637c1.894 0 2.764-.922 3.072-2.407a16.2 16.2 0 0 0 .307-6.502c-.512-5.223-.922-10.496-1.792-15.667a316 316 0 0 0-4.096-20.839 159.6 159.6 0 0 0-18.432-46.49 138.4 138.4 0 0 0-57.754-53.81 130.2 130.2 0 0 0-36.454-12.442 95.3 95.3 0 0 0-18.535-2.97l-4.608-.102c-12.339-.359-24.78-.717-37.222 1.024a247 247 0 0 0-40.038 8.704c-28.16 8.704-54.375 21.555-79.002 37.683a357 357 0 0 0-41.472 30.976c-6.349 5.632-12.544 11.418-18.74 17.254l-5.324 5.018a47 47 0 0 0-2.867 3.072c-1.741 1.894-3.482 3.84-5.632 5.069a47.1 47.1 0 0 1-26.01 6.553 59.5 59.5 0 0 1-18.944-4.864c-.614-.256-1.331-.204-2.048-.153l-1.024.051c.103 1.024.205 2.048.461 3.072.512 1.792 1.126 3.584 1.74 5.376 1.28 3.635 2.51 7.27 3.226 10.957a40.65 40.65 0 0 1-2.252 20.736l-3.584 10.393 3.225-1.075 4.045-1.433c5.734-2.1 11.725-3.584 17.818-4.301.768-.103 1.587 0 2.406.205a220 220 0 0 1 8.294 1.484c3.84 1.178 7.68 2.458 11.623 3.79zm30.566 380.109 8.5.717 9.42-.82A231.8 231.8 0 0 0 456.09 789.3c16.588-4.915 32.512-11.571 48.128-19.2a360.5 360.5 0 0 0 58.726-36.045 471 471 0 0 0 60.262-54.17 224 224 0 0 0 15.36-17.92c7.68-9.88 15.156-19.865 22.682-29.9l.666-.922c1.894-2.56 1.587-4.25-1.024-5.888a7.17 7.17 0 0 0-3.584-.87H640c-10.752 0-21.606 0-32.41-.205-5.273-.102-8.806 1.178-12.288 5.632-5.376 6.963-11.264 13.466-17.203 19.968l-6.349 7.066c-10.752 12.134-23.04 22.733-35.686 32.768a317.6 317.6 0 0 1-54.272 35.02 247 247 0 0 1-67.02 23.809l-.769.153a230 230 0 0 1-26.829 3.891 160.3 160.3 0 0 1-36.352-1.382 140.1 140.1 0 0 1-47.616-16.077 127.7 127.7 0 0 1-33.382-27.75 132 132 0 0 1-23.962-42.752c-1.74-4.864-2.867-9.933-3.993-15.002l-.256-1.024c-.717-3.277-1.28-6.605-1.895-9.881a340 340 0 0 0-1.228-6.708 19.5 19.5 0 0 0-1.536-5.12c-1.28-2.56-2.816-2.457-5.12-.716-1.792 1.33-1.639 2.918-1.434 4.608l.051.921c.205 2.867.307 5.786.461 8.653.307 6.758.614 13.568 1.382 20.275 1.895 15.667 5.172 31.079 11.264 45.722 2.919 7.014 5.837 14.08 9.472 20.736 5.018 9.165 11.316 17.408 18.228 25.395a128 128 0 0 0 27.904 24.013c18.432 11.776 38.553 19.149 60.313 21.709 6.656.768 13.363 1.28 19.917 1.843"/><path fill="#4550ff" d="M852.94 613.376h-49.254c-4.096 0-5.939-2.15-4.812-6.042 1.536-5.222 3.276-10.393 4.864-15.616l3.737-12.492 5.94-18.74c1.791-5.888 3.43-11.776 5.273-17.612 2.253-7.476 4.608-14.9 6.963-22.375l5.069-16.589 7.475-23.91c1.69-5.53 3.175-11.11 4.864-16.691l7.68-24.115c.717-2.304 2.1-3.072 4.352-3.072h107.52c6.963 0 13.722 1.075 19.968 4.044 8.192 3.84 13.927 9.933 15.872 19.15.461 2.047 1.843 4.095 1.741 6.143-.512 7.68-2.56 15.258-5.786 22.221a63.1 63.1 0 0 1-17.1 20.89c-1.946 1.69-4.455 2.816-6.708 4.198l-.768.256c-2.252 1.28-4.761 2.867-4.71 5.632 0 2.714 2.202 4.3 4.608 5.837a25.7 25.7 0 0 1 12.032 14.694 29.7 29.7 0 0 1 .973 14.439c-1.383 6.604-3.38 13.312-6.349 19.302-8.192 16.691-21.248 28.416-38.81 34.611-5.734 2.048-11.98 2.765-18.022 3.687-23.091 3.532-46.387 1.536-66.611 2.15m40.244-74.138v-.41c-4.352 0-8.704.257-13.107-.05-3.533-.256-5.376 1.536-6.503 4.812-2.56 7.732-4.864 15.463-7.321 23.194-1.946 6.349 0 9.062 6.656 9.114 5.683 0 11.469.102 17.152-.052 6.912-.204 13.824 0 20.633-1.843 7.783-2.048 18.484-12.237 17.562-23.757a9.93 9.93 0 0 0-4.403-7.68 22 22 0 0 0-12.442-3.328c-6.041-.204-12.134 0-18.227 0m20.02-68.915v.512H901.12c-4.096 0-6.144 1.536-7.27 5.427-1.383 4.762-2.868 9.472-4.199 14.285-.921 3.43-2.048 6.861-2.355 10.394s1.536 4.915 5.018 4.915c5.58-.051 11.161.154 16.69-.102 5.12-.154 10.24-.564 15.258-1.23 10.138-1.433 16.23-9.42 17.92-18.636 1.485-8.09-1.74-12.902-9.83-13.978-6.349-.87-12.8-1.075-19.149-1.536zM545.996 613.376c-8.704 0-17.306-.102-26.01 0-2.201 0-3.481-.922-4.25-2.918a22527 22527 0 0 0-29.9-79.668c-.615-1.587-1.536-3.43-2.867-4.3-3.021-1.997-6.656-.052-7.783 3.532l-10.342 33.946c-2.304 7.68-4.506 15.36-6.861 23.04a763 763 0 0 1-7.782 23.86 3.84 3.84 0 0 1-2.612 2.15 69 69 0 0 1-8.448.307l-36.044-.103c-1.076 0-2.202-.204-3.328-.256-2.304-.153-3.277-1.382-2.816-3.584a133 133 0 0 1 2.406-9.881c2.304-7.885 4.66-15.719 7.066-23.552 2.816-9.063 5.683-18.074 8.448-27.136l6.656-21.76 5.99-19.2c2.304-7.475 4.454-15.002 6.758-22.477 1.792-5.888 3.892-11.725 5.735-17.613 1.638-5.325 3.072-10.752 4.659-16.077l3.891-12.85c.615-1.946 2.048-2.868 4.096-2.868h48.64c1.536 0 2.663.41 3.328 2.1 2.355 6.348 4.864 12.594 7.27 18.943l13.364 35.226 9.83 26.419a12.8 12.8 0 0 0 1.639 3.226c2.764 3.635 6.656 3.328 8.652-.87 1.024-2.305 1.946-4.711 2.663-7.169 2.253-7.577 4.403-15.206 6.707-22.733a5702 5702 0 0 1 15.718-50.79c1.178-3.789 1.639-4.25 5.632-4.25 16.077-.05 32.256-.102 48.333-.05 2.355 0 3.994 1.535 3.635 3.89a55 55 0 0 1-1.894 7.936l-10.803 35.79c-3.84 12.39-7.783 24.78-11.571 37.17-2.407 7.834-4.608 15.719-6.964 23.552-3.225 10.496-6.553 20.89-9.728 31.335-2.816 9.062-5.478 18.125-8.243 27.187l-2.304 7.68c-.665 2.355-2.509 2.662-4.608 2.662h-25.958v.103zM269.568 435.968h23.194c3.84 0 5.58 2.406 4.403 6.144l-14.336 46.592c-4.403 14.387-8.704 28.774-13.056 43.213-1.895 6.297-3.789 12.595-5.427 18.944-2.56 9.881 3.02 22.118 14.694 23.859 11.315 1.69 22.118.717 31.693-6.144a39.63 39.63 0 0 0 15.257-19.814c3.43-10.24 6.4-20.685 9.626-30.976l8.704-27.034c1.638-5.325 3.072-10.752 4.71-16.18l7.168-23.142c1.23-3.89 2.458-7.782 3.584-11.724.768-2.765 1.844-3.687 4.66-3.687h48.384c3.072 0 4.966 2.304 4.096 5.223-3.38 11.264-6.861 22.374-10.24 33.587-3.584 11.622-6.912 23.296-10.548 34.867-4.505 14.54-8.704 29.184-14.028 43.418a80.4 80.4 0 0 1-14.95 25.241c-3.175 3.584-6.042 7.475-9.524 10.701a92.16 92.16 0 0 1-38.042 22.528c-16.742 4.608-33.792 5.837-51.097 4.506-7.322-.512-14.643-1.024-22.016-1.741a59 59 0 0 1-8.243-1.639 44.44 44.44 0 0 1-18.381-8.038 43.8 43.8 0 0 1-9.011-10.957 36.05 36.05 0 0 1-5.684-18.125c-.204-5.222.154-10.444.41-15.616.512-10.752 3.942-20.89 7.373-31.027 1.945-5.785 3.43-11.776 5.222-17.613 1.843-5.888 3.891-11.776 5.735-17.715 1.69-5.53 3.225-11.11 4.915-16.64 1.894-6.144 3.942-12.288 5.837-18.483 1.638-5.376 3.328-10.752 4.71-16.18 1.331-5.17 2.56-6.246 7.885-6.143h22.374v-.205zm-132.352-3.482c9.37.82 18.432 1.28 27.392 2.56 7.117 1.024 14.029 3.175 20.275 6.964 7.68 4.71 11.93 11.724 13.773 20.428 1.331 6.144 1.792 12.135.358 18.279-.614 2.56-1.382 4.198-4.352 4.352-5.222.205-10.393.819-15.616 1.126a1920 1920 0 0 1-29.747 1.536c-4.813.256-5.478-.46-6.144-5.12l-.512-4.352c-.717-6.246-4.25-10.035-10.137-11.776a31.59 31.59 0 0 0-26.47 2.919c-4.609 2.764-7.886 6.707-7.937 12.646-.051 3.328 1.28 5.888 4.096 7.168 3.943 1.69 8.039 3.072 12.288 4.25 4.352 1.28 8.96 2.048 13.312 3.379 8.192 2.406 16.384 4.761 24.423 7.629 10.29 3.584 19.302 9.318 25.292 18.688 2.663 3.942 4.096 8.55 4.096 13.312v.204c1.024 11.623-2.406 22.119-7.68 32.205-4.812 9.216-11.366 17.357-19.302 24.064-10.24 8.704-22.272 15.155-35.226 18.79a132.8 132.8 0 0 1-47.513 4.353c-6.81-.512-13.773-.512-20.48-1.792-11.52-2.15-22.938-5.12-30.72-15.156a30.05 30.05 0 0 1-6.298-14.643c-.768-6.349-.87-12.8-1.024-19.2 0-2.56.359-5.12 1.075-7.577.308-1.024 1.792-2.304 2.816-2.356 11.11-.87 22.221-1.484 33.28-2.15 4.813-.307 9.626-.768 14.388-1.024 3.276-.205 5.376 1.74 5.478 4.966.102 2.714 0 5.479.102 8.192.205 5.07 4.864 13.005 11.367 14.9 10.342 3.072 20.582 2.867 30.105-2.612 6.656-3.84 11.674-9.37 12.75-17.356.562-4.199-1.434-7.783-4.609-10.65a31.5 31.5 0 0 0-13.056-6.144c-8.294-2.458-16.64-4.506-24.883-7.014a77 77 0 0 1-22.733-10.599c-5.939-4.3-11.52-9.216-13.568-16.537a43.4 43.4 0 0 1-1.433-13.62c.563-10.854 4.812-20.428 11.264-29.03 6.041-8.192 13.414-15.002 22.323-20.122 9.42-5.376 19.353-9.625 30.105-11.161 9.728-1.383 19.559-2.048 29.133-2.919zm513.843 180.532h-40.397c-5.12-.103-6.4-1.946-4.915-7.168 2.202-7.476 4.608-14.95 6.963-22.426l6.298-20.787 7.168-23.552 9.933-32.256 8.857-28.928 8.295-27.443c1.126-3.636 2.355-7.27 3.43-10.957.717-2.355 2.15-3.43 4.66-3.38 5.631.103 11.161 0 16.742 0 24.883 0 49.766-.05 74.65.154 10.086.103 19.814 1.997 28.876 6.861a40.4 40.4 0 0 1 19.61 23.962c3.891 11.776 3.328 23.756 1.536 35.84-2.355 16.281-7.68 31.59-14.183 46.592a107.4 107.4 0 0 1-29.081 39.27 91.65 91.65 0 0 1-31.027 18.125c-13.67 4.505-27.648 6.451-41.882 6.4h-35.533zm61.184-137.524h-9.113c-2.15 0-3.328 1.178-3.943 3.072l-1.894 6.042c-1.639 5.632-3.175 11.162-4.864 16.742-2.304 7.578-4.813 15.053-7.168 22.63-2.97 9.626-5.837 19.252-8.704 28.878a832 832 0 0 0-4.455 15.001c-.614 2.253 1.434 5.325 3.738 5.479 10.547.768 21.043.512 31.386-1.536 10.188-1.946 17.356-8.602 22.886-16.948 4.608-7.014 7.885-14.745 10.496-22.732 3.891-11.879 7.424-23.757 7.117-36.506-.205-9.318-4.301-14.285-12.595-17.152a54.3 54.3 0 0 0-22.887-2.97"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/tdengine.svg b/apps/desktop/public/icons/database/tdengine.svg
new file mode 100644
index 0000000..9d20ae0
--- /dev/null
+++ b/apps/desktop/public/icons/database/tdengine.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#3578eb" d="M512 91.853c30.413 0 54.938 24.217 54.938 54.22S542.362 200.295 512 200.295a54.477 54.477 0 0 1-54.938-54.22A55.09 55.09 0 0 1 512 91.853m-362.854 258.56c30.412 0 54.937 24.166 54.937 54.17 0 30.003-24.525 54.271-54.937 54.271a54.477 54.477 0 0 1-54.887-54.272 55.81 55.81 0 0 1 54.887-54.22zm142.233 422.093c30.362 0 54.887 24.217 54.887 54.22s-24.525 54.221-54.887 54.221a54.477 54.477 0 0 1-54.937-54.22c0-30.004 24.524-54.221 54.937-54.221m441.293 0c30.362 0 54.886 24.217 54.886 54.22s-24.524 54.221-54.886 54.221a54.477 54.477 0 0 1-54.938-54.22c0-30.004 24.525-54.221 54.887-54.221zM592.384 412.314H431.616l-49.05 150.067L512 655.36l129.434-92.006-48.999-151.04zM436.48 399.77l55.91-170.445c-3.942-.973-8.806-1.895-12.748-3.84L422.81 399.77H236.442v12.544h181.401L370.79 554.65 223.693 449.126c-1.946 3.892-4.915 6.759-7.834 10.65l125.491 90.06 25.498 18.382-8.806 24.217-49.05 150.016c3.942 1.024 8.858 1.997 12.8 3.943l55.86-169.472 122.572 88.166-144.128 103.578c2.918 2.918 5.888 6.81 7.834 9.728L512 671.795l148.07 106.496a38 38 0 0 1 7.834-9.728l-145.1-104.55 122.572-88.064 5.888 16.384 50.995 154.01a48.8 48.8 0 0 1 12.749-3.892l-56.883-174.285 25.497-18.432 124.519-90.01c-2.919-2.918-4.864-6.758-7.834-10.649l-121.6 87.143-3.891 2.918-22.58 15.462-47.103-142.336h181.453v-13.516H600.218L543.386 224.46a49 49 0 0 1-12.75 3.84l55.911 170.445-150.016.972zm-217.702-48.436 220.672-158.77c1.945 3.84 4.864 6.758 7.833 9.676L225.638 361.984c-1.945-3.891-4.864-6.758-6.86-10.65m39.219 395.06-85.3-259.533c3.943-.922 7.834-2.867 11.777-3.84l86.272 259.481c-4.864.973-8.807 2.868-12.75 3.84zm388.352 83.25H378.624v-13.567H646.4v9.728c-1.024 1.894-1.024 2.867 0 3.84zm205.926-341.81-85.299 259.481a55.5 55.5 0 0 0-11.776-3.84l85.3-259.481c2.969.972 6.86 2.867 11.775 3.84m-266.752-295.27 220.672 158.77c-2.918 2.919-4.915 6.759-6.86 10.65L576.716 203.213c2.97-3.891 5.888-6.81 8.857-10.65zm289.28 157.798c30.464 0 54.938 24.217 54.938 54.272 0 29.952-24.525 54.17-54.887 54.17a54.477 54.477 0 0 1-54.937-54.222c0-30.003 24.525-54.22 54.937-54.22z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/tdsql.webp b/apps/desktop/public/icons/database/tdsql.webp
new file mode 100644
index 0000000..c6e6703
Binary files /dev/null and b/apps/desktop/public/icons/database/tdsql.webp differ
diff --git a/apps/desktop/public/icons/database/teradata.webp b/apps/desktop/public/icons/database/teradata.webp
new file mode 100644
index 0000000..cc35758
Binary files /dev/null and b/apps/desktop/public/icons/database/teradata.webp differ
diff --git a/apps/desktop/public/icons/database/tidb.svg b/apps/desktop/public/icons/database/tidb.svg
new file mode 100644
index 0000000..ee0b723
--- /dev/null
+++ b/apps/desktop/public/icons/database/tidb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#e80230" d="M855.654 512.154c0 56.422-.153 112.896.256 169.267 0 9.062-2.713 13.773-10.854 17.92a74510 74510 0 0 0-321.024 169.984c-7.68 3.993-13.824 4.813-22.22.358a62695 62695 0 0 0-323.84-170.7c-7.527-3.943-9.882-8.602-9.882-17.05.256-113.255.256-226.56 0-339.866 0-8.448 2.713-13.107 10.035-16.998A92518 92518 0 0 0 501.914 154.47c7.526-3.993 13.21-4.352 20.992-.256A65522 65522 0 0 0 847.462 326.4c7.783 4.096 8.295 9.267 8.295 16.538a25193 25193 0 0 0-.103 169.216M489.472 727.552V709.12c0-101.888.154-203.776-.358-305.664 0-11.622 2.713-17.971 13.363-23.194 28.774-14.182 56.832-29.696 85.248-44.697 3.174-1.946 6.246-4.096 9.216-6.349-27.648-14.643-53.402-28.672-79.616-41.83-3.482-1.741-9.728-.666-13.568 1.33a21905 21905 0 0 0-166.81 87.604c-13.517 7.168-32 11.878-38.502 23.398-6.912 12.186-2.355 31.13-2.714 47.104-.153 13.517 0 26.983 0 42.701l107.879-56.73v16.897c0 73.37 0 146.79.153 220.262 0 4.915 1.331 12.493 4.455 14.285 25.958 14.54 52.377 28.057 81.254 43.213zm85.248-22.528c4.915-2.15 8.397-3.43 11.674-5.12 20.787-11.008 41.37-22.323 62.464-32.666 8.857-4.352 12.185-9.523 12.134-19.814-.41-81.664-.205-163.328-.205-245.094 0-4.352-.46-8.704-.717-14.95-25.753 13.567-49.766 26.93-74.393 38.911-8.96 4.352-11.11 9.882-11.06 19.098.257 64.717 0 129.433 0 194.048.103 21.197.103 42.291.103 65.536v.102z"/></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/trino.svg b/apps/desktop/public/icons/database/trino.svg
new file mode 100644
index 0000000..725aaac
--- /dev/null
+++ b/apps/desktop/public/icons/database/trino.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 42.88 63.19"><defs><style>.cls-1{fill:#cdcccc;}.cls-2{fill:#fff;}.cls-3{fill:#dd00a1;}.cls-4{fill:#f9d8d2;}.cls-5{fill:#10110e;}.cls-6{fill:#e5e5e5;}.cls-7{fill:#8accce;opacity:0.2;}.cls-8{fill:#515151;}</style></defs><g id="Layer_2" data-name="Layer 2"><g id="Layer_3" data-name="Layer 3"><path class="cls-1" d="M39.09,30.67a3,3,0,0,0-6,0A2.76,2.76,0,0,0,35,33.22v4.57a15.27,15.27,0,0,0-6.91-7.85c.46-1,.93-1.86,1.38-2.65a65.83,65.83,0,0,1,5.67-7.24c1.13-1.34,2.2-2.6,3.07-3.7,2.44-3.06,5.12-7.58,4.62-10.26a2.56,2.56,0,0,0-1.25-1.81c-3.39-2-8,4.5-12.53,10.77-3,4.14-4.55,10-5.26,13.29a19.86,19.86,0,0,0-4.23-.46,18.63,18.63,0,0,0-6.08,1,85.14,85.14,0,0,1,.33-11c1-9.51.56-15.09-1.29-17A2.43,2.43,0,0,0,10.56,0C5.1.27,5.72,16.58,5.81,18.44c.22,4.46,2,9.88,3.08,12.88a15.44,15.44,0,0,0-5.25,7.81H3.25a3.11,3.11,0,0,0-3.25,3v5.17a3.12,3.12,0,0,0,3.25,3h.66A13.34,13.34,0,0,0,7.2,54.93l-1,.88a1.17,1.17,0,0,0-.13,1.64c3,3.65,7.91,5.74,13.42,5.74s10.44-2.09,13.42-5.74a1.17,1.17,0,0,0-.13-1.64l-1-.88a13.56,13.56,0,0,0,3.29-4.71h.75a3.12,3.12,0,0,0,3.25-3V42.09a2.94,2.94,0,0,0-1.91-2.68V33.22A2.75,2.75,0,0,0,39.09,30.67Z"/><path class="cls-2" d="M14.62,55.74c.92-.61-1.5-.38-1.7-.79a16.49,16.49,0,0,1-2.86-.51c-1.7-.45-5.78-3.19-6.22-5.82S3.84,41,5.68,38a17.21,17.21,0,0,1,4.38-4.7s-3.57-8.49-3.87-14.9S6.39.58,10.57.38s3.57,10.48,2.86,17.43a90.59,90.59,0,0,0-.2,13.88,19.73,19.73,0,0,1,5.5-.92,21.12,21.12,0,0,1,4.9.46s1.33-9.84,5.71-16,9-12.45,12-10.66-.82,8.18-3.47,11.51-7.24,8.33-8.77,11a46.59,46.59,0,0,0-2.65,5.51,14.93,14.93,0,0,1,6.39,6.32C35,43.22,35.16,48.52,34,50.77a8.08,8.08,0,0,1-5.61,4c-1.33.06-6.92,1.45-6.92,1.45Z"/><path class="cls-3" d="M24.41,31.32s3.34-8.71,6.33-13.6,7-8.59,8.26-7.84-2.57,5.32-5.93,9.81a113.44,113.44,0,0,0-7.43,12.38Z"/><path class="cls-3" d="M11,32.81l1-.74s-.14-8.71,0-14,.41-11.9-1.36-11.84-3,5.17-2.31,12.38A87.47,87.47,0,0,0,11,32.81Z"/><circle class="cls-4" cx="8.02" cy="49.54" r="1.94"/><circle class="cls-4" cx="30.95" cy="49.54" r="1.94"/><path class="cls-5" d="M22.7,49.38a.18.18,0,0,0-.25.07s-.58,1-1.42,1.06a2.09,2.09,0,0,1-1.5-.7V48.33c.54-.3,1.41-1.2,1.41-1.51a1.41,1.41,0,0,0-1.49-1.09c-1,0-1.7.65-1.7,1.19s1.1,1.24,1.41,1.44v1.46a1.82,1.82,0,0,1-1.31.69c-.79,0-1.39-1.08-1.4-1.09a.19.19,0,0,0-.25-.08.2.2,0,0,0-.08.26s.71,1.29,1.73,1.29a2.12,2.12,0,0,0,1.51-.73,2.37,2.37,0,0,0,1.58.73h.12a2.49,2.49,0,0,0,1.71-1.26A.18.18,0,0,0,22.7,49.38Z"/><path class="cls-6" d="M10.06,33.32s-2.77-7-3.3-10.66-1-9.77-.3-13.84A50,50,0,0,1,7.68,3.26S6.39,12.75,6.87,16.9,10.06,33.32,10.06,33.32Z"/><path class="cls-6" d="M23.63,31.23s2-10.59,4.91-14.75S35.06,7.27,36.89,6l1.83-1.28s-7.34,7.7-10.18,14S23.63,31.23,23.63,31.23Z"/><path class="cls-5" d="M12,43.23a1.52,1.52,0,1,0,1.51,1.52A1.52,1.52,0,0,0,12,43.23Zm.43,1.41a.41.41,0,0,1-.41-.41.41.41,0,0,1,.82,0A.41.41,0,0,1,12.41,44.64Z"/><path class="cls-5" d="M26.92,43.23a1.52,1.52,0,1,0,1.52,1.52A1.52,1.52,0,0,0,26.92,43.23Zm.43,1.41a.42.42,0,0,1-.41-.41.42.42,0,0,1,.83,0A.42.42,0,0,1,27.35,44.64Z"/><ellipse class="cls-7" cx="19.73" cy="45.32" rx="14.1" ry="10.16"/><path class="cls-2" d="M36.8,39.67V33a2.45,2.45,0,0,0,1.92-2.28,2.65,2.65,0,0,0-5.27,0A2.44,2.44,0,0,0,35.36,33V39.5h-.19c-2-6.94-7.91-11.25-15.62-11.25S5.89,32.52,3.92,39.5H3.25A2.75,2.75,0,0,0,.37,42.09v5.17a2.75,2.75,0,0,0,2.88,2.58h.91a13.11,13.11,0,0,0,3.6,5.09l-1.3,1.16a.79.79,0,0,0-.09,1.12c2.92,3.53,7.71,5.6,13.13,5.6s10.21-2,13.13-5.6a.79.79,0,0,0-.09-1.12l-1.3-1.16a13.34,13.34,0,0,0,3.6-5.09h1a2.75,2.75,0,0,0,2.88-2.58V42.09A2.62,2.62,0,0,0,36.8,39.67ZM19.55,35.62c7.14,0,12.94,4.7,12.94,10.47,0,6.25-6.52,9-12.94,9s-12.94-2.8-12.94-9C6.61,40.32,12.41,35.62,19.55,35.62Z"/><path class="cls-8" d="M37.28,45.53H35.36c0-.3,0-.6,0-.94a19.35,19.35,0,0,0-.38-3.8h.81a1.35,1.35,0,0,1,1.44,1.3Z"/><path class="cls-8" d="M35.84,48.55h-1a16.69,16.69,0,0,0,.43-2.15h2v.86A1.34,1.34,0,0,1,35.84,48.55Z"/><path class="cls-8" d="M19.55,61.48c-4.8,0-9.06-1.73-11.75-4.79l1.35-1.2a17.86,17.86,0,0,0,10.4,3,17.89,17.89,0,0,0,10.4-3l1.34,1.2C28.61,59.75,24.34,61.48,19.55,61.48Z"/><path class="cls-8" d="M3.25,40.79h.86a19.66,19.66,0,0,0-.38,3.8,6.18,6.18,0,0,0,0,.94H1.86V42.09A1.28,1.28,0,0,1,3.25,40.79Z"/><path d="M19.55,34.76a17.4,17.4,0,0,0-4.8.69V30.24a17.14,17.14,0,0,1,4.8-.65,17.12,17.12,0,0,1,4.79.65v5.25A16,16,0,0,0,19.55,34.76Z"/><path class="cls-8" d="M13.8,30.54V35.8C9,37.56,5.65,41.53,5.65,46.09,5.65,52,11.26,56,19.55,56s13.9-4,13.9-9.91c0-4.56-3.36-8.53-8.15-10.29V30.54c5.61,2,9.11,7.19,9.11,14.09,0,7.76-5.95,13-14.86,13s-14.86-5.21-14.86-13C4.69,37.73,8.19,32.56,13.8,30.54Z"/><path class="cls-8" d="M1.81,46.4h2a15.15,15.15,0,0,0,.43,2.15h-1a1.35,1.35,0,0,1-1.44-1.29Z"/><ellipse class="cls-8" cx="36.08" cy="30.67" rx="1.2" ry="1.08"/></g></g></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/icons/database/turso.png b/apps/desktop/public/icons/database/turso.png
new file mode 100644
index 0000000..d78843d
Binary files /dev/null and b/apps/desktop/public/icons/database/turso.png differ
diff --git a/apps/desktop/public/icons/database/vastbase.png b/apps/desktop/public/icons/database/vastbase.png
new file mode 100644
index 0000000..1007b05
Binary files /dev/null and b/apps/desktop/public/icons/database/vastbase.png differ
diff --git a/apps/desktop/public/icons/database/vertica.webp b/apps/desktop/public/icons/database/vertica.webp
new file mode 100644
index 0000000..0ec01a3
Binary files /dev/null and b/apps/desktop/public/icons/database/vertica.webp differ
diff --git a/apps/desktop/public/icons/database/weaviate.png b/apps/desktop/public/icons/database/weaviate.png
new file mode 100644
index 0000000..8159f50
Binary files /dev/null and b/apps/desktop/public/icons/database/weaviate.png differ
diff --git a/apps/desktop/public/icons/database/xugu.png b/apps/desktop/public/icons/database/xugu.png
new file mode 100644
index 0000000..e564ac2
Binary files /dev/null and b/apps/desktop/public/icons/database/xugu.png differ
diff --git a/apps/desktop/public/icons/database/yashandb.png b/apps/desktop/public/icons/database/yashandb.png
new file mode 100644
index 0000000..ef3ab69
Binary files /dev/null and b/apps/desktop/public/icons/database/yashandb.png differ
diff --git a/apps/desktop/public/icons/database/zookeeper.svg b/apps/desktop/public/icons/database/zookeeper.svg
new file mode 100644
index 0000000..7d0da94
--- /dev/null
+++ b/apps/desktop/public/icons/database/zookeeper.svg
@@ -0,0 +1,19 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="45.02 22.32 53.115 57.774"><style><![CDATA[.I{stroke-width:.5}.J{stroke-miterlimit:10}.K{stroke:#000}.L{fill:none}.M{fill:#f9c89a}.N{fill:#4f2e0e}.O{fill:#6d9758}.P{stroke-width:.1}]]></style><g transform="matrix(.159884 0 0 .159884 34.20631 17.28392)"><g class="K I"><ellipse cx="299.73" cy="339.813" rx="10.957" ry="5.14" fill="#331e09"/><g stroke-miterlimit="10"><path d="M217.706 319.453s4.363 18.614 4.944 24.142 11.635 8.145 12.798 1.745 5.236-22.105 5.236-22.105zm69.518 4.072s5.816 13.962 5.816 21.814 13.96 9.017 15.125 3.78 2.908-25.887 2.908-25.887z" class="M"/><path d="M234.77 336.03c-2.327.97-8.92 1.746-11.44.777s.195 9.113.97 12.217 8.92 2.52 8.92 2.52z" fill="#a15813"/></g><g class="N"><ellipse cx="220.979" cy="344.03" rx="4.872" ry="11.636"/><ellipse cx="236.249" cy="345.268" rx="5.018" ry="11.416"/></g><g stroke-miterlimit="10"><path d="M202.145 377.77L202 364.1c-.145-7.562 7.854-17.16 24.142-16.725s23.85 9.453 23.85 18.18-.728 15.707-1.6 17.452-42.6 2.327-44.2.728-2.036-5.964-2.036-5.964z" fill="#9e5613"/><path d="M202.145 389.55c-2.763-.727-3.78-3.636-3.927-6.398s2.182-5.1 3.927-5.382c1.308 1.746 3.926 2.474 6.253 2.9s32.14.727 35.63.436 4.363-2.326 4.946-3.197c2.473.87 3.5 3.488 3.635 5.96s-1.018 4.8-3.5 5.673-15.562 2.9-24.578 2.763-22.396-2.764-22.396-2.764z" class="N"/><path d="M310.638 342.43s-7.854 4.653-17.9 1.164c-6.544-.873-8.3-.873-8.145 2.327s1.02 11.926-2.035 15.56-6.255 13.1-1.6 17.452 71.988 3.927 74.607 3.2 4.218-5.382 4.218-5.382.87-9.9.58-15.124-7.562-14.834-19.925-14.397-17.45 9.162-22.978 10.325c-4.654-4.362-6.4-9.452-6.4-10.472s-.434-4.653-.434-4.653z" fill="#9e5613"/><path d="M295.585 358.355c4.363 0 7.5-1.963 7.854-6.472s-.727-6.98-3.928-7.198-7.126-.873-9.016-2.108-2.1-3.5-1.3-4.437 2.18-1.817 2.18-1.817l-.5-1.38s-7.2 2.763-6.544 10.47 4.508 12.943 11.27 12.943zm7.927-13.67c2.398.945 2.907 2.764 2.545 4.727s-1.164 7.636 2.98 7.417 5.236-8.3 4.873-11.998-2.764-7.272-3.854-8.145l-.218 1.1s.824.58.85 2.036-2.45 4.216-7.175 4.872z" class="N"/><path d="M317.473 357.556c-2.23 4.85-4.363 20.363-2.424 24.626" class="L"/><path d="M280.97 378.935s-3.346 2.036-3.054 5.234 2.763 3.928 6.4 4.8 38.103 1.9 44.356 2.18 27.632-1.3 31.268-2.763 6.836-7.854-.145-11.636c-2.765 3.055-4.945 3.637-9.454 4.22s-25.597.727-34.322.436l-31.995-.727c-2.18-.146-3.053-1.745-3.053-1.745z" class="N"/></g><g stroke-miterlimit="10" class="M"><path d="M265.554 115.412c-1.02 1.163-5.817 6.7-3.5 11.343s15.56 25.015 15.56 25.015 29.232-14.834 28.36-21.815-6.836-15.27-6.836-15.27zm71.9 105.63c.97-.97 3.1-5.72-2.618-7.466-4.556-.582-7.853 1.552-8.822 2.62s2.035 6.787 3.877 6.98 7.563-2.133 7.563-2.133z"/><path d="M341.42 226.28c.873-1.26 2.715-4.46-1.55-6.593s-9.988.098-11.442 2.327 2.424 7.175 3.2 7.175 9.792-2.9 9.792-2.9z"/><path d="M331.87 202.816l-5.38 9.454s3.005 3.927 4.168 8.87-.776 6.7.872 6.4 11.248-2.908 13.1-1.746 4.363 5.915 2.618 9.114-6.787 9.792-13.865 11.538-15.608-1.455-18.8-5.915-8.24-18.8-8.436-21.33 3.2-10.18 3.2-10.18l13.186-5.914z"/><path d="M325.035 211.542c2.423 1.357 6.303 4.363 7.27 9.502s-1.066 11.635-4.362 14.35"/><path d="M341.7 234.423s-2.328 3.298-7.758 2.52-5.04-7.562-2.424-9.404 6.786-3.296 9.6-2.812 4.167 1.745 4.167 1.745"/><path d="M334.343 228.897l2.617 4.848s-1.65 1.357-3.588.484-1.94-2.327-1.455-3.587 2.426-1.745 2.426-1.745z"/></g><g stroke-miterlimit="10" class="O"><path d="M314.466 123.992s10.764 5.672 12.5 12.653c5.235 1.745 11.392 9.428 10.8 15.052 5.623 2.327 8.12 5.587 8.12 9.27 3.104 2.715 7.744 9.678 2.12 19.76s-8.927 17.055-8.927 17.055l-22.495-1.944-1.94-6.8 10.47-19.392s-4.654-7.562-10.085-7.757c-1.356 5.817-2.714 14.155-2.714 14.155l.58 31.995-2.908 1.745-.582 7.175 7.175 14.93 2.52 2.327-6.594 10.278 1.553 2.9 8.92 21.912-.194 2.715 5.237 6.786-.195 2.908 2.9 7.175-5.624 12.798-3.5 6.98 3.297 10.083s-9.113 8.34-24.24 8.145-25.4-7.95-25.4-7.95l-2.908-1.744s3.297-19.002 2.52-29.668-3.104-26.76-3.104-30.444-.97-14.155-.97-14.155l-1.553 33.546c-.193 11.247-1.745 26.565-3.683 29.667s-4.072 4.072-4.072 4.072l2.132 3.686.582 4.458-2.327 2.9-4.267-1.165s-8.337 9.697-23.462 7.953-24.432-9.308-25.402-15.514c-3.5-2.52-3.878-4.266-3.878-4.266l9.9-11.44-5.624-3.296 4.654-8.34s3.297-8.145 3.878-10.86 2.327-9.307 2.327-9.307l-4.848.193 7.95-12.4-.58-8.533 14.542-30.83-.582-5.042-1.95-2.715-1.587-10.762 1.02-5.818s5.03-6.107 5.6-11.15-2.417-10.083-2.417-10.083l-33.98 22.3-4.87.388-13.973 6.205-3.303-1.358s-1.166-1.938-1.554-5.04-.001-17.064 1.162-19.003 3.877-1.94 3.877-1.94 4.46-.775 7.95-3.103 25.014-18.228 30.25-22.3 23.463-19.778 23.463-19.778 6.205-4.848 9.695-6 5.815-.97 5.815-.97l.195 16.677 15.706 17.8 17.065-10.23 13.574-12.604z"/><path d="M262.936 115.993l-2.327 1.455-10.036 16.724 10.9 1.02-3.927 7.562 20.65 10.907 1.744-2.036-14.98-18.47c-3.5-4.363-4.5-14.107-.582-16.725s-1.453-.437-1.453-.437"/><path d="M272.242 155.915l31.196-5.2-3.673-13.3 13.344 1.7 1.164-15.417-13.816-8.87-1.3-.145s3.346 4.363 3.5 9.744-4.798 9.453-8.87 12.943l-21.525 18.543zm21.668 10.688l20.652-6.834 2.182 11.052-19.343 12.362zm-22.297-10.325l.776 45.18-3.493 12.798-.2 12.4-.582 12.216 2.715 4.072 7.368-1.746m13.573-28.696l-11.44-.97.774 5.43 11.443 2.132z"/><path d="M310.008 209.797l-10.084 2.52 1.357 6.786 8.145-2.132m-51.386-6.786l8.726.775.386 6.98-10.276-.97zm-21.525-1.745l12.604.388-.582 7.174-11.44-1.745m4.848-55.07l-4.848 8.726 21.135 16.482 6.4-15.707zm97.342 43.483s0-6.254 1.9-8.726c-4.654-2.037-15.852-6.544-21.96-5.817-2.9 3.5-8.094 13.67-6.302 19.924 6.737-2.327 26.37-5.38 26.37-5.38zm-147.032-37.085l6.7 9.744 4.218 10.908s-2.618 3.635-5.526 4.944-13.283 5.624-13.283 5.624l-3.296-1.358s3.054-1.938 3.5-13-2.326-12.507-2.326-12.507l6.544-2.473zm98.75 102.53s4.217 14.688 10.326 24.143c3.053-2.035 24.287-3.5 29.426-3.345"/></g><g stroke-miterlimit="10"><path d="M209.174 293.566c3.878 1.018 20.312 3.344 20.312 3.344s8.872 2.182 13.67.146c2.472-5.527 9.9-31.123 9.9-31.123s-7.126-8.3-13.525-9.598-16.433-4.8-16.433-4.8" class="L"/><path d="M220.033 265.062c3.5-.437 20.796 0 30.686 7.125" class="O"/><path d="M214.797 296.862l2.764 9.647" class="L"/><path d="M209.416 312.472c6.544 4.653 23.706 13.963 46.83 3.637" class="O"/><path d="M276.025 319.308c7.997 3.198 27.775 4.07 38.103-1.745" class="L"/></g><g stroke-miterlimit="10" class="O"><path d="M310.056 315.963c10.324 3.345 25.306 3.927 27.05.3S321.64 308.7 321.64 308.7"/><path d="M302.202 309.418c12.65 1.9 26.905-.582 26.905-4.945s-19.488-3.78-19.488-3.78m3.926-53.666c4.22 5.1 7.418 9.9 11.054 11.054-8.726 1.454-29.668 5.817-32.868 9.45-1.453-3.344-2.617-5.1-4.507-6.398 3.78-5.1 26.32-14.107 26.32-14.107z"/></g><path d="M183.093 172.7c-5.236-.582-15.998-2.763-19.924-12.943-2.472-5.1-6.544-5.962-8.435-7.272-2.473-2.18-5.963-3.78-10.908-3.054s-12.798-.437-17.743-3.345-10.18-1.018-11.925 1.455-1.9 5.962-.146 7.853l2.9 3.055s-6.835 1.018-7.417 6.108 3.054 7.562 5.38 8.58 4.363 1.164 4.363 1.164-2.617 3.5-.727 6.834 6.545 4.8 6.545 4.8 2.18 3.054 4.508 3.5 16.434 1.164 16.434 1.164 5.816-2.18 9.162-2.472 11.198-.437 13.816.727 14.107 1.454 14.107 1.454 1.454-6.254 1.3-9.6-1.308-8-1.308-8z" class="J M"/></g><linearGradient id="A" gradientUnits="userSpaceOnUse" x1="103.3" y1="357.36" x2="179.524" y2="357.36"><stop offset="0" stop-color="#442b1f"/><stop offset="1" stop-color="#442b1f"/></linearGradient><path d="M162.055 327.5c-7.95.775-50.222-.582-58.754-5.624.582 29.087 8.726 54.876 13.96 60.5s21.524 10.47 38.395 10.47 27.212-5.067 22.88-11.828c-12.8-19.973-16.483-53.52-16.483-53.52z" fill="url(#A)"/><linearGradient id="B" gradientUnits="userSpaceOnUse" x1="131.029" y1="233.936" x2="143.5" y2="233.936"><stop offset="0" stop-color="#c8b091"/><stop offset=".199" stop-color="#c5a788"/><stop offset=".529" stop-color="#bc8e6e"/><stop offset=".948" stop-color="#ad6745"/><stop offset=".994" stop-color="#ab6240"/></linearGradient><path d="M143.5 363.373V104.5h-12.47l.313 222.514c0 11.053.314 19.196 1.57 23.852s5.293 10.762 7.177 11.634 3.412.873 3.412.873z" fill="url(#B)" class="J K"/><linearGradient id="C" gradientUnits="userSpaceOnUse" x1="131.998" y1="341.231" x2="142.76" y2="341.231"><stop offset="0" stop-color="#88786f"/><stop offset=".105" stop-color="#806f66"/><stop offset=".281" stop-color="#6b574c"/><stop offset=".503" stop-color="#493023"/><stop offset=".622" stop-color="#34180a"/><stop offset="1" stop-color="#3e2316"/></linearGradient><path d="M142.663 332h-10.665s0 15.88 1.357 18.207l9.405.253z" fill="url(#C)"/><g stroke-miterlimit="10" class="I K M"><path d="M127.345 163.938s-3.2 5.526-3.006 7.27 6.206.486 6.593-1.745-3.587-5.526-3.587-5.526zm3.1 25.8c2.62.145 7.417.437 9.163-1.892s5.962-4.508 5.962-7.125-.727-4.072-3.344-6.108-15.416 2.9-16.144 4.217-1.745 4.945-1.308 5.963 1.308 2.9 2.617 3.78 3.054 1.164 3.054 1.164z"/><path d="M138 178.965l3.5 2.472s3.5-2.763.292-4.8-4.072 1.018-4.072 1.018z"/><path d="M123.078 185.267c1.745.485 1.553 1.65 6.012.485s9.5-5.042 10.956-8.532-6.7-9.2-10.083-8.435-9.2 3.587-10.714 5.526-1.793 5.72-.824 7.174 4.653 3.782 4.653 3.782zm15.802-27.05c-1.066-1.55-2.132-4.654-3.5-5.527s-5.816-4.363-7.174-5.235-5.527-4.072-9.114-3.103-6.883 3.006-6.4 7.853 3.587 5.333 5.235 6.98 3.976 3.976 5.333 4.75 5.235 2.618 8.144 2.9 5.72-1.552 6.787-3.394.678-5.235.678-5.235z"/><path d="M133.162 155.3l-4.944 8.144s5.396 2 7.368-.97c2.714-4.072-2.424-7.174-2.424-7.174z"/><path d="M146.008 150.897c-4.364 1.3-15.27 11.343-17.452 16.725s-1.454 10.035 2.9 11.78 10.762-2.18 12.507-5.38 4.508-13.525 4.508-13.525m-17.054 8.3l9.792 4.944s-1.455 2.714-4.46 3.103-6.398-2.036-6.496-4.072 1.163-3.975 1.163-3.975zm14.93-.873c.97 1.745 6.302 6.787 9.2 7.078m-.862 13.185c2.036-.484 3.394-1.648 4.654-2.618"/></g><linearGradient id="D" gradientUnits="userSpaceOnUse" x1="277.188" y1="161.441" x2="284.604" y2="161.441"><stop offset="0" stop-color="#f8fb9b"/><stop offset=".126" stop-color="#f5f892"/><stop offset=".334" stop-color="#efef78"/><stop offset=".601" stop-color="#e3e14f"/><stop offset=".911" stop-color="#d4ce16"/><stop offset="1" stop-color="#cfc804"/></linearGradient><g class="K"><circle cx="280.896" cy="161.441" r="3.708" fill="url(#D)" class="I"/><circle cx="280.871" cy="161.417" r="2.908" class="L P"/></g><linearGradient id="E" gradientUnits="userSpaceOnUse" x1="276.025" y1="182.383" x2="283.44" y2="182.383"><stop offset="0" stop-color="#f8fb9b"/><stop offset=".126" stop-color="#f5f892"/><stop offset=".334" stop-color="#efef78"/><stop offset=".601" stop-color="#e3e14f"/><stop offset=".911" stop-color="#d4ce16"/><stop offset="1" stop-color="#cfc804"/></linearGradient><g class="K"><circle cx="279.733" cy="182.383" r="3.708" fill="url(#E)" class="I"/><circle cx="279.708" cy="182.358" r="2.909" class="L P"/></g><linearGradient id="F" gradientUnits="userSpaceOnUse" x1="274.86" y1="203.325" x2="282.278" y2="203.325"><stop offset="0" stop-color="#f8fb9b"/><stop offset=".126" stop-color="#f5f892"/><stop offset=".334" stop-color="#efef78"/><stop offset=".601" stop-color="#e3e14f"/><stop offset=".911" stop-color="#d4ce16"/><stop offset="1" stop-color="#cfc804"/></linearGradient><g class="K"><circle cx="278.569" cy="203.325" r="3.709" fill="url(#F)" class="I"/><circle cx="278.545" cy="203.301" r="2.909" class="L P"/><path d="M251.542 77.454l-3.2-.873s-1.745.388-1.552 1.262 1.455 1.94 1.357 3.5-.3 4.556.875 6.496 3.975 4.848 5.43 5.623 1.842-.388 1.842-.388 1.356 13.96 1.746 15.416 2.424 5.042 5.72 7.854 8.92 9.2 11.538 11.15 11.246 3.588 14.93-.194 11.635-12.507 12.507-13.768 3.393-4.266 3.297-5.43-.484-13.574-.484-14.06c.58.194 1.84-.484 2.52-1.066s4.945-5.236 4.85-7.272-1.358-7.66-.872-8.047 1.162-1.94.3-2.327-6.012 3.393-6.012 3.393-1.042-13.258-5.815-16.676-43.438-5.817-45.764-2.715-3.204 18.132-3.204 18.132z" class="I J M"/></g><path d="M258 88.797l.457 4.75-1.132-2.472-1.68-6.666-5.053-7.356L250 66.4v-2.036l14.006-4.557-4.05 6.1-3.092 9.598-.158 4.46L258 82.302z"/><path d="M309.328 71.5c10.035 6.544-3.054 4.654-13.815 1.018s-32.286-9.9-37.232-10.035 32.724-3.055 38.54-1.164 12.507 10.18 12.507 10.18z" fill="#161616" class="I J K"/><linearGradient id="G" gradientUnits="userSpaceOnUse" x1="280.96" y1="69.02" x2="280.96" y2="31.748"><stop offset=".372" stop-color="#1d2739"/><stop offset=".994" stop-color="#1d2739"/></linearGradient><g stroke-miterlimit="10" class="I K"><path d="M247.568 61.263c-12.4-6-12.4-13.767.776-22.105s37.23-8.726 48.476-5.624 28.698 14.155 26.566 25.015c-2.132 8.337-11.83 10.47-11.83 10.47z" fill="url(#G)"/><path d="M248.684 65.383l-1.456-6.544c17.9-10.617 50.9-10.908 65.735 7.126-.437 1.308-2.326 4.508-3.636 5.526-25.45-18.906-60.643-6.108-60.643-6.108z" fill="#03468b"/></g><path d="M275.007 56.657l6.688.873-.3 1.744-11.925-1.017 8.727-7.854-5.964-.3.147-1.9 10.906 1.3zm17.523-5.6c3.272 1.9 4.364 4.944 3.2 7.562s-5.382 2.835-7.198 2.254-6.037-3.345-4.072-7.708c1.308-2.544 4.798-4 8.07-2.108zm-5.94 3.288c-1.205 2.677 1.383 4.372 2.5 4.73s3.702.222 4.416-1.382.046-3.48-1.964-4.64-4.15-.268-4.95 1.294zm16.982-.007c3.012 1.603 4.454 4.764 3.977 7.76s-3.88 3.804-5.472 3.42-5.53-2.804-4.714-7.798c.6-2.936 3.196-4.987 6.2-3.382zm-4.256 4.37c-.504 3.065 1.918 4.55 2.9 4.786s3.063-.262 3.357-2.098-.6-3.777-2.44-4.763-3.435.273-3.808 2.075z" fill="#fff"/><path d="M303.187 73.48l1.277 6.787-1.8 4.945.336 5.43v2.8l1.6-2.327.663-8.144 3.045-5.526.262-3.2z"/><g stroke-miterlimit="10" class="K L"><path d="M300.7 81.624c-.97-.583-3.394-2.9-4.557-2.9s-4.364.97-5.817 1.066-5.914 1.84-6.303 2.23m-9.986.195c-.97 0-3.878-.97-4.46-1.26s-3.5-.194-3.5-.194l-2.23-1.455-3.006 2.812"/><path d="M275.782 85.016c.68.388 2.23 2.52 2.135 3.684s-1.747 12.313-1.553 12.604 3.78.872 4.267.485m2.617-1.163c.68-.097 1.552-.3 2.23.582M273.65 86.76c-1.647-3.5-8.34-3.5-10.86.098m23.367.194c.774-4.265 10.567-5.138 12.7-.872" class="I"/></g><ellipse cx="268.414" cy="86.713" rx="3.006" ry="2.375"/><ellipse cx="292.119" cy="85.744" rx="3.151" ry="2.472"/><g stroke-miterlimit="10" class="I K"><path d="M269.867 107.995c4.655 5.914 18.52 5.72 21.695-.97-1.067.3-2.752.92-2.752.92s-5.758.243-7.018.922c-.87 0-2.035.193-2.035.193s-5.72-.776-6.594-.193-3.296-.873-3.296-.873z" fill="#d8d8d8"/><path d="M288.3 112.648c-3.104 3.684-11.054 3.587-14.253.775" class="L"/></g><path d="M289.017 85.355l3.586.437-3.054 1.357c-.58-.58-.532-1.794-.532-1.794zm-23.27 1.165l3.586.437-3.053 1.358c-.582-.583-.533-1.795-.533-1.795z" fill="#fcfcfc"/><path d="M309.9 79.2c-.653 1.163-2.544 3.563-2.7 4.726s.8 4.145.728 4.727m1.162-2.183c-.146-.8-.655-2.98-1.455-3.418m-58.08-3.926c.728 1.02 4.436 4.072 4.58 5.3s-.8 3.127-.5 4.217 1.02 2.763 1.02 2.763m-2.4-3.854c-.22-1.163.072-3.7 1.162-4" class="I J K L"/></g></svg>
\ No newline at end of file
diff --git a/apps/desktop/public/logo-black.png b/apps/desktop/public/logo-black.png
new file mode 100644
index 0000000..c016b38
Binary files /dev/null and b/apps/desktop/public/logo-black.png differ
diff --git a/apps/desktop/public/logo.png b/apps/desktop/public/logo.png
new file mode 100644
index 0000000..011a879
Binary files /dev/null and b/apps/desktop/public/logo.png differ
diff --git a/apps/desktop/src/App.vue b/apps/desktop/src/App.vue
new file mode 100644
index 0000000..269eef2
--- /dev/null
+++ b/apps/desktop/src/App.vue
@@ -0,0 +1,2164 @@
+<script setup lang="ts">
+import { ref, computed, watch, onMounted, onUnmounted, nextTick, defineAsyncComponent } from "vue";
+import { useI18n } from "vue-i18n";
+import { invoke } from "@tauri-apps/api/core";
+import { ChevronsRight } from "@lucide/vue";
+import { TooltipProvider } from "@/components/ui/tooltip";
+import AppToolbar from "@/components/layout/AppToolbar.vue";
+import AppTabBar from "@/components/layout/AppTabBar.vue";
+import AppSidebar from "@/components/layout/AppSidebar.vue";
+import EditorToolbar from "@/components/layout/EditorToolbar.vue";
+import ContentArea from "@/components/layout/ContentArea.vue";
+import AppDialogs from "@/components/layout/AppDialogs.vue";
+import WelcomeScreen from "@/components/layout/WelcomeScreen.vue";
+import DdlViewDialog from "@/components/objects/DdlViewDialog.vue";
+import type { ConfigTab } from "@/components/connection/ConnectionDialog.vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useSavedSqlStore } from "@/stores/savedSqlStore";
+import { useToast } from "@/composables/useToast";
+import { useTheme } from "@/composables/useTheme";
+import { useAppUpdater } from "@/composables/useAppUpdater";
+import { useFileDrop } from "@/composables/useFileDrop";
+import { usePanelResize } from "@/composables/usePanelResize";
+import { useDatabaseOptions } from "@/composables/useDatabaseOptions";
+import { useSqlExecution } from "@/composables/useSqlExecution";
+import { useDialogSources } from "@/composables/useDialogSources";
+import { useNavigationTargets } from "@/composables/useNavigationTargets";
+import { useDataGridActions } from "@/composables/useDataGridActions";
+import { useTauriEvents } from "@/composables/useTauriEvents";
+import { useCloseActionPrompt, type AppCloseAction, type AppCloseRequestOptions } from "@/composables/useCloseActionPrompt";
+import { useVisibilityChange } from "@/composables/useVisibilityChange";
+import { useWebDavAutoUpload } from "@/composables/useWebDavAutoUpload";
+import { shouldDrawDesktopWindowFrame } from "@/composables/useWindowControls";
+import "@/i18n";
+import { translateBackendError } from "@/i18n/backend-errors";
+import * as api from "@/lib/backend/api";
+import { connectionRedactedNameLabel } from "@/lib/connection/connectionPresentation";
+import { quickConnectionOpenTarget } from "@/lib/connection/connectionOpenTarget";
+import { resolveDefaultDatabase } from "@/lib/database/defaultDatabase";
+import { findTreeNodeById, resolveNewQueryTarget } from "@/lib/sql/newQueryContext";
+import { buildExecutableObjectSourceStatements, executeObjectSourceSave } from "@/lib/table/objectSourceEditor";
+import { resolveExecutableSql, resolveExecutableSqlWithBackend, type SqlExecutionSnapshot } from "@/lib/sql/sqlExecutionTarget";
+import { uuid } from "@/lib/common/utils";
+import { isMacOS } from "@/lib/backend/platform";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { openQueryResultArchiveFile } from "@/lib/query/queryResultArchiveFile";
+import { sqlFileTitleFromPath } from "@/lib/sql/sqlFileOpen";
+import type { ConnectionConfig, ObjectSourceKind, QueryTab } from "@/types/database";
+import { parseConnectionDeepLink, type ConnectionDeepLinkDraft } from "@/lib/connection/connectionDeepLink";
+import {
+  isBrowserReloadShortcut,
+  isCloseTabShortcut,
+  isExecuteSqlShortcut,
+  isFocusSearchShortcut,
+  isModRShortcut,
+  isNewQueryShortcut,
+  isObjectSourceSaveShortcutTarget,
+  isOpenSettingsShortcut,
+  isQuickOpenShortcut,
+  isResetZoomShortcut,
+  isRefreshDataShortcut,
+  isSaveShortcut,
+  isSendSelectionToAiShortcut,
+  isSwitchToNextTabShortcut,
+  isSwitchToPreviousTabShortcut,
+  isToggleSidebarShortcut,
+  isZoomInShortcut,
+  isZoomOutShortcut,
+  switchToTabIndexFromShortcut,
+} from "@/lib/editor/keyboardShortcuts";
+import { isPreviewTab } from "@/lib/tabs/tabPresentation";
+import { supportsSqlFileExecution } from "@/lib/database/databaseCapabilities";
+import { classifyAiSqlExecution } from "@/lib/ai/aiSqlExecutionPolicy";
+import { buildAppendedEditorSql } from "@/lib/ai/aiSqlAppend";
+import { assessProductionSql } from "@/lib/database/productionSafety";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import { buildHistoryAiAnalysisPrompt } from "@/lib/history/historyAiAnalysis";
+import { countAvailableAgentDriverUpdates, type AgentDriverUpdateBadgeState } from "@/lib/connection/agentDriverUpdateBadge";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+import { apiUrl, webPath } from "@/lib/common/webPath";
+import { APP_FONT_SANS_CSS_VAR, DEFAULT_UI_FONT_FAMILY } from "@/lib/app/appFonts";
+import { rankSavedSqlHistory } from "@/lib/savedSql/savedSqlHistory";
+import { initSavedSqlEditorPositions } from "@/lib/app/savedSqlEditorPosition";
+import { isSchemaAware, isSingleDatabase, usesTreeSchemaMode } from "@/lib/database/databaseFeatureSupport";
+import { codeMirrorSqlDialect, connectionUsesDatabaseObjectTreeMode, effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import { detectDatabaseFileType } from "@/lib/database/databaseFileDetection";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import type { HistoryEntry } from "@/lib/backend/tauri";
+import type { AiAction } from "@/lib/ai/ai";
+
+const AiAssistant = defineAsyncComponent(() => import("@/components/editor/AiAssistant.vue"));
+const QueryHistory = defineAsyncComponent(() => import("@/components/editor/QueryHistory.vue"));
+const SqlLibraryPanel = defineAsyncComponent(() => import("@/components/layout/SqlLibraryPanel.vue"));
+const SqlFilePanel = defineAsyncComponent(() => import("@/components/layout/SqlFilePanel.vue"));
+const DriverStorePage = defineAsyncComponent(() => import("@/components/config/DriverStoreDialog.vue"));
+const EditorSettingsPage = defineAsyncComponent(() => import("@/components/editor/EditorSettingsDialog.vue"));
+const UpdateDialog = defineAsyncComponent(() => import("@/components/layout/UpdateDialog.vue"));
+const CloseActionPromptDialog = defineAsyncComponent(() => import("@/components/layout/CloseActionPromptDialog.vue"));
+const LoginPage = defineAsyncComponent(() => import("@/components/auth/LoginPage.vue"));
+const QuickOpenDialog = defineAsyncComponent(() => import("@/components/quick-open/QuickOpenDialog.vue"));
+
+type AiAssistantHandle = {
+  triggerAction: (action: AiAction, instruction?: string) => void;
+  setPrompt: (text: string) => void;
+};
+
+const { t } = useI18n();
+const connectionStore = useConnectionStore();
+const queryStore = useQueryStore();
+const settingsStore = useSettingsStore();
+const savedSqlStore = useSavedSqlStore();
+const { message: toastMessage, visible: toastVisible, toast } = useToast();
+const { isDark, themeMode, applyTheme, setThemeMode } = useTheme();
+const { checkingUpdates, updateInfo, updateCheckMessage, showUpdateDialog, isDownloadingUpdate, downloadProgress, updateReady, hasUpdateAvailable, openUrl, checkUpdates, openLatestRelease, downloadAndInstallUpdate, restartApp } = useAppUpdater();
+const { setupFileDrop } = useFileDrop();
+
+const isDesktop = isTauriRuntime();
+const drawDesktopWindowFrame = shouldDrawDesktopWindowFrame(isMacOS(), isDesktop);
+const UPDATE_CHECK_INTERVAL_MS = 60 * 60 * 1000;
+let updateCheckTimer: ReturnType<typeof setInterval> | undefined;
+const needsAuth = ref(!isDesktop);
+const authenticated = ref(isDesktop);
+const setupRequired = ref(false);
+
+const showConnectionDialog = ref(false);
+const connectionDialogPrefill = ref<ConnectionDeepLinkDraft | null>(null);
+const connectionDialogInitialTab = ref<ConfigTab | undefined>(undefined);
+const settingsPageTabOpen = ref(false);
+const settingsInitialTab = ref("appearance");
+const settingsInitialSection = ref<string | undefined>(undefined);
+const showQueryEditorDdlDialog = ref(false);
+const driverStoreTabOpen = ref(false);
+const driverStoreActive = ref(false);
+const settingsReturnSurface = ref<"query" | "driverStore" | "welcome">("welcome");
+const showDriverStore = computed(() => driverStoreTabOpen.value && driverStoreActive.value);
+const showSettingsPage = computed(() => settingsPageTabOpen.value && settingsStore.settingsPageActive);
+const showQuickOpen = ref(false);
+const agentDriverUpdateCount = ref(0);
+const showHistory = ref(false);
+const showAiPanel = ref(safeLocalStorageGet("dbx-ai-panel-open") === "true");
+const showSqlLibraryPanel = ref(safeLocalStorageGet("dbx-sql-library-open") === "true");
+const showSqlFilePanel = ref(safeLocalStorageGet("dbx-sql-file-panel-open") === "true");
+const sidebarOpen = ref(safeLocalStorageGet("dbx-sidebar-open") !== "false");
+const aiPanelReady = ref(false);
+const { sidebarWidth, aiPanelWidth, historyWidth, sqlLibraryWidth, sqlFilePanelWidth, startSidebarResize, startAiPanelResize, startHistoryResize, startSqlLibraryResize, startSqlFilePanelResize } = usePanelResize();
+const aiAssistantRef = ref<AiAssistantHandle | null>(null);
+const appSidebarRef = ref<InstanceType<typeof AppSidebar> | null>(null);
+const contentAreaRef = ref<InstanceType<typeof ContentArea> | null>(null);
+
+const selectedSql = ref("");
+const cursorPos = ref(0);
+const formatSqlRequest = ref<{ id: number; tabId: string } | null>(null);
+const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result");
+const newQueryContextSource = ref<"tab" | "sidebar">("tab");
+const queryEditorDdlTarget = ref<{ connectionId: string; database: string; schema?: string; tableName: string } | null>(null);
+const showSaveSqlDialog = ref(false);
+const saveSqlName = ref("");
+const saveSqlFolderId = ref("");
+const pendingSaveAndCloseTabId = ref<string | null>(null);
+const pendingPrevActiveTabId = ref<string | null>(null);
+const pendingSaveShouldCloseTab = ref(true);
+const pendingAppCloseAction = ref<AppCloseAction | null>(null);
+const pendingCloseActionChoice = ref(false);
+const ROOT_SAVED_SQL_FOLDER = "__root__";
+
+const activeTab = computed(() => queryStore.tabs.find((t) => t.id === queryStore.activeTabId));
+
+const activeConnection = computed(() => {
+  const tab = activeTab.value;
+  return tab ? connectionStore.getConfig(tab.connectionId) : undefined;
+});
+
+function updateAgentDriverUpdateCount(count: number) {
+  if (!settingsStore.editorSettings.updateNotificationsEnabled) {
+    agentDriverUpdateCount.value = 0;
+    return;
+  }
+  agentDriverUpdateCount.value = count;
+}
+
+async function refreshAgentDriverUpdateCount() {
+  if (!isDesktop || !settingsStore.editorSettings.updateNotificationsEnabled) return;
+  try {
+    const drivers = await invoke<AgentDriverUpdateBadgeState[]>("list_installed_agents");
+    if (!settingsStore.editorSettings.updateNotificationsEnabled) return;
+    updateAgentDriverUpdateCount(countAvailableAgentDriverUpdates(drivers));
+  } catch {
+    // Driver update availability is only a badge hint; keep the existing count if the registry cannot be reached.
+  }
+}
+
+function restoreHistorySql(sql: string, entry: HistoryEntry) {
+  const tab = activeTab.value;
+  if (tab?.mode === "query") {
+    queryStore.updateSql(tab.id, sql);
+    return;
+  }
+
+  const connectionId = entry.connection_id || tab?.connectionId || connectionStore.connections[0]?.id;
+  if (!connectionId) return;
+  const config = connectionStore.getConfig(connectionId);
+  const database = entry.database || tab?.database || (config ? resolveDefaultDatabase(config, []) : "");
+  const tabId = queryStore.createTab(connectionId, database || "", t("tabs.sql"));
+  queryStore.updateSql(tabId, sql);
+}
+
+const executableSql = computed(() => {
+  const tab = activeTab.value;
+  return tab
+    ? resolveExecutableSql(tab.sql, selectedSql.value, {
+        mode: settingsStore.editorSettings.executeMode,
+        cursorPos: cursorPos.value,
+      })
+    : "";
+});
+
+async function resolveActiveExecutableSql(snapshot?: SqlExecutionSnapshot) {
+  const tab = activeTab.value;
+  return tab
+    ? await resolveExecutableSqlWithBackend(snapshot?.fullSql ?? tab.sql, snapshot?.selectedSql ?? selectedSql.value, {
+        mode: settingsStore.editorSettings.executeMode,
+        cursorPos: snapshot?.cursorPos ?? cursorPos.value,
+        databaseType: activeConnection.value?.db_type,
+      })
+    : "";
+}
+
+const blockDangerousRedisCommands = ref(true);
+const databaseRequiredSignal = ref(0);
+const databaseRequiredTabId = ref<string | null>(null);
+
+function promptActiveDatabaseSelection() {
+  const tab = activeTab.value;
+  if (!tab) return;
+  databaseRequiredTabId.value = tab.id;
+  databaseRequiredSignal.value += 1;
+  toast(t("editor.selectDatabaseRequired"), 2500);
+}
+
+const {
+  dangerSql,
+  pendingDangerSql,
+  showDangerDialog,
+  suppressDangerConfirm,
+  tryExecute,
+  doExecute,
+  cancelActiveExecution,
+  tryExplain,
+  onDangerConfirm,
+  showSqlParameterDialog,
+  sqlParameterSourceSql,
+  sqlParameterNames,
+  sqlParameterDatabaseType,
+  sqlParameterEnabledSyntaxes,
+  onSqlParametersConfirm,
+  explainMode,
+} = useSqlExecution({
+  activeTab,
+  activeConnection,
+  executableSql,
+  resolveExecutableSql: resolveActiveExecutableSql,
+  activeOutputView,
+  blockDangerousRedisCommands,
+  onMissingDatabase: promptActiveDatabaseSelection,
+});
+
+function requestActiveEditorExecute() {
+  if (contentAreaRef.value?.requestQueryEditorExecute?.()) return;
+  void tryExecute();
+}
+
+const dialogs = useDialogSources();
+const { getDatabaseOptions } = useDatabaseOptions();
+const { openLineageTarget, openDatabaseSearchTarget, openDiagramTarget, onStructureEditorSaved, openTableTarget } = useNavigationTargets(dialogs);
+const { onExecuteSql, onReloadData, onPaginate, onSort } = useDataGridActions(activeTab);
+const { setupTauriListeners, cleanupTauriListeners } = useTauriEvents({
+  openTableTarget,
+  openSqlFilePath,
+  openDbFilePath,
+  openConnectionDeepLink,
+});
+const { showCloseActionPrompt, chooseQuit, chooseMinimize, cancelCloseActionPrompt, performCloseAction, setupCloseActionPromptListener, cleanupCloseActionPromptListener } = useCloseActionPrompt({ requestClose: requestAppClose });
+useVisibilityChange();
+useWebDavAutoUpload();
+
+const appVersion = ref("");
+const isClassicLayout = computed(() => settingsStore.editorSettings.appLayout === "classic");
+const updateNotificationsEnabled = computed(() => settingsStore.editorSettings.updateNotificationsEnabled);
+
+function openSettings(initialTab = "appearance", initialSection?: string) {
+  settingsInitialTab.value = initialTab;
+  settingsInitialSection.value = initialSection;
+  if (!settingsStore.settingsPageActive) {
+    settingsReturnSurface.value = showDriverStore.value ? "driverStore" : activeTab.value ? "query" : "welcome";
+  }
+  activateSettingsPage();
+}
+
+function activateSettingsPage() {
+  settingsPageTabOpen.value = true;
+  settingsStore.settingsPageActive = true;
+  driverStoreActive.value = false;
+}
+
+function closeSettingsPage() {
+  settingsPageTabOpen.value = false;
+  settingsStore.settingsPageActive = false;
+  if (settingsReturnSurface.value === "driverStore" && driverStoreTabOpen.value) {
+    driverStoreActive.value = true;
+    return;
+  }
+  driverStoreActive.value = false;
+}
+
+function openDriverStorePage() {
+  driverStoreTabOpen.value = true;
+  driverStoreActive.value = true;
+  settingsStore.settingsPageActive = false;
+}
+
+function closeDriverStorePage() {
+  driverStoreTabOpen.value = false;
+  driverStoreActive.value = false;
+}
+const toolbarAgentDriverUpdateCount = computed(() => (updateNotificationsEnabled.value ? agentDriverUpdateCount.value : 0));
+const toolbarHasUpdateAvailable = computed(() => updateNotificationsEnabled.value && hasUpdateAvailable.value);
+const hasSqlFileConnections = computed(() => connectionStore.connections.some((c) => supportsSqlFileExecution(c.db_type)));
+const queryEditorDdlDialect = computed(() => {
+  if (!queryEditorDdlTarget.value?.connectionId) return "mysql";
+  return codeMirrorSqlDialect(effectiveDatabaseTypeForConnection(connectionStore.getConfig(queryEditorDdlTarget.value.connectionId)));
+});
+const connectionStats = computed(() => ({
+  total: connectionStore.connections.length,
+  connected: connectionStore.connectedIds.size,
+  types: new Set(connectionStore.connections.map((c) => c.driver_profile || c.db_type)).size,
+}));
+const recentConnections = computed(() => connectionStore.connections.slice(0, 5));
+const savedSqlHistoryItems = computed(() => {
+  const folderById = new Map(savedSqlStore.allFolders.map((folder) => [folder.id, folder]));
+  const folderPath = (folderId?: string): string | undefined => {
+    if (!folderId) return undefined;
+    const parts: string[] = [];
+    const seen = new Set<string>();
+    let folder = folderById.get(folderId);
+    while (folder && !seen.has(folder.id)) {
+      seen.add(folder.id);
+      parts.unshift(folder.name);
+      folder = folder.parentFolderId ? folderById.get(folder.parentFolderId) : undefined;
+    }
+    return parts.join("/");
+  };
+  return rankSavedSqlHistory(savedSqlStore.allFiles, { limit: 6 }).map((file) => {
+    const connection = connectionStore.getConfig(file.connectionId);
+    return {
+      id: file.id,
+      name: file.name,
+      connectionName: connection ? connectionRedactedNameLabel(connection) : t("welcome.unknownConnection"),
+      database: file.database,
+      folderName: folderPath(file.folderId),
+      openCount: file.openCount ?? 0,
+    };
+  });
+});
+const saveSqlFolders = computed(() => {
+  const folderById = new Map(savedSqlStore.allFolders.map((folder) => [folder.id, folder]));
+  const pathForFolder = (folderId: string) => {
+    const parts: string[] = [];
+    const seen = new Set<string>();
+    let folder = folderById.get(folderId);
+    while (folder && !seen.has(folder.id)) {
+      seen.add(folder.id);
+      parts.unshift(folder.name);
+      folder = folder.parentFolderId ? folderById.get(folder.parentFolderId) : undefined;
+    }
+    return parts.join(" / ");
+  };
+  return savedSqlStore.allFoldersTreeOrder.map((folder) => ({
+    ...folder,
+    displayName: pathForFolder(folder.id) || folder.name,
+  }));
+});
+
+async function applyUiScale(scale: number) {
+  if (!isDesktop) return;
+  try {
+    const { getCurrentWebview } = await import("@tauri-apps/api/webview");
+    await getCurrentWebview().setZoom(scale);
+    window.dispatchEvent(new CustomEvent("dbx:ui-scale-applied", { detail: { scale } }));
+  } catch (error) {
+    console.warn("[DBX] Failed to apply UI scale", { scale, error });
+  }
+}
+
+function setGlobalUiScale(scale: number) {
+  settingsStore.updateEditorSettings({ uiScale: scale });
+}
+
+function zoomInUi() {
+  setGlobalUiScale(settingsStore.editorSettings.uiScale + 0.1);
+}
+
+function zoomOutUi() {
+  setGlobalUiScale(settingsStore.editorSettings.uiScale - 0.1);
+}
+
+function resetUiZoom() {
+  setGlobalUiScale(1);
+}
+
+function applyUiFontFamily(fontFamily: string) {
+  if (typeof document === "undefined") return;
+  const next = fontFamily || DEFAULT_UI_FONT_FAMILY;
+  // Override Tailwind's shared sans variable so app chrome and existing UI classes stay in sync.
+  document.documentElement.style.setProperty(APP_FONT_SANS_CSS_VAR, next);
+  document.body.style.fontFamily = `var(${APP_FONT_SANS_CSS_VAR}, ${DEFAULT_UI_FONT_FAMILY})`;
+}
+
+const appUiFontFamilyStyle = computed<Record<string, string>>(() => {
+  const fontFamily = settingsStore.editorSettings.uiFontFamily || DEFAULT_UI_FONT_FAMILY;
+  return {
+    [APP_FONT_SANS_CSS_VAR]: fontFamily,
+    fontFamily: `var(${APP_FONT_SANS_CSS_VAR}, ${DEFAULT_UI_FONT_FAMILY})`,
+  };
+});
+
+function isGlobalUiZoomTarget(target: EventTarget | null): target is Element {
+  if (!(target instanceof Element)) return false;
+  if (target.closest("[data-query-editor-root], [data-cell-detail-editor-root], [data-object-source-editor]")) {
+    return true;
+  }
+  if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || (target instanceof HTMLElement && target.isContentEditable)) {
+    return false;
+  }
+  return !target.closest("[contenteditable='true']");
+}
+
+watch(
+  () => queryStore.activeTabId,
+  (id, previousId) => {
+    if (previousId && previousId !== id && typeof window !== "undefined") {
+      window.dispatchEvent(
+        new CustomEvent("dbx:before-tab-switch", {
+          detail: { tabId: id, fromTabId: previousId },
+        }),
+      );
+    }
+    if (id) newQueryContextSource.value = "tab";
+    if (id && driverStoreActive.value) driverStoreActive.value = false;
+    if (id && settingsStore.settingsPageActive) settingsStore.settingsPageActive = false;
+    selectedSql.value = "";
+    activeOutputView.value = "result";
+    if (id) queryStore.reloadEvictedTab(id);
+  },
+);
+
+watch(
+  () => connectionStore.selectedTreeNodeId,
+  (id) => {
+    if (id) newQueryContextSource.value = "sidebar";
+  },
+);
+
+watch(
+  () => settingsStore.editorSettings.uiScale,
+  (scale) => {
+    void applyUiScale(scale);
+  },
+  { immediate: true },
+);
+
+watch(
+  () => settingsStore.editorSettings.uiFontFamily,
+  (fontFamily) => {
+    applyUiFontFamily(fontFamily);
+  },
+  { immediate: true },
+);
+
+function toggleAiPanel() {
+  showAiPanel.value = !showAiPanel.value;
+  safeLocalStorageSet("dbx-ai-panel-open", String(showAiPanel.value));
+}
+
+function toggleSqlLibrary() {
+  showSqlLibraryPanel.value = !showSqlLibraryPanel.value;
+  safeLocalStorageSet("dbx-sql-library-open", String(showSqlLibraryPanel.value));
+}
+
+function toggleSqlFilePanel() {
+  showSqlFilePanel.value = !showSqlFilePanel.value;
+  safeLocalStorageSet("dbx-sql-file-panel-open", String(showSqlFilePanel.value));
+}
+
+function invokeWhenAiReady(invoke: (handle: AiAssistantHandle) => void) {
+  if (aiAssistantRef.value) {
+    invoke(aiAssistantRef.value);
+    return;
+  }
+  // AiAssistant 是异步组件，首次打开面板时单个 nextTick 不足以等待挂载完成，
+  // 因此监听 ref，待其从 null 变为组件实例后再调用。
+  const stop = watch(aiAssistantRef, (handle) => {
+    if (handle) {
+      stop();
+      invoke(handle);
+    }
+  });
+}
+
+function fixWithAi(errorMessage: string) {
+  if (!showAiPanel.value) {
+    showAiPanel.value = true;
+    safeLocalStorageSet("dbx-ai-panel-open", "true");
+  }
+  invokeWhenAiReady((handle) => handle.triggerAction("fix", errorMessage));
+}
+
+function sendSelectionToAi(sql: string) {
+  if (!showAiPanel.value) {
+    showAiPanel.value = true;
+    safeLocalStorageSet("dbx-ai-panel-open", "true");
+  }
+  invokeWhenAiReady((handle) => handle.setPrompt(sql));
+}
+
+function openAiPanel() {
+  if (!showAiPanel.value) {
+    showAiPanel.value = true;
+    safeLocalStorageSet("dbx-ai-panel-open", "true");
+  }
+}
+
+function analyzeHistoryWithAi(entry: HistoryEntry) {
+  const connectionId = entry.connection_id || activeTab.value?.connectionId;
+  if (!connectionId) {
+    toast(t("history.aiAnalyzeNoConnection"), 5000);
+    return;
+  }
+
+  const config = connectionStore.getConfig(connectionId);
+  if (!config) {
+    toast(t("history.aiAnalyzeNoConnection"), 5000);
+    return;
+  }
+
+  openAiPanel();
+  const database = entry.database || activeTab.value?.database || resolveDefaultDatabase(config, []);
+  const title = t("history.aiAnalysisTab");
+  const tabId = queryStore.createTab(connectionId, database || "", title, "query");
+  queryStore.updateSql(tabId, entry.sql);
+  invokeWhenAiReady((handle) => handle.triggerAction("explain", buildHistoryAiAnalysisPrompt(entry)));
+}
+
+function formatActiveSql() {
+  const tab = activeTab.value;
+  if (!tab || tab.mode !== "query" || !tab.sql.trim()) return;
+  formatSqlRequest.value = {
+    id: (formatSqlRequest.value?.id ?? 0) + 1,
+    tabId: tab.id,
+  };
+}
+
+function toggleSqlKeywordCase() {
+  const sqlFormatter = settingsStore.editorSettings.sqlFormatter;
+  settingsStore.updateEditorSettings({
+    sqlFormatter: {
+      ...sqlFormatter,
+      keywordCase: sqlFormatter.keywordCase === "lower" ? "upper" : "lower",
+    },
+  });
+}
+
+function defaultSavedSqlName(title: string) {
+  const trimmed = title.trim() || "query";
+  const normalized = trimmed.replace(/\s+/g, "_");
+  return normalized.endsWith(".sql") ? normalized : `${normalized}.sql`;
+}
+
+function canSaveSqlTab(tab: QueryTab): boolean {
+  return !!tab.externalSqlPath || !!tab.sql.trim();
+}
+
+function closePendingSavedTab() {
+  if (!pendingSaveAndCloseTabId.value) return;
+  const closeId = pendingSaveAndCloseTabId.value;
+  pendingSaveAndCloseTabId.value = null;
+  if (pendingPrevActiveTabId.value) queryStore.activeTabId = pendingPrevActiveTabId.value;
+  pendingPrevActiveTabId.value = null;
+  const shouldCloseTab = pendingSaveShouldCloseTab.value;
+  pendingSaveShouldCloseTab.value = true;
+  if (shouldCloseTab) queryStore.closeTab(closeId, { force: true });
+}
+
+function cancelPendingSaveAndClose() {
+  showSaveSqlDialog.value = false;
+  pendingSaveAndCloseTabId.value = null;
+  pendingPrevActiveTabId.value = null;
+  pendingSaveShouldCloseTab.value = true;
+  cancelPendingAppClose();
+}
+
+function cancelPendingAppClose() {
+  pendingAppCloseAction.value = null;
+  pendingCloseActionChoice.value = false;
+  pendingSaveShouldCloseTab.value = true;
+}
+
+function finishPendingAppClose(action: AppCloseAction) {
+  if (pendingCloseActionChoice.value) {
+    pendingCloseActionChoice.value = false;
+    showCloseActionPrompt.value = true;
+    return;
+  }
+  pendingAppCloseAction.value = null;
+  pendingSaveShouldCloseTab.value = true;
+  void queryStore
+    .flushPendingPersist()
+    .catch(() => {})
+    .finally(() => performCloseAction(action));
+}
+
+function continuePendingAppCloseAfterSave() {
+  const action = pendingAppCloseAction.value;
+  if (!action) return;
+  if (queryStore.hasDirtyTabs) {
+    pendingSaveShouldCloseTab.value = false;
+    if (queryStore.requestAppCloseConfirmation()) return;
+  }
+  finishPendingAppClose(action);
+}
+
+function requestAppClose(action: AppCloseAction, options: AppCloseRequestOptions = {}) {
+  pendingCloseActionChoice.value = !!options.requireCloseActionChoice;
+  if (queryStore.hasDirtyTabs) {
+    pendingAppCloseAction.value = action;
+    pendingSaveShouldCloseTab.value = false;
+    if (queryStore.requestAppCloseConfirmation()) return;
+  }
+  finishPendingAppClose(action);
+}
+
+function completePendingTabSave(tabId: string) {
+  if (pendingAppCloseAction.value) {
+    continuePendingAppCloseAfterSave();
+    return;
+  }
+  queryStore.closeTab(tabId, { force: true });
+}
+
+function handleDiscardPendingTabClose() {
+  if (!pendingAppCloseAction.value) return;
+  continuePendingAppCloseAfterSave();
+}
+
+function handleDiscardAllPendingTabClose() {
+  if (!pendingAppCloseAction.value) return;
+  continuePendingAppCloseAfterSave();
+}
+
+function handleCloseActionPromptOpenChange(open: boolean) {
+  showCloseActionPrompt.value = open;
+  if (!open) {
+    cancelCloseActionPrompt();
+    cancelPendingAppClose();
+  }
+}
+
+async function saveExternalSqlPath(tab: QueryTab, options: { closeAfterSave?: boolean } = {}): Promise<boolean> {
+  if (!tab.externalSqlPath || !isTauriRuntime()) return false;
+  try {
+    await api.writeExternalSqlFile(tab.externalSqlPath, tab.sql);
+    queryStore.markTabClean(tab);
+    toast(t("savedSql.saved"), 2000);
+    if (options.closeAfterSave) queryStore.closeTab(tab.id, { force: true });
+    return true;
+  } catch (e: any) {
+    toast(t("toolbar.sqlSaveFailed", { message: e?.message || String(e) }), 5000);
+    return true;
+  }
+}
+
+async function saveTabForCloseAll(tabId: string): Promise<boolean> {
+  const tab = queryStore.tabs.find((t) => t.id === tabId);
+  if (!tab || !canSaveSqlTab(tab)) return true;
+  queryStore.activeTabId = tabId;
+
+  if (tab.objectSource) return saveActiveObjectSource(tab);
+
+  if (await saveExternalSqlPath(tab)) return !queryStore.isTabDirty(tab);
+
+  const existing = tab.savedSqlId ? savedSqlStore.getFile(tab.savedSqlId) : undefined;
+  try {
+    const saved = await savedSqlStore.saveFile({
+      id: existing?.id,
+      connectionId: tab.connectionId,
+      folderId: existing?.folderId,
+      name: existing?.name || defaultSavedSqlName(tab.title),
+      database: tab.database,
+      schema: tab.schema,
+      sql: tab.sql,
+    });
+    queryStore.linkSavedSql(tab.id, saved.id, saved.name);
+    queryStore.markTabClean(tab);
+    return true;
+  } catch (e: any) {
+    toast(t("savedSql.saveFailed", { message: e?.message || String(e) }), 5000);
+    return false;
+  }
+}
+
+async function handleSaveAllPendingTabClose() {
+  const ids = [...queryStore.closeConfirmDirtyTabIds];
+  if (!ids.length) return;
+  queryStore.suspendCloseConfirm();
+
+  for (const id of ids) {
+    const saved = await saveTabForCloseAll(id);
+    if (!saved) break;
+  }
+
+  if (queryStore.closeConfirmDirtyTabIds.length > 0) {
+    queryStore.resumeCloseConfirm();
+    return;
+  }
+
+  const result = queryStore.completePendingCloseAfterSaveAll();
+  if (result === "app") continuePendingAppCloseAfterSave();
+}
+
+async function handleSaveTab(tabId: string) {
+  const tab = queryStore.tabs.find((t) => t.id === tabId);
+  if (!tab || !canSaveSqlTab(tab)) return;
+  const closeAfterSave = pendingAppCloseAction.value === null;
+  pendingSaveShouldCloseTab.value = closeAfterSave;
+  if (tab.objectSource) {
+    const saved = await saveActiveObjectSource(tab);
+    if (saved) completePendingTabSave(tabId);
+    else if (pendingAppCloseAction.value) cancelPendingAppClose();
+    return;
+  }
+  if (await saveExternalSqlPath(tab, { closeAfterSave })) {
+    if (!closeAfterSave) continuePendingAppCloseAfterSave();
+    return;
+  }
+  const existing = tab.savedSqlId ? savedSqlStore.getFile(tab.savedSqlId) : undefined;
+  if (existing) {
+    const updated = await savedSqlStore.saveFile({
+      id: existing.id,
+      connectionId: tab.connectionId,
+      folderId: existing.folderId,
+      name: existing.name,
+      database: tab.database,
+      schema: tab.schema,
+      sql: tab.sql,
+    });
+    queryStore.linkSavedSql(tab.id, updated.id, updated.name);
+    queryStore.markTabClean(tab);
+    toast(t("savedSql.saved"), 2000);
+    completePendingTabSave(tabId);
+    return;
+  }
+  // No existing saved SQL — open save dialog, then close after save
+  const prevActive = queryStore.activeTabId;
+  queryStore.activeTabId = tabId;
+  saveSqlName.value = defaultSavedSqlName(tab.title);
+  saveSqlFolderId.value = ROOT_SAVED_SQL_FOLDER;
+  pendingSaveAndCloseTabId.value = tabId;
+  pendingPrevActiveTabId.value = prevActive;
+  showSaveSqlDialog.value = true;
+}
+
+async function openSaveSqlDialog() {
+  const tab = activeTab.value;
+  if (!tab || !canSaveSqlTab(tab)) return;
+  if (tab.objectSource) {
+    await saveActiveObjectSource(tab);
+    return;
+  }
+  if (await saveExternalSqlPath(tab)) return;
+  const existing = tab.savedSqlId ? savedSqlStore.getFile(tab.savedSqlId) : undefined;
+  if (existing) {
+    const updated = await savedSqlStore.saveFile({
+      id: existing.id,
+      connectionId: tab.connectionId,
+      folderId: existing.folderId,
+      name: existing.name,
+      database: tab.database,
+      schema: tab.schema,
+      sql: tab.sql,
+    });
+    queryStore.linkSavedSql(tab.id, updated.id, updated.name);
+    queryStore.markTabClean(tab);
+    toast(t("savedSql.saved"), 2000);
+    return;
+  }
+
+  saveSqlName.value = defaultSavedSqlName(tab.title);
+  saveSqlFolderId.value = ROOT_SAVED_SQL_FOLDER;
+  showSaveSqlDialog.value = true;
+}
+
+async function saveActiveObjectSource(tab: QueryTab): Promise<boolean> {
+  const connection = connectionStore.getConfig(tab.connectionId);
+  const source = tab.objectSource;
+  if (!connection || !source) return false;
+
+  try {
+    const databaseType = effectiveDatabaseTypeForConnection(connection) ?? connection.db_type;
+    const statements = await buildExecutableObjectSourceStatements({
+      databaseType,
+      objectType: source.objectType,
+      schema: source.schema || tab.schema || tab.database,
+      name: source.name,
+      source: tab.sql,
+    });
+    const executableSql = statements.filter((sql) => sql.trim()).join(";\n");
+    if (executableSql.trim()) {
+      const saved = await executeWithProductionSqlGuard({
+        connection,
+        database: tab.database,
+        sql: executableSql,
+        source: t("production.sourceObjectSource"),
+        execute: async () => {
+          await executeObjectSourceSave(tab.connectionId, tab.database, databaseType, statements, source.schema || tab.schema);
+          return true;
+        },
+      });
+      if (!saved) return false;
+    } else {
+      await executeObjectSourceSave(tab.connectionId, tab.database, databaseType, statements, source.schema || tab.schema);
+    }
+    queryStore.markTabClean(tab);
+    toast(t("objects.sourceSaved"), 2000);
+    return true;
+  } catch (e: any) {
+    toast(t("objects.sourceSaveFailed", { message: e?.message || String(e) }), 5000);
+    return false;
+  }
+}
+
+async function confirmSaveSqlToLibrary() {
+  const tab = activeTab.value;
+  const name = saveSqlName.value.trim();
+  if (!tab || !tab.sql.trim() || !name) return;
+  try {
+    const saved = await savedSqlStore.saveFile({
+      id: tab.savedSqlId,
+      connectionId: tab.connectionId,
+      folderId: saveSqlFolderId.value === ROOT_SAVED_SQL_FOLDER ? undefined : saveSqlFolderId.value,
+      name: defaultSavedSqlName(name),
+      database: tab.database,
+      schema: tab.schema,
+      sql: tab.sql,
+    });
+    queryStore.linkSavedSql(tab.id, saved.id, saved.name);
+    queryStore.markTabClean(tab);
+    showSaveSqlDialog.value = false;
+    closePendingSavedTab();
+    toast(t("savedSql.saved"), 2000);
+  } catch (e: any) {
+    toast(t("savedSql.saveFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function saveActiveSqlAsLocalFile() {
+  const tab = activeTab.value;
+  if (!tab || !canSaveSqlTab(tab) || !isTauriRuntime()) return;
+  try {
+    const { save } = await import("@tauri-apps/plugin-dialog");
+    const path = await save({
+      defaultPath: defaultSavedSqlName(tab.title),
+      filters: [{ name: "SQL", extensions: ["sql"] }],
+    });
+    if (!path) return;
+    await api.writeExternalSqlFile(path, tab.sql);
+    queryStore.linkExternalSqlPath(tab.id, path, sqlFileTitleFromPath(path));
+    showSaveSqlDialog.value = false;
+    closePendingSavedTab();
+    toast(t("savedSql.saved"), 2000);
+  } catch (e: any) {
+    toast(t("toolbar.sqlSaveFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function openSqlFile() {
+  const tab = activeTab.value;
+  if (!tab) return;
+  try {
+    if (isTauriRuntime()) {
+      const { open } = await import("@tauri-apps/plugin-dialog");
+      const path = await open({
+        filters: [{ name: "SQL", extensions: ["sql"] }],
+        multiple: false,
+      });
+      if (path) {
+        const sqlPath = path as string;
+        const content = await api.readExternalSqlFile(sqlPath);
+        queryStore.updateSql(tab.id, content);
+        queryStore.linkExternalSqlPath(tab.id, sqlPath, sqlFileTitleFromPath(sqlPath));
+      }
+    } else {
+      const input = document.createElement("input");
+      input.type = "file";
+      input.accept = ".sql";
+      input.onchange = () => {
+        const file = input.files?.[0];
+        if (!file) return;
+        const reader = new FileReader();
+        reader.onload = () => {
+          if (typeof reader.result === "string") {
+            queryStore.updateSql(tab.id, reader.result);
+          }
+        };
+        reader.readAsText(file);
+      };
+      input.click();
+    }
+  } catch (e: any) {
+    toast(t("toolbar.sqlOpenFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function importResultArchive() {
+  try {
+    const bytes = await openQueryResultArchiveFile();
+    if (!bytes) return;
+    const tabId = await queryStore.importResultArchive(bytes);
+    if (!tabId) {
+      toast(t("tabs.resultArchiveImportInvalid"), 5000);
+      return;
+    }
+    activeOutputView.value = "result";
+    toast(t("tabs.resultArchiveImported"), 2500);
+  } catch (e: any) {
+    toast(t("tabs.resultArchiveImportFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function pasteClipboardAsSqlInCondition() {
+  void contentAreaRef.value?.pasteClipboardAsSqlInCondition?.();
+}
+
+async function openSqlFilePath(path: string) {
+  if (!isTauriRuntime()) return;
+  try {
+    const content = await api.readExternalSqlFile(path);
+    const connectionId = connectionStore.activeConnectionId || activeTab.value?.connectionId || connectionStore.connections[0]?.id || "";
+    const connection = connectionId ? connectionStore.getConfig(connectionId) : undefined;
+    const database = activeTab.value?.database || (connection ? resolveDefaultDatabase(connection, []) : "");
+    queryStore.openExternalSqlFile(connectionId, database, path, content);
+  } catch (e: any) {
+    toast(t("toolbar.sqlOpenFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function openPendingSqlFiles() {
+  if (!isTauriRuntime()) return;
+  try {
+    const paths = await api.pendingOpenSqlFiles();
+    for (const path of paths) {
+      await openSqlFilePath(path);
+    }
+  } catch {
+    /* ignore startup file-open probing errors */
+  }
+}
+
+async function openDbFilePath(path: string) {
+  if (!isTauriRuntime()) return;
+  await connectionStore.initFromDisk();
+  try {
+    const name = path.split("/").pop()?.split("\\").pop() || path;
+    const dbType = await detectDatabaseFileType(path);
+    if (!dbType) return;
+
+    // Check for existing connection with the same file path
+    const existing = connectionStore.connections.find((c) => c.host === path);
+    if (existing) {
+      const { ask } = await import("@tauri-apps/plugin-dialog");
+      const switchTo = await ask(`A connection to "${path}" already exists. Switch to it?`, {
+        title: "Database Already Open",
+        kind: "info",
+      });
+      if (switchTo) {
+        connectionStore.activeConnectionId = existing.id;
+        connectionStore.ensureConnected(existing.id).catch(() => {});
+        const node = connectionStore.treeNodes.find((n) => n.id === existing.id);
+        if (node && !node.isExpanded) {
+          connectionStore.loadDatabases(existing.id);
+        }
+      }
+      return;
+    }
+
+    const config: ConnectionConfig = {
+      id: uuid(),
+      name,
+      db_type: dbType,
+      driver_profile: dbType,
+      driver_label: dbType === "duckdb" ? "DuckDB" : "SQLite",
+      url_params: "",
+      host: path,
+      port: 0,
+      username: "",
+      password: "",
+    };
+    await connectionStore.addConnection(config);
+    void connectionStore.connect(config);
+    toast(t("welcome.fileOpened", { name }));
+  } catch (e: any) {
+    toast(t("toolbar.sqlOpenFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function openPendingDbFiles() {
+  if (!isTauriRuntime()) return;
+  try {
+    const paths = await api.pendingOpenDbFiles();
+    for (const path of paths) {
+      await openDbFilePath(path);
+    }
+  } catch {
+    /* ignore startup file-open probing errors */
+  }
+}
+
+async function openConnectionDeepLink(url: string) {
+  await connectionStore.initFromDisk();
+  try {
+    const draft = parseConnectionDeepLink(url);
+    if (!draft) return;
+    connectionStore.stopEditing();
+    connectionStore.stopCreatingConnectionInGroup();
+    connectionDialogPrefill.value = draft;
+    showConnectionDialog.value = true;
+  } catch (e: any) {
+    toast(
+      t("connection.parseConnectionUrlFailed", {
+        message: e?.message || String(e),
+      }),
+      5000,
+    );
+  }
+}
+
+async function openPendingConnectionLinks() {
+  if (!isTauriRuntime()) return;
+  try {
+    const links = await api.pendingOpenConnectionLinks();
+    for (const link of links) {
+      await openConnectionDeepLink(link);
+    }
+  } catch {
+    /* ignore startup deep-link probing errors */
+  }
+}
+
+function setConnectionDialogOpen(value: boolean) {
+  showConnectionDialog.value = value;
+  if (!value) {
+    connectionDialogPrefill.value = null;
+    connectionDialogInitialTab.value = undefined;
+  }
+}
+
+function openConnectionSettings(connectionId: string, initialTab: ConfigTab = "connection") {
+  if (!connectionStore.getConfig(connectionId)) return;
+  connectionDialogInitialTab.value = initialTab;
+  connectionStore.startEditing(connectionId);
+  showConnectionDialog.value = true;
+}
+
+async function newQuery() {
+  const target = resolveNewQueryTarget({
+    activeTab: activeTab.value,
+    selectedTreeNode: findTreeNodeById(connectionStore.treeNodes, connectionStore.selectedTreeNodeId),
+    activeConnectionId: connectionStore.activeConnectionId,
+    connections: connectionStore.connections,
+    preferredSource: newQueryContextSource.value,
+  });
+  if (!target) return;
+  const conn = connectionStore.getConfig(target.connectionId);
+  if (!conn) return;
+  connectionStore.activeConnectionId = target.connectionId;
+  const tabId = queryStore.createTab(conn.id, target.database, undefined, "query", target.schema);
+  try {
+    await connectionStore.ensureConnected(target.connectionId);
+    if (target.shouldRefreshDefaultDatabase) {
+      const options = await getDatabaseOptions(target.connectionId);
+      queryStore.updateDatabase(tabId, resolveDefaultDatabase(conn, options));
+    }
+  } catch (e: any) {
+    toast(
+      t("connection.connectFailed", {
+        message: translateBackendError(t, e?.message || String(e)),
+      }),
+      5000,
+    );
+  }
+}
+
+async function openConnectionQuery(connectionId: string) {
+  const connection = connectionStore.getConfig(connectionId);
+  if (!connection) return;
+  connectionStore.activeConnectionId = connectionId;
+  const initialTarget = quickConnectionOpenTarget(connection);
+  if (initialTarget.kind === "mq-admin") {
+    queryStore.openMqAdmin(connectionId);
+    return;
+  }
+  if (initialTarget.kind === "nacos-admin") {
+    try {
+      await connectionStore.ensureConnected(connectionId);
+      await connectionStore.loadNacosNamespaces(connectionId);
+    } catch (e: any) {
+      toast(
+        t("connection.connectFailed", {
+          message: translateBackendError(t, e?.message || String(e)),
+        }),
+        5000,
+      );
+    }
+    return;
+  }
+  const tabId = queryStore.createTab(connectionId, initialTarget.database);
+  try {
+    await connectionStore.ensureConnected(connectionId);
+    const options = await getDatabaseOptions(connectionId);
+    const target = quickConnectionOpenTarget(connection, options);
+    if (target.kind === "query") {
+      queryStore.updateDatabase(tabId, target.database);
+    }
+  } catch (e: any) {
+    toast(
+      t("connection.connectFailed", {
+        message: translateBackendError(t, e?.message || String(e)),
+      }),
+      5000,
+    );
+  }
+}
+
+async function openSavedSqlFromWelcome(fileId: string) {
+  const file = await savedSqlStore.ensureFileContent(fileId);
+  if (!file) return;
+  queryStore.openSavedSql(file);
+  connectionStore.activeConnectionId = file.connectionId;
+  void savedSqlStore.recordFileUsage(file.id);
+  toast(t("welcome.fileOpened", { name: file.name }), 2000);
+}
+
+function tableTargetFromActiveTab(tableName: string) {
+  const tab = activeTab.value;
+  if (!tab) return null;
+  const connectionId = tab.connectionId;
+  let database = tab.database;
+  let schema = tab.schema;
+
+  const parts = tableName.split(".").filter(Boolean);
+  const rawTableName = parts[parts.length - 1] || tableName;
+  if (parts.length >= 3) {
+    database = parts[parts.length - 3] || database;
+    schema = parts[parts.length - 2];
+  } else if (parts.length === 2) {
+    const dbType = connectionStore.getConfig(connectionId)?.db_type;
+    if (dbType && !isSchemaAware(dbType) && !isSingleDatabase(dbType)) {
+      database = parts[0] || database;
+      schema = undefined;
+    } else {
+      schema = parts[0];
+    }
+  }
+
+  return { connectionId, database, schema, tableName: rawTableName };
+}
+
+async function onClickTable(tableName: string) {
+  const target = tableTargetFromActiveTab(tableName);
+  if (!target) return;
+  try {
+    await openTableTarget(target, { tableInfoTab: "ddl" });
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+async function onViewTableData(tableName: string) {
+  const target = tableTargetFromActiveTab(tableName);
+  if (!target) return;
+  try {
+    await openTableTarget(target);
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+function onViewTableDdl(tableName: string) {
+  const target = tableTargetFromActiveTab(tableName);
+  if (!target) return;
+  queryEditorDdlTarget.value = target;
+  showQueryEditorDdlDialog.value = true;
+}
+
+function onEditTableStructure(tableName: string) {
+  const target = tableTargetFromActiveTab(tableName);
+  if (!target) return;
+  queryStore.openTableStructure(target.connectionId, target.database, target.schema, target.tableName);
+}
+
+async function changeActiveConnection(connectionId: string) {
+  const tab = activeTab.value;
+  if (!tab) return;
+  const connection = connectionStore.getConfig(connectionId);
+  if (!connection) return;
+  queryStore.updateConnection(tab.id, connectionId, resolveDefaultDatabase(connection, []));
+  connectionStore.activeConnectionId = connectionId;
+  try {
+    await connectionStore.ensureConnected(connectionId);
+    const options = await getDatabaseOptions(connectionId);
+    queryStore.updateDatabase(tab.id, resolveDefaultDatabase(connection, options));
+  } catch (e: any) {
+    toast(
+      t("connection.connectFailed", {
+        message: translateBackendError(t, e?.message || String(e)),
+      }),
+      5000,
+    );
+  }
+}
+
+function changeActiveDatabase(database: string) {
+  const tab = activeTab.value;
+  if (tab) {
+    queryStore.updateDatabase(tab.id, database);
+    if (databaseRequiredTabId.value === tab.id && database) {
+      databaseRequiredTabId.value = null;
+    }
+  }
+}
+
+async function setActiveDatabaseAsDefault() {
+  const tab = activeTab.value;
+  if (!tab || !tab.connectionId || !tab.database) return;
+  await connectionStore.setDefaultDatabase(tab.connectionId, tab.database);
+}
+
+async function clearActiveDefaultDatabase() {
+  const tab = activeTab.value;
+  if (!tab || !tab.connectionId) return;
+  await connectionStore.clearDefaultDatabase(tab.connectionId);
+}
+
+function changeActiveSchema(schema: string | undefined) {
+  const tab = activeTab.value;
+  if (tab) queryStore.updateSchema(tab.id, schema);
+}
+function openGitHub() {
+  openUrl("https://github.com/t8y2/dbx");
+}
+function openMcpGuide() {
+  openUrl("https://dbxio.com/cn/docs/mcp");
+}
+
+function setSidebarOpen(open: boolean) {
+  sidebarOpen.value = open;
+  safeLocalStorageSet("dbx-sidebar-open", open ? "true" : "false");
+}
+
+function ensureQueryTab(): string {
+  const tab = activeTab.value;
+  if (tab && tab.mode === "query") return tab.id;
+  const connId = connectionStore.activeConnectionId || connectionStore.connections[0]?.id || "";
+  const db = tab?.connectionId === connId ? tab.database : connectionStore.getConfig(connId)?.database || "";
+  return queryStore.createTab(connId, db, undefined, "query");
+}
+
+function onAiReplaceSql(sql: string) {
+  const tabId = ensureQueryTab();
+  queryStore.updateSql(tabId, sql);
+}
+
+function runAiGeneratedSql(sql: string) {
+  selectedSql.value = "";
+  nextTick(() => tryExecute(sql));
+}
+
+function onAiExecuteSql(sql: string) {
+  const tabId = ensureQueryTab();
+  queryStore.updateSql(tabId, buildAppendedEditorSql(activeTab.value?.sql || "", sql));
+  runAiGeneratedSql(sql);
+}
+
+function onAiTempRunSql(sql: string) {
+  ensureQueryTab();
+  runAiGeneratedSql(sql);
+}
+
+function onAiRequestAutoExecuteSql(sql: string) {
+  const tabId = ensureQueryTab();
+  queryStore.updateSql(tabId, buildAppendedEditorSql(activeTab.value?.sql || "", sql));
+  selectedSql.value = "";
+
+  const productionAssessment = assessProductionSql(sql, activeConnection.value, activeTab.value?.database);
+  if (productionAssessment.active && productionAssessment.isMutation) {
+    toast(t("production.aiReviewRequired"), 5000);
+    return;
+  }
+
+  const decision = classifyAiSqlExecution(sql, activeConnection.value);
+  if (decision.action === "block") {
+    toast(t("ai.autoSqlBlocked"), 5000);
+    return;
+  }
+
+  nextTick(() => {
+    if (decision.action === "auto_execute") {
+      void doExecute(sql);
+      return;
+    }
+    dangerSql.value = sql;
+    pendingDangerSql.value = sql;
+    showDangerDialog.value = true;
+  });
+}
+
+function onAiOpenExplainPlan(sql: string) {
+  const tabId = ensureQueryTab();
+  queryStore.updateSql(tabId, buildAppendedEditorSql(activeTab.value?.sql || "", sql));
+  selectedSql.value = "";
+  nextTick(() => {
+    void tryExplain(sql);
+  });
+}
+
+async function handleQuickOpenSelect(item: any) {
+  const connectionStore = useConnectionStore();
+  const queryStore = useQueryStore();
+
+  // For all types, set the active connection
+  connectionStore.activeConnectionId = item.connectionId;
+
+  // Ensure connection is connected
+  try {
+    await connectionStore.ensureConnected(item.connectionId);
+  } catch (error) {
+    console.error("Failed to connect:", error);
+    return;
+  }
+
+  // Navigate based on type
+  if (item.type === "connection") {
+    // Expand connection node in sidebar
+    // Tree node ID for connection is just the connectionId
+    const connNode = findTreeNodeById(connectionStore.treeNodes, item.connectionId);
+    if (connNode && !connNode.isExpanded) {
+      const config = connectionStore.getConfig(item.connectionId);
+      if (config?.db_type === "redis") {
+        await connectionStore.loadRedisDatabases(item.connectionId);
+      } else if (config?.db_type === "etcd") {
+        await connectionStore.loadEtcdRoot(item.connectionId);
+      } else if (config?.db_type === "zookeeper") {
+        await connectionStore.loadZooKeeperRoot(item.connectionId);
+      } else if (config?.db_type === "mongodb") {
+        await connectionStore.loadMongoDatabases(item.connectionId);
+      } else if (config?.db_type === "elasticsearch") {
+        await connectionStore.loadElasticsearchIndices(item.connectionId);
+      } else if (config?.db_type === "qdrant" || config?.db_type === "milvus" || config?.db_type === "weaviate" || config?.db_type === "chromadb") {
+        await connectionStore.loadVectorCollections(item.connectionId);
+      } else if (config?.db_type === "mq") {
+        await connectionStore.loadMqTenants(item.connectionId);
+      } else {
+        await connectionStore.loadDatabases(item.connectionId);
+      }
+    }
+    return;
+  } else if (item.type === "database") {
+    // Expand connection node first
+    // Tree node ID for connection is just the connectionId
+    const connNode = findTreeNodeById(connectionStore.treeNodes, item.connectionId);
+    if (connNode && !connNode.isExpanded) {
+      const config = connectionStore.getConfig(item.connectionId);
+      if (config?.db_type === "redis") {
+        await connectionStore.loadRedisDatabases(item.connectionId);
+      } else if (config?.db_type === "etcd") {
+        await connectionStore.loadEtcdRoot(item.connectionId);
+      } else if (config?.db_type === "zookeeper") {
+        await connectionStore.loadZooKeeperRoot(item.connectionId);
+      } else if (config?.db_type === "mongodb") {
+        await connectionStore.loadMongoDatabases(item.connectionId);
+      } else if (config?.db_type === "elasticsearch") {
+        await connectionStore.loadElasticsearchIndices(item.connectionId);
+      } else if (config?.db_type === "qdrant" || config?.db_type === "milvus" || config?.db_type === "weaviate" || config?.db_type === "chromadb") {
+        await connectionStore.loadVectorCollections(item.connectionId);
+      } else if (config?.db_type === "mq") {
+        await connectionStore.loadMqTenants(item.connectionId);
+      } else {
+        await connectionStore.loadDatabases(item.connectionId);
+      }
+    }
+
+    // Expand database node
+    // Tree node ID for database is `${connectionId}:${database_name}`
+    const dbNodeId = `${item.connectionId}:${item.database}`;
+    const dbNode = findTreeNodeById(connectionStore.treeNodes, dbNodeId);
+    if (dbNode && !dbNode.isExpanded) {
+      const config = connectionStore.getConfig(item.connectionId);
+      const effectiveDbType = effectiveDatabaseTypeForConnection(config);
+      if (config?.db_type === "sqlserver") {
+        await connectionStore.loadSqlServerDatabaseObjects(item.connectionId, item.database);
+      } else if (usesTreeSchemaMode(effectiveDbType) && !connectionUsesDatabaseObjectTreeMode(config)) {
+        await connectionStore.loadSchemas(item.connectionId, item.database);
+      } else {
+        await connectionStore.loadTables(item.connectionId, item.database);
+      }
+    }
+    return;
+  } else if (item.type === "schema") {
+    const dbNode = findTreeNodeById(connectionStore.treeNodes, `${item.connectionId}:${item.database}`);
+    if (dbNode && !dbNode.isExpanded) await connectionStore.loadSchemas(item.connectionId, item.database);
+    const schemaNode = findTreeNodeById(connectionStore.treeNodes, `${item.connectionId}:${item.database}:${item.schema}`);
+    if (schemaNode && !schemaNode.isExpanded) await connectionStore.loadTables(item.connectionId, item.database, item.schema);
+    return;
+  } else if (item.type === "table" || item.type === "view" || item.type === "materialized_view") {
+    // Open the table/view in a data tab
+    await openTableTarget({
+      connectionId: item.connectionId,
+      database: item.database,
+      schema: item.schema,
+      tableName: item.objectName || item.tableName,
+      tableType: item.type === "view" ? "VIEW" : item.type === "materialized_view" ? "MATERIALIZED_VIEW" : "TABLE",
+    });
+  } else if (item.type === "procedure" || item.type === "function" || item.type === "sequence" || item.type === "package" || item.type === "package-body") {
+    // Open the object source in a source tab
+    const objectTypeMap: Record<string, ObjectSourceKind> = {
+      procedure: "PROCEDURE",
+      function: "FUNCTION",
+      sequence: "SEQUENCE",
+      package: "PACKAGE",
+      "package-body": "PACKAGE_BODY",
+    };
+
+    const objectType = objectTypeMap[item.type];
+    if (!objectType) return;
+
+    const schema = item.schema || item.database;
+    try {
+      const result = await api.getObjectSource(item.connectionId, item.database, schema, item.objectName || item.tableName, objectType);
+      const tabId = queryStore.createTab(item.connectionId, item.database, `Source - ${item.objectName || item.tableName}`);
+      queryStore.updateSql(tabId, result.source);
+      if (item.type !== "sequence") {
+        queryStore.setObjectSource(tabId, {
+          schema,
+          name: item.objectName || item.tableName,
+          objectType,
+        });
+      }
+      queryStore.markTabClean(queryStore.tabs.find((tab) => tab.id === tabId));
+    } catch (error) {
+      toast((error as any)?.message || String(error), 5000);
+    }
+  }
+}
+
+function dispatchBeforeTabSwitch(tabId: string) {
+  if (tabId === queryStore.activeTabId) return;
+  window.dispatchEvent(new CustomEvent("dbx:before-tab-switch", { detail: { tabId, fromTabId: queryStore.activeTabId } }));
+}
+
+function activateQueryTab(tabId: string): boolean {
+  if (!queryStore.tabs.some((tab) => tab.id === tabId)) return false;
+  dispatchBeforeTabSwitch(tabId);
+  queryStore.activeTabId = tabId;
+  driverStoreActive.value = false;
+  settingsStore.settingsPageActive = false;
+  return true;
+}
+
+function activateTabByIndex(index: number): boolean {
+  const tab = queryStore.tabs[index];
+  return tab ? activateQueryTab(tab.id) : false;
+}
+
+function activateAdjacentTab(direction: -1 | 1): boolean {
+  const count = queryStore.tabs.length;
+  if (count < 2) return false;
+  const currentIndex = queryStore.tabs.findIndex((tab) => tab.id === queryStore.activeTabId);
+  const nextIndex = currentIndex < 0 ? (direction > 0 ? 0 : count - 1) : (currentIndex + direction + count) % count;
+  return activateTabByIndex(nextIndex);
+}
+
+function handleKeydown(e: KeyboardEvent) {
+  if (e.defaultPrevented) return;
+
+  const shortcuts = settingsStore.editorSettings.shortcuts;
+  const switchTabIndex = switchToTabIndexFromShortcut(e, shortcuts);
+
+  if (isOpenSettingsShortcut(e, shortcuts)) {
+    e.preventDefault();
+    e.stopPropagation();
+    openSettings();
+    return;
+  }
+  if (isQuickOpenShortcut(e, shortcuts)) {
+    e.preventDefault();
+    e.stopPropagation();
+    showQuickOpen.value = true;
+    return;
+  }
+  if (isFocusSearchShortcut(e, shortcuts)) {
+    const focused = contentAreaRef.value?.focusSearch() || appSidebarRef.value?.focusSearch();
+    if (focused) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
+    return;
+  }
+  if (isRefreshDataShortcut(e, shortcuts)) {
+    e.preventDefault();
+    e.stopPropagation();
+    contentAreaRef.value?.refreshData();
+    return;
+  }
+  if (isNewQueryShortcut(e, shortcuts)) {
+    e.preventDefault();
+    e.stopPropagation();
+    void newQuery();
+    return;
+  }
+  if (isToggleSidebarShortcut(e, shortcuts)) {
+    e.preventDefault();
+    e.stopPropagation();
+    setSidebarOpen(!sidebarOpen.value);
+    return;
+  }
+  if (switchTabIndex != null) {
+    if (activateTabByIndex(switchTabIndex)) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
+    return;
+  }
+  if (isSwitchToPreviousTabShortcut(e, shortcuts)) {
+    if (activateAdjacentTab(-1)) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
+    return;
+  }
+  if (isSwitchToNextTabShortcut(e, shortcuts)) {
+    if (activateAdjacentTab(1)) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
+    return;
+  }
+  if (isCloseTabShortcut(e, shortcuts)) {
+    e.preventDefault();
+    if (showSettingsPage.value) {
+      closeSettingsPage();
+    } else if (showDriverStore.value) {
+      closeDriverStorePage();
+    } else if (queryStore.activeTabId) {
+      queryStore.closeTab(queryStore.activeTabId);
+    }
+    return;
+  }
+  if (isSaveShortcut(e, shortcuts) && e.target instanceof Element && isObjectSourceSaveShortcutTarget(e.target)) {
+    return;
+  }
+  if (activeTab.value?.mode === "query" && !showSaveSqlDialog.value && isSaveShortcut(e, shortcuts)) {
+    e.preventDefault();
+    e.stopPropagation();
+    void openSaveSqlDialog();
+    return;
+  }
+  if (activeTab.value?.mode === "query" && isExecuteSqlShortcut(e, shortcuts) && e.target instanceof Element && e.target.closest("[data-query-editor-root]")) {
+    e.preventDefault();
+    e.stopPropagation();
+    requestActiveEditorExecute();
+    return;
+  }
+  if (activeTab.value?.mode === "query" && isSendSelectionToAiShortcut(e, shortcuts) && e.target instanceof Element && e.target.closest("[data-query-editor-root]")) {
+    e.preventDefault();
+    e.stopPropagation();
+    if (selectedSql.value.trim()) sendSelectionToAi(selectedSql.value);
+    return;
+  }
+  if (isModRShortcut(e) && e.target instanceof Element && contentAreaRef.value?.handleModRTarget(e.target)) {
+    e.preventDefault();
+    e.stopPropagation();
+    return;
+  }
+  if (isDesktop && isGlobalUiZoomTarget(e.target)) {
+    if (isZoomInShortcut(e, shortcuts)) {
+      e.preventDefault();
+      e.stopPropagation();
+      zoomInUi();
+      return;
+    }
+    if (isZoomOutShortcut(e, shortcuts)) {
+      e.preventDefault();
+      e.stopPropagation();
+      zoomOutUi();
+      return;
+    }
+    if (isResetZoomShortcut(e, shortcuts)) {
+      e.preventDefault();
+      e.stopPropagation();
+      resetUiZoom();
+      return;
+    }
+  }
+  if (isDesktop && isBrowserReloadShortcut(e)) {
+    e.preventDefault();
+    e.stopPropagation();
+  }
+}
+
+function onLoginSuccess() {
+  authenticated.value = true;
+  setupRequired.value = false;
+  needsAuth.value = true;
+  window.history.replaceState(null, "", webPath("/"));
+  void initApp();
+}
+
+async function initApp() {
+  const t0 = performance.now();
+  console.log("[STARTUP] initApp begin");
+  settingsStore.initAiConfig();
+  try {
+    await settingsStore.initEditorSettings();
+    console.log(`[STARTUP]   settingsStore.initEditorSettings: ${(performance.now() - t0).toFixed(0)}ms`);
+    await queryStore.initOpenTabs();
+    console.log(`[STARTUP]   queryStore.initOpenTabs: ${(performance.now() - t0).toFixed(0)}ms`);
+    await settingsStore.initDesktopSettings().catch(() => {});
+
+    void Promise.all([initSavedSqlEditorPositions(), savedSqlStore.initFromStorage()])
+      .then(() => {
+        console.log(`[STARTUP]   savedSqlStore.initFromStorage: ${(performance.now() - t0).toFixed(0)}ms`);
+        void queryStore.hydrateSavedSqlTabs();
+      })
+      .catch((e: any) => {
+        toast(t("connection.loadFailed", { message: e?.message || String(e) }), 5000);
+      });
+
+    await connectionStore.initFromDisk();
+    console.log(`[STARTUP]   connectionStore.initFromDisk: ${(performance.now() - t0).toFixed(0)}ms`);
+    restoreActiveConnectionContext();
+  } catch (e: any) {
+    toast(t("connection.loadFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function restoreActiveConnectionContext() {
+  const activeConnectionId = activeTab.value?.connectionId || connectionStore.activeConnectionId;
+  if (activeConnectionId && connectionStore.getConfig(activeConnectionId)) {
+    connectionStore.activeConnectionId = activeConnectionId;
+  }
+}
+
+function handleContextMenu(e: MouseEvent) {
+  const target = e.target as HTMLElement;
+
+  // Check if target is a standard editable input element
+  if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement) {
+    if (import.meta.env.DEV) {
+      console.debug("[contextmenu] Allowing for input/textarea:", target);
+    }
+    return;
+  }
+
+  // Check if target or any parent has contenteditable attribute
+  if (target.isContentEditable || target.closest("[contenteditable]")) {
+    if (import.meta.env.DEV) {
+      console.debug("[contextmenu] Allowing for contenteditable:", target);
+    }
+    return;
+  }
+
+  // Check if target is within a custom context menu container or collection item
+  if (target.closest("[data-reka-collection-item], [data-radix-vue-collection-item], [data-context-menu]")) {
+    if (import.meta.env.DEV) {
+      console.debug("[contextmenu] Allowing for custom context menu container:", target);
+    }
+    return;
+  }
+
+  // Prevent default context menu for all other elements
+  if (import.meta.env.DEV) {
+    console.debug("[contextmenu] Preventing default for:", target);
+  }
+  e.preventDefault();
+}
+
+function openDriverStoreFromEvent() {
+  openDriverStorePage();
+}
+
+function runUpdateNotificationChecks() {
+  if (!updateNotificationsEnabled.value) return;
+  checkUpdates({ silent: true });
+  void refreshAgentDriverUpdateCount();
+}
+
+watch(updateNotificationsEnabled, (enabled) => {
+  if (!enabled) {
+    agentDriverUpdateCount.value = 0;
+    if (updateCheckTimer) {
+      clearInterval(updateCheckTimer);
+      updateCheckTimer = undefined;
+    }
+    return;
+  }
+  runUpdateNotificationChecks();
+  if (!updateCheckTimer) {
+    updateCheckTimer = setInterval(runUpdateNotificationChecks, UPDATE_CHECK_INTERVAL_MS);
+  }
+});
+
+onMounted(async () => {
+  console.log("[STARTUP] onMounted begin");
+  const mountStart = performance.now();
+  requestAnimationFrame(() => {
+    aiPanelReady.value = true;
+  });
+  applyTheme();
+  void applyUiScale(settingsStore.editorSettings.uiScale);
+  window.addEventListener("keydown", handleKeydown);
+  window.addEventListener("dbx-open-driver-store", openDriverStoreFromEvent);
+  if (isDesktop) {
+    document.addEventListener("contextmenu", handleContextMenu);
+  }
+  // macOS: Ctrl+click fires both click and contextmenu.
+  // Intercept click in capture phase to prevent unwanted navigation.
+  // Windows/Linux use Ctrl+click for multi-select; do not block there.
+  document.addEventListener(
+    "click",
+    (e) => {
+      if (e.ctrlKey && isMacOS()) e.stopPropagation();
+    },
+    true,
+  );
+  if (!isDesktop) {
+    try {
+      const res = await fetch(apiUrl("/api/auth/check"));
+      const data = await res.json();
+      needsAuth.value = data.required;
+      authenticated.value = data.authenticated;
+      setupRequired.value = data.setup_required;
+    } catch {
+      /* server unreachable */
+    }
+    if (needsAuth.value && !authenticated.value) {
+      history.replaceState(null, "", webPath("/login"));
+    }
+    if (!setupRequired.value && (!needsAuth.value || authenticated.value)) void initApp();
+    api
+      .getAppVersion()
+      .then((v) => {
+        appVersion.value = v;
+      })
+      .catch(() => {});
+    return;
+  }
+  void initApp();
+  setupFileDrop().catch(() => {});
+  setTimeout(() => {
+    runUpdateNotificationChecks();
+    if (updateNotificationsEnabled.value && !updateCheckTimer) {
+      updateCheckTimer = setInterval(runUpdateNotificationChecks, UPDATE_CHECK_INTERVAL_MS);
+    }
+  }, 10_000);
+  api
+    .getAppVersion()
+    .then((v) => {
+      appVersion.value = v;
+    })
+    .catch(() => {});
+  setupTauriListeners();
+  setupCloseActionPromptListener();
+  void openPendingSqlFiles();
+  void openPendingDbFiles();
+  void openPendingConnectionLinks();
+  console.log(`[STARTUP] onMounted sync done: ${(performance.now() - mountStart).toFixed(0)}ms`);
+});
+
+onUnmounted(() => {
+  cleanupTauriListeners();
+  cleanupCloseActionPromptListener();
+  if (updateCheckTimer) {
+    clearInterval(updateCheckTimer);
+  }
+  window.removeEventListener("keydown", handleKeydown);
+  window.removeEventListener("dbx-open-driver-store", openDriverStoreFromEvent);
+  document.removeEventListener("contextmenu", handleContextMenu);
+});
+</script>
+
+<template>
+  <LoginPage v-if="setupRequired || (needsAuth && !authenticated)" :setup-mode="setupRequired" @authenticated="onLoginSuccess" />
+  <div v-show="!setupRequired && (!needsAuth || authenticated)" class="fixed inset-0 h-screen w-screen overflow-hidden">
+    <TooltipProvider :delay-duration="300">
+      <div class="h-screen w-screen max-w-full min-w-[760px] min-h-[600px] flex flex-col bg-background text-foreground overflow-hidden" :class="{ 'dbx-desktop-window-frame': drawDesktopWindowFrame }" :style="appUiFontFamilyStyle">
+        <AppToolbar
+          :is-dark="isDark"
+          :theme-mode="themeMode"
+          :show-ai-panel="showAiPanel"
+          :show-history="showHistory"
+          :show-sql-library="showSqlLibraryPanel"
+          :show-sql-file-panel="showSqlFilePanel"
+          :show-driver-store="showDriverStore"
+          :show-settings-page="showSettingsPage"
+          :checking-updates="checkingUpdates"
+          :has-update-available="toolbarHasUpdateAvailable"
+          :agent-driver-update-count="toolbarAgentDriverUpdateCount"
+          :has-connections="connectionStore.connections.length > 0"
+          :has-sql-file-connections="hasSqlFileConnections"
+          @new-connection="showConnectionDialog = true"
+          @new-query="newQuery"
+          @set-theme-mode="setThemeMode"
+          @toggle-ai="toggleAiPanel"
+          @toggle-history="showHistory = !showHistory"
+          @toggle-sql-library="toggleSqlLibrary"
+          @toggle-sql-file-panel="toggleSqlFilePanel"
+          @open-github="openGitHub"
+          @open-settings="openSettings()"
+          @open-driver-store="openDriverStorePage"
+          @check-updates="checkUpdates()"
+          @open-transfer="dialogs.showTransferDialog.value = true"
+          @open-sql-file="dialogs.showSqlFileDialog.value = true"
+          @open-schema-diff="dialogs.showSchemaDiffDialog.value = true"
+          @open-data-compare="dialogs.showDataCompareDialog.value = true"
+        />
+
+        <div :class="isClassicLayout ? 'app-layout-classic flex-1 flex min-h-0' : 'app-panel-gutter flex-1 flex min-h-0 gap-1 p-1'">
+          <AppSidebar v-show="sidebarOpen" ref="appSidebarRef" :sidebar-width="sidebarWidth" :classic-layout="isClassicLayout" @import="dialogs.onImportClick" @export="dialogs.onExportClick" @start-resize="startSidebarResize" @collapse="setSidebarOpen(false)" />
+          <div v-show="!sidebarOpen" class="flex h-full w-8 shrink-0 items-start justify-center border-r bg-background/80 pt-2" :class="isClassicLayout ? '' : 'rounded-md border border-border/80'">
+            <Button variant="ghost" size="icon" class="h-7 w-7" :title="t('sidebar.expand')" :aria-label="t('sidebar.expand')" @click="setSidebarOpen(true)">
+              <ChevronsRight class="h-4 w-4" />
+            </Button>
+          </div>
+
+          <div :class="isClassicLayout ? 'flex-1 min-w-0 overflow-hidden' : 'flex-1 min-w-0 overflow-hidden rounded-md border border-border/80 bg-background'">
+            <div class="h-full flex flex-col min-w-0">
+              <AppTabBar
+                :driver-store-open="driverStoreTabOpen"
+                :driver-store-active="driverStoreActive"
+                :settings-page-open="settingsPageTabOpen"
+                :settings-page-active="settingsStore.settingsPageActive"
+                :agent-driver-update-count="toolbarAgentDriverUpdateCount"
+                @activate-driver-store="openDriverStorePage"
+                @activate-settings-page="activateSettingsPage"
+                @activate-tab="
+                  driverStoreActive = false;
+                  settingsStore.settingsPageActive = false;
+                "
+                @close-driver-store="closeDriverStorePage"
+                @close-settings-page="closeSettingsPage"
+                @save-tab="handleSaveTab"
+                @discard-tab-close="handleDiscardPendingTabClose"
+                @save-all-tab-close="handleSaveAllPendingTabClose"
+                @discard-all-tab-close="handleDiscardAllPendingTabClose"
+                @cancel-tab-close="cancelPendingAppClose"
+              />
+              <DriverStorePage v-if="driverStoreTabOpen" v-show="driverStoreActive" class="flex-1 min-h-0" :update-notifications-enabled="updateNotificationsEnabled" @update-count-change="updateAgentDriverUpdateCount" />
+              <EditorSettingsPage
+                v-if="settingsPageTabOpen"
+                v-show="settingsStore.settingsPageActive"
+                variant="page"
+                :open="settingsPageTabOpen"
+                :initial-tab="settingsInitialTab"
+                :initial-section="settingsInitialSection"
+                :app-version="appVersion"
+                class="flex-1 min-h-0"
+                @update:open="(open: boolean) => (open ? activateSettingsPage() : closeSettingsPage())"
+              />
+              <div v-if="activeTab" v-show="!driverStoreActive && !settingsStore.settingsPageActive" class="flex flex-col flex-1 min-h-0">
+                <EditorToolbar
+                  v-if="activeTab.mode === 'query' && !isPreviewTab(activeTab)"
+                  :active-tab="activeTab"
+                  :active-connection="activeConnection"
+                  :executable-sql="executableSql"
+                  :explain-mode="explainMode"
+                  :block-dangerous-redis-commands="blockDangerousRedisCommands"
+                  :sql-keyword-case="settingsStore.editorSettings.sqlFormatter.keywordCase"
+                  :database-required-signal="databaseRequiredTabId === activeTab.id ? databaseRequiredSignal : 0"
+                  :auto-commit="activeTab.autoCommit ?? true"
+                  :txn-session-id="activeTab?.txnSessionId"
+                  :txn-auto-rolled-back="activeTab?.txnAutoRolledBack"
+                  @update:explain-mode="(m: 'explain' | 'autotrace') => (explainMode = m)"
+                  @update:block-dangerous-redis-commands="(v: boolean) => (blockDangerousRedisCommands = v)"
+                  @update:auto-commit="
+                    (v: boolean) => {
+                      if (activeTab) queryStore.setAutoCommit(activeTab.id, v);
+                    }
+                  "
+                  @commit="activeTab && queryStore.commitTransaction(activeTab.id)"
+                  @rollback="activeTab && queryStore.rollbackTransaction(activeTab.id)"
+                  @dismiss-txn-rolled-back="activeTab && (activeTab.txnAutoRolledBack = false)"
+                  @execute="requestActiveEditorExecute()"
+                  @cancel="cancelActiveExecution()"
+                  @explain="tryExplain()"
+                  @format-sql="formatActiveSql"
+                  @toggle-sql-keyword-case="toggleSqlKeywordCase"
+                  @save-sql="void openSaveSqlDialog()"
+                  @open-sql="openSqlFile"
+                  @import-result-archive="importResultArchive"
+                  @paste-sql-in-condition="pasteClipboardAsSqlInCondition"
+                  @change-connection="changeActiveConnection"
+                  @change-database="changeActiveDatabase"
+                  @change-schema="changeActiveSchema"
+                  @set-default-database="setActiveDatabaseAsDefault"
+                  @clear-default-database="clearActiveDefaultDatabase"
+                />
+                <KeepAlive :max="4">
+                  <ContentArea
+                    ref="contentAreaRef"
+                    :key="activeTab.id"
+                    :active-tab="activeTab"
+                    :active-connection="activeConnection"
+                    :executable-sql="executableSql"
+                    :active-output-view="activeOutputView"
+                    :format-sql-request="formatSqlRequest"
+                    :selected-sql="selectedSql"
+                    :cursor-pos="cursorPos"
+                    :block-dangerous-redis-commands="blockDangerousRedisCommands"
+                    @update:active-output-view="activeOutputView = $event"
+                    @fix-with-ai="fixWithAi"
+                    @send-selection-to-ai="sendSelectionToAi"
+                    @execute="tryExecute($event)"
+                    @cancel="cancelActiveExecution()"
+                    @explain="tryExplain()"
+                    @editor-update="(tabId: string, v: string) => queryStore.updateSql(tabId, v)"
+                    @editor-selection-change="(v: string) => (selectedSql = v)"
+                    @editor-cursor-change="(p: number) => (cursorPos = p)"
+                    @editor-viewport-change="(tabId: string, viewport: { scrollTop: number; scrollLeft: number }) => queryStore.updateEditorViewport(tabId, viewport)"
+                    @editor-selection-state-change="(tabId: string, selection: { anchor: number; head: number }) => queryStore.updateEditorSelection(tabId, selection)"
+                    @format-error="toast(t('toolbar.formatSqlFailed'))"
+                    @save-sql="void openSaveSqlDialog()"
+                    @reload="(sql, searchText, whereInput, orderBy, limit, offset, intent) => onReloadData(sql, searchText, whereInput, orderBy, limit, offset, intent)"
+                    @paginate="onPaginate"
+                    @sort="onSort"
+                    @execute-sql="onExecuteSql"
+                    @click-table="onClickTable"
+                    @view-table-data="onViewTableData"
+                    @edit-table-structure="onEditTableStructure"
+                    @view-table-ddl="onViewTableDdl"
+                    @open-object-table="
+                      (target) =>
+                        activeTab &&
+                        openTableTarget({
+                          connectionId: activeTab.connectionId,
+                          database: activeTab.database,
+                          schema: target.schema,
+                          catalog: target.catalog,
+                          tableName: target.tableName,
+                          tableType: target.tableType,
+                        })
+                    "
+                    @object-schema-change="(schema) => activeTab && queryStore.updateSchema(activeTab.id, schema)"
+                    @object-browser-viewport-change="(tabId, viewport) => queryStore.updateObjectBrowserViewport(tabId, viewport)"
+                    @structure-editor-saved="
+                      (commentChanged) =>
+                        activeTab &&
+                        onStructureEditorSaved(
+                          onReloadData,
+                          toast,
+                          {
+                            connectionId: activeTab.connectionId,
+                            database: activeTab.database,
+                            schema: activeTab.schema,
+                            tableName: activeTab.structureTableName || '',
+                          },
+                          commentChanged,
+                        )
+                    "
+                    @structure-editor-close="activeTab && queryStore.closeTab(activeTab.id)"
+                    @open-settings="openSettings"
+                    @open-connection-settings="openConnectionSettings"
+                  />
+                </KeepAlive>
+              </div>
+              <WelcomeScreen
+                v-else-if="!driverStoreActive && !settingsStore.settingsPageActive"
+                :connection-stats="connectionStats"
+                :recent-connections="recentConnections"
+                :saved-sql-history-items="savedSqlHistoryItems"
+                :app-version="appVersion"
+                :has-connections="connectionStore.connections.length > 0"
+                @open-connection-query="openConnectionQuery"
+                @open-saved-sql="openSavedSqlFromWelcome"
+                @new-connection="showConnectionDialog = true"
+                @new-query="newQuery"
+                @show-history="showHistory = true"
+                @import-config="dialogs.onImportClick"
+                @open-github="openGitHub"
+                @open-mcp-guide="openMcpGuide"
+              />
+            </div>
+          </div>
+
+          <div v-if="showAiPanel" :class="isClassicLayout ? 'h-full shrink-0 relative z-30 isolate bg-background' : 'h-full shrink-0 relative z-30 isolate rounded-md border border-border/80 bg-background'" :style="{ width: aiPanelWidth + 'px' }">
+            <div class="panel-resize-handle panel-resize-handle--left" @mousedown="startAiPanelResize" />
+            <div class="h-full min-h-0 overflow-hidden">
+              <AiAssistant
+                v-if="aiPanelReady"
+                ref="aiAssistantRef"
+                :tab="activeTab"
+                :connection="activeConnection"
+                @replace-sql="onAiReplaceSql"
+                @execute-sql="onAiExecuteSql"
+                @temp-run-sql="onAiTempRunSql"
+                @request-auto-execute-sql="onAiRequestAutoExecuteSql"
+                @open-explain-plan="onAiOpenExplainPlan"
+                @close="toggleAiPanel"
+              />
+            </div>
+          </div>
+
+          <div v-if="showHistory" :class="isClassicLayout ? 'h-full shrink-0 relative z-30 isolate bg-background' : 'h-full shrink-0 relative z-30 isolate rounded-md border border-border/80 bg-background'" :style="{ width: historyWidth + 'px' }">
+            <div class="panel-resize-handle panel-resize-handle--left" @mousedown="startHistoryResize" />
+            <QueryHistory @restore="restoreHistorySql" @analyze-ai="analyzeHistoryWithAi" @close="showHistory = false" />
+          </div>
+
+          <div v-if="showSqlLibraryPanel" :class="isClassicLayout ? 'h-full shrink-0 relative z-30 isolate bg-background' : 'h-full shrink-0 relative z-30 isolate rounded-md border border-border/80 bg-background'" :style="{ width: sqlLibraryWidth + 'px' }">
+            <div class="panel-resize-handle panel-resize-handle--left" @mousedown="startSqlLibraryResize" />
+            <div class="h-full min-h-0 overflow-hidden">
+              <SqlLibraryPanel @close="toggleSqlLibrary" />
+            </div>
+          </div>
+
+          <div v-if="showSqlFilePanel" :class="isClassicLayout ? 'h-full shrink-0 relative z-30 isolate bg-background' : 'h-full shrink-0 relative z-30 isolate rounded-md border border-border/80 bg-background'" :style="{ width: sqlFilePanelWidth + 'px' }">
+            <div class="panel-resize-handle panel-resize-handle--left" @mousedown="startSqlFilePanelResize" />
+            <div class="h-full min-h-0 overflow-hidden">
+              <SqlFilePanel @close="toggleSqlFilePanel" />
+            </div>
+          </div>
+        </div>
+
+        <AppDialogs
+          :show-connection-dialog="showConnectionDialog"
+          :connection-prefill="connectionDialogPrefill"
+          :connection-initial-tab="connectionDialogInitialTab"
+          :show-danger-dialog="showDangerDialog"
+          :danger-sql="dangerSql"
+          :suppress-danger-confirm="suppressDangerConfirm"
+          :show-sql-parameter-dialog="showSqlParameterDialog"
+          :sql-parameter-source-sql="sqlParameterSourceSql"
+          :sql-parameter-names="sqlParameterNames"
+          :sql-parameter-database-type="sqlParameterDatabaseType"
+          :sql-parameter-enabled-syntaxes="sqlParameterEnabledSyntaxes"
+          @update:show-connection-dialog="setConnectionDialogOpen"
+          @update:show-danger-dialog="showDangerDialog = $event"
+          @update:suppress-danger-confirm="suppressDangerConfirm = $event"
+          @update:show-sql-parameter-dialog="showSqlParameterDialog = $event"
+          @danger-confirm="onDangerConfirm"
+          @sql-parameters-confirm="onSqlParametersConfirm"
+          @connect-started="(name: string) => toast(t('connection.connecting', { name }), 30000)"
+          @connect-succeeded="(name: string) => toast(t('connection.connectSuccess', { name }), 2000)"
+          @connect-failed="
+            (msg: string) =>
+              toast(
+                t('connection.connectFailed', {
+                  message: translateBackendError(t, msg),
+                }),
+                5000,
+              )
+          "
+          @open-driver-store="
+            setConnectionDialogOpen(false);
+            openDriverStorePage();
+          "
+          @open-tunnel-profile-settings="
+            setConnectionDialogOpen(false);
+            openSettings('tunnels');
+          "
+          @open-lineage-target="openLineageTarget"
+          @open-database-search-target="openDatabaseSearchTarget"
+          @open-diagram-target="openDiagramTarget"
+        />
+        <UpdateDialog
+          v-if="showUpdateDialog"
+          v-model:open="showUpdateDialog"
+          :update-info="updateInfo"
+          :update-check-message="updateCheckMessage"
+          :is-downloading-update="isDownloadingUpdate"
+          :download-progress="downloadProgress"
+          :update-ready="updateReady"
+          @open-latest-release="openLatestRelease"
+          @download-and-install="downloadAndInstallUpdate"
+          @restart="restartApp"
+        />
+        <CloseActionPromptDialog v-if="isDesktop && showCloseActionPrompt" :open="showCloseActionPrompt" @update:open="handleCloseActionPromptOpenChange" @quit="chooseQuit" @minimize="chooseMinimize" />
+        <QuickOpenDialog :open="showQuickOpen" @update:open="showQuickOpen = $event" @select="handleQuickOpenSelect" />
+      </div>
+      <Teleport to="body">
+        <Transition name="toast">
+          <div v-if="toastVisible" class="fixed bottom-6 inset-x-0 w-max max-w-[90vw] sm:max-w-3xl mx-auto z-99999 px-4 py-2 rounded-lg bg-foreground text-background text-sm shadow-lg select-text whitespace-pre-wrap break-words">
+            {{ toastMessage }}
+          </div>
+        </Transition>
+      </Teleport>
+
+      <Dialog
+        :open="showSaveSqlDialog"
+        @update:open="
+          (open: boolean) => {
+            showSaveSqlDialog = open;
+            if (!open && pendingSaveAndCloseTabId) cancelPendingSaveAndClose();
+          }
+        "
+      >
+        <DialogContent class="sm:max-w-[420px]">
+          <DialogHeader>
+            <DialogTitle>{{ t("savedSql.saveToLibrary") }}</DialogTitle>
+          </DialogHeader>
+          <div class="space-y-3">
+            <div class="space-y-1.5">
+              <label class="text-xs font-medium text-muted-foreground">{{ t("savedSql.fileName") }}</label>
+              <Input v-model="saveSqlName" @keydown.enter.prevent="confirmSaveSqlToLibrary" />
+            </div>
+            <div class="space-y-1.5">
+              <label class="text-xs font-medium text-muted-foreground">{{ t("savedSql.folder") }}</label>
+              <Select v-model="saveSqlFolderId">
+                <SelectTrigger class="h-8 w-full">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent position="popper">
+                  <SelectItem :value="ROOT_SAVED_SQL_FOLDER">{{ t("savedSql.rootFolder") }}</SelectItem>
+                  <SelectItem v-for="folder in saveSqlFolders" :key="folder.id" :value="folder.id">
+                    {{ folder.displayName }}
+                  </SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+          </div>
+          <DialogFooter>
+            <Button v-if="isDesktop" variant="secondary" @click="saveActiveSqlAsLocalFile">{{ t("savedSql.saveToFile") }}</Button>
+            <Button variant="outline" @click="cancelPendingSaveAndClose()">{{ t("dangerDialog.cancel") }}</Button>
+            <Button :disabled="!saveSqlName.trim()" @click="confirmSaveSqlToLibrary">{{ t("savedSql.save") }}</Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+      <DdlViewDialog v-if="queryEditorDdlTarget" v-model:open="showQueryEditorDdlDialog" :connection-id="queryEditorDdlTarget.connectionId" :database="queryEditorDdlTarget.database" :schema="queryEditorDdlTarget.schema" :table-name="queryEditorDdlTarget.tableName" :dialect="queryEditorDdlDialect" />
+    </TooltipProvider>
+  </div>
+</template>
+
+<style scoped>
+.toast-enter-active,
+.toast-leave-active {
+  transition: 0.25s ease;
+  transition-property: transform, opacity;
+}
+.toast-enter-from,
+.toast-leave-to {
+  opacity: 0;
+  transform: translateY(100%) scale(0.95);
+}
+</style>
diff --git a/apps/desktop/src/components/admin/DamengJobAdmin.vue b/apps/desktop/src/components/admin/DamengJobAdmin.vue
new file mode 100644
index 0000000..47a7184
--- /dev/null
+++ b/apps/desktop/src/components/admin/DamengJobAdmin.vue
@@ -0,0 +1,480 @@
+<script setup lang="ts">
+import { computed, onMounted, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { AlertTriangle, CalendarClock, DatabaseZap, Loader2, Play, Plus, Power, RefreshCcw, Square, Trash2, XCircle } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useToast } from "@/composables/useToast";
+import type { ConnectionConfig } from "@/types/database";
+import * as api from "@/lib/backend/api";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import {
+  DAMENG_JOB_ENVIRONMENT_SQL,
+  damengClearJobHistoriesSql,
+  damengCreateJobSql,
+  damengDropJobSql,
+  damengEnableJobSql,
+  damengInitJobSystemSql,
+  damengJobHistoriesSql,
+  damengJobListSql,
+  damengJobSchedulesSql,
+  damengJobStepsSql,
+  damengRunJobSql,
+  damengStopJobSql,
+  isDamengJobEnvironmentMissingError,
+  parseDamengJobEnvironmentReady,
+  parseDamengJobs,
+  queryResultToObjects,
+  type DamengJob,
+} from "@/lib/database/damengJobAdmin";
+
+const props = defineProps<{
+  connection: ConnectionConfig;
+}>();
+
+type DetailTab = "steps" | "schedules" | "histories";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const connectionStore = useConnectionStore();
+
+const jobs = ref<DamengJob[]>([]);
+const selectedJobName = ref("");
+const search = ref("");
+const loadingJobs = ref(false);
+const loadingDetails = ref(false);
+const applying = ref(false);
+const jobEnvironmentReady = ref(true);
+const loadError = ref("");
+const detailError = ref("");
+const detailTab = ref<DetailTab>("steps");
+const detailRows = ref<Record<string, unknown>[]>([]);
+
+const createDialogOpen = ref(false);
+const previewDialogOpen = ref(false);
+const pendingSql = ref("");
+const pendingAfterApply = ref<(() => Promise<void>) | undefined>();
+const pendingDanger = ref(false);
+const pendingUseTransaction = ref(false);
+
+const createName = ref("JOB_TEST");
+const createEnabled = ref(true);
+const createDescription = ref("");
+const createStepName = ref("STEP1");
+const createCommand = ref("SELECT 1;");
+const createScheduleName = ref("SCHEDULE1");
+const createScheduleMode = ref<"once" | "daily">("daily");
+const createStartDate = ref("CURDATE");
+const createStartTime = ref("00:00:00");
+const createEndTime = ref("");
+const createMinuteInterval = ref(0);
+
+const supported = computed(() => props.connection.db_type === "dameng");
+const executionDatabase = computed(() => (props.connection.db_type === "dameng" ? "" : props.connection.database || ""));
+const useSystemJobTables = computed(() => props.connection.username?.trim().toUpperCase() === "SYSDBA");
+const selectedJob = computed(() => jobs.value.find((job) => job.name === selectedJobName.value));
+const filteredJobs = computed(() => {
+  const query = search.value.trim().toLowerCase();
+  if (!query) return jobs.value;
+  return jobs.value.filter((job) => `${job.name} ${job.owner || ""} ${job.description || ""}`.toLowerCase().includes(query));
+});
+const detailColumns = computed(() => {
+  const set = new Set<string>();
+  for (const row of detailRows.value) {
+    Object.keys(row).forEach((key) => set.add(key));
+  }
+  return Array.from(set);
+});
+const canCreateJob = computed(() => createName.value.trim() && createStepName.value.trim() && createScheduleName.value.trim() && createCommand.value.trim());
+
+async function ensureConnection() {
+  await connectionStore.ensureConnected(props.connection.id);
+}
+
+async function loadJobs() {
+  if (!supported.value) return;
+  loadingJobs.value = true;
+  loadError.value = "";
+  try {
+    await ensureConnection();
+    const environment = await api.executeQuery(props.connection.id, executionDatabase.value, DAMENG_JOB_ENVIRONMENT_SQL, undefined, undefined, {
+      maxRows: 1,
+    });
+    jobEnvironmentReady.value = parseDamengJobEnvironmentReady(environment);
+    if (!jobEnvironmentReady.value) {
+      jobs.value = [];
+      detailRows.value = [];
+      selectedJobName.value = "";
+      return;
+    }
+    const result = await api.executeQuery(props.connection.id, executionDatabase.value, damengJobListSql(useSystemJobTables.value), undefined, undefined, {
+      maxRows: 5000,
+    });
+    jobs.value = parseDamengJobs(result);
+    if (!selectedJob.value) selectedJobName.value = jobs.value[0]?.name || "";
+    await loadDetails();
+  } catch (error: any) {
+    const message = error?.message || String(error);
+    if (isDamengJobEnvironmentMissingError(message)) {
+      jobEnvironmentReady.value = false;
+      loadError.value = "";
+    } else {
+      loadError.value = message;
+    }
+    jobs.value = [];
+    detailRows.value = [];
+  } finally {
+    loadingJobs.value = false;
+  }
+}
+
+async function loadDetails() {
+  const job = selectedJob.value;
+  if (!job) {
+    detailRows.value = [];
+    return;
+  }
+  loadingDetails.value = true;
+  detailError.value = "";
+  try {
+    const sql = detailTab.value === "steps" ? damengJobStepsSql(job.id, useSystemJobTables.value) : detailTab.value === "schedules" ? damengJobSchedulesSql(job.id, useSystemJobTables.value) : damengJobHistoriesSql(job, useSystemJobTables.value);
+    const result = await api.executeQuery(props.connection.id, executionDatabase.value, sql, undefined, undefined, {
+      maxRows: 1000,
+    });
+    detailRows.value = queryResultToObjects(result);
+  } catch (error: any) {
+    detailError.value = error?.message || String(error);
+    detailRows.value = [];
+  } finally {
+    loadingDetails.value = false;
+  }
+}
+
+function selectJob(job: DamengJob) {
+  selectedJobName.value = job.name;
+}
+
+function previewSql(sql: string, options: { danger?: boolean; afterApply?: () => Promise<void>; useTransaction?: boolean } = {}) {
+  pendingSql.value = sql;
+  pendingDanger.value = !!options.danger;
+  pendingUseTransaction.value = !!options.useTransaction;
+  pendingAfterApply.value = options.afterApply;
+  previewDialogOpen.value = true;
+}
+
+async function applyPendingSql() {
+  if (!pendingSql.value.trim()) return;
+  applying.value = true;
+  try {
+    await ensureConnection();
+    const result = await executeWithProductionSqlGuard({
+      connection: props.connection,
+      database: executionDatabase.value,
+      sql: pendingSql.value,
+      source: t("production.sourceAdmin"),
+      execute: () =>
+        api.executeMulti(props.connection.id, executionDatabase.value, pendingSql.value, undefined, undefined, {
+          maxRows: 1000,
+          useTransaction: pendingUseTransaction.value,
+        }),
+    });
+    if (!result) return;
+    toast(t("damengJobAdmin.applySuccess"), 2500);
+    previewDialogOpen.value = false;
+    await (pendingAfterApply.value?.() ?? Promise.resolve());
+    await loadJobs();
+  } catch (error: any) {
+    toast(t("damengJobAdmin.applyFailed", { message: error?.message || String(error) }), 5000);
+  } finally {
+    applying.value = false;
+  }
+}
+
+function previewCreateEnvironment() {
+  previewSql(damengInitJobSystemSql());
+}
+
+function previewCreateJob() {
+  if (!canCreateJob.value) return;
+  previewSql(
+    damengCreateJobSql({
+      name: createName.value,
+      enabled: createEnabled.value,
+      description: createDescription.value,
+      stepName: createStepName.value,
+      command: createCommand.value,
+      scheduleName: createScheduleName.value,
+      scheduleMode: createScheduleMode.value,
+      startDate: createStartDate.value,
+      startTime: createStartTime.value,
+      endTime: createEndTime.value,
+      minuteInterval: createMinuteInterval.value,
+    }),
+    {
+      afterApply: async () => {
+        createDialogOpen.value = false;
+      },
+      useTransaction: true,
+    },
+  );
+}
+
+function previewEnableJob(enabled: boolean) {
+  const job = selectedJob.value;
+  if (!job) return;
+  previewSql(damengEnableJobSql(job.name, enabled));
+}
+
+function previewDropJob() {
+  const job = selectedJob.value;
+  if (!job) return;
+  previewSql(damengDropJobSql(job.name), { danger: true });
+}
+
+function previewRunJob() {
+  const job = selectedJob.value;
+  if (!job) return;
+  const sql = damengRunJobSql(job.id);
+  if (sql) previewSql(sql);
+}
+
+function previewStopJob() {
+  const job = selectedJob.value;
+  if (!job) return;
+  const sql = damengStopJobSql(job.id);
+  if (sql) previewSql(sql, { danger: true });
+}
+
+function previewClearHistories() {
+  const job = selectedJob.value;
+  if (!job) return;
+  previewSql(damengClearJobHistoriesSql(job.name), { danger: true });
+}
+
+function cellText(value: unknown): string {
+  return value == null ? "" : String(value);
+}
+
+watch(selectedJobName, () => void loadDetails());
+watch(detailTab, () => void loadDetails());
+onMounted(() => void loadJobs());
+</script>
+
+<template>
+  <div class="flex h-full min-h-0 flex-col bg-background">
+    <div class="flex h-12 shrink-0 items-center gap-2 border-b px-3">
+      <CalendarClock class="h-4 w-4 text-primary" />
+      <div class="min-w-0 flex-1">
+        <div class="truncate text-sm font-semibold">{{ t("damengJobAdmin.title") }}</div>
+        <div class="truncate text-[11px] text-muted-foreground">{{ connection.name }}</div>
+      </div>
+      <Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="loadingJobs" @click="loadJobs">
+        <Loader2 v-if="loadingJobs" class="h-3.5 w-3.5 animate-spin" />
+        <RefreshCcw v-else class="h-3.5 w-3.5" />
+        {{ t("contextMenu.refreshChildren") }}
+      </Button>
+      <Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="jobEnvironmentReady" :title="jobEnvironmentReady ? t('damengJobAdmin.environmentReady') : t('damengJobAdmin.initEnvironment')" @click="previewCreateEnvironment">
+        <DatabaseZap class="h-3.5 w-3.5" />
+        {{ jobEnvironmentReady ? t("damengJobAdmin.environmentReady") : t("damengJobAdmin.initEnvironment") }}
+      </Button>
+      <Button size="sm" class="h-8 gap-1.5" @click="createDialogOpen = true">
+        <Plus class="h-3.5 w-3.5" />
+        {{ t("damengJobAdmin.newJob") }}
+      </Button>
+    </div>
+
+    <div v-if="!supported" class="m-4 rounded border border-dashed p-4 text-sm text-muted-foreground">
+      {{ t("damengJobAdmin.unsupported") }}
+    </div>
+
+    <div v-else class="grid min-h-0 flex-1 grid-cols-[300px_minmax(0,1fr)]">
+      <aside class="flex min-h-0 flex-col border-r">
+        <div class="border-b p-2">
+          <Input v-model="search" class="h-8 text-xs" :placeholder="t('damengJobAdmin.searchJob')" />
+        </div>
+        <div v-if="loadError" class="m-2 rounded border border-destructive/30 bg-destructive/5 p-2 text-xs text-destructive">
+          <div class="mb-1 flex items-center gap-1 font-medium"><AlertTriangle class="h-3.5 w-3.5" />{{ t("damengJobAdmin.loadFailed") }}</div>
+          <div class="break-all">{{ loadError }}</div>
+        </div>
+        <div v-else-if="!jobEnvironmentReady" class="m-2 rounded border border-amber-500/30 bg-amber-500/5 p-2 text-xs text-amber-700 dark:text-amber-300">
+          <div class="mb-1 flex items-center gap-1 font-medium"><AlertTriangle class="h-3.5 w-3.5" />{{ t("damengJobAdmin.environmentMissingTitle") }}</div>
+          <div>{{ t("damengJobAdmin.environmentMissingHint") }}</div>
+        </div>
+        <div class="min-h-0 flex-1 overflow-auto p-2">
+          <button v-for="job in filteredJobs" :key="job.name" type="button" class="mb-1 w-full rounded border px-2 py-2 text-left text-xs transition hover:bg-accent" :class="selectedJobName === job.name ? 'border-primary bg-primary/10' : 'border-transparent'" @click="selectJob(job)">
+            <div class="flex items-center gap-2">
+              <span class="min-w-0 flex-1 truncate font-medium">{{ job.name }}</span>
+              <Badge v-if="job.running" variant="outline" class="h-5 border-amber-500/50 px-1.5 text-[10px] text-amber-700 dark:text-amber-300">{{ t("damengJobAdmin.running") }}</Badge>
+              <Badge :variant="job.enabled ? 'default' : 'secondary'" class="h-5 px-1.5 text-[10px]">{{ job.enabled ? t("damengJobAdmin.enabled") : t("damengJobAdmin.disabled") }}</Badge>
+            </div>
+            <div class="mt-1 truncate text-[11px] text-muted-foreground">{{ job.owner || "-" }} · {{ job.valid || "-" }}</div>
+          </button>
+          <div v-if="!loadingJobs && filteredJobs.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+            {{ t("damengJobAdmin.emptyJobs") }}
+          </div>
+        </div>
+      </aside>
+
+      <main class="flex min-h-0 flex-col">
+        <div v-if="selectedJob" class="flex shrink-0 flex-wrap items-center gap-2 border-b p-3">
+          <div class="min-w-0 flex-1">
+            <div class="truncate text-sm font-semibold">{{ selectedJob.name }}</div>
+            <div class="flex min-w-0 items-center gap-2 text-xs text-muted-foreground">
+              <Badge v-if="selectedJob.running" variant="outline" class="h-5 border-amber-500/50 px-1.5 text-[10px] text-amber-700 dark:text-amber-300">{{ t("damengJobAdmin.running") }}</Badge>
+              <span class="truncate">{{ selectedJob.description || t("damengJobAdmin.noDescription") }}</span>
+            </div>
+          </div>
+          <Button size="sm" variant="outline" class="h-8 gap-1.5" @click="previewRunJob">
+            <Play class="h-3.5 w-3.5" />
+            {{ t("damengJobAdmin.runAsync") }}
+          </Button>
+          <Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="!selectedJob.running" :title="selectedJob.running ? t('damengJobAdmin.stopRunning') : t('damengJobAdmin.stopRunningDisabled')" @click="previewStopJob">
+            <Square class="h-3.5 w-3.5" />
+            {{ t("damengJobAdmin.stopRunning") }}
+          </Button>
+          <Button size="sm" variant="outline" class="h-8 gap-1.5" @click="previewEnableJob(!selectedJob.enabled)">
+            <Power class="h-3.5 w-3.5" />
+            {{ selectedJob.enabled ? t("damengJobAdmin.disable") : t("damengJobAdmin.enable") }}
+          </Button>
+          <Button size="sm" variant="outline" class="h-8 gap-1.5" @click="previewClearHistories">
+            <XCircle class="h-3.5 w-3.5" />
+            {{ t("damengJobAdmin.clearHistories") }}
+          </Button>
+          <Button size="sm" variant="destructive" class="h-8 gap-1.5" @click="previewDropJob">
+            <Trash2 class="h-3.5 w-3.5" />
+            {{ t("damengJobAdmin.dropJob") }}
+          </Button>
+        </div>
+
+        <div v-if="selectedJob" class="flex h-10 shrink-0 items-center gap-1 border-b px-3">
+          <Button size="sm" :variant="detailTab === 'steps' ? 'secondary' : 'ghost'" class="h-7 px-2 text-xs" @click="detailTab = 'steps'">{{ t("damengJobAdmin.steps") }}</Button>
+          <Button size="sm" :variant="detailTab === 'schedules' ? 'secondary' : 'ghost'" class="h-7 px-2 text-xs" @click="detailTab = 'schedules'">{{ t("damengJobAdmin.schedules") }}</Button>
+          <Button size="sm" :variant="detailTab === 'histories' ? 'secondary' : 'ghost'" class="h-7 px-2 text-xs" @click="detailTab = 'histories'">{{ t("damengJobAdmin.histories") }}</Button>
+          <Loader2 v-if="loadingDetails" class="ml-auto h-3.5 w-3.5 animate-spin text-muted-foreground" />
+        </div>
+
+        <div class="min-h-0 flex-1 overflow-auto p-3">
+          <div v-if="!jobEnvironmentReady" class="flex h-full items-center justify-center">
+            <div class="max-w-xl rounded-lg border border-dashed p-5 text-sm">
+              <div class="mb-2 flex items-center gap-2 font-semibold"><DatabaseZap class="h-4 w-4 text-primary" />{{ t("damengJobAdmin.environmentMissingTitle") }}</div>
+              <p class="mb-4 text-xs leading-5 text-muted-foreground">{{ t("damengJobAdmin.environmentMissingDescription") }}</p>
+              <Button size="sm" class="gap-1.5" @click="previewCreateEnvironment">
+                <DatabaseZap class="h-3.5 w-3.5" />
+                {{ t("damengJobAdmin.initEnvironment") }}
+              </Button>
+            </div>
+          </div>
+          <div v-else-if="!selectedJob" class="flex h-full items-center justify-center text-sm text-muted-foreground">
+            {{ t("damengJobAdmin.selectJob") }}
+          </div>
+          <div v-else-if="detailError" class="rounded border border-destructive/30 bg-destructive/5 p-3 text-xs text-destructive">
+            {{ detailError }}
+          </div>
+          <table v-else class="w-full min-w-max border-collapse text-xs">
+            <thead>
+              <tr class="border-b bg-muted/40">
+                <th v-for="column in detailColumns" :key="column" class="px-2 py-2 text-left font-medium">{{ column }}</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="(row, index) in detailRows" :key="index" class="border-b hover:bg-muted/30">
+                <td v-for="column in detailColumns" :key="column" class="max-w-[360px] px-2 py-2 align-top">
+                  <span class="block truncate" :title="cellText(row[column])">{{ cellText(row[column]) || "-" }}</span>
+                </td>
+              </tr>
+            </tbody>
+          </table>
+          <div v-if="selectedJob && !loadingDetails && !detailError && detailRows.length === 0" class="p-8 text-center text-xs text-muted-foreground">
+            {{ t("damengJobAdmin.emptyDetails") }}
+          </div>
+        </div>
+      </main>
+    </div>
+
+    <Dialog v-model:open="createDialogOpen">
+      <DialogContent class="max-w-3xl">
+        <DialogHeader>
+          <DialogTitle>{{ t("damengJobAdmin.newJob") }}</DialogTitle>
+        </DialogHeader>
+        <div class="grid gap-3 text-xs">
+          <div class="grid grid-cols-2 gap-3">
+            <label class="grid gap-1">
+              <span>{{ t("damengJobAdmin.jobName") }}</span>
+              <Input v-model="createName" class="h-8 text-xs" />
+            </label>
+            <label class="grid gap-1">
+              <span>{{ t("damengJobAdmin.description") }}</span>
+              <Input v-model="createDescription" class="h-8 text-xs" />
+            </label>
+          </div>
+          <label class="flex items-center gap-2">
+            <input v-model="createEnabled" type="checkbox" />
+            <span>{{ t("damengJobAdmin.enabled") }}</span>
+          </label>
+          <div class="grid grid-cols-2 gap-3">
+            <label class="grid gap-1">
+              <span>{{ t("damengJobAdmin.stepName") }}</span>
+              <Input v-model="createStepName" class="h-8 text-xs" />
+            </label>
+            <label class="grid gap-1">
+              <span>{{ t("damengJobAdmin.scheduleName") }}</span>
+              <Input v-model="createScheduleName" class="h-8 text-xs" />
+            </label>
+          </div>
+          <label class="grid gap-1">
+            <span>{{ t("damengJobAdmin.sqlCommand") }}</span>
+            <textarea v-model="createCommand" class="min-h-28 rounded-md border bg-background px-3 py-2 font-mono text-xs outline-none focus:ring-2 focus:ring-ring" />
+          </label>
+          <div class="grid grid-cols-5 gap-3">
+            <label class="grid gap-1">
+              <span>{{ t("damengJobAdmin.scheduleMode") }}</span>
+              <select v-model="createScheduleMode" class="h-8 rounded-md border bg-background px-2 text-xs">
+                <option value="daily">{{ t("damengJobAdmin.daily") }}</option>
+                <option value="once">{{ t("damengJobAdmin.once") }}</option>
+              </select>
+            </label>
+            <label class="grid gap-1">
+              <span>{{ t("damengJobAdmin.startDate") }}</span>
+              <Input v-model="createStartDate" class="h-8 text-xs" />
+            </label>
+            <label class="grid gap-1">
+              <span>{{ t("damengJobAdmin.startTime") }}</span>
+              <Input v-model="createStartTime" class="h-8 text-xs" />
+            </label>
+            <label class="grid gap-1">
+              <span>{{ t("damengJobAdmin.endTime") }}</span>
+              <Input v-model="createEndTime" class="h-8 text-xs" placeholder="23:59:59" />
+            </label>
+            <label class="grid gap-1">
+              <span>{{ t("damengJobAdmin.minuteInterval") }}</span>
+              <Input v-model.number="createMinuteInterval" type="number" min="0" max="1439" class="h-8 text-xs" />
+            </label>
+          </div>
+        </div>
+        <DialogFooter>
+          <Button variant="outline" @click="createDialogOpen = false">{{ t("common.cancel") }}</Button>
+          <Button :disabled="!canCreateJob" @click="previewCreateJob">{{ t("damengJobAdmin.previewSql") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <Dialog v-model:open="previewDialogOpen">
+      <DialogContent class="max-w-3xl">
+        <DialogHeader>
+          <DialogTitle>{{ t("damengJobAdmin.sqlPreview") }}</DialogTitle>
+        </DialogHeader>
+        <pre class="max-h-[50vh] overflow-auto rounded-md border bg-muted/30 p-3 text-xs"><code>{{ pendingSql }}</code></pre>
+        <DialogFooter>
+          <Button variant="outline" @click="previewDialogOpen = false">{{ t("common.cancel") }}</Button>
+          <Button :variant="pendingDanger ? 'destructive' : 'default'" :disabled="applying" @click="applyPendingSql">
+            <Loader2 v-if="applying" class="mr-1 h-3.5 w-3.5 animate-spin" />
+            {{ t("damengJobAdmin.applySql") }}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/admin/DatabaseUserAdmin.vue b/apps/desktop/src/components/admin/DatabaseUserAdmin.vue
new file mode 100644
index 0000000..e23af1c
--- /dev/null
+++ b/apps/desktop/src/components/admin/DatabaseUserAdmin.vue
@@ -0,0 +1,557 @@
+<script setup lang="ts">
+import { computed, onMounted, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { AlertTriangle, Check, KeyRound, Lock, Loader2, Plus, RefreshCcw, Search, ShieldCheck, Trash2, Unlock, UserRound } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import PasswordInput from "@/components/ui/PasswordInput.vue";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useToast } from "@/composables/useToast";
+import { useSqlHighlighter } from "@/composables/useSqlHighlighter";
+import type { ConnectionConfig } from "@/types/database";
+import * as api from "@/lib/backend/api";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import { grantsFromQueryResult, getDatabaseUserAdminProvider, supportsDatabaseUserAdmin, type DatabaseUserIdentity, type PrivilegeScope } from "@/lib/database/databaseUserAdmin";
+
+const props = defineProps<{
+  connection: ConnectionConfig;
+}>();
+
+const { t } = useI18n();
+const connectionStore = useConnectionStore();
+const { toast } = useToast();
+const { highlight } = useSqlHighlighter();
+
+const users = ref<DatabaseUserIdentity[]>([]);
+const selectedUserKey = ref("");
+const grants = ref<string[]>([]);
+const search = ref("");
+const loadingUsers = ref(false);
+const loadingGrants = ref(false);
+const applying = ref(false);
+const loadError = ref("");
+const grantError = ref("");
+
+const createDialogOpen = ref(false);
+const passwordDialogOpen = ref(false);
+const sqlDialogOpen = ref(false);
+const pendingSql = ref("");
+const pendingDanger = ref(false);
+const pendingAfterApply = ref<(() => Promise<void>) | undefined>();
+
+const createUser = ref("app_user");
+const createHost = ref("%");
+const createPassword = ref("");
+const newPassword = ref("");
+const privilegeDatabase = ref(props.connection.database || "*");
+const privilegeTable = ref("*");
+const privilegeScope = ref<PrivilegeScope>("mysql");
+const privilegeRole = ref("");
+const grantOption = ref(false);
+const selectedPrivileges = ref<string[]>(["SELECT"]);
+const createCanLogin = ref(true);
+
+const supported = computed(() => supportsDatabaseUserAdmin(props.connection.db_type));
+const provider = computed(() => getDatabaseUserAdminProvider(props.connection.db_type));
+const isPostgres = computed(() => provider.value?.dialect === "postgres");
+const selectedUser = computed(() => users.value.find((user) => userKey(user) === selectedUserKey.value));
+const filteredUsers = computed(() => {
+  const query = search.value.trim().toLowerCase();
+  if (!query) return users.value;
+  return users.value.filter((user) => userLabel(user).toLowerCase().includes(query));
+});
+const selectedPrivilegeSet = computed(() => new Set(selectedPrivileges.value));
+const availablePrivileges = computed(() => provider.value?.privilegesForScope(privilegeScope.value) ?? []);
+const hasPrivilegePicker = computed(() => privilegeScope.value !== "role");
+const loginDisableLabel = computed(() => (isPostgres.value ? t("userAdmin.disableLogin") : t("userAdmin.lock")));
+const loginEnableLabel = computed(() => (isPostgres.value ? t("userAdmin.enableLogin") : t("userAdmin.unlock")));
+const createNameLabel = computed(() => (isPostgres.value ? t("userAdmin.roleName") : t("userAdmin.username")));
+const selectedDetail = computed(() => {
+  const user = selectedUser.value;
+  return user ? provider.value?.detail(user) || "" : "";
+});
+const grantsSqlText = computed(() => grants.value.join("\n") || t("userAdmin.noGrants"));
+const highlightedGrantsSql = computed(() => highlight(grantsSqlText.value));
+const highlightedPendingSql = computed(() => highlight(pendingSql.value));
+
+function userKey(user: DatabaseUserIdentity): string {
+  return `${user.user}\u0000${user.host}`;
+}
+
+function userLabel(user: DatabaseUserIdentity): string {
+  return provider.value?.label(user) ?? user.user;
+}
+
+function userDetail(user: DatabaseUserIdentity): string {
+  return provider.value?.detail(user) || "";
+}
+
+async function ensureConnection() {
+  await connectionStore.ensureConnected(props.connection.id);
+}
+
+async function loadUsers() {
+  const userProvider = provider.value;
+  if (!userProvider) return;
+  loadingUsers.value = true;
+  loadError.value = "";
+  try {
+    await ensureConnection();
+    let nextUsers: DatabaseUserIdentity[] = [];
+    try {
+      const result = await api.executeQuery(props.connection.id, "", userProvider.listUsersSql(), undefined, undefined, {
+        maxRows: 5000,
+      });
+      nextUsers = userProvider.parseUsers(result);
+    } catch (error) {
+      if (!userProvider.fallbackListUsersSql || !userProvider.parseFallbackUsers) throw error;
+      const fallback = await api.executeQuery(props.connection.id, "", userProvider.fallbackListUsersSql(), undefined, undefined, {
+        maxRows: 5000,
+      });
+      nextUsers = userProvider.parseFallbackUsers(fallback);
+    }
+    users.value = nextUsers;
+    if (!selectedUser.value) selectedUserKey.value = nextUsers[0] ? userKey(nextUsers[0]) : "";
+  } catch (error: any) {
+    loadError.value = error?.message || String(error);
+  } finally {
+    loadingUsers.value = false;
+  }
+}
+
+async function loadGrants() {
+  const user = selectedUser.value;
+  const userProvider = provider.value;
+  if (!user || !userProvider) {
+    grants.value = [];
+    return;
+  }
+  loadingGrants.value = true;
+  grantError.value = "";
+  try {
+    const result = await api.executeQuery(props.connection.id, "", userProvider.showGrantsSql(user), undefined, undefined, {
+      maxRows: 1000,
+    });
+    grants.value = grantsFromQueryResult(result);
+  } catch (error: any) {
+    grantError.value = error?.message || String(error);
+    grants.value = [];
+  } finally {
+    loadingGrants.value = false;
+  }
+}
+
+function selectUser(user: DatabaseUserIdentity) {
+  selectedUserKey.value = userKey(user);
+}
+
+function togglePrivilege(privilege: string) {
+  const set = new Set(selectedPrivileges.value);
+  if (set.has(privilege)) set.delete(privilege);
+  else set.add(privilege);
+  selectedPrivileges.value = Array.from(set);
+}
+
+function previewSql(sql: string, options: { danger?: boolean; afterApply?: () => Promise<void> } = {}) {
+  pendingSql.value = sql;
+  pendingDanger.value = !!options.danger;
+  pendingAfterApply.value = options.afterApply;
+  sqlDialogOpen.value = true;
+}
+
+async function applyPendingSql() {
+  if (!pendingSql.value.trim()) return;
+  applying.value = true;
+  try {
+    const result = await executeWithProductionSqlGuard({
+      connection: props.connection,
+      database: "",
+      sql: pendingSql.value,
+      source: t("production.sourceAdmin"),
+      execute: () => api.executeMulti(props.connection.id, "", pendingSql.value, undefined, undefined, { maxRows: 1000 }),
+    });
+    if (!result) return;
+    toast(t("userAdmin.applySuccess"), 2500);
+    sqlDialogOpen.value = false;
+    await (pendingAfterApply.value?.() ?? Promise.resolve());
+    await loadUsers();
+    await loadGrants();
+  } catch (error: any) {
+    toast(t("userAdmin.applyFailed", { message: error?.message || String(error) }), 5000);
+  } finally {
+    applying.value = false;
+  }
+}
+
+function previewCreateUser() {
+  const userProvider = provider.value;
+  if (!userProvider) return;
+  if (!createUser.value.trim() || !createPassword.value) return;
+  previewSql(
+    userProvider.createUserSql({
+      user: createUser.value.trim(),
+      host: createHost.value.trim() || "%",
+      password: createPassword.value,
+      canLogin: createCanLogin.value,
+    }),
+    {
+      afterApply: async () => {
+        createDialogOpen.value = false;
+        createPassword.value = "";
+      },
+    },
+  );
+}
+
+function previewPasswordChange() {
+  const user = selectedUser.value;
+  const userProvider = provider.value;
+  if (!user || !userProvider || !newPassword.value) return;
+  previewSql(userProvider.alterPasswordSql(user, newPassword.value), {
+    danger: true,
+    afterApply: async () => {
+      passwordDialogOpen.value = false;
+      newPassword.value = "";
+    },
+  });
+}
+
+function previewDropUser() {
+  const user = selectedUser.value;
+  const userProvider = provider.value;
+  if (!user || !userProvider) return;
+  previewSql(userProvider.dropUserSql(user), { danger: true });
+}
+
+function previewLoginChange(enabled: boolean) {
+  const user = selectedUser.value;
+  const userProvider = provider.value;
+  if (!user || !userProvider) return;
+  previewSql(userProvider.alterLoginSql(user, enabled), { danger: true });
+}
+
+function previewGrant() {
+  const user = selectedUser.value;
+  const userProvider = provider.value;
+  if (!user || !userProvider || (privilegeScope.value === "role" && !privilegeRole.value.trim())) return;
+  previewSql(
+    userProvider.grantPrivilegesSql({
+      user,
+      privileges: selectedPrivileges.value,
+      database: privilegeDatabase.value,
+      table: privilegeTable.value,
+      grantOption: grantOption.value,
+      scope: privilegeScope.value,
+      role: privilegeRole.value,
+    }),
+  );
+}
+
+function previewRevoke() {
+  const user = selectedUser.value;
+  const userProvider = provider.value;
+  if (!user || !userProvider || (privilegeScope.value === "role" && !privilegeRole.value.trim())) return;
+  previewSql(
+    userProvider.revokePrivilegesSql({
+      user,
+      privileges: selectedPrivileges.value,
+      database: privilegeDatabase.value,
+      table: privilegeTable.value,
+      scope: privilegeScope.value,
+      role: privilegeRole.value,
+    }),
+    { danger: true },
+  );
+}
+
+function resetPrivilegeDefaults(scope: PrivilegeScope) {
+  const userProvider = provider.value;
+  if (!userProvider) return;
+  selectedPrivileges.value = userProvider.defaultPrivilegesForScope(scope);
+  if (userProvider.dialect === "postgres") {
+    if (scope === "database") privilegeDatabase.value = props.connection.database || "postgres";
+    if (scope === "schema" || scope === "table") privilegeDatabase.value = "public";
+    if (scope === "table") privilegeTable.value = "*";
+  }
+}
+
+watch(
+  () => selectedUserKey.value,
+  () => void loadGrants(),
+);
+
+watch(
+  () => props.connection.id,
+  () => {
+    users.value = [];
+    selectedUserKey.value = "";
+    grants.value = [];
+    privilegeScope.value = provider.value?.defaultScope ?? "mysql";
+    resetPrivilegeDefaults(privilegeScope.value);
+    void loadUsers();
+  },
+);
+
+watch(
+  () => provider.value?.dialect,
+  () => {
+    privilegeScope.value = provider.value?.defaultScope ?? "mysql";
+    resetPrivilegeDefaults(privilegeScope.value);
+  },
+  { immediate: true },
+);
+
+watch(
+  () => privilegeScope.value,
+  (scope) => resetPrivilegeDefaults(scope),
+);
+
+onMounted(loadUsers);
+</script>
+
+<template>
+  <div class="flex h-full min-h-0 flex-col bg-background">
+    <div class="flex h-11 shrink-0 items-center gap-2 border-b bg-muted/20 px-3">
+      <div class="flex min-w-0 items-center gap-2">
+        <ShieldCheck class="h-4 w-4 text-primary" />
+        <div class="truncate text-sm font-semibold">{{ t("userAdmin.title") }}</div>
+        <Badge variant="outline" class="h-5 rounded-md px-1.5 text-[11px]">{{ connection.name }}</Badge>
+      </div>
+      <div class="ml-auto flex items-center gap-1.5">
+        <Button variant="outline" size="sm" class="h-7 gap-1.5 px-2 text-xs" @click="loadUsers">
+          <Loader2 v-if="loadingUsers" class="h-3.5 w-3.5 animate-spin" />
+          <RefreshCcw v-else class="h-3.5 w-3.5" />
+          {{ t("grid.refresh") }}
+        </Button>
+        <Button size="sm" class="h-7 gap-1.5 px-2 text-xs" :disabled="!supported" @click="createDialogOpen = true">
+          <Plus class="h-3.5 w-3.5" />
+          {{ t("userAdmin.newUser") }}
+        </Button>
+      </div>
+    </div>
+
+    <div v-if="!supported" class="flex flex-1 items-center justify-center px-6 text-center text-sm text-muted-foreground">
+      {{ t("userAdmin.unsupported") }}
+    </div>
+
+    <div v-else class="grid min-h-0 flex-1 grid-cols-[280px_minmax(0,1fr)]">
+      <aside class="flex min-h-0 flex-col border-r bg-muted/10">
+        <div class="flex h-12 items-center border-b px-2">
+          <div class="flex h-8 items-center gap-2 rounded-md border bg-background px-2">
+            <Search class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+            <input v-model="search" class="min-w-0 flex-1 bg-transparent text-xs outline-none placeholder:text-muted-foreground" :placeholder="t('userAdmin.searchUser')" />
+          </div>
+        </div>
+        <div class="min-h-0 flex-1 overflow-auto">
+          <div v-if="loadingUsers" class="flex items-center gap-2 px-3 py-4 text-xs text-muted-foreground">
+            <Loader2 class="h-3.5 w-3.5 animate-spin" />
+            {{ t("userAdmin.loadingUsers") }}
+          </div>
+          <div v-else-if="loadError" class="px-3 py-4 text-xs text-destructive">{{ loadError }}</div>
+          <button
+            v-for="user in filteredUsers"
+            :key="userKey(user)"
+            type="button"
+            class="grid w-full grid-cols-[1.5rem_minmax(0,1fr)] items-center gap-2 border-b px-3 py-2 text-left text-xs hover:bg-accent"
+            :class="{ 'bg-primary/10 text-primary': userKey(user) === selectedUserKey }"
+            @click="selectUser(user)"
+          >
+            <UserRound class="h-4 w-4" />
+            <span class="min-w-0">
+              <span class="block truncate font-medium">{{ userLabel(user) || t("userAdmin.anonymous") }}</span>
+              <span v-if="userDetail(user)" class="mt-1 inline-flex max-w-full rounded-full border bg-muted/40 px-1.5 py-0.5 text-[10px] leading-none text-muted-foreground">
+                <span class="truncate">{{ userDetail(user) }}</span>
+              </span>
+            </span>
+          </button>
+          <div v-if="!loadingUsers && !loadError && filteredUsers.length === 0" class="px-3 py-8 text-center text-xs text-muted-foreground">
+            {{ t("grid.noSearchResults") }}
+          </div>
+        </div>
+      </aside>
+
+      <main class="flex min-h-0 flex-col">
+        <div v-if="selectedUser" class="flex h-12 shrink-0 items-center gap-3 border-b px-4">
+          <div class="flex h-8 w-8 items-center justify-center rounded-md bg-primary/10 text-primary">
+            <UserRound class="h-4 w-4" />
+          </div>
+          <div class="flex min-w-0 items-center gap-2">
+            <div class="truncate text-sm font-semibold">{{ userLabel(selectedUser) }}</div>
+            <Badge v-if="selectedDetail" variant="outline" class="h-5 max-w-[180px] rounded-full px-2 py-0 text-[10px] font-normal">
+              <span class="truncate">{{ selectedDetail }}</span>
+            </Badge>
+          </div>
+          <div class="ml-auto flex items-center gap-1.5">
+            <Button variant="outline" size="sm" class="h-7 gap-1.5 px-2 text-xs" @click="passwordDialogOpen = true">
+              <KeyRound class="h-3.5 w-3.5" />
+              {{ t("userAdmin.changePassword") }}
+            </Button>
+            <Button variant="outline" size="sm" class="h-7 gap-1.5 px-2 text-xs" @click="previewLoginChange(false)">
+              <Lock class="h-3.5 w-3.5" />
+              {{ loginDisableLabel }}
+            </Button>
+            <Button variant="outline" size="sm" class="h-7 gap-1.5 px-2 text-xs" @click="previewLoginChange(true)">
+              <Unlock class="h-3.5 w-3.5" />
+              {{ loginEnableLabel }}
+            </Button>
+            <Button variant="destructive" size="sm" class="h-7 gap-1.5 px-2 text-xs" @click="previewDropUser">
+              <Trash2 class="h-3.5 w-3.5" />
+              {{ t("userAdmin.dropUser") }}
+            </Button>
+          </div>
+        </div>
+
+        <div v-if="selectedUser" class="grid min-h-0 flex-1 grid-cols-[minmax(0,1fr)_320px]">
+          <section class="flex min-h-0 flex-col border-r">
+            <div class="flex h-9 shrink-0 items-center gap-2 border-b bg-muted/20 px-3 text-xs font-medium">
+              <ShieldCheck class="h-3.5 w-3.5" />
+              {{ t("userAdmin.grants") }}
+            </div>
+            <div class="min-h-0 flex-1 overflow-auto p-3">
+              <div v-if="loadingGrants" class="flex items-center gap-2 text-xs text-muted-foreground">
+                <Loader2 class="h-3.5 w-3.5 animate-spin" />
+                {{ t("userAdmin.loadingGrants") }}
+              </div>
+              <div v-else-if="grantError" class="text-xs text-destructive">{{ grantError }}</div>
+              <pre v-else class="min-h-full whitespace-pre-wrap rounded-md bg-muted/30 p-3 font-mono text-xs leading-5 text-foreground" v-html="highlightedGrantsSql" />
+            </div>
+          </section>
+
+          <aside class="flex min-h-0 flex-col bg-muted/10">
+            <div class="border-b p-3">
+              <div class="text-xs font-semibold">{{ t("userAdmin.privilegeEditor") }}</div>
+              <div class="mt-1 text-[11px] leading-4 text-muted-foreground">{{ t("userAdmin.privilegeHint") }}</div>
+            </div>
+            <div class="min-h-0 flex-1 overflow-auto p-3">
+              <template v-if="isPostgres">
+                <label class="mb-2 block text-xs font-medium">{{ t("userAdmin.scope") }}</label>
+                <Select v-model="privilegeScope">
+                  <SelectTrigger class="mb-3 h-8 w-full text-xs">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent position="popper">
+                    <SelectItem value="database">{{ t("userAdmin.scopeDatabase") }}</SelectItem>
+                    <SelectItem value="schema">{{ t("userAdmin.scopeSchema") }}</SelectItem>
+                    <SelectItem value="table">{{ t("userAdmin.scopeTable") }}</SelectItem>
+                    <SelectItem value="role">{{ t("userAdmin.scopeRole") }}</SelectItem>
+                  </SelectContent>
+                </Select>
+              </template>
+
+              <template v-if="privilegeScope === 'role'">
+                <label class="mb-2 block text-xs font-medium">{{ t("userAdmin.memberRole") }}</label>
+                <Input v-model="privilegeRole" class="mb-3 h-8 text-xs" :placeholder="t('userAdmin.memberRole')" />
+              </template>
+              <template v-else>
+                <label class="mb-2 block text-xs font-medium">
+                  {{ isPostgres && privilegeScope !== "database" ? t("userAdmin.schema") : t("userAdmin.database") }}
+                </label>
+                <Input v-model="privilegeDatabase" class="mb-3 h-8 text-xs" :placeholder="isPostgres ? 'public' : '*'" />
+                <template v-if="!isPostgres || privilegeScope === 'table'">
+                  <label class="mb-2 block text-xs font-medium">{{ t("userAdmin.table") }}</label>
+                  <Input v-model="privilegeTable" class="mb-3 h-8 text-xs" placeholder="*" />
+                </template>
+              </template>
+
+              <div v-if="hasPrivilegePicker" class="mb-2 text-xs font-medium">{{ t("userAdmin.privileges") }}</div>
+              <div v-if="hasPrivilegePicker" class="grid grid-cols-2 gap-1.5">
+                <button
+                  v-for="privilege in availablePrivileges"
+                  :key="privilege"
+                  type="button"
+                  class="flex h-7 items-center gap-1.5 rounded-md border px-2 text-left text-[11px] hover:bg-accent"
+                  :class="selectedPrivilegeSet.has(privilege) ? 'border-primary bg-primary/10 text-primary' : 'bg-background'"
+                  @click="togglePrivilege(privilege)"
+                >
+                  <span class="flex h-3.5 w-3.5 items-center justify-center rounded border" :class="selectedPrivilegeSet.has(privilege) ? 'border-primary bg-primary text-primary-foreground' : 'border-border'">
+                    <Check v-if="selectedPrivilegeSet.has(privilege)" class="h-2.5 w-2.5" />
+                  </span>
+                  <span class="truncate">{{ privilege }}</span>
+                </button>
+              </div>
+              <label class="mt-3 flex items-center gap-2 text-xs">
+                <input v-model="grantOption" type="checkbox" class="h-3.5 w-3.5 accent-primary" />
+                {{ privilegeScope === "role" ? t("userAdmin.adminOption") : t("userAdmin.grantOption") }}
+              </label>
+            </div>
+            <div class="flex shrink-0 items-center justify-end gap-2 border-t p-3">
+              <Button variant="outline" size="sm" class="h-7 px-2 text-xs" @click="previewRevoke">
+                {{ t("userAdmin.revoke") }}
+              </Button>
+              <Button size="sm" class="h-7 px-2 text-xs" @click="previewGrant">
+                {{ t("userAdmin.grant") }}
+              </Button>
+            </div>
+          </aside>
+        </div>
+
+        <div v-else class="flex flex-1 items-center justify-center px-6 text-center text-sm text-muted-foreground">
+          {{ t("userAdmin.emptyUsers") }}
+        </div>
+      </main>
+    </div>
+
+    <Dialog v-model:open="createDialogOpen">
+      <DialogContent class="max-w-sm">
+        <DialogHeader>
+          <DialogTitle>{{ t("userAdmin.newUser") }}</DialogTitle>
+        </DialogHeader>
+        <div class="space-y-3">
+          <label class="block text-xs font-medium">{{ createNameLabel }}</label>
+          <Input v-model="createUser" />
+          <template v-if="!isPostgres">
+            <label class="block text-xs font-medium">{{ t("userAdmin.host") }}</label>
+            <Input v-model="createHost" />
+          </template>
+          <label v-else class="flex items-center gap-2 text-xs">
+            <input v-model="createCanLogin" type="checkbox" class="h-3.5 w-3.5 accent-primary" />
+            {{ t("userAdmin.allowLogin") }}
+          </label>
+          <label class="block text-xs font-medium">{{ t("connection.password") }}</label>
+          <PasswordInput v-model="createPassword" />
+        </div>
+        <DialogFooter>
+          <Button variant="outline" @click="createDialogOpen = false">{{ t("dangerDialog.cancel") }}</Button>
+          <Button :disabled="!createUser.trim() || !createPassword" @click="previewCreateUser">
+            {{ t("userAdmin.previewSql") }}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <Dialog v-model:open="passwordDialogOpen">
+      <DialogContent class="max-w-sm">
+        <DialogHeader>
+          <DialogTitle>{{ t("userAdmin.changePassword") }}</DialogTitle>
+        </DialogHeader>
+        <PasswordInput v-model="newPassword" :placeholder="t('userAdmin.newPassword')" />
+        <DialogFooter>
+          <Button variant="outline" @click="passwordDialogOpen = false">{{ t("dangerDialog.cancel") }}</Button>
+          <Button :disabled="!newPassword" @click="previewPasswordChange">{{ t("userAdmin.previewSql") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <Dialog v-model:open="sqlDialogOpen">
+      <DialogContent class="max-w-2xl">
+        <DialogHeader>
+          <DialogTitle class="flex items-center gap-2">
+            <AlertTriangle v-if="pendingDanger" class="h-4 w-4 text-destructive" />
+            {{ t("userAdmin.sqlPreview") }}
+          </DialogTitle>
+        </DialogHeader>
+        <pre class="max-h-[50vh] min-h-44 overflow-auto whitespace-pre-wrap rounded-md border bg-muted/30 p-3 font-mono text-xs leading-5" v-html="highlightedPendingSql" />
+        <DialogFooter>
+          <Button variant="outline" @click="sqlDialogOpen = false">{{ t("dangerDialog.cancel") }}</Button>
+          <Button :variant="pendingDanger ? 'destructive' : 'default'" :disabled="applying" @click="applyPendingSql">
+            <Loader2 v-if="applying" class="mr-1.5 h-3.5 w-3.5 animate-spin" />
+            {{ t("userAdmin.applySql") }}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/auth/LoginPage.vue b/apps/desktop/src/components/auth/LoginPage.vue
new file mode 100644
index 0000000..a081d71
--- /dev/null
+++ b/apps/desktop/src/components/auth/LoginPage.vue
@@ -0,0 +1,90 @@
+<script setup lang="ts">
+import { ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import PasswordInput from "@/components/ui/PasswordInput.vue";
+import { Lock, Loader2, ShieldCheck } from "@lucide/vue";
+import AppLogo from "@/components/icons/AppLogo.vue";
+import { apiUrl } from "@/lib/common/webPath";
+
+const props = withDefaults(
+  defineProps<{
+    setupMode?: boolean;
+  }>(),
+  { setupMode: false },
+);
+
+const emit = defineEmits<{ authenticated: [] }>();
+const { t } = useI18n();
+
+const password = ref("");
+const confirmPassword = ref("");
+const error = ref("");
+const loading = ref(false);
+
+async function submit() {
+  if (props.setupMode && password.value !== confirmPassword.value) {
+    error.value = t("auth.passwordMismatch");
+    return;
+  }
+
+  loading.value = true;
+  error.value = "";
+  try {
+    const url = apiUrl(props.setupMode ? "/api/auth/setup" : "/api/auth/login");
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ password: password.value }),
+    });
+    if (res.ok) {
+      emit("authenticated");
+    } else {
+      const text = await res.text();
+      error.value = text || t("auth.loginFailed");
+    }
+  } catch (e: any) {
+    error.value = e?.message || t("auth.connectFailed");
+  } finally {
+    loading.value = false;
+  }
+}
+</script>
+
+<template>
+  <div class="flex items-center justify-center h-screen bg-gradient-to-br from-background via-background to-blue-950/20">
+    <div class="w-[360px] space-y-8">
+      <div class="flex flex-col items-center gap-4">
+        <AppLogo class="w-20 h-20 rounded-2xl shadow-lg shadow-blue-500/20" />
+        <div class="text-center">
+          <h1 class="text-2xl font-bold tracking-tight">DBX</h1>
+          <p class="text-sm text-muted-foreground mt-1">
+            {{ setupMode ? t("auth.setupDescription") : t("auth.loginDescription") }}
+          </p>
+        </div>
+      </div>
+
+      <form class="space-y-4" @submit.prevent="submit" autocomplete="off">
+        <div v-if="setupMode" class="flex items-center justify-center gap-2 text-sm text-muted-foreground">
+          <ShieldCheck class="w-4 h-4" />
+          <span>{{ t("auth.setupTitle") }}</span>
+        </div>
+        <div class="relative">
+          <Lock class="absolute left-3 top-1/2 -translate-y-1/2 w-4 h-4 text-muted-foreground" />
+          <PasswordInput v-model="password" :placeholder="setupMode ? t('auth.newPassword') : t('auth.enterPassword')" inputClass="pl-10 h-11" autocomplete="off" autofocus />
+        </div>
+        <div v-if="setupMode" class="relative">
+          <Lock class="absolute left-3 top-1/2 -translate-y-1/2 w-4 h-4 text-muted-foreground" />
+          <PasswordInput v-model="confirmPassword" :placeholder="t('auth.confirmPassword')" inputClass="pl-10 h-11" autocomplete="off" />
+        </div>
+        <p v-if="error" class="text-sm text-destructive text-center">{{ error }}</p>
+        <Button type="submit" class="w-full h-11 text-sm font-medium" :disabled="loading || !password || (setupMode && !confirmPassword)">
+          <Loader2 v-if="loading" class="w-4 h-4 animate-spin mr-2" />
+          {{ loading ? t("auth.processing") : setupMode ? t("auth.setPassword") : t("auth.login") }}
+        </Button>
+      </form>
+
+      <p class="text-center text-xs text-muted-foreground/50">Powered by DBX</p>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/chart/QueryChart.vue b/apps/desktop/src/components/chart/QueryChart.vue
new file mode 100644
index 0000000..a31f950
--- /dev/null
+++ b/apps/desktop/src/components/chart/QueryChart.vue
@@ -0,0 +1,178 @@
+<script setup lang="ts">
+import { ref, computed, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { use } from "echarts/core";
+import { CanvasRenderer } from "echarts/renderers";
+import { LineChart, BarChart, PieChart } from "echarts/charts";
+import { GridComponent, TooltipComponent, LegendComponent } from "echarts/components";
+import VChart from "vue-echarts";
+import { BarChart3, ChevronDown } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import type { QueryResult } from "@/types/database";
+import { useTheme } from "@/composables/useTheme";
+import { axisColumnLabel, chartableColumnIndexes, toChartNumber } from "@/lib/dataGrid/chartData";
+
+use([CanvasRenderer, LineChart, BarChart, PieChart, GridComponent, TooltipComponent, LegendComponent]);
+
+const props = defineProps<{
+  result: QueryResult;
+}>();
+
+const { t } = useI18n();
+const { isDark } = useTheme();
+
+type ChartType = "line" | "bar" | "pie";
+const chartType = ref<ChartType>("bar");
+const xColumnIndex = ref(0);
+const yColumnIndexes = ref<number[]>([]);
+
+const numericColumnIndexes = computed(() => chartableColumnIndexes(props.result));
+
+const allColumnOptions = computed(() => props.result.columns.map((_, index) => ({ index, label: axisColumnLabel(props.result.columns, index) })));
+const numericColumnOptions = computed(() => numericColumnIndexes.value.map((index) => ({ index, label: axisColumnLabel(props.result.columns, index) })));
+const xColumnValue = computed({
+  get: () => String(xColumnIndex.value),
+  set: (value: string) => {
+    const index = Number(value);
+    if (Number.isInteger(index) && index >= 0 && index < props.result.columns.length) {
+      xColumnIndex.value = index;
+    }
+  },
+});
+const yColumnLabel = computed(() => {
+  if (yColumnIndexes.value.length === 0) return "0";
+  const [first, ...rest] = yColumnIndexes.value;
+  const label = axisColumnLabel(props.result.columns, first);
+  return rest.length > 0 ? `${label} +${rest.length}` : label;
+});
+
+watch(
+  () => props.result,
+  () => {
+    const cols = props.result.columns;
+    const numCols = numericColumnIndexes.value;
+    xColumnIndex.value = cols.findIndex((_, index) => !numCols.includes(index));
+    if (xColumnIndex.value < 0) xColumnIndex.value = cols.length > 0 ? 0 : -1;
+    yColumnIndexes.value = numCols.length > 0 ? [numCols[0]] : [];
+  },
+  { immediate: true },
+);
+
+function toggleYColumn(index: number) {
+  const idx = yColumnIndexes.value.indexOf(index);
+  if (idx >= 0) {
+    yColumnIndexes.value = yColumnIndexes.value.filter((selected) => selected !== index);
+  } else {
+    yColumnIndexes.value = [...yColumnIndexes.value, index];
+  }
+}
+
+const chartOption = computed(() => {
+  const xIdx = xColumnIndex.value;
+  if (xIdx < 0 || yColumnIndexes.value.length === 0) return null;
+
+  const xData = props.result.rows.map((row) => String(row[xIdx] ?? ""));
+
+  if (chartType.value === "pie") {
+    const yIdx = yColumnIndexes.value[0];
+    if (yIdx < 0) return null;
+    return {
+      tooltip: { trigger: "item" },
+      legend: { bottom: 0, textStyle: { color: isDark.value ? "#ccc" : "#333" } },
+      series: [
+        {
+          type: "pie",
+          radius: ["30%", "60%"],
+          data: xData.map((name, i) => ({
+            name,
+            value: toChartNumber(props.result.rows[i][yIdx]) ?? 0,
+          })),
+        },
+      ],
+    };
+  }
+
+  const yIndices = yColumnIndexes.value.filter((index) => index >= 0 && index < props.result.columns.length);
+
+  return {
+    tooltip: { trigger: "axis" },
+    legend: {
+      bottom: 0,
+      textStyle: { color: isDark.value ? "#ccc" : "#333" },
+    },
+    grid: { left: 60, right: 20, top: 20, bottom: 40 },
+    xAxis: {
+      type: "category" as const,
+      data: xData,
+      axisLabel: { color: isDark.value ? "#aaa" : "#666" },
+    },
+    yAxis: {
+      type: "value" as const,
+      axisLabel: { color: isDark.value ? "#aaa" : "#666" },
+    },
+    series: yIndices.map((yIdx) => ({
+      name: axisColumnLabel(props.result.columns, yIdx),
+      type: chartType.value,
+      data: props.result.rows.map((row) => toChartNumber(row[yIdx]) ?? 0),
+      smooth: chartType.value === "line",
+    })),
+  };
+});
+
+const hasData = computed(() => props.result.rows.length > 0 && numericColumnIndexes.value.length > 0);
+</script>
+
+<template>
+  <div class="h-full flex flex-col">
+    <div v-if="!hasData" class="flex-1 flex flex-col items-center justify-center gap-2 text-muted-foreground text-sm">
+      <BarChart3 class="h-10 w-10 opacity-30" />
+      <span>{{ t("chart.noNumericData") }}</span>
+    </div>
+    <template v-else>
+      <div class="h-9 shrink-0 border-b bg-muted/20 px-3 flex items-center gap-3 text-xs">
+        <div class="flex items-center gap-1.5">
+          <span class="text-muted-foreground">{{ t("chart.type") }}</span>
+          <div class="flex gap-0.5">
+            <Button v-for="ct in ['bar', 'line', 'pie'] as ChartType[]" :key="ct" size="sm" :variant="chartType === ct ? 'secondary' : 'ghost'" class="h-6 px-2 text-xs" @click="chartType = ct">
+              {{ t(`chart.${ct}`) }}
+            </Button>
+          </div>
+        </div>
+        <span class="h-4 w-px bg-border" />
+        <div class="flex items-center gap-1.5">
+          <span class="text-muted-foreground">X</span>
+          <Select v-model="xColumnValue">
+            <SelectTrigger class="h-6 w-auto max-w-40 border-0 bg-transparent px-1 text-xs shadow-none focus:ring-0">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem v-for="col in allColumnOptions" :key="col.index" :value="String(col.index)">{{ col.label }}</SelectItem>
+            </SelectContent>
+          </Select>
+        </div>
+        <span class="h-4 w-px bg-border" />
+        <div class="flex items-center gap-1.5">
+          <span class="text-muted-foreground">Y</span>
+          <DropdownMenu>
+            <DropdownMenuTrigger as-child>
+              <Button variant="ghost" size="sm" class="h-6 max-w-48 gap-1 px-2 text-xs">
+                <span class="truncate">{{ yColumnLabel }}</span>
+                <ChevronDown class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+              </Button>
+            </DropdownMenuTrigger>
+            <DropdownMenuContent class="w-56" align="start" @close-auto-focus.prevent>
+              <DropdownMenuCheckboxItem v-for="col in numericColumnOptions" :key="col.index" :checked="yColumnIndexes.includes(col.index)" class="text-xs" @select.prevent @click="toggleYColumn(col.index)">
+                <span class="truncate">{{ col.label }}</span>
+              </DropdownMenuCheckboxItem>
+            </DropdownMenuContent>
+          </DropdownMenu>
+        </div>
+      </div>
+      <div class="flex-1 min-h-0 p-2">
+        <VChart v-if="chartOption" :option="chartOption" autoresize class="h-full w-full" />
+      </div>
+    </template>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/common/ElasticsearchJsonResponsePanel.vue b/apps/desktop/src/components/common/ElasticsearchJsonResponsePanel.vue
new file mode 100644
index 0000000..73e24c1
--- /dev/null
+++ b/apps/desktop/src/components/common/ElasticsearchJsonResponsePanel.vue
@@ -0,0 +1,120 @@
+<script setup lang="ts">
+import { computed, nextTick, onMounted, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Code2, Copy } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { useToast } from "@/composables/useToast";
+import { useTheme } from "@/composables/useTheme";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { parseJsonPreservingLargeNumbers } from "@/lib/common/safeJsonFormat";
+import { createShikiJsonHighlighter, type JsonHighlighter } from "@/lib/common/shikiJsonHighlighter";
+import JsonTree from "./JsonTree.vue";
+
+const props = defineProps<{
+  status: number;
+  body: string;
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+const { isDark } = useTheme();
+const responseView = ref<"raw" | "json">("json");
+const jsonTreeRef = ref<{ refresh: () => void }>();
+const jsonHighlighter = ref<JsonHighlighter>();
+
+const parsedBody = computed(() => {
+  try {
+    return { valid: true, value: parseJsonPreservingLargeNumbers(props.body) };
+  } catch {
+    return { valid: false, value: null };
+  }
+});
+
+const statusClass = computed(() => {
+  if (props.status >= 500) return "border-destructive/40 bg-destructive/10 text-destructive";
+  if (props.status >= 400) return "border-amber-500/40 bg-amber-500/10 text-amber-700 dark:text-amber-300";
+  if (props.status >= 300) return "border-sky-500/40 bg-sky-500/10 text-sky-700 dark:text-sky-300";
+  return "border-emerald-500/40 bg-emerald-500/10 text-emerald-700 dark:text-emerald-300";
+});
+
+const statusLabel = computed(() => `HTTP ${props.status}`);
+const jsonAppearance = computed(() => (isDark.value ? "dark" : "light"));
+
+watch(
+  () => props.body,
+  () => {
+    responseView.value = parsedBody.value.valid ? "json" : "raw";
+  },
+  { immediate: true },
+);
+
+watch(responseView, (view) => {
+  if (view === "json") void nextTick(() => jsonTreeRef.value?.refresh());
+});
+
+async function copyResponse() {
+  try {
+    await copyToClipboard(props.body);
+    toast(t("grid.copied"), 2000);
+  } catch (error: any) {
+    toast(t("grid.copyFailed", { message: error?.message || String(error) }), 5000);
+  }
+}
+
+function highlightJson(value: string): string {
+  return jsonHighlighter.value?.(value, jsonAppearance.value) ?? escapeHtml(value);
+}
+
+function escapeHtml(value: string): string {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+onMounted(() => {
+  void createShikiJsonHighlighter({ appearance: () => jsonAppearance.value })
+    .then((highlight) => {
+      jsonHighlighter.value = highlight;
+    })
+    .catch(() => {
+      jsonHighlighter.value = undefined;
+    });
+});
+</script>
+
+<template>
+  <section data-elasticsearch-json-response-root class="flex h-full min-h-0 flex-col bg-background" :aria-label="t('redis.jsonView')">
+    <header class="flex min-h-11 shrink-0 items-center gap-2 border-b bg-muted/25 px-3 py-1.5 text-xs">
+      <div class="flex min-w-0 flex-1 items-center gap-2">
+        <span class="flex h-6 w-6 shrink-0 items-center justify-center rounded-md border bg-background text-muted-foreground shadow-sm" aria-hidden="true">
+          <Code2 class="h-3.5 w-3.5" />
+        </span>
+        <div class="inline-flex h-7 items-center rounded-md border bg-muted/45 p-0.5">
+          <button type="button" class="h-6 rounded-[4px] px-2 text-xs transition-colors" :class="responseView === 'raw' ? 'bg-background font-medium text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'" :aria-pressed="responseView === 'raw'" @click="responseView = 'raw'">
+            {{ t("redis.rawContent") }}
+          </button>
+          <button
+            type="button"
+            class="h-6 rounded-[4px] px-2 text-xs transition-colors"
+            :class="responseView === 'json' ? 'bg-background font-medium text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+            :aria-pressed="responseView === 'json'"
+            :disabled="!parsedBody.valid"
+            @click="responseView = 'json'"
+          >
+            {{ t("redis.jsonView") }}
+          </button>
+        </div>
+      </div>
+      <span class="shrink-0 rounded-full border px-2 py-0.5 font-mono text-[11px] font-medium tabular-nums" :class="statusClass" role="status" :aria-label="statusLabel">
+        {{ statusLabel }}
+      </span>
+      <Button variant="ghost" size="icon" class="h-7 w-7 shrink-0" :title="t('grid.copyJson')" :aria-label="t('grid.copyJson')" @click="copyResponse">
+        <Copy class="h-3.5 w-3.5" />
+      </Button>
+    </header>
+    <div class="min-h-0 flex-1 overflow-hidden bg-background p-4">
+      <pre v-show="responseView === 'raw' || !parsedBody.valid" class="m-0 h-full overflow-auto bg-transparent p-0 font-mono text-sm leading-6 whitespace-pre-wrap break-words">{{ body }}</pre>
+      <div v-if="parsedBody.valid" v-show="responseView === 'json'" class="h-full min-h-0">
+        <JsonTree ref="jsonTreeRef" :value="parsedBody.value" :highlight-json="highlightJson" :virtualized="true" class="dbx-editor-font-family text-sm leading-6" />
+      </div>
+    </div>
+  </section>
+</template>
diff --git a/apps/desktop/src/components/common/JsonTree.vue b/apps/desktop/src/components/common/JsonTree.vue
new file mode 100644
index 0000000..718a490
--- /dev/null
+++ b/apps/desktop/src/components/common/JsonTree.vue
@@ -0,0 +1,317 @@
+<script setup lang="ts">
+import { computed, defineComponent, h, nextTick, ref, shallowRef, watch, type VNodeChild } from "vue";
+import { DynamicScroller, DynamicScrollerItem } from "vue-virtual-scroller";
+import { ChevronDown, ChevronRight } from "@lucide/vue";
+import { createJsonTreeRoot, getJsonTreeChildren, getVisibleJsonTreeNodes, isJsonTreeContainer, isJsonTreeInitiallyExpanded, jsonTreeContainerKind, jsonTreeContainerSummary, type JsonTreeNode } from "@/lib/common/jsonTree";
+import { isLosslessJsonNumber } from "@/lib/common/safeJsonFormat";
+
+defineOptions({ name: "JsonTree" });
+
+const props = withDefaults(
+  defineProps<{
+    value: unknown;
+    wordWrap?: boolean;
+    /** Optional Shiki-style inline highlighter retained for Redis value views. */
+    highlightJson?: (json: string) => string;
+    /** Number of expanded container levels, with the root counted as level one. */
+    initialExpandedDepth?: number;
+    /** Render only viewport rows for large, scrollable JSON responses. */
+    virtualized?: boolean;
+  }>(),
+  {
+    wordWrap: true,
+    highlightJson: undefined,
+    initialExpandedDepth: Number.POSITIVE_INFINITY,
+    virtualized: false,
+  },
+);
+
+type ExpansionMode = "default" | "all" | "none";
+type DynamicScrollerHandle = {
+  forceUpdate: (clear?: boolean) => void;
+  scrollToPosition?: (position: number) => void;
+};
+
+const expansionMode = ref<ExpansionMode>("default");
+const expansionOverrides = shallowRef(new Map<string, boolean>());
+const virtualScroller = ref<DynamicScrollerHandle>();
+
+const rootNode = computed(() => createJsonTreeRoot(props.value));
+
+function resetExpansion() {
+  expansionMode.value = "default";
+  expansionOverrides.value = new Map();
+}
+
+function expandAll() {
+  expansionMode.value = "all";
+  expansionOverrides.value = new Map();
+}
+
+function collapseAll() {
+  expansionMode.value = "none";
+  expansionOverrides.value = new Map();
+}
+
+function isNodeExpanded(node: JsonTreeNode): boolean {
+  const override = expansionOverrides.value.get(node.path);
+  if (override !== undefined) return override;
+
+  if (expansionMode.value === "all") return true;
+  if (expansionMode.value === "none") return false;
+  return isJsonTreeInitiallyExpanded(node.depth, props.initialExpandedDepth);
+}
+
+function setNodeExpanded(path: string, expanded: boolean) {
+  const next = new Map(expansionOverrides.value);
+  next.set(path, expanded);
+  expansionOverrides.value = next;
+}
+
+function toggleNode(node: JsonTreeNode) {
+  setNodeExpanded(node.path, !isNodeExpanded(node));
+}
+
+function scalarClass(value: unknown): string {
+  if (isLosslessJsonNumber(value) || typeof value === "number") return "json-tree-number";
+  if (typeof value === "string") return "json-tree-string";
+  if (typeof value === "boolean") return "json-tree-boolean";
+  if (value === null) return "json-tree-null";
+  return "json-tree-string";
+}
+
+function scalarText(value: unknown): string {
+  if (isLosslessJsonNumber(value)) return value.raw;
+  if (typeof value === "string") return JSON.stringify(value);
+  if (value === null) return "null";
+  return String(value);
+}
+
+function highlightedJson(value: string): string {
+  return props.highlightJson?.(value) ?? escapeHtml(value);
+}
+
+function escapeHtml(value: string): string {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+function nodeAccessibleLabel(node: JsonTreeNode): string {
+  // JSON Pointer paths are language-neutral and uniquely identify each toggle.
+  return node.path || "$";
+}
+
+function highlightedJsonSpan(className: string, json: string): VNodeChild {
+  if (!props.highlightJson) return h("span", { class: className }, json);
+  return h("span", { class: className, innerHTML: props.highlightJson(json) });
+}
+
+function renderJsonNode(node: JsonTreeNode): VNodeChild {
+  const containerValue = isJsonTreeContainer(node.value) ? node.value : undefined;
+  const expanded = containerValue !== undefined && isNodeExpanded(node);
+  const indent = `${node.depth * 16}px`;
+  const rowChildren: VNodeChild[] = [];
+
+  if (containerValue !== undefined) {
+    const accessibleLabel = nodeAccessibleLabel(node);
+    rowChildren.push(
+      h(
+        "button",
+        {
+          type: "button",
+          class: "json-tree-toggle",
+          "aria-expanded": expanded,
+          "aria-label": accessibleLabel,
+          title: accessibleLabel,
+          onClick: () => toggleNode(node),
+        },
+        [expanded ? h(ChevronDown, { class: "h-3.5 w-3.5", "aria-hidden": "true" }) : h(ChevronRight, { class: "h-3.5 w-3.5", "aria-hidden": "true" })],
+      ),
+    );
+  } else {
+    rowChildren.push(h("span", { class: "json-tree-spacer", "aria-hidden": "true" }));
+  }
+
+  if (node.parentKind !== "root") {
+    rowChildren.push(node.parentKind === "array" ? h("span", { class: "json-tree-index" }, `[${node.label}]`) : highlightedJsonSpan("json-tree-key", JSON.stringify(node.label)), h("span", { class: "json-tree-punctuation" }, ":"));
+  }
+
+  if (containerValue !== undefined) {
+    const kind = jsonTreeContainerKind(containerValue);
+    rowChildren.push(h("span", { class: `json-tree-bracket is-${kind}` }, kind === "array" ? "[" : "{"), h("span", { class: "json-tree-summary" }, jsonTreeContainerSummary(containerValue, expanded)), h("span", { class: `json-tree-bracket is-${kind}` }, kind === "array" ? "]" : "}"));
+  } else {
+    rowChildren.push(highlightedJsonSpan(scalarClass(node.value), scalarText(node.value)));
+  }
+
+  const children = containerValue !== undefined && expanded ? h("div", { class: "json-tree-children" }, getJsonTreeChildren(node).map(renderJsonNode)) : null;
+
+  return h("div", { key: node.path, class: "json-tree-node", "data-json-path": node.path }, [h("div", { class: "json-tree-row", style: { paddingInlineStart: indent } }, rowChildren), children]);
+}
+
+const JsonTreeRoot = defineComponent({
+  name: "JsonTreeRoot",
+  setup() {
+    return () => renderJsonNode(rootNode.value);
+  },
+});
+
+const visibleNodes = computed(() => getVisibleJsonTreeNodes(rootNode.value, isNodeExpanded));
+
+function refresh(resetScroll = false) {
+  if (!props.virtualized) return;
+  void nextTick(() => {
+    virtualScroller.value?.forceUpdate(true);
+    if (resetScroll) virtualScroller.value?.scrollToPosition?.(0);
+  });
+}
+
+watch([() => props.value, () => props.initialExpandedDepth], () => {
+  resetExpansion();
+  refresh(true);
+});
+
+defineExpose({ expandAll, collapseAll, resetExpansion, refresh });
+</script>
+
+<template>
+  <div class="json-tree" :class="{ 'is-nowrap': !wordWrap, 'is-virtualized': virtualized }">
+    <!-- Virtual rows keep a fully expanded response responsive even when it has thousands of nodes. -->
+    <DynamicScroller v-if="virtualized" ref="virtualScroller" :items="visibleNodes" :min-item-size="24" :buffer="600" key-field="path" class="json-tree-scroller">
+      <template #default="{ item: node, active, index }">
+        <DynamicScrollerItem :item="node" :active="active" :size-dependencies="[wordWrap, node.path, node.label, scalarText(node.value), isNodeExpanded(node)]" :data-index="index">
+          <div class="json-tree-node" :data-json-path="node.path">
+            <div class="json-tree-row" :style="{ paddingInlineStart: `${node.depth * 16}px` }">
+              <button v-if="isJsonTreeContainer(node.value)" type="button" class="json-tree-toggle" :aria-expanded="isNodeExpanded(node)" :aria-label="nodeAccessibleLabel(node)" :title="nodeAccessibleLabel(node)" @click="toggleNode(node)">
+                <ChevronDown v-if="isNodeExpanded(node)" class="h-3.5 w-3.5" aria-hidden="true" />
+                <ChevronRight v-else class="h-3.5 w-3.5" aria-hidden="true" />
+              </button>
+              <span v-else class="json-tree-spacer" aria-hidden="true" />
+
+              <template v-if="node.parentKind !== 'root'">
+                <span v-if="node.parentKind === 'array'" class="json-tree-index">[{{ node.label }}]</span>
+                <span v-else class="json-tree-key" v-html="highlightedJson(JSON.stringify(node.label))" />
+                <span class="json-tree-punctuation">:</span>
+              </template>
+
+              <template v-if="isJsonTreeContainer(node.value)">
+                <span class="json-tree-bracket" :class="`is-${jsonTreeContainerKind(node.value)}`">{{ jsonTreeContainerKind(node.value) === "array" ? "[" : "{" }}</span>
+                <span class="json-tree-summary">{{ jsonTreeContainerSummary(node.value, isNodeExpanded(node)) }}</span>
+                <span class="json-tree-bracket" :class="`is-${jsonTreeContainerKind(node.value)}`">{{ jsonTreeContainerKind(node.value) === "array" ? "]" : "}" }}</span>
+              </template>
+              <span v-else :class="scalarClass(node.value)" v-html="highlightedJson(scalarText(node.value))" />
+            </div>
+          </div>
+        </DynamicScrollerItem>
+      </template>
+    </DynamicScroller>
+    <JsonTreeRoot v-else />
+  </div>
+</template>
+
+<style>
+.json-tree {
+  --json-tree-key: #1d4ed8;
+  --json-tree-string: #15803d;
+  --json-tree-number: #b45309;
+  --json-tree-boolean: #7c3aed;
+  --json-tree-null: #64748b;
+
+  color: hsl(var(--foreground));
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+
+.json-tree.is-virtualized {
+  height: 100%;
+  min-height: 0;
+}
+
+.json-tree-scroller {
+  height: 100%;
+  min-height: 0;
+  overflow: auto;
+}
+
+.json-tree.is-nowrap {
+  white-space: pre;
+  overflow-wrap: normal;
+}
+
+.json-tree-row {
+  display: flex;
+  min-height: 24px;
+  align-items: flex-start;
+  gap: 4px;
+  border-radius: 4px;
+}
+
+.json-tree-row:hover {
+  background: hsl(var(--muted) / 0.5);
+}
+
+.json-tree-toggle {
+  margin-top: 1px;
+  display: inline-flex;
+  height: 18px;
+  width: 18px;
+  flex: 0 0 auto;
+  align-items: center;
+  justify-content: center;
+  border-radius: 3px;
+  color: hsl(var(--muted-foreground));
+}
+
+.json-tree-toggle:hover {
+  background: hsl(var(--accent));
+  color: hsl(var(--foreground));
+}
+
+.json-tree-toggle:focus-visible {
+  outline: 2px solid hsl(var(--ring));
+  outline-offset: 1px;
+}
+
+.json-tree-spacer {
+  width: 18px;
+  flex: 0 0 auto;
+}
+
+.json-tree-key {
+  color: var(--json-tree-key);
+}
+
+.json-tree-string {
+  color: var(--json-tree-string);
+}
+
+.json-tree-number {
+  color: var(--json-tree-number);
+}
+
+.json-tree-boolean {
+  color: var(--json-tree-boolean);
+}
+
+.json-tree-null {
+  color: var(--json-tree-null);
+  font-style: italic;
+}
+
+.json-tree-index,
+.json-tree-punctuation,
+.json-tree-summary {
+  color: hsl(var(--muted-foreground));
+}
+
+.json-tree-bracket {
+  color: hsl(var(--foreground));
+  font-weight: 650;
+}
+
+.dark .json-tree {
+  --json-tree-key: #93c5fd;
+  --json-tree-string: #86efac;
+  --json-tree-number: #fbbf24;
+  --json-tree-boolean: #c4b5fd;
+  --json-tree-null: #94a3b8;
+}
+</style>
diff --git a/apps/desktop/src/components/common/ProductionContextBadge.vue b/apps/desktop/src/components/common/ProductionContextBadge.vue
new file mode 100644
index 0000000..b8b693b
--- /dev/null
+++ b/apps/desktop/src/components/common/ProductionContextBadge.vue
@@ -0,0 +1,20 @@
+<script setup lang="ts">
+import { ShieldAlert } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+
+const { t } = useI18n();
+
+withDefaults(
+  defineProps<{
+    compact?: boolean;
+  }>(),
+  { compact: false },
+);
+</script>
+
+<template>
+  <span class="inline-flex h-5 shrink-0 items-center gap-1 rounded-[4px] border border-red-500/40 bg-red-500/10 px-1.5 font-mono text-[10px] font-semibold leading-none text-red-700 dark:text-red-300" :class="compact ? 'px-1' : ''" :title="t('production.title')">
+    <ShieldAlert class="h-3 w-3" aria-hidden="true" />
+    <span>PROD</span>
+  </span>
+</template>
diff --git a/apps/desktop/src/components/common/QueryErrorActions.vue b/apps/desktop/src/components/common/QueryErrorActions.vue
new file mode 100644
index 0000000..c27f385
--- /dev/null
+++ b/apps/desktop/src/components/common/QueryErrorActions.vue
@@ -0,0 +1,29 @@
+<script setup lang="ts">
+import { Bot, Wrench } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { isQueryTimeoutErrorMessage } from "@/lib/sql/queryError";
+
+const props = defineProps<{
+  errorMessage: string;
+  connectionId?: string;
+}>();
+
+const emit = defineEmits<{
+  changeQueryTimeout: [];
+  fixWithAi: [errorMessage: string];
+}>();
+
+const { t } = useI18n();
+</script>
+
+<template>
+  <Button v-if="connectionId && isQueryTimeoutErrorMessage(errorMessage)" variant="outline" size="sm" class="h-7 gap-1.5 px-2.5 text-xs" @click="emit('changeQueryTimeout')">
+    <Wrench class="h-3.5 w-3.5" />
+    {{ t("editor.changeQueryTimeout") }}
+  </Button>
+  <Button variant="outline" size="sm" class="h-7 gap-1.5 px-2.5 text-xs" @click="emit('fixWithAi', errorMessage)">
+    <Bot class="h-3.5 w-3.5" />
+    {{ t("ai.fixWithAi") }}
+  </Button>
+</template>
diff --git a/apps/desktop/src/components/common/QueryLoadingState.vue b/apps/desktop/src/components/common/QueryLoadingState.vue
new file mode 100644
index 0000000..5f7cbf2
--- /dev/null
+++ b/apps/desktop/src/components/common/QueryLoadingState.vue
@@ -0,0 +1,63 @@
+<script setup lang="ts">
+import { Loader2, Square } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+
+withDefaults(
+  defineProps<{
+    labelKey?: string;
+    elapsedSeconds?: number | string;
+    showCancel?: boolean;
+    cancelDisabled?: boolean;
+    cancelling?: boolean;
+    cancelLabelKey?: string;
+  }>(),
+  {
+    labelKey: "common.loading",
+    elapsedSeconds: undefined,
+    showCancel: false,
+    cancelDisabled: false,
+    cancelling: false,
+    cancelLabelKey: "toolbar.stopQuery",
+  },
+);
+
+const emit = defineEmits<{
+  cancel: [];
+}>();
+
+const { t } = useI18n();
+</script>
+
+<template>
+  <div class="flex flex-col items-center justify-center gap-3 text-muted-foreground text-sm">
+    <div class="flex items-center">
+      <Loader2 class="h-5 w-5 animate-spin mr-2" />
+      {{ t(labelKey) }}
+      <span v-if="elapsedSeconds !== undefined" class="ml-1 tabular-nums text-muted-foreground/80">· {{ elapsedSeconds }}s</span>
+    </div>
+    <Button v-if="showCancel" variant="destructive" size="sm" class="query-loading-cancel-button h-7 gap-1.5" :disabled="cancelDisabled" @click="emit('cancel')">
+      <Loader2 v-if="cancelling" class="h-3.5 w-3.5 animate-spin" />
+      <Square v-else class="h-3.5 w-3.5 fill-current" />
+      {{ t(cancelLabelKey) }}
+    </Button>
+  </div>
+</template>
+
+<style>
+.query-loading-cancel-button {
+  border: 1px solid rgba(220, 38, 38, 0.22) !important;
+  background-color: rgba(220, 38, 38, 0.08) !important;
+  color: rgb(185, 28, 28) !important;
+}
+
+.query-loading-cancel-button:hover {
+  background-color: rgba(220, 38, 38, 0.14) !important;
+}
+
+.dark .query-loading-cancel-button {
+  border-color: rgba(248, 113, 113, 0.28) !important;
+  background-color: rgba(248, 113, 113, 0.12) !important;
+  color: rgb(248, 113, 113) !important;
+}
+</style>
diff --git a/apps/desktop/src/components/config/ConfigPassphraseDialog.vue b/apps/desktop/src/components/config/ConfigPassphraseDialog.vue
new file mode 100644
index 0000000..5c3bd6e
--- /dev/null
+++ b/apps/desktop/src/components/config/ConfigPassphraseDialog.vue
@@ -0,0 +1,97 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Lock } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import PasswordInput from "@/components/ui/PasswordInput.vue";
+import { Label } from "@/components/ui/label";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+
+const props = defineProps<{
+  open: boolean;
+  mode: "export" | "import";
+  externalError?: string;
+}>();
+
+const emit = defineEmits<{
+  "update:open": [value: boolean];
+  confirm: [passphrase: string];
+}>();
+
+const { t } = useI18n();
+const dialogOpen = computed({
+  get: () => props.open,
+  set: (v) => emit("update:open", v),
+});
+
+const passphrase = ref("");
+const passphraseConfirm = ref("");
+const error = ref("");
+
+watch(
+  dialogOpen,
+  (open) => {
+    if (open) {
+      passphrase.value = "";
+      passphraseConfirm.value = "";
+      error.value = "";
+    }
+  },
+  { immediate: true },
+);
+
+function confirm() {
+  if (!passphrase.value) {
+    error.value = t("configExport.passphraseRequired");
+    return;
+  }
+  if (props.mode === "export" && passphrase.value !== passphraseConfirm.value) {
+    error.value = t("configExport.passphraseMismatch");
+    return;
+  }
+  if (props.mode === "export" && passphrase.value.length < 4) {
+    error.value = t("configExport.passphraseTooShort");
+    return;
+  }
+  emit("confirm", passphrase.value);
+}
+
+const displayError = computed(() => error.value || props.externalError || "");
+</script>
+
+<template>
+  <Dialog v-model:open="dialogOpen">
+    <DialogContent class="sm:max-w-[440px]">
+      <DialogHeader>
+        <DialogTitle class="flex items-center gap-2">
+          <Lock class="h-5 w-5" />
+          {{ mode === "export" ? t("configExport.passphraseTitle") : t("configExport.passphraseImportTitle") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="grid gap-4 py-4">
+        <p class="text-sm text-muted-foreground">
+          {{ mode === "export" ? t("configExport.passphraseExportHint") : t("configExport.passphraseImportHint") }}
+        </p>
+
+        <div class="grid gap-2">
+          <Label>{{ t("configExport.passphrase") }}</Label>
+          <PasswordInput v-model="passphrase" :placeholder="t('configExport.passphrasePlaceholder')" @keydown.enter="mode === 'import' ? confirm() : undefined" />
+        </div>
+
+        <div v-if="mode === 'export'" class="grid gap-2">
+          <Label>{{ t("configExport.passphraseConfirm") }}</Label>
+          <PasswordInput v-model="passphraseConfirm" :placeholder="t('configExport.passphraseConfirmPlaceholder')" @keydown.enter="confirm" />
+        </div>
+
+        <p v-if="displayError" class="text-sm text-destructive">{{ displayError }}</p>
+      </div>
+
+      <DialogFooter>
+        <Button @click="confirm">
+          {{ mode === "export" ? t("configExport.exportEncrypted") : t("configExport.decryptImport") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/config/DriverInstallProgressCircle.vue b/apps/desktop/src/components/config/DriverInstallProgressCircle.vue
new file mode 100644
index 0000000..96cd0b8
--- /dev/null
+++ b/apps/desktop/src/components/config/DriverInstallProgressCircle.vue
@@ -0,0 +1,18 @@
+<script setup lang="ts">
+const props = defineProps<{
+  percent: number | null;
+  title: string;
+}>();
+</script>
+
+<template>
+  <span class="relative flex h-8 w-8 shrink-0 items-center justify-center rounded-full" role="status" :aria-label="title" :title="title">
+    <svg class="absolute inset-0 h-8 w-8 -rotate-90" viewBox="0 0 32 32" aria-hidden="true">
+      <circle class="text-green-600/20" cx="16" cy="16" r="13" fill="none" stroke="currentColor" stroke-width="3" />
+      <circle class="text-green-600 transition-[stroke-dashoffset] duration-200" cx="16" cy="16" r="13" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" pathLength="100" stroke-dasharray="100" :stroke-dashoffset="100 - (props.percent ?? 0)" />
+    </svg>
+    <span class="relative z-10 font-mono text-[10px] font-semibold leading-none text-green-700 tabular-nums">
+      {{ props.percent ?? 0 }}
+    </span>
+  </span>
+</template>
diff --git a/apps/desktop/src/components/config/DriverStoreDialog.vue b/apps/desktop/src/components/config/DriverStoreDialog.vue
new file mode 100644
index 0000000..17d71dd
--- /dev/null
+++ b/apps/desktop/src/components/config/DriverStoreDialog.vue
@@ -0,0 +1,1683 @@
+<script setup lang="ts">
+import { ref, onMounted, onUnmounted, computed, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Activity, ExternalLink, Cpu, FolderOpen, FolderSync, MemoryStick, Search, Square, Trash2, Download, RotateCcw, Loader2, RefreshCw, Check, Clock3, FileUp } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Badge } from "@/components/ui/badge";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import DriverInstallProgressCircle from "@/components/config/DriverInstallProgressCircle.vue";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import { useToast } from "@/composables/useToast";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { countAvailableDriverUpdates } from "@/lib/connection/agentDriverUpdateBadge";
+import type { JdbcDriverInfo, JdbcLocalBundleInfo, JdbcMavenBundleInfo, JdbcPluginStatus } from "@/types/database";
+import * as api from "@/lib/backend/api";
+import type { AgentDriverInfo, DriverRuntimeInfo, DriverRuntimeSummary, DriverStoreUsage, JavaRuntimeConfig } from "@/lib/backend/api";
+import { formatRuntimeBytes, formatRuntimeCpu, formatRuntimeUptime, runtimeHealthClass, runtimeStatusClass, runtimeStatusDotClass } from "@/lib/connection/driverRuntimePresentation";
+import { addDriverInstallQueue, driverInstallProgressPercent, isDriverInstallProgressTarget, removeDriverInstallQueue, takeNextDriverInstallQueue, type DriverInstallProgress } from "@/lib/connection/driverInstallProgressUi";
+import { PRESTOSQL_DRIVER_DB_TYPE, prestoSqlBuiltinDriverRow, prestoSqlMavenBundle } from "@/lib/database/prestoSqlBuiltinDriver";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const isWeb = !isTauriRuntime();
+
+const props = withDefaults(
+  defineProps<{
+    updateNotificationsEnabled?: boolean;
+  }>(),
+  {
+    updateNotificationsEnabled: true,
+  },
+);
+
+const emit = defineEmits<{
+  "update-count-change": [count: number];
+}>();
+
+const driverStoreTab = ref("agent");
+
+// ──────────── Driver store path ────────────
+
+import { useSettingsStore } from "@/stores/settingsStore";
+import type { DriverStorePathInfo } from "@/lib/backend/api";
+const settingsStore = useSettingsStore();
+
+type DriverStoreDirKind = "plugin" | "agent";
+
+const legacyDriverStoreDir = computed(() => settingsStore.desktopSettings.driver_store_dir ?? null);
+const pluginStoreDir = computed(() => settingsStore.desktopSettings.plugin_store_dir ?? null);
+const agentStoreDir = computed(() => settingsStore.desktopSettings.agent_store_dir ?? null);
+const driverStoreDirMigrating = ref<DriverStoreDirKind | null>(null);
+const currentDriverStorePath = ref<DriverStorePathInfo | null>(null);
+
+async function loadDriverStorePath() {
+  if (isWeb) return;
+  try {
+    currentDriverStorePath.value = await api.getDriverStorePath();
+  } catch {
+    currentDriverStorePath.value = null;
+  }
+}
+
+function configuredDriverStoreDir(kind: DriverStoreDirKind): string | null {
+  if (kind === "plugin") {
+    return pluginStoreDir.value ?? (legacyDriverStoreDir.value ? `${legacyDriverStoreDir.value}/plugins` : null);
+  }
+  return agentStoreDir.value ?? (legacyDriverStoreDir.value ? `${legacyDriverStoreDir.value}/agents` : null);
+}
+
+function actualDriverStoreDir(kind: DriverStoreDirKind): string | null {
+  if (!currentDriverStorePath.value) return null;
+  return kind === "plugin" ? currentDriverStorePath.value.plugins_dir : currentDriverStorePath.value.agents_dir;
+}
+
+function driverStoreDirDisplay(kind: DriverStoreDirKind): string {
+  return actualDriverStoreDir(kind) ?? configuredDriverStoreDir(kind) ?? t("driverStore.driverStoreDirDefault");
+}
+
+function driverStoreTargetLabel(kind: DriverStoreDirKind): string {
+  return kind === "plugin" ? t("driverStore.pluginStoreDir") : t("driverStore.agentStoreDir");
+}
+
+const driverStorePathRows = computed(() => [
+  {
+    kind: "plugin" as const,
+    label: t("driverStore.pluginStoreDir"),
+    description: t("driverStore.pluginStoreDirDescription"),
+    display: driverStoreDirDisplay("plugin"),
+    custom: Boolean(pluginStoreDir.value || legacyDriverStoreDir.value),
+  },
+  {
+    kind: "agent" as const,
+    label: t("driverStore.agentStoreDir"),
+    description: t("driverStore.agentStoreDirDescription"),
+    display: driverStoreDirDisplay("agent"),
+    custom: Boolean(agentStoreDir.value || legacyDriverStoreDir.value),
+  },
+]);
+
+async function chooseDriverStoreDir(kind: DriverStoreDirKind) {
+  if (isWeb || driverStoreDirMigrating.value) return;
+  const { open } = await import("@tauri-apps/plugin-dialog");
+  const selected = await open({
+    title: t("driverStore.driverStoreDirDialogTitle", { target: driverStoreTargetLabel(kind) }),
+    directory: true,
+    multiple: false,
+  });
+  if (typeof selected === "string") {
+    await applyDriverStoreDir(kind, selected);
+  }
+}
+
+async function resetDriverStoreDir(kind: DriverStoreDirKind) {
+  if (driverStoreDirMigrating.value) return;
+  await applyDriverStoreDir(kind, null);
+}
+
+async function applyDriverStoreDir(kind: DriverStoreDirKind, newDir: string | null) {
+  if (driverStoreDirMigrating.value) return;
+
+  const target = driverStoreTargetLabel(kind);
+  const confirmed = window.confirm(t("driverStore.driverStoreDirConfirm", { target }));
+  if (!confirmed) return;
+
+  driverStoreDirMigrating.value = kind;
+  try {
+    const result = kind === "plugin" ? await api.setPluginStoreDir(newDir) : await api.setAgentStoreDir(newDir);
+    settingsStore.desktopSettings.driver_store_dir = result.driver_store_dir;
+    settingsStore.desktopSettings.plugin_store_dir = result.plugin_store_dir;
+    settingsStore.desktopSettings.agent_store_dir = result.agent_store_dir;
+    currentDriverStorePath.value = {
+      driver_store_dir: result.driver_store_dir,
+      plugin_store_dir: result.plugin_store_dir,
+      agent_store_dir: result.agent_store_dir,
+      plugins_dir: result.plugins_dir,
+      agents_dir: result.agents_dir,
+    };
+    toast(t("driverStore.driverStoreDirSuccess", { target }));
+    // Restart the app to use the new paths
+    const { relaunch } = await import("@tauri-apps/plugin-process");
+    relaunch();
+  } catch (e: any) {
+    toast(t("driverStore.driverStoreDirMigrationFailed", { error: e?.message || String(e) }), 5000);
+  } finally {
+    driverStoreDirMigrating.value = null;
+  }
+}
+
+// ──────────── Agent drivers ────────────
+
+const drivers = ref<AgentDriverInfo[]>([]);
+const agentDriverSearch = ref("");
+const installing = ref<string | null>(null);
+const upgradingAll = ref(false);
+const upgradingCurrent = ref("");
+const upgradingIndex = ref(0);
+const upgradingTotal = ref(0);
+const queuedDriverInstalls = ref<string[]>([]);
+const reinstallingJre = ref<string | null>(null);
+const refreshing = ref(false);
+const progress = ref<DriverInstallProgress | null>(null);
+const javaRuntimeConfig = ref<JavaRuntimeConfig>({ mode: "managed", custom_java_path: null });
+const customJavaPath = ref("");
+const savingJavaRuntime = ref(false);
+const driverStoreUsage = ref<DriverStoreUsage | null>(null);
+const clearingDownloadCache = ref(false);
+const runtimeSummary = ref<DriverRuntimeSummary | null>(null);
+const runtimeLoading = ref(false);
+const runtimeError = ref("");
+const runtimeBusy = ref<string | null>(null);
+let runtimeTimer: ReturnType<typeof setInterval> | null = null;
+const DRIVER_RUNTIME_POLL_MS = 5000;
+const OFFLINE_DRIVER_DOWNLOAD_URL = "https://dbxio.com/cn/drivers";
+
+let unlisten: (() => void) | null = null;
+const lastProgressPercent = ref<number | null>(null);
+
+const installedJres = computed(() => {
+  const jreMap = new Map<string, boolean>();
+  for (const d of drivers.value) {
+    if (driverRequiresJavaRuntime(d) && d.jre && !jreMap.has(d.jre)) {
+      jreMap.set(d.jre, d.jre_installed);
+    }
+  }
+  return [...jreMap.entries()].map(([key, installed]) => ({ key, installed })).sort((a, b) => b.key.localeCompare(a.key));
+});
+
+const progressText = computed(() => {
+  const p = progress.value;
+  if (!p) return "";
+  if (p.step === "jre-extract") return t("driverStore.progressJreExtract");
+  if (p.step === "jdbc-plugin-extract") return t("driverStore.progressJdbcPluginExtract");
+  const label = p.step === "jre" ? t("driverStore.progressDownloadJre") : p.step === "jdbc-plugin" ? t("driverStore.progressDownloadJdbcPlugin") : t("driverStore.progressDownloadDriver");
+  if (!p.total) return `${label}...`;
+  const pct = Math.round(((p.downloaded ?? 0) / p.total) * 100);
+  const dl = formatSize(p.downloaded ?? 0);
+  const total = formatSize(p.total);
+  const prefix = upgradingAll.value && upgradingCurrent.value ? `[${upgradingIndex.value}/${upgradingTotal.value}] ${upgradingCurrent.value} - ` : "";
+  return `${prefix}${label}  ${dl} / ${total}  (${pct}%)`;
+});
+
+const progressNumber = computed(() => {
+  const next = driverInstallProgressPercent(progress.value);
+  if (next !== null) {
+    lastProgressPercent.value = next;
+  }
+  return next ?? lastProgressPercent.value;
+});
+
+function resetInstallProgress() {
+  progress.value = null;
+  lastProgressPercent.value = null;
+}
+
+const updatableCount = computed(() => drivers.value.filter((d) => d.update_available).length);
+const downloadCacheBytes = computed(() => Number(driverStoreUsage.value?.download_cache_bytes || 0));
+const usageSummary = computed(() => {
+  const usage = driverStoreUsage.value;
+  if (!usage) return [];
+  return [
+    { key: "total", label: t("driverStore.usageTotalLabel"), bytes: usage.total_bytes },
+    { key: "jre", label: t("driverStore.usageManagedJre"), bytes: usage.jre_bytes },
+    { key: "agent", label: t("driverStore.usageAgentDrivers"), bytes: usage.agent_driver_bytes },
+    { key: "download-cache", label: t("driverStore.usageDownloadCache"), bytes: usage.download_cache_bytes || 0 },
+    { key: "jdbc-plugin", label: t("driverStore.usageJdbcPlugin"), bytes: usage.jdbc_plugin_bytes },
+    { key: "jdbc-driver", label: t("driverStore.usageJdbcDriverJars"), bytes: usage.jdbc_driver_bytes },
+  ];
+});
+const canClearDownloadCache = computed(() => !clearingDownloadCache.value && installing.value === null && !upgradingAll.value && reinstallingJre.value === null && downloadCacheBytes.value > 0);
+const jreUsageByKey = computed(() => {
+  const map = new Map<string, number>();
+  for (const item of driverStoreUsage.value?.jres || []) {
+    map.set(String(item.id), Number(item.bytes || 0));
+  }
+  return map;
+});
+
+function updateAgentDrivers(nextDrivers: AgentDriverInfo[]) {
+  drivers.value = nextDrivers;
+  emitDriverUpdateCount();
+}
+
+const agentTabUpdateCount = computed(() => drivers.value.filter((d) => d.update_available).length);
+const jdbcTabUpdateCount = computed(() => (jdbcPluginStatus.value?.update_available ? 1 : 0));
+
+function emitDriverUpdateCount() {
+  if (!props.updateNotificationsEnabled) {
+    emit("update-count-change", 0);
+    return;
+  }
+  emit("update-count-change", countAvailableDriverUpdates(drivers.value, jdbcPluginStatus.value));
+}
+
+function isDriverProgressActive(dbType: string): boolean {
+  return isDriverInstallProgressTarget(dbType, {
+    installing: installing.value,
+    upgradingAll: upgradingAll.value,
+    progress: progress.value,
+  });
+}
+
+function driverRequiresJavaRuntime(driver: AgentDriverInfo): boolean {
+  return driver.requires_java_runtime ?? Boolean(driver.jre);
+}
+
+function progressTitle(fallback: string): string {
+  return progressText.value || fallback;
+}
+
+function isPrestoSqlBuiltinDriver(dbType: string): boolean {
+  return dbType === PRESTOSQL_DRIVER_DB_TYPE;
+}
+
+const builtinDriverRows = computed<AgentDriverInfo[]>(() => [...drivers.value, prestoSqlBuiltinDriverRow(jdbcMavenBundles.value)]);
+
+function driverLabel(dbType: string): string {
+  return builtinDriverRows.value.find((d) => d.db_type === dbType)?.label ?? dbType;
+}
+
+function isDriverQueued(dbType: string): boolean {
+  return queuedDriverInstalls.value.includes(dbType);
+}
+
+function canInstallOrUpdateDriver(dbType: string): boolean {
+  const driver = builtinDriverRows.value.find((d) => d.db_type === dbType);
+  return Boolean(driver && (!driver.installed || driver.update_available));
+}
+
+async function openOfflineDriverDownload() {
+  if (isWeb) {
+    window.open(OFFLINE_DRIVER_DOWNLOAD_URL, "_blank", "noopener,noreferrer");
+    return;
+  }
+  const { open } = await import("@tauri-apps/plugin-shell");
+  await open(OFFLINE_DRIVER_DOWNLOAD_URL);
+}
+
+function queueDriverInstall(dbType: string) {
+  queuedDriverInstalls.value = addDriverInstallQueue(queuedDriverInstalls.value, dbType, installing.value);
+}
+
+function removeQueuedDriverInstall(dbType: string) {
+  queuedDriverInstalls.value = removeDriverInstallQueue(queuedDriverInstalls.value, dbType);
+}
+
+async function refreshAgents() {
+  updateAgentDrivers(await api.listInstalledAgents());
+  void loadDriverStoreUsage();
+}
+
+async function forceRefresh() {
+  refreshing.value = true;
+  try {
+    await api.invalidateAgentRegistryCache();
+    await refreshAgents();
+  } finally {
+    refreshing.value = false;
+  }
+}
+
+async function loadJavaRuntimeConfig() {
+  const config = await api.getAgentJavaRuntimeConfig();
+  javaRuntimeConfig.value = config;
+  customJavaPath.value = config.custom_java_path ?? "";
+}
+
+function setJavaRuntimeMode(value: any) {
+  if (value === "managed" || value === "system" || value === "custom") {
+    javaRuntimeConfig.value.mode = value;
+  }
+}
+
+async function saveJavaRuntimeConfig() {
+  savingJavaRuntime.value = true;
+  try {
+    const config = await api.setAgentJavaRuntimeConfig({
+      mode: javaRuntimeConfig.value.mode,
+      custom_java_path: javaRuntimeConfig.value.mode === "custom" ? customJavaPath.value.trim() || null : null,
+    });
+    javaRuntimeConfig.value = config;
+    customJavaPath.value = config.custom_java_path ?? "";
+    toast(t("driverStore.javaRuntimeSaved"));
+  } catch (e: any) {
+    toast(t("driverStore.javaRuntimeSaveFailed", { error: e }));
+  } finally {
+    savingJavaRuntime.value = false;
+  }
+}
+
+async function chooseCustomJavaPath() {
+  if (isWeb) return;
+  const { open } = await import("@tauri-apps/plugin-dialog");
+  const selected = await open({
+    title: t("driverStore.chooseJavaExecutable"),
+    multiple: false,
+  });
+  if (typeof selected === "string") {
+    customJavaPath.value = selected;
+  }
+}
+
+async function installDriver(dbType: string) {
+  if (installing.value !== null || upgradingAll.value) {
+    queueDriverInstall(dbType);
+    return;
+  }
+  await runDriverInstall(dbType);
+  await runQueuedDriverInstalls();
+}
+
+async function runDriverInstall(dbType: string) {
+  const label = driverLabel(dbType);
+  installing.value = dbType;
+  resetInstallProgress();
+  try {
+    if (isPrestoSqlBuiltinDriver(dbType)) {
+      if (!jdbcPluginStatus.value?.installed || !jdbcPluginStatus.value.compatible) {
+        jdbcPluginStatus.value = await api.installJdbcPlugin();
+        emitDriverUpdateCount();
+      }
+      jdbcDrivers.value = await api.installPrestoSqlJdbcDriver();
+      jdbcMavenBundles.value = await api.listJdbcMavenBundles();
+      void loadDriverStoreUsage();
+      toast(t("driverStore.driverInstallSuccess", { label }));
+      return;
+    }
+    const blockers = await api.checkAgentUpdateBlockers([dbType]);
+    if (blockers.length > 0) {
+      toast(t("driverStore.driverUpdateBlocked", { labels: blockers.map((blocker) => blocker.label).join(", ") }));
+      return;
+    }
+    await api.installAgent(dbType);
+    await refreshAgents();
+    toast(t("driverStore.driverInstallSuccess", { label }));
+  } catch (e: any) {
+    toast(t("driverStore.driverInstallFailed", { label, error: e }));
+  } finally {
+    installing.value = null;
+    resetInstallProgress();
+  }
+}
+
+async function runQueuedDriverInstalls() {
+  if (installing.value !== null || upgradingAll.value) return;
+
+  const result = takeNextDriverInstallQueue(queuedDriverInstalls.value, canInstallOrUpdateDriver);
+  queuedDriverInstalls.value = result.queue;
+  if (!result.next) return;
+
+  await runDriverInstall(result.next);
+  await runQueuedDriverInstalls();
+}
+
+async function upgradeAll() {
+  upgradingAll.value = true;
+  queuedDriverInstalls.value = [];
+  resetInstallProgress();
+  try {
+    const updatableDbTypes = drivers.value.filter((driver) => driver.update_available).map((driver) => driver.db_type);
+    const blockers = await api.checkAgentUpdateBlockers(updatableDbTypes);
+    if (blockers.length > 0) {
+      toast(t("driverStore.driverUpdateBlocked", { labels: blockers.map((blocker) => blocker.label).join(", ") }));
+      return;
+    }
+    const result = await api.upgradeAllAgents();
+    await refreshAgents();
+    if (result.failed.length > 0) {
+      const failedLabels = result.failed.map((item) => drivers.value.find((driver) => driver.db_type === item.db_type)?.label ?? item.db_type).join(", ");
+      toast(t("driverStore.upgradeAllPartial", { count: result.upgraded, failed: failedLabels }));
+    } else {
+      toast(t("driverStore.upgradeAllSuccess", { count: result.upgraded }));
+    }
+  } catch (e: any) {
+    toast(t("driverStore.upgradeAllFailed", { error: e }));
+  } finally {
+    upgradingAll.value = false;
+    upgradingCurrent.value = "";
+    upgradingIndex.value = 0;
+    upgradingTotal.value = 0;
+    resetInstallProgress();
+  }
+}
+
+async function uninstallDriver(dbType: string) {
+  const label = driverLabel(dbType);
+  try {
+    if (isPrestoSqlBuiltinDriver(dbType)) {
+      const bundle = prestoSqlMavenBundle(jdbcMavenBundles.value);
+      if (!bundle) return;
+      jdbcDrivers.value = await api.deleteJdbcMavenBundle(bundle.id);
+      jdbcMavenBundles.value = await api.listJdbcMavenBundles();
+      void loadDriverStoreUsage();
+      toast(t("driverStore.driverUninstallSuccess", { label }));
+      return;
+    }
+    await api.uninstallAgent(dbType);
+    await refreshAgents();
+    toast(t("driverStore.driverUninstallSuccess", { label }));
+  } catch (e: any) {
+    toast(t("driverStore.driverUninstallFailed", { label, error: e }));
+  }
+}
+
+const importingZip = ref(false);
+
+function chooseWebOfflineZip(): Promise<File | null> {
+  return new Promise((resolve) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = ".zip";
+    input.onchange = () => resolve(input.files?.[0] ?? null);
+    input.click();
+  });
+}
+
+function chooseWebFiles(accept: string, multiple: boolean): Promise<File[] | null> {
+  return new Promise((resolve) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = accept;
+    input.multiple = multiple;
+    input.onchange = () => {
+      const files = input.files;
+      if (!files || files.length === 0) {
+        resolve(null);
+        return;
+      }
+      resolve(Array.from(files));
+    };
+    input.click();
+  });
+}
+
+function chooseWebFile(accept: string): Promise<File | null> {
+  return new Promise((resolve) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = accept;
+    input.onchange = () => resolve(input.files?.[0] ?? null);
+    input.click();
+  });
+}
+
+async function importOfflineZip() {
+  if (importingZip.value) return;
+  let selected: string | File | null = null;
+  if (isWeb) {
+    selected = await chooseWebOfflineZip();
+  } else {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const path = await open({
+      title: t("driverStore.chooseOfflineDriverPackage"),
+      multiple: false,
+      filters: [{ name: "ZIP", extensions: ["zip"] }],
+    });
+    selected = typeof path === "string" ? path : null;
+  }
+  if (!selected) return;
+  importingZip.value = true;
+  resetInstallProgress();
+  try {
+    const count = await api.importAgentsFromZip(selected);
+    await refreshAgents();
+    toast(t("driverStore.offlineImportSuccess", { count }));
+  } catch (e: any) {
+    toast(t("driverStore.offlineImportFailed", { error: e }));
+  } finally {
+    importingZip.value = false;
+    resetInstallProgress();
+  }
+}
+
+async function importDriverJar(dbType: string) {
+  if (isPrestoSqlBuiltinDriver(dbType)) {
+    await importJdbcDrivers();
+    return;
+  }
+  const label = driverLabel(dbType);
+  if (isWeb) {
+    const file = await chooseWebFile(".jar");
+    if (!file) return;
+    try {
+      await api.importAgentJar(dbType, file);
+      await refreshAgents();
+      toast(t("driverStore.driverImportSuccess", { label }));
+    } catch (e: any) {
+      toast(t("driverStore.driverImportFailed", { label, error: e }));
+    }
+    return;
+  }
+  const { open } = await import("@tauri-apps/plugin-dialog");
+  const selected = await open({
+    title: t("driverStore.chooseDriverJar"),
+    multiple: false,
+    filters: [{ name: "JAR", extensions: ["jar"] }],
+  });
+  if (typeof selected !== "string") return;
+  try {
+    await api.importAgentJar(dbType, selected);
+    await refreshAgents();
+    toast(t("driverStore.driverImportSuccess", { label }));
+  } catch (e: any) {
+    toast(t("driverStore.driverImportFailed", { label, error: e }));
+  }
+}
+
+async function reinstallJre(jreKey: string) {
+  reinstallingJre.value = jreKey;
+  resetInstallProgress();
+  try {
+    await api.reinstallJre(jreKey);
+    await refreshAgents();
+    toast(t("driverStore.jreReinstallSuccess", { jre: jreKey }));
+  } catch (e: any) {
+    toast(t("driverStore.jreReinstallFailed", { jre: jreKey, error: e }));
+  } finally {
+    reinstallingJre.value = null;
+    resetInstallProgress();
+  }
+}
+
+async function uninstallJre(jreKey: string) {
+  try {
+    await api.uninstallJre(jreKey);
+    await refreshAgents();
+    toast(t("driverStore.jreUninstallSuccess", { jre: jreKey }));
+  } catch (e: any) {
+    toast(String(e));
+  }
+}
+
+function formatSize(bytes: number): string {
+  if (!bytes) return "";
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+// ──────────── JDBC drivers ────────────
+
+const jdbcDrivers = ref<JdbcDriverInfo[]>([]);
+const jdbcMavenBundles = ref<JdbcMavenBundleInfo[]>([]);
+const jdbcLocalBundles = ref<JdbcLocalBundleInfo[]>([]);
+const jdbcDriverSearch = ref("");
+const isLoadingJdbcDrivers = ref(false);
+const jdbcPluginStatus = ref<JdbcPluginStatus | null>(null);
+const isInstallingJdbcPlugin = ref(false);
+const isUninstallingJdbcPlugin = ref(false);
+const jdbcDriverPathInput = ref("");
+const jdbcMavenCoordinateInput = ref("");
+const jdbcMavenRepository = ref("https://repo.maven.apache.org/maven2/");
+const customJdbcMavenRepository = ref("");
+const isInstallingJdbcMavenDriver = ref(false);
+
+const jdbcMavenRepositoryOptions = [
+  { label: "Maven Central", value: "https://repo.maven.apache.org/maven2/" },
+  { label: "Aliyun", value: "https://maven.aliyun.com/repository/public" },
+  { label: "Huawei Cloud", value: "https://repo.huaweicloud.com/repository/maven" },
+  { label: "Tencent Cloud", value: "https://mirrors.cloud.tencent.com/nexus/repository/maven-public" },
+  { label: "Custom", value: "custom" },
+];
+
+type JdbcDriverListItem =
+  | {
+      kind: "manual";
+      id: string;
+      title: string;
+      subtitle: string;
+      source: string;
+      size: number;
+      driver: JdbcDriverInfo;
+    }
+  | {
+      kind: "local";
+      id: string;
+      title: string;
+      subtitle: string;
+      source: string;
+      size: number;
+      bundle: JdbcLocalBundleInfo;
+    }
+  | {
+      kind: "maven";
+      id: string;
+      title: string;
+      subtitle: string;
+      source: string;
+      size: number;
+      bundle: JdbcMavenBundleInfo;
+    };
+
+const filteredAgentDrivers = computed(() => {
+  const query = agentDriverSearch.value.trim().toLowerCase();
+  if (!query) return builtinDriverRows.value;
+  return builtinDriverRows.value.filter((driver) => [driver.label, driver.db_type, driver.version, driver.installed_version, driverRequiresJavaRuntime(driver) ? driver.jre : ""].filter(Boolean).join(" ").toLowerCase().includes(query));
+});
+
+const jdbcDriverListItems = computed<JdbcDriverListItem[]>(() => {
+  const localBundleItems = jdbcLocalBundles.value.map((bundle) => ({
+    kind: "local" as const,
+    id: `local:${bundle.id}`,
+    title: bundle.name,
+    subtitle: `${bundle.artifacts.length} JARs - ${bundle.artifacts.map((artifact) => artifact.file_name).join(", ")}`,
+    source: t("driverStore.jdbcSourceManual"),
+    size: bundle.artifacts.reduce((total, artifact) => total + Number(artifact.size || 0), 0),
+    bundle,
+  }));
+  const bundleItems = jdbcMavenBundles.value.map((bundle) => ({
+    kind: "maven" as const,
+    id: `maven:${bundle.id}`,
+    title: bundle.coordinate,
+    subtitle: `${bundle.artifacts.length} JARs - ${bundle.repositories.join(", ")}`,
+    source: t("driverStore.jdbcSourceMaven"),
+    size: bundle.artifacts.reduce((total, artifact) => total + Number(artifact.size || 0), 0),
+    bundle,
+  }));
+  const manualItems = jdbcDrivers.value
+    .filter((driver) => !driver.bundle_id)
+    .map((driver) => ({
+      kind: "manual" as const,
+      id: `manual:${driver.path}`,
+      title: driver.name,
+      subtitle: driver.path,
+      source: t("driverStore.jdbcSourceManual"),
+      size: driver.size,
+      driver,
+    }));
+  return [...localBundleItems, ...bundleItems, ...manualItems].sort((a, b) => a.title.localeCompare(b.title));
+});
+
+const filteredJdbcDrivers = computed(() => {
+  const query = jdbcDriverSearch.value.trim().toLowerCase();
+  if (!query) return jdbcDriverListItems.value;
+  return jdbcDriverListItems.value.filter((item) => [item.title, item.subtitle, String(item.size)].join(" ").toLowerCase().includes(query));
+});
+
+function formatBytes(bytes: number) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+const runtimeOverview = computed(() => {
+  const summary = runtimeSummary.value;
+  return [
+    {
+      key: "running",
+      label: t("driverStore.runtimeRunning"),
+      value: String(summary?.running_count ?? 0),
+    },
+    {
+      key: "memory",
+      label: t("driverStore.runtimeMemory"),
+      value: formatRuntimeBytes(summary?.total_memory_bytes),
+    },
+    {
+      key: "health",
+      label: t("driverStore.runtimeHealth"),
+      value: t(`driverStore.runtimeHealth_${summary?.health ?? "healthy"}`),
+      class: runtimeHealthClass(summary?.health ?? "healthy"),
+    },
+  ];
+});
+
+function runtimeKindLabel(runtime: DriverRuntimeInfo) {
+  return runtime.kind === "plugin" ? t("driverStore.runtimeKindPlugin") : t("driverStore.runtimeKindAgent");
+}
+
+function runtimeSourceLabel(runtime: DriverRuntimeInfo) {
+  return runtime.source === "connection" ? t("driverStore.runtimeSourceConnection") : t("driverStore.runtimeSourceDaemon");
+}
+
+function runtimeStatusLabel(status: DriverRuntimeInfo["status"]) {
+  return t(`driverStore.runtimeStatus_${status}`);
+}
+
+function runtimeControlUnavailableReasonLabel(reason: string | null) {
+  if (reason === "connection-owned") return t("driverStore.runtimeControlConnectionOwned");
+  return reason || "-";
+}
+
+async function loadDriverRuntimeSummary(showLoading = false) {
+  if (showLoading) runtimeLoading.value = true;
+  try {
+    runtimeSummary.value = await api.getDriverRuntimeSummary();
+    runtimeError.value = "";
+  } catch (e: any) {
+    runtimeError.value = String(e?.message || e);
+  } finally {
+    runtimeLoading.value = false;
+  }
+}
+
+function startDriverRuntimePolling() {
+  if (runtimeTimer) return;
+  void loadDriverRuntimeSummary(true);
+  runtimeTimer = setInterval(() => {
+    if (driverStoreTab.value !== "storage") {
+      stopDriverRuntimePolling();
+      return;
+    }
+    void loadDriverRuntimeSummary(false);
+  }, DRIVER_RUNTIME_POLL_MS);
+}
+
+function stopDriverRuntimePolling() {
+  if (runtimeTimer) {
+    clearInterval(runtimeTimer);
+    runtimeTimer = null;
+  }
+}
+
+async function refreshDriverRuntime() {
+  if (driverStoreTab.value !== "runtime") return;
+  await loadDriverRuntimeSummary(true);
+}
+
+async function stopRuntime(runtime: DriverRuntimeInfo) {
+  runtimeBusy.value = runtime.id;
+  try {
+    await api.stopDriverRuntime(runtime.id);
+    await loadDriverRuntimeSummary(false);
+    toast(t("driverStore.runtimeStopSuccess", { label: runtime.label }));
+  } catch (e: any) {
+    toast(t("driverStore.runtimeStopFailed", { label: runtime.label, error: e }));
+  } finally {
+    runtimeBusy.value = null;
+  }
+}
+
+async function restartRuntime(runtime: DriverRuntimeInfo) {
+  runtimeBusy.value = runtime.id;
+  try {
+    await api.restartDriverRuntime(runtime.id);
+    await loadDriverRuntimeSummary(false);
+    toast(t("driverStore.runtimeRestartSuccess", { label: runtime.label }));
+  } catch (e: any) {
+    toast(t("driverStore.runtimeRestartFailed", { label: runtime.label, error: e }));
+  } finally {
+    runtimeBusy.value = null;
+  }
+}
+
+function jreUsageLabel(key: string) {
+  const bytes = jreUsageByKey.value.get(String(key)) || 0;
+  return bytes > 0 ? formatBytes(bytes) : "";
+}
+
+async function loadJdbcDrivers() {
+  isLoadingJdbcDrivers.value = true;
+  try {
+    const [drivers, bundles, localBundles] = await Promise.all([api.listJdbcDrivers(), api.listJdbcMavenBundles(), api.listJdbcLocalBundles()]);
+    jdbcDrivers.value = drivers;
+    jdbcMavenBundles.value = bundles;
+    jdbcLocalBundles.value = localBundles;
+  } catch (e: any) {
+    toast(String(e?.message || e), 5000);
+  } finally {
+    isLoadingJdbcDrivers.value = false;
+    void loadDriverStoreUsage();
+  }
+}
+
+async function loadDriverStoreUsage() {
+  try {
+    driverStoreUsage.value = await api.getDriverStoreUsage();
+  } catch {
+    driverStoreUsage.value = null;
+  }
+}
+
+async function clearDownloadCache() {
+  if (!canClearDownloadCache.value) return;
+  clearingDownloadCache.value = true;
+  try {
+    await api.clearDriverDownloadCache();
+    await loadDriverStoreUsage();
+    toast(t("driverStore.downloadCacheClearSuccess"));
+  } catch (e: any) {
+    toast(t("driverStore.downloadCacheClearFailed", { error: e?.message || String(e) }), 5000);
+  } finally {
+    clearingDownloadCache.value = false;
+  }
+}
+
+async function loadJdbcPluginStatus() {
+  try {
+    jdbcPluginStatus.value = await api.jdbcPluginStatus();
+    emitDriverUpdateCount();
+  } catch (e: any) {
+    toast(String(e?.message || e), 5000);
+  }
+}
+
+async function installJdbcPlugin() {
+  if (isInstallingJdbcPlugin.value) return;
+  isInstallingJdbcPlugin.value = true;
+  resetInstallProgress();
+  try {
+    jdbcPluginStatus.value = await api.installJdbcPlugin();
+    emitDriverUpdateCount();
+    toast(t("settings.jdbcPluginInstallSuccess"));
+    await loadJdbcDrivers();
+  } catch (e: any) {
+    toast(String(e?.message || e), 5000);
+  } finally {
+    isInstallingJdbcPlugin.value = false;
+    resetInstallProgress();
+  }
+}
+
+async function installJdbcPluginLocal() {
+  if (isInstallingJdbcPlugin.value) return;
+  let selected: string | File | null = null;
+  if (isWeb) {
+    selected = await chooseWebFile(".zip");
+  } else {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const result = await open({
+      title: t("driverStore.chooseJdbcPluginZip"),
+      multiple: false,
+      filters: [{ name: "ZIP", extensions: ["zip"] }],
+    });
+    selected = typeof result === "string" ? result : null;
+  }
+  if (!selected) return;
+  isInstallingJdbcPlugin.value = true;
+  try {
+    jdbcPluginStatus.value = await api.installJdbcPluginLocal(selected);
+    emitDriverUpdateCount();
+    toast(t("settings.jdbcPluginInstallSuccess"));
+    await loadJdbcDrivers();
+  } catch (e: any) {
+    toast(String(e?.message || e), 5000);
+  } finally {
+    isInstallingJdbcPlugin.value = false;
+  }
+}
+
+async function uninstallJdbcPlugin() {
+  if (isUninstallingJdbcPlugin.value) return;
+  isUninstallingJdbcPlugin.value = true;
+  try {
+    jdbcPluginStatus.value = await api.uninstallJdbcPlugin();
+    emitDriverUpdateCount();
+    toast(t("settings.jdbcPluginUninstallSuccess"));
+    await loadJdbcDrivers();
+  } catch (e: any) {
+    toast(String(e?.message || e), 5000);
+  } finally {
+    isUninstallingJdbcPlugin.value = false;
+  }
+}
+
+async function importJdbcDriverPaths(paths: string[]) {
+  if (!paths.length) return;
+  try {
+    jdbcDrivers.value = await api.importJdbcDrivers(paths);
+    jdbcLocalBundles.value = await api.listJdbcLocalBundles();
+    jdbcDriverPathInput.value = "";
+    void loadDriverStoreUsage();
+    toast(t("settings.jdbcImportSuccess", { count: paths.length }));
+  } catch (e: any) {
+    toast(String(e?.message || e), 5000);
+  }
+}
+
+async function importJdbcDrivers() {
+  if (isWeb) {
+    const files = await chooseWebFiles(".jar", true);
+    if (!files || !files.length) return;
+    try {
+      jdbcDrivers.value = await api.importJdbcDrivers(files);
+      jdbcLocalBundles.value = await api.listJdbcLocalBundles();
+      void loadDriverStoreUsage();
+      toast(t("settings.jdbcImportSuccess", { count: files.length }));
+    } catch (e: any) {
+      toast(String(e?.message || e), 5000);
+    }
+    return;
+  }
+  const { open } = await import("@tauri-apps/plugin-dialog");
+  const selected = await open({
+    title: t("settings.jdbcImport"),
+    multiple: true,
+    filters: [{ name: "JDBC Driver", extensions: ["jar"] }],
+  });
+  if (!selected) return;
+
+  const paths = (Array.isArray(selected) ? selected : [selected]).filter((path): path is string => typeof path === "string");
+  await importJdbcDriverPaths(paths);
+}
+
+async function importJdbcDriverPathInput() {
+  const paths = jdbcDriverPathInput.value
+    .split(/\r?\n/)
+    .map((path) => path.trim())
+    .filter(Boolean);
+  await importJdbcDriverPaths(paths);
+}
+
+async function installJdbcMavenDriver() {
+  const coordinate = jdbcMavenCoordinateInput.value.trim();
+  const repository = jdbcMavenRepository.value === "custom" ? customJdbcMavenRepository.value.trim() : jdbcMavenRepository.value;
+  if (!coordinate || !repository || isInstallingJdbcMavenDriver.value) return;
+  isInstallingJdbcMavenDriver.value = true;
+  try {
+    jdbcDrivers.value = await api.installJdbcDriverFromMaven(coordinate, [repository]);
+    jdbcMavenBundles.value = await api.listJdbcMavenBundles();
+    jdbcMavenCoordinateInput.value = "";
+    void loadDriverStoreUsage();
+    toast(t("driverStore.jdbcMavenInstallSuccess"));
+  } catch (e: any) {
+    toast(String(e?.message || e), 8000);
+  } finally {
+    isInstallingJdbcMavenDriver.value = false;
+  }
+}
+
+async function deleteJdbcDriver(path: string) {
+  try {
+    jdbcDrivers.value = await api.deleteJdbcDriver(path);
+    void loadDriverStoreUsage();
+    toast(t("settings.jdbcDeleteSuccess"));
+  } catch (e: any) {
+    toast(String(e?.message || e), 5000);
+  }
+}
+
+async function deleteJdbcMavenBundle(bundleId: string) {
+  try {
+    jdbcDrivers.value = await api.deleteJdbcMavenBundle(bundleId);
+    jdbcMavenBundles.value = await api.listJdbcMavenBundles();
+    void loadDriverStoreUsage();
+    toast(t("settings.jdbcDeleteSuccess"));
+  } catch (e: any) {
+    toast(String(e?.message || e), 5000);
+  }
+}
+
+async function deleteJdbcLocalBundle(bundleId: string) {
+  try {
+    jdbcDrivers.value = await api.deleteJdbcLocalBundle(bundleId);
+    jdbcLocalBundles.value = await api.listJdbcLocalBundles();
+    void loadDriverStoreUsage();
+    toast(t("settings.jdbcDeleteSuccess"));
+  } catch (e: any) {
+    toast(String(e?.message || e), 5000);
+  }
+}
+
+// ──────────── Lifecycle ────────────
+
+onMounted(async () => {
+  updateAgentDrivers(await api.listInstalledAgentsLocal());
+  void loadJavaRuntimeConfig();
+  void loadDriverStoreUsage();
+  void loadDriverStorePath();
+
+  void forceRefresh().catch(() => undefined);
+
+  unlisten = await api.listenAgentInstallProgress((payload) => {
+    if (payload.step === "done" || payload.step === "all-done") {
+      progress.value = null;
+    } else {
+      progress.value = payload as DriverInstallProgress;
+    }
+    if (payload.db_type && payload.total_drivers) {
+      upgradingCurrent.value = drivers.value.find((d) => d.db_type === payload.db_type)?.label ?? payload.db_type;
+      upgradingIndex.value = payload.current ?? 0;
+      upgradingTotal.value = payload.total_drivers ?? 0;
+    }
+    // During a batch upgrade, refresh the list as soon as each driver finishes
+    // (step="done") so its "Update" button disappears immediately instead of
+    // staying disabled until the whole batch completes (step="all-done").
+    // Single-driver installs (upgradingAll=false) are refreshed by runDriverInstall.
+    if (upgradingAll.value && payload.step === "done") {
+      void refreshAgents();
+    }
+  });
+  void loadJdbcDrivers();
+  void loadJdbcPluginStatus();
+});
+
+onUnmounted(() => {
+  unlisten?.();
+  stopDriverRuntimePolling();
+});
+
+watch(driverStoreTab, (tab) => {
+  if (tab === "storage") {
+    startDriverRuntimePolling();
+  } else {
+    stopDriverRuntimePolling();
+  }
+});
+</script>
+
+<template>
+  <div class="driver-store-view h-full flex flex-col">
+    <div class="driver-store-scroll flex-1 min-h-0 overflow-y-auto">
+      <div class="driver-store-container max-w-4xl mx-auto px-6 py-6">
+        <Tabs v-model="driverStoreTab" default-value="agent" class="driver-store-tabs-root">
+          <div class="driver-store-header flex items-center justify-between">
+            <TabsList class="driver-store-tabs grid w-[360px] grid-cols-3">
+              <TabsTrigger value="agent" class="gap-1.5 relative">
+                {{ t("driverStore.agentDrivers") }}
+                <span v-if="agentTabUpdateCount > 0" class="inline-block h-2 w-2 rounded-full bg-red-500" />
+              </TabsTrigger>
+              <TabsTrigger value="jdbc" class="gap-1.5 relative">
+                {{ t("driverStore.jdbcDrivers") }}
+                <span v-if="jdbcTabUpdateCount > 0" class="inline-block h-2 w-2 rounded-full bg-red-500" />
+              </TabsTrigger>
+              <TabsTrigger value="storage" class="gap-1.5">
+                {{ t("driverStore.storageTab") }}
+              </TabsTrigger>
+            </TabsList>
+            <div v-if="driverStoreTab !== 'storage'" class="flex items-center gap-2">
+              <Button variant="ghost" size="sm" class="h-7 rounded-[6px] text-xs gap-1 text-muted-foreground" :disabled="importingZip" @click="importOfflineZip">
+                <FileUp class="h-3.5 w-3.5" />
+                {{ importingZip ? t("driverStore.importing") : t("driverStore.importOfflinePackage") }}
+              </Button>
+              <Button variant="ghost" size="sm" class="h-7 rounded-[6px] text-xs gap-1 text-muted-foreground" :disabled="refreshing" @click="forceRefresh">
+                <RefreshCw class="h-3.5 w-3.5" :class="{ 'animate-spin': refreshing }" />
+                {{ t("driverStore.refresh") }}
+              </Button>
+            </div>
+          </div>
+
+          <!-- Agent Tab -->
+          <TabsContent value="agent" class="driver-store-tab driver-store-agent-tab mt-5 space-y-5">
+            <!-- Java Runtime -->
+            <div class="rounded-xl border bg-muted/20 p-4 space-y-3">
+              <div class="flex flex-wrap items-center gap-2">
+                <Label class="shrink-0">{{ t("driverStore.javaRuntime") }}</Label>
+                <Select :model-value="javaRuntimeConfig.mode" @update:model-value="setJavaRuntimeMode">
+                  <SelectTrigger class="h-8 min-w-[112px] text-xs">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="managed">{{ t("driverStore.javaRuntimeManaged") }}</SelectItem>
+                    <SelectItem value="system">{{ t("driverStore.javaRuntimeSystem") }}</SelectItem>
+                    <SelectItem value="custom">{{ t("driverStore.javaRuntimeCustom") }}</SelectItem>
+                  </SelectContent>
+                </Select>
+                <Input v-if="javaRuntimeConfig.mode === 'custom'" v-model="customJavaPath" class="h-8 min-w-[180px] flex-1 text-xs" :placeholder="t('driverStore.customJavaPathPlaceholder')" @keydown.enter.prevent="saveJavaRuntimeConfig" />
+                <span v-else class="min-w-0 flex-1 truncate text-xs text-muted-foreground">
+                  {{ javaRuntimeConfig.mode === "system" ? t("driverStore.systemJavaHint") : t("driverStore.jreRuntimeAutoDownloadHint") }}
+                </span>
+                <Button v-if="javaRuntimeConfig.mode === 'custom'" variant="outline" class="h-8 shrink-0 rounded-[6px] text-xs" @click="chooseCustomJavaPath">
+                  <FolderOpen class="h-3.5 w-3.5" />
+                  {{ t("driverStore.choose") }}
+                </Button>
+                <Button class="h-8 shrink-0 rounded-[6px] text-xs" :disabled="savingJavaRuntime || (javaRuntimeConfig.mode === 'custom' && !customJavaPath.trim())" @click="saveJavaRuntimeConfig">
+                  {{ savingJavaRuntime ? t("driverStore.saving") : t("settings.save") }}
+                </Button>
+              </div>
+
+              <div v-if="installedJres.length > 0" class="divide-y rounded-lg border bg-background/50">
+                <div v-for="jre in installedJres" :key="jre.key" class="flex items-center justify-between gap-3 px-3 py-2.5">
+                  <div class="min-w-0">
+                    <div class="text-sm font-medium">{{ t("driverStore.jreRuntimeTitle", { jre: jre.key }) }}</div>
+                  </div>
+                  <div class="flex shrink-0 items-center gap-3">
+                    <span v-if="jreUsageLabel(jre.key)" class="rounded-full bg-muted px-2 py-0.5 text-[11px] text-muted-foreground">
+                      {{ jreUsageLabel(jre.key) }}
+                    </span>
+                    <Check v-if="jre.installed" class="h-4 w-4 text-green-600" />
+                    <span v-else class="text-xs text-muted-foreground">{{ t("driverStore.notInstalled") }}</span>
+                    <DriverInstallProgressCircle v-if="reinstallingJre === jre.key" :percent="progressNumber" :title="progressTitle(jre.installed ? t('driverStore.reinstalling') : t('driverStore.installing'))" />
+                    <Button v-else-if="!jre.installed" type="button" variant="default" size="sm" class="h-8 rounded-[6px] text-xs" :disabled="reinstallingJre !== null || installing !== null" @click="reinstallJre(jre.key)">
+                      <Download class="h-3.5 w-3.5 mr-1" />
+                      {{ t("driverStore.install") }}
+                    </Button>
+                    <Button v-else-if="jre.installed" type="button" variant="outline" size="sm" class="h-8 rounded-[6px] text-xs" :disabled="reinstallingJre !== null || installing !== null" @click="reinstallJre(jre.key)">
+                      <RotateCcw class="h-3.5 w-3.5 mr-1" />
+                      {{ t("driverStore.reinstall") }}
+                    </Button>
+                    <Button v-if="jre.installed" type="button" variant="ghost" size="sm" class="h-8 rounded-[6px] text-xs text-muted-foreground hover:text-destructive" :disabled="reinstallingJre !== null || installing !== null" @click="uninstallJre(jre.key)">
+                      {{ t("driverStore.uninstall") }}
+                    </Button>
+                  </div>
+                </div>
+              </div>
+            </div>
+
+            <!-- Driver List -->
+            <div class="relative">
+              <Search class="absolute left-3 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+              <Input v-model="agentDriverSearch" class="h-8 pl-8 text-xs" :placeholder="t('driverStore.searchDrivers')" />
+            </div>
+            <div v-if="drivers.length === 0" class="py-12 text-center text-sm text-muted-foreground">
+              {{ t("common.loading") }}
+            </div>
+            <div v-else-if="filteredAgentDrivers.length === 0" class="py-12 text-center text-sm text-muted-foreground">
+              {{ t("driverStore.noMatchingDrivers") }}
+            </div>
+            <div v-else class="driver-store-agent-list rounded-md border divide-y">
+              <div v-if="updatableCount > 0" class="flex items-center justify-between px-4 py-2 bg-muted/30">
+                <span class="text-xs text-muted-foreground">{{ t("driverStore.driversUpdatable", { count: updatableCount }) }}</span>
+                <Button size="sm" class="h-7 rounded-[6px] text-xs" :disabled="installing !== null || upgradingAll" @click="upgradeAll">
+                  <Loader2 v-if="upgradingAll" class="h-3 w-3 animate-spin mr-1" />
+                  <Download v-else class="h-3 w-3 mr-1" />
+                  {{ upgradingAll ? t("driverStore.upgradingProgress", { current: upgradingIndex, total: upgradingTotal }) : t("driverStore.upgradeAll") }}
+                </Button>
+              </div>
+              <div v-for="driver in filteredAgentDrivers" :key="driver.db_type" class="driver-store-agent-row flex items-center gap-3 px-4 py-2 transition hover:bg-muted/30">
+                <span class="flex h-8 w-8 items-center justify-center rounded-lg bg-muted/60 shrink-0">
+                  <DatabaseIcon :db-type="driver.db_type" class="h-4 w-4" />
+                </span>
+                <div class="driver-store-agent-name min-w-0 flex-1">
+                  <div class="text-sm font-medium">{{ driver.label }}</div>
+                </div>
+                <div class="driver-store-agent-meta flex shrink-0 items-center gap-1.5">
+                  <span v-if="driverRequiresJavaRuntime(driver) && driver.jre" class="rounded-full px-2 py-0.5 text-[11px]" :class="driver.jre !== '21' ? 'bg-blue-500/10 text-blue-600' : 'bg-muted text-muted-foreground'">JRE {{ driver.jre }}</span>
+                  <template v-if="driver.installed">
+                    <span class="rounded-full bg-muted px-2 py-0.5 text-[11px] text-muted-foreground">v{{ driver.installed_version }}</span>
+                    <span v-if="driver.update_available" class="rounded-full bg-amber-500/15 px-2 py-0.5 text-[11px] text-amber-600">→ v{{ driver.version }}</span>
+                  </template>
+                  <template v-else>
+                    <span v-if="driver.version" class="rounded-full bg-muted px-2 py-0.5 text-[11px] text-muted-foreground">v{{ driver.version }}</span>
+                  </template>
+                  <span v-if="formatSize(driver.size)" class="rounded-full bg-muted px-2 py-0.5 text-[11px] text-muted-foreground">{{ formatSize(driver.size) }}</span>
+                </div>
+                <div class="driver-store-agent-actions flex shrink-0 items-center gap-2">
+                  <Button v-if="!driver.installed && isDriverQueued(driver.db_type)" size="sm" variant="outline" class="h-7 rounded-[6px] border-green-500/30 bg-green-500/10 text-xs text-green-700 hover:bg-green-500/15" :disabled="upgradingAll" @click="removeQueuedDriverInstall(driver.db_type)">
+                    <Clock3 class="h-3 w-3 mr-1" />
+                    {{ t("driverStore.queued") }}
+                  </Button>
+                  <DriverInstallProgressCircle v-else-if="!driver.installed && isDriverProgressActive(driver.db_type)" :percent="progressNumber" :title="progressTitle(t('driverStore.installing'))" />
+                  <Button v-else-if="!driver.installed" size="sm" class="h-7 rounded-[6px] text-xs" :disabled="upgradingAll" @click="installDriver(driver.db_type)">
+                    <Download class="h-3 w-3 mr-1" />
+                    {{ t("driverStore.install") }}
+                  </Button>
+                  <Button
+                    v-if="!driver.installed && !isPrestoSqlBuiltinDriver(driver.db_type) && !isDriverProgressActive(driver.db_type) && !isDriverQueued(driver.db_type)"
+                    size="sm"
+                    variant="ghost"
+                    class="h-7 w-7 rounded-[6px] text-xs text-muted-foreground"
+                    :title="t('driverStore.importLocalJar')"
+                    :disabled="upgradingAll || installing !== null"
+                    @click="importDriverJar(driver.db_type)"
+                  >
+                    <FileUp class="h-3.5 w-3.5" />
+                  </Button>
+                  <template v-if="driver.installed">
+                    <Check v-if="!(driver.update_available && isDriverProgressActive(driver.db_type))" class="h-4 w-4 text-green-600" />
+                    <Button
+                      v-if="driver.update_available && isDriverQueued(driver.db_type)"
+                      size="sm"
+                      variant="outline"
+                      class="h-7 rounded-[6px] border-green-500/30 bg-green-500/10 text-xs text-green-700 hover:bg-green-500/15"
+                      :disabled="upgradingAll"
+                      @click="removeQueuedDriverInstall(driver.db_type)"
+                    >
+                      <Clock3 class="h-3 w-3 mr-1" />
+                      {{ t("driverStore.queued") }}
+                    </Button>
+                    <DriverInstallProgressCircle v-else-if="driver.update_available && isDriverProgressActive(driver.db_type)" :percent="progressNumber" :title="progressTitle(t('driverStore.updating'))" />
+                    <Button v-else-if="driver.update_available" size="sm" variant="outline" class="h-7 rounded-[6px] text-xs" :disabled="upgradingAll" @click="installDriver(driver.db_type)">
+                      {{ t("driverStore.update") }}
+                    </Button>
+                    <Button variant="ghost" size="sm" class="h-7 rounded-[6px] text-xs text-muted-foreground hover:text-destructive" :disabled="installing !== null || upgradingAll || isDriverQueued(driver.db_type)" @click="uninstallDriver(driver.db_type)">
+                      {{ t("driverStore.uninstall") }}
+                    </Button>
+                  </template>
+                </div>
+              </div>
+            </div>
+          </TabsContent>
+
+          <!-- JDBC Tab -->
+          <TabsContent value="jdbc" class="driver-store-tab driver-store-jdbc-tab mt-5 space-y-5">
+            <!-- JDBC Plugin -->
+            <div class="rounded-xl border bg-muted/20 p-4">
+              <div class="flex min-h-12 items-center justify-between gap-3">
+                <div class="min-w-0 space-y-1">
+                  <Label>{{ t("settings.jdbcPlugin") }}</Label>
+                  <p v-if="!jdbcPluginStatus?.installed" class="text-xs text-muted-foreground">
+                    {{ t("settings.jdbcPluginNotInstalled") }}
+                  </p>
+                </div>
+                <div class="flex shrink-0 items-center gap-3">
+                  <DriverInstallProgressCircle v-if="isInstallingJdbcPlugin" :percent="progressNumber" :title="progressTitle(t('driverStore.progressDownloadJdbcPlugin'))" />
+                  <span v-if="jdbcPluginStatus?.installed" class="text-xs" :class="jdbcPluginStatus.compatible ? 'text-green-600' : 'text-destructive'">
+                    {{
+                      jdbcPluginStatus.compatible
+                        ? t("settings.jdbcPluginInstalled", {
+                            version: jdbcPluginStatus.version || "-",
+                          })
+                        : t("settings.jdbcPluginIncompatible")
+                    }}
+                  </span>
+                  <span v-if="jdbcPluginStatus?.installed && jdbcPluginStatus.update_available" class="rounded-full bg-amber-500/15 px-2 py-0.5 text-[11px] text-amber-600">→ v{{ jdbcPluginStatus.latest_version }}</span>
+                  <Button v-if="jdbcPluginStatus?.installed && jdbcPluginStatus.update_available" type="button" variant="outline" class="rounded-[6px]" :disabled="isInstallingJdbcPlugin" @click="installJdbcPlugin">
+                    {{ isInstallingJdbcPlugin ? t("common.loading") : t("settings.jdbcPluginUpdate") }}
+                  </Button>
+                  <Button v-if="jdbcPluginStatus?.installed" type="button" variant="outline" class="rounded-[6px]" :disabled="isUninstallingJdbcPlugin" @click="uninstallJdbcPlugin">
+                    {{ isUninstallingJdbcPlugin ? t("common.loading") : t("settings.jdbcPluginUninstall") }}
+                  </Button>
+                  <Button v-else type="button" variant="default" class="rounded-[6px]" :disabled="isInstallingJdbcPlugin" @click="installJdbcPlugin">
+                    {{ isInstallingJdbcPlugin ? t("common.loading") : t("settings.jdbcPluginInstall") }}
+                  </Button>
+                  <Button v-if="!jdbcPluginStatus?.installed" type="button" variant="outline" class="rounded-[6px]" :disabled="isInstallingJdbcPlugin" @click="installJdbcPluginLocal">
+                    <FolderOpen class="h-3.5 w-3.5 mr-1" />
+                    {{ t("driverStore.localInstall") }}
+                  </Button>
+                </div>
+              </div>
+            </div>
+
+            <!-- JDBC Drivers -->
+            <div class="space-y-3">
+              <div class="space-y-1">
+                <Label>{{ t("settings.jdbcDrivers") }}</Label>
+              </div>
+              <div class="relative">
+                <Search class="absolute left-3 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+                <Input v-model="jdbcDriverSearch" class="h-8 pl-8 text-xs" :placeholder="t('driverStore.searchJdbcDrivers')" />
+              </div>
+              <div class="flex items-center gap-2">
+                <Input v-model="jdbcDriverPathInput" class="flex-1" :placeholder="t('settings.jdbcDriverPathPlaceholder')" @keydown.enter.prevent="importJdbcDriverPathInput" />
+                <Button variant="outline" class="rounded-[6px]" :disabled="!jdbcDriverPathInput.trim()" @click="importJdbcDriverPathInput">
+                  {{ t("settings.jdbcImportPath") }}
+                </Button>
+                <Button class="shrink-0 rounded-[6px]" @click="importJdbcDrivers">
+                  <FolderOpen class="h-4 w-4" />
+                  {{ t("settings.jdbcImport") }}
+                </Button>
+              </div>
+              <div class="grid gap-2 md:grid-cols-[minmax(0,1fr)_180px_auto]">
+                <Input v-model="jdbcMavenCoordinateInput" class="h-8 text-xs" :placeholder="t('driverStore.jdbcMavenCoordinatePlaceholder')" @keydown.enter.prevent="installJdbcMavenDriver" />
+                <Select v-model="jdbcMavenRepository">
+                  <SelectTrigger class="h-8 text-xs">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem v-for="repo in jdbcMavenRepositoryOptions" :key="repo.value" :value="repo.value">
+                      {{ repo.label }}
+                    </SelectItem>
+                  </SelectContent>
+                </Select>
+                <Button class="h-8 shrink-0 rounded-[6px]" :disabled="!jdbcMavenCoordinateInput.trim() || isInstallingJdbcMavenDriver || (jdbcMavenRepository === 'custom' && !customJdbcMavenRepository.trim())" @click="installJdbcMavenDriver">
+                  <Loader2 v-if="isInstallingJdbcMavenDriver" class="h-4 w-4 animate-spin" />
+                  <Download v-else class="h-4 w-4" />
+                  {{ t("driverStore.jdbcMavenInstall") }}
+                </Button>
+              </div>
+              <Input v-if="jdbcMavenRepository === 'custom'" v-model="customJdbcMavenRepository" class="h-8 text-xs" placeholder="https://repo.example.com/repository/maven-public" @keydown.enter.prevent="installJdbcMavenDriver" />
+            </div>
+
+            <div class="driver-store-jdbc-list rounded-md border">
+              <div v-if="isLoadingJdbcDrivers" class="p-4 text-sm text-muted-foreground">
+                {{ t("common.loading") }}
+              </div>
+              <div v-else-if="jdbcDriverListItems.length === 0" class="p-4 text-sm text-muted-foreground">
+                {{ t("settings.jdbcNoDrivers") }}
+              </div>
+              <div v-else-if="filteredJdbcDrivers.length === 0" class="p-4 text-sm text-muted-foreground">
+                {{ t("driverStore.noMatchingDrivers") }}
+              </div>
+              <div v-else class="divide-y">
+                <div v-for="item in filteredJdbcDrivers" :key="item.id" class="driver-store-jdbc-row flex items-center gap-3 p-3">
+                  <div class="driver-store-jdbc-name min-w-0 flex-1">
+                    <div class="flex min-w-0 items-center gap-2">
+                      <div class="truncate text-sm font-medium">{{ item.title }}</div>
+                      <Badge variant="outline" class="h-5 shrink-0 rounded-full px-2 text-[10px] font-medium">
+                        {{ item.source }}
+                      </Badge>
+                    </div>
+                    <div class="truncate text-xs text-muted-foreground">{{ item.subtitle }}</div>
+                  </div>
+                  <div class="shrink-0 text-xs text-muted-foreground">{{ formatBytes(item.size) }}</div>
+                  <Button variant="ghost" size="icon" class="h-8 w-8 shrink-0 rounded-[6px]" @click="item.kind === 'maven' ? deleteJdbcMavenBundle(item.bundle.id) : item.kind === 'local' ? deleteJdbcLocalBundle(item.bundle.id) : deleteJdbcDriver(item.driver.path)">
+                    <Trash2 class="h-4 w-4" />
+                  </Button>
+                </div>
+              </div>
+            </div>
+          </TabsContent>
+
+          <!-- Runtime Tab -->
+          <TabsContent value="storage" class="driver-store-tab driver-store-storage-tab mt-5 space-y-5">
+            <!-- Storage Usage -->
+            <div class="rounded-xl border bg-muted/20 p-4 space-y-3">
+              <div class="flex items-center justify-between gap-3">
+                <div class="text-sm font-medium">{{ t("driverStore.usageTitle") }}</div>
+                <div class="flex shrink-0 items-center gap-2">
+                  <div class="text-xs text-muted-foreground">
+                    {{ usageSummary.length ? t("driverStore.usageTotal", { size: formatBytes(usageSummary[0].bytes) }) : t("driverStore.calculating") }}
+                  </div>
+                  <Button variant="outline" size="sm" class="h-7 gap-1.5 rounded-[6px] text-xs" :disabled="!canClearDownloadCache" @click="clearDownloadCache">
+                    <Loader2 v-if="clearingDownloadCache" class="h-3.5 w-3.5 animate-spin" />
+                    <Trash2 v-else class="h-3.5 w-3.5" />
+                    {{ clearingDownloadCache ? t("common.loading") : t("driverStore.clearDownloadCache") }}
+                  </Button>
+                </div>
+              </div>
+              <div v-if="usageSummary.length" class="grid grid-cols-2 gap-2 sm:grid-cols-3 lg:grid-cols-6">
+                <div v-for="item in usageSummary" :key="item.key" class="rounded-lg border bg-background/50 px-2.5 py-2 text-center">
+                  <div class="text-[11px] text-muted-foreground">{{ item.label }}</div>
+                  <div class="mt-0.5 text-xs font-medium">{{ formatBytes(item.bytes) }}</div>
+                </div>
+              </div>
+            </div>
+
+            <!-- Driver Store Path -->
+            <div v-if="!isWeb" class="rounded-xl border bg-muted/20 p-4 space-y-3">
+              <div class="text-sm font-medium">{{ t("driverStore.driverStoreDir") }}</div>
+              <p class="text-xs text-muted-foreground">{{ t("driverStore.driverStoreDirDescription") }}</p>
+              <div class="space-y-2.5">
+                <div v-for="row in driverStorePathRows" :key="row.kind" class="rounded-lg border bg-background/50 p-3">
+                  <div class="mb-2 flex items-start justify-between gap-3">
+                    <div class="min-w-0 text-xs leading-5">
+                      <span class="font-medium">{{ row.label }}</span>
+                      <span class="ml-2 text-[11px] text-muted-foreground">{{ row.description }}</span>
+                    </div>
+                    <Loader2 v-if="driverStoreDirMigrating === row.kind" class="mt-0.5 h-3.5 w-3.5 shrink-0 animate-spin text-muted-foreground" />
+                  </div>
+                  <div class="flex items-center gap-2">
+                    <Tooltip>
+                      <TooltipTrigger as-child>
+                        <div class="min-w-0 flex-1 rounded-md border bg-background px-3 py-2 text-xs font-mono truncate">
+                          {{ row.display }}
+                        </div>
+                      </TooltipTrigger>
+                      <TooltipContent side="bottom" class="max-w-100 break-all text-xs">
+                        {{ row.display }}
+                      </TooltipContent>
+                    </Tooltip>
+                    <Button variant="outline" size="sm" class="shrink-0 gap-1" :disabled="Boolean(driverStoreDirMigrating)" @click="chooseDriverStoreDir(row.kind)">
+                      <FolderSync class="h-3.5 w-3.5" />
+                      {{ t("driverStore.driverStoreDirChange") }}
+                    </Button>
+                    <Button v-if="row.custom" variant="ghost" size="sm" class="shrink-0 gap-1 text-muted-foreground" :disabled="Boolean(driverStoreDirMigrating)" @click="resetDriverStoreDir(row.kind)">
+                      {{ t("driverStore.driverStoreDirReset") }}
+                    </Button>
+                  </div>
+                </div>
+              </div>
+              <p v-if="driverStoreDirMigrating" class="text-xs text-muted-foreground flex items-center gap-1.5">
+                <Loader2 class="h-3 w-3 animate-spin" />
+                {{ t("driverStore.driverStoreDirMigrating", { target: driverStoreTargetLabel(driverStoreDirMigrating) }) }}
+              </p>
+            </div>
+
+            <!-- Offline Download -->
+            <div class="rounded-xl border bg-muted/20 p-4">
+              <div class="flex items-center justify-between gap-3">
+                <div class="min-w-0 text-xs text-muted-foreground">
+                  {{ t("driverStore.offlineDownloadHint") }}
+                </div>
+                <Button variant="outline" size="sm" class="shrink-0 gap-1" @click="openOfflineDriverDownload">
+                  <ExternalLink class="h-3.5 w-3.5" />
+                  {{ t("driverStore.offlineDownloadLink") }}
+                </Button>
+              </div>
+            </div>
+
+            <!-- Runtime Info -->
+            <div class="overflow-hidden rounded-md border bg-background">
+              <div class="flex flex-col gap-3 border-b px-4 py-3 lg:flex-row lg:items-center lg:justify-between">
+                <div class="flex min-w-0 items-center gap-2.5">
+                  <span class="flex h-8 w-8 shrink-0 items-center justify-center rounded-md bg-muted">
+                    <Activity class="h-4 w-4 text-muted-foreground" />
+                  </span>
+                  <div class="min-w-0">
+                    <div class="text-sm font-medium">{{ t("driverStore.runtimeTitle") }}</div>
+                    <div class="mt-0.5 flex flex-wrap items-center gap-2 text-xs text-muted-foreground">
+                      <span v-for="item in runtimeOverview" :key="item.key" class="inline-flex items-center gap-1.5">
+                        <span>{{ item.label }}</span>
+                        <span class="font-medium text-foreground" :class="item.class">{{ item.value }}</span>
+                      </span>
+                    </div>
+                  </div>
+                </div>
+                <Button variant="ghost" size="icon" class="h-8 w-8 shrink-0 rounded-[6px] text-muted-foreground" :title="t('driverStore.refresh')" :disabled="runtimeLoading" @click="refreshDriverRuntime">
+                  <RefreshCw class="h-4 w-4" :class="{ 'animate-spin': runtimeLoading }" />
+                </Button>
+              </div>
+
+              <div v-if="runtimeSummary?.last_error" class="border-b border-amber-500/20 bg-amber-500/10 px-4 py-2.5">
+                <div class="text-xs font-medium text-amber-700 dark:text-amber-300">
+                  {{ t("driverStore.runtimeLastError") }}
+                </div>
+                <pre class="mt-1 max-h-20 overflow-auto whitespace-pre-wrap text-[11px] text-muted-foreground">{{ runtimeSummary.last_error }}</pre>
+              </div>
+
+              <div v-if="runtimeLoading && !runtimeSummary" class="p-6 text-center text-sm text-muted-foreground">
+                {{ t("common.loading") }}
+              </div>
+              <div v-else-if="runtimeError" class="p-6 text-sm text-destructive">
+                {{ runtimeError }}
+              </div>
+              <div v-else-if="!runtimeSummary?.runtimes.length" class="p-6 text-center text-sm text-muted-foreground">
+                {{ t("driverStore.runtimeEmpty") }}
+              </div>
+              <div v-else>
+                <div class="hidden grid-cols-[minmax(0,1.6fr)_72px_56px_76px_58px_76px_72px] gap-2 border-b bg-muted/30 px-4 py-2 text-[11px] font-medium text-muted-foreground lg:grid">
+                  <div>{{ t("driverStore.runtimeDrivers") }}</div>
+                  <div>{{ t("driverStore.runtimeHealth") }}</div>
+                  <div>{{ t("driverStore.runtimePid") }}</div>
+                  <div>{{ t("driverStore.runtimeMemory") }}</div>
+                  <div>CPU</div>
+                  <div>{{ t("driverStore.runtimeUptime") }}</div>
+                  <div class="text-right">{{ t("driverStore.runtimeActions") }}</div>
+                </div>
+                <div class="divide-y">
+                  <div v-for="runtime in runtimeSummary.runtimes" :key="runtime.id" class="grid gap-2 px-4 py-3 transition hover:bg-muted/25 lg:grid-cols-[minmax(0,1.6fr)_72px_56px_76px_58px_76px_72px] lg:items-center">
+                    <div class="min-w-0">
+                      <div class="flex min-w-0 items-center gap-2">
+                        <span class="h-2 w-2 shrink-0 rounded-full" :class="runtimeStatusDotClass(runtime.status)" />
+                        <span class="truncate text-sm font-medium">{{ runtime.label }}</span>
+                        <span v-if="runtime.version" class="shrink-0 rounded bg-muted px-1.5 py-0.5 text-[10px] text-muted-foreground"> v{{ runtime.version }} </span>
+                      </div>
+                      <div class="mt-1 flex flex-wrap items-center gap-1.5 text-[11px] text-muted-foreground">
+                        <span>{{ runtimeKindLabel(runtime) }}</span>
+                        <span class="text-muted-foreground/50">/</span>
+                        <span>{{ runtimeSourceLabel(runtime) }}</span>
+                      </div>
+                    </div>
+
+                    <div class="flex items-center gap-2 lg:block">
+                      <span class="lg:hidden text-[11px] text-muted-foreground">{{ t("driverStore.runtimeHealth") }}</span>
+                      <span class="rounded-full px-2 py-0.5 text-[11px]" :class="runtimeStatusClass(runtime.status)">
+                        {{ runtimeStatusLabel(runtime.status) }}
+                      </span>
+                    </div>
+                    <div class="text-xs text-muted-foreground">
+                      <span class="lg:hidden">{{ t("driverStore.runtimePid") }}: </span>{{ runtime.pid ?? "-" }}
+                    </div>
+                    <div class="flex items-center gap-1 text-xs text-muted-foreground">
+                      <MemoryStick class="h-3.5 w-3.5 lg:hidden" />
+                      {{ formatRuntimeBytes(runtime.memory_bytes) }}
+                    </div>
+                    <div class="flex items-center gap-1 text-xs text-muted-foreground">
+                      <Cpu class="h-3.5 w-3.5 lg:hidden" />
+                      {{ formatRuntimeCpu(runtime.cpu_percent) }}
+                    </div>
+                    <div class="text-xs text-muted-foreground">
+                      <span class="lg:hidden">{{ t("driverStore.runtimeUptime") }}: </span>
+                      {{ formatRuntimeUptime(runtime.uptime_seconds) }}
+                    </div>
+                    <div class="flex min-w-0 items-center gap-1.5 lg:justify-end">
+                      <Button v-if="runtime.can_stop" variant="ghost" size="icon" class="h-7 w-7 rounded-[6px] text-muted-foreground hover:text-destructive" :title="t('driverStore.runtimeStop')" :disabled="runtimeBusy === runtime.id" @click="stopRuntime(runtime)">
+                        <Square class="h-3.5 w-3.5" />
+                      </Button>
+                      <Button v-if="runtime.can_restart" variant="ghost" size="icon" class="h-7 w-7 rounded-[6px] text-muted-foreground" :title="t('driverStore.runtimeRestart')" :disabled="runtimeBusy === runtime.id" @click="restartRuntime(runtime)">
+                        <RotateCcw class="h-3.5 w-3.5" :class="{ 'animate-spin': runtimeBusy === runtime.id }" />
+                      </Button>
+                      <span v-if="!runtime.can_stop && !runtime.can_restart" class="min-w-0 truncate text-[11px] text-muted-foreground lg:text-right" :title="runtimeControlUnavailableReasonLabel(runtime.control_unavailable_reason)">
+                        {{ runtimeControlUnavailableReasonLabel(runtime.control_unavailable_reason) }}
+                      </span>
+                    </div>
+
+                    <div v-if="runtime.last_error" class="rounded-md bg-muted/60 p-2 lg:col-span-7">
+                      <pre class="max-h-16 overflow-auto whitespace-pre-wrap text-[11px] text-muted-foreground">{{ runtime.last_error }}</pre>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </TabsContent>
+        </Tabs>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style>
+.driver-store-view,
+.driver-store-scroll {
+  overflow-x: hidden;
+}
+
+.driver-store-view {
+  height: 100%;
+  min-height: 0;
+  overflow: hidden;
+}
+
+.driver-store-scroll {
+  height: 100%;
+  min-height: 0;
+  overflow-y: auto !important;
+}
+
+.driver-store-container {
+  box-sizing: border-box;
+  width: 100%;
+  max-width: none !important;
+  margin-left: 0 !important;
+  margin-right: 0 !important;
+  padding: 1.25rem 1.5rem 1.5rem !important;
+}
+
+.driver-store-tabs {
+  display: grid !important;
+  width: 360px !important;
+  grid-template-columns: repeat(3, minmax(0, 1fr)) !important;
+}
+
+.driver-store-tabs-root {
+  display: flex !important;
+  width: 100%;
+  min-width: 0;
+  flex-direction: column !important;
+}
+
+.driver-store-tabs-root > [data-slot="tabs-content"] {
+  width: 100%;
+  min-width: 0;
+}
+
+.driver-store-header {
+  flex-shrink: 0;
+}
+
+.driver-store-tab {
+  min-height: 0;
+  overflow: visible;
+}
+
+.driver-store-tabs-root > [data-slot="tabs-content"][hidden] {
+  display: none !important;
+}
+
+.driver-store-agent-tab,
+.driver-store-jdbc-tab {
+  flex-direction: column;
+  gap: 1rem;
+}
+
+.driver-store-agent-tab:not([hidden]),
+.driver-store-jdbc-tab:not([hidden]) {
+  display: flex !important;
+}
+
+.driver-store-agent-tab > :not([hidden]) ~ :not([hidden]),
+.driver-store-jdbc-tab > :not([hidden]) ~ :not([hidden]) {
+  margin-top: 0 !important;
+}
+
+.driver-store-agent-tab > *,
+.driver-store-jdbc-tab > * {
+  flex-shrink: 0;
+}
+
+.driver-store-agent-row {
+  display: flex !important;
+  align-items: center !important;
+  min-width: 0;
+  width: 100%;
+}
+
+.driver-store-agent-list,
+.driver-store-jdbc-list {
+  width: 100%;
+  flex: 0 0 auto !important;
+  min-height: 0;
+  overflow-y: visible;
+  overflow-x: hidden;
+}
+
+.driver-store-agent-name,
+.driver-store-jdbc-name {
+  flex: 1 1 auto !important;
+  min-width: 0 !important;
+}
+
+.driver-store-agent-meta,
+.driver-store-agent-actions,
+.driver-store-jdbc-row > .shrink-0,
+.driver-store-jdbc-row > button {
+  flex-shrink: 0 !important;
+}
+
+.driver-store-jdbc-row {
+  display: flex !important;
+  align-items: center !important;
+  min-width: 0;
+  width: 100%;
+}
+
+.driver-store-jdbc-row > button {
+  width: 2rem !important;
+  height: 2rem !important;
+}
+
+@media (max-width: 900px) {
+  .driver-store-header {
+    align-items: flex-start !important;
+    flex-direction: column !important;
+    gap: 0.75rem;
+  }
+
+  .driver-store-tabs {
+    width: 100% !important;
+  }
+
+  .driver-store-agent-row {
+    align-items: flex-start !important;
+    flex-wrap: wrap;
+  }
+
+  .driver-store-jdbc-row {
+    align-items: flex-start !important;
+    flex-wrap: wrap;
+  }
+
+  .driver-store-agent-meta,
+  .driver-store-agent-actions {
+    margin-left: 2.75rem;
+  }
+
+  .driver-store-jdbc-row > .shrink-0,
+  .driver-store-jdbc-row > button {
+    margin-left: 2.75rem;
+  }
+}
+</style>
diff --git a/apps/desktop/src/components/connection/CloudflareD1ConnectionFields.vue b/apps/desktop/src/components/connection/CloudflareD1ConnectionFields.vue
new file mode 100644
index 0000000..ad64384
--- /dev/null
+++ b/apps/desktop/src/components/connection/CloudflareD1ConnectionFields.vue
@@ -0,0 +1,33 @@
+<script setup lang="ts">
+import { useI18n } from "vue-i18n";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import PasswordInput from "@/components/ui/PasswordInput.vue";
+
+const accountId = defineModel<string>("accountId", { required: true });
+const databaseId = defineModel<string | undefined>("databaseId");
+const apiToken = defineModel<string>("apiToken", { required: true });
+const { t } = useI18n();
+</script>
+
+<template>
+  <div class="grid grid-cols-4 items-center gap-4">
+    <Label class="justify-self-start text-left">{{ t("connection.d1AccountId") }}</Label>
+    <Input v-model="accountId" class="col-span-3" placeholder="023e105f4ecef8ad9ca31a8372d0c353" />
+  </div>
+
+  <div class="grid grid-cols-4 items-center gap-4">
+    <Label class="justify-self-start text-left">{{ t("connection.d1DatabaseId") }}</Label>
+    <Input v-model="databaseId" class="col-span-3" placeholder="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" />
+  </div>
+
+  <div class="grid grid-cols-4 items-center gap-4">
+    <Label class="justify-self-start text-left">{{ t("connection.d1ApiToken") }}</Label>
+    <PasswordInput v-model="apiToken" class="col-span-3" placeholder="Cloudflare API Token" />
+  </div>
+
+  <div class="grid grid-cols-4 items-start gap-4">
+    <span />
+    <p class="col-span-3 text-xs text-muted-foreground">{{ t("connection.d1TokenHint") }}</p>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/connection/ConnectionDialog.vue b/apps/desktop/src/components/connection/ConnectionDialog.vue
new file mode 100644
index 0000000..e6d8b13
--- /dev/null
+++ b/apps/desktop/src/components/connection/ConnectionDialog.vue
@@ -0,0 +1,5928 @@
+<script setup lang="ts">
+import { computed, nextTick, onMounted, onUnmounted, ref, watch } from "vue";
+import { uuid } from "@/lib/common/utils";
+import { useI18n } from "vue-i18n";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Input } from "@/components/ui/input";
+import PasswordInput from "@/components/ui/PasswordInput.vue";
+import { Label } from "@/components/ui/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Switch } from "@/components/ui/switch";
+import type { ConnectionConfig, DatabaseType, HttpTunnelConfig, JdbcDriverInfo, JdbcLocalBundleInfo, JdbcMavenBundleInfo, ProxyTunnelConfig, SshConfigHostEntry, SshTunnelConfig, TransportLayerConfig } from "@/types/database";
+import type { InfluxDbExternalConfig, InfluxDbVersion } from "@/types/influxdb";
+import type { MqAdminConfig, MqAuth, MqSystemKind } from "@/types/mq";
+import type { NacosAdminConfig, NacosAuthConfig } from "@/types/nacos";
+import { CONNECTION_ATTEMPT_CANCELLED_MESSAGE, useConnectionStore } from "@/stores/connectionStore";
+import { useTunnelProfileStore } from "@/stores/tunnelProfileStore";
+import { detachTunnelProfileLayer, tunnelProfileReferenceLayer, tunnelProfileSummary } from "@/lib/connection/tunnelProfiles";
+import { REDIS_SCAN_PAGE_SIZE_DEFAULT, REDIS_SCAN_PAGE_SIZE_MIN, REDIS_SCAN_PAGE_SIZE_MAX, REDIS_SCAN_PAGE_SIZE_OPTIONS } from "@/lib/redis/redisKeyPattern";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useToast } from "@/composables/useToast";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import * as api from "@/lib/backend/api";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { applyParsedConnectionUrl, normalizeMongoConnectionString, parseConnectionUrl } from "@/lib/connection/connectionUrl";
+import { parseConnectionDeepLink, type ConnectionDeepLinkDraft } from "@/lib/connection/connectionDeepLink";
+import { connectionUrlPlaceholder as getUrlPlaceholder } from "@/lib/connection/connectionPresentation";
+import { h2ConnectionModeForConfig, h2FileJdbcUrlWithPath, h2FilePathFromJdbcUrl, isH2SplitJdbcUrl, type H2ConnectionMode } from "@/lib/database/h2Connection";
+import { firstZooKeeperEndpoint, normalizeZooKeeperConnectString } from "@/lib/zookeeper/zookeeperConnection";
+import { isLocalFileTypeDb } from "@/lib/connection/connectionFile";
+import { MQ_PINNED_VERSION_OPTIONS, pinnedVersionToSelection, selectionToPinnedVersion } from "@/lib/mq/mqPinnedVersionOptions";
+import { mongodbAuthFailureHint, mongoUrlParam, mongoUrlParamIsTrue, normalizeMongoTlsFormState, setMongoUrlParam, setMongoUrlParamBoolean } from "@/lib/mongo/mongoConnectionOptions";
+import { mysqlCleartextPasswordAuthEnabled, setMysqlCleartextPasswordAuthEnabled } from "@/lib/database/mysqlConnectionOptions";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { agentDriverInstallKey, appendAgentDriverUpdateHint, hasAgentDriverUpdate, showAgentDriverInstallHint, type AgentDriverInstallState } from "@/lib/connection/agentDriverInstallHint";
+import { prestoSqlBuiltinDriverPaths } from "@/lib/database/prestoSqlBuiltinDriver";
+import { SQLITE_DATABASE_FILE_EXTENSIONS } from "@/lib/database/databaseFileDetection";
+import { connectionAttemptOriginalErrorMessage, connectionAttemptTimeoutMessage, connectionAttemptTimeoutMs } from "@/lib/connection/connectionAttemptTimeout";
+import { appendConnectionErrorHints } from "@/lib/connection/connectionErrorHints";
+import { normalizeKafkaBootstrapServers } from "@/lib/connection/kafkaBootstrapServers";
+import { detectMqUiAuthKind, isMqAuthKindAllowedForSystem, type MqUiAuthKind } from "@/lib/connection/mqAuth";
+import { driverInstallProgressPercent, type DriverInstallProgress } from "@/lib/connection/driverInstallProgressUi";
+import { isSqlServerLegacyCompatibilityMode, requiresSqlServerLegacyCompatibilityComponent, setSqlServerLegacyCompatibilityMode, SQLSERVER_LEGACY_COMPATIBILITY_DRIVER_KEY } from "@/lib/connection/sqlServerLegacyCompatibility";
+import { ArrowLeft, ArrowDown, ArrowUp, CheckSquare, ChevronRight, CircleHelp, Copy, ExternalLink, FilePlus2, FolderOpen, GripVertical, Grid3X3, KeyRound, Link2, List, ListFilter, Loader2, Pencil, Pipette, Plus, RefreshCw, Search, ShieldAlert, ShieldCheck, Square, Trash2 } from "@lucide/vue";
+import { buildDraftVisibleDatabasesConnectionId, connectionCanChooseVisibleDatabases, initialVisibleDatabaseSelection, visibleDatabaseSelectionIsStale } from "@/lib/connection/connectionVisibleDatabases";
+import { canSaveVisibleDatabaseSelection, connectionUsesVisibleSchemaFilter, filterDatabaseNamesForVisiblePicker, isSystemDatabaseName, normalizeVisibleDatabaseSelection, buildDraftVisibleSchemasConnectionId, normalizeVisibleSchemaSelection } from "@/lib/database/visibleDatabases";
+import { isSchemaAware, isSingleDatabase } from "@/lib/database/databaseFeatureSupport";
+import VisibleSchemasDialog from "@/components/sidebar/VisibleSchemasDialog.vue";
+import CloudflareD1ConnectionFields from "@/components/connection/CloudflareD1ConnectionFields.vue";
+import { oceanbaseModeConnectionPatch, oceanbaseSubModeFromConfig } from "@/lib/database/oceanbaseConnectionMode";
+import { translateBackendError } from "@/i18n/backend-errors";
+import { applyHiveKerberosSubmitConfig, hiveKerberosFormConfig, type HiveKerberosAuthMode } from "@/lib/database/hiveKerberosOptions";
+import { hasCloudflareD1Credentials, isCloudflareD1Connection, normalizeCloudflareD1Connection } from "@/lib/connection/cloudflareD1";
+
+type DbOption = { value: string; label: string };
+type DbCategory = { key: string; title: string; options: DbOption[] };
+type DialogStep = "select" | "config";
+type DbPickerView = "icon" | "list";
+export type ConfigTab = "connection" | "advanced" | "tls" | "transport";
+type ProductionScope = "connection" | "databases";
+type MqTokenSigningMode = "none" | "hs256" | "rs256";
+type NacosAuthKind = NacosAuthConfig["kind"];
+type DremioConnectionMode = "arrow-flight-sql" | "legacy";
+type JdbcDriverSelectItem = {
+  id: string;
+  label: string;
+  paths: string[];
+};
+
+const DREMIO_ARROW_FLIGHT_SQL_JDBC_URL = "jdbc:arrow-flight-sql://127.0.0.1:32010";
+const DREMIO_ARROW_FLIGHT_SQL_JDBC_DRIVER_CLASS = "org.apache.arrow.driver.jdbc.ArrowFlightJdbcDriver";
+const DREMIO_LEGACY_JDBC_URL = "jdbc:dremio:direct=127.0.0.1:31010";
+const DREMIO_LEGACY_JDBC_DRIVER_CLASS = "com.dremio.jdbc.Driver";
+const NACOS_DEFAULT_CONSOLE_URL = "http://127.0.0.1:8085";
+const NACOS_LEGACY_SERVER_PORT = "8848";
+const NACOS_DOCKER_CONSOLE_PORT = "8085";
+const DEFAULT_SSH_USER = "root";
+
+type LegacyTransportFields = {
+  ssh_enabled?: boolean;
+  ssh_host?: string;
+  ssh_port?: number;
+  ssh_user?: string;
+  ssh_password?: string;
+  ssh_key_path?: string;
+  ssh_key_passphrase?: string;
+  ssh_expose_lan?: boolean;
+  ssh_connect_timeout_secs?: number;
+  ssh_tunnels?: SshTunnelConfig[];
+  proxy_enabled?: boolean;
+  proxy_type?: "socks5" | "http";
+  proxy_host?: string;
+  proxy_port?: number;
+  proxy_username?: string;
+  proxy_password?: string;
+};
+type LegacyConnectionConfig = ConnectionConfig & LegacyTransportFields;
+type ConnectionForm = Omit<ConnectionConfig, "id">;
+
+const { t } = useI18n();
+const { toast } = useToast();
+const settingsStore = useSettingsStore();
+const open = defineModel<boolean>("open", { default: false });
+const isDesktop = isTauriRuntime();
+
+const props = defineProps<{
+  editConfig?: ConnectionConfig;
+  prefillConfig?: ConnectionDeepLinkDraft | null;
+  initialTab?: ConfigTab;
+}>();
+
+const emit = defineEmits<{
+  connectStarted: [name: string];
+  connectSucceeded: [name: string];
+  connectFailed: [message: string];
+  openDriverStore: [];
+  openTunnelProfileSettings: [];
+}>();
+
+const store = useConnectionStore();
+const tunnelProfileStore = useTunnelProfileStore();
+const isTesting = ref(false);
+const isSaving = ref(false);
+const testResult = ref<{ ok: boolean; message: string } | null>(null);
+const showAgentInstallDialog = ref(false);
+const agentInstallRunning = ref(false);
+const agentInstallDriverKey = ref("");
+const agentInstallLabel = ref("");
+const agentInstallProgress = ref<DriverInstallProgress | null>(null);
+const agentInstallError = ref("");
+const showConnectionErrorDialog = ref(false);
+const connectionErrorDetail = ref("");
+const editingId = ref<string | null>(null);
+const draftTestConnectionId = ref(uuid());
+const showVisibleDatabasesDialog = ref(false);
+const isLoadingVisibleDatabases = ref(false);
+const visibleDatabaseNames = ref<string[]>([]);
+const visibleDatabaseSelection = ref<Set<string>>(new Set());
+const visibleDatabaseSearchText = ref("");
+const visibleDatabaseError = ref("");
+const visibleDatabaseShowSystem = ref(false);
+const showProductionDatabasesDialog = ref(false);
+const isLoadingProductionDatabases = ref(false);
+const productionDatabaseNames = ref<string[]>([]);
+const productionDatabaseSelection = ref<Set<string>>(new Set());
+const productionDatabaseSearchText = ref("");
+const productionDatabaseError = ref("");
+const productionProtectionEnabled = ref(false);
+const showVisibleSchemasDialog = ref(false);
+const isLoadingVisibleSchemas = ref(false);
+const visibleSchemaNames = ref<string[]>([]);
+const visibleSchemaInitialSelection = ref<string[]>([]);
+const visibleSchemaError = ref("");
+let testRunId = 0;
+let unlistenAgentInstallProgress: (() => void) | null = null;
+
+function initialConfigTab(): ConfigTab {
+  return props.initialTab ?? "connection";
+}
+
+const defaultForm = (): ConnectionForm => ({
+  name: "",
+  db_type: "mysql",
+  driver_profile: "mysql",
+  driver_label: "MySQL",
+  url_params: "",
+  agent_java_options: [],
+  host: "127.0.0.1",
+  port: 3306,
+  username: "root",
+  password: "",
+  database: undefined,
+  color: "",
+  transport_layers: [],
+  connect_timeout_secs: 10,
+  query_timeout_secs: 30,
+  idle_timeout_secs: 60,
+  keepalive_interval_secs: 30,
+  ssl: false,
+  ca_cert_path: "",
+  client_cert_path: "",
+  client_key_path: "",
+  sysdba: false,
+  oracle_connection_type: "service_name",
+  connection_string: undefined,
+  jdbc_driver_class: undefined,
+  jdbc_driver_paths: [],
+  redis_connection_mode: "standalone",
+  redis_sentinel_master: "",
+  redis_sentinel_nodes: "",
+  redis_sentinel_username: "",
+  redis_sentinel_password: "",
+  redis_sentinel_tls: false,
+  redis_cluster_nodes: "",
+  redis_key_separator: ":",
+  redis_scan_page_size: REDIS_SCAN_PAGE_SIZE_DEFAULT,
+  etcd_endpoints: "",
+  gbase_server: "",
+  informix_server: "",
+  external_config: undefined,
+  read_only: false,
+  is_production: false,
+  production_databases: [],
+  visible_databases: undefined,
+});
+
+function defaultSshTunnel(): SshTunnelConfig {
+  return {
+    id: uuid(),
+    name: "",
+    enabled: true,
+    host: "",
+    port: 22,
+    user: DEFAULT_SSH_USER,
+    password: "",
+    key_path: "",
+    key_passphrase: "",
+    connect_timeout_secs: 5,
+    expose_lan: false,
+    use_ssh_agent: false,
+    ssh_agent_sock_path: "",
+    auth_method: "password",
+  };
+}
+
+/**
+ * Infers a login method for connections saved before `auth_method` existed
+ * (or imported from a source that never set it), so the dropdown shows a
+ * sensible current state instead of defaulting blindly to "password".
+ * Mirrors the priority `connect_and_authenticate` actually uses at connect
+ * time (key > password > agent > none) — see `db/ssh_tunnel.rs`.
+ */
+function inferSshAuthMethod(hop: Partial<SshTunnelConfig>): "password" | "key" | "agent" | "none" {
+  if (hop.key_path?.trim()) return "key";
+  if (hop.password) return "password";
+  if (hop.use_ssh_agent) return "agent";
+  return "none";
+}
+
+function normalizeSshTunnel(hop: Partial<SshTunnelConfig>): SshTunnelConfig {
+  return {
+    id: hop.id || uuid(),
+    name: hop.name || "",
+    enabled: hop.enabled !== false,
+    host: hop.host || "",
+    port: Number(hop.port) || 22,
+    user: hop.user?.trim() || DEFAULT_SSH_USER,
+    password: hop.password || "",
+    key_path: hop.key_path || "",
+    key_passphrase: hop.key_passphrase || "",
+    connect_timeout_secs: Number(hop.connect_timeout_secs) || 5,
+    expose_lan: !!hop.expose_lan,
+    use_ssh_agent: !!hop.use_ssh_agent,
+    ssh_agent_sock_path: hop.ssh_agent_sock_path || "",
+    auth_method: hop.auth_method || inferSshAuthMethod(hop),
+    profile_id: hop.profile_id || undefined,
+  };
+}
+
+function defaultProxyTunnel(): ProxyTunnelConfig {
+  return {
+    id: uuid(),
+    name: "",
+    enabled: true,
+    proxy_type: "socks5",
+    host: "",
+    port: 1080,
+    username: "",
+    password: "",
+  };
+}
+
+function defaultHttpTunnel(): HttpTunnelConfig {
+  return {
+    id: uuid(),
+    name: "",
+    enabled: true,
+    url: "",
+    token: "",
+    connect_timeout_secs: 10,
+  };
+}
+
+function normalizeProxyTunnel(layer: Partial<ProxyTunnelConfig>): ProxyTunnelConfig {
+  return {
+    id: layer.id || uuid(),
+    name: layer.name || "",
+    enabled: layer.enabled !== false,
+    proxy_type: layer.proxy_type || "socks5",
+    host: layer.host || "",
+    port: Number(layer.port) || 1080,
+    username: layer.username || "",
+    password: layer.password || "",
+    profile_id: layer.profile_id || undefined,
+  };
+}
+
+function normalizeHttpTunnel(layer: Partial<HttpTunnelConfig>): HttpTunnelConfig {
+  return {
+    id: layer.id || uuid(),
+    name: layer.name || "",
+    enabled: layer.enabled !== false,
+    url: layer.url || "",
+    token: layer.token || "",
+    connect_timeout_secs: Number(layer.connect_timeout_secs) || 10,
+    profile_id: layer.profile_id || undefined,
+  };
+}
+
+function normalizeTransportLayer(layer: Partial<TransportLayerConfig>): TransportLayerConfig {
+  if (layer.type === "proxy") {
+    return { type: "proxy", ...normalizeProxyTunnel(layer) };
+  }
+  if (layer.type === "http_tunnel") {
+    return { type: "http_tunnel", ...normalizeHttpTunnel(layer) };
+  }
+  return { type: "ssh", ...normalizeSshTunnel(layer as Partial<SshTunnelConfig>) };
+}
+
+function transportLayersForConfig(config: LegacyConnectionConfig): TransportLayerConfig[] {
+  if (config.transport_layers?.length) {
+    return config.transport_layers.map(normalizeTransportLayer);
+  }
+  const layers: TransportLayerConfig[] = sshLayersForConfig(config).map((hop) => ({ type: "ssh", ...hop }));
+  if (config.proxy_enabled || config.proxy_host || config.proxy_username || config.proxy_password) {
+    layers.push({
+      type: "proxy",
+      ...normalizeProxyTunnel({
+        id: "legacy-proxy",
+        enabled: true,
+        proxy_type: config.proxy_type || "socks5",
+        host: config.proxy_host || "",
+        port: config.proxy_port || 1080,
+        username: config.proxy_username || "",
+        password: config.proxy_password || "",
+      }),
+    });
+  }
+  return layers;
+}
+
+function sshLayersForConfig(config: LegacyConnectionConfig): SshTunnelConfig[] {
+  if (config.ssh_tunnels?.length) {
+    return config.ssh_tunnels.map(normalizeSshTunnel);
+  }
+  if (config.ssh_enabled || config.ssh_host || config.ssh_user || config.ssh_password || config.ssh_key_path || config.ssh_key_passphrase) {
+    return [
+      normalizeSshTunnel({
+        id: "legacy",
+        enabled: true,
+        host: config.ssh_host || "",
+        port: config.ssh_port || 22,
+        user: config.ssh_user || "",
+        password: config.ssh_password || "",
+        key_path: config.ssh_key_path || "",
+        key_passphrase: config.ssh_key_passphrase || "",
+        connect_timeout_secs: config.ssh_connect_timeout_secs || 5,
+        expose_lan: config.ssh_expose_lan || false,
+        use_ssh_agent: false,
+        ssh_agent_sock_path: "",
+      }),
+    ];
+  }
+  return [];
+}
+
+const form = ref(defaultForm());
+const keepaliveEnabled = computed({
+  get: () => Number(form.value.keepalive_interval_secs) > 0,
+  set: (enabled: boolean) => {
+    if (enabled) {
+      const current = Number(form.value.keepalive_interval_secs);
+      form.value.keepalive_interval_secs = Number.isFinite(current) && current > 0 ? current : 30;
+    } else {
+      form.value.keepalive_interval_secs = 0;
+    }
+  },
+});
+const selectedTransportLayerId = ref<string | null>(null);
+const draggedTransportLayerId = ref<string | null>(null);
+const selectedType = ref("mysql");
+const customDriverName = ref("");
+const mongoUseUrl = ref(false);
+const jdbcDriverPathsInput = ref("");
+const jdbcDrivers = ref<JdbcDriverInfo[]>([]);
+const jdbcMavenBundles = ref<JdbcMavenBundleInfo[]>([]);
+const jdbcLocalBundles = ref<JdbcLocalBundleInfo[]>([]);
+const sshConfigHosts = ref<SshConfigHostEntry[]>([]);
+const agentDrivers = ref<AgentDriverInstallState[]>([]);
+const selectedJdbcDriverPath = ref("");
+const jdbcManualClasspathOpen = ref(false);
+const connectionUrlInput = ref("");
+const appliedConnectionUrlInput = ref("");
+const oceanbaseSubMode = ref<"mysql" | "oracle">("mysql");
+const h2ConnectionMode = ref<H2ConnectionMode>("file");
+const dremioConnectionMode = ref<DremioConnectionMode>("legacy");
+const dremioConnectionUrls = ref<Record<DremioConnectionMode, string>>({
+  "arrow-flight-sql": DREMIO_ARROW_FLIGHT_SQL_JDBC_URL,
+  legacy: DREMIO_LEGACY_JDBC_URL,
+});
+const hiveAuthMode = ref<HiveKerberosAuthMode>("none");
+const hivePrincipal = ref("");
+const hiveKrb5ConfPath = ref("");
+const hiveJaasConfigPath = ref("");
+const hiveUseSubjectCredsOnlyFalse = ref(false);
+const hiveExtraJavaOptions = ref("");
+const dialogStep = ref<DialogStep>("select");
+const dbPickerView = ref<DbPickerView>("icon");
+const dbSearchQuery = ref("");
+const configTab = ref<ConfigTab>("connection");
+const MQ_KAFKA_SECURITY_PROTOCOL_AUTO = "__auto";
+const mqAdminUrl = ref("http://127.0.0.1:8080");
+const mqSystemKind = ref<MqSystemKind>("pulsar");
+const mqKafkaBootstrapServers = ref("127.0.0.1:9092");
+const mqKafkaSecurityProtocol = ref(MQ_KAFKA_SECURITY_PROTOCOL_AUTO);
+const mqKafkaSaslMechanism = ref("PLAIN");
+const mqKafkaKerberosPrincipal = ref("");
+const mqKafkaKerberosKeytabPath = ref("");
+const mqKafkaKerberosServiceName = ref("kafka");
+const mqKafkaKrb5ConfPath = ref("");
+const mqAuthKind = ref<MqUiAuthKind>("none");
+const mqToken = ref("");
+const mqBasicUsername = ref("");
+const mqBasicPassword = ref("");
+const mqApiKeyHeader = ref("Authorization");
+const mqApiKeyValue = ref("");
+const mqOauthIssuerUrl = ref("");
+const mqOauthClientId = ref("");
+const mqOauthClientSecret = ref("");
+const mqOauthAudience = ref("");
+const mqOauthScope = ref("");
+const mqTlsSkipVerify = ref(false);
+const mqPinnedVersion = ref(pinnedVersionToSelection(undefined));
+const mqTokenSigningMode = ref<MqTokenSigningMode>("none");
+const mqTokenSigningKey = ref("");
+const mqSystemOptions: Array<{ value: MqSystemKind; label: string }> = [
+  { value: "pulsar", label: "Apache Pulsar" },
+  { value: "kafka", label: "Apache Kafka" },
+];
+const mqKafkaSecurityProtocolOptions = [
+  { value: MQ_KAFKA_SECURITY_PROTOCOL_AUTO, label: "Auto" },
+  { value: "PLAINTEXT", label: "PLAINTEXT" },
+  { value: "SSL", label: "SSL" },
+  { value: "SASL_PLAINTEXT", label: "SASL_PLAINTEXT" },
+  { value: "SASL_SSL", label: "SASL_SSL" },
+];
+const mqKafkaSaslMechanismOptions = [
+  { value: "PLAIN", label: "PLAIN" },
+  { value: "SCRAM-SHA-256", label: "SCRAM-SHA-256" },
+  { value: "SCRAM-SHA-512", label: "SCRAM-SHA-512" },
+];
+const nacosServerAddr = ref(NACOS_DEFAULT_CONSOLE_URL);
+const nacosNamespace = ref("");
+const nacosContextPath = ref("");
+const nacosAuthKind = ref<NacosAuthKind>("none");
+const nacosUsername = ref("nacos");
+const nacosPassword = ref("");
+const nacosTlsSkipVerify = ref(false);
+const nacosPageSize = ref(20);
+
+const colorOptions = [
+  { value: "", class: "bg-transparent border-dashed", labelKey: "connection.colorNone" },
+  { value: "#22c55e", class: "bg-green-500", labelKey: "connection.colorGreen" },
+  { value: "#eab308", class: "bg-yellow-500", labelKey: "connection.colorYellow" },
+  { value: "#f97316", class: "bg-orange-500", labelKey: "connection.colorOrange" },
+  { value: "#ef4444", class: "bg-red-500", labelKey: "connection.colorRed" },
+  { value: "#3b82f6", class: "bg-blue-500", labelKey: "connection.colorBlue" },
+  { value: "#a855f7", class: "bg-purple-500", labelKey: "connection.colorPurple" },
+];
+
+const isPresetColor = (color: string | undefined) => colorOptions.some((c) => c.value === (color || ""));
+const customColorInput = ref("");
+const customColorOpen = ref(false);
+
+const jdbcDriverSelectItems = computed<JdbcDriverSelectItem[]>(() => {
+  const localBundles = jdbcLocalBundles.value.map((bundle) => ({
+    id: `local:${bundle.id}`,
+    label: bundle.name,
+    paths: bundle.artifacts.map((artifact) => artifact.path),
+  }));
+  const bundles = jdbcMavenBundles.value.map((bundle) => ({
+    id: `maven:${bundle.id}`,
+    label: bundle.coordinate,
+    paths: bundle.artifacts.map((artifact) => artifact.path),
+  }));
+  const manual = jdbcDrivers.value
+    .filter((driver) => !driver.bundle_id)
+    .map((driver) => ({
+      id: `manual:${driver.path}`,
+      label: driver.name,
+      paths: [driver.path],
+    }));
+  return [...localBundles, ...bundles, ...manual].sort((left, right) => left.label.localeCompare(right.label));
+});
+
+const jdbcDriverSelectItemById = computed(() => new Map(jdbcDriverSelectItems.value.map((item) => [item.id, item])));
+const jdbcManualClasspathCount = computed(
+  () =>
+    jdbcDriverPathsInput.value
+      .split(/\r?\n/)
+      .map((value) => value.trim())
+      .filter(Boolean).length,
+);
+
+function applyCustomColor(value: string) {
+  form.value.color = value;
+  customColorInput.value = value;
+}
+
+function handlePresetClick(color: string) {
+  form.value.color = color;
+  customColorInput.value = "";
+}
+
+function handleCustomColorPicked(value: string) {
+  applyCustomColor(value);
+}
+
+function handleCustomColorInput(value: string) {
+  applyCustomColor(value);
+}
+
+const driverProfiles: Record<
+  string,
+  {
+    type: DatabaseType;
+    port: number;
+    user: string;
+    label: string;
+    icon: string;
+    host?: string;
+    urlParams?: string;
+  }
+> = {
+  mysql: { type: "mysql", port: 3306, user: "root", label: "MySQL", icon: "mysql", urlParams: "" },
+  postgres: {
+    type: "postgres",
+    port: 5432,
+    user: "postgres",
+    label: "PostgreSQL",
+    icon: "postgres",
+    urlParams: "",
+  },
+  redis: { type: "redis", port: 6379, user: "", label: "Redis", icon: "redis" },
+  sqlite: { type: "sqlite", port: 0, user: "", label: "SQLite", icon: "sqlite" },
+  rqlite: { type: "rqlite", port: 4001, user: "", label: "RQLite", icon: "rqlite" },
+  turso: { type: "turso", port: 443, user: "", label: "Turso", icon: "turso" },
+  "cloudflare-d1": { type: "cloudflare-d1", port: 443, user: "", label: "Cloudflare D1", icon: "cloudflare-d1" },
+  duckdb: { type: "duckdb", port: 0, user: "", label: "DuckDB", icon: "duckdb" },
+  access: { type: "access", port: 0, user: "", label: "Microsoft Access", icon: "access" },
+  mongodb: { type: "mongodb", port: 27017, user: "", label: "MongoDB", icon: "mongodb" },
+  "mongodb-legacy": { type: "mongodb", port: 27017, user: "", label: "MongoDB (Legacy)", icon: "mongodb" },
+  clickhouse: {
+    type: "clickhouse",
+    port: 8123,
+    user: "default",
+    label: "ClickHouse",
+    icon: "clickhouse",
+  },
+  sqlserver: { type: "sqlserver", port: 1433, user: "sa", label: "SQL Server", icon: "sqlserver" },
+  oracle: { type: "oracle", port: 1521, user: "system", label: "Oracle", icon: "oracle" },
+  elasticsearch: {
+    type: "elasticsearch",
+    port: 9200,
+    user: "",
+    label: "Elasticsearch",
+    icon: "elasticsearch",
+  },
+  qdrant: { type: "qdrant", port: 6333, user: "", label: "Qdrant", icon: "qdrant" },
+  milvus: { type: "milvus", port: 19530, user: "root", label: "Milvus", icon: "milvus" },
+  weaviate: { type: "weaviate", port: 8080, user: "", label: "Weaviate", icon: "weaviate" },
+  chromadb: { type: "chromadb", port: 8000, user: "", label: "ChromaDB", icon: "chromadb" },
+  mariadb: { type: "mysql", port: 3306, user: "root", label: "MariaDB", icon: "mariadb" },
+  tidb: { type: "mysql", port: 4000, user: "root", label: "TiDB", icon: "tidb" },
+  oceanbase: { type: "mysql", port: 2883, user: "root", label: "OceanBase", icon: "oceanbase" },
+  "oceanbase-oracle": {
+    type: "oceanbase-oracle",
+    port: 2883,
+    user: "SYS",
+    label: "OceanBase Oracle Mode",
+    icon: "oceanbase",
+  },
+  goldendb: { type: "goldendb", port: 3306, user: "root", label: "GoldenDB", icon: "goldendb" },
+  databend: { type: "databend", port: 8000, user: "databend", label: "Databend", icon: "databend" },
+  tdsql: { type: "mysql", port: 3306, user: "root", label: "TDSQL", icon: "tdsql" },
+  polardb: { type: "mysql", port: 3306, user: "root", label: "PolarDB", icon: "polardb" },
+  greatsql: { type: "mysql", port: 3306, user: "root", label: "GreatSQL", icon: "greatsql" },
+  databricks: { type: "databricks", port: 443, user: "token", label: "Databricks SQL", icon: "databricks" },
+  saphana: { type: "saphana", port: 30015, user: "SYSTEM", label: "SAP HANA", icon: "saphana" },
+  teradata: { type: "teradata", port: 1025, user: "", label: "Teradata", icon: "teradata" },
+  vertica: { type: "vertica", port: 5433, user: "dbadmin", label: "Vertica", icon: "vertica" },
+  firebird: { type: "firebird", port: 3050, user: "SYSDBA", label: "Firebird", icon: "firebird" },
+  exasol: { type: "exasol", port: 8563, user: "sys", label: "Exasol", icon: "exasol" },
+  gbase: { type: "gbase", port: 5258, user: "gbasedbt", label: "GBase 8a", icon: "gbase" },
+  gbase8a: { type: "gbase", port: 5258, user: "gbasedbt", label: "GBase 8a", icon: "gbase" },
+  gbase8s: { type: "gbase", port: 9088, user: "gbasedbt", label: "GBase 8s", icon: "gbase" },
+  opengauss: {
+    type: "opengauss",
+    port: 5432,
+    user: "gaussdb",
+    label: "openGauss",
+    icon: "opengauss",
+  },
+  gaussdb: { type: "gaussdb", port: 5432, user: "gaussdb", label: "GaussDB", icon: "gaussdb" },
+  kwdb: { type: "kwdb", port: 26257, user: "root", label: "KWDB", icon: "kwdb" },
+  questdb: { type: "questdb", port: 8812, user: "questdb", label: "QuestDB", icon: "questdb" },
+  kingbase: { type: "kingbase", port: 54321, user: "system", label: "KingBase", icon: "kingbase" },
+  highgo: { type: "highgo", port: 5866, user: "highgo", label: "瀚高 HighGo", icon: "highgo" },
+  yashandb: { type: "yashandb", port: 1688, user: "sys", label: "崖山 YashanDB", icon: "yashandb" },
+  vastbase: { type: "vastbase", port: 5432, user: "vastbase", label: "Vastbase", icon: "vastbase" },
+  doris: { type: "mysql", port: 9030, user: "root", label: "Doris", icon: "doris", urlParams: "" },
+  selectdb: {
+    type: "mysql",
+    port: 9030,
+    user: "root",
+    label: "SelectDB",
+    icon: "selectdb",
+    urlParams: "",
+  },
+  starrocks: {
+    type: "mysql",
+    port: 9030,
+    user: "root",
+    label: "StarRocks",
+    icon: "starrocks",
+    urlParams: "",
+  },
+  manticoresearch: {
+    type: "manticoresearch",
+    port: 9306,
+    user: "root",
+    label: "Manticore Search",
+    icon: "manticoresearch",
+    urlParams: "",
+  },
+  redshift: { type: "redshift", port: 5439, user: "awsuser", label: "Redshift", icon: "redshift" },
+  cockroachdb: {
+    type: "postgres",
+    port: 26257,
+    user: "root",
+    label: "CockroachDB",
+    icon: "cockroachdb",
+  },
+  dm: { type: "dameng", port: 5236, user: "SYSDBA", label: "DM (Dameng)", icon: "dm" },
+  h2: { type: "h2", port: 9092, user: "sa", label: "H2", icon: "h2" },
+  "h2-legacy": { type: "h2", port: 9092, user: "sa", label: "H2 2.1 Legacy", icon: "h2" },
+  snowflake: { type: "snowflake", port: 443, user: "", label: "Snowflake", icon: "snowflake" },
+  trino: { type: "trino", port: 8080, user: "", label: "Trino", icon: "trino" },
+  prestosql: { type: "prestosql", port: 8080, user: "", label: "PrestoSQL", icon: "presto" },
+  hive: { type: "hive", port: 10000, user: "", label: "Apache Hive", icon: "hive" },
+  spark: { type: "spark", port: 10015, user: "", label: "Apache Spark", icon: "spark-logo.png" },
+  db2: { type: "db2", port: 50000, user: "db2inst1", label: "IBM DB2", icon: "db2" },
+  informix: { type: "informix", port: 9088, user: "informix", label: "Informix", icon: "informix" },
+  dremio: { type: "jdbc", port: 31010, user: "", label: "Dremio", icon: "dremio" },
+  neo4j: { type: "neo4j", port: 7687, user: "neo4j", label: "Neo4j", icon: "neo4j" },
+  cassandra: { type: "cassandra", port: 9042, user: "cassandra", label: "Cassandra", icon: "cassandra" },
+  bigquery: {
+    type: "bigquery",
+    port: 443,
+    user: "",
+    label: "BigQuery",
+    icon: "bigquery",
+    host: "https://www.googleapis.com/bigquery/v2",
+  },
+  kylin: { type: "kylin", port: 7070, user: "ADMIN", label: "Apache Kylin", icon: "kylin" },
+  sundb: { type: "sundb", port: 22000, user: "root", label: "SunDB", icon: "sundb" },
+  oscar: { type: "oscar", port: 2003, user: "SYSDBA", label: "神通 OSCAR", icon: "oscar" },
+  jdbc: { type: "jdbc", port: 0, user: "", label: "JDBC", icon: "jdbc" },
+  tdengine: { type: "tdengine", port: 6041, user: "root", label: "TDengine", icon: "tdengine" },
+  xugu: { type: "xugu", port: 5138, user: "", label: "虚谷 XuguDB", icon: "xugu" },
+  iotdb: { type: "iotdb", port: 6667, user: "root", label: "Apache IoTDB", icon: "iotdb" },
+  etcd: { type: "etcd", port: 2379, user: "", label: "etcd", icon: "etcd" },
+  zookeeper: { type: "zookeeper", port: 2181, user: "", label: "Apache ZooKeeper", icon: "zookeeper" },
+  mq: { type: "mq", port: 8080, user: "", label: "Apache Pulsar", icon: "pulsar", host: "127.0.0.1" },
+  kafka: { type: "mq", port: 9092, user: "", label: "Apache Kafka", icon: "kafka", host: "127.0.0.1" },
+  nacos: { type: "nacos", port: 8848, user: "nacos", label: "Nacos", icon: "nacos", host: "127.0.0.1" },
+  iris: { type: "iris", port: 1972, user: "_SYSTEM", label: "IRIS", icon: "iris" },
+  influxdb: { type: "influxdb", port: 8086, user: "", label: "InfluxDB", icon: "InfluxDB" },
+  custom_mysql: {
+    type: "mysql",
+    port: 3306,
+    user: "root",
+    label: "Custom",
+    icon: "mysql",
+    urlParams: "",
+  },
+  custom_postgres: {
+    type: "postgres",
+    port: 5432,
+    user: "postgres",
+    label: "Custom",
+    icon: "postgres",
+    urlParams: "",
+  },
+};
+
+function profileForConfig(config: ConnectionConfig) {
+  if (config.db_type === "oracle") return "oracle";
+  if (config.driver_profile && driverProfiles[config.driver_profile]) {
+    if (config.driver_profile === "oceanbase-oracle") return "oceanbase";
+    return config.driver_profile;
+  }
+  if (config.db_type === "mq" && (config.external_config as MqAdminConfig | undefined)?.systemKind === "kafka") return "kafka";
+  if (config.db_type === "mq") return "mq";
+  if (config.db_type === "dameng") return "dm";
+  if (config.db_type === "oceanbase-oracle") return "oceanbase";
+  return config.db_type;
+}
+
+function selectedProfile() {
+  return driverProfiles[selectedType.value] ?? driverProfiles.mysql;
+}
+
+function mqExtraRecord(config?: Partial<MqAdminConfig>): Record<string, unknown> {
+  const extra = config?.extra;
+  return extra && typeof extra === "object" && !Array.isArray(extra) ? (extra as Record<string, unknown>) : {};
+}
+
+function mqExtraString(extra: Record<string, unknown>, key: string): string {
+  const value = extra[key];
+  return typeof value === "string" ? value : "";
+}
+
+function mqExtraProperties(extra: Record<string, unknown>): Record<string, unknown> {
+  const value = extra.properties;
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+function mqExtraPropertyString(extra: Record<string, unknown>, key: string): string {
+  const value = mqExtraProperties(extra)[key];
+  return typeof value === "string" ? value : "";
+}
+
+function jaasStringValue(value: string): string {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"');
+}
+
+function parseJaasStringProperty(value: string, key: string): string {
+  const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = value.match(new RegExp(`${escapedKey}\\s*=\\s*"((?:\\\\.|[^"\\\\])*)"`, "i"));
+  if (!match) return "";
+  return match[1].replace(/\\(["\\])/g, "$1");
+}
+
+function resetMqFields(config?: Partial<MqAdminConfig>) {
+  const systemKind = config?.systemKind === "kafka" ? "kafka" : "pulsar";
+  const extra = mqExtraRecord(config);
+  const properties = mqExtraProperties(extra);
+  const jaasConfig = mqExtraPropertyString(extra, "sasl.jaas.config");
+  mqSystemKind.value = systemKind;
+  mqAdminUrl.value = config?.adminUrl?.trim() || (systemKind === "kafka" ? "" : "http://127.0.0.1:8080");
+  mqKafkaBootstrapServers.value = mqExtraString(extra, "bootstrapServers") || "127.0.0.1:9092";
+  mqKafkaSecurityProtocol.value = mqExtraString(extra, "securityProtocol") || MQ_KAFKA_SECURITY_PROTOCOL_AUTO;
+  mqKafkaSaslMechanism.value = mqExtraString(extra, "saslMechanism") || "PLAIN";
+  mqKafkaKerberosPrincipal.value = parseJaasStringProperty(jaasConfig, "principal");
+  mqKafkaKerberosKeytabPath.value = parseJaasStringProperty(jaasConfig, "keyTab");
+  mqKafkaKerberosServiceName.value = typeof properties["sasl.kerberos.service.name"] === "string" ? properties["sasl.kerberos.service.name"] : "kafka";
+  mqKafkaKrb5ConfPath.value = typeof properties["java.security.krb5.conf"] === "string" ? properties["java.security.krb5.conf"] : "";
+  mqTlsSkipVerify.value = !!config?.tlsSkipVerify;
+  mqPinnedVersion.value = pinnedVersionToSelection(config?.pinnedVersion);
+  const auth = (config?.auth || { kind: "none" }) as MqAuth;
+  mqAuthKind.value = detectMqUiAuthKind({
+    systemKind,
+    authKind: auth.kind,
+    saslMechanism: mqKafkaSaslMechanism.value,
+    jaasConfig,
+  });
+  mqToken.value = auth.token || "";
+  mqBasicUsername.value = auth.username || "";
+  mqBasicPassword.value = auth.password || "";
+  mqApiKeyHeader.value = auth.header || "Authorization";
+  mqApiKeyValue.value = auth.value || "";
+  mqOauthIssuerUrl.value = auth.issuerUrl || "";
+  mqOauthClientId.value = auth.clientId || "";
+  mqOauthClientSecret.value = auth.clientSecret || "";
+  mqOauthAudience.value = auth.audience || "";
+  mqOauthScope.value = auth.scope || "";
+  const tokenSigning = config?.tokenSigning;
+  mqTokenSigningMode.value = tokenSigning?.algorithm === "hs256" || tokenSigning?.algorithm === "rs256" ? tokenSigning.algorithm : "none";
+  mqTokenSigningKey.value = tokenSigning?.key || "";
+}
+
+function defaultMqFieldsForProfile(profile: string): Partial<MqAdminConfig> | undefined {
+  if (profile !== "kafka") return undefined;
+  return {
+    systemKind: "kafka",
+    adminUrl: "",
+    auth: { kind: "none" },
+    extra: { bootstrapServers: "127.0.0.1:9092" },
+  };
+}
+
+function hydrateMqFields(value: unknown) {
+  if (!value || typeof value !== "object") {
+    resetMqFields();
+    return;
+  }
+  resetMqFields(value as Partial<MqAdminConfig>);
+}
+
+watch(mqSystemKind, (kind) => {
+  if (kind === "kafka") {
+    if (!mqKafkaBootstrapServers.value.trim()) mqKafkaBootstrapServers.value = "127.0.0.1:9092";
+    if (!isMqAuthKindAllowedForSystem(kind, mqAuthKind.value)) mqAuthKind.value = "none";
+    return;
+  }
+  if (!mqAdminUrl.value.trim()) mqAdminUrl.value = "http://127.0.0.1:8080";
+});
+
+watch(mqAuthKind, (kind) => {
+  if (mqSystemKind.value === "kafka" && kind === "basic" && mqKafkaSaslMechanism.value.toUpperCase() === "GSSAPI") {
+    mqKafkaSaslMechanism.value = "PLAIN";
+  }
+});
+
+function resetNacosFields(config?: Partial<NacosAdminConfig>) {
+  nacosServerAddr.value = config?.serverAddr?.trim() || NACOS_DEFAULT_CONSOLE_URL;
+  nacosNamespace.value = config?.namespace || "";
+  nacosContextPath.value = config?.contextPath || "";
+  nacosTlsSkipVerify.value = !!config?.tlsSkipVerify;
+  nacosPageSize.value = Number(config?.pageSize) > 0 ? Number(config?.pageSize) : 20;
+  const auth = (config?.auth || { kind: "none" }) as NacosAuthConfig;
+  nacosAuthKind.value = auth.kind || "none";
+  nacosUsername.value = auth.username || "nacos";
+  nacosPassword.value = auth.password || "";
+}
+
+function hydrateNacosFields(value: unknown) {
+  if (!value || typeof value !== "object") {
+    resetNacosFields();
+    return;
+  }
+  resetNacosFields(value as Partial<NacosAdminConfig>);
+}
+
+const influxDbVersion = ref<InfluxDbVersion>("1");
+const influxDbOrg = ref("");
+
+function resetInfluxDbFields(config?: Partial<InfluxDbExternalConfig>) {
+  influxDbVersion.value = config?.version === "2" ? "2" : "1";
+  influxDbOrg.value = config?.org?.trim() || "";
+}
+
+function hydrateInfluxDbFields(value: unknown) {
+  if (!value || typeof value !== "object") {
+    resetInfluxDbFields();
+    return;
+  }
+  resetInfluxDbFields(value as Partial<InfluxDbExternalConfig>);
+}
+
+function resetHiveKerberosFields(config?: Pick<ConnectionConfig, "url_params" | "agent_java_options">) {
+  const kerberos = hiveKerberosFormConfig(config?.url_params, config?.agent_java_options);
+  hiveAuthMode.value = kerberos.authMode;
+  hivePrincipal.value = kerberos.principal;
+  hiveKrb5ConfPath.value = kerberos.krb5ConfPath;
+  hiveJaasConfigPath.value = kerberos.jaasConfigPath;
+  hiveUseSubjectCredsOnlyFalse.value = kerberos.useSubjectCredsOnlyFalse;
+  hiveExtraJavaOptions.value = kerberos.extraJavaOptions;
+}
+
+function buildInfluxDbExternalConfig(): InfluxDbExternalConfig {
+  if (influxDbVersion.value !== "2") return { version: "1" };
+  const org = influxDbOrg.value.trim();
+  if (!org) throw new Error("InfluxDB 2.x organization is required");
+  if (!form.value.password.trim()) throw new Error("InfluxDB 2.x token is required");
+  if (!form.value.database?.trim()) throw new Error("InfluxDB 2.x bucket is required");
+  return { version: "2", org };
+}
+
+watch(influxDbVersion, (version) => {
+  if (form.value.db_type !== "influxdb") return;
+  if (version === "2") {
+    form.value.username = "";
+  }
+});
+
+function requireMqField(value: string, message: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) throw new Error(message);
+  return trimmed;
+}
+
+function buildMqAuth(): MqAuth {
+  switch (mqAuthKind.value) {
+    case "token":
+      return { kind: "token", token: requireMqField(mqToken.value, "Token auth requires a token") };
+    case "basic":
+      return {
+        kind: "basic",
+        username: requireMqField(mqBasicUsername.value, "Basic auth requires a username"),
+        password: mqBasicPassword.value,
+      };
+    case "apiKey":
+      return {
+        kind: "apiKey",
+        header: requireMqField(mqApiKeyHeader.value, "API key auth requires a header"),
+        value: requireMqField(mqApiKeyValue.value, "API key auth requires a value"),
+      };
+    case "oauth2":
+      return {
+        kind: "oauth2",
+        issuerUrl: requireMqField(mqOauthIssuerUrl.value, "OAuth2 auth requires an issuer URL"),
+        clientId: requireMqField(mqOauthClientId.value, "OAuth2 auth requires a client ID"),
+        clientSecret: requireMqField(mqOauthClientSecret.value, "OAuth2 auth requires a client secret"),
+        audience: mqOauthAudience.value.trim() || undefined,
+        scope: mqOauthScope.value.trim() || undefined,
+      };
+    default:
+      return { kind: "none" };
+  }
+}
+
+function buildKafkaKerberosJaasConfig(): string {
+  const principal = requireMqField(mqKafkaKerberosPrincipal.value, t("connection.kafkaKerberosPrincipalRequired"));
+  const keytab = requireMqField(mqKafkaKerberosKeytabPath.value, t("connection.kafkaKerberosKeytabRequired"));
+  return `com.sun.security.auth.module.Krb5LoginModule required useKeyTab=true storeKey=true keyTab="${jaasStringValue(keytab)}" principal="${jaasStringValue(principal)}";`;
+}
+
+function buildMqTokenSigning() {
+  if (mqTokenSigningMode.value === "none") return undefined;
+  return {
+    algorithm: mqTokenSigningMode.value,
+    key: requireMqField(mqTokenSigningKey.value, "Broker token signing key is required"),
+  };
+}
+
+function buildMqAdminConfig(): MqAdminConfig {
+  const systemKind = mqSystemKind.value;
+  if (systemKind === "kafka") {
+    const bootstrapServers = normalizeKafkaBootstrapServers(mqKafkaBootstrapServers.value);
+    const extra: Record<string, unknown> = { bootstrapServers };
+    const securityProtocol = mqKafkaSecurityProtocol.value === MQ_KAFKA_SECURITY_PROTOCOL_AUTO ? "" : mqKafkaSecurityProtocol.value.trim();
+    const saslMechanism = mqAuthKind.value === "kerberos" ? "GSSAPI" : mqKafkaSaslMechanism.value.trim();
+    const properties: Record<string, string> = {};
+    if (securityProtocol) extra.securityProtocol = securityProtocol;
+    if (mqAuthKind.value === "basic" && saslMechanism) extra.saslMechanism = saslMechanism;
+    if (mqAuthKind.value === "kerberos") {
+      extra.saslMechanism = "GSSAPI";
+      properties["sasl.jaas.config"] = buildKafkaKerberosJaasConfig();
+      properties["sasl.kerberos.service.name"] = mqKafkaKerberosServiceName.value.trim() || "kafka";
+      if (mqKafkaKrb5ConfPath.value.trim()) {
+        properties["java.security.krb5.conf"] = mqKafkaKrb5ConfPath.value.trim();
+      }
+    }
+    if (Object.keys(properties).length) extra.properties = properties;
+    return {
+      systemKind: mqSystemKind.value,
+      adminUrl: "",
+      auth: buildMqAuth(),
+      tlsSkipVerify: mqTlsSkipVerify.value || undefined,
+      extra,
+    };
+  }
+
+  return {
+    systemKind: mqSystemKind.value,
+    adminUrl: requireMqField(mqAdminUrl.value, "MQ Admin URL is required"),
+    auth: buildMqAuth(),
+    tlsSkipVerify: mqTlsSkipVerify.value || undefined,
+    pinnedVersion: selectionToPinnedVersion(mqPinnedVersion.value),
+    tokenSigning: buildMqTokenSigning(),
+  };
+}
+
+function buildNacosAuth(): NacosAuthConfig {
+  if (nacosAuthKind.value === "usernamePassword") {
+    return {
+      kind: "usernamePassword",
+      username: requireMqField(nacosUsername.value, t("connection.nacosUsernameRequired")),
+      password: nacosPassword.value,
+    };
+  }
+  return { kind: "none" };
+}
+
+function buildNacosAdminConfig(): NacosAdminConfig {
+  return {
+    serverAddr: requireMqField(nacosServerAddr.value, t("connection.nacosConsoleUrlRequired")),
+    namespace: nacosNamespace.value.trim() || undefined,
+    contextPath: nacosContextPath.value.trim(),
+    auth: buildNacosAuth(),
+    tlsSkipVerify: nacosTlsSkipVerify.value || undefined,
+    pageSize: Number(nacosPageSize.value) > 0 ? Number(nacosPageSize.value) : 20,
+  };
+}
+
+function dockerNacosConsoleFallbackUrl(serverAddr: string): string | null {
+  let parsed: URL;
+  try {
+    parsed = new URL(serverAddr);
+  } catch {
+    return null;
+  }
+  const port = parsed.port || (parsed.protocol === "https:" ? "443" : "80");
+  const host = parsed.hostname.toLowerCase();
+  if (port !== NACOS_LEGACY_SERVER_PORT || !["127.0.0.1", "localhost", "::1"].includes(host)) {
+    return null;
+  }
+  parsed.port = NACOS_DOCKER_CONSOLE_PORT;
+  return parsed.toString().replace(/\/$/, "");
+}
+
+function isNacosAdminEndpointNotFound(message: string): boolean {
+  return /Nacos admin endpoint was not found/i.test(message);
+}
+
+async function tryNacosDockerConsoleFallback(config: ConnectionConfig, originalError: string, runId: number): Promise<string | null> {
+  if (config.db_type !== "nacos" || !isNacosAdminEndpointNotFound(originalError)) return null;
+  const fallbackUrl = dockerNacosConsoleFallbackUrl(nacosServerAddr.value);
+  if (!fallbackUrl || fallbackUrl === nacosServerAddr.value.trim()) return null;
+
+  const previousUrl = nacosServerAddr.value;
+  nacosServerAddr.value = fallbackUrl;
+  try {
+    const fallbackConfig = connectionConfigForSubmit(config.id);
+    const message = await testConnectionWithTimeout(fallbackConfig, runId);
+    return `${message} ${t("connection.nacosConsoleUrlAutoAdjusted", { from: previousUrl.trim(), to: fallbackUrl })}`;
+  } catch {
+    nacosServerAddr.value = previousUrl;
+    return null;
+  }
+}
+
+function errorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+function connectionErrorWithDriverUpdateHint(config: ConnectionConfig, message: string): string {
+  message = appendConnectionErrorHints(config, message, t);
+  if (!hasAgentDriverUpdate(config.db_type, agentDrivers.value, config.driver_profile)) return message;
+  return appendAgentDriverUpdateHint(message, t("connection.agentDriverUpdateConnectionHint"));
+}
+
+function installedAgentDriver(drivers: readonly AgentDriverInstallState[], key: string): AgentDriverInstallState | undefined {
+  return drivers.find((driver) => driver.db_type === key);
+}
+
+async function refreshLocalAgentDrivers(): Promise<AgentDriverInstallState[]> {
+  const drivers = await api.listInstalledAgentsLocal();
+  agentDrivers.value = drivers;
+  return drivers;
+}
+
+function beginAgentDriverInstall(driverKey: string, label: string) {
+  agentInstallDriverKey.value = driverKey;
+  agentInstallLabel.value = label;
+  agentInstallProgress.value = null;
+  agentInstallError.value = "";
+  agentInstallRunning.value = true;
+  showAgentInstallDialog.value = true;
+}
+
+function finishAgentDriverInstall() {
+  agentInstallRunning.value = false;
+  agentInstallProgress.value = null;
+  agentInstallError.value = "";
+  showAgentInstallDialog.value = false;
+}
+
+function failAgentDriverInstall(error: unknown) {
+  agentInstallRunning.value = false;
+  agentInstallError.value = errorMessage(error);
+  showAgentInstallDialog.value = true;
+}
+
+function showConnectionError(message: string) {
+  connectionErrorDetail.value = translateBackendError(t, message);
+  showConnectionErrorDialog.value = true;
+}
+
+function setAgentInstallDialogOpen(value: boolean) {
+  if (value || canCloseAgentInstallDialog.value) {
+    showAgentInstallDialog.value = value;
+  }
+}
+
+function handleAgentInstallProgress(payload: DriverInstallProgress) {
+  if (!agentInstallRunning.value || !agentInstallDriverKey.value) return;
+  if (payload.db_type && payload.db_type !== agentInstallDriverKey.value) return;
+  if (payload.step === "done" || payload.step === "all-done") {
+    agentInstallProgress.value = null;
+    return;
+  }
+  agentInstallProgress.value = payload;
+}
+
+function formatInstallSize(bytes: number): string {
+  if (!bytes) return "0 B";
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+async function ensureRequiredAgentDriverInstalled(config: ConnectionConfig): Promise<void> {
+  if (requiresSqlServerLegacyCompatibilityComponent(config)) {
+    await installSqlServerLegacyCompatibilityComponentIfNeeded();
+  }
+
+  const driverKey = agentDriverInstallKey(config.db_type, config.driver_profile);
+  if (!driverKey) return;
+
+  let drivers = agentDrivers.value.length ? agentDrivers.value : await refreshLocalAgentDrivers();
+  if (!showAgentDriverInstallHint(config.db_type, drivers, config.driver_profile)) return;
+  if (installedAgentDriver(drivers, driverKey)?.installed === true) return;
+
+  drivers = await refreshLocalAgentDrivers();
+  if (installedAgentDriver(drivers, driverKey)?.installed === true) return;
+
+  const label = config.driver_label || driverKey;
+  testResult.value = { ok: true, message: `Installing ${label} driver...` };
+  beginAgentDriverInstall(driverKey, label);
+  try {
+    await api.installAgent(driverKey);
+    await refreshLocalAgentDrivers();
+    finishAgentDriverInstall();
+  } catch (error) {
+    testResult.value = { ok: false, message: errorMessage(error) };
+    failAgentDriverInstall(error);
+    throw error;
+  }
+}
+
+async function installSqlServerLegacyCompatibilityComponentIfNeeded(): Promise<boolean> {
+  if (await api.isAgentInstalled(SQLSERVER_LEGACY_COMPATIBILITY_DRIVER_KEY)) return true;
+
+  const label = t("connection.sqlServerLegacyCompatibilityComponent");
+  testResult.value = { ok: true, message: t("connection.sqlServerLegacyCompatibilityComponentInstalling") };
+  beginAgentDriverInstall(SQLSERVER_LEGACY_COMPATIBILITY_DRIVER_KEY, label);
+  try {
+    await api.installAgent(SQLSERVER_LEGACY_COMPATIBILITY_DRIVER_KEY);
+    await refreshLocalAgentDrivers();
+    finishAgentDriverInstall();
+  } catch (error) {
+    testResult.value = { ok: false, message: errorMessage(error) };
+    failAgentDriverInstall(error);
+    throw error;
+  }
+  return true;
+}
+
+async function onSqlServerLegacyCompatibilityModeChange(event: Event) {
+  if (form.value.db_type !== "sqlserver") return;
+  const input = event.target instanceof HTMLInputElement ? event.target : null;
+  const enabled = input?.checked === true;
+  if (!enabled) {
+    form.value.url_params = setSqlServerLegacyCompatibilityMode(form.value.url_params, false);
+    return;
+  }
+
+  if (input) input.checked = false;
+  try {
+    await installSqlServerLegacyCompatibilityComponentIfNeeded();
+    form.value.url_params = setSqlServerLegacyCompatibilityMode(form.value.url_params, true);
+    testResult.value = { ok: true, message: t("connection.sqlServerLegacyCompatibilityModeEnabled") };
+  } catch {
+    form.value.url_params = setSqlServerLegacyCompatibilityMode(form.value.url_params, false);
+    if (input) input.checked = false;
+  }
+}
+
+function isSqlServerTlsHandshakeFailure(message: string): boolean {
+  const text = message.toLowerCase();
+  return text.includes("sql server") && text.includes("tls") && (text.includes("handshake") || text.includes("eof") || text.includes("performing i/o"));
+}
+
+async function testConnectionWithTimeout(config: ConnectionConfig, runId: number): Promise<string> {
+  const timeoutMs = connectionAttemptTimeoutMs(config);
+  const timeoutMessage = connectionAttemptTimeoutMessage(timeoutMs);
+  const promise = api.testConnection(config);
+  let timedOut = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  void promise.catch((error) => {
+    if (!timedOut) return;
+    if (runId !== testRunId) return;
+    testResult.value = {
+      ok: false,
+      message: connectionErrorWithDriverUpdateHint(config, connectionAttemptOriginalErrorMessage(timeoutMessage, errorMessage(error))),
+    };
+  });
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<string>((_, reject) => {
+        timer = setTimeout(() => {
+          timedOut = true;
+          reject(new Error(timeoutMessage));
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+function applyMqAdminUrl(config: LegacyConnectionConfig, adminUrl: string) {
+  let parsed: URL;
+  try {
+    parsed = new URL(adminUrl);
+  } catch {
+    throw new Error("MQ Admin URL is invalid");
+  }
+  const port = Number(parsed.port) || (parsed.protocol === "https:" ? 443 : 8080);
+  config.host = parsed.hostname;
+  config.port = port;
+  config.ssl = parsed.protocol === "https:";
+}
+
+function applyMqKafkaBootstrapServers(config: LegacyConnectionConfig, bootstrapServers: string, securityProtocol?: string) {
+  const first = normalizeKafkaBootstrapServers(bootstrapServers).split(",")[0];
+  if (!first) throw new Error("Kafka bootstrap servers are required");
+  let parsed: URL;
+  try {
+    parsed = new URL(`kafka://${first}`);
+  } catch {
+    throw new Error("Kafka bootstrap servers are invalid");
+  }
+  config.host = parsed.hostname;
+  config.port = Number(parsed.port) || 9092;
+  config.ssl = securityProtocol === "SSL" || securityProtocol === "SASL_SSL";
+}
+
+function applyNacosServerAddr(config: LegacyConnectionConfig, serverAddr: string) {
+  let parsed: URL;
+  try {
+    parsed = new URL(serverAddr);
+  } catch {
+    throw new Error("Nacos server address is invalid");
+  }
+  const port = Number(parsed.port) || (parsed.protocol === "https:" ? 443 : 8848);
+  config.host = parsed.hostname;
+  config.port = port;
+  config.ssl = parsed.protocol === "https:";
+}
+
+function applyDremioConnectionMode(mode: DremioConnectionMode) {
+  rememberCurrentDremioConnectionUrl();
+  dremioConnectionMode.value = mode;
+  form.value.connection_string = dremioConnectionUrls.value[mode] || dremioDefaultConnectionUrl(mode);
+  if (isDremioGeneratedDefaultDriverClass(form.value.jdbc_driver_class)) {
+    form.value.jdbc_driver_class = dremioDefaultDriverClass(mode);
+  }
+}
+
+function rememberCurrentDremioConnectionUrl() {
+  if (form.value.driver_profile !== "dremio") return;
+  const url = form.value.connection_string?.trim();
+  dremioConnectionUrls.value[dremioConnectionMode.value] = url || dremioDefaultConnectionUrl();
+}
+
+function resetDremioConnectionUrls(mode: DremioConnectionMode = "legacy", url?: string) {
+  dremioConnectionUrls.value = {
+    "arrow-flight-sql": DREMIO_ARROW_FLIGHT_SQL_JDBC_URL,
+    legacy: DREMIO_LEGACY_JDBC_URL,
+  };
+  if (url?.trim()) {
+    dremioConnectionUrls.value[mode] = url.trim();
+  }
+}
+
+function dremioDefaultConnectionUrl(mode = dremioConnectionMode.value) {
+  return mode === "legacy" ? DREMIO_LEGACY_JDBC_URL : DREMIO_ARROW_FLIGHT_SQL_JDBC_URL;
+}
+
+function dremioDefaultDriverClass(mode = dremioConnectionMode.value) {
+  return mode === "legacy" ? DREMIO_LEGACY_JDBC_DRIVER_CLASS : DREMIO_ARROW_FLIGHT_SQL_JDBC_DRIVER_CLASS;
+}
+
+function isDremioGeneratedDefaultDriverClass(value: string | undefined) {
+  const driverClass = value?.trim() || "";
+  return !driverClass || driverClass === DREMIO_ARROW_FLIGHT_SQL_JDBC_DRIVER_CLASS || driverClass === DREMIO_LEGACY_JDBC_DRIVER_CLASS;
+}
+
+function restoreDremioConnectionDefaultsIfEmpty() {
+  if (form.value.driver_profile !== "dremio") return;
+  if (!form.value.connection_string?.trim()) {
+    form.value.connection_string = dremioDefaultConnectionUrl();
+  }
+  if (isDremioGeneratedDefaultDriverClass(form.value.jdbc_driver_class)) {
+    form.value.jdbc_driver_class = dremioDefaultDriverClass();
+  }
+}
+
+function syncDremioConnectionModeFromUrl() {
+  if (form.value.driver_profile !== "dremio") return;
+  restoreDremioConnectionDefaultsIfEmpty();
+  const nextMode = dremioConnectionModeForConfig({
+    connection_string: form.value.connection_string,
+    jdbc_driver_class: "",
+  });
+  dremioConnectionUrls.value[nextMode] = form.value.connection_string?.trim() || dremioDefaultConnectionUrl(nextMode);
+  if (nextMode === dremioConnectionMode.value) return;
+  dremioConnectionMode.value = nextMode;
+  if (isDremioGeneratedDefaultDriverClass(form.value.jdbc_driver_class)) {
+    form.value.jdbc_driver_class = dremioDefaultDriverClass(nextMode);
+  }
+}
+
+function dremioConnectionModeForConfig(config: Pick<ConnectionConfig, "connection_string" | "jdbc_driver_class">): DremioConnectionMode {
+  const haystack = `${config.connection_string || ""}\n${config.jdbc_driver_class || ""}`.toLowerCase();
+  return haystack.includes("jdbc:dremio:") || haystack.includes("com.dremio.jdbc.driver") ? "legacy" : "arrow-flight-sql";
+}
+
+function isCustomCompatibleProfile() {
+  return selectedType.value === "custom_mysql" || selectedType.value === "custom_postgres";
+}
+
+function applyProfile(val: string, preserveConnectionFields = false) {
+  const profile = driverProfiles[val];
+  if (!profile) return;
+
+  selectedType.value = val;
+  form.value.db_type = profile.type;
+  form.value.driver_profile = val;
+  form.value.driver_label = isCustomCompatibleProfile() ? customDriverName.value.trim() || profile.label : profile.label;
+
+  if (!preserveConnectionFields) {
+    form.value.port = profile.port;
+    form.value.username = profile.user;
+    form.value.url_params = profile.urlParams || "";
+    form.value.agent_java_options = [];
+    if (profile.host) {
+      form.value.host = profile.host;
+    }
+    if (profile.type === "sqlite" || profile.type === "duckdb" || profile.type === "access") {
+      form.value.host = "";
+    }
+    if (profile.type === "h2") {
+      h2ConnectionMode.value = "file";
+      form.value.host = "";
+      form.value.port = 0;
+      form.value.connection_string = undefined;
+    }
+    if (profile.type === "jdbc") {
+      form.value.host = "";
+      form.value.connection_string = "";
+      form.value.jdbc_driver_class = "";
+      form.value.jdbc_driver_paths = [];
+      jdbcDriverPathsInput.value = "";
+      if (val === "dremio") {
+        resetDremioConnectionUrls();
+        applyDremioConnectionMode("legacy");
+      }
+    }
+    if (profile.type === "prestosql") {
+      form.value.connection_string = undefined;
+      form.value.jdbc_driver_class = "io.prestosql.jdbc.PrestoDriver";
+      form.value.jdbc_driver_paths = [];
+      jdbcDriverPathsInput.value = "";
+      jdbcManualClasspathOpen.value = true;
+      applyPrestoSqlBuiltinDriverPathsIfAvailable();
+    }
+    if (profile.type === "mq") {
+      resetMqFields(defaultMqFieldsForProfile(val));
+      form.value.database = undefined;
+      form.value.connection_string = undefined;
+    }
+    if (profile.type === "zookeeper") {
+      form.value.database = undefined;
+      form.value.connection_string = "";
+      form.value.ssl = false;
+      form.value.ca_cert_path = "";
+      form.value.client_cert_path = "";
+      form.value.client_key_path = "";
+    }
+    if (profile.type === "nacos") {
+      resetNacosFields();
+      form.value.database = undefined;
+      form.value.connection_string = undefined;
+      form.value.url_params = "";
+    }
+    if (profile.type === "influxdb") {
+      resetInfluxDbFields();
+      form.value.database = undefined;
+      form.value.password = "";
+      form.value.connection_string = undefined;
+    }
+    resetHiveKerberosFields(profile.type === "hive" ? form.value : undefined);
+  }
+}
+
+function switchOceanbaseMode(mode: "mysql" | "oracle") {
+  oceanbaseSubMode.value = mode;
+  if (mode === "mysql") {
+    applyProfile("oceanbase", false);
+  } else {
+    applyProfile("oceanbase-oracle", false);
+    selectedType.value = "oceanbase";
+  }
+  resetTestState();
+}
+
+function switchGbaseProfile(profile: "gbase8a" | "gbase8s") {
+  applyProfile(profile, false);
+  selectedType.value = "gbase";
+  resetTestState();
+}
+
+watch(
+  () => props.editConfig,
+  (config) => {
+    if (config) {
+      const legacyConfig = config as LegacyConnectionConfig;
+      const profile = profileForConfig(config);
+      const oceanbaseMode = profile === "oceanbase" ? oceanbaseSubModeFromConfig(config) : "mysql";
+      const oceanbasePatch = profile === "oceanbase" ? oceanbaseModeConnectionPatch(oceanbaseMode) : null;
+      editingId.value = config.id;
+      const profileConfig = driverProfiles[profile];
+      form.value = {
+        name: config.name,
+        db_type: oceanbasePatch?.db_type || profileConfig?.type || config.db_type,
+        driver_profile: oceanbasePatch?.driver_profile || profile,
+        driver_label: config.driver_label || oceanbasePatch?.driver_label || driverProfiles[profile]?.label || config.db_type,
+        url_params: config.url_params || "",
+        agent_java_options: config.agent_java_options || [],
+        host: config.db_type === "h2" && h2FilePathFromJdbcUrl(config.connection_string) ? h2FilePathFromJdbcUrl(config.connection_string) : config.host,
+        port: profile === "tdengine" && (config.port === 0 || config.port === 6030) ? 6041 : config.port,
+        username: config.username,
+        password: config.password,
+        database: config.database,
+        color: config.color || "",
+        transport_layers: transportLayersForConfig(legacyConfig),
+        connect_timeout_secs: config.connect_timeout_secs || 10,
+        query_timeout_secs: config.query_timeout_secs ?? 30,
+        idle_timeout_secs: config.idle_timeout_secs ?? 60,
+        keepalive_interval_secs: config.keepalive_interval_secs ?? 30,
+        ssl: config.ssl || false,
+        ca_cert_path: config.ca_cert_path || "",
+        client_cert_path: config.client_cert_path || "",
+        client_key_path: config.client_key_path || "",
+        sysdba: config.sysdba || isOracleSysUser(config),
+        oracle_connection_type: config.oracle_connection_type || "service_name",
+        connection_string: config.connection_string,
+        jdbc_driver_class: config.jdbc_driver_class,
+        jdbc_driver_paths: config.jdbc_driver_paths || [],
+        redis_connection_mode: config.redis_connection_mode || "standalone",
+        redis_sentinel_master: config.redis_sentinel_master || "",
+        redis_sentinel_nodes: config.redis_sentinel_nodes || "",
+        redis_sentinel_username: config.redis_sentinel_username || "",
+        redis_sentinel_password: config.redis_sentinel_password || "",
+        redis_sentinel_tls: config.redis_sentinel_tls || false,
+        redis_cluster_nodes: config.redis_cluster_nodes || "",
+        redis_key_separator: config.redis_key_separator ?? ":",
+        redis_scan_page_size: config.redis_scan_page_size ?? REDIS_SCAN_PAGE_SIZE_DEFAULT,
+        etcd_endpoints: config.etcd_endpoints || "",
+        informix_server: config.informix_server || "",
+        external_config: config.external_config,
+        read_only: config.read_only || false,
+        is_production: config.is_production || false,
+        production_databases: config.production_databases || [],
+        visible_databases: config.visible_databases,
+      };
+      productionProtectionEnabled.value = !!config.is_production || (config.production_databases?.length ?? 0) > 0;
+      connectionUrlInput.value = config.db_type === "h2" && config.connection_string ? config.connection_string : "";
+      appliedConnectionUrlInput.value = connectionUrlInput.value.trim();
+      if (config.db_type === "mq") {
+        hydrateMqFields(config.external_config);
+      } else {
+        resetMqFields();
+      }
+      if (config.db_type === "nacos") {
+        hydrateNacosFields(config.external_config);
+      } else {
+        resetNacosFields();
+      }
+      if (config.db_type === "influxdb") {
+        hydrateInfluxDbFields(config.external_config);
+      } else {
+        resetInfluxDbFields();
+      }
+      resetHiveKerberosFields(config.db_type === "hive" ? config : undefined);
+      h2ConnectionMode.value = h2ConnectionModeForConfig(config);
+      customColorInput.value = config.color || "";
+      selectedTransportLayerId.value = form.value.transport_layers?.[0]?.id || null;
+      selectedType.value = profile;
+      if (profile === "oceanbase") {
+        oceanbaseSubMode.value = oceanbaseMode;
+      }
+      if (profile === "gbase8a" || profile === "gbase8s") {
+        selectedType.value = "gbase";
+      }
+      dremioConnectionMode.value = profile === "dremio" ? dremioConnectionModeForConfig(config) : "legacy";
+      resetDremioConnectionUrls(dremioConnectionMode.value, profile === "dremio" ? config.connection_string : undefined);
+      mongoUseUrl.value = !!config.connection_string;
+      jdbcDriverPathsInput.value = (config.jdbc_driver_paths || []).join("\n");
+      jdbcManualClasspathOpen.value = config.db_type === "prestosql" || (config.jdbc_driver_paths || []).length > 0;
+      customDriverName.value = isCustomCompatibleProfile() ? config.driver_label || "" : "";
+      dialogStep.value = "config";
+      configTab.value = initialConfigTab();
+    } else {
+      editingId.value = null;
+      form.value = defaultForm();
+      productionProtectionEnabled.value = false;
+      selectedTransportLayerId.value = null;
+      selectedType.value = "mysql";
+      customDriverName.value = "";
+      resetMqFields();
+      resetNacosFields();
+      resetInfluxDbFields();
+      resetHiveKerberosFields();
+      oceanbaseSubMode.value = "mysql";
+      h2ConnectionMode.value = "file";
+      dremioConnectionMode.value = "legacy";
+      resetDremioConnectionUrls();
+      dialogStep.value = "select";
+      configTab.value = "connection";
+    }
+    resetTestState();
+  },
+  { immediate: true },
+);
+
+const isEditing = ref(false);
+watch(
+  () => editingId.value,
+  (v) => {
+    isEditing.value = !!v;
+  },
+);
+
+const databaseLabel = computed(() => {
+  if (form.value.db_type === "oracle") return t("connection.serviceName");
+  if (form.value.db_type === "influxdb" && influxDbVersion.value === "2") return "Bucket";
+  return t("connection.database");
+});
+
+const databasePlaceholder = computed(() => {
+  if (form.value.db_type === "kingbase") return t("connection.databasePlaceholderRequired");
+  const fallback = defaultDatabaseForProfile();
+  if (!fallback) return t("connection.databasePlaceholder");
+  return t("connection.databasePlaceholderWithDefault", { database: fallback });
+});
+
+const transportLayers = computed(() => form.value.transport_layers || []);
+const selectedTransportLayer = computed(() => {
+  const layers = transportLayers.value;
+  return layers.find((layer) => layer.id === selectedTransportLayerId.value) || layers[0] || null;
+});
+const selectedSshLayer = computed(() => (selectedTransportLayer.value?.type === "ssh" ? selectedTransportLayer.value : null));
+const selectedProxyLayer = computed(() => (selectedTransportLayer.value?.type === "proxy" ? selectedTransportLayer.value : null));
+const selectedHttpTunnelLayer = computed(() => (selectedTransportLayer.value?.type === "http_tunnel" ? selectedTransportLayer.value : null));
+
+const tunnelProfiles = computed(() => tunnelProfileStore.profiles);
+const selectedLayerProfileId = computed(() => selectedTransportLayer.value?.profile_id || "");
+const selectedLayerProfile = computed(() => tunnelProfileStore.profileById(selectedLayerProfileId.value));
+
+function tunnelProfileOptionLabel(profile: (typeof tunnelProfiles.value)[number]): string {
+  const summary = tunnelProfileSummary(profile);
+  if (!profile.name?.trim()) return summary || profile.id;
+  return summary ? `${profile.name} (${summary})` : profile.name;
+}
+
+function applyTunnelProfileSelection(value: unknown) {
+  const selected = selectedTransportLayer.value;
+  if (!selected) return;
+  if (!value || value === "custom") {
+    if (!selected.profile_id) return;
+    const detached = detachTunnelProfileLayer(selected, tunnelProfileStore.profileById(selected.profile_id));
+    form.value.transport_layers = transportLayers.value.map((layer) => (layer.id === selected.id ? detached : layer));
+  } else {
+    const profile = tunnelProfileStore.profileById(String(value));
+    if (!profile) return;
+    const stub = tunnelProfileReferenceLayer(profile, selected);
+    form.value.transport_layers = transportLayers.value.map((layer) => (layer.id === selected.id ? stub : layer));
+  }
+  resetTestState();
+}
+
+function transportLayerDefaultName(layer: TransportLayerConfig, index: number): string {
+  if (layer.type === "proxy") return `Proxy ${index + 1}`;
+  if (layer.type === "http_tunnel") return t("connection.httpTunnelDefaultName", { index: index + 1 });
+  return t("connection.sshHopDefaultName", { index: index + 1 });
+}
+
+function transportLayerDisplayName(layer: TransportLayerConfig, index: number): string {
+  if (layer.profile_id) {
+    const profile = tunnelProfileStore.profileById(layer.profile_id);
+    if (profile) return profile.name?.trim() || tunnelProfileSummary(profile) || transportLayerDefaultName(layer, index);
+    return layer.name?.trim() || t("connection.tunnelProfileMissingName");
+  }
+  const target = layer.type === "http_tunnel" ? layer.url?.trim() : layer.host?.trim();
+  return layer.name?.trim() || target || transportLayerDefaultName(layer, index);
+}
+
+const transportPathSegments = computed(() => {
+  const layers = transportLayers.value.filter((layer) => layer.enabled !== false);
+  return ["DBX", ...layers.map(transportLayerDisplayName), form.value.host || "Database"];
+});
+
+function defaultDatabaseForProfile() {
+  if (form.value.db_type === "redshift") return "dev";
+  if (form.value.db_type === "gaussdb") return "postgres";
+  if (form.value.db_type === "kwdb") return "defaultdb";
+  if (form.value.db_type === "databend") return "default";
+  if (selectedType.value === "cockroachdb") return "defaultdb";
+  if (form.value.db_type === "highgo") return "highgo";
+  if (form.value.db_type === "yashandb") return "yasdb";
+  if (form.value.db_type === "postgres" || form.value.db_type === "vastbase") return "postgres";
+  if (form.value.db_type === "sqlserver") return "master";
+  if (form.value.db_type === "oracle") return "ORCL";
+  if (form.value.db_type === "h2" && h2ConnectionMode.value === "tcp") return "test";
+  return "";
+}
+
+function onDbTypeChange(val: string) {
+  customDriverName.value = "";
+  applyProfile(val, !!editingId.value);
+  resetTestState();
+  resetVisibleSchemasState();
+}
+
+function switchH2ConnectionMode(mode: H2ConnectionMode) {
+  h2ConnectionMode.value = mode;
+  if (mode === "file") {
+    form.value.host = h2FilePathFromJdbcUrl(form.value.connection_string) || "";
+    form.value.port = 0;
+  } else {
+    form.value.host = form.value.host.trim() && !isH2FileJdbcUrlLikePath(form.value.host) ? form.value.host : "127.0.0.1";
+    form.value.port = form.value.port || 9092;
+    if (form.value.connection_string && h2FilePathFromJdbcUrl(form.value.connection_string)) {
+      form.value.connection_string = undefined;
+    }
+  }
+  resetTestState();
+}
+
+function isH2FileJdbcUrlLikePath(value: string): boolean {
+  return /\.(mv|h2)\.db$/i.test(value.trim()) || value.includes("/") || value.includes("\\");
+}
+
+const iconTypeMap: Record<string, string> = {
+  mysql: "mysql",
+  postgres: "postgres",
+  sqlite: "sqlite",
+  rqlite: "rqlite",
+  turso: "turso",
+  "cloudflare-d1": "cloudflare-d1",
+  access: "access",
+  redis: "redis",
+  mongodb: "mongodb",
+  duckdb: "duckdb",
+  clickhouse: "clickhouse",
+  sqlserver: "sqlserver",
+  oracle: "oracle",
+  elasticsearch: "elasticsearch",
+  qdrant: "qdrant",
+  milvus: "milvus",
+  weaviate: "weaviate",
+  chromadb: "chromadb",
+  mariadb: "mariadb",
+  tidb: "tidb",
+  oceanbase: "oceanbase",
+  "oceanbase-oracle": "oceanbase",
+  goldendb: "goldendb",
+  databend: "databend",
+  tdsql: "tdsql",
+  polardb: "polardb",
+  greatsql: "greatsql",
+  databricks: "databricks",
+  saphana: "saphana",
+  teradata: "teradata",
+  vertica: "vertica",
+  firebird: "firebird",
+  exasol: "exasol",
+  gbase: "gbase",
+  opengauss: "opengauss",
+  gaussdb: "gaussdb",
+  kwdb: "kwdb",
+  questdb: "questdb",
+  kingbase: "kingbase",
+  highgo: "highgo",
+  yashandb: "yashandb",
+  vastbase: "vastbase",
+  doris: "doris",
+  selectdb: "selectdb",
+  starrocks: "starrocks",
+  manticoresearch: "manticoresearch",
+  redshift: "redshift",
+  cockroachdb: "cockroachdb",
+  tdengine: "tdengine",
+  xugu: "xugu",
+  iotdb: "iotdb",
+  etcd: "etcd",
+  zookeeper: "zookeeper",
+  mq: "mq",
+  kafka: "kafka",
+  nacos: "nacos",
+  dm: "dm",
+  h2: "h2",
+  snowflake: "snowflake",
+  trino: "trino",
+  prestosql: "prestosql",
+  hive: "hive",
+  spark: "spark-logo.png",
+  db2: "db2",
+  informix: "informix",
+  dremio: "dremio",
+  iris: "iris",
+  neo4j: "neo4j",
+  cassandra: "cassandra",
+  bigquery: "bigquery",
+  kylin: "kylin",
+  sundb: "sundb",
+  oscar: "oscar",
+  influxdb: "influxdb",
+  jdbc: "jdbc",
+  custom_mysql: "mysql",
+  custom_postgres: "postgres",
+};
+
+const dbOptions: DbOption[] = [
+  { value: "postgres", label: "PostgreSQL" },
+  { value: "mysql", label: "MySQL" },
+  { value: "mongodb", label: "MongoDB" },
+  { value: "redis", label: "Redis" },
+  { value: "oracle", label: "Oracle" },
+  { value: "sqlite", label: "SQLite" },
+  { value: "sqlserver", label: "SQL Server" },
+  { value: "elasticsearch", label: "Elasticsearch" },
+  { value: "qdrant", label: "Qdrant" },
+  { value: "milvus", label: "Milvus" },
+  { value: "weaviate", label: "Weaviate" },
+  { value: "chromadb", label: "ChromaDB" },
+  { value: "dm", label: "DM (Dameng)" },
+  { value: "opengauss", label: "openGauss" },
+  { value: "turso", label: "Turso" },
+  { value: "cloudflare-d1", label: "Cloudflare D1" },
+  { value: "duckdb", label: "DuckDB" },
+  { value: "rqlite", label: "RQLite" },
+  { value: "access", label: "Microsoft Access" },
+  { value: "mariadb", label: "MariaDB" },
+  { value: "clickhouse", label: "ClickHouse" },
+  { value: "gaussdb", label: "GaussDB" },
+  { value: "kwdb", label: "KWDB" },
+  { value: "questdb", label: "QuestDB" },
+  { value: "tidb", label: "TiDB" },
+  { value: "oceanbase", label: "OceanBase" },
+  { value: "goldendb", label: "GoldenDB" },
+  { value: "databend", label: "Databend" },
+  { value: "tdsql", label: "TDSQL" },
+  { value: "polardb", label: "PolarDB" },
+  { value: "greatsql", label: "GreatSQL" },
+  { value: "doris", label: "Doris" },
+  { value: "selectdb", label: "SelectDB" },
+  { value: "starrocks", label: "StarRocks" },
+  { value: "tdengine", label: "TDengine" },
+  { value: "databricks", label: "Databricks SQL" },
+  { value: "saphana", label: "SAP HANA" },
+  { value: "teradata", label: "Teradata" },
+  { value: "vertica", label: "Vertica" },
+  { value: "firebird", label: "Firebird" },
+  { value: "exasol", label: "Exasol" },
+  { value: "gbase", label: "GBase" },
+  { value: "kingbase", label: "KingBase" },
+  { value: "highgo", label: "瀚高 HighGo" },
+  { value: "yashandb", label: "崖山 YashanDB" },
+  { value: "vastbase", label: "Vastbase" },
+  { value: "redshift", label: "Redshift" },
+  { value: "cockroachdb", label: "CockroachDB" },
+  { value: "h2", label: "H2" },
+  { value: "snowflake", label: "Snowflake" },
+  { value: "trino", label: "Trino" },
+  { value: "prestosql", label: "PrestoSQL" },
+  { value: "hive", label: "Hive" },
+  { value: "spark", label: "Apache Spark" },
+  { value: "db2", label: "DB2" },
+  { value: "informix", label: "Informix" },
+  { value: "neo4j", label: "Neo4j" },
+  { value: "cassandra", label: "Cassandra" },
+  { value: "bigquery", label: "BigQuery" },
+  { value: "kylin", label: "Kylin" },
+  { value: "sundb", label: "SunDB" },
+  { value: "oscar", label: "神通 OSCAR" },
+  { value: "xugu", label: "虚谷 XuguDB" },
+  { value: "iotdb", label: "Apache IoTDB" },
+  { value: "etcd", label: "etcd" },
+  { value: "zookeeper", label: "Apache ZooKeeper" },
+  { value: "mq", label: "Apache Pulsar" },
+  { value: "kafka", label: "Apache Kafka" },
+  { value: "nacos", label: "Nacos" },
+  { value: "influxdb", label: "InfluxDB" },
+  { value: "iris", label: "IRIS" },
+  { value: "jdbc", label: "JDBC" },
+  { value: "manticoresearch", label: "Manticore Search" },
+  { value: "custom_mysql", label: "Custom (MySQL)" },
+  { value: "custom_postgres", label: "Custom (PostgreSQL)" },
+  { value: "dremio", label: "Dremio" },
+];
+
+const dbCategories = computed<DbCategory[]>(() => [{ key: "all", title: "", options: dbOptions }]);
+
+function matchesDbOption(option: DbOption, keyword: string, categoryTitle = "") {
+  const profile = driverProfiles[option.value];
+  return [option.label, option.value, profile?.label, profile?.type, categoryTitle].some((value) =>
+    String(value || "")
+      .toLowerCase()
+      .includes(keyword),
+  );
+}
+
+const filteredDbCategories = computed<DbCategory[]>(() => {
+  const keyword = dbSearchQuery.value.trim().toLowerCase();
+  if (!keyword) return dbCategories.value;
+
+  return dbCategories.value
+    .map((category) => ({
+      ...category,
+      options: category.options.filter((option) => matchesDbOption(option, keyword, category.title)),
+    }))
+    .filter((category) => category.options.length > 0);
+});
+
+const hasDbPickerResults = computed(() => filteredDbCategories.value.some((category) => category.options.length > 0));
+const selectedDbIcon = computed(() => iconTypeMap[selectedType.value] || selectedProfile().icon || selectedType.value);
+const jdbcBackedDatabaseTypes = new Set<DatabaseType>(["jdbc", "prestosql"]);
+const isJdbcConnection = computed(() => form.value.db_type === "jdbc");
+const isPrestoSqlConnection = computed(() => form.value.db_type === "prestosql");
+const isH2FileMode = computed(() => form.value.db_type === "h2" && h2ConnectionMode.value === "file");
+const usesLocalFilePathInput = computed(() => isLocalFileTypeDb(form.value.db_type) && (form.value.db_type !== "h2" || isH2FileMode.value));
+
+const connectionUrlPlaceholder = computed(() => getUrlPlaceholder(form.value.db_type));
+const jdbcUsernamePlaceholder = computed(() => (form.value.driver_profile === "dremio" ? "" : "sa"));
+const filePathPlaceholder = computed(() => {
+  if (form.value.db_type === "duckdb") return "/path/to/database.duckdb or :memory:";
+  if (form.value.db_type === "access") return "/path/to/database.accdb";
+  if (form.value.db_type === "h2") return "/path/to/database.mv.db";
+  return "/path/to/database.db or :memory:";
+});
+const supportsMemoryDatabasePath = computed(() => form.value.db_type === "sqlite" || form.value.db_type === "duckdb");
+const sqliteExtensionPaths = computed({
+  get: () => sqliteExtensionPathsFromParams(form.value.url_params),
+  set: (value: string) => {
+    form.value.url_params = setSqliteExtensionPaths(form.value.url_params, value);
+  },
+});
+const tlsCapableDatabaseTypes = new Set<DatabaseType>(["mysql", "starrocks", "postgres", "redshift", "gaussdb", "kwdb", "opengauss", "questdb", "redis", "etcd", "clickhouse", "elasticsearch", "qdrant", "milvus", "weaviate", "chromadb", "influxdb"]);
+const supportsTlsToggle = computed(() => tlsCapableDatabaseTypes.has(form.value.db_type));
+const supportsCaCertificatePath = computed(() => form.value.db_type === "clickhouse");
+const supportsGenericUrlParams = computed(() => form.value.db_type !== "manticoresearch");
+const bareMysqlProfiles = new Set(["doris", "selectdb", "oceanbase"]);
+const supportsMysqlTlsOptions = computed(() => form.value.db_type === "starrocks" || (form.value.db_type === "mysql" && !bareMysqlProfiles.has(selectedType.value)));
+const supportsMysqlCleartextPasswordAuth = computed(() => form.value.db_type === "mysql" && !bareMysqlProfiles.has(selectedType.value));
+const mysqlCleartextPasswordAuth = computed({
+  get: () => mysqlCleartextPasswordAuthEnabled(form.value.url_params),
+  set: (value: boolean) => {
+    form.value.url_params = setMysqlCleartextPasswordAuthEnabled(form.value.url_params, value);
+  },
+});
+const mysqlTlsMode = computed({
+  get: () => mysqlTlsModeFromParams(form.value.url_params, form.value.ssl),
+  set: (value: string) => {
+    form.value.ssl = value !== "preferred" && value !== "disabled";
+    form.value.url_params = applyMysqlTlsMode(form.value.url_params, value);
+  },
+});
+const mysqlClientCertPath = computed({
+  get: () => getUrlParam(form.value.url_params, "ssl-cert") || getUrlParam(form.value.url_params, "sslcert"),
+  set: (value: string) => {
+    let next = setUrlParam(form.value.url_params, "sslcert", "");
+    form.value.url_params = setUrlParam(next, "ssl-cert", value);
+  },
+});
+const mysqlClientKeyPath = computed({
+  get: () => getUrlParam(form.value.url_params, "ssl-key") || getUrlParam(form.value.url_params, "sslkey"),
+  set: (value: string) => {
+    let next = setUrlParam(form.value.url_params, "sslkey", "");
+    form.value.url_params = setUrlParam(next, "ssl-key", value);
+  },
+});
+const nativePostgresTlsDatabaseTypes = new Set<DatabaseType>(["postgres", "redshift", "gaussdb", "kwdb", "opengauss"]);
+const supportsPostgresTlsOptions = computed(() => nativePostgresTlsDatabaseTypes.has(form.value.db_type));
+const postgresTlsMode = computed({
+  get: () => {
+    const value = normalizePostgresSslMode(getUrlParam(form.value.url_params, "sslmode"));
+    if (value) return value;
+    return form.value.ssl ? "require" : "disable";
+  },
+  set: (value: string) => {
+    form.value.ssl = value !== "disable";
+    form.value.url_params = setUrlParam(form.value.url_params, "sslmode", value);
+  },
+});
+const postgresRootCertPath = computed({
+  get: () => getUrlParam(form.value.url_params, "sslrootcert"),
+  set: (value: string) => {
+    form.value.url_params = setUrlParam(form.value.url_params, "sslrootcert", value);
+  },
+});
+const postgresClientCertPath = computed({
+  get: () => getUrlParam(form.value.url_params, "sslcert"),
+  set: (value: string) => {
+    form.value.url_params = setUrlParam(form.value.url_params, "sslcert", value);
+  },
+});
+const postgresClientKeyPath = computed({
+  get: () => getUrlParam(form.value.url_params, "sslkey"),
+  set: (value: string) => {
+    form.value.url_params = setUrlParam(form.value.url_params, "sslkey", value);
+  },
+});
+const redisTlsInsecure = computed({
+  get: () => getUrlParam(form.value.url_params, "insecure").toLowerCase() === "true",
+  set: (value: boolean) => {
+    form.value.url_params = setUrlParam(form.value.url_params, "insecure", value ? "true" : "");
+  },
+});
+const etcdEndpointsLines = computed({
+  get: () => form.value.etcd_endpoints || "",
+  set: (value: string) => {
+    form.value.etcd_endpoints = normalizeEndpointLines(value);
+  },
+});
+const zookeeperConnectString = computed({
+  get: () => form.value.connection_string || "",
+  set: (value: string) => {
+    form.value.connection_string = normalizeZooKeeperConnectString(value);
+  },
+});
+const canUseTransportLayers = computed(() => form.value.db_type !== "sqlite" && form.value.db_type !== "access" && !isCloudflareD1Connection(form.value) && !isH2FileMode.value);
+const shouldShowAgentDriverInstallHint = computed(() => showAgentDriverInstallHint(form.value.db_type, agentDrivers.value, form.value.driver_profile));
+const h2DriverMissing = computed(() => form.value.db_type === "h2" && isH2FileMode.value && agentDrivers.value.find((d) => d.db_type === "h2")?.installed !== true);
+const canChooseVisibleDatabases = computed(() => connectionCanChooseVisibleDatabases(form.value));
+const visibleFilterUsesSchemas = computed(() => connectionUsesVisibleSchemaFilter(form.value));
+const hasVisibleDatabaseFilter = computed(() => Array.isArray(form.value.visible_databases));
+const visibleDatabaseSummary = computed(() => {
+  const configured = form.value.visible_databases;
+  if (!Array.isArray(configured)) return t("visibleDatabases.showAll");
+  return t("visibleDatabases.selectedCount", { selected: configured.length, total: visibleDatabaseNames.value.length });
+});
+const listedVisibleDatabaseNames = computed(() => {
+  if (visibleFilterUsesSchemas.value) return visibleDatabaseNames.value;
+  const connection = connectionConfigSnapshotForVisibleDatabases();
+  if (visibleDatabaseShowSystem.value) return visibleDatabaseNames.value;
+  return filterDatabaseNamesForVisiblePicker(visibleDatabaseNames.value, connection);
+});
+const filteredVisibleDatabaseNames = computed(() => {
+  const query = visibleDatabaseSearchText.value.trim().toLowerCase();
+  if (!query) return listedVisibleDatabaseNames.value;
+  return listedVisibleDatabaseNames.value.filter((name) => name.toLowerCase().includes(query));
+});
+const visibleDatabaseSelectedCount = computed(() => visibleDatabaseSelection.value.size);
+const visibleDatabaseTotalCount = computed(() => listedVisibleDatabaseNames.value.length);
+const visibleDatabaseCanSave = computed(() => canSaveVisibleDatabaseSelection([...visibleDatabaseSelection.value]));
+const visibleDatabaseHasSystemDatabases = computed(() => {
+  if (visibleFilterUsesSchemas.value) return false;
+  const connection = connectionConfigSnapshotForVisibleDatabases();
+  return visibleDatabaseNames.value.some((database) => isSystemDatabaseName(connection.db_type, database));
+});
+const filteredProductionDatabaseNames = computed(() => {
+  const query = productionDatabaseSearchText.value.trim().toLowerCase();
+  if (!query) return productionDatabaseNames.value;
+  return productionDatabaseNames.value.filter((name) => name.toLowerCase().includes(query));
+});
+const productionDatabaseSelectedCount = computed(() => productionDatabaseSelection.value.size);
+const productionDatabaseCanSave = computed(() => productionDatabaseNames.value.length > 0 && productionDatabaseSelection.value.size > 0);
+const productionDatabaseSummary = computed(() => {
+  const selected = form.value.production_databases?.length || 0;
+  if (!selected) return t("production.noDatabasesSelected");
+  if (!productionDatabaseNames.value.length) return t("production.databasesConfiguredCount", { count: selected });
+  return t("production.databasesSelectedCount", { selected, total: productionDatabaseNames.value.length });
+});
+const productionScope = computed<ProductionScope>({
+  get: () => (isSingleDatabase(form.value.db_type) || form.value.is_production ? "connection" : "databases"),
+  set: (scope) => {
+    form.value.is_production = isSingleDatabase(form.value.db_type) || scope === "connection";
+  },
+});
+const canSelectProductionDatabases = computed(() => !isSingleDatabase(form.value.db_type));
+
+function setProductionProtectionEnabled(enabled: boolean) {
+  productionProtectionEnabled.value = enabled;
+  if (!enabled) {
+    form.value.is_production = false;
+    form.value.production_databases = [];
+  } else if (!form.value.is_production && !form.value.production_databases?.length) {
+    // Enabling protection starts with the broadest scope until the user chooses a narrower one.
+    form.value.is_production = true;
+  }
+}
+const canChooseVisibleSchemas = computed(() => isSchemaAware(form.value.db_type));
+const visibleSchemasDatabaseKey = computed(() => form.value.database || "");
+const hasVisibleSchemaFilter = computed(() => {
+  const key = visibleSchemasDatabaseKey.value;
+  return Array.isArray(form.value.visible_schemas?.[key]);
+});
+const visibleSchemaObjectSelection = computed(() => {
+  const configured = form.value.visible_schemas?.[visibleSchemasDatabaseKey.value];
+  if (Array.isArray(configured)) return configured;
+  if (visibleFilterUsesSchemas.value && Array.isArray(form.value.visible_databases)) return form.value.visible_databases;
+  return undefined;
+});
+const visibleSchemaSummary = computed(() => {
+  const key = visibleSchemasDatabaseKey.value;
+  const configured = form.value.visible_schemas?.[key];
+  if (!Array.isArray(configured)) return t("visibleSchemas.showAll");
+  return t("visibleSchemas.selectedCount", { selected: configured.length, total: visibleSchemaNames.value.length });
+});
+const hasVisibleObjectFilter = computed(() => (visibleFilterUsesSchemas.value ? Array.isArray(visibleSchemaObjectSelection.value) : hasVisibleDatabaseFilter.value));
+const visibleObjectSummary = computed(() => {
+  if (!visibleFilterUsesSchemas.value) return visibleDatabaseSummary.value;
+  const configured = visibleSchemaObjectSelection.value;
+  if (!Array.isArray(configured)) return t("visibleSchemas.showAll");
+  return t("visibleSchemas.selectedCount", { selected: configured.length, total: visibleDatabaseNames.value.length });
+});
+const visibleObjectTitleKey = computed(() => (visibleFilterUsesSchemas.value ? "visibleSchemas.title" : "visibleDatabases.title"));
+const visibleObjectDescriptionKey = computed(() => (visibleFilterUsesSchemas.value ? "visibleSchemas.description" : "visibleDatabases.description"));
+const visibleObjectSearchPlaceholderKey = computed(() => (visibleFilterUsesSchemas.value ? "visibleSchemas.searchPlaceholder" : "visibleDatabases.searchPlaceholder"));
+const visibleObjectSelectedCountKey = computed(() => (visibleFilterUsesSchemas.value ? "visibleSchemas.selectedCount" : "visibleDatabases.selectedCount"));
+const visibleObjectEmptySelectionKey = computed(() => (visibleFilterUsesSchemas.value ? "visibleSchemas.emptySelection" : "visibleDatabases.emptySelection"));
+const visibleObjectLoadFailedKey = computed(() => (visibleFilterUsesSchemas.value ? "visibleSchemas.loadFailed" : "visibleDatabases.loadFailed"));
+const visibleObjectSaveKey = computed(() => (visibleFilterUsesSchemas.value ? "visibleSchemas.save" : "visibleDatabases.save"));
+const testResultMessage = computed(() => {
+  if (!testResult.value) return "";
+  return testResult.value.ok ? t("connection.testSuccess") : translateBackendError(t, testResult.value.message);
+});
+const agentInstallPercent = computed(() => driverInstallProgressPercent(agentInstallProgress.value));
+const agentInstallProgressLabel = computed(() => {
+  const progress = agentInstallProgress.value;
+  if (agentInstallError.value) return "安装失败";
+  if (!agentInstallRunning.value) return "等待安装";
+  if (!progress) return "准备安装驱动...";
+  if (progress.step === "jre-extract") return "解压 JRE...";
+  const label = progress.step === "jre" ? "下载 JRE" : progress.step === "driver" ? "下载驱动" : progress.step || "安装驱动";
+  if (!progress.total) return `${label}...`;
+  return `${label} ${formatInstallSize(progress.downloaded ?? 0)} / ${formatInstallSize(progress.total)} (${agentInstallPercent.value ?? 0}%)`;
+});
+const canCloseAgentInstallDialog = computed(() => !agentInstallRunning.value || !!agentInstallError.value);
+const sqlServerLegacyCompatibilityModeEnabled = computed(() => form.value.db_type === "sqlserver" && isSqlServerLegacyCompatibilityMode(form.value.url_params));
+const shouldUseWideConnectionDialog = computed(() => dialogStep.value === "config" && (canChooseVisibleDatabases.value || (canChooseVisibleSchemas.value && !visibleFilterUsesSchemas.value)));
+const connectionDialogContentClass = computed(() => {
+  if (dialogStep.value === "select") return "sm:max-w-[760px]";
+  return shouldUseWideConnectionDialog.value ? "sm:max-w-[660px]" : "sm:max-w-[560px]";
+});
+const connectionLabelClass = "justify-self-start text-left";
+const connectionLabelSmallClass = `${connectionLabelClass} text-xs`;
+const connectionLabelTopClass = `${connectionLabelClass} mt-2`;
+const connectionLabelSmallPaddedClass = `${connectionLabelClass} pt-2 text-xs`;
+const hasRequiredConnectionTarget = computed(() => {
+  if (form.value.db_type === "mq") {
+    return mqSystemKind.value === "kafka" ? !!mqKafkaBootstrapServers.value.trim() : !!mqAdminUrl.value.trim();
+  }
+  if (form.value.db_type === "zookeeper") return !!(form.value.host || form.value.connection_string || connectionUrlInput.value.trim());
+  if (form.value.db_type === "nacos") return !!nacosServerAddr.value.trim();
+  if (isCloudflareD1Connection(form.value)) return hasCloudflareD1Credentials(form.value);
+  if (isH2FileMode.value) return !!(form.value.host.trim() || h2FilePathFromJdbcUrl(form.value.connection_string));
+  return !!(form.value.host || (mongoUseUrl.value && form.value.connection_string) || (form.value.db_type === "jdbc" && form.value.connection_string) || connectionUrlInput.value.trim());
+});
+const mongoAuthDatabase = computed({
+  get: () => mongoUrlParam(form.value.url_params, "authSource"),
+  set: (value: string) => {
+    form.value.url_params = setMongoUrlParam(form.value.url_params, "authSource", value);
+  },
+});
+const mongoAuthMechanism = computed({
+  get: () => mongoUrlParam(form.value.url_params, "authMechanism") || "default",
+  set: (value: string) => {
+    form.value.url_params = setMongoUrlParam(form.value.url_params, "authMechanism", value === "default" ? "" : value);
+  },
+});
+const mongoTlsAllowInvalidCertificates = computed({
+  get: () => mongoUrlParamIsTrue(form.value.url_params, "tlsAllowInvalidCertificates"),
+  set: (value: boolean) => {
+    let next = setMongoUrlParamBoolean(form.value.url_params, "tlsAllowInvalidCertificates", value);
+    next = setMongoUrlParam(next, "tlsAllowInvalidHostnames", "");
+    form.value.url_params = next;
+  },
+});
+const mongoRetryWrites = computed({
+  get: () => mongoUrlParamIsTrue(form.value.url_params, "retryWrites", true),
+  set: (value: boolean) => {
+    form.value.url_params = setMongoUrlParamBoolean(form.value.url_params, "retryWrites", value, true);
+  },
+});
+const mongoDriverMode = computed({
+  get: () => (form.value.driver_profile === "mongodb-legacy" ? "legacy" : "auto"),
+  set: (value: string) => {
+    form.value.driver_profile = value === "legacy" ? "mongodb-legacy" : "mongodb";
+    form.value.driver_label = value === "legacy" ? "MongoDB (Legacy)" : "MongoDB";
+  },
+});
+
+function goToConnectionStep(value = selectedType.value) {
+  if (value !== selectedType.value) {
+    onDbTypeChange(value);
+  }
+  dialogStep.value = "config";
+  configTab.value = "connection";
+  dbSearchQuery.value = "";
+}
+
+function backToDatabasePicker() {
+  dialogStep.value = "select";
+  resetTestState();
+}
+
+watch(customDriverName, (value) => {
+  if (isCustomCompatibleProfile()) {
+    form.value.driver_label = value.trim() || selectedProfile().label;
+  }
+});
+
+async function testConnection() {
+  if (!ensureConnectionHostResolvedFromUrl()) return;
+
+  const runId = ++testRunId;
+  isTesting.value = true;
+  testResult.value = null;
+  let config: ConnectionConfig | null = null;
+  try {
+    config = connectionConfigForSubmit(editingId.value || draftTestConnectionId.value);
+    await ensureRequiredAgentDriverInstalled(config);
+    const msg = await testConnectionWithTimeout(config, runId);
+    if (runId !== testRunId) return;
+    if (config.db_type === "mongodb" && /legacy driver/i.test(msg)) {
+      mongoDriverMode.value = "legacy";
+    }
+    testResult.value = { ok: true, message: msg };
+    clearEditedConnectionErrorAfterSuccessfulTest();
+  } catch (e: any) {
+    if (runId !== testRunId) return;
+    const rawMessage = mongodbAuthFailureHint(errorMessage(e));
+    const message = config ? connectionErrorWithDriverUpdateHint(config, rawMessage) : rawMessage;
+    const fallbackMessage = config ? await tryNacosDockerConsoleFallback(config, message, runId) : null;
+    if (runId !== testRunId) return;
+    const shouldShowSqlServerLegacyMode = !fallbackMessage && config?.db_type === "sqlserver" && !isSqlServerLegacyCompatibilityMode(config.url_params) && isSqlServerTlsHandshakeFailure(message);
+    if (shouldShowSqlServerLegacyMode) {
+      configTab.value = "advanced";
+    }
+    testResult.value = fallbackMessage ? { ok: true, message: fallbackMessage } : { ok: false, message };
+    if (fallbackMessage) {
+      clearEditedConnectionErrorAfterSuccessfulTest();
+    } else {
+      showConnectionError(message);
+    }
+  } finally {
+    if (runId === testRunId) {
+      isTesting.value = false;
+    }
+  }
+}
+
+function clearEditedConnectionErrorAfterSuccessfulTest() {
+  if (editingId.value) store.clearConnectionError(editingId.value);
+}
+
+function applyConnectionUrlToForm(input: string): boolean {
+  try {
+    const draft = parseConnectionDeepLink(input);
+    if (draft) {
+      applyConnectionDraftToForm({ ...draft, oneTime: undefined });
+      resetTestState();
+      appliedConnectionUrlInput.value = input.trim();
+      return true;
+    }
+
+    const parsed = parseConnectionUrl(input, selectedType.value);
+    form.value = applyParsedConnectionUrl(form.value, parsed);
+    selectedType.value = parsed.driverProfile;
+    customDriverName.value = isCustomCompatibleProfile() ? parsed.driverLabel : "";
+    mongoUseUrl.value = !!parsed.useMongoUrl;
+    if (form.value.db_type === "h2") {
+      h2ConnectionMode.value = h2ConnectionModeForConfig(form.value);
+    }
+    if (!form.value.name.trim()) {
+      form.value.name = parsed.database || parsed.host || parsed.driverLabel;
+    }
+    resetTestState();
+    appliedConnectionUrlInput.value = input.trim();
+    return true;
+  } catch (e: any) {
+    toast(t("connection.parseConnectionUrlFailed", { message: e?.message || String(e) }), 5000);
+    return false;
+  }
+}
+
+function hasPendingConnectionUrlInput(): boolean {
+  const url = connectionUrlInput.value.trim();
+  return !!url && url !== appliedConnectionUrlInput.value;
+}
+
+function ensureConnectionHostResolvedFromUrl(): boolean {
+  if (!hasPendingConnectionUrlInput()) return true;
+  return applyConnectionUrlToForm(connectionUrlInput.value.trim());
+}
+
+function formValueForSubmit(): Omit<ConnectionConfig, "id"> {
+  const url = connectionUrlInput.value.trim();
+  if (!url || url === appliedConnectionUrlInput.value) return form.value;
+
+  const draft = parseConnectionDeepLink(url);
+  if (draft) {
+    return applyConnectionDraftToConfig(form.value, { ...draft, oneTime: undefined });
+  }
+
+  return applyParsedConnectionUrl(form.value, parseConnectionUrl(url, selectedType.value));
+}
+
+function applyDremioJdbcMetadata(config: LegacyConnectionConfig) {
+  config.connection_string = config.connection_string?.trim() || dremioDefaultConnectionUrl();
+  try {
+    const parsed = parseConnectionUrl(config.connection_string);
+    if (parsed.driverProfile !== "dremio") return;
+    config.host = parsed.host;
+    config.port = parsed.port;
+    config.database = config.database?.trim() || parsed.database;
+    config.connection_string = dremioConnectionStringForSubmit(config.connection_string, config.url_params, config.database);
+    config.url_params = "";
+    if (!config.username) config.username = parsed.username;
+    if (!config.password) config.password = parsed.password;
+  } catch {
+    // Keep custom JDBC input editable; the agent will surface driver-specific URL errors.
+  }
+}
+
+function dremioConnectionStringForSubmit(connectionString: string, urlParams: string | undefined, database: string | undefined) {
+  const params = dremioSubmitUrlParams(connectionString, urlParams, database);
+  if (!params) return connectionString;
+  return `${connectionString}${dremioSubmitUrlParamSeparator(connectionString)}${params}`;
+}
+
+function dremioSubmitUrlParams(connectionString: string | undefined, urlParams: string | undefined, database: string | undefined) {
+  const existingKeys = dremioUrlParamKeys(connectionString || "");
+  const extraParams = filterDremioUrlParams(urlParams || "", existingKeys);
+  if (database?.trim() && !existingKeys.has("schema") && !dremioUrlParamKeys(extraParams.join("&")).has("schema")) {
+    extraParams.push(`schema=${database.trim()}`);
+  }
+  return extraParams.join(dremioConnectionStringUsesLegacyUrlParams(connectionString || "") ? ";" : "&");
+}
+
+function dremioSubmitUrlParamSeparator(connectionString: string) {
+  if (dremioConnectionStringUsesLegacyUrlParams(connectionString)) {
+    return connectionString.endsWith(";") ? "" : ";";
+  }
+  return connectionString.includes("?") ? (connectionString.endsWith("?") || connectionString.endsWith("&") ? "" : "&") : "?";
+}
+
+function dremioConnectionStringUsesLegacyUrlParams(connectionString: string) {
+  if (/^jdbc:dremio:/i.test(connectionString)) return true;
+  if (/^jdbc:arrow-flight-sql:\/\//i.test(connectionString)) return false;
+  return dremioConnectionMode.value === "legacy";
+}
+
+function filterDremioUrlParams(urlParams: string, existingKeys: Set<string>) {
+  const result: string[] = [];
+  for (const part of urlParams.split(/[&;]/)) {
+    const param = part.trim();
+    if (!param) continue;
+    const key = param.split("=")[0]?.trim().toLowerCase();
+    if (!key || existingKeys.has(key)) continue;
+    result.push(param);
+  }
+  return result;
+}
+
+function dremioUrlParamKeys(value: string) {
+  const keys = new Set<string>();
+  const params = dremioUrlParamString(value);
+  for (const part of params.split(/[&;]/)) {
+    const key = part.split("=")[0]?.trim().toLowerCase();
+    if (key) keys.add(key);
+  }
+  return keys;
+}
+
+function dremioUrlParamString(value: string) {
+  if (/^jdbc:dremio:/i.test(value)) {
+    return value.split(";").slice(1).join(";");
+  }
+  const queryStart = value.indexOf("?");
+  if (queryStart < 0) return value;
+  const fragmentStart = value.indexOf("#", queryStart + 1);
+  return value.slice(queryStart + 1, fragmentStart < 0 ? undefined : fragmentStart);
+}
+
+function generateConnectionName(): string {
+  const label = selectedProfile().label;
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `${label}_${rand}`;
+}
+
+function connectionConfigForSubmit(id: string): ConnectionConfig {
+  const config = { ...formValueForSubmit(), id } as LegacyConnectionConfig;
+  if (selectedType.value === "oceanbase" && (config.driver_profile === "oceanbase" || config.driver_profile === "oceanbase-oracle")) {
+    Object.assign(config, oceanbaseModeConnectionPatch(oceanbaseSubMode.value));
+  }
+  if (!config.name?.trim()) {
+    config.name = generateConnectionName();
+  }
+  if (config.db_type === "kingbase") {
+    config.database = config.database?.trim() || undefined;
+    if (!config.database) {
+      throw new Error(t("connection.kingbaseDatabaseRequired"));
+    }
+  }
+  if (isCloudflareD1Connection(config)) {
+    normalizeCloudflareD1Connection(config);
+    if (!hasCloudflareD1Credentials(config)) {
+      throw new Error(t("connection.d1FieldsRequired"));
+    }
+  }
+  config.transport_layers = (config.transport_layers || []).map(normalizeTransportLayer);
+  config.transport_layers = config.transport_layers.map((layer) => {
+    if (layer.type !== "ssh") return layer;
+    const normalized = normalizeSshTunnel(layer);
+    const timeout = Number(normalized.connect_timeout_secs);
+    normalized.connect_timeout_secs = Number.isFinite(timeout) && timeout > 0 ? timeout : 5;
+    return { type: "ssh", ...normalized };
+  });
+  validateTransportLayers(config);
+  const connectTimeout = Number(config.connect_timeout_secs);
+  config.connect_timeout_secs = Number.isFinite(connectTimeout) && connectTimeout > 0 ? connectTimeout : 10;
+  const queryTimeout = Number(config.query_timeout_secs);
+  config.query_timeout_secs = Number.isFinite(queryTimeout) && queryTimeout >= 0 ? queryTimeout : 30;
+  const idleTimeout = Number(config.idle_timeout_secs);
+  config.idle_timeout_secs = Number.isFinite(idleTimeout) && idleTimeout >= 0 ? idleTimeout : 60;
+  const keepaliveInterval = Number(config.keepalive_interval_secs);
+  config.keepalive_interval_secs = Number.isFinite(keepaliveInterval) && keepaliveInterval >= 0 ? keepaliveInterval : 30;
+  if (config.db_type === "manticoresearch") {
+    config.url_params = "";
+  }
+  if (config.db_type === "hive") {
+    if (hiveAuthMode.value === "kerberos" && !hivePrincipal.value.trim()) {
+      throw new Error(t("connection.hiveKerberosPrincipalRequired"));
+    }
+    const hiveKerberos = applyHiveKerberosSubmitConfig({
+      authMode: hiveAuthMode.value,
+      principal: hivePrincipal.value,
+      krb5ConfPath: hiveKrb5ConfPath.value,
+      jaasConfigPath: hiveJaasConfigPath.value,
+      useSubjectCredsOnlyFalse: hiveUseSubjectCredsOnlyFalse.value,
+      extraJavaOptions: hiveExtraJavaOptions.value,
+      urlParams: config.url_params,
+    });
+    config.url_params = hiveKerberos.urlParams;
+    config.agent_java_options = hiveKerberos.agentJavaOptions;
+  } else {
+    config.agent_java_options = undefined;
+  }
+  if (config.db_type === "informix" && config.informix_server) {
+    // Strip INFORMIXSERVER from url_params to avoid duplicate when dedicated field is used
+    config.url_params = (config.url_params || "")
+      .replace(/(?:^|[;])\s*INFORMIXSERVER\s*=[^;]*/gi, "")
+      .replace(/^[;]|[;]$/g, "")
+      .trim();
+  }
+  if (!config.one_time) config.one_time = undefined;
+  if (!config.read_only) config.read_only = undefined;
+  if (isSingleDatabase(config.db_type) && config.production_databases?.length) {
+    // Single-database drivers expose schemas or internal names, not independently selectable databases.
+    config.is_production = true;
+    config.production_databases = [];
+  }
+  if (!config.is_production) config.is_production = undefined;
+  config.production_databases = [...new Set((config.production_databases || []).map((database) => database.trim()).filter(Boolean))];
+  if (!config.production_databases.length) config.production_databases = undefined;
+  if (config.db_type === "mq") {
+    const mqConfig = buildMqAdminConfig();
+    config.external_config = mqConfig;
+    config.driver_profile = mqConfig.systemKind === "kafka" ? "kafka" : "pulsar";
+    config.driver_label = mqConfig.systemKind === "kafka" ? "Apache Kafka" : "Apache Pulsar";
+    if (mqConfig.systemKind === "kafka") {
+      const extra = mqExtraRecord(mqConfig);
+      applyMqKafkaBootstrapServers(config, mqExtraString(extra, "bootstrapServers"), mqExtraString(extra, "securityProtocol"));
+    } else {
+      applyMqAdminUrl(config, mqConfig.adminUrl);
+    }
+    config.username = "";
+    config.password = "";
+    config.database = undefined;
+    config.connection_string = undefined;
+    config.url_params = "";
+  } else if (config.db_type === "nacos") {
+    const nacosConfig = buildNacosAdminConfig();
+    config.external_config = nacosConfig;
+    applyNacosServerAddr(config, nacosConfig.serverAddr);
+    config.username = nacosAuthKind.value === "usernamePassword" ? nacosUsername.value.trim() : "";
+    config.password = nacosAuthKind.value === "usernamePassword" ? nacosPassword.value : "";
+    config.database = nacosConfig.namespace || undefined;
+    config.connection_string = undefined;
+    config.url_params = "";
+  } else if (config.db_type === "influxdb") {
+    config.external_config = buildInfluxDbExternalConfig();
+    config.connection_string = undefined;
+    if (influxDbVersion.value === "2") {
+      config.username = "";
+      config.password = config.password.trim();
+      config.database = config.database?.trim() || undefined;
+    }
+  } else {
+    config.external_config = undefined;
+  }
+  if (config.db_type === "mongodb" && !mongoUseUrl.value) {
+    config.connection_string = undefined;
+  } else if (config.db_type === "mongodb") {
+    config.connection_string = normalizeMongoConnectionString(config.connection_string?.trim() || "");
+  }
+  if (config.db_type === "mongodb" && config.driver_profile !== "mongodb-legacy") {
+    config.driver_profile = "mongodb";
+    config.driver_label = "MongoDB";
+  }
+  if (config.db_type === "mongodb") {
+    const mongoTls = normalizeMongoTlsFormState(!!config.ssl, config.url_params, config.ca_cert_path);
+    config.url_params = mongoTls.urlParams;
+    config.ca_cert_path = mongoTls.caCertPath;
+  }
+  if (config.db_type !== "oracle") {
+    config.sysdba = undefined;
+    config.oracle_connection_type = undefined;
+  } else {
+    config.sysdba = !!config.sysdba || isOracleSysUser(config);
+    config.oracle_connection_type = config.oracle_connection_type || "service_name";
+  }
+  if (config.db_type !== "redis") {
+    config.redis_connection_mode = undefined;
+    config.redis_sentinel_master = undefined;
+    config.redis_sentinel_nodes = undefined;
+    config.redis_sentinel_username = undefined;
+    config.redis_sentinel_password = undefined;
+    config.redis_sentinel_tls = undefined;
+    config.redis_cluster_nodes = undefined;
+    config.redis_key_separator = undefined;
+    config.redis_scan_page_size = undefined;
+  } else if (config.redis_connection_mode === "sentinel") {
+    config.redis_sentinel_master = config.redis_sentinel_master?.trim() || "";
+    config.redis_sentinel_nodes = normalizeRedisSentinelNodes(config.redis_sentinel_nodes || "");
+    config.redis_sentinel_username = config.redis_sentinel_username?.trim() || "";
+    config.redis_cluster_nodes = undefined;
+    const firstNode = firstRedisSentinelEndpoint(config.redis_sentinel_nodes);
+    if (firstNode) {
+      config.host = firstNode.host;
+      config.port = firstNode.port;
+    }
+  } else if (config.redis_connection_mode === "cluster") {
+    config.redis_sentinel_master = undefined;
+    config.redis_sentinel_nodes = undefined;
+    config.redis_sentinel_username = undefined;
+    config.redis_sentinel_password = undefined;
+    config.redis_sentinel_tls = undefined;
+    config.redis_cluster_nodes = normalizeRedisClusterNodes(config.redis_cluster_nodes || "");
+    const firstNode = firstRedisClusterEndpoint(config.redis_cluster_nodes);
+    if (firstNode) {
+      config.host = firstNode.host;
+      config.port = firstNode.port;
+    }
+  } else {
+    config.redis_connection_mode = "standalone";
+    config.redis_sentinel_master = undefined;
+    config.redis_sentinel_nodes = undefined;
+    config.redis_sentinel_username = undefined;
+    config.redis_sentinel_password = undefined;
+    config.redis_sentinel_tls = undefined;
+    config.redis_cluster_nodes = undefined;
+  }
+  if (config.db_type === "redis") {
+    config.redis_key_separator = config.redis_key_separator?.trim() ?? ":";
+    const scanSize = Number(config.redis_scan_page_size);
+    config.redis_scan_page_size = Number.isFinite(scanSize) && scanSize >= REDIS_SCAN_PAGE_SIZE_MIN && scanSize <= REDIS_SCAN_PAGE_SIZE_MAX ? Math.round(scanSize) : REDIS_SCAN_PAGE_SIZE_DEFAULT;
+  }
+  if (config.db_type === "zookeeper") {
+    const normalizedConnectString = normalizeZooKeeperConnectString(config.connection_string || "");
+    config.connection_string = normalizedConnectString || undefined;
+    const firstEndpoint = firstZooKeeperEndpoint(normalizedConnectString || (config.host ? `${config.host}:${config.port || 2181}` : ""));
+    if (firstEndpoint) {
+      config.host = firstEndpoint.host;
+      config.port = firstEndpoint.port;
+    }
+    config.database = undefined;
+    config.ssl = false;
+  }
+  if (config.db_type === "etcd") {
+    config.etcd_endpoints = normalizeEndpointLines(config.etcd_endpoints || "");
+    const firstEndpoint = firstEtcdEndpoint(config.etcd_endpoints);
+    if (firstEndpoint) {
+      config.host = firstEndpoint.host;
+      config.port = firstEndpoint.port;
+      config.ssl = firstEndpoint.scheme === "https" || !!config.ssl;
+    }
+    config.client_cert_path = config.client_cert_path?.trim() || "";
+    config.client_key_path = config.client_key_path?.trim() || "";
+    if ((config.client_cert_path && !config.client_key_path) || (!config.client_cert_path && config.client_key_path)) {
+      throw new Error(t("connection.etcdClientCertPairRequired"));
+    }
+  } else {
+    config.etcd_endpoints = undefined;
+    config.client_cert_path = undefined;
+    config.client_key_path = undefined;
+  }
+  if (config.db_type !== "mysql" && config.db_type !== "clickhouse" && config.db_type !== "etcd" && config.db_type !== "starrocks" && config.db_type !== "mongodb") {
+    config.ca_cert_path = undefined;
+  } else {
+    config.ca_cert_path = config.ca_cert_path?.trim() || "";
+  }
+  if (jdbcBackedDatabaseTypes.has(config.db_type)) {
+    if (config.db_type === "jdbc") {
+      if (config.driver_profile === "dremio") {
+        applyDremioJdbcMetadata(config);
+      } else {
+        config.host = "";
+        config.port = 0;
+        config.connection_string = config.connection_string?.trim() || "";
+      }
+    } else if (config.db_type === "prestosql") {
+      config.connection_string = undefined;
+      config.jdbc_driver_class = config.jdbc_driver_class?.trim() || "io.prestosql.jdbc.PrestoDriver";
+      applyPrestoSqlBuiltinDriverPathsIfAvailable();
+    }
+    config.jdbc_driver_class = config.jdbc_driver_class?.trim() || undefined;
+    config.jdbc_driver_paths = jdbcDriverPathsInput.value
+      .split(/\r?\n/)
+      .map((path) => path.trim())
+      .filter(Boolean);
+  }
+  if (config.db_type === "h2") {
+    const h2Mode = connectionUrlInput.value.trim() ? h2ConnectionModeForConfig(config) : h2ConnectionMode.value;
+    if (h2Mode === "file") {
+      const jdbcFilePath = h2FilePathFromJdbcUrl(config.connection_string);
+      const filePath = config.host?.trim() || jdbcFilePath || "";
+      if (!filePath) {
+        throw new Error(t("connection.h2FilePathRequired"));
+      }
+      config.host = filePath;
+      config.port = 0;
+      config.connection_string = isH2SplitJdbcUrl(config.connection_string) ? h2FileJdbcUrlWithPath(config.connection_string, filePath) : h2FileJdbcUrlWithPath(undefined, filePath);
+      config.transport_layers = [];
+    } else {
+      config.host = config.host?.trim() || "127.0.0.1";
+      config.port = Number(config.port) || 9092;
+      if (h2FilePathFromJdbcUrl(config.connection_string)) {
+        config.connection_string = undefined;
+      } else {
+        config.connection_string = config.connection_string?.trim() || undefined;
+      }
+    }
+  }
+  const legacy = config as LegacyConnectionConfig;
+  delete legacy.ssh_enabled;
+  delete legacy.ssh_host;
+  delete legacy.ssh_port;
+  delete legacy.ssh_user;
+  delete legacy.ssh_password;
+  delete legacy.ssh_key_path;
+  delete legacy.ssh_key_passphrase;
+  delete legacy.ssh_expose_lan;
+  delete legacy.ssh_connect_timeout_secs;
+  delete legacy.ssh_tunnels;
+  delete legacy.proxy_enabled;
+  delete legacy.proxy_type;
+  delete legacy.proxy_host;
+  delete legacy.proxy_port;
+  delete legacy.proxy_username;
+  delete legacy.proxy_password;
+  if (connectionUsesVisibleSchemaFilter(config)) {
+    config.visible_databases = undefined;
+  } else {
+    config.visible_databases = Array.isArray(config.visible_databases) && config.visible_databases.length > 0 ? config.visible_databases : undefined;
+  }
+  if (config.visible_schemas && Object.keys(config.visible_schemas).length === 0) config.visible_schemas = undefined;
+  if (config.agent_java_options && config.agent_java_options.length === 0) config.agent_java_options = undefined;
+  return config as ConnectionConfig;
+}
+
+function connectionConfigSnapshotForVisibleDatabases(): ConnectionConfig {
+  return {
+    ...(form.value as ConnectionConfig),
+    id: editingId.value || "draft",
+    visible_databases: form.value.visible_databases,
+  };
+}
+
+function getUrlParam(params: string | undefined, key: string): string {
+  const parsed = new URLSearchParams((params || "").trim().replace(/^\?/, ""));
+  return parsed.get(key) || "";
+}
+
+function sqliteExtensionPathsFromParams(params: string | undefined): string {
+  const parsed = new URLSearchParams((params || "").trim().replace(/^\?/, ""));
+  return [...parsed.getAll("sqlite_extension"), ...parsed.getAll("sqlite_extensions").flatMap((value) => value.split(/\r?\n/))]
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .join("\n");
+}
+
+function setSqliteExtensionPaths(params: string | undefined, paths: string): string {
+  const parsed = new URLSearchParams((params || "").trim().replace(/^\?/, ""));
+  parsed.delete("sqlite_extension");
+  parsed.delete("sqlite_extensions");
+  paths
+    .split(/\r?\n/)
+    .map((value) => value.trim())
+    .filter(Boolean)
+    .forEach((value) => parsed.append("sqlite_extension", value));
+  return parsed.toString();
+}
+
+function setUrlParam(params: string | undefined, key: string, value: string): string {
+  const parsed = new URLSearchParams((params || "").trim().replace(/^\?/, ""));
+  const normalized = value.trim();
+  if (normalized) {
+    parsed.set(key, normalized);
+  } else {
+    parsed.delete(key);
+  }
+  return parsed.toString();
+}
+
+function deleteUrlParams(params: string | undefined, keys: string[]): string {
+  const parsed = new URLSearchParams((params || "").trim().replace(/^\?/, ""));
+  for (const key of keys) {
+    parsed.delete(key);
+  }
+  return parsed.toString();
+}
+
+function mysqlTlsModeFromParams(params: string | undefined, ssl: boolean | undefined): string {
+  const sslMode = getUrlParam(params, "ssl-mode") || getUrlParam(params, "sslmode");
+  switch (sslMode.trim().toLowerCase().replace("-", "_")) {
+    case "disabled":
+    case "disable":
+      return "disabled";
+    case "preferred":
+    case "prefer":
+      return "preferred";
+    case "required":
+    case "require":
+      return "required";
+    case "verify_ca":
+      return "verify_ca";
+    case "verify_identity":
+      return "verify_identity";
+  }
+
+  if (!ssl && getUrlParam(params, "require_ssl").toLowerCase() !== "true") return "disabled";
+  if (getUrlParam(params, "verify_identity").toLowerCase() === "true") return "verify_identity";
+  if (getUrlParam(params, "verify_ca").toLowerCase() === "true") return "verify_ca";
+  return "required";
+}
+
+function applyMysqlTlsMode(params: string | undefined, mode: string): string {
+  let next = deleteUrlParams(params, ["ssl-mode", "sslmode", "require_ssl", "verify_ca", "verify_identity"]);
+  if (mode === "disabled") {
+    return setUrlParam(next, "ssl-mode", "disabled");
+  }
+  if (mode === "preferred") {
+    return setUrlParam(next, "ssl-mode", "preferred");
+  }
+
+  next = setUrlParam(next, "require_ssl", "true");
+  if (mode === "required") {
+    next = setUrlParam(next, "verify_ca", "false");
+    return setUrlParam(next, "verify_identity", "false");
+  }
+  if (mode === "verify_ca") {
+    next = setUrlParam(next, "verify_ca", "true");
+    return setUrlParam(next, "verify_identity", "false");
+  }
+  next = setUrlParam(next, "verify_ca", "true");
+  return setUrlParam(next, "verify_identity", "true");
+}
+
+function normalizePostgresSslMode(value: string): string {
+  switch (value.trim().toLowerCase()) {
+    case "disable":
+    case "prefer":
+    case "require":
+    case "verify-ca":
+    case "verify-full":
+      return value.trim().toLowerCase();
+    case "verify_identity":
+    case "verify-identity":
+      return "verify-full";
+    default:
+      return "";
+  }
+}
+
+function normalizeRedisSentinelNodes(value: string): string {
+  return normalizeRedisNodeList(value);
+}
+
+function normalizeRedisClusterNodes(value: string): string {
+  return normalizeRedisNodeList(value);
+}
+
+function normalizeRedisNodeList(value: string): string {
+  return normalizeEndpointLines(value);
+}
+
+function normalizeEndpointLines(value: string): string {
+  return value
+    .split(/[\n,;]+/)
+    .map((node) => node.trim())
+    .filter(Boolean)
+    .join("\n");
+}
+
+function firstRedisSentinelEndpoint(value?: string): { host: string; port: number } | null {
+  const first = normalizeRedisNodeList(value || "")
+    .split("\n")
+    .find(Boolean);
+  if (!first) return null;
+  return parseRedisEndpoint(first, 26379);
+}
+
+function firstRedisClusterEndpoint(value?: string): { host: string; port: number } | null {
+  const first = normalizeRedisNodeList(value || "")
+    .split("\n")
+    .find(Boolean);
+  if (!first) return null;
+  return parseRedisEndpoint(first, 6379);
+}
+
+function parseRedisEndpoint(value: string, defaultPort: number): { host: string; port: number } {
+  const endpoint = value
+    .trim()
+    .replace(/^rediss?:\/\//, "")
+    .replace(/^.*@/, "")
+    .replace(/[/?#].*$/, "");
+  if (endpoint.startsWith("[")) {
+    const end = endpoint.indexOf("]");
+    if (end > 0) {
+      const host = endpoint.slice(1, end);
+      const portText = endpoint.slice(end + 1).replace(/^:/, "");
+      const port = Number(portText);
+      return { host, port: Number.isFinite(port) && port > 0 ? port : defaultPort };
+    }
+  }
+  const parts = endpoint.split(":");
+  if (parts.length === 2) {
+    const port = Number(parts[1]);
+    return { host: parts[0], port: Number.isFinite(port) && port > 0 ? port : defaultPort };
+  }
+  return { host: endpoint, port: defaultPort };
+}
+
+function firstEtcdEndpoint(value?: string): { scheme?: string; host: string; port: number } | null {
+  const first = normalizeEndpointLines(value || "")
+    .split("\n")
+    .find(Boolean);
+  if (!first) return null;
+  return parseEtcdEndpoint(first);
+}
+
+function parseEtcdEndpoint(value: string): { scheme?: string; host: string; port: number } {
+  const trimmed = value.trim().replace(/^.*@/, "");
+  const schemeMatch = trimmed.match(/^(https?):\/\//i);
+  const scheme = schemeMatch?.[1].toLowerCase();
+  const endpoint = trimmed.replace(/^https?:\/\//i, "").replace(/[/?#].*$/, "");
+  if (endpoint.startsWith("[")) {
+    const end = endpoint.indexOf("]");
+    if (end > 0) {
+      const host = endpoint.slice(1, end);
+      const portText = endpoint.slice(end + 1).replace(/^:/, "");
+      const port = Number(portText);
+      return { scheme, host, port: Number.isFinite(port) && port > 0 ? port : 2379 };
+    }
+  }
+  const parts = endpoint.split(":");
+  if (parts.length === 2) {
+    const port = Number(parts[1]);
+    return { scheme, host: parts[0], port: Number.isFinite(port) && port > 0 ? port : 2379 };
+  }
+  return { scheme, host: endpoint, port: 2379 };
+}
+
+function isOracleSysUser(config: Pick<ConnectionConfig, "db_type" | "username">): boolean {
+  return config.db_type === "oracle" && config.username.trim().toLowerCase() === "sys";
+}
+
+function resetTestState() {
+  testRunId += 1;
+  isTesting.value = false;
+  testResult.value = null;
+  showConnectionErrorDialog.value = false;
+  connectionErrorDetail.value = "";
+}
+
+function resetVisibleDatabaseDraftState() {
+  showVisibleDatabasesDialog.value = false;
+  isLoadingVisibleDatabases.value = false;
+  visibleDatabaseNames.value = [];
+  visibleDatabaseSelection.value = new Set();
+  visibleDatabaseSearchText.value = "";
+  visibleDatabaseError.value = "";
+  visibleDatabaseShowSystem.value = false;
+}
+
+function resetProductionDatabaseDraftState() {
+  showProductionDatabasesDialog.value = false;
+  isLoadingProductionDatabases.value = false;
+  productionDatabaseNames.value = [];
+  productionDatabaseSelection.value = new Set();
+  productionDatabaseSearchText.value = "";
+  productionDatabaseError.value = "";
+  productionProtectionEnabled.value = false;
+}
+
+/** Silently load database names so the summary count shows a real total. */
+async function preloadVisibleDatabaseNames() {
+  if (!ensureConnectionHostResolvedFromUrl()) return;
+  if (visibleDatabaseNames.value.length > 0) return;
+  isLoadingVisibleDatabases.value = true;
+  const draftId = buildDraftVisibleDatabasesConnectionId(uuid());
+  try {
+    const draftConfig = {
+      ...connectionConfigForSubmit(draftId),
+      id: draftId,
+      one_time: true,
+    };
+    await api.connectDb(draftConfig);
+    visibleDatabaseNames.value = await loadVisibleDatabaseNames(draftId, draftConfig);
+  } catch {
+    // silently fail
+  } finally {
+    await api.disconnectDb(draftId).catch(() => undefined);
+    isLoadingVisibleDatabases.value = false;
+  }
+}
+
+async function openVisibleDatabasesPicker() {
+  if (!ensureConnectionHostResolvedFromUrl()) return;
+  if (!canChooseVisibleDatabases.value || isLoadingVisibleDatabases.value) return;
+
+  isLoadingVisibleDatabases.value = true;
+  visibleDatabaseError.value = "";
+  visibleDatabaseSearchText.value = "";
+  const draftId = buildDraftVisibleDatabasesConnectionId(uuid());
+
+  try {
+    const draftConfig = {
+      ...connectionConfigForSubmit(draftId),
+      id: draftId,
+      one_time: true,
+    };
+    await api.connectDb(draftConfig);
+    const names = await loadVisibleDatabaseNames(draftId, draftConfig);
+    visibleDatabaseNames.value = names;
+    const configuredSchemas = visibleSchemaObjectSelection.value;
+    const initialSelection = visibleFilterUsesSchemas.value ? (Array.isArray(configuredSchemas) ? normalizeVisibleSchemaSelection(configuredSchemas, names) : names) : initialVisibleDatabaseSelection(names, form.value.visible_databases, draftConfig);
+    visibleDatabaseSelection.value = new Set(initialSelection);
+    visibleDatabaseShowSystem.value = !visibleFilterUsesSchemas.value && initialSelection.some((database) => isSystemDatabaseName(draftConfig.db_type, database));
+    showVisibleDatabasesDialog.value = true;
+  } catch (e: any) {
+    visibleDatabaseNames.value = [];
+    visibleDatabaseSelection.value = new Set();
+    visibleDatabaseError.value = mongodbAuthFailureHint(errorMessage(e));
+    testResult.value = { ok: false, message: visibleDatabaseError.value };
+    showVisibleDatabasesDialog.value = true;
+  } finally {
+    await api.disconnectDb(draftId).catch(() => undefined);
+    isLoadingVisibleDatabases.value = false;
+  }
+}
+
+async function loadVisibleDatabaseNames(connectionId: string, config: ConnectionConfig): Promise<string[]> {
+  if (connectionUsesVisibleSchemaFilter(config)) {
+    return api.listSchemas(connectionId, config.database || "");
+  }
+  if (config.db_type === "redis") {
+    return (await api.redisListDatabases(connectionId)).map((database) => String(database.db));
+  }
+  if (config.db_type === "mongodb") {
+    return api.mongoListDatabases(connectionId);
+  }
+  return (await api.listDatabases(connectionId)).map((database) => database.name);
+}
+
+function normalizeProductionDatabaseSelection(selectedNames: Iterable<string>, databaseNames: string[]): string[] {
+  const available = new Map(databaseNames.map((name) => [name.toLowerCase(), name]));
+  const selected = new Set<string>();
+  for (const name of selectedNames) {
+    const canonicalName = available.get(name.toLowerCase());
+    if (canonicalName) selected.add(canonicalName);
+  }
+  return [...selected];
+}
+
+function initialProductionDatabaseSelection(databaseNames: string[]): string[] {
+  const configured = form.value.production_databases || [];
+  // A new database-level safeguard starts broad; users can explicitly narrow it in the picker.
+  return configured.length ? normalizeProductionDatabaseSelection(configured, databaseNames) : databaseNames;
+}
+
+async function loadProductionDatabaseNames(connectionId: string, config: ConnectionConfig): Promise<string[]> {
+  if (config.db_type === "redis") {
+    return (await api.redisListDatabases(connectionId)).map((database) => String(database.db));
+  }
+  if (config.db_type === "mongodb") {
+    return api.mongoListDatabases(connectionId);
+  }
+  return (await api.listDatabases(connectionId)).map((database) => database.name);
+}
+
+async function openProductionDatabasesPicker() {
+  if (!ensureConnectionHostResolvedFromUrl() || !productionProtectionEnabled.value || form.value.is_production || isLoadingProductionDatabases.value) return;
+  showProductionDatabasesDialog.value = true;
+  await reloadProductionDatabases();
+}
+
+async function reloadProductionDatabases() {
+  if (isLoadingProductionDatabases.value) return;
+
+  isLoadingProductionDatabases.value = true;
+  productionDatabaseError.value = "";
+  productionDatabaseSearchText.value = "";
+  const draftId = `__production_database_draft_${uuid()}`;
+  try {
+    const draftConfig = {
+      ...connectionConfigForSubmit(draftId),
+      id: draftId,
+      one_time: true,
+    };
+    await api.connectDb(draftConfig);
+    productionDatabaseNames.value = await loadProductionDatabaseNames(draftId, draftConfig);
+    productionDatabaseSelection.value = new Set(initialProductionDatabaseSelection(productionDatabaseNames.value));
+  } catch (e: any) {
+    productionDatabaseNames.value = [];
+    productionDatabaseSelection.value = new Set();
+    productionDatabaseError.value = mongodbAuthFailureHint(errorMessage(e));
+  } finally {
+    await api.disconnectDb(draftId).catch(() => undefined);
+    isLoadingProductionDatabases.value = false;
+  }
+}
+
+function toggleProductionDatabase(database: string) {
+  const next = new Set(productionDatabaseSelection.value);
+  if (next.has(database)) next.delete(database);
+  else next.add(database);
+  productionDatabaseSelection.value = next;
+}
+
+function selectAllProductionDatabases() {
+  productionDatabaseSelection.value = new Set(productionDatabaseNames.value);
+}
+
+function clearProductionDatabaseSelection() {
+  productionDatabaseSelection.value = new Set();
+}
+
+function saveProductionDatabaseSelection() {
+  if (!productionDatabaseCanSave.value) return;
+  // A database selection is always narrower than a connection-wide marker.
+  productionProtectionEnabled.value = true;
+  form.value.is_production = false;
+  form.value.production_databases = normalizeProductionDatabaseSelection(productionDatabaseSelection.value, productionDatabaseNames.value);
+  showProductionDatabasesDialog.value = false;
+}
+
+function toggleVisibleDatabase(database: string) {
+  const next = new Set(visibleDatabaseSelection.value);
+  if (next.has(database)) next.delete(database);
+  else next.add(database);
+  visibleDatabaseSelection.value = next;
+}
+
+function selectAllVisibleDatabases() {
+  visibleDatabaseSelection.value = new Set(listedVisibleDatabaseNames.value);
+}
+
+function clearVisibleDatabaseSelection() {
+  visibleDatabaseSelection.value = new Set();
+}
+
+function showAllVisibleDatabases() {
+  if (visibleFilterUsesSchemas.value) {
+    handleDraftSchemasShowAll();
+    form.value.visible_databases = undefined;
+  } else {
+    form.value.visible_databases = undefined;
+  }
+  visibleDatabaseSelection.value = new Set();
+  visibleDatabaseNames.value = [];
+  showVisibleDatabasesDialog.value = false;
+}
+
+function saveVisibleDatabaseSelection() {
+  if (!visibleDatabaseCanSave.value) return;
+  if (visibleFilterUsesSchemas.value) {
+    const key = visibleSchemasDatabaseKey.value;
+    form.value.visible_databases = undefined;
+    form.value.visible_schemas = {
+      ...form.value.visible_schemas,
+      [key]: normalizeVisibleSchemaSelection([...visibleDatabaseSelection.value], visibleDatabaseNames.value),
+    };
+  } else {
+    form.value.visible_databases = normalizeVisibleDatabaseSelection([...visibleDatabaseSelection.value], visibleDatabaseNames.value);
+  }
+  showVisibleDatabasesDialog.value = false;
+}
+
+function resetVisibleSchemasState() {
+  showVisibleSchemasDialog.value = false;
+  isLoadingVisibleSchemas.value = false;
+  visibleSchemaNames.value = [];
+  visibleSchemaInitialSelection.value = [];
+  visibleSchemaError.value = "";
+}
+
+async function openVisibleSchemasPicker() {
+  if (!ensureConnectionHostResolvedFromUrl()) return;
+  if (!canChooseVisibleSchemas.value || isLoadingVisibleSchemas.value) return;
+  isLoadingVisibleSchemas.value = true;
+  visibleSchemaError.value = "";
+  const draftId = buildDraftVisibleSchemasConnectionId(uuid());
+  try {
+    const draftConfig: ConnectionConfig = {
+      ...connectionConfigForSubmit(draftId),
+      id: draftId,
+    };
+    await store.addEphemeralConnection(draftConfig);
+    await store.ensureConnected(draftId);
+    const names = await api.listSchemas(draftId, visibleSchemasDatabaseKey.value);
+    visibleSchemaNames.value = names;
+    const key = visibleSchemasDatabaseKey.value;
+    const configured = form.value.visible_schemas?.[key];
+    visibleSchemaInitialSelection.value = Array.isArray(configured) ? configured : [];
+    showVisibleSchemasDialog.value = true;
+  } catch (e: any) {
+    visibleSchemaNames.value = [];
+    visibleSchemaInitialSelection.value = [];
+    visibleSchemaError.value = String(e?.message || e);
+  } finally {
+    isLoadingVisibleSchemas.value = false;
+    store.removeConnection(draftId).catch(() => {});
+  }
+}
+
+function handleDraftSchemasSave(selectedNames: string[]) {
+  const key = visibleSchemasDatabaseKey.value;
+  form.value.visible_schemas = { ...form.value.visible_schemas, [key]: selectedNames };
+}
+
+function handleDraftSchemasShowAll() {
+  const key = visibleSchemasDatabaseKey.value;
+  if (form.value.visible_schemas) {
+    const next = { ...form.value.visible_schemas };
+    delete next[key];
+    form.value.visible_schemas = Object.keys(next).length > 0 ? next : undefined;
+  }
+}
+
+function applyConnectionUrl() {
+  if (applyConnectionUrlToForm(connectionUrlInput.value)) {
+    toast(t("connection.parseConnectionUrlApplied"), 2000);
+  }
+}
+
+async function copyTestResult() {
+  if (!testResultMessage.value) return;
+  try {
+    await copyToClipboard(testResultMessage.value);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function copyAgentInstallError() {
+  if (!agentInstallError.value) return;
+  try {
+    await copyToClipboard(agentInstallError.value);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function copyConnectionErrorDetail() {
+  if (!connectionErrorDetail.value) return;
+  try {
+    await copyToClipboard(connectionErrorDetail.value);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function resetForm() {
+  editingId.value = null;
+  form.value = defaultForm();
+  selectedTransportLayerId.value = null;
+  draggedTransportLayerId.value = null;
+  selectedType.value = "mysql";
+  customDriverName.value = "";
+  mongoUseUrl.value = false;
+  resetMqFields();
+  oceanbaseSubMode.value = "mysql";
+  dremioConnectionMode.value = "legacy";
+  resetDremioConnectionUrls();
+  jdbcDriverPathsInput.value = "";
+  selectedJdbcDriverPath.value = "";
+  connectionUrlInput.value = "";
+  appliedConnectionUrlInput.value = "";
+  dialogStep.value = "select";
+  dbPickerView.value = "icon";
+  dbSearchQuery.value = "";
+  configTab.value = "connection";
+  resetVisibleDatabaseDraftState();
+  resetProductionDatabaseDraftState();
+  resetVisibleSchemasState();
+  resetTestState();
+}
+
+const submittedOneTimePrefillKey = ref<string | null>(null);
+
+function oneTimePrefillKey(draft: ConnectionDeepLinkDraft) {
+  return JSON.stringify([draft.name, draft.dbType, draft.driverProfile, draft.driverLabel, draft.host, draft.port, draft.username, draft.password, draft.database, draft.urlParams, draft.ssl, draft.connectionString, draft.oracleConnectionType, draft.useMongoUrl]);
+}
+
+function submitOneTimePrefill(draft: ConnectionDeepLinkDraft) {
+  if (!draft.oneTime) return;
+  const key = oneTimePrefillKey(draft);
+  if (submittedOneTimePrefillKey.value === key) return;
+  submittedOneTimePrefillKey.value = key;
+  void nextTick(() => save());
+}
+
+function applyConnectionDraftToConfig(config: Omit<ConnectionConfig, "id">, draft: ConnectionDeepLinkDraft): Omit<ConnectionConfig, "id"> {
+  return {
+    ...config,
+    db_type: draft.dbType,
+    driver_profile: draft.driverProfile,
+    driver_label: draft.driverLabel,
+    host: draft.host ?? config.host,
+    port: draft.port ?? config.port,
+    username: draft.username ?? config.username,
+    password: draft.password ?? config.password,
+    database: draft.database ?? config.database,
+    url_params: draft.urlParams ?? config.url_params,
+    ssl: draft.ssl ?? config.ssl,
+    connection_string: draft.connectionString ?? config.connection_string,
+    oracle_connection_type: draft.oracleConnectionType ?? config.oracle_connection_type,
+    one_time: draft.oneTime || undefined,
+  };
+}
+
+function applyConnectionDraftToForm(draft: ConnectionDeepLinkDraft) {
+  applyProfile(draft.driverProfile);
+  form.value = applyConnectionDraftToConfig(form.value, draft);
+  selectedType.value = draft.driverProfile;
+  if (form.value.db_type === "h2") {
+    h2ConnectionMode.value = h2ConnectionModeForConfig(form.value);
+  }
+  if (draft.driverProfile === "oceanbase-oracle") {
+    oceanbaseSubMode.value = "oracle";
+    selectedType.value = "oceanbase";
+  }
+  if (draft.driverProfile === "gbase8a" || draft.driverProfile === "gbase8s") {
+    selectedType.value = "gbase";
+  }
+  customDriverName.value = isCustomCompatibleProfile() ? draft.driverLabel : "";
+  mongoUseUrl.value = !!draft.useMongoUrl;
+  if (draft.name?.trim()) {
+    form.value.name = draft.name.trim();
+  } else if (!form.value.name.trim()) {
+    form.value.name = draft.database || draft.host || draft.driverLabel;
+  }
+  dialogStep.value = "config";
+  configTab.value = "connection";
+  resetTestState();
+}
+
+function applyConnectionPrefill(draft: ConnectionDeepLinkDraft) {
+  resetForm();
+  applyConnectionDraftToForm(draft);
+  submitOneTimePrefill(draft);
+}
+
+watch(
+  open,
+  (value) => {
+    if (!value) {
+      const draftId = editingId.value ? null : draftTestConnectionId.value;
+      submittedOneTimePrefillKey.value = null;
+      resetForm();
+      if (draftId) {
+        void api.disconnectDb(draftId).catch(() => undefined);
+        draftTestConnectionId.value = uuid();
+      }
+      return;
+    }
+    if (!props.editConfig) {
+      resetForm();
+      if (props.prefillConfig) applyConnectionPrefill(props.prefillConfig);
+    }
+    if (!props.prefillConfig?.oneTime) {
+      void loadJdbcDrivers();
+      void loadAgentDrivers();
+      void loadSshConfigHosts();
+    }
+    // Preload database names so the summary count is accurate right away.
+    void nextTick(() => {
+      if (canChooseVisibleDatabases.value && hasVisibleDatabaseFilter.value) {
+        void preloadVisibleDatabaseNames();
+      }
+    });
+  },
+  { immediate: true },
+);
+
+watch(
+  () => props.prefillConfig,
+  (draft) => {
+    if (open.value && draft && !props.editConfig) applyConnectionPrefill(draft);
+  },
+);
+
+watch([() => form.value.db_type, () => form.value.username], () => {
+  if (isOracleSysUser(form.value)) form.value.sysdba = true;
+});
+
+watch(
+  () => connectionConfigSnapshotForVisibleDatabases(),
+  (current, previous) => {
+    if (!previous || !form.value.visible_databases?.length) return;
+    if (!visibleDatabaseSelectionIsStale(previous, current)) return;
+    form.value.visible_databases = undefined;
+    visibleDatabaseNames.value = [];
+    visibleDatabaseSelection.value = new Set();
+  },
+);
+
+watch(visibleDatabaseShowSystem, (show) => {
+  if (show) return;
+  const connection = connectionConfigSnapshotForVisibleDatabases();
+  visibleDatabaseSelection.value = new Set([...visibleDatabaseSelection.value].filter((database) => !isSystemDatabaseName(connection.db_type, database)));
+});
+
+watch(canUseTransportLayers, (value) => {
+  if (!value && configTab.value === "transport") {
+    configTab.value = "connection";
+  }
+});
+
+watch(supportsTlsToggle, (value) => {
+  if (!value && configTab.value === "tls") {
+    configTab.value = "connection";
+  }
+});
+
+function ensureSelectedTransportLayer() {
+  if (!selectedTransportLayerId.value || !transportLayers.value.some((layer) => layer.id === selectedTransportLayerId.value)) {
+    selectedTransportLayerId.value = transportLayers.value[0]?.id || null;
+  }
+}
+
+function addSshTunnel() {
+  const next: TransportLayerConfig = { type: "ssh", ...defaultSshTunnel() };
+  next.name = t("connection.sshHopDefaultName", { index: transportLayers.value.length + 1 });
+  form.value.transport_layers = [...transportLayers.value, next];
+  selectedTransportLayerId.value = next.id;
+  resetTestState();
+}
+
+function addProxyTunnel() {
+  const next: TransportLayerConfig = { type: "proxy", ...defaultProxyTunnel() };
+  next.name = `Proxy ${transportLayers.value.length + 1}`;
+  form.value.transport_layers = [...transportLayers.value, next];
+  selectedTransportLayerId.value = next.id;
+  resetTestState();
+}
+
+function addHttpTunnel() {
+  const next: TransportLayerConfig = { type: "http_tunnel", ...defaultHttpTunnel() };
+  next.name = t("connection.httpTunnelDefaultName", { index: 1 });
+  form.value.transport_layers = [next, ...transportLayers.value];
+  selectedTransportLayerId.value = next.id;
+  resetTestState();
+}
+
+function duplicateTransportLayer(layer: TransportLayerConfig) {
+  const next = normalizeTransportLayer({ ...layer, id: uuid(), name: layer.name ? `${layer.name} copy` : "" });
+  form.value.transport_layers = [...transportLayers.value, next];
+  selectedTransportLayerId.value = next.id;
+  resetTestState();
+}
+
+function removeTransportLayer(id: string) {
+  form.value.transport_layers = transportLayers.value.filter((layer) => layer.id !== id);
+  ensureSelectedTransportLayer();
+  resetTestState();
+}
+
+function moveTransportLayer(id: string, direction: -1 | 1) {
+  const layers = [...transportLayers.value];
+  const index = layers.findIndex((layer) => layer.id === id);
+  const target = index + direction;
+  if (index < 0 || target < 0 || target >= layers.length) return;
+  [layers[index], layers[target]] = [layers[target], layers[index]];
+  form.value.transport_layers = layers;
+  resetTestState();
+}
+
+function dropTransportLayer(targetId: string) {
+  const sourceId = draggedTransportLayerId.value;
+  draggedTransportLayerId.value = null;
+  if (!sourceId || sourceId === targetId) return;
+  const layers = [...transportLayers.value];
+  const sourceIndex = layers.findIndex((layer) => layer.id === sourceId);
+  const targetIndex = layers.findIndex((layer) => layer.id === targetId);
+  if (sourceIndex < 0 || targetIndex < 0) return;
+  const [source] = layers.splice(sourceIndex, 1);
+  layers.splice(targetIndex, 0, source);
+  form.value.transport_layers = layers;
+  resetTestState();
+}
+
+function changeSelectedTransportLayerType(type: "ssh" | "proxy" | "http_tunnel") {
+  const selected = selectedTransportLayer.value;
+  if (!selected || selected.type === type) return;
+  const replacement: TransportLayerConfig =
+    type === "proxy" ? { type: "proxy", ...defaultProxyTunnel(), id: selected.id, name: selected.name } : type === "http_tunnel" ? { type: "http_tunnel", ...defaultHttpTunnel(), id: selected.id, name: selected.name } : { type: "ssh", ...defaultSshTunnel(), id: selected.id, name: selected.name };
+  form.value.transport_layers = transportLayers.value.map((layer) => (layer.id === selected.id ? replacement : layer));
+  resetTestState();
+}
+
+function updateSelectedProxyType(value: unknown) {
+  const layer = selectedProxyLayer.value;
+  if (!layer) return;
+  layer.proxy_type = value === "http" ? "http" : "socks5";
+  resetTestState();
+}
+
+/**
+ * "agent" is legacy-only: it's never chosen from this dropdown, only ever
+ * inherited from a connection saved before this selector existed. Once the
+ * user picks something else, the option (and its underlying checkbox) is
+ * gone from the form for good.
+ */
+function isLegacySshAgentMethod(hop: Partial<SshTunnelConfig> | null | undefined) {
+  return hop?.auth_method === "agent";
+}
+
+function updateSelectedSshAuthMethod(value: unknown) {
+  const layer = selectedSshLayer.value;
+  if (!layer) return;
+  layer.auth_method = value === "key" ? "key" : value === "none" ? "none" : "password";
+  // Scrub credential fields that do not apply to the selected method so
+  // they are not accidentally submitted or used by the backend fallback.
+  if (layer.auth_method !== "password") layer.password = "";
+  if (layer.auth_method !== "key") {
+    layer.key_path = "";
+    layer.key_passphrase = "";
+  }
+  if (layer.auth_method !== "key") {
+    layer.use_ssh_agent = false;
+  }
+  resetTestState();
+}
+
+function validateTransportLayers(config: LegacyConnectionConfig) {
+  const layers = config.transport_layers || [];
+  layers.forEach((layer, index) => {
+    if (layer.enabled === false) return;
+    // Profile-referencing layers are stubs: the shared profile supplies the
+    // whole configuration at connect time, so there is nothing to validate.
+    if (layer.profile_id) return;
+    const label = layer.name?.trim() || transportLayerDefaultName(layer, index);
+    if (layer.type === "http_tunnel") {
+      if (index !== 0) throw new Error(t("connection.httpTunnelInvalidOrder", { hop: label }));
+      if (!layer.url?.trim()) throw new Error(t("connection.httpTunnelInvalidUrl", { hop: label }));
+      const timeout = Number(layer.connect_timeout_secs);
+      if (!Number.isFinite(timeout) || timeout < 1 || timeout > 300) {
+        throw new Error(t("connection.httpTunnelInvalidTimeout", { hop: label }));
+      }
+      return;
+    }
+    if (!layer.host?.trim()) throw new Error(t("connection.sshHopInvalidHost", { hop: label }));
+    const port = Number(layer.port);
+    if (!Number.isFinite(port) || port < 1 || port > 65535) {
+      throw new Error(t("connection.sshHopInvalidPort", { hop: label }));
+    }
+    if (layer.type === "ssh") {
+      layer.user = layer.user?.trim() || DEFAULT_SSH_USER;
+      // Auth credentials are optional: the backend probes "none" authentication
+      // first, so hops that require no credential (e.g. passwordless SSH proxies)
+      // are valid with password, key, and agent all left empty.
+      const timeout = Number(layer.connect_timeout_secs);
+      if (!Number.isFinite(timeout) || timeout < 1 || timeout > 300) {
+        throw new Error(t("connection.sshHopInvalidTimeout", { hop: label }));
+      }
+    }
+  });
+}
+
+async function save() {
+  if (!ensureConnectionHostResolvedFromUrl()) return;
+  if (isSaving.value) return;
+  isSaving.value = true;
+  resetTestState();
+  try {
+    if (editingId.value) {
+      const updated = connectionConfigForSubmit(editingId.value);
+      await ensureRequiredAgentDriverInstalled(updated);
+      await store.updateConnection(updated);
+      store.stopEditing();
+    } else {
+      const config = connectionConfigForSubmit(draftTestConnectionId.value);
+      await ensureRequiredAgentDriverInstalled(config);
+      await store.addConnection(config);
+      draftTestConnectionId.value = uuid();
+      if (config.db_type === "jdbc") {
+        open.value = false;
+        return;
+      }
+      open.value = false;
+      await nextTick();
+      emit("connectStarted", config.name);
+      void store
+        .connect(config)
+        .then(() => {
+          emit("connectSucceeded", config.name);
+        })
+        .catch((e: any) => {
+          const message = String(e?.message || e);
+          if (message.includes(CONNECTION_ATTEMPT_CANCELLED_MESSAGE)) return;
+          if (config.one_time) void store.removeConnection(config.id);
+          emit("connectFailed", appendConnectionErrorHints(config, mongodbAuthFailureHint(message), t));
+        });
+      return;
+    }
+    open.value = false;
+  } catch (e: any) {
+    const message = mongodbAuthFailureHint(String(e?.message || e));
+    testResult.value = { ok: false, message };
+    showConnectionError(message);
+  } finally {
+    isSaving.value = false;
+  }
+}
+
+const dialogTitle = ref("");
+watch([() => editingId.value, () => open.value], () => {
+  dialogTitle.value = editingId.value ? t("connection.editTitle") : t("connection.title");
+});
+
+const sshConfigHostAliases = computed(() => sshConfigHosts.value.map((entry) => entry.alias));
+
+/**
+ * Prefills user/port/key_path from a matching ~/.ssh/config alias, without
+ * overwriting values the user already changed away from the form defaults.
+ * This is a UX preview only — the authoritative resolution happens in the
+ * Rust backend at connect time (see resolve_ssh_tunnel_config), so imported
+ * configs that never touched this UI still resolve correctly.
+ */
+function applySshConfigHostAliasPrefill(target: SshTunnelConfig) {
+  const entry = sshConfigHosts.value.find((candidate) => candidate.alias === target.host);
+  if (!entry) return;
+  if (target.user === DEFAULT_SSH_USER && entry.user) target.user = entry.user;
+  if (target.port === 22 && entry.port) target.port = entry.port;
+  if (!target.key_path && entry.identity_file) {
+    target.key_path = entry.identity_file;
+    if ((!target.auth_method || target.auth_method === "password") && !target.password?.trim()) {
+      target.auth_method = "key";
+    }
+  }
+}
+
+async function browseSshKeyPath(target?: SshTunnelConfig | null) {
+  if (isTauriRuntime()) {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const selected = await open({
+      title: "Select SSH Private Key",
+      multiple: false,
+    });
+    if (selected && typeof selected === "string") {
+      if (target) {
+        target.key_path = selected;
+      }
+    }
+  }
+}
+
+async function browseCaCertPath() {
+  if (isTauriRuntime()) {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const selected = await open({
+      title: "Select CA Certificate",
+      multiple: false,
+      filters: [{ name: "Certificate", extensions: ["crt", "cer", "pem"] }],
+    });
+    if (selected && typeof selected === "string") {
+      form.value.ca_cert_path = selected;
+    }
+  }
+}
+
+async function browseMysqlTlsFile(target: "cert" | "key") {
+  if (isTauriRuntime()) {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const selected = await open({
+      title: target === "cert" ? t("connection.mysqlClientCertBrowse") : t("connection.mysqlClientKeyBrowse"),
+      multiple: false,
+      filters: [
+        { name: "PEM", extensions: ["pem", "crt", "cer", "key"] },
+        { name: "All Files", extensions: ["*"] },
+      ],
+    });
+    if (selected && typeof selected === "string") {
+      if (target === "cert") {
+        mysqlClientCertPath.value = selected;
+      } else {
+        mysqlClientKeyPath.value = selected;
+      }
+    }
+  }
+}
+
+async function browsePostgresTlsFile(target: "root" | "cert" | "key") {
+  if (isTauriRuntime()) {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const selected = await open({
+      title: target === "root" ? t("connection.postgresRootCertBrowse") : target === "cert" ? t("connection.postgresClientCertBrowse") : t("connection.postgresClientKeyBrowse"),
+      multiple: false,
+      filters: [
+        { name: "PEM", extensions: ["pem", "crt", "cer", "key"] },
+        { name: "All Files", extensions: ["*"] },
+      ],
+    });
+    if (selected && typeof selected === "string") {
+      if (target === "root") {
+        postgresRootCertPath.value = selected;
+      } else if (target === "cert") {
+        postgresClientCertPath.value = selected;
+      } else {
+        postgresClientKeyPath.value = selected;
+      }
+    }
+  }
+}
+
+async function browseEtcdTlsFile(target: "ca" | "cert" | "key") {
+  if (isTauriRuntime()) {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const selected = await open({
+      title: target === "ca" ? t("connection.etcdCaCertBrowse") : target === "cert" ? t("connection.etcdClientCertBrowse") : t("connection.etcdClientKeyBrowse"),
+      multiple: false,
+      filters: [
+        { name: "PEM", extensions: ["pem", "crt", "cer", "key"] },
+        { name: "All Files", extensions: ["*"] },
+      ],
+    });
+    if (selected && typeof selected === "string") {
+      if (target === "ca") {
+        form.value.ca_cert_path = selected;
+      } else if (target === "cert") {
+        form.value.client_cert_path = selected;
+      } else {
+        form.value.client_key_path = selected;
+      }
+    }
+  }
+}
+
+async function browseHiveKerberosFile(target: "krb5" | "jaas") {
+  if (isTauriRuntime()) {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const selected = await open({
+      title: target === "krb5" ? t("connection.hiveKrb5ConfBrowse") : t("connection.hiveJaasConfigBrowse"),
+      multiple: false,
+      filters: [{ name: "Config", extensions: ["conf", "ini", "properties", "*"] }],
+    });
+    if (selected && typeof selected === "string") {
+      if (target === "krb5") {
+        hiveKrb5ConfPath.value = selected;
+      } else {
+        hiveJaasConfigPath.value = selected;
+      }
+    }
+  }
+}
+
+async function browseKafkaKerberosFile(target: "keytab" | "krb5") {
+  if (isTauriRuntime()) {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const selected = await open({
+      title: target === "keytab" ? t("connection.kafkaKerberosKeytabBrowse") : t("connection.kafkaKerberosKrb5ConfBrowse"),
+      multiple: false,
+      filters: [{ name: "Kerberos", extensions: target === "keytab" ? ["keytab", "kt", "*"] : ["conf", "ini", "*"] }],
+    });
+    if (selected && typeof selected === "string") {
+      if (target === "keytab") {
+        mqKafkaKerberosKeytabPath.value = selected;
+      } else {
+        mqKafkaKrb5ConfPath.value = selected;
+      }
+    }
+  }
+}
+
+async function browseDbFilePath() {
+  if (isTauriRuntime()) {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const filters = form.value.db_type === "duckdb" ? [{ name: "DuckDB", extensions: ["duckdb", "db"] }] : form.value.db_type === "access" ? [{ name: "Microsoft Access", extensions: ["accdb", "mdb"] }] : form.value.db_type === "h2" ? [{ name: "H2", extensions: ["db"] }] : undefined;
+    const selected = await open({
+      title: "Select Database File",
+      multiple: false,
+      ...(filters ? { filters } : {}),
+    });
+    if (selected && typeof selected === "string") {
+      form.value.host = selected;
+    }
+  }
+}
+
+async function browseSqliteExtensionPath() {
+  if (isTauriRuntime()) {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const selected = await open({
+      title: t("connection.sqliteExtensionBrowse"),
+      multiple: true,
+      filters: [
+        { name: "SQLite Extension", extensions: ["dylib", "so", "dll"] },
+        { name: "All Files", extensions: ["*"] },
+      ],
+    });
+    const selectedPaths = Array.isArray(selected) ? selected : selected && typeof selected === "string" ? [selected] : [];
+    if (selectedPaths.length) {
+      const existing = sqliteExtensionPaths.value
+        .split(/\r?\n/)
+        .map((path) => path.trim())
+        .filter(Boolean);
+      sqliteExtensionPaths.value = [...existing, ...selectedPaths].join("\n");
+    }
+  }
+}
+
+function ensureDuckDbFileExtension(path: string): string {
+  return /\.(duckdb|db)$/i.test(path) ? path : `${path}.duckdb`;
+}
+
+async function createDuckDbFilePath() {
+  if (!isTauriRuntime()) return;
+  const { save } = await import("@tauri-apps/plugin-dialog");
+  const selected = await save({
+    title: t("connection.createDuckDbFile"),
+    defaultPath: "database.duckdb",
+    filters: [{ name: "DuckDB", extensions: ["duckdb", "db"] }],
+  });
+  if (!selected) return;
+
+  const path = ensureDuckDbFileExtension(selected);
+  form.value.host = path;
+
+  try {
+    const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+    await writeTextFile(path, "");
+  } catch (e) {
+    console.error("Failed to create DuckDB file:", e);
+  }
+}
+
+function ensureSqliteFileExtension(path: string): string {
+  const extensionPattern = new RegExp(`\\.(${SQLITE_DATABASE_FILE_EXTENSIONS.join("|")})$`, "i");
+  return extensionPattern.test(path) ? path : `${path}.db`;
+}
+
+async function createSqliteFilePath() {
+  if (!isTauriRuntime()) return;
+  const { save } = await import("@tauri-apps/plugin-dialog");
+  const selected = await save({
+    title: t("connection.createSqliteFile"),
+    defaultPath: "database.db",
+    filters: [{ name: "SQLite", extensions: SQLITE_DATABASE_FILE_EXTENSIONS }],
+  });
+  if (!selected) return;
+
+  const path = ensureSqliteFileExtension(selected);
+  form.value.host = path;
+
+  try {
+    const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+    await writeTextFile(path, "");
+  } catch (e) {
+    console.error("Failed to create SQLite file:", e);
+  }
+}
+
+async function browseJdbcDriverPaths() {
+  if (!isTauriRuntime()) return;
+  const { open } = await import("@tauri-apps/plugin-dialog");
+  const selected = await open({
+    title: t("connection.jdbcDriverBrowse"),
+    multiple: true,
+    filters: [{ name: "JDBC Driver", extensions: ["jar"] }],
+  });
+  if (!selected) return;
+
+  const paths = Array.isArray(selected) ? selected : [selected];
+  const existing = jdbcDriverPathsInput.value
+    .split(/\r?\n/)
+    .map((path) => path.trim())
+    .filter(Boolean);
+  const merged = Array.from(new Set([...existing, ...paths.filter((path): path is string => typeof path === "string")]));
+  jdbcDriverPathsInput.value = merged.join("\n");
+}
+
+async function loadJdbcDrivers() {
+  if (!isDesktop) return;
+  try {
+    const [drivers, bundles, localBundles] = await Promise.all([api.listJdbcDrivers(), api.listJdbcMavenBundles(), api.listJdbcLocalBundles()]);
+    jdbcDrivers.value = drivers;
+    jdbcMavenBundles.value = bundles;
+    jdbcLocalBundles.value = localBundles;
+    applyPrestoSqlBuiltinDriverPathsIfAvailable();
+  } catch {
+    jdbcDrivers.value = [];
+    jdbcMavenBundles.value = [];
+    jdbcLocalBundles.value = [];
+  }
+}
+
+async function loadSshConfigHosts() {
+  try {
+    sshConfigHosts.value = await api.listSshConfigHosts();
+  } catch {
+    sshConfigHosts.value = [];
+  }
+}
+
+async function loadAgentDrivers() {
+  try {
+    agentDrivers.value = await api.listInstalledAgentsLocal();
+    if (!settingsStore.editorSettings.updateNotificationsEnabled) return;
+    api
+      .listInstalledAgents()
+      .then((drivers) => {
+        agentDrivers.value = drivers;
+      })
+      .catch(() => {
+        /* keep local state */
+      });
+  } catch {
+    agentDrivers.value = [];
+  }
+}
+
+function addJdbcDriverPaths(paths: string[]) {
+  const existing = jdbcDriverPathsInput.value
+    .split(/\r?\n/)
+    .map((value) => value.trim())
+    .filter(Boolean);
+  jdbcDriverPathsInput.value = Array.from(new Set([...existing, ...paths])).join("\n");
+}
+
+function applyPrestoSqlBuiltinDriverPathsIfAvailable() {
+  if (form.value.db_type !== "prestosql" || jdbcManualClasspathCount.value > 0) return;
+  const paths = prestoSqlBuiltinDriverPaths(jdbcMavenBundles.value);
+  if (paths.length === 0) return;
+  addJdbcDriverPaths(paths);
+  selectedJdbcDriverPath.value = jdbcDriverSelectItems.value.find((item) => paths.every((path) => item.paths.includes(path)))?.id ?? "";
+  jdbcManualClasspathOpen.value = false;
+}
+
+function onJdbcDriverSelect(id: any) {
+  if (typeof id !== "string" || !id) return;
+  const item = jdbcDriverSelectItemById.value.get(id);
+  if (!item) return;
+  selectedJdbcDriverPath.value = id;
+  addJdbcDriverPaths(item.paths);
+  jdbcManualClasspathOpen.value = false;
+}
+
+onMounted(async () => {
+  void tunnelProfileStore.init();
+  unlistenAgentInstallProgress = await api.listenAgentInstallProgress(handleAgentInstallProgress);
+});
+
+onUnmounted(() => {
+  unlistenAgentInstallProgress?.();
+  unlistenAgentInstallProgress = null;
+});
+
+function openExternalUrl(url: string) {
+  if (isTauriRuntime()) {
+    import("@tauri-apps/plugin-shell").then(({ open }) => open(url));
+  } else {
+    window.open(url, "_blank", "noopener,noreferrer");
+  }
+}
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent class="connection-dialog-content" :class="connectionDialogContentClass" :data-wide="shouldUseWideConnectionDialog ? 'true' : undefined" @interact-outside.prevent>
+      <DialogHeader>
+        <DialogTitle>{{ editingId ? t("connection.editTitle") : t("connection.title") }}</DialogTitle>
+      </DialogHeader>
+
+      <template v-if="dialogStep === 'select'">
+        <div class="space-y-4">
+          <div class="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-end">
+            <div class="flex items-center gap-2">
+              <div class="flex shrink-0 rounded-lg border bg-muted/40 p-0.5">
+                <Button type="button" size="icon-sm" :variant="dbPickerView === 'icon' ? 'secondary' : 'ghost'" :title="t('connection.iconView')" :aria-label="t('connection.iconView')" @click="dbPickerView = 'icon'">
+                  <Grid3X3 class="h-3.5 w-3.5" />
+                </Button>
+                <Button type="button" size="icon-sm" :variant="dbPickerView === 'list' ? 'secondary' : 'ghost'" :title="t('connection.listView')" :aria-label="t('connection.listView')" @click="dbPickerView = 'list'">
+                  <List class="h-3.5 w-3.5" />
+                </Button>
+              </div>
+              <div class="relative w-full sm:w-64">
+                <Search class="absolute left-2.5 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
+                <Input v-model="dbSearchQuery" class="h-9 pl-8" :placeholder="t('connection.searchDatabasePlaceholder')" />
+              </div>
+            </div>
+          </div>
+
+          <div class="max-h-[58vh] space-y-5 overflow-y-auto pr-2">
+            <section v-for="category in filteredDbCategories" :key="category.key" class="space-y-2">
+              <div class="flex items-center">
+                <h3 v-if="category.title" class="text-sm font-medium">{{ category.title }}</h3>
+              </div>
+
+              <div v-if="dbPickerView === 'icon'" class="connection-db-picker-grid grid grid-cols-2 gap-2 sm:grid-cols-4 lg:grid-cols-5">
+                <button
+                  v-for="opt in category.options"
+                  :key="opt.value"
+                  type="button"
+                  class="connection-db-picker-option group flex min-h-24 flex-col items-center justify-center gap-2 rounded-xl border bg-background/70 p-3 text-center transition hover:-translate-y-0.5 hover:border-primary/40 hover:bg-muted/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                  :class="selectedType === opt.value ? 'connection-db-picker-option--selected shadow-sm' : 'border-border'"
+                  :aria-pressed="selectedType === opt.value"
+                  @click="onDbTypeChange(opt.value)"
+                  @dblclick="goToConnectionStep(opt.value)"
+                >
+                  <span class="flex h-10 w-10 items-center justify-center rounded-xl bg-muted/60 transition group-hover:bg-background">
+                    <DatabaseIcon :db-type="iconTypeMap[opt.value]" class="h-6 w-6" />
+                  </span>
+                  <span class="max-w-full truncate text-sm font-medium">{{ opt.label }}</span>
+                </button>
+              </div>
+
+              <div v-else class="grid gap-2">
+                <button
+                  v-for="opt in category.options"
+                  :key="opt.value"
+                  type="button"
+                  class="connection-db-picker-option flex items-center gap-3 rounded-lg border bg-background px-3 py-2 text-left transition hover:border-primary/40 hover:bg-muted/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                  :class="selectedType === opt.value ? 'connection-db-picker-option--selected' : 'border-border'"
+                  :aria-pressed="selectedType === opt.value"
+                  @click="onDbTypeChange(opt.value)"
+                  @dblclick="goToConnectionStep(opt.value)"
+                >
+                  <DatabaseIcon :db-type="iconTypeMap[opt.value]" class="h-5 w-5 shrink-0" />
+                  <span class="min-w-0 flex-1 truncate text-sm font-medium">{{ opt.label }}</span>
+                  <span class="text-xs text-muted-foreground">{{ category.title }}</span>
+                </button>
+              </div>
+            </section>
+
+            <div v-if="!hasDbPickerResults" class="rounded-xl border border-dashed py-12 text-center text-sm text-muted-foreground">
+              {{ t("connection.noDatabaseMatches") }}
+            </div>
+          </div>
+        </div>
+
+        <DialogFooter class="flex items-center gap-2">
+          <div class="mr-auto flex min-w-0 items-center gap-2 text-sm text-muted-foreground">
+            <DatabaseIcon :db-type="selectedDbIcon" class="h-4 w-4 shrink-0" />
+            <span class="truncate">{{ t("connection.selectedDatabase") }}: {{ selectedProfile().label }}</span>
+          </div>
+          <Button :disabled="!hasDbPickerResults" @click="goToConnectionStep()">
+            {{ t("connection.next") }}
+            <ChevronRight class="h-4 w-4" />
+          </Button>
+        </DialogFooter>
+      </template>
+
+      <template v-else>
+        <div class="space-y-3">
+          <Tabs v-model="configTab" class="min-h-0">
+            <div class="flex items-center justify-between border-b pb-2">
+              <TabsList>
+                <TabsTrigger value="connection">{{ t("connection.basicTab") }}</TabsTrigger>
+                <TabsTrigger v-if="supportsTlsToggle" value="tls">{{ t("connection.tlsTab") }}</TabsTrigger>
+                <TabsTrigger v-if="canUseTransportLayers" value="transport">{{ t("connection.sshTunnel") }}</TabsTrigger>
+                <TabsTrigger value="advanced">{{ t("connection.advancedTab") }}</TabsTrigger>
+              </TabsList>
+            </div>
+
+            <TabsContent value="connection" class="m-0">
+              <div class="connection-form-body grid gap-4 py-4 pr-2 max-h-[65vh] overflow-y-auto">
+                <div v-if="!isJdbcConnection" class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelClass">{{ t("connection.connectionUrlOptional") }}</Label>
+                  <div class="col-span-3 flex items-center gap-1">
+                    <Input v-model="connectionUrlInput" class="flex-1" :placeholder="connectionUrlPlaceholder" @keydown.enter.prevent="applyConnectionUrl" />
+                    <Tooltip>
+                      <TooltipTrigger as-child>
+                        <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" :disabled="!connectionUrlInput.trim()" :aria-label="t('connection.parseConnectionUrl')" @click="applyConnectionUrl">
+                          <Link2 class="h-4 w-4" />
+                        </Button>
+                      </TooltipTrigger>
+                      <TooltipContent>{{ t("connection.parseConnectionUrl") }}</TooltipContent>
+                    </Tooltip>
+                  </div>
+                </div>
+
+                <div class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelClass">{{ t("connection.name") }}</Label>
+                  <Input v-model="form.name" class="col-span-3" :placeholder="t('connection.namePlaceholder')" />
+                </div>
+
+                <div class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelClass">{{ t("connection.type") }}</Label>
+                  <button type="button" class="col-span-3 flex items-center gap-2 rounded-md border bg-muted/20 px-3 py-2 hover:bg-muted/40 cursor-pointer transition" @click="backToDatabasePicker()">
+                    <DatabaseIcon :db-type="selectedDbIcon" class="h-4 w-4 shrink-0" />
+                    <span class="min-w-0 flex-1 truncate text-sm text-left">{{ selectedProfile().label }}</span>
+                    <Pencil class="h-3 w-3 text-muted-foreground" />
+                  </button>
+                </div>
+
+                <!-- OceanBase mode toggle -->
+                <div v-if="selectedType === 'oceanbase'" class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("connection.mode") }}</Label>
+                  <div class="col-span-3 flex gap-2">
+                    <Button size="sm" :variant="oceanbaseSubMode === 'mysql' ? 'default' : 'outline'" @click="switchOceanbaseMode('mysql')">
+                      {{ t("connection.oceanbaseMySQLMode") }}
+                    </Button>
+                    <Button size="sm" :variant="oceanbaseSubMode === 'oracle' ? 'default' : 'outline'" @click="switchOceanbaseMode('oracle')">
+                      {{ t("connection.oceanbaseOracleMode") }}
+                    </Button>
+                  </div>
+                </div>
+
+                <div v-if="selectedType === 'gbase'" class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("connection.version") }}</Label>
+                  <div class="col-span-3 flex gap-2">
+                    <Button size="sm" :variant="form.driver_profile === 'gbase8s' ? 'outline' : 'default'" @click="switchGbaseProfile('gbase8a')"> GBase 8a </Button>
+                    <Button size="sm" :variant="form.driver_profile === 'gbase8s' ? 'default' : 'outline'" @click="switchGbaseProfile('gbase8s')"> GBase 8s </Button>
+                  </div>
+                </div>
+
+                <div v-if="isCustomCompatibleProfile()" class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelClass">{{ t("connection.driverName") }}</Label>
+                  <Input v-model="customDriverName" class="col-span-3" :placeholder="t('connection.driverNamePlaceholder')" />
+                </div>
+
+                <div class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelClass">{{ t("connection.color") }}</Label>
+                  <div class="col-span-3 flex items-center gap-1.5">
+                    <button
+                      v-for="color in colorOptions"
+                      :key="color.value || 'none'"
+                      type="button"
+                      class="h-6 w-6 rounded-full border ring-offset-background transition hover:scale-105"
+                      :class="[color.class, form.color === color.value ? 'ring-2 ring-ring ring-offset-2' : 'border-border']"
+                      :title="t(color.labelKey)"
+                      @click="handlePresetClick(color.value)"
+                    />
+                    <Popover v-model:open="customColorOpen">
+                      <PopoverTrigger as-child>
+                        <button
+                          type="button"
+                          class="h-6 w-6 rounded-full border flex items-center justify-center hover:scale-105 transition"
+                          :class="[!isPresetColor(form.color) && form.color ? 'border-border ring-2 ring-ring ring-offset-2' : 'border-dashed border-border']"
+                          :style="!isPresetColor(form.color) && form.color ? { backgroundColor: form.color } : {}"
+                          :title="t('connection.colorCustom')"
+                        >
+                          <Pipette class="h-3.5 w-3.5" :class="!isPresetColor(form.color) && form.color ? 'text-white' : 'text-muted-foreground'" />
+                        </button>
+                      </PopoverTrigger>
+                      <PopoverContent class="w-auto p-2">
+                        <div class="flex items-center gap-2">
+                          <input type="color" :value="form.color" @input="handleCustomColorPicked(($event.target as HTMLInputElement).value)" class="h-6 w-6 cursor-pointer rounded border-0 p-0" />
+                          <Input type="text" :value="customColorInput || form.color" @input="handleCustomColorInput(($event.target as HTMLInputElement).value)" class="w-28 h-7 text-xs font-mono" :placeholder="'#ff0000 或 rgba(…)'" />
+                        </div>
+                      </PopoverContent>
+                    </Popover>
+                  </div>
+                </div>
+
+                <div v-if="form.db_type === 'h2'" class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("connection.mode") }}</Label>
+                  <div class="col-span-3 flex gap-2">
+                    <Button size="sm" :variant="h2ConnectionMode === 'file' ? 'default' : 'outline'" @click="switchH2ConnectionMode('file')">
+                      {{ t("connection.h2FileMode") }}
+                    </Button>
+                    <Button size="sm" :variant="h2ConnectionMode === 'tcp' ? 'default' : 'outline'" @click="switchH2ConnectionMode('tcp')">
+                      {{ t("connection.h2TcpMode") }}
+                    </Button>
+                  </div>
+                </div>
+
+                <div v-if="form.db_type === 'h2'" class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">Driver</Label>
+                  <div class="col-span-3 flex gap-2">
+                    <Button
+                      size="sm"
+                      :variant="form.driver_profile !== 'h2-legacy' ? 'default' : 'outline'"
+                      @click="
+                        form.driver_profile = 'h2';
+                        resetTestState();
+                      "
+                      >H2 2.3</Button
+                    >
+                    <Button
+                      size="sm"
+                      :variant="form.driver_profile === 'h2-legacy' ? 'default' : 'outline'"
+                      @click="
+                        form.driver_profile = 'h2-legacy';
+                        resetTestState();
+                      "
+                      >H2 2.1 Legacy</Button
+                    >
+                  </div>
+                </div>
+
+                <div v-if="h2DriverMissing" class="grid grid-cols-4 items-center gap-4">
+                  <span />
+                  <p class="col-span-3 text-xs text-muted-foreground">
+                    {{ t("connection.driverInstallHintPrefix") }}<a class="underline cursor-pointer text-primary hover:text-primary/80" @click="emit('openDriverStore')">{{ t("toolbar.driverManager") }}</a
+                    >{{ t("connection.driverInstallHintSuffix") }}
+                  </p>
+                </div>
+
+                <!-- JDBC: optional external plugin -->
+                <template v-if="isJdbcConnection">
+                  <div v-if="form.driver_profile === 'dremio'" class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.mode") }}</Label>
+                    <div class="col-span-3 flex gap-2">
+                      <Button size="sm" :variant="dremioConnectionMode === 'arrow-flight-sql' ? 'default' : 'outline'" @click="applyDremioConnectionMode('arrow-flight-sql')">
+                        {{ t("connection.dremioArrowFlightSqlMode") }}
+                      </Button>
+                      <Button size="sm" :variant="dremioConnectionMode === 'legacy' ? 'default' : 'outline'" @click="applyDremioConnectionMode('legacy')">
+                        {{ t("connection.dremioLegacyJdbcMode") }}
+                      </Button>
+                    </div>
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.jdbcUrl") }}</Label>
+                    <Input v-model="form.connection_string" class="col-span-3" :placeholder="t('connection.jdbcUrlPlaceholder')" @blur="syncDremioConnectionModeFromUrl" />
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.user") }}</Label>
+                    <Input v-model="form.username" class="col-span-3" :placeholder="jdbcUsernamePlaceholder" />
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.password") }}</Label>
+                    <PasswordInput v-model="form.password" class="col-span-3" />
+                  </div>
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <Label :class="connectionLabelTopClass">{{ t("connection.jdbcDriverPaths") }}</Label>
+                    <div class="col-span-3 space-y-2">
+                      <Select v-if="jdbcDriverSelectItems.length > 0" :model-value="selectedJdbcDriverPath" @update:model-value="onJdbcDriverSelect">
+                        <SelectTrigger>
+                          <SelectValue :placeholder="t('connection.jdbcDriverSelectPlaceholder')" />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem v-for="driver in jdbcDriverSelectItems" :key="driver.id" :value="driver.id">
+                            {{ driver.label }}
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+                      <div class="flex items-center justify-between gap-3 rounded-md border bg-muted/20 px-3 py-2">
+                        <div class="flex min-w-0 items-center gap-2">
+                          <div class="truncate text-xs font-medium">{{ t("connection.jdbcManualClasspath") }}</div>
+                          <Badge variant="outline" class="h-5 shrink-0 rounded-full px-2 text-[10px] font-medium">
+                            {{ t("connection.jdbcManualClasspathCount", { count: jdbcManualClasspathCount }) }}
+                          </Badge>
+                        </div>
+                        <Switch v-model="jdbcManualClasspathOpen" />
+                      </div>
+                      <div v-if="jdbcManualClasspathOpen" class="flex items-start gap-1">
+                        <textarea
+                          v-model="jdbcDriverPathsInput"
+                          class="flex min-h-12 w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                          :placeholder="t('connection.jdbcDriverPathsPlaceholder')"
+                        />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button type="button" variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseJdbcDriverPaths">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.jdbcDriverBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                    </div>
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.jdbcDriverClass") }}</Label>
+                    <Input v-model="form.jdbc_driver_class" class="col-span-3" :placeholder="t('connection.jdbcDriverClassPlaceholder')" />
+                  </div>
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <span />
+                    <div class="col-span-3 space-y-2">
+                      <p class="text-xs text-muted-foreground">
+                        {{ t("connection.jdbcPluginHint") }}
+                      </p>
+                      <div class="flex flex-wrap gap-2">
+                        <Button type="button" variant="outline" size="sm" @click="emit('openDriverStore')">
+                          <FolderOpen class="h-3.5 w-3.5" />
+                          {{ t("toolbar.driverManager") }}
+                        </Button>
+                        <Button type="button" variant="outline" size="sm" @click="openExternalUrl('https://dbxio.com')">
+                          <ExternalLink class="h-3.5 w-3.5" />
+                          {{ t("connection.jdbcDocs") }}
+                        </Button>
+                      </div>
+                    </div>
+                  </div>
+                </template>
+
+                <!-- Local database files: file path only -->
+                <template v-else-if="usesLocalFilePathInput">
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.filePath") }}</Label>
+                    <div class="col-span-3 space-y-1">
+                      <div class="flex items-center gap-1">
+                        <Input v-model="form.host" class="flex-1" :placeholder="filePathPlaceholder" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseDbFilePath">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.sshKeyPathBrowse") }}</TooltipContent>
+                        </Tooltip>
+                        <Tooltip v-if="isDesktop && form.db_type === 'duckdb'">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="createDuckDbFilePath">
+                              <FilePlus2 class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.createDuckDbFile") }}</TooltipContent>
+                        </Tooltip>
+                        <Tooltip v-if="isDesktop && form.db_type === 'sqlite'">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="createSqliteFilePath">
+                              <FilePlus2 class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.createSqliteFile") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                      <p v-if="supportsMemoryDatabasePath" class="text-xs text-muted-foreground">
+                        {{ t("connection.memoryDatabasePathHint") }}
+                      </p>
+                    </div>
+                  </div>
+                  <div v-if="form.db_type === 'sqlite'" class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.sqliteCipherKey") }}</Label>
+                    <PasswordInput v-model="form.password" class="col-span-3" :placeholder="t('connection.sqliteCipherKeyPlaceholder')" />
+                  </div>
+                  <div v-if="form.db_type === 'sqlite'" class="grid grid-cols-4 items-start gap-4">
+                    <Label :class="connectionLabelTopClass">{{ t("connection.sqliteExtensions") }}</Label>
+                    <div class="col-span-3 space-y-1">
+                      <div class="flex items-start gap-1">
+                        <textarea
+                          v-model="sqliteExtensionPaths"
+                          class="flex min-h-[76px] flex-1 rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                          :placeholder="t('connection.sqliteExtensionsPlaceholder')"
+                          spellcheck="false"
+                        />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseSqliteExtensionPath">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.sqliteExtensionBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                      <p class="text-xs text-muted-foreground">
+                        {{ t("connection.sqliteExtensionsHint") }}
+                      </p>
+                    </div>
+                  </div>
+                  <template v-if="form.db_type === 'h2' || form.db_type === 'access'">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.user") }}{{ form.db_type === "access" ? "（可选）" : "" }}</Label>
+                      <Input v-model="form.username" class="col-span-3" :placeholder="form.db_type === 'access' ? '' : 'sa'" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.password") }}{{ form.db_type === "access" ? "（可选）" : "" }}</Label>
+                      <PasswordInput v-model="form.password" class="col-span-3" />
+                    </div>
+                  </template>
+                </template>
+
+                <!-- Message Queue: admin URL and auth -->
+                <template v-else-if="form.db_type === 'mq'">
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">System</Label>
+                    <Select v-model="mqSystemKind">
+                      <SelectTrigger class="col-span-3 h-9">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem v-for="option in mqSystemOptions" :key="option.value" :value="option.value">
+                          {{ option.label }}
+                        </SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+                  <template v-if="mqSystemKind === 'kafka'">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Bootstrap Servers</Label>
+                      <Input v-model="mqKafkaBootstrapServers" class="col-span-3" placeholder="127.0.0.1:9092" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Security</Label>
+                      <Select v-model="mqKafkaSecurityProtocol">
+                        <SelectTrigger class="col-span-3 h-9">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem v-for="option in mqKafkaSecurityProtocolOptions" :key="option.value" :value="option.value">
+                            {{ option.label }}
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                  </template>
+                  <template v-else>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Admin URL</Label>
+                      <Input v-model="mqAdminUrl" class="col-span-3" placeholder="http://127.0.0.1:8080" />
+                    </div>
+                  </template>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">Auth</Label>
+                    <div class="col-span-3 flex flex-wrap gap-2">
+                      <Button size="sm" :variant="mqAuthKind === 'none' ? 'default' : 'outline'" @click="mqAuthKind = 'none'">None</Button>
+                      <Button v-if="mqSystemKind !== 'kafka'" size="sm" :variant="mqAuthKind === 'token' ? 'default' : 'outline'" @click="mqAuthKind = 'token'">Token</Button>
+                      <Button size="sm" :variant="mqAuthKind === 'basic' ? 'default' : 'outline'" @click="mqAuthKind = 'basic'">Basic</Button>
+                      <Button v-if="mqSystemKind === 'kafka'" size="sm" :variant="mqAuthKind === 'kerberos' ? 'default' : 'outline'" @click="mqAuthKind = 'kerberos'">Kerberos</Button>
+                      <Button v-if="mqSystemKind !== 'kafka'" size="sm" :variant="mqAuthKind === 'apiKey' ? 'default' : 'outline'" @click="mqAuthKind = 'apiKey'">API Key</Button>
+                      <Button v-if="mqSystemKind !== 'kafka'" size="sm" :variant="mqAuthKind === 'oauth2' ? 'default' : 'outline'" @click="mqAuthKind = 'oauth2'">OAuth2</Button>
+                    </div>
+                  </div>
+                  <template v-if="mqAuthKind === 'token'">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Token</Label>
+                      <PasswordInput v-model="mqToken" class="col-span-3" />
+                    </div>
+                  </template>
+                  <template v-else-if="mqAuthKind === 'basic'">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.user") }}</Label>
+                      <Input v-model="mqBasicUsername" class="col-span-3" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.password") }}</Label>
+                      <PasswordInput v-model="mqBasicPassword" class="col-span-3" />
+                    </div>
+                    <div v-if="mqSystemKind === 'kafka'" class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">SASL Mechanism</Label>
+                      <Select v-model="mqKafkaSaslMechanism">
+                        <SelectTrigger class="col-span-3 h-9">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem v-for="option in mqKafkaSaslMechanismOptions" :key="option.value" :value="option.value">
+                            {{ option.label }}
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                  </template>
+                  <template v-else-if="mqSystemKind === 'kafka' && mqAuthKind === 'kerberos'">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.kafkaKerberosPrincipal") }}</Label>
+                      <Input v-model="mqKafkaKerberosPrincipal" class="col-span-3" placeholder="user@EXAMPLE.COM" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.kafkaKerberosKeytab") }}</Label>
+                      <div class="col-span-3 flex items-center gap-1">
+                        <Input v-model="mqKafkaKerberosKeytabPath" class="flex-1" :placeholder="t('connection.kafkaKerberosKeytabPlaceholder')" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseKafkaKerberosFile('keytab')">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.kafkaKerberosKeytabBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.kafkaKerberosServiceName") }}</Label>
+                      <Input v-model="mqKafkaKerberosServiceName" class="col-span-3" placeholder="kafka" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.kafkaKerberosKrb5Conf") }}</Label>
+                      <div class="col-span-3 flex items-center gap-1">
+                        <Input v-model="mqKafkaKrb5ConfPath" class="flex-1" :placeholder="t('connection.kafkaKerberosKrb5ConfPlaceholder')" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseKafkaKerberosFile('krb5')">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.kafkaKerberosKrb5ConfBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                    </div>
+                    <div class="grid grid-cols-4 items-start gap-4">
+                      <div></div>
+                      <div class="col-span-3 space-y-1 text-xs leading-5 text-muted-foreground">
+                        <p>{{ t("connection.kafkaKerberosPathHint") }}</p>
+                        <p>{{ t("connection.kafkaKerberosAuthHint") }}</p>
+                      </div>
+                    </div>
+                  </template>
+                  <template v-else-if="mqAuthKind === 'apiKey'">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Header</Label>
+                      <Input v-model="mqApiKeyHeader" class="col-span-3" placeholder="Authorization" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Value</Label>
+                      <PasswordInput v-model="mqApiKeyValue" class="col-span-3" />
+                    </div>
+                  </template>
+                  <template v-else-if="mqAuthKind === 'oauth2'">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Issuer URL</Label>
+                      <Input v-model="mqOauthIssuerUrl" class="col-span-3" placeholder="https://issuer.example.com/oauth/token" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Client ID</Label>
+                      <Input v-model="mqOauthClientId" class="col-span-3" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Client Secret</Label>
+                      <PasswordInput v-model="mqOauthClientSecret" class="col-span-3" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Audience</Label>
+                      <Input v-model="mqOauthAudience" class="col-span-3" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Scope</Label>
+                      <Input v-model="mqOauthScope" class="col-span-3" />
+                    </div>
+                  </template>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">TLS</Label>
+                    <label class="col-span-3 inline-flex items-center gap-2">
+                      <input type="checkbox" v-model="mqTlsSkipVerify" class="mr-0" />
+                      <span class="text-xs text-muted-foreground">Skip certificate verification</span>
+                    </label>
+                  </div>
+                  <div v-if="mqSystemKind !== 'kafka'" class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">Pinned Version</Label>
+                    <Select v-model="mqPinnedVersion">
+                      <SelectTrigger class="col-span-3 h-9">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem v-for="option in MQ_PINNED_VERSION_OPTIONS" :key="option.value" :value="option.value">
+                          <div class="grid gap-0.5 text-left">
+                            <span>{{ option.label }}</span>
+                            <span class="text-xs text-muted-foreground">{{ option.description }}</span>
+                          </div>
+                        </SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+                  <div v-if="mqSystemKind !== 'kafka'" class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">Broker Token 签发</Label>
+                    <Select v-model="mqTokenSigningMode">
+                      <SelectTrigger class="col-span-3 h-9">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="none">不配置</SelectItem>
+                        <SelectItem value="hs256">HS256 SECRET</SelectItem>
+                        <SelectItem value="rs256">RS256 PRIVATE</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+                  <div v-if="mqSystemKind !== 'kafka' && mqTokenSigningMode !== 'none'" class="grid grid-cols-4 items-start gap-4">
+                    <Label class="pt-2 text-right">签发密钥</Label>
+                    <textarea
+                      v-model="mqTokenSigningKey"
+                      class="col-span-3 min-h-24 rounded-md border border-input bg-background px-3 py-2 text-sm shadow-sm outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                      :placeholder="mqTokenSigningMode === 'hs256' ? 'Broker SECRET' : '-----BEGIN PRIVATE KEY-----'"
+                    />
+                  </div>
+                  <div v-if="mqSystemKind !== 'kafka' && mqTokenSigningMode !== 'none'" class="grid grid-cols-4 items-start gap-4">
+                    <span />
+                    <p class="col-span-3 m-0 text-xs leading-5 text-muted-foreground">按 Broker 的 jwt.broker.token.mode 选择：SECRET 使用 HS256，PRIVATE 使用 RS256。密钥会走连接 secret 存储。</p>
+                  </div>
+                </template>
+
+                <!-- Nacos: server address, namespace and auth -->
+                <template v-else-if="form.db_type === 'nacos'">
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.nacosConsoleUrl") }}</Label>
+                    <Input v-model="nacosServerAddr" class="col-span-3" placeholder="http://127.0.0.1:8085" />
+                  </div>
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <span />
+                    <p class="col-span-3 m-0 text-xs leading-5 text-muted-foreground">{{ t("connection.nacosConsoleUrlHint") }}</p>
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.nacosNamespace") }}</Label>
+                    <Input v-model="nacosNamespace" class="col-span-3" placeholder="public" />
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.nacosContextPath") }}</Label>
+                    <Input v-model="nacosContextPath" class="col-span-3" :placeholder="t('connection.nacosContextPathPlaceholder')" />
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.nacosAuth") }}</Label>
+                    <div class="col-span-3 flex flex-wrap gap-2">
+                      <Button size="sm" :variant="nacosAuthKind === 'none' ? 'default' : 'outline'" @click="nacosAuthKind = 'none'">{{ t("connection.nacosAuthNone") }}</Button>
+                      <Button size="sm" :variant="nacosAuthKind === 'usernamePassword' ? 'default' : 'outline'" @click="nacosAuthKind = 'usernamePassword'">{{ t("connection.nacosAuthUserPassword") }}</Button>
+                    </div>
+                  </div>
+                  <template v-if="nacosAuthKind === 'usernamePassword'">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.user") }}</Label>
+                      <Input v-model="nacosUsername" class="col-span-3" placeholder="nacos" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.password") }}</Label>
+                      <PasswordInput v-model="nacosPassword" class="col-span-3" />
+                    </div>
+                  </template>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.nacosTls") }}</Label>
+                    <label class="col-span-3 inline-flex items-center gap-2">
+                      <input type="checkbox" v-model="nacosTlsSkipVerify" class="mr-0" />
+                      <span class="text-xs text-muted-foreground">{{ t("connection.nacosTlsSkipVerify") }}</span>
+                    </label>
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.nacosPageSize") }}</Label>
+                    <Input v-model.number="nacosPageSize" type="number" min="1" max="500" class="col-span-3" />
+                  </div>
+                </template>
+
+                <!-- Redis: host, port, user, password, ssl -->
+                <template v-else-if="form.db_type === 'redis'">
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.mode") }}</Label>
+                    <div class="col-span-3 flex gap-2">
+                      <Button size="sm" :variant="form.redis_connection_mode === 'standalone' ? 'default' : 'outline'" @click="form.redis_connection_mode = 'standalone'">
+                        {{ t("connection.redisStandaloneMode") }}
+                      </Button>
+                      <Button size="sm" :variant="form.redis_connection_mode === 'sentinel' ? 'default' : 'outline'" @click="form.redis_connection_mode = 'sentinel'">
+                        {{ t("connection.redisSentinelMode") }}
+                      </Button>
+                      <Button size="sm" :variant="form.redis_connection_mode === 'cluster' ? 'default' : 'outline'" @click="form.redis_connection_mode = 'cluster'">
+                        {{ t("connection.redisClusterMode") }}
+                      </Button>
+                    </div>
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ form.redis_connection_mode === "sentinel" ? t("connection.redisFirstSentinel") : form.redis_connection_mode === "cluster" ? t("connection.redisFirstClusterNode") : t("connection.host") }}</Label>
+                    <Input v-model="form.host" class="col-span-2" />
+                    <Input v-model.number="form.port" type="number" class="col-span-1" />
+                  </div>
+                  <template v-if="form.redis_connection_mode === 'sentinel'">
+                    <div class="grid grid-cols-4 items-start gap-4">
+                      <Label :class="connectionLabelTopClass">{{ t("connection.redisSentinelNodes") }}</Label>
+                      <textarea
+                        v-model="form.redis_sentinel_nodes"
+                        class="col-span-3 flex min-h-[76px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                        placeholder="sentinel-1:26379&#10;sentinel-2:26379"
+                        spellcheck="false"
+                      />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.redisSentinelMaster") }}</Label>
+                      <Input v-model="form.redis_sentinel_master" class="col-span-3" placeholder="mymaster" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.redisSentinelUser") }}</Label>
+                      <Input v-model="form.redis_sentinel_username" class="col-span-3" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.redisSentinelPassword") }}</Label>
+                      <PasswordInput v-model="form.redis_sentinel_password" class="col-span-3" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.redisSentinelTls") }}</Label>
+                      <label class="col-span-3 inline-flex items-center gap-2">
+                        <input type="checkbox" v-model="form.redis_sentinel_tls" class="mr-0" />
+                        <span class="text-xs text-muted-foreground">{{ t("connection.redisSentinelTlsHint") }}</span>
+                      </label>
+                    </div>
+                  </template>
+                  <template v-else-if="form.redis_connection_mode === 'cluster'">
+                    <div class="grid grid-cols-4 items-start gap-4">
+                      <Label :class="connectionLabelTopClass">{{ t("connection.redisClusterNodes") }}</Label>
+                      <textarea
+                        v-model="form.redis_cluster_nodes"
+                        class="col-span-3 flex min-h-[76px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                        placeholder="redis-1:6379&#10;redis-2:6379"
+                        spellcheck="false"
+                      />
+                    </div>
+                  </template>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.user") }}</Label>
+                    <Input v-model="form.username" class="col-span-3" placeholder="default" />
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.password") }}</Label>
+                    <PasswordInput v-model="form.password" class="col-span-3" :placeholder="t('connection.databasePlaceholder')" />
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.redisKeySeparator") }}</Label>
+                    <Input v-model="form.redis_key_separator" class="col-span-3 h-8 text-xs" placeholder=":" />
+                  </div>
+                </template>
+
+                <!-- etcd: endpoints, user, password, TLS -->
+                <template v-else-if="form.db_type === 'etcd'">
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.host") }}</Label>
+                    <Input v-model="form.host" class="col-span-2" />
+                    <Input v-model.number="form.port" type="number" class="col-span-1" />
+                  </div>
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <Label :class="connectionLabelTopClass">{{ t("connection.etcdEndpoints") }}</Label>
+                    <div class="col-span-3 space-y-1">
+                      <textarea
+                        v-model="etcdEndpointsLines"
+                        class="flex min-h-[76px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                        placeholder="http://127.0.0.1:2379&#10;https://etcd-2:2379"
+                        spellcheck="false"
+                      />
+                      <p class="text-xs text-muted-foreground">
+                        {{ t("connection.etcdEndpointsHint") }}
+                      </p>
+                    </div>
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.user") }}</Label>
+                    <Input v-model="form.username" class="col-span-3" />
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.password") }}</Label>
+                    <PasswordInput v-model="form.password" class="col-span-3" />
+                  </div>
+                </template>
+
+                <!-- ZooKeeper: host, connect string, user, password -->
+                <template v-else-if="form.db_type === 'zookeeper'">
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.host") }}</Label>
+                    <Input v-model="form.host" class="col-span-2" placeholder="127.0.0.1" />
+                    <Input v-model.number="form.port" type="number" class="col-span-1" />
+                  </div>
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <Label :class="connectionLabelTopClass">{{ t("connection.zookeeperConnectString") }}</Label>
+                    <div class="col-span-3 space-y-1">
+                      <textarea
+                        v-model="zookeeperConnectString"
+                        class="flex min-h-[76px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                        placeholder="127.0.0.1:2181&#10;zk-2:2181"
+                        spellcheck="false"
+                      />
+                      <p class="text-xs text-muted-foreground">
+                        {{ t("connection.zookeeperConnectStringHint") }}
+                      </p>
+                    </div>
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.user") }}</Label>
+                    <Input v-model="form.username" class="col-span-3" />
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.password") }}</Label>
+                    <PasswordInput v-model="form.password" class="col-span-3" />
+                  </div>
+                </template>
+
+                <!-- MongoDB: URL or form -->
+                <template v-else-if="form.db_type === 'mongodb'">
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.driverMode") }}</Label>
+                    <div class="col-span-3 flex items-center gap-2">
+                      <Button size="sm" :variant="mongoDriverMode === 'legacy' ? 'outline' : 'default'" @click="mongoDriverMode = 'auto'">{{ t("connection.mongoDriverAuto") }}</Button>
+                      <Button size="sm" :variant="mongoDriverMode === 'legacy' ? 'default' : 'outline'" @click="mongoDriverMode = 'legacy'">{{ t("connection.mongoDriverLegacy") }}</Button>
+                      <Tooltip>
+                        <TooltipTrigger as-child>
+                          <CircleHelp class="h-3.5 w-3.5 cursor-help text-muted-foreground hover:text-foreground" />
+                        </TooltipTrigger>
+                        <TooltipContent side="top" align="center" class="max-w-[320px] text-xs leading-relaxed">
+                          {{ t("connection.mongoLegacyHint") }}
+                        </TooltipContent>
+                      </Tooltip>
+                    </div>
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.mode") }}</Label>
+                    <div class="col-span-3 flex gap-2">
+                      <Button size="sm" :variant="mongoUseUrl ? 'outline' : 'default'" @click="mongoUseUrl = false">{{ t("connection.modeForm") }}</Button>
+                      <Button size="sm" :variant="mongoUseUrl ? 'default' : 'outline'" @click="mongoUseUrl = true">URL</Button>
+                    </div>
+                  </div>
+                  <template v-if="mongoUseUrl">
+                    <div class="grid grid-cols-4 items-start gap-4">
+                      <Label :class="connectionLabelTopClass">URL</Label>
+                      <textarea
+                        v-model="form.connection_string"
+                        class="col-span-3 flex min-h-[80px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                        placeholder="mongodb+srv://user:pass@cluster.mongodb.net/mydb"
+                      />
+                    </div>
+                  </template>
+                  <template v-else>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.host") }}</Label>
+                      <Input v-model="form.host" class="col-span-2" />
+                      <Input v-model.number="form.port" type="number" class="col-span-1" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <span />
+                      <label class="col-span-3 flex items-center gap-2 text-sm">
+                        <input type="checkbox" v-model="form.ssl" class="mr-0" />
+                        <span>{{ t("connection.sslEnable") }}</span>
+                      </label>
+                    </div>
+                    <template v-if="form.ssl">
+                      <div class="grid grid-cols-4 items-start gap-4">
+                        <Label :class="connectionLabelClass">{{ t("connection.mongoTlsAllowInvalidCertificates") }}</Label>
+                        <label class="col-span-3 flex items-start gap-2 cursor-pointer">
+                          <input v-model="mongoTlsAllowInvalidCertificates" type="checkbox" class="mr-0 mt-0.5" />
+                          <span class="text-xs leading-5 text-muted-foreground">
+                            {{ t("connection.mongoTlsAllowInvalidCertificatesHint") }}
+                          </span>
+                        </label>
+                      </div>
+                      <div class="grid grid-cols-4 items-start gap-4">
+                        <Label :class="connectionLabelClass">{{ t("connection.mongoRetryWrites") }}</Label>
+                        <label class="col-span-3 flex items-start gap-2 cursor-pointer">
+                          <input v-model="mongoRetryWrites" type="checkbox" class="mr-0 mt-0.5" />
+                          <span class="text-xs leading-5 text-muted-foreground">
+                            {{ t("connection.mongoRetryWritesHint") }}
+                          </span>
+                        </label>
+                      </div>
+                      <div class="grid grid-cols-4 items-center gap-4">
+                        <Label :class="connectionLabelClass">{{ t("connection.caCertPath") }}</Label>
+                        <div class="col-span-3 flex items-center gap-1">
+                          <Input v-model="form.ca_cert_path" class="flex-1" :placeholder="t('connection.caCertPathPlaceholder')" />
+                          <Tooltip v-if="isDesktop">
+                            <TooltipTrigger as-child>
+                              <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseCaCertPath">
+                                <FolderOpen class="h-4 w-4" />
+                              </Button>
+                            </TooltipTrigger>
+                            <TooltipContent>{{ t("connection.caCertPathBrowse") }}</TooltipContent>
+                          </Tooltip>
+                        </div>
+                      </div>
+                    </template>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.user") }}</Label>
+                      <Input v-model="form.username" class="col-span-3" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.password") }}</Label>
+                      <PasswordInput v-model="form.password" class="col-span-3" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.defaultDatabase") }}</Label>
+                      <Input v-model="form.database" class="col-span-3" :placeholder="t('connection.databasePlaceholder')" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.authDatabase") }}</Label>
+                      <Input v-model="mongoAuthDatabase" class="col-span-3" :placeholder="t('connection.authDatabasePlaceholder')" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.authMechanism") }}</Label>
+                      <Select v-model="mongoAuthMechanism">
+                        <SelectTrigger class="col-span-3">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="default">{{ t("connection.authMechanismDefault") }}</SelectItem>
+                          <SelectItem value="SCRAM-SHA-1">SCRAM-SHA-1</SelectItem>
+                          <SelectItem value="SCRAM-SHA-256">SCRAM-SHA-256</SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.urlParams") }}</Label>
+                      <Input v-model="form.url_params" class="col-span-3" placeholder="replicaSet=rs0&authSource=admin" />
+                    </div>
+                  </template>
+                </template>
+
+                <!-- InfluxDB: v1 username/password or v2 token/org/bucket -->
+                <template v-else-if="form.db_type === 'influxdb'">
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.version") }}</Label>
+                    <Select v-model="influxDbVersion">
+                      <SelectTrigger class="col-span-3">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="1">InfluxDB 1.x</SelectItem>
+                        <SelectItem value="2">InfluxDB 2.x</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.host") }}</Label>
+                    <Input v-model="form.host" class="col-span-2" />
+                    <Input v-model.number="form.port" type="number" class="col-span-1" />
+                  </div>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <span />
+                    <label class="col-span-3 flex items-center gap-2 text-sm">
+                      <input type="checkbox" v-model="form.ssl" class="mr-0" />
+                      <span>{{ t("connection.sslEnable") }}</span>
+                    </label>
+                  </div>
+                  <template v-if="influxDbVersion === '2'">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Organization</Label>
+                      <Input v-model="influxDbOrg" class="col-span-3" placeholder="my-org" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Bucket</Label>
+                      <Input v-model="form.database" class="col-span-3" placeholder="my-bucket" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">Token</Label>
+                      <PasswordInput v-model="form.password" class="col-span-3" />
+                    </div>
+                  </template>
+                  <template v-else>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.user") }}</Label>
+                      <Input v-model="form.username" class="col-span-3" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.password") }}</Label>
+                      <PasswordInput v-model="form.password" class="col-span-3" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.database") }}</Label>
+                      <Input v-model="form.database" class="col-span-3" :placeholder="t('connection.databasePlaceholder')" />
+                    </div>
+                  </template>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.urlParams") }}</Label>
+                    <Input v-model="form.url_params" class="col-span-3" :placeholder="influxDbVersion === '2' ? 'precision=ns' : 'epoch=ms'" />
+                  </div>
+                </template>
+
+                <!-- Turso: simplified form (URL + Token) -->
+                <template v-else-if="form.db_type === 'turso'">
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.host") }}</Label>
+                    <Input v-model="form.host" class="col-span-3" placeholder="your-database.turso.io 或 libsql://your-database.turso.io" />
+                  </div>
+
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <span />
+                    <p class="col-span-3 text-xs text-muted-foreground">支持 libsql:// 或 https:// 协议，也可以只填主机名（自动使用 HTTPS）</p>
+                  </div>
+
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">Auth Token</Label>
+                    <PasswordInput v-model="form.password" class="col-span-3" placeholder="eyJhbGciOiJFZERTQSIsInR5cCI6IkpXVCJ9..." />
+                  </div>
+
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <span />
+                    <p class="col-span-3 text-xs text-muted-foreground">使用 <code class="px-1 py-0.5 rounded bg-muted text-xs">turso db tokens create &lt;database-name&gt;</code> 创建 token</p>
+                  </div>
+
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.urlParams") }}</Label>
+                    <Input v-model="form.url_params" class="col-span-3" placeholder="authToken=xxx（可选，优先使用上面的 Token 字段）" />
+                  </div>
+                </template>
+
+                <template v-else-if="form.db_type === 'cloudflare-d1'">
+                  <CloudflareD1ConnectionFields v-model:account-id="form.host" v-model:database-id="form.database" v-model:api-token="form.password" />
+                </template>
+
+                <!-- MySQL / PostgreSQL: host, port, user, password, database -->
+                <template v-else>
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.host") }}</Label>
+                    <Input v-model="form.host" class="col-span-2" />
+                    <Input v-model.number="form.port" type="number" class="col-span-1" />
+                  </div>
+
+                  <div v-if="form.driver_profile === 'gbase8s'" class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.gbaseServer") }}</Label>
+                    <Input v-model="form.gbase_server" class="col-span-3" placeholder="gbase01" />
+                  </div>
+
+                  <div v-if="form.db_type === 'informix'" class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.informixServer") }}</Label>
+                    <Input v-model="form.informix_server" class="col-span-3" placeholder="ol_informix1170" />
+                  </div>
+
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.user") }}</Label>
+                    <Input v-model="form.username" class="col-span-3" />
+                  </div>
+
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.password") }}</Label>
+                    <PasswordInput v-model="form.password" class="col-span-3" />
+                  </div>
+
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ databaseLabel }}</Label>
+                    <Input v-model="form.database" class="col-span-3" :placeholder="databasePlaceholder" />
+                  </div>
+
+                  <template v-if="form.db_type === 'hive'">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.hiveAuthMode") }}</Label>
+                      <div class="col-span-3 grid h-8 grid-cols-2 overflow-hidden rounded-md border border-input bg-muted/30 p-0.5">
+                        <button type="button" class="h-7 rounded-sm px-3 text-sm transition-colors" :class="hiveAuthMode === 'none' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'" :aria-pressed="hiveAuthMode === 'none'" @click="hiveAuthMode = 'none'">
+                          {{ t("connection.hiveAuthNone") }}
+                        </button>
+                        <button
+                          type="button"
+                          class="h-7 rounded-sm px-3 text-sm transition-colors"
+                          :class="hiveAuthMode === 'kerberos' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                          :aria-pressed="hiveAuthMode === 'kerberos'"
+                          @click="hiveAuthMode = 'kerberos'"
+                        >
+                          Kerberos
+                        </button>
+                      </div>
+                    </div>
+
+                    <template v-if="hiveAuthMode === 'kerberos'">
+                      <div class="grid grid-cols-4 items-center gap-4">
+                        <Label :class="connectionLabelSmallClass">{{ t("connection.hivePrincipal") }}</Label>
+                        <Input v-model="hivePrincipal" class="col-span-3" placeholder="hive/_HOST@EXAMPLE.COM" />
+                      </div>
+                      <div class="grid grid-cols-4 items-center gap-4">
+                        <Label :class="connectionLabelSmallClass">krb5.conf</Label>
+                        <div class="col-span-3 flex items-center gap-1">
+                          <Input v-model="hiveKrb5ConfPath" class="flex-1" placeholder="/etc/krb5.conf" />
+                          <Tooltip v-if="isDesktop">
+                            <TooltipTrigger as-child>
+                              <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseHiveKerberosFile('krb5')">
+                                <FolderOpen class="h-4 w-4" />
+                              </Button>
+                            </TooltipTrigger>
+                            <TooltipContent>{{ t("connection.hiveKrb5ConfBrowse") }}</TooltipContent>
+                          </Tooltip>
+                        </div>
+                      </div>
+                      <div class="grid grid-cols-4 items-center gap-4">
+                        <Label :class="connectionLabelSmallClass">JAAS</Label>
+                        <div class="col-span-3 flex items-center gap-1">
+                          <Input v-model="hiveJaasConfigPath" class="flex-1" placeholder="/etc/hive-jaas.conf" />
+                          <Tooltip v-if="isDesktop">
+                            <TooltipTrigger as-child>
+                              <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseHiveKerberosFile('jaas')">
+                                <FolderOpen class="h-4 w-4" />
+                              </Button>
+                            </TooltipTrigger>
+                            <TooltipContent>{{ t("connection.hiveJaasConfigBrowse") }}</TooltipContent>
+                          </Tooltip>
+                        </div>
+                      </div>
+                      <div class="grid grid-cols-4 items-center gap-4">
+                        <Label :class="connectionLabelSmallClass">{{ t("connection.hiveTicketCache") }}</Label>
+                        <label class="col-span-3 flex items-center gap-2 cursor-pointer">
+                          <input type="checkbox" v-model="hiveUseSubjectCredsOnlyFalse" class="mr-0" />
+                          <span class="text-xs text-muted-foreground">{{ t("connection.hiveTicketCacheFallback") }}</span>
+                        </label>
+                      </div>
+                      <div class="grid grid-cols-4 items-start gap-4">
+                        <Label :class="connectionLabelTopClass">{{ t("connection.hiveJvmOptions") }}</Label>
+                        <textarea
+                          v-model="hiveExtraJavaOptions"
+                          class="col-span-3 min-h-16 rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                          :placeholder="t('connection.hiveJvmOptionsPlaceholder')"
+                        />
+                      </div>
+                    </template>
+                  </template>
+
+                  <div v-if="form.db_type === 'oracle'" class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.mode") }}</Label>
+                    <div class="col-span-3 grid h-8 grid-cols-2 overflow-hidden rounded-md border border-input bg-muted/30 p-0.5">
+                      <button
+                        type="button"
+                        class="h-7 rounded-sm px-3 text-sm transition-colors"
+                        :class="form.oracle_connection_type !== 'sid' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                        :aria-pressed="form.oracle_connection_type !== 'sid'"
+                        @click="form.oracle_connection_type = 'service_name'"
+                      >
+                        {{ t("connection.serviceNameOnly") }}
+                      </button>
+                      <button
+                        type="button"
+                        class="h-7 rounded-sm px-3 text-sm transition-colors"
+                        :class="form.oracle_connection_type === 'sid' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                        :aria-pressed="form.oracle_connection_type === 'sid'"
+                        @click="form.oracle_connection_type = 'sid'"
+                      >
+                        SID
+                      </button>
+                    </div>
+                  </div>
+
+                  <div v-if="shouldShowAgentDriverInstallHint" class="grid grid-cols-4 items-center gap-4">
+                    <span />
+                    <p class="col-span-3 text-xs text-muted-foreground">
+                      {{ t("connection.driverInstallHintPrefix") }}<a class="underline cursor-pointer text-primary hover:text-primary/80" @click="emit('openDriverStore')">{{ t("toolbar.driverManager") }}</a
+                      >{{ t("connection.driverInstallHintSuffix") }}
+                    </p>
+                  </div>
+
+                  <div v-if="form.db_type === 'oracle'" class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">SYSDBA</Label>
+                    <label class="col-span-3 flex items-center gap-2 cursor-pointer">
+                      <input type="checkbox" v-model="form.sysdba" class="mr-0" :disabled="isOracleSysUser(form)" />
+                      <span class="text-xs text-muted-foreground">as SYSDBA</span>
+                    </label>
+                  </div>
+
+                  <div v-if="supportsGenericUrlParams" class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelClass">{{ t("connection.urlParams") }}</Label>
+                    <Input
+                      v-model="form.url_params"
+                      class="col-span-3"
+                      :placeholder="
+                        form.db_type === 'mysql'
+                          ? 'charset=utf8mb4'
+                          : form.db_type === 'saphana'
+                            ? 'databaseName=TENANT_DB'
+                            : form.db_type === 'clickhouse'
+                              ? 'secure=true'
+                              : form.db_type === 'bigquery'
+                                ? 'OAuthType=0;OAuthServiceAcctEmail=svc@project.iam.gserviceaccount.com;OAuthPvtKeyPath=/path/key.json'
+                                : form.db_type === 'informix'
+                                  ? 'CLIENT_LOCALE=en_US.utf8;DB_LOCALE=en_US.utf8'
+                                  : form.db_type === 'spark'
+                                    ? 'catalog=paimon_catalog'
+                                    : form.db_type === 'cassandra'
+                                      ? 'localdatacenter=dc1'
+                                      : 'sslmode=disable'
+                      "
+                    />
+                  </div>
+
+                  <template v-if="isPrestoSqlConnection">
+                    <div class="grid grid-cols-4 items-start gap-4">
+                      <Label :class="connectionLabelTopClass">{{ t("connection.jdbcDriverPaths") }}</Label>
+                      <div class="col-span-3 space-y-2">
+                        <Select v-if="jdbcDriverSelectItems.length > 0" :model-value="selectedJdbcDriverPath" @update:model-value="onJdbcDriverSelect">
+                          <SelectTrigger>
+                            <SelectValue :placeholder="t('connection.jdbcDriverSelectPlaceholder')" />
+                          </SelectTrigger>
+                          <SelectContent>
+                            <SelectItem v-for="driver in jdbcDriverSelectItems" :key="driver.id" :value="driver.id">
+                              {{ driver.label }}
+                            </SelectItem>
+                          </SelectContent>
+                        </Select>
+                        <div class="flex items-center justify-between gap-3 rounded-md border bg-muted/20 px-3 py-2">
+                          <div class="flex min-w-0 items-center gap-2">
+                            <div class="truncate text-xs font-medium">{{ t("connection.jdbcManualClasspath") }}</div>
+                            <Badge variant="outline" class="h-5 shrink-0 rounded-full px-2 text-[10px] font-medium">
+                              {{ t("connection.jdbcManualClasspathCount", { count: jdbcManualClasspathCount }) }}
+                            </Badge>
+                          </div>
+                          <Switch v-model="jdbcManualClasspathOpen" />
+                        </div>
+                        <div v-if="jdbcManualClasspathOpen" class="flex items-start gap-1">
+                          <textarea
+                            v-model="jdbcDriverPathsInput"
+                            class="flex min-h-12 w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+                            :placeholder="t('connection.jdbcDriverPathsPlaceholder')"
+                          />
+                          <Tooltip v-if="isDesktop">
+                            <TooltipTrigger as-child>
+                              <Button type="button" variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseJdbcDriverPaths">
+                                <FolderOpen class="h-4 w-4" />
+                              </Button>
+                            </TooltipTrigger>
+                            <TooltipContent>{{ t("connection.jdbcDriverBrowse") }}</TooltipContent>
+                          </Tooltip>
+                        </div>
+                      </div>
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelClass">{{ t("connection.jdbcDriverClass") }}</Label>
+                      <Input v-model="form.jdbc_driver_class" class="col-span-3" :placeholder="t('connection.jdbcDriverClassPlaceholder')" />
+                    </div>
+                    <div class="grid grid-cols-4 items-start gap-4">
+                      <span />
+                      <div class="col-span-3 space-y-2">
+                        <p class="text-xs text-muted-foreground">
+                          {{ t("connection.jdbcPluginHint") }}
+                        </p>
+                        <div class="flex flex-wrap gap-2">
+                          <Button type="button" variant="outline" size="sm" @click="emit('openDriverStore')">
+                            <FolderOpen class="h-3.5 w-3.5" />
+                            {{ t("toolbar.driverManager") }}
+                          </Button>
+                          <Button type="button" variant="outline" size="sm" @click="openExternalUrl('https://dbxio.com')">
+                            <ExternalLink class="h-3.5 w-3.5" />
+                            {{ t("connection.jdbcDocs") }}
+                          </Button>
+                        </div>
+                      </div>
+                    </div>
+                  </template>
+                </template>
+              </div>
+            </TabsContent>
+
+            <TabsContent v-if="supportsTlsToggle" value="tls" class="m-0">
+              <div class="connection-form-body grid gap-4 py-4 pr-2 max-h-[65vh] overflow-y-auto overflow-x-hidden">
+                <div v-if="!supportsPostgresTlsOptions && !supportsMysqlTlsOptions" class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">SSL/TLS</Label>
+                  <label class="col-span-3 flex items-center gap-2 cursor-pointer">
+                    <input type="checkbox" v-model="form.ssl" class="mr-0" />
+                    <span class="text-xs text-muted-foreground">{{ t("connection.sslEnable") }}</span>
+                  </label>
+                </div>
+
+                <div v-if="form.db_type === 'redis'" class="grid grid-cols-4 items-start gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("connection.redisTlsInsecure") }}</Label>
+                  <label class="col-span-3 flex items-start gap-2 cursor-pointer">
+                    <input type="checkbox" v-model="redisTlsInsecure" class="mr-0 mt-0.5" :disabled="!form.ssl" />
+                    <span class="text-xs leading-5 text-muted-foreground">
+                      {{ t("connection.redisTlsInsecureHint") }}
+                    </span>
+                  </label>
+                </div>
+
+                <template v-if="form.db_type === 'etcd'">
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <Label :class="connectionLabelSmallPaddedClass">
+                      <span class="inline-flex items-center justify-end gap-1">
+                        <ShieldCheck class="h-3.5 w-3.5" />
+                        {{ t("connection.caCertPath") }}
+                      </span>
+                    </Label>
+                    <div class="col-span-3 space-y-2">
+                      <div class="flex items-center gap-1">
+                        <Input v-model="form.ca_cert_path" class="flex-1" :placeholder="t('connection.etcdCaCertPlaceholder')" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseEtcdTlsFile('ca')">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.etcdCaCertBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                    </div>
+                  </div>
+
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <Label :class="connectionLabelSmallPaddedClass">
+                      <span class="inline-flex items-center justify-end gap-1">
+                        <KeyRound class="h-3.5 w-3.5" />
+                        {{ t("connection.etcdClientAuth") }}
+                      </span>
+                    </Label>
+                    <div class="col-span-3 grid gap-2">
+                      <div class="flex items-center gap-1">
+                        <Input v-model="form.client_cert_path" class="flex-1" :placeholder="t('connection.etcdClientCertPlaceholder')" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseEtcdTlsFile('cert')">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.etcdClientCertBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                      <div class="flex items-center gap-1">
+                        <Input v-model="form.client_key_path" class="flex-1" :placeholder="t('connection.etcdClientKeyPlaceholder')" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" @click="browseEtcdTlsFile('key')">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.etcdClientKeyBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                      <p class="text-[11px] leading-4 text-muted-foreground">
+                        {{ t("connection.etcdClientCertHint") }}
+                      </p>
+                    </div>
+                  </div>
+                </template>
+
+                <template v-if="supportsMysqlTlsOptions">
+                  <div v-if="supportsMysqlCleartextPasswordAuth" class="grid grid-cols-4 items-start gap-4">
+                    <Label :class="[connectionLabelSmallPaddedClass, 'min-w-0 break-words']">{{ t("connection.mysqlCleartextPasswordAuth") }}</Label>
+                    <div class="col-span-3 flex min-w-0 items-start justify-between gap-4">
+                      <p class="min-w-0 text-[11px] leading-4 text-muted-foreground break-words">
+                        {{ t("connection.mysqlCleartextPasswordAuthHint") }}
+                      </p>
+                      <Switch v-model="mysqlCleartextPasswordAuth" class="mt-0.5 shrink-0" />
+                    </div>
+                  </div>
+
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.mysqlTlsMode") }}</Label>
+                    <Select v-model="mysqlTlsMode">
+                      <SelectTrigger class="col-span-3 h-9">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="disabled">{{ t("connection.mysqlTlsModeDisabled") }}</SelectItem>
+                        <SelectItem value="preferred">{{ t("connection.mysqlTlsModePreferred") }}</SelectItem>
+                        <SelectItem value="required">{{ t("connection.mysqlTlsModeRequired") }}</SelectItem>
+                        <SelectItem value="verify_ca">{{ t("connection.mysqlTlsModeVerifyCa") }}</SelectItem>
+                        <SelectItem value="verify_identity">{{ t("connection.mysqlTlsModeVerifyIdentity") }}</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <Label :class="connectionLabelSmallPaddedClass">
+                      <span class="inline-flex items-center justify-end gap-1">
+                        <ShieldCheck class="h-3.5 w-3.5" />
+                        {{ t("connection.caCertPath") }}
+                      </span>
+                    </Label>
+                    <div class="col-span-3 space-y-2">
+                      <div class="flex items-center gap-1">
+                        <Input v-model="form.ca_cert_path" class="flex-1" :placeholder="t('connection.caCertPathPlaceholder')" :disabled="mysqlTlsMode === 'preferred' || mysqlTlsMode === 'disabled'" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" :disabled="mysqlTlsMode === 'preferred' || mysqlTlsMode === 'disabled'" @click="browseCaCertPath">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.caCertPathBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                      <p class="text-[11px] leading-4 text-muted-foreground">
+                        {{ t("connection.mysqlCaCertHint") }}
+                      </p>
+                    </div>
+                  </div>
+
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <Label :class="connectionLabelSmallPaddedClass">
+                      <span class="inline-flex items-center justify-end gap-1">
+                        <KeyRound class="h-3.5 w-3.5" />
+                        {{ t("connection.mysqlClientCert") }}
+                      </span>
+                    </Label>
+                    <div class="col-span-3 grid gap-2">
+                      <div class="flex items-center gap-1">
+                        <Input v-model="mysqlClientCertPath" class="flex-1" :placeholder="t('connection.mysqlClientCertPlaceholder')" :disabled="mysqlTlsMode === 'preferred' || mysqlTlsMode === 'disabled'" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" :disabled="mysqlTlsMode === 'preferred' || mysqlTlsMode === 'disabled'" @click="browseMysqlTlsFile('cert')">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.mysqlClientCertBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                      <div class="flex items-center gap-1">
+                        <Input v-model="mysqlClientKeyPath" class="flex-1" :placeholder="t('connection.mysqlClientKeyPlaceholder')" :disabled="mysqlTlsMode === 'preferred' || mysqlTlsMode === 'disabled'" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" :disabled="mysqlTlsMode === 'preferred' || mysqlTlsMode === 'disabled'" @click="browseMysqlTlsFile('key')">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.mysqlClientKeyBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                      <p class="text-[11px] leading-4 text-muted-foreground">
+                        {{ t("connection.mysqlClientCertHint") }}
+                      </p>
+                    </div>
+                  </div>
+                </template>
+
+                <template v-if="supportsPostgresTlsOptions">
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.postgresSslMode") }}</Label>
+                    <Select v-model="postgresTlsMode">
+                      <SelectTrigger class="col-span-3 h-9">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="disable">{{ t("connection.postgresSslModeDisable") }}</SelectItem>
+                        <SelectItem value="prefer">{{ t("connection.postgresSslModePrefer") }}</SelectItem>
+                        <SelectItem value="require">{{ t("connection.postgresSslModeRequire") }}</SelectItem>
+                        <SelectItem value="verify-ca">{{ t("connection.postgresSslModeVerifyCa") }}</SelectItem>
+                        <SelectItem value="verify-full">{{ t("connection.postgresSslModeVerifyFull") }}</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <Label :class="connectionLabelSmallPaddedClass">
+                      <span class="inline-flex items-center justify-end gap-1">
+                        <ShieldCheck class="h-3.5 w-3.5" />
+                        {{ t("connection.postgresServerCert") }}
+                      </span>
+                    </Label>
+                    <div class="col-span-3 space-y-2">
+                      <div class="flex items-center gap-1">
+                        <Input v-model="postgresRootCertPath" class="flex-1" :placeholder="t('connection.postgresRootCertPlaceholder')" :disabled="postgresTlsMode === 'disable'" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" :disabled="postgresTlsMode === 'disable'" @click="browsePostgresTlsFile('root')">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.postgresRootCertBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                      <p class="text-[11px] leading-4 text-muted-foreground">
+                        {{ t("connection.postgresRootCertHint") }}
+                      </p>
+                    </div>
+                  </div>
+
+                  <div class="grid grid-cols-4 items-start gap-4">
+                    <Label :class="connectionLabelSmallPaddedClass">
+                      <span class="inline-flex items-center justify-end gap-1">
+                        <KeyRound class="h-3.5 w-3.5" />
+                        {{ t("connection.postgresClientCert") }}
+                      </span>
+                    </Label>
+                    <div class="col-span-3 grid gap-2">
+                      <div class="flex items-center gap-1">
+                        <Input v-model="postgresClientCertPath" class="flex-1" :placeholder="t('connection.postgresClientCertPlaceholder')" :disabled="postgresTlsMode === 'disable'" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" :disabled="postgresTlsMode === 'disable'" @click="browsePostgresTlsFile('cert')">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.postgresClientCertBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                      <div class="flex items-center gap-1">
+                        <Input v-model="postgresClientKeyPath" class="flex-1" :placeholder="t('connection.postgresClientKeyPlaceholder')" :disabled="postgresTlsMode === 'disable'" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" :disabled="postgresTlsMode === 'disable'" @click="browsePostgresTlsFile('key')">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.postgresClientKeyBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                      <p class="text-[11px] leading-4 text-muted-foreground">
+                        {{ t("connection.postgresClientCertHint") }}
+                      </p>
+                    </div>
+                  </div>
+                </template>
+
+                <div v-if="supportsCaCertificatePath" class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("connection.caCertPath") }}</Label>
+                  <div class="col-span-3 flex items-center gap-1">
+                    <Input v-model="form.ca_cert_path" class="flex-1" :placeholder="t('connection.caCertPathPlaceholder')" :disabled="!form.ssl" />
+                    <Tooltip v-if="isDesktop">
+                      <TooltipTrigger as-child>
+                        <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" :disabled="!form.ssl" @click="browseCaCertPath">
+                          <FolderOpen class="h-4 w-4" />
+                        </Button>
+                      </TooltipTrigger>
+                      <TooltipContent>{{ t("connection.caCertPathBrowse") }}</TooltipContent>
+                    </Tooltip>
+                  </div>
+                </div>
+              </div>
+            </TabsContent>
+
+            <TabsContent value="advanced" class="m-0">
+              <div class="connection-form-body grid gap-4 py-4 pr-2 max-h-[65vh] overflow-y-auto">
+                <div class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("connection.connectTimeout") }}</Label>
+                  <Input v-model.number="form.connect_timeout_secs" type="number" min="1" max="300" step="1" class="col-span-3" />
+                </div>
+                <div class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("connection.queryTimeout") }}</Label>
+                  <Input v-model.number="form.query_timeout_secs" type="number" min="0" max="300" step="1" class="col-span-3" />
+                </div>
+                <div v-show="form.db_type === 'mongodb'" class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("connection.idleTimeout") }}</Label>
+                  <Input v-model.number="form.idle_timeout_secs" type="number" min="0" max="600" step="1" class="col-span-3" />
+                </div>
+                <div class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("connection.keepaliveInterval") }}</Label>
+                  <div class="col-span-3 flex items-center gap-2">
+                    <Switch v-model="keepaliveEnabled" />
+                    <Input v-model.number="form.keepalive_interval_secs" type="number" min="1" max="3600" step="1" class="flex-1" :disabled="!keepaliveEnabled" />
+                  </div>
+                </div>
+                <div class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("connection.readOnly") }}</Label>
+                  <label class="col-span-3 flex items-center gap-2 cursor-pointer">
+                    <input type="checkbox" v-model="form.read_only" class="mr-0" />
+                    <span class="text-xs text-muted-foreground">{{ t("connection.readOnlyHint") }}</span>
+                  </label>
+                </div>
+                <div class="grid grid-cols-4 items-start gap-4 rounded-[6px] border border-red-500/25 bg-red-500/[0.035] px-3 py-2.5">
+                  <Label :class="[connectionLabelSmallClass, 'pt-0.5 text-red-700 dark:text-red-300']">
+                    <span class="inline-flex items-center justify-end gap-1"><ShieldAlert class="h-3.5 w-3.5" />PROD</span>
+                  </Label>
+                  <div class="col-span-3 grid gap-2">
+                    <div class="flex items-center justify-between gap-3">
+                      <Label class="text-sm font-medium">{{ t("production.enable") }}</Label>
+                      <Switch :model-value="productionProtectionEnabled" @update:model-value="setProductionProtectionEnabled" />
+                    </div>
+                    <p v-if="!productionProtectionEnabled" class="text-xs leading-5 text-muted-foreground">{{ t("production.disabledDescription") }}</p>
+                    <template v-else>
+                      <Label class="text-xs font-medium">{{ t("production.scope") }}</Label>
+                      <Tabs v-model="productionScope" class="w-full">
+                        <TabsList class="grid h-8 w-full grid-cols-2">
+                          <TabsTrigger value="connection" class="text-xs">{{ t("production.allDatabases") }}</TabsTrigger>
+                          <TabsTrigger value="databases" class="text-xs" :disabled="!canSelectProductionDatabases" :title="canSelectProductionDatabases ? undefined : t('production.singleDatabaseScopeHint')">{{ t("production.selectedDatabases") }}</TabsTrigger>
+                        </TabsList>
+                      </Tabs>
+                      <p class="text-xs leading-5 text-muted-foreground">{{ productionScope === "connection" ? t("production.connectionDescription") : t("production.databaseDescription") }}</p>
+                      <div v-if="productionScope === 'databases'" class="grid gap-1.5">
+                        <div class="flex items-center justify-between gap-3">
+                          <Label class="text-xs font-medium">{{ t("production.databases") }}</Label>
+                          <span class="text-xs text-muted-foreground">{{ productionDatabaseSummary }}</span>
+                        </div>
+                        <Button type="button" variant="outline" size="sm" class="justify-start" :disabled="isTesting || isSaving || isLoadingProductionDatabases || !hasRequiredConnectionTarget" @click="openProductionDatabasesPicker">
+                          <Loader2 v-if="isLoadingProductionDatabases" class="mr-1.5 h-4 w-4 animate-spin" />
+                          <ListFilter v-else class="mr-1.5 h-4 w-4" />
+                          {{ t("production.selectDatabases") }}
+                        </Button>
+                      </div>
+                    </template>
+                  </div>
+                </div>
+                <div v-show="form.db_type === 'sqlserver'" class="grid grid-cols-4 items-start gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("connection.sqlServerLegacyCompatibilityMode") }}</Label>
+                  <div class="col-span-3 flex flex-col gap-1">
+                    <label class="flex h-5 cursor-pointer items-center gap-2">
+                      <input type="checkbox" :checked="sqlServerLegacyCompatibilityModeEnabled" :disabled="agentInstallRunning" class="mr-0" @change="onSqlServerLegacyCompatibilityModeChange" />
+                      <span class="text-xs text-foreground">{{ t("connection.sqlServerLegacyCompatibilityModeEnable") }}</span>
+                    </label>
+                    <p class="m-0 whitespace-pre-line text-xs leading-5 text-muted-foreground">
+                      {{ t("connection.sqlServerLegacyCompatibilityModeHint") }}
+                    </p>
+                  </div>
+                </div>
+                <div v-show="form.db_type === 'redis'" class="grid grid-cols-4 items-center gap-4">
+                  <Label :class="connectionLabelSmallClass">{{ t("settings.redisScanPageSize") }}</Label>
+                  <div class="col-span-3 flex flex-col gap-1">
+                    <Select :model-value="String(form.redis_scan_page_size ?? REDIS_SCAN_PAGE_SIZE_DEFAULT)" @update:model-value="form.redis_scan_page_size = Number($event)">
+                      <SelectTrigger>
+                        <SelectValue :placeholder="t('settings.redisScanPageSize')" />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem v-for="size in REDIS_SCAN_PAGE_SIZE_OPTIONS" :key="size" :value="String(size)">
+                          {{ t("settings.redisScanPageSizeOption", { count: size }) }}
+                        </SelectItem>
+                      </SelectContent>
+                    </Select>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.redisScanPageSizeDescription") }}</p>
+                  </div>
+                </div>
+              </div>
+            </TabsContent>
+
+            <TabsContent v-if="canUseTransportLayers" value="transport" class="m-0">
+              <div class="connection-form-body grid gap-4 py-4 pr-2 max-h-[65vh] overflow-y-auto overflow-x-hidden">
+                <div class="connection-label-wide-grid grid min-w-0 grid-cols-4 items-start gap-4">
+                  <Label :class="connectionLabelSmallPaddedClass">{{ t("connection.sshHops") }}</Label>
+                  <div class="col-span-3 grid min-w-0 gap-3">
+                    <div class="flex min-w-0 flex-wrap items-center gap-1 text-[11px] text-muted-foreground">
+                      <template v-for="(segment, index) in transportPathSegments" :key="`${segment}-${index}`">
+                        <span class="inline-block max-w-full truncate rounded border bg-muted/40 px-2 py-1">{{ segment }}</span>
+                        <ChevronRight v-if="index < transportPathSegments.length - 1" class="h-3 w-3" />
+                      </template>
+                    </div>
+                    <div class="grid min-w-0 gap-2">
+                      <button
+                        v-for="(hop, index) in transportLayers"
+                        :key="hop.id"
+                        type="button"
+                        draggable="true"
+                        class="flex min-h-10 items-center gap-2 rounded-md border px-2 text-left text-xs transition-colors"
+                        :class="hop.id === selectedTransportLayer?.id ? 'border-primary bg-primary/5' : 'hover:bg-muted/50'"
+                        @click="selectedTransportLayerId = hop.id"
+                        @dragstart="draggedTransportLayerId = hop.id"
+                        @dragover.prevent
+                        @drop="dropTransportLayer(hop.id)"
+                      >
+                        <GripVertical class="h-4 w-4 shrink-0 text-muted-foreground" />
+                        <span class="w-5 shrink-0 text-muted-foreground">{{ index + 1 }}</span>
+                        <input v-model="hop.enabled" type="checkbox" class="mr-0" @click.stop />
+                        <span class="min-w-0 flex-1 truncate">
+                          {{ transportLayerDisplayName(hop, index) }}
+                        </span>
+                        <Tooltip>
+                          <TooltipTrigger as-child>
+                            <Button variant="ghost" size="icon" class="h-7 w-7" :disabled="index === 0" @click.stop="moveTransportLayer(hop.id, -1)">
+                              <ArrowUp class="h-3.5 w-3.5" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.sshHopMoveUp") }}</TooltipContent>
+                        </Tooltip>
+                        <Tooltip>
+                          <TooltipTrigger as-child>
+                            <Button variant="ghost" size="icon" class="h-7 w-7" :disabled="index === transportLayers.length - 1" @click.stop="moveTransportLayer(hop.id, 1)">
+                              <ArrowDown class="h-3.5 w-3.5" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.sshHopMoveDown") }}</TooltipContent>
+                        </Tooltip>
+                      </button>
+                    </div>
+                    <div class="flex min-w-0 flex-wrap items-center gap-2">
+                      <Button type="button" variant="outline" size="sm" @click="addSshTunnel">
+                        <Plus class="mr-1.5 h-3.5 w-3.5" />
+                        {{ t("connection.sshHopAdd") }}
+                      </Button>
+                      <Button type="button" variant="outline" size="sm" @click="addProxyTunnel">
+                        <Plus class="mr-1.5 h-3.5 w-3.5" />
+                        {{ t("connection.proxy") }}
+                      </Button>
+                      <Button type="button" variant="outline" size="sm" @click="addHttpTunnel">
+                        <Plus class="mr-1.5 h-3.5 w-3.5" />
+                        {{ t("connection.httpTunnelAdd") }}
+                      </Button>
+                      <Button v-if="selectedTransportLayer" type="button" variant="outline" size="sm" @click="duplicateTransportLayer(selectedTransportLayer)">
+                        <Copy class="mr-1.5 h-3.5 w-3.5" />
+                        {{ t("connection.sshHopDuplicate") }}
+                      </Button>
+                      <Button v-if="selectedTransportLayer" type="button" variant="outline" size="sm" @click="removeTransportLayer(selectedTransportLayer.id)">
+                        <Trash2 class="mr-1.5 h-3.5 w-3.5" />
+                        {{ t("connection.sshHopDelete") }}
+                      </Button>
+                    </div>
+                  </div>
+                </div>
+
+                <template v-if="selectedTransportLayer">
+                  <div class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.sshHopName") }}</Label>
+                    <Input v-model="selectedTransportLayer.name" class="col-span-3" :placeholder="t('connection.sshHopNamePlaceholder')" />
+                  </div>
+                  <div v-if="tunnelProfiles.length || selectedLayerProfileId" class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">{{ t("connection.tunnelProfile") }}</Label>
+                    <div class="col-span-3 flex min-w-0 items-center gap-2">
+                      <Select :model-value="selectedLayerProfileId || 'custom'" @update:model-value="applyTunnelProfileSelection">
+                        <SelectTrigger class="h-9 min-w-0 flex-1">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="custom">{{ t("connection.tunnelProfileCustom") }}</SelectItem>
+                          <SelectItem v-for="profile in tunnelProfiles" :key="profile.id" :value="profile.id">{{ tunnelProfileOptionLabel(profile) }}</SelectItem>
+                        </SelectContent>
+                      </Select>
+                      <Button type="button" variant="outline" size="sm" class="shrink-0" @click="emit('openTunnelProfileSettings')">
+                        {{ t("connection.tunnelProfileManage") }}
+                      </Button>
+                    </div>
+                  </div>
+                  <div v-if="selectedLayerProfileId" class="grid grid-cols-4 items-start gap-4">
+                    <span />
+                    <div class="col-span-3 grid min-w-0 gap-1 rounded-md border bg-muted/30 px-3 py-2 text-xs text-muted-foreground">
+                      <template v-if="selectedLayerProfile">
+                        <span class="truncate font-medium text-foreground">{{ selectedLayerProfile.name || tunnelProfileSummary(selectedLayerProfile) }}</span>
+                        <span v-if="selectedLayerProfile.name && tunnelProfileSummary(selectedLayerProfile)" class="truncate">{{ tunnelProfileSummary(selectedLayerProfile) }}</span>
+                        <span>{{ t("connection.tunnelProfileManaged") }}</span>
+                      </template>
+                      <span v-else class="text-red-500">{{ t("connection.tunnelProfileMissing") }}</span>
+                    </div>
+                  </div>
+                  <div v-if="!selectedLayerProfileId" class="grid grid-cols-4 items-center gap-4">
+                    <Label :class="connectionLabelSmallClass">Type</Label>
+                    <Select :model-value="selectedTransportLayer.type" @update:model-value="(value: any) => changeSelectedTransportLayerType(value)">
+                      <SelectTrigger class="col-span-3 h-9">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="ssh">SSH</SelectItem>
+                        <SelectItem value="proxy">Proxy</SelectItem>
+                        <SelectItem value="http_tunnel">{{ t("connection.httpTunnel") }}</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+                  <template v-if="selectedSshLayer && !selectedLayerProfileId">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.sshHost") }}</Label>
+                      <Input v-model="selectedSshLayer.host" class="col-span-2" list="ssh-config-host-aliases" :placeholder="t('connection.sshHostPlaceholder')" :disabled="selectedSshLayer.enabled === false" @change="applySshConfigHostAliasPrefill(selectedSshLayer!)" />
+                      <datalist id="ssh-config-host-aliases">
+                        <option v-for="alias in sshConfigHostAliases" :key="alias" :value="alias" />
+                      </datalist>
+                      <Input v-model.number="selectedSshLayer.port" type="number" min="1" max="65535" class="col-span-1" :disabled="selectedSshLayer.enabled === false" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.sshUser") }}</Label>
+                      <Input v-model="selectedSshLayer.user" class="col-span-3" placeholder="root" :disabled="selectedSshLayer.enabled === false" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.sshAuthMethod") }}</Label>
+                      <Select :model-value="selectedSshLayer.auth_method || 'password'" :disabled="selectedSshLayer.enabled === false" @update:model-value="updateSelectedSshAuthMethod">
+                        <SelectTrigger class="col-span-3 h-9">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="password">{{ t("connection.sshAuthMethodPassword") }}</SelectItem>
+                          <SelectItem value="key">{{ t("connection.sshAuthMethodKey") }}</SelectItem>
+                          <SelectItem value="none">{{ t("connection.sshAuthMethodNone") }}</SelectItem>
+                          <SelectItem v-if="isLegacySshAgentMethod(selectedSshLayer)" value="agent" disabled>{{ t("connection.sshAuthMethodAgentLegacy") }}</SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                    <div v-if="selectedSshLayer.auth_method === 'key'" class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.sshKeyPath") }}</Label>
+                      <div class="col-span-3 flex items-center gap-1">
+                        <Input v-model="selectedSshLayer.key_path" class="flex-1" placeholder="~/.ssh/id_rsa" :disabled="selectedSshLayer.enabled === false" />
+                        <Tooltip v-if="isDesktop">
+                          <TooltipTrigger as-child>
+                            <Button variant="outline" size="icon" class="h-9 w-9 shrink-0" :disabled="selectedSshLayer.enabled === false" @click="browseSshKeyPath(selectedSshLayer)">
+                              <FolderOpen class="h-4 w-4" />
+                            </Button>
+                          </TooltipTrigger>
+                          <TooltipContent>{{ t("connection.sshKeyPathBrowse") }}</TooltipContent>
+                        </Tooltip>
+                      </div>
+                    </div>
+                    <div v-if="selectedSshLayer.auth_method === 'key'" class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.sshKeyPassphrase") }}</Label>
+                      <PasswordInput v-model="selectedSshLayer.key_passphrase" class="col-span-3" :placeholder="t('connection.sshKeyPassphrasePlaceholder')" :disabled="selectedSshLayer.enabled === false" />
+                    </div>
+                    <div v-if="!selectedSshLayer.auth_method || selectedSshLayer.auth_method === 'password'" class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.sshPassword") }}</Label>
+                      <PasswordInput v-model="selectedSshLayer.password" class="col-span-3" :placeholder="t('connection.sshPasswordPlaceholder')" :disabled="selectedSshLayer.enabled === false" />
+                    </div>
+                    <div v-if="selectedSshLayer.auth_method === 'none'" class="grid grid-cols-4 items-center gap-4">
+                      <span />
+                      <p class="col-span-3 text-xs text-muted-foreground">{{ t("connection.sshAuthMethodNoneHint") }}</p>
+                    </div>
+                    <template v-if="isLegacySshAgentMethod(selectedSshLayer)">
+                      <div class="grid grid-cols-4 items-center gap-4">
+                        <span />
+                        <label class="col-span-3 flex items-center gap-2 cursor-pointer">
+                          <input type="checkbox" v-model="selectedSshLayer.use_ssh_agent" class="mr-0" :disabled="selectedSshLayer.enabled === false" />
+                          <span class="text-xs text-muted-foreground">{{ t("connection.sshUseAgent") }}</span>
+                        </label>
+                      </div>
+                      <div v-if="selectedSshLayer.use_ssh_agent" class="grid grid-cols-4 items-center gap-4">
+                        <Label :class="connectionLabelSmallClass">{{ t("connection.sshAgentSockPath") }}</Label>
+                        <Input v-model="selectedSshLayer.ssh_agent_sock_path" class="col-span-3" :placeholder="t('connection.sshAgentSockPathPlaceholder')" :disabled="selectedSshLayer.enabled === false" />
+                      </div>
+                    </template>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <span />
+                      <label class="col-span-3 flex items-center gap-2 cursor-pointer">
+                        <input type="checkbox" v-model="selectedSshLayer.expose_lan" class="mr-0" :disabled="selectedSshLayer.enabled === false" />
+                        <span class="text-xs text-muted-foreground">{{ t("connection.sshExposeLan") }}</span>
+                      </label>
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.sshConnectTimeout") }}</Label>
+                      <Input v-model.number="selectedSshLayer.connect_timeout_secs" type="number" min="1" max="300" step="1" class="col-span-3" :disabled="selectedSshLayer.enabled === false" />
+                    </div>
+                  </template>
+                  <template v-else-if="selectedProxyLayer && !selectedLayerProfileId">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.proxyType") }}</Label>
+                      <Select :model-value="selectedProxyLayer.proxy_type || 'socks5'" :disabled="selectedProxyLayer.enabled === false" @update:model-value="updateSelectedProxyType">
+                        <SelectTrigger class="col-span-3 h-9">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="socks5">SOCKS5</SelectItem>
+                          <SelectItem value="http">HTTP CONNECT</SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.proxyHost") }}</Label>
+                      <Input v-model="selectedProxyLayer.host" class="col-span-2" placeholder="127.0.0.1" :disabled="selectedProxyLayer.enabled === false" />
+                      <Input v-model.number="selectedProxyLayer.port" type="number" class="col-span-1" :disabled="selectedProxyLayer.enabled === false" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.proxyUsername") }}</Label>
+                      <Input v-model="selectedProxyLayer.username" class="col-span-3" :placeholder="t('connection.proxyUsernamePlaceholder')" :disabled="selectedProxyLayer.enabled === false" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.proxyPassword") }}</Label>
+                      <PasswordInput v-model="selectedProxyLayer.password" class="col-span-3" :placeholder="t('connection.proxyPasswordPlaceholder')" :disabled="selectedProxyLayer.enabled === false" />
+                    </div>
+                  </template>
+                  <template v-else-if="selectedHttpTunnelLayer && !selectedLayerProfileId">
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.httpTunnelUrl") }}</Label>
+                      <Input v-model="selectedHttpTunnelLayer.url" class="col-span-3" placeholder="https://dbx.example.com/dbx_tunnel.php" :disabled="selectedHttpTunnelLayer.enabled === false" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.httpTunnelToken") }}</Label>
+                      <PasswordInput v-model="selectedHttpTunnelLayer.token" class="col-span-3" :placeholder="t('connection.httpTunnelTokenPlaceholder')" :disabled="selectedHttpTunnelLayer.enabled === false" />
+                    </div>
+                    <div class="grid grid-cols-4 items-center gap-4">
+                      <Label :class="connectionLabelSmallClass">{{ t("connection.httpTunnelConnectTimeout") }}</Label>
+                      <Input v-model.number="selectedHttpTunnelLayer.connect_timeout_secs" type="number" min="1" max="300" step="1" class="col-span-3" :disabled="selectedHttpTunnelLayer.enabled === false" />
+                    </div>
+                  </template>
+                </template>
+              </div>
+            </TabsContent>
+          </Tabs>
+        </div>
+
+        <DialogFooter class="flex min-w-0 items-center gap-2 sm:flex-nowrap">
+          <div class="mr-auto flex min-w-0 flex-1 basis-0 items-center gap-2 overflow-hidden">
+            <Button v-if="!editingId" variant="outline" class="shrink-0" :disabled="isSaving" @click="backToDatabasePicker">
+              <ArrowLeft class="h-4 w-4" />
+              {{ t("connection.back") }}
+            </Button>
+            <template v-if="testResult">
+              <span class="block min-w-0 flex-1 basis-0 truncate text-xs" :class="testResult.ok ? 'text-green-600' : 'text-red-600'" :title="testResultMessage" role="status" aria-live="polite">
+                {{ testResultMessage }}
+              </span>
+              <Button variant="ghost" size="icon-xs" class="h-5 w-5 shrink-0" :title="t('connection.copyTestResult')" :aria-label="t('connection.copyTestResult')" @click="copyTestResult">
+                <Copy class="h-3 w-3" />
+              </Button>
+            </template>
+          </div>
+          <Button v-if="canChooseVisibleDatabases" variant="outline" class="shrink-0" :disabled="isTesting || isSaving || isLoadingVisibleDatabases || !hasRequiredConnectionTarget" @click="openVisibleDatabasesPicker">
+            <Loader2 v-if="isLoadingVisibleDatabases" class="mr-1.5 h-4 w-4 animate-spin" />
+            <ListFilter v-else class="mr-1.5 h-4 w-4" />
+            {{ hasVisibleObjectFilter ? visibleObjectSummary : visibleFilterUsesSchemas ? t("contextMenu.configureVisibleObjects") : t("contextMenu.selectVisibleDatabases") }}
+          </Button>
+          <Button v-if="canChooseVisibleSchemas && !visibleFilterUsesSchemas && hasVisibleSchemaFilter" variant="outline" class="shrink-0" :disabled="isTesting || isSaving || isLoadingVisibleSchemas || !hasRequiredConnectionTarget" @click="openVisibleSchemasPicker">
+            <Loader2 v-if="isLoadingVisibleSchemas" class="mr-1.5 h-4 w-4 animate-spin" />
+            <ListFilter v-else class="mr-1.5 h-4 w-4" />
+            {{ visibleSchemaSummary }}
+          </Button>
+          <Button variant="outline" class="shrink-0" :disabled="isTesting || isSaving" @click="testConnection">
+            {{ isTesting ? t("connection.testing") : t("connection.test") }}
+          </Button>
+          <Button class="shrink-0" @click="save" :disabled="isSaving || !hasRequiredConnectionTarget">
+            {{ isSaving ? t("common.loading") : editingId || isJdbcConnection ? t("connection.save") : t("connection.saveAndConnect") }}
+          </Button>
+        </DialogFooter>
+      </template>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog :open="showAgentInstallDialog" @update:open="setAgentInstallDialogOpen">
+    <DialogContent class="sm:max-w-[520px]" @interact-outside.prevent @escape-key-down.prevent>
+      <DialogHeader>
+        <DialogTitle>{{ agentInstallError ? "驱动安装失败" : "正在安装驱动" }}</DialogTitle>
+      </DialogHeader>
+
+      <div class="space-y-4">
+        <div class="rounded-lg border bg-muted/20 p-4">
+          <div class="flex items-center justify-between gap-3">
+            <div class="min-w-0">
+              <div class="truncate text-sm font-medium">{{ agentInstallLabel || agentInstallDriverKey }}</div>
+              <div class="mt-1 text-xs text-muted-foreground">{{ agentInstallProgressLabel }}</div>
+            </div>
+            <Loader2 v-if="agentInstallRunning && !agentInstallError" class="h-4 w-4 shrink-0 animate-spin text-muted-foreground" />
+          </div>
+          <div v-if="!agentInstallError" class="mt-4 h-2 overflow-hidden rounded-full bg-muted">
+            <div class="h-full rounded-full bg-primary transition-all" :class="{ 'animate-pulse': agentInstallPercent === null }" :style="{ width: `${agentInstallPercent ?? 35}%` }" />
+          </div>
+        </div>
+
+        <div v-if="agentInstallError" class="space-y-2">
+          <div class="text-sm font-medium text-destructive">完整错误</div>
+          <pre class="max-h-56 overflow-auto whitespace-pre-wrap break-words rounded-md border bg-muted/30 p-3 text-xs leading-5 text-destructive">{{ agentInstallError }}</pre>
+        </div>
+      </div>
+
+      <DialogFooter class="gap-2">
+        <Button v-if="agentInstallError" variant="outline" @click="copyAgentInstallError">
+          <Copy class="mr-1.5 h-3.5 w-3.5" />
+          复制错误
+        </Button>
+        <Button :disabled="!canCloseAgentInstallDialog" @click="showAgentInstallDialog = false">
+          {{ agentInstallError ? "关闭" : "安装中..." }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showConnectionErrorDialog">
+    <DialogContent class="sm:max-w-[560px]">
+      <DialogHeader>
+        <DialogTitle>连接失败</DialogTitle>
+      </DialogHeader>
+
+      <div class="space-y-2">
+        <div class="text-sm text-muted-foreground">完整错误信息</div>
+        <pre class="max-h-72 overflow-auto whitespace-pre-wrap break-words rounded-md border bg-muted/30 p-3 text-xs leading-5 text-destructive">{{ connectionErrorDetail }}</pre>
+      </div>
+
+      <DialogFooter class="gap-2">
+        <Button variant="outline" @click="copyConnectionErrorDetail">
+          <Copy class="mr-1.5 h-3.5 w-3.5" />
+          复制错误
+        </Button>
+        <Button @click="showConnectionErrorDialog = false">关闭</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showVisibleDatabasesDialog">
+    <DialogContent class="sm:max-w-[460px]">
+      <DialogHeader>
+        <DialogTitle>{{ t(visibleObjectTitleKey) }}</DialogTitle>
+        <p class="text-sm text-muted-foreground">
+          {{ t(visibleObjectDescriptionKey, { connection: form.name || selectedProfile().label }) }}
+        </p>
+      </DialogHeader>
+
+      <div class="flex items-center gap-2 rounded-md border bg-background px-2">
+        <Search class="h-4 w-4 shrink-0 text-muted-foreground" />
+        <Input v-model="visibleDatabaseSearchText" :placeholder="t(visibleObjectSearchPlaceholderKey)" class="h-8 border-0 px-0 shadow-none focus-visible:ring-0" :disabled="isLoadingVisibleDatabases || !!visibleDatabaseError" />
+      </div>
+
+      <div class="flex items-center justify-between text-xs text-muted-foreground">
+        <span>
+          {{
+            t(visibleObjectSelectedCountKey, {
+              selected: visibleDatabaseSelectedCount,
+              total: visibleDatabaseTotalCount,
+            })
+          }}
+        </span>
+        <div class="flex items-center gap-2">
+          <button class="hover:text-foreground disabled:opacity-50" :disabled="isLoadingVisibleDatabases" @click="selectAllVisibleDatabases">
+            {{ t("visibleDatabases.selectAll") }}
+          </button>
+          <button class="hover:text-foreground disabled:opacity-50" :disabled="isLoadingVisibleDatabases" @click="clearVisibleDatabaseSelection">
+            {{ t("visibleDatabases.clear") }}
+          </button>
+          <button class="hover:text-foreground disabled:opacity-50" :disabled="isLoadingVisibleDatabases" @click="showAllVisibleDatabases">
+            {{ t("visibleDatabases.showAll") }}
+          </button>
+        </div>
+      </div>
+      <p v-if="!isLoadingVisibleDatabases && !visibleDatabaseError && !visibleDatabaseCanSave" class="text-xs text-destructive">
+        {{ t(visibleObjectEmptySelectionKey) }}
+      </p>
+
+      <label v-if="visibleDatabaseHasSystemDatabases" class="flex h-8 items-center gap-2 rounded-md px-1 text-xs text-muted-foreground">
+        <input v-model="visibleDatabaseShowSystem" type="checkbox" class="h-3.5 w-3.5 accent-primary" :disabled="isLoadingVisibleDatabases || !!visibleDatabaseError" />
+        <span>{{ t("visibleDatabases.showSystemDatabases") }}</span>
+      </label>
+
+      <div class="h-72 overflow-y-auto rounded-md border bg-background/50 p-1">
+        <div v-if="isLoadingVisibleDatabases" class="flex h-full items-center justify-center gap-2 text-sm text-muted-foreground">
+          <Loader2 class="h-4 w-4 animate-spin" />
+          {{ t("common.loading") }}
+        </div>
+        <div v-else-if="visibleDatabaseError" class="p-3 text-sm text-destructive">
+          {{ t(visibleObjectLoadFailedKey, { message: visibleDatabaseError }) }}
+        </div>
+        <div v-else-if="!filteredVisibleDatabaseNames.length" class="p-3 text-sm text-muted-foreground">
+          {{ t("grid.noSearchResults") }}
+        </div>
+        <template v-else>
+          <button
+            v-for="database in filteredVisibleDatabaseNames"
+            :key="database"
+            type="button"
+            class="flex h-8 w-full min-w-0 items-center gap-2 rounded-sm px-2 text-left text-sm hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground focus-visible:outline-none"
+            @click="toggleVisibleDatabase(database)"
+          >
+            <CheckSquare v-if="visibleDatabaseSelection.has(database)" class="h-4 w-4 shrink-0 text-primary" />
+            <Square v-else class="h-4 w-4 shrink-0 text-muted-foreground" />
+            <span class="truncate">{{ database }}</span>
+          </button>
+        </template>
+      </div>
+
+      <DialogFooter>
+        <Button variant="outline" @click="showVisibleDatabasesDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="isLoadingVisibleDatabases || !!visibleDatabaseError || !visibleDatabaseCanSave" @click="saveVisibleDatabaseSelection">
+          {{ t(visibleObjectSaveKey) }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showProductionDatabasesDialog">
+    <DialogContent class="sm:max-w-[460px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("production.databasePickerTitle") }}</DialogTitle>
+        <p class="text-sm text-muted-foreground">
+          {{ t("production.databasePickerDescription", { connection: form.name || selectedProfile().label }) }}
+        </p>
+      </DialogHeader>
+
+      <div class="flex items-center gap-2 rounded-md border bg-background px-2">
+        <Search class="h-4 w-4 shrink-0 text-muted-foreground" />
+        <Input v-model="productionDatabaseSearchText" :placeholder="t('production.databaseSearchPlaceholder')" class="h-8 border-0 px-0 shadow-none focus-visible:ring-0" :disabled="isLoadingProductionDatabases || !!productionDatabaseError" />
+      </div>
+
+      <div class="flex items-center justify-between text-xs text-muted-foreground">
+        <span>{{ t("production.databasesSelectedCount", { selected: productionDatabaseSelectedCount, total: productionDatabaseNames.length }) }}</span>
+        <div class="flex items-center gap-2">
+          <button class="hover:text-foreground disabled:opacity-50" :disabled="isLoadingProductionDatabases || !!productionDatabaseError" @click="selectAllProductionDatabases">
+            {{ t("visibleDatabases.selectAll") }}
+          </button>
+          <button class="hover:text-foreground disabled:opacity-50" :disabled="isLoadingProductionDatabases || !!productionDatabaseError" @click="clearProductionDatabaseSelection">
+            {{ t("visibleDatabases.clear") }}
+          </button>
+        </div>
+      </div>
+      <p v-if="!isLoadingProductionDatabases && !productionDatabaseError && !productionDatabaseCanSave" class="text-xs text-destructive">
+        {{ t("production.databaseSelectionRequired") }}
+      </p>
+
+      <div class="h-72 overflow-y-auto rounded-md border bg-background/50 p-1">
+        <div v-if="isLoadingProductionDatabases" class="flex h-full items-center justify-center gap-2 text-sm text-muted-foreground">
+          <Loader2 class="h-4 w-4 animate-spin" />
+          {{ t("common.loading") }}
+        </div>
+        <div v-else-if="productionDatabaseError" class="flex h-full flex-col items-start justify-center gap-3 p-3 text-sm text-destructive">
+          <p>{{ t("production.databaseLoadFailed", { message: productionDatabaseError }) }}</p>
+          <Button type="button" variant="outline" size="sm" @click="reloadProductionDatabases">
+            <RefreshCw class="mr-1.5 h-3.5 w-3.5" />
+            {{ t("production.retry") }}
+          </Button>
+        </div>
+        <div v-else-if="!filteredProductionDatabaseNames.length" class="p-3 text-sm text-muted-foreground">
+          {{ productionDatabaseNames.length ? t("grid.noSearchResults") : t("production.noDatabasesAvailable") }}
+        </div>
+        <template v-else>
+          <button
+            v-for="database in filteredProductionDatabaseNames"
+            :key="database"
+            type="button"
+            class="flex h-8 w-full min-w-0 items-center gap-2 rounded-sm px-2 text-left text-sm hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground focus-visible:outline-none"
+            @click="toggleProductionDatabase(database)"
+          >
+            <CheckSquare v-if="productionDatabaseSelection.has(database)" class="h-4 w-4 shrink-0 text-primary" />
+            <Square v-else class="h-4 w-4 shrink-0 text-muted-foreground" />
+            <span class="truncate">{{ database }}</span>
+          </button>
+        </template>
+      </div>
+
+      <DialogFooter>
+        <Button variant="outline" @click="showProductionDatabasesDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="isLoadingProductionDatabases || !!productionDatabaseError || !productionDatabaseCanSave" @click="saveProductionDatabaseSelection">
+          {{ t("visibleDatabases.save") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <VisibleSchemasDialog
+    v-model:open="showVisibleSchemasDialog"
+    draft-mode
+    :connection-id="''"
+    :connection-name="form.name || selectedProfile().label"
+    :database="visibleSchemasDatabaseKey"
+    :draft-schema-names="visibleSchemaNames"
+    :draft-initial-selection="visibleSchemaInitialSelection"
+    :draft-loading="isLoadingVisibleSchemas"
+    :draft-error="visibleSchemaError"
+    @draft:save="handleDraftSchemasSave"
+    @draft:show-all="handleDraftSchemasShowAll"
+  />
+</template>
+
+<style>
+@media (min-width: 640px) {
+  .connection-db-picker-grid {
+    grid-template-columns: repeat(4, minmax(0, 1fr)) !important;
+  }
+}
+
+@media (min-width: 1024px) {
+  .connection-db-picker-grid {
+    grid-template-columns: repeat(5, minmax(0, 1fr)) !important;
+  }
+}
+
+.connection-db-picker-option {
+  color: var(--foreground);
+}
+
+.connection-db-picker-option--selected {
+  border-color: rgb(23, 23, 23);
+  background-color: rgba(23, 23, 23, 0.08);
+  box-shadow: 0 0 0 1px rgba(23, 23, 23, 0.24);
+  color: rgb(10, 10, 10);
+}
+
+.connection-db-picker-option--selected:hover {
+  background-color: rgba(23, 23, 23, 0.12);
+}
+
+.dark .connection-db-picker-option--selected {
+  border-color: rgb(208, 208, 214);
+  background-color: rgba(255, 255, 255, 0.08);
+  box-shadow: 0 0 0 1px rgba(255, 255, 255, 0.22);
+  color: rgb(221, 221, 226);
+}
+
+.dark .connection-db-picker-option--selected:hover {
+  background-color: rgba(255, 255, 255, 0.12);
+}
+
+.connection-dialog-content[data-wide="true"] .grid.grid-cols-4 {
+  grid-template-columns: minmax(5.5rem, 0.7fr) repeat(3, minmax(0, 1fr));
+}
+
+.connection-dialog-content[data-wide="true"] .connection-form-body {
+  width: min(100%, 36rem);
+  margin-inline: auto;
+}
+</style>
diff --git a/apps/desktop/src/components/connection/ConnectionErrorIndicator.vue b/apps/desktop/src/components/connection/ConnectionErrorIndicator.vue
new file mode 100644
index 0000000..4dc825e
--- /dev/null
+++ b/apps/desktop/src/components/connection/ConnectionErrorIndicator.vue
@@ -0,0 +1,52 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import { useI18n } from "vue-i18n";
+import { AlertTriangle, X } from "@lucide/vue";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { useConnectionStore } from "@/stores/connectionStore";
+
+const props = withDefaults(
+  defineProps<{
+    connectionId?: string | null;
+    triggerClass?: string;
+  }>(),
+  {
+    connectionId: null,
+    triggerClass: "",
+  },
+);
+
+const { t } = useI18n();
+const connectionStore = useConnectionStore();
+
+const errorMessage = computed(() => (props.connectionId ? connectionStore.connectionErrors[props.connectionId] : ""));
+
+function clearError() {
+  if (props.connectionId) connectionStore.clearConnectionError(props.connectionId);
+}
+</script>
+
+<template>
+  <Popover v-if="errorMessage">
+    <PopoverTrigger as-child>
+      <button type="button" class="inline-flex h-4 w-4 shrink-0 items-center justify-center rounded text-amber-500 hover:bg-amber-500/10 hover:text-amber-600 focus:outline-none focus:ring-1 focus:ring-amber-500/40" :class="triggerClass" :title="t('connection.lastError')" @click.stop>
+        <AlertTriangle class="h-3.5 w-3.5" />
+      </button>
+    </PopoverTrigger>
+    <PopoverContent side="top" class="w-72 gap-2 p-2 text-xs" @click.stop>
+      <div class="flex items-start gap-2">
+        <div class="min-w-0 flex-1">
+          <div class="font-medium text-foreground">
+            {{ t("connection.lastError") }}
+          </div>
+          <div class="mt-1 max-h-36 overflow-auto whitespace-pre-wrap break-words text-muted-foreground">
+            {{ errorMessage }}
+          </div>
+        </div>
+        <button type="button" class="shrink-0 rounded p-0.5 text-muted-foreground hover:bg-muted hover:text-foreground" :title="t('connection.clearError')" @click="clearError">
+          <X class="h-3.5 w-3.5" />
+        </button>
+      </div>
+    </PopoverContent>
+  </Popover>
+</template>
diff --git a/apps/desktop/src/components/connection/TunnelProfileManager.vue b/apps/desktop/src/components/connection/TunnelProfileManager.vue
new file mode 100644
index 0000000..eeb9260
--- /dev/null
+++ b/apps/desktop/src/components/connection/TunnelProfileManager.vue
@@ -0,0 +1,258 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import PasswordInput from "@/components/ui/PasswordInput.vue";
+import { Label } from "@/components/ui/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Loader2, Plus, Trash2 } from "@lucide/vue";
+import { useToast } from "@/composables/useToast";
+import { useTunnelProfileStore } from "@/stores/tunnelProfileStore";
+import { createTunnelProfile, tunnelProfileSummary, type TunnelProfileType } from "@/lib/connection/tunnelProfiles";
+import type { TunnelProfile } from "@/types/database";
+import { translateBackendError } from "@/i18n/backend-errors";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const store = useTunnelProfileStore();
+
+const draft = ref<TunnelProfile[]>([]);
+const selectedId = ref<string | null>(null);
+const isSaving = ref(false);
+const hasInitializedDraft = ref(false);
+
+function cloneProfiles(profiles: TunnelProfile[]): TunnelProfile[] {
+  return JSON.parse(JSON.stringify(profiles)) as TunnelProfile[];
+}
+
+function resetDraft() {
+  draft.value = cloneProfiles(store.profiles);
+  if (!draft.value.some((profile) => profile.id === selectedId.value)) {
+    selectedId.value = draft.value[0]?.id || null;
+  }
+}
+
+const isDirty = computed(() => JSON.stringify(draft.value) !== JSON.stringify(store.profiles));
+
+void store.init();
+watch(
+  () => store.isLoaded,
+  (loaded) => {
+    // A remounted settings panel starts with an empty draft even when Pinia
+    // already contains profiles, so the initial empty state is not a user edit.
+    if (loaded && (!hasInitializedDraft.value || !isDirty.value)) {
+      resetDraft();
+      hasInitializedDraft.value = true;
+    }
+  },
+  { immediate: true },
+);
+
+const selected = computed(() => draft.value.find((profile) => profile.id === selectedId.value) || null);
+const selectedSsh = computed(() => (selected.value?.type === "ssh" ? selected.value : null));
+const selectedProxy = computed(() => (selected.value?.type === "proxy" ? selected.value : null));
+const selectedHttp = computed(() => (selected.value?.type === "http_tunnel" ? selected.value : null));
+
+function profileTypeLabel(profile: TunnelProfile): string {
+  if (profile.type === "proxy") return "Proxy";
+  if (profile.type === "http_tunnel") return t("connection.httpTunnel");
+  return "SSH";
+}
+
+function profileDisplayName(profile: TunnelProfile): string {
+  return profile.name?.trim() || tunnelProfileSummary(profile) || t("settings.tunnelsUnnamedProfile");
+}
+
+function addProfile(type: TunnelProfileType) {
+  const profile = createTunnelProfile(type);
+  draft.value = [...draft.value, profile];
+  selectedId.value = profile.id;
+}
+
+function removeSelected() {
+  const current = selected.value;
+  if (!current) return;
+  draft.value = draft.value.filter((profile) => profile.id !== current.id);
+  selectedId.value = draft.value[0]?.id || null;
+}
+
+function updateSshAuthMethod(value: unknown) {
+  const profile = selectedSsh.value;
+  if (!profile) return;
+  profile.auth_method = value === "key" ? "key" : value === "none" ? "none" : "password";
+  if (profile.auth_method !== "password") profile.password = "";
+  if (profile.auth_method !== "key") {
+    profile.key_path = "";
+    profile.key_passphrase = "";
+  }
+}
+
+function updateProxyType(value: unknown) {
+  const profile = selectedProxy.value;
+  if (!profile) return;
+  profile.proxy_type = value === "http" ? "http" : "socks5";
+}
+
+async function save() {
+  if (isSaving.value) return;
+  isSaving.value = true;
+  try {
+    await store.saveProfiles(cloneProfiles(draft.value));
+    toast(t("settings.tunnelsSaved"));
+  } catch (error) {
+    toast(t("settings.tunnelsSaveFailed", { message: translateBackendError(t, String(error)) }), 5000);
+  } finally {
+    isSaving.value = false;
+  }
+}
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <p class="text-xs text-muted-foreground">{{ t("settings.tunnelsDescription") }}</p>
+
+    <div class="grid min-w-0 gap-2">
+      <p v-if="!draft.length" class="rounded-md border border-dashed px-3 py-4 text-center text-xs text-muted-foreground">
+        {{ t("settings.tunnelsEmpty") }}
+      </p>
+      <button v-for="profile in draft" :key="profile.id" type="button" class="flex min-h-10 items-center gap-2 rounded-md border px-3 text-left text-xs transition-colors" :class="profile.id === selectedId ? 'border-primary bg-primary/5' : 'hover:bg-muted/50'" @click="selectedId = profile.id">
+        <span class="shrink-0 rounded border bg-muted/40 px-1.5 py-0.5 text-[10px] uppercase text-muted-foreground">{{ profileTypeLabel(profile) }}</span>
+        <span class="min-w-0 flex-1 truncate">{{ profileDisplayName(profile) }}</span>
+        <span class="min-w-0 truncate text-muted-foreground">{{ tunnelProfileSummary(profile) }}</span>
+      </button>
+    </div>
+
+    <div class="flex flex-wrap items-center gap-2">
+      <Button type="button" variant="outline" size="sm" @click="addProfile('ssh')">
+        <Plus class="mr-1.5 h-3.5 w-3.5" />
+        {{ t("settings.tunnelsAddSsh") }}
+      </Button>
+      <Button type="button" variant="outline" size="sm" @click="addProfile('proxy')">
+        <Plus class="mr-1.5 h-3.5 w-3.5" />
+        {{ t("settings.tunnelsAddProxy") }}
+      </Button>
+      <Button type="button" variant="outline" size="sm" @click="addProfile('http_tunnel')">
+        <Plus class="mr-1.5 h-3.5 w-3.5" />
+        {{ t("settings.tunnelsAddHttp") }}
+      </Button>
+      <Button v-if="selected" type="button" variant="outline" size="sm" @click="removeSelected">
+        <Trash2 class="mr-1.5 h-3.5 w-3.5" />
+        {{ t("settings.tunnelsDelete") }}
+      </Button>
+    </div>
+
+    <template v-if="selected">
+      <div class="grid grid-cols-4 items-center gap-4">
+        <Label class="text-xs">{{ t("settings.tunnelsProfileName") }}</Label>
+        <Input v-model="selected.name" class="col-span-3" :placeholder="t('settings.tunnelsProfileNamePlaceholder')" />
+      </div>
+
+      <template v-if="selectedSsh">
+        <div class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.sshHost") }}</Label>
+          <Input v-model="selectedSsh.host" class="col-span-2" :placeholder="t('connection.sshHostPlaceholder')" />
+          <Input v-model.number="selectedSsh.port" type="number" min="1" max="65535" class="col-span-1" />
+        </div>
+        <div class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.sshUser") }}</Label>
+          <Input v-model="selectedSsh.user" class="col-span-3" placeholder="root" />
+        </div>
+        <div class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.sshAuthMethod") }}</Label>
+          <Select :model-value="selectedSsh.auth_method || 'password'" @update:model-value="updateSshAuthMethod">
+            <SelectTrigger class="col-span-3 h-9">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="password">{{ t("connection.sshAuthMethodPassword") }}</SelectItem>
+              <SelectItem value="key">{{ t("connection.sshAuthMethodKey") }}</SelectItem>
+              <SelectItem value="none">{{ t("connection.sshAuthMethodNone") }}</SelectItem>
+            </SelectContent>
+          </Select>
+        </div>
+        <div v-if="!selectedSsh.auth_method || selectedSsh.auth_method === 'password'" class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.sshPassword") }}</Label>
+          <PasswordInput v-model="selectedSsh.password" class="col-span-3" :placeholder="t('connection.sshPasswordPlaceholder')" />
+        </div>
+        <div v-if="selectedSsh.auth_method === 'key'" class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.sshKeyPath") }}</Label>
+          <Input v-model="selectedSsh.key_path" class="col-span-3" placeholder="~/.ssh/id_rsa" />
+        </div>
+        <div v-if="selectedSsh.auth_method === 'key'" class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.sshKeyPassphrase") }}</Label>
+          <PasswordInput v-model="selectedSsh.key_passphrase" class="col-span-3" :placeholder="t('connection.sshKeyPassphrasePlaceholder')" />
+        </div>
+        <div v-if="selectedSsh.auth_method === 'none'" class="grid grid-cols-4 items-center gap-4">
+          <span />
+          <p class="col-span-3 text-xs text-muted-foreground">{{ t("connection.sshAuthMethodNoneHint") }}</p>
+        </div>
+        <div class="grid grid-cols-4 items-center gap-4">
+          <span />
+          <label class="col-span-3 flex cursor-pointer items-center gap-2">
+            <input v-model="selectedSsh.expose_lan" type="checkbox" class="mr-0" />
+            <span class="text-xs text-muted-foreground">{{ t("connection.sshExposeLan") }}</span>
+          </label>
+        </div>
+        <div class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.sshConnectTimeout") }}</Label>
+          <Input v-model.number="selectedSsh.connect_timeout_secs" type="number" min="1" max="300" step="1" class="col-span-3" />
+        </div>
+      </template>
+
+      <template v-else-if="selectedProxy">
+        <div class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.proxyType") }}</Label>
+          <Select :model-value="selectedProxy.proxy_type || 'socks5'" @update:model-value="updateProxyType">
+            <SelectTrigger class="col-span-3 h-9">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="socks5">SOCKS5</SelectItem>
+              <SelectItem value="http">HTTP CONNECT</SelectItem>
+            </SelectContent>
+          </Select>
+        </div>
+        <div class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.proxyHost") }}</Label>
+          <Input v-model="selectedProxy.host" class="col-span-2" placeholder="127.0.0.1" />
+          <Input v-model.number="selectedProxy.port" type="number" class="col-span-1" />
+        </div>
+        <div class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.proxyUsername") }}</Label>
+          <Input v-model="selectedProxy.username" class="col-span-3" :placeholder="t('connection.proxyUsernamePlaceholder')" />
+        </div>
+        <div class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.proxyPassword") }}</Label>
+          <PasswordInput v-model="selectedProxy.password" class="col-span-3" :placeholder="t('connection.proxyPasswordPlaceholder')" />
+        </div>
+      </template>
+
+      <template v-else-if="selectedHttp">
+        <div class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.httpTunnelUrl") }}</Label>
+          <Input v-model="selectedHttp.url" class="col-span-3" placeholder="https://dbx.example.com/dbx_tunnel.php" />
+        </div>
+        <div class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.httpTunnelToken") }}</Label>
+          <PasswordInput v-model="selectedHttp.token" class="col-span-3" :placeholder="t('connection.httpTunnelTokenPlaceholder')" />
+        </div>
+        <div class="grid grid-cols-4 items-center gap-4">
+          <Label class="text-xs">{{ t("connection.httpTunnelConnectTimeout") }}</Label>
+          <Input v-model.number="selectedHttp.connect_timeout_secs" type="number" min="1" max="300" step="1" class="col-span-3" />
+        </div>
+      </template>
+    </template>
+
+    <div class="flex items-center gap-2">
+      <Button type="button" size="sm" :disabled="!isDirty || isSaving" @click="save">
+        <Loader2 v-if="isSaving" class="mr-1.5 h-3.5 w-3.5 animate-spin" />
+        {{ t("settings.tunnelsSave") }}
+      </Button>
+      <Button type="button" variant="outline" size="sm" :disabled="!isDirty || isSaving" @click="resetDraft">
+        {{ t("settings.tunnelsReset") }}
+      </Button>
+      <p v-if="isDirty" class="text-xs text-muted-foreground">{{ t("settings.tunnelsUnsavedHint") }}</p>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/diagram/SchemaDiagramDialog.vue b/apps/desktop/src/components/diagram/SchemaDiagramDialog.vue
new file mode 100644
index 0000000..7ed4434
--- /dev/null
+++ b/apps/desktop/src/components/diagram/SchemaDiagramDialog.vue
@@ -0,0 +1,1149 @@
+<script setup lang="ts">
+import { computed, nextTick, onUnmounted, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Dialog, DialogContent, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Input } from "@/components/ui/input";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { useConnectionStore } from "@/stores/connectionStore";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import * as api from "@/lib/backend/api";
+import { DIAGRAM_SQL_TYPES, isSchemaAware as isSchemaAwareDatabase } from "@/lib/database/databaseCapabilities";
+import { databaseOptionsForConnection } from "@/composables/useDatabaseOptions";
+import { buildDiagramJoinSql, buildDiagramRelationships, filterDiagramTables, layoutDiagramTables, normalizeCustomDiagramRelationship, type CustomDiagramRelationship, type DiagramPosition, type DiagramRelationship, type DiagramTable } from "@/lib/diagram/erDiagram";
+import { buildEngineeringDiagram } from "@/lib/diagram/engineeringDiagram";
+import { buildEngineeringDiagramSvg, buildTableDiagramSvg, diagramSvgFileName } from "@/lib/export/diagramSvgExport";
+import { clampDiagramZoom, zoomFromGestureScale, zoomFromWheelDelta } from "@/lib/diagram/diagramZoom";
+import { Copy, Download, KeyRound, Link2, Loader2, Maximize2, Network, Plus, RefreshCw, Search, Table2, Trash2, X, ZoomIn, ZoomOut } from "@lucide/vue";
+import { useToast } from "@/composables/useToast";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { copyToClipboard } from "@/lib/common/clipboard";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const open = defineModel<boolean>("open", { default: false });
+const store = useConnectionStore();
+
+const props = defineProps<{
+  prefillConnectionId?: string;
+  prefillDatabase?: string;
+  prefillSchema?: string;
+  focusTableName?: string;
+}>();
+
+const emit = defineEmits<{
+  "open-target": [
+    value: {
+      connectionId: string;
+      database: string;
+      schema?: string;
+      tableName: string;
+      tableType?: string;
+    },
+  ];
+}>();
+
+const CARD_WIDTH = 270;
+const COLUMN_ROW_HEIGHT = 24;
+const CARD_HEADER_HEIGHT = 44;
+const CARD_BOTTOM_PADDING = 12;
+const MAX_VISIBLE_COLUMNS = 9;
+const METADATA_BATCH_SIZE = 4;
+const ROUTE_PADDING = 56;
+const ROUTE_BLOCK_MARGIN = 18;
+
+const connectionId = ref("");
+const database = ref("");
+const schema = ref("");
+const databases = ref<string[]>([]);
+const schemas = ref<string[]>([]);
+const tables = ref<DiagramTable[]>([]);
+const customRelationships = ref<CustomDiagramRelationship[]>([]);
+const tableSearch = ref("");
+const loadingDatabases = ref(false);
+const loadingSchemas = ref(false);
+const loadingDiagram = ref(false);
+const loadedTableCount = ref(0);
+const totalTableCount = ref(0);
+const failedTableCount = ref(0);
+const positions = ref<Record<string, DiagramPosition>>({});
+const showAllTables = ref(false);
+const diagramViewport = ref<HTMLDivElement | null>(null);
+const diagramMode = ref<"table" | "engineering">("table");
+const showRelationshipPanel = ref(false);
+const zoom = ref(1);
+const gestureStartZoom = ref(1);
+const dragging = ref<{
+  table: string;
+  startX: number;
+  startY: number;
+  originX: number;
+  originY: number;
+} | null>(null);
+const relationshipDraft = ref({
+  name: "",
+  sourceTable: "",
+  sourceColumn: "",
+  targetTable: "",
+  targetColumn: "",
+  cardinality: "one-to-many" as "one-to-one" | "one-to-many" | "many-to-one",
+});
+
+const sqlConnections = computed(() => store.connections.filter((connection) => DIAGRAM_SQL_TYPES.has(connection.db_type)));
+
+const selectedConnection = computed(() => (connectionId.value ? store.getConfig(connectionId.value) : undefined));
+
+const isSchemaAware = computed(() => isSchemaAwareDatabase(selectedConnection.value?.db_type));
+
+const tableMap = computed(() => new Map(tables.value.map((table) => [table.name, table])));
+
+const allRelationships = computed(() => buildDiagramRelationships(tables.value, customRelationships.value));
+
+const relatedTableNames = computed(() => {
+  const focus = props.focusTableName;
+  const names = new Set<string>();
+  if (!focus) return names;
+  names.add(focus);
+  for (const relationship of allRelationships.value) {
+    if (relationship.sourceTable === focus) names.add(relationship.targetTable);
+    if (relationship.targetTable === focus) names.add(relationship.sourceTable);
+  }
+  return names;
+});
+
+const visibleTables = computed(() => {
+  const filtered = filterDiagramTables(tables.value, tableSearch.value);
+  if (props.focusTableName && !showAllTables.value && !tableSearch.value.trim()) {
+    return filtered.filter((table) => relatedTableNames.value.has(table.name));
+  }
+  return filtered;
+});
+
+const visibleTableMap = computed(() => new Map(visibleTables.value.map((table) => [table.name, table])));
+
+const visibleRelationships = computed(() => buildDiagramRelationships(visibleTables.value, customRelationships.value));
+
+const diagramReady = computed(() => !!connectionId.value && !!database.value && (!isSchemaAware.value || !!schema.value));
+
+const loadingText = computed(() => (totalTableCount.value > 0 ? t("diagram.loadingProgress", { loaded: loadedTableCount.value, total: totalTableCount.value }) : t("diagram.loading")));
+
+const sourceColumns = computed(() => tableMap.value.get(relationshipDraft.value.sourceTable)?.columns ?? []);
+
+const targetColumns = computed(() => tableMap.value.get(relationshipDraft.value.targetTable)?.columns ?? []);
+
+const generatedJoinSql = computed(() => buildDiagramJoinSql(visibleRelationships.value));
+
+const customRelationshipCount = computed(() => customRelationships.value.length);
+
+function connectionIconType(id: string) {
+  const config = store.getConfig(id);
+  return config?.driver_profile || config?.db_type || "mysql";
+}
+
+function tableHeight(table: DiagramTable): number {
+  const visibleCount = Math.min(table.columns.length, MAX_VISIBLE_COLUMNS);
+  const overflowHeight = table.columns.length > MAX_VISIBLE_COLUMNS ? 24 : 0;
+  return CARD_HEADER_HEIGHT + visibleCount * COLUMN_ROW_HEIGHT + overflowHeight + CARD_BOTTOM_PADDING;
+}
+
+const canvasSize = computed(() => {
+  let width = 960;
+  let height = 540;
+  for (const table of visibleTables.value) {
+    const position = positions.value[table.name];
+    if (!position) continue;
+    width = Math.max(width, position.x + CARD_WIDTH + 80);
+    height = Math.max(height, position.y + tableHeight(table) + 80);
+  }
+  return { width, height };
+});
+
+const engineeringDiagram = computed(() => buildEngineeringDiagram(visibleTables.value, visibleRelationships.value, positions.value));
+
+const activeCanvasSize = computed(() => (diagramMode.value === "engineering" ? engineeringDiagram.value.canvas : canvasSize.value));
+
+function resetLayout() {
+  const count = visibleTables.value.length;
+  const columnsPerRow = Math.max(1, Math.min(4, Math.ceil(Math.sqrt(Math.max(count, 1)))));
+  positions.value = layoutDiagramTables(visibleTables.value, {
+    columnsPerRow,
+    cardWidth: CARD_WIDTH,
+    rowHeight: 240,
+    gapX: 64,
+    gapY: 44,
+  });
+}
+
+function visibleColumns(table: DiagramTable) {
+  return table.columns.slice(0, MAX_VISIBLE_COLUMNS);
+}
+
+function hiddenColumnCount(table: DiagramTable): number {
+  return Math.max(0, table.columns.length - MAX_VISIBLE_COLUMNS);
+}
+
+function isForeignKeyColumn(table: DiagramTable, columnName: string): boolean {
+  return table.foreignKeys.some((fk) => fk.column === columnName);
+}
+
+function isRelationshipColumn(table: DiagramTable, columnName: string): boolean {
+  return visibleRelationships.value.some((relationship) => (relationship.sourceTable === table.name && relationship.sourceColumn === columnName) || (relationship.targetTable === table.name && relationship.targetColumn === columnName));
+}
+
+function relationshipTitle(relationship: DiagramRelationship): string {
+  return `${relationship.sourceTable}.${relationship.sourceColumn} (${relationship.sourceCardinality}:${relationship.targetCardinality}) -> ${relationship.targetTable}.${relationship.targetColumn}`;
+}
+
+function openTableData(tableName: string) {
+  if (!connectionId.value || !database.value || !tableName) return;
+  emit("open-target", {
+    connectionId: connectionId.value,
+    database: database.value,
+    schema: isSchemaAware.value ? schema.value || undefined : undefined,
+    tableName,
+    tableType: "TABLE",
+  });
+}
+
+function relationshipStorageKey(): string {
+  if (!connectionId.value || !database.value) return "";
+  return ["dbx", "diagram", "relationships", "v1", connectionId.value, database.value, schema.value || ""].join(":");
+}
+
+function isStoredRelationship(value: unknown): value is CustomDiagramRelationship {
+  const relationship = value as Partial<CustomDiagramRelationship>;
+  return (
+    typeof relationship?.id === "string" &&
+    typeof relationship.name === "string" &&
+    typeof relationship.sourceTable === "string" &&
+    typeof relationship.sourceColumn === "string" &&
+    typeof relationship.targetTable === "string" &&
+    typeof relationship.targetColumn === "string" &&
+    (relationship.sourceCardinality === "1" || relationship.sourceCardinality === "N") &&
+    (relationship.targetCardinality === "1" || relationship.targetCardinality === "N")
+  );
+}
+
+function loadCustomRelationships() {
+  const key = relationshipStorageKey();
+  if (!key || typeof localStorage === "undefined") {
+    customRelationships.value = [];
+    return;
+  }
+  try {
+    const parsed = JSON.parse(localStorage.getItem(key) || "[]");
+    customRelationships.value = Array.isArray(parsed) ? parsed.filter(isStoredRelationship) : [];
+  } catch {
+    customRelationships.value = [];
+  }
+}
+
+function saveCustomRelationships() {
+  const key = relationshipStorageKey();
+  if (!key || typeof localStorage === "undefined") return;
+  localStorage.setItem(key, JSON.stringify(customRelationships.value));
+}
+
+function defaultRelationshipName(relationship: Omit<CustomDiagramRelationship, "id" | "name">): string {
+  return `${relationship.sourceTable}_${relationship.sourceColumn}_${relationship.targetTable}_${relationship.targetColumn}`;
+}
+
+function relationshipCardinality(): Pick<CustomDiagramRelationship, "sourceCardinality" | "targetCardinality"> {
+  if (relationshipDraft.value.cardinality === "one-to-one") return { sourceCardinality: "1", targetCardinality: "1" };
+  if (relationshipDraft.value.cardinality === "many-to-one") return { sourceCardinality: "N", targetCardinality: "1" };
+  return { sourceCardinality: "1", targetCardinality: "N" };
+}
+
+function updateRelationshipDraftDefaults() {
+  const availableTables = tables.value.filter((table) => table.columns.length > 0);
+  if (availableTables.length === 0) return;
+
+  if (!tableMap.value.has(relationshipDraft.value.sourceTable)) {
+    relationshipDraft.value.sourceTable = availableTables[0].name;
+  }
+  if (!tableMap.value.has(relationshipDraft.value.targetTable)) {
+    relationshipDraft.value.targetTable = availableTables[1]?.name ?? availableTables[0].name;
+  }
+  if (!sourceColumns.value.some((column) => column.name === relationshipDraft.value.sourceColumn)) {
+    relationshipDraft.value.sourceColumn = sourceColumns.value[0]?.name ?? "";
+  }
+  if (!targetColumns.value.some((column) => column.name === relationshipDraft.value.targetColumn)) {
+    relationshipDraft.value.targetColumn = targetColumns.value[0]?.name ?? "";
+  }
+}
+
+function addCustomRelationship() {
+  updateRelationshipDraftDefaults();
+  const { sourceTable, sourceColumn, targetTable, targetColumn } = relationshipDraft.value;
+  if (!sourceTable || !sourceColumn || !targetTable || !targetColumn) {
+    toast(t("diagram.relationshipIncomplete"), 3000);
+    return;
+  }
+  if (sourceTable === targetTable && sourceColumn === targetColumn) {
+    toast(t("diagram.relationshipSelfInvalid"), 3000);
+    return;
+  }
+
+  const cardinality = relationshipCardinality();
+  const relationship = normalizeCustomDiagramRelationship({
+    name: relationshipDraft.value.name.trim() || defaultRelationshipName({ sourceTable, sourceColumn, targetTable, targetColumn, ...cardinality }),
+    sourceTable,
+    sourceColumn,
+    targetTable,
+    targetColumn,
+    ...cardinality,
+  });
+
+  if (customRelationships.value.some((item) => item.id === relationship.id)) {
+    toast(t("diagram.relationshipExists"), 3000);
+    return;
+  }
+
+  customRelationships.value = [...customRelationships.value, relationship];
+  relationshipDraft.value.name = "";
+  saveCustomRelationships();
+  toast(t("diagram.relationshipAdded"), 2000);
+}
+
+function removeCustomRelationship(id: string) {
+  customRelationships.value = customRelationships.value.filter((relationship) => relationship.id !== id);
+  saveCustomRelationships();
+}
+
+async function copyJoinSql() {
+  if (!generatedJoinSql.value.trim()) {
+    toast(t("diagram.noJoinSql"), 3000);
+    return;
+  }
+  try {
+    await copyToClipboard(generatedJoinSql.value);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function columnAnchorY(tableName: string, columnName: string): number {
+  const table = visibleTableMap.value.get(tableName);
+  const position = positions.value[tableName];
+  if (!table || !position) return 0;
+
+  const index = table.columns.findIndex((column) => column.name === columnName);
+  if (index < 0) return position.y + CARD_HEADER_HEIGHT / 2;
+  const visibleIndex = Math.min(index, MAX_VISIBLE_COLUMNS - 1);
+  return position.y + CARD_HEADER_HEIGHT + visibleIndex * COLUMN_ROW_HEIGHT + COLUMN_ROW_HEIGHT / 2;
+}
+
+interface TableRect {
+  name: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+interface DiagramGestureEvent extends Event {
+  scale?: number;
+  clientX?: number;
+  clientY?: number;
+}
+
+function getTableRect(tableName: string): TableRect | null {
+  const table = visibleTableMap.value.get(tableName);
+  const position = positions.value[tableName];
+  if (!table || !position) return null;
+  return {
+    name: tableName,
+    x: position.x,
+    y: position.y,
+    width: CARD_WIDTH,
+    height: tableHeight(table),
+  };
+}
+
+function rangesOverlap(a1: number, a2: number, b1: number, b2: number): boolean {
+  return Math.max(a1, b1) <= Math.min(a2, b2);
+}
+
+function routeSideX(rect: TableRect, routeX: number, offset = 0): number {
+  if (routeX < rect.x) return rect.x - offset;
+  return rect.x + rect.width + offset;
+}
+
+function tableRects(): TableRect[] {
+  return visibleTables.value.map((table) => getTableRect(table.name)).filter((rect): rect is TableRect => rect !== null);
+}
+
+function isVerticalRouteBlocked(routeX: number, y1: number, y2: number, ignoredTables: Set<string>): boolean {
+  const top = Math.min(y1, y2);
+  const bottom = Math.max(y1, y2);
+  return tableRects().some((rect) => !ignoredTables.has(rect.name) && routeX >= rect.x - ROUTE_BLOCK_MARGIN && routeX <= rect.x + rect.width + ROUTE_BLOCK_MARGIN && rangesOverlap(top, bottom, rect.y - ROUTE_BLOCK_MARGIN, rect.y + rect.height + ROUTE_BLOCK_MARGIN));
+}
+
+function isHorizontalRouteBlocked(y: number, x1: number, x2: number, ignoredTables: Set<string>): boolean {
+  const left = Math.min(x1, x2);
+  const right = Math.max(x1, x2);
+  return tableRects().some((rect) => !ignoredTables.has(rect.name) && y >= rect.y - ROUTE_BLOCK_MARGIN && y <= rect.y + rect.height + ROUTE_BLOCK_MARGIN && rangesOverlap(left, right, rect.x - ROUTE_BLOCK_MARGIN, rect.x + rect.width + ROUTE_BLOCK_MARGIN));
+}
+
+function candidateRouteXs(source: TableRect, target: TableRect): number[] {
+  const candidates = new Set<number>();
+  const sourceRight = source.x + source.width;
+  const targetRight = target.x + target.width;
+  const minLeft = Math.min(source.x, target.x);
+  const maxRight = Math.max(sourceRight, targetRight);
+
+  candidates.add(minLeft - ROUTE_PADDING);
+  candidates.add(maxRight + ROUTE_PADDING);
+
+  if (sourceRight + ROUTE_PADDING <= target.x) {
+    candidates.add((sourceRight + target.x) / 2);
+  }
+  if (targetRight + ROUTE_PADDING <= source.x) {
+    candidates.add((targetRight + source.x) / 2);
+  }
+
+  const columns = [...new Set(tableRects().map((rect) => rect.x))].sort((left, right) => left - right);
+  for (let index = 0; index < columns.length - 1; index++) {
+    const leftRight = columns[index] + CARD_WIDTH;
+    const rightLeft = columns[index + 1];
+    if (rightLeft - leftRight >= ROUTE_PADDING) {
+      candidates.add((leftRight + rightLeft) / 2);
+    }
+  }
+
+  return [...candidates].sort((left, right) => {
+    const leftSourceX = routeSideX(source, left);
+    const leftTargetX = routeSideX(target, left);
+    const rightSourceX = routeSideX(source, right);
+    const rightTargetX = routeSideX(target, right);
+    return Math.abs(left - leftSourceX) + Math.abs(left - leftTargetX) - (Math.abs(right - rightSourceX) + Math.abs(right - rightTargetX));
+  });
+}
+
+function relationshipPath(relationship: DiagramRelationship): string {
+  const source = getTableRect(relationship.sourceTable);
+  const target = getTableRect(relationship.targetTable);
+  if (!source || !target) return "";
+
+  const y1 = columnAnchorY(relationship.sourceTable, relationship.sourceColumn);
+  const y2 = columnAnchorY(relationship.targetTable, relationship.targetColumn);
+  const ignoredTables = new Set([source.name, target.name]);
+  const candidates = candidateRouteXs(source, target);
+
+  const routeX =
+    candidates.find((candidate) => {
+      const x1 = routeSideX(source, candidate);
+      const x2 = routeSideX(target, candidate);
+      return !isVerticalRouteBlocked(candidate, y1, y2, ignoredTables) && !isHorizontalRouteBlocked(y1, x1, candidate, ignoredTables) && !isHorizontalRouteBlocked(y2, candidate, x2, ignoredTables);
+    }) ??
+    candidates[0] ??
+    Math.max(source.x + source.width, target.x + target.width) + ROUTE_PADDING;
+
+  const x1 = routeSideX(source, routeX, 2);
+  const x2 = routeSideX(target, routeX, 2);
+  return `M ${x1} ${y1} L ${routeX} ${y1} L ${routeX} ${y2} L ${x2} ${y2}`;
+}
+
+function engineeringEntityCenter(tableName: string): DiagramPosition {
+  const entity = engineeringDiagram.value.entities.find((item) => item.name === tableName);
+  return entity ? { x: entity.x + entity.width / 2, y: entity.y + entity.height / 2 } : { x: 0, y: 0 };
+}
+
+function engineeringAttributeCenter(attribute: { x: number; y: number; width: number; height: number }): DiagramPosition {
+  return { x: attribute.x + attribute.width / 2, y: attribute.y + attribute.height / 2 };
+}
+
+function engineeringRelationshipCenter(relationship: { x: number; y: number; width: number; height: number }): DiagramPosition {
+  return {
+    x: relationship.x + relationship.width / 2,
+    y: relationship.y + relationship.height / 2,
+  };
+}
+
+function engineeringCardinalityPoint(from: DiagramPosition, to: DiagramPosition): DiagramPosition {
+  return {
+    x: from.x + (to.x - from.x) * 0.72,
+    y: from.y + (to.y - from.y) * 0.72,
+  };
+}
+
+async function loadDatabases(id: string) {
+  if (!id) return;
+  loadingDatabases.value = true;
+  databases.value = [];
+  try {
+    await store.ensureConnected(id);
+    const dbs = await api.listDatabases(id);
+    databases.value = databaseOptionsForConnection(
+      dbs.map((db) => db.name),
+      store.getConfig(id),
+    );
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    loadingDatabases.value = false;
+  }
+}
+
+async function loadSchemas() {
+  schemas.value = [];
+  schema.value = "";
+  if (!connectionId.value || !database.value) return;
+  if (!isSchemaAware.value) {
+    schema.value = database.value;
+    return;
+  }
+
+  loadingSchemas.value = true;
+  try {
+    const names = await api.listSchemas(connectionId.value, database.value);
+    schemas.value = names;
+    schema.value = props.prefillSchema && names.includes(props.prefillSchema) ? props.prefillSchema : names.includes("public") ? "public" : (names[0] ?? "");
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    loadingSchemas.value = false;
+  }
+}
+
+async function setConnection(id: string) {
+  connectionId.value = id;
+  database.value = "";
+  schema.value = "";
+  tables.value = [];
+  customRelationships.value = [];
+  positions.value = {};
+  await loadDatabases(id);
+  if (databases.value.length === 1) {
+    await setDatabase(databases.value[0]);
+  }
+}
+
+async function setDatabase(value: string) {
+  database.value = value;
+  tables.value = [];
+  customRelationships.value = [];
+  positions.value = {};
+  await loadSchemas();
+  if (diagramReady.value) await loadDiagram();
+}
+
+async function setSchema(value: string) {
+  schema.value = value;
+  tables.value = [];
+  customRelationships.value = [];
+  positions.value = {};
+  if (diagramReady.value) await loadDiagram();
+}
+
+async function loadTableDiagramData(tableName: string, querySchema: string): Promise<DiagramTable> {
+  try {
+    const [columns, foreignKeys] = await Promise.all([api.getColumns(connectionId.value, database.value, querySchema, tableName), api.listForeignKeys(connectionId.value, database.value, querySchema, tableName).catch(() => [])]);
+    return { name: tableName, columns, foreignKeys };
+  } catch (e) {
+    failedTableCount.value += 1;
+    console.warn(`[diagram] failed to load table metadata: ${tableName}`, e);
+    return { name: tableName, columns: [], foreignKeys: [] };
+  }
+}
+
+async function loadDiagram() {
+  if (!diagramReady.value) return;
+
+  loadingDiagram.value = true;
+  tables.value = [];
+  positions.value = {};
+  loadedTableCount.value = 0;
+  totalTableCount.value = 0;
+  failedTableCount.value = 0;
+  try {
+    await store.ensureConnected(connectionId.value);
+    const querySchema = schema.value || database.value;
+    const tableInfos = await api.listTables(connectionId.value, database.value, querySchema);
+    const baseTables = tableInfos.filter((table) => table.table_type !== "VIEW" && table.table_type !== "MATERIALIZED_VIEW").sort((a, b) => a.name.localeCompare(b.name));
+    totalTableCount.value = baseTables.length;
+
+    const loadedTables: DiagramTable[] = [];
+    for (let index = 0; index < baseTables.length; index += METADATA_BATCH_SIZE) {
+      const batch = baseTables.slice(index, index + METADATA_BATCH_SIZE);
+      const batchTables = await Promise.all(batch.map((table) => loadTableDiagramData(table.name, querySchema)));
+      loadedTables.push(...batchTables);
+      loadedTableCount.value = loadedTables.length;
+    }
+
+    tables.value = loadedTables;
+    loadCustomRelationships();
+    updateRelationshipDraftDefaults();
+    showAllTables.value = false;
+    await nextTick();
+    resetLayout();
+    if (failedTableCount.value > 0) {
+      toast(t("diagram.partialError", { count: failedTableCount.value }), 5000);
+    }
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    loadingDiagram.value = false;
+  }
+}
+
+async function initialize() {
+  connectionId.value = "";
+  database.value = "";
+  schema.value = "";
+  databases.value = [];
+  schemas.value = [];
+  tables.value = [];
+  customRelationships.value = [];
+  tableSearch.value = "";
+  showAllTables.value = false;
+  showRelationshipPanel.value = false;
+  diagramMode.value = "table";
+  zoom.value = 1;
+  positions.value = {};
+  loadedTableCount.value = 0;
+  totalTableCount.value = 0;
+  failedTableCount.value = 0;
+
+  if (props.prefillConnectionId) {
+    connectionId.value = props.prefillConnectionId;
+    await loadDatabases(props.prefillConnectionId);
+    const initialDatabase = props.prefillDatabase && databases.value.includes(props.prefillDatabase) ? props.prefillDatabase : props.prefillDatabase || databases.value[0] || "";
+    if (initialDatabase) await setDatabase(initialDatabase);
+    return;
+  }
+
+  if (sqlConnections.value.length === 1) {
+    await setConnection(sqlConnections.value[0].id);
+  }
+}
+
+function applyZoomAt(nextZoom: number, clientX?: number, clientY?: number) {
+  const viewport = diagramViewport.value;
+  const previousZoom = zoom.value;
+  if (!viewport || nextZoom === previousZoom) {
+    zoom.value = nextZoom;
+    return;
+  }
+
+  const rect = viewport.getBoundingClientRect();
+  const originX = (clientX ?? rect.left + rect.width / 2) - rect.left;
+  const originY = (clientY ?? rect.top + rect.height / 2) - rect.top;
+  const contentX = (viewport.scrollLeft + originX) / previousZoom;
+  const contentY = (viewport.scrollTop + originY) / previousZoom;
+
+  zoom.value = nextZoom;
+  void nextTick(() => {
+    viewport.scrollLeft = contentX * nextZoom - originX;
+    viewport.scrollTop = contentY * nextZoom - originY;
+  });
+}
+
+function zoomIn() {
+  applyZoomAt(clampDiagramZoom(zoom.value + 0.1));
+}
+
+function zoomOut() {
+  applyZoomAt(clampDiagramZoom(zoom.value - 0.1));
+}
+
+function resetZoomAndLayout() {
+  zoom.value = 1;
+  resetLayout();
+}
+
+function tableRelationshipPaths(): Record<string, string> {
+  return Object.fromEntries(visibleRelationships.value.map((relationship) => [relationship.id, relationshipPath(relationship)]));
+}
+
+function currentDiagramSvg(): string {
+  if (diagramMode.value === "engineering") {
+    return buildEngineeringDiagramSvg(engineeringDiagram.value);
+  }
+
+  return buildTableDiagramSvg({
+    tables: visibleTables.value,
+    relationships: visibleRelationships.value,
+    positions: positions.value,
+    relationshipPaths: tableRelationshipPaths(),
+    canvas: canvasSize.value,
+    cardWidth: CARD_WIDTH,
+    cardHeaderHeight: CARD_HEADER_HEIGHT,
+    columnRowHeight: COLUMN_ROW_HEIGHT,
+    maxVisibleColumns: MAX_VISIBLE_COLUMNS,
+    cardBottomPadding: CARD_BOTTOM_PADDING,
+    moreColumnsLabel: (count) => t("diagram.moreColumns", { count }),
+  });
+}
+
+async function exportSvg() {
+  try {
+    const scopeName = isSchemaAware.value && schema.value ? `${database.value}-${schema.value}` : database.value;
+    const defaultPath = diagramSvgFileName(selectedConnection.value?.name ?? "", scopeName, diagramMode.value);
+    const svgContent = currentDiagramSvg();
+
+    if (isTauriRuntime()) {
+      const [{ save }, { writeTextFile }] = await Promise.all([import("@tauri-apps/plugin-dialog"), import("@tauri-apps/plugin-fs")]);
+      const path = await save({
+        defaultPath,
+        filters: [{ name: "SVG", extensions: ["svg"] }],
+      });
+      if (!path) return;
+      await writeTextFile(path, svgContent);
+    } else {
+      const blob = new Blob([svgContent], { type: "image/svg+xml" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = defaultPath;
+      a.click();
+      URL.revokeObjectURL(url);
+    }
+    toast(t("diagram.exportedSvg"));
+  } catch (e: any) {
+    toast(t("diagram.exportSvgFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function onDiagramWheel(event: WheelEvent) {
+  if (!event.ctrlKey && !event.metaKey) return;
+  event.preventDefault();
+  applyZoomAt(zoomFromWheelDelta(zoom.value, event.deltaY), event.clientX, event.clientY);
+}
+
+function onDiagramGestureStart(event: DiagramGestureEvent) {
+  event.preventDefault();
+  gestureStartZoom.value = zoom.value;
+}
+
+function onDiagramGestureChange(event: DiagramGestureEvent) {
+  if (typeof event.scale !== "number") return;
+  event.preventDefault();
+  applyZoomAt(zoomFromGestureScale(gestureStartZoom.value, event.scale), event.clientX, event.clientY);
+}
+
+function startDrag(table: string, event: MouseEvent) {
+  event.preventDefault();
+  const position = positions.value[table];
+  if (!position) return;
+  dragging.value = {
+    table,
+    startX: event.clientX,
+    startY: event.clientY,
+    originX: position.x,
+    originY: position.y,
+  };
+  window.addEventListener("mousemove", onDrag);
+  window.addEventListener("mouseup", stopDrag);
+}
+
+function onDrag(event: MouseEvent) {
+  if (!dragging.value) return;
+  const current = dragging.value;
+  positions.value = {
+    ...positions.value,
+    [current.table]: {
+      x: Math.max(16, current.originX + (event.clientX - current.startX) / zoom.value),
+      y: Math.max(16, current.originY + (event.clientY - current.startY) / zoom.value),
+    },
+  };
+}
+
+function stopDrag() {
+  dragging.value = null;
+  window.removeEventListener("mousemove", onDrag);
+  window.removeEventListener("mouseup", stopDrag);
+}
+
+watch(
+  open,
+  (value) => {
+    if (value) void initialize();
+  },
+  { immediate: true },
+);
+
+watch(
+  () => visibleTables.value.map((table) => table.name).join("\n"),
+  () => {
+    resetLayout();
+  },
+);
+
+watch(
+  () => relationshipDraft.value.sourceTable,
+  () => {
+    if (!sourceColumns.value.some((column) => column.name === relationshipDraft.value.sourceColumn)) {
+      relationshipDraft.value.sourceColumn = sourceColumns.value[0]?.name ?? "";
+    }
+  },
+);
+
+watch(
+  () => relationshipDraft.value.targetTable,
+  () => {
+    if (!targetColumns.value.some((column) => column.name === relationshipDraft.value.targetColumn)) {
+      relationshipDraft.value.targetColumn = targetColumns.value[0]?.name ?? "";
+    }
+  },
+);
+
+onUnmounted(stopDrag);
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent class="w-[94vw] max-w-[94vw] sm:max-w-[94vw] md:max-w-[94vw] lg:max-w-[94vw] xl:max-w-[94vw] h-[86vh] max-h-[86vh] gap-0 p-0 overflow-hidden flex flex-col">
+      <DialogHeader class="px-4 py-3 border-b">
+        <DialogTitle class="flex items-center gap-2">
+          <Network class="w-4 h-4" />
+          {{ t("diagram.title") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="flex items-center gap-2 border-b px-3 py-2 shrink-0 overflow-x-auto">
+        <Select :model-value="connectionId" @update:model-value="(value: any) => setConnection(String(value))">
+          <SelectTrigger class="h-8 w-48 text-xs">
+            <div v-if="connectionId" class="flex min-w-0 items-center gap-2">
+              <DatabaseIcon :db-type="connectionIconType(connectionId)" class="w-3.5 h-3.5 shrink-0" />
+              <span class="truncate">{{ selectedConnection?.name }}</span>
+            </div>
+            <SelectValue v-else :placeholder="t('diagram.selectConnection')" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem v-for="connection in sqlConnections" :key="connection.id" :value="connection.id">
+              <div class="flex items-center gap-2">
+                <DatabaseIcon :db-type="connection.driver_profile || connection.db_type" class="w-3.5 h-3.5" />
+                {{ connection.name }}
+              </div>
+            </SelectItem>
+          </SelectContent>
+        </Select>
+
+        <Select :model-value="database" :disabled="!databases.length || loadingDatabases" @update:model-value="(value: any) => setDatabase(String(value))">
+          <SelectTrigger class="h-8 w-44 text-xs">
+            <SelectValue :placeholder="loadingDatabases ? t('common.loading') : t('diagram.selectDatabase')" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem v-for="db in databases" :key="db" :value="db">{{ db }}</SelectItem>
+          </SelectContent>
+        </Select>
+
+        <Select v-if="isSchemaAware" :model-value="schema" :disabled="!schemas.length || loadingSchemas" @update:model-value="(value: any) => setSchema(String(value))">
+          <SelectTrigger class="h-8 w-40 text-xs">
+            <SelectValue :placeholder="loadingSchemas ? t('common.loading') : t('diagram.selectSchema')" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem v-for="name in schemas" :key="name" :value="name">{{ name }}</SelectItem>
+          </SelectContent>
+        </Select>
+
+        <div class="relative min-w-40 flex-1">
+          <Search class="absolute left-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+          <Input v-model="tableSearch" class="h-8 pl-7 text-xs" :placeholder="t('diagram.searchTables')" />
+        </div>
+
+        <div class="flex h-8 shrink-0 items-center overflow-hidden rounded-md border bg-background">
+          <Button variant="ghost" size="sm" class="h-8 rounded-none px-2 text-xs" :class="diagramMode === 'table' ? 'bg-accent' : ''" @click="diagramMode = 'table'">
+            <Table2 class="mr-1 h-3.5 w-3.5" />
+            {{ t("diagram.tableMode") }}
+          </Button>
+          <Button variant="ghost" size="sm" class="h-8 rounded-none border-l px-2 text-xs" :class="diagramMode === 'engineering' ? 'bg-accent' : ''" @click="diagramMode = 'engineering'">
+            <Network class="mr-1 h-3.5 w-3.5" />
+            {{ t("diagram.engineeringMode") }}
+          </Button>
+        </div>
+
+        <Button variant="outline" size="sm" class="h-8 px-2 text-xs" :disabled="tables.length === 0" :title="t('diagram.modelRelationships')" @click="showRelationshipPanel = !showRelationshipPanel">
+          <Link2 class="mr-1 h-3.5 w-3.5" />
+          {{ t("diagram.modelRelationships") }}
+        </Button>
+
+        <Button variant="outline" size="sm" class="h-8 px-2 text-xs" :disabled="!generatedJoinSql.trim()" :title="t('diagram.copyJoinSql')" @click="copyJoinSql">
+          <Copy class="mr-1 h-3.5 w-3.5" />
+          {{ t("diagram.copyJoinSql") }}
+        </Button>
+
+        <Button v-if="focusTableName && tables.length > 0" variant="outline" size="sm" class="h-8 px-2 text-xs" @click="showAllTables = !showAllTables">
+          {{ showAllTables ? t("diagram.relatedTables") : t("diagram.allTables") }}
+        </Button>
+
+        <Badge variant="secondary" class="h-6 shrink-0">
+          {{ t("diagram.tablesCount", { count: visibleTables.length }) }}
+        </Badge>
+        <Badge variant="secondary" class="h-6 shrink-0">
+          {{ t("diagram.relationshipsCount", { count: visibleRelationships.length }) }}
+        </Badge>
+        <Badge v-if="customRelationshipCount > 0" variant="outline" class="h-6 shrink-0">
+          {{ t("diagram.customRelationshipsCount", { count: customRelationshipCount }) }}
+        </Badge>
+
+        <Button variant="ghost" size="icon" class="h-8 w-8" :disabled="loadingDiagram || visibleTables.length === 0" :title="t('diagram.exportSvg')" @click="exportSvg">
+          <Download class="h-4 w-4" />
+        </Button>
+        <Button variant="ghost" size="icon" class="h-8 w-8" :disabled="!diagramReady || loadingDiagram" :title="t('diagram.refresh')" @click="loadDiagram">
+          <Loader2 v-if="loadingDiagram" class="h-4 w-4 animate-spin" />
+          <RefreshCw v-else class="h-4 w-4" />
+        </Button>
+        <Button variant="ghost" size="icon" class="h-8 w-8" :title="t('diagram.zoomOut')" @click="zoomOut">
+          <ZoomOut class="h-4 w-4" />
+        </Button>
+        <Button variant="ghost" size="icon" class="h-8 w-8" :title="t('diagram.zoomIn')" @click="zoomIn">
+          <ZoomIn class="h-4 w-4" />
+        </Button>
+        <Button variant="ghost" size="icon" class="h-8 w-8" :title="t('diagram.resetLayout')" @click="resetZoomAndLayout">
+          <Maximize2 class="h-4 w-4" />
+        </Button>
+      </div>
+
+      <div class="flex min-h-0 flex-1 flex-col bg-muted/20">
+        <div v-if="showRelationshipPanel && tables.length > 0" class="shrink-0 border-b bg-background/95 px-3 py-2">
+          <div class="flex flex-wrap items-end gap-2">
+            <div class="w-44">
+              <div class="mb-1 text-[11px] font-medium text-muted-foreground">{{ t("diagram.relationshipName") }}</div>
+              <Input v-model="relationshipDraft.name" class="h-8 text-xs" :placeholder="t('diagram.relationshipNamePlaceholder')" />
+            </div>
+
+            <div class="w-44">
+              <div class="mb-1 text-[11px] font-medium text-muted-foreground">{{ t("diagram.sourceTable") }}</div>
+              <Select v-model="relationshipDraft.sourceTable">
+                <SelectTrigger class="h-8 text-xs">
+                  <SelectValue :placeholder="t('diagram.sourceTable')" />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem v-for="table in tables" :key="`source-${table.name}`" :value="table.name" :disabled="table.columns.length === 0">{{ table.name }}</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+
+            <div class="w-44">
+              <div class="mb-1 text-[11px] font-medium text-muted-foreground">{{ t("diagram.sourceColumn") }}</div>
+              <Select v-model="relationshipDraft.sourceColumn">
+                <SelectTrigger class="h-8 text-xs">
+                  <SelectValue :placeholder="t('diagram.sourceColumn')" />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem v-for="column in sourceColumns" :key="`source-column-${column.name}`" :value="column.name">{{ column.name }}</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+
+            <div class="w-32">
+              <div class="mb-1 text-[11px] font-medium text-muted-foreground">{{ t("diagram.cardinality") }}</div>
+              <Select v-model="relationshipDraft.cardinality">
+                <SelectTrigger class="h-8 text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="one-to-many">{{ t("diagram.cardinalityOneToMany") }}</SelectItem>
+                  <SelectItem value="many-to-one">{{ t("diagram.cardinalityManyToOne") }}</SelectItem>
+                  <SelectItem value="one-to-one">{{ t("diagram.cardinalityOneToOne") }}</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+
+            <div class="w-44">
+              <div class="mb-1 text-[11px] font-medium text-muted-foreground">{{ t("diagram.targetTable") }}</div>
+              <Select v-model="relationshipDraft.targetTable">
+                <SelectTrigger class="h-8 text-xs">
+                  <SelectValue :placeholder="t('diagram.targetTable')" />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem v-for="table in tables" :key="`target-${table.name}`" :value="table.name" :disabled="table.columns.length === 0">{{ table.name }}</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+
+            <div class="w-44">
+              <div class="mb-1 text-[11px] font-medium text-muted-foreground">{{ t("diagram.targetColumn") }}</div>
+              <Select v-model="relationshipDraft.targetColumn">
+                <SelectTrigger class="h-8 text-xs">
+                  <SelectValue :placeholder="t('diagram.targetColumn')" />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem v-for="column in targetColumns" :key="`target-column-${column.name}`" :value="column.name">{{ column.name }}</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+
+            <Button variant="default" size="sm" class="h-8 px-2 text-xs" @click="addCustomRelationship">
+              <Plus class="mr-1 h-3.5 w-3.5" />
+              {{ t("diagram.addRelationship") }}
+            </Button>
+            <Button variant="ghost" size="icon" class="h-8 w-8" :title="t('common.close')" @click="showRelationshipPanel = false">
+              <X class="h-4 w-4" />
+            </Button>
+          </div>
+
+          <div v-if="customRelationships.length > 0" class="mt-2 flex flex-wrap gap-1.5">
+            <Badge v-for="relationship in customRelationships" :key="relationship.id" variant="secondary" class="gap-1 pr-1">
+              <span class="max-w-80 truncate">{{ relationship.sourceTable }}.{{ relationship.sourceColumn }} {{ relationship.sourceCardinality }}:{{ relationship.targetCardinality }} {{ relationship.targetTable }}.{{ relationship.targetColumn }}</span>
+              <button type="button" class="rounded-sm p-0.5 hover:bg-background/80" :title="t('diagram.removeRelationship')" @click="removeCustomRelationship(relationship.id)">
+                <Trash2 class="h-3 w-3" />
+              </button>
+            </Badge>
+          </div>
+        </div>
+
+        <div class="min-h-0 flex-1">
+          <div v-if="loadingDiagram" class="h-full flex items-center justify-center text-sm text-muted-foreground">
+            <Loader2 class="mr-2 h-4 w-4 animate-spin" />
+            {{ loadingText }}
+          </div>
+          <div v-else-if="!diagramReady" class="h-full flex items-center justify-center text-sm text-muted-foreground">
+            {{ t("diagram.selectTarget") }}
+          </div>
+          <div v-else-if="tables.length === 0" class="h-full flex items-center justify-center text-sm text-muted-foreground">
+            {{ t("diagram.empty") }}
+          </div>
+          <div v-else-if="visibleTables.length === 0" class="h-full flex items-center justify-center text-sm text-muted-foreground">
+            {{ t("diagram.noMatches") }}
+          </div>
+          <div v-else ref="diagramViewport" class="h-full overflow-auto" @wheel="onDiagramWheel" @gesturestart="onDiagramGestureStart" @gesturechange="onDiagramGestureChange">
+            <div
+              class="relative"
+              :style="{
+                width: `${activeCanvasSize.width * zoom}px`,
+                height: `${activeCanvasSize.height * zoom}px`,
+              }"
+            >
+              <div
+                class="absolute left-0 top-0 origin-top-left"
+                :style="{
+                  width: `${activeCanvasSize.width}px`,
+                  height: `${activeCanvasSize.height}px`,
+                  transform: `scale(${zoom})`,
+                }"
+              >
+                <template v-if="diagramMode === 'table'">
+                  <svg class="absolute inset-0 h-full w-full overflow-visible pointer-events-none">
+                    <defs>
+                      <marker id="diagram-arrow" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto" markerUnits="strokeWidth">
+                        <path d="M 0 0 L 8 4 L 0 8 z" class="fill-primary/70" />
+                      </marker>
+                    </defs>
+                    <path v-for="relationship in visibleRelationships" :key="relationship.id" :d="relationshipPath(relationship)" class="fill-none stroke-primary/55" stroke-width="1.6" marker-end="url(#diagram-arrow)">
+                      <title>{{ relationshipTitle(relationship) }}</title>
+                    </path>
+                  </svg>
+
+                  <div
+                    v-for="table in visibleTables"
+                    :key="table.name"
+                    class="absolute overflow-hidden rounded-md border bg-background shadow-sm"
+                    :class="table.name === focusTableName ? 'border-primary ring-1 ring-primary/30' : 'border-border'"
+                    :style="{
+                      width: `${CARD_WIDTH}px`,
+                      transform: `translate(${positions[table.name]?.x ?? 0}px, ${positions[table.name]?.y ?? 0}px)`,
+                    }"
+                    @dblclick.stop="openTableData(table.name)"
+                  >
+                    <div class="flex h-11 cursor-grab items-center gap-2 border-b bg-muted/40 px-3 active:cursor-grabbing" @mousedown="startDrag(table.name, $event)">
+                      <Table2 class="h-4 w-4 shrink-0 text-muted-foreground" />
+                      <span class="min-w-0 flex-1 truncate text-sm font-medium">{{ table.name }}</span>
+                      <Badge variant="outline" class="h-5 px-1.5 text-[10px]">{{ table.columns.length }}</Badge>
+                    </div>
+                    <div>
+                      <div v-for="column in visibleColumns(table)" :key="column.name" class="flex h-6 items-center gap-1.5 border-b border-border/40 px-3 text-xs last:border-b-0">
+                        <KeyRound v-if="column.is_primary_key" class="h-3 w-3 shrink-0 text-amber-500" />
+                        <Link2 v-else-if="isForeignKeyColumn(table, column.name)" class="h-3 w-3 shrink-0 text-primary" />
+                        <Link2 v-else-if="isRelationshipColumn(table, column.name)" class="h-3 w-3 shrink-0 text-muted-foreground" />
+                        <span v-else class="h-3 w-3 shrink-0" />
+                        <span class="min-w-0 flex-1 truncate font-mono">{{ column.name }}</span>
+                        <span class="max-w-24 truncate text-[10px] text-muted-foreground">{{ column.data_type }}</span>
+                      </div>
+                      <div v-if="hiddenColumnCount(table) > 0" class="h-6 px-3 text-xs leading-6 text-muted-foreground">
+                        {{ t("diagram.moreColumns", { count: hiddenColumnCount(table) }) }}
+                      </div>
+                    </div>
+                  </div>
+                </template>
+
+                <template v-else>
+                  <svg class="absolute inset-0 h-full w-full overflow-visible pointer-events-none">
+                    <g class="stroke-foreground/70">
+                      <line
+                        v-for="attribute in engineeringDiagram.attributes"
+                        :key="attribute.id"
+                        :x1="engineeringEntityCenter(attribute.tableName).x"
+                        :y1="engineeringEntityCenter(attribute.tableName).y"
+                        :x2="engineeringAttributeCenter(attribute).x"
+                        :y2="engineeringAttributeCenter(attribute).y"
+                        stroke-width="1.2"
+                      />
+                      <template v-for="relationship in engineeringDiagram.relationships" :key="relationship.id">
+                        <line :x1="engineeringEntityCenter(relationship.sourceTable).x" :y1="engineeringEntityCenter(relationship.sourceTable).y" :x2="engineeringRelationshipCenter(relationship).x" :y2="engineeringRelationshipCenter(relationship).y" stroke-width="1.4" />
+                        <line :x1="engineeringRelationshipCenter(relationship).x" :y1="engineeringRelationshipCenter(relationship).y" :x2="engineeringEntityCenter(relationship.targetTable).x" :y2="engineeringEntityCenter(relationship.targetTable).y" stroke-width="1.4" />
+                        <text
+                          class="fill-foreground text-[13px] font-semibold"
+                          :x="engineeringCardinalityPoint(engineeringRelationshipCenter(relationship), engineeringEntityCenter(relationship.sourceTable)).x"
+                          :y="engineeringCardinalityPoint(engineeringRelationshipCenter(relationship), engineeringEntityCenter(relationship.sourceTable)).y"
+                        >
+                          {{ relationship.sourceCardinality }}
+                        </text>
+                        <text
+                          class="fill-foreground text-[13px] font-semibold"
+                          :x="engineeringCardinalityPoint(engineeringRelationshipCenter(relationship), engineeringEntityCenter(relationship.targetTable)).x"
+                          :y="engineeringCardinalityPoint(engineeringRelationshipCenter(relationship), engineeringEntityCenter(relationship.targetTable)).y"
+                        >
+                          {{ relationship.targetCardinality }}
+                        </text>
+                      </template>
+                    </g>
+                  </svg>
+
+                  <div
+                    v-for="attribute in engineeringDiagram.attributes"
+                    :key="attribute.id"
+                    class="absolute flex items-center justify-center rounded-full border border-green-600/55 bg-green-100/80 px-3 text-center text-xs text-green-950 shadow-sm dark:bg-green-950/35 dark:text-green-100"
+                    :class="attribute.primaryKey ? 'font-semibold underline underline-offset-2' : ''"
+                    :title="`${attribute.tableName}.${attribute.columnName}: ${attribute.dataType}`"
+                    :style="{
+                      width: `${attribute.width}px`,
+                      height: `${attribute.height}px`,
+                      transform: `translate(${attribute.x}px, ${attribute.y}px)`,
+                    }"
+                  >
+                    <span class="truncate">{{ attribute.label }}</span>
+                  </div>
+
+                  <div
+                    v-for="relationship in engineeringDiagram.relationships"
+                    :key="relationship.id"
+                    class="absolute flex items-center justify-center text-center text-xs font-medium text-red-950 dark:text-red-100"
+                    :style="{
+                      width: `${relationship.width}px`,
+                      height: `${relationship.height}px`,
+                      transform: `translate(${relationship.x}px, ${relationship.y}px)`,
+                    }"
+                    :title="`${relationship.sourceTable} -> ${relationship.targetTable}`"
+                  >
+                    <div class="absolute inset-0 border border-red-500/70 bg-red-100/80 dark:bg-red-950/35" style="clip-path: polygon(50% 0, 100% 50%, 50% 100%, 0 50%)" />
+                    <span class="relative max-w-[70px] truncate">{{ relationship.label }}</span>
+                  </div>
+
+                  <div
+                    v-for="entity in engineeringDiagram.entities"
+                    :key="entity.id"
+                    class="absolute flex cursor-pointer items-center justify-center border border-blue-500/70 bg-blue-100/80 px-3 text-center text-sm font-semibold text-blue-950 shadow-sm dark:bg-blue-950/35 dark:text-blue-100"
+                    :class="entity.name === focusTableName ? 'ring-2 ring-primary/40' : ''"
+                    :style="{
+                      width: `${entity.width}px`,
+                      height: `${entity.height}px`,
+                      transform: `translate(${entity.x}px, ${entity.y}px)`,
+                    }"
+                    @dblclick.stop="openTableData(entity.name)"
+                  >
+                    <span class="truncate">{{ entity.name }}</span>
+                  </div>
+                </template>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/diff/DataCompareDialog.vue b/apps/desktop/src/components/diff/DataCompareDialog.vue
new file mode 100644
index 0000000..2b9f6cc
--- /dev/null
+++ b/apps/desktop/src/components/diff/DataCompareDialog.vue
@@ -0,0 +1,1285 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import SearchableSelect from "@/components/ui/searchable-select/SearchableSelect.vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useToast } from "@/composables/useToast";
+import { databaseOptionsForConnection } from "@/composables/useDatabaseOptions";
+import { isSchemaAware } from "@/lib/database/databaseCapabilities";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import type { DataCompareCellValue, DataCompareModifiedRow, DataCompareResult, DataCompareRow, DataCompareSyncPlan, DataCompareSyncPlanTableOptions } from "@/lib/dataGrid/dataCompare";
+import type { ColumnInfo, DatabaseType } from "@/types/database";
+import * as api from "@/lib/backend/api";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import { ArrowLeftRight, CheckSquare, ChevronDown, ChevronRight, Copy, GitCompareArrows, Loader2, Play, Square } from "@lucide/vue";
+
+type CompareColumn = ColumnInfo;
+
+interface DataCompareTableTask {
+  sourceTable: string;
+  targetTable: string;
+}
+
+type DataCompareTableStatus = "different" | "same" | "error";
+type DiffKind = "added" | "removed" | "modified";
+
+interface SelectableDataCompareRow extends DataCompareRow {
+  selected: boolean;
+}
+
+interface SelectableDataCompareModifiedRow extends DataCompareModifiedRow {
+  selected: boolean;
+}
+
+interface SelectableDataCompareResult {
+  added: SelectableDataCompareRow[];
+  removed: SelectableDataCompareRow[];
+  modified: SelectableDataCompareModifiedRow[];
+}
+
+interface DataCompareTableResult {
+  sourceTable: string;
+  targetTable: string;
+  keyColumns: string[];
+  columns: string[];
+  columnInfo: CompareColumn[];
+  status: DataCompareTableStatus;
+  added: number;
+  removed: number;
+  modified: number;
+  sourceRowCount: number;
+  targetRowCount: number;
+  sourceTruncated: boolean;
+  targetTruncated: boolean;
+  databaseType?: DatabaseType;
+  preSyncStatements?: string[];
+  diff: SelectableDataCompareResult;
+  expanded: boolean;
+  showAll: Record<DiffKind, boolean>;
+  error?: string;
+}
+
+const PREVIEW_LIMIT_OPTIONS = [50, 100, 200, 500];
+const SYNC_EXECUTE_BATCH_SIZE = 500;
+
+const { t } = useI18n();
+const { toast } = useToast();
+const store = useConnectionStore();
+const open = defineModel<boolean>("open", { default: false });
+
+const props = defineProps<{
+  prefillConnectionId?: string;
+  prefillDatabase?: string;
+  prefillSchema?: string;
+  prefillTable?: string;
+}>();
+
+const sourceConnectionId = ref("");
+const sourceDatabase = ref("");
+const sourceSchema = ref("");
+const sourceTable = ref("");
+const sourceDatabases = ref<string[]>([]);
+const sourceSchemas = ref<string[]>([]);
+const sourceTables = ref<string[]>([]);
+const sourceTableSearch = ref("");
+const selectedSourceTables = ref<Set<string>>(new Set());
+
+const targetConnectionId = ref("");
+const targetDatabase = ref("");
+const targetSchema = ref("");
+const targetTable = ref("");
+const targetDatabases = ref<string[]>([]);
+const targetSchemas = ref<string[]>([]);
+const targetTables = ref<string[]>([]);
+
+const keyColumnsText = ref("");
+const detailPreviewLimit = ref(String(PREVIEW_LIMIT_OPTIONS[1]));
+const batchResults = ref<DataCompareTableResult[]>([]);
+const syncPlan = ref<DataCompareSyncPlan>(emptySyncPlan());
+const comparing = ref(false);
+const planningSync = ref(false);
+const compareProgressCurrent = ref(0);
+const compareProgressTotal = ref(0);
+const compareProgressTable = ref("");
+const executing = ref(false);
+const executedCount = ref(0);
+const executeTotal = ref(0);
+const syncErrors = ref<{ sql: string; error: string }[]>([]);
+const showAdded = ref(true);
+const showRemoved = ref(true);
+const showModified = ref(true);
+
+let syncPlanRequestId = 0;
+
+const sqlConnections = computed(() => store.connections.filter((connection) => !["redis", "mongodb", "elasticsearch", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "mq", "nacos"].includes(connection.db_type)));
+const selectedSourceTableNames = computed(() => sourceTables.value.filter((table) => selectedSourceTables.value.has(table)));
+const isBatchCompare = computed(() => selectedSourceTableNames.value.length > 1);
+const filteredSourceTables = computed(() => {
+  const query = sourceTableSearch.value.trim().toLowerCase();
+  if (!query) return sourceTables.value;
+  return sourceTables.value.filter((table) => table.toLowerCase().includes(query));
+});
+const allFilteredTablesSelected = computed(() => filteredSourceTables.value.length > 0 && filteredSourceTables.value.every((table) => selectedSourceTables.value.has(table)));
+const compareTasksPreview = computed(() =>
+  selectedSourceTableNames.value.map((table) => {
+    const target = isBatchCompare.value ? table : targetTable.value || table;
+    const matched = !!target && targetTables.value.includes(target);
+    return {
+      sourceTable: table,
+      targetTable: target,
+      matched,
+    };
+  }),
+);
+const matchedTaskCount = computed(() => compareTasksPreview.value.filter((task) => task.matched).length);
+const missingTargetTables = computed(() => compareTasksPreview.value.filter((task) => !task.matched).map((task) => task.targetTable || task.sourceTable));
+const canCompare = computed(() => sourceConnectionId.value && sourceDatabase.value && sourceSchema.value && selectedSourceTableNames.value.length > 0 && targetConnectionId.value && targetDatabase.value && targetSchema.value);
+const keyColumns = computed(() =>
+  keyColumnsText.value
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean),
+);
+const detailPreviewLimitNumber = computed(() => Number(detailPreviewLimit.value) || PREVIEW_LIMIT_OPTIONS[1]);
+
+const sameTableCount = computed(() => batchResults.value.filter((item) => item.status === "same").length);
+const differentTableCount = computed(() => batchResults.value.filter((item) => item.status === "different").length);
+const failedTableCount = computed(() => batchResults.value.filter((item) => item.status === "error").length);
+const totalAdded = computed(() => batchResults.value.reduce((sum, item) => sum + item.added, 0));
+const totalRemoved = computed(() => batchResults.value.reduce((sum, item) => sum + item.removed, 0));
+const totalModified = computed(() => batchResults.value.reduce((sum, item) => sum + item.modified, 0));
+const hasResults = computed(() => batchResults.value.length > 0);
+const visibleKinds = computed(() => [...(showAdded.value ? (["added"] as DiffKind[]) : []), ...(showRemoved.value ? (["removed"] as DiffKind[]) : []), ...(showModified.value ? (["modified"] as DiffKind[]) : [])]);
+const selectedAddedCount = computed(() => selectedDiffCount("added"));
+const selectedRemovedCount = computed(() => selectedDiffCount("removed"));
+const selectedModifiedCount = computed(() => selectedDiffCount("modified"));
+const summary = computed(() => {
+  if (!hasResults.value) return "";
+  if (batchResults.value.length === 1 && batchResults.value[0]?.status !== "error") {
+    const item = batchResults.value[0];
+    return t("dataCompare.summary", {
+      added: item.added,
+      removed: item.removed,
+      modified: item.modified,
+    });
+  }
+  return t("dataCompare.batchSummary", {
+    tables: batchResults.value.length,
+    different: differentTableCount.value,
+    same: sameTableCount.value,
+    failed: failedTableCount.value,
+    added: totalAdded.value,
+    removed: totalRemoved.value,
+    modified: totalModified.value,
+  });
+});
+const selectedSummary = computed(() =>
+  t("dataCompare.selectedSummary", {
+    added: selectedAddedCount.value,
+    removed: selectedRemovedCount.value,
+    modified: selectedModifiedCount.value,
+  }),
+);
+const compareProgressLabel = computed(() => {
+  if (!comparing.value || compareProgressTotal.value === 0) return "";
+  return t("dataCompare.comparingTable", {
+    current: compareProgressCurrent.value,
+    total: compareProgressTotal.value,
+    table: compareProgressTable.value,
+  });
+});
+
+function emptySyncPlan(): DataCompareSyncPlan {
+  return {
+    insertCount: 0,
+    updateCount: 0,
+    deleteCount: 0,
+    statementCount: 0,
+    syncStatements: [],
+    syncSql: "",
+  };
+}
+
+function connectionIconType(connectionId: string) {
+  const config = store.getConfig(connectionId);
+  return config?.driver_profile || config?.db_type || "mysql";
+}
+
+function targetDatabaseType(): DatabaseType | undefined {
+  return store.getConfig(targetConnectionId.value)?.db_type;
+}
+
+function resetSelectedSourceTables(nextTables: Iterable<string>) {
+  selectedSourceTables.value = new Set(nextTables);
+}
+
+function toggleSourceTable(table: string) {
+  const next = new Set(selectedSourceTables.value);
+  if (next.has(table)) next.delete(table);
+  else next.add(table);
+  resetSelectedSourceTables(next);
+}
+
+function toggleSelectAllSourceTables() {
+  const next = new Set(selectedSourceTables.value);
+  if (allFilteredTablesSelected.value) {
+    filteredSourceTables.value.forEach((table) => next.delete(table));
+  } else {
+    filteredSourceTables.value.forEach((table) => next.add(table));
+  }
+  resetSelectedSourceTables(next);
+}
+
+function buildCompareTasks(): DataCompareTableTask[] {
+  if (!selectedSourceTableNames.value.length) return [];
+  if (!isBatchCompare.value) {
+    const table = selectedSourceTableNames.value[0];
+    return table ? [{ sourceTable: table, targetTable: targetTable.value || table }] : [];
+  }
+  return selectedSourceTableNames.value.map((table) => ({
+    sourceTable: table,
+    targetTable: table,
+  }));
+}
+
+function clearResult() {
+  batchResults.value = [];
+  syncPlan.value = emptySyncPlan();
+  syncErrors.value = [];
+  compareProgressCurrent.value = 0;
+  compareProgressTotal.value = 0;
+  compareProgressTable.value = "";
+  executedCount.value = 0;
+  executeTotal.value = 0;
+  syncPlanRequestId++;
+}
+
+function swapSourceTarget() {
+  const previousSelectedTables = [...selectedSourceTableNames.value];
+  const nextSingleTarget = previousSelectedTables.length === 1 ? (previousSelectedTables[0] ?? "") : "";
+  const nextSourceSelection = previousSelectedTables.length <= 1 ? [targetTable.value].filter(Boolean) : previousSelectedTables;
+
+  const tmpConnId = sourceConnectionId.value;
+  const tmpDb = sourceDatabase.value;
+  const tmpDbs = sourceDatabases.value;
+  const tmpSchema = sourceSchema.value;
+  const tmpSchemas = sourceSchemas.value;
+  const tmpTables = sourceTables.value;
+
+  sourceConnectionId.value = targetConnectionId.value;
+  sourceDatabase.value = targetDatabase.value;
+  sourceDatabases.value = targetDatabases.value;
+  sourceSchema.value = targetSchema.value;
+  sourceSchemas.value = targetSchemas.value;
+  sourceTables.value = targetTables.value;
+  resetSelectedSourceTables(nextSourceSelection.filter((table) => targetTables.value.includes(table)));
+
+  targetConnectionId.value = tmpConnId;
+  targetDatabase.value = tmpDb;
+  targetDatabases.value = tmpDbs;
+  targetSchema.value = tmpSchema;
+  targetSchemas.value = tmpSchemas;
+  targetTables.value = tmpTables;
+  targetTable.value = nextSingleTarget;
+
+  sourceTable.value = selectedSourceTableNames.value.length === 1 ? selectedSourceTableNames.value[0] : "";
+  clearResult();
+}
+
+async function resolveSchema(connectionId: string, database: string, preferredSchema = ""): Promise<string> {
+  const config = store.getConfig(connectionId);
+  if (isSchemaAware(config?.db_type)) {
+    const schemas = await api.listSchemas(connectionId, database);
+    if (preferredSchema && schemas.includes(preferredSchema)) return preferredSchema;
+    return schemas.includes("public") ? "public" : (schemas[0] ?? "");
+  }
+  return database;
+}
+
+async function loadSchemas(side: "source" | "target", preferredSchema = "") {
+  const connectionId = side === "source" ? sourceConnectionId.value : targetConnectionId.value;
+  const database = side === "source" ? sourceDatabase.value : targetDatabase.value;
+  if (!connectionId || !database) return;
+  const config = store.getConfig(connectionId);
+  if (!isSchemaAware(config?.db_type)) {
+    if (side === "source") {
+      sourceSchemas.value = [];
+      sourceSchema.value = database;
+    } else {
+      targetSchemas.value = [];
+      targetSchema.value = database;
+    }
+    await loadTables(side);
+    return;
+  }
+
+  const schemas = await api.listSchemas(connectionId, database);
+  const schema = preferredSchema && schemas.includes(preferredSchema) ? preferredSchema : schemas.includes("public") ? "public" : (schemas[0] ?? "");
+  if (side === "source") {
+    sourceSchemas.value = schemas;
+    sourceSchema.value = schema;
+  } else {
+    targetSchemas.value = schemas;
+    targetSchema.value = schema;
+  }
+}
+
+async function loadDatabases(connectionId: string, side: "source" | "target") {
+  if (!connectionId) return;
+  await store.ensureConnected(connectionId);
+  const names = databaseOptionsForConnection(
+    (await api.listDatabases(connectionId)).map((database) => database.name),
+    store.getConfig(connectionId),
+  );
+  if (side === "source") {
+    sourceDatabases.value = names;
+    sourceDatabase.value = names.length === 1 ? names[0] : "";
+    sourceSchemas.value = [];
+    sourceSchema.value = "";
+    sourceTables.value = [];
+    sourceTable.value = "";
+    resetSelectedSourceTables([]);
+  } else {
+    targetDatabases.value = names;
+    targetDatabase.value = names.length === 1 ? names[0] : "";
+    targetSchemas.value = [];
+    targetSchema.value = "";
+    targetTables.value = [];
+    targetTable.value = "";
+  }
+}
+
+async function loadTables(side: "source" | "target") {
+  const connectionId = side === "source" ? sourceConnectionId.value : targetConnectionId.value;
+  const database = side === "source" ? sourceDatabase.value : targetDatabase.value;
+  if (!connectionId || !database) return;
+  const schema = side === "source" ? sourceSchema.value || (await resolveSchema(connectionId, database, props.prefillSchema)) : targetSchema.value || (await resolveSchema(connectionId, database));
+  const tables = (await api.listTables(connectionId, database, schema)).filter((table) => table.table_type !== "VIEW" && table.table_type !== "MATERIALIZED_VIEW").map((table) => table.name);
+
+  if (side === "source") {
+    const preferredSelection = props.prefillTable && tables.includes(props.prefillTable) ? [props.prefillTable] : [...selectedSourceTables.value].filter((table) => tables.includes(table));
+    sourceSchema.value = schema;
+    sourceTables.value = tables;
+    resetSelectedSourceTables(preferredSelection);
+    sourceTable.value = preferredSelection.length === 1 ? preferredSelection[0] : "";
+  } else {
+    targetSchema.value = schema;
+    targetTables.value = tables;
+    const singleSourceTable = selectedSourceTableNames.value.length === 1 ? selectedSourceTableNames.value[0] : "";
+    const preferred = targetTable.value && tables.includes(targetTable.value) ? targetTable.value : singleSourceTable && tables.includes(singleSourceTable) ? singleSourceTable : "";
+    targetTable.value = preferred;
+  }
+}
+
+async function loadColumnsWithCache(cache: Map<string, CompareColumn[]>, connectionId: string, database: string, schema: string, table: string): Promise<CompareColumn[]> {
+  const key = `${connectionId}:${database}:${schema}:${table}`;
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const columns = (await api.getColumns(connectionId, database, schema, table)) as CompareColumn[];
+  cache.set(key, columns);
+  return columns;
+}
+
+async function inferKeyColumnsForTable(table: string, sourceColumnCache?: Map<string, CompareColumn[]>): Promise<string[]> {
+  if (!sourceConnectionId.value || !sourceDatabase.value || !sourceSchema.value || !table) return [];
+  const columns = sourceColumnCache ? await loadColumnsWithCache(sourceColumnCache, sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, table) : (((await api.getColumns(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, table)) as CompareColumn[]) ?? []);
+  const primaryKeys = columns.filter((column) => column.is_primary_key).map((column) => column.name);
+  if (primaryKeys.length > 0) return primaryKeys;
+  return columns.slice(0, 1).map((column) => column.name);
+}
+
+async function inferKeyColumns() {
+  const table = selectedSourceTableNames.value.length === 1 ? selectedSourceTableNames.value[0] : "";
+  if (!table) return;
+  const inferred = await inferKeyColumnsForTable(table);
+  keyColumnsText.value = inferred.join(", ");
+}
+
+function resultStatusLabel(status: DataCompareTableStatus): string {
+  if (status === "different") return t("dataCompare.statusDifferent");
+  if (status === "same") return t("dataCompare.statusSame");
+  return t("dataCompare.statusError");
+}
+
+function resultStatusClass(status: DataCompareTableStatus): string {
+  if (status === "different") return "bg-amber-500/15 text-amber-700";
+  if (status === "same") return "bg-emerald-500/15 text-emerald-700";
+  return "bg-destructive/15 text-destructive";
+}
+
+function toSelectableDiff(diff: DataCompareResult): SelectableDataCompareResult {
+  return {
+    added: diff.added.map((row) => ({ ...row, selected: true })),
+    removed: diff.removed.map((row) => ({ ...row, selected: true })),
+    modified: diff.modified.map((row) => ({ ...row, selected: true })),
+  };
+}
+
+function buildSelectedDiff(table: DataCompareTableResult): DataCompareResult {
+  return {
+    added: table.diff.added.filter((row) => row.selected).map(stripSelectedRow),
+    removed: table.diff.removed.filter((row) => row.selected).map(stripSelectedRow),
+    modified: table.diff.modified.filter((row) => row.selected).map(stripSelectedModifiedRow),
+  };
+}
+
+function stripSelectedRow(row: SelectableDataCompareRow): DataCompareRow {
+  const { selected: _selected, ...rest } = row;
+  return rest;
+}
+
+function stripSelectedModifiedRow(row: SelectableDataCompareModifiedRow): DataCompareModifiedRow {
+  const { selected: _selected, ...rest } = row;
+  return rest;
+}
+
+function hasDiffRows(table: DataCompareTableResult, kind: DiffKind): boolean {
+  return table.diff[kind].length > 0;
+}
+
+function selectedRows(table: DataCompareTableResult, kind: DiffKind): number {
+  return table.diff[kind].filter((row) => row.selected).length;
+}
+
+function rowsForDisplay(table: DataCompareTableResult, kind: DiffKind) {
+  const rows = table.diff[kind];
+  return table.showAll[kind] ? rows : rows.slice(0, detailPreviewLimitNumber.value);
+}
+
+function remainingRows(table: DataCompareTableResult, kind: DiffKind) {
+  return Math.max(0, table.diff[kind].length - rowsForDisplay(table, kind).length);
+}
+
+function toggleTableExpanded(table: DataCompareTableResult) {
+  table.expanded = !table.expanded;
+}
+
+function toggleShowAll(table: DataCompareTableResult, kind: DiffKind) {
+  table.showAll[kind] = !table.showAll[kind];
+}
+
+function setDiffSelection(kind: DiffKind, selected: boolean) {
+  batchResults.value.forEach((table) => {
+    table.diff[kind].forEach((row) => {
+      row.selected = selected;
+    });
+  });
+  rebuildSyncPlan().catch((e) => toast(String(e), 5000));
+}
+
+function setTableDiffSelection(table: DataCompareTableResult, kind: DiffKind, selected: boolean) {
+  table.diff[kind].forEach((row) => {
+    row.selected = selected;
+  });
+  rebuildSyncPlan().catch((e) => toast(String(e), 5000));
+}
+
+function clearAllSelections() {
+  (["added", "removed", "modified"] as DiffKind[]).forEach((kind) => {
+    batchResults.value.forEach((table) => {
+      table.diff[kind].forEach((row) => {
+        row.selected = false;
+      });
+    });
+  });
+  rebuildSyncPlan().catch((e) => toast(String(e), 5000));
+}
+
+function toggleRowSelection(row: SelectableDataCompareRow | SelectableDataCompareModifiedRow) {
+  row.selected = !row.selected;
+  rebuildSyncPlan().catch((e) => toast(String(e), 5000));
+}
+
+function selectedDiffCount(kind: DiffKind) {
+  return batchResults.value.reduce((sum, table) => sum + selectedRows(table, kind), 0);
+}
+
+function buildSyncPlanTables(): DataCompareSyncPlanTableOptions[] {
+  return batchResults.value
+    .filter((table) => table.status === "different")
+    .map((table) => ({
+      tableName: table.targetTable,
+      schema: targetSchema.value,
+      columns: table.columns,
+      keyColumns: table.keyColumns,
+      columnInfo: table.columnInfo,
+      diff: buildSelectedDiff(table),
+      databaseType: table.databaseType,
+      preSyncStatements: table.preSyncStatements ?? [],
+    }))
+    .filter((table) => table.preSyncStatements.length > 0 || table.diff.added.length > 0 || table.diff.removed.length > 0 || table.diff.modified.length > 0);
+}
+
+async function rebuildSyncPlan() {
+  const requestId = ++syncPlanRequestId;
+  const tables = buildSyncPlanTables();
+  if (tables.length === 0) {
+    syncPlan.value = emptySyncPlan();
+    planningSync.value = false;
+    return;
+  }
+  planningSync.value = true;
+  try {
+    const plan = await api.buildDataCompareSyncPlan({ tables });
+    if (requestId !== syncPlanRequestId) return;
+    syncPlan.value = plan;
+  } catch (e: any) {
+    if (requestId !== syncPlanRequestId) return;
+    syncPlan.value = emptySyncPlan();
+    toast(e?.message || String(e), 5000);
+  } finally {
+    if (requestId === syncPlanRequestId) planningSync.value = false;
+  }
+}
+
+async function startCompare() {
+  if (!canCompare.value || comparing.value) return;
+  const tasks = buildCompareTasks();
+  if (tasks.length === 0) {
+    toast(t("dataCompare.noComparableTables"), 5000);
+    return;
+  }
+
+  comparing.value = true;
+  clearResult();
+  compareProgressTotal.value = tasks.length;
+
+  const sourceColumnCache = new Map<string, CompareColumn[]>();
+  const targetColumnCache = new Map<string, CompareColumn[]>();
+  const results: DataCompareTableResult[] = [];
+  const currentTargetDatabaseType = targetDatabaseType();
+
+  try {
+    await Promise.all([store.ensureConnected(sourceConnectionId.value), store.ensureConnected(targetConnectionId.value)]);
+
+    for (const [index, task] of tasks.entries()) {
+      compareProgressCurrent.value = index + 1;
+      compareProgressTable.value = task.sourceTable;
+
+      try {
+        if (!targetTables.value.includes(task.targetTable)) {
+          const sourceColumns = await loadColumnsWithCache(sourceColumnCache, sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, task.sourceTable);
+          const resolvedKeys = keyColumns.value.length > 0 ? keyColumns.value : [];
+          const preparation = await api.prepareDataCompareMissingTarget({
+            sourceConnectionId: sourceConnectionId.value,
+            sourceDatabase: sourceDatabase.value,
+            sourceSchema: sourceSchema.value,
+            sourceTable: task.sourceTable,
+            targetConnectionId: targetConnectionId.value,
+            targetDatabase: targetDatabase.value,
+            targetSchema: targetSchema.value,
+            targetTable: task.targetTable,
+            keyColumns: resolvedKeys,
+          });
+          results.push({
+            sourceTable: task.sourceTable,
+            targetTable: task.targetTable,
+            keyColumns: resolvedKeys,
+            columns: sourceColumns.map((column) => column.name),
+            columnInfo: sourceColumns,
+            status: "different",
+            added: preparation.result.added.length,
+            removed: 0,
+            modified: 0,
+            sourceRowCount: preparation.sourceRowCount,
+            targetRowCount: 0,
+            sourceTruncated: preparation.sourceTruncated,
+            targetTruncated: false,
+            databaseType: currentTargetDatabaseType,
+            preSyncStatements: preparation.preSyncStatements,
+            diff: toSelectableDiff(preparation.result),
+            expanded: preparation.result.added.length > 0,
+            showAll: {
+              added: false,
+              removed: false,
+              modified: false,
+            },
+          });
+          continue;
+        }
+
+        const resolvedKeys = keyColumns.value.length > 0 ? keyColumns.value : await inferKeyColumnsForTable(task.sourceTable, sourceColumnCache);
+        if (resolvedKeys.length === 0) {
+          throw new Error(t("dataCompare.noKeyColumns"));
+        }
+
+        const sourceColumns = await loadColumnsWithCache(sourceColumnCache, sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, task.sourceTable);
+        const targetColumns = await loadColumnsWithCache(targetColumnCache, targetConnectionId.value, targetDatabase.value, targetSchema.value, task.targetTable);
+        const columns = sourceColumns.map((column) => column.name).filter((column) => targetColumns.some((target) => target.name === column));
+        const columnInfo = columns.map((column) => targetColumns.find((target) => target.name === column)).filter((column): column is CompareColumn => !!column);
+        const missingKeys = resolvedKeys.filter((column) => !columns.includes(column));
+        if (missingKeys.length > 0) {
+          throw new Error(t("dataCompare.missingKeyColumns", { columns: missingKeys.join(", ") }));
+        }
+        if (columns.length === 0) {
+          throw new Error(t("dataCompare.noCommonColumns"));
+        }
+
+        const preparation = await api.prepareDataCompareFromTables({
+          sourceConnectionId: sourceConnectionId.value,
+          sourceDatabase: sourceDatabase.value,
+          sourceSchema: sourceSchema.value,
+          sourceTable: task.sourceTable,
+          targetConnectionId: targetConnectionId.value,
+          targetDatabase: targetDatabase.value,
+          targetSchema: targetSchema.value,
+          targetTable: task.targetTable,
+          columns,
+          keyColumns: resolvedKeys,
+        });
+
+        const added = preparation.result.added.length;
+        const removed = preparation.result.removed.length;
+        const modified = preparation.result.modified.length;
+        const status: DataCompareTableStatus = added || removed || modified ? "different" : "same";
+
+        results.push({
+          sourceTable: task.sourceTable,
+          targetTable: task.targetTable,
+          keyColumns: resolvedKeys,
+          columns,
+          columnInfo,
+          status,
+          added,
+          removed,
+          modified,
+          sourceRowCount: preparation.sourceRowCount,
+          targetRowCount: preparation.targetRowCount,
+          sourceTruncated: preparation.sourceTruncated,
+          targetTruncated: preparation.targetTruncated,
+          databaseType: currentTargetDatabaseType,
+          diff: toSelectableDiff(preparation.result),
+          expanded: status === "different",
+          showAll: {
+            added: false,
+            removed: false,
+            modified: false,
+          },
+        });
+      } catch (e: any) {
+        results.push({
+          sourceTable: task.sourceTable,
+          targetTable: task.targetTable,
+          keyColumns: keyColumns.value,
+          columns: [],
+          columnInfo: [],
+          status: "error",
+          added: 0,
+          removed: 0,
+          modified: 0,
+          sourceRowCount: 0,
+          targetRowCount: 0,
+          sourceTruncated: false,
+          targetTruncated: false,
+          databaseType: currentTargetDatabaseType,
+          preSyncStatements: [],
+          diff: { added: [], removed: [], modified: [] },
+          expanded: false,
+          showAll: {
+            added: false,
+            removed: false,
+            modified: false,
+          },
+          error: e?.message || String(e),
+        });
+      }
+    }
+
+    batchResults.value = results;
+    await rebuildSyncPlan();
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    comparing.value = false;
+    compareProgressCurrent.value = 0;
+    compareProgressTotal.value = 0;
+    compareProgressTable.value = "";
+  }
+}
+
+async function copySql() {
+  try {
+    await copyToClipboard(syncPlan.value.syncSql);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function executeSql() {
+  if (!syncPlan.value.syncSql.trim() || syncPlan.value.syncStatements.length === 0 || executing.value) return;
+  const targetConnection = store.getConfig(targetConnectionId.value);
+  try {
+    const failed = await executeWithProductionSqlGuard({
+      connection: targetConnection,
+      database: targetDatabase.value,
+      sql: syncPlan.value.syncSql,
+      source: t("production.sourceDataCompare"),
+      execute: async () => {
+        executing.value = true;
+        syncErrors.value = [];
+        executeTotal.value = syncPlan.value.syncStatements.length;
+        executedCount.value = 0;
+        await store.ensureConnected(targetConnectionId.value);
+        const statements = syncPlan.value.syncStatements;
+        for (let index = 0; index < statements.length; index += SYNC_EXECUTE_BATCH_SIZE) {
+          const batch = statements.slice(index, index + SYNC_EXECUTE_BATCH_SIZE);
+          try {
+            await api.executeBatch(targetConnectionId.value, targetDatabase.value, batch, targetSchema.value);
+            executedCount.value += batch.length;
+          } catch (e: any) {
+            for (const stmt of batch) {
+              try {
+                await api.executeBatch(targetConnectionId.value, targetDatabase.value, [stmt], targetSchema.value);
+              } catch (singleError: any) {
+                syncErrors.value.push({ sql: stmt, error: singleError?.message || String(singleError) });
+              }
+              executedCount.value++;
+            }
+          }
+        }
+        return syncErrors.value.length;
+      },
+    });
+    if (failed === undefined) return;
+    if (failed === 0) {
+      toast(t("dataCompare.syncSuccess"), 2000);
+    } else {
+      toast(t("diff.syncSummary", { success: syncPlan.value.syncStatements.length - failed, failed }), 5000);
+    }
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    executing.value = false;
+  }
+}
+
+function formatValue(value: DataCompareCellValue): string {
+  if (value == null) return "NULL";
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
+function truncateText(text: string, limit = 160): string {
+  return text.length > limit ? `${text.slice(0, limit - 3)}...` : text;
+}
+
+function formatKeyValues(values: Record<string, DataCompareCellValue>): string {
+  return Object.entries(values)
+    .map(([column, value]) => `${column}=${formatValue(value)}`)
+    .join(", ");
+}
+
+function formatRowValues(values: Record<string, DataCompareCellValue>): string {
+  return truncateText(
+    Object.entries(values)
+      .map(([column, value]) => `${column}=${formatValue(value)}`)
+      .join(", "),
+  );
+}
+
+function formatModifiedSummary(row: SelectableDataCompareModifiedRow): string {
+  return truncateText(row.changes.map((change) => `${change.column}: ${formatValue(change.target)} -> ${formatValue(change.source)}`).join(", "), 220);
+}
+
+watch(sourceConnectionId, (id) => {
+  clearResult();
+  sourceDatabase.value = "";
+  sourceSchema.value = "";
+  sourceSchemas.value = [];
+  sourceTables.value = [];
+  sourceTable.value = "";
+  sourceTableSearch.value = "";
+  resetSelectedSourceTables([]);
+  loadDatabases(id, "source").catch((e) => toast(String(e), 5000));
+});
+watch(targetConnectionId, (id) => {
+  clearResult();
+  targetDatabase.value = "";
+  targetSchema.value = "";
+  targetSchemas.value = [];
+  targetTables.value = [];
+  targetTable.value = "";
+  loadDatabases(id, "target").catch((e) => toast(String(e), 5000));
+});
+watch(sourceDatabase, () => {
+  clearResult();
+  sourceSchema.value = "";
+  sourceSchemas.value = [];
+  sourceTables.value = [];
+  sourceTable.value = "";
+  sourceTableSearch.value = "";
+  resetSelectedSourceTables([]);
+  loadSchemas("source", props.prefillSchema).catch((e) => toast(String(e), 5000));
+});
+watch(targetDatabase, () => {
+  clearResult();
+  targetSchema.value = "";
+  targetSchemas.value = [];
+  targetTables.value = [];
+  targetTable.value = "";
+  loadSchemas("target").catch((e) => toast(String(e), 5000));
+});
+watch(sourceSchema, () => {
+  clearResult();
+  sourceTables.value = [];
+  sourceTable.value = "";
+  sourceTableSearch.value = "";
+  resetSelectedSourceTables([]);
+  if (sourceSchema.value) loadTables("source").catch((e) => toast(String(e), 5000));
+});
+watch(targetSchema, () => {
+  clearResult();
+  targetTables.value = [];
+  targetTable.value = "";
+  if (targetSchema.value) loadTables("target").catch((e) => toast(String(e), 5000));
+});
+watch(selectedSourceTableNames, (tables, previous) => {
+  clearResult();
+  sourceTable.value = tables.length === 1 ? tables[0] : "";
+  if (tables.length !== 1) {
+    keyColumnsText.value = "";
+    return;
+  }
+  const table = tables[0];
+  if (targetTables.value.includes(table)) {
+    targetTable.value = table;
+  } else if (previous?.length === 1 && targetTable.value === previous[0]) {
+    targetTable.value = "";
+  }
+  if (table !== previous?.[0]) {
+    keyColumnsText.value = "";
+  }
+  inferKeyColumns().catch(() => {});
+});
+watch(targetTable, () => clearResult());
+watch(
+  open,
+  async (value) => {
+    if (!value) return;
+    clearResult();
+    if (props.prefillConnectionId) {
+      sourceConnectionId.value = props.prefillConnectionId;
+      await loadDatabases(props.prefillConnectionId, "source");
+      if (props.prefillDatabase) sourceDatabase.value = props.prefillDatabase;
+      if (props.prefillDatabase) await loadSchemas("source", props.prefillSchema);
+      if (props.prefillTable) {
+        await loadTables("source");
+        if (sourceTables.value.includes(props.prefillTable)) {
+          resetSelectedSourceTables([props.prefillTable]);
+          sourceTable.value = props.prefillTable;
+        }
+      }
+    }
+  },
+  { immediate: true },
+);
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent class="sm:max-w-5xl max-h-[85vh] flex flex-col overflow-hidden" @interact-outside.prevent>
+      <DialogHeader>
+        <DialogTitle class="flex items-center gap-2">
+          <GitCompareArrows class="w-4 h-4" />
+          {{ t("dataCompare.title") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="flex-1 min-h-0 overflow-auto space-y-4 py-2">
+        <div class="grid grid-cols-[1fr_auto_1fr] gap-4 items-start">
+          <div class="space-y-2">
+            <Label class="text-xs font-medium">{{ t("diff.source") }}</Label>
+            <SearchableSelect
+              v-model="sourceConnectionId"
+              :options="sqlConnections.map((c) => c.id)"
+              :placeholder="t('diff.selectConnection')"
+              :search-placeholder="t('diff.searchConnection')"
+              :empty-text="t('common.noResults')"
+              :display-name="(id) => sqlConnections.find((c) => c.id === id)?.name ?? id"
+              trigger-variant="outline"
+              trigger-class="h-8 w-full justify-between text-xs"
+              content-class="w-[var(--reka-popover-trigger-width)]"
+            >
+              <template #option-label="{ option, label }">
+                <div class="flex items-center gap-2">
+                  <DatabaseIcon :db-type="connectionIconType(option)" class="w-3.5 h-3.5" />
+                  {{ label }}
+                </div>
+              </template>
+            </SearchableSelect>
+            <SearchableSelect
+              v-model="sourceDatabase"
+              :options="sourceDatabases"
+              :placeholder="t('diff.selectDatabase')"
+              :search-placeholder="t('diff.searchDatabase')"
+              :empty-text="t('common.noResults')"
+              :disabled="!sourceDatabases.length"
+              trigger-variant="outline"
+              trigger-class="h-8 w-full justify-between text-xs"
+              content-class="w-[var(--reka-popover-trigger-width)]"
+            />
+            <SearchableSelect
+              v-if="sourceSchemas.length"
+              v-model="sourceSchema"
+              :options="sourceSchemas"
+              :placeholder="t('diff.selectSchema')"
+              :search-placeholder="t('diff.searchSchema')"
+              :empty-text="t('common.noResults')"
+              trigger-variant="outline"
+              trigger-class="h-8 w-full justify-between text-xs"
+              content-class="w-[var(--reka-popover-trigger-width)]"
+            />
+
+            <div class="space-y-2 rounded-lg border p-2">
+              <div class="flex items-center justify-between gap-2">
+                <Label class="text-xs font-medium">{{ t("dataCompare.sourceTables") }}</Label>
+                <div v-if="sourceTables.length" class="text-[11px] text-muted-foreground">
+                  {{
+                    t("dataCompare.selectedTables", {
+                      selected: selectedSourceTableNames.length,
+                      total: sourceTables.length,
+                    })
+                  }}
+                </div>
+              </div>
+
+              <Input v-if="sourceTables.length > 5" v-model="sourceTableSearch" class="h-7 text-xs" :placeholder="t('dataCompare.searchTables')" />
+
+              <div class="flex items-center gap-2">
+                <Button v-if="sourceTables.length" variant="outline" size="sm" class="h-7 px-2 text-xs" @click="toggleSelectAllSourceTables">
+                  {{ allFilteredTablesSelected ? t("dataCompare.deselectAllTables") : t("dataCompare.selectAllTables") }}
+                </Button>
+              </div>
+
+              <div v-if="!sourceConnectionId || !sourceDatabase" class="text-xs text-muted-foreground py-3 text-center">
+                {{ t("dataCompare.selectSourceTables") }}
+              </div>
+              <div v-else-if="sourceTables.length === 0" class="text-xs text-muted-foreground py-3 text-center">
+                {{ t("dataCompare.noTables") }}
+              </div>
+              <div v-else class="max-h-40 overflow-auto rounded border">
+                <button v-for="table in filteredSourceTables" :key="table" type="button" class="flex w-full items-center gap-2 px-2.5 py-1.5 text-left text-xs hover:bg-muted/50" @click="toggleSourceTable(table)">
+                  <CheckSquare v-if="selectedSourceTables.has(table)" class="w-3.5 h-3.5 text-primary shrink-0" />
+                  <Square v-else class="w-3.5 h-3.5 text-muted-foreground/40 shrink-0" />
+                  <span class="truncate">{{ table }}</span>
+                </button>
+              </div>
+            </div>
+          </div>
+
+          <div class="flex items-center pt-6">
+            <Button variant="ghost" size="icon" class="h-7 w-7" :title="t('diff.swap')" @click="swapSourceTarget">
+              <ArrowLeftRight class="w-3.5 h-3.5" />
+            </Button>
+          </div>
+
+          <div class="space-y-2">
+            <Label class="text-xs font-medium">{{ t("diff.target") }}</Label>
+            <SearchableSelect
+              v-model="targetConnectionId"
+              :options="sqlConnections.map((c) => c.id)"
+              :placeholder="t('diff.selectConnection')"
+              :search-placeholder="t('diff.searchConnection')"
+              :empty-text="t('common.noResults')"
+              :display-name="(id) => sqlConnections.find((c) => c.id === id)?.name ?? id"
+              trigger-variant="outline"
+              trigger-class="h-8 w-full justify-between text-xs"
+              content-class="w-[var(--reka-popover-trigger-width)]"
+            >
+              <template #option-label="{ option, label }">
+                <div class="flex items-center gap-2">
+                  <DatabaseIcon :db-type="connectionIconType(option)" class="w-3.5 h-3.5" />
+                  {{ label }}
+                </div>
+              </template>
+            </SearchableSelect>
+            <SearchableSelect
+              v-model="targetDatabase"
+              :options="targetDatabases"
+              :placeholder="t('diff.selectDatabase')"
+              :search-placeholder="t('diff.searchDatabase')"
+              :empty-text="t('common.noResults')"
+              :disabled="!targetDatabases.length"
+              trigger-variant="outline"
+              trigger-class="h-8 w-full justify-between text-xs"
+              content-class="w-[var(--reka-popover-trigger-width)]"
+            />
+            <SearchableSelect
+              v-if="targetSchemas.length"
+              v-model="targetSchema"
+              :options="targetSchemas"
+              :placeholder="t('diff.selectSchema')"
+              :search-placeholder="t('diff.searchSchema')"
+              :empty-text="t('common.noResults')"
+              trigger-variant="outline"
+              trigger-class="h-8 w-full justify-between text-xs"
+              content-class="w-[var(--reka-popover-trigger-width)]"
+            />
+
+            <div v-if="!isBatchCompare" class="space-y-1">
+              <Label class="text-xs font-medium">{{ t("dataCompare.targetTable") }}</Label>
+              <SearchableSelect
+                v-model="targetTable"
+                :options="targetTables"
+                :placeholder="t('dataCompare.selectTable')"
+                :search-placeholder="t('dataCompare.searchTable')"
+                :empty-text="t('common.noResults')"
+                trigger-variant="outline"
+                trigger-class="h-8 w-full justify-between text-xs"
+                content-class="w-[var(--reka-popover-trigger-width)]"
+              />
+            </div>
+            <div v-else class="space-y-2 rounded-lg border p-3 text-xs">
+              <div class="font-medium">{{ t("dataCompare.autoMatchHint") }}</div>
+              <div class="text-muted-foreground">
+                {{ t("dataCompare.matchedTables", { matched: matchedTaskCount, total: selectedSourceTableNames.length }) }}
+              </div>
+              <div v-if="missingTargetTables.length" class="text-destructive">
+                {{ t("dataCompare.missingTargetTables", { tables: missingTargetTables.join(", ") }) }}
+              </div>
+              <div v-if="compareTasksPreview.length" class="max-h-36 overflow-auto rounded border bg-muted/20">
+                <div v-for="task in compareTasksPreview" :key="`${task.sourceTable}:${task.targetTable}`" class="flex items-center justify-between gap-2 border-b px-2 py-1 last:border-b-0">
+                  <span class="truncate font-mono">{{ task.sourceTable }}</span>
+                  <span class="text-muted-foreground">→</span>
+                  <span class="truncate font-mono" :class="task.matched ? '' : 'text-destructive'">
+                    {{ task.targetTable || t("dataCompare.targetTableMissing", { table: task.sourceTable }) }}
+                  </span>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <div class="space-y-1">
+          <Label class="text-xs font-medium">{{ t("dataCompare.keyColumns") }}</Label>
+          <Input v-model="keyColumnsText" class="h-8 text-xs" :placeholder="t('dataCompare.keyColumnsPlaceholder')" />
+          <div class="text-[11px] text-muted-foreground">
+            {{ t("dataCompare.keyColumnsAutoHint") }}
+          </div>
+        </div>
+
+        <div v-if="hasResults" class="space-y-3">
+          <div class="rounded-lg border p-3 text-sm space-y-2">
+            <div>{{ summary }}</div>
+            <div class="text-xs text-muted-foreground">{{ selectedSummary }}</div>
+          </div>
+
+          <div class="rounded-lg border p-3 space-y-3">
+            <div class="flex flex-wrap items-center gap-2">
+              <Button size="sm" variant="outline" class="h-7 text-xs" :class="showAdded ? 'border-primary' : ''" @click="showAdded = !showAdded"> {{ t("diff.added") }} · {{ totalAdded }} </Button>
+              <Button size="sm" variant="outline" class="h-7 text-xs" :class="showRemoved ? 'border-primary' : ''" @click="showRemoved = !showRemoved"> {{ t("diff.removed") }} · {{ totalRemoved }} </Button>
+              <Button size="sm" variant="outline" class="h-7 text-xs" :class="showModified ? 'border-primary' : ''" @click="showModified = !showModified"> {{ t("diff.modified") }} · {{ totalModified }} </Button>
+              <span class="flex-1" />
+              <Select v-model="detailPreviewLimit">
+                <SelectTrigger class="h-7 w-32 text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem v-for="limit in PREVIEW_LIMIT_OPTIONS" :key="limit" :value="String(limit)">
+                    {{ t("dataCompare.previewLimitOption", { count: limit }) }}
+                  </SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+
+            <div class="flex flex-wrap items-center gap-2">
+              <Button size="sm" variant="outline" class="h-7 text-xs" @click="setDiffSelection('added', true)">
+                {{ t("dataCompare.selectAllKind", { kind: t("diff.added") }) }}
+              </Button>
+              <Button size="sm" variant="outline" class="h-7 text-xs" @click="setDiffSelection('removed', true)">
+                {{ t("dataCompare.selectAllKind", { kind: t("diff.removed") }) }}
+              </Button>
+              <Button size="sm" variant="outline" class="h-7 text-xs" @click="setDiffSelection('modified', true)">
+                {{ t("dataCompare.selectAllKind", { kind: t("diff.modified") }) }}
+              </Button>
+              <Button size="sm" variant="outline" class="h-7 text-xs" @click="clearAllSelections">
+                {{ t("dataCompare.clearSelection") }}
+              </Button>
+            </div>
+          </div>
+
+          <div class="rounded-lg border overflow-hidden">
+            <div class="max-h-64 overflow-auto">
+              <table class="w-full text-xs">
+                <thead class="bg-muted sticky top-0 z-10">
+                  <tr>
+                    <th class="px-3 py-2 text-left font-medium">{{ t("diff.table") }}</th>
+                    <th class="px-3 py-2 text-left font-medium">{{ t("dataCompare.targetTable") }}</th>
+                    <th class="px-3 py-2 text-left font-medium">{{ t("diff.status") }}</th>
+                    <th class="px-3 py-2 text-left font-medium">{{ t("diff.details") }}</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  <tr v-for="item in batchResults" :key="`${item.sourceTable}:${item.targetTable}`" class="border-t">
+                    <td class="px-3 py-2 align-top font-mono">{{ item.sourceTable }}</td>
+                    <td class="px-3 py-2 align-top font-mono text-muted-foreground">{{ item.targetTable }}</td>
+                    <td class="px-3 py-2 align-top">
+                      <span class="inline-flex rounded px-2 py-0.5 text-[11px]" :class="resultStatusClass(item.status)">
+                        {{ resultStatusLabel(item.status) }}
+                      </span>
+                    </td>
+                    <td class="px-3 py-2 align-top text-muted-foreground">
+                      <div v-if="item.status === 'error'" class="text-destructive">{{ item.error }}</div>
+                      <template v-else>
+                        <div>
+                          {{
+                            t("dataCompare.summary", {
+                              added: item.added,
+                              removed: item.removed,
+                              modified: item.modified,
+                            })
+                          }}
+                        </div>
+                        <div class="mt-1">
+                          {{
+                            t("dataCompare.rowCounts", {
+                              source: item.sourceRowCount,
+                              target: item.targetRowCount,
+                            })
+                          }}
+                        </div>
+                        <div class="mt-1">
+                          {{ t("dataCompare.keyColumnsInline", { columns: item.keyColumns.join(", ") }) }}
+                        </div>
+                        <div v-if="item.status === 'different'" class="mt-1">
+                          {{
+                            t("dataCompare.selectedInline", {
+                              selected: selectedRows(item, "added") + selectedRows(item, "removed") + selectedRows(item, "modified"),
+                              total: item.added + item.removed + item.modified,
+                            })
+                          }}
+                        </div>
+                      </template>
+                    </td>
+                  </tr>
+                </tbody>
+              </table>
+            </div>
+          </div>
+
+          <div class="space-y-3">
+            <div v-for="item in batchResults.filter((entry) => entry.status === 'different')" :key="`details-${item.sourceTable}:${item.targetTable}`" class="rounded-lg border overflow-hidden">
+              <button type="button" class="flex w-full items-center gap-2 border-b bg-muted/30 px-3 py-2 text-left text-sm font-medium" @click="toggleTableExpanded(item)">
+                <ChevronDown v-if="item.expanded" class="h-4 w-4 shrink-0" />
+                <ChevronRight v-else class="h-4 w-4 shrink-0" />
+                <span class="font-mono">{{ item.sourceTable }}</span>
+                <span class="text-muted-foreground">→</span>
+                <span class="font-mono text-muted-foreground">{{ item.targetTable }}</span>
+              </button>
+
+              <div v-if="item.expanded" class="space-y-3 p-3">
+                <div v-for="kind in visibleKinds" :key="`${item.sourceTable}:${kind}`" class="rounded-lg border" v-show="hasDiffRows(item, kind)">
+                  <div class="flex flex-wrap items-center gap-2 border-b bg-muted/20 px-3 py-2 text-xs">
+                    <span class="font-medium">{{ t(`diff.${kind}`) }}</span>
+                    <span class="text-muted-foreground">{{ selectedRows(item, kind) }}/{{ item.diff[kind].length }}</span>
+                    <span class="flex-1" />
+                    <Button size="sm" variant="ghost" class="h-6 px-2 text-xs" @click="setTableDiffSelection(item, kind, true)">
+                      {{ t("dataCompare.selectAllKind", { kind: t(`diff.${kind}`) }) }}
+                    </Button>
+                    <Button size="sm" variant="ghost" class="h-6 px-2 text-xs" @click="setTableDiffSelection(item, kind, false)">
+                      {{ t("dataCompare.clearKind", { kind: t(`diff.${kind}`) }) }}
+                    </Button>
+                    <Button v-if="item.diff[kind].length > detailPreviewLimitNumber" size="sm" variant="ghost" class="h-6 px-2 text-xs" @click="toggleShowAll(item, kind)">
+                      {{ item.showAll[kind] ? t("dataCompare.showLessRows") : t("dataCompare.showAllRows", { count: item.diff[kind].length }) }}
+                    </Button>
+                  </div>
+
+                  <div class="max-h-72 overflow-auto divide-y">
+                    <button v-for="row in rowsForDisplay(item, kind)" :key="`${item.sourceTable}:${kind}:${row.key}`" type="button" class="flex w-full items-start gap-3 px-3 py-2 text-left text-xs hover:bg-muted/40" @click="toggleRowSelection(row)">
+                      <CheckSquare v-if="row.selected" class="mt-0.5 h-3.5 w-3.5 shrink-0 text-primary" />
+                      <Square v-else class="mt-0.5 h-3.5 w-3.5 shrink-0 text-muted-foreground/40" />
+                      <div class="min-w-0 flex-1">
+                        <div class="font-mono">{{ formatKeyValues(row.keyValues) }}</div>
+                        <div class="mt-1 text-muted-foreground break-words">
+                          {{ kind === "modified" ? formatModifiedSummary(row as SelectableDataCompareModifiedRow) : formatRowValues((row as SelectableDataCompareRow).values) }}
+                        </div>
+                      </div>
+                    </button>
+                  </div>
+
+                  <div v-if="remainingRows(item, kind) > 0 && !item.showAll[kind]" class="border-t px-3 py-2 text-xs text-muted-foreground">
+                    {{ t("dataCompare.remainingRows", { count: remainingRows(item, kind) }) }}
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+
+          <div v-if="planningSync" class="text-sm text-muted-foreground">
+            {{ t("dataCompare.planningSync") }}
+          </div>
+          <div v-else-if="syncPlan.syncSql.trim()" class="space-y-1">
+            <Label class="text-xs font-medium">{{ t("diff.generatedSql") }}</Label>
+            <textarea :value="syncPlan.syncSql" readonly class="w-full h-48 rounded-[6px] border bg-muted/20 p-3 font-mono text-xs resize-none focus:outline-none focus:ring-1 focus:ring-ring" />
+          </div>
+          <div v-else-if="differentTableCount === 0 && failedTableCount === 0" class="text-sm text-muted-foreground">
+            {{ t("dataCompare.noDifferences") }}
+          </div>
+          <div v-else class="text-sm text-muted-foreground">
+            {{ t("dataCompare.noSelectedDifferences") }}
+          </div>
+        </div>
+
+        <div v-if="syncErrors.length > 0" class="space-y-1">
+          <Label class="text-xs font-medium text-destructive">
+            {{ t("diff.syncSummary", { success: executeTotal - syncErrors.length, failed: syncErrors.length }) }}
+          </Label>
+          <div class="max-h-32 overflow-auto border rounded-lg bg-destructive/5 p-2 space-y-1">
+            <div v-for="(err, i) in syncErrors" :key="i" class="text-xs font-mono">
+              <span class="text-destructive">{{ err.error }}</span>
+              <span class="text-muted-foreground ml-1">— {{ err.sql.slice(0, 80) }}{{ err.sql.length > 80 ? "..." : "" }}</span>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <DialogFooter v-if="!hasResults">
+        <Button variant="outline" @click="open = false">{{ t("common.close") }}</Button>
+        <span v-if="compareProgressLabel" class="text-xs text-muted-foreground self-center">{{ compareProgressLabel }}</span>
+        <Button size="sm" :disabled="!canCompare || comparing" @click="startCompare">
+          <Loader2 v-if="comparing" class="w-3.5 h-3.5 animate-spin mr-1" />
+          <GitCompareArrows v-else class="w-3.5 h-3.5 mr-1" />
+          {{ t("dataCompare.compare") }}
+        </Button>
+      </DialogFooter>
+
+      <DialogFooter v-else class="flex items-center gap-2">
+        <Button variant="outline" @click="open = false">{{ t("common.close") }}</Button>
+        <span v-if="executing" class="text-xs text-muted-foreground mr-auto">
+          {{ t("diff.syncProgress", { current: executedCount, total: executeTotal }) }}
+        </span>
+        <span v-else-if="planningSync" class="text-xs text-muted-foreground mr-auto">
+          {{ t("dataCompare.planningSync") }}
+        </span>
+        <span v-else class="text-xs text-muted-foreground mr-auto">
+          {{
+            t("dataCompare.planSummary", {
+              inserts: syncPlan.insertCount,
+              updates: syncPlan.updateCount,
+              deletes: syncPlan.deleteCount,
+              statements: syncPlan.statementCount,
+            })
+          }}
+        </span>
+        <Button variant="outline" size="sm" :disabled="!syncPlan.syncSql.trim()" @click="copySql"> <Copy class="w-3 h-3 mr-1" /> {{ t("diff.copySql") }} </Button>
+        <Button size="sm" :disabled="planningSync || executing || syncPlan.statementCount === 0" @click="executeSql">
+          <Loader2 v-if="executing" class="w-3 h-3 animate-spin mr-1" />
+          <Play v-else class="w-3 h-3 mr-1" />
+          {{ t("diff.executeSync") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/diff/DiffHunkBuilder.ts b/apps/desktop/src/components/diff/DiffHunkBuilder.ts
new file mode 100644
index 0000000..3aed892
--- /dev/null
+++ b/apps/desktop/src/components/diff/DiffHunkBuilder.ts
@@ -0,0 +1,297 @@
+import { diffLines, type Change } from "diff";
+
+export type HunkType = "equal" | "delete" | "insert" | "modify";
+
+export interface DiffLine {
+  type: HunkType;
+  content: string;
+  lineNumber: number | null;
+  isPadding: boolean;
+}
+
+export interface DiffHunk {
+  id: string;
+  type: HunkType;
+  leftLines: DiffLine[];
+  rightLines: DiffLine[];
+  // Measured pixel positions after rendering
+  leftTop: number;
+  leftBottom: number;
+  rightTop: number;
+  rightBottom: number;
+}
+
+const SIMILARITY_THRESHOLD = 0.3;
+const ALIGN_WINDOW = 3;
+
+function splitLines(value: string): string[] {
+  const lines = value.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+
+function buildLines(lines: string[], type: HunkType, startLineNum: number): DiffLine[] {
+  return lines.map((content, idx) => ({
+    type,
+    content,
+    lineNumber: startLineNum + idx,
+    isPadding: false,
+  }));
+}
+
+function buildPaddingLines(count: number): DiffLine[] {
+  return Array.from({ length: count }, () => ({
+    type: "equal" as HunkType,
+    content: "",
+    lineNumber: null,
+    isPadding: true,
+  }));
+}
+
+function normalizeDdl(ddl: string): string {
+  return ddl
+    .replace(/\r\n/g, "\n")
+    .replace(/\r/g, "\n")
+    .split("\n")
+    .map((line) => line.replace(/[ \t]+$/g, ""))
+    .join("\n");
+}
+
+function collectSameKindChanges(changes: Change[], startIdx: number, kind: "added" | "removed"): [string[], number] {
+  const parts: string[] = [];
+  let i = startIdx;
+  while (i < changes.length && changes[i][kind]) {
+    parts.push(changes[i].value);
+    i++;
+  }
+  return [parts, i];
+}
+
+function levenshteinDistance(a: string, b: string): number {
+  const matrix: number[][] = [];
+  for (let i = 0; i <= b.length; i++) matrix[i] = [i];
+  for (let j = 0; j <= a.length; j++) matrix[0][j] = j;
+  for (let i = 1; i <= b.length; i++) {
+    for (let j = 1; j <= a.length; j++) {
+      matrix[i][j] = b.charAt(i - 1) === a.charAt(j - 1) ? matrix[i - 1][j - 1] : Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+    }
+  }
+  return matrix[b.length][a.length];
+}
+
+function computeSimilarity(a: string, b: string): number {
+  if (a === b) return 1;
+  const longer = a.length > b.length ? a : b;
+  if (longer.length === 0) return 1;
+  const distance = levenshteinDistance(a, b);
+  return (longer.length - distance) / longer.length;
+}
+
+type AlignedItem = { type: "modify"; left: string; right: string } | { type: "delete"; left: string } | { type: "insert"; right: string };
+
+function alignLineByLine(removedLines: string[], addedLines: string[]): AlignedItem[] {
+  const result: AlignedItem[] = [];
+  let r = 0;
+  let a = 0;
+
+  while (r < removedLines.length || a < addedLines.length) {
+    if (r < removedLines.length && a < addedLines.length) {
+      const directSim = computeSimilarity(removedLines[r], addedLines[a]);
+      if (directSim >= SIMILARITY_THRESHOLD) {
+        result.push({ type: "modify", left: removedLines[r], right: addedLines[a] });
+        r++;
+        a++;
+        continue;
+      }
+
+      // Look ahead for best match within a small window
+      let bestR = -1;
+      let bestA = -1;
+      let bestSim = SIMILARITY_THRESHOLD;
+
+      for (let ri = r; ri < Math.min(r + ALIGN_WINDOW, removedLines.length); ri++) {
+        for (let aj = a; aj < Math.min(a + ALIGN_WINDOW, addedLines.length); aj++) {
+          const sim = computeSimilarity(removedLines[ri], addedLines[aj]);
+          if (sim > bestSim) {
+            bestSim = sim;
+            bestR = ri;
+            bestA = aj;
+          }
+        }
+      }
+
+      if (bestR >= 0 && bestA >= 0) {
+        while (r < bestR) {
+          result.push({ type: "delete", left: removedLines[r] });
+          r++;
+        }
+        while (a < bestA) {
+          result.push({ type: "insert", right: addedLines[a] });
+          a++;
+        }
+        result.push({ type: "modify", left: removedLines[r], right: addedLines[a] });
+        r++;
+        a++;
+      } else {
+        result.push({ type: "delete", left: removedLines[r] });
+        result.push({ type: "insert", right: addedLines[a] });
+        r++;
+        a++;
+      }
+    } else if (r < removedLines.length) {
+      result.push({ type: "delete", left: removedLines[r] });
+      r++;
+    } else {
+      result.push({ type: "insert", right: addedLines[a] });
+      a++;
+    }
+  }
+
+  return result;
+}
+
+export function buildHunks(sourceDdl: string, targetDdl: string): DiffHunk[] {
+  const normalizedSource = normalizeDdl(sourceDdl);
+  const normalizedTarget = normalizeDdl(targetDdl);
+  const changes = diffLines(normalizedSource, normalizedTarget, { newlineIsToken: false });
+
+  const hunks: DiffHunk[] = [];
+  let leftLineNum = 1;
+  let rightLineNum = 1;
+  let hunkIdCounter = 0;
+
+  function nextId(): string {
+    return `hunk-${hunkIdCounter++}`;
+  }
+
+  let i = 0;
+  while (i < changes.length) {
+    const change = changes[i];
+
+    if (!change.added && !change.removed) {
+      const lines = splitLines(change.value);
+      hunks.push({
+        id: nextId(),
+        type: "equal",
+        leftLines: buildLines(lines, "equal", leftLineNum),
+        rightLines: buildLines(lines, "equal", rightLineNum),
+        leftTop: 0,
+        leftBottom: 0,
+        rightTop: 0,
+        rightBottom: 0,
+      });
+      leftLineNum += lines.length;
+      rightLineNum += lines.length;
+      i++;
+      continue;
+    }
+
+    if (change.removed) {
+      const [removedParts, afterRemoved] = collectSameKindChanges(changes, i, "removed");
+      const [addedParts, afterAdded] = collectSameKindChanges(changes, afterRemoved, "added");
+      const removedValue = removedParts.join("");
+      const removedLines = splitLines(removedValue);
+
+      if (addedParts.length > 0) {
+        const addedValue = addedParts.join("");
+        const addedLines = splitLines(addedValue);
+        const aligned = alignLineByLine(removedLines, addedLines);
+
+        for (const item of aligned) {
+          if (item.type === "modify") {
+            const maxLines = 1;
+            const leftReal = buildLines([item.left], "modify", leftLineNum);
+            const rightReal = buildLines([item.right], "modify", rightLineNum);
+            leftLineNum++;
+            rightLineNum++;
+            hunks.push({
+              id: nextId(),
+              type: "modify",
+              leftLines: padLines(leftReal, maxLines, "modify"),
+              rightLines: padLines(rightReal, maxLines, "modify"),
+              leftTop: 0,
+              leftBottom: 0,
+              rightTop: 0,
+              rightBottom: 0,
+            });
+          } else if (item.type === "delete") {
+            const leftReal = buildLines([item.left], "delete", leftLineNum);
+            leftLineNum++;
+            hunks.push({
+              id: nextId(),
+              type: "delete",
+              leftLines: leftReal,
+              rightLines: buildPaddingLines(1),
+              leftTop: 0,
+              leftBottom: 0,
+              rightTop: 0,
+              rightBottom: 0,
+            });
+          } else if (item.type === "insert") {
+            const rightReal = buildLines([item.right], "insert", rightLineNum);
+            rightLineNum++;
+            hunks.push({
+              id: nextId(),
+              type: "insert",
+              leftLines: buildPaddingLines(1),
+              rightLines: rightReal,
+              leftTop: 0,
+              leftBottom: 0,
+              rightTop: 0,
+              rightBottom: 0,
+            });
+          }
+        }
+      } else {
+        const maxLines = removedLines.length;
+        const leftReal = buildLines(removedLines, "delete", leftLineNum);
+        leftLineNum += removedLines.length;
+        hunks.push({
+          id: nextId(),
+          type: "delete",
+          leftLines: leftReal,
+          rightLines: buildPaddingLines(maxLines),
+          leftTop: 0,
+          leftBottom: 0,
+          rightTop: 0,
+          rightBottom: 0,
+        });
+      }
+      i = afterAdded;
+      continue;
+    }
+
+    if (change.added) {
+      const [addedParts, afterAdded] = collectSameKindChanges(changes, i, "added");
+      const addedValue = addedParts.join("");
+      const addedLines = splitLines(addedValue);
+      const rightReal = buildLines(addedLines, "insert", rightLineNum);
+      rightLineNum += addedLines.length;
+      hunks.push({
+        id: nextId(),
+        type: "insert",
+        leftLines: buildPaddingLines(addedLines.length),
+        rightLines: rightReal,
+        leftTop: 0,
+        leftBottom: 0,
+        rightTop: 0,
+        rightBottom: 0,
+      });
+      i = afterAdded;
+      continue;
+    }
+  }
+
+  return hunks;
+}
+
+function padLines(lines: DiffLine[], targetCount: number, type: HunkType): DiffLine[] {
+  if (lines.length >= targetCount) return lines;
+  const padding = Array.from({ length: targetCount - lines.length }, () => ({
+    type,
+    content: "",
+    lineNumber: null,
+    isPadding: true,
+  }));
+  return [...lines, ...padding];
+}
diff --git a/apps/desktop/src/components/diff/DiffSvgConnector.vue b/apps/desktop/src/components/diff/DiffSvgConnector.vue
new file mode 100644
index 0000000..f31caa7
--- /dev/null
+++ b/apps/desktop/src/components/diff/DiffSvgConnector.vue
@@ -0,0 +1,40 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import type { DiffHunk } from "@/components/diff/DiffHunkBuilder";
+
+const props = defineProps<{
+  hunks: DiffHunk[];
+  containerWidth: number;
+  containerHeight: number;
+}>();
+
+const connectionPaths = computed(() => {
+  const paths: { d: string; stroke: string; id: string }[] = [];
+  const midX = props.containerWidth / 2;
+  const halfLine = 10;
+
+  for (const hunk of props.hunks) {
+    // Only draw short connectors for modify hunks
+    if (hunk.type !== "modify") continue;
+    if (hunk.leftBottom <= hunk.leftTop || hunk.rightBottom <= hunk.rightTop) continue;
+    if (hunk.leftBottom < 0 || hunk.rightBottom < 0) continue;
+    if (hunk.leftTop > props.containerHeight || hunk.rightTop > props.containerHeight) continue;
+
+    const leftY = (hunk.leftTop + hunk.leftBottom) / 2;
+    const rightY = (hunk.rightTop + hunk.rightBottom) / 2;
+
+    paths.push({
+      id: hunk.id,
+      d: `M ${midX - halfLine},${leftY} L ${midX + halfLine},${rightY}`,
+      stroke: "rgba(234, 179, 8, 0.6)",
+    });
+  }
+  return paths;
+});
+</script>
+
+<template>
+  <svg class="absolute inset-0 pointer-events-none z-10" :width="containerWidth" :height="containerHeight" xmlns="http://www.w3.org/2000/svg">
+    <path v-for="path in connectionPaths" :key="path.id" :d="path.d" :stroke="path.stroke" fill="none" stroke-width="2" />
+  </svg>
+</template>
diff --git a/apps/desktop/src/components/diff/SchemaDiffConfigSelector.vue b/apps/desktop/src/components/diff/SchemaDiffConfigSelector.vue
new file mode 100644
index 0000000..21dfb6e
--- /dev/null
+++ b/apps/desktop/src/components/diff/SchemaDiffConfigSelector.vue
@@ -0,0 +1,201 @@
+<script setup lang="ts">
+import { ref, computed } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Download, Upload, Plus, Trash2, Copy, FileDown } from "@lucide/vue";
+import type { SchemaDiffConfig } from "@/types/schemaDiff";
+
+const props = defineProps<{
+  configs: SchemaDiffConfig[];
+  activeConfigId: string;
+}>();
+
+const emit = defineEmits<{
+  (e: "update:activeConfigId", id: string): void;
+  (e: "create", name: string): void;
+  (e: "rename", id: string, name: string): void;
+  (e: "delete", id: string): void;
+  (e: "duplicate", id: string): void;
+  (e: "export", config: SchemaDiffConfig): void;
+  (e: "exportAll", configs: SchemaDiffConfig[]): void;
+  (e: "import", jsonText: string): void;
+}>();
+
+const { t } = useI18n();
+
+const renameDialogOpen = ref(false);
+const renameValue = ref("");
+const renamingId = ref("");
+
+const importDialogOpen = ref(false);
+const importValue = ref("");
+const importError = ref("");
+
+function onSelectChange(value: unknown) {
+  emit("update:activeConfigId", String(value));
+}
+
+function startRename(config: SchemaDiffConfig) {
+  renamingId.value = config.id;
+  renameValue.value = config.name;
+  renameDialogOpen.value = true;
+}
+
+function confirmRename() {
+  if (renamingId.value && renameValue.value.trim()) {
+    emit("rename", renamingId.value, renameValue.value.trim());
+  }
+  renameDialogOpen.value = false;
+}
+
+function handleCreate() {
+  const baseName = t("schemaDiff.newConfigName");
+  let name = baseName;
+  let counter = 1;
+  while (props.configs.some((c) => c.name === name)) {
+    counter++;
+    name = `${baseName} ${counter}`;
+  }
+  emit("create", name);
+}
+
+function handleImport() {
+  importError.value = "";
+  try {
+    JSON.parse(importValue.value);
+    emit("import", importValue.value);
+    importDialogOpen.value = false;
+    importValue.value = "";
+  } catch {
+    importError.value = t("schemaDiff.importInvalidJson");
+  }
+}
+
+function downloadJson(data: string, filename: string) {
+  const blob = new Blob([data], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+function onExport() {
+  const config = props.configs.find((c) => c.id === props.activeConfigId);
+  if (config) {
+    emit("export", config);
+    downloadJson(JSON.stringify(config, null, 2), `dbx-schema-diff-${config.name}.json`);
+  }
+}
+
+function onExportAll() {
+  emit("exportAll", props.configs);
+  downloadJson(JSON.stringify(props.configs, null, 2), "dbx-schema-diff-configs.json");
+}
+
+async function onImportFile(event: Event) {
+  const input = event.target as HTMLInputElement;
+  const file = input.files?.[0];
+  if (!file) return;
+  try {
+    const text = await file.text();
+    JSON.parse(text);
+    emit("import", text);
+    importDialogOpen.value = false;
+  } catch {
+    importError.value = t("schemaDiff.importInvalidJson");
+  }
+  input.value = "";
+}
+
+const activeConfig = computed(() => props.configs.find((c) => c.id === props.activeConfigId));
+</script>
+
+<template>
+  <div class="flex items-center gap-2">
+    <Select :model-value="activeConfigId" @update:model-value="onSelectChange">
+      <SelectTrigger class="h-8 text-sm min-w-[180px]">
+        <SelectValue :placeholder="t('schemaDiff.selectConfig')" />
+      </SelectTrigger>
+      <SelectContent>
+        <SelectItem v-for="config in configs" :key="config.id" :value="config.id">
+          {{ config.name }}
+        </SelectItem>
+      </SelectContent>
+    </Select>
+
+    <Button variant="outline" size="icon" class="h-8 w-8" :title="t('schemaDiff.newConfig')" @click="handleCreate">
+      <Plus class="h-4 w-4" />
+    </Button>
+
+    <Button v-if="activeConfig" variant="outline" size="icon" class="h-8 w-8" :title="t('schemaDiff.renameConfig')" @click="startRename(activeConfig)">
+      <Copy class="h-4 w-4" />
+    </Button>
+
+    <Button v-if="activeConfig" variant="outline" size="icon" class="h-8 w-8" :title="t('schemaDiff.duplicateConfig')" @click="emit('duplicate', activeConfig.id)">
+      <FileDown class="h-4 w-4" />
+    </Button>
+
+    <Button v-if="activeConfig && configs.length > 1" variant="outline" size="icon" class="h-8 w-8" :title="t('schemaDiff.deleteConfig')" @click="activeConfig && emit('delete', activeConfig.id)">
+      <Trash2 class="h-4 w-4" />
+    </Button>
+
+    <Button variant="outline" size="icon" class="h-8 w-8" :title="t('schemaDiff.exportConfig')" @click="onExport">
+      <Upload class="h-4 w-4" />
+    </Button>
+
+    <Button variant="outline" size="icon" class="h-8 w-8" :title="t('schemaDiff.importConfig')" @click="importDialogOpen = true">
+      <Download class="h-4 w-4" />
+    </Button>
+
+    <Button variant="outline" size="icon" class="h-8 w-8" :title="t('schemaDiff.exportAllConfigs')" @click="onExportAll">
+      <Upload class="h-4 w-4" />
+    </Button>
+
+    <!-- Rename Dialog -->
+    <Dialog v-model:open="renameDialogOpen">
+      <DialogContent class="sm:max-w-[400px]">
+        <DialogHeader>
+          <DialogTitle>{{ t("schemaDiff.renameConfig") }}</DialogTitle>
+        </DialogHeader>
+        <div class="py-4">
+          <Label class="text-sm">{{ t("schemaDiff.configName") }}</Label>
+          <Input v-model="renameValue" class="mt-2" @keydown.enter="confirmRename" />
+        </div>
+        <DialogFooter>
+          <Button variant="outline" @click="renameDialogOpen = false">{{ t("common.cancel") }}</Button>
+          <Button @click="confirmRename">{{ t("common.save") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <!-- Import Dialog -->
+    <Dialog v-model:open="importDialogOpen">
+      <DialogContent class="sm:max-w-[500px]">
+        <DialogHeader>
+          <DialogTitle>{{ t("schemaDiff.importConfig") }}</DialogTitle>
+        </DialogHeader>
+        <div class="py-4 space-y-4">
+          <div>
+            <Label class="text-sm">{{ t("schemaDiff.importFromFile") }}</Label>
+            <Input type="file" accept=".json" class="mt-2" @change="onImportFile" />
+          </div>
+          <div>
+            <Label class="text-sm">{{ t("schemaDiff.importFromText") }}</Label>
+            <textarea v-model="importValue" class="mt-2 w-full min-h-[120px] rounded-md border border-input bg-background px-3 py-2 text-sm" :placeholder="t('schemaDiff.importPlaceholder')" />
+          </div>
+          <p v-if="importError" class="text-sm text-destructive">{{ importError }}</p>
+        </div>
+        <DialogFooter>
+          <Button variant="outline" @click="importDialogOpen = false">{{ t("common.cancel") }}</Button>
+          <Button @click="handleImport">{{ t("common.import") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/diff/SchemaDiffConfigStep.vue b/apps/desktop/src/components/diff/SchemaDiffConfigStep.vue
new file mode 100644
index 0000000..8e53cc1
--- /dev/null
+++ b/apps/desktop/src/components/diff/SchemaDiffConfigStep.vue
@@ -0,0 +1,480 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import SearchableSelect from "@/components/ui/searchable-select/SearchableSelect.vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import * as api from "@/lib/backend/api";
+import { isSchemaAware } from "@/lib/database/databaseCapabilities";
+import { ArrowLeftRight, GitCompareArrows, Save, FolderOpen, Settings, X } from "@lucide/vue";
+import type { SchemaDiffConfig, SchemaDiffCompareOptions } from "@/types/schemaDiff";
+
+const { t } = useI18n();
+const store = useConnectionStore();
+
+const props = defineProps<{
+  configs: SchemaDiffConfig[];
+  activeConfigId: string;
+  sourceConnectionId: string;
+  sourceDatabase: string;
+  sourceSchema: string;
+  targetConnectionId: string;
+  targetDatabase: string;
+  targetSchema: string;
+  ignoreComments: boolean;
+  options: SchemaDiffCompareOptions;
+  loading: boolean;
+  recentConfigs: SchemaDiffConfig[];
+}>();
+
+const emit = defineEmits<{
+  (e: "update:sourceConnectionId", value: string): void;
+  (e: "update:sourceDatabase", value: string): void;
+  (e: "update:sourceSchema", value: string): void;
+  (e: "update:targetConnectionId", value: string): void;
+  (e: "update:targetDatabase", value: string): void;
+  (e: "update:targetSchema", value: string): void;
+  (e: "update:ignoreComments", value: boolean): void;
+  (e: "compare"): void;
+  (e: "saveConfig"): void;
+  (e: "loadConfig"): void;
+  (e: "showOptions"): void;
+  (e: "swap"): void;
+  (e: "loadHistoryConfig", config: SchemaDiffConfig): void;
+  (e: "deleteHistoryConfig", configId: string): void;
+}>();
+
+const sourceDatabases = ref<string[]>([]);
+const sourceSchemas = ref<string[]>([]);
+const targetDatabases = ref<string[]>([]);
+const targetSchemas = ref<string[]>([]);
+const sourceDbVersion = ref<string | null>(null);
+const targetDbVersion = ref<string | null>(null);
+
+const sqlConnections = computed(() => store.connections.filter((c: any) => !["mongodb", "redis", "elasticsearch", "etcd", "mq", "nacos"].includes(c.db_type)));
+
+const sourceConfig = computed(() => store.getConfig(props.sourceConnectionId));
+const targetConfig = computed(() => store.getConfig(props.targetConnectionId));
+
+const canCompare = computed(() => {
+  return props.sourceConnectionId && props.targetConnectionId && props.sourceDatabase && props.targetDatabase && (!isSchemaAware(sourceConfig.value?.db_type) || props.sourceSchema) && (!isSchemaAware(targetConfig.value?.db_type) || props.targetSchema);
+});
+
+async function loadDatabases(connectionId: string, side: "source" | "target") {
+  if (!connectionId) return;
+  try {
+    await store.ensureConnected(connectionId);
+    const dbs = await api.listDatabases(connectionId);
+    const dbNames = Array.isArray(dbs) ? dbs.map((db: any) => (typeof db === "string" ? db : db.name || db.database)) : [];
+    if (side === "source") {
+      sourceDatabases.value = dbNames;
+      if (props.sourceDatabase) {
+        await fetchDbVersion(connectionId, props.sourceDatabase, props.sourceSchema, "source");
+        // Ensure schema list is loaded after databases are available (handles race with sourceDatabase watcher)
+        if (isSchemaAware(sourceConfig.value?.db_type)) {
+          await loadSchemas("source");
+        }
+      }
+    } else {
+      targetDatabases.value = dbNames;
+      if (props.targetDatabase) {
+        await fetchDbVersion(connectionId, props.targetDatabase, props.targetSchema, "target");
+        // Ensure schema list is loaded after databases are available (handles race with targetDatabase watcher)
+        if (isSchemaAware(targetConfig.value?.db_type)) {
+          await loadSchemas("target");
+        }
+      }
+    }
+  } catch {
+    if (side === "source") {
+      sourceDatabases.value = [];
+      sourceDbVersion.value = null;
+    } else {
+      targetDatabases.value = [];
+      targetDbVersion.value = null;
+    }
+  }
+}
+
+async function loadSchemas(side: "source" | "target") {
+  const connectionId = side === "source" ? props.sourceConnectionId : props.targetConnectionId;
+  const database = side === "source" ? props.sourceDatabase : props.targetDatabase;
+  const schema = side === "source" ? props.sourceSchema : props.targetSchema;
+  if (!connectionId || !database) return;
+
+  try {
+    await store.ensureConnected(connectionId);
+    const schemas = await api.listSchemas(connectionId, database);
+    if (side === "source") {
+      sourceSchemas.value = schemas;
+    } else {
+      targetSchemas.value = schemas;
+    }
+    await fetchDbVersion(connectionId, database, schema, side);
+  } catch {
+    if (side === "source") {
+      sourceSchemas.value = [];
+    } else {
+      targetSchemas.value = [];
+    }
+  }
+}
+
+watch(
+  () => props.sourceConnectionId,
+  async (id) => {
+    if (id) {
+      await loadDatabases(id, "source");
+    } else {
+      sourceDatabases.value = [];
+    }
+  },
+  { immediate: true },
+);
+
+watch(
+  () => props.sourceDatabase,
+  async (db) => {
+    if (db && props.sourceConnectionId) {
+      await loadSchemas("source");
+    } else {
+      sourceSchemas.value = [];
+    }
+  },
+  { immediate: true },
+);
+
+watch(
+  () => props.targetConnectionId,
+  async (id) => {
+    if (id) {
+      await loadDatabases(id, "target");
+    } else {
+      targetDatabases.value = [];
+    }
+  },
+  { immediate: true },
+);
+
+watch(
+  () => props.targetDatabase,
+  async (db) => {
+    if (db && props.targetConnectionId) {
+      await loadSchemas("target");
+    } else {
+      targetSchemas.value = [];
+    }
+  },
+  { immediate: true },
+);
+
+function connectionIconType(connectionId: string) {
+  const c = store.getConfig(connectionId);
+  return c?.driver_profile || c?.db_type || "mysql";
+}
+
+function getConnectionInfo(connectionId: string) {
+  const c = store.getConfig(connectionId);
+  if (!c) return null;
+  return {
+    name: c.name,
+    dbType: c.db_type,
+    host: c.host,
+    port: c.port,
+  };
+}
+
+async function fetchDbVersion(connectionId: string, database: string, schema: string, side: "source" | "target") {
+  try {
+    await store.ensureConnected(connectionId);
+    const config = store.getConfig(connectionId);
+    const dbType = config?.db_type;
+    let sql = "";
+    switch (dbType) {
+      case "postgres":
+      case "opengauss":
+        sql = "SELECT version()";
+        break;
+      case "mysql":
+        sql = "SELECT VERSION()";
+        break;
+      case "sqlite":
+        sql = "SELECT sqlite_version()";
+        break;
+      default:
+        return;
+    }
+    const result = await api.executeQuery(connectionId, database, sql, schema || undefined);
+    if (result.rows && result.rows.length > 0) {
+      const version = String(result.rows[0][0]);
+      if (side === "source") {
+        sourceDbVersion.value = version;
+      } else {
+        targetDbVersion.value = version;
+      }
+    }
+  } catch (e) {
+    console.error(`[fetchDbVersion] Failed to fetch version for ${side}:`, e);
+    if (side === "source") {
+      sourceDbVersion.value = null;
+    } else {
+      targetDbVersion.value = null;
+    }
+  }
+}
+</script>
+
+<template>
+  <div class="space-y-4">
+    <!-- Header -->
+    <div class="flex items-center justify-center gap-4 py-2">
+      <div class="text-center">
+        <div class="text-xs text-muted-foreground">{{ sourceConfig?.name || t("diff.source") }}</div>
+        <div class="text-xs font-medium">{{ sourceDatabase }}{{ sourceSchema ? `.${sourceSchema}` : "" }}</div>
+      </div>
+      <div class="flex items-center gap-2">
+        <DatabaseIcon v-if="sourceConnectionId" :db-type="connectionIconType(sourceConnectionId)" class="w-5 h-5" />
+        <ArrowLeftRight class="w-4 h-4 text-muted-foreground" />
+        <DatabaseIcon v-if="targetConnectionId" :db-type="connectionIconType(targetConnectionId)" class="w-5 h-5" />
+      </div>
+      <div class="text-center">
+        <div class="text-xs text-muted-foreground">{{ targetConfig?.name || t("diff.target") }}</div>
+        <div class="text-xs font-medium">{{ targetDatabase }}{{ targetSchema ? `.${targetSchema}` : "" }}</div>
+      </div>
+    </div>
+
+    <!-- Source / Target Selection -->
+    <div class="grid grid-cols-[1fr_auto_1fr] gap-4 items-start">
+      <!-- Source Side -->
+      <div class="space-y-3">
+        <div class="text-sm font-medium text-blue-500">{{ t("diff.source") }}</div>
+
+        <div class="space-y-1.5">
+          <Label class="text-xs">{{ t("diff.connection") }}</Label>
+          <SearchableSelect
+            :model-value="sourceConnectionId"
+            @update:model-value="(v: string) => $emit('update:sourceConnectionId', v)"
+            :options="sqlConnections.map((c) => c.id)"
+            :placeholder="t('diff.selectConnection')"
+            :search-placeholder="t('diff.searchConnection')"
+            :empty-text="t('common.noResults')"
+            :display-name="(id) => sqlConnections.find((c) => c.id === id)?.name ?? id"
+            trigger-variant="outline"
+            trigger-class="h-8 w-full justify-between text-xs"
+            content-class="w-[var(--reka-popover-trigger-width)]"
+          >
+            <template #option-label="{ option, label }">
+              <div class="flex items-center gap-2">
+                <DatabaseIcon :db-type="sqlConnections.find((c) => c.id === option)?.driver_profile || sqlConnections.find((c) => c.id === option)?.db_type || 'mysql'" class="w-3.5 h-3.5" />
+                {{ label }}
+              </div>
+            </template>
+          </SearchableSelect>
+        </div>
+
+        <div class="space-y-1.5">
+          <Label class="text-xs">{{ t("diff.database") }}</Label>
+          <SearchableSelect
+            :model-value="sourceDatabase"
+            @update:model-value="(v: string) => $emit('update:sourceDatabase', v)"
+            :options="sourceDatabases"
+            :placeholder="t('diff.selectDatabase')"
+            :search-placeholder="t('diff.searchDatabase')"
+            :empty-text="t('common.noResults')"
+            :disabled="!sourceDatabases.length"
+            trigger-variant="outline"
+            trigger-class="h-8 w-full justify-between text-xs"
+            content-class="w-[var(--reka-popover-trigger-width)]"
+          />
+        </div>
+
+        <div v-if="isSchemaAware(sourceConfig?.db_type)" class="space-y-1.5">
+          <Label class="text-xs">{{ t("diff.schema") }}</Label>
+          <SearchableSelect
+            :model-value="sourceSchema"
+            @update:model-value="(v: string) => $emit('update:sourceSchema', v)"
+            :options="sourceSchemas"
+            :placeholder="t('diff.selectSchema')"
+            :search-placeholder="t('diff.searchSchema')"
+            :empty-text="t('common.noResults')"
+            :disabled="!sourceSchemas.length"
+            trigger-variant="outline"
+            trigger-class="h-8 w-full justify-between text-xs"
+            content-class="w-[var(--reka-popover-trigger-width)]"
+          />
+        </div>
+
+        <!-- Source Info -->
+        <div v-if="getConnectionInfo(sourceConnectionId)" class="mt-4 p-3 rounded-lg bg-muted/30 border space-y-1.5">
+          <div class="text-xs font-medium text-blue-500">{{ t("diff.info") }}</div>
+          <div class="grid grid-cols-[80px_1fr] gap-x-2 gap-y-0.5 text-xs">
+            <span class="text-muted-foreground">{{ t("diff.connType") }}</span>
+            <span>{{ getConnectionInfo(sourceConnectionId)?.dbType }}</span>
+            <span class="text-muted-foreground">{{ t("diff.connName") }}</span>
+            <span>{{ getConnectionInfo(sourceConnectionId)?.name }}</span>
+            <span class="text-muted-foreground">{{ t("diff.host") }}</span>
+            <span>{{ getConnectionInfo(sourceConnectionId)?.host }}</span>
+            <span class="text-muted-foreground">{{ t("diff.port") }}</span>
+            <span>{{ getConnectionInfo(sourceConnectionId)?.port }}</span>
+            <span class="text-muted-foreground">{{ t("diff.serverVersion") }}</span>
+            <span>{{ sourceDbVersion || "--" }}</span>
+          </div>
+        </div>
+      </div>
+
+      <!-- Swap Button -->
+      <div class="pt-8">
+        <Button variant="ghost" size="icon" class="h-8 w-8" @click="$emit('swap')">
+          <ArrowLeftRight class="w-4 h-4" />
+        </Button>
+      </div>
+
+      <!-- Target Side -->
+      <div class="space-y-3">
+        <div class="text-sm font-medium text-green-500">{{ t("diff.target") }}</div>
+
+        <div class="space-y-1.5">
+          <Label class="text-xs">{{ t("diff.connection") }}</Label>
+          <SearchableSelect
+            :model-value="targetConnectionId"
+            @update:model-value="(v: string) => $emit('update:targetConnectionId', v)"
+            :options="sqlConnections.map((c) => c.id)"
+            :placeholder="t('diff.selectConnection')"
+            :search-placeholder="t('diff.searchConnection')"
+            :empty-text="t('common.noResults')"
+            :display-name="(id) => sqlConnections.find((c) => c.id === id)?.name ?? id"
+            trigger-variant="outline"
+            trigger-class="h-8 w-full justify-between text-xs"
+            content-class="w-[var(--reka-popover-trigger-width)]"
+          >
+            <template #option-label="{ option, label }">
+              <div class="flex items-center gap-2">
+                <DatabaseIcon :db-type="sqlConnections.find((c) => c.id === option)?.driver_profile || sqlConnections.find((c) => c.id === option)?.db_type || 'mysql'" class="w-3.5 h-3.5" />
+                {{ label }}
+              </div>
+            </template>
+          </SearchableSelect>
+        </div>
+
+        <div class="space-y-1.5">
+          <Label class="text-xs">{{ t("diff.database") }}</Label>
+          <SearchableSelect
+            :model-value="targetDatabase"
+            @update:model-value="(v: string) => $emit('update:targetDatabase', v)"
+            :options="targetDatabases"
+            :placeholder="t('diff.selectDatabase')"
+            :search-placeholder="t('diff.searchDatabase')"
+            :empty-text="t('common.noResults')"
+            :disabled="!targetDatabases.length"
+            trigger-variant="outline"
+            trigger-class="h-8 w-full justify-between text-xs"
+            content-class="w-[var(--reka-popover-trigger-width)]"
+          />
+        </div>
+
+        <div v-if="isSchemaAware(targetConfig?.db_type)" class="space-y-1.5">
+          <Label class="text-xs">{{ t("diff.schema") }}</Label>
+          <SearchableSelect
+            :model-value="targetSchema"
+            @update:model-value="(v: string) => $emit('update:targetSchema', v)"
+            :options="targetSchemas"
+            :placeholder="t('diff.selectSchema')"
+            :search-placeholder="t('diff.searchSchema')"
+            :empty-text="t('common.noResults')"
+            :disabled="!targetSchemas.length"
+            trigger-variant="outline"
+            trigger-class="h-8 w-full justify-between text-xs"
+            content-class="w-[var(--reka-popover-trigger-width)]"
+          />
+        </div>
+
+        <!-- Target Info -->
+        <div v-if="getConnectionInfo(targetConnectionId)" class="mt-4 p-3 rounded-lg bg-muted/30 border space-y-1.5">
+          <div class="text-xs font-medium text-green-500">{{ t("diff.info") }}</div>
+          <div class="grid grid-cols-[80px_1fr] gap-x-2 gap-y-0.5 text-xs">
+            <span class="text-muted-foreground">{{ t("diff.connType") }}</span>
+            <span>{{ getConnectionInfo(targetConnectionId)?.dbType }}</span>
+            <span class="text-muted-foreground">{{ t("diff.connName") }}</span>
+            <span>{{ getConnectionInfo(targetConnectionId)?.name }}</span>
+            <span class="text-muted-foreground">{{ t("diff.host") }}</span>
+            <span>{{ getConnectionInfo(targetConnectionId)?.host }}</span>
+            <span class="text-muted-foreground">{{ t("diff.port") }}</span>
+            <span>{{ getConnectionInfo(targetConnectionId)?.port }}</span>
+            <span class="text-muted-foreground">{{ t("diff.serverVersion") }}</span>
+            <span>{{ targetDbVersion || "--" }}</span>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <!-- Options -->
+    <div class="flex items-center gap-2 p-3 rounded-lg border bg-muted/20">
+      <input id="schema-diff-ignore-comments" :checked="ignoreComments" type="checkbox" class="accent-primary" @change="$emit('update:ignoreComments', ($event.target as HTMLInputElement).checked)" />
+      <Label for="schema-diff-ignore-comments" class="cursor-pointer text-xs">
+        {{ t("diff.ignoreComments") }}
+      </Label>
+    </div>
+
+    <!-- Recent Configs Dropdown -->
+    <div v-if="recentConfigs.length > 0" class="flex items-center gap-2">
+      <Label class="text-xs text-muted-foreground">{{ t("diff.recentConfigs") }}</Label>
+      <Select
+        :model-value="''"
+        @update:model-value="
+          (v: any) => {
+            const config = recentConfigs.find((c) => c.id === v);
+            if (config) $emit('loadHistoryConfig', config);
+          }
+        "
+      >
+        <SelectTrigger class="h-8 text-xs w-[280px]">
+          <SelectValue :placeholder="t('diff.selectRecentConfig')" />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem v-for="config in recentConfigs" :key="config.id" :value="config.id" class="pr-8">
+            <div class="flex items-center justify-between w-full gap-2">
+              <div class="flex flex-col gap-0.5 min-w-0">
+                <span class="text-xs font-medium truncate">{{ config.name }}</span>
+                <span class="text-[10px] text-muted-foreground truncate">
+                  {{ store.getConfig(config.sourceConnectionId)?.name || config.sourceConnectionId }}
+                  /{{ config.sourceDatabase }}{{ config.sourceSchema ? `.${config.sourceSchema}` : "" }}
+                  →
+                  {{ store.getConfig(config.targetConnectionId)?.name || config.targetConnectionId }}
+                  /{{ config.targetDatabase }}{{ config.targetSchema ? `.${config.targetSchema}` : "" }}
+                </span>
+              </div>
+              <button class="shrink-0 p-1 rounded hover:bg-destructive/10 hover:text-destructive transition-colors" @click.stop="$emit('deleteHistoryConfig', config.id)">
+                <X class="w-3 h-3" />
+              </button>
+            </div>
+          </SelectItem>
+        </SelectContent>
+      </Select>
+    </div>
+
+    <!-- Bottom Actions -->
+    <div class="flex items-center justify-between pt-2">
+      <div class="flex items-center gap-2">
+        <Button variant="outline" size="sm" @click="$emit('saveConfig')">
+          <Save class="w-3.5 h-3.5 mr-1" />
+          {{ t("diff.saveConfig") }}
+        </Button>
+        <Button variant="outline" size="sm" @click="$emit('loadConfig')">
+          <FolderOpen class="w-3.5 h-3.5 mr-1" />
+          {{ t("diff.loadConfig") }}
+        </Button>
+        <Button variant="outline" size="sm" @click="$emit('showOptions')">
+          <Settings class="w-3.5 h-3.5 mr-1" />
+          {{ t("diff.options") }}
+        </Button>
+      </div>
+      <Button size="sm" :disabled="!canCompare || loading" @click="$emit('compare')">
+        <GitCompareArrows class="w-3.5 h-3.5 mr-1" />
+        {{ loading ? t("common.loading") : t("diff.compare") }}
+      </Button>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/diff/SchemaDiffDdlPanel.vue b/apps/desktop/src/components/diff/SchemaDiffDdlPanel.vue
new file mode 100644
index 0000000..eec5d8a
--- /dev/null
+++ b/apps/desktop/src/components/diff/SchemaDiffDdlPanel.vue
@@ -0,0 +1,390 @@
+<script setup lang="ts">
+import { ref, computed, watch, nextTick } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { useToast } from "@/composables/useToast";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { DEFAULT_CUSTOM_THEME_DDL_COLORS } from "@/stores/settingsStore";
+import { useDiffScrollSync } from "@/composables/useDiffScrollSync";
+import { buildHunks, type DiffLine } from "@/components/diff/DiffHunkBuilder";
+import DiffSvgConnector from "@/components/diff/DiffSvgConnector.vue";
+import { FileCode, ScrollText, Copy, Play } from "@lucide/vue";
+import { Splitpanes, Pane } from "splitpanes";
+import "splitpanes/dist/splitpanes.css";
+import type { SchemaDiffObject } from "@/lib/schema/schemaDiff";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const settingsStore = useSettingsStore();
+
+const ddlColors = computed(() => {
+  const themes = settingsStore.editorSettings.customThemes;
+  const activeId = settingsStore.editorSettings.activeCustomThemeId;
+  const activeTheme = themes.find((t) => t.id === activeId);
+  return activeTheme?.ddlColors ?? DEFAULT_CUSTOM_THEME_DDL_COLORS;
+});
+
+function toRgba(hex: string, alpha: number): string {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return `rgba(${r}, ${g}, ${b}, ${alpha / 100})`;
+}
+
+const props = defineProps<{
+  selectedObject: SchemaDiffObject | null;
+  deploySql: string;
+  deploySqlAll: string;
+}>();
+
+const emit = defineEmits<{
+  executeScript: [];
+}>();
+
+const activeTab = ref<"ddl" | "script" | "scriptAll">("ddl");
+const diffContainerRef = ref<HTMLDivElement>();
+const leftPaneRef = ref<HTMLDivElement>();
+const rightPaneRef = ref<HTMLDivElement>();
+const containerSize = ref({ width: 0, height: 0 });
+const connectorKey = ref(0);
+
+const hunks = computed(() => {
+  if (!props.selectedObject?.sourceDdl && !props.selectedObject?.targetDdl) return [];
+  return buildHunks(props.selectedObject?.sourceDdl || "", props.selectedObject?.targetDdl || "");
+});
+
+const { syncScroll, measureHunks } = useDiffScrollSync({
+  container: diffContainerRef,
+  leftPane: leftPaneRef,
+  rightPane: rightPaneRef,
+  hunks,
+});
+
+// Cache char-level diff segments so we don't recompute on every render
+const modifySegments = computed(() => {
+  const map = new Map<string, { leftSegments: Segment[]; rightSegments: Segment[] }>();
+  for (const hunk of hunks.value) {
+    if (hunk.type !== "modify") continue;
+    for (let i = 0; i < hunk.leftLines.length; i++) {
+      const left = hunk.leftLines[i];
+      const right = hunk.rightLines[i];
+      if (left.isPadding || right.isPadding) continue;
+      const key = `${hunk.id}:${i}`;
+      map.set(key, renderModifyLine(left, right));
+    }
+  }
+  return map;
+});
+
+let measureRaf: number | null = null;
+let measureTimeout: ReturnType<typeof setTimeout> | null = null;
+
+function requestMeasure() {
+  if (measureRaf) return;
+  measureRaf = requestAnimationFrame(() => {
+    measureRaf = null;
+    measureHunks();
+    connectorKey.value++;
+  });
+}
+
+function requestMeasureDebounced() {
+  if (measureTimeout) clearTimeout(measureTimeout);
+  measureTimeout = setTimeout(() => {
+    requestMeasure();
+  }, 100);
+}
+
+function handleScroll(from: "left" | "right") {
+  syncScroll(from);
+  requestMeasureDebounced();
+}
+
+watch(
+  () => props.selectedObject?.id,
+  async () => {
+    await nextTick();
+    updateContainerSize();
+    requestMeasure();
+  },
+);
+
+function updateContainerSize() {
+  const el = diffContainerRef.value;
+  if (!el) return;
+  const rect = el.getBoundingClientRect();
+  containerSize.value = { width: rect.width, height: rect.height };
+}
+
+function onSplitpanesResized() {
+  updateContainerSize();
+  requestMeasure();
+}
+
+function lineBackground(line: DiffLine): string | undefined {
+  if (line.isPadding) return undefined;
+  if (line.type === "delete") {
+    // source-only = will be added to target = green
+    return toRgba(ddlColors.value.addedRowBg, ddlColors.value.addedRowBgAlpha);
+  }
+  if (line.type === "insert") {
+    // target-only = will be removed from target = red
+    return toRgba(ddlColors.value.removedRowBg, ddlColors.value.removedRowBgAlpha);
+  }
+  if (line.type === "modify") {
+    return toRgba(ddlColors.value.modifiedRowBg, ddlColors.value.modifiedRowBgAlpha);
+  }
+  return undefined;
+}
+
+function lineTextClass(line: DiffLine): string {
+  if (line.isPadding) return "text-transparent";
+  if (line.type === "insert") return "line-through opacity-80";
+  return "";
+}
+
+function computeCharDiffs(source: string, target: string): { source: string; target: string }[] {
+  const result: { source: string; target: string }[] = [];
+  let sIdx = 0;
+  let tIdx = 0;
+  while (sIdx < source.length || tIdx < target.length) {
+    if (sIdx >= source.length) {
+      result.push({ source: "", target: target.substring(tIdx) });
+      break;
+    }
+    if (tIdx >= target.length) {
+      result.push({ source: source.substring(sIdx), target: "" });
+      break;
+    }
+    if (source[sIdx] === target[tIdx]) {
+      let matchLen = 0;
+      while (sIdx + matchLen < source.length && tIdx + matchLen < target.length && source[sIdx + matchLen] === target[tIdx + matchLen]) {
+        matchLen++;
+      }
+      result.push({
+        source: source.substring(sIdx, sIdx + matchLen),
+        target: target.substring(tIdx, tIdx + matchLen),
+      });
+      sIdx += matchLen;
+      tIdx += matchLen;
+    } else {
+      let sMatch = -1;
+      let tMatch = -1;
+      for (let i = 0; i < Math.min(10, source.length - sIdx, target.length - tIdx); i++) {
+        if (source[sIdx + i] === target[tIdx]) {
+          sMatch = i;
+          tMatch = 0;
+          break;
+        }
+        if (source[sIdx] === target[tIdx + i]) {
+          sMatch = 0;
+          tMatch = i;
+          break;
+        }
+      }
+      if (sMatch === -1) {
+        sMatch = Math.min(1, source.length - sIdx);
+        tMatch = Math.min(1, target.length - tIdx);
+      }
+      result.push({
+        source: source.substring(sIdx, sIdx + (sMatch > 0 ? sMatch : 1)),
+        target: target.substring(tIdx, tIdx + (tMatch > 0 ? tMatch : 1)),
+      });
+      sIdx += sMatch > 0 ? sMatch : 1;
+      tIdx += tMatch > 0 ? tMatch : 1;
+    }
+  }
+  return result;
+}
+
+function renderModifyLine(leftLine: DiffLine, rightLine: DiffLine): { leftSegments: Segment[]; rightSegments: Segment[] } {
+  const charDiffs = computeCharDiffs(leftLine.content, rightLine.content);
+  const leftSegments: Segment[] = [];
+  const rightSegments: Segment[] = [];
+  for (const cd of charDiffs) {
+    if (cd.source === cd.target) {
+      leftSegments.push({ text: cd.source, changed: false });
+      rightSegments.push({ text: cd.target, changed: false });
+    } else {
+      if (cd.source) leftSegments.push({ text: cd.source, changed: true });
+      if (cd.target) rightSegments.push({ text: cd.target, changed: true });
+    }
+  }
+  return { leftSegments, rightSegments };
+}
+
+interface Segment {
+  text: string;
+  changed: boolean;
+}
+
+function copyDeploySql() {
+  copyToClipboard(props.deploySql);
+  toast(t("diff.copied"), 2000);
+}
+
+function copyDeploySqlAll() {
+  copyToClipboard(props.deploySqlAll);
+  toast(t("diff.copied"), 2000);
+}
+</script>
+
+<template>
+  <div class="border rounded-md flex flex-col h-full">
+    <!-- Tabs -->
+    <div class="flex border-b shrink-0">
+      <button class="px-3 py-1.5 text-xs font-medium flex items-center gap-1 transition-colors" :class="activeTab === 'ddl' ? 'bg-primary/10 text-primary border-b-2 border-primary' : 'hover:bg-muted/50'" @click="activeTab = 'ddl'">
+        <FileCode class="w-3.5 h-3.5" />
+        {{ t("diff.ddlCompare") }}
+      </button>
+      <button class="px-3 py-1.5 text-xs font-medium flex items-center gap-1 transition-colors" :class="activeTab === 'script' ? 'bg-primary/10 text-primary border-b-2 border-primary' : 'hover:bg-muted/50'" @click="activeTab = 'script'">
+        <ScrollText class="w-3.5 h-3.5" />
+        {{ t("diff.deployScript") }}
+      </button>
+      <button class="px-3 py-1.5 text-xs font-medium flex items-center gap-1 transition-colors" :class="activeTab === 'scriptAll' ? 'bg-primary/10 text-primary border-b-2 border-primary' : 'hover:bg-muted/50'" @click="activeTab = 'scriptAll'">
+        <ScrollText class="w-3.5 h-3.5" />
+        {{ t("diff.deployScriptAll") }}
+      </button>
+    </div>
+
+    <!-- DDL Compare -->
+    <div v-if="activeTab === 'ddl'" class="flex-1 overflow-hidden relative">
+      <!-- No object selected -->
+      <div v-if="!selectedObject" class="absolute inset-0 flex items-center justify-center text-sm text-muted-foreground">
+        {{ t("diff.selectObjectToCompare") }}
+      </div>
+      <!-- No DDL data available -->
+      <div v-else-if="!selectedObject.sourceDdl && !selectedObject.targetDdl" class="absolute inset-0 flex items-center justify-center text-sm text-muted-foreground">
+        {{ t("diff.noDdlAvailable") }}
+      </div>
+      <!-- Diff View -->
+      <div v-else ref="diffContainerRef" class="absolute inset-0 font-mono text-xs leading-relaxed">
+        <Splitpanes class="h-full" @resized="onSplitpanesResized">
+          <!-- Source DDL -->
+          <Pane min-size="20">
+            <div ref="leftPaneRef" class="h-full overflow-y-auto border-r" @scroll="handleScroll('left')">
+              <div class="sticky top-0 bg-muted/50 px-3 py-1.5 text-xs font-medium border-b z-10">
+                {{ t("diff.sourceDdl") }}
+              </div>
+              <div v-for="hunk in hunks" :key="`left-${hunk.id}`" :data-hunk-id="hunk.id">
+                <div
+                  v-for="(line, idx) in hunk.leftLines"
+                  :key="`l-${hunk.id}-${idx}`"
+                  class="flex min-h-[1.5em]"
+                  :class="{
+                    'border-l border-r border-yellow-500/40': hunk.type === 'modify',
+                    'border-t rounded-t-sm': hunk.type === 'modify' && idx === 0,
+                    'border-b rounded-b-sm': hunk.type === 'modify' && idx === hunk.leftLines.length - 1,
+                  }"
+                  :style="{ backgroundColor: lineBackground(line) }"
+                >
+                  <span class="text-muted-foreground w-8 text-right pr-2 select-none shrink-0">
+                    {{ line.lineNumber ?? "" }}
+                  </span>
+                  <span class="flex-1 px-1 whitespace-pre" :class="lineTextClass(line)">
+                    <template v-if="line.type === 'modify' && !line.isPadding">
+                      <template v-for="(segment, si) in modifySegments.get(`${hunk.id}:${idx}`)?.leftSegments ?? []" :key="`ls-${si}`">
+                        <span :style="segment.changed ? { backgroundColor: toRgba(ddlColors.modifiedCharBg, ddlColors.modifiedCharBgAlpha) } : undefined">{{ segment.text }}</span>
+                      </template>
+                    </template>
+                    <span v-else>{{ line.isPadding ? "\u00A0" : line.content }}</span>
+                  </span>
+                </div>
+              </div>
+            </div>
+          </Pane>
+
+          <!-- Target DDL -->
+          <Pane min-size="20">
+            <div ref="rightPaneRef" class="h-full overflow-y-auto" @scroll="handleScroll('right')">
+              <div class="sticky top-0 bg-muted/50 px-3 py-1.5 text-xs font-medium border-b z-10">
+                {{ t("diff.targetDdl") }}
+              </div>
+              <div v-for="hunk in hunks" :key="`right-${hunk.id}`" :data-hunk-id="hunk.id">
+                <div
+                  v-for="(line, idx) in hunk.rightLines"
+                  :key="`r-${hunk.id}-${idx}`"
+                  class="flex min-h-[1.5em]"
+                  :class="{
+                    'border-l border-r border-yellow-500/40': hunk.type === 'modify',
+                    'border-t rounded-t-sm': hunk.type === 'modify' && idx === 0,
+                    'border-b rounded-b-sm': hunk.type === 'modify' && idx === hunk.rightLines.length - 1,
+                  }"
+                  :style="{ backgroundColor: lineBackground(line) }"
+                >
+                  <span class="text-muted-foreground w-8 text-right pr-2 select-none shrink-0">
+                    {{ line.lineNumber ?? "" }}
+                  </span>
+                  <span class="flex-1 px-1 whitespace-pre" :class="lineTextClass(line)">
+                    <template v-if="line.type === 'modify' && !line.isPadding">
+                      <template v-for="(segment, si) in modifySegments.get(`${hunk.id}:${idx}`)?.rightSegments ?? []" :key="`rs-${si}`">
+                        <span :style="segment.changed ? { backgroundColor: toRgba(ddlColors.modifiedCharBg, ddlColors.modifiedCharBgAlpha) } : undefined">{{ segment.text }}</span>
+                      </template>
+                    </template>
+                    <span v-else>{{ line.isPadding ? "\u00A0" : line.content }}</span>
+                  </span>
+                </div>
+              </div>
+            </div>
+          </Pane>
+        </Splitpanes>
+
+        <!-- SVG Connector Overlay -->
+        <DiffSvgConnector :key="connectorKey" :hunks="hunks" :container-width="containerSize.width" :container-height="containerSize.height" />
+      </div>
+    </div>
+
+    <!-- Deploy Script -->
+    <div v-else-if="activeTab === 'script'" class="flex-1 flex flex-col overflow-hidden">
+      <div class="flex items-center justify-between px-3 py-1.5 border-b shrink-0">
+        <span class="text-xs text-muted-foreground">{{ t("diff.deployScriptDesc") }}</span>
+        <div class="flex gap-1">
+          <Button variant="ghost" size="sm" class="h-6 px-2 text-xs gap-1" @click="copyDeploySql">
+            <Copy class="w-3 h-3" />
+            {{ t("diff.copy") }}
+          </Button>
+          <Button variant="ghost" size="sm" class="h-6 px-2 text-xs gap-1" @click="$emit('executeScript')">
+            <Play class="w-3 h-3" />
+            {{ t("diff.execute") }}
+          </Button>
+        </div>
+      </div>
+      <div class="flex-1 overflow-auto p-3">
+        <pre class="text-xs whitespace-pre-wrap font-mono">{{ deploySql || t("diff.noDeployScript") }}</pre>
+      </div>
+    </div>
+
+    <!-- Deploy Script All -->
+    <div v-else-if="activeTab === 'scriptAll'" class="flex-1 flex flex-col overflow-hidden">
+      <div class="flex items-center justify-between px-3 py-1.5 border-b shrink-0">
+        <span class="text-xs text-muted-foreground">{{ t("diff.deployScriptAllDesc") }}</span>
+        <div class="flex gap-1">
+          <Button variant="ghost" size="sm" class="h-6 px-2 text-xs gap-1" @click="copyDeploySqlAll">
+            <Copy class="w-3 h-3" />
+            {{ t("diff.copy") }}
+          </Button>
+          <Button variant="ghost" size="sm" class="h-6 px-2 text-xs gap-1" @click="$emit('executeScript')">
+            <Play class="w-3 h-3" />
+            {{ t("diff.executeAll") }}
+          </Button>
+        </div>
+      </div>
+      <div class="flex-1 overflow-auto p-3">
+        <pre class="text-xs whitespace-pre-wrap font-mono">{{ deploySqlAll || t("diff.noDeployScriptAll") }}</pre>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+:deep(.splitpanes--vertical > .splitpanes__splitter) {
+  background-color: hsl(var(--border));
+  width: 4px;
+  cursor: col-resize;
+  position: relative;
+}
+:deep(.splitpanes--vertical > .splitpanes__splitter:hover) {
+  background-color: hsl(var(--primary));
+}
+</style>
diff --git a/apps/desktop/src/components/diff/SchemaDiffDeployStep.vue b/apps/desktop/src/components/diff/SchemaDiffDeployStep.vue
new file mode 100644
index 0000000..26d3841
--- /dev/null
+++ b/apps/desktop/src/components/diff/SchemaDiffDeployStep.vue
@@ -0,0 +1,344 @@
+<script setup lang="ts">
+import { ref, computed, onMounted, onUnmounted, watch, shallowRef } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { useToast } from "@/composables/useToast";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useTheme } from "@/composables/useTheme";
+import { loadEditorTheme, editorFontTheme } from "@/lib/editor/editorThemes";
+import { createDbxCodeMirrorSqlDialect } from "@/lib/editor/codemirrorSqlDialect";
+import { Splitpanes, Pane } from "splitpanes";
+import type { SchemaDiffObject, DiffOperationType, DiffObjectKind } from "@/lib/schema/schemaDiff";
+import { ArrowLeft, Copy, Download, Play, Loader2, PlusCircle, XCircle, ArrowRightLeft, Table, Eye, FunctionSquare, ListOrdered, ScrollText, UserCog, ListTree, Link2, Zap } from "@lucide/vue";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const settingsStore = useSettingsStore();
+const { isDark, themePalette } = useTheme();
+
+const props = defineProps<{
+  deploySql: string;
+  selectedObjects: SchemaDiffObject[];
+  targetConnectionId: string;
+  targetDatabase: string;
+  targetSchema: string;
+  executing: boolean;
+}>();
+
+const emit = defineEmits<{
+  "update:deploySql": [sql: string];
+  back: [];
+  deploy: [];
+}>();
+
+const editorContainer = ref<HTMLDivElement>();
+const editorView = shallowRef<any>(null);
+const isEditorReady = ref(false);
+const selectedObjectId = ref<string | null>(null);
+
+// Parse object positions in deploySql
+const objectPositions = computed(() => {
+  const positions = new Map<string, { from: number; to: number }>();
+  const sql = props.deploySql;
+  for (const obj of topLevelObjects.value) {
+    const patterns = [`-- Create ${obj.objectKind}: ${obj.name}`, `-- Modify ${obj.objectKind}: ${obj.name}`, `-- Drop ${obj.objectKind}: ${obj.name}`];
+    for (const pattern of patterns) {
+      const index = sql.indexOf(pattern);
+      if (index !== -1) {
+        let endPos = sql.length;
+        const remaining = sql.slice(index + pattern.length);
+        const nextMatch = remaining.match(/--\s*(Create|Modify|Drop)\s+\w+:/);
+        if (nextMatch && nextMatch.index !== undefined) {
+          endPos = index + pattern.length + nextMatch.index;
+        }
+        positions.set(obj.id, { from: index, to: endPos });
+        break;
+      }
+    }
+  }
+  return positions;
+});
+
+async function handleSelectObject(obj: SchemaDiffObject) {
+  selectedObjectId.value = obj.id;
+  if (editorView.value) {
+    const pos = objectPositions.value.get(obj.id);
+    if (pos) {
+      const { EditorView } = await import("@codemirror/view");
+      editorView.value.dispatch({
+        effects: EditorView.scrollIntoView(pos.from, { y: "start" }),
+      });
+    }
+  }
+}
+
+// Filter top-level selected objects (exclude children and none)
+const topLevelObjects = computed(() => {
+  const operationOrder: Record<DiffOperationType, number> = { create: 0, modify: 1, delete: 2, none: 3 };
+  return props.selectedObjects
+    .filter((o) => {
+      const isTopLevel = !o.id.startsWith("col-") && !o.id.startsWith("idx-") && !o.id.startsWith("fk-") && !o.id.startsWith("trg-");
+      return o.selected && o.operationType !== "none" && isTopLevel;
+    })
+    .sort((a, b) => operationOrder[a.operationType] - operationOrder[b.operationType]);
+});
+
+const operationCounts = computed(() => {
+  const counts: Record<DiffOperationType, number> = { create: 0, modify: 0, delete: 0, none: 0 };
+  for (const obj of topLevelObjects.value) {
+    counts[obj.operationType]++;
+  }
+  return counts;
+});
+
+const operationIcons: Record<DiffOperationType, any> = {
+  modify: ArrowRightLeft,
+  create: PlusCircle,
+  delete: XCircle,
+  none: ArrowRightLeft,
+};
+
+const operationColors: Record<DiffOperationType, string> = {
+  modify: "text-blue-500",
+  create: "text-green-500",
+  delete: "text-red-500",
+  none: "text-muted-foreground",
+};
+
+// Initialize CodeMirror editor
+async function initEditor() {
+  if (!editorContainer.value) return;
+
+  const [{ EditorView }, { EditorState, Compartment }, langSql, { basicSetup }] = await Promise.all([import("@codemirror/view"), import("@codemirror/state"), import("@codemirror/lang-sql"), import("codemirror")]);
+
+  const themeComp = new Compartment();
+  const fontComp = new Compartment();
+
+  const editorTheme = settingsStore.editorSettings.theme;
+  const appAppearance = isDark.value ? "dark" : "light";
+  const fontSize = settingsStore.editorSettings.fontSize;
+  const fontFamily = settingsStore.editorSettings.fontFamily;
+
+  const themeExt = await loadEditorTheme(editorTheme, appAppearance, undefined, themePalette.value);
+  const fontExt = editorFontTheme(EditorView, fontSize, fontFamily, { fixedHeight: true, scrollable: true });
+
+  const dialect = createDbxCodeMirrorSqlDialect(langSql, "postgres");
+
+  const state = EditorState.create({
+    doc: props.deploySql,
+    extensions: [
+      basicSetup,
+      langSql.sql({ dialect }),
+      themeComp.of(themeExt),
+      fontComp.of(fontExt),
+      EditorView.updateListener.of((update: any) => {
+        if (update.docChanged) {
+          emit("update:deploySql", update.state.doc.toString());
+        }
+      }),
+    ],
+  });
+
+  editorView.value = new EditorView({ state, parent: editorContainer.value });
+  isEditorReady.value = true;
+}
+
+// Watch for external deploySql changes
+watch(
+  () => props.deploySql,
+  (newVal) => {
+    if (editorView.value && editorView.value.state.doc.toString() !== newVal) {
+      editorView.value.dispatch({
+        changes: { from: 0, to: editorView.value.state.doc.length, insert: newVal },
+      });
+    }
+  },
+);
+
+onMounted(() => {
+  initEditor();
+});
+
+onUnmounted(() => {
+  editorView.value?.destroy();
+  editorView.value = null;
+});
+
+function handleCopy() {
+  copyToClipboard(props.deploySql);
+  toast(t("diff.copied"), 2000);
+}
+
+async function handleExport() {
+  try {
+    const dbName = props.targetDatabase || "deploy";
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const defaultName = `${dbName}_deploy_${timestamp}.sql`;
+
+    const { save } = await import("@tauri-apps/plugin-dialog");
+    const path = await save({
+      defaultPath: defaultName,
+      filters: [{ name: "SQL", extensions: ["sql"] }],
+    });
+
+    if (path) {
+      const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+      await writeTextFile(path, props.deploySql);
+      toast(t("diff.exportSuccess"), 3000);
+    }
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  }
+}
+
+function handleDeploy() {
+  emit("deploy");
+}
+
+function getOperationLabel(type: DiffOperationType): string {
+  switch (type) {
+    case "create":
+      return t("diff.create");
+    case "delete":
+      return t("diff.delete");
+    case "modify":
+      return t("diff.modify");
+    default:
+      return "";
+  }
+}
+
+function getObjectIcon(kind: DiffObjectKind) {
+  switch (kind) {
+    case "table":
+      return Table;
+    case "view":
+      return Eye;
+    case "function":
+      return FunctionSquare;
+    case "sequence":
+      return ListOrdered;
+    case "rule":
+      return ScrollText;
+    case "owner":
+      return UserCog;
+    case "index":
+      return ListTree;
+    case "foreignKey":
+      return Link2;
+    case "trigger":
+      return Zap;
+    default:
+      return Table;
+  }
+}
+
+function getObjectIconColor(kind: DiffObjectKind): string {
+  switch (kind) {
+    case "table":
+      return "text-amber-500";
+    case "view":
+      return "text-cyan-500";
+    case "function":
+      return "text-purple-500";
+    case "sequence":
+      return "text-orange-500";
+    case "rule":
+      return "text-pink-500";
+    case "owner":
+      return "text-indigo-500";
+    case "index":
+      return "text-teal-500";
+    case "foreignKey":
+      return "text-lime-500";
+    case "trigger":
+      return "text-rose-500";
+    default:
+      return "text-muted-foreground";
+  }
+}
+</script>
+
+<template>
+  <div class="flex flex-col h-full">
+    <!-- Header -->
+    <div class="flex items-center justify-between px-3 py-2 border-b shrink-0">
+      <div class="flex items-center gap-2">
+        <Button variant="ghost" size="sm" class="h-7 px-2 text-xs gap-1" @click="$emit('back')">
+          <ArrowLeft class="w-3.5 h-3.5" />
+          {{ t("diff.backToResult") }}
+        </Button>
+        <span class="text-sm font-medium">{{ t("diff.deployReview") }}</span>
+        <span class="text-xs text-muted-foreground"> ({{ t("diff.selectedCount", { selected: topLevelObjects.length, total: topLevelObjects.length }) }}) </span>
+      </div>
+      <div class="flex items-center gap-3 text-xs">
+        <span class="text-green-500">{{ t("diff.create") }}: {{ operationCounts.create }}</span>
+        <span class="text-blue-500">{{ t("diff.modify") }}: {{ operationCounts.modify }}</span>
+        <span class="text-red-500">{{ t("diff.delete") }}: {{ operationCounts.delete }}</span>
+      </div>
+    </div>
+
+    <!-- Content -->
+    <Splitpanes class="flex-1 min-h-0">
+      <Pane size="30" min-size="20">
+        <div class="h-full overflow-auto p-2 space-y-0.5">
+          <div v-for="obj in topLevelObjects" :key="obj.id" class="flex items-center gap-2 px-2 py-1.5 rounded text-xs hover:bg-accent/50 cursor-pointer" :class="{ 'bg-primary/10': selectedObjectId === obj.id }" @click="handleSelectObject(obj)">
+            <component :is="operationIcons[obj.operationType]" class="w-3.5 h-3.5 shrink-0" :class="operationColors[obj.operationType]" />
+            <component :is="getObjectIcon(obj.objectKind)" class="w-3.5 h-3.5 shrink-0" :class="getObjectIconColor(obj.objectKind)" />
+            <span class="truncate">{{ obj.name }}</span>
+            <span class="text-[10px] text-muted-foreground shrink-0 ml-auto">
+              {{ getOperationLabel(obj.operationType) }}
+            </span>
+          </div>
+          <div v-if="topLevelObjects.length === 0" class="text-xs text-muted-foreground text-center py-4">
+            {{ t("diff.noObjectsSelected") }}
+          </div>
+        </div>
+      </Pane>
+
+      <Pane size="70" min-size="40">
+        <div ref="editorContainer" class="h-full w-full" />
+      </Pane>
+    </Splitpanes>
+
+    <!-- Footer -->
+    <div class="flex items-center justify-between px-3 py-2 border-t shrink-0 gap-2">
+      <div class="flex items-center gap-2">
+        <Button variant="outline" size="sm" class="h-7 text-xs gap-1" @click="handleCopy">
+          <Copy class="w-3.5 h-3.5" />
+          {{ t("diff.copyScript") }}
+        </Button>
+        <Button variant="outline" size="sm" class="h-7 text-xs gap-1" @click="handleExport">
+          <Download class="w-3.5 h-3.5" />
+          {{ t("diff.exportSql") }}
+        </Button>
+      </div>
+      <div class="flex items-center gap-2">
+        <Button variant="ghost" size="sm" class="h-7 text-xs gap-1" @click="$emit('back')">
+          <ArrowLeft class="w-3.5 h-3.5" />
+          {{ t("diff.backToResult") }}
+        </Button>
+        <Button variant="ghost" size="sm" class="h-7 text-xs" @click="$emit('back')">
+          {{ t("diff.cancel") }}
+        </Button>
+        <Button size="sm" class="h-7 text-xs gap-1" :disabled="topLevelObjects.length === 0 || executing" @click="handleDeploy">
+          <Loader2 v-if="executing" class="w-3.5 h-3.5 animate-spin" />
+          <Play v-else class="w-3.5 h-3.5" />
+          {{ t("diff.deployToServer") }}
+        </Button>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+:deep(.splitpanes--vertical > .splitpanes__splitter) {
+  width: 4px;
+  background: hsl(var(--border));
+  cursor: col-resize;
+}
+:deep(.splitpanes--vertical > .splitpanes__splitter:hover) {
+  background: hsl(var(--primary));
+}
+</style>
diff --git a/apps/desktop/src/components/diff/SchemaDiffDialog.vue b/apps/desktop/src/components/diff/SchemaDiffDialog.vue
new file mode 100644
index 0000000..045362e
--- /dev/null
+++ b/apps/desktop/src/components/diff/SchemaDiffDialog.vue
@@ -0,0 +1,887 @@
+<script setup lang="ts">
+import { computed, ref, watch, onBeforeUnmount } from "vue";
+import { useI18n } from "vue-i18n";
+import { Dialog, DialogHeader, DialogTitle, DialogFooter, DialogContent } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useToast } from "@/composables/useToast";
+import { GitCompareArrows, ArrowLeft, Play, Loader2, Maximize2, Minimize2, AlertTriangle, CircleCheck } from "@lucide/vue";
+import * as api from "@/lib/backend/api";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import { useSchemaDiffConfig } from "@/composables/useSchemaDiffConfig";
+import SchemaDiffConfigStep from "@/components/diff/SchemaDiffConfigStep.vue";
+import SchemaDiffObjectTree from "@/components/diff/SchemaDiffObjectTree.vue";
+import SchemaDiffDdlPanel from "@/components/diff/SchemaDiffDdlPanel.vue";
+import SchemaDiffDeployStep from "@/components/diff/SchemaDiffDeployStep.vue";
+import SchemaDiffOptionsPanel from "@/components/diff/SchemaDiffOptionsPanel.vue";
+
+import { getSchemaDiffOptionsForDbType } from "@/lib/schema/schemaDiffOptions";
+import { createConcurrencyLimiter, mapWithConcurrency, schemaDiffMetadataConcurrency } from "@/lib/schema/schemaDiffMetadataLoad";
+import { normalizeSchemaDiffCompareOptions } from "@/types/schemaDiff";
+import type { SchemaDiffCompareOptions, SchemaDiffConfig } from "@/types/schemaDiff";
+import type { ObjectSourceKind, TableInfo } from "@/types/database";
+import { buildDeploySqlForObjects, convertToSchemaDiffObjects, groupDiffObjects, schemaDiffDeployTargetSchema, type OperationGroup, type SchemaDiffObject, type DiffOperationType, type DiffObjectKind, type SchemaDiffPreparation, type TableSchemaDetail } from "@/lib/schema/schemaDiff";
+import { compileSchemaDiffTableFilter, filterSchemaDiffTables } from "@/lib/schema/schemaDiffTableFilter";
+import { Splitpanes, Pane } from "splitpanes";
+import "splitpanes/dist/splitpanes.css";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const open = defineModel<boolean>("open", { default: false });
+const store = useConnectionStore();
+
+const props = defineProps<{
+  prefillConnectionId?: string;
+  prefillDatabase?: string;
+  prefillSchema?: string;
+}>();
+
+// Wizard state
+const step = ref<"config" | "compare" | "result" | "deploy-review">("config");
+
+// Deploy confirm dialog
+const showConfirmDialog = ref(false);
+
+// Source/Target selections
+const sourceConnectionId = ref("");
+const sourceDatabase = ref("");
+const sourceSchema = ref("");
+const targetConnectionId = ref("");
+const targetDatabase = ref("");
+const targetSchema = ref("");
+const ignoreComments = ref(false);
+
+// Options panel
+const showOptionsPanel = ref(false);
+const optionTree = computed(() => {
+  const targetConfig = store.getConfig(targetConnectionId.value);
+  const dbType = targetConfig?.db_type || "postgres";
+  return getSchemaDiffOptionsForDbType(dbType);
+});
+
+// Compare state
+const loading = ref(false);
+const diffObjects = ref<SchemaDiffObject[]>([]);
+const diffGroups = ref<OperationGroup[]>([]);
+const selectedObjectId = ref<string | null>(null);
+const deploySql = ref("");
+const deploySqlAll = ref("");
+const executing = ref(false);
+const lastDiffResult = ref<SchemaDiffPreparation | null>(null);
+const targetDbVersion = ref<string | null>(null);
+const showResultDialog = ref(false);
+const deployResult = ref<{ success: boolean; message: string; affectedRows?: number } | null>(null);
+
+// Dialog size memory (width + height + splitpanes ratio)
+const DIALOG_SIZE_KEY = "dbx-schema-diff-size";
+const SPLITPANES_SIZE_KEY = "dbx-schema-diff-splitpanes-v2";
+const savedSize = JSON.parse(localStorage.getItem(DIALOG_SIZE_KEY) || "null");
+
+const savedSplitpanes = (() => {
+  try {
+    const raw = localStorage.getItem(SPLITPANES_SIZE_KEY);
+    if (!raw) return null;
+    const val = JSON.parse(raw);
+    return typeof val === "number" && val >= 10 && val <= 90 ? val : null;
+  } catch {
+    return null;
+  }
+})();
+
+// Splitpanes size memory (percentage for first pane)
+const splitpanesSize = ref(savedSplitpanes ?? 60);
+
+function handleSplitpanesResized(payload: { panes: { size: number }[] }) {
+  if (payload.panes && payload.panes.length > 0) {
+    const size = payload.panes[0].size;
+    splitpanesSize.value = size;
+    localStorage.setItem(SPLITPANES_SIZE_KEY, JSON.stringify(size));
+  }
+}
+
+const isMaximized = ref(false);
+
+// Config step: always use default size 1100x820
+// Result step: use saved size if exists
+const dialogStyle = computed(() => {
+  if (isMaximized.value) {
+    return {
+      width: "100vw",
+      height: "100vh",
+      maxWidth: "100vw",
+      maxHeight: "100vh",
+      borderRadius: "0",
+    };
+  }
+  if (step.value === "result") {
+    return {
+      width: savedSize?.width || "1100px",
+      height: savedSize?.height || "820px",
+      maxWidth: "calc(100vw - 2rem)",
+      maxHeight: "calc(100vh - 2rem)",
+    };
+  }
+  return {
+    width: "1100px",
+    height: "820px",
+    maxWidth: "calc(100vw - 2rem)",
+    maxHeight: "calc(100vh - 2rem)",
+  };
+});
+
+function toggleMaximize() {
+  isMaximized.value = !isMaximized.value;
+}
+
+let resizeObserver: ResizeObserver | null = null;
+let saveTimeout: number | null = null;
+
+function setupResizeObserver() {
+  const el = document.querySelector('[data-slot="dialog-content"]') as HTMLElement;
+  if (!el) return;
+
+  resizeObserver = new ResizeObserver((entries) => {
+    for (const entry of entries) {
+      const { width, height } = entry.contentRect;
+      if (saveTimeout) clearTimeout(saveTimeout);
+      saveTimeout = window.setTimeout(() => {
+        localStorage.setItem(
+          DIALOG_SIZE_KEY,
+          JSON.stringify({
+            width: `${width}px`,
+            height: `${height}px`,
+          }),
+        );
+      }, 500);
+    }
+  });
+
+  resizeObserver.observe(el);
+}
+
+function teardownResizeObserver() {
+  if (saveTimeout) clearTimeout(saveTimeout);
+  resizeObserver?.disconnect();
+  resizeObserver = null;
+}
+
+// Only enable resize observer in result step
+watch(
+  () => step.value,
+  (newStep) => {
+    if (newStep === "result") {
+      setTimeout(setupResizeObserver, 100);
+    } else {
+      teardownResizeObserver();
+    }
+  },
+);
+
+onBeforeUnmount(() => {
+  teardownResizeObserver();
+});
+
+// Config management
+const { configs, activeConfigId, activeConfig, recentConfigs, ensureDefaultConfig, updateActiveConfigConnection, updateActiveConfigOptions, saveToHistory, deleteFromHistory } = useSchemaDiffConfig();
+const schemaDiffPanelOptions = computed(() => normalizeSchemaDiffCompareOptions(activeConfig.value?.options, getDbType()));
+
+const selectedObject = computed(() => {
+  if (!selectedObjectId.value) return null;
+  for (const group of diffGroups.value) {
+    for (const typeGroup of group.typeGroups) {
+      const obj = typeGroup.objects.find((o) => o.id === selectedObjectId.value);
+      if (obj) return obj;
+    }
+  }
+  return null;
+});
+
+const canDeploy = computed(() => {
+  return diffObjects.value.some((o) => o.selected && o.operationType !== "none");
+});
+
+// Watch for prefilled values
+watch(
+  () => open.value,
+  (isOpen) => {
+    if (isOpen) {
+      ensureDefaultConfig();
+      if (props.prefillConnectionId) {
+        sourceConnectionId.value = props.prefillConnectionId;
+        if (props.prefillDatabase) {
+          sourceDatabase.value = props.prefillDatabase;
+        }
+        if (props.prefillSchema) {
+          sourceSchema.value = props.prefillSchema;
+        }
+      }
+    }
+  },
+  { immediate: true },
+);
+
+// Config sync
+watch([sourceConnectionId, sourceDatabase, sourceSchema, targetConnectionId, targetDatabase, targetSchema], ([srcConn, srcDb, srcSchema, tgtConn, tgtDb, tgtSchema]) => {
+  updateActiveConfigConnection({
+    sourceConnectionId: srcConn,
+    sourceDatabase: srcDb,
+    sourceSchema: srcSchema,
+    targetConnectionId: tgtConn,
+    targetDatabase: tgtDb,
+    targetSchema: tgtSchema,
+  });
+});
+
+// Auto-fetch target database version when connection/database changes
+watch(
+  () => [targetConnectionId.value, targetDatabase.value],
+  async ([connId, db]) => {
+    if (connId && db) {
+      await fetchDbVersion(connId, db, targetSchema.value);
+    } else {
+      targetDbVersion.value = null;
+    }
+  },
+);
+
+function getDbType(): string {
+  const targetConfig = store.getConfig(targetConnectionId.value);
+  return targetConfig?.db_type || "postgres";
+}
+
+function handleSwap() {
+  const tempConn = sourceConnectionId.value;
+  const tempDb = sourceDatabase.value;
+  const tempSchema = sourceSchema.value;
+  sourceConnectionId.value = targetConnectionId.value;
+  sourceDatabase.value = targetDatabase.value;
+  sourceSchema.value = targetSchema.value;
+  targetConnectionId.value = tempConn;
+  targetDatabase.value = tempDb;
+  targetSchema.value = tempSchema;
+}
+
+function handleOptionsUpdate(options: SchemaDiffCompareOptions) {
+  if (activeConfig.value) {
+    updateActiveConfigOptions(normalizeSchemaDiffCompareOptions(options, getDbType()));
+  }
+}
+
+/** Map a JDBC table_type to an ObjectSourceKind for getTableDdl routing.
+ *  Views and materialized views need the object_type parameter so the
+ *  backend can call DBMS_METADATA.GET_DDL with the correct type. */
+function isViewOrMaterializedView(tableType: string): ObjectSourceKind | undefined {
+  switch (tableType.toUpperCase().replace(/\s+/g, "_")) {
+    case "VIEW":
+      return "VIEW";
+    case "MATERIALIZED_VIEW":
+      return "MATERIALIZED_VIEW";
+    default:
+      return undefined;
+  }
+}
+
+interface SchemaDetailLoadContext {
+  connectionId: string;
+  database: string;
+  schema: string;
+  dbType: string;
+  options: SchemaDiffCompareOptions;
+}
+
+function shouldLoadIndexes(options: SchemaDiffCompareOptions): boolean {
+  return options.indexes || options.primaryKeys || options.uniqueKeys;
+}
+
+async function loadSchemaDetails(tables: TableInfo[], context: SchemaDetailLoadContext): Promise<TableSchemaDetail[]> {
+  const concurrency = schemaDiffMetadataConcurrency(context.dbType, tables.length);
+  const runMetadataQuery = createConcurrencyLimiter(concurrency);
+
+  return mapWithConcurrency(tables, concurrency, async (table) => {
+    const objectType = isViewOrMaterializedView(table.table_type);
+    const [columns, indexes, foreignKeys, triggers, ddl] = await Promise.all([
+      runMetadataQuery(() => api.getColumns(context.connectionId, context.database, context.schema, table.name)),
+      shouldLoadIndexes(context.options) ? runMetadataQuery(() => api.listIndexes(context.connectionId, context.database, context.schema, table.name)) : Promise.resolve([]),
+      context.options.foreignKeys ? runMetadataQuery(() => api.listForeignKeys(context.connectionId, context.database, context.schema, table.name)) : Promise.resolve([]),
+      context.options.triggers ? runMetadataQuery(() => api.listTriggers(context.connectionId, context.database, context.schema, table.name)) : Promise.resolve([]),
+      runMetadataQuery(() => api.getTableDdl(context.connectionId, context.database, context.schema, table.name, objectType)),
+    ]);
+
+    return { name: table.name, columns, indexes, foreignKeys, triggers, ddl };
+  });
+}
+
+async function handleCompare() {
+  loading.value = true;
+  step.value = "compare";
+
+  try {
+    const sourceConfig = store.getConfig(sourceConnectionId.value);
+    const targetConfig = store.getConfig(targetConnectionId.value);
+    const dbType = targetConfig?.db_type || "mysql";
+    const sourceDbType = sourceConfig?.db_type || dbType;
+    const opts = normalizeSchemaDiffCompareOptions(activeConfig.value?.options, dbType);
+    const tableFilter = compileSchemaDiffTableFilter(opts);
+
+    await store.ensureConnected(sourceConnectionId.value);
+    await store.ensureConnected(targetConnectionId.value);
+
+    const [srcTables, tgtTables] = await Promise.all([api.listTables(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value), api.listTables(targetConnectionId.value, targetDatabase.value, targetSchema.value)]);
+    const { sourceTables, targetTables } = filterSchemaDiffTables(srcTables, tgtTables, tableFilter);
+
+    const sourceDetails = await loadSchemaDetails(sourceTables, {
+      connectionId: sourceConnectionId.value,
+      database: sourceDatabase.value,
+      schema: sourceSchema.value,
+      dbType: sourceDbType,
+      options: opts,
+    });
+
+    const targetDetails = await loadSchemaDetails(targetTables, {
+      connectionId: targetConnectionId.value,
+      database: targetDatabase.value,
+      schema: targetSchema.value,
+      dbType,
+      options: opts,
+    });
+
+    const isPostgresLike = dbType === "postgres" || dbType === "opengauss";
+
+    // Fetch new object types for PostgreSQL-like databases
+    const promises: Promise<any>[] = [];
+    if (isPostgresLike && opts?.functions) {
+      promises.push(api.listFunctions(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value));
+      promises.push(api.listFunctions(targetConnectionId.value, targetDatabase.value, targetSchema.value));
+    }
+    if (isPostgresLike && opts?.sequences) {
+      promises.push(api.listSequences(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, !!opts?.sequenceLastValues));
+      promises.push(api.listSequences(targetConnectionId.value, targetDatabase.value, targetSchema.value, !!opts?.sequenceLastValues));
+    }
+    if (isPostgresLike && opts?.rules) {
+      promises.push(api.listRules(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value));
+      promises.push(api.listRules(targetConnectionId.value, targetDatabase.value, targetSchema.value));
+    }
+    if (isPostgresLike && opts?.owners) {
+      promises.push(api.listOwners(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value));
+      promises.push(api.listOwners(targetConnectionId.value, targetDatabase.value, targetSchema.value));
+    }
+
+    const results = await Promise.all(promises);
+    let idx = 0;
+    const srcFunctions = opts?.functions && isPostgresLike ? results[idx++] : [];
+    const tgtFunctions = opts?.functions && isPostgresLike ? results[idx++] : [];
+    const srcSequences = opts?.sequences && isPostgresLike ? results[idx++] : [];
+    const tgtSequences = opts?.sequences && isPostgresLike ? results[idx++] : [];
+    const srcRules = opts?.rules && isPostgresLike ? results[idx++] : [];
+    const tgtRules = opts?.rules && isPostgresLike ? results[idx++] : [];
+    const srcOwners = opts?.owners && isPostgresLike ? results[idx++] : [];
+    const tgtOwners = opts?.owners && isPostgresLike ? results[idx++] : [];
+
+    const result = await api.prepareSchemaDiff({
+      sourceTables,
+      targetTables,
+      sourceDetails,
+      targetDetails,
+      sourceFunctions: srcFunctions,
+      targetFunctions: tgtFunctions,
+      sourceSequences: srcSequences,
+      targetSequences: tgtSequences,
+      sourceRules: srcRules,
+      targetRules: tgtRules,
+      sourceOwners: srcOwners,
+      targetOwners: tgtOwners,
+      databaseType: dbType,
+      targetSchema: schemaDiffDeployTargetSchema(dbType, targetDatabase.value, targetSchema.value),
+      ignoreComments: ignoreComments.value,
+      cascadeDelete: opts?.cascadeDelete ?? false,
+      compareColumnOrder: opts.compareColumnOrder,
+    });
+
+    // Convert to unified objects
+    diffObjects.value = convertToSchemaDiffObjects(result.diffs, result.functionDiffs, result.sequenceDiffs, result.ruleDiffs, result.ownerDiffs);
+
+    // Group by operation type and object kind
+    diffGroups.value = groupDiffObjects(diffObjects.value);
+
+    // Save full result and generate deploy SQL
+    lastDiffResult.value = result;
+    deploySqlAll.value = result.syncSql;
+    regenerateDeploySql();
+
+    step.value = "result";
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+    step.value = "config";
+  } finally {
+    loading.value = false;
+  }
+}
+
+function handleToggleGroup(operationType: DiffOperationType) {
+  diffGroups.value = diffGroups.value.map((g) => (g.operationType === operationType ? { ...g, expanded: !g.expanded } : g));
+}
+
+function handleToggleTypeGroup(operationType: DiffOperationType, kind: DiffObjectKind) {
+  diffGroups.value = diffGroups.value.map((g) => {
+    if (g.operationType !== operationType) return g;
+    return {
+      ...g,
+      typeGroups: g.typeGroups.map((tg) => (tg.kind === kind ? { ...tg, expanded: !tg.expanded } : tg)),
+    };
+  });
+}
+
+function handleToggleGroupSelection(operationType: DiffOperationType, selected: boolean) {
+  diffGroups.value = diffGroups.value.map((g) => {
+    if (g.operationType !== operationType) return g;
+    return {
+      ...g,
+      selectedCount: selected ? g.count : 0,
+      typeGroups: g.typeGroups.map((tg) => {
+        for (const obj of tg.objects) {
+          obj.selected = selected;
+        }
+        return { ...tg, selectedCount: selected ? tg.objects.length : 0 };
+      }),
+    };
+  });
+  regenerateDeploySql();
+}
+
+function handleToggleTypeSelection(operationType: DiffOperationType, kind: DiffObjectKind, selected: boolean) {
+  diffGroups.value = diffGroups.value.map((g) => {
+    if (g.operationType !== operationType) return g;
+    const newTypeGroups = g.typeGroups.map((tg) => {
+      if (tg.kind !== kind) return tg;
+      for (const obj of tg.objects) {
+        obj.selected = selected;
+      }
+      return { ...tg, selectedCount: selected ? tg.objects.length : 0 };
+    });
+    const newSelectedCount = newTypeGroups.reduce((sum, tg) => sum + tg.selectedCount, 0);
+    return { ...g, selectedCount: newSelectedCount, typeGroups: newTypeGroups };
+  });
+  regenerateDeploySql();
+}
+
+function handleToggleObjectSelection(objectId: string, selected: boolean) {
+  const obj = diffObjects.value.find((o) => o.id === objectId);
+  if (!obj) return;
+
+  obj.selected = selected;
+
+  // Update diffGroups with new references to trigger reactivity
+  diffGroups.value = diffGroups.value.map((g) => {
+    if (g.operationType !== obj.operationType) return g;
+    const newTypeGroups = g.typeGroups.map((tg) => {
+      if (tg.kind !== obj.objectKind) return tg;
+      const newSelectedCount = tg.objects.filter((o) => o.selected).length;
+      return { ...tg, selectedCount: newSelectedCount };
+    });
+    const newSelectedCount = newTypeGroups.reduce((sum, tg) => sum + tg.selectedCount, 0);
+    return { ...g, selectedCount: newSelectedCount, typeGroups: newTypeGroups };
+  });
+
+  regenerateDeploySql();
+}
+
+function regenerateDeploySql() {
+  deploySql.value = buildDeploySqlForObjects(diffObjects.value);
+}
+
+async function handleExecuteScript() {
+  if (!deploySql.value || deploySql.value.startsWith("-- ")) {
+    toast(t("diff.noObjectsSelected"), 3000);
+    return;
+  }
+
+  executing.value = true;
+  try {
+    const result = await executeWithProductionSqlGuard({
+      connection: store.getConfig(targetConnectionId.value),
+      database: targetDatabase.value,
+      sql: deploySql.value,
+      source: t("production.sourceSchemaDiff"),
+      execute: () => api.executeScript(targetConnectionId.value, targetDatabase.value, deploySql.value, targetSchema.value),
+    });
+    if (!result) return;
+    toast(t("diff.executeSuccess"), 3000);
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    executing.value = false;
+  }
+}
+async function handleSelectObject(obj: SchemaDiffObject) {
+  selectedObjectId.value = obj.id;
+
+  // Dynamically fetch DDL for objects that don't have pre-generated DDL
+  // (views need runtime retrieval; functions should already have definition)
+  const objectTypeMap: Record<string, ObjectSourceKind> = {
+    function: "FUNCTION",
+    view: "VIEW",
+  };
+  const objectType = objectTypeMap[obj.objectKind];
+  if (!objectType) return;
+
+  try {
+    // For "create" objects: source has it, target doesn't → fetch source DDL
+    if (obj.operationType === "create" && !obj.sourceDdl) {
+      const result = await api.getObjectSource(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, obj.name, objectType);
+      if (result?.source) obj.sourceDdl = result.source;
+    }
+
+    // For "delete" objects: target has it, source doesn't → fetch target DDL
+    if (obj.operationType === "delete" && !obj.targetDdl) {
+      const result = await api.getObjectSource(targetConnectionId.value, targetDatabase.value, targetSchema.value, obj.name, objectType);
+      if (result?.source) obj.targetDdl = result.source;
+    }
+
+    // For "modify" objects: fetch whichever side is missing
+    if (obj.operationType === "modify") {
+      if (!obj.sourceDdl) {
+        const result = await api.getObjectSource(sourceConnectionId.value, sourceDatabase.value, sourceSchema.value, obj.name, objectType);
+        if (result?.source) obj.sourceDdl = result.source;
+      }
+      if (!obj.targetDdl) {
+        const result = await api.getObjectSource(targetConnectionId.value, targetDatabase.value, targetSchema.value, obj.name, objectType);
+        if (result?.source) obj.targetDdl = result.source;
+      }
+    }
+  } catch {
+    // Silently ignore errors
+  }
+}
+function handleLoadHistoryConfig(config: SchemaDiffConfig) {
+  sourceConnectionId.value = config.sourceConnectionId;
+  sourceDatabase.value = config.sourceDatabase;
+  sourceSchema.value = config.sourceSchema;
+  targetConnectionId.value = config.targetConnectionId;
+  targetDatabase.value = config.targetDatabase;
+  targetSchema.value = config.targetSchema;
+  if (config.options) {
+    updateActiveConfigOptions(config.options);
+  }
+}
+
+function handleSaveConfig() {
+  if (activeConfig.value) {
+    const name = window.prompt(t("diff.saveConfigPrompt") || "Please enter config name:", activeConfig.value.name || "Default");
+    if (name === null) return; // User cancelled
+    const configToSave = { ...activeConfig.value, name: name.trim() || "Default" };
+    saveToHistory(configToSave);
+    toast(t("diff.configSaved"), 2000);
+  }
+}
+
+function handleDeleteHistoryConfig(configId: string) {
+  deleteFromHistory(configId);
+  toast(t("diff.configDeleted"), 2000);
+}
+
+async function fetchDbVersion(connectionId: string, database: string, schema: string) {
+  try {
+    await store.ensureConnected(connectionId);
+    const config = store.getConfig(connectionId);
+    const dbType = config?.db_type;
+    let sql = "";
+    switch (dbType) {
+      case "postgres":
+      case "opengauss":
+        sql = "SELECT version()";
+        break;
+      case "mysql":
+        sql = "SELECT VERSION()";
+        break;
+      case "sqlite":
+        sql = "SELECT sqlite_version()";
+        break;
+      default:
+        return;
+    }
+    const result = await api.executeQuery(connectionId, database, sql, schema || undefined);
+    if (result.rows && result.rows.length > 0) {
+      targetDbVersion.value = String(result.rows[0][0]);
+    } else {
+      console.warn("[fetchDbVersion] No rows returned");
+    }
+  } catch (e) {
+    console.error("[fetchDbVersion] Failed to fetch version:", e);
+    targetDbVersion.value = null;
+  }
+}
+
+function handleDeployReview() {
+  const selectedObjects = diffObjects.value.filter((o) => o.selected && o.operationType !== "none");
+  if (selectedObjects.length === 0) {
+    toast(t("diff.noObjectsSelected"), 3000);
+    return;
+  }
+  step.value = "deploy-review";
+  fetchDbVersion(targetConnectionId.value, targetDatabase.value, targetSchema.value);
+}
+
+async function handleDeploy() {
+  showConfirmDialog.value = true;
+}
+
+async function onConfirmDeploy() {
+  showConfirmDialog.value = false;
+  executing.value = true;
+  try {
+    const result = await executeWithProductionSqlGuard({
+      connection: store.getConfig(targetConnectionId.value),
+      database: targetDatabase.value,
+      sql: deploySql.value,
+      source: t("production.sourceSchemaDiff"),
+      execute: () => api.executeScript(targetConnectionId.value, targetDatabase.value, deploySql.value, targetSchema.value),
+    });
+    if (!result) return;
+    deployResult.value = {
+      success: true,
+      message: t("diff.deploySuccess"),
+      affectedRows: result.affected_rows,
+    };
+    showResultDialog.value = true;
+  } catch (e: any) {
+    deployResult.value = {
+      success: false,
+      message: e?.message || String(e),
+    };
+    showResultDialog.value = true;
+  } finally {
+    executing.value = false;
+  }
+}
+
+const deployStats = computed(() => {
+  const selected = diffObjects.value.filter((o) => o.selected && o.operationType !== "none");
+  const isTopLevel = (o: SchemaDiffObject) => !o.id.startsWith("col-") && !o.id.startsWith("idx-") && !o.id.startsWith("fk-") && !o.id.startsWith("trg-");
+  const topLevel = selected.filter(isTopLevel);
+  return {
+    create: topLevel.filter((o) => o.operationType === "create").length,
+    modify: topLevel.filter((o) => o.operationType === "modify").length,
+    delete: topLevel.filter((o) => o.operationType === "delete").length,
+    total: topLevel.length,
+  };
+});
+
+const targetConnectionInfo = computed(() => {
+  const config = store.getConfig(targetConnectionId.value);
+  if (!config) return null;
+  return {
+    host: config.host || "-",
+    port: config.port || "-",
+    dbType: config.db_type || "-",
+  };
+});
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent :class="['min-w-[800px] flex flex-col overflow-hidden', isMaximized ? '' : 'resize']" :style="dialogStyle" @interact-outside.prevent>
+      <Button variant="ghost" size="icon-sm" class="absolute top-2 right-10 z-10" @click="toggleMaximize">
+        <Maximize2 v-if="!isMaximized" class="w-4 h-4" />
+        <Minimize2 v-else class="w-4 h-4" />
+        <span class="sr-only">{{ isMaximized ? t("diff.restore") : t("diff.maximize") }}</span>
+      </Button>
+
+      <DialogHeader>
+        <DialogTitle class="flex items-center gap-2">
+          <GitCompareArrows class="w-4 h-4" />
+          {{ t("diff.title") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="flex-1 min-h-0 overflow-hidden flex flex-col">
+        <!-- Config Step -->
+        <SchemaDiffConfigStep
+          v-if="step === 'config'"
+          v-model:source-connection-id="sourceConnectionId"
+          v-model:source-database="sourceDatabase"
+          v-model:source-schema="sourceSchema"
+          v-model:target-connection-id="targetConnectionId"
+          v-model:target-database="targetDatabase"
+          v-model:target-schema="targetSchema"
+          v-model:ignore-comments="ignoreComments"
+          :configs="configs"
+          :active-config-id="activeConfigId"
+          :options="activeConfig?.options"
+          :loading="loading"
+          :recent-configs="recentConfigs"
+          @compare="handleCompare"
+          @swap="handleSwap"
+          @show-options="showOptionsPanel = true"
+          @save-config="handleSaveConfig"
+          @load-history-config="handleLoadHistoryConfig"
+          @delete-history-config="handleDeleteHistoryConfig"
+        />
+
+        <!-- Compare Loading -->
+        <div v-else-if="step === 'compare'" class="flex items-center justify-center py-20">
+          <Loader2 class="w-6 h-6 animate-spin mr-2" />
+          <span class="text-sm text-muted-foreground">{{ t("diff.comparing") }}</span>
+        </div>
+
+        <!-- Result Step -->
+        <template v-else-if="step === 'result'">
+          <Splitpanes horizontal class="flex-1 min-h-0" @resized="handleSplitpanesResized">
+            <Pane :size="splitpanesSize" min-size="20">
+              <div class="h-full overflow-auto">
+                <SchemaDiffObjectTree
+                  :groups="diffGroups"
+                  :selected-object-id="selectedObject?.id ?? null"
+                  @toggle-group="handleToggleGroup"
+                  @toggle-type-group="handleToggleTypeGroup"
+                  @toggle-group-selection="handleToggleGroupSelection"
+                  @toggle-type-selection="handleToggleTypeSelection"
+                  @toggle-object-selection="handleToggleObjectSelection"
+                  @select-object="handleSelectObject"
+                />
+              </div>
+            </Pane>
+            <Pane :size="100 - splitpanesSize" min-size="20">
+              <SchemaDiffDdlPanel :selected-object="selectedObject" :deploy-sql="deploySql" :deploy-sql-all="deploySqlAll" @execute-script="handleExecuteScript" />
+            </Pane>
+          </Splitpanes>
+        </template>
+
+        <!-- Deploy Review Step -->
+        <template v-else-if="step === 'deploy-review'">
+          <SchemaDiffDeployStep v-model:deploy-sql="deploySql" :selected-objects="diffObjects" :target-connection-id="targetConnectionId" :target-database="targetDatabase" :target-schema="targetSchema" :executing="executing" @back="step = 'result'" @deploy="handleDeploy" />
+        </template>
+      </div>
+
+      <!-- Footer -->
+      <DialogFooter class="flex items-center justify-between">
+        <div v-if="step === 'result'" class="flex items-center gap-2">
+          <Button variant="outline" size="sm" @click="step = 'config'">
+            <ArrowLeft class="w-3.5 h-3.5 mr-1" />
+            {{ t("diff.prevStep") }}
+          </Button>
+          <Button variant="outline" size="sm" :disabled="loading" @click="handleCompare">
+            <GitCompareArrows class="w-3.5 h-3.5 mr-1" />
+            {{ t("diff.recompare") }}
+          </Button>
+        </div>
+        <div v-else></div>
+
+        <div v-if="step === 'result'" class="flex items-center gap-2">
+          <Button size="sm" :disabled="!canDeploy || executing" @click="handleDeployReview">
+            <Loader2 v-if="executing" class="w-3.5 h-3.5 mr-1 animate-spin" />
+            <Play v-else class="w-3.5 h-3.5 mr-1" />
+            {{ t("diff.nextStepDeploy") }}
+          </Button>
+        </div>
+      </DialogFooter>
+
+      <!-- Deploy Confirm Dialog -->
+      <Dialog v-model:open="showConfirmDialog">
+        <DialogContent class="sm:max-w-[520px]">
+          <DialogHeader>
+            <DialogTitle class="flex items-center gap-2 text-destructive">
+              <AlertTriangle class="h-5 w-5" />
+              {{ t("diff.deployConfirmTitle") }}
+            </DialogTitle>
+          </DialogHeader>
+
+          <div class="py-2 space-y-3">
+            <p class="text-sm text-muted-foreground">{{ t("diff.deployConfirmMessage") }}</p>
+
+            <div class="bg-muted p-3 rounded text-xs font-mono space-y-1">
+              <div v-if="targetConnectionInfo">
+                {{ t("diff.targetServer") }}: {{ targetConnectionInfo.host }}:{{ targetConnectionInfo.port }}
+                <span class="text-muted-foreground">({{ targetConnectionInfo.dbType }})</span>
+              </div>
+              <div v-if="targetDbVersion">{{ t("diff.dbVersion") }}: {{ targetDbVersion }}</div>
+              <div>
+                {{ t("diff.targetDatabase") }}:
+                <span class="text-primary font-bold">{{ targetDatabase }}</span>
+              </div>
+              <div>
+                {{ t("diff.targetSchema") }}:
+                <span class="text-primary font-bold">{{ targetSchema || "-" }}</span>
+              </div>
+            </div>
+
+            <div class="flex gap-4 text-sm">
+              <span class="text-green-600">{{ t("diff.create") }}: {{ deployStats.create }}</span>
+              <span class="text-blue-600">{{ t("diff.modify") }}: {{ deployStats.modify }}</span>
+              <span class="text-red-600">{{ t("diff.delete") }}: {{ deployStats.delete }}</span>
+            </div>
+          </div>
+
+          <DialogFooter>
+            <Button variant="outline" @click="showConfirmDialog = false">{{ t("diff.cancel") }}</Button>
+            <Button variant="destructive" :disabled="executing" @click="onConfirmDeploy">
+              <Loader2 v-if="executing" class="w-3.5 h-3.5 mr-1 animate-spin" />
+              {{ t("diff.confirmDeploy") }}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+
+      <!-- Deploy Result Dialog -->
+      <Dialog v-model:open="showResultDialog">
+        <DialogContent class="sm:max-w-[480px]">
+          <DialogHeader>
+            <DialogTitle class="flex items-center gap-2" :class="deployResult?.success ? 'text-green-500' : 'text-destructive'">
+              <AlertTriangle v-if="!deployResult?.success" class="h-5 w-5" />
+              <CircleCheck v-else class="h-5 w-5" />
+              {{ deployResult?.success ? t("diff.deploySuccess") : t("diff.deployFailed") }}
+            </DialogTitle>
+          </DialogHeader>
+
+          <div class="py-2">
+            <div v-if="deployResult?.success" class="space-y-2">
+              <p class="text-sm text-muted-foreground">{{ t("diff.deploySuccessMessage") }}</p>
+              <div class="bg-muted p-3 rounded text-xs font-mono">
+                <div>{{ t("diff.affectedRows") }}: {{ deployResult.affectedRows ?? 0 }}</div>
+                <div>{{ t("diff.executedStatements") }}: {{ deployStats.total }}</div>
+              </div>
+            </div>
+            <div v-else class="space-y-2">
+              <p class="text-sm text-muted-foreground">{{ t("diff.deployFailedMessage") }}</p>
+              <pre class="text-xs bg-destructive/10 text-destructive p-3 rounded overflow-auto max-h-40 font-mono whitespace-pre-wrap">{{ deployResult?.message }}</pre>
+            </div>
+          </div>
+
+          <DialogFooter>
+            <Button variant="outline" @click="showResultDialog = false">{{ t("diff.close") }}</Button>
+            <Button
+              v-if="deployResult?.success"
+              @click="
+                showResultDialog = false;
+                step = 'result';
+              "
+            >
+              {{ t("diff.backToResult") }}
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+
+      <!-- Options Panel Overlay -->
+      <div v-if="showOptionsPanel" class="absolute inset-0 bg-background/80 backdrop-blur-sm z-50 flex items-center justify-center" @click.self="showOptionsPanel = false">
+        <div class="bg-card border rounded-lg shadow-lg w-[760px] max-w-[calc(100vw-2rem)] max-h-[80vh] overflow-auto p-4">
+          <div class="flex items-center justify-between mb-4">
+            <h3 class="text-sm font-medium">{{ t("schemaDiff.optionsTitle") }}</h3>
+            <Button variant="ghost" size="sm" @click="showOptionsPanel = false">✕</Button>
+          </div>
+          <SchemaDiffOptionsPanel :options="schemaDiffPanelOptions" :option-tree="optionTree" @update:options="handleOptionsUpdate" @close="showOptionsPanel = false" />
+        </div>
+      </div>
+    </DialogContent>
+  </Dialog>
+</template>
+
+<style scoped>
+:deep(.splitpanes--horizontal > .splitpanes__splitter) {
+  height: 8px;
+  background: hsl(var(--border));
+  cursor: row-resize;
+}
+:deep(.splitpanes--horizontal > .splitpanes__splitter:hover) {
+  background: hsl(var(--primary));
+}
+</style>
diff --git a/apps/desktop/src/components/diff/SchemaDiffObjectTree.vue b/apps/desktop/src/components/diff/SchemaDiffObjectTree.vue
new file mode 100644
index 0000000..dbd973b
--- /dev/null
+++ b/apps/desktop/src/components/diff/SchemaDiffObjectTree.vue
@@ -0,0 +1,245 @@
+<script setup lang="ts">
+import { useI18n } from "vue-i18n";
+import type { SchemaDiffObject, DiffOperationType, DiffObjectKind } from "@/lib/schema/schemaDiff";
+import { Table, Eye, FunctionSquare, ListOrdered, ScrollText, UserCog, ListTree, Link2, Zap, ChevronDown, ChevronRight, ArrowRightLeft, PlusCircle, XCircle, MinusCircle } from "@lucide/vue";
+
+const { t } = useI18n();
+
+interface ObjectTypeGroup {
+  kind: DiffObjectKind;
+  label: string;
+  objects: SchemaDiffObject[];
+  expanded: boolean;
+}
+
+interface OperationGroup {
+  operationType: DiffOperationType;
+  label: string;
+  count: number;
+  selectedCount: number;
+  expanded: boolean;
+  typeGroups: ObjectTypeGroup[];
+}
+
+const props = defineProps<{
+  groups: OperationGroup[];
+  selectedObjectId?: string | null;
+}>();
+
+const emit = defineEmits<{
+  (e: "toggleGroup", operationType: DiffOperationType): void;
+  (e: "toggleTypeGroup", operationType: DiffOperationType, kind: DiffObjectKind): void;
+  (e: "toggleGroupSelection", operationType: DiffOperationType, selected: boolean): void;
+  (e: "toggleTypeSelection", operationType: DiffOperationType, kind: DiffObjectKind, selected: boolean): void;
+  (e: "toggleObjectSelection", objectId: string, selected: boolean): void;
+  (e: "selectObject", object: SchemaDiffObject): void;
+}>();
+
+const operationIcons: Record<DiffOperationType, any> = {
+  modify: ArrowRightLeft,
+  create: PlusCircle,
+  delete: XCircle,
+  none: MinusCircle,
+};
+
+const operationColors: Record<DiffOperationType, string> = {
+  modify: "text-blue-500",
+  create: "text-green-500",
+  delete: "text-red-500",
+  none: "text-muted-foreground",
+};
+
+const operationBgColors: Record<DiffOperationType, string> = {
+  modify: "bg-blue-500/10 border-blue-500/20",
+  create: "bg-green-500/10 border-green-500/20",
+  delete: "bg-red-500/10 border-red-500/20",
+  none: "bg-muted/30 border-muted",
+};
+
+function getObjectIcon(kind: DiffObjectKind) {
+  switch (kind) {
+    case "table":
+      return Table;
+    case "view":
+      return Eye;
+    case "function":
+      return FunctionSquare;
+    case "sequence":
+      return ListOrdered;
+    case "rule":
+      return ScrollText;
+    case "owner":
+      return UserCog;
+    case "index":
+      return ListTree;
+    case "foreignKey":
+      return Link2;
+    case "trigger":
+      return Zap;
+    default:
+      return Table;
+  }
+}
+
+function getObjectIconColor(kind: DiffObjectKind): string {
+  switch (kind) {
+    case "table":
+      return "text-amber-500";
+    case "view":
+      return "text-cyan-500";
+    case "function":
+      return "text-purple-500";
+    case "sequence":
+      return "text-orange-500";
+    case "rule":
+      return "text-pink-500";
+    case "owner":
+      return "text-indigo-500";
+    case "index":
+      return "text-teal-500";
+    case "foreignKey":
+      return "text-lime-500";
+    case "trigger":
+      return "text-rose-500";
+    default:
+      return "text-muted-foreground";
+  }
+}
+
+function getObjectTypeLabel(kind: DiffObjectKind): string {
+  switch (kind) {
+    case "table":
+      return "diff.objectKindLabel.table";
+    case "view":
+      return "diff.objectKindLabel.view";
+    case "function":
+      return "diff.objectKindLabel.function";
+    case "sequence":
+      return "diff.objectKindLabel.sequence";
+    case "rule":
+      return "diff.objectKindLabel.rule";
+    case "owner":
+      return "diff.objectKindLabel.owner";
+    case "index":
+      return "diff.objectKindLabel.index";
+    case "foreignKey":
+      return "diff.objectKindLabel.foreignKey";
+    case "trigger":
+      return "diff.objectKindLabel.trigger";
+    default:
+      return kind;
+  }
+}
+
+function isGroupFullySelected(group: OperationGroup): boolean {
+  return group.count > 0 && group.selectedCount === group.count;
+}
+
+function isGroupPartiallySelected(group: OperationGroup): boolean {
+  return group.selectedCount > 0 && group.selectedCount < group.count;
+}
+
+function isTypeGroupFullySelected(typeGroup: ObjectTypeGroup): boolean {
+  return typeGroup.objects.length > 0 && typeGroup.objects.every((o) => o.selected);
+}
+
+function isTypeGroupPartiallySelected(typeGroup: ObjectTypeGroup): boolean {
+  const selectedCount = typeGroup.objects.filter((o) => o.selected).length;
+  return selectedCount > 0 && selectedCount < typeGroup.objects.length;
+}
+
+function onGroupCheckboxChange(group: OperationGroup, event: Event) {
+  const checked = (event.target as HTMLInputElement).checked;
+  emit("toggleGroupSelection", group.operationType, checked);
+}
+
+function onTypeCheckboxChange(group: OperationGroup, typeGroup: ObjectTypeGroup, event: Event) {
+  const checked = (event.target as HTMLInputElement).checked;
+  emit("toggleTypeSelection", group.operationType, typeGroup.kind, checked);
+}
+
+function onObjectCheckboxChange(obj: SchemaDiffObject, event: Event) {
+  const checked = (event.target as HTMLInputElement).checked;
+  emit("toggleObjectSelection", obj.id, checked);
+}
+
+function formatObjectName(obj: SchemaDiffObject): string {
+  if (obj.objectKind === "function" && obj.arguments) {
+    return `${obj.name}(${obj.arguments})`;
+  }
+  return obj.name;
+}
+</script>
+
+<template>
+  <div class="space-y-1">
+    <!-- Header -->
+    <div class="grid grid-cols-[1fr_60px_1fr] gap-2 px-2 py-1.5 text-xs font-medium text-muted-foreground border-b">
+      <div class="text-center">{{ t("diff.sourceObject") }}</div>
+      <div class="text-center">{{ t("diff.operation") }}</div>
+      <div class="text-center">{{ t("diff.targetObject") }}</div>
+    </div>
+
+    <!-- Operation Groups -->
+    <div v-for="group in groups" :key="group.operationType" class="border rounded-md overflow-hidden">
+      <!-- Operation Group Header -->
+      <button class="flex items-center gap-2 w-full px-3 py-2 text-sm font-medium transition-colors" :class="operationBgColors[group.operationType]" @click="$emit('toggleGroup', group.operationType)">
+        <ChevronDown v-if="group.expanded" class="w-4 h-4 shrink-0" />
+        <ChevronRight v-else class="w-4 h-4 shrink-0" />
+
+        <input type="checkbox" class="accent-primary shrink-0" :checked="isGroupFullySelected(group)" :indeterminate="isGroupPartiallySelected(group)" @click.stop @change="onGroupCheckboxChange(group, $event)" />
+
+        <component :is="operationIcons[group.operationType]" class="w-4 h-4 shrink-0" :class="operationColors[group.operationType]" />
+        <span :class="operationColors[group.operationType]">{{ t(group.label) }}</span>
+        <span class="text-xs text-muted-foreground ml-1"> ({{ t("diff.selectedCount", { selected: group.selectedCount, total: group.count }) }}) </span>
+      </button>
+
+      <!-- Type Groups -->
+      <div v-if="group.expanded" class="divide-y divide-border/30">
+        <div v-for="typeGroup in group.typeGroups" :key="typeGroup.kind" class="border-l-2 border-l-border/50 ml-2">
+          <!-- Type Group Header -->
+          <button class="flex items-center gap-2 w-full px-3 py-1.5 text-xs font-medium hover:bg-accent/20 transition-colors" @click="$emit('toggleTypeGroup', group.operationType, typeGroup.kind)">
+            <ChevronDown v-if="typeGroup.expanded" class="w-3.5 h-3.5 shrink-0" />
+            <ChevronRight v-else class="w-3.5 h-3.5 shrink-0" />
+
+            <input type="checkbox" class="accent-primary shrink-0" :checked="isTypeGroupFullySelected(typeGroup)" :indeterminate="isTypeGroupPartiallySelected(typeGroup)" @click.stop @change="onTypeCheckboxChange(group, typeGroup, $event)" />
+
+            <component :is="getObjectIcon(typeGroup.kind)" class="w-3.5 h-3.5 shrink-0" :class="getObjectIconColor(typeGroup.kind)" />
+            <span>{{ t(getObjectTypeLabel(typeGroup.kind)) }}</span>
+            <span class="text-xs text-muted-foreground">({{ typeGroup.objects.length }})</span>
+          </button>
+
+          <!-- Objects -->
+          <div v-if="typeGroup.expanded" class="divide-y divide-border/20">
+            <div v-for="obj in typeGroup.objects" :key="obj.id" class="grid grid-cols-[1fr_60px_1fr] gap-2 px-3 py-1 items-center hover:bg-accent/30 cursor-pointer ml-8" :class="{ 'bg-primary/10': selectedObjectId === obj.id }" @click="$emit('selectObject', obj)">
+              <!-- Source (hide for delete objects) -->
+              <div v-if="obj.operationType !== 'delete'" class="flex items-center gap-2 min-w-0">
+                <input type="checkbox" class="accent-primary shrink-0" :checked="obj.selected" @click.stop @change="onObjectCheckboxChange(obj, $event)" />
+                <component :is="getObjectIcon(obj.objectKind)" class="w-3.5 h-3.5 shrink-0" :class="getObjectIconColor(obj.objectKind)" />
+                <span class="text-xs truncate" :class="obj.operationType === 'create' ? 'text-green-500' : ''">
+                  {{ obj.sourceName ? (obj.objectKind === "function" && obj.arguments ? `${obj.sourceName}(${obj.arguments})` : obj.sourceName) : formatObjectName(obj) }}
+                </span>
+              </div>
+              <div v-else></div>
+
+              <!-- Operation -->
+              <div class="flex justify-center">
+                <component :is="operationIcons[obj.operationType]" class="w-3.5 h-3.5" :class="operationColors[obj.operationType]" />
+              </div>
+
+              <!-- Target (hide for create objects) -->
+              <div v-if="obj.operationType !== 'create'" class="flex items-center gap-2 min-w-0">
+                <input v-if="obj.operationType === 'delete'" type="checkbox" class="accent-primary shrink-0" :checked="obj.selected" @click.stop @change="onObjectCheckboxChange(obj, $event)" />
+                <component :is="getObjectIcon(obj.objectKind)" class="w-3.5 h-3.5 shrink-0" :class="getObjectIconColor(obj.objectKind)" />
+                <span class="text-xs truncate" :class="obj.operationType === 'delete' ? 'text-red-500 line-through' : ''">
+                  {{ obj.targetName ? (obj.objectKind === "function" && obj.arguments ? `${obj.targetName}(${obj.arguments})` : obj.targetName) : formatObjectName(obj) }}
+                </span>
+              </div>
+              <div v-else></div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/diff/SchemaDiffOptionsPanel.vue b/apps/desktop/src/components/diff/SchemaDiffOptionsPanel.vue
new file mode 100644
index 0000000..8c82e10
--- /dev/null
+++ b/apps/desktop/src/components/diff/SchemaDiffOptionsPanel.vue
@@ -0,0 +1,162 @@
+<script setup lang="ts">
+import { ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { HelpTooltip } from "@/components/ui/tooltip";
+import type { BooleanSchemaDiffCompareOptionKey, SchemaDiffCompareOptions, SchemaDiffOptionItem } from "@/types/schemaDiff";
+import { normalizeSchemaDiffCompareOptions } from "@/types/schemaDiff";
+
+const props = defineProps<{
+  options: SchemaDiffCompareOptions;
+  optionTree: SchemaDiffOptionItem[];
+}>();
+
+const emit = defineEmits<{
+  (e: "update:options", options: SchemaDiffCompareOptions): void;
+  (e: "close"): void;
+}>();
+
+const { t } = useI18n();
+
+// Local copy of options
+const localOptions = ref<SchemaDiffCompareOptions>(normalizeSchemaDiffCompareOptions(props.options));
+
+// Watch for external changes
+watch(
+  () => props.options,
+  (newOptions) => {
+    localOptions.value = normalizeSchemaDiffCompareOptions(newOptions);
+  },
+  { deep: true },
+);
+
+function isChecked(id: BooleanSchemaDiffCompareOptionKey): boolean {
+  return !!localOptions.value[id];
+}
+
+function setOption(id: BooleanSchemaDiffCompareOptionKey, checked: boolean) {
+  localOptions.value = { ...localOptions.value, [id]: checked };
+}
+
+function getChildState(item: SchemaDiffOptionItem): "checked" | "unchecked" | "indeterminate" {
+  if (!item.children || item.children.length === 0) {
+    return isChecked(item.id) ? "checked" : "unchecked";
+  }
+  const childStates = item.children.map((child) => getChildState(child));
+  if (childStates.every((s) => s === "checked")) return "checked";
+  if (childStates.every((s) => s === "unchecked")) return "unchecked";
+  return "indeterminate";
+}
+
+function toggleItem(item: SchemaDiffOptionItem) {
+  const state = getChildState(item);
+  const nextChecked = state !== "checked";
+  setSubtree(item, nextChecked);
+}
+
+function setSubtree(item: SchemaDiffOptionItem, checked: boolean) {
+  setOption(item.id, checked);
+  if (item.children) {
+    for (const child of item.children) {
+      setSubtree(child, checked);
+    }
+  }
+}
+
+function handleDone() {
+  emit("update:options", { ...localOptions.value });
+  emit("close");
+}
+
+function handleCancel() {
+  emit("close");
+}
+
+function getItemClasses(state: "checked" | "unchecked" | "indeterminate"): string {
+  const base = "h-4 w-4 rounded border flex items-center justify-center transition-colors cursor-pointer";
+  if (state === "checked") {
+    return `${base} bg-primary border-primary text-primary-foreground`;
+  }
+  if (state === "indeterminate") {
+    return `${base} bg-primary border-primary text-primary-foreground`;
+  }
+  return `${base} bg-background border-input hover:border-muted-foreground`;
+}
+</script>
+
+<template>
+  <div class="flex flex-col h-full">
+    <div class="grid flex-1 grid-cols-[minmax(0,1fr)_minmax(300px,0.95fr)] gap-4 overflow-auto pr-1">
+      <div class="min-w-0 space-y-1">
+        <div class="px-2 pb-1 text-xs font-medium text-muted-foreground">{{ t("schemaDiff.optionsTitle") }}</div>
+        <div class="space-y-1">
+          <template v-for="item in optionTree" :key="item.id">
+            <div class="space-y-1">
+              <div class="flex items-center gap-2 py-1 px-2 rounded hover:bg-muted/50 cursor-pointer" @click="toggleItem(item)">
+                <div :class="getItemClasses(getChildState(item))">
+                  <svg v-if="getChildState(item) === 'checked'" class="h-3 w-3" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="4">
+                    <polyline points="20 6 9 17 4 12" />
+                  </svg>
+                  <svg v-else-if="getChildState(item) === 'indeterminate'" class="h-3 w-3" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="4">
+                    <line x1="5" y1="12" x2="19" y2="12" />
+                  </svg>
+                </div>
+                <span class="text-sm select-none">{{ t(item.labelKey) }}</span>
+              </div>
+              <div v-if="item.children" class="ml-6 space-y-1">
+                <div v-for="child in item.children" :key="child.id" class="flex items-center gap-2 py-1 px-2 rounded hover:bg-muted/50 cursor-pointer" @click="toggleItem(child)">
+                  <div :class="getItemClasses(getChildState(child))">
+                    <svg v-if="getChildState(child) === 'checked'" class="h-3 w-3" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="4">
+                      <polyline points="20 6 9 17 4 12" />
+                    </svg>
+                  </div>
+                  <span class="text-sm select-none">{{ t(child.labelKey) }}</span>
+                </div>
+              </div>
+            </div>
+          </template>
+        </div>
+      </div>
+
+      <div class="grid min-w-0 grid-cols-[112px_minmax(0,1fr)] content-start gap-x-3 gap-y-2 border-l pl-4">
+        <div class="pt-1 text-xs font-medium text-muted-foreground">{{ t("schemaDiff.tableFilter") }}</div>
+        <div class="flex min-w-0 items-center justify-between gap-2">
+          <span class="truncate text-xs text-muted-foreground">{{ t("schemaDiff.tableFilterHintShort") }}</span>
+          <HelpTooltip :label="t('schemaDiff.tableFilterHelp')" side="left">
+            <div class="space-y-1">
+              <div>{{ t("schemaDiff.tableFilterHelpRule") }}</div>
+              <div>{{ t("schemaDiff.tableFilterHelpBlank") }}</div>
+              <div>{{ t("schemaDiff.tableFilterHelpExample") }}</div>
+            </div>
+          </HelpTooltip>
+        </div>
+        <label class="pt-2 text-xs font-medium text-muted-foreground" for="schema-diff-table-include">{{ t("schemaDiff.tableIncludePattern") }}</label>
+        <input id="schema-diff-table-include" v-model="localOptions.tableIncludePattern" class="h-8 w-full rounded-md border border-input bg-background px-2 text-xs outline-none focus:ring-1 focus:ring-ring" :placeholder="t('schemaDiff.tableIncludePatternPlaceholder')" />
+        <label class="pt-2 text-xs font-medium text-muted-foreground" for="schema-diff-table-exclude">{{ t("schemaDiff.tableExcludePattern") }}</label>
+        <input id="schema-diff-table-exclude" v-model="localOptions.tableExcludePattern" class="h-8 w-full rounded-md border border-input bg-background px-2 text-xs outline-none focus:ring-1 focus:ring-ring" :placeholder="t('schemaDiff.tableExcludePatternPlaceholder')" />
+        <label class="pt-2 text-xs font-medium text-muted-foreground" for="schema-diff-table-priority">{{ t("schemaDiff.tableFilterPriority") }}</label>
+        <div>
+          <Select v-model="localOptions.tableFilterPriority">
+            <SelectTrigger id="schema-diff-table-priority" class="h-8 w-full text-xs">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="exclude">{{ t("schemaDiff.tableFilterPriorityExclude") }}</SelectItem>
+              <SelectItem value="include">{{ t("schemaDiff.tableFilterPriorityInclude") }}</SelectItem>
+            </SelectContent>
+          </Select>
+        </div>
+      </div>
+    </div>
+
+    <div class="flex items-center justify-end gap-2 pt-4 border-t mt-2">
+      <Button variant="outline" size="sm" @click="handleCancel">
+        {{ t("common.cancel") }}
+      </Button>
+      <Button size="sm" @click="handleDone">
+        {{ t("common.done") }}
+      </Button>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/document/DocumentBrowser.vue b/apps/desktop/src/components/document/DocumentBrowser.vue
new file mode 100644
index 0000000..c52e77a
--- /dev/null
+++ b/apps/desktop/src/components/document/DocumentBrowser.vue
@@ -0,0 +1,1263 @@
+<script setup lang="ts">
+import { computed, ref, onMounted, onBeforeUnmount } from "vue";
+import { uuid } from "@/lib/common/utils";
+import { useI18n } from "vue-i18n";
+import { RefreshCw, Trash2, Plus, Save, ChevronLeft, ChevronRight, Table2, Braces, X, Columns3, Check, Search, Wrench, Filter } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Input } from "@/components/ui/input";
+import { Popover, PopoverTrigger, PopoverContent } from "@/components/ui/popover";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import ErrorBanner from "@/components/ui/ErrorBanner.vue";
+import DataGrid from "@/components/grid/DataGrid.vue";
+import QueryLoadingState from "@/components/common/QueryLoadingState.vue";
+import * as api from "@/lib/backend/api";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { clampSearchSplitWidth } from "@/lib/dataGrid/dataGridSearchSplit";
+import { documentViewerFontStyle } from "@/lib/document/documentViewerFontStyle";
+import {
+  buildDocumentFilterCondition,
+  combineDocumentFilterConditions,
+  currentDocumentFilterJson,
+  currentDocumentSortJson,
+  defaultDocumentFilterRule,
+  documentFilterModeNeedsValue,
+  documentFilterModeOptions,
+  documentStoreProviderFor,
+  type DocumentFilterMode,
+  type DocumentFilterRule,
+} from "@/lib/app/documentStoreProvider";
+import { buildMongoInsertDocument, buildMongoUpdateDocument, formatMongoShellLiteral, parseMongoDocumentInputValue, type MongoInputValue } from "@/lib/mongo/mongoDocumentValues";
+import { normalizeResultPageSize } from "@/lib/dataGrid/paginationPageSize";
+import { useSettingsStore } from "@/stores/settingsStore";
+import JsonEditNode from "./JsonEditNode.vue";
+import type { EditNode } from "@/types/editor";
+import type { DatabaseType, QueryResult } from "@/types/database";
+import type { CustomSaveHandler } from "@/composables/useDataGridEditor";
+import { Splitpanes, Pane } from "splitpanes";
+import "splitpanes/dist/splitpanes.css";
+
+const { t } = useI18n();
+const settingsStore = useSettingsStore();
+const connectionStore = useConnectionStore();
+
+const props = defineProps<{
+  connectionId: string;
+  database: string;
+  collection: string;
+  databaseType?: DatabaseType;
+}>();
+
+type JsonRecord = Record<string, unknown>;
+type ViewMode = "document" | "table";
+
+const documents = ref<JsonRecord[]>([]);
+const lastGridColumns = ref<string[]>([]);
+const total = ref(0);
+const loading = ref(false);
+const documentLoadExecutionId = ref("");
+const documentLoadCancelling = ref(false);
+const documentLoadingElapsedSeconds = ref("0.0");
+const page = ref(0);
+const pageSize = ref(normalizeResultPageSize(settingsStore.editorSettings.pageSize));
+const selectedIdx = ref<number | null>(null);
+const editJson = ref("");
+const isEditing = ref(false);
+const isNew = ref(false);
+const error = ref("");
+const editFields = ref<EditNode[]>([]);
+const showDeleteConfirm = ref(false);
+const viewMode = computed<ViewMode>({
+  get: () => settingsStore.editorSettings.mongoViewMode,
+  set: (value) => settingsStore.updateEditorSettings({ mongoViewMode: value }),
+});
+const filterInput = ref("");
+const sortInput = ref("");
+const dataGridRef = ref<InstanceType<typeof DataGrid>>();
+const columnVisibilitySearch = ref("");
+const columnVisibilityOptions = computed(() => dataGridRef.value?.filteredColumnVisibilityOptions(columnVisibilitySearch.value) ?? []);
+const tableSearchSplitContainerRef = ref<HTMLDivElement>();
+const tableFindPaneWidth = ref<number | null>(null);
+const isResizingTableSearchSplit = ref(false);
+let tableSearchSplitStartX = 0;
+let tableSearchSplitStartWidth = 0;
+const documentStoreProvider = computed(() => documentStoreProviderFor(props.databaseType));
+
+const tableFindPaneStyle = computed(() => {
+  if (tableFindPaneWidth.value == null) return {};
+  return { flex: `0 0 ${tableFindPaneWidth.value}px` };
+});
+const documentFontStyle = computed(() => documentViewerFontStyle(settingsStore.editorSettings));
+const documentStoreLabels = computed(() => ({
+  documentsLabel: documentStoreProvider.value.documentsLabel({ total: total.value, t }),
+  queryPreview: documentQueryPreview.value,
+}));
+
+type PendingDelete = { kind: "document"; index: number } | { kind: "field"; index: number; name: string };
+type LocalFilterSummary = {
+  columnIndex: number;
+  columnName: string;
+  values: string[];
+  hiddenValueCount: number;
+};
+type DocumentGridChanges = {
+  dirtyRows: Map<number, Map<number, MongoInputValue>>;
+  deletedRows: Set<number>;
+  newRows: MongoInputValue[][];
+  columns: string[];
+  rows: MongoInputValue[][];
+};
+const documentFilterBuilderOpen = ref(false);
+const documentFilterRules = ref<DocumentFilterRule[]>([]);
+const appliedDocumentFilter = ref<Record<string, unknown> | null>(null);
+
+const pendingDelete = ref<PendingDelete | null>(null);
+
+const selectedDoc = computed(() => {
+  if (selectedIdx.value === null) return null;
+  return documents.value[selectedIdx.value] ?? null;
+});
+
+const editKeyWidth = computed(() => {
+  const longest = editFields.value.reduce((max, field) => {
+    return Math.max(max, Array.from(field.keyName || "").length);
+  }, 0);
+  return `${Math.min(Math.max(longest + 4, 8), 36)}ch`;
+});
+
+const deleteDetails = computed(() => {
+  const pending = pendingDelete.value;
+  if (!pending) return "";
+  if (pending.kind === "document") {
+    const id = documents.value[pending.index]?._id ?? "";
+    if (props.databaseType === "elasticsearch") return `Elasticsearch index: ${props.collection}\nDocument _id: ${String(id)}`;
+    return t("dangerDialog.mongoDocumentDetails", { collection: props.collection, id: String(id) });
+  }
+  return t("dangerDialog.mongoFieldDetails", { field: pending.name || t("mongo.field") });
+});
+
+const gridResult = computed<QueryResult>(() => {
+  const docs = documents.value;
+  if (!docs.length) {
+    return {
+      columns: lastGridColumns.value,
+      rows: [],
+      affected_rows: 0,
+      execution_time_ms: 0,
+      truncated: false,
+    };
+  }
+
+  const keySet = new Set<string>();
+  keySet.add("_id");
+  for (const doc of docs) {
+    for (const key of Object.keys(doc)) {
+      if (key !== "_id") keySet.add(key);
+    }
+  }
+  const columns = [...keySet];
+
+  const rows = docs.map((doc) =>
+    columns.map((col) => {
+      const val = doc[col];
+      if (val === undefined || val === null) return null;
+      if (typeof val === "object") return JSON.stringify(val);
+      if (typeof val === "string" || typeof val === "number" || typeof val === "boolean") return val;
+      return String(val);
+    }),
+  );
+
+  return { columns, rows, affected_rows: 0, execution_time_ms: 0, truncated: false };
+});
+const documentFilterFieldOptions = computed(() => gridResult.value.columns);
+const documentStructuredFilterCount = computed(() => (appliedDocumentFilter.value ? 1 : 0));
+const documentLoadingLabelKey = computed(() => (documentLoadCancelling.value ? "common.stopping" : "common.loading"));
+let documentLoadingTimer: ReturnType<typeof setInterval> | undefined;
+
+function createDocumentFilterRule(): DocumentFilterRule {
+  return defaultDocumentFilterRule(uuid(), documentFilterFieldOptions.value[0] ?? "");
+}
+
+function ensureDocumentFilterRule() {
+  if (documentFilterRules.value.length === 0 && documentFilterFieldOptions.value.length > 0) {
+    documentFilterRules.value = [createDocumentFilterRule()];
+  }
+}
+
+function addDocumentFilterRule() {
+  ensureDocumentFilterRule();
+  documentFilterRules.value = [...documentFilterRules.value, createDocumentFilterRule()];
+}
+
+function removeDocumentFilterRule(ruleId: string) {
+  documentFilterRules.value = documentFilterRules.value.filter((rule) => rule.id !== ruleId);
+  if (documentFilterRules.value.length === 0) appliedDocumentFilter.value = null;
+}
+
+function updateDocumentFilterRule(ruleId: string, patch: Partial<DocumentFilterRule>) {
+  documentFilterRules.value = documentFilterRules.value.map((rule) => {
+    if (rule.id !== ruleId) return rule;
+    const next = { ...rule, ...patch };
+    if (!documentFilterModeNeedsValue(next.mode)) next.rawValue = "";
+    return next;
+  });
+}
+
+function resetDocumentFilterBuilder() {
+  appliedDocumentFilter.value = null;
+  documentFilterRules.value = documentFilterFieldOptions.value.length > 0 ? [createDocumentFilterRule()] : [];
+}
+
+function currentDocumentFilter(): string | undefined {
+  return currentDocumentFilterJson(filterInput.value, appliedDocumentFilter.value, documentStoreProvider.value.kind);
+}
+
+const documentQueryPreview = computed(() => {
+  let filter = "{}";
+  try {
+    filter = currentDocumentFilter() ?? "{}";
+  } catch {
+    filter = filterInput.value.trim() || "{}";
+  }
+  return documentStoreProvider.value.queryPreview({
+    collection: props.collection,
+    filterJson: filter,
+    sortJson: sortInput.value.trim(),
+    skip: page.value * pageSize.value,
+    limit: pageSize.value,
+  });
+});
+
+async function applyDocumentStructuredFilters() {
+  const items = documentFilterRules.value
+    .map((rule) => ({
+      rule,
+      condition: buildDocumentFilterCondition(rule, { kind: documentStoreProvider.value.kind }),
+    }))
+    .filter((item): item is { rule: DocumentFilterRule; condition: Record<string, unknown> } => !!item.condition);
+  const structured = combineDocumentFilterConditions(
+    items.map((item) => item.condition),
+    items.map((item) => item.rule),
+  );
+  appliedDocumentFilter.value = structured;
+  documentFilterBuilderOpen.value = false;
+  applyFilter();
+}
+
+function clearDocumentFilters(clearLocalFilter?: (columnIndex?: number) => void) {
+  appliedDocumentFilter.value = null;
+  resetDocumentFilterBuilder();
+  clearLocalFilter?.();
+  applyFilter();
+}
+
+function documentIdFromGridValue(value: MongoInputValue | undefined): string | null {
+  if (value === null || value === undefined) return null;
+  const parsed = parseMongoDocumentInputValue(value);
+  if (parsed === null || parsed === undefined) return null;
+  const id = typeof parsed === "object" ? JSON.stringify(parsed) : String(parsed);
+  return id.trim() ? id : null;
+}
+
+function documentRoutingValue(value: unknown): string | undefined {
+  if (value === null || value === undefined) return undefined;
+  const routing = typeof value === "string" ? value : String(value);
+  const trimmed = routing.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function documentRoutingFromDocument(doc: JsonRecord | undefined): string | undefined {
+  return documentRoutingValue(doc?._routing);
+}
+
+function documentRoutingFromGridRow(row: MongoInputValue[] | undefined, columns: string[]): string | undefined {
+  const routingColIdx = columns.indexOf("_routing");
+  return routingColIdx >= 0 ? documentRoutingValue(row?.[routingColIdx]) : undefined;
+}
+
+async function gridSave(changes: DocumentGridChanges) {
+  const cols = changes.columns;
+  const idColIdx = cols.indexOf("_id");
+  if (idColIdx < 0) throw new Error("No _id column");
+  const isEs = documentStoreProvider.value.kind === "elasticsearch";
+
+  for (const [rowIdx, dirtyCols] of changes.dirtyRows) {
+    const row = changes.rows[rowIdx];
+    const id = row?.[idColIdx];
+    if (id == null) continue;
+
+    if (isEs) {
+      const doc = documents.value[rowIdx];
+      if (!doc) continue;
+      const routing = documentRoutingFromDocument(doc);
+      const updated = { ...doc };
+      for (const [colIdx, newVal] of dirtyCols) {
+        const col = cols[colIdx];
+        if (col === "_id" || col === "_routing") continue;
+        if (newVal === null) {
+          delete updated[col];
+        } else {
+          updated[col] = parseMongoDocumentInputValue(newVal);
+        }
+      }
+      await api.documentUpdateDocument(props.connectionId, props.database, props.collection, String(id), JSON.stringify(updated), routing);
+      continue;
+    }
+
+    const updateDoc = buildMongoUpdateDocument(dirtyCols, cols);
+    if (Object.keys(updateDoc).length === 0) continue;
+    await api.documentUpdateDocument(props.connectionId, props.database, props.collection, String(id), JSON.stringify(updateDoc));
+  }
+
+  for (const rowIdx of changes.deletedRows) {
+    const row = changes.rows[rowIdx];
+    const id = row?.[idColIdx];
+    if (id == null) continue;
+    const routing = isEs ? documentRoutingFromDocument(documents.value[rowIdx]) : undefined;
+    await api.documentDeleteDocument(props.connectionId, props.database, props.collection, String(id), routing);
+  }
+
+  for (const newRow of changes.newRows) {
+    const doc = buildMongoInsertDocument(newRow, cols);
+    if (isEs) {
+      const id = documentIdFromGridValue(newRow[idColIdx]);
+      if (id) {
+        await api.documentUpdateDocument(props.connectionId, props.database, props.collection, id, JSON.stringify(doc), documentRoutingFromGridRow(newRow, cols));
+      } else {
+        await api.documentInsertDocument(props.connectionId, props.database, props.collection, JSON.stringify(doc));
+      }
+      continue;
+    }
+    await api.documentInsertDocument(props.connectionId, props.database, props.collection, JSON.stringify(doc));
+  }
+
+  await load();
+}
+
+function formatMongoValue(val: unknown): string {
+  if (val === null || val === undefined) return "null";
+  if (typeof val === "number" || typeof val === "boolean") return String(val);
+  if (typeof val === "string") return JSON.stringify(val);
+  return JSON.stringify(val);
+}
+
+function mongoIdPreview(val: unknown): string {
+  if (val === null || val === undefined) return "null";
+  if (typeof val === "string" && /^[a-fA-F0-9]{24}$/.test(val)) return `ObjectId("${val}")`;
+  return formatMongoValue(val);
+}
+
+function elasticsearchPathIdPreview(id: string): string {
+  return encodeURIComponent(id);
+}
+
+function elasticsearchRoutingPreview(routing: string | undefined): string {
+  return routing ? `?routing=${encodeURIComponent(routing)}` : "";
+}
+
+function buildElasticsearchPartialUpdateDocument(changes: Map<number, MongoInputValue>, columns: string[]): Record<string, unknown> {
+  const filtered = new Map<number, MongoInputValue>();
+  for (const [colIdx, newVal] of changes) {
+    const col = columns[colIdx];
+    if (col === "_id" || col === "_routing") continue;
+    filtered.set(colIdx, newVal);
+  }
+  return buildMongoUpdateDocument(filtered, columns);
+}
+
+async function previewDocumentChanges(changes: DocumentGridChanges): Promise<string[]> {
+  const { dirtyRows, deletedRows, newRows, columns, rows } = changes;
+  const idColIdx = columns.indexOf("_id");
+  const stmts: string[] = [];
+  const coll = props.collection;
+  const isEs = documentStoreProvider.value.kind === "elasticsearch";
+
+  for (const [rowIdx, dirtyCols] of dirtyRows) {
+    const row = rows[rowIdx];
+    const id = row?.[idColIdx];
+    if (id == null) continue;
+    if (isEs) {
+      const updateDoc = buildElasticsearchPartialUpdateDocument(dirtyCols, columns);
+      const routing = documentRoutingFromGridRow(row, columns);
+      stmts.push(`POST /${coll}/_update/${elasticsearchPathIdPreview(String(id))}${elasticsearchRoutingPreview(routing)}\n${JSON.stringify({ doc: updateDoc.$set ?? updateDoc }, null, 2)}`);
+    } else {
+      const updateDoc = buildMongoUpdateDocument(dirtyCols, columns);
+      stmts.push(`db.${coll}.updateOne({_id: ${mongoIdPreview(id)}}, ${formatMongoShellLiteral(updateDoc)})`);
+    }
+  }
+
+  for (const rowIdx of deletedRows) {
+    const row = rows[rowIdx];
+    const id = row?.[idColIdx];
+    if (id == null) continue;
+    if (isEs) {
+      const routing = documentRoutingFromGridRow(row, columns);
+      stmts.push(`DELETE /${coll}/_doc/${elasticsearchPathIdPreview(String(id))}${elasticsearchRoutingPreview(routing)}`);
+    } else {
+      stmts.push(`db.${coll}.deleteOne({_id: ${mongoIdPreview(id)}})`);
+    }
+  }
+
+  for (const newRow of newRows) {
+    const doc = buildMongoInsertDocument(newRow, columns);
+    if (isEs) {
+      const id = idColIdx >= 0 ? documentIdFromGridValue(newRow[idColIdx]) : null;
+      if (id) {
+        stmts.push(`PUT /${coll}/_doc/${elasticsearchPathIdPreview(id)}\n${JSON.stringify(doc, null, 2)}`);
+      } else {
+        stmts.push(`POST /${coll}/_doc\n${JSON.stringify(doc, null, 2)}`);
+      }
+    } else {
+      stmts.push(`db.${coll}.insertOne(${formatMongoShellLiteral(doc)})`);
+    }
+  }
+
+  return stmts;
+}
+
+const customSaveHandler = computed<CustomSaveHandler>(() => ({
+  save: gridSave,
+  preview: previewDocumentChanges,
+  supportsInsert: true,
+  readonlyColumns: documentStoreProvider.value.kind === "elasticsearch" ? ["_routing"] : undefined,
+}));
+
+function stopDocumentLoadingTimer() {
+  if (documentLoadingTimer) clearInterval(documentLoadingTimer);
+  documentLoadingTimer = undefined;
+}
+
+function startDocumentLoadingTimer() {
+  stopDocumentLoadingTimer();
+  const startedAt = Date.now();
+  documentLoadingElapsedSeconds.value = "0.0";
+  documentLoadingTimer = setInterval(() => {
+    documentLoadingElapsedSeconds.value = ((Date.now() - startedAt) / 1000).toFixed(1);
+  }, 100);
+}
+
+async function load() {
+  if (documentLoadExecutionId.value) void api.cancelQuery(documentLoadExecutionId.value);
+  const executionId = uuid();
+  loading.value = true;
+  documentLoadExecutionId.value = executionId;
+  documentLoadCancelling.value = false;
+  startDocumentLoadingTimer();
+  error.value = "";
+  const previousSelectedIdx = selectedIdx.value;
+  const previousSelectedId = previousSelectedIdx === null ? null : documentIdentity(documents.value[previousSelectedIdx]);
+  try {
+    const filter = currentDocumentFilter();
+    const sort = currentDocumentSortJson(sortInput.value);
+    const result = await api.documentFindDocuments(props.connectionId, props.database, props.collection, page.value * pageSize.value, pageSize.value, filter, undefined, sort, executionId);
+    if (documentLoadExecutionId.value !== executionId) return;
+    const nextDocuments = result.documents.map(asRecord);
+    documents.value = nextDocuments;
+    if (nextDocuments.length > 0) {
+      const keySet = new Set<string>();
+      keySet.add("_id");
+      for (const doc of nextDocuments) {
+        for (const key of Object.keys(doc)) {
+          if (key !== "_id") keySet.add(key);
+        }
+      }
+      lastGridColumns.value = [...keySet];
+    }
+    total.value = result.total;
+    syncSelectedDocumentAfterLoad(previousSelectedIdx, previousSelectedId);
+  } catch (e: unknown) {
+    if (documentLoadExecutionId.value === executionId) error.value = e instanceof Error ? e.message : String(e);
+  } finally {
+    if (documentLoadExecutionId.value === executionId) {
+      loading.value = false;
+      documentLoadExecutionId.value = "";
+      documentLoadCancelling.value = false;
+      stopDocumentLoadingTimer();
+    }
+  }
+}
+
+async function cancelDocumentLoad() {
+  const executionId = documentLoadExecutionId.value;
+  if (!executionId || documentLoadCancelling.value) return;
+  documentLoadCancelling.value = true;
+  try {
+    await api.cancelQuery(executionId);
+  } finally {
+    if (documentLoadExecutionId.value === executionId) {
+      loading.value = false;
+      documentLoadExecutionId.value = "";
+      documentLoadCancelling.value = false;
+      stopDocumentLoadingTimer();
+    }
+  }
+}
+
+function applyFilter() {
+  page.value = 0;
+  load();
+}
+
+function paginate(offset: number, limit: number) {
+  const normalizedLimit = normalizeResultPageSize(limit, pageSize.value);
+  pageSize.value = normalizedLimit;
+  page.value = Math.floor(Math.max(0, offset) / normalizedLimit);
+  load();
+}
+
+function onSort(column: string, _columnIndex: number, direction: "asc" | "desc" | null) {
+  sortInput.value = documentStoreProvider.value.sortInputForColumn(column, direction);
+  page.value = 0;
+  load();
+}
+
+function asRecord(value: unknown): JsonRecord {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value as JsonRecord;
+  }
+  return {};
+}
+
+function documentIdentity(doc: JsonRecord | undefined): string | null {
+  const id = doc?._id;
+  if (id === null || id === undefined) return null;
+  return typeof id === "object" ? JSON.stringify(id) : String(id);
+}
+
+function syncSelectedDocumentAfterLoad(previousSelectedIdx: number | null, previousSelectedId: string | null) {
+  if (isNew.value || previousSelectedIdx === null) return;
+  if (!documents.value.length) {
+    selectedIdx.value = null;
+    if (!isEditing.value) editJson.value = "";
+    return;
+  }
+
+  const nextIdx = previousSelectedId ? documents.value.findIndex((doc) => documentIdentity(doc) === previousSelectedId) : previousSelectedIdx < documents.value.length ? previousSelectedIdx : -1;
+  if (nextIdx < 0) {
+    selectedIdx.value = null;
+    if (!isEditing.value) editJson.value = "";
+    return;
+  }
+
+  selectedIdx.value = nextIdx;
+  if (!isEditing.value) {
+    editJson.value = JSON.stringify(documents.value[nextIdx], null, 2);
+  }
+}
+
+function selectDoc(idx: number) {
+  selectedIdx.value = idx;
+  editJson.value = JSON.stringify(documents.value[idx], null, 2);
+  isEditing.value = false;
+  isNew.value = false;
+  editFields.value = [];
+}
+
+function startNew() {
+  selectedIdx.value = null;
+  editJson.value = "";
+  editFields.value = [createEditNode("", "", false, false)];
+  isEditing.value = true;
+  isNew.value = true;
+}
+
+function startEdit() {
+  const doc = selectedDoc.value;
+  if (!doc) return;
+  editFields.value = Object.entries(doc).map(([name, value]) => {
+    const readonlyMetadata = name === "_id" || (documentStoreProvider.value.kind === "elasticsearch" && name === "_routing");
+    return createEditNode(name, value, readonlyMetadata, readonlyMetadata);
+  });
+  isEditing.value = true;
+  isNew.value = false;
+}
+
+function cancelEdit() {
+  isEditing.value = false;
+  if (isNew.value) {
+    isNew.value = false;
+    editFields.value = [];
+    return;
+  }
+  if (selectedDoc.value) {
+    editJson.value = JSON.stringify(selectedDoc.value, null, 2);
+  }
+  editFields.value = [];
+  error.value = "";
+}
+
+function createEditNode(keyName: string, value: unknown, readonlyKey: boolean, readonlyValue: boolean): EditNode {
+  if (Array.isArray(value)) {
+    return {
+      key: uuid(),
+      keyName,
+      kind: "array",
+      valueText: "",
+      readonlyKey,
+      readonlyValue,
+      children: value.map((child, idx) => createEditNode(String(idx), child, true, readonlyValue)),
+    };
+  }
+
+  if (value && typeof value === "object") {
+    return {
+      key: uuid(),
+      keyName,
+      kind: "object",
+      valueText: "",
+      readonlyKey,
+      readonlyValue,
+      children: Object.entries(value as JsonRecord).map(([childName, child]) => createEditNode(childName, child, readonlyValue, readonlyValue)),
+    };
+  }
+
+  return {
+    key: uuid(),
+    keyName,
+    kind: "value",
+    valueText: formatForEdit(value),
+    readonlyKey,
+    readonlyValue,
+    children: [],
+  };
+}
+
+function addField() {
+  editFields.value.push(createEditNode("", "", false, false));
+}
+
+function applyRemoveField(idx: number) {
+  if (editFields.value[idx]?.readonlyValue) return;
+  editFields.value.splice(idx, 1);
+}
+
+function requestRemoveField(idx: number) {
+  const field = editFields.value[idx];
+  if (!field || field.readonlyValue) return;
+  pendingDelete.value = { kind: "field", index: idx, name: field.keyName };
+  showDeleteConfirm.value = true;
+}
+
+function formatForEdit(value: unknown): string {
+  if (value === undefined) return "";
+  if (value === null) return "null";
+  if (typeof value === "string") return JSON.stringify(value);
+  if (typeof value === "object") return JSON.stringify(value, null, 2);
+  return String(value);
+}
+
+function parseFieldValue(raw: string): unknown {
+  return parseMongoDocumentInputValue(raw);
+}
+
+function buildObjectFromNodes(nodes: EditNode[], path: string): JsonRecord {
+  const doc: JsonRecord = {};
+  const seen = new Set<string>();
+
+  for (const field of nodes) {
+    const name = field.keyName.trim();
+    if (!name || (!path && (name === "_id" || (documentStoreProvider.value.kind === "elasticsearch" && name === "_routing")))) continue;
+    if (seen.has(name)) throw new Error(t("mongo.duplicateField", { field: name }));
+    seen.add(name);
+    doc[name] = buildValueFromNode(field, path ? `${path}.${name}` : name);
+  }
+
+  return doc;
+}
+
+function buildValueFromNode(node: EditNode, path: string): unknown {
+  if (node.kind === "value") return parseFieldValue(node.valueText);
+  if (node.kind === "array") {
+    return node.children.map((child, idx) => buildValueFromNode(child, `${path}[${idx}]`));
+  }
+  return buildObjectFromNodes(node.children, path);
+}
+
+function buildDocumentFromFields(): JsonRecord {
+  return buildObjectFromNodes(editFields.value, "");
+}
+
+async function saveDoc() {
+  error.value = "";
+  try {
+    const doc = buildDocumentFromFields();
+    if (isNew.value) {
+      await api.documentInsertDocument(props.connectionId, props.database, props.collection, JSON.stringify(doc));
+    } else if (selectedIdx.value !== null) {
+      const current = documents.value[selectedIdx.value];
+      const id = current?._id;
+      if (!id) {
+        error.value = "No _id field";
+        return;
+      }
+      await api.documentUpdateDocument(props.connectionId, props.database, props.collection, String(id), JSON.stringify(doc), documentRoutingFromDocument(current));
+    }
+    isEditing.value = false;
+    isNew.value = false;
+    editFields.value = [];
+    await load();
+    if (selectedIdx.value !== null && documents.value[selectedIdx.value]) {
+      editJson.value = JSON.stringify(documents.value[selectedIdx.value], null, 2);
+    }
+  } catch (e: unknown) {
+    error.value = e instanceof Error ? e.message : String(e);
+  }
+}
+
+async function applyDeleteDoc(idx: number) {
+  const doc = documents.value[idx];
+  const id = doc._id;
+  if (!id) return;
+  error.value = "";
+  try {
+    await api.documentDeleteDocument(props.connectionId, props.database, props.collection, String(id), documentRoutingFromDocument(doc));
+    if (selectedIdx.value === idx) {
+      selectedIdx.value = null;
+      editJson.value = "";
+    }
+    await load();
+  } catch (e: unknown) {
+    error.value = e instanceof Error ? e.message : String(e);
+  }
+}
+
+function requestDeleteDoc(idx: number) {
+  pendingDelete.value = { kind: "document", index: idx };
+  showDeleteConfirm.value = true;
+}
+
+async function confirmDelete() {
+  const pending = pendingDelete.value;
+  if (!pending) return;
+  if (pending.kind === "document") {
+    await applyDeleteDoc(pending.index);
+  } else {
+    applyRemoveField(pending.index);
+  }
+  pendingDelete.value = null;
+}
+
+function prevPage() {
+  if (page.value <= 0) return;
+  page.value--;
+  load();
+}
+
+function nextPage() {
+  if ((page.value + 1) * pageSize.value >= total.value) return;
+  page.value++;
+  load();
+}
+
+function docPreview(doc: JsonRecord): string {
+  const id = doc._id || "";
+  const keys = Object.keys(doc)
+    .filter((k) => k !== "_id")
+    .slice(0, 3);
+  const preview = keys.map((k) => `${k}: ${JSON.stringify(doc[k]).substring(0, 30)}`).join(", ");
+  return `${id} - ${preview}`;
+}
+
+function highlightedJson(json: string): string {
+  const escaped = json.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+  return escaped.replace(/("(?:\\u[a-fA-F0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(?:true|false|null)\b|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)/g, (match) => {
+    let cls = "json-number";
+    if (match.startsWith('"')) cls = match.endsWith(":") ? "json-key" : "json-string";
+    else if (match === "true" || match === "false") cls = "json-boolean";
+    else if (match === "null") cls = "json-null";
+    return `<span class="${cls}">${match}</span>`;
+  });
+}
+
+onMounted(async () => {
+  try {
+    await connectionStore.ensureConnected(props.connectionId);
+  } catch (e) {
+    console.warn("[DBX] ensureConnected failed for", props.connectionId, e);
+  }
+  load();
+});
+onBeforeUnmount(() => {
+  if (documentLoadExecutionId.value) void api.cancelQuery(documentLoadExecutionId.value);
+  stopDocumentLoadingTimer();
+  endTableSearchSplitResize();
+});
+
+function tableSearchSplitContainerWidth(): number {
+  return tableSearchSplitContainerRef.value?.getBoundingClientRect().width ?? 0;
+}
+
+function startTableSearchSplitResize(event: MouseEvent) {
+  const containerWidth = tableSearchSplitContainerWidth();
+  if (containerWidth <= 0) return;
+  event.preventDefault();
+  isResizingTableSearchSplit.value = true;
+  tableSearchSplitStartX = event.clientX;
+  tableSearchSplitStartWidth = clampSearchSplitWidth({
+    containerWidth,
+    desiredWidth: tableFindPaneWidth.value ?? undefined,
+  });
+  tableFindPaneWidth.value = tableSearchSplitStartWidth;
+  document.body.classList.add("select-none", "cursor-col-resize");
+  window.addEventListener("mousemove", moveTableSearchSplitResize);
+  window.addEventListener("mouseup", endTableSearchSplitResize);
+}
+
+function moveTableSearchSplitResize(event: MouseEvent) {
+  if (!isResizingTableSearchSplit.value) return;
+  const containerWidth = tableSearchSplitContainerWidth();
+  if (containerWidth <= 0) return;
+  tableFindPaneWidth.value = clampSearchSplitWidth({
+    containerWidth,
+    desiredWidth: tableSearchSplitStartWidth + event.clientX - tableSearchSplitStartX,
+  });
+}
+
+function endTableSearchSplitResize() {
+  isResizingTableSearchSplit.value = false;
+  document.body.classList.remove("select-none", "cursor-col-resize");
+  window.removeEventListener("mousemove", moveTableSearchSplitResize);
+  window.removeEventListener("mouseup", endTableSearchSplitResize);
+}
+
+function resetTableSearchSplitWidth() {
+  const containerWidth = tableSearchSplitContainerWidth();
+  tableFindPaneWidth.value = containerWidth > 0 ? clampSearchSplitWidth({ containerWidth }) : null;
+}
+</script>
+
+<template>
+  <div class="h-full flex flex-col overflow-hidden">
+    <!-- Top toolbar: view toggle + document count + pagination + actions -->
+    <div class="h-9 flex items-center gap-1 px-3 border-b shrink-0 text-xs text-muted-foreground">
+      <div class="flex items-center border rounded-md overflow-hidden mr-2">
+        <Button variant="ghost" size="icon" class="h-5 w-5 rounded-none" :class="{ 'bg-accent': viewMode === 'document' }" :title="t('mongo.documentView')" @click="viewMode = 'document'">
+          <Braces class="h-3 w-3" />
+        </Button>
+        <Button variant="ghost" size="icon" class="h-5 w-5 rounded-none" :class="{ 'bg-accent': viewMode === 'table' }" :title="t('mongo.tableView')" @click="viewMode = 'table'">
+          <Table2 class="h-3 w-3" />
+        </Button>
+      </div>
+
+      <span class="shrink-0 ml-1">{{ documentStoreLabels.documentsLabel }}</span>
+
+      <Button v-if="viewMode === 'document'" variant="ghost" size="icon" class="h-5 w-5" @click="startNew"><Plus class="h-3 w-3" /></Button>
+      <Button v-if="viewMode === 'document'" variant="ghost" size="icon" class="h-5 w-5" @click="load"><RefreshCw class="h-3 w-3" :class="{ 'animate-spin': loading }" /></Button>
+
+      <div v-if="viewMode === 'document'" class="flex items-center gap-1 ml-1">
+        <Button variant="ghost" size="icon" class="h-5 w-5" :disabled="page <= 0" @click="prevPage">
+          <ChevronLeft class="h-3 w-3" />
+        </Button>
+        <span>{{ page + 1 }} / {{ Math.max(1, Math.ceil(total / pageSize)) }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5" :disabled="(page + 1) * pageSize >= total" @click="nextPage">
+          <ChevronRight class="h-3 w-3" />
+        </Button>
+      </div>
+
+      <div class="flex-1" />
+
+      <Popover v-if="viewMode === 'table' && gridResult.columns.length">
+        <PopoverTrigger as-child>
+          <Button variant="ghost" size="sm" class="h-5 shrink-0 gap-1 px-1.5 text-xs text-foreground hover:bg-accent" :class="{ 'bg-accent text-foreground': (dataGridRef?.hiddenColumnCount ?? 0) > 0 }" :title="t('grid.columnVisibility')" :aria-label="t('grid.columnVisibility')">
+            <Columns3 class="h-3.5 w-3.5" />
+            {{ t("grid.columnVisibility") }}
+            <span v-if="(dataGridRef?.hiddenColumnCount ?? 0) > 0" class="tabular-nums"> {{ dataGridRef?.visibleColumnCount }}/{{ dataGridRef?.displayableColumnCount }} </span>
+          </Button>
+        </PopoverTrigger>
+        <PopoverContent align="end" class="w-64 max-w-[calc(100vw-2rem)] gap-0 overflow-hidden rounded-xl border bg-popover p-0 text-popover-foreground shadow-xl" @click.stop @keydown.stop>
+          <div class="border-b bg-muted/40 px-2 py-1.5">
+            <div class="flex items-center justify-between gap-2">
+              <div class="text-xs font-semibold">{{ t("grid.columnVisibility") }}</div>
+              <div class="text-[10px] text-muted-foreground tabular-nums">{{ dataGridRef?.visibleColumnCount ?? 0 }}/{{ dataGridRef?.displayableColumnCount ?? 0 }}</div>
+            </div>
+          </div>
+          <div class="flex items-center gap-1.5 border-b px-2 py-1.5">
+            <Search class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+            <input v-model="columnVisibilitySearch" autocapitalize="off" autocorrect="off" spellcheck="false" class="h-6 min-w-0 flex-1 bg-transparent text-xs outline-none placeholder:text-muted-foreground" :placeholder="t('grid.searchColumns')" />
+          </div>
+          <div class="max-h-72 overflow-auto py-0.5">
+            <button v-for="option in columnVisibilityOptions" :key="`${option.index}:${option.column}`" type="button" class="grid w-full grid-cols-[1.5rem_minmax(0,1fr)] items-center px-2 py-1 text-left text-xs hover:bg-accent" @click="dataGridRef?.toggleColumnVisibility(option.index)">
+              <span class="flex h-4 w-4 items-center justify-center rounded border" :class="dataGridRef?.isColumnVisible(option.index) ? 'border-primary bg-primary text-primary-foreground' : 'border-border bg-background text-transparent'">
+                <Check class="h-3 w-3 stroke-[3]" />
+              </span>
+              <span class="truncate font-mono text-xs" :title="option.column">{{ option.column }}</span>
+            </button>
+            <div v-if="columnVisibilityOptions.length === 0" class="px-2 py-6 text-center text-xs text-muted-foreground">
+              {{ t("grid.noSearchResults") }}
+            </div>
+          </div>
+          <div class="flex flex-col gap-1 border-t bg-muted/30 px-2 py-1.5">
+            <span class="text-[11px] leading-4 text-muted-foreground">{{ t("grid.columnVisibilityHint") }}</span>
+            <div class="flex items-center justify-end gap-1">
+              <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" :disabled="(dataGridRef?.displayableColumnCount ?? 0) <= 1" @click="dataGridRef?.invertColumnVisibility()">
+                {{ t("grid.invertColumnVisibility") }}
+              </Button>
+              <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" :disabled="!dataGridRef?.hasCustomColumnOrder" @click="dataGridRef?.resetColumnOrder()">
+                {{ t("grid.resetColumnOrder") }}
+              </Button>
+              <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" :disabled="(dataGridRef?.hiddenColumnCount ?? 0) === 0" @click="dataGridRef?.showAllColumns()">
+                {{ t("grid.showAllColumns") }}
+              </Button>
+            </div>
+          </div>
+        </PopoverContent>
+      </Popover>
+
+      <Popover v-if="viewMode === 'table' && gridResult.columns.length">
+        <PopoverTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-7 shrink-0 text-foreground hover:bg-accent" :class="{ 'bg-accent text-foreground': dataGridRef?.nullColumnsHidden }" :title="t('grid.viewOptions')" :aria-label="t('grid.viewOptions')">
+            <Wrench class="h-4 w-4" />
+          </Button>
+        </PopoverTrigger>
+        <PopoverContent align="end" class="w-max min-w-44 max-w-[calc(100vw-2rem)] gap-0 overflow-hidden rounded-xl border bg-popover p-0 text-popover-foreground shadow-xl" @click.stop @keydown.stop>
+          <div class="border-b bg-muted/40 px-3 py-2">
+            <div class="text-xs font-semibold">{{ t("grid.viewOptions") }}</div>
+          </div>
+          <label class="flex cursor-pointer items-center gap-2 px-3 py-2 text-xs hover:bg-accent" :class="{ 'cursor-not-allowed opacity-60': !dataGridRef?.canToggleAllNullColumns }">
+            <input type="checkbox" class="h-3.5 w-3.5 shrink-0 accent-primary" :checked="!!dataGridRef?.nullColumnsHidden" :disabled="!dataGridRef?.canToggleAllNullColumns" @change="dataGridRef?.toggleAllNullColumns()" />
+            <span class="min-w-0 flex items-center gap-1 font-medium">
+              {{ t("grid.hideNullColumns") }}
+              <span v-if="(dataGridRef?.allNullColumnCount ?? 0) > 0" class="text-muted-foreground tabular-nums"> ({{ dataGridRef?.allNullColumnCount }}) </span>
+            </span>
+          </label>
+        </PopoverContent>
+      </Popover>
+    </div>
+
+    <!-- Table view -->
+    <QueryLoadingState
+      v-if="viewMode === 'table' && loading && gridResult.columns.length === 0"
+      class="flex-1 min-h-0"
+      :label-key="documentLoadingLabelKey"
+      :elapsed-seconds="documentLoadingElapsedSeconds"
+      show-cancel
+      :cancel-disabled="!documentLoadExecutionId || documentLoadCancelling"
+      :cancelling="documentLoadCancelling"
+      @cancel="cancelDocumentLoad"
+    />
+    <DataGrid
+      v-else-if="viewMode === 'table'"
+      ref="dataGridRef"
+      class="flex-1 min-h-0"
+      :result="gridResult"
+      context="results"
+      editable
+      :custom-save-handler="customSaveHandler"
+      :loading="loading"
+      :sql="documentStoreLabels.queryPreview"
+      :page-offset="page * pageSize"
+      :page-limit="pageSize"
+      :total-row-count="total"
+      @sort="onSort"
+      @reload="load"
+      @paginate="(offset: number, limit: number) => paginate(offset, limit)"
+    >
+      <template #search-bar="{ localFilterCount, hasLocalColumnFilters, localFilterSummaries, clearLocalFilter }: { localFilterCount: number; hasLocalColumnFilters: boolean; localFilterSummaries: LocalFilterSummary[]; clearLocalFilter: (columnIndex?: number) => void }">
+        <div ref="tableSearchSplitContainerRef" class="flex flex-1 min-w-0">
+          <div class="flex flex-1 items-center gap-1 px-2 py-0.5 min-w-0" :style="tableFindPaneStyle">
+            <Popover v-model:open="documentFilterBuilderOpen">
+              <PopoverTrigger as-child>
+                <button
+                  type="button"
+                  class="relative flex h-5 w-5 shrink-0 items-center justify-center rounded border text-[11px] font-medium transition-colors"
+                  :class="hasLocalColumnFilters || appliedDocumentFilter ? 'border-primary/40 bg-primary/10 text-primary hover:bg-primary/15' : 'border-border/70 text-muted-foreground hover:bg-accent hover:text-foreground'"
+                  @click="ensureDocumentFilterRule"
+                >
+                  <Filter class="h-3 w-3" />
+                  <span v-if="localFilterCount + documentStructuredFilterCount" class="absolute -right-1 -top-1 flex h-3.5 min-w-3.5 items-center justify-center rounded-full bg-primary px-1 text-[9px] leading-none text-primary-foreground">
+                    {{ localFilterCount + documentStructuredFilterCount }}
+                  </span>
+                </button>
+              </PopoverTrigger>
+              <PopoverContent align="start" class="w-[360px] max-w-[calc(100vw-24px)] gap-3 p-3">
+                <div class="flex items-center justify-between gap-3">
+                  <div class="text-xs font-medium text-foreground">{{ t("grid.filter") }}</div>
+                  <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" @click="addDocumentFilterRule">
+                    <Plus class="mr-1 h-3.5 w-3.5" />
+                    {{ t("grid.filterBuilderAddRule") }}
+                  </Button>
+                </div>
+                <div v-if="hasLocalColumnFilters" class="space-y-2 rounded-md border border-primary/20 bg-primary/5 px-2.5 py-2">
+                  <div class="flex items-center justify-between gap-3">
+                    <div class="flex min-w-0 items-center gap-2 text-xs font-medium text-primary">
+                      <Filter class="h-3.5 w-3.5 shrink-0" />
+                      <span class="truncate">{{ t("grid.localFiltersActive", { count: localFilterCount }) }}</span>
+                    </div>
+                    <Button variant="ghost" size="sm" class="h-7 shrink-0 px-2 text-xs" @click="clearLocalFilter()">
+                      <X class="mr-1 h-3.5 w-3.5" />
+                      {{ t("grid.clearLocalFiltersShort") }}
+                    </Button>
+                  </div>
+                  <div class="space-y-1">
+                    <div v-for="summary in localFilterSummaries" :key="summary.columnIndex" class="grid grid-cols-[minmax(0,0.9fr)_minmax(0,1.6fr)_auto] items-center gap-2 rounded border border-primary/10 bg-background/70 px-2 py-1 text-xs">
+                      <span class="truncate font-medium text-foreground" :title="summary.columnName">
+                        {{ summary.columnName }}
+                      </span>
+                      <span class="min-w-0 truncate font-mono text-muted-foreground">
+                        <template v-for="(value, valueIndex) in summary.values" :key="valueIndex">
+                          <span v-if="valueIndex > 0">, </span>
+                          <span>{{ value }}</span>
+                        </template>
+                        <span v-if="summary.hiddenValueCount">
+                          {{ t("grid.localFilterMoreValues", { count: summary.hiddenValueCount }) }}
+                        </span>
+                      </span>
+                      <Button variant="ghost" size="icon" class="h-6 w-6 text-muted-foreground hover:text-destructive" :title="t('grid.clearFilter')" @click="clearLocalFilter(summary.columnIndex)">
+                        <X class="h-3.5 w-3.5" />
+                      </Button>
+                    </div>
+                  </div>
+                </div>
+
+                <div v-if="documentFilterRules.length" class="space-y-2">
+                  <template v-for="(rule, index) in documentFilterRules" :key="rule.id">
+                    <div v-if="index > 0" class="flex justify-center">
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        class="h-6 px-2 text-[11px] font-medium text-muted-foreground hover:text-foreground"
+                        @click="
+                          updateDocumentFilterRule(rule.id, {
+                            conjunction: rule.conjunction === 'AND' ? 'OR' : 'AND',
+                          })
+                        "
+                      >
+                        {{ rule.conjunction }}
+                      </Button>
+                    </div>
+                    <div class="grid grid-cols-[minmax(0,1fr)_minmax(0,0.95fr)_minmax(0,1fr)_auto] items-center gap-1.5">
+                      <Select :model-value="rule.fieldName" @update:model-value="(value: any) => updateDocumentFilterRule(rule.id, { fieldName: String(value) })">
+                        <SelectTrigger class="h-8 w-full min-w-0 overflow-hidden text-xs [&_[data-slot=select-value]]:min-w-0 [&_[data-slot=select-value]]:truncate">
+                          <SelectValue :placeholder="t('grid.filterBuilderColumn')" />
+                        </SelectTrigger>
+                        <SelectContent position="popper">
+                          <SelectItem v-for="fieldName in documentFilterFieldOptions" :key="fieldName" :value="fieldName">
+                            {{ fieldName }}
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+
+                      <Select :model-value="rule.mode" @update:model-value="(value: any) => updateDocumentFilterRule(rule.id, { mode: value as DocumentFilterMode })">
+                        <SelectTrigger class="h-8 w-full min-w-0 overflow-hidden text-xs [&_[data-slot=select-value]]:min-w-0 [&_[data-slot=select-value]]:truncate">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent position="popper">
+                          <SelectItem v-for="option in documentFilterModeOptions" :key="option.value" :value="option.value">
+                            {{ t(option.labelKey) }}
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+
+                      <Input
+                        v-if="documentFilterModeNeedsValue(rule.mode)"
+                        :model-value="rule.rawValue"
+                        class="h-8 min-w-0 text-xs"
+                        :placeholder="t('grid.filterBuilderValue')"
+                        @update:model-value="(value) => updateDocumentFilterRule(rule.id, { rawValue: String(value ?? '') })"
+                        @keydown.enter.prevent="applyDocumentStructuredFilters"
+                      />
+                      <div v-else class="flex h-8 min-w-0 items-center overflow-hidden rounded-md border border-dashed px-2 text-xs text-muted-foreground">
+                        <span class="truncate">{{ t("grid.filterBuilderNoValue") }}</span>
+                      </div>
+
+                      <Button variant="ghost" size="icon" class="h-8 w-8 shrink-0 text-muted-foreground hover:text-destructive" :disabled="documentFilterRules.length === 1" @click="removeDocumentFilterRule(rule.id)">
+                        <Trash2 class="h-3.5 w-3.5" />
+                      </Button>
+                    </div>
+                  </template>
+                </div>
+                <div v-else class="rounded-md border border-dashed px-3 py-4 text-center text-xs text-muted-foreground">
+                  {{ t("grid.filterBuilderEmpty") }}
+                </div>
+
+                <div class="flex items-center justify-between gap-2 pt-1">
+                  <Button variant="ghost" size="sm" class="h-8 px-2 text-xs" @click="clearDocumentFilters(clearLocalFilter)">
+                    {{ t("grid.clearFilter") }}
+                  </Button>
+                  <div class="flex items-center gap-2">
+                    <Button variant="ghost" size="sm" class="h-8 px-2 text-xs" @click="resetDocumentFilterBuilder">
+                      {{ t("grid.resetFilterBuilder") }}
+                    </Button>
+                    <Button size="sm" class="h-8 px-3 text-xs" @click="applyDocumentStructuredFilters">
+                      {{ t("grid.applyFilter") }}
+                    </Button>
+                  </div>
+                </div>
+              </PopoverContent>
+            </Popover>
+            <span class="text-blue-600 dark:text-blue-400 text-xs font-medium select-none shrink-0">{{ documentStoreProvider.filterInputLabel }}</span>
+            <input v-model="filterInput" autocapitalize="off" autocorrect="off" spellcheck="false" class="flex-1 h-5 min-w-0 text-xs bg-transparent outline-none placeholder:text-muted-foreground/60 font-mono" placeholder="{}" @keydown.enter="applyFilter" />
+            <button
+              v-if="filterInput.trim()"
+              class="text-muted-foreground hover:text-foreground shrink-0"
+              @click="
+                filterInput = '';
+                applyFilter();
+              "
+            >
+              <X class="w-3 h-3" />
+            </button>
+          </div>
+          <button
+            type="button"
+            class="group relative flex w-2 shrink-0 cursor-col-resize items-center justify-center border-l border-r border-border/80 bg-muted/15 hover:bg-primary/10 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-primary"
+            aria-label="Resize document filter and sort"
+            @mousedown="startTableSearchSplitResize"
+            @dblclick.stop="resetTableSearchSplitWidth"
+          >
+            <span class="h-5 w-px bg-border group-hover:bg-primary/60" />
+          </button>
+          <div class="flex flex-1 items-center gap-1 px-2 py-0.5 min-w-0">
+            <span class="text-orange-600 dark:text-orange-400 text-xs font-medium select-none shrink-0">{{ documentStoreProvider.sortInputLabel }}</span>
+            <input v-model="sortInput" autocapitalize="off" autocorrect="off" spellcheck="false" class="flex-1 h-5 min-w-0 text-xs bg-transparent outline-none placeholder:text-muted-foreground/60 font-mono" placeholder="{}" @keydown.enter="applyFilter" />
+            <button
+              v-if="sortInput.trim()"
+              class="text-muted-foreground hover:text-foreground shrink-0"
+              @click="
+                sortInput = '';
+                applyFilter();
+              "
+            >
+              <X class="w-3 h-3" />
+            </button>
+          </div>
+        </div>
+      </template>
+    </DataGrid>
+
+    <!-- Document view (split pane) -->
+    <Splitpanes v-else class="flex-1 min-h-0">
+      <!-- Document list (left) -->
+      <Pane :size="30" :min-size="15" :max-size="50">
+        <div class="h-full flex flex-col overflow-hidden">
+          <div class="flex-1 overflow-y-auto">
+            <div v-for="(doc, idx) in documents" :key="idx" class="px-3 py-1.5 border-b text-xs font-mono cursor-pointer hover:bg-accent/50 flex items-center gap-2 group" :class="{ 'bg-accent': selectedIdx === idx }" @click="selectDoc(idx)">
+              <span class="truncate flex-1">{{ docPreview(doc) }}</span>
+              <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100 text-destructive shrink-0" @click.stop="requestDeleteDoc(idx)">
+                <Trash2 class="w-3 h-3" />
+              </Button>
+            </div>
+            <div v-if="documents.length === 0 && !loading" class="px-3 py-8 text-center text-muted-foreground text-xs">
+              {{ t("mongo.emptyCollection") }}
+            </div>
+          </div>
+        </div>
+      </Pane>
+
+      <!-- Document viewer/editor (right) -->
+      <Pane :size="70">
+        <div class="h-full flex flex-col min-w-0 overflow-hidden">
+          <template v-if="selectedIdx !== null || isNew">
+            <div class="h-9 flex items-center gap-2 px-4 border-b bg-muted/30 shrink-0">
+              <Badge variant="secondary" class="text-xs">{{ isNew ? "New" : selectedDoc?._id }}</Badge>
+              <span class="flex-1" />
+              <Button v-if="!isEditing" variant="ghost" size="sm" class="h-6 text-xs" @click="startEdit">{{ t("mongo.edit") }}</Button>
+              <template v-if="isEditing">
+                <Button variant="ghost" size="sm" class="h-6 text-xs" @click="addField"> <Plus class="w-3 h-3 mr-1" /> {{ t("mongo.addField") }} </Button>
+                <Button variant="ghost" size="sm" class="h-6 text-xs" @click="cancelEdit">{{ t("grid.discard") }}</Button>
+                <Button size="sm" class="h-6 text-xs" @click="saveDoc"><Save class="w-3 h-3 mr-1" />{{ t("grid.save") }}</Button>
+              </template>
+            </div>
+
+            <div v-if="isEditing" class="flex-1 overflow-auto bg-muted/10">
+              <div class="json-edit min-w-fit p-5" :style="{ ...documentFontStyle, '--mongo-key-width': editKeyWidth }">
+                <div class="json-edit-brace">{</div>
+
+                <JsonEditNode v-for="(field, idx) in editFields" :key="field.key" :node="field" parent-kind="root" :removable="!field.readonlyValue" @remove="requestRemoveField(idx)" />
+
+                <Button variant="ghost" size="sm" class="json-edit-add" @click="addField"> <Plus class="w-3 h-3 mr-1" /> {{ t("mongo.addField") }} </Button>
+
+                <div class="json-edit-brace">}</div>
+              </div>
+            </div>
+
+            <div v-else class="flex-1 overflow-auto bg-muted/10">
+              <pre class="json-viewer min-w-fit p-5" :style="documentFontStyle" v-html="highlightedJson(editJson)" />
+            </div>
+          </template>
+          <div v-else class="h-full flex items-center justify-center text-muted-foreground text-sm">
+            {{ t("mongo.selectDocument") }}
+          </div>
+
+          <ErrorBanner v-if="error" :message="error" />
+          <DangerConfirmDialog v-model:open="showDeleteConfirm" :message="t('dangerDialog.deleteMessage')" :details="deleteDetails" :confirm-label="t('dangerDialog.deleteConfirm')" @confirm="confirmDelete" />
+        </div>
+      </Pane>
+    </Splitpanes>
+  </div>
+</template>
+
+<style scoped>
+.json-viewer {
+  font-family: var(--dbx-editor-font-family);
+  font-size: var(--dbx-editor-font-size);
+  line-height: 1.6;
+  tab-size: 2;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+
+.json-edit {
+  font-family: var(--dbx-editor-font-family);
+  font-size: var(--dbx-editor-font-size);
+  line-height: 1.6;
+  tab-size: 2;
+  color: var(--foreground);
+  white-space: pre-wrap;
+}
+
+.json-edit-brace {
+  color: var(--muted-foreground);
+  font-weight: 700;
+}
+
+.json-edit-add {
+  margin: 6px 0 6px 2ch;
+  font-family: ui-sans-serif, system-ui, sans-serif;
+}
+
+:deep(.json-key) {
+  color: #7c3aed;
+  font-weight: 600;
+}
+
+:deep(.json-string) {
+  color: #15803d;
+}
+
+:deep(.json-number) {
+  color: #b45309;
+}
+
+:deep(.json-boolean) {
+  color: #2563eb;
+  font-weight: 600;
+}
+
+:deep(.json-null) {
+  color: #64748b;
+  font-style: italic;
+}
+
+:global(.dark) :deep(.json-key) {
+  color: #c4b5fd;
+}
+
+:global(.dark) :deep(.json-string) {
+  color: #86efac;
+}
+
+:global(.dark) :deep(.json-number) {
+  color: #fbbf24;
+}
+
+:global(.dark) :deep(.json-boolean) {
+  color: #93c5fd;
+}
+
+:global(.dark) :deep(.json-null) {
+  color: #94a3b8;
+}
+</style>
diff --git a/apps/desktop/src/components/document/JsonEditNode.vue b/apps/desktop/src/components/document/JsonEditNode.vue
new file mode 100644
index 0000000..74de4bc
--- /dev/null
+++ b/apps/desktop/src/components/document/JsonEditNode.vue
@@ -0,0 +1,329 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { uuid } from "@/lib/common/utils";
+import { useI18n } from "vue-i18n";
+import { Plus, Trash2 } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import type { EditNode, EditNodeKind } from "@/types/editor";
+
+defineOptions({ name: "JsonEditNode" });
+
+const props = withDefaults(
+  defineProps<{
+    node: EditNode;
+    removable?: boolean;
+    parentKind?: EditNodeKind | "root";
+  }>(),
+  {
+    removable: true,
+    parentKind: "root",
+  },
+);
+
+const emit = defineEmits<{
+  (e: "remove"): void;
+}>();
+
+const { t } = useI18n();
+
+const isContainer = computed(() => props.node.kind !== "value");
+const showChildDeleteConfirm = ref(false);
+const pendingChildDeleteIdx = ref<number | null>(null);
+
+const childKeyWidth = computed(() => {
+  const longest = props.node.children.reduce((max, child) => {
+    return Math.max(max, Array.from(child.keyName || "").length);
+  }, 0);
+  return `${Math.min(Math.max(longest + 4, 8), 36)}ch`;
+});
+
+const childDeleteDetails = computed(() => {
+  const idx = pendingChildDeleteIdx.value;
+  if (idx === null) return "";
+  const child = props.node.children[idx];
+  if (!child) return "";
+  if (props.node.kind === "array") {
+    return t("dangerDialog.mongoArrayItemDetails", { index: child.keyName });
+  }
+  return t("dangerDialog.mongoFieldDetails", { field: child.keyName || t("mongo.field") });
+});
+
+function fieldRows(value: string): number {
+  const estimatedRows = value.split(/\r?\n/).reduce((sum, line) => {
+    return sum + Math.max(1, Math.ceil(Array.from(line).length / 110));
+  }, 0);
+  return Math.min(Math.max(estimatedRows, 2), 14);
+}
+
+function fieldValueTone(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"')) return "is-string";
+  if (/^(true|false)$/i.test(trimmed)) return "is-boolean";
+  if (/^(null|NULL)$/i.test(trimmed)) return "is-null";
+  if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) return "is-number";
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return "is-complex";
+  return "is-string";
+}
+
+function createBlankNode(keyName: string, readonlyKey: boolean): EditNode {
+  return {
+    key: uuid(),
+    keyName,
+    kind: "value",
+    valueText: "",
+    readonlyKey,
+    readonlyValue: false,
+    children: [],
+  };
+}
+
+function addChild() {
+  if (props.node.kind === "array") {
+    props.node.children.push(createBlankNode(String(props.node.children.length), true));
+    return;
+  }
+  props.node.children.push(createBlankNode("", false));
+}
+
+function removeChild(idx: number) {
+  props.node.children.splice(idx, 1);
+  if (props.node.kind === "array") {
+    props.node.children.forEach((child, childIdx) => {
+      child.keyName = String(childIdx);
+    });
+  }
+}
+
+function requestRemoveChild(idx: number) {
+  pendingChildDeleteIdx.value = idx;
+  showChildDeleteConfirm.value = true;
+}
+
+function confirmRemoveChild() {
+  if (pendingChildDeleteIdx.value === null) return;
+  removeChild(pendingChildDeleteIdx.value);
+  pendingChildDeleteIdx.value = null;
+}
+</script>
+
+<template>
+  <div class="json-node">
+    <div class="json-edit-row" :class="{ 'is-container': isContainer }">
+      <div class="json-edit-key">
+        <template v-if="parentKind === 'array'">
+          <span class="json-edit-index">[{{ node.keyName }}]</span>
+        </template>
+        <template v-else>
+          <span class="json-edit-quote">"</span>
+          <input v-model="node.keyName" autocapitalize="off" autocorrect="off" spellcheck="false" class="json-edit-key-input" :disabled="node.readonlyKey" :placeholder="t('mongo.fieldPlaceholder')" />
+          <span class="json-edit-quote">"</span>
+        </template>
+        <span class="json-edit-colon">:</span>
+      </div>
+
+      <textarea v-if="node.kind === 'value'" v-model="node.valueText" class="json-edit-value" :class="[fieldValueTone(node.valueText), { 'is-readonly': node.readonlyValue }]" :disabled="node.readonlyValue" :rows="fieldRows(node.valueText)" wrap="soft" />
+      <div v-else class="json-edit-container-open">
+        <span>{{ node.kind === "array" ? "[" : "{" }}</span>
+        <span class="json-edit-count">{{ node.children.length }}</span>
+      </div>
+
+      <span class="json-edit-comma">{{ node.kind === "value" ? "," : "" }}</span>
+
+      <Button v-if="removable" variant="ghost" size="icon" class="json-edit-remove" :title="t('mongo.deleteField')" @click="emit('remove')">
+        <Trash2 class="w-3 h-3" />
+      </Button>
+      <span v-else-if="node.readonlyValue" class="json-edit-lock">{{ t("mongo.readonlyId") }}</span>
+    </div>
+
+    <div v-if="isContainer" class="json-edit-children" :style="{ '--mongo-key-width': childKeyWidth }">
+      <JsonEditNode v-for="(child, idx) in node.children" :key="child.key" :node="child" :parent-kind="node.kind" :removable="!child.readonlyValue || node.kind === 'array'" @remove="requestRemoveChild(idx)" />
+
+      <Button variant="ghost" size="sm" class="json-edit-add" @click="addChild"> <Plus class="w-3 h-3 mr-1" /> {{ t("mongo.addField") }} </Button>
+
+      <div class="json-edit-close">{{ node.kind === "array" ? "]" : "}" }}<span class="json-edit-comma">,</span></div>
+    </div>
+
+    <DangerConfirmDialog v-model:open="showChildDeleteConfirm" :message="t('dangerDialog.deleteMessage')" :details="childDeleteDetails" :confirm-label="t('mongo.deleteField')" @confirm="confirmRemoveChild" />
+  </div>
+</template>
+
+<style scoped>
+.json-edit-row {
+  display: grid;
+  grid-template-columns: var(--mongo-key-width) minmax(380px, 1fr) 14px minmax(32px, auto);
+  gap: 8px;
+  align-items: start;
+  margin: 4px 0 4px 2ch;
+  padding: 7px 8px;
+  border: 1px solid var(--border);
+  border: 1px solid color-mix(in oklab, var(--border) 82%, transparent);
+  border-left-width: 3px;
+  border-radius: 8px;
+  background: var(--muted);
+  background: color-mix(in oklab, var(--background) 76%, var(--muted));
+}
+
+.json-edit-row:hover {
+  background: var(--accent);
+  background: color-mix(in oklab, var(--background) 58%, var(--muted));
+}
+
+.json-edit-row.is-container {
+  border-bottom-left-radius: 4px;
+  border-bottom-right-radius: 4px;
+}
+
+.json-edit-key {
+  display: flex;
+  align-items: center;
+  min-height: 34px;
+  color: #7c3aed;
+  font-weight: 600;
+}
+
+.json-edit-key-input {
+  width: 100%;
+  min-width: 0;
+  border: 0;
+  border-radius: 4px;
+  background: transparent;
+  color: inherit;
+  font: inherit;
+  outline: none;
+}
+
+.json-edit-key-input:focus {
+  background: var(--background);
+  box-shadow: 0 0 0 1px var(--ring);
+}
+
+.json-edit-key-input:disabled {
+  color: var(--muted-foreground);
+  cursor: not-allowed;
+}
+
+.json-edit-quote,
+.json-edit-colon,
+.json-edit-comma,
+.json-edit-close {
+  color: var(--muted-foreground);
+}
+
+.json-edit-colon {
+  margin-left: 2px;
+}
+
+.json-edit-index {
+  color: var(--muted-foreground);
+}
+
+.json-edit-value {
+  width: 100%;
+  min-height: 42px;
+  resize: vertical;
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  background: var(--background);
+  padding: 5px 8px;
+  font: inherit;
+  line-height: 1.55;
+  outline: none;
+  overflow-y: auto;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+
+.json-edit-value:focus {
+  border-color: var(--ring);
+  box-shadow: 0 0 0 2px rgb(59 130 246 / 0.18);
+  box-shadow: 0 0 0 2px color-mix(in oklab, var(--ring) 28%, transparent);
+}
+
+.json-edit-value.is-readonly {
+  color: var(--muted-foreground);
+  cursor: not-allowed;
+}
+
+.json-edit-value.is-string {
+  color: #15803d;
+}
+
+.json-edit-value.is-number {
+  color: #b45309;
+}
+
+.json-edit-value.is-boolean {
+  color: #2563eb;
+  font-weight: 600;
+}
+
+.json-edit-value.is-null {
+  color: #64748b;
+  font-style: italic;
+}
+
+.json-edit-value.is-complex,
+.json-edit-container-open {
+  color: var(--foreground);
+}
+
+.json-edit-count {
+  margin-left: 8px;
+  color: var(--muted-foreground);
+  font-family: ui-sans-serif, system-ui, sans-serif;
+  font-size: 11px;
+}
+
+.json-edit-remove {
+  height: 28px;
+  width: 28px;
+  color: var(--destructive);
+}
+
+.json-edit-lock {
+  display: inline-flex;
+  align-items: center;
+  min-height: 28px;
+  color: var(--muted-foreground);
+  font-family: ui-sans-serif, system-ui, sans-serif;
+  font-size: 11px;
+  white-space: nowrap;
+}
+
+.json-edit-children {
+  margin: -4px 0 6px calc(2ch + 12px);
+  padding: 4px 0 4px 10px;
+  border-left: 1px solid var(--border);
+}
+
+.json-edit-close {
+  margin: 4px 0 4px 2ch;
+  font-weight: 700;
+}
+
+.json-edit-add {
+  margin: 6px 0 6px 2ch;
+  font-family: ui-sans-serif, system-ui, sans-serif;
+}
+
+:global(.dark) .json-edit-key {
+  color: #c4b5fd;
+}
+
+:global(.dark) .json-edit-value.is-string {
+  color: #86efac;
+}
+
+:global(.dark) .json-edit-value.is-number {
+  color: #fbbf24;
+}
+
+:global(.dark) .json-edit-value.is-boolean {
+  color: #93c5fd;
+}
+
+:global(.dark) .json-edit-value.is-null {
+  color: #94a3b8;
+}
+</style>
diff --git a/apps/desktop/src/components/document/MongoBucketBrowser.vue b/apps/desktop/src/components/document/MongoBucketBrowser.vue
new file mode 100644
index 0000000..4b23cdc
--- /dev/null
+++ b/apps/desktop/src/components/document/MongoBucketBrowser.vue
@@ -0,0 +1,716 @@
+<script setup lang="ts">
+import { computed, onMounted, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { ArrowDown, ArrowUp, ArrowUpDown, ChevronLeft, ChevronRight, Download, Filter, LoaderCircle, Plus, RefreshCcw, Trash2, Upload, X } from "@lucide/vue";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { useToast } from "@/composables/useToast";
+import { buildDocumentFilterCondition, currentDocumentFilterJson, currentDocumentSortJson, documentFilterModeNeedsValue, documentFilterModeOptions, documentStoreProviderFor, type DocumentFilterMode, type DocumentFilterRule } from "@/lib/app/documentStoreProvider";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import * as api from "@/lib/backend/api";
+import { uuid } from "@/lib/common/utils";
+import { downloadBinaryCellPayload, type BinaryCellDownloadPayload } from "@/lib/dataGrid/binaryCellDownload";
+import { normalizeResultPageSize, resultPageSizeMenuOptions } from "@/lib/dataGrid/paginationPageSize";
+import { buildGridFsFilesStructuredFilter, createGridFsFileFilterRule, currentGridFsFileSortDirection, gridFsFileFieldDisplayOption, gridFsFileFieldDisplayOptions, gridFsFilesQueryPreview } from "@/lib/document/gridFsBrowser";
+import { buildGridFsDownloadArchive, defaultGridFsArchiveFileName, formatGridFsUploadDate } from "@/lib/document/gridfsFiles";
+import { clampGridFsPage, gridFsTotalPages, paginateGridFsItems } from "@/lib/document/gridfsPagination";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+
+const props = defineProps<{
+  connectionId: string;
+  database: string;
+  bucket: string;
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+const connectionStore = useConnectionStore();
+const settingsStore = useSettingsStore();
+
+const loading = ref(false);
+const uploading = ref(false);
+const downloading = ref(false);
+const deleting = ref(false);
+const error = ref("");
+const files = ref<Awaited<ReturnType<typeof api.documentListGridFsFiles>>>([]);
+const selectedFileId = ref("");
+const checkedFileIds = ref<Set<string>>(new Set());
+const showDeleteConfirm = ref(false);
+const filterInput = ref("");
+const sortInput = ref("");
+const filterBuilderOpen = ref(false);
+const filterRules = ref<DocumentFilterRule[]>([createGridFsFileFilterRule(uuid())]);
+const appliedStructuredFilter = ref<Record<string, unknown> | null>(null);
+const page = ref(0);
+const pageSize = ref(normalizeResultPageSize(settingsStore.editorSettings.pageSize));
+
+const totalBytes = computed(() => files.value.reduce((sum, file) => sum + (file.length || 0), 0));
+const totalFileCount = computed(() => files.value.length);
+const totalPages = computed(() => gridFsTotalPages(totalFileCount.value, pageSize.value));
+const pagedFiles = computed(() => paginateGridFsItems(files.value, page.value, pageSize.value));
+const pageSizeOptions = computed(() => resultPageSizeMenuOptions(pageSize.value));
+const selectedFile = computed(() => files.value.find((file) => file.id === selectedFileId.value) || null);
+const checkedFiles = computed(() => files.value.filter((file) => checkedFileIds.value.has(file.id)));
+const checkedFileCount = computed(() => checkedFiles.value.length);
+const canToggleAllFiles = computed(() => files.value.length > 0);
+const allFilesChecked = computed(() => files.value.length > 0 && checkedFileIds.value.size === files.value.length);
+const partiallyChecked = computed(() => checkedFileIds.value.size > 0 && checkedFileIds.value.size < files.value.length);
+const downloadTargets = computed(() => (checkedFileCount.value > 0 ? checkedFiles.value : selectedFile.value ? [selectedFile.value] : []));
+const downloadButtonLabel = computed(() => (checkedFileCount.value > 0 ? t("gridfsBrowser.downloadSelected") : t("gridfsBrowser.downloadFile")));
+const selectedMetadata = computed(() => (selectedFile.value?.metadata ? JSON.stringify(selectedFile.value.metadata, null, 2) : ""));
+const isReadonly = computed(() => connectionStore.getConfig(props.connectionId)?.read_only ?? false);
+const mongoProvider = documentStoreProviderFor("mongodb");
+const activeStructuredRuleCount = computed(() => {
+  if (!appliedStructuredFilter.value) return 0;
+  return filterRules.value.filter((rule) => !!buildDocumentFilterCondition(rule, { kind: "mongodb" })).length;
+});
+const filterBuilderActive = computed(() => !!appliedStructuredFilter.value);
+const filesQueryPreview = computed(() => {
+  let filter = "{}";
+  let sort: string | undefined;
+  try {
+    filter = currentFilesFilter() || "{}";
+    sort = currentDocumentSortJson(sortInput.value);
+  } catch {
+    filter = filterInput.value.trim() || "{}";
+    sort = sortInput.value.trim() || undefined;
+  }
+  return gridFsFilesQueryPreview({
+    bucket: props.bucket,
+    filterJson: filter,
+    sortJson: sort,
+  });
+});
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(bytes < 10 * 1024 ? 1 : 0)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(bytes < 10 * 1024 * 1024 ? 1 : 0)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+
+function displayName(file: (typeof files.value)[number]): string {
+  return file.filename || file.id;
+}
+
+function gridFsFileFieldLabel(fieldName: string): string {
+  const option = gridFsFileFieldDisplayOption(fieldName);
+  if (!option) return fieldName;
+  if (option.label !== undefined) return option.label;
+  if (option.labelKey !== undefined) return t(option.labelKey);
+  return fieldName;
+}
+
+function formattedUploadDate(value?: string | null): string {
+  return formatGridFsUploadDate(value);
+}
+
+function currentFilesFilter(): string | undefined {
+  return currentDocumentFilterJson(filterInput.value, appliedStructuredFilter.value, "mongodb");
+}
+
+function ensureFilterRule() {
+  if (filterRules.value.length === 0) {
+    filterRules.value = [createGridFsFileFilterRule(uuid())];
+  }
+}
+
+function addFilterRule() {
+  ensureFilterRule();
+  filterRules.value = [...filterRules.value, createGridFsFileFilterRule(uuid())];
+}
+
+function removeFilterRule(ruleId: string) {
+  filterRules.value = filterRules.value.filter((rule) => rule.id !== ruleId);
+  if (filterRules.value.length === 0) {
+    appliedStructuredFilter.value = null;
+  }
+}
+
+function updateFilterRule(ruleId: string, patch: Partial<DocumentFilterRule>) {
+  filterRules.value = filterRules.value.map((rule) => {
+    if (rule.id !== ruleId) return rule;
+    const next = { ...rule, ...patch };
+    if (!documentFilterModeNeedsValue(next.mode)) next.rawValue = "";
+    return next;
+  });
+}
+
+function resetFilterBuilder() {
+  appliedStructuredFilter.value = null;
+  filterRules.value = [createGridFsFileFilterRule(uuid())];
+}
+
+function isFileChecked(fileId: string): boolean {
+  return checkedFileIds.value.has(fileId);
+}
+
+function setFileChecked(fileId: string, checked: boolean) {
+  const next = new Set(checkedFileIds.value);
+  if (checked) next.add(fileId);
+  else next.delete(fileId);
+  checkedFileIds.value = next;
+}
+
+function toggleAllFiles(checked: boolean) {
+  checkedFileIds.value = checked ? new Set(files.value.map((file) => file.id)) : new Set();
+}
+
+function ensurePageInRange() {
+  page.value = clampGridFsPage(page.value, totalFileCount.value, pageSize.value);
+}
+
+function resetToFirstPage() {
+  page.value = 0;
+}
+
+function prevPage() {
+  if (page.value <= 0) return;
+  page.value -= 1;
+}
+
+function nextPage() {
+  if (page.value + 1 >= totalPages.value) return;
+  page.value += 1;
+}
+
+function updatePageSize(nextValue: unknown) {
+  const normalized = normalizeResultPageSize(nextValue, pageSize.value);
+  pageSize.value = normalized;
+  resetToFirstPage();
+  settingsStore.updateEditorSettings({ pageSize: normalized });
+}
+
+async function loadFiles() {
+  loading.value = true;
+  error.value = "";
+  try {
+    const nextFiles = await api.documentListGridFsFiles(props.connectionId, props.database, props.bucket, currentFilesFilter(), currentDocumentSortJson(sortInput.value));
+    files.value = nextFiles;
+    checkedFileIds.value = new Set(nextFiles.filter((file) => checkedFileIds.value.has(file.id)).map((file) => file.id));
+    if (selectedFileId.value && !nextFiles.some((file) => file.id === selectedFileId.value)) {
+      selectedFileId.value = "";
+    }
+    ensurePageInRange();
+  } catch (e: any) {
+    error.value = e?.message || String(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function applyQuery() {
+  resetToFirstPage();
+  void loadFiles();
+}
+
+type SortDirection = "asc" | "desc" | null;
+
+function currentSortDirection(column: string): SortDirection {
+  const direction = currentGridFsFileSortDirection(sortInput.value, column);
+  return direction === "none" ? null : direction;
+}
+
+function toggleSortForColumn(column: string) {
+  const current = currentSortDirection(column);
+  const nextDirection: SortDirection = current === "asc" ? "desc" : current === "desc" ? null : "asc";
+  sortInput.value = mongoProvider.sortInputForColumn(column, nextDirection);
+  resetToFirstPage();
+  void loadFiles();
+}
+
+function sortIconForColumn(column: string) {
+  const direction = currentSortDirection(column);
+  return direction === "asc" ? ArrowUp : direction === "desc" ? ArrowDown : ArrowUpDown;
+}
+
+function sortIconClass(column: string): string {
+  return currentSortDirection(column) ? "text-foreground" : "text-muted-foreground/60";
+}
+
+function applyStructuredFilters() {
+  appliedStructuredFilter.value = buildGridFsFilesStructuredFilter(filterRules.value);
+  filterBuilderOpen.value = false;
+  resetToFirstPage();
+  void loadFiles();
+}
+
+function clearAllFilters() {
+  filterInput.value = "";
+  appliedStructuredFilter.value = null;
+  filterRules.value = [createGridFsFileFilterRule(uuid())];
+  resetToFirstPage();
+  void loadFiles();
+}
+
+async function downloadSingleFile(file: (typeof files.value)[number]) {
+  const bytes = await api.documentDownloadGridFsFile(props.connectionId, props.database, props.bucket, file.id);
+  const payload: BinaryCellDownloadPayload = {
+    data: bytes,
+    mimeType: file.contentType || "application/octet-stream",
+    extension: file.filename?.includes(".") ? file.filename.split(".").pop() || "bin" : "bin",
+  };
+  return downloadBinaryCellPayload(payload, displayName(file));
+}
+
+async function downloadMultipleFiles(selectedFiles: typeof files.value) {
+  const archiveEntries: Array<{ id: string; filename?: string; data: Uint8Array }> = [];
+  for (const file of selectedFiles) {
+    archiveEntries.push({
+      id: file.id,
+      filename: file.filename,
+      data: await api.documentDownloadGridFsFile(props.connectionId, props.database, props.bucket, file.id),
+    });
+  }
+  const payload: BinaryCellDownloadPayload = {
+    data: buildGridFsDownloadArchive(archiveEntries),
+    mimeType: "application/zip",
+    extension: "zip",
+  };
+  return downloadBinaryCellPayload(payload, defaultGridFsArchiveFileName(props.bucket));
+}
+
+async function downloadSpecificFile(file: (typeof files.value)[number]) {
+  if (downloading.value) return;
+  downloading.value = true;
+  try {
+    const result = await downloadSingleFile(file);
+    if (result.kind === "saved") {
+      toast(t("grid.exported"), 2500);
+    }
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    downloading.value = false;
+  }
+}
+
+async function downloadCurrentSelection() {
+  if (downloading.value || downloadTargets.value.length === 0) return;
+  downloading.value = true;
+  try {
+    const result = downloadTargets.value.length === 1 ? await downloadSingleFile(downloadTargets.value[0]) : await downloadMultipleFiles(downloadTargets.value);
+    if (result.kind === "saved") {
+      toast(t("grid.exported"), 2500);
+    }
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    downloading.value = false;
+  }
+}
+
+async function pickUploadFile(): Promise<{ name: string; data: Uint8Array; contentType?: string } | null> {
+  if (isTauriRuntime()) {
+    const [{ open }, fs] = await Promise.all([import("@tauri-apps/plugin-dialog"), import("@tauri-apps/plugin-fs")]);
+    const selected = await open({ multiple: false });
+    const path = Array.isArray(selected) ? selected[0] : selected;
+    if (!path || typeof path !== "string") return null;
+    const data = await fs.readFile(path);
+    const name = path.split(/[\\/]/).pop() || "file";
+    return { name, data };
+  }
+
+  return new Promise((resolve, reject) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.onchange = async () => {
+      try {
+        const file = input.files?.[0];
+        if (!file) {
+          resolve(null);
+          return;
+        }
+        const data = new Uint8Array(await file.arrayBuffer());
+        resolve({ name: file.name, data, contentType: file.type || undefined });
+      } catch (error) {
+        reject(error);
+      }
+    };
+    input.click();
+  });
+}
+
+async function uploadFile() {
+  if (uploading.value) return;
+  try {
+    const selected = await pickUploadFile();
+    if (!selected) return;
+    uploading.value = true;
+    const fileId = await api.documentUploadGridFsFile(props.connectionId, props.database, props.bucket, selected.name, selected.data, selected.contentType);
+    await loadFiles();
+    selectedFileId.value = fileId;
+    toast(t("gridfsBrowser.fileUploaded", { fileName: selected.name }), 2500);
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    uploading.value = false;
+  }
+}
+
+async function deleteSelectedFile() {
+  const file = selectedFile.value;
+  if (!file || deleting.value) return;
+  deleting.value = true;
+  try {
+    await api.documentDeleteGridFsFile(props.connectionId, props.database, props.bucket, file.id);
+    showDeleteConfirm.value = false;
+    selectedFileId.value = "";
+    setFileChecked(file.id, false);
+    await loadFiles();
+    toast(t("gridfsBrowser.fileDeleted", { fileName: displayName(file) }), 2500);
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    deleting.value = false;
+  }
+}
+
+onMounted(() => {
+  void loadFiles();
+});
+
+watch(
+  () => settingsStore.editorSettings.pageSize,
+  (value) => {
+    pageSize.value = normalizeResultPageSize(value, pageSize.value);
+    ensurePageInRange();
+  },
+);
+</script>
+
+<template>
+  <div class="flex h-full min-h-0 flex-col overflow-hidden">
+    <div class="border-b border-border px-4 py-3">
+      <div class="flex flex-wrap items-center justify-between gap-3">
+        <div class="min-w-0">
+          <div class="truncate text-sm font-semibold">{{ database }}.{{ bucket }}</div>
+          <div class="text-xs text-muted-foreground">
+            {{ totalFileCount }} {{ t("gridfsBrowser.fileCount") }} / {{ formatBytes(totalBytes) }}
+            <span v-if="checkedFileCount > 0"> / {{ t("gridfsBrowser.selectedCount", { count: checkedFileCount }) }}</span>
+          </div>
+        </div>
+        <div v-if="totalFileCount > 0" class="flex items-center gap-1 text-xs text-muted-foreground">
+          <Button variant="ghost" size="icon" class="h-7 w-7" :disabled="page <= 0" @click="prevPage">
+            <ChevronLeft class="h-3.5 w-3.5" />
+          </Button>
+          <span class="tabular-nums">{{ page + 1 }} / {{ totalPages }}</span>
+          <Button variant="ghost" size="icon" class="h-7 w-7" :disabled="page + 1 >= totalPages" @click="nextPage">
+            <ChevronRight class="h-3.5 w-3.5" />
+          </Button>
+          <Select :model-value="String(pageSize)" @update:model-value="(value) => updatePageSize(value)">
+            <SelectTrigger class="h-7 w-[106px] text-xs">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent align="end">
+              <SelectItem v-for="size in pageSizeOptions" :key="size" :value="String(size)"> {{ size }}{{ t("grid.rowsPerPageShort") }} </SelectItem>
+            </SelectContent>
+          </Select>
+        </div>
+        <div class="flex flex-wrap items-center gap-2">
+          <Button size="sm" class="h-8 gap-1.5" :disabled="isReadonly || uploading" @click="uploadFile">
+            <Upload class="h-3.5 w-3.5" />
+            {{ t("gridfsBrowser.uploadFile") }}
+          </Button>
+          <Button variant="outline" size="sm" class="h-8 gap-1.5" :disabled="downloadTargets.length === 0 || downloading" @click="downloadCurrentSelection">
+            <LoaderCircle v-if="downloading" class="h-3.5 w-3.5 animate-spin" />
+            <Download v-else class="h-3.5 w-3.5" />
+            {{ downloadButtonLabel }}
+          </Button>
+          <Button variant="destructive" size="sm" class="h-8 gap-1.5" :disabled="isReadonly || !selectedFile || deleting" @click="showDeleteConfirm = true">
+            <Trash2 class="h-3.5 w-3.5" />
+            {{ t("gridfsBrowser.deleteFile") }}
+          </Button>
+          <Button variant="outline" size="sm" class="h-8 gap-1.5" :disabled="loading" @click="loadFiles">
+            <RefreshCcw class="h-3.5 w-3.5" :class="{ 'animate-spin': loading }" />
+            {{ t("grid.refresh") }}
+          </Button>
+        </div>
+      </div>
+      <div class="mt-3 overflow-hidden rounded-xl border border-border/70 bg-background/80 shadow-xs">
+        <div class="flex flex-col md:flex-row">
+          <div class="flex min-w-0 flex-1 items-center gap-1 px-2 py-1.5">
+            <Popover v-model:open="filterBuilderOpen">
+              <PopoverTrigger as-child>
+                <button
+                  type="button"
+                  class="relative flex h-7 w-7 shrink-0 items-center justify-center rounded-md border text-[11px] transition-colors"
+                  :class="filterBuilderActive || filterInput.trim() ? 'border-primary/40 bg-primary/10 text-primary hover:bg-primary/15' : 'border-border/70 text-muted-foreground hover:bg-accent hover:text-foreground'"
+                  @click="ensureFilterRule"
+                >
+                  <Filter class="h-3.5 w-3.5" />
+                  <span v-if="activeStructuredRuleCount" class="absolute -right-1 -top-1 flex h-3.5 min-w-3.5 items-center justify-center rounded-full bg-primary px-1 text-[9px] leading-none text-primary-foreground">
+                    {{ activeStructuredRuleCount }}
+                  </span>
+                </button>
+              </PopoverTrigger>
+              <PopoverContent align="start" class="w-[420px] max-w-[calc(100vw-24px)] gap-3 p-3" @click.stop @keydown.stop>
+                <div class="flex items-center justify-between gap-3">
+                  <div class="text-xs font-medium text-foreground">{{ t("grid.filter") }}</div>
+                  <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" @click="addFilterRule">
+                    <Plus class="mr-1 h-3.5 w-3.5" />
+                    {{ t("grid.filterBuilderAddRule") }}
+                  </Button>
+                </div>
+
+                <div v-if="filterRules.length" class="space-y-2">
+                  <template v-for="(rule, index) in filterRules" :key="rule.id">
+                    <div v-if="index > 0" class="flex justify-center">
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        class="h-6 px-2 text-[11px] font-medium text-muted-foreground hover:text-foreground"
+                        @click="
+                          updateFilterRule(rule.id, {
+                            conjunction: rule.conjunction === 'AND' ? 'OR' : 'AND',
+                          })
+                        "
+                      >
+                        {{ rule.conjunction }}
+                      </Button>
+                    </div>
+                    <div class="grid grid-cols-[minmax(0,1fr)_minmax(0,0.95fr)_minmax(0,1fr)_auto] items-center gap-1.5">
+                      <Select :model-value="rule.fieldName" @update:model-value="(value: any) => updateFilterRule(rule.id, { fieldName: String(value) })">
+                        <SelectTrigger class="h-8 w-full min-w-0 overflow-hidden text-xs [&_[data-slot=select-value]]:min-w-0 [&_[data-slot=select-value]]:truncate">
+                          <SelectValue :placeholder="t('grid.filterBuilderColumn')" />
+                        </SelectTrigger>
+                        <SelectContent position="popper">
+                          <SelectItem v-for="option in gridFsFileFieldDisplayOptions" :key="option.fieldName" :value="option.fieldName">
+                            {{ gridFsFileFieldLabel(option.fieldName) }}
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+
+                      <Select :model-value="rule.mode" @update:model-value="(value: any) => updateFilterRule(rule.id, { mode: value as DocumentFilterMode })">
+                        <SelectTrigger class="h-8 w-full min-w-0 overflow-hidden text-xs [&_[data-slot=select-value]]:min-w-0 [&_[data-slot=select-value]]:truncate">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent position="popper">
+                          <SelectItem v-for="option in documentFilterModeOptions" :key="option.value" :value="option.value">
+                            {{ t(option.labelKey) }}
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+
+                      <Input
+                        v-if="documentFilterModeNeedsValue(rule.mode)"
+                        :model-value="rule.rawValue"
+                        class="h-8 min-w-0 text-xs"
+                        :placeholder="t('grid.filterBuilderValue')"
+                        @update:model-value="(value) => updateFilterRule(rule.id, { rawValue: String(value ?? '') })"
+                        @keydown.enter.prevent="applyStructuredFilters"
+                      />
+                      <div v-else class="flex h-8 min-w-0 items-center overflow-hidden rounded-md border border-dashed px-2 text-xs text-muted-foreground">
+                        <span class="truncate">{{ t("grid.filterBuilderNoValue") }}</span>
+                      </div>
+
+                      <Button variant="ghost" size="icon" class="h-8 w-8 shrink-0 text-muted-foreground hover:text-destructive" :disabled="filterRules.length === 1" @click="removeFilterRule(rule.id)">
+                        <Trash2 class="h-3.5 w-3.5" />
+                      </Button>
+                    </div>
+                  </template>
+                </div>
+                <div v-else class="rounded-md border border-dashed px-3 py-4 text-center text-xs text-muted-foreground">
+                  {{ t("grid.filterBuilderEmpty") }}
+                </div>
+
+                <div class="flex items-center justify-between gap-2 pt-1">
+                  <Button variant="ghost" size="sm" class="h-8 px-2 text-xs" @click="clearAllFilters">
+                    {{ t("grid.clearFilter") }}
+                  </Button>
+                  <div class="flex items-center gap-2">
+                    <Button variant="ghost" size="sm" class="h-8 px-2 text-xs" @click="resetFilterBuilder">
+                      {{ t("grid.resetFilterBuilder") }}
+                    </Button>
+                    <Button size="sm" class="h-8 px-3 text-xs" @click="applyStructuredFilters">
+                      {{ t("grid.applyFilter") }}
+                    </Button>
+                  </div>
+                </div>
+              </PopoverContent>
+            </Popover>
+            <span class="shrink-0 text-xs font-medium text-blue-600 dark:text-blue-400">{{ mongoProvider.filterInputLabel }}</span>
+            <input v-model="filterInput" autocapitalize="off" autocorrect="off" spellcheck="false" class="h-7 min-w-0 flex-1 bg-transparent font-mono text-xs outline-none placeholder:text-muted-foreground/60" placeholder="{}" @keydown.enter="applyQuery" />
+            <button
+              v-if="filterInput.trim()"
+              class="shrink-0 text-muted-foreground hover:text-foreground"
+              @click="
+                filterInput = '';
+                applyQuery();
+              "
+            >
+              <X class="h-3.5 w-3.5" />
+            </button>
+          </div>
+          <div class="h-px bg-border/70 md:h-auto md:w-px" />
+          <div class="flex min-w-0 flex-1 items-center gap-1 px-2 py-1.5">
+            <span class="shrink-0 text-xs font-medium text-orange-600 dark:text-orange-400">{{ mongoProvider.sortInputLabel }}</span>
+            <input v-model="sortInput" autocapitalize="off" autocorrect="off" spellcheck="false" class="h-7 min-w-0 flex-1 bg-transparent font-mono text-xs outline-none placeholder:text-muted-foreground/60" placeholder='{"uploadDate":-1}' @keydown.enter="applyQuery" />
+            <button
+              v-if="sortInput.trim()"
+              class="shrink-0 text-muted-foreground hover:text-foreground"
+              @click="
+                sortInput = '';
+                applyQuery();
+              "
+            >
+              <X class="h-3.5 w-3.5" />
+            </button>
+          </div>
+        </div>
+        <div class="border-t border-border/60 px-3 py-1.5">
+          <div class="truncate font-mono text-[11px] text-muted-foreground" :title="filesQueryPreview">
+            {{ filesQueryPreview }}
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div v-if="error" class="px-4 py-3 text-sm text-destructive">
+      {{ error }}
+    </div>
+
+    <div v-else-if="loading && files.length === 0" class="flex flex-1 items-center justify-center text-sm text-muted-foreground">
+      {{ t("executionSummary.executing") }}
+    </div>
+
+    <div v-else-if="files.length === 0" class="flex flex-1 items-center justify-center px-6 text-sm text-muted-foreground">
+      {{ t("gridfsBrowser.emptyFiles") }}
+    </div>
+
+    <div v-else class="min-h-0 flex flex-1 flex-col overflow-hidden xl:flex-row xl:divide-x xl:divide-border">
+      <div class="min-h-0 flex-1 overflow-auto">
+        <table class="min-w-full border-collapse text-[13px]">
+          <thead class="sticky top-0 z-10 bg-background">
+            <tr class="border-b border-border text-left text-xs text-muted-foreground">
+              <th class="w-11 px-3 py-2 font-medium">
+                <input type="checkbox" class="h-3.5 w-3.5 accent-primary" :checked="allFilesChecked" :indeterminate="partiallyChecked" :disabled="!canToggleAllFiles" @click.stop @change="toggleAllFiles(($event.target as HTMLInputElement).checked)" />
+              </th>
+              <th class="min-w-[320px] px-4 py-2 font-medium">
+                <button type="button" class="inline-flex items-center gap-1 whitespace-nowrap hover:text-foreground" @click="toggleSortForColumn('filename')">
+                  <span>{{ gridFsFileFieldLabel("filename") }}</span>
+                  <component :is="sortIconForColumn('filename')" class="h-3.5 w-3.5" :class="sortIconClass('filename')" />
+                </button>
+              </th>
+              <th class="min-w-[180px] px-4 py-2 font-medium">
+                <button type="button" class="inline-flex items-center gap-1 whitespace-nowrap hover:text-foreground" @click="toggleSortForColumn('_id')">
+                  <span>{{ gridFsFileFieldLabel("_id") }}</span>
+                  <component :is="sortIconForColumn('_id')" class="h-3.5 w-3.5" :class="sortIconClass('_id')" />
+                </button>
+              </th>
+              <th class="min-w-[96px] px-4 py-2 font-medium">
+                <button type="button" class="inline-flex items-center gap-1 whitespace-nowrap hover:text-foreground" @click="toggleSortForColumn('length')">
+                  <span>{{ gridFsFileFieldLabel("length") }}</span>
+                  <component :is="sortIconForColumn('length')" class="h-3.5 w-3.5" :class="sortIconClass('length')" />
+                </button>
+              </th>
+              <th class="min-w-[96px] px-4 py-2 font-medium">
+                <button type="button" class="inline-flex items-center gap-1 whitespace-nowrap hover:text-foreground" @click="toggleSortForColumn('chunkSize')">
+                  <span>{{ gridFsFileFieldLabel("chunkSize") }}</span>
+                  <component :is="sortIconForColumn('chunkSize')" class="h-3.5 w-3.5" :class="sortIconClass('chunkSize')" />
+                </button>
+              </th>
+              <th class="min-w-[158px] px-4 py-2 font-medium">
+                <button type="button" class="inline-flex items-center gap-1 whitespace-nowrap hover:text-foreground" @click="toggleSortForColumn('uploadDate')">
+                  <span>{{ gridFsFileFieldLabel("uploadDate") }}</span>
+                  <component :is="sortIconForColumn('uploadDate')" class="h-3.5 w-3.5" :class="sortIconClass('uploadDate')" />
+                </button>
+              </th>
+              <th class="min-w-[104px] px-4 py-2 font-medium">
+                <button type="button" class="inline-flex items-center gap-1 whitespace-nowrap hover:text-foreground" @click="toggleSortForColumn('contentType')">
+                  <span>{{ gridFsFileFieldLabel("contentType") }}</span>
+                  <component :is="sortIconForColumn('contentType')" class="h-3.5 w-3.5" :class="sortIconClass('contentType')" />
+                </button>
+              </th>
+              <th class="min-w-[220px] px-4 py-2 font-medium">
+                <button type="button" class="inline-flex items-center gap-1 whitespace-nowrap hover:text-foreground" @click="toggleSortForColumn('md5')">
+                  <span>{{ gridFsFileFieldLabel("md5") }}</span>
+                  <component :is="sortIconForColumn('md5')" class="h-3.5 w-3.5" :class="sortIconClass('md5')" />
+                </button>
+              </th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr
+              v-for="file in pagedFiles"
+              :key="file.id"
+              class="cursor-pointer border-b border-border/60 transition-colors hover:bg-muted/40"
+              :class="{
+                'bg-accent/45': selectedFileId === file.id,
+                'bg-muted/35': selectedFileId !== file.id && isFileChecked(file.id),
+              }"
+              @click="selectedFileId = file.id"
+              @dblclick="downloadSpecificFile(file)"
+            >
+              <td class="px-3 py-2 align-top">
+                <input type="checkbox" class="h-3.5 w-3.5 accent-primary" :checked="isFileChecked(file.id)" @click.stop @change="setFileChecked(file.id, ($event.target as HTMLInputElement).checked)" />
+              </td>
+              <td class="max-w-[440px] px-4 py-2 align-top">
+                <div class="truncate font-medium" :title="displayName(file)">{{ displayName(file) }}</div>
+                <div v-if="file.aliases?.length" class="mt-1 truncate text-xs text-muted-foreground" :title="file.aliases.join(', ')">{{ file.aliases.join(", ") }}</div>
+              </td>
+              <td class="px-4 py-2 align-top whitespace-nowrap text-[12px] text-muted-foreground">{{ file.id }}</td>
+              <td class="px-4 py-2 align-top whitespace-nowrap tabular-nums text-muted-foreground">{{ formatBytes(file.length) }}</td>
+              <td class="px-4 py-2 align-top whitespace-nowrap tabular-nums text-muted-foreground">{{ formatBytes(file.chunkSize || 0) }}</td>
+              <td class="px-4 py-2 align-top whitespace-nowrap tabular-nums text-muted-foreground">{{ formattedUploadDate(file.uploadDate) }}</td>
+              <td class="px-4 py-2 align-top whitespace-nowrap text-muted-foreground">{{ file.contentType || "-" }}</td>
+              <td class="px-4 py-2 align-top whitespace-nowrap text-[12px] text-muted-foreground">{{ file.md5 || "-" }}</td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+
+      <aside class="overflow-auto border-t border-border px-4 py-4 xl:w-80 xl:shrink-0 xl:border-t-0">
+        <template v-if="selectedFile">
+          <div class="text-xs font-semibold uppercase tracking-[0.18em] text-muted-foreground">{{ t("tabs.gridfs") }}</div>
+          <div class="mt-2 break-all text-lg font-semibold">{{ displayName(selectedFile) }}</div>
+          <div class="mt-1 break-all text-xs text-muted-foreground">{{ selectedFile.id }}</div>
+
+          <div class="mt-5 space-y-4 text-sm">
+            <div>
+              <div class="text-xs text-muted-foreground">{{ t("gridfsBrowser.totalSize") }}</div>
+              <div class="mt-1 font-medium">{{ formatBytes(selectedFile.length) }}</div>
+            </div>
+            <div>
+              <div class="text-xs text-muted-foreground">{{ t("gridfsBrowser.chunkSize") }}</div>
+              <div class="mt-1 font-medium">{{ formatBytes(selectedFile.chunkSize || 0) }}</div>
+            </div>
+            <div>
+              <div class="text-xs text-muted-foreground">{{ t("gridfsBrowser.uploadDate") }}</div>
+              <div class="mt-1 font-medium">{{ formattedUploadDate(selectedFile.uploadDate) }}</div>
+            </div>
+            <div>
+              <div class="text-xs text-muted-foreground">{{ t("gridfsBrowser.contentType") }}</div>
+              <div class="mt-1 break-all font-medium">{{ selectedFile.contentType || "-" }}</div>
+            </div>
+            <div v-if="selectedFile.md5">
+              <div class="text-xs text-muted-foreground">MD5</div>
+              <div class="mt-1 break-all font-medium">{{ selectedFile.md5 }}</div>
+            </div>
+            <div v-if="selectedMetadata">
+              <div class="text-xs text-muted-foreground">{{ t("gridfsBrowser.metadata") }}</div>
+              <pre class="mt-1 max-h-44 overflow-auto rounded bg-muted px-3 py-2 text-xs whitespace-pre-wrap">{{ selectedMetadata }}</pre>
+            </div>
+          </div>
+        </template>
+        <div v-else class="text-sm text-muted-foreground">
+          {{ t("gridfsBrowser.selectFile") }}
+        </div>
+      </aside>
+    </div>
+
+    <DangerConfirmDialog
+      v-model:open="showDeleteConfirm"
+      :loading="deleting"
+      :title="t('gridfsBrowser.deleteFileTitle')"
+      :message="t('gridfsBrowser.deleteFileMessage')"
+      :details="selectedFile ? displayName(selectedFile) : ''"
+      :confirm-label="t('gridfsBrowser.deleteFile')"
+      @confirm="deleteSelectedFile"
+    />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/document/MongoGridFsBrowser.vue b/apps/desktop/src/components/document/MongoGridFsBrowser.vue
new file mode 100644
index 0000000..ec5f917
--- /dev/null
+++ b/apps/desktop/src/components/document/MongoGridFsBrowser.vue
@@ -0,0 +1,344 @@
+<script setup lang="ts">
+import { computed, onMounted, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { ArrowDown, ArrowUp, ArrowUpDown, Filter, FolderOpen, Plus, RefreshCcw, Trash2, X } from "@lucide/vue";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { useToast } from "@/composables/useToast";
+import * as api from "@/lib/backend/api";
+import { currentGridFsBucketFilter, currentGridFsBucketSort, currentGridFsBucketSortDirection, gridFsBucketSortInputForColumn } from "@/lib/document/gridFsBrowser";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+
+const props = defineProps<{
+  connectionId: string;
+  database: string;
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+const queryStore = useQueryStore();
+const connectionStore = useConnectionStore();
+
+const loading = ref(false);
+const creating = ref(false);
+const deleting = ref(false);
+const error = ref("");
+const buckets = ref<Awaited<ReturnType<typeof api.documentListGridFsBuckets>>>([]);
+const selectedBucketName = ref("");
+const showCreateDialog = ref(false);
+const showDeleteConfirm = ref(false);
+const newBucketName = ref("");
+const filterInput = ref("");
+const sortInput = ref("");
+const filterBuilderOpen = ref(false);
+
+const selectedBucket = computed(() => buckets.value.find((bucket) => bucket.name === selectedBucketName.value) || null);
+const totalFiles = computed(() => buckets.value.reduce((sum, bucket) => sum + bucket.fileCount, 0));
+const totalBytes = computed(() => buckets.value.reduce((sum, bucket) => sum + bucket.totalBytes, 0));
+const isReadonly = computed(() => connectionStore.getConfig(props.connectionId)?.read_only ?? false);
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(bytes < 10 * 1024 ? 1 : 0)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(bytes < 10 * 1024 * 1024 ? 1 : 0)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+
+async function loadBuckets() {
+  loading.value = true;
+  error.value = "";
+  try {
+    const nextBuckets = await api.documentListGridFsBuckets(props.connectionId, props.database, currentGridFsBucketFilter(filterInput.value), currentGridFsBucketSort(sortInput.value));
+    buckets.value = nextBuckets;
+    if (selectedBucketName.value && !nextBuckets.some((bucket) => bucket.name === selectedBucketName.value)) {
+      selectedBucketName.value = "";
+    }
+  } catch (e: any) {
+    error.value = e?.message || String(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function applyQuery() {
+  void loadBuckets();
+}
+
+type SortDirection = "asc" | "desc" | null;
+
+function currentSortDirection(column: "name" | "fileCount" | "totalBytes"): SortDirection {
+  const direction = currentGridFsBucketSortDirection(sortInput.value, column);
+  return direction === "none" ? null : direction;
+}
+
+function toggleSortForColumn(column: "name" | "fileCount" | "totalBytes") {
+  const current = currentSortDirection(column);
+  const nextDirection: SortDirection = current === "asc" ? "desc" : current === "desc" ? null : "asc";
+  sortInput.value = gridFsBucketSortInputForColumn(column, nextDirection);
+  void loadBuckets();
+}
+
+function sortIconForColumn(column: "name" | "fileCount" | "totalBytes") {
+  const direction = currentSortDirection(column);
+  return direction === "asc" ? ArrowUp : direction === "desc" ? ArrowDown : ArrowUpDown;
+}
+
+function sortIconClass(column: "name" | "fileCount" | "totalBytes"): string {
+  return currentSortDirection(column) ? "text-foreground" : "text-muted-foreground/60";
+}
+
+function applyBucketNameFilter() {
+  filterBuilderOpen.value = false;
+  void loadBuckets();
+}
+
+function resetBucketNameFilter() {
+  filterInput.value = "";
+}
+
+function clearBucketNameFilter() {
+  filterInput.value = "";
+  filterBuilderOpen.value = false;
+  void loadBuckets();
+}
+
+function openBucket(bucketName = selectedBucketName.value) {
+  if (!bucketName) return;
+  queryStore.openMongoBucket(props.connectionId, props.database, bucketName);
+}
+
+async function createBucket() {
+  const bucketName = newBucketName.value.trim();
+  if (!bucketName || creating.value) return;
+  creating.value = true;
+  try {
+    await api.documentCreateGridFsBucket(props.connectionId, props.database, bucketName);
+    showCreateDialog.value = false;
+    newBucketName.value = "";
+    selectedBucketName.value = bucketName;
+    await loadBuckets();
+    toast(t("gridfsBrowser.bucketCreated", { bucket: bucketName }), 2500);
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    creating.value = false;
+  }
+}
+
+async function deleteBucket() {
+  const bucketName = selectedBucketName.value;
+  if (!bucketName || deleting.value) return;
+  deleting.value = true;
+  try {
+    await api.documentDeleteGridFsBucket(props.connectionId, props.database, bucketName);
+    showDeleteConfirm.value = false;
+    selectedBucketName.value = "";
+    await loadBuckets();
+    toast(t("gridfsBrowser.bucketDeleted", { bucket: bucketName }), 2500);
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    deleting.value = false;
+  }
+}
+
+onMounted(() => {
+  void loadBuckets();
+});
+</script>
+
+<template>
+  <div class="flex h-full min-h-0 flex-col overflow-hidden">
+    <div class="border-b border-border px-4 py-3">
+      <div class="flex flex-wrap items-center justify-between gap-3">
+        <div class="min-w-0">
+          <div class="truncate text-sm font-semibold">{{ database }} / {{ t("tabs.gridfs") }}</div>
+          <div class="text-xs text-muted-foreground">{{ buckets.length }} {{ t("gridfsBrowser.bucketCount") }} / {{ totalFiles }} {{ t("gridfsBrowser.fileCount") }} / {{ formatBytes(totalBytes) }}</div>
+        </div>
+        <div class="flex flex-wrap items-center gap-2">
+          <Button size="sm" class="h-8 gap-1.5" :disabled="isReadonly" @click="showCreateDialog = true">
+            <Plus class="h-3.5 w-3.5" />
+            {{ t("gridfsBrowser.createBucket") }}
+          </Button>
+          <Button variant="outline" size="sm" class="h-8 gap-1.5" :disabled="!selectedBucket" @click="openBucket()">
+            <FolderOpen class="h-3.5 w-3.5" />
+            {{ t("gridfsBrowser.openBucket") }}
+          </Button>
+          <Button variant="destructive" size="sm" class="h-8 gap-1.5" :disabled="isReadonly || !selectedBucket || deleting" @click="showDeleteConfirm = true">
+            <Trash2 class="h-3.5 w-3.5" />
+            {{ t("gridfsBrowser.deleteBucket") }}
+          </Button>
+          <Button variant="outline" size="sm" class="h-8 gap-1.5" :disabled="loading" @click="loadBuckets">
+            <RefreshCcw class="h-3.5 w-3.5" :class="{ 'animate-spin': loading }" />
+            {{ t("grid.refresh") }}
+          </Button>
+        </div>
+      </div>
+      <div class="mt-3 overflow-hidden rounded-xl border border-border/70 bg-background/80 shadow-xs">
+        <div class="flex flex-col md:flex-row">
+          <div class="flex min-w-0 flex-1 items-center gap-1 px-2 py-1.5">
+            <Popover v-model:open="filterBuilderOpen">
+              <PopoverTrigger as-child>
+                <button
+                  type="button"
+                  class="flex h-7 w-7 shrink-0 items-center justify-center rounded-md border text-[11px] transition-colors"
+                  :class="filterInput.trim() ? 'border-primary/40 bg-primary/10 text-primary hover:bg-primary/15' : 'border-border/70 text-muted-foreground hover:bg-accent hover:text-foreground'"
+                >
+                  <Filter class="h-3.5 w-3.5" />
+                </button>
+              </PopoverTrigger>
+              <PopoverContent align="start" class="w-[420px] max-w-[calc(100vw-24px)] gap-3 p-3" @click.stop @keydown.stop>
+                <div class="flex items-center justify-between gap-3">
+                  <div class="text-xs font-medium text-foreground">{{ t("grid.filter") }}</div>
+                </div>
+                <div class="grid grid-cols-[minmax(0,1fr)_minmax(0,0.95fr)_minmax(0,1fr)] items-center gap-1.5">
+                  <div class="flex h-8 min-w-0 items-center overflow-hidden rounded-md border px-2 text-xs font-medium text-foreground">
+                    <span class="truncate">{{ t("gridfsBrowser.name") }}</span>
+                  </div>
+                  <div class="flex h-8 min-w-0 items-center overflow-hidden rounded-md border px-2 text-xs text-muted-foreground">
+                    <span class="truncate">{{ t("grid.filterBuilderContains") }}</span>
+                  </div>
+                  <Input v-model="filterInput" class="h-8 min-w-0 text-xs" :placeholder="t('gridfsBrowser.bucketNamePlaceholder')" @keydown.enter.prevent="applyBucketNameFilter" />
+                </div>
+                <div class="flex items-center justify-between gap-2 pt-1">
+                  <Button variant="ghost" size="sm" class="h-8 px-2 text-xs" @click="clearBucketNameFilter">
+                    {{ t("grid.clearFilter") }}
+                  </Button>
+                  <div class="flex items-center gap-2">
+                    <Button variant="ghost" size="sm" class="h-8 px-2 text-xs" @click="resetBucketNameFilter">
+                      {{ t("grid.resetFilterBuilder") }}
+                    </Button>
+                    <Button size="sm" class="h-8 px-3 text-xs" @click="applyBucketNameFilter">
+                      {{ t("grid.applyFilter") }}
+                    </Button>
+                  </div>
+                </div>
+              </PopoverContent>
+            </Popover>
+            <span class="shrink-0 text-xs font-medium text-blue-600 dark:text-blue-400">{{ t("grid.filter") }}</span>
+            <input v-model="filterInput" autocapitalize="off" autocorrect="off" spellcheck="false" class="h-7 min-w-0 flex-1 bg-transparent text-xs outline-none placeholder:text-muted-foreground/60" :placeholder="t('gridfsBrowser.bucketNamePlaceholder')" @keydown.enter="applyQuery" />
+            <button
+              v-if="filterInput.trim()"
+              class="shrink-0 text-muted-foreground hover:text-foreground"
+              @click="
+                filterInput = '';
+                applyQuery();
+              "
+            >
+              <X class="h-3.5 w-3.5" />
+            </button>
+          </div>
+          <div class="h-px bg-border/70 md:h-auto md:w-px" />
+          <div class="flex min-w-0 flex-1 items-center gap-1 px-2 py-1.5">
+            <span class="shrink-0 text-xs font-medium text-orange-600 dark:text-orange-400">{{ t("grid.sort") }}</span>
+            <input v-model="sortInput" autocapitalize="off" autocorrect="off" spellcheck="false" class="h-7 min-w-0 flex-1 bg-transparent font-mono text-xs outline-none placeholder:text-muted-foreground/60" placeholder='{"name":1}' @keydown.enter="applyQuery" />
+            <button
+              v-if="sortInput.trim()"
+              class="shrink-0 text-muted-foreground hover:text-foreground"
+              @click="
+                sortInput = '';
+                applyQuery();
+              "
+            >
+              <X class="h-3.5 w-3.5" />
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div v-if="error" class="px-4 py-3 text-sm text-destructive">
+      {{ error }}
+    </div>
+
+    <div v-else-if="loading && buckets.length === 0" class="flex flex-1 items-center justify-center text-sm text-muted-foreground">
+      {{ t("executionSummary.executing") }}
+    </div>
+
+    <div v-else-if="buckets.length === 0" class="flex flex-1 items-center justify-center px-6 text-sm text-muted-foreground">
+      {{ t("gridfsBrowser.emptyBuckets") }}
+    </div>
+
+    <div v-else class="min-h-0 flex flex-1 flex-col overflow-hidden xl:flex-row xl:divide-x xl:divide-border">
+      <div class="min-h-0 flex-1 overflow-auto">
+        <table class="min-w-full border-collapse text-sm">
+          <thead class="sticky top-0 z-10 bg-background">
+            <tr class="border-b border-border text-left text-xs text-muted-foreground">
+              <th class="px-4 py-2 font-medium">
+                <button type="button" class="inline-flex items-center gap-1 hover:text-foreground" @click="toggleSortForColumn('name')">
+                  <span>{{ t("gridfsBrowser.name") }}</span>
+                  <component :is="sortIconForColumn('name')" class="h-3.5 w-3.5" :class="sortIconClass('name')" />
+                </button>
+              </th>
+              <th class="px-4 py-2 font-medium">
+                <button type="button" class="inline-flex items-center gap-1 hover:text-foreground" @click="toggleSortForColumn('fileCount')">
+                  <span>{{ t("gridfsBrowser.fileCount") }}</span>
+                  <component :is="sortIconForColumn('fileCount')" class="h-3.5 w-3.5" :class="sortIconClass('fileCount')" />
+                </button>
+              </th>
+              <th class="px-4 py-2 font-medium">
+                <button type="button" class="inline-flex items-center gap-1 hover:text-foreground" @click="toggleSortForColumn('totalBytes')">
+                  <span>{{ t("gridfsBrowser.totalSize") }}</span>
+                  <component :is="sortIconForColumn('totalBytes')" class="h-3.5 w-3.5" :class="sortIconClass('totalBytes')" />
+                </button>
+              </th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="bucket in buckets" :key="bucket.name" class="cursor-pointer border-b border-border/60 transition-colors hover:bg-muted/40" :class="{ 'bg-accent/45': selectedBucketName === bucket.name }" @click="selectedBucketName = bucket.name" @dblclick="openBucket(bucket.name)">
+              <td class="px-4 py-2 font-medium">{{ bucket.name }}</td>
+              <td class="px-4 py-2 text-muted-foreground">{{ bucket.fileCount }}</td>
+              <td class="px-4 py-2 text-muted-foreground">{{ formatBytes(bucket.totalBytes) }}</td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+
+      <aside class="overflow-auto border-t border-border px-4 py-4 xl:w-72 xl:shrink-0 xl:border-t-0">
+        <template v-if="selectedBucket">
+          <div class="text-xs font-semibold uppercase tracking-[0.18em] text-muted-foreground">{{ t("tabs.gridfs") }}</div>
+          <div class="mt-2 break-all text-lg font-semibold">{{ selectedBucket.name }}</div>
+
+          <div class="mt-5 space-y-4 text-sm">
+            <div>
+              <div class="text-xs text-muted-foreground">{{ t("gridfsBrowser.fileCount") }}</div>
+              <div class="mt-1 font-medium">{{ selectedBucket.fileCount }}</div>
+            </div>
+            <div>
+              <div class="text-xs text-muted-foreground">{{ t("gridfsBrowser.totalSize") }}</div>
+              <div class="mt-1 font-medium">{{ formatBytes(selectedBucket.totalBytes) }}</div>
+            </div>
+          </div>
+        </template>
+        <div v-else class="text-sm text-muted-foreground">
+          {{ t("gridfsBrowser.selectBucket") }}
+        </div>
+      </aside>
+    </div>
+
+    <Dialog v-model:open="showCreateDialog">
+      <DialogContent class="sm:max-w-[420px]">
+        <DialogHeader>
+          <DialogTitle>{{ t("gridfsBrowser.createTitle") }}</DialogTitle>
+        </DialogHeader>
+        <div class="space-y-2 py-2">
+          <label class="text-sm font-medium">{{ t("gridfsBrowser.bucketName") }}</label>
+          <Input v-model="newBucketName" :placeholder="t('gridfsBrowser.bucketNamePlaceholder')" @keydown.enter="createBucket" />
+        </div>
+        <DialogFooter>
+          <Button variant="outline" :disabled="creating" @click="showCreateDialog = false">{{ t("common.cancel") }}</Button>
+          <Button :disabled="creating || !newBucketName.trim()" class="gap-1.5" @click="createBucket">
+            <RefreshCcw v-if="creating" class="h-3.5 w-3.5 animate-spin" />
+            {{ t("gridfsBrowser.createBucket") }}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <DangerConfirmDialog v-model:open="showDeleteConfirm" :loading="deleting" :title="t('gridfsBrowser.deleteTitle')" :message="t('gridfsBrowser.deleteMessage')" :details="selectedBucketName" :confirm-label="t('gridfsBrowser.deleteBucket')" @confirm="deleteBucket" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/editor/AiAssistant.vue b/apps/desktop/src/components/editor/AiAssistant.vue
new file mode 100644
index 0000000..a29bd20
--- /dev/null
+++ b/apps/desktop/src/components/editor/AiAssistant.vue
@@ -0,0 +1,2299 @@
+<script setup lang="ts">
+import { computed, nextTick, onMounted, onUnmounted, ref, watch, type Component } from "vue";
+import { uuid } from "@/lib/common/utils";
+import { useI18n } from "vue-i18n";
+import { translateBackendError } from "@/i18n/backend-errors";
+import {
+  ArrowDown,
+  ArrowUp,
+  ArrowRightLeft,
+  AlertTriangle,
+  Bot,
+  Check,
+  ChevronRight,
+  CircleSlash,
+  Copy,
+  Database,
+  FileCode,
+  FlaskConical,
+  GitBranch,
+  HelpCircle,
+  History,
+  Loader2,
+  MessageSquarePlus,
+  Pencil,
+  Replace,
+  Server,
+  ShieldCheck,
+  Table2,
+  Play,
+  Square,
+  Trash2,
+  Terminal,
+  Wand2,
+  Wrench,
+  X,
+  Zap,
+  TestTube,
+  Search,
+} from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import LightDropdown from "@/components/ui/LightDropdown.vue";
+import { SearchableSelect } from "@/components/ui/searchable-select";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { useTheme } from "@/composables/useTheme";
+import { useSettingsStore, AI_PROVIDER_PRESETS, type AiProvider } from "@/stores/settingsStore";
+import AiProviderLogo from "@/components/icons/AiProviderLogo.vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useSavedSqlStore } from "@/stores/savedSqlStore";
+import { connectionIconType } from "@/lib/connection/connectionPresentation";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import { useQueryStore } from "@/stores/queryStore";
+import { useToast } from "@/composables/useToast";
+import { useNavigationTargets } from "@/composables/useNavigationTargets";
+import { buildAiContext, runAgentStream, isVectorDbType, isValidActionForMode, defaultActionForMode, type AiAction, type AiAssistantMode, type AiSqlFileContext } from "@/lib/ai/ai";
+import { formatAiModelOption } from "@/lib/ai/aiModelPresentation";
+import type { AgentEvent } from "@/lib/backend/tauri";
+import { buildAiAgentPlan } from "@/lib/ai/aiAgentPlan";
+import { extractFirstSqlCodeBlock } from "@/lib/ai/aiSqlExecutionPolicy";
+import { productionContextForDatabase } from "@/lib/database/productionSafety";
+import ProductionContextBadge from "@/components/common/ProductionContextBadge.vue";
+import { buildAiAgentStepItems, toolCallStepKey, upsertAgentStep, type AiAgentStepItem, type AiAgentStepTone } from "@/lib/ai/aiAgentStepPresentation";
+import { createAiShikiCodeHighlighter, type AiCodeHighlighter } from "@/lib/ai/aiCodeHighlighter";
+import { createAiMessageRenderer } from "@/lib/ai/aiMessageRender";
+import { formatAiInlineMarkdown, handleAiMarkdownLinkClick } from "@/lib/ai/aiMarkdown";
+import { aiCancelStream, aiListModels, saveAiConversation, loadAiConversations, deleteAiConversation, listSchemas, listTables, type AiConversation, type AiModelInfo } from "@/lib/backend/api";
+import type { AiMessage } from "@/lib/backend/api";
+import type { ConnectionConfig, QueryTab, SavedSqlFile, TableInfo } from "@/types/database";
+import { useDatabaseOptions } from "@/composables/useDatabaseOptions";
+import { decodeSelectableDatabaseValue, encodeSelectableDatabaseValue, formatDatabaseLabel, resolveDefaultDatabase } from "@/lib/database/defaultDatabase";
+import { isSchemaAware } from "@/lib/database/databaseCapabilities";
+import ExplainPlanViewer from "@/components/explain/ExplainPlanViewer.vue";
+import { parseExplainResult, parseOracleExplainText, type ParsedExplainPlan } from "@/lib/diagram/explainPlan";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { AI_TABLE_MENTION_CANDIDATE_LIMIT, AI_TABLE_MENTION_SCHEMA_LIMIT, filterAiTableMentionCandidates, formatAiTableMention, parseAiTableMentions, type AiTableMention } from "@/lib/ai/aiTableMentions";
+import { isAiPromptImeCompositionEvent, shouldSubmitAiPromptOnKeydown } from "@/lib/ai/aiPromptKeyboard";
+import { looksLikeActionProposal, containsChinese } from "@/lib/ai/aiProposalDetect";
+import { visibleToActualIndex } from "@/lib/ai/aiMessageEdit";
+
+const { t } = useI18n();
+const settings = useSettingsStore();
+const connectionStore = useConnectionStore();
+const savedSqlStore = useSavedSqlStore();
+const queryStore = useQueryStore();
+const { openTableTarget } = useNavigationTargets({
+  showFieldLineageDialog: ref(false),
+  showDatabaseSearchDialog: ref(false),
+  showDiagramDialog: ref(false),
+});
+const { toast } = useToast();
+const { isDark } = useTheme();
+
+type AiMessageMention =
+  | {
+      kind: "table";
+      raw: string;
+      connectionId: string;
+      database: string;
+      schema?: string;
+      table: string;
+    }
+  | {
+      kind: "sqlFile";
+      raw: string;
+      connectionId: string;
+      id: string;
+      name: string;
+    };
+
+interface ChatMessage {
+  role: "user" | "assistant";
+  content: string;
+  mentions?: AiMessageMention[];
+  reasoning?: string;
+  isThinking?: boolean;
+  agentSteps?: AiAgentStepItem[];
+  /** Hidden system-generated context summary; not rendered in chat UI but included in LLM history. */
+  kind?: "contextSummary";
+}
+
+const props = defineProps<{
+  tab?: QueryTab;
+  connection?: ConnectionConfig;
+}>();
+
+const emit = defineEmits<{
+  replaceSql: [sql: string];
+  executeSql: [sql: string];
+  tempRunSql: [sql: string];
+  requestAutoExecuteSql: [sql: string];
+  openExplainPlan: [sql: string];
+  close: [];
+}>();
+
+const prompt = ref("");
+const messages = ref<ChatMessage[]>([]);
+const isGenerating = ref(false);
+const scrollRef = ref<InstanceType<typeof ScrollArea> | null>(null);
+const activeAction = ref<AiAction>("general");
+const assistantMode = ref<"ask" | "agent">("ask");
+const currentSessionId = ref("");
+const conversationId = ref("");
+const conversations = ref<AiConversation[]>([]);
+const showConversationList = ref(false);
+const promptTextareaRef = ref<HTMLTextAreaElement | null>(null);
+const shouldAutoScroll = ref(true);
+const userPausedAutoScroll = ref(false);
+const showScrollToBottom = ref(false);
+const promptCompositionActive = ref(false);
+const shikiCodeHighlighter = ref<AiCodeHighlighter>();
+const agentTokens = ref<{ input: number; output: number } | null>(null);
+const promptHistory = ref<string[]>([]);
+const historyIndex = ref(-1);
+const draftBeforeHistory = ref("");
+
+const editingMessageIndex = ref<number | null>(null);
+const editingContent = ref("");
+const editingMentions = ref<AiPromptMentionChip[]>([]);
+const editCompositionActive = ref(false);
+const MESSAGE_SCROLL_RESUME_THRESHOLD_PX = 16;
+const MESSAGE_SCROLL_BUTTON_SHOW_THRESHOLD_PX = 120;
+const MESSAGE_SCROLL_BUTTON_HIDE_THRESHOLD_PX = 48;
+let messageScrollViewport: HTMLElement | null = null;
+let messageTouchStartY: number | null = null;
+let lastMessageScrollTop = 0;
+let assistantDeltaFrame: number | null = null;
+let pendingAssistantDelta = "";
+let pendingAssistantReasoning = "";
+let pendingAssistantIndex = -1;
+
+function startEditMessage(visibleIndex: number) {
+  if (isGenerating.value) return;
+  editingMessageIndex.value = visibleIndex;
+  const msg = visibleMessages.value[visibleIndex];
+  editingContent.value = msg.content;
+  editingMentions.value = promptMentionChipsFromMessage(msg);
+  nextTick(() => {
+    const el = document.querySelector<HTMLTextAreaElement>("[data-edit-textarea]");
+    if (el) {
+      el.focus();
+      el.setSelectionRange(el.value.length, el.value.length);
+    }
+  });
+}
+
+function cancelEdit() {
+  editingMessageIndex.value = null;
+  editingContent.value = "";
+  editingMentions.value = [];
+}
+
+function submitEdit(visibleIndex: number) {
+  const content = editingContent.value.trim();
+  if (!content && !editingMentions.value.length) return;
+  const actualIndex = visibleToActualIndex(messages.value, visibleIndex);
+  if (actualIndex < 0) return;
+  if (!props.connection || !props.tab) return;
+  if (!settings.isConfigured()) {
+    toast(t("ai.noConfig"));
+    return;
+  }
+  messages.value = messages.value.slice(0, actualIndex);
+  editingMessageIndex.value = null;
+  editingContent.value = "";
+  selectedMentions.value = editingMentions.value.filter((mention): mention is AiTableMention & { kind: "table" } => mention.kind === "table").map(({ raw, schema, table }) => ({ raw, schema, table }));
+  selectedSqlFileMentions.value = editingMentions.value.filter((mention): mention is AiSqlFileMention => mention.kind === "sqlFile");
+  editingMentions.value = [];
+  prompt.value = content;
+  send();
+}
+
+function onEditKeydown(event: KeyboardEvent, visibleIndex: number) {
+  if (isAiPromptImeCompositionEvent(event, editCompositionActive.value)) return;
+  if (event.key === "Escape") {
+    cancelEdit();
+    return;
+  }
+  if (event.key === "Enter" && !event.shiftKey) {
+    event.preventDefault();
+    submitEdit(visibleIndex);
+  }
+}
+
+// Inline model selector
+const modelOptions = ref<AiModelInfo[]>([]);
+const modelLoading = ref(false);
+let modelRequestToken = 0;
+const providerSelectorOpen = ref(false);
+
+// Configured providers for quick switching
+const configuredProviders = computed(() => (Object.keys(AI_PROVIDER_PRESETS) as AiProvider[]).filter((p) => p !== settings.aiConfig.provider && settings.isAiProviderConfigured(p)));
+
+function handleProviderSwitch(provider: AiProvider) {
+  settings.updateAiConfig({ provider });
+  modelOptions.value = [];
+  providerSelectorOpen.value = false;
+}
+
+function normalizeModelOptions(models: AiModelInfo[]): AiModelInfo[] {
+  const seen = new Set<string>();
+  const normalized: AiModelInfo[] = [];
+  for (const model of models) {
+    const id = model.id?.trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    normalized.push({ id, displayName: model.displayName?.trim() || undefined });
+  }
+  return normalized;
+}
+
+async function fetchModelOptions() {
+  if (modelLoading.value) return;
+  if (!settings.isConfigured()) return;
+  const token = ++modelRequestToken;
+  modelLoading.value = true;
+  try {
+    const models = normalizeModelOptions(await aiListModels(settings.aiConfig));
+    if (token !== modelRequestToken) return;
+    modelOptions.value = models;
+  } catch {
+    if (token !== modelRequestToken) return;
+    modelOptions.value = [];
+  } finally {
+    if (token === modelRequestToken) modelLoading.value = false;
+  }
+}
+
+function handleModelSelect(modelId: string) {
+  settings.updateAiConfig({ model: modelId });
+}
+
+const modelOptionIds = computed(() => {
+  const currentModel = settings.aiConfig.model;
+  const ids = modelOptions.value.map((model) => model.id);
+  if (currentModel && !ids.includes(currentModel)) {
+    return [currentModel, ...ids];
+  }
+  return ids;
+});
+
+function displayModelName(modelId: string) {
+  return modelOptions.value.find((model) => model.id === modelId)?.displayName || modelId;
+}
+
+function modelOptionPresentation(modelId: string, label = displayModelName(modelId)) {
+  return formatAiModelOption(label, modelId);
+}
+
+function modelOptionSecondary(modelId: string, label = displayModelName(modelId)) {
+  return modelOptionPresentation(modelId, label).secondary;
+}
+
+/** Deferred context compaction info; applied after stream ends to avoid shifting assistantIdx. */
+const pendingCompaction = ref<{ summary: string; compactedMessages: number } | null>(null);
+
+const AI_TEXTAREA_MIN_HEIGHT_PX = 64;
+const AI_TEXTAREA_MAX_PANEL_RATIO = 0.5;
+const AI_TEXTAREA_HEIGHT_STORAGE_KEY = "dbx-ai-textarea-height";
+
+const textareaHeight = ref<number>(AI_TEXTAREA_MIN_HEIGHT_PX);
+const assistantRootRef = ref<HTMLElement | null>(null);
+const promptPanelRef = ref<HTMLElement | null>(null);
+const isResizing = ref<boolean>(false);
+let resizeStartY = 0;
+let resizeStartHeight = 0;
+let promptPanelResizeObserver: ResizeObserver | undefined;
+
+interface AiTableMentionCandidate {
+  kind: "table";
+  schema?: string;
+  name: string;
+  tableType: string;
+}
+
+interface AiSqlFileMentionCandidate {
+  kind: "sqlFile";
+  id: string;
+  name: string;
+  folderPath?: string;
+}
+
+type AiMentionCandidate = AiTableMentionCandidate | AiSqlFileMentionCandidate;
+
+interface AiSqlFileMention {
+  kind: "sqlFile";
+  raw: string;
+  id: string;
+  name: string;
+}
+
+type AiPromptMentionChip = (AiTableMention & { kind: "table" }) | AiSqlFileMention;
+
+const mentionOpen = ref(false);
+const mentionLoading = ref(false);
+const mentionError = ref("");
+const mentionStart = ref(0);
+const mentionSelectedIndex = ref(0);
+const mentionCandidates = ref<AiMentionCandidate[]>([]);
+const mentionCache = ref<Record<string, AiMentionCandidate[]>>({});
+const mentionListRef = ref<HTMLElement | null>(null);
+const selectedMentions = ref<AiTableMention[]>([]);
+const selectedSqlFileMentions = ref<AiSqlFileMention[]>([]);
+let mentionTimer: ReturnType<typeof setTimeout> | undefined;
+let mentionRequestId = 0;
+
+// Slash command menu
+const commandOpen = ref(false);
+const commandSelectedIndex = ref(0);
+const commandStart = ref(0);
+
+const filteredCommands = computed(() => {
+  const query = prompt.value.slice(commandStart.value + 1).toLowerCase();
+  return actionButtons.value.filter((cmd) => cmd.action.toLowerCase().includes(query) || t(cmd.key).toLowerCase().includes(query));
+});
+
+const AI_SQL_FILE_MENTION_CANDIDATE_LIMIT = 50;
+const AI_SQL_FILE_CONTEXT_MAX_CHARS = 12_000;
+
+interface AiActionButton {
+  action: AiAction;
+  icon: Component;
+  /** i18n key for the menu label. */
+  key: string;
+}
+
+/** Ask-mode actions: SQL-producing, never auto-run. */
+const askActionButtons: AiActionButton[] = [
+  { action: "general", icon: MessageSquarePlus, key: "ai.actions.general" },
+  { action: "generate", icon: Wand2, key: "ai.actions.generate" },
+  { action: "explain", icon: HelpCircle, key: "ai.actions.explain" },
+  { action: "optimize", icon: Zap, key: "ai.actions.optimize" },
+  { action: "fix", icon: Wrench, key: "ai.actions.fix" },
+  { action: "convert", icon: ArrowRightLeft, key: "ai.actions.convert" },
+  { action: "sampleData", icon: TestTube, key: "ai.actions.sampleData" },
+];
+
+/** Agent-mode actions: task-oriented, drive tool use and real results. */
+const agentActionButtons: AiActionButton[] = [
+  { action: "general", icon: MessageSquarePlus, key: "ai.actions.general" },
+  { action: "query", icon: Search, key: "ai.actions.query" },
+  { action: "exploreSchema", icon: Table2, key: "ai.actions.exploreSchema" },
+  { action: "executeAndExplain", icon: Play, key: "ai.actions.executeAndExplain" },
+  // `generate` is shared with Ask so users can still request SQL-only output without execution.
+  { action: "generate", icon: Wand2, key: "ai.actions.generateNoExec" },
+];
+
+const actionButtons = computed<AiActionButton[]>(() => (assistantMode.value === "agent" ? agentActionButtons : askActionButtons));
+
+// Vector DBs hide the action menu and only expose collection tools.
+// Keep their action at `generate` so the task contract doesn't tell the LLM to call execute_query.
+function resolveDefaultAction(mode: AiAssistantMode): AiAction {
+  if (props.connection && isVectorDbType(props.connection.db_type)) return "generate";
+  return defaultActionForMode(mode);
+}
+
+// Switching mode is a deliberate context change: land on that mode's default action so the
+// menu and behavior match the new intent. The shared `general` action is the default.
+//
+// `triggerAction` may set the action itself after programmatically switching mode (e.g. "Fix
+// with AI" invoked from Agent mode); `suppressModeActionReset` tells this watch to skip the
+// default reset so the menu keeps reflecting the action actually being run.
+let suppressModeActionReset = false;
+watch(assistantMode, (mode) => {
+  if (suppressModeActionReset) {
+    suppressModeActionReset = false;
+    return;
+  }
+  activeAction.value = resolveDefaultAction(mode);
+});
+
+watch(
+  () => props.connection?.db_type,
+  () => {
+    // Vector DBs hide the action picker, so keep the hidden action aligned with
+    // the collection-oriented prompt contract on initial render and connection changes.
+    if (props.connection && isVectorDbType(props.connection.db_type)) {
+      activeAction.value = "generate";
+    }
+  },
+  { immediate: true },
+);
+
+function selectAction(action: AiAction) {
+  activeAction.value = action;
+  if (action === "fix" && props.tab?.result) {
+    const cols = props.tab.result.columns;
+    if (cols.includes("Error")) {
+      const errVal = props.tab.result.rows[0]?.[0];
+      if (errVal != null) prompt.value = String(errVal);
+    }
+  }
+}
+
+/** Messages visible in the chat UI (excludes hidden context summaries). */
+const visibleMessages = computed(() => messages.value.filter((m) => m.kind !== "contextSummary"));
+
+function messagesForAgentHistory(historyMessages: ChatMessage[]): AiMessage[] {
+  let latestSummaryIndex = -1;
+  for (let i = historyMessages.length - 1; i >= 0; i--) {
+    if (historyMessages[i].kind === "contextSummary") {
+      latestSummaryIndex = i;
+      break;
+    }
+  }
+  if (latestSummaryIndex < 0) {
+    return historyMessages.map((m) => ({ role: m.role, content: messageContentForModel(m) }));
+  }
+  const compactedHistory = historyMessages.slice(latestSummaryIndex);
+  const firstMsg = historyMessages[0];
+  if (firstMsg && firstMsg.role === "user" && firstMsg.kind !== "contextSummary") {
+    return [{ role: "user" as const, content: messageContentForModel(firstMsg) }, ...compactedHistory.map((m) => ({ role: m.role, content: messageContentForModel(m) }))];
+  }
+  return compactedHistory.map((m) => ({ role: m.role, content: messageContentForModel(m) }));
+}
+
+const chatTitle = computed(() => {
+  const first = messages.value.find((m) => m.role === "user" && m.kind !== "contextSummary");
+  return first ? messageTitle(first).slice(0, 30) : t("ai.newChat");
+});
+
+const promptMentionChips = computed<AiPromptMentionChip[]>(() => [...selectedMentions.value.map((mention) => ({ ...mention, kind: "table" as const })), ...selectedSqlFileMentions.value]);
+
+function messageMentionLabels(message: ChatMessage): string[] {
+  return promptMentionChipsFromMessage(message).map((mention) => mention.raw);
+}
+
+function messageContentForModel(message: ChatMessage): string {
+  if (message.kind === "contextSummary") return message.content;
+  return [...messageMentionLabels(message), message.content].filter(Boolean).join(" ");
+}
+
+function messageTitle(message: ChatMessage): string {
+  return [promptMentionChipsFromMessage(message).map(mentionDisplayName).join(" "), message.content].filter(Boolean).join(" ") || t("ai.newChat");
+}
+
+const isWaitingForFirstDelta = computed(() => {
+  const last = messages.value[messages.value.length - 1];
+  return isGenerating.value && last?.role === "assistant" && !last.content && !last.reasoning;
+});
+
+/**
+ * The last assistant message whose final line looks like an action
+ * proposal question. Used to render an inline "Yes / No" confirmation bar
+ * so the user can answer without typing. `null` while the assistant is
+ * still generating or when no such message exists.
+ */
+const proposalConfirmMessage = computed<ChatMessage | null>(() => {
+  if (isGenerating.value) return null;
+  for (let i = messages.value.length - 1; i >= 0; i--) {
+    const msg = messages.value[i];
+    if (msg.kind === "contextSummary") continue;
+    if (msg.role !== "assistant") return null;
+    if (!msg.content) return null;
+    return looksLikeActionProposal(msg.content) ? msg : null;
+  }
+  return null;
+});
+
+let allowWriteSqlForNextRun = false;
+
+const productionContext = computed(() => productionContextForDatabase(props.connection, props.tab?.database));
+
+function proposalContainsWriteSql(content: string) {
+  return /\b(insert|update|delete|replace|merge|create|alter|drop|truncate|rename|grant|revoke)\b/i.test(content);
+}
+
+function sendProposalReply(positive: boolean) {
+  // Disable while a stream is in flight or no proposal is currently active.
+  if (isGenerating.value) return;
+  const target = proposalConfirmMessage.value;
+  if (!target) return;
+  if (positive && productionContext.value.active && proposalContainsWriteSql(target.content)) {
+    const sql = extractFirstSqlCodeBlock(target.content);
+    if (sql) emit("replaceSql", sql);
+    toast(t("production.aiReviewRequired"), 5000);
+    return;
+  }
+  const isZh = containsChinese(target.content || "");
+  const replyZh = positive ? "请执行上面你刚提议的操作，不要再反问确认。" : "不用执行上面提到的操作，继续当前对话。";
+  const replyEn = positive ? "Execute the action you just proposed above; do not ask for confirmation again." : "Do not execute the action mentioned above; continue the current conversation.";
+  prompt.value = isZh ? replyZh : replyEn;
+  allowWriteSqlForNextRun = positive && assistantMode.value === "agent" && proposalContainsWriteSql(target.content);
+  // Use the existing send pipeline so the message is added to history, persisted, etc.
+  send();
+}
+
+const activePlaceholder = computed(() => `${t(`ai.placeholders.${activeAction.value}`)} ${t("ai.tableMentionPlaceholderHint")}`);
+const activeModeHint = computed(() => t(`ai.modeHints.${assistantMode.value}`));
+const assistantModeItems = computed(() => [
+  {
+    value: "ask",
+    label: t("ai.modes.ask"),
+    title: t("ai.modeHints.ask"),
+    icon: MessageSquarePlus,
+  },
+  {
+    value: "agent",
+    label: t("ai.modes.agent"),
+    title: t("ai.modeHints.agent"),
+    icon: Bot,
+  },
+]);
+const actionMenuItems = computed(() =>
+  actionButtons.value.map((button) => ({
+    value: button.action,
+    label: t(button.key),
+    icon: button.icon,
+  })),
+);
+const aiCodeAppearance = computed(() => (isDark.value ? "dark" : "light"));
+
+const showActionButtons = computed(() => {
+  if (!props.connection) return true;
+  return !isVectorDbType(props.connection.db_type);
+});
+
+const { databaseOptions: allDbOptions, loadDatabaseOptions } = useDatabaseOptions();
+
+const dbOptions = computed(() => {
+  if (!props.connection) return [];
+  return allDbOptions.value[props.connection.id] || [];
+});
+
+const dbSelectOptions = computed(() => {
+  const connection = props.connection;
+  if (!connection) return [];
+  return dbOptions.value.map((database) => ({
+    database,
+    value: encodeSelectableDatabaseValue(connection.db_type, database),
+    label: formatDatabaseLabel(connection, database, {
+      defaultDatabase: t("editor.defaultDatabase"),
+      noDatabase: t("editor.noDatabase"),
+    }),
+  }));
+});
+
+const selectedDatabaseSelectValue = computed(() => (props.connection ? encodeSelectableDatabaseValue(props.connection.db_type, props.tab?.database || "") : ""));
+
+const selectedDatabaseLabel = computed(() => {
+  if (!props.connection) return t("editor.selectDatabase");
+  if (!props.tab) return t("editor.selectDatabase");
+  return formatDatabaseLabel(props.connection, props.tab.database || "", {
+    defaultDatabase: t("editor.defaultDatabase"),
+    noDatabase: t("editor.noDatabase"),
+  });
+});
+
+async function loadDatabases() {
+  if (!props.connection) return;
+  await loadDatabaseOptions(props.connection.id);
+}
+
+async function changeConnection(connectionId: string) {
+  const conn = connectionStore.getConfig(connectionId);
+  if (!conn) return;
+  connectionStore.activeConnectionId = connectionId;
+  const tab = props.tab;
+  if (tab) {
+    queryStore.updateConnection(tab.id, connectionId, resolveDefaultDatabase(conn, []));
+  } else {
+    queryStore.createTab(connectionId, resolveDefaultDatabase(conn, []));
+  }
+  try {
+    await loadDatabaseOptions(connectionId);
+    const database = resolveDefaultDatabase(conn, allDbOptions.value[connectionId] || []);
+    if (tab) {
+      queryStore.updateDatabase(tab.id, database);
+    }
+  } catch (e: unknown) {
+    const message = e instanceof Error ? e.message : String(e);
+    toast(t("connection.connectFailed", { message: translateBackendError(t, message) }), 5000);
+  }
+}
+
+function changeDatabase(value: string) {
+  const tab = props.tab;
+  const connection = props.connection;
+  if (!tab || !connection) return;
+  queryStore.updateDatabase(tab.id, decodeSelectableDatabaseValue(connection.db_type, value));
+}
+
+function flushAssistantDeltas() {
+  assistantDeltaFrame = null;
+  const msg = messages.value[pendingAssistantIndex];
+  if (!msg) return;
+  if (pendingAssistantReasoning) {
+    msg.reasoning = (msg.reasoning || "") + pendingAssistantReasoning;
+    msg.isThinking = true;
+  }
+  if (pendingAssistantDelta) {
+    msg.isThinking = false;
+    msg.content += pendingAssistantDelta;
+  }
+  pendingAssistantDelta = "";
+  pendingAssistantReasoning = "";
+  scrollToBottom();
+}
+
+function scheduleAssistantDeltaFlush(assistantIdx: number) {
+  pendingAssistantIndex = assistantIdx;
+  if (assistantDeltaFrame !== null) return;
+  // Providers can emit many tiny chunks. Render once per animation frame so
+  // Markdown parsing, highlighting, and layout do not run for every token.
+  assistantDeltaFrame = requestAnimationFrame(flushAssistantDeltas);
+}
+
+function appendAssistantDelta(assistantIdx: number, delta: string) {
+  const msg = messages.value[assistantIdx];
+  if (msg.isThinking) msg.isThinking = false;
+  pendingAssistantDelta += delta;
+  scheduleAssistantDeltaFlush(assistantIdx);
+}
+
+function appendAssistantReasoning(assistantIdx: number, delta: string) {
+  pendingAssistantReasoning += delta;
+  scheduleAssistantDeltaFlush(assistantIdx);
+}
+
+const reasoningExpanded = ref(false);
+const expandedSteps = ref<Set<string>>(new Set());
+
+function toggleStep(key: string) {
+  const next = new Set(expandedSteps.value);
+  if (next.has(key)) next.delete(key);
+  else next.add(key);
+  expandedSteps.value = next;
+}
+
+function agentStepIcon(tone: AiAgentStepTone) {
+  if (tone === "danger") return CircleSlash;
+  if (tone === "warning") return AlertTriangle;
+  if (tone === "active") return Play;
+  return ShieldCheck;
+}
+
+function agentStepClass(tone: AiAgentStepTone): string {
+  const base = "transition-colors duration-200 ease-out motion-safe:transition-colors motion-reduce:transition-none";
+  switch (tone) {
+    case "success":
+      return `border-emerald-500/30 bg-emerald-500/10 text-emerald-700 dark:text-emerald-300 ${base}`;
+    case "active":
+      return `border-blue-500/30 bg-blue-500/10 text-blue-700 dark:text-blue-300 ${base}`;
+    case "warning":
+      return `border-amber-500/35 bg-amber-500/10 text-amber-700 dark:text-amber-300 ${base}`;
+    case "danger":
+      return `border-red-500/35 bg-red-500/10 text-red-700 dark:text-red-300 ${base}`;
+    default:
+      return `border-border bg-background/60 text-muted-foreground ${base}`;
+  }
+}
+
+/** Extract tool result content from the AgentEvent result value */
+function extractToolResultContent(result: unknown): string | undefined {
+  if (!result) return undefined;
+  if (typeof result === "string") return result;
+  if (Array.isArray(result)) return result.map(extractToolResultContent).filter(Boolean).join("\n");
+  if (typeof result === "object" && result !== null && "content" in result) {
+    const content = (result as Record<string, unknown>).content;
+    if (Array.isArray(content)) return content.map(extractToolResultContent).filter(Boolean).join("\n");
+    return typeof content === "string" ? content : JSON.stringify(content);
+  }
+  if (typeof result === "object" && result !== null && "text" in result) {
+    const text = (result as Record<string, unknown>).text;
+    if (typeof text === "string") return text;
+  }
+  if (typeof result === "object" && result !== null && "message" in result) {
+    const message = (result as Record<string, unknown>).message;
+    if (typeof message === "string") return message;
+  }
+  return JSON.stringify(result);
+}
+
+/** Extract structured explain plan data from the AgentEvent result value */
+function extractExplainData(result: unknown): unknown | undefined {
+  if (!result || typeof result !== "object") return undefined;
+  const obj = result as Record<string, unknown>;
+  return obj.explain_data;
+}
+
+/** Parse explain_data (a serialized QueryResult) into ParsedExplainPlan */
+function parseExplainFromData(explainData: unknown, dbType: string): ParsedExplainPlan | undefined {
+  if (dbType === "oracle" && typeof explainData === "string") {
+    return parseOracleExplainText(explainData);
+  }
+  if (!explainData || typeof explainData !== "object") return undefined;
+  const supportedTypes = ["mysql", "postgres", "dameng", "questdb"] as const;
+  if (!supportedTypes.includes(dbType as (typeof supportedTypes)[number])) return undefined;
+  try {
+    return parseExplainResult(dbType as (typeof supportedTypes)[number], explainData as import("@/types/database").QueryResult);
+  } catch {
+    return undefined;
+  }
+}
+
+function agentEventToStep(event: AgentEvent, index: number): AiAgentStepItem | undefined {
+  if (event.type === "context_compacted") {
+    return {
+      key: `compact-${index}`,
+      labelKey: "ai.agentSteps.contextCompacted",
+      tone: "active",
+      toolResult: `Compacted ${event.compacted_messages} messages. Estimated prompt tokens: ${event.estimated_before.toLocaleString()} -> ${event.estimated_after.toLocaleString()}. Summary: ${event.summary_tokens.toLocaleString()} tokens.`,
+      isError: false,
+    };
+  }
+
+  if (event.type !== "tool_call_start" && event.type !== "tool_call_end") return undefined;
+
+  // Use a stable key based on tool_call_id so start and end events map to the same card.
+  const toolKey = toolCallStepKey(event.tool_call_id, index, event.type);
+
+  if (event.type === "tool_call_start") {
+    return {
+      key: toolKey,
+      labelKey: "ai.agentSteps.callingTool",
+      tone: "active",
+      toolName: event.tool_name,
+      toolArgs: event.args as Record<string, unknown>,
+    };
+  }
+
+  // tool_call_end: produce a final step; toolArgs will be merged from the start step by upsert if missing.
+  const isExecuteQuery = event.tool_name === "execute_query" || event.tool_name === "dbx_execute_query";
+  const labelKey = isExecuteQuery ? (event.is_error ? "ai.agentSteps.executeBlocked" : "ai.agentSteps.executeSafe") : event.is_error ? "ai.agentSteps.toolError" : "ai.agentSteps.toolDone";
+  const tone: AiAgentStepTone = event.is_error ? "danger" : "success";
+
+  return {
+    key: toolKey,
+    labelKey,
+    tone,
+    toolName: event.tool_name,
+    toolResult: extractToolResultContent(event.result),
+    explainData: extractExplainData(event.result),
+    isError: event.is_error,
+  };
+}
+
+function toggleReasoning() {
+  reasoningExpanded.value = !reasoningExpanded.value;
+}
+
+function getMessageScrollViewport(): HTMLElement | null {
+  const root = scrollRef.value?.$el as HTMLElement | undefined;
+  return root?.querySelector('[data-slot="scroll-area-viewport"]') as HTMLElement | null;
+}
+
+function messageBottomDistance(el: HTMLElement) {
+  return Math.max(0, el.scrollHeight - el.scrollTop - el.clientHeight);
+}
+
+function isAtMessageBottom(el: HTMLElement) {
+  return messageBottomDistance(el) <= MESSAGE_SCROLL_RESUME_THRESHOLD_PX;
+}
+
+function messageCanScroll(el: HTMLElement) {
+  return el.scrollHeight > el.clientHeight + MESSAGE_SCROLL_RESUME_THRESHOLD_PX;
+}
+
+function shouldShowMessageScrollButton(el: HTMLElement) {
+  if (!messageCanScroll(el)) return false;
+  const distance = messageBottomDistance(el);
+  return distance > (showScrollToBottom.value ? MESSAGE_SCROLL_BUTTON_HIDE_THRESHOLD_PX : MESSAGE_SCROLL_BUTTON_SHOW_THRESHOLD_PX);
+}
+
+function updateMessageScrollButtonVisibility() {
+  const el = getMessageScrollViewport();
+  showScrollToBottom.value = !!el && shouldShowMessageScrollButton(el);
+}
+
+function pauseMessageAutoScroll() {
+  userPausedAutoScroll.value = true;
+  shouldAutoScroll.value = false;
+  updateMessageScrollButtonVisibility();
+}
+
+function updateMessageScrollState() {
+  const el = getMessageScrollViewport();
+  if (!el) {
+    showScrollToBottom.value = false;
+    return;
+  }
+  if (isAtMessageBottom(el)) {
+    userPausedAutoScroll.value = false;
+    shouldAutoScroll.value = true;
+    showScrollToBottom.value = false;
+    return;
+  }
+  if (userPausedAutoScroll.value) {
+    shouldAutoScroll.value = false;
+    showScrollToBottom.value = shouldShowMessageScrollButton(el);
+    return;
+  }
+  shouldAutoScroll.value = false;
+  showScrollToBottom.value = shouldShowMessageScrollButton(el);
+}
+
+function handleMessageScroll() {
+  const el = getMessageScrollViewport();
+  if (!el) return;
+  if (el.scrollTop < lastMessageScrollTop - 2) {
+    userPausedAutoScroll.value = true;
+  }
+  lastMessageScrollTop = el.scrollTop;
+  updateMessageScrollState();
+}
+
+function handleMessageWheel(event: WheelEvent) {
+  if (event.deltaY < 0) pauseMessageAutoScroll();
+}
+
+function handleMessageTouchStart(event: TouchEvent) {
+  messageTouchStartY = event.touches[0]?.clientY ?? null;
+}
+
+function handleMessageTouchMove(event: TouchEvent) {
+  if (messageTouchStartY == null) return;
+  const currentY = event.touches[0]?.clientY ?? messageTouchStartY;
+  if (currentY - messageTouchStartY > 4) pauseMessageAutoScroll();
+}
+
+function handleMessageKeydown(event: KeyboardEvent) {
+  if (["ArrowUp", "PageUp", "Home"].includes(event.key)) pauseMessageAutoScroll();
+}
+
+function detachMessageScrollListener() {
+  if (!messageScrollViewport) return;
+  messageScrollViewport.removeEventListener("scroll", handleMessageScroll);
+  messageScrollViewport.removeEventListener("wheel", handleMessageWheel);
+  messageScrollViewport.removeEventListener("touchstart", handleMessageTouchStart);
+  messageScrollViewport.removeEventListener("touchmove", handleMessageTouchMove);
+  messageScrollViewport.removeEventListener("keydown", handleMessageKeydown);
+  messageScrollViewport = null;
+}
+
+function attachMessageScrollListener() {
+  nextTick(() => {
+    const el = getMessageScrollViewport();
+    if (el === messageScrollViewport) return;
+    detachMessageScrollListener();
+    messageScrollViewport = el;
+    if (!el) return;
+    el.addEventListener("scroll", handleMessageScroll, { passive: true });
+    el.addEventListener("wheel", handleMessageWheel, { passive: true });
+    el.addEventListener("touchstart", handleMessageTouchStart, { passive: true });
+    el.addEventListener("touchmove", handleMessageTouchMove, { passive: true });
+    el.addEventListener("keydown", handleMessageKeydown);
+    lastMessageScrollTop = el.scrollTop;
+    updateMessageScrollState();
+  });
+}
+
+function scrollToBottom(options: { force?: boolean } = {}) {
+  if (options.force) {
+    userPausedAutoScroll.value = false;
+    shouldAutoScroll.value = true;
+  }
+  if (!options.force && (userPausedAutoScroll.value || !shouldAutoScroll.value)) {
+    updateMessageScrollButtonVisibility();
+    return;
+  }
+  nextTick(() => {
+    const el = getMessageScrollViewport();
+    if (!el) return;
+    requestAnimationFrame(() => {
+      if (!options.force && (userPausedAutoScroll.value || !shouldAutoScroll.value)) {
+        updateMessageScrollButtonVisibility();
+        return;
+      }
+      el.scrollTop = el.scrollHeight;
+      lastMessageScrollTop = el.scrollTop;
+      userPausedAutoScroll.value = false;
+      shouldAutoScroll.value = true;
+      showScrollToBottom.value = false;
+    });
+  });
+}
+
+watch(
+  () => messages.value.length,
+  (length) => {
+    if (length) {
+      attachMessageScrollListener();
+      return;
+    }
+    detachMessageScrollListener();
+    userPausedAutoScroll.value = false;
+    shouldAutoScroll.value = true;
+    showScrollToBottom.value = false;
+  },
+  { flush: "post" },
+);
+
+function mentionCacheKey(connectionId: string, database: string, query: string) {
+  return `${connectionId}:${database}:${savedSqlStore.version}:${query.toLowerCase()}`;
+}
+
+function mentionSchemaOrder(schemas: string[]): string[] {
+  const currentSchema = props.tab?.tableMeta?.schema;
+  const preferred = [currentSchema, "public", "dbo", "main"].filter((value): value is string => !!value);
+  return [...schemas].sort((a, b) => {
+    const ai = preferred.indexOf(a);
+    const bi = preferred.indexOf(b);
+    if (ai >= 0 || bi >= 0) return (ai >= 0 ? ai : 99) - (bi >= 0 ? bi : 99);
+    return a.localeCompare(b);
+  });
+}
+
+function activeMentionAtCursor(): { start: number; query: string } | null {
+  const textarea = promptTextareaRef.value;
+  const cursor = textarea?.selectionStart ?? prompt.value.length;
+  const beforeCursor = prompt.value.slice(0, cursor);
+  const match = /(^|[\s([{,;:])@([^\s]*)$/.exec(beforeCursor);
+  if (!match) return null;
+  return { start: beforeCursor.length - match[2].length - 1, query: match[2] };
+}
+
+function normalizeMentionQuery(query: string): { schemaPrefix: string; tableFilter: string } {
+  const clean = query.replace(/^["`]+|["`]+$/g, "");
+  const dot = clean.lastIndexOf(".");
+  if (dot < 0) return { schemaPrefix: "", tableFilter: clean };
+  return {
+    schemaPrefix: clean.slice(0, dot).replace(/^["`]+|["`]+$/g, ""),
+    tableFilter: clean.slice(dot + 1).replace(/^["`]+|["`]+$/g, ""),
+  };
+}
+
+async function loadMentionCandidates(query: string) {
+  if (!props.connection || !props.tab?.connectionId || !props.tab.database) return;
+
+  const key = mentionCacheKey(props.tab.connectionId, props.tab.database, query);
+  if (mentionCache.value[key]) {
+    mentionCandidates.value = mentionCache.value[key];
+    return;
+  }
+
+  const requestId = ++mentionRequestId;
+  mentionLoading.value = true;
+  mentionError.value = "";
+  const { schemaPrefix, tableFilter } = normalizeMentionQuery(query);
+  let sqlFileCandidates: AiSqlFileMentionCandidate[] = [];
+
+  try {
+    sqlFileCandidates = await loadSqlFileMentionCandidates(query);
+    await connectionStore.ensureConnected(props.tab.connectionId);
+    let tableCandidates: AiMentionCandidate[] = [];
+    if (isSchemaAware(props.connection.db_type)) {
+      const schemas = mentionSchemaOrder(await listSchemas(props.tab.connectionId, props.tab.database));
+      const filteredSchemas = schemaPrefix ? schemas.filter((schema) => schema.toLowerCase().includes(schemaPrefix.toLowerCase())) : schemas;
+      const results = await Promise.all(
+        filteredSchemas.slice(0, AI_TABLE_MENTION_SCHEMA_LIMIT).map(async (schema) => {
+          const tables = await listTables(props.tab!.connectionId, props.tab!.database, schema, tableFilter || undefined, AI_TABLE_MENTION_CANDIDATE_LIMIT);
+          return filterAiTableMentionCandidates(
+            tables.map((table) => mentionCandidateFromTable(table, schema)),
+            tableFilter,
+            AI_TABLE_MENTION_CANDIDATE_LIMIT,
+          );
+        }),
+      );
+      tableCandidates = filterAiTableMentionCandidates(results.flat(), "", AI_TABLE_MENTION_CANDIDATE_LIMIT);
+    } else {
+      const schema = props.tab.database || props.connection.database || "main";
+      const tables = await listTables(props.tab.connectionId, props.tab.database, schema, tableFilter || undefined, AI_TABLE_MENTION_CANDIDATE_LIMIT);
+      tableCandidates = filterAiTableMentionCandidates(
+        tables.map((table) => mentionCandidateFromTable(table)),
+        tableFilter,
+        AI_TABLE_MENTION_CANDIDATE_LIMIT,
+      );
+    }
+
+    if (requestId !== mentionRequestId) return;
+    mentionCache.value[key] = [...tableCandidates, ...sqlFileCandidates];
+    mentionCandidates.value = mentionCache.value[key];
+    setMentionSelectedIndex(0);
+  } catch (e: unknown) {
+    if (requestId !== mentionRequestId) return;
+    if (sqlFileCandidates.length) {
+      mentionCache.value[key] = sqlFileCandidates;
+      mentionCandidates.value = sqlFileCandidates;
+      mentionError.value = "";
+      setMentionSelectedIndex(0);
+      return;
+    }
+    const message = e instanceof Error ? e.message : String(e);
+    mentionError.value = translateBackendError(t, message);
+    mentionCandidates.value = [];
+  } finally {
+    if (requestId === mentionRequestId) mentionLoading.value = false;
+  }
+}
+
+async function loadSqlFileMentionCandidates(query: string): Promise<AiSqlFileMentionCandidate[]> {
+  const connectionId = props.tab?.connectionId;
+  if (!connectionId) return [];
+  await savedSqlStore.initFromStorage();
+  const normalizedQuery = normalizeSqlFileMentionQuery(query);
+  return savedSqlStore.allFiles
+    .filter((file) => file.connectionId === connectionId)
+    .map((file) => ({ file, folderPath: savedSqlFolderPath(file) }))
+    .filter(({ file, folderPath }) => sqlFileMatchesQuery(file, folderPath, normalizedQuery))
+    .slice(0, AI_SQL_FILE_MENTION_CANDIDATE_LIMIT)
+    .map(({ file, folderPath }) => ({
+      kind: "sqlFile",
+      id: file.id,
+      name: file.name,
+      folderPath,
+    }));
+}
+
+function normalizeSqlFileMentionQuery(query: string) {
+  return query.replace(/^["`{]+|["`}]+$/g, "").toLowerCase();
+}
+
+function sqlFileMatchesQuery(file: SavedSqlFile, folderPath: string | undefined, query: string) {
+  if (!query) return true;
+  return [file.name, folderPath || ""].some((value) => value.toLowerCase().includes(query));
+}
+
+function savedSqlFolderPath(file: SavedSqlFile): string | undefined {
+  if (!file.folderId) return undefined;
+  const foldersById = new Map(savedSqlStore.allFolders.map((folder) => [folder.id, folder]));
+  const names: string[] = [];
+  let current = foldersById.get(file.folderId);
+  while (current) {
+    names.unshift(current.name);
+    current = current.parentFolderId ? foldersById.get(current.parentFolderId) : undefined;
+  }
+  return names.length ? names.join(" / ") : undefined;
+}
+
+function mentionCandidateFromTable(table: TableInfo, schema?: string): AiTableMentionCandidate {
+  return { kind: "table", schema, name: table.name, tableType: table.table_type };
+}
+
+function mentionCandidateName(candidate: AiMentionCandidate) {
+  if (candidate.kind === "sqlFile") return candidate.name;
+  return [candidate.schema, candidate.name].filter(Boolean).join(".");
+}
+
+function mentionDisplayName(mention: AiPromptMentionChip) {
+  if (mention.kind === "sqlFile") return mention.name;
+  return [mention.schema, mention.table].filter(Boolean).join(".");
+}
+
+function promptMentionChipsFromMessage(message: ChatMessage): AiPromptMentionChip[] {
+  return (message.mentions || []).map((mention) => {
+    if (mention.kind === "sqlFile") return { kind: "sqlFile", raw: mention.raw, id: mention.id, name: mention.name };
+    return { kind: "table", raw: mention.raw, schema: mention.schema, table: mention.table };
+  });
+}
+
+function removeMentionChip(mention: AiPromptMentionChip) {
+  if (mention.kind === "sqlFile") {
+    selectedSqlFileMentions.value = selectedSqlFileMentions.value.filter((item) => item.id !== mention.id);
+  } else {
+    selectedMentions.value = selectedMentions.value.filter((item) => item.raw !== mention.raw);
+  }
+  nextTick(() => promptTextareaRef.value?.focus());
+}
+
+function removeEditingMentionChip(index: number) {
+  editingMentions.value = editingMentions.value.filter((_, itemIndex) => itemIndex !== index);
+  nextTick(() => {
+    const el = document.querySelector<HTMLTextAreaElement>("[data-edit-textarea]");
+    el?.focus();
+  });
+}
+
+function addSelectedMention(candidate: AiMentionCandidate) {
+  if (candidate.kind === "sqlFile") {
+    const raw = `@{${candidate.name}}`;
+    if (selectedSqlFileMentions.value.some((mention) => mention.id === candidate.id)) return;
+    selectedSqlFileMentions.value.push({ kind: "sqlFile", raw, id: candidate.id, name: candidate.name });
+    return;
+  }
+  const raw = formatAiTableMention(candidate.schema, candidate.name);
+  const key = `${candidate.schema || ""}.${candidate.name}`.toLowerCase();
+  if (selectedMentions.value.some((mention) => `${mention.schema || ""}.${mention.table}`.toLowerCase() === key)) return;
+  selectedMentions.value.push({ raw, schema: candidate.schema, table: candidate.name });
+}
+
+function formatMentionCandidateType(candidate: AiMentionCandidate) {
+  if (candidate.kind === "sqlFile") return candidate.folderPath || "SQL";
+  return formatMentionTableType(candidate.tableType);
+}
+
+function selectedMessageMentions(tableMentions: AiTableMention[], sqlFileMentions: AiSqlFileMention[]): AiMessageMention[] {
+  const connectionId = props.tab?.connectionId || props.connection?.id || "";
+  const database = props.tab?.database || props.connection?.database || "";
+  return [
+    ...tableMentions.map((mention) => ({
+      kind: "table" as const,
+      raw: mention.raw,
+      connectionId,
+      database,
+      schema: mention.schema,
+      table: mention.table,
+    })),
+    ...sqlFileMentions.map((mention) => ({
+      kind: "sqlFile" as const,
+      raw: mention.raw,
+      connectionId,
+      id: mention.id,
+      name: mention.name,
+    })),
+  ];
+}
+
+async function openMessageMention(mention: AiMessageMention) {
+  try {
+    if (mention.kind === "sqlFile") {
+      const file = await savedSqlStore.ensureFileContent(mention.id);
+      if (file) queryStore.openSavedSql(file);
+      return;
+    }
+    await openTableTarget({
+      connectionId: mention.connectionId || props.tab?.connectionId || props.connection?.id || "",
+      database: mention.database || props.tab?.database || props.connection?.database || "",
+      schema: mention.schema,
+      tableName: mention.table,
+    });
+  } catch (e: unknown) {
+    const message = e instanceof Error ? e.message : String(e);
+    toast(translateBackendError(t, message), 5000);
+  }
+}
+
+function formatMentionTableType(tableType: string) {
+  const normalized = tableType.toUpperCase().replace(/\s+/g, "_");
+  if (normalized.includes("VIEW")) return t("ai.tableMentionTypes.view");
+  if (normalized.includes("SYSTEM")) return t("ai.tableMentionTypes.systemTable");
+  if (normalized.includes("TEMP")) return t("ai.tableMentionTypes.temporaryTable");
+  return t("ai.tableMentionTypes.table");
+}
+
+function setMentionSelectedIndex(index: number, keepVisible = true) {
+  mentionSelectedIndex.value = Math.max(0, Math.min(index, Math.max(mentionCandidates.value.length - 1, 0)));
+  if (keepVisible) scrollMentionSelectedIntoView();
+}
+
+function scrollMentionSelectedIntoView() {
+  nextTick(() => {
+    const list = mentionListRef.value;
+    if (!list) return;
+    const item = list.querySelector<HTMLElement>(`[data-mention-index="${mentionSelectedIndex.value}"]`);
+    if (!item) return;
+
+    const listRect = list.getBoundingClientRect();
+    const itemRect = item.getBoundingClientRect();
+    const itemTop = itemRect.top - listRect.top + list.scrollTop;
+    const itemBottom = itemTop + itemRect.height;
+    const visibleTop = list.scrollTop;
+    const visibleBottom = visibleTop + list.clientHeight;
+
+    if (itemTop < visibleTop) {
+      list.scrollTop = itemTop;
+    } else if (itemBottom > visibleBottom) {
+      list.scrollTop = itemBottom - list.clientHeight;
+    }
+  });
+}
+
+function refreshMentionState() {
+  clearTimeout(mentionTimer);
+
+  // 优先检测斜杠命令（仅在输入内容为空时触发）
+  const textarea = promptTextareaRef.value;
+  const cursor = textarea?.selectionStart ?? prompt.value.length;
+  const beforeCursor = prompt.value.slice(0, cursor);
+  const slashMatch = /^\/([^\s]*)$/.exec(beforeCursor.trimStart());
+
+  if (slashMatch) {
+    mentionOpen.value = false;
+    commandOpen.value = true;
+    commandStart.value = beforeCursor.length - slashMatch[1].length - 1;
+    commandSelectedIndex.value = 0;
+    return;
+  }
+
+  commandOpen.value = false;
+
+  const mention = activeMentionAtCursor();
+  if (!mention || !props.connection || !props.tab?.database) {
+    mentionOpen.value = false;
+    return;
+  }
+
+  mentionOpen.value = true;
+  mentionStart.value = mention.start;
+  mentionTimer = setTimeout(() => {
+    loadMentionCandidates(mention.query).catch(() => {});
+  }, 120);
+}
+
+function onPromptKeyup(event: KeyboardEvent) {
+  if (["ArrowDown", "ArrowUp", "Enter", "Tab", "Escape"].includes(event.key)) return;
+  refreshMentionState();
+}
+
+function selectCommand(command: AiActionButton) {
+  const before = prompt.value.slice(0, commandStart.value);
+  const after = prompt.value.slice(promptTextareaRef.value?.selectionStart ?? prompt.value.length);
+  prompt.value = `${before}${after}`.replace(/\s{2,}/g, " ").trim();
+  commandOpen.value = false;
+  activeAction.value = command.action;
+  nextTick(() => {
+    const textarea = promptTextareaRef.value;
+    if (textarea) {
+      textarea.selectionStart = textarea.selectionEnd = before.length;
+      textarea.focus();
+    }
+  });
+}
+
+function insertMention(candidate: AiMentionCandidate) {
+  const textarea = promptTextareaRef.value;
+  const cursor = textarea?.selectionStart ?? prompt.value.length;
+  const before = prompt.value.slice(0, mentionStart.value);
+  const after = prompt.value.slice(cursor);
+  addSelectedMention(candidate);
+  prompt.value = `${before}${after}`.replace(/\s{2,}/g, " ");
+  mentionOpen.value = false;
+  nextTick(() => {
+    const nextCursor = before.length;
+    promptTextareaRef.value?.focus();
+    promptTextareaRef.value?.setSelectionRange(nextCursor, nextCursor);
+  });
+}
+
+function onPromptKeydown(event: KeyboardEvent) {
+  if (isAiPromptImeCompositionEvent(event, promptCompositionActive.value)) return;
+
+  // 斜杠命令菜单键盘导航
+  if (commandOpen.value) {
+    if (event.key === "ArrowDown") {
+      event.preventDefault();
+      commandSelectedIndex.value = Math.min(commandSelectedIndex.value + 1, filteredCommands.value.length - 1);
+      return;
+    }
+    if (event.key === "ArrowUp") {
+      event.preventDefault();
+      commandSelectedIndex.value = Math.max(commandSelectedIndex.value - 1, 0);
+      return;
+    }
+    if ((event.key === "Enter" || event.key === "Tab") && filteredCommands.value[commandSelectedIndex.value]) {
+      event.preventDefault();
+      selectCommand(filteredCommands.value[commandSelectedIndex.value]);
+      return;
+    }
+    if (event.key === "Escape") {
+      event.preventDefault();
+      commandOpen.value = false;
+      return;
+    }
+  }
+
+  if (mentionOpen.value) {
+    if (event.key === "ArrowDown") {
+      event.preventDefault();
+      setMentionSelectedIndex(mentionSelectedIndex.value + 1);
+      return;
+    }
+    if (event.key === "ArrowUp") {
+      event.preventDefault();
+      setMentionSelectedIndex(mentionSelectedIndex.value - 1);
+      return;
+    }
+    if ((event.key === "Enter" || event.key === "Tab") && mentionCandidates.value[mentionSelectedIndex.value]) {
+      event.preventDefault();
+      insertMention(mentionCandidates.value[mentionSelectedIndex.value]);
+      return;
+    }
+    if (event.key === "Escape") {
+      event.preventDefault();
+      mentionOpen.value = false;
+      return;
+    }
+  }
+
+  // Prompt history navigation (↑/↓ when not in @mention dropdown)
+  if (event.key === "ArrowUp" && promptHistory.value.length > 0) {
+    const textarea = promptTextareaRef.value;
+    // Only enter history when cursor is on the first line
+    if (textarea && textarea.selectionStart === 0 && textarea.selectionEnd === 0) {
+      event.preventDefault();
+      if (historyIndex.value === -1) {
+        draftBeforeHistory.value = prompt.value;
+      }
+      const nextIndex = historyIndex.value + 1;
+      if (nextIndex < promptHistory.value.length) {
+        historyIndex.value = nextIndex;
+        prompt.value = promptHistory.value[nextIndex];
+        nextTick(() => {
+          textarea.selectionStart = textarea.selectionEnd = prompt.value.length;
+        });
+      }
+      return;
+    }
+  }
+  if (event.key === "ArrowDown" && historyIndex.value >= 0) {
+    event.preventDefault();
+    const nextIndex = historyIndex.value - 1;
+    if (nextIndex >= 0) {
+      historyIndex.value = nextIndex;
+      prompt.value = promptHistory.value[nextIndex];
+    } else {
+      historyIndex.value = -1;
+      prompt.value = draftBeforeHistory.value;
+    }
+    nextTick(() => {
+      const textarea = promptTextareaRef.value;
+      if (textarea) textarea.selectionStart = textarea.selectionEnd = prompt.value.length;
+    });
+    return;
+  }
+
+  if (shouldSubmitAiPromptOnKeydown(event, promptCompositionActive.value)) {
+    event.preventDefault();
+    send();
+  }
+}
+
+async function loadReferencedSqlFiles(mentions: AiSqlFileMention[]): Promise<AiSqlFileContext[]> {
+  if (!mentions.length) return [];
+  const results: AiSqlFileContext[] = [];
+  for (const mention of mentions) {
+    const file = await savedSqlStore.ensureFileContent(mention.id).catch(() => undefined);
+    if (!file) continue;
+    const sql = file.sql || "";
+    const truncated = sql.length > AI_SQL_FILE_CONTEXT_MAX_CHARS;
+    results.push({
+      id: file.id,
+      name: file.name,
+      sql: truncated ? `${sql.slice(0, AI_SQL_FILE_CONTEXT_MAX_CHARS)}\n-- ... truncated ...` : sql,
+      truncated,
+    });
+  }
+  return results;
+}
+
+async function send() {
+  const text = prompt.value.trim();
+  if ((!text && !selectedMentions.value.length && !selectedSqlFileMentions.value.length) || isGenerating.value) return;
+
+  if (!props.connection || !props.tab) return;
+  if (!settings.isConfigured()) {
+    toast(t("ai.noConfig"));
+    return;
+  }
+
+  const selectedTableMentions = [...selectedMentions.value];
+  const selectedSqlFiles = [...selectedSqlFileMentions.value];
+  const mentionedTables = [...selectedTableMentions, ...parseAiTableMentions(text)];
+  const modelInstruction = [selectedTableMentions.map((mention) => mention.raw).join(" "), selectedSqlFiles.map((mention) => mention.raw).join(" "), text].filter(Boolean).join(" ");
+
+  messages.value.push({ role: "user", content: text, mentions: selectedMessageMentions(selectedTableMentions, selectedSqlFiles) });
+  // Save to prompt history (deduplicate consecutive duplicates)
+  if (text && promptHistory.value[0] !== text) {
+    promptHistory.value.unshift(text);
+    if (promptHistory.value.length > 100) promptHistory.value.length = 100;
+  }
+  historyIndex.value = -1;
+  draftBeforeHistory.value = "";
+  prompt.value = "";
+  selectedMentions.value = [];
+  selectedSqlFileMentions.value = [];
+  scrollToBottom({ force: true });
+
+  const requestedAction = activeAction.value;
+  const requestedMode = assistantMode.value;
+  // Agent confirmation cannot grant autonomous writes while the active database is production.
+  const allowWriteSql = requestedMode === "agent" && allowWriteSqlForNextRun && !productionContext.value.active;
+  allowWriteSqlForNextRun = false;
+  isGenerating.value = true;
+  messages.value.push({ role: "assistant", content: "" });
+  const assistantIdx = messages.value.length - 1;
+  const sessionId = uuid();
+  currentSessionId.value = sessionId;
+  const agentEvents: AgentEvent[] = [];
+  agentTokens.value = null;
+  try {
+    const sqlFiles = await loadReferencedSqlFiles(selectedSqlFiles);
+    const context = await buildAiContext(props.tab, props.connection, {
+      mentionedTables,
+      sqlFiles,
+    });
+    const history: AiMessage[] = messagesForAgentHistory(messages.value.slice(0, -2));
+    await runAgentStream(
+      {
+        config: settings.aiConfig,
+        action: requestedAction,
+        mode: requestedMode,
+        instruction: modelInstruction,
+        context,
+        allowWriteSql,
+      },
+      history,
+      (event: AgentEvent) => {
+        agentEvents.push(event);
+        if (event.type === "text_delta" && event.delta) {
+          appendAssistantDelta(assistantIdx, event.delta);
+        }
+        if (event.type === "reasoning_delta" && event.delta) {
+          appendAssistantReasoning(assistantIdx, event.delta);
+        }
+        if (event.type === "agent_end") {
+          if (event.input_tokens || event.output_tokens) {
+            agentTokens.value = { input: event.input_tokens ?? 0, output: event.output_tokens ?? 0 };
+          }
+        }
+        if (event.type === "context_compacted") {
+          const msg = messages.value[assistantIdx];
+          if (msg) {
+            if (!msg.agentSteps) msg.agentSteps = [];
+            const step = agentEventToStep(event, agentEvents.length - 1);
+            if (step) upsertAgentStep(msg.agentSteps, step);
+          }
+          pendingCompaction.value = { summary: event.summary, compactedMessages: event.compacted_messages };
+        }
+        // Real-time agent step rendering
+        if (event.type === "tool_call_start" || event.type === "tool_call_end") {
+          const msg = messages.value[assistantIdx];
+          if (msg) {
+            if (!msg.agentSteps) msg.agentSteps = [];
+            const step = agentEventToStep(event, agentEvents.length - 1);
+            if (step) upsertAgentStep(msg.agentSteps, step);
+          }
+        }
+        scrollToBottom();
+      },
+      sessionId,
+    );
+  } catch (e: unknown) {
+    const message = e instanceof Error ? e.message : String(e);
+    messages.value[assistantIdx].content = `Error: ${message}`;
+  } finally {
+    if (assistantDeltaFrame !== null) cancelAnimationFrame(assistantDeltaFrame);
+    flushAssistantDeltas();
+    const msg = messages.value[assistantIdx];
+    if (msg) msg.isThinking = false;
+    isGenerating.value = false;
+    // Render agent tool call steps from agent events (fallback when no real-time steps)
+    if (msg && agentEvents.length > 0 && !msg.agentSteps?.length) {
+      const steps: AiAgentStepItem[] = [];
+      agentEvents.forEach((e, index) => {
+        const step = agentEventToStep(e, index);
+        if (step) upsertAgentStep(steps, step);
+      });
+      if (steps.length) msg.agentSteps = steps;
+    }
+    // Fallback: use aiAgentPlan for backward compatibility
+    if (msg && !msg.agentSteps?.length) {
+      const agentPlan = buildAiAgentPlan({
+        mode: requestedMode,
+        action: requestedAction,
+        instruction: modelInstruction,
+        assistantContent: msg?.content || "",
+        connection: props.connection,
+        database: props.tab?.database,
+      });
+      if (msg && requestedMode === "agent") msg.agentSteps = buildAiAgentStepItems(agentPlan);
+      if (agentPlan.handoffSql) emit("requestAutoExecuteSql", agentPlan.handoffSql);
+    }
+    currentSessionId.value = "";
+    // Apply deferred context compaction after streaming so assistantIdx stays stable.
+    // Visible chat history is kept for the user; future LLM history starts from this hidden summary.
+    if (pendingCompaction.value) {
+      const { summary, compactedMessages } = pendingCompaction.value;
+      pendingCompaction.value = null;
+      const insertAt = Math.min(1 + compactedMessages, messages.value.length - 1);
+      if (summary) {
+        messages.value.splice(insertAt, 0, {
+          role: "user",
+          content: summary,
+          kind: "contextSummary",
+        });
+      }
+    }
+    persistConversation();
+    scrollToBottom();
+  }
+}
+
+async function cancelStream() {
+  if (currentSessionId.value) {
+    await aiCancelStream(currentSessionId.value).catch(() => {});
+  }
+}
+
+function applySql(code: string) {
+  emit("replaceSql", code);
+}
+
+function executeSql(code: string) {
+  emit("executeSql", code);
+}
+
+function tempRunSql(code: string) {
+  emit("tempRunSql", code);
+}
+
+const copiedIndex = ref("");
+
+async function copyCode(code: string, key: string) {
+  try {
+    await copyToClipboard(code);
+    copiedIndex.value = key;
+    setTimeout(() => {
+      if (copiedIndex.value === key) copiedIndex.value = "";
+    }, 2000);
+  } catch (e: unknown) {
+    const message = e instanceof Error ? e.message : String(e);
+    toast(t("grid.copyFailed", { message }), 5000);
+  }
+}
+
+function clearMessages() {
+  messages.value = [];
+  conversationId.value = "";
+  historyIndex.value = -1;
+  draftBeforeHistory.value = "";
+}
+
+async function persistConversation() {
+  if (!messages.value.length || !props.connection) return;
+  if (!conversationId.value) conversationId.value = uuid();
+  const first = messages.value.find((m) => m.role === "user" && m.kind !== "contextSummary");
+  await saveAiConversation({
+    id: conversationId.value,
+    title: first ? messageTitle(first).slice(0, 50) : "Untitled",
+    connectionName: props.connection.name,
+    database: props.tab?.database || "",
+    messages: messages.value.map((m) => ({
+      role: m.role,
+      content: m.content,
+      ...(m.mentions?.length ? { mentions: m.mentions } : {}),
+      ...(m.reasoning ? { reasoning: m.reasoning } : {}),
+      ...(m.kind ? { kind: m.kind } : {}),
+    })),
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  }).catch(() => {});
+}
+
+async function setConversationListOpen(open: boolean) {
+  showConversationList.value = open;
+  if (open) conversations.value = await loadAiConversations().catch(() => []);
+}
+
+function selectConversation(conv: AiConversation) {
+  conversationId.value = conv.id;
+  messages.value = conv.messages.map((m) => ({
+    role: m.role as "user" | "assistant",
+    content: m.content,
+    mentions: Array.isArray(m.mentions) ? (m.mentions as AiMessageMention[]) : undefined,
+    reasoning: m.reasoning,
+    kind: m.kind,
+  }));
+  agentTokens.value = null;
+  pendingCompaction.value = null;
+  showConversationList.value = false;
+  scrollToBottom({ force: true });
+}
+
+async function deleteConversation(id: string) {
+  await deleteAiConversation(id).catch(() => {});
+  conversations.value = conversations.value.filter((c) => c.id !== id);
+  if (conversationId.value === id) clearMessages();
+}
+
+function startNewChat() {
+  clearMessages();
+  showConversationList.value = false;
+}
+
+onMounted(async () => {
+  const savedHeight = localStorage.getItem(AI_TEXTAREA_HEIGHT_STORAGE_KEY);
+  if (savedHeight) {
+    const height = parseInt(savedHeight, 10);
+    if (!isNaN(height)) {
+      textareaHeight.value = clampTextareaHeight(height);
+    }
+  }
+
+  conversations.value = await loadAiConversations().catch(() => []);
+  shikiCodeHighlighter.value = await createAiShikiCodeHighlighter({
+    appearance: () => aiCodeAppearance.value,
+  }).catch(() => undefined);
+
+  // Load available AI models for inline selector
+  fetchModelOptions();
+
+  window.addEventListener("resize", handlePanelResize);
+  if (typeof ResizeObserver !== "undefined" && assistantRootRef.value) {
+    promptPanelResizeObserver = new ResizeObserver(handlePanelResize);
+    promptPanelResizeObserver.observe(assistantRootRef.value);
+  }
+});
+
+function maxTextareaHeight() {
+  const panelHeight = assistantRootRef.value?.clientHeight || window.innerHeight || 0;
+  const promptPanelHeight = promptPanelRef.value?.offsetHeight || 0;
+  const currentTextareaHeight = promptTextareaRef.value?.offsetHeight || textareaHeight.value;
+  const promptPanelChromeHeight = Math.max(0, promptPanelHeight - currentTextareaHeight);
+  return Math.max(AI_TEXTAREA_MIN_HEIGHT_PX, Math.floor(panelHeight * AI_TEXTAREA_MAX_PANEL_RATIO - promptPanelChromeHeight));
+}
+
+function clampTextareaHeight(height: number) {
+  return Math.max(AI_TEXTAREA_MIN_HEIGHT_PX, Math.min(maxTextareaHeight(), Math.round(height)));
+}
+
+function handlePanelResize() {
+  textareaHeight.value = clampTextareaHeight(textareaHeight.value);
+}
+
+function startResize(event: MouseEvent) {
+  event.preventDefault();
+  isResizing.value = true;
+  resizeStartY = event.clientY;
+  resizeStartHeight = textareaHeight.value;
+
+  document.addEventListener("mousemove", handleResize);
+  document.addEventListener("mouseup", stopResize);
+
+  document.body.style.userSelect = "none";
+  document.body.style.cursor = "ns-resize";
+}
+
+function handleResize(event: MouseEvent) {
+  if (!isResizing.value) return;
+
+  const deltaY = resizeStartY - event.clientY;
+  textareaHeight.value = clampTextareaHeight(resizeStartHeight + deltaY);
+}
+
+function stopResize() {
+  if (!isResizing.value) return;
+
+  isResizing.value = false;
+
+  document.removeEventListener("mousemove", handleResize);
+  document.removeEventListener("mouseup", stopResize);
+
+  document.body.style.userSelect = "";
+  document.body.style.cursor = "";
+
+  localStorage.setItem(AI_TEXTAREA_HEIGHT_STORAGE_KEY, clampTextareaHeight(textareaHeight.value).toString());
+}
+
+onUnmounted(() => {
+  if (assistantDeltaFrame !== null) cancelAnimationFrame(assistantDeltaFrame);
+  clearTimeout(mentionTimer);
+  cancelStream();
+  detachMessageScrollListener();
+  // 清理拖拽事件监听，防止内存泄漏
+  document.removeEventListener("mousemove", handleResize);
+  document.removeEventListener("mouseup", stopResize);
+  // 若卸载时仍在拖拽，复位 body 样式，避免全局残留
+  document.body.style.userSelect = "";
+  document.body.style.cursor = "";
+  window.removeEventListener("resize", handlePanelResize);
+  promptPanelResizeObserver?.disconnect();
+});
+
+function triggerAction(action: AiAction, instruction?: string) {
+  // External Ask-style entry points (Fix with AI, Explain history) produce/analyze SQL text.
+  // If the assistant is currently in Agent mode where those actions aren't offered, switch to
+  // Ask mode so the action is valid and the menu reflects what actually runs.
+  if (!isValidActionForMode(action, assistantMode.value)) {
+    // Suppress the mode-switch watch so it doesn't overwrite `action` (set below) with the
+    // Ask default — the menu must reflect the action actually being run.
+    suppressModeActionReset = true;
+    assistantMode.value = "ask";
+  }
+  activeAction.value = action;
+  if (instruction) prompt.value = instruction;
+  send();
+}
+
+function setPrompt(text: string) {
+  prompt.value = text;
+  nextTick(() => promptTextareaRef.value?.focus());
+}
+
+defineExpose({ triggerAction, setPrompt });
+
+const messageRenderer = computed(() => {
+  const appearance = aiCodeAppearance.value;
+  const highlightCode = shikiCodeHighlighter.value;
+  return createAiMessageRenderer({
+    markdown: formatAiInlineMarkdown,
+    highlightCode: highlightCode ? (content, lang) => highlightCode(content, lang, appearance) : undefined,
+  });
+});
+
+function onMarkdownClick(event: MouseEvent) {
+  handleAiMarkdownLinkClick(event, openExternalUrl);
+}
+
+async function openExternalUrl(url: string) {
+  try {
+    const { open } = await import("@tauri-apps/plugin-shell");
+    await open(url);
+  } catch {
+    window.open(url, "_blank", "noopener,noreferrer");
+  }
+}
+</script>
+
+<template>
+  <div ref="assistantRootRef" class="flex h-full min-h-0 flex-col overflow-hidden">
+    <div class="flex items-center gap-2 border-b px-3 shrink-0" :class="settings.editorSettings.appLayout === 'classic' ? 'h-9' : 'h-10'">
+      <span class="flex flex-1 self-stretch items-center truncate text-xs font-medium" data-tauri-drag-region>
+        {{ chatTitle }}
+      </span>
+      <ProductionContextBadge v-if="productionContext.active" compact />
+      <Button variant="ghost" size="icon" class="h-6 w-6" @click="startNewChat" :title="t('ai.newChat')">
+        <MessageSquarePlus class="h-3.5 w-3.5" />
+      </Button>
+      <Popover :open="showConversationList" @update:open="setConversationListOpen">
+        <PopoverTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6" :class="{ 'bg-accent': showConversationList }" :title="t('history.title')">
+            <History class="h-3.5 w-3.5" />
+          </Button>
+        </PopoverTrigger>
+        <PopoverContent align="end" class="w-72 gap-0 p-0" @click.stop>
+          <div class="flex items-center border-b px-3 py-2">
+            <span class="flex-1 text-xs font-medium">{{ t("history.title") }}</span>
+            <Button variant="ghost" size="icon" class="h-6 w-6" @click="startNewChat">
+              <MessageSquarePlus class="h-3.5 w-3.5" />
+            </Button>
+          </div>
+          <div v-if="!conversations.length" class="p-3 text-center text-xs text-muted-foreground">
+            {{ t("history.empty") }}
+          </div>
+          <div v-else class="max-h-64 overflow-auto p-1">
+            <div v-for="conv in conversations" :key="conv.id" class="flex min-w-0 cursor-pointer items-center gap-2 rounded-md px-2 py-1.5 text-xs hover:bg-muted" :class="{ 'bg-muted': conv.id === conversationId }" @click="selectConversation(conv)">
+              <span class="min-w-0 flex-1 truncate">{{ conv.title }}</span>
+              <button class="shrink-0 rounded p-0.5 text-muted-foreground hover:bg-background hover:text-destructive" @click.stop="deleteConversation(conv.id)">
+                <X class="h-3 w-3" />
+              </button>
+            </div>
+          </div>
+        </PopoverContent>
+      </Popover>
+      <Button variant="ghost" size="icon" class="h-6 w-6" @click="clearMessages" :title="t('ai.clear')">
+        <Trash2 class="h-3.5 w-3.5" />
+      </Button>
+      <Button variant="ghost" size="icon" class="h-6 w-6" @click="emit('close')">
+        <X class="h-3.5 w-3.5" />
+      </Button>
+    </div>
+
+    <div v-if="messages.length === 0" class="flex-1 min-h-0 flex flex-col items-center justify-center text-center text-muted-foreground">
+      <Bot class="h-10 w-10 mb-3 opacity-30" />
+      <p class="text-sm">{{ t("ai.welcome") }}</p>
+    </div>
+    <div v-else class="relative min-h-0 flex-1">
+      <ScrollArea ref="scrollRef" class="ai-message-scroll h-full overflow-hidden">
+        <div class="flex flex-col gap-3 p-3">
+          <template v-for="(msg, i) in visibleMessages" :key="i">
+            <div v-if="msg.role === 'user'" class="group flex justify-end">
+              <div class="min-w-0 max-w-[85%]" :class="{ 'w-[85%]': editingMessageIndex === i }">
+                <template v-if="editingMessageIndex === i">
+                  <div v-if="editingMentions.length" class="mb-1.5 flex flex-wrap justify-end gap-1">
+                    <button
+                      v-for="(mention, mentionIndex) in editingMentions"
+                      :key="`${mention.kind}:${mention.raw}:${mentionIndex}`"
+                      type="button"
+                      class="group inline-flex max-w-full items-center gap-1 rounded border border-border/80 bg-muted/70 px-1.5 py-0.5 text-[11px] text-foreground/90 hover:bg-muted"
+                      :title="mentionDisplayName(mention)"
+                      @click="removeEditingMentionChip(mentionIndex)"
+                    >
+                      <FileCode v-if="mention.kind === 'sqlFile'" class="h-3 w-3 shrink-0 text-primary" />
+                      <Table2 v-else class="h-3 w-3 shrink-0 text-primary" />
+                      <span class="truncate">{{ mentionDisplayName(mention) }}</span>
+                      <X class="h-3 w-3 shrink-0 text-muted-foreground group-hover:text-foreground" />
+                    </button>
+                  </div>
+                  <textarea
+                    data-edit-textarea
+                    v-model="editingContent"
+                    rows="3"
+                    class="w-full resize-none rounded-lg border bg-background px-3 py-2 text-xs outline-none focus:ring-1 focus:ring-primary"
+                    @keydown="onEditKeydown($event, i)"
+                    @compositionstart="editCompositionActive = true"
+                    @compositionend="editCompositionActive = false"
+                  />
+                  <div class="mt-1.5 flex justify-end gap-1.5">
+                    <Button size="sm" variant="ghost" class="h-6 px-2 text-[11px]" @click="cancelEdit">{{ t("ai.editCancel") }}</Button>
+                    <Button size="sm" class="h-6 px-2 text-[11px]" @click="submitEdit(i)">{{ t("ai.editResend") }}</Button>
+                  </div>
+                </template>
+                <template v-else>
+                  <div class="flex items-start gap-1">
+                    <button v-if="!isGenerating" class="mt-1 hidden h-5 w-5 shrink-0 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground group-hover:flex" :title="t('ai.editMessage')" @click="startEditMessage(i)">
+                      <Pencil class="h-3 w-3" />
+                    </button>
+                    <div class="min-w-0 rounded-lg bg-primary px-3 py-2 text-xs text-primary-foreground">
+                      <div v-if="msg.mentions?.length" class="mb-1.5 flex flex-wrap justify-end gap-1">
+                        <button
+                          v-for="mention in msg.mentions"
+                          :key="`${mention.kind}:${mention.raw}`"
+                          type="button"
+                          class="inline-flex max-w-full items-center gap-1 rounded border border-primary-foreground/25 bg-primary-foreground/15 px-1.5 py-0.5 text-[11px] text-primary-foreground hover:bg-primary-foreground/25"
+                          :title="mention.kind === 'sqlFile' ? mention.name : [mention.schema, mention.table].filter(Boolean).join('.')"
+                          @click.stop="openMessageMention(mention)"
+                        >
+                          <FileCode v-if="mention.kind === 'sqlFile'" class="h-3 w-3 shrink-0" />
+                          <Table2 v-else class="h-3 w-3 shrink-0" />
+                          <span class="truncate">{{ mention.kind === "sqlFile" ? mention.name : [mention.schema, mention.table].filter(Boolean).join(".") }}</span>
+                        </button>
+                      </div>
+                      <div v-if="msg.content" class="whitespace-pre-wrap">{{ msg.content }}</div>
+                    </div>
+                  </div>
+                </template>
+              </div>
+            </div>
+
+            <div v-else-if="msg.content || msg.reasoning || msg.isThinking" class="flex">
+              <div class="max-w-[95%] min-w-0 rounded-lg bg-muted px-3 py-2 text-xs leading-relaxed">
+                <div v-if="msg.reasoning || msg.isThinking" class="mb-2">
+                  <button class="flex items-center gap-1 text-[11px] text-muted-foreground hover:text-foreground transition-colors" @click="toggleReasoning()">
+                    <ChevronRight class="h-3 w-3 transition-transform duration-200" :class="{ 'rotate-90': reasoningExpanded }" />
+                    <Loader2 v-if="msg.isThinking" class="h-3 w-3 animate-spin" />
+                    <span>{{ t("ai.reasoningProcess") }}</span>
+                  </button>
+                  <div
+                    class="overflow-hidden transition-[max-height,opacity] duration-200 ease-in-out"
+                    :style="{
+                      maxHeight: reasoningExpanded ? '20000px' : '0px',
+                      opacity: reasoningExpanded ? '1' : '0',
+                    }"
+                  >
+                    <div class="mt-1.5 pl-4 border-l-2 border-muted-foreground/20 text-[11px] text-muted-foreground whitespace-pre-wrap">
+                      {{ msg.reasoning }}
+                    </div>
+                  </div>
+                </div>
+                <div v-if="msg.agentSteps?.length" class="mb-2 space-y-1">
+                  <div v-for="step in msg.agentSteps" :key="step.key" class="rounded border text-[10px]" :class="agentStepClass(step.tone)">
+                    <button class="flex w-full items-center gap-1 px-2 py-1.5 text-left" @click="step.toolResult || step.toolArgs?.sql ? toggleStep(step.key) : undefined">
+                      <component :is="agentStepIcon(step.tone)" class="h-3 w-3 shrink-0" />
+                      <span class="font-medium">{{ t(step.labelKey) }}</span>
+                      <span v-if="step.toolName" class="text-muted-foreground">: {{ step.toolName }}</span>
+                      <ChevronRight v-if="step.toolResult || step.toolArgs?.sql" class="ml-auto h-3 w-3 shrink-0 transition-transform duration-150" :class="{ 'rotate-90': expandedSteps.has(step.key) }" />
+                    </button>
+                    <div v-if="expandedSteps.has(step.key)" class="border-t border-current/10 px-2 pb-2 pt-1">
+                      <div v-if="step.toolArgs?.sql" class="mb-1 rounded bg-background/50 px-2 py-1 font-mono text-[10px] text-foreground/80 whitespace-pre-wrap">{{ step.toolArgs.sql }}</div>
+                      <Button v-if="step.toolName === 'explain_query' && step.toolArgs?.sql" size="sm" variant="outline" class="mb-1 h-6 gap-1 text-[10px]" @click="emit('openExplainPlan', step.toolArgs.sql as string)">
+                        <GitBranch class="h-3 w-3" />
+                        {{ t("explain.title") }}
+                      </Button>
+                      <div v-if="step.toolName === 'explain_query' && step.explainData && connection?.db_type" class="mb-1">
+                        <ExplainPlanViewer :plan="parseExplainFromData(step.explainData, connection.db_type)" class="max-h-64" />
+                      </div>
+                      <div v-else-if="step.isError && step.toolResult" class="text-[10px] text-red-600 dark:text-red-400">{{ step.toolResult }}</div>
+                      <div v-else-if="step.toolResult" class="max-h-48 overflow-auto text-[10px] text-muted-foreground whitespace-pre-wrap">{{ step.toolResult }}</div>
+                    </div>
+                  </div>
+                </div>
+                <div v-if="isGenerating && msg === messages[messages.length - 1]" class="whitespace-pre-wrap break-words text-sm leading-relaxed">{{ msg.content }}</div>
+                <template v-else v-for="(seg, j) in messageRenderer.render(msg.content)" :key="j">
+                  <div v-if="seg.type === 'text'" class="ai-markdown whitespace-normal" @click.capture="onMarkdownClick">
+                    <div v-html="seg.html" />
+                  </div>
+                  <div v-else class="my-2 overflow-hidden rounded-md border border-zinc-200 bg-zinc-50 dark:border-zinc-700/50 dark:bg-zinc-900">
+                    <div class="flex items-center border-b border-zinc-200 px-3 py-1.5 text-[10px] font-medium text-zinc-600 dark:border-zinc-700/50 dark:text-zinc-400">
+                      <component :is="seg.isSql ? Database : Terminal" class="h-3 w-3 mr-1.5" />
+                      <span>{{ seg.lang }}</span>
+                      <span class="flex-1" />
+                      <div class="flex items-center gap-1.5">
+                        <button v-if="seg.isSql" class="rounded p-0.5 text-zinc-500 hover:bg-zinc-200 hover:text-zinc-900 dark:text-zinc-400 dark:hover:bg-zinc-700 dark:hover:text-zinc-200" :title="t('ai.tempRunSql')" @click="tempRunSql(seg.content)">
+                          <FlaskConical class="h-3.5 w-3.5" />
+                        </button>
+                        <button v-if="seg.isSql" class="rounded p-0.5 text-zinc-500 hover:bg-zinc-200 hover:text-zinc-900 dark:text-zinc-400 dark:hover:bg-zinc-700 dark:hover:text-zinc-200" :title="t('ai.executeSql')" @click="executeSql(seg.content)">
+                          <Play class="h-3.5 w-3.5" />
+                        </button>
+                        <button v-if="seg.isSql" class="rounded p-0.5 text-zinc-500 hover:bg-zinc-200 hover:text-zinc-900 dark:text-zinc-400 dark:hover:bg-zinc-700 dark:hover:text-zinc-200" :title="t('ai.apply')" @click="applySql(seg.content)">
+                          <Replace class="h-3.5 w-3.5" />
+                        </button>
+                        <button
+                          class="rounded p-0.5 text-zinc-500 hover:bg-zinc-200 hover:text-zinc-900 dark:text-zinc-400 dark:hover:bg-zinc-700 dark:hover:text-zinc-200"
+                          :title="copiedIndex === `${i}-${j}` ? t('ai.copied') : t(seg.isSql ? 'ai.copySql' : 'ai.copyCode')"
+                          @click="copyCode(seg.content, `${i}-${j}`)"
+                        >
+                          <Check v-if="copiedIndex === `${i}-${j}`" class="h-3.5 w-3.5 text-green-400" />
+                          <Copy v-else class="h-3.5 w-3.5" />
+                        </button>
+                      </div>
+                    </div>
+                    <pre class="ai-code-block whitespace-pre-wrap break-words p-3 text-xs leading-relaxed text-zinc-900 dark:text-zinc-100"><code v-html="seg.html"></code></pre>
+                  </div>
+                </template>
+                <div v-if="msg === proposalConfirmMessage" class="mt-2 flex gap-2" :title="t('ai.proposalConfirmTitle')">
+                  <Button size="sm" variant="default" class="h-7 gap-1 text-[11px]" @click="sendProposalReply(true)">
+                    <Check class="h-3 w-3" />
+                    {{ t("ai.proposalConfirmYes") }}
+                  </Button>
+                  <Button size="sm" variant="outline" class="h-7 gap-1 text-[11px]" @click="sendProposalReply(false)">
+                    <X class="h-3 w-3" />
+                    {{ t("ai.proposalConfirmNo") }}
+                  </Button>
+                </div>
+              </div>
+            </div>
+          </template>
+
+          <div v-if="isWaitingForFirstDelta" class="flex items-center gap-2 text-xs text-muted-foreground">
+            <Loader2 class="h-3.5 w-3.5 animate-spin" />
+            <span>{{ t("ai.thinking") }}</span>
+          </div>
+          <div v-if="agentTokens && !isGenerating" class="flex items-center gap-1 text-[10px] text-muted-foreground px-2 pb-1">
+            <span>&#8593;{{ agentTokens.input.toLocaleString() }} &#8595;{{ agentTokens.output.toLocaleString() }} tokens</span>
+          </div>
+        </div>
+      </ScrollArea>
+      <button
+        v-if="showScrollToBottom"
+        type="button"
+        class="absolute bottom-3 right-3 z-10 inline-flex h-8 w-8 items-center justify-center rounded-full border bg-background/95 text-foreground shadow-md backdrop-blur hover:bg-muted"
+        :title="t('ai.scrollToBottom')"
+        @click="scrollToBottom({ force: true })"
+      >
+        <ArrowDown class="h-4 w-4" />
+        <span class="sr-only">{{ t("ai.scrollToBottom") }}</span>
+      </button>
+    </div>
+
+    <div class="p-2">
+      <div ref="promptPanelRef" class="relative rounded-[6px] border bg-background">
+        <div class="resize-handle" @mousedown="startResize"></div>
+        <div class="px-2 pb-2 pt-1">
+          <div v-if="connectionStore.connections.length" class="flex items-center gap-1 mb-1 text-xs text-foreground/80">
+            <DatabaseIcon v-if="connection" :db-type="connectionIconType(connection)" class="h-3 w-3 shrink-0" />
+            <Server v-else class="h-3 w-3 shrink-0" />
+            <Select
+              :model-value="connection?.id || ''"
+              @update:model-value="
+                (v) => {
+                  if (typeof v === 'string') changeConnection(v);
+                }
+              "
+            >
+              <SelectTrigger class="h-5 w-auto border-0 rounded-md bg-transparent dark:bg-transparent p-0 px-1 text-xs text-foreground/80 shadow-none focus:ring-0 focus-visible:ring-0 [&_svg]:size-3">
+                <SelectValue :placeholder="t('editor.selectConnection')">{{ connection?.name || t("editor.selectConnection") }}</SelectValue>
+              </SelectTrigger>
+              <SelectContent class="min-w-48">
+                <SelectItem v-for="conn in connectionStore.connections" :key="conn.id" :value="conn.id">
+                  <div class="flex min-w-0 items-center gap-2">
+                    <DatabaseIcon :db-type="connectionIconType(conn)" class="h-3.5 w-3.5 shrink-0" />
+                    <span class="truncate">{{ conn.name }}</span>
+                  </div>
+                </SelectItem>
+              </SelectContent>
+            </Select>
+            <template v-if="connection">
+              <Database class="h-3 w-3 shrink-0 text-foreground/40" />
+              <Select
+                :model-value="selectedDatabaseSelectValue"
+                @update:model-value="
+                  (v) => {
+                    if (typeof v === 'string') changeDatabase(v);
+                  }
+                "
+                @update:open="
+                  (open: boolean) => {
+                    if (open) loadDatabases();
+                  }
+                "
+              >
+                <SelectTrigger class="h-5 w-auto border-0 rounded-md bg-transparent dark:bg-transparent p-0 px-1 text-xs text-foreground/80 shadow-none focus:ring-0 focus-visible:ring-0 [&_svg]:size-3">
+                  <SelectValue :placeholder="t('editor.selectDatabase')">{{ selectedDatabaseLabel }}</SelectValue>
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem v-for="option in dbSelectOptions" :key="option.value" :value="option.value">{{ option.label }}</SelectItem>
+                  <SelectItem v-if="!dbSelectOptions.length && connection && tab" :value="selectedDatabaseSelectValue">{{ selectedDatabaseLabel }}</SelectItem>
+                </SelectContent>
+              </Select>
+            </template>
+          </div>
+          <div v-if="mentionOpen" class="absolute bottom-full left-2 right-2 z-20 mb-1 max-h-56 overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md">
+            <div v-if="mentionLoading" class="flex items-center gap-2 px-2 py-2 text-xs text-muted-foreground">
+              <Loader2 class="h-3.5 w-3.5 animate-spin" />
+              <span>{{ t("common.loading") }}</span>
+            </div>
+            <div v-else-if="mentionError" class="px-2 py-2 text-xs text-destructive">
+              {{ mentionError }}
+            </div>
+            <div v-else-if="!mentionCandidates.length" class="px-2 py-2 text-xs text-muted-foreground">
+              {{ t("ai.tableMentionEmpty") }}
+            </div>
+            <div v-else ref="mentionListRef" class="max-h-56 overflow-auto p-1">
+              <button
+                v-for="(candidate, index) in mentionCandidates"
+                :key="candidate.kind === 'sqlFile' ? `sql-file:${candidate.id}` : `table:${candidate.schema || ''}.${candidate.name}`"
+                type="button"
+                :data-mention-index="index"
+                class="flex w-full min-w-0 items-center gap-2 rounded px-2 py-1.5 text-left text-xs hover:bg-muted"
+                :class="{ 'bg-muted': index === mentionSelectedIndex }"
+                @mousedown.prevent="insertMention(candidate)"
+                @mouseenter="setMentionSelectedIndex(index, false)"
+              >
+                <FileCode v-if="candidate.kind === 'sqlFile'" class="h-3.5 w-3.5 shrink-0 text-primary" />
+                <Table2 v-else class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                <span class="min-w-0 flex-1 truncate">
+                  {{ mentionCandidateName(candidate) }}
+                </span>
+                <span class="max-w-[45%] shrink-0 truncate text-[10px] text-muted-foreground">{{ formatMentionCandidateType(candidate) }}</span>
+              </button>
+            </div>
+          </div>
+          <div v-if="commandOpen && filteredCommands.length" class="absolute bottom-full left-2 right-2 z-20 mb-1 max-h-56 overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md">
+            <div class="max-h-56 overflow-auto p-1">
+              <button
+                v-for="(cmd, index) in filteredCommands"
+                :key="cmd.action"
+                type="button"
+                class="flex w-full items-center gap-2 rounded px-2 py-1.5 text-left text-xs hover:bg-muted"
+                :class="{ 'bg-muted': index === commandSelectedIndex }"
+                @mousedown.prevent="selectCommand(cmd)"
+                @mouseenter="commandSelectedIndex = index"
+              >
+                <component :is="cmd.icon" class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                <span class="font-medium">/{{ cmd.action }}</span>
+                <span class="ml-auto text-[11px] text-muted-foreground">{{ t(cmd.key) }}</span>
+              </button>
+            </div>
+          </div>
+          <div v-if="promptMentionChips.length" class="mb-1.5 flex flex-wrap gap-1">
+            <button
+              v-for="mention in promptMentionChips"
+              :key="mention.raw"
+              type="button"
+              class="group inline-flex max-w-full items-center gap-1 rounded border border-border/80 bg-muted/60 px-1.5 py-0.5 text-[11px] text-foreground/90 hover:bg-muted"
+              :title="mentionDisplayName(mention)"
+              @click="removeMentionChip(mention)"
+            >
+              <FileCode v-if="mention.kind === 'sqlFile'" class="h-3 w-3 shrink-0 text-primary" />
+              <Table2 v-else class="h-3 w-3 shrink-0 text-primary" />
+              <span class="truncate">{{ mentionDisplayName(mention) }}</span>
+              <X class="h-3 w-3 shrink-0 text-muted-foreground group-hover:text-foreground" />
+            </button>
+          </div>
+          <textarea
+            ref="promptTextareaRef"
+            v-model="prompt"
+            :style="{ height: `${textareaHeight}px`, maxHeight: `${maxTextareaHeight()}px` }"
+            class="w-full resize-none bg-transparent text-xs outline-none placeholder:text-muted-foreground mb-1"
+            :placeholder="activePlaceholder"
+            @input="refreshMentionState"
+            @click="refreshMentionState"
+            @keyup="onPromptKeyup"
+            @compositionstart="promptCompositionActive = true"
+            @compositionend="promptCompositionActive = false"
+            @keydown="onPromptKeydown"
+          />
+          <div class="flex min-w-0 flex-nowrap items-center gap-1.5 overflow-hidden">
+            <LightDropdown
+              v-model="assistantMode"
+              :items="assistantModeItems"
+              :aria-label="activeModeHint"
+              trigger-class="flex shrink-0 items-center gap-1 whitespace-nowrap rounded-[6px] border px-2 py-0.5 text-[11px] text-muted-foreground hover:bg-muted hover:text-foreground"
+              item-class="text-xs px-2"
+            />
+            <LightDropdown
+              v-if="showActionButtons"
+              :model-value="activeAction"
+              :items="actionMenuItems"
+              content-class="w-max min-w-0"
+              trigger-class="flex shrink-0 items-center gap-1 whitespace-nowrap rounded-[6px] border px-2 py-0.5 text-[11px] text-muted-foreground hover:bg-muted hover:text-foreground"
+              item-class="text-xs px-2"
+              @update:model-value="(value) => selectAction(value as AiAction)"
+            />
+            <span class="min-w-0 flex-1" />
+            <template v-if="settings.isConfigured()">
+              <!-- Combined provider + model selector -->
+              <Popover v-model:open="providerSelectorOpen">
+                <PopoverTrigger as-child>
+                  <button type="button" class="min-w-0 flex shrink items-center gap-1.5 max-w-[220px] rounded-[6px] border px-2 py-0.5 text-[11px] text-muted-foreground hover:bg-muted hover:text-foreground">
+                    <AiProviderLogo :provider="settings.aiConfig.provider" :label="AI_PROVIDER_PRESETS[settings.aiConfig.provider]?.label ?? settings.aiConfig.provider" :icon-slug="AI_PROVIDER_PRESETS[settings.aiConfig.provider]?.iconSlug" class="h-3 w-3 shrink-0" />
+                    <span class="min-w-0 truncate">{{ modelLoading ? t("ai.loadingModels") : settings.aiConfig.model }}</span>
+                    <svg class="h-3 w-3 shrink-0 opacity-60" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="m6 9 6 6 6-6" /></svg>
+                  </button>
+                </PopoverTrigger>
+                <PopoverContent align="end" class="w-72 gap-0 p-1.5" @open-auto-focus.prevent>
+                  <!-- Configured providers section -->
+                  <template v-if="configuredProviders.length">
+                    <p class="px-2 py-1 text-[10px] font-medium uppercase tracking-wide text-muted-foreground">{{ t("ai.switchProvider") }}</p>
+                    <button v-for="p in configuredProviders" :key="p" type="button" class="flex w-full items-center gap-2 rounded-sm px-2 py-1.5 text-left text-xs hover:bg-accent hover:text-accent-foreground" @click="handleProviderSwitch(p)">
+                      <AiProviderLogo :provider="p" :label="AI_PROVIDER_PRESETS[p]?.label ?? p" :icon-slug="AI_PROVIDER_PRESETS[p]?.iconSlug" class="h-3.5 w-3.5 shrink-0" />
+                      <span class="font-medium">{{ AI_PROVIDER_PRESETS[p]?.label ?? p }}</span>
+                      <span class="ml-auto min-w-0 truncate text-[11px] text-muted-foreground">{{ settings.aiProviderConfigs[p]?.model }}</span>
+                    </button>
+                    <div class="my-1 border-t" />
+                  </template>
+                  <!-- Model list for current provider -->
+                  <p class="px-2 py-1 text-[10px] font-medium uppercase tracking-wide text-muted-foreground">
+                    {{ AI_PROVIDER_PRESETS[settings.aiConfig.provider]?.label ?? settings.aiConfig.provider }}
+                  </p>
+                  <SearchableSelect
+                    :model-value="settings.aiConfig.model"
+                    :options="modelOptionIds"
+                    :placeholder="t('ai.browseModels')"
+                    :search-placeholder="t('ai.searchModels')"
+                    :empty-text="t('ai.modelListHint')"
+                    :loading-text="t('ai.loadingModels')"
+                    :loading="modelLoading"
+                    :display-name="displayModelName"
+                    trigger-class="w-full max-w-full justify-start rounded-sm px-2 py-1.5 text-xs text-foreground hover:bg-accent"
+                    content-class="w-72"
+                    item-class="h-auto min-h-8 px-2 py-1.5 text-xs"
+                    @update:model-value="handleModelSelect"
+                    @update:open="(open: boolean) => open && fetchModelOptions()"
+                  >
+                    <template #trigger-label="{ label, loading }">
+                      <AiProviderLogo :provider="settings.aiConfig.provider" :label="AI_PROVIDER_PRESETS[settings.aiConfig.provider]?.label ?? settings.aiConfig.provider" :icon-slug="AI_PROVIDER_PRESETS[settings.aiConfig.provider]?.iconSlug" class="h-3.5 w-3.5 shrink-0" />
+                      <span class="min-w-0 truncate">{{ loading ? t("ai.loadingModels") : label }}</span>
+                    </template>
+                    <template #option-label="{ option, label }">
+                      <span class="flex min-w-0 flex-col leading-tight">
+                        <span class="truncate">{{ modelOptionPresentation(option, label).primary }}</span>
+                        <span v-if="modelOptionSecondary(option, label)" class="mt-0.5 truncate text-[11px] text-muted-foreground">{{ modelOptionSecondary(option, label) }}</span>
+                      </span>
+                    </template>
+                  </SearchableSelect>
+                </PopoverContent>
+              </Popover>
+            </template>
+            <button v-if="isGenerating" class="h-7 w-7 shrink-0 rounded-full bg-destructive text-destructive-foreground flex items-center justify-center" :title="t('ai.stopGenerating')" @click="cancelStream">
+              <Square class="h-3.5 w-3.5" />
+            </button>
+            <button v-else class="h-7 w-7 shrink-0 rounded-full bg-foreground text-background flex items-center justify-center disabled:opacity-30" :disabled="(!prompt.trim() && !selectedMentions.length && !selectedSqlFileMentions.length) || !props.tab?.database" @click="send">
+              <ArrowUp class="h-4 w-4" />
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.ai-markdown :deep(h1) {
+  font-size: 1em;
+  font-weight: 700;
+  margin: 0.5em 0 0.25em;
+}
+.ai-markdown :deep(h2) {
+  font-size: 0.95em;
+  font-weight: 600;
+  margin: 0.5em 0 0.25em;
+}
+.ai-markdown :deep(h3) {
+  font-size: 0.9em;
+  font-weight: 600;
+  margin: 0.4em 0 0.2em;
+}
+.ai-markdown :deep(p) {
+  margin: 0.3em 0;
+}
+.ai-markdown :deep(ul),
+.ai-markdown :deep(ol) {
+  padding-left: 1.4em;
+  margin: 0.3em 0;
+}
+.ai-markdown :deep(ul) {
+  list-style-type: disc;
+}
+.ai-markdown :deep(ol) {
+  list-style-type: decimal;
+}
+.ai-markdown :deep(li) {
+  margin: 0.15em 0;
+}
+.ai-markdown :deep(strong) {
+  font-weight: 600;
+}
+.ai-markdown :deep(a) {
+  color: hsl(var(--primary));
+  text-decoration: underline;
+}
+.ai-markdown :deep(blockquote) {
+  border-left: 2px solid hsl(var(--muted-foreground) / 0.3);
+  padding-left: 0.75em;
+  margin: 0.3em 0;
+  color: hsl(var(--muted-foreground));
+}
+.ai-markdown :deep(code) {
+  border-radius: 0.25rem;
+  background: hsl(var(--muted));
+  padding: 0.125rem 0.375rem;
+  font-size: 11px;
+  font-family: ui-monospace, monospace;
+}
+.ai-markdown :deep(pre) {
+  background: hsl(var(--muted));
+  border-radius: 0.375rem;
+  padding: 0.5em 0.75em;
+  margin: 0.3em 0;
+  overflow-x: auto;
+}
+.ai-markdown :deep(pre code) {
+  background: none;
+  padding: 0;
+}
+.ai-markdown :deep(table) {
+  border-collapse: collapse;
+  margin: 0;
+  width: max-content;
+  min-width: 100%;
+}
+.ai-markdown :deep(.ai-markdown-table-wrap) {
+  overflow-x: auto;
+  max-height: 320px;
+  overflow-y: auto;
+  max-width: 100%;
+  margin: 0.3em 0;
+  border-radius: 0.375rem;
+  border: 1px solid hsl(var(--border));
+}
+.ai-markdown :deep(.ai-markdown-table-wrap table) {
+  border: none;
+  margin: 0;
+}
+.ai-markdown :deep(th),
+.ai-markdown :deep(td) {
+  border: 1px solid hsl(var(--border));
+  padding: 0.25em 0.5em;
+  text-align: left;
+  white-space: nowrap;
+}
+.ai-markdown :deep(th) {
+  font-weight: 600;
+  background: hsl(var(--muted));
+  position: sticky;
+  top: 0;
+  z-index: 1;
+}
+.ai-code-block :deep(.line) {
+  min-height: 1lh;
+}
+
+.ai-message-scroll :deep([data-slot="scroll-area-viewport"]) {
+  overflow-anchor: none;
+}
+
+.resize-handle {
+  height: 4px;
+  width: 100%;
+  cursor: ns-resize;
+  background-color: hsl(var(--border));
+  transition: background-color 0.15s ease;
+}
+
+.resize-handle:hover {
+  background-color: hsl(var(--foreground) / 0.2);
+}
+</style>
diff --git a/apps/desktop/src/components/editor/ColumnInfoPanel.vue b/apps/desktop/src/components/editor/ColumnInfoPanel.vue
new file mode 100644
index 0000000..1c271ef
--- /dev/null
+++ b/apps/desktop/src/components/editor/ColumnInfoPanel.vue
@@ -0,0 +1,115 @@
+<script setup lang="ts">
+import { X, Copy } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { useToast } from "@/composables/useToast";
+import { copyToClipboard } from "@/lib/common/clipboard";
+
+export interface ColumnInfo {
+  name: string;
+  table: string;
+  dataType?: string;
+  isNullable?: boolean;
+  columnDefault?: string | null;
+  isPrimaryKey?: boolean;
+  comment?: string | null;
+  extra?: string | null;
+}
+
+defineProps<{
+  columns: ColumnInfo[];
+  loading: boolean;
+  error?: string;
+}>();
+
+const emit = defineEmits<{
+  close: [];
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+
+async function copyText(text: string) {
+  try {
+    await copyToClipboard(text);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+</script>
+
+<template>
+  <div class="absolute top-0 right-0 bottom-0 z-10 w-72 bg-card border-l border-border shadow-lg flex flex-col">
+    <!-- Header -->
+    <div class="flex items-center justify-between px-3 py-2 border-b border-border">
+      <span class="text-sm font-medium">{{ t("grid.columnDetails") }}</span>
+      <Button variant="ghost" size="sm" class="h-6 w-6 p-0" @click="emit('close')">
+        <X class="h-3.5 w-3.5" />
+      </Button>
+    </div>
+
+    <!-- Content -->
+    <div class="flex-1 overflow-y-auto p-3 space-y-3">
+      <template v-if="loading">
+        <div class="text-xs text-muted-foreground animate-pulse">{{ t("common.loading") }}</div>
+      </template>
+
+      <template v-else-if="error">
+        <div class="text-xs text-destructive">{{ error }}</div>
+      </template>
+
+      <template v-else>
+        <!-- Column detail sections -->
+        <div v-for="(col, idx) in columns" :key="idx" class="space-y-2">
+          <!-- Column header -->
+          <div class="flex items-center justify-between">
+            <div class="flex items-center gap-1.5">
+              <span class="font-semibold text-sm text-foreground">{{ col.name }}</span>
+              <Badge v-if="col.isPrimaryKey" variant="outline" class="h-4 px-1 text-[10px] border-primary/40 text-primary"> PK </Badge>
+            </div>
+            <Button variant="ghost" size="sm" class="h-5 w-5 p-0" @click="copyText(col.name)">
+              <Copy class="h-3 w-3" />
+            </Button>
+          </div>
+
+          <!-- Table origin -->
+          <div class="text-xs text-muted-foreground">{{ t("tabs.tooltipTable") }} {{ col.table }}</div>
+
+          <!-- Detail rows -->
+          <div class="rounded-md border border-border divide-y divide-border text-xs">
+            <div class="flex items-center justify-between px-2 py-1">
+              <span class="text-muted-foreground">{{ t("grid.columnType") }}</span>
+              <span class="font-medium max-w-[180px] truncate" :title="col.dataType">
+                {{ col.dataType || "—" }}
+              </span>
+            </div>
+            <div class="flex items-center justify-between px-2 py-1">
+              <span class="text-muted-foreground">{{ t("structureEditor.nullable") }}</span>
+              <span class="font-medium">{{ col.isNullable ? t("structureEditor.yes") : t("structureEditor.no") }}</span>
+            </div>
+            <div v-if="col.columnDefault" class="flex items-start justify-between px-2 py-1 gap-2">
+              <span class="text-muted-foreground shrink-0">{{ t("structureEditor.defaultValue") }}</span>
+              <span class="font-medium text-right max-w-[180px] truncate" :title="col.columnDefault">
+                {{ col.columnDefault }}
+              </span>
+            </div>
+            <div v-if="col.comment" class="flex items-start justify-between px-2 py-1 gap-2">
+              <span class="text-muted-foreground shrink-0">{{ t("structureEditor.comment") }}</span>
+              <span class="font-medium text-right max-w-[180px] truncate" :title="col.comment">
+                {{ col.comment }}
+              </span>
+            </div>
+            <div v-if="col.extra" class="flex items-start justify-between px-2 py-1 gap-2">
+              <span class="text-muted-foreground shrink-0">Extra</span>
+              <span class="font-medium text-right max-w-[180px] truncate" :title="col.extra">
+                {{ col.extra }}
+              </span>
+            </div>
+          </div>
+        </div>
+      </template>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/editor/DangerConfirmDialog.vue b/apps/desktop/src/components/editor/DangerConfirmDialog.vue
new file mode 100644
index 0000000..4b18a89
--- /dev/null
+++ b/apps/desktop/src/components/editor/DangerConfirmDialog.vue
@@ -0,0 +1,101 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { AlertTriangle, Loader2, TextWrap } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
+import { Label } from "@/components/ui/label";
+import { Switch } from "@/components/ui/switch";
+import { useSqlHighlighter } from "@/composables/useSqlHighlighter";
+
+const { t } = useI18n();
+const { highlight } = useSqlHighlighter();
+
+const open = defineModel<boolean>("open", { default: false });
+const suppressFuturePrompts = defineModel<boolean>("suppressFuturePrompts", { default: false });
+const wrap = ref(false);
+
+const props = withDefaults(
+  defineProps<{
+    sql?: string;
+    title?: string;
+    message?: string;
+    details?: string;
+    detailsText?: string;
+    confirmLabel?: string;
+    showSuppressToggle?: boolean;
+    suppressToggleLabel?: string;
+    loading?: boolean;
+    closeOnConfirm?: boolean;
+  }>(),
+  {
+    sql: "",
+    title: "",
+    message: "",
+    details: "",
+    detailsText: "",
+    confirmLabel: "",
+    showSuppressToggle: false,
+    suppressToggleLabel: "",
+    loading: false,
+    closeOnConfirm: true,
+  },
+);
+
+const emit = defineEmits<{
+  confirm: [];
+}>();
+
+const code = computed(() => props.details || props.sql);
+const highlightedCode = computed(() => highlight(code.value));
+const dialogOpen = computed({
+  get: () => open.value,
+  set: (value) => {
+    if (props.loading && !value) return;
+    open.value = value;
+  },
+});
+
+function onConfirm() {
+  if (props.loading) return;
+  if (props.closeOnConfirm) open.value = false;
+  emit("confirm");
+}
+</script>
+
+<template>
+  <Dialog v-model:open="dialogOpen">
+    <DialogContent class="sm:max-w-[480px]">
+      <DialogHeader>
+        <DialogTitle class="flex items-center gap-2 text-destructive">
+          <AlertTriangle class="h-5 w-5" />
+          {{ title || t("dangerDialog.title") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="py-4 min-w-0">
+        <p class="text-sm text-muted-foreground mb-3">{{ message || t("dangerDialog.message") }}</p>
+        <p v-if="detailsText" class="text-xs text-muted-foreground mb-3 whitespace-pre-line">{{ detailsText }}</p>
+        <slot name="options" />
+        <div v-if="code" class="relative">
+          <Button variant="ghost" size="icon-xs" class="absolute top-1 right-1 z-10 h-6 w-6" :class="wrap ? 'text-foreground bg-accent' : 'text-muted-foreground'" :title="t('dangerDialog.wrapLines')" @click="wrap = !wrap">
+            <TextWrap class="h-3.5 w-3.5" />
+          </Button>
+          <pre class="text-xs bg-muted px-3 pt-3 pb-3 pr-7 rounded overflow-auto max-h-40 min-w-0 font-mono" :class="wrap ? 'whitespace-pre-wrap' : 'whitespace-pre'" v-html="highlightedCode" />
+        </div>
+        <div v-if="showSuppressToggle" class="mt-3 flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+          <Label for="danger-confirm-suppress" class="text-sm leading-5">{{ suppressToggleLabel || t("dangerDialog.suppressFuturePrompts") }}</Label>
+          <Switch id="danger-confirm-suppress" v-model="suppressFuturePrompts" />
+        </div>
+      </div>
+
+      <DialogFooter>
+        <Button variant="outline" :disabled="loading" @click="open = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button variant="destructive" class="gap-1.5" :disabled="loading" @click="onConfirm">
+          <Loader2 v-if="loading" class="h-3.5 w-3.5 animate-spin" />
+          {{ confirmLabel || t("dangerDialog.confirm") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/editor/EditorSearchPanel.vue b/apps/desktop/src/components/editor/EditorSearchPanel.vue
new file mode 100644
index 0000000..23b2371
--- /dev/null
+++ b/apps/desktop/src/components/editor/EditorSearchPanel.vue
@@ -0,0 +1,459 @@
+<script setup lang="ts">
+import { ref, nextTick, onBeforeUnmount, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import type { EditorView } from "@codemirror/view";
+import { EditorSelection } from "@codemirror/state";
+import { setSearchQuery, openSearchPanel as cmOpenSearchPanel, findNext as cmFindNext, findPrevious as cmFindPrevious, replaceNext as cmReplaceNext, replaceAll as cmReplaceAll } from "@codemirror/search";
+import { ChevronUp, ChevronDown, ChevronRight, X } from "@lucide/vue";
+import { createEditorSearchQuery } from "@/lib/editor/editorSearchQuery";
+
+const props = defineProps<{
+  view: EditorView | null;
+  tone?: "app" | "editor";
+}>();
+
+const { t } = useI18n();
+
+const searchVisible = ref(false);
+const searchText = ref("");
+const replaceText = ref("");
+const showReplace = ref(false);
+const caseSensitive = ref(false);
+const useRegex = ref(false);
+const matchCount = ref(0);
+const currentMatchIndex = ref(0);
+const searchInputRef = ref<HTMLInputElement>();
+const replaceInputRef = ref<HTMLInputElement>();
+const matchCountLimited = ref(false);
+
+const SEARCH_UPDATE_DELAY_MS = 120;
+const DOCUMENT_SEARCH_UPDATE_DELAY_MS = 500;
+const MATCH_COUNT_LIMIT = 1000;
+
+let searchUpdateTimer: ReturnType<typeof setTimeout> | null = null;
+let documentSearchUpdateTimer: ReturnType<typeof setTimeout> | null = null;
+
+function clearDocumentSearchUpdate() {
+  if (!documentSearchUpdateTimer) return;
+  clearTimeout(documentSearchUpdateTimer);
+  documentSearchUpdateTimer = null;
+}
+
+function dispatchSearchQuery() {
+  const v = props.view;
+  if (!v) return;
+  const q = createEditorSearchQuery({
+    search: searchText.value,
+    caseSensitive: caseSensitive.value,
+    useRegex: useRegex.value,
+    replace: replaceText.value,
+  });
+  v.dispatch({ effects: setSearchQuery.of(q) });
+}
+
+function clearSearchQuery() {
+  const v = props.view;
+  if (!v) return;
+  const selection = v.state.selection.main;
+  v.dispatch({
+    selection: EditorSelection.single(selection.head),
+    effects: setSearchQuery.of(createEditorSearchQuery({ search: "", caseSensitive: false, useRegex: false })),
+  });
+  matchCount.value = 0;
+  currentMatchIndex.value = 0;
+  matchCountLimited.value = false;
+}
+
+function updateMatchInfo(autoSelect = false) {
+  const v = props.view;
+  if (!v || !searchText.value) {
+    matchCount.value = 0;
+    currentMatchIndex.value = 0;
+    matchCountLimited.value = false;
+    return;
+  }
+  try {
+    const q = createEditorSearchQuery({
+      search: searchText.value,
+      caseSensitive: caseSensitive.value,
+      useRegex: useRegex.value,
+    });
+    if (!q.valid) {
+      matchCount.value = 0;
+      currentMatchIndex.value = 0;
+      matchCountLimited.value = false;
+      return;
+    }
+    if (autoSelect) {
+      cmFindNext(v);
+    }
+    const iter = q.getCursor(v.state);
+    let count = 0;
+    let curIdx = 0;
+    const selFrom = v.state.selection.main.from;
+    const selTo = v.state.selection.main.to;
+    let r = iter.next();
+    while (!r.done) {
+      count++;
+      if (r.value.from === selFrom && r.value.to === selTo) curIdx = count;
+      if (count >= MATCH_COUNT_LIMIT) break;
+      r = iter.next();
+    }
+    matchCount.value = count;
+    matchCountLimited.value = count >= MATCH_COUNT_LIMIT && !r.done;
+    currentMatchIndex.value = curIdx || (count > 0 ? 1 : 0);
+  } catch {
+    matchCount.value = 0;
+    currentMatchIndex.value = 0;
+    matchCountLimited.value = false;
+  }
+}
+
+function scheduleSearchUpdate(autoSelect = false) {
+  clearDocumentSearchUpdate();
+  if (searchUpdateTimer) {
+    clearTimeout(searchUpdateTimer);
+    searchUpdateTimer = null;
+  }
+  if (!searchText.value) {
+    clearSearchQuery();
+    return;
+  }
+  dispatchSearchQuery();
+  searchUpdateTimer = setTimeout(() => {
+    searchUpdateTimer = null;
+    updateMatchInfo(autoSelect);
+  }, SEARCH_UPDATE_DELAY_MS);
+}
+
+function scheduleDocumentSearchUpdate() {
+  if (!searchVisible.value || !searchText.value) return;
+  clearDocumentSearchUpdate();
+  documentSearchUpdateTimer = setTimeout(() => {
+    documentSearchUpdateTimer = null;
+    updateMatchInfo();
+  }, DOCUMENT_SEARCH_UPDATE_DELAY_MS);
+}
+
+function openSearch(): boolean {
+  searchVisible.value = true;
+  const v = props.view;
+  if (v) {
+    cmOpenSearchPanel(v);
+    const sel = v.state.sliceDoc(v.state.selection.main.from, v.state.selection.main.to);
+    if (sel && !sel.includes("\n")) searchText.value = sel;
+  }
+  nextTick(() => {
+    searchInputRef.value?.focus();
+    searchInputRef.value?.select();
+  });
+  if (searchText.value) scheduleSearchUpdate(true);
+  return true;
+}
+
+function openReplace(): boolean {
+  openSearch();
+  showReplace.value = true;
+  nextTick(() => {
+    replaceInputRef.value?.focus();
+    replaceInputRef.value?.select();
+  });
+  return true;
+}
+
+function closeSearch() {
+  const wasVisible = searchVisible.value;
+  searchVisible.value = false;
+  showReplace.value = false;
+  clearDocumentSearchUpdate();
+  const v = props.view;
+  if (v) {
+    clearSearchQuery();
+    v.focus();
+  }
+  return wasVisible;
+}
+
+function nextMatch() {
+  const v = props.view;
+  if (!v || !searchText.value) return;
+  cmFindNext(v);
+  updateMatchInfo();
+}
+
+function prevMatch() {
+  const v = props.view;
+  if (!v || !searchText.value) return;
+  cmFindPrevious(v);
+  updateMatchInfo();
+}
+
+function doReplace() {
+  const v = props.view;
+  if (!v || !searchText.value) return;
+  cmReplaceNext(v);
+  updateMatchInfo();
+}
+
+function doReplaceAll() {
+  const v = props.view;
+  if (!v || !searchText.value) return;
+  cmReplaceAll(v);
+  updateMatchInfo();
+}
+
+function onSearchKeydown(e: KeyboardEvent) {
+  if (e.key === "Escape") {
+    e.preventDefault();
+    closeSearch();
+  } else if (e.key === "Enter" && !e.shiftKey) {
+    e.preventDefault();
+    nextMatch();
+  } else if (e.key === "Enter" && e.shiftKey) {
+    e.preventDefault();
+    prevMatch();
+  }
+}
+
+watch([searchText, caseSensitive, useRegex], () => {
+  if (searchVisible.value) scheduleSearchUpdate(true);
+});
+
+watch(replaceText, () => {
+  if (searchVisible.value) dispatchSearchQuery();
+});
+
+onBeforeUnmount(() => {
+  clearDocumentSearchUpdate();
+  if (searchUpdateTimer) {
+    clearTimeout(searchUpdateTimer);
+    searchUpdateTimer = null;
+  }
+});
+
+defineExpose({ openSearch, openReplace, closeSearch, scheduleDocumentSearchUpdate });
+</script>
+
+<template>
+  <Transition enter-active-class="transition-[transform,opacity] duration-150" leave-active-class="transition-[transform,opacity] duration-100" enter-from-class="opacity-0 -translate-y-1" leave-to-class="opacity-0 -translate-y-1">
+    <div v-if="searchVisible" class="editor-search-panel absolute right-4 top-3 z-[9999] isolate flex flex-col gap-1 rounded-lg border border-border bg-popover p-1.5 text-popover-foreground shadow-xl ring-1 ring-border/60" :class="{ 'editor-search-panel--editor': tone === 'editor' }">
+      <div class="flex items-center gap-1">
+        <button class="flex h-7 w-7 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-accent hover:text-foreground" :title="showReplace ? t('editor.search.collapseReplace') : t('editor.search.expandReplace')" @click="showReplace = !showReplace">
+          <ChevronRight class="h-4 w-4 transition-transform" :class="showReplace && 'rotate-90'" />
+        </button>
+        <div class="flex h-8 w-64 items-center rounded-md border border-input bg-background focus-within:border-ring focus-within:ring-1 focus-within:ring-ring">
+          <input
+            ref="searchInputRef"
+            v-model="searchText"
+            autocapitalize="off"
+            autocorrect="off"
+            spellcheck="false"
+            class="h-full min-w-0 flex-1 bg-transparent px-2 text-sm text-foreground outline-none placeholder:text-muted-foreground"
+            :placeholder="t('editor.search.find')"
+            @keydown="onSearchKeydown"
+          />
+          <button
+            class="flex h-6 min-w-7 items-center justify-center rounded px-1.5 text-xs font-medium transition-colors hover:bg-accent hover:text-foreground"
+            :class="caseSensitive ? 'bg-accent text-foreground' : 'text-muted-foreground'"
+            :title="t('editor.search.caseSensitive')"
+            @click="caseSensitive = !caseSensitive"
+          >
+            Aa
+          </button>
+          <button
+            class="mr-1 flex h-6 min-w-7 items-center justify-center rounded px-1.5 font-mono text-xs transition-colors hover:bg-accent hover:text-foreground"
+            :class="useRegex ? 'bg-accent text-foreground' : 'text-muted-foreground'"
+            :title="t('editor.search.regex')"
+            @click="useRegex = !useRegex"
+          >
+            .*
+          </button>
+        </div>
+        <span class="min-w-[3.4rem] shrink-0 text-center text-xs" :class="searchText && matchCount === 0 ? 'text-destructive' : 'text-muted-foreground'">
+          {{ searchText && matchCount > 0 ? `${currentMatchIndex}/${matchCount}${matchCountLimited ? "+" : ""}` : t("editor.search.noResults") }}
+        </span>
+        <button class="flex h-7 w-7 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-accent hover:text-foreground" :title="t('editor.search.prevMatch')" @click="prevMatch">
+          <ChevronUp class="h-4 w-4" />
+        </button>
+        <button class="flex h-7 w-7 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-accent hover:text-foreground" :title="t('editor.search.nextMatch')" @click="nextMatch">
+          <ChevronDown class="h-4 w-4" />
+        </button>
+        <button class="flex h-7 w-7 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-accent hover:text-foreground" :title="t('editor.search.close')" @click="closeSearch">
+          <X class="h-4 w-4" />
+        </button>
+      </div>
+      <div v-if="showReplace" class="flex items-center gap-1">
+        <div class="h-7 w-7 shrink-0" />
+        <div class="flex h-8 w-64 items-center rounded-md border border-input bg-background focus-within:border-ring focus-within:ring-1 focus-within:ring-ring">
+          <input
+            ref="replaceInputRef"
+            v-model="replaceText"
+            autocapitalize="off"
+            autocorrect="off"
+            spellcheck="false"
+            class="h-full min-w-0 flex-1 bg-transparent px-2 text-sm text-foreground outline-none placeholder:text-muted-foreground"
+            :placeholder="t('editor.search.replace')"
+            @keydown.enter.prevent="doReplace"
+            @keydown.escape.prevent="closeSearch"
+          />
+        </div>
+        <button class="flex h-7 items-center justify-center rounded-md border border-border px-2 text-xs text-muted-foreground transition-colors hover:bg-accent hover:text-foreground" :title="t('editor.search.replace')" @click="doReplace">
+          {{ t("editor.search.replace") }}
+        </button>
+        <button class="flex h-7 items-center justify-center rounded-md border border-border px-2 text-xs text-muted-foreground transition-colors hover:bg-accent hover:text-foreground" :title="t('editor.search.replaceAll')" @click="doReplaceAll">
+          {{ t("editor.search.replaceAll") }}
+        </button>
+      </div>
+    </div>
+  </Transition>
+</template>
+
+<style scoped>
+.editor-search-panel {
+  max-width: min(calc(100vw - 2rem), 620px);
+}
+
+.editor-search-panel--editor {
+  background: #f6f7f9;
+  border-color: #d8dce3;
+  border-radius: 6px;
+  box-shadow:
+    0 8px 22px rgb(15 23 42 / 0.14),
+    0 1px 0 rgb(255 255 255 / 0.78) inset;
+  color: #20242a;
+  gap: 3px;
+  max-width: min(calc(100vw - 2rem), 500px);
+  padding: 4px 6px;
+  right: 0.75rem;
+  top: 0.75rem;
+}
+
+.editor-search-panel--editor :deep(.h-8) {
+  height: 27px;
+}
+
+.editor-search-panel--editor :deep(.h-7) {
+  height: 27px;
+}
+
+.editor-search-panel--editor :deep(.w-7) {
+  width: 27px;
+}
+
+.editor-search-panel--editor :deep(.w-64) {
+  width: 230px;
+}
+
+.editor-search-panel--editor :deep(button) {
+  font-size: 12px;
+}
+
+.editor-search-panel--editor :deep(button.px-2) {
+  padding-left: 7px;
+  padding-right: 7px;
+}
+
+.editor-search-panel--editor :deep(.min-w-\[3\.4rem\]) {
+  min-width: 3.25rem;
+}
+
+.editor-search-panel--editor :deep(.border-input) {
+  background: #ffffff;
+  border-color: #c7ccd5;
+  border-radius: 5px;
+  box-shadow: 0 1px 0 rgb(15 23 42 / 0.03) inset;
+}
+
+.editor-search-panel--editor :deep(.focus-within\:border-ring:focus-within) {
+  border-color: #3b82f6;
+  box-shadow: 0 0 0 1px #3b82f6;
+}
+
+.editor-search-panel--editor :deep(input) {
+  color: #20242a;
+  font-size: 12px;
+}
+
+.editor-search-panel--editor :deep(input::placeholder) {
+  color: #7a828e;
+}
+
+.editor-search-panel--editor :deep(.text-muted-foreground) {
+  color: #6e7681;
+}
+
+.editor-search-panel--editor :deep(.text-destructive) {
+  color: #c2410c;
+}
+
+.editor-search-panel--editor :deep(.hover\:bg-accent:hover),
+.editor-search-panel--editor :deep(.bg-accent) {
+  background: #e6e9ef;
+}
+
+.editor-search-panel--editor :deep(.hover\:text-foreground:hover),
+.editor-search-panel--editor :deep(.text-foreground) {
+  color: #1f2329;
+}
+
+.editor-search-panel--editor :deep(button.border-border) {
+  border-color: #d0d5dd;
+}
+
+:global(.dark) .editor-search-panel--editor {
+  background: #20252d;
+  border-color: #2c333d;
+  box-shadow:
+    0 8px 24px rgb(0 0 0 / 0.28),
+    0 1px 0 rgb(255 255 255 / 0.04) inset;
+  color: #d4d7dc;
+}
+
+:global(.dark) .editor-search-panel--editor :deep(.border-input) {
+  background: #191d25;
+  border-color: #2f3742;
+  box-shadow: none;
+}
+
+:global(.dark) .editor-search-panel--editor :deep(.focus-within\:border-ring:focus-within) {
+  border-color: #4d8dff;
+  box-shadow: 0 0 0 1px #4d8dff;
+}
+
+:global(.dark) .editor-search-panel--editor :deep(input) {
+  color: #d7dae0;
+}
+
+:global(.dark) .editor-search-panel--editor :deep(input::placeholder) {
+  color: #858c97;
+}
+
+:global(.dark) .editor-search-panel--editor :deep(.text-muted-foreground) {
+  color: #9aa2ad;
+}
+
+:global(.dark) .editor-search-panel--editor :deep(.text-destructive) {
+  color: #f59e7a;
+}
+
+:global(.dark) .editor-search-panel--editor :deep(.hover\:bg-accent:hover),
+:global(.dark) .editor-search-panel--editor :deep(.bg-accent) {
+  background: #303844;
+}
+
+:global(.dark) .editor-search-panel--editor :deep(.hover\:text-foreground:hover),
+:global(.dark) .editor-search-panel--editor :deep(.text-foreground) {
+  color: #f2f4f8;
+}
+
+:global(.dark) .editor-search-panel--editor :deep(button.border-border) {
+  border-color: #38414d;
+}
+
+@media (max-width: 720px) {
+  .editor-search-panel {
+    left: 0.75rem;
+    right: 0.75rem;
+  }
+}
+</style>
diff --git a/apps/desktop/src/components/editor/EditorSettingsDialog.vue b/apps/desktop/src/components/editor/EditorSettingsDialog.vue
new file mode 100644
index 0000000..ef0005b
--- /dev/null
+++ b/apps/desktop/src/components/editor/EditorSettingsDialog.vue
@@ -0,0 +1,4883 @@
+<script setup lang="ts">
+import { ref, watch, shallowRef, computed, onMounted, onUnmounted, nextTick } from "vue";
+import type { Ref } from "vue";
+import type { EditorView as EditorViewType } from "@codemirror/view";
+import { useI18n } from "vue-i18n";
+import { AlertTriangle, CheckCircle2, CircleHelp, Cloud, Copy, Download, ExternalLink, GripVertical, Loader2, Moon, PackageSearch, Pencil, Plus, RefreshCw, RotateCcw, Search, Settings, Sun, SunMoon, Terminal, Trash2, Upload, X } from "@lucide/vue";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import PasswordInput from "@/components/ui/PasswordInput.vue";
+import { Label } from "@/components/ui/label";
+import { SearchableSelect } from "@/components/ui/searchable-select";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Separator } from "@/components/ui/separator";
+import { Switch } from "@/components/ui/switch";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { HelpTooltip, Tooltip, TooltipContent, TooltipTrigger, TooltipProvider } from "@/components/ui/tooltip";
+import {
+  useSettingsStore,
+  AI_PROVIDER_PRESETS,
+  EDITOR_THEMES,
+  FONT_FAMILIES,
+  DEFAULT_EDITOR_SETTINGS,
+  DEFAULT_DESKTOP_SETTINGS,
+  DEFAULT_SIDEBAR_TABLE_PAGE_SIZE,
+  DUCKDB_WORKER_MAX_PROCESSES_MAX,
+  DUCKDB_WORKER_MAX_PROCESSES_MIN,
+  normalizeDuckDbWorkerMaxProcesses,
+  normalizeAiEnv,
+  type AiProvider,
+  type AiApiStyle,
+  type AiAuthMethod,
+  type AiReasoningLevel,
+  type EditorTheme,
+  type DesktopIconTheme,
+  type InterfaceLayout,
+  type DisconnectTabHandlingMode,
+  type OpenTabsRestoreMode,
+  type SqlSemanticDiagnosticsMode,
+  type UpdateDownloadSource,
+  type CustomThemeColors,
+  type CustomTheme,
+} from "@/stores/settingsStore";
+import { createRunStatementButtonDom, loadEditorTheme, editorFontTheme } from "@/lib/editor/editorThemes";
+import { formatAiModelOption } from "@/lib/ai/aiModelPresentation";
+import ThemeCustomizerDialog from "./ThemeCustomizerDialog.vue";
+import TunnelProfileManager from "@/components/connection/TunnelProfileManager.vue";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { useTheme } from "@/composables/useTheme";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { clearDebugLogs as clearStoredDebugLogs, downloadDebugLogs, getDebugLogBundleText } from "@/lib/backend/debugLog";
+import {
+  aiListModels,
+  aiTestConnection,
+  checkMcpServerStatus,
+  installMcpServer,
+  forgetSnippetSavedToken,
+  forgetWebdavSyncSecretsPassphrase,
+  forgetWebdavSavedPassword,
+  getAppSupportInfo,
+  listSystemFonts,
+  saveWebdavSyncSecretsPreference,
+  saveWebdavSavedPassword,
+  saveSnippetSavedToken,
+  snippetSyncDownload,
+  snippetSyncTest,
+  snippetSyncUpload,
+  snippetTokenStatus,
+  webdavPasswordStatus,
+  webdavSyncDownload,
+  webdavSyncSecretsStatus,
+  webdavSyncTest,
+  webdavSyncUpload,
+  type AppSupportInfo,
+  type AiModelInfo,
+  type McpServerStatus,
+  type SnippetProvider,
+  type SnippetSyncConfig,
+  type WebDavConfig,
+} from "@/lib/backend/api";
+import { eventToShortcut } from "@/lib/editor/keyboardShortcuts";
+import { SHORTCUT_DEFINITIONS, findShortcutConflict, normalizeShortcutSettings, type ShortcutActionId } from "@/lib/editor/shortcutRegistry";
+import { formatShortcutDisplay } from "@/lib/editor/shortcutDisplay";
+import { normalizeSidebarHiddenTablePrefixes } from "@/lib/sidebar/sidebarTableNameDisplay";
+import { currentStatementFrameRangeTo, visualSqlColumnsWithInlineHints } from "@/lib/sql/currentStatementFrame";
+import { normalizeSqlFormatterSettings, type SqlFormatterSettings } from "@/lib/sql/sqlFormatterConfig";
+import { currentExecutableStatementRange, type SqlTextRange } from "@/lib/sql/sqlStatementRanges";
+import { executableStatementRangeCacheForDoc, executableStatementRangeStartingAt, type ExecutableStatementRangeCache } from "@/lib/sql/executableStatementRangeCache";
+import { EMPTY_TABLE_COLUMN_TEMPLATE_DATA_TYPE, parseTableColumnTemplateFields, TABLE_COLUMN_TEMPLATE_DATABASE_TYPES } from "@/lib/table/tableColumnTemplates";
+import { DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES, normalizeSqlVariableSyntaxOverrides, SQL_VARIABLE_SYNTAX_DATABASE_TYPES, SQL_VARIABLE_SYNTAX_KEYS, SQL_VARIABLE_SYNTAX_TOKENS, type SqlVariableSyntaxOverrides, type SqlVariableSyntaxToggles } from "@/lib/sql/sqlVariableSyntax";
+import { buildMcpCodexConfig, buildMcpJsonConfig, buildMcpOpenCodeConfig, buildMcpVsCodeConfig, type McpEnvEntry, type McpLaunchConfig } from "@/lib/mcp/mcpConfigTemplates";
+import { isMacOS, isWindows } from "@/lib/backend/platform";
+import { combineDataTypeForDatabase, dataTypeLengthInputValue, getDataTypeOptions, getDefaultLengthForType, isDataTypeLengthDisabled, splitDataType } from "@/lib/table/tableStructureEditorState";
+import { useToast } from "@/composables/useToast";
+import type { DatabaseType, SqlSnippet } from "@/types/database";
+import { uuid } from "@/lib/common/utils";
+import { DEFAULT_SQL_SNIPPETS } from "@/lib/sql/sqlCompletion";
+import AiProviderLogo from "@/components/icons/AiProviderLogo.vue";
+import AppLogo from "@/components/icons/AppLogo.vue";
+import SqlFormatterSettingsPanel from "./SqlFormatterSettingsPanel.vue";
+import { APP_THEME_PALETTES, type AppThemeAppearance, type AppThemeMode, type AppThemePalette } from "@/lib/app/appTheme";
+import { editorSettingsDraftChanged, editorSettingsDraftFromSettings, editorSettingsPatchFromDraft, type EditorSettingsDraft } from "@/lib/settings/editorSettingsDraft";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useSavedSqlStore } from "@/stores/savedSqlStore";
+import { currentLocale, setLocale, type Locale } from "@/i18n";
+import { LOCALE_OPTIONS } from "@/lib/app/localeOptions";
+import { DEFAULT_WEB_DAV_AUTO_UPLOAD_INTERVAL_MINUTES, DEFAULT_WEB_DAV_REMOTE_PATH, normalizedWebDavAutoUploadInterval, writeWebDavAutoUploadFields } from "@/lib/webdav/webdavAutoUploadConfig";
+import { apiUrl } from "@/lib/common/webPath";
+import { DEFAULT_UI_FONT_FAMILY, SYSTEM_UI_FONT_FAMILY } from "@/lib/app/appFonts";
+import { buildAppSupportInfoRows, formatAppSupportInfoForClipboard, type AppSupportInfoLabels } from "@/lib/app/supportInfo";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const settingsStore = useSettingsStore();
+const connectionStore = useConnectionStore();
+const savedSqlStore = useSavedSqlStore();
+const { isDark, themeMode, themePalette, setThemeMode, setThemePalette } = useTheme();
+
+const appThemePaletteOptions = computed(
+  (): Array<{ value: AppThemePalette; label: string; previewColor: string }> =>
+    APP_THEME_PALETTES.map((palette) => ({
+      value: palette.value,
+      label: t(palette.labelKey),
+      previewColor: palette.previewColor,
+    })),
+);
+const selectedThemePaletteOption = computed(() => appThemePaletteOptions.value.find((option) => option.value === themePalette.value) ?? appThemePaletteOptions.value[0]);
+const selectedLocaleOption = computed(() => LOCALE_OPTIONS.find((locale) => locale.value === currentLocale()) ?? LOCALE_OPTIONS[0]);
+const appThemeModeOptions = computed(() => [
+  { value: "light" as AppThemeMode, label: t("toolbar.themeLight"), icon: Sun },
+  { value: "dark" as AppThemeMode, label: t("toolbar.themeDark"), icon: Moon },
+  { value: "system" as AppThemeMode, label: t("toolbar.themeSystem"), icon: SunMoon },
+]);
+
+let cachedSystemFonts: string[] | null = null;
+let pendingSystemFonts: Promise<string[]> | null = null;
+
+const props = defineProps<{
+  open?: boolean;
+  variant?: "dialog" | "page";
+  initialTab?: string;
+  initialSection?: string;
+  appVersion?: string;
+}>();
+
+const emit = defineEmits<{
+  "update:open": [value: boolean];
+}>();
+
+const isSettingsPage = computed(() => props.variant === "page");
+const settingsVisible = computed(() => isSettingsPage.value || props.open === true);
+const settingsRootComponent = computed(() => (isSettingsPage.value ? "div" : Dialog));
+const settingsRootProps = computed(() => (isSettingsPage.value ? {} : { open: props.open === true }));
+const settingsRootClass = computed(() => (isSettingsPage.value ? "h-full min-h-0 overflow-hidden bg-background" : ""));
+const settingsContentComponent = computed(() => (isSettingsPage.value ? "div" : DialogContent));
+const settingsContentClass = computed(() => (isSettingsPage.value ? "flex h-full min-h-0 flex-col gap-4 overflow-hidden bg-background p-4" : "h-[min(660px,calc(100dvh-80px))] !max-w-[min(920px,calc(100vw-32px))] grid-rows-[auto_minmax(0,1fr)] gap-3 p-4 sm:!max-w-[min(920px,calc(100vw-48px))]"));
+const settingsTitleComponent = computed(() => (isSettingsPage.value ? "h2" : DialogTitle));
+
+function onSettingsRootOpenChange(value: boolean) {
+  if (!isSettingsPage.value) emit("update:open", value);
+}
+
+function closeSettings() {
+  emit("update:open", false);
+}
+
+interface TableColumnTemplateOverrideRow {
+  id: string;
+  databaseType: DatabaseType;
+  dataType: string;
+}
+
+interface TableColumnTemplateGridRow {
+  id: string;
+  name: string;
+  defaultValue: string;
+  required: boolean;
+  comment: string;
+  overrides: TableColumnTemplateOverrideRow[];
+}
+
+interface AiEnvRow {
+  id: string;
+  key: string;
+  value: string;
+}
+
+function tableColumnTemplateRowsFromSettings(lines: readonly string[]): TableColumnTemplateGridRow[] {
+  return parseTableColumnTemplateFields([...lines]).map((field) => ({
+    id: uuid(),
+    name: field.name,
+    defaultValue: field.defaultValue ?? "",
+    required: !(field.isNullable ?? false),
+    comment: field.comment ?? "",
+    overrides: Object.entries(field.dataTypesByDatabase).map(([databaseType, dataType]) => ({
+      id: uuid(),
+      databaseType: databaseType as DatabaseType,
+      dataType: dataType === EMPTY_TABLE_COLUMN_TEMPLATE_DATA_TYPE ? "" : dataType,
+    })),
+  }));
+}
+
+function tableColumnTemplateRowsToSettings(rows: readonly TableColumnTemplateGridRow[]): string[] {
+  const seenNames = new Set<string>();
+  const settings: string[] = [];
+  for (const row of rows) {
+    const name = row.name.trim();
+    if (!name) continue;
+    const key = name.toLowerCase();
+    if (seenNames.has(key)) continue;
+    seenNames.add(key);
+
+    const parts = [name];
+
+    const seenDatabaseTypes = new Set<DatabaseType>();
+    for (const override of row.overrides) {
+      const dataType = override.dataType.trim();
+      if (seenDatabaseTypes.has(override.databaseType)) continue;
+      seenDatabaseTypes.add(override.databaseType);
+      parts.push(`${override.databaseType}:${dataType || EMPTY_TABLE_COLUMN_TEMPLATE_DATA_TYPE}`);
+    }
+    if (!row.required) parts.push("required:false");
+    const defaultValue = row.defaultValue.trim();
+    if (defaultValue) parts.push(`default:${defaultValue}`);
+    const comment = row.comment.trim();
+    if (comment) parts.push(`comment:${comment}`);
+    settings.push(parts.join(" | "));
+  }
+  return settings;
+}
+
+function createEmptyTableColumnTemplateRow(): TableColumnTemplateGridRow {
+  return {
+    id: uuid(),
+    name: "",
+    defaultValue: "",
+    required: true,
+    comment: "",
+    overrides: [],
+  };
+}
+
+// Local edit state
+const editFontFamily = ref(settingsStore.editorSettings.fontFamily);
+const editFontSize = ref(settingsStore.editorSettings.fontSize);
+const editUiFontFamily = ref(settingsStore.editorSettings.uiFontFamily);
+const editUiScale = ref(settingsStore.editorSettings.uiScale);
+const editTheme = ref(settingsStore.editorSettings.theme);
+const editCustomThemes = ref<CustomTheme[]>([...settingsStore.editorSettings.customThemes]);
+const editActiveCustomThemeId = ref(settingsStore.editorSettings.activeCustomThemeId);
+const showThemeCustomizer = ref(false);
+const editExecuteMode = ref(settingsStore.editorSettings.executeMode);
+const editShowExecutionTargetPicker = ref(settingsStore.editorSettings.showExecutionTargetPicker);
+const editShowStatementRunButtons = ref(settingsStore.editorSettings.showStatementRunButtons);
+const editShowCurrentStatementFrame = ref(settingsStore.editorSettings.showCurrentStatementFrame);
+const editShowInsertValueHints = ref(settingsStore.editorSettings.showInsertValueHints);
+const editAutoAliasTables = ref(settingsStore.editorSettings.autoAliasTables);
+const editWordWrap = ref(settingsStore.editorSettings.wordWrap);
+const editVimModeEnabled = ref(settingsStore.editorSettings.vimModeEnabled);
+const editAutoCloseBrackets = ref(settingsStore.editorSettings.autoCloseBrackets);
+const editSqlSemanticDiagnosticsMode = ref<SqlSemanticDiagnosticsMode>(settingsStore.editorSettings.sqlSemanticDiagnosticsMode);
+const editSqlSemanticDiagnosticsEnabled = ref(settingsStore.editorSettings.sqlSemanticDiagnosticsEnabled);
+const editConfirmDangerousSqlExecution = ref(settingsStore.editorSettings.confirmDangerousSqlExecution);
+const editConfirmUnsavedSqlClose = ref(settingsStore.editorSettings.confirmUnsavedSqlClose);
+const editAppLayout = ref(settingsStore.editorSettings.appLayout);
+const editShowTrayIcon = ref(settingsStore.desktopSettings.show_tray_icon);
+const editQuitOnClose = ref(settingsStore.desktopSettings.quit_on_close);
+const desktopCloseBehaviorResetPending = ref(false);
+const editIconTheme = ref<DesktopIconTheme>(settingsStore.desktopSettings.icon_theme);
+const editDebugLoggingEnabled = ref(settingsStore.desktopSettings.debug_logging_enabled);
+const editDuckDbWorkerProcessIsolation = ref(settingsStore.desktopSettings.duckdb_worker_process_isolation);
+const editDuckDbWorkerMaxProcesses = ref(settingsStore.desktopSettings.duckdb_worker_max_processes);
+const startupDuckDbWorkerProcessIsolation = ref(settingsStore.desktopSettings.duckdb_worker_process_isolation);
+const startupDuckDbWorkerMaxProcesses = ref(settingsStore.desktopSettings.duckdb_worker_max_processes);
+const duckDbWorkerStartupCaptured = ref(false);
+const duckDbRestarting = ref(false);
+const editSidebarTablePageSize = ref(settingsStore.desktopSettings.sidebar_table_page_size ?? DEFAULT_SIDEBAR_TABLE_PAGE_SIZE);
+const debugLogCopied = ref(false);
+const debugLogDownloaded = ref(false);
+const editShowColumnCommentsInHeader = ref(settingsStore.editorSettings.showColumnCommentsInHeader);
+const editShowColumnTypesInHeader = ref(settingsStore.editorSettings.showColumnTypesInHeader);
+const editCompactColumnHeaderActions = ref(settingsStore.editorSettings.compactColumnHeaderActions);
+const editDataGridQuickEntry = ref(settingsStore.editorSettings.dataGridQuickEntry);
+const editInfiniteScroll = ref(settingsStore.editorSettings.infiniteScroll);
+const editInfiniteScrollMaxRows = ref(settingsStore.editorSettings.infiniteScrollMaxRows);
+const editAutoCalculateTotalRows = ref(settingsStore.editorSettings.autoCalculateTotalRows);
+const editTableColumnTemplateRows = ref<TableColumnTemplateGridRow[]>(tableColumnTemplateRowsFromSettings(settingsStore.editorSettings.tableColumnTemplateFields));
+const editTableColumnTemplateDatabaseType = ref<DatabaseType>(TABLE_COLUMN_TEMPLATE_DATABASE_TYPES[0] ?? "mysql");
+const editSqlVariableSyntaxOverrides = ref<SqlVariableSyntaxOverrides>(normalizeSqlVariableSyntaxOverrides(settingsStore.editorSettings.sqlVariableSyntaxOverrides));
+const editSqlVariableSyntaxDatabaseType = ref<DatabaseType>(SQL_VARIABLE_SYNTAX_DATABASE_TYPES[0] ?? "mysql");
+
+function sqlVariableSyntaxToggle(key: keyof SqlVariableSyntaxToggles): boolean {
+  return editSqlVariableSyntaxOverrides.value[editSqlVariableSyntaxDatabaseType.value]?.[key] ?? true;
+}
+
+function setSqlVariableSyntaxToggle(key: keyof SqlVariableSyntaxToggles, value: boolean) {
+  const dbType = editSqlVariableSyntaxDatabaseType.value;
+  const merged: SqlVariableSyntaxToggles = {
+    ...DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES,
+    ...editSqlVariableSyntaxOverrides.value[dbType],
+    [key]: value,
+  };
+  const next: SqlVariableSyntaxOverrides = { ...editSqlVariableSyntaxOverrides.value };
+  // Keep storage sparse: an all-enabled type has no entry; otherwise persist only the disabled syntaxes.
+  if (SQL_VARIABLE_SYNTAX_KEYS.every((toggleKey) => merged[toggleKey])) {
+    delete next[dbType];
+  } else {
+    const partial: Partial<SqlVariableSyntaxToggles> = {};
+    for (const toggleKey of SQL_VARIABLE_SYNTAX_KEYS) {
+      if (!merged[toggleKey]) partial[toggleKey] = false;
+    }
+    next[dbType] = partial;
+  }
+  editSqlVariableSyntaxOverrides.value = next;
+}
+const tableColumnTemplateSectionRef = ref<HTMLElement | null>(null);
+const draggedTableColumnTemplateRowId = ref<string | null>(null);
+let tableColumnTemplatePointerDragCleanup: (() => void) | null = null;
+const editShortcuts = ref(normalizeShortcutSettings(settingsStore.editorSettings.shortcuts));
+const editSqlFormatter = ref<SqlFormatterSettings>(normalizeSqlFormatterSettings(settingsStore.editorSettings.sqlFormatter));
+const sqlFormatterConfigValid = ref(true);
+const editingShortcutId = ref<ShortcutActionId | null>(null);
+const editSidebarActivation = ref(settingsStore.editorSettings.sidebarActivation);
+const editSidebarObjectDisplay = ref(settingsStore.editorSettings.sidebarObjectDisplay);
+const sidebarObjectDisplayHelp = ref<"grouped" | "simple" | null>(null);
+const editSidebarTableSearchEnabled = ref(settingsStore.editorSettings.sidebarTableSearchEnabled);
+const editAutoSelectActiveSidebarNode = ref(settingsStore.editorSettings.autoSelectActiveSidebarNode);
+const editOpenTabsRestoreMode = ref<OpenTabsRestoreMode>(settingsStore.editorSettings.openTabsRestoreMode);
+const editDisconnectTabHandlingMode = ref<DisconnectTabHandlingMode>(settingsStore.editorSettings.disconnectTabHandlingMode);
+const editReuseDataTab = ref(settingsStore.editorSettings.reuseDataTab);
+const editUpdateNotificationsEnabled = ref(settingsStore.editorSettings.updateNotificationsEnabled);
+const editSidebarHiddenTablePrefixes = ref(settingsStore.editorSettings.sidebarHiddenTablePrefixes.join("\n"));
+const editSidebarHideTableComments = ref(settingsStore.editorSettings.sidebarHideTableComments);
+const editSidebarAllowHorizontalScroll = ref(settingsStore.editorSettings.sidebarAllowHorizontalScroll);
+const editExportBatchSize = ref(settingsStore.editorSettings.exportBatchSize);
+const editExportRowLimitEnabled = ref(settingsStore.editorSettings.exportRowLimitEnabled);
+const editExportRowLimit = ref(settingsStore.editorSettings.exportRowLimit);
+const editQueryExportKeysetOptimizationEnabled = ref(settingsStore.editorSettings.queryExportKeysetOptimizationEnabled);
+const editUpdateDownloadSource = ref<UpdateDownloadSource>(settingsStore.editorSettings.updateDownloadSource);
+const editToolbarItems = ref({ ...settingsStore.editorSettings.toolbarItems });
+const systemFonts = ref<string[]>([]);
+const systemFontsLoading = ref(false);
+const systemFontsLoaded = ref(false);
+const uiScaleOptions = [0.75, 0.9, 1, 1.1, 1.25, 1.5, 1.75, 2];
+const fontSearchTriggerClass =
+  "h-8 w-full max-w-none justify-between gap-1.5 rounded-[6px] border border-input bg-transparent py-2 pl-2.5 pr-2 text-sm font-normal shadow-none hover:bg-transparent focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 aria-expanded:bg-transparent dark:bg-input/30 dark:hover:bg-input/50";
+const appearanceFontSearchTriggerClass = `${fontSearchTriggerClass} gap-0 pl-2 pr-1.5`;
+const fontSearchTriggerIconClass = "size-4 text-muted-foreground";
+const appearanceFontSearchTriggerIconClass = "size-2.5 text-muted-foreground";
+const disconnectTabHandlingModeDescriptionKey = computed(() => {
+  switch (editDisconnectTabHandlingMode.value) {
+    case "close-tabs":
+      return "disconnectTabHandlingModeCloseTabsDescription";
+    case "keep-tabs-clear-results":
+      return "disconnectTabHandlingModeKeepTabsClearResultsDescription";
+    case "keep-tabs-keep-results":
+      return "disconnectTabHandlingModeKeepTabsKeepResultsDescription";
+  }
+
+  return "disconnectTabHandlingModeCloseTabsDescription";
+});
+const normalizedEditTableColumnTemplateFields = computed(() => tableColumnTemplateRowsToSettings(editTableColumnTemplateRows.value));
+const visibleTableColumnTemplateRows = computed(() =>
+  editTableColumnTemplateRows.value.filter((row) => {
+    if (row.overrides.length === 0) return true;
+    return row.overrides.some((override) => override.databaseType === editTableColumnTemplateDatabaseType.value);
+  }),
+);
+
+// --- Snippet state ---
+function editableSnippet(snippet: SqlSnippet): SqlSnippet {
+  return { ...snippet, enabled: snippet.enabled !== false };
+}
+
+const editSnippets = ref<SqlSnippet[]>(settingsStore.editorSettings.snippets.map(editableSnippet));
+
+function currentEditorSettingsDraft(): EditorSettingsDraft {
+  return {
+    fontFamily: editFontFamily.value,
+    fontSize: editFontSize.value,
+    uiFontFamily: editUiFontFamily.value,
+    uiScale: editUiScale.value,
+    theme: editTheme.value,
+    customThemes: editCustomThemes.value,
+    activeCustomThemeId: editActiveCustomThemeId.value,
+    executeMode: editExecuteMode.value,
+    showExecutionTargetPicker: editShowExecutionTargetPicker.value,
+    showStatementRunButtons: editShowStatementRunButtons.value,
+    showCurrentStatementFrame: editShowCurrentStatementFrame.value,
+    showInsertValueHints: editShowInsertValueHints.value,
+    autoAliasTables: editAutoAliasTables.value,
+    wordWrap: editWordWrap.value,
+    vimModeEnabled: editVimModeEnabled.value,
+    autoCloseBrackets: editAutoCloseBrackets.value,
+    sqlSemanticDiagnosticsMode: editSqlSemanticDiagnosticsMode.value,
+    confirmDangerousSqlExecution: editConfirmDangerousSqlExecution.value,
+    confirmUnsavedSqlClose: editConfirmUnsavedSqlClose.value,
+    appLayout: editAppLayout.value,
+    showColumnCommentsInHeader: editShowColumnCommentsInHeader.value,
+    showColumnTypesInHeader: editShowColumnTypesInHeader.value,
+    compactColumnHeaderActions: editCompactColumnHeaderActions.value,
+    dataGridQuickEntry: editDataGridQuickEntry.value,
+    infiniteScroll: editInfiniteScroll.value,
+    infiniteScrollMaxRows: editInfiniteScrollMaxRows.value,
+    autoCalculateTotalRows: editAutoCalculateTotalRows.value,
+    tableColumnTemplateFields: normalizedEditTableColumnTemplateFields.value,
+    shortcuts: editShortcuts.value,
+    sqlFormatter: normalizeSqlFormatterSettings(editSqlFormatter.value),
+    sidebarActivation: editSidebarActivation.value,
+    sidebarObjectDisplay: editSidebarObjectDisplay.value,
+    sidebarTableSearchEnabled: editSidebarTableSearchEnabled.value,
+    autoSelectActiveSidebarNode: editAutoSelectActiveSidebarNode.value,
+    openTabsRestoreMode: editOpenTabsRestoreMode.value,
+    disconnectTabHandlingMode: editDisconnectTabHandlingMode.value,
+    reuseDataTab: editReuseDataTab.value,
+    updateNotificationsEnabled: editUpdateNotificationsEnabled.value,
+    sidebarHideTableComments: editSidebarHideTableComments.value,
+    sidebarAllowHorizontalScroll: editSidebarAllowHorizontalScroll.value,
+    sidebarHiddenTablePrefixes: normalizeSidebarHiddenTablePrefixes(editSidebarHiddenTablePrefixes.value),
+    exportBatchSize: editExportBatchSize.value,
+    exportRowLimitEnabled: editExportRowLimitEnabled.value,
+    exportRowLimit: editExportRowLimit.value,
+    queryExportKeysetOptimizationEnabled: editQueryExportKeysetOptimizationEnabled.value,
+    updateDownloadSource: editUpdateDownloadSource.value,
+    toolbarItems: { ...editToolbarItems.value },
+    snippets: editSnippets.value,
+    sqlVariableSyntaxOverrides: editSqlVariableSyntaxOverrides.value,
+  };
+}
+
+const editEditorSettingsBase = ref<EditorSettingsDraft>(editorSettingsDraftFromSettings(settingsStore.editorSettings));
+const hasEditorDraftChanges = computed(() => editorSettingsDraftChanged(currentEditorSettingsDraft(), editEditorSettingsBase.value));
+
+const snippetDialogOpen = ref(false);
+const snippetEditingId = ref<string | null>(null);
+const snippetForm = ref({ label: "", prefix: "", body: "" });
+const snippetFormPrefixError = ref("");
+const iconThemeDescTruncated = { default: ref<boolean>(false), black: ref<boolean>(false) };
+const iconThemeDescRef = {
+  default: ref<HTMLElement | null>(null),
+  black: ref<HTMLElement | null>(null),
+};
+const iconThemeBlackDescriptionText = computed(() => (isMacOS() ? t("settings.iconThemeBlackDescriptionMac") : t("settings.iconThemeBlackDescription")));
+const layoutDescTruncated = { separated: ref<boolean>(false), classic: ref<boolean>(false) };
+const layoutDescRefs = {
+  separated: ref<HTMLElement | null>(null),
+  classic: ref<HTMLElement | null>(null),
+};
+let layoutDescObservers: Record<InterfaceLayout, ResizeObserver | undefined> = {
+  separated: undefined,
+  classic: undefined,
+};
+let iconThemeDescObservers: Record<DesktopIconTheme, ResizeObserver | undefined> = {
+  default: undefined,
+  black: undefined,
+};
+
+function observeElementTruncation(el: Ref<HTMLElement | null>, truncated: Ref<boolean>) {
+  if (!el.value) return;
+
+  const observer = new ResizeObserver(() => {
+    truncated.value = checkElementTruncation(el.value);
+  });
+
+  observer.observe(el.value);
+  return observer;
+}
+
+function initTruncationObservers() {
+  layoutDescObservers.separated = observeElementTruncation(layoutDescRefs.separated, layoutDescTruncated.separated);
+  layoutDescObservers.classic = observeElementTruncation(layoutDescRefs.classic, layoutDescTruncated.classic);
+  iconThemeDescObservers.default = observeElementTruncation(iconThemeDescRef.default, iconThemeDescTruncated.default);
+  iconThemeDescObservers.black = observeElementTruncation(iconThemeDescRef.black, iconThemeDescTruncated.black);
+}
+
+function cleanupTruncationObservers() {
+  layoutDescObservers.separated?.disconnect();
+  layoutDescObservers.classic?.disconnect();
+  iconThemeDescObservers.default?.disconnect();
+  iconThemeDescObservers.black?.disconnect();
+}
+
+function setLayoutDescRef(layout: InterfaceLayout, el: unknown) {
+  layoutDescRefs[layout].value = el instanceof HTMLElement ? el : null;
+}
+
+function setIconThemeDescRef(theme: DesktopIconTheme, el: unknown) {
+  iconThemeDescRef[theme].value = el instanceof HTMLElement ? el : null;
+}
+
+function checkLayoutDescTruncation() {
+  checkTruncationForRefs([
+    { el: layoutDescRefs.separated, truncated: layoutDescTruncated.separated },
+    { el: layoutDescRefs.classic, truncated: layoutDescTruncated.classic },
+  ]);
+}
+
+function checkIconThemeDescTruncation() {
+  checkTruncationForRefs([
+    { el: iconThemeDescRef.default, truncated: iconThemeDescTruncated.default },
+    { el: iconThemeDescRef.black, truncated: iconThemeDescTruncated.black },
+  ]);
+}
+
+function checkTruncationForRefs(items: Array<{ el: Ref<HTMLElement | null>; truncated: Ref<boolean> }>) {
+  nextTick(() => {
+    for (const item of items) {
+      if (item.el.value) {
+        item.truncated.value = checkElementTruncation(item.el.value);
+      }
+    }
+  });
+}
+
+function checkElementTruncation(el: HTMLElement | null) {
+  return el ? el.scrollWidth > el.clientWidth : false;
+}
+
+function openAddSnippetDialog() {
+  snippetEditingId.value = null;
+  snippetForm.value = { label: "", prefix: "", body: "" };
+  snippetFormPrefixError.value = "";
+  snippetDialogOpen.value = true;
+}
+
+function openEditSnippetDialog(snippet: SqlSnippet) {
+  snippetEditingId.value = snippet.id;
+  snippetForm.value = { label: snippet.label, prefix: snippet.prefix, body: snippet.body };
+  snippetFormPrefixError.value = "";
+  snippetDialogOpen.value = true;
+}
+
+function saveSnippet() {
+  const prefix = snippetForm.value.prefix.trim();
+  if (!prefix) {
+    snippetFormPrefixError.value = "Prefix is required.";
+    return;
+  }
+  const duplicate = editSnippets.value.find((s) => s.prefix === prefix && s.id !== snippetEditingId.value);
+  if (duplicate) {
+    snippetFormPrefixError.value = "Prefix must be unique.";
+    return;
+  }
+  if (snippetEditingId.value) {
+    const idx = editSnippets.value.findIndex((s) => s.id === snippetEditingId.value);
+    if (idx !== -1) {
+      editSnippets.value[idx] = {
+        id: snippetEditingId.value,
+        label: snippetForm.value.label.trim() || prefix,
+        prefix,
+        body: snippetForm.value.body,
+        enabled: editSnippets.value[idx].enabled !== false,
+      };
+    }
+  } else {
+    editSnippets.value.push({
+      id: uuid(),
+      label: snippetForm.value.label.trim() || prefix,
+      prefix,
+      body: snippetForm.value.body,
+      enabled: true,
+    });
+  }
+  snippetDialogOpen.value = false;
+}
+
+function setSnippetEnabled(id: string, enabled: boolean) {
+  const idx = editSnippets.value.findIndex((s) => s.id === id);
+  if (idx === -1) return;
+  editSnippets.value[idx] = { ...editSnippets.value[idx], enabled };
+}
+
+function deleteSnippet(id: string) {
+  editSnippets.value = editSnippets.value.filter((s) => s.id !== id);
+}
+
+function confirmDeleteSnippet(snippet: SqlSnippet) {
+  if (window.confirm(`Delete snippet "${snippet.label}"?`)) {
+    deleteSnippet(snippet.id);
+  }
+}
+
+const presetFontLabels = new Map(FONT_FAMILIES.map((font) => [font.value, font.label]));
+const presetFontValues = new Set(FONT_FAMILIES.map((font) => font.value));
+const uiFontPreviewValues = new Set([DEFAULT_UI_FONT_FAMILY, SYSTEM_UI_FONT_FAMILY]);
+
+function cssFontFamilyForName(name: string): string {
+  return `'${name.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}', monospace`;
+}
+
+function readableFontFamily(value: string): string {
+  const first = value.split(",")[0]?.trim() ?? value;
+  return first.replace(/^['"]|['"]$/g, "").replace(/\\'/g, "'");
+}
+
+function normalizeCustomFontFamilyInput(value: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  if (trimmed.includes(",") || trimmed.includes("'") || trimmed.includes('"')) return trimmed;
+  return cssFontFamilyForName(trimmed);
+}
+
+const systemFontOptions = computed(() => {
+  const options = new Set(FONT_FAMILIES.map((font) => font.value));
+  for (const font of systemFonts.value) options.add(cssFontFamilyForName(font));
+  if (editFontFamily.value) options.add(editFontFamily.value);
+  return [...options];
+});
+
+const uiFontOptions = computed(() => {
+  const options = new Set([SYSTEM_UI_FONT_FAMILY, DEFAULT_UI_FONT_FAMILY, ...systemFontOptions.value]);
+  if (editUiFontFamily.value) options.add(editUiFontFamily.value);
+  return [...options];
+});
+
+function displayFontFamily(value: string): string {
+  return presetFontLabels.get(value) ?? readableFontFamily(value);
+}
+
+function displayUiFontFamily(value: string): string {
+  if (value === SYSTEM_UI_FONT_FAMILY) return t("settings.uiFontSystemDefault");
+  if (value === DEFAULT_UI_FONT_FAMILY) return t("settings.uiFontAppDefault");
+  return displayFontFamily(value);
+}
+
+function fontOptionStyle(value: string, selectedValue = editFontFamily.value) {
+  return presetFontValues.has(value) || uiFontPreviewValues.has(value) || value === selectedValue ? { fontFamily: value } : undefined;
+}
+
+async function loadSystemFontOptions() {
+  if (systemFontsLoaded.value || systemFontsLoading.value) return;
+  systemFontsLoading.value = true;
+  try {
+    if (cachedSystemFonts) {
+      systemFonts.value = cachedSystemFonts;
+    } else {
+      pendingSystemFonts ??= listSystemFonts().finally(() => {
+        pendingSystemFonts = null;
+      });
+      cachedSystemFonts = await pendingSystemFonts;
+      systemFonts.value = cachedSystemFonts;
+    }
+    systemFontsLoaded.value = true;
+  } catch {
+    systemFonts.value = [];
+  } finally {
+    systemFontsLoading.value = false;
+  }
+}
+
+function syncEditorSettingsDraftFromStore() {
+  editFontFamily.value = settingsStore.editorSettings.fontFamily;
+  editFontSize.value = settingsStore.editorSettings.fontSize;
+  editUiFontFamily.value = settingsStore.editorSettings.uiFontFamily;
+  editUiScale.value = settingsStore.editorSettings.uiScale;
+  editTheme.value = settingsStore.editorSettings.theme;
+  editCustomThemes.value = [...settingsStore.editorSettings.customThemes];
+  editActiveCustomThemeId.value = settingsStore.editorSettings.activeCustomThemeId;
+  editExecuteMode.value = settingsStore.editorSettings.executeMode;
+  editShowExecutionTargetPicker.value = settingsStore.editorSettings.showExecutionTargetPicker;
+  editShowStatementRunButtons.value = settingsStore.editorSettings.showStatementRunButtons;
+  editShowCurrentStatementFrame.value = settingsStore.editorSettings.showCurrentStatementFrame;
+  editShowInsertValueHints.value = settingsStore.editorSettings.showInsertValueHints;
+  editAutoAliasTables.value = settingsStore.editorSettings.autoAliasTables;
+  editWordWrap.value = settingsStore.editorSettings.wordWrap;
+  editVimModeEnabled.value = settingsStore.editorSettings.vimModeEnabled;
+  editAutoCloseBrackets.value = settingsStore.editorSettings.autoCloseBrackets;
+  editSqlSemanticDiagnosticsMode.value = settingsStore.editorSettings.sqlSemanticDiagnosticsMode;
+  editSqlSemanticDiagnosticsEnabled.value = settingsStore.editorSettings.sqlSemanticDiagnosticsEnabled;
+  editConfirmDangerousSqlExecution.value = settingsStore.editorSettings.confirmDangerousSqlExecution;
+  editConfirmUnsavedSqlClose.value = settingsStore.editorSettings.confirmUnsavedSqlClose;
+  editAppLayout.value = settingsStore.editorSettings.appLayout;
+  editShowColumnCommentsInHeader.value = settingsStore.editorSettings.showColumnCommentsInHeader;
+  editShowColumnTypesInHeader.value = settingsStore.editorSettings.showColumnTypesInHeader;
+  editCompactColumnHeaderActions.value = settingsStore.editorSettings.compactColumnHeaderActions;
+  editDataGridQuickEntry.value = settingsStore.editorSettings.dataGridQuickEntry;
+  editInfiniteScroll.value = settingsStore.editorSettings.infiniteScroll;
+  editInfiniteScrollMaxRows.value = settingsStore.editorSettings.infiniteScrollMaxRows;
+  editAutoCalculateTotalRows.value = settingsStore.editorSettings.autoCalculateTotalRows;
+  editTableColumnTemplateRows.value = tableColumnTemplateRowsFromSettings(settingsStore.editorSettings.tableColumnTemplateFields);
+  editShortcuts.value = normalizeShortcutSettings(settingsStore.editorSettings.shortcuts);
+  editSqlFormatter.value = normalizeSqlFormatterSettings(settingsStore.editorSettings.sqlFormatter);
+  sqlFormatterConfigValid.value = true;
+  editSidebarActivation.value = settingsStore.editorSettings.sidebarActivation;
+  editSidebarObjectDisplay.value = settingsStore.editorSettings.sidebarObjectDisplay;
+  editSidebarTableSearchEnabled.value = settingsStore.editorSettings.sidebarTableSearchEnabled;
+  editAutoSelectActiveSidebarNode.value = settingsStore.editorSettings.autoSelectActiveSidebarNode;
+  editOpenTabsRestoreMode.value = settingsStore.editorSettings.openTabsRestoreMode;
+  editDisconnectTabHandlingMode.value = settingsStore.editorSettings.disconnectTabHandlingMode;
+  editReuseDataTab.value = settingsStore.editorSettings.reuseDataTab;
+  editUpdateNotificationsEnabled.value = settingsStore.editorSettings.updateNotificationsEnabled;
+  editSidebarHiddenTablePrefixes.value = settingsStore.editorSettings.sidebarHiddenTablePrefixes.join("\n");
+  editSidebarHideTableComments.value = settingsStore.editorSettings.sidebarHideTableComments;
+  editSidebarAllowHorizontalScroll.value = settingsStore.editorSettings.sidebarAllowHorizontalScroll;
+  editExportBatchSize.value = settingsStore.editorSettings.exportBatchSize;
+  editExportRowLimitEnabled.value = settingsStore.editorSettings.exportRowLimitEnabled;
+  editExportRowLimit.value = settingsStore.editorSettings.exportRowLimit;
+  editQueryExportKeysetOptimizationEnabled.value = settingsStore.editorSettings.queryExportKeysetOptimizationEnabled;
+  editUpdateDownloadSource.value = settingsStore.editorSettings.updateDownloadSource;
+  editToolbarItems.value = { ...settingsStore.editorSettings.toolbarItems };
+  editSnippets.value = settingsStore.editorSettings.snippets.map(editableSnippet);
+  editSqlVariableSyntaxOverrides.value = normalizeSqlVariableSyntaxOverrides(settingsStore.editorSettings.sqlVariableSyntaxOverrides);
+  editEditorSettingsBase.value = editorSettingsDraftFromSettings(settingsStore.editorSettings);
+}
+
+// Sync from store when dialog opens
+watch(
+  () => settingsVisible.value,
+  (open) => {
+    if (open) {
+      syncEditorSettingsDraftFromStore();
+      editShowTrayIcon.value = settingsStore.desktopSettings.show_tray_icon;
+      editQuitOnClose.value = settingsStore.desktopSettings.quit_on_close;
+      editIconTheme.value = settingsStore.desktopSettings.icon_theme;
+      editDebugLoggingEnabled.value = settingsStore.desktopSettings.debug_logging_enabled;
+      editDuckDbWorkerProcessIsolation.value = settingsStore.desktopSettings.duckdb_worker_process_isolation;
+      editSidebarTablePageSize.value = settingsStore.desktopSettings.sidebar_table_page_size ?? DEFAULT_SIDEBAR_TABLE_PAGE_SIZE;
+    }
+  },
+  { immediate: true },
+);
+
+watch(
+  () => settingsStore.editorSettings,
+  () => {
+    if (settingsVisible.value && !hasEditorDraftChanges.value) {
+      syncEditorSettingsDraftFromStore();
+    }
+  },
+  { deep: true },
+);
+
+const shortcutConflicts = computed(() =>
+  SHORTCUT_DEFINITIONS.flatMap((definition) => {
+    const conflict = findShortcutConflict(definition.id, editShortcuts.value[definition.id], editShortcuts.value);
+    return conflict ? [definition.id] : [];
+  }),
+);
+const shortcutSearchQuery = ref("");
+const formatterEditorShortcutIds: ShortcutActionId[] = [
+  "formatSql",
+  "toggleLineComment",
+  "find",
+  "replace",
+  "saveSql",
+  "acceptCompletion",
+  "indentMore",
+  "indentLess",
+  "duplicateLine",
+  "deleteLine",
+  "moveLineUp",
+  "moveLineDown",
+  "copyLineUp",
+  "copyLineDown",
+  "undo",
+  "redo",
+  "selectAll",
+  "uppercaseSelection",
+  "lowercaseSelection",
+];
+const formatterEditorShortcutDefinitions = computed(() => formatterEditorShortcutIds.map((id) => SHORTCUT_DEFINITIONS.find((definition) => definition.id === id)).filter((definition): definition is (typeof SHORTCUT_DEFINITIONS)[number] => !!definition));
+const filteredShortcutDefinitions = computed(() => {
+  const query = shortcutSearchQuery.value.trim().toLowerCase();
+  if (!query) return SHORTCUT_DEFINITIONS;
+  return SHORTCUT_DEFINITIONS.filter((definition) => {
+    const scope = t(`settings.shortcutScope${definition.scope[0].toUpperCase()}${definition.scope.slice(1)}`);
+    const shortcut = formatShortcutPill(editShortcuts.value[definition.id]);
+    return [definition.id, t(definition.labelKey), scope, shortcut].some((value) => value.toLowerCase().includes(query));
+  });
+});
+const hasShortcutConflicts = computed(() => shortcutConflicts.value.length > 0);
+const shortcutsChanged = computed(() => JSON.stringify(editShortcuts.value) !== JSON.stringify(editEditorSettingsBase.value.shortcuts));
+const duckDbWorkerSettingsRequireRestart = computed(() => editDuckDbWorkerProcessIsolation.value !== startupDuckDbWorkerProcessIsolation.value || normalizeDuckDbWorkerMaxProcesses(editDuckDbWorkerMaxProcesses.value) !== startupDuckDbWorkerMaxProcesses.value);
+const hasBlockingShortcutConflicts = computed(() => shortcutsChanged.value && hasShortcutConflicts.value);
+const hasBlockingFormatterConfig = computed(() => activeSettingsTab.value === "formatter" && !sqlFormatterConfigValid.value);
+const hasApplyBlocker = computed(() => hasBlockingShortcutConflicts.value || hasBlockingFormatterConfig.value);
+
+function hasChanges(): boolean {
+  return (
+    hasEditorDraftChanges.value ||
+    editShowTrayIcon.value !== settingsStore.desktopSettings.show_tray_icon ||
+    editQuitOnClose.value !== settingsStore.desktopSettings.quit_on_close ||
+    editIconTheme.value !== settingsStore.desktopSettings.icon_theme ||
+    editDebugLoggingEnabled.value !== settingsStore.desktopSettings.debug_logging_enabled ||
+    editDuckDbWorkerProcessIsolation.value !== settingsStore.desktopSettings.duckdb_worker_process_isolation ||
+    normalizeDuckDbWorkerMaxProcesses(editDuckDbWorkerMaxProcesses.value) !== settingsStore.desktopSettings.duckdb_worker_max_processes ||
+    editSidebarTablePageSize.value !== (settingsStore.desktopSettings.sidebar_table_page_size ?? DEFAULT_SIDEBAR_TABLE_PAGE_SIZE)
+  );
+}
+
+async function persistSettings() {
+  if (hasApplyBlocker.value) return;
+  const editorSettingsPatch = editorSettingsPatchFromDraft(currentEditorSettingsDraft(), editEditorSettingsBase.value);
+  const sidebarObjectDisplayChanged = editorSettingsPatch.sidebarObjectDisplay !== undefined && editorSettingsPatch.sidebarObjectDisplay !== settingsStore.editorSettings.sidebarObjectDisplay;
+  const sidebarTablePageSizeChanged = editSidebarTablePageSize.value !== (settingsStore.desktopSettings.sidebar_table_page_size ?? DEFAULT_SIDEBAR_TABLE_PAGE_SIZE);
+  if (Object.keys(editorSettingsPatch).length > 0) {
+    settingsStore.updateEditorSettings(editorSettingsPatch);
+    editEditorSettingsBase.value = editorSettingsDraftFromSettings(settingsStore.editorSettings);
+  }
+  await settingsStore.updateDesktopSettings({
+    show_tray_icon: editShowTrayIcon.value,
+    quit_on_close: editQuitOnClose.value,
+    close_action_prompted: desktopCloseBehaviorResetPending.value ? false : true,
+    icon_theme: editIconTheme.value,
+    debug_logging_enabled: editDebugLoggingEnabled.value,
+    duckdb_worker_process_isolation: editDuckDbWorkerProcessIsolation.value,
+    duckdb_worker_max_processes: normalizeDuckDbWorkerMaxProcesses(editDuckDbWorkerMaxProcesses.value),
+    sidebar_table_page_size: editSidebarTablePageSize.value,
+  });
+  desktopCloseBehaviorResetPending.value = false;
+  if (sidebarObjectDisplayChanged) {
+    await connectionStore.refreshAllTree();
+  } else if (sidebarTablePageSizeChanged) {
+    await connectionStore.refreshSidebarObjectPagination();
+  }
+}
+
+async function applySettings() {
+  await persistSettings();
+}
+
+async function applySettingsAndClose() {
+  await persistSettings();
+  closeSettings();
+}
+
+async function restartDbxForDuckDbIsolation() {
+  if (duckDbRestarting.value || hasApplyBlocker.value || isWeb) return;
+  duckDbRestarting.value = true;
+  try {
+    await persistSettings();
+    const { relaunch } = await import("@tauri-apps/plugin-process");
+    await relaunch();
+  } catch (e: any) {
+    toast(t("settings.restartDbxFailed", { error: e?.message || String(e) }), 5000);
+  } finally {
+    duckDbRestarting.value = false;
+  }
+}
+
+function resetDefaultsForTab(tab: SettingsCategory) {
+  if (tab === "editor") {
+    editFontFamily.value = DEFAULT_EDITOR_SETTINGS.fontFamily;
+    editFontSize.value = DEFAULT_EDITOR_SETTINGS.fontSize;
+    editExecuteMode.value = DEFAULT_EDITOR_SETTINGS.executeMode;
+    editShowExecutionTargetPicker.value = DEFAULT_EDITOR_SETTINGS.showExecutionTargetPicker;
+    editShowStatementRunButtons.value = DEFAULT_EDITOR_SETTINGS.showStatementRunButtons;
+    editShowCurrentStatementFrame.value = DEFAULT_EDITOR_SETTINGS.showCurrentStatementFrame;
+    editShowInsertValueHints.value = DEFAULT_EDITOR_SETTINGS.showInsertValueHints;
+    editAutoAliasTables.value = DEFAULT_EDITOR_SETTINGS.autoAliasTables;
+    editWordWrap.value = DEFAULT_EDITOR_SETTINGS.wordWrap;
+    editVimModeEnabled.value = DEFAULT_EDITOR_SETTINGS.vimModeEnabled;
+    editAutoCloseBrackets.value = DEFAULT_EDITOR_SETTINGS.autoCloseBrackets;
+    editSqlSemanticDiagnosticsMode.value = DEFAULT_EDITOR_SETTINGS.sqlSemanticDiagnosticsMode;
+    editSqlSemanticDiagnosticsEnabled.value = DEFAULT_EDITOR_SETTINGS.sqlSemanticDiagnosticsEnabled;
+    editConfirmDangerousSqlExecution.value = DEFAULT_EDITOR_SETTINGS.confirmDangerousSqlExecution;
+    editConfirmUnsavedSqlClose.value = DEFAULT_EDITOR_SETTINGS.confirmUnsavedSqlClose;
+    editSqlVariableSyntaxOverrides.value = normalizeSqlVariableSyntaxOverrides(DEFAULT_EDITOR_SETTINGS.sqlVariableSyntaxOverrides);
+  } else if (tab === "formatter") {
+    editSqlFormatter.value = normalizeSqlFormatterSettings(DEFAULT_EDITOR_SETTINGS.sqlFormatter);
+    sqlFormatterConfigValid.value = true;
+  } else if (tab === "appearance") {
+    editUiFontFamily.value = DEFAULT_EDITOR_SETTINGS.uiFontFamily;
+    editUiScale.value = DEFAULT_EDITOR_SETTINGS.uiScale;
+    editTheme.value = DEFAULT_EDITOR_SETTINGS.theme;
+    editCustomThemes.value = [...DEFAULT_EDITOR_SETTINGS.customThemes];
+    editActiveCustomThemeId.value = DEFAULT_EDITOR_SETTINGS.activeCustomThemeId;
+    editAppLayout.value = DEFAULT_EDITOR_SETTINGS.appLayout;
+    editShowTrayIcon.value = DEFAULT_DESKTOP_SETTINGS.show_tray_icon;
+    editQuitOnClose.value = DEFAULT_DESKTOP_SETTINGS.quit_on_close;
+    desktopCloseBehaviorResetPending.value = true;
+    editIconTheme.value = DEFAULT_DESKTOP_SETTINGS.icon_theme;
+    editDebugLoggingEnabled.value = DEFAULT_DESKTOP_SETTINGS.debug_logging_enabled;
+  } else if (tab === "navigation") {
+    editSidebarTablePageSize.value = DEFAULT_SIDEBAR_TABLE_PAGE_SIZE;
+    editSidebarActivation.value = DEFAULT_EDITOR_SETTINGS.sidebarActivation;
+    editSidebarObjectDisplay.value = DEFAULT_EDITOR_SETTINGS.sidebarObjectDisplay;
+    editSidebarTableSearchEnabled.value = DEFAULT_EDITOR_SETTINGS.sidebarTableSearchEnabled;
+    editAutoSelectActiveSidebarNode.value = DEFAULT_EDITOR_SETTINGS.autoSelectActiveSidebarNode;
+    editOpenTabsRestoreMode.value = DEFAULT_EDITOR_SETTINGS.openTabsRestoreMode;
+    editDisconnectTabHandlingMode.value = DEFAULT_EDITOR_SETTINGS.disconnectTabHandlingMode;
+    editReuseDataTab.value = DEFAULT_EDITOR_SETTINGS.reuseDataTab;
+    editUpdateNotificationsEnabled.value = DEFAULT_EDITOR_SETTINGS.updateNotificationsEnabled;
+    editSidebarHideTableComments.value = DEFAULT_EDITOR_SETTINGS.sidebarHideTableComments;
+    editSidebarAllowHorizontalScroll.value = DEFAULT_EDITOR_SETTINGS.sidebarAllowHorizontalScroll;
+    editSidebarHiddenTablePrefixes.value = DEFAULT_EDITOR_SETTINGS.sidebarHiddenTablePrefixes.join("\n");
+    editToolbarItems.value = { ...DEFAULT_EDITOR_SETTINGS.toolbarItems };
+  } else if (tab === "data") {
+    editShowColumnCommentsInHeader.value = DEFAULT_EDITOR_SETTINGS.showColumnCommentsInHeader;
+    editShowColumnTypesInHeader.value = DEFAULT_EDITOR_SETTINGS.showColumnTypesInHeader;
+    editCompactColumnHeaderActions.value = DEFAULT_EDITOR_SETTINGS.compactColumnHeaderActions;
+    editDataGridQuickEntry.value = DEFAULT_EDITOR_SETTINGS.dataGridQuickEntry;
+    editInfiniteScroll.value = DEFAULT_EDITOR_SETTINGS.infiniteScroll;
+    editInfiniteScrollMaxRows.value = DEFAULT_EDITOR_SETTINGS.infiniteScrollMaxRows;
+    editAutoCalculateTotalRows.value = DEFAULT_EDITOR_SETTINGS.autoCalculateTotalRows;
+    editDuckDbWorkerProcessIsolation.value = DEFAULT_DESKTOP_SETTINGS.duckdb_worker_process_isolation;
+    editDuckDbWorkerMaxProcesses.value = DEFAULT_DESKTOP_SETTINGS.duckdb_worker_max_processes;
+    editTableColumnTemplateRows.value = tableColumnTemplateRowsFromSettings(DEFAULT_EDITOR_SETTINGS.tableColumnTemplateFields);
+    editExportBatchSize.value = DEFAULT_EDITOR_SETTINGS.exportBatchSize;
+    editExportRowLimitEnabled.value = DEFAULT_EDITOR_SETTINGS.exportRowLimitEnabled;
+    editExportRowLimit.value = DEFAULT_EDITOR_SETTINGS.exportRowLimit;
+    editQueryExportKeysetOptimizationEnabled.value = DEFAULT_EDITOR_SETTINGS.queryExportKeysetOptimizationEnabled;
+  } else if (tab === "shortcuts") {
+    editShortcuts.value = normalizeShortcutSettings(DEFAULT_EDITOR_SETTINGS.shortcuts);
+  } else if (tab === "snippets") {
+    editSnippets.value = DEFAULT_SQL_SNIPPETS.map((s) => ({ ...s }));
+  } else if (tab === "about") {
+    editUpdateDownloadSource.value = DEFAULT_EDITOR_SETTINGS.updateDownloadSource;
+  }
+}
+
+function resetAllDefaults() {
+  editFontFamily.value = DEFAULT_EDITOR_SETTINGS.fontFamily;
+  editFontSize.value = DEFAULT_EDITOR_SETTINGS.fontSize;
+  editUiFontFamily.value = DEFAULT_EDITOR_SETTINGS.uiFontFamily;
+  editUiScale.value = DEFAULT_EDITOR_SETTINGS.uiScale;
+  editTheme.value = DEFAULT_EDITOR_SETTINGS.theme;
+  editCustomThemes.value = [...DEFAULT_EDITOR_SETTINGS.customThemes];
+  editActiveCustomThemeId.value = DEFAULT_EDITOR_SETTINGS.activeCustomThemeId;
+  editExecuteMode.value = DEFAULT_EDITOR_SETTINGS.executeMode;
+  editShowExecutionTargetPicker.value = DEFAULT_EDITOR_SETTINGS.showExecutionTargetPicker;
+  editShowStatementRunButtons.value = DEFAULT_EDITOR_SETTINGS.showStatementRunButtons;
+  editShowCurrentStatementFrame.value = DEFAULT_EDITOR_SETTINGS.showCurrentStatementFrame;
+  editShowInsertValueHints.value = DEFAULT_EDITOR_SETTINGS.showInsertValueHints;
+  editAutoAliasTables.value = DEFAULT_EDITOR_SETTINGS.autoAliasTables;
+  editWordWrap.value = DEFAULT_EDITOR_SETTINGS.wordWrap;
+  editVimModeEnabled.value = DEFAULT_EDITOR_SETTINGS.vimModeEnabled;
+  editAutoCloseBrackets.value = DEFAULT_EDITOR_SETTINGS.autoCloseBrackets;
+  editSqlSemanticDiagnosticsMode.value = DEFAULT_EDITOR_SETTINGS.sqlSemanticDiagnosticsMode;
+  editSqlSemanticDiagnosticsEnabled.value = DEFAULT_EDITOR_SETTINGS.sqlSemanticDiagnosticsEnabled;
+  editConfirmDangerousSqlExecution.value = DEFAULT_EDITOR_SETTINGS.confirmDangerousSqlExecution;
+  editConfirmUnsavedSqlClose.value = DEFAULT_EDITOR_SETTINGS.confirmUnsavedSqlClose;
+  editSqlVariableSyntaxOverrides.value = normalizeSqlVariableSyntaxOverrides(DEFAULT_EDITOR_SETTINGS.sqlVariableSyntaxOverrides);
+  editAppLayout.value = DEFAULT_EDITOR_SETTINGS.appLayout;
+  editShowTrayIcon.value = DEFAULT_DESKTOP_SETTINGS.show_tray_icon;
+  editQuitOnClose.value = DEFAULT_DESKTOP_SETTINGS.quit_on_close;
+  desktopCloseBehaviorResetPending.value = true;
+  editIconTheme.value = DEFAULT_DESKTOP_SETTINGS.icon_theme;
+  editDebugLoggingEnabled.value = DEFAULT_DESKTOP_SETTINGS.debug_logging_enabled;
+  editDuckDbWorkerProcessIsolation.value = DEFAULT_DESKTOP_SETTINGS.duckdb_worker_process_isolation;
+  editDuckDbWorkerMaxProcesses.value = DEFAULT_DESKTOP_SETTINGS.duckdb_worker_max_processes;
+  editSidebarTablePageSize.value = DEFAULT_SIDEBAR_TABLE_PAGE_SIZE;
+  editShowColumnCommentsInHeader.value = DEFAULT_EDITOR_SETTINGS.showColumnCommentsInHeader;
+  editShowColumnTypesInHeader.value = DEFAULT_EDITOR_SETTINGS.showColumnTypesInHeader;
+  editCompactColumnHeaderActions.value = DEFAULT_EDITOR_SETTINGS.compactColumnHeaderActions;
+  editDataGridQuickEntry.value = DEFAULT_EDITOR_SETTINGS.dataGridQuickEntry;
+  editInfiniteScroll.value = DEFAULT_EDITOR_SETTINGS.infiniteScroll;
+  editInfiniteScrollMaxRows.value = DEFAULT_EDITOR_SETTINGS.infiniteScrollMaxRows;
+  editAutoCalculateTotalRows.value = DEFAULT_EDITOR_SETTINGS.autoCalculateTotalRows;
+  editTableColumnTemplateRows.value = tableColumnTemplateRowsFromSettings(DEFAULT_EDITOR_SETTINGS.tableColumnTemplateFields);
+  editShortcuts.value = normalizeShortcutSettings(DEFAULT_EDITOR_SETTINGS.shortcuts);
+  editSqlFormatter.value = normalizeSqlFormatterSettings(DEFAULT_EDITOR_SETTINGS.sqlFormatter);
+  sqlFormatterConfigValid.value = true;
+  editSidebarActivation.value = DEFAULT_EDITOR_SETTINGS.sidebarActivation;
+  editSidebarObjectDisplay.value = DEFAULT_EDITOR_SETTINGS.sidebarObjectDisplay;
+  editSidebarTableSearchEnabled.value = DEFAULT_EDITOR_SETTINGS.sidebarTableSearchEnabled;
+  editAutoSelectActiveSidebarNode.value = DEFAULT_EDITOR_SETTINGS.autoSelectActiveSidebarNode;
+  editOpenTabsRestoreMode.value = DEFAULT_EDITOR_SETTINGS.openTabsRestoreMode;
+  editDisconnectTabHandlingMode.value = DEFAULT_EDITOR_SETTINGS.disconnectTabHandlingMode;
+  editReuseDataTab.value = DEFAULT_EDITOR_SETTINGS.reuseDataTab;
+  editUpdateNotificationsEnabled.value = DEFAULT_EDITOR_SETTINGS.updateNotificationsEnabled;
+  editSidebarHideTableComments.value = DEFAULT_EDITOR_SETTINGS.sidebarHideTableComments;
+  editSidebarAllowHorizontalScroll.value = DEFAULT_EDITOR_SETTINGS.sidebarAllowHorizontalScroll;
+  editSidebarHiddenTablePrefixes.value = DEFAULT_EDITOR_SETTINGS.sidebarHiddenTablePrefixes.join("\n");
+  editExportBatchSize.value = DEFAULT_EDITOR_SETTINGS.exportBatchSize;
+  editExportRowLimitEnabled.value = DEFAULT_EDITOR_SETTINGS.exportRowLimitEnabled;
+  editExportRowLimit.value = DEFAULT_EDITOR_SETTINGS.exportRowLimit;
+  editQueryExportKeysetOptimizationEnabled.value = DEFAULT_EDITOR_SETTINGS.queryExportKeysetOptimizationEnabled;
+  editUpdateDownloadSource.value = DEFAULT_EDITOR_SETTINGS.updateDownloadSource;
+  editToolbarItems.value = { ...DEFAULT_EDITOR_SETTINGS.toolbarItems };
+  editSnippets.value = DEFAULT_SQL_SNIPPETS.map((s) => ({ ...s }));
+}
+
+function addTableColumnTemplateRow() {
+  const row = createEmptyTableColumnTemplateRow();
+  row.overrides.push({
+    id: uuid(),
+    databaseType: editTableColumnTemplateDatabaseType.value,
+    dataType: "",
+  });
+  editTableColumnTemplateRows.value.push(row);
+}
+
+function removeTableColumnTemplateRow(id: string) {
+  const row = editTableColumnTemplateRows.value.find((item) => item.id === id);
+  if (!row) return;
+  if (row.overrides.some((override) => override.databaseType === editTableColumnTemplateDatabaseType.value)) {
+    row.overrides = row.overrides.filter((override) => override.databaseType !== editTableColumnTemplateDatabaseType.value);
+    if (row.overrides.length > 0) return;
+  }
+  editTableColumnTemplateRows.value = editTableColumnTemplateRows.value.filter((item) => item.id !== id);
+}
+
+function moveTableColumnTemplateRow(sourceId: string, targetId: string, placement: "before" | "after") {
+  if (!sourceId || sourceId === targetId) return;
+  const rows = [...editTableColumnTemplateRows.value];
+  const sourceIndex = rows.findIndex((row) => row.id === sourceId);
+  const targetIndex = rows.findIndex((row) => row.id === targetId);
+  if (sourceIndex === -1 || targetIndex === -1) return;
+  const [source] = rows.splice(sourceIndex, 1);
+  if (!source) return;
+  const nextTargetIndex = rows.findIndex((row) => row.id === targetId);
+  const insertIndex = placement === "after" ? nextTargetIndex + 1 : nextTargetIndex;
+  rows.splice(nextTargetIndex === -1 ? rows.length : insertIndex, 0, source);
+  editTableColumnTemplateRows.value = rows;
+}
+
+function cleanupTableColumnTemplatePointerDrag() {
+  tableColumnTemplatePointerDragCleanup?.();
+  tableColumnTemplatePointerDragCleanup = null;
+  draggedTableColumnTemplateRowId.value = null;
+  document.body.style.cursor = "";
+  document.body.style.userSelect = "";
+}
+
+function startTableColumnTemplateRowDrag(id: string, event: PointerEvent) {
+  if (event.button !== 0) return;
+  event.preventDefault();
+  cleanupTableColumnTemplatePointerDrag();
+  draggedTableColumnTemplateRowId.value = id;
+  document.body.style.cursor = "grabbing";
+  document.body.style.userSelect = "none";
+
+  const onPointerMove = (moveEvent: PointerEvent) => {
+    const sourceId = draggedTableColumnTemplateRowId.value;
+    if (!sourceId) return;
+    const targetRow = document.elementFromPoint(moveEvent.clientX, moveEvent.clientY)?.closest<HTMLElement>("[data-table-column-template-row-id]");
+    const targetId = targetRow?.dataset.tableColumnTemplateRowId;
+    if (!targetRow || !targetId || targetId === sourceId) return;
+    const rect = targetRow.getBoundingClientRect();
+    moveTableColumnTemplateRow(sourceId, targetId, moveEvent.clientY > rect.top + rect.height / 2 ? "after" : "before");
+  };
+  const onPointerUp = () => cleanupTableColumnTemplatePointerDrag();
+
+  window.addEventListener("pointermove", onPointerMove);
+  window.addEventListener("pointerup", onPointerUp, { once: true });
+  window.addEventListener("pointercancel", onPointerUp, { once: true });
+  tableColumnTemplatePointerDragCleanup = () => {
+    window.removeEventListener("pointermove", onPointerMove);
+    window.removeEventListener("pointerup", onPointerUp);
+    window.removeEventListener("pointercancel", onPointerUp);
+  };
+}
+
+function tableColumnTemplateTypeOptions(databaseType: DatabaseType): string[] {
+  return getDataTypeOptions(databaseType);
+}
+
+function tableColumnTemplateDataTypeForSelectedDatabase(row: TableColumnTemplateGridRow): string {
+  return row.overrides.find((override) => override.databaseType === editTableColumnTemplateDatabaseType.value)?.dataType ?? "";
+}
+
+function tableColumnTemplateBaseTypeForSelectedDatabase(row: TableColumnTemplateGridRow): string {
+  return splitDataType(tableColumnTemplateDataTypeForSelectedDatabase(row)).baseType;
+}
+
+function tableColumnTemplateLengthForSelectedDatabase(row: TableColumnTemplateGridRow): string {
+  return dataTypeLengthInputValue(editTableColumnTemplateDatabaseType.value, tableColumnTemplateDataTypeForSelectedDatabase(row));
+}
+
+function setTableColumnTemplateDataTypeForSelectedDatabase(row: TableColumnTemplateGridRow, value: string) {
+  const dataType = value.trim();
+  const databaseType = editTableColumnTemplateDatabaseType.value;
+  const existing = row.overrides.find((override) => override.databaseType === databaseType);
+  if (!dataType) {
+    row.overrides = row.overrides.filter((override) => override.databaseType !== databaseType);
+    return;
+  }
+  if (existing) {
+    existing.dataType = dataType;
+  } else {
+    row.overrides.push({ id: uuid(), databaseType, dataType });
+  }
+}
+
+function setTableColumnTemplateBaseTypeForSelectedDatabase(row: TableColumnTemplateGridRow, value: string) {
+  const baseType = value.trim();
+  if (!baseType) {
+    setTableColumnTemplateDataTypeForSelectedDatabase(row, "");
+    return;
+  }
+  const databaseType = editTableColumnTemplateDatabaseType.value;
+  setTableColumnTemplateDataTypeForSelectedDatabase(row, combineDataTypeForDatabase(databaseType, baseType, getDefaultLengthForType(databaseType, baseType)));
+}
+
+function setTableColumnTemplateLengthForSelectedDatabase(row: TableColumnTemplateGridRow, value: string) {
+  const databaseType = editTableColumnTemplateDatabaseType.value;
+  const baseType = tableColumnTemplateBaseTypeForSelectedDatabase(row);
+  if (!baseType || isDataTypeLengthDisabled(databaseType, baseType)) return;
+  setTableColumnTemplateDataTypeForSelectedDatabase(row, combineDataTypeForDatabase(databaseType, baseType, value));
+}
+
+function isTableColumnTemplateLengthDisabled(row: TableColumnTemplateGridRow): boolean {
+  const baseType = tableColumnTemplateBaseTypeForSelectedDatabase(row);
+  return !baseType || isDataTypeLengthDisabled(editTableColumnTemplateDatabaseType.value, baseType);
+}
+
+function onExecuteModeChange(v: any) {
+  if (v === "all" || v === "current") editExecuteMode.value = v;
+}
+
+function onSqlSemanticDiagnosticsEnabledChange(value: boolean) {
+  editSqlSemanticDiagnosticsEnabled.value = value;
+  editSqlSemanticDiagnosticsMode.value = value ? "enabled" : "disabled";
+}
+
+function onFontFamilyChange(v: any) {
+  if (typeof v === "string") editFontFamily.value = v;
+}
+
+function onUiFontFamilyChange(v: any) {
+  if (typeof v === "string") editUiFontFamily.value = v;
+}
+
+const themeSelectValue = computed(() => {
+  if (editTheme.value === "custom") {
+    return `custom:${editActiveCustomThemeId.value}`;
+  }
+  return editTheme.value;
+});
+
+const themeSelectOptions = computed(() => [
+  ...EDITOR_THEMES.filter((theme) => theme.value !== "custom").map((theme) => ({
+    value: theme.value,
+    label: theme.value === "app" ? t("settings.followAppTheme") : theme.label,
+    dark: theme.dark,
+    isCustom: false,
+  })),
+  ...editCustomThemes.value.map((theme) => ({
+    value: `custom:${theme.id}`,
+    label: theme.name,
+    dark: true,
+    isCustom: true,
+  })),
+]);
+
+function onThemeChange(v: any) {
+  if (typeof v !== "string") return;
+  if (v.startsWith("custom:")) {
+    editTheme.value = "custom";
+    editActiveCustomThemeId.value = v.slice(7);
+  } else {
+    editTheme.value = v as typeof DEFAULT_EDITOR_SETTINGS.theme;
+  }
+}
+
+function handleThemeSave(updatedThemes: CustomTheme[], activeId: string) {
+  editCustomThemes.value = updatedThemes;
+  editActiveCustomThemeId.value = activeId;
+  editTheme.value = "custom";
+  showThemeCustomizer.value = false;
+}
+
+function onDisconnectTabHandlingModeChange(v: any) {
+  if (v === "close-tabs" || v === "keep-tabs-clear-results" || v === "keep-tabs-keep-results") {
+    editDisconnectTabHandlingMode.value = v;
+  }
+}
+
+function onLocaleChange(v: any) {
+  if (typeof v === "string") void setLocale(v as Locale);
+}
+
+function onUpdateDownloadSourceChange(v: any) {
+  if (v === "official" || v === "cnb" || v === "atomgit") editUpdateDownloadSource.value = v;
+}
+
+function setSidebarObjectDisplay(value: "grouped" | "simple") {
+  editSidebarObjectDisplay.value = value;
+}
+
+function setIconTheme(value: DesktopIconTheme) {
+  editIconTheme.value = value;
+}
+
+function onShortcutChange(actionId: ShortcutActionId, value: any) {
+  if (typeof value !== "string") return;
+  const definition = SHORTCUT_DEFINITIONS.find((item) => item.id === actionId);
+  if (!definition) return;
+  editShortcuts.value = { ...editShortcuts.value, [actionId]: value };
+}
+
+function onShortcutKeydown(actionId: ShortcutActionId, event: KeyboardEvent) {
+  event.preventDefault();
+  event.stopPropagation();
+  if (editingShortcutId.value !== actionId) return;
+  if (event.key === "Escape") {
+    editingShortcutId.value = null;
+    return;
+  }
+  const shortcut = eventToShortcut(event);
+  if (!shortcut) return;
+  onShortcutChange(actionId, shortcut);
+  editingShortcutId.value = null;
+}
+
+function formatShortcutPill(shortcut: string): string {
+  return formatShortcutDisplay(shortcut);
+}
+
+const shortcutPressShortcutLabel = computed(() => t("settings.shortcutPressShortcut"));
+const shortcutPressShortcutInputWidth = computed(() => `${shortcutPressShortcutLabel.value.length + 2}em`);
+
+function focusShortcutInput(actionId: ShortcutActionId) {
+  editingShortcutId.value = actionId;
+  const input = document.querySelector<HTMLInputElement>(`[data-shortcut-input="${actionId}"]`);
+  requestAnimationFrame(() => {
+    input?.focus();
+    input?.select();
+  });
+}
+
+function cancelShortcutEdit() {
+  editingShortcutId.value = null;
+}
+
+function resetShortcut(actionId: ShortcutActionId) {
+  const definition = SHORTCUT_DEFINITIONS.find((item) => item.id === actionId);
+  if (!definition) return;
+  editShortcuts.value = { ...editShortcuts.value, [actionId]: definition.defaultShortcut };
+}
+
+function clearShortcut(actionId: ShortcutActionId) {
+  editShortcuts.value = { ...editShortcuts.value, [actionId]: "" };
+}
+
+function setAppLayout(value: InterfaceLayout) {
+  editAppLayout.value = value;
+}
+
+function setSidebarActivation(value: "single" | "double") {
+  editSidebarActivation.value = value;
+}
+
+const activeSettingsTab = ref("appearance");
+const isWeb = !isTauriRuntime();
+const appSupportInfo = ref<AppSupportInfo | null>(null);
+const appSupportInfoLoading = ref(false);
+const appSupportInfoError = ref("");
+const appSupportInfoCopied = ref(false);
+const appSupportInfoLabels = computed<AppSupportInfoLabels>(() => ({
+  appVersion: t("settings.supportInfoAppVersion"),
+  runtime: t("settings.supportInfoRuntime"),
+  runtimeDesktop: t("settings.supportInfoRuntimeDesktop"),
+  runtimeWeb: t("settings.supportInfoRuntimeWeb"),
+  operatingSystem: t("settings.supportInfoOperatingSystem"),
+  architecture: t("settings.supportInfoArchitecture"),
+  unknown: t("settings.supportInfoUnknown"),
+}));
+const appSupportInfoRows = computed(() => (appSupportInfo.value ? buildAppSupportInfoRows(appSupportInfo.value, appSupportInfoLabels.value) : []));
+type SettingsCategory = "editor" | "formatter" | "appearance" | "navigation" | "data" | "tunnels" | "shortcuts" | "snippets" | "sync" | "ai" | "mcp" | "security" | "about";
+const settingsCategoryNav = computed<{ value: SettingsCategory; label: string }[]>(() => [
+  { value: "appearance", label: t("settings.appearanceTab") },
+  { value: "editor", label: t("settings.editorTab") },
+  { value: "formatter", label: t("settings.sqlFormatterTab") },
+  { value: "navigation", label: t("settings.navigationTab") },
+  { value: "data", label: t("settings.dataTab") },
+  { value: "tunnels", label: t("settings.tunnelsTab") },
+  { value: "shortcuts", label: t("settings.shortcutsTab") },
+  { value: "snippets", label: t("settings.snippetsTab") },
+  ...(isWeb ? [] : [{ value: "sync" as const, label: t("settings.syncTab") }]),
+  { value: "ai", label: t("settings.aiTab") },
+  ...(isWeb ? [] : [{ value: "mcp" as const, label: t("settings.mcpTab") }]),
+  ...(isWeb ? [{ value: "security" as const, label: t("settings.securityTab") }] : []),
+  { value: "about", label: t("settings.aboutTab") },
+]);
+const settingsTabsWithApplyFooter = new Set<SettingsCategory>(["editor", "formatter", "appearance", "navigation", "data", "shortcuts", "snippets"]);
+
+function hasSettingsApplyFooter(value: SettingsCategory): boolean {
+  return settingsTabsWithApplyFooter.has(value);
+}
+
+function settingsCategoryButton(value: SettingsCategory): string {
+  return [
+    "settings-category-button w-auto shrink-0 whitespace-nowrap rounded-md px-3 py-2 text-left text-sm transition-colors lg:w-full",
+    value === activeSettingsTab.value ? "settings-category-button--active bg-primary text-primary-foreground shadow-sm" : "text-muted-foreground hover:bg-muted hover:text-foreground",
+  ].join(" ");
+}
+
+function openExternalUrl(url: string) {
+  if (isTauriRuntime()) {
+    import("@tauri-apps/plugin-shell").then(({ open }) => open(url));
+  } else {
+    window.open(url, "_blank", "noopener,noreferrer");
+  }
+}
+
+async function copyDebugLogs() {
+  await copyToClipboard(await getDebugLogBundleText());
+  debugLogCopied.value = true;
+  window.setTimeout(() => {
+    debugLogCopied.value = false;
+  }, 1500);
+}
+
+function fallbackAppSupportInfo(): AppSupportInfo {
+  return {
+    appVersion: props.appVersion || "",
+    runtime: isWeb ? "web" : "desktop",
+    osName: "",
+    osVersion: null,
+    arch: "",
+  };
+}
+
+async function refreshAppSupportInfo() {
+  if (appSupportInfoLoading.value) return;
+  appSupportInfoLoading.value = true;
+  appSupportInfoError.value = "";
+  try {
+    appSupportInfo.value = await getAppSupportInfo();
+  } catch (e: any) {
+    appSupportInfo.value = appSupportInfo.value || fallbackAppSupportInfo();
+    appSupportInfoError.value = e?.message || String(e);
+  } finally {
+    appSupportInfoLoading.value = false;
+  }
+}
+
+async function copyAppSupportInfo() {
+  if (!appSupportInfo.value) await refreshAppSupportInfo();
+  if (!appSupportInfo.value) return;
+  try {
+    await copyToClipboard(formatAppSupportInfoForClipboard(appSupportInfo.value, appSupportInfoLabels.value));
+    appSupportInfoCopied.value = true;
+    window.setTimeout(() => {
+      appSupportInfoCopied.value = false;
+    }, 1500);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function clearDebugLogs() {
+  clearStoredDebugLogs();
+  debugLogCopied.value = false;
+  debugLogDownloaded.value = false;
+}
+
+async function exportDebugLogs() {
+  const saved = await downloadDebugLogs();
+  if (!saved) return;
+  debugLogDownloaded.value = true;
+  window.setTimeout(() => {
+    debugLogDownloaded.value = false;
+  }, 1500);
+}
+
+// ---------- MCP Server ----------
+type McpConfigTab = "claude" | "cursor" | "trae" | "vscode" | "windsurf" | "codex" | "opencode";
+type McpCopyKind = "install" | `${McpConfigTab}-config`;
+
+const mcpStatus = ref<McpServerStatus | null>(null);
+const mcpStatusLoading = ref(false);
+const mcpStatusError = ref("");
+const mcpCopied = ref<"" | McpCopyKind>("");
+const mcpConfigTab = ref<McpConfigTab>("claude");
+const MCP_READONLY_STORAGE_KEY = "dbx-mcp-config-readonly";
+const MCP_ALLOW_DANGEROUS_STORAGE_KEY = "dbx-mcp-config-allow-dangerous";
+const mcpReadonlyMode = ref(localStorage.getItem(MCP_READONLY_STORAGE_KEY) === "true");
+const mcpAllowDangerous = ref(localStorage.getItem(MCP_ALLOW_DANGEROUS_STORAGE_KEY) === "true");
+const mcpInstalling = ref(false);
+const mcpInstallMessage = ref("");
+const mcpInstallError = ref(false);
+
+const mcpEnvEntries = computed<McpEnvEntry[]>(() => {
+  const entries: McpEnvEntry[] = [];
+  if (mcpReadonlyMode.value) {
+    entries.push(["DBX_MCP_ALLOW_WRITES", "0"]);
+  }
+  if (!mcpReadonlyMode.value && mcpAllowDangerous.value) {
+    entries.push(["DBX_MCP_ALLOW_DANGEROUS_SQL", "1"]);
+  }
+  return entries;
+});
+
+const mcpLaunchConfig = computed<McpLaunchConfig | undefined>(() => {
+  if (!isWindows() || !mcpStatus.value?.script_path) return undefined;
+  return {
+    command: mcpStatus.value.node_path || "node",
+    args: [mcpStatus.value.script_path],
+  };
+});
+
+const mcpJsonRecommendedConfig = computed(() => buildMcpJsonConfig(mcpEnvEntries.value, mcpLaunchConfig.value));
+
+const mcpVsCodeRecommendedConfig = computed(() => buildMcpVsCodeConfig(mcpEnvEntries.value, mcpLaunchConfig.value));
+
+const mcpCodexRecommendedConfig = computed(() => buildMcpCodexConfig(mcpEnvEntries.value, mcpLaunchConfig.value));
+
+const mcpOpenCodeRecommendedConfig = computed(() => buildMcpOpenCodeConfig(mcpEnvEntries.value, mcpLaunchConfig.value));
+
+const mcpStatusTone = computed<"ok" | "warning" | "muted">(() => {
+  if (!mcpStatus.value) return "muted";
+  if (!mcpStatus.value.installed || mcpStatus.value.update_available || mcpStatus.value.error) return "warning";
+  return "ok";
+});
+
+const mcpStatusLabel = computed(() => {
+  if (mcpStatusLoading.value) return t("settings.mcpChecking");
+  if (mcpStatusError.value) return t("settings.mcpStatusError");
+  if (!mcpStatus.value) return t("settings.mcpStatusUnknown");
+  if (!mcpStatus.value.installed) return t("settings.mcpNotInstalled");
+  if (mcpStatus.value.update_available) return t("settings.mcpUpdateAvailable");
+  return t("settings.mcpReady");
+});
+
+const mcpCommand = computed(() => {
+  if (!mcpStatus.value) return "npm install -g @dbx-app/mcp-server@latest --registry=https://registry.npmjs.org";
+  return mcpStatus.value.installed ? mcpStatus.value.update_command : mcpStatus.value.install_command;
+});
+
+watch(mcpReadonlyMode, (value) => {
+  localStorage.setItem(MCP_READONLY_STORAGE_KEY, String(value));
+  if (value) mcpAllowDangerous.value = false;
+});
+
+watch(mcpAllowDangerous, (value) => {
+  localStorage.setItem(MCP_ALLOW_DANGEROUS_STORAGE_KEY, String(value));
+});
+
+async function refreshMcpStatus() {
+  if (mcpStatusLoading.value) return;
+  mcpStatusLoading.value = true;
+  mcpStatusError.value = "";
+  try {
+    mcpStatus.value = await checkMcpServerStatus();
+  } catch (e: any) {
+    mcpStatusError.value = e?.message || String(e);
+  } finally {
+    mcpStatusLoading.value = false;
+  }
+}
+
+async function copyMcpText(kind: McpCopyKind, value: string) {
+  mcpCopied.value = kind;
+  try {
+    await copyToClipboard(value);
+  } catch {
+    mcpCopied.value = "";
+    return;
+  }
+  window.setTimeout(() => {
+    if (mcpCopied.value === kind) mcpCopied.value = "";
+  }, 1500);
+}
+
+async function installMcp() {
+  if (mcpInstalling.value) return;
+  mcpInstalling.value = true;
+  mcpInstallMessage.value = "";
+  mcpInstallError.value = false;
+  try {
+    const result = await installMcpServer();
+    mcpInstallMessage.value = result;
+    mcpInstallError.value = false;
+    // 安装成功后刷新状态
+    await refreshMcpStatus();
+  } catch (e: any) {
+    mcpInstallMessage.value = e?.message || String(e);
+    mcpInstallError.value = true;
+  } finally {
+    mcpInstalling.value = false;
+    // 3秒后清除消息
+    window.setTimeout(() => {
+      mcpInstallMessage.value = "";
+      mcpInstallError.value = false;
+    }, 3000);
+  }
+}
+
+// ---------- WebDAV Sync ----------
+const webdavEndpoint = ref(localStorage.getItem("dbx-webdav-endpoint") || "");
+const webdavUsername = ref(localStorage.getItem("dbx-webdav-username") || "");
+const webdavPassword = ref("");
+const webdavRememberPassword = ref(localStorage.getItem("dbx-webdav-remember-password") === "true");
+const webdavHasSavedPassword = ref(false);
+const webdavRemotePath = ref(localStorage.getItem("dbx-webdav-remote-path") || DEFAULT_WEB_DAV_REMOTE_PATH);
+const webdavSyncSecrets = ref(false);
+const webdavSecretsPassphrase = ref("");
+const webdavHasSavedSecretsPassphrase = ref(false);
+const webdavAutoUploadEnabled = ref(localStorage.getItem("dbx-webdav-auto-upload-enabled") === "true");
+const webdavAutoUploadIntervalMinutes = ref(Number(localStorage.getItem("dbx-webdav-auto-upload-interval-minutes") || String(DEFAULT_WEB_DAV_AUTO_UPLOAD_INTERVAL_MINUTES)));
+const webdavBusy = ref<"" | "test" | "upload" | "download">("");
+const webdavMessage = ref("");
+const webdavError = ref(false);
+const syncMethodTab = ref<"webdav" | "snippet">("webdav");
+
+const snippetProvider = ref<SnippetProvider>((localStorage.getItem("dbx-snippet-provider") as SnippetProvider) || "github");
+const snippetId = ref(localStorage.getItem(`dbx-snippet-id-${snippetProvider.value}`) || "");
+const snippetToken = ref("");
+const snippetRememberToken = ref(localStorage.getItem(`dbx-snippet-remember-token-${snippetProvider.value}`) === "true");
+const snippetHasSavedToken = ref(false);
+const snippetBusy = ref<"" | "test" | "upload" | "download">("");
+const snippetMessage = ref("");
+const snippetError = ref(false);
+
+const webdavReady = computed(() => !!webdavEndpoint.value.trim() && !webdavBusy.value && (!webdavSyncSecrets.value || !!webdavSecretsPassphrase.value.trim() || webdavHasSavedSecretsPassphrase.value));
+const snippetReady = computed(() => !snippetBusy.value && (!!snippetToken.value.trim() || snippetHasSavedToken.value));
+
+function currentSnippetConfig(): SnippetSyncConfig {
+  return {
+    provider: snippetProvider.value,
+    token: snippetToken.value.trim() || undefined,
+    snippetId: snippetId.value.trim() || undefined,
+  };
+}
+
+function currentSnippetAccountConfig(): SnippetSyncConfig {
+  return { ...currentSnippetConfig(), token: undefined };
+}
+
+async function refreshSnippetTokenStatus() {
+  try {
+    const status = await snippetTokenStatus(currentSnippetAccountConfig());
+    snippetHasSavedToken.value = status.hasSavedToken;
+    if (status.hasSavedToken) snippetRememberToken.value = true;
+  } catch {
+    snippetHasSavedToken.value = false;
+  }
+}
+
+async function applySnippetTokenPreference() {
+  const token = snippetToken.value.trim();
+  if (snippetRememberToken.value && token) {
+    await saveSnippetSavedToken(currentSnippetAccountConfig(), token);
+    snippetHasSavedToken.value = true;
+    return;
+  }
+  if (!snippetRememberToken.value && snippetHasSavedToken.value) {
+    await forgetSnippetSavedToken(currentSnippetAccountConfig());
+    snippetHasSavedToken.value = false;
+  }
+}
+
+async function runSnippetAction(kind: "test" | "upload" | "download", action: () => Promise<string>) {
+  snippetBusy.value = kind;
+  snippetMessage.value = "";
+  snippetError.value = false;
+  try {
+    localStorage.setItem("dbx-snippet-provider", snippetProvider.value);
+    localStorage.setItem(`dbx-snippet-id-${snippetProvider.value}`, snippetId.value.trim());
+    localStorage.setItem(`dbx-snippet-remember-token-${snippetProvider.value}`, String(snippetRememberToken.value));
+    await applySnippetTokenPreference();
+    await applyWebDavSyncSecretsPreference();
+    snippetMessage.value = await action();
+  } catch (e: any) {
+    snippetMessage.value = e?.message || String(e);
+    snippetError.value = true;
+  } finally {
+    snippetBusy.value = "";
+  }
+}
+
+async function testSnippetSync() {
+  await runSnippetAction("test", async () => {
+    await snippetSyncTest(currentSnippetConfig());
+    return t("settings.syncSnippetTestSuccess");
+  });
+}
+
+async function uploadSnippetSnapshot() {
+  await runSnippetAction("upload", async () => {
+    const summary = await snippetSyncUpload(currentSnippetConfig(), settingsStore.editorSettings, webdavSyncSecrets.value ? webdavSecretsPassphrase.value : undefined);
+    snippetId.value = summary.snippetId;
+    localStorage.setItem(`dbx-snippet-id-${snippetProvider.value}`, summary.snippetId);
+    return t("settings.syncSnippetUploadSuccess", { bytes: summary.bytes, id: summary.snippetId });
+  });
+}
+
+async function downloadSnippetSnapshot() {
+  if (!snippetId.value.trim() || !window.confirm(t("settings.syncDownloadConfirm"))) return;
+  await runSnippetAction("download", async () => {
+    const result = await snippetSyncDownload(currentSnippetConfig(), webdavSyncSecrets.value ? webdavSecretsPassphrase.value : undefined);
+    if (result.editorSettings && typeof result.editorSettings === "object") settingsStore.updateEditorSettings(result.editorSettings as any);
+    await settingsStore.updateDesktopSettings(result.desktopSettings);
+    await connectionStore.initFromDisk();
+    await savedSqlStore.initFromStorage();
+    let message = t("settings.syncSnippetDownloadSuccess", { bytes: result.summary.bytes, id: result.summary.snippetId });
+    if (result.applySummary.encryptedSecretsPresent && !result.applySummary.secretsApplied) message += ` ${t("settings.syncSecretsSkipped")}`;
+    if (result.applySummary.secretsApplied) message += ` ${t("settings.syncSecretsApplied")}`;
+    return message;
+  });
+}
+
+function currentWebDavConfig(): WebDavConfig {
+  return {
+    endpoint: webdavEndpoint.value.trim(),
+    username: webdavUsername.value.trim() || undefined,
+    password: webdavPassword.value || undefined,
+    remotePath: webdavRemotePath.value.trim() || DEFAULT_WEB_DAV_REMOTE_PATH,
+  };
+}
+
+function currentWebDavAccountConfig(): WebDavConfig {
+  const config = currentWebDavConfig();
+  return { ...config, password: undefined };
+}
+
+function rememberWebDavFields() {
+  writeWebDavAutoUploadFields(currentWebDavConfig(), {
+    enabled: webdavAutoUploadEnabled.value,
+    intervalMinutes: webdavAutoUploadIntervalMinutes.value,
+  });
+  window.dispatchEvent(new Event("dbx:webdav-auto-upload-config-changed"));
+}
+
+function setWebDavResult(message: string, error = false) {
+  webdavMessage.value = message;
+  webdavError.value = error;
+}
+
+async function runWebDavAction(kind: "test" | "upload" | "download", action: () => Promise<string>) {
+  webdavBusy.value = kind;
+  webdavMessage.value = "";
+  webdavError.value = false;
+  try {
+    rememberWebDavFields();
+    await applyWebDavPasswordPreference();
+    await applyWebDavSyncSecretsPreference();
+    setWebDavResult(await action());
+  } catch (e: any) {
+    setWebDavResult(e?.message || String(e), true);
+  } finally {
+    webdavBusy.value = "";
+  }
+}
+
+async function refreshWebDavPasswordStatus() {
+  if (!webdavEndpoint.value.trim()) {
+    webdavHasSavedPassword.value = false;
+    webdavRememberPassword.value = false;
+    return;
+  }
+  try {
+    const status = await webdavPasswordStatus(currentWebDavAccountConfig());
+    webdavHasSavedPassword.value = status.hasSavedPassword;
+    if (status.hasSavedPassword) webdavRememberPassword.value = true;
+  } catch {
+    webdavHasSavedPassword.value = false;
+  }
+}
+
+async function applyWebDavPasswordPreference() {
+  const password = webdavPassword.value;
+  if (webdavRememberPassword.value && password) {
+    await saveWebdavSavedPassword(currentWebDavAccountConfig(), password);
+    webdavHasSavedPassword.value = true;
+    return;
+  }
+  if (!webdavRememberPassword.value && webdavHasSavedPassword.value) {
+    await forgetWebdavSavedPassword(currentWebDavAccountConfig());
+    webdavHasSavedPassword.value = false;
+  }
+}
+
+async function refreshWebDavSyncSecretsStatus() {
+  try {
+    const status = await webdavSyncSecretsStatus();
+    webdavSyncSecrets.value = status.enabled;
+    webdavHasSavedSecretsPassphrase.value = status.hasSavedPassphrase;
+  } catch {
+    webdavSyncSecrets.value = false;
+    webdavHasSavedSecretsPassphrase.value = false;
+  }
+}
+
+async function applyWebDavSyncSecretsPreference() {
+  const passphrase = webdavSecretsPassphrase.value.trim();
+  if (!webdavSyncSecrets.value) {
+    await saveWebdavSyncSecretsPreference(false);
+    return;
+  }
+  await saveWebdavSyncSecretsPreference(true, passphrase || undefined);
+  if (passphrase) {
+    webdavHasSavedSecretsPassphrase.value = true;
+    webdavSecretsPassphrase.value = "";
+  }
+}
+
+async function clearWebDavSyncSecretsPassphrase() {
+  try {
+    await forgetWebdavSyncSecretsPassphrase();
+    webdavHasSavedSecretsPassphrase.value = false;
+    webdavSecretsPassphrase.value = "";
+  } catch (e: any) {
+    setWebDavResult(e?.message || String(e), true);
+  }
+}
+
+async function testWebDav() {
+  await runWebDavAction("test", async () => {
+    await webdavSyncTest(currentWebDavConfig());
+    return t("settings.syncTestSuccess");
+  });
+}
+
+async function uploadWebDavSnapshot() {
+  await runWebDavAction("upload", async () => {
+    const summary = await webdavSyncUpload(currentWebDavConfig(), settingsStore.editorSettings, webdavSyncSecrets.value ? webdavSecretsPassphrase.value : undefined);
+    return t("settings.syncUploadSuccess", { bytes: summary.bytes, path: summary.remotePath });
+  });
+}
+
+async function downloadWebDavSnapshot() {
+  if (!window.confirm(t("settings.syncDownloadConfirm"))) return;
+  await runWebDavAction("download", async () => {
+    const result = await webdavSyncDownload(currentWebDavConfig(), webdavSyncSecrets.value ? webdavSecretsPassphrase.value : undefined);
+    if (result.editorSettings && typeof result.editorSettings === "object") {
+      settingsStore.updateEditorSettings(result.editorSettings as any);
+    }
+    await settingsStore.updateDesktopSettings(result.desktopSettings);
+    await connectionStore.initFromDisk();
+    await savedSqlStore.initFromStorage();
+    const message = t("settings.syncDownloadSuccess", {
+      bytes: result.summary.bytes,
+      path: result.summary.remotePath,
+    });
+    if (result.applySummary.encryptedSecretsPresent && !result.applySummary.secretsApplied) {
+      return `${message} ${t("settings.syncSecretsSkipped")}`;
+    }
+    if (result.applySummary.secretsApplied) {
+      return `${message} ${t("settings.syncSecretsApplied")}`;
+    }
+    return message;
+  });
+}
+
+const oldPassword = ref("");
+const newPassword = ref("");
+const confirmNewPassword = ref("");
+const passwordMessage = ref("");
+const passwordError = ref(false);
+const changingPassword = ref(false);
+
+async function scrollToInitialSettingsSection() {
+  await nextTick();
+  if (props.initialSection === "tableColumnTemplates") {
+    tableColumnTemplateSectionRef.value?.scrollIntoView({ block: "center", behavior: "smooth" });
+  }
+}
+
+watch(
+  () => settingsVisible.value,
+  async (open) => {
+    if (open) {
+      activeSettingsTab.value = props.initialTab || "appearance";
+      passwordMessage.value = "";
+      oldPassword.value = "";
+      newPassword.value = "";
+      confirmNewPassword.value = "";
+      await settingsStore.initAiConfig();
+      await settingsStore.initDesktopSettings();
+      editShowTrayIcon.value = settingsStore.desktopSettings.show_tray_icon;
+      editQuitOnClose.value = settingsStore.desktopSettings.quit_on_close;
+      editIconTheme.value = settingsStore.desktopSettings.icon_theme;
+      editDebugLoggingEnabled.value = settingsStore.desktopSettings.debug_logging_enabled;
+      editDuckDbWorkerProcessIsolation.value = settingsStore.desktopSettings.duckdb_worker_process_isolation;
+      editDuckDbWorkerMaxProcesses.value = settingsStore.desktopSettings.duckdb_worker_max_processes;
+      if (!duckDbWorkerStartupCaptured.value) {
+        startupDuckDbWorkerProcessIsolation.value = settingsStore.desktopSettings.duckdb_worker_process_isolation;
+        startupDuckDbWorkerMaxProcesses.value = settingsStore.desktopSettings.duckdb_worker_max_processes;
+        duckDbWorkerStartupCaptured.value = true;
+      }
+      editSidebarTablePageSize.value = settingsStore.desktopSettings.sidebar_table_page_size ?? DEFAULT_SIDEBAR_TABLE_PAGE_SIZE;
+      webdavPassword.value = "";
+      snippetToken.value = "";
+      webdavSecretsPassphrase.value = "";
+      await refreshWebDavPasswordStatus();
+      await refreshWebDavSyncSecretsStatus();
+      await refreshSnippetTokenStatus();
+      syncAiEditState();
+      if (!isWeb && activeSettingsTab.value === "mcp") void refreshMcpStatus();
+      if (!isWeb && activeSettingsTab.value === "ai" && aiIsCodexCli.value) void ensureCodexMcpStatus();
+      if (activeSettingsTab.value === "about") void refreshAppSupportInfo();
+      await scrollToInitialSettingsSection();
+    }
+  },
+  { immediate: true },
+);
+
+watch(
+  () => props.initialSection,
+  () => {
+    if (settingsVisible.value) void scrollToInitialSettingsSection();
+  },
+);
+
+watch(
+  () => props.initialTab,
+  (tab) => {
+    if (!settingsVisible.value || !tab) return;
+    activeSettingsTab.value = tab;
+    void scrollToInitialSettingsSection();
+  },
+);
+
+watch([webdavEndpoint, webdavUsername], () => {
+  void refreshWebDavPasswordStatus();
+});
+watch(webdavRememberPassword, (val) => {
+  localStorage.setItem("dbx-webdav-remember-password", String(val));
+});
+watch([webdavAutoUploadEnabled, webdavAutoUploadIntervalMinutes], () => {
+  webdavAutoUploadIntervalMinutes.value = normalizedWebDavAutoUploadInterval(webdavAutoUploadIntervalMinutes.value);
+  rememberWebDavFields();
+});
+watch(snippetProvider, (provider) => {
+  localStorage.setItem("dbx-snippet-provider", provider);
+  snippetId.value = localStorage.getItem(`dbx-snippet-id-${provider}`) || "";
+  snippetRememberToken.value = localStorage.getItem(`dbx-snippet-remember-token-${provider}`) === "true";
+  snippetToken.value = "";
+  void refreshSnippetTokenStatus();
+});
+
+watch(activeSettingsTab, (tab) => {
+  if (tab === "mcp" && !mcpStatus.value && !mcpStatusLoading.value) void refreshMcpStatus();
+  if (tab === "ai" && aiIsCodexCli.value) void ensureCodexMcpStatus();
+  if (tab === "about" && !appSupportInfo.value) void refreshAppSupportInfo();
+  if (tab === "appearance") {
+    checkLayoutDescTruncation();
+    checkIconThemeDescTruncation();
+  }
+});
+
+onMounted(() => {
+  void refreshWebDavPasswordStatus();
+  checkLayoutDescTruncation();
+  checkIconThemeDescTruncation();
+  initTruncationObservers();
+});
+
+onUnmounted(() => {
+  cleanupTableColumnTemplatePointerDrag();
+  cleanupTruncationObservers();
+});
+
+async function changePassword() {
+  if (newPassword.value !== confirmNewPassword.value) {
+    passwordMessage.value = t("auth.passwordMismatch");
+    passwordError.value = true;
+    return;
+  }
+  changingPassword.value = true;
+  passwordMessage.value = "";
+  try {
+    const res = await fetch(apiUrl("/api/auth/change-password"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ old_password: oldPassword.value, new_password: newPassword.value }),
+    });
+    if (res.ok) {
+      passwordMessage.value = t("auth.passwordChanged");
+      passwordError.value = false;
+      oldPassword.value = "";
+      newPassword.value = "";
+      confirmNewPassword.value = "";
+    } else if (res.status === 401) {
+      passwordMessage.value = t("auth.oldPasswordWrong");
+      passwordError.value = true;
+    } else {
+      passwordMessage.value = t("auth.changePasswordFailed");
+      passwordError.value = true;
+    }
+  } catch {
+    passwordMessage.value = t("auth.connectFailed");
+    passwordError.value = true;
+  } finally {
+    changingPassword.value = false;
+  }
+}
+
+// ---------- AI Settings ----------
+const aiProviderOptions = computed(() => Object.values(AI_PROVIDER_PRESETS).filter((provider) => !isWeb || provider.provider !== "codex-cli"));
+const selectedAiProviderPreset = computed(() => AI_PROVIDER_PRESETS[aiEditProvider.value]);
+
+const aiEditProvider = ref<AiProvider>(settingsStore.aiConfig.provider);
+const aiEditApiKey = ref(settingsStore.aiConfig.apiKey);
+const aiEditAuthMethod = ref<AiAuthMethod>(settingsStore.aiConfig.authMethod || AI_PROVIDER_PRESETS[settingsStore.aiConfig.provider].authMethod);
+const aiEditEndpoint = ref(settingsStore.aiConfig.endpoint);
+const aiEditModel = ref(settingsStore.aiConfig.model);
+const aiEditApiStyle = ref<AiApiStyle>(settingsStore.aiConfig.apiStyle || "completions");
+const aiEditProxyEnabled = ref(!!settingsStore.aiConfig.proxyEnabled);
+const aiEditProxyUrl = ref(settingsStore.aiConfig.proxyUrl || "");
+const aiEditEnableThinking = ref(settingsStore.aiConfig.enableThinking ?? true);
+const aiEditReasoningLevel = ref<AiReasoningLevel>(settingsStore.aiConfig.reasoningLevel || "default");
+const aiEditContextWindow = ref<number | undefined>(settingsStore.aiConfig.contextWindow);
+const aiEditCodexCliPath = ref(settingsStore.aiConfig.codexCliPath || "");
+const aiEditCodexCliEnvRows = ref<AiEnvRow[]>(aiEnvRowsFromConfig(settingsStore.aiConfig.codexCliEnv));
+
+const aiModelOptions = ref<AiModelInfo[]>([]);
+const aiModelLoading = ref(false);
+const aiModelError = ref("");
+const aiModelLoadedSignature = ref("");
+let aiModelRequestToken = 0;
+
+const aiCompletionsMode = computed(() => aiEditApiStyle.value === "completions");
+const aiAnthropicMessagesMode = computed(() => aiEditApiStyle.value === "anthropic-messages");
+const aiReasoningLevelOptions: Array<{ value: AiReasoningLevel; labelKey: string }> = [
+  { value: "default", labelKey: "ai.reasoningLevelDefault" },
+  { value: "minimal", labelKey: "ai.reasoningLevelMinimal" },
+  { value: "low", labelKey: "ai.reasoningLevelLow" },
+  { value: "medium", labelKey: "ai.reasoningLevelMedium" },
+  { value: "high", labelKey: "ai.reasoningLevelHigh" },
+];
+
+const aiTesting = ref(false);
+const aiTestResult = ref<"" | "success" | "error">("");
+const aiTestError = ref("");
+const aiTestLatency = ref<number | null>(null);
+const aiTestErrorCopied = ref(false);
+const aiIsCodexCli = computed(() => aiEditProvider.value === "codex-cli");
+watch(aiIsCodexCli, (isCodex) => {
+  if (isCodex) void ensureCodexMcpStatus();
+});
+const aiRequiresApiKey = computed(() => AI_PROVIDER_PRESETS[aiEditProvider.value].requiresApiKey);
+const aiSupportsAuthMethod = computed(() => aiEditProvider.value === "claude" || (aiEditProvider.value === "custom" && aiAnthropicMessagesMode.value));
+const aiCredentialLabel = computed(() => (aiSupportsAuthMethod.value && aiEditAuthMethod.value === "bearer" ? "Auth Token" : "API Key"));
+const aiCredentialPlaceholder = computed(() => {
+  if (!aiRequiresApiKey.value) return "Optional";
+  if (aiSupportsAuthMethod.value && aiEditAuthMethod.value === "bearer") return "ANTHROPIC_AUTH_TOKEN";
+  return "";
+});
+const aiEndpointPlaceholder = computed(() => {
+  if (aiEditProvider.value === "custom" && aiAnthropicMessagesMode.value) {
+    return "https://api.example.com/v1/messages";
+  }
+  if (aiEditProvider.value === "openai-compatible" || aiEditProvider.value === "custom") {
+    return "https://api.example.com/v1";
+  }
+  return "https://api.openai.com/v1";
+});
+const aiEndpointHint = computed(() => {
+  if (aiEditProvider.value === "custom" && aiAnthropicMessagesMode.value) {
+    return t("ai.anthropicMessagesHint");
+  }
+  if (aiEditProvider.value === "openai-compatible" || aiEditProvider.value === "custom") {
+    return "大多数 OpenAI 兼容 API 需要 /v1 路径前缀";
+  }
+  return "";
+});
+const aiSupportsApiStyle = computed(() => !aiIsCodexCli.value && (aiEditProvider.value === "openai" || aiEditProvider.value === "openai-compatible" || aiEditProvider.value === "custom"));
+const aiSupportsAnthropicApiStyle = computed(() => aiEditProvider.value === "custom");
+const aiCodexMcpNeedsInstall = computed(() => aiIsCodexCli.value && (!mcpStatus.value || !mcpStatus.value.installed));
+const aiCodexMcpCanInstall = computed(() => {
+  const status = mcpStatus.value;
+  return !mcpInstalling.value && !!status?.npm_available && (!status.installed || status.update_available);
+});
+const aiCodexMcpActionLabel = computed(() => {
+  if (!mcpStatus.value?.installed) return t("settings.mcpInstallButton");
+  if (mcpStatus.value.update_available) return t("settings.mcpUpdateButton");
+  return t("settings.mcpUpToDate");
+});
+const aiModelListSupported = computed(() => aiEditProvider.value !== "gemini");
+const aiCanListModels = computed(() => aiModelListSupported.value && (aiIsCodexCli.value || !!aiEditEndpoint.value.trim()) && (!aiRequiresApiKey.value || !!aiEditApiKey.value.trim()));
+const aiModelOptionIds = computed(() => aiModelOptions.value.map((model) => model.id));
+const aiModelEmptyText = computed(() => {
+  if (aiModelError.value) return aiModelError.value;
+  if (!aiModelListSupported.value) return t("ai.modelListUnsupported");
+  return t("ai.noModels");
+});
+const aiCodexEnvError = computed(() => codexEnvValidationError());
+const aiCodexPathError = computed(() => {
+  const path = aiEditCodexCliPath.value.trim();
+  const firstToken = path.split(/\s+/)[0] || "";
+  return /^[A-Za-z_][A-Za-z0-9_]*=/.test(firstToken) ? t("ai.codexCliPathEnvError") : "";
+});
+const aiCodexValidationError = computed(() => (aiIsCodexCli.value ? aiCodexPathError.value || aiCodexEnvError.value : ""));
+
+function aiEnvRowsFromConfig(env: unknown): AiEnvRow[] {
+  return Object.entries(normalizeAiEnv(env)).map(([key, value]) => ({ id: uuid(), key, value }));
+}
+
+function codexEnvFromRows(): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const row of aiEditCodexCliEnvRows.value) {
+    const key = row.key.trim();
+    if (!key || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || key.toUpperCase().startsWith("DBX_MCP_")) continue;
+    result[key] = row.value;
+  }
+  return result;
+}
+
+function codexEnvSignature(): string {
+  return JSON.stringify(Object.entries(codexEnvFromRows()).sort(([left], [right]) => left.localeCompare(right)));
+}
+
+function savedCodexEnvSignature(): string {
+  return JSON.stringify(Object.entries(normalizeAiEnv(settingsStore.aiConfig.codexCliEnv)).sort(([left], [right]) => left.localeCompare(right)));
+}
+
+function codexEnvValidationError(): string {
+  for (const row of aiEditCodexCliEnvRows.value) {
+    const key = row.key.trim();
+    if (key && !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) return t("ai.codexCliEnvInvalidName", { name: key });
+    if (key.toUpperCase().startsWith("DBX_MCP_")) return t("ai.codexCliEnvReservedName", { name: key });
+  }
+  return "";
+}
+
+function addCodexEnvRow() {
+  aiEditCodexCliEnvRows.value.push({ id: uuid(), key: "", value: "" });
+}
+
+function removeCodexEnvRow(id: string) {
+  aiEditCodexCliEnvRows.value = aiEditCodexCliEnvRows.value.filter((row) => row.id !== id);
+}
+
+function clearAiModelOptions() {
+  aiModelRequestToken += 1;
+  aiModelOptions.value = [];
+  aiModelError.value = "";
+  aiModelLoadedSignature.value = "";
+  aiModelLoading.value = false;
+}
+
+function aiModelConfigSignature() {
+  return JSON.stringify({
+    provider: aiEditProvider.value,
+    endpoint: aiEditEndpoint.value.trim(),
+    apiKey: aiEditApiKey.value.trim(),
+    authMethod: aiEditAuthMethod.value,
+    proxyEnabled: aiEditProxyEnabled.value,
+    proxyUrl: aiEditProxyUrl.value.trim(),
+    codexCliPath: aiEditCodexCliPath.value.trim(),
+    codexCliEnv: codexEnvSignature(),
+  });
+}
+
+function currentAiEditConfig() {
+  return {
+    provider: aiEditProvider.value,
+    apiKey: aiEditApiKey.value,
+    authMethod: aiEditAuthMethod.value,
+    endpoint: aiEditEndpoint.value,
+    model: aiEditModel.value,
+    apiStyle: aiEditApiStyle.value,
+    proxyEnabled: aiEditProxyEnabled.value,
+    proxyUrl: aiEditProxyUrl.value,
+    enableThinking: aiEditEnableThinking.value,
+    reasoningLevel: aiEditReasoningLevel.value,
+    contextWindow: aiEditContextWindow.value || undefined,
+    codexCliPath: aiEditCodexCliPath.value.trim() || undefined,
+    codexCliEnv: aiIsCodexCli.value ? codexEnvFromRows() : {},
+  };
+}
+
+function normalizeAiModelOptions(models: AiModelInfo[]): AiModelInfo[] {
+  const seen = new Set<string>();
+  const normalized: AiModelInfo[] = [];
+  for (const model of models) {
+    const id = model.id?.trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    normalized.push({ id, displayName: model.displayName?.trim() || undefined });
+  }
+  return normalized;
+}
+
+function displayAiModelName(modelId: string): string {
+  return aiModelOptions.value.find((model) => model.id === modelId)?.displayName || modelId;
+}
+
+function aiModelOptionPresentation(modelId: string, label = displayAiModelName(modelId)) {
+  return formatAiModelOption(label, modelId);
+}
+
+function aiModelOptionSecondary(modelId: string, label = displayAiModelName(modelId)) {
+  return aiModelOptionPresentation(modelId, label).secondary;
+}
+
+async function aiRefreshModels() {
+  if (aiModelLoading.value) return;
+  if (!aiModelListSupported.value) {
+    aiModelError.value = t("ai.modelListUnsupported");
+    return;
+  }
+  if (!aiIsCodexCli.value && !aiEditEndpoint.value.trim()) {
+    aiModelError.value = t("ai.modelListEndpointRequired");
+    return;
+  }
+  if (aiRequiresApiKey.value && !aiEditApiKey.value.trim()) {
+    aiModelError.value = t("ai.modelListApiKeyRequired");
+    return;
+  }
+
+  const token = ++aiModelRequestToken;
+  const signature = aiModelConfigSignature();
+  aiModelLoading.value = true;
+  aiModelError.value = "";
+  try {
+    const models = normalizeAiModelOptions(await aiListModels(currentAiEditConfig()));
+    if (token !== aiModelRequestToken) return;
+    aiModelOptions.value = models;
+    aiModelLoadedSignature.value = signature;
+    if (!aiEditModel.value.trim() && models[0]) aiEditModel.value = models[0].id;
+  } catch (e: any) {
+    if (token !== aiModelRequestToken) return;
+    aiModelOptions.value = [];
+    aiModelError.value = e?.message || String(e);
+  } finally {
+    if (token === aiModelRequestToken) aiModelLoading.value = false;
+  }
+}
+
+function onAiModelListOpen(open: boolean) {
+  if (open && aiCanListModels.value && !aiModelLoading.value && (!aiModelOptions.value.length || aiModelLoadedSignature.value !== aiModelConfigSignature())) {
+    void aiRefreshModels();
+  }
+}
+
+function aiSelectModel(modelId: string) {
+  aiEditModel.value = modelId;
+}
+
+function syncAiEditState() {
+  const provider = isWeb && settingsStore.aiConfig.provider === "codex-cli" ? "claude" : settingsStore.aiConfig.provider;
+  aiEditProvider.value = provider;
+  aiEditApiKey.value = settingsStore.aiConfig.apiKey;
+  aiEditAuthMethod.value = settingsStore.aiConfig.authMethod || AI_PROVIDER_PRESETS[provider].authMethod;
+  aiEditEndpoint.value = provider === settingsStore.aiConfig.provider ? settingsStore.aiConfig.endpoint : AI_PROVIDER_PRESETS[provider].endpoint;
+  aiEditModel.value = provider === settingsStore.aiConfig.provider ? settingsStore.aiConfig.model : AI_PROVIDER_PRESETS[provider].model;
+  aiEditApiStyle.value = provider === settingsStore.aiConfig.provider ? settingsStore.aiConfig.apiStyle || "completions" : AI_PROVIDER_PRESETS[provider].apiStyle;
+  aiEditProxyEnabled.value = !!settingsStore.aiConfig.proxyEnabled;
+  aiEditProxyUrl.value = settingsStore.aiConfig.proxyUrl || "";
+  aiEditEnableThinking.value = settingsStore.aiConfig.enableThinking ?? true;
+  aiEditReasoningLevel.value = settingsStore.aiConfig.reasoningLevel || "default";
+  aiEditContextWindow.value = settingsStore.aiConfig.contextWindow;
+  aiEditCodexCliPath.value = settingsStore.aiConfig.codexCliPath || "";
+  aiEditCodexCliEnvRows.value = aiEnvRowsFromConfig(settingsStore.aiConfig.codexCliEnv);
+  aiTestResult.value = "";
+  aiTestError.value = "";
+  aiTestLatency.value = null;
+  aiTestErrorCopied.value = false;
+  clearAiModelOptions();
+}
+
+function aiSelectProvider(provider: AiProvider) {
+  if (isWeb && provider === "codex-cli") return;
+  if (provider === aiEditProvider.value) return;
+
+  // Save current form edits before switching to prevent data loss.
+  if (aiHasChanges()) {
+    settingsStore.updateAiConfig(currentAiEditConfig());
+  }
+
+  settingsStore.updateAiConfig({ provider });
+  syncAiEditState();
+  if (provider === "codex-cli") void ensureCodexMcpStatus();
+}
+
+function aiSelectApiStyle(style: AiApiStyle) {
+  aiEditApiStyle.value = style;
+  if (aiEditProvider.value === "custom") {
+    aiEditAuthMethod.value = style === "anthropic-messages" ? "api-key" : "bearer";
+  }
+}
+
+function aiHasChanges(): boolean {
+  return (
+    aiEditProvider.value !== settingsStore.aiConfig.provider ||
+    aiEditApiKey.value !== settingsStore.aiConfig.apiKey ||
+    aiEditAuthMethod.value !== (settingsStore.aiConfig.authMethod || AI_PROVIDER_PRESETS[settingsStore.aiConfig.provider].authMethod) ||
+    aiEditEndpoint.value !== settingsStore.aiConfig.endpoint ||
+    aiEditModel.value !== settingsStore.aiConfig.model ||
+    aiEditApiStyle.value !== (settingsStore.aiConfig.apiStyle || "completions") ||
+    aiEditProxyEnabled.value !== !!settingsStore.aiConfig.proxyEnabled ||
+    aiEditProxyUrl.value !== (settingsStore.aiConfig.proxyUrl || "") ||
+    aiEditEnableThinking.value !== (settingsStore.aiConfig.enableThinking ?? true) ||
+    aiEditReasoningLevel.value !== (settingsStore.aiConfig.reasoningLevel || "default") ||
+    aiEditContextWindow.value !== settingsStore.aiConfig.contextWindow ||
+    aiEditCodexCliPath.value !== (settingsStore.aiConfig.codexCliPath || "") ||
+    codexEnvSignature() !== savedCodexEnvSignature()
+  );
+}
+
+function aiApplySettings() {
+  if (aiCodexValidationError.value) {
+    aiTestResult.value = "error";
+    aiTestError.value = aiCodexValidationError.value;
+    return;
+  }
+  settingsStore.updateAiConfig(currentAiEditConfig());
+}
+
+async function aiTestConn() {
+  if ((aiRequiresApiKey.value && !aiEditApiKey.value.trim()) || (!aiIsCodexCli.value && !aiEditEndpoint.value.trim()) || (!aiIsCodexCli.value && !aiEditModel.value.trim())) return;
+  if (aiCodexValidationError.value) {
+    aiTestResult.value = "error";
+    aiTestError.value = aiCodexValidationError.value;
+    return;
+  }
+  aiTesting.value = true;
+  aiTestResult.value = "";
+  aiTestError.value = "";
+  aiTestLatency.value = null;
+  aiTestErrorCopied.value = false;
+  try {
+    const result = await aiTestConnection(currentAiEditConfig());
+    aiTestResult.value = "success";
+    aiTestLatency.value = result.latencyMs ?? null;
+  } catch (e: any) {
+    aiTestResult.value = "error";
+    aiTestError.value = e?.message || String(e);
+  } finally {
+    aiTesting.value = false;
+  }
+}
+
+async function copyAiTestError() {
+  if (!aiTestError.value) return;
+  await copyToClipboard(aiTestError.value);
+  aiTestErrorCopied.value = true;
+  window.setTimeout(() => {
+    aiTestErrorCopied.value = false;
+  }, 1500);
+}
+
+async function ensureCodexMcpStatus() {
+  if (isWeb || activeSettingsTab.value !== "ai" || !aiIsCodexCli.value || mcpStatus.value || mcpStatusLoading.value) return;
+  await refreshMcpStatus();
+}
+
+// ---------- CodeMirror preview ----------
+const previewRef = ref<HTMLDivElement>();
+const previewView = shallowRef<EditorViewType | null>(null);
+
+interface PreviewSqlDiagnostic {
+  from: number;
+  to: number;
+  message: string;
+}
+
+function getPreviewCustomThemeColors(): CustomThemeColors | undefined {
+  if (editTheme.value !== "custom") return undefined;
+  const activeTheme = editCustomThemes.value.find((t) => t.id === editActiveCustomThemeId.value);
+  return activeTheme?.colors;
+}
+
+const previewSettings = computed<{
+  fontFamily: string;
+  fontSize: number;
+  theme: EditorTheme;
+  appAppearance: AppThemeAppearance;
+  appPalette: AppThemePalette;
+  customColors?: CustomThemeColors;
+  showStatementRunButtons: boolean;
+  showCurrentStatementFrame: boolean;
+}>(() => ({
+  fontFamily: editFontFamily.value,
+  fontSize: editFontSize.value,
+  theme: editTheme.value,
+  appAppearance: isDark.value ? "dark" : "light",
+  appPalette: themePalette.value,
+  customColors: getPreviewCustomThemeColors(),
+  showStatementRunButtons: editShowStatementRunButtons.value,
+  showCurrentStatementFrame: editShowCurrentStatementFrame.value,
+}));
+
+const previewSqlNormal = `SELECT u.id, u.name
+FROM users u
+ORDER BY u.id LIMIT 5;
+
+SELECT o.id, o.total
+FROM orders o
+WHERE o.total > 100;`;
+const previewSqlWithSyntaxError = `SELECT u.id, u.name
+FOM users u
+ORDER BY u.id LIMIT 5;
+
+SELECT o.id, o.total
+FROM orders o
+WHERE o.total > 100;`;
+
+let fontThemeComp: import("@codemirror/state").Compartment | null = null;
+let themeComp: import("@codemirror/state").Compartment | null = null;
+let diagnosticComp: import("@codemirror/state").Compartment | null = null;
+let previewRunGutterComp: import("@codemirror/state").Compartment | null = null;
+let currentStatementFrameComp: import("@codemirror/state").Compartment | null = null;
+let setPreviewDiagnosticsEffect: import("@codemirror/state").StateEffectType<PreviewSqlDiagnostic[]> | null = null;
+let setPreviewRunHighlightEffect: import("@codemirror/state").StateEffectType<{ from: number; to: number } | null> | null = null;
+let editorViewModule: typeof import("@codemirror/view") | null = null;
+let previewSqlDiagnostics: PreviewSqlDiagnostic[] = [];
+let previewExecutableCache: ExecutableStatementRangeCache | null = null;
+let previewRunHighlightRange: { from: number; to: number } | null = null;
+let previewRunHighlightTimer: ReturnType<typeof setTimeout> | null = null;
+let buildPreviewRunGutterExtension: () => import("@codemirror/state").Extension = () => [];
+
+function currentPreviewSql(): string {
+  return editSqlSemanticDiagnosticsEnabled.value ? previewSqlWithSyntaxError : previewSqlNormal;
+}
+
+function previewDiagnosticsForSql(sql: string): PreviewSqlDiagnostic[] {
+  if (!editSqlSemanticDiagnosticsEnabled.value) return [];
+  const from = sql.indexOf("FOM");
+  return from >= 0 ? [{ from, to: from + 3, message: "Syntax error: expected FROM" }] : [];
+}
+
+function updatePreviewSqlDiagnostics() {
+  const view = previewView.value;
+  if (!view || !setPreviewDiagnosticsEffect) return;
+  const nextSql = currentPreviewSql();
+  const currentSql = view.state.doc.toString();
+  previewSqlDiagnostics = previewDiagnosticsForSql(nextSql);
+  const effects = setPreviewDiagnosticsEffect.of(previewSqlDiagnostics);
+  if (currentSql === nextSql) {
+    view.dispatch({ effects });
+    return;
+  }
+  previewExecutableCache = null;
+  view.dispatch({
+    changes: { from: 0, to: currentSql.length, insert: nextSql },
+    effects,
+  });
+}
+
+function previewExecutableStatementRangeStartingAt(currentView: EditorViewType, lineFrom: number) {
+  previewExecutableCache = executableStatementRangeCacheForDoc(previewExecutableCache, currentView.state.doc, "mysql");
+  return executableStatementRangeStartingAt(previewExecutableCache, lineFrom);
+}
+
+function clearPreviewRunHighlight() {
+  previewRunHighlightRange = null;
+  if (previewView.value && setPreviewRunHighlightEffect) {
+    previewView.value.dispatch({ effects: setPreviewRunHighlightEffect.of(null) });
+  }
+}
+
+function flashPreviewRunHighlight(range: { from: number; to: number }, event: Event) {
+  previewRunHighlightRange = range;
+  if (previewView.value && setPreviewRunHighlightEffect) {
+    previewView.value.dispatch({ effects: setPreviewRunHighlightEffect.of(range) });
+  }
+  if (event.target instanceof Element) {
+    const marker = event.target.closest(".cm-run-statement-marker");
+    marker?.classList.add("cm-run-statement-marker--executed");
+    window.setTimeout(() => marker?.classList.remove("cm-run-statement-marker--executed"), 650);
+  }
+  if (previewRunHighlightTimer) clearTimeout(previewRunHighlightTimer);
+  previewRunHighlightTimer = window.setTimeout(() => {
+    previewRunHighlightTimer = null;
+    clearPreviewRunHighlight();
+  }, 650);
+}
+
+function handlePreviewRunGutterMouseDown(currentView: EditorViewType, line: { from: number; to: number }, event: Event): boolean {
+  if (!(event instanceof MouseEvent) || event.button !== 0) return false;
+  const statementRange = previewExecutableStatementRangeStartingAt(currentView, line.from);
+  if (!statementRange) return false;
+  event.preventDefault();
+  event.stopPropagation();
+  flashPreviewRunHighlight({ from: statementRange.from, to: statementRange.to }, event);
+  currentView.focus();
+  return true;
+}
+
+function buildPreviewCurrentStatementFrameExtension(viewModule: Pick<typeof import("@codemirror/view"), "Decoration" | "EditorView" | "ViewPlugin">, enabled: boolean) {
+  if (!enabled) return [];
+  const { Decoration, EditorView, ViewPlugin } = viewModule;
+  const frameTheme = EditorView.baseTheme({
+    ".cm-db-current-statement-line": {
+      position: "relative",
+    },
+    ".cm-db-current-statement-line::after": {
+      content: '""',
+      position: "absolute",
+      top: "0",
+      bottom: "0",
+      left: "0",
+      boxSizing: "border-box",
+      width: "var(--dbx-current-statement-frame-width, 100%)",
+      borderRight: "1px solid rgb(34 197 94 / 0.75)",
+      borderLeft: "1px solid rgb(34 197 94 / 0.75)",
+      pointerEvents: "none",
+    },
+    ".cm-db-current-statement-line--first::after": {
+      borderTop: "1px solid rgb(34 197 94 / 0.75)",
+    },
+    ".cm-db-current-statement-line--last::after": {
+      borderBottom: "1px solid rgb(34 197 94 / 0.75)",
+    },
+  });
+  const framePlugin = ViewPlugin.fromClass(
+    class {
+      decorations: import("@codemirror/view").DecorationSet;
+      constructor(view: import("@codemirror/view").EditorView) {
+        this.decorations = this.getDeco(view);
+      }
+      update(update: import("@codemirror/view").ViewUpdate) {
+        this.decorations = this.getDeco(update.view);
+      }
+      getDeco(view: import("@codemirror/view").EditorView) {
+        if (view.state.selection.ranges.some((range) => !range.empty)) return Decoration.none;
+        const range = currentExecutableStatementRange(view.state.doc.toString(), view.state.selection.main.head, "mysql");
+        if (!range) return Decoration.none;
+
+        const startLine = view.state.doc.lineAt(range.from);
+        const frameTo = previewCurrentStatementFrameTo(view, range);
+        const endLine = view.state.doc.lineAt(Math.max(range.from, frameTo - 1));
+        let maxWidth = 1;
+        for (let lineNumber = startLine.number; lineNumber <= endLine.number; lineNumber += 1) {
+          const line = view.state.doc.line(lineNumber);
+          const lineRangeTo = Math.min(line.to, frameTo);
+          maxWidth = Math.max(maxWidth, visualSqlColumnsWithInlineHints(view.state.doc.sliceString(line.from, lineRangeTo), line.from, lineRangeTo));
+        }
+
+        const deco: any[] = [];
+        const frameWidth = `calc(${maxWidth}ch + 2ch)`;
+        for (let lineNumber = startLine.number; lineNumber <= endLine.number; lineNumber += 1) {
+          const line = view.state.doc.line(lineNumber);
+          const classes = ["cm-db-current-statement-line"];
+          if (lineNumber === startLine.number) classes.push("cm-db-current-statement-line--first");
+          if (lineNumber === endLine.number) classes.push("cm-db-current-statement-line--last");
+          deco.push(Decoration.line({ class: classes.join(" "), attributes: { style: `--dbx-current-statement-frame-width: ${frameWidth};` } }).range(line.from));
+        }
+        return Decoration.set(deco);
+      }
+    },
+    { decorations: (v) => v.decorations },
+  );
+
+  return [framePlugin, frameTheme];
+}
+
+function previewCurrentStatementFrameTo(view: import("@codemirror/view").EditorView, range: SqlTextRange): number {
+  const nextChar = range.to < view.state.doc.length ? view.state.doc.sliceString(range.to, range.to + 1) : "";
+  return currentStatementFrameRangeTo(nextChar, range);
+}
+
+watch(
+  [previewSettings, editCustomThemes, editActiveCustomThemeId],
+  async ([ss]) => {
+    if (!previewView.value || !fontThemeComp || !themeComp || !editorViewModule) return;
+
+    const themeExt = await loadEditorTheme(ss.theme, ss.appAppearance, ss.customColors, ss.appPalette);
+    previewView.value.dispatch({
+      effects: [
+        themeComp.reconfigure(themeExt),
+        fontThemeComp.reconfigure(editorFontTheme(editorViewModule.EditorView, ss.fontSize, ss.fontFamily)),
+        ...(previewRunGutterComp ? [previewRunGutterComp.reconfigure(buildPreviewRunGutterExtension())] : []),
+        ...(currentStatementFrameComp ? [currentStatementFrameComp.reconfigure(buildPreviewCurrentStatementFrameExtension(editorViewModule, ss.showCurrentStatementFrame))] : []),
+      ],
+    });
+  },
+  { deep: true },
+);
+
+watch(editSqlSemanticDiagnosticsEnabled, () => {
+  updatePreviewSqlDiagnostics();
+});
+
+let previewInitialized = false;
+
+function cleanupPreviewEditor() {
+  if (!previewView.value) return;
+  previewView.value.destroy();
+  previewView.value = null;
+  previewInitialized = false;
+  fontThemeComp = null;
+  themeComp = null;
+  diagnosticComp = null;
+  previewRunGutterComp = null;
+  currentStatementFrameComp = null;
+  setPreviewDiagnosticsEffect = null;
+  setPreviewRunHighlightEffect = null;
+  editorViewModule = null;
+  previewSqlDiagnostics = [];
+  previewExecutableCache = null;
+  previewRunHighlightRange = null;
+  buildPreviewRunGutterExtension = () => [];
+  if (previewRunHighlightTimer) {
+    clearTimeout(previewRunHighlightTimer);
+    previewRunHighlightTimer = null;
+  }
+}
+
+watch(activeSettingsTab, (tab) => {
+  if (tab !== "editor" && previewView.value) {
+    cleanupPreviewEditor();
+  }
+});
+
+watch(previewRef, async (el) => {
+  if (!el || previewInitialized) return;
+  previewInitialized = true;
+  if (previewView.value) return;
+
+  const [{ EditorView, Decoration, ViewPlugin, gutter, GutterMarker }, { EditorState, Compartment, StateEffect, StateField }, { sql, MySQL }, { basicSetup }] = await Promise.all([import("@codemirror/view"), import("@codemirror/state"), import("@codemirror/lang-sql"), import("codemirror")]);
+
+  editorViewModule = { Decoration, EditorView, ViewPlugin } as typeof import("@codemirror/view");
+  fontThemeComp = new Compartment();
+  themeComp = new Compartment();
+  diagnosticComp = new Compartment();
+  previewRunGutterComp = new Compartment();
+  currentStatementFrameComp = new Compartment();
+  setPreviewDiagnosticsEffect = StateEffect.define<PreviewSqlDiagnostic[]>();
+  setPreviewRunHighlightEffect = StateEffect.define<{ from: number; to: number } | null>();
+  previewSqlDiagnostics = previewDiagnosticsForSql(currentPreviewSql());
+
+  const ss = previewSettings.value;
+  const themeExt = await loadEditorTheme(ss.theme, ss.appAppearance, ss.customColors, ss.appPalette);
+  const diagnosticTheme = EditorView.baseTheme({
+    ".cm-settings-preview-sql-error": {
+      textDecoration: "underline wavy var(--destructive)",
+      textUnderlineOffset: "3px",
+    },
+  });
+  const buildPreviewDiagnosticExtension = () => {
+    const diagnosticEffect = setPreviewDiagnosticsEffect;
+    const buildDecorations = () =>
+      Decoration.set(
+        previewSqlDiagnostics.map((diagnostic) =>
+          Decoration.mark({
+            class: "cm-settings-preview-sql-error",
+            attributes: { title: diagnostic.message },
+          }).range(diagnostic.from, diagnostic.to),
+        ),
+        true,
+      );
+
+    const field = StateField.define({
+      create: buildDecorations,
+      update(value, transaction) {
+        const diagnosticsChanged = !!diagnosticEffect && transaction.effects.some((effect) => effect.is(diagnosticEffect));
+        return transaction.docChanged || diagnosticsChanged ? buildDecorations() : value;
+      },
+      provide: (field) => EditorView.decorations.from(field),
+    });
+
+    return [field, diagnosticTheme];
+  };
+
+  class PreviewRunStatementGutterMarker extends GutterMarker {
+    toDOM() {
+      return createRunStatementButtonDom(t("settings.previewStatementRunButton"));
+    }
+  }
+
+  const previewRunMarker = new PreviewRunStatementGutterMarker();
+  buildPreviewRunGutterExtension = () =>
+    editShowStatementRunButtons.value
+      ? gutter({
+          class: "cm-run-statement-gutter",
+          lineMarker(currentView, line) {
+            return previewExecutableStatementRangeStartingAt(currentView, line.from) ? previewRunMarker : null;
+          },
+          domEventHandlers: {
+            mousedown: handlePreviewRunGutterMouseDown,
+          },
+        })
+      : [];
+
+  const buildPreviewRunHighlightExtension = () => {
+    const highlightEffect = setPreviewRunHighlightEffect;
+    const buildDecorations = () => (previewRunHighlightRange ? Decoration.set([Decoration.mark({ class: "cm-settings-preview-run-highlight" }).range(previewRunHighlightRange.from, previewRunHighlightRange.to)], true) : Decoration.none);
+    const field = StateField.define({
+      create: buildDecorations,
+      update(value, transaction) {
+        const highlightChanged = !!highlightEffect && transaction.effects.some((effect) => effect.is(highlightEffect));
+        return transaction.docChanged || highlightChanged ? buildDecorations() : value;
+      },
+      provide: (field) => EditorView.decorations.from(field),
+    });
+    return field;
+  };
+
+  const state = EditorState.create({
+    doc: currentPreviewSql(),
+    extensions: [
+      basicSetup,
+      sql({ dialect: MySQL }),
+      themeComp.of(themeExt),
+      fontThemeComp.of(editorFontTheme(EditorView, ss.fontSize, ss.fontFamily)),
+      previewRunGutterComp.of(buildPreviewRunGutterExtension()),
+      currentStatementFrameComp.of(buildPreviewCurrentStatementFrameExtension(editorViewModule, ss.showCurrentStatementFrame)),
+      diagnosticComp.of(buildPreviewDiagnosticExtension()),
+      buildPreviewRunHighlightExtension(),
+    ],
+  });
+
+  previewView.value = new EditorView({ state, parent: previewRef.value });
+});
+
+watch(
+  () => settingsVisible.value,
+  (open) => {
+    if (!open) cleanupPreviewEditor();
+  },
+);
+
+onUnmounted(cleanupPreviewEditor);
+</script>
+
+<template>
+  <component :is="settingsRootComponent" v-bind="settingsRootProps" :class="settingsRootClass" @update:open="onSettingsRootOpenChange">
+    <component :is="settingsContentComponent" :class="settingsContentClass">
+      <DialogHeader>
+        <component :is="settingsTitleComponent" class="flex items-center gap-2 text-base leading-none font-medium cn-font-heading">
+          <Settings class="h-4 w-4" />
+          {{ t("settings.title") }}
+        </component>
+      </DialogHeader>
+
+      <div class="settings-layout flex min-h-0 flex-1 flex-col gap-3 overflow-hidden lg:flex-row">
+        <nav class="settingsCategoryNav settings-category-nav flex min-h-0 shrink-0 gap-1 overflow-x-auto border-b pb-3 lg:w-40 lg:flex-col lg:overflow-x-hidden lg:overflow-y-auto lg:border-b-0 lg:border-r lg:pb-0 lg:pr-3">
+          <button v-for="category in settingsCategoryNav" :key="category.value" type="button" :class="settingsCategoryButton(category.value)" @click="activeSettingsTab = category.value">
+            {{ category.label }}
+          </button>
+        </nav>
+
+        <div class="min-w-0 flex-1 overflow-hidden px-1 flex flex-col">
+          <div class="min-h-0 flex-1 overflow-y-auto overflow-x-hidden px-1 pr-2">
+            <section v-if="activeSettingsTab === 'editor'" class="flex flex-col gap-5 py-2">
+              <div class="grid gap-4 md:grid-cols-[1fr_auto]">
+                <!-- Font Family -->
+                <div class="space-y-2 min-w-0">
+                  <Label>{{ t("settings.fontFamily") }}</Label>
+                  <SearchableSelect
+                    :model-value="editFontFamily"
+                    :options="systemFontOptions"
+                    :placeholder="t('settings.selectFont')"
+                    :search-placeholder="t('settings.searchFont')"
+                    :empty-text="t('settings.noFontsFound')"
+                    :loading-text="t('settings.loadingFonts')"
+                    allow-custom
+                    :display-name="displayFontFamily"
+                    :normalize-custom="normalizeCustomFontFamilyInput"
+                    :trigger-class="fontSearchTriggerClass"
+                    :trigger-icon-class="fontSearchTriggerIconClass"
+                    content-class="w-[var(--reka-popover-trigger-width)] min-w-[260px]"
+                    @update:model-value="onFontFamilyChange"
+                    @update:open="(open: boolean) => open && loadSystemFontOptions()"
+                  >
+                    <template #trigger-label="{ label, loading }">
+                      <span class="truncate" :style="{ fontFamily: editFontFamily }">
+                        {{ loading ? t("settings.loadingFonts") : label }}
+                      </span>
+                    </template>
+                    <template #option-label="{ option, label }">
+                      <span class="truncate" :style="fontOptionStyle(option)">{{ label }}</span>
+                    </template>
+                    <template #custom-option-label="{ value }">
+                      <span class="truncate" :style="{ fontFamily: value }">
+                        {{ t("settings.useCustomFont", { font: readableFontFamily(value) }) }}
+                      </span>
+                    </template>
+                  </SearchableSelect>
+                </div>
+
+                <!-- Theme + Custom Theme Button -->
+                <div class="flex gap-2 items-end">
+                  <div class="space-y-2">
+                    <Label>{{ t("settings.theme") }}</Label>
+                    <Select :model-value="themeSelectValue" @update:model-value="onThemeChange">
+                      <SelectTrigger class="min-w-[80px] max-w-[200px]">
+                        <SelectValue :placeholder="t('settings.selectTheme')" />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem v-for="theme in themeSelectOptions" :key="theme.value" :value="theme.value">
+                          <div class="flex items-center gap-2">
+                            <span class="h-3 w-3 rounded-full border" :class="theme.dark ? 'bg-foreground border-foreground/20' : 'bg-muted-foreground/30 border-muted-foreground/40'" />
+                            {{ theme.label }}
+                          </div>
+                        </SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+                  <Button v-if="editTheme === 'custom'" variant="outline" class="h-9 w-auto px-4" @click="showThemeCustomizer = true">
+                    <Settings class="mr-2 h-4 w-4" />
+                    {{ t("settings.customThemeConfigure") }}
+                  </Button>
+                </div>
+              </div>
+
+              <!-- Font Size -->
+              <div class="space-y-2">
+                <div class="flex items-center justify-between">
+                  <Label>{{ t("settings.fontSize") }}</Label>
+                  <span class="text-xs text-muted-foreground tabular-nums">{{ editFontSize }}px</span>
+                </div>
+                <input type="range" min="10" max="24" step="1" :value="editFontSize" @input="editFontSize = Number(($event.target as HTMLInputElement).value)" class="w-full accent-primary" />
+                <div class="flex items-center gap-2 text-xs text-muted-foreground">
+                  <span>10px</span>
+                  <span class="flex-1 border-b border-dashed border-muted-foreground/30" />
+                  <span>24px</span>
+                </div>
+              </div>
+
+              <Separator />
+
+              <div class="grid gap-4 md:grid-cols-[minmax(0,1fr)_minmax(0,1fr)]">
+                <div class="space-y-2">
+                  <Label>{{ t("settings.executeMode") }}</Label>
+                  <Select :model-value="editExecuteMode" @update:model-value="onExecuteModeChange">
+                    <SelectTrigger>
+                      <SelectValue :placeholder="t('settings.executeMode')" />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="all">{{ t("settings.executeModeAll") }}</SelectItem>
+                      <SelectItem value="current">{{ t("settings.executeModeCurrent") }}</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="editor-show-execution-target-picker">{{ t("settings.showExecutionTargetPicker") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.showExecutionTargetPickerDescription") }}</p>
+                  </div>
+                  <Switch id="editor-show-execution-target-picker" v-model="editShowExecutionTargetPicker" class="mt-0.5" />
+                </div>
+
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="editor-show-statement-run-buttons">{{ t("settings.showStatementRunButtons") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.showStatementRunButtonsDescription") }}</p>
+                  </div>
+                  <Switch id="editor-show-statement-run-buttons" v-model="editShowStatementRunButtons" class="mt-0.5" />
+                </div>
+
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="editor-show-current-statement-frame">{{ t("settings.showCurrentStatementFrame") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.showCurrentStatementFrameDescription") }}</p>
+                  </div>
+                  <Switch id="editor-show-current-statement-frame" v-model="editShowCurrentStatementFrame" class="mt-0.5" />
+                </div>
+
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="editor-show-insert-value-hints">{{ t("settings.showInsertValueHints") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.showInsertValueHintsDescription") }}</p>
+                  </div>
+                  <Switch id="editor-show-insert-value-hints" v-model="editShowInsertValueHints" class="mt-0.5" />
+                </div>
+
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="editor-word-wrap">{{ t("settings.wordWrap") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.wordWrapDescription") }}</p>
+                  </div>
+                  <Switch id="editor-word-wrap" v-model="editWordWrap" class="mt-0.5" />
+                </div>
+
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="editor-vim-mode">{{ t("settings.vimMode") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.vimModeDescription") }}</p>
+                  </div>
+                  <Switch id="editor-vim-mode" v-model="editVimModeEnabled" class="mt-0.5" />
+                </div>
+
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="editor-auto-close-brackets">{{ t("settings.autoCloseBrackets") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.autoCloseBracketsDescription") }}</p>
+                  </div>
+                  <Switch id="editor-auto-close-brackets" v-model="editAutoCloseBrackets" class="mt-0.5" />
+                </div>
+
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="editor-auto-alias-tables">{{ t("settings.autoAliasTables") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.autoAliasTablesDescription") }}</p>
+                  </div>
+                  <Switch id="editor-auto-alias-tables" v-model="editAutoAliasTables" class="mt-0.5" />
+                </div>
+              </div>
+
+              <div class="grid gap-3 md:grid-cols-2">
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="editor-sql-semantic-diagnostics">{{ t("settings.sqlSemanticDiagnosticsEnabled") }}</Label>
+                    <p class="text-xs text-muted-foreground">
+                      {{ t("settings.sqlSemanticDiagnosticsEnabledDescription") }}
+                    </p>
+                  </div>
+                  <Switch id="editor-sql-semantic-diagnostics" :model-value="editSqlSemanticDiagnosticsEnabled" class="mt-0.5" @update:model-value="onSqlSemanticDiagnosticsEnabledChange" />
+                </div>
+
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="editor-confirm-dangerous-sql">{{ t("settings.confirmDangerousSqlExecution") }}</Label>
+                    <p class="text-xs text-muted-foreground">
+                      {{ t("settings.confirmDangerousSqlExecutionDescription") }}
+                    </p>
+                  </div>
+                  <Switch id="editor-confirm-dangerous-sql" v-model="editConfirmDangerousSqlExecution" class="mt-0.5" />
+                </div>
+
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="editor-confirm-unsaved-sql-close">{{ t("settings.confirmUnsavedSqlClose") }}</Label>
+                    <p class="text-xs text-muted-foreground">
+                      {{ t("settings.confirmUnsavedSqlCloseDescription") }}
+                    </p>
+                  </div>
+                  <Switch id="editor-confirm-unsaved-sql-close" v-model="editConfirmUnsavedSqlClose" class="mt-0.5" />
+                </div>
+              </div>
+
+              <Separator />
+
+              <div class="space-y-3">
+                <div class="flex flex-wrap items-start justify-between gap-3">
+                  <div class="space-y-1">
+                    <div class="text-sm font-medium text-muted-foreground">{{ t("settings.sqlVariableSyntax") }}</div>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.sqlVariableSyntaxDescription") }}</p>
+                  </div>
+                  <Select v-model="editSqlVariableSyntaxDatabaseType">
+                    <SelectTrigger class="h-8 w-44 px-2 text-xs">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent class="max-h-72">
+                      <SelectItem v-for="dbType in SQL_VARIABLE_SYNTAX_DATABASE_TYPES" :key="dbType" :value="dbType">
+                        {{ dbType }}
+                      </SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+                <div class="grid gap-3 md:grid-cols-2">
+                  <div v-for="key in SQL_VARIABLE_SYNTAX_KEYS" :key="key" class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                    <div class="min-w-0 space-y-1">
+                      <Label :for="`sql-var-syntax-${key}`" class="flex items-center gap-1.5">
+                        <span class="font-mono text-xs text-primary">{{ SQL_VARIABLE_SYNTAX_TOKENS[key] }}</span>
+                        <span>{{ t(`settings.sqlVariableSyntax_${key}`) }}</span>
+                      </Label>
+                      <p class="text-xs text-muted-foreground">{{ t(`settings.sqlVariableSyntax_${key}Description`) }}</p>
+                    </div>
+                    <Switch :id="`sql-var-syntax-${key}`" :model-value="sqlVariableSyntaxToggle(key)" class="mt-0.5 shrink-0" @update:model-value="(value) => setSqlVariableSyntaxToggle(key, value as boolean)" />
+                  </div>
+                </div>
+              </div>
+
+              <Separator />
+
+              <!-- Live Preview -->
+              <div class="space-y-2">
+                <Label>{{ t("settings.preview") }}</Label>
+                <div class="rounded-md border overflow-auto max-w-full" :class="editTheme === 'vscode-light' || editTheme === 'duotone-light' || editTheme === 'xcode' ? 'border-border' : 'border-border/50'">
+                  <div ref="previewRef" style="min-width: 100%" />
+                </div>
+              </div>
+            </section>
+
+            <section v-else-if="activeSettingsTab === 'formatter'" class="flex flex-col gap-5 py-2">
+              <div class="space-y-3 rounded-md border border-border/70 bg-muted/10 p-3">
+                <div class="text-sm font-medium">{{ t("settings.sqlFormatterEditorShortcuts") }}</div>
+                <div class="overflow-hidden rounded-md border border-border/70 bg-background">
+                  <div v-for="definition in formatterEditorShortcutDefinitions" :key="definition.id" class="group -mt-px grid gap-2 border-t border-border/70 px-3 py-2 transition-colors first:mt-0 first:border-t-0 hover:bg-muted/40 sm:grid-cols-[minmax(0,1fr)_auto] sm:items-center">
+                    <div class="min-w-0">
+                      <Label class="min-w-0 truncate leading-none">{{ t(definition.labelKey) }}</Label>
+                    </div>
+                    <div class="min-w-0 space-y-1">
+                      <div class="flex items-center justify-end gap-1.5">
+                        <input
+                          :data-shortcut-input="definition.id"
+                          :value="editingShortcutId === definition.id ? '' : formatShortcutPill(editShortcuts[definition.id])"
+                          :style="{
+                            width: editingShortcutId === definition.id ? shortcutPressShortcutInputWidth : `${Math.max(4, formatShortcutPill(editShortcuts[definition.id]).length + 3)}ch`,
+                          }"
+                          readonly
+                          :aria-invalid="shortcutConflicts.includes(definition.id)"
+                          :placeholder="t('settings.shortcutPressShortcut')"
+                          class="h-7 w-auto min-w-12 max-w-64 shrink-0 cursor-default rounded-[6px] border border-transparent bg-background px-2.5 text-center font-mono text-[13px] font-semibold text-foreground/75 shadow-inner outline-none selection:bg-transparent placeholder:text-muted-foreground aria-invalid:border-destructive/70 aria-invalid:text-destructive aria-invalid:ring-destructive/20"
+                          :class="editingShortcutId === definition.id ? 'max-w-64 cursor-text border-border/80 bg-background text-left text-foreground shadow-none focus-visible:border-ring focus-visible:ring-2 focus-visible:ring-ring/35' : ''"
+                          @keydown="(event: KeyboardEvent) => onShortcutKeydown(definition.id, event)"
+                        />
+                        <Button
+                          v-if="editingShortcutId !== definition.id"
+                          type="button"
+                          variant="ghost"
+                          size="icon"
+                          class="h-7 w-7 shrink-0 text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:opacity-100 group-hover:opacity-100"
+                          :aria-label="t('settings.shortcutPressShortcut')"
+                          @click="focusShortcutInput(definition.id)"
+                        >
+                          <Pencil class="h-4 w-4" />
+                        </Button>
+                        <Button v-else type="button" variant="ghost" size="sm" class="h-7 shrink-0 px-2 text-sm font-medium text-muted-foreground hover:text-foreground" @click="cancelShortcutEdit">
+                          {{ t("settings.cancel") }}
+                        </Button>
+                        <Button
+                          v-if="editingShortcutId !== definition.id"
+                          type="button"
+                          variant="ghost"
+                          size="icon"
+                          class="h-7 w-7 shrink-0 text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:opacity-100 group-hover:opacity-100"
+                          :aria-label="t('settings.reset')"
+                          @click="resetShortcut(definition.id)"
+                        >
+                          <RotateCcw class="h-4 w-4" />
+                        </Button>
+                        <Button
+                          v-if="editingShortcutId !== definition.id && editShortcuts[definition.id]"
+                          type="button"
+                          variant="ghost"
+                          size="icon"
+                          class="h-7 w-7 shrink-0 text-muted-foreground opacity-0 transition-opacity hover:text-destructive focus-visible:opacity-100 group-hover:opacity-100"
+                          :aria-label="t('settings.shortcutClear')"
+                          @click="clearShortcut(definition.id)"
+                        >
+                          <X class="h-4 w-4" />
+                        </Button>
+                        <span v-else-if="editingShortcutId !== definition.id" class="h-7 w-7 shrink-0" aria-hidden="true" />
+                      </div>
+                      <p v-if="shortcutConflicts.includes(definition.id)" class="text-xs text-destructive">
+                        {{ t("settings.shortcutConflict") }}
+                      </p>
+                    </div>
+                  </div>
+                </div>
+              </div>
+              <SqlFormatterSettingsPanel v-model="editSqlFormatter" @validity-change="(value: boolean) => (sqlFormatterConfigValid = value)" />
+            </section>
+
+            <section v-else-if="activeSettingsTab === 'appearance'" class="settings-appearance-section flex flex-col gap-5 py-2">
+              <div class="settings-appearance-top-grid">
+                <div class="settings-appearance-field min-w-0">
+                  <div class="flex h-9 items-end">
+                    <Label class="whitespace-normal leading-tight">{{ t("settings.languageTitle") }}</Label>
+                  </div>
+                  <Select :model-value="currentLocale()" @update:model-value="onLocaleChange">
+                    <SelectTrigger class="h-8 w-full gap-0.5 px-0.5">
+                      <SelectValue>
+                        <span v-if="selectedLocaleOption" class="flex min-w-0 items-center gap-0.5">
+                          <span class="inline-flex h-5 shrink-0 items-center justify-center text-sm font-medium leading-none">
+                            {{ selectedLocaleOption.flag }}
+                          </span>
+                          <span class="truncate">{{ selectedLocaleOption.label }}</span>
+                        </span>
+                      </SelectValue>
+                    </SelectTrigger>
+                    <SelectContent class="w-[150px]">
+                      <SelectItem v-for="locale in LOCALE_OPTIONS" :key="locale.value" :value="locale.value">
+                        <div class="flex items-center gap-1">
+                          <span class="inline-flex h-5 w-6 shrink-0 items-center justify-center text-sm font-medium leading-none">
+                            {{ locale.flag }}
+                          </span>
+                          <span>{{ locale.label }}</span>
+                        </div>
+                      </SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+
+                <div class="settings-appearance-field min-w-0">
+                  <div class="flex h-9 items-end">
+                    <Label class="whitespace-normal leading-tight">{{ t("settings.colorTheme") }}</Label>
+                  </div>
+                  <Select :model-value="themePalette" @update:model-value="(value) => setThemePalette(value as AppThemePalette)">
+                    <SelectTrigger class="h-8 w-full gap-1">
+                      <SelectValue :placeholder="t('settings.selectColorTheme')">
+                        <span v-if="selectedThemePaletteOption" class="flex min-w-0 items-center gap-1">
+                          <span class="h-3 w-3 shrink-0 rounded-full border border-border shadow-xs" :style="{ background: selectedThemePaletteOption.previewColor }" />
+                          <span class="truncate">{{ selectedThemePaletteOption.label }}</span>
+                        </span>
+                      </SelectValue>
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem v-for="option in appThemePaletteOptions" :key="option.value" :value="option.value">
+                        <div class="flex items-center gap-2">
+                          <span class="h-3 w-3 rounded-full border border-border shadow-xs" :style="{ background: option.previewColor }" />
+                          {{ option.label }}
+                        </div>
+                      </SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+
+                <div class="settings-appearance-field min-w-0">
+                  <div class="flex h-9 items-end gap-1">
+                    <Label class="min-w-0 whitespace-normal leading-tight">{{ t("settings.uiFontFamily") }}</Label>
+                    <HelpTooltip :label="t('settings.uiFontFamily')" trigger-class="[&_svg]:h-3 [&_svg]:w-3" content-class="max-w-64">
+                      <p>{{ t("settings.uiFontFamilyDescription") }}</p>
+                    </HelpTooltip>
+                  </div>
+                  <SearchableSelect
+                    :model-value="editUiFontFamily"
+                    :options="uiFontOptions"
+                    :placeholder="t('settings.selectFont')"
+                    :search-placeholder="t('settings.searchFont')"
+                    :empty-text="t('settings.noFontsFound')"
+                    :loading-text="t('settings.loadingFonts')"
+                    allow-custom
+                    :display-name="displayUiFontFamily"
+                    :normalize-custom="normalizeCustomFontFamilyInput"
+                    :trigger-class="appearanceFontSearchTriggerClass"
+                    :trigger-icon-class="appearanceFontSearchTriggerIconClass"
+                    content-class="w-[var(--reka-popover-trigger-width)] min-w-[260px]"
+                    @update:model-value="onUiFontFamilyChange"
+                    @update:open="(open: boolean) => open && loadSystemFontOptions()"
+                  >
+                    <template #trigger-label="{ label, loading }">
+                      <span class="truncate" :style="{ fontFamily: editUiFontFamily }">
+                        {{ loading ? t("settings.loadingFonts") : label }}
+                      </span>
+                    </template>
+                    <template #option-label="{ option, label }">
+                      <span class="truncate" :style="fontOptionStyle(option, editUiFontFamily)">{{ label }}</span>
+                    </template>
+                    <template #custom-option-label="{ value }">
+                      <span class="truncate" :style="{ fontFamily: value }">
+                        {{ t("settings.useCustomFont", { font: readableFontFamily(value) }) }}
+                      </span>
+                    </template>
+                  </SearchableSelect>
+                </div>
+
+                <div class="settings-appearance-field min-w-0">
+                  <div class="flex h-9 items-end gap-1">
+                    <Label class="min-w-0 whitespace-normal leading-tight">{{ t("settings.uiScale") }}</Label>
+                    <HelpTooltip :label="t('settings.uiScale')" trigger-class="[&_svg]:h-3 [&_svg]:w-3" content-class="max-w-64">
+                      <p>{{ t("settings.uiScaleDescription") }}</p>
+                    </HelpTooltip>
+                  </div>
+                  <Select
+                    :model-value="String(editUiScale)"
+                    @update:model-value="
+                      (value: any) => {
+                        const next = Number(value);
+                        if (Number.isFinite(next)) editUiScale = next;
+                      }
+                    "
+                  >
+                    <SelectTrigger class="h-8 w-full">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem v-for="scale in uiScaleOptions" :key="scale" :value="String(scale)" class="pl-2.5"> {{ Math.round(scale * 100) }}% </SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+              </div>
+
+              <div class="settings-appearance-group">
+                <Label>{{ t("settings.theme") }}</Label>
+                <div class="settings-appearance-button-row flex flex-wrap gap-2">
+                  <Button
+                    v-for="option in appThemeModeOptions"
+                    :key="option.value"
+                    type="button"
+                    variant="outline"
+                    size="sm"
+                    class="settings-choice-button h-8 gap-1.5 rounded-[6px] px-3"
+                    :class="themeMode === option.value ? 'settings-choice-button--selected border-primary/40 bg-primary/10 text-primary ring-1 ring-primary/30' : 'text-foreground'"
+                    @click="setThemeMode(option.value)"
+                  >
+                    <component :is="option.icon" class="h-3.5 w-3.5" />
+                    {{ option.label }}
+                  </Button>
+                </div>
+              </div>
+
+              <Separator />
+
+              <div class="settings-appearance-group">
+                <Label>{{ t("settings.appLayout") }}</Label>
+                <div class="settings-appearance-choice-grid">
+                  <Button type="button" variant="outline" class="settings-choice-card h-auto justify-start border p-3" :class="editAppLayout === 'separated' ? 'settings-choice-card--selected border-blue-300 ring-2 ring-blue-300/50' : ''" @click="setAppLayout('separated')">
+                    <TooltipProvider>
+                      <Tooltip>
+                        <TooltipTrigger as-child>
+                          <div class="w-full min-w-0 text-left">
+                            <div class="text-sm font-medium">{{ t("settings.appLayoutSeparated") }}</div>
+                            <div :ref="(el) => setLayoutDescRef('separated', el)" class="text-xs text-muted-foreground truncate">{{ t("settings.appLayoutSeparatedDescription") }}</div>
+                          </div>
+                        </TooltipTrigger>
+                        <TooltipContent v-if="layoutDescTruncated.separated.value" class="max-w-[320px] text-xs leading-relaxed">
+                          {{ t("settings.appLayoutSeparatedDescription") }}
+                        </TooltipContent>
+                      </Tooltip>
+                    </TooltipProvider>
+                  </Button>
+                  <Button type="button" variant="outline" class="settings-choice-card h-auto justify-start border p-3" :class="editAppLayout === 'classic' ? 'settings-choice-card--selected border-blue-300 ring-2 ring-blue-300/50' : ''" @click="setAppLayout('classic')">
+                    <TooltipProvider>
+                      <Tooltip>
+                        <TooltipTrigger as-child>
+                          <div class="w-full min-w-0 text-left">
+                            <div class="text-sm font-medium">{{ t("settings.appLayoutClassic") }}</div>
+                            <div :ref="(el) => setLayoutDescRef('classic', el)" class="text-xs text-muted-foreground truncate">{{ t("settings.appLayoutClassicDescription") }}</div>
+                          </div>
+                        </TooltipTrigger>
+                        <TooltipContent v-if="layoutDescTruncated.classic.value" class="max-w-[320px] text-xs leading-relaxed">
+                          {{ t("settings.appLayoutClassicDescription") }}
+                        </TooltipContent>
+                      </Tooltip>
+                    </TooltipProvider>
+                  </Button>
+                </div>
+              </div>
+
+              <!-- <div v-if="!isWeb" class="space-y-2"> -->
+              <div class="settings-appearance-group">
+                <Label>{{ t("settings.iconTheme") }}</Label>
+                <div class="settings-appearance-choice-grid">
+                  <Button type="button" variant="outline" class="settings-choice-card h-auto justify-start border p-3" :class="editIconTheme === 'default' ? 'settings-choice-card--selected border-blue-300 ring-2 ring-blue-300/50' : ''" @click="setIconTheme('default')">
+                    <div class="flex items-center gap-3 text-left w-full min-w-0">
+                      <img src="/icon-preview-default.png" alt="DBX" class="h-12 w-12 shrink-0" />
+                      <TooltipProvider>
+                        <Tooltip>
+                          <TooltipTrigger as-child>
+                            <div class="w-full min-w-0 text-left">
+                              <div class="text-sm font-medium">{{ t("settings.iconThemeDefault") }}</div>
+                              <div :ref="(el) => setIconThemeDescRef('default', el)" class="text-xs text-muted-foreground truncate">{{ t("settings.iconThemeDefaultDescription") }}</div>
+                            </div>
+                          </TooltipTrigger>
+                          <TooltipContent v-if="iconThemeDescTruncated.default.value" class="max-w-[320px] text-xs leading-relaxed">
+                            {{ t("settings.iconThemeDefaultDescription") }}
+                          </TooltipContent>
+                        </Tooltip>
+                      </TooltipProvider>
+                    </div>
+                  </Button>
+                  <Button type="button" variant="outline" class="settings-choice-card h-auto justify-start border p-3" :class="editIconTheme === 'black' ? 'settings-choice-card--selected border-blue-300 ring-2 ring-blue-300/50' : ''" @click="setIconTheme('black')">
+                    <div class="flex items-center gap-3 text-left w-full min-w-0">
+                      <img src="/icon-preview-black.png" alt="DBX" class="h-12 w-12 shrink-0" />
+                      <TooltipProvider>
+                        <Tooltip>
+                          <TooltipTrigger as-child>
+                            <div class="w-full min-w-0 text-left">
+                              <div class="text-sm font-medium">{{ t("settings.iconThemeBlack") }}</div>
+                              <div :ref="(el) => setIconThemeDescRef('black', el)" class="text-xs text-muted-foreground truncate">{{ iconThemeBlackDescriptionText }}</div>
+                            </div>
+                          </TooltipTrigger>
+                          <TooltipContent v-if="iconThemeDescTruncated.black.value" class="max-w-[320px] text-xs leading-relaxed">
+                            {{ iconThemeBlackDescriptionText }}
+                          </TooltipContent>
+                        </Tooltip>
+                      </TooltipProvider>
+                    </div>
+                  </Button>
+                </div>
+              </div>
+
+              <div v-if="!isWeb" class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="space-y-1">
+                  <Label for="show-tray-icon">{{ t("settings.showTrayIcon") }}</Label>
+                  <p class="text-xs text-muted-foreground">{{ t("settings.showTrayIconDescription") }}</p>
+                </div>
+                <Switch id="show-tray-icon" v-model="editShowTrayIcon" />
+              </div>
+
+              <div v-if="!isWeb" class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="space-y-1">
+                  <Label for="quit-on-close">{{ t("settings.quitOnClose") }}</Label>
+                  <p class="text-xs text-muted-foreground">{{ t("settings.quitOnCloseDescription") }}</p>
+                </div>
+                <Switch id="quit-on-close" v-model="editQuitOnClose" />
+              </div>
+
+              <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="space-y-1">
+                  <Label for="update-notifications-enabled">{{ t("settings.updateNotificationsEnabled") }}</Label>
+                  <p class="text-xs text-muted-foreground">
+                    {{ t("settings.updateNotificationsEnabledDescription") }}
+                  </p>
+                </div>
+                <Switch id="update-notifications-enabled" v-model="editUpdateNotificationsEnabled" />
+              </div>
+
+              <div v-if="!isWeb" class="flex flex-col gap-3 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="flex items-center justify-between gap-4">
+                  <div class="space-y-1">
+                    <Label for="debug-logging-enabled">{{ t("settings.debugLoggingEnabled") }}</Label>
+                    <p class="text-xs text-muted-foreground">
+                      {{ t("settings.debugLoggingEnabledDescription") }}
+                    </p>
+                  </div>
+                  <Switch id="debug-logging-enabled" v-model="editDebugLoggingEnabled" />
+                </div>
+                <div class="flex justify-end gap-2">
+                  <Button type="button" variant="outline" size="sm" @click="clearDebugLogs">
+                    {{ t("settings.debugLogsClear") }}
+                  </Button>
+                  <Button type="button" variant="outline" size="sm" @click="copyDebugLogs">
+                    {{ debugLogCopied ? t("settings.debugLogsCopied") : t("settings.debugLogsCopy") }}
+                  </Button>
+                  <Button type="button" variant="outline" size="sm" @click="exportDebugLogs">
+                    {{ debugLogDownloaded ? t("settings.debugLogsDownloaded") : t("settings.debugLogsDownload") }}
+                  </Button>
+                </div>
+              </div>
+
+              <Separator />
+
+              <div class="settings-appearance-group settings-option-stack">
+                <Label>{{ t("settings.dataGridDisplay") }}</Label>
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="show-column-comments-in-header">
+                      {{ t("settings.showColumnCommentsInHeader") }}
+                    </Label>
+                    <p class="text-xs text-muted-foreground">
+                      {{ t("settings.showColumnCommentsInHeaderDescription") }}
+                    </p>
+                  </div>
+                  <Switch id="show-column-comments-in-header" v-model="editShowColumnCommentsInHeader" />
+                </div>
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="show-column-types-in-header">
+                      {{ t("settings.showColumnTypesInHeader") }}
+                    </Label>
+                    <p class="text-xs text-muted-foreground">
+                      {{ t("settings.showColumnTypesInHeaderDescription") }}
+                    </p>
+                  </div>
+                  <Switch id="show-column-types-in-header" v-model="editShowColumnTypesInHeader" />
+                </div>
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="compact-column-header-actions">
+                      {{ t("settings.compactColumnHeaderActions") }}
+                    </Label>
+                    <p class="text-xs text-muted-foreground">
+                      {{ t("settings.compactColumnHeaderActionsDescription") }}
+                    </p>
+                  </div>
+                  <Switch id="compact-column-header-actions" v-model="editCompactColumnHeaderActions" />
+                </div>
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="data-grid-quick-entry">
+                      {{ t("settings.dataGridQuickEntry") }}
+                    </Label>
+                    <p class="text-xs text-muted-foreground">
+                      {{ t("settings.dataGridQuickEntryDescription") }}
+                    </p>
+                  </div>
+                  <Switch id="data-grid-quick-entry" v-model="editDataGridQuickEntry" />
+                </div>
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="infinite-scroll">
+                      {{ t("settings.infiniteScroll") }}
+                    </Label>
+                    <p class="text-xs text-muted-foreground">
+                      {{ t("settings.infiniteScrollDescription") }}
+                    </p>
+                  </div>
+                  <Switch id="infinite-scroll" v-model="editInfiniteScroll" />
+                </div>
+                <div v-if="editInfiniteScroll" class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="infinite-scroll-max-rows">
+                      {{ t("settings.infiniteScrollMaxRows") }}
+                    </Label>
+                    <p class="text-xs text-muted-foreground">
+                      {{ t("settings.infiniteScrollMaxRowsDescription") }}
+                    </p>
+                  </div>
+                  <Input
+                    id="infinite-scroll-max-rows"
+                    v-model="editInfiniteScrollMaxRows"
+                    type="number"
+                    inputmode="numeric"
+                    :min="1000"
+                    :max="50000"
+                    class="h-7 w-24 px-2 text-xs tabular-nums [appearance:textfield] [&::-webkit-inner-spin-button]:appearance-none [&::-webkit-outer-spin-button]:appearance-none"
+                  />
+                </div>
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="auto-calculate-total-rows">
+                      {{ t("settings.autoCalculateTotalRows") }}
+                    </Label>
+                    <p class="text-xs text-muted-foreground">
+                      {{ t("settings.autoCalculateTotalRowsDescription") }}
+                    </p>
+                  </div>
+                  <Switch id="auto-calculate-total-rows" v-model="editAutoCalculateTotalRows" />
+                </div>
+              </div>
+
+              <Separator />
+
+              <div class="space-y-2">
+                <div class="flex items-center gap-2">
+                  <Label>{{ t("settings.toolbarTitle") }}</Label>
+                  <HelpTooltip :label="t('settings.toolbarTitle')" content-class="max-w-64">
+                    <p>{{ t("settings.toolbarHiddenHint") }}</p>
+                  </HelpTooltip>
+                </div>
+                <div class="grid grid-cols-3 gap-2 mt-2">
+                  <div
+                    v-for="item in [
+                      { key: 'dataTransfer', label: t('transfer.dataTransfer') },
+                      { key: 'driverManager', label: t('toolbar.driverManager') },
+                      { key: 'sqlFile', label: t('sqlFile.title') },
+                      { key: 'schemaDiff', label: t('diff.title') },
+                      { key: 'dataCompare', label: t('dataCompare.title') },
+                      { key: 'checkUpdates', label: t('updates.check') },
+                      { key: 'sqlLibrary', label: t('sqlLibrary.title') },
+                      { key: 'sqlFileTree', label: t('sqlFileTree.title') },
+                      { key: 'history', label: t('history.title') },
+                      { key: 'ai', label: 'AI' },
+                      { key: 'theme', label: t('toolbar.theme') },
+                      { key: 'github', label: 'GitHub' },
+                    ]"
+                    :key="item.key"
+                    class="flex items-center gap-2"
+                  >
+                    <Switch :id="`toolbar-${item.key}`" :model-value="(editToolbarItems as any)[item.key]" @update:model-value="(v: boolean) => ((editToolbarItems as any)[item.key] = v)" />
+                    <Label :for="`toolbar-${item.key}`" class="text-sm cursor-pointer">{{ item.label }}</Label>
+                  </div>
+                </div>
+              </div>
+            </section>
+
+            <section v-else-if="activeSettingsTab === 'navigation'" class="flex flex-col gap-5 py-2">
+              <div class="space-y-2">
+                <Label>{{ t("settings.sidebarActivation") }}</Label>
+                <div class="grid grid-cols-2 gap-2">
+                  <Button type="button" variant="outline" class="h-auto justify-start border p-3" :class="editSidebarActivation === 'single' ? 'border-blue-300 ring-2 ring-blue-300/50' : ''" @click="setSidebarActivation('single')">
+                    <div class="text-left">
+                      <div class="text-sm font-medium">{{ t("settings.sidebarActivationSingle") }}</div>
+                      <div class="text-xs text-muted-foreground">
+                        {{ t("settings.sidebarActivationSingleDescription") }}
+                      </div>
+                    </div>
+                  </Button>
+                  <Button type="button" variant="outline" class="h-auto justify-start border p-3" :class="editSidebarActivation === 'double' ? 'border-blue-300 ring-2 ring-blue-300/50' : ''" @click="setSidebarActivation('double')">
+                    <div class="text-left">
+                      <div class="text-sm font-medium">{{ t("settings.sidebarActivationDouble") }}</div>
+                      <div class="text-xs text-muted-foreground">
+                        {{ t("settings.sidebarActivationDoubleDescription") }}
+                      </div>
+                    </div>
+                  </Button>
+                </div>
+              </div>
+              <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="flex items-center gap-2">
+                  <Label for="reuse-data-tab">{{ t("settings.reuseDataTab") }}</Label>
+                  <HelpTooltip :label="t('settings.reuseDataTab')">
+                    {{ t("settings.reuseDataTabDescription") }}
+                  </HelpTooltip>
+                </div>
+                <Switch id="reuse-data-tab" v-model="editReuseDataTab" />
+              </div>
+              <div class="space-y-2">
+                <Label>{{ t("settings.sidebarObjectDisplay") }}</Label>
+                <div class="grid grid-cols-2 gap-2">
+                  <Button type="button" variant="outline" class="h-auto justify-start border p-3" :class="editSidebarObjectDisplay === 'grouped' ? 'border-blue-300 ring-2 ring-blue-300/50' : ''" @click="setSidebarObjectDisplay('grouped')">
+                    <div class="text-left">
+                      <div class="flex items-center gap-2">
+                        <div class="text-sm font-medium">{{ t("settings.sidebarObjectDisplayGrouped") }}</div>
+                        <Tooltip :open="sidebarObjectDisplayHelp === 'grouped'">
+                          <TooltipTrigger as-child>
+                            <span class="inline-flex shrink-0 cursor-help text-muted-foreground hover:text-foreground" @click.stop @pointerdown.stop @mouseenter="sidebarObjectDisplayHelp = 'grouped'" @mouseleave="sidebarObjectDisplayHelp = null">
+                              <CircleHelp class="h-3.5 w-3.5" />
+                            </span>
+                          </TooltipTrigger>
+                          <TooltipContent class="max-w-[320px] text-xs leading-relaxed" side="top" align="center" :side-offset="8">
+                            {{ t("settings.sidebarObjectDisplayGroupedDescription") }}
+                          </TooltipContent>
+                        </Tooltip>
+                      </div>
+                    </div>
+                  </Button>
+                  <Button type="button" variant="outline" class="h-auto justify-start border p-3" :class="editSidebarObjectDisplay === 'simple' ? 'border-blue-300 ring-2 ring-blue-300/50' : ''" @click="setSidebarObjectDisplay('simple')">
+                    <div class="text-left">
+                      <div class="flex items-center gap-2">
+                        <div class="text-sm font-medium">{{ t("settings.sidebarObjectDisplaySimple") }}</div>
+                        <Tooltip :open="sidebarObjectDisplayHelp === 'simple'">
+                          <TooltipTrigger as-child>
+                            <span class="inline-flex shrink-0 cursor-help text-muted-foreground hover:text-foreground" @click.stop @pointerdown.stop @mouseenter="sidebarObjectDisplayHelp = 'simple'" @mouseleave="sidebarObjectDisplayHelp = null">
+                              <CircleHelp class="h-3.5 w-3.5" />
+                            </span>
+                          </TooltipTrigger>
+                          <TooltipContent class="max-w-[320px] text-xs leading-relaxed" side="top" align="center" :side-offset="8">
+                            {{ t("settings.sidebarObjectDisplaySimpleDescription") }}
+                          </TooltipContent>
+                        </Tooltip>
+                      </div>
+                    </div>
+                  </Button>
+                </div>
+              </div>
+              <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="flex items-center gap-2">
+                  <Label for="sidebar-table-search-enabled">{{ t("settings.sidebarTableSearchEnabled") }}</Label>
+                  <HelpTooltip :label="t('settings.sidebarTableSearchEnabled')">
+                    {{ t("settings.sidebarTableSearchEnabledDescription") }}
+                  </HelpTooltip>
+                </div>
+                <Switch id="sidebar-table-search-enabled" v-model="editSidebarTableSearchEnabled" />
+              </div>
+              <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="flex items-center gap-2">
+                  <Label for="auto-select-active-sidebar-node">{{ t("settings.autoSelectActiveSidebarNode") }}</Label>
+                  <HelpTooltip :label="t('settings.autoSelectActiveSidebarNode')">
+                    {{ t("settings.autoSelectActiveSidebarNodeDescription") }}
+                  </HelpTooltip>
+                </div>
+                <Switch id="auto-select-active-sidebar-node" v-model="editAutoSelectActiveSidebarNode" />
+              </div>
+              <div class="space-y-2 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="flex items-center gap-2">
+                  <Label for="open-tabs-restore-mode">{{ t("settings.openTabsRestoreMode") }}</Label>
+                  <HelpTooltip :label="t('settings.openTabsRestoreMode')">
+                    {{ t("settings.openTabsRestoreModeDescription") }}
+                  </HelpTooltip>
+                </div>
+                <Select :model-value="editOpenTabsRestoreMode" @update:model-value="(value) => (editOpenTabsRestoreMode = value as OpenTabsRestoreMode)">
+                  <SelectTrigger id="open-tabs-restore-mode" class="w-full">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="all">{{ t("settings.openTabsRestoreModeAll") }}</SelectItem>
+                    <SelectItem value="pinned">{{ t("settings.openTabsRestoreModePinned") }}</SelectItem>
+                    <SelectItem value="none">{{ t("settings.openTabsRestoreModeNone") }}</SelectItem>
+                  </SelectContent>
+                </Select>
+                <p class="text-xs text-muted-foreground">
+                  {{ t("settings.openTabsRestoreModeHint") }}
+                </p>
+              </div>
+              <div class="space-y-2 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="flex items-center gap-2">
+                  <Label for="disconnect-tab-handling-mode">{{ t("settings.disconnectTabHandlingMode") }}</Label>
+                  <HelpTooltip :label="t('settings.disconnectTabHandlingMode')">
+                    {{ t("settings.disconnectTabHandlingModeDescription") }}
+                  </HelpTooltip>
+                </div>
+                <Select :model-value="editDisconnectTabHandlingMode" @update:model-value="onDisconnectTabHandlingModeChange">
+                  <SelectTrigger id="disconnect-tab-handling-mode" class="w-full">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem value="close-tabs">{{ t("settings.disconnectTabHandlingModeCloseTabs") }}</SelectItem>
+                    <SelectItem value="keep-tabs-clear-results">
+                      {{ t("settings.disconnectTabHandlingModeKeepTabsClearResults") }}
+                    </SelectItem>
+                    <SelectItem value="keep-tabs-keep-results">
+                      {{ t("settings.disconnectTabHandlingModeKeepTabsKeepResults") }}
+                    </SelectItem>
+                  </SelectContent>
+                </Select>
+                <p class="text-xs text-muted-foreground">
+                  {{ t(`settings.${disconnectTabHandlingModeDescriptionKey}`) }}
+                </p>
+              </div>
+              <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="flex items-center gap-2">
+                  <Label for="sidebar-hide-table-comments">{{ t("settings.sidebarHideTableComments") }}</Label>
+                  <HelpTooltip :label="t('settings.sidebarHideTableComments')">
+                    {{ t("settings.sidebarHideTableCommentsDescription") }}
+                  </HelpTooltip>
+                </div>
+                <Switch id="sidebar-hide-table-comments" v-model="editSidebarHideTableComments" />
+              </div>
+              <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="flex items-center gap-2">
+                  <Label for="sidebar-allow-horizontal-scroll">
+                    {{ t("settings.sidebarAllowHorizontalScroll") }}
+                  </Label>
+                  <HelpTooltip :label="t('settings.sidebarAllowHorizontalScroll')">
+                    {{ t("settings.sidebarAllowHorizontalScrollDescription") }}
+                  </HelpTooltip>
+                </div>
+                <Switch id="sidebar-allow-horizontal-scroll" v-model="editSidebarAllowHorizontalScroll" />
+              </div>
+              <div class="space-y-2">
+                <Label for="sidebar-hidden-table-prefixes">{{ t("settings.sidebarHiddenTablePrefixes") }}</Label>
+                <textarea
+                  id="sidebar-hidden-table-prefixes"
+                  v-model="editSidebarHiddenTablePrefixes"
+                  class="min-h-24 w-full rounded-md border border-input bg-background px-3 py-2 text-sm outline-none transition-colors placeholder:text-muted-foreground focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-ring"
+                  :placeholder="t('settings.sidebarHiddenTablePrefixesPlaceholder')"
+                />
+                <p class="text-xs text-muted-foreground">
+                  {{ t("settings.sidebarHiddenTablePrefixesDescription") }}
+                </p>
+              </div>
+              <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                <div class="space-y-1">
+                  <Label for="sidebar-table-page-size">{{ t("settings.sidebarTablePageSize") }}</Label>
+                  <p class="text-xs text-muted-foreground">
+                    {{ t("settings.sidebarTablePageSizeDescription") }}
+                  </p>
+                </div>
+                <Input
+                  id="sidebar-table-page-size"
+                  type="number"
+                  class="w-24 text-right"
+                  :min="100"
+                  :max="10000"
+                  :step="100"
+                  :model-value="editSidebarTablePageSize"
+                  @update:model-value="
+                    (value: string | number) => {
+                      const n = typeof value === 'string' ? parseInt(value) : value;
+                      if (!isNaN(n)) editSidebarTablePageSize = n;
+                    }
+                  "
+                />
+              </div>
+            </section>
+
+            <!-- Data Tab -->
+            <section v-else-if="activeSettingsTab === 'data'" class="flex flex-col gap-5 py-2">
+              <template v-if="!isWeb">
+                <div class="space-y-3">
+                  <div class="text-sm font-medium text-muted-foreground">DuckDB</div>
+                  <div class="space-y-3 rounded-md border bg-muted/20 px-3 py-2">
+                    <div class="flex items-start justify-between gap-4">
+                      <div class="space-y-1">
+                        <Label for="duckdb-worker-process-isolation">
+                          {{ t("settings.duckDbWorkerProcessIsolation") }}
+                        </Label>
+                        <p class="text-xs text-muted-foreground">
+                          {{ t("settings.duckDbWorkerProcessIsolationDescription") }}
+                        </p>
+                      </div>
+                      <Switch id="duckdb-worker-process-isolation" v-model="editDuckDbWorkerProcessIsolation" class="mt-0.5" />
+                    </div>
+                    <div class="flex items-start justify-between gap-4">
+                      <div class="space-y-1">
+                        <Label for="duckdb-worker-max-processes">
+                          {{ t("settings.duckDbWorkerMaxProcesses") }}
+                        </Label>
+                        <p class="text-xs text-muted-foreground">
+                          {{ t("settings.duckDbWorkerMaxProcessesDescription") }}
+                        </p>
+                      </div>
+                      <Input
+                        id="duckdb-worker-max-processes"
+                        v-model.number="editDuckDbWorkerMaxProcesses"
+                        type="number"
+                        class="h-8 w-20 text-right [&::-webkit-inner-spin-button]:appearance-none"
+                        :min="DUCKDB_WORKER_MAX_PROCESSES_MIN"
+                        :max="DUCKDB_WORKER_MAX_PROCESSES_MAX"
+                        :step="1"
+                        @blur="editDuckDbWorkerMaxProcesses = normalizeDuckDbWorkerMaxProcesses(editDuckDbWorkerMaxProcesses)"
+                      />
+                    </div>
+                    <div v-if="duckDbWorkerSettingsRequireRestart" class="flex flex-wrap items-center gap-2 border-t pt-2">
+                      <p class="text-xs font-medium text-amber-600 dark:text-amber-400">
+                        {{ t("settings.duckDbWorkerProcessIsolationRestartRequired") }}
+                      </p>
+                      <Button type="button" variant="outline" size="sm" class="h-7 gap-1.5 px-2 text-xs" :disabled="duckDbRestarting || hasApplyBlocker" @click="restartDbxForDuckDbIsolation">
+                        <Loader2 v-if="duckDbRestarting" class="size-3.5 animate-spin" />
+                        <RefreshCw v-else class="size-3.5" />
+                        {{ t("settings.restartDbx") }}
+                      </Button>
+                    </div>
+                  </div>
+                </div>
+
+                <Separator />
+              </template>
+
+              <div class="space-y-3">
+                <div class="text-sm font-medium text-muted-foreground">{{ t("settings.exportSection") }}</div>
+                <div class="space-y-2">
+                  <Label>{{ t("settings.exportBatchSize") }}</Label>
+                  <div class="flex items-center gap-3">
+                    <Input type="number" list="export-batch-sizes" min="100" max="100000" step="100" v-model.number="editExportBatchSize" class="h-9 w-28 [&::-webkit-inner-spin-button]:appearance-none" />
+                    <datalist id="export-batch-sizes">
+                      <option value="500" />
+                      <option value="1000" />
+                      <option value="2000" />
+                      <option value="5000" />
+                      <option value="10000" />
+                    </datalist>
+                    <span class="text-xs text-muted-foreground">{{ t("settings.exportBatchSizeDescription") }}</span>
+                  </div>
+                </div>
+                <div class="flex items-start justify-between gap-3">
+                  <div class="space-y-0.5">
+                    <Label for="export-row-limit-enabled">{{ t("settings.exportRowLimitEnabled") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.exportRowLimitEnabledDescription") }}</p>
+                  </div>
+                  <Switch id="export-row-limit-enabled" v-model="editExportRowLimitEnabled" class="mt-0.5" />
+                </div>
+                <div class="space-y-2">
+                  <Label for="export-row-limit">{{ t("settings.exportRowLimit") }}</Label>
+                  <div class="flex items-center gap-3">
+                    <Input id="export-row-limit" type="number" min="100" max="2147483647" step="100" v-model.number="editExportRowLimit" :disabled="!editExportRowLimitEnabled" class="h-9 w-32 [&::-webkit-inner-spin-button]:appearance-none" />
+                    <span class="text-xs text-muted-foreground">
+                      {{ editExportRowLimitEnabled ? t("settings.exportRowLimitDescription") : t("settings.exportRowLimitUnlimited") }}
+                    </span>
+                  </div>
+                </div>
+                <div class="flex items-start justify-between gap-3">
+                  <div class="space-y-0.5">
+                    <Label for="query-export-keyset-enabled">{{ t("settings.queryExportKeysetOptimizationEnabled") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.queryExportKeysetOptimizationEnabledDescription") }}</p>
+                  </div>
+                  <Switch id="query-export-keyset-enabled" v-model="editQueryExportKeysetOptimizationEnabled" class="mt-0.5" />
+                </div>
+              </div>
+
+              <Separator />
+
+              <div class="space-y-3">
+                <div class="text-sm font-medium text-muted-foreground">{{ t("settings.tableStructureSection") }}</div>
+                <div ref="tableColumnTemplateSectionRef" class="space-y-2 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="flex items-start justify-between gap-3">
+                    <div class="space-y-1">
+                      <Label>{{ t("settings.tableColumnTemplateFields") }}</Label>
+                      <p class="text-xs text-muted-foreground">{{ t("settings.tableColumnTemplateFieldsDescription") }}</p>
+                    </div>
+                    <div class="flex items-center gap-2">
+                      <Select v-model="editTableColumnTemplateDatabaseType">
+                        <SelectTrigger class="h-8 w-44 px-2 text-xs">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent class="max-h-72">
+                          <SelectItem v-for="dbType in TABLE_COLUMN_TEMPLATE_DATABASE_TYPES" :key="dbType" :value="dbType">
+                            {{ dbType }}
+                          </SelectItem>
+                        </SelectContent>
+                      </Select>
+                      <Button type="button" size="sm" variant="outline" @click="addTableColumnTemplateRow">
+                        {{ t("settings.tableColumnTemplateAdd") }}
+                      </Button>
+                    </div>
+                  </div>
+                  <div class="overflow-x-auto rounded-md border bg-background">
+                    <table class="w-full min-w-[900px] border-separate border-spacing-0 text-xs">
+                      <thead class="bg-muted/50 text-muted-foreground">
+                        <tr>
+                          <th class="w-8 border-b px-2 py-1.5" />
+                          <th class="border-b px-2 py-1.5 text-left font-medium">{{ t("settings.tableColumnTemplateColumn") }}</th>
+                          <th class="border-b px-2 py-1.5 text-left font-medium">{{ t("settings.tableColumnTemplateType") }}</th>
+                          <th class="border-b px-2 py-1.5 text-left font-medium">{{ t("settings.tableColumnTemplateLength") }}</th>
+                          <th class="border-b px-2 py-1.5 text-left font-medium">{{ t("settings.tableColumnTemplateDefault") }}</th>
+                          <th class="border-b px-2 py-1.5 text-left font-medium">{{ t("settings.tableColumnTemplateRequired") }}</th>
+                          <th class="border-b px-2 py-1.5 text-left font-medium">{{ t("settings.tableColumnTemplateComment") }}</th>
+                          <th class="w-10 border-b px-2 py-1.5" />
+                        </tr>
+                      </thead>
+                      <tbody>
+                        <tr v-for="row in visibleTableColumnTemplateRows" :key="row.id" :data-table-column-template-row-id="row.id" :class="draggedTableColumnTemplateRowId === row.id ? 'opacity-60' : ''">
+                          <td class="border-b px-2 py-1.5 align-middle">
+                            <button
+                              type="button"
+                              class="flex h-7 w-6 cursor-grab touch-none items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground active:cursor-grabbing"
+                              :aria-label="t('settings.tableColumnTemplateDragHandle')"
+                              @pointerdown="startTableColumnTemplateRowDrag(row.id, $event)"
+                            >
+                              <GripVertical class="h-3.5 w-3.5" />
+                            </button>
+                          </td>
+                          <td class="border-b px-2 py-1.5">
+                            <Input v-model="row.name" class="h-7 px-2 text-xs" />
+                          </td>
+                          <td class="border-b px-2 py-1.5">
+                            <SearchableSelect
+                              :model-value="tableColumnTemplateBaseTypeForSelectedDatabase(row)"
+                              :options="tableColumnTemplateTypeOptions(editTableColumnTemplateDatabaseType)"
+                              :placeholder="t('settings.tableColumnTemplateNoPresetType')"
+                              :search-placeholder="t('structureEditor.typePlaceholder')"
+                              :empty-text="t('structureEditor.noMatchingType')"
+                              :loading-text="t('common.loading')"
+                              :allow-custom="true"
+                              :trigger-class="['h-7 w-full px-2 font-mono text-xs']"
+                              @update:model-value="setTableColumnTemplateBaseTypeForSelectedDatabase(row, $event)"
+                            />
+                          </td>
+                          <td class="border-b px-2 py-1.5">
+                            <Input :model-value="tableColumnTemplateLengthForSelectedDatabase(row)" class="h-7 w-28 px-2 font-mono text-xs" :disabled="isTableColumnTemplateLengthDisabled(row)" @update:model-value="setTableColumnTemplateLengthForSelectedDatabase(row, String($event))" />
+                          </td>
+                          <td class="border-b px-2 py-1.5">
+                            <Input v-model="row.defaultValue" class="h-7 px-2 font-mono text-xs" />
+                          </td>
+                          <td class="border-b px-2 py-1.5">
+                            <Switch v-model="row.required" />
+                          </td>
+                          <td class="border-b px-2 py-1.5">
+                            <Input v-model="row.comment" class="h-7 px-2 text-xs" />
+                          </td>
+                          <td class="border-b px-2 py-1.5 text-right">
+                            <Button type="button" variant="ghost" size="icon" class="h-7 w-7" @click="removeTableColumnTemplateRow(row.id)">
+                              <X class="h-3.5 w-3.5" />
+                            </Button>
+                          </td>
+                        </tr>
+                      </tbody>
+                    </table>
+                  </div>
+                </div>
+              </div>
+            </section>
+
+            <section v-else-if="activeSettingsTab === 'shortcuts'" class="flex flex-col gap-2 py-2">
+              <div class="relative">
+                <Search class="pointer-events-none absolute top-1/2 left-3 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
+                <Input v-model="shortcutSearchQuery" autocomplete="off" :placeholder="t('settings.shortcutSearchPlaceholder')" class="h-9 pl-9 text-sm" />
+              </div>
+              <div class="overflow-hidden rounded-md border border-border/70 bg-background">
+                <div v-if="filteredShortcutDefinitions.length === 0" class="px-3 py-8 text-center text-sm text-muted-foreground">
+                  {{ t("settings.shortcutSearchNoResults") }}
+                </div>
+                <div v-for="definition in filteredShortcutDefinitions" :key="definition.id" class="group -mt-px grid gap-2 border-t border-border/70 px-3 py-2 transition-colors first:mt-0 first:border-t-0 hover:bg-muted/40 sm:grid-cols-[minmax(0,1fr)_auto] sm:items-center">
+                  <div class="min-w-0">
+                    <div class="flex min-w-0 items-center gap-2">
+                      <Label class="min-w-0 truncate leading-none">{{ t(definition.labelKey) }}</Label>
+                      <Badge variant="outline" class="h-5 shrink-0 rounded-md border-border/60 px-1.5 text-[11px] font-normal text-muted-foreground">
+                        {{ t(`settings.shortcutScope${definition.scope[0].toUpperCase()}${definition.scope.slice(1)}`) }}
+                      </Badge>
+                    </div>
+                  </div>
+                  <div class="min-w-0 space-y-1">
+                    <div class="flex items-center justify-end gap-1.5">
+                      <input
+                        :data-shortcut-input="definition.id"
+                        :value="editingShortcutId === definition.id ? '' : formatShortcutPill(editShortcuts[definition.id])"
+                        :style="{
+                          width: editingShortcutId === definition.id ? shortcutPressShortcutInputWidth : `${Math.max(4, formatShortcutPill(editShortcuts[definition.id]).length + 3)}ch`,
+                        }"
+                        readonly
+                        :aria-invalid="shortcutConflicts.includes(definition.id)"
+                        :placeholder="t('settings.shortcutPressShortcut')"
+                        class="h-7 w-auto min-w-12 max-w-64 shrink-0 cursor-default rounded-[6px] border border-transparent bg-muted px-2.5 text-center font-mono text-[13px] font-semibold text-foreground/75 shadow-inner outline-none selection:bg-transparent placeholder:text-muted-foreground aria-invalid:border-destructive/70 aria-invalid:text-destructive aria-invalid:ring-destructive/20"
+                        :class="editingShortcutId === definition.id ? 'max-w-64 cursor-text border-border/80 bg-background text-left text-foreground shadow-none focus-visible:border-ring focus-visible:ring-2 focus-visible:ring-ring/35' : ''"
+                        @keydown="(event: KeyboardEvent) => onShortcutKeydown(definition.id, event)"
+                      />
+                      <Button
+                        v-if="editingShortcutId !== definition.id"
+                        type="button"
+                        variant="ghost"
+                        size="icon"
+                        class="h-7 w-7 shrink-0 text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:opacity-100 group-hover:opacity-100"
+                        :aria-label="t('settings.shortcutPressShortcut')"
+                        @click="focusShortcutInput(definition.id)"
+                      >
+                        <Pencil class="h-4 w-4" />
+                      </Button>
+                      <Button v-else type="button" variant="ghost" size="sm" class="h-7 shrink-0 px-2 text-sm font-medium text-muted-foreground hover:text-foreground" @click="cancelShortcutEdit">
+                        {{ t("settings.cancel") }}
+                      </Button>
+                      <Button
+                        v-if="editingShortcutId !== definition.id"
+                        type="button"
+                        variant="ghost"
+                        size="icon"
+                        class="h-7 w-7 shrink-0 text-muted-foreground opacity-0 transition-opacity hover:text-foreground focus-visible:opacity-100 group-hover:opacity-100"
+                        :aria-label="t('settings.reset')"
+                        @click="resetShortcut(definition.id)"
+                      >
+                        <RotateCcw class="h-4 w-4" />
+                      </Button>
+                      <Button
+                        v-if="editingShortcutId !== definition.id && editShortcuts[definition.id]"
+                        type="button"
+                        variant="ghost"
+                        size="icon"
+                        class="h-7 w-7 shrink-0 text-muted-foreground opacity-0 transition-opacity hover:text-destructive focus-visible:opacity-100 group-hover:opacity-100"
+                        :aria-label="t('settings.shortcutClear')"
+                        @click="clearShortcut(definition.id)"
+                      >
+                        <X class="h-4 w-4" />
+                      </Button>
+                      <span v-else-if="editingShortcutId !== definition.id" class="h-7 w-7 shrink-0" aria-hidden="true" />
+                    </div>
+                    <p v-if="shortcutConflicts.includes(definition.id)" class="text-xs text-destructive">
+                      {{ t("settings.shortcutConflict") }}
+                    </p>
+                  </div>
+                </div>
+              </div>
+            </section>
+
+            <!-- Snippets Tab -->
+            <section v-else-if="activeSettingsTab === 'snippets'" class="flex flex-col gap-4 py-2">
+              <div class="flex items-center justify-between">
+                <p class="text-sm text-muted-foreground">{{ t("settings.snippetsDescription") }}</p>
+                <Button variant="outline" size="sm" @click="openAddSnippetDialog">
+                  <Plus class="mr-2 h-4 w-4" />
+                  {{ t("settings.snippetsAdd") }}
+                </Button>
+              </div>
+
+              <div class="overflow-x-auto rounded-md border">
+                <table class="w-full min-w-[720px] text-sm">
+                  <thead>
+                    <tr class="border-b bg-muted/50">
+                      <th class="px-3 py-2 text-left font-medium whitespace-nowrap">
+                        {{ t("settings.snippetsLabel") }}
+                      </th>
+                      <th class="px-3 py-2 text-left font-medium whitespace-nowrap">
+                        {{ t("settings.snippetsPrefix") }}
+                      </th>
+                      <th class="px-3 py-2 text-left font-medium whitespace-nowrap">
+                        {{ t("settings.snippetsStatus") }}
+                      </th>
+                      <th class="px-3 py-2 text-left font-medium whitespace-nowrap">
+                        {{ t("settings.snippetsBody") }}
+                      </th>
+                      <th class="px-3 py-2 w-20"></th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    <tr v-for="snippet in editSnippets" :key="snippet.id" class="border-b last:border-b-0 hover:bg-muted/30" :class="snippet.enabled === false ? 'text-muted-foreground' : ''">
+                      <td class="px-3 py-2">{{ snippet.label }}</td>
+                      <td class="px-3 py-2">
+                        <Badge variant="outline" class="h-5 rounded-md px-1.5 text-[11px] font-mono text-muted-foreground">
+                          {{ snippet.prefix }}
+                        </Badge>
+                      </td>
+                      <td class="px-3 py-2">
+                        <div class="flex items-center gap-2">
+                          <Switch :id="`snippet-enabled-${snippet.id}`" :model-value="snippet.enabled !== false" size="sm" :aria-label="t('settings.snippetsToggle')" @update:model-value="(value: boolean) => setSnippetEnabled(snippet.id, value)" />
+                          <Label :for="`snippet-enabled-${snippet.id}`" class="text-xs font-normal text-muted-foreground">
+                            {{ snippet.enabled === false ? t("settings.snippetsDisabled") : t("settings.snippetsEnabled") }}
+                          </Label>
+                        </div>
+                      </td>
+                      <td class="px-3 py-2 font-mono text-xs text-muted-foreground max-w-[300px] truncate">
+                        {{ snippet.body }}
+                      </td>
+                      <td class="px-3 py-2">
+                        <div class="flex items-center gap-1">
+                          <Button variant="ghost" size="icon-xs" @click="openEditSnippetDialog(snippet)">
+                            <Pencil class="size-3.5" />
+                          </Button>
+                          <Button variant="ghost" size="icon-xs" @click="confirmDeleteSnippet(snippet)">
+                            <Trash2 class="size-3.5" />
+                          </Button>
+                        </div>
+                      </td>
+                    </tr>
+                  </tbody>
+                </table>
+              </div>
+            </section>
+
+            <section v-else-if="activeSettingsTab === 'sync'" class="py-2">
+              <Tabs v-model="syncMethodTab" class="w-full">
+                <TabsList class="grid w-full grid-cols-2">
+                  <TabsTrigger value="webdav">WebDAV</TabsTrigger>
+                  <TabsTrigger value="snippet">GitHub / Gitee</TabsTrigger>
+                </TabsList>
+
+                <TabsContent value="webdav" class="mt-5 space-y-5">
+                  <div class="space-y-1">
+                    <div class="flex items-center gap-2 text-sm font-medium">
+                      <Cloud class="h-4 w-4 text-muted-foreground" />
+                      {{ t("settings.syncWebDavTitle") }}
+                    </div>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.syncWebDavDescription") }}</p>
+                  </div>
+
+                  <div class="grid gap-4 md:grid-cols-2">
+                    <div class="space-y-2 md:col-span-2">
+                      <Label for="webdav-endpoint">{{ t("settings.syncEndpoint") }}</Label>
+                      <Input id="webdav-endpoint" v-model="webdavEndpoint" autocomplete="off" placeholder="https://example.com/remote.php/dav/files/user/" />
+                    </div>
+                    <div class="space-y-2">
+                      <Label for="webdav-username">{{ t("settings.syncUsername") }}</Label>
+                      <Input id="webdav-username" v-model="webdavUsername" autocomplete="username" />
+                    </div>
+                    <div class="space-y-2">
+                      <Label for="webdav-password">{{ t("settings.syncPassword") }}</Label>
+                      <div class="relative">
+                        <PasswordInput id="webdav-password" v-model="webdavPassword" :placeholder="webdavHasSavedPassword ? '••••••••' : t('settings.syncPasswordPlaceholder')" :disabled="webdavHasSavedPassword" :show-toggle="!webdavHasSavedPassword" autocomplete="current-password" />
+                        <button
+                          v-if="webdavHasSavedPassword"
+                          type="button"
+                          class="absolute right-1 top-1/2 inline-flex size-7 -translate-y-1/2 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-accent hover:text-accent-foreground focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-3 focus-visible:outline-none disabled:pointer-events-none disabled:opacity-50"
+                          :title="t('settings.syncClearSavedPassword')"
+                          @click="
+                            webdavRememberPassword = false;
+                            forgetWebdavSavedPassword(currentWebDavAccountConfig());
+                            webdavHasSavedPassword = false;
+                            webdavPassword = '';
+                          "
+                        >
+                          <X class="size-3.5" />
+                        </button>
+                      </div>
+                      <div class="flex items-center gap-2 text-xs text-muted-foreground">
+                        <label class="flex items-center gap-2">
+                          <input v-model="webdavRememberPassword" type="checkbox" class="h-4 w-4 shrink-0 accent-primary" />
+                          <span>
+                            {{ t("settings.syncRememberWebDavPassword") }}
+                            <span v-if="webdavHasSavedPassword">{{ t("settings.syncSavedPassword") }}</span>
+                          </span>
+                        </label>
+                        <HelpTooltip :label="t('settings.syncRememberWebDavPassword')">
+                          {{ t("settings.syncRememberWebDavPasswordDescription") }}
+                        </HelpTooltip>
+                      </div>
+                    </div>
+                    <div class="space-y-2 md:col-span-2">
+                      <Label for="webdav-remote-path">{{ t("settings.syncRemotePath") }}</Label>
+                      <Input id="webdav-remote-path" v-model="webdavRemotePath" autocomplete="off" />
+                      <p class="text-xs text-muted-foreground">{{ t("settings.syncRemotePathDescription") }}</p>
+                    </div>
+                    <div class="space-y-2 md:col-span-2 rounded-md border bg-muted/20 px-3 py-3">
+                      <label class="flex items-center gap-2 text-xs">
+                        <input v-model="webdavAutoUploadEnabled" type="checkbox" class="h-4 w-4 shrink-0 accent-primary" />
+                        <span class="font-medium">{{ t("settings.syncAutoUpload") }}</span>
+                      </label>
+                      <div class="flex items-center gap-2">
+                        <Label for="webdav-auto-upload-interval" class="text-xs text-muted-foreground">{{ t("settings.syncAutoUploadInterval") }}</Label>
+                        <Input id="webdav-auto-upload-interval" v-model.number="webdavAutoUploadIntervalMinutes" type="number" min="1" max="1440" step="1" class="h-7 w-24 text-xs" :disabled="!webdavAutoUploadEnabled" />
+                        <span class="text-xs text-muted-foreground">{{ t("settings.syncAutoUploadMinutes") }}</span>
+                      </div>
+                      <p class="text-xs text-muted-foreground">{{ t("settings.syncAutoUploadDescription") }}</p>
+                    </div>
+                  </div>
+
+                  <div v-if="webdavMessage" class="text-xs" :class="webdavError ? 'text-destructive' : 'text-green-600 dark:text-green-400'">
+                    {{ webdavMessage }}
+                  </div>
+                  <div class="flex flex-wrap justify-end gap-2">
+                    <Button variant="outline" size="sm" :disabled="!webdavReady" @click="testWebDav">
+                      <Loader2 v-if="webdavBusy === 'test'" class="mr-1 h-3 w-3 animate-spin" />
+                      {{ t("settings.syncTest") }}
+                    </Button>
+                    <Button variant="outline" size="sm" :disabled="!webdavReady" @click="downloadWebDavSnapshot">
+                      <Loader2 v-if="webdavBusy === 'download'" class="mr-1 h-3 w-3 animate-spin" />
+                      <Download v-else class="mr-1 h-3 w-3" />
+                      {{ t("settings.syncDownload") }}
+                    </Button>
+                    <Button size="sm" :disabled="!webdavReady" @click="uploadWebDavSnapshot">
+                      <Loader2 v-if="webdavBusy === 'upload'" class="mr-1 h-3 w-3 animate-spin" />
+                      <Upload v-else class="mr-1 h-3 w-3" />
+                      {{ t("settings.syncUpload") }}
+                    </Button>
+                  </div>
+                </TabsContent>
+
+                <TabsContent value="snippet" class="mt-5 space-y-5">
+                  <div class="space-y-1">
+                    <div class="flex items-center justify-between gap-3">
+                      <div class="flex items-center gap-2 text-sm font-medium">
+                        <Cloud class="h-4 w-4 text-muted-foreground" />
+                        {{ t("settings.syncSnippetTitle") }}
+                      </div>
+                      <Button type="button" variant="ghost" size="sm" class="h-7 px-2 text-xs" @click="openExternalUrl(`https://dbxio.com/${currentLocale() === 'zh-CN' ? 'cn' : 'en'}/docs/cloud-sync`)">
+                        <ExternalLink class="mr-1 h-3 w-3" />
+                        {{ t("settings.syncSnippetGuide") }}
+                      </Button>
+                    </div>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.syncSnippetDescription") }}</p>
+                  </div>
+
+                  <div class="grid gap-4 rounded-md border p-4 md:grid-cols-2">
+                    <div class="space-y-2">
+                      <Label>{{ t("settings.syncSnippetProvider") }}</Label>
+                      <Select v-model="snippetProvider">
+                        <SelectTrigger><SelectValue /></SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="github">GitHub Gist</SelectItem>
+                          <SelectItem value="gitee">Gitee 代码片段</SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                    <div class="space-y-2">
+                      <Label for="snippet-sync-id">{{ t("settings.syncSnippetId") }}</Label>
+                      <Input id="snippet-sync-id" v-model="snippetId" autocomplete="off" :placeholder="t('settings.syncSnippetIdPlaceholder')" />
+                    </div>
+                    <div class="space-y-2 md:col-span-2">
+                      <Label for="snippet-sync-token">{{ t("settings.syncSnippetToken") }}</Label>
+                      <div class="relative">
+                        <PasswordInput id="snippet-sync-token" v-model="snippetToken" :placeholder="snippetHasSavedToken ? '••••••••' : ''" :disabled="snippetHasSavedToken" :show-toggle="!snippetHasSavedToken" autocomplete="off" />
+                        <button
+                          v-if="snippetHasSavedToken"
+                          type="button"
+                          class="absolute right-1 top-1/2 inline-flex size-7 -translate-y-1/2 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-accent hover:text-accent-foreground"
+                          :title="t('settings.syncClearSavedPassword')"
+                          @click="
+                            snippetRememberToken = false;
+                            forgetSnippetSavedToken(currentSnippetAccountConfig());
+                            snippetHasSavedToken = false;
+                            snippetToken = '';
+                          "
+                        >
+                          <X class="size-3.5" />
+                        </button>
+                      </div>
+                      <label class="flex items-center gap-2 text-xs text-muted-foreground">
+                        <input v-model="snippetRememberToken" type="checkbox" class="h-4 w-4 shrink-0 accent-primary" />
+                        <span>{{ t("settings.syncSnippetRememberToken") }}</span>
+                      </label>
+                      <p class="text-xs text-muted-foreground">{{ t("settings.syncSnippetTokenDescription") }}</p>
+                    </div>
+                    <div class="flex flex-wrap items-center justify-between gap-3 md:col-span-2">
+                      <div v-if="snippetMessage" class="min-w-0 flex-1 text-xs" :class="snippetError ? 'text-destructive' : 'text-green-600 dark:text-green-400'">
+                        {{ snippetMessage }}
+                      </div>
+                      <div v-else class="flex-1" />
+                      <div class="flex shrink-0 flex-wrap justify-end gap-2">
+                        <Button variant="outline" size="sm" :disabled="!snippetReady" @click="testSnippetSync">
+                          <Loader2 v-if="snippetBusy === 'test'" class="mr-1 h-3 w-3 animate-spin" />
+                          {{ t("settings.syncTest") }}
+                        </Button>
+                        <Button variant="outline" size="sm" :disabled="!snippetReady || !snippetId.trim()" @click="downloadSnippetSnapshot">
+                          <Loader2 v-if="snippetBusy === 'download'" class="mr-1 h-3 w-3 animate-spin" />
+                          <Download v-else class="mr-1 h-3 w-3" />
+                          {{ t("settings.syncDownload") }}
+                        </Button>
+                        <Button size="sm" :disabled="!snippetReady" @click="uploadSnippetSnapshot">
+                          <Loader2 v-if="snippetBusy === 'upload'" class="mr-1 h-3 w-3 animate-spin" />
+                          <Upload v-else class="mr-1 h-3 w-3" />
+                          {{ t("settings.syncUpload") }}
+                        </Button>
+                      </div>
+                    </div>
+                  </div>
+                </TabsContent>
+              </Tabs>
+
+              <div class="mt-5 space-y-3 rounded-md border bg-muted/20 px-3 py-3">
+                <div class="flex items-center justify-between gap-4">
+                  <div class="space-y-1">
+                    <Label for="sync-secrets">{{ t("settings.syncSecrets") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.syncSecretsSharedDescription") }}</p>
+                  </div>
+                  <Switch id="sync-secrets" v-model="webdavSyncSecrets" />
+                </div>
+                <div class="rounded-md border bg-background/60 px-3 py-2 text-xs text-muted-foreground">
+                  {{ t("settings.syncSecretNotice") }}
+                </div>
+                <div v-if="webdavSyncSecrets" class="space-y-2">
+                  <Label for="sync-secrets-passphrase">{{ t("settings.syncSecretsPassphrase") }}</Label>
+                  <div class="flex items-center gap-2">
+                    <PasswordInput id="sync-secrets-passphrase" v-model="webdavSecretsPassphrase" class="min-w-0 flex-1" :placeholder="webdavHasSavedSecretsPassphrase ? '••••••••' : ''" :show-toggle="!webdavHasSavedSecretsPassphrase || !!webdavSecretsPassphrase" autocomplete="new-password" />
+                    <Button
+                      v-if="webdavHasSavedSecretsPassphrase"
+                      type="button"
+                      variant="ghost"
+                      size="icon"
+                      class="h-9 w-9 shrink-0 text-muted-foreground hover:text-foreground"
+                      :title="t('settings.syncClearSavedPassword')"
+                      :aria-label="t('settings.syncClearSavedPassword')"
+                      @click="clearWebDavSyncSecretsPassphrase"
+                    >
+                      <X class="size-3.5" />
+                    </Button>
+                  </div>
+                  <p class="text-xs text-muted-foreground">{{ t("settings.syncSecretsPassphraseDescription") }}</p>
+                </div>
+              </div>
+            </section>
+
+            <!-- AI Settings Tab -->
+            <section v-else-if="activeSettingsTab === 'ai'" class="flex flex-col gap-5 py-2">
+              <div class="space-y-3">
+                <div class="grid grid-cols-3 items-center gap-3">
+                  <Label class="text-right text-xs">{{ t("ai.provider") }}</Label>
+                  <Select :model-value="aiEditProvider" @update:model-value="(v: any) => aiSelectProvider(v)">
+                    <SelectTrigger class="col-span-2" inputClass="h-8 text-xs">
+                      <SelectValue>
+                        <span class="flex items-center gap-2">
+                          <AiProviderLogo :provider="selectedAiProviderPreset.provider" :label="selectedAiProviderPreset.label" :icon-slug="selectedAiProviderPreset.iconSlug" />
+                          <span>{{ selectedAiProviderPreset.label }}</span>
+                        </span>
+                      </SelectValue>
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem v-for="provider in aiProviderOptions" :key="provider.provider" :value="provider.provider">
+                        <span class="flex w-full items-center justify-between gap-4">
+                          <span class="flex items-center gap-2">
+                            <AiProviderLogo :provider="provider.provider" :label="provider.label" :icon-slug="provider.iconSlug" />
+                            <span>{{ provider.label }}</span>
+                          </span>
+                          <span class="flex shrink-0 items-center gap-1">
+                            <span v-if="aiEditProvider === provider.provider" class="rounded px-1 py-0.5 text-[10px] font-medium leading-none" :class="settingsStore.isAiProviderConfigured(provider.provider) ? 'bg-primary/15 text-primary' : 'bg-muted text-muted-foreground'">{{
+                              t("ai.providerStatusActive")
+                            }}</span>
+                            <span v-else-if="settingsStore.isAiProviderConfigured(provider.provider)" class="rounded bg-green-500/15 px-1 py-0.5 text-[10px] font-medium leading-none text-green-700 dark:text-green-400">{{ t("ai.providerStatusConfigured") }}</span>
+                          </span>
+                        </span>
+                      </SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+
+                <div v-if="aiIsCodexCli && !isWeb" class="rounded-md border px-3 py-2.5 text-xs" :class="aiCodexMcpNeedsInstall ? 'border-amber-500/30 bg-amber-500/10 text-amber-700 dark:text-amber-300' : 'border-green-500/30 bg-green-500/10 text-green-700 dark:text-green-300'">
+                  <div class="flex flex-col gap-2 sm:flex-row sm:items-start sm:justify-between">
+                    <div class="min-w-0 space-y-1">
+                      <div class="flex min-w-0 items-center gap-2 font-medium">
+                        <Loader2 v-if="mcpStatusLoading" class="h-3.5 w-3.5 shrink-0 animate-spin" />
+                        <AlertTriangle v-else-if="aiCodexMcpNeedsInstall || mcpStatus?.error || mcpStatusError" class="h-3.5 w-3.5 shrink-0" />
+                        <CheckCircle2 v-else class="h-3.5 w-3.5 shrink-0" />
+                        <span>{{ t("ai.codexMcpRequiredTitle") }}</span>
+                        <Badge variant="outline" class="h-5 shrink-0 rounded-md border-current/30 px-1.5 text-[11px] font-normal">
+                          {{ mcpStatusLabel }}
+                        </Badge>
+                      </div>
+                      <p class="leading-relaxed">
+                        {{ t("ai.codexMcpRequiredDescription") }}
+                      </p>
+                      <p v-if="mcpStatus?.error || mcpStatusError" class="select-text leading-relaxed">
+                        {{ mcpStatusError || mcpStatus?.error }}
+                      </p>
+                    </div>
+                    <div class="flex shrink-0 items-center gap-2">
+                      <Button type="button" size="sm" variant="outline" class="h-7 bg-background/80 px-2 text-xs" :disabled="mcpStatusLoading" @click="refreshMcpStatus">
+                        <Loader2 v-if="mcpStatusLoading" class="mr-1 h-3 w-3 animate-spin" />
+                        <RefreshCw v-else class="mr-1 h-3 w-3" />
+                        {{ t("settings.mcpRefresh") }}
+                      </Button>
+                      <Button v-if="aiCodexMcpNeedsInstall || mcpStatus?.update_available" type="button" size="sm" class="h-7 px-2 text-xs" :disabled="!aiCodexMcpCanInstall" @click="installMcp">
+                        <Loader2 v-if="mcpInstalling" class="mr-1 h-3 w-3 animate-spin" />
+                        {{ mcpInstalling ? t("settings.mcpInstalling") : aiCodexMcpActionLabel }}
+                      </Button>
+                    </div>
+                  </div>
+                </div>
+
+                <div v-if="!aiIsCodexCli && aiSupportsAuthMethod" class="grid grid-cols-3 items-center gap-3">
+                  <Label class="text-right text-xs">Authentication</Label>
+                  <Select v-model="aiEditAuthMethod">
+                    <SelectTrigger class="col-span-2" inputClass="h-8 text-xs">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="api-key">API Key</SelectItem>
+                      <SelectItem value="bearer">Auth Token</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+
+                <div v-if="!aiIsCodexCli" class="grid grid-cols-3 items-center gap-3">
+                  <Label class="text-right text-xs">{{ aiCredentialLabel }}</Label>
+                  <PasswordInput v-model="aiEditApiKey" autocomplete="off" class="col-span-2" inputClass="h-8 text-xs" :placeholder="aiCredentialPlaceholder" />
+                </div>
+
+                <div v-if="!aiIsCodexCli" class="grid grid-cols-3 items-start gap-3">
+                  <Label class="pt-2 text-right text-xs">Endpoint</Label>
+                  <div class="col-span-2 space-y-1.5">
+                    <Input v-model="aiEditEndpoint" :placeholder="aiEndpointPlaceholder" autocomplete="off" class="h-8 text-xs" />
+                    <p v-if="aiEndpointHint" class="text-[11px] text-muted-foreground">{{ aiEndpointHint }}</p>
+                  </div>
+                </div>
+
+                <div v-if="aiIsCodexCli" class="grid grid-cols-3 items-start gap-3">
+                  <Label class="pt-2 text-right text-xs">{{ t("ai.codexCliPath") }}</Label>
+                  <div class="col-span-2 space-y-1.5">
+                    <Input v-model="aiEditCodexCliPath" autocomplete="off" class="h-8 text-xs" placeholder="codex" />
+                    <p class="text-[11px] text-muted-foreground">{{ t("ai.codexCliPathHint") }}</p>
+                    <p v-if="aiCodexPathError" class="text-[11px] text-destructive">{{ aiCodexPathError }}</p>
+                  </div>
+                </div>
+
+                <div v-if="aiIsCodexCli" class="grid grid-cols-3 items-start gap-3">
+                  <Label class="pt-2 text-right text-xs">{{ t("ai.codexCliEnv") }}</Label>
+                  <div class="col-span-2 space-y-2">
+                    <div class="space-y-1.5">
+                      <div v-for="row in aiEditCodexCliEnvRows" :key="row.id" class="grid grid-cols-[minmax(0,0.9fr)_minmax(0,1.3fr)_2rem] gap-2">
+                        <Input v-model="row.key" autocomplete="off" class="h-8 font-mono text-xs" :placeholder="t('ai.codexCliEnvKeyPlaceholder')" />
+                        <Input v-model="row.value" autocomplete="off" class="h-8 font-mono text-xs" :placeholder="t('ai.codexCliEnvValuePlaceholder')" />
+                        <Button type="button" variant="ghost" size="icon" class="h-8 w-8" :title="t('common.remove')" :aria-label="t('common.remove')" @click="removeCodexEnvRow(row.id)">
+                          <X class="h-3.5 w-3.5" />
+                        </Button>
+                      </div>
+                    </div>
+                    <Button type="button" variant="outline" size="sm" class="h-7 px-2 text-xs" @click="addCodexEnvRow">
+                      <Plus class="mr-1 h-3.5 w-3.5" />
+                      {{ t("ai.codexCliEnvAdd") }}
+                    </Button>
+                    <p v-if="aiCodexEnvError" class="text-[11px] text-destructive">{{ aiCodexEnvError }}</p>
+                    <p v-else class="text-[11px] text-muted-foreground">{{ t("ai.codexCliEnvHint") }}</p>
+                  </div>
+                </div>
+
+                <div class="grid grid-cols-3 items-start gap-3">
+                  <Label class="pt-2 text-right text-xs">{{ t("ai.model") }}</Label>
+                  <div class="col-span-2 space-y-1.5">
+                    <div class="flex min-w-0 items-center gap-2">
+                      <Input v-model="aiEditModel" autocomplete="off" class="h-8 min-w-0 flex-1 text-xs" />
+                      <SearchableSelect
+                        :model-value="aiEditModel"
+                        :options="aiModelOptionIds"
+                        :placeholder="t('ai.browseModels')"
+                        :search-placeholder="t('ai.searchModels')"
+                        :empty-text="aiModelEmptyText"
+                        :loading-text="t('ai.loadingModels')"
+                        :loading="aiModelLoading"
+                        :display-name="displayAiModelName"
+                        trigger-class="h-8 min-w-[104px] max-w-[150px] shrink-0 border border-border bg-background px-2 text-xs shadow-none hover:bg-muted/50"
+                        content-class="w-72"
+                        item-class="h-auto min-h-8 py-1.5"
+                        @update:model-value="aiSelectModel"
+                        @update:open="onAiModelListOpen"
+                      >
+                        <template #trigger-label="{ loading }">
+                          <span class="truncate">{{ loading ? t("ai.loadingModels") : t("ai.browseModels") }}</span>
+                        </template>
+                        <template #option-label="{ option, label }">
+                          <span class="flex min-w-0 flex-col leading-tight">
+                            <span class="truncate">{{ aiModelOptionPresentation(option, label).primary }}</span>
+                            <span v-if="aiModelOptionSecondary(option, label)" class="mt-0.5 truncate text-[11px] text-muted-foreground">{{ aiModelOptionSecondary(option, label) }}</span>
+                          </span>
+                        </template>
+                      </SearchableSelect>
+                      <Button type="button" size="icon" variant="outline" class="shrink-0" :disabled="aiModelLoading || !aiModelListSupported" :title="t('ai.refreshModels')" :aria-label="t('ai.refreshModels')" @click="aiRefreshModels">
+                        <Loader2 v-if="aiModelLoading" class="h-3.5 w-3.5 animate-spin" />
+                        <RefreshCw v-else class="h-3.5 w-3.5" />
+                      </Button>
+                    </div>
+                    <p v-if="aiModelError" class="text-xs text-destructive">{{ aiModelError }}</p>
+                    <p v-else-if="!aiModelOptionIds.length" class="text-xs text-muted-foreground">
+                      {{ aiModelListSupported ? t("ai.modelListHint") : t("ai.modelListUnsupported") }}
+                    </p>
+                  </div>
+                </div>
+
+                <div v-if="aiIsCodexCli" class="grid grid-cols-3 items-start gap-3">
+                  <Label class="pt-2 text-right text-xs">{{ t("ai.reasoningLevel") }}</Label>
+                  <div class="col-span-2 space-y-1.5">
+                    <Select v-model="aiEditReasoningLevel">
+                      <SelectTrigger inputClass="h-8 text-xs">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem v-for="option in aiReasoningLevelOptions" :key="option.value" :value="option.value">
+                          {{ t(option.labelKey) }}
+                        </SelectItem>
+                      </SelectContent>
+                    </Select>
+                    <p class="text-[11px] text-muted-foreground">{{ t("ai.reasoningLevelHint") }}</p>
+                  </div>
+                </div>
+
+                <div v-if="aiSupportsApiStyle" class="grid grid-cols-3 items-center gap-3">
+                  <Label class="text-right text-xs">API</Label>
+                  <div class="col-span-2 flex gap-2">
+                    <Button size="sm" variant="outline" class="h-8 flex-1 text-xs" :class="{ 'border-blue-300 border-2 ring-2 ring-blue-300/50': aiEditApiStyle === 'completions' }" @click="aiSelectApiStyle('completions')">/chat/completions</Button>
+                    <Button size="sm" variant="outline" class="h-8 flex-1 text-xs" :class="{ 'border-blue-300 border-2 ring-2 ring-blue-300/50': aiEditApiStyle === 'responses' }" @click="aiSelectApiStyle('responses')">/responses</Button>
+                    <Button v-if="aiSupportsAnthropicApiStyle" size="sm" variant="outline" class="h-8 flex-1 text-xs" :class="{ 'border-blue-300 border-2 ring-2 ring-blue-300/50': aiEditApiStyle === 'anthropic-messages' }" @click="aiSelectApiStyle('anthropic-messages')">/messages</Button>
+                  </div>
+                </div>
+
+                <div v-if="!aiIsCodexCli" class="grid grid-cols-3 items-center gap-3">
+                  <Label class="text-right text-xs">{{ t("ai.enableThinking") }}</Label>
+                  <div class="col-span-2 flex items-center gap-2">
+                    <label class="flex items-center gap-2 text-xs text-muted-foreground">
+                      <input v-model="aiEditEnableThinking" type="checkbox" class="h-4 w-4 shrink-0 accent-primary" :disabled="!aiCompletionsMode || aiEditProvider === 'gemini'" />
+                      {{ aiEditEnableThinking ? t("ai.enableThinkingOn") : t("ai.enableThinkingOff") }}
+                    </label>
+                    <Popover>
+                      <PopoverTrigger as-child>
+                        <CircleHelp class="h-3.5 w-3.5 cursor-help text-muted-foreground hover:text-foreground" />
+                      </PopoverTrigger>
+                      <PopoverContent class="max-w-[320px] text-xs leading-relaxed" side="top" align="start">
+                        {{ t("ai.enableThinkingHint") }}
+                      </PopoverContent>
+                    </Popover>
+                  </div>
+                </div>
+
+                <div v-if="!aiIsCodexCli" class="grid grid-cols-3 items-start gap-3">
+                  <Label class="text-right text-xs">{{ t("ai.contextWindow") }}</Label>
+                  <div class="col-span-2">
+                    <Input v-model.number="aiEditContextWindow" type="number" min="1000" step="1000" class="h-8 text-xs" :placeholder="t('ai.contextWindowAuto')" />
+                    <p class="mt-1 text-xs text-muted-foreground">{{ t("ai.contextWindowHint") }}</p>
+                  </div>
+                </div>
+
+                <div v-if="!aiIsCodexCli" class="grid grid-cols-3 items-center gap-3">
+                  <Label class="text-right text-xs">{{ t("ai.proxy") }}</Label>
+                  <label class="col-span-2 flex items-center gap-2 text-xs text-muted-foreground">
+                    <input v-model="aiEditProxyEnabled" type="checkbox" class="h-4 w-4 shrink-0 accent-primary" />
+                    {{ t("ai.proxyEnable") }}
+                  </label>
+                </div>
+
+                <div v-if="!aiIsCodexCli" class="grid grid-cols-3 items-center gap-3">
+                  <Label class="text-right text-xs">{{ t("ai.proxyUrl") }}</Label>
+                  <Input v-model="aiEditProxyUrl" autocomplete="off" class="col-span-2" inputClass="h-8 text-xs" placeholder="socks5://127.0.0.1:7890" :disabled="!aiEditProxyEnabled" />
+                </div>
+              </div>
+            </section>
+
+            <section v-else-if="activeSettingsTab === 'mcp' && !isWeb" class="flex flex-col gap-5 py-2">
+              <div class="rounded-md border bg-muted/20 p-4">
+                <div class="flex items-start justify-between gap-4">
+                  <div class="min-w-0 space-y-2">
+                    <div class="flex items-center gap-2">
+                      <PackageSearch class="h-4 w-4 text-muted-foreground" />
+                      <Label class="text-base">{{ t("settings.mcpTitle") }}</Label>
+                      <HelpTooltip :label="t('settings.mcpTitle')">
+                        {{ t("settings.mcpDescription") }}
+                      </HelpTooltip>
+                    </div>
+                  </div>
+                  <Badge variant="outline" class="shrink-0 rounded-md" :class="mcpStatusTone === 'ok' ? 'border-green-500/40 text-green-600 dark:text-green-400' : mcpStatusTone === 'warning' ? 'border-amber-500/40 text-amber-600 dark:text-amber-400' : 'text-muted-foreground'">
+                    <Loader2 v-if="mcpStatusLoading" class="mr-1 h-3 w-3 animate-spin" />
+                    <CheckCircle2 v-else-if="mcpStatusTone === 'ok'" class="mr-1 h-3 w-3" />
+                    <AlertTriangle v-else-if="mcpStatusTone === 'warning'" class="mr-1 h-3 w-3" />
+                    {{ mcpStatusLabel }}
+                  </Badge>
+                </div>
+              </div>
+
+              <div class="grid gap-3 sm:grid-cols-2">
+                <div class="rounded-md border p-3">
+                  <div class="text-xs font-medium uppercase text-muted-foreground">{{ t("settings.mcpCurrent") }}</div>
+                  <div class="mt-2 font-mono text-sm">
+                    {{ mcpStatus?.current_version ? `v${mcpStatus.current_version}` : t("settings.mcpVersionMissing") }}
+                  </div>
+                </div>
+                <div class="rounded-md border p-3">
+                  <div class="text-xs font-medium uppercase text-muted-foreground">{{ t("settings.mcpLatest") }}</div>
+                  <div class="mt-2 font-mono text-sm">
+                    {{ mcpStatus?.latest_version ? `v${mcpStatus.latest_version}` : t("settings.mcpVersionUnknown") }}
+                  </div>
+                </div>
+                <div class="rounded-md border p-3">
+                  <div class="text-xs font-medium uppercase text-muted-foreground">Node.js</div>
+                  <div class="mt-2 font-mono text-sm">
+                    {{ mcpStatus?.node_version || t("settings.mcpVersionUnknown") }}
+                  </div>
+                </div>
+                <div class="rounded-md border p-3">
+                  <div class="text-xs font-medium uppercase text-muted-foreground">npm</div>
+                  <div class="mt-2 font-mono text-sm">
+                    {{ mcpStatus?.npm_available ? t("settings.mcpAvailable") : t("settings.mcpUnavailable") }}
+                  </div>
+                </div>
+              </div>
+
+              <div v-if="mcpStatus?.bin_path" class="space-y-2">
+                <Label>{{ t("settings.mcpBinPath") }}</Label>
+                <div class="rounded-md border bg-muted/20 px-3 py-2 font-mono text-xs text-muted-foreground">
+                  {{ mcpStatus.bin_path }}
+                </div>
+              </div>
+
+              <div class="space-y-2">
+                <Label>{{ mcpStatus?.installed ? t("settings.mcpUpdateCommand") : t("settings.mcpInstallCommand") }}</Label>
+                <div class="flex min-w-0 items-center gap-2">
+                  <div class="min-w-0 flex-1 overflow-x-auto rounded-md border bg-background px-3 py-2 font-mono text-xs whitespace-nowrap">
+                    {{ mcpCommand }}
+                  </div>
+                  <Button type="button" variant="outline" size="icon" :title="t('common.copy')" @click="copyMcpText('install', mcpCommand)">
+                    <CheckCircle2 v-if="mcpCopied === 'install'" class="h-4 w-4 text-green-500" />
+                    <Copy v-else class="h-4 w-4" />
+                  </Button>
+                  <Button type="button" variant="default" :disabled="mcpInstalling || !mcpStatus?.npm_available || (mcpStatus?.installed && !mcpStatus?.update_available)" @click="installMcp">
+                    <Loader2 v-if="mcpInstalling" class="mr-2 h-4 w-4 animate-spin" />
+                    <CheckCircle2 v-if="!mcpInstalling && mcpStatus?.installed && !mcpStatus?.update_available" class="mr-2 h-4 w-4" />
+                    {{ mcpInstalling ? t("settings.mcpInstalling") : !mcpStatus?.installed ? t("settings.mcpInstallButton") : mcpStatus?.update_available ? t("settings.mcpUpdateButton") : t("settings.mcpUpToDate") }}
+                  </Button>
+                </div>
+                <div
+                  v-if="mcpInstallMessage"
+                  :class="['text-xs px-3 py-2 rounded-md border', mcpInstallError ? 'bg-red-50 text-red-700 border-red-200 dark:bg-red-950/30 dark:text-red-300 dark:border-red-800' : 'bg-green-50 text-green-700 border-green-200 dark:bg-green-950/30 dark:text-green-300 dark:border-green-800']"
+                >
+                  {{ mcpInstallMessage }}
+                </div>
+              </div>
+
+              <div class="space-y-2">
+                <p class="text-xs text-muted-foreground">{{ t("settings.mcpConfigOptionsHint") }}</p>
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="mcp-readonly-mode">{{ t("settings.mcpReadonlyMode") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.mcpReadonlyModeDescription") }}</p>
+                  </div>
+                  <Switch id="mcp-readonly-mode" v-model="mcpReadonlyMode" />
+                </div>
+              </div>
+
+              <div class="space-y-2">
+                <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div class="space-y-1">
+                    <Label for="mcp-allow-dangerous">{{ t("settings.mcpAllowDangerous") }}</Label>
+                    <p class="text-xs text-muted-foreground">{{ t("settings.mcpAllowDangerousDescription") }}</p>
+                  </div>
+                  <Switch id="mcp-allow-dangerous" v-model="mcpAllowDangerous" :disabled="mcpReadonlyMode" />
+                </div>
+              </div>
+
+              <div class="space-y-2">
+                <Label>{{ t("settings.mcpConfig") }}</Label>
+                <Tabs v-model="mcpConfigTab" class="space-y-3">
+                  <TabsList class="max-w-full overflow-x-auto">
+                    <TabsTrigger value="claude">Claude Code</TabsTrigger>
+                    <TabsTrigger value="cursor">Cursor</TabsTrigger>
+                    <TabsTrigger value="trae">TRAE</TabsTrigger>
+                    <TabsTrigger value="vscode">VS Code</TabsTrigger>
+                    <TabsTrigger value="windsurf">Windsurf</TabsTrigger>
+                    <TabsTrigger value="codex">Codex</TabsTrigger>
+                    <TabsTrigger value="opencode">OpenCode</TabsTrigger>
+                  </TabsList>
+
+                  <TabsContent value="claude" class="m-0">
+                    <div class="relative rounded-md border bg-background p-3">
+                      <pre class="overflow-x-auto whitespace-pre text-xs leading-relaxed"><code>{{ mcpJsonRecommendedConfig }}</code></pre>
+                      <Button type="button" variant="outline" size="icon" class="absolute right-2 top-2 h-7 w-7" :title="t('common.copy')" @click="copyMcpText('claude-config', mcpJsonRecommendedConfig)">
+                        <CheckCircle2 v-if="mcpCopied === 'claude-config'" class="h-3.5 w-3.5 text-green-500" />
+                        <Copy v-else class="h-3.5 w-3.5" />
+                      </Button>
+                    </div>
+                  </TabsContent>
+
+                  <TabsContent value="cursor" class="m-0">
+                    <div class="space-y-2">
+                      <div class="rounded-md border bg-muted/20 px-3 py-2 text-xs text-muted-foreground">
+                        {{ t("settings.mcpCursorConfigPath") }}
+                      </div>
+                      <div class="relative rounded-md border bg-background p-3">
+                        <pre class="overflow-x-auto whitespace-pre text-xs leading-relaxed"><code>{{ mcpJsonRecommendedConfig }}</code></pre>
+                        <Button type="button" variant="outline" size="icon" class="absolute right-2 top-2 h-7 w-7" :title="t('common.copy')" @click="copyMcpText('cursor-config', mcpJsonRecommendedConfig)">
+                          <CheckCircle2 v-if="mcpCopied === 'cursor-config'" class="h-3.5 w-3.5 text-green-500" />
+                          <Copy v-else class="h-3.5 w-3.5" />
+                        </Button>
+                      </div>
+                    </div>
+                  </TabsContent>
+
+                  <TabsContent value="trae" class="m-0">
+                    <div class="space-y-2">
+                      <div class="rounded-md border bg-muted/20 px-3 py-2 text-xs text-muted-foreground">
+                        {{ t("settings.mcpTraeConfigPath") }}
+                      </div>
+                      <div class="relative rounded-md border bg-background p-3">
+                        <pre class="overflow-x-auto whitespace-pre text-xs leading-relaxed"><code>{{ mcpJsonRecommendedConfig }}</code></pre>
+                        <Button type="button" variant="outline" size="icon" class="absolute right-2 top-2 h-7 w-7" :title="t('common.copy')" @click="copyMcpText('trae-config', mcpJsonRecommendedConfig)">
+                          <CheckCircle2 v-if="mcpCopied === 'trae-config'" class="h-3.5 w-3.5 text-green-500" />
+                          <Copy v-else class="h-3.5 w-3.5" />
+                        </Button>
+                      </div>
+                    </div>
+                  </TabsContent>
+
+                  <TabsContent value="vscode" class="m-0">
+                    <div class="space-y-2">
+                      <div class="rounded-md border bg-muted/20 px-3 py-2 text-xs text-muted-foreground">
+                        {{ t("settings.mcpVsCodeConfigPath") }}
+                      </div>
+                      <div class="relative rounded-md border bg-background p-3">
+                        <pre class="overflow-x-auto whitespace-pre text-xs leading-relaxed"><code>{{ mcpVsCodeRecommendedConfig }}</code></pre>
+                        <Button type="button" variant="outline" size="icon" class="absolute right-2 top-2 h-7 w-7" :title="t('common.copy')" @click="copyMcpText('vscode-config', mcpVsCodeRecommendedConfig)">
+                          <CheckCircle2 v-if="mcpCopied === 'vscode-config'" class="h-3.5 w-3.5 text-green-500" />
+                          <Copy v-else class="h-3.5 w-3.5" />
+                        </Button>
+                      </div>
+                    </div>
+                  </TabsContent>
+
+                  <TabsContent value="windsurf" class="m-0">
+                    <div class="space-y-2">
+                      <div class="rounded-md border bg-muted/20 px-3 py-2 text-xs text-muted-foreground">
+                        {{ t("settings.mcpWindsurfConfigPath") }}
+                      </div>
+                      <div class="relative rounded-md border bg-background p-3">
+                        <pre class="overflow-x-auto whitespace-pre text-xs leading-relaxed"><code>{{ mcpJsonRecommendedConfig }}</code></pre>
+                        <Button type="button" variant="outline" size="icon" class="absolute right-2 top-2 h-7 w-7" :title="t('common.copy')" @click="copyMcpText('windsurf-config', mcpJsonRecommendedConfig)">
+                          <CheckCircle2 v-if="mcpCopied === 'windsurf-config'" class="h-3.5 w-3.5 text-green-500" />
+                          <Copy v-else class="h-3.5 w-3.5" />
+                        </Button>
+                      </div>
+                    </div>
+                  </TabsContent>
+
+                  <TabsContent value="codex" class="m-0">
+                    <div class="space-y-2">
+                      <div class="rounded-md border bg-muted/20 px-3 py-2 text-xs text-muted-foreground">
+                        {{ t("settings.mcpCodexConfigPath") }}
+                      </div>
+                      <div class="relative rounded-md border bg-background p-3">
+                        <pre class="overflow-x-auto whitespace-pre text-xs leading-relaxed"><code>{{ mcpCodexRecommendedConfig }}</code></pre>
+                        <Button type="button" variant="outline" size="icon" class="absolute right-2 top-2 h-7 w-7" :title="t('common.copy')" @click="copyMcpText('codex-config', mcpCodexRecommendedConfig)">
+                          <CheckCircle2 v-if="mcpCopied === 'codex-config'" class="h-3.5 w-3.5 text-green-500" />
+                          <Copy v-else class="h-3.5 w-3.5" />
+                        </Button>
+                      </div>
+                    </div>
+                  </TabsContent>
+
+                  <TabsContent value="opencode" class="m-0">
+                    <div class="space-y-2">
+                      <div class="rounded-md border bg-muted/20 px-3 py-2 text-xs text-muted-foreground">
+                        {{ t("settings.mcpOpenCodeConfigPath") }}
+                      </div>
+                      <div class="relative rounded-md border bg-background p-3">
+                        <pre class="overflow-x-auto whitespace-pre text-xs leading-relaxed"><code>{{ mcpOpenCodeRecommendedConfig }}</code></pre>
+                        <Button type="button" variant="outline" size="icon" class="absolute right-2 top-2 h-7 w-7" :title="t('common.copy')" @click="copyMcpText('opencode-config', mcpOpenCodeRecommendedConfig)">
+                          <CheckCircle2 v-if="mcpCopied === 'opencode-config'" class="h-3.5 w-3.5 text-green-500" />
+                          <Copy v-else class="h-3.5 w-3.5" />
+                        </Button>
+                      </div>
+                    </div>
+                  </TabsContent>
+                </Tabs>
+              </div>
+
+              <div v-if="mcpStatus?.error || mcpStatusError" class="rounded-md border border-amber-500/30 bg-amber-500/10 px-3 py-2 text-xs text-amber-700 dark:text-amber-300">
+                {{ mcpStatusError || mcpStatus?.error }}
+              </div>
+
+              <div class="flex items-center gap-2 text-xs text-muted-foreground">
+                <Terminal class="h-3.5 w-3.5" />
+                <span>{{ t("settings.mcpDetectionTiming") }} {{ t("settings.mcpNpmBoundary") }}</span>
+              </div>
+            </section>
+
+            <section v-else-if="activeSettingsTab === 'security' && isWeb" class="flex flex-col gap-5 py-2">
+              <div class="space-y-3">
+                <Label class="text-base">{{ t("auth.changePassword") }}</Label>
+                <p class="text-sm text-muted-foreground">{{ t("auth.changePasswordDescription") }}</p>
+                <PasswordInput v-model="oldPassword" :placeholder="t('auth.oldPassword')" inputClass="h-9" autocomplete="off" />
+                <PasswordInput v-model="newPassword" :placeholder="t('auth.newPassword')" inputClass="h-9" autocomplete="off" />
+                <PasswordInput v-model="confirmNewPassword" :placeholder="t('auth.confirmPassword')" inputClass="h-9" autocomplete="off" />
+                <p v-if="passwordMessage" class="text-xs" :class="passwordError ? 'text-destructive' : 'text-green-500'">
+                  {{ passwordMessage }}
+                </p>
+              </div>
+            </section>
+
+            <section v-else-if="activeSettingsTab === 'tunnels'" class="flex flex-col gap-5 py-2">
+              <TunnelProfileManager />
+            </section>
+
+            <section v-else-if="activeSettingsTab === 'about'" class="flex flex-col gap-5 py-2">
+              <div class="rounded-lg border p-4">
+                <div class="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
+                  <div class="min-w-0 space-y-1">
+                    <Label>{{ t("settings.supportInfoTitle") }}</Label>
+                    <p class="text-sm text-muted-foreground">{{ t("settings.supportInfoDescription") }}</p>
+                  </div>
+                  <Button type="button" variant="outline" size="sm" class="shrink-0" :disabled="appSupportInfoLoading && !appSupportInfo" @click="copyAppSupportInfo">
+                    <Loader2 v-if="appSupportInfoLoading && !appSupportInfo" class="mr-1 h-3.5 w-3.5 animate-spin" />
+                    <CheckCircle2 v-else-if="appSupportInfoCopied" class="mr-1 h-3.5 w-3.5" />
+                    <Copy v-else class="mr-1 h-3.5 w-3.5" />
+                    {{ appSupportInfoCopied ? t("settings.supportInfoCopied") : t("settings.supportInfoCopy") }}
+                  </Button>
+                </div>
+                <div v-if="appSupportInfoRows.length" class="mt-4 grid gap-3 sm:grid-cols-2">
+                  <div v-for="row in appSupportInfoRows" :key="row.key" class="min-w-0 rounded-md bg-muted/30 px-3 py-2">
+                    <div class="text-xs font-medium text-muted-foreground">{{ row.label }}</div>
+                    <div class="mt-1 min-w-0 select-text break-words font-mono text-xs text-foreground">{{ row.value }}</div>
+                  </div>
+                </div>
+                <p v-else class="mt-4 text-sm text-muted-foreground">{{ t("settings.supportInfoLoading") }}</p>
+                <p v-if="appSupportInfoError" class="mt-3 text-xs text-destructive">{{ t("settings.supportInfoLoadFailed", { message: appSupportInfoError }) }}</p>
+              </div>
+
+              <div class="rounded-lg border p-4">
+                <div class="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+                  <div class="min-w-0 space-y-1">
+                    <Label>{{ t("settings.updateDownloadSource") }}</Label>
+                    <p class="text-sm text-muted-foreground">{{ t("settings.updateDownloadSourceDescription") }}</p>
+                  </div>
+                  <Select :model-value="editUpdateDownloadSource" @update:model-value="onUpdateDownloadSourceChange">
+                    <SelectTrigger class="h-9 w-full sm:w-[180px]">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem value="official">{{ t("settings.updateDownloadSourceOfficial") }}</SelectItem>
+                      <SelectItem value="cnb">{{ t("settings.updateDownloadSourceCnb") }}</SelectItem>
+                      <SelectItem value="atomgit">{{ t("settings.updateDownloadSourceAtomgit") }}</SelectItem>
+                    </SelectContent>
+                  </Select>
+                </div>
+              </div>
+
+              <div class="grid gap-3 sm:grid-cols-2">
+                <button type="button" class="rounded-lg border p-4 text-left transition-colors hover:bg-muted/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring" @click="openExternalUrl('https://qm.qq.com/cgi-bin/qm/qr?k=&group_code=1087880322')">
+                  <div class="text-xs font-medium uppercase tracking-wider text-muted-foreground">
+                    {{ t("settings.community") }}
+                  </div>
+                  <div class="mt-3 flex items-center gap-2 text-sm font-medium">
+                    <img
+                      src="data:image/svg+xml;base64,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"
+                      alt="QQ"
+                      class="h-7 w-7 rounded-md bg-white p-1"
+                    />
+                    {{ t("settings.qqGroup") }}
+                    <ExternalLink class="ml-auto h-3.5 w-3.5 text-muted-foreground" />
+                  </div>
+                  <div class="mt-1 font-mono text-base">1087880322</div>
+                </button>
+                <button type="button" class="rounded-lg border p-4 text-left transition-colors hover:bg-muted/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring" @click="openExternalUrl('https://discord.gg/W7NyVDRt6a')">
+                  <div class="text-xs font-medium uppercase tracking-wider text-muted-foreground">
+                    {{ t("settings.community") }}
+                  </div>
+                  <div class="mt-3 flex items-center gap-2 text-sm font-medium">
+                    <img src="https://cdn.simpleicons.org/discord/5865F2" alt="Discord" class="h-7 w-7 rounded-md bg-white p-1" />
+                    Discord
+                    <ExternalLink class="ml-auto h-3.5 w-3.5 text-muted-foreground" />
+                  </div>
+                  <div class="mt-1 text-sm text-primary">discord.gg/W7NyVDRt6a</div>
+                </button>
+                <button type="button" class="rounded-lg border p-4 text-left transition-colors hover:bg-muted/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring" @click="openExternalUrl('https://docs.qq.com/doc/DVVhMY0h1ekJqc0tz')">
+                  <div class="text-xs font-medium uppercase tracking-wider text-muted-foreground">
+                    {{ t("settings.community") }}
+                  </div>
+                  <div class="mt-3 flex items-center gap-2 text-sm font-medium">
+                    <span class="flex h-7 w-7 items-center justify-center rounded-md bg-[#07C160] text-white">
+                      <svg class="h-4 w-4" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
+                        <path
+                          d="M9.5 4C5.36 4 2 6.69 2 10c0 1.89 1.08 3.56 2.78 4.66l-.7 2.1 2.46-1.23c.87.27 1.8.42 2.78.42.24 0 .48-.01.71-.03A5.93 5.93 0 0 1 10 14c0-3.31 3.13-6 7-6 .34 0 .67.03 1 .07C17.27 5.56 13.72 4 9.5 4Zm-3 4.5a1 1 0 1 1 0-2 1 1 0 0 1 0 2Zm5 0a1 1 0 1 1 0-2 1 1 0 0 1 0 2ZM22 14c0-2.76-2.69-5-6-5s-6 2.24-6 5 2.69 5 6 5c.73 0 1.43-.11 2.09-.3l1.72.86-.49-1.46C20.94 17.07 22 15.64 22 14Zm-7.5-.5a.75.75 0 1 1 0-1.5.75.75 0 0 1 0 1.5Zm4 0a.75.75 0 1 1 0-1.5.75.75 0 0 1 0 1.5Z"
+                        />
+                      </svg>
+                    </span>
+                    {{ t("settings.wechatGroup") }}
+                    <ExternalLink class="ml-auto h-3.5 w-3.5 text-muted-foreground" />
+                  </div>
+                  <div class="mt-1 text-sm text-primary">{{ t("settings.wechatGroupInvite") }}</div>
+                </button>
+                <button type="button" class="rounded-lg border p-4 text-left transition-colors hover:bg-muted/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring" @click="openExternalUrl('https://github.com/t8y2/dbx')">
+                  <div class="text-xs font-medium uppercase tracking-wider text-muted-foreground">
+                    {{ t("settings.project") }}
+                  </div>
+                  <div class="mt-3 flex items-center gap-2 text-sm font-medium">
+                    <img src="https://cdn.simpleicons.org/github/181717" alt="GitHub" class="h-7 w-7 rounded-md bg-white p-1" />
+                    {{ t("settings.openSource") }}
+                    <ExternalLink class="ml-auto h-3.5 w-3.5 text-muted-foreground" />
+                  </div>
+                  <div class="mt-1 text-sm text-primary">github.com/t8y2/dbx</div>
+                </button>
+                <button type="button" class="rounded-lg border p-4 text-left transition-colors hover:bg-muted/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring" @click="openExternalUrl('https://dbxio.com')">
+                  <div class="text-xs font-medium uppercase tracking-wider text-muted-foreground">
+                    {{ t("settings.project") }}
+                  </div>
+                  <div class="mt-3 flex items-center gap-2 text-sm font-medium">
+                    <AppLogo class="h-7 w-7" />
+                    {{ t("settings.officialDocs") }}
+                    <ExternalLink class="ml-auto h-3.5 w-3.5 text-muted-foreground" />
+                  </div>
+                  <div class="mt-1 text-sm text-primary">dbxio.com</div>
+                </button>
+              </div>
+            </section>
+          </div>
+
+          <DialogFooter v-if="hasSettingsApplyFooter(activeSettingsTab as SettingsCategory)" class="mx-0 mb-0 flex-row flex-wrap items-center justify-end gap-2 rounded-none border-t border-border/60 bg-transparent px-0 pb-0 pt-3 sm:flex-row sm:gap-2 [&>button]:w-auto [&>button]:shrink-0">
+            <Button variant="outline" @click="resetDefaultsForTab(activeSettingsTab as SettingsCategory)">
+              {{ t("settings.resetDefaults") }}
+            </Button>
+            <div class="flex-1" />
+            <Button variant="outline" @click="closeSettings">
+              {{ t("common.close") }}
+            </Button>
+            <Button :disabled="!hasChanges() || hasApplyBlocker" @click="applySettings">
+              {{ t("settings.apply") }}
+            </Button>
+            <Button :disabled="!hasChanges() || hasApplyBlocker" @click="applySettingsAndClose">
+              {{ t("settings.applyAndClose") }}
+            </Button>
+          </DialogFooter>
+
+          <DialogFooter v-else-if="activeSettingsTab === 'ai'" class="mx-0 mb-0 flex-row flex-wrap items-center justify-end gap-2 rounded-none border-t border-border/60 bg-transparent px-0 pb-0 pt-3 sm:flex-row sm:gap-2 [&>button]:w-auto [&>button]:shrink-0">
+            <div class="flex flex-1 items-center gap-2">
+              <Button size="sm" variant="outline" :disabled="aiTesting || !!aiCodexValidationError || (aiRequiresApiKey && !aiEditApiKey?.trim()) || (!aiIsCodexCli && !aiEditEndpoint?.trim()) || (!aiIsCodexCli && !aiEditModel?.trim())" @click="aiTestConn">
+                <Loader2 v-if="aiTesting" class="h-3 w-3 animate-spin mr-1" />
+                {{ t("connection.test") }}
+              </Button>
+              <span v-if="aiTestResult === 'success'" class="text-xs text-green-500 flex items-center gap-1.5">
+                <span>{{ t("connection.testSuccess") }}</span>
+                <span v-if="aiTestLatency != null" class="text-green-500/70">{{ aiTestLatency }}ms</span>
+              </span>
+              <span v-else-if="aiTestResult === 'error'" class="min-w-0 max-w-[360px] flex items-center gap-1.5 text-xs text-destructive">
+                <span class="select-text truncate" :title="aiTestError">{{ aiTestError }}</span>
+                <Button
+                  type="button"
+                  variant="ghost"
+                  size="icon"
+                  class="h-6 w-6 shrink-0 text-destructive/80 hover:text-destructive"
+                  :title="aiTestErrorCopied ? t('ai.copied') : t('ai.copyTestResult')"
+                  :aria-label="aiTestErrorCopied ? t('ai.copied') : t('ai.copyTestResult')"
+                  @click="copyAiTestError"
+                >
+                  <CheckCircle2 v-if="aiTestErrorCopied" class="h-3.5 w-3.5" />
+                  <Copy v-else class="h-3.5 w-3.5" />
+                </Button>
+              </span>
+            </div>
+            <Button variant="outline" @click="closeSettings">{{ t("common.close") }}</Button>
+            <Button :disabled="!aiHasChanges() || !!aiCodexValidationError" @click="aiApplySettings">{{ t("settings.apply") }}</Button>
+          </DialogFooter>
+
+          <DialogFooter v-else-if="activeSettingsTab === 'sync'" class="mx-0 mb-0 flex-row flex-wrap items-center justify-end gap-2 rounded-none border-t border-border/60 bg-transparent px-0 pb-0 pt-3 sm:flex-row sm:gap-2 [&>button]:w-auto [&>button]:shrink-0">
+            <Button variant="outline" @click="closeSettings">
+              {{ t("common.close") }}
+            </Button>
+          </DialogFooter>
+
+          <DialogFooter v-else-if="activeSettingsTab === 'mcp' && !isWeb" class="mx-0 mb-0 flex-row flex-wrap items-center justify-end gap-2 rounded-none border-t border-border/60 bg-transparent px-0 pb-0 pt-3 sm:flex-row sm:gap-2 [&>button]:w-auto [&>button]:shrink-0">
+            <Button variant="outline" @click="closeSettings">
+              {{ t("common.close") }}
+            </Button>
+            <div class="flex-1" />
+            <Button variant="outline" :disabled="mcpStatusLoading" @click="refreshMcpStatus">
+              <Loader2 v-if="mcpStatusLoading" class="mr-1 h-3 w-3 animate-spin" />
+              <RefreshCw v-else class="mr-1 h-3 w-3" />
+              {{ t("settings.mcpRefresh") }}
+            </Button>
+            <Button variant="outline" @click="openExternalUrl('https://dbxio.com/cn/docs/mcp')">
+              <ExternalLink class="mr-1 h-3 w-3" />
+              {{ t("settings.mcpGuide") }}
+            </Button>
+          </DialogFooter>
+
+          <DialogFooter v-else-if="activeSettingsTab === 'security' && isWeb" class="mx-0 mb-0 flex-row flex-wrap items-center justify-end gap-2 rounded-none border-t border-border/60 bg-transparent px-0 pb-0 pt-3 sm:flex-row sm:gap-2 [&>button]:w-auto [&>button]:shrink-0">
+            <Button variant="outline" @click="closeSettings">
+              {{ t("common.close") }}
+            </Button>
+            <Button :disabled="changingPassword || !oldPassword || !newPassword || !confirmNewPassword" @click="changePassword">
+              {{ t("auth.changePassword") }}
+            </Button>
+          </DialogFooter>
+
+          <DialogFooter v-else-if="activeSettingsTab === 'about'" class="mx-0 mb-0 flex-row flex-wrap items-center justify-end gap-2 rounded-none border-t border-border/60 bg-transparent px-0 pb-0 pt-3 sm:flex-row sm:gap-2 [&>button]:w-auto [&>button]:shrink-0">
+            <Button variant="outline" @click="resetAllDefaults">
+              {{ t("settings.resetAllDefaults") }}
+            </Button>
+            <div class="flex-1" />
+            <Button variant="outline" @click="closeSettings">
+              {{ t("common.close") }}
+            </Button>
+            <Button :disabled="!hasChanges() || hasApplyBlocker" @click="applySettings">
+              {{ t("settings.apply") }}
+            </Button>
+            <Button :disabled="!hasChanges() || hasApplyBlocker" @click="applySettingsAndClose">
+              {{ t("settings.applyAndClose") }}
+            </Button>
+          </DialogFooter>
+        </div>
+      </div>
+    </component>
+
+    <!-- Theme Customizer Dialog -->
+    <ThemeCustomizerDialog v-model:open="showThemeCustomizer" :themes="editCustomThemes" :active-theme-id="editActiveCustomThemeId" @save="handleThemeSave" />
+
+    <!-- Snippet Add/Edit Dialog -->
+    <Dialog :open="snippetDialogOpen" @update:open="snippetDialogOpen = $event">
+      <DialogContent class="sm:max-w-[500px]">
+        <DialogHeader>
+          <DialogTitle>
+            {{ snippetEditingId ? t("settings.snippetsEditTitle") : t("settings.snippetsAddTitle") }}
+          </DialogTitle>
+        </DialogHeader>
+        <div class="flex flex-col gap-4 py-2">
+          <div class="flex flex-col gap-1.5">
+            <Label for="snippet-label">{{ t("settings.snippetsLabel") }}</Label>
+            <Input id="snippet-label" v-model="snippetForm.label" :placeholder="t('settings.snippetsLabelPlaceholder')" />
+          </div>
+          <div class="flex flex-col gap-1.5">
+            <Label for="snippet-prefix">{{ t("settings.snippetsPrefix") }}</Label>
+            <Input id="snippet-prefix" v-model="snippetForm.prefix" :placeholder="t('settings.snippetsPrefixPlaceholder')" />
+            <p v-if="snippetFormPrefixError" class="text-xs text-destructive">{{ snippetFormPrefixError }}</p>
+          </div>
+          <div class="flex flex-col gap-1.5">
+            <Label for="snippet-body">{{ t("settings.snippetsBody") }}</Label>
+            <textarea
+              id="snippet-body"
+              v-model="snippetForm.body"
+              :placeholder="t('settings.snippetsBodyPlaceholder')"
+              rows="6"
+              class="flex min-h-[120px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm font-mono shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
+            />
+          </div>
+        </div>
+        <DialogFooter>
+          <Button variant="outline" @click="snippetDialogOpen = false">{{ t("settings.cancel") }}</Button>
+          <Button @click="saveSnippet">{{ t("settings.save") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  </component>
+</template>
+
+<style>
+@media (min-width: 1024px) {
+  .settings-layout {
+    flex-direction: row !important;
+  }
+
+  .settings-category-nav {
+    width: 10rem !important;
+    flex-direction: column !important;
+    overflow-x: hidden !important;
+    overflow-y: auto !important;
+    border-bottom-width: 0 !important;
+    border-right: 1px solid var(--border) !important;
+    padding-bottom: 0 !important;
+    padding-right: 0.75rem !important;
+  }
+
+  .settings-category-button {
+    width: 100% !important;
+    text-align: left !important;
+  }
+}
+
+.settings-category-button--active {
+  background-color: rgb(23, 23, 23) !important;
+  color: rgb(255, 255, 255) !important;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.12);
+}
+
+.settings-choice-button {
+  color: rgb(23, 23, 23);
+}
+
+.settings-choice-button--selected {
+  border-color: rgb(96, 165, 250) !important;
+  background-color: rgba(59, 130, 246, 0.1) !important;
+  color: rgb(29, 78, 216) !important;
+  box-shadow: 0 0 0 1px rgba(96, 165, 250, 0.45) !important;
+}
+
+.settings-choice-button--selected svg {
+  color: currentColor !important;
+}
+
+.settings-choice-card--selected {
+  border-color: rgb(96, 165, 250) !important;
+  background-color: rgba(59, 130, 246, 0.04) !important;
+  color: rgb(23, 23, 23) !important;
+  box-shadow: 0 0 0 2px rgba(96, 165, 250, 0.45) !important;
+}
+
+.settings-appearance-section > * + * {
+  margin-top: 1.25rem;
+}
+
+.settings-appearance-top-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  column-gap: 0.75rem;
+  row-gap: 1rem;
+}
+
+.settings-appearance-field > * + * {
+  margin-top: 0.5rem;
+}
+
+.settings-appearance-group > * + * {
+  margin-top: 0.625rem;
+}
+
+.settings-appearance-button-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+}
+
+.settings-appearance-choice-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 0.625rem;
+}
+
+.settings-option-stack > * + * {
+  margin-top: 0.625rem;
+}
+
+@media (max-width: 760px) {
+  .settings-appearance-top-grid,
+  .settings-appearance-choice-grid {
+    grid-template-columns: 1fr;
+  }
+}
+
+.dark .settings-category-button--active {
+  background-color: rgb(245, 245, 245) !important;
+  color: rgb(23, 23, 23) !important;
+}
+
+.dark .settings-choice-button {
+  color: rgb(245, 245, 245);
+}
+
+.dark .settings-choice-button--selected {
+  border-color: rgb(147, 197, 253) !important;
+  background-color: rgba(96, 165, 250, 0.18) !important;
+  color: rgb(191, 219, 254) !important;
+  box-shadow: 0 0 0 1px rgba(147, 197, 253, 0.5) !important;
+}
+
+.dark .settings-choice-card--selected {
+  border-color: rgb(147, 197, 253) !important;
+  background-color: rgba(96, 165, 250, 0.12) !important;
+  color: rgb(245, 245, 245) !important;
+  box-shadow: 0 0 0 2px rgba(147, 197, 253, 0.45) !important;
+}
+</style>
diff --git a/apps/desktop/src/components/editor/QueryEditor.vue b/apps/desktop/src/components/editor/QueryEditor.vue
new file mode 100644
index 0000000..dd33aa9
--- /dev/null
+++ b/apps/desktop/src/components/editor/QueryEditor.vue
@@ -0,0 +1,3595 @@
+<script setup lang="ts">
+import { ref, onMounted, onBeforeUnmount, onActivated, onDeactivated, watch, shallowRef, computed, nextTick } from "vue";
+import { CaseLower, CaseUpper, FileCode, PencilRuler, Play, Copy, Sparkles, Table2, TextSelect } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import type { CompletionContext } from "@codemirror/autocomplete";
+import type { EditorView as EditorViewType } from "@codemirror/view";
+import { search as cmSearch } from "@codemirror/search";
+import EditorSearchPanel from "./EditorSearchPanel.vue";
+import SqlExecutionTargetPicker from "./SqlExecutionTargetPicker.vue";
+import CustomContextMenu, { type ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
+import { copyToClipboard, readTextFromClipboard } from "@/lib/common/clipboard";
+import { resolveExecutableSql, type SqlExecutionSnapshot, type SqlExecutionOverride, type SqlExecutionCandidate } from "@/lib/sql/sqlExecutionTarget";
+import { buildExecutionCandidates, hasMultipleExecutionTargets, supportsExecutionTargetPicker, type SqlTextRange } from "@/lib/sql/sqlStatementRanges";
+import { executableStatementRangeAtCursor, executableStatementRangeCacheForDoc, executableStatementRangeStartingAt as executableStatementRangeStartingAtLine, type ExecutableStatementRangeCache } from "@/lib/sql/executableStatementRangeCache";
+import { currentStatementFrameRangeTo, visualSqlColumnsWithInlineHints } from "@/lib/sql/currentStatementFrame";
+import { parseInsertValueHints } from "@/lib/sql/insertValueHints";
+import { formatSqlText, type SqlFormatDialect } from "@/lib/sql/sqlFormatter";
+import { buildSqlInConditionFromPasteSource, insertTextForSqlInCondition } from "@/lib/sql/sqlInListPaste";
+import { resolveSqlSingleQuoteKeyAction } from "@/lib/sql/sqlQuoteCaret";
+import { formatMongoShellText } from "@/lib/mongo/mongoFormatter";
+import { useConnectionStore, COMPLETION_METADATA_CONCURRENCY } from "@/stores/connectionStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useTheme } from "@/composables/useTheme";
+import { useToast } from "@/composables/useToast";
+import {
+  buildSqlCompletionItemsFromContext,
+  getSqlFunctionSignatureHelp,
+  getSqlCompletionContext,
+  getSqlCompletionResultValidFor,
+  isSqlCompletionSuppressedContext,
+  isSqlLikeCompletionStatement,
+  recordCompletionSelection,
+  shouldAutoOpenSqlCompletion,
+  extractCteDefinitions,
+} from "@/lib/sql/sqlCompletion";
+import { sqlCompletionContextFromSemantic } from "@/lib/sql/semantic/completion";
+import { buildSqlSemanticModel } from "@/lib/sql/semantic/model";
+import { mergeSqlSemanticReferenceAnalysis, resolveSqlSemanticNavigationTarget } from "@/lib/sql/semantic/references";
+import { buildElasticsearchCompletionItemsFromContext, getElasticsearchCompletionContext, getElasticsearchCompletionResultValidFor, shouldAutoOpenElasticsearchCompletion, type ElasticsearchCompletionItem } from "@/lib/elasticsearch/elasticsearchCompletion";
+import { buildMongoCompletionItemsFromContext, getMongoCompletionContext, getMongoCompletionResultValidFor, shouldAutoOpenMongoCompletion, type MongoCompletionItem } from "@/lib/mongo/mongoCompletion";
+import { resolveSqlCompletionTableLookupTarget } from "@/lib/sql/sqlCompletionLookupTarget";
+import { extractIdentifierDetailsAt, isSqlKeyword, matchTable, splitQualifiedIdentifier } from "@/lib/sql/sqlNavigation";
+import { lineColumnToOffset, parseSqlErrorLocation } from "@/lib/sql/sqlDiagnostics";
+import {
+  DBX_TABLE_REFERENCE_MIME,
+  DBX_TABLE_REFERENCE_DROP_EVENT,
+  activeTableReferencePayloadValue,
+  clearActiveTableReferencePayload,
+  hasTableReferencePayloadType,
+  parseTableReferencePayload,
+  tableReferenceInsertText,
+  type QueryEditorTableReferenceDropDetail,
+  type QueryEditorTableReferencePayload,
+} from "@/lib/editor/queryEditorTableDrop";
+import { EDITOR_FONT_FAMILY_CSS_VAR, EDITOR_FONT_SIZE_CSS_VAR, createRunStatementButtonDom, loadEditorTheme, editorFontTheme, sqlCompletionTheme } from "@/lib/editor/editorThemes";
+import { clampEditorFontSize, createEditorZoomCommitScheduler, fontSizeFromGestureScale, fontSizeFromWheelDelta } from "@/lib/editor/editorZoom";
+import { normalizeShortcutSettings, shortcutToCodeMirrorKey } from "@/lib/editor/shortcutRegistry";
+import { trimmedSelectionLayer } from "@/lib/editor/codemirrorTrimmedSelectionLayer";
+import { selectionMatchOccurrences } from "@/lib/editor/codemirrorSelectionMatches";
+import { createInsertValueHintsExtension, requestInsertValueHintsRefresh } from "@/lib/editor/codemirrorInsertValueHints";
+import { createDbxCodeMirrorSqlDialect } from "@/lib/editor/codemirrorSqlDialect";
+import { startsQueryEditorRectangularSelection } from "@/lib/editor/queryEditorPointerSelection";
+import { isSchemaAware, isSingleDatabase, supportsSqlInListPaste } from "@/lib/database/databaseFeatureSupport";
+import { usesLocalOnlyEditorCompletionMetadata, usesOnDemandOnlyEditorColumnMetadata } from "@/lib/metadata/completionMetadataPolicy";
+import { qualifiedTableNameAtSqlPosition } from "@/lib/sql/queryCursorTableTarget";
+import * as api from "@/lib/backend/api";
+import { areSqlSemanticDiagnosticsEqual, buildSqlParserErrorDiagnostic, buildSqlSemanticDiagnostics, isSqlSemanticDiagnosticInputContext, shouldRunSqlSemanticDiagnostics, sqlSemanticDiagnosticRangesForViewport, tableReferenceKey, type SqlSemanticDiagnostic } from "@/lib/sql/semantic/diagnostics";
+import { buildRedisSyntaxDiagnostics, shouldRunRedisDiagnostics } from "@/lib/redis/redisSyntaxDiagnostics";
+import { buildRedisCompletionItemsFromContext, getRedisCompletionContext, getRedisCompletionResultValidFor, shouldAutoOpenRedisCompletion, takesKeyArgument, type RedisCompletionItem } from "@/lib/redis/redisCompletion";
+import type { SqlCompletionColumn, SqlCompletionForeignKey, SqlCompletionItem, SqlCompletionObject, SqlCompletionTable } from "@/lib/sql/sqlCompletion";
+import type { DatabaseType, SqlReferenceAnalysis, SqlTableReference, SqlTextSpan } from "@/types/database";
+
+const props = defineProps<{
+  modelValue: string;
+  connectionId?: string;
+  database?: string;
+  schema?: string;
+  databaseType?: DatabaseType;
+  dialect?: "mysql" | "postgres" | "sqlserver";
+  formatDialect?: SqlFormatDialect;
+  formatRequestId?: number;
+  executionError?: string;
+  executionErrorSql?: string;
+  readOnly?: boolean;
+  forceWordWrap?: boolean;
+  hideExecutionControls?: boolean;
+  initialViewport?: { scrollTop: number; scrollLeft: number };
+  initialSelection?: { anchor: number; head: number };
+}>();
+
+const COMPLETION_REMOTE_LATENCY_BUDGET_MS = 120;
+// Internal rollback switch: flip to false to route completion, diagnostics, and navigation through the legacy SQL context path.
+const SEMANTIC_SQL_COMPLETION_ENABLED = true;
+
+const emit = defineEmits<{
+  "update:modelValue": [value: string];
+  selectionChange: [value: string];
+  cursorChange: [pos: number];
+  formatError: [message: string];
+  execute: [source: SqlExecutionOverride];
+  save: [];
+  clickTable: [tableName: string];
+  viewTableData: [tableName: string];
+  viewTableDdl: [tableName: string];
+  editTableStructure: [tableName: string];
+  clickColumn: [columns: Array<{ name: string; table: string; schema?: string }>, error?: string | undefined];
+  closeColumnPanel: [];
+  viewportChange: [viewport: { scrollTop: number; scrollLeft: number }];
+  selectionStateChange: [selection: { anchor: number; head: number }];
+  sendSelectionToAi: [sql: string];
+}>();
+
+const editorRef = ref<HTMLDivElement>();
+const view = shallowRef<EditorViewType | null>(null);
+let viewportEmitFrame: number | null = null;
+let viewportRestoreFrame: number | null = null;
+let latestViewport: { scrollTop: number; scrollLeft: number } | undefined = props.initialViewport;
+let lastEmittedViewport: { scrollTop: number; scrollLeft: number } | undefined = props.initialViewport;
+let latestSelection: { anchor: number; head: number } | undefined = props.initialSelection;
+const connectionStore = useConnectionStore();
+const settingsStore = useSettingsStore();
+const { isDark, themePalette } = useTheme();
+const { t } = useI18n();
+const { toast } = useToast();
+
+const SQL_FUNCTION_NAMES = [
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MIN",
+  "MAX",
+  "GROUP_CONCAT",
+  "STRING_AGG",
+  "CONCAT",
+  "CONCAT_WS",
+  "SUBSTRING",
+  "REPLACE",
+  "TRIM",
+  "UPPER",
+  "LOWER",
+  "LENGTH",
+  "REGEXP_REPLACE",
+  "DATE_FORMAT",
+  "DATEDIFF",
+  "DATE_ADD",
+  "DATE_SUB",
+  "EXTRACT",
+  "NOW",
+  "ROUND",
+  "FLOOR",
+  "CEIL",
+  "ABS",
+  "MOD",
+  "COALESCE",
+  "IFNULL",
+  "NULLIF",
+  "CAST",
+  "JSON_EXTRACT",
+  "JSON_VALUE",
+  "JSON_OBJECT",
+  "JSON_ARRAY",
+] as const;
+
+const completionTranslations = computed(() => ({
+  nullValue: t("editor.completion.nullValue"),
+  isNull: t("editor.completion.isNull"),
+  isNotNull: t("editor.completion.isNotNull"),
+  stringLiteral: t("editor.completion.stringLiteral"),
+  numericLiteral: t("editor.completion.numericLiteral"),
+  booleanValue: t("editor.completion.booleanValue"),
+  starExpansionColumns: t("editor.completion.starExpansionColumns"),
+  functionDescriptions: Object.fromEntries(SQL_FUNCTION_NAMES.map((name) => [name, t(`editor.completion.functionDescriptions.${name}`)])) as Record<string, string>,
+}));
+const MAX_COMPLETION_TABLES = 200;
+const PRESTO_ON_DEMAND_TABLE_COMPLETION_MIN_PREFIX = 2;
+const PRESTO_ON_DEMAND_TABLE_COMPLETION_LIMIT = 20;
+const MAX_JOIN_FK_PREFETCH_TABLES = 24;
+const MAX_SEMANTIC_DIAGNOSTIC_COLUMN_TABLES = 4;
+const liveFontSize = ref(settingsStore.editorSettings.fontSize);
+const gestureStartFontSize = ref(settingsStore.editorSettings.fontSize);
+const isGestureZooming = ref(false);
+
+const searchPanelRef = ref<InstanceType<typeof EditorSearchPanel>>();
+const selectedSql = ref("");
+const executableSql = ref("");
+const contextTableName = ref<string | null>(null);
+
+const hasSelectedSql = computed(() => selectedSql.value.trim().length > 0);
+const canCopySelectedSql = computed(() => selectedSql.value.length > 0);
+const canExecuteContextSql = computed(() => executableSql.value.trim().length > 0);
+
+// Execution target picker state
+const pickerVisible = ref(false);
+const pickerCandidates = ref<SqlExecutionCandidate[]>([]);
+const pickerActiveIndex = ref(0);
+const pickerAnchor = ref<{ left: number; top: number }>();
+
+const executeContextMenuLabel = computed(() => t(hasSelectedSql.value ? "editor.contextMenu.executeSelection" : "editor.contextMenu.executeCurrent"));
+
+interface EditorGestureEvent extends Event {
+  scale?: number;
+}
+
+let editorViewModule: typeof import("@codemirror/view") | null = null;
+let codeMirrorPrec: typeof import("@codemirror/state").Prec | null = null;
+let codeMirrorEditorSelection: typeof import("@codemirror/state").EditorSelection | null = null;
+let fontThemeComp: import("@codemirror/state").Compartment | null = null;
+let codeMirrorTheme: import("@codemirror/state").Compartment | null = null;
+let wordWrapComp: import("@codemirror/state").Compartment | null = null;
+let vimModeComp: import("@codemirror/state").Compartment | null = null;
+let closeBracketsComp: import("@codemirror/state").Compartment | null = null;
+let codeMirrorCloseBrackets: typeof import("@codemirror/autocomplete").closeBrackets | null = null;
+let codeMirrorCloseBracketsKeymap: readonly import("@codemirror/view").KeyBinding[] | null = null;
+let readOnlyComp: import("@codemirror/state").Compartment | null = null;
+let runGutterComp: import("@codemirror/state").Compartment | null = null;
+let runKeymapComp: import("@codemirror/state").Compartment | null = null;
+let completionComp: import("@codemirror/state").Compartment | null = null;
+let diagnosticComp: import("@codemirror/state").Compartment | null = null;
+let codeMirrorVim: typeof import("@replit/codemirror-vim").vim | null = null;
+let codeMirrorVimApi: typeof import("@replit/codemirror-vim").Vim | null = null;
+let codeMirrorGetVimCm: typeof import("@replit/codemirror-vim").getCM | null = null;
+let codeMirrorVimImportPromise: Promise<typeof import("@replit/codemirror-vim")> | null = null;
+let dbxVimCommandsConfigured = false;
+let buildSqlDiagnosticExtension: (() => import("@codemirror/state").Extension) | null = null;
+let buildSqlSignatureExtension: (() => import("@codemirror/state").Extension) | null = null;
+let buildSqlCompletionExtension: (() => import("@codemirror/state").Extension) | null = null;
+let codeMirrorSnippetCompletion: typeof import("@codemirror/autocomplete").snippetCompletion;
+let codeMirrorCompletionStatus: typeof import("@codemirror/autocomplete").completionStatus | null = null;
+let codeMirrorAcceptCompletion: typeof import("@codemirror/autocomplete").acceptCompletion | null = null;
+let codeMirrorStartCompletion: typeof import("@codemirror/autocomplete").startCompletion | null = null;
+let codeMirrorInsertCompletionText: typeof import("@codemirror/autocomplete").insertCompletionText | null = null;
+let codeMirrorNextSnippetField: typeof import("@codemirror/autocomplete").nextSnippetField | null = null;
+let codeMirrorIndentMore: typeof import("@codemirror/commands").indentMore | null = null;
+let codeMirrorIndentLess: typeof import("@codemirror/commands").indentLess | null = null;
+let codeMirrorCopyLineDown: typeof import("@codemirror/commands").copyLineDown | null = null;
+let codeMirrorCopyLineUp: typeof import("@codemirror/commands").copyLineUp | null = null;
+let codeMirrorDeleteLine: typeof import("@codemirror/commands").deleteLine | null = null;
+let codeMirrorMoveLineUp: typeof import("@codemirror/commands").moveLineUp | null = null;
+let codeMirrorMoveLineDown: typeof import("@codemirror/commands").moveLineDown | null = null;
+let codeMirrorUndo: typeof import("@codemirror/commands").undo | null = null;
+let codeMirrorRedo: typeof import("@codemirror/commands").redo | null = null;
+let codeMirrorSelectAll: typeof import("@codemirror/commands").selectAll | null = null;
+let codeMirrorInsertNewlineKeepIndent: typeof import("@codemirror/commands").insertNewlineKeepIndent | null = null;
+let codeMirrorToggleLineComment: typeof import("@codemirror/commands").toggleLineComment | null = null;
+let setSqlDiagnosticsEffect: import("@codemirror/state").StateEffectType<SqlSemanticDiagnostic[]> | null = null;
+let setPreviewRangeEffect: import("@codemirror/state").StateEffectType<{ from: number; to: number } | null> | null = null;
+let previewRangeComp: import("@codemirror/state").Compartment | null = null;
+let buildPreviewRangeExtension: (() => import("@codemirror/state").Extension) | null = null;
+let buildRunStatementGutterExtension: (() => import("@codemirror/state").Extension) | null = null;
+let indentComp: import("@codemirror/state").Compartment | null = null;
+let codeMirrorIndentUnit: typeof import("@codemirror/language").indentUnit | null = null;
+let semanticDiagnostics: SqlSemanticDiagnostic[] = [];
+let semanticDiagnosticTimer: ReturnType<typeof setTimeout> | null = null;
+let semanticDiagnosticRunId = 0;
+let pendingSemanticDiagnosticPreserveOutsideRanges = false;
+let editorIsActive = true;
+let tableReferenceDropListenerRegistered = false;
+let imeCompositionActive = false;
+let pendingImeModelEmit = false;
+
+type SelectionCaseMode = "upper" | "lower";
+let executableStatementRangeCache: ExecutableStatementRangeCache | null = null;
+let editorScrollbarPointerCleanup: (() => void) | null = null;
+let editorSelectionDragCleanup: (() => void) | null = null;
+let editorSelectionDropCursorEl: HTMLDivElement | null = null;
+const EDITOR_SCROLLBAR_POINTER_GUTTER_PX = 18;
+const EDITOR_SELECTION_DRAG_THRESHOLD_PX = 6;
+const tableNavigationHoverClass = "query-editor--table-navigation-hover";
+const DBX_VIM_SAVE_EVENT = "dbx-vim-save";
+
+function editorThemeAppearance() {
+  return isDark.value ? "dark" : "light";
+}
+
+// Completion cache
+let cachedTables: Array<{ name: string; schema?: string; type?: "table" | "view" }> = [];
+let cachedCompletionObjects: SqlCompletionObject[] = [];
+// Persistent column cache keyed by "schema.table" or "table"
+const cachedColumnsByTable = new Map<string, SqlCompletionColumn[]>();
+const cachedForeignKeysByTable = new Map<string, SqlCompletionForeignKey[]>();
+const loadedColumnsByTable = new Set<string>();
+
+const zoomCommitScheduler = createEditorZoomCommitScheduler((fontSize) => {
+  if (settingsStore.editorSettings.fontSize === fontSize) return;
+  settingsStore.updateEditorSettings({ fontSize });
+});
+
+const queryEditorAppearanceSettings = computed(() => {
+  const settings = settingsStore.editorSettings;
+  return {
+    fontFamily: settings.fontFamily,
+    fontSize: settings.fontSize,
+    theme: settings.theme,
+    customThemeColors: settings.customThemeColors,
+    customThemes: settings.customThemes,
+    activeCustomThemeId: settings.activeCustomThemeId,
+    wordWrap: settings.wordWrap,
+    vimModeEnabled: settings.vimModeEnabled,
+    autoCloseBrackets: settings.autoCloseBrackets,
+    showCurrentStatementFrame: settings.showCurrentStatementFrame,
+    showInsertValueHints: settings.showInsertValueHints,
+    shortcuts: settings.shortcuts,
+    showStatementRunButtons: settings.showStatementRunButtons,
+  };
+});
+
+function syncEditorFontCssVars(fontSize = liveFontSize.value, fontFamily = settingsStore.editorSettings.fontFamily) {
+  if (!editorRef.value) return;
+  editorRef.value.style.setProperty(EDITOR_FONT_SIZE_CSS_VAR, `${clampEditorFontSize(fontSize)}px`);
+  editorRef.value.style.setProperty(EDITOR_FONT_FAMILY_CSS_VAR, fontFamily);
+}
+
+let pendingFontReconfig: { size: number; family: string } | null = null;
+let fontReconfigScheduled = false;
+
+function reconfigureFontTheme(size: number, family: string) {
+  if (!fontThemeComp || !editorViewModule || !view.value) return;
+  view.value.dispatch({
+    effects: fontThemeComp.reconfigure(
+      editorFontTheme(editorViewModule.EditorView, size, family, {
+        fixedHeight: true,
+        scrollable: true,
+      }),
+    ),
+  });
+}
+
+function scheduleFontThemeReconfig(size: number, family: string) {
+  pendingFontReconfig = { size, family };
+  if (fontReconfigScheduled) return;
+  fontReconfigScheduled = true;
+  requestAnimationFrame(() => {
+    fontReconfigScheduled = false;
+    const p = pendingFontReconfig;
+    if (p) {
+      pendingFontReconfig = null;
+      reconfigureFontTheme(p.size, p.family);
+    }
+  });
+}
+
+function applyLiveFontSize(size: number) {
+  const next = clampEditorFontSize(size);
+  if (liveFontSize.value === next) return;
+  liveFontSize.value = next;
+  syncEditorFontCssVars(next);
+  // Throttle compartment reconfiguration to at most once per animation
+  // frame so that CSS variable changes remain smooth on every wheel tick,
+  // while the CodeMirror measure → syncGutters path keeps gutters aligned.
+  scheduleFontThemeReconfig(next, settingsStore.editorSettings.fontFamily);
+}
+
+function scheduleFontSizeCommit(size: number) {
+  zoomCommitScheduler.schedule(size);
+}
+
+function onEditorGestureStart(event: EditorGestureEvent) {
+  event.preventDefault();
+  isGestureZooming.value = true;
+  gestureStartFontSize.value = liveFontSize.value;
+}
+
+function onEditorGestureChange(event: EditorGestureEvent) {
+  if (typeof event.scale !== "number") return;
+  event.preventDefault();
+  applyLiveFontSize(fontSizeFromGestureScale(gestureStartFontSize.value, event.scale));
+}
+
+function onEditorGestureEnd(event: Event) {
+  event.preventDefault();
+  isGestureZooming.value = false;
+  zoomCommitScheduler.flush(liveFontSize.value);
+}
+
+// Resolve the indent unit (one Tab worth) from the SQL formatter settings so
+// the Tab key, multi-line indent and auto-indent all honor the configured width.
+function editorIndentUnit(): string {
+  const { useTabs, tabWidth } = settingsStore.editorSettings.sqlFormatter;
+  return useTabs ? "\t" : " ".repeat(tabWidth);
+}
+
+function handleTab(view: EditorViewType): boolean {
+  if (codeMirrorCompletionStatus?.(view.state) === "active") return false;
+  const { state, dispatch } = view;
+  const sel = state.selection.main;
+  if (!sel.empty) return codeMirrorIndentMore?.(view) ?? false;
+  const line = state.doc.lineAt(sel.from);
+  const before = line.text.slice(0, sel.from - line.from);
+  if (/^\s*$/.test(before)) return codeMirrorIndentMore?.(view) ?? false;
+  dispatch(state.update(state.replaceSelection(editorIndentUnit()), { userEvent: "input.type" }));
+  return true;
+}
+
+interface RequestExecuteOptions {
+  forceCurrent?: boolean;
+  ignoreSelection?: boolean;
+}
+
+function requestExecute(options: RequestExecuteOptions = {}) {
+  const currentView = view.value;
+  if (!currentView) return false;
+  return requestExecuteFromView(currentView, currentView.state.selection.main.head, options);
+}
+
+function requestExecuteFromView(currentView: EditorViewType, cursorPos: number, options: RequestExecuteOptions = {}) {
+  const selection = currentView.state.selection.main;
+  if (!options.ignoreSelection && !selection.empty) {
+    // Has manual selection → execute directly, skip picker.
+    emit("execute", sqlExecutionSnapshotFromView(currentView));
+    return true;
+  }
+  if (!supportsExecutionTargetPicker(props.databaseType)) {
+    emit("execute", sqlExecutionSnapshotFromView(currentView));
+    return true;
+  }
+  // No selection → show the execution target picker.
+  const doc = currentView.state.doc.toString();
+  const candidates = buildExecutionCandidates(doc, cursorPos, props.databaseType);
+  if (candidates.length === 0) return false;
+  if (options.forceCurrent) {
+    const candidate = candidates.find((item) => item.kind === "cursor") ?? candidates[0];
+    emit("execute", candidate.sql);
+    return true;
+  }
+  if (!settingsStore.editorSettings.showExecutionTargetPicker || !hasMultipleExecutionTargets(doc, props.databaseType)) {
+    const preferredKind = settingsStore.editorSettings.executeMode === "current" ? "cursor" : "all";
+    const candidate = candidates.find((item) => item.kind === preferredKind) ?? candidates[0];
+    emit("execute", candidate.sql);
+    return true;
+  }
+  closePicker();
+  pickerCandidates.value = candidates;
+  pickerActiveIndex.value = 0;
+  pickerAnchor.value = executionPickerAnchor(currentView, cursorPos, candidates.length);
+  pickerVisible.value = true;
+  setPreviewRange({ from: candidates[0].from, to: candidates[0].to });
+  return true;
+}
+
+function sqlSingleQuoteKeyActionAt(state: EditorViewType["state"], position: number) {
+  return resolveSqlSingleQuoteKeyAction({
+    previousChar: position > 0 ? state.doc.sliceString(position - 1, position) : "",
+    nextChar: position < state.doc.length ? state.doc.sliceString(position, position + 1) : "",
+    autoCloseBrackets: settingsStore.editorSettings.autoCloseBrackets,
+  });
+}
+
+function handleSqlSingleQuote(view: EditorViewType): boolean {
+  const { state } = view;
+  const EditorSelection = codeMirrorEditorSelection;
+  if (state.readOnly || !EditorSelection) return false;
+  if (state.selection.ranges.some((range) => !range.empty)) return false;
+  if (state.selection.ranges.some((range) => sqlSingleQuoteKeyActionAt(state, range.from) === "pass")) return false;
+  const transaction = state.changeByRange((range) => {
+    const nextRange = EditorSelection.cursor(range.from + 1);
+    if (sqlSingleQuoteKeyActionAt(state, range.from) !== "insertEscapedQuote") return { range: nextRange };
+    return {
+      changes: { from: range.from, insert: "'" },
+      range: nextRange,
+    };
+  });
+  view.dispatch(transaction, { userEvent: "input.type" });
+  return true;
+}
+
+function executionPickerAnchor(currentView: EditorViewType, cursorPos: number, candidateCount: number): { left: number; top: number } | undefined {
+  const cursorRect = currentView.coordsAtPos(cursorPos);
+  const rootRect = editorRef.value?.getBoundingClientRect();
+  if (!cursorRect || !rootRect) return undefined;
+
+  const verticalGap = 8;
+  const pickerHeight = 40 + Math.max(1, candidateCount) * 36;
+  const verticalMargin = 12;
+  const left = rootRect.width / 2;
+  const cursorBottom = cursorRect.bottom - rootRect.top;
+  const maxTop = Math.max(verticalMargin, rootRect.height - pickerHeight - verticalMargin);
+  const top = Math.min(cursorBottom + verticalGap, maxTop);
+
+  return { left, top };
+}
+
+function setPreviewRange(range: { from: number; to: number } | null) {
+  if (!view.value || !setPreviewRangeEffect) return;
+  view.value.dispatch({
+    effects: setPreviewRangeEffect.of(range),
+  });
+}
+
+function onPickerActiveIndexChange(index: number) {
+  pickerActiveIndex.value = index;
+  const candidate = pickerCandidates.value[index];
+  if (candidate) {
+    setPreviewRange({ from: candidate.from, to: candidate.to });
+  }
+}
+
+function onPickerConfirm(candidate: SqlExecutionCandidate) {
+  closePicker();
+  emit("execute", candidate.sql);
+}
+
+function closePicker() {
+  pickerVisible.value = false;
+  pickerAnchor.value = undefined;
+  setPreviewRange(null);
+  // Restore focus to the CodeMirror editor.
+  view.value?.focus();
+}
+
+function syncContextMenuState(currentView: EditorViewType) {
+  selectedSql.value = selectedSqlFromView(currentView);
+  executableSql.value = executableSqlFromView(currentView);
+}
+
+function syncContextMenuStateAtEvent(currentView: EditorViewType, event: MouseEvent) {
+  syncContextMenuState(currentView);
+  const pos = currentView.posAtCoords({ x: event.clientX, y: event.clientY });
+  contextTableName.value = pos == null ? null : qualifiedTableNameAtSqlPosition(currentView.state.doc.toString(), pos);
+}
+
+function focusEditor() {
+  view.value?.focus();
+}
+
+function clearTableNavigationHover() {
+  editorRef.value?.classList.remove(tableNavigationHoverClass);
+}
+
+function tableNavigationIdentifierAt(currentView: EditorViewType, event: MouseEvent): string | null {
+  if (!props.connectionId || props.database == null) return null;
+  const pos = currentView.posAtCoords({ x: event.clientX, y: event.clientY });
+  if (pos == null) return null;
+  const extracted = extractIdentifierDetailsAt(currentView.state.doc.toString(), pos);
+  if (!extracted || (!extracted.quoted && isSqlKeyword(extracted.identifier))) return null;
+  return extracted.identifier;
+}
+
+function updateTableNavigationHover(currentView: EditorViewType, event: MouseEvent) {
+  if (!event.metaKey && !event.ctrlKey) {
+    clearTableNavigationHover();
+    return false;
+  }
+  const identifier = tableNavigationIdentifierAt(currentView, event);
+  editorRef.value?.classList.toggle(tableNavigationHoverClass, !!identifier);
+  return !!identifier;
+}
+
+function clearTableNavigationHoverOnModifierRelease(event: KeyboardEvent) {
+  if (!event.metaKey && !event.ctrlKey) clearTableNavigationHover();
+}
+
+function isEditorScrollbarPointerEvent(currentView: EditorViewType, event: MouseEvent) {
+  if (event.button !== 0) return false;
+  const scrollDOM = currentView.scrollDOM;
+  const rect = scrollDOM.getBoundingClientRect();
+  const hasVerticalScrollbar = scrollDOM.scrollHeight > scrollDOM.clientHeight + 1;
+  const hasHorizontalScrollbar = scrollDOM.scrollWidth > scrollDOM.clientWidth + 1;
+  const verticalGutter = Math.max(scrollDOM.offsetWidth - scrollDOM.clientWidth, EDITOR_SCROLLBAR_POINTER_GUTTER_PX);
+  const horizontalGutter = Math.max(scrollDOM.offsetHeight - scrollDOM.clientHeight, EDITOR_SCROLLBAR_POINTER_GUTTER_PX);
+  const inVerticalScrollbar = hasVerticalScrollbar && event.clientX >= rect.right - verticalGutter && event.clientX <= rect.right;
+  const inHorizontalScrollbar = hasHorizontalScrollbar && event.clientY >= rect.bottom - horizontalGutter && event.clientY <= rect.bottom;
+  return inVerticalScrollbar || inHorizontalScrollbar;
+}
+
+function registerEditorScrollbarPointerGuard(currentView: EditorViewType) {
+  editorScrollbarPointerCleanup?.();
+  const onPointerDown = (event: MouseEvent) => {
+    if (!isEditorScrollbarPointerEvent(currentView, event)) return;
+    clearTableNavigationHover();
+    event.stopPropagation();
+  };
+  currentView.scrollDOM.addEventListener("mousedown", onPointerDown, true);
+  editorScrollbarPointerCleanup = () => {
+    currentView.scrollDOM.removeEventListener("mousedown", onPointerDown, true);
+    editorScrollbarPointerCleanup = null;
+  };
+}
+
+function selectedRangeAtPointer(currentView: EditorViewType, event: MouseEvent) {
+  if (props.readOnly || event.button !== 0) return null;
+  if (!currentView.contentDOM.contains(event.target as Node | null)) return null;
+  const range = currentView.state.selection.main;
+  if (range.empty) return null;
+  const pos = currentView.posAtCoords({ x: event.clientX, y: event.clientY }, false);
+  if (pos == null || pos < range.from || pos > range.to) return null;
+  return { from: range.from, to: range.to, text: currentView.state.sliceDoc(range.from, range.to) };
+}
+
+function moveOrCopySelectionToPointer(currentView: EditorViewType, selection: { from: number; to: number; text: string }, event: MouseEvent) {
+  const dropPos = currentView.posAtCoords({ x: event.clientX, y: event.clientY }, false);
+  if (dropPos == null) return false;
+  const copy = event.ctrlKey || event.metaKey;
+  if (!copy && dropPos >= selection.from && dropPos <= selection.to) return true;
+
+  const insert = { from: dropPos, insert: selection.text };
+  const changes = copy ? currentView.state.changes(insert) : currentView.state.changes([{ from: selection.from, to: selection.to }, insert]);
+  currentView.dispatch({
+    changes,
+    selection: {
+      anchor: changes.mapPos(dropPos, -1),
+      head: changes.mapPos(dropPos, 1),
+    },
+    scrollIntoView: true,
+    userEvent: copy ? "input.drop" : "move.drop",
+  });
+  currentView.focus();
+  return true;
+}
+
+function hideEditorSelectionDropCursor() {
+  editorSelectionDropCursorEl?.remove();
+  editorSelectionDropCursorEl = null;
+}
+
+function updateEditorSelectionDropCursor(currentView: EditorViewType, event: MouseEvent) {
+  const pos = currentView.posAtCoords({ x: event.clientX, y: event.clientY }, false);
+  if (pos == null) {
+    hideEditorSelectionDropCursor();
+    return;
+  }
+  const coords = currentView.coordsAtPos(pos);
+  if (!coords) {
+    hideEditorSelectionDropCursor();
+    return;
+  }
+  const ownerDocument = currentView.dom.ownerDocument;
+  const cursor = editorSelectionDropCursorEl ?? ownerDocument.createElement("div");
+  if (!editorSelectionDropCursorEl) {
+    cursor.setAttribute("aria-hidden", "true");
+    cursor.className = "dbx-editor-selection-drop-cursor";
+    // Use a fixed overlay instead of CodeMirror's internal drop cursor layer so
+    // the marker stays visible above selection layers, themes, and scrollers.
+    cursor.style.position = "fixed";
+    cursor.style.zIndex = "2147483647";
+    cursor.style.width = "2px";
+    cursor.style.pointerEvents = "none";
+    cursor.style.backgroundImage = "repeating-linear-gradient(to bottom, #e879f9 0 4px, transparent 4px 7px)";
+    cursor.style.filter = "drop-shadow(0 0 1px rgba(0, 0, 0, 0.7))";
+    ownerDocument.body.appendChild(cursor);
+    editorSelectionDropCursorEl = cursor;
+  }
+  cursor.style.left = `${Math.round(coords.left) - 1}px`;
+  cursor.style.top = `${Math.round(coords.top)}px`;
+  cursor.style.height = `${Math.max(16, Math.round(coords.bottom - coords.top))}px`;
+}
+
+function startEditorSelectionDrag(currentView: EditorViewType, event: MouseEvent): boolean {
+  const selection = selectedRangeAtPointer(currentView, event);
+  if (!selection) return false;
+
+  event.preventDefault();
+  event.stopPropagation();
+  if (!event.ctrlKey && !event.metaKey) {
+    emit("closeColumnPanel");
+  }
+  editorSelectionDragCleanup?.();
+  const startX = event.clientX;
+  const startY = event.clientY;
+  let dragging = false;
+
+  const cleanup = () => {
+    currentView.contentDOM.ownerDocument.removeEventListener("mousemove", onMove, true);
+    currentView.contentDOM.ownerDocument.removeEventListener("mouseup", onUp, true);
+    currentView.contentDOM.ownerDocument.removeEventListener("keydown", onKeyDown, true);
+    hideEditorSelectionDropCursor();
+    editorSelectionDragCleanup = null;
+  };
+
+  const onMove = (moveEvent: MouseEvent) => {
+    const distance = Math.hypot(moveEvent.clientX - startX, moveEvent.clientY - startY);
+    if (!dragging && distance < EDITOR_SELECTION_DRAG_THRESHOLD_PX) return;
+    dragging = true;
+    if (moveEvent.ctrlKey || moveEvent.metaKey) {
+      currentView.contentDOM.style.cursor = "copy";
+    } else {
+      currentView.contentDOM.style.cursor = "move";
+    }
+    updateEditorSelectionDropCursor(currentView, moveEvent);
+    moveEvent.preventDefault();
+    moveEvent.stopImmediatePropagation();
+  };
+
+  const onUp = (upEvent: MouseEvent) => {
+    cleanup();
+    currentView.contentDOM.style.cursor = "";
+    upEvent.preventDefault();
+    upEvent.stopImmediatePropagation();
+    if (dragging) {
+      moveOrCopySelectionToPointer(currentView, selection, upEvent);
+      return;
+    }
+    const pos = currentView.posAtCoords({ x: upEvent.clientX, y: upEvent.clientY });
+    if (pos != null) {
+      currentView.dispatch({ selection: { anchor: pos }, userEvent: "select.pointer" });
+      currentView.focus();
+    }
+  };
+
+  const onKeyDown = (keyEvent: KeyboardEvent) => {
+    if (keyEvent.key !== "Escape") return;
+    cleanup();
+    currentView.contentDOM.style.cursor = "";
+    keyEvent.preventDefault();
+    keyEvent.stopImmediatePropagation();
+  };
+
+  currentView.contentDOM.ownerDocument.addEventListener("mousemove", onMove, true);
+  currentView.contentDOM.ownerDocument.addEventListener("mouseup", onUp, true);
+  currentView.contentDOM.ownerDocument.addEventListener("keydown", onKeyDown, true);
+  editorSelectionDragCleanup = () => {
+    cleanup();
+    currentView.contentDOM.style.cursor = "";
+  };
+  return true;
+}
+
+function executeFromContextMenu() {
+  if (!canExecuteContextSql.value) return;
+  requestExecute();
+  focusEditor();
+}
+
+async function copySelectedSqlFromContextMenu() {
+  if (!canCopySelectedSql.value) return;
+  try {
+    await copyToClipboard(selectedSql.value);
+    toast(t("grid.copied"));
+    focusEditor();
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function selectAllSqlFromContextMenu() {
+  const currentView = view.value;
+  if (!currentView) return;
+  currentView.dispatch({
+    selection: { anchor: 0, head: currentView.state.doc.length },
+    scrollIntoView: true,
+  });
+  focusEditor();
+}
+
+function convertSelectedSqlCase(mode: SelectionCaseMode): boolean {
+  const currentView = view.value;
+  const EditorSelection = codeMirrorEditorSelection;
+  if (!currentView || !EditorSelection) return false;
+
+  const state = currentView.state;
+  const transaction = state.changeByRange((range) => {
+    if (range.empty) return { range };
+
+    const selectedText = state.sliceDoc(range.from, range.to);
+    const convertedText = mode === "upper" ? selectedText.toUpperCase() : selectedText.toLowerCase();
+    return {
+      changes: { from: range.from, to: range.to, insert: convertedText },
+      range: EditorSelection.range(range.from, range.from + convertedText.length),
+    };
+  });
+
+  if (!transaction.changes.empty) {
+    currentView.dispatch({ ...transaction, scrollIntoView: true, userEvent: "input" });
+    focusEditor();
+    return true;
+  }
+  return false;
+}
+
+async function pasteClipboardAsSqlInCondition(): Promise<boolean> {
+  if (!supportsSqlInListPaste(props.databaseType)) return false;
+  if (props.readOnly) return false;
+  const currentView = view.value;
+  if (!currentView) return false;
+
+  const selection = currentView.state.selection.main;
+  const selectedSource = selection.empty ? "" : currentView.state.sliceDoc(selection.from, selection.to);
+  let source = selectedSource;
+  if (!source) {
+    try {
+      source = await readTextFromClipboard();
+    } catch (e: any) {
+      toast(t("editor.exPasteClipboardReadFailed", { message: e?.message || String(e) }), 5000);
+      focusEditor();
+      return false;
+    }
+  }
+
+  const result = buildSqlInConditionFromPasteSource(source);
+  if (!result.ok) {
+    const key = result.reason === "too-large" ? "editor.exPasteTooLarge" : result.reason === "too-many-values" ? "editor.exPasteTooManyValues" : result.reason === "not-list" ? "editor.exPasteNotList" : "editor.exPasteNoValues";
+    toast(t(key, { limit: result.limit ?? 0 }), 5000);
+    focusEditor();
+    return false;
+  }
+
+  if (view.value !== currentView || props.readOnly) return false;
+  const state = currentView.state;
+  const line = state.doc.lineAt(selection.from);
+  const prefix = state.sliceDoc(line.from, selection.from);
+  const insertText = insertTextForSqlInCondition(result.sql, prefix);
+
+  currentView.dispatch({
+    changes: { from: selection.from, to: selection.to, insert: insertText },
+    selection: { anchor: selection.from + insertText.length },
+    scrollIntoView: true,
+    userEvent: "input.paste",
+  });
+  currentView.focus();
+  toast(t("editor.exPastePasted", { count: result.valueCount }), 2000);
+  return true;
+}
+
+function openTableFromContextMenu() {
+  if (!contextTableName.value) return;
+  emit("viewTableData", contextTableName.value);
+  focusEditor();
+}
+
+function editTableStructureFromContextMenu() {
+  if (!contextTableName.value) return;
+  emit("editTableStructure", contextTableName.value);
+  focusEditor();
+}
+
+function openTableDdlFromContextMenu() {
+  if (!contextTableName.value) return;
+  emit("viewTableDdl", contextTableName.value);
+  focusEditor();
+}
+
+function executableStatementRangeStartingAt(currentView: EditorViewType, lineFrom: number) {
+  executableStatementRangeCache = executableStatementRangeCacheForDoc(executableStatementRangeCache, currentView.state.doc, props.databaseType);
+  return executableStatementRangeStartingAtLine(executableStatementRangeCache, lineFrom);
+}
+
+function currentExecutableStatementRange(currentView: EditorViewType): SqlTextRange | null {
+  if (!supportsExecutionTargetPicker(props.databaseType)) return null;
+  executableStatementRangeCache = executableStatementRangeCacheForDoc(executableStatementRangeCache, currentView.state.doc, props.databaseType);
+  return executableStatementRangeAtCursor(executableStatementRangeCache, currentView.state.selection.main.head);
+}
+
+function executeSqlStatementFromGutter(currentView: EditorViewType, line: { from: number; to: number }, event: Event): boolean {
+  if (!(event instanceof MouseEvent) || event.button !== 0) return false;
+  const statementRange = executableStatementRangeStartingAt(currentView, line.from);
+  if (!statementRange) return false;
+  event.preventDefault();
+  event.stopPropagation();
+  // Gutter play is always scoped to the statement/command for that line, even
+  // when the main editor execute action would run the full document.
+  emit("execute", statementRange.sql);
+  currentView.focus();
+  return true;
+}
+
+function selectSqlLineFromGutter(currentView: EditorViewType, line: { from: number; to: number }, event: Event): boolean {
+  if (!(event instanceof MouseEvent) || event.button !== 0) return false;
+  event.preventDefault();
+  currentView.dispatch({
+    selection: { anchor: line.from, head: line.to },
+    scrollIntoView: true,
+    userEvent: "select.pointer",
+  });
+  currentView.focus();
+  return true;
+}
+
+const contextMenuItems = computed<ContextMenuItem[]>(() => {
+  const shortcuts = normalizeShortcutSettings(settingsStore.editorSettings.shortcuts);
+  return [
+    ...(props.hideExecutionControls
+      ? []
+      : [
+          {
+            label: executeContextMenuLabel.value,
+            action: executeFromContextMenu,
+            disabled: !canExecuteContextSql.value,
+            icon: Play,
+            shortcut: shortcuts.executeSql,
+          },
+        ]),
+    {
+      label: t("contextMenu.viewData"),
+      action: openTableFromContextMenu,
+      disabled: !contextTableName.value,
+      icon: Table2,
+    },
+    {
+      label: t("contextMenu.editStructure"),
+      action: editTableStructureFromContextMenu,
+      disabled: !contextTableName.value,
+      icon: PencilRuler,
+    },
+    {
+      label: t("contextMenu.viewDdl"),
+      action: openTableDdlFromContextMenu,
+      disabled: !contextTableName.value,
+      icon: FileCode,
+    },
+    { label: "", separator: true },
+    {
+      label: t("editor.contextMenu.copySelection"),
+      action: copySelectedSqlFromContextMenu,
+      disabled: !canCopySelectedSql.value,
+      icon: Copy,
+      shortcut: "Mod+C",
+    },
+    {
+      label: t("editor.contextMenu.sendToAi"),
+      action: () => {
+        if (selectedSql.value.trim()) emit("sendSelectionToAi", selectedSql.value);
+      },
+      disabled: !canCopySelectedSql.value,
+      icon: Sparkles,
+      shortcut: shortcuts.sendSelectionToAi,
+    },
+    {
+      label: t("editor.contextMenu.uppercaseSelection"),
+      action: () => convertSelectedSqlCase("upper"),
+      disabled: !canCopySelectedSql.value,
+      icon: CaseUpper,
+      shortcut: shortcuts.uppercaseSelection,
+    },
+    {
+      label: t("editor.contextMenu.lowercaseSelection"),
+      action: () => convertSelectedSqlCase("lower"),
+      disabled: !canCopySelectedSql.value,
+      icon: CaseLower,
+      shortcut: shortcuts.lowercaseSelection,
+    },
+    { label: t("editor.contextMenu.selectAll"), action: selectAllSqlFromContextMenu, icon: TextSelect, shortcut: shortcuts.selectAll },
+  ];
+});
+
+function runKeymapExtension(codeMirrorKeymap: (typeof import("@codemirror/view"))["keymap"]) {
+  const shortcuts = normalizeShortcutSettings(settingsStore.editorSettings.shortcuts);
+  const Prec = codeMirrorPrec;
+  const binding = (shortcut: string, run: (view: EditorViewType) => boolean) => (shortcut ? [{ key: shortcutToCodeMirrorKey(shortcut), preventDefault: true, run }] : []);
+  const executeBindings = props.hideExecutionControls ? [] : binding(shortcuts.executeSql, () => requestExecute({ forceCurrent: true }));
+  return [
+    Prec?.high(
+      codeMirrorKeymap.of([
+        {
+          key: "Enter",
+          run: codeMirrorInsertNewlineKeepIndent ?? undefined,
+          shift: codeMirrorInsertNewlineKeepIndent ?? undefined,
+        },
+        ...binding(shortcuts.find, openSearch),
+        ...binding(shortcuts.replace, openReplace),
+        ...executeBindings,
+        ...binding(shortcuts.saveSql, () => {
+          emit("save");
+          return true;
+        }),
+        ...binding(shortcuts.formatSql, () => {
+          void formatCurrentSql();
+          return true;
+        }),
+        ...binding(shortcuts.indentMore, (view) => codeMirrorIndentMore?.(view) ?? false),
+        ...binding(shortcuts.indentLess, (view) => codeMirrorIndentLess?.(view) ?? false),
+        ...binding(shortcuts.duplicateLine, (view) => codeMirrorCopyLineDown?.(view) ?? false),
+        ...binding(shortcuts.deleteLine, (view) => codeMirrorDeleteLine?.(view) ?? false),
+        ...binding(shortcuts.moveLineUp, (view) => codeMirrorMoveLineUp?.(view) ?? false),
+        ...binding(shortcuts.moveLineDown, (view) => codeMirrorMoveLineDown?.(view) ?? false),
+        ...binding(shortcuts.copyLineUp, (view) => codeMirrorCopyLineUp?.(view) ?? false),
+        ...binding(shortcuts.copyLineDown, (view) => codeMirrorCopyLineDown?.(view) ?? false),
+        ...binding(shortcuts.undo, (view) => codeMirrorUndo?.(view) ?? false),
+        ...binding(shortcuts.redo, (view) => codeMirrorRedo?.(view) ?? false),
+        ...binding(shortcuts.selectAll, (view) => codeMirrorSelectAll?.(view) ?? false),
+        ...binding(shortcuts.uppercaseSelection, () => convertSelectedSqlCase("upper")),
+        ...binding(shortcuts.lowercaseSelection, () => convertSelectedSqlCase("lower")),
+        ...binding(shortcuts.toggleLineComment, (view) => codeMirrorToggleLineComment?.(view) ?? false),
+        ...binding(shortcuts.exPasteSqlInCondition, () => {
+          if (!supportsSqlInListPaste(props.databaseType)) return false;
+          void pasteClipboardAsSqlInCondition();
+          return true;
+        }),
+        ...binding(shortcuts.sendSelectionToAi, (currentView) => {
+          const sql = selectedSqlFromView(currentView);
+          if (sql.trim()) emit("sendSelectionToAi", sql);
+          return true;
+        }),
+      ]),
+    ) ?? [],
+    codeMirrorKeymap.of(
+      binding(shortcuts.acceptCompletion, acceptCompletionOrNextSnippetField).map((item) => ({
+        ...item,
+        preventDefault: false,
+      })),
+    ),
+  ];
+}
+
+function acceptCompletionOrNextSnippetField(view: EditorViewType): boolean {
+  if (codeMirrorCompletionStatus?.(view.state) && (codeMirrorAcceptCompletion?.(view) ?? false)) {
+    return true;
+  }
+  // Table/column completions can happen inside a CodeMirror snippet field. When
+  // the completion popup is gone, Tab should continue through the snippet fields.
+  return codeMirrorNextSnippetField?.(view) ?? false;
+}
+
+function wordWrapExtension() {
+  if (!editorViewModule) return [];
+  return props.forceWordWrap || settingsStore.editorSettings.wordWrap ? editorViewModule.EditorView.lineWrapping : [];
+}
+
+function closeBracketsExtension(enabled = settingsStore.editorSettings.autoCloseBrackets) {
+  if (!enabled || !codeMirrorCloseBrackets) return [];
+  const exts: import("@codemirror/state").Extension[] = [codeMirrorCloseBrackets()];
+  if (codeMirrorCloseBracketsKeymap?.length && codeMirrorPrec && editorViewModule) {
+    exts.push(codeMirrorPrec.highest(editorViewModule.keymap.of([...codeMirrorCloseBracketsKeymap])));
+  }
+  return exts;
+}
+
+function vimModeExtension(enabled = settingsStore.editorSettings.vimModeEnabled) {
+  if (!codeMirrorVim || !enabled) return [];
+  const vimExtension = codeMirrorVim({ status: true });
+  if (!codeMirrorPrec || !editorViewModule || !codeMirrorGetVimCm || !codeMirrorVimApi) return vimExtension;
+
+  // Beekeeper treats Vim as a first-class editor keymap. Keep it above DBX's
+  // normal shortcuts so regular normal-mode keys are not stolen by other maps.
+  return codeMirrorPrec.highest([
+    editorViewModule.keymap.of([
+      {
+        key: "Ctrl-[",
+        mac: "Ctrl-[",
+        linux: "Ctrl-[",
+        win: "Ctrl-[",
+        run(currentView) {
+          const cm = codeMirrorGetVimCm?.(currentView);
+          if (cm?.state.vim?.insertMode) {
+            codeMirrorVimApi?.exitInsertMode(cm as any, true);
+            return true;
+          }
+          return false;
+        },
+      },
+    ]),
+    vimExtension,
+  ]);
+}
+
+function configureDbxVimCommands(vimApi: typeof import("@replit/codemirror-vim").Vim) {
+  if (dbxVimCommandsConfigured) return;
+  dbxVimCommandsConfigured = true;
+  vimApi.defineEx("write", "w", (cm) => {
+    cm.cm6?.contentDOM.dispatchEvent(new CustomEvent(DBX_VIM_SAVE_EVENT, { bubbles: true }));
+  });
+}
+
+async function ensureCodeMirrorVim() {
+  if (codeMirrorVim && codeMirrorVimApi && codeMirrorGetVimCm) return true;
+  codeMirrorVimImportPromise ??= import("@replit/codemirror-vim");
+  const { vim, Vim, getCM } = await codeMirrorVimImportPromise;
+  codeMirrorVim = vim;
+  codeMirrorVimApi = Vim;
+  codeMirrorGetVimCm = getCM;
+  configureDbxVimCommands(Vim);
+  return true;
+}
+
+function indentExtension() {
+  if (!codeMirrorIndentUnit) return [];
+  return codeMirrorIndentUnit.of(editorIndentUnit());
+}
+
+function selectedSqlFromView(currentView: EditorViewType): string {
+  const selection = currentView.state.selection.main;
+  return currentView.state.sliceDoc(selection.from, selection.to);
+}
+
+function executableSqlFromView(currentView: EditorViewType): string {
+  return resolveExecutableSql(currentView.state.doc.toString(), selectedSqlFromView(currentView));
+}
+
+function sqlExecutionSnapshotFromView(currentView: EditorViewType): SqlExecutionSnapshot {
+  return {
+    fullSql: currentView.state.doc.toString(),
+    selectedSql: selectedSqlFromView(currentView),
+    cursorPos: currentView.state.selection.main.head,
+  };
+}
+
+function identifierRangeAt(sql: string, pos: number): { from: number; to: number; text: string } | null {
+  const isIdentifierChar = (ch: string | undefined) => !!ch && /[\w$.]/.test(ch);
+  if (!isIdentifierChar(sql[pos]) && !isIdentifierChar(sql[pos - 1])) return null;
+
+  let from = pos;
+  while (from > 0 && isIdentifierChar(sql[from - 1])) from--;
+  let to = pos;
+  while (to < sql.length && isIdentifierChar(sql[to])) to++;
+
+  const text = sql.slice(from, to).replace(/^\.+|\.+$/g, "");
+  if (!text || isSqlKeyword(text)) return null;
+  return { from, to, text };
+}
+
+function completionCacheKey(table: { name: string; schema?: string | null }) {
+  const schema = table.schema ?? props.schema;
+  return schema ? `${schema}.${table.name}` : table.name;
+}
+
+const pendingInsertValueHintColumnLoads = new Set<string>();
+
+function insertHintCacheKey(table: { name: string; schema?: string | null; database?: string | null }) {
+  if (table.database) {
+    return table.schema ? `${table.database}.${table.schema}.${table.name}` : `${table.database}.${table.name}`;
+  }
+  return completionCacheKey(table);
+}
+
+function insertHintMetadataTarget(table: { name: string; schema?: string | null; database?: string | null }): { database: string; schema?: string } | null {
+  if (props.database == null) return null;
+  if (table.database) {
+    return { database: table.database, schema: table.schema ?? undefined };
+  }
+  return completionMetadataTarget(table);
+}
+
+function getInsertValueHintTableColumns(table: string, schema?: string, database?: string): string[] | undefined {
+  const cacheKey = insertHintCacheKey({ name: table, schema, database });
+  const cached = cachedColumnsByTable.get(cacheKey);
+  if (!cached) return undefined;
+  return cached.map((column) => column.name);
+}
+
+function requestInsertValueHintTableColumns(table: string, schema?: string, database?: string) {
+  if (!props.connectionId || props.database == null) return;
+  if (props.databaseType === "redis" || props.databaseType === "mongodb" || props.databaseType === "elasticsearch") return;
+  const cacheKey = insertHintCacheKey({ name: table, schema, database });
+  if (cachedColumnsByTable.has(cacheKey) || pendingInsertValueHintColumnLoads.has(cacheKey)) return;
+  const target = insertHintMetadataTarget({ name: table, schema, database });
+  if (!target) return;
+  pendingInsertValueHintColumnLoads.add(cacheKey);
+  void connectionStore
+    .listCompletionColumns(props.connectionId, target.database, table, target.schema)
+    .then((columns) => {
+      cachedColumnsByTable.set(cacheKey, columns);
+      loadedColumnsByTable.add(cacheKey.toLowerCase());
+      if (view.value) requestInsertValueHintsRefresh(view.value);
+    })
+    .catch(() => {})
+    .finally(() => {
+      pendingInsertValueHintColumnLoads.delete(cacheKey);
+    });
+}
+
+function supportsDatabaseQualifierCompletion(): boolean {
+  return !!props.databaseType && !isSchemaAware(props.databaseType) && !isSingleDatabase(props.databaseType);
+}
+
+function usesLocalOnlyCompletionMetadata(): boolean {
+  return usesLocalOnlyEditorCompletionMetadata(props.databaseType);
+}
+
+function usesOnDemandOnlyCompletionColumns(): boolean {
+  return usesOnDemandOnlyEditorColumnMetadata(props.databaseType);
+}
+
+function allowsOnDemandQualifiedTableCompletion(prefix: string): boolean {
+  if (!usesLocalOnlyCompletionMetadata()) return false;
+  if (props.databaseType !== "prestosql" && props.databaseType !== "trino") return false;
+  return prefix.trim().length >= PRESTO_ON_DEMAND_TABLE_COMPLETION_MIN_PREFIX;
+}
+
+function completionMetadataTarget(table: { name: string; schema?: string | null }): { database: string; schema?: string } | null {
+  if (props.database == null) return null;
+  if (supportsDatabaseQualifierCompletion() && table.schema) {
+    return { database: table.schema };
+  }
+  return { database: props.database, schema: table.schema ?? props.schema };
+}
+
+function completionQualifiedTableTarget(completionContext: ReturnType<typeof getSqlCompletionContext>): { name: string; schema: string } | null {
+  if (!completionContext.suggestColumns) return null;
+  const parts = completionContext.qualifierParts ?? completionContext.qualifier?.split(".").filter(Boolean) ?? [];
+  if (parts.length < 2) return null;
+  const name = parts[parts.length - 1];
+  const schema = parts[parts.length - 2];
+  if (!name || !schema) return null;
+  return { name, schema };
+}
+
+function completionTablesMatch(left: { name: string; schema?: string | null }, right: { name: string; schema?: string | null }) {
+  if (left.name.toLowerCase() !== right.name.toLowerCase()) return false;
+  if (!left.schema || !right.schema) return true;
+  return left.schema.toLowerCase() === right.schema.toLowerCase();
+}
+
+async function findExactSemanticDiagnosticTable(table: SqlTableReference): Promise<{ name: string; schema?: string; type?: "table" | "view" } | null> {
+  if (!props.connectionId || props.database == null) return null;
+  const target = completionMetadataTarget(table);
+  if (!target) return null;
+  const localMatches = connectionStore.lookupLocalCompletionTables(props.connectionId, target.database, table.name, MAX_COMPLETION_TABLES, target.schema);
+  const localExact = localMatches.find((item) => completionTablesMatch(item, table));
+  if (localExact) return localExact;
+
+  const remoteMatches = await connectionStore.listCompletionTables(props.connectionId, target.database, table.name, MAX_COMPLETION_TABLES, target.schema);
+  cachedTables = mergeCompletionTables(cachedTables, remoteMatches);
+  return remoteMatches.find((item) => completionTablesMatch(item, table)) ?? null;
+}
+
+async function ensureColumnsForTable(table: { name: string; schema?: string | null }): Promise<boolean> {
+  const cacheKey = completionCacheKey(table);
+  if (cachedColumnsByTable.has(cacheKey)) return true;
+  if (!props.connectionId || props.database == null) return false;
+  const target = completionMetadataTarget(table);
+  if (!target) return false;
+  const columns = await connectionStore.listCompletionColumns(props.connectionId, target.database, table.name, target.schema);
+  cachedColumnsByTable.set(cacheKey, columns);
+  loadedColumnsByTable.add(cacheKey.toLowerCase());
+  return true;
+}
+
+function isMissingTableMetadataError(error: unknown) {
+  const message = String(error instanceof Error ? error.message : error).toLowerCase();
+  return message.includes("42s02") || message.includes("1146") || message.includes("doesn't exist") || message.includes("does not exist") || message.includes("unknown table");
+}
+
+async function ensureForeignKeysForTable(table: { name: string; schema?: string | null }) {
+  const cacheKey = completionCacheKey(table);
+  if (cachedForeignKeysByTable.has(cacheKey) || !props.connectionId || props.database == null) return;
+  const target = completionMetadataTarget(table);
+  if (!target) return;
+  try {
+    const foreignKeys = await connectionStore.listCompletionForeignKeys(props.connectionId, target.database, table.name, target.schema);
+    cachedForeignKeysByTable.set(cacheKey, foreignKeys);
+  } catch (e) {
+    console.warn(`[DBX] Failed to load foreign keys for ${cacheKey}:`, e);
+    cachedForeignKeysByTable.set(cacheKey, []);
+  }
+}
+
+async function ensureForeignKeysForTables(tables: Array<{ name: string; schema?: string | null }>) {
+  const seen = new Set<string>();
+  const uniqueTables = tables.filter((table) => {
+    const key = completionCacheKey(table).toLowerCase();
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  for (let index = 0; index < uniqueTables.length; index += COMPLETION_METADATA_CONCURRENCY) {
+    await Promise.all(uniqueTables.slice(index, index + COMPLETION_METADATA_CONCURRENCY).map((table) => ensureForeignKeysForTable(table)));
+  }
+}
+
+function createHoverDom(title: string, detail: string, rows: string[] = []) {
+  const dom = document.createElement("div");
+  dom.className = "rounded-md border bg-popover px-3 py-2 text-xs text-popover-foreground shadow-md";
+
+  const heading = document.createElement("div");
+  heading.className = "font-medium";
+  heading.textContent = title;
+  dom.appendChild(heading);
+
+  const detailNode = document.createElement("div");
+  detailNode.className = "mt-1 text-muted-foreground";
+  detailNode.textContent = detail;
+  dom.appendChild(detailNode);
+
+  for (const row of rows) {
+    const rowNode = document.createElement("div");
+    rowNode.className = "mt-1 font-mono text-muted-foreground";
+    rowNode.textContent = row;
+    dom.appendChild(rowNode);
+  }
+
+  return dom;
+}
+
+function createSignatureDom(signature: ReturnType<typeof getSqlFunctionSignatureHelp>) {
+  const dom = document.createElement("div");
+  dom.className = "rounded-md border bg-popover px-3 py-2 text-xs text-popover-foreground shadow-md";
+  if (!signature) return dom;
+
+  const signatureNode = document.createElement("div");
+  signatureNode.className = "font-mono";
+
+  const nameNode = document.createElement("span");
+  nameNode.className = "text-muted-foreground";
+  nameNode.textContent = `${signature.name}(`;
+  signatureNode.appendChild(nameNode);
+
+  signature.parameters.forEach((parameter, index) => {
+    if (index > 0) {
+      const comma = document.createElement("span");
+      comma.className = "text-muted-foreground";
+      comma.textContent = ", ";
+      signatureNode.appendChild(comma);
+    }
+    const parameterNode = document.createElement("span");
+    parameterNode.className = index === signature.activeParameter ? "font-semibold text-foreground" : "text-muted-foreground";
+    parameterNode.textContent = parameter;
+    signatureNode.appendChild(parameterNode);
+  });
+
+  const closeNode = document.createElement("span");
+  closeNode.className = "text-muted-foreground";
+  closeNode.textContent = ")";
+  signatureNode.appendChild(closeNode);
+  dom.appendChild(signatureNode);
+
+  return dom;
+}
+
+async function resolveSqlHoverTooltip(currentView: EditorViewType, pos: number) {
+  if (!props.connectionId || props.database == null) return null;
+
+  const sql = currentView.state.doc.toString();
+  const range = identifierRangeAt(sql, pos);
+  if (!range) return null;
+
+  const identifier = range.text;
+  const parts = splitQualifiedIdentifier(identifier);
+  const name = parts[parts.length - 1] ?? identifier;
+  const qualifier = parts.length > 1 ? parts[parts.length - 2] : undefined;
+  const semanticModel = SEMANTIC_SQL_COMPLETION_ENABLED ? buildSqlSemanticModel(sql, pos, { databaseType: props.databaseType, dialect: props.dialect }) : null;
+  const semanticTarget = semanticModel ? resolveSqlSemanticNavigationTarget(semanticModel, parts) : null;
+  const semanticQualifierIsRowSource = !!qualifier && !!semanticTarget && (semanticTarget.alias?.toLowerCase() === qualifier.toLowerCase() || semanticTarget.source.name.toLowerCase() === qualifier.toLowerCase());
+  const tableLookupName = semanticTarget && !semanticQualifierIsRowSource ? semanticTarget.name : name;
+  const qualifiedTableLookup = semanticTarget?.schema ? `${semanticTarget.schema}.${semanticTarget.name}` : identifier;
+
+  try {
+    if (cachedTables.length === 0) {
+      cachedTables = usesLocalOnlyCompletionMetadata()
+        ? connectionStore.lookupLocalCompletionTables(props.connectionId, props.database, tableLookupName, MAX_COMPLETION_TABLES, props.schema)
+        : await connectionStore.listCompletionTables(props.connectionId, props.database, tableLookupName, MAX_COMPLETION_TABLES, props.schema);
+    }
+
+    let table = matchTable(qualifiedTableLookup, cachedTables) ?? matchTable(tableLookupName, cachedTables) ?? matchTable(identifier, cachedTables) ?? matchTable(name, cachedTables);
+    if (!table && !usesLocalOnlyCompletionMetadata()) {
+      const hoverTables = await connectionStore.listCompletionTables(props.connectionId, props.database, tableLookupName, MAX_COMPLETION_TABLES, semanticTarget?.schema ?? props.schema);
+      cachedTables = [...cachedTables, ...hoverTables];
+      table = matchTable(qualifiedTableLookup, hoverTables) ?? matchTable(tableLookupName, hoverTables) ?? matchTable(identifier, hoverTables) ?? matchTable(name, hoverTables);
+    }
+    if (table && !semanticQualifierIsRowSource && (!qualifier || table.schema?.toLowerCase() === qualifier.toLowerCase() || table.name === name)) {
+      return {
+        pos: range.from,
+        end: range.to,
+        create: () => ({
+          dom: createHoverDom(table.name, table.schema ? `table in ${table.schema}` : "table"),
+        }),
+      };
+    }
+
+    const legacyContext = getSqlCompletionContext(sql, pos);
+    const context = semanticModel ? sqlCompletionContextFromSemantic(semanticModel, legacyContext) : legacyContext;
+    const candidates = qualifier ? context.referencedTables.filter((rt) => rt.alias?.toLowerCase() === qualifier.toLowerCase() || rt.name.toLowerCase() === qualifier.toLowerCase()) : context.referencedTables;
+
+    for (const refTable of candidates) {
+      const columns: SqlCompletionColumn[] =
+        refTable.columns?.map((columnName) => ({
+          name: columnName,
+          table: refTable.name,
+          ...(refTable.schema ? { schema: refTable.schema } : {}),
+        })) ?? [];
+      if (columns.length === 0) {
+        await ensureColumnsForTable(refTable);
+        columns.push(...(cachedColumnsByTable.get(completionCacheKey(refTable)) ?? []));
+      }
+      const column = columns.find((col) => col.name.toLowerCase() === name.toLowerCase());
+      if (!column) continue;
+      return {
+        pos: range.from,
+        end: range.to,
+        create: () => ({
+          dom: createHoverDom(column.name, column.dataType || "column", [column.schema ? `${column.schema}.${column.table}` : column.table, ...(column.comment?.trim() ? [column.comment.trim()] : [])]),
+        }),
+      };
+    }
+  } catch {
+    return null;
+  }
+
+  return null;
+}
+
+function sqlErrorDecorationRange(currentState: import("@codemirror/state").EditorState) {
+  if (!props.executionError) return [];
+  if (!props.executionErrorSql || props.executionErrorSql !== currentState.doc.toString()) return [];
+  const location = parseSqlErrorLocation(props.executionError);
+  if (!location) return [];
+  const offset = lineColumnToOffset(currentState.doc.toString(), location);
+  if (offset == null) return [];
+  return [
+    {
+      from: offset,
+      to: Math.min(offset + 1, currentState.doc.length),
+      message: props.executionError,
+    },
+  ];
+}
+
+function sqlTextSpanToRange(sql: string, span: SqlTextSpan): { from: number; to: number } | null {
+  if (!span.start_line || !span.start_column) return null;
+  const from = lineColumnToOffset(sql, { line: span.start_line - 1, column: span.start_column - 1 });
+  const to = lineColumnToOffset(sql, {
+    line: Math.max(span.end_line - 1, span.start_line - 1),
+    column: Math.max(span.end_column, span.start_column),
+  });
+  if (from == null || to == null || to <= from) return null;
+  return { from, to };
+}
+
+function sqlSemanticDecorationRanges(currentState: import("@codemirror/state").EditorState) {
+  const sql = currentState.doc.toString();
+  return semanticDiagnostics
+    .map((diagnostic) => {
+      const range = sqlTextSpanToRange(sql, diagnostic.span);
+      return range ? { ...range, message: diagnostic.message, severity: diagnostic.severity } : null;
+    })
+    .filter((range): range is { from: number; to: number; message: string; severity: "error" | "warning" } => !!range);
+}
+
+function reconfigureDiagnostics() {
+  if (!view.value) return;
+  if (setSqlDiagnosticsEffect) {
+    view.value.dispatch({
+      effects: setSqlDiagnosticsEffect.of(semanticDiagnostics),
+    });
+    return;
+  }
+  if (!diagnosticComp || !buildSqlDiagnosticExtension) return;
+  view.value.dispatch({
+    effects: diagnosticComp.reconfigure(buildSqlDiagnosticExtension()),
+  });
+}
+
+function setSemanticDiagnostics(next: SqlSemanticDiagnostic[]) {
+  if (areSqlSemanticDiagnosticsEqual(semanticDiagnostics, next)) return;
+  semanticDiagnostics = next;
+  reconfigureDiagnostics();
+}
+
+function clearScheduledSemanticDiagnostics() {
+  semanticDiagnosticRunId++;
+  if (semanticDiagnosticTimer) clearTimeout(semanticDiagnosticTimer);
+  semanticDiagnosticTimer = null;
+  pendingSemanticDiagnosticPreserveOutsideRanges = false;
+}
+
+function invalidateSemanticDiagnosticsForDocumentChange() {
+  semanticDiagnosticRunId++;
+  semanticDiagnostics = [];
+}
+
+function shouldSkipSqlSemanticDiagnostics() {
+  return props.databaseType !== "redis" && !settingsStore.editorSettings.sqlSemanticDiagnosticsEnabled;
+}
+
+function rangesOverlap(left: { from: number; to: number }, right: { from: number; to: number }): boolean {
+  return left.from < right.to && right.from < left.to;
+}
+
+function sqlLineColumnAtOffset(sql: string, offset: number): { line: number; column: number } {
+  const safeOffset = Math.max(0, Math.min(offset, sql.length));
+  let line = 1;
+  let lineStart = 0;
+  for (let index = 0; index < safeOffset; index += 1) {
+    if (sql[index] === "\n") {
+      line += 1;
+      lineStart = index + 1;
+    }
+  }
+  return { line, column: safeOffset - lineStart + 1 };
+}
+
+function offsetSqlTextSpan(span: SqlTextSpan, rangeStart: { line: number; column: number }): SqlTextSpan {
+  const offsetLine = (line: number) => rangeStart.line + line - 1;
+  const offsetColumn = (line: number, column: number) => (line === 1 ? rangeStart.column + column - 1 : column);
+  return {
+    start_line: offsetLine(span.start_line),
+    start_column: offsetColumn(span.start_line, span.start_column),
+    end_line: offsetLine(span.end_line),
+    end_column: offsetColumn(span.end_line, span.end_column),
+  };
+}
+
+function offsetSqlSemanticDiagnostics(diagnostics: readonly SqlSemanticDiagnostic[], range: SqlTextRange, fullSql: string): SqlSemanticDiagnostic[] {
+  const rangeStart = sqlLineColumnAtOffset(fullSql, range.from);
+  return diagnostics.map((diagnostic) => ({
+    ...diagnostic,
+    span: offsetSqlTextSpan(diagnostic.span, rangeStart),
+  }));
+}
+
+function replaceSemanticDiagnosticsInRanges(next: SqlSemanticDiagnostic[], ranges: readonly SqlTextRange[], fullSql: string) {
+  const retained = semanticDiagnostics.filter((diagnostic) => {
+    const diagnosticRange = sqlTextSpanToRange(fullSql, diagnostic.span);
+    return !diagnosticRange || !ranges.some((range) => rangesOverlap(diagnosticRange, range));
+  });
+  setSemanticDiagnostics([...retained, ...next].sort(compareSqlSemanticDiagnostics));
+}
+
+function compareSqlSemanticDiagnostics(left: SqlSemanticDiagnostic, right: SqlSemanticDiagnostic): number {
+  return left.span.start_line - right.span.start_line || left.span.start_column - right.span.start_column || left.span.end_line - right.span.end_line || left.span.end_column - right.span.end_column || left.message.localeCompare(right.message);
+}
+
+async function enrichSemanticDiagnosticTables(tables: SqlTableReference[]): Promise<{ tables: SqlTableReference[]; missingTables: Set<string> }> {
+  if (!props.connectionId || props.database == null) return { tables, missingTables: new Set() };
+
+  const enriched: SqlTableReference[] = [];
+  const missingTables = new Set<string>();
+  for (const table of tables) {
+    if (isStatementLocalSemanticTable(table)) {
+      enriched.push(table);
+      continue;
+    }
+    try {
+      const match = await findExactSemanticDiagnosticTable(table);
+      if (!match) missingTables.add(tableReferenceKey(table));
+      enriched.push(match?.schema ? { ...table, schema: match.schema } : table);
+    } catch {
+      enriched.push(table);
+    }
+  }
+  return { tables: enriched, missingTables };
+}
+
+async function ensureColumnsForSemanticDiagnostics(tables: SqlTableReference[]): Promise<Set<string>> {
+  const missingTables = new Set<string>();
+  const seen = new Set<string>();
+  const targets: SqlTableReference[] = [];
+  for (const table of tables) {
+    if (isStatementLocalSemanticTable(table)) continue;
+    const tableWithInlineColumns = table as SqlTableReference & { columns?: string[] };
+    if (tableWithInlineColumns.columns && tableWithInlineColumns.columns.length > 0) continue;
+    const cacheKey = completionCacheKey(table);
+    if (cachedColumnsByTable.has(cacheKey)) continue;
+    const normalizedKey = cacheKey.toLowerCase();
+    if (seen.has(normalizedKey)) continue;
+    seen.add(normalizedKey);
+    targets.push(table);
+    if (targets.length >= MAX_SEMANTIC_DIAGNOSTIC_COLUMN_TABLES) break;
+  }
+  await Promise.all(
+    targets.map(async (table) => {
+      try {
+        await ensureColumnsForTable(table);
+      } catch (error) {
+        if (isMissingTableMetadataError(error)) {
+          missingTables.add(tableReferenceKey(table));
+        }
+      }
+    }),
+  );
+  return missingTables;
+}
+
+function isStatementLocalSemanticTable(table: SqlTableReference): boolean {
+  const kind = (table as SqlTableReference & { semanticSourceKind?: string }).semanticSourceKind;
+  return kind === "cte" || kind === "subquery" || kind === "table_function";
+}
+
+async function refreshSemanticDiagnostics(options: { preserveOutsideRanges?: boolean } = {}) {
+  const currentView = view.value;
+  const runId = ++semanticDiagnosticRunId;
+  if (!currentView || !props.connectionId || props.database == null) {
+    setSemanticDiagnostics([]);
+    return;
+  }
+
+  const sql = currentView.state.doc.toString();
+  if (!sql.trim()) {
+    setSemanticDiagnostics([]);
+    return;
+  }
+  if (props.databaseType === "mongodb" || props.databaseType === "elasticsearch") {
+    setSemanticDiagnostics([]);
+    return;
+  }
+  if (props.databaseType === "redis") {
+    // Redis has no SQL semantics; run command-name / arity / quote / danger checks instead.
+    if (!shouldRunRedisDiagnostics(sql, currentView.state.selection.main.head)) {
+      scheduleSemanticDiagnostics(900, { preserveOutsideRanges: options.preserveOutsideRanges });
+      return;
+    }
+    setSemanticDiagnostics(buildRedisSyntaxDiagnostics(sql));
+    return;
+  }
+  if (shouldSkipSqlSemanticDiagnostics()) {
+    setSemanticDiagnostics([]);
+    return;
+  }
+  if (!shouldRunSqlSemanticDiagnostics(sql, currentView.state.selection.main.head, { databaseType: props.databaseType })) {
+    scheduleSemanticDiagnostics(1200, { preserveOutsideRanges: options.preserveOutsideRanges });
+    return;
+  }
+  if (codeMirrorCompletionStatus?.(currentView.state) && isSqlSemanticDiagnosticInputContext(sql, currentView.state.selection.main.head, { databaseType: props.databaseType })) {
+    scheduleSemanticDiagnostics(900, { preserveOutsideRanges: options.preserveOutsideRanges });
+    return;
+  }
+
+  const visibleRanges = currentView.visibleRanges.length > 0 ? currentView.visibleRanges : [currentView.viewport];
+  const diagnosticRanges = sqlSemanticDiagnosticRangesForViewport(sql, visibleRanges, props.databaseType);
+  if (diagnosticRanges.length === 0) {
+    if (!options.preserveOutsideRanges) setSemanticDiagnostics([]);
+    return;
+  }
+
+  const nextDiagnostics: SqlSemanticDiagnostic[] = [];
+  for (const range of diagnosticRanges) {
+    try {
+      const analysis = await api.analyzeSqlReferences(range.sql, props.formatDialect ?? props.dialect ?? "generic");
+      if (runId !== semanticDiagnosticRunId) return;
+
+      const semanticCursor = Math.max(0, Math.min(currentView.state.selection.main.head - range.from, range.sql.length));
+      const semanticModel = SEMANTIC_SQL_COMPLETION_ENABLED ? buildSqlSemanticModel(range.sql, semanticCursor, { databaseType: props.databaseType, dialect: props.dialect }) : null;
+      const semanticAnalysis = semanticModel ? mergeSqlSemanticReferenceAnalysis(analysis, semanticModel) : analysis;
+      const { tables, missingTables } = await enrichSemanticDiagnosticTables(semanticAnalysis.tables);
+      const columnMetadataMissingTables = await ensureColumnsForSemanticDiagnostics(tables);
+      for (const tableKey of columnMetadataMissingTables) missingTables.add(tableKey);
+      if (runId !== semanticDiagnosticRunId) return;
+
+      const enrichedAnalysis: SqlReferenceAnalysis = { ...semanticAnalysis, tables };
+      nextDiagnostics.push(
+        ...offsetSqlSemanticDiagnostics(
+          buildSqlSemanticDiagnostics(enrichedAnalysis, {
+            tables: cachedTables,
+            columnsByTable: cachedColumnsByTable,
+            missingTables,
+            loadedColumnTables: loadedColumnsByTable,
+            sql: range.sql,
+          }),
+          range,
+          sql,
+        ),
+      );
+    } catch (error) {
+      if (runId !== semanticDiagnosticRunId) return;
+      const diagnostic = buildSqlParserErrorDiagnostic(error, range.sql);
+      if (diagnostic) nextDiagnostics.push(...offsetSqlSemanticDiagnostics([diagnostic], range, sql));
+    }
+  }
+  if (options.preserveOutsideRanges) {
+    replaceSemanticDiagnosticsInRanges(nextDiagnostics, diagnosticRanges, sql);
+  } else {
+    setSemanticDiagnostics(nextDiagnostics.sort(compareSqlSemanticDiagnostics));
+  }
+}
+
+function scheduleSemanticDiagnostics(delay = 500, options: { preserveOutsideRanges?: boolean } = {}) {
+  if (!editorIsActive) return;
+  if (shouldSkipSqlSemanticDiagnostics()) {
+    clearScheduledSemanticDiagnostics();
+    setSemanticDiagnostics([]);
+    return;
+  }
+  pendingSemanticDiagnosticPreserveOutsideRanges = !!options.preserveOutsideRanges;
+  if (semanticDiagnosticTimer) clearTimeout(semanticDiagnosticTimer);
+  semanticDiagnosticTimer = setTimeout(() => {
+    const preserveOutsideRanges = pendingSemanticDiagnosticPreserveOutsideRanges;
+    pendingSemanticDiagnosticPreserveOutsideRanges = false;
+    semanticDiagnosticTimer = null;
+    void refreshSemanticDiagnostics({ preserveOutsideRanges });
+  }, delay);
+}
+
+async function formatCurrentSql() {
+  if (props.readOnly) return;
+  const currentView = view.value;
+  if (!currentView) return;
+
+  const originalState = currentView.state;
+  const selection = originalState.selection.main;
+  const formatsSelection = !selection.empty;
+  const from = formatsSelection ? selection.from : 0;
+  const to = formatsSelection ? selection.to : originalState.doc.length;
+  const source = originalState.sliceDoc(from, to);
+  if (!source.trim()) return;
+
+  try {
+    const formatted = props.databaseType === "mongodb" ? formatMongoShellText(source, settingsStore.editorSettings.sqlFormatter) : await formatSqlText(source, props.formatDialect ?? props.dialect ?? "generic", settingsStore.editorSettings.sqlFormatter);
+    if (view.value !== currentView || currentView.state !== originalState || currentView.state.sliceDoc(from, to) !== source) {
+      return;
+    }
+    if (formatted === source) return;
+    currentView.dispatch({
+      changes: { from, to, insert: formatted },
+      selection: formatsSelection ? { anchor: from, head: from + formatted.length } : { anchor: from + formatted.length },
+    });
+  } catch (e: any) {
+    emit("formatError", String(e?.message || e));
+  }
+}
+
+function droppedTableReference(event: DragEvent) {
+  return activeTableReferencePayloadValue() ?? parseTableReferencePayload(event.dataTransfer?.getData(DBX_TABLE_REFERENCE_MIME));
+}
+
+function hasDroppedTableReference(event: DragEvent) {
+  return !!activeTableReferencePayloadValue() || hasTableReferencePayloadType(event.dataTransfer?.types);
+}
+
+function insertTableReferencePayload(currentView: EditorViewType, payload: QueryEditorTableReferencePayload, coords?: { clientX: number; clientY: number }): boolean {
+  if (props.readOnly) return false;
+  const insertText = tableReferenceInsertText(payload, props.databaseType);
+  const dropPos = coords ? currentView.posAtCoords({ x: coords.clientX, y: coords.clientY }) : null;
+  const selection = currentView.state.selection.main;
+  const from = dropPos ?? selection.from;
+  const to = dropPos == null && !selection.empty ? selection.to : from;
+  currentView.dispatch({
+    changes: { from, to, insert: insertText },
+    selection: { anchor: from + insertText.length },
+    scrollIntoView: true,
+    userEvent: "input.drop",
+  });
+  clearActiveTableReferencePayload(payload);
+  currentView.focus();
+  return true;
+}
+
+function insertDroppedTableReference(currentView: EditorViewType, event: DragEvent): boolean {
+  const payload = droppedTableReference(event);
+  if (!payload) return false;
+
+  event.preventDefault();
+  event.stopPropagation();
+  return insertTableReferencePayload(currentView, payload, { clientX: event.clientX, clientY: event.clientY });
+}
+
+function onTableReferenceDropEvent(event: Event) {
+  const currentView = view.value;
+  if (!currentView || props.readOnly || !(event instanceof CustomEvent)) return;
+  const detail = event.detail as QueryEditorTableReferenceDropDetail | undefined;
+  if (!detail?.payload) return;
+  const target = document.elementFromPoint(detail.clientX, detail.clientY);
+  if (target instanceof Element && editorRef.value?.contains(target)) {
+    insertTableReferencePayload(currentView, detail.payload, detail);
+  }
+}
+
+function registerTableReferenceDropListener() {
+  if (tableReferenceDropListenerRegistered) return;
+  window.addEventListener(DBX_TABLE_REFERENCE_DROP_EVENT, onTableReferenceDropEvent);
+  tableReferenceDropListenerRegistered = true;
+}
+
+function unregisterTableReferenceDropListener() {
+  if (!tableReferenceDropListenerRegistered) return;
+  window.removeEventListener(DBX_TABLE_REFERENCE_DROP_EVENT, onTableReferenceDropEvent);
+  tableReferenceDropListenerRegistered = false;
+}
+
+let completionEpoch = 0;
+let completionDebounceTimer: ReturnType<typeof setTimeout> | null = null;
+let typedCompletionActivationUntil = 0;
+let suppressNextSqlCompletionAutoStartUntil = 0;
+
+type QueryCompletionItem = SqlCompletionItem | ElasticsearchCompletionItem | RedisCompletionItem | MongoCompletionItem;
+
+function markTypedCompletionActivation() {
+  typedCompletionActivationUntil = Date.now() + 500;
+}
+
+function isTypedCompletionActivation(explicit: boolean) {
+  return explicit && typedCompletionActivationUntil >= Date.now();
+}
+
+function markCompletionAccepted() {
+  suppressNextSqlCompletionAutoStartUntil = Date.now() + 750;
+  completionEpoch++;
+}
+
+function consumeSqlCompletionAutoStartSuppression() {
+  if (suppressNextSqlCompletionAutoStartUntil < Date.now()) {
+    suppressNextSqlCompletionAutoStartUntil = 0;
+    return false;
+  }
+  suppressNextSqlCompletionAutoStartUntil = 0;
+  return true;
+}
+
+function buildCompletionResult(items: QueryCompletionItem[], from: number, validFor?: RegExp) {
+  if (items.length === 0) return null;
+  return {
+    from,
+    filter: false,
+    options: items.map((item) => completionOptionForItem(item)),
+    validFor,
+  };
+}
+
+function mergeCompletionQualifierNames(primary: string[], secondary: string[]): string[] {
+  const seen = new Set<string>();
+  const merged: string[] = [];
+  for (const name of [...primary, ...secondary]) {
+    const key = name.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(name);
+  }
+  return merged;
+}
+
+function localCompletionDatabaseNames(completionContext: ReturnType<typeof getSqlCompletionContext>): string[] {
+  if (!supportsDatabaseQualifierCompletion() || !completionContext.suggestTables || completionContext.insertTable || !props.connectionId) return [];
+  return connectionStore.lookupLocalCompletionDatabases(props.connectionId, completionContext.qualifier || completionContext.prefix, MAX_COMPLETION_TABLES);
+}
+
+function completionOptionForItem(item: QueryCompletionItem) {
+  const record = () => {
+    recordCompletionSelection(item.label, item.type);
+  };
+  if ((item.type === "snippet" || item.type === "function") && item.apply) {
+    const completion = codeMirrorSnippetCompletion(item.apply, {
+      label: item.label,
+      type: item.type,
+      detail: item.detail,
+      info: item.info,
+      boost: item.boost,
+    });
+    const originalApply = completion.apply;
+    return {
+      ...completion,
+      apply(view: EditorViewType, completionItem: unknown, from: number, to: number) {
+        record();
+        markCompletionAccepted();
+        if (typeof originalApply === "function") {
+          originalApply(view, completionItem as never, from, to);
+        } else {
+          const insert = String(originalApply ?? item.label);
+          view.dispatch({
+            changes: { from, to, insert },
+            selection: { anchor: from + insert.length },
+          });
+        }
+      },
+    };
+  }
+  return {
+    label: item.label,
+    type: item.type,
+    detail: item.detail,
+    info: item.info,
+    boost: item.boost,
+    apply(view: EditorViewType, _completionItem: unknown, from: number, to: number) {
+      record();
+      markCompletionAccepted();
+      const insert = item.apply ?? item.label;
+      if (codeMirrorInsertCompletionText) {
+        view.dispatch(codeMirrorInsertCompletionText(view.state, insert, from, to));
+      } else {
+        view.dispatch({
+          changes: { from, to, insert },
+          selection: { anchor: from + insert.length },
+        });
+      }
+    },
+  };
+}
+
+async function provideElasticsearchCompletions(currentState: import("@codemirror/state").EditorState, position: number, explicit: boolean) {
+  if (!props.connectionId) return null;
+  const epoch = ++completionEpoch;
+  const fullDoc = currentState.doc.toString();
+  if (!explicit && !shouldAutoOpenElasticsearchCompletion(fullDoc, position)) return null;
+
+  const completionContext = getElasticsearchCompletionContext(fullDoc, position);
+  let indices: string[] = [];
+  if (props.database != null && completionContext.mode === "path") {
+    try {
+      indices = await connectionStore.listElasticsearchCompletionIndices(props.connectionId, props.database);
+    } catch {
+      indices = [];
+    }
+  }
+  if (epoch !== completionEpoch) return null;
+
+  const items = buildElasticsearchCompletionItemsFromContext(completionContext, { indices });
+  return buildCompletionResult(items, completionContext.from, getElasticsearchCompletionResultValidFor());
+}
+
+async function provideRedisCompletions(currentState: import("@codemirror/state").EditorState, position: number, explicit: boolean) {
+  if (!props.connectionId) return null;
+  const epoch = ++completionEpoch;
+  const fullDoc = currentState.doc.toString();
+  if (!explicit && !shouldAutoOpenRedisCompletion(fullDoc, position)) return null;
+
+  const completionContext = getRedisCompletionContext(fullDoc, position);
+  // Key-name completion needs a reliable db index; props.database may briefly be "" on
+  // the New Query path before the active db resolves, and only key-argument commands warrant it.
+  let keys: string[] = [];
+  if (completionContext.mode === "argument" && props.database && takesKeyArgument(completionContext.mainCommand)) {
+    try {
+      keys = await connectionStore.listRedisCompletionKeys(props.connectionId, props.database);
+    } catch {
+      keys = [];
+    }
+  }
+  if (epoch !== completionEpoch) return null;
+
+  const items = buildRedisCompletionItemsFromContext(completionContext, { keys });
+  if (items.length === 0) return null;
+  // Use the built-in filter (the default) so typing narrows the list and moves
+  // the selection synchronously. `filter: false` + `validFor` are mutually
+  // exclusive (the latter is ignored), which would leave the menu frozen while
+  // typing — hence we build the result here instead of via buildCompletionResult.
+  return {
+    from: completionContext.from,
+    options: items.map((item) => completionOptionForItem(item)),
+    validFor: getRedisCompletionResultValidFor(),
+  };
+}
+
+async function provideMongoCompletions(currentState: import("@codemirror/state").EditorState, position: number, explicit: boolean) {
+  if (!props.connectionId) return null;
+  const epoch = ++completionEpoch;
+  const fullDoc = currentState.doc.toString();
+  if (!explicit && !shouldAutoOpenMongoCompletion(fullDoc, position)) return null;
+
+  const completionContext = getMongoCompletionContext(fullDoc, position);
+  let collections: string[] = [];
+  let fields: Awaited<ReturnType<typeof connectionStore.listMongoCompletionFields>> = [];
+
+  if (props.database && completionContext.mode === "collection") {
+    try {
+      collections = await connectionStore.listMongoCompletionCollections(props.connectionId, props.database);
+    } catch {
+      collections = [];
+    }
+  }
+
+  if (props.database && completionContext.mode === "field" && completionContext.collection) {
+    try {
+      fields = await connectionStore.listMongoCompletionFields(props.connectionId, props.database, completionContext.collection);
+    } catch {
+      fields = [];
+    }
+  }
+
+  if (epoch !== completionEpoch) return null;
+
+  const items = buildMongoCompletionItemsFromContext(completionContext, { collections, fields });
+  if (items.length === 0) return null;
+  return {
+    from: completionContext.from,
+    options: items.map((item) => completionOptionForItem(item)),
+    validFor: getMongoCompletionResultValidFor(),
+  };
+}
+
+async function provideSqlCompletions(context: CompletionContext) {
+  const currentState = context.state;
+  const position = context.pos;
+  const explicit = context.explicit;
+  const typedActivation = isTypedCompletionActivation(explicit);
+  if (imeCompositionActive || view.value?.compositionStarted || view.value?.composing) return null;
+  if (!props.connectionId) return null;
+  const fullDoc = currentState.doc.toString();
+  if (props.databaseType === "mongodb") {
+    return provideMongoCompletions(currentState, position, explicit);
+  }
+  if (props.databaseType === "elasticsearch") {
+    if (!isSqlLikeCompletionStatement(fullDoc, position)) {
+      return provideElasticsearchCompletions(currentState, position, explicit);
+    }
+  }
+  if (props.databaseType === "redis") {
+    return provideRedisCompletions(currentState, position, explicit);
+  }
+  const hasDatabase = props.database != null;
+
+  const epoch = ++completionEpoch;
+
+  try {
+    if (isSqlCompletionSuppressedContext(fullDoc, position)) return null;
+    if (!explicit && !shouldAutoOpenSqlCompletion(fullDoc, position)) return null;
+
+    const legacyCompletionContext = getSqlCompletionContext(fullDoc, position);
+    const semanticModel = SEMANTIC_SQL_COMPLETION_ENABLED ? buildSqlSemanticModel(fullDoc, position, { databaseType: props.databaseType, dialect: props.dialect }) : null;
+    const completionContext = semanticModel ? sqlCompletionContextFromSemantic(semanticModel, legacyCompletionContext) : legacyCompletionContext;
+
+    if (!hasDatabase) {
+      const items = buildSqlCompletionItemsFromContext(completionContext, {
+        tables: [],
+        objects: [],
+        columnsByTable: new Map(),
+        schemas: [],
+        translations: completionTranslations.value,
+        snippets: settingsStore.editorSettings.snippets,
+        dialect: props.dialect,
+        databaseType: props.databaseType,
+        keywordCase: settingsStore.editorSettings.sqlFormatter.keywordCase,
+        autoAliasTables: settingsStore.editorSettings.autoAliasTables,
+      });
+      return buildCompletionResult(items, position - completionContext.prefix.length, getSqlCompletionResultValidFor(fullDoc, position));
+    }
+
+    const needsAsyncData =
+      completionContext.suggestTables || completionContext.suggestRoutines || completionContext.exclusiveRoutineSuggestions || !!completionContext.qualifier || !!completionContext.insertTable || completionContext.exclusiveColumnSuggestions || completionContext.referencedTables.length > 0;
+
+    if (!needsAsyncData) {
+      const items = buildSqlCompletionItemsFromContext(completionContext, {
+        tables: [],
+        objects: [],
+        columnsByTable: new Map(),
+        schemas: [],
+        translations: completionTranslations.value,
+        snippets: settingsStore.editorSettings.snippets,
+        dialect: props.dialect,
+        databaseType: props.databaseType,
+        keywordCase: settingsStore.editorSettings.sqlFormatter.keywordCase,
+        autoAliasTables: settingsStore.editorSettings.autoAliasTables,
+      });
+      return buildCompletionResult(items, position - completionContext.prefix.length, getSqlCompletionResultValidFor(fullDoc, position));
+    }
+
+    const tableNameCompletion = isTableNameCompletionContext(completionContext);
+    const shouldResolveColumnCompletion = completionContext.suggestColumns && completionContext.referencedTables.length > 0 && (completionContext.prefix.length > 0 || typedActivation);
+    const shouldResolveAsyncCompletion = tableNameCompletion || shouldResolveColumnCompletion;
+    const localResult = buildLocalSqlCompletionResult(completionContext, fullDoc, position);
+    if (localResult) {
+      scheduleCompletionMetadataRefresh(completionContext);
+      const hasLocalColumnResult = localResult.options.some((option) => option.type === "column");
+      if ((!explicit || typedActivation) && (!shouldResolveColumnCompletion || hasLocalColumnResult)) return localResult;
+    }
+    if ((!explicit || typedActivation) && !shouldResolveAsyncCompletion) {
+      scheduleCompletionMetadataRefresh(completionContext);
+      return null;
+    }
+
+    // Cancel any pending debounced completion
+    if (completionDebounceTimer) {
+      clearTimeout(completionDebounceTimer);
+      completionDebounceTimer = null;
+    }
+
+    // Debounce the full async flow and return the promise to CodeMirror.
+    // This prevents wasted backend calls during rapid typing while still
+    // showing table/column names in the first popup.
+    return new Promise<ReturnType<typeof buildCompletionResult>>((resolve) => {
+      context.addEventListener("abort", () => {
+        if (epoch === completionEpoch) completionEpoch++;
+      });
+      completionDebounceTimer = setTimeout(async () => {
+        completionDebounceTimer = null;
+        if (epoch !== completionEpoch) {
+          resolve(null);
+          return;
+        }
+        try {
+          const result = await performAsyncCompletionWithResult(epoch, completionContext, fullDoc, position);
+          resolve(result ?? localResult);
+        } catch {
+          resolve(localResult);
+        }
+      }, 150);
+    });
+  } catch {
+    return null;
+  }
+}
+
+function isEditorComposing(currentView: EditorViewType): boolean {
+  return imeCompositionActive || currentView.compositionStarted || currentView.composing;
+}
+
+function scheduleSqlCompletionStart(currentView: EditorViewType) {
+  window.setTimeout(() => {
+    if (!codeMirrorStartCompletion || isEditorComposing(currentView)) return;
+    markTypedCompletionActivation();
+    codeMirrorStartCompletion(currentView);
+  }, 0);
+}
+
+function flushImeComposition() {
+  const currentView = view.value;
+  if (!currentView || !pendingImeModelEmit) return;
+  pendingImeModelEmit = false;
+  emit("update:modelValue", currentView.state.doc.toString());
+  invalidateSemanticDiagnosticsForDocumentChange();
+  scheduleSemanticDiagnostics();
+  syncContextMenuState(currentView);
+  emit("selectionChange", selectedSqlFromView(currentView));
+  emit("cursorChange", currentView.state.selection.main.head);
+  latestSelection = readEditorSelection(currentView);
+  if (editorIsActive) emitEditorSelection(latestSelection);
+  if (shouldAutoOpenSqlCompletion(currentView.state.doc.toString(), currentView.state.selection.main.head)) {
+    scheduleSqlCompletionStart(currentView);
+  }
+}
+
+function shouldStartSqlCompletionAfterInput(insertedText: string, removedText: string, currentView: EditorViewType): boolean {
+  const position = currentView.state.selection.main.head;
+  const fullDoc = currentView.state.doc.toString();
+  if (!insertedText && removedText) {
+    const completionContext = getSqlCompletionContext(fullDoc, position);
+    return isTableNameCompletionContext(completionContext) && shouldAutoOpenSqlCompletion(fullDoc, position);
+  }
+  if (insertedText.endsWith(".")) return true;
+  if (/[,(]$/.test(insertedText)) {
+    const completionContext = getSqlCompletionContext(fullDoc, position);
+    return !!completionContext.insertTable;
+  }
+  if (/\s$/.test(insertedText)) {
+    return shouldAutoOpenSqlCompletion(fullDoc, position);
+  }
+  if (!/[\w$@]$/.test(insertedText)) return false;
+  const completionContext = getSqlCompletionContext(fullDoc, position);
+  return isTableNameCompletionContext(completionContext) || shouldAutoOpenSqlCompletion(fullDoc, position);
+}
+
+function buildLocalSqlCompletionResult(completionContext: ReturnType<typeof getSqlCompletionContext>, fullDoc: string, position: number) {
+  if (!props.connectionId || props.database == null) return null;
+  const databaseNames = localCompletionDatabaseNames(completionContext);
+  const shouldLoadTables = completionContext.suggestTables || (!!completionContext.qualifier && !isReferencedTableQualifier(completionContext));
+  const tableLookupTarget = resolveSqlCompletionTableLookupTarget({
+    currentDatabase: props.database,
+    currentSchema: props.schema,
+    supportsDatabaseQualifier: supportsDatabaseQualifierCompletion(),
+    completionContext,
+    knownDatabases: databaseNames,
+  });
+  const tables = shouldLoadTables ? connectionStore.lookupLocalCompletionTables(props.connectionId, tableLookupTarget.database, tableLookupTarget.filter, MAX_COMPLETION_TABLES, tableLookupTarget.schema) : cachedTables;
+
+  const shouldLoadObjects = completionContext.suggestRoutines || completionContext.exclusiveRoutineSuggestions || (!!completionContext.qualifier && !completionContext.exclusiveColumnSuggestions);
+  const completionObjects = shouldLoadObjects
+    ? connectionStore.lookupLocalCompletionObjects(props.connectionId, props.database, completionContext.qualifier || completionContext.prefix, MAX_COMPLETION_TABLES, completionContext.qualifier && !completionContext.exclusiveColumnSuggestions ? completionContext.qualifier : props.schema)
+    : cachedCompletionObjects;
+
+  const schemaNames =
+    completionContext.suggestTables && !completionContext.qualifier && !completionContext.insertTable ? mergeCompletionQualifierNames(connectionStore.lookupLocalCompletionSchemas(props.connectionId, props.database, completionContext.prefix, MAX_COMPLETION_TABLES), databaseNames) : [];
+
+  const columnsByTable = new Map<string, SqlCompletionColumn[]>();
+  if (completionContext.insertTable) {
+    const insertSchema = completionContext.insertSchema ?? props.schema;
+    const insertColumns = connectionStore.lookupLocalCompletionColumns(props.connectionId, props.database, completionContext.insertTable, insertSchema);
+    if (insertColumns.length > 0) {
+      columnsByTable.set(insertSchema ? `${insertSchema}.${completionContext.insertTable}` : completionContext.insertTable, insertColumns);
+    }
+  }
+
+  const qualifiedColumnTarget = completionQualifiedTableTarget(completionContext);
+  if (qualifiedColumnTarget) {
+    const cacheKey = completionCacheKey(qualifiedColumnTarget);
+    const cached = cachedColumnsByTable.get(cacheKey);
+    if (cached) {
+      columnsByTable.set(cacheKey, cached);
+    } else {
+      const target = completionMetadataTarget(qualifiedColumnTarget);
+      const localColumns = target ? connectionStore.lookupLocalCompletionColumns(props.connectionId, target.database, qualifiedColumnTarget.name, target.schema) : [];
+      if (localColumns.length > 0) {
+        columnsByTable.set(cacheKey, localColumns);
+      }
+    }
+  }
+
+  const cteDefs = extractCteDefinitions(fullDoc);
+  for (const refTable of completionContext.referencedTables) {
+    const cteDef = cteDefs.find((c) => c.name.toLowerCase() === refTable.name.toLowerCase());
+    if (cteDef) {
+      columnsByTable.set(
+        refTable.name,
+        cteDef.columns.map((name) => ({ name, table: refTable.name, dataType: undefined })),
+      );
+      continue;
+    }
+    const cacheKey = refTable.schema ? `${refTable.schema}.${refTable.name}` : refTable.name;
+    const cached = cachedColumnsByTable.get(cacheKey);
+    if (cached) {
+      columnsByTable.set(cacheKey, cached);
+      continue;
+    }
+    const target = completionMetadataTarget(refTable);
+    const localColumns = target ? connectionStore.lookupLocalCompletionColumns(props.connectionId, target.database, refTable.name, target.schema) : [];
+    if (localColumns.length > 0) {
+      columnsByTable.set(cacheKey, localColumns);
+    }
+    const localForeignKeys = target ? connectionStore.lookupLocalCompletionForeignKeys(props.connectionId, target.database, refTable.name, target.schema) : [];
+    if (localForeignKeys.length > 0) {
+      cachedForeignKeysByTable.set(cacheKey, localForeignKeys);
+    }
+  }
+
+  if (tables.length === 0 && completionObjects.length === 0 && schemaNames.length === 0 && columnsByTable.size === 0 && (completionContext.exclusiveTableSuggestions || completionContext.exclusiveColumnSuggestions || completionContext.exclusiveRoutineSuggestions)) {
+    return null;
+  }
+
+  const items = buildSqlCompletionItemsFromContext(completionContext, {
+    tables,
+    objects: completionObjects,
+    columnsByTable,
+    foreignKeysByTable: cachedForeignKeysByTable,
+    schemas: schemaNames,
+    translations: completionTranslations.value,
+    snippets: settingsStore.editorSettings.snippets,
+    dialect: props.dialect,
+    databaseType: props.databaseType,
+    keywordCase: settingsStore.editorSettings.sqlFormatter.keywordCase,
+    autoAliasTables: settingsStore.editorSettings.autoAliasTables,
+  });
+
+  return buildCompletionResult(items, position - completionContext.prefix.length, getSqlCompletionResultValidFor(fullDoc, position));
+}
+
+function scheduleCompletionMetadataRefresh(completionContext: ReturnType<typeof getSqlCompletionContext>) {
+  if (!props.connectionId || props.database == null) return;
+  const localOnlyMetadata = usesLocalOnlyCompletionMetadata();
+  const onDemandOnlyColumns = usesOnDemandOnlyCompletionColumns();
+  const tableNameCompletion = isTableNameCompletionContext(completionContext);
+  const connectionId = props.connectionId;
+  const database = props.database;
+  const tableLookupTarget = resolveSqlCompletionTableLookupTarget({
+    currentDatabase: database,
+    currentSchema: props.schema,
+    supportsDatabaseQualifier: supportsDatabaseQualifierCompletion(),
+    completionContext,
+    knownDatabases: localCompletionDatabaseNames(completionContext),
+  });
+  if (!localOnlyMetadata && (completionContext.suggestTables || (!!completionContext.qualifier && !isReferencedTableQualifier(completionContext)))) {
+    void connectionStore
+      .refreshCompletionTables(connectionId, tableLookupTarget.database, tableLookupTarget.filter, MAX_COMPLETION_TABLES, tableLookupTarget.schema)
+      .then((tables) => {
+        cachedTables = mergeCompletionTables(cachedTables, tables);
+        if (completionContext.suggestTables && completionContext.referencedTables.length > 0) {
+          void ensureForeignKeysForTables([...completionContext.referencedTables, ...tables.slice(0, MAX_JOIN_FK_PREFETCH_TABLES)]);
+        }
+      })
+      .catch(() => {});
+  }
+  if (!localOnlyMetadata && (completionContext.suggestRoutines || completionContext.exclusiveRoutineSuggestions || (!!completionContext.qualifier && !completionContext.exclusiveColumnSuggestions))) {
+    void connectionStore
+      .refreshCompletionObjects(connectionId, database, completionContext.prefix, MAX_COMPLETION_TABLES, props.schema)
+      .then((objects) => {
+        cachedCompletionObjects = mergeCompletionObjects(cachedCompletionObjects, objects);
+      })
+      .catch(() => {});
+  }
+  if (!localOnlyMetadata && completionContext.suggestTables && !completionContext.qualifier && !completionContext.insertTable) {
+    void connectionStore.refreshCompletionSchemas(connectionId, database).catch(() => {});
+    if (supportsDatabaseQualifierCompletion()) {
+      void connectionStore.refreshCompletionDatabases(connectionId).catch(() => {});
+    }
+  }
+  if (!onDemandOnlyColumns && completionContext.insertTable) {
+    const insertTable = completionContext.insertTable;
+    void connectionStore
+      .refreshCompletionColumns(connectionId, database, insertTable, completionContext.insertSchema ?? props.schema)
+      .then((columns) => {
+        const insertSchema = completionContext.insertSchema ?? props.schema;
+        cachedColumnsByTable.set(insertSchema ? `${insertSchema}.${insertTable}` : insertTable, columns);
+      })
+      .catch(() => {});
+  }
+  const qualifiedColumnTarget = completionQualifiedTableTarget(completionContext);
+  const qualifiedColumnCacheKey = qualifiedColumnTarget ? completionCacheKey(qualifiedColumnTarget) : undefined;
+  if (!onDemandOnlyColumns && qualifiedColumnTarget && qualifiedColumnCacheKey && !cachedColumnsByTable.has(qualifiedColumnCacheKey)) {
+    const target = completionMetadataTarget(qualifiedColumnTarget);
+    if (target) {
+      void connectionStore
+        .refreshCompletionColumns(connectionId, target.database, qualifiedColumnTarget.name, target.schema)
+        .then((columns) => {
+          if (columns.length > 0) cachedColumnsByTable.set(qualifiedColumnCacheKey, columns);
+        })
+        .catch(() => {});
+    }
+  }
+  if (!onDemandOnlyColumns && !tableNameCompletion) {
+    for (const refTable of completionContext.referencedTables) {
+      if (refTable.columns && refTable.columns.length > 0) continue;
+      const cacheKey = refTable.schema ? `${refTable.schema}.${refTable.name}` : refTable.name;
+      if (cacheKey === qualifiedColumnCacheKey) continue;
+      if (cachedColumnsByTable.has(cacheKey)) continue;
+      const target = completionMetadataTarget(refTable);
+      if (!target) continue;
+      void connectionStore
+        .refreshCompletionColumns(connectionId, target.database, refTable.name, target.schema)
+        .then((columns) => {
+          if (columns.length > 0) cachedColumnsByTable.set(cacheKey, columns);
+        })
+        .catch(() => {});
+    }
+  }
+  if (!tableNameCompletion && (completionContext.suggestTables || completionContext.suggestJoinConditions) && completionContext.referencedTables.length > 0) {
+    void ensureForeignKeysForTables(completionContext.referencedTables);
+  }
+}
+
+function mergeCompletionTables(existing: Array<{ name: string; schema?: string; type?: "table" | "view" }>, incoming: Array<{ name: string; schema?: string; type?: "table" | "view" }>) {
+  const merged = [...existing];
+  const seen = new Set(existing.map((table) => `${table.schema ?? ""}.${table.name}`.toLowerCase()));
+  for (const table of incoming) {
+    const key = `${table.schema ?? ""}.${table.name}`.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(table);
+  }
+  return merged;
+}
+
+function withCompletionLatencyBudget<T>(remote: Promise<T>, local: T): Promise<T> {
+  return Promise.race([remote, new Promise<T>((resolve) => setTimeout(() => resolve(local), COMPLETION_REMOTE_LATENCY_BUDGET_MS))]);
+}
+
+function listCompletionTablesWithLatencyBudget(connectionId: string, database: string, filter: string, limit: number, schema?: string): Promise<SqlCompletionTable[]> {
+  const local = connectionStore.lookupLocalCompletionTables(connectionId, database, filter, limit, schema);
+  const remote = connectionStore.listCompletionTables(connectionId, database, filter, limit, schema).then((tables) => {
+    cachedTables = mergeCompletionTables(cachedTables, tables);
+    return tables;
+  });
+  if (local.length === 0) return remote;
+  return withCompletionLatencyBudget(remote, local);
+}
+
+async function performAsyncCompletionWithResult(epoch: number, completionContext: ReturnType<typeof getSqlCompletionContext>, fullDoc: string, position: number) {
+  const localOnlyMetadata = usesLocalOnlyCompletionMetadata();
+  const onDemandOnlyColumns = usesOnDemandOnlyCompletionColumns();
+  // Handle INSERT column list: fetch columns for the target table
+  let insertColumnsByTable = new Map<string, SqlCompletionColumn[]>();
+  if (completionContext.insertTable) {
+    try {
+      const insertCols = await connectionStore.listCompletionColumns(props.connectionId!, props.database!, completionContext.insertTable, completionContext.insertSchema ?? props.schema);
+      if (epoch !== completionEpoch) return null;
+      if (insertCols.length > 0) {
+        const insertSchema = completionContext.insertSchema ?? props.schema;
+        const insertKey = insertSchema ? `${insertSchema}.${completionContext.insertTable}` : completionContext.insertTable;
+        insertColumnsByTable.set(insertKey, insertCols);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  const shouldLoadTables = completionContext.suggestTables || (!!completionContext.qualifier && !isReferencedTableQualifier(completionContext));
+  let databaseNames = localCompletionDatabaseNames(completionContext);
+  if (!localOnlyMetadata && supportsDatabaseQualifierCompletion() && completionContext.suggestTables && !completionContext.insertTable && !completionContext.qualifier) {
+    try {
+      databaseNames = await connectionStore.listCompletionDatabases(props.connectionId!);
+      if (epoch !== completionEpoch) return null;
+    } catch {
+      databaseNames = [];
+    }
+  }
+  const tableLookupTarget = resolveSqlCompletionTableLookupTarget({
+    currentDatabase: props.database!,
+    currentSchema: props.schema,
+    supportsDatabaseQualifier: supportsDatabaseQualifierCompletion(),
+    completionContext,
+    knownDatabases: databaseNames,
+  });
+  let tables = shouldLoadTables
+    ? localOnlyMetadata
+      ? connectionStore.lookupLocalCompletionTables(props.connectionId!, tableLookupTarget.database, tableLookupTarget.filter, MAX_COMPLETION_TABLES, tableLookupTarget.schema)
+      : await listCompletionTablesWithLatencyBudget(props.connectionId!, tableLookupTarget.database, tableLookupTarget.filter, MAX_COMPLETION_TABLES, tableLookupTarget.schema)
+    : cachedTables;
+  if (epoch !== completionEpoch) return null;
+
+  const shouldLoadObjects = completionContext.suggestRoutines || completionContext.exclusiveRoutineSuggestions || (!!completionContext.qualifier && !completionContext.exclusiveColumnSuggestions);
+  let completionObjects = shouldLoadObjects
+    ? localOnlyMetadata
+      ? connectionStore.lookupLocalCompletionObjects(props.connectionId!, props.database!, completionContext.qualifier || completionContext.prefix, MAX_COMPLETION_TABLES, props.schema)
+      : await connectionStore.listCompletionObjects(props.connectionId!, props.database!, completionContext.qualifier || completionContext.prefix, MAX_COMPLETION_TABLES, props.schema)
+    : cachedCompletionObjects;
+  if (epoch !== completionEpoch) return null;
+
+  if (!localOnlyMetadata && completionContext.qualifier && completionObjects.length === 0) {
+    const schemaObjects = await connectionStore.listCompletionObjects(props.connectionId!, props.database!, completionContext.prefix, MAX_COMPLETION_TABLES, completionContext.qualifier);
+    if (schemaObjects.length > 0) {
+      completionObjects = schemaObjects;
+    }
+    if (epoch !== completionEpoch) return null;
+  }
+  cachedCompletionObjects = mergeCompletionObjects(cachedCompletionObjects, completionObjects);
+
+  // Fetch schemas for schema completion
+  let schemaNames: string[] = [];
+  if (completionContext.suggestTables && !completionContext.qualifier && !completionContext.insertTable) {
+    if (localOnlyMetadata) {
+      schemaNames = mergeCompletionQualifierNames(connectionStore.lookupLocalCompletionSchemas(props.connectionId!, props.database!, completionContext.prefix, MAX_COMPLETION_TABLES), databaseNames);
+    } else {
+      try {
+        const schemas = await connectionStore.listCompletionSchemas(props.connectionId!, props.database!);
+        schemaNames = mergeCompletionQualifierNames(schemas, databaseNames);
+        if (epoch !== completionEpoch) return null;
+      } catch {
+        schemaNames = databaseNames;
+      }
+    }
+  }
+
+  // If qualifier didn't match any table names, try it as a schema name
+  let qualifierIsSchema = false;
+  if (completionContext.qualifier && !tableLookupTarget.qualifierDatabase && !isReferencedTableQualifier(completionContext) && tables.length === 0 && (completionContext.suggestTables || completionContext.exclusiveColumnSuggestions)) {
+    let schemaTables = connectionStore.lookupLocalCompletionTables(props.connectionId!, props.database!, completionContext.prefix, MAX_COMPLETION_TABLES, completionContext.qualifier);
+    if (!localOnlyMetadata) {
+      schemaTables = await listCompletionTablesWithLatencyBudget(props.connectionId!, props.database!, completionContext.prefix, MAX_COMPLETION_TABLES, completionContext.qualifier);
+    } else if (schemaTables.length === 0 && allowsOnDemandQualifiedTableCompletion(completionContext.prefix)) {
+      schemaTables = await listCompletionTablesWithLatencyBudget(props.connectionId!, props.database!, completionContext.prefix, PRESTO_ON_DEMAND_TABLE_COMPLETION_LIMIT, completionContext.qualifier);
+    }
+    if (schemaTables.length > 0) {
+      tables = schemaTables;
+      qualifierIsSchema = true;
+    }
+    if (epoch !== completionEpoch) return null;
+  }
+
+  // Collect referenced tables — enrich with schema from filtered table lookup
+  let refs = completionContext.referencedTables.map((rt) => {
+    if (!rt.schema) {
+      const cached = tables.find((t) => t.name.toLowerCase() === rt.name.toLowerCase());
+      if (cached && cached.schema) {
+        return { ...rt, schema: cached.schema };
+      }
+    }
+    return rt;
+  });
+  const unresolvedRefs = refs.filter((rt) => !rt.schema && !rt.columns);
+  if (!localOnlyMetadata && unresolvedRefs.length > 0) {
+    const lookupGroups = await Promise.all(unresolvedRefs.map((rt) => connectionStore.listCompletionTables(props.connectionId!, props.database!, rt.name, 20, props.schema)));
+    if (epoch !== completionEpoch) return null;
+    const lookupTables = lookupGroups.flat();
+    refs = refs.map((rt) => {
+      if (rt.schema || rt.columns) return rt;
+      const matched = lookupTables.find((table) => table.name.toLowerCase() === rt.name.toLowerCase());
+      return matched?.schema ? { ...rt, schema: matched.schema } : rt;
+    });
+  }
+
+  // If no referenced tables but qualifier exists, infer table from tables list
+  if (refs.length === 0 && completionContext.qualifier) {
+    const q = completionContext.qualifier.toLowerCase();
+    const matched = tables.filter((t) => t.name.toLowerCase() === q || t.name.toLowerCase().endsWith("." + q));
+    refs = matched.map((t) => ({ name: t.name, schema: t.schema }));
+  }
+
+  const qualifiedColumnTarget = completionQualifiedTableTarget(completionContext);
+  if (qualifiedColumnTarget && !refs.some((ref) => completionTablesMatch(ref, qualifiedColumnTarget))) {
+    refs.push(qualifiedColumnTarget);
+  }
+
+  // Populate CTE columns from parsed definitions
+  const cteDefs = extractCteDefinitions(fullDoc);
+  for (const refTable of refs) {
+    if (refTable.columns) continue;
+    const cteDef = cteDefs.find((c) => c.name.toLowerCase() === refTable.name.toLowerCase());
+    if (cteDef) {
+      refTable.columns = cteDef.columns;
+    }
+  }
+
+  const tableNameCompletion = isTableNameCompletionContext(completionContext);
+  const shouldFetchColumnsForCompletion = !tableNameCompletion && (!onDemandOnlyColumns || completionContext.suggestColumns || completionContext.exclusiveColumnSuggestions || !!completionContext.insertTable);
+  if (shouldFetchColumnsForCompletion) {
+    await Promise.all(
+      refs.map(async (refTable) => {
+        if (refTable.columns && refTable.columns.length > 0) return;
+        const cacheKey = refTable.schema ? `${refTable.schema}.${refTable.name}` : refTable.name;
+        if (cachedColumnsByTable.has(cacheKey)) return;
+        try {
+          const target = completionMetadataTarget(refTable);
+          if (!target) return;
+          const columns = await connectionStore.listCompletionColumns(props.connectionId!, target.database, refTable.name, target.schema);
+          if (epoch !== completionEpoch) return;
+          if (columns.length === 0) return;
+          cachedColumnsByTable.set(cacheKey, columns);
+        } catch (e) {
+          console.error(`[DBX] Failed to load columns for ${cacheKey}:`, e);
+        }
+      }),
+    );
+  }
+  if (epoch !== completionEpoch) return null;
+
+  if (!tableNameCompletion && (completionContext.suggestTables || completionContext.suggestJoinConditions) && refs.length > 0) {
+    const fkPrefetchTables = completionContext.suggestTables ? [...refs, ...tables.slice(0, MAX_JOIN_FK_PREFETCH_TABLES)] : refs;
+    await ensureForeignKeysForTables(fkPrefetchTables.filter((table) => !("columns" in table) || !table.columns || table.columns.length === 0));
+    if (epoch !== completionEpoch) return null;
+  }
+
+  // Build columnsByTable — from cache or CTE definitions
+  const columnsByTable = new Map<string, SqlCompletionColumn[]>();
+  const foreignKeysByTable = new Map<string, SqlCompletionForeignKey[]>();
+  if (insertColumnsByTable.size > 0) {
+    for (const [key, cols] of insertColumnsByTable.entries()) {
+      columnsByTable.set(key, cols);
+    }
+  } else {
+    for (const refTable of refs) {
+      if (refTable.columns && refTable.columns.length > 0) {
+        const key = refTable.name;
+        columnsByTable.set(
+          key,
+          refTable.columns.map((name) => ({
+            name,
+            table: refTable.name,
+            dataType: undefined,
+          })),
+        );
+        continue;
+      }
+      const cacheKey = refTable.schema ? `${refTable.schema}.${refTable.name}` : refTable.name;
+      const cached = cachedColumnsByTable.get(cacheKey);
+      if (cached) {
+        columnsByTable.set(cacheKey, cached);
+      }
+      let cachedForeignKeys = cachedForeignKeysByTable.get(cacheKey);
+      if (!cachedForeignKeys) {
+        const target = completionMetadataTarget(refTable);
+        cachedForeignKeys = target ? connectionStore.lookupLocalCompletionForeignKeys(props.connectionId!, target.database, refTable.name, target.schema) : [];
+        if (cachedForeignKeys.length > 0) cachedForeignKeysByTable.set(cacheKey, cachedForeignKeys);
+      }
+      if (cachedForeignKeys) {
+        foreignKeysByTable.set(cacheKey, cachedForeignKeys);
+      }
+    }
+  }
+
+  const effectiveContext = qualifierIsSchema
+    ? {
+        ...completionContext,
+        qualifier: undefined,
+        suggestTables: true,
+        suggestColumns: false,
+        exclusiveColumnSuggestions: false,
+      }
+    : completionContext;
+
+  const items = buildSqlCompletionItemsFromContext(effectiveContext, {
+    tables,
+    objects: completionObjects,
+    columnsByTable,
+    foreignKeysByTable,
+    schemas: schemaNames,
+    translations: completionTranslations.value,
+    snippets: settingsStore.editorSettings.snippets,
+    dialect: props.dialect,
+    databaseType: props.databaseType,
+    keywordCase: settingsStore.editorSettings.sqlFormatter.keywordCase,
+    autoAliasTables: settingsStore.editorSettings.autoAliasTables,
+  });
+
+  return buildCompletionResult(items, position - completionContext.prefix.length, getSqlCompletionResultValidFor(fullDoc, position));
+}
+
+function isReferencedTableQualifier(completionContext: ReturnType<typeof getSqlCompletionContext>): boolean {
+  if (!completionContext.qualifier) return false;
+  const qualifier = completionContext.qualifier.toLowerCase();
+  const qualifiedColumnTarget = completionQualifiedTableTarget(completionContext);
+  return completionContext.referencedTables.some((table) => table.alias?.toLowerCase() === qualifier || table.name.toLowerCase() === qualifier || (!!qualifiedColumnTarget && completionTablesMatch(table, qualifiedColumnTarget)));
+}
+
+function isTableNameCompletionContext(completionContext: ReturnType<typeof getSqlCompletionContext>): boolean {
+  return completionContext.suggestTables || completionContext.exclusiveTableSuggestions;
+}
+
+function mergeCompletionObjects(existing: SqlCompletionObject[], incoming: SqlCompletionObject[]) {
+  const merged = [...existing];
+  const seen = new Set(existing.map((object) => `${object.type}:${object.schema ?? ""}:${object.name}:${object.parentName ?? ""}`.toLowerCase()));
+  for (const object of incoming) {
+    const key = `${object.type}:${object.schema ?? ""}:${object.name}:${object.parentName ?? ""}`.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(object);
+  }
+  return merged;
+}
+
+async function refreshCompletionCache() {
+  cachedTables = [];
+  cachedCompletionObjects = [];
+  cachedColumnsByTable.clear();
+  loadedColumnsByTable.clear();
+  cachedForeignKeysByTable.clear();
+}
+
+onMounted(async () => {
+  if (!editorRef.value) return;
+
+  const [
+    { EditorView, keymap, rectangularSelection, hoverTooltip, showTooltip, Decoration, tooltips, gutter, GutterMarker, lineNumbers, highlightActiveLineGutter, highlightSpecialChars, drawSelection, dropCursor, crosshairCursor, ViewPlugin },
+    { EditorState, EditorSelection, Compartment, Prec, StateEffect, StateField },
+    langSql,
+    { autocompletion, startCompletion, acceptCompletion, closeBrackets, closeBracketsKeymap, snippetCompletion, completionStatus, completionKeymap, insertCompletionText, nextSnippetField },
+    { copyLineDown, copyLineUp, deleteLine, indentLess, indentMore, insertNewlineKeepIndent, moveLineDown, moveLineUp, redo, selectAll, undo, toggleLineComment, history, defaultKeymap, historyKeymap },
+    { bracketMatching, foldGutter, indentOnInput, indentUnit, syntaxHighlighting, defaultHighlightStyle, foldKeymap },
+    { searchKeymap },
+  ] = await Promise.all([import("@codemirror/view"), import("@codemirror/state"), import("@codemirror/lang-sql"), import("@codemirror/autocomplete"), import("@codemirror/commands"), import("@codemirror/language"), import("@codemirror/search")]);
+  editorViewModule = { EditorView, keymap, rectangularSelection } as typeof import("@codemirror/view");
+  codeMirrorPrec = Prec;
+  codeMirrorEditorSelection = EditorSelection;
+  codeMirrorSnippetCompletion = snippetCompletion;
+  fontThemeComp = new Compartment();
+  codeMirrorTheme = new Compartment();
+  wordWrapComp = new Compartment();
+  vimModeComp = new Compartment();
+  closeBracketsComp = new Compartment();
+  codeMirrorCloseBrackets = closeBrackets;
+  codeMirrorCloseBracketsKeymap = closeBracketsKeymap;
+  readOnlyComp = new Compartment();
+  runGutterComp = new Compartment();
+  runKeymapComp = new Compartment();
+  completionComp = new Compartment();
+  diagnosticComp = new Compartment();
+  previewRangeComp = new Compartment();
+  indentComp = new Compartment();
+  setSqlDiagnosticsEffect = StateEffect.define<SqlSemanticDiagnostic[]>();
+  codeMirrorCompletionStatus = completionStatus;
+  codeMirrorAcceptCompletion = acceptCompletion;
+  codeMirrorStartCompletion = startCompletion;
+  codeMirrorInsertCompletionText = insertCompletionText;
+  codeMirrorNextSnippetField = nextSnippetField;
+  codeMirrorIndentMore = indentMore;
+  codeMirrorIndentLess = indentLess;
+  codeMirrorCopyLineDown = copyLineDown;
+  codeMirrorCopyLineUp = copyLineUp;
+  codeMirrorDeleteLine = deleteLine;
+  codeMirrorMoveLineUp = moveLineUp;
+  codeMirrorMoveLineDown = moveLineDown;
+  codeMirrorUndo = undo;
+  codeMirrorRedo = redo;
+  codeMirrorSelectAll = selectAll;
+  codeMirrorInsertNewlineKeepIndent = insertNewlineKeepIndent;
+  codeMirrorToggleLineComment = toggleLineComment;
+  codeMirrorIndentUnit = indentUnit;
+  window.addEventListener("keyup", clearTableNavigationHoverOnModifierRelease);
+  window.addEventListener("blur", clearTableNavigationHover);
+
+  const diagnosticTheme = EditorView.baseTheme({
+    ".cm-sql-error": {
+      textDecoration: "underline wavy var(--destructive)",
+      textUnderlineOffset: "3px",
+    },
+    ".cm-sql-semantic-warning": {
+      textDecoration: "underline wavy hsl(var(--warning, 38 92% 50%))",
+      textUnderlineOffset: "3px",
+    },
+  });
+
+  buildSqlDiagnosticExtension = () => {
+    const diagnosticEffect = setSqlDiagnosticsEffect;
+    const buildDecorations = (state: import("@codemirror/state").EditorState) => {
+      const errorDecorations = sqlErrorDecorationRange(state).map((range) =>
+        Decoration.mark({
+          class: "cm-sql-error",
+          attributes: { title: range.message },
+        }).range(range.from, range.to),
+      );
+      const semanticDecorations = sqlSemanticDecorationRanges(state).map((range) =>
+        Decoration.mark({
+          class: range.severity === "error" ? "cm-sql-error" : "cm-sql-semantic-warning",
+          attributes: { title: range.message },
+        }).range(range.from, range.to),
+      );
+      return Decoration.set([...errorDecorations, ...semanticDecorations], true);
+    };
+
+    const field = StateField.define({
+      create: buildDecorations,
+      update(value, transaction) {
+        const diagnosticsChanged = !!diagnosticEffect && transaction.effects.some((effect) => effect.is(diagnosticEffect));
+        if (diagnosticsChanged) return buildDecorations(transaction.state);
+        if (transaction.docChanged) return Decoration.set([]);
+        return value;
+      },
+      provide: (field) => EditorView.decorations.from(field),
+    });
+
+    return [field, diagnosticTheme];
+  };
+
+  setPreviewRangeEffect = StateEffect.define<{ from: number; to: number } | null>();
+  buildPreviewRangeExtension = () => {
+    const effectType = setPreviewRangeEffect!;
+    const field = StateField.define({
+      create() {
+        return Decoration.none;
+      },
+      update(decorations, transaction) {
+        for (const effect of transaction.effects) {
+          if (effect.is(effectType)) {
+            const range = effect.value;
+            if (!range) return Decoration.none;
+            return Decoration.set([Decoration.mark({ class: "cm-db-execution-preview" }).range(range.from, range.to)]);
+          }
+        }
+        return decorations;
+      },
+      provide: (f) => EditorView.decorations.from(f),
+    });
+    return field;
+  };
+
+  buildSqlSignatureExtension = () =>
+    showTooltip.compute(["doc", "selection"], (currentState) => {
+      const signature = getSqlFunctionSignatureHelp(currentState.doc.toString(), currentState.selection.main.head);
+      if (!signature) return null;
+      return {
+        pos: currentState.selection.main.head,
+        above: false,
+        clip: false,
+        create: () => ({ dom: createSignatureDom(signature) }),
+      };
+    });
+
+  buildSqlCompletionExtension = () =>
+    autocompletion({
+      activateOnTyping: true,
+      override: [async (context: CompletionContext) => provideSqlCompletions(context)],
+    });
+
+  const dialect = createDbxCodeMirrorSqlDialect(langSql, props.dialect);
+
+  const initialSettings = settingsStore.editorSettings;
+  const theme = await loadEditorTheme(initialSettings.theme, editorThemeAppearance(), getCurrentCustomThemeColors(), themePalette.value);
+  if (initialSettings.vimModeEnabled) {
+    await ensureCodeMirrorVim();
+  }
+
+  class RunStatementGutterMarker extends GutterMarker {
+    toDOM() {
+      return createRunStatementButtonDom("Execute statement");
+    }
+  }
+
+  const executableStatementMarker = new RunStatementGutterMarker();
+  buildRunStatementGutterExtension = () =>
+    settingsStore.editorSettings.showStatementRunButtons
+      ? gutter({
+          class: "cm-run-statement-gutter",
+          lineMarker(currentView, line) {
+            return executableStatementRangeStartingAt(currentView, line.from) ? executableStatementMarker : null;
+          },
+          domEventHandlers: {
+            mousedown: executeSqlStatementFromGutter,
+          },
+        })
+      : [];
+
+  const currentStatementFrameHighlighter = ViewPlugin.fromClass(
+    class {
+      decorations: import("@codemirror/view").DecorationSet;
+      constructor(view: import("@codemirror/view").EditorView) {
+        this.decorations = this.getDeco(view);
+      }
+      update(update: import("@codemirror/view").ViewUpdate) {
+        this.decorations = this.getDeco(update.view);
+      }
+      getDeco(view: import("@codemirror/view").EditorView) {
+        if (!settingsStore.editorSettings.showCurrentStatementFrame) return Decoration.none;
+        if (view.state.selection.ranges.some((range) => !range.empty)) return Decoration.none;
+        const range = currentExecutableStatementRange(view);
+        if (!range) return Decoration.none;
+
+        const startLine = view.state.doc.lineAt(range.from);
+        const frameTo = currentStatementFrameTo(view, range);
+        const endLine = view.state.doc.lineAt(Math.max(range.from, frameTo - 1));
+        let insertValueHints: Array<{ from: number; column: string }> = [];
+        try {
+          if (settingsStore.editorSettings.showInsertValueHints && props.databaseType !== "redis" && props.databaseType !== "mongodb" && props.databaseType !== "elasticsearch") {
+            insertValueHints = parseInsertValueHints(view.state.doc.sliceString(range.from, range.to), { resolveTableColumns: getInsertValueHintTableColumns }).map((hint) => ({
+              ...hint,
+              from: hint.from + range.from,
+            }));
+          }
+        } catch {
+          insertValueHints = [];
+        }
+        let maxWidth = 1;
+        for (let lineNumber = startLine.number; lineNumber <= endLine.number; lineNumber += 1) {
+          const line = view.state.doc.line(lineNumber);
+          const lineRangeTo = Math.min(line.to, frameTo);
+          maxWidth = Math.max(maxWidth, visualSqlColumnsWithInlineHints(view.state.doc.sliceString(line.from, lineRangeTo), line.from, lineRangeTo, insertValueHints));
+        }
+
+        const deco: any[] = [];
+        const frameWidth = `calc(${maxWidth}ch + 2ch)`;
+        for (let lineNumber = startLine.number; lineNumber <= endLine.number; lineNumber += 1) {
+          const line = view.state.doc.line(lineNumber);
+          const classes = ["cm-db-current-statement-line"];
+          if (lineNumber === startLine.number) classes.push("cm-db-current-statement-line--first");
+          if (lineNumber === endLine.number) classes.push("cm-db-current-statement-line--last");
+          deco.push(Decoration.line({ class: classes.join(" "), attributes: { style: `--dbx-current-statement-frame-width: ${frameWidth};` } }).range(line.from));
+        }
+        return Decoration.set(deco);
+      }
+    },
+    { decorations: (v) => v.decorations },
+  );
+
+  function currentStatementFrameTo(view: import("@codemirror/view").EditorView, range: SqlTextRange): number {
+    const nextChar = range.to < view.state.doc.length ? view.state.doc.sliceString(range.to, range.to + 1) : "";
+    return currentStatementFrameRangeTo(nextChar, range);
+  }
+
+  const activeLineHighlighter = ViewPlugin.fromClass(
+    class {
+      decorations: import("@codemirror/view").DecorationSet;
+      constructor(view: import("@codemirror/view").EditorView) {
+        this.decorations = this.getDeco(view);
+      }
+      update(update: import("@codemirror/view").ViewUpdate) {
+        if (update.docChanged || update.selectionSet) this.decorations = this.getDeco(update.view);
+      }
+      getDeco(view: import("@codemirror/view").EditorView) {
+        if (!view.state.selection.main.empty) return Decoration.none;
+        let lastLineStart = -1;
+        const deco: any[] = [];
+        for (const r of view.state.selection.ranges) {
+          if (!r.empty) continue;
+          const line = view.lineBlockAt(r.head);
+          if (line.from > lastLineStart) {
+            deco.push(Decoration.line({ class: "cm-activeLine" }).range(line.from));
+            lastLineStart = line.from;
+          }
+        }
+        return Decoration.set(deco);
+      }
+    },
+    { decorations: (v) => v.decorations },
+  );
+
+  const state = EditorState.create({
+    doc: props.modelValue,
+    selection: normalizedEditorSelection(props.initialSelection, props.modelValue.length),
+    extensions: [
+      cmSearch({
+        top: true,
+        createPanel: () => {
+          const dom = document.createElement("span");
+          dom.style.display = "none";
+          return { dom };
+        },
+      }),
+      runGutterComp.of(props.hideExecutionControls ? [] : buildRunStatementGutterExtension()),
+      lineNumbers({
+        domEventHandlers: {
+          mousedown: selectSqlLineFromGutter,
+        },
+      }),
+      currentStatementFrameHighlighter,
+      highlightActiveLineGutter(),
+      highlightSpecialChars(),
+      history(),
+      foldGutter({
+        markerDOM(open: boolean) {
+          const span = document.createElement("span");
+          span.className = "cm-foldMarker-svg";
+          span.innerHTML = open
+            ? '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16" fill="none"><path d="M4.5 6.5l3.5 3.5 3.5-3.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>'
+            : '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16" fill="none"><path d="M6.5 4.5l3.5 3.5-3.5 3.5" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>';
+          return span;
+        },
+      }),
+      drawSelection(),
+      trimmedSelectionLayer(),
+      selectionMatchOccurrences(),
+      dropCursor(),
+      EditorView.dragMovesSelection.of((event) => !event.ctrlKey && !event.metaKey),
+      EditorState.allowMultipleSelections.of(true),
+      indentOnInput(),
+      syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
+      crosshairCursor(),
+      activeLineHighlighter,
+      // Vim must be mounted before DBX/default keymaps so normal-mode keys are handled first.
+      vimModeComp.of(vimModeExtension(initialSettings.vimModeEnabled)),
+      keymap.of([...defaultKeymap, ...searchKeymap, ...historyKeymap, ...foldKeymap, ...completionKeymap]),
+      langSql.sql({ dialect }),
+      tooltips({ parent: document.body }),
+      completionComp.of(buildSqlCompletionExtension()),
+      sqlCompletionTheme(EditorView),
+      codeMirrorTheme.of(theme),
+      closeBracketsComp.of(closeBracketsExtension(initialSettings.autoCloseBrackets)),
+      bracketMatching(),
+      hoverTooltip((currentView, pos) => resolveSqlHoverTooltip(currentView, pos)),
+      buildSqlSignatureExtension(),
+      diagnosticComp.of(buildSqlDiagnosticExtension()),
+      createInsertValueHintsExtension({
+        isEnabled: () => settingsStore.editorSettings.showInsertValueHints && props.databaseType !== "redis" && props.databaseType !== "mongodb" && props.databaseType !== "elasticsearch",
+        getTableColumns: getInsertValueHintTableColumns,
+        requestTableColumns: requestInsertValueHintTableColumns,
+      }),
+      previewRangeComp.of(buildPreviewRangeExtension()),
+      Prec.highest(
+        keymap.of([
+          { key: "'", run: handleSqlSingleQuote },
+          { key: "Tab", run: handleTab },
+          {
+            key: "Escape",
+            run: () => {
+              return searchPanelRef.value?.closeSearch() ?? false;
+            },
+          },
+        ]),
+      ),
+      runKeymapComp.of(runKeymapExtension(keymap)),
+      wordWrapComp.of(props.forceWordWrap || initialSettings.wordWrap ? EditorView.lineWrapping : []),
+      readOnlyComp.of([EditorState.readOnly.of(!!props.readOnly), EditorView.editable.of(!props.readOnly)]),
+      indentComp.of(indentExtension()),
+      // Alt+drag belongs exclusively to rectangular selection. Registering the
+      // same gesture as an added cursor preserves the previous cursor.
+      rectangularSelection({ eventFilter: startsQueryEditorRectangularSelection }),
+      EditorView.updateListener.of((update) => {
+        if (update.docChanged) {
+          searchPanelRef.value?.scheduleDocumentSearchUpdate();
+          if (isEditorComposing(update.view)) {
+            pendingImeModelEmit = true;
+            completionEpoch++;
+          } else {
+            emit("update:modelValue", update.state.doc.toString());
+            invalidateSemanticDiagnosticsForDocumentChange();
+            scheduleSemanticDiagnostics();
+            let insertedText = "";
+            let removedText = "";
+            update.changes.iterChanges((fromA, toA, _fromB, _toB, inserted) => {
+              insertedText += inserted.toString();
+              removedText += update.startState.doc.sliceString(fromA, toA);
+            });
+            const suppressCompletionAutoStart = consumeSqlCompletionAutoStartSuppression();
+            if (!suppressCompletionAutoStart && shouldStartSqlCompletionAfterInput(insertedText, removedText, update.view)) {
+              scheduleSqlCompletionStart(update.view);
+            }
+          }
+        }
+        if (update.selectionSet || update.docChanged) {
+          syncContextMenuState(update.view);
+          emit("selectionChange", selectedSqlFromView(update.view));
+          emit("cursorChange", update.state.selection.main.head);
+          latestSelection = readEditorSelection(update.view);
+          if (editorIsActive) emitEditorSelection(latestSelection);
+        }
+      }),
+      fontThemeComp.of(
+        editorFontTheme(EditorView, liveFontSize.value, initialSettings.fontFamily, {
+          fixedHeight: true,
+          scrollable: true,
+        }),
+      ),
+      EditorView.domEventHandlers({
+        dragover(event) {
+          if (props.readOnly || !hasDroppedTableReference(event)) return false;
+          event.preventDefault();
+          if (event.dataTransfer) event.dataTransfer.dropEffect = "copy";
+          return true;
+        },
+        drop(event, currentView) {
+          return insertDroppedTableReference(currentView, event);
+        },
+        blur(_event, currentView) {
+          latestSelection = readEditorSelection(currentView);
+          if (editorIsActive) emitEditorSelection(latestSelection);
+          return false;
+        },
+        compositionstart() {
+          imeCompositionActive = true;
+          completionEpoch++;
+          return false;
+        },
+        compositionend() {
+          imeCompositionActive = false;
+          window.setTimeout(flushImeComposition, 0);
+          return false;
+        },
+        [DBX_VIM_SAVE_EVENT]() {
+          emit("save");
+          return true;
+        },
+        wheel(event) {
+          if (!event.metaKey && !event.ctrlKey) return false;
+          event.preventDefault();
+          const next = fontSizeFromWheelDelta(liveFontSize.value, event.deltaY);
+          applyLiveFontSize(next);
+          scheduleFontSizeCommit(next);
+          return true;
+        },
+        mousemove: (event: MouseEvent) => {
+          const currentView = view.value;
+          if (!currentView) return false;
+          updateTableNavigationHover(currentView, event);
+          return false;
+        },
+        mouseleave: () => {
+          clearTableNavigationHover();
+          return false;
+        },
+        mousedown: (event: MouseEvent) => {
+          clearTableNavigationHover();
+          const currentView = view.value;
+          if (currentView && startEditorSelectionDrag(currentView, event)) {
+            return true;
+          }
+          // Click without modifier -> close column panel
+          if (!event.metaKey && !event.ctrlKey) {
+            if (event.button === 0) {
+              emit("closeColumnPanel");
+            }
+            return false;
+          }
+          // Only handle Ctrl/Cmd + left click
+          if (event.button !== 0) return false;
+
+          if (!currentView || !props.connectionId || props.database == null) {
+            return false;
+          }
+
+          // Use posAtCoords for accurate click position
+          const coords = { x: event.clientX, y: event.clientY };
+          const pos = currentView.posAtCoords(coords);
+          if (pos == null) {
+            return false;
+          }
+
+          const doc = currentView.state.doc.toString();
+          const extracted = extractIdentifierDetailsAt(doc, pos);
+          if (!extracted) {
+            return false;
+          }
+          if (!extracted.quoted && isSqlKeyword(extracted.identifier)) {
+            return false;
+          }
+          const identifier = extracted.identifier;
+
+          // Prevent default, resolve async
+          event.preventDefault();
+          setTimeout(async () => {
+            try {
+              const identifierParts = splitQualifiedIdentifier(identifier);
+              const tableLookupFilter = identifierParts[identifierParts.length - 1] ?? identifier;
+
+              // Ensure table cache is populated
+              if (cachedTables.length === 0) {
+                // Some metadata providers only accept table-name masks, not schema.table masks.
+                cachedTables = usesLocalOnlyCompletionMetadata()
+                  ? connectionStore.lookupLocalCompletionTables(props.connectionId!, props.database!, tableLookupFilter, MAX_COMPLETION_TABLES, props.schema)
+                  : await connectionStore.listCompletionTables(props.connectionId!, props.database!, tableLookupFilter, MAX_COMPLETION_TABLES, props.schema);
+              }
+
+              // 1. Check if it's a table name
+              const matchedTable = matchTable(identifier, cachedTables);
+              if (matchedTable) {
+                emit("clickTable", matchedTable.schema ? `${matchedTable.schema}.${matchedTable.name}` : matchedTable.name);
+                return;
+              }
+
+              // 2. Parse SQL at click position to get referenced tables
+              const context = getSqlCompletionContext(doc, pos);
+              let referencedTables = context.referencedTables;
+              // Enrich referenced tables with schema from cachedTables
+              referencedTables = referencedTables.map((rt) => {
+                const cached = cachedTables.find((ct) => ct.name.toLowerCase() === rt.name.toLowerCase());
+                if (cached && cached.schema && !rt.schema) {
+                  return { ...rt, schema: cached.schema };
+                }
+                return rt;
+              });
+
+              // Check if identifier has a qualifier (e.g., c.card_name or schema.table)
+              const qualifier = identifierParts.length >= 2 ? identifierParts[identifierParts.length - 2] : null;
+
+              const matchedRef = matchTable(identifier, referencedTables);
+              if (matchedRef) {
+                emit("clickTable", matchedRef.schema ? `${matchedRef.schema}.${matchedRef.name}` : matchedRef.name);
+                return;
+              }
+              const colName = identifierParts[identifierParts.length - 1] ?? identifier;
+              const colLower = colName.toLowerCase();
+
+              if (referencedTables.length === 0) {
+                return;
+              }
+              // 3. Fetch columns — if qualifier, only check matching table; otherwise check all
+              const tablesToCheck = qualifier ? referencedTables.filter((rt) => rt.alias?.toLowerCase() === qualifier.toLowerCase() || rt.name.toLowerCase() === qualifier.toLowerCase()) : referencedTables;
+
+              if (tablesToCheck.length === 0 && qualifier) {
+                return;
+              }
+
+              const matchedCols: Array<{ name: string; table: string; schema?: string }> = [];
+
+              for (const refTable of tablesToCheck) {
+                const cacheKey = refTable.schema ? `${refTable.schema}.${refTable.name}` : refTable.name;
+
+                // Use persistent column cache; fetch only if missing
+                let cols = cachedColumnsByTable.get(cacheKey);
+                if (!cols) {
+                  try {
+                    cols = await connectionStore.listCompletionColumns(props.connectionId!, props.database!, refTable.name, refTable.schema ?? props.schema);
+                    cachedColumnsByTable.set(cacheKey, cols);
+                  } catch {
+                    continue;
+                  }
+                }
+                for (const col of cols) {
+                  if (col.name.toLowerCase() === colLower) {
+                    matchedCols.push({
+                      name: col.name,
+                      table: refTable.name,
+                      schema: col.schema || refTable.schema,
+                    });
+                  }
+                }
+              }
+
+              if (matchedCols.length > 0) {
+                emit("clickColumn", matchedCols);
+              }
+            } catch (e) {
+              console.error("[DBX] Ctrl+click error:", e);
+            }
+          }, 0);
+          return true;
+        },
+      }),
+    ],
+  });
+
+  view.value = new EditorView({ state, parent: editorRef.value });
+  registerEditorScrollbarPointerGuard(view.value);
+  view.value.scrollDOM.addEventListener("scroll", scheduleEditorViewportEmit, { passive: true });
+  restoreEditorViewport();
+  syncContextMenuState(view.value);
+  syncEditorFontCssVars(liveFontSize.value, initialSettings.fontFamily);
+  registerTableReferenceDropListener();
+
+  cachedTables = [];
+  cachedCompletionObjects = [];
+  scheduleSemanticDiagnostics();
+
+  // Ensure theme is applied with the latest settings after mount
+  void nextTick(async () => {
+    if (!view.value || !codeMirrorTheme) return;
+    const settings = settingsStore.editorSettings;
+    const themeColors = settings.theme === "custom" ? getCurrentCustomThemeColors() : settings.customThemeColors;
+    const themeExt = await loadEditorTheme(settings.theme, editorThemeAppearance(), themeColors, themePalette.value);
+    view.value.dispatch({
+      effects: [codeMirrorTheme.reconfigure(themeExt)],
+    });
+  });
+});
+
+watch(
+  () => props.modelValue,
+  (val) => {
+    if (view.value && val !== view.value.state.doc.toString()) {
+      if (isEditorComposing(view.value)) return;
+      view.value.dispatch({
+        changes: { from: 0, to: view.value.state.doc.length, insert: val },
+      });
+      scheduleSemanticDiagnostics();
+    }
+  },
+);
+
+watch(
+  () => props.formatRequestId,
+  (val, oldVal) => {
+    if (val && val !== oldVal) formatCurrentSql();
+  },
+);
+
+watch(
+  () => props.executionError,
+  () => {
+    reconfigureDiagnostics();
+  },
+);
+
+watch(
+  () => props.connectionId,
+  () => {
+    refreshCompletionCache();
+    setSemanticDiagnostics([]);
+    scheduleSemanticDiagnostics();
+  },
+);
+
+watch(
+  () => props.database,
+  () => {
+    refreshCompletionCache();
+    setSemanticDiagnostics([]);
+    scheduleSemanticDiagnostics();
+  },
+);
+
+watch(
+  () => props.schema,
+  () => {
+    refreshCompletionCache();
+    setSemanticDiagnostics([]);
+    scheduleSemanticDiagnostics();
+  },
+);
+
+watch(
+  () => props.databaseType,
+  () => {
+    executableStatementRangeCache = null;
+    view.value?.dispatch({});
+  },
+);
+
+watch(
+  () => props.forceWordWrap,
+  () => {
+    if (!view.value || !wordWrapComp) return;
+    view.value.dispatch({
+      effects: wordWrapComp.reconfigure(wordWrapExtension()),
+    });
+  },
+);
+
+// Derive current custom theme colors from settingsStore
+function getCurrentCustomThemeColors() {
+  const settings = settingsStore.editorSettings;
+  if (settings.theme !== "custom") return settings.customThemeColors;
+  const activeTheme = settings.customThemes?.find((t: { id: string }) => t.id === settings.activeCustomThemeId) || settings.customThemes?.[0];
+  return activeTheme?.colors ?? settings.customThemeColors;
+}
+
+// Reactively apply editor settings changes
+watch(
+  [queryEditorAppearanceSettings, () => isDark.value, () => themePalette.value],
+  async ([ss]) => {
+    if (!view.value || !codeMirrorTheme || !fontThemeComp || !wordWrapComp || !vimModeComp || !closeBracketsComp || !runGutterComp || !runKeymapComp || !editorViewModule) {
+      return;
+    }
+    if (!isGestureZooming.value && !zoomCommitScheduler.hasPendingCommit() && liveFontSize.value !== ss.fontSize) {
+      liveFontSize.value = ss.fontSize;
+    }
+    syncEditorFontCssVars(liveFontSize.value, ss.fontFamily);
+    const themeColors = getCurrentCustomThemeColors();
+    const [themeExt] = await Promise.all([loadEditorTheme(ss.theme, editorThemeAppearance(), themeColors, themePalette.value), ss.vimModeEnabled ? ensureCodeMirrorVim() : Promise.resolve(false)]);
+    if (!view.value || !codeMirrorTheme || !wordWrapComp || !vimModeComp || !closeBracketsComp || !runGutterComp || !runKeymapComp || !editorViewModule) {
+      return;
+    }
+    view.value.dispatch({
+      effects: [
+        codeMirrorTheme.reconfigure(themeExt),
+        wordWrapComp.reconfigure(props.forceWordWrap || ss.wordWrap ? editorViewModule.EditorView.lineWrapping : []),
+        vimModeComp.reconfigure(vimModeExtension(settingsStore.editorSettings.vimModeEnabled)),
+        closeBracketsComp.reconfigure(closeBracketsExtension(settingsStore.editorSettings.autoCloseBrackets)),
+        runGutterComp.reconfigure(props.hideExecutionControls ? [] : (buildRunStatementGutterExtension?.() ?? [])),
+        runKeymapComp.reconfigure(runKeymapExtension(editorViewModule.keymap)),
+      ],
+    });
+  },
+  { deep: true },
+);
+
+watch(
+  () => [settingsStore.editorSettings.sqlFormatter.tabWidth, settingsStore.editorSettings.sqlFormatter.useTabs],
+  () => {
+    if (!view.value || !indentComp) return;
+    view.value.dispatch({ effects: indentComp.reconfigure(indentExtension()) });
+  },
+);
+
+watch(
+  () => settingsStore.editorSettings.snippets,
+  () => {
+    completionEpoch++;
+    if (!view.value || !completionComp || !buildSqlCompletionExtension) return;
+    view.value.dispatch({
+      effects: completionComp.reconfigure(buildSqlCompletionExtension()),
+    });
+    if (codeMirrorCompletionStatus?.(view.value.state) === "active") {
+      codeMirrorStartCompletion?.(view.value);
+    }
+  },
+  { deep: true },
+);
+
+watch(
+  () => settingsStore.editorSettings.sqlSemanticDiagnosticsEnabled,
+  (enabled) => {
+    if (props.databaseType === "redis") return;
+    if (!shouldSkipSqlSemanticDiagnostics() && enabled) {
+      scheduleSemanticDiagnostics(0);
+      return;
+    }
+    clearScheduledSemanticDiagnostics();
+    setSemanticDiagnostics([]);
+  },
+);
+
+watch(
+  () => settingsStore.editorSettings.showInsertValueHints,
+  () => {
+    if (view.value) requestInsertValueHintsRefresh(view.value);
+  },
+);
+
+function pauseQueryEditorBackgroundWork() {
+  flushEditorViewport();
+  flushEditorSelection();
+  clearTableNavigationHover();
+  editorIsActive = false;
+  clearScheduledSemanticDiagnostics();
+  completionEpoch++;
+  unregisterTableReferenceDropListener();
+}
+
+function resumeQueryEditorBackgroundWork() {
+  editorIsActive = true;
+  registerTableReferenceDropListener();
+  scheduleSemanticDiagnostics();
+  restoreEditorSelection();
+  restoreEditorFocus();
+  restoreEditorViewport();
+}
+
+onActivated(resumeQueryEditorBackgroundWork);
+
+onDeactivated(pauseQueryEditorBackgroundWork);
+
+onBeforeUnmount(() => {
+  pauseQueryEditorBackgroundWork();
+  if (viewportEmitFrame !== null) {
+    cancelAnimationFrame(viewportEmitFrame);
+    viewportEmitFrame = null;
+  }
+  if (viewportRestoreFrame !== null) {
+    cancelAnimationFrame(viewportRestoreFrame);
+    viewportRestoreFrame = null;
+  }
+  editorScrollbarPointerCleanup?.();
+  editorSelectionDragCleanup?.();
+  view.value?.scrollDOM.removeEventListener("scroll", scheduleEditorViewportEmit);
+  window.removeEventListener("keyup", clearTableNavigationHoverOnModifierRelease);
+  window.removeEventListener("blur", clearTableNavigationHover);
+  zoomCommitScheduler.dispose();
+  view.value?.destroy();
+});
+
+function readEditorViewport(currentView: EditorViewType) {
+  return {
+    scrollTop: Math.max(0, currentView.scrollDOM.scrollTop),
+    scrollLeft: Math.max(0, currentView.scrollDOM.scrollLeft),
+  };
+}
+
+function sameEditorViewport(a: { scrollTop: number; scrollLeft: number } | undefined, b: { scrollTop: number; scrollLeft: number }) {
+  return a?.scrollTop === b.scrollTop && a.scrollLeft === b.scrollLeft;
+}
+
+function normalizedEditorSelection(selection: { anchor: number; head: number } | undefined, docLength: number) {
+  if (!selection) return undefined;
+  return {
+    anchor: Math.min(Math.max(0, selection.anchor), docLength),
+    head: Math.min(Math.max(0, selection.head), docLength),
+  };
+}
+
+function readEditorSelection(currentView: EditorViewType) {
+  const selection = currentView.state.selection.main;
+  return {
+    anchor: selection.anchor,
+    head: selection.head,
+  };
+}
+
+function emitEditorSelection(selection: { anchor: number; head: number }) {
+  emit("selectionStateChange", selection);
+}
+
+function flushEditorSelection() {
+  if (view.value) latestSelection = readEditorSelection(view.value);
+  if (latestSelection) emitEditorSelection(latestSelection);
+}
+
+function restoreEditorSelection() {
+  const selection = normalizedEditorSelection(props.initialSelection ?? latestSelection, props.modelValue.length);
+  if (!view.value || !selection) return;
+  view.value.dispatch({ selection });
+}
+
+function restoreEditorFocus() {
+  const focusEditorAcrossFrames = () => {
+    if (!view.value || view.value.hasFocus) return;
+    view.value.focus();
+  };
+  focusEditorAcrossFrames();
+  nextTick(() => {
+    focusEditorAcrossFrames();
+    requestAnimationFrame(focusEditorAcrossFrames);
+  });
+}
+
+function emitEditorViewport(viewport: { scrollTop: number; scrollLeft: number }) {
+  if (sameEditorViewport(lastEmittedViewport, viewport)) return;
+  lastEmittedViewport = { ...viewport };
+  emit("viewportChange", viewport);
+}
+
+function scheduleEditorViewportEmit() {
+  if (!view.value || !editorIsActive) return;
+  latestViewport = readEditorViewport(view.value);
+  scheduleSemanticDiagnostics(700, { preserveOutsideRanges: true });
+  if (viewportEmitFrame !== null) return;
+  viewportEmitFrame = requestAnimationFrame(() => {
+    viewportEmitFrame = null;
+    if (latestViewport) emitEditorViewport(latestViewport);
+  });
+}
+
+function flushEditorViewport() {
+  if (viewportEmitFrame !== null) {
+    cancelAnimationFrame(viewportEmitFrame);
+    viewportEmitFrame = null;
+  }
+  if (latestViewport) emitEditorViewport(latestViewport);
+}
+
+function restoreEditorViewport() {
+  const viewport = props.initialViewport ?? latestViewport;
+  if (!view.value || !viewport) return;
+  const restoreScroll = () => {
+    if (!view.value) return;
+    view.value.scrollDOM.scrollTo({
+      top: viewport.scrollTop,
+      left: viewport.scrollLeft,
+    });
+    view.value.scrollDOM.scrollTop = viewport.scrollTop;
+    view.value.scrollDOM.scrollLeft = viewport.scrollLeft;
+  };
+
+  if (viewportRestoreFrame !== null) cancelAnimationFrame(viewportRestoreFrame);
+  restoreScroll();
+  nextTick(() => {
+    restoreScroll();
+    let attempts = 0;
+    const restoreNextFrame = () => {
+      restoreScroll();
+      attempts += 1;
+      if (attempts >= 8) {
+        viewportRestoreFrame = null;
+        return;
+      }
+      viewportRestoreFrame = requestAnimationFrame(restoreNextFrame);
+    };
+    viewportRestoreFrame = requestAnimationFrame(restoreNextFrame);
+  });
+}
+
+function openSearch(): boolean {
+  return searchPanelRef.value?.openSearch() ?? false;
+}
+
+function openReplace(): boolean {
+  return searchPanelRef.value?.openReplace() ?? false;
+}
+
+function scrollCursorIntoView() {
+  if (!view.value || !editorViewModule || !editorIsActive) return;
+  const pos = view.value.state.selection.main.head;
+  view.value.dispatch({
+    effects: editorViewModule.EditorView.scrollIntoView(pos, { y: "nearest" }),
+  });
+}
+
+defineExpose({ openSearch, openReplace, scrollCursorIntoView, requestExecute, pasteClipboardAsSqlInCondition });
+</script>
+
+<template>
+  <div class="h-full w-full overflow-hidden relative" @gesturestart="onEditorGestureStart" @gesturechange="onEditorGestureChange" @gestureend="onEditorGestureEnd">
+    <CustomContextMenu :items="contextMenuItems" v-slot="{ onContextMenu }">
+      <div
+        ref="editorRef"
+        data-query-editor-root
+        class="h-full w-full overflow-hidden"
+        @contextmenu="
+          (e: MouseEvent) => {
+            if (view) syncContextMenuStateAtEvent(view, e);
+            onContextMenu(e);
+          }
+        "
+      />
+    </CustomContextMenu>
+    <EditorSearchPanel ref="searchPanelRef" :view="view" />
+    <SqlExecutionTargetPicker v-if="pickerVisible" :candidates="pickerCandidates" :active-index="pickerActiveIndex" :anchor="pickerAnchor" @update:active-index="onPickerActiveIndexChange" @confirm="onPickerConfirm" @cancel="closePicker" />
+  </div>
+</template>
+
+<style scoped>
+.query-editor--table-navigation-hover :deep(.cm-content),
+.query-editor--table-navigation-hover :deep(.cm-line) {
+  cursor: pointer;
+}
+
+:deep(.cm-db-execution-preview) {
+  background: var(--dbx-editor-selection-background, rgba(59, 130, 246, 0.35));
+}
+
+:deep(.cm-db-current-statement-line) {
+  position: relative;
+}
+
+:deep(.cm-db-current-statement-line::after) {
+  content: "";
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  left: 0;
+  box-sizing: border-box;
+  width: var(--dbx-current-statement-frame-width, 100%);
+  border-right: 1px solid rgb(34 197 94 / 0.75);
+  border-left: 1px solid rgb(34 197 94 / 0.75);
+  pointer-events: none;
+}
+
+:deep(.cm-db-current-statement-line--first::after) {
+  border-top: 1px solid rgb(34 197 94 / 0.75);
+}
+
+:deep(.cm-db-current-statement-line--last::after) {
+  border-bottom: 1px solid rgb(34 197 94 / 0.75);
+}
+
+:deep(.cm-run-statement-gutter) {
+  min-width: 34px;
+}
+
+:deep(.cm-run-statement-gutter .cm-gutterElement) {
+  align-items: center;
+  box-sizing: border-box;
+  display: flex;
+  justify-content: center;
+  min-width: 34px;
+  padding: 0 5px;
+}
+
+:deep(.cm-run-statement-marker) {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  width: min(24px, calc(var(--dbx-editor-font-size, 13px) * 1.6));
+  height: min(24px, calc(var(--dbx-editor-font-size, 13px) * 1.6));
+  margin: 0;
+  padding: 0;
+  border: 1px solid transparent;
+  border-radius: 6px;
+  background: transparent;
+  color: transparent;
+  vertical-align: middle;
+  white-space: nowrap;
+  transition:
+    color 0.15s,
+    background-color 0.15s;
+  outline: none;
+  user-select: none;
+  flex-shrink: 0;
+}
+
+:deep(.cm-run-statement-marker--active) {
+  background: rgb(16 185 129 / 0.1);
+  color: rgb(4 120 87);
+  cursor: pointer;
+}
+
+:deep(.cm-run-statement-marker--active:hover) {
+  background: rgb(16 185 129 / 0.2);
+  color: rgb(6 95 70);
+}
+
+:deep(.dark .cm-run-statement-marker--active) {
+  color: rgb(110 231 183);
+}
+
+:deep(.dark .cm-run-statement-marker--active:hover) {
+  color: rgb(167 243 208);
+}
+
+:deep(.cm-run-statement-marker svg) {
+  display: block;
+  width: min(14px, 70%);
+  height: min(14px, 70%);
+  pointer-events: none;
+  flex-shrink: 0;
+}
+
+:deep(.cm-foldMarker-svg) {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  vertical-align: middle;
+  width: 16px;
+  height: 16px;
+  color: var(--muted-foreground);
+  opacity: 0.65;
+  transition: opacity 0.15s;
+}
+
+:deep(.cm-foldMarker-svg:hover) {
+  opacity: 0.95;
+}
+
+:deep(.cm-foldMarker-svg svg) {
+  display: block;
+  width: 16px;
+  height: 16px;
+}
+</style>
diff --git a/apps/desktop/src/components/editor/QueryHistory.vue b/apps/desktop/src/components/editor/QueryHistory.vue
new file mode 100644
index 0000000..424e209
--- /dev/null
+++ b/apps/desktop/src/components/editor/QueryHistory.vue
@@ -0,0 +1,526 @@
+<script setup lang="ts">
+import { ref, computed, nextTick, onBeforeUnmount, onMounted, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { useSqlHighlighter } from "@/composables/useSqlHighlighter";
+import { CalendarClock, Copy, Database, RotateCcw, Search, Sparkles, Trash2, X } from "@lucide/vue";
+import { RecycleScroller } from "vue-virtual-scroller";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import CustomContextMenu, { type ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
+import { useHistoryStore } from "@/stores/historyStore";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useToast } from "@/composables/useToast";
+import { resolveHistoryActivityKind } from "@/lib/history/historyActivityKind";
+import { canRollbackHistoryEntry } from "@/lib/history/historyAiAnalysis";
+import { hasHistoryDateRange, historyDateRangeIsValid, historyEntryMatchesDateRange, type HistoryDateRange } from "@/lib/history/historyTimeRange";
+import { HISTORY_ROW_HEIGHT, HISTORY_SCROLL_BUFFER, shouldVirtualizeHistory } from "@/lib/history/historyVirtualList";
+import type { HistoryEntry } from "@/lib/backend/api";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import * as api from "@/lib/backend/api";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const { highlight } = useSqlHighlighter();
+const store = useHistoryStore();
+const connectionStore = useConnectionStore();
+
+const emit = defineEmits<{
+  restore: [sql: string, entry: HistoryEntry];
+  analyzeAi: [entry: HistoryEntry];
+  close: [];
+}>();
+
+type HistoryFilter = "all" | "query" | "data_change" | "schema_change" | "failed";
+
+const searchText = ref("");
+const activeFilter = ref<HistoryFilter>("all");
+const dateRange = ref<HistoryDateRange>({ startDate: "", endDate: "" });
+const dateRangeDraft = ref<HistoryDateRange>({ startDate: "", endDate: "" });
+const dateRangeOpen = ref(false);
+const startDateInputRef = ref<HTMLInputElement | null>(null);
+const endDateInputRef = ref<HTMLInputElement | null>(null);
+const selectedEntry = ref<HistoryEntry | null>(null);
+const isRollingBack = ref(false);
+const showDeleteConfirm = ref(false);
+const showClearConfirm = ref(false);
+const deleteTargetId = ref<string | null>(null);
+const filterScrollRef = ref<HTMLElement | null>(null);
+const filtersScrollable = ref(false);
+let filterScrollResizeObserver: ResizeObserver | null = null;
+
+const filters: HistoryFilter[] = ["all", "query", "data_change", "schema_change", "failed"];
+const hasDateFilter = computed(() => hasHistoryDateRange(dateRange.value));
+const dateRangeDraftValid = computed(() => historyDateRangeIsValid(dateRangeDraft.value));
+const dateRangeSummary = computed(() => {
+  if (!hasDateFilter.value) return "";
+  const start = dateRange.value.startDate || t("history.dateRange.unboundedStart");
+  const end = dateRange.value.endDate || t("history.dateRange.unboundedEnd");
+  return `${start} -> ${end}`;
+});
+
+const filtered = computed(() => {
+  const q = searchText.value.toLowerCase();
+  return store.entries.filter((entry) => {
+    if (activeFilter.value === "failed" && entry.success) return false;
+    if (activeFilter.value !== "all" && activeFilter.value !== "failed" && activityKind(entry) !== activeFilter.value) {
+      return false;
+    }
+    if (!historyEntryMatchesDateRange(entry.executed_at, dateRange.value)) return false;
+    if (!q) return true;
+    return [entry.sql, entry.connection_name, entry.database, entry.operation, entry.target].filter(Boolean).some((value) => String(value).toLowerCase().includes(q));
+  });
+});
+const emptyMessage = computed(() => (store.entries.length > 0 ? t("history.emptyFilteredRecent") : t("history.empty")));
+
+function activityKind(entry: HistoryEntry) {
+  return resolveHistoryActivityKind(entry);
+}
+
+function restore(entry: HistoryEntry) {
+  emit("restore", entry.sql, entry);
+  selectedEntry.value = null;
+}
+
+async function copyText(text: string) {
+  try {
+    await copyToClipboard(text);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function confirmDeleteEntry(id: string) {
+  deleteTargetId.value = id;
+  showDeleteConfirm.value = true;
+}
+
+function executeDelete() {
+  if (deleteTargetId.value) {
+    store.remove(deleteTargetId.value);
+    deleteTargetId.value = null;
+  }
+  showDeleteConfirm.value = false;
+}
+
+function confirmClearHistory() {
+  if (store.entries.length > 0) {
+    showClearConfirm.value = true;
+  }
+}
+
+function executeClear() {
+  store.clear();
+  showClearConfirm.value = false;
+}
+
+function formatTime(iso: string): string {
+  const d = new Date(iso);
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+function formatFullTime(iso: string): string {
+  const d = new Date(iso);
+  return Number.isNaN(d.getTime()) ? iso : d.toLocaleString();
+}
+
+function truncateSql(sql: string): string {
+  const line = sql.replace(/\s+/g, " ").trim();
+  return line.length > 120 ? line.slice(0, 120) + "..." : line;
+}
+
+function entryTitle(entry: HistoryEntry) {
+  return entry.target || entry.operation || truncateSql(entry.sql);
+}
+
+function entrySubtitle(entry: HistoryEntry) {
+  if (activityKind(entry) === "query") return truncateSql(entry.sql);
+  return truncateSql(entry.sql || entry.target || entry.operation || "");
+}
+
+function filterLabel(filter: HistoryFilter) {
+  return t(`history.filters.${filter}`);
+}
+
+function updateFilterScrollability() {
+  const el = filterScrollRef.value;
+  if (!el) return;
+  const scrollable = el.scrollWidth > el.clientWidth + 3;
+  filtersScrollable.value = scrollable;
+  if (!scrollable && el.scrollLeft !== 0) {
+    el.scrollLeft = 0;
+  }
+}
+
+function openDateRangeFilter() {
+  dateRangeDraft.value = { ...dateRange.value };
+}
+
+function setDateRangeOpen(value: boolean) {
+  if (value) openDateRangeFilter();
+  dateRangeOpen.value = value;
+}
+
+function applyDateRangeFilter() {
+  if (!dateRangeDraftValid.value) return;
+  dateRange.value = { ...dateRangeDraft.value };
+  dateRangeOpen.value = false;
+}
+
+function clearDateRangeFilter() {
+  dateRange.value = { startDate: "", endDate: "" };
+  dateRangeDraft.value = { startDate: "", endDate: "" };
+}
+
+function cancelDateRangeFilter() {
+  dateRangeDraft.value = { ...dateRange.value };
+  dateRangeOpen.value = false;
+}
+
+function dateFieldLabel(value: string) {
+  return value ? value.replaceAll("-", "/") : "yyyy/mm/dd";
+}
+
+function openDatePicker(input: HTMLInputElement | null) {
+  if (!input) return;
+  input.focus();
+  const pickerInput = input as HTMLInputElement & { showPicker?: () => void };
+  if (pickerInput.showPicker) {
+    pickerInput.showPicker();
+  } else {
+    input.click();
+  }
+}
+
+function kindLabel(entry: HistoryEntry) {
+  return t(`history.kinds.${activityKind(entry)}`);
+}
+
+function kindShortLabel(entry: HistoryEntry) {
+  return t(`history.kindShort.${activityKind(entry)}`);
+}
+
+function detailsRows(entry: HistoryEntry) {
+  const rows = [
+    [t("history.detail.kind"), kindLabel(entry)],
+    [t("history.detail.operation"), entry.operation || "-"],
+    [t("history.detail.connection"), entry.connection_name || "-"],
+    [t("history.detail.database"), entry.database || "-"],
+    [t("history.detail.target"), entry.target || "-"],
+    [t("history.detail.time"), formatFullTime(entry.executed_at)],
+    [t("history.detail.duration"), `${entry.execution_time_ms}ms`],
+    [t("history.detail.affectedRows"), entry.affected_rows ?? "-"],
+    [t("history.detail.rollback"), canRollbackHistoryEntry(entry) ? t("history.rollbackAvailable") : t("history.rollbackUnavailable")],
+    [t("history.detail.status"), entry.success ? t("history.success") : t("history.failed")],
+  ];
+  if (entry.error) rows.push([t("history.detail.error"), entry.error]);
+  return rows;
+}
+
+async function rollback(entry: HistoryEntry) {
+  if (!canRollbackHistoryEntry(entry) || isRollingBack.value) return;
+  if (!window.confirm(t("history.rollbackConfirm"))) return;
+
+  const connectionId = entry.connection_id!;
+  const rollbackSql = entry.rollback_sql!;
+  isRollingBack.value = true;
+  const start = Date.now();
+  try {
+    const result = await executeWithProductionSqlGuard({
+      connection: connectionStore.getConfig(connectionId),
+      database: entry.database,
+      sql: rollbackSql,
+      source: t("production.sourceQueryHistory"),
+      execute: () => api.executeScript(connectionId, entry.database, rollbackSql),
+    });
+    if (!result) return;
+    await store.add({
+      connection_id: connectionId,
+      connection_name: entry.connection_name,
+      database: entry.database,
+      sql: rollbackSql,
+      execution_time_ms: Date.now() - start,
+      success: true,
+      activity_kind: "data_change",
+      operation: "ROLLBACK",
+      target: entry.target,
+      affected_rows: result.affected_rows,
+      details_json: JSON.stringify({ rollback_of: entry.id }),
+    });
+    toast(t("history.rollbackSuccess"));
+    selectedEntry.value = null;
+  } catch (e: any) {
+    toast(t("history.rollbackFailed", { message: e?.message || String(e) }), 5000);
+  } finally {
+    isRollingBack.value = false;
+  }
+}
+
+function getHistoryMenuItems(entry: HistoryEntry): ContextMenuItem[] {
+  return [
+    {
+      label: t("history.viewDetails"),
+      action: () => {
+        selectedEntry.value = entry;
+      },
+    },
+    { label: t("history.restore"), action: () => restore(entry) },
+    { label: t("history.analyzeWithAi"), action: () => emit("analyzeAi", entry), icon: Sparkles },
+    { label: t("history.copy"), action: () => copyText(entry.sql) },
+    ...(canRollbackHistoryEntry(entry) ? [{ label: t("history.rollback"), action: () => rollback(entry) }] : []),
+    { label: t("history.delete"), action: () => confirmDeleteEntry(entry.id), variant: "destructive" as const },
+  ];
+}
+
+watch(
+  () => filters.map((filter) => filterLabel(filter)).join("\0"),
+  () => {
+    void nextTick(updateFilterScrollability);
+  },
+);
+
+onMounted(() => {
+  store.load();
+  void nextTick(updateFilterScrollability);
+
+  if (filterScrollRef.value) {
+    filterScrollResizeObserver = new ResizeObserver(updateFilterScrollability);
+    filterScrollResizeObserver.observe(filterScrollRef.value);
+  }
+});
+
+onBeforeUnmount(() => {
+  filterScrollResizeObserver?.disconnect();
+  filterScrollResizeObserver = null;
+});
+</script>
+
+<template>
+  <div class="h-full flex flex-col overflow-hidden border-l">
+    <div class="h-9 flex items-center gap-1 px-2 border-b shrink-0 bg-muted/20">
+      <span class="text-xs font-medium">{{ t("history.title") }}</span>
+      <span class="flex-1" />
+      <Button v-if="store.entries.length > 0" variant="ghost" size="icon" class="h-5 w-5" @click="confirmClearHistory">
+        <Trash2 class="h-3 w-3" />
+      </Button>
+      <Button variant="ghost" size="icon" class="h-5 w-5" @click="emit('close')">
+        <X class="h-3 w-3" />
+      </Button>
+    </div>
+
+    <div class="border-b shrink-0">
+      <div ref="filterScrollRef" class="history-filter-scroll flex gap-1 px-2 pt-2" :class="{ 'history-filter-scroll--scrollable': filtersScrollable }">
+        <button v-for="filter in filters" :key="filter" type="button" class="h-6 shrink-0 rounded border px-2 text-xs" :class="activeFilter === filter ? 'border-primary bg-primary text-primary-foreground' : 'bg-background'" @click="activeFilter = filter">
+          {{ filterLabel(filter) }}
+        </button>
+      </div>
+      <div class="relative flex items-center px-2 py-1">
+        <Search class="absolute left-3 w-3 h-3 text-muted-foreground pointer-events-none" />
+        <input v-model="searchText" autocapitalize="off" autocorrect="off" spellcheck="false" class="flex-1 h-5 text-xs bg-transparent border rounded pl-5 pr-1 outline-none placeholder:text-muted-foreground" :placeholder="t('history.search')" />
+        <Popover :open="dateRangeOpen" @update:open="setDateRangeOpen">
+          <PopoverTrigger as-child>
+            <button
+              type="button"
+              class="ml-1 flex h-5 w-5 shrink-0 items-center justify-center rounded border transition-colors"
+              :class="hasDateFilter ? 'border-primary/40 bg-primary/10 text-primary hover:bg-primary/15' : 'border-border/70 text-muted-foreground hover:bg-accent hover:text-foreground'"
+              :title="t('history.dateRange.title')"
+            >
+              <CalendarClock class="h-3 w-3" />
+            </button>
+          </PopoverTrigger>
+          <PopoverContent align="end" class="w-auto max-w-[calc(100vw-24px)] gap-3 p-3" @click.stop @keydown.stop>
+            <div class="flex items-center justify-between gap-3">
+              <div class="text-xs font-medium text-foreground">{{ t("history.dateRange.title") }}</div>
+            </div>
+            <div class="flex flex-wrap items-end gap-2">
+              <label class="grid min-w-0 gap-1 text-[11px] text-muted-foreground">
+                <span>{{ t("history.dateRange.start") }}</span>
+                <input ref="startDateInputRef" v-model="dateRangeDraft.startDate" type="date" class="sr-only" tabindex="-1" aria-hidden="true" />
+                <button type="button" class="flex h-8 w-28 min-w-0 items-center gap-1.5 rounded-md border border-input bg-background px-2 text-left text-xs text-foreground outline-none hover:bg-muted/50 focus:border-ring focus:ring-2 focus:ring-ring/30" @click="openDatePicker(startDateInputRef)">
+                  <span class="min-w-0 flex-1 truncate tabular-nums" :class="{ 'text-muted-foreground': !dateRangeDraft.startDate }">
+                    {{ dateFieldLabel(dateRangeDraft.startDate) }}
+                  </span>
+                  <CalendarClock class="h-3 w-3 shrink-0 text-muted-foreground" />
+                </button>
+              </label>
+              <span class="pb-2 text-xs text-muted-foreground">-></span>
+              <label class="grid min-w-0 gap-1 text-[11px] text-muted-foreground">
+                <span>{{ t("history.dateRange.end") }}</span>
+                <input ref="endDateInputRef" v-model="dateRangeDraft.endDate" type="date" class="sr-only" tabindex="-1" aria-hidden="true" />
+                <button type="button" class="flex h-8 w-28 min-w-0 items-center gap-1.5 rounded-md border border-input bg-background px-2 text-left text-xs text-foreground outline-none hover:bg-muted/50 focus:border-ring focus:ring-2 focus:ring-ring/30" @click="openDatePicker(endDateInputRef)">
+                  <span class="min-w-0 flex-1 truncate tabular-nums" :class="{ 'text-muted-foreground': !dateRangeDraft.endDate }">
+                    {{ dateFieldLabel(dateRangeDraft.endDate) }}
+                  </span>
+                  <CalendarClock class="h-3 w-3 shrink-0 text-muted-foreground" />
+                </button>
+              </label>
+            </div>
+            <div v-if="!dateRangeDraftValid" class="rounded-md border border-destructive/30 bg-destructive/10 px-2 py-1.5 text-xs text-destructive">
+              {{ t("history.dateRange.invalid") }}
+            </div>
+            <div class="flex items-center justify-between gap-2 pt-1">
+              <Button variant="ghost" size="sm" class="h-8 px-2 text-xs" @click="clearDateRangeFilter">
+                {{ t("history.dateRange.clear") }}
+              </Button>
+              <div class="flex items-center gap-2">
+                <Button variant="outline" size="sm" class="h-8 px-2 text-xs" @click="cancelDateRangeFilter">
+                  {{ t("dangerDialog.cancel") }}
+                </Button>
+                <Button size="sm" class="h-8 px-3 text-xs" :disabled="!dateRangeDraftValid" @click="applyDateRangeFilter">
+                  {{ t("history.dateRange.apply") }}
+                </Button>
+              </div>
+            </div>
+          </PopoverContent>
+        </Popover>
+      </div>
+      <div v-if="hasDateFilter" class="flex items-center gap-1 px-2 pb-2">
+        <button type="button" class="flex min-w-0 items-center gap-1 rounded border border-primary/30 bg-primary/10 px-1.5 py-0.5 text-[11px] font-medium text-primary hover:bg-primary/15" :title="t('history.dateRange.title')" @click="setDateRangeOpen(true)">
+          <CalendarClock class="h-3 w-3 shrink-0" />
+          <span class="shrink-0">{{ t("history.dateRange.label") }}</span>
+          <span class="min-w-0 truncate tabular-nums">{{ dateRangeSummary }}</span>
+        </button>
+        <button type="button" class="flex h-5 w-5 shrink-0 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground" :title="t('history.dateRange.clear')" @click="clearDateRangeFilter">
+          <X class="h-3 w-3" />
+        </button>
+      </div>
+    </div>
+
+    <div class="min-h-0 flex-1">
+      <RecycleScroller v-if="shouldVirtualizeHistory(filtered.length)" class="h-full" :items="filtered" :item-size="HISTORY_ROW_HEIGHT" :buffer="HISTORY_SCROLL_BUFFER" :skip-hover="true" key-field="id">
+        <template #default="{ item: entry }">
+          <CustomContextMenu :items="getHistoryMenuItems(entry)" v-slot="{ onContextMenu }">
+            <div class="h-[72px] cursor-pointer border-b border-border/50 px-3 py-2 text-xs hover:bg-accent/50" @click="selectedEntry = entry" @contextmenu="onContextMenu">
+              <div class="mb-0.5 flex items-center gap-1">
+                <span class="inline-flex h-5 w-9 shrink-0 items-center justify-center rounded border px-1 text-[10px] leading-none text-muted-foreground">
+                  {{ kindShortLabel(entry) }}
+                </span>
+                <span class="truncate font-medium">{{ entryTitle(entry) }}</span>
+                <span class="ml-auto shrink-0 text-muted-foreground">{{ formatTime(entry.executed_at) }}</span>
+              </div>
+              <div class="truncate font-mono text-muted-foreground">{{ entrySubtitle(entry) }}</div>
+              <div class="mt-0.5 flex items-center gap-2">
+                <span class="inline-flex min-w-0 items-center gap-1 text-muted-foreground">
+                  <Database class="h-3 w-3 shrink-0" />
+                  <span class="truncate">
+                    {{ entry.connection_name }}<template v-if="entry.database"> / {{ entry.database }}</template>
+                  </span>
+                </span>
+                <span class="ml-auto shrink-0" :class="entry.success ? 'text-green-500' : 'text-red-500'">
+                  {{ entry.success ? `${entry.execution_time_ms}ms` : t("history.failed") }}
+                </span>
+              </div>
+            </div>
+          </CustomContextMenu>
+        </template>
+      </RecycleScroller>
+
+      <div v-if="filtered.length === 0" class="px-3 py-8 text-center text-muted-foreground text-xs">
+        {{ emptyMessage }}
+      </div>
+    </div>
+
+    <Dialog :open="!!selectedEntry" @update:open="(value) => !value && (selectedEntry = null)">
+      <DialogContent class="sm:max-w-2xl duration-75" @interact-outside="selectedEntry = null">
+        <DialogHeader>
+          <DialogTitle>{{ selectedEntry ? entryTitle(selectedEntry) : t("history.viewDetails") }}</DialogTitle>
+        </DialogHeader>
+        <div v-if="selectedEntry" class="space-y-4 overflow-y-auto max-h-[60vh]">
+          <div class="grid grid-cols-[120px_1fr] gap-x-3 gap-y-2 text-sm">
+            <template v-for="[label, value] in detailsRows(selectedEntry)" :key="label">
+              <div class="text-muted-foreground">{{ label }}</div>
+              <div class="min-w-0 break-words">{{ value }}</div>
+            </template>
+          </div>
+          <div>
+            <div class="mb-1 flex items-center justify-between">
+              <div class="text-sm font-medium">SQL</div>
+              <Button variant="ghost" size="sm" class="h-7" @click="copyText(selectedEntry.sql)">
+                <Copy class="h-3.5 w-3.5" />
+                {{ t("history.copy") }}
+              </Button>
+            </div>
+            <pre class="max-h-48 overflow-auto rounded border bg-muted/30 p-3 text-xs" v-html="highlight(selectedEntry.sql)"></pre>
+          </div>
+          <div v-if="selectedEntry.rollback_sql">
+            <div class="mb-1 flex items-center justify-between">
+              <div class="text-sm font-medium">{{ t("history.rollbackSql") }}</div>
+              <Button variant="ghost" size="sm" class="h-7" @click="copyText(selectedEntry.rollback_sql || '')">
+                <Copy class="h-3.5 w-3.5" />
+                {{ t("history.copy") }}
+              </Button>
+            </div>
+            <pre class="max-h-40 overflow-auto rounded border bg-muted/30 p-3 text-xs" v-html="highlight(selectedEntry.rollback_sql || '')"></pre>
+          </div>
+        </div>
+        <DialogFooter>
+          <Button variant="outline" @click="selectedEntry && emit('analyzeAi', selectedEntry)">
+            <Sparkles class="h-4 w-4" />
+            {{ t("history.analyzeWithAi") }}
+          </Button>
+          <Button variant="outline" @click="selectedEntry && restore(selectedEntry)">{{ t("history.restore") }}</Button>
+          <Button v-if="selectedEntry && canRollbackHistoryEntry(selectedEntry)" :disabled="isRollingBack" @click="rollback(selectedEntry)">
+            <RotateCcw class="h-4 w-4" />
+            {{ isRollingBack ? t("common.loading") : t("history.rollback") }}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <Dialog v-model:open="showDeleteConfirm">
+      <DialogContent class="sm:max-w-[400px]">
+        <DialogHeader>
+          <DialogTitle>{{ t("history.delete") }}</DialogTitle>
+        </DialogHeader>
+        <p class="text-sm text-muted-foreground">{{ t("history.confirmDelete") }}</p>
+        <DialogFooter>
+          <Button variant="outline" @click="showDeleteConfirm = false">{{ t("dangerDialog.cancel") }}</Button>
+          <Button variant="destructive" @click="executeDelete">{{ t("dangerDialog.confirm") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <Dialog v-model:open="showClearConfirm">
+      <DialogContent class="sm:max-w-[400px]">
+        <DialogHeader>
+          <DialogTitle>{{ t("history.clear") }}</DialogTitle>
+        </DialogHeader>
+        <p class="text-sm text-muted-foreground">{{ t("history.confirmClear") }}</p>
+        <DialogFooter>
+          <Button variant="outline" @click="showClearConfirm = false">{{ t("dangerDialog.cancel") }}</Button>
+          <Button variant="destructive" @click="executeClear">{{ t("dangerDialog.confirm") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  </div>
+</template>
+
+<style scoped>
+.history-filter-scroll {
+  overflow-x: hidden;
+  overscroll-behavior-x: none;
+}
+
+.history-filter-scroll--scrollable {
+  overflow-x: auto;
+  padding-bottom: 2px;
+  scrollbar-color: color-mix(in oklab, var(--muted-foreground) 45%, transparent) transparent;
+  scrollbar-width: thin;
+}
+
+.history-filter-scroll--scrollable::-webkit-scrollbar {
+  height: 4px;
+}
+
+.history-filter-scroll--scrollable::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.history-filter-scroll--scrollable::-webkit-scrollbar-thumb {
+  border-radius: 999px;
+  background: color-mix(in oklab, var(--muted-foreground) 45%, transparent);
+}
+</style>
diff --git a/apps/desktop/src/components/editor/SqlExecutionTargetPicker.vue b/apps/desktop/src/components/editor/SqlExecutionTargetPicker.vue
new file mode 100644
index 0000000..601a2f6
--- /dev/null
+++ b/apps/desktop/src/components/editor/SqlExecutionTargetPicker.vue
@@ -0,0 +1,118 @@
+<script setup lang="ts">
+import { computed, nextTick, onBeforeUnmount, onMounted, ref, watch } from "vue";
+import type { SqlExecutionCandidate } from "@/lib/sql/sqlExecutionTarget";
+import { useI18n } from "vue-i18n";
+
+const props = defineProps<{
+  candidates: SqlExecutionCandidate[];
+  activeIndex: number;
+  anchor?: { left: number; top: number };
+}>();
+
+const emit = defineEmits<{
+  "update:activeIndex": [index: number];
+  confirm: [candidate: SqlExecutionCandidate];
+  cancel: [];
+}>();
+
+const { t } = useI18n();
+
+const listboxRef = ref<HTMLDivElement>();
+const optionRefs = ref<HTMLElement[]>([]);
+
+const title = computed(() => t("editor.executionPicker.title"));
+const pickerStyle = computed(() => {
+  if (!props.anchor) return undefined;
+  return {
+    left: `${props.anchor.left}px`,
+    top: `${props.anchor.top}px`,
+    transform: "translate(-50%, 0)",
+  };
+});
+
+function displayLabel(candidate: SqlExecutionCandidate) {
+  return t(`editor.executionPicker.${candidate.label}`);
+}
+
+function optionId(index: number) {
+  return `dbx-exec-target-${index}`;
+}
+
+watch(
+  () => props.activeIndex,
+  (index) => {
+    void nextTick(() => {
+      optionRefs.value[index]?.scrollIntoView({ block: "nearest" });
+    });
+  },
+);
+
+function setActiveIndex(index: number) {
+  emit("update:activeIndex", Math.max(0, Math.min(index, props.candidates.length - 1)));
+}
+
+function confirmCurrent() {
+  const candidate = props.candidates[props.activeIndex];
+  if (candidate) emit("confirm", candidate);
+}
+
+function onKeydown(event: KeyboardEvent) {
+  switch (event.key) {
+    case "ArrowDown":
+      event.preventDefault();
+      setActiveIndex(props.activeIndex + 1);
+      break;
+    case "ArrowUp":
+      event.preventDefault();
+      setActiveIndex(props.activeIndex - 1);
+      break;
+    case "Enter":
+      event.preventDefault();
+      confirmCurrent();
+      break;
+    case "Escape":
+      event.preventDefault();
+      emit("cancel");
+      break;
+  }
+}
+
+function setOptionRef(index: number, el: Element | null) {
+  if (el instanceof HTMLElement) optionRefs.value[index] = el;
+}
+
+onMounted(() => {
+  listboxRef.value?.focus();
+});
+
+onBeforeUnmount(() => {
+  emit("cancel");
+});
+</script>
+
+<template>
+  <div ref="listboxRef" role="listbox" tabindex="-1" class="sql-execution-picker absolute z-[9998] w-[520px] max-w-[calc(100vw-32px)] flex flex-col rounded-md border bg-popover shadow-lg outline-none" :style="pickerStyle" @keydown="onKeydown" @blur="emit('cancel')">
+    <div class="border-b bg-muted/40 px-3 py-2">
+      <div class="text-xs font-semibold">{{ title }}</div>
+    </div>
+    <div class="flex flex-col py-1">
+      <div
+        v-for="(candidate, index) in candidates"
+        :id="optionId(index)"
+        :key="candidate.kind"
+        role="option"
+        :ref="(el: any) => setOptionRef(index, el as Element | null)"
+        :aria-selected="index === activeIndex"
+        class="flex items-center gap-2 mx-1 px-2 py-1.5 rounded text-sm cursor-pointer select-none"
+        :class="index === activeIndex ? 'bg-primary text-primary-foreground' : 'hover:bg-accent hover:text-accent-foreground'"
+        @mousemove="setActiveIndex(index)"
+        @click="emit('confirm', candidate)"
+      >
+        <span class="shrink-0 text-xs font-medium px-1.5 py-0.5 rounded border" :class="index === activeIndex ? 'border-primary-foreground/40 bg-primary-foreground/10' : 'border-border bg-muted/50'">
+          {{ displayLabel(candidate) }}
+        </span>
+        <span class="truncate min-w-0 font-mono text-xs opacity-80">{{ candidate.sql }}</span>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/editor/SqlFormatterSettingsPanel.vue b/apps/desktop/src/components/editor/SqlFormatterSettingsPanel.vue
new file mode 100644
index 0000000..a6363bf
--- /dev/null
+++ b/apps/desktop/src/components/editor/SqlFormatterSettingsPanel.vue
@@ -0,0 +1,720 @@
+<script setup lang="ts">
+import { computed, nextTick, onBeforeUnmount, ref, watch } from "vue";
+import { Upload, Download, RotateCcw, WandSparkles, Save, Copy } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Label } from "@/components/ui/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { useToast } from "@/composables/useToast";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import {
+  DEFAULT_SQL_FORMATTER_SETTINGS,
+  SQL_FORMATTER_CONFIG_FORMATTER,
+  SQL_FORMATTER_CONFIG_VERSION,
+  normalizeSqlFormatterSettings,
+  parseSqlFormatterConfig,
+  serializeSqlFormatterConfig,
+  syncSqlFormatterConfigDraft,
+  type SqlFormatterCase,
+  type SqlFormatterExpressionWidth,
+  type SqlFormatterIndentStyle,
+  type SqlFormatterLinesBetweenQueries,
+  type SqlFormatterLogicalOperatorNewline,
+  type SqlFormatterOptionSettings,
+  type SqlFormatterParamTypes,
+  type SqlFormatterSettings,
+  type SqlFormatterTabWidth,
+} from "@/lib/sql/sqlFormatterConfig";
+
+type EditorViewInstance = import("@codemirror/view").EditorView;
+type CodeMirrorModules = {
+  view: typeof import("@codemirror/view");
+  state: typeof import("@codemirror/state");
+  langJson: typeof import("@codemirror/lang-json");
+  commands: typeof import("@codemirror/commands");
+  search: typeof import("@codemirror/search");
+};
+
+const props = defineProps<{
+  modelValue: SqlFormatterSettings;
+}>();
+
+const emit = defineEmits<{
+  "update:modelValue": [value: SqlFormatterSettings];
+  validityChange: [value: boolean];
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+
+const activeMode = ref<"form" | "json">("form");
+const fileInputRef = ref<HTMLInputElement>();
+const jsonEditorRef = ref<HTMLDivElement>();
+const jsonDraft = ref(serializeSqlFormatterConfig(props.modelValue));
+const jsonValidationMessage = ref("");
+const importError = ref("");
+const advancedConfigError = ref("");
+const jsonEditorLoading = ref(false);
+const jsonEditorReady = ref(false);
+const jsonEditorLoadError = ref("");
+const paramTypesDraft = ref("");
+const focusedAdvancedOption = ref<"paramTypes" | null>(null);
+
+let cmView: EditorViewInstance | null = null;
+let cmModules: CodeMirrorModules | null = null;
+let lastValidity: boolean | null = null;
+
+const settings = computed(() => normalizeSqlFormatterSettings(props.modelValue));
+
+const caseOptions: { value: SqlFormatterCase; labelKey: string }[] = [
+  { value: "upper", labelKey: "settings.sqlFormatterCaseUpper" },
+  { value: "lower", labelKey: "settings.sqlFormatterCaseLower" },
+  { value: "preserve", labelKey: "settings.sqlFormatterCasePreserve" },
+];
+
+const logicalOperatorOptions: { value: SqlFormatterLogicalOperatorNewline; labelKey: string }[] = [
+  { value: "before", labelKey: "settings.sqlFormatterLogicalBefore" },
+  { value: "after", labelKey: "settings.sqlFormatterLogicalAfter" },
+];
+
+const indentStyleOptions: { value: SqlFormatterIndentStyle; labelKey: string }[] = [
+  { value: "standard", labelKey: "settings.sqlFormatterIndentStyleStandard" },
+  { value: "tabularLeft", labelKey: "settings.sqlFormatterIndentStyleTabularLeft" },
+  { value: "tabularRight", labelKey: "settings.sqlFormatterIndentStyleTabularRight" },
+];
+
+const tabWidthOptions: SqlFormatterTabWidth[] = [2, 4];
+const expressionWidthOptions: SqlFormatterExpressionWidth[] = [50, 80, 120];
+const linesBetweenQueriesOptions: SqlFormatterLinesBetweenQueries[] = [0, 1, 2];
+const sqlFormatterOptionLabelKeys: Record<keyof SqlFormatterOptionSettings, string> = {
+  keywordCase: "settings.sqlFormatterKeywordCase",
+  dataTypeCase: "settings.sqlFormatterDataTypeCase",
+  functionCase: "settings.sqlFormatterFunctionCase",
+  identifierCase: "settings.sqlFormatterIdentifierCase",
+  indentStyle: "settings.sqlFormatterIndentStyle",
+  useTabs: "settings.sqlFormatterIndent",
+  tabWidth: "settings.sqlFormatterTabWidth",
+  logicalOperatorNewline: "settings.sqlFormatterLogicalOperatorNewline",
+  expressionWidth: "settings.sqlFormatterExpressionWidth",
+  linesBetweenQueries: "settings.sqlFormatterLinesBetweenQueries",
+  denseOperators: "settings.sqlFormatterDenseOperators",
+  newlineBeforeSemicolon: "settings.sqlFormatterNewlineBeforeSemicolon",
+  paramTypes: "settings.sqlFormatterParamTypes",
+};
+const sqlFormatterConfigErrorKeys: Record<string, string> = {
+  "Invalid JSON.": "settings.sqlFormatterConfigErrorInvalidJson",
+  "Config must be a JSON object.": "settings.sqlFormatterConfigErrorObject",
+  "Unsupported config version.": "settings.sqlFormatterConfigErrorVersion",
+  "Unsupported formatter.": "settings.sqlFormatterConfigErrorFormatter",
+  "Unsupported formatter option: params.": "settings.sqlFormatterConfigErrorUnsupportedParams",
+  "Config options must be a JSON object.": "settings.sqlFormatterConfigErrorOptionsObject",
+};
+
+function emitValidity(value: boolean) {
+  if (lastValidity === value) return;
+  lastValidity = value;
+  emit("validityChange", value);
+}
+
+function setJsonDraftText(text: string) {
+  jsonDraft.value = text;
+  if (!cmView || cmView.state.doc.toString() === text) return;
+  cmView.dispatch({
+    changes: { from: 0, to: cmView.state.doc.length, insert: text },
+  });
+}
+
+function localizeSqlFormatterConfigError(message: string): string {
+  const exactKey = sqlFormatterConfigErrorKeys[message];
+  if (exactKey) return t(exactKey);
+
+  const unknownOption = message.match(/^Unknown formatter option: (.+)\.$/);
+  if (unknownOption?.[1]) {
+    return t("settings.sqlFormatterConfigErrorUnknownOption", { option: unknownOption[1] });
+  }
+
+  const invalidOption = message.match(/^Invalid formatter option value: (.+)\.$/);
+  if (invalidOption?.[1]) {
+    const labelKey = sqlFormatterOptionLabelKeys[invalidOption[1] as keyof SqlFormatterOptionSettings];
+    if (labelKey) {
+      return t("settings.sqlFormatterConfigErrorInvalidOptionValue", { option: t(labelKey) });
+    }
+  }
+
+  return t("settings.sqlFormatterConfigErrorInvalidConfig");
+}
+
+function validateJsonDraft(text = jsonDraft.value): boolean {
+  const result = parseSqlFormatterConfig(text);
+  jsonValidationMessage.value = result.ok ? "" : localizeSqlFormatterConfigError(result.message);
+  const valid = result.ok;
+  emitValidity(activeMode.value === "json" ? valid : true);
+  return valid;
+}
+
+function syncJsonDraft(text = jsonDraft.value): boolean {
+  const result = syncSqlFormatterConfigDraft(text, updateSettings);
+  jsonValidationMessage.value = result.ok ? "" : localizeSqlFormatterConfigError(result.message);
+  emitValidity(activeMode.value === "json" ? result.ok : true);
+  return result.ok;
+}
+
+function updateSettings(next: unknown) {
+  importError.value = "";
+  advancedConfigError.value = "";
+  emit("update:modelValue", normalizeSqlFormatterSettings(next));
+}
+
+function updateOption<K extends keyof SqlFormatterSettings>(key: K, value: SqlFormatterSettings[K]) {
+  updateSettings({ ...settings.value, [key]: value });
+}
+
+function onCaseOption(key: "keywordCase" | "functionCase" | "dataTypeCase", value: any) {
+  if (value === "upper" || value === "lower" || value === "preserve") updateOption(key, value);
+}
+
+function onIdentifierCase(value: any) {
+  if (value === "upper" || value === "lower" || value === "preserve") updateOption("identifierCase", value);
+}
+
+function onIndentStyle(value: any) {
+  if (value === "standard" || value === "tabularLeft" || value === "tabularRight") updateOption("indentStyle", value);
+}
+
+function onLogicalOperatorNewline(value: any) {
+  if (value === "before" || value === "after") updateOption("logicalOperatorNewline", value);
+}
+
+function onTabWidth(value: any) {
+  const next = Number(value);
+  if (next === 2 || next === 4) updateOption("tabWidth", next);
+}
+
+function onExpressionWidth(value: any) {
+  const next = Number(value);
+  if (next === 50 || next === 80 || next === 120) updateOption("expressionWidth", next);
+}
+
+function onLinesBetweenQueries(value: any) {
+  const next = Number(value);
+  if (next === 0 || next === 1 || next === 2) updateOption("linesBetweenQueries", next);
+}
+
+function restoreDefaults() {
+  updateSettings(DEFAULT_SQL_FORMATTER_SETTINGS);
+}
+
+function stringifyAdvancedOption(value: SqlFormatterParamTypes | null): string {
+  return JSON.stringify(value, null, 2);
+}
+
+function setAdvancedDraft(value: SqlFormatterParamTypes | null) {
+  paramTypesDraft.value = stringifyAdvancedOption(value);
+}
+
+function onAdvancedJsonInput(event: Event) {
+  paramTypesDraft.value = (event.target as HTMLTextAreaElement).value;
+}
+
+function onJsonDraftTextareaInput(event: Event) {
+  const text = (event.target as HTMLTextAreaElement).value;
+  jsonDraft.value = text;
+  syncJsonDraft(text);
+}
+
+function onAdvancedJsonFocus() {
+  focusedAdvancedOption.value = "paramTypes";
+}
+
+function onAdvancedJsonBlur() {
+  focusedAdvancedOption.value = null;
+  applyAdvancedJsonOption();
+}
+
+function applyAdvancedJsonOption() {
+  let parsed: unknown = null;
+  const draft = paramTypesDraft.value.trim();
+  if (draft) {
+    try {
+      parsed = JSON.parse(draft);
+    } catch {
+      advancedConfigError.value = localizeSqlFormatterConfigError("Invalid JSON.");
+      return;
+    }
+  }
+
+  const result = parseSqlFormatterConfig(
+    JSON.stringify({
+      version: SQL_FORMATTER_CONFIG_VERSION,
+      formatter: SQL_FORMATTER_CONFIG_FORMATTER,
+      options: { paramTypes: parsed },
+    }),
+  );
+  if (!result.ok) {
+    advancedConfigError.value = localizeSqlFormatterConfigError(result.message);
+    return;
+  }
+
+  updateOption("paramTypes", result.settings.paramTypes);
+  setAdvancedDraft(result.settings.paramTypes);
+  advancedConfigError.value = "";
+}
+
+function importConfig() {
+  importError.value = "";
+  fileInputRef.value?.click();
+}
+
+async function onImportFile(event: Event) {
+  const input = event.target as HTMLInputElement;
+  const file = input.files?.[0];
+  input.value = "";
+  if (!file) return;
+
+  try {
+    const text = await file.text();
+    const result = parseSqlFormatterConfig(text);
+    if (!result.ok) {
+      importError.value = localizeSqlFormatterConfigError(result.message);
+      return;
+    }
+    updateSettings(result.settings);
+    toast(t("settings.sqlFormatterImportSuccess"));
+  } catch (e: any) {
+    importError.value = e?.message || String(e);
+  }
+}
+
+function exportConfig() {
+  const blob = new Blob([serializeSqlFormatterConfig(settings.value)], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = "dbx-sql-formatter.json";
+  document.body.appendChild(link);
+  link.click();
+  link.remove();
+  URL.revokeObjectURL(url);
+}
+
+async function copyJsonDraft() {
+  try {
+    await copyToClipboard(cmView?.state.doc.toString() ?? jsonDraft.value);
+    toast(t("settings.sqlFormatterCopyJsonSuccess"));
+  } catch (e: any) {
+    toast(t("settings.sqlFormatterCopyJsonFailed", { message: e?.message || String(e) }), 3000);
+  }
+}
+
+function applyJsonDraft(): boolean {
+  const result = parseSqlFormatterConfig(jsonDraft.value);
+  if (!result.ok) {
+    jsonValidationMessage.value = localizeSqlFormatterConfigError(result.message);
+    emitValidity(false);
+    return true;
+  }
+
+  const pretty = serializeSqlFormatterConfig(result.settings);
+  updateSettings(result.settings);
+  setJsonDraftText(pretty);
+  jsonValidationMessage.value = "";
+  emitValidity(true);
+  return true;
+}
+
+function formatJsonDraft(): boolean {
+  const result = parseSqlFormatterConfig(jsonDraft.value);
+  if (!result.ok) {
+    jsonValidationMessage.value = localizeSqlFormatterConfigError(result.message);
+    emitValidity(false);
+    return true;
+  }
+
+  setJsonDraftText(serializeSqlFormatterConfig(result.settings));
+  jsonValidationMessage.value = "";
+  emitValidity(true);
+  return true;
+}
+
+async function loadCodeMirrorModules(): Promise<CodeMirrorModules> {
+  if (cmModules) return cmModules;
+  const [view, state, langJson, commands, search] = await Promise.all([import("@codemirror/view"), import("@codemirror/state"), import("@codemirror/lang-json"), import("@codemirror/commands"), import("@codemirror/search")]);
+  cmModules = { view, state, langJson, commands, search };
+  return cmModules;
+}
+
+function destroyJsonEditor() {
+  cmView?.destroy();
+  cmView = null;
+  jsonEditorReady.value = false;
+  jsonEditorLoadError.value = "";
+}
+
+function jsonEditorKeymapExtension(modules: CodeMirrorModules) {
+  const { keymap } = modules.view;
+  const commands = modules.commands;
+  const search = modules.search;
+  return keymap.of([...search.searchKeymap, ...commands.historyKeymap, ...commands.defaultKeymap]);
+}
+
+async function initJsonEditor() {
+  if (cmView || !jsonEditorRef.value) return;
+  jsonEditorLoading.value = true;
+  jsonEditorLoadError.value = "";
+  try {
+    const modules = await loadCodeMirrorModules();
+    if (activeMode.value !== "json" || cmView || !jsonEditorRef.value) return;
+
+    const { EditorView, lineNumbers, highlightActiveLine, highlightActiveLineGutter } = modules.view;
+    const { EditorState } = modules.state;
+    const { json } = modules.langJson;
+    const commands = modules.commands;
+    const search = modules.search;
+
+    const state = EditorState.create({
+      doc: jsonDraft.value,
+      extensions: [
+        lineNumbers(),
+        highlightActiveLineGutter(),
+        highlightActiveLine(),
+        commands.history(),
+        search.search({ top: true }),
+        json(),
+        jsonEditorKeymapExtension(modules),
+        EditorView.lineWrapping,
+        EditorView.updateListener.of((update) => {
+          if (!update.docChanged) return;
+          jsonDraft.value = update.state.doc.toString();
+          syncJsonDraft(jsonDraft.value);
+        }),
+        EditorView.theme({
+          "&": {
+            minHeight: "260px",
+            maxHeight: "360px",
+            fontSize: "12px",
+            border: "1px solid hsl(var(--border))",
+            borderRadius: "var(--radius-md)",
+            backgroundColor: "hsl(var(--background))",
+            color: "hsl(var(--foreground))",
+          },
+          ".cm-scroller": {
+            fontFamily: "var(--font-mono), ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace",
+          },
+          ".cm-gutters": {
+            backgroundColor: "hsl(var(--muted) / 0.35)",
+            color: "hsl(var(--muted-foreground))",
+            borderRight: "1px solid hsl(var(--border))",
+          },
+          ".cm-activeLine, .cm-activeLineGutter": {
+            backgroundColor: "hsl(var(--muted) / 0.45)",
+          },
+          ".cm-focused": {
+            outline: "2px solid hsl(var(--ring) / 0.35)",
+            outlineOffset: "1px",
+          },
+        }),
+      ],
+    });
+
+    cmView = new EditorView({ state, parent: jsonEditorRef.value });
+    jsonEditorReady.value = true;
+  } catch (e: any) {
+    jsonEditorReady.value = false;
+    jsonEditorLoadError.value = e?.message || String(e);
+  } finally {
+    jsonEditorLoading.value = false;
+  }
+}
+
+watch(
+  () => settings.value.paramTypes,
+  (value) => {
+    if (focusedAdvancedOption.value !== "paramTypes") paramTypesDraft.value = stringifyAdvancedOption(value);
+  },
+  { deep: true, immediate: true },
+);
+
+watch(
+  () => props.modelValue,
+  (value) => {
+    if (activeMode.value === "json") {
+      const currentDraft = parseSqlFormatterConfig(jsonDraft.value);
+      if (currentDraft.ok && serializeSqlFormatterConfig(currentDraft.settings) === serializeSqlFormatterConfig(value)) {
+        validateJsonDraft(jsonDraft.value);
+        return;
+      }
+    }
+
+    const text = serializeSqlFormatterConfig(value);
+    setJsonDraftText(text);
+    if (activeMode.value === "json") validateJsonDraft(text);
+  },
+  { deep: true },
+);
+
+watch(
+  activeMode,
+  async (mode) => {
+    if (mode === "json") {
+      validateJsonDraft();
+      await nextTick();
+      await initJsonEditor();
+      return;
+    }
+    destroyJsonEditor();
+  },
+  { immediate: true },
+);
+
+onBeforeUnmount(() => {
+  destroyJsonEditor();
+});
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="flex flex-wrap items-center gap-2">
+      <input ref="fileInputRef" type="file" accept="application/json,.json" class="hidden" @change="onImportFile" />
+      <Button type="button" variant="outline" size="sm" @click="importConfig">
+        <Download class="mr-2 h-4 w-4" />
+        {{ t("settings.sqlFormatterImport") }}
+      </Button>
+      <Button type="button" variant="outline" size="sm" @click="exportConfig">
+        <Upload class="mr-2 h-4 w-4" />
+        {{ t("settings.sqlFormatterExport") }}
+      </Button>
+      <Button type="button" variant="outline" size="sm" @click="restoreDefaults">
+        <RotateCcw class="mr-2 h-4 w-4" />
+        {{ t("settings.sqlFormatterRestoreDefaults") }}
+      </Button>
+    </div>
+
+    <p v-if="importError" class="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+      {{ importError }}
+    </p>
+
+    <Tabs v-model="activeMode" class="min-h-0">
+      <TabsList class="grid w-full grid-cols-2">
+        <TabsTrigger value="form">{{ t("settings.sqlFormatterFormMode") }}</TabsTrigger>
+        <TabsTrigger value="json">{{ t("settings.sqlFormatterJsonMode") }}</TabsTrigger>
+      </TabsList>
+
+      <TabsContent value="form" class="m-0 flex flex-col gap-4 pt-2">
+        <div class="grid gap-4 md:grid-cols-4">
+          <div class="space-y-2">
+            <Label>{{ t("settings.sqlFormatterKeywordCase") }}</Label>
+            <Select :model-value="settings.keywordCase" @update:model-value="(value: any) => onCaseOption('keywordCase', value)">
+              <SelectTrigger class="w-full">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem v-for="option in caseOptions" :key="option.value" :value="option.value">
+                  {{ t(option.labelKey) }}
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div class="space-y-2">
+            <Label>{{ t("settings.sqlFormatterFunctionCase") }}</Label>
+            <Select :model-value="settings.functionCase" @update:model-value="(value: any) => onCaseOption('functionCase', value)">
+              <SelectTrigger class="w-full">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem v-for="option in caseOptions" :key="option.value" :value="option.value">
+                  {{ t(option.labelKey) }}
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div class="space-y-2">
+            <Label>{{ t("settings.sqlFormatterDataTypeCase") }}</Label>
+            <Select :model-value="settings.dataTypeCase" @update:model-value="(value: any) => onCaseOption('dataTypeCase', value)">
+              <SelectTrigger class="w-full">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem v-for="option in caseOptions" :key="option.value" :value="option.value">
+                  {{ t(option.labelKey) }}
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div class="space-y-2">
+            <Label>{{ t("settings.sqlFormatterIdentifierCase") }}</Label>
+            <Select :model-value="settings.identifierCase" @update:model-value="onIdentifierCase">
+              <SelectTrigger class="w-full">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem v-for="option in caseOptions" :key="option.value" :value="option.value">
+                  {{ t(option.labelKey) }}
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+        </div>
+
+        <div class="grid gap-4 md:grid-cols-[minmax(0,1fr)_10rem_12rem]">
+          <div class="space-y-2">
+            <Label>{{ t("settings.sqlFormatterIndent") }}</Label>
+            <div class="grid grid-cols-2 gap-2">
+              <Button type="button" variant="outline" class="justify-center" :class="!settings.useTabs ? 'border-blue-300 ring-2 ring-blue-300/50' : ''" @click="updateOption('useTabs', false)">
+                {{ t("settings.sqlFormatterIndentSpaces") }}
+              </Button>
+              <Button type="button" variant="outline" class="justify-center" :class="settings.useTabs ? 'border-blue-300 ring-2 ring-blue-300/50' : ''" @click="updateOption('useTabs', true)">
+                {{ t("settings.sqlFormatterIndentTabs") }}
+              </Button>
+            </div>
+          </div>
+
+          <div class="space-y-2">
+            <Label>{{ t("settings.sqlFormatterTabWidth") }}</Label>
+            <Select :model-value="String(settings.tabWidth)" @update:model-value="onTabWidth">
+              <SelectTrigger class="w-full">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem v-for="width in tabWidthOptions" :key="width" :value="String(width)">
+                  {{ width }}
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div class="space-y-2">
+            <Label>{{ t("settings.sqlFormatterIndentStyle") }}</Label>
+            <Select :model-value="settings.indentStyle" @update:model-value="onIndentStyle">
+              <SelectTrigger class="w-full">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem v-for="option in indentStyleOptions" :key="option.value" :value="option.value">
+                  {{ t(option.labelKey) }}
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+        </div>
+
+        <div class="grid gap-4 md:grid-cols-3">
+          <div class="space-y-2">
+            <Label>{{ t("settings.sqlFormatterLogicalOperatorNewline") }}</Label>
+            <Select :model-value="settings.logicalOperatorNewline" @update:model-value="onLogicalOperatorNewline">
+              <SelectTrigger class="w-full">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem v-for="option in logicalOperatorOptions" :key="option.value" :value="option.value">
+                  {{ t(option.labelKey) }}
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div class="space-y-2">
+            <Label>{{ t("settings.sqlFormatterExpressionWidth") }}</Label>
+            <Select :model-value="String(settings.expressionWidth)" @update:model-value="onExpressionWidth">
+              <SelectTrigger class="w-full">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem v-for="width in expressionWidthOptions" :key="width" :value="String(width)">
+                  {{ width }}
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div class="space-y-2">
+            <Label>{{ t("settings.sqlFormatterLinesBetweenQueries") }}</Label>
+            <Select :model-value="String(settings.linesBetweenQueries)" @update:model-value="onLinesBetweenQueries">
+              <SelectTrigger class="w-full">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem v-for="count in linesBetweenQueriesOptions" :key="count" :value="String(count)">
+                  {{ count }}
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+        </div>
+
+        <div class="grid gap-3 md:grid-cols-2">
+          <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+            <Label for="sql-formatter-dense-operators">{{ t("settings.sqlFormatterDenseOperators") }}</Label>
+            <Switch id="sql-formatter-dense-operators" :model-value="settings.denseOperators" @update:model-value="(value: boolean) => updateOption('denseOperators', value)" />
+          </div>
+
+          <div class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+            <Label for="sql-formatter-newline-before-semicolon">
+              {{ t("settings.sqlFormatterNewlineBeforeSemicolon") }}
+            </Label>
+            <Switch id="sql-formatter-newline-before-semicolon" :model-value="settings.newlineBeforeSemicolon" @update:model-value="(value: boolean) => updateOption('newlineBeforeSemicolon', value)" />
+          </div>
+        </div>
+
+        <div class="space-y-3 rounded-md border border-border/70 bg-muted/10 p-3">
+          <div class="text-sm font-medium">{{ t("settings.sqlFormatterAdvancedOptions") }}</div>
+          <div class="space-y-2">
+            <Label for="sql-formatter-param-types">{{ t("settings.sqlFormatterParamTypes") }}</Label>
+            <textarea
+              id="sql-formatter-param-types"
+              :value="paramTypesDraft"
+              spellcheck="false"
+              class="min-h-28 w-full resize-y rounded-md border border-input bg-background px-3 py-2 font-mono text-xs outline-none transition-colors focus:border-ring focus:ring-1 focus:ring-ring/40"
+              @input="onAdvancedJsonInput"
+              @focus="onAdvancedJsonFocus"
+              @blur="onAdvancedJsonBlur"
+            />
+          </div>
+          <p v-if="advancedConfigError" class="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+            {{ advancedConfigError }}
+          </p>
+        </div>
+      </TabsContent>
+
+      <TabsContent value="json" class="m-0 flex min-h-0 flex-col gap-3 pt-2">
+        <div class="flex flex-wrap items-center gap-2">
+          <Button type="button" variant="outline" size="sm" @click="formatJsonDraft">
+            <WandSparkles class="mr-2 h-4 w-4" />
+            {{ t("settings.sqlFormatterShortcutFormatJson") }}
+          </Button>
+          <Button type="button" variant="outline" size="sm" @click="copyJsonDraft">
+            <Copy class="mr-2 h-4 w-4" />
+            {{ t("settings.sqlFormatterCopyJson") }}
+          </Button>
+          <Button type="button" size="sm" :disabled="!!jsonValidationMessage" @click="applyJsonDraft">
+            <Save class="mr-2 h-4 w-4" />
+            {{ t("settings.sqlFormatterShortcutApply") }}
+          </Button>
+          <span v-if="jsonEditorLoading" class="text-xs text-muted-foreground">{{ t("common.loading") }}</span>
+        </div>
+
+        <div ref="jsonEditorRef" v-show="jsonEditorReady || jsonEditorLoading" class="min-h-[320px]" />
+
+        <textarea
+          v-if="!jsonEditorReady && !jsonEditorLoading"
+          :value="jsonDraft"
+          spellcheck="false"
+          class="min-h-[320px] w-full resize-y rounded-md border border-input bg-background px-3 py-2 font-mono text-xs outline-none transition-colors focus:border-ring focus:ring-1 focus:ring-ring/40"
+          @input="onJsonDraftTextareaInput"
+        />
+
+        <p v-if="jsonEditorLoadError" class="rounded-md border border-amber-300/60 bg-amber-50 px-3 py-2 text-xs text-amber-800 dark:border-amber-400/40 dark:bg-amber-950/30 dark:text-amber-200">
+          {{ t("settings.sqlFormatterJsonEditorLoadFailed", { message: jsonEditorLoadError }) }}
+        </p>
+
+        <p v-if="jsonValidationMessage" class="rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+          {{ jsonValidationMessage }}
+        </p>
+      </TabsContent>
+    </Tabs>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/editor/SqlParameterDialog.vue b/apps/desktop/src/components/editor/SqlParameterDialog.vue
new file mode 100644
index 0000000..310796f
--- /dev/null
+++ b/apps/desktop/src/components/editor/SqlParameterDialog.vue
@@ -0,0 +1,207 @@
+<script setup lang="ts">
+import { computed, nextTick, ref, watch } from "vue";
+import { Braces, Copy } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Popover, PopoverAnchor, PopoverContent } from "@/components/ui/popover";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import TruncatedTextTooltip from "@/components/ui/TruncatedTextTooltip.vue";
+import { loadSqlParameterHistory, rememberSqlParameterValues } from "@/lib/sql/sqlParameterHistory";
+import { substituteSqlParameters, type SqlParameterDescriptor, type SqlParameterInput, type SqlParameterSyntax, type SqlParameterValueKind } from "@/lib/sql/sqlParameters";
+import { useSqlHighlighter } from "@/composables/useSqlHighlighter";
+import { useToast } from "@/composables/useToast";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import type { DatabaseType } from "@/types/database";
+
+const { t } = useI18n();
+const { highlight } = useSqlHighlighter();
+const { toast } = useToast();
+
+const open = defineModel<boolean>("open", { default: false });
+
+const props = defineProps<{
+  sql: string;
+  parameters: SqlParameterDescriptor[];
+  databaseType?: DatabaseType;
+  enabledSyntaxes?: SqlParameterSyntax[];
+}>();
+
+const emit = defineEmits<{
+  execute: [sql: string];
+}>();
+
+const values = ref<Record<string, SqlParameterInput>>({});
+const histories = ref<Record<string, SqlParameterInput[]>>({});
+const activeHistoryName = ref("");
+let closeHistoryTimer: ReturnType<typeof setTimeout> | undefined;
+
+const parameterKinds: SqlParameterValueKind[] = ["string", "number", "boolean", "null", "raw"];
+
+const syntaxLabels: Record<SqlParameterSyntax, string> = {
+  positional: "?",
+  named: ":name",
+  shell: "${name}",
+  mybatis: "#{name}",
+  sqlserver: "@name",
+};
+
+const resolvedSql = computed(() => substituteSqlParameters(props.sql, values.value, { databaseType: props.databaseType, enabledSyntaxes: props.enabledSyntaxes }));
+const highlightedSql = computed(() => highlight(resolvedSql.value));
+
+watch(
+  () => [open.value, props.parameters] as const,
+  ([isOpen]) => {
+    if (!isOpen) return;
+    const next: Record<string, SqlParameterInput> = {};
+    const nextHistories: Record<string, SqlParameterInput[]> = {};
+    for (const parameter of props.parameters) {
+      const history = loadSqlParameterHistory(parameter.key);
+      nextHistories[parameter.key] = history;
+      next[parameter.key] = values.value[parameter.key] ?? history[0] ?? { kind: "string", value: "" };
+    }
+    values.value = next;
+    histories.value = nextHistories;
+  },
+  { immediate: true },
+);
+
+function updateKind(name: string, kind: SqlParameterValueKind) {
+  const current = values.value[name] ?? { value: "" };
+  const value = kind === "null" ? "NULL" : current.kind === "null" ? "" : current.value;
+  values.value[name] = { ...current, kind, value };
+}
+
+function updateValue(name: string, value: string) {
+  const matchedHistory = histories.value[name]?.find((entry) => entry.value === value);
+  values.value[name] = { ...(values.value[name] ?? { kind: "string" }), ...(matchedHistory ? { kind: matchedHistory.kind } : {}), value };
+}
+
+function filteredSqlParameterHistory(name: string): SqlParameterInput[] {
+  const history = histories.value[name] ?? [];
+  const query = values.value[name]?.value?.trim().toLowerCase() ?? "";
+  if (!query) return history;
+  return history.filter((entry) => entry.value.toLowerCase().includes(query));
+}
+
+function focusParameterInput(name: string, event: FocusEvent) {
+  if (closeHistoryTimer) clearTimeout(closeHistoryTimer);
+  activeHistoryName.value = name;
+  const input = event.target as HTMLInputElement;
+  void nextTick(() => input.focus());
+}
+
+function closeParameterHistory(name: string) {
+  closeHistoryTimer = setTimeout(() => {
+    if (activeHistoryName.value === name) activeHistoryName.value = "";
+  }, 120);
+}
+
+function selectHistoryEntry(name: string, entry: SqlParameterInput) {
+  if (closeHistoryTimer) clearTimeout(closeHistoryTimer);
+  values.value[name] = { ...entry };
+  activeHistoryName.value = "";
+}
+
+function execute() {
+  histories.value = { ...histories.value, ...rememberSqlParameterValues(values.value) };
+  open.value = false;
+  emit("execute", resolvedSql.value);
+}
+
+async function copyResolvedSql() {
+  try {
+    await copyToClipboard(resolvedSql.value);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent class="max-h-[86vh] border border-border !bg-background text-foreground shadow-2xl !backdrop-blur-none sm:max-w-[720px]">
+      <DialogHeader>
+        <DialogTitle class="flex items-center gap-2">
+          <Braces class="h-5 w-5 text-primary" />
+          {{ t("sqlParameters.title") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="grid max-h-[calc(86vh-8rem)] gap-4 overflow-y-auto pr-1">
+        <p class="text-sm text-muted-foreground">{{ t("sqlParameters.description") }}</p>
+
+        <div class="relative z-20 max-h-[302px] overflow-auto rounded-md border bg-background">
+          <div class="min-w-[680px]">
+            <div class="sticky top-0 z-10 grid grid-cols-[minmax(140px,1fr)_104px_132px_minmax(180px,1.5fr)] border-b bg-muted px-3 py-2 text-xs font-medium text-muted-foreground">
+              <div>{{ t("sqlParameters.name") }}</div>
+              <div>{{ t("sqlParameters.syntax") }}</div>
+              <div>{{ t("sqlParameters.type") }}</div>
+              <div>{{ t("sqlParameters.value") }}</div>
+            </div>
+            <div v-for="parameter in parameters" :key="parameter.key" class="grid grid-cols-[minmax(140px,1fr)_104px_132px_minmax(180px,1.5fr)] items-center gap-2 border-b px-3 py-2 text-sm last:border-b-0">
+              <div class="min-w-0 truncate font-mono text-xs">{{ parameter.name }}</div>
+              <div class="min-w-0 truncate font-mono text-[11px] text-muted-foreground">{{ syntaxLabels[parameter.syntax] }}</div>
+              <Select :model-value="values[parameter.key]?.kind || 'string'" @update:model-value="(value) => updateKind(parameter.key, value as SqlParameterValueKind)">
+                <SelectTrigger class="h-8 bg-background text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem v-for="kind in parameterKinds" :key="kind" :value="kind">
+                    {{ t(`sqlParameters.kind.${kind}`) }}
+                  </SelectItem>
+                </SelectContent>
+              </Select>
+              <div class="relative min-w-0">
+                <Popover :open="activeHistoryName === parameter.key && filteredSqlParameterHistory(parameter.key).length > 0">
+                  <PopoverAnchor as-child>
+                    <Input
+                      :model-value="values[parameter.key]?.value || ''"
+                      class="h-8 bg-background font-mono text-xs"
+                      :disabled="values[parameter.key]?.kind === 'null'"
+                      autocomplete="off"
+                      data-lpignore="true"
+                      data-form-type="other"
+                      :placeholder="t('sqlParameters.valuePlaceholder')"
+                      @focus="focusParameterInput(parameter.key, $event)"
+                      @blur="closeParameterHistory(parameter.key)"
+                      @update:model-value="(value) => updateValue(parameter.key, String(value))"
+                    />
+                  </PopoverAnchor>
+                  <PopoverContent align="start" side="bottom" class="z-[80] w-[var(--reka-popover-trigger-width)] max-h-40 gap-0 overflow-auto p-1" @open-auto-focus.prevent>
+                    <button
+                      v-for="entry in filteredSqlParameterHistory(parameter.key)"
+                      :key="`${entry.kind}:${entry.value}`"
+                      type="button"
+                      class="flex w-full min-w-0 items-center justify-between gap-2 rounded px-2 py-1 text-left text-xs hover:bg-accent hover:text-accent-foreground"
+                      @mousedown.prevent="selectHistoryEntry(parameter.key, entry)"
+                    >
+                      <TruncatedTextTooltip :text="entry.value" class="min-w-0 flex-1 font-mono" side="top" :delay="150" />
+                      <span class="shrink-0 text-[10px] uppercase text-muted-foreground">{{ t(`sqlParameters.kind.${entry.kind}`) }}</span>
+                    </button>
+                  </PopoverContent>
+                </Popover>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <div class="relative z-10 grid gap-2">
+          <div class="text-xs font-medium text-muted-foreground">{{ t("sqlParameters.preview") }}</div>
+          <pre class="max-h-48 min-w-0 overflow-auto rounded-md bg-muted px-3 py-3 text-xs font-mono whitespace-pre" v-html="highlightedSql" />
+        </div>
+      </div>
+
+      <DialogFooter>
+        <Button variant="outline" @click="open = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button variant="outline" @click="copyResolvedSql">
+          <Copy class="mr-1.5 h-4 w-4" />
+          {{ t("grid.copy") }}
+        </Button>
+        <Button @click="execute">{{ t("sqlParameters.execute") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/editor/SqlPreviewPanel.vue b/apps/desktop/src/components/editor/SqlPreviewPanel.vue
new file mode 100644
index 0000000..a12c3cc
--- /dev/null
+++ b/apps/desktop/src/components/editor/SqlPreviewPanel.vue
@@ -0,0 +1,211 @@
+<script setup lang="ts">
+import { ref, computed, watch, onMounted, onBeforeUnmount, nextTick } from "vue";
+import { useI18n } from "vue-i18n";
+import { AlignLeft, Copy, ChevronDown, Undo2, Redo2 } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Tooltip, TooltipTrigger, TooltipContent } from "@/components/ui/tooltip";
+import { useTheme } from "@/composables/useTheme";
+import { useToast } from "@/composables/useToast";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { formatSqlText, type SqlFormatDialect } from "@/lib/sql/sqlFormatter";
+import type { Highlighter } from "shiki";
+
+const props = defineProps<{
+  sql: string;
+  sqlFormatDialect?: SqlFormatDialect;
+  loading?: boolean;
+  canUndo?: boolean;
+  canRedo?: boolean;
+}>();
+
+const emit = defineEmits<{
+  close: [];
+  undo: [];
+  redo: [];
+}>();
+
+const { t } = useI18n();
+const { isDark } = useTheme();
+const { toast } = useToast();
+
+const isFormatted = ref(false);
+const formattedSql = ref("");
+const formatting = ref(false);
+const highlightedHtml = ref("");
+const highlighterReady = ref(false);
+
+let highlighter: Highlighter | null = null;
+
+const displaySql = computed(() => {
+  if (isFormatted.value && formattedSql.value) {
+    return formattedSql.value;
+  }
+  return props.sql;
+});
+
+const hasSql = computed(() => props.sql.trim().length > 0);
+
+async function initHighlighter() {
+  if (highlighter) return;
+  try {
+    const { createHighlighter } = await import("shiki");
+    highlighter = await createHighlighter({
+      themes: ["dark-plus", "min-light"],
+      langs: ["sql"],
+    });
+    highlighterReady.value = true;
+    await highlightSql();
+  } catch (e) {
+    console.error("[DBX][SqlPreviewPanel] Failed to init shiki:", e);
+  }
+}
+
+async function highlightSql() {
+  if (!highlighter || !displaySql.value) return;
+  try {
+    const theme = isDark.value ? "dark-plus" : "min-light";
+    highlightedHtml.value = highlighter.codeToHtml(displaySql.value, {
+      lang: "sql",
+      theme,
+    });
+  } catch {
+    // fallback to plain text
+    highlightedHtml.value = "";
+  }
+}
+
+async function toggleFormat() {
+  if (formatting.value || !hasSql.value) return;
+  if (isFormatted.value) {
+    isFormatted.value = false;
+    await highlightSql();
+    return;
+  }
+
+  formatting.value = true;
+  try {
+    formattedSql.value = await formatSqlText(props.sql, props.sqlFormatDialect ?? "generic");
+    isFormatted.value = true;
+    await highlightSql();
+  } catch {
+    toast(t("toolbar.formatSqlFailed"), 3000);
+  } finally {
+    formatting.value = false;
+  }
+}
+
+async function handleCopy() {
+  const text = displaySql.value;
+  if (!text.trim()) return;
+  try {
+    await copyToClipboard(text);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+watch(
+  () => props.sql,
+  async (newSql) => {
+    isFormatted.value = false;
+    formattedSql.value = "";
+    if (highlighterReady.value && newSql.trim()) {
+      await highlightSql();
+    }
+  },
+);
+
+watch(isDark, async () => {
+  if (highlighterReady.value && displaySql.value) {
+    await highlightSql();
+  }
+});
+
+watch(displaySql, async () => {
+  if (highlighterReady.value) {
+    await highlightSql();
+  }
+});
+
+onMounted(() => {
+  nextTick(() => {
+    void initHighlighter();
+  });
+});
+
+onBeforeUnmount(() => {
+  highlighter?.dispose();
+  highlighter = null;
+  highlighterReady.value = false;
+});
+</script>
+
+<template>
+  <div class="h-full flex flex-col bg-background border-t">
+    <!-- Header bar -->
+    <div class="h-8 shrink-0 border-b bg-muted/30 px-2 flex items-center gap-1 text-xs text-muted-foreground">
+      <span class="font-medium text-muted-foreground/70 select-none">SQL</span>
+      <span class="flex-1 min-w-0" />
+      <Tooltip>
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6" :class="isFormatted ? 'text-amber-600 bg-amber-500/10' : 'text-amber-600/60 hover:text-amber-700 hover:bg-amber-500/10'" :disabled="formatting || !hasSql" :aria-label="t('toolbar.formatSql')" @click="toggleFormat">
+            <AlignLeft class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("toolbar.formatSql") }}</TooltipContent>
+      </Tooltip>
+      <Tooltip>
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6 text-muted-foreground/60 hover:text-foreground hover:bg-accent" :disabled="!canUndo" :aria-label="t('grid.undoChange')" @click="emit('undo')">
+            <Undo2 class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("grid.undoChange") }}</TooltipContent>
+      </Tooltip>
+      <Tooltip>
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6 text-muted-foreground/60 hover:text-foreground hover:bg-accent" :disabled="!canRedo" :aria-label="t('grid.redoChange')" @click="emit('redo')">
+            <Redo2 class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("grid.redoChange") }}</TooltipContent>
+      </Tooltip>
+      <Tooltip>
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6 text-muted-foreground/60 hover:text-foreground hover:bg-accent" :disabled="!hasSql" :aria-label="t('grid.copy')" @click="handleCopy">
+            <Copy class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("grid.copy") }}</TooltipContent>
+      </Tooltip>
+      <Tooltip>
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6 text-muted-foreground/60 hover:text-foreground hover:bg-accent" :aria-label="t('toolbar.hidePreviewSql')" @click="emit('close')">
+            <ChevronDown class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("toolbar.hidePreviewSql") }}</TooltipContent>
+      </Tooltip>
+    </div>
+
+    <!-- Content -->
+    <div class="flex-1 min-h-0 overflow-auto">
+      <!-- Loading -->
+      <div v-if="loading" class="flex items-center justify-center h-full text-xs text-muted-foreground">
+        {{ t("common.loading") }}
+      </div>
+
+      <!-- Empty -->
+      <div v-else-if="!hasSql" class="flex items-center justify-center h-full text-xs text-muted-foreground">
+        {{ t("grid.previewSqlEmpty") }}
+      </div>
+
+      <!-- Shiki highlighted SQL -->
+      <div v-else-if="highlightedHtml" data-native-clipboard class="p-3 text-xs leading-relaxed [&_pre]:!bg-transparent [&_pre]:!p-0 [&_code]:!font-mono [&_code]:text-xs" v-html="highlightedHtml" />
+
+      <!-- Plain text fallback -->
+      <pre v-else data-native-clipboard class="p-3 text-xs font-mono whitespace-pre-wrap select-text">{{ displaySql }}</pre>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/editor/ThemeCustomizerDialog.vue b/apps/desktop/src/components/editor/ThemeCustomizerDialog.vue
new file mode 100644
index 0000000..90b270f
--- /dev/null
+++ b/apps/desktop/src/components/editor/ThemeCustomizerDialog.vue
@@ -0,0 +1,570 @@
+<script setup lang="ts">
+import { ref, watch, computed } from "vue";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { Input } from "@/components/ui/input";
+import type { CustomTheme, CustomThemeColors } from "@/stores/settingsStore";
+import { DEFAULT_CUSTOM_THEME_COLORS, DEFAULT_CUSTOM_THEME_DDL_COLORS } from "@/stores/settingsStore";
+import { Plus, Trash2, Copy, Pencil, ChevronDown, Palette } from "@lucide/vue";
+import { useToast } from "@/composables/useToast";
+import { useI18n } from "vue-i18n";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+
+interface Props {
+  open: boolean;
+  themes: CustomTheme[];
+  activeThemeId: string;
+}
+
+const props = defineProps<Props>();
+const emit = defineEmits<{
+  (e: "update:open", value: boolean): void;
+  (e: "save", themes: CustomTheme[], activeId: string): void;
+}>();
+
+const { toast } = useToast();
+const { t } = useI18n();
+
+const localThemes = ref<CustomTheme[]>([]);
+const activeEditId = ref("");
+const jsonText = ref("");
+const renamingId = ref<string | null>(null);
+const renamingName = ref("");
+
+watch(
+  () => props.open,
+  (isOpen) => {
+    if (isOpen) {
+      localThemes.value = JSON.parse(JSON.stringify(props.themes));
+      activeEditId.value = props.activeThemeId;
+      syncJson();
+    }
+  },
+);
+
+function syncJson() {
+  const theme = localThemes.value.find((t) => t.id === activeEditId.value);
+  jsonText.value = JSON.stringify(theme?.colors ?? DEFAULT_CUSTOM_THEME_COLORS, null, 2);
+}
+
+watch(activeEditId, syncJson);
+
+const activeTheme = computed(() => localThemes.value.find((t) => t.id === activeEditId.value));
+
+const localColors = computed({
+  get: () => activeTheme.value?.colors ?? { ...DEFAULT_CUSTOM_THEME_COLORS },
+  set: (colors: CustomThemeColors) => {
+    const theme = localThemes.value.find((t) => t.id === activeEditId.value);
+    if (theme) theme.colors = { ...colors };
+  },
+});
+
+watch(
+  localThemes,
+  () => {
+    syncJson();
+  },
+  { deep: true },
+);
+
+const colorItems = [
+  { key: "keyword" as const, label: t("settings.customThemeKeyword"), example: "SELECT, WHERE, IF", num: "①" },
+  { key: "field" as const, label: t("settings.customThemeField"), example: "id, name, _var", num: "②" },
+  { key: "function" as const, label: t("settings.customThemeFunction"), example: "count, upper", num: "③" },
+  { key: "string" as const, label: t("settings.customThemeString"), example: "'hello', 'world'", num: "④" },
+  { key: "number" as const, label: t("settings.customThemeNumber"), example: "100, 3.14", num: "⑤" },
+  { key: "comment" as const, label: t("settings.customThemeComment"), example: "--, /* */", num: "⑥" },
+  { key: "table" as const, label: t("settings.customThemeTable"), example: "users, orders", num: "⑦" },
+  { key: "operator" as const, label: t("settings.customThemeOperator"), example: "=, >, <>", num: "⑧" },
+  { key: "type" as const, label: t("settings.customThemeType"), example: "INTEGER, TEXT", num: "⑨" },
+  { key: "builtin" as const, label: t("settings.customThemeBuiltin"), example: "FOUND, SQLERRM", num: "⑩" },
+  { key: "background" as const, label: t("settings.customThemeBackground"), example: "Editor background", num: "⑪" },
+  { key: "foreground" as const, label: t("settings.customThemeForeground"), example: "Default text color", num: "⑫" },
+];
+
+// Preset color themes (including all built-in themes)
+const presetThemes = [
+  {
+    name: "Default",
+    colors: { ...DEFAULT_CUSTOM_THEME_COLORS },
+  },
+  {
+    name: "One Dark",
+    colors: {
+      keyword: "#c678dd",
+      field: "#e06c75",
+      function: "#61afef",
+      string: "#98c379",
+      number: "#d19a66",
+      comment: "#5c6370",
+      table: "#98c379",
+      operator: "#56b6c2",
+      type: "#e5c07b",
+      builtin: "#61afef",
+      background: "#282c34",
+      foreground: "#abb2bf",
+    },
+  },
+  {
+    name: "VS Code Dark+",
+    colors: {
+      keyword: "#569cd6",
+      field: "#9cdcfe",
+      function: "#dcdcaa",
+      string: "#ce9178",
+      number: "#b5cea8",
+      comment: "#6a9955",
+      table: "#ce9178",
+      operator: "#d4d4d4",
+      type: "#4ec9b0",
+      builtin: "#dcdcaa",
+      background: "#1e1e1e",
+      foreground: "#9cdcfe",
+    },
+  },
+  {
+    name: "Nord",
+    colors: {
+      keyword: "#5e81ac",
+      field: "#88c0d0",
+      function: "#8fbcbb",
+      string: "#a3be8c",
+      number: "#b48ead",
+      comment: "#4c566a",
+      table: "#a3be8c",
+      operator: "#a3be8c",
+      type: "#ebcb8b",
+      builtin: "#8fbcbb",
+      background: "#2e3440",
+      foreground: "#d8dee9",
+    },
+  },
+  {
+    name: "Okaidia",
+    colors: {
+      keyword: "#f92672",
+      field: "#a6e22e",
+      function: "#fd971f",
+      string: "#e6db74",
+      number: "#ae81ff",
+      comment: "#8292a2",
+      table: "#e6db74",
+      operator: "#f92672",
+      type: "#66d9ef",
+      builtin: "#fd971f",
+      background: "#272822",
+      foreground: "#f8f8f2",
+    },
+  },
+  {
+    name: "Material",
+    colors: {
+      keyword: "#cf6edf",
+      field: "#56c8d8",
+      function: "#56c8d8",
+      string: "#a3be8c",
+      number: "#ffad42",
+      comment: "#808080",
+      table: "#a3be8c",
+      operator: "#cf6edf",
+      type: "#ffad42",
+      builtin: "#56c8d8",
+      background: "#2e3235",
+      foreground: "#bdbdbd",
+    },
+  },
+  {
+    name: "Dracula",
+    colors: {
+      keyword: "#ff79c6",
+      field: "#8be9fd",
+      function: "#50fa7b",
+      string: "#f1fa8c",
+      number: "#bd93f9",
+      comment: "#6272a4",
+      table: "#f1fa8c",
+      operator: "#ff79c6",
+      type: "#8be9fd",
+      builtin: "#50fa7b",
+      background: "#282a36",
+      foreground: "#f8f8f2",
+    },
+  },
+  {
+    name: "Solarized Dark",
+    colors: {
+      keyword: "#cb4b16",
+      field: "#268bd2",
+      function: "#b58900",
+      string: "#2aa198",
+      number: "#d33682",
+      comment: "#586e75",
+      table: "#2aa198",
+      operator: "#cb4b16",
+      type: "#859900",
+      builtin: "#b58900",
+      background: "#002b36",
+      foreground: "#839496",
+    },
+  },
+  {
+    name: "VS Code Light+",
+    colors: {
+      keyword: "#0000ff",
+      field: "#001080",
+      function: "#795e26",
+      string: "#a31515",
+      number: "#098658",
+      comment: "#008000",
+      table: "#a31515",
+      operator: "#000000",
+      type: "#267f99",
+      builtin: "#795e26",
+      background: "#ffffff",
+      foreground: "#000000",
+    },
+  },
+  {
+    name: "Duotone Light",
+    colors: {
+      keyword: "#6e4cbd",
+      field: "#1a1a1a",
+      function: "#6e4cbd",
+      string: "#6e4cbd",
+      number: "#6e4cbd",
+      comment: "#a0a0a0",
+      table: "#6e4cbd",
+      operator: "#1a1a1a",
+      type: "#6e4cbd",
+      builtin: "#6e4cbd",
+      background: "#faf8f5",
+      foreground: "#1a1a1a",
+    },
+  },
+  {
+    name: "Duotone Dark",
+    colors: {
+      keyword: "#9375f5",
+      field: "#ddd",
+      function: "#9375f5",
+      string: "#9375f5",
+      number: "#9375f5",
+      comment: "#777",
+      table: "#9375f5",
+      operator: "#ddd",
+      type: "#9375f5",
+      builtin: "#9375f5",
+      background: "#2a2734",
+      foreground: "#ddd",
+    },
+  },
+  {
+    name: "Xcode",
+    colors: {
+      keyword: "#ad3da4",
+      field: "#5c2699",
+      function: "#3d1c77",
+      string: "#d12f1b",
+      number: "#272ad8",
+      comment: "#9ba2aa",
+      table: "#d12f1b",
+      operator: "#000000",
+      type: "#234d97",
+      builtin: "#3d1c77",
+      background: "#ffffff",
+      foreground: "#000000",
+    },
+  },
+];
+
+const selectedPreset = ref("");
+
+function applyPreset() {
+  const preset = presetThemes.find((p) => p.name === selectedPreset.value);
+  if (!preset) return;
+
+  const theme = localThemes.value.find((t) => t.id === activeEditId.value);
+  if (theme) {
+    theme.colors = { ...DEFAULT_CUSTOM_THEME_COLORS, ...preset.colors };
+    toast(t("settings.customThemeApplied", { name: preset.name }), 2000);
+  }
+}
+
+// Basic palette colors (similar to Windows color picker)
+const basicColors = [
+  ["#000000", "#7f7f7f", "#880015", "#ed1c24", "#ff7f27", "#fff200", "#22b14c", "#00a2e8"],
+  ["#3f48cc", "#a349a4", "#ffffff", "#c3c3c3", "#b97a57", "#ffaec9", "#ffc90e", "#efe4b0"],
+];
+
+const expandedPalette = ref<string | null>(null);
+
+function togglePalette(key: string) {
+  expandedPalette.value = expandedPalette.value === key ? null : key;
+}
+
+function applyBasicColor(key: keyof CustomThemeColors, color: string) {
+  handleColorChange(key, color);
+  expandedPalette.value = null;
+}
+
+const previewCode = computed(() => {
+  const c = localColors.value;
+  return [
+    { text: "SELECT ", color: c.keyword, num: "①" },
+    { text: "id", color: c.field, num: "②" },
+    { text: ", ", color: c.operator, num: "⑧" },
+    { text: "count", color: c.function, num: "③" },
+    { text: "(*) ", color: c.operator, num: "⑧" },
+    { text: "FROM ", color: c.keyword, num: "①" },
+    { text: "users", color: c.table, num: "⑦" },
+    { text: " ", color: "", num: "" },
+    { text: "WHERE ", color: c.keyword, num: "①" },
+    { text: "status", color: c.field, num: "②" },
+    { text: " = ", color: c.operator, num: "⑧" },
+    { text: "'active'", color: c.string, num: "④" },
+    { text: " ", color: "", num: "" },
+    { text: "AND ", color: c.keyword, num: "①" },
+    { text: "id", color: c.field, num: "②" },
+    { text: " > ", color: c.operator, num: "⑧" },
+    { text: "100", color: c.number, num: "⑤" },
+    { text: ";", color: c.operator, num: "⑧" },
+  ];
+});
+
+function handleColorChange(key: keyof CustomThemeColors, value: string) {
+  const theme = localThemes.value.find((t) => t.id === activeEditId.value);
+  if (theme) {
+    theme.colors = { ...theme.colors, [key]: value };
+  }
+}
+
+function handleJsonChange() {
+  try {
+    const parsed = JSON.parse(jsonText.value);
+    const theme = localThemes.value.find((t) => t.id === activeEditId.value);
+    if (theme) {
+      theme.colors = { ...DEFAULT_CUSTOM_THEME_COLORS, ...parsed };
+    }
+  } catch {
+    // Invalid JSON, ignore
+  }
+}
+
+function handleSave() {
+  emit(
+    "save",
+    localThemes.value.map((t) => ({ ...t })),
+    activeEditId.value,
+  );
+  emit("update:open", false);
+}
+
+function handleAddTheme() {
+  const id = `custom-${Date.now()}`;
+  const name = `${t("settings.customThemeDefaultName")} ${localThemes.value.length + 1}`;
+  localThemes.value.push({
+    id,
+    name,
+    colors: { ...DEFAULT_CUSTOM_THEME_COLORS },
+    ddlColors: { ...DEFAULT_CUSTOM_THEME_DDL_COLORS },
+  });
+  activeEditId.value = id;
+}
+
+function handleDeleteTheme(id: string) {
+  if (localThemes.value.length <= 1) {
+    toast(t("settings.customThemeKeepOne"), 3000);
+    return;
+  }
+  localThemes.value = localThemes.value.filter((t) => t.id !== id);
+  if (activeEditId.value === id) {
+    activeEditId.value = localThemes.value[0]?.id ?? "";
+  }
+}
+
+function handleDuplicateTheme(theme: CustomTheme) {
+  const id = `custom-${Date.now()}`;
+  localThemes.value.push({
+    id,
+    name: `${theme.name}${t("settings.customThemeCopySuffix")}`,
+    colors: { ...theme.colors },
+    ddlColors: { ...(theme.ddlColors ?? DEFAULT_CUSTOM_THEME_DDL_COLORS) },
+  });
+  activeEditId.value = id;
+}
+
+function startRename(theme: CustomTheme) {
+  renamingId.value = theme.id;
+  renamingName.value = theme.name;
+}
+
+function confirmRename() {
+  if (!renamingId.value) return;
+  const theme = localThemes.value.find((t) => t.id === renamingId.value);
+  if (theme && renamingName.value.trim()) {
+    theme.name = renamingName.value.trim();
+  }
+  renamingId.value = null;
+  renamingName.value = "";
+}
+
+function cancelRename() {
+  renamingId.value = null;
+  renamingName.value = "";
+}
+
+function handleExport() {
+  const theme = localThemes.value.find((t) => t.id === activeEditId.value);
+  if (!theme) return;
+  const blob = new Blob([JSON.stringify(theme.colors, null, 2)], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = `dbx-theme-${theme.name}.json`;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+function handleImport() {
+  try {
+    const parsed = JSON.parse(jsonText.value);
+    const theme = localThemes.value.find((t) => t.id === activeEditId.value);
+    if (theme) {
+      theme.colors = { ...DEFAULT_CUSTOM_THEME_COLORS, ...parsed };
+    }
+  } catch (e) {
+    toast(t("settings.customThemeJsonError"), 3000);
+  }
+}
+</script>
+
+<template>
+  <Dialog :open="open" @update:open="emit('update:open', $event)">
+    <DialogContent class="sm:max-w-[860px] max-h-[90vh] overflow-hidden flex flex-col">
+      <DialogHeader>
+        <DialogTitle>{{ t("settings.customThemeTitle") }}</DialogTitle>
+      </DialogHeader>
+
+      <div class="flex-1 min-h-0 flex gap-4">
+        <!-- Theme list sidebar -->
+        <div class="w-48 shrink-0 flex flex-col gap-2">
+          <div class="text-sm font-medium px-1">{{ t("settings.customThemeMyThemes") }}</div>
+          <div class="flex-1 overflow-y-auto space-y-1 pr-1">
+            <div v-for="theme in localThemes" :key="theme.id" class="group flex items-center gap-2 rounded-md px-2 py-1.5 cursor-pointer text-sm" :class="activeEditId === theme.id ? 'bg-primary text-primary-foreground' : 'hover:bg-muted'" @click="activeEditId = theme.id">
+              <div class="flex-1 min-w-0">
+                <div v-if="renamingId === theme.id" class="flex items-center gap-1" @click.stop>
+                  <Input v-model="renamingName" class="h-6 text-xs px-1 py-0" @keydown.enter="confirmRename" @keydown.esc="cancelRename" @blur="confirmRename" autofocus />
+                </div>
+                <div v-else class="truncate">{{ theme.name }}</div>
+              </div>
+              <div class="flex items-center gap-0.5 opacity-0 group-hover:opacity-100 transition-opacity">
+                <Button variant="ghost" size="icon" class="h-5 w-5" @click.stop="startRename(theme)">
+                  <Pencil class="h-3 w-3" />
+                </Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5" @click.stop="handleDuplicateTheme(theme)">
+                  <Copy class="h-3 w-3" />
+                </Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5" @click.stop="handleDeleteTheme(theme.id)">
+                  <Trash2 class="h-3 w-3" />
+                </Button>
+              </div>
+            </div>
+          </div>
+          <Button variant="outline" size="sm" class="w-full gap-1" @click="handleAddTheme">
+            <Plus class="h-4 w-4" />
+            {{ t("settings.customThemeNewTheme") }}
+          </Button>
+        </div>
+
+        <!-- Edit area -->
+        <div class="flex-1 min-w-0 min-h-0 overflow-hidden flex flex-col">
+          <Tabs defaultValue="visual" class="w-full flex-1 min-h-0 flex flex-col">
+            <TabsList class="grid w-full grid-cols-2">
+              <TabsTrigger value="visual">{{ t("settings.customThemeVisualEdit") }}</TabsTrigger>
+              <TabsTrigger value="json">{{ t("settings.customThemeJsonConfig") }}</TabsTrigger>
+            </TabsList>
+
+            <TabsContent value="visual" class="space-y-4 flex-1 min-h-0 overflow-y-auto pr-1">
+              <!-- Preview area -->
+              <div class="rounded-lg border bg-black/50 p-5 font-mono text-base">
+                <div class="mb-2 text-sm text-muted-foreground">{{ t("settings.customThemeLivePreview") }}</div>
+                <div class="leading-relaxed text-lg">
+                  <span v-for="(token, i) in previewCode" :key="i" :style="{ color: token.color }" class="inline">
+                    {{ token.text }}<sup v-if="token.num" class="text-xl opacity-60">{{ token.num }}</sup>
+                  </span>
+                </div>
+                <div class="mt-2 text-lg" :style="{ color: localColors.comment }"><sup class="text-xl">⑥</sup> -- {{ t("settings.customThemePreviewExample") }}</div>
+              </div>
+
+              <!-- Preset color schemes -->
+              <div class="flex items-center gap-2 rounded-lg border p-3 bg-muted/30">
+                <Palette class="h-4 w-4 text-muted-foreground shrink-0" />
+                <span class="text-sm text-muted-foreground shrink-0">{{ t("settings.customThemePreset") }}:</span>
+                <Select v-model="selectedPreset" class="flex-1">
+                  <SelectTrigger class="h-8 text-sm">
+                    <SelectValue :placeholder="t('settings.customThemeSelectPreset')" />
+                  </SelectTrigger>
+                  <SelectContent>
+                    <SelectItem v-for="preset in presetThemes" :key="preset.name" :value="preset.name">
+                      {{ preset.name }}
+                    </SelectItem>
+                  </SelectContent>
+                </Select>
+                <Button variant="outline" size="sm" class="h-8 shrink-0" @click="applyPreset">
+                  <Copy class="mr-1 h-3 w-3" />
+                  {{ t("settings.customThemeApply") }}
+                </Button>
+              </div>
+
+              <!-- Color configuration list -->
+              <div class="grid grid-cols-2 gap-3">
+                <div v-for="item in colorItems" :key="item.key" class="relative flex items-center gap-3 rounded-lg border p-3">
+                  <span class="text-xl font-bold w-8 text-center shrink-0">{{ item.num }}</span>
+                  <div class="flex-1 min-w-0">
+                    <div class="font-medium text-sm">{{ item.label }}</div>
+                    <div class="text-xs text-muted-foreground truncate">{{ item.example }}</div>
+                  </div>
+                  <div class="flex items-center gap-2 shrink-0">
+                    <!-- Color square + dropdown arrow -->
+                    <div class="relative">
+                      <button type="button" class="flex items-center gap-0.5 rounded border p-0.5 hover:bg-muted transition-colors" @click.stop="togglePalette(item.key)">
+                        <div class="h-6 w-6 rounded-sm" :style="{ backgroundColor: localColors[item.key] }" />
+                        <ChevronDown class="h-3 w-3 text-muted-foreground pointer-events-none" />
+                      </button>
+                      <!-- Palette popup -->
+                      <div v-if="expandedPalette === item.key" class="absolute right-0 top-full z-50 mt-1 rounded-lg border bg-popover p-2 shadow-lg" @click.stop>
+                        <div class="space-y-1">
+                          <div v-for="(row, rowIndex) in basicColors" :key="rowIndex" class="flex gap-1">
+                            <button v-for="color in row" :key="color" type="button" class="h-5 w-5 rounded-sm border border-border/50 hover:scale-110 transition-transform" :style="{ backgroundColor: color }" @click="applyBasicColor(item.key, color)" />
+                          </div>
+                        </div>
+                        <div class="mt-2 pt-2 border-t flex items-center gap-2">
+                          <input type="color" :value="localColors[item.key]" @input="handleColorChange(item.key, ($event.target as HTMLInputElement).value)" class="h-6 w-6 cursor-pointer rounded border-0 p-0" />
+                          <input type="text" :value="localColors[item.key]" @input="handleColorChange(item.key, ($event.target as HTMLInputElement).value)" class="w-20 rounded border px-2 py-0.5 text-xs font-mono" />
+                        </div>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              </div>
+            </TabsContent>
+
+            <TabsContent value="json" class="space-y-4 flex-1 min-h-0 flex flex-col">
+              <textarea v-model="jsonText" @blur="handleJsonChange" class="flex-1 w-full rounded-[6px] border bg-black/50 p-4 font-mono text-sm min-h-[360px]" spellcheck="false" />
+              <div class="flex gap-2">
+                <Button variant="outline" size="sm" @click="handleImport">{{ t("settings.customThemePasteImport") }}</Button>
+                <Button variant="outline" size="sm" @click="handleExport">{{ t("settings.customThemeExportJson") }}</Button>
+              </div>
+            </TabsContent>
+          </Tabs>
+        </div>
+      </div>
+
+      <DialogFooter class="gap-2">
+        <Button variant="outline" @click="emit('update:open', false)">{{ t("settings.cancel") }}</Button>
+        <Button @click="handleSave">{{ t("settings.customThemeSaveAndApply") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/etcd/EtcdKeyBrowser.vue b/apps/desktop/src/components/etcd/EtcdKeyBrowser.vue
new file mode 100644
index 0000000..29249de
--- /dev/null
+++ b/apps/desktop/src/components/etcd/EtcdKeyBrowser.vue
@@ -0,0 +1,52 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import KvKeyBrowser from "@/components/kv/KvKeyBrowser.vue";
+import * as api from "@/lib/backend/api";
+
+const props = defineProps<{ connectionId: string }>();
+
+const { t } = useI18n();
+const browserRef = ref<InstanceType<typeof KvKeyBrowser> | null>(null);
+
+const etcdApi = {
+  listPrefix: api.etcdListPrefix,
+  get: api.etcdGet,
+  put: (connectionId: string, key: string, value: api.KvValue) => api.etcdPut(connectionId, key, value),
+  deleteKey: api.etcdDelete,
+};
+
+const labels = computed(() => ({
+  prefixPlaceholder: t("etcd.prefixPlaceholder"),
+  newKey: t("etcd.newKey"),
+  loadingKeys: t("etcd.loadingKeys"),
+  empty: t("etcd.empty"),
+  loadMore: t("etcd.loadMore"),
+  selectKey: t("etcd.selectKey"),
+  loadingValue: t("etcd.loadingValue"),
+  notFound: t("etcd.notFound"),
+  edit: t("etcd.edit"),
+  editKey: t("etcd.editKey"),
+  delete: t("etcd.delete"),
+  deleteTitle: t("etcd.deleteTitle"),
+  keyPlaceholder: t("etcd.keyPlaceholder"),
+  keyRequired: t("etcd.keyRequired"),
+  saved: t("etcd.saved"),
+  deleted: t("etcd.deleted"),
+  base64Readonly: t("etcd.base64Readonly"),
+}));
+
+function focusSearch(): boolean {
+  return browserRef.value?.focusSearch() ?? false;
+}
+
+function refresh(): boolean {
+  return browserRef.value?.refresh() ?? false;
+}
+
+defineExpose({ focusSearch, refresh });
+</script>
+
+<template>
+  <KvKeyBrowser ref="browserRef" :connection-id="props.connectionId" :api="etcdApi" :labels="labels" />
+</template>
diff --git a/apps/desktop/src/components/explain/ExplainPlanNodeTree.vue b/apps/desktop/src/components/explain/ExplainPlanNodeTree.vue
new file mode 100644
index 0000000..b8cd765
--- /dev/null
+++ b/apps/desktop/src/components/explain/ExplainPlanNodeTree.vue
@@ -0,0 +1,57 @@
+<script setup lang="ts">
+import { ref } from "vue";
+import { ChevronRight, ChevronDown } from "@lucide/vue";
+import type { ExplainPlanNode } from "@/lib/diagram/explainPlan";
+
+const props = defineProps<{
+  node: ExplainPlanNode;
+  depth?: number;
+}>();
+
+const collapsed = ref(false);
+
+function toggle() {
+  if (props.node.children.length > 0) {
+    collapsed.value = !collapsed.value;
+  }
+}
+
+function actualRowsFromDetails(): string | undefined {
+  for (const d of props.node.details) {
+    const m = d.match(/Actual Rows:\s*(\S+)/);
+    if (m) return m[1];
+  }
+  return undefined;
+}
+
+const actualRows = actualRowsFromDetails();
+const hasActualStats = !!actualRows;
+const rowDiffers = hasActualStats && actualRows !== props.node.rows;
+</script>
+
+<template>
+  <div>
+    <!-- Single line: collapse icon + title + badges all in one row -->
+    <div class="flex cursor-pointer items-center gap-1 rounded border bg-background px-2 py-1 text-xs hover:bg-muted/30" :class="{ 'border-green-300 dark:border-green-700': hasActualStats }" @click="toggle">
+      <ChevronRight v-if="node.children.length > 0 && collapsed" class="h-3 w-3 shrink-0 text-muted-foreground" />
+      <ChevronDown v-else-if="node.children.length > 0" class="h-3 w-3 shrink-0 text-muted-foreground" />
+
+      <span class="shrink-0 rounded bg-muted px-1 py-0.5 font-medium">{{ node.nodeType }}</span>
+      <span v-if="node.relation" class="shrink-0 truncate max-w-[120px] text-blue-600 dark:text-blue-400">{{ node.relation }}</span>
+      <span v-if="node.index" class="shrink-0 text-emerald-600 dark:text-emerald-400">[{{ node.index }}]</span>
+      <span v-if="node.cost" class="shrink-0 tabular-nums text-muted-foreground">c:{{ node.cost }}</span>
+      <span v-if="node.rows" class="shrink-0 tabular-nums text-amber-600 dark:text-amber-400">e:{{ node.rows }}</span>
+      <span v-if="hasActualStats" class="shrink-0 tabular-nums font-semibold" :class="rowDiffers ? 'text-green-600 dark:text-green-400' : 'text-muted-foreground'"
+        >a:{{ actualRows }}<span v-if="rowDiffers">({{ Math.round((Number(actualRows) / Number(node.rows)) * 100) }}%)</span></span
+      >
+
+      <!-- Details collapsed into tooltip on hover -->
+      <span v-if="node.details.length" class="ml-auto shrink-0 overflow-hidden text-ellipsis whitespace-nowrap text-muted-foreground/40" :title="node.details.join('\n')">{{ node.details.join(" ") }}</span>
+    </div>
+
+    <!-- Children (collapsible) -->
+    <div v-if="node.children.length && !collapsed" class="ml-3 mt-px space-y-px border-l pl-2">
+      <ExplainPlanNodeTree v-for="child in node.children" :key="child.id" :node="child" :depth="(depth || 0) + 1" />
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/explain/ExplainPlanViewer.vue b/apps/desktop/src/components/explain/ExplainPlanViewer.vue
new file mode 100644
index 0000000..8a0caf3
--- /dev/null
+++ b/apps/desktop/src/components/explain/ExplainPlanViewer.vue
@@ -0,0 +1,171 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { AlertCircle, Braces, GitBranch, Table2, FileText } from "@lucide/vue";
+import type { ParsedExplainPlan, ExplainPlanNode } from "@/lib/diagram/explainPlan";
+import { flattenExplainPlanNodes } from "@/lib/diagram/explainPlan";
+import { Button } from "@/components/ui/button";
+import type { QueryResult } from "@/types/database";
+import ExplainPlanNodeTree from "./ExplainPlanNodeTree.vue";
+
+const props = defineProps<{
+  plan?: ParsedExplainPlan;
+  error?: string;
+  loading?: boolean;
+  sourceSql?: string;
+  explainSql?: string;
+  tableResult?: QueryResult;
+  tableError?: string;
+}>();
+
+const { t } = useI18n();
+const activeView = ref<"tree" | "summary" | "raw" | "table">("tree");
+const hasTableView = computed(() => !!props.tableResult || !!props.tableError);
+
+watch(hasTableView, (available) => {
+  if (!available && activeView.value === "table") activeView.value = "tree";
+});
+
+const flatRows = computed(() => {
+  const rows: Array<{ node: ExplainPlanNode; depth: number }> = [];
+  function visit(node: ExplainPlanNode, depth: number) {
+    rows.push({ node, depth });
+    node.children.forEach((child) => visit(child, depth + 1));
+  }
+  props.plan?.nodes.forEach((node) => visit(node, 0));
+  return rows;
+});
+
+const rawContent = computed(() => {
+  if (!props.plan?.raw) return "";
+  // DM returns raw plan text as a string → show as-is
+  if (typeof props.plan.raw === "string") return props.plan.raw;
+  // Other DBs return JSON → pretty-print
+  return JSON.stringify(props.plan.raw, null, 2);
+});
+
+const isRawString = computed(() => typeof props.plan?.raw === "string");
+const nodeCount = computed(() => (props.plan ? flattenExplainPlanNodes(props.plan.nodes).length : 0));
+
+function tableCellText(value: unknown): string {
+  if (value === null) return "NULL";
+  return value === undefined ? "" : String(value);
+}
+</script>
+
+<template>
+  <div class="flex h-full min-h-0 flex-col bg-background">
+    <div class="h-9 shrink-0 border-b px-3 flex items-center gap-2 text-xs">
+      <span class="inline-flex items-center gap-1 rounded border bg-muted px-2 py-0.5 font-medium">
+        <GitBranch class="h-3.5 w-3.5" />
+        {{ t("explain.title") }}
+      </span>
+      <span v-if="plan || hasTableView" class="text-muted-foreground">
+        {{ plan?.databaseType.toUpperCase() || "MYSQL" }}<template v-if="plan"> · {{ t("explain.nodeCount", { count: nodeCount }) }}</template>
+      </span>
+      <span v-if="plan?.databaseType === 'dameng' && isRawString && rawContent.includes('->')" class="ml-1 inline-flex items-center gap-1 rounded bg-green-100 px-1.5 py-0.5 font-semibold text-green-700 dark:bg-green-900/30 dark:text-green-300" style="font-size: 10px">A-TRACE</span>
+      <span class="flex-1" />
+      <div v-if="plan || hasTableView" class="inline-flex rounded-md border bg-muted/40 p-0.5">
+        <Button v-if="plan" size="sm" :variant="activeView === 'tree' ? 'secondary' : 'ghost'" class="h-6 px-2 text-xs gap-1" @click="activeView = 'tree'">
+          <GitBranch class="h-3.5 w-3.5" />
+          {{ t("explain.tree") }}
+        </Button>
+        <Button v-if="plan" size="sm" :variant="activeView === 'summary' ? 'secondary' : 'ghost'" class="h-6 px-2 text-xs gap-1" @click="activeView = 'summary'">
+          <Table2 class="h-3.5 w-3.5" />
+          {{ t("explain.summary") }}
+        </Button>
+        <Button v-if="plan" size="sm" :variant="activeView === 'raw' ? 'secondary' : 'ghost'" class="h-6 px-2 text-xs gap-1" @click="activeView = 'raw'">
+          <FileText v-if="isRawString" class="h-3.5 w-3.5" />
+          <Braces v-else class="h-3.5 w-3.5" />
+          {{ isRawString ? "TEXT" : "JSON" }}
+        </Button>
+        <Button v-if="hasTableView" size="sm" :variant="activeView === 'table' ? 'secondary' : 'ghost'" class="h-6 px-2 text-xs gap-1" @click="activeView = 'table'">
+          <Table2 class="h-3.5 w-3.5" />
+          {{ t("explain.standardTable") }}
+        </Button>
+      </div>
+    </div>
+
+    <div v-if="loading && !(activeView === 'table' && hasTableView)" class="flex-1 min-h-0 flex items-center justify-center text-sm text-muted-foreground">
+      {{ t("explain.running") }}
+    </div>
+
+    <div v-else-if="activeView === 'table' && hasTableView" class="flex-1 min-h-0 overflow-auto">
+      <div v-if="tableError" class="flex h-full min-h-0 items-center justify-center p-3">
+        <div class="flex max-w-xl items-start gap-2 rounded border border-destructive/30 bg-destructive/5 px-3 py-2 text-sm text-destructive">
+          <AlertCircle class="mt-0.5 h-4 w-4 shrink-0" />
+          <span>{{ tableError }}</span>
+        </div>
+      </div>
+
+      <div v-else-if="tableResult" class="p-3">
+        <div class="overflow-x-auto rounded border">
+          <table class="min-w-full w-max text-left text-xs">
+            <thead class="bg-muted/70 text-muted-foreground">
+              <tr>
+                <th v-for="(column, columnIndex) in tableResult.columns" :key="columnIndex" class="whitespace-nowrap px-2 py-1.5 font-medium">{{ column }}</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="(row, rowIndex) in tableResult.rows" :key="rowIndex" class="border-t">
+                <td v-for="(_column, columnIndex) in tableResult.columns" :key="columnIndex" class="whitespace-nowrap px-2 py-1.5 text-muted-foreground">
+                  {{ tableCellText(row[columnIndex]) }}
+                </td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </div>
+
+    <div v-else-if="error" class="flex-1 min-h-0 flex items-center justify-center">
+      <div class="flex max-w-xl items-start gap-2 rounded border border-destructive/30 bg-destructive/5 px-3 py-2 text-sm text-destructive">
+        <AlertCircle class="mt-0.5 h-4 w-4 shrink-0" />
+        <span>{{ error }}</span>
+      </div>
+    </div>
+
+    <div v-else-if="!plan" class="flex-1 min-h-0 flex items-center justify-center text-sm text-muted-foreground">
+      {{ t("explain.empty") }}
+    </div>
+
+    <div v-else class="flex-1 min-h-0 overflow-auto">
+      <div v-if="activeView === 'tree'" class="mx-auto max-w-5xl space-y-px p-2">
+        <ExplainPlanNodeTree v-for="node in plan.nodes" :key="node.id" :node="node" />
+      </div>
+
+      <div v-else-if="activeView === 'summary'" class="p-3">
+        <div class="overflow-auto rounded border">
+          <table class="w-full min-w-[760px] text-left text-xs">
+            <thead class="bg-muted/70 text-muted-foreground">
+              <tr>
+                <th class="px-2 py-1.5 font-medium">{{ t("explain.node") }}</th>
+                <th class="px-2 py-1.5 font-medium">{{ t("explain.relation") }}</th>
+                <th class="px-2 py-1.5 font-medium">{{ t("explain.index") }}</th>
+                <th class="px-2 py-1.5 font-medium">{{ t("explain.cost") }}</th>
+                <th class="px-2 py-1.5 font-medium">{{ t("explain.rows") }}</th>
+                <th class="px-2 py-1.5 font-medium">{{ t("explain.details") }}</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="row in flatRows" :key="row.node.id" class="border-t">
+                <td class="px-2 py-1.5 font-medium" :style="{ paddingLeft: `${8 + row.depth * 18}px` }">
+                  {{ row.node.title }}
+                </td>
+                <td class="px-2 py-1.5 text-muted-foreground">{{ row.node.relation || "-" }}</td>
+                <td class="px-2 py-1.5 text-muted-foreground">{{ row.node.index || "-" }}</td>
+                <td class="px-2 py-1.5 tabular-nums">{{ row.node.cost || "-" }}</td>
+                <td class="px-2 py-1.5 tabular-nums">{{ row.node.rows || "-" }}</td>
+                <td class="px-2 py-1.5 text-muted-foreground">
+                  {{ row.node.details.join("; ") || "-" }}
+                </td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+
+      <pre v-else class="m-3 overflow-auto whitespace-pre rounded border bg-muted/30 p-3 font-mono text-xs leading-relaxed">{{ rawContent }}</pre>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/export/DatabaseExportDialog.vue b/apps/desktop/src/components/export/DatabaseExportDialog.vue
new file mode 100644
index 0000000..6e6293d
--- /dev/null
+++ b/apps/desktop/src/components/export/DatabaseExportDialog.vue
@@ -0,0 +1,771 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Dialog, DialogHeader, DialogTitle, DialogFooter, DialogContent } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Label } from "@/components/ui/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { useConnectionStore } from "@/stores/connectionStore";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import * as api from "@/lib/backend/api";
+import type { ExportProgress } from "@/lib/backend/api";
+import { isSchemaAware } from "@/lib/database/databaseFeatureSupport";
+import { databaseOptionsForConnection } from "@/composables/useDatabaseOptions";
+import { buildAllDatabaseExportPlan, generateDatabaseExportId, type AllDatabaseExportPlanItem } from "@/lib/export/databaseExport";
+import { buildSelectedTablesPayload } from "@/lib/export/databaseExportSelection";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { useToast } from "@/composables/useToast";
+import { Input } from "@/components/ui/input";
+import { Download, Square, CheckSquare, Search, X } from "@lucide/vue";
+import { useExportTracker } from "@/composables/useExportTracker";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const { addDatabaseExportTask, updateDatabaseExportTask } = useExportTracker();
+const open = defineModel<boolean>("open", { default: false });
+const store = useConnectionStore();
+
+const props = defineProps<{
+  prefillConnectionId?: string;
+  prefillDatabase?: string;
+  prefillSchema?: string;
+  prefillTable?: string;
+  prefillTables?: string[];
+  prefillAllDatabases?: boolean;
+}>();
+
+// Connection / Database / Schema selectors
+const connectionId = ref("");
+const database = ref("");
+const databases = ref<string[]>([]);
+const selectedDatabases = ref<string[]>([]);
+const databaseFilter = ref("");
+const schema = ref("");
+const schemas = ref<string[]>([]);
+const loadingMeta = ref(false);
+const tables = ref<string[]>([]);
+const selectedTables = ref<string[]>([]);
+const loadingTables = ref(false);
+const tableFilter = ref("");
+const filteredTables = computed(() => {
+  const q = tableFilter.value.trim().toLowerCase();
+  if (!q) return tables.value;
+  return tables.value.filter((name) => name.toLowerCase().includes(q));
+});
+const tableError = ref<string | null>(null);
+
+// Options
+const includeStructure = ref(true);
+const includeData = ref(true);
+const includeObjects = ref(true);
+const dropTableIfExists = ref(false);
+
+// Export state
+const isExporting = ref(false);
+const exportProgress = ref<ExportProgress | null>(null);
+const exportId = ref("");
+const exportDone = ref(false);
+const exportError = ref<string | null>(null);
+const exportCancelled = ref(false);
+const pendingPrefillTable = ref("");
+const pendingPrefillTables = ref<string[]>([]);
+const exportAllDatabases = ref(false);
+const batchDatabaseIndex = ref(0);
+const batchDatabaseTotal = ref(0);
+const activeDatabaseExportId = ref("");
+
+const sqlConnections = computed(() => store.connections.filter((c) => !["redis", "mongodb", "elasticsearch", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "mq", "nacos"].includes(c.db_type)));
+
+const canExport = computed(() => {
+  const hasContent = includeStructure.value || includeData.value || includeObjects.value;
+  if (!connectionId.value || !hasContent || isExporting.value) return false;
+  if (exportAllDatabases.value) return selectedDatabases.value.length > 0 && !loadingMeta.value;
+  return database.value && schema.value && !loadingTables.value && !tableError.value && (tables.value.length === 0 || selectedTables.value.length > 0);
+});
+
+const selectedTableSet = computed(() => new Set(selectedTables.value));
+const selectedDatabaseSet = computed(() => new Set(selectedDatabases.value));
+const filteredDatabases = computed(() => {
+  const q = databaseFilter.value.trim().toLowerCase();
+  if (!q) return databases.value;
+  return databases.value.filter((name) => name.toLowerCase().includes(q));
+});
+
+function connectionIconType(connId: string) {
+  const config = store.getConfig(connId);
+  return config?.driver_profile || config?.db_type || "mysql";
+}
+
+function sanitizeFileName(value: string): string {
+  return (value || "database").replace(/[\\/:*?"<>|]+/g, "_").trim() || "database";
+}
+
+function joinExportPath(directory: string, fileName: string): string {
+  const separator = directory.includes("\\") ? "\\" : "/";
+  return `${directory.replace(/[\\/]+$/, "")}${separator}${fileName}`;
+}
+
+function currentRowsExported(): number {
+  const progress: ExportProgress | null = exportProgress.value;
+  return progress?.rowsExported ?? 0;
+}
+
+async function runDatabaseExportUntilTerminal(request: api.DatabaseExportRequest, onProgress: (progress: ExportProgress) => void): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    api
+      .exportDatabaseSql(request, (progress) => {
+        onProgress(progress);
+        if (progress.status === "Done" || progress.status === "Cancelled") {
+          resolve();
+        } else if (progress.status === "Error") {
+          reject(new Error(progress.error || "Export failed"));
+        }
+      })
+      .catch(reject);
+  });
+}
+
+async function loadDatabases(connId: string) {
+  if (!connId) return;
+  loadingMeta.value = true;
+  try {
+    await store.ensureConnected(connId);
+    const dbs = await api.listDatabases(connId);
+    const names = databaseOptionsForConnection(
+      dbs.map((d) => d.name),
+      store.getConfig(connId),
+    );
+    databases.value = names;
+    database.value = names.length === 1 ? names[0] : "";
+    selectedDatabases.value = exportAllDatabases.value ? [...names] : [];
+    schemas.value = [];
+    schema.value = "";
+    tables.value = [];
+    selectedTables.value = [];
+  } catch {
+    databases.value = [];
+  } finally {
+    loadingMeta.value = false;
+  }
+}
+
+async function loadSchemas(preferredSchema = "") {
+  if (!connectionId.value || !database.value) return;
+  const config = store.getConfig(connectionId.value);
+  if (!isSchemaAware(config?.db_type)) {
+    schemas.value = [];
+    schema.value = database.value;
+    return;
+  }
+
+  const schemaList = await api.listSchemas(connectionId.value, database.value);
+  const selected = preferredSchema && schemaList.includes(preferredSchema) ? preferredSchema : schemaList.includes("public") ? "public" : (schemaList[0] ?? "");
+  schemas.value = schemaList;
+  schema.value = selected;
+}
+
+async function loadTables(preferredTable = "", preferredTables: string[] = []) {
+  if (!connectionId.value || !database.value || !schema.value) return;
+  loadingTables.value = true;
+  tableError.value = null;
+  tables.value = [];
+  selectedTables.value = [];
+  try {
+    const tableInfos = await api.listTables(connectionId.value, database.value, schema.value);
+    const names = tableInfos.map((table) => table.name);
+    tables.value = names;
+    const preferredSet = new Set(preferredTables.filter((name) => names.includes(name)));
+    selectedTables.value = preferredSet.size > 0 ? names.filter((name) => preferredSet.has(name)) : preferredTable && names.includes(preferredTable) ? [preferredTable] : [...names];
+  } catch (e: any) {
+    tableError.value = e?.message || String(e);
+  } finally {
+    loadingTables.value = false;
+  }
+}
+
+function toggleTable(table: string) {
+  const selected = new Set(selectedTables.value);
+  if (selected.has(table)) {
+    selected.delete(table);
+  } else {
+    selected.add(table);
+  }
+  selectedTables.value = tables.value.filter((name) => selected.has(name));
+}
+
+function selectAllTables() {
+  const selected = new Set(selectedTables.value);
+  for (const name of filteredTables.value) selected.add(name);
+  selectedTables.value = tables.value.filter((name) => selected.has(name));
+}
+
+function clearSelectedTables() {
+  const removing = new Set(filteredTables.value);
+  selectedTables.value = selectedTables.value.filter((name) => !removing.has(name));
+}
+
+function toggleDatabase(db: string) {
+  const selected = new Set(selectedDatabases.value);
+  if (selected.has(db)) {
+    selected.delete(db);
+  } else {
+    selected.add(db);
+  }
+  selectedDatabases.value = databases.value.filter((name) => selected.has(name));
+}
+
+function selectAllDatabases() {
+  const selected = new Set(selectedDatabases.value);
+  for (const name of filteredDatabases.value) selected.add(name);
+  selectedDatabases.value = databases.value.filter((name) => selected.has(name));
+}
+
+function clearSelectedDatabases() {
+  const removing = new Set(filteredDatabases.value);
+  selectedDatabases.value = selectedDatabases.value.filter((name) => !removing.has(name));
+}
+
+async function buildExportPlanForDatabases(dbs: string[]): Promise<AllDatabaseExportPlanItem[]> {
+  const config = store.getConfig(connectionId.value);
+  const schemaAware = isSchemaAware(config?.db_type);
+  const schemasByDatabase: Record<string, string[]> = {};
+  if (schemaAware) {
+    for (const db of dbs) {
+      schemasByDatabase[db] = await api.listSchemas(connectionId.value, db);
+    }
+  }
+  return buildAllDatabaseExportPlan({ databases: dbs, schemaAware, schemasByDatabase });
+}
+
+async function startExport() {
+  if (!canExport.value) return;
+  if (exportAllDatabases.value) {
+    await startAllDatabasesExport();
+    return;
+  }
+  isExporting.value = true;
+  exportDone.value = false;
+  exportError.value = null;
+  exportCancelled.value = false;
+  exportProgress.value = null;
+
+  exportId.value = generateDatabaseExportId();
+
+  let filePath = "";
+
+  if (isTauriRuntime()) {
+    try {
+      const { save } = await import("@tauri-apps/plugin-dialog");
+      const safeName = sanitizeFileName(database.value || "database");
+      const path = await save({
+        defaultPath: `${safeName}.sql`,
+        filters: [{ name: "SQL", extensions: ["sql"] }],
+      });
+      if (!path) {
+        isExporting.value = false;
+        return;
+      }
+      filePath = path;
+    } catch (e: any) {
+      isExporting.value = false;
+      toast(e?.message || String(e), 5000);
+      return;
+    }
+  } else {
+    // Web mode: use a temp path; the server will handle the file
+    filePath = `__web_export_${exportId.value}.sql`;
+  }
+
+  const request: api.DatabaseExportRequest = {
+    exportId: exportId.value,
+    connectionId: connectionId.value,
+    database: database.value,
+    schema: schema.value,
+    filePath,
+    selectedTables: buildSelectedTablesPayload(tables.value, selectedTables.value),
+    includeStructure: includeStructure.value,
+    includeData: includeData.value,
+    includeObjects: includeObjects.value,
+    dropTableIfExists: dropTableIfExists.value,
+    batchSize: 1000,
+  };
+
+  addDatabaseExportTask(exportId.value, database.value || "database", filePath);
+
+  try {
+    await api.exportDatabaseSql(request, (progress) => {
+      exportProgress.value = { ...progress };
+      updateDatabaseExportTask(progress.exportId, progress);
+      if (progress.status === "Done") {
+        exportDone.value = true;
+        isExporting.value = false;
+        toast(t("databaseExport.exportSuccess"), 3000);
+      } else if (progress.status === "Error") {
+        exportError.value = progress.error;
+        isExporting.value = false;
+      } else if (progress.status === "Cancelled") {
+        exportCancelled.value = true;
+        isExporting.value = false;
+      }
+    });
+  } catch (e: any) {
+    exportError.value = e?.message || String(e);
+    const lastProgress = exportProgress.value as api.ExportProgress | null;
+    const fallbackProgress: api.ExportProgress = {
+      exportId: exportId.value,
+      currentObject: database.value || "database",
+      objectIndex: lastProgress?.objectIndex ?? 0,
+      totalObjects: lastProgress?.totalObjects ?? 0,
+      rowsExported: lastProgress?.rowsExported ?? 0,
+      totalRows: lastProgress?.totalRows ?? null,
+      status: "Error",
+      error: exportError.value,
+    };
+    updateDatabaseExportTask(exportId.value, fallbackProgress);
+    isExporting.value = false;
+  }
+}
+
+async function startAllDatabasesExport() {
+  if (!canExport.value) return;
+
+  let directoryPath = "";
+  if (isTauriRuntime()) {
+    try {
+      const { open: openDialog } = await import("@tauri-apps/plugin-dialog");
+      const path = await openDialog({
+        directory: true,
+        multiple: false,
+        title: t("databaseExport.selectExportDirectory"),
+      });
+      if (!path || Array.isArray(path)) return;
+      directoryPath = path;
+    } catch (e: any) {
+      toast(e?.message || String(e), 5000);
+      return;
+    }
+  }
+
+  isExporting.value = true;
+  exportDone.value = false;
+  exportError.value = null;
+  exportCancelled.value = false;
+  exportProgress.value = null;
+  batchDatabaseIndex.value = 0;
+
+  const dbs = [...selectedDatabases.value];
+  const batchId = generateDatabaseExportId();
+  exportId.value = batchId;
+  addDatabaseExportTask(batchId, t("databaseExport.allDatabasesTask", { count: dbs.length }), directoryPath);
+  let exportPlan: AllDatabaseExportPlanItem[] = [];
+
+  try {
+    exportPlan = await buildExportPlanForDatabases(dbs);
+    batchDatabaseTotal.value = exportPlan.length;
+
+    for (let index = 0; index < exportPlan.length; index += 1) {
+      if (exportCancelled.value) break;
+      const item = exportPlan[index]!;
+      batchDatabaseIndex.value = index + 1;
+      const currentExportId = `${batchId}-${index + 1}`;
+      activeDatabaseExportId.value = currentExportId;
+      const filePath = isTauriRuntime() ? joinExportPath(directoryPath, `${sanitizeFileName(item.fileStem)}.sql`) : `__web_export_${currentExportId}.sql`;
+      const request: api.DatabaseExportRequest = {
+        exportId: currentExportId,
+        connectionId: connectionId.value,
+        database: item.database,
+        schema: item.schema,
+        filePath,
+        includeStructure: includeStructure.value,
+        includeData: includeData.value,
+        includeObjects: includeObjects.value,
+        dropTableIfExists: dropTableIfExists.value,
+        batchSize: 1000,
+      };
+
+      await runDatabaseExportUntilTerminal(request, (progress) => {
+        exportProgress.value = { ...progress, exportId: batchId, currentObject: `${item.displayName}: ${progress.currentObject || item.displayName}` };
+        updateDatabaseExportTask(batchId, {
+          ...progress,
+          exportId: batchId,
+          currentObject: item.displayName,
+          objectIndex: index,
+          totalObjects: exportPlan.length,
+        });
+        if (progress.status === "Error") {
+          exportError.value = progress.error;
+          isExporting.value = false;
+        } else if (progress.status === "Cancelled") {
+          exportCancelled.value = true;
+          isExporting.value = false;
+        }
+      });
+
+      if (exportError.value || exportCancelled.value) break;
+      activeDatabaseExportId.value = "";
+    }
+
+    if (!exportError.value && !exportCancelled.value) {
+      exportDone.value = true;
+      isExporting.value = false;
+      updateDatabaseExportTask(batchId, {
+        exportId: batchId,
+        currentObject: t("databaseExport.allDatabasesTask", { count: dbs.length }),
+        objectIndex: exportPlan.length,
+        totalObjects: exportPlan.length,
+        rowsExported: currentRowsExported(),
+        totalRows: null,
+        status: "Done",
+        error: null,
+      });
+      toast(t("databaseExport.exportAllSuccess", { count: dbs.length }), 3000);
+    }
+  } catch (e: any) {
+    exportError.value = e?.message || String(e);
+    updateDatabaseExportTask(batchId, {
+      exportId: batchId,
+      currentObject: t("databaseExport.allDatabasesTask", { count: dbs.length }),
+      objectIndex: Math.max(0, batchDatabaseIndex.value - 1),
+      totalObjects: batchDatabaseTotal.value || dbs.length,
+      rowsExported: currentRowsExported(),
+      totalRows: null,
+      status: "Error",
+      error: exportError.value,
+    });
+    isExporting.value = false;
+  }
+}
+
+async function cancelExport() {
+  if (exportId.value) {
+    if (exportAllDatabases.value) {
+      exportCancelled.value = true;
+      isExporting.value = false;
+      if (activeDatabaseExportId.value) {
+        await api.cancelDatabaseExport(activeDatabaseExportId.value);
+      }
+    } else {
+      await api.cancelDatabaseExport(exportId.value);
+    }
+  }
+}
+
+function resetState() {
+  connectionId.value = "";
+  database.value = "";
+  databases.value = [];
+  schema.value = "";
+  schemas.value = [];
+  tables.value = [];
+  selectedTables.value = [];
+  tableError.value = null;
+  pendingPrefillTable.value = "";
+  pendingPrefillTables.value = [];
+  exportAllDatabases.value = false;
+  selectedDatabases.value = [];
+  databaseFilter.value = "";
+  includeStructure.value = true;
+  includeData.value = true;
+  includeObjects.value = true;
+  dropTableIfExists.value = false;
+  isExporting.value = false;
+  exportProgress.value = null;
+  exportDone.value = false;
+  exportError.value = null;
+  exportCancelled.value = false;
+  exportId.value = "";
+  batchDatabaseIndex.value = 0;
+  batchDatabaseTotal.value = 0;
+  activeDatabaseExportId.value = "";
+}
+
+const progressPercent = computed(() => {
+  const p = exportProgress.value;
+  if (!p || p.totalObjects === 0) return 0;
+  return Math.round((p.objectIndex / p.totalObjects) * 100);
+});
+
+const skipConnectionWatch = ref(false);
+
+watch(connectionId, (id) => {
+  if (skipConnectionWatch.value) {
+    skipConnectionWatch.value = false;
+    return;
+  }
+  database.value = "";
+  databases.value = [];
+  selectedDatabases.value = [];
+  schemas.value = [];
+  schema.value = "";
+  tables.value = [];
+  selectedTables.value = [];
+  tableError.value = null;
+  loadDatabases(id);
+});
+
+watch(database, (db) => {
+  if (exportAllDatabases.value) return;
+  schema.value = "";
+  schemas.value = [];
+  tables.value = [];
+  selectedTables.value = [];
+  tableError.value = null;
+  if (db) loadSchemas(props.prefillSchema).catch((e) => toast(String(e), 5000));
+});
+
+watch(schema, (value) => {
+  if (exportAllDatabases.value) return;
+  tables.value = [];
+  selectedTables.value = [];
+  tableError.value = null;
+  const preferredTable = pendingPrefillTable.value;
+  const preferredTables = pendingPrefillTables.value;
+  pendingPrefillTable.value = "";
+  pendingPrefillTables.value = [];
+  if (value) loadTables(preferredTable, preferredTables).catch((e) => toast(String(e), 5000));
+});
+
+watch(
+  open,
+  async (val) => {
+    if (val) {
+      resetState();
+      exportAllDatabases.value = props.prefillAllDatabases ?? false;
+      pendingPrefillTable.value = props.prefillTable ?? "";
+      pendingPrefillTables.value = props.prefillTables ?? [];
+      if (props.prefillConnectionId) {
+        skipConnectionWatch.value = true;
+        connectionId.value = props.prefillConnectionId;
+        await loadDatabases(props.prefillConnectionId);
+        if (props.prefillDatabase) {
+          database.value = props.prefillDatabase;
+          await loadSchemas(props.prefillSchema);
+        }
+      }
+    }
+  },
+  { immediate: true },
+);
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent class="sm:max-w-[480px] max-h-[80vh] flex flex-col overflow-hidden" @interact-outside.prevent>
+      <DialogHeader>
+        <DialogTitle class="flex items-center gap-2">
+          <Download class="w-4 h-4" />
+          {{ t("databaseExport.title") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="flex-1 min-h-0 overflow-auto space-y-4 py-2">
+        <!-- Connection / Database / Schema Selection -->
+        <div v-if="!isExporting && !exportDone && !exportError && !exportCancelled" class="space-y-3">
+          <div class="space-y-1.5">
+            <Label class="text-xs">{{ t("transfer.sourceConnection") }}</Label>
+            <Select :model-value="connectionId" @update:model-value="(v: any) => (connectionId = String(v))">
+              <SelectTrigger class="h-8 text-xs">
+                <div class="flex items-center gap-2">
+                  <DatabaseIcon v-if="connectionId" :db-type="connectionIconType(connectionId)" class="w-3.5 h-3.5" />
+                  <SelectValue :placeholder="t('diff.selectConnection')" />
+                </div>
+              </SelectTrigger>
+              <SelectContent position="popper" align="start">
+                <SelectItem v-for="c in sqlConnections" :key="c.id" :value="c.id">
+                  <div class="flex items-center gap-2">
+                    <DatabaseIcon :db-type="c.driver_profile || c.db_type" class="w-3.5 h-3.5" />
+                    {{ c.name }}
+                  </div>
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div v-if="exportAllDatabases && databases.length" class="space-y-2">
+            <div class="flex items-center justify-between gap-2">
+              <Label class="text-xs">{{ t("databaseExport.databaseSelection") }}</Label>
+              <div class="text-[11px] text-muted-foreground">
+                {{ t("databaseExport.selectedDatabases", { selected: selectedDatabases.length, total: databases.length }) }}
+              </div>
+            </div>
+            <div class="space-y-2 rounded border border-border/60 p-2">
+              <div class="relative">
+                <Search class="absolute left-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+                <Input v-model="databaseFilter" class="h-7 pl-7 text-xs" :placeholder="t('databaseExport.filterDatabases')" />
+              </div>
+              <div class="flex items-center gap-2">
+                <Button variant="outline" size="sm" class="h-7 px-2 text-xs" @click="selectAllDatabases">
+                  {{ t("databaseExport.selectAllDatabases") }}
+                </Button>
+                <Button variant="outline" size="sm" class="h-7 px-2 text-xs" @click="clearSelectedDatabases">
+                  {{ t("databaseExport.clearDatabases") }}
+                </Button>
+              </div>
+              <div class="max-h-44 overflow-auto space-y-1 pr-1">
+                <button v-for="db in filteredDatabases" :key="db" type="button" class="flex w-full min-w-0 items-center gap-2 rounded px-1.5 py-1 text-left text-xs hover:bg-muted" @click="toggleDatabase(db)">
+                  <CheckSquare v-if="selectedDatabaseSet.has(db)" class="w-3.5 h-3.5 text-primary shrink-0" />
+                  <Square v-else class="w-3.5 h-3.5 text-muted-foreground/40 shrink-0" />
+                  <span class="truncate">{{ db }}</span>
+                </button>
+              </div>
+            </div>
+          </div>
+
+          <div v-else-if="databases.length" class="space-y-1.5">
+            <Label class="text-xs">{{ t("transfer.sourceDatabase") }}</Label>
+            <Select :model-value="database" @update:model-value="(v: any) => (database = String(v))">
+              <SelectTrigger class="h-8 text-xs">
+                <SelectValue :placeholder="t('diff.selectDatabase')" />
+              </SelectTrigger>
+              <SelectContent position="popper" align="start">
+                <SelectItem v-for="db in databases" :key="db" :value="db">{{ db }}</SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div v-if="!exportAllDatabases && schemas.length" class="space-y-1.5">
+            <Label class="text-xs">{{ t("diff.selectSchema") }}</Label>
+            <Select :model-value="schema" @update:model-value="(v: any) => (schema = String(v))">
+              <SelectTrigger class="h-8 text-xs">
+                <SelectValue :placeholder="t('diff.selectSchema')" />
+              </SelectTrigger>
+              <SelectContent position="popper" align="start">
+                <SelectItem v-for="s in schemas" :key="s" :value="s">{{ s }}</SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+
+          <div v-if="!exportAllDatabases && schema" class="space-y-2">
+            <div class="flex items-center justify-between gap-2">
+              <Label class="text-xs">{{ t("databaseExport.tableSelection") }}</Label>
+              <div v-if="tables.length" class="text-[11px] text-muted-foreground">
+                {{ t("databaseExport.selectedTables", { selected: selectedTables.length, total: tables.length }) }}
+              </div>
+            </div>
+
+            <div v-if="loadingTables" class="text-xs text-muted-foreground">
+              {{ t("databaseExport.loadingTables") }}
+            </div>
+            <div v-else-if="tableError" class="text-xs text-destructive">
+              {{ t("databaseExport.tableLoadError", { error: tableError }) }}
+            </div>
+            <div v-else-if="tables.length" class="space-y-2 rounded border border-border/60 p-2">
+              <div class="relative">
+                <Search class="absolute left-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+                <Input v-model="tableFilter" class="h-7 pl-7 text-xs" :placeholder="t('databaseExport.filterTables')" />
+              </div>
+              <div class="flex items-center gap-2">
+                <Button variant="outline" size="sm" class="h-7 px-2 text-xs" @click="selectAllTables">
+                  {{ t("databaseExport.selectAllTables") }}
+                </Button>
+                <Button variant="outline" size="sm" class="h-7 px-2 text-xs" @click="clearSelectedTables">
+                  {{ t("databaseExport.clearTables") }}
+                </Button>
+              </div>
+              <div class="max-h-40 overflow-auto space-y-1 pr-1">
+                <button v-for="table in filteredTables" :key="table" type="button" class="flex w-full min-w-0 items-center gap-2 rounded px-1.5 py-1 text-left text-xs hover:bg-muted" @click="toggleTable(table)">
+                  <CheckSquare v-if="selectedTableSet.has(table)" class="w-3.5 h-3.5 text-primary shrink-0" />
+                  <Square v-else class="w-3.5 h-3.5 text-muted-foreground/40 shrink-0" />
+                  <span class="truncate">{{ table }}</span>
+                </button>
+              </div>
+            </div>
+            <div v-else class="text-xs text-muted-foreground">
+              {{ t("databaseExport.noTables") }}
+            </div>
+          </div>
+
+          <!-- Options -->
+          <div class="space-y-2.5 pt-1">
+            <div class="text-xs font-medium text-muted-foreground uppercase tracking-wider">
+              {{ t("databaseExport.options") }}
+            </div>
+            <div class="flex items-center gap-2 cursor-pointer text-xs" @click="includeStructure = !includeStructure">
+              <CheckSquare v-if="includeStructure" class="w-3.5 h-3.5 text-primary shrink-0" />
+              <Square v-else class="w-3.5 h-3.5 text-muted-foreground/40 shrink-0" />
+              {{ t("databaseExport.includeStructure") }}
+            </div>
+            <div class="flex items-center gap-2 text-xs" :class="includeStructure ? 'cursor-pointer' : 'cursor-not-allowed text-muted-foreground/50'" @click="includeStructure && (dropTableIfExists = !dropTableIfExists)">
+              <CheckSquare v-if="dropTableIfExists && includeStructure" class="w-3.5 h-3.5 text-primary shrink-0" />
+              <Square v-else class="w-3.5 h-3.5 text-muted-foreground/40 shrink-0" />
+              {{ t("databaseExport.dropTableIfExists") }}
+            </div>
+            <div class="flex items-center gap-2 cursor-pointer text-xs" @click="includeData = !includeData">
+              <CheckSquare v-if="includeData" class="w-3.5 h-3.5 text-primary shrink-0" />
+              <Square v-else class="w-3.5 h-3.5 text-muted-foreground/40 shrink-0" />
+              {{ t("databaseExport.includeData") }}
+            </div>
+            <div class="flex items-center gap-2 cursor-pointer text-xs" @click="includeObjects = !includeObjects">
+              <CheckSquare v-if="includeObjects" class="w-3.5 h-3.5 text-primary shrink-0" />
+              <Square v-else class="w-3.5 h-3.5 text-muted-foreground/40 shrink-0" />
+              {{ t("databaseExport.includeObjects") }}
+            </div>
+          </div>
+        </div>
+
+        <!-- Progress View -->
+        <div v-if="isExporting || exportDone || exportError || exportCancelled" class="py-3 space-y-3">
+          <div v-if="exportAllDatabases && batchDatabaseTotal" class="text-xs text-muted-foreground">
+            {{ t("databaseExport.currentDatabase", { current: batchDatabaseIndex, total: batchDatabaseTotal }) }}
+          </div>
+          <div v-if="exportProgress" class="space-y-2">
+            <div class="text-xs text-muted-foreground">
+              {{
+                t("databaseExport.currentTable", {
+                  table: exportProgress.currentObject,
+                  current: exportProgress.objectIndex,
+                  total: exportProgress.totalObjects,
+                })
+              }}
+            </div>
+
+            <div class="w-full bg-muted rounded-full h-2 overflow-hidden">
+              <div class="h-full rounded-full transition-[width] duration-300" :class="exportError ? 'bg-destructive' : exportCancelled ? 'bg-yellow-500' : 'bg-primary'" :style="{ width: `${progressPercent}%` }" />
+            </div>
+
+            <div class="text-xs text-muted-foreground">
+              {{ t("databaseExport.rowsExported", { count: exportProgress.rowsExported.toLocaleString() }) }}
+            </div>
+          </div>
+
+          <!-- Status messages -->
+          <div v-if="exportDone" class="text-xs text-green-600 font-medium">
+            {{ t("databaseExport.exportSuccess") }}
+          </div>
+          <div v-else-if="exportError" class="text-xs text-destructive font-medium">
+            {{ t("databaseExport.exportError", { error: exportError }) }}
+          </div>
+          <div v-else-if="exportCancelled" class="text-xs text-yellow-600 font-medium">
+            {{ t("databaseExport.exportCancelled") }}
+          </div>
+        </div>
+      </div>
+
+      <DialogFooter>
+        <template v-if="!isExporting && !exportDone && !exportError && !exportCancelled">
+          <Button variant="outline" size="sm" @click="open = false">
+            {{ t("transfer.cancel") }}
+          </Button>
+          <Button size="sm" :disabled="!canExport" @click="startExport">
+            <Download class="w-3.5 h-3.5 mr-1.5" />
+            {{ exportAllDatabases ? t("databaseExport.exportAllDatabases") : t("databaseExport.export") }}
+          </Button>
+        </template>
+        <template v-else-if="isExporting">
+          <Button variant="outline" size="sm" @click="open = false">
+            {{ t("databaseExport.runInBackground") }}
+          </Button>
+          <Button variant="destructive" size="sm" @click="cancelExport">
+            <X class="w-3.5 h-3.5 mr-1.5" />
+            {{ t("transfer.cancel") }}
+          </Button>
+        </template>
+        <template v-else>
+          <Button size="sm" @click="open = false">
+            {{ t("common.close") }}
+          </Button>
+        </template>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/export/ExportProgressDialog.vue b/apps/desktop/src/components/export/ExportProgressDialog.vue
new file mode 100644
index 0000000..d20df2e
--- /dev/null
+++ b/apps/desktop/src/components/export/ExportProgressDialog.vue
@@ -0,0 +1,137 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import { useI18n } from "vue-i18n";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Loader2, CheckCircle2, XCircle, AlertCircle, X } from "@lucide/vue";
+
+const { t } = useI18n();
+const open = defineModel<boolean>("open", { default: false });
+
+const props = defineProps<{
+  title: string;
+  tableName: string;
+  format: string;
+  rowsExported: number;
+  totalRows: number | null;
+  status: string;
+  errorMessage: string | null;
+  disableCancel?: boolean;
+}>();
+
+const emit = defineEmits<{
+  cancel: [];
+  "update:open": [value: boolean];
+}>();
+
+const isActive = computed(() => props.status === "Running" || props.status === "Writing");
+const isFinished = computed(() => props.status === "Done" || props.status === "Error" || props.status === "Cancelled");
+const progressPercent = computed(() => {
+  if (!props.totalRows || props.totalRows <= 0) return 0;
+  return Math.min(100, Math.round((props.rowsExported / props.totalRows) * 100));
+});
+const rowsText = computed(() => {
+  if (props.totalRows) {
+    return t("exportProgress.rowsCount", {
+      exported: props.rowsExported.toLocaleString(),
+      total: props.totalRows.toLocaleString(),
+    });
+  }
+  return t("exportProgress.rowsExported", { count: props.rowsExported.toLocaleString() });
+});
+</script>
+
+<template>
+  <Dialog
+    :open="open"
+    @update:open="
+      (v: boolean) => {
+        if (!isActive) emit('update:open', v);
+      }
+    "
+  >
+    <DialogContent class="sm:max-w-md" :class="{ 'pointer-events-none': isActive }" @interact-outside.prevent>
+      <DialogHeader>
+        <DialogTitle>{{ title }}</DialogTitle>
+      </DialogHeader>
+
+      <div class="py-4 space-y-4">
+        <!-- Table name and format info -->
+        <div class="text-sm text-muted-foreground">{{ tableName }} (.{{ format }})</div>
+
+        <!-- Progress bar -->
+        <div class="w-full bg-muted rounded-full h-2 overflow-hidden">
+          <template v-if="status === 'Running' || status === 'Writing'">
+            <div v-if="totalRows" class="h-full bg-primary rounded-full transition-[width] duration-300" :style="{ width: `${progressPercent}%` }" />
+            <div v-else class="h-full w-full overflow-hidden rounded-full">
+              <div class="export-progress-indeterminate h-full rounded-full bg-primary" />
+            </div>
+          </template>
+          <div v-else-if="status === 'Done'" class="h-full bg-green-500 rounded-full" style="width: 100%" />
+        </div>
+
+        <!-- Status message -->
+        <div class="flex items-center gap-2 text-sm">
+          <template v-if="status === 'Running'">
+            <Loader2 class="h-4 w-4 animate-spin text-primary" />
+            <span>{{ t("exportProgress.fetching") }}</span>
+          </template>
+          <template v-else-if="status === 'Writing'">
+            <Loader2 class="h-4 w-4 animate-spin text-primary" />
+            <span>{{ t("exportProgress.writing") }}</span>
+          </template>
+          <template v-else-if="status === 'Done'">
+            <CheckCircle2 class="h-4 w-4 text-green-500" />
+            <span class="text-green-700 dark:text-green-400">{{ t("exportProgress.done") }}</span>
+          </template>
+          <template v-else-if="status === 'Error'">
+            <XCircle class="h-4 w-4 text-destructive" />
+            <span class="text-destructive">{{ errorMessage || t("exportProgress.error") }}</span>
+          </template>
+          <template v-else-if="status === 'Cancelled'">
+            <AlertCircle class="h-4 w-4 text-yellow-500" />
+            <span class="text-yellow-700 dark:text-yellow-400">{{ t("exportProgress.cancelled") }}</span>
+          </template>
+        </div>
+
+        <!-- Row count -->
+        <div class="text-xs text-muted-foreground tabular-nums">
+          {{ rowsText }}
+        </div>
+      </div>
+
+      <DialogFooter>
+        <template v-if="isActive">
+          <Button variant="outline" size="sm" :disabled="disableCancel" @click="emit('cancel')">
+            <X class="h-3.5 w-3.5 mr-1" />
+            {{ t("exportProgress.cancel") }}
+          </Button>
+        </template>
+        <template v-else-if="isFinished">
+          <Button variant="outline" size="sm" @click="emit('update:open', false)">
+            {{ t("exportProgress.close") }}
+          </Button>
+        </template>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
+
+<style scoped>
+.export-progress-indeterminate {
+  width: 42%;
+  animation: export-progress-slide 1.15s ease-in-out infinite;
+}
+
+@keyframes export-progress-slide {
+  0% {
+    transform: translateX(-110%);
+  }
+  50% {
+    transform: translateX(70%);
+  }
+  100% {
+    transform: translateX(250%);
+  }
+}
+</style>
diff --git a/apps/desktop/src/components/export/ExportProgressPopover.vue b/apps/desktop/src/components/export/ExportProgressPopover.vue
new file mode 100644
index 0000000..b6073b7
--- /dev/null
+++ b/apps/desktop/src/components/export/ExportProgressPopover.vue
@@ -0,0 +1,223 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Button } from "@/components/ui/button";
+import { Loader2, CheckCircle2, XCircle, AlertCircle, X, FileDown, DatabaseBackup, FileCode2, ArrowRightLeft } from "@lucide/vue";
+import { useExportTracker, type ExportTask } from "@/composables/useExportTracker";
+
+const { t } = useI18n();
+const { tasks, activeCount, hasActive, clearFinished, cancelTask, removeTask } = useExportTracker();
+const open = ref(false);
+const showAll = ref(false);
+const MAX_VISIBLE = 5;
+
+const reversedTasks = computed(() => {
+  return [...tasks.value].reverse();
+});
+
+const visibleTasks = computed(() => {
+  return showAll.value ? reversedTasks.value : reversedTasks.value.slice(0, MAX_VISIBLE);
+});
+
+const hasMore = computed(() => tasks.value.length > MAX_VISIBLE);
+
+const isActive = (status: string) => status === "Running" || status === "Writing";
+const isFinished = (status: string) => status === "Done" || status === "Error" || status === "Cancelled";
+
+const finishedCount = computed(() => tasks.value.filter((t) => isFinished(t.status)).length);
+const failedCount = computed(() => tasks.value.filter((t) => t.status === "Error").length);
+const triggerTitle = computed(() => (failedCount.value > 0 ? t("exportProgress.failedTooltip", { count: failedCount.value }) : t("exportProgress.tooltip")));
+
+const progressPercent = (totalRows: number | null, rowsExported: number) => {
+  if (!totalRows || totalRows <= 0) return 0;
+  return Math.min(100, Math.round((rowsExported / totalRows) * 100));
+};
+
+const progressValue = (task: ExportTask) => {
+  if (task.kind === "database-export") {
+    if (!task.totalObjects || task.totalObjects <= 0) return 0;
+    return Math.min(100, Math.round(((task.objectIndex ?? 0) / task.totalObjects) * 100));
+  }
+  if (task.kind === "sql-file") {
+    const total = task.totalRows ?? task.statementIndex ?? 0;
+    if (task.status === "Done") return 100;
+    if (total <= 0) return 0;
+    return Math.min(95, Math.round((task.rowsExported / total) * 100));
+  }
+  if (task.kind === "data-transfer") {
+    if (!task.totalTables || task.totalTables <= 0) return 0;
+    if (task.status === "Done") return 100;
+    return Math.min(95, Math.round(((task.tableIndex ?? 0) / task.totalTables) * 100));
+  }
+  return progressPercent(task.totalRows, task.rowsExported);
+};
+
+const taskTitle = (task: ExportTask) => {
+  if (task.kind === "database-export") return t("exportProgress.databaseExportTitle", { name: task.tableName });
+  if (task.kind === "sql-file") return t("exportProgress.sqlFileTitle", { name: task.tableName });
+  if (task.kind === "data-transfer") return t("exportProgress.dataTransferTitle", { name: task.tableName });
+  return `${task.tableName}.${task.format}`;
+};
+
+const rowsText = (task: ExportTask) => {
+  if (task.kind === "database-export") {
+    if (task.totalObjects) {
+      return t("exportProgress.objectsCount", {
+        current: (task.objectIndex ?? 0).toLocaleString(),
+        total: task.totalObjects.toLocaleString(),
+      });
+    }
+    return t("exportProgress.rowsExported", { count: task.rowsExported.toLocaleString() });
+  }
+  if (task.kind === "sql-file") {
+    return t("exportProgress.statementsCount", {
+      done: (task.successCount ?? 0).toLocaleString(),
+      failed: (task.failureCount ?? 0).toLocaleString(),
+    });
+  }
+  if (task.kind === "data-transfer") {
+    const tableText = task.totalTables
+      ? t("exportProgress.tablesCount", {
+          current: (task.tableIndex ?? 0).toLocaleString(),
+          total: task.totalTables.toLocaleString(),
+        })
+      : task.currentTable || "";
+    const rowText = task.totalRows ? `${task.rowsExported.toLocaleString()} / ${task.totalRows.toLocaleString()} ${t("exportProgress.rowsShort")}` : `${task.rowsExported.toLocaleString()} ${t("exportProgress.rowsShort")}`;
+    return task.currentTable ? `${tableText} · ${task.currentTable} · ${rowText}` : tableText;
+  }
+  if (task.totalRows) return `${task.rowsExported.toLocaleString()} / ${task.totalRows.toLocaleString()}`;
+  return `${task.rowsExported.toLocaleString()} ${t("exportProgress.rowsShort")}`;
+};
+
+const statusIcon = (task: ExportTask) => {
+  if (isActive(task.status)) {
+    if (task.kind === "database-export") return DatabaseBackup;
+    if (task.kind === "sql-file") return FileCode2;
+    if (task.kind === "data-transfer") return ArrowRightLeft;
+  }
+  switch (task.status) {
+    case "Running":
+    case "Writing":
+      return Loader2;
+    case "Done":
+      return CheckCircle2;
+    case "Error":
+      return XCircle;
+    case "Cancelled":
+      return AlertCircle;
+    default:
+      return Loader2;
+  }
+};
+
+const statusColor = (status: string) => {
+  switch (status) {
+    case "Running":
+    case "Writing":
+      return "text-primary";
+    case "Done":
+      return "text-green-500";
+    case "Error":
+      return "text-destructive";
+    case "Cancelled":
+      return "text-yellow-500";
+    default:
+      return "text-muted-foreground";
+  }
+};
+
+function toggleShowAll() {
+  showAll.value = !showAll.value;
+}
+</script>
+
+<template>
+  <Popover v-if="tasks.length > 0" v-model:open="open">
+    <PopoverTrigger as-child>
+      <Button variant="ghost" size="icon" class="relative h-8 w-8" :title="triggerTitle" :class="{ 'bg-destructive/10 text-destructive hover:bg-destructive/15': failedCount > 0, 'bg-accent text-primary': failedCount === 0 && hasActive }">
+        <FileDown class="h-4 w-4" />
+        <span v-if="failedCount > 0" class="absolute -right-0.5 -top-0.5 flex h-4 min-w-4 items-center justify-center rounded-full bg-destructive px-1 text-[10px] font-bold leading-none text-destructive-foreground"> ! </span>
+        <span v-else-if="hasActive" class="absolute -right-0.5 -top-0.5 flex h-4 min-w-4 items-center justify-center rounded-full bg-primary px-1 text-[10px] font-medium leading-none text-primary-foreground">
+          {{ activeCount > 9 ? "9+" : activeCount }}
+        </span>
+      </Button>
+    </PopoverTrigger>
+
+    <PopoverContent align="start" class="w-[min(92vw,30rem)] p-0 gap-0 overflow-hidden" :side-offset="8">
+      <div class="border-b bg-muted/40 px-4 py-3">
+        <div class="text-sm font-semibold">{{ t("exportProgress.popoverTitle") }}</div>
+      </div>
+
+      <div class="max-h-96 overflow-y-auto">
+        <div v-for="task in visibleTasks" :key="task.exportId" class="flex items-start gap-3 border-b px-4 py-3 text-xs last:border-b-0">
+          <div class="flex-1 min-w-0 flex flex-col gap-1.5">
+            <div class="flex items-center gap-1.5">
+              <component :is="statusIcon(task)" :class="[statusColor(task.status), task.kind === 'table-export' && isActive(task.status) ? 'animate-spin' : '']" class="h-3.5 w-3.5 shrink-0" />
+              <span class="truncate font-medium">{{ taskTitle(task) }}</span>
+            </div>
+
+            <!-- Progress bar -->
+            <div v-if="isActive(task.status)" class="w-full bg-muted rounded-full h-1.5 overflow-hidden">
+              <div v-if="task.totalRows || (task.kind === 'database-export' && task.totalObjects) || (task.kind === 'data-transfer' && task.totalTables)" class="h-full bg-primary rounded-full transition-[width] duration-300" :style="{ width: `${progressValue(task)}%` }" />
+              <div v-else class="h-full w-full overflow-hidden rounded-full">
+                <div class="export-progress-indeterminate h-full rounded-full bg-primary" />
+              </div>
+            </div>
+            <div v-else-if="task.status === 'Done'" class="w-full bg-muted rounded-full h-1.5 overflow-hidden">
+              <div class="h-full bg-green-500 rounded-full" style="width: 100%" />
+            </div>
+
+            <div class="min-w-0 text-muted-foreground">
+              <span class="break-words tabular-nums">{{ rowsText(task) }}</span>
+              <span v-if="task.status === 'Error' && task.errorMessage" class="mt-1 block whitespace-normal break-words text-destructive" :title="task.errorMessage">
+                {{ task.errorMessage }}
+              </span>
+            </div>
+          </div>
+
+          <!-- Actions: stop/cancel for active, delete for finished -->
+          <div class="flex shrink-0 pt-4">
+            <button v-if="isActive(task.status)" class="flex h-6 w-6 items-center justify-center rounded hover:bg-muted" :title="t('exportProgress.cancel')" @click="cancelTask(task.exportId)">
+              <X class="h-3.5 w-3.5 text-muted-foreground hover:text-destructive" />
+            </button>
+            <button v-else class="flex h-6 w-6 items-center justify-center rounded hover:bg-muted" :title="t('exportProgress.delete')" @click="removeTask(task.exportId)">
+              <X class="h-3.5 w-3.5 text-muted-foreground hover:text-foreground" />
+            </button>
+          </div>
+        </div>
+      </div>
+
+      <div v-if="hasMore" class="border-t bg-muted/30 px-3 py-1.5">
+        <button class="w-full text-center text-xs text-muted-foreground hover:text-foreground" @click="toggleShowAll">
+          {{ showAll ? t("exportProgress.showLess") : t("exportProgress.showMore", { count: tasks.length - MAX_VISIBLE }) }}
+        </button>
+      </div>
+
+      <div v-if="finishedCount > 0" class="border-t bg-muted/30 px-3 py-1.5">
+        <button class="w-full text-center text-xs text-muted-foreground hover:text-foreground" @click="clearFinished">
+          {{ t("exportProgress.clearFinished") }}
+        </button>
+      </div>
+    </PopoverContent>
+  </Popover>
+</template>
+
+<style scoped>
+.export-progress-indeterminate {
+  width: 42%;
+  animation: export-progress-slide 1.15s ease-in-out infinite;
+}
+
+@keyframes export-progress-slide {
+  0% {
+    transform: translateX(-110%);
+  }
+  50% {
+    transform: translateX(70%);
+  }
+  100% {
+    transform: translateX(250%);
+  }
+}
+</style>
diff --git a/apps/desktop/src/components/generate/DataGenerateDialog.vue b/apps/desktop/src/components/generate/DataGenerateDialog.vue
new file mode 100644
index 0000000..bcb30ca
--- /dev/null
+++ b/apps/desktop/src/components/generate/DataGenerateDialog.vue
@@ -0,0 +1,1025 @@
+<script setup lang="ts">
+import { reactive, ref, computed, onMounted, watch, type ComponentPublicInstance } from "vue";
+import { useI18n } from "vue-i18n";
+import { useConnectionStore } from "@/stores/connectionStore";
+import * as api from "@/lib/backend/api";
+import type { TableGenerateConfig } from "@/lib/dataGrid/dataGenerate";
+import { displayGeneratedValue, findGeneratorKey, formatGeneratedValue, generateTableData, defaultGeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import { quoteTableIdentifier } from "@/lib/table/tableSelectSql";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import GeneratorParamsPanel from "./params/GeneratorParamsPanel.vue";
+import type { ColumnInfo, TableInfo } from "@/types/database";
+
+import { Dialog, DialogHeader, DialogTitle, DialogScrollContent, DialogContent, DialogFooter } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Database, Table, Columns, Loader2, Save, Upload, Settings, ChevronRight, X, AlertCircle, ArrowUp, ArrowDown } from "@lucide/vue";
+import { ScrollArea } from "@/components/ui/scroll-area";
+
+const { t } = useI18n();
+const store = useConnectionStore();
+const dbType = computed(() => effectiveDatabaseTypeForConnection(store.getConfig(props.prefillConnectionId ?? "")));
+const open = defineModel<boolean>("open", { default: false });
+
+const props = defineProps<{
+  prefillConnectionId?: string;
+  prefillDatabase?: string;
+  prefillSchema?: string;
+  prefillTable?: string;
+}>();
+
+// Left tree state
+const schemas = ref<string[]>([]);
+const expandedSchemas = reactive<Record<string, boolean>>({});
+const schemaTables = reactive<Record<string, TableInfo[]>>({});
+const schemaLoading = reactive<Record<string, boolean>>({});
+const schemaError = reactive<Record<string, string>>({});
+const loading = ref(false);
+
+// Table expansion and columns cache
+const expandedTables = reactive<Record<string, boolean>>({});
+const tableColumnsExt = reactive<Record<string, ColumnInfo[]>>({});
+const tableColumnsLoading = reactive<Record<string, boolean>>({});
+
+// Config cache
+const configs = reactive<Record<string, TableGenerateConfig>>({});
+const checkedTables = reactive<Record<string, boolean>>({});
+const checkedColumns = reactive<Record<string, boolean>>({});
+
+// Right panel state — explicitly set by activation functions
+const panelTableKey = ref<string | null>(null);
+const panelMode = ref<"table" | "column" | null>(null);
+const panelColumnName = ref<string | null>(null);
+
+// Step state: config -> preview
+const currentStep = ref<"config" | "preview" | "result">("config");
+const generatedResults = ref<{ tableName: string; columns: string[]; rows: unknown[][]; sql: string }[]>([]);
+
+const connectionName = computed(() => (props.prefillConnectionId ? store.getConfig(props.prefillConnectionId)?.name : ""));
+
+function tableKey(schema: string, table: string) {
+  return `${schema}.${table}`;
+}
+function colKey(schema: string, table: string, column: string) {
+  return `${schema}.${table}.${column}`;
+}
+
+// Derived state for template
+const activeCfg = computed(() => {
+  const k = panelTableKey.value;
+  return k ? (configs[k] ?? null) : null;
+});
+const activeCol = computed(() => {
+  if (panelMode.value !== "column" || !panelColumnName.value || !activeCfg.value) return null;
+  return activeCfg.value.columns.find((c) => c.columnName === panelColumnName.value) ?? null;
+});
+
+async function loadSchemas() {
+  const cid = props.prefillConnectionId;
+  const db = props.prefillDatabase;
+  if (!cid || !db) return;
+  loading.value = true;
+  try {
+    await store.ensureConnected(cid);
+
+    let schemaList: string[];
+    try {
+      schemaList = await api.listSchemas(cid, db);
+    } catch {
+      schemaList = [];
+    }
+    if (schemaList.length === 0) {
+      schemaList = [props.prefillSchema || db || "main"];
+    }
+    schemas.value = schemaList;
+
+    const schemaCandidates = props.prefillSchema && schemaList.includes(props.prefillSchema) ? [props.prefillSchema] : [schemaList[0]];
+
+    if (props.prefillTable && schemaCandidates[0]) {
+      for (const targetSchema of schemaCandidates) {
+        if (!targetSchema) continue;
+        expandedSchemas[targetSchema] = true;
+        try {
+          const tables = await api.listTables(cid, db, targetSchema);
+          schemaTables[targetSchema] = tables;
+          if (tables.some((t: { name: string }) => t.name === props.prefillTable)) {
+            const cols = await api.getColumns(cid, db, targetSchema, props.prefillTable);
+            const key = tableKey(targetSchema, props.prefillTable);
+            configs[key] = {
+              tableName: props.prefillTable,
+              schema: targetSchema,
+              database: db,
+              rowCount: 1000,
+              columns: cols.map((c: ColumnInfo) => {
+                const isAI = c.extra === "auto_increment" || (c.column_default?.toLowerCase().includes("nextval") ?? false);
+                const gKey = findGeneratorKey(c.name, c.data_type, isAI);
+                return {
+                  columnName: c.name,
+                  dataType: c.data_type,
+                  rowCount: 1000,
+                  generatorKey: gKey,
+                  generatorParams: defaultGeneratorParams(
+                    c.name,
+                    {
+                      dataType: c.data_type,
+                      isAutoIncrement: isAI,
+                      columnDefault: c.column_default,
+                      numericPrecision: c.numeric_precision,
+                      numericScale: c.numeric_scale,
+                      characterMaximumLength: c.character_maximum_length,
+                    },
+                    gKey,
+                  ),
+                  isAutoIncrement: isAI,
+                  columnDefault: c.column_default,
+                };
+              }),
+            };
+            checkedTables[key] = true;
+            for (const c of cols) {
+              checkedColumns[colKey(targetSchema, props.prefillTable, c.name)] = true;
+            }
+            break;
+          }
+        } catch {
+          // try next schema
+        }
+      }
+    }
+  } catch {
+    // silently fail
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function toggleSchema(schema: string) {
+  if (expandedSchemas[schema]) {
+    expandedSchemas[schema] = false;
+    return;
+  }
+  expandedSchemas[schema] = true;
+  if (!schemaTables[schema] && props.prefillConnectionId && props.prefillDatabase) {
+    schemaLoading[schema] = true;
+    schemaError[schema] = "";
+    try {
+      const tables = await api.listTables(props.prefillConnectionId, props.prefillDatabase, schema);
+      schemaTables[schema] = tables;
+    } catch (e: any) {
+      schemaError[schema] = String(e?.message ?? e);
+    } finally {
+      schemaLoading[schema] = false;
+    }
+  }
+}
+
+async function toggleTable(schema: string, table: string) {
+  const key = tableKey(schema, table);
+  if (expandedTables[key]) {
+    expandedTables[key] = false;
+    return;
+  }
+  expandedTables[key] = true;
+  if (!tableColumnsExt[key] && props.prefillConnectionId && props.prefillDatabase) {
+    tableColumnsLoading[key] = true;
+    try {
+      const cols = await api.getColumns(props.prefillConnectionId, props.prefillDatabase, schema, table);
+      tableColumnsExt[key] = cols;
+    } catch {
+      // ignore
+    } finally {
+      tableColumnsLoading[key] = false;
+    }
+  }
+}
+
+async function loadColumns(schema: string, table: string) {
+  const key = tableKey(schema, table);
+  if (configs[key]) return configs[key];
+  if (!props.prefillConnectionId || !props.prefillDatabase) return null;
+  const cols = await api.getColumns(props.prefillConnectionId, props.prefillDatabase, schema, table);
+  const cfg: TableGenerateConfig = {
+    tableName: table,
+    schema,
+    database: props.prefillDatabase,
+    rowCount: 1000,
+    columns: cols.map((c: ColumnInfo) => {
+      const isAI = c.extra === "auto_increment" || (c.column_default?.toLowerCase().includes("nextval") ?? false);
+      const gKey = findGeneratorKey(c.name, c.data_type, isAI);
+      return {
+        columnName: c.name,
+        dataType: c.data_type,
+        rowCount: 1000,
+        generatorKey: gKey,
+        generatorParams: defaultGeneratorParams(
+          c.name,
+          {
+            dataType: c.data_type,
+            isAutoIncrement: isAI,
+            columnDefault: c.column_default,
+            numericPrecision: c.numeric_precision,
+            numericScale: c.numeric_scale,
+            characterMaximumLength: c.character_maximum_length,
+          },
+          gKey,
+        ),
+        isAutoIncrement: isAI,
+        columnDefault: c.column_default,
+      };
+    }),
+  };
+  configs[key] = cfg;
+  for (const c of cols) {
+    const ck = colKey(schema, table, c.name);
+    if (checkedColumns[ck] === undefined) checkedColumns[ck] = true;
+  }
+  return cfg;
+}
+
+async function selectTable(schema: string, table: string, checked: boolean) {
+  const key = tableKey(schema, table);
+  if (checked) {
+    checkedTables[key] = true;
+    if (!configs[key]) {
+      await loadColumns(schema, table);
+    }
+    const cols = tableColumnsExt[key] ?? configs[key]?.columns;
+    if (cols) {
+      for (const c of cols) {
+        checkedColumns[colKey(schema, table, c.name ?? (c as any).columnName)] = true;
+      }
+    }
+  } else {
+    delete checkedTables[key];
+    const cols = tableColumnsExt[key] ?? configs[key]?.columns;
+    if (cols) {
+      for (const c of cols) {
+        checkedColumns[colKey(schema, table, c.name ?? (c as any).columnName)] = false;
+      }
+    }
+  }
+}
+
+function toggleColumn(schema: string, table: string, column: string) {
+  const ck = colKey(schema, table, column);
+  const key = tableKey(schema, table);
+  checkedColumns[ck] = !checkedColumns[ck];
+  if (checkedColumns[ck]) {
+    checkedTables[key] = true;
+  } else {
+    const cols = tableColumnsExt[key] ?? configs[key]?.columns;
+    if (cols) {
+      const hasAny = cols.some((c) => checkedColumns[colKey(schema, table, c.name ?? (c as any).columnName)]);
+      if (!hasAny) delete checkedTables[key];
+    }
+  }
+}
+
+async function showColumn(schema: string, table: string, column: string) {
+  const key = tableKey(schema, table);
+  if (!configs[key]) {
+    try {
+      await loadColumns(schema, table);
+    } catch {
+      return;
+    }
+  }
+  panelTableKey.value = key;
+  panelMode.value = "column";
+  panelColumnName.value = column;
+}
+
+async function showTable(schema: string, table: string) {
+  const key = tableKey(schema, table);
+  if (!configs[key]) {
+    try {
+      await loadColumns(schema, table);
+    } catch {
+      return;
+    }
+  }
+  panelTableKey.value = key;
+  panelMode.value = "table";
+  panelColumnName.value = null;
+}
+
+const previewTableIndex = ref(0);
+const previewColWidths = reactive<Record<number, number>>({});
+
+function onPreviewColResizeStart(ci: number, event: MouseEvent) {
+  event.preventDefault();
+  const startX = event.clientX;
+  const startW = previewColWidths[ci] ?? 120;
+  const onMove = (e: MouseEvent) => {
+    previewColWidths[ci] = Math.max(60, startW + e.clientX - startX);
+  };
+  const onUp = () => {
+    document.removeEventListener("pointermove", onMove);
+    document.removeEventListener("pointerup", onUp);
+    document.body.classList.remove("select-none", "cursor-col-resize");
+  };
+  document.addEventListener("pointermove", onMove);
+  document.addEventListener("pointerup", onUp);
+  document.body.classList.add("select-none", "cursor-col-resize");
+}
+const currentPreview = computed(() => generatedResults.value[previewTableIndex.value] ?? { tableName: "", columns: [], rows: [], sql: "" });
+
+function displayPreviewCell(cell: unknown): string {
+  return displayGeneratedValue(cell);
+}
+
+async function fetchMaxValues(cfg: TableGenerateConfig): Promise<Record<string, number>> {
+  const starts: Record<string, number> = {};
+  const aiCols = cfg.columns.filter((c) => {
+    const ck = colKey(cfg.schema, cfg.tableName, c.columnName);
+    return c.isAutoIncrement && checkedColumns[ck] !== false;
+  });
+  if (aiCols.length === 0) return starts;
+  const cid = props.prefillConnectionId!;
+  const db = props.prefillDatabase!;
+  for (const col of aiCols) {
+    try {
+      const schemaPart = cfg.schema ? `${quoteTableIdentifier(dbType.value, cfg.schema)}.` : "";
+      const sql = `SELECT COALESCE(MAX(${quoteTableIdentifier(dbType.value, col.columnName)}), 0) FROM ${schemaPart}${quoteTableIdentifier(dbType.value, cfg.tableName)}`;
+      const result = await api.executeQuery(cid, db, sql, cfg.schema, undefined, { maxRows: 1 });
+      const val = result.rows.length > 0 ? Number(result.rows[0][0]) : 0;
+      starts[col.columnName] = (Number.isNaN(val) ? 0 : val) + 1;
+    } catch {
+      starts[col.columnName] = 1;
+    }
+  }
+  return starts;
+}
+
+async function doGenerate() {
+  const results: { tableName: string; columns: string[]; rows: unknown[][]; sql: string }[] = [];
+  const order = tableOrder.value.length > 0 ? tableOrder.value : Object.keys(configs);
+  for (const key of order) {
+    if (!checkedTables[key]) continue;
+    const cfg = configs[key];
+    let columns = cfg.columns.filter((col) => checkedColumns[colKey(cfg.schema, cfg.tableName, col.columnName)] !== false);
+    if (columns.length === 0) continue;
+    const aiStarts = await fetchMaxValues(cfg);
+    if (Object.keys(aiStarts).length > 0) {
+      columns = columns.map((col) => {
+        const start = aiStarts[col.columnName];
+        if (start !== undefined) {
+          return { ...col, generatorKey: "sequence", generatorParams: { startValue: start, increment: 1 } };
+        }
+        return col;
+      });
+    }
+    const result = generateTableData({ ...cfg, columns }, dbType.value);
+    results.push({ tableName: cfg.tableName, columns: result.columns, rows: result.rows, sql: result.sql });
+  }
+  generatedResults.value = results;
+  previewTableIndex.value = 0;
+  currentStep.value = "preview";
+}
+
+async function regenerate() {
+  if (generatedResults.value.length === 0) return;
+  const key = Object.keys(configs).find((k) => configs[k].tableName === generatedResults.value[previewTableIndex.value]?.tableName);
+  if (!key) return;
+  const cfg = configs[key];
+  let columns = cfg.columns.filter((col) => checkedColumns[colKey(cfg.schema, cfg.tableName, col.columnName)] !== false);
+  const aiStarts = await fetchMaxValues(cfg);
+  if (Object.keys(aiStarts).length > 0) {
+    columns = columns.map((col) => {
+      const start = aiStarts[col.columnName];
+      if (start !== undefined) {
+        return { ...col, generatorKey: "sequence", generatorParams: { startValue: start, increment: 1 } };
+      }
+      return col;
+    });
+  }
+  const result = generateTableData({ ...cfg, columns }, dbType.value);
+  generatedResults.value[previewTableIndex.value] = { tableName: cfg.tableName, columns: result.columns, rows: result.rows, sql: result.sql };
+}
+
+function copyAllSql() {
+  const allSql = allSqlStatements().join("\n\n");
+  void navigator.clipboard.writeText(allSql);
+}
+
+const executing = ref(false);
+
+interface TableResult {
+  table: string;
+  total: number;
+  ok: number;
+  err: number;
+  error?: string;
+}
+const executeResults = ref<TableResult[]>([]);
+
+const generateOptions = reactive({
+  continueOnError: false,
+  truncate: false,
+  useTransaction: true,
+  extendedInsert: true,
+});
+
+const optionsDialogOpen = ref(false);
+
+function sqlStatementsForTable(r: { tableName: string; columns: string[]; rows: unknown[][]; sql: string }): string[] {
+  const stmts: string[] = [];
+  if (generateOptions.truncate) {
+    stmts.push(`TRUNCATE TABLE ${quoteTableIdentifier(dbType.value, r.tableName)};`);
+  }
+  if (generateOptions.extendedInsert) {
+    stmts.push(r.sql);
+  } else {
+    const colList = r.columns.map((c) => quoteTableIdentifier(dbType.value, c)).join(", ");
+    for (const row of r.rows) {
+      const vals = row.map(formatGeneratedValue).join(", ");
+      stmts.push(`INSERT INTO ${quoteTableIdentifier(dbType.value, r.tableName)} (${colList}) VALUES (${vals});`);
+    }
+  }
+  return stmts;
+}
+
+function allSqlStatements(): string[] {
+  return generatedResults.value.flatMap((r) => sqlStatementsForTable(r));
+}
+
+async function startInsert() {
+  if (executing.value) return;
+  const cid = props.prefillConnectionId;
+  const db = props.prefillDatabase;
+  if (!cid || !db) return;
+  const sql = allSqlStatements().join("\n");
+  if (!sql.trim()) return;
+  try {
+    await executeWithProductionSqlGuard({
+      connection: store.getConfig(cid),
+      database: db,
+      sql,
+      source: t("production.sourceDataGenerate"),
+      execute: async () => {
+        executing.value = true;
+        const perTable: TableResult[] = [];
+        for (const r of generatedResults.value) {
+          const stmts = sqlStatementsForTable(r);
+          const rowCount = r.rows.length;
+          let ok = 0;
+          let lastError = "";
+          for (let si = 0; si < stmts.length; si++) {
+            try {
+              if (generateOptions.useTransaction) {
+                await api.executeInTransaction(cid, db, [stmts[si]], props.prefillSchema);
+              } else {
+                await api.executeQuery(cid, db, stmts[si], props.prefillSchema);
+              }
+              if (generateOptions.extendedInsert) {
+                ok = rowCount;
+              } else if (!(generateOptions.truncate && si === 0)) {
+                ok++;
+              }
+            } catch (e: unknown) {
+              const msg = e instanceof Error ? e.message : String(e);
+              console.error("[startInsert] SQL error:", msg);
+              if (!lastError) lastError = msg;
+              if (generateOptions.extendedInsert) {
+                ok = 0;
+              }
+              if (!generateOptions.continueOnError) break;
+            }
+          }
+          perTable.push({ table: r.tableName, total: rowCount, ok, err: rowCount - ok, error: lastError || undefined });
+          if (ok > 0) {
+            store.invalidateMetadataCache(cid, db, props.prefillSchema || undefined, r.tableName);
+          }
+        }
+        executeResults.value = perTable;
+        currentStep.value = "result";
+        return true;
+      },
+    });
+  } finally {
+    executing.value = false;
+  }
+}
+
+const orderDialogOpen = ref(false);
+const tableOrder = ref<string[]>([]);
+
+const orderableTables = computed(() => {
+  return Object.keys(checkedTables).filter((k) => checkedTables[k]);
+});
+
+function openOrderDialog() {
+  tableOrder.value = [...orderableTables.value];
+  orderDialogOpen.value = true;
+}
+
+function moveOrderItem(index: number, dir: -1 | 1) {
+  const target = index + dir;
+  if (target < 0 || target >= tableOrder.value.length) return;
+  const arr = tableOrder.value;
+  [arr[index], arr[target]] = [arr[target], arr[index]];
+}
+
+function isPartialTable(schema: string, table: string): boolean {
+  const key = tableKey(schema, table);
+  const cols = tableColumnsExt[key] ?? configs[key]?.columns;
+  if (!cols || cols.length === 0) return false;
+  let n = 0;
+  for (const c of cols) {
+    if (checkedColumns[colKey(schema, table, c.name ?? (c as any).columnName)]) n++;
+  }
+  return n > 0 && n < cols.length;
+}
+
+const tableCheckboxRefs = reactive<Record<string, HTMLInputElement | null>>({});
+function setTableRef(el: Element | ComponentPublicInstance | null, key: string) {
+  const input = el instanceof Element ? (el as HTMLInputElement) : null;
+  tableCheckboxRefs[key] = input;
+  if (input) {
+    const parts = key.split(".");
+    if (parts.length >= 2) {
+      const schema = parts.slice(0, -1).join(".");
+      const table = parts[parts.length - 1];
+      input.indeterminate = isPartialTable(schema, table);
+    }
+  }
+}
+watch(
+  () => [checkedColumns, tableColumnsExt, configs] as const,
+  () => {
+    for (const key of Object.keys(tableCheckboxRefs)) {
+      const el = tableCheckboxRefs[key];
+      if (!el) continue;
+      const parts = key.split(".");
+      if (parts.length < 2) continue;
+      const schema = parts.slice(0, -1).join(".");
+      const table = parts[parts.length - 1];
+      el.indeterminate = isPartialTable(schema, table);
+    }
+  },
+  { deep: true, flush: "post" },
+);
+
+onMounted(() => {
+  void loadSchemas();
+});
+
+watch(open, (val) => {
+  if (val) {
+    void loadSchemas();
+  }
+});
+
+interface GenerateProfileJson {
+  version: 1;
+  connectionId?: string;
+  database?: string;
+  savedAt: string;
+  configs: Record<string, TableGenerateConfig>;
+  checkedTables: Record<string, boolean>;
+  checkedColumns: Record<string, boolean>;
+  expandedTables: Record<string, boolean>;
+  expandedSchemas: Record<string, boolean>;
+  tableOrder: string[];
+}
+
+const fileInputRef = ref<HTMLInputElement | null>(null);
+
+function buildProfilePayload(): GenerateProfileJson {
+  return {
+    version: 1,
+    connectionId: props.prefillConnectionId,
+    database: props.prefillDatabase,
+    savedAt: new Date().toISOString(),
+    configs: JSON.parse(JSON.stringify(configs)),
+    checkedTables: { ...checkedTables },
+    checkedColumns: { ...checkedColumns },
+    expandedTables: { ...expandedTables },
+    expandedSchemas: { ...expandedSchemas },
+    tableOrder: [...tableOrder.value],
+  };
+}
+
+function defaultProfileFilename(): string {
+  const payload = buildProfilePayload();
+  const tableNames = Object.keys(payload.configs);
+  const firstTableName = tableNames[0]?.split(".").pop() || "profile";
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  return tableNames.length === 1 ? `${firstTableName}-${timestamp}.json` : `data-generate-${timestamp}.json`;
+}
+
+function downloadJsonFallback(data: GenerateProfileJson, filename: string) {
+  const json = JSON.stringify(data, null, 2);
+  const blob = new Blob([json], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}
+
+async function saveProfile() {
+  const payload = buildProfilePayload();
+  const json = JSON.stringify(payload, null, 2);
+  const defaultPath = defaultProfileFilename();
+
+  if (isTauriRuntime()) {
+    try {
+      const { save } = await import("@tauri-apps/plugin-dialog");
+      const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+      const path = await save({
+        defaultPath,
+        filters: [{ name: "JSON", extensions: ["json"] }],
+      });
+      if (path) {
+        await writeTextFile(path, json);
+      }
+    } catch (e: any) {
+      console.warn("profile save error (tauri):", e?.message ?? e);
+    }
+  } else {
+    downloadJsonFallback(payload, defaultPath);
+  }
+}
+
+function applyProfileData(data: Partial<GenerateProfileJson> & { configs?: Record<string, TableGenerateConfig> }) {
+  if (!data.configs || typeof data.configs !== "object") {
+    throw new Error("Invalid profile file: missing configs");
+  }
+  Object.keys(configs).forEach((k) => delete configs[k]);
+  Object.keys(checkedTables).forEach((k) => delete checkedTables[k]);
+  Object.keys(checkedColumns).forEach((k) => delete checkedColumns[k]);
+  Object.keys(expandedTables).forEach((k) => delete expandedTables[k]);
+
+  for (const [key, cfg] of Object.entries(data.configs)) {
+    if (cfg && cfg.tableName) configs[key] = cfg;
+  }
+  if (data.checkedTables && typeof data.checkedTables === "object") {
+    for (const [k, v] of Object.entries(data.checkedTables)) {
+      checkedTables[k] = !!v;
+    }
+  }
+  if (data.checkedColumns && typeof data.checkedColumns === "object") {
+    for (const [k, v] of Object.entries(data.checkedColumns)) {
+      checkedColumns[k] = !!v;
+    }
+  }
+  if (data.expandedTables && typeof data.expandedTables === "object") {
+    for (const [k, v] of Object.entries(data.expandedTables)) {
+      expandedTables[k] = !!v;
+    }
+  }
+  if (data.expandedSchemas && typeof data.expandedSchemas === "object") {
+    for (const [k, v] of Object.entries(data.expandedSchemas)) {
+      expandedSchemas[k] = !!v;
+    }
+  }
+  if (Array.isArray(data.tableOrder)) {
+    tableOrder.value = [...data.tableOrder];
+  }
+}
+
+async function triggerLoadProfile() {
+  if (isTauriRuntime()) {
+    try {
+      const { open } = await import("@tauri-apps/plugin-dialog");
+      const { readTextFile } = await import("@tauri-apps/plugin-fs");
+      const path = await open({
+        multiple: false,
+        filters: [{ name: "JSON", extensions: ["json"] }],
+      });
+      if (!path) return;
+      const text = await readTextFile(path as string);
+      const data = JSON.parse(text);
+      applyProfileData(data);
+    } catch (e: any) {
+      console.warn("profile load error (tauri):", e?.message ?? e);
+    }
+  } else {
+    fileInputRef.value?.click();
+  }
+}
+
+async function onFileSelected(event: Event) {
+  const input = event.target as HTMLInputElement;
+  const file = input.files?.[0];
+  if (!file) return;
+  try {
+    const text = await file.text();
+    const data = JSON.parse(text);
+    applyProfileData(data);
+  } catch (e: any) {
+    console.warn("profile load error:", e?.message ?? e);
+  } finally {
+    input.value = "";
+  }
+}
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogScrollContent class="max-w-[1100px] pt-12">
+      <DialogHeader>
+        <DialogTitle class="flex items-center gap-2 text-base">
+          <Database class="h-4 w-4" />
+          {{ t("dataGenerate.title") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="rounded-md border bg-muted/20 px-3 py-2 text-sm">
+        <span class="text-muted-foreground">{{ t("dataGenerate.target") }}:</span>
+        <span class="ml-1 font-medium">{{ connectionName || props.prefillDatabase }}</span>
+      </div>
+
+      <template v-if="currentStep === 'config'">
+        <div class="flex gap-4 min-h-[400px]">
+          <!-- left: schema tree -->
+          <div class="w-64 shrink-0 rounded-md border">
+            <div class="border-b px-3 py-2 text-xs font-medium text-muted-foreground">
+              {{ t("dataGenerate.databaseObjects") }}
+            </div>
+            <ScrollArea class="h-[380px] p-1">
+              <div v-if="loading" class="flex items-center justify-center py-8">
+                <Loader2 class="h-4 w-4 animate-spin text-muted-foreground" />
+              </div>
+              <div v-else-if="schemas.length === 0" class="py-8 text-center text-xs text-muted-foreground">(empty)</div>
+
+              <div v-for="sc in schemas" :key="sc">
+                <div class="group flex items-center gap-1.5 py-1 px-2 cursor-pointer hover:bg-accent" @click="toggleSchema(sc)">
+                  <button type="button" class="-m-0.5 flex h-4 w-4 shrink-0 items-center justify-center rounded-sm text-muted-foreground hover:bg-muted hover:text-foreground">
+                    <Loader2 v-if="schemaLoading[sc]" class="h-3.5 w-3.5 animate-spin" />
+                    <ChevronRight v-else class="h-3.5 w-3.5 transition-transform" :class="{ 'rotate-90': expandedSchemas[sc] }" />
+                  </button>
+                  <span class="text-sm truncate">{{ sc }}</span>
+                  <AlertCircle v-if="schemaError[sc]" class="ml-auto h-3.5 w-3.5 text-destructive shrink-0" />
+                </div>
+
+                <div v-if="expandedSchemas[sc] && schemaTables[sc]" class="ml-[18px]">
+                  <div v-for="tbl in schemaTables[sc]" :key="tbl.name">
+                    <!-- table row -->
+                    <div class="group flex items-center gap-1.5 py-1 px-2 cursor-pointer hover:bg-accent">
+                      <button type="button" class="-m-0.5 flex h-4 w-4 shrink-0 items-center justify-center rounded-sm text-muted-foreground hover:bg-muted hover:text-foreground" @click="toggleTable(sc, tbl.name)">
+                        <Loader2 v-if="tableColumnsLoading[tableKey(sc, tbl.name)]" class="h-3.5 w-3.5 animate-spin" />
+                        <ChevronRight v-else class="h-3.5 w-3.5 transition-transform" :class="{ 'rotate-90': expandedTables[tableKey(sc, tbl.name)] }" />
+                      </button>
+                      <input type="checkbox" class="h-3.5 w-3.5 accent-primary shrink-0" :checked="!!checkedTables[tableKey(sc, tbl.name)]" :ref="(el) => setTableRef(el, tableKey(sc, tbl.name))" @change="selectTable(sc, tbl.name, ($event.target as HTMLInputElement).checked)" />
+                      <Table class="h-3.5 w-3.5 shrink-0 text-green-500" />
+                      <span class="text-sm truncate" :class="{ 'text-foreground font-medium': panelTableKey === tableKey(sc, tbl.name), 'text-muted-foreground': panelTableKey !== tableKey(sc, tbl.name) }" @click="showTable(sc, tbl.name)">
+                        {{ tbl.name }}
+                      </span>
+                    </div>
+                    <!-- column children -->
+                    <div v-if="expandedTables[tableKey(sc, tbl.name)] && tableColumnsExt[tableKey(sc, tbl.name)]" class="ml-[36px]">
+                      <div
+                        v-for="col in tableColumnsExt[tableKey(sc, tbl.name)]"
+                        :key="col.name"
+                        class="group flex items-center gap-1.5 py-0.5 px-2 cursor-pointer hover:bg-accent"
+                        :class="{ 'bg-accent': panelColumnName === col.name && panelTableKey === tableKey(sc, tbl.name) }"
+                        @click="showColumn(sc, tbl.name, col.name)"
+                      >
+                        <input type="checkbox" class="h-3 w-3 accent-primary shrink-0" :checked="!!checkedColumns[colKey(sc, tbl.name, col.name)]" @click.stop @change="toggleColumn(sc, tbl.name, col.name)" />
+                        <Columns class="h-3 w-3 shrink-0 text-muted-foreground" />
+                        <span class="text-xs truncate font-mono">{{ col.name }}</span>
+                      </div>
+                    </div>
+                  </div>
+                </div>
+
+                <div v-else-if="expandedSchemas[sc] && schemaLoading[sc]" class="ml-[18px] px-2 py-1 text-xs text-muted-foreground">Loading...</div>
+                <div v-else-if="expandedSchemas[sc] && schemaError[sc]" class="ml-[18px] px-2 py-1 text-xs text-destructive">
+                  {{ schemaError[sc] }}
+                </div>
+              </div>
+            </ScrollArea>
+          </div>
+
+          <!-- right: active table config -->
+          <div class="flex-1 rounded-md border">
+            <div class="h-[380px] p-1 pt-10 overflow-y-auto">
+              <div v-if="!activeCfg" class="flex h-full items-center justify-center text-xs text-muted-foreground">
+                {{ t("dataGenerate.selectTable") }}
+              </div>
+
+              <template v-else-if="activeCol">
+                <div class="p-3 space-y-3">
+                  <div class="flex items-center gap-2 text-sm font-medium">
+                    <Columns class="h-4 w-4 text-muted-foreground" />
+                    <span>{{ activeCol.columnName }}</span>
+                    <span class="text-xs text-muted-foreground font-mono">{{ activeCol.dataType }}</span>
+                  </div>
+                  <GeneratorParamsPanel :config="activeCol" :connection-id="props.prefillConnectionId" :database="props.prefillDatabase" />
+                  <div class="rounded border border-dashed border-amber-300 bg-amber-50 dark:bg-amber-950/20 px-2 py-1 text-[10px] font-mono text-amber-700 dark:text-amber-400 leading-relaxed break-all">
+                    <div>generatorKey: {{ activeCol.generatorKey ?? "(none)" }}</div>
+                    <div>generatorParams: {{ JSON.stringify(activeCol.generatorParams) }}</div>
+                  </div>
+                </div>
+              </template>
+              <template v-else-if="activeCfg">
+                <div class="p-3 space-y-3">
+                  <div class="flex items-center gap-2 text-sm font-medium">
+                    <Table class="h-4 w-4 text-green-500" />
+                    <span>{{ activeCfg.tableName }}</span>
+                  </div>
+                  <div class="flex items-center gap-3 rounded-md bg-muted/20 px-3 py-2">
+                    <Label class="text-xs shrink-0">{{ t("dataGenerate.rowCount") }}:</Label>
+                    <Input v-model.number="activeCfg.rowCount" class="h-7 w-24 text-xs" />
+                  </div>
+                </div>
+              </template>
+            </div>
+          </div>
+        </div>
+      </template>
+
+      <template v-else-if="currentStep === 'preview'">
+        <!-- status bar -->
+        <div class="flex items-center justify-between -mx-4 -mt-4 mb-0 px-4 py-2 border-b bg-muted/10">
+          <div class="flex items-center gap-1.5 text-xs text-muted-foreground">
+            <Database class="h-3.5 w-3.5" />
+            <span class="font-medium text-foreground">{{ connectionName || props.prefillDatabase }}</span>
+            <span class="text-muted-foreground">/</span>
+            <span>{{ Object.keys(checkedTables).length > 0 ? Object.keys(checkedTables)[0].split(".")[0] : props.prefillSchema || "main" }}</span>
+          </div>
+          <span class="text-sm font-medium absolute left-1/2 -translate-x-1/2">{{ t("dataGenerate.title") }}</span>
+          <div />
+        </div>
+
+        <div class="rounded-md border w-full overflow-hidden">
+          <div v-if="generatedResults.length === 0" class="flex h-[420px] items-center justify-center text-xs text-muted-foreground">{{ t("dataGenerate.noData") }}</div>
+          <template v-else>
+            <div class="flex items-center justify-between px-3 py-2 border-b bg-muted/10">
+              <div class="flex items-center gap-2">
+                <span class="text-xs text-muted-foreground">{{ t("dataGenerate.target") }}：</span>
+                <select v-if="generatedResults.length > 1" v-model="previewTableIndex" class="h-7 rounded border bg-background px-2 text-xs">
+                  <option v-for="(r, i) in generatedResults" :key="i" :value="i">{{ r.tableName }}</option>
+                </select>
+                <span v-else class="text-sm font-medium">{{ generatedResults[0].tableName }}</span>
+                <span class="text-xs text-muted-foreground">{{ currentPreview.rows.length }} 行</span>
+              </div>
+              <Button variant="outline" size="sm" class="h-7 text-xs" @click="regenerate">{{ t("dataGenerate.regenerate") }}</Button>
+            </div>
+            <div class="flex flex-col h-[380px]">
+              <div class="flex-1 overflow-auto overscroll-none bg-background">
+                <table class="w-full text-xs border-collapse" style="table-layout: auto">
+                  <thead>
+                    <tr class="sticky top-0 z-10 bg-[rgb(239_239_239)] dark:bg-muted/60 border-y border-border">
+                      <th class="px-2 py-1.5 border-r border-border text-center text-muted-foreground select-none w-10 shrink-0">#</th>
+                      <th v-for="(col, ci) in currentPreview.columns" :key="col" class="relative px-2 py-1.5 border-r border-border whitespace-nowrap text-left font-medium select-none" :style="{ minWidth: '60px', width: previewColWidths[ci] + 'px' }">
+                        {{ col }}
+                        <div class="absolute right-0 top-0 bottom-0 w-1.5 cursor-col-resize hover:bg-primary/30" @mousedown.stop="onPreviewColResizeStart(ci, $event)" @dblclick.stop="delete previewColWidths[ci]" />
+                      </th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    <tr v-for="(row, ri) in currentPreview.rows.slice(0, 50)" :key="ri" class="border-b border-border" :class="{ 'bg-muted/30': ri % 2 === 1 }">
+                      <td class="data-grid-row-number px-2 py-1 border-r border-border text-center text-muted-foreground select-none text-xs">{{ ri + 1 }}</td>
+                      <td
+                        v-for="(cell, ci) in row"
+                        :key="ci"
+                        class="px-3 py-1 border-r border-border whitespace-nowrap overflow-hidden text-ellipsis select-none font-mono"
+                        :style="{ maxWidth: (previewColWidths[ci] ?? 120) + 'px' }"
+                        :class="{ 'text-muted-foreground italic': cell === null || cell === undefined }"
+                      >
+                        {{ displayPreviewCell(cell) }}
+                      </td>
+                    </tr>
+                  </tbody>
+                </table>
+                <div v-if="currentPreview.rows.length > 50" class="sticky left-0 text-xs text-muted-foreground px-3 py-1.5 border-t border-border bg-background">{{ t("dataGenerate.first50Rows", { count: currentPreview.rows.length }) }}</div>
+              </div>
+            </div>
+          </template>
+        </div>
+      </template>
+
+      <template v-else-if="currentStep === 'result'">
+        <div class="rounded-md border">
+          <div class="border-b bg-muted/10 px-4 py-2 text-sm font-medium">{{ t("dataGenerate.resultTitle") }}</div>
+          <div class="divide-y max-h-[400px] overflow-y-auto">
+            <div v-for="r in executeResults" :key="r.table" class="px-4 py-3 text-xs">
+              <div class="flex items-center justify-between">
+                <span class="font-medium truncate">{{ r.table }}</span>
+                <span class="flex items-center gap-3 shrink-0">
+                  <span class="text-green-600 dark:text-green-400">{{ t("dataGenerate.successLabel", { count: r.ok }) }}</span>
+                  <span v-if="r.err > 0" class="text-destructive">{{ t("dataGenerate.failLabel", { count: r.err }) }}</span>
+                  <span class="text-muted-foreground">{{ t("dataGenerate.totalLabel", { count: r.total }) }}</span>
+                </span>
+              </div>
+              <div v-if="r.error" class="mt-1 text-destructive/80 break-all leading-relaxed">{{ r.error }}</div>
+            </div>
+          </div>
+          <div v-if="executeResults.length === 0" class="flex h-24 items-center justify-center text-xs text-muted-foreground">{{ t("dataGenerate.noResult") }}</div>
+        </div>
+      </template>
+
+      <DialogFooter class="flex items-center justify-between border-t pt-3 sm:justify-between">
+        <div class="flex items-center gap-2">
+          <template v-if="currentStep === 'config'">
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="saveProfile">
+              <Save class="mr-1 h-3 w-3" />
+              {{ t("dataGenerate.saveProfile") }}
+            </Button>
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="triggerLoadProfile">
+              <Upload class="mr-1 h-3 w-3" />
+              {{ t("dataGenerate.loadProfile") }}
+            </Button>
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="optionsDialogOpen = true">
+              <Settings class="mr-1 h-3 w-3" />
+              {{ t("dataGenerate.options") }}
+            </Button>
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="openOrderDialog">
+              <Settings class="mr-1 h-3 w-3" />
+              {{ t("dataGenerate.generateOrder") }}
+            </Button>
+          </template>
+          <template v-else-if="currentStep === 'preview' && generatedResults.length > 0">
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="copyAllSql">{{ t("dataGenerate.copyAllSql") }}</Button>
+          </template>
+        </div>
+        <div class="flex items-center gap-2">
+          <Button variant="outline" size="sm" class="h-7 text-xs" @click="open = false">
+            <X class="mr-1 h-3 w-3" />
+            {{ t("dangerDialog.cancel") }}
+          </Button>
+          <template v-if="currentStep === 'config'">
+            <Button variant="default" size="sm" class="h-7 text-xs" @click="doGenerate">
+              {{ t("dataGenerate.nextStep") }}
+            </Button>
+          </template>
+          <template v-else-if="currentStep === 'preview'">
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="currentStep = 'config'">{{ t("dataGenerate.prevStep") }}</Button>
+            <Button variant="default" size="sm" class="h-7 text-xs" :disabled="executing" @click="startInsert">
+              <Loader2 v-if="executing" class="mr-1 h-3 w-3 animate-spin" />
+              {{ t("dataGenerate.startInsert") }}
+            </Button>
+          </template>
+          <template v-else-if="currentStep === 'result'">
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="currentStep = 'preview'">{{ t("dataGenerate.back") }}</Button>
+            <Button variant="default" size="sm" class="h-7 text-xs" @click="open = false">{{ t("dataGenerate.confirm") }}</Button>
+          </template>
+        </div>
+      </DialogFooter>
+      <input ref="fileInputRef" type="file" accept="application/json,.json" class="hidden" @change="onFileSelected" />
+    </DialogScrollContent>
+
+    <Dialog v-model:open="optionsDialogOpen">
+      <DialogContent class="max-w-sm">
+        <DialogHeader>
+          <DialogTitle class="text-sm">生成选项</DialogTitle>
+        </DialogHeader>
+        <div class="space-y-3 py-2">
+          <label class="flex items-center gap-3 cursor-pointer">
+            <input type="checkbox" v-model="generateOptions.continueOnError" class="h-4 w-4 accent-primary" />
+            <span class="text-xs">{{ t("dataGenerate.errorContinue") }}</span>
+          </label>
+          <label class="flex items-center gap-3 cursor-pointer">
+            <input type="checkbox" v-model="generateOptions.truncate" class="h-4 w-4 accent-primary" />
+            <span class="text-xs">{{ t("dataGenerate.truncateBefore") }}</span>
+          </label>
+          <label class="flex items-center gap-3 cursor-pointer">
+            <input type="checkbox" v-model="generateOptions.useTransaction" class="h-4 w-4 accent-primary" />
+            <span class="text-xs">{{ t("dataGenerate.useTransaction") }}</span>
+          </label>
+          <label class="flex items-center gap-3 cursor-pointer">
+            <input type="checkbox" v-model="generateOptions.extendedInsert" class="h-4 w-4 accent-primary" />
+            <span class="text-xs">{{ t("dataGenerate.extendedInsert") }}</span>
+          </label>
+        </div>
+        <DialogFooter>
+          <Button size="sm" class="h-7 text-xs" @click="optionsDialogOpen = false">{{ t("dataGenerate.ok") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <Dialog v-model:open="orderDialogOpen">
+      <DialogContent class="max-w-md">
+        <DialogHeader>
+          <DialogTitle class="text-sm">{{ t("dataGenerate.generateOrder") }}</DialogTitle>
+        </DialogHeader>
+        <div class="space-y-1 max-h-80 overflow-y-auto">
+          <div v-for="(key, i) in tableOrder" :key="key" class="flex items-center gap-2 rounded border bg-background px-3 py-2 text-xs">
+            <span class="flex h-5 w-5 items-center justify-center rounded bg-muted text-muted-foreground text-[10px] font-medium">{{ i + 1 }}</span>
+            <span class="flex-1 truncate font-medium">{{ configs[key]?.tableName ?? key }}</span>
+            <span class="text-muted-foreground truncate max-w-[120px]">{{ configs[key]?.schema }}</span>
+            <button type="button" class="flex h-5 w-5 items-center justify-center rounded text-muted-foreground hover:bg-accent hover:text-foreground disabled:opacity-20" :disabled="i === 0" @click="moveOrderItem(i, -1)">
+              <ArrowUp class="h-3.5 w-3.5" />
+            </button>
+            <button type="button" class="flex h-5 w-5 items-center justify-center rounded text-muted-foreground hover:bg-accent hover:text-foreground disabled:opacity-20" :disabled="i === tableOrder.length - 1" @click="moveOrderItem(i, 1)">
+              <ArrowDown class="h-3.5 w-3.5" />
+            </button>
+          </div>
+        </div>
+        <div v-if="tableOrder.length === 0" class="py-8 text-center text-xs text-muted-foreground">{{ t("dataGenerate.noTablesSelected") }}</div>
+        <DialogFooter>
+          <Button size="sm" class="h-7 text-xs" @click="orderDialogOpen = false">{{ t("dataGenerate.ok") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/generate/GeneratorSelect.vue b/apps/desktop/src/components/generate/GeneratorSelect.vue
new file mode 100644
index 0000000..cb0e78f
--- /dev/null
+++ b/apps/desktop/src/components/generate/GeneratorSelect.vue
@@ -0,0 +1,66 @@
+<script setup lang="ts">
+import { ref, computed } from "vue";
+import { useI18n } from "vue-i18n";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Button } from "@/components/ui/button";
+import { ChevronRight, Check } from "@lucide/vue";
+import { GeneratorHierarchy, getGeneratorCategoryAndLabel, type GeneratorNode } from "@/lib/dataGrid/dataGenerate";
+
+const { t } = useI18n();
+const modelValue = defineModel<string | undefined>({ required: false });
+const open = ref(false);
+const selectedCategory = ref<GeneratorNode | null>(null);
+
+function tr(key: string, fallback: string): string {
+  const v = t("dataGenerate.gen." + key);
+  return v === "dataGenerate.gen." + key ? fallback : v;
+}
+
+const currentLabel = computed(() => {
+  if (!modelValue.value) return "";
+  const info = getGeneratorCategoryAndLabel(modelValue.value);
+  return `${tr(info.category, info.categoryLabel)} / ${tr(modelValue.value, info.label)}`;
+});
+
+function selectGenerator(_cat: GeneratorNode, gen: GeneratorNode) {
+  modelValue.value = gen.key;
+  selectedCategory.value = null;
+  open.value = false;
+}
+
+function selectCategory(cat: GeneratorNode) {
+  selectedCategory.value = cat;
+}
+
+function backToCategories() {
+  selectedCategory.value = null;
+}
+</script>
+
+<template>
+  <Popover v-model:open="open">
+    <PopoverTrigger as-child>
+      <Button variant="outline" size="sm" class="h-7 w-full justify-start gap-1.5 px-2 text-xs font-normal">
+        <span v-if="modelValue" class="truncate text-muted-foreground">{{ currentLabel }}</span>
+        <span v-else class="text-muted-foreground/50">{{ t("dataGenerate.selectGenerator") }}</span>
+      </Button>
+    </PopoverTrigger>
+    <PopoverContent class="w-64 p-0" align="start">
+      <div v-if="!selectedCategory" class="max-h-[300px] overflow-auto p-1">
+        <div v-for="cat in GeneratorHierarchy" :key="cat.key" class="flex cursor-pointer items-center justify-between rounded-md px-2.5 py-1.5 text-xs hover:bg-accent" @click="selectCategory(cat)">
+          <span>{{ tr(cat.key, cat.label) }}</span>
+          <ChevronRight class="h-3.5 w-3.5 text-muted-foreground" />
+        </div>
+      </div>
+      <div v-else class="max-h-[300px] overflow-auto p-1">
+        <div class="border-b px-2.5 py-1.5">
+          <button class="text-xs text-muted-foreground hover:text-foreground" @click="backToCategories">← {{ tr(selectedCategory.key, selectedCategory.label) }}</button>
+        </div>
+        <div v-for="gen in selectedCategory.children" :key="gen.key" class="flex cursor-pointer items-center justify-between rounded-md px-2.5 py-1.5 text-xs hover:bg-accent" @click="selectGenerator(selectedCategory, gen)">
+          <span>{{ tr(gen.key, gen.label) }}</span>
+          <Check v-if="modelValue === gen.key" class="h-3.5 w-3.5" />
+        </div>
+      </div>
+    </PopoverContent>
+  </Popover>
+</template>
diff --git a/apps/desktop/src/components/generate/params/AddressParams.vue b/apps/desktop/src/components/generate/params/AddressParams.vue
new file mode 100644
index 0000000..79667ac
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/AddressParams.vue
@@ -0,0 +1,118 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const addressTypes = [
+  { value: "line1", label: "第1行地址" },
+  { value: "line2", label: "第2行地址" },
+  { value: "full", label: "完整地址" },
+];
+
+const regions = [
+  { value: "us", label: "美国" },
+  { value: "uk", label: "英国" },
+  { value: "cn", label: "中国 (English)" },
+  { value: "jp", label: "日本 (English)" },
+];
+
+if (!props.params.addressType) props.params.addressType = "line1";
+if (!props.params.regions) props.params.regions = ["us"];
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function randInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+const usStreets = ["Main St", "Oak Ave", "Elm Rd", "Park Blvd", "Lake Dr", "Hill St", "Washington Blvd", "2nd Ave", "3rd St", "Pine Ln"];
+const ukStreets = ["Oxford Street", "Abbey Road", "Baker Street", "Piccadilly", "Downing Street", "Regent Street", "Bond Street"];
+const cnStreets = ["No. 88, YuShuang Road", "No. 128, Nanjing West Road", "No. 56, RenMin Avenue", "No. 201, ZhongShan Road", "No. 77, ChangJiang Road"];
+const jpStreets = ["1-1-1, Marunouchi", "2-3-1, Shibuya", "3-2-1, Ginza", "1-5-2, Shinjuku", "4-1-3, Umeda"];
+
+const usApts = ["Apt #203", "Unit 5", "Suite 300", "#4B", "Floor 7"];
+const ukApts = ["Flat 3", "Apartment 5B", "Studio 2", "Suite 12"];
+const cnApts = ["Building A, Unit 301", "Room 202, Block B", "Unit 1105"];
+const jpApts = ["Building #2, 3F", "Room 402", "Tower A, 15F"];
+
+function toggleRegion(val: string) {
+  if (!props.params.regions) props.params.regions = [];
+  const idx = props.params.regions.indexOf(val);
+  if (idx >= 0) props.params.regions.splice(idx, 1);
+  else props.params.regions.push(val);
+}
+
+function generateAddress(type: string, region: string): string {
+  const num = randInt(1, 9999);
+  const streets: Record<string, string[]> = {
+    us: usStreets,
+    uk: ukStreets,
+    cn: cnStreets,
+    jp: jpStreets,
+  };
+  const apts: Record<string, string[]> = {
+    us: usApts,
+    uk: ukApts,
+    cn: cnApts,
+    jp: jpApts,
+  };
+  const list = streets[region] ?? usStreets;
+  const aptList = apts[region] ?? usApts;
+  if (type === "line1") {
+    if (region === "cn" || region === "jp") return pick(list);
+    return `${num} ${pick(list)}`;
+  }
+  if (type === "line2") return pick(aptList);
+  // full
+  if (region === "cn" || region === "jp") return `${randInt(1, 999)} ${pick(list)}, ${pick(aptList)}`;
+  return `${num} ${pick(list)}, ${pick(aptList)}`;
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const regionsSelected = props.params.regions?.length ? props.params.regions : ["us"];
+  const region = pick(regionsSelected);
+  return generateAddress(props.params.addressType ?? "line1", region);
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">类型</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button v-for="t in addressTypes" :key="t.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.addressType || 'line1') === t.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.addressType = t.value">{{ t.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">地区</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button v-for="r in regions" :key="r.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.regions ?? []).includes(r.value) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleRegion(r.value)">{{ r.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/BarcodeParams.vue b/apps/desktop/src/components/generate/params/BarcodeParams.vue
new file mode 100644
index 0000000..651aa0a
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/BarcodeParams.vue
@@ -0,0 +1,101 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const barcodeTypes = [
+  { value: "ean8", label: "EAN8", regex: "[0-9]{8}" },
+  { value: "ean13", label: "EAN13", regex: "[0-9]{13}" },
+  { value: "upca", label: "UPCA", regex: "[0-9]{12}" },
+  { value: "upce", label: "UPCE", regex: "[0-9]{6}" },
+  { value: "isbn", label: "ISBN", regex: "[0-9]{13}" },
+  { value: "code39", label: "Code39", regex: "[A-Z]{3}-[0-9]{4}" },
+];
+
+if (!props.params.barcodeTypes) {
+  props.params.barcodeTypes = ["ean13"];
+}
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function randDigits(n: number): string {
+  return Array.from({ length: n }, () => Math.floor(Math.random() * 10).toString()).join("");
+}
+
+function generateByType(type: string): string {
+  switch (type) {
+    case "ean8":
+      return randDigits(8);
+    case "ean13":
+      return randDigits(13);
+    case "upca":
+      return randDigits(12);
+    case "upce":
+      return randDigits(6);
+    case "isbn":
+      return `978${randDigits(10)}`;
+    case "code39": {
+      const letters = Array.from({ length: 3 }, () => String.fromCharCode(65 + Math.floor(Math.random() * 26))).join("");
+      return `${letters}-${randDigits(4)}`;
+    }
+    default:
+      return randDigits(13);
+  }
+}
+
+function toggleBarcode(val: string) {
+  if (!props.params.barcodeTypes) props.params.barcodeTypes = [];
+  const idx = props.params.barcodeTypes.indexOf(val);
+  if (idx >= 0) props.params.barcodeTypes.splice(idx, 1);
+  else props.params.barcodeTypes.push(val);
+}
+
+const currentRegex = computed(() => {
+  if (!props.params.barcodeTypes?.length) return "";
+  const chosen = pick(props.params.barcodeTypes);
+  const bt = barcodeTypes.find((b) => b.value === chosen);
+  return bt?.regex ?? "";
+});
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const selected = props.params.barcodeTypes?.length ? props.params.barcodeTypes : ["ean13"];
+  return generateByType(pick(selected));
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">类型</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button v-for="b in barcodeTypes" :key="b.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.barcodeTypes ?? []).includes(b.value) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleBarcode(b.value)">{{ b.label }}</button>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-1">正则表达式</div>
+      <div class="font-mono text-xs bg-background rounded border px-2 py-1 break-all">{{ currentRegex }}</div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/CityParams.vue b/apps/desktop/src/components/generate/params/CityParams.vue
new file mode 100644
index 0000000..840414d
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/CityParams.vue
@@ -0,0 +1,124 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const regions = [
+  { value: "us", label: "美国" },
+  { value: "uk", label: "英国" },
+  { value: "cn", label: "中国" },
+  { value: "jp", label: "日本" },
+];
+
+const languages = [
+  { value: "en", label: "English" },
+  { value: "native", label: "本地语言" },
+];
+
+if (!props.params.regions) props.params.regions = ["us"];
+if (!props.params.languages) props.params.languages = ["en"];
+
+const cities: Record<string, { en: string; native: string }[]> = {
+  us: [
+    { en: "New York", native: "New York" },
+    { en: "Los Angeles", native: "Los Angeles" },
+    { en: "Chicago", native: "Chicago" },
+    { en: "San Francisco", native: "San Francisco" },
+    { en: "Boston", native: "Boston" },
+    { en: "Seattle", native: "Seattle" },
+    { en: "Washington, D.C.", native: "Washington, D.C." },
+    { en: "Miami", native: "Miami" },
+  ],
+  uk: [
+    { en: "London", native: "London" },
+    { en: "Manchester", native: "Manchester" },
+    { en: "Birmingham", native: "Birmingham" },
+    { en: "Liverpool", native: "Liverpool" },
+    { en: "Edinburgh", native: "Edinburgh" },
+    { en: "Glasgow", native: "Glasgow" },
+    { en: "Bristol", native: "Bristol" },
+  ],
+  cn: [
+    { en: "Beijing", native: "北京" },
+    { en: "Shanghai", native: "上海" },
+    { en: "Guangzhou", native: "广州" },
+    { en: "Shenzhen", native: "深圳" },
+    { en: "Chengdu", native: "成都" },
+    { en: "Hangzhou", native: "杭州" },
+    { en: "Nanjing", native: "南京" },
+    { en: "Xi'an", native: "西安" },
+  ],
+  jp: [
+    { en: "Tokyo", native: "東京" },
+    { en: "Osaka", native: "大阪" },
+    { en: "Kyoto", native: "京都" },
+    { en: "Yokohama", native: "横浜" },
+    { en: "Nagoya", native: "名古屋" },
+    { en: "Sapporo", native: "札幌" },
+    { en: "Fukuoka", native: "福岡" },
+  ],
+};
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function toggleRegion(val: string) {
+  if (!props.params.regions) props.params.regions = [];
+  const idx = props.params.regions.indexOf(val);
+  if (idx >= 0) props.params.regions.splice(idx, 1);
+  else props.params.regions.push(val);
+}
+
+function setLang(val: string) {
+  props.params.languages = [val];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const regionsSelected = props.params.regions?.length ? props.params.regions : ["us"];
+  const region = pick(regionsSelected);
+  const city = pick(cities[region] ?? cities["us"]);
+  const lang = props.params.languages?.[0] ?? "en";
+  return lang === "native" ? city.native : city.en;
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">地区</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button v-for="r in regions" :key="r.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.regions ?? []).includes(r.value) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleRegion(r.value)">{{ r.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button v-for="l in languages" :key="l.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.languages?.[0] || 'en') === l.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="setLang(l.value)">{{ l.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/ColorParams.vue b/apps/desktop/src/components/generate/params/ColorParams.vue
new file mode 100644
index 0000000..7b7c434
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/ColorParams.vue
@@ -0,0 +1,66 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const dataMap: Record<string, string[]> = {
+  en: ["Red", "Blue", "Green", "Black", "White", "Yellow", "Purple", "Orange", "Pink", "Brown", "Gray", "Cyan", "Jasmine", "Teal", "Maroon", "Navy", "Olive", "Coral"],
+  zh: ["红色", "蓝色", "绿色", "黑色", "白色", "黄色", "紫色", "橙色", "粉色", "棕色", "灰色", "青色", "茉莉色", "蓝绿色", "褐红色", "藏青", "橄榄", "珊瑚色"],
+  zh_hant: ["紅色", "藍色", "綠色", "黑色", "白色", "黃色", "紫色", "橙色", "粉色", "棕色", "灰色", "青色", "茉莉色", "藍綠色", "褐紅色", "藏青", "橄欖", "珊瑚色"],
+  ja: ["赤", "青", "緑", "黒", "白", "黄色", "紫", "オレンジ", "ピンク", "茶色", "灰色", "シアン", "ジャスミン", "ティール", "えんじ色", "ネイビー", "オリーブ", "コーラル"],
+};
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const lang = props.params.languages?.[0] ?? "en";
+  return pick(dataMap[lang] ?? dataMap["en"]);
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button
+          v-for="l in [
+            { value: 'en', label: 'English' },
+            { value: 'zh', label: '简体中文' },
+            { value: 'zh_hant', label: '繁體中文' },
+            { value: 'ja', label: '日本語' },
+          ]"
+          :key="l.value"
+          type="button"
+          class="px-2 py-1 rounded border text-xs"
+          :class="(params.languages?.[0] || 'en') === l.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'"
+          @click="params.languages = [l.value]"
+        >
+          {{ l.label }}
+        </button>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/CommonOptions.vue b/apps/desktop/src/components/generate/params/CommonOptions.vue
new file mode 100644
index 0000000..3de9189
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/CommonOptions.vue
@@ -0,0 +1,48 @@
+<script setup lang="ts">
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { useI18n } from "vue-i18n";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+
+const props = defineProps<{
+  params: GeneratorParams;
+  disableDefault?: boolean;
+  disableNull?: boolean;
+  disableUnique?: boolean;
+  disableLinks?: boolean;
+}>();
+
+const { t } = useI18n();
+</script>
+
+<template>
+  <div class="rounded-md border bg-muted/10 p-3 space-y-2">
+    <div v-if="!disableDefault" class="flex items-center gap-2 text-xs">
+      <input id="opt-default" type="checkbox" class="h-3.5 w-3.5 accent-primary" :checked="!!params.includeDefault" @change="params.includeDefault = !params.includeDefault" />
+      <Label for="opt-default" class="text-muted-foreground">{{ t("dataGenerate.includeDefault") }}</Label>
+      <div v-if="params.includeDefault" class="flex items-center gap-1 ml-auto">
+        <Input v-model.number="params.defaultPercent" type="number" min="0" max="100" class="h-6 w-16 text-xs" />
+        <span class="text-muted-foreground">%</span>
+      </div>
+    </div>
+
+    <div v-if="!disableNull" class="flex items-center gap-2 text-xs">
+      <input id="opt-null" type="checkbox" class="h-3.5 w-3.5 accent-primary" :checked="!!params.includeNull" @change="params.includeNull = !params.includeNull" />
+      <Label for="opt-null" class="text-muted-foreground">{{ t("dataGenerate.includeNull") }}</Label>
+      <div v-if="params.includeNull" class="flex items-center gap-1 ml-auto">
+        <Input v-model.number="params.nullPercent" type="number" min="0" max="100" class="h-6 w-16 text-xs" />
+        <span class="text-muted-foreground">%</span>
+      </div>
+    </div>
+
+    <div v-if="!disableUnique" class="flex items-center gap-2 text-xs">
+      <input id="opt-unique" type="checkbox" class="h-3.5 w-3.5 accent-primary" :checked="!!params.unique" @change="params.unique = !params.unique" />
+      <Label for="opt-unique" class="text-muted-foreground">{{ t("dataGenerate.unique") }}</Label>
+    </div>
+
+    <div v-if="!disableLinks" class="flex items-center gap-2 text-xs">
+      <input id="opt-links" type="checkbox" class="h-3.5 w-3.5 accent-primary" :checked="!!params.disableLinks" @change="params.disableLinks = !params.disableLinks" />
+      <Label for="opt-links" class="text-muted-foreground">{{ t("dataGenerate.disableLinks") }}</Label>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/CompanyNameParams.vue b/apps/desktop/src/components/generate/params/CompanyNameParams.vue
new file mode 100644
index 0000000..a3b18ed
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/CompanyNameParams.vue
@@ -0,0 +1,96 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const languageOptions = [
+  { value: "en", label: "English" },
+  { value: "zh_pinyin", label: "Chinese (Pinyin)" },
+  { value: "zh_eng", label: "Chinese (Eng)" },
+  { value: "zh_hans", label: "Chinese (简体中文)" },
+  { value: "ja_romaji", label: "Japanese (Romaji)" },
+  { value: "ja", label: "Japanese (日本語)" },
+];
+
+if (!props.params.languages) props.params.languages = ["en"];
+
+const prefixes: Record<string, string[]> = {
+  en: ["Alpha", "Beta", "Global", "Prime", "Apex", "Nexus", "Atlas", "Vertex", "Zenith", "Acme", "Initech", "Globex", "Soylent"],
+  zh_pinyin: ["Hua", "Zhong", "Da", "Xin", "Guo", "Tai", "Sheng", "Long", "Dong", "Nan"],
+  zh_eng: ["Hua", "Zhong", "Da", "Xin", "Great", "New", "China", "Oriental", "Pacific", "Golden"],
+  zh_hans: ["华", "中", "大", "新", "国", "泰", "盛", "龙", "东方", "金"],
+  ja_romaji: ["Abe", "Sato", "Suzuki", "Takahashi", "Tanaka", "Watanabe", "Ito", "Yamamoto", "Nakamura", "Kobayashi"],
+  ja: ["アベ", "サトウ", "スズキ", "タカハシ", "タナカ", "ワタナベ", "イトウ", "ヤマモト"],
+};
+
+const middles: Record<string, string[]> = {
+  en: ["Consulting", "Technologies", "Solutions", "Enterprises", "Industries", "Systems", "Holdings", "Services", "Digital", "Media"],
+  zh_pinyin: ["Keji", "Shangmao", "Gongcheng", "Fuwu", "Zixun", "Chuangxin", "Touzi", "Wenhua", "Dianzi", "Jiadian"],
+  zh_eng: ["Tech", "Trading", "Industry", "Services", "Consulting", "Investment", "Digital", "Media", "Enterprise", "Group"],
+  zh_hans: ["科技", "商贸", "工程", "服务", "咨询", "创新", "投资", "文化", "电子", "集团"],
+  ja_romaji: ["Kigyo", "Sangyo", "Service", "Tech", "Consulting", "Media", "Digital", "System", "Network", "Holding"],
+  ja: ["企業", "産業", "サービス", "テック", "コンサルティング", "メディア", "デジタル"],
+};
+
+const suffixes: Record<string, string[]> = {
+  en: ["Inc.", "Ltd.", "Corporation", "Company", "LLC", "Group", "PLC", "Co."],
+  zh_pinyin: ["Gongsi", "Jituan", "Gufen youxian gongsi", "Youxian gongsi"],
+  zh_eng: ["Co., Ltd.", "Inc.", "Ltd.", "Corporation", "Group", "LLC"],
+  zh_hans: ["有限公司", "股份有限公司", "集团", "公司"],
+  ja_romaji: ["K.K.", "Kabushiki-gaisha", "G.K.", "Co., Ltd."],
+  ja: ["株式会社", "合同会社", "有限会社"],
+};
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function toggleLang(val: string) {
+  if (!props.params.languages) props.params.languages = [];
+  const idx = props.params.languages.indexOf(val);
+  if (idx >= 0) props.params.languages.splice(idx, 1);
+  else props.params.languages.push(val);
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const langs = props.params.languages?.length ? props.params.languages : ["en"];
+  const lang = pick(langs);
+  const pf = prefixes[lang] ?? prefixes["en"];
+  const md = middles[lang] ?? middles["en"];
+  const sf = suffixes[lang] ?? suffixes["en"];
+  return `${pick(pf)} ${pick(md)} ${pick(sf)}`.trim();
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言选择</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button v-for="l in languageOptions" :key="l.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.languages ?? []).includes(l.value) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleLang(l.value)">{{ l.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/CreditCardDateParams.vue b/apps/desktop/src/components/generate/params/CreditCardDateParams.vue
new file mode 100644
index 0000000..9bcb695
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/CreditCardDateParams.vue
@@ -0,0 +1,90 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Label } from "@/components/ui/label";
+import { Input } from "@/components/ui/input";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const dateFormats = [
+  { value: "MM/YY", label: "MM/YY" },
+  { value: "MM/YYYY", label: "MM/YYYY" },
+  { value: "YYYY-MM", label: "YYYY-MM" },
+];
+
+if (!props.params.ccDateFormat) props.params.ccDateFormat = "MM/YY";
+if (props.params.ccYearOffsetMin === undefined) props.params.ccYearOffsetMin = 0;
+if (props.params.ccYearOffsetMax === undefined) props.params.ccYearOffsetMax = 5;
+
+function pad2(n: number): string {
+  return String(n).padStart(2, "0");
+}
+
+function randInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function formatDate(month: number, year: number, fmt: string): string {
+  const yy = year % 100;
+  const yyyy = year;
+  switch (fmt) {
+    case "MM/YYYY":
+      return `${pad2(month)}/${yyyy}`;
+    case "YYYY-MM":
+      return `${yyyy}-${pad2(month)}`;
+    case "MM/YY":
+    default:
+      return `${pad2(month)}/${pad2(yy)}`;
+  }
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const now = new Date();
+  const yearBase = now.getFullYear();
+  const month = randInt(1, 12);
+  const year = yearBase + randInt(props.params.ccYearOffsetMin ?? 0, props.params.ccYearOffsetMax ?? 5);
+  return formatDate(month, year, props.params.ccDateFormat ?? "MM/YY");
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">日期类型</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button v-for="f in dateFormats" :key="f.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.ccDateFormat || 'MM/YY') === f.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.ccDateFormat = f.value">{{ f.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">年份范围（相对于当前年的偏移量）</div>
+      <div class="flex items-center gap-2 text-xs">
+        <Label class="text-muted-foreground">最小</Label>
+        <Input v-model.number="params.ccYearOffsetMin" type="number" class="h-6 w-20 text-xs" />
+        <Label class="text-muted-foreground">最大</Label>
+        <Input v-model.number="params.ccYearOffsetMax" type="number" class="h-6 w-20 text-xs" />
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/CreditCardNumberParams.vue b/apps/desktop/src/components/generate/params/CreditCardNumberParams.vue
new file mode 100644
index 0000000..11d5e98
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/CreditCardNumberParams.vue
@@ -0,0 +1,116 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const cardTypes = [
+  { value: "american_express", label: "American Express" },
+  { value: "jcb", label: "JCB" },
+  { value: "mastercard", label: "MasterCard" },
+  { value: "unionpay", label: "UnionPay" },
+  { value: "visa", label: "Visa" },
+];
+
+if (!props.params.cardTypes) {
+  props.params.cardTypes = ["visa", "mastercard"];
+}
+
+const prefixMap: Record<string, string[]> = {
+  american_express: ["34", "37"],
+  jcb: ["3528", "3529", "3530", "3531", "3532", "3533", "3534", "3535", "3536", "3537", "3538", "3539"],
+  mastercard: ["51", "52", "53", "54", "55", "2221", "2222", "2223", "2224", "2225", "2226", "2227", "2228", "2229", "223", "224", "225", "226", "227", "228", "229", "23", "24", "25", "26", "270", "271", "2720"],
+  unionpay: ["62", "623", "624", "625", "626", "627", "628", "622126", "622127", "622128", "622129", "622130"],
+  visa: ["4"],
+};
+
+const lengthMap: Record<string, number> = {
+  american_express: 15,
+  jcb: 16,
+  mastercard: 16,
+  unionpay: 16,
+  visa: 16,
+};
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function randDigit(): number {
+  return Math.floor(Math.random() * 10);
+}
+
+function luhnCheck(numStr: string): boolean {
+  let sum = 0;
+  let shouldDouble = false;
+  for (let i = numStr.length - 1; i >= 0; i--) {
+    let d = parseInt(numStr.charAt(i), 10);
+    if (shouldDouble) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    shouldDouble = !shouldDouble;
+  }
+  return sum % 10 === 0;
+}
+
+function generateLuhnCard(prefix: string, length: number): string {
+  const body = prefix.split("").map((c) => parseInt(c, 10));
+  while (body.length < length - 1) {
+    body.push(randDigit());
+  }
+  for (let check = 0; check < 10; check++) {
+    const candidate = body.join("") + String(check);
+    if (luhnCheck(candidate)) return candidate;
+  }
+  return body.join("") + "0";
+}
+
+function toggleCardType(val: string) {
+  if (!props.params.cardTypes) props.params.cardTypes = [];
+  const idx = props.params.cardTypes.indexOf(val);
+  if (idx >= 0) props.params.cardTypes.splice(idx, 1);
+  else props.params.cardTypes.push(val);
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const selected = props.params.cardTypes?.length ? props.params.cardTypes : cardTypes.map((c) => c.value);
+  const chosen = pick(selected);
+  const prefix = pick(prefixMap[chosen] ?? ["4"]);
+  const length = lengthMap[chosen] ?? 16;
+  return generateLuhnCard(prefix, length);
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">类型选择</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button v-for="c in cardTypes" :key="c.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.cardTypes ?? []).includes(c.value) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleCardType(c.value)">{{ c.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/CreditCardTypeParams.vue b/apps/desktop/src/components/generate/params/CreditCardTypeParams.vue
new file mode 100644
index 0000000..4a3adc4
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/CreditCardTypeParams.vue
@@ -0,0 +1,68 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const cardTypes = [
+  { value: "american_express", label: "American Express" },
+  { value: "jcb", label: "JCB" },
+  { value: "mastercard", label: "MasterCard" },
+  { value: "unionpay", label: "UnionPay" },
+  { value: "visa", label: "Visa" },
+];
+
+if (!props.params.cardTypes) {
+  props.params.cardTypes = ["visa", "mastercard"];
+}
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function toggleCardType(val: string) {
+  if (!props.params.cardTypes) props.params.cardTypes = [];
+  const idx = props.params.cardTypes.indexOf(val);
+  if (idx >= 0) props.params.cardTypes.splice(idx, 1);
+  else props.params.cardTypes.push(val);
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const selected = props.params.cardTypes?.length ? props.params.cardTypes : cardTypes.map((c) => c.value);
+  const chosen = pick(selected);
+  const item = cardTypes.find((c) => c.value === chosen);
+  return item?.label ?? chosen;
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">类型选择</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button v-for="c in cardTypes" :key="c.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.cardTypes ?? []).includes(c.value) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleCardType(c.value)">{{ c.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/DateParams.vue b/apps/desktop/src/components/generate/params/DateParams.vue
new file mode 100644
index 0000000..3aebef9
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/DateParams.vue
@@ -0,0 +1,101 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const { t } = useI18n();
+
+function parseLocalDate(str: string): Date {
+  const [y, m, d] = str.split("-").map(Number);
+  return new Date(y, m - 1, d);
+}
+
+const previewVal = computed(() => {
+  void previewKey.value;
+  const start = props.params.start ? parseLocalDate(props.params.start) : new Date("2020-01-01");
+  const end = props.params.end ? parseLocalDate(props.params.end) : new Date();
+  const d = new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
+  const year = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+});
+
+const weekdayLabels = ["日", "一", "二", "三", "四", "五", "六"];
+
+function toggleWeekday(d: number) {
+  if (!props.params.weekdays) props.params.weekdays = [];
+  const idx = props.params.weekdays.indexOf(d);
+  if (idx >= 0) props.params.weekdays.splice(idx, 1);
+  else props.params.weekdays.push(d);
+}
+
+const previewKey = ref(0);
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs">
+        <Label class="text-muted-foreground">{{ t("dataGenerate.startDate") }}</Label>
+        <input
+          :value="params.start ?? ''"
+          @change="
+            (e: Event) => {
+              const v = (e.target as HTMLInputElement).value;
+              (params as Record<string, unknown>).start = v;
+              (params as Record<string, unknown>)._debug_start = v;
+            }
+          "
+          type="date"
+          class="h-7 w-full min-w-0 rounded-[6px] border bg-transparent px-2.5 py-1 text-xs outline-none transition-colors dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-3"
+        />
+      </div>
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs mt-2">
+        <Label class="text-muted-foreground">{{ t("dataGenerate.endDate") }}</Label>
+        <input
+          :value="params.end ?? ''"
+          @change="
+            (e: Event) => {
+              const v = (e.target as HTMLInputElement).value;
+              (params as Record<string, unknown>).end = v;
+              (params as Record<string, unknown>)._debug_end = v;
+            }
+          "
+          type="date"
+          class="h-7 w-full min-w-0 rounded-[6px] border bg-transparent px-2.5 py-1 text-xs outline-none transition-colors dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-3"
+        />
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">星期</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="!params.weekdayMode || params.weekdayMode === 'all' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.weekdayMode = 'all'">全部</button>
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="params.weekdayMode === 'weekday' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.weekdayMode = 'weekday'">工作日</button>
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="params.weekdayMode === 'custom' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.weekdayMode = 'custom'">自定义</button>
+      </div>
+      <div v-if="params.weekdayMode === 'custom'" class="flex gap-1 mt-2">
+        <button v-for="(_, i) in 7" :key="i" type="button" class="w-7 h-7 rounded text-xs border" :class="(params.weekdays ?? []).includes(i) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleWeekday(i)">{{ weekdayLabels[i] }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">{{ t("dataGenerate.preview") }}</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/DateTimeParams.vue b/apps/desktop/src/components/generate/params/DateTimeParams.vue
new file mode 100644
index 0000000..d2835a6
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/DateTimeParams.vue
@@ -0,0 +1,140 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const { t } = useI18n();
+
+function parseLocalDate(str: string): Date {
+  const [y, m, d] = str.split("-").map(Number);
+  return new Date(y, m - 1, d);
+}
+
+function formatLocalDate(d: Date): string {
+  const y = d.getFullYear();
+  const month = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${month}-${day}`;
+}
+
+const previewVal = computed(() => {
+  void previewKey.value;
+  const start = props.params.start ? parseLocalDate(props.params.start) : new Date("2020-01-01");
+  const end = props.params.end ? parseLocalDate(props.params.end) : new Date();
+  const d = new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
+  if (!props.params.allDay) {
+    return formatLocalDate(d);
+  }
+  const sh = parseInt(props.params.startTime ?? "00") || 0;
+  const sm = parseInt(props.params.endTime ?? "23") || 23;
+  const h = Math.floor(Math.random() * (sm - sh + 1)) + sh;
+  const m = Math.floor(Math.random() * 60);
+  const s = Math.floor(Math.random() * 60);
+  return `${formatLocalDate(d)} ${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
+});
+
+const weekdayLabels = ["日", "一", "二", "三", "四", "五", "六"];
+
+function toggleWeekday(d: number) {
+  if (!props.params.weekdays) props.params.weekdays = [];
+  const idx = props.params.weekdays.indexOf(d);
+  if (idx >= 0) props.params.weekdays.splice(idx, 1);
+  else props.params.weekdays.push(d);
+}
+
+const previewKey = ref(0);
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs">
+        <Label class="text-muted-foreground">{{ t("dataGenerate.startDate") }}</Label>
+        <input
+          :value="params.start ?? ''"
+          @change="
+            (e: Event) => {
+              (params as Record<string, unknown>).start = (e.target as HTMLInputElement).value;
+            }
+          "
+          type="date"
+          class="h-7 w-full min-w-0 rounded-[6px] border bg-transparent px-2.5 py-1 text-xs outline-none transition-colors dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-3"
+        />
+      </div>
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs mt-2">
+        <Label class="text-muted-foreground">{{ t("dataGenerate.endDate") }}</Label>
+        <input
+          :value="params.end ?? ''"
+          @change="
+            (e: Event) => {
+              (params as Record<string, unknown>).end = (e.target as HTMLInputElement).value;
+            }
+          "
+          type="date"
+          class="h-7 w-full min-w-0 rounded-[6px] border bg-transparent px-2.5 py-1 text-xs outline-none transition-colors dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-3"
+        />
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3 space-y-2">
+      <div class="flex items-center gap-2 text-xs">
+        <input id="dt-all-day" type="checkbox" class="h-3.5 w-3.5 accent-primary" :checked="!!params.allDay" @change="params.allDay = !params.allDay" />
+        <Label for="dt-all-day" class="text-muted-foreground">{{ t("dataGenerate.allDay") }}</Label>
+      </div>
+      <div v-if="params.allDay" class="flex items-center gap-2 text-xs ml-5">
+        <Label class="text-muted-foreground shrink-0">{{ t("dataGenerate.startTime") }}</Label>
+        <input
+          :value="params.startTime ?? ''"
+          @change="
+            (e: Event) => {
+              (params as Record<string, unknown>).startTime = (e.target as HTMLInputElement).value;
+            }
+          "
+          type="time"
+          class="h-7 w-24 min-w-0 rounded-[6px] border bg-transparent px-2.5 py-1 text-xs outline-none transition-colors dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-3"
+        />
+        <Label class="text-muted-foreground shrink-0">{{ t("dataGenerate.endTime") }}</Label>
+        <input
+          :value="params.endTime ?? ''"
+          @change="
+            (e: Event) => {
+              (params as Record<string, unknown>).endTime = (e.target as HTMLInputElement).value;
+            }
+          "
+          type="time"
+          class="h-7 w-24 min-w-0 rounded-[6px] border bg-transparent px-2.5 py-1 text-xs outline-none transition-colors dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-3"
+        />
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">{{ t("dataGenerate.weekday") }}</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="!params.weekdayMode || params.weekdayMode === 'all' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.weekdayMode = 'all'">{{ t("dataGenerate.all") }}</button>
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="params.weekdayMode === 'weekday' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.weekdayMode = 'weekday'">{{ t("dataGenerate.weekdayOnly") }}</button>
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="params.weekdayMode === 'custom' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.weekdayMode = 'custom'">{{ t("dataGenerate.custom") }}</button>
+      </div>
+      <div v-if="params.weekdayMode === 'custom'" class="flex gap-1 mt-2">
+        <button v-for="(_, i) in 7" :key="i" type="button" class="w-7 h-7 rounded text-xs border" :class="(params.weekdays ?? []).includes(i) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleWeekday(i)">{{ weekdayLabels[i] }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">{{ t("dataGenerate.preview") }}</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/DefaultParams.vue b/apps/desktop/src/components/generate/params/DefaultParams.vue
new file mode 100644
index 0000000..de6629b
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/DefaultParams.vue
@@ -0,0 +1,9 @@
+<script setup lang="ts">
+defineProps<{ params: any; config: any }>();
+</script>
+
+<template>
+  <div class="text-xs text-muted-foreground px-1 py-2">
+    {{ config.generatorLabel || config.generatorKey }}
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/DepartmentParams.vue b/apps/desktop/src/components/generate/params/DepartmentParams.vue
new file mode 100644
index 0000000..dee0ea5
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/DepartmentParams.vue
@@ -0,0 +1,71 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const languages = [
+  { value: "en", label: "English" },
+  { value: "zh", label: "简体中文" },
+  { value: "zh_hant", label: "繁體中文" },
+  { value: "ja", label: "日本語" },
+];
+
+if (!props.params.languages) props.params.languages = ["en"];
+
+const dataMap: Record<string, string[]> = {
+  en: ["Engineering", "Marketing", "Sales", "Human Resources", "Finance", "Operations", "Research and Development", "Customer Support", "Legal", "IT", "Design", "Purchasing"],
+  zh: ["研发部", "市场部", "销售部", "人力资源部", "财务部", "运营部", "研发中心", "客户支持部", "法务部", "信息技术部", "设计部", "采购部"],
+  zh_hant: ["研發部", "市場部", "銷售部", "人力資源部", "財務部", "營運部", "研發中心", "客戶支援部", "法務部", "資訊技術部", "設計部", "採購部"],
+  ja: ["エンジニアリング", "マーケティング", "営業", "人事", "経理", "オペレーション", "研究開発", "カスタマーサポート", "法務", "IT", "デザイン", "購買"],
+};
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function toggleLang(val: string) {
+  if (!props.params.languages) props.params.languages = [];
+  const idx = props.params.languages.indexOf(val);
+  if (idx >= 0) props.params.languages.splice(idx, 1);
+  else props.params.languages.push(val);
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const langs = props.params.languages?.length ? props.params.languages : ["en"];
+  const lang = pick(langs);
+  return pick(dataMap[lang] ?? dataMap["en"]);
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言选择</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button v-for="l in languages" :key="l.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.languages ?? []).includes(l.value) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleLang(l.value)">{{ l.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/EmailParams.vue b/apps/desktop/src/components/generate/params/EmailParams.vue
new file mode 100644
index 0000000..a9a8f7d
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/EmailParams.vue
@@ -0,0 +1,58 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const defaultDomains = "gmail.com\noutlook.com\nyahoo.com\nexample.com\ntest.org";
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+
+function genName(): string {
+  const len = Math.floor(Math.random() * 12) + 4;
+  return Array.from({ length: len }, () => chars[Math.floor(Math.random() * chars.length)]).join("");
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const domains = (props.params.emailDomains || defaultDomains)
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  if (domains.length === 0) return "(无域名)";
+  return `${genName()}@${pick(domains)}`;
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <Label class="text-xs text-muted-foreground mb-1 block">域（Domain）列表</Label>
+      <textarea v-model="params.emailDomains" rows="4" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono resize-y" :placeholder="defaultDomains" />
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm break-all">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto shrink-0" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/EnumParams.vue b/apps/desktop/src/components/generate/params/EnumParams.vue
new file mode 100644
index 0000000..5eb8d75
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/EnumParams.vue
@@ -0,0 +1,46 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const { t } = useI18n();
+
+const previewVal = computed(() => {
+  void previewKey.value;
+  const vals = (props.params.values ?? "")
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  if (vals.length === 0) return t("dataGenerate.noValue");
+  return vals[Math.floor(Math.random() * vals.length)];
+});
+
+const previewKey = ref(0);
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <Label class="text-xs text-muted-foreground mb-1 block">{{ t("dataGenerate.values") }}</Label>
+      <textarea v-model="params.values" rows="6" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono resize-y" placeholder="每行一个值&#10;first&#10;second&#10;third" />
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs overflow-hidden">
+        <span class="text-muted-foreground shrink-0">{{ t("dataGenerate.preview") }}</span>
+        <span :key="previewKey" class="font-mono text-sm truncate min-w-0">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/FileExtensionParams.vue b/apps/desktop/src/components/generate/params/FileExtensionParams.vue
new file mode 100644
index 0000000..ef76926
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/FileExtensionParams.vue
@@ -0,0 +1,79 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const extensionCategoryMap: Record<string, string[]> = {
+  image: [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg", ".webp", ".tiff"],
+  document: [".txt", ".pdf", ".doc", ".docx", ".rtf", ".odt"],
+  spreadsheet: [".xls", ".xlsx", ".csv", ".ods", ".tsv"],
+  presentation: [".ppt", ".pptx", ".odp", ".key"],
+  audio: [".mp3", ".wav", ".flac", ".aac", ".ogg", ".m4a"],
+  video: [".mp4", ".avi", ".mov", ".mkv", ".wmv", ".flv"],
+  code: [".js", ".ts", ".py", ".java", ".cpp", ".c", ".h", ".rs", ".go", ".rb", ".php"],
+  archive: [".zip", ".rar", ".7z", ".tar", ".gz", ".bz2"],
+  web: [".html", ".htm", ".css", ".json", ".xml", ".yml", ".yaml"],
+  database: [".db", ".sqlite", ".sql", ".mdb", ".accdb"],
+};
+
+const categoryLabels: Record<string, string> = {
+  image: "图像",
+  document: "文档",
+  spreadsheet: "表格",
+  presentation: "演示文稿",
+  audio: "音频",
+  video: "视频",
+  code: "代码",
+  archive: "压缩包",
+  web: "网页",
+  database: "数据库",
+};
+
+if (!props.params.extensionCategory) {
+  props.params.extensionCategory = "image";
+}
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const exts = extensionCategoryMap[props.params.extensionCategory ?? "image"] ?? extensionCategoryMap.image;
+  return pick(exts);
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">扩展名类型</div>
+      <select v-model="params.extensionCategory" class="w-full rounded border bg-background px-2 py-1 text-xs">
+        <option v-for="(label, key) in categoryLabels" :key="key" :value="key">{{ label }}</option>
+      </select>
+      <div class="mt-2 text-xs text-muted-foreground">扩展名列表：</div>
+      <div class="mt-1 flex flex-wrap gap-1">
+        <span v-for="ext in extensionCategoryMap[params.extensionCategory || 'image'] || []" :key="ext" class="px-1.5 py-0.5 rounded bg-background border text-xs font-mono">{{ ext }}</span>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/FileNameParams.vue b/apps/desktop/src/components/generate/params/FileNameParams.vue
new file mode 100644
index 0000000..57b37a0
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/FileNameParams.vue
@@ -0,0 +1,93 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const extensionCategoryMap: Record<string, string[]> = {
+  image: [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg", ".webp", ".tiff"],
+  document: [".txt", ".pdf", ".doc", ".docx", ".rtf", ".odt"],
+  spreadsheet: [".xls", ".xlsx", ".csv", ".ods", ".tsv"],
+  presentation: [".ppt", ".pptx", ".odp", ".key"],
+  audio: [".mp3", ".wav", ".flac", ".aac", ".ogg", ".m4a"],
+  video: [".mp4", ".avi", ".mov", ".mkv", ".wmv", ".flv"],
+  code: [".js", ".ts", ".py", ".java", ".cpp", ".c", ".h", ".rs", ".go", ".rb", ".php"],
+  archive: [".zip", ".rar", ".7z", ".tar", ".gz", ".bz2"],
+  web: [".html", ".htm", ".css", ".json", ".xml", ".yml", ".yaml"],
+  database: [".db", ".sqlite", ".sql", ".mdb", ".accdb"],
+};
+
+const categoryLabels: Record<string, string> = {
+  image: "图像",
+  document: "文档",
+  spreadsheet: "表格",
+  presentation: "演示文稿",
+  audio: "音频",
+  video: "视频",
+  code: "代码",
+  archive: "压缩包",
+  web: "网页",
+  database: "数据库",
+};
+
+if (!props.params.includeExtension) {
+  props.params.includeExtension = true;
+}
+if (!props.params.extensionCategory) {
+  props.params.extensionCategory = "image";
+}
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const nameBases = ["report", "photo", "backup", "config", "data", "file", "doc", "img", "project", "output", "result"];
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const base = pick(nameBases);
+  const num = Math.floor(Math.random() * 999999);
+  if (!props.params.includeExtension) return `${base}_${num}`;
+  const exts = extensionCategoryMap[props.params.extensionCategory ?? "image"] ?? extensionCategoryMap.image;
+  return `${base}_${num}${pick(exts)}`;
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <label class="text-xs text-muted-foreground flex items-center gap-2">
+        <input type="checkbox" v-model="params.includeExtension" class="rounded" />
+        包含扩展名
+      </label>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3" v-if="params.includeExtension">
+      <div class="text-xs text-muted-foreground mb-2">扩展名类型</div>
+      <select v-model="params.extensionCategory" class="w-full rounded border bg-background px-2 py-1 text-xs">
+        <option v-for="(label, key) in categoryLabels" :key="key" :value="key">{{ label }}</option>
+      </select>
+      <div class="mt-2 text-xs text-muted-foreground">可用扩展名：</div>
+      <div class="mt-1 flex flex-wrap gap-1">
+        <span v-for="ext in extensionCategoryMap[params.extensionCategory || 'image'] || []" :key="ext" class="px-1.5 py-0.5 rounded bg-background border text-xs font-mono">{{ ext }}</span>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/FilePathParams.vue b/apps/desktop/src/components/generate/params/FilePathParams.vue
new file mode 100644
index 0000000..ce43e80
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/FilePathParams.vue
@@ -0,0 +1,152 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const extensionCategoryMap: Record<string, string[]> = {
+  image: [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg", ".webp", ".tiff"],
+  document: [".txt", ".pdf", ".doc", ".docx", ".rtf", ".odt"],
+  spreadsheet: [".xls", ".xlsx", ".csv", ".ods", ".tsv"],
+  presentation: [".ppt", ".pptx", ".odp", ".key"],
+  audio: [".mp3", ".wav", ".flac", ".aac", ".ogg", ".m4a"],
+  video: [".mp4", ".avi", ".mov", ".mkv", ".wmv", ".flv"],
+  code: [".js", ".ts", ".py", ".java", ".cpp", ".c", ".h", ".rs", ".go", ".rb", ".php"],
+  archive: [".zip", ".rar", ".7z", ".tar", ".gz", ".bz2"],
+  web: [".html", ".htm", ".css", ".json", ".xml", ".yml", ".yaml"],
+  database: [".db", ".sqlite", ".sql", ".mdb", ".accdb"],
+};
+
+const categoryLabels: Record<string, string> = {
+  image: "图像",
+  document: "文档",
+  spreadsheet: "表格",
+  presentation: "演示文稿",
+  audio: "音频",
+  video: "视频",
+  code: "代码",
+  archive: "压缩包",
+  web: "网页",
+  database: "数据库",
+};
+
+if (!props.params.pathTypes) {
+  props.params.pathTypes = ["windows", "macos", "linux"];
+}
+if (!props.params.includeFileName) {
+  props.params.includeFileName = true;
+}
+if (!props.params.extensionCategory) {
+  props.params.extensionCategory = "image";
+}
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function generateWindowsPath(includeName: boolean, ext: string): string {
+  const baseDirs = ["Users", "Program Files", "ProgramData", "Windows", "Temp"];
+  const userDirs = ["Administrator", "User", "Admin", "Guest"];
+  const folders = ["Documents", "Downloads", "Pictures", "Music", "Videos", "Desktop"];
+  const nameBases = ["report", "doc", "img", "photo", "backup", "config", "data", "file"];
+  const base = `C:\\${pick(baseDirs)}\\${pick(userDirs)}\\${pick(folders)}`;
+  if (!includeName) return base;
+  return `${base}\\${pick(nameBases)}_${Math.floor(Math.random() * 999999)}${ext}`;
+}
+
+function generateMacPath(includeName: boolean, ext: string): string {
+  const users = ["administrator", "user", "admin", "guest"];
+  const folders = ["Documents", "Downloads", "Pictures", "Music", "Movies", "Desktop", "Library", "Applications"];
+  const nameBases = ["report", "doc", "img", "photo", "backup", "config", "data", "file"];
+  const base = `/Users/${pick(users)}/${pick(folders)}`;
+  if (!includeName) return base;
+  return `${base}/${pick(nameBases)}_${Math.floor(Math.random() * 999999)}${ext}`;
+}
+
+function generateLinuxPath(includeName: boolean, ext: string): string {
+  const baseDirs = ["home", "opt", "var", "usr", "tmp", "root"];
+  const users = ["user", "admin", "root", "ubuntu", "deploy"];
+  const folders = ["documents", "downloads", "pictures", "music", "videos", "projects", "data", "logs"];
+  const nameBases = ["report", "doc", "img", "photo", "backup", "config", "data", "file"];
+  const base = baseDirs[0] === "home" || pick(baseDirs) === "home" ? `/home/${pick(users)}/${pick(folders)}` : `/${pick(baseDirs)}/${pick(folders)}`;
+  if (!includeName) return base;
+  return `${base}/${pick(nameBases)}_${Math.floor(Math.random() * 999999)}${ext}`;
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const exts = extensionCategoryMap[props.params.extensionCategory ?? "image"] ?? extensionCategoryMap.image;
+  const ext = pick(exts);
+  const types = props.params.pathTypes?.length ? props.params.pathTypes : ["linux"];
+  const t = pick(types);
+  const includeName = props.params.includeFileName ?? true;
+  if (t === "windows") return generateWindowsPath(includeName, ext);
+  if (t === "macos") return generateMacPath(includeName, ext);
+  return generateLinuxPath(includeName, ext);
+});
+
+function togglePathType(val: string) {
+  if (!props.params.pathTypes) props.params.pathTypes = [];
+  const idx = props.params.pathTypes.indexOf(val);
+  if (idx >= 0) props.params.pathTypes.splice(idx, 1);
+  else props.params.pathTypes.push(val);
+}
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">路径类型</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button
+          v-for="pt in [
+            { value: 'windows', label: 'Windows' },
+            { value: 'macos', label: 'macOS' },
+            { value: 'linux', label: 'Linux' },
+          ]"
+          :key="pt.value"
+          type="button"
+          class="px-2 py-1 rounded border text-xs"
+          :class="(params.pathTypes || []).includes(pt.value) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'"
+          @click="togglePathType(pt.value)"
+        >
+          {{ pt.label }}
+        </button>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <label class="text-xs text-muted-foreground flex items-center gap-2">
+        <input type="checkbox" v-model="params.includeFileName" class="rounded" />
+        包含文件名称
+      </label>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">扩展名类型</div>
+      <select v-model="params.extensionCategory" class="w-full rounded border bg-background px-2 py-1 text-xs">
+        <option v-for="(label, key) in categoryLabels" :key="key" :value="key">{{ label }}</option>
+      </select>
+      <div class="mt-2 text-xs text-muted-foreground">可用扩展名：</div>
+      <div class="mt-1 flex flex-wrap gap-1">
+        <span v-for="ext in extensionCategoryMap[params.extensionCategory || 'image'] || []" :key="ext" class="px-1.5 py-0.5 rounded bg-background border text-xs font-mono">{{ ext }}</span>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm break-all">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/ForeignKeyParams.vue b/apps/desktop/src/components/generate/params/ForeignKeyParams.vue
new file mode 100644
index 0000000..abd3e19
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/ForeignKeyParams.vue
@@ -0,0 +1,118 @@
+<script setup lang="ts">
+import { ref, onMounted } from "vue";
+import { Label } from "@/components/ui/label";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import * as api from "@/lib/backend/api";
+
+const props = defineProps<{ params: GeneratorParams; config: any; connectionId?: string; database?: string }>();
+
+const schemas = ref<string[]>([]);
+const tables = ref<{ name: string }[]>([]);
+const columns = ref<{ name: string }[]>([]);
+const loadingSchemas = ref(false);
+const loadingTables = ref(false);
+const loadingColumns = ref(false);
+
+const fkModes = [
+  { value: "random", label: "随机" },
+  { value: "unique", label: "不重复" },
+  { value: "repeat", label: "重复每个值" },
+];
+
+onMounted(async () => {
+  await loadSchemas();
+});
+
+async function loadSchemas() {
+  if (!props.connectionId || !props.database) return;
+  loadingSchemas.value = true;
+  try {
+    schemas.value = await api.listSchemas(props.connectionId, props.database);
+    if (schemas.value.length === 0) schemas.value = ["main"];
+    if (props.params.fkSchema) await loadTables();
+  } catch {
+    schemas.value = ["main"];
+  } finally {
+    loadingSchemas.value = false;
+  }
+}
+
+async function loadTables() {
+  if (!props.connectionId || !props.database || !props.params.fkSchema) return;
+  loadingTables.value = true;
+  try {
+    tables.value = await api.listTables(props.connectionId, props.database, props.params.fkSchema);
+    if (props.params.fkTable) await loadColumns();
+  } catch {
+    tables.value = [];
+  } finally {
+    loadingTables.value = false;
+  }
+}
+
+async function loadColumns() {
+  if (!props.connectionId || !props.database || !props.params.fkSchema || !props.params.fkTable) return;
+  loadingColumns.value = true;
+  try {
+    const cols = await api.getColumns(props.connectionId, props.database, props.params.fkSchema, props.params.fkTable);
+    columns.value = cols.map((c: any) => ({ name: c.name }));
+  } catch {
+    columns.value = [];
+  } finally {
+    loadingColumns.value = false;
+  }
+}
+
+function onSchemaChange(val: string) {
+  props.params.fkSchema = val;
+  props.params.fkTable = undefined;
+  props.params.fkField = undefined;
+  tables.value = [];
+  columns.value = [];
+  void loadTables();
+}
+
+function onTableChange(val: string) {
+  props.params.fkTable = val;
+  props.params.fkField = undefined;
+  columns.value = [];
+  void loadColumns();
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3 space-y-2">
+      <div class="grid grid-cols-[60px_1fr] items-center gap-2 text-xs">
+        <Label class="text-muted-foreground">模式</Label>
+        <select v-model="props.params.fkSchema" class="h-7 rounded border bg-background px-2 text-xs" @change="onSchemaChange(($event.target as HTMLSelectElement).value)">
+          <option v-if="loadingSchemas" disabled>加载中...</option>
+          <option v-for="s in schemas" :key="s" :value="s">{{ s }}</option>
+        </select>
+      </div>
+      <div class="grid grid-cols-[60px_1fr] items-center gap-2 text-xs">
+        <Label class="text-muted-foreground">表</Label>
+        <select v-model="props.params.fkTable" class="h-7 rounded border bg-background px-2 text-xs" @change="onTableChange(($event.target as HTMLSelectElement).value)">
+          <option v-if="loadingTables" disabled>加载中...</option>
+          <option v-for="t in tables" :key="t.name" :value="t.name">{{ t.name }}</option>
+        </select>
+      </div>
+      <div class="grid grid-cols-[60px_1fr] items-center gap-2 text-xs">
+        <Label class="text-muted-foreground">字段</Label>
+        <select v-model="props.params.fkField" class="h-7 rounded border bg-background px-2 text-xs">
+          <option v-if="loadingColumns" disabled>加载中...</option>
+          <option v-for="c in columns" :key="c.name" :value="c.name">{{ c.name }}</option>
+        </select>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">生成模式</div>
+      <div class="flex items-center gap-2 text-xs flex-wrap">
+        <button v-for="m in fkModes" :key="m.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.fkMode || 'random') === m.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.fkMode = m.value as 'random' | 'unique' | 'repeat'">
+          {{ m.label }}
+        </button>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/FullNameParams.vue b/apps/desktop/src/components/generate/params/FullNameParams.vue
new file mode 100644
index 0000000..5a94632
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/FullNameParams.vue
@@ -0,0 +1,106 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const nameFormats: Array<{ value: "full" | "last" | "first"; label: string }> = [
+  { value: "full", label: "全名" },
+  { value: "last", label: "仅姓氏" },
+  { value: "first", label: "仅名字" },
+];
+
+const languageOptions = [
+  { value: "en", label: "English" },
+  { value: "zh_pinyin", label: "Chinese (Pinyin)" },
+  { value: "zh_hans", label: "Chinese (简体中文)" },
+  { value: "zh_eng", label: "Chinese (Eng)" },
+  { value: "zh_hant", label: "Chinese (繁体中文)" },
+  { value: "ja_romaji", label: "Japanese (Romaji)" },
+  { value: "ja", label: "Japanese (日本語)" },
+];
+
+function formatName(first: string, last: string, lang: string): string {
+  const cjkNative = new Set(["zh_hans", "zh_hant", "ja"]);
+  const cjkRomanized = new Set(["zh_pinyin", "ja_romaji"]);
+  if (cjkNative.has(lang)) return `${last}${first}`;
+  if (cjkRomanized.has(lang)) return `${last} ${first}`;
+  return `${first} ${last}`;
+}
+
+const firstNames: Record<string, string[]> = {
+  en: ["James", "Mary", "John", "Patricia", "Robert", "Jennifer", "Michael", "Linda", "David", "Elizabeth"],
+  zh_hans: ["伟", "芳", "娜", "秀英", "敏", "静", "丽", "强", "磊", "洋"],
+  zh_hant: ["偉", "芳", "娜", "秀英", "敏", "靜", "麗", "強", "磊", "洋"],
+  ja: ["翼", "桜", "翔太", "美咲", "蓮", "結菜", "大輔", "陽子"],
+};
+const lastNames: Record<string, string[]> = {
+  en: ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis"],
+  zh_hans: ["王", "李", "张", "刘", "陈", "杨", "赵", "黄"],
+  zh_hant: ["王", "李", "張", "劉", "陳", "楊", "趙", "黃"],
+  ja: ["佐藤", "鈴木", "高橋", "田中", "渡辺"],
+};
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const langs = props.params.languages?.length ? props.params.languages : ["en"];
+  const lang = pick(langs);
+  const fn = firstNames[lang] ?? firstNames["en"];
+  const ln = lastNames[lang] ?? lastNames["en"];
+  const fmt = props.params.nameFormat ?? "full";
+  const first = pick(fn);
+  const last = pick(ln);
+  if (fmt === "first") return first;
+  if (fmt === "last") return last;
+  return formatName(first, last, lang);
+});
+
+function toggleLang(val: string) {
+  if (!props.params.languages) props.params.languages = [];
+  const idx = props.params.languages.indexOf(val);
+  if (idx >= 0) props.params.languages.splice(idx, 1);
+  else props.params.languages.push(val);
+}
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">格式类型</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button v-for="f in nameFormats" :key="f.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.nameFormat || 'full') === f.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.nameFormat = f.value">{{ f.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言选择</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button v-for="l in languageOptions" :key="l.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.languages ?? []).includes(l.value) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleLang(l.value)">{{ l.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/GenderParams.vue b/apps/desktop/src/components/generate/params/GenderParams.vue
new file mode 100644
index 0000000..4720189
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/GenderParams.vue
@@ -0,0 +1,64 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const languages = [
+  { value: "en", label: "English" },
+  { value: "zh", label: "简体中文" },
+  { value: "zh_hant", label: "繁体中文" },
+  { value: "ja", label: "日本語" },
+];
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const lang = props.params.languages?.[0] ?? "en";
+  const map: Record<string, string[]> = {
+    en: ["Male", "Female"],
+    zh: ["男", "女"],
+    zh_hant: ["男", "女"],
+    ja: ["男性", "女性"],
+  };
+  return pick(map[lang] ?? map["en"]);
+});
+
+function setLang(val: string) {
+  props.params.languages = [val];
+}
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言选择</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button v-for="l in languages" :key="l.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.languages?.[0] || 'en') === l.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="setLang(l.value)">{{ l.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" :disable-default="true" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/GeneratorParamsPanel.vue b/apps/desktop/src/components/generate/params/GeneratorParamsPanel.vue
new file mode 100644
index 0000000..08653bd
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/GeneratorParamsPanel.vue
@@ -0,0 +1,134 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { RotateCcw } from "@lucide/vue";
+import type { ColumnGenerateConfig, GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import GeneratorSelect from "../GeneratorSelect.vue";
+import NumberParams from "./NumberParams.vue";
+import DateTimeParams from "./DateTimeParams.vue";
+import DateParams from "./DateParams.vue";
+import TimeParams from "./TimeParams.vue";
+import SequenceParams from "./SequenceParams.vue";
+import EnumParams from "./EnumParams.vue";
+import TextParams from "./TextParams.vue";
+import ImageBinaryParams from "./ImageBinaryParams.vue";
+import ForeignKeyParams from "./ForeignKeyParams.vue";
+import UuidParams from "./UuidParams.vue";
+import RegexParams from "./RegexParams.vue";
+import FullNameParams from "./FullNameParams.vue";
+import GenderParams from "./GenderParams.vue";
+import TitleParams from "./TitleParams.vue";
+import MaritalStatusParams from "./MaritalStatusParams.vue";
+import PhoneParams from "./PhoneParams.vue";
+import EmailParams from "./EmailParams.vue";
+import JobTitleParams from "./JobTitleParams.vue";
+import SocialIdParams from "./SocialIdParams.vue";
+import PaymentMethodParams from "./PaymentMethodParams.vue";
+import CreditCardTypeParams from "./CreditCardTypeParams.vue";
+import CreditCardNumberParams from "./CreditCardNumberParams.vue";
+import CreditCardDateParams from "./CreditCardDateParams.vue";
+import CompanyNameParams from "./CompanyNameParams.vue";
+import DepartmentParams from "./DepartmentParams.vue";
+import IndustryParams from "./IndustryParams.vue";
+import AddressParams from "./AddressParams.vue";
+import CityParams from "./CityParams.vue";
+import RegionParams from "./RegionParams.vue";
+import ProductNameParams from "./ProductNameParams.vue";
+import ProductCategoryParams from "./ProductCategoryParams.vue";
+import ColorParams from "./ColorParams.vue";
+import SizeParams from "./SizeParams.vue";
+import WeightUnitParams from "./WeightUnitParams.vue";
+import BarcodeParams from "./BarcodeParams.vue";
+import SkuParams from "./SkuParams.vue";
+import IpAddressParams from "./IpAddressParams.vue";
+import MacAddressParams from "./MacAddressParams.vue";
+import FilePathParams from "./FilePathParams.vue";
+import FileNameParams from "./FileNameParams.vue";
+import FileExtensionParams from "./FileExtensionParams.vue";
+import UrlParams from "./UrlParams.vue";
+import HostnameParams from "./HostnameParams.vue";
+import IdNumberParams from "./IdNumberParams.vue";
+import DefaultParams from "./DefaultParams.vue";
+
+const { t } = useI18n();
+const props = defineProps<{ config: ColumnGenerateConfig; connectionId?: string; database?: string }>();
+
+function initParams() {
+  if (!props.config.generatorParams) {
+    props.config.generatorParams = {} as GeneratorParams;
+  }
+  return props.config.generatorParams;
+}
+
+const key = computed(() => props.config.generatorKey);
+
+function resetParams() {
+  props.config.generatorParams = {} as GeneratorParams;
+}
+
+const componentMap: Record<string, any> = {
+  number: NumberParams,
+  datetime: DateTimeParams,
+  date: DateParams,
+  time: TimeParams,
+  sequence: SequenceParams,
+  enum: EnumParams,
+  text: TextParams,
+  image: ImageBinaryParams,
+  foreign_key: ForeignKeyParams,
+  uuid: UuidParams,
+  regex: RegexParams,
+  full_name: FullNameParams,
+  gender: GenderParams,
+  title: TitleParams,
+  marital_status: MaritalStatusParams,
+  phone: PhoneParams,
+  email: EmailParams,
+  job_title: JobTitleParams,
+  social_id: SocialIdParams,
+  payment_method: PaymentMethodParams,
+  credit_card_type: CreditCardTypeParams,
+  credit_card_number: CreditCardNumberParams,
+  credit_card_date: CreditCardDateParams,
+  company_name: CompanyNameParams,
+  department: DepartmentParams,
+  industry: IndustryParams,
+  address: AddressParams,
+  city: CityParams,
+  region: RegionParams,
+  product_name: ProductNameParams,
+  product_category: ProductCategoryParams,
+  color: ColorParams,
+  size: SizeParams,
+  weight_unit: WeightUnitParams,
+  barcode: BarcodeParams,
+  sku: SkuParams,
+  ip_address: IpAddressParams,
+  mac_address: MacAddressParams,
+  file_path: FilePathParams,
+  file_name: FileNameParams,
+  file_extension: FileExtensionParams,
+  url: UrlParams,
+  hostname: HostnameParams,
+  id_number: IdNumberParams,
+};
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="grid grid-cols-[80px_1fr_auto] items-center gap-2 text-xs">
+        <span class="text-muted-foreground">{{ t("dataGenerate.generator") }}</span>
+        <GeneratorSelect v-model="config.generatorKey" />
+        <Button variant="outline" size="sm" class="h-7 text-xs gap-1" @click="resetParams">
+          <RotateCcw class="h-3 w-3" />
+          {{ t("dataGenerate.reset") }}
+        </Button>
+      </div>
+    </div>
+
+    <component :is="componentMap[key!] ?? DefaultParams" v-if="key" :params="initParams()" :config="config" :connection-id="connectionId" :database="database" />
+    <div v-else class="text-xs text-muted-foreground px-1 py-3 text-center border rounded-md bg-muted/5">{{ t("dataGenerate.selectGeneratorHint") }}</div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/HostnameParams.vue b/apps/desktop/src/components/generate/params/HostnameParams.vue
new file mode 100644
index 0000000..d286264
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/HostnameParams.vue
@@ -0,0 +1,68 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+if (!props.params.urlSubdomains) {
+  props.params.urlSubdomains = "auth.\ndrive.\nimage.\nwww.\napi.\nmail.\nshop.\nblog.";
+}
+if (!props.params.urlTlds) {
+  props.params.urlTlds = ".biz\n.co.jp\n.com\n.cn\n.org\n.net\n.io\n.dev\n.xyz";
+}
+
+const baseDomains = ["example", "test", "demo", "sample", "meyer80", "acme", "contoso", "fabrikam"];
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function splitLines(text: string): string[] {
+  return text
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const subs = splitLines(props.params.urlSubdomains ?? "");
+  const tlds = splitLines(props.params.urlTlds ?? "");
+  const sub = subs.length ? pick(subs) : "www.";
+  const tld = tlds.length ? pick(tlds) : ".com";
+  const base = pick(baseDomains);
+  return `${sub}${base}${tld}`;
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <Label class="text-xs text-muted-foreground mb-1 block">子域</Label>
+      <textarea v-model="params.urlSubdomains" rows="4" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono resize-y" placeholder="每行一个子域&#10;auth.&#10;www.&#10;api." />
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <Label class="text-xs text-muted-foreground mb-1 block">顶级域</Label>
+      <textarea v-model="params.urlTlds" rows="4" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono resize-y" placeholder="每行一个TLD&#10;.com&#10;.cn&#10;.io" />
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm break-all">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/IdNumberParams.vue b/apps/desktop/src/components/generate/params/IdNumberParams.vue
new file mode 100644
index 0000000..8aa268d
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/IdNumberParams.vue
@@ -0,0 +1,250 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const { t } = useI18n();
+
+function tr(key: string, fallback: string): string {
+  const v = t("dataGenerate.idTypes." + key);
+  return v === "dataGenerate.idTypes." + key ? fallback : v;
+}
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const idTypeKeys = ["id_card", "passport", "hk_macau_pass", "taiwan_pass", "uscc", "bank_card", "drivers_license", "custom"];
+
+if (!props.params.idTypes) {
+  props.params.idTypes = ["id_card"];
+}
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function toggleType(val: string) {
+  if (!props.params.idTypes) props.params.idTypes = [];
+  const idx = props.params.idTypes.indexOf(val);
+  if (idx >= 0) props.params.idTypes.splice(idx, 1);
+  else props.params.idTypes.push(val);
+}
+
+const hasCustom = computed(() => (props.params.idTypes ?? []).includes("custom"));
+
+const areaCodes = [
+  "110101",
+  "110105",
+  "110108",
+  "120101",
+  "120103",
+  "130102",
+  "130105",
+  "210102",
+  "210105",
+  "210203",
+  "310101",
+  "310104",
+  "310115",
+  "320102",
+  "320105",
+  "330102",
+  "330106",
+  "340102",
+  "340104",
+  "350102",
+  "360102",
+  "370102",
+  "370202",
+  "410102",
+  "410105",
+  "420102",
+  "420106",
+  "430102",
+  "440103",
+  "440106",
+  "440303",
+  "440305",
+  "450102",
+  "460105",
+  "500103",
+  "510104",
+  "510107",
+  "520102",
+  "530102",
+  "540102",
+  "610103",
+  "620102",
+  "630102",
+  "640104",
+  "650102",
+];
+
+function generateIdCard(): string {
+  const area = pick(areaCodes);
+  const year = (1970 + Math.floor(Math.random() * 35)).toString();
+  const month = (Math.floor(Math.random() * 12) + 1).toString().padStart(2, "0");
+  const day = (Math.floor(Math.random() * 28) + 1).toString().padStart(2, "0");
+  const seq = Math.floor(Math.random() * 1000)
+    .toString()
+    .padStart(3, "0");
+  const first17 = `${area}${year}${month}${day}${seq}`;
+  const weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+  const checks = ["1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"];
+  let sum = 0;
+  for (let i = 0; i < 17; i++) sum += parseInt(first17[i]) * weights[i];
+  const check = checks[sum % 11];
+  return `${first17}${check}`;
+}
+
+function randDigits(n: number): string {
+  return Array.from({ length: n }, () => Math.floor(Math.random() * 10).toString()).join("");
+}
+
+function generatePassport(): string {
+  return `${pick(["E", "G", "E", "H", "P"])}${randDigits(7)}`;
+}
+
+function generateHKMacauPass(): string {
+  return `${pick(["C", "W", "H"])}${randDigits(8)}`;
+}
+
+function generateTaiwanPass(): string {
+  return `T${randDigits(8)}`;
+}
+
+function generateUSCC(): string {
+  const randChars = (n: number) => Array.from({ length: n }, () => "ABCDEFGHJKLMNPQRSTUVWXY23456789".charAt(Math.floor(Math.random() * "ABCDEFGHJKLMNPQRSTUVWXY23456789".length))).join("");
+  return `91310115MA${randChars(6)}${randDigits(4)}`;
+}
+
+function luhnCalculateCheckDigit(numStr: string): string {
+  let sum = 0;
+  const digits = numStr.split("").map(Number);
+  for (let i = 0; i < digits.length; i++) {
+    let d = digits[digits.length - 1 - i];
+    if (i % 2 === 0) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+  }
+  return ((10 - (sum % 10)) % 10).toString();
+}
+
+function generateBankCard(): string {
+  const bins = ["622202", "622700", "621700", "622848", "621559", "621798", "622208", "622280", "621661", "621785", "622588", "621286", "622696"];
+  const bin = pick(bins);
+  const middle = randDigits(10);
+  const first15 = `${bin}${middle}`;
+  return `${first15}${luhnCalculateCheckDigit(first15)}`;
+}
+
+function randFromCharSet(charSet: string, n: number): string {
+  return Array.from({ length: n }, () => charSet.charAt(Math.floor(Math.random() * charSet.length))).join("");
+}
+
+function generateFromPattern(pattern: string): string {
+  const letterCharSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const digitCharSet = "0123456789";
+  let result = "";
+  const tokens = pattern.split(/([{}[\]-])/).filter(Boolean);
+  let i = 0;
+  while (i < tokens.length) {
+    const t = tokens[i];
+    if (t === "(" || t === ")") {
+      i++;
+      continue;
+    }
+    if (t === "[") {
+      const charSetToken = tokens[i + 1];
+      i += 2;
+      let charSet = "";
+      if (charSetToken?.includes("A-F") || charSetToken?.includes("A-Z")) charSet = letterCharSet;
+      else if (charSetToken?.includes("0-9")) charSet = digitCharSet;
+      else charSet = letterCharSet + digitCharSet;
+      i++;
+      let count = 1;
+      if (tokens[i] === "{") {
+        i++;
+        count = parseInt(tokens[i], 10) || 1;
+        i += 2;
+      }
+      result += randFromCharSet(charSet, count);
+      continue;
+    }
+    if (t === "-") {
+      result += "-";
+      i++;
+      continue;
+    }
+    i++;
+  }
+  if (!result) {
+    return randDigits(10);
+  }
+  return result;
+}
+
+function generateByType(type: string): string {
+  switch (type) {
+    case "id_card":
+      return generateIdCard();
+    case "passport":
+      return generatePassport();
+    case "hk_macau_pass":
+      return generateHKMacauPass();
+    case "taiwan_pass":
+      return generateTaiwanPass();
+    case "uscc":
+      return generateUSCC();
+    case "bank_card":
+      return generateBankCard();
+    case "drivers_license":
+      return generateIdCard();
+    case "custom":
+      return generateFromPattern(props.params.idCustomPattern ?? "([A-Z]{2})-([0-9]{8})");
+    default:
+      return generateIdCard();
+  }
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const selected = props.params.idTypes?.length ? props.params.idTypes : ["id_card"];
+  return generateByType(pick(selected));
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">{{ tr("title", "证件类型") }}</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button v-for="k in idTypeKeys" :key="k" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.idTypes ?? []).includes(k) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleType(k)">{{ tr(k, k) }}</button>
+      </div>
+    </div>
+    <div v-if="hasCustom" class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-1">{{ tr("customPattern", "自定义模式") }}</div>
+      <input v-model="params.idCustomPattern" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono" :placeholder="tr('customPatternPlaceholder', '如 ([A-Z]{2})-([0-9]{8})')" />
+      <div class="text-[10px] text-muted-foreground mt-1">{{ tr("customPatternHint", "支持 [A-Z] 字母、[0-9] 数字、{n} 重复、连字符等简单模式") }}</div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">{{ t("dataGenerate.preview") }}</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/ImageBinaryParams.vue b/apps/desktop/src/components/generate/params/ImageBinaryParams.vue
new file mode 100644
index 0000000..3820870
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/ImageBinaryParams.vue
@@ -0,0 +1,56 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import { useI18n } from "vue-i18n";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const { t } = useI18n();
+
+const isGenerate = computed(() => props.params.imageMode !== "folder");
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">{{ t("dataGenerate.imageMode") }}</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="isGenerate ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.imageMode = 'generate'">{{ t("dataGenerate.generate") }}</button>
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="!isGenerate ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.imageMode = 'folder'">{{ t("dataGenerate.fromFolder") }}</button>
+      </div>
+    </div>
+
+    <template v-if="isGenerate">
+      <div class="rounded-md border bg-muted/10 p-3 space-y-2">
+        <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs">
+          <Label class="text-muted-foreground">{{ t("dataGenerate.imageWidth") }}</Label>
+          <Input v-model.number="params.imageWidth" type="number" placeholder="200" class="h-7 w-24 text-xs" />
+        </div>
+        <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs">
+          <Label class="text-muted-foreground">{{ t("dataGenerate.imageHeight") }}</Label>
+          <Input v-model.number="params.imageHeight" type="number" placeholder="200" class="h-7 w-24 text-xs" />
+        </div>
+        <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs">
+          <Label class="text-muted-foreground">{{ t("dataGenerate.imageFormat") }}</Label>
+          <div class="flex items-center gap-2">
+            <button type="button" class="px-2 py-1 rounded border text-xs" :class="(params.imageFormat || 'JPEG') === 'JPEG' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.imageFormat = 'JPEG'">JPEG</button>
+            <button type="button" class="px-2 py-1 rounded border text-xs" :class="params.imageFormat === 'PNG' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.imageFormat = 'PNG'">PNG</button>
+          </div>
+        </div>
+      </div>
+    </template>
+
+    <template v-else>
+      <div class="rounded-md border bg-muted/10 p-3 space-y-2">
+        <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs">
+          <Label class="text-muted-foreground">{{ t("dataGenerate.folderPath") }}</Label>
+          <Input v-model="params.folderPath" type="text" placeholder="/path/to/images" class="h-7 text-xs" />
+        </div>
+        <div class="text-xs text-muted-foreground mt-2 mb-1">{{ t("dataGenerate.filterByExtension") }}</div>
+        <textarea v-model="params.fileExtensions" rows="3" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono resize-y" placeholder="每行一个扩展名&#10;png&#10;jpg&#10;txt" />
+      </div>
+    </template>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/IndustryParams.vue b/apps/desktop/src/components/generate/params/IndustryParams.vue
new file mode 100644
index 0000000..e0d2ef3
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/IndustryParams.vue
@@ -0,0 +1,71 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const languages = [
+  { value: "en", label: "English" },
+  { value: "zh", label: "简体中文" },
+  { value: "zh_hant", label: "繁體中文" },
+  { value: "ja", label: "日本語" },
+];
+
+if (!props.params.languages) props.params.languages = ["en"];
+
+const dataMap: Record<string, string[]> = {
+  en: ["Technology", "Healthcare", "Finance", "Education", "Manufacturing", "Retail", "Media", "Energy", "Real Estate", "Transportation", "Telecommunications", "Agriculture", "Hospitality", "Pharmaceutical", "Automotive", "Logistics", "Construction", "Entertainment"],
+  zh: ["科技", "医疗保健", "金融", "教育", "制造业", "零售", "媒体", "能源", "房地产", "交通运输", "电信", "农业", "酒店业", "制药", "汽车", "物流", "建筑", "娱乐"],
+  zh_hant: ["科技", "醫療保健", "金融", "教育", "製造業", "零售", "媒體", "能源", "房地產", "交通運輸", "電信", "農業", "酒店業", "製藥", "汽車", "物流", "建築", "娛樂"],
+  ja: ["テクノロジー", "医療", "金融", "教育", "製造業", "小売", "メディア", "エネルギー", "不動産", "運輸", "通信", "農業", "ホスピタリティ", "製薬", "自動車", "物流", "建設", "エンターテイメント"],
+};
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function toggleLang(val: string) {
+  if (!props.params.languages) props.params.languages = [];
+  const idx = props.params.languages.indexOf(val);
+  if (idx >= 0) props.params.languages.splice(idx, 1);
+  else props.params.languages.push(val);
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const langs = props.params.languages?.length ? props.params.languages : ["en"];
+  const lang = pick(langs);
+  return pick(dataMap[lang] ?? dataMap["en"]);
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言选择</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button v-for="l in languages" :key="l.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.languages ?? []).includes(l.value) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleLang(l.value)">{{ l.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/IpAddressParams.vue b/apps/desktop/src/components/generate/params/IpAddressParams.vue
new file mode 100644
index 0000000..6968bf7
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/IpAddressParams.vue
@@ -0,0 +1,70 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const ipTypes = [
+  { value: "ipv4", label: "IPv4", regex: "^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$" },
+  { value: "ipv6", label: "IPv6", regex: "^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$" },
+];
+
+function generateIPv4(): string {
+  return `${Math.floor(Math.random() * 256)}.${Math.floor(Math.random() * 256)}.${Math.floor(Math.random() * 256)}.${Math.floor(Math.random() * 256)}`;
+}
+
+function generateIPv6(): string {
+  const groups: string[] = [];
+  for (let i = 0; i < 8; i++) {
+    groups.push(
+      Math.floor(Math.random() * 65536)
+        .toString(16)
+        .padStart(4, "0"),
+    );
+  }
+  return groups.join(":");
+}
+
+const previewKey = ref(0);
+const currentRegex = computed(() => {
+  const t = props.params.ipType ?? "ipv4";
+  return ipTypes.find((x) => x.value === t)?.regex ?? "";
+});
+const previewVal = computed(() => {
+  void previewKey.value;
+  if (props.params.ipType === "ipv6") return generateIPv6();
+  return generateIPv4();
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">IP地址类型</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button v-for="t in ipTypes" :key="t.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.ipType || 'ipv4') === t.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.ipType = t.value">{{ t.label }}</button>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-1">正则表达式</div>
+      <div class="font-mono text-xs bg-background rounded border px-2 py-1 break-all">{{ currentRegex }}</div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/JobTitleParams.vue b/apps/desktop/src/components/generate/params/JobTitleParams.vue
new file mode 100644
index 0000000..902b8d7
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/JobTitleParams.vue
@@ -0,0 +1,64 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const languages = [
+  { value: "en", label: "English" },
+  { value: "zh", label: "简体中文" },
+  { value: "zh_hant", label: "繁体中文" },
+  { value: "ja", label: "日本語" },
+];
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const lang = props.params.languages?.[0] ?? "en";
+  const map: Record<string, string[]> = {
+    en: ["Software Engineer", "Senior Manager", "Product Designer", "Data Analyst", "DevOps Engineer", "HR Director", "Marketing Lead", "Human resources manager"],
+    zh: ["软件工程师", "高级经理", "产品设计师", "数据分析师", "运维工程师", "人力资源总监", "市场主管", "项目经理"],
+    zh_hant: ["軟體工程師", "高級經理", "產品設計師", "數據分析師", "運維工程師", "人力資源總監", "市場主管"],
+    ja: ["ソフトウェアエンジニア", "シニアマネージャー", "プロダクトデザイナー", "データアナリスト", "人事部長", "マーケティング部長"],
+  };
+  return pick(map[lang] ?? map["en"]);
+});
+
+function setLang(val: string) {
+  props.params.languages = [val];
+}
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言选择</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button v-for="l in languages" :key="l.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.languages?.[0] || 'en') === l.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="setLang(l.value)">{{ l.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/MacAddressParams.vue b/apps/desktop/src/components/generate/params/MacAddressParams.vue
new file mode 100644
index 0000000..55af5d1
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/MacAddressParams.vue
@@ -0,0 +1,50 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+if (!props.params.pattern) {
+  props.params.pattern = "([0-9a-f]{2}[:]){5}([0-9a-f]{2})";
+}
+
+function generateMac(): string {
+  return Array.from({ length: 6 }, () =>
+    Math.floor(Math.random() * 256)
+      .toString(16)
+      .padStart(2, "0"),
+  ).join(":");
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  return generateMac();
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-1">正则表达式</div>
+      <input v-model="params.pattern" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono" />
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/MaritalStatusParams.vue b/apps/desktop/src/components/generate/params/MaritalStatusParams.vue
new file mode 100644
index 0000000..20a7d0b
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/MaritalStatusParams.vue
@@ -0,0 +1,64 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const languages = [
+  { value: "en", label: "English" },
+  { value: "zh", label: "简体中文" },
+  { value: "zh_hant", label: "繁体中文" },
+  { value: "ja", label: "日本語" },
+];
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const lang = props.params.languages?.[0] ?? "en";
+  const map: Record<string, string[]> = {
+    en: ["Married", "Single", "Divorced", "Widowed"],
+    zh: ["已婚", "未婚", "离异", "丧偶"],
+    zh_hant: ["已婚", "未婚", "離異", "喪偶"],
+    ja: ["既婚", "未婚", "離婚", "死別"],
+  };
+  return pick(map[lang] ?? map["en"]);
+});
+
+function setLang(val: string) {
+  props.params.languages = [val];
+}
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言选择</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button v-for="l in languages" :key="l.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.languages?.[0] || 'en') === l.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="setLang(l.value)">{{ l.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/NumberParams.vue b/apps/desktop/src/components/generate/params/NumberParams.vue
new file mode 100644
index 0000000..5632b9d
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/NumberParams.vue
@@ -0,0 +1,77 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import { randInt, randDecimal } from "@/lib/dataGrid/dataGenerate";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const { t } = useI18n();
+
+const previewVal = computed(() => {
+  void previewKey.value;
+  const p = props.params;
+  const min = p.min ?? 1;
+  const max = p.max ?? 1000;
+  if (p.numberType === "decimal") {
+    return randDecimal(min, max, p.decimalPlaces ?? 2).toString();
+  }
+  return randInt(min, max).toString();
+});
+
+const isDecimal = computed(() => props.params.numberType === "decimal");
+
+function handleTypeChange(val: "integer" | "decimal") {
+  props.params.numberType = val;
+  if (val === "integer") delete props.params.decimalPlaces;
+  else props.params.decimalPlaces = props.params.decimalPlaces ?? 2;
+}
+
+const previewKey = ref(0);
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs">
+        <Label class="text-muted-foreground">{{ t("dataGenerate.min") }}</Label>
+        <Input v-model.number="params.min" type="number" placeholder="1" class="h-7 text-xs" />
+      </div>
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs mt-2">
+        <Label class="text-muted-foreground">{{ t("dataGenerate.max") }}</Label>
+        <Input v-model.number="params.max" type="number" placeholder="1000" class="h-7 text-xs" />
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-3 text-xs">
+        <Label class="text-muted-foreground shrink-0">数字类型</Label>
+        <div class="flex gap-2">
+          <button type="button" class="px-2 py-1 rounded text-xs border" :class="params.numberType !== 'decimal' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="handleTypeChange('integer')">整数</button>
+          <button type="button" class="px-2 py-1 rounded text-xs border" :class="params.numberType === 'decimal' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="handleTypeChange('decimal')">小数</button>
+        </div>
+      </div>
+      <div v-if="isDecimal" class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs mt-2">
+        <Label class="text-muted-foreground">小数位数</Label>
+        <Input v-model.number="params.decimalPlaces" type="number" min="0" max="10" class="h-7 w-20 text-xs" />
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">{{ t("dataGenerate.preview") }}</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/PaymentMethodParams.vue b/apps/desktop/src/components/generate/params/PaymentMethodParams.vue
new file mode 100644
index 0000000..8653109
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/PaymentMethodParams.vue
@@ -0,0 +1,50 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+if (!props.params.values) {
+  props.params.values = "Credit Card\nPayPal\nApple Pay\nGoogle Pay\nBank Transfer\nCash\nCryptocurrency\nAlipay\nWeChat Pay";
+}
+
+const previewVal = computed(() => {
+  void previewKey.value;
+  const vals = (props.params.values ?? "")
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  if (vals.length === 0) return "(无)";
+  return vals[Math.floor(Math.random() * vals.length)];
+});
+
+const previewKey = ref(0);
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <Label class="text-xs text-muted-foreground mb-1 block">值列表</Label>
+      <textarea v-model="params.values" rows="6" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono resize-y" placeholder="每行一个支付方式&#10;Credit Card&#10;PayPal&#10;Apple Pay" />
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/PhoneParams.vue b/apps/desktop/src/components/generate/params/PhoneParams.vue
new file mode 100644
index 0000000..8be5425
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/PhoneParams.vue
@@ -0,0 +1,113 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Label } from "@/components/ui/label";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const { t } = useI18n();
+
+const regions = [
+  { value: "us", label: "美国" },
+  { value: "uk", label: "英国" },
+  { value: "cn", label: "中国" },
+  { value: "jp", label: "日本" },
+  { value: "other", label: "其他" },
+];
+
+function randInt(min: number, max: number) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function genCN(sep: boolean): string {
+  const a = randInt(130, 199);
+  const b = randInt(1000, 9999);
+  const c = randInt(1000, 9999);
+  return sep ? `${a}-${b}-${c}` : `${a}${b}${c}`;
+}
+function genUS(sep: boolean): string {
+  const a = randInt(200, 999);
+  const b = randInt(100, 999);
+  const c = randInt(1000, 9999);
+  return sep ? `(${a}) ${b}-${c}` : `+1${a}${b}${c}`;
+}
+function genUK(sep: boolean): string {
+  const a = randInt(1000, 9999);
+  const b = randInt(100000, 999999);
+  return sep ? `${a} ${b}` : `+44${a}${b}`;
+}
+function genJP(sep: boolean): string {
+  const a = randInt(10, 99);
+  const b = randInt(1000, 9999);
+  const c = randInt(1000, 9999);
+  return sep ? `0${a}-${b}-${c}` : `+810${a}${b}${c}`;
+}
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const regs = props.params.phoneRegions?.length ? props.params.phoneRegions : ["cn"];
+  const reg = pick(regs);
+  const sep = !!props.params.phoneSeparator;
+  const num = reg === "us" ? genUS(sep) : reg === "uk" ? genUK(sep) : reg === "jp" ? genJP(sep) : genCN(sep);
+  const fmt = props.params.phoneFormat ?? "domestic";
+  return fmt === "international" && reg === "cn" ? `+86${num.replace(/[^0-9]/g, "")}` : num;
+});
+
+function toggleRegion(val: string) {
+  if (!props.params.phoneRegions) props.params.phoneRegions = [];
+  const idx = props.params.phoneRegions.indexOf(val);
+  if (idx >= 0) props.params.phoneRegions.splice(idx, 1);
+  else props.params.phoneRegions.push(val);
+}
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">格式</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="(params.phoneFormat || 'domestic') === 'domestic' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.phoneFormat = 'domestic'">国内</button>
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="params.phoneFormat === 'international' ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.phoneFormat = 'international'">国际</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <input id="phone-sep" type="checkbox" class="h-3.5 w-3.5 accent-primary" :checked="!!params.phoneSeparator" @change="params.phoneSeparator = !params.phoneSeparator" />
+        <Label for="phone-sep" class="text-muted-foreground">包含分隔符</Label>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">地区选择</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button v-for="r in regions" :key="r.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.phoneRegions ?? []).includes(r.value) ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="toggleRegion(r.value)">{{ r.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">{{ t("dataGenerate.preview") }}</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/ProductCategoryParams.vue b/apps/desktop/src/components/generate/params/ProductCategoryParams.vue
new file mode 100644
index 0000000..c1a4ffa
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/ProductCategoryParams.vue
@@ -0,0 +1,66 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const dataMap: Record<string, string[]> = {
+  en: ["Electronics", "Clothing", "Food", "Books", "Home Goods", "Sports", "Toys", "Beauty", "Furniture", "Automotive", "Garden", "Pet Supplies", "Video Games", "Music Instruments", "Office Supplies"],
+  zh: ["电子", "服装", "食品", "图书", "家居", "运动", "玩具", "美妆", "家具", "汽车用品", "园艺", "宠物用品", "视频游戏", "乐器", "办公用品"],
+  zh_hant: ["電子", "服裝", "食品", "圖書", "家居", "運動", "玩具", "美妝", "家具", "汽車用品", "園藝", "寵物用品", "視頻遊戲", "樂器", "辦公用品"],
+  ja: ["電子機器", "衣料品", "食品", "書籍", "家財", "スポーツ", "玩具", "美容", "家具", "自動車用品", "ガーデニング", "ペット用品", "ビデオゲーム", "楽器", "オフィス用品"],
+};
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const lang = props.params.languages?.[0] ?? "en";
+  return pick(dataMap[lang] ?? dataMap["en"]);
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button
+          v-for="l in [
+            { value: 'en', label: 'English' },
+            { value: 'zh', label: '简体中文' },
+            { value: 'zh_hant', label: '繁體中文' },
+            { value: 'ja', label: '日本語' },
+          ]"
+          :key="l.value"
+          type="button"
+          class="px-2 py-1 rounded border text-xs"
+          :class="(params.languages?.[0] || 'en') === l.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'"
+          @click="params.languages = [l.value]"
+        >
+          {{ l.label }}
+        </button>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/ProductNameParams.vue b/apps/desktop/src/components/generate/params/ProductNameParams.vue
new file mode 100644
index 0000000..b39703c
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/ProductNameParams.vue
@@ -0,0 +1,68 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+if (!props.params.productKeywords) {
+  props.params.productKeywords = "Apple\nCherry\nOrange\nMango\nBanana\nLemon\nGrape\nPeach\nPear\nMelon";
+}
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function jumbleWord(word: string): string {
+  const letters = word.split("");
+  for (let i = letters.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [letters[i], letters[j]] = [letters[j], letters[i]];
+  }
+  return letters.join("");
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const keywords = (props.params.productKeywords ?? "")
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  if (keywords.length === 0) return "(无)";
+  const mode = Math.random();
+  if (mode < 0.4) {
+    return pick(keywords);
+  } else if (mode < 0.7) {
+    return `${pick(keywords)} ${pick(keywords)}`;
+  } else {
+    return jumbleWord(pick(keywords).toLowerCase());
+  }
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <Label class="text-xs text-muted-foreground mb-1 block">使用关键字生成</Label>
+      <textarea v-model="params.productKeywords" rows="6" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono resize-y" placeholder="每行一个关键字&#10;Apple&#10;Cherry&#10;Orange" />
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/RegexParams.vue b/apps/desktop/src/components/generate/params/RegexParams.vue
new file mode 100644
index 0000000..e38167d
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/RegexParams.vue
@@ -0,0 +1,62 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const p = props.params.pattern ?? "";
+  if (!p) return "(未设置)";
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  try {
+    const regex = new RegExp("^" + p + "$");
+    let attempt = "";
+    for (let i = 0; i < 100; i++) {
+      const len = p.includes("{") ? parseInt(p.match(/\{(\d+)/)?.[1] ?? "10") : 10;
+      attempt = Array.from({ length: Math.min(len, 50) }, () => chars[Math.floor(Math.random() * chars.length)]).join("");
+      if (regex.test(attempt)) return attempt;
+    }
+    return attempt || "(无法匹配)";
+  } catch {
+    return "(无效正则)";
+  }
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs">
+        <Label class="text-muted-foreground">正则表达式</Label>
+        <Input v-model="params.pattern" type="text" placeholder="[A-Za-z0-9]{10}" class="h-7 text-xs font-mono" />
+      </div>
+      <div class="flex items-center gap-2 text-xs mt-2">
+        <input id="regex-raw" type="checkbox" class="h-3.5 w-3.5 accent-primary" :checked="!!params.rawPattern" @change="params.rawPattern = !params.rawPattern" />
+        <Label for="regex-raw" class="text-muted-foreground">原始数据模式</Label>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm break-all">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto shrink-0" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/RegionParams.vue b/apps/desktop/src/components/generate/params/RegionParams.vue
new file mode 100644
index 0000000..dc9bc13
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/RegionParams.vue
@@ -0,0 +1,118 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const formats = [
+  { value: "name", label: "名称" },
+  { value: "code", label: "代码" },
+  { value: "code_name", label: "代码+名称" },
+];
+
+const textTransforms = [
+  { value: "none", label: "原样" },
+  { value: "upper", label: "全大写" },
+  { value: "lower", label: "全小写" },
+  { value: "title", label: "每个单词首字母大写" },
+];
+
+const regionData = [
+  { code: "US", en: "United States", zh: "美国", zh_hant: "美國", ja: "アメリカ合衆国" },
+  { code: "CN", en: "China", zh: "中国", zh_hant: "中國", ja: "中国" },
+  { code: "JP", en: "Japan", zh: "日本", zh_hant: "日本", ja: "日本" },
+  { code: "GB", en: "United Kingdom", zh: "英国", zh_hant: "英國", ja: "イギリス" },
+  { code: "DE", en: "Germany", zh: "德国", zh_hant: "德國", ja: "ドイツ" },
+  { code: "FR", en: "France", zh: "法国", zh_hant: "法國", ja: "フランス" },
+  { code: "CA", en: "Canada", zh: "加拿大", zh_hant: "加拿大", ja: "カナダ" },
+  { code: "AU", en: "Australia", zh: "澳大利亚", zh_hant: "澳洲", ja: "オーストラリア" },
+  { code: "IN", en: "India", zh: "印度", zh_hant: "印度", ja: "インド" },
+  { code: "BR", en: "Brazil", zh: "巴西", zh_hant: "巴西", ja: "ブラジル" },
+  { code: "RU", en: "Russia", zh: "俄罗斯", zh_hant: "俄羅斯", ja: "ロシア" },
+  { code: "KR", en: "South Korea", zh: "韩国", zh_hant: "韓國", ja: "韓国" },
+  { code: "IT", en: "Italy", zh: "意大利", zh_hant: "意大利", ja: "イタリア" },
+  { code: "ES", en: "Spain", zh: "西班牙", zh_hant: "西班牙", ja: "スペイン" },
+  { code: "MX", en: "Mexico", zh: "墨西哥", zh_hant: "墨西哥", ja: "メキシコ" },
+];
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function transformText(text: string, mode: string): string {
+  if (mode === "upper") return text.toUpperCase();
+  if (mode === "lower") return text.toLowerCase();
+  if (mode === "title") return text.replace(/\w\S*/g, (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase());
+  return text;
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const region = pick(regionData);
+  const lang = props.params.regionLang ?? "en";
+  const fmt = props.params.regionFormat ?? "name";
+  const tf = props.params.textTransform ?? "none";
+  let text = "";
+  if (fmt === "code") text = region.code;
+  else if (fmt === "code_name") text = `${region.code} - ${(region as any)[lang] ?? region.en}`;
+  else text = (region as any)[lang] ?? region.en;
+  return transformText(text, tf);
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">格式</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button v-for="f in formats" :key="f.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.regionFormat || 'name') === f.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.regionFormat = f.value">{{ f.label }}</button>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button
+          v-for="l in [
+            { value: 'en', label: 'English' },
+            { value: 'zh', label: '简体中文' },
+            { value: 'zh_hant', label: '繁體中文' },
+            { value: 'ja', label: '日本語' },
+          ]"
+          :key="l.value"
+          type="button"
+          class="px-2 py-1 rounded border text-xs"
+          :class="(params.regionLang || 'en') === l.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'"
+          @click="params.regionLang = l.value"
+        >
+          {{ l.label }}
+        </button>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">将值转换为</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button v-for="t in textTransforms" :key="t.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.textTransform || 'none') === t.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.textTransform = t.value">
+          {{ t.label }}
+        </button>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/SequenceParams.vue b/apps/desktop/src/components/generate/params/SequenceParams.vue
new file mode 100644
index 0000000..de3fff8
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/SequenceParams.vue
@@ -0,0 +1,65 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const { t } = useI18n();
+
+const previewVal = computed(() => {
+  void previewKey.value;
+  const s = props.params.startValue ?? 1;
+  const inc = props.params.increment ?? 1;
+  return Array.from({ length: 5 }, (_, i) => s + i * inc).join(", ") + ", ...";
+});
+
+const previewKey = ref(0);
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs">
+        <Label class="text-muted-foreground">开始</Label>
+        <Input v-model.number="params.startValue" type="number" placeholder="1" class="h-7 text-xs" />
+      </div>
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs mt-2">
+        <Label class="text-muted-foreground">{{ t("dataGenerate.increment") }}</Label>
+        <Input v-model.number="params.increment" type="number" placeholder="1" class="h-7 text-xs" />
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs">
+        <Label class="text-muted-foreground">{{ t("dataGenerate.min") }}</Label>
+        <Input v-model.number="params.sequenceMin" type="number" placeholder="-" class="h-7 text-xs" />
+      </div>
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs mt-2">
+        <Label class="text-muted-foreground">{{ t("dataGenerate.max") }}</Label>
+        <Input v-model.number="params.sequenceMax" type="number" placeholder="-" class="h-7 text-xs" />
+      </div>
+      <div class="flex items-center gap-2 text-xs mt-2 ml-[88px]">
+        <input id="seq-cycle" type="checkbox" class="h-3.5 w-3.5 accent-primary" :checked="!!params.sequenceCycle" @change="params.sequenceCycle = !params.sequenceCycle" />
+        <Label for="seq-cycle" class="text-muted-foreground">{{ t("dataGenerate.cycle") }}</Label>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">{{ t("dataGenerate.preview") }}</span>
+        <span :key="previewKey" class="font-mono text-sm truncate">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto shrink-0" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/SizeParams.vue b/apps/desktop/src/components/generate/params/SizeParams.vue
new file mode 100644
index 0000000..3ab757c
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/SizeParams.vue
@@ -0,0 +1,66 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const dataMap: Record<string, string[]> = {
+  en: ["XS", "S", "M", "L", "XL", "XXL", "XXXL", "One Size"],
+  zh: ["特小", "小", "中", "大", "加大", "特大", "超特大", "均码"],
+  zh_hant: ["特小", "小", "中", "大", "加大", "特大", "超特大", "均碼"],
+  ja: ["XS", "S", "M", "L", "XL", "XXL", "XXXL", "フリーサイズ"],
+};
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const lang = props.params.languages?.[0] ?? "en";
+  return pick(dataMap[lang] ?? dataMap["en"]);
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言</div>
+      <div class="flex flex-wrap gap-1.5">
+        <button
+          v-for="l in [
+            { value: 'en', label: 'English' },
+            { value: 'zh', label: '简体中文' },
+            { value: 'zh_hant', label: '繁體中文' },
+            { value: 'ja', label: '日本語' },
+          ]"
+          :key="l.value"
+          type="button"
+          class="px-2 py-1 rounded border text-xs"
+          :class="(params.languages?.[0] || 'en') === l.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'"
+          @click="params.languages = [l.value]"
+        >
+          {{ l.label }}
+        </button>
+      </div>
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/SkuParams.vue b/apps/desktop/src/components/generate/params/SkuParams.vue
new file mode 100644
index 0000000..c8400b3
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/SkuParams.vue
@@ -0,0 +1,89 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+if (!props.params.pattern) {
+  props.params.pattern = "([A-F]{2}[-]){2}([0-9]{4}[-])([A-Z])";
+}
+
+function randFromCharSet(charSet: string, n: number): string {
+  return Array.from({ length: n }, () => charSet.charAt(Math.floor(Math.random() * charSet.length))).join("");
+}
+
+function literalFromPattern(pattern: string): string {
+  const letterCharSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const digitCharSet = "0123456789";
+  let result = "";
+  const tokens = pattern.split(/([{}[\]-])/).filter(Boolean);
+  let i = 0;
+  while (i < tokens.length) {
+    const t = tokens[i];
+    if (t === "(" || t === ")") {
+      i++;
+      continue;
+    }
+    if (t === "[") {
+      const charSetToken = tokens[i + 1];
+      i += 2;
+      let charSet = "";
+      if (charSetToken?.includes("A-F") || charSetToken?.includes("A-Z")) charSet = letterCharSet;
+      else if (charSetToken?.includes("0-9")) charSet = digitCharSet;
+      else charSet = letterCharSet + digitCharSet;
+      i++;
+      let count = 1;
+      if (tokens[i] === "{") {
+        i++;
+        count = parseInt(tokens[i], 10) || 1;
+        i += 2;
+      }
+      result += randFromCharSet(charSet, count);
+      continue;
+    }
+    if (t === "-") {
+      result += "-";
+      i++;
+      continue;
+    }
+    i++;
+  }
+  if (!result) {
+    return `${randFromCharSet("ABCDEF", 2)}-${randFromCharSet("ABCDEF", 2)}-${randFromCharSet("0123456789", 4)}-${randFromCharSet("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 1)}`;
+  }
+  return result;
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  return literalFromPattern(props.params.pattern ?? "");
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <Label class="text-xs text-muted-foreground mb-1 block">正则表达式</Label>
+      <input v-model="params.pattern" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono" placeholder="([A-F]{2}[-]){2}([0-9]{4}[-])([A-Z])" />
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/SocialIdParams.vue b/apps/desktop/src/components/generate/params/SocialIdParams.vue
new file mode 100644
index 0000000..f8a26f4
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/SocialIdParams.vue
@@ -0,0 +1,39 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const chars = "abcdefghijklmnopqrstuvwxyz0123456789_";
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const len = Math.floor(Math.random() * 10) + 4;
+  const name = Array.from({ length: len }, () => chars[Math.floor(Math.random() * chars.length)]).join("");
+  return name;
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm break-all">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto shrink-0" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/TextParams.vue b/apps/desktop/src/components/generate/params/TextParams.vue
new file mode 100644
index 0000000..6a463e0
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/TextParams.vue
@@ -0,0 +1,55 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const lorem =
+  "Lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua Ut enim ad minim veniam quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur Excepteur sint occaecat cupidatat non proident sunt in culpa qui officia deserunt mollit anim id est laborum";
+
+const previewVal = computed(() => {
+  void previewKey.value;
+  const min = props.params.minLength ?? 50;
+  const max = props.params.maxLength ?? 500;
+  const len = Math.floor(Math.random() * (max - min + 1)) + min;
+  let txt = "";
+  while (txt.length < len) {
+    txt += lorem + " ";
+  }
+  return txt.slice(0, len);
+});
+
+const previewKey = ref(0);
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="grid grid-cols-[80px_1fr] items-center gap-2 text-xs">
+        <Label class="text-muted-foreground">字符数</Label>
+        <div class="flex items-center gap-2">
+          <Input v-model.number="params.minLength" type="number" min="1" placeholder="50" class="h-7 w-20 text-xs" />
+          <span class="text-muted-foreground">-</span>
+          <Input v-model.number="params.maxLength" type="number" min="1" placeholder="500" class="h-7 w-20 text-xs" />
+        </div>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-start gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0 mt-0.5">预览</span>
+        <p :key="previewKey" class="font-mono text-xs leading-relaxed break-all">{{ previewVal }}</p>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto shrink-0 mt-0.5" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/TimeParams.vue b/apps/desktop/src/components/generate/params/TimeParams.vue
new file mode 100644
index 0000000..8834da3
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/TimeParams.vue
@@ -0,0 +1,77 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const { t } = useI18n();
+
+const previewVal = computed(() => {
+  void previewKey.value;
+  let sh = 0,
+    sm = 23;
+  if (!props.params.allDay) {
+    sh = parseInt(props.params.startTime ?? "00") || 0;
+    sm = parseInt(props.params.endTime ?? "23") || 23;
+  }
+  const h = Math.floor(Math.random() * (sm - sh + 1)) + sh;
+  const m = Math.floor(Math.random() * 60);
+  const s = Math.floor(Math.random() * 60);
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${pad(h)}:${pad(m)}:${pad(s)}`;
+});
+
+const previewKey = ref(0);
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3 space-y-2">
+      <div class="flex items-center gap-2 text-xs">
+        <input id="tm-all-day" type="checkbox" class="h-3.5 w-3.5 accent-primary" :checked="!!params.allDay" @change="params.allDay = !params.allDay" />
+        <Label for="tm-all-day" class="text-muted-foreground">{{ t("dataGenerate.allDay") }}</Label>
+      </div>
+      <div v-if="!params.allDay" class="flex items-center gap-2 text-xs ml-5">
+        <Label class="text-muted-foreground shrink-0">{{ t("dataGenerate.startTime") }}</Label>
+        <input
+          :value="params.startTime ?? ''"
+          @change="
+            (e: Event) => {
+              (params as Record<string, unknown>).startTime = (e.target as HTMLInputElement).value;
+            }
+          "
+          type="time"
+          class="h-7 w-24 min-w-0 rounded-[6px] border bg-transparent px-2.5 py-1 text-xs outline-none transition-colors dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-3"
+        />
+        <Label class="text-muted-foreground shrink-0">{{ t("dataGenerate.endTime") }}</Label>
+        <input
+          :value="params.endTime ?? ''"
+          @change="
+            (e: Event) => {
+              (params as Record<string, unknown>).endTime = (e.target as HTMLInputElement).value;
+            }
+          "
+          type="time"
+          class="h-7 w-24 min-w-0 rounded-[6px] border bg-transparent px-2.5 py-1 text-xs outline-none transition-colors dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-3"
+        />
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">{{ t("dataGenerate.preview") }}</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/TitleParams.vue b/apps/desktop/src/components/generate/params/TitleParams.vue
new file mode 100644
index 0000000..05b7018
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/TitleParams.vue
@@ -0,0 +1,64 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+const languages = [
+  { value: "en", label: "English" },
+  { value: "zh", label: "简体中文" },
+  { value: "zh_hant", label: "繁体中文" },
+  { value: "ja", label: "日本語" },
+];
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const lang = props.params.languages?.[0] ?? "en";
+  const map: Record<string, string[]> = {
+    en: ["Mr.", "Mrs.", "Miss", "Ms.", "Dr.", "Prof."],
+    zh: ["先生", "女士", "小姐", "博士", "教授"],
+    zh_hant: ["先生", "女士", "小姐", "博士", "教授"],
+    ja: ["様", "殿", "先生", "博士"],
+  };
+  return pick(map[lang] ?? map["en"]);
+});
+
+function setLang(val: string) {
+  props.params.languages = [val];
+}
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">语言选择</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button v-for="l in languages" :key="l.value" type="button" class="px-2 py-1 rounded border text-xs" :class="(params.languages?.[0] || 'en') === l.value ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="setLang(l.value)">{{ l.label }}</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/UrlParams.vue b/apps/desktop/src/components/generate/params/UrlParams.vue
new file mode 100644
index 0000000..e154c9d
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/UrlParams.vue
@@ -0,0 +1,70 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+if (!props.params.urlSubdomains) {
+  props.params.urlSubdomains = "auth.\ndrive.\nimage.\nwww.\napi.\nmail.\nshop.\nblog.";
+}
+if (!props.params.urlTlds) {
+  props.params.urlTlds = ".biz\n.co.jp\n.com\n.cn\n.org\n.net\n.io\n.dev\n.xyz";
+}
+
+const baseDomains = ["example", "test", "demo", "sample", "meyer80", "acme", "contoso", "fabrikam"];
+const paths = ["ToysGames", "home", "about", "products", "login", "dashboard", "items", "search", "profile", "settings"];
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function splitLines(text: string): string[] {
+  return text
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const subs = splitLines(props.params.urlSubdomains ?? "");
+  const tlds = splitLines(props.params.urlTlds ?? "");
+  const sub = subs.length ? pick(subs) : "www.";
+  const tld = tlds.length ? pick(tlds) : ".com";
+  const base = pick(baseDomains);
+  const path = pick(paths);
+  return `https://${sub}${base}${tld}/${path}`;
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <Label class="text-xs text-muted-foreground mb-1 block">子域</Label>
+      <textarea v-model="params.urlSubdomains" rows="4" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono resize-y" placeholder="每行一个子域&#10;auth.&#10;www.&#10;api." />
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <Label class="text-xs text-muted-foreground mb-1 block">顶级域</Label>
+      <textarea v-model="params.urlTlds" rows="4" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono resize-y" placeholder="每行一个TLD&#10;.com&#10;.cn&#10;.io" />
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm break-all">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/UuidParams.vue b/apps/desktop/src/components/generate/params/UuidParams.vue
new file mode 100644
index 0000000..1ddd354
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/UuidParams.vue
@@ -0,0 +1,57 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+function genUuid(hyphens: boolean): string {
+  const hex = "0123456789abcdef";
+  const parts = [8, 4, 4, 4, 12];
+  const uuid = parts.map((len) => {
+    let s = "";
+    for (let i = 0; i < len; i++) s += hex[Math.floor(Math.random() * 16)];
+    return s;
+  });
+  return hyphens ? uuid.join("-") : uuid.join("");
+}
+
+const previewVal = computed(() => {
+  void previewKey.value;
+  return genUuid(props.params.uuidHyphens !== false);
+});
+const regex = computed(() => (props.params.uuidHyphens !== false ? "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$" : "^[0-9a-f]{32}$"));
+
+const previewKey = ref(0);
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-2">UUID格式</div>
+      <div class="flex items-center gap-2 text-xs">
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="params.uuidHyphens !== false ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.uuidHyphens = true">包含连字符</button>
+        <button type="button" class="px-2 py-1 rounded border text-xs" :class="params.uuidHyphens === false ? 'bg-primary text-primary-foreground border-primary' : 'bg-background'" @click="params.uuidHyphens = false">无格式</button>
+      </div>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="text-xs text-muted-foreground mb-1">正则表达式</div>
+      <code class="block text-xs font-mono bg-background rounded px-2 py-1 break-all">{{ regex }}</code>
+    </div>
+
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm break-all">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto shrink-0" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/generate/params/WeightUnitParams.vue b/apps/desktop/src/components/generate/params/WeightUnitParams.vue
new file mode 100644
index 0000000..235f2e6
--- /dev/null
+++ b/apps/desktop/src/components/generate/params/WeightUnitParams.vue
@@ -0,0 +1,52 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { RefreshCw } from "@lucide/vue";
+import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";
+import CommonOptions from "./CommonOptions.vue";
+
+const props = defineProps<{ params: GeneratorParams }>();
+
+if (!props.params.values) {
+  props.params.values = "g\nkg\nlb\noz\nt\nmg\nct";
+}
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+const previewKey = ref(0);
+const previewVal = computed(() => {
+  void previewKey.value;
+  const vals = (props.params.values ?? "")
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  if (vals.length === 0) return "(无)";
+  return pick(vals);
+});
+
+function refresh() {
+  previewKey.value++;
+}
+</script>
+
+<template>
+  <div class="space-y-3">
+    <div class="rounded-md border bg-muted/10 p-3">
+      <Label class="text-xs text-muted-foreground mb-1 block">值</Label>
+      <textarea v-model="params.values" rows="5" class="w-full rounded border bg-background px-2 py-1 text-xs font-mono resize-y" placeholder="每行一个单位&#10;g&#10;kg&#10;lb" />
+    </div>
+    <div class="rounded-md border bg-muted/10 p-3">
+      <div class="flex items-center gap-2 text-xs">
+        <span class="text-muted-foreground shrink-0">预览</span>
+        <span :key="previewKey" class="font-mono text-sm">{{ previewVal }}</span>
+        <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="refresh">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </div>
+    </div>
+    <CommonOptions :params="params" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/grid/DataGrid.vue b/apps/desktop/src/components/grid/DataGrid.vue
new file mode 100644
index 0000000..000af2d
--- /dev/null
+++ b/apps/desktop/src/components/grid/DataGrid.vue
@@ -0,0 +1,12182 @@
+<script lang="ts">
+type CachedStructuredFilterRule = {
+  id: string;
+  columnName: string;
+  mode: "equals" | "not-equals" | "is-null" | "is-not-null" | "like" | "not-like" | "less-than" | "greater-than";
+  rawValue: string;
+  conjunction: "AND" | "OR";
+  disabled?: boolean;
+};
+type StructuredFilterCacheState = {
+  scopeKey: string;
+  manualWhereInput: string;
+  rules: CachedStructuredFilterRule[];
+  appliedWhereInput: string;
+};
+const structuredFilterStateCache = new Map<string, StructuredFilterCacheState>();
+</script>
+
+<script setup lang="ts">
+import { computed, nextTick, onMounted, onUnmounted, onActivated, onDeactivated, ref, shallowRef, useSlots, watch, defineAsyncComponent, type Component, type CSSProperties } from "vue";
+import { useI18n } from "vue-i18n";
+import {
+  ArrowUp,
+  ArrowDown,
+  ArrowUpDown,
+  Upload,
+  Plus,
+  Trash2,
+  Save,
+  ChevronDown,
+  ChevronLeft,
+  ChevronRight,
+  ChevronsLeft,
+  ChevronsRight,
+  Search,
+  Inbox,
+  SearchX,
+  Code2,
+  Copy,
+  Eye,
+  EyeOff,
+  Loader2,
+  X,
+  Undo2,
+  WrapText,
+  Info,
+  Rows3,
+  RefreshCcw,
+  RotateCcw,
+  Pencil,
+  Filter,
+  SquareDashed,
+  Check,
+  CopyPlus,
+  KeyRound,
+  Link2,
+  ListTree,
+  Maximize2,
+  PanelBottom,
+  PanelRight,
+  TableProperties,
+  Database,
+  Columns3,
+  Columns3Cog,
+  Timer,
+} from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import QueryLoadingState from "@/components/common/QueryLoadingState.vue";
+import CustomContextMenu, { type ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { Input } from "@/components/ui/input";
+import LightTooltip from "@/components/ui/LightTooltip.vue";
+import LightDropdown from "@/components/ui/LightDropdown.vue";
+import LightDropdownMenu from "@/components/ui/LightDropdownMenu.vue";
+import { Popover, PopoverAnchor, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import ErrorBanner from "@/components/ui/ErrorBanner.vue";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import ImagePreviewDialog from "@/components/grid/ImagePreviewDialog.vue";
+import TemporalCellEditor from "@/components/grid/TemporalCellEditor.vue";
+import EnumCellEditor from "@/components/grid/EnumCellEditor.vue";
+import type { QueryResult, ColumnInfo, DatabaseType, ForeignKeyInfo, IndexInfo, TriggerInfo, TableInfoTab } from "@/types/database";
+import * as api from "@/lib/backend/api";
+import { formatElapsedSeconds } from "@/lib/common/elapsedTime";
+import { dataGridCellDisplayText, dataGridCellEditorText } from "@/lib/dataGrid/dataGridCellCoercion";
+import { createColumnDrafts } from "@/lib/table/tableStructureEditorState";
+import type { BuildSingleColumnAlterSqlOptions } from "@/lib/table/tableStructureEditorSql";
+import { buildTableSelectSql, quoteTableIdentifier } from "@/lib/table/tableSelectSql";
+import { uuid } from "@/lib/common/utils";
+import { compactHeaderColumnType, resolveHeaderColumnType } from "@/lib/dataGrid/dataGridColumnType";
+import {
+  canDeleteExistingTdengineRows,
+  canEditExistingTableRows,
+  canInsertTableRows,
+  canUseKeylessRowPredicate,
+  hasCompleteTdengineRowIdentity,
+  hiveTablePropertiesIndicateTransactional,
+  isClickHouseExistingRowReadonlyColumn,
+  isHiddenGridColumn,
+  isTdengineExistingRowReadonlyColumn,
+  usesSyntheticRowIdKey,
+} from "@/lib/table/tableEditing";
+import { buildDataGridColumnDistinctValuesSql, buildDataGridContextFilterCondition, buildDataGridCountSql, buildHiveTablePropertiesSql, type DataGridContextFilterMode } from "@/lib/dataGrid/dataGridSql";
+import {
+  buildVisibleTransposeRows,
+  averageTransposeRecordWidth,
+  calculateTransposeRecordWidth,
+  defaultTransposeRecordWidth,
+  minTransposeFieldWidth,
+  minTransposeRecordWidth,
+  nextAppendedTransposeState,
+  nextContextTransposeState,
+  nextKeyboardTransposeState,
+  nextTransposeState,
+  nextTransposeStateForRecordCount,
+  transposeRecordIndexesForMode,
+  transposeRecordWidthsForDensity,
+  transposeFieldWidth,
+  transposeScrollLeftForRecord,
+  visibleTransposeRecordWindow,
+} from "@/lib/dataGrid/dataGridTranspose";
+import { canApplyGridSelectionValue, canDeleteGridRowItem, canEditGridCellDetail, matchesRowStatusFilter, shouldShowQuickEntryDraftRow, type RowStatus, type RowStatusFilter } from "@/lib/dataGrid/gridRowStatus";
+import { displayCellValue, firstLineCellDisplayValue, type CellValue } from "@/lib/dataGrid/cellValue";
+import { getApplicablePreviewActions } from "@/lib/dataGrid/resultPreviewRegistry";
+import "@/lib/dataGrid/geometryMapPreview";
+import { BINARY_CELL_DOWNLOAD_MODES, binaryCellDisplayText, binaryCellDownloadFileName, binaryCellDownloadPayload, canDownloadBinaryCellValue, downloadBinaryCellPayload, isBinaryCellColumnType, parseBinaryCellBytes, type BinaryCellDownloadMode } from "@/lib/dataGrid/binaryCellDownload";
+import { buildBinaryHexViewRows } from "@/lib/dataGrid/binaryHexViewer";
+import { canFormatCellDetailJson, cellDetailEditorText, compactJsonText, defaultCellDetailTab, formatJsonText, isGeometryColumnType, linkedCellDetailTarget, looksLikeJsonContainerText, valueEditorActions, visibleCellDetailTabs, type CellDetailTab } from "@/lib/dataGrid/cellDetailPresentation";
+import { renderWktOnCanvas, isHexGeometry } from "@/lib/dataGrid/geometryPreview";
+import {
+  buildDataGridCellDetail,
+  buildDataGridColumnDetail,
+  buildDataGridRowDetail,
+  CELL_DETAIL_VALUE_PREVIEW_MAX_LENGTH,
+  dataGridColumnDetailJson,
+  dataGridColumnDetailTsv,
+  dataGridRowDetailJson,
+  dataGridRowDetailTsv,
+  filterDataGridDetailFields,
+  type DataGridCellDetail,
+} from "@/lib/dataGrid/dataGridDetail";
+import { applyColumnFormatter, buildColumnFormatterKey, normalizeColumnFormatter, resolveColumnFormatter, type ColumnFormatterConfig, type DateTimeFormatterUnit, DateTimePatterns } from "@/lib/dataGrid/columnFormatter";
+import { temporalCellEditorConfig, type TemporalCellEditorConfig } from "@/lib/dataGrid/dataGridTemporalEditor";
+import { isCancelSearchShortcut, isCopyCurrentRowShortcut, isDeleteCurrentRowShortcut, isFocusSearchShortcut, isModRShortcut, isSaveShortcut, isToggleTransposeShortcut } from "@/lib/editor/keyboardShortcuts";
+import { dataGridHeaderContentWidth, scrollbarGutterWidth } from "@/lib/dataGrid/dataGridScrollGutter";
+import { canGoNextDataGridPage } from "@/lib/dataGrid/dataGridPagination";
+import { dataGridBottomScrollTop, dataGridScrollPosition, isDataGridAtScrollBottom, isDataGridNearScrollBottom, shouldCheckInfiniteScrollAfterScroll, type DataGridScrollPosition } from "@/lib/dataGrid/dataGridInfiniteScroll";
+import { CANVAS_DATA_GRID_ROW_HEIGHT, drawCanvasDataGrid } from "@/lib/dataGrid/canvasDataGridRenderer";
+import { dataGridSaveActionMode, dataGridSaveToolbarState } from "@/lib/dataGrid/dataGridSaveUi";
+import type { QueryEditabilityReason } from "@/lib/sql/sqlAnalysis";
+import { EDITOR_FONT_FAMILY_CSS_VAR } from "@/lib/editor/editorThemes";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+import { appendColumnValueFilterCondition, buildColumnValueFilterCondition, buildColumnValuesFilterCondition, combineWhereInputs, filterModeNeedsValue, parseFilterValue } from "@/lib/dataGrid/dataGridColumnFilter";
+import { clampSearchSplitWidth } from "@/lib/dataGrid/dataGridSearchSplit";
+import { MAX_RESULT_PAGE_SIZE, MIN_RESULT_PAGE_SIZE, normalizeResultPageSize, resultPageSizeMenuOptions } from "@/lib/dataGrid/paginationPageSize";
+import { allNullColumnIndexes, filterColumnVisibilityOptions, hiddenColumnIndexesWithAllNullColumns, invertedHiddenColumnIndexes, nextHiddenColumnIndexes, removeAutoHiddenColumnIndexes, visibleColumnIndexesForFilter } from "@/lib/dataGrid/dataGridColumnVisibility";
+import { buildDataGridColumnLookupItems, filterDataGridColumnLookupItems } from "@/lib/dataGrid/dataGridColumnLookup";
+import { columnOrderKeysForIndexes, isDefaultColumnOrder, moveVisibleColumnIndex, orderedColumnIndexes, uniqueDataGridColumnOrderKeys } from "@/lib/dataGrid/dataGridColumnOrder";
+import {
+  dataGridColumnLayoutScopeKey,
+  loadDataGridColumnOrder,
+  loadTableDataGridColumnOrder,
+  notifyTableDataGridColumnOrderChanged,
+  removeDataGridColumnOrder,
+  removeTableDataGridColumnOrder,
+  saveDataGridColumnOrder,
+  saveTableDataGridColumnOrder,
+  TABLE_DATA_GRID_COLUMN_ORDER_CHANGED_EVENT,
+  tableDataGridColumnOrderScopeKey,
+  type TableDataGridColumnOrderChangedDetail,
+} from "@/lib/dataGrid/dataGridColumnLayoutStorage";
+import { parseClipboardTable, summarizeSelection } from "@/lib/dataGrid/gridSelection";
+import { columnHeaderCanvasPointerDisabled, columnHeaderClickShouldBeSuppressed, columnHeaderPreviewOffsetForColumn, columnHeaderTooltipDisabled } from "@/lib/dataGrid/dataGridColumnHeaderInteraction";
+
+import { useToast } from "@/composables/useToast";
+import { useDataGridExport } from "@/composables/useDataGridExport";
+import { eventTargetAllowsNativeClipboard, isPlainClipboardShortcut, readTextFromClipboard } from "@/lib/common/clipboard";
+import ExportProgressDialog from "@/components/export/ExportProgressDialog.vue";
+import { DATA_GRID_ROW_NUM_WIDTH, useDataGridColumnResize } from "@/composables/useDataGridColumnResize";
+import { useDataGridSelection } from "@/composables/useDataGridSelection";
+import { useDataGridEditor } from "@/composables/useDataGridEditor";
+import { useSqlHighlighter } from "@/composables/useSqlHighlighter";
+import { useCellDetailEditor, type UseCellDetailEditorReturn } from "@/composables/useCellDetailEditor";
+import { useTheme } from "@/composables/useTheme";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import type { DataGridSortDirection, DataGridSortMode } from "@/lib/dataGrid/dataGridSort";
+import { DATA_GRID_COMPACT_TOPBAR_WIDTH, type DataGridReloadIntent } from "@/lib/dataGrid/dataGridToolbar";
+import { getTableMetadataCapabilities } from "@/lib/table/tableMetadataCapabilities";
+import { getTableStructureCapabilities } from "@/lib/table/tableStructureCapabilities";
+import { supportsTableStructureEditing } from "@/lib/database/databaseCapabilities";
+import { forgetDataGridConditionHistory, loadDataGridConditionHistory, rememberDataGridConditionHistory } from "@/lib/dataGrid/dataGridConditionHistory";
+import { getDataGridConditionSuggestionPosition } from "@/lib/dataGrid/dataGridConditionSuggestionPosition";
+import { caretPositionInsideInsertedSqlSingleQuotes, insertedSqlSingleQuoteAtCaret } from "@/lib/sql/sqlQuoteCaret";
+import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import { isMacOS } from "@/lib/backend/platform";
+import { appendDebugLog, isDebugLoggingEnabled } from "@/lib/backend/debugLog";
+import { formatShortcut } from "@/lib/editor/shortcutRegistry";
+import { SearchableSelect } from "@/components/ui/searchable-select";
+
+const SqlPreviewPanel = defineAsyncComponent(() => import("@/components/editor/SqlPreviewPanel.vue"));
+const FORMATTED_JSON_EDIT_WARNING_COUNT_STORAGE_KEY = "dbx-cell-detail-formatted-json-edit-warning-count";
+const FORMATTED_JSON_EDIT_WARNING_MAX_COUNT = 3;
+
+const { t } = useI18n();
+const slots = useSlots();
+const connectionStore = useConnectionStore();
+const queryStore = useQueryStore();
+const settingsStore = useSettingsStore();
+const tableFontSize = computed(() => settingsStore.editorSettings.tableFontSize);
+const { isDark, themePalette } = useTheme();
+const { toast } = useToast();
+const { highlight } = useSqlHighlighter();
+const binaryCellDownloadMenuItems = computed(() =>
+  BINARY_CELL_DOWNLOAD_MODES.map((mode) => ({
+    label: t(`grid.binaryDownload.${mode}`),
+    value: mode,
+  })),
+);
+
+interface PreparedCopyValue {
+  key: string;
+  text: string;
+  loading: boolean;
+  ready: boolean;
+}
+
+type ConditionSuggestion = {
+  value: string;
+  kind: "column" | "history";
+};
+
+type SortMenuValue = "local-asc" | "local-desc" | "database-asc" | "database-desc" | "clear";
+
+interface DataGridProps {
+  result: QueryResult;
+  sql?: string;
+  editable?: boolean;
+  databaseType?: DatabaseType;
+  connectionId?: string;
+  database?: string;
+  executionDatabase?: string;
+  schema?: string;
+  context?: "results" | "table-data";
+  sourceColumns?: Array<string | undefined>;
+  initialWhereInput?: string;
+  initialOrderByInput?: string;
+  sortColumn?: string;
+  sortColumnIndex?: number;
+  sortDirection?: DataGridSortDirection;
+  sortMode?: DataGridSortMode;
+  tableMeta?: {
+    catalog?: string;
+    schema?: string;
+    tableName: string;
+    tableType?: string;
+    columns: ColumnInfo[];
+    primaryKeys: string[];
+  };
+  tableInfoTab?: TableInfoTab;
+  pageOffset?: number;
+  pageLimit?: number;
+  countSql?: string;
+  totalRowCount?: number;
+  totalRowCountLoading?: boolean;
+  loading?: boolean;
+  cacheKey?: string;
+  onExecuteSql?: (sql: string) => Promise<void>;
+  fullExportResult?: (onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void) => Promise<QueryResult | undefined>;
+  queryResultExportRequest?: (options: { exportId: string; filePath: string; format: "csv" | "xlsx" }) => Promise<api.QueryResultExportRequest | undefined>;
+  allExportResults?: Array<{ sheetName: string; result: QueryResult }>;
+  exportFileBaseName?: string;
+  customSaveHandler?: import("@/composables/useDataGridEditor").CustomSaveHandler;
+  queryEditabilityReason?: QueryEditabilityReason;
+  allowInsertRows?: boolean;
+  allowDeleteRows?: boolean;
+}
+
+const props = withDefaults(defineProps<DataGridProps>(), {
+  // Vue casts absent Boolean props to false unless the default is explicitly
+  // undefined; omitted row-action limits must keep normal table-data editing.
+  allowInsertRows: undefined,
+  allowDeleteRows: undefined,
+});
+
+const dataGridTraceId = uuid().slice(0, 8);
+const dataGridCreatedAt = performance.now();
+const dataGridElapsed = () => `${Math.round(performance.now() - dataGridCreatedAt)}ms`;
+const isMac = isMacOS();
+const shortcutMod = isMac ? "Cmd" : "Ctrl";
+const saveShortcutLabel = computed(() => formatShortcut(settingsStore.editorSettings.shortcuts.saveSql));
+const AUTO_REFRESH_INTERVAL_OPTIONS = [5, 10, 30, 60, 300];
+
+function logDataGridTiming(message: string, payload?: Record<string, unknown>) {
+  appendDebugLog("info", message, payload);
+}
+
+const emit = defineEmits<{
+  reload: [sql?: string, searchText?: string, whereInput?: string, orderBy?: string, limit?: number, offset?: number, intent?: DataGridReloadIntent];
+  paginate: [offset: number, limit: number, whereInput?: string, orderBy?: string];
+  sort: [column: string, columnIndex: number, direction: "asc" | "desc" | null, whereInput?: string, mode?: DataGridSortMode];
+  "update:whereInput": [value: string];
+  "update:orderByInput": [value: string];
+}>();
+
+const autoRefreshIntervalSeconds = ref(10);
+const autoRefreshEnabled = ref(false);
+let autoRefreshTimer: ReturnType<typeof setInterval> | undefined;
+const autoRefreshLabel = computed(() => (autoRefreshEnabled.value ? t("tabs.autoRefreshEvery", { seconds: autoRefreshIntervalSeconds.value }) : t("tabs.autoRefresh")));
+
+if (isDebugLoggingEnabled()) {
+  logDataGridTiming("[DBX][DataGrid:setup]", {
+    traceId: dataGridTraceId,
+    cacheKey: props.cacheKey,
+    rowCount: props.result.rows.length,
+    columnCount: props.result.columns.length,
+    backendMs: props.result.execution_time_ms,
+    loading: props.loading,
+  });
+}
+
+const transposeRowIndex = ref<number | null>(null);
+const showTranspose = ref(false);
+const multiRowTranspose = ref(false);
+const preserveTransposeOnNextResult = ref(false);
+
+watch(
+  () => props.result,
+  (result) => {
+    if (!isDebugLoggingEnabled()) return;
+    const startedAt = performance.now();
+    logDataGridTiming("[DBX][DataGrid:result:prop]", {
+      traceId: dataGridTraceId,
+      cacheKey: props.cacheKey,
+      rowCount: result.rows.length,
+      columnCount: result.columns.length,
+      backendMs: result.execution_time_ms,
+      loading: props.loading,
+      elapsedSinceSetup: dataGridElapsed(),
+    });
+
+    nextTick(() => {
+      logDataGridTiming("[DBX][DataGrid:result:nextTick]", {
+        traceId: dataGridTraceId,
+        cacheKey: props.cacheKey,
+        elapsed: `${Math.round(performance.now() - startedAt)}ms`,
+        loading: props.loading,
+      });
+      requestAnimationFrame(() => {
+        logDataGridTiming("[DBX][DataGrid:result:first-frame]", {
+          traceId: dataGridTraceId,
+          cacheKey: props.cacheKey,
+          elapsed: `${Math.round(performance.now() - startedAt)}ms`,
+          loading: props.loading,
+        });
+      });
+    });
+  },
+  { immediate: true },
+);
+
+const hasData = computed(() => props.result.columns.length > 0);
+
+const columnTypeMap = computed(() => {
+  const map = new Map<string, string>();
+  if (props.tableMeta?.columns) {
+    for (const col of props.tableMeta.columns) {
+      const typeName = shortTypeName(col.data_type);
+      // Add precision for numeric/decimal types
+      if (col.numeric_precision != null && ["numeric", "decimal"].includes(col.data_type.toLowerCase())) {
+        const scale = col.numeric_scale ?? 0;
+        map.set(col.name, `${typeName}(${col.numeric_precision},${scale})`);
+      } else {
+        map.set(col.name, typeName);
+      }
+    }
+  }
+  return map;
+});
+const resolvedConnectionConfig = computed(() => connectionStore.getConfig(props.connectionId ?? ""));
+const resolvedDatabaseType = computed(() => props.databaseType ?? effectiveDatabaseTypeForConnection(resolvedConnectionConfig.value));
+const tableStructureCapabilities = computed(() => getTableStructureCapabilities(resolvedDatabaseType.value, resolvedConnectionConfig.value?.db_type));
+
+const columnCommentMap = computed(() => {
+  const map = new Map<string, string>();
+  if (props.tableMeta?.columns) {
+    for (const col of props.tableMeta.columns) {
+      if (col.comment) map.set(col.name, col.comment);
+    }
+    for (const col of props.tableMeta.columns) {
+      if (!col.comment) continue;
+      const normalizedName = col.name.toLowerCase();
+      if (!map.has(normalizedName)) map.set(normalizedName, col.comment);
+    }
+  }
+  return map;
+});
+const dataGridTopbarWidth = ref(0);
+const showColumnCommentsInHeader = computed(() => settingsStore.editorSettings.showColumnCommentsInHeader);
+const showColumnTypesInHeader = computed(() => settingsStore.editorSettings.showColumnTypesInHeader);
+const compactColumnHeaderActions = computed(() => settingsStore.editorSettings.compactColumnHeaderActions);
+const dataGridRenderMode = computed(() => settingsStore.editorSettings.dataGridRenderMode);
+const dataGridSearchMode = computed(() => settingsStore.editorSettings.dataGridSearchMode);
+const compactDataGridToolbar = computed(() => dataGridTopbarWidth.value > 0 && dataGridTopbarWidth.value < DATA_GRID_COMPACT_TOPBAR_WIDTH);
+const infiniteScrollEnabled = computed(() => settingsStore.editorSettings.infiniteScroll);
+const infiniteScrollMaxRows = computed(() => settingsStore.editorSettings.infiniteScrollMaxRows);
+const expandedCellEditor = ref<{ rowId: number; col: number } | null>(null);
+
+function headerColumnComment(column: string): string {
+  if (!showColumnCommentsInHeader.value) return "";
+  return columnCommentMap.value.get(column) || "";
+}
+
+function headerColumnType(column: string, actualColIdx: number): string {
+  if (!showColumnTypesInHeader.value) return "";
+  const resolved = resolveHeaderColumnType({
+    tableColumnType: columnTypeMap.value.get(column),
+    resultColumnTypes: props.result.column_types,
+    actualColIdx,
+  });
+  return resolved ? shortTypeName(compactHeaderColumnType(resolved)) : "";
+}
+
+function shortTypeName(t: string): string {
+  const s = t.toLowerCase();
+  if (s === "character varying") return "varchar";
+  if (s === "character") return "char";
+  if (s === "double precision") return "double";
+  if (s === "timestamp without time zone") return "timestamp";
+  if (s === "timestamp with time zone") return "timestamptz";
+  if (s === "time without time zone") return "time";
+  if (s === "time with time zone") return "timetz";
+  if (s === "boolean") return "bool";
+  if (s === "integer") return "int";
+  if (s === "smallint") return "int2";
+  if (s === "real") return "float4";
+  return t;
+}
+
+function headerColumnSortable(actualColIdx: number): boolean {
+  const resolved = props.result.column_sortables?.[actualColIdx];
+  return resolved !== undefined ? resolved : true;
+}
+
+function columnIsSorted(column: string, columnIndex: number): boolean {
+  return sortCol.value === column && sortColIndex.value === columnIndex;
+}
+
+function sortMenuItems(column: string, columnIndex: number) {
+  return [
+    {
+      label: t("grid.sortDatabaseAscending"),
+      value: "database-asc",
+      icon: Database,
+      checked: columnIsSorted(column, columnIndex) && sortDir.value === "asc" && sortMode.value === "database",
+    },
+    {
+      label: t("grid.sortDatabaseDescending"),
+      value: "database-desc",
+      icon: Database,
+      checked: columnIsSorted(column, columnIndex) && sortDir.value === "desc" && sortMode.value === "database",
+    },
+    {
+      label: t("grid.sortCurrentPageAscending"),
+      value: "local-asc",
+      icon: ArrowUp,
+      checked: columnIsSorted(column, columnIndex) && sortDir.value === "asc" && sortMode.value === "local",
+      separatorBefore: true,
+    },
+    {
+      label: t("grid.sortCurrentPageDescending"),
+      value: "local-desc",
+      icon: ArrowDown,
+      checked: columnIsSorted(column, columnIndex) && sortDir.value === "desc" && sortMode.value === "local",
+    },
+    {
+      label: t("grid.clearSort"),
+      value: "clear",
+      icon: ArrowUpDown,
+      disabled: !columnIsSorted(column, columnIndex),
+      separatorBefore: true,
+    },
+  ];
+}
+
+function selectedSortMenuValue(column: string, columnIndex: number): SortMenuValue | undefined {
+  return columnIsSorted(column, columnIndex) ? (`${sortMode.value}-${sortDir.value}` as SortMenuValue) : undefined;
+}
+
+function typeColorClass(t: string): string {
+  // Strip precision/scale suffix like (20,6)
+  const base = t.replace(/\(.*\)$/, "").toLowerCase();
+  if (["int", "int2", "int4", "int8", "smallint", "bigint", "integer", "serial", "bigserial", "tinyint", "mediumint"].includes(base)) return "text-blue-500";
+  // number: Oracle/Dameng NUMBER；binary_float/binary_double: Oracle IEEE 浮点
+  if (["float4", "float8", "double", "decimal", "numeric", "real", "float", "money", "number", "binary_float", "binary_double", "dec"].includes(base)) return "text-cyan-500";
+  // varchar2/nvarchar2/long: Oracle/Dameng 字符类型（LONG 在 Oracle 中是变长字符）
+  if (["varchar", "varchar2", "nvarchar2", "text", "char", "character varying", "character", "string", "nvarchar", "nchar", "ntext", "longtext", "mediumtext", "tinytext", "clob", "long"].includes(base)) return "text-green-500";
+  if (["bool", "boolean", "bit"].includes(base)) return "text-orange-500";
+  if (["timestamp", "timestamptz", "datetime", "date", "time", "timetz", "datetime2", "smalldatetime"].includes(base)) return "text-purple-500";
+  // xmltype: Oracle XMLType
+  if (["json", "jsonb", "xml", "xmltype", "array"].includes(base)) return "text-pink-500";
+  if (["uuid", "uniqueidentifier"].includes(base)) return "text-amber-500";
+  // raw/long raw/bfile: Oracle 二进制
+  if (["bytea", "blob", "binary", "varbinary", "image", "raw", "long raw", "bfile"].includes(base)) return "text-red-400";
+  // sdo_geometry: Oracle Spatial
+  if (["geometry", "geography", "sdo_geometry"].includes(base)) return "text-emerald-500";
+  return "text-muted-foreground";
+}
+const contextCell = ref<{ rowId: number; rowIndex: number; col: number } | null>(null);
+const contextHeaderColumn = ref<string | null>(null);
+const contextHeaderColumnIndex = ref<number | null>(null);
+const bulkEditDialogOpen = ref(false);
+const bulkEditValue = ref("");
+const detailCell = ref<{ rowIndex: number; col: number } | null>(null);
+const hoveredDetailCell = ref<{ rowIndex: number; col: number } | null>(null);
+const quickDownloadMenuCell = ref<{ rowIndex: number; col: number } | null>(null);
+const showCellDetail = ref(false);
+const showMongoJsonPreview = ref(false);
+const activeCellDetailTab = ref<CellDetailTab>(defaultCellDetailTab());
+const cellDetailDialogOpen = ref(false);
+const cellDetailDialogTarget = ref<{ rowIndex: number; col: number } | null>(null);
+const rowDetailDialogOpen = ref(false);
+const rowDetailDialogRowId = ref<number | null>(null);
+const columnDetailDialogOpen = ref(false);
+const columnDetailDialogColumnIndex = ref<number | null>(null);
+const rowDetailSearch = ref("");
+const columnDetailSearch = ref("");
+const isResizingDetail = ref(false);
+const imagePreviewOpen = ref(false);
+const imagePreviewSrc = ref("");
+const imagePreviewTitle = ref("");
+const sideGeometryPreviewOpen = ref(false);
+const dialogGeometryPreviewOpen = ref(false);
+const sideGeometryCanvas = ref<HTMLCanvasElement | null>(null);
+const dialogGeometryCanvas = ref<HTMLCanvasElement | null>(null);
+const previewDialogOpen = ref(false);
+const previewDialogConfig = shallowRef<{ component: any; props: Record<string, any> } | null>(null);
+const transposeScrollRef = ref<HTMLElement | { $el?: HTMLElement }>();
+const transposeScrollLeft = ref(0);
+const transposeViewportWidth = ref(0);
+const sortCol = ref<string | null>(null);
+const sortColIndex = ref<number | null>(null);
+const sortDir = ref<DataGridSortDirection>("asc");
+const sortMode = ref<DataGridSortMode>("database");
+const searchText = ref("");
+const deferredClientSearchText = ref("");
+const searchOverlayVisible = ref(false);
+const currentMatchIndex = ref(-1);
+let _searchTimer: ReturnType<typeof setTimeout> | undefined;
+
+const searchSuggestions = ref<string[]>([]);
+const suggestionIndex = ref(-1);
+const searchInputRef = ref<HTMLInputElement>();
+const measureRef = ref<HTMLSpanElement>();
+const suggestionLeft = ref(0);
+
+const whereSuggestions = ref<ConditionSuggestion[]>([]);
+const whereSuggestionIndex = ref(-1);
+const whereHistoryMenuOpen = ref(false);
+const whereFilterInputRef = ref<HTMLTextAreaElement>();
+const whereFilterOverlayRef = ref<HTMLTextAreaElement>();
+const whereConditionPaneRef = ref<HTMLDivElement>();
+const whereConditionControlRef = ref<HTMLDivElement>();
+const whereSuggestionDropdownRef = ref<HTMLDivElement>();
+const whereSuggestionPosition = ref({ left: 0, top: 0, width: 180 });
+const whereConditionRendered = ref(false);
+const whereConditionExpanded = ref(false);
+const whereConditionHeight = ref(28);
+const whereConditionRect = ref({ left: 0, top: 0, width: 0, height: 28 });
+const whereConditionScrollTop = ref(0);
+const whereConditionImmediateHeight = ref(false);
+let whereConditionCollapseTimer: ReturnType<typeof setTimeout> | undefined;
+let suppressNextWhereWatchResize = false;
+
+const orderBySuggestions = ref<ConditionSuggestion[]>([]);
+const orderBySuggestionIndex = ref(-1);
+const orderByHistoryMenuOpen = ref(false);
+const orderByInputRef = ref<HTMLTextAreaElement>();
+const orderByOverlayRef = ref<HTMLTextAreaElement>();
+const orderByConditionPaneRef = ref<HTMLDivElement>();
+const orderByConditionControlRef = ref<HTMLDivElement>();
+const orderBySuggestionDropdownRef = ref<HTMLDivElement>();
+const orderBySuggestionPosition = ref({ left: 0, top: 0, width: 180 });
+const orderByConditionRendered = ref(false);
+const orderByConditionExpanded = ref(false);
+const orderByConditionHeight = ref(28);
+const orderByConditionRect = ref({ left: 0, top: 0, width: 0, height: 28 });
+const orderByConditionScrollTop = ref(0);
+const orderByConditionImmediateHeight = ref(false);
+let orderByConditionCollapseTimer: ReturnType<typeof setTimeout> | undefined;
+let suppressNextOrderByWatchResize = false;
+const conditionHistoryPreview = ref<{ value: string; left: number; top: number; maxWidth: number; arrowTop: number; side: "left" | "right" } | null>(null);
+
+const orderByInput = ref(props.initialOrderByInput ?? "");
+const hasOrderByInput = computed(() => orderByInput.value.trim().length > 0);
+const whereFilterInput = ref(props.initialWhereInput ?? "");
+let previousWhereFilterInputValue = whereFilterInput.value;
+let suppressWhereHistoryOnNextEmptyInput = false;
+let suppressOrderByHistoryOnNextEmptyInput = false;
+const hasWhereFilterInput = computed(() => whereFilterInput.value.trim().length > 0);
+const conditionHistoryScope = computed(() => ({
+  connectionId: props.connectionId,
+  database: props.database,
+  schema: props.tableMeta?.schema ?? props.schema,
+  tableName: props.tableMeta?.tableName,
+}));
+const searchSplitContainerRef = ref<HTMLDivElement>();
+const searchSplitWhereWidth = ref<number | null>(null);
+const isResizingSearchSplit = ref(false);
+let searchSplitStartX = 0;
+let searchSplitStartWidth = 0;
+
+const whereSearchPaneStyle = computed(() => {
+  if (searchSplitWhereWidth.value == null) return {};
+  return {
+    flex: `0 0 ${searchSplitWhereWidth.value}px`,
+  };
+});
+
+const whereSuggestionStyle = computed(() => ({
+  left: `${whereSuggestionPosition.value.left}px`,
+  top: `${whereSuggestionPosition.value.top}px`,
+  width: `${whereSuggestionPosition.value.width}px`,
+}));
+const showWhereSuggestionDropdown = computed(() => whereSuggestions.value.length > 0 || whereHistoryMenuOpen.value);
+const whereHistoryEmptyText = computed(() => (whereFilterInput.value.trim() ? t("grid.conditionHistoryNoMatches") : t("grid.conditionHistoryEmpty")));
+
+const orderBySuggestionStyle = computed(() => ({
+  left: `${orderBySuggestionPosition.value.left}px`,
+  top: `${orderBySuggestionPosition.value.top}px`,
+  width: `${orderBySuggestionPosition.value.width}px`,
+}));
+const showOrderBySuggestionDropdown = computed(() => orderBySuggestions.value.length > 0 || orderByHistoryMenuOpen.value);
+const orderByHistoryEmptyText = computed(() => (orderByInput.value.trim() ? t("grid.conditionHistoryNoMatches") : t("grid.conditionHistoryEmpty")));
+const conditionHistoryPreviewStyle = computed<CSSProperties>(() => {
+  const preview = conditionHistoryPreview.value;
+  if (!preview) return {};
+  return {
+    left: `${preview.left}px`,
+    maxWidth: `${preview.maxWidth}px`,
+    top: `${preview.top}px`,
+  };
+});
+const conditionHistoryPreviewArrowStyle = computed<CSSProperties>(() => {
+  const preview = conditionHistoryPreview.value;
+  if (!preview) return {};
+  return {
+    top: `${preview.arrowTop}px`,
+  };
+});
+
+type ConditionInputKind = "where" | "orderBy";
+const CONDITION_EXPANDED_MAX_HEIGHT = 260;
+
+function conditionInputRef(kind: ConditionInputKind) {
+  return kind === "where" ? whereFilterInputRef.value : orderByInputRef.value;
+}
+
+function conditionOverlayRef(kind: ConditionInputKind) {
+  return kind === "where" ? whereFilterOverlayRef.value : orderByOverlayRef.value;
+}
+
+function conditionPaneRef(kind: ConditionInputKind) {
+  return kind === "where" ? whereConditionPaneRef.value : orderByConditionPaneRef.value;
+}
+
+function conditionControlRef(kind: ConditionInputKind) {
+  return kind === "where" ? whereConditionControlRef.value : orderByConditionControlRef.value;
+}
+
+function conditionEditorRef(kind: ConditionInputKind) {
+  return conditionOverlayRef(kind) ?? conditionInputRef(kind);
+}
+
+function conditionInputTextWidth(input: HTMLTextAreaElement): number {
+  const probe = document.createElement("span");
+  const style = window.getComputedStyle(input);
+  probe.textContent = input.value || input.placeholder || "";
+  probe.style.cssText = `
+    position: fixed;
+    left: -9999px;
+    top: -9999px;
+    visibility: hidden;
+    white-space: pre;
+    font: ${style.font};
+    font-size: ${style.fontSize};
+    font-family: ${style.fontFamily};
+    font-weight: ${style.fontWeight};
+    letter-spacing: ${style.letterSpacing};
+  `;
+  document.body.appendChild(probe);
+  const width = probe.getBoundingClientRect().width;
+  probe.remove();
+  return width;
+}
+
+function conditionInputShouldExpand(input: HTMLTextAreaElement): boolean {
+  return input.value.length > 0 && conditionInputTextWidth(input) > input.clientWidth + 1;
+}
+
+function conditionInputContentHeight(input: HTMLTextAreaElement): number {
+  const probe = document.createElement("div");
+  const style = window.getComputedStyle(input);
+  probe.textContent = input.value || input.placeholder || "";
+  probe.style.cssText = `
+    position: fixed;
+    left: -9999px;
+    top: -9999px;
+    visibility: hidden;
+    box-sizing: border-box;
+    width: ${input.clientWidth}px;
+    min-height: 0;
+    padding: ${style.paddingTop} ${style.paddingRight} ${style.paddingBottom} ${style.paddingLeft};
+    border: 0;
+    white-space: pre-wrap;
+    overflow-wrap: anywhere;
+    font: ${style.font};
+    font-size: ${style.fontSize};
+    font-family: ${style.fontFamily};
+    font-weight: ${style.fontWeight};
+    line-height: ${style.lineHeight};
+    letter-spacing: ${style.letterSpacing};
+    text-indent: ${style.textIndent};
+  `;
+  document.body.appendChild(probe);
+  const height = probe.scrollHeight;
+  probe.remove();
+  return height;
+}
+
+function conditionExpandedHeight(input: HTMLTextAreaElement): number {
+  const style = window.getComputedStyle(input);
+  const lineHeight = Number.parseFloat(style.lineHeight) || 24;
+  const inputRect = input.getBoundingClientRect();
+  const pane = input.parentElement;
+  const paneRect = pane?.getBoundingClientRect();
+  const verticalInset = paneRect ? Math.max(0, inputRect.top - paneRect.top) + Math.max(0, paneRect.bottom - inputRect.bottom) : 0;
+  const minimumHeight = Math.max(56, lineHeight * 2.5);
+  const availableHeight = Math.max(minimumHeight, window.innerHeight - input.getBoundingClientRect().top - 12);
+  const contentHeight = conditionInputContentHeight(input);
+  return Math.min(Math.max(minimumHeight, contentHeight + verticalInset), Math.min(CONDITION_EXPANDED_MAX_HEIGHT, availableHeight));
+}
+
+function conditionCaretTop(input: HTMLTextAreaElement, caretIndex: number): number {
+  const probe = document.createElement("div");
+  const style = window.getComputedStyle(input);
+  const textBeforeCaret = input.value.slice(0, caretIndex);
+  probe.textContent = textBeforeCaret || " ";
+  probe.style.cssText = `
+    position: fixed;
+    left: -9999px;
+    top: -9999px;
+    visibility: hidden;
+    box-sizing: border-box;
+    width: ${input.clientWidth}px;
+    min-height: 0;
+    padding: ${style.paddingTop} ${style.paddingRight} ${style.paddingBottom} ${style.paddingLeft};
+    border: 0;
+    white-space: pre-wrap;
+    overflow-wrap: anywhere;
+    font: ${style.font};
+    font-size: ${style.fontSize};
+    font-family: ${style.fontFamily};
+    font-weight: ${style.fontWeight};
+    line-height: ${style.lineHeight};
+    letter-spacing: ${style.letterSpacing};
+    text-indent: ${style.textIndent};
+  `;
+  document.body.appendChild(probe);
+  const lineHeight = Number.parseFloat(style.lineHeight) || 24;
+  const top = Math.max(0, probe.scrollHeight - lineHeight);
+  probe.remove();
+  return top;
+}
+
+function setConditionScrollTop(kind: ConditionInputKind, scrollTop: number) {
+  if (kind === "where") {
+    whereConditionScrollTop.value = scrollTop;
+  } else {
+    orderByConditionScrollTop.value = scrollTop;
+  }
+}
+
+function scrollConditionCaretIntoView(kind: ConditionInputKind, input: HTMLTextAreaElement, caretIndex: number) {
+  const caretTop = conditionCaretTop(input, caretIndex);
+  const lineHeight = Number.parseFloat(window.getComputedStyle(input).lineHeight) || 24;
+  const topPadding = lineHeight * 0.5;
+  const maxScrollTop = Math.max(0, input.scrollHeight - input.clientHeight);
+  input.scrollTop = Math.min(Math.max(0, caretTop - topPadding), maxScrollTop);
+  setConditionScrollTop(kind, input.scrollTop);
+}
+
+function conditionCollapsedHeight(kind: ConditionInputKind) {
+  const pane = conditionPaneRef(kind) ?? conditionControlRef(kind);
+  return pane ? pane.getBoundingClientRect().height : 28;
+}
+
+function clearConditionCollapseTimer(kind: ConditionInputKind) {
+  if (kind === "where") {
+    if (whereConditionCollapseTimer) clearTimeout(whereConditionCollapseTimer);
+    whereConditionCollapseTimer = undefined;
+  } else {
+    if (orderByConditionCollapseTimer) clearTimeout(orderByConditionCollapseTimer);
+    orderByConditionCollapseTimer = undefined;
+  }
+}
+
+function conditionPaneRendered(kind: ConditionInputKind) {
+  return kind === "where" ? whereConditionRendered.value : orderByConditionRendered.value;
+}
+
+function setConditionRendered(kind: ConditionInputKind, rendered: boolean) {
+  if (kind === "where") {
+    whereConditionRendered.value = rendered;
+  } else {
+    orderByConditionRendered.value = rendered;
+  }
+}
+
+function conditionPaneExpanded(kind: ConditionInputKind) {
+  return kind === "where" ? whereConditionExpanded.value : orderByConditionExpanded.value;
+}
+
+function setConditionExpandedState(kind: ConditionInputKind, expanded: boolean) {
+  if (kind === "where") {
+    whereConditionExpanded.value = expanded;
+  } else {
+    orderByConditionExpanded.value = expanded;
+  }
+}
+
+function queueConditionPaneRemoval(kind: ConditionInputKind) {
+  clearConditionCollapseTimer(kind);
+  const timer = setTimeout(() => {
+    if (!conditionPaneExpanded(kind)) setConditionRendered(kind, false);
+  }, 160);
+  if (kind === "where") {
+    whereConditionCollapseTimer = timer;
+  } else {
+    orderByConditionCollapseTimer = timer;
+  }
+}
+
+function setConditionExpanded(kind: ConditionInputKind, expanded: boolean) {
+  if (expanded) {
+    const wasRendered = conditionPaneRendered(kind);
+    clearConditionCollapseTimer(kind);
+    setConditionRendered(kind, true);
+    if (wasRendered) {
+      setConditionExpandedState(kind, true);
+    } else {
+      setConditionExpandedState(kind, false);
+      requestAnimationFrame(() => requestAnimationFrame(() => setConditionExpandedState(kind, true)));
+    }
+    return;
+  }
+  setConditionExpandedState(kind, false);
+  queueConditionPaneRemoval(kind);
+}
+
+function setConditionHeight(kind: ConditionInputKind, height: number) {
+  if (kind === "where") {
+    whereConditionHeight.value = height;
+  } else {
+    orderByConditionHeight.value = height;
+  }
+}
+
+function setConditionRect(kind: ConditionInputKind, rect: DOMRect) {
+  const nextRect = {
+    left: rect.left,
+    top: rect.top,
+    width: rect.width,
+    height: rect.height,
+  };
+  if (kind === "where") {
+    whereConditionRect.value = nextRect;
+  } else {
+    orderByConditionRect.value = nextRect;
+  }
+}
+
+function conditionInputInsets(kind: ConditionInputKind) {
+  const pane = conditionPaneRef(kind);
+  const input = conditionInputRef(kind);
+  const control = conditionControlRef(kind);
+  if (!pane || !input) {
+    return { controlsTop: 3, inputTop: 3, prefix: 0, suffix: 0 };
+  }
+  const paneRect = pane.getBoundingClientRect();
+  const inputRect = input.getBoundingClientRect();
+  const controlRect = control?.getBoundingClientRect();
+  const paneStyle = window.getComputedStyle(pane);
+  const paddingLeft = Number.parseFloat(paneStyle.paddingLeft) || 0;
+  const paddingRight = Number.parseFloat(paneStyle.paddingRight) || 0;
+  return {
+    controlsTop: Math.max(0, (controlRect?.top ?? inputRect.top) - paneRect.top),
+    inputTop: Math.max(0, inputRect.top - paneRect.top),
+    prefix: Math.max(0, inputRect.left - paneRect.left - paddingLeft),
+    suffix: Math.max(28, paneRect.right - inputRect.right - paddingRight),
+  };
+}
+
+function conditionPaneStyle(kind: ConditionInputKind): CSSProperties {
+  const rendered = conditionPaneRendered(kind);
+  const expanded = conditionPaneExpanded(kind);
+  const height = kind === "where" ? whereConditionHeight.value : orderByConditionHeight.value;
+  const immediateHeight = kind === "where" ? whereConditionImmediateHeight.value : orderByConditionImmediateHeight.value;
+  if (!rendered) return {};
+  const rect = kind === "where" ? whereConditionRect.value : orderByConditionRect.value;
+  const collapsedHeight = rect.height || 28;
+  const insets = conditionInputInsets(kind);
+  return {
+    "--data-grid-condition-controls-top": `${insets.controlsTop}px`,
+    "--data-grid-condition-input-top": `${insets.inputTop}px`,
+    "--data-grid-condition-prefix-indent": `${insets.prefix}px`,
+    "--data-grid-condition-suffix-width": `${insets.suffix}px`,
+    height: `${expanded ? height : collapsedHeight}px`,
+    left: `${rect.left}px`,
+    pointerEvents: expanded ? "auto" : "none",
+    top: `${rect.top}px`,
+    transition: immediateHeight ? "box-shadow 150ms ease" : undefined,
+    width: `${rect.width}px`,
+  };
+}
+
+function conditionTopbarOverlayStyle(kind: ConditionInputKind): CSSProperties {
+  const scrollTop = kind === "where" ? whereConditionScrollTop.value : orderByConditionScrollTop.value;
+  return {
+    transform: `translateY(${-scrollTop}px)`,
+  };
+}
+
+function focusConditionOverlay(kind: ConditionInputKind, source: HTMLTextAreaElement) {
+  window.setTimeout(() => {
+    const overlay = conditionOverlayRef(kind);
+    if (!overlay) return;
+    const start = source.selectionStart ?? source.value.length;
+    const end = source.selectionEnd ?? start;
+    overlay.focus();
+    overlay.setSelectionRange(start, end);
+    scrollConditionCaretIntoView(kind, overlay, start);
+    requestAnimationFrame(() => scrollConditionCaretIntoView(kind, overlay, start));
+    updateConditionSuggestionPosition(kind);
+  }, 0);
+}
+
+function focusConditionInput(kind: ConditionInputKind, source: HTMLTextAreaElement) {
+  const input = conditionInputRef(kind);
+  if (!input) return;
+  const start = source.selectionStart ?? source.value.length;
+  const end = source.selectionEnd ?? start;
+  nextTick(() => {
+    input.focus();
+    input.setSelectionRange(start, end);
+    updateConditionSuggestionPosition(kind);
+  });
+}
+
+function onConditionOverlayScroll(kind: ConditionInputKind, event: Event) {
+  const input = event.target instanceof HTMLTextAreaElement ? event.target : null;
+  if (!input) return;
+  setConditionScrollTop(kind, input.scrollTop);
+}
+
+function resetConditionOverlayScrollIfContentFits(kind: ConditionInputKind) {
+  requestAnimationFrame(() => {
+    const overlay = conditionOverlayRef(kind);
+    const pane = overlay?.parentElement;
+    if (!overlay || !pane || overlay.scrollHeight > overlay.clientHeight + 1 || pane.getBoundingClientRect().height >= CONDITION_EXPANDED_MAX_HEIGHT - 1) return;
+    overlay.scrollTop = 0;
+    setConditionScrollTop(kind, 0);
+  });
+}
+
+function onConditionOverlayClick(kind: ConditionInputKind) {
+  if (kind === "where") {
+    if (whereHistoryMenuOpen.value) {
+      dismissWhereSuggestions();
+      return;
+    }
+    updateWhereSuggestionPosition();
+  } else {
+    if (orderByHistoryMenuOpen.value) {
+      dismissOrderBySuggestions();
+      return;
+    }
+    updateOrderBySuggestionPosition();
+  }
+}
+
+function resizeConditionInput(kind: ConditionInputKind, options: { focusOverlay?: boolean; expandFromFocus?: boolean; immediateHeight?: boolean } = {}) {
+  nextTick(() => {
+    const input = conditionInputRef(kind);
+    if (!input) return;
+    const editor = conditionEditorRef(kind) ?? input;
+    const focused = document.activeElement === input || document.activeElement === conditionOverlayRef(kind);
+    const expanded = focused && conditionInputShouldExpand(input) && (options.expandFromFocus || document.activeElement === conditionOverlayRef(kind));
+    const shouldRestoreInputFocus = !expanded && document.activeElement === conditionOverlayRef(kind);
+    if (shouldRestoreInputFocus && editor instanceof HTMLTextAreaElement) focusConditionInput(kind, editor);
+    if (expanded) setConditionRect(kind, (conditionPaneRef(kind) ?? conditionControlRef(kind) ?? input).getBoundingClientRect());
+    setConditionExpanded(kind, expanded);
+    requestAnimationFrame(() => {
+      if (!expanded) {
+        if (kind === "where") whereConditionImmediateHeight.value = false;
+        else orderByConditionImmediateHeight.value = false;
+        setConditionHeight(kind, conditionCollapsedHeight(kind));
+        return;
+      }
+      if (options.immediateHeight) {
+        if (kind === "where") whereConditionImmediateHeight.value = true;
+        else orderByConditionImmediateHeight.value = true;
+      }
+      setConditionHeight(kind, conditionExpandedHeight(editor));
+      if (options.immediateHeight) {
+        requestAnimationFrame(() => {
+          if (kind === "where") whereConditionImmediateHeight.value = false;
+          else orderByConditionImmediateHeight.value = false;
+        });
+      }
+      updateConditionSuggestionPosition(kind);
+      if (options.focusOverlay && document.activeElement === input) focusConditionOverlay(kind, input);
+      else resetConditionOverlayScrollIfContentFits(kind);
+    });
+  });
+}
+
+function onConditionInputClick(kind: ConditionInputKind) {
+  if (kind === "where" && showWhereSuggestionDropdown.value) {
+    dismissWhereSuggestions();
+    resizeConditionInput(kind, { expandFromFocus: true, focusOverlay: true });
+    return;
+  }
+  if (kind === "orderBy" && showOrderBySuggestionDropdown.value) {
+    dismissOrderBySuggestions();
+    resizeConditionInput(kind, { expandFromFocus: true, focusOverlay: true });
+    return;
+  }
+  updateConditionSuggestionPosition(kind);
+  resizeConditionInput(kind, { expandFromFocus: true, focusOverlay: true });
+}
+
+function collapseConditionInput(kind: ConditionInputKind) {
+  setConditionExpanded(kind, false);
+  setConditionHeight(kind, conditionCollapsedHeight(kind));
+  setConditionScrollTop(kind, 0);
+}
+
+function collapseConditionInputAfterBlur(kind: ConditionInputKind) {
+  window.setTimeout(() => {
+    const input = conditionInputRef(kind);
+    const overlay = conditionOverlayRef(kind);
+    if (document.activeElement === input || document.activeElement === overlay) return;
+    collapseConditionInput(kind);
+  }, 0);
+}
+
+function resizeFocusedConditionInputs() {
+  resizeConditionInput("where");
+  resizeConditionInput("orderBy");
+}
+
+function normalizeConditionInputValue(value: string) {
+  return value.replace(/\s*\r?\n\s*/g, " ");
+}
+
+function updateConditionSuggestionPosition(kind: ConditionInputKind) {
+  if (kind === "where") {
+    updateWhereSuggestionPosition();
+  } else {
+    updateOrderBySuggestionPosition();
+  }
+}
+
+function showConditionHistoryPreview(value: string, event: MouseEvent) {
+  const target = event.currentTarget instanceof HTMLElement ? event.currentTarget : null;
+  if (!target) return;
+  const textElement = target.querySelector<HTMLElement>("[data-condition-history-text]");
+  if (!textElement || textElement.scrollWidth <= textElement.clientWidth + 1) {
+    hideConditionHistoryPreview();
+    return;
+  }
+  const rect = target.getBoundingClientRect();
+  const gap = 10;
+  const minWidth = 280;
+  const preferredWidth = 560;
+  const availableRight = window.innerWidth - rect.right - gap - 8;
+  const availableLeft = rect.left - gap - 8;
+  const placeRight = availableRight >= minWidth || availableRight >= availableLeft;
+  const maxWidth = Math.max(minWidth, Math.min(preferredWidth, placeRight ? availableRight : availableLeft));
+  const left = placeRight ? rect.right + gap : Math.max(8, rect.left - gap - maxWidth);
+  const estimatedHeight = Math.min(260, Math.max(56, Math.ceil(value.length / 58) * 18 + 24));
+  const top = Math.min(Math.max(8, rect.top), Math.max(8, window.innerHeight - estimatedHeight - 8));
+  const arrowTop = Math.min(Math.max(14, rect.top + rect.height / 2 - top), estimatedHeight - 14);
+  conditionHistoryPreview.value = { value, left, top, maxWidth, arrowTop, side: placeRight ? "left" : "right" };
+}
+
+function hideConditionHistoryPreview() {
+  conditionHistoryPreview.value = null;
+}
+
+type LocalFilterMode = "local" | "server";
+type LocalFilterOption = {
+  key: string;
+  label: string;
+  count: number | null;
+  value: CellValue;
+};
+
+type LocalColumnFilterDraft = {
+  columnIndex: number;
+  values: Set<string>;
+  mode: LocalFilterMode;
+  touched: boolean;
+};
+
+type FilterMode = DataGridContextFilterMode;
+
+type StructuredFilterRule = {
+  id: string;
+  columnName: string;
+  mode: FilterMode;
+  rawValue: string;
+  conjunction: "AND" | "OR";
+  disabled?: boolean;
+};
+
+const localColumnFilters = ref<Record<number, Set<string>>>({});
+const localFilterOpenColumn = ref<number | null>(null);
+const headerActionMenuOpenColumn = ref<number | null>(null);
+const headerSortMenuOpenColumn = ref<number | null>(null);
+const headerPanelDismissGuardUntil = ref(0);
+const localFilterSearch = ref("");
+const localFilterDraft = ref<LocalColumnFilterDraft | null>(null);
+const SERVER_COLUMN_FILTER_LIMIT = 1000;
+const SERVER_COLUMN_FILTER_DEBOUNCE_MS = 300;
+const serverFilterLoading = ref(false);
+const serverFilterError = ref("");
+const serverFilterOptions = ref<LocalFilterOption[]>([]);
+const serverFilterLimited = ref(false);
+const serverFilterValueByKey = ref<Map<string, CellValue>>(new Map());
+let serverFilterRequestId = 0;
+let serverFilterSearchTimer: ReturnType<typeof window.setTimeout> | undefined;
+const filterBuilderOpen = ref(false);
+const filterBuilderColumnSearch = ref("");
+const filterModeOptions: Array<{ value: FilterMode; labelKey: string }> = [
+  { value: "equals", labelKey: "grid.filterBuilderEquals" },
+  { value: "not-equals", labelKey: "grid.filterBuilderNotEquals" },
+  { value: "like", labelKey: "grid.filterBuilderContains" },
+  { value: "not-like", labelKey: "grid.filterBuilderNotContains" },
+  { value: "greater-than", labelKey: "grid.filterBuilderGreaterThan" },
+  { value: "less-than", labelKey: "grid.filterBuilderLessThan" },
+  { value: "is-null", labelKey: "grid.filterBuilderIsNull" },
+  { value: "is-not-null", labelKey: "grid.filterBuilderIsNotNull" },
+];
+const filterBuilderColumns = computed(() => props.tableMeta?.columns ?? []);
+const filterBuilderColumnOptions = computed(() => filterBuilderColumns.value.map((column) => column.name));
+const filteredFilterBuilderColumnOptions = computed(() => {
+  const query = filterBuilderColumnSearch.value.trim().toLowerCase();
+  if (!query) return filterBuilderColumnOptions.value;
+  return filterBuilderColumnOptions.value.filter((columnName) => columnName.toLowerCase().includes(query));
+});
+const filterBuilderColumnSearchNavigationKeys = new Set(["Escape", "Tab", "ArrowUp", "ArrowDown", "Home", "End", "PageUp", "PageDown"]);
+const structuredFilterCacheKey = computed(() => props.cacheKey || [props.connectionId ?? "", props.database ?? "", props.context ?? "", props.tableMeta?.schema ?? "", props.tableMeta?.tableName ?? ""].join("\u0001"));
+const structuredFilterScopeKey = computed(() => [props.connectionId ?? "", props.database ?? "", props.schema ?? "", props.context ?? "", props.tableMeta?.schema ?? "", props.tableMeta?.tableName ?? "", filterBuilderColumnOptions.value.join("\0")].join("\u0001"));
+const structuredFilterRules = ref<StructuredFilterRule[]>([]);
+const appliedStructuredWhereInput = ref("");
+const structuredFilterCount = computed(() => structuredFilterRules.value.filter((rule) => !rule.disabled && !!rule.columnName && (!filterModeNeedsValue(rule.mode) || rule.rawValue.trim().length > 0)).length);
+const hasStructuredFilters = computed(() => !!combineWhereInputs(undefined, appliedStructuredWhereInput.value));
+const formatterOpenColumn = ref<number | null>(null);
+type FormatterDraftKind = Exclude<ColumnFormatterConfig["kind"], "custom-ref">;
+const CUSTOM_FORMATTER_NEW = "__new";
+const formatterKind = ref<FormatterDraftKind>("datetime");
+const formatterDateUnit = ref<DateTimeFormatterUnit>("auto");
+const formatterDatetimePattern = ref<string>("YYYY-MM-DD HH:mm:ss");
+const formatterJsonPath = ref("$.user.name");
+const formatterMaskPrefix = ref(4);
+const formatterMaskSuffix = ref(4);
+const formatterCustomId = ref(CUSTOM_FORMATTER_NEW);
+const formatterCustomName = ref("");
+const formatterCustomTemplate = ref("${value}");
+
+const savedCustomFormatters = computed(() => {
+  return Object.values(settingsStore.editorSettings.customColumnFormatters).sort((a, b) => a.name.localeCompare(b.name));
+});
+
+function localFilterKey(value: CellValue): string {
+  if (value === null) return "__dbx_null__";
+  if (typeof value === "boolean") return `bool:${value}`;
+  if (typeof value === "number") return `num:${value}`;
+  return `str:${String(value)}`;
+}
+
+function localFilterLabel(value: CellValue, columnIndex: number): string {
+  return value === null ? "NULL" : formatCellCached(value, columnIndex);
+}
+
+function localFilterActive(colIdx: number): boolean {
+  return !!localColumnFilters.value[colIdx]?.size;
+}
+
+const localFilterCount = computed(() => Object.values(localColumnFilters.value).filter((values) => values.size).length);
+const hasLocalColumnFilters = computed(() => localFilterCount.value > 0);
+const filterButtonCount = computed(() => structuredFilterCount.value + localFilterCount.value);
+const filterButtonActive = computed(() => hasStructuredFilters.value || hasLocalColumnFilters.value);
+const localFilterSummaries = computed(() =>
+  Object.entries(localColumnFilters.value)
+    .filter(([, selected]) => selected.size > 0)
+    .map(([columnIndexText, selected]) => {
+      const columnIndex = Number(columnIndexText);
+      const labelByKey = new Map(buildLocalFilterOptions(columnIndex).map((option) => [option.key, option.label]));
+      const values = [...selected].map((key) => labelByKey.get(key) ?? key);
+      return {
+        columnIndex,
+        columnName: props.result.columns[columnIndex] ?? `#${columnIndex + 1}`,
+        values: values.slice(0, 3),
+        hiddenValueCount: Math.max(0, values.length - 3),
+      };
+    }),
+);
+
+function rowMatchesLocalColumnFilters(data: CellValue[]): boolean {
+  const activeEntries = Object.entries(localColumnFilters.value).filter(([, selected]) => selected.size > 0);
+  if (activeEntries.length === 0) return true;
+  return activeEntries.every(([columnIndex, selected]) => selected.has(localFilterKey(data[Number(columnIndex)] ?? null)));
+}
+
+const localFilteredRows = computed(() => {
+  const rows = props.result.rows;
+  const indices: number[] = [];
+  if (!hasLocalColumnFilters.value) {
+    for (let i = 0; i < rows.length; i++) indices.push(i);
+    return indices;
+  }
+  for (let i = 0; i < rows.length; i++) {
+    if (rowMatchesLocalColumnFilters(rowDataWithChanges(rows[i], i))) {
+      indices.push(i);
+    }
+  }
+  return indices;
+});
+
+function buildLocalFilterOptions(columnIndex: number): LocalFilterOption[] {
+  const byKey = new Map<string, LocalFilterOption>();
+  const addValue = (value: CellValue) => {
+    const key = localFilterKey(value);
+    const current = byKey.get(key);
+    if (current) {
+      current.count = (current.count ?? 0) + 1;
+    } else {
+      byKey.set(key, { key, label: localFilterLabel(value, columnIndex), count: 1, value });
+    }
+  };
+
+  for (const [sourceIndex, row] of props.result.rows.entries()) {
+    addValue(rowDataWithChanges(row, sourceIndex)[columnIndex] ?? null);
+  }
+  for (const row of newRows.value) {
+    addValue(row[columnIndex] ?? null);
+  }
+
+  return [...byKey.values()].sort((a, b) => {
+    if (a.value === null && b.value !== null) return -1;
+    if (a.value !== null && b.value === null) return 1;
+    return a.label.localeCompare(b.label, undefined, { numeric: true, sensitivity: "base" });
+  });
+}
+
+const localFilterAllOptions = computed(() => {
+  if (localFilterDraft.value?.mode === "server") return serverFilterOptions.value;
+  const columnIndex = localFilterDraft.value?.columnIndex;
+  if (columnIndex === undefined) return [];
+  return buildLocalFilterOptions(columnIndex);
+});
+
+const localFilterOptions = computed(() => {
+  if (localFilterDraft.value?.mode === "server") return serverFilterOptions.value;
+  const query = localFilterSearch.value.trim().toLowerCase();
+  return localFilterAllOptions.value.filter((option) => !query || option.label.toLowerCase().includes(query)).slice(0, 500);
+});
+
+const localFilterAllVisibleSelected = computed(() => {
+  const draft = localFilterDraft.value;
+  if (!draft || localFilterOptions.value.length === 0) return false;
+  return localFilterOptions.value.every((option) => draft.values.has(option.key));
+});
+
+const localFilterTypedValue = computed(() => localFilterSearch.value.trim());
+
+const localFilterDraftIsAllSelected = computed(() => {
+  const draft = localFilterDraft.value;
+  if (!draft) return false;
+  const allKeys = localFilterAllOptions.value.map((option) => option.key);
+  return allKeys.length > 0 && allKeys.every((key) => draft.values.has(key));
+});
+
+const canApplyTypedLocalFilterValue = computed(() => {
+  const draft = localFilterDraft.value;
+  const typed = localFilterTypedValue.value;
+  if (!draft || !typed || !canUseWhereSearch.value) return false;
+  const normalized = typed.toLowerCase();
+  return !localFilterAllOptions.value.some((option) => option.label.toLowerCase() === normalized);
+});
+
+function openLocalFilter(colIdx: number, requestedMode: LocalFilterMode = "local") {
+  localFilterSearch.value = "";
+  const mode: LocalFilterMode = requestedMode === "server" && canUseServerColumnFilter.value ? "server" : "local";
+  const allKeys = mode === "server" ? [] : buildLocalFilterOptions(colIdx).map((option) => option.key);
+  localFilterDraft.value = {
+    columnIndex: colIdx,
+    values: new Set(mode === "server" ? allKeys : (localColumnFilters.value[colIdx] ?? allKeys)),
+    mode,
+    touched: false,
+  };
+  localFilterOpenColumn.value = colIdx;
+  if (mode === "server") {
+    resetServerFilterState();
+    void loadServerFilterValues(colIdx, "");
+  } else {
+    resetServerFilterState();
+  }
+}
+
+function resetServerFilterState() {
+  serverFilterRequestId++;
+  if (serverFilterSearchTimer !== undefined) {
+    window.clearTimeout(serverFilterSearchTimer);
+    serverFilterSearchTimer = undefined;
+  }
+  serverFilterLoading.value = false;
+  serverFilterError.value = "";
+  serverFilterOptions.value = [];
+  serverFilterLimited.value = false;
+  serverFilterValueByKey.value = new Map();
+}
+
+function serverFilterOptionFromRow(row: QueryResult["rows"][number], columnIndex: number): LocalFilterOption {
+  const value = (row[0] ?? null) as CellValue;
+  const countValue = Number(row[1]);
+  const count = Number.isFinite(countValue) ? countValue : null;
+  return {
+    key: localFilterKey(value),
+    label: localFilterLabel(value, columnIndex),
+    count,
+    value,
+  };
+}
+
+function serverFilterOptionsFromResult(result: QueryResult, columnIndex: number): LocalFilterOption[] {
+  const byKey = new Map<string, LocalFilterOption>();
+  for (const row of result.rows) {
+    const option = serverFilterOptionFromRow(row, columnIndex);
+    const current = byKey.get(option.key);
+    if (current) {
+      current.count = (current.count ?? 0) + (option.count ?? 0);
+    } else {
+      byKey.set(option.key, option);
+    }
+  }
+  return [...byKey.values()];
+}
+
+function syncServerFilterDraft(columnIndex: number, options: LocalFilterOption[]) {
+  const draft = localFilterDraft.value;
+  if (!draft || draft.mode !== "server" || draft.columnIndex !== columnIndex) return;
+  if (draft.touched) return;
+  localFilterDraft.value = {
+    ...draft,
+    values: new Set(options.map((option) => option.key)),
+  };
+}
+
+async function loadServerFilterValues(columnIndex: number, searchValue: string) {
+  if (!canUseServerColumnFilter.value || !props.connectionId) return;
+  const columnName = props.result.columns[columnIndex];
+  if (!columnName) return;
+  const requestId = ++serverFilterRequestId;
+  serverFilterLoading.value = true;
+  serverFilterError.value = "";
+  serverFilterLimited.value = false;
+  try {
+    const tableMeta = await waitForTableMeta();
+    if (!tableMeta) return;
+    const columnInfo = tableMeta.columns.find((column) => column.name === columnName);
+    const sql = await buildDataGridColumnDistinctValuesSql({
+      databaseType: resolvedDatabaseType.value,
+      catalog: tableMeta.catalog,
+      schema: tableMeta.schema,
+      tableName: tableMeta.tableName,
+      columnName,
+      columnInfo,
+      whereInput: currentWhereInput(),
+      searchValue: searchValue.trim() || undefined,
+      limit: SERVER_COLUMN_FILTER_LIMIT,
+      includeCounts: true,
+    });
+    const result = await api.executeQuery(props.connectionId, props.executionDatabase ?? props.database ?? "", sql, tableMeta.schema ?? props.schema, undefined, {
+      maxRows: SERVER_COLUMN_FILTER_LIMIT,
+      fetchSize: SERVER_COLUMN_FILTER_LIMIT,
+      pageSize: SERVER_COLUMN_FILTER_LIMIT,
+    });
+    if (requestId !== serverFilterRequestId || localFilterOpenColumn.value !== columnIndex) return;
+    const options = serverFilterOptionsFromResult(result, columnIndex);
+    const nextValueByKey = new Map(serverFilterValueByKey.value);
+    for (const option of options) nextValueByKey.set(option.key, option.value);
+    serverFilterValueByKey.value = nextValueByKey;
+    serverFilterOptions.value = options;
+    serverFilterLimited.value = result.truncated === true || result.rows.length >= SERVER_COLUMN_FILTER_LIMIT;
+    syncServerFilterDraft(columnIndex, options);
+  } catch (e: any) {
+    if (requestId !== serverFilterRequestId) return;
+    serverFilterOptions.value = [];
+    serverFilterError.value = String(e?.message || e);
+  } finally {
+    if (requestId === serverFilterRequestId) {
+      serverFilterLoading.value = false;
+    }
+  }
+}
+
+function guardHeaderPanelDismiss() {
+  headerPanelDismissGuardUntil.value = Date.now() + 350;
+}
+
+function shouldIgnoreHeaderPanelClose(columnIndex: number, openColumn: number | null): boolean {
+  return compactColumnHeaderActions.value && openColumn === columnIndex && Date.now() < headerPanelDismissGuardUntil.value;
+}
+
+function openCompactLocalFilter(colIdx: number, mode: LocalFilterMode = "local") {
+  headerActionMenuOpenColumn.value = null;
+  guardHeaderPanelDismiss();
+  nextTick(() => {
+    window.setTimeout(() => {
+      guardHeaderPanelDismiss();
+      openLocalFilter(colIdx, mode);
+    }, 0);
+  });
+}
+
+function compactColumnActionMenuItems(columnName: string) {
+  return [
+    {
+      label: t("grid.columnFormatter"),
+      value: "formatter",
+      icon: Code2,
+      disabled: !formatterKeyForColumn(columnName),
+    },
+    {
+      label: t("grid.localFilter"),
+      value: "localFilter",
+      icon: Filter,
+    },
+    ...(canUseServerColumnFilter.value
+      ? [
+          {
+            label: t("grid.databaseValueFilter"),
+            value: "serverFilter",
+            icon: Database,
+          },
+        ]
+      : []),
+  ];
+}
+
+function columnFilterPanelTitle(columnName: string): string {
+  return localFilterDraft.value?.mode === "server" ? t("grid.databaseValueFilterFor", { column: columnName }) : t("grid.localFilterFor", { column: columnName });
+}
+
+function selectCompactColumnAction(value: string, columnIndex: number) {
+  if (value === "formatter") {
+    openCompactColumnFormatter(columnIndex);
+  } else if (value === "localFilter") {
+    openCompactLocalFilter(columnIndex, "local");
+  } else if (value === "serverFilter") {
+    openCompactLocalFilter(columnIndex, "server");
+  }
+}
+
+function handleLocalFilterOpenChange(value: boolean, columnIndex: number) {
+  if (value) {
+    openLocalFilter(columnIndex, "local");
+  } else if (!shouldIgnoreHeaderPanelClose(columnIndex, localFilterOpenColumn.value)) {
+    closeLocalFilter();
+  }
+}
+
+function closeLocalFilter() {
+  localFilterOpenColumn.value = null;
+  localFilterDraft.value = null;
+  localFilterSearch.value = "";
+  resetServerFilterState();
+}
+
+function formatterKeyForColumn(column: string): string | null {
+  if (!props.connectionId || !props.tableMeta) return null;
+  return buildColumnFormatterKey({
+    connectionId: props.connectionId,
+    database: props.database,
+    schema: props.tableMeta.schema,
+    tableName: props.tableMeta.tableName,
+    column,
+  });
+}
+
+function columnFormatter(columnIndex: number): ColumnFormatterConfig | undefined {
+  const column = props.result.columns[columnIndex];
+  if (!column) return undefined;
+  const key = formatterKeyForColumn(column);
+  return key ? resolveColumnFormatter(settingsStore.editorSettings.columnFormatters[key], settingsStore.editorSettings.customColumnFormatters) : undefined;
+}
+
+function savedColumnFormatter(columnIndex: number): ColumnFormatterConfig | undefined {
+  const column = props.result.columns[columnIndex];
+  if (!column) return undefined;
+  const key = formatterKeyForColumn(column);
+  return key ? settingsStore.editorSettings.columnFormatters[key] : undefined;
+}
+
+function columnHasFormatter(columnIndex: number): boolean {
+  return !!columnFormatter(columnIndex);
+}
+
+function currentFormatterDraft(): ColumnFormatterConfig {
+  if (formatterKind.value === "json-path") {
+    return { kind: "json-path", path: formatterJsonPath.value.trim() || "$" };
+  }
+  if (formatterKind.value === "mask") {
+    return {
+      kind: "mask",
+      prefix: Math.max(0, Math.floor(Number(formatterMaskPrefix.value) || 0)),
+      suffix: Math.max(0, Math.floor(Number(formatterMaskSuffix.value) || 0)),
+    };
+  }
+  if (formatterKind.value === "custom-template") {
+    return { kind: "custom-template", template: formatterCustomTemplate.value.trim() || "${value}" };
+  }
+  return { kind: "datetime", unit: formatterDateUnit.value, pattern: formatterDatetimePattern.value };
+}
+
+function loadFormatterDraft(formatter: ColumnFormatterConfig | undefined) {
+  const draft = formatter ?? { kind: "datetime", unit: "auto" as const, pattern: "YYYY-MM-DD HH:mm:ss" as const };
+  formatterKind.value = draft.kind === "custom-ref" ? "custom-template" : draft.kind;
+  if (draft.kind === "datetime") {
+    formatterDateUnit.value = draft.unit;
+    formatterDatetimePattern.value = draft.pattern;
+  } else if (draft.kind === "json-path") {
+    formatterJsonPath.value = draft.path;
+  } else if (draft.kind === "mask") {
+    formatterMaskPrefix.value = draft.prefix;
+    formatterMaskSuffix.value = draft.suffix;
+  } else if (draft.kind === "custom-ref") {
+    const saved = settingsStore.editorSettings.customColumnFormatters[draft.formatterId];
+    formatterCustomId.value = saved ? saved.id : CUSTOM_FORMATTER_NEW;
+    formatterCustomName.value = saved?.name ?? "";
+    formatterCustomTemplate.value = saved?.template ?? "${value}";
+  } else if (draft.kind === "custom-template") {
+    formatterCustomId.value = CUSTOM_FORMATTER_NEW;
+    formatterCustomName.value = "";
+    formatterCustomTemplate.value = draft.template;
+  }
+}
+
+function openColumnFormatter(columnIndex: number) {
+  loadFormatterDraft(savedColumnFormatter(columnIndex));
+  formatterOpenColumn.value = columnIndex;
+}
+
+function openCompactColumnFormatter(columnIndex: number) {
+  headerActionMenuOpenColumn.value = null;
+  guardHeaderPanelDismiss();
+  nextTick(() => {
+    window.setTimeout(() => {
+      guardHeaderPanelDismiss();
+      openColumnFormatter(columnIndex);
+    }, 0);
+  });
+}
+
+function closeColumnFormatter() {
+  formatterOpenColumn.value = null;
+}
+
+function handleColumnFormatterOpenChange(value: boolean, columnIndex: number) {
+  if (value) {
+    openColumnFormatter(columnIndex);
+  } else if (!shouldIgnoreHeaderPanelClose(columnIndex, formatterOpenColumn.value)) {
+    closeColumnFormatter();
+  }
+}
+
+function saveColumnFormatter(columnIndex: number) {
+  const column = props.result.columns[columnIndex];
+  const key = column ? formatterKeyForColumn(column) : null;
+  if (!key) return;
+  let formatter = currentFormatterDraft();
+  if (formatterKind.value === "custom-template" && formatterCustomName.value.trim()) {
+    const id = formatterCustomId.value === CUSTOM_FORMATTER_NEW ? createCustomFormatterId() : formatterCustomId.value;
+    const saved = settingsStore.upsertCustomColumnFormatter({
+      id,
+      name: formatterCustomName.value,
+      template: formatterCustomTemplate.value,
+    });
+    if (saved) formatter = { kind: "custom-ref", formatterId: saved.id };
+  }
+  settingsStore.updateColumnFormatter(key, formatter);
+  closeColumnFormatter();
+}
+
+function clearColumnFormatter(columnIndex: number) {
+  const column = props.result.columns[columnIndex];
+  const key = column ? formatterKeyForColumn(column) : null;
+  if (!key) return;
+  settingsStore.updateColumnFormatter(key, undefined);
+  closeColumnFormatter();
+}
+
+function formatterDraftIsSavable(): boolean {
+  return !!normalizeColumnFormatter(currentFormatterDraft());
+}
+
+function selectCustomFormatter(value: string) {
+  formatterCustomId.value = value;
+  if (value === CUSTOM_FORMATTER_NEW) {
+    formatterCustomName.value = "";
+    formatterCustomTemplate.value = "${value}";
+    return;
+  }
+  const saved = settingsStore.editorSettings.customColumnFormatters[value];
+  if (!saved) return;
+  formatterCustomName.value = saved.name;
+  formatterCustomTemplate.value = saved.template;
+}
+
+function createCustomFormatterId(): string {
+  return `fmt_${uuid()}`;
+}
+
+function formatterPreviewRows(columnIndex: number) {
+  const formatter = resolveColumnFormatter(currentFormatterDraft(), settingsStore.editorSettings.customColumnFormatters);
+  return displayRowRefs.value.slice(0, 5).map((_, index) => {
+    const item = displayItemAt(index);
+    const value = item?.data[columnIndex] ?? null;
+    return {
+      index: index + 1,
+      raw: displayCellValue(value),
+      formatted: applyColumnFormatter(value, formatter),
+    };
+  });
+}
+
+function toggleLocalFilterValue(key: string) {
+  const draft = localFilterDraft.value;
+  if (!draft) return;
+  const next = new Set(draft.values);
+  if (next.has(key)) next.delete(key);
+  else next.add(key);
+  localFilterDraft.value = { ...draft, values: next, touched: true };
+}
+
+function toggleAllLocalFilterOptions() {
+  const draft = localFilterDraft.value;
+  if (!draft) return;
+  const visibleKeys = localFilterOptions.value.map((option) => option.key);
+  const next = new Set(draft.values);
+  if (localFilterAllVisibleSelected.value) {
+    visibleKeys.forEach((key) => next.delete(key));
+  } else {
+    visibleKeys.forEach((key) => next.add(key));
+  }
+  localFilterDraft.value = { ...draft, values: next, touched: true };
+}
+
+async function applyLocalFilter() {
+  const draft = localFilterDraft.value;
+  if (!draft) return;
+  if (draft.mode === "server") {
+    await applyServerColumnFilter(draft);
+    return;
+  }
+  if (canApplyTypedLocalFilterValue.value && localFilterDraftIsAllSelected.value && localFilterOptions.value.length === 0) {
+    await applyTypedLocalFilterValue();
+    return;
+  }
+  const allKeys = new Set(localFilterAllOptions.value.map((option) => option.key));
+  const next = { ...localColumnFilters.value };
+  let selected = draft.values;
+  if (localFilterSearch.value.trim()) {
+    const visibleKeys = new Set(localFilterOptions.value.map((o) => o.key));
+    selected = new Set([...draft.values].filter((k) => visibleKeys.has(k)));
+  }
+  if (selected.size === 0 || selected.size === allKeys.size) {
+    delete next[draft.columnIndex];
+  } else {
+    next[draft.columnIndex] = new Set(selected);
+  }
+  localColumnFilters.value = next;
+  closeLocalFilter();
+  resetGridVerticalScroll();
+}
+
+async function applyServerColumnFilter(draft: LocalColumnFilterDraft) {
+  if (!draft.touched && !localFilterSearch.value.trim()) {
+    closeLocalFilter();
+    return;
+  }
+  if (canApplyTypedLocalFilterValue.value && serverFilterOptions.value.length === 0) {
+    await applyTypedLocalFilterValue();
+    return;
+  }
+  const columnName = props.result.columns[draft.columnIndex];
+  if (!columnName) return;
+  const values = [...draft.values].flatMap((key) => {
+    if (!serverFilterValueByKey.value.has(key)) return [];
+    return [serverFilterValueByKey.value.get(key)!];
+  });
+  if (values.length === 0) {
+    closeLocalFilter();
+    return;
+  }
+  const condition = await buildColumnValuesFilterCondition({
+    databaseType: resolvedDatabaseType.value,
+    columnName,
+    columnInfo: props.tableMeta?.columns.find((column) => column.name === columnName),
+    values,
+  });
+  if (!condition) return;
+  const next = { ...localColumnFilters.value };
+  delete next[draft.columnIndex];
+  localColumnFilters.value = next;
+  whereFilterInput.value = appendColumnValueFilterCondition(whereFilterInput.value, condition);
+  closeLocalFilter();
+  await applyWhereFilter();
+}
+
+async function applyTypedLocalFilterValue() {
+  const draft = localFilterDraft.value;
+  if (!draft) return;
+  const columnName = props.result.columns[draft.columnIndex];
+  if (!columnName) return;
+  const condition = await buildColumnValueFilterCondition({
+    databaseType: resolvedDatabaseType.value,
+    columnName,
+    columnInfo: props.tableMeta?.columns.find((column) => column.name === columnName),
+    rawValue: localFilterTypedValue.value,
+  });
+  if (!condition) return;
+  const next = { ...localColumnFilters.value };
+  delete next[draft.columnIndex];
+  localColumnFilters.value = next;
+  whereFilterInput.value = appendColumnValueFilterCondition(whereFilterInput.value, condition);
+  closeLocalFilter();
+  await applyWhereFilter();
+}
+
+function clearLocalFilter(colIdx?: number) {
+  if (colIdx === undefined) {
+    localColumnFilters.value = {};
+  } else {
+    const next = { ...localColumnFilters.value };
+    delete next[colIdx];
+    localColumnFilters.value = next;
+  }
+  closeLocalFilter();
+  resetGridVerticalScroll();
+}
+
+watch(localFilterSearch, (value) => {
+  const draft = localFilterDraft.value;
+  if (!draft || draft.mode !== "server" || localFilterOpenColumn.value !== draft.columnIndex) return;
+  if (serverFilterSearchTimer !== undefined) {
+    window.clearTimeout(serverFilterSearchTimer);
+  }
+  serverFilterSearchTimer = window.setTimeout(() => {
+    void loadServerFilterValues(draft.columnIndex, value);
+  }, SERVER_COLUMN_FILTER_DEBOUNCE_MS);
+});
+
+function defaultStructuredFilterRule(): StructuredFilterRule {
+  return {
+    id: uuid(),
+    columnName: filterBuilderColumnOptions.value[0] ?? "",
+    mode: "equals",
+    rawValue: "",
+    conjunction: "AND",
+  };
+}
+
+function cloneStructuredFilterRules(rules: StructuredFilterRule[]): StructuredFilterRule[] {
+  return rules.map((rule) => ({ ...rule }));
+}
+
+function cachedStructuredFilterState(): StructuredFilterCacheState | undefined {
+  const cached = structuredFilterStateCache.get(structuredFilterCacheKey.value);
+  return cached?.scopeKey === structuredFilterScopeKey.value ? cached : undefined;
+}
+
+async function buildStructuredWhereFromRules(rules: StructuredFilterRule[]): Promise<string> {
+  const rulesWithConditions = (
+    await Promise.all(
+      rules.map(async (rule) => {
+        if (rule.disabled) return { rule, condition: null };
+        if (!rule.columnName) return { rule, condition: null };
+        if (filterModeNeedsValue(rule.mode) && !rule.rawValue.trim()) return { rule, condition: null };
+        const columnInfo = filterBuilderColumns.value.find((column) => column.name === rule.columnName);
+        return {
+          rule,
+          condition:
+            (await buildDataGridContextFilterCondition({
+              databaseType: resolvedDatabaseType.value,
+              columnName: rule.columnName,
+              columnInfo,
+              mode: rule.mode,
+              value: filterModeNeedsValue(rule.mode) ? parseFilterValue(rule.rawValue, columnInfo) : null,
+            })) ?? null,
+        };
+      }),
+    )
+  ).filter((item): item is { rule: StructuredFilterRule; condition: string } => !!item.condition);
+
+  return buildGroupedWhere(
+    rulesWithConditions.map((item) => item.condition),
+    rulesWithConditions.map((item) => item.rule),
+  );
+}
+
+function persistStructuredFilterState() {
+  structuredFilterStateCache.set(structuredFilterCacheKey.value, {
+    scopeKey: structuredFilterScopeKey.value,
+    manualWhereInput: whereFilterInput.value,
+    rules: cloneStructuredFilterRules(structuredFilterRules.value),
+    appliedWhereInput: appliedStructuredWhereInput.value,
+  });
+}
+
+function loadStructuredFilterStateForScope() {
+  const cached = cachedStructuredFilterState();
+  if (cached) {
+    const cacheKey = structuredFilterCacheKey.value;
+    const scopeKey = structuredFilterScopeKey.value;
+    structuredFilterRules.value = cloneStructuredFilterRules(cached.rules);
+    whereFilterInput.value = cached.manualWhereInput;
+    appliedStructuredWhereInput.value = "";
+    void buildStructuredWhereFromRules(structuredFilterRules.value).then((whereInput) => {
+      if (structuredFilterCacheKey.value !== cacheKey || structuredFilterScopeKey.value !== scopeKey) return;
+      appliedStructuredWhereInput.value = whereInput;
+      nextTick(() => emit("update:whereInput", currentWhereInput() ?? ""));
+    });
+    return;
+  }
+  appliedStructuredWhereInput.value = "";
+  structuredFilterRules.value = filterBuilderColumnOptions.value.length > 0 ? [defaultStructuredFilterRule()] : [];
+  persistStructuredFilterState();
+}
+
+function ensureStructuredFilterRule() {
+  if (structuredFilterRules.value.length === 0 && filterBuilderColumnOptions.value.length > 0) {
+    structuredFilterRules.value = [defaultStructuredFilterRule()];
+  }
+}
+
+function openStructuredFilterFromExpandedWhere() {
+  collapseConditionInput("where");
+  ensureStructuredFilterRule();
+  filterBuilderOpen.value = true;
+}
+
+function addStructuredFilterRule() {
+  ensureStructuredFilterRule();
+  structuredFilterRules.value = [...structuredFilterRules.value, defaultStructuredFilterRule()];
+}
+
+function removeStructuredFilterRule(ruleId: string) {
+  structuredFilterRules.value = structuredFilterRules.value.filter((rule) => rule.id !== ruleId);
+  if (structuredFilterRules.value.length === 0) {
+    appliedStructuredWhereInput.value = "";
+  }
+}
+
+function updateStructuredFilterRule(ruleId: string, patch: Partial<StructuredFilterRule>) {
+  structuredFilterRules.value = structuredFilterRules.value.map((rule) => {
+    if (rule.id !== ruleId) return rule;
+    const next = { ...rule, ...patch };
+    if (!filterModeNeedsValue(next.mode)) next.rawValue = "";
+    return next;
+  });
+}
+
+function updateStructuredFilterRuleColumn(ruleId: string, columnName: string) {
+  updateStructuredFilterRule(ruleId, { columnName });
+  filterBuilderColumnSearch.value = "";
+}
+
+function handleFilterBuilderColumnSearchKeydown(event: KeyboardEvent) {
+  if (event.isComposing || event.key === "Process") {
+    event.stopPropagation();
+    return;
+  }
+  if (filterBuilderColumnSearchNavigationKeys.has(event.key)) return;
+  if (event.ctrlKey || event.metaKey || event.altKey) return;
+  if (event.key.length === 1 || event.key === "Backspace" || event.key === "Delete") {
+    // Let text editing stay in the search box without breaking Select navigation keys.
+    event.stopPropagation();
+  }
+}
+
+function resetStructuredFilters() {
+  appliedStructuredWhereInput.value = "";
+  structuredFilterRules.value = filterBuilderColumnOptions.value.length > 0 ? [defaultStructuredFilterRule()] : [];
+}
+
+async function clearAllFilters() {
+  whereFilterInput.value = "";
+  resetStructuredFilters();
+  clearLocalFilter();
+  if (canUseWhereSearch.value) await applyWhereFilter();
+}
+
+function buildGroupedWhere(conditions: string[], rules: StructuredFilterRule[]): string {
+  if (conditions.length === 0) return "";
+  if (conditions.length === 1) return conditions[0];
+
+  const groups: { conditions: string[]; conjunction: string }[] = [];
+  let current = { conditions: [conditions[0]], conjunction: "AND" };
+
+  for (let i = 1; i < conditions.length; i++) {
+    const conj = rules[i].conjunction;
+    if (conj !== current.conjunction) {
+      groups.push(current);
+      current = { conditions: [conditions[i]], conjunction: conj };
+    } else {
+      current.conditions.push(conditions[i]);
+    }
+  }
+  groups.push(current);
+
+  if (groups.length === 1) {
+    const g = groups[0];
+    return g.conditions.length > 1 ? `(${g.conditions.join(` ${g.conjunction} `)})` : g.conditions[0];
+  }
+
+  const groupClauses = groups.map((g) => {
+    const inner = g.conditions.join(` ${g.conjunction} `);
+    return g.conditions.length > 1 ? `(${inner})` : inner;
+  });
+
+  let result = groupClauses[0];
+  for (let i = 1; i < groupClauses.length; i++) {
+    result = `(${result}) ${groups[i].conjunction} (${groupClauses[i]})`;
+  }
+  return result;
+}
+
+async function applyStructuredFilters() {
+  if (!canUseWhereSearch.value) return;
+  appliedStructuredWhereInput.value = await buildStructuredWhereFromRules(structuredFilterRules.value);
+  filterBuilderOpen.value = false;
+  await applyWhereFilter();
+}
+
+watch([structuredFilterCacheKey, structuredFilterScopeKey], loadStructuredFilterStateForScope, { immediate: true });
+
+watch(filterBuilderOpen, (open) => {
+  if (!open) filterBuilderColumnSearch.value = "";
+});
+
+watch(
+  [structuredFilterRules, appliedStructuredWhereInput],
+  () => {
+    const columns = filterBuilderColumnOptions.value;
+    if (columns.length > 0 && structuredFilterRules.value.some((rule) => !columns.includes(rule.columnName))) {
+      structuredFilterRules.value = structuredFilterRules.value.map((rule) => (columns.includes(rule.columnName) ? rule : { ...rule, columnName: columns[0] ?? "" }));
+      return;
+    }
+    persistStructuredFilterState();
+  },
+  { deep: true },
+);
+
+function updateSuggestionPosition() {
+  nextTick(() => {
+    const input = searchInputRef.value;
+    const measure = measureRef.value;
+    if (!input || !measure) return;
+    const cursorPos = input.selectionStart ?? 0;
+    measure.textContent = searchText.value.slice(0, cursorPos);
+    suggestionLeft.value = measure.getBoundingClientRect().width;
+  });
+}
+
+watch(searchText, (val) => {
+  searchSuggestions.value = [];
+  if (!props.tableMeta?.columns?.length) return;
+
+  const trimmed = val.trim();
+  if (trimmed.length === 0) return;
+
+  const lastToken = trimmed.split(/[\s,()><=!&|]+/).pop() || "";
+  if (lastToken.length > 0) {
+    const tl = lastToken.toLowerCase();
+    searchSuggestions.value = props.tableMeta.columns
+      .map((c) => c.name)
+      .filter((n) => n.toLowerCase().startsWith(tl) && n.toLowerCase() !== tl)
+      .slice(0, 8);
+    suggestionIndex.value = 0;
+    updateSuggestionPosition();
+  }
+});
+
+function acceptSuggestion() {
+  const idx = suggestionIndex.value;
+  if (idx < 0 || idx >= searchSuggestions.value.length) return;
+  const sug = searchSuggestions.value[idx];
+
+  const lastWordMatch = searchText.value.match(/([^\s,()><=!&|]+)$/);
+  if (lastWordMatch) {
+    const lastWord = lastWordMatch[1];
+    const prefix = searchText.value.slice(0, -lastWord.length);
+    searchText.value = prefix + sug;
+  }
+  searchSuggestions.value = [];
+  suggestionIndex.value = -1;
+  searchInputRef.value?.focus();
+}
+
+function dismissSuggestions() {
+  searchSuggestions.value = [];
+  suggestionIndex.value = -1;
+}
+
+function navigateSuggestion(delta: number) {
+  if (searchSuggestions.value.length === 0) return;
+  suggestionIndex.value = Math.min(Math.max(suggestionIndex.value + delta, 0), searchSuggestions.value.length - 1);
+}
+
+function focusSearch(): boolean {
+  searchOverlayVisible.value = true;
+  nextTick(() => {
+    const input = searchInputRef.value;
+    if (!input) return;
+    input.focus();
+    input.select();
+    updateSuggestionPosition();
+  });
+  return true;
+}
+
+function closeSearch() {
+  searchOverlayVisible.value = false;
+  searchText.value = "";
+  searchSuggestions.value = [];
+}
+
+const PAIRS: Record<string, string> = { "'": "'", '"': '"', "(": ")" };
+
+function onSearchKeydown(e: KeyboardEvent) {
+  if (e.key in PAIRS && !e.ctrlKey && !e.metaKey) {
+    const input = e.target as HTMLInputElement;
+    const start = input.selectionStart ?? 0;
+    const end = input.selectionEnd ?? 0;
+    const close = PAIRS[e.key];
+
+    if (start !== end) {
+      // Wrap selection: 'text' → 'text'
+      e.preventDefault();
+      const selected = searchText.value.slice(start, end);
+      searchText.value = searchText.value.slice(0, start) + e.key + selected + close + searchText.value.slice(end);
+      nextTick(() => {
+        input.setSelectionRange(start + 1 + selected.length, start + 1 + selected.length);
+      });
+      suggestionIndex.value = -1;
+      return;
+    }
+
+    if (e.key === close && searchText.value[start] === close) {
+      // Cursor before matching close char → skip over it (only for quotes)
+      e.preventDefault();
+      input.setSelectionRange(start + 1, start + 1);
+      return;
+    }
+
+    e.preventDefault();
+    searchText.value = searchText.value.slice(0, start) + e.key + close + searchText.value.slice(end);
+    nextTick(() => {
+      input.setSelectionRange(start + 1, start + 1);
+    });
+    suggestionIndex.value = -1;
+    return;
+  }
+
+  if (searchSuggestions.value.length > 0) {
+    if (e.key === "Tab") {
+      e.preventDefault();
+      acceptSuggestion();
+      return;
+    }
+    if (isCancelSearchShortcut(e)) {
+      e.preventDefault();
+      dismissSuggestions();
+      return;
+    }
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      navigateSuggestion(1);
+      return;
+    }
+    if (e.key === "ArrowUp") {
+      e.preventDefault();
+      navigateSuggestion(-1);
+      return;
+    }
+  }
+  if (isCancelSearchShortcut(e)) {
+    e.preventDefault();
+    closeSearch();
+    return;
+  }
+  if (e.key === "Enter") {
+    e.preventDefault();
+    navigateMatch(e.shiftKey ? -1 : 1);
+  }
+}
+
+// --- WHERE filter input suggestions ---
+function updateWhereSuggestionPosition() {
+  nextTick(() => {
+    const input = conditionEditorRef("where");
+    if (!input) return;
+    const inputRect = input.getBoundingClientRect();
+    whereSuggestionPosition.value = getDataGridConditionSuggestionPosition(inputRect, { viewportWidth: window.innerWidth });
+  });
+}
+
+function acceptWhereSuggestion() {
+  const idx = whereSuggestionIndex.value;
+  if (idx < 0 || idx >= whereSuggestions.value.length) return;
+  const sug = whereSuggestions.value[idx];
+  if (sug.kind === "history") {
+    whereFilterInput.value = sug.value;
+    whereSuggestions.value = [];
+    whereSuggestionIndex.value = -1;
+    whereHistoryMenuOpen.value = false;
+    conditionEditorRef("where")?.focus();
+    return;
+  }
+  const lastWordMatch = whereFilterInput.value.match(/([^\s,()><=!&|]+)$/);
+  if (lastWordMatch) {
+    const lastWord = lastWordMatch[1];
+    const prefix = whereFilterInput.value.slice(0, -lastWord.length);
+    whereFilterInput.value = prefix + sug.value;
+  }
+  whereSuggestions.value = [];
+  whereSuggestionIndex.value = -1;
+  whereHistoryMenuOpen.value = false;
+  conditionEditorRef("where")?.focus();
+}
+
+function dismissWhereSuggestions() {
+  whereSuggestions.value = [];
+  whereSuggestionIndex.value = -1;
+  whereHistoryMenuOpen.value = false;
+  hideConditionHistoryPreview();
+}
+
+function eventTargetInside(event: Event, ...elements: Array<HTMLElement | undefined>): boolean {
+  const path = typeof event.composedPath === "function" ? event.composedPath() : [];
+  const target = event.target instanceof Node ? event.target : null;
+  return elements.some((element) => element && (path.includes(element) || (target ? element.contains(target) : false)));
+}
+
+function onConditionSuggestionDocumentPointerDown(event: PointerEvent) {
+  const whereExpandedPane = whereFilterOverlayRef.value?.parentElement ?? undefined;
+  const orderByExpandedPane = orderByOverlayRef.value?.parentElement ?? undefined;
+  if (!eventTargetInside(event, whereFilterInputRef.value, whereFilterOverlayRef.value, whereConditionPaneRef.value, whereExpandedPane, whereSuggestionDropdownRef.value)) {
+    dismissWhereSuggestions();
+  }
+  if (!eventTargetInside(event, orderByInputRef.value, orderByOverlayRef.value, orderByConditionPaneRef.value, orderByExpandedPane, orderBySuggestionDropdownRef.value)) {
+    dismissOrderBySuggestions();
+  }
+}
+
+function navigateWhereSuggestion(delta: number) {
+  if (whereSuggestions.value.length === 0) return;
+  if (whereSuggestionIndex.value < 0) {
+    whereSuggestionIndex.value = delta > 0 ? 0 : whereSuggestions.value.length - 1;
+    return;
+  }
+  whereSuggestionIndex.value = Math.min(Math.max(whereSuggestionIndex.value + delta, 0), whereSuggestions.value.length - 1);
+}
+
+function openWhereHistoryMenu() {
+  if (showWhereSuggestionDropdown.value) {
+    dismissWhereSuggestions();
+    return;
+  }
+  conditionEditorRef("where")?.focus();
+  whereHistoryMenuOpen.value = true;
+  const history = loadDataGridConditionHistory("where", conditionHistoryScope.value);
+  whereSuggestions.value = history.map((value) => ({ value, kind: "history" }));
+  whereSuggestionIndex.value = -1;
+  updateWhereSuggestionPosition();
+}
+
+function clearWhereFilterInput() {
+  suppressWhereHistoryOnNextEmptyInput = true;
+  whereFilterInput.value = "";
+  dismissWhereSuggestions();
+  void applyWhereFilter();
+}
+
+function deleteWhereHistorySuggestion(value: string) {
+  const history = forgetDataGridConditionHistory("where", conditionHistoryScope.value, value);
+  whereSuggestions.value = history.map((item) => ({ value: item, kind: "history" }));
+  whereSuggestionIndex.value = whereSuggestions.value.length ? Math.min(whereSuggestionIndex.value, whereSuggestions.value.length - 1) : -1;
+  whereHistoryMenuOpen.value = true;
+  updateWhereSuggestionPosition();
+}
+
+function onWhereFilterInput(event: Event) {
+  const input = event.target instanceof HTMLTextAreaElement ? event.target : null;
+  if (!input) return;
+  suppressNextWhereWatchResize = true;
+  const nextValue = normalizeConditionInputValue(input.value);
+  if (nextValue !== input.value) {
+    whereFilterInput.value = nextValue;
+    previousWhereFilterInputValue = nextValue;
+    nextTick(() => input.setSelectionRange(nextValue.length, nextValue.length));
+    resizeConditionInput("where", { expandFromFocus: true, focusOverlay: true, immediateHeight: true });
+    return;
+  }
+  if (
+    insertedSqlSingleQuoteAtCaret({
+      previousValue: previousWhereFilterInputValue,
+      nextValue,
+      selectionStart: input.selectionStart,
+    })
+  ) {
+    const caret = input.selectionStart ?? nextValue.length;
+    const pairedValue = `${nextValue.slice(0, caret)}'${nextValue.slice(caret)}`;
+    whereFilterInput.value = pairedValue;
+    previousWhereFilterInputValue = pairedValue;
+    nextTick(() => input.setSelectionRange(caret, caret));
+    resizeConditionInput("where", { expandFromFocus: true, focusOverlay: true, immediateHeight: true });
+    return;
+  }
+  const nextCaret = caretPositionInsideInsertedSqlSingleQuotes({
+    previousValue: previousWhereFilterInputValue,
+    nextValue,
+    selectionStart: input.selectionStart,
+  });
+  previousWhereFilterInputValue = nextValue;
+  resizeConditionInput("where", { expandFromFocus: true, focusOverlay: true, immediateHeight: true });
+  if (nextCaret == null) return;
+  nextTick(() => input.setSelectionRange(nextCaret, nextCaret));
+}
+
+watch(whereFilterInput, (val) => {
+  emit("update:whereInput", currentWhereInput() ?? "");
+  persistStructuredFilterState();
+  previousWhereFilterInputValue = val;
+  if (suppressNextWhereWatchResize) {
+    suppressNextWhereWatchResize = false;
+  } else {
+    resizeConditionInput("where");
+  }
+  whereSuggestions.value = [];
+  whereHistoryMenuOpen.value = false;
+  const trimmed = val.trim();
+  if (trimmed.length === 0) {
+    if (suppressWhereHistoryOnNextEmptyInput) {
+      suppressWhereHistoryOnNextEmptyInput = false;
+    }
+    return;
+  }
+  suppressWhereHistoryOnNextEmptyInput = false;
+  if (!props.tableMeta?.columns?.length) return;
+  const lastToken = trimmed.split(/[\s,()><=!&|]+/).pop() || "";
+  if (lastToken.length > 0) {
+    const tl = lastToken.toLowerCase();
+    whereSuggestions.value = props.tableMeta.columns
+      .map((c) => c.name)
+      .filter((n) => n.toLowerCase().startsWith(tl) && n.toLowerCase() !== tl)
+      .slice(0, 8)
+      .map((value) => ({ value, kind: "column" }));
+    whereSuggestionIndex.value = 0;
+    updateWhereSuggestionPosition();
+  }
+});
+
+function onWhereFilterKeydown(e: KeyboardEvent) {
+  if (e.key in PAIRS && !e.ctrlKey && !e.metaKey) {
+    const input = e.target as HTMLTextAreaElement;
+    const start = input.selectionStart ?? 0;
+    const end = input.selectionEnd ?? 0;
+    const close = PAIRS[e.key];
+    if (start !== end) {
+      e.preventDefault();
+      const selected = whereFilterInput.value.slice(start, end);
+      whereFilterInput.value = whereFilterInput.value.slice(0, start) + e.key + selected + close + whereFilterInput.value.slice(end);
+      nextTick(() => {
+        input.setSelectionRange(start + 1 + selected.length, start + 1 + selected.length);
+      });
+      whereSuggestionIndex.value = -1;
+      return;
+    }
+    if (e.key === close && whereFilterInput.value[start] === close) {
+      e.preventDefault();
+      input.setSelectionRange(start + 1, start + 1);
+      return;
+    }
+    e.preventDefault();
+    whereFilterInput.value = whereFilterInput.value.slice(0, start) + e.key + close + whereFilterInput.value.slice(end);
+    nextTick(() => {
+      input.setSelectionRange(start + 1, start + 1);
+    });
+    whereSuggestionIndex.value = -1;
+    return;
+  }
+  if (whereSuggestions.value.length > 0) {
+    if (e.key === "Tab") {
+      e.preventDefault();
+      acceptWhereSuggestion();
+      return;
+    }
+    if (e.key === "Escape") {
+      e.preventDefault();
+      dismissWhereSuggestions();
+      return;
+    }
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      navigateWhereSuggestion(1);
+      return;
+    }
+    if (e.key === "ArrowUp") {
+      e.preventDefault();
+      navigateWhereSuggestion(-1);
+      return;
+    }
+  }
+  if (e.key === "Enter") {
+    e.preventDefault();
+    if (whereSuggestions.value.length > 0 && whereSuggestionIndex.value >= 0) {
+      acceptWhereSuggestion();
+      return;
+    }
+    applyWhereFilter();
+  }
+}
+
+// --- ORDER BY input suggestions ---
+function updateOrderBySuggestionPosition() {
+  nextTick(() => {
+    const input = conditionEditorRef("orderBy");
+    if (!input) return;
+    const inputRect = input.getBoundingClientRect();
+    orderBySuggestionPosition.value = getDataGridConditionSuggestionPosition(inputRect, { viewportWidth: window.innerWidth });
+  });
+}
+
+function acceptOrderBySuggestion() {
+  const idx = orderBySuggestionIndex.value;
+  if (idx < 0 || idx >= orderBySuggestions.value.length) return;
+  const sug = orderBySuggestions.value[idx];
+  if (sug.kind === "history") {
+    orderByInput.value = sug.value;
+    orderBySuggestions.value = [];
+    orderBySuggestionIndex.value = -1;
+    orderByHistoryMenuOpen.value = false;
+    conditionEditorRef("orderBy")?.focus();
+    return;
+  }
+  const lastWordMatch = orderByInput.value.match(/([^\s,()]+)$/);
+  if (lastWordMatch) {
+    const lastWord = lastWordMatch[1];
+    const prefix = orderByInput.value.slice(0, -lastWord.length);
+    orderByInput.value = prefix + sug.value;
+  }
+  orderBySuggestions.value = [];
+  orderBySuggestionIndex.value = -1;
+  orderByHistoryMenuOpen.value = false;
+  conditionEditorRef("orderBy")?.focus();
+}
+
+function dismissOrderBySuggestions() {
+  orderBySuggestions.value = [];
+  orderBySuggestionIndex.value = -1;
+  orderByHistoryMenuOpen.value = false;
+  hideConditionHistoryPreview();
+}
+
+function navigateOrderBySuggestion(delta: number) {
+  if (orderBySuggestions.value.length === 0) return;
+  if (orderBySuggestionIndex.value < 0) {
+    orderBySuggestionIndex.value = delta > 0 ? 0 : orderBySuggestions.value.length - 1;
+    return;
+  }
+  orderBySuggestionIndex.value = Math.min(Math.max(orderBySuggestionIndex.value + delta, 0), orderBySuggestions.value.length - 1);
+}
+
+function openOrderByHistoryMenu() {
+  if (showOrderBySuggestionDropdown.value) {
+    dismissOrderBySuggestions();
+    return;
+  }
+  conditionEditorRef("orderBy")?.focus();
+  orderByHistoryMenuOpen.value = true;
+  const history = loadDataGridConditionHistory("orderBy", conditionHistoryScope.value);
+  orderBySuggestions.value = history.map((value) => ({ value, kind: "history" }));
+  orderBySuggestionIndex.value = -1;
+  updateOrderBySuggestionPosition();
+}
+
+function clearOrderByInput() {
+  suppressOrderByHistoryOnNextEmptyInput = true;
+  orderByInput.value = "";
+  dismissOrderBySuggestions();
+  void applyOrderBySearch();
+}
+
+function deleteOrderByHistorySuggestion(value: string) {
+  const history = forgetDataGridConditionHistory("orderBy", conditionHistoryScope.value, value);
+  orderBySuggestions.value = history.map((item) => ({ value: item, kind: "history" }));
+  orderBySuggestionIndex.value = orderBySuggestions.value.length ? Math.min(orderBySuggestionIndex.value, orderBySuggestions.value.length - 1) : -1;
+  orderByHistoryMenuOpen.value = true;
+  updateOrderBySuggestionPosition();
+}
+
+watch(orderByInput, (val) => {
+  emit("update:orderByInput", val);
+  if (suppressNextOrderByWatchResize) {
+    suppressNextOrderByWatchResize = false;
+  } else {
+    resizeConditionInput("orderBy");
+  }
+  orderBySuggestions.value = [];
+  orderByHistoryMenuOpen.value = false;
+  const trimmed = val.trim();
+  if (trimmed.length === 0) {
+    if (suppressOrderByHistoryOnNextEmptyInput) {
+      suppressOrderByHistoryOnNextEmptyInput = false;
+    }
+    return;
+  }
+  suppressOrderByHistoryOnNextEmptyInput = false;
+  if (!props.tableMeta?.columns?.length) return;
+  const lastToken = trimmed.split(/[\s,()]+/).pop() || "";
+  if (lastToken.length > 0 && !["asc", "desc"].includes(lastToken.toLowerCase())) {
+    const tl = lastToken.toLowerCase();
+    orderBySuggestions.value = props.tableMeta.columns
+      .map((c) => c.name)
+      .filter((n) => n.toLowerCase().startsWith(tl) && n.toLowerCase() !== tl)
+      .slice(0, 8)
+      .map((value) => ({ value, kind: "column" }));
+    orderBySuggestionIndex.value = 0;
+    updateOrderBySuggestionPosition();
+  }
+});
+
+function onOrderByInput(event: Event) {
+  const input = event.target instanceof HTMLTextAreaElement ? event.target : null;
+  if (!input) return;
+  suppressNextOrderByWatchResize = true;
+  const nextValue = normalizeConditionInputValue(input.value);
+  if (nextValue !== input.value) {
+    orderByInput.value = nextValue;
+    nextTick(() => input.setSelectionRange(nextValue.length, nextValue.length));
+  }
+  resizeConditionInput("orderBy", { expandFromFocus: true, focusOverlay: true, immediateHeight: true });
+}
+
+function onOrderByKeydown(e: KeyboardEvent) {
+  if (orderBySuggestions.value.length > 0) {
+    if (e.key === "Tab") {
+      e.preventDefault();
+      acceptOrderBySuggestion();
+      return;
+    }
+    if (e.key === "Escape") {
+      e.preventDefault();
+      dismissOrderBySuggestions();
+      return;
+    }
+    if (e.key === "ArrowDown") {
+      e.preventDefault();
+      navigateOrderBySuggestion(1);
+      return;
+    }
+    if (e.key === "ArrowUp") {
+      e.preventDefault();
+      navigateOrderBySuggestion(-1);
+      return;
+    }
+  }
+  if (e.key === "Enter") {
+    e.preventDefault();
+    if (orderBySuggestions.value.length > 0 && orderBySuggestionIndex.value >= 0) {
+      acceptOrderBySuggestion();
+      return;
+    }
+    applyOrderBySearch();
+  }
+}
+
+const isApplyingWhere = ref(false);
+const rowStatusFilter = ref<RowStatusFilter>("all");
+const gridRef = ref<HTMLDivElement>();
+const dataGridTopbarRef = ref<HTMLDivElement>();
+const headerRef = ref<HTMLDivElement>();
+const gridScrollbarGutter = ref(0);
+const gridHorizontalScrollbarTrackRef = ref<HTMLDivElement>();
+const gridHorizontalScrollbarThumbRef = ref<HTMLDivElement>();
+const gridVerticalScrollbarTrackRef = ref<HTMLDivElement>();
+const gridVerticalScrollbarThumbRef = ref<HTMLDivElement>();
+const hasGridHorizontalOverflow = ref(false);
+const hasGridVerticalOverflow = ref(false);
+let gridHorizontalScrollbarThumbLeftPercent = 0;
+let gridHorizontalScrollbarThumbWidthPercent = 100;
+let gridVerticalScrollbarThumbTopPercent = 0;
+let gridVerticalScrollbarThumbHeightPercent = 100;
+let gridHorizontalScrollbarFrame = 0;
+let gridHorizontalScrollbarDragFrame = 0;
+let gridHorizontalScrollbarPendingClientX = 0;
+let gridVerticalScrollbarDragFrame = 0;
+let gridVerticalScrollbarPendingClientY = 0;
+let gridHorizontalScrollbarResizeObserver: ResizeObserver | null = null;
+let dataGridTopbarResizeObserver: ResizeObserver | null = null;
+let cellEditResizeObserver: ResizeObserver | null = null;
+let resetCellEditTextareaScrollOnResize = false;
+let gridHorizontalScrollbarDragState: {
+  scroller: HTMLElement;
+  trackRect: DOMRect;
+  thumbOffsetPx: number;
+  maxScrollLeft: number;
+} | null = null;
+let gridVerticalScrollbarDragState: {
+  scroller: HTMLElement;
+  trackRect: DOMRect;
+  thumbOffsetPx: number;
+  maxScrollTop: number;
+} | null = null;
+const GRID_HORIZONTAL_SCROLLBAR_DRAGGING_CLASS = "data-grid-horizontal-scrollbar--dragging";
+const GRID_VERTICAL_SCROLLBAR_DRAGGING_CLASS = "data-grid-vertical-scrollbar--dragging";
+const hiddenColumnIndexes = ref<Set<number>>(new Set());
+const nullColumnsHidden = ref(false);
+const autoHiddenNullColumnIndexes = ref<Set<number>>(new Set());
+const highlightedColumnIndex = ref<number | null>(null);
+let highlightedColumnTimer = 0;
+
+const goToColumnOpen = ref(false);
+const goToColumnSearch = ref("");
+const columnOrderKeys = computed(() => uniqueDataGridColumnOrderKeys(props.result.columns, props.sourceColumns));
+const columnLayoutScopeKey = computed(() =>
+  dataGridColumnLayoutScopeKey({
+    connectionId: props.connectionId,
+    database: props.database,
+    schema: props.schema,
+    context: props.context,
+    tableSchema: props.tableMeta?.schema,
+    tableName: props.tableMeta?.tableName,
+    sql: props.sql,
+    columns: props.result.columns,
+    sourceColumns: props.sourceColumns,
+  }),
+);
+const tableColumnOrderScopeKey = computed(() => {
+  if (props.context !== "table-data" || !props.connectionId || !props.database || !props.tableMeta?.tableName) return "";
+  return tableDataGridColumnOrderScopeKey({
+    connectionId: props.connectionId,
+    database: props.database,
+    schema: props.tableMeta.schema,
+    tableName: props.tableMeta.tableName,
+  });
+});
+const persistedColumnOrderKeys = ref<string[]>([]);
+const displayableColumnIndexes = computed(() =>
+  props.result.columns
+    .map((column, index) => ({ column, index }))
+    .filter(({ column, index }) => !props.result.hidden_column_indexes?.includes(index) && !isHiddenGridColumn(props.databaseType, column, props.tableMeta?.primaryKeys ?? [], props.tableMeta?.tableType))
+    .map(({ index }) => index),
+);
+const goToColumnItems = computed(() =>
+  buildDataGridColumnLookupItems({
+    columns: props.result.columns,
+    sourceColumns: props.sourceColumns,
+    displayableIndexes: displayableColumnIndexes.value,
+    commentByColumn: columnCommentMap.value,
+  }),
+);
+const filteredGoToColumns = computed(() => {
+  return filterDataGridColumnLookupItems(goToColumnItems.value, goToColumnSearch.value);
+});
+const orderedDisplayableColumnIndexes = computed(() =>
+  orderedColumnIndexes({
+    availableIndexes: displayableColumnIndexes.value,
+    columnKeys: columnOrderKeys.value,
+    orderedKeys: persistedColumnOrderKeys.value,
+  }),
+);
+const visibleColumnIndexes = computed(() => visibleColumnIndexesForFilter(orderedDisplayableColumnIndexes.value, hiddenColumnIndexes.value));
+const visibleColumns = computed(() => visibleColumnIndexes.value.map((index) => props.result.columns[index]));
+const visibleSourceColumns = computed(() => {
+  if (!props.sourceColumns || props.sourceColumns.length !== props.result.columns.length) return undefined;
+  return visibleColumnIndexes.value.map((index) => props.sourceColumns?.[index]);
+});
+const tableColumnTypesByName = computed(() => {
+  const map = new Map<string, string>();
+  for (const column of props.tableMeta?.columns ?? []) {
+    map.set(column.name.toLocaleLowerCase(), column.data_type);
+  }
+  return map;
+});
+const visibleColumnTypes = computed(() =>
+  visibleColumnIndexes.value.map((index) => {
+    const resultColumn = props.result.columns[index]?.toLocaleLowerCase();
+    const sourceColumn = props.sourceColumns?.[index]?.toLocaleLowerCase();
+    return (sourceColumn ? tableColumnTypesByName.value.get(sourceColumn) : undefined) || (resultColumn ? tableColumnTypesByName.value.get(resultColumn) : undefined) || props.result.column_types?.[index];
+  }),
+);
+const visibleColumnCount = computed(() => visibleColumnIndexes.value.length);
+
+/** Preview actions from the result preview registry for the current result. */
+const previewActions = computed(() => {
+  if (!props.result) return [];
+  return getApplicablePreviewActions(props.result);
+});
+const displayableColumnCount = computed(() => displayableColumnIndexes.value.length);
+const hiddenColumnCount = computed(() => displayableColumnCount.value - visibleColumnCount.value);
+const hasCustomColumnOrder = computed(() => !isDefaultColumnOrder(displayableColumnIndexes.value, orderedDisplayableColumnIndexes.value));
+const allNullColumnIndexesForResult = computed(() => allNullColumnIndexes(props.result.rows, displayableColumnIndexes.value));
+const allNullColumnCount = computed(() => allNullColumnIndexesForResult.value.length);
+const canToggleAllNullColumns = computed(() => nullColumnsHidden.value || (allNullColumnCount.value > 0 && displayableColumnCount.value > 1));
+function filteredColumnVisibilityOptions(query: string) {
+  const displayable = new Set(displayableColumnIndexes.value);
+  return filterColumnVisibilityOptions(props.result.columns, query, { sourceColumns: props.sourceColumns, commentByColumn: columnCommentMap.value }).filter((option) => displayable.has(option.index));
+}
+function isColumnVisible(columnIndex: number): boolean {
+  return !hiddenColumnIndexes.value.has(columnIndex);
+}
+function toggleColumnVisibility(columnIndex: number) {
+  hiddenColumnIndexes.value = nextHiddenColumnIndexes({
+    columnIndex,
+    hiddenIndexes: hiddenColumnIndexes.value,
+    totalColumns: displayableColumnCount.value,
+  });
+}
+function showAllColumns() {
+  hiddenColumnIndexes.value = new Set();
+}
+function invertColumnVisibility() {
+  hiddenColumnIndexes.value = invertedHiddenColumnIndexes(displayableColumnIndexes.value, hiddenColumnIndexes.value);
+}
+function loadColumnOrder() {
+  const tableOrder = tableColumnOrderScopeKey.value ? loadTableDataGridColumnOrder(tableColumnOrderScopeKey.value) : [];
+  persistedColumnOrderKeys.value = tableOrder.length ? tableOrder : loadDataGridColumnOrder(columnLayoutScopeKey.value, columnOrderKeys.value);
+}
+function onTableDataGridColumnOrderChanged(event: Event) {
+  if (!(event instanceof CustomEvent)) return;
+  const detail = event.detail as TableDataGridColumnOrderChangedDetail | undefined;
+  if (!detail || detail.scopeKey !== tableColumnOrderScopeKey.value) return;
+  loadColumnOrder();
+  nextTick(refreshGridScrollerMetrics);
+}
+function persistColumnOrder(indexes: number[]) {
+  const tableScopeKey = tableColumnOrderScopeKey.value;
+  if (isDefaultColumnOrder(displayableColumnIndexes.value, indexes)) {
+    removeDataGridColumnOrder(columnLayoutScopeKey.value);
+    if (tableScopeKey) {
+      removeTableDataGridColumnOrder(tableScopeKey);
+      notifyTableDataGridColumnOrderChanged(tableScopeKey);
+    }
+    persistedColumnOrderKeys.value = [];
+    return;
+  }
+  const keys = columnOrderKeysForIndexes(indexes, columnOrderKeys.value);
+  persistedColumnOrderKeys.value = keys;
+  saveDataGridColumnOrder(columnLayoutScopeKey.value, columnOrderKeys.value, keys);
+  if (tableScopeKey) {
+    saveTableDataGridColumnOrder(tableScopeKey, keys);
+    notifyTableDataGridColumnOrderChanged(tableScopeKey);
+  }
+}
+function resetColumnOrder() {
+  removeDataGridColumnOrder(columnLayoutScopeKey.value);
+  const tableScopeKey = tableColumnOrderScopeKey.value;
+  if (tableScopeKey) {
+    removeTableDataGridColumnOrder(tableScopeKey);
+    notifyTableDataGridColumnOrderChanged(tableScopeKey);
+  }
+  persistedColumnOrderKeys.value = [];
+  nextTick(refreshGridScrollerMetrics);
+}
+function showAllNullColumns() {
+  hiddenColumnIndexes.value = removeAutoHiddenColumnIndexes(hiddenColumnIndexes.value, autoHiddenNullColumnIndexes.value);
+  autoHiddenNullColumnIndexes.value = new Set();
+  nullColumnsHidden.value = false;
+}
+function hideAllNullColumns() {
+  const next = hiddenColumnIndexesWithAllNullColumns({
+    availableIndexes: displayableColumnIndexes.value,
+    hiddenIndexes: hiddenColumnIndexes.value,
+    allNullIndexes: new Set(allNullColumnIndexesForResult.value),
+  });
+  hiddenColumnIndexes.value = next.hiddenIndexes;
+  autoHiddenNullColumnIndexes.value = next.autoHiddenIndexes;
+  nullColumnsHidden.value = next.autoHiddenIndexes.size > 0;
+}
+function toggleAllNullColumns() {
+  if (nullColumnsHidden.value) {
+    showAllNullColumns();
+  } else {
+    hideAllNullColumns();
+  }
+}
+watch(allNullColumnIndexesForResult, () => {
+  if (!nullColumnsHidden.value) return;
+  hiddenColumnIndexes.value = removeAutoHiddenColumnIndexes(hiddenColumnIndexes.value, autoHiddenNullColumnIndexes.value);
+  autoHiddenNullColumnIndexes.value = new Set();
+  hideAllNullColumns();
+});
+watch([columnLayoutScopeKey, tableColumnOrderScopeKey], loadColumnOrder, { immediate: true });
+const firstVisibleColumnIndex = computed(() => visibleColumnIndexes.value[0] ?? 0);
+function actualColumnIndex(visibleColumnIndex: number): number {
+  return visibleColumnIndexes.value[visibleColumnIndex] ?? visibleColumnIndex;
+}
+function scrollToColumn(columnIndex: number) {
+  goToColumnOpen.value = false;
+  goToColumnSearch.value = "";
+  scrollToColumnIndex(columnIndex);
+  gridRef.value?.focus();
+}
+
+function onGoToColumnKeydown(event: KeyboardEvent) {
+  if (event.key === "Escape") {
+    goToColumnOpen.value = false;
+    goToColumnSearch.value = "";
+  }
+}
+
+watch(goToColumnOpen, (open) => {
+  if (!open) goToColumnSearch.value = "";
+});
+
+function matchesTableInfoColumn(resultColumn: string, sourceColumn: string | undefined, columnName: string): boolean {
+  const target = columnName.toLocaleLowerCase();
+  return resultColumn.toLocaleLowerCase() === target || sourceColumn?.toLocaleLowerCase() === target;
+}
+function scrollToTableInfoColumn(columnName: string) {
+  const columnIndex = props.result.columns.findIndex((column, index) => matchesTableInfoColumn(column, props.sourceColumns?.[index], columnName));
+  scrollToColumnIndex(columnIndex);
+}
+function scrollToColumnIndex(columnIndex: number) {
+  if (columnIndex < 0 || !displayableColumnIndexes.value.includes(columnIndex)) return;
+
+  if (hiddenColumnIndexes.value.has(columnIndex)) {
+    hiddenColumnIndexes.value.delete(columnIndex);
+    hiddenColumnIndexes.value = new Set(hiddenColumnIndexes.value);
+  }
+
+  highlightedColumnIndex.value = columnIndex;
+  clearTimeout(highlightedColumnTimer);
+  highlightedColumnTimer = window.setTimeout(() => {
+    highlightedColumnIndex.value = null;
+  }, 1400);
+
+  nextTick(() => {
+    const visibleColIdx = visibleColumnIndexes.value.indexOf(columnIndex);
+    const scroller = gridRef.value?.querySelector<HTMLElement>(".data-grid-scroller");
+    if (visibleColIdx < 0 || !scroller) return;
+
+    const targetLeft = Math.max(0, columnContentOffsetLeft(visibleColIdx) - scroller.clientWidth / 2 + (renderedColumnWidths.value[visibleColIdx] ?? 0) / 2);
+    scroller.scrollLeft = targetLeft;
+    updateGridHorizontalViewport(scroller);
+    if (headerRef.value) {
+      headerRef.value.scrollLeft = scroller.scrollLeft;
+    }
+  });
+}
+
+// --- Column resize composable ---
+const columnWidthDensity = computed(() => settingsStore.editorSettings.columnWidthDensity);
+const { initColumnWidths, onResizeStart, autoFitColumn, renderedColumnWidths, totalWidth, columnVars, getIsResizing } = useDataGridColumnResize({
+  columns: visibleColumns,
+  sourceRows: computed(() => props.result.rows),
+  columnIndexes: visibleColumnIndexes,
+  density: columnWidthDensity,
+  compactColumnHeaderActions,
+});
+const gridStyle = computed(() => ({
+  ...columnVars.value,
+  "--header-total-w": dataGridHeaderContentWidth("var(--total-w)", gridScrollbarGutter.value),
+  "--grid-scrollbar-gutter": `${gridScrollbarGutter.value}px`,
+  [EDITOR_FONT_FAMILY_CSS_VAR]: settingsStore.editorSettings.fontFamily,
+  "--dbx-table-font-size": `${tableFontSize.value}px`,
+}));
+const gridHorizontalScrollLeft = ref(0);
+const gridViewportWidth = ref(0);
+const renderedColumnOffsets = computed(() => {
+  const widths = renderedColumnWidths.value;
+  const offsets = Array.from({ length: widths.length + 1 }, () => 0);
+  offsets[0] = 0;
+  for (let index = 0; index < widths.length; index++) {
+    offsets[index + 1] = offsets[index] + (widths[index] ?? 0);
+  }
+  return offsets;
+});
+
+function updateGridHorizontalViewport(element: HTMLElement) {
+  const nextScrollLeft = element.scrollLeft;
+  const nextViewportWidth = element.clientWidth;
+  const horizontalChanged = gridHorizontalScrollLeft.value !== nextScrollLeft || gridViewportWidth.value !== nextViewportWidth;
+  if (gridHorizontalScrollLeft.value !== nextScrollLeft) gridHorizontalScrollLeft.value = nextScrollLeft;
+  if (gridViewportWidth.value !== nextViewportWidth) gridViewportWidth.value = nextViewportWidth;
+  if (horizontalChanged) updateGridHorizontalScrollbar(element);
+  updateGridVerticalScrollbar(element);
+}
+
+function gridScrollerElement(): HTMLElement | null {
+  return gridRef.value?.querySelector<HTMLElement>(".data-grid-scroller") ?? null;
+}
+
+function updateGridHorizontalScrollbar(element: HTMLElement | null = gridScrollerElement()) {
+  if (!element) {
+    setGridHorizontalOverflow(false);
+    gridHorizontalScrollbarThumbLeftPercent = 0;
+    gridHorizontalScrollbarThumbWidthPercent = 100;
+    applyGridHorizontalScrollbarThumbStyle();
+    return;
+  }
+
+  const maxScrollLeft = Math.max(0, element.scrollWidth - element.clientWidth);
+  setGridHorizontalOverflow(maxScrollLeft > 1);
+
+  const rawThumbWidth = element.scrollWidth > 0 ? (element.clientWidth / element.scrollWidth) * 100 : 100;
+  const thumbWidth = Math.min(100, Math.max(6, rawThumbWidth));
+  const thumbTravel = Math.max(0, 100 - thumbWidth);
+  gridHorizontalScrollbarThumbWidthPercent = thumbWidth;
+  gridHorizontalScrollbarThumbLeftPercent = maxScrollLeft > 0 ? (element.scrollLeft / maxScrollLeft) * thumbTravel : 0;
+  if (!applyGridHorizontalScrollbarThumbStyle() && hasGridHorizontalOverflow.value) {
+    nextTick(applyGridHorizontalScrollbarThumbStyle);
+  }
+}
+
+function updateGridVerticalScrollbar(element: HTMLElement | null = gridScrollerElement()) {
+  if (!element) {
+    setGridVerticalOverflow(false);
+    gridVerticalScrollbarThumbTopPercent = 0;
+    gridVerticalScrollbarThumbHeightPercent = 100;
+    applyGridVerticalScrollbarThumbStyle();
+    return;
+  }
+
+  const maxScrollTop = Math.max(0, element.scrollHeight - element.clientHeight);
+  setGridVerticalOverflow(maxScrollTop > 1);
+
+  const rawThumbHeight = element.scrollHeight > 0 ? (element.clientHeight / element.scrollHeight) * 100 : 100;
+  const thumbHeight = Math.min(100, Math.max(6, rawThumbHeight));
+  const thumbTravel = Math.max(0, 100 - thumbHeight);
+  gridVerticalScrollbarThumbHeightPercent = thumbHeight;
+  gridVerticalScrollbarThumbTopPercent = maxScrollTop > 0 ? (element.scrollTop / maxScrollTop) * thumbTravel : 0;
+  if (!applyGridVerticalScrollbarThumbStyle() && hasGridVerticalOverflow.value) {
+    nextTick(applyGridVerticalScrollbarThumbStyle);
+  }
+}
+
+function setGridHorizontalOverflow(overflow: boolean) {
+  if (hasGridHorizontalOverflow.value === overflow) return;
+  const scroller = gridScrollerElement();
+  const preserveBottom = overflow && !!scroller && isDataGridAtScrollBottom(scroller);
+  hasGridHorizontalOverflow.value = overflow;
+  if (!overflow) return;
+  nextTick(() => {
+    applyGridHorizontalScrollbarThumbStyle();
+    if (!preserveBottom || gridScrollerElement() !== scroller) return;
+    // The custom horizontal scrollbar changes the scrollable geometry after render;
+    // restore bottom anchoring through the normal handlers so every grid mode stays synchronized.
+    scroller.scrollTop = dataGridBottomScrollTop(scroller);
+    if (useCanvasGridRows.value) {
+      onCanvasScroll({ target: scroller } as unknown as Event);
+    } else {
+      onScrollerScroll({ target: scroller } as unknown as Event);
+    }
+  });
+}
+
+function setGridVerticalOverflow(overflow: boolean) {
+  if (hasGridVerticalOverflow.value === overflow) return;
+  hasGridVerticalOverflow.value = overflow;
+  if (overflow) nextTick(applyGridVerticalScrollbarThumbStyle);
+}
+
+function applyGridHorizontalScrollbarThumbStyle(): boolean {
+  const thumb = gridHorizontalScrollbarThumbRef.value;
+  if (!thumb) return false;
+  // Scroll thumb position changes on every drag frame; update it outside Vue's
+  // render path so large result grids do not re-render while the user drags.
+  thumb.style.width = `${gridHorizontalScrollbarThumbWidthPercent}%`;
+  thumb.style.left = `${gridHorizontalScrollbarThumbLeftPercent}%`;
+  return true;
+}
+
+function applyGridVerticalScrollbarThumbStyle(): boolean {
+  const thumb = gridVerticalScrollbarThumbRef.value;
+  if (!thumb) return false;
+  thumb.style.height = `${gridVerticalScrollbarThumbHeightPercent}%`;
+  thumb.style.top = `${gridVerticalScrollbarThumbTopPercent}%`;
+  return true;
+}
+
+function setGridHorizontalScrollbarDragging(dragging: boolean) {
+  gridHorizontalScrollbarTrackRef.value?.classList.toggle(GRID_HORIZONTAL_SCROLLBAR_DRAGGING_CLASS, dragging);
+}
+
+function setGridVerticalScrollbarDragging(dragging: boolean) {
+  gridVerticalScrollbarTrackRef.value?.classList.toggle(GRID_VERTICAL_SCROLLBAR_DRAGGING_CLASS, dragging);
+}
+
+function scheduleGridHorizontalScrollbarUpdate() {
+  if (gridHorizontalScrollbarFrame) return;
+  const update = () => {
+    gridHorizontalScrollbarFrame = 0;
+    updateGridHorizontalScrollbar();
+    updateGridVerticalScrollbar();
+  };
+  if (typeof requestAnimationFrame === "function") {
+    gridHorizontalScrollbarFrame = requestAnimationFrame(update);
+  } else {
+    window.setTimeout(update, 0);
+  }
+}
+
+function observeGridHorizontalScrollbarScroller() {
+  gridHorizontalScrollbarResizeObserver?.disconnect();
+  gridHorizontalScrollbarResizeObserver = null;
+  const scroller = gridScrollerElement();
+  if (scroller && typeof ResizeObserver !== "undefined") {
+    gridHorizontalScrollbarResizeObserver = new ResizeObserver(scheduleGridHorizontalScrollbarUpdate);
+    gridHorizontalScrollbarResizeObserver.observe(scroller);
+    for (const child of Array.from(scroller.children)) {
+      gridHorizontalScrollbarResizeObserver.observe(child);
+    }
+  }
+  scheduleGridHorizontalScrollbarUpdate();
+}
+
+function updateDataGridTopbarWidth() {
+  dataGridTopbarWidth.value = dataGridTopbarRef.value?.clientWidth ?? 0;
+}
+
+function observeDataGridTopbarWidth() {
+  dataGridTopbarResizeObserver?.disconnect();
+  dataGridTopbarResizeObserver = null;
+  const topbar = dataGridTopbarRef.value;
+  updateDataGridTopbarWidth();
+  if (topbar && typeof ResizeObserver !== "undefined") {
+    dataGridTopbarResizeObserver = new ResizeObserver(updateDataGridTopbarWidth);
+    dataGridTopbarResizeObserver.observe(topbar);
+  }
+}
+
+function applyPendingGridHorizontalScrollbarDrag() {
+  gridHorizontalScrollbarDragFrame = 0;
+  const dragState = gridHorizontalScrollbarDragState;
+  if (!dragState) return;
+
+  const thumbWidthPx = dragState.trackRect.width * (gridHorizontalScrollbarThumbWidthPercent / 100);
+  const maxThumbLeftPx = Math.max(1, dragState.trackRect.width - thumbWidthPx);
+  const thumbLeftPx = Math.min(maxThumbLeftPx, Math.max(0, gridHorizontalScrollbarPendingClientX - dragState.trackRect.left - dragState.thumbOffsetPx));
+  const scroller = dragState.scroller;
+  const nextScrollLeft = (thumbLeftPx / maxThumbLeftPx) * dragState.maxScrollLeft;
+  if (Math.abs(scroller.scrollLeft - nextScrollLeft) < 0.5) return;
+  scroller.scrollLeft = nextScrollLeft;
+  updateGridHorizontalViewport(scroller);
+  if (headerRef.value) headerRef.value.scrollLeft = scroller.scrollLeft;
+  if (useCanvasGridRows.value) {
+    drawCanvasGridNow();
+  }
+}
+
+function scheduleGridHorizontalScrollbarDrag(clientX: number) {
+  gridHorizontalScrollbarPendingClientX = clientX;
+  if (gridHorizontalScrollbarDragFrame) return;
+  // Pointermove can fire faster than paint; keep expensive canvas/layout work to one frame.
+  gridHorizontalScrollbarDragFrame = requestAnimationFrame(applyPendingGridHorizontalScrollbarDrag);
+}
+
+function flushGridHorizontalScrollbarDrag() {
+  if (!gridHorizontalScrollbarDragFrame) return;
+  cancelAnimationFrame(gridHorizontalScrollbarDragFrame);
+  applyPendingGridHorizontalScrollbarDrag();
+}
+
+function onGridHorizontalScrollbarPointerMove(event: PointerEvent) {
+  if (!gridHorizontalScrollbarDragState) return;
+  event.preventDefault();
+  scheduleGridHorizontalScrollbarDrag(event.clientX);
+}
+
+function stopGridHorizontalScrollbarDrag() {
+  if (!gridHorizontalScrollbarDragState) return;
+  flushGridHorizontalScrollbarDrag();
+  gridHorizontalScrollbarDragState = null;
+  setGridHorizontalScrollbarDragging(false);
+  window.removeEventListener("pointermove", onGridHorizontalScrollbarPointerMove, true);
+  window.removeEventListener("pointerup", stopGridHorizontalScrollbarDrag, true);
+  window.removeEventListener("pointercancel", stopGridHorizontalScrollbarDrag, true);
+  document.body.style.userSelect = "";
+}
+
+function stopGridVerticalScrollbarDrag() {
+  if (!gridVerticalScrollbarDragState) return;
+  flushGridVerticalScrollbarDrag();
+  gridVerticalScrollbarDragState = null;
+  setGridVerticalScrollbarDragging(false);
+  window.removeEventListener("pointermove", onGridVerticalScrollbarPointerMove, true);
+  window.removeEventListener("pointerup", stopGridVerticalScrollbarDrag, true);
+  window.removeEventListener("pointercancel", stopGridVerticalScrollbarDrag, true);
+  document.body.style.userSelect = "";
+}
+
+function startGridHorizontalScrollbarDrag(event: PointerEvent) {
+  const scroller = gridScrollerElement();
+  const track = gridHorizontalScrollbarTrackRef.value;
+  if (!scroller || !track || !hasGridHorizontalOverflow.value) return;
+
+  const maxScrollLeft = Math.max(0, scroller.scrollWidth - scroller.clientWidth);
+  if (maxScrollLeft <= 1) return;
+  const trackRect = track.getBoundingClientRect();
+  const thumbLeftPx = trackRect.width * (gridHorizontalScrollbarThumbLeftPercent / 100);
+  const thumbWidthPx = trackRect.width * (gridHorizontalScrollbarThumbWidthPercent / 100);
+  const pointerX = event.clientX - trackRect.left;
+  const pointerInsideThumb = pointerX >= thumbLeftPx && pointerX <= thumbLeftPx + thumbWidthPx;
+
+  gridHorizontalScrollbarDragState = {
+    scroller,
+    trackRect,
+    thumbOffsetPx: pointerInsideThumb ? pointerX - thumbLeftPx : thumbWidthPx / 2,
+    maxScrollLeft,
+  };
+  setGridHorizontalScrollbarDragging(true);
+  document.body.style.userSelect = "none";
+  window.addEventListener("pointermove", onGridHorizontalScrollbarPointerMove, true);
+  window.addEventListener("pointerup", stopGridHorizontalScrollbarDrag, true);
+  window.addEventListener("pointercancel", stopGridHorizontalScrollbarDrag, true);
+  event.preventDefault();
+  scheduleGridHorizontalScrollbarDrag(event.clientX);
+}
+
+function applyPendingGridVerticalScrollbarDrag() {
+  gridVerticalScrollbarDragFrame = 0;
+  const dragState = gridVerticalScrollbarDragState;
+  if (!dragState) return;
+
+  const thumbHeightPx = dragState.trackRect.height * (gridVerticalScrollbarThumbHeightPercent / 100);
+  const maxThumbTopPx = Math.max(1, dragState.trackRect.height - thumbHeightPx);
+  const thumbTopPx = Math.min(maxThumbTopPx, Math.max(0, gridVerticalScrollbarPendingClientY - dragState.trackRect.top - dragState.thumbOffsetPx));
+  const scroller = dragState.scroller;
+  const nextScrollTop = (thumbTopPx / maxThumbTopPx) * dragState.maxScrollTop;
+  if (Math.abs(scroller.scrollTop - nextScrollTop) < 0.5) return;
+  scroller.scrollTop = nextScrollTop;
+  updateGridVerticalScrollbar(scroller);
+  if (useCanvasGridRows.value) {
+    canvasScrollTop.value = scroller.scrollTop;
+    drawCanvasGridNow();
+  }
+}
+
+function scheduleGridVerticalScrollbarDrag(clientY: number) {
+  gridVerticalScrollbarPendingClientY = clientY;
+  if (gridVerticalScrollbarDragFrame) return;
+  // Match horizontal dragging: coalesce pointermove bursts to one canvas/layout update per frame.
+  gridVerticalScrollbarDragFrame = requestAnimationFrame(applyPendingGridVerticalScrollbarDrag);
+}
+
+function flushGridVerticalScrollbarDrag() {
+  if (!gridVerticalScrollbarDragFrame) return;
+  cancelAnimationFrame(gridVerticalScrollbarDragFrame);
+  applyPendingGridVerticalScrollbarDrag();
+}
+
+function onGridVerticalScrollbarPointerMove(event: PointerEvent) {
+  if (!gridVerticalScrollbarDragState) return;
+  event.preventDefault();
+  scheduleGridVerticalScrollbarDrag(event.clientY);
+}
+
+function startGridVerticalScrollbarDrag(event: PointerEvent) {
+  const scroller = gridScrollerElement();
+  const track = gridVerticalScrollbarTrackRef.value;
+  if (!scroller || !track || !hasGridVerticalOverflow.value) return;
+
+  const maxScrollTop = Math.max(0, scroller.scrollHeight - scroller.clientHeight);
+  if (maxScrollTop <= 1) return;
+  const trackRect = track.getBoundingClientRect();
+  const thumbTopPx = trackRect.height * (gridVerticalScrollbarThumbTopPercent / 100);
+  const thumbHeightPx = trackRect.height * (gridVerticalScrollbarThumbHeightPercent / 100);
+  const pointerY = event.clientY - trackRect.top;
+  const pointerInsideThumb = pointerY >= thumbTopPx && pointerY <= thumbTopPx + thumbHeightPx;
+
+  gridVerticalScrollbarDragState = {
+    scroller,
+    trackRect,
+    thumbOffsetPx: pointerInsideThumb ? pointerY - thumbTopPx : thumbHeightPx / 2,
+    maxScrollTop,
+  };
+  setGridVerticalScrollbarDragging(true);
+  document.body.style.userSelect = "none";
+  window.addEventListener("pointermove", onGridVerticalScrollbarPointerMove, true);
+  window.addEventListener("pointerup", stopGridVerticalScrollbarDrag, true);
+  window.addEventListener("pointercancel", stopGridVerticalScrollbarDrag, true);
+  event.preventDefault();
+  scheduleGridVerticalScrollbarDrag(event.clientY);
+}
+
+function updateGridScrollbarGutter(element: HTMLElement) {
+  gridScrollbarGutter.value = scrollbarGutterWidth(element);
+}
+
+function refreshGridScrollerMetrics() {
+  const scrollerEl = gridRef.value?.querySelector<HTMLElement>(".data-grid-scroller");
+  if (!scrollerEl) return;
+  updateGridScrollbarGutter(scrollerEl);
+  updateGridHorizontalViewport(scrollerEl);
+  rememberInfiniteScrollPosition(scrollerEl);
+  if (headerRef.value) {
+    headerRef.value.scrollLeft = scrollerEl.scrollLeft;
+  }
+  observeGridHorizontalScrollbarScroller();
+}
+
+function syncHeaderScroll(e: Event) {
+  const target = e.target as HTMLElement;
+  updateGridScrollbarGutter(target);
+  updateGridHorizontalViewport(target);
+  if (headerRef.value) {
+    headerRef.value.scrollLeft = target.scrollLeft;
+  }
+}
+
+const HORIZONTAL_COLUMN_BUFFER_PX = 900;
+
+interface RenderedGridColumn {
+  visibleColIdx: number;
+  actualColIdx: number;
+  name: string;
+}
+
+interface HorizontalColumnWindow {
+  start: number;
+  end: number;
+  beforeWidth: number;
+  afterWidth: number;
+}
+
+function getHorizontalColumnWindow(): HorizontalColumnWindow {
+  const widths = renderedColumnWidths.value;
+  const offsets = renderedColumnOffsets.value;
+  const totalColumns = visibleColumnIndexes.value.length;
+  if (totalColumns === 0 || widths.length === 0) {
+    return { start: 0, end: 0, beforeWidth: 0, afterWidth: 0 };
+  }
+
+  const viewportStart = Math.max(0, gridHorizontalScrollLeft.value - DATA_GRID_ROW_NUM_WIDTH - HORIZONTAL_COLUMN_BUFFER_PX);
+  const viewportEnd = Math.max(gridViewportWidth.value, 1) + Math.max(0, gridHorizontalScrollLeft.value - DATA_GRID_ROW_NUM_WIDTH) + HORIZONTAL_COLUMN_BUFFER_PX;
+  let low = 0;
+  let high = totalColumns - 1;
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if ((offsets[mid + 1] ?? 0) < viewportStart) low = mid + 1;
+    else high = mid;
+  }
+  const start = low;
+  const offset = offsets[start] ?? 0;
+
+  let end = start;
+  while (end < totalColumns && (offsets[end] ?? 0) < viewportEnd) {
+    end++;
+  }
+  const visibleWidth = offsets[end] ?? offset;
+
+  const columnsWidth = offsets[totalColumns] ?? 0;
+  return {
+    start,
+    end,
+    beforeWidth: offset,
+    afterWidth: Math.max(0, columnsWidth - visibleWidth),
+  };
+}
+
+const horizontalColumnWindow = computed(getHorizontalColumnWindow);
+
+const renderedGridColumns = computed<RenderedGridColumn[]>(() => {
+  const window = horizontalColumnWindow.value;
+  const columns: RenderedGridColumn[] = [];
+  for (let visibleColIdx = window.start; visibleColIdx < window.end; visibleColIdx++) {
+    const actualColIdx = visibleColumnIndexes.value[visibleColIdx];
+    if (actualColIdx === undefined) continue;
+    columns.push({
+      visibleColIdx,
+      actualColIdx,
+      name: props.result.columns[actualColIdx] ?? "",
+    });
+  }
+  return columns;
+});
+
+function renderedColumnStyle(visibleColIdx: number) {
+  return { width: `var(--col-w-${visibleColIdx})` };
+}
+
+type ColumnHeaderDragState = {
+  sourceVisibleIndex: number;
+  targetVisibleIndex: number;
+  startX: number;
+  startY: number;
+  currentX: number;
+  columnRects: { visibleIndex: number; left: number; width: number }[];
+  dragging: boolean;
+};
+const columnHeaderDragState = ref<ColumnHeaderDragState | null>(null);
+const columnHeaderResizeActive = ref(false);
+let columnHeaderDragClickGuardUntil = 0;
+let columnHeaderSuppressNextClick = false;
+let columnHeaderSuppressClickTimer = 0;
+let columnHeaderDragFrame = 0;
+let columnHeaderPendingClientX = 0;
+let columnHeaderResizeListenersCleanup: (() => void) | null = null;
+
+const columnHeaderTooltipsDisabled = computed(() =>
+  columnHeaderTooltipDisabled({
+    columnDragActive: columnHeaderDragState.value !== null,
+    columnResizeActive: columnHeaderResizeActive.value,
+  }),
+);
+
+function columnHeaderPointerInteractionActive(): boolean {
+  return columnHeaderCanvasPointerDisabled({
+    columnDragActive: columnHeaderDragState.value !== null,
+    columnResizeActive: columnHeaderResizeActive.value,
+  });
+}
+
+function finishColumnHeaderResizeInteraction() {
+  clearColumnHeaderResizeListeners();
+  requestAnimationFrame(() => {
+    columnHeaderResizeActive.value = false;
+  });
+}
+
+function clearColumnHeaderResizeListeners() {
+  if (!columnHeaderResizeListenersCleanup) return;
+  columnHeaderResizeListenersCleanup();
+  columnHeaderResizeListenersCleanup = null;
+}
+
+function clearColumnHeaderClickGuard() {
+  columnHeaderSuppressNextClick = false;
+  columnHeaderDragClickGuardUntil = 0;
+  if (columnHeaderSuppressClickTimer) {
+    window.clearTimeout(columnHeaderSuppressClickTimer);
+    columnHeaderSuppressClickTimer = 0;
+  }
+}
+
+function armColumnHeaderClickGuard() {
+  clearColumnHeaderClickGuard();
+  columnHeaderSuppressNextClick = true;
+  columnHeaderDragClickGuardUntil = Date.now() + 800;
+  columnHeaderSuppressClickTimer = window.setTimeout(() => {
+    clearColumnHeaderClickGuard();
+  }, 800);
+}
+
+function startColumnHeaderResize(visibleColIdx: number, event: MouseEvent) {
+  // Browser hover state can stick to multiple header cells during pointer drags,
+  // so keep header tooltips closed until the resize gesture has fully settled.
+  clearColumnHeaderResizeListeners();
+  columnHeaderResizeActive.value = true;
+  armColumnHeaderClickGuard();
+  onCanvasMouseLeave();
+  const finishResize = () => {
+    armColumnHeaderClickGuard();
+    finishColumnHeaderResizeInteraction();
+  };
+  columnHeaderResizeListenersCleanup = () => {
+    window.removeEventListener("mouseup", finishResize, true);
+    window.removeEventListener("blur", finishResize, true);
+  };
+  window.addEventListener("mouseup", finishResize, true);
+  window.addEventListener("blur", finishResize, true);
+  onResizeStart(visibleColIdx, event);
+}
+
+function columnHeaderInteractiveTarget(target: EventTarget | null): boolean {
+  return target instanceof HTMLElement && !!target.closest("button, input, textarea, select, [contenteditable='true'], [role='button'], [data-column-resize-handle]");
+}
+
+function columnHeaderDropTargetVisibleIndex(clientX: number): number {
+  const state = columnHeaderDragState.value;
+  if (!state || state.columnRects.length === 0) return state?.sourceVisibleIndex ?? 0;
+  for (const rect of state.columnRects) {
+    const visibleIndex = rect.visibleIndex;
+    if (!Number.isFinite(visibleIndex)) continue;
+    if (clientX < rect.left + rect.width / 2) return visibleIndex;
+  }
+  return visibleColumnIndexes.value.length;
+}
+
+function applyColumnHeaderDragPreview() {
+  columnHeaderDragFrame = 0;
+  const state = columnHeaderDragState.value;
+  if (!state?.dragging) return;
+  state.currentX = columnHeaderPendingClientX;
+  state.targetVisibleIndex = columnHeaderDropTargetVisibleIndex(columnHeaderPendingClientX);
+  if (useCanvasGridRows.value) scheduleCanvasDraw();
+}
+
+function scheduleColumnHeaderDragPreview(clientX: number) {
+  columnHeaderPendingClientX = clientX;
+  if (columnHeaderDragFrame) return;
+  columnHeaderDragFrame = requestAnimationFrame(applyColumnHeaderDragPreview);
+}
+
+function flushColumnHeaderDragPreview() {
+  if (columnHeaderDragFrame) cancelAnimationFrame(columnHeaderDragFrame);
+  applyColumnHeaderDragPreview();
+}
+
+function cancelColumnHeaderDragPreview() {
+  if (!columnHeaderDragFrame) return;
+  cancelAnimationFrame(columnHeaderDragFrame);
+  columnHeaderDragFrame = 0;
+}
+
+function columnHeaderLayoutRects(): { visibleIndex: number; left: number; width: number }[] {
+  const header = headerRef.value;
+  return Array.from(header?.querySelectorAll<HTMLElement>("[data-visible-col-index]") ?? [])
+    .map((element) => {
+      const rect = element.getBoundingClientRect();
+      return {
+        visibleIndex: Number(element.dataset.visibleColIndex),
+        left: rect.left,
+        width: rect.width,
+      };
+    })
+    .filter((rect) => Number.isFinite(rect.visibleIndex));
+}
+
+function stopColumnHeaderDrag(commit: boolean) {
+  const state = columnHeaderDragState.value;
+  if (!state) return;
+  const hadCanvasPreview = useCanvasGridRows.value && state.dragging;
+  window.removeEventListener("pointermove", onColumnHeaderPointerMove, true);
+  window.removeEventListener("pointerup", onColumnHeaderPointerUp, true);
+  window.removeEventListener("pointercancel", onColumnHeaderPointerCancel, true);
+  cancelColumnHeaderDragPreview();
+  document.body.style.userSelect = "";
+  columnHeaderDragState.value = null;
+  if (hadCanvasPreview) scheduleCanvasDraw();
+  if (state.dragging) armColumnHeaderClickGuard();
+  if (!commit || !state.dragging || state.sourceVisibleIndex === state.targetVisibleIndex) return;
+  const next = moveVisibleColumnIndex({
+    orderedIndexes: orderedDisplayableColumnIndexes.value,
+    hiddenIndexes: hiddenColumnIndexes.value,
+    fromVisibleIndex: state.sourceVisibleIndex,
+    toVisibleIndex: state.targetVisibleIndex,
+  });
+  persistColumnOrder(next);
+  nextTick(refreshGridScrollerMetrics);
+}
+
+function onColumnHeaderPointerMove(event: PointerEvent) {
+  const state = columnHeaderDragState.value;
+  if (!state) return;
+  const moved = Math.abs(event.clientX - state.startX) > 5 || Math.abs(event.clientY - state.startY) > 5;
+  if (!state.dragging && moved) {
+    state.dragging = true;
+    document.body.style.userSelect = "none";
+    onCanvasMouseLeave();
+  }
+  if (!state.dragging) return;
+  event.preventDefault();
+  scheduleColumnHeaderDragPreview(event.clientX);
+}
+
+function onColumnHeaderPointerUp(event: PointerEvent) {
+  columnHeaderPendingClientX = event.clientX;
+  flushColumnHeaderDragPreview();
+  stopColumnHeaderDrag(true);
+}
+
+function onColumnHeaderPointerCancel() {
+  stopColumnHeaderDrag(false);
+}
+
+function startColumnHeaderDrag(visibleColIdx: number, event: PointerEvent) {
+  if (event.button !== 0 || getIsResizing() || columnHeaderInteractiveTarget(event.target)) return;
+  columnHeaderDragState.value = {
+    sourceVisibleIndex: visibleColIdx,
+    targetVisibleIndex: visibleColIdx,
+    startX: event.clientX,
+    startY: event.clientY,
+    currentX: event.clientX,
+    columnRects: columnHeaderLayoutRects(),
+    dragging: false,
+  };
+  columnHeaderPendingClientX = event.clientX;
+  window.addEventListener("pointermove", onColumnHeaderPointerMove, true);
+  window.addEventListener("pointerup", onColumnHeaderPointerUp, true);
+  window.addEventListener("pointercancel", onColumnHeaderPointerCancel, true);
+}
+
+function suppressHeaderClickIfNeeded(event: MouseEvent): boolean {
+  if (
+    !columnHeaderClickShouldBeSuppressed({
+      now: Date.now(),
+      guardUntil: columnHeaderDragClickGuardUntil,
+      suppressNextClick: columnHeaderSuppressNextClick,
+    })
+  ) {
+    return false;
+  }
+  clearColumnHeaderClickGuard();
+  event.preventDefault();
+  event.stopPropagation();
+  event.stopImmediatePropagation();
+  return true;
+}
+
+function onHeaderClickCapture(event: MouseEvent) {
+  suppressHeaderClickIfNeeded(event);
+}
+
+function onHeaderClick(visibleColIdx: number, event: MouseEvent) {
+  if (suppressHeaderClickIfNeeded(event)) return;
+  selectColumn(visibleColIdx, event);
+}
+
+function columnHeaderDragClass(visibleColIdx: number) {
+  const state = columnHeaderDragState.value;
+  return {
+    "z-30 shadow-lg ring-1 ring-primary/40 bg-background dark:bg-muted pointer-events-none": state?.dragging && state.sourceVisibleIndex === visibleColIdx,
+  };
+}
+
+function columnHeaderPreviewOffset(visibleColIdx: number): number {
+  const state = columnHeaderDragState.value;
+  if (!state) return 0;
+  return columnHeaderPreviewOffsetForColumn({
+    columnDragActive: state.dragging,
+    visibleColIdx,
+    sourceVisibleIndex: state.sourceVisibleIndex,
+    targetVisibleIndex: state.targetVisibleIndex,
+    startX: state.startX,
+    currentX: state.currentX,
+    sourceWidth: renderedColumnWidths.value[state.sourceVisibleIndex] ?? 0,
+  });
+}
+
+function columnHeaderStyle(visibleColIdx: number) {
+  const style = renderedColumnStyle(visibleColIdx);
+  const offset = columnHeaderPreviewOffset(visibleColIdx);
+  if (!offset) return style;
+  return {
+    ...style,
+    transform: `translateX(${offset}px)`,
+    transition: columnHeaderDragState.value?.sourceVisibleIndex === visibleColIdx ? undefined : "transform 120ms ease-out",
+  };
+}
+
+const columnHeaderPreviewOffsets = computed(() => renderedColumnWidths.value.map((_, visibleColIdx) => columnHeaderPreviewOffset(visibleColIdx)));
+const columnHeaderPreviewSourceVisibleIndex = computed(() => {
+  const state = columnHeaderDragState.value;
+  return state?.dragging ? state.sourceVisibleIndex : null;
+});
+
+function columnContentOffsetLeft(visibleColIdx: number): number {
+  return DATA_GRID_ROW_NUM_WIDTH + (renderedColumnOffsets.value[visibleColIdx] ?? 0);
+}
+
+let scrollingTimer = 0;
+const isScrolling = ref(false);
+let infiniteScrollPositions = new WeakMap<HTMLElement, DataGridScrollPosition>();
+
+function updateDomGridVisibleItemsDuringScroll(scroller: HTMLElement) {
+  if (useCanvasGridRows.value || scroller !== gridScrollerElement()) return;
+  (scrollerRef.value as { updateVisibleItems?: (itemsChanged: boolean, checkPositionDiff?: boolean) => void } | null)?.updateVisibleItems?.(false, true);
+}
+
+function markGridScrolling() {
+  if (!isScrolling.value) isScrolling.value = true;
+  clearTimeout(scrollingTimer);
+  scrollingTimer = window.setTimeout(() => {
+    const scroller = gridScrollerElement();
+    if (scroller) updateDomGridVisibleItemsDuringScroll(scroller);
+    isScrolling.value = false;
+  }, 120);
+}
+
+function rememberInfiniteScrollPosition(scroller: HTMLElement) {
+  infiniteScrollPositions.set(scroller, dataGridScrollPosition(scroller.scrollTop, scroller.scrollLeft));
+}
+
+function maybeCheckInfiniteScroll(scroller: HTMLElement) {
+  const current = dataGridScrollPosition(scroller.scrollTop, scroller.scrollLeft);
+  const previous = infiniteScrollPositions.get(scroller);
+  infiniteScrollPositions.set(scroller, current);
+  if (shouldCheckInfiniteScrollAfterScroll(previous, current)) {
+    checkInfiniteScroll(scroller);
+  }
+}
+
+function clampGridScrollerBounds(scroller: HTMLElement) {
+  const maxTop = Math.max(0, scroller.scrollHeight - scroller.clientHeight);
+  const maxLeft = Math.max(0, scroller.scrollWidth - scroller.clientWidth);
+  const nextTop = Math.max(0, Math.min(maxTop, scroller.scrollTop));
+  const nextLeft = Math.max(0, Math.min(maxLeft, scroller.scrollLeft));
+  if (nextTop !== scroller.scrollTop) scroller.scrollTop = nextTop;
+  if (nextLeft !== scroller.scrollLeft) scroller.scrollLeft = nextLeft;
+}
+
+function onScrollerScroll(e: Event) {
+  const target = e.target;
+  if (target instanceof HTMLElement) {
+    clampGridScrollerBounds(target);
+    updateDomGridVisibleItemsDuringScroll(target);
+    syncHeaderScroll(e);
+    recordScrollPosition({ top: target.scrollTop, left: target.scrollLeft });
+    maybeCheckInfiniteScroll(target);
+  } else {
+    syncHeaderScroll(e);
+  }
+  markGridScrolling();
+}
+
+watch(isScrolling, (scrolling) => {
+  if (scrolling) {
+    hoveredDetailCell.value = null;
+    quickDownloadMenuCell.value = null;
+  }
+});
+
+initColumnWidths();
+watch(
+  () => visibleColumns.value.length,
+  () => initColumnWidths(),
+);
+watch(
+  () => [visibleColumnCount.value, renderedColumnWidths.value.length],
+  () => {
+    nextTick(refreshGridScrollerMetrics);
+  },
+);
+const localFilterScopeKey = computed(() =>
+  [
+    props.connectionId ?? "",
+    props.database ?? "",
+    props.schema ?? "",
+    props.context ?? "",
+    props.tableMeta?.schema ?? "",
+    props.tableMeta?.tableName ?? "",
+    props.tableMeta ? "" : (props.sql ?? ""),
+    props.result.columns.join("\0"),
+    (props.sourceColumns ?? []).map((column) => column ?? "").join("\0"),
+  ].join("\u0001"),
+);
+watch(
+  () => localFilterScopeKey.value,
+  () => {
+    localColumnFilters.value = {};
+    hiddenColumnIndexes.value = new Set();
+    nullColumnsHidden.value = false;
+    autoHiddenNullColumnIndexes.value = new Set();
+    closeLocalFilter();
+  },
+);
+
+// --- Pagination ---
+const pageSize = ref(normalizeResultPageSize(settingsStore.editorSettings.pageSize));
+const currentPage = ref(1);
+const pageSizeOptions = computed(() => resultPageSizeMenuOptions(pageSize.value));
+const customPageSizeInput = ref(String(pageSize.value));
+const infiniteScrollLoading = ref(false);
+const isInfiniteScrollPaginating = ref(false);
+let lastInfiniteScrollPage = 0;
+let infiniteScrollCheckScheduled = false;
+let infiniteScrollAllLoaded = false;
+// Tracks whether the current loading cycle was triggered by a refresh/rollback
+// (as opposed to a normal paginate). Used to decide whether to auto-redirect
+// when the current page no longer exists after data was deleted.
+const isRefreshingData = ref(false);
+watch(pageSize, (value) => {
+  customPageSizeInput.value = String(value);
+});
+watch(
+  () => settingsStore.editorSettings.pageSize,
+  (value) => {
+    pageSize.value = normalizeResultPageSize(value, pageSize.value);
+  },
+);
+watch(
+  () => infiniteScrollEnabled.value,
+  (enabled, prevEnabled) => {
+    // Switched between paginated and infinite scroll: reset to first page
+    if (enabled !== prevEnabled) {
+      resetInfiniteScrollState();
+      emit("paginate", 0, pageSize.value, currentWhereInput(), currentOrderBy());
+    }
+  },
+);
+watch(
+  () => [props.pageOffset, props.pageLimit],
+  ([offset, limit]) => {
+    if (typeof offset !== "number" || typeof limit !== "number" || limit <= 0) return;
+    // Skip resetting pagination state during infinite scroll pagination
+    if (isInfiniteScrollPaginating.value) return;
+    const normalizedLimit = normalizeResultPageSize(limit);
+    pageSize.value = normalizedLimit;
+    currentPage.value = Math.floor(offset / normalizedLimit) + 1;
+  },
+  { immediate: true },
+);
+// Clear infinite-scroll loading when the parent finishes loading new data
+watch(
+  () => props.loading,
+  (loading, prevLoading) => {
+    if (prevLoading && !loading && infiniteScrollLoading.value) {
+      infiniteScrollLoading.value = false;
+      isInfiniteScrollPaginating.value = false;
+      // Detect if the backend returned no new data for this page
+      const expectedRows = currentPage.value * pageSize.value;
+      if (props.result.rows.length < expectedRows) {
+        infiniteScrollAllLoaded = true;
+      }
+    }
+  },
+);
+const manualTotalRowCount = ref<number | undefined>(undefined);
+const manualTotalRowCountLoading = ref(false);
+const showTruncationWarning = computed(() => props.result.truncated === true && typeof props.pageLimit !== "number" && props.result.has_more !== true);
+const isResultsContext = computed(() => props.context === "results");
+// affected_rows reported by the backend can be larger than the rows we
+// actually have in memory — e.g. ES auto-pages SELECT * on a big index and
+// reports the index's true match count. Surface that in the status bar so
+// the user sees the real total, but do NOT use it to unlock pagination:
+// we don't have those rows, so letting the user page into them would just
+// show blank screens.
+const inferredBackendTotalRowCount = computed(() => {
+  const affected = props.result.affected_rows;
+  if (typeof affected !== "number" || !Number.isFinite(affected)) return undefined;
+  if (affected <= props.result.rows.length) return undefined;
+  return affected;
+});
+const serverKnownTotalRowCount = computed(() => props.totalRowCount ?? manualTotalRowCount.value);
+const displayedTotalRowCount = computed(() => serverKnownTotalRowCount.value ?? inferredBackendTotalRowCount.value);
+// Only a server-confirmed total drives pagination — an inferred total means
+// rows exist that we never fetched, so navigation must stay inside rows.length.
+const hasKnownTotalRowCount = computed(() => typeof serverKnownTotalRowCount.value === "number" && serverKnownTotalRowCount.value >= 0);
+// When context=results and the caller hasn't configured server-side
+// pagination (no pageLimit), the backend handed us every row up-front and
+// rowCount IS the total. Without this hint, the "page is full → assume more"
+// fallback in canGoNextDataGridPage lets the user keep clicking next forever.
+const allRowsLoaded = computed(() => isResultsContext.value && props.pageLimit === undefined);
+// True when the in-memory result already holds the complete result set (results
+// context, no server-side pagination, not truncated, no further pages). Used to
+// skip re-executing the query on export and instead write the local rows.
+const hasCompleteLocalResult = computed(() => !!props.result && allRowsLoaded.value && props.result.truncated !== true && props.result.has_more !== true);
+const canGoNextPage = computed(() => {
+  return canGoNextDataGridPage({
+    hasMore: props.result.has_more,
+    rowCount: props.result.rows.length,
+    pageSize: pageSize.value,
+    pageOffset: props.pageOffset,
+    currentPage: currentPage.value,
+    totalRowCount: hasKnownTotalRowCount.value ? displayedTotalRowCount.value : undefined,
+    allRowsLoaded: allRowsLoaded.value,
+  });
+});
+const canJumpLastPage = computed(() => canGoNextPage.value && (hasKnownTotalRowCount.value || allRowsLoaded.value || !!props.tableMeta || !!props.countSql));
+const totalRowCountBusy = computed(() => props.totalRowCountLoading === true || manualTotalRowCountLoading.value);
+const canCalculateTotalRowCount = computed(() => !!props.connectionId && (!!props.tableMeta || !!props.countSql));
+// When a refresh/rollback completes and the current page exceeds the last
+// available page (e.g. data was deleted while viewing), auto-navigate to the
+// last available page instead of showing an empty page.
+watch(
+  () => props.loading,
+  (loading, prevLoading) => {
+    // Only act when loading completes (transitions from true to false)
+    // and the completion was triggered by a refresh/rollback.
+    if (!loading && prevLoading && isRefreshingData.value) {
+      isRefreshingData.value = false;
+      const total = displayedTotalRowCount.value;
+      if (!total || total <= 0) return;
+      const lastPageNum = Math.max(1, Math.ceil(total / pageSize.value));
+      if (currentPage.value <= lastPageNum) return;
+      currentPage.value = lastPageNum;
+      resetGridVerticalScroll(true);
+      emit("paginate", (lastPageNum - 1) * pageSize.value, pageSize.value, currentWhereInput(), currentOrderBy());
+    }
+  },
+);
+const showQueryEditReadOnlyBadge = computed(() => isResultsContext.value && hasData.value && !props.editable && !!props.queryEditabilityReason);
+const queryEditReadOnlyReason = computed(() => (props.queryEditabilityReason ? t(`grid.queryEditUnsupported.${props.queryEditabilityReason}`) : ""));
+const showKeylessEditWarning = computed(() => !!props.editable && !!props.tableMeta && canUseKeylessRowPredicate(props.databaseType, props.tableMeta.primaryKeys ?? []));
+const canShowWhereSearch = computed(() => !!props.onExecuteSql && !isResultsContext.value);
+const canUseWhereSearch = computed(() => !!props.tableMeta && !!props.onExecuteSql && !isResultsContext.value);
+const canUseServerColumnFilter = computed(() => canUseWhereSearch.value && !!props.connectionId && !!props.tableMeta);
+type DataGridTableMeta = NonNullable<typeof props.tableMeta>;
+const hiveTableTransactional = ref<boolean | undefined>(undefined);
+const resultSourceColumns = computed(() => props.result.columns.map((column, index) => props.sourceColumns?.[index] ?? column));
+const canEditExistingRows = computed(
+  () => !!props.customSaveHandler || (canEditExistingTableRows(props.databaseType, hiveTableTransactional.value, props.tableMeta?.primaryKeys ?? []) && hasCompleteTdengineRowIdentity(props.databaseType, props.tableMeta?.primaryKeys ?? [], resultSourceColumns.value)),
+);
+const customReadonlyColumns = computed(() => new Set((props.customSaveHandler?.readonlyColumns ?? []).map((column) => column.toLowerCase())));
+const hasDataGridSaveTarget = computed(() => !!props.tableMeta || !!props.customSaveHandler);
+const hasDataGridInsertTarget = computed(() => {
+  if (props.allowInsertRows === false) return false;
+  const handler = props.customSaveHandler;
+  if (handler) return handler.supportsInsert === true || handler.canInsert === true;
+  return !!props.tableMeta && canInsertTableRows(props.databaseType);
+});
+const canInsertRows = computed(() => !!props.editable && hasDataGridInsertTarget.value);
+const canDeleteRows = computed(() => props.allowDeleteRows !== false && (!props.customSaveHandler || props.customSaveHandler.canDelete !== false));
+const canDeleteExistingRows = computed(() => !!props.customSaveHandler || canDeleteExistingTdengineRows(props.databaseType, props.tableMeta?.primaryKeys ?? []));
+watch(
+  () => [props.databaseType, props.connectionId, props.database, props.tableMeta?.schema, props.tableMeta?.tableName],
+  async () => {
+    if (props.databaseType !== "hive" || !props.connectionId || !props.database || !props.tableMeta) {
+      hiveTableTransactional.value = undefined;
+      return;
+    }
+    try {
+      const sql = await buildHiveTablePropertiesSql({
+        schema: props.tableMeta.schema,
+        tableName: props.tableMeta.tableName,
+        propertyName: "transactional",
+      });
+      const result = await api.executeQuery(props.connectionId, props.database, sql, props.tableMeta.schema);
+      hiveTableTransactional.value = hiveTablePropertiesIndicateTransactional(result);
+    } catch {
+      hiveTableTransactional.value = false;
+    }
+  },
+  { immediate: true },
+);
+const clientSearchText = computed(() => (searchText.value.trim() ? searchText.value : ""));
+watch(clientSearchText, (value) => {
+  clearTimeout(_searchTimer);
+  const q = value.trim().toLowerCase();
+  if (!q) {
+    deferredClientSearchText.value = "";
+    return;
+  }
+  _searchTimer = setTimeout(() => {
+    deferredClientSearchText.value = q;
+  }, 150);
+});
+
+function currentWhereInput(): string | undefined {
+  return combineWhereInputs(whereFilterInput.value, appliedStructuredWhereInput.value);
+}
+
+function currentOrderBy(): string | undefined {
+  return orderByInput.value.trim() || (sortCol.value ? `${queryColumnRef(sortCol.value)} ${sortDir.value.toUpperCase()}` : undefined);
+}
+
+watch(
+  () => [props.countSql ?? "", props.tableMeta?.schema ?? "", props.tableMeta?.tableName ?? "", currentWhereInput() ?? "", props.database ?? "", props.connectionId ?? "", props.result],
+  () => {
+    manualTotalRowCount.value = undefined;
+    // Reset infinite-scroll allLoaded when query context changes
+    infiniteScrollAllLoaded = false;
+  },
+);
+
+function syncOrderByInputWithSort(column: string | null, direction: "asc" | "desc" | null) {
+  const nextOrderByInput = column && direction ? `${queryColumnRef(column)} ${direction.toUpperCase()}` : "";
+  orderByInput.value = nextOrderByInput;
+  emit("update:orderByInput", nextOrderByInput);
+}
+
+watch(
+  () => [props.sortColumn, props.sortColumnIndex, props.sortDirection, props.sortMode] as const,
+  ([column, columnIndex, direction, mode], previous) => {
+    const wasControlledSort = !!previous?.[0] && !!previous?.[2];
+    const isControlledSort = !!column && !!direction;
+    sortCol.value = column && direction ? column : null;
+    sortColIndex.value = typeof columnIndex === "number" && direction ? columnIndex : null;
+    sortDir.value = direction ?? "asc";
+    sortMode.value = mode ?? "database";
+    if (isControlledSort && sortMode.value === "database") {
+      syncOrderByInputWithSort(sortCol.value, sortDir.value);
+    } else if (wasControlledSort) {
+      syncOrderByInputWithSort(null, null);
+    }
+  },
+  { immediate: true },
+);
+
+function firstPage() {
+  if (currentPage.value <= 1) return;
+  currentPage.value = 1;
+  lastInfiniteScrollPage = 0;
+  resetGridVerticalScroll(true);
+  emit("paginate", 0, pageSize.value, currentWhereInput(), currentOrderBy());
+}
+function prevPage() {
+  if (currentPage.value <= 1) return;
+  currentPage.value--;
+  resetGridVerticalScroll(true);
+  emit("paginate", (currentPage.value - 1) * pageSize.value, pageSize.value, currentWhereInput(), currentOrderBy());
+}
+function nextPage() {
+  if (!canGoNextPage.value) return;
+  currentPage.value++;
+  resetGridVerticalScroll(true);
+  emit("paginate", (currentPage.value - 1) * pageSize.value, pageSize.value, currentWhereInput(), currentOrderBy());
+}
+
+function infiniteScrollNextPage() {
+  if (infiniteScrollLoading.value || props.loading) return;
+  const nextPageNum = currentPage.value + 1;
+  const cumulativeLimit = nextPageNum * pageSize.value;
+  if (cumulativeLimit > infiniteScrollMaxRows.value) return;
+  // Stop if we already know all data is loaded
+  if (infiniteScrollAllLoaded) return;
+  // Skip if we already have this many rows loaded (e.g. cached data)
+  if (props.result.rows.length >= cumulativeLimit) {
+    currentPage.value = nextPageNum;
+    return;
+  }
+  infiniteScrollLoading.value = true;
+  isInfiniteScrollPaginating.value = true;
+  currentPage.value = nextPageNum;
+  // Load cumulative data (all rows up to current page) to append instead of replace
+  emit("paginate", 0, cumulativeLimit, currentWhereInput(), currentOrderBy());
+}
+function checkInfiniteScroll(scroller: HTMLElement) {
+  if (!infiniteScrollEnabled.value || infiniteScrollLoading.value || props.loading) return;
+  if (infiniteScrollAllLoaded) return;
+  if (infiniteScrollCheckScheduled) return;
+  infiniteScrollCheckScheduled = true;
+  requestAnimationFrame(() => {
+    infiniteScrollCheckScheduled = false;
+    // Only trigger when near bottom AND page has changed since last trigger
+    if (isDataGridNearScrollBottom(scroller) && currentPage.value !== lastInfiniteScrollPage) {
+      lastInfiniteScrollPage = currentPage.value;
+      infiniteScrollNextPage();
+    }
+  });
+}
+
+function changePageSize(size: number) {
+  const normalizedSize = normalizeResultPageSize(size);
+  pageSize.value = normalizedSize;
+  settingsStore.updateEditorSettings({ pageSize: normalizedSize });
+  currentPage.value = 1;
+  lastInfiniteScrollPage = 0;
+  infiniteScrollAllLoaded = false;
+  infiniteScrollPositions = new WeakMap();
+  resetGridVerticalScroll(true);
+  emit("paginate", 0, normalizedSize, currentWhereInput(), currentOrderBy());
+}
+
+function applyCustomPageSize() {
+  changePageSize(normalizeResultPageSize(customPageSizeInput.value, pageSize.value));
+}
+
+async function lastPage() {
+  if (infiniteScrollEnabled.value) return;
+  if (hasKnownTotalRowCount.value) {
+    const total = displayedTotalRowCount.value ?? 0;
+    if (total <= 0) return;
+    const lastPageNum = Math.ceil(total / pageSize.value);
+    if (lastPageNum <= currentPage.value) return;
+    currentPage.value = lastPageNum;
+    resetGridVerticalScroll(true);
+    emit("paginate", (lastPageNum - 1) * pageSize.value, pageSize.value, currentWhereInput(), currentOrderBy());
+    return;
+  }
+  if (allRowsLoaded.value) {
+    const total = props.result.rows.length;
+    if (total <= 0) return;
+    const lastPageNum = Math.ceil(total / pageSize.value);
+    if (lastPageNum <= currentPage.value) return;
+    currentPage.value = lastPageNum;
+    resetGridVerticalScroll(true);
+    return;
+  }
+  if (!props.connectionId) return;
+  const countTarget = await buildCurrentCountTarget();
+  const sql = countTarget?.sql;
+  if (!sql) return;
+  try {
+    const result = await api.executeQuery(props.connectionId, props.executionDatabase ?? props.database ?? "", sql, countTarget.schema);
+    const total = Number(result.rows?.[0]?.[0] ?? 0);
+    if (total <= 0) return;
+    const lastPageNum = Math.ceil(total / pageSize.value);
+    if (lastPageNum <= currentPage.value) return;
+    currentPage.value = lastPageNum;
+    resetGridVerticalScroll(true);
+    emit("paginate", (lastPageNum - 1) * pageSize.value, pageSize.value, currentWhereInput(), currentOrderBy());
+  } catch {
+    // COUNT query failed — ignore silently
+  }
+}
+
+async function buildCurrentCountTarget(): Promise<{ sql: string; schema?: string } | undefined> {
+  if (props.countSql) return { sql: props.countSql, schema: props.schema };
+  if (props.tableMeta) {
+    const sql = await buildDataGridCountSql({
+      databaseType: props.databaseType,
+      catalog: props.tableMeta.catalog,
+      schema: props.tableMeta.schema,
+      tableName: props.tableMeta.tableName,
+      whereInput: currentWhereInput(),
+    });
+    return { sql, schema: props.context === "table-data" ? undefined : (props.tableMeta.schema ?? props.schema) };
+  }
+  return undefined;
+}
+
+async function calculateTotalRowCount() {
+  if (!props.connectionId || manualTotalRowCountLoading.value) return;
+  manualTotalRowCountLoading.value = true;
+  try {
+    const countTarget = await buildCurrentCountTarget();
+    if (!countTarget?.sql) return;
+    const result = await api.executeQuery(props.connectionId, props.executionDatabase ?? props.database ?? "", countTarget.sql, countTarget.schema);
+    const total = Number(result.rows?.[0]?.[0] ?? 0);
+    if (Number.isFinite(total) && total >= 0) {
+      manualTotalRowCount.value = total;
+    }
+  } catch (e: any) {
+    toast(t("grid.calculateTotalRowsFailed", { message: e?.message || String(e) }), 5000);
+  } finally {
+    manualTotalRowCountLoading.value = false;
+  }
+}
+
+// --- Editing (composable) ---
+
+interface RowItem {
+  id: number;
+  displayIndex: number;
+  sourceIndex?: number;
+  newIndex?: number;
+  data: CellValue[];
+  isNew: boolean;
+  isDraft?: boolean;
+  isDeleted: boolean;
+  isDirtyCol: boolean[];
+  status: RowStatus;
+}
+
+type DisplayRowRef =
+  | {
+      id: number;
+      displayIndex: number;
+      sourceIndex: number;
+      isNew: false;
+      isDeleted: boolean;
+      status: RowStatus;
+    }
+  | {
+      id: number;
+      displayIndex: number;
+      newIndex: number;
+      isNew: true;
+      isDeleted: false;
+      status: RowStatus;
+    }
+  | {
+      id: number;
+      displayIndex: number;
+      isNew: false;
+      isDraft: true;
+      isDeleted: false;
+      status: RowStatus;
+    };
+
+const editor = useDataGridEditor({
+  result: computed(() => props.result),
+  editable: computed(() => props.editable),
+  databaseType: computed(() => props.databaseType),
+  connectionId: computed(() => props.connectionId),
+  database: computed(() => props.executionDatabase ?? props.database),
+  tableMeta: computed(() => props.tableMeta),
+  sourceColumns: computed(() => props.sourceColumns),
+  canEditExistingRows,
+  onExecuteSql: computed(() => props.onExecuteSql),
+  customSaveHandler: computed(() => props.customSaveHandler),
+  sql: computed(() => props.sql),
+  searchText,
+  whereFilterInput,
+  currentWhereInput: computed(() => currentWhereInput()),
+  orderByInput,
+  rowStatusFilter,
+  dataGridQuickEntryEnabled: computed(() => settingsStore.editorSettings.dataGridQuickEntry),
+  initialEditColumn: firstVisibleColumnIndex,
+  getRowItem,
+  pageSize,
+  currentPage,
+  cacheKey: computed(() => props.cacheKey),
+  emit,
+});
+
+const {
+  editingCell,
+  editValue,
+  scrollerRef,
+  dirtyRows,
+  newRows,
+  deletedRows,
+  quickEntryDraftRow,
+  quickEntryDraftRowId,
+  pendingChangesVersion,
+  pendingChangeCount,
+  hasPendingChanges,
+  transactionActive,
+  isSaving,
+  saveError,
+  useTransaction,
+  exitTransaction,
+  startEdit,
+  commitEdit,
+  commitEditAndMaybeAutoSave,
+  commitEditFromBlur,
+  applyCellValue,
+  restoreCellValue,
+  cancelEdit,
+  onEditKeydown,
+  addRow: addEditorRow,
+  cloneRow,
+  showDeleteRowConfirm,
+  requestDeleteRow,
+  confirmDeleteRow,
+  restoreRow,
+  restoreRows,
+  pendingDeleteRowIds,
+  requestDeleteRows,
+  cloneRows,
+  saveChanges,
+  discardChanges,
+  canUndoPendingChange,
+  canRedoPendingChange,
+  undoPendingChange,
+  redoPendingChange,
+  rowDataWithChanges,
+  ensureQuickEntryDraftRow,
+  isSavingNewRow,
+  canEditColumn,
+  resetGridVerticalScroll,
+  getResetScrollAfterResult,
+  clearResetScrollAfterResult,
+  cleanupFrames,
+  recordScrollPosition,
+  isPreviewLoading,
+  previewChanges,
+} = editor;
+const pendingQuickEntryDraftCellFocus = ref<{ rowId: number; col: number } | null>(null);
+
+const showSqlPreview = ref(false);
+const previewSqlText = ref("");
+
+let previewRefreshTimer: ReturnType<typeof setTimeout> | null = null;
+
+async function refreshPreviewSql() {
+  if (!showSqlPreview.value) return;
+  const stmts = await previewChanges();
+  if (showSqlPreview.value) {
+    previewSqlText.value = stmts.join("\n");
+  }
+}
+
+function schedulePreviewRefresh() {
+  if (!showSqlPreview.value) return;
+  if (pendingChangeCount.value === 0) {
+    // Keep the panel visible so undo/redo results are explicit in the SQL preview area.
+    previewSqlText.value = "";
+    return;
+  }
+  if (previewRefreshTimer) clearTimeout(previewRefreshTimer);
+  previewRefreshTimer = setTimeout(() => {
+    previewRefreshTimer = null;
+    void refreshPreviewSql();
+  }, 500);
+}
+
+async function openSqlPreview() {
+  const stmts = await previewChanges();
+  previewSqlText.value = stmts.join("\n");
+  if (stmts.length > 0) {
+    showSqlPreview.value = true;
+  }
+}
+
+function closeSqlPreview() {
+  showSqlPreview.value = false;
+  if (previewRefreshTimer) {
+    clearTimeout(previewRefreshTimer);
+    previewRefreshTimer = null;
+  }
+}
+
+// Watch for edits — auto-refresh preview when panel is open
+watch([pendingChangeCount, pendingChangesVersion], () => {
+  schedulePreviewRefresh();
+});
+
+const saveActionMode = computed(() =>
+  dataGridSaveActionMode({
+    pendingChangeCount: pendingChangeCount.value,
+    useTransaction: !!useTransaction.value,
+  }),
+);
+const saveToolbarState = computed(() =>
+  dataGridSaveToolbarState({
+    editable: props.editable,
+    hasSaveTarget: hasDataGridSaveTarget.value,
+    hasPendingChanges: hasPendingChanges.value,
+    isSaving: isSaving.value,
+  }),
+);
+const hasSearchBarSlot = computed(() => !!slots["search-bar"]);
+const hasResultToolbarLeadingSlot = computed(() => !!slots["result-toolbar-leading"]);
+const hasResultToolbarActionsSlot = computed(() => !!slots["result-toolbar-actions"]);
+const quickEntryEnabled = computed(() => settingsStore.editorSettings.dataGridQuickEntry);
+const showQuickEntryDraftRow = computed(() =>
+  shouldShowQuickEntryDraftRow({
+    editable: !!props.editable,
+    hasInsertTarget: hasDataGridInsertTarget.value,
+    quickEntryEnabled: quickEntryEnabled.value,
+    rowStatusFilter: rowStatusFilter.value,
+    hasPendingChanges: hasPendingChanges.value,
+  }),
+);
+const showDataGridTopbar = computed(
+  () =>
+    (useTransaction.value && !!props.editable && hasDataGridSaveTarget.value) ||
+    hasLocalColumnFilters.value ||
+    canShowWhereSearch.value ||
+    hasSearchBarSlot.value ||
+    hasResultToolbarLeadingSlot.value ||
+    hasResultToolbarActionsSlot.value ||
+    showQueryEditReadOnlyBadge.value ||
+    props.context !== "results" ||
+    (!!props.editable && hasDataGridSaveTarget.value) ||
+    transactionActive.value ||
+    saveToolbarState.value.showActions,
+);
+
+function canEditRowItem(item: RowItem | undefined): boolean {
+  return !!props.editable && !!item && !item.isDeleted && (item.isNew || item.isDraft || canEditExistingRows.value);
+}
+
+function canEditCellItem(item: RowItem | undefined, columnIndex: number): boolean {
+  if (!canEditRowItem(item) || !canEditColumn(columnIndex)) return false;
+  if (isSavingNewRow(item)) return false;
+  const column = props.result.columns[columnIndex] ?? "";
+  if (customReadonlyColumns.value.has(column.toLowerCase())) return false;
+  if (!item?.isNew && !item?.isDraft) {
+    const sourceColumn = props.sourceColumns?.[columnIndex] ?? column;
+    if (isClickHouseExistingRowReadonlyColumn(props.databaseType, sourceColumn, props.tableMeta?.primaryKeys ?? [], props.tableMeta?.columns ?? [])) return false;
+    if (isTdengineExistingRowReadonlyColumn(props.databaseType, column, props.tableMeta?.columns ?? [])) return false;
+  }
+  return true;
+}
+
+function cellUsesExpandedEditor(rowId: number | undefined, columnIndex: number): boolean {
+  return !!expandedCellEditor.value && expandedCellEditor.value.rowId === rowId && expandedCellEditor.value.col === columnIndex;
+}
+
+function startCellEdit(rowId: number, columnIndex: number, expanded: boolean) {
+  expandedCellEditor.value = expanded ? { rowId, col: columnIndex } : null;
+  startEdit(rowId, columnIndex);
+}
+
+function startDomCellEdit(rowId: number, columnIndex: number, displayText: string, event: MouseEvent) {
+  const item = getRowItem(rowId);
+  const editText = item ? cellEditorTextForValue(item.data[columnIndex], columnIndex) : displayText;
+  startCellEdit(rowId, columnIndex, cellEditContentNeedsExpandedEditor({ displayText, editText, target: event.currentTarget }));
+}
+
+function cellEditContentNeedsExpandedEditor(options: { displayText: string; editText: string; target: EventTarget | null }): boolean {
+  const text = options.editText || options.displayText;
+  if (text.includes("\n") || text.includes("\r")) return true;
+  if (text.length > options.displayText.length) return true;
+  return cellTextOverflowsElement(options.displayText, options.target);
+}
+
+function cellEditorTextForValue(value: CellValue | undefined, columnIndex: number): string {
+  return dataGridCellEditorText({
+    value: value ?? null,
+    databaseType: props.databaseType,
+    columnInfo: tableColumnForGridColumn(columnIndex),
+  });
+}
+
+function cellTextOverflowsElement(text: string, target: EventTarget | null): boolean {
+  if (!(target instanceof HTMLElement)) return false;
+  const style = window.getComputedStyle(target);
+  const paddingLeft = Number.parseFloat(style.paddingLeft) || 0;
+  const paddingRight = Number.parseFloat(style.paddingRight) || 0;
+  const availableWidth = Math.max(0, target.clientWidth - paddingLeft - paddingRight - 2);
+  return measureCellTextWidth(text, style.font) > availableWidth;
+}
+
+function measureCellTextWidth(text: string, font: string): number {
+  const canvas = canvasRef.value ?? document.createElement("canvas");
+  const context = canvas.getContext("2d");
+  if (!context) return 0;
+  context.save();
+  context.font = font;
+  const width = context.measureText(text).width;
+  context.restore();
+  return width;
+}
+
+function tableColumnForGridColumn(columnIndex: number): ColumnInfo | undefined {
+  const columnName = props.sourceColumns?.[columnIndex] ?? props.result.columns[columnIndex];
+  if (!columnName) return undefined;
+  return props.tableMeta?.columns.find((column) => column.name.toLowerCase() === columnName.toLowerCase());
+}
+
+function resultColumnInfoForGridColumn(columnIndex: number): Pick<ColumnInfo, "data_type"> | undefined {
+  const dataType = props.result.column_types?.[columnIndex]?.trim();
+  return dataType ? { data_type: dataType } : undefined;
+}
+
+function temporalEditorConfigForColumn(columnIndex: number): TemporalCellEditorConfig | undefined {
+  return temporalCellEditorConfig(tableColumnForGridColumn(columnIndex), props.databaseType);
+}
+
+function enumValuesForGridColumn(columnIndex: number): string[] {
+  return tableColumnForGridColumn(columnIndex)?.enum_values ?? [];
+}
+
+function isEnumGridColumn(columnIndex: number): boolean {
+  return (tableColumnForGridColumn(columnIndex)?.enum_values?.length ?? 0) > 0;
+}
+
+function isEnumGridColumnNullable(columnIndex: number): boolean {
+  return tableColumnForGridColumn(columnIndex)?.is_nullable ?? false;
+}
+
+function isEnumEditorInitialNull(rowId: number | undefined, columnIndex: number): boolean {
+  if (rowId === undefined) return false;
+  return getRowItem(rowId)?.data[columnIndex] === null;
+}
+
+function cellEditInputModeForColumn(columnIndex: number): "decimal" | "numeric" | undefined {
+  const dataType = normalizedColumnDataType(tableColumnForGridColumn(columnIndex));
+  if (isIntegerColumnType(dataType)) return "numeric";
+  if (isDecimalColumnType(dataType)) return "decimal";
+  return undefined;
+}
+
+function normalizedColumnDataType(column: ColumnInfo | undefined): string {
+  return (column?.data_type ?? "").trim().toLowerCase();
+}
+
+function isIntegerColumnType(dataType: string): boolean {
+  return /^(tinyint|smallint|mediumint|int|integer|bigint|serial|smallserial|bigserial|int2|int4|int8|uint|uint8|uint16|uint32|uint64)\b/.test(dataType);
+}
+
+function isDecimalColumnType(dataType: string): boolean {
+  return /^(decimal|numeric|number|float|double|real|money|smallmoney|dec|fixed)\b/.test(dataType);
+}
+
+function canDeleteRowItem(item: RowItem | undefined): boolean {
+  if (!item) return false;
+  return canDeleteGridRowItem({
+    editable: !!props.editable && canDeleteRows.value,
+    isDraft: !!item.isDraft,
+    isDeleted: item.isDeleted,
+    isNew: item.isNew,
+    canEditExistingRows: canEditExistingRows.value && canDeleteExistingRows.value,
+    isSavingNewRow: isSavingNewRow(item),
+  });
+}
+
+function resetInfiniteScrollState() {
+  currentPage.value = 1;
+  lastInfiniteScrollPage = 0;
+  infiniteScrollAllLoaded = false;
+  isInfiniteScrollPaginating.value = false;
+  infiniteScrollLoading.value = false;
+  infiniteScrollPositions = new WeakMap();
+  resetGridVerticalScroll(true);
+}
+
+async function onToolbarRefresh() {
+  if (transactionActive.value) {
+    discardChanges();
+  }
+  // Reset infinite scroll state on refresh
+  if (infiniteScrollEnabled.value) {
+    resetInfiniteScrollState();
+  }
+  preserveTransposeOnNextResult.value = showTranspose.value;
+  isRefreshingData.value = true;
+  emit("reload", props.sql, searchText.value, currentWhereInput(), currentOrderBy(), pageSize.value, (currentPage.value - 1) * pageSize.value, "refresh");
+}
+
+function stopAutoRefreshTimer() {
+  clearInterval(autoRefreshTimer);
+  autoRefreshTimer = undefined;
+}
+
+function runAutoRefreshTick() {
+  if (!autoRefreshEnabled.value || !canAutoRefresh.value) return;
+  void onToolbarRefresh();
+}
+
+function restartAutoRefreshTimer() {
+  stopAutoRefreshTimer();
+  if (!autoRefreshEnabled.value) return;
+  autoRefreshTimer = setInterval(runAutoRefreshTick, autoRefreshIntervalSeconds.value * 1000);
+}
+
+function setAutoRefreshInterval(seconds: number) {
+  autoRefreshIntervalSeconds.value = seconds;
+  if (autoRefreshEnabled.value) restartAutoRefreshTimer();
+}
+
+function toggleAutoRefresh() {
+  autoRefreshEnabled.value = !autoRefreshEnabled.value;
+  if (autoRefreshEnabled.value) {
+    restartAutoRefreshTimer();
+  } else {
+    stopAutoRefreshTimer();
+  }
+}
+
+async function onToolbarCommit() {
+  await saveChanges();
+}
+
+function onToolbarRollback() {
+  preserveTransposeOnNextResult.value = showTranspose.value;
+  discardChanges();
+  // Reset infinite scroll state on rollback
+  if (infiniteScrollEnabled.value) {
+    resetInfiniteScrollState();
+  }
+  isRefreshingData.value = true;
+  emit("reload", props.sql, searchText.value, currentWhereInput(), currentOrderBy(), pageSize.value, (currentPage.value - 1) * pageSize.value);
+}
+
+function addRow() {
+  if (!canInsertRows.value) return;
+  addEditorRow();
+  focusAppendedTransposeRecord();
+}
+
+const sortedRows = computed(() => {
+  let indices = localFilteredRows.value;
+  const q = deferredClientSearchText.value;
+  if (q && dataGridSearchMode.value === "filter") {
+    // Preserve the legacy Ctrl+F behavior when the user chooses row filtering.
+    const rows = props.result.rows;
+    indices = indices.filter((sourceIndex) => {
+      const data = rows[sourceIndex];
+      return data.some((cell, columnIndex) => cell !== null && formatCellCached(cell, columnIndex).toLowerCase().includes(q));
+    });
+  }
+  return indices;
+});
+
+const cleanDirtyColumns = computed(() => Object.freeze(Array(props.result.columns.length).fill(false)) as boolean[]);
+
+function dirtyColumnsForRow(dirty: Map<number, CellValue> | undefined, columnCount: number): boolean[] {
+  if (!dirty?.size) return cleanDirtyColumns.value;
+  const flags = Array(columnCount).fill(false) as boolean[];
+  for (const colIdx of dirty.keys()) {
+    if (colIdx >= 0 && colIdx < columnCount) flags[colIdx] = true;
+  }
+  return flags;
+}
+
+const displayRowRefs = computed<DisplayRowRef[]>(() => {
+  const refs: DisplayRowRef[] = [];
+  for (const sourceIndex of sortedRows.value) {
+    const dirty = dirtyRows.value.get(sourceIndex);
+    const isDeleted = deletedRows.value.has(sourceIndex);
+    const status: RowStatus = isDeleted ? "deleted" : dirty?.size ? "edited" : "clean";
+    const isActiveEditingRow = quickEntryEnabled.value && editingCell.value?.rowId === sourceIndex;
+    if (matchesRowStatusFilter(status, rowStatusFilter.value) || isActiveEditingRow) {
+      refs.push({ id: sourceIndex, displayIndex: refs.length, sourceIndex, isNew: false, isDeleted, status });
+    }
+  }
+  newRows.value.forEach((row, i) => {
+    if (!rowMatchesLocalColumnFilters(row)) return;
+    const status: RowStatus = "new";
+    if (!matchesRowStatusFilter(status, rowStatusFilter.value)) return;
+    refs.push({
+      id: -(i + 1),
+      displayIndex: refs.length,
+      newIndex: i,
+      isNew: true,
+      isDeleted: false,
+      status,
+    });
+  });
+  if (showQuickEntryDraftRow.value) {
+    ensureQuickEntryDraftRow();
+    refs.push({
+      id: quickEntryDraftRowId,
+      displayIndex: refs.length,
+      isNew: false,
+      isDraft: true,
+      isDeleted: false,
+      status: "draft",
+    });
+  }
+  return refs;
+});
+
+const displayRowCount = computed(() => displayRowRefs.value.length);
+
+const displayRowIndexByIdLookup = computed(() => {
+  const lookup = new Map<number, number>();
+  displayRowRefs.value.forEach((ref, index) => {
+    lookup.set(ref.id, index);
+  });
+  return lookup;
+});
+
+function rowItemFromDisplayRef(ref: DisplayRowRef): RowItem {
+  if (ref.isNew) {
+    return {
+      ...ref,
+      data: newRows.value[ref.newIndex] ?? cleanDirtyColumns.value.map(() => null),
+      isDirtyCol: cleanDirtyColumns.value,
+    };
+  }
+  if (!("sourceIndex" in ref)) {
+    ensureQuickEntryDraftRow();
+    return {
+      ...ref,
+      data: quickEntryDraftRow.value,
+      isDirtyCol: cleanDirtyColumns.value,
+    };
+  }
+  const row = props.result.rows[ref.sourceIndex] ?? [];
+  const dirty = dirtyRows.value.get(ref.sourceIndex);
+  return {
+    ...ref,
+    data: rowDataWithChanges(row, ref.sourceIndex),
+    isDirtyCol: dirtyColumnsForRow(dirty, props.result.columns.length),
+  };
+}
+
+function displayItemAt(rowIndex: number): RowItem | undefined {
+  const ref = displayRowRefs.value[rowIndex];
+  return ref ? rowItemFromDisplayRef(ref) : undefined;
+}
+
+function displayRowIndexById(rowId: number): number {
+  // Multi-row actions call getRowItem for each selected row; keep that lookup O(1).
+  return displayRowIndexByIdLookup.value.get(rowId) ?? -1;
+}
+
+const displayItems = computed<RowItem[]>(() => displayRowRefs.value.map(rowItemFromDisplayRef));
+
+watch(
+  () => displayRowCount.value,
+  (length) => {
+    const shouldLogTiming = isDebugLoggingEnabled();
+    const startedAt = shouldLogTiming ? performance.now() : 0;
+    if (shouldLogTiming) {
+      logDataGridTiming("[DBX][DataGrid:display-items:ready]", {
+        traceId: dataGridTraceId,
+        cacheKey: props.cacheKey,
+        displayItemCount: length,
+        sourceRowCount: props.result.rows.length,
+        elapsedSinceSetup: dataGridElapsed(),
+      });
+    }
+    nextTick(() => {
+      const scrollerEl = gridRef.value?.querySelector<HTMLElement>(".data-grid-scroller");
+      if (scrollerEl) {
+        updateGridScrollbarGutter(scrollerEl);
+        updateGridHorizontalViewport(scrollerEl);
+      }
+      if (!shouldLogTiming) return;
+      requestAnimationFrame(() => {
+        const renderedRows = gridRef.value?.querySelectorAll(".vue-recycle-scroller__item-view").length;
+        logDataGridTiming("[DBX][DataGrid:display-items:first-frame]", {
+          traceId: dataGridTraceId,
+          cacheKey: props.cacheKey,
+          displayItemCount: length,
+          renderedRows,
+          elapsed: `${Math.round(performance.now() - startedAt)}ms`,
+          elapsedSinceSetup: dataGridElapsed(),
+          loading: props.loading,
+        });
+      });
+    });
+  },
+  { immediate: true },
+);
+
+interface SearchMatch {
+  kind: "cell" | "column";
+  displayRow: number; // -1 for column matches
+  col: number;
+}
+
+const searchMatches = computed<SearchMatch[]>(() => {
+  const q = deferredClientSearchText.value;
+  if (!q) return [];
+  const lowered = q.toLowerCase();
+  const items = displayItems.value;
+  const matches: SearchMatch[] = [];
+
+  // Column name matches (navigate first)
+  for (let c = 0; c < props.result.columns.length; c++) {
+    if (props.result.columns[c].toLowerCase().includes(lowered)) {
+      matches.push({ kind: "column", displayRow: -1, col: c });
+    }
+  }
+
+  // Cell value matches
+  for (let r = 0; r < items.length; r++) {
+    const data = items[r].data;
+    for (let c = 0; c < data.length; c++) {
+      if (data[c] !== null && formatCellCached(data[c], c).toLowerCase().includes(lowered)) {
+        matches.push({ kind: "cell", displayRow: r, col: c });
+      }
+    }
+  }
+  return matches;
+});
+
+const searchMatchSet = computed(() => {
+  const set = new Set<string>();
+  for (const m of searchMatches.value) {
+    set.add(`${m.kind}:${m.displayRow}:${m.col}`);
+  }
+  return set;
+});
+
+const currentSearchMatch = computed(() => {
+  const idx = currentMatchIndex.value;
+  if (idx < 0 || idx >= searchMatches.value.length) return null;
+  return searchMatches.value[idx] ?? null;
+});
+
+watch(searchMatches, (matches) => {
+  currentMatchIndex.value = matches.length > 0 ? 0 : -1;
+  if (matches.length > 0) nextTick(scrollToCurrentMatch);
+});
+
+function cellIsSearchMatch(displayRow: number, col: number): boolean {
+  if (isScrolling.value) return false;
+  return searchMatchSet.value.has(`cell:${displayRow}:${col}`);
+}
+
+function cellIsCurrentMatch(displayRow: number, col: number): boolean {
+  if (isScrolling.value) return false;
+  const m = currentSearchMatch.value;
+  if (!m) return false;
+  return m.kind === "cell" && m.displayRow === displayRow && m.col === col;
+}
+
+// Transpose view renders fields as rows; a column-name match (displayRow = -1)
+// maps to the field row header at the field's column index.
+function transposeHeaderIsSearchMatch(fieldIndex: number): boolean {
+  if (isScrolling.value) return false;
+  return searchMatchSet.value.has(`column:-1:${fieldIndex}`);
+}
+
+function transposeHeaderIsCurrentMatch(fieldIndex: number): boolean {
+  if (isScrolling.value) return false;
+  const m = currentSearchMatch.value;
+  if (!m) return false;
+  return m.kind === "column" && m.col === fieldIndex;
+}
+
+function navigateMatch(delta: number) {
+  const total = searchMatches.value.length;
+  if (total === 0) return;
+  currentMatchIndex.value = (currentMatchIndex.value + delta + total) % total;
+  scrollToCurrentMatch();
+}
+
+function scrollToCurrentMatch() {
+  const idx = currentMatchIndex.value;
+  if (idx < 0 || idx >= searchMatches.value.length) return;
+  const match = searchMatches.value[idx];
+  if (showTranspose.value) {
+    scrollTransposeMatchIntoView(match);
+    return;
+  }
+  const visibleColIdx = visibleColumnIndexes.value.indexOf(match.col);
+  if (visibleColIdx >= 0) scrollGridColumnIntoView(visibleColIdx);
+  if (match.kind === "column") {
+    // Scroll to top so the column header is visible
+    const scrollEl = gridRef.value;
+    if (scrollEl) scrollEl.scrollTop = 0;
+    if (useCanvasGridRows.value) {
+      const scroller = canvasScrollerElement();
+      if (scroller) scroller.scrollTop = 0;
+    }
+    return;
+  }
+  const scrollEl = gridRef.value;
+  if (!scrollEl) return;
+  if (useCanvasGridRows.value) {
+    const scroller = canvasScrollerElement();
+    if (!scroller) return;
+    const targetTop = Math.max(0, match.displayRow * CANVAS_DATA_GRID_ROW_HEIGHT - (scroller.clientHeight - CANVAS_DATA_GRID_ROW_HEIGHT) / 2);
+    scroller.scrollTop = targetTop;
+    syncCanvasViewport();
+    return;
+  }
+  const rowEl = scrollEl.querySelector(`[data-row-index="${match.displayRow}"]`) as HTMLElement | null;
+  if (rowEl) rowEl.scrollIntoView({ block: "center" });
+}
+
+// In transpose view records are columns (horizontal) and fields are rows
+// (vertical). Bring the matched record column into the horizontal viewport and
+// the matched field row into the vertical viewport.
+function scrollTransposeMatchIntoView(match: SearchMatch) {
+  nextTick(() => {
+    const scroller = transposeScrollRef.value;
+    // Both match kinds use `col` as the field (transpose row) index: cell
+    // matches store the field/value index, column-name matches store the field.
+    const fieldIndex = match.col;
+    if (scroller && !(scroller instanceof HTMLElement)) {
+      // RecycleScroller component instance exposes scrollToItem via vue-virtual-scroller.
+      (scroller as { scrollToItem?: (index: number) => void }).scrollToItem?.(fieldIndex);
+    } else if (scroller instanceof HTMLElement) {
+      scroller.scrollTop = fieldIndex * 30;
+    }
+    if (match.kind === "cell") {
+      scrollTransposeRecordIntoView(match.displayRow);
+    }
+  });
+}
+
+function getRowItem(rowId: number): RowItem | undefined {
+  const rowIndex = displayRowIndexById(rowId);
+  return rowIndex >= 0 ? displayItemAt(rowIndex) : undefined;
+}
+
+function visibleRowData(row: CellValue[]): CellValue[] {
+  return visibleColumnIndexes.value.map((index) => row[index]);
+}
+
+function visibleDirtyColumns(row: boolean[]): boolean[] {
+  return visibleColumnIndexes.value.map((index) => row[index] ?? false);
+}
+
+const visibleDisplayItems = computed<RowItem[]>(() =>
+  displayItems.value.map((item) => ({
+    ...item,
+    data: visibleRowData(item.data),
+    isDirtyCol: visibleDirtyColumns(item.isDirtyCol),
+  })),
+);
+const exportContextCell = computed(() => {
+  if (!contextCell.value) return null;
+  const visibleCol = visibleColumnIndexes.value.indexOf(contextCell.value.col);
+  return { ...contextCell.value, col: visibleCol };
+});
+
+const deleteRowDetails = computed(() => (props.tableMeta?.tableName ? t("dangerDialog.deleteRowDetails", { table: props.tableMeta.tableName }) : t("dangerDialog.deleteRowDetailsNoTable")));
+
+const hasVisibleRows = computed(() => displayRowCount.value > 0);
+const hasActiveFilter = computed(() => (dataGridSearchMode.value === "filter" && !!deferredClientSearchText.value) || rowStatusFilter.value !== "all" || hasLocalColumnFilters.value);
+const emptyTitle = computed(() => (hasActiveFilter.value ? t("grid.noFilteredRows") : t("grid.noRows")));
+const emptyDescription = computed(() => (hasActiveFilter.value ? t("grid.noFilteredRowsDescription") : t("grid.noRowsDescription")));
+watch(
+  () => [hasVisibleRows.value, props.result.columns.length] as const,
+  () => {
+    nextTick(refreshGridScrollerMetrics);
+  },
+  { immediate: true },
+);
+const isErrorResult = computed(() => props.result.columns.length === 1 && props.result.columns[0] === "Error" && props.result.rows.length > 0);
+const errorMessage = computed(() => (isErrorResult.value ? String(props.result.rows[0]?.[0] ?? "") : ""));
+// --- Selection composable ---
+const selection = useDataGridSelection({
+  columns: visibleColumns,
+  displayItems: visibleDisplayItems,
+  editingCell,
+  showTranspose,
+  transposeRowIndex,
+  gridRef,
+  getScrollElement: dataGridSelectionScroller,
+  cellFromClientPoint: dataGridCellFromClientPoint,
+});
+
+const {
+  isSelectingAll,
+  selectedRange,
+  selectedCells,
+  selectedCellCount,
+  hasCellSelection,
+  clearCellSelection,
+  selectSingleCell,
+  selectRow,
+  selectColumn,
+  selectAllCells,
+  extendCellSelectionTo,
+  finishCellSelection,
+  extendCellSelection,
+  cellIsSelected,
+  columnIsSelected,
+  selectedRangeStart,
+  selectedRowIds,
+  selectedColumnIndexes,
+  hasRowSelection,
+  selectedRowCount,
+  hasColumnSelection,
+  clearRowSelection,
+  handleRowClick,
+  handleDataCellMousedown,
+  isRowSelected,
+} = selection;
+
+const multiRowCount = computed(() => {
+  if (hasRowSelection.value) return selectedRowCount.value;
+  const range = selectedRange.value;
+  if (range && range.startRow !== range.endRow) return range.endRow - range.startRow + 1;
+  return 1;
+});
+
+const selectionSummary = computed(() => (hasCellSelection.value ? summarizeSelection(selectedCells.value) : null));
+const selectionSummarySumText = computed(() => {
+  const summary = selectionSummary.value;
+  if (!summary) return "0";
+  const sum = Object.is(summary.sum, -0) ? 0 : summary.sum;
+  return Number.isInteger(sum) ? String(sum) : sum.toLocaleString(undefined, { maximumFractionDigits: 12 });
+});
+
+const isMultiRow = computed(() => multiRowCount.value > 1);
+
+function onCellMouseenter(rowIndex: number, visibleColIdx: number, actualColIdx: number) {
+  if (!isScrolling.value) hoveredDetailCell.value = { rowIndex, col: actualColIdx };
+  extendCellSelection(rowIndex, visibleColIdx);
+}
+
+function onCellMouseleave(rowIndex: number, actualColIdx: number) {
+  if (isScrolling.value) return;
+  if (hoveredDetailCell.value?.rowIndex === rowIndex && hoveredDetailCell.value.col === actualColIdx) {
+    hoveredDetailCell.value = null;
+  }
+}
+
+function quickDownloadMenuOpenFor(rowIndex: number, actualColIdx: number): boolean {
+  return quickDownloadMenuCell.value?.rowIndex === rowIndex && quickDownloadMenuCell.value.col === actualColIdx;
+}
+
+function handleQuickDownloadMenuOpenChange(open: boolean, rowIndex: number, actualColIdx: number) {
+  if (open) {
+    quickDownloadMenuCell.value = { rowIndex, col: actualColIdx };
+    hoveredDetailCell.value = { rowIndex, col: actualColIdx };
+    return;
+  }
+  if (quickDownloadMenuOpenFor(rowIndex, actualColIdx)) {
+    quickDownloadMenuCell.value = null;
+  }
+}
+
+function cellDetailButtonVisible(rowIndex: number, actualColIdx: number) {
+  if (isScrolling.value) return false;
+  return (hoveredDetailCell.value?.rowIndex === rowIndex && hoveredDetailCell.value.col === actualColIdx) || quickDownloadMenuOpenFor(rowIndex, actualColIdx) || (showCellDetail.value && detailCell.value?.rowIndex === rowIndex && detailCell.value.col === actualColIdx);
+}
+
+function affectedRowIds(): number[] {
+  if (hasRowSelection.value && selectedRowCount.value > 0) {
+    return [...selectedRowIds.value].filter((rowId) => !getRowItem(rowId)?.isDraft);
+  }
+  const range = selectedRange.value;
+  if (range && range.startRow !== range.endRow) {
+    return displayRowRefs.value
+      .slice(range.startRow, range.endRow + 1)
+      .filter((ref) => !("isDraft" in ref && ref.isDraft))
+      .map((ref) => ref.id);
+  }
+  return [];
+}
+
+function deletableRowIds(rowIds: number[]): number[] {
+  return rowIds.filter((rowId) => canDeleteRowItem(getRowItem(rowId)));
+}
+
+function exportSelectedRowsCsv() {
+  const rowIds = affectedRowIds();
+  if (rowIds.length === 0) return;
+  return exportCsv(rowIds);
+}
+
+function exportSelectedRowsXlsx() {
+  const rowIds = affectedRowIds();
+  if (rowIds.length === 0) return;
+  return exportXlsx(rowIds);
+}
+
+function exportSelectedRowsJson() {
+  const rowIds = affectedRowIds();
+  if (rowIds.length === 0) return;
+  return exportJson(rowIds);
+}
+
+function exportSelectedRowsMarkdown() {
+  const rowIds = affectedRowIds();
+  if (rowIds.length === 0) return;
+  return exportMarkdown(rowIds);
+}
+
+function exportSelectedRowsSql() {
+  const rowIds = affectedRowIds();
+  if (rowIds.length === 0) return;
+  return exportSql(rowIds);
+}
+
+function executePreviewAction(action: { execute: (ctx: any) => any }) {
+  const config = action.execute({
+    result: props.result,
+    selectedRowIds: affectedRowIds(),
+    displayRowRefs: displayRowRefs.value.filter((ref) => "sourceIndex" in ref),
+  });
+  if (config) {
+    previewDialogConfig.value = config;
+    previewDialogOpen.value = true;
+  }
+}
+
+function isRowActive(index: number): boolean {
+  const item = displayItemAt(index);
+  if (item && isRowSelected(item.id)) return true;
+  const range = selectedRange.value;
+  if (!range) return false;
+  const coversAllVisibleRows = range.startRow === 0 && range.endRow >= displayRowCount.value - 1;
+  const coversAllVisibleColumns = range.startCol === 0 && range.endCol >= visibleColumnCount.value - 1;
+  if (coversAllVisibleRows && !coversAllVisibleColumns) return false;
+  return index >= range.startRow && index <= range.endRow;
+}
+
+const contextRowItem = computed(() => (contextCell.value ? getRowItem(contextCell.value.rowId) : undefined));
+const contextColumn = computed(() => {
+  if (!contextCell.value || contextCell.value.col < 0) return null;
+  return props.result.columns[contextCell.value.col] ?? null;
+});
+const contextCellValue = computed<CellValue | null>(() => {
+  if (!contextCell.value || contextCell.value.col < 0) return null;
+  return contextRowItem.value?.data[contextCell.value.col] ?? null;
+});
+const contextCellDetail = computed(() => {
+  const cell = contextCell.value;
+  if (!cell || cell.col < 0) return null;
+  return cellDetailFor(cell.rowIndex, cell.col);
+});
+function cellDetailFor(rowIndex: number, columnIndex: number): DataGridCellDetail | null {
+  const item = displayItemAt(rowIndex);
+  if (!item) return null;
+  return buildDataGridCellDetail({
+    rowIndex,
+    rowId: item.id,
+    row: item.data,
+    columns: props.result.columns,
+    columnIndex,
+    typeByColumn: columnTypeMap.value,
+    resultColumnTypes: props.result.column_types,
+    commentByColumn: columnCommentMap.value,
+    displayValue: (value, index) => formatCellCached(value, index),
+    isEditable: canEditGridCellDetail({ canEditCell: canEditCellItem(item, columnIndex), isDraft: !!item.isDraft }),
+  });
+}
+
+const activeCellDetail = computed(() => {
+  const cell = detailCell.value;
+  return cell ? cellDetailFor(cell.rowIndex, cell.col) : null;
+});
+
+const canShowMongoJsonPreview = computed(() => props.databaseType === "mongodb" && !!props.result.mongo_documents && props.result.mongo_documents.length === props.result.rows.length);
+const mongoJsonPreviewOpen = computed(() => showMongoJsonPreview.value && canShowMongoJsonPreview.value);
+const activeMongoJsonDocument = computed(() => {
+  if (!mongoJsonPreviewOpen.value) return undefined;
+  const selectedCell = currentSelectedCellPosition();
+  if (!selectedCell) return undefined;
+  const item = displayItemAt(selectedCell.rowIndex);
+  return item?.sourceIndex === undefined ? undefined : props.result.mongo_documents?.[item.sourceIndex];
+});
+const mongoJsonPreviewFullText = computed(() => {
+  const document = activeMongoJsonDocument.value;
+  if (document === undefined) return "";
+  try {
+    return JSON.stringify(document, null, 2) ?? "";
+  } catch {
+    return "";
+  }
+});
+const mongoJsonPreviewText = computed(() => mongoJsonPreviewFullText.value.slice(0, CELL_DETAIL_VALUE_PREVIEW_MAX_LENGTH));
+const mongoJsonPreviewTruncated = computed(() => mongoJsonPreviewText.value.length < mongoJsonPreviewFullText.value.length);
+const mongoJsonPreviewUsesCodeEditor = computed(() => !!mongoJsonPreviewText.value && !mongoJsonPreviewTruncated.value);
+
+watch(canShowMongoJsonPreview, (available) => {
+  if (!available) showMongoJsonPreview.value = false;
+});
+
+// Result-set switches remount the grid, but re-executing the same result set
+// keeps this component alive. Clear the ephemeral preview before fresh query
+// data arrives so it cannot retain a stale row selection or drawer state.
+watch(
+  () => props.loading,
+  (loading) => {
+    if (loading) showMongoJsonPreview.value = false;
+  },
+);
+
+const dialogCellDetail = computed(() => {
+  const target = cellDetailDialogTarget.value;
+  return target ? cellDetailFor(target.rowIndex, target.col) : null;
+});
+
+const cellDetailJsonFormatted = computed(() => settingsStore.editorSettings.cellDetailJsonFormatted);
+const sideDetailJsonView = computed(() => cellDetailJsonFormatted.value && !!activeCellDetail.value?.formattedJson);
+const cellDetailJsonView = computed(() => cellDetailJsonFormatted.value && !!dialogCellDetail.value?.formattedJson);
+
+const rowDetail = computed(() => {
+  if (rowDetailDialogRowId.value === null) return null;
+  const item = getRowItem(rowDetailDialogRowId.value);
+  if (!item) return null;
+  return buildDataGridRowDetail({
+    rowIndex: item.displayIndex,
+    rowId: item.id,
+    row: item.data,
+    columns: props.result.columns,
+    columnIndexes: visibleColumnIndexes.value,
+    typeByColumn: columnTypeMap.value,
+    resultColumnTypes: props.result.column_types,
+    commentByColumn: columnCommentMap.value,
+    displayValue: (value, index) => formatCellCached(value, index),
+    isEditableColumn: (columnIndex) => canEditGridCellDetail({ canEditCell: canEditCellItem(item, columnIndex), isDraft: !!item.isDraft }),
+  });
+});
+
+const columnDetail = computed(() => {
+  if (columnDetailDialogColumnIndex.value === null) return null;
+  const columnIndex = columnDetailDialogColumnIndex.value;
+  return buildDataGridColumnDetail({
+    rows: displayItems.value
+      .filter((item) => !item.isDraft)
+      .map((item) => ({
+        rowIndex: item.displayIndex,
+        rowId: item.id,
+        row: item.data,
+        isEditable: canEditGridCellDetail({ canEditCell: canEditCellItem(item, columnIndex), isDraft: !!item.isDraft }),
+      })),
+    columns: props.result.columns,
+    columnIndex,
+    typeByColumn: columnTypeMap.value,
+    resultColumnTypes: props.result.column_types,
+    commentByColumn: columnCommentMap.value,
+    displayValue: (value, index) => formatCellCached(value, index),
+  });
+});
+
+const filteredRowDetailFields = computed(() => (rowDetail.value ? filterDataGridDetailFields(rowDetail.value.fields, rowDetailSearch.value) : []));
+
+const filteredColumnDetailFields = computed(() => (columnDetail.value ? filterDataGridDetailFields(columnDetail.value.fields, columnDetailSearch.value) : []));
+
+watch(cellDetailDialogOpen, (open) => {
+  if (!open) cellDetailDialogTarget.value = null;
+});
+
+watch(rowDetailDialogOpen, (open) => {
+  if (!open) {
+    rowDetailDialogRowId.value = null;
+    rowDetailSearch.value = "";
+  }
+});
+
+watch(columnDetailDialogOpen, (open) => {
+  if (!open) {
+    columnDetailDialogColumnIndex.value = null;
+    columnDetailSearch.value = "";
+  }
+});
+
+watch(sideGeometryPreviewOpen, async (open) => {
+  if (open) {
+    await nextTick();
+    const canvas = sideGeometryCanvas.value;
+    const detail = activeCellDetail.value;
+    if (canvas && detail && detail.value !== null) {
+      renderWktOnCanvas(canvas, String(detail.value));
+    }
+  }
+});
+
+watch(dialogGeometryPreviewOpen, async (open) => {
+  if (open) {
+    await nextTick();
+    const canvas = dialogGeometryCanvas.value;
+    const detail = dialogCellDetail.value;
+    if (canvas && detail && detail.value !== null) {
+      renderWktOnCanvas(canvas, String(detail.value));
+    }
+  }
+});
+
+const activeCellDetailTabs = computed(() => {
+  const detail = activeCellDetail.value;
+  return visibleCellDetailTabs({
+    isEditable: !!detail?.isEditable,
+    hasBinaryHexViewer: isBinaryCellColumnType(detail?.type),
+  });
+});
+
+const activeBinaryHexBytes = computed(() => {
+  if (activeCellDetailTab.value !== "hexViewer") return null;
+  const detail = activeCellDetail.value;
+  return detail ? parseBinaryCellBytes(detail.value, detail.type) : null;
+});
+
+const activeBinaryHexRows = computed(() => (activeBinaryHexBytes.value ? buildBinaryHexViewRows(activeBinaryHexBytes.value) : []));
+const activeBinaryHexByteCount = computed(() => activeBinaryHexBytes.value?.length ?? 0);
+
+const activeCellDetailTabsGridClass = computed(() => {
+  const count = activeCellDetailTabs.value.length;
+  if (count >= 3) return "grid-cols-3";
+  if (count === 2) return "grid-cols-2";
+  return "grid-cols-1";
+});
+
+watch(activeCellDetailTabs, (tabs) => {
+  if (!tabs.includes(activeCellDetailTab.value)) {
+    activeCellDetailTab.value = defaultCellDetailTab();
+  }
+});
+
+watch(activeCellDetailTab, (tab) => {
+  if (tab === "valueEditor") {
+    startDetailEdit();
+  } else {
+    resetDetailEdit();
+  }
+});
+
+const activeValueEditorActions = computed(() => {
+  const detail = activeCellDetail.value;
+  return valueEditorActions({
+    canSetNull: !!detail?.isEditable && detail.value !== null,
+    canFormatJson: !!detail?.isEditable && canFormatCellDetailJson(detail.value, detail.type),
+  });
+});
+
+const detailSqlConditionCopy = ref<PreparedCopyValue>({
+  key: "",
+  text: "",
+  loading: false,
+  ready: false,
+});
+
+const detailSqlConditionKey = computed(() => {
+  const detail = activeCellDetail.value;
+  if (!detail) return "";
+  return JSON.stringify({
+    databaseType: props.databaseType ?? null,
+    column: detail.column,
+    value: detail.value,
+    type: detail.type,
+    schema: props.tableMeta?.schema ?? null,
+    tableName: props.tableMeta?.tableName ?? null,
+  });
+});
+
+function canCopyPreparedDetailSqlCondition(): boolean {
+  return detailSqlConditionCopy.value.ready && detailSqlConditionCopy.value.key === detailSqlConditionKey.value;
+}
+
+async function prefetchDetailSqlCondition() {
+  const detail = activeCellDetail.value;
+  const key = detailSqlConditionKey.value;
+  if (!detail || !key) {
+    detailSqlConditionCopy.value = {
+      key: "",
+      text: "",
+      loading: false,
+      ready: false,
+    };
+    return;
+  }
+  const current = detailSqlConditionCopy.value;
+  if ((current.loading || current.ready) && current.key === key) return;
+
+  detailSqlConditionCopy.value = {
+    key,
+    text: "",
+    loading: true,
+    ready: false,
+  };
+
+  try {
+    const condition = await buildDataGridContextFilterCondition({
+      databaseType: resolvedDatabaseType.value,
+      columnName: detail.column,
+      columnInfo: props.tableMeta?.columns.find((column) => column.name === detail.column),
+      mode: "equals",
+      value: detail.value,
+    });
+    if (detailSqlConditionCopy.value.key !== key) return;
+    detailSqlConditionCopy.value = {
+      key,
+      text: condition ?? "",
+      loading: false,
+      ready: !!condition,
+    };
+  } catch {
+    if (detailSqlConditionCopy.value.key !== key) return;
+    detailSqlConditionCopy.value = {
+      key,
+      text: "",
+      loading: false,
+      ready: false,
+    };
+  }
+}
+
+watch(activeCellDetail, (detail) => {
+  void prefetchDetailSqlCondition();
+  if (activeCellDetailTab.value !== "valueEditor") return;
+  if (!detail?.isEditable) {
+    resetDetailEdit();
+    return;
+  }
+  detailEditValue.value = dataGridCellEditorText({
+    value: detail.value,
+    databaseType: props.databaseType,
+    columnInfo: tableColumnForGridColumn(detail.colIndex),
+  });
+  syncEditorFromDetailEdit();
+  isEditingDetail.value = true;
+});
+
+const detailEditValue = ref("");
+const isEditingDetail = ref(false);
+const detailTemporalEditorConfig = computed(() => {
+  const detail = activeCellDetail.value;
+  return detail ? temporalEditorConfigForColumn(detail.colIndex) : undefined;
+});
+const sideDetailPrioritizesValue = computed(() => !cellDetailPanelIsBottom.value && !isEditingDetail.value && !!activeCellDetail.value?.formattedJson);
+const sideDetailValueFillsHeight = computed(() => cellDetailPanelIsBottom.value || isEditingDetail.value || (!cellDetailPanelIsBottom.value && !activeCellDetail.value?.imagePreviewUrl));
+const sideJsonPreviewText = computed(() => {
+  const detail = activeCellDetail.value;
+  if (!detail?.formattedJson) return "";
+  return sideDetailJsonView.value ? detail.formattedJson : detail.rawValuePreview;
+});
+const canCompactDetailJson = computed(() => {
+  const detail = activeCellDetail.value;
+  return !!detail && isEditingDetail.value && canFormatCellDetailJson(detailEditValue.value, detail.type);
+});
+const showCompactDetailJson = computed(() => {
+  const detail = activeCellDetail.value;
+  if (!detail || !isEditingDetail.value) return false;
+  return !!detail.formattedJson || looksLikeJsonContainerText(detailEditValue.value);
+});
+
+// CodeMirror-based cell detail editors
+const detailsEditorContainer = ref<HTMLElement>();
+const valueEditorContainer = ref<HTMLElement>();
+const sideJsonPreviewContainer = ref<HTMLElement>();
+const dialogJsonPreviewContainer = ref<HTMLElement>();
+const mongoJsonPreviewContainer = ref<HTMLElement>();
+let detailsDetailEditor: UseCellDetailEditorReturn | null = null;
+let valueDetailEditor: UseCellDetailEditorReturn | null = null;
+let sideJsonPreviewEditor: UseCellDetailEditorReturn | null = null;
+let dialogJsonPreviewEditor: UseCellDetailEditorReturn | null = null;
+let mongoJsonPreviewEditor: UseCellDetailEditorReturn | null = null;
+
+const editorThemeAccessor = () => settingsStore.editorSettings.theme;
+const editorAppAppearance = () => (isDark.value ? "dark" : "light") as import("@/lib/app/appTheme").AppThemeAppearance;
+const editorAppPalette = () => themePalette.value;
+const editorFontSize = () => settingsStore.editorSettings.fontSize;
+const editorFontFamily = () => settingsStore.editorSettings.fontFamily;
+const SIDE_DETAIL_EDITOR_MIN_HEIGHT = 160;
+const SIDE_DETAIL_EDITOR_MAX_HEIGHT = 360;
+const SIDE_DETAIL_EDITOR_LINE_HEIGHT = 20;
+const SIDE_DETAIL_EDITOR_SOFT_WRAP_CHARS = 48;
+const sideDetailEditorStyle = computed(() => {
+  if (cellDetailPanelIsBottom.value || isEditingDetail.value) return undefined;
+  const lines = detailEditValue.value.split(/\r\n|\r|\n/).reduce((total, line) => total + Math.max(1, Math.ceil(line.length / SIDE_DETAIL_EDITOR_SOFT_WRAP_CHARS)), 0);
+  const height = Math.min(SIDE_DETAIL_EDITOR_MAX_HEIGHT, Math.max(SIDE_DETAIL_EDITOR_MIN_HEIGHT, lines * SIDE_DETAIL_EDITOR_LINE_HEIGHT + 28));
+  return { height: `${height}px` };
+});
+
+function getDetailEditor(): UseCellDetailEditorReturn | null {
+  return activeCellDetailTab.value === "valueEditor" ? valueDetailEditor : detailsDetailEditor;
+}
+
+watch(detailsEditorContainer, async (el) => {
+  if (el && !detailsDetailEditor) {
+    detailsDetailEditor = useCellDetailEditor({
+      onChange: (v) => {
+        detailEditValue.value = v;
+      },
+      onEscape: () => cancelDetailEdit(),
+      editorTheme: editorThemeAccessor,
+      appAppearance: editorAppAppearance,
+      appPalette: editorAppPalette,
+      fontSize: editorFontSize,
+      fontFamily: editorFontFamily,
+    });
+    await detailsDetailEditor.create(el, detailEditValue.value, activeCellDetail.value?.type);
+  } else if (!el && detailsDetailEditor) {
+    detailsDetailEditor.destroy();
+    detailsDetailEditor = null;
+  }
+});
+
+watch(valueEditorContainer, async (el) => {
+  if (el && !valueDetailEditor) {
+    valueDetailEditor = useCellDetailEditor({
+      onChange: (v) => {
+        detailEditValue.value = v;
+      },
+      onEscape: () => restoreDetailOriginalValue(),
+      onBlur: () => commitValueEditorEdit(),
+      editorTheme: editorThemeAccessor,
+      appAppearance: editorAppAppearance,
+      appPalette: editorAppPalette,
+      fontSize: editorFontSize,
+      fontFamily: editorFontFamily,
+    });
+    await valueDetailEditor.create(el, detailEditValue.value, activeCellDetail.value?.type);
+  } else if (!el && valueDetailEditor) {
+    valueDetailEditor.destroy();
+    valueDetailEditor = null;
+  }
+});
+
+watch(sideJsonPreviewContainer, async (el) => {
+  if (el && !sideJsonPreviewEditor) {
+    sideJsonPreviewEditor = useCellDetailEditor({
+      language: "json",
+      readOnly: true,
+      editorTheme: editorThemeAccessor,
+      appAppearance: editorAppAppearance,
+      appPalette: editorAppPalette,
+      fontSize: editorFontSize,
+      fontFamily: editorFontFamily,
+    });
+    await sideJsonPreviewEditor.create(el, sideJsonPreviewText.value, "json");
+  } else if (!el && sideJsonPreviewEditor) {
+    sideJsonPreviewEditor.destroy();
+    sideJsonPreviewEditor = null;
+  }
+});
+
+watch(dialogJsonPreviewContainer, async (el) => {
+  if (el && !dialogJsonPreviewEditor) {
+    dialogJsonPreviewEditor = useCellDetailEditor({
+      language: "json",
+      readOnly: true,
+      editorTheme: editorThemeAccessor,
+      appAppearance: editorAppAppearance,
+      appPalette: editorAppPalette,
+      fontSize: editorFontSize,
+      fontFamily: editorFontFamily,
+    });
+    await dialogJsonPreviewEditor.create(el, dialogCellDetail.value?.formattedJson ?? "", "json");
+  } else if (!el && dialogJsonPreviewEditor) {
+    dialogJsonPreviewEditor.destroy();
+    dialogJsonPreviewEditor = null;
+  }
+});
+
+watch(mongoJsonPreviewContainer, async (el) => {
+  if (el && !mongoJsonPreviewEditor) {
+    mongoJsonPreviewEditor = useCellDetailEditor({
+      language: "json",
+      readOnly: true,
+      editorTheme: editorThemeAccessor,
+      appAppearance: editorAppAppearance,
+      appPalette: editorAppPalette,
+      fontSize: editorFontSize,
+      fontFamily: editorFontFamily,
+    });
+    await mongoJsonPreviewEditor.create(el, mongoJsonPreviewText.value, "json");
+  } else if (!el && mongoJsonPreviewEditor) {
+    mongoJsonPreviewEditor.destroy();
+    mongoJsonPreviewEditor = null;
+  }
+});
+
+watch(sideJsonPreviewText, (value) => {
+  sideJsonPreviewEditor?.setValue(value, "json");
+});
+
+watch(mongoJsonPreviewText, (value) => {
+  mongoJsonPreviewEditor?.setValue(value, "json");
+});
+
+watch(
+  () => dialogCellDetail.value?.formattedJson ?? "",
+  (value) => {
+    dialogJsonPreviewEditor?.setValue(value, "json");
+  },
+);
+
+function resetDetailEdit() {
+  isEditingDetail.value = false;
+  detailEditValue.value = "";
+}
+
+function closeCellDetails() {
+  resetDetailEdit();
+  showCellDetail.value = false;
+  detailCell.value = null;
+}
+
+function toggleMongoJsonPreview() {
+  if (!canShowMongoJsonPreview.value) return;
+  showMongoJsonPreview.value = !showMongoJsonPreview.value;
+  if (showMongoJsonPreview.value) closeCellDetails();
+}
+
+function closeMongoJsonPreview() {
+  showMongoJsonPreview.value = false;
+}
+
+function copyMongoJsonPreview() {
+  if (mongoJsonPreviewFullText.value) copyText(mongoJsonPreviewFullText.value);
+}
+
+function cellDetailEditText(detail: DataGridCellDetail): string {
+  if (sideDetailJsonView.value && detail.formattedJson) return detail.formattedJson;
+  return dataGridCellEditorText({
+    value: detail.value,
+    databaseType: props.databaseType,
+    columnInfo: tableColumnForGridColumn(detail.colIndex),
+  });
+}
+
+function warnFormattedJsonEditIfNeeded(detail: DataGridCellDetail, force = false) {
+  if (!force && (!sideDetailJsonView.value || !detail.formattedJson)) return;
+  const count = Number(safeLocalStorageGet(FORMATTED_JSON_EDIT_WARNING_COUNT_STORAGE_KEY)) || 0;
+  if (count >= FORMATTED_JSON_EDIT_WARNING_MAX_COUNT) return;
+  toast(t("grid.formattedJsonEditWarning"), 6000);
+  safeLocalStorageSet(FORMATTED_JSON_EDIT_WARNING_COUNT_STORAGE_KEY, String(count + 1));
+}
+
+function toggleCellDetailJsonFormatted() {
+  settingsStore.updateEditorSettings({ cellDetailJsonFormatted: !cellDetailJsonFormatted.value });
+}
+
+function startDetailEdit() {
+  const detail = activeCellDetail.value;
+  if (!detail || !detail.isEditable) return;
+  warnFormattedJsonEditIfNeeded(detail);
+  detailEditValue.value = cellDetailEditText(detail);
+  isEditingDetail.value = true;
+}
+
+function commitDetailEdit() {
+  const detail = activeCellDetail.value;
+  if (!detail || !isEditingDetail.value) return;
+  isEditingDetail.value = false;
+
+  const item = getRowItem(detail.rowId);
+  if (!item || item.isDeleted) return;
+  applyCellValue(detail.rowId, detail.colIndex, detailEditValue.value);
+  detailCell.value = detailCell.value ? { ...detailCell.value } : null;
+}
+
+function cancelDetailEdit() {
+  resetDetailEdit();
+}
+
+function syncEditorFromDetailEdit() {
+  const editor = getDetailEditor();
+  if (editor) {
+    editor.setValue(detailEditValue.value, activeCellDetail.value?.type);
+  }
+}
+
+function cancelValueEditorEdit() {
+  const detail = activeCellDetail.value;
+  if (!detail || !detail.isEditable) return;
+  detailEditValue.value = dataGridCellEditorText({
+    value: detail.value,
+    databaseType: props.databaseType,
+    columnInfo: tableColumnForGridColumn(detail.colIndex),
+  });
+  syncEditorFromDetailEdit();
+  isEditingDetail.value = true;
+}
+
+function commitValueEditorEdit() {
+  commitDetailEdit();
+  if (activeCellDetailTab.value === "valueEditor") {
+    isEditingDetail.value = true;
+  }
+}
+
+function restoreDetailOriginalValue() {
+  const detail = activeCellDetail.value;
+  if (!detail || !detail.isEditable) return;
+
+  const item = getRowItem(detail.rowId);
+  if (!item || item.isDeleted) return;
+
+  let restoredValue: CellValue = null;
+
+  if (!item.isNew && item.sourceIndex !== undefined) {
+    restoredValue = props.result.rows[item.sourceIndex]?.[detail.colIndex] ?? null;
+  }
+  restoreCellValue(detail.rowId, detail.colIndex);
+
+  detailEditValue.value = dataGridCellEditorText({
+    value: restoredValue,
+    databaseType: props.databaseType,
+    columnInfo: tableColumnForGridColumn(detail.colIndex),
+  });
+  syncEditorFromDetailEdit();
+  isEditingDetail.value = activeCellDetailTab.value === "valueEditor";
+  detailCell.value = { ...detailCell.value! };
+}
+
+function setValueEditorNull() {
+  setDetailNull();
+  detailEditValue.value = cellDetailEditorText(null);
+  syncEditorFromDetailEdit();
+  isEditingDetail.value = activeCellDetailTab.value === "valueEditor";
+}
+
+function formatValueEditorJson() {
+  const detail = activeCellDetail.value;
+  if (!detail || !canFormatCellDetailJson(detailEditValue.value, detail.type)) return;
+  detailEditValue.value = formatJsonText(detailEditValue.value) ?? detailEditValue.value;
+  syncEditorFromDetailEdit();
+  warnFormattedJsonEditIfNeeded(detail, true);
+}
+
+function compactDetailJson() {
+  const detail = activeCellDetail.value;
+  if (!detail || !canFormatCellDetailJson(detailEditValue.value, detail.type)) return;
+  detailEditValue.value = compactJsonText(detailEditValue.value) ?? detailEditValue.value;
+  syncEditorFromDetailEdit();
+}
+
+function setDetailNull() {
+  const detail = activeCellDetail.value;
+  if (!detail || !detail.isEditable) return;
+
+  const item = getRowItem(detail.rowId);
+  if (!item || item.isDeleted) return;
+
+  applyCellValue(detail.rowId, detail.colIndex, null);
+  resetDetailEdit();
+  detailCell.value = { ...detailCell.value! };
+}
+
+function applyColumnSort(column: string, columnIndex: number, direction: "asc" | "desc" | null, mode: DataGridSortMode = "database") {
+  if (getIsResizing()) return;
+  currentPage.value = 1;
+  resetGridVerticalScroll(true);
+  if (direction) {
+    sortCol.value = column;
+    sortColIndex.value = columnIndex;
+    sortDir.value = direction;
+    sortMode.value = mode;
+    if (mode === "database") {
+      syncOrderByInputWithSort(column, direction);
+    } else {
+      syncOrderByInputWithSort(null, null);
+    }
+  } else {
+    sortCol.value = null;
+    sortColIndex.value = null;
+    sortDir.value = "asc";
+    sortMode.value = "database";
+    syncOrderByInputWithSort(null, null);
+  }
+  emit("sort", column, columnIndex, direction, currentWhereInput(), mode);
+}
+
+function selectHeaderSort(value: string, column: string, columnIndex: number) {
+  if (value === "clear") {
+    applyColumnSort(column, columnIndex, null, sortMode.value);
+    return;
+  }
+  const [mode, direction] = value.split("-") as [DataGridSortMode, DataGridSortDirection];
+  applyColumnSort(column, columnIndex, direction, mode);
+}
+
+function applyContextSort(direction: "asc" | "desc" | null, mode: DataGridSortMode = "database") {
+  if (!contextColumn.value || !contextCell.value) return;
+  applyColumnSort(contextColumn.value, contextCell.value.col, direction, mode);
+}
+
+async function contextFilterCondition(mode: FilterMode): Promise<string | null> {
+  if (!contextColumn.value) return null;
+  return (
+    (await buildDataGridContextFilterCondition({
+      databaseType: resolvedDatabaseType.value,
+      columnName: contextColumn.value,
+      columnInfo: props.tableMeta?.columns.find((column) => column.name === contextColumn.value),
+      mode,
+      value: contextCellValue.value,
+    })) ?? null
+  );
+}
+
+async function applyContextFilter(mode: FilterMode) {
+  if (!canUseWhereSearch.value) return;
+  const condition = await contextFilterCondition(mode);
+  if (!condition) return;
+  const existing = whereFilterInput.value.trim();
+  whereFilterInput.value = existing ? `(${existing}) AND (${condition})` : condition;
+  await applyWhereFilter();
+}
+
+async function clearContextFilter() {
+  await clearAllFilters();
+}
+
+function waitForTableMeta(timeoutMs = 2500): Promise<DataGridTableMeta | null> {
+  if (props.tableMeta) return Promise.resolve(props.tableMeta);
+  return new Promise((resolve) => {
+    let stop: (() => void) | undefined;
+    const timer = window.setTimeout(() => {
+      stop?.();
+      resolve(null);
+    }, timeoutMs);
+    stop = watch(
+      () => props.tableMeta,
+      (tableMeta) => {
+        if (!tableMeta) return;
+        window.clearTimeout(timer);
+        stop?.();
+        resolve(tableMeta);
+      },
+      { flush: "sync" },
+    );
+  });
+}
+
+async function applyOrderBySearch() {
+  if (!props.onExecuteSql) return;
+  const orderByClause = orderByInput.value.trim() || undefined;
+  emit("update:orderByInput", orderByInput.value);
+  if (orderByClause) rememberDataGridConditionHistory("orderBy", conditionHistoryScope.value, orderByClause);
+  isApplyingWhere.value = true;
+  saveError.value = "";
+  currentPage.value = 1;
+  sortCol.value = null;
+  sortColIndex.value = null;
+  sortDir.value = "asc";
+  try {
+    const tableMeta = await waitForTableMeta();
+    if (!tableMeta) return;
+    const sql = await buildTableSelectSql({
+      databaseType: resolvedDatabaseType.value,
+      catalog: tableMeta.catalog,
+      schema: tableMeta.schema,
+      tableName: tableMeta.tableName,
+      tableType: tableMeta.tableType,
+      columns: tableMeta.columns.map((column) => column.name),
+      primaryKeys: tableMeta.primaryKeys,
+      orderBy: orderByClause,
+      limit: pageSize.value,
+      whereInput: currentWhereInput(),
+      includeRowId: usesSyntheticRowIdKey(resolvedDatabaseType.value, tableMeta.primaryKeys, tableMeta.tableType),
+    });
+    await props.onExecuteSql(sql);
+  } catch (e: any) {
+    saveError.value = String(e?.message || e);
+  } finally {
+    isApplyingWhere.value = false;
+  }
+}
+
+async function applyWhereFilter() {
+  if (!props.onExecuteSql) return;
+  const whereInput = currentWhereInput();
+  if (whereInput) rememberDataGridConditionHistory("where", conditionHistoryScope.value, whereInput);
+  isApplyingWhere.value = true;
+  saveError.value = "";
+  currentPage.value = 1;
+  emit("update:whereInput", whereInput ?? "");
+  try {
+    const tableMeta = await waitForTableMeta();
+    if (!tableMeta) return;
+    const sql = await buildTableSelectSql({
+      databaseType: resolvedDatabaseType.value,
+      catalog: tableMeta.catalog,
+      schema: tableMeta.schema,
+      tableName: tableMeta.tableName,
+      tableType: tableMeta.tableType,
+      columns: tableMeta.columns.map((column) => column.name),
+      primaryKeys: tableMeta.primaryKeys,
+      orderBy: orderByInput.value.trim() || (sortCol.value ? `${queryColumnRef(sortCol.value)} ${sortDir.value.toUpperCase()}` : undefined),
+      limit: pageSize.value,
+      whereInput,
+      includeRowId: usesSyntheticRowIdKey(resolvedDatabaseType.value, tableMeta.primaryKeys, tableMeta.tableType),
+    });
+    await props.onExecuteSql(sql);
+  } catch (e: any) {
+    saveError.value = String(e?.message || e);
+  } finally {
+    isApplyingWhere.value = false;
+  }
+}
+
+const CELL_DISPLAY_MAX_LENGTH = 256;
+const CELL_FORMAT_CACHE_LIMIT = 20_000;
+const CELL_FORMAT_CACHE_PRUNE_COUNT = 5_000;
+
+const resolvedColumnFormatters = computed(() => props.result.columns.map((_, columnIndex) => columnFormatter(columnIndex)));
+const columnFormatterSignatures = computed(() => resolvedColumnFormatters.value.map(formatterSignature));
+const primitiveCellFormatCache = new Map<string, string>();
+let objectCellFormatCache = new WeakMap<object, Map<number, string>>();
+
+function formatterSignature(formatter: ColumnFormatterConfig | undefined): string {
+  return formatter ? JSON.stringify(formatter) : "";
+}
+
+function clearCellFormatCache() {
+  primitiveCellFormatCache.clear();
+  objectCellFormatCache = new WeakMap<object, Map<number, string>>();
+}
+
+function rememberPrimitiveCellFormat(key: string, display: string): string {
+  primitiveCellFormatCache.set(key, display);
+  if (primitiveCellFormatCache.size > CELL_FORMAT_CACHE_LIMIT) {
+    let removed = 0;
+    for (const cacheKey of primitiveCellFormatCache.keys()) {
+      primitiveCellFormatCache.delete(cacheKey);
+      removed++;
+      if (removed >= CELL_FORMAT_CACHE_PRUNE_COUNT) break;
+    }
+  }
+  return display;
+}
+
+function primitiveCellFormatKey(value: CellValue, columnIndex?: number): string {
+  return `${columnIndex ?? -1}\u0000${typeof value}\u0000${String(value)}`;
+}
+
+function formatCell(value: CellValue, columnIndex?: number): string {
+  const formatter = columnIndex === undefined ? undefined : resolvedColumnFormatters.value[columnIndex];
+  const columnName = columnIndex === undefined ? undefined : props.result.columns[columnIndex];
+  const columnInfo = columnIndex === undefined ? undefined : tableColumnForGridColumn(columnIndex);
+  const displayColumnInfo = columnInfo ?? (columnIndex === undefined ? undefined : resultColumnInfoForGridColumn(columnIndex));
+  const arrayDisplay = formatter ? undefined : dataGridCellDisplayText({ value, databaseType: props.databaseType, columnInfo: displayColumnInfo });
+  if (arrayDisplay !== undefined) return arrayDisplay;
+  const binaryDisplay = formatter ? null : binaryCellDisplayText(value, columnInfo?.data_type ?? (columnName ? columnTypeMap.value.get(columnName) : undefined));
+  if (binaryDisplay) return binaryDisplay;
+  const s = applyColumnFormatter(value, formatter);
+  return s.length > CELL_DISPLAY_MAX_LENGTH ? s.slice(0, CELL_DISPLAY_MAX_LENGTH) : s;
+}
+
+function formatCellCached(value: CellValue, columnIndex?: number): string {
+  if (value !== null && typeof (value as unknown) === "object") {
+    const objectValue = value as unknown as object;
+    const cacheColumn = columnIndex ?? -1;
+    const columnCache = objectCellFormatCache.get(objectValue);
+    const cached = columnCache?.get(cacheColumn);
+    if (cached !== undefined) return cached;
+
+    const display = formatCell(value, columnIndex);
+    if (columnCache) {
+      columnCache.set(cacheColumn, display);
+    } else {
+      objectCellFormatCache.set(objectValue, new Map([[cacheColumn, display]]));
+    }
+    return display;
+  }
+
+  const key = primitiveCellFormatKey(value, columnIndex);
+  const cached = primitiveCellFormatCache.get(key);
+  if (cached !== undefined) return cached;
+  return rememberPrimitiveCellFormat(key, formatCell(value, columnIndex));
+}
+
+function rowNumberText(item: RowItem | undefined): string {
+  if (!item) return "";
+  if (item.isDraft) return "*";
+  return String(infiniteScrollEnabled.value ? item.displayIndex + 1 : item.displayIndex + 1 + (currentPage.value - 1) * pageSize.value);
+}
+
+function draftCellPlaceholder(item: RowItem | undefined, columnIndex: number): string | null {
+  return item?.isDraft && item.data[columnIndex] === null ? t("grid.quickEntryDraftPlaceholder") : null;
+}
+
+function columnTypeCacheSignature(): string {
+  const resultTypes = props.result.column_types?.join("\u0000") ?? "";
+  const tableTypes = props.tableMeta?.columns?.map((column) => `${column.name}:${column.data_type}`).join("\u0000") ?? "";
+  return `${resultTypes}\u0001${tableTypes}`;
+}
+
+watch(() => [props.result.columns.join("\u0000"), columnFormatterSignatures.value.join("\u0000"), columnTypeCacheSignature()], clearCellFormatCache);
+
+function quoteIdent(name: string): string {
+  return quoteTableIdentifier(props.databaseType, name);
+}
+
+function queryColumnRef(name: string): string {
+  const quoted = quoteIdent(name);
+  return props.databaseType === "neo4j" ? `n.${quoted}` : quoted;
+}
+
+function isNull(value: unknown): boolean {
+  return value === null;
+}
+
+function rowNumberStatusClass(item: RowItem): string {
+  if (item.status === "draft") {
+    return "border-muted-foreground/20 bg-muted/20 font-semibold text-muted-foreground";
+  }
+  if (item.status === "new") {
+    return "border-emerald-500/40 bg-emerald-500/15 font-semibold text-emerald-700 dark:text-emerald-300";
+  }
+  if (item.status === "edited") {
+    return "border-amber-500/40 bg-amber-500/15 font-semibold text-amber-700 dark:text-amber-300";
+  }
+  if (item.status === "deleted") {
+    return "border-destructive/40 bg-destructive/15 font-semibold text-destructive line-through";
+  }
+  return "text-muted-foreground";
+}
+
+function rowCellsUseSelectionVisual(rowId: number): boolean {
+  return hasRowSelection.value && isRowSelected(rowId) && !hasCellSelection.value;
+}
+
+function dataGridRowStyle(item: RowItem): CSSProperties {
+  const dark = isDark.value || (typeof document !== "undefined" && document.documentElement.classList.contains("dark"));
+  const rowBg = item.isDeleted
+    ? dark
+      ? "rgb(55, 31, 32)"
+      : "rgb(255, 244, 244)"
+    : item.isNew
+      ? dark
+        ? "rgb(51, 51, 55)"
+        : "rgb(243, 243, 243)"
+      : item.isDraft
+        ? dark
+          ? "rgb(51, 51, 55)"
+          : "rgb(243, 243, 243)"
+        : item.displayIndex % 2 === 1
+          ? dark
+            ? "rgb(32, 32, 34)"
+            : "rgb(248, 248, 248)"
+          : dark
+            ? "rgb(19, 20, 22)"
+            : "rgb(255, 255, 255)";
+  const rowNumberBg =
+    item.status === "new"
+      ? dark
+        ? "rgb(33, 45, 40)"
+        : "rgb(219, 244, 233)"
+      : item.status === "edited"
+        ? dark
+          ? "rgb(48, 41, 28)"
+          : "rgb(253, 241, 219)"
+        : item.status === "deleted"
+          ? dark
+            ? "rgb(55, 31, 32)"
+            : "rgb(255, 244, 244)"
+          : isRowActive(item.displayIndex) && !item.isDeleted
+            ? dark
+              ? "rgb(66, 67, 70)"
+              : "rgb(226, 226, 226)"
+            : dark
+              ? "rgb(35, 37, 42)"
+              : "rgb(255, 255, 255)";
+  return {
+    "--data-grid-cell-bg": rowBg,
+    "--data-grid-row-number-bg": rowNumberBg,
+    "--data-grid-cell-selected-bg": dark ? "rgb(66, 67, 70)" : "rgb(226, 226, 226)",
+    "--data-grid-cell-selected-dirty-bg": dark ? "rgb(94, 75, 26)" : "rgb(244, 229, 186)",
+    "--data-grid-cell-selected-border": dark ? "rgb(170, 170, 175)" : "rgb(90, 90, 90)",
+    "--data-grid-row-number-active-bg": dark ? "rgb(66, 67, 70)" : "rgb(232, 232, 232)",
+    "--data-grid-row-number-selected-bg": dark ? "rgb(66, 67, 70)" : "rgb(226, 226, 226)",
+  } as CSSProperties;
+}
+
+const canvasRef = ref<HTMLCanvasElement>();
+const canvasOverlayRef = ref<HTMLElement>();
+const canvasViewportWidth = ref(0);
+const canvasViewportHeight = ref(0);
+const canvasScrollTop = ref(0);
+const canvasHoverCell = ref<{ rowIndex: number; visibleColIdx: number } | null>(null);
+const canvasDevicePixelRatio = ref(typeof window === "undefined" ? 1 : window.devicePixelRatio || 1);
+const canvasBackingPixelRatio = computed(() => Math.min(4, Math.max(1, canvasDevicePixelRatio.value * settingsStore.editorSettings.uiScale)));
+const useCanvasGridRows = computed(() => dataGridRenderMode.value === "canvas");
+const canvasContentHeight = computed(() => Math.max(1, displayRowCount.value * CANVAS_DATA_GRID_ROW_HEIGHT));
+// Clamp the sticky canvas/overlay to the content width. A viewport-wide sticky surface inflates the
+// scroller's scrollWidth up to clientWidth, so with few columns it sits right on the overflow threshold
+// and the custom horizontal scrollbar flickers while the pane shrinks (canvas width lags clientWidth).
+const canvasSurfaceWidth = computed(() => {
+  const total = totalWidth.value;
+  const vw = canvasViewportWidth.value;
+  if (total <= 0) return Math.max(0, vw);
+  if (vw <= 0) return total;
+  return Math.min(vw, total);
+});
+const canvasRenderStyleKey = computed(() => `${settingsStore.editorSettings.theme}:${settingsStore.editorSettings.uiScale}:${canvasBackingPixelRatio.value}:${isDark.value}:${themePalette.value}:${settingsStore.editorSettings.fontFamily}:${tableFontSize.value}`);
+const CANVAS_MOUSE_WHEEL_SCROLL_MULTIPLIER = 1.5;
+const CANVAS_TRACKPAD_DELTA_THRESHOLD = 40;
+let canvasResizeObserver: ResizeObserver | null = null;
+let canvasPixelRatioMediaQuery: MediaQueryList | null = null;
+let canvasPixelRatioMediaQueryCleanup: (() => void) | null = null;
+let canvasPixelRatioFrame = 0;
+let canvasDrawFrame = 0;
+let dataGridIsActive = true;
+
+watch(
+  () => [totalWidth.value, displayRowCount.value, useCanvasGridRows.value, props.result.columns.join("\u0000")],
+  () => {
+    nextTick(() => {
+      refreshGridScrollerMetrics();
+      observeGridHorizontalScrollbarScroller();
+    });
+  },
+  { flush: "post" },
+);
+
+function canvasScrollerElement(): HTMLElement | null {
+  const scroller = scrollerRef.value;
+  if (!scroller) return null;
+  if (scroller instanceof HTMLElement) return scroller;
+  if (scroller.$el instanceof HTMLElement) return scroller.$el;
+  if (scroller.el instanceof HTMLElement) return scroller.el;
+  if (scroller.el?.value instanceof HTMLElement) return scroller.el.value;
+  return null;
+}
+
+function dataGridSelectionScroller(): HTMLElement | null {
+  if (showTranspose.value) return null;
+  return canvasScrollerElement();
+}
+
+function dataGridCellFromClientPoint(clientX: number, clientY: number): { rowIndex: number; colIndex: number } | null {
+  const scroller = dataGridSelectionScroller();
+  if (!scroller) return null;
+  const rect = scroller.getBoundingClientRect();
+  const clampedX = Math.min(rect.right - 1, Math.max(rect.left + DATA_GRID_ROW_NUM_WIDTH + 1, clientX));
+  const clampedY = Math.min(rect.bottom - 1, Math.max(rect.top + 1, clientY));
+
+  if (useCanvasGridRows.value) {
+    const rowIndex = Math.floor((scroller.scrollTop + clampedY - rect.top) / CANVAS_DATA_GRID_ROW_HEIGHT);
+    const visibleColIdx = canvasColumnAt(scroller.scrollLeft + clampedX - rect.left - DATA_GRID_ROW_NUM_WIDTH);
+    if (rowIndex < 0 || rowIndex >= displayRowCount.value || visibleColIdx < 0) return null;
+    const item = displayItemAt(rowIndex);
+    return item ? { rowIndex: item.displayIndex, colIndex: visibleColIdx } : null;
+  }
+
+  const target = document.elementFromPoint(clampedX, clampedY);
+  const cell = target instanceof Element ? target.closest<HTMLElement>("[data-row-index] [data-visible-col-index]") : null;
+  const row = cell?.closest<HTMLElement>("[data-row-index]");
+  const rowIndex = Number(row?.dataset.rowIndex);
+  const colIndex = Number(cell?.dataset.visibleColIndex);
+  if (!Number.isInteger(rowIndex) || !Number.isInteger(colIndex)) return null;
+  return { rowIndex, colIndex };
+}
+
+function syncCanvasViewport() {
+  if (!dataGridIsActive) return;
+  const scroller = canvasScrollerElement();
+  if (!scroller) return;
+  canvasViewportWidth.value = scroller.clientWidth;
+  canvasViewportHeight.value = scroller.clientHeight;
+  canvasScrollTop.value = scroller.scrollTop;
+  updateGridScrollbarGutter(scroller);
+  updateGridHorizontalViewport(scroller);
+  drawCanvasGridNow();
+}
+
+function currentCanvasDevicePixelRatio(): number {
+  return typeof window === "undefined" ? 1 : Math.max(1, window.devicePixelRatio || 1);
+}
+
+function scheduleCanvasPixelRatioRefresh() {
+  if (!dataGridIsActive || canvasPixelRatioFrame) return;
+  canvasPixelRatioFrame = requestAnimationFrame(() => {
+    canvasPixelRatioFrame = 0;
+    const next = currentCanvasDevicePixelRatio();
+    if (Math.abs(next - canvasDevicePixelRatio.value) > 0.001) {
+      canvasDevicePixelRatio.value = next;
+      attachCanvasPixelRatioWatcher();
+    }
+    syncCanvasViewport();
+  });
+}
+
+function attachCanvasPixelRatioWatcher() {
+  canvasPixelRatioMediaQueryCleanup?.();
+  canvasPixelRatioMediaQueryCleanup = null;
+  canvasPixelRatioMediaQuery = null;
+  if (!dataGridIsActive || !useCanvasGridRows.value || typeof window === "undefined" || !window.matchMedia) return;
+
+  const ratio = currentCanvasDevicePixelRatio();
+  canvasDevicePixelRatio.value = ratio;
+  canvasPixelRatioMediaQuery = window.matchMedia(`(resolution: ${ratio}dppx)`);
+  const onChange = () => scheduleCanvasPixelRatioRefresh();
+  canvasPixelRatioMediaQuery.addEventListener("change", onChange);
+  canvasPixelRatioMediaQueryCleanup = () => {
+    canvasPixelRatioMediaQuery?.removeEventListener("change", onChange);
+  };
+}
+
+function attachCanvasResizeObserver() {
+  canvasResizeObserver?.disconnect();
+  canvasResizeObserver = null;
+  if (!dataGridIsActive) return;
+  if (!useCanvasGridRows.value) return;
+  const scroller = canvasScrollerElement();
+  if (!scroller) return;
+  attachCanvasPixelRatioWatcher();
+  syncCanvasViewport();
+  if (typeof ResizeObserver === "undefined") return;
+  canvasResizeObserver = new ResizeObserver(syncCanvasViewport);
+  canvasResizeObserver.observe(scroller);
+}
+
+function scheduleCanvasDraw() {
+  if (!dataGridIsActive) return;
+  if (!useCanvasGridRows.value || canvasDrawFrame) return;
+  canvasDrawFrame = requestAnimationFrame(() => {
+    canvasDrawFrame = 0;
+    drawCanvasGrid();
+  });
+}
+
+function drawCanvasGridNow() {
+  if (!useCanvasGridRows.value) return;
+  if (canvasDrawFrame) {
+    cancelAnimationFrame(canvasDrawFrame);
+    canvasDrawFrame = 0;
+  }
+  drawCanvasGrid();
+}
+
+function canvasColumnAt(contentX: number): number {
+  const offsets = renderedColumnOffsets.value;
+  const totalColumns = renderedColumnWidths.value.length;
+  if (contentX < 0 || totalColumns === 0 || contentX >= (offsets[totalColumns] ?? 0)) return -1;
+  let low = 0;
+  let high = totalColumns - 1;
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if ((offsets[mid + 1] ?? 0) <= contentX) low = mid + 1;
+    else high = mid;
+  }
+  return low;
+}
+
+function canvasHitTest(event: MouseEvent): { rowIndex: number; visibleColIdx: number; rowNumber: boolean } | null {
+  const canvas = canvasRef.value;
+  const scroller = canvasScrollerElement();
+  if (!canvas || !scroller) return null;
+  const rect = canvas.getBoundingClientRect();
+  const x = event.clientX - rect.left;
+  const y = event.clientY - rect.top;
+  const rowIndex = Math.floor((scroller.scrollTop + y) / CANVAS_DATA_GRID_ROW_HEIGHT);
+  if (rowIndex < 0 || rowIndex >= displayRowCount.value) return null;
+  if (x < DATA_GRID_ROW_NUM_WIDTH) return { rowIndex, visibleColIdx: -1, rowNumber: true };
+  const visibleColIdx = canvasColumnAt(scroller.scrollLeft + x - DATA_GRID_ROW_NUM_WIDTH);
+  if (visibleColIdx < 0) return null;
+  return { rowIndex, visibleColIdx, rowNumber: false };
+}
+
+function onCanvasScroll(event: Event) {
+  const target = event.target;
+  const scroller = target instanceof HTMLElement ? target : canvasScrollerElement();
+  if (!scroller) return;
+
+  const scrollTop = scroller.scrollTop;
+  const scrollLeft = scroller.scrollLeft;
+  const viewportWidth = scroller.clientWidth;
+  const viewportHeight = scroller.clientHeight;
+  const scrollTopChanged = canvasScrollTop.value !== scrollTop;
+  const viewportHeightChanged = canvasViewportHeight.value !== viewportHeight;
+  const scrollLeftChanged = gridHorizontalScrollLeft.value !== scrollLeft;
+  const viewportWidthChanged = gridViewportWidth.value !== viewportWidth || canvasViewportWidth.value !== viewportWidth;
+
+  if (canvasScrollTop.value !== scrollTop) canvasScrollTop.value = scrollTop;
+  if (canvasViewportWidth.value !== viewportWidth) canvasViewportWidth.value = viewportWidth;
+  if (canvasViewportHeight.value !== viewportHeight) canvasViewportHeight.value = viewportHeight;
+  if (scrollLeftChanged || viewportWidthChanged) {
+    gridHorizontalScrollLeft.value = scrollLeft;
+    gridViewportWidth.value = viewportWidth;
+    updateGridHorizontalScrollbar(scroller);
+  }
+  if (scrollTopChanged || viewportHeightChanged) {
+    updateGridVerticalScrollbar(scroller);
+    maybeCheckInfiniteScroll(scroller);
+  }
+  if (viewportWidthChanged || viewportHeightChanged) {
+    const gutter = scrollbarGutterWidth(scroller);
+    if (gridScrollbarGutter.value !== gutter) gridScrollbarGutter.value = gutter;
+  }
+  if (headerRef.value && headerRef.value.scrollLeft !== scrollLeft) headerRef.value.scrollLeft = scrollLeft;
+  recordScrollPosition({ top: scrollTop, left: scrollLeft });
+  markGridScrolling();
+  scheduleCanvasDraw();
+}
+
+function canvasWheelDeltaToPixels(delta: number, deltaMode: number, pageSize: number): number {
+  if (deltaMode === WheelEvent.DOM_DELTA_LINE) return delta * CANVAS_DATA_GRID_ROW_HEIGHT;
+  if (deltaMode === WheelEvent.DOM_DELTA_PAGE) return delta * pageSize;
+  return delta;
+}
+
+function shouldAccelerateCanvasWheel(event: WheelEvent): boolean {
+  if (event.ctrlKey || event.metaKey) return false;
+  if (event.deltaMode !== WheelEvent.DOM_DELTA_PIXEL) return true;
+  return event.shiftKey && Math.abs(event.deltaY) > Math.abs(event.deltaX) && Math.abs(event.deltaY) >= CANVAS_TRACKPAD_DELTA_THRESHOLD;
+}
+
+function onCanvasWheel(event: WheelEvent) {
+  if (!shouldAccelerateCanvasWheel(event)) return;
+  const scroller = canvasScrollerElement();
+  if (!scroller) return;
+
+  const verticalDelta = canvasWheelDeltaToPixels(event.deltaY, event.deltaMode, scroller.clientHeight);
+  const horizontalDelta = canvasWheelDeltaToPixels(event.deltaX, event.deltaMode, scroller.clientWidth);
+  const shiftedHorizontalDelta = event.shiftKey && Math.abs(verticalDelta) > Math.abs(horizontalDelta) ? verticalDelta : 0;
+  const nextTop = shiftedHorizontalDelta === 0 ? Math.max(0, Math.min(scroller.scrollHeight - scroller.clientHeight, scroller.scrollTop + verticalDelta * CANVAS_MOUSE_WHEEL_SCROLL_MULTIPLIER)) : scroller.scrollTop;
+  const nextLeft = Math.max(0, Math.min(scroller.scrollWidth - scroller.clientWidth, scroller.scrollLeft + (horizontalDelta + shiftedHorizontalDelta) * CANVAS_MOUSE_WHEEL_SCROLL_MULTIPLIER));
+
+  if (nextTop === scroller.scrollTop && nextLeft === scroller.scrollLeft) return;
+  event.preventDefault();
+  scroller.scrollTop = nextTop;
+  scroller.scrollLeft = nextLeft;
+  onCanvasScroll({ target: scroller } as unknown as Event);
+}
+
+function onDomGridWheel(event: WheelEvent) {
+  if (event.ctrlKey || event.metaKey) return;
+  const scroller = event.currentTarget instanceof HTMLElement ? event.currentTarget : gridScrollerElement();
+  if (!scroller) return;
+
+  const verticalDelta = canvasWheelDeltaToPixels(event.deltaY, event.deltaMode, scroller.clientHeight);
+  const horizontalDelta = canvasWheelDeltaToPixels(event.deltaX, event.deltaMode, scroller.clientWidth);
+  const shiftedHorizontalDelta = event.shiftKey && Math.abs(verticalDelta) > Math.abs(horizontalDelta) ? verticalDelta : 0;
+  const effectiveVerticalDelta = shiftedHorizontalDelta === 0 ? verticalDelta : 0;
+  const effectiveHorizontalDelta = horizontalDelta + shiftedHorizontalDelta;
+  if (effectiveVerticalDelta === 0 && effectiveHorizontalDelta === 0) return;
+
+  const maxTop = Math.max(0, scroller.scrollHeight - scroller.clientHeight);
+  const maxLeft = Math.max(0, scroller.scrollWidth - scroller.clientWidth);
+  const nextTop = Math.max(0, Math.min(maxTop, scroller.scrollTop + effectiveVerticalDelta));
+  const nextLeft = Math.max(0, Math.min(maxLeft, scroller.scrollLeft + effectiveHorizontalDelta));
+  // Let an outer scroll container handle wheel input once the grid reaches its boundary.
+  if (nextTop === scroller.scrollTop && nextLeft === scroller.scrollLeft) return;
+  event.preventDefault();
+  event.stopPropagation();
+
+  scroller.scrollTop = nextTop;
+  scroller.scrollLeft = nextLeft;
+  onScrollerScroll({ target: scroller } as unknown as Event);
+}
+
+function onCanvasMouseMove(event: MouseEvent) {
+  if (columnHeaderPointerInteractionActive()) {
+    if (canvasRef.value) canvasRef.value.style.cursor = "default";
+    onCanvasMouseLeave();
+    return;
+  }
+  const hit = canvasHitTest(event);
+  const hitItem = hit ? displayItemAt(hit.rowIndex) : undefined;
+  const next = hit && hitItem ? { rowIndex: hitItem.displayIndex, visibleColIdx: hit.rowNumber ? -1 : hit.visibleColIdx } : null;
+  const actualColIdx = next ? visibleColumnIndexes.value[next.visibleColIdx] : undefined;
+  if (canvasRef.value) {
+    canvasRef.value.style.cursor = hit?.rowNumber ? "default" : hitItem && actualColIdx !== undefined && canEditCellItem(hitItem, actualColIdx) ? "text" : "cell";
+  }
+  if (next?.rowIndex === canvasHoverCell.value?.rowIndex && next?.visibleColIdx === canvasHoverCell.value?.visibleColIdx) {
+    return;
+  }
+  const previous = canvasHoverCell.value;
+  if (previous) {
+    const previousActualColIdx = visibleColumnIndexes.value[previous.visibleColIdx];
+    if (previousActualColIdx !== undefined) onCellMouseleave(previous.rowIndex, previousActualColIdx);
+  }
+  canvasHoverCell.value = next;
+  if (next && actualColIdx !== undefined) onCellMouseenter(next.rowIndex, next.visibleColIdx, actualColIdx);
+  scheduleCanvasDraw();
+}
+
+function onCanvasMouseLeave(event?: MouseEvent) {
+  const relatedTarget = event?.relatedTarget;
+  if (relatedTarget instanceof Node && canvasOverlayRef.value?.contains(relatedTarget)) return;
+  const previous = canvasHoverCell.value;
+  if (previous) {
+    const previousActualColIdx = visibleColumnIndexes.value[previous.visibleColIdx];
+    if (previousActualColIdx !== undefined) onCellMouseleave(previous.rowIndex, previousActualColIdx);
+  }
+  canvasHoverCell.value = null;
+  scheduleCanvasDraw();
+}
+
+function keepCanvasDetailHover() {
+  const cell = canvasDetailButtonCell.value;
+  if (!cell) return;
+  canvasHoverCell.value = { rowIndex: cell.rowIndex, visibleColIdx: cell.visibleColIdx };
+  hoveredDetailCell.value = { rowIndex: cell.rowIndex, col: cell.actualColIdx };
+  scheduleCanvasDraw();
+}
+
+function clearCanvasDetailHover(event?: MouseEvent) {
+  const relatedTarget = event?.relatedTarget;
+  if (relatedTarget instanceof Node && (canvasOverlayRef.value?.contains(relatedTarget) || canvasRef.value?.contains(relatedTarget))) {
+    return;
+  }
+  onCanvasMouseLeave();
+}
+
+function onCanvasMouseDown(event: MouseEvent) {
+  if (event.button !== 0) return;
+  const hit = canvasHitTest(event);
+  if (!hit) {
+    commitHiddenCanvasEditBeforeCellInteraction();
+    return;
+  }
+  const item = displayItemAt(hit.rowIndex);
+  const actualColIdx = hit.rowNumber ? undefined : visibleColumnIndexes.value[hit.visibleColIdx];
+  if (item && actualColIdx !== undefined) prepareDataCellMouseDown(item, actualColIdx);
+  commitHiddenCanvasEditBeforeCellInteraction();
+  if (!item) return;
+  if (hit.rowNumber) {
+    handleRowClick(item.displayIndex, item.id, event);
+  } else {
+    handleDataCellMousedown(item.displayIndex, hit.visibleColIdx, item.id, event);
+  }
+  gridRef.value?.focus({ preventScroll: true });
+  scheduleCanvasDraw();
+}
+
+function onCanvasContext(event: MouseEvent) {
+  commitHiddenCanvasEditBeforeCellInteraction();
+  const hit = canvasHitTest(event);
+  if (!hit) return;
+  const item = displayItemAt(hit.rowIndex);
+  if (!item) return;
+  if (hit.rowNumber) {
+    onRowContext(item.id, item.displayIndex);
+    return;
+  }
+  const actualColIdx = visibleColumnIndexes.value[hit.visibleColIdx];
+  if (actualColIdx === undefined) return;
+  onCellContext(item.id, item.displayIndex, actualColIdx, hit.visibleColIdx, event);
+}
+
+function onCanvasDblClick(event: MouseEvent) {
+  const hit = canvasHitTest(event);
+  if (!hit) return;
+  if (hit.rowNumber) {
+    const item = displayItemAt(hit.rowIndex);
+    if (item) toggleTranspose(item.displayIndex);
+    return;
+  }
+  const item = displayItemAt(hit.rowIndex);
+  const actualColIdx = visibleColumnIndexes.value[hit.visibleColIdx];
+  if (!item || actualColIdx === undefined || !canEditCellItem(item, actualColIdx)) return;
+  startCellEdit(item.id, actualColIdx, canvasCellContentOverflows(item, actualColIdx, hit.visibleColIdx));
+}
+
+function canvasCellContentOverflows(item: RowItem, actualColIdx: number, visibleColIdx: number): boolean {
+  const cellWidth = renderedColumnWidths.value[visibleColIdx] ?? 0;
+  if (cellWidth <= 0) return false;
+  const displayText = formatCellCached(item.data[actualColIdx], actualColIdx);
+  const editText = cellEditorTextForValue(item.data[actualColIdx], actualColIdx);
+  if (editText.includes("\n") || editText.includes("\r") || editText.length > displayText.length) return true;
+  const textWidth = measureCellTextWidth(displayText, `400 13px ${settingsStore.editorSettings.fontFamily}`);
+  return textWidth > Math.max(0, cellWidth - 24);
+}
+
+function canvasCellViewportRect(rowIndex: number, visibleColIdx: number) {
+  const widths = renderedColumnWidths.value;
+  const colWidth = widths[visibleColIdx];
+  if (colWidth === undefined) return null;
+  const left = DATA_GRID_ROW_NUM_WIDTH + (renderedColumnOffsets.value[visibleColIdx] ?? 0) - gridHorizontalScrollLeft.value;
+  return {
+    left,
+    top: rowIndex * CANVAS_DATA_GRID_ROW_HEIGHT - canvasScrollTop.value,
+    width: colWidth,
+    height: CANVAS_DATA_GRID_ROW_HEIGHT,
+  };
+}
+
+function canvasEditingCellViewportRect() {
+  const editing = editingCell.value;
+  if (!editing || !useCanvasGridRows.value) return null;
+  const rowIndex = displayRowIndexById(editing.rowId);
+  const visibleColIdx = visibleColumnIndexes.value.indexOf(editing.col);
+  if (rowIndex < 0 || visibleColIdx < 0) return null;
+  return canvasCellViewportRect(rowIndex, visibleColIdx);
+}
+
+function canvasEditingCellIsVisible() {
+  const rect = canvasEditingCellViewportRect();
+  if (!rect) return false;
+  const viewportWidth = canvasEffectiveViewportWidth();
+  const viewportHeight = canvasEffectiveViewportHeight();
+  const clippedLeft = Math.max(DATA_GRID_ROW_NUM_WIDTH, rect.left);
+  const clippedRight = viewportWidth > 0 ? Math.min(viewportWidth, rect.left + rect.width) : rect.left + rect.width;
+  return rect.top + rect.height > 0 && rect.top < viewportHeight && clippedRight - clippedLeft > 0;
+}
+
+function commitHiddenCanvasEditBeforeCellInteraction() {
+  if (!editingCell.value || !useCanvasGridRows.value) return;
+  if (canvasEditingCellIsVisible()) return;
+  void commitEditFromCellBlur();
+}
+
+const canvasEditingCell = computed(() => {
+  const editing = editingCell.value;
+  if (!editing || !useCanvasGridRows.value) return null;
+  const rowIndex = displayRowIndexById(editing.rowId);
+  const visibleColIdx = visibleColumnIndexes.value.indexOf(editing.col);
+  if (rowIndex < 0 || visibleColIdx < 0) return null;
+  const rect = canvasCellViewportRect(rowIndex, visibleColIdx);
+  if (!rect) return null;
+  return { rowId: editing.rowId, rowIndex, visibleColIdx, actualColIdx: editing.col, rect };
+});
+
+function canvasEffectiveViewportWidth(): number {
+  return canvasViewportWidth.value || canvasScrollerElement()?.clientWidth || 0;
+}
+
+function canvasEffectiveViewportHeight(): number {
+  return canvasViewportHeight.value || canvasScrollerElement()?.clientHeight || 0;
+}
+
+const canvasOverlayStyle = computed(() => {
+  const vh = canvasEffectiveViewportHeight();
+  return {
+    width: `${canvasSurfaceWidth.value}px`,
+    height: `${vh}px`,
+    marginTop: `-${vh}px`,
+  };
+});
+
+const canvasEditingCellStyle = computed(() => {
+  const cell = canvasEditingCell.value;
+  if (!cell) return {};
+  const viewportWidth = canvasEffectiveViewportWidth();
+  const clippedLeft = Math.max(DATA_GRID_ROW_NUM_WIDTH, cell.rect.left);
+  const clippedRight = viewportWidth > 0 ? Math.min(viewportWidth, cell.rect.left + cell.rect.width) : cell.rect.left + cell.rect.width;
+  return {
+    left: `${clippedLeft}px`,
+    top: `${cell.rect.top}px`,
+    width: `${Math.max(0, clippedRight - clippedLeft)}px`,
+    height: `${cell.rect.height}px`,
+  };
+});
+
+const canvasDetailButtonCell = computed(() => {
+  if (!useCanvasGridRows.value || isScrolling.value) return null;
+  const target = hoveredDetailCell.value ?? quickDownloadMenuCell.value ?? (showCellDetail.value ? detailCell.value : null);
+  if (!target || !cellDetailButtonVisible(target.rowIndex, target.col)) return null;
+  const editing = editingCell.value;
+  if (editing && editing.rowId === displayItems.value[target.rowIndex]?.id && editing.col === target.col) return null;
+  const visibleColIdx = visibleColumnIndexes.value.indexOf(target.col);
+  if (visibleColIdx < 0) return null;
+  const rect = canvasCellViewportRect(target.rowIndex, visibleColIdx);
+  if (!rect) return null;
+  const viewportWidth = canvasEffectiveViewportWidth();
+  const viewportHeight = canvasEffectiveViewportHeight();
+  const visibleLeft = Math.max(DATA_GRID_ROW_NUM_WIDTH, rect.left);
+  const visibleRight = viewportWidth > 0 ? Math.min(viewportWidth, rect.left + rect.width) : rect.left + rect.width;
+  const canQuickDownload = canQuickDownloadCellValue(target.rowIndex, target.col);
+  const minWidth = canQuickDownload ? 46 : 24;
+  if (rect.top < 0 || rect.top > viewportHeight - 1 || visibleRight - visibleLeft < minWidth) return null;
+  return { rowIndex: target.rowIndex, visibleColIdx, actualColIdx: target.col, rect, canQuickDownload };
+});
+
+const canvasDetailButtonStyle = computed(() => {
+  const cell = canvasDetailButtonCell.value;
+  if (!cell) return {};
+  const actionWidth = cell.canQuickDownload ? 44 : 22;
+  const edgeGap = 6;
+  return {
+    left: `${Math.max(DATA_GRID_ROW_NUM_WIDTH, cell.rect.left + cell.rect.width - actionWidth - edgeGap)}px`,
+    top: `${cell.rect.top + 2}px`,
+  };
+});
+
+function drawCanvasGrid() {
+  const canvas = canvasRef.value;
+  const scroller = canvasScrollerElement();
+  if (!canvas || !scroller || !useCanvasGridRows.value) return;
+
+  drawCanvasDataGrid({
+    canvas,
+    scroller,
+    width: Math.max(1, canvasSurfaceWidth.value || scroller.clientWidth),
+    height: Math.max(1, canvasViewportHeight.value || scroller.clientHeight),
+    pixelRatio: canvasBackingPixelRatio.value,
+    isDark: isDark.value,
+    styleKey: canvasRenderStyleKey.value,
+    rowCount: displayRowCount.value,
+    rowAt: displayItemAt,
+    renderedColumnWidths: renderedColumnWidths.value,
+    renderedColumnOffsets: renderedColumnOffsets.value,
+    columnPreviewOffsets: columnHeaderPreviewOffsets.value,
+    columnPreviewSourceVisibleIndex: columnHeaderPreviewSourceVisibleIndex.value,
+    visibleColumnIndexes: visibleColumnIndexes.value,
+    rowNumberWidth: DATA_GRID_ROW_NUM_WIDTH,
+    hoverCell: canvasHoverCell.value,
+    isScrolling: isScrolling.value,
+    editingCell: editingCell.value,
+    searchMatchKeys: searchMatchSet.value,
+    currentSearchMatch: currentSearchMatch.value,
+    formatCell: formatCellCached,
+    draftCellPlaceholder: t("grid.quickEntryDraftPlaceholder"),
+    isRowActive,
+    rowCellsUseSelectionVisual,
+    cellIsSelected,
+    cellCanHover: canEditCellItem,
+    infiniteScrollEnabled: infiniteScrollEnabled.value,
+    pageSize: pageSize.value,
+    currentPage: currentPage.value,
+  });
+}
+
+watch(
+  [useCanvasGridRows, hasVisibleRows],
+  () => {
+    // When an empty table gets its first pending row, the canvas scroller is created by
+    // the v-if branch after the original mount-time observer attempt has already no-op'd.
+    // Reattach after that branch mounts so the canvas/overlay get real viewport dimensions.
+    nextTick(attachCanvasResizeObserver);
+  },
+  { immediate: true },
+);
+watch(showDataGridTopbar, () => nextTick(observeDataGridTopbarWidth), { immediate: true });
+watch(
+  [
+    displayRowRefs,
+    renderedColumnWidths,
+    visibleColumnIndexes,
+    selectedRange,
+    selectedRowIds,
+    hasCellSelection,
+    hasRowSelection,
+    isSelectingAll,
+    searchMatchSet,
+    currentSearchMatch,
+    isDark,
+    canvasRenderStyleKey,
+    canvasDevicePixelRatio,
+    canvasBackingPixelRatio,
+    isScrolling,
+    hoveredDetailCell,
+    detailCell,
+    showCellDetail,
+    editingCell,
+    // Pending edit structures can contain large nested cell maps; the editor
+    // version ref gives the canvas a cheap invalidation signal without a deep watch.
+    pendingChangesVersion,
+  ],
+  scheduleCanvasDraw,
+);
+
+function pauseCanvasGridWork() {
+  dataGridIsActive = false;
+  canvasResizeObserver?.disconnect();
+  canvasResizeObserver = null;
+  disconnectCellEditResizeObserver();
+  dataGridTopbarResizeObserver?.disconnect();
+  dataGridTopbarResizeObserver = null;
+  canvasPixelRatioMediaQueryCleanup?.();
+  canvasPixelRatioMediaQueryCleanup = null;
+  canvasPixelRatioMediaQuery = null;
+  if (canvasPixelRatioFrame) {
+    cancelAnimationFrame(canvasPixelRatioFrame);
+    canvasPixelRatioFrame = 0;
+  }
+  if (canvasDrawFrame) {
+    cancelAnimationFrame(canvasDrawFrame);
+    canvasDrawFrame = 0;
+  }
+}
+
+function resumeCanvasGridWork() {
+  dataGridIsActive = true;
+  nextTick(() => {
+    attachCanvasResizeObserver();
+    observeDataGridTopbarWidth();
+    refreshGridScrollerMetrics();
+    observeGridHorizontalScrollbarScroller();
+  });
+}
+
+onMounted(resumeCanvasGridWork);
+onActivated(resumeCanvasGridWork);
+onMounted(() => {
+  if (typeof window === "undefined") return;
+  window.addEventListener("resize", scheduleCanvasPixelRatioRefresh);
+  window.addEventListener("resize", resizeFocusedConditionInputs);
+  window.visualViewport?.addEventListener("resize", scheduleCanvasPixelRatioRefresh);
+  window.visualViewport?.addEventListener("resize", resizeFocusedConditionInputs);
+  window.addEventListener("dbx:ui-scale-applied", scheduleCanvasPixelRatioRefresh);
+  window.addEventListener("dbx:ui-scale-applied", resizeFocusedConditionInputs);
+  window.addEventListener(TABLE_DATA_GRID_COLUMN_ORDER_CHANGED_EVENT, onTableDataGridColumnOrderChanged);
+  document.addEventListener("pointerdown", onConditionSuggestionDocumentPointerDown, true);
+});
+onDeactivated(pauseCanvasGridWork);
+onUnmounted(() => {
+  pauseCanvasGridWork();
+  clearConditionCollapseTimer("where");
+  clearConditionCollapseTimer("orderBy");
+  gridHorizontalScrollbarResizeObserver?.disconnect();
+  dataGridTopbarResizeObserver?.disconnect();
+  disconnectCellEditResizeObserver();
+  stopColumnHeaderDrag(false);
+  stopGridHorizontalScrollbarDrag();
+  stopGridVerticalScrollbarDrag();
+  if (gridHorizontalScrollbarFrame && typeof cancelAnimationFrame === "function") {
+    cancelAnimationFrame(gridHorizontalScrollbarFrame);
+  }
+  if (gridVerticalScrollbarDragFrame && typeof cancelAnimationFrame === "function") {
+    cancelAnimationFrame(gridVerticalScrollbarDragFrame);
+  }
+  if (typeof window === "undefined") return;
+  window.removeEventListener("resize", scheduleCanvasPixelRatioRefresh);
+  window.removeEventListener("resize", resizeFocusedConditionInputs);
+  window.visualViewport?.removeEventListener("resize", scheduleCanvasPixelRatioRefresh);
+  window.visualViewport?.removeEventListener("resize", resizeFocusedConditionInputs);
+  window.removeEventListener("dbx:ui-scale-applied", scheduleCanvasPixelRatioRefresh);
+  window.removeEventListener("dbx:ui-scale-applied", resizeFocusedConditionInputs);
+  window.removeEventListener(TABLE_DATA_GRID_COLUMN_ORDER_CHANGED_EVENT, onTableDataGridColumnOrderChanged);
+  document.removeEventListener("pointerdown", onConditionSuggestionDocumentPointerDown, true);
+});
+
+function setRowStatusFilter(value: string) {
+  rowStatusFilter.value = value as RowStatusFilter;
+}
+
+// --- Export progress dialog state ---
+const exportProgressDialog = ref(false);
+const exportProgressState = ref({
+  title: "",
+  tableName: "",
+  format: "csv" as string,
+  rowsExported: 0,
+  totalRows: null as number | null,
+  status: "",
+  errorMessage: null as string | null,
+});
+const exportCancelHandler = ref<(() => Promise<void>) | null>(null);
+
+async function cancelActiveExport() {
+  await exportCancelHandler.value?.();
+}
+
+// --- Export composable ---
+const {
+  copyText,
+  copyCell,
+  copyRow,
+  copyRowAsInsert,
+  copyRowAsInsertWithoutPrimaryKeys,
+  prefetchRowAsInsertStatement,
+  canCopyRowAsInsert,
+  prefetchRowAsUpdateStatement,
+  copyRowAsUpdate,
+  canCopyRowAsInsertWithoutPrimaryKeys,
+  canCopyRowAsUpdate,
+  copyAll,
+  copySelectionTsv,
+  copySelectionTsvWithHeaders,
+  copySelectionCsv,
+  copySelectionJson,
+  copySelectionSqlInList,
+  copySelectedRowsTsv,
+  copySelectedRowsTsvWithHeaders,
+  copyColumnNames,
+  exportCsv,
+  exportCurrentPageCsv,
+  exportJson,
+  exportCurrentPageJson,
+  exportMarkdown,
+  exportCurrentPageMarkdown,
+  exportXlsx,
+  exportCurrentPageXlsx,
+  exportAllResultsXlsx,
+  exportSql,
+  exportCurrentPageSql,
+  copySql,
+} = useDataGridExport({
+  columns: visibleColumns,
+  displayItems: visibleDisplayItems,
+  sql: computed(() => props.sql),
+  tableMeta: computed(() => (props.tableMeta ? { ...props.tableMeta } : undefined)),
+  copyInsertTargetLabel: computed(() => props.tableMeta?.tableName ?? props.customSaveHandler?.targetLabel),
+  databaseType: computed(() => props.databaseType),
+  connectionId: computed(() => props.connectionId),
+  database: computed(() => props.executionDatabase ?? props.database),
+  context: computed(() => props.context),
+  sourceColumns: visibleSourceColumns,
+  columnTypes: visibleColumnTypes,
+  whereInput: computed(() => currentWhereInput()),
+  orderBy: computed(() => currentOrderBy()),
+  exportBatchSize: computed(() => settingsStore.editorSettings.exportBatchSize),
+  hasCellSelection,
+  selectedCells,
+  selectedRange,
+  contextCell: exportContextCell,
+  getRowItem: (rowId: number) => visibleDisplayItems.value.find((item) => item.id === rowId),
+  selectedRowIds,
+  hasRowSelection,
+  fullExportResult: props.fullExportResult,
+  queryResultExportRequest: props.queryResultExportRequest,
+  hasCompleteLocalResult,
+  completeLocalResult: computed(() => (hasCompleteLocalResult.value ? props.result : undefined)),
+  allExportResults: computed(() => props.allExportResults),
+  currentResultLabel: computed(() => props.result.sourceLabel),
+  exportFileBaseName: computed(() => props.exportFileBaseName),
+  exportProgressDialog,
+  exportProgressState,
+  exportCancelHandler,
+});
+
+const canAutoRefresh = computed(() => !isSaving.value && !props.loading);
+
+const pageSizeMenuItems = computed(() =>
+  pageSizeOptions.value.map((size) => ({
+    value: String(size),
+    label: `${size} ${t("grid.rowsPerPageShort")}`,
+  })),
+);
+
+const exportMenuItems = computed(() => {
+  const hasFullResultExport = !!props.fullExportResult;
+  const allResultItems = (props.allExportResults?.length ?? 0) > 1 ? [{ value: "all-results-xlsx", label: t("grid.exportAllResultsXlsx"), separatorBefore: true }] : [];
+  const selectedItems = isMultiRow.value
+    ? [
+        { value: "selected-csv", label: t("grid.exportSelectedRowsCsv"), separatorBefore: true },
+        { value: "selected-xlsx", label: t("grid.exportSelectedRowsXlsx") },
+        { value: "selected-json", label: t("grid.exportSelectedRowsJson") },
+        { value: "selected-markdown", label: t("grid.exportSelectedRowsMarkdown") },
+        { value: "selected-sql", label: t("grid.exportSelectedRowsSql") },
+      ]
+    : [];
+
+  if (!hasFullResultExport) {
+    return [{ value: "csv", label: t("grid.exportCsv") }, { value: "xlsx", label: t("grid.exportXlsx") }, { value: "json", label: t("grid.exportJson") }, { value: "markdown", label: t("grid.exportMarkdown") }, { value: "sql", label: t("grid.exportSql") }, ...allResultItems, ...selectedItems];
+  }
+
+  return [
+    { value: "page-csv", label: t("grid.exportCurrentPageCsv") },
+    { value: "page-xlsx", label: t("grid.exportCurrentPageXlsx") },
+    { value: "page-json", label: t("grid.exportCurrentPageJson") },
+    { value: "page-markdown", label: t("grid.exportCurrentPageMarkdown") },
+    { value: "page-sql", label: t("grid.exportCurrentPageSql") },
+    { value: "csv", label: t("grid.exportCurrentResultCsv"), separatorBefore: true },
+    { value: "xlsx", label: t("grid.exportCurrentResultXlsx") },
+    { value: "json", label: t("grid.exportCurrentResultJson") },
+    { value: "markdown", label: t("grid.exportCurrentResultMarkdown") },
+    { value: "sql", label: t("grid.exportCurrentResultSql") },
+    ...allResultItems,
+    ...selectedItems,
+  ];
+});
+
+function selectPageSizeMenuItem(value: string) {
+  changePageSize(Number(value));
+}
+
+function selectExportMenuItem(value: string) {
+  const actions: Record<string, () => void> = {
+    "page-csv": exportCurrentPageCsv,
+    "page-xlsx": exportCurrentPageXlsx,
+    "page-json": exportCurrentPageJson,
+    "page-markdown": exportCurrentPageMarkdown,
+    "page-sql": exportCurrentPageSql,
+    csv: exportCsv,
+    xlsx: exportXlsx,
+    "all-results-xlsx": exportAllResultsXlsx,
+    json: exportJson,
+    markdown: exportMarkdown,
+    sql: exportSql,
+    "selected-csv": exportSelectedRowsCsv,
+    "selected-xlsx": exportSelectedRowsXlsx,
+    "selected-json": exportSelectedRowsJson,
+    "selected-markdown": exportSelectedRowsMarkdown,
+    "selected-sql": exportSelectedRowsSql,
+  };
+  actions[value]?.();
+}
+
+// --- Cell selection and detail ---
+function showCellDetails(rowIndex: number, colIndex: number) {
+  closeMongoJsonPreview();
+  resetDetailEdit();
+  detailCell.value = { rowIndex, col: colIndex };
+  activeCellDetailTab.value = defaultCellDetailTab();
+  showCellDetail.value = true;
+}
+
+function showCellDetailsForVisibleCell(rowIndex: number, visibleColIdx: number, actualColIdx: number) {
+  clearRowSelection();
+  selectSingleCell(rowIndex, visibleColIdx);
+  showCellDetails(rowIndex, actualColIdx);
+}
+
+function openCellDetailDialog(rowIndex: number, columnIndex: number) {
+  cellDetailDialogTarget.value = { rowIndex, col: columnIndex };
+  cellDetailDialogOpen.value = true;
+}
+
+function openColumnDetailDialog(columnIndex: number) {
+  if (!props.result.columns[columnIndex]) return;
+  columnDetailDialogColumnIndex.value = columnIndex;
+  columnDetailDialogOpen.value = true;
+}
+
+function openContextCellDetailDialog() {
+  const cell = contextCell.value;
+  if (!cell || cell.col < 0) return;
+  openCellDetailDialog(cell.rowIndex, cell.col);
+}
+
+function openContextColumnDetailDialog() {
+  const cell = contextCell.value;
+  if (cell && cell.col >= 0) {
+    openColumnDetailDialog(cell.col);
+    return;
+  }
+  if (contextHeaderColumnIndex.value === null) return;
+  openColumnDetailDialog(contextHeaderColumnIndex.value);
+}
+
+function openActiveCellDetailDialog() {
+  const detail = activeCellDetail.value;
+  if (!detail) return;
+  openCellDetailDialog(detail.rowNumber - 1, detail.colIndex);
+}
+
+function openActiveColumnDetailDialog() {
+  const detail = activeCellDetail.value;
+  if (!detail) return;
+  openColumnDetailDialog(detail.colIndex);
+}
+
+function openRowDetailDialog(rowId: number) {
+  rowDetailDialogRowId.value = rowId;
+  rowDetailDialogOpen.value = true;
+}
+
+function openContextRowDetailDialog() {
+  const cell = contextCell.value;
+  if (!cell) return;
+  openRowDetailDialog(cell.rowId);
+}
+
+function openActiveRowDetailDialog() {
+  const detail = activeCellDetail.value;
+  if (!detail) return;
+  openRowDetailDialog(detail.rowId);
+}
+
+function closeDetailDialogs() {
+  cellDetailDialogOpen.value = false;
+  cellDetailDialogTarget.value = null;
+  rowDetailDialogOpen.value = false;
+  rowDetailDialogRowId.value = null;
+  columnDetailDialogOpen.value = false;
+  columnDetailDialogColumnIndex.value = null;
+}
+
+function transposeCellIsSelected(rowIndex: number, actualColIdx: number) {
+  const visibleColIdx = visibleColumnIndexes.value.indexOf(actualColIdx);
+  return visibleColIdx >= 0 && cellIsSelected(rowIndex, visibleColIdx);
+}
+
+function onTransposeCellMouseenter(rowIndex: number, actualColIdx: number) {
+  if (isScrolling.value) return;
+  hoveredDetailCell.value = { rowIndex, col: actualColIdx };
+}
+
+function selectTransposeCell(rowIndex: number, actualColIdx: number, event: MouseEvent) {
+  const visibleColIdx = visibleColumnIndexes.value.indexOf(actualColIdx);
+  if (visibleColIdx < 0) return;
+  contextHeaderColumn.value = null;
+  contextHeaderColumnIndex.value = null;
+  clearRowSelection();
+  if (event.shiftKey || event.metaKey || event.ctrlKey) {
+    extendCellSelectionTo(rowIndex, visibleColIdx);
+  } else {
+    selectSingleCell(rowIndex, visibleColIdx);
+  }
+  transposeRowIndex.value = rowIndex;
+  gridRef.value?.focus({ preventScroll: true });
+}
+
+function showTransposeCellDetails(rowIndex: number, actualColIdx: number) {
+  const visibleColIdx = visibleColumnIndexes.value.indexOf(actualColIdx);
+  if (visibleColIdx < 0) return;
+  contextHeaderColumn.value = null;
+  contextHeaderColumnIndex.value = null;
+  clearRowSelection();
+  selectSingleCell(rowIndex, visibleColIdx);
+  transposeRowIndex.value = rowIndex;
+  showCellDetails(rowIndex, actualColIdx);
+  gridRef.value?.focus({ preventScroll: true });
+}
+
+function onTransposeCellContext(rowIndex: number, actualColIdx: number, event: MouseEvent) {
+  selectTransposeCell(rowIndex, actualColIdx, event);
+  const item = displayItemAt(rowIndex);
+  contextCell.value = item ? { rowId: item.id, rowIndex, col: actualColIdx } : null;
+  void prefetchCopyStatements();
+}
+
+watch([selectedRange, showCellDetail, isEditingDetail], () => {
+  const selectedCell = currentSelectedCellPosition();
+  const target = linkedCellDetailTarget({
+    isOpen: showCellDetail.value,
+    isEditing: isEditingDetail.value && activeCellDetailTab.value !== "valueEditor",
+    selectedCell: selectedCell ? { rowIndex: selectedCell.rowIndex, visibleColIndex: selectedCell.colIndex } : null,
+    actualColumnIndex,
+  });
+  if (!target) return;
+  detailCell.value = target;
+});
+
+function openImagePreview(src: string, title: string) {
+  imagePreviewSrc.value = src;
+  imagePreviewTitle.value = title;
+  imagePreviewOpen.value = true;
+}
+
+function onDrawerContextMenu(event: MouseEvent) {
+  event.stopPropagation();
+  const target = event.target as HTMLElement | null;
+  if (target?.closest("input, textarea, [contenteditable='true'], [role='textbox']")) return;
+  event.preventDefault();
+}
+
+function clipboardShortcut(event: KeyboardEvent, key: string): boolean {
+  return isPlainClipboardShortcut(event, key);
+}
+
+let lastPasteEventAt = 0;
+
+async function pasteClipboardIntoSelection() {
+  if (!props.editable) return;
+  const text = await readTextFromClipboard();
+  pasteTextIntoSelection(text);
+}
+
+function pasteTextIntoSelection(text: string): boolean {
+  const rows = parseClipboardTable(text);
+  const allowDraftSelectionValue = selectedRangeTargetsOnlyDraftRow();
+
+  if (rows.length === 1 && rows[0]?.length === 1 && fillSelectionWithValue(rows[0][0])) {
+    toast(t("grid.pasted"));
+    return true;
+  }
+
+  const start = pasteStartCell();
+  if (!start) return false;
+  let applied = false;
+  rows.forEach((row, rowOffset) => {
+    const item = displayItemAt(start.rowIndex + rowOffset);
+    if (!item) return;
+    row.forEach((value, colOffset) => {
+      const visibleCol = start.colIndex + colOffset;
+      if (visibleCol >= visibleColumns.value.length) return;
+      applied = applyVisibleSelectedCellValue(item, visibleCol, value, allowDraftSelectionValue) || applied;
+    });
+  });
+  if (applied) toast(t("grid.pasted"));
+  return applied;
+}
+
+function onGridPaste(event: ClipboardEvent) {
+  if (!props.editable || (!selectedRange.value && !hasColumnSelection.value)) return;
+  const target = event.target as HTMLElement | null;
+  if (target?.closest("input, textarea, [contenteditable='true'], [role='textbox']")) return;
+  const text = event.clipboardData?.getData("text/plain");
+  if (text === undefined) return;
+  event.preventDefault();
+  lastPasteEventAt = Date.now();
+  pasteTextIntoSelection(text);
+}
+
+function pasteStartCell() {
+  const start = selectedRangeStart();
+  if (start) return start;
+  if (!hasColumnSelection.value) return null;
+  const firstCol = selectedVisibleColumnIndexes()[0];
+  return firstCol === undefined ? null : { rowIndex: 0, colIndex: firstCol };
+}
+
+function selectedVisibleColumnIndexes(): number[] {
+  return [...selectedColumnIndexes.value].filter((index) => index >= 0 && index < visibleColumns.value.length).sort((a, b) => a - b);
+}
+
+function applyVisibleCellValue(item: RowItem, visibleCol: number, value: string | null): boolean {
+  const actualCol = actualColumnIndex(visibleCol);
+  if (!canEditCellItem(item, actualCol)) return false;
+  applyCellValue(item.id, actualCol, value);
+  return true;
+}
+
+function applyVisibleSelectedCellValue(item: RowItem, visibleCol: number, value: string | null, allowDraft = selectedRangeTargetsOnlyDraftRow()): boolean {
+  if (!canApplyGridSelectionValue({ isDraft: !!item.isDraft, allowDraft })) return false;
+  return applyVisibleCellValue(item, visibleCol, value);
+}
+
+function selectedRangeTargetsOnlyDraftRow(): boolean {
+  const range = selectedRange.value;
+  if (!range) return false;
+  if (range.startRow !== range.endRow) return false;
+  return displayItemAt(range.startRow)?.isDraft === true;
+}
+
+function fillSelectionWithValue(value: string | null): boolean {
+  const range = selectedRange.value;
+  let applied = false;
+  const allowDraftSelectionValue = selectedRangeTargetsOnlyDraftRow();
+  if (range) {
+    for (let rowIndex = range.startRow; rowIndex <= range.endRow; rowIndex++) {
+      const item = displayItemAt(rowIndex);
+      if (!item) continue;
+      for (let visibleCol = range.startCol; visibleCol <= range.endCol; visibleCol++) {
+        applied = applyVisibleSelectedCellValue(item, visibleCol, value, allowDraftSelectionValue) || applied;
+      }
+    }
+    return applied;
+  }
+
+  if (!hasColumnSelection.value) return false;
+  const visibleColumnIndexes = selectedVisibleColumnIndexes();
+  if (!visibleColumnIndexes.length) return false;
+  for (let rowIndex = 0; rowIndex < displayRowCount.value; rowIndex++) {
+    const item = displayItemAt(rowIndex);
+    if (!item) continue;
+    for (const visibleCol of visibleColumnIndexes) {
+      applied = applyVisibleSelectedCellValue(item, visibleCol, value) || applied;
+    }
+  }
+  return applied;
+}
+
+function selectionHasEditableCells(): boolean {
+  const range = selectedRange.value;
+  if (range) {
+    for (let rowIndex = range.startRow; rowIndex <= range.endRow; rowIndex++) {
+      const item = displayItemAt(rowIndex);
+      if (!item) continue;
+      for (let visibleCol = range.startCol; visibleCol <= range.endCol; visibleCol++) {
+        if (canEditCellItem(item, actualColumnIndex(visibleCol))) return true;
+      }
+    }
+    return false;
+  }
+
+  if (!hasColumnSelection.value) return false;
+  const visibleColumnIndexes = selectedVisibleColumnIndexes();
+  for (let rowIndex = 0; rowIndex < displayRowCount.value; rowIndex++) {
+    const item = displayItemAt(rowIndex);
+    if (!item) continue;
+    for (const visibleCol of visibleColumnIndexes) {
+      if (canEditCellItem(item, actualColumnIndex(visibleCol))) return true;
+    }
+  }
+  return false;
+}
+
+function openBulkEditDialog() {
+  if (!props.editable || !selectionHasEditableCells()) return;
+  bulkEditValue.value = "";
+  bulkEditDialogOpen.value = true;
+}
+
+function applyBulkEditValue() {
+  // Empty input sets the selected cells to SQL NULL (the placeholder hints "Value, or NULL").
+  const value = bulkEditValue.value === "" ? null : bulkEditValue.value;
+  if (!fillSelectionWithValue(value)) return;
+  bulkEditDialogOpen.value = false;
+}
+
+function cutSelection() {
+  if (!props.editable || !selectedRange.value) return;
+  copySelectionTsv();
+  const range = selectedRange.value;
+  const allowDraftSelectionValue = selectedRangeTargetsOnlyDraftRow();
+  for (let rowIndex = range.startRow; rowIndex <= range.endRow; rowIndex++) {
+    const item = displayItemAt(rowIndex);
+    if (!item) continue;
+    for (let visibleCol = range.startCol; visibleCol <= range.endCol; visibleCol++) {
+      applyVisibleSelectedCellValue(item, visibleCol, null, allowDraftSelectionValue);
+    }
+  }
+}
+
+function currentSelectedCellPosition() {
+  const range = selectedRange.value;
+  if (!range) return null;
+  return { rowIndex: range.startRow, colIndex: range.startCol };
+}
+
+function scrollCellIntoView(rowIndex: number, colIndex: number) {
+  nextTick(() => {
+    scrollGridColumnIntoView(colIndex);
+    if (useCanvasGridRows.value) {
+      scrollCanvasRowIntoView(rowIndex, "nearest");
+      return;
+    }
+    nextTick(() => {
+      const rowEl = gridRef.value?.querySelector<HTMLElement>(`[data-row-index="${rowIndex}"]`);
+      const cellEl = rowEl?.querySelector<HTMLElement>(`[data-visible-col-index="${colIndex}"]`);
+      (cellEl ?? rowEl)?.scrollIntoView({ block: "nearest", inline: "nearest" });
+    });
+  });
+}
+
+function scrollGridColumnIntoView(visibleColIdx: number) {
+  const scroller = gridRef.value?.querySelector<HTMLElement>(".data-grid-scroller");
+  if (!scroller) return;
+  const colLeft = columnContentOffsetLeft(visibleColIdx);
+  const colRight = colLeft + (renderedColumnWidths.value[visibleColIdx] ?? 0);
+  const viewportLeft = scroller.scrollLeft + DATA_GRID_ROW_NUM_WIDTH;
+  const viewportRight = scroller.scrollLeft + scroller.clientWidth;
+
+  if (colLeft < viewportLeft) {
+    scroller.scrollLeft = Math.max(0, colLeft - DATA_GRID_ROW_NUM_WIDTH);
+  } else if (colRight > viewportRight) {
+    scroller.scrollLeft = Math.max(0, colRight - scroller.clientWidth);
+  }
+
+  updateGridHorizontalViewport(scroller);
+  if (headerRef.value) headerRef.value.scrollLeft = scroller.scrollLeft;
+  if (useCanvasGridRows.value) syncCanvasViewport();
+}
+
+function scrollCanvasRowIntoView(rowIndex: number, block: "nearest" | "start") {
+  const target = Math.max(0, Math.min(displayRowCount.value - 1, rowIndex));
+  const scroller = canvasScrollerElement();
+  if (!scroller) return;
+  const rowTop = target * CANVAS_DATA_GRID_ROW_HEIGHT;
+  const rowBottom = rowTop + CANVAS_DATA_GRID_ROW_HEIGHT;
+  if (block === "start" || rowTop < scroller.scrollTop) {
+    scroller.scrollTop = rowTop;
+  } else if (rowBottom > scroller.scrollTop + scroller.clientHeight) {
+    scroller.scrollTop = Math.max(0, rowBottom - scroller.clientHeight);
+  }
+  syncCanvasViewport();
+}
+
+function scrollGridRowIntoView(rowIndex: number) {
+  const target = Math.max(0, Math.min(displayRowCount.value - 1, rowIndex));
+  nextTick(() => {
+    if (useCanvasGridRows.value) {
+      scrollCanvasRowIntoView(target, "start");
+      return;
+    }
+    const scroller = scrollerRef.value;
+    if (scroller && !(scroller instanceof HTMLElement)) {
+      scroller.scrollToItem?.(target);
+      scroller.scrollToPosition?.(target * 26);
+    } else if (scroller instanceof HTMLElement) {
+      scroller.scrollTop = target * 26;
+    }
+    requestAnimationFrame(() => {
+      const rowEl = gridRef.value?.querySelector<HTMLElement>(`[data-row-index="${target}"]`);
+      rowEl?.scrollIntoView({ block: "nearest", inline: "nearest" });
+    });
+  });
+}
+
+function currentTransposeRequestedRowIndex(): number {
+  const position = currentSelectedCellPosition();
+  if (position) return position.rowIndex;
+  if (transposeRowIndex.value !== null) return transposeRowIndex.value;
+  return 0;
+}
+
+function toggleKeyboardTranspose(): boolean {
+  if (displayRowCount.value === 0) return false;
+  const requestedRowIndex = currentTransposeRequestedRowIndex();
+  const next = nextKeyboardTransposeState({
+    showTranspose: showTranspose.value,
+    transposeRowIndex: transposeRowIndex.value,
+    requestedRowIndex,
+    rowIds: displayRowRefs.value.map((ref) => ref.id),
+    selectedRowIds: selectedRowIds.value,
+    selectedRange: selectedRange.value,
+  });
+  showTranspose.value = next.showTranspose;
+  transposeRowIndex.value = next.transposeRowIndex;
+  if (next.showTranspose) {
+    closeCellDetails();
+    nextTick(updateTransposeViewport);
+    if (next.transposeRowIndex !== null) scrollTransposeRecordIntoView(next.transposeRowIndex);
+  } else {
+    scrollGridRowIntoView(requestedRowIndex);
+  }
+  return true;
+}
+
+function moveSelectedCell(rowDelta: number, colDelta: number): boolean {
+  const position = currentSelectedCellPosition();
+  if (!position || editingCell.value || displayRowCount.value === 0 || visibleColumnIndexes.value.length === 0) return false;
+  const rowIndex = Math.max(0, Math.min(displayRowCount.value - 1, position.rowIndex + rowDelta));
+  const colIndex = Math.max(0, Math.min(visibleColumnIndexes.value.length - 1, position.colIndex + colDelta));
+  selectSingleCell(rowIndex, colIndex);
+  clearRowSelection();
+  if (showTranspose.value) transposeRowIndex.value = rowIndex;
+  scrollCellIntoView(rowIndex, colIndex);
+  return true;
+}
+
+function editSelectedCell(): boolean {
+  const position = currentSelectedCellPosition();
+  if (!position || editingCell.value) return false;
+  const item = displayItemAt(position.rowIndex);
+  const actualColIndex = actualColumnIndex(position.colIndex);
+  if (!item || !canEditCellItem(item, actualColIndex)) return false;
+  startEdit(item.id, actualColIndex);
+  return true;
+}
+
+function selectedOrCurrentRowIds(): number[] {
+  const affected = affectedRowIds();
+  if (affected.length > 0) return affected;
+  const position = currentSelectedCellPosition();
+  if (!position) return [];
+  const item = displayItemAt(position.rowIndex);
+  return item ? [item.id] : [];
+}
+
+function copyCurrentRow(): boolean {
+  if (!canInsertRows.value) return false;
+  const rowIds = selectedOrCurrentRowIds().filter((rowId) => !getRowItem(rowId)?.isDraft);
+  if (rowIds.length === 0) return false;
+  if (rowIds.length === 1) {
+    cloneRow(rowIds[0]);
+    return true;
+  }
+  cloneRows(rowIds);
+  return true;
+}
+
+function deleteCurrentRow(): boolean {
+  const rowIds = selectedOrCurrentRowIds();
+  if (rowIds.length === 0) return false;
+
+  const targetRowIds = deletableRowIds(rowIds);
+  if (targetRowIds.length === 0) return false;
+  if (targetRowIds.length === 1) {
+    requestDeleteRow(targetRowIds[0]);
+    return true;
+  }
+  requestDeleteRows(targetRowIds);
+  return true;
+}
+
+function commitGridEdit(value?: string | null) {
+  void commitEditAndMaybeAutoSave(value === undefined ? undefined : { explicitValue: value }).finally(() => nextTick(() => gridRef.value?.focus({ preventScroll: true })));
+}
+
+async function commitEditFromCellBlur() {
+  const target = pendingQuickEntryDraftCellFocus.value;
+  pendingQuickEntryDraftCellFocus.value = null;
+  if (target && editingCell.value?.rowId === quickEntryDraftRowId && target.rowId === quickEntryDraftRowId) {
+    await commitEditFromBlur({ promoteDraft: false });
+    nextTick(() => {
+      const item = getRowItem(target.rowId);
+      if (item && canEditCellItem(item, target.col)) startEdit(target.rowId, target.col);
+    });
+    return;
+  }
+  await commitEditFromBlur();
+}
+
+function prepareDataCellMouseDown(item: RowItem, actualColIdx: number) {
+  const editing = editingCell.value;
+  if (editing?.rowId === quickEntryDraftRowId && item.isDraft && item.id === quickEntryDraftRowId && editing.col !== actualColIdx) {
+    pendingQuickEntryDraftCellFocus.value = { rowId: item.id, col: actualColIdx };
+  } else {
+    pendingQuickEntryDraftCellFocus.value = null;
+  }
+}
+
+function prepareTransposeCellMouseDown(rowIndex: number, actualColIdx: number) {
+  const item = displayItemAt(rowIndex);
+  if (item) prepareDataCellMouseDown(item, actualColIdx);
+}
+
+async function saveGridChangesFromShortcut() {
+  if (!saveToolbarState.value.showActions || saveToolbarState.value.actionsDisabled) return false;
+  await onToolbarCommit();
+  return true;
+}
+
+async function onCellEditKeydown(event: KeyboardEvent) {
+  if (isSaveShortcut(event, settingsStore.editorSettings.shortcuts)) {
+    event.preventDefault();
+    event.stopPropagation();
+    commitEdit();
+    await nextTick();
+    if (await saveGridChangesFromShortcut()) {
+      gridRef.value?.focus({ preventScroll: true });
+    }
+    return;
+  }
+  onEditKeydown(event);
+}
+
+function undoGridChange(): boolean {
+  if (editingCell.value || !canUndoPendingChange.value) return false;
+  undoPendingChange();
+  return true;
+}
+
+function redoGridChange(): boolean {
+  if (editingCell.value || !canRedoPendingChange.value) return false;
+  redoPendingChange();
+  return true;
+}
+
+function openCellDetailSearch(): boolean {
+  return getDetailEditor()?.openSearch() ?? false;
+}
+
+async function onGridKeydown(event: KeyboardEvent) {
+  if (event.defaultPrevented) return;
+
+  if (isFocusSearchShortcut(event)) {
+    event.preventDefault();
+    focusSearch();
+    return;
+  }
+  if (isModRShortcut(event)) {
+    event.preventDefault();
+    event.stopPropagation();
+    await onToolbarRefresh();
+    return;
+  }
+  if (eventTargetAllowsNativeClipboard(event)) return;
+  if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === "z") {
+    const handled = event.shiftKey ? redoGridChange() : undoGridChange();
+    if (handled) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+    return;
+  }
+  if (event.ctrlKey && !event.metaKey && event.key.toLowerCase() === "y") {
+    if (redoGridChange()) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+    return;
+  }
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && event.key.toLowerCase() === "n") {
+    if (props.editable && hasDataGridInsertTarget.value && canInsertRows.value) {
+      event.preventDefault();
+      event.stopPropagation();
+      addRow();
+    }
+    return;
+  }
+  if (isSaveShortcut(event, settingsStore.editorSettings.shortcuts)) {
+    if (await saveGridChangesFromShortcut()) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+    return;
+  }
+  if (isCopyCurrentRowShortcut(event, settingsStore.editorSettings.shortcuts) && copyCurrentRow()) {
+    event.preventDefault();
+    return;
+  }
+  if (isDeleteCurrentRowShortcut(event, settingsStore.editorSettings.shortcuts) && deleteCurrentRow()) {
+    event.preventDefault();
+    return;
+  }
+  if (isToggleTransposeShortcut(event, settingsStore.editorSettings.shortcuts) && toggleKeyboardTranspose()) {
+    event.preventDefault();
+    return;
+  }
+  if (event.key === "ArrowLeft" && moveTransposeRecordSelection(-1)) {
+    event.preventDefault();
+    return;
+  }
+  if (event.key === "ArrowRight" && moveTransposeRecordSelection(1)) {
+    event.preventDefault();
+    return;
+  }
+  if (event.key === "ArrowUp" && moveSelectedCell(-1, 0)) {
+    event.preventDefault();
+    return;
+  }
+  if (event.key === "ArrowDown" && moveSelectedCell(1, 0)) {
+    event.preventDefault();
+    return;
+  }
+  if (event.key === "ArrowLeft" && moveSelectedCell(0, -1)) {
+    event.preventDefault();
+    return;
+  }
+  if (event.key === "ArrowRight" && moveSelectedCell(0, 1)) {
+    event.preventDefault();
+    return;
+  }
+  if (event.key === "Enter" && editSelectedCell()) {
+    event.preventDefault();
+    return;
+  }
+  if (clipboardShortcut(event, "c")) {
+    if (!hasCellSelection.value && !hasRowSelection.value) return;
+    event.preventDefault();
+    if (isTransposeMode.value && hasRowSelection.value) {
+      copyRow();
+      return;
+    }
+    if (hasCellSelection.value) {
+      copySelectionTsv();
+    } else {
+      copySelectedRowsTsv();
+    }
+    return;
+  }
+  if (clipboardShortcut(event, "a")) {
+    if (!hasData.value) return;
+    event.preventDefault();
+    selectAllCells();
+    return;
+  }
+  if (clipboardShortcut(event, "x")) {
+    if (!props.editable || !selectedRange.value) return;
+    event.preventDefault();
+    cutSelection();
+    return;
+  }
+  if (clipboardShortcut(event, "v")) {
+    if (!props.editable || (!selectedRange.value && !hasColumnSelection.value)) return;
+    const keydownAt = Date.now();
+    window.setTimeout(() => {
+      if (lastPasteEventAt >= keydownAt) return;
+      pasteClipboardIntoSelection().catch((e) => toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000));
+    }, 50);
+    return;
+  }
+}
+
+function copyDetailValue() {
+  const detail = activeCellDetail.value;
+  if (!detail) return;
+  const text = detail.value === null ? "" : displayCellValue(detail.value);
+  copyText(text);
+}
+
+function copyDetailFormattedJson() {
+  const detail = activeCellDetail.value;
+  if (!detail?.formattedJson) return;
+  copyText(detail.formattedJson);
+}
+
+function copyDetailCurrentValue() {
+  if (sideDetailJsonView.value && activeCellDetail.value?.formattedJson) {
+    copyDetailFormattedJson();
+  } else {
+    copyDetailValue();
+  }
+}
+
+function copyDetailColumnName() {
+  if (!activeCellDetail.value) return;
+  copyText(activeCellDetail.value.column);
+}
+
+function canDownloadDetailBinaryValue(detail: DataGridCellDetail | null): boolean {
+  return !!detail && canDownloadBinaryCellValue(detail.value, detail.type);
+}
+
+function canQuickDownloadCellValue(rowIndex: number, columnIndex: number): boolean {
+  return canDownloadDetailBinaryValue(cellDetailFor(rowIndex, columnIndex));
+}
+
+function downloadCellBinaryValue(rowIndex: number, columnIndex: number, mode: BinaryCellDownloadMode) {
+  void downloadDetailBinaryValue(cellDetailFor(rowIndex, columnIndex), mode);
+}
+
+async function downloadDetailBinaryValue(detail: DataGridCellDetail | null, mode: BinaryCellDownloadMode) {
+  if (!detail || !canDownloadDetailBinaryValue(detail)) return;
+  try {
+    const payload = binaryCellDownloadPayload(detail.value, mode, detail.type);
+    const fileName = binaryCellDownloadFileName({
+      column: detail.column,
+      rowNumber: detail.rowNumber,
+      mode,
+      extension: payload.extension,
+    });
+    const result = await downloadBinaryCellPayload(payload, fileName);
+    if (result.kind === "saved" && result.path) {
+      toast(t("grid.downloadSaved", { path: result.path }));
+    } else if (result.kind === "browser-download") {
+      toast(t("grid.downloadStarted", { fileName: result.fileName ?? fileName }));
+    }
+  } catch (e: any) {
+    toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function binaryDownloadSubmenu(detail: DataGridCellDetail | null): ContextMenuItem | null {
+  if (!canDownloadDetailBinaryValue(detail)) return null;
+  return {
+    label: t("grid.downloadBinaryValue"),
+    icon: Upload,
+    children: BINARY_CELL_DOWNLOAD_MODES.map((mode) => ({
+      label: t(`grid.binaryDownload.${mode}`),
+      action: () => {
+        void downloadDetailBinaryValue(detail, mode);
+      },
+    })),
+  };
+}
+
+async function copyDetailSqlCondition() {
+  if (!canCopyPreparedDetailSqlCondition()) return;
+  copyText(detailSqlConditionCopy.value.text);
+}
+
+function copyDialogCellValue() {
+  const detail = dialogCellDetail.value;
+  if (!detail) return;
+  copyText(detail.value === null ? "" : displayCellValue(detail.value));
+}
+
+function copyDialogCellFormattedJson() {
+  const detail = dialogCellDetail.value;
+  if (!detail?.formattedJson) return;
+  copyText(detail.formattedJson);
+}
+
+function copyDialogCellCurrentValue() {
+  if (cellDetailJsonView.value && dialogCellDetail.value?.formattedJson) {
+    copyDialogCellFormattedJson();
+  } else {
+    copyDialogCellValue();
+  }
+}
+
+function copyDialogCellColumnName() {
+  const detail = dialogCellDetail.value;
+  if (!detail) return;
+  copyText(detail.column);
+}
+
+async function openDialogCellInSidePanel() {
+  const detail = dialogCellDetail.value;
+  if (!detail) return;
+  showCellDetails(detail.rowNumber - 1, detail.colIndex);
+  cellDetailDialogOpen.value = false;
+  await nextTick();
+  if (detail.isEditable) startDetailEdit();
+}
+
+function copyRowDetailJson() {
+  const detail = rowDetail.value;
+  if (!detail) return;
+  copyText(dataGridRowDetailJson(detail));
+}
+
+function copyRowDetailTsv() {
+  const detail = rowDetail.value;
+  if (!detail) return;
+  copyText(dataGridRowDetailTsv(detail));
+}
+
+function copyRowDetailFieldValue(field: DataGridCellDetail) {
+  copyText(field.value === null ? "" : displayCellValue(field.value));
+}
+
+function copyColumnDetailJson() {
+  const detail = columnDetail.value;
+  if (!detail) return;
+  copyText(dataGridColumnDetailJson(detail));
+}
+
+function copyColumnDetailTsv() {
+  const detail = columnDetail.value;
+  if (!detail) return;
+  copyText(dataGridColumnDetailTsv(detail));
+}
+
+function copyColumnDetailColumnName() {
+  const detail = columnDetail.value;
+  if (!detail) return;
+  copyText(detail.column);
+}
+
+function copyColumnDetailFieldValue(field: DataGridCellDetail) {
+  copyText(field.value === null ? "" : displayCellValue(field.value));
+}
+
+const transposeRecordWidths = ref<number[]>([]);
+const transposeManualRecordWidthIndexes = ref(new Set<number>());
+
+function calcTransposeRecordWidth(recordIndex: number): number {
+  const item = displayItemAt(recordIndex);
+  if (!item) return defaultTransposeRecordWidth(columnWidthDensity.value);
+  return calculateTransposeRecordWidth(item.data, columnWidthDensity.value);
+}
+
+function getTransposeRecordWidth(recordIndex: number): number {
+  return transposeRecordWidths.value[recordIndex] ?? defaultTransposeRecordWidth(columnWidthDensity.value);
+}
+
+function ensureTransposeRecordWidths(count: number) {
+  if (transposeRecordWidths.value.length === count) return;
+  transposeManualRecordWidthIndexes.value = new Set([...transposeManualRecordWidthIndexes.value].filter((index) => index < count));
+  transposeRecordWidths.value = transposeRecordWidthsForDensity({
+    records: Array.from({ length: count }, (_, index) => displayItemAt(index)?.data ?? []),
+    density: columnWidthDensity.value,
+    previousWidths: transposeRecordWidths.value,
+    manualWidthIndexes: transposeManualRecordWidthIndexes.value,
+  });
+}
+
+function estimatedTransposeRecordWidth(): number {
+  return averageTransposeRecordWidth(transposeRecordWidths.value, columnWidthDensity.value);
+}
+
+watch(
+  () => displayRowCount.value,
+  (count) => ensureTransposeRecordWidths(count),
+);
+watch(columnWidthDensity, () => {
+  // Explicit pixel widths are user overrides; only auto-sized columns follow density changes.
+  transposeRecordWidths.value = transposeRecordWidthsForDensity({
+    records: Array.from({ length: displayRowCount.value }, (_, index) => displayItemAt(index)?.data ?? []),
+    density: columnWidthDensity.value,
+    previousWidths: transposeRecordWidths.value,
+    manualWidthIndexes: transposeManualRecordWidthIndexes.value,
+  });
+  nextTick(updateTransposeViewport);
+});
+const transposePinnedWidthOverride = ref<number | null>(null);
+const transposePinnedWidth = computed(() => transposePinnedWidthOverride.value ?? transposeFieldWidth(visibleColumns.value, { density: columnWidthDensity.value }));
+
+const transposeRecordWindow = computed(() =>
+  visibleTransposeRecordWindow({
+    totalRecords: displayRowCount.value,
+    scrollLeft: transposeScrollLeft.value,
+    viewportWidth: transposeViewportWidth.value,
+    pinnedWidth: transposePinnedWidth.value,
+    recordWidth: estimatedTransposeRecordWidth(),
+    overscan: 2,
+  }),
+);
+const visibleTransposeRecordIndexes = computed(() => {
+  const window = transposeRecordWindow.value;
+  return Array.from({ length: window.end - window.start }, (_, offset) => window.start + offset);
+});
+const activeTransposeRecordIndexes = computed(() =>
+  transposeRecordIndexesForMode({
+    multiRow: multiRowTranspose.value,
+    activeRecordIndex: transposeRowIndex.value,
+    totalRecords: displayRowCount.value,
+    visibleRecordIndexes: visibleTransposeRecordIndexes.value,
+  }),
+);
+const transposeBeforeSpacerWidth = computed(() => (multiRowTranspose.value ? transposeRecordWindow.value.beforeWidth : 0));
+const transposeAfterSpacerWidth = computed(() => (multiRowTranspose.value ? transposeRecordWindow.value.afterWidth : 0));
+const transposeRows = computed(() => {
+  return buildVisibleTransposeRows({
+    columns: visibleColumns.value,
+    records: displayRowRefs.value.map((_, index) => displayItemAt(index)?.data ?? []),
+    recordIndexes: activeTransposeRecordIndexes.value,
+    valueIndexes: visibleColumnIndexes.value,
+    typeByColumn: columnTypeMap.value,
+    displayValue: (value, _column, index) => formatCellCached(value, visibleColumnIndexes.value[index]),
+  });
+});
+const isTransposeMode = computed(() => showTranspose.value && transposeRows.value.length > 0);
+const transposeTotalWidth = computed(() => {
+  const recordIndexes = multiRowTranspose.value ? Array.from({ length: displayRowCount.value }, (_, i) => i) : activeTransposeRecordIndexes.value;
+  return transposePinnedWidth.value + recordIndexes.reduce((sum, i) => sum + getTransposeRecordWidth(i), 0);
+});
+
+function transposeScrollElement(): HTMLElement | undefined {
+  const raw = transposeScrollRef.value;
+  if (!raw) return undefined;
+  return raw instanceof HTMLElement ? raw : raw.$el;
+}
+
+function updateTransposeViewport() {
+  const el = transposeScrollElement();
+  if (!el) return;
+  transposeScrollLeft.value = el.scrollLeft;
+  transposeViewportWidth.value = el.clientWidth;
+}
+
+function onTransposeScroll() {
+  updateTransposeViewport();
+  const el = transposeScrollElement();
+  recordScrollPosition(el ? { top: el.scrollTop, left: el.scrollLeft } : undefined);
+  markGridScrolling();
+}
+
+function scrollTransposeRecordIntoView(rowIndex: number) {
+  nextTick(() => {
+    const el = transposeScrollElement();
+    if (!el) return;
+    el.scrollLeft = transposeScrollLeftForRecord({
+      recordIndex: rowIndex,
+      totalRecords: displayRowCount.value,
+      viewportWidth: el.clientWidth,
+      pinnedWidth: transposePinnedWidth.value,
+      recordWidth: estimatedTransposeRecordWidth(),
+    });
+    updateTransposeViewport();
+  });
+}
+
+function setMultiRowTranspose(value: boolean) {
+  multiRowTranspose.value = value;
+  if (!showTranspose.value) return;
+  nextTick(updateTransposeViewport);
+  if (value && transposeRowIndex.value !== null) {
+    scrollTransposeRecordIntoView(transposeRowIndex.value);
+  } else {
+    nextTick(() => {
+      const el = transposeScrollElement();
+      if (!el) return;
+      el.scrollLeft = 0;
+      updateTransposeViewport();
+    });
+  }
+}
+
+function toggleMultiRowTranspose() {
+  setMultiRowTranspose(!multiRowTranspose.value);
+}
+
+function applyTransposeState(next: { showTranspose: boolean; transposeRowIndex: number | null }) {
+  showTranspose.value = next.showTranspose;
+  transposeRowIndex.value = next.transposeRowIndex;
+  if (next.showTranspose) {
+    nextTick(updateTransposeViewport);
+    if (next.transposeRowIndex !== null) scrollTransposeRecordIntoView(next.transposeRowIndex);
+  }
+}
+
+function focusAppendedTransposeRecord() {
+  if (!showTranspose.value) return;
+  nextTick(() => {
+    applyTransposeState(nextAppendedTransposeState(true, displayRowCount.value));
+  });
+}
+
+function onTransposePinnedResizeStart(event: MouseEvent) {
+  event.preventDefault();
+  const startX = event.clientX;
+  const startWidth = transposePinnedWidth.value;
+  const onMove = (e: MouseEvent) => {
+    transposePinnedWidthOverride.value = Math.max(minTransposeFieldWidth(columnWidthDensity.value), startWidth + e.clientX - startX);
+    updateTransposeViewport();
+  };
+  const onUp = () => {
+    document.removeEventListener("mousemove", onMove);
+    document.removeEventListener("mouseup", onUp);
+  };
+  document.addEventListener("mousemove", onMove);
+  document.addEventListener("mouseup", onUp);
+}
+
+function onTransposeRecordResizeStart(recordIndex: number, event: MouseEvent) {
+  event.preventDefault();
+  ensureTransposeRecordWidths(displayRowCount.value);
+  const startX = event.clientX;
+  const startWidth = getTransposeRecordWidth(recordIndex);
+  const onMove = (e: MouseEvent) => {
+    const next = [...transposeRecordWidths.value];
+    next[recordIndex] = Math.max(minTransposeRecordWidth(columnWidthDensity.value), startWidth + e.clientX - startX);
+    transposeRecordWidths.value = next;
+    transposeManualRecordWidthIndexes.value = new Set(transposeManualRecordWidthIndexes.value).add(recordIndex);
+    updateTransposeViewport();
+  };
+  const onUp = () => {
+    document.removeEventListener("mousemove", onMove);
+    document.removeEventListener("mouseup", onUp);
+  };
+  document.addEventListener("mousemove", onMove);
+  document.addEventListener("mouseup", onUp);
+}
+
+function autoFitTransposeRecord(recordIndex: number) {
+  ensureTransposeRecordWidths(displayRowCount.value);
+  const manualIndexes = new Set(transposeManualRecordWidthIndexes.value);
+  manualIndexes.delete(recordIndex);
+  transposeManualRecordWidthIndexes.value = manualIndexes;
+  const next = [...transposeRecordWidths.value];
+  next[recordIndex] = calcTransposeRecordWidth(recordIndex);
+  transposeRecordWidths.value = next;
+}
+
+function currentTransposeViewportRowIndex(): number {
+  if (displayRowCount.value === 0) return 0;
+  const rowIndex = transposeRowIndex.value ?? transposeRecordWindow.value.start;
+  return Math.max(0, Math.min(displayRowCount.value - 1, rowIndex));
+}
+
+function closeTranspose(scrollToCurrentRecord = true) {
+  const rowIndex = currentTransposeViewportRowIndex();
+  showTranspose.value = false;
+  transposeRowIndex.value = null;
+  if (scrollToCurrentRecord) scrollGridRowIntoView(rowIndex);
+}
+
+function openContextTranspose() {
+  if (showTranspose.value) {
+    closeTranspose();
+    return;
+  }
+  if (!contextCell.value) return;
+  const next = nextContextTransposeState({
+    showTranspose: showTranspose.value,
+    transposeRowIndex: transposeRowIndex.value,
+    requestedRowIndex: contextCell.value.rowIndex,
+    rowIds: displayRowRefs.value.map((ref) => ref.id),
+    selectedRowIds: selectedRowIds.value,
+    selectedRange: selectedRange.value,
+  });
+  transposeRowIndex.value = next.transposeRowIndex;
+  showTranspose.value = next.showTranspose;
+  if (next.showTranspose) {
+    closeCellDetails();
+    nextTick(updateTransposeViewport);
+    if (next.transposeRowIndex !== null) scrollTransposeRecordIntoView(next.transposeRowIndex);
+  }
+}
+
+function toggleTranspose(rowIndex: number) {
+  const next = nextTransposeState(showTranspose.value, transposeRowIndex.value, rowIndex);
+  transposeRowIndex.value = next.transposeRowIndex;
+  showTranspose.value = next.showTranspose;
+  if (next.showTranspose) {
+    closeCellDetails();
+    nextTick(updateTransposeViewport);
+    if (next.transposeRowIndex !== null) scrollTransposeRecordIntoView(next.transposeRowIndex);
+  } else {
+    scrollGridRowIntoView(rowIndex);
+  }
+}
+
+function selectTransposeRecord(rowIndex: number, event?: MouseEvent) {
+  if (rowIndex < 0 || rowIndex >= displayRowCount.value) return;
+  transposeRowIndex.value = rowIndex;
+  contextHeaderColumn.value = null;
+  contextHeaderColumnIndex.value = null;
+  const item = displayItemAt(rowIndex);
+  if (item) {
+    if (event) {
+      handleRowClick(rowIndex, item.id, event);
+    } else {
+      selectedRowIds.value = new Set([item.id]);
+      selection.lastClickedRowIndex.value = rowIndex;
+      selectRow(rowIndex);
+    }
+    contextCell.value = { rowId: item.id, rowIndex, col: -1 };
+    void prefetchCopyStatements();
+  }
+  gridRef.value?.focus({ preventScroll: true });
+}
+
+function transposeRecordIsSelected(rowIndex: number): boolean {
+  const item = displayItemAt(rowIndex);
+  return !!item && isRowSelected(item.id);
+}
+
+function transposeRecordUsesSelectionVisual(rowIndex: number): boolean {
+  return hasRowSelection.value && transposeRecordIsSelected(rowIndex);
+}
+
+function transposeRecordUsesActiveHighlight(rowIndex: number): boolean {
+  return transposeRowIndex.value === rowIndex;
+}
+
+function transposeRecordUsesFramedHeader(rowIndex: number): boolean {
+  return hasRowSelection.value && transposeRecordIsSelected(rowIndex) && !hasCellSelection.value;
+}
+
+function moveTransposeRecordSelection(delta: number): boolean {
+  if (!isTransposeMode.value || displayRowCount.value === 0) return false;
+  const current = transposeRowIndex.value ?? 0;
+  const next = Math.max(0, Math.min(displayRowCount.value - 1, current + delta));
+  transposeRowIndex.value = next;
+  scrollTransposeRecordIntoView(next);
+  return true;
+}
+
+function transposeNav(delta: number) {
+  moveTransposeRecordSelection(delta);
+}
+
+watch(isTransposeMode, (active) => {
+  if (active) nextTick(updateTransposeViewport);
+});
+
+watch(
+  () => props.result,
+  () => {
+    const shouldPreserveTranspose = preserveTransposeOnNextResult.value;
+    preserveTransposeOnNextResult.value = false;
+    if (getResetScrollAfterResult()) {
+      clearResetScrollAfterResult();
+      resetGridVerticalScroll();
+    }
+    clearCellSelection();
+    clearRowSelection();
+    closeCellDetails();
+    closeDetailDialogs();
+    if (shouldPreserveTranspose) {
+      applyTransposeState(nextTransposeStateForRecordCount(showTranspose.value, transposeRowIndex.value, displayRowCount.value));
+    } else {
+      closeTranspose(false);
+    }
+    exitTransaction();
+  },
+);
+
+// --- Context menu handlers ---
+function onHeaderContext(col: string, columnIndex: number) {
+  contextCell.value = null;
+  const visibleColIdx = visibleColumnIndexes.value.indexOf(columnIndex);
+  if (visibleColIdx >= 0 && !columnIsSelected(visibleColIdx)) {
+    selectColumn(visibleColIdx);
+  }
+  contextHeaderColumn.value = col;
+  contextHeaderColumnIndex.value = columnIndex;
+}
+async function copyHeaderColumn() {
+  if (!contextHeaderColumn.value) return;
+  await copyText(contextHeaderColumn.value);
+}
+
+const canCopyAlterColumnSql = computed(() => {
+  if (!contextHeaderColumn.value || !props.tableMeta?.columns) return false;
+  if (tableStructureCapabilities.value.alterStrategy !== "direct") return false;
+  return props.tableMeta.columns.some((c) => c.name.toLowerCase() === contextHeaderColumn.value!.toLowerCase());
+});
+
+async function copyAlterColumnSql() {
+  if (!contextHeaderColumn.value) return;
+  const colName = contextHeaderColumn.value;
+  const columnInfo = props.tableMeta?.columns.find((c) => c.name.toLowerCase() === colName.toLowerCase());
+  if (!columnInfo) return;
+
+  const [draft] = createColumnDrafts([columnInfo], props.databaseType);
+  draft.original = { ...columnInfo };
+  draft.original.data_type = "";
+  draft.original.is_nullable = !columnInfo.is_nullable;
+  draft.original.column_default = null;
+  draft.original.comment = null;
+  draft.original.extra = null;
+
+  const options: BuildSingleColumnAlterSqlOptions = {
+    databaseType: props.databaseType,
+    schema: props.tableMeta?.schema,
+    tableName: props.tableMeta!.tableName,
+    column: draft,
+  };
+
+  const sqlPromise = api.buildSingleColumnAlterSql(options).then((result) => {
+    const sql = result.statements.join("\n");
+    if (!sql) throw new Error(t("grid.noAlterSqlAvailable"));
+    return { sql, warnings: result.warnings };
+  });
+
+  try {
+    const item = new ClipboardItem({
+      "text/plain": sqlPromise.then(({ sql }) => new Blob([sql], { type: "text/plain" })),
+    });
+    await navigator.clipboard.write([item]);
+    const { warnings } = await sqlPromise;
+    if (warnings.length > 0) {
+      toast(t("grid.alterSqlCopiedWithWarnings", { count: warnings.length }), 3000);
+    } else {
+      toast(t("grid.alterSqlCopied"), 2000);
+    }
+  } catch (e: any) {
+    toast(t("grid.copyAlterSqlFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+function clearNativeTextSelection() {
+  window.getSelection()?.removeAllRanges();
+}
+
+function onCellContext(rowId: number, rowIndex: number, colIdx: number, visibleColIdx: number, event?: MouseEvent) {
+  event?.preventDefault();
+  clearNativeTextSelection();
+  contextHeaderColumn.value = null;
+  contextHeaderColumnIndex.value = null;
+  contextCell.value = { rowId, rowIndex, col: colIdx };
+  if (hasRowSelection.value && isRowSelected(rowId)) {
+    void prefetchCopyStatements();
+    return;
+  }
+  clearRowSelection();
+  if (!cellIsSelected(rowIndex, visibleColIdx)) {
+    selectSingleCell(rowIndex, visibleColIdx);
+  }
+  void prefetchCopyStatements();
+}
+
+function onCellEditTextareaInput(event: Event) {
+  resetCellEditTextareaScrollOnResize = false;
+  const input = event.currentTarget as HTMLInputElement | HTMLTextAreaElement | null;
+  if (input instanceof HTMLTextAreaElement) {
+    resizeCellEditTextareaElement(input);
+    scheduleCellEditTextareaResize(input);
+  }
+}
+
+function onCellEditTextareaPaste(event: ClipboardEvent) {
+  const input = event.currentTarget as HTMLInputElement | HTMLTextAreaElement | null;
+  if (input instanceof HTMLTextAreaElement) scheduleCellEditTextareaResize(input);
+}
+
+function resizeCellEditTextareaElement(textarea: HTMLTextAreaElement | null) {
+  if (!textarea) return;
+  const textareaRect = textarea.getBoundingClientRect();
+  const visibleBottom = cellEditVisibleBottom(textarea);
+  const availableHeight = Math.max(36, Math.floor(visibleBottom - textareaRect.top - 10));
+  const metrics = cellEditTextMetrics(textarea);
+  const maxVisibleHeight = Math.ceil(metrics.lineHeight * 9.5 + metrics.verticalChrome);
+  const maxHeight = Math.min(maxVisibleHeight, availableHeight);
+  const naturalHeight = cellEditNaturalHeight(textarea, metrics);
+  const targetMinHeight = Math.max(64, Math.min(naturalHeight, 120));
+  const minHeight = Math.min(targetMinHeight, maxHeight);
+  textarea.style.setProperty("--cell-edit-min-height", `${minHeight}px`);
+  textarea.style.setProperty("--cell-edit-max-height", `${maxHeight}px`);
+  textarea.style.height = "auto";
+  textarea.style.height = `${Math.max(minHeight, Math.min(textarea.scrollHeight, maxHeight))}px`;
+  if (resetCellEditTextareaScrollOnResize) {
+    textarea.scrollTop = 0;
+    textarea.setSelectionRange?.(0, 0);
+  }
+}
+
+function cellEditTextMetrics(textarea: HTMLTextAreaElement): { lineHeight: number; verticalChrome: number } {
+  const computedStyle = window.getComputedStyle(textarea);
+  const lineHeight = Number.parseFloat(computedStyle.lineHeight) || 18;
+  const paddingTop = Number.parseFloat(computedStyle.paddingTop) || 0;
+  const paddingBottom = Number.parseFloat(computedStyle.paddingBottom) || 0;
+  const borderTop = Number.parseFloat(computedStyle.borderTopWidth) || 0;
+  const borderBottom = Number.parseFloat(computedStyle.borderBottomWidth) || 0;
+  return { lineHeight, verticalChrome: paddingTop + paddingBottom + borderTop + borderBottom };
+}
+
+function cellEditNaturalHeight(textarea: HTMLTextAreaElement, metrics = cellEditTextMetrics(textarea)): number {
+  const lines = Math.max(1, textarea.value.split(/\r\n|\r|\n/).length);
+  return Math.ceil(lines * metrics.lineHeight + metrics.verticalChrome);
+}
+
+function cellEditScrollerElement(textarea: HTMLTextAreaElement): HTMLElement | null {
+  return textarea.closest(".data-grid-scroller, .transpose-grid-scroller") as HTMLElement | null;
+}
+
+function cellEditVisibleBottom(textarea: HTMLTextAreaElement): number {
+  const bottoms: number[] = [];
+  const scroller = cellEditScrollerElement(textarea);
+  const root = gridRef.value;
+  if (scroller) bottoms.push(scroller.getBoundingClientRect().bottom);
+  if (root) bottoms.push(root.getBoundingClientRect().bottom);
+  if (typeof window !== "undefined") bottoms.push(window.innerHeight);
+
+  if (cellDetailPanelIsBottom.value && showCellDetail.value) {
+    const detailPanel = root?.querySelector<HTMLElement>("[data-cell-detail-panel]");
+    if (detailPanel) bottoms.push(detailPanel.getBoundingClientRect().top);
+  }
+
+  return Math.min(...bottoms.filter((bottom) => Number.isFinite(bottom)));
+}
+
+function scheduleCellEditTextareaResize(textarea: HTMLTextAreaElement | null) {
+  if (!textarea || typeof requestAnimationFrame !== "function") return;
+  requestAnimationFrame(() => {
+    resizeCellEditTextareaElement(textarea);
+    requestAnimationFrame(() => resizeCellEditTextareaElement(textarea));
+  });
+}
+
+function resizeActiveCellEditTextarea() {
+  const textarea = gridRef.value?.querySelector<HTMLTextAreaElement>(".cell-edit-input--expanded");
+  resizeCellEditTextareaElement(textarea ?? null);
+}
+
+function disconnectCellEditResizeObserver() {
+  cellEditResizeObserver?.disconnect();
+  cellEditResizeObserver = null;
+}
+
+function observeCellEditResizeBounds() {
+  disconnectCellEditResizeObserver();
+  if (!editingCell.value || typeof ResizeObserver === "undefined") return;
+  const textarea = gridRef.value?.querySelector<HTMLTextAreaElement>(".cell-edit-input--expanded");
+  const scroller = textarea ? cellEditScrollerElement(textarea) : null;
+  if (!textarea || !scroller) return;
+  cellEditResizeObserver = new ResizeObserver(scheduleActiveCellEditTextareaResize);
+  cellEditResizeObserver.observe(scroller);
+  cellEditResizeObserver.observe(textarea);
+  if (gridRef.value) cellEditResizeObserver.observe(gridRef.value);
+}
+
+function scheduleActiveCellEditTextareaResize() {
+  nextTick(() => {
+    resizeActiveCellEditTextarea();
+    if (typeof requestAnimationFrame === "function") {
+      requestAnimationFrame(() => {
+        resizeActiveCellEditTextarea();
+        requestAnimationFrame(resizeActiveCellEditTextarea);
+      });
+    }
+  });
+}
+
+watch(editingCell, (cell) => {
+  resetCellEditTextareaScrollOnResize = !!cell;
+  scheduleActiveCellEditTextareaResize();
+  if (cell) nextTick(observeCellEditResizeBounds);
+  else {
+    resetCellEditTextareaScrollOnResize = false;
+    expandedCellEditor.value = null;
+    disconnectCellEditResizeObserver();
+  }
+});
+watch(editValue, scheduleActiveCellEditTextareaResize);
+
+function onRowContext(rowId: number, rowIndex: number) {
+  contextHeaderColumn.value = null;
+  contextHeaderColumnIndex.value = null;
+  contextCell.value = { rowId, rowIndex, col: -1 };
+  if (!isRowSelected(rowId)) {
+    clearCellSelection();
+    selectedRowIds.value = new Set([rowId]);
+    selection.lastClickedRowIndex.value = rowIndex;
+  }
+  void prefetchCopyStatements();
+}
+
+async function prefetchCopyStatements() {
+  await prefetchRowAsInsertStatement(false);
+  if (isMultiRow.value) {
+    await prefetchRowAsInsertStatement(false, "row-by-row");
+  }
+  if (canCopyRowAsInsertWithoutPrimaryKeys.value) {
+    await prefetchRowAsInsertStatement(true);
+    if (isMultiRow.value) {
+      await prefetchRowAsInsertStatement(true, "row-by-row");
+    }
+  }
+  if (canCopyRowAsUpdate.value) {
+    await prefetchRowAsUpdateStatement();
+  }
+}
+
+const sqlOneLiner = computed(() => props.sql?.replace(/\s+/g, " ").trim() || "");
+
+type TableInfoTabItem = { id: TableInfoTab; label: string; icon: Component; count?: number };
+
+const TABLE_INFO_DRAWER_MIN_WIDTH = 240;
+const CELL_DETAIL_PANEL_MIN_HEIGHT = 180;
+const CELL_DETAIL_PANEL_MIN_WIDTH = 260;
+const CELL_DETAIL_PANEL_MAX_HEIGHT = 520;
+const CELL_DETAIL_TABLE_HEADER_HEIGHT = 28;
+const CELL_DETAIL_TABLE_MIN_VISIBLE_ROWS = 1.5;
+const CELL_DETAIL_TABLE_HORIZONTAL_SCROLLBAR_HEIGHT = 10;
+const CELL_DETAIL_TABLE_MIN_VISIBLE_HEIGHT = Math.ceil(CELL_DETAIL_TABLE_HEADER_HEIGHT + CANVAS_DATA_GRID_ROW_HEIGHT * CELL_DETAIL_TABLE_MIN_VISIBLE_ROWS + CELL_DETAIL_TABLE_HORIZONTAL_SCROLLBAR_HEIGHT);
+const DRAWER_MAX_WIDTH = 900;
+const MONGO_JSON_PREVIEW_DEFAULT_WIDTH = 420;
+function clampCellDetailPanelSize(value: number, layout = cellDetailPanelLayout.value): number {
+  const min = layout === "bottom" ? CELL_DETAIL_PANEL_MIN_HEIGHT : CELL_DETAIL_PANEL_MIN_WIDTH;
+  const max = layout === "bottom" ? CELL_DETAIL_PANEL_MAX_HEIGHT : DRAWER_MAX_WIDTH;
+  return Math.min(Math.max(value, min), max);
+}
+// Table info drawers are tied to a single grid instance. Keeping this state
+// module-global leaks the drawer into other kept-alive tabs.
+const showTableInfo = ref(false);
+const activeTableInfoTab = ref<TableInfoTab>("ddl");
+const ddlContent = ref("");
+const ddlPreRef = ref<HTMLPreElement | null>(null);
+function onDdlKeydown(e: KeyboardEvent) {
+  if ((e.ctrlKey || e.metaKey) && e.key === "a") {
+    e.preventDefault();
+    const el = ddlPreRef.value;
+    if (!el) return;
+    const range = document.createRange();
+    range.selectNodeContents(el);
+    const sel = window.getSelection();
+    sel?.removeAllRanges();
+    sel?.addRange(range);
+  }
+}
+const ddlLoading = ref(false);
+const ddlWidth = ref(settingsStore.editorSettings.tableInfoDrawerWidth);
+const detailPanelHeight = ref(settingsStore.editorSettings.cellDetailDrawerWidth);
+const mongoJsonPreviewWidth = ref(MONGO_JSON_PREVIEW_DEFAULT_WIDTH);
+const ddlWrap = ref(true);
+const isResizingDdl = ref(false);
+const isResizingMongoJsonPreview = ref(false);
+let ddlResizeStartX = 0;
+let ddlResizeStartWidth = 0;
+let detailResizeStartY = 0;
+let detailResizeStartHeight = 0;
+let mongoJsonPreviewResizeStartX = 0;
+let mongoJsonPreviewResizeStartWidth = 0;
+const indexes = ref<IndexInfo[]>([]);
+const indexesLoaded = ref(false);
+const indexesLoading = ref(false);
+const indexesError = ref("");
+const showDropMongoIndexConfirm = ref(false);
+const dropMongoIndexLoading = ref(false);
+const pendingDropMongoIndex = ref<IndexInfo | null>(null);
+const showDropAllMongoIndexesConfirm = ref(false);
+const dropAllMongoIndexesLoading = ref(false);
+const foreignKeys = ref<ForeignKeyInfo[]>([]);
+const foreignKeysLoaded = ref(false);
+const foreignKeysLoading = ref(false);
+const foreignKeysError = ref("");
+const triggers = ref<TriggerInfo[]>([]);
+const triggersLoaded = ref(false);
+const triggersLoading = ref(false);
+const triggersError = ref("");
+const searchQuery = ref("");
+const cellDetailPanelLayout = computed(() => settingsStore.editorSettings.cellDetailPanelLayout);
+const cellDetailPanelIsBottom = computed(() => cellDetailPanelLayout.value === "bottom");
+
+watch([showCellDetail, showTableInfo], () => {
+  if (useCanvasGridRows.value) nextTick(syncCanvasViewport);
+});
+
+watch(activeTableInfoTab, () => {
+  searchQuery.value = "";
+});
+
+watch([activeTableInfoTab, ddlLoading], ([tab, loading]) => {
+  if (tab === "ddl" && !loading) {
+    void nextTick(() => {
+      ddlPreRef.value?.focus();
+    });
+  }
+});
+
+watch(
+  () => settingsStore.editorSettings.tableInfoDrawerWidth,
+  (width) => {
+    if (!isResizingDdl.value) ddlWidth.value = width;
+  },
+);
+
+watch(
+  () => settingsStore.editorSettings.cellDetailDrawerWidth,
+  (height) => {
+    if (!isResizingDetail.value) detailPanelHeight.value = clampCellDetailPanelSize(height);
+    scheduleActiveCellEditTextareaResize();
+  },
+);
+
+watch(cellDetailPanelLayout, (layout) => {
+  if (!isResizingDetail.value) detailPanelHeight.value = clampCellDetailPanelSize(detailPanelHeight.value, layout);
+  scheduleActiveCellEditTextareaResize();
+});
+
+watch([showCellDetail, activeCellDetail, cellDetailPanelIsBottom, detailPanelHeight], scheduleActiveCellEditTextareaResize);
+
+const ddlDrawerStyle = computed(() => ({
+  width: `${ddlWidth.value}px`,
+}));
+
+const detailPanelStyle = computed(() =>
+  cellDetailPanelIsBottom.value
+    ? {
+        height: "100%",
+      }
+    : { width: `${detailPanelHeight.value}px` },
+);
+
+const mongoJsonPreviewStyle = computed(() => ({
+  width: `${mongoJsonPreviewWidth.value}px`,
+}));
+
+const contentGridStyle = computed(() =>
+  cellDetailPanelIsBottom.value && showCellDetail.value && activeCellDetail.value
+    ? {
+        gridTemplateColumns: "minmax(0, 1fr) auto",
+        gridTemplateRows: `minmax(${CELL_DETAIL_TABLE_MIN_VISIBLE_HEIGHT}px, 1fr) minmax(0, min(${detailPanelHeight.value}px, 70vh, ${CELL_DETAIL_PANEL_MAX_HEIGHT}px, calc(100% - ${CELL_DETAIL_TABLE_MIN_VISIBLE_HEIGHT}px)))`,
+      }
+    : {
+        gridTemplateColumns: "minmax(0, 1fr) auto auto",
+        gridTemplateRows: "minmax(0, 1fr)",
+      },
+);
+
+function toggleCellDetailPanelLayout() {
+  const nextLayout = cellDetailPanelIsBottom.value ? "right" : "bottom";
+  const nextSize = clampCellDetailPanelSize(detailPanelHeight.value, nextLayout);
+  detailPanelHeight.value = nextSize;
+  settingsStore.updateEditorSettings({
+    ...(nextLayout === "right" ? { cellDetailDrawerWidth: nextSize } : {}),
+    cellDetailPanelLayout: nextLayout,
+  });
+}
+
+const tableMetadataCapabilities = computed(() => getTableMetadataCapabilities(props.databaseType));
+const canOpenTableStructureEditor = computed(() => !!props.connectionId && !!props.database && !!props.tableMeta?.tableName && supportsTableStructureEditing(resolvedDatabaseType.value));
+const mongoConnectionConfig = resolvedConnectionConfig;
+const canManageMongoIndexes = computed(() => resolvedDatabaseType.value === "mongodb" && !!props.connectionId && !!props.database && !!props.tableMeta?.tableName && mongoConnectionConfig.value?.db_type === "mongodb" && mongoConnectionConfig.value?.driver_profile !== "mongodb-legacy");
+const tableInfoTabs = computed(() => {
+  const tabs: TableInfoTabItem[] = [];
+  if (tableMetadataCapabilities.value.ddl) {
+    tabs.push({ id: "ddl", label: "DDL", icon: Code2 });
+  }
+  if (tableMetadataCapabilities.value.columns) {
+    tabs.push({
+      id: "columns",
+      label: t("grid.tableInfoColumns"),
+      icon: ListTree,
+      count: props.tableMeta?.columns.length,
+    });
+  }
+  if (tableMetadataCapabilities.value.indexes) {
+    tabs.push({ id: "indexes", label: t("grid.tableInfoIndexes"), icon: KeyRound, count: indexes.value.length });
+  }
+  if (tableMetadataCapabilities.value.foreignKeys) {
+    tabs.push({
+      id: "foreignKeys",
+      label: t("grid.tableInfoForeignKeys"),
+      icon: Link2,
+      count: foreignKeys.value.length,
+    });
+  }
+  if (tableMetadataCapabilities.value.triggers) {
+    tabs.push({ id: "triggers", label: t("grid.tableInfoTriggers"), icon: RotateCcw, count: triggers.value.length });
+  }
+  return tabs;
+});
+const tableInfoTabListStyle = computed(() => ({
+  gridTemplateColumns: `repeat(${tableInfoTabs.value.length}, minmax(0, 1fr))`,
+}));
+
+async function toggleTableInfo(tab: TableInfoTab = activeTableInfoTab.value) {
+  if (showTableInfo.value && activeTableInfoTab.value === tab) {
+    showTableInfo.value = false;
+    return;
+  }
+  showTableInfo.value = true;
+  await selectTableInfoTab(tab);
+}
+
+async function selectTableInfoTab(tab: TableInfoTab) {
+  const nextTab = tableInfoTabs.value.some((item) => item.id === tab) ? tab : tableInfoTabs.value[0]?.id;
+  if (!nextTab) return;
+  activeTableInfoTab.value = nextTab;
+  if (nextTab === "ddl") await fetchDdl();
+  else if (nextTab === "indexes") await fetchIndexes();
+  else if (nextTab === "foreignKeys") await fetchForeignKeys();
+  else if (nextTab === "triggers") await fetchTriggers();
+}
+
+watch(
+  () => [props.tableInfoTab, props.connectionId, props.database, props.tableMeta?.catalog, props.tableMeta?.schema, props.tableMeta?.tableName] as const,
+  ([tab]) => {
+    if (tab) void selectTableInfoTab(tab);
+  },
+  { immediate: true },
+);
+
+async function fetchDdl() {
+  if (!props.connectionId || !props.tableMeta) return;
+  showTableInfo.value = true;
+  ddlLoading.value = true;
+  try {
+    ddlContent.value = await api.getTableDdl(props.connectionId, props.database || "", props.tableMeta.schema || props.database || "", props.tableMeta.tableName, undefined, props.tableMeta.catalog);
+  } catch (e: any) {
+    ddlContent.value = `-- Error: ${e}`;
+  } finally {
+    ddlLoading.value = false;
+  }
+}
+
+async function fetchIndexes() {
+  if (!props.connectionId || !props.tableMeta || indexesLoaded.value || indexesLoading.value) return;
+  indexesLoading.value = true;
+  indexesError.value = "";
+  try {
+    indexes.value = await api.listIndexes(props.connectionId, props.database || "", props.tableMeta.schema || props.database || "", props.tableMeta.tableName, props.tableMeta.catalog);
+    indexesLoaded.value = true;
+  } catch (e: any) {
+    indexesError.value = String(e?.message || e);
+  } finally {
+    indexesLoading.value = false;
+  }
+}
+
+async function reloadIndexes() {
+  indexesLoaded.value = false;
+  await fetchIndexes();
+}
+
+async function fetchForeignKeys() {
+  if (!props.connectionId || !props.tableMeta || foreignKeysLoaded.value || foreignKeysLoading.value) return;
+  foreignKeysLoading.value = true;
+  foreignKeysError.value = "";
+  try {
+    foreignKeys.value = await api.listForeignKeys(props.connectionId, props.database || "", props.tableMeta.schema || props.database || "", props.tableMeta.tableName, props.tableMeta.catalog);
+    foreignKeysLoaded.value = true;
+  } catch (e: any) {
+    foreignKeysError.value = String(e?.message || e);
+  } finally {
+    foreignKeysLoading.value = false;
+  }
+}
+
+async function fetchTriggers() {
+  if (!props.connectionId || !props.tableMeta || triggersLoaded.value || triggersLoading.value) return;
+  triggersLoading.value = true;
+  triggersError.value = "";
+  try {
+    triggers.value = await api.listTriggers(props.connectionId, props.database || "", props.tableMeta.schema || props.database || "", props.tableMeta.tableName, props.tableMeta.catalog);
+    triggersLoaded.value = true;
+  } catch (e: any) {
+    triggersError.value = String(e?.message || e);
+  } finally {
+    triggersLoading.value = false;
+  }
+}
+
+watch(
+  () => [props.connectionId, props.database, props.tableMeta?.catalog, props.tableMeta?.schema, props.tableMeta?.tableName],
+  () => {
+    ddlContent.value = "";
+    indexes.value = [];
+    indexesLoaded.value = false;
+    indexesError.value = "";
+    foreignKeys.value = [];
+    foreignKeysLoaded.value = false;
+    foreignKeysError.value = "";
+    triggers.value = [];
+    triggersLoaded.value = false;
+    triggersError.value = "";
+    if (showTableInfo.value) selectTableInfoTab(activeTableInfoTab.value);
+  },
+);
+
+if (showTableInfo.value && props.tableMeta && props.connectionId) {
+  selectTableInfoTab(activeTableInfoTab.value);
+}
+
+function copyDdl() {
+  copyText(ddlContent.value);
+}
+
+function openTableStructureEditor() {
+  if (!props.connectionId || !props.database || !props.tableMeta?.tableName || !canOpenTableStructureEditor.value) return;
+  queryStore.openTableStructure(props.connectionId, props.database, props.tableMeta.schema, props.tableMeta.tableName, activeTableInfoTab.value);
+}
+
+function toggleDdlWrap() {
+  ddlWrap.value = !ddlWrap.value;
+}
+
+function searchSplitContainerWidth(): number {
+  return searchSplitContainerRef.value?.getBoundingClientRect().width ?? 0;
+}
+
+function onSearchSplitResizeStart(event: MouseEvent) {
+  const containerWidth = searchSplitContainerWidth();
+  if (containerWidth <= 0) return;
+  event.preventDefault();
+  isResizingSearchSplit.value = true;
+  searchSplitStartX = event.clientX;
+  searchSplitStartWidth = clampSearchSplitWidth({
+    containerWidth,
+    desiredWidth: searchSplitWhereWidth.value ?? undefined,
+  });
+  searchSplitWhereWidth.value = searchSplitStartWidth;
+  document.body.classList.add("select-none", "cursor-col-resize");
+  window.addEventListener("mousemove", onSearchSplitResizeMove);
+  window.addEventListener("mouseup", onSearchSplitResizeEnd);
+}
+
+function onSearchSplitResizeMove(event: MouseEvent) {
+  if (!isResizingSearchSplit.value) return;
+  const containerWidth = searchSplitContainerWidth();
+  if (containerWidth <= 0) return;
+  searchSplitWhereWidth.value = clampSearchSplitWidth({
+    containerWidth,
+    desiredWidth: searchSplitStartWidth + event.clientX - searchSplitStartX,
+  });
+  resizeFocusedConditionInputs();
+}
+
+function onSearchSplitResizeEnd() {
+  isResizingSearchSplit.value = false;
+  document.body.classList.remove("select-none", "cursor-col-resize");
+  window.removeEventListener("mousemove", onSearchSplitResizeMove);
+  window.removeEventListener("mouseup", onSearchSplitResizeEnd);
+}
+
+function resetSearchSplitWidth() {
+  const containerWidth = searchSplitContainerWidth();
+  searchSplitWhereWidth.value = containerWidth > 0 ? clampSearchSplitWidth({ containerWidth }) : null;
+  resizeFocusedConditionInputs();
+}
+
+function onDataGridTopbarFixedActionWheel(event: WheelEvent) {
+  if (Math.abs(event.deltaX) <= Math.abs(event.deltaY)) return;
+  event.preventDefault();
+  event.stopPropagation();
+}
+
+function onConditionInputWheel(event: WheelEvent) {
+  const input = event.currentTarget instanceof HTMLTextAreaElement ? event.currentTarget : null;
+  if (!input || Math.abs(event.deltaX) <= Math.abs(event.deltaY)) return;
+  input.scrollLeft += event.deltaX;
+  event.preventDefault();
+  event.stopPropagation();
+}
+
+function onDdlResizeStart(event: MouseEvent) {
+  isResizingDdl.value = true;
+  ddlResizeStartX = event.clientX;
+  ddlResizeStartWidth = ddlWidth.value;
+  document.body.classList.add("select-none", "cursor-col-resize");
+  window.addEventListener("mousemove", onDdlResizeMove);
+  window.addEventListener("mouseup", onDdlResizeEnd);
+}
+
+function onDdlResizeMove(event: MouseEvent) {
+  if (!isResizingDdl.value) return;
+  const nextWidth = ddlResizeStartWidth + ddlResizeStartX - event.clientX;
+  ddlWidth.value = Math.min(Math.max(nextWidth, TABLE_INFO_DRAWER_MIN_WIDTH), DRAWER_MAX_WIDTH);
+}
+
+function onDdlResizeEnd() {
+  if (isResizingDdl.value) {
+    settingsStore.updateEditorSettings({ tableInfoDrawerWidth: ddlWidth.value });
+  }
+  isResizingDdl.value = false;
+  document.body.classList.remove("select-none", "cursor-col-resize");
+  window.removeEventListener("mousemove", onDdlResizeMove);
+  window.removeEventListener("mouseup", onDdlResizeEnd);
+}
+
+function onDetailResizeStart(event: MouseEvent) {
+  isResizingDetail.value = true;
+  // 底部布局拖顶部边缘(垂直/clientY),右侧布局拖左边缘(水平/clientX)
+  detailResizeStartY = cellDetailPanelIsBottom.value ? event.clientY : event.clientX;
+  detailResizeStartHeight = detailPanelHeight.value;
+  document.body.classList.add("select-none", cellDetailPanelIsBottom.value ? "cursor-row-resize" : "cursor-col-resize");
+  window.addEventListener("mousemove", onDetailResizeMove);
+  window.addEventListener("mouseup", onDetailResizeEnd);
+}
+
+function onDetailResizeMove(event: MouseEvent) {
+  if (!isResizingDetail.value) return;
+  const pos = cellDetailPanelIsBottom.value ? event.clientY : event.clientX;
+  const nextSize = detailResizeStartHeight + detailResizeStartY - pos;
+  detailPanelHeight.value = clampCellDetailPanelSize(nextSize);
+}
+
+function onDetailResizeEnd() {
+  if (isResizingDetail.value) {
+    settingsStore.updateEditorSettings({ cellDetailDrawerWidth: detailPanelHeight.value });
+  }
+  isResizingDetail.value = false;
+  document.body.classList.remove("select-none", "cursor-row-resize", "cursor-col-resize");
+  window.removeEventListener("mousemove", onDetailResizeMove);
+  window.removeEventListener("mouseup", onDetailResizeEnd);
+}
+
+function onMongoJsonPreviewResizeStart(event: MouseEvent) {
+  isResizingMongoJsonPreview.value = true;
+  mongoJsonPreviewResizeStartX = event.clientX;
+  mongoJsonPreviewResizeStartWidth = mongoJsonPreviewWidth.value;
+  document.body.classList.add("select-none", "cursor-col-resize");
+  window.addEventListener("mousemove", onMongoJsonPreviewResizeMove);
+  window.addEventListener("mouseup", onMongoJsonPreviewResizeEnd);
+}
+
+function onMongoJsonPreviewResizeMove(event: MouseEvent) {
+  if (!isResizingMongoJsonPreview.value) return;
+  mongoJsonPreviewWidth.value = clampCellDetailPanelSize(mongoJsonPreviewResizeStartWidth + mongoJsonPreviewResizeStartX - event.clientX, "right");
+}
+
+function onMongoJsonPreviewResizeEnd() {
+  isResizingMongoJsonPreview.value = false;
+  document.body.classList.remove("select-none", "cursor-col-resize");
+  window.removeEventListener("mousemove", onMongoJsonPreviewResizeMove);
+  window.removeEventListener("mouseup", onMongoJsonPreviewResizeEnd);
+}
+
+const loadingElapsed = ref(0);
+let _loadingFrame: number | undefined;
+let _loadingStart = 0;
+
+function stopLoadingElapsedTimer() {
+  if (_loadingFrame !== undefined) {
+    window.cancelAnimationFrame(_loadingFrame);
+    _loadingFrame = undefined;
+  }
+}
+
+function startLoadingElapsedTimer() {
+  stopLoadingElapsedTimer();
+  if (!dataGridIsActive || !props.loading) return;
+  _loadingStart = Date.now();
+  loadingElapsed.value = 0;
+  const updateOnNextFrame = () => {
+    if (!dataGridIsActive || !props.loading) return;
+    loadingElapsed.value = Date.now() - _loadingStart;
+    _loadingFrame = window.requestAnimationFrame(updateOnNextFrame);
+  };
+  _loadingFrame = window.requestAnimationFrame(updateOnNextFrame);
+}
+
+watch(
+  () => props.loading,
+  (isLoading) => {
+    stopLoadingElapsedTimer();
+    if (isDebugLoggingEnabled()) {
+      logDataGridTiming(isLoading ? "[DBX][DataGrid:loading:start]" : "[DBX][DataGrid:loading:stop]", {
+        traceId: dataGridTraceId,
+        cacheKey: props.cacheKey,
+        elapsedSinceSetup: dataGridElapsed(),
+      });
+    }
+    if (isLoading) {
+      startLoadingElapsedTimer();
+    } else {
+      if (isDebugLoggingEnabled()) {
+        nextTick(() => {
+          requestAnimationFrame(() => {
+            logDataGridTiming("[DBX][DataGrid:loading:stop:first-frame]", {
+              traceId: dataGridTraceId,
+              cacheKey: props.cacheKey,
+              elapsedSinceSetup: dataGridElapsed(),
+            });
+          });
+        });
+      }
+    }
+  },
+);
+
+onActivated(() => {
+  startLoadingElapsedTimer();
+  restartAutoRefreshTimer();
+});
+onDeactivated(() => {
+  stopLoadingElapsedTimer();
+  stopAutoRefreshTimer();
+});
+
+onUnmounted(() => {
+  cleanupFrames();
+  stopAutoRefreshTimer();
+  cancelColumnHeaderDragPreview();
+  clearColumnHeaderResizeListeners();
+  clearColumnHeaderClickGuard();
+  columnHeaderResizeActive.value = false;
+  onSearchSplitResizeEnd();
+  onDdlResizeEnd();
+  onDetailResizeEnd();
+  onMongoJsonPreviewResizeEnd();
+  finishCellSelection();
+  clearTimeout(highlightedColumnTimer);
+  clearTimeout(_searchTimer);
+  if (serverFilterSearchTimer !== undefined) {
+    window.clearTimeout(serverFilterSearchTimer);
+  }
+  stopLoadingElapsedTimer();
+});
+
+const filteredColumns = computed(() => {
+  if (!searchQuery.value) return props.tableMeta?.columns ?? [];
+  const q = searchQuery.value.toLowerCase();
+  return (props.tableMeta?.columns ?? []).filter((c) => c.name.toLowerCase().includes(q) || c.data_type.toLowerCase().includes(q));
+});
+
+const filteredIndexes = computed(() => {
+  if (!searchQuery.value) return indexes.value;
+  const q = searchQuery.value.toLowerCase();
+  return indexes.value.filter((i) => i.name.toLowerCase().includes(q) || i.columns.some((c) => c.toLowerCase().includes(q)));
+});
+
+const droppableMongoIndexes = computed(() => indexes.value.filter((index) => !index.is_primary));
+const dropMongoIndexConfirmMessage = computed(() =>
+  pendingDropMongoIndex.value
+    ? t("contextMenu.confirmDropMongoIndexMessage", {
+        name: pendingDropMongoIndex.value.name,
+        collection: props.tableMeta?.tableName || "",
+      })
+    : "",
+);
+const dropAllMongoIndexesConfirmMessage = computed(() => t("contextMenu.confirmDropMongoAllIndexesMessage", { name: props.tableMeta?.tableName || "" }));
+const dropAllMongoIndexesConfirmDetails = computed(() => t("contextMenu.confirmDropMongoAllIndexesDetails"));
+const dropMongoIndexPreview = computed(() => (pendingDropMongoIndex.value ? `db.getCollection(${JSON.stringify(props.tableMeta?.tableName || "")}).dropIndex(${JSON.stringify(pendingDropMongoIndex.value.name)})` : ""));
+const dropAllMongoIndexesPreview = computed(() => `db.getCollection(${JSON.stringify(props.tableMeta?.tableName || "")}).dropIndexes()`);
+
+function requestDropMongoIndex(index: IndexInfo) {
+  pendingDropMongoIndex.value = index;
+  showDropMongoIndexConfirm.value = true;
+}
+
+function requestDropAllMongoIndexes() {
+  showDropAllMongoIndexesConfirm.value = true;
+}
+
+async function confirmDropMongoIndex() {
+  if (!props.connectionId || !props.database || !props.tableMeta?.tableName || !pendingDropMongoIndex.value || dropMongoIndexLoading.value) return;
+  dropMongoIndexLoading.value = true;
+  try {
+    await connectionStore.ensureConnected(props.connectionId);
+    await api.mongoDropIndexes(props.connectionId, props.database, props.tableMeta.tableName, JSON.stringify(pendingDropMongoIndex.value.name), true);
+    toast(t("contextMenu.dropTableChildObjectSuccess", { name: pendingDropMongoIndex.value.name }), 3000);
+    showDropMongoIndexConfirm.value = false;
+    pendingDropMongoIndex.value = null;
+    await reloadIndexes();
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  } finally {
+    dropMongoIndexLoading.value = false;
+  }
+}
+
+async function confirmDropAllMongoIndexes() {
+  if (!props.connectionId || !props.database || !props.tableMeta?.tableName || dropAllMongoIndexesLoading.value) return;
+  dropAllMongoIndexesLoading.value = true;
+  try {
+    await connectionStore.ensureConnected(props.connectionId);
+    const result = await api.mongoDropIndexes(props.connectionId, props.database, props.tableMeta.tableName, undefined, false);
+    toast(t("contextMenu.dropAllIndexesSuccess", { count: result.dropped_names.length, name: props.tableMeta.tableName }), 3000);
+    showDropAllMongoIndexesConfirm.value = false;
+    await reloadIndexes();
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  } finally {
+    dropAllMongoIndexesLoading.value = false;
+  }
+}
+
+const filteredForeignKeys = computed(() => {
+  if (!searchQuery.value) return foreignKeys.value;
+  const q = searchQuery.value.toLowerCase();
+  return foreignKeys.value.filter((fk) => fk.name.toLowerCase().includes(q) || fk.column.toLowerCase().includes(q) || fk.ref_table.toLowerCase().includes(q) || fk.ref_column.toLowerCase().includes(q));
+});
+
+const filteredTriggers = computed(() => {
+  if (!searchQuery.value) return triggers.value;
+  const q = searchQuery.value.toLowerCase();
+  return triggers.value.filter((t) => t.name.toLowerCase().includes(q));
+});
+
+const filteredDdlContent = computed(() => {
+  if (!ddlContent.value) return "";
+  const html = highlight(ddlContent.value);
+  if (!searchQuery.value) return html;
+
+  const escaped = searchQuery.value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`(${escaped})`, "gi");
+  // Match only text between > and < (text nodes), then replace the search term within those spans
+  return html.replace(/>([^<]*)</g, (_, text) => {
+    return `>${text.replace(regex, "<mark>$1</mark>")}<`;
+  });
+});
+
+defineExpose({
+  useTransaction,
+  transactionActive,
+  isSaving,
+  onToolbarRefresh,
+  onToolbarCommit,
+  onToolbarRollback,
+  showDdl: showTableInfo,
+  toggleDdl: toggleTableInfo,
+  showTableInfo,
+  toggleTableInfo,
+  multiRowTranspose,
+  setMultiRowTranspose,
+  toggleMultiRowTranspose,
+  focusSearch,
+  visibleColumnCount,
+  displayableColumnCount,
+  hiddenColumnCount,
+  filteredColumnVisibilityOptions,
+  isColumnVisible,
+  toggleColumnVisibility,
+  showAllColumns,
+  invertColumnVisibility,
+  hasCustomColumnOrder,
+  resetColumnOrder,
+  nullColumnsHidden,
+  allNullColumnCount,
+  canToggleAllNullColumns,
+  toggleAllNullColumns,
+  openCellDetailSearch,
+  exportCsv,
+  exportJson,
+  exportSql,
+  exportXlsx,
+});
+
+// ---- CustomContextMenu ----
+
+function rowActionLabels() {
+  return {
+    clone: isMultiRow.value ? t("grid.cloneRows", { count: multiRowCount.value }) : t("grid.cloneRow"),
+    restore: isMultiRow.value ? t("grid.restoreRows", { count: multiRowCount.value }) : t("grid.restoreRow"),
+    delete: isMultiRow.value ? t("grid.deleteRows", { count: multiRowCount.value }) : t("grid.deleteRow"),
+  };
+}
+
+function copyRowLabels() {
+  const count = multiRowCount.value;
+  return {
+    row: isMultiRow.value ? t("grid.copyRows", { count }) : t("grid.copyRow"),
+    insert: isMultiRow.value ? t("grid.copyRowsInsert", { count }) : t("grid.copyRowInsert"),
+    insertMerged: t("grid.copyRowsInsertMerged", { count }),
+    insertRowByRow: t("grid.copyRowsInsertRowByRow", { count }),
+    insertNoPk: isMultiRow.value ? t("grid.copyRowsInsertWithoutPrimaryKeys", { count }) : t("grid.copyRowInsertWithoutPrimaryKeys"),
+    insertNoPkMerged: t("grid.copyRowsInsertWithoutPrimaryKeysMerged", { count }),
+    insertNoPkRowByRow: t("grid.copyRowsInsertWithoutPrimaryKeysRowByRow", { count }),
+    update: isMultiRow.value ? t("grid.copyRowsUpdate", { count }) : t("grid.copyRowUpdate"),
+  };
+}
+
+function filterSubmenu(): ContextMenuItem {
+  return {
+    label: t("grid.filter"),
+    icon: Filter,
+    children: [
+      { label: t("grid.filterByValue"), action: () => applyContextFilter("equals") },
+      { label: t("grid.filterExcludeValue"), action: () => applyContextFilter("not-equals") },
+      { label: t("grid.filterLike"), action: () => applyContextFilter("like") },
+      { label: t("grid.filterNotLike"), action: () => applyContextFilter("not-like") },
+      { label: t("grid.filterLessThan"), action: () => applyContextFilter("less-than") },
+      { label: t("grid.filterGreaterThan"), action: () => applyContextFilter("greater-than") },
+      { label: "", separator: true },
+      { label: t("grid.filterIsNull"), action: () => applyContextFilter("is-null") },
+      { label: t("grid.filterIsNotNull"), action: () => applyContextFilter("is-not-null") },
+      { label: "", separator: true },
+      { label: t("grid.clearFilter"), action: clearContextFilter },
+    ],
+  };
+}
+
+function copySubmenu(): ContextMenuItem {
+  const labels = copyRowLabels();
+  const items: ContextMenuItem[] = [];
+  if (contextColumn.value) {
+    items.push({ label: t("grid.copyCell"), action: copyCell });
+  }
+  items.push({ label: labels.row, action: copyRow });
+  if (hasRowSelection.value && selectedRowCount.value > 0) {
+    const singleRowSelected = selectedRowCount.value === 1;
+    items.push({ label: singleRowSelected ? t("grid.copySelectedRowTsv") : t("grid.copySelectedRowsTsv", { count: selectedRowCount.value }), action: copySelectedRowsTsv });
+    items.push({ label: singleRowSelected ? t("grid.copySelectedRowTsvWithHeaders") : t("grid.copySelectedRowsTsvWithHeaders", { count: selectedRowCount.value }), action: copySelectedRowsTsvWithHeaders });
+  }
+  if (isMultiRow.value) {
+    items.push({ label: labels.insertMerged, action: () => copyRowAsInsert("merged"), disabled: !canCopyRowAsInsert.value });
+    items.push({ label: labels.insertRowByRow, action: () => copyRowAsInsert("row-by-row"), disabled: !canCopyRowAsInsert.value });
+  } else {
+    items.push({ label: labels.insert, action: () => copyRowAsInsert(), disabled: !canCopyRowAsInsert.value });
+  }
+  if (canCopyRowAsInsertWithoutPrimaryKeys.value) {
+    if (isMultiRow.value) {
+      items.push({
+        label: labels.insertNoPkMerged,
+        action: () => copyRowAsInsertWithoutPrimaryKeys("merged"),
+      });
+      items.push({
+        label: labels.insertNoPkRowByRow,
+        action: () => copyRowAsInsertWithoutPrimaryKeys("row-by-row"),
+      });
+    } else {
+      items.push({
+        label: labels.insertNoPk,
+        action: () => copyRowAsInsertWithoutPrimaryKeys(),
+      });
+    }
+  }
+  if (canCopyRowAsUpdate.value) {
+    items.push({ label: labels.update, action: copyRowAsUpdate });
+  }
+  items.push({ label: t("grid.copyAll"), action: copyAll });
+  items.push({ label: t("grid.copyColumnNames"), action: copyColumnNames });
+  return { label: t("grid.copy"), icon: Copy, children: items };
+}
+
+function selectionSubmenu(): ContextMenuItem {
+  return {
+    label: t("grid.selection"),
+    icon: SquareDashed,
+    children: [
+      { label: t("grid.copySelectionTsv"), action: copySelectionTsv },
+      { label: t("grid.copySelectionTsvWithHeaders"), action: copySelectionTsvWithHeaders },
+      { label: t("grid.copySelectionCsv"), action: copySelectionCsv },
+      { label: t("grid.copySelectionJson"), action: copySelectionJson },
+      { label: t("grid.copySelectionSql"), action: copySelectionSqlInList },
+      { label: "", separator: true },
+      { label: t("grid.clearSelection"), action: clearCellSelection },
+    ],
+  };
+}
+
+function exportSubmenu(): ContextMenuItem {
+  const items: ContextMenuItem[] = [
+    { label: t("grid.exportCsv"), action: exportCsv },
+    { label: t("grid.exportXlsx"), action: exportXlsx },
+    { label: t("grid.exportJson"), action: exportJson },
+    { label: t("grid.exportMarkdown"), action: exportMarkdown },
+    { label: t("grid.exportSql"), action: exportSql },
+  ];
+  if (isMultiRow.value) {
+    items.push(
+      { label: "", separator: true },
+      { label: t("grid.exportSelectedRowsCsv"), action: exportSelectedRowsCsv },
+      { label: t("grid.exportSelectedRowsXlsx"), action: exportSelectedRowsXlsx },
+      { label: t("grid.exportSelectedRowsJson"), action: exportSelectedRowsJson },
+      { label: t("grid.exportSelectedRowsMarkdown"), action: exportSelectedRowsMarkdown },
+      { label: t("grid.exportSelectedRowsSql"), action: exportSelectedRowsSql },
+    );
+  }
+  return { label: t("grid.export"), icon: Upload, children: items };
+}
+
+const gridContextMenuItems = computed<ContextMenuItem[]>(() => {
+  const items: ContextMenuItem[] = [];
+
+  // 1. Copy column name
+  if (contextHeaderColumn.value) {
+    items.push({ label: t("grid.copyColumnName"), action: copyHeaderColumn, icon: Copy });
+    items.push({ label: t("grid.copyColumnNames"), action: copyColumnNames, icon: Copy });
+    items.push({
+      label: t("grid.openColumnDetailsDialog"),
+      action: openContextColumnDetailDialog,
+      icon: TableProperties,
+    });
+    if (canCopyAlterColumnSql.value) {
+      items.push({ label: t("grid.copyAlterColumnSql"), action: copyAlterColumnSql, icon: Copy });
+    }
+  }
+
+  // 2. Column sort & filter
+  if (contextColumn.value) {
+    items.push(
+      { label: t("grid.sortDatabaseAscending"), action: () => applyContextSort("asc", "database"), icon: Database },
+      { label: t("grid.sortDatabaseDescending"), action: () => applyContextSort("desc", "database"), icon: Database },
+      { label: "", separator: true },
+      { label: t("grid.sortCurrentPageAscending"), action: () => applyContextSort("asc", "local"), icon: ArrowUp },
+      { label: t("grid.sortCurrentPageDescending"), action: () => applyContextSort("desc", "local"), icon: ArrowDown },
+    );
+    if (sortCol.value) {
+      items.push({ label: t("grid.clearSort"), action: () => applyContextSort(null, sortMode.value), icon: ArrowUpDown });
+    }
+    if (canUseWhereSearch.value) {
+      items.push({ label: "", separator: true });
+      items.push(filterSubmenu());
+    }
+    items.push({ label: "", separator: true });
+  }
+
+  // 3. Detail dialogs
+  if (contextCell.value) {
+    if (contextColumn.value) {
+      items.push({ label: t("grid.openCellDetailsDialog"), action: openContextCellDetailDialog, icon: Maximize2 });
+      const downloadItem = binaryDownloadSubmenu(contextCellDetail.value);
+      if (downloadItem) items.push(downloadItem);
+      items.push({
+        label: t("grid.openColumnDetailsDialog"),
+        action: openContextColumnDetailDialog,
+        icon: TableProperties,
+      });
+    }
+    items.push({ label: t("grid.openRowDetailsDialog"), action: openContextRowDetailDialog, icon: ListTree });
+    items.push({ label: "", separator: true });
+  }
+
+  // 4. Copy submenu
+  if (!contextHeaderColumn.value) {
+    items.push(copySubmenu());
+  }
+
+  if (props.editable && hasCellSelection.value) {
+    items.push({
+      label: t("grid.bulkEditSelection"),
+      action: openBulkEditDialog,
+      disabled: !selectionHasEditableCells(),
+      icon: Pencil,
+    });
+  }
+
+  // 5. Transpose
+  if (contextCell.value) {
+    items.push({ label: t("grid.transpose"), action: openContextTranspose, icon: Rows3 });
+  }
+
+  // 6. Selection submenu
+  if (hasCellSelection.value) {
+    items.push(selectionSubmenu());
+  }
+
+  // 7. Row actions
+  if (props.editable && contextRowItem.value) {
+    const labels = rowActionLabels();
+    items.push({ label: "", separator: true });
+    if (canInsertRows.value && !contextRowItem.value.isDraft) {
+      items.push({
+        label: labels.clone,
+        action: () => (isMultiRow.value ? cloneRows(affectedRowIds()) : cloneRow(contextRowItem.value!.id)),
+        icon: CopyPlus,
+      });
+    }
+    if (contextRowItem.value.isDeleted) {
+      items.push({
+        label: labels.restore,
+        action: () => (isMultiRow.value ? restoreRows(affectedRowIds()) : restoreRow(contextRowItem.value!.id)),
+        icon: Undo2,
+      });
+    } else if (canDeleteRowItem(contextRowItem.value)) {
+      items.push({
+        label: labels.delete,
+        action: () => (isMultiRow.value ? requestDeleteRows(deletableRowIds(affectedRowIds())) : requestDeleteRow(contextRowItem.value!.id)),
+        icon: Trash2,
+        variant: "destructive" as const,
+      });
+    }
+    items.push({ label: "", separator: true });
+  }
+
+  // 8. Export submenu
+  items.push(exportSubmenu());
+
+  // 9. Preview actions from registry (e.g. geometry map preview)
+  if (!contextHeaderColumn.value && contextCell.value) {
+    const colType = props.result.column_types?.[contextCell.value.col];
+    if (colType && isGeometryColumnType(colType)) {
+      const actions = previewActions.value;
+      if (actions.length > 0) {
+        items.push({ label: "", separator: true });
+        for (const action of actions) {
+          items.push({
+            label: t("grid.layerPreview"),
+            action: () => executePreviewAction(action),
+            icon: action.icon,
+          });
+        }
+      }
+    }
+  }
+
+  return items;
+});
+</script>
+
+<template>
+  <div ref="gridRef" data-grid-root class="h-full flex flex-col overflow-hidden outline-none" :class="{ 'data-grid--editing-cell': !!editingCell, 'data-grid--dark': isDark }" :style="gridStyle" tabindex="0" @keydown="onGridKeydown" @paste="onGridPaste">
+    <CustomContextMenu :items="gridContextMenuItems" v-slot="{ onContextMenu }">
+      <div v-if="hasData || canShowWhereSearch" class="flex-1 flex flex-col overflow-hidden" @contextmenu="onContextMenu">
+        <!-- Search bar -->
+        <div ref="dataGridTopbarRef" v-if="showDataGridTopbar" class="data-grid-topbar-shell shrink-0 flex min-w-0 border-b bg-muted/20">
+          <div v-if="hasResultToolbarLeadingSlot" class="flex shrink-0 items-center border-r">
+            <slot name="result-toolbar-leading" :compact="compactDataGridToolbar" />
+          </div>
+          <div
+            class="data-grid-topbar-scroll min-w-0 flex-1 overflow-x-hidden"
+            @scroll="
+              updateWhereSuggestionPosition();
+              updateOrderBySuggestionPosition();
+            "
+          >
+            <div class="data-grid-topbar flex items-stretch relative" :class="{ 'data-grid-topbar--compact': compactDataGridToolbar }">
+              <div v-if="useTransaction && editable && hasDataGridSaveTarget" class="flex items-center px-2 py-0.5 border-r shrink-0">
+                <Select :model-value="rowStatusFilter" @update:model-value="(value: any) => setRowStatusFilter(String(value))">
+                  <SelectTrigger class="h-5 max-w-28 border-0 bg-transparent px-0 py-0 text-xs font-medium text-foreground/70 shadow-none focus-visible:ring-0 data-[state=open]:text-foreground [&_svg]:size-3">
+                    <SelectValue :placeholder="t('grid.filterRows')" />
+                  </SelectTrigger>
+                  <SelectContent position="popper">
+                    <SelectItem value="all">{{ t("grid.filterAllRows") }}</SelectItem>
+                    <SelectItem value="changed">{{ t("grid.filterChangedRows") }}</SelectItem>
+                    <SelectItem value="edited">{{ t("grid.statusEdited") }}</SelectItem>
+                    <SelectItem value="new">{{ t("grid.statusNew") }}</SelectItem>
+                    <SelectItem value="deleted">{{ t("grid.statusDeleted") }}</SelectItem>
+                  </SelectContent>
+                </Select>
+              </div>
+              <template v-if="hasLocalColumnFilters && !canShowWhereSearch && !hasSearchBarSlot">
+                <div class="flex items-center gap-1 px-2 py-0.5 min-w-0">
+                  <button type="button" class="flex shrink-0 items-center gap-1 rounded border border-primary/30 bg-primary/10 px-1.5 py-0.5 text-[11px] font-medium text-primary hover:bg-primary/15" :title="t('grid.clearLocalFilters')" @click="clearLocalFilter()">
+                    <Filter class="h-3 w-3" />
+                    {{ localFilterCount }}
+                    <X class="h-3 w-3" />
+                  </button>
+                </div>
+              </template>
+              <template v-if="canShowWhereSearch">
+                <div ref="searchSplitContainerRef" class="flex flex-1 min-w-0">
+                  <div ref="whereConditionPaneRef" class="flex flex-1 items-center gap-1 px-2 py-0.5 min-w-0 relative" :class="{ 'border-l': useTransaction && editable && hasDataGridSaveTarget }" :style="whereSearchPaneStyle">
+                    <Popover v-model:open="filterBuilderOpen">
+                      <PopoverTrigger as-child>
+                        <button
+                          type="button"
+                          class="relative flex h-5 w-5 shrink-0 items-center justify-center rounded border text-[11px] font-medium transition-colors"
+                          :class="filterButtonActive ? 'border-primary/40 bg-primary/10 text-primary hover:bg-primary/15' : 'border-border/70 text-muted-foreground hover:bg-accent hover:text-foreground'"
+                          :disabled="!canUseWhereSearch"
+                          @click="ensureStructuredFilterRule"
+                        >
+                          <Filter class="h-3 w-3" />
+                          <span v-if="filterButtonCount" class="absolute -right-1 -top-1 flex h-3.5 min-w-3.5 items-center justify-center rounded-full bg-primary px-1 text-[9px] leading-none text-primary-foreground">
+                            {{ filterButtonCount }}
+                          </span>
+                        </button>
+                      </PopoverTrigger>
+                      <PopoverContent align="start" class="w-[380px] max-w-[calc(100vw-24px)] gap-3 p-3">
+                        <div class="flex items-center justify-between gap-3">
+                          <div class="text-xs font-medium text-foreground">{{ t("grid.filter") }}</div>
+                          <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" @click="addStructuredFilterRule">
+                            <Plus class="mr-1 h-3.5 w-3.5" />
+                            {{ t("grid.filterBuilderAddRule") }}
+                          </Button>
+                        </div>
+
+                        <div v-if="hasLocalColumnFilters" class="space-y-2 rounded-md border border-primary/20 bg-primary/5 px-2.5 py-2">
+                          <div class="flex items-center justify-between gap-3">
+                            <div class="flex min-w-0 items-center gap-2 text-xs font-medium text-primary">
+                              <Filter class="h-3.5 w-3.5 shrink-0" />
+                              <span class="truncate">{{ t("grid.localFiltersActive", { count: localFilterCount }) }}</span>
+                            </div>
+                            <Button variant="ghost" size="sm" class="h-7 shrink-0 px-2 text-xs" @click="clearLocalFilter()">
+                              <X class="mr-1 h-3.5 w-3.5" />
+                              {{ t("grid.clearLocalFiltersShort") }}
+                            </Button>
+                          </div>
+                          <div class="space-y-1">
+                            <div v-for="summary in localFilterSummaries" :key="summary.columnIndex" class="grid grid-cols-[minmax(0,0.9fr)_minmax(0,1.6fr)_auto] items-center gap-2 rounded border border-primary/10 bg-background/70 px-2 py-1 text-xs">
+                              <span class="truncate font-medium text-foreground" :title="summary.columnName">
+                                {{ summary.columnName }}
+                              </span>
+                              <span class="min-w-0 truncate font-mono text-muted-foreground">
+                                <template v-for="(value, valueIndex) in summary.values" :key="valueIndex">
+                                  <span v-if="valueIndex > 0">, </span>
+                                  <span>{{ value }}</span>
+                                </template>
+                                <span v-if="summary.hiddenValueCount">
+                                  {{ t("grid.localFilterMoreValues", { count: summary.hiddenValueCount }) }}
+                                </span>
+                              </span>
+                              <Button variant="ghost" size="icon" class="h-6 w-6 text-muted-foreground hover:text-destructive" :title="t('grid.clearFilter')" @click="clearLocalFilter(summary.columnIndex)">
+                                <X class="h-3.5 w-3.5" />
+                              </Button>
+                            </div>
+                          </div>
+                        </div>
+
+                        <div v-if="structuredFilterRules.length" class="space-y-2">
+                          <template v-for="(rule, index) in structuredFilterRules" :key="rule.id">
+                            <div v-if="index > 0" class="flex justify-center">
+                              <Button
+                                variant="ghost"
+                                size="sm"
+                                class="h-6 px-2 text-[11px] font-medium text-muted-foreground hover:text-foreground"
+                                @click="
+                                  updateStructuredFilterRule(rule.id, {
+                                    conjunction: rule.conjunction === 'AND' ? 'OR' : 'AND',
+                                  })
+                                "
+                              >
+                                {{ rule.conjunction }}
+                              </Button>
+                            </div>
+                            <div class="grid grid-cols-[minmax(0,1.2fr)_minmax(0,1fr)_minmax(0,1.2fr)_auto] items-center gap-2">
+                              <Select :model-value="rule.columnName" :disabled="rule.disabled" :class="rule.disabled ? 'opacity-45' : ''" @update:model-value="(value: any) => updateStructuredFilterRuleColumn(rule.id, String(value))">
+                                <SelectTrigger class="h-8 w-full min-w-0 overflow-hidden text-xs [&_[data-slot=select-value]]:min-w-0 [&_[data-slot=select-value]]:truncate">
+                                  <SelectValue :placeholder="t('grid.filterBuilderColumn')" />
+                                </SelectTrigger>
+                                <SelectContent position="popper" class="max-h-72" :hide-scroll-buttons="true">
+                                  <SelectItem v-for="columnName in filteredFilterBuilderColumnOptions" :key="columnName" :value="columnName">
+                                    {{ columnName }}
+                                  </SelectItem>
+                                  <div v-if="filteredFilterBuilderColumnOptions.length === 0" class="px-2 py-2 text-xs text-muted-foreground">
+                                    {{ t("grid.filterBuilderNoMatchingColumns") }}
+                                  </div>
+                                  <div class="sticky bottom-0 mt-1 flex items-center gap-1.5 border-t bg-popover px-2 py-1.5">
+                                    <Search class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                                    <input
+                                      v-model="filterBuilderColumnSearch"
+                                      autocapitalize="off"
+                                      autocomplete="off"
+                                      autocorrect="off"
+                                      spellcheck="false"
+                                      class="h-7 min-w-0 flex-1 bg-transparent text-xs outline-none placeholder:text-muted-foreground"
+                                      :placeholder="t('grid.filterBuilderSearchColumns')"
+                                      @click.stop
+                                      @keydown="handleFilterBuilderColumnSearchKeydown"
+                                      @pointerdown.stop
+                                    />
+                                  </div>
+                                </SelectContent>
+                              </Select>
+
+                              <Select :model-value="rule.mode" :disabled="rule.disabled" :class="rule.disabled ? 'opacity-45' : ''" @update:model-value="(value: any) => updateStructuredFilterRule(rule.id, { mode: value as FilterMode })">
+                                <SelectTrigger class="h-8 w-full min-w-0 overflow-hidden text-xs [&_[data-slot=select-value]]:min-w-0 [&_[data-slot=select-value]]:truncate">
+                                  <SelectValue />
+                                </SelectTrigger>
+                                <SelectContent position="popper">
+                                  <SelectItem v-for="option in filterModeOptions" :key="option.value" :value="option.value">
+                                    {{ t(option.labelKey) }}
+                                  </SelectItem>
+                                </SelectContent>
+                              </Select>
+
+                              <Input
+                                v-if="filterModeNeedsValue(rule.mode)"
+                                :model-value="rule.rawValue"
+                                class="h-8 min-w-0 text-xs"
+                                :class="rule.disabled ? 'opacity-45' : ''"
+                                :disabled="rule.disabled"
+                                :placeholder="t('grid.filterBuilderValue')"
+                                @update:model-value="(value) => updateStructuredFilterRule(rule.id, { rawValue: String(value ?? '') })"
+                                @keydown.enter.prevent="applyStructuredFilters"
+                              />
+                              <div v-else class="flex h-8 min-w-0 items-center overflow-hidden rounded-md border border-dashed px-2 text-xs text-muted-foreground" :class="rule.disabled ? 'opacity-45' : ''">
+                                <span class="truncate">{{ t("grid.filterBuilderNoValue") }}</span>
+                              </div>
+
+                              <div class="flex items-center gap-1">
+                                <Button variant="ghost" size="icon" class="h-8 w-8 shrink-0 text-muted-foreground hover:text-foreground" @click="updateStructuredFilterRule(rule.id, { disabled: !rule.disabled })">
+                                  <EyeOff v-if="rule.disabled" class="h-3.5 w-3.5" />
+                                  <Eye v-else class="h-3.5 w-3.5" />
+                                </Button>
+                                <Button variant="ghost" size="icon" class="h-8 w-8 shrink-0 text-muted-foreground hover:text-destructive" :disabled="structuredFilterRules.length === 1" @click="removeStructuredFilterRule(rule.id)">
+                                  <Trash2 class="h-3.5 w-3.5" />
+                                </Button>
+                              </div>
+                            </div>
+                          </template>
+                        </div>
+
+                        <div v-else class="rounded-md border border-dashed px-3 py-4 text-center text-xs text-muted-foreground">
+                          {{ t("grid.filterBuilderEmpty") }}
+                        </div>
+
+                        <div class="flex items-center justify-between gap-2 pt-1">
+                          <Button variant="ghost" size="sm" class="h-8 px-2 text-xs" @click="clearAllFilters">
+                            {{ t("grid.clearFilter") }}
+                          </Button>
+                          <div class="flex items-center gap-2">
+                            <Button variant="ghost" size="sm" class="h-8 px-2 text-xs" @click="resetStructuredFilters">
+                              {{ t("grid.resetFilterBuilder") }}
+                            </Button>
+                            <Button size="sm" class="h-8 px-3 text-xs" @click="applyStructuredFilters">
+                              {{ t("grid.applyFilter") }}
+                            </Button>
+                          </div>
+                        </div>
+                      </PopoverContent>
+                    </Popover>
+                    <div ref="whereConditionControlRef" class="flex min-w-0 flex-1 items-center gap-1">
+                      <span class="data-grid-topbar-condition-label data-grid-topbar-condition-label--where" :class="{ 'data-grid-topbar-condition-label--compact': compactDataGridToolbar }">WHERE</span>
+                      <div class="relative h-6 min-w-0 flex-1 overflow-hidden">
+                        <textarea
+                          ref="whereFilterInputRef"
+                          v-model="whereFilterInput"
+                          wrap="off"
+                          rows="1"
+                          autocapitalize="off"
+                          autocorrect="off"
+                          spellcheck="false"
+                          class="data-grid-topbar-condition-input data-grid-topbar-condition-input--where absolute inset-x-0 top-0 h-6 min-w-0 resize-none bg-transparent outline-none"
+                          :class="{ 'data-grid-topbar-condition-input--compact': compactDataGridToolbar }"
+                          style="height: 24px"
+                          placeholder="WHERE"
+                          @input="onWhereFilterInput"
+                          @keydown="onWhereFilterKeydown"
+                          @focus="resizeConditionInput('where')"
+                          @click="onConditionInputClick('where')"
+                          @wheel="onConditionInputWheel"
+                          @blur="
+                            dismissWhereSuggestions();
+                            collapseConditionInputAfterBlur('where');
+                          "
+                        />
+                      </div>
+                      <button class="text-muted-foreground hover:text-foreground shrink-0" type="button" @mousedown.prevent="openWhereHistoryMenu">
+                        <ChevronDown class="w-3 h-3" />
+                      </button>
+                      <button v-if="hasWhereFilterInput" class="text-muted-foreground hover:text-foreground shrink-0" @click="clearWhereFilterInput">
+                        <X class="w-3 h-3" />
+                      </button>
+                    </div>
+                    <Teleport to="body">
+                      <div v-if="whereConditionRendered" class="data-grid-topbar-condition-pane--expanded flex min-w-0 items-start gap-1" :class="{ 'border-l': useTransaction && editable && hasDataGridSaveTarget }" :style="conditionPaneStyle('where')">
+                        <textarea
+                          ref="whereFilterOverlayRef"
+                          v-model="whereFilterInput"
+                          wrap="soft"
+                          rows="1"
+                          autocapitalize="off"
+                          autocorrect="off"
+                          spellcheck="false"
+                          class="data-grid-topbar-condition-input data-grid-topbar-condition-input--where data-grid-topbar-condition-input--expanded absolute resize-none outline-none"
+                          :class="{ 'data-grid-topbar-condition-input--compact': compactDataGridToolbar }"
+                          placeholder="WHERE"
+                          @input="onWhereFilterInput"
+                          @keydown="onWhereFilterKeydown"
+                          @focus="resizeConditionInput('where')"
+                          @click="onConditionOverlayClick('where')"
+                          @scroll="onConditionOverlayScroll('where', $event)"
+                          @blur="
+                            dismissWhereSuggestions();
+                            collapseConditionInputAfterBlur('where');
+                          "
+                        />
+                        <div class="data-grid-topbar-condition-floating-controls pointer-events-none absolute inset-x-2 z-[1] flex h-6 min-w-0 items-center gap-1" :style="conditionTopbarOverlayStyle('where')">
+                          <button
+                            type="button"
+                            class="data-grid-topbar-condition-icon-control pointer-events-auto relative flex h-5 w-5 shrink-0 items-center justify-center rounded border text-[11px] font-medium transition-colors"
+                            :class="filterButtonActive ? 'border-primary/40 bg-primary/10 text-primary hover:bg-primary/15' : 'border-border/70 text-muted-foreground hover:bg-accent hover:text-foreground'"
+                            :disabled="!canUseWhereSearch"
+                            @mousedown.prevent
+                            @click="openStructuredFilterFromExpandedWhere"
+                          >
+                            <Filter class="h-3 w-3" />
+                            <span v-if="filterButtonCount" class="absolute -right-1 -top-1 flex h-3.5 min-w-3.5 items-center justify-center rounded-full bg-primary px-1 text-[9px] leading-none text-primary-foreground">
+                              {{ filterButtonCount }}
+                            </span>
+                          </button>
+                          <span class="data-grid-topbar-condition-label data-grid-topbar-condition-label--where" :class="{ 'data-grid-topbar-condition-label--compact': compactDataGridToolbar }">WHERE</span>
+                          <div class="min-w-0 flex-1" />
+                          <button class="data-grid-topbar-condition-icon-control pointer-events-auto text-muted-foreground hover:text-foreground shrink-0" type="button" @mousedown.prevent="openWhereHistoryMenu">
+                            <ChevronDown class="w-3 h-3" />
+                          </button>
+                          <button v-if="hasWhereFilterInput" class="data-grid-topbar-condition-icon-control pointer-events-auto text-muted-foreground hover:text-foreground shrink-0" @click="clearWhereFilterInput">
+                            <X class="w-3 h-3" />
+                          </button>
+                        </div>
+                      </div>
+                    </Teleport>
+                    <!-- WHERE suggestion dropdown -->
+                    <Teleport to="body">
+                      <div v-if="showWhereSuggestionDropdown" ref="whereSuggestionDropdownRef" class="fixed z-[90] min-w-[180px] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md" :style="whereSuggestionStyle">
+                        <div
+                          v-for="(sug, idx) in whereSuggestions"
+                          :key="`${sug.kind}:${sug.value}`"
+                          class="flex min-w-0 items-center gap-2 px-3 py-1.5 text-xs cursor-pointer"
+                          :class="idx === whereSuggestionIndex ? 'bg-accent text-accent-foreground' : 'hover:bg-gray-200 dark:hover:bg-gray-800'"
+                          @mousedown.prevent="
+                            whereSuggestionIndex = idx;
+                            acceptWhereSuggestion();
+                          "
+                          @mouseenter="
+                            whereSuggestionIndex = idx;
+                            sug.kind === 'history' ? showConditionHistoryPreview(sug.value, $event) : hideConditionHistoryPreview();
+                          "
+                          @mouseleave="hideConditionHistoryPreview"
+                        >
+                          <Search class="w-3 h-3 mr-2 text-muted-foreground shrink-0" />
+                          <span data-condition-history-text class="min-w-0 flex-1 truncate font-mono">{{ sug.value }}</span>
+                          <button v-if="sug.kind === 'history'" class="shrink-0 rounded p-0.5 text-muted-foreground hover:bg-destructive/10 hover:text-destructive" type="button" @mousedown.stop.prevent="deleteWhereHistorySuggestion(sug.value)">
+                            <X class="h-3 w-3" />
+                          </button>
+                        </div>
+                        <div v-if="whereSuggestions.length === 0" class="px-3 py-2 text-xs text-muted-foreground">
+                          {{ whereHistoryEmptyText }}
+                        </div>
+                      </div>
+                    </Teleport>
+                  </div>
+                  <button
+                    type="button"
+                    class="group relative flex w-2 shrink-0 cursor-col-resize items-center justify-center border-l border-r border-border/80 bg-muted/15 hover:bg-primary/10 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-primary"
+                    aria-label="Resize WHERE and ORDER BY"
+                    @mousedown="onSearchSplitResizeStart"
+                    @dblclick.stop="resetSearchSplitWidth"
+                  >
+                    <span class="h-5 w-px bg-border group-hover:bg-primary/60" />
+                  </button>
+                  <div ref="orderByConditionPaneRef" class="flex flex-1 items-center gap-1 px-2 py-0.5 border-r min-w-0 relative">
+                    <div ref="orderByConditionControlRef" class="flex min-w-0 flex-1 items-center gap-1">
+                      <span class="data-grid-topbar-condition-label data-grid-topbar-condition-label--order" :class="{ 'data-grid-topbar-condition-label--compact': compactDataGridToolbar }">ORDER BY</span>
+                      <div class="relative h-6 min-w-0 flex-1 overflow-hidden">
+                        <textarea
+                          ref="orderByInputRef"
+                          v-model="orderByInput"
+                          wrap="off"
+                          rows="1"
+                          autocapitalize="off"
+                          autocorrect="off"
+                          spellcheck="false"
+                          class="data-grid-topbar-condition-input data-grid-topbar-condition-input--order absolute inset-x-0 top-0 h-6 min-w-0 resize-none bg-transparent outline-none"
+                          :class="{ 'data-grid-topbar-condition-input--compact': compactDataGridToolbar }"
+                          style="height: 24px"
+                          placeholder="ORDER BY"
+                          @input="onOrderByInput"
+                          @keydown="onOrderByKeydown"
+                          @focus="resizeConditionInput('orderBy')"
+                          @click="onConditionInputClick('orderBy')"
+                          @wheel="onConditionInputWheel"
+                          @blur="
+                            dismissOrderBySuggestions();
+                            collapseConditionInputAfterBlur('orderBy');
+                          "
+                        />
+                      </div>
+                      <button class="text-muted-foreground hover:text-foreground shrink-0" type="button" @mousedown.prevent="openOrderByHistoryMenu">
+                        <ChevronDown class="w-3 h-3" />
+                      </button>
+                      <button v-if="hasOrderByInput" class="text-muted-foreground hover:text-foreground shrink-0" @click="clearOrderByInput">
+                        <X class="w-3 h-3" />
+                      </button>
+                    </div>
+                    <Teleport to="body">
+                      <div v-if="orderByConditionRendered" class="data-grid-topbar-condition-pane--expanded flex min-w-0 items-start gap-1 border-r" :style="conditionPaneStyle('orderBy')">
+                        <textarea
+                          ref="orderByOverlayRef"
+                          v-model="orderByInput"
+                          wrap="soft"
+                          rows="1"
+                          autocapitalize="off"
+                          autocorrect="off"
+                          spellcheck="false"
+                          class="data-grid-topbar-condition-input data-grid-topbar-condition-input--order data-grid-topbar-condition-input--expanded absolute resize-none outline-none"
+                          :class="{ 'data-grid-topbar-condition-input--compact': compactDataGridToolbar }"
+                          placeholder="ORDER BY"
+                          @input="onOrderByInput"
+                          @keydown="onOrderByKeydown"
+                          @focus="resizeConditionInput('orderBy')"
+                          @click="onConditionOverlayClick('orderBy')"
+                          @scroll="onConditionOverlayScroll('orderBy', $event)"
+                          @blur="
+                            dismissOrderBySuggestions();
+                            collapseConditionInputAfterBlur('orderBy');
+                          "
+                        />
+                        <div class="data-grid-topbar-condition-floating-controls pointer-events-none absolute inset-x-2 z-[1] flex h-6 min-w-0 items-center gap-1" :style="conditionTopbarOverlayStyle('orderBy')">
+                          <span class="data-grid-topbar-condition-label data-grid-topbar-condition-label--order" :class="{ 'data-grid-topbar-condition-label--compact': compactDataGridToolbar }">ORDER BY</span>
+                          <div class="min-w-0 flex-1" />
+                          <button class="data-grid-topbar-condition-icon-control pointer-events-auto text-muted-foreground hover:text-foreground shrink-0" type="button" @mousedown.prevent="openOrderByHistoryMenu">
+                            <ChevronDown class="w-3 h-3" />
+                          </button>
+                          <button v-if="hasOrderByInput" class="data-grid-topbar-condition-icon-control pointer-events-auto text-muted-foreground hover:text-foreground shrink-0" @click="clearOrderByInput">
+                            <X class="w-3 h-3" />
+                          </button>
+                        </div>
+                      </div>
+                    </Teleport>
+                    <!-- ORDER BY suggestion dropdown -->
+                    <Teleport to="body">
+                      <div v-if="showOrderBySuggestionDropdown" ref="orderBySuggestionDropdownRef" class="fixed z-[90] min-w-[180px] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md" :style="orderBySuggestionStyle">
+                        <div
+                          v-for="(sug, idx) in orderBySuggestions"
+                          :key="`${sug.kind}:${sug.value}`"
+                          class="flex min-w-0 items-center gap-2 px-3 py-1.5 text-xs cursor-pointer"
+                          :class="idx === orderBySuggestionIndex ? 'bg-accent text-accent-foreground' : 'hover:bg-gray-200 dark:hover:bg-gray-800'"
+                          @mousedown.prevent="
+                            orderBySuggestionIndex = idx;
+                            acceptOrderBySuggestion();
+                          "
+                          @mouseenter="
+                            orderBySuggestionIndex = idx;
+                            sug.kind === 'history' ? showConditionHistoryPreview(sug.value, $event) : hideConditionHistoryPreview();
+                          "
+                          @mouseleave="hideConditionHistoryPreview"
+                        >
+                          <Search class="w-3 h-3 mr-2 text-muted-foreground shrink-0" />
+                          <span data-condition-history-text class="min-w-0 flex-1 truncate font-mono">{{ sug.value }}</span>
+                          <button v-if="sug.kind === 'history'" class="shrink-0 rounded p-0.5 text-muted-foreground hover:bg-destructive/10 hover:text-destructive" type="button" @mousedown.stop.prevent="deleteOrderByHistorySuggestion(sug.value)">
+                            <X class="h-3 w-3" />
+                          </button>
+                        </div>
+                        <div v-if="orderBySuggestions.length === 0" class="px-3 py-2 text-xs text-muted-foreground">
+                          {{ orderByHistoryEmptyText }}
+                        </div>
+                      </div>
+                    </Teleport>
+                    <Teleport to="body">
+                      <div v-if="conditionHistoryPreview" class="pointer-events-none fixed z-[140] rounded-md bg-foreground shadow-xl" :style="conditionHistoryPreviewStyle">
+                        <span class="absolute h-3 w-3 rotate-45 bg-foreground" :class="conditionHistoryPreview.side === 'left' ? '-left-1.5' : '-right-1.5'" :style="conditionHistoryPreviewArrowStyle" />
+                        <div class="max-h-[min(320px,calc(100vh-16px))] overflow-auto rounded-md px-3 py-2 font-mono text-xs leading-relaxed whitespace-pre-wrap break-words text-background">
+                          {{ conditionHistoryPreview.value }}
+                        </div>
+                      </div>
+                    </Teleport>
+                  </div>
+                </div>
+              </template>
+
+              <slot name="search-bar" :local-filter-count="localFilterCount" :has-local-column-filters="hasLocalColumnFilters" :local-filter-summaries="localFilterSummaries" :clear-local-filter="clearLocalFilter" />
+            </div>
+          </div>
+
+          <div class="flex shrink-0 items-center gap-1 px-1 ml-auto" @wheel="onDataGridTopbarFixedActionWheel">
+            <slot v-if="hasResultToolbarActionsSlot" name="result-toolbar-actions" :compact="compactDataGridToolbar" />
+            <Tooltip v-if="showQueryEditReadOnlyBadge">
+              <TooltipTrigger as-child>
+                <div class="flex h-5 items-center gap-1 rounded border border-muted-foreground/30 bg-muted/60 px-1.5 text-xs font-medium text-muted-foreground">
+                  {{ t("grid.queryEditReadOnly") }}
+                </div>
+              </TooltipTrigger>
+              <TooltipContent side="bottom" class="max-w-sm">
+                {{ queryEditReadOnlyReason }}
+              </TooltipContent>
+            </Tooltip>
+            <Tooltip v-if="showKeylessEditWarning">
+              <TooltipTrigger as-child>
+                <div class="flex h-5 items-center gap-1 rounded border border-amber-500/30 bg-amber-500/10 px-1.5 text-xs font-medium text-amber-700 dark:text-amber-300">
+                  <KeyRound class="h-3 w-3" />
+                  {{ t("grid.keylessEditWarning") }}
+                </div>
+              </TooltipTrigger>
+              <TooltipContent side="bottom" class="max-w-sm">
+                {{ t("grid.keylessEditWarningHint") }}
+              </TooltipContent>
+            </Tooltip>
+            <Tooltip v-if="canShowMongoJsonPreview">
+              <TooltipTrigger as-child>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  :class="['data-grid-topbar-action-button h-5 shrink-0 text-xs px-1.5', compactDataGridToolbar ? 'data-grid-topbar-action-button--compact' : '', mongoJsonPreviewOpen ? 'text-primary bg-primary/10 hover:bg-primary/15' : '']"
+                  :aria-pressed="mongoJsonPreviewOpen"
+                  @click="toggleMongoJsonPreview"
+                >
+                  <Code2 class="data-grid-topbar-action-icon w-3 h-3" />
+                  <span class="data-grid-topbar-action-label" :class="{ 'data-grid-topbar-action-label--compact': compactDataGridToolbar }">{{ t("grid.mongoJsonPreview") }}</span>
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent side="bottom">{{ t("grid.mongoJsonPreview") }}</TooltipContent>
+            </Tooltip>
+            <Tooltip>
+              <TooltipTrigger as-child>
+                <Button variant="ghost" size="sm" :class="['data-grid-topbar-action-button h-5 shrink-0 text-xs px-1.5', compactDataGridToolbar ? 'data-grid-topbar-action-button--compact' : '', isSaving ? '' : '']" :disabled="isSaving" @click="onToolbarRefresh">
+                  <Loader2 v-if="loading" class="data-grid-topbar-action-icon w-3 h-3 animate-spin" />
+                  <RefreshCcw v-else class="data-grid-topbar-action-icon w-3 h-3" />
+                  <span class="data-grid-topbar-action-label" :class="{ 'data-grid-topbar-action-label--compact': compactDataGridToolbar }">{{ t("grid.refresh") }}</span>
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent side="bottom">{{ t("grid.refresh") }} ({{ shortcutMod }}+R)</TooltipContent>
+            </Tooltip>
+            <DropdownMenu>
+              <DropdownMenuTrigger as-child>
+                <Button
+                  variant="ghost"
+                  size="sm"
+                  :class="['data-grid-topbar-action-button h-5 shrink-0 text-xs px-1.5', compactDataGridToolbar ? 'data-grid-topbar-action-button--compact' : '', autoRefreshEnabled ? 'text-primary bg-primary/10 hover:bg-primary/15' : 'text-muted-foreground hover:text-foreground']"
+                  :title="autoRefreshLabel"
+                  :aria-label="autoRefreshLabel"
+                  :aria-pressed="autoRefreshEnabled"
+                >
+                  <Timer class="data-grid-topbar-action-icon w-3 h-3" />
+                  <span class="data-grid-topbar-action-label" :class="{ 'data-grid-topbar-action-label--compact': compactDataGridToolbar }">{{ autoRefreshEnabled ? `${autoRefreshIntervalSeconds}s` : t("tabs.autoRefreshShort") }}</span>
+                </Button>
+              </DropdownMenuTrigger>
+              <DropdownMenuContent align="end" class="w-40">
+                <DropdownMenuItem class="gap-2" @select="toggleAutoRefresh">
+                  <Check v-if="autoRefreshEnabled" class="h-3.5 w-3.5" />
+                  <span v-else class="h-3.5 w-3.5" />
+                  {{ autoRefreshEnabled ? t("tabs.stopAutoRefresh") : t("tabs.startAutoRefresh") }}
+                </DropdownMenuItem>
+                <DropdownMenuItem v-for="seconds in AUTO_REFRESH_INTERVAL_OPTIONS" :key="seconds" class="gap-2" @select="setAutoRefreshInterval(seconds)">
+                  <Check v-if="autoRefreshIntervalSeconds === seconds" class="h-3.5 w-3.5" />
+                  <span v-else class="h-3.5 w-3.5" />
+                  {{ t("tabs.autoRefreshEvery", { seconds }) }}
+                </DropdownMenuItem>
+              </DropdownMenuContent>
+            </DropdownMenu>
+            <Tooltip v-if="props.result.columns.length">
+              <TooltipTrigger as-child>
+                <Popover v-model:open="goToColumnOpen">
+                  <PopoverTrigger as-child>
+                    <Button variant="ghost" size="sm" :class="['data-grid-topbar-action-button h-5 shrink-0 text-xs px-1.5', compactDataGridToolbar ? 'data-grid-topbar-action-button--compact' : '', goToColumnOpen ? 'text-primary bg-primary/10' : '']">
+                      <Columns3 class="data-grid-topbar-action-icon w-3 h-3" />
+                      <span class="data-grid-topbar-action-label" :class="{ 'data-grid-topbar-action-label--compact': compactDataGridToolbar }">{{ t("grid.goToColumn") }}</span>
+                    </Button>
+                  </PopoverTrigger>
+                  <PopoverContent align="end" class="w-56 p-2" @keydown="onGoToColumnKeydown">
+                    <div class="relative mb-1">
+                      <Search class="pointer-events-none absolute left-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+                      <input v-model="goToColumnSearch" :placeholder="t('grid.searchColumn')" class="h-8 w-full rounded-md border bg-transparent pl-7 pr-6 text-xs outline-none focus-visible:border-ring/50 focus-visible:ring-1 focus-visible:ring-ring/25" />
+                      <button v-if="goToColumnSearch" type="button" class="absolute right-1.5 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground" @click="goToColumnSearch = ''">
+                        <X class="h-3.5 w-3.5" />
+                      </button>
+                    </div>
+                    <div class="max-h-56 overflow-auto rounded border">
+                      <button v-for="column in filteredGoToColumns" :key="column.index" type="button" class="grid w-full grid-cols-[minmax(0,1fr)_auto] items-center gap-x-2 gap-y-0.5 px-2 py-1.5 text-left text-xs hover:bg-accent hover:text-accent-foreground" @click="scrollToColumn(column.index)">
+                        <span class="min-w-0 truncate">{{ column.name }}</span>
+                        <span class="shrink-0 font-mono text-[10px] text-muted-foreground">#{{ column.index + 1 }}</span>
+                        <span v-if="column.comment" class="col-span-2 min-w-0 truncate text-[11px] leading-4 text-muted-foreground" :title="column.comment">{{ column.comment }}</span>
+                      </button>
+                      <div v-if="!filteredGoToColumns.length" class="px-2 py-3 text-center text-xs text-muted-foreground">{{ t("grid.noColumnsFound") }}</div>
+                    </div>
+                  </PopoverContent>
+                </Popover>
+              </TooltipTrigger>
+              <TooltipContent side="bottom">{{ t("grid.goToColumn") }}</TooltipContent>
+            </Tooltip>
+            <Tooltip v-if="editable && hasDataGridInsertTarget && canInsertRows">
+              <TooltipTrigger as-child>
+                <Button variant="ghost" size="sm" :class="['data-grid-topbar-action-button h-5 shrink-0 text-xs px-1.5', compactDataGridToolbar ? 'data-grid-topbar-action-button--compact' : '']" @click="addRow">
+                  <Plus class="data-grid-topbar-action-icon w-3 h-3" />
+                  <span class="data-grid-topbar-action-label" :class="{ 'data-grid-topbar-action-label--compact': compactDataGridToolbar }">{{ t("grid.addRow") }}</span>
+                </Button>
+              </TooltipTrigger>
+              <TooltipContent side="bottom">{{ t("grid.addRow") }} ({{ shortcutMod }}+N)</TooltipContent>
+            </Tooltip>
+            <template v-if="saveToolbarState.showActions">
+              <Tooltip v-if="pendingChangeCount > 0">
+                <TooltipTrigger as-child>
+                  <Button
+                    variant="ghost"
+                    size="sm"
+                    :class="['data-grid-topbar-action-button h-5 shrink-0 text-xs px-1.5 text-sky-600 hover:bg-sky-500/10 hover:text-sky-700', compactDataGridToolbar ? 'data-grid-topbar-action-button--compact' : '']"
+                    :disabled="isPreviewLoading"
+                    @click="openSqlPreview"
+                  >
+                    <Loader2 v-if="isPreviewLoading" class="data-grid-topbar-action-icon w-3 h-3 animate-spin" />
+                    <Eye v-else class="data-grid-topbar-action-icon w-3 h-3" />
+                    <span class="data-grid-topbar-action-label" :class="{ 'data-grid-topbar-action-label--compact': compactDataGridToolbar }">{{ t("toolbar.previewSql") }}</span>
+                  </Button>
+                </TooltipTrigger>
+                <TooltipContent side="bottom" class="max-w-sm">
+                  {{ t("toolbar.previewSql") }}
+                </TooltipContent>
+              </Tooltip>
+              <Tooltip>
+                <TooltipTrigger as-child>
+                  <Button
+                    variant="default"
+                    size="sm"
+                    :class="['data-grid-topbar-action-button data-grid-topbar-action-button--commit relative h-5 shrink-0 text-xs px-1.5', compactDataGridToolbar ? 'data-grid-topbar-action-button--compact' : '']"
+                    :disabled="saveToolbarState.actionsDisabled"
+                    @click="onToolbarCommit"
+                  >
+                    <Loader2 v-if="isSaving" class="data-grid-topbar-action-icon w-3 h-3 animate-spin" />
+                    <Save v-else-if="compactDataGridToolbar || pendingChangeCount === 0" class="data-grid-topbar-action-icon w-3 h-3" />
+                    <span
+                      v-if="pendingChangeCount > 0"
+                      :class="
+                        compactDataGridToolbar
+                          ? 'absolute -right-1 -top-1 flex h-3.5 min-w-3.5 items-center justify-center rounded-full bg-amber-300 px-1 text-[9px] font-semibold leading-none text-amber-950 shadow-[0_0_0_1px_rgba(120,53,15,0.16)] dark:bg-amber-400 dark:text-amber-950'
+                          : 'mr-1 flex h-3.5 min-w-3.5 items-center justify-center rounded-full bg-amber-300 px-1 text-[9px] font-semibold leading-none text-amber-950 shadow-[0_0_0_1px_rgba(120,53,15,0.16)] dark:bg-amber-400 dark:text-amber-950'
+                      "
+                    >
+                      {{ pendingChangeCount }}
+                    </span>
+                    <span class="data-grid-topbar-action-label" :class="{ 'data-grid-topbar-action-label--compact': compactDataGridToolbar }">{{ t(saveActionMode.labelKey, { count: pendingChangeCount }) }}</span>
+                  </Button>
+                </TooltipTrigger>
+                <TooltipContent side="bottom" class="max-w-sm"> {{ t(saveActionMode.tooltipKey, { count: pendingChangeCount }) }} ({{ saveShortcutLabel }}) </TooltipContent>
+              </Tooltip>
+              <Tooltip>
+                <TooltipTrigger as-child>
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    :class="['data-grid-topbar-action-button h-5 shrink-0 text-xs px-1.5', compactDataGridToolbar ? 'data-grid-topbar-action-button--compact' : '']"
+                    :disabled="saveToolbarState.actionsDisabled"
+                    @click="useTransaction ? onToolbarRollback() : discardChanges()"
+                  >
+                    <RotateCcw class="data-grid-topbar-action-icon w-3 h-3" />
+                    <span class="data-grid-topbar-action-label" :class="{ 'data-grid-topbar-action-label--compact': compactDataGridToolbar }">{{ t(saveActionMode.secondaryActionKey) }}</span>
+                  </Button>
+                </TooltipTrigger>
+                <TooltipContent side="bottom">{{ t(saveActionMode.secondaryActionKey) }}</TooltipContent>
+              </Tooltip>
+            </template>
+          </div>
+        </div>
+        <!-- Truncation warning banner -->
+        <div v-if="showTruncationWarning" class="shrink-0 px-3 py-1 bg-amber-500/10 border-b border-amber-500/20 text-xs text-amber-600 dark:text-amber-400 flex items-center gap-1.5">
+          <span>{{ t("grid.truncatedHint", { count: pageSize }) }}</span>
+        </div>
+        <!-- Content area: table + side/bottom detail panes -->
+        <div class="flex-1 grid min-h-0 overflow-hidden" :style="contentGridStyle">
+          <div class="col-start-1 row-start-1 flex flex-col min-w-0 overflow-hidden relative">
+            <!-- Search overlay (Ctrl+F) -->
+            <Transition enter-active-class="transition-opacity duration-150" leave-active-class="transition-opacity duration-100" enter-from-class="opacity-0" leave-to-class="opacity-0">
+              <div v-if="searchOverlayVisible" class="absolute top-1 right-2 z-20 flex items-center gap-1 px-2 py-1 bg-background border rounded-md shadow-md">
+                <Search class="w-3.5 h-3.5 text-muted-foreground shrink-0" />
+                <input
+                  ref="searchInputRef"
+                  v-model="searchText"
+                  autocapitalize="off"
+                  autocorrect="off"
+                  spellcheck="false"
+                  class="w-48 h-5 min-w-0 text-xs bg-transparent outline-none placeholder:text-muted-foreground"
+                  :placeholder="t('grid.search')"
+                  @keydown="onSearchKeydown"
+                  @click="updateSuggestionPosition"
+                />
+                <span ref="measureRef" class="invisible absolute left-0 top-0 text-xs whitespace-pre pointer-events-none" aria-hidden="true" />
+                <div v-if="searchSuggestions.length > 0" class="absolute top-full right-0 mt-0.5 z-50 min-w-[180px] rounded-md border bg-popover text-popover-foreground shadow-md">
+                  <div
+                    v-for="(sug, idx) in searchSuggestions"
+                    :key="sug"
+                    class="flex items-center px-3 py-1.5 text-xs cursor-pointer"
+                    :class="idx === suggestionIndex ? 'bg-accent text-accent-foreground' : 'hover:bg-gray-200 dark:hover:bg-gray-800'"
+                    @mousedown.prevent="
+                      suggestionIndex = idx;
+                      acceptSuggestion();
+                    "
+                    @mouseenter="suggestionIndex = idx"
+                  >
+                    <Search class="w-3 h-3 mr-2 text-muted-foreground shrink-0" />
+                    <span>{{ sug }}</span>
+                  </div>
+                </div>
+                <span v-if="searchMatches.length > 0" class="text-xs text-muted-foreground shrink-0"> {{ currentMatchIndex + 1 }}/{{ searchMatches.length }} </span>
+                <span v-else-if="deferredClientSearchText" class="text-xs text-muted-foreground shrink-0"> 0 </span>
+                <button class="text-muted-foreground hover:text-foreground shrink-0" @click="closeSearch">
+                  <X class="w-3.5 h-3.5" />
+                </button>
+              </div>
+            </Transition>
+            <ErrorBanner v-if="isErrorResult" variant="centered" :message="errorMessage">
+              <template #actions>
+                <slot name="error-actions" :error-message="errorMessage" />
+              </template>
+            </ErrorBanner>
+            <div v-else-if="isTransposeMode" class="flex-1 flex flex-col min-h-0 overflow-hidden">
+              <div class="h-8 flex items-center gap-2 px-3 border-y shrink-0 bg-muted/20">
+                <Rows3 class="w-3.5 h-3.5 text-muted-foreground" />
+                <span class="text-xs font-medium">{{ t("grid.transpose") }}</span>
+                <span class="text-xs text-muted-foreground"> {{ t("grid.rowNumber") }} {{ (transposeRowIndex ?? 0) + 1 }} </span>
+                <span class="rounded border border-border bg-background px-1.5 py-0.5 text-[10px] font-medium text-muted-foreground">
+                  {{ multiRowTranspose ? t("grid.transposeMultiRow") : t("grid.transposeSingleRow") }}
+                </span>
+                <span class="flex-1" />
+                <Button variant="ghost" size="icon" class="h-5 w-5" :disabled="transposeRowIndex === 0" @click="transposeNav(-1)">
+                  <ChevronLeft class="w-3 h-3" />
+                </Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5" :disabled="transposeRowIndex === displayItems.length - 1" @click="transposeNav(1)">
+                  <ChevronRight class="w-3 h-3" />
+                </Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5" @click="closeTranspose">
+                  <X class="w-3 h-3" />
+                </Button>
+              </div>
+              <RecycleScroller
+                ref="transposeScrollRef"
+                class="transpose-grid-scroller flex-1 min-h-0 overflow-auto overscroll-none bg-background"
+                :class="{ 'is-scrolling': isScrolling }"
+                :style="{
+                  '--transpose-total-w': `${transposeTotalWidth}px`,
+                  '--transpose-field-w': `${transposePinnedWidth}px`,
+                }"
+                :items="transposeRows"
+                :item-size="30"
+                :buffer="400"
+                key-field="id"
+                @scroll="onTransposeScroll"
+              >
+                <template #before>
+                  <div class="data-grid-transpose-header data-grid-header-shell sticky top-0 z-20 flex h-7 border-b border-border font-semibold text-muted-foreground" :style="{ width: `${transposeTotalWidth}px` }">
+                    <div class="data-grid-header-cell sticky left-0 z-30 shrink-0 border-r border-border px-3 py-1.5 truncate relative" :style="{ width: `${transposePinnedWidth}px` }">
+                      {{ t("grid.columnName") }}
+                      <div class="absolute right-0 top-0 bottom-0 w-1.5 cursor-col-resize hover:bg-primary/30" @mousedown.stop="onTransposePinnedResizeStart" />
+                    </div>
+                    <div class="shrink-0" :style="{ width: `${transposeBeforeSpacerWidth}px` }" />
+                    <div
+                      v-for="recordIndex in activeTransposeRecordIndexes"
+                      :key="`transpose-head-${recordIndex}`"
+                      class="shrink-0 border-r border-border px-2 py-1.5 text-center tabular-nums relative"
+                      :class="{
+                        'transpose-record-header-selected text-primary font-semibold': transposeRecordUsesFramedHeader(recordIndex),
+                        'transpose-record-header-active text-primary': transposeRecordUsesActiveHighlight(recordIndex) && !transposeRecordUsesFramedHeader(recordIndex),
+                        'data-grid-header-cell': !transposeRecordUsesActiveHighlight(recordIndex) && !transposeRecordUsesFramedHeader(recordIndex),
+                      }"
+                      :style="{ width: `${getTransposeRecordWidth(recordIndex)}px` }"
+                      @click="selectTransposeRecord(recordIndex, $event)"
+                      @contextmenu="selectTransposeRecord(recordIndex, $event)"
+                    >
+                      {{ rowNumberText(displayItems[recordIndex]) }}
+                      <div class="absolute right-0 top-0 bottom-0 w-1.5 cursor-col-resize hover:bg-primary/30" @mousedown.stop="onTransposeRecordResizeStart(recordIndex, $event)" @dblclick.stop="autoFitTransposeRecord(recordIndex)" />
+                    </div>
+                    <div class="shrink-0" :style="{ width: `${transposeAfterSpacerWidth}px` }" />
+                  </div>
+                </template>
+                <template #default="{ item, index }">
+                  <div class="data-grid-transpose-row flex border-b border-border/60" :style="{ height: '30px', width: `${transposeTotalWidth}px` }">
+                    <div
+                      class="sticky left-0 z-10 flex shrink-0 items-center border-r border-border bg-background px-3 py-0 font-medium truncate"
+                      :class="{
+                        'bg-yellow-200/60 dark:bg-yellow-500/20': transposeHeaderIsSearchMatch(visibleColumnIndexes[index]),
+                        'ring-2 ring-inset ring-yellow-500 bg-yellow-300/60 dark:bg-yellow-500/40': transposeHeaderIsCurrentMatch(visibleColumnIndexes[index]),
+                      }"
+                      :style="{ width: `${transposePinnedWidth}px` }"
+                      :title="item.column"
+                    >
+                      {{ item.column }}
+                    </div>
+                    <div class="shrink-0" :style="{ width: `${transposeBeforeSpacerWidth}px` }" />
+                    <div
+                      v-for="cell in item.values"
+                      :key="`${item.id}:${cell.recordIndex}`"
+                      class="relative flex shrink-0 items-center border-r border-border/70 px-2 py-0 font-mono truncate"
+                      :class="{
+                        'text-muted-foreground italic': cell.isNull,
+                        'cell-selected': transposeCellIsSelected(cell.recordIndex, cell.valueIndex) && !displayItems[cell.recordIndex]?.isDirtyCol[cell.valueIndex],
+                        'cell-selected-dirty': transposeCellIsSelected(cell.recordIndex, cell.valueIndex) && displayItems[cell.recordIndex]?.isDirtyCol[cell.valueIndex],
+                        'row-cell-selected': transposeRecordUsesSelectionVisual(cell.recordIndex) && !transposeCellIsSelected(cell.recordIndex, cell.valueIndex) && !displayItems[cell.recordIndex]?.isDirtyCol[cell.valueIndex],
+                        'row-cell-selected-dirty': transposeRecordUsesSelectionVisual(cell.recordIndex) && !transposeCellIsSelected(cell.recordIndex, cell.valueIndex) && displayItems[cell.recordIndex]?.isDirtyCol[cell.valueIndex],
+                        'bg-primary/15': transposeRecordUsesActiveHighlight(cell.recordIndex) && !transposeRecordUsesSelectionVisual(cell.recordIndex) && !displayItems[cell.recordIndex]?.isDirtyCol[cell.valueIndex] && !transposeCellIsSelected(cell.recordIndex, cell.valueIndex),
+                        'bg-yellow-500/10 cell-dirty': displayItems[cell.recordIndex]?.isDirtyCol[cell.valueIndex],
+                        'bg-yellow-200/60 dark:bg-yellow-500/20': cellIsSearchMatch(cell.recordIndex, cell.valueIndex),
+                        'ring-2 ring-inset ring-yellow-500 bg-yellow-300/60 dark:bg-yellow-500/40': cellIsCurrentMatch(cell.recordIndex, cell.valueIndex),
+                        'cursor-text': !isScrolling && canEditCellItem(displayItems[cell.recordIndex], cell.valueIndex),
+                        'hover:bg-gray-200 dark:hover:bg-gray-800':
+                          !isScrolling && canEditCellItem(displayItems[cell.recordIndex], cell.valueIndex) && !transposeRecordUsesSelectionVisual(cell.recordIndex) && !transposeRecordUsesActiveHighlight(cell.recordIndex) && !transposeCellIsSelected(cell.recordIndex, cell.valueIndex),
+                      }"
+                      :style="{ width: `${getTransposeRecordWidth(cell.recordIndex)}px` }"
+                      :title="cell.display"
+                      @mousedown="prepareTransposeCellMouseDown(cell.recordIndex, cell.valueIndex)"
+                      @click="selectTransposeCell(cell.recordIndex, cell.valueIndex, $event)"
+                      @mouseenter="onTransposeCellMouseenter(cell.recordIndex, cell.valueIndex)"
+                      @mouseleave="onCellMouseleave(cell.recordIndex, cell.valueIndex)"
+                      @contextmenu="onTransposeCellContext(cell.recordIndex, cell.valueIndex, $event)"
+                      @dblclick.stop="canEditCellItem(displayItems[cell.recordIndex], cell.valueIndex) && startDomCellEdit(displayItems[cell.recordIndex].id, cell.valueIndex, cell.display, $event)"
+                    >
+                      <template v-if="editingCell?.rowId === displayItems[cell.recordIndex]?.id && editingCell?.col === cell.valueIndex">
+                        <TemporalCellEditor
+                          v-if="temporalEditorConfigForColumn(cell.valueIndex)"
+                          v-model="editValue"
+                          :kind="temporalEditorConfigForColumn(cell.valueIndex)!.kind"
+                          :fraction-precision="temporalEditorConfigForColumn(cell.valueIndex)!.fractionPrecision"
+                          cell-layout="transpose"
+                          @cancel="cancelEdit"
+                          @commit="commitGridEdit"
+                        />
+                        <EnumCellEditor
+                          v-else-if="isEnumGridColumn(cell.valueIndex)"
+                          v-model="editValue"
+                          :values="enumValuesForGridColumn(cell.valueIndex)"
+                          :nullable="isEnumGridColumnNullable(cell.valueIndex)"
+                          :initial-null="isEnumEditorInitialNull(displayItems[cell.recordIndex]?.id, cell.valueIndex)"
+                          cell-layout="transpose"
+                          @cancel="cancelEdit"
+                          @commit="commitGridEdit"
+                        />
+                        <textarea
+                          v-else-if="cellUsesExpandedEditor(displayItems[cell.recordIndex]?.id, cell.valueIndex)"
+                          v-model="editValue"
+                          data-expanded-cell-editor="true"
+                          rows="1"
+                          :inputmode="cellEditInputModeForColumn(cell.valueIndex)"
+                          autocapitalize="off"
+                          autocorrect="off"
+                          spellcheck="false"
+                          class="cell-edit-input cell-edit-input--expanded absolute left-0 top-0 min-h-full bg-background px-1.5 py-1 leading-[18px] outline-none z-10"
+                          @blur="commitEditFromCellBlur"
+                          @click.stop
+                          @focus="onCellEditTextareaInput"
+                          @input="onCellEditTextareaInput"
+                          @keydown.stop="onCellEditKeydown"
+                          @paste.stop="onCellEditTextareaPaste"
+                        />
+                        <input
+                          v-else
+                          v-model="editValue"
+                          :inputmode="cellEditInputModeForColumn(cell.valueIndex)"
+                          autocapitalize="off"
+                          autocorrect="off"
+                          spellcheck="false"
+                          class="cell-edit-input absolute inset-0 bg-background border-2 border-primary px-1.5 py-0 leading-[26px] outline-none z-10"
+                          @blur="commitEditFromCellBlur"
+                          @click.stop
+                          @input="onCellEditTextareaInput"
+                          @keydown.stop="onCellEditKeydown"
+                          @paste.stop="onCellEditTextareaPaste"
+                        />
+                      </template>
+                      <template v-else>
+                        <template v-if="draftCellPlaceholder(displayItems[cell.recordIndex], cell.valueIndex)">
+                          <span class="text-muted-foreground/70 italic">{{ draftCellPlaceholder(displayItems[cell.recordIndex], cell.valueIndex) }}</span>
+                        </template>
+                        <template v-else>{{ firstLineCellDisplayValue(cell.display) }}</template>
+                        <div v-if="cellDetailButtonVisible(cell.recordIndex, cell.valueIndex)" class="absolute right-2 top-0.5 flex items-center gap-1">
+                          <LightDropdownMenu
+                            v-if="canQuickDownloadCellValue(cell.recordIndex, cell.valueIndex)"
+                            :items="binaryCellDownloadMenuItems"
+                            :open="quickDownloadMenuOpenFor(cell.recordIndex, cell.valueIndex)"
+                            align="end"
+                            content-class="w-44"
+                            :match-trigger-width="false"
+                            @update:open="(value: boolean) => handleQuickDownloadMenuOpenChange(value, cell.recordIndex, cell.valueIndex)"
+                            @select="(mode: string) => downloadCellBinaryValue(cell.recordIndex, cell.valueIndex, mode as BinaryCellDownloadMode)"
+                          >
+                            <template #trigger="{ open, toggle }">
+                              <button class="flex h-5 w-5 items-center justify-center rounded bg-background/90 text-muted-foreground shadow-sm ring-1 ring-border hover:text-foreground" :title="t('grid.downloadBinaryValue')" :aria-expanded="open" @mousedown.stop @click.stop="toggle">
+                                <Upload class="h-3 w-3" />
+                              </button>
+                            </template>
+                          </LightDropdownMenu>
+                          <button
+                            class="flex h-5 w-5 items-center justify-center rounded bg-background/90 text-muted-foreground shadow-sm ring-1 ring-border hover:text-foreground"
+                            :title="t('grid.cellDetails')"
+                            @mousedown.stop
+                            @click.stop="showTransposeCellDetails(cell.recordIndex, cell.valueIndex)"
+                          >
+                            <Info class="h-3 w-3" />
+                          </button>
+                        </div>
+                      </template>
+                    </div>
+                    <div class="shrink-0" :style="{ width: `${transposeAfterSpacerWidth}px` }" />
+                  </div>
+                </template>
+              </RecycleScroller>
+            </div>
+            <template v-else>
+              <!-- Sticky header -->
+              <div ref="headerRef" class="data-grid-header-shell shrink-0 z-10 w-full border-y border-border overflow-hidden">
+                <div class="data-grid-header-row flex w-(--header-total-w) font-semibold text-foreground">
+                  <div
+                    class="data-grid-header-cell shrink-0 px-2 py-1.5 border-r w-(--row-num-w) border-border text-center text-muted-foreground select-none cursor-default hover:bg-gray-200 dark:hover:bg-gray-800 sticky left-0 z-20"
+                    :class="{ 'data-grid-header-cell--selected outline outline-primary -outline-offset-1': isSelectingAll }"
+                    @click="selectAllCells"
+                  >
+                    #
+                  </div>
+                  <div class="shrink-0" :style="{ width: `${horizontalColumnWindow.beforeWidth}px` }" />
+                  <LightTooltip v-for="col in renderedGridColumns" :key="`${col.name}-${col.actualColIdx}`" :text="col.name" side="bottom" :side-offset="4" :disabled="columnHeaderTooltipsDisabled">
+                    <div
+                      class="data-grid-header-cell shrink-0 px-2 py-1.5 border-r border-border whitespace-nowrap hover:bg-gray-200 dark:hover:bg-gray-800 select-none relative overflow-hidden"
+                      :class="{
+                        'data-grid-header-cell--selected outline outline-primary -outline-offset-1': highlightedColumnIndex === col.actualColIdx || columnIsSelected(col.visibleColIdx),
+                        'bg-amber-500/20 ring-1 ring-inset ring-amber-500/40': currentSearchMatch?.kind === 'column' && currentSearchMatch.col === col.actualColIdx,
+                        ...columnHeaderDragClass(col.visibleColIdx),
+                      }"
+                      :style="columnHeaderStyle(col.visibleColIdx)"
+                      :data-grid-column-index="col.actualColIdx"
+                      :data-visible-col-index="col.visibleColIdx"
+                      @pointerdown="startColumnHeaderDrag(col.visibleColIdx, $event)"
+                      @click.capture="onHeaderClickCapture"
+                      @click="onHeaderClick(col.visibleColIdx, $event)"
+                      @contextmenu="onHeaderContext(col.name, col.actualColIdx)"
+                    >
+                      <span class="flex min-w-0 items-center gap-1 overflow-hidden">
+                        <span class="flex min-w-0 flex-1 flex-col overflow-hidden">
+                          <span class="min-w-0 truncate leading-4">
+                            {{ col.name }}
+                          </span>
+                          <span v-if="headerColumnType(col.name, col.actualColIdx)" class="min-w-0 truncate text-[10px] font-normal leading-3" :class="typeColorClass(headerColumnType(col.name, col.actualColIdx))" :title="headerColumnType(col.name, col.actualColIdx)">
+                            {{ headerColumnType(col.name, col.actualColIdx) }}
+                          </span>
+                          <span v-if="headerColumnComment(col.name)" class="min-w-0 truncate text-[10px] font-normal leading-3 text-muted-foreground" :title="headerColumnComment(col.name)">
+                            {{ headerColumnComment(col.name) }}
+                          </span>
+                        </span>
+                        <span class="flex shrink-0 items-center gap-1" :class="{ 'flex-col !gap-0': columnWidthDensity === 'compact' }">
+                          <LightDropdownMenu
+                            v-if="headerColumnSortable(col.actualColIdx)"
+                            :items="sortMenuItems(col.name, col.actualColIdx)"
+                            :open="headerSortMenuOpenColumn === col.actualColIdx"
+                            :selected-value="selectedSortMenuValue(col.name, col.actualColIdx)"
+                            align="end"
+                            content-class="w-max min-w-28 p-0.5"
+                            item-class="gap-1 px-1.5 py-0.5 text-xs"
+                            item-icon-class="h-3 w-3"
+                            :match-trigger-width="false"
+                            @update:open="(value: boolean) => (headerSortMenuOpenColumn = value ? col.actualColIdx : null)"
+                            @select="(value: string) => selectHeaderSort(value, col.name, col.actualColIdx)"
+                          >
+                            <template #trigger="{ open, toggle }">
+                              <button
+                                type="button"
+                                class="flex h-4 w-4 shrink-0 items-center justify-center rounded text-muted-foreground hover:bg-gray-200 dark:hover:bg-gray-800 hover:text-foreground"
+                                :class="columnIsSorted(col.name, col.actualColIdx) ? 'text-primary opacity-100' : 'opacity-80'"
+                                :title="t('grid.sort')"
+                                :aria-expanded="open"
+                                @mousedown.stop
+                                @click.stop="toggle"
+                              >
+                                <ArrowUp v-if="columnIsSorted(col.name, col.actualColIdx) && sortDir === 'asc'" class="h-3 w-3 shrink-0" />
+                                <ArrowDown v-else-if="columnIsSorted(col.name, col.actualColIdx) && sortDir === 'desc'" class="h-3 w-3 shrink-0" />
+                                <ArrowUpDown v-else class="h-3 w-3 shrink-0" />
+                              </button>
+                            </template>
+                          </LightDropdownMenu>
+                          <LightDropdownMenu
+                            v-if="compactColumnHeaderActions"
+                            :items="compactColumnActionMenuItems(col.name)"
+                            :open="headerActionMenuOpenColumn === col.actualColIdx"
+                            align="end"
+                            content-class="w-max min-w-28 max-w-48 p-0.5"
+                            item-class="gap-1 px-1.5 py-0.5 text-xs"
+                            item-icon-class="h-3 w-3"
+                            :match-trigger-width="false"
+                            @update:open="(value: boolean) => (headerActionMenuOpenColumn = value ? col.actualColIdx : null)"
+                            @select="(value: string) => selectCompactColumnAction(value, col.actualColIdx)"
+                          >
+                            <template #trigger="{ open, toggle }">
+                              <button
+                                type="button"
+                                class="flex h-4 w-4 shrink-0 items-center justify-center rounded text-muted-foreground hover:bg-gray-200 dark:hover:bg-gray-800 hover:text-foreground"
+                                :class="columnHasFormatter(col.actualColIdx) || localFilterActive(col.actualColIdx) ? 'text-primary opacity-90' : 'opacity-80'"
+                                :title="t('grid.columnActions')"
+                                :aria-expanded="open"
+                                @click.stop="toggle"
+                              >
+                                <ChevronDown class="h-3 w-3" />
+                              </button>
+                            </template>
+                          </LightDropdownMenu>
+                          <Popover :open="formatterOpenColumn === col.actualColIdx" @update:open="(value: boolean) => handleColumnFormatterOpenChange(value, col.actualColIdx)">
+                            <PopoverAnchor v-if="compactColumnHeaderActions" as-child>
+                              <span class="pointer-events-none absolute right-3 top-1/2 h-px w-px -translate-y-1/2" />
+                            </PopoverAnchor>
+                            <PopoverTrigger v-else as-child>
+                              <button
+                                type="button"
+                                class="flex h-4 w-4 shrink-0 items-center justify-center rounded text-muted-foreground hover:bg-gray-200 dark:hover:bg-gray-800 hover:text-foreground"
+                                :class="columnHasFormatter(col.actualColIdx) ? 'text-primary opacity-100' : 'opacity-80'"
+                                :disabled="!formatterKeyForColumn(col.name)"
+                                :title="t('grid.columnFormatter')"
+                                @click.stop
+                              >
+                                <Code2 class="h-3.5 w-3.5" />
+                              </button>
+                            </PopoverTrigger>
+                            <PopoverContent align="start" side="bottom" class="w-[420px] max-w-[calc(100vw-2rem)] gap-0 overflow-hidden rounded-xl border bg-popover p-0 text-popover-foreground shadow-xl" @click.stop @keydown.stop>
+                              <div class="border-b bg-muted/40 px-3 py-2">
+                                <div class="text-sm font-semibold">
+                                  {{ t("grid.columnFormatterFor", { column: col.name }) }}
+                                </div>
+                                <div class="mt-0.5 text-[11px] text-muted-foreground">
+                                  {{ t("grid.columnFormatterHint") }}
+                                </div>
+                              </div>
+                              <div class="space-y-3 p-3">
+                                <div class="space-y-1.5">
+                                  <div class="text-xs font-medium text-muted-foreground">
+                                    {{ t("grid.formatterType") }}
+                                  </div>
+                                  <Select :model-value="formatterKind" @update:model-value="(value: any) => (formatterKind = value)">
+                                    <SelectTrigger class="h-8 text-xs">
+                                      <SelectValue />
+                                    </SelectTrigger>
+                                    <SelectContent>
+                                      <SelectItem value="datetime">{{ t("grid.formatterDatetime") }}</SelectItem>
+                                      <SelectItem value="json-path">{{ t("grid.formatterJsonPath") }}</SelectItem>
+                                      <SelectItem value="mask">{{ t("grid.formatterMask") }}</SelectItem>
+                                      <SelectItem value="custom-template">{{ t("grid.formatterCustomTemplate") }}</SelectItem>
+                                    </SelectContent>
+                                  </Select>
+                                </div>
+
+                                <div v-if="formatterKind === 'datetime'" class="flex gap-2">
+                                  <div class="space-y-1.5">
+                                    <div class="text-xs font-medium text-muted-foreground">
+                                      {{ t("grid.formatterTimestampUnit") }}
+                                    </div>
+                                    <Select :model-value="formatterDateUnit" @update:model-value="(value: any) => (formatterDateUnit = value)">
+                                      <SelectTrigger class="h-8 text-xs">
+                                        <SelectValue />
+                                      </SelectTrigger>
+                                      <SelectContent>
+                                        <SelectItem value="auto">{{ t("grid.formatterUnitAuto") }}</SelectItem>
+                                        <SelectItem value="seconds">{{ t("grid.formatterUnitSeconds") }}</SelectItem>
+                                        <SelectItem value="milliseconds">{{ t("grid.formatterUnitMilliseconds") }}</SelectItem>
+                                      </SelectContent>
+                                    </Select>
+                                  </div>
+                                  <div class="space-y-1.5 flex-1">
+                                    <div class="text-xs font-medium text-muted-foreground">
+                                      {{ t("grid.formatterDatetimePattern") }}
+                                    </div>
+                                    <SearchableSelect
+                                      :model-value="formatterDatetimePattern"
+                                      :options="DateTimePatterns"
+                                      :placeholder="t('grid.formatterDatetimePatternPlaceholder')"
+                                      :search-placeholder="t('grid.formatterDatetimePatternPlaceholder')"
+                                      :empty-text="t('grid.formatterDatetimePatternEmpty')"
+                                      :loading-text="t('common.loading')"
+                                      :allow-custom="true"
+                                      :trigger-class="['border border-input h-8 w-72 pl-2.5 text-xs']"
+                                      content-class="w-72"
+                                      item-class="h-auto min-h-8 px-2 py-1.5 text-xs"
+                                      @update:model-value="(value: any) => (formatterDatetimePattern = value)"
+                                    />
+                                  </div>
+                                </div>
+
+                                <div v-else-if="formatterKind === 'json-path'" class="space-y-1.5">
+                                  <div class="text-xs font-medium text-muted-foreground">
+                                    {{ t("grid.formatterJsonPathInput") }}
+                                  </div>
+                                  <input v-model="formatterJsonPath" autocapitalize="off" autocorrect="off" spellcheck="false" class="h-8 w-full rounded border bg-background px-2 font-mono text-xs outline-none focus:border-primary" placeholder="$.user.name" />
+                                </div>
+
+                                <div v-else-if="formatterKind === 'mask'" class="grid grid-cols-2 gap-2">
+                                  <label class="space-y-1.5">
+                                    <span class="text-xs font-medium text-muted-foreground">
+                                      {{ t("grid.formatterMaskPrefix") }}
+                                    </span>
+                                    <input v-model.number="formatterMaskPrefix" type="number" min="0" class="h-8 w-full rounded border bg-background px-2 text-xs outline-none focus:border-primary" />
+                                  </label>
+                                  <label class="space-y-1.5">
+                                    <span class="text-xs font-medium text-muted-foreground">
+                                      {{ t("grid.formatterMaskSuffix") }}
+                                    </span>
+                                    <input v-model.number="formatterMaskSuffix" type="number" min="0" class="h-8 w-full rounded border bg-background px-2 text-xs outline-none focus:border-primary" />
+                                  </label>
+                                </div>
+
+                                <div v-else class="space-y-2">
+                                  <div v-if="savedCustomFormatters.length" class="space-y-1.5">
+                                    <div class="text-xs font-medium text-muted-foreground">
+                                      {{ t("grid.formatterSavedCustom") }}
+                                    </div>
+                                    <Select :model-value="formatterCustomId" @update:model-value="(value: any) => selectCustomFormatter(String(value))">
+                                      <SelectTrigger class="h-8 text-xs">
+                                        <SelectValue />
+                                      </SelectTrigger>
+                                      <SelectContent>
+                                        <SelectItem :value="CUSTOM_FORMATTER_NEW">{{ t("grid.formatterNewCustom") }}</SelectItem>
+                                        <SelectItem v-for="formatter in savedCustomFormatters" :key="formatter.id" :value="formatter.id">
+                                          {{ formatter.name }}
+                                        </SelectItem>
+                                      </SelectContent>
+                                    </Select>
+                                  </div>
+                                  <label class="block space-y-1.5">
+                                    <span class="text-xs font-medium text-muted-foreground">
+                                      {{ t("grid.formatterCustomName") }}
+                                    </span>
+                                    <input v-model="formatterCustomName" class="h-8 w-full rounded border bg-background px-2 text-xs outline-none focus:border-primary" :placeholder="t('grid.formatterCustomNamePlaceholder')" />
+                                  </label>
+                                  <label class="block space-y-1.5">
+                                    <span class="text-xs font-medium text-muted-foreground">
+                                      {{ t("grid.formatterCustomTemplateInput") }}
+                                    </span>
+                                    <input v-model="formatterCustomTemplate" autocapitalize="off" autocorrect="off" spellcheck="false" class="h-8 w-full rounded border bg-background px-2 font-mono text-xs outline-none focus:border-primary" placeholder="ID-${value}" />
+                                  </label>
+                                  <div class="text-[11px] leading-4 text-muted-foreground">
+                                    {{ t("grid.formatterCustomTemplateHint") }}
+                                  </div>
+                                </div>
+
+                                <div class="space-y-1.5">
+                                  <div class="text-xs font-medium text-muted-foreground">
+                                    {{ t("grid.formatterPreview") }}
+                                  </div>
+                                  <div class="max-h-40 overflow-auto rounded border bg-muted/20">
+                                    <div v-for="row in formatterPreviewRows(col.actualColIdx)" :key="row.index" class="grid grid-cols-[2rem_minmax(0,1fr)_minmax(0,1fr)] gap-2 border-b px-2 py-1.5 text-[11px] last:border-b-0">
+                                      <span class="text-muted-foreground">{{ row.index }}</span>
+                                      <span class="truncate font-mono text-muted-foreground">{{ row.raw }}</span>
+                                      <span class="truncate font-mono">{{ row.formatted }}</span>
+                                    </div>
+                                  </div>
+                                </div>
+                              </div>
+
+                              <div class="flex items-center justify-between gap-2 border-t bg-muted/30 px-3 py-2">
+                                <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" :disabled="!columnHasFormatter(col.actualColIdx)" @click="clearColumnFormatter(col.actualColIdx)">
+                                  {{ t("grid.clearFormatter") }}
+                                </Button>
+                                <div class="flex items-center gap-2">
+                                  <Button variant="outline" size="sm" class="h-7 px-2 text-xs" @click="closeColumnFormatter">
+                                    {{ t("dangerDialog.cancel") }}
+                                  </Button>
+                                  <Button size="sm" class="h-7 px-2 text-xs" :disabled="!formatterDraftIsSavable()" @click="saveColumnFormatter(col.actualColIdx)">
+                                    {{ t("grid.saveFormatter") }}
+                                  </Button>
+                                </div>
+                              </div>
+                            </PopoverContent>
+                          </Popover>
+                          <Popover :open="localFilterOpenColumn === col.actualColIdx" @update:open="(value: boolean) => handleLocalFilterOpenChange(value, col.actualColIdx)">
+                            <PopoverAnchor v-if="compactColumnHeaderActions" as-child>
+                              <span class="pointer-events-none absolute right-3 top-1/2 h-px w-px -translate-y-1/2" />
+                            </PopoverAnchor>
+                            <PopoverTrigger v-else as-child>
+                              <button
+                                type="button"
+                                class="flex h-4 w-4 shrink-0 items-center justify-center rounded text-muted-foreground hover:bg-gray-200 dark:hover:bg-gray-800 hover:text-foreground"
+                                :class="localFilterActive(col.actualColIdx) ? 'text-primary opacity-100' : 'opacity-80'"
+                                :title="t('grid.localFilter')"
+                                @click.stop
+                              >
+                                <Filter class="h-3.5 w-3.5" />
+                              </button>
+                            </PopoverTrigger>
+                            <PopoverContent align="start" side="bottom" class="w-[300px] max-w-[calc(100vw-2rem)] gap-0 overflow-hidden rounded-xl border bg-popover p-0 text-popover-foreground shadow-xl" @click.stop @keydown.stop>
+                              <div class="border-b bg-muted/40 px-2 py-1.5 text-center text-xs font-semibold">
+                                {{ columnFilterPanelTitle(col.name) }}
+                              </div>
+                              <div class="flex items-center gap-1.5 border-b px-2 py-1.5">
+                                <Search class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                                <input v-model="localFilterSearch" autocapitalize="off" autocorrect="off" spellcheck="false" class="h-7 min-w-0 flex-1 bg-transparent text-xs outline-none placeholder:text-muted-foreground" :placeholder="t('grid.searchValues')" />
+                              </div>
+                              <div class="grid grid-cols-[1.75rem_minmax(0,1fr)_3.5rem] border-b bg-muted/40 px-2 py-1 text-xs font-medium text-muted-foreground">
+                                <button type="button" class="flex h-4 w-4 items-center justify-center rounded border" :class="localFilterAllVisibleSelected ? 'border-blue-600 bg-blue-600 text-white' : 'border-border bg-background text-foreground/70'" @click="toggleAllLocalFilterOptions">
+                                  <Check v-if="localFilterAllVisibleSelected" class="h-3 w-3 stroke-[3]" />
+                                </button>
+                                <span>{{ t("grid.value") }}</span>
+                                <span class="text-right">{{ t("grid.count") }}</span>
+                              </div>
+                              <div v-if="localFilterDraft?.mode === 'server' && (serverFilterLoading || serverFilterError || serverFilterLimited)" class="flex items-center gap-1.5 border-b px-2 py-1 text-[11px] text-muted-foreground">
+                                <Loader2 v-if="serverFilterLoading" class="h-3 w-3 animate-spin" />
+                                <span class="min-w-0 truncate">
+                                  <template v-if="serverFilterLoading">{{ t("grid.loadingValues") }}</template>
+                                  <template v-else-if="serverFilterError">{{ serverFilterError }}</template>
+                                  <template v-else>{{ t("grid.serverValuesLimited", { count: SERVER_COLUMN_FILTER_LIMIT }) }}</template>
+                                </span>
+                              </div>
+                              <div class="max-h-72 overflow-auto py-0.5">
+                                <button v-for="option in localFilterOptions" :key="option.key" type="button" class="grid w-full grid-cols-[1.75rem_minmax(0,1fr)_3.5rem] items-center px-2 py-1 text-left text-xs hover:bg-accent" @click="toggleLocalFilterValue(option.key)">
+                                  <span class="flex h-4 w-4 items-center justify-center rounded border" :class="localFilterDraft?.values.has(option.key) ? 'border-blue-600 bg-blue-600 text-white' : 'border-border bg-background text-foreground/70'">
+                                    <Check v-if="localFilterDraft?.values.has(option.key)" class="h-3 w-3 stroke-[3]" />
+                                  </span>
+                                  <span class="truncate font-mono" :class="{ 'italic text-muted-foreground': option.value === null }">
+                                    {{ option.label }}
+                                  </span>
+                                  <span class="text-right tabular-nums text-muted-foreground text-xs">{{ option.count ?? "" }}</span>
+                                </button>
+                                <div v-if="localFilterDraft?.mode === 'local' && localFilterAllOptions.length > localFilterOptions.length" class="px-2 py-0.5 text-center text-[10px] text-muted-foreground">
+                                  {{
+                                    t("grid.moreValues", {
+                                      count: localFilterAllOptions.length - localFilterOptions.length,
+                                    })
+                                  }}
+                                </div>
+                                <button v-if="canApplyTypedLocalFilterValue" type="button" class="grid w-full grid-cols-[1.75rem_minmax(0,1fr)] items-center px-2 py-1 text-left text-xs text-primary hover:bg-accent" @click="applyTypedLocalFilterValue">
+                                  <Search class="h-3.5 w-3.5" />
+                                  <span class="truncate font-mono">
+                                    {{ t("grid.filterTypedValue", { value: localFilterTypedValue }) }}
+                                  </span>
+                                </button>
+                                <div v-if="localFilterOptions.length === 0 && !canApplyTypedLocalFilterValue && !serverFilterLoading" class="px-2 py-6 text-center text-xs text-muted-foreground">
+                                  {{ t("grid.noSearchResults") }}
+                                </div>
+                              </div>
+                              <div class="flex items-center justify-between gap-2 border-t bg-muted/40 px-2 py-1.5">
+                                <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" @click="clearLocalFilter(col.actualColIdx)">
+                                  {{ t("grid.clearFilter") }}
+                                </Button>
+                                <div class="flex items-center gap-2">
+                                  <Button variant="outline" size="sm" class="h-7 px-2 text-xs" @click="closeLocalFilter">
+                                    {{ t("dangerDialog.cancel") }}
+                                  </Button>
+                                  <Button size="sm" class="h-7 px-2 text-xs" @click="applyLocalFilter">
+                                    {{ t("grid.applyFilter") }}
+                                  </Button>
+                                </div>
+                              </div>
+                            </PopoverContent>
+                          </Popover>
+                          <button
+                            v-if="!compactColumnHeaderActions && canUseServerColumnFilter"
+                            type="button"
+                            class="flex h-4 w-4 shrink-0 items-center justify-center rounded text-muted-foreground hover:bg-gray-200 dark:hover:bg-gray-800 hover:text-foreground"
+                            :class="localFilterOpenColumn === col.actualColIdx && localFilterDraft?.mode === 'server' ? 'text-primary opacity-100' : 'opacity-80'"
+                            :title="t('grid.databaseValueFilter')"
+                            @click.stop="openLocalFilter(col.actualColIdx, 'server')"
+                          >
+                            <Database class="h-3.5 w-3.5" />
+                          </button>
+                        </span>
+                      </span>
+                      <div data-column-resize-handle class="absolute right-0 top-0 bottom-0 w-1.5 cursor-col-resize hover:bg-primary/30" @mousedown.stop="startColumnHeaderResize(col.visibleColIdx, $event)" @click.stop.prevent @dblclick.stop="autoFitColumn(col.visibleColIdx)" />
+                    </div>
+                    <template #content>
+                      <div class="grid min-w-56 grid-cols-[auto_minmax(0,1fr)] gap-x-2 gap-y-1 px-3 py-2">
+                        <span class="text-background/70">{{ t("grid.columnName") }}</span>
+                        <span class="flex min-w-0 items-center gap-2">
+                          <span class="min-w-0 flex-1 truncate font-mono">{{ col.name }}</span>
+                          <button type="button" class="flex h-5 w-5 shrink-0 items-center justify-center rounded hover:bg-background/10" :title="t('grid.copyColumnName')" @click.stop="copyText(col.name)">
+                            <Copy class="h-3 w-3" />
+                          </button>
+                        </span>
+                        <template v-if="columnTypeMap.get(col.name)">
+                          <span class="text-background/70">{{ t("grid.columnType") }}</span>
+                          <span :class="typeColorClass(columnTypeMap.get(col.name)!)">{{ columnTypeMap.get(col.name) }}</span>
+                        </template>
+                        <template v-if="columnCommentMap.get(col.name)">
+                          <span class="text-background/70">{{ t("grid.columnComment") }}</span>
+                          <span>{{ columnCommentMap.get(col.name) }}</span>
+                        </template>
+                      </div>
+                    </template>
+                  </LightTooltip>
+                  <div class="shrink-0" :style="{ width: `${horizontalColumnWindow.afterWidth}px` }" />
+                  <div v-if="gridScrollbarGutter > 0" class="shrink-0 border-l border-border w-(--grid-scrollbar-gutter)" />
+                </div>
+              </div>
+
+              <div v-if="!hasVisibleRows" class="relative min-h-0 flex-1">
+                <div class="data-grid-scroller h-full overflow-x-auto overflow-y-hidden overscroll-none" :class="{ 'is-scrolling': isScrolling }" @scroll="onScrollerScroll" @wheel="onDomGridWheel">
+                  <div class="h-full min-h-[220px]" :style="{ width: 'max(100%, var(--total-w))' }" />
+                </div>
+                <div class="pointer-events-none absolute inset-0 flex flex-col items-center justify-center gap-2 px-6 text-center text-muted-foreground">
+                  <component :is="hasActiveFilter ? SearchX : Inbox" class="h-8 w-8 text-muted-foreground/50" aria-hidden="true" />
+                  <div class="space-y-1">
+                    <div class="text-sm font-medium text-foreground">{{ emptyTitle }}</div>
+                    <div class="text-xs">{{ emptyDescription }}</div>
+                  </div>
+                </div>
+              </div>
+
+              <div
+                v-else-if="useCanvasGridRows"
+                ref="scrollerRef"
+                class="data-grid-scroller canvas-grid-scroller flex-1 overflow-auto overscroll-none relative"
+                :class="{ 'is-scrolling': isScrolling, 'has-horizontal-scrollbar': hasGridHorizontalOverflow }"
+                @scroll="onCanvasScroll"
+                @wheel="onCanvasWheel"
+              >
+                <div class="relative" :style="{ width: `${totalWidth}px`, height: `${canvasContentHeight}px` }">
+                  <canvas
+                    ref="canvasRef"
+                    class="canvas-grid-surface dbx-data-grid-font-family sticky left-0 top-0 z-0 block font-normal"
+                    :style="{ width: `${canvasSurfaceWidth}px`, height: `${canvasViewportHeight}px` }"
+                    @mousemove="onCanvasMouseMove"
+                    @mouseleave="onCanvasMouseLeave"
+                    @mousedown="onCanvasMouseDown"
+                    @contextmenu="onCanvasContext"
+                    @dblclick="onCanvasDblClick"
+                  />
+                  <div ref="canvasOverlayRef" class="canvas-grid-overlay dbx-data-grid-font-family sticky left-0 top-0 z-10 overflow-visible" :style="canvasOverlayStyle">
+                    <div v-if="canvasEditingCell" class="absolute pointer-events-auto z-20 tabular-nums" :style="canvasEditingCellStyle" @mousedown.stop @click.stop>
+                      <TemporalCellEditor
+                        v-if="temporalEditorConfigForColumn(canvasEditingCell.actualColIdx)"
+                        v-model="editValue"
+                        :kind="temporalEditorConfigForColumn(canvasEditingCell.actualColIdx)!.kind"
+                        :fraction-precision="temporalEditorConfigForColumn(canvasEditingCell.actualColIdx)!.fractionPrecision"
+                        @cancel="cancelEdit"
+                        @commit="commitGridEdit"
+                      />
+                      <EnumCellEditor
+                        v-else-if="isEnumGridColumn(canvasEditingCell.actualColIdx)"
+                        v-model="editValue"
+                        :values="enumValuesForGridColumn(canvasEditingCell.actualColIdx)"
+                        :nullable="isEnumGridColumnNullable(canvasEditingCell.actualColIdx)"
+                        :initial-null="isEnumEditorInitialNull(canvasEditingCell.rowId, canvasEditingCell.actualColIdx)"
+                        @cancel="cancelEdit"
+                        @commit="commitGridEdit"
+                      />
+                      <textarea
+                        v-else-if="cellUsesExpandedEditor(canvasEditingCell.rowId, canvasEditingCell.actualColIdx)"
+                        v-model="editValue"
+                        data-expanded-cell-editor="true"
+                        rows="1"
+                        :inputmode="cellEditInputModeForColumn(canvasEditingCell.actualColIdx)"
+                        autocapitalize="off"
+                        autocorrect="off"
+                        spellcheck="false"
+                        class="cell-edit-input cell-edit-input--expanded absolute left-0 top-0 min-h-full bg-background px-2.5 py-1 leading-[18px] outline-none z-10"
+                        @blur="commitEditFromCellBlur"
+                        @click.stop
+                        @focus="onCellEditTextareaInput"
+                        @input="onCellEditTextareaInput"
+                        @keydown.stop="onCellEditKeydown"
+                        @paste.stop="onCellEditTextareaPaste"
+                      />
+                      <input
+                        v-else
+                        v-model="editValue"
+                        :inputmode="cellEditInputModeForColumn(canvasEditingCell.actualColIdx)"
+                        autocapitalize="off"
+                        autocorrect="off"
+                        spellcheck="false"
+                        class="cell-edit-input absolute inset-0 bg-background border-2 border-primary px-2.5 py-0 leading-[22px] outline-none z-10"
+                        @blur="commitEditFromCellBlur"
+                        @click.stop
+                        @input="onCellEditTextareaInput"
+                        @keydown.stop="onCellEditKeydown"
+                        @paste.stop="onCellEditTextareaPaste"
+                      />
+                    </div>
+                    <div v-if="canvasDetailButtonCell" class="absolute pointer-events-auto z-20 flex items-center gap-1" :style="canvasDetailButtonStyle" @mouseenter="keepCanvasDetailHover" @mouseleave="clearCanvasDetailHover">
+                      <LightDropdownMenu
+                        v-if="canvasDetailButtonCell.canQuickDownload"
+                        :items="binaryCellDownloadMenuItems"
+                        :open="quickDownloadMenuOpenFor(canvasDetailButtonCell.rowIndex, canvasDetailButtonCell.actualColIdx)"
+                        align="end"
+                        content-class="w-44"
+                        :match-trigger-width="false"
+                        @update:open="(value: boolean) => handleQuickDownloadMenuOpenChange(value, canvasDetailButtonCell!.rowIndex, canvasDetailButtonCell!.actualColIdx)"
+                        @select="(mode: string) => downloadCellBinaryValue(canvasDetailButtonCell!.rowIndex, canvasDetailButtonCell!.actualColIdx, mode as BinaryCellDownloadMode)"
+                      >
+                        <template #trigger="{ open, toggle }">
+                          <button class="flex h-5 w-5 items-center justify-center rounded bg-background/90 text-muted-foreground shadow-sm ring-1 ring-border hover:text-foreground" :title="t('grid.downloadBinaryValue')" :aria-expanded="open" @mousedown.stop @click.stop="toggle">
+                            <Upload class="h-3 w-3" />
+                          </button>
+                        </template>
+                      </LightDropdownMenu>
+                      <button
+                        class="flex h-5 w-5 items-center justify-center rounded bg-background/90 text-muted-foreground shadow-sm ring-1 ring-border hover:text-foreground"
+                        :title="t('grid.cellDetails')"
+                        @mousedown.stop
+                        @click.stop="showCellDetailsForVisibleCell(canvasDetailButtonCell.rowIndex, canvasDetailButtonCell.visibleColIdx, canvasDetailButtonCell.actualColIdx)"
+                      >
+                        <Info class="h-3 w-3" />
+                      </button>
+                    </div>
+                  </div>
+                </div>
+                <!-- Infinite scroll loading indicator for Canvas -->
+                <div v-if="infiniteScrollEnabled && infiniteScrollLoading" class="absolute bottom-0 left-0 right-0 flex items-center justify-center py-2 text-xs text-muted-foreground bg-background/80 backdrop-blur-sm z-10">
+                  <Loader2 class="w-3 h-3 animate-spin mr-1" />
+                  {{ t("grid.loadingMore") }}
+                </div>
+              </div>
+
+              <!-- Virtual scrolled rows -->
+              <RecycleScroller
+                v-else-if="hasVisibleRows"
+                ref="scrollerRef"
+                class="data-grid-scroller dbx-data-grid-font-family flex-1 overflow-x-auto overscroll-none"
+                :class="{ 'is-scrolling': isScrolling, 'has-horizontal-scrollbar': hasGridHorizontalOverflow }"
+                :items="displayItems"
+                :item-size="26"
+                :buffer="600"
+                :skip-hover="true"
+                key-field="id"
+                @scroll="onScrollerScroll"
+                @wheel="onDomGridWheel"
+              >
+                <template #default="{ item }">
+                  <div
+                    class="data-grid-row flex border-b border-border h-6.5 w-(--total-w)"
+                    :class="{
+                      'data-grid-row--deleted opacity-70': item.isDeleted,
+                      'data-grid-row--new': item.isNew && !isRowActive(item.displayIndex),
+                      'data-grid-row--draft': item.isDraft && !isRowActive(item.displayIndex),
+                      'data-grid-row--striped': !item.isNew && !item.isDraft && !item.isDeleted && !isRowActive(item.displayIndex) && item.displayIndex % 2 === 1,
+                      'active-row': isRowActive(item.displayIndex) && !item.isDeleted,
+                      'relative z-20 overflow-visible': editingCell?.rowId === item.id,
+                    }"
+                    :style="dataGridRowStyle(item)"
+                    :data-row-index="item.displayIndex"
+                  >
+                    <div
+                      class="data-grid-row-number w-(--row-num-w) shrink-0 px-2 py-1 border-r text-center select-none cursor-default sticky left-0 z-10"
+                      :class="rowNumberStatusClass(item)"
+                      @click="handleRowClick(item.displayIndex, item.id, $event)"
+                      @dblclick.stop="toggleTranspose(item.displayIndex)"
+                      @contextmenu="onRowContext(item.id, item.displayIndex)"
+                    >
+                      {{ rowNumberText(item) }}
+                    </div>
+                    <div class="shrink-0" :style="{ width: `${horizontalColumnWindow.beforeWidth}px` }" />
+                    <div
+                      v-for="col in renderedGridColumns"
+                      :key="col.actualColIdx"
+                      class="data-grid-cell group/cell shrink-0 px-3 py-1 border-r border-border whitespace-nowrap overflow-hidden text-ellipsis relative select-none inline-block items-center tabular-nums"
+                      :style="renderedColumnStyle(col.visibleColIdx)"
+                      :class="{
+                        'text-muted-foreground italic': isNull(item.data[col.actualColIdx]),
+                        'bg-yellow-500/10 cell-dirty': item.isDirtyCol[col.actualColIdx],
+                        'cell-selected': cellIsSelected(item.displayIndex, col.visibleColIdx) && !item.isDirtyCol[col.actualColIdx],
+                        'cell-selected-dirty': cellIsSelected(item.displayIndex, col.visibleColIdx) && item.isDirtyCol[col.actualColIdx],
+                        'row-cell-selected': rowCellsUseSelectionVisual(item.id) && !cellIsSelected(item.displayIndex, col.visibleColIdx) && !item.isDirtyCol[col.actualColIdx],
+                        'row-cell-selected-dirty': rowCellsUseSelectionVisual(item.id) && !cellIsSelected(item.displayIndex, col.visibleColIdx) && item.isDirtyCol[col.actualColIdx],
+                        'cell-search-match': cellIsSearchMatch(item.displayIndex, col.actualColIdx),
+                        'cell-current-search-match': cellIsCurrentMatch(item.displayIndex, col.actualColIdx),
+                        'bg-yellow-200/60 dark:bg-yellow-500/20': cellIsSearchMatch(item.displayIndex, col.actualColIdx),
+                        'ring-2 ring-inset ring-yellow-500 bg-yellow-300/60 dark:bg-yellow-500/40': cellIsCurrentMatch(item.displayIndex, col.actualColIdx),
+                        'tabular-nums': typeof item.data[col.actualColIdx] === 'number',
+                        'cursor-text hover:bg-gray-200 dark:hover:bg-gray-800': !isScrolling && canEditCellItem(item, col.actualColIdx),
+                        'line-through': item.isDeleted,
+                        'overflow-visible z-20 border-r-transparent': editingCell?.rowId === item.id && editingCell?.col === col.actualColIdx,
+                        'overflow-hidden': !(editingCell?.rowId === item.id && editingCell?.col === col.actualColIdx),
+                      }"
+                      @mousedown="
+                        prepareDataCellMouseDown(item, col.actualColIdx);
+                        handleDataCellMousedown(item.displayIndex, col.visibleColIdx, item.id, $event);
+                      "
+                      @mouseenter="onCellMouseenter(item.displayIndex, col.visibleColIdx, col.actualColIdx)"
+                      @mouseleave="onCellMouseleave(item.displayIndex, col.actualColIdx)"
+                      @dblclick="canEditCellItem(item, col.actualColIdx) && startDomCellEdit(item.id, col.actualColIdx, formatCellCached(item.data[col.actualColIdx], col.actualColIdx), $event)"
+                      :data-visible-col-index="col.visibleColIdx"
+                      @contextmenu="onCellContext(item.id, item.displayIndex, col.actualColIdx, col.visibleColIdx, $event)"
+                    >
+                      <template v-if="editingCell?.rowId === item.id && editingCell?.col === col.actualColIdx">
+                        <TemporalCellEditor
+                          v-if="temporalEditorConfigForColumn(col.actualColIdx)"
+                          v-model="editValue"
+                          :kind="temporalEditorConfigForColumn(col.actualColIdx)!.kind"
+                          :fraction-precision="temporalEditorConfigForColumn(col.actualColIdx)!.fractionPrecision"
+                          @cancel="cancelEdit"
+                          @commit="commitGridEdit"
+                        />
+                        <EnumCellEditor
+                          v-else-if="isEnumGridColumn(col.actualColIdx)"
+                          v-model="editValue"
+                          :values="enumValuesForGridColumn(col.actualColIdx)"
+                          :nullable="isEnumGridColumnNullable(col.actualColIdx)"
+                          :initial-null="isEnumEditorInitialNull(item.id, col.actualColIdx)"
+                          @cancel="cancelEdit"
+                          @commit="commitGridEdit"
+                        />
+                        <textarea
+                          v-else-if="cellUsesExpandedEditor(item.id, col.actualColIdx)"
+                          v-model="editValue"
+                          data-expanded-cell-editor="true"
+                          rows="1"
+                          :inputmode="cellEditInputModeForColumn(col.actualColIdx)"
+                          autocapitalize="off"
+                          autocorrect="off"
+                          spellcheck="false"
+                          class="cell-edit-input cell-edit-input--expanded absolute left-0 top-0 min-h-full bg-background px-2.5 py-1 leading-[18px] outline-none z-10"
+                          @blur="commitEditFromCellBlur"
+                          @click.stop
+                          @focus="onCellEditTextareaInput"
+                          @input="onCellEditTextareaInput"
+                          @keydown.stop="onCellEditKeydown"
+                          @paste.stop="onCellEditTextareaPaste"
+                        />
+                        <input
+                          v-else
+                          v-model="editValue"
+                          :inputmode="cellEditInputModeForColumn(col.actualColIdx)"
+                          autocapitalize="off"
+                          autocorrect="off"
+                          spellcheck="false"
+                          class="cell-edit-input absolute inset-0 bg-background border-2 border-primary px-2.5 py-0 leading-[22px] outline-none z-10"
+                          @blur="commitEditFromCellBlur"
+                          @click.stop
+                          @input="onCellEditTextareaInput"
+                          @keydown.stop="onCellEditKeydown"
+                          @paste.stop="onCellEditTextareaPaste"
+                        />
+                      </template>
+                      <template v-else>
+                        <template v-if="draftCellPlaceholder(item, col.actualColIdx)">
+                          <span class="text-muted-foreground/70 italic">{{ draftCellPlaceholder(item, col.actualColIdx) }}</span>
+                        </template>
+                        <template v-else>{{ firstLineCellDisplayValue(formatCellCached(item.data[col.actualColIdx], col.actualColIdx)) }}</template>
+                        <div v-if="cellDetailButtonVisible(item.displayIndex, col.actualColIdx)" class="absolute right-2 top-0.5 flex items-center gap-1">
+                          <LightDropdownMenu
+                            v-if="canQuickDownloadCellValue(item.displayIndex, col.actualColIdx)"
+                            :items="binaryCellDownloadMenuItems"
+                            :open="quickDownloadMenuOpenFor(item.displayIndex, col.actualColIdx)"
+                            align="end"
+                            content-class="w-44"
+                            :match-trigger-width="false"
+                            @update:open="(value: boolean) => handleQuickDownloadMenuOpenChange(value, item.displayIndex, col.actualColIdx)"
+                            @select="(mode: string) => downloadCellBinaryValue(item.displayIndex, col.actualColIdx, mode as BinaryCellDownloadMode)"
+                          >
+                            <template #trigger="{ open, toggle }">
+                              <button class="flex h-5 w-5 items-center justify-center rounded bg-background/90 text-muted-foreground shadow-sm ring-1 ring-border hover:text-foreground" :title="t('grid.downloadBinaryValue')" :aria-expanded="open" @mousedown.stop @click.stop="toggle">
+                                <Upload class="h-3 w-3" />
+                              </button>
+                            </template>
+                          </LightDropdownMenu>
+                          <button
+                            class="flex h-5 w-5 items-center justify-center rounded bg-background/90 text-muted-foreground shadow-sm ring-1 ring-border hover:text-foreground"
+                            :title="t('grid.cellDetails')"
+                            @mousedown.stop
+                            @click.stop="showCellDetailsForVisibleCell(item.displayIndex, col.visibleColIdx, col.actualColIdx)"
+                          >
+                            <Info class="h-3 w-3" />
+                          </button>
+                        </div>
+                      </template>
+                    </div>
+                    <div class="shrink-0" :style="{ width: `${horizontalColumnWindow.afterWidth}px` }" />
+                  </div>
+                </template>
+              </RecycleScroller>
+              <!-- Infinite scroll loading indicator for RecycleScroller -->
+              <div v-if="infiniteScrollEnabled && infiniteScrollLoading && !loading" class="flex items-center justify-center py-2 text-xs text-muted-foreground">
+                <Loader2 class="w-3 h-3 animate-spin mr-1" />
+                {{ t("grid.loadingMore") }}
+              </div>
+              <div v-if="hasGridHorizontalOverflow" ref="gridHorizontalScrollbarTrackRef" class="data-grid-horizontal-scrollbar" @pointerdown="startGridHorizontalScrollbarDrag">
+                <div ref="gridHorizontalScrollbarThumbRef" class="data-grid-horizontal-scrollbar__thumb" />
+              </div>
+              <div v-if="hasGridVerticalOverflow" ref="gridVerticalScrollbarTrackRef" class="data-grid-vertical-scrollbar" @pointerdown="startGridVerticalScrollbarDrag">
+                <div ref="gridVerticalScrollbarThumbRef" class="data-grid-vertical-scrollbar__thumb" />
+              </div>
+              <div v-if="loading" class="absolute inset-0 z-20 bg-background/50 flex items-center justify-center">
+                <div class="flex items-center gap-2 px-3 py-1.5 rounded-md bg-background border shadow-sm text-xs text-muted-foreground">
+                  <Loader2 class="w-3.5 h-3.5 animate-spin" />
+                  <span>{{ formatElapsedSeconds(loadingElapsed) }}s</span>
+                </div>
+              </div>
+            </template>
+          </div>
+          <!-- Table Info Drawer -->
+          <div v-if="showTableInfo" class="table-info-drawer relative col-start-2 row-start-1 border-l flex flex-col bg-background min-w-0" :class="[{ 'row-span-2': cellDetailPanelIsBottom }, { 'ddl-drawer-resizing': isResizingDdl }]" :style="ddlDrawerStyle" @contextmenu="onDrawerContextMenu">
+            <div class="absolute left-0 top-0 bottom-0 z-20 w-1.5 -translate-x-1/2 cursor-col-resize hover:bg-primary/30" @mousedown.prevent="onDdlResizeStart" />
+            <div class="flex items-center gap-2 px-3 py-1.5 border-b shrink-0 bg-muted/20 h-9">
+              <TableProperties class="w-3.5 h-3.5 text-muted-foreground" />
+              <span class="text-xs font-medium flex-1 min-w-0 truncate">{{ tableMeta?.tableName }}</span>
+              <div v-if="activeTableInfoTab === 'ddl'" class="table-info-actions flex min-w-0 shrink-0 items-center gap-1">
+                <Button variant="ghost" size="sm" class="table-info-action-button h-6 px-2 text-xs" :title="t('grid.copyDdl')" :aria-label="t('grid.copyDdl')" @click="copyDdl">
+                  <Copy class="w-3 h-3" />
+                  <span class="table-info-action-label">{{ t("grid.copyDdl") }}</span>
+                </Button>
+                <Button variant="ghost" size="icon" class="h-6 w-6" :class="{ 'bg-accent': ddlWrap }" @click="toggleDdlWrap">
+                  <WrapText class="w-3 h-3" />
+                </Button>
+              </div>
+              <div v-else-if="activeTableInfoTab === 'indexes' && canManageMongoIndexes" class="table-info-actions flex min-w-0 shrink-0 items-center gap-1">
+                <Button variant="ghost" size="sm" class="table-info-action-button h-6 px-2 text-xs text-destructive hover:text-destructive" :disabled="indexesLoading || dropAllMongoIndexesLoading || droppableMongoIndexes.length === 0" @click="requestDropAllMongoIndexes">
+                  <Trash2 class="w-3 h-3" />
+                  <span class="table-info-action-label">{{ t("contextMenu.dropAllIndexes") }}</span>
+                </Button>
+              </div>
+              <Button v-if="canOpenTableStructureEditor" variant="ghost" size="sm" class="table-info-action-button h-6 px-2 text-xs" :title="t('contextMenu.editStructure')" :aria-label="t('contextMenu.editStructure')" @click="openTableStructureEditor">
+                <Columns3Cog class="w-3 h-3" />
+                <span class="table-info-action-label">{{ t("contextMenu.editStructure") }}</span>
+              </Button>
+              <Button variant="ghost" size="icon" class="h-5 w-5" @click="showTableInfo = false">
+                <X class="w-3 h-3" />
+              </Button>
+            </div>
+            <div class="grid border-b bg-background shrink-0" :style="tableInfoTabListStyle">
+              <button
+                v-for="tab in tableInfoTabs"
+                :key="tab.id"
+                class="h-9 min-w-0 px-1.5 text-[11px] border-b-2 transition-colors"
+                :class="activeTableInfoTab === tab.id ? 'border-primary bg-gray-300/80 text-foreground dark:bg-gray-700/80' : 'border-transparent text-muted-foreground hover:bg-gray-200 hover:text-foreground dark:hover:bg-gray-800/50'"
+                :title="tab.label"
+                @click="selectTableInfoTab(tab.id)"
+              >
+                <component :is="tab.icon" class="mx-auto h-3.5 w-3.5" />
+                <span class="block truncate">{{ tab.label }}</span>
+              </button>
+            </div>
+
+            <div class="px-2 py-1.5 border-b shrink-0 bg-background">
+              <div class="relative">
+                <Search class="absolute left-2 top-1/2 -translate-y-1/2 w-3.5 h-3.5 text-muted-foreground" />
+                <input v-model="searchQuery" :placeholder="t('grid.tableInfoSearch')" class="w-full h-7 pl-7 pr-6 text-xs bg-muted/50 rounded border border-border focus:outline-none focus:border-primary/50" @keydown.escape="searchQuery = ''" />
+                <button v-if="searchQuery" class="absolute right-1.5 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground" @click="searchQuery = ''">
+                  <X class="w-3 h-3" />
+                </button>
+              </div>
+            </div>
+
+            <div v-if="activeTableInfoTab === 'columns'" class="flex-1 min-h-0 overflow-auto">
+              <div v-if="searchQuery && filteredColumns.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+                {{ t("grid.tableInfoNoResults") }}
+              </div>
+              <table v-else class="w-full text-xs">
+                <thead class="sticky top-0 bg-muted text-muted-foreground">
+                  <tr class="border-b">
+                    <th class="text-left text-nowrap font-medium px-3 py-2 w-8">#</th>
+                    <th class="text-left text-nowrap font-medium px-3 py-2">{{ t("grid.columnName") }}</th>
+                    <th class="text-left text-nowrap font-medium px-3 py-2">{{ t("grid.columnType") }}</th>
+                    <th class="text-left text-nowrap font-medium px-3 py-2">{{ t("grid.tableInfoNullable") }}</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  <tr
+                    v-for="(column, index) in filteredColumns"
+                    :key="column.name"
+                    class="border-b cursor-pointer hover:bg-gray-200 dark:hover:bg-gray-800/30"
+                    role="button"
+                    tabindex="0"
+                    :title="column.name"
+                    @click="scrollToTableInfoColumn(column.name)"
+                    @keydown.enter.prevent="scrollToTableInfoColumn(column.name)"
+                    @keydown.space.prevent="scrollToTableInfoColumn(column.name)"
+                  >
+                    <td class="px-3 py-2 text-muted-foreground w-8">{{ index + 1 }}</td>
+                    <td class="px-3 py-2 font-medium">
+                      <span class="inline-flex items-center gap-1.5">
+                        <KeyRound v-if="column.is_primary_key" class="h-3 w-3 text-amber-500" />
+                        {{ column.name }}
+                      </span>
+                      <div v-if="column.comment" class="mt-0.5 text-[11px] text-muted-foreground truncate">
+                        {{ column.comment }}
+                      </div>
+                    </td>
+                    <td class="px-3 py-2 font-mono text-[11px] text-muted-foreground">{{ column.data_type }}</td>
+                    <td class="px-3 py-2">{{ column.is_nullable ? "YES" : "NO" }}</td>
+                  </tr>
+                </tbody>
+              </table>
+            </div>
+
+            <div v-else-if="activeTableInfoTab === 'indexes'" class="flex-1 min-h-0 overflow-auto">
+              <div v-if="indexesLoading" class="h-full flex items-center justify-center">
+                <Loader2 class="w-4 h-4 animate-spin text-muted-foreground" />
+              </div>
+              <div v-else-if="indexesError" class="p-3 text-xs text-destructive">{{ indexesError }}</div>
+              <div v-else-if="searchQuery && filteredIndexes.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+                {{ t("grid.tableInfoNoResults") }}
+              </div>
+              <div v-else-if="indexes.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+                {{ t("grid.tableInfoEmpty") }}
+              </div>
+              <div v-else class="divide-y">
+                <div v-for="index in filteredIndexes" :key="index.name" class="p-3 text-xs">
+                  <div class="flex items-start gap-2">
+                    <div class="min-w-0 flex-1">
+                      <div class="font-medium truncate">{{ index.name }}</div>
+                      <div class="mt-1 flex flex-wrap gap-1">
+                        <span v-if="index.is_primary" class="rounded bg-amber-500/10 px-1.5 py-0.5 text-amber-600">PK</span>
+                        <span v-if="index.is_unique" class="rounded bg-emerald-500/10 px-1.5 py-0.5 text-emerald-600">UNIQUE</span>
+                        <span v-if="index.index_type" class="rounded bg-muted px-1.5 py-0.5 text-muted-foreground">{{ index.index_type }}</span>
+                      </div>
+                      <div class="mt-2 font-mono text-[11px] text-muted-foreground break-all">
+                        {{ index.columns.join(", ") }}
+                      </div>
+                    </div>
+                    <Button v-if="canManageMongoIndexes && !index.is_primary" variant="ghost" size="sm" class="h-7 shrink-0 px-2 text-[11px] text-destructive hover:text-destructive" @click="requestDropMongoIndex(index)">
+                      <Trash2 class="mr-1 h-3 w-3" />
+                      {{ t("contextMenu.dropIndex") }}
+                    </Button>
+                  </div>
+                </div>
+              </div>
+            </div>
+
+            <div v-else-if="activeTableInfoTab === 'foreignKeys'" class="flex-1 min-h-0 overflow-auto">
+              <div v-if="foreignKeysLoading" class="h-full flex items-center justify-center">
+                <Loader2 class="w-4 h-4 animate-spin text-muted-foreground" />
+              </div>
+              <div v-else-if="foreignKeysError" class="p-3 text-xs text-destructive">{{ foreignKeysError }}</div>
+              <div v-else-if="searchQuery && filteredForeignKeys.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+                {{ t("grid.tableInfoNoResults") }}
+              </div>
+              <div v-else-if="foreignKeys.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+                {{ t("grid.tableInfoEmpty") }}
+              </div>
+              <div v-else class="divide-y">
+                <div v-for="fk in filteredForeignKeys" :key="`${fk.name}:${fk.column}`" class="p-3 text-xs">
+                  <div class="font-medium truncate">{{ fk.name }}</div>
+                  <div class="mt-1 font-mono text-[11px] text-muted-foreground break-all">{{ fk.column }} -> {{ fk.ref_table }}.{{ fk.ref_column }}</div>
+                </div>
+              </div>
+            </div>
+
+            <div v-else-if="activeTableInfoTab === 'triggers'" class="flex-1 min-h-0 overflow-auto">
+              <div v-if="triggersLoading" class="h-full flex items-center justify-center">
+                <Loader2 class="w-4 h-4 animate-spin text-muted-foreground" />
+              </div>
+              <div v-else-if="triggersError" class="p-3 text-xs text-destructive">{{ triggersError }}</div>
+              <div v-else-if="searchQuery && filteredTriggers.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+                {{ t("grid.tableInfoNoResults") }}
+              </div>
+              <div v-else-if="triggers.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+                {{ t("grid.tableInfoEmpty") }}
+              </div>
+              <div v-else class="divide-y">
+                <div v-for="trigger in filteredTriggers" :key="trigger.name" class="p-3 text-xs">
+                  <div class="font-medium truncate">{{ trigger.name }}</div>
+                  <div class="mt-1 text-[11px] text-muted-foreground">{{ trigger.timing }} {{ trigger.event }}</div>
+                </div>
+              </div>
+            </div>
+
+            <pre
+              v-else-if="activeTableInfoTab === 'ddl' && !ddlLoading"
+              ref="ddlPreRef"
+              data-native-clipboard
+              tabindex="0"
+              class="flex-1 min-w-0 text-xs font-mono p-3 overflow-auto ddl-code leading-5 select-text outline-none"
+              :class="ddlWrap ? 'whitespace-pre-wrap break-words' : 'whitespace-pre'"
+              v-html="filteredDdlContent"
+              @keydown="onDdlKeydown"
+            ></pre>
+            <div v-else class="flex-1 flex items-center justify-center">
+              <Loader2 class="w-4 h-4 animate-spin text-muted-foreground" />
+            </div>
+          </div>
+          <!-- Cell Detail Drawer -->
+          <div
+            v-if="showCellDetail && activeCellDetail"
+            class="relative flex flex-col bg-background min-w-0"
+            :class="[cellDetailPanelIsBottom ? 'col-start-1 row-start-2 border-t' : 'col-start-3 row-start-1 border-l', { 'detail-drawer-resizing': isResizingDetail }]"
+            :style="detailPanelStyle"
+            @contextmenu="onDrawerContextMenu"
+          >
+            <div v-if="!cellDetailPanelIsBottom" class="absolute left-0 top-0 bottom-0 z-20 w-1.5 -translate-x-1/2 cursor-col-resize hover:bg-primary/30" @mousedown.prevent="onDetailResizeStart" />
+            <div v-else class="absolute left-0 right-0 top-0 z-20 h-1.5 -translate-y-1/2 cursor-row-resize hover:bg-primary/30" @mousedown.prevent="onDetailResizeStart" />
+            <div class="h-9 flex items-center gap-2 px-3 border-b shrink-0 bg-muted/20">
+              <Info class="w-3.5 h-3.5 text-muted-foreground" />
+              <span class="text-xs font-medium flex-1 min-w-0 truncate">{{ t("grid.cellDetails") }}</span>
+              <Button variant="ghost" size="icon" class="h-5 w-5" :title="cellDetailPanelIsBottom ? t('grid.cellDetailLayoutRight') : t('grid.cellDetailLayoutBottom')" @click="toggleCellDetailPanelLayout">
+                <PanelRight v-if="cellDetailPanelIsBottom" class="w-3 h-3" />
+                <PanelBottom v-else class="w-3 h-3" />
+              </Button>
+              <Button variant="ghost" size="icon" class="h-5 w-5" :title="t('grid.openCellDetailsDialog')" @click="openActiveCellDetailDialog">
+                <Maximize2 class="w-3 h-3" />
+              </Button>
+              <Button variant="ghost" size="icon" class="h-5 w-5" :title="t('grid.openRowDetailsDialog')" @click="openActiveRowDetailDialog">
+                <ListTree class="w-3 h-3" />
+              </Button>
+              <Button variant="ghost" size="icon" class="h-5 w-5" :title="t('grid.openColumnDetailsDialog')" @click="openActiveColumnDetailDialog">
+                <TableProperties class="w-3 h-3" />
+              </Button>
+              <Button variant="ghost" size="icon" class="h-5 w-5" @click="closeCellDetails">
+                <X class="w-3 h-3" />
+              </Button>
+            </div>
+
+            <Tabs v-model="activeCellDetailTab" class="flex-1 min-h-0 gap-0">
+              <div class="shrink-0 border-b px-3 py-2">
+                <TabsList class="grid h-7 w-full p-0.5" :class="activeCellDetailTabsGridClass">
+                  <TabsTrigger value="details" class="h-6 text-xs">{{ t("grid.cellDetails") }}</TabsTrigger>
+                  <TabsTrigger v-if="activeCellDetailTabs.includes('hexViewer')" value="hexViewer" class="h-6 text-xs">
+                    {{ t("grid.hexViewer") }}
+                  </TabsTrigger>
+                  <TabsTrigger v-if="activeCellDetailTabs.includes('valueEditor')" value="valueEditor" class="h-6 text-xs">
+                    {{ t("grid.valueEditor") }}
+                  </TabsTrigger>
+                </TabsList>
+              </div>
+
+              <TabsContent value="details" class="m-0 min-h-0 flex-1 flex flex-col">
+                <div data-native-clipboard class="flex-1 min-h-0 overflow-auto px-3 pt-3 text-xs" :class="[sideDetailValueFillsHeight ? 'flex flex-col gap-3' : 'space-y-3', isEditingDetail && !cellDetailPanelIsBottom ? 'pb-1' : 'pb-3']">
+                  <div v-if="cellDetailPanelIsBottom" class="grid grid-cols-[minmax(180px,1.6fr)_repeat(4,minmax(74px,0.55fr))_minmax(160px,1fr)] gap-3 rounded border bg-muted/20 p-2">
+                    <div class="min-w-0 space-y-1">
+                      <div class="text-muted-foreground">{{ t("grid.columnName") }}</div>
+                      <div class="truncate font-medium" :title="activeCellDetail.column">
+                        {{ activeCellDetail.column }}
+                      </div>
+                    </div>
+                    <div class="space-y-1">
+                      <div class="text-muted-foreground">{{ t("grid.rowNumber") }}</div>
+                      <div>{{ activeCellDetail.rowNumber }}</div>
+                    </div>
+                    <div class="min-w-0 space-y-1">
+                      <div class="text-muted-foreground">{{ t("grid.columnType") }}</div>
+                      <div class="truncate" :class="activeCellDetail.type ? typeColorClass(activeCellDetail.type) : 'text-muted-foreground'" :title="activeCellDetail.type || '-'">
+                        {{ activeCellDetail.type || "-" }}
+                      </div>
+                    </div>
+                    <div class="space-y-1">
+                      <div class="text-muted-foreground">{{ t("grid.nullValue") }}</div>
+                      <div>{{ activeCellDetail.value === null ? "true" : "false" }}</div>
+                    </div>
+                    <div class="space-y-1">
+                      <div class="text-muted-foreground">{{ t("grid.valueLength") }}</div>
+                      <div>{{ activeCellDetail.length }}</div>
+                    </div>
+                    <div class="min-w-0 space-y-1">
+                      <div class="text-muted-foreground">{{ t("grid.columnComment") }}</div>
+                      <div class="truncate" :title="activeCellDetail.comment || t('grid.noComment')">
+                        {{ activeCellDetail.comment || t("grid.noComment") }}
+                      </div>
+                    </div>
+                  </div>
+                  <template v-else-if="!isEditingDetail && !sideDetailPrioritizesValue">
+                    <div class="space-y-1">
+                      <div class="text-muted-foreground">{{ t("grid.columnName") }}</div>
+                      <div class="font-medium break-all">{{ activeCellDetail.column }}</div>
+                    </div>
+                    <div class="grid grid-cols-2 gap-3">
+                      <div class="space-y-1">
+                        <div class="text-muted-foreground">{{ t("grid.rowNumber") }}</div>
+                        <div>{{ activeCellDetail.rowNumber }}</div>
+                      </div>
+                      <div class="space-y-1">
+                        <div class="text-muted-foreground">{{ t("grid.columnType") }}</div>
+                        <div :class="activeCellDetail.type ? typeColorClass(activeCellDetail.type) : 'text-muted-foreground'">
+                          {{ activeCellDetail.type || "-" }}
+                        </div>
+                      </div>
+                      <div class="space-y-1">
+                        <div class="text-muted-foreground">{{ t("grid.nullValue") }}</div>
+                        <div>{{ activeCellDetail.value === null ? "true" : "false" }}</div>
+                      </div>
+                      <div class="space-y-1">
+                        <div class="text-muted-foreground">{{ t("grid.valueLength") }}</div>
+                        <div>{{ activeCellDetail.length }}</div>
+                      </div>
+                    </div>
+                    <div class="space-y-1">
+                      <div class="text-muted-foreground">{{ t("grid.columnComment") }}</div>
+                      <div class="whitespace-pre-wrap break-words">
+                        {{ activeCellDetail.comment || t("grid.noComment") }}
+                      </div>
+                    </div>
+                  </template>
+                  <div class="space-y-1" :class="[{ 'min-h-0 flex flex-col': sideDetailValueFillsHeight }, sideDetailValueFillsHeight && !(activeCellDetail.imagePreviewUrl && !isEditingDetail) ? 'flex-1' : '', activeCellDetail.imagePreviewUrl && !isEditingDetail ? 'shrink-0' : '']">
+                    <div class="flex min-h-5 items-center justify-between gap-2">
+                      <div class="text-muted-foreground">{{ t("grid.cellValue") }}</div>
+                      <div class="flex items-center gap-1">
+                        <Button v-if="showCompactDetailJson" variant="ghost" size="sm" class="h-5 gap-1 px-1.5 text-xs" :disabled="!canCompactDetailJson" :title="t('grid.compactJson')" @click="compactDetailJson">
+                          <Code2 class="h-3 w-3" />
+                          {{ t("grid.compactJson") }}
+                        </Button>
+                        <Button v-if="!isEditingDetail && activeCellDetail.formattedJson" :variant="sideDetailJsonView ? 'secondary' : 'ghost'" size="sm" class="h-5 gap-1 px-1.5 text-xs" :title="t('grid.formattedJson')" @click="toggleCellDetailJsonFormatted">
+                          <Code2 class="h-3 w-3" />
+                          {{ t("grid.formattedJson") }}
+                        </Button>
+                        <Button v-if="!isEditingDetail && activeCellDetail.isEditable" variant="ghost" size="icon" class="h-5 w-5" :title="t('grid.editValue')" @click="startDetailEdit">
+                          <Pencil class="h-3 w-3" />
+                        </Button>
+                        <Button v-if="!isEditingDetail" variant="ghost" size="icon" class="h-5 w-5" :title="t('grid.copyValue')" @click="copyDetailCurrentValue">
+                          <Copy class="h-3 w-3" />
+                        </Button>
+                        <DropdownMenu v-if="!isEditingDetail && canDownloadDetailBinaryValue(activeCellDetail)">
+                          <DropdownMenuTrigger as-child>
+                            <Button variant="ghost" size="icon" class="h-5 w-5" :title="t('grid.downloadBinaryValue')">
+                              <Upload class="h-3 w-3" />
+                            </Button>
+                          </DropdownMenuTrigger>
+                          <DropdownMenuContent align="end" class="w-44">
+                            <DropdownMenuItem v-for="mode in BINARY_CELL_DOWNLOAD_MODES" :key="mode" @click="downloadDetailBinaryValue(activeCellDetail, mode)">
+                              {{ t(`grid.binaryDownload.${mode}`) }}
+                            </DropdownMenuItem>
+                          </DropdownMenuContent>
+                        </DropdownMenu>
+                        <!-- Skip hex fallback from backend (unsupported geometry types like TIN/Triangle) -->
+                        <Popover v-if="isGeometryColumnType(activeCellDetail.type) && activeCellDetail.value !== null && !isEditingDetail && !isHexGeometry(activeCellDetail.value as string)" v-model:open="sideGeometryPreviewOpen">
+                          <PopoverTrigger as-child>
+                            <Button variant="ghost" size="icon" class="h-5 w-5" :title="t('grid.geometryPreview')">
+                              <Eye class="h-3 w-3" />
+                            </Button>
+                          </PopoverTrigger>
+                          <PopoverContent class="w-auto p-1.5" align="end">
+                            <canvas v-show="sideGeometryPreviewOpen" ref="sideGeometryCanvas" width="400" height="280" class="block rounded" />
+                          </PopoverContent>
+                        </Popover>
+                      </div>
+                    </div>
+                    <div v-if="activeCellDetail.imagePreviewUrl && !isEditingDetail" class="shrink-0 space-y-1.5">
+                      <div class="text-muted-foreground">{{ t("grid.imagePreview") }}</div>
+                      <a :href="activeCellDetail.imagePreviewUrl" role="button" class="flex overflow-hidden rounded border bg-muted/20" :class="cellDetailPanelIsBottom ? 'max-h-28' : 'max-h-40'" @click.prevent="openImagePreview(activeCellDetail.imagePreviewUrl, activeCellDetail.column)">
+                        <img :src="activeCellDetail.imagePreviewUrl" :alt="activeCellDetail.column" loading="lazy" decoding="async" referrerpolicy="no-referrer" class="max-h-full w-full object-contain" />
+                      </a>
+                    </div>
+                    <template v-if="isEditingDetail">
+                      <div class="min-h-0 flex-1" :style="sideDetailEditorStyle">
+                        <TemporalCellEditor
+                          v-if="detailTemporalEditorConfig"
+                          v-model="detailEditValue"
+                          :kind="detailTemporalEditorConfig.kind"
+                          :fraction-precision="detailTemporalEditorConfig.fractionPrecision"
+                          variant="inline"
+                          :commit-on-close="false"
+                          @cancel="cancelDetailEdit"
+                          @commit="commitDetailEdit"
+                        />
+                        <div v-else ref="detailsEditorContainer" data-cell-detail-editor-root class="min-h-0 h-full w-full rounded border overflow-hidden" />
+                      </div>
+                      <div v-if="!cellDetailPanelIsBottom" class="flex shrink-0 gap-1 py-0.5">
+                        <Button size="sm" class="h-6 text-xs" @click="commitDetailEdit">
+                          {{ t("dangerDialog.confirm") }}
+                        </Button>
+                        <Button variant="outline" size="sm" class="h-6 text-xs" @click="cancelDetailEdit">
+                          {{ t("dangerDialog.cancel") }}
+                        </Button>
+                      </div>
+                    </template>
+                    <div
+                      v-else-if="activeCellDetail.formattedJson"
+                      ref="sideJsonPreviewContainer"
+                      data-cell-detail-editor-root
+                      class="overflow-hidden rounded border bg-muted/20 p-2"
+                      :class="[{ 'cursor-text': activeCellDetail.isEditable }, sideDetailValueFillsHeight ? 'min-h-0 flex-1' : 'h-72 max-h-[42vh]']"
+                      @dblclick.capture="startDetailEdit"
+                    />
+                    <pre
+                      v-else
+                      class="overflow-auto rounded border bg-muted/20 p-2 font-mono text-xs whitespace-pre-wrap break-words cursor-pointer hover:border-primary/50"
+                      :class="[{ 'cursor-text': activeCellDetail.isEditable }, cellDetailPanelIsBottom && activeCellDetail.imagePreviewUrl ? 'min-h-24 max-h-32 shrink-0' : '', sideDetailValueFillsHeight && !activeCellDetail.imagePreviewUrl ? 'min-h-0 flex-1' : '']"
+                      @dblclick="startDetailEdit"
+                      >{{ activeCellDetail.rawValuePreview }}</pre
+                    >
+                    <div v-if="activeCellDetail.isValuePreviewTruncated && !sideDetailJsonView" class="text-[11px] text-muted-foreground">
+                      {{
+                        t("grid.largeValuePreviewHint", {
+                          count: activeCellDetail.rawValuePreview.length,
+                        })
+                      }}
+                    </div>
+                  </div>
+                </div>
+
+                <div class="border-t flex gap-1 overflow-hidden bg-background p-1.5" :class="cellDetailPanelIsBottom ? 'shrink-0 items-center' : 'shrink-0 flex-col'">
+                  <div v-if="isEditingDetail && cellDetailPanelIsBottom" class="flex shrink-0 gap-1 mr-auto">
+                    <Button size="sm" class="h-6 text-xs" @click="commitDetailEdit">
+                      {{ t("dangerDialog.confirm") }}
+                    </Button>
+                    <Button variant="outline" size="sm" class="h-6 text-xs" @click="cancelDetailEdit">
+                      {{ t("dangerDialog.cancel") }}
+                    </Button>
+                  </div>
+                  <div class="flex gap-1" :class="cellDetailPanelIsBottom ? 'ml-auto shrink-0 justify-end' : 'flex-col'">
+                    <Button v-if="activeCellDetail.isEditable && activeCellDetail.value !== null" variant="ghost" size="sm" class="h-6 justify-start text-xs" @click="setDetailNull"> <X class="w-3 h-3 mr-2" /> {{ t("grid.setNull") }} </Button>
+                    <Button variant="ghost" size="sm" class="h-6 justify-start text-xs" @click="copyDetailColumnName"> <Copy class="w-3 h-3 mr-2" /> {{ t("grid.copyColumnName") }} </Button>
+                    <Button variant="ghost" size="sm" class="h-6 justify-start text-xs" :disabled="!canCopyPreparedDetailSqlCondition()" @click="copyDetailSqlCondition"> <Code2 class="w-3 h-3 mr-2" /> {{ t("grid.copySqlCondition") }} </Button>
+                  </div>
+                </div>
+              </TabsContent>
+
+              <TabsContent v-if="activeCellDetailTabs.includes('hexViewer')" value="hexViewer" class="m-0 min-h-0 flex-1 flex flex-col p-3 text-xs">
+                <div class="mb-2 min-w-0 shrink-0">
+                  <div class="font-medium">{{ t("grid.hexViewer") }}</div>
+                  <div class="text-[11px] text-muted-foreground">{{ t("grid.hexViewerByteCount", { count: activeBinaryHexByteCount }) }}</div>
+                </div>
+                <div class="min-h-0 flex-1 overflow-auto rounded border bg-muted/20 font-mono text-[11px]">
+                  <div class="sticky top-0 grid grid-cols-[5.5rem_minmax(24rem,1fr)_8rem] gap-3 border-b bg-muted px-2 py-1 font-semibold text-muted-foreground">
+                    <div>{{ t("grid.hexViewerOffset") }}</div>
+                    <div>{{ t("grid.hexViewerHex") }}</div>
+                    <div>{{ t("grid.hexViewerAscii") }}</div>
+                  </div>
+                  <div v-for="row in activeBinaryHexRows" :key="row.offset" class="grid grid-cols-[5.5rem_minmax(24rem,1fr)_8rem] gap-3 border-b border-border/50 px-2 py-1 last:border-b-0">
+                    <div class="select-all text-muted-foreground">{{ row.offset }}</div>
+                    <div class="select-all whitespace-pre">{{ row.hex }}</div>
+                    <div class="select-all whitespace-pre">{{ row.ascii }}</div>
+                  </div>
+                  <div v-if="activeBinaryHexRows.length === 0" class="px-2 py-6 text-center font-sans text-muted-foreground">
+                    {{ t("grid.hexViewerEmpty") }}
+                  </div>
+                </div>
+              </TabsContent>
+
+              <TabsContent v-if="activeCellDetailTabs.includes('valueEditor')" value="valueEditor" class="m-0 min-h-0 flex-1 flex flex-col p-3 text-xs">
+                <div class="flex min-h-0 flex-1 flex-col">
+                  <TemporalCellEditor
+                    v-if="detailTemporalEditorConfig"
+                    v-model="detailEditValue"
+                    :kind="detailTemporalEditorConfig.kind"
+                    :fraction-precision="detailTemporalEditorConfig.fractionPrecision"
+                    variant="inline"
+                    :commit-on-close="false"
+                    @cancel="cancelValueEditorEdit"
+                    @commit="commitValueEditorEdit"
+                  />
+                  <div v-else ref="valueEditorContainer" data-cell-detail-editor-root class="min-h-0 flex-1 w-full rounded border overflow-auto" />
+                </div>
+                <div class="flex gap-1 mt-2 shrink-0">
+                  <Button v-if="activeValueEditorActions.includes('formatJson')" variant="outline" size="sm" class="h-6 text-xs" @mousedown.prevent @click="formatValueEditorJson">
+                    {{ t("grid.formatJson") }}
+                  </Button>
+                  <Button v-if="activeValueEditorActions.includes('setNull')" variant="outline" size="sm" class="h-6 text-xs" @mousedown.prevent @click="setValueEditorNull">
+                    {{ t("grid.setNull") }}
+                  </Button>
+                  <Button v-if="activeValueEditorActions.includes('restoreOriginal')" variant="outline" size="sm" class="h-6 text-xs" @mousedown.prevent @click="restoreDetailOriginalValue">
+                    {{ t("grid.restoreOriginalValue") }}
+                  </Button>
+                </div>
+              </TabsContent>
+            </Tabs>
+          </div>
+          <!-- MongoDB document JSON preview -->
+          <div v-else-if="mongoJsonPreviewOpen" class="relative col-start-3 row-start-1 flex min-w-0 flex-col border-l bg-background" :class="{ 'detail-drawer-resizing': isResizingMongoJsonPreview }" :style="mongoJsonPreviewStyle" @contextmenu="onDrawerContextMenu">
+            <div class="absolute bottom-0 left-0 top-0 z-20 w-1.5 -translate-x-1/2 cursor-col-resize hover:bg-primary/30" @mousedown.prevent="onMongoJsonPreviewResizeStart" />
+            <div class="flex h-9 shrink-0 items-center gap-2 border-b bg-muted/20 px-3">
+              <Code2 class="h-3.5 w-3.5 text-muted-foreground" />
+              <span class="min-w-0 flex-1 truncate text-xs font-medium">{{ t("grid.mongoJsonPreview") }}</span>
+              <Button variant="ghost" size="icon" class="h-5 w-5" :disabled="!mongoJsonPreviewFullText" :title="t('grid.copyJson')" @click="copyMongoJsonPreview">
+                <Copy class="h-3 w-3" />
+              </Button>
+              <Button variant="ghost" size="icon" class="h-5 w-5" @click="closeMongoJsonPreview">
+                <X class="h-3 w-3" />
+              </Button>
+            </div>
+            <div v-if="mongoJsonPreviewText" class="flex min-h-0 flex-1 flex-col overflow-hidden p-2">
+              <div v-if="mongoJsonPreviewUsesCodeEditor" ref="mongoJsonPreviewContainer" data-cell-detail-editor-root class="min-h-0 flex-1 overflow-hidden" />
+              <template v-else>
+                <pre class="min-h-0 flex-1 overflow-auto rounded border bg-muted/20 p-3 font-mono text-xs whitespace-pre-wrap break-words">{{ mongoJsonPreviewText }}</pre>
+                <div class="mt-1 text-[11px] text-muted-foreground">{{ t("grid.largeValuePreviewHint", { count: mongoJsonPreviewText.length }) }}</div>
+              </template>
+            </div>
+            <div v-else class="flex min-h-0 flex-1 items-center justify-center px-6 text-center text-xs text-muted-foreground">
+              {{ t("grid.mongoJsonPreviewEmpty") }}
+            </div>
+          </div>
+        </div>
+      </div>
+    </CustomContextMenu>
+    <QueryLoadingState v-if="!hasData && loading" class="flex-1 min-h-0" />
+    <div v-else-if="!hasData" class="flex-1 flex items-center justify-center text-muted-foreground text-sm">
+      {{ t("grid.querySuccess") }}
+    </div>
+
+    <!-- Error bar -->
+    <ErrorBanner v-if="saveError" :message="saveError" copy-mode="label" dismissible @dismiss="saveError = ''" />
+
+    <!-- Bottom status bar -->
+    <div v-if="!isErrorResult" class="grid grid-cols-[max-content_minmax(0,1fr)_max-content] items-center gap-2 px-3 py-1 border-t text-xs text-muted-foreground bg-muted/30 shrink-0">
+      <div class="flex min-w-0 items-center gap-2 overflow-hidden">
+        <span v-if="hasData" class="shrink-0">
+          {{ t("grid.totalRows", { count: result.rows.length }) }}
+          <span v-if="typeof displayedTotalRowCount === 'number' && displayedTotalRowCount >= 0" class="text-muted-foreground/70">{{ t("grid.totalRowCount", { count: displayedTotalRowCount }) }}</span>
+          <span v-else-if="totalRowCountBusy" class="text-muted-foreground/70">
+            {{ t("grid.totalRowCountLoading") }}
+          </span>
+          <button v-else-if="canCalculateTotalRowCount" type="button" class="text-muted-foreground/70 hover:text-foreground hover:underline underline-offset-2 disabled:pointer-events-none" :disabled="manualTotalRowCountLoading" @click="calculateTotalRowCount">
+            {{ t("grid.calculateTotalRowsInline") }}
+          </button>
+        </span>
+        <span v-if="showTruncationWarning" class="shrink-0 text-amber-500 text-xs">(truncated)</span>
+        <span v-if="!hasData" class="shrink-0">{{ t("grid.rowsAffected", { count: result.affected_rows }) }}</span>
+        <span class="shrink-0">{{ result.execution_time_ms }}ms</span>
+
+        <template v-if="editable && hasDataGridSaveTarget">
+          <span v-if="hasPendingChanges" class="shrink-0 text-foreground">
+            {{ t("grid.pendingChanges", { count: pendingChangeCount }) }}
+          </span>
+        </template>
+      </div>
+
+      <Tooltip v-if="sqlOneLiner">
+        <TooltipTrigger as-child>
+          <span class="min-w-0 max-w-full justify-self-center truncate opacity-60 cursor-pointer hover:opacity-100" @click="copySql">
+            {{ sqlOneLiner }}
+          </span>
+        </TooltipTrigger>
+        <TooltipContent side="top" class="max-w-md">
+          <pre class="text-xs font-mono whitespace-pre-wrap">{{ props.sql }}</pre>
+        </TooltipContent>
+      </Tooltip>
+      <span v-else class="min-w-0" />
+
+      <div class="flex min-w-max items-center justify-end gap-1">
+        <div v-if="selectionSummary" class="flex shrink-0 items-center gap-3 tabular-nums">
+          <span class="shrink-0">{{ t("grid.selectionSum", { value: selectionSummarySumText }) }}</span>
+          <div class="flex shrink-0 items-center gap-1">
+            <span class="shrink-0">{{ t("grid.selectionCells", { count: selectionSummary.cellCount }) }}</span>
+            <span class="shrink-0">{{ t("grid.rows", { count: selectionSummary.rowCount }) }}</span>
+          </div>
+        </div>
+        <Loader2 v-if="loading" class="w-3 h-3 animate-spin text-muted-foreground" />
+        <template v-if="infiniteScrollEnabled">
+          <span v-if="infiniteScrollAllLoaded" class="text-xs text-muted-foreground shrink-0">
+            {{ t("grid.allLoaded") }}
+          </span>
+        </template>
+        <template v-if="!infiniteScrollEnabled">
+          <LightDropdown
+            :model-value="String(pageSize)"
+            :items="pageSizeMenuItems"
+            :trigger-label="`${pageSize}${t('grid.rowsPerPageShort')}`"
+            trigger-class="inline-flex h-5 shrink-0 items-center justify-center whitespace-nowrap rounded-md px-1.5 text-xs hover:bg-accent hover:text-accent-foreground"
+            content-class="w-36"
+            :highlight-selected="false"
+            check-position="none"
+            align="end"
+            @update:model-value="selectPageSizeMenuItem"
+          >
+            <div class="bg-border -mx-1 my-1 h-px" />
+            <div class="text-muted-foreground px-1.5 py-1 text-xs">{{ t("grid.customRowsPerPage") }}</div>
+            <div class="flex items-center gap-1 px-1.5 pb-1" @click.stop @keydown.stop>
+              <Input
+                v-model="customPageSizeInput"
+                type="number"
+                inputmode="numeric"
+                :min="MIN_RESULT_PAGE_SIZE"
+                :max="MAX_RESULT_PAGE_SIZE"
+                class="h-6 w-20 px-1.5 text-xs tabular-nums [appearance:textfield] [&::-webkit-inner-spin-button]:appearance-none [&::-webkit-outer-spin-button]:appearance-none"
+                @keydown.enter.prevent.stop="applyCustomPageSize"
+              />
+              <Tooltip>
+                <TooltipTrigger as-child>
+                  <Button variant="outline" size="icon" class="h-6 w-6 shrink-0" :aria-label="t('grid.applyPageSize')" @click.stop="applyCustomPageSize">
+                    <Check class="h-3 w-3" />
+                  </Button>
+                </TooltipTrigger>
+                <TooltipContent side="bottom">{{ t("grid.applyPageSize") }}</TooltipContent>
+              </Tooltip>
+            </div>
+          </LightDropdown>
+          <Button variant="ghost" size="icon" class="h-5 w-5 shrink-0" :disabled="currentPage <= 1" @click="firstPage">
+            <ChevronsLeft class="h-3 w-3" />
+          </Button>
+          <Button variant="ghost" size="icon" class="h-5 w-5 shrink-0" :disabled="currentPage <= 1" @click="prevPage">
+            <ChevronLeft class="h-3 w-3" />
+          </Button>
+          <span class="shrink-0 tabular-nums">{{ currentPage }}</span>
+          <Button variant="ghost" size="icon" class="h-5 w-5 shrink-0" :disabled="!canGoNextPage" @click="nextPage">
+            <ChevronRight class="h-3 w-3" />
+          </Button>
+          <Button variant="ghost" size="icon" class="h-5 w-5 shrink-0" :disabled="!canJumpLastPage" @click="lastPage">
+            <ChevronsRight class="h-3 w-3" />
+          </Button>
+        </template>
+        <LightDropdown
+          model-value=""
+          :items="exportMenuItems"
+          :aria-label="t('grid.export')"
+          :trigger-icon="Upload"
+          :trigger-label="t('grid.export')"
+          trigger-class="inline-flex h-6 shrink-0 items-center justify-center gap-1 whitespace-nowrap rounded-md px-2 text-foreground/80 hover:bg-accent hover:text-accent-foreground"
+          trigger-icon-class="h-3.5 w-3.5"
+          :show-trigger-label="true"
+          :show-chevron="true"
+          :highlight-selected="false"
+          check-position="none"
+          align="end"
+          @update:model-value="selectExportMenuItem"
+        />
+      </div>
+    </div>
+
+    <Dialog v-model:open="cellDetailDialogOpen">
+      <DialogContent v-if="dialogCellDetail" class="sm:max-w-[840px] max-h-[85vh] flex flex-col overflow-hidden">
+        <DialogHeader class="shrink-0 pr-8">
+          <DialogTitle class="flex min-w-0 items-center gap-2 text-sm">
+            <Info class="h-4 w-4 shrink-0 text-muted-foreground" />
+            <span class="min-w-0 truncate">{{ t("grid.cellDetails") }}</span>
+          </DialogTitle>
+        </DialogHeader>
+
+        <div class="min-h-0 flex-1 overflow-auto pr-1 text-xs space-y-4">
+          <div class="grid gap-3 rounded border bg-muted/20 p-3 sm:grid-cols-2 lg:grid-cols-4">
+            <div class="space-y-1">
+              <div class="text-muted-foreground">{{ t("grid.columnName") }}</div>
+              <div class="font-medium break-all">{{ dialogCellDetail.column }}</div>
+            </div>
+            <div class="space-y-1">
+              <div class="text-muted-foreground">{{ t("grid.rowNumber") }}</div>
+              <div>{{ dialogCellDetail.rowNumber }}</div>
+            </div>
+            <div class="space-y-1">
+              <div class="text-muted-foreground">{{ t("grid.columnType") }}</div>
+              <div :class="dialogCellDetail.type ? typeColorClass(dialogCellDetail.type) : 'text-muted-foreground'">
+                {{ dialogCellDetail.type || "-" }}
+              </div>
+            </div>
+            <div class="space-y-1">
+              <div class="text-muted-foreground">{{ t("grid.valueLength") }}</div>
+              <div>{{ dialogCellDetail.length }}</div>
+            </div>
+          </div>
+
+          <div class="space-y-1">
+            <div class="text-muted-foreground">{{ t("grid.columnComment") }}</div>
+            <div class="whitespace-pre-wrap break-words">
+              {{ dialogCellDetail.comment || t("grid.noComment") }}
+            </div>
+          </div>
+
+          <div class="space-y-2">
+            <div class="flex items-center justify-between gap-2">
+              <div class="text-muted-foreground">{{ t("grid.cellValue") }}</div>
+              <div class="flex items-center gap-1">
+                <Button v-if="dialogCellDetail.formattedJson" :variant="cellDetailJsonView ? 'secondary' : 'ghost'" size="sm" class="h-6 gap-1 px-2 text-xs" :title="t('grid.formattedJson')" @click="toggleCellDetailJsonFormatted">
+                  <Code2 class="h-3 w-3" />
+                  {{ t("grid.formattedJson") }}
+                </Button>
+                <Button v-if="dialogCellDetail.isEditable" variant="ghost" size="icon" class="h-6 w-6" :title="t('grid.editValue')" @click="openDialogCellInSidePanel">
+                  <Pencil class="h-3 w-3" />
+                </Button>
+                <Button variant="ghost" size="icon" class="h-6 w-6" :title="t('grid.copyValue')" @click="copyDialogCellCurrentValue">
+                  <Copy class="h-3 w-3" />
+                </Button>
+                <DropdownMenu v-if="canDownloadDetailBinaryValue(dialogCellDetail)">
+                  <DropdownMenuTrigger as-child>
+                    <Button variant="ghost" size="icon" class="h-6 w-6" :title="t('grid.downloadBinaryValue')">
+                      <Upload class="h-3 w-3" />
+                    </Button>
+                  </DropdownMenuTrigger>
+                  <DropdownMenuContent align="end" class="w-44">
+                    <DropdownMenuItem v-for="mode in BINARY_CELL_DOWNLOAD_MODES" :key="mode" @click="downloadDetailBinaryValue(dialogCellDetail, mode)">
+                      {{ t(`grid.binaryDownload.${mode}`) }}
+                    </DropdownMenuItem>
+                  </DropdownMenuContent>
+                </DropdownMenu>
+                <!-- Skip hex fallback from backend (unsupported geometry types like TIN/Triangle) -->
+                <Popover v-if="isGeometryColumnType(dialogCellDetail.type) && dialogCellDetail.value !== null && !isHexGeometry(dialogCellDetail.value as string)" v-model:open="dialogGeometryPreviewOpen">
+                  <PopoverTrigger as-child>
+                    <Button variant="ghost" size="icon" class="h-6 w-6" :title="t('grid.geometryPreview')">
+                      <Eye class="h-3 w-3" />
+                    </Button>
+                  </PopoverTrigger>
+                  <PopoverContent class="w-auto p-1.5" align="end">
+                    <canvas v-show="dialogGeometryPreviewOpen" ref="dialogGeometryCanvas" width="400" height="280" class="block rounded" />
+                  </PopoverContent>
+                </Popover>
+              </div>
+            </div>
+            <a v-if="dialogCellDetail.imagePreviewUrl" :href="dialogCellDetail.imagePreviewUrl" role="button" class="block max-h-72 overflow-hidden rounded border bg-muted/20" @click.prevent="openImagePreview(dialogCellDetail.imagePreviewUrl, dialogCellDetail.column)">
+              <img :src="dialogCellDetail.imagePreviewUrl" :alt="dialogCellDetail.column" loading="lazy" decoding="async" referrerpolicy="no-referrer" class="max-h-72 w-full object-contain" />
+            </a>
+            <div v-if="cellDetailJsonView && dialogCellDetail.formattedJson" ref="dialogJsonPreviewContainer" data-cell-detail-editor-root class="h-[44vh] min-h-60 overflow-hidden rounded border bg-muted/20 p-3" />
+            <pre v-else class="max-h-[44vh] overflow-auto rounded border bg-muted/20 p-3 font-mono text-xs whitespace-pre-wrap break-words" :class="{ 'italic text-muted-foreground': dialogCellDetail.value === null }">{{ dialogCellDetail.rawValuePreview }}</pre>
+            <div v-if="dialogCellDetail.isValuePreviewTruncated && !cellDetailJsonView" class="text-[11px] text-muted-foreground">
+              {{ t("grid.largeValuePreviewHint", { count: dialogCellDetail.rawValuePreview.length }) }}
+            </div>
+          </div>
+        </div>
+
+        <DialogFooter class="shrink-0 flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
+          <div class="flex flex-wrap gap-2"></div>
+          <Button variant="ghost" size="sm" class="h-7 text-xs" @click="copyDialogCellColumnName"> <Copy class="mr-1.5 h-3 w-3" /> {{ t("grid.copyColumnName") }} </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <Dialog v-model:open="rowDetailDialogOpen">
+      <DialogContent v-if="rowDetail" class="sm:max-w-[960px] max-h-[85vh] flex flex-col overflow-hidden">
+        <DialogHeader class="shrink-0 pr-8">
+          <DialogTitle class="flex min-w-0 items-center gap-2 text-sm">
+            <ListTree class="h-4 w-4 shrink-0 text-muted-foreground" />
+            <span class="min-w-0 truncate">{{ t("grid.rowDetailsFor", { row: rowDetail.rowNumber }) }}</span>
+          </DialogTitle>
+        </DialogHeader>
+
+        <div class="flex shrink-0 items-center gap-2 text-xs text-muted-foreground">
+          <span class="whitespace-nowrap">{{ t("grid.columnsCount", { count: rowDetail.fields.length }) }}</span>
+          <div class="relative ml-auto w-56 max-w-full">
+            <Search class="pointer-events-none absolute left-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+            <Input v-model="rowDetailSearch" :placeholder="t('grid.detailSearchPlaceholder')" class="h-7 pl-7 text-xs" />
+          </div>
+        </div>
+
+        <div class="min-h-0 flex-1 overflow-auto rounded border">
+          <table class="w-full min-w-[640px] text-xs">
+            <thead class="sticky top-0 z-10 bg-muted text-muted-foreground">
+              <tr class="border-b">
+                <th class="w-16 px-3 py-2 text-left font-medium">{{ t("grid.fieldIndex") }}</th>
+                <th class="w-56 px-3 py-2 text-left font-medium">{{ t("grid.columnName") }}</th>
+                <th class="px-3 py-2 text-left font-medium">{{ t("grid.cellValue") }}</th>
+                <th class="w-10 px-2 py-2"></th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="(field, fieldIndex) in filteredRowDetailFields" :key="`${field.colIndex}:${field.column}`" class="border-b align-top last:border-b-0">
+                <td class="px-3 py-2 text-muted-foreground tabular-nums">{{ fieldIndex + 1 }}</td>
+                <td class="px-3 py-2">
+                  <div class="font-medium break-words">{{ field.column }}</div>
+                  <div :class="field.type ? typeColorClass(field.type) : 'text-muted-foreground'" class="mt-1 text-[11px]">
+                    {{ field.type || "-" }}
+                  </div>
+                  <div v-if="field.comment" class="mt-1 text-[11px] text-muted-foreground whitespace-pre-wrap">
+                    {{ field.comment }}
+                  </div>
+                </td>
+                <td class="w-full max-w-0 px-3 py-2">
+                  <div class="mb-1 text-[11px] text-muted-foreground">
+                    {{ field.value === null ? t("grid.nullValue") : t("grid.valueLength") }}:
+                    {{ field.value === null ? "true" : field.length }}
+                  </div>
+                  <a v-if="field.imagePreviewUrl" :href="field.imagePreviewUrl" role="button" class="mb-2 block max-h-48 overflow-hidden rounded border bg-muted/20" @click.prevent="openImagePreview(field.imagePreviewUrl, field.column)">
+                    <img :src="field.imagePreviewUrl" :alt="field.column" loading="lazy" decoding="async" referrerpolicy="no-referrer" class="max-h-48 w-full object-contain" />
+                  </a>
+                  <pre class="max-h-44 overflow-auto rounded border bg-muted/20 p-2 font-mono text-xs whitespace-pre-wrap break-words" :class="{ 'italic text-muted-foreground': field.value === null }">{{ field.rawValuePreview }}</pre>
+                  <div v-if="field.isValuePreviewTruncated" class="mt-1 text-[11px] text-muted-foreground">
+                    {{ t("grid.largeValuePreviewHint", { count: field.rawValuePreview.length }) }}
+                  </div>
+                  <div v-if="field.formattedJson" class="mt-2 space-y-1">
+                    <div class="text-muted-foreground">{{ t("grid.formattedJson") }}</div>
+                    <pre class="max-h-44 overflow-auto rounded border bg-muted/20 p-2 font-mono text-xs whitespace-pre-wrap break-words">{{ field.formattedJson }}</pre>
+                  </div>
+                </td>
+                <td class="px-2 py-2">
+                  <Button variant="ghost" size="icon" class="h-6 w-6" :title="t('grid.copyValue')" @click="copyRowDetailFieldValue(field)">
+                    <Copy class="h-3 w-3" />
+                  </Button>
+                </td>
+              </tr>
+            </tbody>
+          </table>
+          <div v-if="rowDetailSearch && !filteredRowDetailFields.length" class="px-3 py-6 text-center text-xs text-muted-foreground">
+            {{ t("grid.detailSearchNoMatch") }}
+          </div>
+        </div>
+
+        <DialogFooter class="shrink-0 flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
+          <div class="flex flex-wrap gap-2">
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="copyRowDetailJson"> <Copy class="mr-1.5 h-3 w-3" /> {{ t("grid.copyRow") }} </Button>
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="copyRowDetailTsv"> <Copy class="mr-1.5 h-3 w-3" /> {{ t("grid.copyRowTsv") }} </Button>
+          </div>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <Dialog v-model:open="columnDetailDialogOpen">
+      <DialogContent v-if="columnDetail" class="sm:max-w-[900px] max-h-[85vh] flex flex-col overflow-hidden">
+        <DialogHeader class="shrink-0 pr-8">
+          <DialogTitle class="flex min-w-0 items-center gap-2 text-sm">
+            <TableProperties class="h-4 w-4 shrink-0 text-muted-foreground" />
+            <span class="min-w-0 truncate">{{ t("grid.columnDetailsFor", { column: columnDetail.column }) }}</span>
+          </DialogTitle>
+        </DialogHeader>
+
+        <div class="grid shrink-0 gap-3 rounded border bg-muted/20 p-3 text-xs sm:grid-cols-3">
+          <div class="space-y-1">
+            <div class="text-muted-foreground">{{ t("grid.columnName") }}</div>
+            <div class="font-medium break-all">{{ columnDetail.column }}</div>
+          </div>
+          <div class="space-y-1">
+            <div class="text-muted-foreground">{{ t("grid.columnType") }}</div>
+            <div :class="columnDetail.type ? typeColorClass(columnDetail.type) : 'text-muted-foreground'">
+              {{ columnDetail.type || "-" }}
+            </div>
+          </div>
+          <div class="space-y-1">
+            <div class="text-muted-foreground">{{ t("grid.rowCount") }}</div>
+            <div>{{ columnDetail.fields.length }}</div>
+          </div>
+          <div class="space-y-1 sm:col-span-3">
+            <div class="text-muted-foreground">{{ t("grid.columnComment") }}</div>
+            <div class="whitespace-pre-wrap break-words">
+              {{ columnDetail.comment || t("grid.noComment") }}
+            </div>
+          </div>
+        </div>
+
+        <div class="flex shrink-0 items-center gap-2 text-xs text-muted-foreground">
+          <span class="whitespace-nowrap">{{ t("grid.rowCount") }}: {{ columnDetail.fields.length }}</span>
+          <div class="relative ml-auto w-56 max-w-full">
+            <Search class="pointer-events-none absolute left-2 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+            <Input v-model="columnDetailSearch" :placeholder="t('grid.detailSearchPlaceholder')" class="h-7 pl-7 text-xs" />
+          </div>
+        </div>
+
+        <div class="min-h-0 flex-1 overflow-auto rounded border">
+          <table class="w-full min-w-[500px] text-xs">
+            <thead class="sticky top-0 z-10 bg-muted text-muted-foreground">
+              <tr class="border-b">
+                <th class="w-24 px-3 py-2 text-left font-medium">{{ t("grid.rowNumber") }}</th>
+                <th class="px-3 py-2 text-left font-medium">{{ t("grid.cellValue") }}</th>
+                <th class="w-10 px-2 py-2"></th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="field in filteredColumnDetailFields" :key="`${field.rowId}:${field.colIndex}`" class="border-b align-top last:border-b-0">
+                <td class="px-3 py-2 tabular-nums">{{ field.rowNumber }}</td>
+                <td class="w-full max-w-0 px-3 py-2">
+                  <div class="mb-1 text-[11px] text-muted-foreground">
+                    {{ field.value === null ? t("grid.nullValue") : t("grid.valueLength") }}:
+                    {{ field.value === null ? "true" : field.length }}
+                  </div>
+                  <a v-if="field.imagePreviewUrl" :href="field.imagePreviewUrl" role="button" class="mb-2 block max-h-40 overflow-hidden rounded border bg-muted/20" @click.prevent="openImagePreview(field.imagePreviewUrl, field.column)">
+                    <img :src="field.imagePreviewUrl" :alt="field.column" loading="lazy" decoding="async" referrerpolicy="no-referrer" class="max-h-40 w-full object-contain" />
+                  </a>
+                  <pre class="max-h-36 overflow-auto rounded border bg-muted/20 p-2 font-mono text-xs whitespace-pre-wrap break-words" :class="{ 'italic text-muted-foreground': field.value === null }">{{ field.rawValuePreview }}</pre>
+                  <div v-if="field.isValuePreviewTruncated" class="mt-1 text-[11px] text-muted-foreground">
+                    {{ t("grid.largeValuePreviewHint", { count: field.rawValuePreview.length }) }}
+                  </div>
+                  <div v-if="field.formattedJson" class="mt-2 space-y-1">
+                    <div class="text-muted-foreground">{{ t("grid.formattedJson") }}</div>
+                    <pre class="max-h-36 overflow-auto rounded border bg-muted/20 p-2 font-mono text-xs whitespace-pre-wrap break-words">{{ field.formattedJson }}</pre>
+                  </div>
+                </td>
+                <td class="px-2 py-2">
+                  <Button variant="ghost" size="icon" class="h-6 w-6" :title="t('grid.copyValue')" @click="copyColumnDetailFieldValue(field)">
+                    <Copy class="h-3 w-3" />
+                  </Button>
+                </td>
+              </tr>
+            </tbody>
+          </table>
+          <div v-if="columnDetailSearch && !filteredColumnDetailFields.length" class="px-3 py-6 text-center text-xs text-muted-foreground">
+            {{ t("grid.detailSearchNoMatch") }}
+          </div>
+        </div>
+
+        <DialogFooter class="shrink-0 flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
+          <div class="flex flex-wrap gap-2">
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="copyColumnDetailJson"> <Copy class="mr-1.5 h-3 w-3" /> {{ t("grid.copyColumnValues") }} </Button>
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="copyColumnDetailTsv"> <Copy class="mr-1.5 h-3 w-3" /> {{ t("grid.copyColumnTsv") }} </Button>
+          </div>
+          <Button variant="ghost" size="sm" class="h-7 text-xs" @click="copyColumnDetailColumnName"> <Copy class="mr-1.5 h-3 w-3" /> {{ t("grid.copyColumnName") }} </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <Dialog v-model:open="bulkEditDialogOpen">
+      <DialogContent class="sm:max-w-[420px]">
+        <DialogHeader>
+          <DialogTitle>{{ t("grid.bulkEditTitle") }}</DialogTitle>
+        </DialogHeader>
+        <div class="space-y-2">
+          <p class="text-sm text-muted-foreground">
+            {{ t("grid.bulkEditDescription", { count: selectedCellCount }) }}
+          </p>
+          <textarea
+            v-model="bulkEditValue"
+            autocapitalize="off"
+            autocomplete="off"
+            autocorrect="off"
+            spellcheck="false"
+            rows="5"
+            class="min-h-24 w-full min-w-0 resize-y rounded-[6px] border border-input bg-transparent px-2.5 py-1.5 text-base outline-none transition-colors placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 md:text-sm"
+            :placeholder="t('grid.bulkEditValuePlaceholder')"
+            @keydown.ctrl.enter.prevent="applyBulkEditValue"
+            @keydown.meta.enter.prevent="applyBulkEditValue"
+          />
+        </div>
+        <DialogFooter>
+          <Button variant="outline" @click="bulkEditDialogOpen = false">{{ t("dangerDialog.cancel") }}</Button>
+          <Button @click="applyBulkEditValue">{{ t("grid.applyBulkEdit") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <!-- SQL Preview panel for pending data changes -->
+    <div v-if="showSqlPreview" class="h-52 shrink-0 border-t">
+      <SqlPreviewPanel :sql="previewSqlText" :loading="isPreviewLoading" :can-undo="canUndoPendingChange" :can-redo="canRedoPendingChange" @undo="undoGridChange" @redo="redoGridChange" @close="closeSqlPreview" />
+    </div>
+
+    <DangerConfirmDialog
+      v-model:open="showDeleteRowConfirm"
+      :message="pendingDeleteRowIds.length > 1 ? t('dangerDialog.deleteRowsMessage', { count: pendingDeleteRowIds.length }) : t('dangerDialog.deleteRowMessage')"
+      :details="deleteRowDetails"
+      :confirm-label="pendingDeleteRowIds.length > 1 ? t('grid.deleteRows', { count: pendingDeleteRowIds.length }) : t('grid.deleteRow')"
+      @confirm="confirmDeleteRow"
+    />
+    <DangerConfirmDialog
+      v-model:open="showDropMongoIndexConfirm"
+      :title="t('contextMenu.confirmDropIndexTitle')"
+      :message="dropMongoIndexConfirmMessage"
+      :details="dropMongoIndexPreview"
+      :confirm-label="t('contextMenu.dropIndex')"
+      :loading="dropMongoIndexLoading"
+      :close-on-confirm="false"
+      @confirm="confirmDropMongoIndex"
+    />
+    <DangerConfirmDialog
+      v-model:open="showDropAllMongoIndexesConfirm"
+      :title="t('contextMenu.dropAllIndexes')"
+      :message="dropAllMongoIndexesConfirmMessage"
+      :details-text="dropAllMongoIndexesConfirmDetails"
+      :sql="dropAllMongoIndexesPreview"
+      :confirm-label="t('contextMenu.dropAllIndexes')"
+      :loading="dropAllMongoIndexesLoading"
+      :close-on-confirm="false"
+      @confirm="confirmDropAllMongoIndexes"
+    />
+    <ImagePreviewDialog v-model:open="imagePreviewOpen" :src="imagePreviewSrc" :title="imagePreviewTitle" />
+    <component v-if="previewDialogOpen && previewDialogConfig" :is="previewDialogConfig.component" v-model:open="previewDialogOpen" v-bind="previewDialogConfig.props" />
+    <ExportProgressDialog v-model:open="exportProgressDialog" v-bind="exportProgressState" :disable-cancel="!exportCancelHandler" @cancel="cancelActiveExport" />
+  </div>
+</template>
+
+<style scoped>
+@reference "../../styles/globals.css";
+
+[data-grid-root] {
+  --data-grid-row-muted-bg: rgb(248, 248, 248);
+  --data-grid-row-new-bg: rgb(243, 243, 243);
+  --data-grid-row-deleted-bg: rgb(255, 244, 244);
+  --data-grid-cell-active-bg: rgb(232, 232, 232);
+  --data-grid-cell-dirty-bg: rgb(255, 248, 230);
+  --data-grid-cell-selected-bg: rgb(226, 226, 226);
+  --data-grid-cell-selected-dirty-bg: rgb(244, 229, 186);
+  --data-grid-cell-selected-border: rgb(90, 90, 90);
+  --data-grid-cell-hover-bg: rgb(245, 245, 245);
+  --data-grid-cell-search-bg: rgb(253, 245, 184);
+  --data-grid-cell-current-search-bg: rgba(253, 224, 71, 0.52);
+  --data-grid-cell-current-search-border: rgba(234, 179, 8, 0.82);
+  --data-grid-row-number-default-bg: rgb(255, 255, 255);
+  --data-grid-row-number-new-bg: rgb(219, 244, 233);
+  --data-grid-row-number-edited-bg: rgb(253, 241, 219);
+  --data-grid-row-number-deleted-bg: rgb(255, 244, 244);
+  --data-grid-row-number-active-bg: rgb(232, 232, 232);
+  --data-grid-row-number-selected-bg: rgb(226, 226, 226);
+  --data-grid-scrollbar-thumb: color-mix(in oklch, var(--foreground) 30%, transparent);
+  --data-grid-scrollbar-thumb-hover: color-mix(in oklch, var(--foreground) 48%, transparent);
+  --data-grid-scrollbar-track: transparent;
+  background-color: rgb(255, 255, 255);
+}
+
+[data-grid-root].data-grid--dark,
+:global(.dark) [data-grid-root] {
+  --data-grid-row-muted-bg: rgb(32, 32, 34);
+  --data-grid-row-new-bg: rgb(51, 51, 55);
+  --data-grid-row-deleted-bg: rgb(55, 31, 32);
+  --data-grid-cell-active-bg: rgb(64, 64, 64);
+  --data-grid-cell-dirty-bg: rgb(94, 75, 26);
+  --data-grid-cell-selected-bg: rgb(66, 67, 70);
+  --data-grid-cell-selected-dirty-bg: rgb(94, 75, 26);
+  --data-grid-cell-selected-border: rgb(170, 170, 175);
+  --data-grid-cell-hover-bg: rgb(46, 47, 51);
+  --data-grid-cell-search-bg: rgb(72, 57, 8);
+  --data-grid-cell-current-search-bg: rgb(116, 87, 0);
+  --data-grid-cell-current-search-border: rgb(239, 177, 0);
+  --data-grid-row-number-default-bg: rgb(35, 37, 42);
+  --data-grid-row-number-new-bg: rgb(33, 45, 40);
+  --data-grid-row-number-edited-bg: rgb(48, 41, 28);
+  --data-grid-row-number-deleted-bg: rgb(55, 31, 32);
+  --data-grid-row-number-active-bg: rgb(64, 64, 64);
+  --data-grid-row-number-selected-bg: rgb(66, 67, 70);
+  --data-grid-scrollbar-thumb: rgb(82, 82, 91);
+  --data-grid-scrollbar-thumb-hover: rgb(113, 113, 122);
+  --data-grid-scrollbar-track: rgb(24, 24, 27);
+  background-color: rgb(19, 20, 22);
+}
+
+@supports (background: color-mix(in oklab, white 50%, transparent)) {
+  [data-grid-root] {
+    --data-grid-row-muted-bg: color-mix(in oklab, var(--muted) 30%, transparent);
+    --data-grid-row-new-bg: color-mix(in oklab, var(--primary) 5%, transparent);
+    --data-grid-row-deleted-bg: color-mix(in oklab, var(--destructive) 5%, transparent);
+    --data-grid-cell-active-bg: color-mix(in oklab, var(--primary) 15%, transparent);
+    --data-grid-cell-dirty-bg: color-mix(in oklab, rgb(240 177 0) 10%, transparent);
+    --data-grid-cell-selected-bg: color-mix(in oklab, var(--primary) 25%, transparent);
+    --data-grid-cell-selected-dirty-bg: color-mix(in oklab, rgb(234 181 50) 30%, color-mix(in oklab, var(--primary) 18%, transparent));
+    --data-grid-cell-selected-border: color-mix(in oklab, var(--primary) 70%, transparent);
+    --data-grid-cell-hover-bg: color-mix(in oklab, var(--accent) 50%, transparent);
+    --data-grid-row-number-new-bg: color-mix(in oklab, rgb(16 185 129) 15%, var(--background));
+    --data-grid-row-number-edited-bg: color-mix(in oklab, rgb(245 158 11) 15%, var(--background));
+    --data-grid-row-number-deleted-bg: color-mix(in oklab, var(--destructive) 15%, var(--background));
+    --data-grid-row-number-active-bg: color-mix(in oklab, var(--primary) 15%, var(--background));
+    --data-grid-row-number-selected-bg: color-mix(in oklab, var(--primary) 25%, var(--background));
+  }
+}
+
+.data-grid-header-shell,
+.data-grid-header-cell {
+  background-color: rgb(239, 239, 239);
+}
+
+[data-grid-root].data-grid--dark .data-grid-header-shell,
+[data-grid-root].data-grid--dark .data-grid-header-cell,
+:global(.dark) [data-grid-root] .data-grid-header-shell,
+:global(.dark) [data-grid-root] .data-grid-header-cell {
+  background-color: rgb(32, 32, 34) !important;
+}
+
+[data-grid-root].data-grid--dark .data-grid-header-row,
+:global(.dark) [data-grid-root] .data-grid-header-row {
+  color: rgb(215, 215, 219);
+}
+
+[data-grid-root].data-grid--dark .data-grid-header-cell:hover,
+:global(.dark) [data-grid-root] .data-grid-header-cell:hover {
+  background-color: rgb(46, 47, 51) !important;
+}
+
+.data-grid-header-cell--selected {
+  background-color: rgb(209, 213, 219) !important;
+}
+
+:global(.dark) [data-grid-root] {
+  --data-grid-cell-selected-bg: rgb(66, 67, 70);
+  --data-grid-cell-selected-dirty-bg: rgb(94, 75, 26);
+  --data-grid-cell-selected-border: rgb(170, 170, 175);
+  --data-grid-row-number-selected-bg: rgb(66, 67, 70);
+}
+
+[data-grid-root].data-grid--dark .data-grid-header-cell--selected,
+[data-grid-root].data-grid--dark .transpose-record-header-selected,
+[data-grid-root].data-grid--dark .transpose-record-header-active,
+:global(.dark) [data-grid-root] .data-grid-header-cell--selected,
+:global(.dark) [data-grid-root] .transpose-record-header-selected,
+:global(.dark) [data-grid-root] .transpose-record-header-active {
+  background-color: rgb(66, 67, 70) !important;
+  color: rgb(244, 244, 245) !important;
+}
+
+.data-grid-row {
+  background-color: var(--data-grid-cell-bg);
+}
+
+.data-grid-cell {
+  background-color: var(--data-grid-cell-bg);
+}
+
+.data-grid-row-number {
+  background-color: var(--data-grid-row-number-bg);
+}
+
+.data-grid-row--striped {
+  background-color: var(--data-grid-cell-bg);
+}
+
+.data-grid-row--draft,
+.data-grid-row--new {
+  background-color: var(--data-grid-cell-bg);
+}
+
+.data-grid-row--deleted {
+  background-color: var(--data-grid-cell-bg);
+}
+
+:global(.dark) [data-grid-root] .data-grid-row {
+  background-color: var(--data-grid-cell-bg) !important;
+}
+
+:global(.dark) [data-grid-root] .data-grid-row--striped {
+  background-color: var(--data-grid-cell-bg) !important;
+}
+
+:global(.dark) [data-grid-root] .data-grid-row--draft,
+:global(.dark) [data-grid-root] .data-grid-row--new {
+  background-color: var(--data-grid-cell-bg) !important;
+}
+
+:global(.dark) [data-grid-root] .data-grid-row--deleted {
+  background-color: var(--data-grid-cell-bg) !important;
+}
+
+.data-grid-topbar {
+  --data-grid-topbar-transition-duration: 340ms;
+  --data-grid-topbar-transition-easing: cubic-bezier(0.22, 1, 0.36, 1);
+  --data-grid-condition-font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  width: 100%;
+  min-width: 0;
+  transition: min-width var(--data-grid-topbar-transition-duration) var(--data-grid-topbar-transition-easing);
+}
+
+.data-grid-topbar-shell {
+  background-color: color-mix(in oklab, var(--muted) 20%, transparent);
+}
+
+[data-grid-root].data-grid--dark .data-grid-topbar-shell {
+  background-color: rgb(24, 24, 27) !important;
+}
+
+[data-grid-root].data-grid--dark .data-grid-topbar,
+[data-grid-root].data-grid--dark .data-grid-topbar-scroll {
+  background-color: rgb(24, 24, 27) !important;
+}
+
+[data-grid-root].data-grid--dark .data-grid-topbar [class*="bg-muted/"],
+[data-grid-root].data-grid--dark .data-grid-topbar [class*="bg-background/"] {
+  background-color: rgb(31, 31, 35) !important;
+}
+
+[data-grid-root].data-grid--dark .data-grid-topbar [class*="hover:bg-accent"]:hover {
+  background-color: rgb(46, 47, 51) !important;
+}
+
+.data-grid-topbar--compact {
+  min-width: 0;
+}
+
+.data-grid-topbar-condition-label {
+  display: inline-flex;
+  flex-shrink: 0;
+  max-width: 5rem;
+  overflow: hidden;
+  white-space: nowrap;
+  font-family: var(--data-grid-condition-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
+  font-size: 0.875rem;
+  font-weight: 600;
+  line-height: 1.5rem;
+  user-select: none;
+  opacity: 1;
+  transform: translateX(0);
+  transition:
+    max-width var(--data-grid-topbar-transition-duration) var(--data-grid-topbar-transition-easing),
+    opacity 240ms ease 60ms,
+    transform var(--data-grid-topbar-transition-duration) var(--data-grid-topbar-transition-easing),
+    color 240ms ease;
+}
+
+.data-grid-topbar-condition-label--where {
+  color: rgb(37 99 235);
+}
+
+.data-grid-topbar-condition-label--order {
+  color: rgb(234 88 12);
+}
+
+:global(.dark) [data-grid-root] .data-grid-topbar-condition-label--where {
+  color: rgb(96 165 250);
+}
+
+:global(.dark) [data-grid-root] .data-grid-topbar-condition-label--order {
+  color: rgb(251 146 60);
+}
+
+.data-grid-topbar-condition-label--compact {
+  max-width: 0;
+  opacity: 0;
+  transform: translateX(-4px);
+}
+
+.data-grid-topbar-condition-input,
+.data-grid-topbar-condition-measure {
+  font-family: var(--data-grid-condition-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
+  font-size: 0.875rem;
+  line-height: 1.5rem;
+  font-variant-ligatures: none;
+  font-feature-settings:
+    "liga" 0,
+    "calt" 0;
+}
+
+.data-grid-topbar-condition-input {
+  width: 100%;
+  max-width: 100%;
+  box-sizing: border-box;
+  padding: 0 0.125rem;
+  overflow-x: auto;
+  overflow-y: hidden;
+  white-space: pre;
+  border: 0;
+  border-radius: 0;
+  appearance: none;
+  scrollbar-width: none;
+}
+
+[data-grid-root].data-grid--dark .data-grid-topbar-condition-input {
+  color: rgb(244, 244, 245);
+  background-color: transparent !important;
+}
+
+.data-grid-topbar-condition-input::-webkit-scrollbar {
+  display: none;
+}
+
+.data-grid-topbar-condition-icon-control {
+  align-self: center;
+  margin-top: 0;
+}
+
+.data-grid-topbar-condition-floating-controls {
+  top: var(--data-grid-condition-controls-top);
+  will-change: transform;
+}
+
+.data-grid-topbar-condition-pane--expanded {
+  --data-grid-condition-font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+  position: fixed;
+  z-index: 80;
+  right: auto;
+  bottom: auto;
+  box-sizing: border-box;
+  padding: 0.1875rem 0.5rem 0.1875rem 0.5rem;
+  overflow: hidden;
+  background: color-mix(in oklab, var(--background) 96%, var(--muted) 4%);
+  box-shadow:
+    inset 0 -1px 0 var(--border),
+    0 8px 16px rgb(15 23 42 / 8%);
+  transition:
+    height 150ms ease,
+    box-shadow 150ms ease;
+  --data-grid-expanded-scrollbar-offset: 8px;
+  --data-grid-condition-controls-top: 0.125rem;
+  --data-grid-condition-input-top: 0.125rem;
+  --data-grid-condition-prefix-indent: 0px;
+  --data-grid-condition-suffix-width: 0px;
+}
+
+[data-grid-root].data-grid--dark .data-grid-topbar-condition-pane--expanded {
+  background: rgb(24, 24, 27) !important;
+  color: rgb(244, 244, 245);
+  box-shadow:
+    inset 0 -1px 0 rgb(63, 63, 70),
+    0 8px 16px rgb(0 0 0 / 32%);
+}
+
+.data-grid-topbar-condition-input--expanded {
+  top: var(--data-grid-condition-input-top);
+  right: 0.5rem;
+  bottom: 0.125rem;
+  left: 0.5rem;
+  height: auto;
+  line-height: 1.5rem;
+  margin-left: 0;
+  width: calc(100% - 1rem + var(--data-grid-expanded-scrollbar-offset));
+  max-width: none;
+  margin-right: calc(-1 * var(--data-grid-expanded-scrollbar-offset));
+  padding: 0 calc(var(--data-grid-condition-suffix-width) + 0.5rem) 0.0625rem 0.125rem;
+  text-indent: var(--data-grid-condition-prefix-indent);
+  overflow-x: hidden;
+  overflow-y: auto;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  border: 0;
+  border-radius: 0;
+  background: transparent;
+  scrollbar-width: thin;
+}
+
+.data-grid-topbar-condition-input--expanded::-webkit-scrollbar {
+  display: initial;
+  width: 8px;
+}
+
+.data-grid-topbar-condition-input::placeholder {
+  color: transparent;
+  transition: color 240ms ease;
+}
+
+.data-grid-topbar-condition-input--where.data-grid-topbar-condition-input--compact::placeholder {
+  color: rgb(59 130 246 / 70%);
+}
+
+.data-grid-topbar-condition-input--order.data-grid-topbar-condition-input--compact::placeholder {
+  color: rgb(249 115 22 / 70%);
+}
+
+:global(.dark) [data-grid-root] .data-grid-topbar-condition-input--where.data-grid-topbar-condition-input--compact::placeholder {
+  color: rgb(147 197 253 / 70%);
+}
+
+:global(.dark) [data-grid-root] .data-grid-topbar-condition-input--order.data-grid-topbar-condition-input--compact::placeholder {
+  color: rgb(253 186 116 / 70%);
+}
+
+.data-grid-topbar-action-button {
+  align-items: center;
+  justify-content: center;
+  max-width: 9rem;
+  min-width: 1.25rem;
+  gap: 0;
+  line-height: 1;
+  overflow: hidden;
+  transition:
+    max-width var(--data-grid-topbar-transition-duration) var(--data-grid-topbar-transition-easing),
+    min-width var(--data-grid-topbar-transition-duration) var(--data-grid-topbar-transition-easing),
+    padding-inline var(--data-grid-topbar-transition-duration) var(--data-grid-topbar-transition-easing),
+    color 220ms ease,
+    background-color 220ms ease,
+    border-color 220ms ease;
+}
+
+.data-grid-topbar-action-button--compact {
+  max-width: 1.25rem;
+  min-width: 1.25rem;
+  padding-inline: 0;
+}
+
+.data-grid-topbar-action-button--commit.data-grid-topbar-action-button--compact {
+  overflow: visible;
+}
+
+.data-grid-topbar-action-icon {
+  display: block;
+  align-self: center;
+  flex-shrink: 0;
+  transition:
+    margin-inline-end var(--data-grid-topbar-transition-duration) var(--data-grid-topbar-transition-easing),
+    transform var(--data-grid-topbar-transition-duration) var(--data-grid-topbar-transition-easing);
+}
+
+.data-grid-topbar-action-button:not(.data-grid-topbar-action-button--compact) .data-grid-topbar-action-icon {
+  margin-inline-end: 0.25rem;
+}
+
+.data-grid-scroller,
+.data-grid-header-row,
+.data-grid-transpose-header,
+.data-grid-transpose-row {
+  font-size: var(--dbx-table-font-size, 13px);
+}
+
+.data-grid-topbar-action-button--compact .data-grid-topbar-action-icon {
+  margin-inline-end: 0;
+  transform: scale(0.96);
+}
+
+.data-grid-topbar-action-label {
+  display: inline-flex;
+  align-items: center;
+  height: 1rem;
+  max-width: 8rem;
+  overflow: hidden;
+  white-space: nowrap;
+  line-height: 1;
+  opacity: 1;
+  transform: translateX(0);
+  transition:
+    max-width var(--data-grid-topbar-transition-duration) var(--data-grid-topbar-transition-easing),
+    opacity 240ms ease 60ms,
+    transform var(--data-grid-topbar-transition-duration) var(--data-grid-topbar-transition-easing);
+}
+
+.data-grid-topbar-action-label--compact {
+  max-width: 0;
+  opacity: 0;
+  transform: translateX(-4px);
+}
+
+.data-grid-topbar-scroll {
+  scrollbar-width: none;
+  scrollbar-gutter: auto;
+}
+
+.data-grid-topbar-scroll::-webkit-scrollbar {
+  display: none;
+}
+
+.data-grid-scroller {
+  overflow-anchor: none;
+  overscroll-behavior: none;
+  overscroll-behavior-x: none;
+  overscroll-behavior-y: none;
+  scrollbar-gutter: stable;
+  will-change: scroll-position;
+  contain: layout style paint;
+  scrollbar-width: none;
+}
+
+.data-grid-scroller::-webkit-scrollbar {
+  display: none;
+}
+
+.canvas-grid-scroller.has-horizontal-scrollbar {
+  margin-bottom: 10px;
+  box-shadow: 0 10px 0 0 rgb(255, 255, 255);
+}
+
+.canvas-grid-scroller {
+  background-color: rgb(255, 255, 255);
+}
+
+[data-grid-root].data-grid--dark .canvas-grid-scroller,
+:global(.dark) [data-grid-root] .canvas-grid-scroller {
+  background-color: rgb(19, 20, 22) !important;
+}
+
+[data-grid-root].data-grid--dark .canvas-grid-scroller.has-horizontal-scrollbar,
+:global(.dark) [data-grid-root] .canvas-grid-scroller.has-horizontal-scrollbar {
+  box-shadow: 0 10px 0 0 rgb(19, 20, 22);
+}
+
+.data-grid-scroller.has-horizontal-scrollbar:not(.canvas-grid-scroller) {
+  padding-bottom: 10px;
+}
+
+.data-grid-scroller:not(.canvas-grid-scroller) {
+  background-color: rgb(255, 255, 255);
+}
+
+[data-grid-root].data-grid--dark .data-grid-scroller:not(.canvas-grid-scroller),
+:global(.dark) [data-grid-root] .data-grid-scroller:not(.canvas-grid-scroller) {
+  background-color: rgb(19, 20, 22) !important;
+}
+
+.data-grid-scroller:not(.canvas-grid-scroller) :deep(.vue-recycle-scroller__item-wrapper),
+.data-grid-scroller:not(.canvas-grid-scroller) :deep(.vue-recycle-scroller__item-view) {
+  background-color: rgb(255, 255, 255);
+}
+
+[data-grid-root].data-grid--dark .data-grid-scroller:not(.canvas-grid-scroller) :deep(.vue-recycle-scroller__item-wrapper),
+[data-grid-root].data-grid--dark .data-grid-scroller:not(.canvas-grid-scroller) :deep(.vue-recycle-scroller__item-view),
+:global(.dark) [data-grid-root] .data-grid-scroller:not(.canvas-grid-scroller) :deep(.vue-recycle-scroller__item-wrapper),
+:global(.dark) [data-grid-root] .data-grid-scroller:not(.canvas-grid-scroller) :deep(.vue-recycle-scroller__item-view) {
+  background-color: rgb(19, 20, 22) !important;
+}
+
+.data-grid-scroller :deep(.vue-recycle-scroller__item-wrapper) {
+  min-width: var(--total-w);
+  overflow: visible;
+}
+
+[data-grid-root].data-grid--dark .data-grid-scroller :deep(.vue-recycle-scroller__item-wrapper),
+[data-grid-root].data-grid--dark .data-grid-scroller :deep(.vue-recycle-scroller__item-view) {
+  background-color: rgb(19, 20, 22) !important;
+}
+
+.data-grid-scroller :deep(.vue-recycle-scroller__item-view) {
+  contain: layout style paint;
+}
+
+[data-grid-root].data-grid--editing-cell .data-grid-scroller :deep(.vue-recycle-scroller__item-view),
+[data-grid-root].data-grid--editing-cell .transpose-grid-scroller :deep(.vue-recycle-scroller__item-view) {
+  contain: layout style;
+  overflow: visible;
+}
+
+[data-grid-root] .data-grid-scroller :deep(.vue-recycle-scroller__item-view:has(.cell-edit-input--expanded)),
+[data-grid-root] .transpose-grid-scroller :deep(.vue-recycle-scroller__item-view:has(.cell-edit-input--expanded)) {
+  z-index: 80 !important;
+  overflow: visible;
+}
+
+.data-grid-scroller.is-scrolling :deep(.vue-recycle-scroller__item-view) {
+  pointer-events: none;
+}
+
+.data-grid-horizontal-scrollbar {
+  position: absolute;
+  inset-inline: calc(var(--row-num-w) + 8px) 4px;
+  bottom: 0;
+  z-index: 30;
+  height: 10px;
+  cursor: pointer;
+  touch-action: none;
+  background-color: rgb(255, 255, 255);
+}
+
+[data-grid-root].data-grid--dark .data-grid-horizontal-scrollbar,
+:global(.dark) [data-grid-root] .data-grid-horizontal-scrollbar {
+  background-color: rgb(19, 20, 22) !important;
+}
+
+.data-grid-horizontal-scrollbar::before {
+  content: "";
+  position: absolute;
+  inset-inline: 0;
+  top: 4px;
+  height: 2px;
+  border-radius: 999px;
+  background: var(--data-grid-scrollbar-track);
+}
+
+.data-grid-horizontal-scrollbar__thumb {
+  position: absolute;
+  top: 3px;
+  height: 4px;
+  min-width: 24px;
+  border-radius: 999px;
+  background: var(--data-grid-scrollbar-thumb);
+  transition:
+    height 120ms ease,
+    background-color 120ms ease,
+    top 120ms ease;
+}
+
+.data-grid-horizontal-scrollbar:hover .data-grid-horizontal-scrollbar__thumb,
+.data-grid-horizontal-scrollbar--dragging .data-grid-horizontal-scrollbar__thumb {
+  top: 2px;
+  height: 6px;
+  background: var(--data-grid-scrollbar-thumb-hover);
+}
+
+.data-grid-vertical-scrollbar {
+  position: absolute;
+  top: 10px;
+  right: 2px;
+  bottom: 14px;
+  z-index: 30;
+  width: 10px;
+  cursor: pointer;
+  touch-action: none;
+}
+
+:global(.dark) [data-grid-root] .data-grid-vertical-scrollbar {
+  background-color: rgb(19, 20, 22);
+}
+
+.data-grid-vertical-scrollbar__thumb {
+  position: absolute;
+  left: 3px;
+  width: 4px;
+  min-height: 24px;
+  border-radius: 999px;
+  background: var(--data-grid-scrollbar-thumb);
+  transition:
+    background-color 120ms ease,
+    left 120ms ease,
+    width 120ms ease;
+}
+
+.data-grid-vertical-scrollbar:hover .data-grid-vertical-scrollbar__thumb,
+.data-grid-vertical-scrollbar--dragging .data-grid-vertical-scrollbar__thumb {
+  left: 2px;
+  width: 6px;
+  background: var(--data-grid-scrollbar-thumb-hover);
+}
+
+.canvas-grid-surface {
+  cursor: cell;
+  font-family: var(--dbx-data-grid-font-family);
+  font-size: var(--dbx-table-font-size, 13px);
+  font-weight: 400;
+  line-height: 1rem;
+  outline: none;
+}
+
+.cell-edit-input {
+  font-family: inherit;
+  font-size: var(--dbx-table-font-size, 13px);
+}
+
+.cell-edit-input--expanded {
+  left: 7px;
+  width: calc(100% - 14px);
+  min-height: var(--cell-edit-min-height, 54px);
+  max-height: var(--cell-edit-max-height, calc(9.5lh + 10px));
+  overflow-y: auto;
+  scrollbar-width: thin;
+  scrollbar-color: color-mix(in oklab, var(--foreground) 24%, transparent) transparent;
+  resize: none;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  background-color: var(--background);
+  background-color: color-mix(in oklab, var(--background) 96%, var(--primary) 4%);
+  border: 1px solid color-mix(in oklab, var(--primary) 62%, var(--border));
+  border-radius: 6px;
+  z-index: 90;
+  box-shadow:
+    0 28px 72px rgb(0 0 0 / 34%),
+    0 12px 30px rgb(0 0 0 / 24%),
+    0 3px 10px rgb(0 0 0 / 18%),
+    0 0 0 1px var(--background),
+    inset 0 0 0 1px color-mix(in oklab, var(--background) 70%, transparent);
+}
+
+:global(.dark) .cell-edit-input--expanded {
+  box-shadow:
+    0 0 0 1px color-mix(in oklab, var(--foreground) 26%, transparent),
+    0 0 34px color-mix(in oklab, var(--foreground) 24%, transparent),
+    0 0 70px color-mix(in oklab, var(--foreground) 14%, transparent),
+    0 24px 64px rgb(0 0 0 / 42%),
+    inset 0 0 0 1px color-mix(in oklab, var(--background) 58%, transparent);
+}
+
+.cell-edit-input--expanded::-webkit-scrollbar {
+  width: 4px;
+}
+
+.cell-edit-input--expanded::-webkit-scrollbar-thumb {
+  border-radius: 999px;
+  background: color-mix(in oklab, var(--foreground) 24%, transparent);
+}
+
+.cell-edit-input--expanded:hover::-webkit-scrollbar-thumb,
+.cell-edit-input--expanded:focus::-webkit-scrollbar-thumb {
+  background: color-mix(in oklab, var(--foreground) 42%, transparent);
+}
+
+.cell-edit-input--expanded:hover::-webkit-scrollbar,
+.cell-edit-input--expanded:focus::-webkit-scrollbar {
+  width: 6px;
+}
+
+.canvas-grid-overlay {
+  pointer-events: none;
+}
+
+.transpose-grid-scroller {
+  overflow-anchor: none;
+  scrollbar-gutter: stable;
+  will-change: scroll-position;
+}
+
+.transpose-grid-scroller :deep(.vue-recycle-scroller__item-wrapper) {
+  min-width: var(--transpose-total-w);
+  overflow: visible;
+}
+
+.transpose-grid-scroller :deep(.vue-recycle-scroller__item-view) {
+  contain: layout style paint;
+}
+
+.transpose-grid-scroller.is-scrolling :deep(.vue-recycle-scroller__item-view) {
+  pointer-events: none;
+}
+
+.ddl-drawer-resizing {
+  transition: none;
+}
+
+.table-info-drawer {
+  container-type: inline-size;
+}
+
+.table-info-action-button {
+  gap: 0.25rem;
+  max-width: 8rem;
+  overflow: hidden;
+  transition:
+    max-width 180ms ease,
+    padding-inline 180ms ease;
+}
+
+.table-info-action-label {
+  min-width: 0;
+  max-width: 6rem;
+  overflow: hidden;
+  white-space: nowrap;
+  opacity: 1;
+  transition:
+    max-width 180ms ease,
+    opacity 120ms ease;
+}
+
+@container (max-width: 360px) {
+  .table-info-action-button {
+    width: 1.5rem;
+    max-width: 1.5rem;
+    padding-inline: 0;
+  }
+
+  .table-info-action-label {
+    max-width: 0;
+    opacity: 0;
+  }
+}
+
+.detail-drawer-resizing {
+  transition: none;
+}
+
+.row-cell-selected {
+  background-color: var(--data-grid-cell-selected-bg) !important;
+  outline: 1px solid var(--data-grid-cell-selected-border);
+  outline-offset: -1px;
+}
+
+.cell-dirty {
+  background-color: var(--data-grid-cell-dirty-bg) !important;
+}
+
+.cell-search-match {
+  background-color: var(--data-grid-cell-search-bg) !important;
+}
+
+.cell-current-search-match {
+  background-color: var(--data-grid-cell-current-search-bg) !important;
+  box-shadow: inset 0 0 0 2px var(--data-grid-cell-current-search-border);
+}
+
+.transpose-record-header-selected {
+  background-color: var(--data-grid-row-number-selected-bg);
+  outline: 1px solid var(--data-grid-cell-selected-border);
+  outline-offset: -1px;
+}
+
+.transpose-record-header-active {
+  background-color: var(--data-grid-row-number-selected-bg);
+}
+
+.cell-selected-dirty {
+  background-color: var(--data-grid-cell-selected-dirty-bg) !important;
+  outline: 1px solid var(--data-grid-cell-selected-border);
+  outline-offset: -1px;
+}
+
+.row-cell-selected-dirty {
+  background-color: var(--data-grid-cell-selected-dirty-bg) !important;
+  outline: 1px solid var(--data-grid-cell-selected-border);
+  outline-offset: -1px;
+}
+
+.data-grid-row-number.bg-emerald-500\/15 {
+  background-color: var(--data-grid-row-number-new-bg);
+}
+
+.data-grid-row-number.bg-amber-500\/15 {
+  background-color: var(--data-grid-row-number-edited-bg);
+}
+
+.data-grid-row-number.bg-destructive\/15 {
+  background-color: var(--data-grid-row-number-deleted-bg);
+}
+
+.active-row > .data-grid-row-number {
+  background-color: var(--data-grid-row-number-active-bg) !important;
+}
+
+.cell-selected {
+  color: hsl(var(--foreground));
+  background-color: var(--data-grid-cell-selected-bg) !important;
+}
+
+.cell-selected {
+  @apply outline outline-primary -outline-offset-1;
+}
+
+:global(.dark) [data-grid-root] .cell-selected,
+:global(.dark) [data-grid-root] .row-cell-selected {
+  color: rgb(244, 244, 245) !important;
+  background-color: rgb(66, 67, 70) !important;
+}
+
+:global(.dark) [data-grid-root] .cell-selected-dirty,
+:global(.dark) [data-grid-root] .row-cell-selected-dirty {
+  background-color: rgb(94, 75, 26) !important;
+}
+
+:global(.dark) [data-grid-root] .cell-selected,
+:global(.dark) [data-grid-root] .row-cell-selected,
+:global(.dark) [data-grid-root] .cell-selected-dirty,
+:global(.dark) [data-grid-root] .row-cell-selected-dirty {
+  outline-color: rgb(170, 170, 175) !important;
+}
+
+.ddl-code :deep(.ddl-kw) {
+  color: rgb(39 132 213);
+  color: oklch(0.6 0.15 250);
+  font-weight: 600;
+}
+
+.ddl-code :deep(.ddl-ident) {
+  color: rgb(58 168 91);
+  color: oklch(0.65 0.15 150);
+}
+
+.ddl-code :deep(.ddl-str) {
+  color: rgb(213 111 44);
+  color: oklch(0.65 0.15 50);
+}
+</style>
diff --git a/apps/desktop/src/components/grid/EnumCellEditor.vue b/apps/desktop/src/components/grid/EnumCellEditor.vue
new file mode 100644
index 0000000..1d0f26b
--- /dev/null
+++ b/apps/desktop/src/components/grid/EnumCellEditor.vue
@@ -0,0 +1,118 @@
+<script setup lang="ts">
+import { computed, nextTick, onMounted, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import type { FocusOutsideEvent, PointerDownOutsideEvent } from "reka-ui";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+
+const props = withDefaults(
+  defineProps<{
+    modelValue: string;
+    values: string[];
+    nullable?: boolean;
+    initialNull?: boolean;
+    cellLayout?: "grid" | "transpose";
+  }>(),
+  {
+    nullable: false,
+    initialNull: false,
+    cellLayout: "grid",
+  },
+);
+
+const emit = defineEmits<{
+  "update:modelValue": [value: string];
+  commit: [value?: string | null];
+  cancel: [];
+}>();
+
+const { t } = useI18n();
+
+const open = ref(true);
+const triggerRef = ref<HTMLButtonElement | null>(null);
+let closeHandled = false;
+
+const triggerClass = computed(() => ["cell-edit-input absolute inset-0 z-10 flex items-center gap-1 border-2 border-primary bg-background py-0 text-left text-xs outline-none", props.cellLayout === "transpose" ? "px-1.5" : "px-2.5"].join(" "));
+
+const displayValue = computed(() => {
+  if (props.initialNull && props.modelValue === "") return t("grid.nullValue");
+  return props.modelValue === "" ? "''" : props.modelValue;
+});
+
+onMounted(() => {
+  nextTick(() => triggerRef.value?.focus());
+});
+
+function selectValue(value: string | null) {
+  if (value !== null) emit("update:modelValue", value);
+  finishCommit(value);
+}
+
+function finishCommit(value?: string | null) {
+  closeHandled = true;
+  emit("commit", value);
+}
+
+function finishCancel() {
+  closeHandled = true;
+  emit("cancel");
+}
+
+function onKeydown(event: KeyboardEvent) {
+  if (event.key === "Enter") {
+    event.preventDefault();
+    finishCommit();
+  } else if (event.key === "Escape") {
+    event.preventDefault();
+    event.stopPropagation();
+    finishCancel();
+  }
+}
+
+function onPopoverInteractOutside(event: PointerDownOutsideEvent | FocusOutsideEvent) {
+  const originalEvent = event.detail.originalEvent;
+  if (originalEvent instanceof FocusEvent) {
+    event.preventDefault();
+    return;
+  }
+  finishCommit();
+}
+</script>
+
+<template>
+  <Popover
+    :open="open"
+    @update:open="
+      (v) => {
+        open = v;
+        if (!v && !closeHandled) finishCommit();
+      }
+    "
+  >
+    <PopoverTrigger as-child>
+      <button ref="triggerRef" type="button" :class="triggerClass" @keydown.stop="onKeydown" @click.stop>
+        <span class="min-w-0 flex-1 truncate">{{ displayValue }}</span>
+      </button>
+    </PopoverTrigger>
+    <PopoverContent align="start" side="bottom" class="w-auto min-w-[120px] rounded-md p-1" @click.stop @keydown.stop="onKeydown" @interact-outside="onPopoverInteractOutside">
+      <div class="flex flex-col gap-0.5">
+        <button v-if="nullable" type="button" class="flex min-h-7 w-full items-center rounded-sm px-2 py-1 text-left text-xs italic text-muted-foreground hover:bg-accent hover:text-accent-foreground" :class="{ 'bg-accent text-accent-foreground': initialNull }" @click="selectValue(null)">
+          {{ t("grid.nullValue") }}
+        </button>
+        <button
+          v-for="val in values"
+          :key="val"
+          type="button"
+          class="flex min-h-7 w-full items-center rounded-sm px-2 py-1 text-left text-xs hover:bg-accent hover:text-accent-foreground"
+          :class="{ 'bg-accent text-accent-foreground': modelValue === val && !(initialNull && val === '') }"
+          @click="selectValue(val)"
+        >
+          <template v-if="val === ''">
+            <code>''</code>
+            <span class="ml-2 text-muted-foreground">{{ t("grid.emptyStringValue") }}</span>
+          </template>
+          <template v-else>{{ val }}</template>
+        </button>
+      </div>
+    </PopoverContent>
+  </Popover>
+</template>
diff --git a/apps/desktop/src/components/grid/ImagePreviewDialog.vue b/apps/desktop/src/components/grid/ImagePreviewDialog.vue
new file mode 100644
index 0000000..973535c
--- /dev/null
+++ b/apps/desktop/src/components/grid/ImagePreviewDialog.vue
@@ -0,0 +1,265 @@
+<script setup lang="ts">
+import { computed, onMounted, onUnmounted, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { ExternalLink, Maximize2, X, ZoomIn, ZoomOut } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogTitle } from "@/components/ui/dialog";
+import { imagePreviewDialogSize, imagePreviewFitScale, imagePreviewTransform, nextImagePreviewScale } from "@/lib/dataGrid/imagePreviewViewer";
+
+const props = defineProps<{
+  open: boolean;
+  src: string;
+  title?: string;
+}>();
+
+const emit = defineEmits<{
+  "update:open": [open: boolean];
+}>();
+
+const { t } = useI18n();
+const scale = ref(1);
+const offsetX = ref(0);
+const offsetY = ref(0);
+const imageLoaded = ref(false);
+const imageError = ref(false);
+const stageRef = ref<HTMLElement>();
+const naturalWidth = ref(0);
+const naturalHeight = ref(0);
+const viewportWidth = ref(typeof window === "undefined" ? 0 : window.innerWidth);
+const viewportHeight = ref(typeof window === "undefined" ? 0 : window.innerHeight);
+const dragStart = ref<{ x: number; y: number; offsetX: number; offsetY: number } | null>(null);
+
+const hostLabel = computed(() => {
+  try {
+    const url = new URL(props.src);
+    return url.protocol === "data:" ? "data:image" : url.host;
+  } catch {
+    return "";
+  }
+});
+
+const imageTitle = computed(() => props.title || t("grid.imagePreview"));
+const zoomLabel = computed(() => `${Math.round(scale.value * 100)}%`);
+const canOpenExternal = computed(() => !props.src.startsWith("data:"));
+const imageStyle = computed(() => ({
+  width: naturalWidth.value ? `${naturalWidth.value}px` : "auto",
+  height: naturalHeight.value ? `${naturalHeight.value}px` : "auto",
+  transform: `translate(-50%, -50%) ${imagePreviewTransform({
+    scale: scale.value,
+    offsetX: offsetX.value,
+    offsetY: offsetY.value,
+  })}`,
+}));
+const dialogSize = computed(() =>
+  imagePreviewDialogSize({
+    imageWidth: naturalWidth.value,
+    imageHeight: naturalHeight.value,
+    viewportWidth: viewportWidth.value,
+    viewportHeight: viewportHeight.value,
+  }),
+);
+const dialogStyle = computed(() => ({
+  width: dialogSize.value ? `${dialogSize.value.width}px` : "min(92vw, 1280px)",
+  height: dialogSize.value ? `${dialogSize.value.height}px` : "min(86vh, 720px)",
+  maxWidth: "92vw",
+  maxHeight: "86vh",
+}));
+
+function updateViewportSize() {
+  viewportWidth.value = window.innerWidth;
+  viewportHeight.value = window.innerHeight;
+}
+
+function resetViewer() {
+  scale.value = 1;
+  offsetX.value = 0;
+  offsetY.value = 0;
+  imageLoaded.value = false;
+  imageError.value = false;
+  naturalWidth.value = 0;
+  naturalHeight.value = 0;
+  dragStart.value = null;
+}
+
+function close() {
+  emit("update:open", false);
+}
+
+function zoomIn() {
+  scale.value = nextImagePreviewScale(scale.value, "in");
+}
+
+function zoomOut() {
+  scale.value = nextImagePreviewScale(scale.value, "out");
+}
+
+function fitImage() {
+  scale.value = currentFitScale();
+  offsetX.value = 0;
+  offsetY.value = 0;
+}
+
+function currentFitScale(): number {
+  const stage = stageRef.value;
+  if (!stage) return 1;
+  return imagePreviewFitScale({
+    imageWidth: naturalWidth.value,
+    imageHeight: naturalHeight.value,
+    viewportWidth: stage.clientWidth,
+    viewportHeight: stage.clientHeight,
+  });
+}
+
+function onImageLoad(event: Event) {
+  const img = event.currentTarget as HTMLImageElement;
+  naturalWidth.value = img.naturalWidth;
+  naturalHeight.value = img.naturalHeight;
+  imageLoaded.value = true;
+  requestAnimationFrame(fitImage);
+}
+
+function onWheel(event: WheelEvent) {
+  event.preventDefault();
+  scale.value = nextImagePreviewScale(scale.value, event.deltaY < 0 ? "in" : "out");
+}
+
+function onImagePointerDown(event: PointerEvent) {
+  if (event.button !== 0) return;
+  dragStart.value = { x: event.clientX, y: event.clientY, offsetX: offsetX.value, offsetY: offsetY.value };
+  (event.currentTarget as HTMLElement).setPointerCapture(event.pointerId);
+}
+
+function onImagePointerMove(event: PointerEvent) {
+  if (!dragStart.value) return;
+  offsetX.value = dragStart.value.offsetX + event.clientX - dragStart.value.x;
+  offsetY.value = dragStart.value.offsetY + event.clientY - dragStart.value.y;
+}
+
+function onImagePointerUp(event: PointerEvent) {
+  dragStart.value = null;
+  (event.currentTarget as HTMLElement).releasePointerCapture(event.pointerId);
+}
+
+function onDoubleClick() {
+  scale.value = scale.value === 1 ? 2 : 1;
+  offsetX.value = 0;
+  offsetY.value = 0;
+}
+
+async function openExternal() {
+  try {
+    const { open } = await import("@tauri-apps/plugin-shell");
+    await open(props.src);
+  } catch {
+    window.open(props.src, "_blank", "noopener,noreferrer");
+  }
+}
+
+watch(
+  () => [props.open, props.src] as const,
+  ([open]) => {
+    if (open) {
+      updateViewportSize();
+      resetViewer();
+    }
+  },
+);
+
+watch([viewportWidth, viewportHeight], () => {
+  if (props.open && imageLoaded.value) fitImage();
+});
+
+onMounted(() => {
+  window.addEventListener("resize", updateViewportSize);
+});
+
+onUnmounted(() => {
+  window.removeEventListener("resize", updateViewportSize);
+});
+</script>
+
+<template>
+  <Dialog :open="open" @update:open="(value) => emit('update:open', value)">
+    <DialogContent
+      :show-close-button="false"
+      overlay-class="!z-[80]"
+      portal-class="!z-[81]"
+      class="image-preview-dialog !flex !max-w-[92vw] flex-col gap-0 overflow-hidden rounded-xl border-white/10 bg-[#090b0f] p-0 text-white shadow-2xl sm:!max-w-[92vw]"
+      :style="dialogStyle"
+      @escape-key-down="close"
+    >
+      <div class="flex h-12 shrink-0 items-center gap-3 border-b border-white/10 bg-white/[0.035] px-4">
+        <div class="min-w-0 flex-1">
+          <DialogTitle class="truncate text-sm font-semibold text-white">{{ imageTitle }}</DialogTitle>
+          <div class="truncate text-[11px] text-white/45">{{ hostLabel || src }}</div>
+        </div>
+        <div class="flex items-center gap-1 rounded-md border border-white/10 bg-black/20 p-1">
+          <Button variant="ghost" size="icon" class="h-7 w-7 text-white/75 hover:bg-white/10 hover:text-white" :title="t('grid.zoomOut')" @click="zoomOut">
+            <ZoomOut class="h-3.5 w-3.5" />
+          </Button>
+          <div class="w-12 text-center text-[11px] tabular-nums text-white/65">{{ zoomLabel }}</div>
+          <Button variant="ghost" size="icon" class="h-7 w-7 text-white/75 hover:bg-white/10 hover:text-white" :title="t('grid.zoomIn')" @click="zoomIn">
+            <ZoomIn class="h-3.5 w-3.5" />
+          </Button>
+          <Button variant="ghost" size="icon" class="h-7 w-7 text-white/75 hover:bg-white/10 hover:text-white" :title="t('grid.fitImage')" @click="fitImage">
+            <Maximize2 class="h-3.5 w-3.5" />
+          </Button>
+          <Button v-if="canOpenExternal" variant="ghost" size="icon" class="h-7 w-7 text-white/75 hover:bg-white/10 hover:text-white" :title="t('grid.openImage')" @click="openExternal">
+            <ExternalLink class="h-3.5 w-3.5" />
+          </Button>
+        </div>
+        <Button variant="ghost" size="icon" class="h-8 w-8 text-white/70 hover:bg-white/10 hover:text-white" :title="t('dangerDialog.cancel')" @click="close">
+          <X class="h-4 w-4" />
+        </Button>
+      </div>
+
+      <div ref="stageRef" class="image-preview-stage relative min-h-0 flex-1 overflow-hidden" :class="{ 'cursor-grabbing': dragStart, 'cursor-grab': !dragStart && imageLoaded && !imageError }" @wheel="onWheel">
+        <div v-if="!imageLoaded && !imageError" class="absolute inset-0 flex items-center justify-center">
+          <div class="h-16 w-16 animate-pulse rounded-full border border-white/10 bg-white/10 shadow-[0_0_80px_rgba(255,255,255,0.12)]" />
+        </div>
+        <div v-if="imageError" class="absolute inset-0 flex items-center justify-center px-8 text-center text-sm text-white/55">
+          {{ t("grid.imageLoadFailed") }}
+        </div>
+        <img
+          v-show="!imageError"
+          :src="src"
+          :alt="imageTitle"
+          draggable="false"
+          decoding="async"
+          referrerpolicy="no-referrer"
+          class="absolute left-1/2 top-1/2 max-w-none select-none object-contain transition-opacity duration-150"
+          :class="{ 'opacity-100': imageLoaded, 'opacity-0': !imageLoaded }"
+          :style="imageStyle"
+          @load="onImageLoad"
+          @error="imageError = true"
+          @pointerdown="onImagePointerDown"
+          @pointermove="onImagePointerMove"
+          @pointerup="onImagePointerUp"
+          @pointercancel="onImagePointerUp"
+          @dblclick="onDoubleClick"
+        />
+      </div>
+    </DialogContent>
+  </Dialog>
+</template>
+
+<style scoped>
+.image-preview-stage {
+  background-color: #07090d;
+  background-image:
+    linear-gradient(45deg, rgba(255, 255, 255, 0.055) 25%, transparent 25%), linear-gradient(-45deg, rgba(255, 255, 255, 0.055) 25%, transparent 25%), linear-gradient(45deg, transparent 75%, rgba(255, 255, 255, 0.055) 75%), linear-gradient(-45deg, transparent 75%, rgba(255, 255, 255, 0.055) 75%),
+    radial-gradient(circle at 50% 30%, rgba(255, 255, 255, 0.08), transparent 42%);
+  background-position:
+    0 0,
+    0 12px,
+    12px -12px,
+    -12px 0,
+    center;
+  background-size:
+    24px 24px,
+    24px 24px,
+    24px 24px,
+    24px 24px,
+    100% 100%;
+}
+</style>
diff --git a/apps/desktop/src/components/grid/LayerPreviewDialog.vue b/apps/desktop/src/components/grid/LayerPreviewDialog.vue
new file mode 100644
index 0000000..0e665ee
--- /dev/null
+++ b/apps/desktop/src/components/grid/LayerPreviewDialog.vue
@@ -0,0 +1,523 @@
+<script setup lang="ts">
+import { computed, ref, watch, onBeforeUnmount, nextTick } from "vue";
+import { useI18n } from "vue-i18n";
+import { Camera, Loader2, Map, Maximize2, Minimize2, X } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogTitle } from "@/components/ui/dialog";
+import "leaflet/dist/leaflet.css";
+import type L from "leaflet";
+
+const props = defineProps<{
+  open: boolean;
+  title?: string;
+  geojson: string;
+}>();
+
+const emit = defineEmits<{
+  "update:open": [open: boolean];
+}>();
+
+const { t } = useI18n();
+const mapContainer = ref<HTMLDivElement>();
+const mapError = ref<string>("");
+const isExporting = ref(false);
+
+// ── Resize / maximise ──────────────────────────────────────────────────────
+const customSize = ref<{ w: number; h: number } | null>(null);
+const isMaximized = ref(false);
+type ResizeEdge = "e" | "s" | "se";
+let _resizeEdge: ResizeEdge | null = null;
+let _resizeStart: { x: number; y: number; w: number; h: number } | null = null;
+
+const contentStyle = computed(() => {
+  if (isMaximized.value)
+    return {
+      width: "100vw",
+      height: "100vh",
+      maxWidth: "none",
+      maxHeight: "none",
+    };
+  if (customSize.value)
+    return {
+      width: `${customSize.value.w}px`,
+      height: `${customSize.value.h}px`,
+      maxWidth: "none",
+      maxHeight: "none",
+    };
+  return {};
+});
+
+function toggleMaximize() {
+  isMaximized.value = !isMaximized.value;
+}
+
+function onResizePointerDown(event: PointerEvent, edge: ResizeEdge) {
+  const el = (event.currentTarget as HTMLElement).closest("[data-slot='dialog-content']") as HTMLElement;
+  if (!el) return;
+  _resizeEdge = edge;
+  const rect = el.getBoundingClientRect();
+  _resizeStart = {
+    x: event.clientX,
+    y: event.clientY,
+    w: rect.width,
+    h: rect.height,
+  };
+  (event.target as HTMLElement).setPointerCapture(event.pointerId);
+  event.preventDefault();
+}
+
+function onResizePointerMove(event: PointerEvent) {
+  if (!_resizeStart || !_resizeEdge) return;
+  const dx = event.clientX - _resizeStart.x;
+  const dy = event.clientY - _resizeStart.y;
+  let w = _resizeStart.w;
+  let h = _resizeStart.h;
+  if (_resizeEdge === "e" || _resizeEdge === "se") w += dx;
+  if (_resizeEdge === "s" || _resizeEdge === "se") h += dy;
+  w = Math.max(640, Math.min(w, window.innerWidth - 32));
+  h = Math.max(400, Math.min(h, window.innerHeight - 32));
+  customSize.value = { w, h };
+}
+
+function onResizePointerUp() {
+  _resizeEdge = null;
+  _resizeStart = null;
+}
+
+// ── Leaflet ───────────────────────────────────────────────────────────────
+let _L: typeof L | null = null;
+let map: L.Map | null = null;
+let geoLayer: L.GeoJSON | null = null;
+let labelLayer: L.LayerGroup | null = null;
+let tileLayer: L.TileLayer | null = null;
+let mapResizeObserver: ResizeObserver | null = null;
+let _geojsonData: any = null;
+
+async function loadLeaflet(): Promise<typeof L> {
+  if (!_L) {
+    console.log("[LayerPreview] dynamic import leaflet…");
+    const mod = await import("leaflet");
+    _L = mod.default as unknown as typeof L;
+    console.log("[LayerPreview] leaflet loaded, L.version =", (_L as any).version);
+  }
+  return _L;
+}
+
+interface BasemapOption {
+  id: string;
+  label: string;
+  url: string;
+  attribution: string;
+}
+
+const basemaps: BasemapOption[] = [
+  {
+    id: "osm",
+    label: "OpenStreetMap",
+    url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
+    attribution: '&copy; <a href="https://openstreetmap.org/copyright">OpenStreetMap</a> contributors',
+  },
+  {
+    id: "satellite",
+    label: "Satellite",
+    url: "https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}",
+    attribution: "&copy; Esri, Maxar, Earthstar Geographics, and the GIS User Community",
+  },
+  {
+    id: "street",
+    label: "World Street",
+    url: "https://server.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/{z}/{y}/{x}",
+    attribution: "&copy; Esri, HERE, Garmin, and the GIS User Community",
+  },
+  {
+    id: "topo",
+    label: "World Topo",
+    url: "https://server.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/{z}/{y}/{x}",
+    attribution: "&copy; Esri, HERE, FAO, NOAA, and the GIS User Community",
+  },
+  {
+    id: "light",
+    label: "Light",
+    url: "https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}{r}.png",
+    attribution: '&copy; <a href="https://carto.com/">CARTO</a>',
+  },
+];
+
+const selectedBasemap = ref(basemaps[0]);
+const selectedBasemapId = ref(basemaps[0].id);
+const dialogTitle = computed(() => props.title || t("grid.layerPreview"));
+
+// ── Label property ─────────────────────────────────────────────────────────
+const labelProperties = ref<string[]>([]);
+const labelProperty = ref<string>("");
+
+function parseLabelProperties(data: any) {
+  const keys = new Set<string>();
+  const features = data.features || (data.type === "Feature" ? [data] : []);
+  for (const f of features) {
+    if (f.properties) Object.keys(f.properties).forEach((k) => keys.add(k));
+    if (keys.size >= 20) break;
+  }
+  labelProperties.value = Array.from(keys).sort();
+  labelProperty.value = "";
+}
+
+function onLabelPropertyChange() {
+  updateLabels();
+}
+
+function updateLabels() {
+  if (!map || !_geojsonData || !_L) return;
+  // Remove old labels
+  if (labelLayer) {
+    map.removeLayer(labelLayer);
+    labelLayer = null;
+  }
+
+  const prop = labelProperty.value;
+  if (!prop) return;
+
+  const L = _L;
+  labelLayer = L.layerGroup().addTo(map);
+
+  const features = _geojsonData.features || [];
+  for (const f of features) {
+    const value = f.properties?.[prop];
+    if (value == null) continue;
+    const coords = getLabelCoords(f.geometry);
+    if (!coords) continue;
+    const icon = L.divIcon({
+      className: "layer-preview-label",
+      html: `<span>${escapeHtml(String(value))}</span>`,
+      iconSize: [0, 0],
+      iconAnchor: [0, 0],
+    });
+    L.marker(coords, { icon, interactive: false }).addTo(labelLayer);
+  }
+}
+
+function getLabelCoords(geom: any): [number, number] | null {
+  if (!geom) return null;
+  if (geom.type === "Point") return [geom.coordinates[1], geom.coordinates[0]];
+  if (geom.type === "MultiPoint") return [geom.coordinates[0][1], geom.coordinates[0][0]];
+  // For lines/polygons, label at the centroid (midpoint)
+  const coords = geom.coordinates?.flat(Infinity).filter((n: any) => typeof n === "number");
+  if (!coords || coords.length < 2) return null;
+  // Collect all [lng, lat] pairs
+  const pts: [number, number][] = [];
+  const flat = geom.coordinates?.flat(Infinity) ?? [];
+  for (let i = 0; i + 1 < flat.length; i += 2) {
+    if (typeof flat[i] === "number" && typeof flat[i + 1] === "number") pts.push([flat[i], flat[i + 1]]);
+  }
+  if (pts.length === 0) return null;
+  const avgLng = pts.reduce((s, p) => s + p[0], 0) / pts.length;
+  const avgLat = pts.reduce((s, p) => s + p[1], 0) / pts.length;
+  return [avgLat, avgLng];
+}
+
+function escapeHtml(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// ── Map ────────────────────────────────────────────────────────────────────
+function pointToCircleFeature(_feature: any, latlng: L.LatLng): L.CircleMarker {
+  return _L!.circleMarker(latlng, {
+    radius: 7,
+    color: "#ff6600",
+    weight: 3,
+    opacity: 0.95,
+    fillColor: "#ff6600",
+    fillOpacity: 0.5,
+  });
+}
+
+function popupContent(feature: any): string {
+  const rows: string[] = [];
+  if (feature.properties) {
+    for (const [k, v] of Object.entries(feature.properties)) {
+      rows.push(`<tr><td class="pr-2 font-medium">${escapeHtml(k)}</td><td>${escapeHtml(String(v ?? ""))}</td></tr>`);
+    }
+  }
+  const geom = feature.geometry?.type ?? "?";
+  return `<div class="text-xs leading-relaxed"><div class="mb-1 font-semibold text-[#ff6600]">${geom}</div><table>${rows.join("")}</table></div>`;
+}
+
+async function initMap() {
+  const container = mapContainer.value;
+  if (!container) {
+    console.warn("[LayerPreview] mapContainer ref is null");
+    return;
+  }
+  cleanupMap();
+  mapError.value = "";
+
+  // Remove the "Loading map…" placeholder so Leaflet can take over.
+  const placeholder = container.querySelector("[data-map-placeholder]");
+  if (placeholder) placeholder.remove();
+
+  try {
+    console.log("[LayerPreview] container offset:", container.offsetWidth, "x", container.offsetHeight);
+    const L = await loadLeaflet();
+    const rect = container.getBoundingClientRect();
+    console.log("[LayerPreview] container getBoundingClientRect:", rect.width, "x", rect.height);
+
+    map = L.map(container, {
+      zoomControl: true,
+      attributionControl: true,
+      center: [35, 110],
+      zoom: 4,
+    });
+    console.log("[LayerPreview] L.map created");
+    map.invalidateSize();
+
+    tileLayer = L.tileLayer(selectedBasemap.value.url, {
+      attribution: selectedBasemap.value.attribution,
+      maxZoom: 19,
+      crossOrigin: true,
+    }).addTo(map);
+    // Sync ID ref
+    selectedBasemapId.value = selectedBasemap.value.id;
+    console.log("[LayerPreview] tileLayer added");
+    addGeoJsonToMap();
+    parseLabelProperties(_geojsonData);
+
+    mapResizeObserver = new ResizeObserver(() => {
+      map?.invalidateSize();
+    });
+    mapResizeObserver.observe(container);
+    setTimeout(() => {
+      map?.invalidateSize();
+    }, 500);
+  } catch (err) {
+    console.error("[LayerPreview] initMap error:", err);
+    mapError.value = String(err);
+  }
+}
+
+function addGeoJsonToMap() {
+  if (!map || geoLayer) return;
+  try {
+    _geojsonData = JSON.parse(props.geojson);
+  } catch {
+    console.warn("[LayerPreview] invalid geojson JSON");
+    return;
+  }
+  console.log("[LayerPreview] GeoJSON type:", _geojsonData.type, "features:", _geojsonData.features?.length);
+
+  let data = _geojsonData;
+  if (data.type === "Feature") data = { type: "FeatureCollection", features: [data] };
+  else if (data.type && data.coordinates)
+    data = {
+      type: "FeatureCollection",
+      features: [{ type: "Feature", geometry: data, properties: {} }],
+    };
+  if (!data.features?.length) {
+    console.warn("[LayerPreview] no features");
+    return;
+  }
+
+  geoLayer = _L!
+    .geoJSON(data, {
+      style: {
+        color: "#ff6600",
+        weight: 3,
+        opacity: 0.95,
+        fillColor: "#ff6600",
+        fillOpacity: 0.25,
+      },
+      pointToLayer: pointToCircleFeature,
+      onEachFeature: (feature, layer) => {
+        layer.bindPopup(popupContent(feature));
+      },
+    })
+    .addTo(map);
+
+  const bounds = geoLayer.getBounds();
+  console.log("[LayerPreview] geoLayer added, bounds:", bounds.toBBoxString(), "valid:", bounds.isValid());
+  if (bounds.isValid()) {
+    map.fitBounds(bounds, { padding: [30, 30], maxZoom: 18 });
+    console.log("[LayerPreview] fitBounds done, zoom:", map.getZoom());
+  }
+}
+
+function switchBasemap(basemap: BasemapOption) {
+  selectedBasemap.value = basemap;
+  selectedBasemapId.value = basemap.id;
+  if (!map) return;
+  const L = _L!;
+  if (tileLayer) map.removeLayer(tileLayer);
+  tileLayer = L.tileLayer(basemap.url, {
+    attribution: basemap.attribution,
+    maxZoom: 19,
+    crossOrigin: true,
+  }).addTo(map);
+}
+
+// Watch the dropdown-driven basemap ID and switch when it changes.
+watch(selectedBasemapId, (id) => {
+  const bm = basemaps.find((b) => b.id === id);
+  if (bm && bm !== selectedBasemap.value) switchBasemap(bm);
+});
+
+function cleanupMap() {
+  mapResizeObserver?.disconnect();
+  mapResizeObserver = null;
+  labelLayer = null;
+  geoLayer = null;
+  tileLayer = null;
+  if (map) {
+    map.remove();
+    map = null;
+  }
+  _geojsonData = null;
+  labelProperty.value = "";
+}
+
+function close() {
+  emit("update:open", false);
+}
+
+async function saveAsImage() {
+  if (!map || !mapContainer.value || isExporting.value) return;
+  isExporting.value = true;
+  try {
+    const defaultName = `map-${Date.now()}.png`;
+    const domtoimage = (await import("dom-to-image-more")).default;
+    const dataUrl = await domtoimage.toPng(mapContainer.value, {
+      quality: 1,
+      width: mapContainer.value.offsetWidth,
+      height: mapContainer.value.offsetHeight,
+    });
+    const blob = await (await fetch(dataUrl)).blob();
+    if (!blob) return;
+
+    try {
+      const { save } = await import("@tauri-apps/plugin-dialog");
+      const { writeFile } = await import("@tauri-apps/plugin-fs");
+      const path = await save({
+        defaultPath: defaultName,
+        filters: [{ name: "PNG", extensions: ["png"] }],
+      });
+      if (!path) return;
+      await writeFile(path, new Uint8Array(await blob.arrayBuffer()));
+    } catch {
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = defaultName;
+      a.click();
+      URL.revokeObjectURL(url);
+    }
+  } catch (err) {
+    console.error("[LayerPreview] saveAsImage error:", err);
+  } finally {
+    isExporting.value = false;
+  }
+}
+
+watch(
+  () => props.open,
+  async (open) => {
+    console.log("[LayerPreview] open prop changed:", open);
+    if (open) {
+      await nextTick();
+      if (!mapContainer.value) await nextTick();
+      console.log("[LayerPreview] after nextTick, mapContainer in DOM:", !!mapContainer.value);
+      await initMap();
+    } else {
+      cleanupMap();
+    }
+  },
+  { immediate: true },
+);
+
+onBeforeUnmount(() => cleanupMap());
+</script>
+
+<template>
+  <Dialog :open="open" @update:open="(value) => emit('update:open', value)">
+    <DialogContent :show-close-button="false" :style="contentStyle" class="layer-preview-dialog flex w-[96vw] max-w-[1800px] h-[88vh] max-h-[960px] min-w-[640px] min-h-[400px] flex-col gap-0 overflow-hidden rounded-xl border p-0 shadow-2xl" @escape-key-down="close">
+      <!-- Header -->
+      <div class="flex h-12 shrink-0 items-center gap-2 border-b bg-muted/20 px-3">
+        <div class="flex min-w-0 shrink-0 items-center gap-2">
+          <Map class="h-4 w-4 shrink-0 text-muted-foreground" />
+          <DialogTitle class="truncate text-sm font-semibold">{{ dialogTitle }}</DialogTitle>
+        </div>
+
+        <!-- Label property selector -->
+        <select v-if="labelProperties.length" v-model="labelProperty" class="h-6 shrink-0 rounded border bg-background px-1.5 text-[11px] outline-none" @change="onLabelPropertyChange">
+          <option value="">— 标签 —</option>
+          <option v-for="p in labelProperties" :key="p" :value="p">
+            {{ p }}
+          </option>
+        </select>
+
+        <div class="flex flex-1" />
+
+        <!-- Basemap selector -->
+        <select v-model="selectedBasemapId" class="h-6 shrink-0 rounded border bg-background px-1.5 text-[11px] outline-none">
+          <option v-for="bm in basemaps" :key="bm.id" :value="bm.id">
+            {{ bm.label }}
+          </option>
+        </select>
+
+        <!-- Save as image -->
+        <Button variant="ghost" size="icon" class="h-7 w-7 shrink-0 text-muted-foreground hover:bg-accent hover:text-accent-foreground" title="导出图片" :disabled="isExporting" @click="saveAsImage">
+          <Camera v-if="!isExporting" class="h-3.5 w-3.5" />
+          <Loader2 v-else class="h-3.5 w-3.5 animate-spin" />
+        </Button>
+
+        <!-- Maximise -->
+        <Button variant="ghost" size="icon" class="h-7 w-7 shrink-0 text-muted-foreground hover:bg-accent hover:text-accent-foreground" :title="isMaximized ? '还原' : '最大化'" @click="toggleMaximize">
+          <Maximize2 v-if="!isMaximized" class="h-3.5 w-3.5" />
+          <Minimize2 v-else class="h-3.5 w-3.5" />
+        </Button>
+
+        <Button variant="ghost" size="icon" class="h-7 w-7 shrink-0 text-muted-foreground hover:bg-accent hover:text-accent-foreground" :title="t('dangerDialog.cancel')" @click="close">
+          <X class="h-3.5 w-3.5" />
+        </Button>
+      </div>
+
+      <!-- Map -->
+      <div ref="mapContainer" class="relative w-full flex-1" style="min-height: 200px" data-map-container>
+        <div class="absolute inset-0 z-10 flex items-center justify-center text-xs text-muted-foreground pointer-events-none" data-map-placeholder>Loading map…</div>
+      </div>
+      <div v-if="mapError" class="absolute inset-0 flex items-center justify-center bg-background/80 p-4 text-sm text-destructive">
+        {{ mapError }}
+      </div>
+
+      <!-- Resize handles -->
+      <div class="absolute bottom-0 right-0 z-50 h-5 w-5 cursor-se-resize" @pointerdown.prevent="onResizePointerDown($event, 'se')" @pointermove="onResizePointerMove" @pointerup="onResizePointerUp" @pointercancel="onResizePointerUp">
+        <div class="absolute bottom-0.5 right-0.5 h-2.5 w-2.5" style="border-right: 2px solid; border-bottom: 2px solid; opacity: 0.3" />
+      </div>
+      <div class="absolute bottom-0 left-2 right-6 z-50 h-2 cursor-s-resize opacity-0 hover:opacity-25" @pointerdown.prevent="onResizePointerDown($event, 's')" @pointermove="onResizePointerMove" @pointerup="onResizePointerUp" @pointercancel="onResizePointerUp" />
+      <div class="absolute right-0 top-2 bottom-6 z-50 w-2 cursor-e-resize opacity-0 hover:opacity-25" @pointerdown.prevent="onResizePointerDown($event, 'e')" @pointermove="onResizePointerMove" @pointerup="onResizePointerUp" @pointercancel="onResizePointerUp" />
+    </DialogContent>
+  </Dialog>
+</template>
+
+<style>
+.layer-preview-dialog .leaflet-container {
+  width: 100% !important;
+  height: 100% !important;
+  background: #1a1a2e;
+}
+.layer-preview-dialog .leaflet-popup-content-wrapper {
+  border-radius: 6px;
+  font-size: 12px;
+}
+.layer-preview-dialog .leaflet-popup-content {
+  margin: 8px 12px;
+}
+.layer-preview-label span {
+  display: inline-block;
+  background: rgba(0, 0, 0, 0.65);
+  color: #fff;
+  font-size: 10px;
+  line-height: 1.3;
+  padding: 1px 5px;
+  border-radius: 3px;
+  white-space: nowrap;
+  pointer-events: none;
+}
+</style>
diff --git a/apps/desktop/src/components/grid/TemporalCellEditor.vue b/apps/desktop/src/components/grid/TemporalCellEditor.vue
new file mode 100644
index 0000000..e8d9faf
--- /dev/null
+++ b/apps/desktop/src/components/grid/TemporalCellEditor.vue
@@ -0,0 +1,395 @@
+<script setup lang="ts">
+import { computed, nextTick, onMounted, ref, watch } from "vue";
+import type { FocusOutsideEvent, PointerDownOutsideEvent } from "reka-ui";
+import { CalendarClock, ChevronDown, ChevronUp, CircleSlash } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Popover, PopoverAnchor, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { formatTemporalInputValue, parseTemporalInputValue, stepTemporalInputValue, type TemporalCellEditorKind } from "@/lib/dataGrid/dataGridTemporalEditor";
+
+const props = withDefaults(
+  defineProps<{
+    kind: TemporalCellEditorKind;
+    modelValue: string;
+    variant?: "cell" | "inline";
+    cellLayout?: "grid" | "transpose";
+    commitOnClose?: boolean;
+    fractionPrecision?: number;
+  }>(),
+  {
+    variant: "cell",
+    cellLayout: "grid",
+    commitOnClose: true,
+    fractionPrecision: 0,
+  },
+);
+
+const emit = defineEmits<{
+  "update:modelValue": [value: string];
+  commit: [];
+  cancel: [];
+}>();
+
+const open = ref(false);
+const editorRootRef = ref<HTMLDivElement | null>(null);
+const inputRef = ref<HTMLInputElement | null>(null);
+const localValue = ref(props.modelValue);
+let closeHandled = false;
+let isCommitting = false;
+let skipCommitOnClose = false;
+
+const hasDate = computed(() => props.kind !== "time");
+const hasTime = computed(() => props.kind !== "date");
+const normalizedFractionPrecision = computed(() => Math.max(0, Math.min(9, props.fractionPrecision || 0)));
+const existingFractionDigits = computed(() => parseFractionDigits(timeValue.value));
+const fractionInputLength = computed(() => normalizedFractionPrecision.value || existingFractionDigits.value.length);
+const fractionInputMaxLength = computed(() => Math.max(1, fractionInputLength.value));
+const showFractionInput = computed(() => hasTime.value && (normalizedFractionPrecision.value > 0 || existingFractionDigits.value.length > 0));
+const timeGridStyle = computed(() => ({
+  gridTemplateColumns: showFractionInput.value ? "3.5rem 0.5rem 3.5rem 0.5rem 3.5rem 0.5rem 5rem" : "3.5rem 0.5rem 3.5rem 0.5rem 3.5rem",
+}));
+const editorRootClass = computed(() => (props.variant === "inline" ? "relative h-9 w-full" : "absolute inset-0 z-10"));
+const inputClass = computed(() =>
+  props.variant === "inline"
+    ? "cell-edit-input h-9 w-full rounded border bg-background py-0 pl-2 pr-8 text-left text-xs outline-none hover:border-primary/60 focus:border-primary"
+    : ["cell-edit-input absolute inset-0 z-10 border-2 border-primary bg-background py-0 text-left text-xs outline-none", props.cellLayout === "transpose" ? "pl-1.5 pr-6" : "pl-2.5 pr-7"],
+);
+const triggerButtonClass = computed(() =>
+  props.variant === "inline"
+    ? "absolute right-1 top-1/2 z-20 flex h-6 w-6 -translate-y-1/2 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground"
+    : "absolute right-0.5 top-1/2 z-20 flex h-5 w-5 -translate-y-1/2 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground",
+);
+const dateParts = computed(() => {
+  const text = formatTemporalInputValue(localValue.value, "date");
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
+  if (!match) {
+    const now = new Date();
+    return { year: now.getFullYear(), month: now.getMonth() + 1, day: now.getDate() };
+  }
+  return { year: Number(match[1]), month: Number(match[2]), day: Number(match[3]) };
+});
+
+const timeValue = computed(() => {
+  if (props.kind === "time") return formatTemporalInputValue(localValue.value, "time") || "00:00:00";
+  return formatTemporalInputValue(localValue.value, "datetime").split("T")[1] || "00:00:00";
+});
+
+const timeParts = computed(() => {
+  const match = /^(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?$/.exec(timeValue.value);
+  if (!match) return { hour: "00", minute: "00", second: "00" };
+  const [, hour = "00", minute = "00", second = "00"] = match;
+  return { hour, minute, second };
+});
+
+onMounted(() => {
+  nextTick(() => {
+    inputRef.value?.focus();
+    inputRef.value?.select();
+  });
+});
+
+watch(
+  () => props.modelValue,
+  (value) => {
+    localValue.value = value;
+  },
+);
+
+function setOpen(value: boolean) {
+  open.value = value;
+  if (!value && props.commitOnClose && !closeHandled && !skipCommitOnClose) finishCommit();
+}
+
+function setModelValue(value: string) {
+  localValue.value = value;
+  emit("update:modelValue", value);
+}
+
+function updateTextInput(event: Event) {
+  setModelValue((event.target as HTMLInputElement).value);
+}
+
+function updateDate(part: "day" | "month" | "year", rawValue: string | number) {
+  const numberValue = Number(rawValue);
+  const next = { ...dateParts.value };
+  if (Number.isNaN(numberValue)) return;
+  if (part === "year") next.year = Math.max(1, Math.min(9999, numberValue));
+  else if (part === "month") next.month = Math.max(1, Math.min(12, numberValue));
+  else next.day = Math.max(1, Math.min(31, numberValue));
+  const maxDay = daysInMonth(next.year, next.month);
+  next.day = Math.max(1, Math.min(maxDay, next.day));
+  setDateTimeValue(next.year, next.month, next.day, timeValue.value);
+}
+
+function updateDateFromInput(part: "day" | "month" | "year", event: Event) {
+  updateDate(part, (event.target as HTMLInputElement).value);
+}
+
+function stepDate(part: "day" | "month" | "year", delta: number) {
+  setModelValue(stepTemporalInputValue(localValue.value, props.kind, part, delta));
+}
+
+function updateTime(part: "hour" | "minute" | "second", rawValue: string | number) {
+  const parts = { ...timeParts.value, [part]: normalizeTimePart(rawValue, part === "hour" ? 23 : 59) };
+  const nextTime = `${parts.hour}:${parts.minute}:${parts.second}${fractionSuffix.value}`;
+  if (props.kind === "time") {
+    setModelValue(nextTime);
+    return;
+  }
+  setDateTimeValue(dateParts.value.year, dateParts.value.month, dateParts.value.day, nextTime);
+}
+
+function updateTimeFromInput(part: "hour" | "minute" | "second", event: Event) {
+  updateTime(part, (event.target as HTMLInputElement).value);
+}
+
+function stepTime(part: "hour" | "minute" | "second", delta: number) {
+  setModelValue(stepTemporalInputValue(localValue.value, props.kind, part, delta));
+}
+
+const fractionSuffix = computed(() => {
+  const digits = existingFractionDigits.value;
+  return digits ? `.${digits}` : "";
+});
+
+function updateFraction(event: Event) {
+  updateFractionValue((event.target as HTMLInputElement).value);
+}
+
+function updateFractionValue(rawValue: string) {
+  const maxLength = Math.max(1, fractionInputLength.value);
+  const digits = rawValue.replace(/\D/g, "").slice(0, maxLength);
+  const nextTime = `${timeParts.value.hour}:${timeParts.value.minute}:${timeParts.value.second}${digits ? `.${digits}` : ""}`;
+  if (props.kind === "time") {
+    setModelValue(nextTime);
+    return;
+  }
+  setDateTimeValue(dateParts.value.year, dateParts.value.month, dateParts.value.day, nextTime);
+}
+
+function flushInputValue(target: EventTarget | null) {
+  if (!(target instanceof HTMLInputElement)) return;
+  const part = target.dataset.temporalPart;
+  if (part === "year" || part === "month" || part === "day") {
+    updateDate(part, target.value);
+  } else if (part === "hour" || part === "minute" || part === "second") {
+    updateTime(part, target.value);
+  } else if (part === "fraction") {
+    updateFractionValue(target.value);
+  }
+}
+
+function normalizeTextInputValue() {
+  setModelValue(parseTemporalInputValue(localValue.value, props.kind) ?? "");
+}
+
+function setNull() {
+  setModelValue("NULL");
+}
+
+function setNow() {
+  const now = new Date();
+  const dateText = [String(now.getFullYear()).padStart(4, "0"), String(now.getMonth() + 1).padStart(2, "0"), String(now.getDate()).padStart(2, "0")].join("-");
+  const nextTime = [String(now.getHours()).padStart(2, "0"), String(now.getMinutes()).padStart(2, "0"), String(now.getSeconds()).padStart(2, "0")].join(":") + nowFractionSuffix(now);
+  if (props.kind === "date") setModelValue(dateText);
+  else if (props.kind === "time") setModelValue(nextTime);
+  else setModelValue(`${dateText} ${nextTime}`);
+}
+
+function finishCommit() {
+  if (isCommitting) return;
+  normalizeTextInputValue();
+  closeHandled = true;
+  isCommitting = true;
+  emit("commit");
+}
+
+function finishCancel() {
+  if (isCommitting) return;
+  closeHandled = true;
+  isCommitting = true;
+  emit("cancel");
+}
+
+function onKeydown(event: KeyboardEvent) {
+  if (event.key === "Enter") {
+    event.preventDefault();
+    flushInputValue(event.target);
+    finishCommit();
+  } else if (event.key === "Escape") {
+    event.preventDefault();
+    event.stopPropagation();
+    finishCancel();
+  }
+}
+
+function onInputBlur() {
+  if (!props.commitOnClose || open.value || closeHandled || skipCommitOnClose) return;
+  finishCommit();
+}
+
+function onPopoverInteractOutside(event: PointerDownOutsideEvent | FocusOutsideEvent) {
+  const originalEvent = event.detail.originalEvent;
+  if (isEditorInteractionTarget(originalEvent.target)) {
+    event.preventDefault();
+    closePickerOnly();
+    return;
+  }
+  if (isSelectInteractionTarget(originalEvent.target)) {
+    event.preventDefault();
+  }
+}
+
+function closePickerOnly() {
+  if (!open.value) return;
+  skipCommitOnClose = true;
+  setOpen(false);
+  nextTick(() => {
+    skipCommitOnClose = false;
+  });
+}
+
+function isEditorInteractionTarget(target: EventTarget | null): boolean {
+  return target instanceof Node && !!editorRootRef.value?.contains(target);
+}
+
+function isSelectInteractionTarget(target: EventTarget | null): boolean {
+  return target instanceof Element && !!target.closest("[data-slot='select-content'], [data-slot='select-trigger']");
+}
+
+function normalizeTimePart(value: string | number, max: number): string {
+  const parsed = Number(value);
+  const numberValue = Math.max(0, Math.min(max, Number.isNaN(parsed) ? 0 : parsed));
+  return String(numberValue).padStart(2, "0");
+}
+
+function setDateTimeValue(year: number, month: number, day: number, time: string) {
+  const dateText = [String(year).padStart(4, "0"), String(month).padStart(2, "0"), String(day).padStart(2, "0")].join("-");
+  if (props.kind === "date") setModelValue(dateText);
+  else setModelValue(`${dateText} ${time}`);
+}
+
+function parseFractionDigits(value: string): string {
+  return value.match(/\.(\d{1,9})/)?.[1] ?? "";
+}
+
+function nowFractionSuffix(now: Date): string {
+  const precision = normalizedFractionPrecision.value;
+  if (precision <= 0) return "";
+  return `.${String(now.getMilliseconds()).padStart(3, "0").padEnd(precision, "0").slice(0, precision)}`;
+}
+
+function daysInMonth(year: number, month: number): number {
+  return new Date(year, month, 0).getDate();
+}
+
+function twoDigit(value: string | number): string {
+  return String(value).padStart(2, "0");
+}
+</script>
+
+<template>
+  <Popover :open="open" :modal="false" @update:open="setOpen">
+    <div ref="editorRootRef" :class="editorRootClass" @click.stop>
+      <PopoverAnchor as-child>
+        <input ref="inputRef" :value="localValue" :class="inputClass" autocapitalize="off" autocorrect="off" autocomplete="off" spellcheck="false" placeholder="NULL" @blur="onInputBlur" @click.stop @input="updateTextInput" @keydown.stop="onKeydown" />
+      </PopoverAnchor>
+      <PopoverTrigger as-child>
+        <button type="button" :class="triggerButtonClass" @mousedown.prevent @click.stop>
+          <CalendarClock class="h-3.5 w-3.5" />
+          <span class="sr-only">Open temporal picker</span>
+        </button>
+      </PopoverTrigger>
+    </div>
+    <PopoverContent align="start" side="bottom" class="w-auto gap-1.5 rounded-md p-1.5" @click.stop @keydown.stop="onKeydown" @open-auto-focus.prevent @close-auto-focus.prevent @interact-outside="onPopoverInteractOutside">
+      <div v-if="hasDate" class="grid grid-cols-[4.5rem_4.5rem_4.5rem] gap-1.5">
+        <div class="grid h-7 min-w-0 grid-cols-[1fr_1.35rem] overflow-hidden rounded-md border border-input bg-background">
+          <input :value="dateParts.year" data-temporal-part="year" inputmode="numeric" class="min-w-0 bg-transparent px-1 text-center text-[13px] tabular-nums outline-none" @input="updateDateFromInput('year', $event)" />
+          <div class="grid border-l">
+            <button type="button" class="flex items-center justify-center hover:bg-muted" @mousedown.prevent @click="stepDate('year', 1)">
+              <ChevronUp class="h-3 w-3" />
+            </button>
+            <button type="button" class="flex items-center justify-center border-t hover:bg-muted" @mousedown.prevent @click="stepDate('year', -1)">
+              <ChevronDown class="h-3 w-3" />
+            </button>
+          </div>
+        </div>
+
+        <div class="grid h-7 min-w-0 grid-cols-[1fr_1.35rem] overflow-hidden rounded-md border border-input bg-background">
+          <input :value="twoDigit(dateParts.month)" data-temporal-part="month" inputmode="numeric" class="min-w-0 bg-transparent px-1 text-center text-[13px] tabular-nums outline-none" @input="updateDateFromInput('month', $event)" />
+          <div class="grid border-l">
+            <button type="button" class="flex items-center justify-center hover:bg-muted" @mousedown.prevent @click="stepDate('month', 1)">
+              <ChevronUp class="h-3 w-3" />
+            </button>
+            <button type="button" class="flex items-center justify-center border-t hover:bg-muted" @mousedown.prevent @click="stepDate('month', -1)">
+              <ChevronDown class="h-3 w-3" />
+            </button>
+          </div>
+        </div>
+
+        <div class="grid h-7 min-w-0 grid-cols-[1fr_1.35rem] overflow-hidden rounded-md border border-input bg-background">
+          <input :value="twoDigit(dateParts.day)" data-temporal-part="day" inputmode="numeric" class="min-w-0 bg-transparent px-1 text-center text-[13px] tabular-nums outline-none" @input="updateDateFromInput('day', $event)" />
+          <div class="grid border-l">
+            <button type="button" class="flex items-center justify-center hover:bg-muted" @mousedown.prevent @click="stepDate('day', 1)">
+              <ChevronUp class="h-3 w-3" />
+            </button>
+            <button type="button" class="flex items-center justify-center border-t hover:bg-muted" @mousedown.prevent @click="stepDate('day', -1)">
+              <ChevronDown class="h-3 w-3" />
+            </button>
+          </div>
+        </div>
+      </div>
+
+      <div v-if="hasTime" class="grid items-center gap-1.5" :style="timeGridStyle">
+        <div class="grid h-7 min-w-0 grid-cols-[1fr_1.35rem] overflow-hidden rounded-md border border-input bg-background">
+          <input :value="twoDigit(timeParts.hour)" data-temporal-part="hour" inputmode="numeric" class="min-w-0 bg-transparent px-1 text-center text-[13px] tabular-nums outline-none" @input="updateTimeFromInput('hour', $event)" />
+          <div class="grid border-l">
+            <button type="button" class="flex items-center justify-center hover:bg-muted" @mousedown.prevent @click="stepTime('hour', 1)">
+              <ChevronUp class="h-3 w-3" />
+            </button>
+            <button type="button" class="flex items-center justify-center border-t hover:bg-muted" @mousedown.prevent @click="stepTime('hour', -1)">
+              <ChevronDown class="h-3 w-3" />
+            </button>
+          </div>
+        </div>
+        <span class="text-center text-xs text-muted-foreground">:</span>
+        <div class="grid h-7 min-w-0 grid-cols-[1fr_1.35rem] overflow-hidden rounded-md border border-input bg-background">
+          <input :value="twoDigit(timeParts.minute)" data-temporal-part="minute" inputmode="numeric" class="min-w-0 bg-transparent px-1 text-center text-[13px] tabular-nums outline-none" @input="updateTimeFromInput('minute', $event)" />
+          <div class="grid border-l">
+            <button type="button" class="flex items-center justify-center hover:bg-muted" @mousedown.prevent @click="stepTime('minute', 1)">
+              <ChevronUp class="h-3 w-3" />
+            </button>
+            <button type="button" class="flex items-center justify-center border-t hover:bg-muted" @mousedown.prevent @click="stepTime('minute', -1)">
+              <ChevronDown class="h-3 w-3" />
+            </button>
+          </div>
+        </div>
+        <span class="text-center text-xs text-muted-foreground">:</span>
+        <div class="grid h-7 min-w-0 grid-cols-[1fr_1.35rem] overflow-hidden rounded-md border border-input bg-background">
+          <input :value="twoDigit(timeParts.second)" data-temporal-part="second" inputmode="numeric" class="min-w-0 bg-transparent px-1 text-center text-[13px] tabular-nums outline-none" @input="updateTimeFromInput('second', $event)" />
+          <div class="grid border-l">
+            <button type="button" class="flex items-center justify-center hover:bg-muted" @mousedown.prevent @click="stepTime('second', 1)">
+              <ChevronUp class="h-3 w-3" />
+            </button>
+            <button type="button" class="flex items-center justify-center border-t hover:bg-muted" @mousedown.prevent @click="stepTime('second', -1)">
+              <ChevronDown class="h-3 w-3" />
+            </button>
+          </div>
+        </div>
+        <template v-if="showFractionInput">
+          <span class="text-center text-xs text-muted-foreground">.</span>
+          <div class="grid h-7 min-w-0 overflow-hidden rounded-md border border-input bg-background">
+            <input :value="existingFractionDigits" data-temporal-part="fraction" inputmode="numeric" :maxlength="fractionInputMaxLength" class="min-w-0 bg-transparent px-1 text-center text-[13px] tabular-nums outline-none" placeholder="0" @input="updateFraction" />
+          </div>
+        </template>
+      </div>
+
+      <div class="flex items-center justify-between gap-1">
+        <Button type="button" variant="ghost" size="xs" class="h-6 px-1.5 text-[11px]" @mousedown.prevent @click="setNull">
+          <CircleSlash class="h-3 w-3" />
+          NULL
+        </Button>
+        <Button type="button" variant="ghost" size="xs" class="h-6 px-1.5 text-[11px]" @mousedown.prevent @click="setNow">Now</Button>
+      </div>
+    </PopoverContent>
+  </Popover>
+</template>
diff --git a/apps/desktop/src/components/icons/AiProviderLogo.vue b/apps/desktop/src/components/icons/AiProviderLogo.vue
new file mode 100644
index 0000000..87e922d
--- /dev/null
+++ b/apps/desktop/src/components/icons/AiProviderLogo.vue
@@ -0,0 +1,43 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { Settings2 } from "@lucide/vue";
+import type { AiProvider } from "@/stores/settingsStore";
+import { useTheme } from "@/composables/useTheme";
+import { webPath } from "@/lib/common/webPath";
+
+const props = defineProps<{
+  provider: AiProvider;
+  label: string;
+  iconSlug?: string;
+}>();
+
+const failed = ref(false);
+const { isDark } = useTheme();
+
+watch(
+  () => props.iconSlug,
+  () => {
+    failed.value = false;
+  },
+);
+
+const usesWhiteDarkIcon = computed(() => props.provider === "claude" || props.provider === "ollama" || props.provider === "openai" || props.provider === "openai-compatible");
+const localIconUrl = computed(() => {
+  if (props.provider === "openai-compatible") return webPath("/icons/ai/openai.svg");
+  return props.iconSlug ? webPath(`/icons/ai/${props.iconSlug}.svg`) : "";
+});
+const fallbackText = computed(() => {
+  if (props.provider === "openai-compatible") return "OC";
+  return props.label.slice(0, 1).toUpperCase();
+});
+</script>
+
+<template>
+  <span class="flex h-4 w-4 shrink-0 items-center justify-center overflow-hidden rounded-sm">
+    <Settings2 v-if="provider === 'custom'" class="h-4 w-4 text-muted-foreground" />
+    <img v-else-if="localIconUrl && !failed" :src="localIconUrl" :alt="label" class="h-4 w-4 object-contain" :class="{ 'dark:invert': isDark && usesWhiteDarkIcon }" @error="failed = true" />
+    <span v-else class="flex h-4 w-4 items-center justify-center rounded-sm bg-muted text-[8px] font-semibold">
+      {{ fallbackText }}
+    </span>
+  </span>
+</template>
diff --git a/apps/desktop/src/components/icons/AppLogo.vue b/apps/desktop/src/components/icons/AppLogo.vue
new file mode 100644
index 0000000..d25684c
--- /dev/null
+++ b/apps/desktop/src/components/icons/AppLogo.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import { useSettingsStore } from "@/stores/settingsStore";
+
+const settingsStore = useSettingsStore();
+const isBlackLogo = computed(() => settingsStore.desktopSettings.icon_theme === "black");
+const logoSrc = computed(() => (isBlackLogo.value ? "/logo-black.png" : "/logo.png"));
+</script>
+
+<template>
+  <img :src="logoSrc" alt="DBX" :class="isBlackLogo ? 'dark:invert' : ''" />
+</template>
diff --git a/apps/desktop/src/components/icons/DatabaseIcon.vue b/apps/desktop/src/components/icons/DatabaseIcon.vue
new file mode 100644
index 0000000..b99cab5
--- /dev/null
+++ b/apps/desktop/src/components/icons/DatabaseIcon.vue
@@ -0,0 +1,126 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import { Database } from "@lucide/vue";
+import { webPath } from "@/lib/common/webPath";
+
+const props = defineProps<{
+  dbType: string;
+}>();
+
+const assetIcons: Record<string, string> = {
+  mysql: "mysql",
+  postgres: "postgres",
+  postgresql: "postgres",
+  sqlite: "sqlite",
+  rqlite: "rqlite.png",
+  turso: "turso.png",
+  cloudflare_d1: "cloudflare-d1",
+  redis: "redis",
+  mongodb: "mongodb",
+  mongodb_legacy: "mongodb",
+  clickhouse: "clickhouse",
+  duckdb: "duckdb",
+  mariadb: "mariadb",
+  tidb: "tidb",
+  elasticsearch: "elasticsearch",
+  oracle: "oracle",
+  "oracle-10g": "oracle",
+  "oracle-legacy": "oracle",
+  oracle_10g: "oracle",
+  oracle_legacy: "oracle",
+  sqlserver: "sqlserver",
+  access: "access.png",
+  oceanbase: "oceanbase",
+  opengauss: "opengauss",
+  gaussdb: "gaussdb",
+  questdb: "questdb",
+  kwdb: "kwdb",
+  kingbase: "kingbase",
+  highgo: "highgo.png",
+  goldendb: "goldendb.png",
+  databend: "databend",
+  vastbase: "vastbase.png",
+  yashandb: "yashandb.png",
+  snowflake: "snowflake",
+  h2: "h2",
+  dm: "dm",
+  dameng: "dm",
+  presto: "presto",
+  prestosql: "presto",
+  hive: "hive",
+  spark: "spark-logo.png",
+  apache_kylin: "apache_kylin",
+  sundb: "sundb",
+  trino: "trino",
+  kylin: "apache_kylin",
+  cockroachdb: "cockroachdb",
+  db2: "db2",
+  dremio: "dremio",
+  bigquery: "bigquery",
+  cassandra: "cassandra",
+  doris: "doris",
+  manticoresearch: "manticoresearch.png",
+  selectdb: "selectdb",
+  tdengine: "tdengine",
+  starrocks: "starrocks",
+  redshift: "redshift",
+  neo4j: "neo4j",
+  informix: "informix",
+  databricks: "databricks.webp",
+  saphana: "saphana.webp",
+  teradata: "teradata.webp",
+  vertica: "vertica.webp",
+  firebird: "firebird.webp",
+  exasol: "exasol.webp",
+  gbase: "gbase.webp",
+  gbase8a: "gbase.webp",
+  gbase8s: "gbase.webp",
+  tdsql: "tdsql.webp",
+  polardb: "polardb.webp",
+  greatsql: "greatsql.webp",
+  xugu: "xugu.png",
+  iotdb: "iotdb",
+  etcd: "etcd",
+  qdrant: "qdrant",
+  milvus: "milvus.png",
+  weaviate: "weaviate.png",
+  chromadb: "chromadb",
+  mq: "pulsar",
+  pulsar: "pulsar",
+  kafka: "kafka",
+  nacos: "nacos.png",
+  iris: "iris.png",
+  influxdb: "influxdb",
+  zookeeper: "zookeeper",
+};
+
+const letterIcons: Record<string, { letter: string; color: string }> = {
+  oscar: { letter: "O", color: "#2563eb" },
+};
+
+const normalizedType = computed(() => props.dbType.toLowerCase().replace(/[\s-]+/g, "_"));
+const assetName = computed(() => assetIcons[normalizedType.value]);
+const assetSrc = computed(() => {
+  if (!assetName.value) return "";
+  return webPath(assetName.value.includes(".") ? `/icons/database/${assetName.value}` : `/icons/database/${assetName.value}.svg`);
+});
+const letter = computed(() => letterIcons[normalizedType.value]);
+</script>
+
+<template>
+  <img v-if="assetName" :src="assetSrc" alt="" class="database-logo object-contain" aria-hidden="true" />
+  <svg v-else-if="letter" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
+    <circle cx="12" cy="12" r="12" :fill="letter.color" />
+    <text x="12" y="16.5" text-anchor="middle" fill="white" font-size="14" font-weight="bold" font-family="system-ui, sans-serif">
+      {{ letter.letter }}
+    </text>
+  </svg>
+  <Database v-else class="text-blue-400" />
+</template>
+
+<style scoped>
+.database-logo {
+  transform: scale(1.35);
+  transform-origin: center;
+}
+</style>
diff --git a/apps/desktop/src/components/import/TableImportDialog.vue b/apps/desktop/src/components/import/TableImportDialog.vue
new file mode 100644
index 0000000..af47947
--- /dev/null
+++ b/apps/desktop/src/components/import/TableImportDialog.vue
@@ -0,0 +1,1191 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { uuid } from "@/lib/common/utils";
+import { useI18n } from "vue-i18n";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { Dialog, DialogHeader, DialogTitle, DialogFooter, DialogScrollContent } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { SearchableSelect } from "@/components/ui/searchable-select";
+import { AlertTriangle, ArrowLeft, ArrowRight, Check, CheckCircle2, FileJson, FileSpreadsheet, FileText, FileUp, Loader2, RefreshCw, Square, Upload, X } from "@lucide/vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useToast } from "@/composables/useToast";
+import { autoMapImportColumns, nextTableImportWizardStep, previousTableImportWizardStep, requiredImportTargetColumns, suggestImportTargetDataTypes, validateImportMappings, type TableImportWizardStep } from "@/lib/table/tableImport";
+import { getDataTypeOptions } from "@/lib/table/tableStructureEditorState";
+import { tableStructureDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import type { ColumnInfo } from "@/types/database";
+import * as api from "@/lib/backend/api";
+
+const { t } = useI18n();
+const store = useConnectionStore();
+const { toast } = useToast();
+const open = defineModel<boolean>("open", { default: false });
+
+const props = defineProps<{
+  prefillConnectionId?: string;
+  prefillDatabase?: string;
+  prefillSchema?: string;
+  prefillTable?: string;
+}>();
+
+type ImportTargetMode = "existing" | "create";
+type ImportSource = string | File;
+
+interface BatchImportTask {
+  id: string;
+  source: ImportSource;
+  format: api.TableImportSourceFormat;
+  sheetName: string;
+  tableName: string;
+  preview: api.TableImportPreview;
+  columnMapping: Record<string, string>;
+  columnDataTypes: Record<string, string>;
+  status: "pending" | "running" | "done" | "error" | "cancelled";
+  rowsImported: number;
+  error?: string;
+}
+
+const SKIP_VALUE = "__skip__";
+const targetColumns = ref<ColumnInfo[]>([]);
+const targetMode = ref<ImportTargetMode>(props.prefillTable ? "existing" : "create");
+const newTableName = ref("");
+const selectedSource = ref<string | File | null>(null);
+const batchTasks = ref<BatchImportTask[]>([]);
+const activeTaskIndex = ref(0);
+const sourceFormat = ref<api.TableImportSourceFormat>("csv");
+const preview = ref<api.TableImportPreview | null>(null);
+const columnMapping = ref<Record<string, string>>({});
+const columnDataTypes = ref<Record<string, string>>({});
+const dynamicDataTypeOptions = ref<string[]>([]);
+const loadingDataTypeOptions = ref(false);
+const loadingTarget = ref(false);
+const loadingPreview = ref(false);
+const importMode = ref<api.TableImportMode>("append");
+const batchSize = ref(500);
+const running = ref(false);
+const cancelling = ref(false);
+const importId = ref("");
+const progress = ref<api.TableImportProgress | null>(null);
+const errorMessage = ref("");
+const wizardStep = ref<TableImportWizardStep>("source");
+const fileInput = ref<HTMLInputElement | null>(null);
+const delimiter = ref(",");
+const titleRow = ref(1);
+const dataStartRow = ref(2);
+const lastDataRow = ref(0);
+const trimValues = ref(false);
+const emptyStringAsNull = ref(true);
+const selectedSheet = ref("");
+const jsonShape = ref<api.TableImportJsonShape>("auto");
+const previewLimit = ref(50);
+let previewReloadTimer: ReturnType<typeof setTimeout> | null = null;
+let dataTypeOptionsRequestId = 0;
+
+const formatOptions: Array<{ value: api.TableImportSourceFormat; icon: any; labelKey: string; descriptionKey: string }> = [
+  { value: "csv", icon: FileText, labelKey: "tableImport.formatCsv", descriptionKey: "tableImport.formatCsvDescription" },
+  { value: "tsv", icon: FileText, labelKey: "tableImport.formatTsv", descriptionKey: "tableImport.formatTsvDescription" },
+  { value: "delimited", icon: FileText, labelKey: "tableImport.formatDelimited", descriptionKey: "tableImport.formatDelimitedDescription" },
+  { value: "json", icon: FileJson, labelKey: "tableImport.formatJson", descriptionKey: "tableImport.formatJsonDescription" },
+  { value: "excel", icon: FileSpreadsheet, labelKey: "tableImport.formatExcel", descriptionKey: "tableImport.formatExcelDescription" },
+];
+
+const wizardSteps: Array<{ value: TableImportWizardStep; labelKey: string }> = [
+  { value: "source", labelKey: "tableImport.stepSource" },
+  { value: "options", labelKey: "tableImport.stepOptions" },
+  { value: "mapping", labelKey: "tableImport.stepMapping" },
+  { value: "review", labelKey: "tableImport.stepReview" },
+  { value: "execution", labelKey: "tableImport.stepExecution" },
+];
+
+const selectedConnection = computed(() => (props.prefillConnectionId ? store.getConfig(props.prefillConnectionId) : undefined));
+const structureDatabaseType = computed(() => tableStructureDatabaseTypeForConnection(selectedConnection.value));
+const dataTypeOptions = computed(() => mergeDataTypeOptions(dynamicDataTypeOptions.value, getDataTypeOptions(structureDatabaseType.value), Object.values(columnDataTypes.value)));
+const hasExistingTarget = computed(() => !!props.prefillTable);
+const targetTableName = computed(() => (targetMode.value === "create" ? newTableName.value.trim() : props.prefillTable || ""));
+const targetColumnNames = computed(() => targetColumns.value.map((column) => column.name));
+const mappedColumns = computed<api.TableImportColumnMapping[]>(() => {
+  const currentPreview = preview.value;
+  if (!currentPreview) return [];
+  return currentPreview.columns
+    .map((sourceColumn) => {
+      const targetDataType = targetMode.value === "create" ? String(columnDataTypes.value[sourceColumn] ?? "").trim() : undefined;
+      return {
+        sourceColumn,
+        targetColumn: columnMapping.value[sourceColumn] ?? "",
+        ...(targetMode.value === "create" ? { targetDataType } : {}),
+      };
+    })
+    .filter((mapping) => mapping.targetColumn);
+});
+const mappedCount = computed(() => mappedColumns.value.length);
+const mappingValidation = computed(() => validateImportMappings(mappedColumns.value));
+const requiredUnmappedColumns = computed(() =>
+  requiredImportTargetColumns(
+    targetColumns.value,
+    mappedColumns.value.map((mapping) => mapping.targetColumn),
+  ),
+);
+const isBatchImport = computed(() => targetMode.value === "create" && batchTasks.value.length > 1);
+const canImport = computed(() => {
+  if (running.value || !props.prefillConnectionId) return false;
+  if (!isBatchImport.value) return !!preview.value && !!targetTableName.value && mappingValidation.value.valid;
+  const tableNames = batchTasks.value.map((task) => task.tableName.trim().toLowerCase());
+  if (new Set(tableNames).size !== tableNames.length) return false;
+  return batchTasks.value.every((task) => {
+    const mappings = task.preview.columns.map((sourceColumn) => ({ sourceColumn, targetColumn: task.columnMapping[sourceColumn] ?? "", targetDataType: task.columnDataTypes[sourceColumn] ?? "" })).filter((mapping) => mapping.targetColumn);
+    return !!task.tableName.trim() && validateImportMappings(mappings).valid;
+  });
+});
+const canGoBack = computed(() => wizardStep.value !== "source" && wizardStep.value !== "execution" && !running.value);
+const canGoNext = computed(() => {
+  if (wizardStep.value === "source") return !!selectedSource.value && !!sourceFormat.value;
+  if (wizardStep.value === "options") return !!preview.value && !!targetTableName.value;
+  if (wizardStep.value === "mapping") return mappingValidation.value.valid;
+  return false;
+});
+const progressPercent = computed(() => {
+  const p = progress.value;
+  if (!p || p.totalRows <= 0) return 0;
+  return Math.min(100, Math.round((p.rowsImported / p.totalRows) * 100));
+});
+const currentStepIndex = computed(() => wizardSteps.findIndex((step) => step.value === wizardStep.value));
+const targetLabel = computed(() => {
+  const pieces = [selectedConnection.value?.name, props.prefillDatabase, props.prefillSchema, targetTableName.value].filter(Boolean);
+  return pieces.join(" / ");
+});
+const selectedSourceName = computed(() => {
+  const source = selectedSource.value;
+  if (!source) return "";
+  return typeof source === "string" ? source.split(/[\\/]/).pop() || source : source.name;
+});
+const createColumnSummaries = computed(() =>
+  mappedColumns.value.map((mapping) => ({
+    sourceColumn: mapping.sourceColumn,
+    targetColumn: mapping.targetColumn,
+    targetDataType: mapping.targetDataType || "",
+  })),
+);
+const parseOptions = computed<api.TableImportParseOptions>(() => ({
+  delimiter: sourceFormat.value === "tsv" ? "\\t" : sourceFormat.value === "csv" ? "," : delimiter.value,
+  titleRow: titleRow.value,
+  dataStartRow: dataStartRow.value,
+  lastDataRow: lastDataRow.value,
+  trimValues: trimValues.value,
+  emptyStringAsNull: emptyStringAsNull.value,
+  sheetName: sourceFormat.value === "excel" ? selectedSheet.value || null : null,
+  jsonShape: sourceFormat.value === "json" ? jsonShape.value : null,
+}));
+const terminalStatus = computed(() => progress.value?.status && ["done", "error", "cancelled"].includes(progress.value.status));
+
+function resetState() {
+  targetColumns.value = [];
+  targetMode.value = props.prefillTable ? "existing" : "create";
+  newTableName.value = "";
+  selectedSource.value = null;
+  batchTasks.value = [];
+  activeTaskIndex.value = 0;
+  sourceFormat.value = "csv";
+  delimiter.value = ",";
+  titleRow.value = 1;
+  dataStartRow.value = 2;
+  lastDataRow.value = 0;
+  trimValues.value = false;
+  emptyStringAsNull.value = true;
+  selectedSheet.value = "";
+  jsonShape.value = "auto";
+  previewLimit.value = 50;
+  preview.value = null;
+  columnMapping.value = {};
+  columnDataTypes.value = {};
+  importMode.value = "append";
+  batchSize.value = 500;
+  running.value = false;
+  cancelling.value = false;
+  importId.value = "";
+  progress.value = null;
+  errorMessage.value = "";
+  wizardStep.value = "source";
+}
+
+function detectFormat(name: string): api.TableImportSourceFormat {
+  const lower = name.toLowerCase();
+  if (lower.endsWith(".tsv")) return "tsv";
+  if (lower.endsWith(".txt")) return "delimited";
+  if (lower.endsWith(".json")) return "json";
+  if (lower.endsWith(".xls") || lower.endsWith(".xlsx") || lower.endsWith(".xlsm")) return "excel";
+  return "csv";
+}
+
+function suggestedTableName(name: string) {
+  const baseName = name.split(/[\\/]/).pop() || name;
+  const withoutExtension = baseName.replace(/\.[^.]+$/, "").trim();
+  return withoutExtension.replace(/[\s-]+/g, "_") || "imported_data";
+}
+
+function sourceName(source: ImportSource): string {
+  return typeof source === "string" ? source.split(/[\\/]/).pop() || source : source.name;
+}
+
+function uniqueTableName(baseName: string, usedNames: Set<string>): string {
+  const normalizedBase = suggestedTableName(baseName);
+  let candidate = normalizedBase;
+  let suffix = 2;
+  while (usedNames.has(candidate.toLowerCase())) candidate = `${normalizedBase}_${suffix++}`;
+  usedNames.add(candidate.toLowerCase());
+  return candidate;
+}
+
+function taskParseOptions(format: api.TableImportSourceFormat, sheetName = ""): api.TableImportParseOptions {
+  return {
+    delimiter: format === "tsv" ? "\\t" : format === "csv" ? "," : delimiter.value,
+    titleRow: titleRow.value,
+    dataStartRow: dataStartRow.value,
+    lastDataRow: lastDataRow.value,
+    trimValues: trimValues.value,
+    emptyStringAsNull: emptyStringAsNull.value,
+    sheetName: format === "excel" ? sheetName || null : null,
+    jsonShape: format === "json" ? jsonShape.value : null,
+  };
+}
+
+function mergeDataTypeOptions(...groups: readonly string[][]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const group of groups) {
+    for (const option of group) {
+      const trimmed = option.trim();
+      if (!trimmed) continue;
+      const key = trimmed.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      result.push(trimmed);
+    }
+  }
+  return result;
+}
+
+function applyAutoMapping() {
+  const currentPreview = preview.value;
+  if (!currentPreview) return;
+  if (targetMode.value === "create") {
+    columnMapping.value = Object.fromEntries(currentPreview.columns.map((source) => [source, source]));
+    return;
+  }
+  columnMapping.value = autoMapImportColumns(currentPreview.columns, targetColumnNames.value);
+}
+
+function applySuggestedColumnDataTypes(currentPreview = preview.value) {
+  if (targetMode.value !== "create" || !currentPreview) {
+    columnDataTypes.value = {};
+    return;
+  }
+  const suggested = suggestImportTargetDataTypes(currentPreview.columns, currentPreview.rows, structureDatabaseType.value);
+  const previous = columnDataTypes.value;
+  columnDataTypes.value = Object.fromEntries(currentPreview.columns.map((sourceColumn) => [sourceColumn, previous[sourceColumn]?.trim() ? previous[sourceColumn] : suggested[sourceColumn] || "TEXT"]));
+}
+
+async function loadDataTypeOptions() {
+  const requestId = ++dataTypeOptionsRequestId;
+  const connectionId = props.prefillConnectionId;
+  const database = props.prefillDatabase || "";
+  if (!connectionId || !database || targetMode.value !== "create") {
+    dynamicDataTypeOptions.value = [];
+    loadingDataTypeOptions.value = false;
+    return;
+  }
+  loadingDataTypeOptions.value = true;
+  try {
+    await store.ensureConnected(connectionId);
+    const options = await api.listDataTypes(connectionId, database);
+    if (requestId !== dataTypeOptionsRequestId) return;
+    dynamicDataTypeOptions.value = mergeDataTypeOptions(options);
+  } catch {
+    if (requestId === dataTypeOptionsRequestId) {
+      dynamicDataTypeOptions.value = [];
+    }
+  } finally {
+    if (requestId === dataTypeOptionsRequestId) {
+      loadingDataTypeOptions.value = false;
+    }
+  }
+}
+
+async function loadTargetColumns() {
+  if (targetMode.value !== "existing" || !props.prefillConnectionId || !props.prefillDatabase || !props.prefillTable) return;
+  loadingTarget.value = true;
+  errorMessage.value = "";
+  try {
+    await store.ensureConnected(props.prefillConnectionId);
+    targetColumns.value = await api.getColumns(props.prefillConnectionId, props.prefillDatabase, props.prefillSchema || props.prefillDatabase, props.prefillTable);
+    applyAutoMapping();
+  } catch (e: any) {
+    errorMessage.value = String(e?.message || e);
+  } finally {
+    loadingTarget.value = false;
+  }
+}
+
+async function previewSelectedImportFile(fileOrPath: string | File) {
+  return api.previewTableImportFile(fileOrPath, {
+    sourceFormat: sourceFormat.value,
+    parseOptions: parseOptions.value,
+    previewLimit: Math.max(1, Number(previewLimit.value) || 50),
+  });
+}
+
+async function loadPreview(fileOrPath = selectedSource.value) {
+  if (!fileOrPath) return;
+  loadingPreview.value = true;
+  errorMessage.value = "";
+  try {
+    const nextPreview = await previewSelectedImportFile(fileOrPath);
+    preview.value = nextPreview;
+    if (sourceFormat.value === "excel" && !selectedSheet.value && nextPreview.sheets?.length) {
+      selectedSheet.value = nextPreview.sheets[0];
+    }
+    applyAutoMapping();
+    applySuggestedColumnDataTypes(nextPreview);
+  } catch (e: any) {
+    preview.value = null;
+    columnMapping.value = {};
+    columnDataTypes.value = {};
+    errorMessage.value = String(e?.message || e);
+  } finally {
+    loadingPreview.value = false;
+  }
+}
+
+function assignSelectedSource(source: string | File) {
+  batchTasks.value = [];
+  selectedSource.value = source;
+  preview.value = null;
+  columnMapping.value = {};
+  columnDataTypes.value = {};
+  progress.value = null;
+  errorMessage.value = "";
+  const name = typeof source === "string" ? source : source.name;
+  sourceFormat.value = detectFormat(name);
+  if (!newTableName.value.trim()) {
+    newTableName.value = suggestedTableName(name);
+  }
+  delimiter.value = sourceFormat.value === "tsv" ? "\\t" : ",";
+  selectedSheet.value = "";
+  wizardStep.value = "options";
+}
+
+function activateBatchTask(index: number) {
+  const task = batchTasks.value[index];
+  if (!task || running.value) return;
+  activeTaskIndex.value = index;
+  selectedSource.value = task.source;
+  sourceFormat.value = task.format;
+  selectedSheet.value = task.sheetName;
+  newTableName.value = task.tableName;
+  preview.value = task.preview;
+  columnMapping.value = { ...task.columnMapping };
+  columnDataTypes.value = { ...task.columnDataTypes };
+}
+
+function saveActiveBatchTask() {
+  if (!isBatchImport.value) return;
+  const task = batchTasks.value[activeTaskIndex.value];
+  if (!task) return;
+  task.tableName = newTableName.value.trim();
+  task.columnMapping = { ...columnMapping.value };
+  task.columnDataTypes = { ...columnDataTypes.value };
+}
+
+async function prepareBatchSources(sources: ImportSource[]) {
+  loadingPreview.value = true;
+  errorMessage.value = "";
+  const tasks: BatchImportTask[] = [];
+  const usedNames = new Set<string>();
+  try {
+    for (const source of sources) {
+      const format = detectFormat(sourceName(source));
+      const initialPreview = await api.previewTableImportFile(source, {
+        sourceFormat: format,
+        parseOptions: taskParseOptions(format),
+        previewLimit: Math.max(1, Number(previewLimit.value) || 50),
+      });
+      const sheets = format === "excel" && initialPreview.sheets?.length ? initialPreview.sheets : [""];
+      for (const sheetName of sheets) {
+        const taskPreview =
+          sheetName && sheetName !== initialPreview.sheets?.[0]
+            ? await api.previewTableImportFile(source, {
+                sourceFormat: format,
+                parseOptions: taskParseOptions(format, sheetName),
+                previewLimit: Math.max(1, Number(previewLimit.value) || 50),
+              })
+            : initialPreview;
+        const tableBase = sheetName ? `${suggestedTableName(sourceName(source))}_${sheetName}` : sourceName(source);
+        tasks.push({
+          id: uuid(),
+          source,
+          format,
+          sheetName,
+          tableName: uniqueTableName(tableBase, usedNames),
+          preview: taskPreview,
+          columnMapping: Object.fromEntries(taskPreview.columns.map((column) => [column, column])),
+          columnDataTypes: suggestImportTargetDataTypes(taskPreview.columns, taskPreview.rows, structureDatabaseType.value),
+          status: "pending",
+          rowsImported: 0,
+        });
+      }
+    }
+    batchTasks.value = tasks;
+    if (tasks.length) {
+      activateBatchTask(0);
+      wizardStep.value = "options";
+    }
+  } catch (e: any) {
+    batchTasks.value = [];
+    errorMessage.value = String(e?.message || e);
+  } finally {
+    loadingPreview.value = false;
+  }
+}
+
+async function selectFile() {
+  if (!isTauriRuntime()) {
+    fileInput.value?.click();
+    return;
+  }
+  const { open } = await import("@tauri-apps/plugin-dialog");
+  const selected = await open({
+    multiple: targetMode.value === "create",
+    filters: [
+      { name: "Data files", extensions: ["csv", "tsv", "txt", "json", "xlsx", "xlsm", "xls"] },
+      { name: "Text", extensions: ["csv", "tsv", "txt"] },
+      { name: "JSON", extensions: ["json"] },
+      { name: "Excel", extensions: ["xlsx", "xlsm", "xls"] },
+    ],
+  });
+  if (!selected) return;
+  const sources = Array.isArray(selected) ? selected : [selected];
+  if (targetMode.value === "create") await prepareBatchSources(sources);
+  else assignSelectedSource(sources[0]);
+}
+
+async function handleFileInputChange(event: Event) {
+  const input = event.target as HTMLInputElement;
+  const files = Array.from(input.files || []);
+  input.value = "";
+  if (!files.length || running.value) return;
+  if (targetMode.value === "create") await prepareBatchSources(files);
+  else assignSelectedSource(files[0]);
+}
+
+function updateMapping(sourceColumn: string, value: any) {
+  const target = String(value);
+  columnMapping.value = {
+    ...columnMapping.value,
+    [sourceColumn]: target === SKIP_VALUE ? "" : target,
+  };
+}
+
+function updateColumnDataType(sourceColumn: string, value: any) {
+  columnDataTypes.value = {
+    ...columnDataTypes.value,
+    [sourceColumn]: String(value),
+  };
+}
+
+function formatCell(value: unknown) {
+  if (value === null) return "NULL";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+
+function goBack() {
+  wizardStep.value = previousTableImportWizardStep(wizardStep.value);
+}
+
+function canOpenStep(step: TableImportWizardStep) {
+  if (running.value || step === "execution") return false;
+  if (step === "source") return true;
+  if (step === "options") return !!selectedSource.value;
+  if (step === "mapping") return !!preview.value;
+  if (step === "review") return !!preview.value && mappingValidation.value.valid;
+  return false;
+}
+
+function wizardStepIndex(step: TableImportWizardStep) {
+  return wizardSteps.findIndex((item) => item.value === step);
+}
+
+function isWizardStepActive(step: TableImportWizardStep) {
+  return step === wizardStep.value;
+}
+
+function isWizardStepComplete(step: TableImportWizardStep) {
+  return wizardStepIndex(step) < currentStepIndex.value;
+}
+
+function wizardStepConnectorClass(index: number, leading: boolean) {
+  return (leading ? index <= currentStepIndex.value : index < currentStepIndex.value) ? "bg-primary/60" : "bg-border";
+}
+
+function wizardStepTextClass(step: TableImportWizardStep) {
+  if (isWizardStepActive(step)) return "text-foreground";
+  if (isWizardStepComplete(step)) return "text-foreground hover:bg-muted/40";
+  return "text-muted-foreground";
+}
+
+function wizardStepCircleClass(step: TableImportWizardStep) {
+  if (isWizardStepActive(step)) return "border-primary bg-primary text-primary-foreground shadow-sm";
+  if (isWizardStepComplete(step)) return "border-primary/70 bg-background text-primary";
+  return "border-border bg-background text-muted-foreground";
+}
+
+async function goNext() {
+  if (wizardStep.value === "options" && !preview.value) {
+    await loadPreview();
+    if (!preview.value) return;
+  }
+  wizardStep.value = nextTableImportWizardStep(wizardStep.value);
+}
+
+async function startImport() {
+  saveActiveBatchTask();
+  if (isBatchImport.value) {
+    await startBatchImport();
+    return;
+  }
+  const currentPreview = preview.value;
+  const tableName = targetTableName.value;
+  if (!canImport.value || !currentPreview || !props.prefillConnectionId || !tableName) return;
+  running.value = true;
+  cancelling.value = false;
+  errorMessage.value = "";
+  wizardStep.value = "execution";
+  importId.value = uuid();
+  progress.value = {
+    importId: importId.value,
+    status: "running",
+    rowsImported: 0,
+    totalRows: currentPreview.totalRows,
+  };
+
+  try {
+    const summary = await api.importTableFile(
+      {
+        importId: importId.value,
+        connectionId: props.prefillConnectionId,
+        database: props.prefillDatabase || "",
+        schema: props.prefillSchema || "",
+        table: tableName,
+        filePath: currentPreview.filePath,
+        sourceRef: currentPreview.sourceRef || null,
+        sourceFormat: sourceFormat.value,
+        parseOptions: parseOptions.value,
+        mappings: mappedColumns.value,
+        mode: targetMode.value === "create" ? "append" : importMode.value,
+        createTable: targetMode.value === "create",
+        batchSize: Math.max(1, Number(batchSize.value) || 500),
+      },
+      (nextProgress) => {
+        progress.value = nextProgress;
+      },
+    );
+    progress.value = { importId: summary.importId, status: "done", rowsImported: summary.rowsImported, totalRows: summary.totalRows };
+    toast(t("tableImport.success", { count: summary.rowsImported }), 2500);
+    store.invalidateMetadataCache(props.prefillConnectionId, props.prefillDatabase || "", props.prefillSchema || undefined, tableName);
+    if (targetMode.value === "create") {
+      store.refreshObjectListTreeNode(props.prefillConnectionId, props.prefillDatabase || "", props.prefillSchema || undefined).catch((error) => {
+        console.warn("[DBX][table-import:refresh-created-table-failed]", error);
+      });
+    }
+  } catch (e: any) {
+    const message = String(e?.message || e);
+    errorMessage.value = message;
+    progress.value = {
+      importId: importId.value,
+      status: progress.value?.status === "cancelled" ? "cancelled" : "error",
+      rowsImported: progress.value?.rowsImported ?? 0,
+      totalRows: progress.value?.totalRows ?? currentPreview.totalRows,
+      error: message,
+    };
+  } finally {
+    running.value = false;
+    cancelling.value = false;
+  }
+}
+
+async function startBatchImport() {
+  if (!props.prefillConnectionId || !batchTasks.value.length || running.value) return;
+  running.value = true;
+  cancelling.value = false;
+  errorMessage.value = "";
+  wizardStep.value = "execution";
+  const totalRows = batchTasks.value.reduce((sum, task) => sum + task.preview.totalRows, 0);
+  let completedRows = 0;
+  importId.value = uuid();
+  progress.value = { importId: importId.value, status: "running", rowsImported: 0, totalRows };
+
+  try {
+    const tableNames = batchTasks.value.map((task) => task.tableName.trim().toLowerCase());
+    if (new Set(tableNames).size !== tableNames.length) throw new Error("Target table names must be unique");
+    for (let index = 0; index < batchTasks.value.length; index++) {
+      const task = batchTasks.value[index];
+      activeTaskIndex.value = index;
+      task.status = "running";
+      importId.value = uuid();
+      const mappings = task.preview.columns
+        .map((sourceColumn) => ({
+          sourceColumn,
+          targetColumn: task.columnMapping[sourceColumn] ?? "",
+          targetDataType: String(task.columnDataTypes[sourceColumn] ?? "").trim(),
+        }))
+        .filter((mapping) => mapping.targetColumn);
+      const validation = validateImportMappings(mappings);
+      if (!task.tableName.trim() || !validation.valid) {
+        throw new Error(validation.errors[0] || "Target table name is required");
+      }
+
+      const summary = await api.importTableFile(
+        {
+          importId: importId.value,
+          connectionId: props.prefillConnectionId,
+          database: props.prefillDatabase || "",
+          schema: props.prefillSchema || "",
+          table: task.tableName,
+          filePath: task.preview.filePath,
+          sourceRef: task.preview.sourceRef || null,
+          sourceFormat: task.format,
+          parseOptions: taskParseOptions(task.format, task.sheetName),
+          mappings,
+          mode: "append",
+          createTable: true,
+          batchSize: Math.max(1, Number(batchSize.value) || 500),
+        },
+        (nextProgress) => {
+          task.rowsImported = nextProgress.rowsImported;
+          progress.value = { ...nextProgress, rowsImported: completedRows + nextProgress.rowsImported, totalRows };
+        },
+      );
+      task.status = "done";
+      task.rowsImported = summary.rowsImported;
+      completedRows += summary.rowsImported;
+      store.invalidateMetadataCache(props.prefillConnectionId, props.prefillDatabase || "", props.prefillSchema || undefined, task.tableName);
+    }
+    progress.value = { importId: importId.value, status: "done", rowsImported: completedRows, totalRows };
+    toast(t("tableImport.success", { count: completedRows }), 2500);
+    store.refreshObjectListTreeNode(props.prefillConnectionId, props.prefillDatabase || "", props.prefillSchema || undefined).catch((error) => {
+      console.warn("[DBX][table-import:refresh-created-table-failed]", error);
+    });
+  } catch (e: any) {
+    const task = batchTasks.value[activeTaskIndex.value];
+    const message = String(e?.message || e);
+    if (task) {
+      task.status = progress.value?.status === "cancelled" ? "cancelled" : "error";
+      task.error = message;
+    }
+    errorMessage.value = message;
+    progress.value = {
+      importId: importId.value,
+      status: progress.value?.status === "cancelled" ? "cancelled" : "error",
+      rowsImported: progress.value?.rowsImported ?? completedRows,
+      totalRows,
+      error: message,
+    };
+  } finally {
+    running.value = false;
+    cancelling.value = false;
+  }
+}
+
+async function cancelImport() {
+  if (!importId.value) return;
+  cancelling.value = true;
+  await api.cancelTableImport(importId.value);
+}
+
+function schedulePreviewReload() {
+  // Batch tasks own independent previews and mappings; reloading the active task would overwrite its saved configuration.
+  if (isBatchImport.value || !preview.value || !selectedSource.value || loadingPreview.value || running.value) return;
+  if (previewReloadTimer) clearTimeout(previewReloadTimer);
+  previewReloadTimer = setTimeout(() => {
+    void loadPreview();
+  }, 250);
+}
+
+watch(
+  open,
+  (value) => {
+    if (value) {
+      resetState();
+      void loadTargetColumns();
+      void loadDataTypeOptions();
+    }
+  },
+  { immediate: true },
+);
+
+watch([sourceFormat, delimiter, titleRow, dataStartRow, lastDataRow, trimValues, emptyStringAsNull, selectedSheet, jsonShape, previewLimit], schedulePreviewReload);
+watch([newTableName, columnMapping, columnDataTypes], saveActiveBatchTask, { deep: true });
+watch(targetMode, (mode) => {
+  if (mode === "existing") {
+    columnDataTypes.value = {};
+    dynamicDataTypeOptions.value = [];
+    void loadTargetColumns();
+  } else {
+    targetColumns.value = [];
+    importMode.value = "append";
+    applyAutoMapping();
+    applySuggestedColumnDataTypes();
+    void loadDataTypeOptions();
+  }
+});
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogScrollContent class="sm:max-w-[980px]" :trap-focus="false" @interact-outside.prevent>
+      <DialogHeader class="pr-8">
+        <DialogTitle class="flex items-center gap-2 text-base">
+          <FileUp class="h-4 w-4" />
+          {{ t("tableImport.title") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="space-y-4 py-2">
+        <div class="grid grid-cols-[minmax(0,1fr)_auto] items-center gap-2">
+          <input ref="fileInput" type="file" accept=".csv,.tsv,.txt,.json,.xlsx,.xlsm,.xls" :multiple="targetMode === 'create'" class="hidden" @change="handleFileInputChange" />
+          <div class="flex h-10 min-w-0 items-center gap-2 rounded-md border bg-muted/20 px-3">
+            <span class="shrink-0 text-xs text-muted-foreground">{{ t("tableImport.target") }}</span>
+            <span class="min-w-0 truncate text-sm font-medium">
+              {{ targetLabel || t("editor.noDatabase") }}
+            </span>
+          </div>
+          <Button variant="outline" class="h-10 px-3" :disabled="running || loadingPreview" @click="selectFile">
+            <Loader2 v-if="loadingPreview" class="mr-1.5 h-3.5 w-3.5 animate-spin" />
+            <Upload v-else class="mr-1.5 h-3.5 w-3.5" />
+            {{ selectedSource ? t("tableImport.changeFile") : t("tableImport.selectFile") }}
+          </Button>
+        </div>
+
+        <div v-if="isBatchImport" class="rounded-md border">
+          <div class="flex items-center justify-between border-b px-3 py-2 text-xs font-medium">
+            <span>{{ batchTasks.length }} {{ t("tableImport.file") }}</span>
+            <span class="text-muted-foreground">{{ selectedSourceName }}</span>
+          </div>
+          <div class="flex max-h-32 flex-wrap gap-1.5 overflow-auto p-2">
+            <button
+              v-for="(task, index) in batchTasks"
+              :key="task.id"
+              type="button"
+              class="flex max-w-[260px] items-center gap-1.5 rounded-md border px-2 py-1 text-xs transition-colors"
+              :class="index === activeTaskIndex ? 'border-primary bg-primary/10 text-primary' : 'hover:bg-muted/60'"
+              :disabled="running"
+              @click="
+                saveActiveBatchTask();
+                activateBatchTask(index);
+              "
+            >
+              <CheckCircle2 v-if="task.status === 'done'" class="h-3.5 w-3.5 shrink-0 text-emerald-500" />
+              <Loader2 v-else-if="task.status === 'running'" class="h-3.5 w-3.5 shrink-0 animate-spin" />
+              <AlertTriangle v-else-if="task.status === 'error'" class="h-3.5 w-3.5 shrink-0 text-destructive" />
+              <FileSpreadsheet v-else-if="task.format === 'excel'" class="h-3.5 w-3.5 shrink-0" />
+              <FileText v-else class="h-3.5 w-3.5 shrink-0" />
+              <span class="truncate">{{ task.tableName }}</span>
+            </button>
+          </div>
+        </div>
+
+        <nav class="rounded-md border bg-muted/20 px-3 py-2" :aria-label="t('tableImport.progress')">
+          <ol class="grid grid-cols-5">
+            <li v-for="(step, index) in wizardSteps" :key="step.value" class="relative flex min-w-0 justify-center">
+              <div v-if="index > 0" class="pointer-events-none absolute left-0 right-1/2 top-3.5 h-px" :class="wizardStepConnectorClass(index, true)" />
+              <div v-if="index < wizardSteps.length - 1" class="pointer-events-none absolute left-1/2 right-0 top-3.5 h-px" :class="wizardStepConnectorClass(index, false)" />
+              <button
+                type="button"
+                class="relative z-10 flex min-w-0 flex-col items-center gap-1 rounded-md px-2 py-1 text-xs font-medium transition-colors"
+                :class="[wizardStepTextClass(step.value), canOpenStep(step.value) ? 'cursor-pointer' : 'cursor-default']"
+                :disabled="!canOpenStep(step.value)"
+                :aria-current="isWizardStepActive(step.value) ? 'step' : undefined"
+                @click="wizardStep = step.value"
+              >
+                <span class="flex h-6 w-6 shrink-0 items-center justify-center rounded-full border text-[11px] font-semibold" :class="wizardStepCircleClass(step.value)">
+                  <Check v-if="isWizardStepComplete(step.value)" class="h-3.5 w-3.5" />
+                  <span v-else>{{ index + 1 }}</span>
+                </span>
+                <span class="max-w-full truncate">{{ t(step.labelKey) }}</span>
+              </button>
+            </li>
+          </ol>
+        </nav>
+
+        <div v-if="wizardStep === 'source'" class="space-y-4">
+          <div class="rounded-md border border-dashed p-6 text-center">
+            <FileUp class="mx-auto mb-3 h-8 w-8 text-muted-foreground" />
+            <div class="text-sm font-medium">{{ selectedSourceName || t("tableImport.noFileSelected") }}</div>
+            <Button class="mt-4" size="sm" @click="selectFile">
+              <Upload class="mr-1.5 h-3.5 w-3.5" />
+              {{ t("tableImport.selectFile") }}
+            </Button>
+          </div>
+          <div class="grid grid-cols-5 gap-2">
+            <button v-for="format in formatOptions" :key="format.value" type="button" class="min-h-20 rounded-md border px-3 py-2 text-left" :class="sourceFormat === format.value ? 'border-primary bg-primary/5' : 'hover:bg-muted/30'" @click="sourceFormat = format.value">
+              <component :is="format.icon" class="mb-2 h-4 w-4 text-muted-foreground" />
+              <div class="text-xs font-medium">{{ t(format.labelKey) }}</div>
+              <div class="mt-1 text-[11px] leading-snug text-muted-foreground">{{ t(format.descriptionKey) }}</div>
+            </button>
+          </div>
+        </div>
+
+        <div v-else-if="wizardStep === 'options'" class="space-y-4">
+          <div class="grid grid-cols-3 gap-3">
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.sourceFormat") }}</Label>
+              <Select :model-value="sourceFormat" @update:model-value="(value: any) => (sourceFormat = value)">
+                <SelectTrigger class="h-8 text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem v-for="format in formatOptions" :key="format.value" :value="format.value">
+                    {{ t(format.labelKey) }}
+                  </SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.previewRows") }}</Label>
+              <Input v-model.number="previewLimit" type="number" min="1" max="500" class="h-8 text-xs" />
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.sourceFile") }}</Label>
+              <div class="flex h-8 items-center rounded-md border px-2 text-xs">
+                <span class="truncate">{{ selectedSourceName || t("tableImport.noFileSelected") }}</span>
+              </div>
+            </div>
+          </div>
+
+          <div class="grid grid-cols-[minmax(0,1fr)_minmax(220px,320px)] gap-3 rounded-md border p-3">
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.targetMode") }}</Label>
+              <div class="grid grid-cols-2 gap-2">
+                <button type="button" class="rounded-md border px-3 py-2 text-left text-xs" :class="targetMode === 'existing' ? 'border-primary bg-primary/5' : 'hover:bg-muted/30'" :disabled="!hasExistingTarget" @click="targetMode = 'existing'">
+                  <div class="font-medium">{{ t("tableImport.existingTable") }}</div>
+                  <div class="mt-1 truncate text-[11px] text-muted-foreground">{{ props.prefillTable || t("tableImport.noExistingTarget") }}</div>
+                </button>
+                <button type="button" class="rounded-md border px-3 py-2 text-left text-xs" :class="targetMode === 'create' ? 'border-primary bg-primary/5' : 'hover:bg-muted/30'" @click="targetMode = 'create'">
+                  <div class="font-medium">{{ t("tableImport.createTable") }}</div>
+                  <div class="mt-1 text-[11px] text-muted-foreground">{{ t("tableImport.createTableHint") }}</div>
+                </button>
+              </div>
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.targetTableName") }}</Label>
+              <Input v-if="targetMode === 'create'" v-model="newTableName" class="h-8 text-xs font-mono" />
+              <div v-else class="flex h-8 items-center rounded-md border px-2 text-xs">
+                <span class="truncate">{{ props.prefillTable }}</span>
+              </div>
+            </div>
+          </div>
+
+          <div v-if="sourceFormat === 'csv' || sourceFormat === 'tsv' || sourceFormat === 'delimited'" class="grid grid-cols-4 gap-3 rounded-md border p-3">
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.delimiter") }}</Label>
+              <Input v-model="delimiter" :disabled="sourceFormat !== 'delimited'" class="h-8 text-xs font-mono" />
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.titleRow") }}</Label>
+              <Input v-model.number="titleRow" type="number" min="0" class="h-8 text-xs" />
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.dataStartRow") }}</Label>
+              <Input v-model.number="dataStartRow" type="number" min="1" class="h-8 text-xs" />
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.lastDataRow") }}</Label>
+              <Input v-model.number="lastDataRow" type="number" min="0" class="h-8 text-xs" />
+            </div>
+            <label class="flex items-center gap-2 text-xs">
+              <input v-model="trimValues" type="checkbox" class="h-3.5 w-3.5 accent-primary" />
+              {{ t("tableImport.trimValues") }}
+            </label>
+            <label class="flex items-center gap-2 text-xs">
+              <input v-model="emptyStringAsNull" type="checkbox" class="h-3.5 w-3.5 accent-primary" />
+              {{ t("tableImport.emptyStringAsNull") }}
+            </label>
+          </div>
+
+          <div v-else-if="sourceFormat === 'json'" class="grid grid-cols-2 gap-3 rounded-md border p-3">
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.jsonShape") }}</Label>
+              <Select :model-value="jsonShape" @update:model-value="(value: any) => (jsonShape = value)">
+                <SelectTrigger class="h-8 text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="auto">{{ t("tableImport.jsonShapeAuto") }}</SelectItem>
+                  <SelectItem value="objects">{{ t("tableImport.jsonShapeObjects") }}</SelectItem>
+                  <SelectItem value="arrays">{{ t("tableImport.jsonShapeArrays") }}</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+          </div>
+
+          <div v-else-if="sourceFormat === 'excel'" class="grid grid-cols-4 gap-3 rounded-md border p-3">
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.sheet") }}</Label>
+              <Select :model-value="selectedSheet" :disabled="!preview?.sheets?.length" @update:model-value="(value: any) => (selectedSheet = value)">
+                <SelectTrigger class="h-8 text-xs">
+                  <SelectValue :placeholder="t('tableImport.firstSheet')" />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem v-for="sheet in preview?.sheets || []" :key="sheet" :value="sheet">{{ sheet }}</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.titleRow") }}</Label>
+              <Input v-model.number="titleRow" type="number" min="0" class="h-8 text-xs" />
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.dataStartRow") }}</Label>
+              <Input v-model.number="dataStartRow" type="number" min="1" class="h-8 text-xs" />
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.lastDataRow") }}</Label>
+              <Input v-model.number="lastDataRow" type="number" min="0" class="h-8 text-xs" />
+            </div>
+          </div>
+
+          <div class="flex items-center gap-2">
+            <Button size="sm" :disabled="!selectedSource || loadingPreview" @click="loadPreview()">
+              <Loader2 v-if="loadingPreview" class="mr-1.5 h-3.5 w-3.5 animate-spin" />
+              <RefreshCw v-else class="mr-1.5 h-3.5 w-3.5" />
+              {{ preview ? t("tableImport.reloadPreview") : t("tableImport.loadPreview") }}
+            </Button>
+            <span v-if="preview" class="text-xs text-muted-foreground">{{ t("tableImport.previewReady", { rows: preview.totalRows, columns: preview.columns.length }) }}</span>
+          </div>
+        </div>
+
+        <div v-else-if="wizardStep === 'mapping'" class="space-y-3">
+          <div v-if="preview" class="grid grid-cols-3 gap-2 text-xs">
+            <div class="rounded-md border px-3 py-2">
+              <div class="text-muted-foreground">{{ t("tableImport.file") }}</div>
+              <div class="truncate font-medium">{{ preview.fileName }}</div>
+            </div>
+            <div class="rounded-md border px-3 py-2">
+              <div class="text-muted-foreground">{{ t("tableImport.rows") }}</div>
+              <div class="font-medium">{{ preview.totalRows.toLocaleString() }}</div>
+            </div>
+            <div class="rounded-md border px-3 py-2">
+              <div class="text-muted-foreground">{{ t("tableImport.mapped") }}</div>
+              <div class="font-medium">{{ mappedCount }} / {{ preview.columns.length }}</div>
+            </div>
+          </div>
+
+          <div v-if="preview" class="grid gap-3" :class="targetMode === 'create' ? 'grid-cols-[minmax(360px,460px)_1fr]' : 'grid-cols-[minmax(240px,300px)_1fr]'">
+            <div class="rounded-md border">
+              <div class="border-b px-3 py-2 text-xs font-medium">{{ t("tableImport.mapping") }}</div>
+              <div class="max-h-[320px] overflow-auto p-2">
+                <div class="grid items-center gap-2 border-b px-1 pb-1 text-[11px] font-medium text-muted-foreground" :class="targetMode === 'create' ? 'grid-cols-[minmax(0,1fr)_minmax(0,1fr)_minmax(92px,120px)]' : 'grid-cols-[1fr_1fr]'">
+                  <span>{{ t("tableImport.sourceColumn") }}</span>
+                  <span>{{ t("tableImport.targetColumn") }}</span>
+                  <span v-if="targetMode === 'create'">{{ t("tableImport.targetDataType") }}</span>
+                </div>
+                <div v-for="sourceColumn in preview.columns" :key="sourceColumn" class="grid items-center gap-2 py-1" :class="targetMode === 'create' ? 'grid-cols-[minmax(0,1fr)_minmax(0,1fr)_minmax(92px,120px)]' : 'grid-cols-[1fr_1fr]'">
+                  <div class="truncate font-mono text-xs" :title="sourceColumn">
+                    {{ sourceColumn }}
+                  </div>
+                  <Input v-if="targetMode === 'create'" :model-value="columnMapping[sourceColumn] ?? sourceColumn" class="h-7 text-xs font-mono" @update:model-value="(value: any) => updateMapping(sourceColumn, value)" />
+                  <Select v-else :model-value="columnMapping[sourceColumn] || SKIP_VALUE" @update:model-value="(value: any) => updateMapping(sourceColumn, value)">
+                    <SelectTrigger class="h-7 text-xs">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem :value="SKIP_VALUE">{{ t("tableImport.skipColumn") }}</SelectItem>
+                      <SelectItem v-for="column in targetColumns" :key="column.name" :value="column.name">
+                        {{ column.name }}
+                      </SelectItem>
+                    </SelectContent>
+                  </Select>
+                  <SearchableSelect
+                    v-if="targetMode === 'create'"
+                    :model-value="columnDataTypes[sourceColumn] || ''"
+                    :placeholder="t('tableImport.targetDataType')"
+                    :search-placeholder="t('tableImport.targetDataType')"
+                    :empty-text="t('structureEditor.noMatchingType')"
+                    :loading-text="t('common.loading')"
+                    :loading="loadingDataTypeOptions"
+                    :options="dataTypeOptions"
+                    :allow-custom="true"
+                    :trigger-class="'h-7 w-full max-w-none rounded-md border bg-background px-2 text-xs font-mono shadow-none hover:bg-muted/30 focus-visible:ring-1 focus-visible:ring-ring/25'"
+                    :content-class="'w-56'"
+                    :item-class="'font-mono text-xs'"
+                    :trigger-icon-class="'h-3 w-3'"
+                    @update:model-value="(value: any) => updateColumnDataType(sourceColumn, value)"
+                  />
+                </div>
+              </div>
+            </div>
+
+            <div class="min-w-0 rounded-md border">
+              <div class="border-b px-3 py-2 text-xs font-medium">{{ t("tableImport.preview") }}</div>
+              <div class="max-h-[320px] overflow-auto">
+                <table class="min-w-full border-separate border-spacing-0 text-xs">
+                  <thead class="sticky top-0 bg-background">
+                    <tr>
+                      <th v-for="column in preview.columns" :key="column" class="border-b border-r px-2 py-1.5 text-left font-medium">
+                        <span class="block max-w-[140px] truncate">{{ column }}</span>
+                      </th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    <tr v-for="(row, rowIndex) in preview.rows" :key="rowIndex">
+                      <td v-for="(cell, colIndex) in row" :key="colIndex" class="max-w-[180px] border-b border-r px-2 py-1.5 font-mono" :class="{ 'text-muted-foreground': cell === null }">
+                        <span class="block truncate">{{ formatCell(cell) }}</span>
+                      </td>
+                    </tr>
+                  </tbody>
+                </table>
+              </div>
+            </div>
+          </div>
+
+          <div v-if="mappingValidation.errors.length" class="rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+            {{ mappingValidation.errors.join("; ") }}
+          </div>
+          <div v-else-if="requiredUnmappedColumns.length" class="flex items-start gap-2 rounded-md border border-amber-300 bg-amber-50 px-3 py-2 text-xs text-amber-800 dark:bg-amber-950/20 dark:text-amber-300">
+            <AlertTriangle class="mt-0.5 h-3.5 w-3.5 shrink-0" />
+            <span>{{ t("tableImport.requiredUnmapped", { columns: requiredUnmappedColumns.join(", ") }) }}</span>
+          </div>
+        </div>
+
+        <div v-else-if="wizardStep === 'review'" class="space-y-3">
+          <div class="grid grid-cols-2 gap-3 text-xs">
+            <div class="rounded-md border px-3 py-2">
+              <div class="text-muted-foreground">{{ t("tableImport.target") }}</div>
+              <div class="truncate font-medium">{{ targetLabel }}</div>
+            </div>
+            <div class="rounded-md border px-3 py-2">
+              <div class="text-muted-foreground">{{ t("tableImport.sourceFile") }}</div>
+              <div class="truncate font-medium">{{ preview?.fileName }}</div>
+            </div>
+            <div class="rounded-md border px-3 py-2">
+              <div class="text-muted-foreground">{{ t("tableImport.rows") }}</div>
+              <div class="font-medium">{{ preview?.totalRows.toLocaleString() }}</div>
+            </div>
+            <div class="rounded-md border px-3 py-2">
+              <div class="text-muted-foreground">{{ t("tableImport.mapped") }}</div>
+              <div class="font-medium">{{ mappedCount }} / {{ preview?.columns.length || 0 }}</div>
+            </div>
+          </div>
+          <div class="grid grid-cols-3 gap-3">
+            <div v-if="targetMode === 'existing'" class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.mode") }}</Label>
+              <Select :model-value="importMode" @update:model-value="(value: any) => (importMode = value)">
+                <SelectTrigger class="h-8 text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="append">{{ t("tableImport.append") }}</SelectItem>
+                  <SelectItem value="truncate">{{ t("tableImport.truncate") }}</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("transfer.batchSize") }}</Label>
+              <Input v-model.number="batchSize" type="number" min="1" class="h-8 text-xs" />
+            </div>
+          </div>
+          <div v-if="targetMode === 'create' && createColumnSummaries.length" class="rounded-md border">
+            <div class="border-b px-3 py-2 text-xs font-medium">{{ t("tableImport.createColumns") }}</div>
+            <div class="max-h-40 overflow-auto">
+              <table class="min-w-full border-separate border-spacing-0 text-xs">
+                <thead class="sticky top-0 bg-background">
+                  <tr>
+                    <th class="border-b border-r px-2 py-1.5 text-left font-medium">{{ t("tableImport.sourceColumn") }}</th>
+                    <th class="border-b border-r px-2 py-1.5 text-left font-medium">{{ t("tableImport.targetColumn") }}</th>
+                    <th class="border-b px-2 py-1.5 text-left font-medium">{{ t("tableImport.targetDataType") }}</th>
+                  </tr>
+                </thead>
+                <tbody>
+                  <tr v-for="column in createColumnSummaries" :key="column.sourceColumn">
+                    <td class="max-w-[180px] border-b border-r px-2 py-1.5 font-mono">
+                      <span class="block truncate">{{ column.sourceColumn }}</span>
+                    </td>
+                    <td class="max-w-[180px] border-b border-r px-2 py-1.5 font-mono">
+                      <span class="block truncate">{{ column.targetColumn }}</span>
+                    </td>
+                    <td class="max-w-[140px] border-b px-2 py-1.5 font-mono">
+                      <span class="block truncate">{{ column.targetDataType }}</span>
+                    </td>
+                  </tr>
+                </tbody>
+              </table>
+            </div>
+          </div>
+          <div v-if="importMode === 'truncate'" class="flex items-start gap-2 rounded-md border border-amber-300 bg-amber-50 px-3 py-2 text-xs text-amber-800 dark:bg-amber-950/20 dark:text-amber-300">
+            <AlertTriangle class="mt-0.5 h-3.5 w-3.5 shrink-0" />
+            <span>{{ t("tableImport.truncateWarning") }}</span>
+          </div>
+        </div>
+
+        <div v-else class="space-y-4">
+          <div class="rounded-md border px-4 py-5">
+            <div class="flex items-center gap-3">
+              <Loader2 v-if="running && !cancelling" class="h-5 w-5 animate-spin text-primary" />
+              <Square v-else-if="cancelling || progress?.status === 'cancelled'" class="h-5 w-5 fill-current text-destructive" />
+              <CheckCircle2 v-else-if="progress?.status === 'done'" class="h-5 w-5 text-emerald-600" />
+              <AlertTriangle v-else-if="progress?.status === 'error'" class="h-5 w-5 text-destructive" />
+              <FileUp v-else class="h-5 w-5 text-muted-foreground" />
+              <div class="min-w-0 flex-1">
+                <div class="text-sm font-medium">{{ t(`tableImport.status_${progress?.status || "idle"}`) }}</div>
+                <div class="mt-1 text-xs text-muted-foreground">{{ progress?.rowsImported ?? 0 }} / {{ progress?.totalRows ?? preview?.totalRows ?? 0 }} · {{ progressPercent }}%</div>
+              </div>
+            </div>
+            <div class="mt-4 h-2 overflow-hidden rounded bg-muted">
+              <div class="h-full bg-primary transition-all" :style="{ width: `${progressPercent}%` }" />
+            </div>
+          </div>
+          <div v-if="errorMessage || progress?.error" class="rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+            {{ errorMessage || progress?.error }}
+          </div>
+        </div>
+
+        <div v-if="loadingTarget" class="flex items-center gap-2 text-xs text-muted-foreground">
+          <Loader2 class="h-3.5 w-3.5 animate-spin" />
+          {{ t("common.loading") }}
+        </div>
+        <div v-if="errorMessage && wizardStep !== 'execution'" class="rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+          {{ errorMessage }}
+        </div>
+      </div>
+
+      <DialogFooter>
+        <Button variant="outline" :disabled="running" @click="open = false">
+          <X class="mr-1.5 h-3.5 w-3.5" />
+          {{ terminalStatus ? t("common.close") : t("dangerDialog.cancel") }}
+        </Button>
+        <Button v-if="canGoBack" variant="outline" @click="goBack">
+          <ArrowLeft class="mr-1.5 h-3.5 w-3.5" />
+          {{ t("tableImport.back") }}
+        </Button>
+        <Button v-if="wizardStep === 'source' || wizardStep === 'options' || wizardStep === 'mapping'" :disabled="!canGoNext || loadingPreview" @click="goNext">
+          <ArrowRight class="mr-1.5 h-3.5 w-3.5" />
+          {{ t("tableImport.next") }}
+        </Button>
+        <Button v-else-if="wizardStep === 'review'" :disabled="!canImport" @click="startImport">
+          <Upload class="mr-1.5 h-3.5 w-3.5" />
+          {{ t("tableImport.start") }}
+        </Button>
+        <Button v-else-if="running" variant="destructive" :disabled="cancelling" @click="cancelImport">
+          <Loader2 v-if="cancelling" class="mr-1.5 h-3.5 w-3.5 animate-spin" />
+          <Square v-else class="mr-1.5 h-3.5 w-3.5 fill-current" />
+          {{ t("sqlFile.cancel") }}
+        </Button>
+        <Button v-else-if="progress?.status === 'done'" @click="open = false">
+          <Check class="mr-1.5 h-3.5 w-3.5" />
+          {{ t("common.done") }}
+        </Button>
+      </DialogFooter>
+    </DialogScrollContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/kv/KvKeyBrowser.vue b/apps/desktop/src/components/kv/KvKeyBrowser.vue
new file mode 100644
index 0000000..cbef150
--- /dev/null
+++ b/apps/desktop/src/components/kv/KvKeyBrowser.vue
@@ -0,0 +1,767 @@
+<script setup lang="ts">
+import { computed, onMounted, reactive, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { ChevronDown, ChevronRight, FolderClosed, FolderOpen, KeyRound, Loader2, Plus, RefreshCw, Search, Trash2 } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Badge } from "@/components/ui/badge";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Label } from "@/components/ui/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import CustomContextMenu, { type ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
+import type { KvCreateMode, KvGetResponse, KvKeySummary, KvListPrefixOptions, KvPutOptions, KvPutResponse, KvValue } from "@/lib/backend/api";
+import { buildKvKeyTree, flattenVisibleKvKeyTree, preserveKvExpandedGroupIds, type KvKeyTreeNode } from "@/lib/kv/kvKeyTree";
+import { refreshedKvSelectionKey } from "@/lib/kv/kvRefreshSelection";
+import { formatZooKeeperMetadataRows, formatZooKeeperSummaryBadges, prettyPrintJsonText } from "@/lib/kv/kvValueDisplay";
+import {
+  createLazyKvKeyTreeState,
+  createZooKeeperChildPathDraft,
+  flattenLazyKvKeyTree,
+  lazyExpandedKeyFromId,
+  normalizeZooKeeperPath,
+  parentZooKeeperPath,
+  replaceLazyKvChildren,
+  replaceLazyKvFocusedRoot,
+  resetLazyKvKeyTree,
+  type LazyKvKeyTreeNode,
+  type LazyKvKeyTreeRow,
+} from "@/lib/zookeeper/zookeeperLazyKeyTree";
+import { useToast } from "@/composables/useToast";
+
+interface KvKeyBrowserLabels {
+  prefixPlaceholder: string;
+  newKey: string;
+  loadingKeys: string;
+  empty: string;
+  loadMore: string;
+  selectKey: string;
+  loadingValue: string;
+  notFound: string;
+  edit: string;
+  editKey: string;
+  delete: string;
+  deleteTitle: string;
+  keyPlaceholder: string;
+  keyRequired: string;
+  rootReadonly?: string;
+  saved: string;
+  deleted: string;
+  base64Readonly: string;
+  createMode?: string;
+  add?: string;
+  value?: string;
+  metadata?: string;
+  prettyJson?: string;
+  invalidJson?: string;
+  summaryRevision?: string;
+  summaryVersion?: string;
+  summaryLease?: string;
+  summarySize?: string;
+}
+
+interface KvCreateModeOption {
+  value: KvCreateMode;
+  label: string;
+}
+
+interface KvKeyBrowserApi {
+  listPrefix: (connectionId: string, prefix: string, limit: number, continuation?: string | null, options?: KvListPrefixOptions | null) => Promise<{ keys: KvKeySummary[]; continuation?: string | null }>;
+  get: (connectionId: string, key: string) => Promise<KvGetResponse>;
+  put: (connectionId: string, key: string, value: KvValue, options?: KvPutOptions | null) => Promise<KvPutResponse>;
+  deleteKey: (connectionId: string, key: string) => Promise<{ deleted: number }>;
+}
+
+type BrowserTreeNode = KvKeyTreeNode | LazyKvKeyTreeNode;
+type BrowserTreeRow = { type: "node"; node: BrowserTreeNode; depth: number } | LazyKvKeyTreeRow;
+
+const props = withDefaults(
+  defineProps<{
+    connectionId: string;
+    labels: KvKeyBrowserLabels;
+    api: KvKeyBrowserApi;
+    supportsCreateModes?: boolean;
+    createModeOptions?: KvCreateModeOption[];
+    enableNodeActions?: boolean;
+    metadataStyle?: "default" | "zookeeper";
+    lazyHierarchy?: boolean;
+  }>(),
+  {
+    supportsCreateModes: false,
+    createModeOptions: () => [],
+    enableNodeActions: false,
+    metadataStyle: "default",
+    lazyHierarchy: false,
+  },
+);
+
+const { t } = useI18n();
+const { toast } = useToast();
+const connectionStore = useConnectionStore();
+const searchInputRef = ref<HTMLInputElement>();
+const prefix = ref("");
+const keys = ref<KvKeySummary[]>([]);
+const continuation = ref<string | null>(null);
+const loading = ref(false);
+const loadingMore = ref(false);
+const expandedGroupIds = ref<Set<string>>(new Set());
+const selectedKey = ref<string | null>(null);
+const selectedValue = ref<KvGetResponse | null>(null);
+const detailLoading = ref(false);
+const detailError = ref("");
+const showEditDialog = ref(false);
+const isCreating = ref(false);
+const editKey = ref("");
+const editValue = ref("");
+const editError = ref("");
+const saving = ref(false);
+const showDeleteConfirm = ref(false);
+const deleting = ref(false);
+const selectedCreateMode = ref<KvCreateMode>("persistent");
+const selectedPrettyValue = ref<string | null>(null);
+const lazyTreeState = reactive(createLazyKvKeyTreeState());
+const pageSize = 200;
+type LoadKeysOptions = {
+  preserveSelection?: boolean;
+};
+
+const tree = computed(() => buildKvKeyTree(keys.value));
+const visibleRows = computed<BrowserTreeRow[]>(() => {
+  if (props.lazyHierarchy) return flattenLazyKvKeyTree(lazyTreeState, expandedGroupIds.value);
+  return flattenVisibleKvKeyTree(tree.value, expandedGroupIds.value).map((row) => ({ type: "node", node: row.node, depth: row.depth }));
+});
+const selectedMetadata = computed(() => selectedValue.value?.metadata ?? (props.lazyHierarchy && selectedKey.value ? lazyTreeState.nodeByKey.get(selectedKey.value) : keys.value.find((key) => key.key === selectedKey.value)));
+const selectedTextValue = computed(() => {
+  const value = selectedValue.value?.value;
+  if (!value) return "";
+  return value.encoding === "utf8" ? value.data : value.data;
+});
+const displayedSelectedTextValue = computed(() => selectedPrettyValue.value ?? selectedTextValue.value);
+const selectedValueIsBase64 = computed(() => selectedValue.value?.value?.encoding === "base64");
+const showCreateModeSelect = computed(() => props.supportsCreateModes && isCreating.value && props.createModeOptions.length > 0);
+const zookeeperSummaryBadges = computed(() =>
+  formatZooKeeperSummaryBadges(selectedMetadata.value, {
+    revision: props.labels.summaryRevision,
+    version: props.labels.summaryVersion,
+    lease: props.labels.summaryLease,
+    size: props.labels.summarySize,
+  }),
+);
+const zookeeperMetadataRows = computed(() => formatZooKeeperMetadataRows(selectedMetadata.value));
+const selectedValueCanPrettyJson = computed(() => selectedValue.value?.value?.encoding === "utf8" && prettyPrintJsonText(selectedTextValue.value).ok);
+const editValueCanPrettyJson = computed(() => prettyPrintJsonText(editValue.value).ok);
+
+function preserveExpandedGroups(expandAll = false) {
+  expandedGroupIds.value = preserveKvExpandedGroupIds(tree.value, expandedGroupIds.value, expandAll);
+}
+
+async function loadKeys(reset = true, options: LoadKeysOptions = {}) {
+  if (props.lazyHierarchy) {
+    await loadLazyRoot(reset, options);
+    return;
+  }
+
+  const keyToRestore = options.preserveSelection ? selectedKey.value : null;
+  if (reset) {
+    loading.value = true;
+    continuation.value = null;
+    keys.value = [];
+    if (!options.preserveSelection) {
+      selectedKey.value = null;
+      selectedValue.value = null;
+    }
+  } else {
+    loadingMore.value = true;
+  }
+  try {
+    const result = await props.api.listPrefix(props.connectionId, prefix.value.trim(), pageSize, reset ? null : continuation.value);
+    const existing = new Set(keys.value.map((key) => key.key));
+    const merged = reset ? result.keys : [...keys.value, ...result.keys.filter((key) => !existing.has(key.key))];
+    keys.value = merged;
+    continuation.value = result.continuation || null;
+    preserveExpandedGroups(!!prefix.value.trim());
+    if (reset && options.preserveSelection) {
+      const restoredKey = refreshedKvSelectionKey(keyToRestore, merged);
+      if (restoredKey) {
+        await loadSelectedKey(restoredKey);
+      } else {
+        selectedKey.value = null;
+        selectedValue.value = null;
+      }
+    }
+  } finally {
+    loading.value = false;
+    loadingMore.value = false;
+  }
+}
+
+async function loadLazyRoot(reset = true, options: LoadKeysOptions = {}) {
+  const keyToRestore = options.preserveSelection ? selectedKey.value : null;
+  if (!reset) {
+    await loadMoreLazyChildren(null);
+    return;
+  }
+
+  const previousExpanded = new Set(expandedGroupIds.value);
+  loading.value = true;
+  loadingMore.value = false;
+  if (!options.preserveSelection) {
+    selectedKey.value = null;
+    selectedValue.value = null;
+  }
+
+  try {
+    const rootPath = normalizeZooKeeperPath(prefix.value);
+    resetLazyKvKeyTree(lazyTreeState, rootPath);
+    const result = await props.api.listPrefix(props.connectionId, rootPath, pageSize, null, { recursive: false });
+    if (rootPath === "/") {
+      replaceLazyKvChildren(lazyTreeState, null, result.keys, result.continuation);
+    } else {
+      const rootSummary = await loadLazyRootSummary(rootPath, result.keys, result.continuation);
+      if (rootSummary) {
+        replaceLazyKvFocusedRoot(lazyTreeState, rootSummary, result.keys, result.continuation);
+      } else {
+        replaceLazyKvChildren(lazyTreeState, null, result.keys, result.continuation);
+      }
+    }
+
+    if (options.preserveSelection) {
+      await restoreLazyExpandedBranches(previousExpanded);
+      expandFocusedRoot(rootPath);
+      if (keyToRestore && lazyTreeState.nodeByKey.has(keyToRestore)) {
+        await loadSelectedKey(keyToRestore);
+      } else {
+        selectedKey.value = null;
+        selectedValue.value = null;
+      }
+    } else {
+      expandedGroupIds.value = focusedRootExpansion(rootPath);
+    }
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function loadLazyRootSummary(rootPath: string, children: KvKeySummary[], continuation?: string | null): Promise<KvKeySummary | null> {
+  try {
+    const rootValue = await props.api.get(props.connectionId, rootPath);
+    if (rootValue.found) return { key: rootValue.key || rootPath, ...rootValue.metadata };
+    if (children.length === 0 && !continuation) return null;
+  } catch {
+    if (children.length === 0 && !continuation) return null;
+  }
+  return { key: rootPath, numChildren: children.length + (continuation ? 1 : 0) };
+}
+
+function focusedRootExpansion(rootPath: string): Set<string> {
+  const normalized = normalizeZooKeeperPath(rootPath);
+  if (normalized === "/") return new Set();
+  return new Set(
+    focusedPathKeys(normalized)
+      .filter((key) => lazyTreeState.nodeByKey.has(key))
+      .map((key) => `lazy:${key}`),
+  );
+}
+
+function expandFocusedRoot(rootPath: string) {
+  expandedGroupIds.value = new Set([...expandedGroupIds.value, ...focusedRootExpansion(rootPath)]);
+}
+
+function focusedPathKeys(rootPath: string): string[] {
+  const segments = normalizeZooKeeperPath(rootPath).split("/").filter(Boolean);
+  return segments.map((_, index) => `/${segments.slice(0, index + 1).join("/")}`);
+}
+
+async function restoreLazyExpandedBranches(previousExpanded: ReadonlySet<string>) {
+  const restored = new Set<string>();
+  const keysToExpand = [...previousExpanded]
+    .map((id) => lazyExpandedKeyFromId(id))
+    .filter((key): key is string => !!key)
+    .sort((a, b) => a.split("/").length - b.split("/").length);
+
+  for (const key of keysToExpand) {
+    const node = lazyTreeState.nodeByKey.get(key);
+    if (!node?.hasChildren) continue;
+    restored.add(node.id);
+    await loadLazyChildren(key, true);
+  }
+
+  expandedGroupIds.value = restored;
+}
+
+async function loadLazyChildren(parentKey: string, reset = true) {
+  const node = lazyTreeState.nodeByKey.get(parentKey);
+  if (!node || node.loading) return;
+  node.loading = true;
+  try {
+    const continuationToUse = reset ? null : node.continuation;
+    const result = await props.api.listPrefix(props.connectionId, parentKey, pageSize, continuationToUse, { recursive: false });
+    replaceLazyKvChildren(lazyTreeState, parentKey, result.keys, result.continuation, { append: !reset });
+  } finally {
+    const latest = lazyTreeState.nodeByKey.get(parentKey);
+    if (latest) latest.loading = false;
+  }
+}
+
+async function loadMoreLazyChildren(parentKey: string | null) {
+  if (parentKey) {
+    await loadLazyChildren(parentKey, false);
+    return;
+  }
+
+  if (loadingMore.value || !lazyTreeState.rootContinuation) return;
+  loadingMore.value = true;
+  try {
+    const result = await props.api.listPrefix(props.connectionId, lazyTreeState.rootPath, pageSize, lazyTreeState.rootContinuation, { recursive: false });
+    replaceLazyKvChildren(lazyTreeState, null, result.keys, result.continuation, { append: true });
+  } finally {
+    loadingMore.value = false;
+  }
+}
+
+async function refreshLazyParent(parentPath: string) {
+  const normalizedParent = normalizeZooKeeperPath(parentPath);
+  if (normalizedParent === lazyTreeState.rootPath) {
+    if (lazyTreeState.rootPath === "/") {
+      const result = await props.api.listPrefix(props.connectionId, lazyTreeState.rootPath, pageSize, null, { recursive: false });
+      replaceLazyKvChildren(lazyTreeState, null, result.keys, result.continuation);
+    } else {
+      await loadLazyChildren(lazyTreeState.rootPath, true);
+      expandFocusedRoot(lazyTreeState.rootPath);
+    }
+    return;
+  }
+
+  if (lazyTreeState.nodeByKey.has(normalizedParent)) {
+    await loadLazyChildren(normalizedParent, true);
+  } else {
+    await loadLazyRoot(true, { preserveSelection: true });
+  }
+}
+
+async function loadSelectedKey(key: string) {
+  selectedKey.value = key;
+  selectedPrettyValue.value = null;
+  detailLoading.value = true;
+  detailError.value = "";
+  try {
+    selectedValue.value = await props.api.get(props.connectionId, key);
+  } catch (error) {
+    detailError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    detailLoading.value = false;
+  }
+}
+
+async function toggleGroup(node: BrowserTreeNode) {
+  if (!nodeIsExpandable(node)) return;
+  const next = new Set(expandedGroupIds.value);
+  if (next.has(node.id)) {
+    next.delete(node.id);
+  } else {
+    next.add(node.id);
+    if (node.kind === "lazy" && node.hasChildren && !node.loaded) {
+      void loadLazyChildren(node.key, true);
+    }
+  }
+  expandedGroupIds.value = next;
+}
+
+function nodePath(node: BrowserTreeNode): string {
+  if (node.kind === "lazy") return node.key;
+  if (node.kind === "leaf") return node.key;
+  return `/${node.pathSegments.join("/")}`;
+}
+
+function onRowClick(node: BrowserTreeNode) {
+  if (nodeIsExpandable(node)) {
+    void toggleGroup(node);
+    if (props.enableNodeActions) void loadSelectedKey(nodePath(node));
+  } else {
+    void loadSelectedKey(nodePath(node));
+  }
+}
+
+function onRowDoubleClick(node: BrowserTreeNode) {
+  if (!nodeIsExpandable(node)) {
+    void loadSelectedKey(nodePath(node)).then(() => openEditDialog());
+  }
+}
+
+function createKeyPrefix(parentPath?: string): string {
+  if (props.lazyHierarchy) return createZooKeeperChildPathDraft(parentPath ?? prefix.value);
+  const path = parentPath ?? prefix.value.trim();
+  if (!path) return "";
+  if (path === "/") return "/";
+  return path.endsWith("/") ? path : `${path}/`;
+}
+
+function openCreateDialog(parentPath?: string) {
+  isCreating.value = true;
+  editKey.value = createKeyPrefix(parentPath);
+  editValue.value = "";
+  editError.value = "";
+  selectedCreateMode.value = props.createModeOptions[0]?.value || "persistent";
+  showEditDialog.value = true;
+}
+
+function openEditDialog() {
+  if (!selectedKey.value) return;
+  isCreating.value = false;
+  editKey.value = selectedKey.value;
+  editValue.value = selectedTextValue.value;
+  editError.value = selectedValueIsBase64.value ? props.labels.base64Readonly : "";
+  showEditDialog.value = true;
+}
+
+function putOptions(): KvPutOptions | undefined {
+  if (!props.supportsCreateModes) return undefined;
+  if (isCreating.value) {
+    return { writeMode: "create", createMode: selectedCreateMode.value };
+  }
+  return { writeMode: "update" };
+}
+
+async function saveKey() {
+  const rawKey = editKey.value.trim();
+  if (!rawKey) {
+    editError.value = props.labels.keyRequired;
+    return;
+  }
+  if (props.lazyHierarchy && normalizeZooKeeperPath(rawKey) === "/") {
+    editError.value = props.labels.rootReadonly || props.labels.keyRequired;
+    return;
+  }
+  const key = props.lazyHierarchy ? normalizeZooKeeperPath(rawKey) : rawKey;
+  saving.value = true;
+  editError.value = "";
+  try {
+    const value: KvValue = { encoding: "utf8", data: editValue.value };
+    const response = await props.api.put(props.connectionId, key, value, putOptions());
+    const keyToSelect = response.createdKey || response.key || key;
+    showEditDialog.value = false;
+    if (props.lazyHierarchy) {
+      await refreshLazyParent(parentZooKeeperPath(keyToSelect));
+    } else {
+      await loadKeys(true);
+    }
+    await loadSelectedKey(keyToSelect);
+    toast(props.labels.saved, 2500);
+  } catch (error) {
+    editError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    saving.value = false;
+  }
+}
+
+async function deleteSelectedKey() {
+  if (!selectedKey.value) return;
+  const parentPath = parentZooKeeperPath(selectedKey.value);
+  deleting.value = true;
+  try {
+    await props.api.deleteKey(props.connectionId, selectedKey.value);
+    showDeleteConfirm.value = false;
+    selectedKey.value = null;
+    selectedValue.value = null;
+    if (props.lazyHierarchy) {
+      await refreshLazyParent(parentPath);
+    } else {
+      await loadKeys(true);
+    }
+    toast(props.labels.deleted, 2500);
+  } finally {
+    deleting.value = false;
+  }
+}
+
+function selectNodeForAction(node: BrowserTreeNode) {
+  const key = nodePath(node);
+  if (selectedKey.value !== key) void loadSelectedKey(key);
+  else selectedKey.value = key;
+}
+
+function openDeleteForNode(node: BrowserTreeNode) {
+  selectNodeForAction(node);
+  showDeleteConfirm.value = true;
+}
+
+function nodeContextMenuItems(node: BrowserTreeNode): ContextMenuItem[] {
+  if (!props.enableNodeActions) return [];
+  return [
+    {
+      label: props.labels.add || props.labels.newKey,
+      icon: Plus,
+      action: () => openCreateDialog(nodePath(node)),
+    },
+    {
+      label: props.labels.delete,
+      icon: Trash2,
+      variant: "destructive",
+      action: () => openDeleteForNode(node),
+    },
+  ];
+}
+
+function onRowContextMenu(event: MouseEvent, node: BrowserTreeNode, openContextMenu: (event: MouseEvent) => void) {
+  if (!props.enableNodeActions) return;
+  selectNodeForAction(node);
+  openContextMenu(event);
+}
+
+function rowIsSelected(node: BrowserTreeNode): boolean {
+  return nodePath(node) === selectedKey.value;
+}
+
+function nodeIsExpandable(node: BrowserTreeNode): boolean {
+  return node.kind === "group" || (node.kind === "lazy" && node.hasChildren);
+}
+
+function nodeIsExpanded(node: BrowserTreeNode): boolean {
+  return expandedGroupIds.value.has(node.id);
+}
+
+function nodeIsLoading(node: BrowserTreeNode): boolean {
+  return node.kind === "lazy" && node.loading;
+}
+
+function prettifySelectedJson() {
+  const result = prettyPrintJsonText(selectedTextValue.value);
+  if (result.ok && result.value != null) {
+    selectedPrettyValue.value = result.value;
+  } else {
+    toast(props.labels.invalidJson || "Invalid JSON", 2500);
+  }
+}
+
+function prettifyEditJson() {
+  const result = prettyPrintJsonText(editValue.value);
+  if (result.ok && result.value != null) {
+    editValue.value = result.value;
+    editError.value = "";
+  } else {
+    editError.value = props.labels.invalidJson || "Invalid JSON";
+  }
+}
+
+function metadataLabel(value: number | null | undefined): string {
+  return value == null ? "-" : String(value);
+}
+
+function focusSearch(): boolean {
+  searchInputRef.value?.focus();
+  return true;
+}
+
+function refresh(): boolean {
+  void loadKeys(true, { preserveSelection: true });
+  return true;
+}
+
+watch(
+  () => props.connectionId,
+  async () => {
+    try {
+      await connectionStore.ensureConnected(props.connectionId);
+    } catch {
+      // Connection failed — loadKeys will show the error state
+    }
+    void loadKeys(true);
+  },
+);
+
+watch(
+  () => props.createModeOptions,
+  (options) => {
+    if (!options.some((option) => option.value === selectedCreateMode.value)) {
+      selectedCreateMode.value = options[0]?.value || "persistent";
+    }
+  },
+  { immediate: true },
+);
+
+onMounted(async () => {
+  try {
+    await connectionStore.ensureConnected(props.connectionId);
+  } catch (e) {
+    console.warn("[DBX] ensureConnected failed for", props.connectionId, e);
+  }
+  void loadKeys(true);
+});
+defineExpose({ focusSearch, refresh });
+</script>
+
+<template>
+  <div class="flex h-full min-h-0 flex-col bg-background">
+    <div class="flex shrink-0 items-center gap-2 border-b px-3 py-2">
+      <div class="relative min-w-0 flex-1">
+        <Search class="pointer-events-none absolute left-2.5 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
+        <Input ref="searchInputRef" v-model="prefix" class="h-8 pl-8" :placeholder="labels.prefixPlaceholder" @keyup.enter="loadKeys(true)" />
+      </div>
+      <Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="loading" @click="loadKeys(true, { preserveSelection: true })">
+        <Loader2 v-if="loading" class="h-3.5 w-3.5 animate-spin" />
+        <RefreshCw v-else class="h-3.5 w-3.5" />
+        {{ t("grid.refresh") }}
+      </Button>
+      <Button size="sm" class="h-8 gap-1.5" @click="openCreateDialog()">
+        <Plus class="h-3.5 w-3.5" />
+        {{ labels.newKey }}
+      </Button>
+    </div>
+
+    <div class="grid min-h-0 flex-1 grid-cols-[minmax(260px,38%)_1fr]">
+      <div class="min-h-0 border-r">
+        <div v-if="loading" class="flex h-full items-center justify-center text-sm text-muted-foreground">
+          <Loader2 class="mr-2 h-4 w-4 animate-spin" />
+          {{ labels.loadingKeys }}
+        </div>
+        <div v-else-if="visibleRows.length === 0" class="flex h-full items-center justify-center text-sm text-muted-foreground">
+          {{ labels.empty }}
+        </div>
+        <div v-else class="h-full overflow-auto py-1 text-sm">
+          <template v-for="row in visibleRows" :key="row.type === 'node' ? row.node.id : row.id">
+            <CustomContextMenu v-if="row.type === 'node'" :items="nodeContextMenuItems(row.node)" v-slot="{ onContextMenu }">
+              <button
+                type="button"
+                class="flex h-8 w-full items-center gap-1.5 px-2 text-left hover:bg-accent"
+                :class="{ 'bg-accent/70': rowIsSelected(row.node) }"
+                :style="{ paddingLeft: `${8 + row.depth * 18}px` }"
+                @click="onRowClick(row.node)"
+                @dblclick.stop.prevent="onRowDoubleClick(row.node)"
+                @contextmenu="(event) => onRowContextMenu(event, row.node, onContextMenu)"
+              >
+                <template v-if="nodeIsExpandable(row.node)">
+                  <Loader2 v-if="nodeIsLoading(row.node)" class="h-3.5 w-3.5 shrink-0 animate-spin" />
+                  <ChevronDown v-else-if="nodeIsExpanded(row.node)" class="h-3.5 w-3.5 shrink-0" />
+                  <ChevronRight v-else class="h-3.5 w-3.5 shrink-0" />
+                  <FolderOpen v-if="nodeIsExpanded(row.node)" class="h-4 w-4 shrink-0 text-sky-500" />
+                  <FolderClosed v-else class="h-4 w-4 shrink-0 text-sky-500" />
+                </template>
+                <template v-else>
+                  <span class="w-3.5 shrink-0" />
+                  <KeyRound class="h-4 w-4 shrink-0 text-sky-500" />
+                </template>
+                <span class="truncate">{{ row.node.label }}</span>
+              </button>
+            </CustomContextMenu>
+            <div v-else class="px-2 py-1" :style="{ paddingLeft: `${8 + row.depth * 18}px` }">
+              <Button size="sm" variant="outline" class="h-7 w-full gap-1.5" :disabled="row.loading || loadingMore" @click="loadMoreLazyChildren(row.parentKey)">
+                <Loader2 v-if="row.loading || (row.parentKey === null && loadingMore)" class="h-3.5 w-3.5 animate-spin" />
+                {{ labels.loadMore }}
+              </Button>
+            </div>
+          </template>
+          <div v-if="!lazyHierarchy && continuation" class="border-t p-2">
+            <Button size="sm" variant="outline" class="h-8 w-full gap-1.5" :disabled="loadingMore" @click="loadKeys(false)">
+              <Loader2 v-if="loadingMore" class="h-3.5 w-3.5 animate-spin" />
+              {{ labels.loadMore }}
+            </Button>
+          </div>
+        </div>
+      </div>
+
+      <div class="min-h-0 overflow-auto">
+        <div v-if="!selectedKey" class="flex h-full items-center justify-center text-sm text-muted-foreground">
+          {{ labels.selectKey }}
+        </div>
+        <div v-else class="flex min-h-full flex-col">
+          <div class="flex shrink-0 items-start justify-between gap-3 border-b px-4 py-3">
+            <div class="min-w-0">
+              <div class="truncate font-medium" :class="{ 'text-blue-600 dark:text-blue-400': metadataStyle === 'zookeeper' }">{{ selectedKey }}</div>
+              <div class="mt-1 flex flex-wrap gap-1.5 text-xs text-muted-foreground">
+                <template v-if="metadataStyle === 'zookeeper'">
+                  <Badge v-for="badge in zookeeperSummaryBadges" :key="badge.label" variant="outline" class="rounded-full">
+                    {{ `${badge.label} ${badge.value}` }}
+                  </Badge>
+                </template>
+                <template v-else>
+                  <Badge variant="secondary">rev {{ metadataLabel(selectedMetadata?.modRevision) }}</Badge>
+                  <Badge variant="outline">ver {{ metadataLabel(selectedMetadata?.version) }}</Badge>
+                  <Badge variant="outline">lease {{ metadataLabel(selectedMetadata?.lease) }}</Badge>
+                  <Badge variant="outline">{{ metadataLabel(selectedMetadata?.valueSize) }} B</Badge>
+                </template>
+              </div>
+            </div>
+            <div class="flex shrink-0 gap-2">
+              <Button size="sm" variant="outline" class="h-8" :disabled="selectedValueIsBase64" @click="openEditDialog">
+                {{ labels.edit }}
+              </Button>
+              <Button size="sm" variant="destructive" class="h-8 gap-1.5" @click="showDeleteConfirm = true">
+                <Trash2 class="h-3.5 w-3.5" />
+                {{ labels.delete }}
+              </Button>
+            </div>
+          </div>
+          <div v-if="detailLoading" class="flex flex-1 items-center justify-center text-sm text-muted-foreground">
+            <Loader2 class="mr-2 h-4 w-4 animate-spin" />
+            {{ labels.loadingValue }}
+          </div>
+          <div v-else-if="detailError" class="p-4 text-sm text-destructive">{{ detailError }}</div>
+          <div v-else-if="selectedValue && !selectedValue.found" class="p-4 text-sm text-muted-foreground">
+            {{ labels.notFound }}
+          </div>
+          <div v-else class="flex min-h-0 flex-1 flex-col gap-4 p-4">
+            <div class="min-h-0">
+              <div v-if="metadataStyle === 'zookeeper'" class="mb-2 text-xs font-medium text-muted-foreground">{{ labels.value || "Value" }}</div>
+              <pre class="dbx-editor-font-family m-0 max-h-[40vh] min-h-32 overflow-auto rounded-md border bg-muted/20 whitespace-pre-wrap break-words p-3 text-sm">{{ displayedSelectedTextValue }}</pre>
+              <div v-if="selectedValueCanPrettyJson" class="mt-2 flex justify-end">
+                <Button size="sm" variant="outline" class="h-8" @click="prettifySelectedJson">
+                  {{ labels.prettyJson || "Pretty" }}
+                </Button>
+              </div>
+            </div>
+            <div v-if="metadataStyle === 'zookeeper'" class="grid gap-3 border-t pt-4">
+              <div class="text-xs font-medium text-muted-foreground">{{ labels.metadata || "Metadata" }}</div>
+              <div class="grid gap-x-10 gap-y-4 sm:grid-cols-2">
+                <div v-for="row in zookeeperMetadataRows" :key="row.label" class="grid grid-cols-[minmax(96px,auto)_1fr] items-baseline gap-5 text-sm">
+                  <div class="text-foreground">{{ row.label }}</div>
+                  <div class="dbx-editor-font-family min-w-0 break-all text-blue-600 dark:text-blue-400">{{ row.value }}</div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <Dialog v-model:open="showEditDialog">
+      <DialogContent class="sm:max-w-2xl">
+        <DialogHeader>
+          <DialogTitle>{{ isCreating ? labels.newKey : labels.editKey }}</DialogTitle>
+        </DialogHeader>
+        <div class="grid gap-3 py-2">
+          <Input v-model="editKey" :placeholder="labels.keyPlaceholder" />
+          <div v-if="showCreateModeSelect" class="grid grid-cols-4 items-center gap-3">
+            <Label class="text-right text-xs">{{ labels.createMode || "Create Mode" }}</Label>
+            <Select v-model="selectedCreateMode">
+              <SelectTrigger class="col-span-3 h-9">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem v-for="option in createModeOptions" :key="option.value" :value="option.value">
+                  {{ option.label }}
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+          <textarea v-model="editValue" class="min-h-52 rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring" spellcheck="false" />
+          <div v-if="editValueCanPrettyJson" class="flex justify-end">
+            <Button size="sm" variant="outline" class="h-8" @click="prettifyEditJson">
+              {{ labels.prettyJson || "Pretty" }}
+            </Button>
+          </div>
+          <div v-if="editError" class="text-sm text-destructive">{{ editError }}</div>
+        </div>
+        <DialogFooter>
+          <Button variant="outline" @click="showEditDialog = false">{{ t("common.cancel") }}</Button>
+          <Button :disabled="saving || (!!editError && selectedValueIsBase64)" @click="saveKey">
+            <Loader2 v-if="saving" class="mr-2 h-4 w-4 animate-spin" />
+            {{ t("common.save") }}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <DangerConfirmDialog v-model:open="showDeleteConfirm" :title="labels.deleteTitle" :details="selectedKey || ''" :confirm-label="labels.delete" @confirm="deleteSelectedKey" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/layout/AppDialogs.vue b/apps/desktop/src/components/layout/AppDialogs.vue
new file mode 100644
index 0000000..fa6d9d4
--- /dev/null
+++ b/apps/desktop/src/components/layout/AppDialogs.vue
@@ -0,0 +1,263 @@
+<script setup lang="ts">
+import { computed, watch, defineAsyncComponent } from "vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+const ConnectionDialog = defineAsyncComponent(() => import("@/components/connection/ConnectionDialog.vue"));
+const DangerConfirmDialog = defineAsyncComponent(() => import("@/components/editor/DangerConfirmDialog.vue"));
+const SqlParameterDialog = defineAsyncComponent(() => import("@/components/editor/SqlParameterDialog.vue"));
+const DataTransferDialog = defineAsyncComponent(() => import("@/components/transfer/DataTransferDialog.vue"));
+const SchemaDiffDialog = defineAsyncComponent(() => import("@/components/diff/SchemaDiffDialog.vue"));
+const DataCompareDialog = defineAsyncComponent(() => import("@/components/diff/DataCompareDialog.vue"));
+const SqlFileExecutionDialog = defineAsyncComponent(() => import("@/components/sql-file/SqlFileExecutionDialog.vue"));
+const SchemaDiagramDialog = defineAsyncComponent(() => import("@/components/diagram/SchemaDiagramDialog.vue"));
+const TableImportDialog = defineAsyncComponent(() => import("@/components/import/TableImportDialog.vue"));
+const FieldLineageDialog = defineAsyncComponent(() => import("@/components/lineage/FieldLineageDialog.vue"));
+const ConfigPassphraseDialog = defineAsyncComponent(() => import("@/components/config/ConfigPassphraseDialog.vue"));
+const DatabaseSearchDialog = defineAsyncComponent(() => import("@/components/search/DatabaseSearchDialog.vue"));
+const DatabaseExportDialog = defineAsyncComponent(() => import("@/components/export/DatabaseExportDialog.vue"));
+const DataGenerateDialog = defineAsyncComponent(() => import("@/components/generate/DataGenerateDialog.vue"));
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
+import { useDialogSources } from "@/composables/useDialogSources";
+import type { ConnectionDeepLinkDraft } from "@/lib/connection/connectionDeepLink";
+import type { SqlParameterDescriptor, SqlParameterSyntax } from "@/lib/sql/sqlParameters";
+import type { ConfigTab } from "@/components/connection/ConnectionDialog.vue";
+import type { DatabaseType } from "@/types/database";
+
+const props = defineProps<{
+  showConnectionDialog: boolean;
+  connectionPrefill?: ConnectionDeepLinkDraft | null;
+  connectionInitialTab?: ConfigTab;
+  showDangerDialog: boolean;
+  dangerSql: string;
+  suppressDangerConfirm: boolean;
+  showSqlParameterDialog: boolean;
+  sqlParameterSourceSql: string;
+  sqlParameterNames: SqlParameterDescriptor[];
+  sqlParameterDatabaseType?: DatabaseType;
+  sqlParameterEnabledSyntaxes?: SqlParameterSyntax[];
+}>();
+
+const emit = defineEmits<{
+  "update:showConnectionDialog": [value: boolean];
+  "update:showDangerDialog": [value: boolean];
+  "update:suppressDangerConfirm": [value: boolean];
+  "update:showSqlParameterDialog": [value: boolean];
+  dangerConfirm: [];
+  sqlParametersConfirm: [sql: string];
+  connectStarted: [name: string];
+  connectSucceeded: [name: string];
+  connectFailed: [message: string];
+  openDriverStore: [];
+  openTunnelProfileSettings: [];
+  openLineageTarget: [
+    target: {
+      connectionId: string;
+      database: string;
+      schema?: string;
+      tableName: string;
+      tableType?: string;
+      columnName?: string;
+    },
+  ];
+  openDatabaseSearchTarget: [
+    target: {
+      connectionId: string;
+      database: string;
+      schema?: string;
+      tableName: string;
+      tableType?: string;
+      whereInput?: string;
+    },
+  ];
+  openDiagramTarget: [
+    target: {
+      connectionId: string;
+      database: string;
+      schema?: string;
+      tableName: string;
+      tableType?: string;
+    },
+  ];
+}>();
+
+const { t } = useI18n();
+const connectionStore = useConnectionStore();
+const productionSafetyStore = useProductionSafetyStore();
+const dialogs = useDialogSources();
+const productionConfirmationDetails = computed(() => {
+  const request = productionSafetyStore.pending;
+  if (!request) return "";
+  return t("production.confirmDetails", {
+    connection: request.connectionName || "-",
+    database: request.productionDatabases?.join(", ") || request.database || "-",
+    source: request.source || "-",
+  });
+});
+
+const editConfig = computed(() => {
+  const id = connectionStore.editingConnectionId;
+  if (!id) return undefined;
+  return connectionStore.getConfig(id);
+});
+const shouldShowConnectionDialog = computed(() => props.showConnectionDialog || !!editConfig.value);
+
+watch(editConfig, (v) => {
+  if (v) emit("update:showConnectionDialog", true);
+});
+
+watch(
+  () => connectionStore.newConnectionGroupId,
+  (v) => {
+    if (v) emit("update:showConnectionDialog", true);
+  },
+);
+
+watch(
+  () => props.showConnectionDialog,
+  (v) => {
+    if (!v) {
+      connectionStore.stopEditing();
+      connectionStore.stopCreatingConnectionInGroup();
+    }
+  },
+);
+</script>
+
+<template>
+  <ConnectionDialog
+    v-if="shouldShowConnectionDialog"
+    :open="shouldShowConnectionDialog"
+    :edit-config="editConfig"
+    :prefill-config="connectionPrefill"
+    :initial-tab="connectionInitialTab"
+    @update:open="emit('update:showConnectionDialog', $event)"
+    @connect-started="emit('connectStarted', $event)"
+    @connect-succeeded="emit('connectSucceeded', $event)"
+    @connect-failed="emit('connectFailed', $event)"
+    @open-driver-store="emit('openDriverStore')"
+    @open-tunnel-profile-settings="emit('openTunnelProfileSettings')"
+  />
+  <DangerConfirmDialog
+    v-if="showDangerDialog"
+    :open="showDangerDialog"
+    :sql="dangerSql"
+    :show-suppress-toggle="true"
+    :suppress-future-prompts="suppressDangerConfirm"
+    @update:open="emit('update:showDangerDialog', $event)"
+    @update:suppress-future-prompts="emit('update:suppressDangerConfirm', $event)"
+    @confirm="emit('dangerConfirm')"
+  />
+  <DangerConfirmDialog
+    v-if="productionSafetyStore.pending"
+    :open="true"
+    :title="t('production.confirmTitle')"
+    :message="t('production.confirmMessage')"
+    :details-text="productionConfirmationDetails"
+    :sql="productionSafetyStore.pending.sql"
+    :confirm-label="t('production.confirmAction')"
+    :close-on-confirm="false"
+    @update:open="(open) => !open && productionSafetyStore.cancel()"
+    @confirm="productionSafetyStore.confirm()"
+  />
+  <SqlParameterDialog
+    v-if="showSqlParameterDialog"
+    :open="showSqlParameterDialog"
+    :sql="sqlParameterSourceSql"
+    :parameters="sqlParameterNames"
+    :database-type="sqlParameterDatabaseType"
+    :enabled-syntaxes="sqlParameterEnabledSyntaxes"
+    @update:open="emit('update:showSqlParameterDialog', $event)"
+    @execute="emit('sqlParametersConfirm', $event)"
+  />
+  <DataTransferDialog v-model:open="dialogs.showTransferDialog.value" :prefill-connection-id="dialogs.transferPrefillConnectionId.value" :prefill-database="dialogs.transferPrefillDatabase.value" />
+  <SchemaDiffDialog v-if="dialogs.showSchemaDiffDialog.value" v-model:open="dialogs.showSchemaDiffDialog.value" :prefill-connection-id="dialogs.schemaDiffPrefillConnectionId.value" :prefill-database="dialogs.schemaDiffPrefillDatabase.value" :prefill-schema="dialogs.schemaDiffPrefillSchema.value" />
+  <DataCompareDialog
+    v-if="dialogs.showDataCompareDialog.value"
+    v-model:open="dialogs.showDataCompareDialog.value"
+    :prefill-connection-id="dialogs.dataComparePrefillConnectionId.value"
+    :prefill-database="dialogs.dataComparePrefillDatabase.value"
+    :prefill-schema="dialogs.dataComparePrefillSchema.value"
+    :prefill-table="dialogs.dataComparePrefillTable.value"
+  />
+  <SqlFileExecutionDialog v-model:open="dialogs.showSqlFileDialog.value" :prefill-connection-id="dialogs.sqlFilePrefillConnectionId.value" :prefill-database="dialogs.sqlFilePrefillDatabase.value" :prefill-file-path="dialogs.sqlFilePrefillFilePath.value" />
+  <SchemaDiagramDialog
+    v-if="dialogs.showDiagramDialog.value"
+    v-model:open="dialogs.showDiagramDialog.value"
+    :prefill-connection-id="dialogs.diagramPrefillConnectionId.value"
+    :prefill-database="dialogs.diagramPrefillDatabase.value"
+    :prefill-schema="dialogs.diagramPrefillSchema.value"
+    :focus-table-name="dialogs.diagramFocusTableName.value"
+    @open-target="emit('openDiagramTarget', $event)"
+  />
+  <TableImportDialog
+    v-if="dialogs.showTableImportDialog.value"
+    v-model:open="dialogs.showTableImportDialog.value"
+    :prefill-connection-id="dialogs.tableImportPrefillConnectionId.value"
+    :prefill-database="dialogs.tableImportPrefillDatabase.value"
+    :prefill-schema="dialogs.tableImportPrefillSchema.value"
+    :prefill-table="dialogs.tableImportPrefillTable.value"
+  />
+  <DataGenerateDialog
+    v-if="dialogs.showTableDataGenerateDialog.value"
+    v-model:open="dialogs.showTableDataGenerateDialog.value"
+    :prefill-connection-id="dialogs.tableDataGeneratePrefillConnectionId.value"
+    :prefill-database="dialogs.tableDataGeneratePrefillDatabase.value"
+    :prefill-schema="dialogs.tableDataGeneratePrefillSchema.value"
+    :prefill-table="dialogs.tableDataGeneratePrefillTable.value"
+  />
+  <FieldLineageDialog
+    v-if="dialogs.showFieldLineageDialog.value"
+    v-model:open="dialogs.showFieldLineageDialog.value"
+    :prefill-connection-id="dialogs.lineagePrefillConnectionId.value"
+    :prefill-database="dialogs.lineagePrefillDatabase.value"
+    :prefill-schema="dialogs.lineagePrefillSchema.value"
+    :prefill-table="dialogs.lineagePrefillTable.value"
+    :prefill-column="dialogs.lineagePrefillColumn.value"
+    @open-target="emit('openLineageTarget', $event)"
+  />
+  <DatabaseSearchDialog
+    v-if="dialogs.showDatabaseSearchDialog.value"
+    v-model:open="dialogs.showDatabaseSearchDialog.value"
+    :prefill-connection-id="dialogs.databaseSearchPrefillConnectionId.value"
+    :prefill-database="dialogs.databaseSearchPrefillDatabase.value"
+    :prefill-schema="dialogs.databaseSearchPrefillSchema.value"
+    @open-target="emit('openDatabaseSearchTarget', $event)"
+  />
+  <DatabaseExportDialog
+    v-if="dialogs.showDatabaseExportDialog.value"
+    v-model:open="dialogs.showDatabaseExportDialog.value"
+    :prefill-connection-id="dialogs.databaseExportPrefillConnectionId.value"
+    :prefill-database="dialogs.databaseExportPrefillDatabase.value"
+    :prefill-schema="dialogs.databaseExportPrefillSchema.value"
+    :prefill-table="dialogs.databaseExportPrefillTable.value"
+    :prefill-tables="dialogs.databaseExportPrefillTables.value"
+    :prefill-all-databases="dialogs.databaseExportAllDatabases.value"
+  />
+  <ConfigPassphraseDialog
+    v-if="dialogs.showConfigPassphraseDialog.value"
+    v-model:open="dialogs.showConfigPassphraseDialog.value"
+    :mode="dialogs.configPassphraseMode.value"
+    :external-error="dialogs.configPassphraseError.value"
+    @confirm="dialogs.configPassphraseMode.value === 'export' ? dialogs.onExportConfirm($event) : dialogs.onImportConfirm($event)"
+  />
+  <Dialog v-model:open="dialogs.showImportLayoutConfirm.value">
+    <DialogContent class="sm:max-w-[400px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("configExport.importLayoutTitle") }}</DialogTitle>
+      </DialogHeader>
+      <p class="text-sm text-muted-foreground">{{ t("configExport.importLayoutConfirm") }}</p>
+      <DialogFooter>
+        <Button variant="outline" @click="dialogs.showImportLayoutConfirm.value = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button
+          @click="
+            dialogs.showImportLayoutConfirm.value = false;
+            dialogs.pendingImportLayout.value && connectionStore.applySidebarLayout(dialogs.pendingImportLayout.value);
+          "
+          >{{ t("configExport.importLayoutApply") }}</Button
+        >
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/layout/AppSidebar.vue b/apps/desktop/src/components/layout/AppSidebar.vue
new file mode 100644
index 0000000..775104a
--- /dev/null
+++ b/apps/desktop/src/components/layout/AppSidebar.vue
@@ -0,0 +1,277 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { translateBackendError } from "@/i18n/backend-errors";
+import { Upload, Download, FolderPlus, RefreshCw, ChevronsLeft, ChevronsUp, Trash2, FolderInput, Check, Minus, Square, X } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import LightDropdown from "@/components/ui/LightDropdown.vue";
+import LightTooltip from "@/components/ui/LightTooltip.vue";
+import ConnectionTree from "@/components/sidebar/ConnectionTree.vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useToast } from "@/composables/useToast";
+
+defineProps<{
+  sidebarWidth: number;
+  classicLayout?: boolean;
+}>();
+
+const emit = defineEmits<{
+  import: [source: "dbx" | "navicat" | "dbeaver" | "datagrip"];
+  export: [];
+  startResize: [event: MouseEvent];
+  collapse: [];
+}>();
+
+type ImportSource = "dbx" | "navicat" | "dbeaver" | "datagrip";
+
+const { t } = useI18n();
+const connectionStore = useConnectionStore();
+const { toast } = useToast();
+const connectionTreeRef = ref<InstanceType<typeof ConnectionTree>>();
+const showDeleteSelectedConfirm = ref(false);
+const showCreateSelectedGroupDialog = ref(false);
+const selectedGroupName = ref("");
+const UNGROUPED_GROUP_VALUE = "__ungrouped";
+const importSourceItems = computed(() => [
+  { value: "dbx", label: t("sidebar.importDbx") },
+  { value: "navicat", label: t("sidebar.importNavicat") },
+  { value: "dbeaver", label: t("sidebar.importDbeaver") },
+  { value: "datagrip", label: t("sidebar.importDatagrip") },
+]);
+const connectionIdSet = computed(() => new Set(connectionStore.connections.map((connection) => connection.id)));
+const allConnectionIds = computed(() => connectionStore.connections.map((connection) => connection.id));
+const selectedConnectionIds = computed(() => (connectionStore.connectionMultiSelectActive ? connectionStore.selectedTreeNodeIds.filter((id) => connectionIdSet.value.has(id)) : []));
+const selectedConnectionCount = computed(() => selectedConnectionIds.value.length);
+const showConnectionMultiSelectToolbar = computed(() => connectionStore.connectionMultiSelectActive && selectedConnectionCount.value > 0);
+const allConnectionsSelected = computed(() => allConnectionIds.value.length > 0 && selectedConnectionCount.value === allConnectionIds.value.length);
+const selectAllIcon = computed(() => (allConnectionsSelected.value ? Check : selectedConnectionCount.value > 0 ? Minus : Square));
+const selectAllLabel = computed(() => (allConnectionsSelected.value ? t("connectionGroup.deselectAllConnections") : t("connectionGroup.selectAllConnections")));
+const moveGroupItems = computed(() => [
+  ...connectionStore.sidebarLayout.groups.map((group) => ({
+    value: group.id,
+    label: group.name,
+  })),
+  {
+    value: UNGROUPED_GROUP_VALUE,
+    label: t("connectionGroup.ungrouped"),
+    separatorBefore: connectionStore.sidebarLayout.groups.length > 0,
+  },
+]);
+
+async function refreshTree() {
+  try {
+    await connectionStore.refreshAllTree();
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+function createNewGroup() {
+  void connectionTreeRef.value?.createNewGroup();
+}
+
+function selectImportSource(source: string) {
+  emit("import", source as ImportSource);
+}
+
+function collapseAllTreeNodes() {
+  connectionTreeRef.value?.collapseAllTreeNodes();
+}
+
+function focusSearch(): boolean {
+  return connectionTreeRef.value?.focusSearch() ?? false;
+}
+
+function clearConnectionMultiSelection() {
+  connectionStore.connectionMultiSelectActive = false;
+  connectionStore.selectedTreeNodeIds = [];
+  connectionStore.selectedTreeNodeId = null;
+  connectionStore.treeSelectionAnchorId = null;
+}
+
+function toggleAllConnectionsSelected() {
+  if (allConnectionsSelected.value) {
+    clearConnectionMultiSelection();
+    return;
+  }
+
+  const ids = allConnectionIds.value;
+  connectionStore.connectionMultiSelectActive = ids.length > 0;
+  connectionStore.selectedTreeNodeIds = ids;
+  connectionStore.selectedTreeNodeId = ids[0] ?? null;
+  connectionStore.treeSelectionAnchorId = ids[0] ?? null;
+}
+
+async function confirmDeleteSelectedConnections() {
+  const ids = selectedConnectionIds.value;
+  if (ids.length === 0) return;
+  try {
+    await connectionStore.removeConnections(ids);
+    for (const connectionId of ids) {
+      connectionStore.disconnect(connectionId).catch((error) => {
+        console.warn("[DBX][connection:delete:disconnect-failed]", { connectionId, error });
+      });
+    }
+    clearConnectionMultiSelection();
+    showDeleteSelectedConfirm.value = false;
+    toast(t("connection.deletedSelected", { count: ids.length }), 2000);
+  } catch (e: any) {
+    toast(t("connection.saveFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function moveSelectedConnectionsToGroup(value: string) {
+  const groupId = value === UNGROUPED_GROUP_VALUE ? null : value;
+  for (const connectionId of selectedConnectionIds.value) {
+    connectionStore.moveConnectionToGroup(connectionId, groupId);
+  }
+}
+
+function openCreateSelectedGroupDialog() {
+  selectedGroupName.value = "";
+  showCreateSelectedGroupDialog.value = true;
+}
+
+function confirmCreateSelectedGroup() {
+  const name = selectedGroupName.value.trim();
+  if (!name || selectedConnectionIds.value.length === 0) return;
+  const groupId = connectionStore.createConnectionGroup(name);
+  for (const connectionId of selectedConnectionIds.value) {
+    connectionStore.moveConnectionToGroup(connectionId, groupId);
+  }
+  showCreateSelectedGroupDialog.value = false;
+}
+
+defineExpose({ focusSearch });
+</script>
+
+<template>
+  <div class="app-sidebar-panel h-full shrink-0 relative select-none" :class="classicLayout ? '' : 'rounded-md border border-border/80 bg-background'" :style="{ width: sidebarWidth + 'px' }">
+    <div class="h-full flex flex-col overflow-hidden">
+      <div class="app-sidebar-toolbar flex items-center gap-px px-3 text-xs font-medium text-muted-foreground border-b bg-muted/20" :class="classicLayout ? 'h-9' : 'h-10'">
+        <span class="flex self-stretch items-center truncate" data-tauri-drag-region>{{ t("sidebar.connections") }}</span>
+        <span class="flex-1 self-stretch" data-tauri-drag-region />
+        <template v-if="showConnectionMultiSelectToolbar">
+          <span class="mr-1 text-[11px] font-medium text-muted-foreground">{{ selectedConnectionCount }}</span>
+          <LightTooltip :text="t('connectionGroup.createGroup')" side="bottom" :delay="0" :close-delay="0" nowrap>
+            <Button variant="ghost" size="icon" class="h-5 w-5" @click="openCreateSelectedGroupDialog">
+              <FolderPlus class="h-3 w-3" />
+            </Button>
+          </LightTooltip>
+          <LightTooltip :text="t('connectionGroup.moveToGroup')" side="bottom" :delay="0" :close-delay="0" nowrap>
+            <span class="inline-flex">
+              <LightDropdown
+                model-value=""
+                :items="moveGroupItems"
+                :aria-label="t('connectionGroup.moveToGroup')"
+                :trigger-icon="FolderInput"
+                trigger-class="inline-flex h-5 w-5 items-center justify-center rounded-md outline-none hover:bg-muted hover:text-foreground focus-visible:ring-0"
+                trigger-icon-class="h-3.5 w-3.5"
+                content-class="w-44"
+                :show-trigger-label="false"
+                :show-chevron="false"
+                :highlight-selected="false"
+                check-position="none"
+                align="end"
+                @update:model-value="moveSelectedConnectionsToGroup"
+              />
+            </span>
+          </LightTooltip>
+          <LightTooltip :text="t('contextMenu.deleteSelectedConnections', { count: selectedConnectionCount })" side="bottom" :delay="0" :close-delay="0" nowrap>
+            <Button variant="ghost" size="icon" class="h-5 w-5 text-destructive hover:text-destructive" @click="showDeleteSelectedConfirm = true">
+              <Trash2 class="h-3 w-3" />
+            </Button>
+          </LightTooltip>
+          <LightTooltip :text="selectAllLabel" side="bottom" :delay="0" :close-delay="0" nowrap>
+            <Button variant="ghost" size="icon" class="h-5 w-5" @click="toggleAllConnectionsSelected">
+              <component :is="selectAllIcon" class="h-3 w-3" />
+            </Button>
+          </LightTooltip>
+          <LightTooltip :text="t('connectionGroup.exitMultiSelect')" side="bottom" :delay="0" :close-delay="0" nowrap>
+            <Button variant="ghost" size="icon" class="h-5 w-5" @click="clearConnectionMultiSelection">
+              <X class="h-3 w-3" />
+            </Button>
+          </LightTooltip>
+        </template>
+        <template v-else>
+          <LightTooltip :text="t('sidebar.import')" side="bottom" :delay="0" :close-delay="0" nowrap>
+            <span class="inline-flex">
+              <LightDropdown
+                model-value=""
+                :items="importSourceItems"
+                :aria-label="t('sidebar.import')"
+                :trigger-icon="Download"
+                trigger-class="inline-flex h-6 w-5 items-center justify-center rounded-md outline-none hover:bg-muted hover:text-foreground focus-visible:ring-0"
+                trigger-icon-class="h-4 w-4"
+                content-class="w-44"
+                :show-trigger-label="false"
+                :show-chevron="false"
+                :highlight-selected="false"
+                check-position="none"
+                align="end"
+                @update:model-value="selectImportSource"
+              />
+            </span>
+          </LightTooltip>
+          <LightTooltip :text="t('sidebar.export')" side="bottom" :delay="0" :close-delay="0" nowrap>
+            <Button variant="ghost" size="icon" class="h-5 w-5" @click="emit('export')">
+              <Upload class="h-3 w-3" />
+            </Button>
+          </LightTooltip>
+          <LightTooltip :text="t('sidebar.collapseAll')" side="bottom" :delay="0" :close-delay="0" nowrap>
+            <Button variant="ghost" size="icon" class="h-5 w-5" @click="collapseAllTreeNodes">
+              <ChevronsUp class="h-3 w-3" />
+            </Button>
+          </LightTooltip>
+          <LightTooltip :text="t('connectionGroup.createGroup')" side="bottom" :delay="0" :close-delay="0" nowrap>
+            <Button variant="ghost" size="icon" class="h-5 w-5" @click="createNewGroup">
+              <FolderPlus class="h-3 w-3" />
+            </Button>
+          </LightTooltip>
+          <LightTooltip :text="t('contextMenu.refreshChildren')" side="bottom" :delay="0" :close-delay="0" nowrap>
+            <Button variant="ghost" size="icon" class="h-5 w-5" @click="refreshTree">
+              <RefreshCw class="h-3 w-3" />
+            </Button>
+          </LightTooltip>
+          <LightTooltip :text="t('sidebar.collapse')" side="bottom" :delay="0" :close-delay="0" nowrap>
+            <Button variant="ghost" size="icon" class="h-6 w-6" @click="emit('collapse')">
+              <ChevronsLeft class="h-3.5 w-3.5" />
+            </Button>
+          </LightTooltip>
+        </template>
+      </div>
+      <div class="flex-1 min-h-0">
+        <ConnectionTree ref="connectionTreeRef" />
+      </div>
+    </div>
+    <div class="panel-resize-handle panel-resize-handle--right" @mousedown="emit('startResize', $event)" />
+    <Dialog v-model:open="showDeleteSelectedConfirm">
+      <DialogContent class="sm:max-w-[400px]">
+        <DialogHeader>
+          <DialogTitle>{{ t("contextMenu.confirmDeleteTitle") }}</DialogTitle>
+        </DialogHeader>
+        <p class="text-sm text-muted-foreground">
+          {{ t("contextMenu.confirmDeleteSelectedMessage", { count: selectedConnectionCount }) }}
+        </p>
+        <DialogFooter>
+          <Button variant="outline" @click="showDeleteSelectedConfirm = false">{{ t("dangerDialog.cancel") }}</Button>
+          <Button variant="destructive" @click="confirmDeleteSelectedConnections">{{ t("contextMenu.deleteSelectedConnections", { count: selectedConnectionCount }) }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+    <Dialog v-model:open="showCreateSelectedGroupDialog">
+      <DialogContent class="sm:max-w-[360px]">
+        <DialogHeader>
+          <DialogTitle>{{ t("connectionGroup.createGroup") }}</DialogTitle>
+        </DialogHeader>
+        <Input v-model="selectedGroupName" :placeholder="t('connectionGroup.groupNamePlaceholder')" @keydown.enter.prevent="confirmCreateSelectedGroup" />
+        <DialogFooter>
+          <Button variant="outline" @click="showCreateSelectedGroupDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+          <Button :disabled="!selectedGroupName.trim()" @click="confirmCreateSelectedGroup">{{ t("connectionGroup.createGroup") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/layout/AppTabBar.vue b/apps/desktop/src/components/layout/AppTabBar.vue
new file mode 100644
index 0000000..3f30028
--- /dev/null
+++ b/apps/desktop/src/components/layout/AppTabBar.vue
@@ -0,0 +1,994 @@
+<script setup lang="ts">
+import { computed, ref, watch, nextTick, onUnmounted } from "vue";
+import type { CSSProperties } from "vue";
+import { useI18n } from "vue-i18n";
+import { X, Pin, ChevronDown, Table2, Code2, TableProperties, PencilRuler, KeyRound, Pencil, Package, Lock, Copy, AlertTriangle, Network, Minimize2, Maximize2, Settings, CalendarClock } from "@lucide/vue";
+import CustomContextMenu, { type ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
+import { Tooltip, TooltipTrigger, TooltipContent } from "@/components/ui/tooltip";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useTabScroll } from "@/composables/useTabScroll";
+import { useTabDrag } from "@/composables/useTabDrag";
+import { connectionColor, isConnectionReadonly, tabDisplayTitle, tabTooltipLines } from "@/lib/tabs/tabPresentation";
+import { hexToRgba } from "@/lib/common/color";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { useToast } from "@/composables/useToast";
+import type { QueryTab } from "@/types/database";
+
+const props = defineProps<{
+  driverStoreOpen?: boolean;
+  driverStoreActive?: boolean;
+  settingsPageOpen?: boolean;
+  settingsPageActive?: boolean;
+  agentDriverUpdateCount?: number;
+}>();
+
+const emit = defineEmits<{
+  "activate-tab": [];
+  "activate-driver-store": [];
+  "close-driver-store": [];
+  "activate-settings-page": [];
+  "close-settings-page": [];
+  "save-tab": [tabId: string];
+  "discard-tab-close": [];
+  "save-all-tab-close": [];
+  "discard-all-tab-close": [];
+  "cancel-tab-close": [];
+}>();
+
+const { t } = useI18n();
+const connectionStore = useConnectionStore();
+const queryStore = useQueryStore();
+const settingsStore = useSettingsStore();
+const { toast } = useToast();
+const tabDrag = useTabDrag((draggedId, targetId, position) => {
+  queryStore.reorderTab(draggedId, targetId, position);
+});
+const editingTabId = ref<string | null>(null);
+const editingTitle = ref("");
+const isClassicLayout = computed(() => settingsStore.editorSettings.appLayout === "classic");
+const fixedTabs = computed(() => queryStore.tabs.filter((tab) => tab.pinned));
+const regularTabs = computed(() => queryStore.tabs.filter((tab) => !tab.pinned));
+const hasFixedTabs = computed(() => fixedTabs.value.length > 0);
+const regularSurfaceCount = computed(() => regularTabs.value.length + (props.driverStoreOpen ? 1 : 0) + (props.settingsPageOpen ? 1 : 0));
+const closeConfirmDirtyCount = computed(() => queryStore.closeConfirmDirtyTabIds.length);
+const showCloseConfirmBulkActions = computed(() => closeConfirmDirtyCount.value > 1);
+const closeConfirmDirtyTabs = computed(() => queryStore.closeConfirmDirtyTabIds.map((id) => queryStore.tabs.find((tab) => tab.id === id)).filter((tab): tab is QueryTab => !!tab));
+const closeConfirmCurrentTitle = computed(() => {
+  const focusedTab = closeConfirmDirtyTabs.value.find((tab) => tab.id === queryStore.pendingCloseTabId) ?? closeConfirmDirtyTabs.value[0];
+  return focusedTab ? tabDisplayTitle(focusedTab, t) : "";
+});
+const closeConfirmMessage = computed(() => {
+  const params = {
+    count: closeConfirmDirtyCount.value,
+    title: closeConfirmCurrentTitle.value,
+  };
+  if (closeConfirmDirtyCount.value > 1) {
+    if (queryStore.closeConfirmContext === "app") return t("editor.unsavedChangesAppCloseMultipleMessage", params);
+    return t("editor.unsavedChangesBatchCloseMultipleMessage", params);
+  }
+  if (queryStore.closeConfirmContext === "app") return t("editor.unsavedChangesAppCloseMessage", params);
+  return t("editor.unsavedChangesMessage", params);
+});
+const closeConfirmListOpen = ref(false);
+let closeConfirmListCloseTimer: ReturnType<typeof setTimeout> | null = null;
+const compactTabTitle = computed({
+  get: () => settingsStore.editorSettings.compactTabTitle,
+  set: (checked: boolean | "indeterminate") => {
+    settingsStore.updateEditorSettings({ compactTabTitle: checked === true });
+  },
+});
+
+function openCloseConfirmList() {
+  if (closeConfirmListCloseTimer) {
+    clearTimeout(closeConfirmListCloseTimer);
+    closeConfirmListCloseTimer = null;
+  }
+  closeConfirmListOpen.value = true;
+}
+
+function scheduleCloseConfirmListClose() {
+  if (closeConfirmListCloseTimer) clearTimeout(closeConfirmListCloseTimer);
+  closeConfirmListCloseTimer = setTimeout(() => {
+    closeConfirmListOpen.value = false;
+    closeConfirmListCloseTimer = null;
+  }, 120);
+}
+
+onUnmounted(() => {
+  if (closeConfirmListCloseTimer) {
+    clearTimeout(closeConfirmListCloseTimer);
+    closeConfirmListCloseTimer = null;
+  }
+});
+
+watch(
+  () => queryStore.showCloseConfirm,
+  (open) => {
+    if (!open) closeConfirmListOpen.value = false;
+  },
+);
+
+function toggleCompactTabTitle() {
+  compactTabTitle.value = !compactTabTitle.value;
+}
+
+function canRenameTab(tab: QueryTab) {
+  return tab.mode === "query";
+}
+
+function startRenameTab(tab: QueryTab) {
+  if (!canRenameTab(tab)) return;
+  editingTabId.value = tab.id;
+  editingTitle.value = tab.title;
+  nextTick(() => {
+    const input = document.querySelector<HTMLInputElement>(`[data-tab-title-input="${tab.id}"]`);
+    input?.focus();
+    input?.select();
+  });
+}
+
+function commitRenameTab(tab: QueryTab) {
+  if (editingTabId.value !== tab.id) return;
+  const title = editingTitle.value.trim();
+  if (title) queryStore.renameTab(tab.id, title);
+  editingTabId.value = null;
+}
+
+function cancelRenameTab() {
+  editingTabId.value = null;
+}
+
+function isDirtyTab(tab: QueryTab) {
+  return queryStore.isTabDirty(tab);
+}
+
+function tabTitleLabel(tab: QueryTab) {
+  const title = tabDisplayTitle(tab, t);
+  return isDirtyTab(tab) ? `* ${title}` : title;
+}
+
+function tabTitleText(tab: QueryTab) {
+  return tabDisplayTitle(tab, t);
+}
+
+function tabTitleStyle(tab: QueryTab): CSSProperties | undefined {
+  if (!isDirtyTab(tab)) return undefined;
+  return {
+    fontStyle: "italic",
+    fontWeight: 700,
+    transform: "skewX(-8deg)",
+    transformOrigin: "left center",
+  };
+}
+
+type SpecialRegularSurface = "driverStore" | "settings";
+
+function closeSpecialRegularSurfaces(keep?: SpecialRegularSurface) {
+  if (keep !== "driverStore" && props.driverStoreOpen) emit("close-driver-store");
+  if (keep !== "settings" && props.settingsPageOpen) emit("close-settings-page");
+}
+
+function closeOtherRegularTabsFromTab(tab: QueryTab) {
+  queryStore.closeOtherRegularTabs(tab.id);
+  closeSpecialRegularSurfaces();
+}
+
+function closeAllRegularSurfaces() {
+  queryStore.closeRegularTabs();
+  closeSpecialRegularSurfaces();
+}
+
+function getSpecialRegularTabMenuItems(surface: SpecialRegularSurface): ContextMenuItem[] {
+  const keep = surface;
+  const closeCurrent = surface === "driverStore" ? () => emit("close-driver-store") : () => emit("close-settings-page");
+  const closeOtherDisabled = regularSurfaceCount.value <= 1;
+  const closeOtherLabel = hasFixedTabs.value ? t("contextMenu.closeOtherRegularTabs") : t("contextMenu.closeOtherTabs");
+  const closeAllLabel = hasFixedTabs.value ? t("contextMenu.closeAllRegularTabs") : t("contextMenu.closeAllTabs");
+
+  return [
+    {
+      label: compactTabTitle.value ? t("contextMenu.fullTabTitle") : t("contextMenu.compactTabTitle"),
+      action: toggleCompactTabTitle,
+      icon: compactTabTitle.value ? Maximize2 : Minimize2,
+    },
+    { label: "", separator: true },
+    { label: t("contextMenu.closeTab"), action: closeCurrent, icon: X },
+    {
+      label: closeOtherLabel,
+      action: () => {
+        queryStore.closeRegularTabs();
+        closeSpecialRegularSurfaces(keep);
+      },
+      disabled: closeOtherDisabled,
+      icon: X,
+    },
+    {
+      label: closeAllLabel,
+      action: closeAllRegularSurfaces,
+      variant: "destructive" as const,
+      icon: X,
+    },
+  ];
+}
+
+function getTabMenuItems(tab: QueryTab): ContextMenuItem[] {
+  const closeCurrentLabel = tab.pinned ? t("contextMenu.closeFixedTab") : t("contextMenu.closeTab");
+  const closeOtherLabel = tab.pinned ? t("contextMenu.closeOtherFixedTabs") : hasFixedTabs.value ? t("contextMenu.closeOtherRegularTabs") : t("contextMenu.closeOtherTabs");
+  const closeAllLabel = tab.pinned ? t("contextMenu.closeAllFixedTabs") : hasFixedTabs.value ? t("contextMenu.closeAllRegularTabs") : t("contextMenu.closeAllTabs");
+  const closeOtherDisabled = tab.pinned ? fixedTabs.value.length <= 1 : regularSurfaceCount.value <= 1;
+  const closeOtherAction = tab.pinned ? () => queryStore.closeOtherFixedTabs(tab.id) : () => closeOtherRegularTabsFromTab(tab);
+  const closeAllAction = tab.pinned ? () => queryStore.closeFixedTabs() : closeAllRegularSurfaces;
+
+  return [
+    {
+      label: compactTabTitle.value ? t("contextMenu.fullTabTitle") : t("contextMenu.compactTabTitle"),
+      action: toggleCompactTabTitle,
+      icon: compactTabTitle.value ? Maximize2 : Minimize2,
+    },
+    {
+      label: t("contextMenu.renameTab"),
+      action: () => startRenameTab(tab),
+      icon: Pencil,
+      visible: canRenameTab(tab),
+    },
+    {
+      label: t("contextMenu.duplicateTab"),
+      action: () => queryStore.duplicateTab(tab.id),
+      icon: Copy,
+      visible: canRenameTab(tab),
+    },
+    {
+      label: t("contextMenu.copyName"),
+      action: async () => {
+        try {
+          await copyToClipboard(tabDisplayTitle(tab, t));
+          toast(t("connection.copied"), 2000);
+        } catch (e: any) {
+          toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+        }
+      },
+      icon: Copy,
+    },
+    { label: "", separator: true },
+    {
+      label: tab.pinned ? t("contextMenu.unfixTab") : t("contextMenu.fixTab"),
+      action: () => queryStore.togglePinnedTab(tab.id),
+      icon: Pin,
+      iconClass: tab.pinned ? "fill-current" : "",
+    },
+    { label: "", separator: true },
+    { label: closeCurrentLabel, action: () => queryStore.closeTab(tab.id), icon: X },
+    {
+      label: closeOtherLabel,
+      action: closeOtherAction,
+      disabled: closeOtherDisabled,
+      icon: X,
+    },
+    {
+      label: closeAllLabel,
+      action: closeAllAction,
+      variant: "destructive" as const,
+      icon: X,
+    },
+  ];
+}
+
+function handleSaveAndClose() {
+  const id = queryStore.saveAndClosePendingTab();
+  if (id) emit("save-tab", id);
+}
+
+function handleDiscardAndClose() {
+  queryStore.forceClosePendingTab();
+  emit("discard-tab-close");
+}
+
+function handleSaveAllAndClose() {
+  emit("save-all-tab-close");
+}
+
+function handleDiscardAllAndClose() {
+  queryStore.forceCloseAllPendingTabs();
+  emit("discard-all-tab-close");
+}
+
+function handleCancelClose() {
+  queryStore.cancelClosePendingTab();
+  emit("cancel-tab-close");
+}
+
+const tabsContainerRef = ref<HTMLElement | null>(null);
+const { hasTabOverflow, scrollThumbLeftPercent, scrollThumbWidthPercent, isScrollbarDragging, updateScrollButtons, onTabsWheel, startScrollbarDrag } = useTabScroll(tabsContainerRef);
+const fixedTabsContainerRef = ref<HTMLElement | null>(null);
+const {
+  hasTabOverflow: hasFixedTabOverflow,
+  scrollThumbLeftPercent: fixedScrollThumbLeftPercent,
+  scrollThumbWidthPercent: fixedScrollThumbWidthPercent,
+  isScrollbarDragging: isFixedScrollbarDragging,
+  updateScrollButtons: updateFixedScrollButtons,
+  onTabsWheel: onFixedTabsWheel,
+  startScrollbarDrag: startFixedScrollbarDrag,
+} = useTabScroll(fixedTabsContainerRef);
+const tabScrollBehavior = ref<ScrollBehavior>("smooth");
+
+function updateAllScrollButtons() {
+  updateScrollButtons();
+  updateFixedScrollButtons();
+}
+
+function activeTabScrollInline(container: HTMLElement, tabId: string | null): ScrollLogicalPosition {
+  if (!tabId) return "center";
+  const lastRegularTab = regularTabs.value[regularTabs.value.length - 1];
+  const lastFixedTab = fixedTabs.value[fixedTabs.value.length - 1];
+  if (container === tabsContainerRef.value && lastRegularTab?.id === tabId) return "end";
+  if (container === fixedTabsContainerRef.value && lastFixedTab?.id === tabId) return "end";
+  return "center";
+}
+
+watch(
+  () => queryStore.tabs.map((tab) => `${tab.id}:${tab.pinned ? "1" : "0"}`).join("|"),
+  () => {
+    nextTick(updateAllScrollButtons);
+  },
+);
+
+watch(
+  () => queryStore.activeTabId,
+  () => {
+    nextTick(() => {
+      for (const container of [tabsContainerRef.value, fixedTabsContainerRef.value]) {
+        if (!container) continue;
+        const activeEl = container.querySelector('[data-active-tab="true"]');
+        if (activeEl) {
+          activeEl.scrollIntoView({ behavior: tabScrollBehavior.value, block: "nearest", inline: activeTabScrollInline(container, queryStore.activeTabId) });
+          break;
+        }
+      }
+      updateAllScrollButtons();
+      tabScrollBehavior.value = "smooth";
+    });
+  },
+);
+
+watch(
+  () => props.driverStoreActive,
+  (show) => {
+    if (!show) return;
+    nextTick(() => {
+      const container = tabsContainerRef.value;
+      if (!container) return;
+      const el = container.querySelector("[data-driver-store-tab]");
+      if (el) {
+        el.scrollIntoView({ behavior: "smooth", block: "nearest", inline: "center" });
+      }
+      updateAllScrollButtons();
+    });
+  },
+);
+
+watch(
+  () => props.settingsPageActive,
+  (show) => {
+    if (!show) return;
+    nextTick(() => {
+      const container = tabsContainerRef.value;
+      if (!container) return;
+      const el = container.querySelector("[data-settings-page-tab]");
+      if (el) {
+        el.scrollIntoView({ behavior: "smooth", block: "nearest", inline: "center" });
+      }
+      updateAllScrollButtons();
+    });
+  },
+);
+
+function tabColorStyle(tab: QueryTab) {
+  const color = connectionColor(tab.connectionId);
+  const isActive = tab.id === queryStore.activeTabId && !props.driverStoreActive && !props.settingsPageActive;
+  const isClassic = isClassicLayout.value;
+  if (!color) {
+    if (isClassic) {
+      return isActive ? { boxShadow: "inset 0 -2px 0 var(--ring)" } : undefined;
+    }
+    return isActive
+      ? {
+          borderColor: "var(--ring)",
+        }
+      : undefined;
+  }
+
+  if (isClassic) {
+    return {
+      backgroundColor: hexToRgba(color, isActive ? 0.16 : 0.07),
+      boxShadow: isActive ? `inset 0 -2px 0 ${color}` : undefined,
+    };
+  }
+
+  return {
+    backgroundColor: hexToRgba(color, isActive ? 0.16 : 0.09),
+    borderColor: isActive ? hexToRgba(color, 0.72) : hexToRgba(color, 0.18),
+  };
+}
+
+function tabIconClass(tab: QueryTab) {
+  if (tab.mode === "mq") return "";
+  if (tab.mode === "data" || tab.mode === "mongo" || tab.mode === "vector" || tab.mode === "redis" || tab.mode === "objects" || tab.mode === "structure") return "text-emerald-600 dark:text-emerald-400";
+  return "text-blue-600 dark:text-blue-400";
+}
+
+function tabDatabaseIconType(tab: QueryTab) {
+  const connection = connectionStore.getConfig(tab.connectionId);
+  if (!connection) return "mq";
+  if (connection.db_type === "mq") {
+    const externalConfig = connection.external_config as { systemKind?: unknown } | undefined;
+    const systemKind = typeof externalConfig?.systemKind === "string" ? externalConfig.systemKind : "";
+    if (connection.driver_profile === "kafka" || systemKind === "kafka") return "kafka";
+    if (connection.driver_profile === "pulsar" || systemKind === "pulsar") return "pulsar";
+  }
+  return connection.driver_profile || connection.db_type;
+}
+
+const showRegularTabScrollbar = computed(() => hasTabOverflow.value);
+const showFixedTabScrollbar = computed(() => hasFixedTabOverflow.value);
+const showRegularTabOverflowControls = computed(() => regularTabs.value.length > 0 && hasTabOverflow.value);
+const regularTabOverflowOpen = ref(false);
+const fixedTabOverflowOpen = ref(false);
+const tabBarClass = computed(() => [isClassicLayout.value ? "bg-muted" : "border-b bg-background", hasFixedTabs.value ? "flex-col" : "", isClassicLayout.value && hasFixedTabs.value ? "border-b" : ""]);
+const regularTabRowClass = computed(() => [isClassicLayout.value ? "h-9 items-stretch" : "h-10 items-center px-2", isClassicLayout.value && !hasFixedTabs.value ? "border-b" : ""]);
+
+function tabMenuIcon(tab: QueryTab) {
+  if (tab.mode === "data" || tab.mode === "mongo" || tab.mode === "redis") return Table2;
+  if (tab.mode === "vector") return TableProperties;
+  if (tab.mode === "etcd" || tab.mode === "zookeeper") return KeyRound;
+  if (tab.mode === "nacos") return Network;
+  if (tab.mode === "objects") return TableProperties;
+  if (tab.mode === "structure") return PencilRuler;
+  if (tab.mode === "dameng-jobs") return CalendarClock;
+  return Code2;
+}
+
+function handleTabClick(tab: QueryTab) {
+  if (tabDrag.state.wasDragged) return;
+  activateTab(tab.id);
+}
+
+function handleTabMouseDown(event: MouseEvent, tabId: string) {
+  if (event.button === 0) {
+    dispatchBeforeTabSwitch(tabId);
+    event.preventDefault();
+  }
+  tabDrag.startDrag(event, tabId);
+}
+
+function handleTabDragTarget(event: MouseEvent, tab: QueryTab) {
+  const draggedTab = queryStore.tabs.find((item) => item.id === tabDrag.state.draggedId);
+  if (draggedTab && draggedTab.pinned !== tab.pinned) {
+    tabDrag.clearTarget(tab.id);
+    return;
+  }
+  tabDrag.updateTarget(event, tab.id);
+}
+
+function tabDropStyle(tabId: string) {
+  if (!tabDrag.state.active) return {};
+  if (tabDrag.state.draggedId === tabId) return { opacity: 0.4 };
+  if (tabDrag.state.targetId !== tabId) return {};
+  const dropColor = `var(--ring)`;
+  if (tabDrag.state.dropPosition === "before") {
+    return { boxShadow: `inset 3px 0 0 0 ${dropColor}` };
+  }
+  return { boxShadow: `inset -3px 0 0 0 ${dropColor}` };
+}
+
+const tabsContainerStyle = computed<CSSProperties>(() => ({
+  msOverflowStyle: "none",
+  scrollbarWidth: "none",
+  WebkitOverflowScrolling: "touch",
+}));
+
+const tabScrollbarThumbStyle = computed<CSSProperties>(() => ({
+  insetInlineStart: `${scrollThumbLeftPercent.value}%`,
+  width: `${scrollThumbWidthPercent.value}%`,
+}));
+
+const fixedTabScrollbarThumbStyle = computed<CSSProperties>(() => ({
+  insetInlineStart: `${fixedScrollThumbLeftPercent.value}%`,
+  width: `${fixedScrollThumbWidthPercent.value}%`,
+}));
+
+const tabTailDragRegionClass = computed(() => (showRegularTabOverflowControls.value ? "w-0 flex-none self-stretch" : "min-w-8 flex-1 self-stretch"));
+const fixedTabTailDragRegionClass = computed(() => (showFixedTabScrollbar.value ? "w-0 flex-none self-stretch" : "min-w-8 flex-1 self-stretch"));
+
+const tabOverflowControlClass = computed(() =>
+  isClassicLayout.value
+    ? "h-full w-8 border-r border-border/80 dark:border-border/45 bg-background/80 text-foreground/75 hover:bg-accent hover:text-foreground disabled:cursor-default disabled:opacity-40"
+    : "h-7 w-7 rounded-md border border-border/60 bg-background text-foreground/70 hover:border-border hover:text-foreground",
+);
+
+function dispatchBeforeTabSwitch(tabId: string) {
+  if (tabId === queryStore.activeTabId) return;
+  window.dispatchEvent(new CustomEvent("dbx:before-tab-switch", { detail: { tabId, fromTabId: queryStore.activeTabId } }));
+}
+
+function activateTab(tabId: string) {
+  dispatchBeforeTabSwitch(tabId);
+  tabScrollBehavior.value = "auto";
+  queryStore.activeTabId = tabId;
+  emit("activate-tab");
+}
+
+function activateTabFromOverflow(tabId: string, kind: "regular" | "fixed") {
+  activateTab(tabId);
+  if (kind === "regular") regularTabOverflowOpen.value = false;
+  else fixedTabOverflowOpen.value = false;
+}
+
+function closeTabFromOverflow(tabId: string, event: MouseEvent) {
+  event.preventDefault();
+  event.stopPropagation();
+  queryStore.closeTab(tabId);
+}
+
+function onOverflowItemKeydown(event: KeyboardEvent, tabId: string, kind: "regular" | "fixed") {
+  if (event.key !== "Enter" && event.key !== " ") return;
+  event.preventDefault();
+  activateTabFromOverflow(tabId, kind);
+}
+</script>
+
+<template>
+  <div v-if="queryStore.tabs.length > 0 || driverStoreOpen || settingsPageOpen" class="app-tab-bar relative flex w-full min-w-0 shrink-0 overflow-hidden" :class="tabBarClass">
+    <div class="flex w-full min-w-0 shrink-0 overflow-hidden" :class="regularTabRowClass">
+      <div class="app-tab-strip relative h-full min-w-0 flex-1 overflow-hidden">
+        <div v-if="showRegularTabScrollbar" class="app-tab-scrollbar" :class="{ 'app-tab-scrollbar--dragging': isScrollbarDragging }" @pointerdown="startScrollbarDrag">
+          <div class="app-tab-scrollbar__thumb" :style="tabScrollbarThumbStyle" />
+        </div>
+        <div ref="tabsContainerRef" class="app-tab-scroll flex w-full min-w-0 flex-1 items-center overflow-x-auto" :class="isClassicLayout ? 'h-full' : 'h-full gap-1.5 py-1.5'" :style="tabsContainerStyle" @scroll="updateScrollButtons" @wheel="onTabsWheel">
+          <CustomContextMenu v-for="tab in regularTabs" :key="tab.id" :items="getTabMenuItems(tab)" v-slot="{ onContextMenu }">
+            <div :class="isClassicLayout ? 'h-full' : ''" @contextmenu="onContextMenu">
+              <Tooltip>
+                <TooltipTrigger as-child>
+                  <div
+                    class="group flex items-center gap-1 px-2 text-xs cursor-pointer transition-colors whitespace-nowrap select-none"
+                    :class="
+                      isClassicLayout
+                        ? [
+                            compactTabTitle ? 'min-w-24' : 'min-w-38',
+                            'h-full border-r border-border/80 font-medium dark:border-border/45',
+                            tab.id === queryStore.activeTabId && !driverStoreActive && !settingsPageActive ? 'bg-background text-foreground' : 'text-foreground/70 hover:text-foreground/90',
+                          ]
+                        : [compactTabTitle ? 'min-w-24' : 'min-w-38', 'h-7 rounded-md border', tab.id === queryStore.activeTabId && !driverStoreActive && !settingsPageActive ? 'text-foreground font-medium' : 'border-border/60 text-foreground/70 hover:border-border hover:text-foreground/90']
+                    "
+                    :style="[tabColorStyle(tab), tabDropStyle(tab.id)]"
+                    :data-active-tab="tab.id === queryStore.activeTabId && !driverStoreActive && !settingsPageActive"
+                    @click="handleTabClick(tab)"
+                    @dblclick.stop="startRenameTab(tab)"
+                    @mousedown.middle.prevent="queryStore.closeTab(tab.id)"
+                    @mousedown="handleTabMouseDown($event, tab.id)"
+                    @mouseenter="handleTabDragTarget($event, tab)"
+                    @mousemove="handleTabDragTarget($event, tab)"
+                    @mouseleave="tabDrag.clearTarget(tab.id)"
+                  >
+                    <span class="shrink-0" :class="tabIconClass(tab)">
+                      <Table2 v-if="tab.mode === 'data' || tab.mode === 'mongo' || tab.mode === 'redis'" class="h-3.5 w-3.5" />
+                      <DatabaseIcon v-else-if="tab.mode === 'mq'" :db-type="tabDatabaseIconType(tab)" class="h-3.5 w-3.5" />
+                      <TableProperties v-else-if="tab.mode === 'vector'" class="h-3.5 w-3.5" />
+                      <KeyRound v-else-if="tab.mode === 'etcd' || tab.mode === 'zookeeper'" class="h-3.5 w-3.5" />
+                      <Network v-else-if="tab.mode === 'nacos'" class="h-3.5 w-3.5" />
+                      <TableProperties v-else-if="tab.mode === 'objects'" class="h-3.5 w-3.5" />
+                      <PencilRuler v-else-if="tab.mode === 'structure'" class="h-3.5 w-3.5" />
+                      <CalendarClock v-else-if="tab.mode === 'dameng-jobs'" class="h-3.5 w-3.5" />
+                      <Code2 v-else class="h-3.5 w-3.5" />
+                    </span>
+                    <input
+                      v-if="editingTabId === tab.id"
+                      v-model="editingTitle"
+                      :data-tab-title-input="tab.id"
+                      :aria-label="t('contextMenu.renameTab')"
+                      class="h-5 min-w-0 flex-1 rounded border border-ring bg-background px-1.5 text-xs font-normal text-foreground outline-none"
+                      @click.stop
+                      @mousedown.stop
+                      @keydown.enter.prevent="commitRenameTab(tab)"
+                      @keydown.escape.prevent="cancelRenameTab"
+                      @blur="commitRenameTab(tab)"
+                    />
+                    <span v-else class="inline-flex min-w-0 flex-1 items-center gap-0.5 overflow-hidden">
+                      <span v-if="isDirtyTab(tab)" aria-hidden="true" class="dirty-tab-marker">*</span>
+                      <span class="min-w-0 flex-1 truncate" :style="tabTitleStyle(tab)">{{ tabTitleText(tab) }}</span>
+                    </span>
+                    <Tooltip v-if="isConnectionReadonly(tab.connectionId)">
+                      <TooltipTrigger as-child>
+                        <Lock class="h-3 w-3 text-muted-foreground shrink-0" />
+                      </TooltipTrigger>
+                      <TooltipContent>{{ t("connection.readOnlyBadge") }}</TooltipContent>
+                    </Tooltip>
+                    <button class="rounded hover:bg-muted-foreground/20 p-0.5 shrink-0" @click.stop="queryStore.closeTab(tab.id)">
+                      <X class="h-3 w-3" />
+                    </button>
+                  </div>
+                </TooltipTrigger>
+                <TooltipContent side="bottom" class="text-xs grid grid-cols-[auto_1fr] gap-x-2">
+                  <template v-for="line in tabTooltipLines(tab, t)" :key="line.label">
+                    <span class="text-muted-foreground">{{ line.label }}</span>
+                    <span>{{ line.value }}</span>
+                  </template>
+                </TooltipContent>
+              </Tooltip>
+            </div>
+          </CustomContextMenu>
+
+          <!-- Settings Page Tab -->
+          <CustomContextMenu v-if="settingsPageOpen" :items="getSpecialRegularTabMenuItems('settings')" v-slot="{ onContextMenu }">
+            <div :class="isClassicLayout ? 'h-full' : ''" @contextmenu="onContextMenu">
+              <div
+                data-settings-page-tab
+                class="group flex min-w-36 items-center gap-1 px-2 text-xs cursor-pointer transition-colors whitespace-nowrap"
+                :class="
+                  isClassicLayout
+                    ? ['h-full border-r border-border/80 dark:border-border/45 font-medium', settingsPageActive ? 'bg-background text-foreground' : 'text-foreground/70 hover:text-foreground/90']
+                    : ['h-7 rounded-md border font-medium', settingsPageActive ? 'border-ring text-foreground' : 'border-border/60 text-foreground/70 hover:border-border hover:text-foreground/90']
+                "
+                :style="isClassicLayout && settingsPageActive ? { boxShadow: '0 1px 0 0 var(--color-background)' } : {}"
+                @click="emit('activate-settings-page')"
+                @mousedown.middle.prevent="emit('close-settings-page')"
+              >
+                <span class="shrink-0 text-sky-600 dark:text-sky-400">
+                  <Settings class="h-3.5 w-3.5" />
+                </span>
+                <span class="min-w-0 truncate flex-1">{{ t("settings.title") }}</span>
+                <button class="rounded hover:bg-muted-foreground/20 p-0.5 shrink-0" @click.stop="emit('close-settings-page')">
+                  <X class="h-3 w-3" />
+                </button>
+              </div>
+            </div>
+          </CustomContextMenu>
+
+          <!-- Driver Store Tab -->
+          <CustomContextMenu v-if="driverStoreOpen" :items="getSpecialRegularTabMenuItems('driverStore')" v-slot="{ onContextMenu }">
+            <div :class="isClassicLayout ? 'h-full' : ''" @contextmenu="onContextMenu">
+              <div
+                data-driver-store-tab
+                class="group flex min-w-38 items-center gap-1 px-2 text-xs cursor-pointer transition-colors whitespace-nowrap"
+                :class="
+                  isClassicLayout
+                    ? ['h-full border-r border-border/80 dark:border-border/45 font-medium', driverStoreActive ? 'bg-background text-foreground' : 'text-foreground/70 hover:text-foreground/90']
+                    : ['h-7 rounded-md border font-medium', driverStoreActive ? 'border-ring text-foreground' : 'border-border/60 text-foreground/70 hover:border-border hover:text-foreground/90']
+                "
+                :style="isClassicLayout && driverStoreActive ? { boxShadow: '0 1px 0 0 var(--color-background)' } : {}"
+                @click="emit('activate-driver-store')"
+                @mousedown.middle.prevent="emit('close-driver-store')"
+              >
+                <span class="shrink-0 text-amber-600 dark:text-amber-400">
+                  <Package class="h-3.5 w-3.5" />
+                </span>
+                <span class="min-w-0 truncate flex-1">{{ t("toolbar.driverManager") }}</span>
+                <span v-if="(agentDriverUpdateCount ?? 0) > 0" class="inline-flex h-4 min-w-4 shrink-0 items-center justify-center rounded-full bg-red-500 px-1 text-[10px] font-medium leading-none text-white" :aria-label="t('toolbar.updatableDriverCount')">
+                  {{ (agentDriverUpdateCount ?? 0) > 99 ? "99+" : agentDriverUpdateCount }}
+                </span>
+                <button class="rounded hover:bg-muted-foreground/20 p-0.5 shrink-0" @click.stop="emit('close-driver-store')">
+                  <X class="h-3 w-3" />
+                </button>
+              </div>
+            </div>
+          </CustomContextMenu>
+          <div :class="tabTailDragRegionClass" data-tauri-drag-region />
+        </div>
+      </div>
+      <div v-if="showRegularTabOverflowControls" class="relative z-30 flex shrink-0 items-center">
+        <Popover v-model:open="regularTabOverflowOpen">
+          <PopoverTrigger as-child>
+            <button type="button" :class="['inline-flex shrink-0 items-center justify-center', tabOverflowControlClass].join(' ')" :aria-label="t('tabs.openTabs')" :title="t('tabs.openTabs')">
+              <ChevronDown class="h-4 w-4" />
+            </button>
+          </PopoverTrigger>
+          <PopoverContent align="end" class="w-auto min-w-56 max-w-80 max-h-[min(70vh,28rem)] gap-0 overflow-y-auto rounded-[6px] p-1" @click.stop @keydown.stop>
+            <CustomContextMenu v-for="tab in queryStore.tabs" :key="tab.id" :items="getTabMenuItems(tab)" v-slot="{ onContextMenu }">
+              <div
+                class="group flex w-full items-center gap-2 rounded-md px-1.5 py-1.5 text-left text-sm outline-hidden hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground"
+                :class="tab.id === queryStore.activeTabId && !driverStoreActive && !settingsPageActive ? 'bg-accent/70 text-accent-foreground' : ''"
+                :title="tabTitleLabel(tab)"
+                role="menuitem"
+                tabindex="0"
+                @click="activateTabFromOverflow(tab.id, 'regular')"
+                @contextmenu="onContextMenu"
+                @keydown="onOverflowItemKeydown($event, tab.id, 'regular')"
+              >
+                <DatabaseIcon v-if="tab.mode === 'mq'" :db-type="tabDatabaseIconType(tab)" class="h-3.5 w-3.5 shrink-0" />
+                <component :is="tabMenuIcon(tab)" v-else :class="['h-3.5 w-3.5 shrink-0', tabIconClass(tab)]" />
+                <span class="inline-flex min-w-0 flex-1 items-center gap-0.5 overflow-hidden">
+                  <span v-if="isDirtyTab(tab)" aria-hidden="true" class="dirty-tab-marker">*</span>
+                  <span class="min-w-0 flex-1 truncate" :style="tabTitleStyle(tab)">{{ tabTitleText(tab) }}</span>
+                </span>
+                <Lock v-if="isConnectionReadonly(tab.connectionId)" class="h-3 w-3 shrink-0 text-muted-foreground" />
+                <Pin v-if="tab.pinned" class="h-3 w-3 shrink-0 fill-current text-primary" />
+                <span class="w-5 shrink-0">
+                  <button
+                    type="button"
+                    class="inline-flex rounded p-1 text-muted-foreground opacity-70 hover:bg-muted-foreground/20 hover:text-foreground group-hover:opacity-100"
+                    :aria-label="t('contextMenu.closeTab')"
+                    :title="t('contextMenu.closeTab')"
+                    @click="closeTabFromOverflow(tab.id, $event)"
+                    @mousedown.stop
+                  >
+                    <X class="h-3 w-3" />
+                  </button>
+                </span>
+              </div>
+            </CustomContextMenu>
+          </PopoverContent>
+        </Popover>
+      </div>
+    </div>
+
+    <div v-if="hasFixedTabs" class="flex w-full min-w-0 shrink-0 overflow-hidden border-t" :class="isClassicLayout ? 'h-8 items-stretch border-border/80 bg-background/45 dark:border-border/45 dark:bg-background/20' : 'h-9 items-center border-border/70 bg-muted/45 px-2 dark:bg-muted/25'">
+      <div class="app-tab-strip relative h-full min-w-0 flex-1 overflow-hidden">
+        <div v-if="showFixedTabScrollbar" class="app-tab-scrollbar app-tab-scrollbar--bottom" :class="{ 'app-tab-scrollbar--dragging': isFixedScrollbarDragging }" @pointerdown="startFixedScrollbarDrag">
+          <div class="app-tab-scrollbar__thumb" :style="fixedTabScrollbarThumbStyle" />
+        </div>
+        <div ref="fixedTabsContainerRef" class="app-tab-scroll flex w-full min-w-0 flex-1 items-center overflow-x-auto" :class="isClassicLayout ? 'h-full' : 'h-full gap-1.5 py-1'" :style="tabsContainerStyle" @scroll="updateFixedScrollButtons" @wheel="onFixedTabsWheel">
+          <CustomContextMenu v-for="tab in fixedTabs" :key="tab.id" :items="getTabMenuItems(tab)" v-slot="{ onContextMenu }">
+            <div :class="isClassicLayout ? 'h-full' : ''" @contextmenu="onContextMenu">
+              <Tooltip>
+                <TooltipTrigger as-child>
+                  <div
+                    class="group flex items-center gap-1 px-2 text-xs cursor-pointer transition-colors whitespace-nowrap select-none"
+                    :class="
+                      isClassicLayout
+                        ? [
+                            compactTabTitle ? 'min-w-24' : 'min-w-38',
+                            'h-full border-r border-border/80 font-medium dark:border-border/45',
+                            tab.id === queryStore.activeTabId && !driverStoreActive && !settingsPageActive ? 'bg-background text-foreground' : 'text-foreground/70 hover:text-foreground/90',
+                          ]
+                        : [compactTabTitle ? 'min-w-24' : 'min-w-38', 'h-7 rounded-md border', tab.id === queryStore.activeTabId && !driverStoreActive && !settingsPageActive ? 'text-foreground font-medium' : 'border-border/60 text-foreground/70 hover:border-border hover:text-foreground/90']
+                    "
+                    :style="[tabColorStyle(tab), tabDropStyle(tab.id)]"
+                    :data-active-tab="tab.id === queryStore.activeTabId && !driverStoreActive && !settingsPageActive"
+                    @click="handleTabClick(tab)"
+                    @dblclick.stop="startRenameTab(tab)"
+                    @mousedown.middle.prevent="queryStore.closeTab(tab.id)"
+                    @mousedown="handleTabMouseDown($event, tab.id)"
+                    @mouseenter="handleTabDragTarget($event, tab)"
+                    @mousemove="handleTabDragTarget($event, tab)"
+                    @mouseleave="tabDrag.clearTarget(tab.id)"
+                  >
+                    <span class="shrink-0" :class="tabIconClass(tab)">
+                      <Table2 v-if="tab.mode === 'data' || tab.mode === 'mongo' || tab.mode === 'redis'" class="h-3.5 w-3.5" />
+                      <DatabaseIcon v-else-if="tab.mode === 'mq'" :db-type="tabDatabaseIconType(tab)" class="h-3.5 w-3.5" />
+                      <TableProperties v-else-if="tab.mode === 'vector'" class="h-3.5 w-3.5" />
+                      <KeyRound v-else-if="tab.mode === 'etcd' || tab.mode === 'zookeeper'" class="h-3.5 w-3.5" />
+                      <Network v-else-if="tab.mode === 'nacos'" class="h-3.5 w-3.5" />
+                      <TableProperties v-else-if="tab.mode === 'objects'" class="h-3.5 w-3.5" />
+                      <PencilRuler v-else-if="tab.mode === 'structure'" class="h-3.5 w-3.5" />
+                      <CalendarClock v-else-if="tab.mode === 'dameng-jobs'" class="h-3.5 w-3.5" />
+                      <Code2 v-else class="h-3.5 w-3.5" />
+                    </span>
+                    <input
+                      v-if="editingTabId === tab.id"
+                      v-model="editingTitle"
+                      :data-tab-title-input="tab.id"
+                      :aria-label="t('contextMenu.renameTab')"
+                      class="h-5 min-w-0 flex-1 rounded border border-ring bg-background px-1.5 text-xs font-normal text-foreground outline-none"
+                      @click.stop
+                      @mousedown.stop
+                      @keydown.enter.prevent="commitRenameTab(tab)"
+                      @keydown.escape.prevent="cancelRenameTab"
+                      @blur="commitRenameTab(tab)"
+                    />
+                    <span v-else class="inline-flex min-w-0 flex-1 items-center gap-0.5 overflow-hidden text-foreground">
+                      <span v-if="isDirtyTab(tab)" aria-hidden="true" class="dirty-tab-marker">*</span>
+                      <span class="min-w-0 flex-1 truncate" :style="tabTitleStyle(tab)">{{ tabTitleText(tab) }}</span>
+                    </span>
+                    <Tooltip v-if="isConnectionReadonly(tab.connectionId)">
+                      <TooltipTrigger as-child>
+                        <Lock class="h-3 w-3 text-muted-foreground shrink-0" />
+                      </TooltipTrigger>
+                      <TooltipContent>{{ t("connection.readOnlyBadge") }}</TooltipContent>
+                    </Tooltip>
+                    <button class="rounded p-0.5 text-primary hover:bg-muted-foreground/20 shrink-0" :aria-label="t('contextMenu.unfixTab')" :title="t('contextMenu.unfixTab')" @click.stop="queryStore.togglePinnedTab(tab.id)">
+                      <Pin class="h-3 w-3 fill-current" aria-hidden="true" />
+                    </button>
+                    <button class="rounded hover:bg-muted-foreground/20 p-0.5 shrink-0" @click.stop="queryStore.closeTab(tab.id)">
+                      <X class="h-3 w-3" />
+                    </button>
+                  </div>
+                </TooltipTrigger>
+                <TooltipContent side="bottom" class="text-xs grid grid-cols-[auto_1fr] gap-x-2">
+                  <template v-for="line in tabTooltipLines(tab, t)" :key="line.label">
+                    <span class="text-muted-foreground">{{ line.label }}</span>
+                    <span>{{ line.value }}</span>
+                  </template>
+                </TooltipContent>
+              </Tooltip>
+            </div>
+          </CustomContextMenu>
+          <div :class="fixedTabTailDragRegionClass" data-tauri-drag-region />
+        </div>
+      </div>
+      <div v-if="showFixedTabScrollbar" class="relative z-30 flex shrink-0 items-center">
+        <Popover v-model:open="fixedTabOverflowOpen">
+          <PopoverTrigger as-child>
+            <button type="button" :class="['inline-flex shrink-0 items-center justify-center', tabOverflowControlClass].join(' ')" :aria-label="t('tabs.fixedTabs')" :title="t('tabs.fixedTabs')">
+              <ChevronDown class="h-4 w-4" />
+            </button>
+          </PopoverTrigger>
+          <PopoverContent align="end" class="w-auto min-w-56 max-w-80 max-h-[min(70vh,28rem)] gap-0 overflow-y-auto rounded-[6px] p-1" @click.stop @keydown.stop>
+            <CustomContextMenu v-for="tab in fixedTabs" :key="tab.id" :items="getTabMenuItems(tab)" v-slot="{ onContextMenu }">
+              <div
+                class="group flex w-full items-center gap-2 rounded-md px-1.5 py-1.5 text-left text-sm outline-hidden hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground"
+                :class="tab.id === queryStore.activeTabId && !driverStoreActive && !settingsPageActive ? 'bg-accent/70 text-accent-foreground' : ''"
+                :title="tabTitleLabel(tab)"
+                role="menuitem"
+                tabindex="0"
+                @click="activateTabFromOverflow(tab.id, 'fixed')"
+                @contextmenu="onContextMenu"
+                @keydown="onOverflowItemKeydown($event, tab.id, 'fixed')"
+              >
+                <DatabaseIcon v-if="tab.mode === 'mq'" :db-type="tabDatabaseIconType(tab)" class="h-3.5 w-3.5 shrink-0" />
+                <component :is="tabMenuIcon(tab)" v-else :class="['h-3.5 w-3.5 shrink-0', tabIconClass(tab)]" />
+                <span class="inline-flex min-w-0 flex-1 items-center gap-0.5 overflow-hidden">
+                  <span v-if="isDirtyTab(tab)" aria-hidden="true" class="dirty-tab-marker">*</span>
+                  <span class="min-w-0 flex-1 truncate" :style="tabTitleStyle(tab)">{{ tabTitleText(tab) }}</span>
+                </span>
+                <Lock v-if="isConnectionReadonly(tab.connectionId)" class="h-3 w-3 shrink-0 text-muted-foreground" />
+                <Pin class="h-3 w-3 shrink-0 fill-current text-primary" />
+                <span class="w-5 shrink-0">
+                  <button
+                    type="button"
+                    class="inline-flex rounded p-1 text-muted-foreground opacity-70 hover:bg-muted-foreground/20 hover:text-foreground group-hover:opacity-100"
+                    :aria-label="t('contextMenu.closeTab')"
+                    :title="t('contextMenu.closeTab')"
+                    @click="closeTabFromOverflow(tab.id, $event)"
+                    @mousedown.stop
+                  >
+                    <X class="h-3 w-3" />
+                  </button>
+                </span>
+              </div>
+            </CustomContextMenu>
+          </PopoverContent>
+        </Popover>
+      </div>
+    </div>
+  </div>
+
+  <Dialog
+    :open="queryStore.showCloseConfirm"
+    @update:open="
+      (open) => {
+        if (!open) queryStore.cancelClosePendingTab();
+      }
+    "
+  >
+    <DialogContent class="sm:max-w-md">
+      <DialogHeader>
+        <DialogTitle class="flex items-center gap-2">
+          <AlertTriangle class="h-5 w-5 text-amber-500" />
+          {{ t("editor.unsavedChangesTitle") }}
+        </DialogTitle>
+      </DialogHeader>
+      <div class="space-y-2">
+        <p class="text-sm text-muted-foreground">{{ closeConfirmMessage }}</p>
+        <Popover v-if="showCloseConfirmBulkActions" :open="closeConfirmListOpen" @update:open="closeConfirmListOpen = $event">
+          <PopoverTrigger as-child>
+            <button
+              type="button"
+              class="inline-flex items-center text-sm font-medium text-foreground underline-offset-4 hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2"
+              @mouseenter="openCloseConfirmList"
+              @mouseleave="scheduleCloseConfirmListClose"
+            >
+              {{ t("editor.unsavedChangesViewList", { count: closeConfirmDirtyCount }) }}
+            </button>
+          </PopoverTrigger>
+          <PopoverContent align="start" side="bottom" class="w-72 max-w-[calc(100vw-2rem)] gap-1 p-2" @mouseenter="openCloseConfirmList" @mouseleave="scheduleCloseConfirmListClose" @pointerdown.stop @click.stop @keydown.stop>
+            <div class="px-2 pb-1 text-xs font-medium text-muted-foreground">
+              {{ t("editor.unsavedChangesListTitle", { count: closeConfirmDirtyCount }) }}
+            </div>
+            <div class="max-h-48 overflow-y-auto">
+              <div v-for="tab in closeConfirmDirtyTabs" :key="tab.id" class="flex min-w-0 items-center gap-2 rounded-[6px] px-2 py-1.5 text-sm" :class="tab.id === queryStore.pendingCloseTabId ? 'bg-muted text-foreground' : 'text-muted-foreground'">
+                <span class="h-1.5 w-1.5 shrink-0 rounded-full" :class="tab.id === queryStore.pendingCloseTabId ? 'bg-foreground' : 'bg-muted-foreground/50'" />
+                <span class="min-w-0 truncate">{{ tabDisplayTitle(tab, t) }}</span>
+              </div>
+            </div>
+          </PopoverContent>
+        </Popover>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" @click="handleCancelClose">{{ t("common.cancel") }}</Button>
+        <Button v-if="showCloseConfirmBulkActions" variant="secondary" @click="handleDiscardAllAndClose">{{ t("editor.discardAllChanges") }}</Button>
+        <Button v-if="showCloseConfirmBulkActions" @click="handleSaveAllAndClose">{{ t("editor.saveAllChanges") }}</Button>
+        <Button variant="secondary" @click="handleDiscardAndClose">{{ t("editor.discardChanges") }}</Button>
+        <Button @click="handleSaveAndClose">{{ t("savedSql.save") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
+
+<style scoped>
+.dirty-tab-marker {
+  display: inline-flex;
+  width: 0.5rem;
+  height: 0.75rem;
+  flex-shrink: 0;
+  align-items: center;
+  justify-content: center;
+  color: currentColor;
+  font-size: 13px;
+  font-weight: 700;
+  line-height: 12px;
+  opacity: 0.9;
+  transform: translateY(2px);
+}
+
+.app-tab-scroll::-webkit-scrollbar {
+  display: none;
+}
+
+.app-tab-scrollbar {
+  position: absolute;
+  inset-inline: 0;
+  top: 0;
+  z-index: 20;
+  height: 6px;
+  cursor: pointer;
+  opacity: 0;
+  pointer-events: none;
+  touch-action: none;
+  transition: opacity 140ms ease;
+}
+
+.app-tab-strip:hover .app-tab-scrollbar,
+.app-tab-strip:focus-within .app-tab-scrollbar,
+.app-tab-scrollbar--dragging {
+  opacity: 1;
+  pointer-events: auto;
+}
+
+.app-tab-scrollbar::before {
+  content: "";
+  position: absolute;
+  inset-inline: 0;
+  top: 0;
+  height: 2px;
+  border-radius: 999px;
+  background: color-mix(in oklch, var(--foreground) 8%, transparent);
+}
+
+.app-tab-scrollbar--bottom {
+  top: auto;
+  bottom: 0;
+}
+
+.app-tab-scrollbar--bottom::before {
+  top: auto;
+  bottom: 0;
+}
+
+.app-tab-scrollbar__thumb {
+  position: absolute;
+  top: 0;
+  height: 2px;
+  min-width: 20px;
+  border-radius: 999px;
+  background: color-mix(in oklch, var(--foreground) 30%, transparent);
+  transition:
+    height 120ms ease,
+    background-color 120ms ease;
+}
+
+.app-tab-scrollbar--bottom .app-tab-scrollbar__thumb {
+  top: auto;
+  bottom: 0;
+}
+
+.app-tab-scrollbar:hover .app-tab-scrollbar__thumb,
+.app-tab-scrollbar--dragging .app-tab-scrollbar__thumb {
+  height: 5px;
+  background: color-mix(in oklch, var(--foreground) 52%, transparent);
+}
+</style>
diff --git a/apps/desktop/src/components/layout/AppToolbar.vue b/apps/desktop/src/components/layout/AppToolbar.vue
new file mode 100644
index 0000000..7569405
--- /dev/null
+++ b/apps/desktop/src/components/layout/AppToolbar.vue
@@ -0,0 +1,630 @@
+<script setup lang="ts">
+import { computed, ref, onMounted, onBeforeUnmount, h, nextTick, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { invoke } from "@tauri-apps/api/core";
+import { DatabaseZap, FilePlus2, Loader2, Moon, Sun, SunMoon, History, Bot, ArrowLeftRight, FileCode, BookMarked, GitCompareArrows, TableProperties, Settings, CloudDownload, Package, FileDown, FolderTree } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import LightDropdown from "@/components/ui/LightDropdown.vue";
+import WindowControls from "@/components/layout/WindowControls.vue";
+import ExportProgressPopover from "@/components/export/ExportProgressPopover.vue";
+import { MAC_TRAFFIC_LIGHT_X, macTrafficLightInsetPaddingForScale, shouldReserveMacTrafficLightInset, useWindowControls } from "@/composables/useWindowControls";
+import { useToast } from "@/composables/useToast";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { isSystemAppThemeMode, type AppThemeMode } from "@/lib/app/appTheme";
+
+const GithubIcon = {
+  render() {
+    return h("svg", { class: "h-4 w-4", viewBox: "0 0 24 24", fill: "currentColor" }, [
+      h("path", {
+        d: "M12 0C5.37 0 0 5.37 0 12c0 5.3 3.438 9.8 8.205 11.387.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61-.546-1.387-1.333-1.756-1.333-1.756-1.09-.745.083-.729.083-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 21.795 24 17.295 24 12 24 5.37 18.627 0 12 0z",
+      }),
+    ]);
+  },
+};
+
+const props = defineProps<{
+  isDark: boolean;
+  themeMode: AppThemeMode;
+  showAiPanel: boolean;
+  showHistory: boolean;
+  showSqlLibrary: boolean;
+  showSqlFilePanel: boolean;
+  showDriverStore: boolean;
+  showSettingsPage: boolean;
+  checkingUpdates: boolean;
+  hasUpdateAvailable: boolean;
+  agentDriverUpdateCount: number;
+  hasConnections: boolean;
+  hasSqlFileConnections: boolean;
+}>();
+
+const emit = defineEmits<{
+  "new-connection": [];
+  "new-query": [];
+  "set-theme-mode": [mode: AppThemeMode];
+  "toggle-ai": [];
+  "toggle-history": [];
+  "toggle-sql-library": [];
+  "toggle-sql-file-panel": [];
+  "open-github": [];
+  "open-settings": [];
+  "open-driver-store": [];
+  "check-updates": [];
+  "open-transfer": [];
+  "open-sql-file": [];
+  "open-schema-diff": [];
+  "open-data-compare": [];
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+const settingsStore = useSettingsStore();
+const toolbarItems = computed(() => settingsStore.editorSettings.toolbarItems);
+const { isMac, isDesktop, showControls, isMaximized, isFullscreen, minimize, toggleMaximize, close } = useWindowControls();
+const checkingUpdates = computed(() => props.checkingUpdates);
+
+const themeTriggerIcon = computed(() => {
+  if (isSystemAppThemeMode(props.themeMode)) return SunMoon;
+  return props.isDark ? Moon : Sun;
+});
+
+const themeCycle: AppThemeMode[] = ["light", "dark", "system"];
+
+function nextThemeMode(mode: AppThemeMode): AppThemeMode {
+  const index = themeCycle.indexOf(mode);
+  return themeCycle[(index + 1) % themeCycle.length] ?? themeCycle[0];
+}
+
+function themeModeLabel(mode: AppThemeMode): string {
+  if (mode === "light") return t("toolbar.themeLight");
+  if (mode === "dark") return t("toolbar.themeDark");
+  return t("toolbar.themeSystem");
+}
+
+function cycleThemeMode() {
+  const next = nextThemeMode(props.themeMode);
+  emit("set-theme-mode", next);
+  toast(`${t("toolbar.theme")}: ${themeModeLabel(next)}`, 1600);
+}
+
+function onToolbarDblClick(e: MouseEvent) {
+  if (isDesktop) return;
+  const target = e.target as HTMLElement;
+  if (target.closest("button, [role='button'], a")) return;
+  toggleMaximize();
+}
+
+const toolbarEl = ref<HTMLElement>();
+const newConnectionLabelEl = ref<HTMLElement>();
+const toolbarCollapsed = ref(false);
+const shouldReserveTrafficLightInset = computed(() => shouldReserveMacTrafficLightInset(isMac, isFullscreen.value, isDesktop));
+
+function checkToolbarWidth() {
+  const el = toolbarEl.value;
+  if (!el) return;
+  const screenWidth = window.visualViewport?.width ?? window.innerWidth;
+  const threshold = screenWidth / 2;
+  toolbarCollapsed.value = el.clientWidth < threshold;
+}
+
+// ──────────── Right-side overflow detection ────────────
+
+const rightWrapper = ref<HTMLElement>();
+const rightOverflowCount = ref(0);
+let toolbarLayoutRaf = 0;
+let trafficLightSyncRaf = 0;
+let settlingRightOverflow = false;
+let pendingRightOverflowSettle = false;
+const measuredTrafficLightInset = ref<number | null>(null);
+
+type MacosTrafficLightLayout = {
+  x: number;
+  y: number;
+  center_y: number;
+  previous_center_y: number;
+  reserved_inset: number;
+};
+
+/** Ordered list of right-side item keys that can overflow into "More".
+ *  Items earlier in the list overflow first when space shrinks. */
+const collapsibleRightItemDefs = computed(() => {
+  interface ItemDef {
+    key: string;
+    label: string;
+    icon: any;
+    action: () => void;
+    disabled: boolean;
+  }
+  const items: ItemDef[] = [];
+  if (toolbarItems.value.checkUpdates) {
+    items.push({
+      key: "checkUpdates",
+      label: t("updates.check"),
+      icon: CloudDownload,
+      action: () => emit("check-updates"),
+      disabled: checkingUpdates.value,
+    });
+  }
+  items.push({
+    key: "exportProgress",
+    label: t("exportProgress.tooltip"),
+    icon: FileDown,
+    action: () => {},
+    disabled: false,
+  });
+  if (toolbarItems.value.sqlLibrary) {
+    items.push({
+      key: "sqlLibrary",
+      label: t("sqlLibrary.title"),
+      icon: BookMarked,
+      action: () => emit("toggle-sql-library"),
+      disabled: false,
+    });
+  }
+  if (toolbarItems.value.sqlFileTree) {
+    items.push({
+      key: "sqlFileTree",
+      label: t("sqlFileTree.title"),
+      icon: FolderTree,
+      action: () => emit("toggle-sql-file-panel"),
+      disabled: false,
+    });
+  }
+  if (toolbarItems.value.history) {
+    items.push({
+      key: "history",
+      label: t("history.title"),
+      icon: History,
+      action: () => emit("toggle-history"),
+      disabled: false,
+    });
+  }
+  if (toolbarItems.value.ai) {
+    items.push({
+      key: "ai",
+      label: "AI",
+      icon: Bot,
+      action: () => emit("toggle-ai"),
+      disabled: false,
+    });
+  }
+  if (toolbarItems.value.theme) {
+    items.push({
+      key: "theme",
+      label: t("toolbar.theme"),
+      icon: themeTriggerIcon.value,
+      action: cycleThemeMode,
+      disabled: false,
+    });
+  }
+  if (toolbarItems.value.github) {
+    items.push({
+      key: "github",
+      label: "GitHub",
+      icon: GithubIcon,
+      action: () => emit("open-github"),
+      disabled: false,
+    });
+  }
+  return items;
+});
+
+const overflowedRightKeys = computed(() => {
+  const defs = collapsibleRightItemDefs.value;
+  const overflowKeys = defs.slice(0, rightOverflowCount.value).map((d) => d.key);
+  return new Set(overflowKeys);
+});
+
+/** Overflowed right items to show in the "More" dropdown. */
+const overflowRightMenuItems = computed(() => {
+  const defs = collapsibleRightItemDefs.value;
+  return defs.slice(0, rightOverflowCount.value).map((d) => ({
+    value: d.key,
+    label: d.label,
+    icon: d.icon,
+    action: d.action,
+    disabled: d.disabled,
+  }));
+});
+
+async function settleRightOverflowOnce() {
+  const wrapper = rightWrapper.value;
+  if (!wrapper) return;
+
+  const defsLength = collapsibleRightItemDefs.value.length;
+  if (rightOverflowCount.value > defsLength) {
+    rightOverflowCount.value = defsLength;
+    await nextTick();
+  }
+
+  for (let i = 0; i <= defsLength + 1; i++) {
+    const current = rightWrapper.value;
+    if (!current) return;
+
+    if (current.scrollWidth > current.clientWidth + 1 && rightOverflowCount.value < defsLength) {
+      rightOverflowCount.value++;
+      await nextTick();
+      continue;
+    }
+
+    if (rightOverflowCount.value <= 0) return;
+
+    rightOverflowCount.value--;
+    await nextTick();
+
+    const restored = rightWrapper.value;
+    if (restored && restored.scrollWidth <= restored.clientWidth + 1) {
+      continue;
+    }
+
+    rightOverflowCount.value++;
+    await nextTick();
+    return;
+  }
+}
+
+async function settleRightOverflow() {
+  if (settlingRightOverflow) {
+    pendingRightOverflowSettle = true;
+    return;
+  }
+
+  settlingRightOverflow = true;
+  try {
+    do {
+      pendingRightOverflowSettle = false;
+      await nextTick();
+      await settleRightOverflowOnce();
+    } while (pendingRightOverflowSettle);
+  } finally {
+    settlingRightOverflow = false;
+  }
+}
+
+function scheduleToolbarLayout() {
+  if (toolbarLayoutRaf) cancelAnimationFrame(toolbarLayoutRaf);
+  toolbarLayoutRaf = requestAnimationFrame(() => {
+    toolbarLayoutRaf = 0;
+    checkToolbarWidth();
+    scheduleTrafficLightSync();
+    void settleRightOverflow();
+  });
+}
+
+function scheduleTrafficLightSync() {
+  if (!shouldReserveTrafficLightInset.value) return;
+  if (trafficLightSyncRaf) cancelAnimationFrame(trafficLightSyncRaf);
+  trafficLightSyncRaf = requestAnimationFrame(() => {
+    trafficLightSyncRaf = 0;
+    void syncTrafficLightsToToolbar();
+  });
+}
+
+async function syncTrafficLightsToToolbar() {
+  if (!shouldReserveTrafficLightInset.value) return;
+  const toolbarRect = toolbarEl.value?.getBoundingClientRect();
+  const targetEl = newConnectionLabelEl.value;
+  const targetRect = targetEl?.getBoundingClientRect();
+  if (!toolbarRect || !targetRect) return;
+  const targetCenterY = targetRect.top - toolbarRect.top + targetRect.height / 2;
+  try {
+    const layout = await invoke<MacosTrafficLightLayout>("set_macos_traffic_light_position", {
+      x: MAC_TRAFFIC_LIGHT_X,
+      y: targetCenterY,
+      scale: settingsStore.editorSettings.uiScale,
+    });
+    measuredTrafficLightInset.value = Math.ceil(layout.reserved_inset / settingsStore.editorSettings.uiScale);
+  } catch (error) {
+    console.warn("[DBX] Failed to sync macOS traffic light position", { targetCenterY, error });
+  }
+}
+
+function handleWindowResize() {
+  scheduleToolbarLayout();
+}
+
+watch(collapsibleRightItemDefs, () => scheduleToolbarLayout(), { flush: "post" });
+watch(
+  () => settingsStore.editorSettings.uiScale,
+  () => {
+    measuredTrafficLightInset.value = null;
+    scheduleToolbarLayout();
+    window.setTimeout(scheduleTrafficLightSync, 120);
+  },
+);
+watch(shouldReserveTrafficLightInset, () => scheduleToolbarLayout());
+
+// ──────────── Resize observer ────────────
+
+let resizeObserver: ResizeObserver | null = null;
+
+onMounted(() => {
+  resizeObserver = new ResizeObserver(scheduleToolbarLayout);
+  if (toolbarEl.value) resizeObserver.observe(toolbarEl.value);
+  if (rightWrapper.value) resizeObserver.observe(rightWrapper.value);
+  window.addEventListener("resize", handleWindowResize);
+  scheduleToolbarLayout();
+});
+
+onBeforeUnmount(() => {
+  if (toolbarLayoutRaf) cancelAnimationFrame(toolbarLayoutRaf);
+  if (trafficLightSyncRaf) cancelAnimationFrame(trafficLightSyncRaf);
+  resizeObserver?.disconnect();
+  window.removeEventListener("resize", handleWindowResize);
+});
+
+// ──────────── Left-side "More" items ────────────
+
+const moreItems = computed(() => {
+  const items: Array<{ value: string; label: string; icon: any; action: () => void; disabled: boolean }> = [];
+
+  // Hidden left-side items go into "More"
+  if (!toolbarItems.value.dataTransfer) {
+    items.push({
+      value: "transfer",
+      label: t("transfer.dataTransfer"),
+      icon: ArrowLeftRight,
+      action: () => emit("open-transfer"),
+      disabled: !props.hasConnections,
+    });
+  }
+  if (!toolbarItems.value.driverManager) {
+    items.push({
+      value: "driver-store",
+      label: t("toolbar.driverManager"),
+      icon: Package,
+      action: () => emit("open-driver-store"),
+      disabled: false,
+    });
+  }
+
+  // "More" menu items (individually toggleable)
+  if (toolbarItems.value.sqlFile) {
+    items.push({
+      value: "sql-file",
+      label: t("sqlFile.title"),
+      icon: FileCode,
+      action: () => emit("open-sql-file"),
+      disabled: !props.hasSqlFileConnections,
+    });
+  }
+  if (toolbarItems.value.schemaDiff) {
+    items.push({
+      value: "schema-diff",
+      label: t("diff.title"),
+      icon: GitCompareArrows,
+      action: () => emit("open-schema-diff"),
+      disabled: !props.hasConnections,
+    });
+  }
+  if (toolbarItems.value.dataCompare) {
+    items.push({
+      value: "data-compare",
+      label: t("dataCompare.title"),
+      icon: TableProperties,
+      action: () => emit("open-data-compare"),
+      disabled: !props.hasConnections,
+    });
+  }
+
+  // Append overflowed right-side items at the end
+  for (const ri of overflowRightMenuItems.value) {
+    items.push({
+      value: `right-${ri.value}`,
+      label: ri.label,
+      icon: ri.icon,
+      action: ri.action,
+      disabled: ri.disabled,
+    });
+  }
+
+  return items;
+});
+
+const showMoreDropdown = computed(() => moreItems.value.length > 0);
+
+const collapsedItems = computed(() => {
+  const items: Array<{ value: string; label: string; icon: any; action: () => void; disabled: boolean }> = [];
+  if (toolbarItems.value.dataTransfer) {
+    items.push({
+      value: "transfer",
+      label: t("transfer.dataTransfer"),
+      icon: ArrowLeftRight,
+      action: () => emit("open-transfer"),
+      disabled: !props.hasConnections,
+    });
+  }
+  if (toolbarItems.value.driverManager) {
+    items.push({
+      value: "driver-store",
+      label: props.agentDriverUpdateCount > 0 ? `${t("toolbar.driverManager")} (${props.agentDriverUpdateCount})` : t("toolbar.driverManager"),
+      icon: Package,
+      action: () => emit("open-driver-store"),
+      disabled: false,
+    });
+  }
+  // Always include moreItems (may contain hidden left-side items + overflowed right items)
+  if (moreItems.value.length > 0) {
+    items.push(...moreItems.value);
+  }
+  return items;
+});
+
+function runMoreItem(value: string) {
+  const item = moreItems.value.find((i) => i.value === value);
+  item?.action();
+}
+
+function runCollapsedItem(value: string) {
+  const item = collapsedItems.value.find((i) => i.value === value);
+  item?.action();
+}
+
+// Per-item overflow visibility helper
+function isRightItemVisible(key: string) {
+  return !overflowedRightKeys.value.has(key);
+}
+
+const toolbarTextButtonClass = "h-8 px-2 text-xs gap-1 leading-none";
+const toolbarTextLabelClass = "inline-flex translate-y-px items-center leading-none";
+const toolbarDropdownTriggerClass = `inline-flex h-8 items-center gap-1 rounded-[6px] px-2 text-xs font-medium leading-none hover:bg-muted hover:text-foreground dark:hover:bg-muted/50 transition-colors [&>span:first-child]:translate-y-px`;
+const toolbarStyle = computed(() => {
+  if (!shouldReserveTrafficLightInset.value) return undefined;
+  return {
+    paddingLeft: `${measuredTrafficLightInset.value ?? parseInt(macTrafficLightInsetPaddingForScale(settingsStore.editorSettings.uiScale), 10)}px`,
+  };
+});
+</script>
+
+<template>
+  <div ref="toolbarEl" class="app-toolbar h-10 flex items-center gap-1 px-2 border-b bg-muted/30 shrink-0 overflow-hidden" :style="toolbarStyle" data-tauri-drag-region @dblclick="onToolbarDblClick">
+    <Button variant="ghost" size="sm" :class="toolbarTextButtonClass" @click="emit('new-connection')">
+      <span class="inline-flex items-center gap-1">
+        <DatabaseZap class="h-3.5 w-3.5" />
+        <span ref="newConnectionLabelEl" :class="toolbarTextLabelClass">{{ t("toolbar.newConnection") }}</span>
+      </span>
+    </Button>
+
+    <Button variant="ghost" size="sm" :class="toolbarTextButtonClass" @click="emit('new-query')" :disabled="!hasConnections">
+      <FilePlus2 class="h-3.5 w-3.5" />
+      <span :class="toolbarTextLabelClass">{{ t("toolbar.newQuery") }}</span>
+    </Button>
+
+    <template v-if="!toolbarCollapsed">
+      <Button v-if="toolbarItems.dataTransfer" variant="ghost" size="sm" :class="toolbarTextButtonClass" @click="emit('open-transfer')" :disabled="!hasConnections">
+        <ArrowLeftRight class="h-3.5 w-3.5" />
+        <span :class="toolbarTextLabelClass">{{ t("transfer.dataTransfer") }}</span>
+      </Button>
+
+      <Button v-if="toolbarItems.driverManager" variant="ghost" size="sm" :class="[toolbarTextButtonClass, { 'bg-accent': showDriverStore }]" @click="emit('open-driver-store')">
+        <Package class="h-3.5 w-3.5" />
+        <span :class="toolbarTextLabelClass">{{ t("toolbar.driverManager") }}</span>
+        <!-- 小圆点仅提示"有可更新驱动"，具体数量交给对话框内标签页红点展示，避免工具栏长期挂红数字。 -->
+        <span v-if="agentDriverUpdateCount > 0" class="ml-0.5 inline-block h-2 w-2 rounded-full bg-red-500" :aria-label="t('toolbar.updatableDriverCount')" :title="t('toolbar.updatableDriverCount')" />
+      </Button>
+
+      <LightDropdown
+        v-if="showMoreDropdown"
+        model-value=""
+        :items="moreItems"
+        :aria-label="t('common.more')"
+        :trigger-label="t('common.more')"
+        :trigger-class="toolbarDropdownTriggerClass"
+        :show-trigger-label="true"
+        :show-chevron="true"
+        check-position="none"
+        align="start"
+        @update:model-value="runMoreItem"
+      />
+    </template>
+
+    <template v-if="toolbarCollapsed">
+      <LightDropdown
+        v-if="collapsedItems.length > 0"
+        model-value=""
+        :items="collapsedItems"
+        :aria-label="t('common.more')"
+        :trigger-label="t('common.more')"
+        :trigger-class="toolbarDropdownTriggerClass"
+        :show-trigger-label="true"
+        :show-chevron="true"
+        check-position="none"
+        align="start"
+        @update:model-value="runCollapsedItem"
+      />
+    </template>
+
+    <div class="flex-1" data-tauri-drag-region />
+
+    <!-- Right-side items wrapped in overflow-aware container -->
+    <div ref="rightWrapper" class="flex min-w-0 items-center gap-1 overflow-hidden">
+      <template v-if="toolbarItems.checkUpdates">
+        <Tooltip>
+          <TooltipTrigger as-child>
+            <Button v-show="isRightItemVisible('checkUpdates')" variant="ghost" size="icon" class="relative h-8 w-8 shrink-0" :disabled="checkingUpdates" @click="emit('check-updates')">
+              <Loader2 v-if="checkingUpdates" class="h-4 w-4 animate-spin" />
+              <CloudDownload v-else class="h-4 w-4" />
+              <span v-if="hasUpdateAvailable" class="absolute right-1.5 top-1.5 h-2 w-2 rounded-full bg-red-500 ring-2 ring-background" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>{{ t("updates.check") }}</TooltipContent>
+        </Tooltip>
+      </template>
+
+      <div v-show="isRightItemVisible('exportProgress')" class="contents">
+        <ExportProgressPopover />
+      </div>
+
+      <Tooltip v-if="toolbarItems.sqlLibrary">
+        <TooltipTrigger as-child>
+          <Button v-show="isRightItemVisible('sqlLibrary')" variant="ghost" size="icon" class="h-8 w-8 shrink-0" :class="{ 'bg-accent': showSqlLibrary }" @click="emit('toggle-sql-library')">
+            <BookMarked class="h-4 w-4" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("sqlLibrary.title") }}</TooltipContent>
+      </Tooltip>
+
+      <Tooltip v-if="toolbarItems.sqlFileTree">
+        <TooltipTrigger as-child>
+          <Button v-show="isRightItemVisible('sqlFileTree')" variant="ghost" size="icon" class="h-8 w-8 shrink-0" :class="{ 'bg-accent': showSqlFilePanel }" @click="emit('toggle-sql-file-panel')">
+            <FolderTree class="h-4 w-4" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("sqlFileTree.title") }}</TooltipContent>
+      </Tooltip>
+
+      <Tooltip v-if="toolbarItems.history">
+        <TooltipTrigger as-child>
+          <Button v-show="isRightItemVisible('history')" variant="ghost" size="icon" class="h-8 w-8 shrink-0" :class="{ 'bg-accent': showHistory }" @click="emit('toggle-history')">
+            <History class="h-4 w-4" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("history.title") }}</TooltipContent>
+      </Tooltip>
+
+      <Tooltip v-if="toolbarItems.ai">
+        <TooltipTrigger as-child>
+          <Button v-show="isRightItemVisible('ai')" variant="ghost" size="icon" class="h-8 w-8 shrink-0" :class="{ 'bg-accent': showAiPanel }" @click="emit('toggle-ai')">
+            <Bot class="h-4 w-4" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>AI</TooltipContent>
+      </Tooltip>
+
+      <Tooltip v-if="toolbarItems.theme">
+        <TooltipTrigger as-child>
+          <Button v-show="isRightItemVisible('theme')" variant="ghost" size="icon" class="h-8 w-8 shrink-0" :aria-label="t('toolbar.theme')" @click="cycleThemeMode">
+            <component :is="themeTriggerIcon" class="h-4 w-4" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("toolbar.theme") }}</TooltipContent>
+      </Tooltip>
+
+      <Tooltip v-if="toolbarItems.github">
+        <TooltipTrigger as-child>
+          <Button v-show="isRightItemVisible('github')" variant="ghost" size="icon" class="h-8 w-8 shrink-0" @click="emit('open-github')">
+            <svg class="h-4 w-4" viewBox="0 0 24 24" fill="currentColor">
+              <path
+                d="M12 0C5.37 0 0 5.37 0 12c0 5.3 3.438 9.8 8.205 11.387.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61-.546-1.387-1.333-1.756-1.333-1.756-1.09-.745.083-.729.083-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 21.795 24 17.295 24 12 24 5.37 18.627 0 12 0z"
+              />
+            </svg>
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>GitHub</TooltipContent>
+      </Tooltip>
+    </div>
+    <!-- /rightWrapper -->
+
+    <Tooltip>
+      <TooltipTrigger as-child>
+        <Button variant="ghost" size="icon" class="h-8 w-8 shrink-0" :class="{ 'bg-accent': showSettingsPage }" @click="emit('open-settings')">
+          <Settings class="h-4 w-4" />
+        </Button>
+      </TooltipTrigger>
+      <TooltipContent>{{ t("settings.title") }}</TooltipContent>
+    </Tooltip>
+
+    <WindowControls v-if="showControls" :is-maximized="isMaximized" @minimize="minimize" @toggle-maximize="toggleMaximize" @close="close" />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/layout/CloseActionPromptDialog.vue b/apps/desktop/src/components/layout/CloseActionPromptDialog.vue
new file mode 100644
index 0000000..958c46a
--- /dev/null
+++ b/apps/desktop/src/components/layout/CloseActionPromptDialog.vue
@@ -0,0 +1,33 @@
+<script setup lang="ts">
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+
+const open = defineModel<boolean>("open", { required: true });
+
+const emit = defineEmits<{
+  quit: [];
+  minimize: [];
+}>();
+
+const { t } = useI18n();
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent class="sm:max-w-[440px]" @interact-outside.prevent @escape-key-down.prevent>
+      <DialogHeader>
+        <DialogTitle>{{ t("settings.closeActionPromptTitle") }}</DialogTitle>
+        <DialogDescription>{{ t("settings.closeActionPromptDescription") }}</DialogDescription>
+      </DialogHeader>
+      <DialogFooter class="gap-2 sm:gap-2">
+        <Button type="button" variant="outline" @click="emit('minimize')">
+          {{ t("settings.closeActionMinimize") }}
+        </Button>
+        <Button type="button" @click="emit('quit')">
+          {{ t("settings.closeActionQuit") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/layout/ContentArea.vue b/apps/desktop/src/components/layout/ContentArea.vue
new file mode 100644
index 0000000..972ddc2
--- /dev/null
+++ b/apps/desktop/src/components/layout/ContentArea.vue
@@ -0,0 +1,1670 @@
+<script setup lang="ts">
+import { computed, ref, defineAsyncComponent, watch, nextTick, onMounted, onUnmounted } from "vue";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+import { appendDebugLog, isDebugLoggingEnabled } from "@/lib/backend/debugLog";
+import { canReloadUnavailableDataTab } from "@/lib/table/tableDataRefresh";
+import type { CSSProperties } from "vue";
+import { useI18n } from "vue-i18n";
+import { Check, Columns3, Columns3Cog, EyeOff, Loader2, Search, TableProperties, ChevronDown, ChevronUp, Inbox, RefreshCcw, Wrench, Toolbox, Database, Download, Upload, X, Pin, Rows3, SquareDashed, Minus, Plus, ShieldAlert } from "@lucide/vue";
+import { Splitpanes, Pane } from "splitpanes";
+import "splitpanes/dist/splitpanes.css";
+import { Button } from "@/components/ui/button";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, DropdownMenuPortal } from "@/components/ui/dropdown-menu";
+import { Switch } from "@/components/ui/switch";
+import LightTooltip from "@/components/ui/LightTooltip.vue";
+import QueryEditor from "@/components/editor/QueryEditor.vue";
+import ColumnInfoPanel from "@/components/editor/ColumnInfoPanel.vue";
+import QueryLoadingState from "@/components/common/QueryLoadingState.vue";
+import QueryErrorActions from "@/components/common/QueryErrorActions.vue";
+import QueryResultToolbarActions from "@/components/layout/QueryResultToolbarActions.vue";
+import QueryResultViewSwitcher from "@/components/layout/QueryResultViewSwitcher.vue";
+import type { ColumnInfo } from "@/components/editor/ColumnInfoPanel.vue";
+let dataGridComponentPromise: Promise<typeof import("@/components/grid/DataGrid.vue")> | undefined;
+function loadDataGridComponent() {
+  if (!dataGridComponentPromise) {
+    dataGridComponentPromise = (async () => {
+      const shouldLogTiming = isDebugLoggingEnabled();
+      const startedAt = shouldLogTiming ? performance.now() : 0;
+      if (shouldLogTiming) appendDebugLog("info", "[DBX][DataGrid:load:start]");
+      const component = await import("@/components/grid/DataGrid.vue");
+      if (shouldLogTiming) appendDebugLog("info", "[DBX][DataGrid:load:done]", { elapsed: `${Math.round(performance.now() - startedAt)}ms` });
+      return component;
+    })();
+  }
+  return dataGridComponentPromise;
+}
+
+function preloadDataGridComponent() {
+  void loadDataGridComponent();
+}
+
+const DataGrid = defineAsyncComponent(loadDataGridComponent);
+const RedisKeyBrowser = defineAsyncComponent(() => import("@/components/redis/RedisKeyBrowser.vue"));
+const RedisDashboard = defineAsyncComponent(() => import("@/components/redis/RedisDashboard.vue"));
+const EtcdKeyBrowser = defineAsyncComponent(() => import("@/components/etcd/EtcdKeyBrowser.vue"));
+const ZooKeeperKeyBrowser = defineAsyncComponent(() => import("@/components/zookeeper/ZooKeeperKeyBrowser.vue"));
+const DocumentBrowser = defineAsyncComponent(() => import("@/components/document/DocumentBrowser.vue"));
+const MongoGridFsBrowser = defineAsyncComponent(() => import("@/components/document/MongoGridFsBrowser.vue"));
+const MongoBucketBrowser = defineAsyncComponent(() => import("@/components/document/MongoBucketBrowser.vue"));
+const VectorBrowser = defineAsyncComponent(() => import("@/components/vector/VectorBrowser.vue"));
+const ElasticsearchJsonResponsePanel = defineAsyncComponent(() => import("@/components/common/ElasticsearchJsonResponsePanel.vue"));
+const MqAdminConsole = defineAsyncComponent(() => import("@/components/mq/MqAdminConsole.vue"));
+const NacosAdminConsole = defineAsyncComponent(() => import("@/components/nacos/NacosAdminConsole.vue"));
+const ObjectBrowser = defineAsyncComponent(() => import("@/components/objects/ObjectBrowser.vue"));
+const TableStructureEditor = defineAsyncComponent(() => import("@/components/structure/TableStructureEditor.vue"));
+const DatabaseUserAdmin = defineAsyncComponent(() => import("@/components/admin/DatabaseUserAdmin.vue"));
+const DamengJobAdmin = defineAsyncComponent(() => import("@/components/admin/DamengJobAdmin.vue"));
+const ExplainPlanViewer = defineAsyncComponent(() => import("@/components/explain/ExplainPlanViewer.vue"));
+const QueryChart = defineAsyncComponent(() => import("@/components/chart/QueryChart.vue"));
+import { useQueryStore } from "@/stores/queryStore";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { TABLE_FONT_SIZE_MAX, TABLE_FONT_SIZE_MIN, useSettingsStore, type DataGridSearchMode } from "@/stores/settingsStore";
+import { useToast } from "@/composables/useToast";
+import { canCancelQueryExecution, queryExecutionLabelKey } from "@/lib/sql/queryExecutionState";
+import { databaseDisplayNameForTab, executionSummaryItems, resultGridCacheKey, resultRunItems, resultSqlForGrid, tabularResultItems } from "@/lib/tabs/tabPresentation";
+import { defaultQueryResultArchiveFileName } from "@/lib/query/queryResultArchive";
+import { saveQueryResultArchiveFile } from "@/lib/query/queryResultArchiveFile";
+import { isTableDataEditable } from "@/lib/table/tableEditing";
+import { tableMetaForDataTab } from "@/lib/table/tableDataTabMeta";
+import { dataTabExecutionDatabase } from "@/lib/table/dataTabExecutionDatabase";
+import { formatShortcut } from "@/lib/editor/shortcutRegistry";
+import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import { chartableColumnIndexes } from "@/lib/dataGrid/chartData";
+import { elasticsearchJsonResponseForResult } from "@/lib/elasticsearch/elasticsearchJsonResponse";
+import * as api from "@/lib/backend/api";
+import { applyMongoGridChangesToDocument, buildMongoUpdateDocument, formatMongoShellLiteral, type MongoInputValue } from "@/lib/mongo/mongoDocumentValues";
+import type { SqlExecutionOverride } from "@/lib/sql/sqlExecutionTarget";
+import type { DataGridSortMode } from "@/lib/dataGrid/dataGridSort";
+import { DATA_GRID_COMPACT_TOPBAR_WIDTH, type DataGridReloadIntent } from "@/lib/dataGrid/dataGridToolbar";
+import { useTabScroll } from "@/composables/useTabScroll";
+import { formatElapsedSeconds } from "@/lib/common/elapsedTime";
+import type { CustomSaveHandler } from "@/composables/useDataGridEditor";
+import type { QueryTab, ConnectionConfig, TableInfoTab, TreeNode, VectorCollectionMeta, ObjectBrowserViewport } from "@/types/database";
+import { sqlFormatDialectForDbType, type SqlFormatDialect } from "@/lib/sql/sqlFormatter";
+import { productionContextForDatabase } from "@/lib/database/productionSafety";
+
+type DataGridHandle = {
+  onToolbarRefresh: () => Promise<void> | void;
+  focusSearch: () => boolean;
+  openCellDetailSearch: () => boolean;
+  visibleColumnCount: number;
+  displayableColumnCount: number;
+  hiddenColumnCount: number;
+  filteredColumnVisibilityOptions: (search: string) => Array<{ index: number; column: string; comment?: string }>;
+  isColumnVisible: (columnIndex: number) => boolean;
+  toggleColumnVisibility: (columnIndex: number) => void;
+  showAllColumns: () => void;
+  invertColumnVisibility: () => void;
+  hasCustomColumnOrder: boolean;
+  resetColumnOrder: () => void;
+  nullColumnsHidden: boolean;
+  allNullColumnCount: number;
+  canToggleAllNullColumns: boolean;
+  toggleAllNullColumns: () => void;
+  showDdl: boolean;
+  toggleDdl: (tab?: TableInfoTab) => void;
+  multiRowTranspose: boolean;
+  setMultiRowTranspose: (value: boolean) => void;
+  exportCsv: () => Promise<void>;
+  exportJson: () => Promise<void>;
+  exportSql: () => Promise<void>;
+  exportXlsx: () => Promise<void>;
+};
+
+type SearchableBrowserHandle = {
+  focusSearch: () => boolean;
+  refresh?: () => boolean;
+};
+
+const props = defineProps<{
+  activeTab: QueryTab;
+  activeConnection?: ConnectionConfig;
+  executableSql: string;
+  activeOutputView: "result" | "summary" | "explain" | "chart";
+  formatSqlRequest: { id: number; tabId: string } | null;
+  selectedSql: string;
+  cursorPos: number;
+  blockDangerousRedisCommands: boolean;
+}>();
+
+const emit = defineEmits<{
+  "update:activeOutputView": [value: "result" | "summary" | "explain" | "chart"];
+  fixWithAi: [errorMessage: string];
+  sendSelectionToAi: [sql: string];
+  execute: [sqlOverride?: SqlExecutionOverride];
+  saveSql: [];
+  cancel: [];
+  explain: [];
+  editorUpdate: [tabId: string, value: string];
+  editorSelectionChange: [value: string];
+  editorCursorChange: [pos: number];
+  editorViewportChange: [tabId: string, viewport: { scrollTop: number; scrollLeft: number }];
+  editorSelectionStateChange: [tabId: string, selection: { anchor: number; head: number }];
+  formatError: [];
+  reload: [sql?: string, searchText?: string, whereInput?: string, orderBy?: string, limit?: number, offset?: number, intent?: DataGridReloadIntent];
+  paginate: [offset: number, limit: number, whereInput?: string, orderBy?: string];
+  sort: [column: string, columnIndex: number, direction: "asc" | "desc" | null, whereInput?: string, mode?: DataGridSortMode];
+  executeSql: [sql: string];
+  clickTable: [tableName: string];
+  viewTableData: [tableName: string];
+  viewTableDdl: [tableName: string];
+  editTableStructure: [tableName: string];
+  openObjectTable: [target: { tableName: string; schema?: string; tableType?: string; catalog?: string }];
+  objectSchemaChange: [schema: string | undefined];
+  objectBrowserViewportChange: [tabId: string, viewport: ObjectBrowserViewport];
+  structureEditorSaved: [commentChanged: boolean];
+  structureEditorClose: [];
+  openSettings: [initialTab?: string, initialSection?: string];
+  openConnectionSettings: [connectionId: string, initialTab: "advanced"];
+}>();
+
+const { t, locale } = useI18n();
+const queryStore = useQueryStore();
+const connectionStore = useConnectionStore();
+const settingsStore = useSettingsStore();
+const { toast } = useToast();
+const DEFAULT_QUERY_RESULTS_PANE_SIZE = 68;
+
+onMounted(() => {
+  const preload = () => preloadDataGridComponent();
+  if ("requestIdleCallback" in window) {
+    window.requestIdleCallback(preload, { timeout: 1500 });
+  } else {
+    setTimeout(preload, 300);
+  }
+  window.addEventListener("dbx-refresh-active-kv-browser", onRefreshActiveKvBrowser);
+});
+
+watch(
+  () => [props.activeTab.mode, !!props.activeTab.result] as const,
+  ([mode, hasResult]) => {
+    if (mode === "data" || hasResult) preloadDataGridComponent();
+  },
+  { immediate: true },
+);
+
+// Column info panel state
+const showColumnInfo = ref(false);
+const columnInfoColumns = ref<ColumnInfo[]>([]);
+const columnInfoLoading = ref(false);
+const columnInfoError = ref<string | undefined>(undefined);
+const dataGridRef = ref<DataGridHandle>();
+const queryEditorRef = ref<InstanceType<typeof QueryEditor>>();
+const standaloneResultToolbarRef = ref<HTMLElement | null>(null);
+const standaloneResultToolbarWidth = ref(0);
+const resultTabsScrollerRef = ref<HTMLElement | null>(null);
+const columnVisibilitySearch = ref("");
+const columnVisibilityOptions = computed(() => dataGridRef.value?.filteredColumnVisibilityOptions(columnVisibilitySearch.value) ?? []);
+const dataGridRenderMode = computed(() => settingsStore.editorSettings.dataGridRenderMode);
+const dataGridSearchMode = computed(() => settingsStore.editorSettings.dataGridSearchMode);
+const columnWidthDensity = computed(() => settingsStore.editorSettings.columnWidthDensity);
+const tableFontSize = computed(() => settingsStore.editorSettings.tableFontSize);
+const redisKeyBrowserRef = ref<SearchableBrowserHandle>();
+
+const etcdKeyBrowserRef = ref<SearchableBrowserHandle>();
+const zookeeperKeyBrowserRef = ref<SearchableBrowserHandle>();
+const objectBrowserRef = ref<SearchableBrowserHandle>();
+const activeTableMeta = computed(() => props.activeTab.tableMeta);
+const activeDataTabTableMeta = computed(() => tableMetaForDataTab(props.activeTab));
+const activeEffectiveDatabaseType = computed(() => effectiveDatabaseTypeForConnection(props.activeConnection));
+const activeDataTabExecutionDatabase = computed(() => dataTabExecutionDatabase(props.activeConnection, props.activeTab.database, activeDataTabTableMeta.value?.catalog));
+const activeProductionContext = computed(() => productionContextForDatabase(props.activeConnection, props.activeTab.database));
+const productionWatermarkText = computed(() => (locale.value.startsWith("zh") ? "生产环境" : "PROD"));
+const productionSessionDetail = computed(() => {
+  if (!activeProductionContext.value.active) return "";
+  if (activeProductionContext.value.reason === "connection") return t("production.connection");
+  return activeProductionContext.value.databases.join(", ") || t("production.databases");
+});
+
+function findNodeInTree(nodes: TreeNode[], id: string): TreeNode | undefined {
+  for (const node of nodes) {
+    if (node.id === id) return node;
+    if (node.children) {
+      const found = findNodeInTree(node.children, id);
+      if (found) return found;
+    }
+  }
+  return undefined;
+}
+
+function setDataGridRenderMode(value: "canvas" | "dom") {
+  settingsStore.updateEditorSettings({ dataGridRenderMode: value });
+}
+
+function setDataGridSearchMode(value: DataGridSearchMode) {
+  settingsStore.updateEditorSettings({ dataGridSearchMode: value });
+}
+
+function setColumnWidthDensity(value: "compact" | "standard" | "comfortable") {
+  settingsStore.updateEditorSettings({ columnWidthDensity: value });
+}
+
+function setTableFontSize(value: number) {
+  settingsStore.updateEditorSettings({ tableFontSize: value });
+}
+
+function decreaseTableFontSize() {
+  setTableFontSize(tableFontSize.value - 1);
+}
+
+function increaseTableFontSize() {
+  setTableFontSize(tableFontSize.value + 1);
+}
+
+const activeTabDimension = computed(() => {
+  const tab = props.activeTab;
+  if (!tab.connectionId || tab.mode !== "vector") return undefined;
+  const isMilvus = connectionStore.getConfig(tab.connectionId)?.db_type === "milvus";
+  const suffix = isMilvus && tab.database ? `${tab.database}:${tab.sql}` : tab.sql;
+  const nodeId = `${tab.connectionId}:__vector_collection:${suffix}`;
+  const meta = findNodeInTree(connectionStore.treeNodes, nodeId)?.meta;
+  return meta && "dimension" in meta ? (meta as VectorCollectionMeta).dimension : undefined;
+});
+
+const activeSqlFormatDialect = computed<SqlFormatDialect>(() => sqlFormatDialectForDbType(activeEffectiveDatabaseType.value));
+
+const editorDialect = computed<"mysql" | "postgres" | "sqlserver">(() => {
+  if (activeEffectiveDatabaseType.value === "postgres" || activeEffectiveDatabaseType.value === "kwdb") return "postgres";
+  if (activeEffectiveDatabaseType.value === "sqlserver") return "sqlserver";
+  return "mysql";
+});
+
+const shortcutModifier = computed(() => (navigator.platform.toLowerCase().includes("mac") ? "Cmd" : "Ctrl"));
+
+const modRKeys = computed(() =>
+  formatShortcut("Mod+R")
+    .split("+")
+    .map((key) => (key === "Cmd" ? "⌘" : key)),
+);
+
+const {
+  hasTabOverflow: hasResultTabOverflow,
+  scrollThumbLeftPercent: resultTabsThumbLeftPercent,
+  scrollThumbWidthPercent: resultTabsThumbWidthPercent,
+  isScrollbarDragging: isResultTabsScrollbarDragging,
+  updateScrollButtons: updateResultTabsScrollbar,
+  onTabsWheel: onResultTabsWheel,
+  startScrollbarDrag: startResultTabsScrollbarDrag,
+} = useTabScroll(resultTabsScrollerRef);
+
+const resultTabsScrollerStyle: CSSProperties = {
+  msOverflowStyle: "none",
+  scrollbarWidth: "none",
+  WebkitOverflowScrolling: "touch",
+};
+
+const resultTabsScrollbarThumbStyle = computed<CSSProperties>(() => ({
+  insetInlineStart: `${resultTabsThumbLeftPercent.value}%`,
+  width: `${resultTabsThumbWidthPercent.value}%`,
+}));
+
+const hasNumericData = computed(() => {
+  const r = props.activeTab.result;
+  if (!r || r.rows.length === 0) return false;
+  return chartableColumnIndexes(r).length > 0;
+});
+
+const activeQueryError = computed(() => {
+  const result = props.activeTab.result;
+  if (!result?.columns.includes("Error")) return "";
+  return String(result.rows[0]?.[0] ?? "");
+});
+const hasQueryOutput = computed(() => !!props.activeTab.result || !!props.activeTab.explainPlan || !!props.activeTab.explainError || !!props.activeTab.explainTableResult || !!props.activeTab.explainTableError || props.activeTab.isExecuting === true || props.activeTab.isExplaining === true);
+const visibleResultItems = computed(() => tabularResultItems(props.activeTab.results ?? (props.activeTab.result ? [props.activeTab.result] : undefined)));
+const tabularResults = computed(() => tabularResultItems(props.activeTab.results));
+const allResultExportSheets = computed(() =>
+  tabularResults.value.map((item) => ({
+    sheetName: item.label || t("tabs.resultN", { n: item.n }),
+    result: item.result,
+  })),
+);
+const resultRuns = computed(() => resultRunItems(props.activeTab));
+const activeResultRunItem = computed(() => resultRuns.value.find((run) => run.active));
+const activeResultGridCacheKey = computed(() => resultGridCacheKey(props.activeTab));
+const activeResultSql = computed(() => resultSqlForGrid(props.activeTab));
+const activeElasticsearchJsonResponse = computed(() => elasticsearchJsonResponseForResult(activeEffectiveDatabaseType.value, activeResultSql.value, props.activeTab.result));
+const resultArchiveExporting = ref(false);
+const canExportResultArchive = computed(() => props.activeTab.mode === "query" && (!!props.activeTab.result || !!props.activeTab.results?.length || !!props.activeTab.resultRuns?.length));
+const resultAutoSave = computed(() => props.activeTab.resultAutoSave === true);
+const showResultRunSelector = computed(() => resultAutoSave.value && resultRuns.value.length > 0);
+watch(
+  () => visibleResultItems.value.map((item) => item.index).join(","),
+  () => {
+    nextTick(updateResultTabsScrollbar);
+  },
+);
+const summaryItems = computed(() => executionSummaryItems(props.activeTab));
+const hasExecutionSummary = computed(() => summaryItems.value.length > 0 || props.activeTab.isExecuting);
+const hasTabularResult = computed(() => {
+  if (props.activeTab.result?.columns.length) return true;
+  return visibleResultItems.value.length > 0;
+});
+const canShowResultOutput = computed(() => hasTabularResult.value || props.activeTab.isExecuting);
+const canShowExplainOutput = computed(() => !!props.activeTab.explainPlan || !!props.activeTab.explainError || !!props.activeTab.explainTableResult || !!props.activeTab.explainTableError || props.activeTab.isExplaining === true);
+const showStandaloneResultToolbar = computed(() => activeElasticsearchJsonResponse.value || props.activeOutputView !== "result" || !props.activeTab.result || !hasTabularResult.value);
+const standaloneResultToolbarCompact = computed(() => standaloneResultToolbarWidth.value > 0 && standaloneResultToolbarWidth.value < DATA_GRID_COMPACT_TOPBAR_WIDTH);
+let standaloneResultToolbarResizeObserver: ResizeObserver | undefined;
+
+function observeStandaloneResultToolbar() {
+  standaloneResultToolbarResizeObserver?.disconnect();
+  standaloneResultToolbarResizeObserver = undefined;
+  const toolbar = standaloneResultToolbarRef.value;
+  standaloneResultToolbarWidth.value = toolbar?.clientWidth ?? 0;
+  if (toolbar && typeof ResizeObserver !== "undefined") {
+    standaloneResultToolbarResizeObserver = new ResizeObserver(() => {
+      standaloneResultToolbarWidth.value = toolbar.clientWidth;
+    });
+    standaloneResultToolbarResizeObserver.observe(toolbar);
+  }
+}
+
+watch(standaloneResultToolbarRef, observeStandaloneResultToolbar, { flush: "post" });
+type MongoQueryGridChanges = {
+  dirtyRows: Map<number, Map<number, MongoInputValue>>;
+  deletedRows: Set<number>;
+  newRows: MongoInputValue[][];
+  columns: string[];
+  rows: MongoInputValue[][];
+};
+function mongoIdPreview(val: unknown): string {
+  if (val === null || val === undefined) return "null";
+  if (typeof val === "string" && /^[a-fA-F0-9]{24}$/.test(val)) return `ObjectId("${val}")`;
+  return formatMongoShellLiteral(val);
+}
+function mongoCollectionExpression(collection: string): string {
+  return `db.getCollection(${JSON.stringify(collection)})`;
+}
+const mongoQueryResultSaveHandler = computed<CustomSaveHandler | undefined>(() => {
+  const tab = props.activeTab;
+  const target = tab.mongoEditTarget;
+  if (tab.mode !== "query" || activeEffectiveDatabaseType.value !== "mongodb" || !target || !tab.connectionId || !tab.database || !tab.result) return undefined;
+  if (!tab.result.columns.includes(target.idColumn)) return undefined;
+
+  const save: CustomSaveHandler["save"] = async (changes: MongoQueryGridChanges) => {
+    if (changes.newRows.length > 0 || changes.deletedRows.size > 0) {
+      throw new Error("MongoDB query result editing only supports updating existing rows.");
+    }
+    const idColIdx = changes.columns.indexOf(target.idColumn);
+    if (idColIdx < 0) throw new Error("No _id column");
+    for (const [rowIdx, dirtyCols] of changes.dirtyRows) {
+      const row = changes.rows[rowIdx];
+      const id = row?.[idColIdx];
+      if (id === null || id === undefined || String(id).trim() === "") continue;
+      const updateDoc = buildMongoUpdateDocument(dirtyCols, changes.columns);
+      if (Object.keys(updateDoc).length === 0) continue;
+      await api.mongoUpdateDocument(tab.connectionId, tab.database, target.collection, String(id), JSON.stringify(updateDoc));
+    }
+  };
+
+  const preview: CustomSaveHandler["preview"] = async (changes: MongoQueryGridChanges) => {
+    const idColIdx = changes.columns.indexOf(target.idColumn);
+    if (idColIdx < 0) return [];
+    const stmts: string[] = [];
+    for (const [rowIdx, dirtyCols] of changes.dirtyRows) {
+      const row = changes.rows[rowIdx];
+      const id = row?.[idColIdx];
+      if (id === null || id === undefined || String(id).trim() === "") continue;
+      const updateDoc = buildMongoUpdateDocument(dirtyCols, changes.columns);
+      if (Object.keys(updateDoc).length === 0) continue;
+      stmts.push(`${mongoCollectionExpression(target.collection)}.updateOne({_id: ${mongoIdPreview(id)}}, ${formatMongoShellLiteral(updateDoc)})`);
+    }
+    return stmts;
+  };
+
+  const applySavedChanges: NonNullable<CustomSaveHandler["applySavedChanges"]> = ({ dirtyRows, columns }) => {
+    const documents = tab.result?.mongo_documents;
+    if (!documents) return;
+
+    // Replace the raw array only after every backend update succeeds, keeping
+    // the grid and JSON preview atomic when a multi-row save partially fails.
+    const replacements = new Map<unknown, unknown>();
+    tab.result!.mongo_documents = documents.map((document, rowIdx) => {
+      const changes = dirtyRows.get(rowIdx);
+      if (!changes) return document;
+      const updated = applyMongoGridChangesToDocument(document, changes, columns);
+      replacements.set(document, updated);
+      return updated;
+    });
+    if (tab.resultLocalSortOriginalMongoDocuments) {
+      tab.resultLocalSortOriginalMongoDocuments = tab.resultLocalSortOriginalMongoDocuments.map((document) => replacements.get(document) ?? document);
+    }
+  };
+
+  return { save, preview, applySavedChanges, canInsert: false, canDelete: false, supportsInsert: false, readonlyColumns: [target.idColumn], targetLabel: target.collection };
+});
+const resultsPaneOpen = ref(false);
+const resultsPaneSize = ref(Number(safeLocalStorageGet("dbx-results-pane-size")) || DEFAULT_QUERY_RESULTS_PANE_SIZE);
+const editorPaneSize = computed(() => (resultsPaneOpen.value ? 100 - resultsPaneSize.value : 100));
+const queryRunningElapsed = ref(0);
+
+function onResultsResized(payload: { panes: { size: number }[] }) {
+  const resultsPane = payload.panes[1];
+  if (resultsPane?.size != null && resultsPane.size >= 20 && resultsPane.size <= 85) {
+    resultsPaneSize.value = resultsPane.size;
+    safeLocalStorageSet("dbx-results-pane-size", String(resultsPane.size));
+  }
+}
+let queryRunningElapsedFrame: number | undefined;
+
+function stopQueryRunningElapsedTimer() {
+  if (queryRunningElapsedFrame !== undefined) {
+    window.cancelAnimationFrame(queryRunningElapsedFrame);
+    queryRunningElapsedFrame = undefined;
+  }
+}
+
+function updateQueryRunningElapsed() {
+  const startedAt = props.activeTab.queryExecutionStartedAt;
+  queryRunningElapsed.value = props.activeTab.isExecuting && startedAt ? Math.max(0, Date.now() - startedAt) : 0;
+}
+
+function startQueryRunningElapsedTimer() {
+  stopQueryRunningElapsedTimer();
+  updateQueryRunningElapsed();
+  if (!props.activeTab.isExecuting || !props.activeTab.queryExecutionStartedAt) return;
+  const updateOnNextFrame = () => {
+    updateQueryRunningElapsed();
+    if (props.activeTab.isExecuting && props.activeTab.queryExecutionStartedAt) {
+      queryRunningElapsedFrame = window.requestAnimationFrame(updateOnNextFrame);
+    }
+  };
+  queryRunningElapsedFrame = window.requestAnimationFrame(updateOnNextFrame);
+}
+
+const queryRunningElapsedSeconds = computed(() => formatElapsedSeconds(queryRunningElapsed.value));
+
+watch(() => [props.activeTab.id, props.activeTab.isExecuting, props.activeTab.queryExecutionStartedAt] as const, startQueryRunningElapsedTimer, { immediate: true });
+
+onUnmounted(() => {
+  stopQueryRunningElapsedTimer();
+  standaloneResultToolbarResizeObserver?.disconnect();
+  window.removeEventListener("dbx-refresh-active-kv-browser", onRefreshActiveKvBrowser);
+});
+
+watch(
+  hasQueryOutput,
+  (hasOutput) => {
+    resultsPaneOpen.value = hasOutput ? true : false;
+  },
+  { immediate: true },
+);
+
+watch(
+  () => props.activeTab.id,
+  () => {
+    resultsPaneOpen.value = hasQueryOutput.value;
+  },
+);
+
+watch(
+  () => [props.activeTab.id, props.activeTab.result, props.activeTab.results, props.activeTab.isExecuting] as const,
+  () => {
+    if (props.activeTab.isExecuting) return;
+    if (hasExecutionSummary.value && !hasTabularResult.value && props.activeOutputView === "result") {
+      emit("update:activeOutputView", "summary");
+    }
+  },
+  { immediate: true },
+);
+
+watch(
+  () => [props.activeTab.isExecuting, props.activeTab.isExplaining],
+  ([isExecuting, isExplaining]) => {
+    if (isExecuting || isExplaining) resultsPaneOpen.value = true;
+  },
+);
+
+watch(
+  () => props.activeTab.result,
+  (result) => {
+    if (!result) return;
+    if (!isDebugLoggingEnabled()) return;
+    const startedAt = performance.now();
+    appendDebugLog("info", "[DBX][ContentArea:result:observed]", {
+      tabId: props.activeTab.id,
+      rowCount: result.rows.length,
+      columnCount: result.columns.length,
+      backendMs: result.execution_time_ms,
+      isExecuting: props.activeTab.isExecuting,
+    });
+    nextTick(() => {
+      appendDebugLog("info", "[DBX][ContentArea:result:nextTick]", {
+        tabId: props.activeTab.id,
+        elapsed: `${Math.round(performance.now() - startedAt)}ms`,
+        isExecuting: props.activeTab.isExecuting,
+      });
+      requestAnimationFrame(() => {
+        appendDebugLog("info", "[DBX][ContentArea:result:first-frame]", {
+          tabId: props.activeTab.id,
+          elapsed: `${Math.round(performance.now() - startedAt)}ms`,
+          isExecuting: props.activeTab.isExecuting,
+        });
+      });
+    });
+  },
+);
+
+watch(
+  () => props.activeTab.isExecuting,
+  (isExecuting, wasExecuting) => {
+    if (!isExecuting && wasExecuting) {
+      nextTick(() => {
+        requestAnimationFrame(() => {
+          queryEditorRef.value?.scrollCursorIntoView();
+        });
+      });
+    }
+  },
+);
+
+// Table toolbox handlers
+function handleTableImport() {
+  const tab = props.activeTab;
+  if (!tab.tableMeta || !tab.connectionId) return;
+  connectionStore.tableImportSource = {
+    connectionId: tab.connectionId,
+    database: tab.database,
+    schema: tab.tableMeta.schema,
+    tableName: tab.tableMeta.tableName,
+  };
+}
+
+function handleTableDataGenerate() {
+  const tab = props.activeTab;
+  if (!tab.tableMeta || !tab.connectionId) return;
+  connectionStore.tableDataGenerateSource = {
+    connectionId: tab.connectionId,
+    database: tab.database,
+    schema: tab.tableMeta.schema,
+    tableName: tab.tableMeta.tableName,
+  };
+}
+
+// Column info panel handlers
+async function onHandleClickColumn(matchedCols: Array<{ name: string; table: string; schema?: string }>, errorMsg?: string) {
+  if (!props.activeTab.connectionId || !props.activeTab.database) return;
+
+  // If error or no columns, silently ignore — don't show the panel
+  if (errorMsg || matchedCols.length === 0) return;
+
+  columnInfoLoading.value = true;
+  columnInfoError.value = undefined;
+
+  try {
+    // Fetch full column details from API
+    const apiModule = await import("@/lib/backend/api");
+    const results: ColumnInfo[] = [];
+
+    for (const matchedCol of matchedCols) {
+      const querySchema = matchedCol.schema || props.activeTab.database || "";
+      try {
+        const fullColumns = await apiModule.getColumns(props.activeTab.connectionId, props.activeTab.database, querySchema, matchedCol.table);
+        for (const col of fullColumns) {
+          if (col.name === matchedCol.name) {
+            results.push({
+              name: col.name,
+              table: matchedCol.table,
+              dataType: col.data_type,
+              isNullable: col.is_nullable,
+              columnDefault: col.column_default,
+              isPrimaryKey: col.is_primary_key,
+              comment: col.comment,
+              extra: col.extra,
+            });
+          }
+        }
+      } catch {
+        // Skip tables that fail
+      }
+    }
+
+    columnInfoColumns.value = results;
+  } catch (e: any) {
+    // Silently ignore errors
+    console.error("[DBX] Failed to fetch column info:", e);
+    return;
+  } finally {
+    columnInfoLoading.value = false;
+    showColumnInfo.value = true;
+  }
+}
+
+function closeColumnInfo() {
+  showColumnInfo.value = false;
+  columnInfoColumns.value = [];
+  columnInfoError.value = undefined;
+}
+
+function onHandleClickTable(tableName: string) {
+  emit("clickTable", tableName);
+}
+
+function onHandleViewTableData(tableName: string) {
+  emit("viewTableData", tableName);
+}
+
+function onHandleViewTableDdl(tableName: string) {
+  emit("viewTableDdl", tableName);
+}
+
+function onHandleEditTableStructure(tableName: string) {
+  emit("editTableStructure", tableName);
+}
+
+function onHandleCloseColumnPanel() {
+  showColumnInfo.value = false;
+  columnInfoColumns.value = [];
+  columnInfoError.value = undefined;
+}
+
+function focusSearch(): boolean {
+  if (props.activeTab.mode === "redis") return redisKeyBrowserRef.value?.focusSearch() ?? false;
+  if (props.activeTab.mode === "etcd") return etcdKeyBrowserRef.value?.focusSearch() ?? false;
+  if (props.activeTab.mode === "zookeeper") return zookeeperKeyBrowserRef.value?.focusSearch() ?? false;
+  if (props.activeTab.mode === "objects") return objectBrowserRef.value?.focusSearch() ?? false;
+  if (props.activeTab.mode === "query") return queryEditorRef.value?.openSearch() ?? false;
+  return dataGridRef.value?.focusSearch() ?? false;
+}
+
+function refreshData(): boolean {
+  if (props.activeTab.mode === "etcd") return etcdKeyBrowserRef.value?.refresh?.() ?? false;
+  if (props.activeTab.mode === "zookeeper") return zookeeperKeyBrowserRef.value?.refresh?.() ?? false;
+  // Restored data tabs intentionally omit row data, so refresh must work before DataGrid mounts.
+  if (canReloadUnavailableDataTab(props.activeTab)) {
+    emit("reload");
+    return true;
+  }
+  if (activeElasticsearchJsonResponse.value) {
+    // Match DataGrid's toolbar refresh intent so multi-result runs are
+    // refreshed as a group instead of replacing them with the active result.
+    emit("reload", activeResultSql.value, undefined, undefined, undefined, undefined, undefined, "refresh");
+    return true;
+  }
+  if (!dataGridRef.value) return false;
+  void dataGridRef.value.onToolbarRefresh();
+  return true;
+}
+
+function onRefreshActiveKvBrowser(event: Event) {
+  const detail = (event as CustomEvent<{ mode?: string; connectionId?: string }>).detail;
+  if (!detail || props.activeTab.mode !== detail.mode || props.activeTab.connectionId !== detail.connectionId) return;
+  void nextTick(() => refreshData());
+}
+
+async function exportResultArchive() {
+  if (resultArchiveExporting.value) return;
+  resultArchiveExporting.value = true;
+  try {
+    const bytes = await queryStore.exportResultArchive(props.activeTab.id);
+    if (!bytes) {
+      toast(t("tabs.resultArchiveUnavailable"), 4000);
+      return;
+    }
+    const saved = await saveQueryResultArchiveFile(defaultQueryResultArchiveFileName(props.activeTab.title), bytes);
+    if (saved) toast(t("tabs.resultArchiveExported"), 2500);
+  } catch (error: any) {
+    toast(t("tabs.resultArchiveExportFailed", { message: error?.message || String(error) }), 5000);
+  } finally {
+    resultArchiveExporting.value = false;
+  }
+}
+
+async function removeResultRun(runId: string) {
+  const removedActiveRun = props.activeTab.activeResultRunId === runId;
+  const removed = await queryStore.removeResultRun(props.activeTab.id, runId);
+  if (removed && removedActiveRun) emit("update:activeOutputView", "result");
+}
+
+async function selectResultRun(runId: string) {
+  if (!(await queryStore.setActiveResultRun(props.activeTab.id, runId))) {
+    toast(t("tabs.missingResultRun"), 4000);
+    return;
+  }
+  emit("update:activeOutputView", "result");
+}
+
+function toggleResultAutoSave() {
+  const enabled = queryStore.toggleResultAutoSave(props.activeTab.id);
+  toast(t(enabled ? "tabs.autoKeepResultsEnabled" : "tabs.autoKeepResultsDisabled"), 2500);
+}
+
+function handleModRTarget(target: Element): boolean {
+  if (target.closest("[data-query-editor-root]")) return queryEditorRef.value?.openReplace() ?? false;
+  if (target.closest("[data-cell-detail-editor-root]")) return dataGridRef.value?.openCellDetailSearch() ?? false;
+  if (target.closest("[data-grid-root], [data-elasticsearch-json-response-root]")) return refreshData();
+  if (canReloadUnavailableDataTab(props.activeTab)) return refreshData();
+  return false;
+}
+
+function requestQueryEditorExecute() {
+  return queryEditorRef.value?.requestExecute();
+}
+
+function pasteClipboardAsSqlInCondition() {
+  return queryEditorRef.value?.pasteClipboardAsSqlInCondition();
+}
+
+defineExpose({ focusSearch, refreshData, handleModRTarget, requestQueryEditorExecute, pasteClipboardAsSqlInCondition });
+</script>
+
+<template>
+  <div class="production-session-shell flex flex-col flex-1 min-h-0" :class="{ 'production-session-shell--active': activeProductionContext.active }">
+    <div v-if="activeProductionContext.active" class="production-session-strip flex h-7 shrink-0 items-center gap-2 border-b border-red-500/35 bg-red-500/10 px-3 text-xs font-semibold text-red-800 shadow-[inset_0_1px_0_rgb(239_68_68_/_0.28)] dark:text-red-200">
+      <ShieldAlert class="h-3.5 w-3.5 shrink-0" aria-hidden="true" />
+      <span class="font-mono uppercase tracking-normal">{{ t("production.title") }}</span>
+      <span v-if="productionSessionDetail" class="min-w-0 truncate rounded-[4px] border border-red-500/25 bg-background/65 px-1.5 py-0.5 font-medium text-red-700 dark:text-red-200">{{ productionSessionDetail }}</span>
+    </div>
+    <!-- Query mode: editor + results -->
+    <template v-if="activeTab.mode === 'query'">
+      <Splitpanes horizontal class="query-output-splitpanes flex-1 min-h-0 overflow-hidden" @resized="onResultsResized">
+        <Pane class="min-h-0" :size="editorPaneSize" :min-size="resultsPaneOpen ? 15 : 100">
+          <div class="h-full flex flex-col relative">
+            <div v-if="activeProductionContext.active" class="production-watermark pointer-events-none absolute inset-0 z-10 grid select-none" aria-hidden="true">
+              <span v-for="index in 4" :key="index" class="production-watermark__label whitespace-nowrap font-mono text-6xl font-extrabold text-red-700/[0.24] dark:text-red-200/[0.2]">{{ productionWatermarkText }}</span>
+            </div>
+            <QueryEditor
+              ref="queryEditorRef"
+              class="relative z-0 flex-1"
+              :model-value="activeTab.sql"
+              :connection-id="activeTab.connectionId"
+              :database="activeTab.database"
+              :schema="activeTab.schema"
+              :database-type="activeEffectiveDatabaseType"
+              :dialect="editorDialect"
+              :format-dialect="activeSqlFormatDialect"
+              :format-request-id="formatSqlRequest?.tabId === activeTab.id ? formatSqlRequest.id : undefined"
+              :execution-error="activeQueryError"
+              :execution-error-sql="activeTab.lastExecutedSql"
+              :initial-viewport="activeTab.editorViewport"
+              :initial-selection="activeTab.editorSelection"
+              @update:model-value="emit('editorUpdate', activeTab.id, $event)"
+              @selection-change="emit('editorSelectionChange', $event)"
+              @send-selection-to-ai="emit('sendSelectionToAi', $event)"
+              @cursor-change="emit('editorCursorChange', $event)"
+              @viewport-change="emit('editorViewportChange', activeTab.id, $event)"
+              @selection-state-change="emit('editorSelectionStateChange', activeTab.id, $event)"
+              @format-error="emit('formatError')"
+              @execute="emit('execute', $event)"
+              @save="emit('saveSql')"
+              @click-table="onHandleClickTable"
+              @view-table-data="onHandleViewTableData"
+              @edit-table-structure="onHandleEditTableStructure"
+              @view-table-ddl="onHandleViewTableDdl"
+              @click-column="onHandleClickColumn"
+              @close-column-panel="onHandleCloseColumnPanel"
+            />
+            <ColumnInfoPanel v-if="showColumnInfo" :columns="columnInfoColumns" :loading="columnInfoLoading" :error="columnInfoError" @close="closeColumnInfo" />
+            <Button v-if="hasQueryOutput && !resultsPaneOpen" variant="secondary" size="sm" class="absolute bottom-3 right-3 z-20 h-7 gap-1.5 rounded-full border bg-background/95 px-3 text-xs shadow-lg hover:bg-accent" @click="resultsPaneOpen = true">
+              <ChevronUp class="h-3.5 w-3.5" />
+              {{ t("editor.showResultsPane") }}
+            </Button>
+          </div>
+        </Pane>
+        <Pane v-if="resultsPaneOpen" class="min-h-0" :size="resultsPaneSize" :min-size="20">
+          <div class="h-full flex flex-col">
+            <div v-if="hasQueryOutput" class="flex h-10 shrink-0 items-center gap-1 border-b bg-muted/20 px-2">
+              <Button
+                v-if="activeTab.mode === 'query' && activeTab.result"
+                variant="ghost"
+                size="icon"
+                class="h-6 w-7 shrink-0"
+                :class="resultAutoSave ? 'bg-primary/10 text-primary hover:bg-primary/15 hover:text-primary' : 'text-muted-foreground hover:bg-accent hover:text-foreground'"
+                :title="resultAutoSave ? t('tabs.autoKeepResultsEnabled') : t('tabs.autoKeepResults')"
+                :aria-label="resultAutoSave ? t('tabs.autoKeepResultsEnabled') : t('tabs.autoKeepResults')"
+                :aria-pressed="resultAutoSave"
+                @click="toggleResultAutoSave"
+              >
+                <Pin class="h-3.5 w-3.5" :class="{ 'fill-current': resultAutoSave }" />
+              </Button>
+              <template v-if="showResultRunSelector">
+                <span class="mx-1 h-4 w-px shrink-0 bg-border" />
+                <DropdownMenu>
+                  <DropdownMenuTrigger as-child>
+                    <Button variant="ghost" size="sm" class="h-6 shrink-0 gap-1 px-2 text-xs">
+                      {{ activeResultRunItem ? t("tabs.runN", { n: activeResultRunItem.sequence }) : t("tabs.resultRuns") }}
+                      <ChevronDown class="h-3.5 w-3.5" />
+                    </Button>
+                  </DropdownMenuTrigger>
+                  <DropdownMenuContent align="start" class="w-48">
+                    <DropdownMenuItem v-for="run in resultRuns" :key="run.id" class="flex items-center gap-2 pr-1" @select="selectResultRun(run.id)">
+                      <Check v-if="run.active" class="h-3.5 w-3.5 shrink-0" />
+                      <span v-else class="h-3.5 w-3.5 shrink-0" />
+                      <span class="min-w-0 flex-1 truncate">{{ t("tabs.runN", { n: run.sequence }) }}</span>
+                      <button
+                        type="button"
+                        class="inline-flex h-5 w-5 shrink-0 items-center justify-center rounded-sm text-muted-foreground hover:bg-accent hover:text-foreground"
+                        :title="t('tabs.removeRun', { n: run.sequence })"
+                        :aria-label="t('tabs.removeRun', { n: run.sequence })"
+                        @click.stop.prevent="removeResultRun(run.id)"
+                      >
+                        <X class="h-3 w-3" />
+                      </button>
+                    </DropdownMenuItem>
+                  </DropdownMenuContent>
+                </DropdownMenu>
+              </template>
+              <template v-if="visibleResultItems.length > 0">
+                <span class="mx-1 h-4 w-px shrink-0 bg-border" />
+                <div class="relative min-w-0 flex-1 self-stretch">
+                  <div v-if="hasResultTabOverflow" class="result-tab-scrollbar" :class="{ 'result-tab-scrollbar--dragging': isResultTabsScrollbarDragging }" @pointerdown="startResultTabsScrollbarDrag">
+                    <div class="result-tab-scrollbar__thumb" :style="resultTabsScrollbarThumbStyle" />
+                  </div>
+                  <div ref="resultTabsScrollerRef" class="result-tab-scroll flex h-full items-center gap-1 overflow-x-auto overflow-y-hidden px-1" :style="resultTabsScrollerStyle" @scroll="updateResultTabsScrollbar" @wheel="onResultTabsWheel">
+                    <Button
+                      v-for="item in visibleResultItems"
+                      :key="item.index"
+                      size="sm"
+                      :variant="activeOutputView === 'result' && (activeTab.activeResultIndex ?? 0) === item.index ? 'default' : 'ghost'"
+                      class="h-6 max-w-48 shrink-0 overflow-hidden text-ellipsis whitespace-nowrap px-2 text-xs"
+                      :title="item.title || item.label || t('tabs.resultN', { n: item.n })"
+                      @click="
+                        queryStore.setActiveResultIndex(activeTab.id, item.index);
+                        emit('update:activeOutputView', 'result');
+                      "
+                    >
+                      {{ item.label || t("tabs.resultN", { n: item.n }) }}
+                    </Button>
+                  </div>
+                </div>
+              </template>
+              <div class="ml-auto flex shrink-0 items-center gap-1">
+                <Popover v-if="activeOutputView === 'result' && activeTab.result && hasTabularResult && !activeElasticsearchJsonResponse">
+                  <PopoverTrigger as-child>
+                    <Button variant="ghost" size="icon" class="h-6 w-7 shrink-0 text-foreground hover:bg-accent" :title="t('grid.viewOptions')" :aria-label="t('grid.viewOptions')">
+                      <Wrench class="h-4 w-4" />
+                    </Button>
+                  </PopoverTrigger>
+                  <PopoverContent align="end" class="w-max min-w-44 max-w-[calc(100vw-2rem)] gap-0 overflow-hidden rounded-xl border bg-popover p-0 text-popover-foreground shadow-xl" @click.stop @keydown.stop>
+                    <div class="border-b bg-muted/40 px-3 py-2">
+                      <div class="text-xs font-semibold">{{ t("grid.viewOptions") }}</div>
+                    </div>
+                    <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs">
+                      <div class="min-w-0 flex items-center gap-2 font-medium">
+                        <SquareDashed class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                        <span>{{ t("grid.renderMode") }}</span>
+                      </div>
+                      <LightTooltip :text="t('grid.renderModeHint')" side="left" :side-offset="6" :delay="0" :open-on-focus="false">
+                        <div class="grid w-32 grid-cols-2 rounded-md border bg-muted/40 p-0.5">
+                          <button
+                            type="button"
+                            class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                            :class="dataGridRenderMode === 'canvas' ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                            @click="setDataGridRenderMode('canvas')"
+                          >
+                            {{ t("grid.canvasRenderMode") }}
+                          </button>
+                          <button
+                            type="button"
+                            class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                            :class="dataGridRenderMode === 'dom' ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                            @click="setDataGridRenderMode('dom')"
+                          >
+                            {{ t("grid.domRenderMode") }}
+                          </button>
+                        </div>
+                      </LightTooltip>
+                    </div>
+                    <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs">
+                      <div class="min-w-0 flex items-center gap-2 font-medium">
+                        <Columns3Cog class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                        <span>{{ t("grid.columnWidth") }}</span>
+                      </div>
+                      <div class="grid w-48 grid-cols-3 rounded-md border bg-muted/40 p-0.5">
+                        <button
+                          v-for="density in ['compact', 'standard', 'comfortable'] as const"
+                          :key="density"
+                          type="button"
+                          class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-1.5 text-xs transition-colors"
+                          :class="columnWidthDensity === density ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                          @click="setColumnWidthDensity(density)"
+                        >
+                          {{ t(`grid.columnWidth${density.charAt(0).toUpperCase()}${density.slice(1)}`) }}
+                        </button>
+                      </div>
+                    </div>
+                    <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs">
+                      <div class="min-w-0 flex items-center gap-2 font-medium">
+                        <span class="flex h-3.5 w-3.5 shrink-0 items-center justify-center text-[11px] font-semibold text-muted-foreground">A</span>
+                        <span>{{ t("grid.tableFontSize") }}</span>
+                      </div>
+                      <div class="flex h-6 w-32 items-center rounded-md border bg-muted/40 p-0.5">
+                        <button
+                          type="button"
+                          class="flex h-5 w-8 items-center justify-center rounded-[5px] bg-background text-foreground shadow-sm transition-colors hover:text-foreground disabled:pointer-events-none disabled:bg-muted/40 disabled:text-muted-foreground disabled:opacity-50 disabled:shadow-none"
+                          :disabled="tableFontSize <= TABLE_FONT_SIZE_MIN"
+                          :aria-label="t('common.decrease')"
+                          @click="decreaseTableFontSize"
+                        >
+                          <Minus class="h-3.5 w-3.5" />
+                        </button>
+                        <span class="flex-1 text-center text-xs font-semibold tabular-nums">{{ tableFontSize }}</span>
+                        <button
+                          type="button"
+                          class="flex h-5 w-8 items-center justify-center rounded-[5px] bg-background text-foreground shadow-sm transition-colors hover:text-foreground disabled:pointer-events-none disabled:bg-muted/40 disabled:text-muted-foreground disabled:opacity-50 disabled:shadow-none"
+                          :disabled="tableFontSize >= TABLE_FONT_SIZE_MAX"
+                          :aria-label="t('common.increase')"
+                          @click="increaseTableFontSize"
+                        >
+                          <Plus class="h-3.5 w-3.5" />
+                        </button>
+                      </div>
+                    </div>
+                    <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs">
+                      <div class="min-w-0 flex items-center gap-2 font-medium">
+                        <Search class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                        <span>{{ t("grid.searchMode") }}</span>
+                      </div>
+                      <LightTooltip :text="t('grid.searchModeHint')" side="left" :side-offset="6" :delay="0" :open-on-focus="false">
+                        <div class="grid w-32 grid-cols-2 rounded-md border bg-muted/40 p-0.5">
+                          <button
+                            type="button"
+                            class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                            :class="dataGridSearchMode === 'filter' ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                            @click="setDataGridSearchMode('filter')"
+                          >
+                            {{ t("grid.searchModeFilter") }}
+                          </button>
+                          <button
+                            type="button"
+                            class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                            :class="dataGridSearchMode === 'highlight' ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                            @click="setDataGridSearchMode('highlight')"
+                          >
+                            {{ t("grid.searchModeHighlight") }}
+                          </button>
+                        </div>
+                      </LightTooltip>
+                    </div>
+                    <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs">
+                      <div class="min-w-0 flex items-center gap-2 font-medium">
+                        <Rows3 class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                        <span>{{ t("grid.transposeMultiRowToggle") }}</span>
+                      </div>
+                      <LightTooltip :text="t('grid.transposeMultiRowHint')" side="left" :side-offset="6" :delay="0" :open-on-focus="false">
+                        <div class="grid w-32 grid-cols-2 rounded-md border bg-muted/40 p-0.5">
+                          <button
+                            type="button"
+                            class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                            :class="!dataGridRef?.multiRowTranspose ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                            @click="dataGridRef?.setMultiRowTranspose(false)"
+                          >
+                            {{ t("grid.transposeSingleRow") }}
+                          </button>
+                          <button
+                            type="button"
+                            class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                            :class="dataGridRef?.multiRowTranspose ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                            @click="dataGridRef?.setMultiRowTranspose(true)"
+                          >
+                            {{ t("grid.transposeMultiRow") }}
+                          </button>
+                        </div>
+                      </LightTooltip>
+                    </div>
+                    <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs" :class="{ 'opacity-60': !dataGridRef?.canToggleAllNullColumns }">
+                      <span class="min-w-0 flex items-center gap-2 font-medium">
+                        <EyeOff class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                        {{ t("grid.hideNullColumns") }}
+                        <span v-if="(dataGridRef?.allNullColumnCount ?? 0) > 0" class="text-muted-foreground tabular-nums"> ({{ dataGridRef?.allNullColumnCount }}) </span>
+                      </span>
+                      <Switch size="sm" :model-value="!!dataGridRef?.nullColumnsHidden" :disabled="!dataGridRef?.canToggleAllNullColumns" :aria-label="t('grid.hideNullColumns')" @update:model-value="dataGridRef?.toggleAllNullColumns()" />
+                    </div>
+                  </PopoverContent>
+                </Popover>
+                <LightTooltip :text="t('editor.hideResultsPane')" side="bottom" :delay="0" :close-delay="0" nowrap>
+                  <Button variant="ghost" size="icon" class="h-6 w-7 shrink-0 text-muted-foreground hover:text-foreground" :title="t('editor.hideResultsPane')" :aria-label="t('editor.hideResultsPane')" @click="resultsPaneOpen = false">
+                    <ChevronDown class="h-3.5 w-3.5" />
+                  </Button>
+                </LightTooltip>
+              </div>
+            </div>
+
+            <div v-if="hasQueryOutput && showStandaloneResultToolbar" ref="standaloneResultToolbarRef" class="flex min-h-7 shrink-0 items-center border-b bg-muted/20">
+              <QueryResultViewSwitcher
+                :active-view="activeOutputView"
+                :can-show-result="canShowResultOutput"
+                :can-show-summary="hasExecutionSummary"
+                :can-show-chart="hasNumericData && !activeElasticsearchJsonResponse"
+                :compact="standaloneResultToolbarCompact"
+                @select-view="emit('update:activeOutputView', $event)"
+              />
+              <QueryResultToolbarActions
+                class="ml-auto"
+                :active-view="activeOutputView"
+                :can-show-explain="canShowExplainOutput"
+                :can-export-archive="canExportResultArchive"
+                :archive-exporting="resultArchiveExporting"
+                :compact="standaloneResultToolbarCompact"
+                @select-explain="emit('update:activeOutputView', 'explain')"
+                @export-archive="exportResultArchive"
+              />
+            </div>
+
+            <ExplainPlanViewer
+              v-if="activeOutputView === 'explain'"
+              class="flex-1 min-h-0"
+              :plan="activeTab.explainPlan"
+              :error="activeTab.explainError"
+              :loading="activeTab.isExplaining"
+              :source-sql="activeTab.lastExplainedSql"
+              :explain-sql="activeTab.explainSql"
+              :table-result="activeTab.explainTableResult"
+              :table-error="activeTab.explainTableError"
+            />
+
+            <QueryChart v-else-if="activeOutputView === 'chart' && activeTab.result && !activeElasticsearchJsonResponse" class="flex-1 min-h-0" :result="activeTab.result" />
+
+            <div v-else-if="activeOutputView === 'summary'" class="flex-1 min-h-0 overflow-auto bg-background">
+              <div v-if="activeTab.isExecuting" class="flex h-full items-center justify-center text-sm text-muted-foreground">
+                <Loader2 class="mr-2 h-4 w-4 animate-spin" />
+                {{ t("executionSummary.executing") }}
+              </div>
+              <div v-else-if="summaryItems.length === 0" class="flex h-full items-center justify-center text-sm text-muted-foreground">
+                {{ t("executionSummary.empty") }}
+              </div>
+              <div v-else>
+                <div class="overflow-hidden border-b">
+                  <div class="grid grid-cols-[4rem_1fr_8rem_8rem_7rem] border-b bg-muted/30 px-3 py-2 text-xs font-medium text-muted-foreground">
+                    <div>{{ t("executionSummary.statement") }}</div>
+                    <div>{{ t("executionSummary.type") }}</div>
+                    <div class="text-right">{{ t("executionSummary.rows") }}</div>
+                    <div class="text-right">{{ t("executionSummary.affected") }}</div>
+                    <div class="text-right">{{ t("executionSummary.time") }}</div>
+                  </div>
+                  <div v-for="item in summaryItems" :key="item.index" class="grid grid-cols-[4rem_1fr_8rem_8rem_7rem] items-center border-b px-3 py-2 text-xs last:border-b-0">
+                    <div class="font-mono text-muted-foreground">#{{ item.index + 1 }}</div>
+                    <div class="flex min-w-0 items-center gap-2">
+                      <span class="inline-flex h-5 items-center rounded-full border px-2 text-[10px]" :class="item.isError ? 'border-destructive/40 bg-destructive/10 text-destructive' : 'border-emerald-500/30 bg-emerald-500/10 text-emerald-700 dark:text-emerald-300'">
+                        {{ item.isError ? t("executionSummary.error") : t("executionSummary.success") }}
+                      </span>
+                      <span class="truncate">
+                        {{ item.hasTabularResult ? t("executionSummary.returnedTable", { count: item.returnedColumns }) : t("executionSummary.noTable") }}
+                      </span>
+                    </div>
+                    <div class="text-right tabular-nums">{{ item.returnedRows.toLocaleString() }}</div>
+                    <div class="text-right tabular-nums">{{ item.affectedRows.toLocaleString() }}</div>
+                    <div class="text-right tabular-nums">{{ item.executionTimeMs }}ms</div>
+                  </div>
+                </div>
+              </div>
+            </div>
+
+            <template v-else>
+              <ElasticsearchJsonResponsePanel v-if="activeElasticsearchJsonResponse" class="flex-1 min-h-0" :status="activeElasticsearchJsonResponse.status" :body="activeElasticsearchJsonResponse.body" />
+              <DataGrid
+                v-else-if="activeTab.result && hasTabularResult"
+                ref="dataGridRef"
+                :key="activeResultGridCacheKey"
+                :cache-key="activeResultGridCacheKey"
+                class="flex-1 min-h-0"
+                :result="activeTab.result"
+                :sort-column="activeTab.resultSortColumn"
+                :sort-column-index="activeTab.resultSortColumnIndex"
+                :sort-direction="activeTab.resultSortDirection"
+                :sort-mode="activeTab.resultSortMode"
+                :initial-order-by-input="activeTab.orderByInput"
+                :sql="activeResultSql"
+                :loading="activeTab.isExecuting"
+                :editable="!!activeTab.queryAnalysis || !!mongoQueryResultSaveHandler"
+                :source-columns="activeTab.querySourceColumns"
+                :custom-save-handler="mongoQueryResultSaveHandler"
+                :query-editability-reason="activeTab.queryEditabilityReason"
+                :allow-insert-rows="activeTab.queryAnalysis?.allowInsert !== false && activeTab.queryAnalysis?.allowInsertDelete !== false"
+                :allow-delete-rows="activeTab.queryAnalysis?.allowInsertDelete !== false"
+                context="results"
+                :database-type="activeEffectiveDatabaseType"
+                :connection-id="activeTab.connectionId"
+                :database="activeTab.database"
+                :schema="activeTab.schema"
+                :table-meta="activeTab.tableMeta"
+                :table-info-tab="activeTab.tableInfoTab"
+                :page-offset="activeTab.resultPageOffset"
+                :page-limit="activeTab.resultPageLimit"
+                :count-sql="activeTab.resultCountSql"
+                :total-row-count="activeTab.resultTotalRowCount"
+                :total-row-count-loading="activeTab.resultTotalRowCountLoading"
+                :on-execute-sql="async (sql: string) => emit('executeSql', sql)"
+                :full-export-result="(onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void) => queryStore.fetchTabResultForExport(activeTab.id, onProgress)"
+                :query-result-export-request="(options: { exportId: string; filePath: string; format: 'csv' | 'xlsx' }) => queryStore.buildQueryResultExportRequest(activeTab.id, options)"
+                :all-export-results="allResultExportSheets"
+                :export-file-base-name="activeTab.title"
+                @update:order-by-input="(v: string) => (activeTab.orderByInput = v)"
+                @reload="(sql?: string, searchText?: string, whereInput?: string, orderBy?: string, limit?: number, offset?: number, intent?: DataGridReloadIntent) => emit('reload', sql, searchText, whereInput, orderBy, limit, offset, intent)"
+                @paginate="(offset: number, limit: number, whereInput?: string, orderBy?: string) => emit('paginate', offset, limit, whereInput, orderBy)"
+                @sort="(column: string, columnIndex: number, direction: 'asc' | 'desc' | null, whereInput?: string, mode?: DataGridSortMode) => emit('sort', column, columnIndex, direction, whereInput, mode)"
+              >
+                <template #result-toolbar-leading="{ compact }">
+                  <QueryResultViewSwitcher :active-view="activeOutputView" :can-show-result="canShowResultOutput" :can-show-summary="hasExecutionSummary" :can-show-chart="hasNumericData && !activeElasticsearchJsonResponse" :compact="compact" @select-view="emit('update:activeOutputView', $event)" />
+                </template>
+                <template #result-toolbar-actions="{ compact }">
+                  <QueryResultToolbarActions
+                    :active-view="activeOutputView"
+                    :can-show-explain="canShowExplainOutput"
+                    :can-export-archive="canExportResultArchive"
+                    :archive-exporting="resultArchiveExporting"
+                    :compact="compact"
+                    @select-explain="emit('update:activeOutputView', 'explain')"
+                    @export-archive="exportResultArchive"
+                  />
+                </template>
+                <template v-if="activeTab.result?.columns.includes('Error')" #error-actions="{ errorMessage }">
+                  <QueryErrorActions :error-message="String(errorMessage)" :connection-id="activeTab.connectionId" @change-query-timeout="activeTab.connectionId && emit('openConnectionSettings', activeTab.connectionId, 'advanced')" @fix-with-ai="(message) => emit('fixWithAi', message)" />
+                </template>
+              </DataGrid>
+              <QueryLoadingState
+                v-else-if="!activeTab.result && activeTab.isExecuting"
+                class="flex-1 min-h-0"
+                :label-key="queryExecutionLabelKey(activeTab)"
+                :elapsed-seconds="queryRunningElapsedSeconds"
+                show-cancel
+                :cancel-disabled="!canCancelQueryExecution(activeTab)"
+                :cancelling="activeTab.isCancelling"
+                @cancel="emit('cancel')"
+              />
+              <div v-else-if="!activeTab.result" class="flex-1 min-h-0 flex flex-col items-center justify-center gap-1 text-muted-foreground text-sm">
+                <div>{{ t("editor.pressToExecute", { mod: shortcutModifier }) }}</div>
+                <div>{{ t("editor.pressToSaveSql", { mod: shortcutModifier }) }}</div>
+              </div>
+            </template>
+          </div>
+        </Pane>
+      </Splitpanes>
+    </template>
+
+    <!-- Data mode: full-height grid -->
+    <template v-else-if="activeTab.mode === 'data'">
+      <div class="flex-1 min-h-0 flex flex-col">
+        <div class="h-9 shrink-0 border-b bg-background/80 px-3 flex items-center gap-2 text-xs">
+          <span class="inline-flex items-center rounded border border-border bg-muted/50 px-2 py-0.5 font-medium truncate">
+            {{ activeTab.tableMeta?.tableName || activeTab.title }}
+          </span>
+          <span class="inline-flex items-center rounded border border-border bg-muted/30 px-2 py-0.5 text-muted-foreground truncate">
+            <template v-if="activeTab.tableMeta?.schema">{{ activeTab.tableMeta.schema }}@</template>{{ databaseDisplayNameForTab(activeTab.connectionId, activeTab.database, t) }}
+          </span>
+          <span v-if="activeTab.mode === 'data' && activeTab.tableMeta" class="inline-flex shrink-0 items-center rounded border border-border bg-muted/30 px-2 py-0.5 font-medium text-muted-foreground tabular-nums"> {{ activeTab.tableMeta.columns.length }} {{ t("tree.columns") }} </span>
+          <span class="ml-auto" />
+          <Popover v-if="activeTab.result?.columns.length">
+            <PopoverTrigger as-child>
+              <Button variant="ghost" size="sm" class="h-5 text-xs px-1.5 shrink-0" :class="{ 'bg-accent text-foreground': (dataGridRef?.hiddenColumnCount ?? 0) > 0 }">
+                <Columns3 class="h-3.5 w-3.5" />
+                {{ t("grid.columnVisibility") }}
+                <span v-if="(dataGridRef?.hiddenColumnCount ?? 0) > 0" class="tabular-nums"> {{ dataGridRef?.visibleColumnCount }}/{{ dataGridRef?.displayableColumnCount }} </span>
+              </Button>
+            </PopoverTrigger>
+            <PopoverContent align="end" class="w-64 max-w-[calc(100vw-2rem)] gap-0 overflow-hidden rounded-xl border bg-popover p-0 text-popover-foreground shadow-xl" @click.stop @keydown.stop>
+              <div class="border-b bg-muted/40 px-2 py-1.5">
+                <div class="flex items-center justify-between gap-2">
+                  <div class="text-xs font-semibold">{{ t("grid.columnVisibility") }}</div>
+                  <div class="text-[10px] text-muted-foreground tabular-nums">{{ dataGridRef?.visibleColumnCount ?? 0 }}/{{ dataGridRef?.displayableColumnCount ?? 0 }}</div>
+                </div>
+              </div>
+              <div class="flex items-center gap-1.5 border-b px-2 py-1.5">
+                <Search class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                <input v-model="columnVisibilitySearch" autocapitalize="off" autocorrect="off" spellcheck="false" class="h-6 min-w-0 flex-1 bg-transparent text-xs outline-none placeholder:text-muted-foreground" :placeholder="t('grid.searchColumns')" />
+              </div>
+              <div class="max-h-72 overflow-auto py-0.5">
+                <button v-for="option in columnVisibilityOptions" :key="`${option.index}:${option.column}`" type="button" class="grid w-full grid-cols-[1.5rem_minmax(0,1fr)] items-center px-2 py-1 text-left text-xs hover:bg-accent" @click="dataGridRef?.toggleColumnVisibility(option.index)">
+                  <span class="flex h-4 w-4 items-center justify-center rounded border" :class="dataGridRef?.isColumnVisible(option.index) ? 'border-primary bg-primary text-primary-foreground' : 'border-border bg-background text-transparent'">
+                    <Check class="h-3 w-3 stroke-[3]" />
+                  </span>
+                  <span class="min-w-0">
+                    <span class="block truncate font-mono text-xs" :title="option.column">{{ option.column }}</span>
+                    <span v-if="option.comment" class="block truncate text-[11px] leading-4 text-muted-foreground" :title="option.comment">{{ option.comment }}</span>
+                  </span>
+                </button>
+                <div v-if="columnVisibilityOptions.length === 0" class="px-2 py-6 text-center text-xs text-muted-foreground">
+                  {{ t("grid.noSearchResults") }}
+                </div>
+              </div>
+              <div class="flex flex-col gap-1 border-t bg-muted/30 px-2 py-1.5">
+                <span class="text-[11px] leading-4 text-muted-foreground">{{ t("grid.columnVisibilityHint") }}</span>
+                <div class="flex items-center justify-end gap-1">
+                  <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" :disabled="(dataGridRef?.displayableColumnCount ?? 0) <= 1" @click="dataGridRef?.invertColumnVisibility()">
+                    {{ t("grid.invertColumnVisibility") }}
+                  </Button>
+                  <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" :disabled="!dataGridRef?.hasCustomColumnOrder" @click="dataGridRef?.resetColumnOrder()">
+                    {{ t("grid.resetColumnOrder") }}
+                  </Button>
+                  <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" :disabled="(dataGridRef?.hiddenColumnCount ?? 0) === 0" @click="dataGridRef?.showAllColumns()">
+                    {{ t("grid.showAllColumns") }}
+                  </Button>
+                </div>
+              </div>
+            </PopoverContent>
+          </Popover>
+          <Button v-if="activeTab.result && activeTab.tableMeta && activeTab.connectionId" variant="ghost" size="sm" class="h-5 text-xs px-1.5 shrink-0" :class="{ 'bg-accent': dataGridRef?.showDdl }" @click="dataGridRef?.toggleDdl()"
+            ><TableProperties class="h-3.5 w-3.5" />{{ t("grid.tableInfo") }}</Button
+          >
+          <DropdownMenu v-if="activeTab.result && activeTab.tableMeta && activeTab.connectionId">
+            <DropdownMenuTrigger as-child>
+              <Button variant="ghost" size="sm" class="h-5 text-xs px-1.5 shrink-0" :title="t('tableToolbox.title')"><Toolbox class="h-3.5 w-3.5" />{{ t("tableToolbox.title") }}</Button>
+            </DropdownMenuTrigger>
+            <DropdownMenuContent align="end" class="w-max min-w-44 gap-0 overflow-hidden rounded-xl border bg-popover p-0 text-popover-foreground shadow-xl">
+              <div class="border-b bg-muted/40 px-3 py-2">
+                <div class="text-xs font-semibold">{{ t("tableToolbox.title") }}</div>
+              </div>
+              <div class="p-1">
+                <DropdownMenuItem class="gap-2" @click="handleTableDataGenerate">
+                  <Database class="h-4 w-4" />
+                  {{ t("tableToolbox.generateData") }}
+                </DropdownMenuItem>
+                <DropdownMenuItem class="gap-2" @click="handleTableImport">
+                  <Download class="h-4 w-4" />
+                  {{ t("tableToolbox.importData") }}
+                </DropdownMenuItem>
+                <DropdownMenuSub>
+                  <DropdownMenuSubTrigger class="gap-2">
+                    <Upload class="h-4 w-4" />
+                    {{ t("tableToolbox.exportData") }}
+                  </DropdownMenuSubTrigger>
+                  <DropdownMenuPortal>
+                    <DropdownMenuSubContent>
+                      <DropdownMenuItem @click="dataGridRef?.exportCsv()"> CSV </DropdownMenuItem>
+                      <DropdownMenuItem @click="dataGridRef?.exportJson()"> JSON </DropdownMenuItem>
+                      <DropdownMenuItem @click="dataGridRef?.exportSql()"> SQL INSERT </DropdownMenuItem>
+                      <DropdownMenuItem @click="dataGridRef?.exportXlsx()"> XLSX </DropdownMenuItem>
+                    </DropdownMenuSubContent>
+                  </DropdownMenuPortal>
+                </DropdownMenuSub>
+              </div>
+            </DropdownMenuContent>
+          </DropdownMenu>
+          <Popover v-if="activeTab.result?.columns.length">
+            <PopoverTrigger as-child>
+              <Button variant="ghost" size="icon" class="h-6 w-7 shrink-0 text-foreground hover:bg-accent" :title="t('grid.viewOptions')" :aria-label="t('grid.viewOptions')">
+                <Wrench class="h-4 w-4" />
+              </Button>
+            </PopoverTrigger>
+            <PopoverContent align="end" class="w-max min-w-44 max-w-[calc(100vw-2rem)] gap-0 overflow-hidden rounded-xl border bg-popover p-0 text-popover-foreground shadow-xl" @click.stop @keydown.stop>
+              <div class="border-b bg-muted/40 px-3 py-2">
+                <div class="text-xs font-semibold">{{ t("grid.viewOptions") }}</div>
+              </div>
+              <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs">
+                <div class="min-w-0 flex items-center gap-2 font-medium">
+                  <SquareDashed class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                  <span>{{ t("grid.renderMode") }}</span>
+                </div>
+                <LightTooltip :text="t('grid.renderModeHint')" side="left" :side-offset="6" :delay="0" :open-on-focus="false">
+                  <div class="grid w-32 grid-cols-2 rounded-md border bg-muted/40 p-0.5">
+                    <button
+                      type="button"
+                      class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                      :class="dataGridRenderMode === 'canvas' ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                      @click="setDataGridRenderMode('canvas')"
+                    >
+                      {{ t("grid.canvasRenderMode") }}
+                    </button>
+                    <button
+                      type="button"
+                      class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                      :class="dataGridRenderMode === 'dom' ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                      @click="setDataGridRenderMode('dom')"
+                    >
+                      {{ t("grid.domRenderMode") }}
+                    </button>
+                  </div>
+                </LightTooltip>
+              </div>
+              <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs">
+                <div class="min-w-0 flex items-center gap-2 font-medium">
+                  <Columns3Cog class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                  <span>{{ t("grid.columnWidth") }}</span>
+                </div>
+                <div class="grid w-48 grid-cols-3 rounded-md border bg-muted/40 p-0.5">
+                  <button
+                    v-for="density in ['compact', 'standard', 'comfortable'] as const"
+                    :key="density"
+                    type="button"
+                    class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-1.5 text-xs transition-colors"
+                    :class="columnWidthDensity === density ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                    @click="setColumnWidthDensity(density)"
+                  >
+                    {{ t(`grid.columnWidth${density.charAt(0).toUpperCase()}${density.slice(1)}`) }}
+                  </button>
+                </div>
+              </div>
+              <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs">
+                <div class="min-w-0 flex items-center gap-2 font-medium">
+                  <span class="flex h-3.5 w-3.5 shrink-0 items-center justify-center text-[11px] font-semibold text-muted-foreground">A</span>
+                  <span>{{ t("grid.tableFontSize") }}</span>
+                </div>
+                <div class="flex h-6 w-32 items-center rounded-md border bg-muted/40 p-0.5">
+                  <button
+                    type="button"
+                    class="flex h-5 w-8 items-center justify-center rounded-[5px] bg-background text-foreground shadow-sm transition-colors hover:text-foreground disabled:pointer-events-none disabled:bg-muted/40 disabled:text-muted-foreground disabled:opacity-50 disabled:shadow-none"
+                    :disabled="tableFontSize <= TABLE_FONT_SIZE_MIN"
+                    :aria-label="t('common.decrease')"
+                    @click="decreaseTableFontSize"
+                  >
+                    <Minus class="h-3.5 w-3.5" />
+                  </button>
+                  <span class="flex-1 text-center text-xs font-semibold tabular-nums">{{ tableFontSize }}</span>
+                  <button
+                    type="button"
+                    class="flex h-5 w-8 items-center justify-center rounded-[5px] bg-background text-foreground shadow-sm transition-colors hover:text-foreground disabled:pointer-events-none disabled:bg-muted/40 disabled:text-muted-foreground disabled:opacity-50 disabled:shadow-none"
+                    :disabled="tableFontSize >= TABLE_FONT_SIZE_MAX"
+                    :aria-label="t('common.increase')"
+                    @click="increaseTableFontSize"
+                  >
+                    <Plus class="h-3.5 w-3.5" />
+                  </button>
+                </div>
+              </div>
+              <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs">
+                <div class="min-w-0 flex items-center gap-2 font-medium">
+                  <Search class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                  <span>{{ t("grid.searchMode") }}</span>
+                </div>
+                <LightTooltip :text="t('grid.searchModeHint')" side="left" :side-offset="6" :delay="0" :open-on-focus="false">
+                  <div class="grid w-32 grid-cols-2 rounded-md border bg-muted/40 p-0.5">
+                    <button
+                      type="button"
+                      class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                      :class="dataGridSearchMode === 'filter' ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                      @click="setDataGridSearchMode('filter')"
+                    >
+                      {{ t("grid.searchModeFilter") }}
+                    </button>
+                    <button
+                      type="button"
+                      class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                      :class="dataGridSearchMode === 'highlight' ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                      @click="setDataGridSearchMode('highlight')"
+                    >
+                      {{ t("grid.searchModeHighlight") }}
+                    </button>
+                  </div>
+                </LightTooltip>
+              </div>
+              <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs">
+                <div class="min-w-0 flex items-center gap-2 font-medium">
+                  <Rows3 class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                  <span>{{ t("grid.transposeMultiRowToggle") }}</span>
+                </div>
+                <LightTooltip :text="t('grid.transposeMultiRowHint')" side="left" :side-offset="6" :delay="0" :open-on-focus="false">
+                  <div class="grid w-32 grid-cols-2 rounded-md border bg-muted/40 p-0.5">
+                    <button
+                      type="button"
+                      class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                      :class="!dataGridRef?.multiRowTranspose ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                      @click="dataGridRef?.setMultiRowTranspose(false)"
+                    >
+                      {{ t("grid.transposeSingleRow") }}
+                    </button>
+                    <button
+                      type="button"
+                      class="h-5 min-w-0 truncate whitespace-nowrap rounded-[5px] px-2 text-xs transition-colors"
+                      :class="dataGridRef?.multiRowTranspose ? 'bg-background font-semibold text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'"
+                      @click="dataGridRef?.setMultiRowTranspose(true)"
+                    >
+                      {{ t("grid.transposeMultiRow") }}
+                    </button>
+                  </div>
+                </LightTooltip>
+              </div>
+              <div class="flex items-center justify-between gap-3 px-3 py-1.5 text-xs" :class="{ 'opacity-60': !dataGridRef?.canToggleAllNullColumns }">
+                <span class="min-w-0 flex items-center gap-2 font-medium">
+                  <EyeOff class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                  {{ t("grid.hideNullColumns") }}
+                  <span v-if="(dataGridRef?.allNullColumnCount ?? 0) > 0" class="text-muted-foreground tabular-nums"> ({{ dataGridRef?.allNullColumnCount }}) </span>
+                </span>
+                <Switch size="sm" :model-value="!!dataGridRef?.nullColumnsHidden" :disabled="!dataGridRef?.canToggleAllNullColumns" :aria-label="t('grid.hideNullColumns')" @update:model-value="dataGridRef?.toggleAllNullColumns()" />
+              </div>
+            </PopoverContent>
+          </Popover>
+        </div>
+        <DataGrid
+          v-if="activeTab.result"
+          ref="dataGridRef"
+          class="flex-1 min-h-0"
+          :key="activeTab.id"
+          :cache-key="activeTab.id"
+          :result="activeTab.result"
+          :sort-column="activeTab.resultSortColumn"
+          :sort-column-index="activeTab.resultSortColumnIndex"
+          :sort-direction="activeTab.resultSortDirection"
+          :sort-mode="activeTab.resultSortMode"
+          :initial-order-by-input="activeTab.orderByInput"
+          :sql="activeTab.sql"
+          :loading="activeTab.isExecuting"
+          :editable="isTableDataEditable(activeEffectiveDatabaseType, activeTableMeta?.primaryKeys ?? [], activeTableMeta?.tableType)"
+          context="table-data"
+          :initial-where-input="activeTab.whereInput"
+          :database-type="activeEffectiveDatabaseType"
+          :connection-id="activeTab.connectionId"
+          :database="activeTab.database"
+          :catalog="activeTab.objectBrowser?.catalog"
+          :execution-database="activeDataTabExecutionDatabase"
+          :table-meta="activeDataTabTableMeta"
+          :table-info-tab="activeTab.tableInfoTab"
+          :page-offset="activeTab.resultPageOffset"
+          :page-limit="activeTab.resultPageLimit"
+          :total-row-count="activeTab.resultTotalRowCount"
+          :total-row-count-loading="activeTab.resultTotalRowCountLoading"
+          :on-execute-sql="async (sql: string) => emit('executeSql', sql)"
+          :full-export-result="(onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void) => queryStore.fetchTabResultForExport(activeTab.id, onProgress)"
+          :export-file-base-name="activeTab.title"
+          @update:where-input="(v: string) => (activeTab.whereInput = v)"
+          @update:order-by-input="(v: string) => (activeTab.orderByInput = v)"
+          @reload="(sql?: string, searchText?: string, whereInput?: string, orderBy?: string, limit?: number, offset?: number, intent?: DataGridReloadIntent) => emit('reload', sql, searchText, whereInput, orderBy, limit, offset, intent)"
+          @paginate="(offset: number, limit: number, whereInput?: string, orderBy?: string) => emit('paginate', offset, limit, whereInput, orderBy)"
+          @sort="(column: string, columnIndex: number, direction: 'asc' | 'desc' | null, whereInput?: string, mode?: DataGridSortMode) => emit('sort', column, columnIndex, direction, whereInput, mode)"
+        >
+          <template v-if="activeTab.result?.columns.includes('Error')" #error-actions="{ errorMessage }">
+            <QueryErrorActions :error-message="String(errorMessage)" :connection-id="activeTab.connectionId" @change-query-timeout="activeTab.connectionId && emit('openConnectionSettings', activeTab.connectionId, 'advanced')" @fix-with-ai="(message) => emit('fixWithAi', message)" />
+          </template>
+        </DataGrid>
+        <QueryLoadingState v-else-if="activeTab.isExecuting" class="h-full" :label-key="queryExecutionLabelKey(activeTab)" :elapsed-seconds="queryRunningElapsedSeconds" show-cancel :cancel-disabled="!canCancelQueryExecution(activeTab)" :cancelling="activeTab.isCancelling" @cancel="emit('cancel')" />
+        <div v-else class="h-full flex flex-col items-center justify-center gap-3 text-muted-foreground text-sm">
+          <Inbox class="h-8 w-8 opacity-60" />
+          <div>{{ t("grid.dataUnavailable") }}</div>
+          <div class="text-xs text-muted-foreground/70 inline-flex items-center gap-1">
+            <span>{{ t("grid.dataUnavailableHintPrefix") }}</span>
+            <kbd v-for="key in modRKeys" :key="key" class="min-w-5 rounded border border-border/60 bg-muted/50 px-1.5 py-0.5 text-center font-mono text-[12px] leading-none text-muted-foreground shadow-xs">{{ key }}</kbd>
+            <span>{{ t("grid.dataUnavailableHintSuffix") }}</span>
+          </div>
+          <Button variant="outline" size="sm" class="h-7 gap-1.5" @click="emit('reload')">
+            <RefreshCcw class="h-3.5 w-3.5" />
+            {{ t("grid.refresh") }}
+          </Button>
+        </div>
+      </div>
+    </template>
+
+    <!-- Redis mode: key browser -->
+    <template v-else-if="activeTab.mode === 'redis'">
+      <div class="flex-1 min-h-0">
+        <RedisKeyBrowser ref="redisKeyBrowserRef" :key="activeTab.id" :connection-id="activeTab.connectionId" :db="Number(activeTab.database)" :block-dangerous-redis-commands="props.blockDangerousRedisCommands" />
+      </div>
+    </template>
+
+    <!-- Redis Dashboard: instance info -->
+    <template v-else-if="activeTab.mode === 'redis-dashboard'">
+      <div class="flex-1 min-h-0">
+        <RedisDashboard :key="activeTab.id" :connection-id="activeTab.connectionId" />
+      </div>
+    </template>
+
+    <!-- etcd mode: key browser -->
+    <template v-else-if="activeTab.mode === 'etcd'">
+      <div class="flex-1 min-h-0">
+        <EtcdKeyBrowser ref="etcdKeyBrowserRef" :key="activeTab.id" :connection-id="activeTab.connectionId" />
+      </div>
+    </template>
+
+    <!-- ZooKeeper mode: znode browser -->
+    <template v-else-if="activeTab.mode === 'zookeeper'">
+      <div class="flex-1 min-h-0">
+        <ZooKeeperKeyBrowser ref="zookeeperKeyBrowserRef" :key="activeTab.id" :connection-id="activeTab.connectionId" />
+      </div>
+    </template>
+
+    <!-- Document mode: MongoDB collections and Elasticsearch indices -->
+    <template v-else-if="activeTab.mode === 'mongo'">
+      <div class="flex-1 min-h-0">
+        <DocumentBrowser :key="activeTab.id" :connection-id="activeTab.connectionId" :database="activeTab.database" :collection="activeTab.sql" :database-type="activeEffectiveDatabaseType" />
+      </div>
+    </template>
+
+    <template v-else-if="activeTab.mode === 'mongo-gridfs'">
+      <div class="flex-1 min-h-0">
+        <MongoGridFsBrowser :key="activeTab.id" :connection-id="activeTab.connectionId" :database="activeTab.database" />
+      </div>
+    </template>
+
+    <template v-else-if="activeTab.mode === 'mongo-bucket'">
+      <div class="flex-1 min-h-0">
+        <MongoBucketBrowser :key="activeTab.id" :connection-id="activeTab.connectionId" :database="activeTab.database" :bucket="activeTab.mongoBucket?.bucketName || activeTab.sql" />
+      </div>
+    </template>
+
+    <!-- Vector mode: Qdrant and Milvus collections -->
+    <template v-else-if="activeTab.mode === 'vector'">
+      <div class="flex-1 min-h-0">
+        <VectorBrowser :key="activeTab.id" :connection-id="activeTab.connectionId" :database="activeTab.database" :collection="activeTab.sql" :collection-label="activeTab.title" :database-type="activeEffectiveDatabaseType" :dimension="activeTabDimension" />
+      </div>
+    </template>
+
+    <template v-else-if="activeTab.mode === 'mq'">
+      <div class="flex-1 min-h-0">
+        <MqAdminConsole :key="activeTab.id" :connection-id="activeTab.connectionId" :initial-tenant="activeTab.mqTenant" :initial-tab="activeTab.mqInitialTab" :read-only="activeConnection?.read_only ?? false" />
+      </div>
+    </template>
+
+    <template v-else-if="activeTab.mode === 'nacos'">
+      <div class="flex-1 min-h-0">
+        <NacosAdminConsole :key="activeTab.id" :connection-id="activeTab.connectionId" :namespace="activeTab.nacosNamespace" :namespace-name="activeTab.nacosNamespaceName" :read-only="activeConnection?.read_only ?? false" />
+      </div>
+    </template>
+
+    <!-- Objects mode: virtualized database object browser -->
+    <template v-else-if="activeTab.mode === 'objects' && activeConnection">
+      <div class="min-w-0 flex-1 min-h-0">
+        <ObjectBrowser
+          ref="objectBrowserRef"
+          :key="`${activeTab.id}-${activeTab.objectBrowser?.schema || ''}`"
+          :connection="activeConnection"
+          :database="activeTab.database"
+          :schema="activeTab.objectBrowser?.schema"
+          :viewport="activeTab.objectBrowser?.viewport"
+          @open-table="emit('openObjectTable', $event)"
+          @schema-change="emit('objectSchemaChange', $event)"
+          @viewport-change="emit('objectBrowserViewportChange', activeTab.id, $event)"
+        />
+      </div>
+    </template>
+
+    <!-- Structure mode: table structure editor -->
+    <template v-else-if="activeTab.mode === 'structure'">
+      <TableStructureEditor
+        :key="activeTab.id"
+        :connection-id="activeTab.connectionId"
+        :database="activeTab.database"
+        :schema="activeTab.schema"
+        :table-name="activeTab.structureTableName || ''"
+        :initial-tab="activeTab.structureInitialTab"
+        :initial-tab-request-id="activeTab.structureInitialTabRequestId"
+        :initial-target="activeTab.structureInitialTarget"
+        :draft="activeTab.structureDraft"
+        @update:draft="(draft) => (activeTab.structureDraft = draft)"
+        @saved="(commentChanged) => emit('structureEditorSaved', commentChanged)"
+        @close="emit('structureEditorClose')"
+        @open-settings="(initialTab, initialSection) => emit('openSettings', initialTab, initialSection)"
+      />
+    </template>
+
+    <template v-else-if="activeTab.mode === 'users' && activeConnection">
+      <DatabaseUserAdmin :key="activeTab.id" :connection="activeConnection" />
+    </template>
+
+    <template v-else-if="activeTab.mode === 'dameng-jobs' && activeConnection">
+      <DamengJobAdmin :key="activeTab.id" :connection="activeConnection" />
+    </template>
+  </div>
+</template>
+
+<style scoped>
+.query-output-splitpanes {
+  isolation: isolate;
+}
+
+.production-session-shell--active {
+  box-shadow: inset 3px 0 0 color-mix(in oklch, var(--destructive) 78%, transparent);
+}
+
+.production-session-strip {
+  background-image: linear-gradient(90deg, color-mix(in oklch, var(--destructive) 14%, transparent), color-mix(in oklch, var(--destructive) 7%, transparent));
+}
+
+.query-output-splitpanes :deep(> .splitpanes__splitter) {
+  z-index: 1;
+  flex: 0 0 3px;
+}
+
+.production-watermark {
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  grid-template-rows: repeat(2, minmax(0, 1fr));
+  gap: 3rem;
+  overflow: hidden;
+  padding: 3rem 2.5rem;
+}
+
+.production-watermark__label {
+  align-self: center;
+  justify-self: center;
+  transform: rotate(-22deg);
+}
+
+@media (max-width: 700px) {
+  .production-watermark {
+    grid-template-columns: 1fr;
+    gap: 1.5rem;
+    padding-inline: 1rem;
+  }
+}
+
+.result-tab-scroll::-webkit-scrollbar {
+  display: none;
+}
+
+.result-tab-scrollbar {
+  position: absolute;
+  inset-inline: 0.5rem;
+  bottom: 2px;
+  z-index: 20;
+  height: 8px;
+  cursor: pointer;
+  touch-action: none;
+}
+
+.result-tab-scrollbar::before {
+  content: "";
+  position: absolute;
+  inset-inline: 0;
+  top: 3px;
+  height: 2px;
+  border-radius: 999px;
+  background: color-mix(in oklch, var(--foreground) 10%, transparent);
+}
+
+.result-tab-scrollbar__thumb {
+  position: absolute;
+  top: 2px;
+  height: 4px;
+  min-width: 20px;
+  border-radius: 999px;
+  background: color-mix(in oklch, var(--foreground) 38%, transparent);
+  transition:
+    height 120ms ease,
+    background-color 120ms ease,
+    top 120ms ease;
+}
+
+.result-tab-scrollbar:hover .result-tab-scrollbar__thumb,
+.result-tab-scrollbar--dragging .result-tab-scrollbar__thumb {
+  top: 1px;
+  height: 6px;
+  background: color-mix(in oklch, var(--foreground) 58%, transparent);
+}
+</style>
diff --git a/apps/desktop/src/components/layout/EditorToolbar.vue b/apps/desktop/src/components/layout/EditorToolbar.vue
new file mode 100644
index 0000000..3e29b2c
--- /dev/null
+++ b/apps/desktop/src/components/layout/EditorToolbar.vue
@@ -0,0 +1,463 @@
+<script setup lang="ts">
+import { computed, ref, watch, watchEffect } from "vue";
+import { useI18n } from "vue-i18n";
+import { Play, Loader2, Square, Database, Check, Table2, AlignLeft, GitBranch, Save, FolderOpen, Layers, X, Shield, Download, RotateCcw, AlertTriangle, ClipboardPaste } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { SearchableSelect } from "@/components/ui/searchable-select";
+import { Tooltip, TooltipTrigger, TooltipContent } from "@/components/ui/tooltip";
+import TruncatedTextTooltip from "@/components/ui/TruncatedTextTooltip.vue";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import ProductionContextBadge from "@/components/common/ProductionContextBadge.vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useDatabaseOptions } from "@/composables/useDatabaseOptions";
+import { useSchemaOptions } from "@/composables/useSchemaOptions";
+import { connectionIconType } from "@/lib/connection/connectionPresentation";
+import { formatDatabaseLabel, isDefaultDatabase } from "@/lib/database/defaultDatabase";
+import { connectionDisplayName } from "@/lib/tabs/tabPresentation";
+import { isSingleDatabase, supportsSqlInListPaste, supportsTransaction as supportsTransactionFeature } from "@/lib/database/databaseCapabilities";
+import { hexToRgba } from "@/lib/common/color";
+import { productionContextForDatabase } from "@/lib/database/productionSafety";
+import type { QueryTab, ConnectionConfig } from "@/types/database";
+
+const props = defineProps<{
+  activeTab: QueryTab;
+  activeConnection?: ConnectionConfig;
+  executableSql: string;
+  explainMode?: string;
+  blockDangerousRedisCommands?: boolean;
+  sqlKeywordCase: "preserve" | "upper" | "lower";
+  databaseRequiredSignal?: number;
+  autoCommit?: boolean;
+  txnSessionId?: string;
+  txnAutoRolledBack?: boolean;
+}>();
+
+const emit = defineEmits<{
+  execute: [];
+  cancel: [];
+  explain: [];
+  "update:explainMode": [mode: "explain" | "autotrace"];
+  formatSql: [];
+  toggleSqlKeywordCase: [];
+  saveSql: [];
+  openSql: [];
+  importResultArchive: [];
+  pasteSqlInCondition: [];
+  changeConnection: [connectionId: string];
+  changeDatabase: [database: string];
+  changeSchema: [schema: string | undefined];
+  setDefaultDatabase: [];
+  clearDefaultDatabase: [];
+  "update:blockDangerousRedisCommands": [value: boolean];
+  "update:autoCommit": [value: boolean];
+  commit: [];
+  rollback: [];
+  dismissTxnRolledBack: [];
+}>();
+
+const { t } = useI18n();
+const connectionStore = useConnectionStore();
+const { databaseOptions, loadingDatabaseOptions, loadDatabaseOptions } = useDatabaseOptions();
+const { loadSchemaOptions, getSchemaOptionsForDb, isLoadingSchemas, isSchemaAware } = useSchemaOptions();
+
+const activeDatabaseOptions = computed(() => {
+  const connection = props.activeConnection;
+  return connection ? (databaseOptions.value[connection.id] ?? []) : [];
+});
+
+const connectionOptionIds = computed(() => connectionStore.connections.map((connection) => connection.id));
+const activeDatabaseValue = computed(() => props.activeTab.database || "");
+const activeProductionContext = computed(() => productionContextForDatabase(props.activeConnection, props.activeTab.database));
+const showConnectionProductionBadge = computed(() => activeProductionContext.value.reason === "connection");
+const showDatabaseProductionBadge = computed(() => activeProductionContext.value.reason === "database");
+const activeConnectionValue = computed(() => props.activeConnection?.id || "");
+const activeSchemaValue = computed(() => props.activeTab.schema || "");
+const supportsExplain = computed(() => {
+  const dbType = props.activeConnection?.db_type;
+  return dbType !== "redis" && dbType !== "mongodb" && dbType !== "elasticsearch" && dbType !== "qdrant" && dbType !== "milvus" && dbType !== "weaviate" && dbType !== "chromadb" && dbType !== "etcd" && dbType !== "zookeeper" && dbType !== "mq" && dbType !== "nacos";
+});
+const isSingleDb = computed(() => isSingleDatabase(props.activeConnection?.db_type));
+const supportsExPaste = computed(() => supportsSqlInListPaste(props.activeConnection?.db_type));
+const supportsTransaction = computed(() => supportsTransactionFeature(props.activeConnection?.db_type));
+const hasDefaultDatabaseOption = computed(() => activeDatabaseOptions.value.includes(""));
+const schemaDatabaseKey = computed(() => props.activeTab.database || (isSingleDb.value ? "_" : ""));
+const saveTooltip = computed(() => (props.activeTab.objectSource ? t("objects.saveSource") : t("toolbar.saveSql")));
+const canSaveSql = computed(() => !!props.activeTab.externalSqlPath || !!props.activeTab.sql.trim());
+const keywordCaseIsLower = computed(() => props.sqlKeywordCase === "lower");
+const keywordCaseToggleTooltip = computed(() => (keywordCaseIsLower.value ? t("toolbar.keywordCaseUpper") : t("toolbar.keywordCaseLower")));
+const transactionTooltip = computed(() => {
+  const isAgent = (props.activeConnection?.db_type as string) === "agent";
+  const isManual = props.autoCommit === false;
+  if (isAgent && isManual) return t("toolbar.manualTransactionAgent");
+  if (isAgent) return t("toolbar.autoCommitAgent");
+  return isManual ? t("toolbar.manualTransaction") : t("toolbar.autoCommit");
+});
+const executeButtonClass = computed(() => {
+  if (props.activeTab.isExecuting) return "";
+  return activeProductionContext.value.active ? "bg-red-500/10 text-red-700 hover:bg-red-500/20 hover:text-red-800 dark:text-red-300 dark:hover:text-red-200" : "bg-emerald-500/10 text-emerald-700 hover:bg-emerald-500/20 hover:text-emerald-800 dark:text-emerald-300 dark:hover:text-emerald-200";
+});
+
+const isTransactionActive = computed(() => !!props.txnSessionId);
+
+const showSchemaSelector = computed(() => {
+  const connection = props.activeConnection;
+  return connection && isSchemaAware(connection.id) && (props.activeTab.database || isSingleDb.value || hasDefaultDatabaseOption.value);
+});
+
+const activeSchemaOptions = computed(() => {
+  const connection = props.activeConnection;
+  if (!connection) return [];
+  return getSchemaOptionsForDb(connection.id, schemaDatabaseKey.value);
+});
+const databaseRequiredVisible = ref(false);
+
+watch(
+  () => props.databaseRequiredSignal,
+  (signal) => {
+    if (!signal) return;
+    databaseRequiredVisible.value = false;
+    requestAnimationFrame(() => {
+      databaseRequiredVisible.value = true;
+    });
+  },
+);
+
+watch(activeDatabaseValue, (database) => {
+  if (database) databaseRequiredVisible.value = false;
+});
+
+watchEffect(() => {
+  const connection = props.activeConnection;
+  if (connection && showSchemaSelector.value) {
+    loadSchemaOptions(connection.id, schemaDatabaseKey.value).catch(() => {});
+  }
+});
+
+const isActiveDatabaseDefault = computed(() => isDefaultDatabase(props.activeConnection, activeDatabaseValue.value));
+const toolbarStyle = computed(() => {
+  const color = props.activeConnection?.color;
+  if (!color) return undefined;
+  return {
+    backgroundColor: hexToRgba(color, 0.1),
+    boxShadow: `inset 0 1px 0 ${hexToRgba(color, 0.18)}`,
+  };
+});
+
+function databaseDisplayName(database: string): string {
+  return formatDatabaseLabel(props.activeConnection, database, {
+    defaultDatabase: t("editor.defaultDatabase"),
+    noDatabase: t("editor.noDatabase"),
+  });
+}
+
+function connectionById(connectionId: string): ConnectionConfig | undefined {
+  return connectionStore.getConfig(connectionId);
+}
+
+function databaseOptionIsProduction(database: string): boolean {
+  if (!database || props.activeConnection?.is_production) return false;
+  return productionContextForDatabase(props.activeConnection, database).reason === "database";
+}
+</script>
+
+<template>
+  <div class="app-editor-toolbar h-9 shrink-0 border-b bg-background/80 px-3 flex items-center gap-1 text-xs text-muted-foreground relative z-10" :style="toolbarStyle">
+    <div class="flex items-center gap-0.5">
+      <Tooltip>
+        <TooltipTrigger as-child>
+          <Button
+            :variant="activeTab.isExecuting ? 'destructive' : 'ghost'"
+            size="icon"
+            class="h-6 w-6"
+            :class="executeButtonClass"
+            :disabled="activeTab.isCancelling || activeTab.isExplaining || (!activeTab.isExecuting && !executableSql.trim())"
+            @click="activeTab.isExecuting ? emit('cancel') : emit('execute')"
+          >
+            <Loader2 v-if="activeTab.isCancelling" class="h-3.5 w-3.5 animate-spin" />
+            <Square v-else-if="activeTab.isExecuting" class="h-3.5 w-3.5 fill-current" />
+            <Play v-else class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ activeTab.isExecuting ? t("toolbar.stopQuery") : t("toolbar.executeShortcut") }}</TooltipContent>
+      </Tooltip>
+      <Tooltip v-if="supportsExplain">
+        <TooltipTrigger as-child>
+          <Button
+            :variant="activeTab.isExplaining ? 'destructive' : 'ghost'"
+            size="icon"
+            class="h-6 w-6"
+            :class="activeTab.isExplaining ? '' : 'text-violet-600 hover:bg-violet-500/10 hover:text-violet-700 dark:text-violet-300 dark:hover:text-violet-200'"
+            :disabled="activeTab.isExecuting || (!activeTab.isExplaining && !executableSql.trim())"
+            @click="activeTab.isExplaining ? emit('cancel') : emit('explain')"
+          >
+            <Square v-if="activeTab.isExplaining" class="h-3.5 w-3.5 fill-current" />
+            <GitBranch v-else class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ activeTab.isExplaining ? t("toolbar.stopExplain") : t("toolbar.explainPlan") }}</TooltipContent>
+      </Tooltip>
+      <!-- Autotrace toggle (only for DM) -->
+      <Button
+        v-if="activeConnection?.db_type === 'dameng'"
+        variant="ghost"
+        size="icon"
+        class="h-6 w-6"
+        :class="props.explainMode === 'autotrace' ? 'text-green-600 bg-green-100 dark:text-green-300 dark:bg-green-900/30' : 'text-muted-foreground/50'"
+        :disabled="activeTab.isExecuting"
+        @click="emit('update:explainMode', props.explainMode === 'autotrace' ? 'explain' : 'autotrace')"
+      >
+        <span class="font-bold" style="font-size: 9px">A</span>
+      </Button>
+      <!-- Transaction toggle -->
+      <Tooltip v-if="supportsTransaction">
+        <TooltipTrigger as-child>
+          <Button
+            variant="ghost"
+            size="icon"
+            class="h-6 w-6"
+            :class="isTransactionActive || autoCommit === false ? 'text-orange-600 bg-orange-100 dark:text-orange-300 dark:bg-orange-900/30' : 'text-muted-foreground/50'"
+            :disabled="activeTab.isExecuting || activeTab.isExplaining"
+            @click="emit('update:autoCommit', autoCommit === false)"
+          >
+            <span class="font-bold" style="font-size: 9px">Tx</span>
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ transactionTooltip }}</TooltipContent>
+      </Tooltip>
+      <!-- Commit button (only when transaction is active) -->
+      <Tooltip v-if="isTransactionActive">
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6 text-green-600 hover:bg-green-500/10 hover:text-green-700 dark:text-green-300 dark:hover:text-green-200" :disabled="activeTab.isExecuting" @click="emit('commit')">
+            <Check class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("toolbar.commit") }}</TooltipContent>
+      </Tooltip>
+
+      <!-- Rollback button (only when transaction is active) -->
+      <Tooltip v-if="isTransactionActive">
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6 text-red-600 hover:bg-red-500/10 hover:text-red-700 dark:text-red-300 dark:hover:text-red-200" :disabled="activeTab.isExecuting" @click="emit('rollback')">
+            <RotateCcw class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("toolbar.rollback") }}</TooltipContent>
+      </Tooltip>
+      <Tooltip>
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6 text-amber-600 hover:bg-amber-500/10 hover:text-amber-700 dark:text-amber-300 dark:hover:text-amber-200" :disabled="activeTab.isExecuting || activeTab.isExplaining || !activeTab.sql.trim()" @click="emit('formatSql')">
+            <AlignLeft class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("toolbar.formatSql") }}</TooltipContent>
+      </Tooltip>
+      <Tooltip>
+        <TooltipTrigger as-child>
+          <Button
+            variant="ghost"
+            size="icon"
+            class="h-6 w-6 font-mono text-[11px] leading-none"
+            :class="keywordCaseIsLower ? 'bg-amber-500/10 text-amber-700 hover:bg-amber-500/20 hover:text-amber-800 dark:text-amber-300 dark:hover:text-amber-200' : 'text-muted-foreground hover:bg-muted hover:text-foreground'"
+            :aria-label="keywordCaseToggleTooltip"
+            @click="emit('toggleSqlKeywordCase')"
+          >
+            {{ keywordCaseIsLower ? "a" : "A" }}
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ keywordCaseToggleTooltip }}</TooltipContent>
+      </Tooltip>
+      <Tooltip v-if="activeConnection?.db_type === 'redis'">
+        <TooltipTrigger as-child>
+          <Button
+            variant="ghost"
+            size="icon"
+            class="h-6 w-6"
+            :class="blockDangerousRedisCommands !== false ? 'text-orange-600 bg-orange-100 dark:text-orange-300 dark:bg-orange-900/30' : 'text-muted-foreground/50'"
+            @click="emit('update:blockDangerousRedisCommands', blockDangerousRedisCommands === false)"
+          >
+            <Shield class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("toolbar.blockDangerousRedisCommands") }}</TooltipContent>
+      </Tooltip>
+      <Tooltip>
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6 text-blue-600 hover:bg-blue-500/10 hover:text-blue-700 dark:text-blue-300 dark:hover:text-blue-200" :disabled="!canSaveSql" @click="emit('saveSql')">
+            <Save class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ saveTooltip }}</TooltipContent>
+      </Tooltip>
+      <Tooltip>
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6 text-sky-600 hover:bg-sky-500/10 hover:text-sky-700 dark:text-sky-300 dark:hover:text-sky-200" @click="emit('openSql')">
+            <FolderOpen class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("toolbar.openSql") }}</TooltipContent>
+      </Tooltip>
+      <Tooltip>
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6 text-cyan-600 hover:bg-cyan-500/10 hover:text-cyan-700 dark:text-cyan-300 dark:hover:text-cyan-200" @click="emit('importResultArchive')">
+            <Download class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("tabs.importResultArchive") }}</TooltipContent>
+      </Tooltip>
+      <Tooltip v-if="supportsExPaste">
+        <TooltipTrigger as-child>
+          <Button variant="ghost" size="icon" class="h-6 w-6 text-teal-600 hover:bg-teal-500/10 hover:text-teal-700 dark:text-teal-300 dark:hover:text-teal-200" @click="emit('pasteSqlInCondition')">
+            <ClipboardPaste class="h-3.5 w-3.5" />
+          </Button>
+        </TooltipTrigger>
+        <TooltipContent>{{ t("toolbar.exPasteSqlInCondition") }}</TooltipContent>
+      </Tooltip>
+    </div>
+    <span class="flex-1 min-w-0" />
+    <div class="flex items-center gap-2 shrink-0">
+      <div class="flex items-center gap-1">
+        <span v-if="activeConnection?.color" class="h-4 w-1 rounded-full shrink-0" :style="{ backgroundColor: activeConnection.color }" />
+        <SearchableSelect
+          :model-value="activeConnectionValue"
+          :options="connectionOptionIds"
+          :placeholder="t('editor.selectConnection')"
+          :search-placeholder="t('editor.searchConnection')"
+          :empty-text="t('grid.noSearchResults')"
+          :loading-text="t('common.loading')"
+          trigger-class="font-medium text-foreground"
+          :display-name="connectionDisplayName"
+          @update:model-value="(connectionId) => emit('changeConnection', connectionId)"
+        >
+          <template #trigger-label="{ label }">
+            <div v-if="activeConnection" class="flex min-w-0 items-center gap-1.5">
+              <DatabaseIcon :db-type="connectionIconType(activeConnection)" class="h-3.5 w-3.5 shrink-0" />
+              <span class="truncate">{{ label }}</span>
+              <ProductionContextBadge v-if="showConnectionProductionBadge" compact />
+            </div>
+            <span v-else class="truncate text-muted-foreground">{{ t("editor.selectConnection") }}</span>
+          </template>
+          <template #option-label="{ option, label }">
+            <div class="flex min-w-0 items-center gap-2">
+              <DatabaseIcon :db-type="connectionIconType(connectionById(option))" class="h-3.5 w-3.5 shrink-0" />
+              <TruncatedTextTooltip :text="label" class="min-w-0 flex-1" side="left" :side-offset="8" />
+            </div>
+          </template>
+        </SearchableSelect>
+      </div>
+      <div
+        v-if="activeConnection?.db_type !== 'elasticsearch' && activeConnection?.db_type !== 'qdrant' && activeConnection?.db_type !== 'milvus' && activeConnection?.db_type !== 'weaviate' && activeConnection?.db_type !== 'chromadb' && activeConnection?.db_type !== 'zookeeper' && !isSingleDb"
+        class="flex items-center gap-1"
+        :class="{ 'database-required-prompt': databaseRequiredVisible }"
+      >
+        <SearchableSelect
+          :model-value="activeDatabaseValue"
+          :options="activeDatabaseOptions.length ? activeDatabaseOptions : activeDatabaseValue ? [activeDatabaseValue] : []"
+          :placeholder="t('editor.selectDatabase')"
+          :search-placeholder="t('editor.searchDatabase')"
+          :empty-text="t('grid.noSearchResults')"
+          :loading-text="t('common.loading')"
+          :loading="loadingDatabaseOptions[activeConnection?.id || '']"
+          :display-name="databaseDisplayName"
+          trigger-class="gap-1.5"
+          @update:model-value="(database) => emit('changeDatabase', database)"
+          @update:open="
+            (open: boolean) => {
+              if (open && activeConnection) loadDatabaseOptions(activeConnection.id).catch(() => {});
+            }
+          "
+        >
+          <template #trigger-label="{ label, loading }">
+            <Database class="h-3.5 w-3.5 shrink-0" />
+            <span class="truncate">{{ loading ? t("common.loading") : label }}</span>
+            <ProductionContextBadge v-if="showDatabaseProductionBadge" compact />
+          </template>
+          <template #option-label="{ option, label }">
+            <div class="flex min-w-0 flex-1 items-center gap-1.5">
+              <TruncatedTextTooltip :text="label" class="min-w-0 flex-1" side="left" :side-offset="8" />
+              <ProductionContextBadge v-if="databaseOptionIsProduction(option)" compact />
+            </div>
+          </template>
+        </SearchableSelect>
+        <Tooltip v-if="activeDatabaseValue && !isSingleDb">
+          <TooltipTrigger as-child>
+            <Button variant="ghost" size="icon" class="h-6 w-6 text-muted-foreground hover:text-foreground" @click="emit('changeDatabase', '')">
+              <X class="h-3.5 w-3.5" />
+            </Button>
+          </TooltipTrigger>
+          <TooltipContent>{{ t("editor.clearDatabase") }}</TooltipContent>
+        </Tooltip>
+        <Button v-if="activeDatabaseValue" variant="ghost" size="sm" class="h-6 px-2 text-[11px]" @click="isActiveDatabaseDefault ? emit('clearDefaultDatabase') : emit('setDefaultDatabase')">
+          <Check v-if="isActiveDatabaseDefault" class="h-3 w-3" />
+          {{ isActiveDatabaseDefault ? t("editor.defaultDatabase") : t("editor.setDefaultDatabase") }}
+        </Button>
+      </div>
+      <div v-if="showSchemaSelector" class="flex items-center gap-1">
+        <SearchableSelect
+          :model-value="activeSchemaValue"
+          :options="activeSchemaOptions.length ? activeSchemaOptions : activeSchemaValue ? [activeSchemaValue] : []"
+          :placeholder="t('editor.selectSchema')"
+          :search-placeholder="t('editor.searchSchema')"
+          :empty-text="t('grid.noSearchResults')"
+          :loading-text="t('common.loading')"
+          :loading="!!activeConnection && isLoadingSchemas(activeConnection.id, schemaDatabaseKey)"
+          trigger-class="gap-1.5"
+          @update:model-value="(schema) => emit('changeSchema', schema || undefined)"
+          @update:open="
+            (open: boolean) => {
+              if (open && activeConnection) loadSchemaOptions(activeConnection.id, schemaDatabaseKey).catch(() => {});
+            }
+          "
+        >
+          <template #trigger-label="{ label, loading }">
+            <Layers class="h-3.5 w-3.5 shrink-0" />
+            <span class="truncate">{{ loading ? t("common.loading") : label }}</span>
+          </template>
+          <template #option-label="{ label }">
+            <TruncatedTextTooltip :text="label" class="min-w-0 flex-1" side="left" :side-offset="8" />
+          </template>
+        </SearchableSelect>
+      </div>
+    </div>
+    <div v-if="activeTab.mode === 'data' && activeTab.tableMeta" class="ml-2 inline-flex shrink-0 items-center gap-1 rounded border border-border bg-muted/30 px-2 py-0.5 font-medium text-muted-foreground tabular-nums">
+      <Table2 class="h-3.5 w-3.5 shrink-0" />
+      <span class="truncate">{{ activeTab.tableMeta.columns.length }} {{ t("tree.columns") }}</span>
+    </div>
+  </div>
+  <div v-if="txnAutoRolledBack" class="flex items-center gap-2 px-3 py-1 text-xs bg-amber-500/10 text-amber-700 dark:text-amber-300 border-b border-amber-500/20">
+    <AlertTriangle class="h-3.5 w-3.5 shrink-0" />
+    <span>{{ t("toolbar.txnAutoRolledBack") }}</span>
+    <Button variant="ghost" size="icon" class="h-5 w-5 ml-auto" @click="emit('dismissTxnRolledBack')">
+      <X class="h-3 w-3" />
+    </Button>
+  </div>
+</template>
+
+<style scoped>
+.database-required-prompt {
+  color: var(--destructive);
+  animation: database-required-shake 420ms ease;
+}
+
+.database-required-prompt :deep(button) {
+  color: var(--destructive);
+  border-color: color-mix(in oklch, var(--destructive) 55%, transparent);
+  background: color-mix(in oklch, var(--destructive) 10%, transparent);
+}
+
+@keyframes database-required-shake {
+  0%,
+  100% {
+    transform: translateX(0);
+  }
+  12%,
+  36%,
+  60% {
+    transform: translateX(-3px);
+  }
+  24%,
+  48%,
+  72% {
+    transform: translateX(3px);
+  }
+}
+</style>
diff --git a/apps/desktop/src/components/layout/QueryResultToolbarActions.vue b/apps/desktop/src/components/layout/QueryResultToolbarActions.vue
new file mode 100644
index 0000000..caa264b
--- /dev/null
+++ b/apps/desktop/src/components/layout/QueryResultToolbarActions.vue
@@ -0,0 +1,65 @@
+<script setup lang="ts">
+import { GitBranch, Loader2, Upload } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import LightTooltip from "@/components/ui/LightTooltip.vue";
+
+type OutputView = "result" | "summary" | "explain" | "chart";
+
+withDefaults(
+  defineProps<{
+    activeView: OutputView;
+    canShowExplain: boolean;
+    canExportArchive: boolean;
+    archiveExporting: boolean;
+    compact?: boolean;
+  }>(),
+  { compact: false },
+);
+
+const emit = defineEmits<{
+  selectExplain: [];
+  exportArchive: [];
+}>();
+
+const { t } = useI18n();
+</script>
+
+<template>
+  <div data-query-result-toolbar-actions class="flex shrink-0 items-center gap-1 border-r px-1">
+    <LightTooltip :text="t('explain.title')" :disabled="!compact" side="bottom" :delay="0" :close-delay="0" nowrap>
+      <Button
+        size="sm"
+        :variant="activeView === 'explain' ? 'secondary' : 'ghost'"
+        class="h-5 shrink-0 text-xs leading-none"
+        :class="compact ? 'w-6 gap-0 px-0' : 'gap-1 px-2'"
+        :title="t('explain.title')"
+        :aria-label="t('explain.title')"
+        :aria-pressed="activeView === 'explain'"
+        :disabled="!canShowExplain"
+        @click="emit('selectExplain')"
+      >
+        <GitBranch class="block h-3.5 w-3.5 self-center" />
+        <span v-if="!compact" class="inline-flex h-4 items-center leading-none">{{ t("explain.title") }}</span>
+      </Button>
+    </LightTooltip>
+
+    <LightTooltip v-if="canExportArchive" :text="t('tabs.exportResultArchive')" :disabled="!compact" side="bottom" :delay="0" :close-delay="0" nowrap>
+      <Button
+        variant="ghost"
+        size="sm"
+        class="h-5 shrink-0 text-xs leading-none text-muted-foreground hover:text-foreground"
+        :class="compact ? 'w-6 gap-0 px-0' : 'gap-1 px-2'"
+        :title="t('tabs.exportResultArchive')"
+        :aria-label="t('tabs.exportResultArchive')"
+        :aria-busy="archiveExporting"
+        :disabled="archiveExporting"
+        @click="emit('exportArchive')"
+      >
+        <Loader2 v-if="archiveExporting" class="block h-3.5 w-3.5 self-center animate-spin" />
+        <Upload v-else class="block h-3.5 w-3.5 self-center" />
+        <span v-if="!compact" class="inline-flex h-4 items-center leading-none">{{ t("tabs.exportResultArchive") }}</span>
+      </Button>
+    </LightTooltip>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/layout/QueryResultViewSwitcher.vue b/apps/desktop/src/components/layout/QueryResultViewSwitcher.vue
new file mode 100644
index 0000000..e90347c
--- /dev/null
+++ b/apps/desktop/src/components/layout/QueryResultViewSwitcher.vue
@@ -0,0 +1,73 @@
+<script setup lang="ts">
+import { BarChart3, ListChecks } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import LightTooltip from "@/components/ui/LightTooltip.vue";
+
+type OutputView = "result" | "summary" | "explain" | "chart";
+type PrimaryResultView = Exclude<OutputView, "explain">;
+
+const props = withDefaults(
+  defineProps<{
+    activeView: OutputView;
+    canShowResult: boolean;
+    canShowSummary: boolean;
+    canShowChart: boolean;
+    compact?: boolean;
+  }>(),
+  { compact: false },
+);
+
+const emit = defineEmits<{
+  selectView: [view: PrimaryResultView];
+}>();
+
+const { t } = useI18n();
+
+function selectView(view: PrimaryResultView) {
+  if (props.activeView === view) return;
+  emit("selectView", view);
+}
+</script>
+
+<template>
+  <div data-query-result-view-switcher class="flex shrink-0 items-center gap-1 px-1">
+    <Button size="sm" :variant="activeView === 'result' ? 'secondary' : 'ghost'" class="h-5 shrink-0 px-2 text-xs leading-none" :disabled="!canShowResult" :aria-pressed="activeView === 'result'" @click="selectView('result')">
+      <span class="inline-flex h-4 items-center leading-none">{{ t("tabs.tableData") }}</span>
+    </Button>
+
+    <LightTooltip :text="t('tabs.executionSummary')" :disabled="!compact" side="bottom" :delay="0" :close-delay="0" nowrap>
+      <Button
+        size="sm"
+        :variant="activeView === 'summary' ? 'secondary' : 'ghost'"
+        class="h-5 shrink-0 text-xs leading-none"
+        :class="compact ? 'w-6 gap-0 px-0' : 'gap-1 px-2'"
+        :title="t('tabs.executionSummary')"
+        :aria-label="t('tabs.executionSummary')"
+        :aria-pressed="activeView === 'summary'"
+        :disabled="!canShowSummary"
+        @click="selectView('summary')"
+      >
+        <ListChecks class="block h-3.5 w-3.5 self-center" />
+        <span v-if="!compact" class="inline-flex h-4 items-center leading-none">{{ t("tabs.executionSummary") }}</span>
+      </Button>
+    </LightTooltip>
+
+    <LightTooltip :text="t('chart.title')" :disabled="!compact" side="bottom" :delay="0" :close-delay="0" nowrap>
+      <Button
+        size="sm"
+        :variant="activeView === 'chart' ? 'secondary' : 'ghost'"
+        class="h-5 shrink-0 text-xs leading-none"
+        :class="compact ? 'w-6 gap-0 px-0' : 'gap-1 px-2'"
+        :title="t('chart.title')"
+        :aria-label="t('chart.title')"
+        :aria-pressed="activeView === 'chart'"
+        :disabled="!canShowChart"
+        @click="selectView('chart')"
+      >
+        <BarChart3 class="block h-3.5 w-3.5 self-center" />
+        <span v-if="!compact" class="inline-flex h-4 items-center leading-none">{{ t("chart.title") }}</span>
+      </Button>
+    </LightTooltip>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/layout/SqlFilePanel.vue b/apps/desktop/src/components/layout/SqlFilePanel.vue
new file mode 100644
index 0000000..fcc1619
--- /dev/null
+++ b/apps/desktop/src/components/layout/SqlFilePanel.vue
@@ -0,0 +1,467 @@
+<script setup lang="ts">
+import { ref, computed, onMounted } from "vue";
+import { useI18n } from "vue-i18n";
+import { FolderOpen, FileCode, FolderClosed, ChevronRight, ChevronDown, X, Trash2, RefreshCw, FolderSearch, Copy, Play, ChevronsUpDown, ChevronsDownUp } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import LightTooltip from "@/components/ui/LightTooltip.vue";
+import CustomContextMenu, { type ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
+import { useQueryStore } from "@/stores/queryStore";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useToast } from "@/composables/useToast";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+import { resolveDefaultDatabase } from "@/lib/database/defaultDatabase";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import * as api from "@/lib/backend/api";
+import type { SqlFileEntry } from "@/lib/backend/api";
+
+const STORAGE_KEY = "dbx-sql-file-folders";
+
+const emit = defineEmits<{
+  close: [];
+}>();
+
+const { t } = useI18n();
+const queryStore = useQueryStore();
+const connectionStore = useConnectionStore();
+const { toast } = useToast();
+
+interface FolderState {
+  path: string;
+  entries: SqlFileEntry[];
+  expanded: Set<string>;
+  loading: boolean;
+  collapsed: boolean;
+}
+
+const folders = ref<FolderState[]>([]);
+
+// Right-click target. `kind` discriminates between a folder header, a tree
+// directory entry, and a tree file entry. `folderPath` is the owning top-level
+// folder (for refresh scoping); `entryPath` is the right-clicked node path.
+type ContextTarget = { kind: "panel" } | { kind: "folderHeader"; folderPath: string } | { kind: "dir"; folderPath: string; entry: SqlFileEntry } | { kind: "file"; folderPath: string; entry: SqlFileEntry };
+
+const contextTarget = ref<ContextTarget | null>(null);
+
+// The currently highlighted tree row (file or folder path). Set on click or
+// right-click so the user sees which item an opened context menu refers to.
+const selectedPath = ref<string | null>(null);
+
+function selectPath(path: string | null) {
+  selectedPath.value = path;
+}
+
+function loadSavedFolders(): string[] {
+  try {
+    const raw = safeLocalStorageGet(STORAGE_KEY);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((p): p is string => typeof p === "string") : [];
+  } catch {
+    return [];
+  }
+}
+
+function saveFolders() {
+  const paths = folders.value.map((f) => f.path);
+  safeLocalStorageSet(STORAGE_KEY, JSON.stringify(paths));
+}
+
+async function pickFolder() {
+  if (!isTauriRuntime()) {
+    toast(t("sqlFileTree.desktopOnly"), 3000);
+    return;
+  }
+  try {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const selected = await open({ directory: true, multiple: false });
+    if (!selected) return;
+    const folderPath = selected as string;
+    if (folders.value.some((f) => f.path === folderPath)) {
+      toast(t("sqlFileTree.folderAlreadyOpen"), 2000);
+      return;
+    }
+    await addFolder(folderPath);
+  } catch (e: any) {
+    toast(t("sqlFileTree.openFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function addFolder(folderPath: string) {
+  const folder: FolderState = {
+    path: folderPath,
+    entries: [],
+    expanded: new Set(),
+    loading: true,
+    collapsed: false,
+  };
+  folders.value.push(folder);
+  saveFolders();
+  await loadFolderEntries(folderPath);
+}
+
+// Re-scan a single top-level folder and replace its entries. Mutated via the
+// reactive proxy (folders.value[idx]) so Vue tracks the change — see the note
+// in addFolder above.
+async function loadFolderEntries(folderPath: string) {
+  const idx = folders.value.findIndex((f) => f.path === folderPath);
+  if (idx === -1) return;
+  folders.value[idx].loading = true;
+  try {
+    const entries = await api.listSqlFilesInFolder(folderPath);
+    const target = folders.value.findIndex((f) => f.path === folderPath);
+    if (target !== -1) {
+      folders.value[target].entries = entries;
+      // Drop expand state for paths that no longer exist after the refresh so
+      // stale entries don't keep phantom directories open.
+      const stillPresent = new Set<string>();
+      collectPaths(entries, stillPresent);
+      const nextExpanded = new Set<string>();
+      for (const p of folders.value[target].expanded) {
+        if (stillPresent.has(p)) nextExpanded.add(p);
+      }
+      folders.value[target].expanded = nextExpanded;
+    }
+  } catch (e: any) {
+    toast(t("sqlFileTree.loadFailed", { message: e?.message || String(e) }), 5000);
+  } finally {
+    const target = folders.value.findIndex((f) => f.path === folderPath);
+    if (target !== -1) {
+      folders.value[target].loading = false;
+    }
+  }
+}
+
+function collectPaths(entries: SqlFileEntry[], into: Set<string>) {
+  for (const e of entries) {
+    into.add(e.path);
+    if (e.is_dir && e.children.length) collectPaths(e.children, into);
+  }
+}
+
+async function refreshFolder(folderPath: string) {
+  await loadFolderEntries(folderPath);
+  toast(t("sqlFileTree.refreshed"), 1500);
+}
+
+async function refreshAll() {
+  await Promise.all(folders.value.map((f) => loadFolderEntries(f.path)));
+  toast(t("sqlFileTree.refreshed"), 1500);
+}
+
+async function removeFolder(index: number) {
+  folders.value.splice(index, 1);
+  saveFolders();
+}
+
+async function revealInFileManager(path: string) {
+  if (!isTauriRuntime()) {
+    toast(t("sqlFileTree.desktopOnly"), 3000);
+    return;
+  }
+  try {
+    await api.revealPathInFileManager(path);
+  } catch (e: any) {
+    toast(t("sqlFileTree.revealFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function copyPath(path: string) {
+  try {
+    await copyToClipboard(path);
+    toast(t("sqlFileTree.pathCopied"), 1500);
+  } catch {
+    toast(t("sqlFileTree.copyFailed"), 3000);
+  }
+}
+
+function toggleExpand(folder: FolderState, path: string) {
+  const next = new Set(folder.expanded);
+  if (next.has(path)) {
+    next.delete(path);
+  } else {
+    next.add(path);
+  }
+  folder.expanded = next;
+}
+
+function toggleFolderCollapse(folder: FolderState) {
+  folder.collapsed = !folder.collapsed;
+}
+
+// Expand/collapse every directory beneath the given top-level folder.
+function setAllExpanded(folder: FolderState, expanded: boolean) {
+  if (expanded) {
+    const next = new Set(folder.expanded);
+    collectDirPaths(folder.entries, next);
+    folder.expanded = next;
+  } else {
+    folder.expanded = new Set();
+  }
+}
+
+function collectDirPaths(entries: SqlFileEntry[], into: Set<string>) {
+  for (const e of entries) {
+    if (e.is_dir) {
+      into.add(e.path);
+      collectDirPaths(e.children, into);
+    }
+  }
+}
+
+async function openFile(path: string) {
+  if (!isTauriRuntime()) return;
+  try {
+    const content = await api.readExternalSqlFile(path);
+    const connectionId = connectionStore.activeConnectionId || connectionStore.connections[0]?.id || "";
+    const connection = connectionId ? connectionStore.getConfig(connectionId) : undefined;
+    const database = connection ? resolveDefaultDatabase(connection, []) : "";
+    queryStore.openExternalSqlFile(connectionId, database, path, content);
+  } catch (e: any) {
+    toast(t("toolbar.sqlOpenFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+// Open the App-level SQL file execution dialog with this file pre-selected so
+// the user can review its statements and pick a connection/database before run.
+function executeFile(path: string) {
+  connectionStore.sqlFileSource = {
+    connectionId: connectionStore.activeConnectionId || connectionStore.connections[0]?.id || "",
+    database: "",
+    filePath: path,
+  };
+}
+
+function folderName(path: string): string {
+  const normalized = path.replace(/\\/g, "/");
+  const parts = normalized.split("/").filter(Boolean);
+  return parts.pop() || path;
+}
+
+onMounted(async () => {
+  const saved = loadSavedFolders();
+  for (const path of saved) {
+    await addFolder(path);
+  }
+});
+
+type TreeEntry = { entry: SqlFileEntry; depth: number };
+function flatTree(entries: SqlFileEntry[], expanded: Set<string>): TreeEntry[] {
+  const result: TreeEntry[] = [];
+  function walk(items: SqlFileEntry[], depth: number) {
+    for (const item of items) {
+      result.push({ entry: item, depth });
+      if (item.is_dir && expanded.has(item.path)) {
+        walk(item.children, depth + 1);
+      }
+    }
+  }
+  walk(entries, 0);
+  return result;
+}
+
+// ---- context menu ----
+const contextMenuItems = computed<ContextMenuItem[]>(() => {
+  const target = contextTarget.value;
+  if (!target) return [];
+
+  if (target.kind === "panel") {
+    const items: ContextMenuItem[] = [{ label: t("sqlFileTree.openFolder"), action: pickFolder, icon: FolderOpen }];
+    if (folders.value.length > 0) {
+      items.push({ label: "", separator: true });
+      items.push({ label: t("sqlFileTree.refreshAll"), action: refreshAll, icon: RefreshCw });
+    }
+    return items;
+  }
+
+  if (target.kind === "folderHeader") {
+    const folderIdx = folders.value.findIndex((f) => f.path === target.folderPath);
+    const folder = folderIdx !== -1 ? folders.value[folderIdx] : undefined;
+    return [
+      { label: t("sqlFileTree.revealInFileManager"), action: () => revealInFileManager(target.folderPath), icon: FolderSearch },
+      { label: t("sqlFileTree.copyPath"), action: () => copyPath(target.folderPath), icon: Copy },
+      { label: "", separator: true },
+      { label: t("sqlFileTree.expandAll"), action: () => folder && setAllExpanded(folder, true), icon: ChevronsUpDown, disabled: !folder },
+      { label: t("sqlFileTree.collapseAll"), action: () => folder && setAllExpanded(folder, false), icon: ChevronsDownUp, disabled: !folder },
+      { label: "", separator: true },
+      { label: t("sqlFileTree.refreshFolder"), action: () => refreshFolder(target.folderPath), icon: RefreshCw },
+      { label: "", separator: true },
+      { label: t("sqlFileTree.removeFolder"), action: () => folderIdx !== -1 && removeFolder(folderIdx), icon: Trash2, variant: "destructive" },
+    ];
+  }
+
+  if (target.kind === "dir") {
+    return [
+      { label: t("sqlFileTree.revealInFileManager"), action: () => revealInFileManager(target.entry.path), icon: FolderSearch },
+      { label: t("sqlFileTree.copyPath"), action: () => copyPath(target.entry.path), icon: Copy },
+      { label: "", separator: true },
+      { label: t("sqlFileTree.expandAll"), action: () => expandSubtree(target), icon: ChevronsUpDown },
+      { label: t("sqlFileTree.collapseAll"), action: () => collapseSubtree(target), icon: ChevronsDownUp },
+    ];
+  }
+
+  // file
+  return [
+    { label: t("sqlFileTree.openFile"), action: () => openFile(target.entry.path), icon: FileCode },
+    { label: t("sqlFileTree.executeSqlFile"), action: () => executeFile(target.entry.path), icon: Play },
+    { label: "", separator: true },
+    { label: t("sqlFileTree.revealInFileManager"), action: () => revealInFileManager(target.entry.path), icon: FolderSearch },
+    { label: t("sqlFileTree.copyPath"), action: () => copyPath(target.entry.path), icon: Copy },
+  ];
+});
+
+function expandSubtree(target: Extract<ContextTarget, { kind: "dir" }>) {
+  const folder = folders.value.find((f) => f.path === target.folderPath);
+  if (!folder) return;
+  const next = new Set(folder.expanded);
+  next.add(target.entry.path);
+  collectDirPaths(target.entry.children, next);
+  folder.expanded = next;
+}
+
+function collapseSubtree(target: Extract<ContextTarget, { kind: "dir" }>) {
+  const folder = folders.value.find((f) => f.path === target.folderPath);
+  if (!folder) return;
+  const subtree = new Set<string>();
+  collectDirPaths(target.entry.children, subtree);
+  subtree.add(target.entry.path);
+  const next = new Set<string>();
+  for (const p of folder.expanded) {
+    if (!subtree.has(p)) next.add(p);
+  }
+  folder.expanded = next;
+}
+
+function clearContextTarget() {
+  contextTarget.value = null;
+}
+</script>
+
+<template>
+  <div class="h-full flex flex-col overflow-hidden">
+    <div class="h-9 flex items-center gap-1 px-2 border-b shrink-0 bg-muted/20">
+      <span class="text-[13px] font-medium">{{ t("sqlFileTree.title") }}</span>
+      <span class="flex-1" />
+      <LightTooltip v-if="folders.length > 0" :text="t('sqlFileTree.refreshAll')" side="bottom" :delay="0" :close-delay="0" nowrap>
+        <Button variant="ghost" size="icon" class="h-5 w-5" @click="refreshAll">
+          <RefreshCw class="h-3 w-3" />
+        </Button>
+      </LightTooltip>
+      <LightTooltip :text="t('sqlFileTree.openFolder')" side="bottom" :delay="0" :close-delay="0" nowrap>
+        <Button variant="ghost" size="icon" class="h-5 w-5" @click="pickFolder">
+          <FolderOpen class="h-3 w-3" />
+        </Button>
+      </LightTooltip>
+      <LightTooltip :text="t('sqlFileTree.closePanel')" side="bottom" :delay="0" :close-delay="0" nowrap>
+        <Button variant="ghost" size="icon" class="h-5 w-5" @click="emit('close')">
+          <X class="h-3 w-3" />
+        </Button>
+      </LightTooltip>
+    </div>
+
+    <CustomContextMenu :items="contextMenuItems" @close="clearContextTarget">
+      <template #default="{ onContextMenu }">
+        <div
+          class="flex-1 overflow-y-auto"
+          @contextmenu.capture="contextTarget = { kind: 'panel' }"
+          @contextmenu.prevent="
+            contextTarget = { kind: 'panel' };
+            onContextMenu($event);
+          "
+          @click.self="selectPath(null)"
+        >
+          <div v-if="folders.length === 0" class="flex-1 flex flex-col items-center justify-center gap-2 p-4 text-xs text-muted-foreground">
+            <FolderOpen class="h-8 w-8 text-muted-foreground/40" />
+            <span>{{ t("sqlFileTree.noFolder") }}</span>
+            <Button variant="outline" size="sm" class="h-7 text-xs" @click="pickFolder"> <FolderOpen class="h-3.5 w-3.5 mr-1" />{{ t("sqlFileTree.openFolder") }} </Button>
+          </div>
+
+          <div v-else>
+            <div v-for="(folder, fi) in folders" :key="folder.path" class="border-b last:border-b-0">
+              <div
+                class="flex items-center gap-1 px-2 py-1.5 text-[11px] font-medium text-muted-foreground bg-muted/10 sticky top-0 cursor-pointer select-none hover:bg-muted/30"
+                :class="selectedPath === folder.path ? 'bg-accent/60 text-accent-foreground' : ''"
+                @click="
+                  toggleFolderCollapse(folder);
+                  selectPath(folder.path);
+                "
+                @contextmenu.capture="
+                  contextTarget = { kind: 'folderHeader', folderPath: folder.path };
+                  selectPath(folder.path);
+                "
+                @contextmenu.prevent="
+                  contextTarget = { kind: 'folderHeader', folderPath: folder.path };
+                  selectPath(folder.path);
+                  onContextMenu($event);
+                "
+              >
+                <ChevronRight v-if="folder.collapsed" class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                <ChevronDown v-else class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                <FolderOpen class="h-3.5 w-3.5 shrink-0 text-amber-500" />
+                <span class="truncate shrink-0" :title="folder.path">{{ folderName(folder.path) }}</span>
+                <span class="truncate flex-1 text-[10px] text-muted-foreground/50" :title="folder.path">{{ folder.path }}</span>
+                <LightTooltip :text="t('sqlFileTree.refreshFolder')" side="bottom" :delay="0" :close-delay="0" nowrap>
+                  <Button variant="ghost" size="icon" class="h-4 w-4 shrink-0 text-muted-foreground hover:text-foreground" @click.stop="refreshFolder(folder.path)">
+                    <RefreshCw class="h-3 w-3" :class="folder.loading ? 'animate-spin' : ''" />
+                  </Button>
+                </LightTooltip>
+                <LightTooltip :text="t('sqlFileTree.revealInFileManager')" side="bottom" :delay="0" :close-delay="0" nowrap>
+                  <Button variant="ghost" size="icon" class="h-4 w-4 shrink-0 text-muted-foreground hover:text-foreground" @click.stop="revealInFileManager(folder.path)">
+                    <FolderSearch class="h-3 w-3" />
+                  </Button>
+                </LightTooltip>
+                <LightTooltip :text="t('sqlFileTree.removeFolder')" side="bottom" :delay="0" :close-delay="0" nowrap>
+                  <Button variant="ghost" size="icon" class="h-4 w-4 shrink-0 text-muted-foreground hover:text-destructive" @click.stop="removeFolder(fi)">
+                    <Trash2 class="h-3 w-3" />
+                  </Button>
+                </LightTooltip>
+              </div>
+              <div v-show="!folder.collapsed">
+                <div v-if="folder.loading" class="px-3 py-2 text-xs text-muted-foreground">
+                  {{ t("sqlFileTree.loading") }}
+                </div>
+                <div v-else-if="folder.entries.length === 0" class="px-3 py-2 text-xs text-muted-foreground">
+                  {{ t("sqlFileTree.noSqlFiles") }}
+                </div>
+                <div v-else>
+                  <div
+                    v-for="{ entry, depth } in flatTree(folder.entries, folder.expanded)"
+                    :key="entry.path"
+                    class="flex items-center gap-1 px-2 py-1 cursor-pointer hover:bg-muted/60 text-sm"
+                    :class="[entry.is_dir ? 'rounded-sm' : 'rounded-none', selectedPath === entry.path ? 'bg-accent text-accent-foreground' : '']"
+                    :style="{ paddingLeft: depth * 16 + 8 + 'px' }"
+                    @click="
+                      selectPath(entry.path);
+                      entry.is_dir ? toggleExpand(folder, entry.path) : openFile(entry.path);
+                    "
+                    @contextmenu.capture="
+                      contextTarget = entry.is_dir ? { kind: 'dir', folderPath: folder.path, entry } : { kind: 'file', folderPath: folder.path, entry };
+                      selectPath(entry.path);
+                    "
+                    @contextmenu.prevent="
+                      contextTarget = entry.is_dir ? { kind: 'dir', folderPath: folder.path, entry } : { kind: 'file', folderPath: folder.path, entry };
+                      selectPath(entry.path);
+                      onContextMenu($event);
+                    "
+                  >
+                    <template v-if="entry.is_dir">
+                      <ChevronRight v-if="!folder.expanded.has(entry.path)" class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                      <ChevronDown v-else class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                      <FolderClosed v-if="!folder.expanded.has(entry.path)" class="h-4 w-4 shrink-0 text-amber-500" />
+                      <FolderOpen v-else class="h-4 w-4 shrink-0 text-amber-500" />
+                    </template>
+                    <template v-else>
+                      <span class="w-3.5 shrink-0" />
+                      <FileCode class="h-4 w-4 shrink-0 text-blue-500" />
+                    </template>
+                    <span class="truncate ml-1">{{ entry.name }}</span>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </template>
+    </CustomContextMenu>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/layout/SqlLibraryPanel.vue b/apps/desktop/src/components/layout/SqlLibraryPanel.vue
new file mode 100644
index 0000000..296368d
--- /dev/null
+++ b/apps/desktop/src/components/layout/SqlLibraryPanel.vue
@@ -0,0 +1,1450 @@
+<script setup lang="ts">
+import { computed, nextTick, onBeforeUnmount, reactive, ref, watch } from "vue";
+import type { CSSProperties } from "vue";
+import { useI18n } from "vue-i18n";
+import { ArrowDownWideNarrow, Download, FilePlus, FileText, FolderCog, FolderClosed, FolderOpen, FolderPlus, Library, LocateFixed, Pencil, Search, Trash2, Upload, X } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import CustomContextMenu, { type ContextMenuItem as CtxMenuItem } from "@/components/ui/CustomContextMenu.vue";
+import LightTooltip from "@/components/ui/LightTooltip.vue";
+import { useToast } from "@/composables/useToast";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import * as api from "@/lib/backend/api";
+import { useSavedSqlStore } from "@/stores/savedSqlStore";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { focusSidebarRenameInput } from "@/lib/sidebar/sidebarRenameFocus";
+import { savedSqlFolderBranchFileCount } from "@/lib/savedSql/savedSqlFolderCounts";
+import { ensureSqlExtension, stripSqlExtension } from "@/lib/savedSql/savedSqlFileName";
+import type { SavedSqlFile, SavedSqlFolder } from "@/types/database";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const savedSqlStore = useSavedSqlStore();
+const connectionStore = useConnectionStore();
+const queryStore = useQueryStore();
+const settingsStore = useSettingsStore();
+
+const emit = defineEmits<{
+  close: [];
+}>();
+
+const UNFILED_DROP_TARGET_ID = "__sql-library-unfiled__";
+const DRAG_THRESHOLD = 5;
+
+type DragItemType = "folder" | "file" | "unfiled";
+type DropPosition = "before" | "after" | "inside";
+
+const activeConnectionIds = computed(() => new Set(connectionStore.connections.map((c) => c.id)));
+const searchText = ref("");
+const searchQuery = computed(() => searchText.value.trim().toLowerCase());
+const orphanedIds = computed(() => savedSqlStore.orphanedFileIds(activeConnectionIds.value));
+
+// Sort mode: "folder" (default tree structure) or "date" (flat list by update date)
+const sortMode = ref<"folder" | "date">("folder");
+
+function isConnectionVisible(connectionId: string) {
+  return activeConnectionIds.value.has(connectionId);
+}
+
+function getConnectionLabel(connectionId: string) {
+  const conn = connectionStore.connections.find((c) => c.id === connectionId);
+  return conn?.name || connectionId;
+}
+
+function folderPath(folder: SavedSqlFolder) {
+  const folderById = new Map(savedSqlStore.allFolders.map((item) => [item.id, item]));
+  const parts: string[] = [];
+  const seen = new Set<string>();
+  let current: SavedSqlFolder | undefined = folder;
+  while (current && !seen.has(current.id)) {
+    seen.add(current.id);
+    parts.unshift(current.name);
+    current = current.parentFolderId ? folderById.get(current.parentFolderId) : undefined;
+  }
+  return parts.join(" / ");
+}
+
+function activeImportConnectionId() {
+  return connectionStore.activeConnectionId || connectionStore.connections[0]?.id || "";
+}
+
+function importConnectionIdForFolder(folder?: SavedSqlFolder) {
+  return folder?.connectionId || activeImportConnectionId();
+}
+
+function sanitizeFileSystemSegment(name: string) {
+  return name.replace(/[<>:"/\\|?*\u0000-\u001F]/g, "_").trim() || "untitled";
+}
+
+function relativeImportName(baseDir: string, filePath: string) {
+  const normalizedBase = baseDir.replace(/\\/g, "/").replace(/\/+$/, "");
+  const normalizedFile = filePath.replace(/\\/g, "/");
+  const relative = normalizedFile.startsWith(`${normalizedBase}/`) ? normalizedFile.slice(normalizedBase.length + 1) : normalizedFile.split("/").pop() || "import.sql";
+  const pretty = relative.replace(/\//g, " - ");
+  return ensureSqlExtension(pretty);
+}
+
+function uniqueImportedName(name: string, takenNames: Set<string>) {
+  const normalized = ensureSqlExtension(name);
+  if (!takenNames.has(normalized)) {
+    takenNames.add(normalized);
+    return normalized;
+  }
+
+  const base = stripSqlExtension(normalized);
+  let counter = 2;
+  while (true) {
+    const candidate = `${base} (${counter}).sql`;
+    if (!takenNames.has(candidate)) {
+      takenNames.add(candidate);
+      return candidate;
+    }
+    counter++;
+  }
+}
+
+async function downloadText(content: string, fileName: string) {
+  const blob = new Blob([content], { type: "text/plain;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = fileName;
+  anchor.click();
+  URL.revokeObjectURL(url);
+}
+
+async function exportSingleFile(file: SavedSqlFile) {
+  try {
+    const loadedFile = await savedSqlStore.ensureFileContent(file.id);
+    if (!loadedFile) return;
+    const defaultFileName = sanitizeFileSystemSegment(ensureSqlExtension(file.name));
+    if (isTauriRuntime()) {
+      const { save } = await import("@tauri-apps/plugin-dialog");
+      const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+      const path = await save({
+        defaultPath: defaultFileName,
+        filters: [{ name: "SQL", extensions: ["sql"] }],
+      });
+      if (!path) return;
+      await writeTextFile(path, loadedFile.sql);
+    } else {
+      await downloadText(loadedFile.sql, defaultFileName);
+    }
+    toast(t("sqlLibrary.exported"), 2000);
+  } catch (e: any) {
+    toast(t("sqlLibrary.exportFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function exportFolderContents(folder?: SavedSqlFolder) {
+  if (!isTauriRuntime()) {
+    toast(t("sqlLibrary.desktopOnly"), 4000);
+    return;
+  }
+
+  try {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const { mkdir, writeTextFile } = await import("@tauri-apps/plugin-fs");
+    const { join } = await import("@tauri-apps/api/path");
+
+    const targetDir = await open({
+      directory: true,
+      multiple: false,
+      recursive: true,
+      title: folder ? t("sqlLibrary.exportFolder") : t("sqlLibrary.exportLibrary"),
+    });
+    if (!targetDir || Array.isArray(targetDir)) return;
+
+    const rootDirName = sanitizeFileSystemSegment(folder?.name || t("savedSql.rootFolder"));
+    const rootDir = await join(targetDir, rootDirName);
+    await mkdir(rootDir, { recursive: true });
+
+    const writeFolder = async (libraryFolder: SavedSqlFolder, dir: string): Promise<void> => {
+      for (const child of savedSqlStore.allFolders.filter((item) => item.parentFolderId === libraryFolder.id)) {
+        const childDir = await join(dir, sanitizeFileSystemSegment(child.name));
+        await mkdir(childDir, { recursive: true });
+        await writeFolder(child, childDir);
+      }
+      for (const file of savedSqlStore.filesInFolder(libraryFolder.id)) {
+        const loadedFile = await savedSqlStore.ensureFileContent(file.id);
+        if (!loadedFile) continue;
+        const filePath = await join(dir, sanitizeFileSystemSegment(ensureSqlExtension(file.name)));
+        await writeTextFile(filePath, loadedFile.sql);
+      }
+    };
+
+    if (folder) {
+      await writeFolder(folder, rootDir);
+    } else {
+      for (const libraryFolder of savedSqlStore.allFolders.filter((item) => isConnectionVisible(item.connectionId) && !item.parentFolderId)) {
+        const folderDir = await join(rootDir, sanitizeFileSystemSegment(libraryFolder.name));
+        await mkdir(folderDir, { recursive: true });
+        await writeFolder(libraryFolder, folderDir);
+      }
+
+      const unfiled = savedSqlStore.filesWithoutFolder().filter((file) => !orphanedIds.value.has(file.id));
+      if (unfiled.length > 0) {
+        const unfiledDir = await join(rootDir, sanitizeFileSystemSegment(t("sqlLibrary.unfiled")));
+        await mkdir(unfiledDir, { recursive: true });
+        for (const file of unfiled) {
+          const loadedFile = await savedSqlStore.ensureFileContent(file.id);
+          if (!loadedFile) continue;
+          const filePath = await join(unfiledDir, sanitizeFileSystemSegment(ensureSqlExtension(file.name)));
+          await writeTextFile(filePath, loadedFile.sql);
+        }
+      }
+    }
+
+    toast(t("sqlLibrary.exported"), 2000);
+  } catch (e: any) {
+    toast(t("sqlLibrary.exportFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function collectSqlFilesRecursively(dir: string): Promise<string[]> {
+  const { readDir } = await import("@tauri-apps/plugin-fs");
+  const { join } = await import("@tauri-apps/api/path");
+
+  const results: string[] = [];
+  for (const entry of await readDir(dir)) {
+    const fullPath = await join(dir, entry.name);
+    if (entry.isDirectory) {
+      results.push(...(await collectSqlFilesRecursively(fullPath)));
+      continue;
+    }
+    if (!entry.isFile) continue;
+    if (!fullPath.toLowerCase().endsWith(".sql")) continue;
+    results.push(fullPath);
+  }
+  return results;
+}
+
+async function importDirectoryIntoLibrary(targetFolder?: SavedSqlFolder) {
+  if (!isTauriRuntime()) {
+    toast(t("sqlLibrary.desktopOnly"), 4000);
+    return;
+  }
+
+  const connectionId = importConnectionIdForFolder(targetFolder);
+  if (!connectionId) {
+    toast(t("sqlLibrary.noConnection"), 4000);
+    return;
+  }
+
+  try {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const { readTextFile } = await import("@tauri-apps/plugin-fs");
+    const selected = await open({
+      directory: true,
+      multiple: false,
+      recursive: true,
+      title: t("sqlLibrary.importDirectory"),
+    });
+    if (!selected || Array.isArray(selected)) return;
+
+    const sqlPaths = await collectSqlFilesRecursively(selected);
+    if (sqlPaths.length === 0) {
+      toast(t("sqlLibrary.importNone"), 3000);
+      return;
+    }
+
+    const takenNames = new Set((targetFolder ? savedSqlStore.filesInFolder(targetFolder.id) : savedSqlStore.filesWithoutFolder()).filter((file) => !orphanedIds.value.has(file.id)).map((file) => file.name));
+
+    for (const path of sqlPaths) {
+      const content = await readTextFile(path);
+      const displayName = uniqueImportedName(relativeImportName(selected, path), takenNames);
+      await savedSqlStore.saveFile({
+        connectionId,
+        folderId: targetFolder?.id,
+        name: displayName,
+        database: "",
+        sql: content,
+      });
+    }
+
+    toast(t("sqlLibrary.imported", { count: sqlPaths.length }), 2500);
+  } catch (e: any) {
+    toast(t("sqlLibrary.importFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function chooseSyncDirectory() {
+  if (!isTauriRuntime()) {
+    toast(t("sqlLibrary.desktopOnly"), 4000);
+    return;
+  }
+
+  try {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const selected = await open({
+      directory: true,
+      multiple: false,
+      recursive: true,
+      title: t("sqlLibrary.chooseSyncDirectory"),
+    });
+    if (!selected || Array.isArray(selected)) return;
+
+    await settingsStore.updateDesktopSettings({ saved_sql_sync_dir: selected });
+    await savedSqlStore.syncToLocalDirectory();
+    toast(t("sqlLibrary.syncDirectorySaved"), 2500);
+  } catch (e: any) {
+    toast(t("sqlLibrary.syncDirectoryFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function disableSyncDirectory() {
+  try {
+    await settingsStore.updateDesktopSettings({ saved_sql_sync_dir: null });
+    toast(t("sqlLibrary.syncDirectoryDisabled"), 2500);
+  } catch (e: any) {
+    toast(t("sqlLibrary.syncDirectoryFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function openSqlStorageDirectory() {
+  if (!isTauriRuntime()) {
+    toast(t("sqlLibrary.desktopOnly"), 4000);
+    return;
+  }
+
+  const syncDir = settingsStore.desktopSettings.saved_sql_sync_dir?.trim();
+  if (!syncDir) {
+    toast(t("sqlLibrary.noSyncDirectory"), 3000);
+    return;
+  }
+  try {
+    await api.openSavedSqlStorageDir(syncDir);
+  } catch (e: any) {
+    toast(t("sqlLibrary.openDirectoryFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function fileMatchesQuery(file: SavedSqlFile) {
+  const q = searchQuery.value;
+  if (!q) return true;
+  return [file.name, file.database, file.schema, file.sql, getConnectionLabel(file.connectionId)].filter(Boolean).some((value) => String(value).toLowerCase().includes(q));
+}
+
+function folderMatchesQuery(folder: SavedSqlFolder) {
+  const q = searchQuery.value;
+  if (!q) return true;
+  if (folder.name.toLowerCase().includes(q)) return true;
+  return savedSqlStore.filesInFolder(folder.id).some((file) => !orphanedIds.value.has(file.id) && fileMatchesQuery(file));
+}
+
+function childFolders(parentFolderId?: string) {
+  return savedSqlStore.allFolders.filter((folder) => isConnectionVisible(folder.connectionId) && (folder.parentFolderId || "") === (parentFolderId || ""));
+}
+
+function descendantFolders(parentFolderId: string): SavedSqlFolder[] {
+  const direct = childFolders(parentFolderId);
+  return direct.flatMap((folder) => [folder, ...descendantFolders(folder.id)]);
+}
+
+function folderBranchMatchesQuery(folder: SavedSqlFolder) {
+  if (folderMatchesQuery(folder)) return true;
+  return descendantFolders(folder.id).some((child) => folderMatchesQuery(child));
+}
+
+function filesInFolder(folderId: string) {
+  const folder = savedSqlStore.allFolders.find((item) => item.id === folderId);
+  const includeAllFilesForMatchedFolder = !!folder && !!searchQuery.value && folder.name.toLowerCase().includes(searchQuery.value);
+  return savedSqlStore
+    .filesInFolder(folderId)
+    .filter((file) => !orphanedIds.value.has(file.id))
+    .filter((file) => includeAllFilesForMatchedFolder || fileMatchesQuery(file));
+}
+
+function folderFileCount(folderId: string) {
+  const visibleFolders = savedSqlStore.allFolders.filter((folder) => isConnectionVisible(folder.connectionId));
+  return savedSqlFolderBranchFileCount(folderId, visibleFolders, filesInFolder);
+}
+
+type SqlLibraryRow = { type: "folder"; folder: SavedSqlFolder; depth: number; folderIndex: number } | { type: "file"; file: SavedSqlFile; depth: number };
+
+const visibleFolderRows = computed<SqlLibraryRow[]>(() => {
+  const rows: SqlLibraryRow[] = [];
+  let folderIndex = 0;
+  const appendFolder = (folder: SavedSqlFolder, depth: number) => {
+    if (!folderBranchMatchesQuery(folder)) return;
+    rows.push({ type: "folder", folder, depth, folderIndex: folderIndex++ });
+    if (!isFolderExpanded(folder.id)) return;
+    for (const child of childFolders(folder.id)) {
+      appendFolder(child, depth + 1);
+    }
+    for (const file of filesInFolder(folder.id)) {
+      rows.push({ type: "file", file, depth: depth + 1 });
+    }
+  };
+  for (const folder of childFolders()) {
+    appendFolder(folder, 0);
+  }
+  return rows;
+});
+
+const visibleFiles = computed(() =>
+  savedSqlStore
+    .filesWithoutFolder()
+    .filter((file) => !orphanedIds.value.has(file.id))
+    .filter((file) => fileMatchesQuery(file)),
+);
+
+// Flat list sorted by updatedAt (descending) - combines all folders and files
+const itemsByDate = computed(() => {
+  const allFolders = savedSqlStore.allFolders
+    .filter((folder) => isConnectionVisible(folder.connectionId))
+    .filter((folder) => folderBranchMatchesQuery(folder))
+    .map((folder) => ({ type: "folder" as const, item: folder, updatedAt: folder.updatedAt }));
+
+  const allFiles = [...savedSqlStore.allFolders.flatMap((folder) => filesInFolder(folder.id)), ...visibleFiles.value].map((file) => ({ type: "file" as const, item: file, updatedAt: file.updatedAt }));
+
+  return [...allFolders, ...allFiles].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+});
+
+const hasAnyVisibleItem = computed(() => visibleFolderRows.value.length > 0 || visibleFiles.value.length > 0);
+
+const collapsedFolders = ref<Set<string>>(new Set());
+
+function toggleFolder(folderId: string) {
+  if (suppressNextRowClick.value) return;
+  const next = new Set(collapsedFolders.value);
+  if (next.has(folderId)) next.delete(folderId);
+  else next.add(folderId);
+  collapsedFolders.value = next;
+}
+
+function isFolderExpanded(folderId: string) {
+  return !collapsedFolders.value.has(folderId);
+}
+
+async function openNewFolderInput(parentFolderId?: string) {
+  const parent = parentFolderId ? savedSqlStore.allFolders.find((folder) => folder.id === parentFolderId) : undefined;
+  const connectionId = parent?.connectionId || connectionStore.connections[0]?.id;
+  if (!connectionId) return;
+  if (parent?.id) {
+    collapsedFolders.value = new Set([...collapsedFolders.value].filter((id) => id !== parent.id));
+  }
+  const folder = await savedSqlStore.createFolder(connectionId, t("savedSql.newFolderDefault"), parent?.id);
+  startRenameFolder(folder);
+}
+
+async function openNewQueryInFolder(folder?: SavedSqlFolder) {
+  const connectionId = folder?.connectionId || connectionStore.activeConnectionId || connectionStore.connections[0]?.id;
+  if (!connectionId) return;
+
+  const takenNames = folder
+    ? new Set(savedSqlStore.filesInFolder(folder.id).map((f) => f.name))
+    : new Set(
+        savedSqlStore
+          .filesWithoutFolder()
+          .filter((file) => !orphanedIds.value.has(file.id))
+          .map((f) => f.name),
+      );
+  const name = uniqueImportedName("new_query.sql", takenNames);
+  const file = await savedSqlStore.saveFile({
+    connectionId,
+    folderId: folder?.id,
+    name,
+    database: "",
+    sql: "",
+  });
+  queryStore.openSavedSql(file);
+}
+
+// Batch selection state
+const selectedFileIds = ref<Set<string>>(new Set());
+const selectedFolderIds = ref<Set<string>>(new Set());
+const lastClickedItemIndex = ref<number | null>(null); // Unified index for both folders and files
+
+// Active item state (single selection highlight, like left sidebar)
+const activeItemId = ref<string | null>(null);
+const activeItemType = ref<"file" | "folder" | null>(null);
+const activeSavedSqlId = computed(() => queryStore.tabs.find((tab) => tab.id === queryStore.activeTabId)?.savedSqlId ?? null);
+
+watch(
+  activeSavedSqlId,
+  (fileId) => {
+    if (fileId) {
+      setActiveItem(fileId, "file");
+    } else if (activeItemType.value === "file") {
+      activeItemId.value = null;
+      activeItemType.value = null;
+    }
+  },
+  { immediate: true },
+);
+
+// Unified item list for selection, matching the currently rendered order.
+const allSelectableItems = computed(() => {
+  if (sortMode.value === "date") {
+    return itemsByDate.value.map((item) => ({
+      type: item.type,
+      id: item.item.id,
+    }));
+  }
+
+  const treeItems = visibleFolderRows.value.map((row) => (row.type === "folder" ? { type: "folder" as const, id: row.folder.id } : { type: "file" as const, id: row.file.id }));
+  const rootFiles = visibleFiles.value.map((file) => ({ type: "file" as const, id: file.id }));
+  return [...treeItems, ...rootFiles];
+});
+
+const hasSelection = computed(() => selectedFileIds.value.size > 0 || selectedFolderIds.value.size > 0);
+const selectedCount = computed(() => selectedFileIds.value.size + selectedFolderIds.value.size);
+
+function clearSelection() {
+  selectedFileIds.value = new Set();
+  selectedFolderIds.value = new Set();
+  lastClickedItemIndex.value = null;
+}
+
+function setActiveItem(id: string, type: "file" | "folder") {
+  activeItemId.value = id;
+  activeItemType.value = type;
+}
+
+function isFileSelected(fileId: string): boolean {
+  return selectedFileIds.value.has(fileId);
+}
+
+function isFolderSelected(folderId: string): boolean {
+  return selectedFolderIds.value.has(folderId);
+}
+
+function isFileActive(fileId: string): boolean {
+  return activeItemType.value === "file" && activeItemId.value === fileId;
+}
+
+function isFolderActive(folderId: string): boolean {
+  return activeItemType.value === "folder" && activeItemId.value === folderId;
+}
+
+function selectionRowClass(selected: boolean, active: boolean): string {
+  if (selected) return "bg-primary/10 text-foreground";
+  if (active) return "bg-primary/12 text-foreground";
+  return "hover:bg-accent";
+}
+
+function fileRowClass(fileId: string): string {
+  return selectionRowClass(isFileSelected(fileId), isFileActive(fileId));
+}
+
+function folderRowClass(folderId: string): string {
+  return selectionRowClass(isFolderSelected(folderId), isFolderActive(folderId));
+}
+
+function fileMetaClass(fileId: string): string {
+  return isFileSelected(fileId) || isFileActive(fileId) ? "text-foreground/70" : "text-muted-foreground";
+}
+
+function isFileDirty(file: SavedSqlFile): boolean {
+  return queryStore.tabs.some((tab) => tab.savedSqlId === file.id && queryStore.isTabDirty(tab));
+}
+
+function fileTitleLabel(file: SavedSqlFile): string {
+  return isFileDirty(file) ? `* ${file.name}` : file.name;
+}
+
+function fileTitleStyle(file: SavedSqlFile): CSSProperties | undefined {
+  if (!isFileDirty(file)) return undefined;
+  return {
+    fontStyle: "italic",
+    fontWeight: 700,
+    transform: "skewX(-8deg)",
+    transformOrigin: "left center",
+  };
+}
+
+const renamingTarget = ref<{ type: "folder" | "file"; id: string } | null>(null);
+const renameValue = ref("");
+const renameInputRef = ref<HTMLInputElement | null>(null);
+function setRenameInputRef(el: unknown) {
+  renameInputRef.value = (el as HTMLInputElement) ?? null;
+}
+
+function isRenamingFolder(folderId: string) {
+  return renamingTarget.value?.type === "folder" && renamingTarget.value.id === folderId;
+}
+
+function isRenamingFile(fileId: string) {
+  return renamingTarget.value?.type === "file" && renamingTarget.value.id === fileId;
+}
+
+function prepareRenameInput() {
+  resetDragState();
+  clearSelection();
+  markSuppressedClick();
+  renameInputRef.value = null;
+}
+
+function startRenameFolder(folder: SavedSqlFolder) {
+  prepareRenameInput();
+  setActiveItem(folder.id, "folder");
+  renamingTarget.value = { type: "folder", id: folder.id };
+  renameValue.value = folder.name;
+  nextTick(() => {
+    focusSidebarRenameInput(() => renameInputRef.value ?? undefined);
+  });
+}
+
+function startRenameFile(file: SavedSqlFile) {
+  prepareRenameInput();
+  setActiveItem(file.id, "file");
+  renamingTarget.value = { type: "file", id: file.id };
+  renameValue.value = file.name.replace(/\.sql$/i, "");
+  nextTick(() => {
+    focusSidebarRenameInput(() => renameInputRef.value ?? undefined);
+  });
+}
+
+async function confirmRename() {
+  if (!renamingTarget.value) return;
+  const { type, id } = renamingTarget.value;
+  const name = renameValue.value.trim();
+  renamingTarget.value = null;
+  renameValue.value = "";
+  if (!name) return;
+  if (type === "folder") {
+    await savedSqlStore.renameFolder(id, name);
+  } else {
+    await savedSqlStore.renameFile(id, ensureSqlExtension(name));
+  }
+}
+
+function cancelRename() {
+  renamingTarget.value = null;
+  renameValue.value = "";
+}
+
+const deleteTarget = ref<{ type: "folder" | "file"; id: string; name: string } | null>(null);
+const showDeleteConfirm = ref(false);
+const showBatchDeleteConfirm = ref(false);
+
+function confirmDeleteFolder(folder: SavedSqlFolder) {
+  deleteTarget.value = { type: "folder", id: folder.id, name: folder.name };
+  showDeleteConfirm.value = true;
+}
+
+function confirmDeleteFile(file: SavedSqlFile) {
+  deleteTarget.value = { type: "file", id: file.id, name: file.name };
+  showDeleteConfirm.value = true;
+}
+
+function confirmBatchDelete() {
+  if (!hasSelection.value) return;
+  showBatchDeleteConfirm.value = true;
+}
+
+async function executeDelete() {
+  if (!deleteTarget.value) return;
+  const { type, id } = deleteTarget.value;
+  if (type === "folder") await savedSqlStore.deleteFolder(id);
+  else await savedSqlStore.deleteFile(id);
+  showDeleteConfirm.value = false;
+  deleteTarget.value = null;
+}
+
+async function executeBatchDelete() {
+  const fileIds = Array.from(selectedFileIds.value);
+  const folderIds = Array.from(selectedFolderIds.value);
+
+  // Delete files first, then folders
+  for (const fileId of fileIds) {
+    await savedSqlStore.deleteFile(fileId);
+  }
+  for (const folderId of folderIds) {
+    await savedSqlStore.deleteFolder(folderId);
+  }
+
+  showBatchDeleteConfirm.value = false;
+  clearSelection();
+  toast(t("sqlLibrary.batchDeleteSuccess", { count: fileIds.length + folderIds.length }), 2000);
+}
+
+async function moveFilesToFolder(fileIds: string[], folderId?: string) {
+  const movableIds = [...new Set(fileIds)].filter((id) => savedSqlStore.getFile(id));
+  if (movableIds.length === 0) return;
+  await savedSqlStore.moveFilesToFolder(movableIds, folderId);
+  clearSelection();
+  toast(t("sqlLibrary.moveSuccess", { count: movableIds.length }), 2000);
+}
+
+async function openFile(file: SavedSqlFile) {
+  if (suppressNextRowClick.value) return;
+  const loadedFile = await savedSqlStore.ensureFileContent(file.id);
+  if (!loadedFile) return;
+  queryStore.openSavedSql(loadedFile);
+  connectionStore.activeConnectionId = loadedFile.connectionId;
+  void savedSqlStore.recordFileUsage(loadedFile.id);
+}
+
+function handleFileClick(file: SavedSqlFile, event: MouseEvent) {
+  if (suppressNextRowClick.value) return;
+
+  const isMeta = event.metaKey || event.ctrlKey;
+  const isShift = event.shiftKey;
+
+  // Find current file index in unified list
+  const currentIndex = allSelectableItems.value.findIndex((item) => item.type === "file" && item.id === file.id);
+  if (currentIndex < 0) return;
+
+  if (isMeta) {
+    // Toggle selection
+    event.preventDefault();
+    event.stopPropagation();
+    const next = new Set(selectedFileIds.value);
+    if (next.has(file.id)) {
+      next.delete(file.id);
+    } else {
+      next.add(file.id);
+    }
+    selectedFileIds.value = next;
+    lastClickedItemIndex.value = currentIndex;
+  } else if (isShift) {
+    // Range selection - additive mode (add to existing selection)
+    event.preventDefault();
+    event.stopPropagation();
+
+    const startIndex = lastClickedItemIndex.value ?? 0;
+    const start = Math.min(startIndex, currentIndex);
+    const end = Math.max(startIndex, currentIndex);
+
+    // Add to existing selection (additive mode)
+    const nextFiles = new Set(selectedFileIds.value);
+    const nextFolders = new Set(selectedFolderIds.value);
+    for (let i = start; i <= end; i++) {
+      const item = allSelectableItems.value[i];
+      if (item) {
+        if (item.type === "file") {
+          nextFiles.add(item.id);
+        } else {
+          nextFolders.add(item.id);
+        }
+      }
+    }
+    selectedFileIds.value = nextFiles;
+    selectedFolderIds.value = nextFolders;
+    lastClickedItemIndex.value = currentIndex;
+  } else {
+    // Normal click - open file, clear selection but keep anchor, and set active
+    const hadSelection = hasSelection.value;
+    clearSelection();
+    setActiveItem(file.id, "file");
+    openFile(file);
+    // Set anchor for future shift-click even when not selecting
+    if (!hadSelection) {
+      lastClickedItemIndex.value = currentIndex;
+    }
+  }
+}
+
+function handleFolderClick(folder: SavedSqlFolder, event: MouseEvent) {
+  if (suppressNextRowClick.value) return;
+
+  const isMeta = event.metaKey || event.ctrlKey;
+  const isShift = event.shiftKey;
+
+  // Find current folder index in unified list
+  const currentIndex = allSelectableItems.value.findIndex((item) => item.type === "folder" && item.id === folder.id);
+  if (currentIndex < 0) return;
+
+  if (isMeta) {
+    // Toggle selection
+    event.preventDefault();
+    event.stopPropagation();
+    const next = new Set(selectedFolderIds.value);
+    if (next.has(folder.id)) {
+      next.delete(folder.id);
+    } else {
+      next.add(folder.id);
+    }
+    selectedFolderIds.value = next;
+    lastClickedItemIndex.value = currentIndex;
+  } else if (isShift) {
+    // Range selection - additive mode (add to existing selection)
+    event.preventDefault();
+    event.stopPropagation();
+
+    const startIndex = lastClickedItemIndex.value ?? 0;
+    const start = Math.min(startIndex, currentIndex);
+    const end = Math.max(startIndex, currentIndex);
+
+    // Add to existing selection (additive mode)
+    const nextFiles = new Set(selectedFileIds.value);
+    const nextFolders = new Set(selectedFolderIds.value);
+    for (let i = start; i <= end; i++) {
+      const item = allSelectableItems.value[i];
+      if (item) {
+        if (item.type === "file") {
+          nextFiles.add(item.id);
+        } else {
+          nextFolders.add(item.id);
+        }
+      }
+    }
+    selectedFileIds.value = nextFiles;
+    selectedFolderIds.value = nextFolders;
+    lastClickedItemIndex.value = currentIndex;
+  } else {
+    // Normal click - toggle folder expansion, clear selection but keep anchor, and set active
+    const hadSelection = hasSelection.value;
+    clearSelection();
+    setActiveItem(folder.id, "folder");
+    toggleFolder(folder.id);
+    // Set anchor for future shift-click even when not selecting
+    if (!hadSelection) {
+      lastClickedItemIndex.value = currentIndex;
+    }
+  }
+}
+
+const contextTarget = ref<SavedSqlFolder | SavedSqlFile | "panel" | null>(null);
+
+function folderMoveMenuItems(fileIds: string[]): CtxMenuItem[] {
+  const files = [...new Set(fileIds)].map((id) => savedSqlStore.getFile(id)).filter((file): file is SavedSqlFile => Boolean(file));
+  const allInUnfiled = files.length > 0 && files.every((file) => !file.folderId);
+  const folderItems = savedSqlStore.allFoldersTreeOrder
+    .filter((folder) => isConnectionVisible(folder.connectionId))
+    .map((folder) => ({
+      label: folderPath(folder),
+      action: () =>
+        moveFilesToFolder(
+          files.map((file) => file.id),
+          folder.id,
+        ),
+      disabled: files.every((file) => file.folderId === folder.id),
+      icon: FolderClosed,
+    }));
+
+  return [
+    {
+      label: t("sqlLibrary.unfiled"),
+      action: () =>
+        moveFilesToFolder(
+          files.map((file) => file.id),
+          undefined,
+        ),
+      disabled: files.length === 0 || allInUnfiled,
+      icon: FolderOpen,
+    },
+    ...(folderItems.length > 0 ? [{ label: "", separator: true }, ...folderItems] : []),
+  ];
+}
+
+const contextMenuItems = computed<CtxMenuItem[]>(() => {
+  const target = contextTarget.value;
+  if (!target) return [];
+
+  // If there's selection, show batch delete option
+  if (hasSelection.value) {
+    const selectedFiles = Array.from(selectedFileIds.value);
+    return [
+      {
+        label: t("sqlLibrary.moveSelectedToFolder", { count: selectedFiles.length }),
+        icon: FolderClosed,
+        children: folderMoveMenuItems(selectedFiles),
+        visible: selectedFiles.length > 0,
+      },
+      { label: "", separator: true, visible: selectedFiles.length > 0 },
+      {
+        label: t("sqlLibrary.batchDelete", { count: selectedCount.value }),
+        action: confirmBatchDelete,
+        icon: Trash2,
+        variant: "destructive",
+      },
+      { label: "", separator: true },
+      { label: t("sqlLibrary.clearSelection"), action: clearSelection, icon: X },
+    ];
+  }
+
+  if (target === "panel") {
+    return [
+      { label: t("savedSql.newFolder"), action: openNewFolderInput, icon: FolderPlus },
+      { label: t("savedSql.newQuery"), action: () => openNewQueryInFolder(), icon: FilePlus },
+      { label: t("sqlLibrary.importDirectory"), action: () => importDirectoryIntoLibrary(), icon: Download },
+      { label: t("sqlLibrary.exportLibrary"), action: () => exportFolderContents(), icon: Upload },
+      { label: "", separator: true },
+      { label: t("sqlLibrary.openStorageDirectory"), action: openSqlStorageDirectory, icon: LocateFixed },
+      { label: t("sqlLibrary.chooseSyncDirectory"), action: chooseSyncDirectory, icon: FolderCog },
+      {
+        label: t("sqlLibrary.disableSyncDirectory"),
+        action: disableSyncDirectory,
+        icon: X,
+        visible: !!settingsStore.desktopSettings.saved_sql_sync_dir,
+      },
+    ];
+  }
+  if ("sql" in target) {
+    return [
+      { label: t("savedSql.open"), action: () => openFile(target), icon: FileText },
+      { label: t("sqlLibrary.exportFile"), action: () => exportSingleFile(target), icon: Upload },
+      { label: t("sqlLibrary.moveToFolder"), icon: FolderClosed, children: folderMoveMenuItems([target.id]) },
+      { label: "", separator: true },
+      { label: t("savedSql.renameFile"), action: () => startRenameFile(target), icon: Pencil },
+      { label: "", separator: true },
+      {
+        label: t("savedSql.deleteFile"),
+        action: () => confirmDeleteFile(target),
+        icon: Trash2,
+        variant: "destructive",
+      },
+    ];
+  }
+  return [
+    { label: t("savedSql.newFolder"), action: () => openNewFolderInput(target.id), icon: FolderPlus },
+    { label: t("savedSql.newQuery"), action: () => openNewQueryInFolder(target), icon: FilePlus },
+    { label: t("sqlLibrary.importIntoFolder"), action: () => importDirectoryIntoLibrary(target), icon: Download },
+    { label: t("sqlLibrary.exportFolder"), action: () => exportFolderContents(target), icon: Upload },
+    { label: "", separator: true },
+    { label: t("savedSql.renameFolder"), action: () => startRenameFolder(target), icon: Pencil },
+    { label: "", separator: true },
+    {
+      label: t("savedSql.deleteFolder"),
+      action: () => confirmDeleteFolder(target),
+      icon: Trash2,
+      variant: "destructive",
+    },
+  ];
+});
+
+function clearContextTarget() {
+  contextTarget.value = null;
+}
+
+const dragState = reactive<{
+  active: boolean;
+  draggedId: string | null;
+  draggedType: DragItemType | null;
+  targetId: string | null;
+  targetType: DragItemType | null;
+  dropPosition: DropPosition | null;
+}>({
+  active: false,
+  draggedId: null,
+  draggedType: null,
+  targetId: null,
+  targetType: null,
+  dropPosition: null,
+});
+
+let pendingDrag: {
+  id: string;
+  type: DragItemType;
+  startX: number;
+  startY: number;
+  sourceEl: HTMLElement | null;
+} | null = null;
+let dragGhostEl: HTMLElement | null = null;
+let clearSuppressTimer: number | undefined;
+const suppressNextRowClick = ref(false);
+
+function markSuppressedClick() {
+  suppressNextRowClick.value = true;
+  window.clearTimeout(clearSuppressTimer);
+  clearSuppressTimer = window.setTimeout(() => {
+    suppressNextRowClick.value = false;
+  }, 0);
+}
+
+function resetDragState() {
+  dragState.active = false;
+  dragState.draggedId = null;
+  dragState.draggedType = null;
+  dragState.targetId = null;
+  dragState.targetType = null;
+  dragState.dropPosition = null;
+  pendingDrag = null;
+  if (dragGhostEl) {
+    dragGhostEl.remove();
+    dragGhostEl = null;
+  }
+  document.body.style.cursor = "";
+  document.body.style.userSelect = "";
+}
+
+function createDragGhost(sourceEl: HTMLElement, x: number, y: number) {
+  const ghost = document.createElement("div");
+  const textNode = sourceEl.querySelector(".dbx-sql-library-drag-label");
+  ghost.textContent = textNode?.textContent || "";
+  ghost.style.cssText = `
+    position: fixed;
+    pointer-events: none;
+    z-index: 9999;
+    opacity: 0.9;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.12);
+    border-radius: 4px;
+    background: var(--background, #fff);
+    border: 1px solid var(--border, #e5e7eb);
+    max-width: 220px;
+    height: 24px;
+    padding: 0 8px;
+    font-size: 13px;
+    line-height: 24px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    left: ${x + 8}px;
+    top: ${y - 12}px;
+  `;
+  document.body.appendChild(ghost);
+  return ghost;
+}
+
+function moveDragGhost(x: number, y: number) {
+  if (!dragGhostEl) return;
+  dragGhostEl.style.left = `${x + 8}px`;
+  dragGhostEl.style.top = `${y - 12}px`;
+}
+
+function onDocumentMouseMove(event: MouseEvent) {
+  if (!pendingDrag && !dragState.active) return;
+
+  if (pendingDrag && !dragState.active) {
+    const dx = event.clientX - pendingDrag.startX;
+    const dy = event.clientY - pendingDrag.startY;
+    if (Math.abs(dx) < DRAG_THRESHOLD && Math.abs(dy) < DRAG_THRESHOLD) return;
+
+    dragState.active = true;
+    dragState.draggedId = pendingDrag.id;
+    dragState.draggedType = pendingDrag.type;
+    document.body.style.cursor = "grabbing";
+    document.body.style.userSelect = "none";
+    if (pendingDrag.sourceEl) {
+      dragGhostEl = createDragGhost(pendingDrag.sourceEl, event.clientX, event.clientY);
+    }
+    pendingDrag = null;
+  }
+
+  if (dragState.active) {
+    moveDragGhost(event.clientX, event.clientY);
+  }
+}
+
+async function performDrop() {
+  const draggedId = dragState.draggedId;
+  const draggedType = dragState.draggedType;
+  const targetId = dragState.targetId;
+  const targetType = dragState.targetType;
+  const dropPosition = dragState.dropPosition;
+  if (!draggedId || !draggedType || !targetId || !targetType || !dropPosition) return;
+
+  if (draggedType === "folder" && targetType === "folder" && dropPosition !== "inside") {
+    await savedSqlStore.reorderFolders(draggedId, targetId, dropPosition);
+    return;
+  }
+
+  if (draggedType === "folder" && targetType === "folder" && dropPosition === "inside") {
+    await savedSqlStore.moveFolderToFolder(draggedId, targetId);
+    return;
+  }
+
+  if (draggedType !== "file") return;
+
+  if (targetType === "folder") {
+    await savedSqlStore.moveFileToFolder(draggedId, targetId);
+    return;
+  }
+
+  if (targetType === "unfiled") {
+    await savedSqlStore.moveFileToFolder(draggedId, undefined);
+    return;
+  }
+
+  if (targetType === "file" && dropPosition !== "inside") {
+    await savedSqlStore.reorderFiles(draggedId, targetId, dropPosition);
+  }
+}
+
+function onDocumentMouseUp() {
+  const hadActiveDrag = dragState.active;
+  const dropPromise = hadActiveDrag ? performDrop() : Promise.resolve();
+  if (hadActiveDrag) markSuppressedClick();
+  resetDragState();
+  void dropPromise;
+}
+
+document.addEventListener("mousemove", onDocumentMouseMove, true);
+document.addEventListener("mouseup", onDocumentMouseUp, true);
+
+onBeforeUnmount(() => {
+  document.removeEventListener("mousemove", onDocumentMouseMove, true);
+  document.removeEventListener("mouseup", onDocumentMouseUp, true);
+  window.clearTimeout(clearSuppressTimer);
+  resetDragState();
+});
+
+function handleDragMouseDown(event: MouseEvent, id: string, type: Extract<DragItemType, "folder" | "file">) {
+  if (event.button !== 0) return;
+  // Skip drag when modifier keys are pressed (for selection)
+  if (event.shiftKey || event.metaKey || event.ctrlKey) return;
+  const target = event.target as HTMLElement | null;
+  if (target?.closest("[data-no-drag='true']")) return;
+  pendingDrag = {
+    id,
+    type,
+    startX: event.clientX,
+    startY: event.clientY,
+    sourceEl: event.currentTarget as HTMLElement,
+  };
+}
+
+function updateDropTarget(event: MouseEvent, targetId: string, targetType: DragItemType) {
+  if (!dragState.active || !dragState.draggedId || !dragState.draggedType) return;
+  if (dragState.draggedId === targetId) {
+    clearDropTarget(targetId);
+    return;
+  }
+
+  let nextPosition: DropPosition | null = null;
+  if (dragState.draggedType === "folder" && targetType === "folder") {
+    const rect = (event.currentTarget as HTMLElement).getBoundingClientRect();
+    const y = event.clientY - rect.top;
+    const third = rect.height / 3;
+    nextPosition = y > third && y < rect.height - third ? "inside" : y < rect.height / 2 ? "before" : "after";
+  } else if (dragState.draggedType === "file" && targetType === "file") {
+    const rect = (event.currentTarget as HTMLElement).getBoundingClientRect();
+    nextPosition = event.clientY - rect.top < rect.height / 2 ? "before" : "after";
+  } else if (dragState.draggedType === "file" && (targetType === "folder" || targetType === "unfiled")) {
+    nextPosition = "inside";
+  }
+
+  dragState.targetId = nextPosition ? targetId : null;
+  dragState.targetType = nextPosition ? targetType : null;
+  dragState.dropPosition = nextPosition;
+}
+
+function clearDropTarget(targetId: string) {
+  if (dragState.targetId !== targetId) return;
+  dragState.targetId = null;
+  dragState.targetType = null;
+  dragState.dropPosition = null;
+}
+
+function isDraggingItem(id: string) {
+  return dragState.active && dragState.draggedId === id;
+}
+
+function showDropBefore(targetId: string) {
+  return dragState.active && dragState.targetId === targetId && dragState.dropPosition === "before";
+}
+
+function showDropAfter(targetId: string) {
+  return dragState.active && dragState.targetId === targetId && dragState.dropPosition === "after";
+}
+
+function showDropInside(targetId: string) {
+  return dragState.active && dragState.targetId === targetId && dragState.dropPosition === "inside";
+}
+</script>
+
+<template>
+  <div class="h-full flex flex-col overflow-hidden border-l bg-background select-none">
+    <div class="h-9 flex items-center gap-1 px-2 border-b shrink-0 bg-muted/20">
+      <span class="text-[13px] font-medium">{{ t("sqlLibrary.title") }}</span>
+      <span v-if="hasSelection" class="text-[12px] text-muted-foreground ml-1">({{ selectedCount }})</span>
+      <span class="flex-1" />
+      <LightTooltip :text="sortMode === 'folder' ? t('sqlLibrary.sortByDate') : t('sqlLibrary.sortByFolder')" side="bottom" :delay="0" :close-delay="0" nowrap>
+        <Button variant="ghost" size="icon" class="h-5 w-5" @click="sortMode = sortMode === 'folder' ? 'date' : 'folder'">
+          <ArrowDownWideNarrow :class="['h-3 w-3', sortMode === 'date' ? 'text-primary' : '']" />
+        </Button>
+      </LightTooltip>
+      <LightTooltip :text="t('savedSql.newFolder')" side="bottom" :delay="0" :close-delay="0" nowrap>
+        <Button variant="ghost" size="icon" class="h-5 w-5" @click="openNewFolderInput">
+          <FolderPlus class="h-3 w-3" />
+        </Button>
+      </LightTooltip>
+      <LightTooltip :text="t('sqlLibrary.importDirectory')" side="bottom" :delay="0" :close-delay="0" nowrap>
+        <Button variant="ghost" size="icon" class="h-5 w-5" @click="importDirectoryIntoLibrary()">
+          <Download class="h-3 w-3" />
+        </Button>
+      </LightTooltip>
+      <LightTooltip :text="t('sqlLibrary.exportLibrary')" side="bottom" :delay="0" :close-delay="0" nowrap>
+        <Button variant="ghost" size="icon" class="h-5 w-5" @click="exportFolderContents()">
+          <Upload class="h-3 w-3" />
+        </Button>
+      </LightTooltip>
+      <LightTooltip :text="t('common.close')" side="bottom" :delay="0" :close-delay="0" nowrap>
+        <Button variant="ghost" size="icon" class="h-5 w-5" @click="emit('close')">
+          <X class="h-3 w-3" />
+        </Button>
+      </LightTooltip>
+    </div>
+
+    <div class="border-b shrink-0 px-2 py-1">
+      <div class="relative">
+        <Search class="absolute left-2 top-1/2 -translate-y-1/2 h-3 w-3 text-muted-foreground" />
+        <input v-model="searchText" autocapitalize="off" autocorrect="off" spellcheck="false" class="w-full h-6 pl-7 pr-6 text-[13px] rounded border border-border bg-background focus:outline-none focus:ring-1 focus:ring-ring" :placeholder="t('grid.search')" />
+        <button v-if="searchText" type="button" class="absolute right-1.5 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground" @click="searchText = ''">
+          <X class="h-3 w-3" />
+        </button>
+      </div>
+    </div>
+
+    <div class="min-h-0 flex-1 overflow-y-auto py-1">
+      <CustomContextMenu :items="contextMenuItems" @close="clearContextTarget">
+        <template #default="{ onContextMenu }">
+          <div
+            class="h-full"
+            @contextmenu.capture="contextTarget = 'panel'"
+            @contextmenu.prevent="
+              contextTarget = 'panel';
+              onContextMenu($event);
+            "
+          >
+            <!-- Flat list sorted by date -->
+            <div v-if="sortMode === 'date'" class="space-y-0">
+              <div v-for="item in itemsByDate" :key="item.type + '-' + item.item.id">
+                <div
+                  v-if="item.type === 'folder'"
+                  class="relative flex items-center gap-1 px-2 py-1.5 text-[13px] cursor-pointer group"
+                  :class="[folderRowClass(item.item.id), isDraggingItem(item.item.id) ? 'opacity-50' : '']"
+                  @mousedown="handleDragMouseDown($event, item.item.id, 'folder')"
+                  @click="handleFolderClick(item.item, $event)"
+                  @contextmenu.capture="contextTarget = item.item"
+                  @contextmenu.prevent="
+                    contextTarget = item.item;
+                    onContextMenu($event);
+                  "
+                >
+                  <FolderClosed class="h-4 w-4 text-amber-500 shrink-0" />
+                  <template v-if="isRenamingFolder(item.item.id)">
+                    <input
+                      :ref="setRenameInputRef"
+                      v-model="renameValue"
+                      data-no-drag="true"
+                      class="min-w-0 flex-1 rounded border border-primary/50 bg-transparent px-1 text-[13px] outline-none"
+                      @keydown.enter.prevent="confirmRename"
+                      @keydown.escape.prevent="cancelRename"
+                      @blur="confirmRename"
+                      @mousedown.stop
+                      @click.stop
+                    />
+                  </template>
+                  <span v-else class="dbx-sql-library-drag-label min-w-0 flex-1 truncate">
+                    {{ item.item.name }}
+                    <span class="ml-1 text-muted-foreground">({{ folderFileCount(item.item.id) }})</span>
+                  </span>
+                </div>
+
+                <div
+                  v-else
+                  class="relative flex items-center gap-1 px-2 py-1.5 text-[13px] cursor-pointer group"
+                  :class="[fileRowClass(item.item.id), isDraggingItem(item.item.id) ? 'opacity-50' : '']"
+                  @mousedown="handleDragMouseDown($event, item.item.id, 'file')"
+                  @click="handleFileClick(item.item, $event)"
+                  @contextmenu.capture="contextTarget = item.item"
+                  @contextmenu.prevent="
+                    contextTarget = item.item;
+                    onContextMenu($event);
+                  "
+                >
+                  <FileText class="h-3.5 w-3.5 text-blue-400 shrink-0" />
+                  <span v-if="isFileDirty(item.item)" aria-hidden="true" class="dirty-sql-library-marker">*</span>
+                  <template v-if="isRenamingFile(item.item.id)">
+                    <input
+                      :ref="setRenameInputRef"
+                      v-model="renameValue"
+                      data-no-drag="true"
+                      class="min-w-0 flex-1 rounded border border-primary/50 bg-transparent px-1 text-[13px] outline-none"
+                      @keydown.enter.prevent="confirmRename"
+                      @keydown.escape.prevent="cancelRename"
+                      @blur="confirmRename"
+                      @mousedown.stop
+                      @click.stop
+                    />
+                  </template>
+                  <span v-else class="dbx-sql-library-drag-label min-w-0 flex-1 truncate" :title="fileTitleLabel(item.item)" :style="fileTitleStyle(item.item)">{{ item.item.name }}</span>
+                  <span class="min-w-0 max-w-[45%] shrink truncate text-[13px]" :class="fileMetaClass(item.item.id)" :title="getConnectionLabel(item.item.connectionId)">[{{ getConnectionLabel(item.item.connectionId) }}]</span>
+                </div>
+              </div>
+            </div>
+
+            <!-- Tree structure sorted by folder -->
+            <div v-else>
+              <div v-for="row in visibleFolderRows" :key="row.type === 'folder' ? row.folder.id : row.file.id">
+                <div
+                  v-if="row.type === 'folder'"
+                  class="relative flex items-center gap-1 py-1.5 pr-2 text-[13px] cursor-pointer group"
+                  :style="{ paddingLeft: `${8 + row.depth * 16}px` }"
+                  :class="[showDropInside(row.folder.id) ? 'ring-1 ring-primary/50 bg-primary/5' : folderRowClass(row.folder.id), isDraggingItem(row.folder.id) ? 'opacity-50' : '']"
+                  @mousedown="handleDragMouseDown($event, row.folder.id, 'folder')"
+                  @mousemove="updateDropTarget($event, row.folder.id, 'folder')"
+                  @mouseleave="clearDropTarget(row.folder.id)"
+                  @click="handleFolderClick(row.folder, $event)"
+                  @contextmenu.capture="contextTarget = row.folder"
+                  @contextmenu.prevent="
+                    contextTarget = row.folder;
+                    onContextMenu($event);
+                  "
+                >
+                  <div v-if="showDropBefore(row.folder.id)" class="absolute left-2 right-2 top-0 border-t-2 border-primary" />
+                  <div v-if="showDropAfter(row.folder.id)" class="absolute left-2 right-2 bottom-0 border-b-2 border-primary" />
+                  <component :is="isFolderExpanded(row.folder.id) ? FolderOpen : FolderClosed" class="h-4 w-4 text-amber-500 shrink-0" />
+                  <template v-if="isRenamingFolder(row.folder.id)">
+                    <input
+                      :ref="setRenameInputRef"
+                      v-model="renameValue"
+                      data-no-drag="true"
+                      class="min-w-0 flex-1 rounded border border-primary/50 bg-transparent px-1 text-[13px] outline-none"
+                      @keydown.enter.prevent="confirmRename"
+                      @keydown.escape.prevent="cancelRename"
+                      @blur="confirmRename"
+                      @mousedown.stop
+                      @click.stop
+                    />
+                  </template>
+                  <span v-else class="dbx-sql-library-drag-label min-w-0 flex-1 truncate">
+                    {{ row.folder.name }}
+                    <span class="ml-1 text-muted-foreground">({{ folderFileCount(row.folder.id) }})</span>
+                  </span>
+                </div>
+
+                <div
+                  v-else
+                  class="relative flex items-center gap-1 py-1.5 pr-2 text-[13px] cursor-pointer group"
+                  :style="{ paddingLeft: `${8 + row.depth * 16}px` }"
+                  :class="[fileRowClass(row.file.id), isDraggingItem(row.file.id) ? 'opacity-50' : '']"
+                  @mousedown="handleDragMouseDown($event, row.file.id, 'file')"
+                  @mousemove="updateDropTarget($event, row.file.id, 'file')"
+                  @mouseleave="clearDropTarget(row.file.id)"
+                  @click="handleFileClick(row.file, $event)"
+                  @contextmenu.capture="contextTarget = row.file"
+                  @contextmenu.prevent="
+                    contextTarget = row.file;
+                    onContextMenu($event);
+                  "
+                >
+                  <div v-if="showDropBefore(row.file.id)" class="absolute left-2 right-2 top-0 border-t-2 border-primary" />
+                  <div v-if="showDropAfter(row.file.id)" class="absolute left-2 right-2 bottom-0 border-b-2 border-primary" />
+                  <FileText class="h-3.5 w-3.5 text-blue-400 shrink-0" />
+                  <span v-if="isFileDirty(row.file)" aria-hidden="true" class="dirty-sql-library-marker">*</span>
+                  <template v-if="isRenamingFile(row.file.id)">
+                    <input
+                      :ref="setRenameInputRef"
+                      v-model="renameValue"
+                      data-no-drag="true"
+                      class="min-w-0 flex-1 rounded border border-primary/50 bg-transparent px-1 text-[13px] outline-none"
+                      @keydown.enter.prevent="confirmRename"
+                      @keydown.escape.prevent="cancelRename"
+                      @blur="confirmRename"
+                      @mousedown.stop
+                      @click.stop
+                    />
+                  </template>
+                  <span v-else class="dbx-sql-library-drag-label min-w-0 flex-1 truncate" :title="fileTitleLabel(row.file)" :style="fileTitleStyle(row.file)">{{ row.file.name }}</span>
+                  <span class="min-w-0 max-w-[45%] shrink truncate text-[13px]" :class="fileMetaClass(row.file.id)" :title="getConnectionLabel(row.file.connectionId)">[{{ getConnectionLabel(row.file.connectionId) }}]</span>
+                </div>
+              </div>
+
+              <div v-if="visibleFiles.length > 0 || dragState.draggedType === 'file'">
+                <div
+                  v-if="dragState.draggedType === 'file'"
+                  class="relative px-2 py-1 text-[10px] font-medium uppercase text-muted-foreground"
+                  :class="showDropInside(UNFILED_DROP_TARGET_ID) ? 'ring-1 ring-primary/50 bg-primary/5' : ''"
+                  @mousemove="updateDropTarget($event, UNFILED_DROP_TARGET_ID, 'unfiled')"
+                  @mouseleave="clearDropTarget(UNFILED_DROP_TARGET_ID)"
+                >
+                  {{ t("sqlLibrary.unfiled") }}
+                </div>
+                <div
+                  v-for="file in visibleFiles"
+                  :key="file.id"
+                  class="relative flex items-center gap-1 px-2 py-1.5 text-[13px] cursor-pointer group"
+                  :class="[fileRowClass(file.id), isDraggingItem(file.id) ? 'opacity-50' : '']"
+                  @mousedown="handleDragMouseDown($event, file.id, 'file')"
+                  @mousemove="updateDropTarget($event, file.id, 'file')"
+                  @mouseleave="clearDropTarget(file.id)"
+                  @click="handleFileClick(file, $event)"
+                  @contextmenu.capture="contextTarget = file"
+                  @contextmenu.prevent="
+                    contextTarget = file;
+                    onContextMenu($event);
+                  "
+                >
+                  <div v-if="showDropBefore(file.id)" class="absolute left-2 right-2 top-0 border-t-2 border-primary" />
+                  <div v-if="showDropAfter(file.id)" class="absolute left-2 right-2 bottom-0 border-b-2 border-primary" />
+                  <FileText class="h-3.5 w-3.5 text-blue-400 shrink-0" />
+                  <span v-if="isFileDirty(file)" aria-hidden="true" class="dirty-sql-library-marker">*</span>
+                  <template v-if="isRenamingFile(file.id)">
+                    <input
+                      :ref="setRenameInputRef"
+                      v-model="renameValue"
+                      data-no-drag="true"
+                      class="min-w-0 flex-1 rounded border border-primary/50 bg-transparent px-1 text-[13px] outline-none"
+                      @keydown.enter.prevent="confirmRename"
+                      @keydown.escape.prevent="cancelRename"
+                      @blur="confirmRename"
+                      @mousedown.stop
+                      @click.stop
+                    />
+                  </template>
+                  <span v-else class="dbx-sql-library-drag-label min-w-0 flex-1 truncate" :title="fileTitleLabel(file)" :style="fileTitleStyle(file)">{{ file.name }}</span>
+                  <span class="min-w-0 max-w-[45%] shrink truncate text-[13px]" :class="fileMetaClass(file.id)" :title="getConnectionLabel(file.connectionId)">[{{ getConnectionLabel(file.connectionId) }}]</span>
+                </div>
+              </div>
+            </div>
+            <!-- End tree structure -->
+
+            <div v-if="!hasAnyVisibleItem" class="flex h-full flex-col items-center justify-center gap-2 text-muted-foreground">
+              <Library class="h-8 w-8 opacity-30" />
+              <p class="text-[13px]">{{ t("sqlLibrary.empty") }}</p>
+            </div>
+          </div>
+        </template>
+      </CustomContextMenu>
+    </div>
+
+    <Dialog v-model:open="showDeleteConfirm">
+      <DialogContent class="sm:max-w-[380px]">
+        <DialogHeader>
+          <DialogTitle v-if="deleteTarget?.type === 'folder'">{{ t("savedSql.deleteFolder") }}</DialogTitle>
+          <DialogTitle v-else>{{ t("savedSql.deleteFile") }}</DialogTitle>
+          <DialogDescription v-if="deleteTarget?.type === 'folder'">
+            {{ t("savedSql.deleteFolderConfirm", { name: deleteTarget?.name || "" }) }}
+          </DialogDescription>
+          <DialogDescription v-else>
+            {{ t("savedSql.deleteFileConfirm", { name: deleteTarget?.name || "" }) }}
+          </DialogDescription>
+        </DialogHeader>
+        <DialogFooter>
+          <Button variant="outline" size="sm" @click="showDeleteConfirm = false">{{ t("dangerDialog.cancel") }}</Button>
+          <Button variant="destructive" size="sm" @click="executeDelete">{{ t("dangerDialog.confirm") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+
+    <!-- Batch Delete Confirmation Dialog -->
+    <Dialog :open="showBatchDeleteConfirm" @update:open="(open) => (showBatchDeleteConfirm = open)">
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>{{ t("sqlLibrary.batchDelete") }}</DialogTitle>
+          <DialogDescription>
+            {{ t("sqlLibrary.batchDeleteConfirm", { count: selectedCount }) }}
+          </DialogDescription>
+        </DialogHeader>
+        <DialogFooter>
+          <Button variant="outline" size="sm" @click="showBatchDeleteConfirm = false">{{ t("dangerDialog.cancel") }}</Button>
+          <Button variant="destructive" size="sm" @click="executeBatchDelete">{{ t("dangerDialog.confirm") }}</Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  </div>
+</template>
+
+<style scoped>
+.dirty-sql-library-marker {
+  display: inline-flex;
+  width: 0.5rem;
+  height: 0.75rem;
+  flex-shrink: 0;
+  align-items: center;
+  justify-content: center;
+  color: currentColor;
+  font-size: 13px;
+  font-weight: 700;
+  line-height: 12px;
+  opacity: 0.9;
+  transform: translateY(2px);
+}
+</style>
diff --git a/apps/desktop/src/components/layout/UpdateDialog.vue b/apps/desktop/src/components/layout/UpdateDialog.vue
new file mode 100644
index 0000000..f2e4f76
--- /dev/null
+++ b/apps/desktop/src/components/layout/UpdateDialog.vue
@@ -0,0 +1,123 @@
+<script setup lang="ts">
+import { ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Loader2 } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import type { UpdateInfo } from "@/lib/backend/api";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { canDownloadAndInstallUpdate } from "@/composables/useAppUpdater";
+
+const open = defineModel<boolean>("open", { required: true });
+
+const props = defineProps<{
+  updateInfo: UpdateInfo | null;
+  updateCheckMessage: string;
+  isDownloadingUpdate: boolean;
+  downloadProgress: number;
+  updateReady: boolean;
+}>();
+
+const emit = defineEmits<{
+  "open-latest-release": [];
+  "download-and-install": [];
+  restart: [];
+}>();
+
+const { t } = useI18n();
+const isDesktop = isTauriRuntime();
+
+const renderedNotes = ref("");
+
+function handleReleaseNotesClick(event: MouseEvent) {
+  const target = event.target as HTMLElement;
+  const anchor = target.closest("a");
+  if (!anchor) return;
+  event.preventDefault();
+  const url = anchor.getAttribute("href");
+  if (!url) return;
+  if (isTauriRuntime()) {
+    import("@tauri-apps/plugin-shell").then(({ open }) => open(url));
+  } else {
+    window.open(url, "_blank", "noopener,noreferrer");
+  }
+}
+
+watch(
+  () => props.updateInfo?.release_notes,
+  async (notes) => {
+    if (!notes) {
+      renderedNotes.value = "";
+      return;
+    }
+    const { Marked } = await import("marked");
+    const marked = new Marked({ breaks: true, gfm: true });
+    renderedNotes.value = marked.parse(notes) as string;
+  },
+  { immediate: true },
+);
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent
+      class="sm:max-w-[520px]"
+      @interact-outside="
+        (e: Event) => {
+          if (isDownloadingUpdate || updateReady) e.preventDefault();
+        }
+      "
+      @escape-key-down="
+        (e: Event) => {
+          if (isDownloadingUpdate || updateReady) e.preventDefault();
+        }
+      "
+    >
+      <DialogHeader>
+        <DialogTitle>{{ updateInfo?.update_available ? t("updates.availableTitle") : t("updates.title") }}</DialogTitle>
+      </DialogHeader>
+      <div class="space-y-3 text-sm">
+        <p v-if="updateInfo?.update_available">
+          {{
+            t("updates.availableMessage", {
+              current: updateInfo.current_version,
+              latest: updateInfo.latest_version,
+            })
+          }}
+        </p>
+        <p v-else class="text-muted-foreground">
+          {{ updateCheckMessage || t("updates.upToDate", { version: updateInfo?.current_version || "" }) }}
+        </p>
+        <div
+          v-if="updateInfo?.update_available && updateInfo.release_notes"
+          class="max-h-48 overflow-auto rounded-md border bg-muted/30 p-3 text-xs [&_h1]:text-sm [&_h1]:font-semibold [&_h1]:mb-1 [&_h2]:text-sm [&_h2]:font-semibold [&_h2]:mb-1 [&_h3]:text-xs [&_h3]:font-semibold [&_h3]:mb-1 [&_ul]:list-disc [&_ul]:pl-4 [&_ul]:my-1 [&_ol]:list-decimal [&_ol]:pl-4 [&_ol]:my-1 [&_li]:my-0.5 [&_p]:my-1 [&_code]:bg-muted [&_code]:px-1 [&_code]:py-0.5 [&_code]:rounded [&_code]:text-[11px] [&_a]:text-primary [&_a]:underline"
+          v-html="renderedNotes"
+          @click="handleReleaseNotesClick"
+        />
+        <p v-if="!isDesktop && updateInfo?.update_available" class="text-xs text-muted-foreground">
+          {{ t("updates.dockerUsersRun") }}
+          <code class="bg-muted px-1 py-0.5 rounded text-[11px]">docker compose pull && docker compose up -d</code>
+          {{ t("updates.toUpdate") }}
+        </p>
+        <p v-if="isDesktop && updateInfo?.update_available && updateInfo.portable_mode" class="text-xs text-muted-foreground">
+          {{ t("updates.portableManualUpdate") }}
+        </p>
+      </div>
+      <DialogFooter>
+        <Button v-if="!isDownloadingUpdate && !updateReady" variant="outline" @click="open = false">{{ t("dangerDialog.cancel") }}</Button>
+        <template v-if="updateInfo?.update_available">
+          <Button variant="outline" @click="emit('open-latest-release')">{{ t("updates.openRelease") }}</Button>
+          <template v-if="canDownloadAndInstallUpdate(updateInfo, isDesktop)">
+            <Button v-if="updateReady" @click="emit('restart')">{{ t("updates.restart") }}</Button>
+            <Button v-else-if="isDownloadingUpdate" disabled>
+              <Loader2 class="h-4 w-4 animate-spin" />
+              {{ t("updates.downloading", { progress: downloadProgress }) }}
+            </Button>
+            <Button v-else @click="emit('download-and-install')">{{ t("updates.downloadAndInstall") }}</Button>
+          </template>
+        </template>
+        <Button v-else-if="updateCheckMessage" @click="emit('open-latest-release')">{{ t("updates.openRelease") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/layout/WelcomeScreen.vue b/apps/desktop/src/components/layout/WelcomeScreen.vue
new file mode 100644
index 0000000..281de77
--- /dev/null
+++ b/apps/desktop/src/components/layout/WelcomeScreen.vue
@@ -0,0 +1,183 @@
+<script setup lang="ts">
+import { useI18n } from "vue-i18n";
+import { FilePlus2, Plus, History, Download, Database, Search, ShieldCheck, Sparkles } from "@lucide/vue";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import TruncatedTextTooltip from "@/components/ui/TruncatedTextTooltip.vue";
+import { connectionDriverLabel, connectionIconType, connectionRedactedNameLabel, connectionRedactedOptionSubtitle } from "@/lib/connection/connectionPresentation";
+import type { ConnectionConfig } from "@/types/database";
+
+export interface WelcomeSavedSqlHistoryItem {
+  id: string;
+  name: string;
+  connectionName: string;
+  database?: string;
+  folderName?: string;
+  openCount?: number;
+}
+
+defineProps<{
+  connectionStats: { total: number; connected: number; types: number };
+  recentConnections: ConnectionConfig[];
+  savedSqlHistoryItems: WelcomeSavedSqlHistoryItem[];
+  appVersion: string;
+  hasConnections: boolean;
+}>();
+
+const emit = defineEmits<{
+  "open-connection-query": [connectionId: string];
+  "open-saved-sql": [fileId: string];
+  "new-connection": [];
+  "new-query": [];
+  "show-history": [];
+  "import-config": [];
+  "open-github": [];
+  "open-mcp-guide": [];
+}>();
+
+const { t } = useI18n();
+
+function welcomeConnectionSubtitle(connection: ConnectionConfig): string {
+  return connectionRedactedOptionSubtitle(connection) || connectionDriverLabel(connection);
+}
+</script>
+
+<template>
+  <div class="min-w-0 flex-1 overflow-x-hidden overflow-y-auto bg-background">
+    <div class="welcome-content mx-auto flex min-h-full w-full min-w-0 max-w-5xl flex-col justify-center gap-6 px-8 py-10">
+      <div class="welcome-stats-grid grid min-w-0 grid-cols-1 gap-3 sm:grid-cols-3">
+        <div class="min-w-0 overflow-hidden rounded-lg border bg-muted/20 px-4 py-3">
+          <div class="flex min-w-0 items-center gap-2 text-xs text-muted-foreground">
+            <Database class="h-3.5 w-3.5 shrink-0" /> <span class="min-w-0 truncate">{{ t("welcome.connections") }}</span>
+          </div>
+          <div class="mt-2 text-2xl font-semibold">{{ connectionStats.total }}</div>
+        </div>
+        <div class="min-w-0 overflow-hidden rounded-lg border bg-muted/20 px-4 py-3">
+          <div class="flex min-w-0 items-center gap-2 text-xs text-muted-foreground">
+            <ShieldCheck class="h-3.5 w-3.5 shrink-0" /> <span class="min-w-0 truncate">{{ t("welcome.connected") }}</span>
+          </div>
+          <div class="mt-2 text-2xl font-semibold">{{ connectionStats.connected }}</div>
+        </div>
+        <div class="min-w-0 overflow-hidden rounded-lg border bg-muted/20 px-4 py-3">
+          <div class="flex min-w-0 items-center gap-2 text-xs text-muted-foreground">
+            <Sparkles class="h-3.5 w-3.5 shrink-0" /> <span class="min-w-0 truncate">{{ t("welcome.databaseTypes") }}</span>
+          </div>
+          <div class="mt-2 text-2xl font-semibold">{{ connectionStats.types }}</div>
+        </div>
+      </div>
+
+      <div class="welcome-main-grid grid min-w-0 grid-cols-1 gap-4 lg:grid-cols-[minmax(0,1.2fr)_minmax(0,0.8fr)]">
+        <div class="min-w-0 overflow-hidden rounded-lg border">
+          <div class="flex items-center justify-between border-b px-4 py-3">
+            <div class="text-sm font-medium">{{ t("welcome.quickConnections") }}</div>
+          </div>
+          <div class="divide-y">
+            <button v-for="connection in recentConnections" :key="connection.id" class="flex w-full min-w-0 items-center gap-3 overflow-hidden px-4 py-3 text-left hover:bg-muted/40" @click="emit('open-connection-query', connection.id)">
+              <DatabaseIcon :db-type="connectionIconType(connection)" class="h-4 w-4 shrink-0" />
+              <span class="h-5 w-1 rounded-full shrink-0" :style="{ backgroundColor: connection.color || '#9ca3af' }" />
+              <div class="min-w-0 flex-1">
+                <TruncatedTextTooltip :text="connectionRedactedNameLabel(connection)" class="block text-sm font-medium" />
+                <TruncatedTextTooltip :text="welcomeConnectionSubtitle(connection)" class="block text-xs text-muted-foreground" tooltip-class="max-w-[min(42rem,calc(100vw-2rem))] whitespace-pre-wrap break-all px-3 py-2 text-left leading-5" />
+              </div>
+              <FilePlus2 class="h-4 w-4 shrink-0 text-muted-foreground" />
+            </button>
+            <div v-if="recentConnections.length === 0" class="px-4 py-8 text-sm text-muted-foreground">
+              {{ t("sidebar.noConnections") }}
+            </div>
+          </div>
+        </div>
+
+        <div class="min-w-0 overflow-hidden rounded-lg border">
+          <div class="border-b px-4 py-3">
+            <div class="text-sm font-medium">{{ t("welcome.shortcuts") }}</div>
+          </div>
+          <div class="grid min-w-0 gap-1 p-2">
+            <button class="flex min-w-0 items-center gap-2 overflow-hidden rounded-md px-3 py-2 text-left text-sm hover:bg-muted/50" @click="emit('new-connection')">
+              <Plus class="h-4 w-4 shrink-0" /> <span class="min-w-0 truncate">{{ t("toolbar.newConnection") }}</span>
+            </button>
+            <button class="flex min-w-0 items-center gap-2 overflow-hidden rounded-md px-3 py-2 text-left text-sm hover:bg-muted/50" :disabled="!hasConnections" @click="emit('new-query')">
+              <FilePlus2 class="h-4 w-4 shrink-0" /> <span class="min-w-0 truncate">{{ t("toolbar.newQuery") }}</span>
+            </button>
+            <button class="flex min-w-0 items-center gap-2 overflow-hidden rounded-md px-3 py-2 text-left text-sm hover:bg-muted/50" @click="emit('show-history')">
+              <History class="h-4 w-4 shrink-0" /> <span class="min-w-0 truncate">{{ t("history.title") }}</span>
+            </button>
+            <button class="flex min-w-0 items-center gap-2 overflow-hidden rounded-md px-3 py-2 text-left text-sm hover:bg-muted/50" @click="emit('import-config')">
+              <Download class="h-4 w-4 shrink-0" /> <span class="min-w-0 truncate">{{ t("sidebar.import") }}</span>
+            </button>
+            <div class="mt-2 min-w-0 overflow-hidden rounded-md bg-muted/30 px-3 py-2 text-xs leading-5 text-muted-foreground">
+              <Search class="mr-1 inline h-3.5 w-3.5 shrink-0" />
+              {{ t("welcome.tip") }}
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="min-w-0 overflow-hidden rounded-lg border">
+        <div class="flex items-center justify-between border-b px-4 py-3">
+          <div class="flex min-w-0 items-center gap-2 text-sm font-medium">
+            <History class="h-4 w-4 shrink-0" /> <span class="min-w-0 truncate">{{ t("welcome.sqlHistory") }}</span>
+          </div>
+        </div>
+        <div class="divide-y">
+          <button v-for="item in savedSqlHistoryItems" :key="item.id" class="flex w-full min-w-0 items-center gap-3 overflow-hidden px-4 py-3 text-left hover:bg-muted/40" @click="emit('open-saved-sql', item.id)">
+            <History class="h-4 w-4 shrink-0 text-muted-foreground" />
+            <div class="min-w-0 flex-1">
+              <div class="truncate text-sm font-medium">{{ item.name }}</div>
+              <div class="truncate text-xs text-muted-foreground">
+                <span>{{ item.connectionName }}</span>
+                <span v-if="item.database"> · {{ item.database }}</span>
+                <span v-if="item.folderName"> · {{ item.folderName }}</span>
+                <span v-if="item.openCount"> · {{ t("welcome.sqlHistoryOpenCount", { count: item.openCount }) }}</span>
+              </div>
+            </div>
+            <FilePlus2 class="h-4 w-4 shrink-0 text-muted-foreground" />
+          </button>
+          <div v-if="savedSqlHistoryItems.length === 0" class="px-4 py-8 text-sm text-muted-foreground">
+            {{ t("welcome.sqlHistoryEmpty") }}
+          </div>
+        </div>
+      </div>
+
+      <!-- MCP Integration Hint -->
+      <div class="min-w-0 overflow-hidden rounded-lg border bg-muted/10 px-5 py-4">
+        <div class="flex min-w-0 items-start gap-3">
+          <Sparkles class="h-4 w-4 mt-0.5 text-muted-foreground shrink-0" />
+          <div class="min-w-0 flex-1">
+            <div class="text-sm font-medium">{{ t("welcome.mcpTitle") }}</div>
+            <p class="mt-1 text-xs leading-5 text-muted-foreground">
+              {{ t("welcome.mcpDescription") }}
+            </p>
+            <div class="mt-2 flex flex-wrap items-center gap-2">
+              <code class="max-w-full break-all rounded bg-muted px-2 py-0.5 text-[11px] select-all">npx @dbx-app/mcp-server</code>
+              <a href="#" class="text-xs text-primary hover:underline" @click.prevent="emit('open-mcp-guide')">{{ t("welcome.mcpLearnMore") }}</a>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <!-- Project Info -->
+      <div class="mt-2 flex items-center justify-center gap-3 text-[11px] text-muted-foreground/60">
+        <span>DBX {{ appVersion ? "v" + appVersion : "" }}</span>
+        <span>·</span>
+        <a href="#" class="hover:text-foreground transition-colors" @click.prevent="emit('open-github')">GitHub</a>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style>
+.welcome-content {
+  max-width: 64rem;
+}
+
+@media (min-width: 640px) {
+  .welcome-stats-grid {
+    grid-template-columns: repeat(3, minmax(0, 1fr)) !important;
+  }
+}
+
+@media (min-width: 1024px) {
+  .welcome-main-grid {
+    grid-template-columns: minmax(0, 1.2fr) minmax(0, 0.8fr) !important;
+  }
+}
+</style>
diff --git a/apps/desktop/src/components/layout/WindowControls.vue b/apps/desktop/src/components/layout/WindowControls.vue
new file mode 100644
index 0000000..3205ea3
--- /dev/null
+++ b/apps/desktop/src/components/layout/WindowControls.vue
@@ -0,0 +1,28 @@
+<script setup lang="ts">
+import { Minus, Square, Copy, X } from "@lucide/vue";
+
+defineProps<{
+  isMaximized: boolean;
+}>();
+
+const emit = defineEmits<{
+  minimize: [];
+  "toggle-maximize": [];
+  close: [];
+}>();
+</script>
+
+<template>
+  <div class="flex items-stretch -mr-2 ml-1">
+    <button class="inline-flex items-center justify-center w-11.5 h-10 hover:bg-foreground/10 transition-colors" @click="emit('minimize')">
+      <Minus class="h-4 w-4" />
+    </button>
+    <button class="inline-flex items-center justify-center w-11.5 h-10 hover:bg-foreground/10 transition-colors" @click="emit('toggle-maximize')">
+      <Copy v-if="isMaximized" class="h-3.5 w-3.5" />
+      <Square v-else class="h-3.5 w-3.5" />
+    </button>
+    <button class="inline-flex items-center justify-center w-11.5 h-10 hover:bg-red-500 hover:text-white transition-colors" @click="emit('close')">
+      <X class="h-4 w-4" />
+    </button>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/lineage/FieldLineageDialog.vue b/apps/desktop/src/components/lineage/FieldLineageDialog.vue
new file mode 100644
index 0000000..2adac3d
--- /dev/null
+++ b/apps/desktop/src/components/lineage/FieldLineageDialog.vue
@@ -0,0 +1,401 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { useSqlHighlighter } from "@/composables/useSqlHighlighter";
+import { ArrowUpRight, Check, Columns3, Copy, Eye, Filter, History, Link, Loader2, RefreshCw, Search, SearchX, X } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Dialog, DialogFooter, DialogHeader, DialogScrollContent, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { useToast } from "@/composables/useToast";
+import { useConnectionStore } from "@/stores/connectionStore";
+import * as api from "@/lib/backend/api";
+import { analyzeFieldLineage, summarizeLineageCounts, type FieldLineageConfidence, type FieldLineageItem, type FieldLineageResult, type FieldLineageTable, type FieldLineageView } from "@/lib/diagram/fieldLineage";
+import { copyToClipboard } from "@/lib/common/clipboard";
+
+const props = defineProps<{
+  open: boolean;
+  prefillConnectionId: string;
+  prefillDatabase: string;
+  prefillSchema?: string;
+  prefillTable: string;
+  prefillColumn: string;
+}>();
+
+const emit = defineEmits<{
+  "update:open": [value: boolean];
+  "open-target": [
+    value: {
+      connectionId: string;
+      database: string;
+      schema?: string;
+      tableName: string;
+      tableType?: string;
+      columnName?: string;
+    },
+  ];
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+const { highlight } = useSqlHighlighter();
+const connectionStore = useConnectionStore();
+const dialogOpen = computed({
+  get: () => props.open,
+  set: (value) => emit("update:open", value),
+});
+
+const MAX_TABLES = 180;
+const MAX_VIEW_DDLS = 60;
+const BATCH_SIZE = 6;
+
+const loading = ref(false);
+const cancelled = ref(false);
+const error = ref("");
+const progressDone = ref(0);
+const progressTotal = ref(0);
+const result = ref<FieldLineageResult | null>(null);
+const confidenceFilter = ref<"all" | FieldLineageConfidence>("all");
+const searchText = ref("");
+const copiedId = ref("");
+let runId = 0;
+
+const targetLabel = computed(() => {
+  const scope = props.prefillSchema ? `${props.prefillSchema}.${props.prefillTable}` : props.prefillTable;
+  return `${scope}.${props.prefillColumn}`;
+});
+
+const counts = computed(() => summarizeLineageCounts(result.value?.items ?? []));
+
+const confidenceOptions = computed<Array<{ value: "all" | FieldLineageConfidence; label: string; count: number }>>(() => [
+  { value: "all", label: t("lineage.all"), count: result.value?.items.length ?? 0 },
+  { value: "certain", label: t("lineage.certain"), count: counts.value.certain },
+  { value: "likely", label: t("lineage.likely"), count: counts.value.likely },
+  { value: "possible", label: t("lineage.possible"), count: counts.value.possible },
+]);
+
+const filteredItems = computed(() => {
+  const query = searchText.value.trim().toLowerCase();
+  return (result.value?.items ?? [])
+    .filter((item) => confidenceFilter.value === "all" || item.confidence === confidenceFilter.value)
+    .filter((item) => {
+      if (!query) return true;
+      return [item.title, item.schema, item.table, item.column, item.sqlSnippet, itemKindLabel(item), itemDescription(item)].some((value) =>
+        String(value ?? "")
+          .toLowerCase()
+          .includes(query),
+      );
+    })
+    .sort((a, b) => itemRank(a) - itemRank(b));
+});
+
+const filteredCounts = computed(() => summarizeLineageCounts(filteredItems.value));
+
+watch(
+  dialogOpen,
+  (open) => {
+    if (open) {
+      confidenceFilter.value = "all";
+      searchText.value = "";
+      void loadLineage();
+    } else {
+      cancelLoad();
+    }
+  },
+  { immediate: true },
+);
+
+function cancelLoad() {
+  cancelled.value = true;
+  runId++;
+  loading.value = false;
+}
+
+async function loadLineage() {
+  if (!props.prefillConnectionId || !props.prefillDatabase || !props.prefillTable || !props.prefillColumn) return;
+  const currentRun = ++runId;
+  loading.value = true;
+  cancelled.value = false;
+  error.value = "";
+  result.value = null;
+  progressDone.value = 0;
+  progressTotal.value = 0;
+
+  try {
+    await connectionStore.ensureConnected(props.prefillConnectionId);
+    if (isStale(currentRun)) return;
+
+    const schema = props.prefillSchema || props.prefillDatabase;
+    const tableInfos = prioritizeTargetTable(await api.listTables(props.prefillConnectionId, props.prefillDatabase, schema), props.prefillTable).slice(0, MAX_TABLES);
+    const viewInfos = tableInfos.filter((table) => table.table_type.toUpperCase().includes("VIEW")).slice(0, MAX_VIEW_DDLS);
+    progressTotal.value = tableInfos.length + viewInfos.length + 1;
+
+    const tables: FieldLineageTable[] = [];
+    for (let i = 0; i < tableInfos.length; i += BATCH_SIZE) {
+      if (isStale(currentRun)) return;
+      const batch = tableInfos.slice(i, i + BATCH_SIZE);
+      const loaded = await Promise.all(
+        batch.map(async (table) => {
+          try {
+            const columns = await api.getColumns(props.prefillConnectionId, props.prefillDatabase, schema, table.name);
+            const foreignKeys = await api.listForeignKeys(props.prefillConnectionId, props.prefillDatabase, schema, table.name);
+            return {
+              schema,
+              name: table.name,
+              columns: columns.map((column) => column.name),
+              foreignKeys,
+            };
+          } catch {
+            return { schema, name: table.name, columns: [], foreignKeys: [] };
+          }
+        }),
+      );
+      tables.push(...loaded);
+      progressDone.value += batch.length;
+    }
+
+    const views: FieldLineageView[] = [];
+    for (const view of viewInfos) {
+      if (isStale(currentRun)) return;
+      try {
+        const ddl = await api.getTableDdl(props.prefillConnectionId, props.prefillDatabase, schema, view.name);
+        views.push({ schema, name: view.name, ddl });
+      } catch {
+        // Some drivers may not expose view DDL consistently; keep the rest of the lineage usable.
+      } finally {
+        progressDone.value++;
+      }
+    }
+
+    const histories = (await api.loadHistory(200, 0)).filter((entry) => !entry.database || entry.database === props.prefillDatabase).map((entry) => ({ id: entry.id, sql: entry.sql, executed_at: entry.executed_at }));
+    progressDone.value++;
+    if (isStale(currentRun)) return;
+
+    result.value = analyzeFieldLineage({
+      target: {
+        schema,
+        table: props.prefillTable,
+        column: props.prefillColumn,
+      },
+      tables,
+      views,
+      histories,
+    });
+  } catch (e: any) {
+    if (!isStale(currentRun)) error.value = e?.message || String(e);
+  } finally {
+    if (!isStale(currentRun)) loading.value = false;
+  }
+}
+
+function isStale(id: number) {
+  return cancelled.value || id !== runId;
+}
+
+function prioritizeTargetTable<T extends { name: string }>(tables: T[], targetTable: string): T[] {
+  return [...tables].sort((a, b) => Number(a.name !== targetTable) - Number(b.name !== targetTable));
+}
+
+function itemIcon(item: FieldLineageItem) {
+  if (item.kind === "foreignKey") return Link;
+  if (item.kind === "viewReference") return Eye;
+  if (item.kind === "historyReference") return History;
+  return Columns3;
+}
+
+function confidenceVariant(confidence: FieldLineageItem["confidence"]) {
+  return confidence === "certain" ? "default" : "secondary";
+}
+
+function confidenceTone(confidence: FieldLineageItem["confidence"]) {
+  if (confidence === "certain") return "text-emerald-600 bg-emerald-50 border-emerald-200";
+  if (confidence === "likely") return "text-blue-600 bg-blue-50 border-blue-200";
+  return "text-zinc-600 bg-zinc-50 border-zinc-200";
+}
+
+function itemRank(item: FieldLineageItem) {
+  const confidenceRank = item.confidence === "certain" ? 0 : item.confidence === "likely" ? 10 : 20;
+  const kindRank = item.kind === "foreignKey" ? 0 : item.kind === "viewReference" ? 1 : item.kind === "historyReference" ? 2 : 3;
+  return confidenceRank + kindRank;
+}
+
+function itemKindLabel(item: FieldLineageItem) {
+  return t(`lineage.kind.${item.kind}`);
+}
+
+function itemPrimaryLabel(item: FieldLineageItem) {
+  if (item.kind === "historyReference") return t("lineage.queryHistory");
+  if (item.table && item.column) return `${item.table}.${item.column}`;
+  if (item.table) return `${item.table}.${props.prefillColumn}`;
+  return item.title;
+}
+
+function itemDescription(item: FieldLineageItem) {
+  if (item.kind === "foreignKey") {
+    if (item.direction === "incoming") {
+      return t("lineage.description.foreignKeyIncoming", {
+        target: `${item.table}.${item.column}`,
+      });
+    }
+    return t("lineage.description.foreignKeyOutgoing", { target: `${item.table}.${item.column}` });
+  }
+  if (item.kind === "viewReference") {
+    return item.confidence === "likely" ? t("lineage.description.viewLikely") : t("lineage.description.viewPossible");
+  }
+  if (item.kind === "historyReference") {
+    return item.confidence === "likely" ? t("lineage.description.historyLikely") : t("lineage.description.historyPossible");
+  }
+  return t("lineage.description.sameName");
+}
+
+async function copyItem(item: FieldLineageItem) {
+  const text = itemPrimaryLabel(item);
+  try {
+    await copyToClipboard(text);
+    copiedId.value = item.id;
+    toast(t("lineage.copied"));
+    setTimeout(() => {
+      if (copiedId.value === item.id) copiedId.value = "";
+    }, 1400);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function openItemTarget(item: FieldLineageItem) {
+  if (!item.table) return;
+  emit("open-target", {
+    connectionId: props.prefillConnectionId,
+    database: props.prefillDatabase,
+    schema: item.schema || props.prefillSchema,
+    tableName: item.table,
+    tableType: item.kind === "viewReference" ? "VIEW" : "TABLE",
+    columnName: item.column || props.prefillColumn,
+  });
+}
+</script>
+
+<template>
+  <Dialog v-model:open="dialogOpen">
+    <DialogScrollContent class="h-[78vh] min-h-[560px] max-h-[780px] grid-rows-[auto_minmax(0,1fr)_auto] overflow-hidden gap-0 p-0 sm:max-w-[980px]">
+      <DialogHeader class="border-b px-6 py-4 pr-12">
+        <DialogTitle class="flex items-center gap-2 text-lg">
+          <Link class="h-5 w-5" />
+          {{ t("lineage.title") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="flex min-h-0 flex-col overflow-hidden">
+        <div class="border-b bg-muted/10 px-6 py-3">
+          <div class="flex flex-wrap items-center justify-between gap-3">
+            <div class="min-w-0">
+              <div class="text-xs text-muted-foreground">{{ t("lineage.targetField") }}</div>
+              <div class="mt-1 flex min-w-0 flex-wrap items-center gap-2 text-sm">
+                <span class="max-w-[520px] truncate font-semibold">{{ targetLabel }}</span>
+                <Badge variant="outline">{{ props.prefillDatabase }}</Badge>
+                <Badge v-if="props.prefillSchema" variant="outline">{{ props.prefillSchema }}</Badge>
+              </div>
+            </div>
+            <div v-if="result" class="flex flex-wrap gap-2 text-xs">
+              <Badge>{{ t("lineage.certain") }} {{ counts.certain }}</Badge>
+              <Badge variant="secondary">{{ t("lineage.likely") }} {{ counts.likely }}</Badge>
+              <Badge variant="outline">{{ t("lineage.possible") }} {{ counts.possible }}</Badge>
+            </div>
+          </div>
+
+          <div v-if="result" class="mt-3 flex flex-col gap-2 lg:flex-row lg:items-center">
+            <div class="relative min-w-0 flex-1">
+              <Search class="absolute left-2.5 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
+              <Input v-model="searchText" class="h-8 pl-8 text-sm" :placeholder="t('lineage.searchPlaceholder')" />
+            </div>
+            <div class="flex items-center gap-2 overflow-x-auto">
+              <Filter class="h-4 w-4 shrink-0 text-muted-foreground" />
+              <Button v-for="option in confidenceOptions" :key="option.value" size="sm" :variant="confidenceFilter === option.value ? 'default' : 'outline'" class="h-8 shrink-0 px-3" @click="confidenceFilter = option.value"> {{ option.label }} {{ option.count }} </Button>
+            </div>
+          </div>
+        </div>
+
+        <div class="min-h-0 flex-1 overflow-y-auto px-6 py-4">
+          <div v-if="loading" class="rounded-md border bg-muted/20 p-4">
+            <div class="flex items-center gap-2 text-sm text-muted-foreground">
+              <Loader2 class="h-4 w-4 animate-spin" />
+              {{ t("lineage.loading", { done: progressDone, total: progressTotal || "-" }) }}
+            </div>
+          </div>
+
+          <div v-else-if="error" class="rounded-md border border-destructive/30 bg-destructive/5 p-4 text-sm text-destructive">
+            {{ error }}
+          </div>
+
+          <div v-else-if="result && result.items.length === 0" class="flex flex-col items-center justify-center gap-2 rounded-md border py-12 text-sm text-muted-foreground">
+            <SearchX class="h-8 w-8" />
+            {{ t("lineage.empty") }}
+          </div>
+
+          <template v-else-if="result">
+            <div class="mb-3 flex flex-wrap items-center justify-between gap-2 text-xs text-muted-foreground">
+              <span>{{ t("lineage.showing", { shown: filteredItems.length, total: result.items.length }) }}</span>
+              <span v-if="filteredItems.length">
+                {{ t("lineage.certain") }} {{ filteredCounts.certain }} · {{ t("lineage.likely") }} {{ filteredCounts.likely }} · {{ t("lineage.possible") }}
+                {{ filteredCounts.possible }}
+              </span>
+            </div>
+
+            <div v-if="filteredItems.length === 0" class="flex flex-col items-center justify-center gap-2 rounded-md border py-12 text-sm text-muted-foreground">
+              <SearchX class="h-8 w-8" />
+              {{ t("lineage.noFiltered") }}
+            </div>
+
+            <div v-else class="space-y-2">
+              <div v-for="item in filteredItems" :key="item.id" class="rounded-md border bg-background transition-colors hover:bg-muted/25">
+                <div class="flex items-start gap-3 p-3">
+                  <div :class="['mt-0.5 flex h-7 w-7 shrink-0 items-center justify-center rounded-md border', confidenceTone(item.confidence)]">
+                    <component :is="itemIcon(item)" class="h-4 w-4" />
+                  </div>
+                  <div class="min-w-0 flex-1">
+                    <div class="flex min-w-0 flex-wrap items-center gap-2">
+                      <button
+                        v-if="item.table"
+                        type="button"
+                        class="group inline-flex min-w-0 max-w-[560px] items-center gap-1 truncate rounded-sm font-medium text-primary hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+                        :title="t('lineage.openTable')"
+                        @click="openItemTarget(item)"
+                      >
+                        <span class="truncate">{{ itemPrimaryLabel(item) }}</span>
+                        <ArrowUpRight class="h-3.5 w-3.5 shrink-0 opacity-70 transition-opacity group-hover:opacity-100" />
+                      </button>
+                      <span v-else class="max-w-[560px] truncate font-medium">{{ itemPrimaryLabel(item) }}</span>
+                      <Badge v-if="item.schema" variant="outline" class="text-[10px]">{{ item.schema }}</Badge>
+                      <Badge variant="outline" class="text-[10px]">{{ itemKindLabel(item) }}</Badge>
+                      <Badge :variant="confidenceVariant(item.confidence)" class="text-[10px]">{{ t(`lineage.${item.confidence}`) }}</Badge>
+                    </div>
+                    <p class="mt-1 text-xs leading-5 text-muted-foreground">
+                      {{ itemDescription(item) }}
+                    </p>
+                    <pre v-if="item.sqlSnippet" class="mt-2 max-h-20 overflow-auto rounded-md bg-muted/40 p-2 text-xs whitespace-pre-wrap" v-html="highlight(item.sqlSnippet)" />
+                  </div>
+                  <Button variant="ghost" size="sm" class="h-8 w-8 shrink-0 p-0" :title="t('lineage.copy')" @click="copyItem(item)">
+                    <Check v-if="copiedId === item.id" class="h-4 w-4 text-emerald-600" />
+                    <Copy v-else class="h-4 w-4" />
+                  </Button>
+                </div>
+              </div>
+            </div>
+          </template>
+        </div>
+      </div>
+
+      <DialogFooter class="border-t px-6 py-4">
+        <Button v-if="loading" variant="outline" @click="cancelLoad">
+          <X class="h-4 w-4" />
+          {{ t("lineage.cancel") }}
+        </Button>
+        <Button v-else variant="outline" @click="loadLineage">
+          <RefreshCw class="h-4 w-4" />
+          {{ t("lineage.refresh") }}
+        </Button>
+        <Button @click="dialogOpen = false">{{ t("common.close") }}</Button>
+      </DialogFooter>
+    </DialogScrollContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/mq/BrokerPanel.vue b/apps/desktop/src/components/mq/BrokerPanel.vue
new file mode 100644
index 0000000..e2a47c3
--- /dev/null
+++ b/apps/desktop/src/components/mq/BrokerPanel.vue
@@ -0,0 +1,384 @@
+<script setup lang="ts">
+import { formatError } from "@/lib/backend/errorUtils";
+import { ref, watch, onMounted, onUnmounted } from "vue";
+import type { ClusterInfo } from "@/types/mq";
+import { mqGetClusterInfo } from "@/lib/backend/api";
+
+interface Props {
+  connectionId: string;
+  readOnly?: boolean;
+}
+
+const props = defineProps<Props>();
+
+const clusterInfo = ref<ClusterInfo>();
+const loading = ref(false);
+const error = ref<string>();
+const autoRefresh = ref(true);
+const refreshInterval = ref(10);
+
+let refreshTimer: number | undefined;
+
+function isDocumentHidden(): boolean {
+  return typeof document !== "undefined" && document.hidden;
+}
+
+async function loadClusterInfo(options: { skipWhenHidden?: boolean } = {}) {
+  if (options.skipWhenHidden && isDocumentHidden()) return;
+  loading.value = true;
+  error.value = undefined;
+  try {
+    clusterInfo.value = await mqGetClusterInfo(props.connectionId);
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function refreshNow() {
+  void loadClusterInfo();
+}
+
+function startAutoRefresh() {
+  stopAutoRefresh();
+  if (autoRefresh.value && !isDocumentHidden()) {
+    refreshTimer = window.setInterval(() => {
+      void loadClusterInfo({ skipWhenHidden: true });
+    }, refreshInterval.value * 1000);
+  }
+}
+
+function stopAutoRefresh() {
+  if (refreshTimer !== undefined) {
+    clearInterval(refreshTimer);
+    refreshTimer = undefined;
+  }
+}
+
+function handleVisibilityChange() {
+  if (isDocumentHidden()) {
+    stopAutoRefresh();
+    return;
+  }
+  startAutoRefresh();
+  void loadClusterInfo();
+}
+
+watch(autoRefresh, () => {
+  startAutoRefresh();
+});
+
+watch(refreshInterval, () => {
+  if (autoRefresh.value) {
+    startAutoRefresh();
+  }
+});
+
+onMounted(() => {
+  document.addEventListener("visibilitychange", handleVisibilityChange);
+  void loadClusterInfo();
+  startAutoRefresh();
+});
+
+onUnmounted(() => {
+  document.removeEventListener("visibilitychange", handleVisibilityChange);
+  stopAutoRefresh();
+});
+</script>
+
+<template>
+  <div class="broker-panel">
+    <div class="panel-toolbar">
+      <h3>Broker 集群</h3>
+      <div class="toolbar-actions">
+        <label class="checkbox-label">
+          <input type="checkbox" v-model="autoRefresh" />
+          自动刷新
+        </label>
+        <select v-model.number="refreshInterval" :disabled="!autoRefresh" class="refresh-interval">
+          <option :value="5">5秒</option>
+          <option :value="10">10秒</option>
+          <option :value="30">30秒</option>
+          <option :value="60">60秒</option>
+        </select>
+        <button @click="refreshNow" :disabled="loading" class="btn-sm">
+          {{ loading ? "刷新中..." : "立即刷新" }}
+        </button>
+      </div>
+    </div>
+
+    <div v-if="error" class="panel-error">{{ error }}</div>
+
+    <div v-else-if="loading && !clusterInfo" class="panel-loading">加载中...</div>
+
+    <div v-else-if="clusterInfo" class="broker-content">
+      <!-- 集群概览 -->
+      <div class="stats-section">
+        <h4>集群概览</h4>
+        <div class="stats-grid">
+          <div class="stat-card">
+            <div class="stat-icon">🔗</div>
+            <div class="stat-content">
+              <div class="stat-label">集群 ID</div>
+              <div class="stat-value stat-value-sm">{{ clusterInfo.clusterId || "未知" }}</div>
+            </div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon">🖥️</div>
+            <div class="stat-content">
+              <div class="stat-label">Broker 数量</div>
+              <div class="stat-value">{{ clusterInfo.brokerCount }}</div>
+            </div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon">👑</div>
+            <div class="stat-content">
+              <div class="stat-label">Controller</div>
+              <div class="stat-value stat-value-sm">
+                <template v-if="clusterInfo.controllerHost"> Node {{ clusterInfo.controllerId ?? "?" }} · {{ clusterInfo.controllerHost }} </template>
+                <template v-else>未知</template>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <!-- Broker 节点列表 -->
+      <div class="stats-section">
+        <h4>Broker 节点</h4>
+        <div v-if="clusterInfo.brokers.length" class="broker-table-wrap">
+          <table class="broker-table">
+            <thead>
+              <tr>
+                <th>Node ID</th>
+                <th>Host</th>
+                <th>Port</th>
+                <th>Rack</th>
+                <th>角色</th>
+              </tr>
+            </thead>
+            <tbody>
+              <tr v-for="broker in clusterInfo.brokers" :key="broker.id" :class="{ 'is-controller': broker.id === clusterInfo.controllerId }">
+                <td class="node-id">{{ broker.id }}</td>
+                <td>{{ broker.host }}</td>
+                <td>{{ broker.port }}</td>
+                <td>{{ broker.rack || "-" }}</td>
+                <td>
+                  <span v-if="broker.id === clusterInfo.controllerId" class="role-badge controller">Controller</span>
+                  <span v-else class="role-badge follower">Follower</span>
+                </td>
+              </tr>
+            </tbody>
+          </table>
+        </div>
+        <div v-else class="empty-state">暂无 Broker 节点信息</div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.broker-panel {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.panel-toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.panel-toolbar h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.toolbar-actions {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.checkbox-label {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 13px;
+  cursor: pointer;
+}
+
+.refresh-interval {
+  padding: 4px 8px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  font-size: 13px;
+  background: var(--color-background);
+  cursor: pointer;
+}
+
+.refresh-interval:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.btn-sm {
+  padding: 6px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: 13px;
+  transition: all 0.2s;
+}
+
+.btn-sm:hover:not(:disabled) {
+  background: var(--color-hover);
+}
+
+.btn-sm:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.panel-error,
+.panel-loading,
+.empty-state {
+  padding: 24px;
+  text-align: center;
+  color: var(--color-text-secondary);
+}
+
+.panel-error {
+  color: var(--color-error);
+}
+
+.broker-content {
+  flex: 1;
+  overflow-y: auto;
+  padding: 16px;
+}
+
+.stats-section {
+  margin-bottom: 24px;
+}
+
+.stats-section h4 {
+  margin: 0 0 12px 0;
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--color-text-secondary);
+}
+
+.stats-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  gap: 12px;
+}
+
+.stat-card {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  padding: 16px;
+  background: var(--color-background-secondary);
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  transition: all 0.2s;
+}
+
+.stat-card:hover {
+  border-color: var(--color-primary);
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+}
+
+.stat-icon {
+  font-size: 32px;
+  line-height: 1;
+}
+
+.stat-content {
+  flex: 1;
+  min-width: 0;
+}
+
+.stat-label {
+  font-size: 12px;
+  color: var(--color-text-tertiary);
+  margin-bottom: 4px;
+}
+
+.stat-value {
+  font-size: 20px;
+  font-weight: 600;
+  color: var(--color-text);
+}
+
+.stat-value-sm {
+  font-size: 14px;
+  font-weight: 500;
+  word-break: break-all;
+}
+
+.broker-table-wrap {
+  overflow-x: auto;
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-background-secondary);
+}
+
+.broker-table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+.broker-table th,
+.broker-table td {
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--color-border-light);
+  text-align: left;
+  font-size: 13px;
+}
+
+.broker-table th {
+  color: var(--color-text-secondary);
+  font-weight: 600;
+}
+
+.broker-table tbody tr:last-child td {
+  border-bottom: none;
+}
+
+.broker-table tbody tr.is-controller {
+  background: var(--color-primary-alpha);
+}
+
+.node-id {
+  font-weight: 600;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+}
+
+.role-badge {
+  display: inline-block;
+  padding: 2px 10px;
+  border-radius: 12px;
+  font-size: 12px;
+  font-weight: 500;
+}
+
+.role-badge.controller {
+  background: var(--color-primary-alpha);
+  color: var(--color-primary);
+}
+
+.role-badge.follower {
+  background: var(--color-background-tertiary);
+  color: var(--color-text-secondary);
+}
+</style>
diff --git a/apps/desktop/src/components/mq/MonitoringPanel.vue b/apps/desktop/src/components/mq/MonitoringPanel.vue
new file mode 100644
index 0000000..966f6f5
--- /dev/null
+++ b/apps/desktop/src/components/mq/MonitoringPanel.vue
@@ -0,0 +1,1622 @@
+<script setup lang="ts">
+import { formatError } from "@/lib/backend/errorUtils";
+import { computed, ref, watch, onMounted, onUnmounted } from "vue";
+import { use } from "echarts/core";
+import { CanvasRenderer } from "echarts/renderers";
+import { LineChart } from "echarts/charts";
+import { GridComponent, LegendComponent, TooltipComponent } from "echarts/components";
+import VChart from "vue-echarts";
+import { Activity, AlertTriangle, BarChart3, Boxes, CheckCircle2, Database, Download, Gauge, Hash, HardDrive, Layers3, Loader2, Package, RadioTower, RefreshCw, Send, ShieldCheck, Table2, Upload, Users } from "@lucide/vue";
+import type { TopicRef, TopicInfo, TopicStats, BacklogStats, PeekedMessage } from "@/types/mq";
+import { mqGetTopicStats, mqGetBacklog, mqPeekMessages } from "@/lib/backend/api";
+
+use([CanvasRenderer, LineChart, GridComponent, LegendComponent, TooltipComponent]);
+
+interface Props {
+  connectionId: string;
+  topic?: TopicInfo;
+  tenant?: string;
+  namespace?: string;
+}
+
+interface MetricPoint {
+  time: string;
+  msgRateIn: number;
+  msgRateOut: number;
+  backlogSize: number;
+  msgBacklog: number;
+  consumerLagMs: number;
+}
+
+interface PartitionStatsRow {
+  name: string;
+  shortName: string;
+  msgRateIn: number;
+  msgRateOut: number;
+  msgThroughputIn: number;
+  msgThroughputOut: number;
+  backlogSize: number;
+  msgBacklog: number;
+  storageSize: number;
+  producerCount: number;
+  subscriptionCount: number;
+  raw: Record<string, unknown>;
+}
+
+interface KafkaPartitionStatsRow {
+  partition: number;
+  beginOffset: number;
+  endOffset: number;
+  messageCount: number;
+  leader: number;
+  replicas: number[];
+  isr: number[];
+}
+
+const props = defineProps<Props>();
+
+const stats = ref<TopicStats>();
+const backlog = ref<BacklogStats>();
+const loading = ref(false);
+const error = ref<string>();
+const autoRefresh = ref(true);
+const refreshInterval = ref(5); // seconds
+const selectedPartitionName = ref<string>();
+const kafkaMessageSql = ref("");
+const kafkaMessageLoading = ref(false);
+const kafkaMessageError = ref<string>();
+const kafkaMessages = ref<PeekedMessage[]>([]);
+
+let refreshTimer: number | undefined;
+const history = ref<MetricPoint[]>([]);
+const MAX_HISTORY_POINTS = 60;
+
+const partitionRows = computed(() => extractPartitionRows(stats.value?.raw));
+const kafkaPartitionRows = computed(() => extractKafkaPartitionRows(stats.value?.raw));
+const isKafkaStats = computed(() => isKafkaStatsPayload(stats.value?.raw));
+const kafkaOverview = computed(() => {
+  const raw = objectRecord(stats.value?.raw);
+  const rows = kafkaPartitionRows.value;
+  const totalMessages = numberField(raw.totalMessages) ?? rows.reduce((sum, row) => sum + row.messageCount, 0);
+  const totalBeginOffset = rows.reduce((sum, row) => sum + row.beginOffset, 0);
+  const totalEndOffset = rows.reduce((sum, row) => sum + row.endOffset, 0);
+  const underReplicatedPartitions = rows.filter((row) => row.replicas.length > 0 && row.isr.length < row.replicas.length).length;
+  const offlinePartitions = rows.filter((row) => row.leader < 0).length;
+  const healthyPartitions = rows.filter((row) => row.leader >= 0 && (row.replicas.length === 0 || row.isr.length === row.replicas.length)).length;
+  return {
+    partitionCount: numberField(raw.partitions) ?? rows.length,
+    replicationFactor: numberField(raw.replicationFactor) ?? Math.max(0, ...rows.map((row) => row.replicas.length)),
+    totalMessages,
+    totalBeginOffset,
+    totalEndOffset,
+    leaderCount: new Set(rows.map((row) => row.leader).filter((leader) => leader >= 0)).size,
+    underReplicatedPartitions,
+    offlinePartitions,
+    healthyPartitions,
+  };
+});
+const selectedPartition = computed(() => partitionRows.value.find((row) => row.name === selectedPartitionName.value) ?? partitionRows.value[0]);
+const selectedPartitionPublishers = computed(() => arrayObjects(selectedPartition.value?.raw.publishers));
+const selectedPartitionSubscriptions = computed(() => {
+  const subscriptions = objectRecord(selectedPartition.value?.raw.subscriptions);
+  return Object.entries(subscriptions).map(([name, value]) => {
+    const body = objectRecord(value);
+    return {
+      name,
+      type: stringField(body.type),
+      msgBacklog: numberField(body.msgBacklog) ?? 0,
+      msgRateOut: numberField(body.msgRateOut) ?? 0,
+      consumerCount: arrayObjects(body.consumers).length,
+    };
+  });
+});
+
+const rateChartOption = computed(() => ({
+  tooltip: { trigger: "axis" },
+  legend: { top: 0, data: ["In", "Out"] },
+  grid: { left: 48, right: 18, top: 36, bottom: 32 },
+  xAxis: { type: "category", boundaryGap: false, data: history.value.map((point) => point.time) },
+  yAxis: { type: "value", name: "msg/s" },
+  series: [
+    { name: "In", type: "line", smooth: true, showSymbol: false, data: history.value.map((point) => point.msgRateIn) },
+    { name: "Out", type: "line", smooth: true, showSymbol: false, data: history.value.map((point) => point.msgRateOut) },
+  ],
+}));
+
+const backlogChartOption = computed(() => ({
+  tooltip: { trigger: "axis" },
+  legend: { top: 0, data: ["Messages", "Bytes"] },
+  grid: { left: 56, right: 54, top: 36, bottom: 32 },
+  xAxis: { type: "category", boundaryGap: false, data: history.value.map((point) => point.time) },
+  yAxis: [
+    { type: "value", name: "msg" },
+    { type: "value", name: "bytes" },
+  ],
+  series: [
+    { name: "Messages", type: "line", smooth: true, showSymbol: false, data: history.value.map((point) => point.msgBacklog) },
+    { name: "Bytes", type: "line", smooth: true, showSymbol: false, yAxisIndex: 1, data: history.value.map((point) => point.backlogSize) },
+  ],
+}));
+
+const latencyChartOption = computed(() => ({
+  tooltip: { trigger: "axis" },
+  legend: { top: 0, data: ["Consumer lag"] },
+  grid: { left: 56, right: 18, top: 36, bottom: 32 },
+  xAxis: { type: "category", boundaryGap: false, data: history.value.map((point) => point.time) },
+  yAxis: { type: "value", name: "ms" },
+  series: [{ name: "Consumer lag", type: "line", smooth: true, showSymbol: false, data: history.value.map((point) => point.consumerLagMs) }],
+}));
+
+function getTopicRef(): TopicRef | null {
+  if (!props.topic || !props.tenant || !props.namespace) return null;
+  return {
+    tenant: props.tenant,
+    namespace: props.namespace,
+    topic: props.topic.shortName,
+    persistent: props.topic.persistent,
+    partitioned: props.topic.partitioned,
+  };
+}
+
+function isDocumentHidden(): boolean {
+  return typeof document !== "undefined" && document.hidden;
+}
+
+async function loadStats(options: { skipWhenHidden?: boolean } = {}) {
+  if (options.skipWhenHidden && isDocumentHidden()) return;
+  const topicRef = getTopicRef();
+  if (!topicRef) {
+    stats.value = undefined;
+    backlog.value = undefined;
+    history.value = [];
+    return;
+  }
+  loading.value = true;
+  error.value = undefined;
+  try {
+    const statsData = await mqGetTopicStats(props.connectionId, topicRef);
+
+    if (isKafkaStatsPayload(statsData.raw)) {
+      stats.value = statsData;
+      backlog.value = undefined;
+      appendHistoryPoint(statsData);
+      return;
+    }
+
+    const backlogData = await mqGetBacklog(props.connectionId, topicRef, undefined);
+    stats.value = statsData;
+    backlog.value = backlogData;
+    appendHistoryPoint(statsData, backlogData);
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function refreshNow() {
+  void loadStats();
+}
+
+function defaultKafkaMessageSql(): string {
+  const topic = props.topic?.shortName;
+  return topic ? `SELECT * FROM "${topic}" PARTITION 0 OFFSET 0 LIMIT 20` : "";
+}
+
+function parseKafkaMessageSql(sql: string): { topic: string; partition: number; offset: number; limit: number } {
+  const match = sql.trim().match(/^\s*select\s+\*\s+from\s+(?:"([^"]+)"|`([^`]+)`|'([^']+)'|([^\s;]+))(?:\s+partition\s+(\d+))?(?:\s+offset\s+(\d+))?(?:\s+limit\s+(\d+))?\s*;?\s*$/i);
+  if (!match) {
+    throw new Error('仅支持 SELECT * FROM "topic" [PARTITION n] [OFFSET n] [LIMIT n]');
+  }
+  const topic = match[1] || match[2] || match[3] || match[4] || "";
+  const partition = Math.max(0, Number(match[5] ?? 0));
+  const offset = Math.max(0, Number(match[6] ?? 0));
+  const limit = Math.max(1, Math.min(100, Number(match[7] ?? 20)));
+  return { topic, partition, offset, limit };
+}
+
+async function runKafkaMessageSql() {
+  if (!props.tenant || !props.namespace) return;
+  kafkaMessageLoading.value = true;
+  kafkaMessageError.value = undefined;
+  try {
+    const parsed = parseKafkaMessageSql(kafkaMessageSql.value);
+    const selected = props.topic && parsed.topic === props.topic.shortName ? props.topic : undefined;
+    kafkaMessages.value = await mqPeekMessages(
+      props.connectionId,
+      {
+        tenant: props.tenant,
+        namespace: props.namespace,
+        topic: parsed.topic,
+        persistent: selected?.persistent ?? true,
+        partitioned: selected?.partitioned,
+      },
+      "__dbx_kafka_monitor__",
+      parsed.limit,
+      { partition: parsed.partition, offset: parsed.offset },
+    );
+  } catch (e: unknown) {
+    kafkaMessageError.value = formatError(e);
+  } finally {
+    kafkaMessageLoading.value = false;
+  }
+}
+
+function kafkaMessagePayload(message: PeekedMessage): string {
+  return message.payloadText ?? message.payloadBase64;
+}
+
+function formatKafkaMessageTimestamp(value?: string): string {
+  if (!value) return "-";
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return value;
+  return new Date(numeric).toLocaleString();
+}
+
+function appendHistoryPoint(statsData: TopicStats, backlogData?: BacklogStats) {
+  const point: MetricPoint = {
+    time: new Date().toLocaleTimeString(),
+    msgRateIn: statsData.msgRateIn,
+    msgRateOut: statsData.msgRateOut,
+    backlogSize: statsData.backlogSize,
+    msgBacklog: backlogData?.msgBacklog ?? 0,
+    consumerLagMs: extractConsumerLagMs(statsData.raw),
+  };
+  history.value = [...history.value.slice(-(MAX_HISTORY_POINTS - 1)), point];
+}
+
+function extractConsumerLagMs(raw: unknown): number {
+  if (!raw || typeof raw !== "object") return 0;
+  const subscriptions = (raw as { subscriptions?: unknown }).subscriptions;
+  if (!subscriptions || typeof subscriptions !== "object") return 0;
+  const now = Date.now();
+  let maxLag = 0;
+  for (const subscription of Object.values(subscriptions as Record<string, unknown>)) {
+    if (!subscription || typeof subscription !== "object") continue;
+    const data = subscription as Record<string, unknown>;
+    const timestamp = numberField(data.lastAckedTimestamp) ?? numberField(data.lastConsumedTimestamp) ?? numberField(data.lastMarkDeleteAdvancedTimestamp);
+    if (timestamp && timestamp > 0 && timestamp <= now) {
+      maxLag = Math.max(maxLag, now - timestamp);
+    }
+  }
+  return maxLag;
+}
+
+function extractPartitionRows(raw: unknown): PartitionStatsRow[] {
+  const root = objectRecord(raw);
+  const partitions = objectRecord(root.partitions);
+  return Object.entries(partitions).map(([name, value]) => {
+    const body = objectRecord(value);
+    return {
+      name,
+      shortName: partitionShortName(name),
+      msgRateIn: numberField(body.msgRateIn) ?? 0,
+      msgRateOut: numberField(body.msgRateOut) ?? 0,
+      msgThroughputIn: numberField(body.msgThroughputIn) ?? 0,
+      msgThroughputOut: numberField(body.msgThroughputOut) ?? 0,
+      backlogSize: numberField(body.backlogSize) ?? 0,
+      msgBacklog: partitionBacklogMessages(body),
+      storageSize: numberField(body.storageSize) ?? 0,
+      producerCount: arrayObjects(body.publishers).length,
+      subscriptionCount: Object.keys(objectRecord(body.subscriptions)).length,
+      raw: body,
+    };
+  });
+}
+
+function extractKafkaPartitionRows(raw: unknown): KafkaPartitionStatsRow[] {
+  return arrayObjects(objectRecord(raw).partitionStats)
+    .map((body) => ({
+      partition: numberField(body.partition) ?? 0,
+      beginOffset: numberField(body.beginOffset) ?? 0,
+      endOffset: numberField(body.endOffset) ?? 0,
+      messageCount: numberField(body.messageCount) ?? 0,
+      leader: numberField(body.leader) ?? -1,
+      replicas: numberArrayField(body.replicas),
+      isr: numberArrayField(body.isr),
+    }))
+    .sort((a, b) => a.partition - b.partition);
+}
+
+function isKafkaStatsPayload(raw: unknown): boolean {
+  const root = objectRecord(raw);
+  return Array.isArray(root.partitionStats) || (numberField(root.partitions) !== undefined && numberField(root.replicationFactor) !== undefined && numberField(root.totalMessages) !== undefined);
+}
+
+function isKafkaPartitionHealthy(row: KafkaPartitionStatsRow): boolean {
+  return row.leader >= 0 && (row.replicas.length === 0 || row.isr.length >= row.replicas.length);
+}
+
+function kafkaPartitionStatusLabel(row: KafkaPartitionStatsRow): string {
+  if (row.leader < 0) return "无 leader";
+  if (row.replicas.length > 0 && row.isr.length < row.replicas.length) return "ISR 不完整";
+  return "正常";
+}
+
+function partitionBacklogMessages(body: Record<string, unknown>): number {
+  const direct = numberField(body.msgBacklog);
+  if (direct !== undefined) return direct;
+  return Object.values(objectRecord(body.subscriptions)).reduce<number>((sum, value) => {
+    return sum + (numberField(objectRecord(value).msgBacklog) ?? 0);
+  }, 0);
+}
+
+function partitionShortName(name: string): string {
+  const path = name.includes("://") ? name.split("://", 2)[1] || name : name;
+  return path.split("/").slice(-1)[0] || name;
+}
+
+function objectRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+function arrayObjects(value: unknown): Record<string, unknown>[] {
+  return Array.isArray(value) ? value.filter((item): item is Record<string, unknown> => !!item && typeof item === "object" && !Array.isArray(item)) : [];
+}
+
+function numberField(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function numberArrayField(value: unknown): number[] {
+  return Array.isArray(value) ? value.map(numberField).filter((item): item is number => item !== undefined) : [];
+}
+
+function stringField(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+function startAutoRefresh() {
+  stopAutoRefresh();
+  if (autoRefresh.value && props.topic && !isDocumentHidden()) {
+    refreshTimer = window.setInterval(() => {
+      void loadStats({ skipWhenHidden: true });
+    }, refreshInterval.value * 1000);
+  }
+}
+
+function stopAutoRefresh() {
+  if (refreshTimer !== undefined) {
+    clearInterval(refreshTimer);
+    refreshTimer = undefined;
+  }
+}
+
+function handleVisibilityChange() {
+  if (isDocumentHidden()) {
+    stopAutoRefresh();
+    return;
+  }
+  startAutoRefresh();
+  void loadStats();
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + " " + sizes[i];
+}
+
+function formatNumber(num: number): string {
+  return num.toLocaleString();
+}
+
+watch(
+  () => props.topic,
+  () => {
+    history.value = [];
+    selectedPartitionName.value = undefined;
+    kafkaMessageSql.value = defaultKafkaMessageSql();
+    kafkaMessageError.value = undefined;
+    kafkaMessages.value = [];
+    void loadStats();
+    startAutoRefresh();
+  },
+  { immediate: true },
+);
+
+watch(partitionRows, (rows) => {
+  if (!rows.length) {
+    selectedPartitionName.value = undefined;
+    return;
+  }
+  if (!selectedPartitionName.value || !rows.some((row) => row.name === selectedPartitionName.value)) {
+    selectedPartitionName.value = rows[0].name;
+  }
+});
+
+watch(autoRefresh, () => {
+  startAutoRefresh();
+});
+
+watch(refreshInterval, () => {
+  if (autoRefresh.value) {
+    startAutoRefresh();
+  }
+});
+
+onMounted(() => {
+  document.addEventListener("visibilitychange", handleVisibilityChange);
+  startAutoRefresh();
+});
+
+onUnmounted(() => {
+  document.removeEventListener("visibilitychange", handleVisibilityChange);
+  stopAutoRefresh();
+});
+</script>
+
+<template>
+  <div class="monitoring-panel">
+    <div class="panel-toolbar">
+      <h3>监控统计</h3>
+      <div class="toolbar-actions">
+        <label class="checkbox-label">
+          <input type="checkbox" v-model="autoRefresh" />
+          <span>自动刷新</span>
+        </label>
+        <select v-model.number="refreshInterval" :disabled="!autoRefresh" class="refresh-interval">
+          <option :value="5">5秒</option>
+          <option :value="10">10秒</option>
+          <option :value="30">30秒</option>
+          <option :value="60">60秒</option>
+        </select>
+        <button @click="refreshNow" :disabled="loading" class="btn-sm">
+          <Loader2 v-if="loading" class="btn-icon spinning" :size="14" />
+          <RefreshCw v-else class="btn-icon" :size="14" />
+          <span>{{ loading ? "刷新中..." : "立即刷新" }}</span>
+        </button>
+      </div>
+    </div>
+
+    <div v-if="!topic" class="panel-placeholder">
+      <Table2 :size="24" />
+      <span>请先选择一个主题</span>
+    </div>
+
+    <div v-else-if="error" class="panel-error">
+      <AlertTriangle :size="18" />
+      <span>{{ error }}</span>
+    </div>
+
+    <div v-else-if="loading && !stats" class="panel-loading">
+      <Loader2 class="loading-icon spinning" :size="22" />
+      <span>加载监控数据...</span>
+      <div class="loading-skeleton-grid" aria-hidden="true">
+        <div v-for="item in 4" :key="item" class="loading-skeleton-card"></div>
+      </div>
+    </div>
+
+    <div v-else-if="stats && isKafkaStats" class="stats-container">
+      <div class="stats-section">
+        <h4>Kafka Topic 概览</h4>
+        <div class="stats-grid">
+          <div class="stat-card">
+            <div class="stat-icon"><Layers3 :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">分区数</div>
+              <div class="stat-value">{{ kafkaOverview.partitionCount }}</div>
+            </div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon"><Boxes :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">副本因子</div>
+              <div class="stat-value">{{ kafkaOverview.replicationFactor }}</div>
+            </div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon"><Hash :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">消息数</div>
+              <div class="stat-value">{{ formatNumber(kafkaOverview.totalMessages) }}</div>
+            </div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon"><BarChart3 :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">Log end offset</div>
+              <div class="stat-value">{{ formatNumber(kafkaOverview.totalEndOffset) }}</div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="stats-section">
+        <h4>Offset 与副本状态</h4>
+        <div class="stats-grid">
+          <div class="stat-card">
+            <div class="stat-icon"><Gauge :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">起始 offset</div>
+              <div class="stat-value">{{ formatNumber(kafkaOverview.totalBeginOffset) }}</div>
+            </div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon"><RadioTower :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">Leader 数</div>
+              <div class="stat-value">{{ kafkaOverview.leaderCount }}</div>
+            </div>
+          </div>
+          <div class="stat-card" :class="{ warning: kafkaOverview.underReplicatedPartitions > 0 }">
+            <div class="stat-icon"><ShieldCheck :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">ISR 健康分区</div>
+              <div class="stat-value">{{ kafkaOverview.healthyPartitions }} / {{ kafkaOverview.partitionCount }}</div>
+            </div>
+          </div>
+          <div class="stat-card" :class="{ warning: kafkaOverview.offlinePartitions > 0 }">
+            <div class="stat-icon"><AlertTriangle :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">无 leader 分区</div>
+              <div class="stat-value">{{ kafkaOverview.offlinePartitions }}</div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="stats-section">
+        <h4>Kafka 分区明细</h4>
+        <div v-if="kafkaPartitionRows.length" class="partition-layout">
+          <div class="partition-table-wrap">
+            <table class="partition-table">
+              <thead>
+                <tr>
+                  <th>分区</th>
+                  <th>起始 offset</th>
+                  <th>Log end offset</th>
+                  <th>消息数</th>
+                  <th>Leader</th>
+                  <th>Replicas</th>
+                  <th>ISR</th>
+                  <th>状态</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr v-for="partition in kafkaPartitionRows" :key="partition.partition" :class="{ warning: partition.leader < 0 || (partition.replicas.length > 0 && partition.isr.length < partition.replicas.length) }">
+                  <td>{{ partition.partition }}</td>
+                  <td>{{ formatNumber(partition.beginOffset) }}</td>
+                  <td>{{ formatNumber(partition.endOffset) }}</td>
+                  <td>{{ formatNumber(partition.messageCount) }}</td>
+                  <td>{{ partition.leader >= 0 ? partition.leader : "-" }}</td>
+                  <td>{{ partition.replicas.join(", ") || "-" }}</td>
+                  <td>{{ partition.isr.join(", ") || "-" }}</td>
+                  <td>
+                    <span :class="['table-status', isKafkaPartitionHealthy(partition) ? 'healthy' : 'warning']">
+                      {{ kafkaPartitionStatusLabel(partition) }}
+                    </span>
+                  </td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+        </div>
+        <div v-else class="empty-state compact">当前 Kafka 响应未返回分区指标</div>
+      </div>
+
+      <div class="stats-section">
+        <div class="section-title-row">
+          <h4>Kafka 消息查询</h4>
+          <button type="button" class="btn-sm" :disabled="kafkaMessageLoading || !kafkaMessageSql.trim()" @click="runKafkaMessageSql">
+            <Loader2 v-if="kafkaMessageLoading" class="btn-icon spinning" :size="14" />
+            <span>{{ kafkaMessageLoading ? "查询中..." : "查询消息" }}</span>
+          </button>
+        </div>
+        <textarea v-model="kafkaMessageSql" class="kafka-sql-input" rows="2" spellcheck="false" />
+        <div class="query-hint">支持：SELECT * FROM "topic" PARTITION 0 OFFSET 0 LIMIT 20，单次最多返回 100 条。</div>
+        <div v-if="kafkaMessageError" class="panel-error inline-error">
+          <AlertTriangle :size="16" />
+          <span>{{ kafkaMessageError }}</span>
+        </div>
+        <div v-else-if="kafkaMessageLoading" class="empty-state compact">消息加载中...</div>
+        <div v-else-if="!kafkaMessages.length" class="empty-state compact">暂无消息</div>
+        <div v-else class="kafka-message-list">
+          <article v-for="message in kafkaMessages" :key="message.messageId || message.position" class="kafka-message-row">
+            <div class="kafka-message-meta">
+              <span>#{{ message.position }}</span>
+              <span>offset {{ message.messageId || "-" }}</span>
+              <span v-if="message.key">key {{ message.key }}</span>
+              <span>{{ formatKafkaMessageTimestamp(message.publishTime) }}</span>
+            </div>
+            <pre class="kafka-message-payload">{{ kafkaMessagePayload(message) }}</pre>
+            <div v-if="Object.keys(message.headers || {}).length" class="kafka-message-headers">
+              <span v-for="(value, key) in message.headers" :key="key">{{ key }}: {{ value }}</span>
+            </div>
+          </article>
+        </div>
+      </div>
+    </div>
+
+    <div v-else-if="stats" class="stats-container">
+      <!-- Overview Section -->
+      <div class="stats-section">
+        <h4>消息速率</h4>
+        <div class="stats-grid">
+          <div class="stat-card">
+            <div class="stat-icon"><Download :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">入站速率</div>
+              <div class="stat-value">{{ stats.msgRateIn.toFixed(2) }} msg/s</div>
+            </div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon"><Upload :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">出站速率</div>
+              <div class="stat-value">{{ stats.msgRateOut.toFixed(2) }} msg/s</div>
+            </div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon"><Activity :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">入站吞吐量</div>
+              <div class="stat-value">{{ formatBytes(stats.msgThroughputIn) }}/s</div>
+            </div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon"><BarChart3 :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">出站吞吐量</div>
+              <div class="stat-value">{{ formatBytes(stats.msgThroughputOut) }}/s</div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="charts-grid">
+        <div class="chart-panel">
+          <h4>速率趋势</h4>
+          <VChart :option="rateChartOption" autoresize class="trend-chart" />
+        </div>
+        <div class="chart-panel">
+          <h4>积压趋势</h4>
+          <VChart :option="backlogChartOption" autoresize class="trend-chart" />
+        </div>
+        <div class="chart-panel">
+          <h4>消费延迟</h4>
+          <VChart :option="latencyChartOption" autoresize class="trend-chart" />
+        </div>
+      </div>
+
+      <!-- Storage Section -->
+      <div class="stats-section">
+        <h4>存储与积压</h4>
+        <div class="stats-grid">
+          <div class="stat-card">
+            <div class="stat-icon"><Database :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">存储大小</div>
+              <div class="stat-value">{{ formatBytes(stats.storageSize) }}</div>
+            </div>
+          </div>
+          <div class="stat-card" :class="{ warning: stats.backlogSize > 10 * 1024 * 1024 }">
+            <div class="stat-icon"><Package :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">积压大小</div>
+              <div class="stat-value">{{ formatBytes(stats.backlogSize) }}</div>
+            </div>
+          </div>
+          <div class="stat-card" v-if="backlog">
+            <div class="stat-icon"><HardDrive :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">积压消息数</div>
+              <div class="stat-value">{{ formatNumber(backlog.msgBacklog) }}</div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <!-- Counters Section -->
+      <div class="stats-section">
+        <h4>消息计数器</h4>
+        <div class="stats-grid">
+          <div class="stat-card">
+            <div class="stat-icon"><Send :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">已发布消息</div>
+              <div class="stat-value">{{ formatNumber(stats.msgInCounter) }}</div>
+            </div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon"><CheckCircle2 :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">已消费消息</div>
+              <div class="stat-value">{{ formatNumber(stats.msgOutCounter) }}</div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <!-- Connections Section -->
+      <div class="stats-section">
+        <h4>连接统计</h4>
+        <div class="stats-grid">
+          <div class="stat-card">
+            <div class="stat-icon"><Users :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">订阅数量</div>
+              <div class="stat-value">{{ stats.subscriptionCount }}</div>
+            </div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-icon"><RadioTower :size="21" /></div>
+            <div class="stat-content">
+              <div class="stat-label">生产者数量</div>
+              <div class="stat-value">{{ stats.producerCount }}</div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <div class="stats-section">
+        <h4>分区明细</h4>
+        <div v-if="partitionRows.length" class="partition-layout">
+          <div class="partition-table-wrap">
+            <table class="partition-table interactive-table">
+              <thead>
+                <tr>
+                  <th>分区</th>
+                  <th>入站</th>
+                  <th>出站</th>
+                  <th>入站吞吐</th>
+                  <th>出站吞吐</th>
+                  <th>积压消息</th>
+                  <th>积压大小</th>
+                  <th>生产者</th>
+                  <th>订阅</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr v-for="partition in partitionRows" :key="partition.name" :class="{ selected: selectedPartition?.name === partition.name }" @click="selectedPartitionName = partition.name">
+                  <td :title="partition.name">{{ partition.shortName }}</td>
+                  <td>{{ partition.msgRateIn.toFixed(2) }} msg/s</td>
+                  <td>{{ partition.msgRateOut.toFixed(2) }} msg/s</td>
+                  <td>{{ formatBytes(partition.msgThroughputIn) }}/s</td>
+                  <td>{{ formatBytes(partition.msgThroughputOut) }}/s</td>
+                  <td>{{ formatNumber(partition.msgBacklog) }}</td>
+                  <td>{{ formatBytes(partition.backlogSize) }}</td>
+                  <td>{{ partition.producerCount }}</td>
+                  <td>{{ partition.subscriptionCount }}</td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+
+          <div v-if="selectedPartition" class="partition-detail">
+            <h5>{{ selectedPartition.shortName }}</h5>
+            <div class="detail-grid">
+              <div>
+                <div class="detail-title">生产者</div>
+                <table v-if="selectedPartitionPublishers.length" class="detail-table">
+                  <thead>
+                    <tr>
+                      <th>名称</th>
+                      <th>速率</th>
+                      <th>地址</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    <tr v-for="publisher in selectedPartitionPublishers" :key="String(publisher.producerName ?? publisher.producerId ?? publisher.address)">
+                      <td>{{ publisher.producerName || publisher.producerId || "-" }}</td>
+                      <td>{{ (numberField(publisher.msgRateIn) ?? 0).toFixed(2) }} msg/s</td>
+                      <td>{{ publisher.address || "-" }}</td>
+                    </tr>
+                  </tbody>
+                </table>
+                <div v-else class="empty-state compact">暂无生产者</div>
+              </div>
+              <div>
+                <div class="detail-title">订阅</div>
+                <table v-if="selectedPartitionSubscriptions.length" class="detail-table">
+                  <thead>
+                    <tr>
+                      <th>名称</th>
+                      <th>类型</th>
+                      <th>积压</th>
+                      <th>消费者</th>
+                    </tr>
+                  </thead>
+                  <tbody>
+                    <tr v-for="subscription in selectedPartitionSubscriptions" :key="subscription.name">
+                      <td>{{ subscription.name }}</td>
+                      <td>{{ subscription.type || "-" }}</td>
+                      <td>{{ formatNumber(subscription.msgBacklog) }}</td>
+                      <td>{{ subscription.consumerCount }}</td>
+                    </tr>
+                  </tbody>
+                </table>
+                <div v-else class="empty-state compact">暂无订阅</div>
+              </div>
+            </div>
+          </div>
+        </div>
+        <div v-else class="empty-state compact">
+          {{ topic.partitioned ? "当前 Broker 响应未返回分区指标" : "非分区主题没有分区明细" }}
+        </div>
+      </div>
+
+      <!-- Health Indicators -->
+      <div class="stats-section">
+        <h4>健康指标</h4>
+        <div class="health-indicators">
+          <div class="health-item">
+            <span class="health-label">消息流动:</span>
+            <span :class="['health-badge', stats.msgRateIn > 0 || stats.msgRateOut > 0 ? 'healthy' : 'idle']">
+              {{ stats.msgRateIn > 0 || stats.msgRateOut > 0 ? "活跃" : "空闲" }}
+            </span>
+          </div>
+          <div class="health-item">
+            <span class="health-label">积压状态:</span>
+            <span :class="['health-badge', stats.backlogSize < 10 * 1024 * 1024 ? 'healthy' : 'warning']">
+              {{ stats.backlogSize < 10 * 1024 * 1024 ? "正常" : "偏高" }}
+            </span>
+          </div>
+          <div class="health-item">
+            <span class="health-label">生产者:</span>
+            <span :class="['health-badge', stats.producerCount > 0 ? 'healthy' : 'idle']">
+              {{ stats.producerCount > 0 ? "已连接" : "无连接" }}
+            </span>
+          </div>
+          <div class="health-item">
+            <span class="health-label">订阅:</span>
+            <span :class="['health-badge', stats.subscriptionCount > 0 ? 'healthy' : 'idle']">
+              {{ stats.subscriptionCount > 0 ? "活跃" : "无订阅" }}
+            </span>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.monitoring-panel {
+  --monitor-panel-bg: color-mix(in srgb, var(--color-background, #ffffff) 94%, var(--color-muted, #f5f5f5));
+  --monitor-surface: var(--color-background-secondary, var(--color-card, #ffffff));
+  --monitor-surface-raised: color-mix(in srgb, var(--monitor-surface) 96%, var(--monitor-accent) 4%);
+  --monitor-border: color-mix(in srgb, var(--color-border, #e5e7eb) 76%, transparent);
+  --monitor-border-strong: color-mix(in srgb, var(--color-border, #d4d4d8) 88%, var(--monitor-accent) 12%);
+  --monitor-text: var(--color-text, var(--color-foreground, #18181b));
+  --monitor-muted: var(--color-text-secondary, var(--color-muted-foreground, #64748b));
+  --monitor-faint: var(--color-text-tertiary, color-mix(in srgb, var(--monitor-muted) 72%, transparent));
+  --monitor-hover: color-mix(in srgb, var(--color-hover, var(--color-muted, #f4f4f5)) 72%, var(--monitor-accent) 7%);
+  --monitor-accent: #0f766e;
+  --monitor-accent-soft: rgb(15 118 110 / 0.1);
+  --monitor-accent-border: rgb(15 118 110 / 0.22);
+  --monitor-success: #15803d;
+  --monitor-success-soft: rgb(21 128 61 / 0.1);
+  --monitor-warning: #b45309;
+  --monitor-warning-soft: rgb(180 83 9 / 0.12);
+  --monitor-danger: #b91c1c;
+  --monitor-danger-soft: rgb(185 28 28 / 0.1);
+  --monitor-shadow: 0 18px 38px -28px rgb(15 23 42 / 0.42);
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  background: linear-gradient(180deg, color-mix(in srgb, var(--monitor-panel-bg) 88%, var(--monitor-accent-soft)) 0%, var(--monitor-panel-bg) 38%), var(--monitor-panel-bg);
+  color: var(--monitor-text);
+  font-family: var(--font-sans, "Geist Variable", "PingFang SC", "Microsoft YaHei", system-ui, sans-serif);
+}
+
+:global(.dark) .monitoring-panel {
+  --monitor-panel-bg: color-mix(in srgb, var(--color-background, #131416) 90%, #0f766e 4%);
+  --monitor-surface: color-mix(in srgb, var(--color-card, #1b1b1e) 94%, #ffffff 2%);
+  --monitor-surface-raised: color-mix(in srgb, var(--monitor-surface) 92%, #0f766e 8%);
+  --monitor-border: color-mix(in srgb, var(--color-border, rgb(110 110 114 / 0.28)) 82%, transparent);
+  --monitor-border-strong: color-mix(in srgb, var(--monitor-border) 76%, #2dd4bf 24%);
+  --monitor-accent: #2dd4bf;
+  --monitor-accent-soft: rgb(45 212 191 / 0.12);
+  --monitor-accent-border: rgb(45 212 191 / 0.24);
+  --monitor-success: #4ade80;
+  --monitor-success-soft: rgb(74 222 128 / 0.12);
+  --monitor-warning: #f59e0b;
+  --monitor-warning-soft: rgb(245 158 11 / 0.14);
+  --monitor-danger: #f87171;
+  --monitor-danger-soft: rgb(248 113 113 / 0.12);
+  --monitor-shadow: 0 18px 42px -28px rgb(0 0 0 / 0.72);
+}
+
+.panel-toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 16px;
+  padding: 14px 20px;
+  border-bottom: 1px solid var(--monitor-border);
+  background: color-mix(in srgb, var(--monitor-surface) 92%, transparent);
+  backdrop-filter: blur(10px);
+  position: sticky;
+  top: 0;
+  z-index: 1;
+}
+
+.panel-toolbar h3 {
+  margin: 0;
+  font-size: 18px;
+  line-height: 1.3;
+  font-weight: 650;
+  color: var(--monitor-text);
+  text-wrap: balance;
+}
+
+.toolbar-actions {
+  display: flex;
+  align-items: center;
+  justify-content: flex-end;
+  gap: 10px;
+  min-width: 0;
+  flex-wrap: wrap;
+}
+
+.checkbox-label {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-height: 32px;
+  padding: 5px 9px;
+  border: 1px solid transparent;
+  border-radius: 8px;
+  font-size: 13px;
+  font-weight: 500;
+  color: var(--monitor-muted);
+  cursor: pointer;
+  user-select: none;
+  transition:
+    background 0.2s ease,
+    color 0.2s ease,
+    border-color 0.2s ease;
+}
+
+.checkbox-label:hover {
+  border-color: var(--monitor-border);
+  background: var(--monitor-hover);
+  color: var(--monitor-text);
+}
+
+.checkbox-label input {
+  width: 14px;
+  height: 14px;
+  accent-color: var(--monitor-accent);
+}
+
+.refresh-interval {
+  min-height: 34px;
+  padding: 5px 30px 5px 10px;
+  border: 1px solid var(--monitor-border);
+  border-radius: 8px;
+  font-size: 13px;
+  font-weight: 500;
+  background: var(--monitor-surface);
+  color: var(--monitor-text);
+  cursor: pointer;
+  outline: none;
+  transition:
+    border-color 0.2s ease,
+    box-shadow 0.2s ease,
+    background 0.2s ease;
+}
+
+.refresh-interval:hover:not(:disabled) {
+  border-color: var(--monitor-border-strong);
+}
+
+.refresh-interval:focus-visible {
+  border-color: var(--monitor-accent);
+  box-shadow: 0 0 0 3px var(--monitor-accent-soft);
+}
+
+.refresh-interval:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.btn-sm {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 7px;
+  min-height: 34px;
+  padding: 7px 12px;
+  border: 1px solid var(--monitor-border);
+  border-radius: 8px;
+  background: var(--monitor-surface);
+  color: var(--monitor-text);
+  cursor: pointer;
+  font-size: 13px;
+  font-weight: 560;
+  line-height: 1;
+  white-space: nowrap;
+  box-shadow: 0 1px 0 rgb(255 255 255 / 0.55) inset;
+  transition:
+    transform 0.16s ease,
+    background 0.2s ease,
+    border-color 0.2s ease,
+    box-shadow 0.2s ease;
+}
+
+.btn-sm:hover:not(:disabled) {
+  border-color: var(--monitor-border-strong);
+  background: var(--monitor-hover);
+  box-shadow: var(--monitor-shadow);
+  transform: translateY(-1px);
+}
+
+.btn-sm:active:not(:disabled) {
+  transform: translateY(0) scale(0.98);
+}
+
+.btn-sm:focus-visible {
+  outline: none;
+  border-color: var(--monitor-accent);
+  box-shadow: 0 0 0 3px var(--monitor-accent-soft);
+}
+
+.btn-sm:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+  box-shadow: none;
+}
+
+.btn-icon {
+  flex: 0 0 auto;
+  color: var(--monitor-accent);
+}
+
+.panel-placeholder,
+.panel-error,
+.panel-loading,
+.empty-state {
+  display: grid;
+  place-items: center;
+  gap: 10px;
+  padding: 32px;
+  text-align: center;
+  color: var(--monitor-muted);
+  line-height: 1.5;
+}
+
+.panel-error {
+  display: flex;
+  justify-content: center;
+  color: var(--monitor-danger);
+  background: var(--monitor-danger-soft);
+  border-bottom: 1px solid color-mix(in srgb, var(--monitor-danger) 18%, transparent);
+}
+
+.panel-loading {
+  align-content: start;
+  padding-top: 48px;
+}
+
+.loading-icon {
+  color: var(--monitor-accent);
+}
+
+.spinning {
+  animation: monitor-spin 0.9s linear infinite;
+}
+
+.loading-skeleton-grid {
+  width: min(100%, 920px);
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: 12px;
+  margin-top: 12px;
+}
+
+.loading-skeleton-card {
+  height: 96px;
+  border-radius: 8px;
+  background: linear-gradient(90deg, transparent, rgb(255 255 255 / 0.45), transparent), var(--monitor-surface);
+  background-size: 220% 100%;
+  border: 1px solid var(--monitor-border);
+  animation: monitor-skeleton 1.3s ease-in-out infinite;
+}
+
+.stats-container {
+  flex: 1;
+  overflow-y: auto;
+  width: min(100%, 1480px);
+  margin: 0 auto;
+  padding: 22px 24px 32px;
+  box-sizing: border-box;
+}
+
+.stats-section {
+  margin-bottom: 28px;
+}
+
+.stats-section:last-child {
+  margin-bottom: 0;
+}
+
+.stats-section h4 {
+  display: flex;
+  align-items: center;
+  gap: 9px;
+  margin: 0 0 14px;
+  font-size: 14px;
+  line-height: 1.35;
+  font-weight: 680;
+  color: var(--monitor-text);
+}
+
+.stats-section h4::before {
+  content: "";
+  width: 4px;
+  height: 16px;
+  border-radius: 2px;
+  background: var(--monitor-accent);
+  box-shadow: 0 0 0 4px var(--monitor-accent-soft);
+}
+
+.section-title-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-bottom: 12px;
+}
+
+.section-title-row h4 {
+  margin-bottom: 0;
+}
+
+.kafka-sql-input {
+  width: 100%;
+  min-height: 54px;
+  padding: 10px 12px;
+  border: 1px solid var(--monitor-border);
+  border-radius: 8px;
+  background: var(--monitor-surface);
+  color: var(--monitor-text);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 12px;
+  line-height: 1.5;
+  resize: vertical;
+  box-sizing: border-box;
+}
+
+.kafka-sql-input:focus {
+  outline: none;
+  border-color: var(--monitor-accent);
+  box-shadow: 0 0 0 3px var(--monitor-accent-soft);
+}
+
+.query-hint {
+  margin-top: 6px;
+  color: var(--monitor-faint);
+  font-size: 12px;
+}
+
+.inline-error {
+  justify-content: flex-start;
+  margin-top: 10px;
+  border: 1px solid color-mix(in srgb, var(--monitor-danger) 22%, transparent);
+  border-radius: 8px;
+  padding: 10px 12px;
+}
+
+.kafka-message-list {
+  display: grid;
+  gap: 10px;
+  margin-top: 12px;
+}
+
+.kafka-message-row {
+  border: 1px solid var(--monitor-border);
+  border-radius: 8px;
+  background: var(--monitor-surface);
+  overflow: hidden;
+}
+
+.kafka-message-meta {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  padding: 8px 10px;
+  border-bottom: 1px solid var(--monitor-border);
+  color: var(--monitor-muted);
+  font-size: 12px;
+}
+
+.kafka-message-payload {
+  max-height: 220px;
+  margin: 0;
+  overflow: auto;
+  padding: 10px;
+  color: var(--monitor-text);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 12px;
+  line-height: 1.5;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.kafka-message-headers {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  padding: 8px 10px;
+  border-top: 1px solid var(--monitor-border);
+  color: var(--monitor-muted);
+  font-size: 11px;
+}
+
+.charts-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+  gap: 14px;
+  margin-bottom: 28px;
+}
+
+.chart-panel {
+  min-height: 260px;
+  padding: 14px;
+  border: 1px solid var(--monitor-border);
+  border-radius: 8px;
+  background: var(--monitor-surface);
+  box-shadow: var(--monitor-shadow);
+}
+
+.chart-panel h4 {
+  margin: 0 0 8px 0;
+  font-size: 13px;
+  line-height: 1.35;
+  font-weight: 650;
+  color: var(--monitor-muted);
+}
+
+.trend-chart {
+  width: 100%;
+  height: 220px;
+}
+
+.stats-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(230px, 1fr));
+  gap: 14px;
+}
+
+.stat-card {
+  position: relative;
+  isolation: isolate;
+  overflow: hidden;
+  display: flex;
+  align-items: center;
+  min-height: 96px;
+  gap: 14px;
+  padding: 17px 18px;
+  background: var(--monitor-surface);
+  border: 1px solid var(--monitor-border);
+  border-radius: 8px;
+  box-shadow: 0 1px 0 rgb(255 255 255 / 0.52) inset;
+  transition:
+    transform 0.22s cubic-bezier(0.16, 1, 0.3, 1),
+    border-color 0.22s ease,
+    box-shadow 0.22s ease,
+    background 0.22s ease;
+}
+
+.stat-card::before {
+  content: "";
+  position: absolute;
+  inset: 0 auto 0 0;
+  width: 3px;
+  background: var(--monitor-accent);
+  opacity: 0.75;
+  z-index: 0;
+}
+
+.stat-card::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background: linear-gradient(135deg, var(--monitor-accent-soft), transparent 42%);
+  opacity: 0.45;
+  pointer-events: none;
+  z-index: 0;
+}
+
+.stat-card:hover {
+  transform: translateY(-2px);
+  border-color: var(--monitor-accent-border);
+  background: var(--monitor-surface-raised);
+  box-shadow: var(--monitor-shadow);
+}
+
+.stat-card.warning {
+  border-color: color-mix(in srgb, var(--monitor-warning) 34%, transparent);
+  background: color-mix(in srgb, var(--monitor-surface) 86%, var(--monitor-warning-soft));
+}
+
+.stat-card.warning::before {
+  background: var(--monitor-warning);
+}
+
+.stat-card.warning .stat-icon {
+  color: var(--monitor-warning);
+  background: var(--monitor-warning-soft);
+  border-color: color-mix(in srgb, var(--monitor-warning) 24%, transparent);
+}
+
+.stat-icon {
+  position: relative;
+  z-index: 1;
+  display: grid;
+  place-items: center;
+  width: 42px;
+  height: 42px;
+  flex: 0 0 42px;
+  border: 1px solid var(--monitor-accent-border);
+  border-radius: 8px;
+  background: var(--monitor-accent-soft);
+  color: var(--monitor-accent);
+}
+
+.stat-content {
+  position: relative;
+  z-index: 1;
+  flex: 1;
+  min-width: 0;
+}
+
+.stat-label {
+  margin-bottom: 6px;
+  font-size: 12px;
+  line-height: 1.3;
+  font-weight: 560;
+  color: var(--monitor-muted);
+  text-wrap: pretty;
+}
+
+.stat-value {
+  font-family: "Geist Variable Tabular", var(--font-sans, system-ui, sans-serif);
+  font-size: 23px;
+  line-height: 1.1;
+  font-weight: 720;
+  color: var(--monitor-text);
+  font-variant-numeric: tabular-nums;
+  letter-spacing: 0;
+}
+
+.health-indicators {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+  gap: 12px;
+}
+
+.partition-layout {
+  display: grid;
+  gap: 14px;
+}
+
+.partition-table-wrap {
+  overflow-x: auto;
+  border: 1px solid var(--monitor-border);
+  border-radius: 8px;
+  background: var(--monitor-surface);
+  box-shadow: var(--monitor-shadow);
+}
+
+.partition-table,
+.detail-table {
+  width: 100%;
+  border-collapse: separate;
+  border-spacing: 0;
+}
+
+.partition-table {
+  min-width: 860px;
+}
+
+.detail-table {
+  min-width: 0;
+}
+
+.partition-table th,
+.partition-table td,
+.detail-table th,
+.detail-table td {
+  padding: 11px 14px;
+  border-bottom: 1px solid var(--monitor-border);
+  text-align: left;
+  white-space: nowrap;
+  font-size: 12.5px;
+  line-height: 1.45;
+  color: var(--monitor-text);
+  font-variant-numeric: tabular-nums;
+}
+
+.partition-table th,
+.detail-table th {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+  background: color-mix(in srgb, var(--monitor-surface) 86%, var(--monitor-panel-bg));
+  color: var(--monitor-muted);
+  font-size: 12px;
+  font-weight: 680;
+}
+
+.partition-table tbody tr:last-child td,
+.detail-table tbody tr:last-child td {
+  border-bottom: none;
+}
+
+.partition-table tbody tr {
+  transition:
+    background 0.18s ease,
+    color 0.18s ease;
+}
+
+.partition-table.interactive-table tbody tr {
+  cursor: pointer;
+}
+
+.partition-table tbody tr:hover,
+.partition-table tbody tr.selected {
+  background: var(--monitor-hover);
+}
+
+.partition-table tbody tr:nth-child(even):not(.selected):not(.warning) {
+  background: color-mix(in srgb, var(--monitor-surface) 90%, var(--monitor-panel-bg));
+}
+
+.partition-table tbody tr.warning {
+  background: var(--monitor-warning-soft);
+}
+
+.table-status {
+  display: inline-flex;
+  align-items: center;
+  min-height: 24px;
+  padding: 3px 9px;
+  border-radius: 7px;
+  font-size: 12px;
+  font-weight: 650;
+  line-height: 1;
+}
+
+.table-status.healthy {
+  color: var(--monitor-success);
+  background: var(--monitor-success-soft);
+}
+
+.table-status.warning {
+  color: var(--monitor-warning);
+  background: var(--monitor-warning-soft);
+}
+
+.partition-detail {
+  padding: 14px;
+  border: 1px solid var(--monitor-border);
+  border-radius: 8px;
+  background: var(--monitor-surface);
+  box-shadow: var(--monitor-shadow);
+}
+
+.partition-detail h5 {
+  margin: 0 0 12px;
+  font-size: 13px;
+  line-height: 1.4;
+  font-weight: 680;
+  color: var(--monitor-text);
+}
+
+.detail-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
+  gap: 12px;
+}
+
+.detail-title {
+  margin-bottom: 8px;
+  color: var(--monitor-muted);
+  font-size: 12px;
+  font-weight: 650;
+}
+
+.empty-state.compact {
+  padding: 16px;
+  border: 1px dashed var(--monitor-border);
+  border-radius: 8px;
+  background: color-mix(in srgb, var(--monitor-surface) 74%, transparent);
+}
+
+.health-item {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 13px 15px;
+  background: var(--monitor-surface);
+  border: 1px solid var(--monitor-border);
+  border-radius: 8px;
+  box-shadow: 0 1px 0 rgb(255 255 255 / 0.48) inset;
+}
+
+.health-label {
+  font-size: 13px;
+  line-height: 1.35;
+  color: var(--monitor-muted);
+  font-weight: 560;
+}
+
+.health-badge {
+  display: inline-flex;
+  align-items: center;
+  min-height: 24px;
+  padding: 4px 10px;
+  border-radius: 7px;
+  font-size: 12px;
+  font-weight: 650;
+  white-space: nowrap;
+}
+
+.health-badge.healthy {
+  background: var(--monitor-success-soft);
+  color: var(--monitor-success);
+}
+
+.health-badge.warning {
+  background: var(--monitor-warning-soft);
+  color: var(--monitor-warning);
+}
+
+.health-badge.idle {
+  background: color-mix(in srgb, var(--monitor-muted) 12%, transparent);
+  color: var(--monitor-muted);
+}
+
+@keyframes monitor-spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+@keyframes monitor-skeleton {
+  0% {
+    background-position: 120% 0;
+  }
+  100% {
+    background-position: -120% 0;
+  }
+}
+
+@media (max-width: 900px) {
+  .panel-toolbar {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .toolbar-actions {
+    justify-content: flex-start;
+    width: 100%;
+  }
+
+  .stats-container {
+    padding: 18px 16px 26px;
+  }
+
+  .loading-skeleton-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}
+
+@media (max-width: 640px) {
+  .stats-grid,
+  .charts-grid,
+  .health-indicators,
+  .loading-skeleton-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .stat-card {
+    min-height: 84px;
+  }
+}
+</style>
diff --git a/apps/desktop/src/components/mq/MqAdminConsole.vue b/apps/desktop/src/components/mq/MqAdminConsole.vue
new file mode 100644
index 0000000..6585075
--- /dev/null
+++ b/apps/desktop/src/components/mq/MqAdminConsole.vue
@@ -0,0 +1,401 @@
+<script setup lang="ts">
+import { formatError } from "@/lib/backend/errorUtils";
+import { ref, computed, onMounted, watch } from "vue";
+import type { MqClusterInfo, TopicInfo } from "@/types/mq";
+import { mqTestConnection } from "@/lib/backend/api";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { mqClusterOptionsFromExtra } from "@/lib/mq/mqTenantForm";
+import TenantsPanel from "./TenantsPanel.vue";
+import NamespacesPanel from "./NamespacesPanel.vue";
+import TopicsPanel from "./TopicsPanel.vue";
+import SubscriptionsPanel from "./SubscriptionsPanel.vue";
+import MonitoringPanel from "./MonitoringPanel.vue";
+import ProducerConsumerPanel from "./ProducerConsumerPanel.vue";
+import PoliciesPanel from "./PoliciesPanel.vue";
+import PermissionsPanel from "./PermissionsPanel.vue";
+import RawApiPanel from "./RawApiPanel.vue";
+import SendMessagePanel from "./SendMessagePanel.vue";
+import BrokerPanel from "./BrokerPanel.vue";
+
+type MqTab = "tenants" | "namespaces" | "topics" | "subscriptions" | "monitoring" | "clients" | "policies" | "permissions" | "messages" | "raw" | "broker";
+
+interface Props {
+  connectionId: string;
+  initialTenant?: string;
+  initialTab?: MqTab;
+  readOnly?: boolean;
+}
+
+const props = defineProps<Props>();
+const connectionStore = useConnectionStore();
+
+// State
+const activeTab = ref<MqTab>(props.initialTab || (props.initialTenant ? "namespaces" : "tenants"));
+const selectedTenant = ref<string | undefined>(props.initialTenant);
+const selectedNamespace = ref<string>();
+const selectedTopic = ref<TopicInfo>();
+const selectedSubscriptionName = ref<string>();
+const capabilities = ref<MqClusterInfo["capabilities"]>();
+const clusterInfo = ref<MqClusterInfo>();
+const loading = ref(false);
+const error = ref<string>();
+const KAFKA_CONTEXT = "_kafka";
+
+// Computed
+const isKafkaCluster = computed(() => clusterInfo.value?.systemKind === "kafka");
+const effectiveTenant = computed(() => (isKafkaCluster.value ? selectedTenant.value || KAFKA_CONTEXT : selectedTenant.value));
+const effectiveNamespace = computed(() => (isKafkaCluster.value ? selectedNamespace.value || KAFKA_CONTEXT : selectedNamespace.value));
+const canManageTenants = computed(() => capabilities.value?.supportsTenants ?? true);
+const canManageNamespaces = computed(() => capabilities.value?.supportsNamespaces ?? true);
+const canManagePartitionedTopics = computed(() => capabilities.value?.supportsPartitionedTopics ?? true);
+const canManageSubscriptions = computed(() => capabilities.value?.supportsSubscriptions ?? true);
+const canCreateSubscription = computed(() => capabilities.value?.supportsCreateSubscription ?? true);
+const canResetCursor = computed(() => capabilities.value?.supportsResetCursor ?? true);
+const canSkipMessages = computed(() => capabilities.value?.supportsSkipMessages ?? true);
+const canClearBacklog = computed(() => capabilities.value?.supportsClearBacklog ?? true);
+const canPeekMessages = computed(() => capabilities.value?.supportsPeekMessages ?? false);
+const canExpireMessages = computed(() => capabilities.value?.supportsExpireMessages ?? true);
+const canManageRateLimits = computed(() => capabilities.value?.supportsRateLimits ?? true);
+const canManageBacklogQuota = computed(() => capabilities.value?.supportsBacklogQuota ?? true);
+const canManageRetention = computed(() => capabilities.value?.supportsRetention ?? true);
+const canManagePolicies = computed(() => {
+  return canManageRateLimits.value || canManageBacklogQuota.value || canManageRetention.value;
+});
+const canManagePermissions = computed(() => capabilities.value?.supportsPermissions ?? true);
+const canSendMessage = computed(() => capabilities.value?.supportsSendMessage ?? false);
+const canUseRawApi = computed(() => capabilities.value?.supportsRawAdminApi ?? true);
+const clusterOptions = computed(() => mqClusterOptionsFromExtra(clusterInfo.value?.extra));
+const availableTabs = computed<MqTab[]>(() => {
+  const tabs: MqTab[] = [];
+  if (canManageTenants.value) tabs.push("tenants");
+  if (canManageNamespaces.value) tabs.push("namespaces");
+  tabs.push("topics");
+  if (canManageSubscriptions.value) tabs.push("subscriptions");
+  tabs.push("monitoring");
+  tabs.push("clients");
+  if (canSendMessage.value) tabs.push("messages");
+  tabs.push("broker");
+  if (canManagePolicies.value) tabs.push("policies");
+  if (canManagePermissions.value) tabs.push("permissions");
+  if (canUseRawApi.value) tabs.push("raw");
+  return tabs;
+});
+
+// Methods
+async function loadClusterInfo() {
+  loading.value = true;
+  error.value = undefined;
+  try {
+    clusterInfo.value = await mqTestConnection(props.connectionId);
+    capabilities.value = clusterInfo.value.capabilities;
+    reconcileActiveTab();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function selectTenant(tenant: string) {
+  selectedTenant.value = tenant;
+  selectedNamespace.value = undefined;
+  selectedTopic.value = undefined;
+  selectedSubscriptionName.value = undefined;
+  if (canManageNamespaces.value) {
+    activeTab.value = "namespaces";
+  } else {
+    activeTab.value = "topics";
+  }
+}
+
+function handleTenantSelected(tenant: string) {
+  selectTenant(tenant);
+}
+
+function handleNamespaceSelected(namespace: string) {
+  selectedNamespace.value = namespace;
+  selectedTopic.value = undefined;
+  selectedSubscriptionName.value = undefined;
+  activeTab.value = "topics";
+}
+
+function handleNamespaceRolesSelected(namespace: string) {
+  selectedNamespace.value = namespace;
+  selectedTopic.value = undefined;
+  selectedSubscriptionName.value = undefined;
+  activeTab.value = canManagePermissions.value ? "permissions" : "namespaces";
+}
+
+function handleTopicSelected(topic: TopicInfo) {
+  selectedTopic.value = topic;
+  selectedSubscriptionName.value = undefined;
+  activeTab.value = isKafkaCluster.value ? "monitoring" : canManageSubscriptions.value ? "subscriptions" : "monitoring";
+}
+
+function handleSubscriptionSelected(subscription: string) {
+  selectedSubscriptionName.value = subscription;
+  activeTab.value = "clients";
+}
+
+function goToTenantLevel() {
+  selectedNamespace.value = undefined;
+  selectedTopic.value = undefined;
+  selectedSubscriptionName.value = undefined;
+  activeTab.value = canManageTenants.value ? "tenants" : firstAvailableTab();
+}
+
+function goToNamespaceLevel() {
+  selectedTopic.value = undefined;
+  selectedSubscriptionName.value = undefined;
+  activeTab.value = canManageNamespaces.value ? "namespaces" : "topics";
+}
+
+function goToTopicLevel() {
+  selectedSubscriptionName.value = undefined;
+  activeTab.value = "topics";
+}
+
+function setActiveTab(tab: MqTab) {
+  activeTab.value = availableTabs.value.includes(tab) ? tab : firstAvailableTab();
+}
+
+function firstAvailableTab(): MqTab {
+  return availableTabs.value[0] ?? "topics";
+}
+
+function reconcileActiveTab() {
+  if (!availableTabs.value.includes(activeTab.value)) {
+    activeTab.value = firstAvailableTab();
+  }
+}
+
+watch(availableTabs, reconcileActiveTab);
+watch(
+  () => props.initialTenant,
+  (tenant) => {
+    if (tenant && tenant !== selectedTenant.value) {
+      selectTenant(tenant);
+    }
+  },
+);
+watch(
+  () => props.initialTab,
+  (tab) => {
+    if (tab) setActiveTab(tab);
+  },
+);
+
+// Lifecycle
+onMounted(async () => {
+  try {
+    await connectionStore.ensureConnected(props.connectionId);
+  } catch (e) {
+    console.warn("[DBX] ensureConnected failed for", props.connectionId, e);
+  }
+  loadClusterInfo();
+});
+</script>
+
+<template>
+  <div class="mq-admin-console">
+    <!-- Top Toolbar -->
+    <div class="mq-toolbar">
+      <div class="mq-breadcrumb">
+        <span v-if="clusterInfo" class="cluster-info"> {{ clusterInfo.systemKind.toUpperCase() }} {{ clusterInfo.serverVersion || "" }} </span>
+        <span v-if="selectedTenant" class="breadcrumb-separator">›</span>
+        <button v-if="selectedTenant" class="breadcrumb-button" @click="goToTenantLevel" title="查看租户">{{ selectedTenant }}</button>
+        <span v-if="selectedNamespace" class="breadcrumb-separator">›</span>
+        <button v-if="selectedNamespace" class="breadcrumb-button" @click="goToNamespaceLevel" title="查看命名空间">{{ selectedNamespace }}</button>
+        <span v-if="selectedTopic" class="breadcrumb-separator">›</span>
+        <button v-if="selectedTopic" class="breadcrumb-button" @click="goToTopicLevel" title="查看主题">{{ selectedTopic.shortName }}</button>
+      </div>
+      <div class="toolbar-status">
+        <span v-if="readOnly" class="readonly-badge">只读</span>
+        <span v-if="error" class="toolbar-error">{{ error }}</span>
+      </div>
+    </div>
+
+    <!-- Tab Bar -->
+    <div class="mq-tabs">
+      <button v-if="canManageTenants" :class="{ active: activeTab === 'tenants' }" @click="setActiveTab('tenants')">租户</button>
+      <button v-if="canManageNamespaces" :class="{ active: activeTab === 'namespaces' }" @click="setActiveTab('namespaces')">命名空间</button>
+      <button :class="{ active: activeTab === 'topics' }" @click="setActiveTab('topics')">主题</button>
+      <button v-if="canManageSubscriptions" :class="{ active: activeTab === 'subscriptions' }" @click="setActiveTab('subscriptions')">订阅</button>
+      <button :class="{ active: activeTab === 'monitoring' }" @click="setActiveTab('monitoring')">监控</button>
+      <button :class="{ active: activeTab === 'clients' }" @click="setActiveTab('clients')">客户端</button>
+      <button v-if="canSendMessage" :class="{ active: activeTab === 'messages' }" @click="setActiveTab('messages')">消息</button>
+      <button :class="{ active: activeTab === 'broker' }" @click="setActiveTab('broker')">Broker</button>
+      <button v-if="canManagePolicies" :class="{ active: activeTab === 'policies' }" @click="setActiveTab('policies')">策略</button>
+      <button v-if="canManagePermissions" :class="{ active: activeTab === 'permissions' }" @click="setActiveTab('permissions')">权限</button>
+      <button v-if="canUseRawApi" :class="{ active: activeTab === 'raw' }" @click="setActiveTab('raw')">Raw API</button>
+    </div>
+
+    <!-- Main Content Area -->
+    <div class="mq-content">
+      <TenantsPanel v-if="activeTab === 'tenants'" :connection-id="connectionId" :supports-tenants="canManageTenants" :read-only="readOnly" :cluster-options="clusterOptions" @tenant-selected="handleTenantSelected" />
+      <NamespacesPanel v-else-if="activeTab === 'namespaces'" :connection-id="connectionId" :tenant="selectedTenant" :supports-namespaces="canManageNamespaces" :read-only="readOnly" @namespace-selected="handleNamespaceSelected" @namespace-roles-selected="handleNamespaceRolesSelected" />
+      <TopicsPanel v-else-if="activeTab === 'topics'" :connection-id="connectionId" :tenant="effectiveTenant" :namespace="effectiveNamespace" :read-only="readOnly" :supports-partitioned-topics="canManagePartitionedTopics" :is-kafka-cluster="isKafkaCluster" @topic-selected="handleTopicSelected" />
+      <SubscriptionsPanel
+        v-else-if="activeTab === 'subscriptions' && canManageSubscriptions"
+        :connection-id="connectionId"
+        :topic="selectedTopic"
+        :tenant="effectiveTenant"
+        :namespace="effectiveNamespace"
+        :read-only="readOnly"
+        :supports-create-subscription="canCreateSubscription"
+        :supports-reset-cursor="canResetCursor"
+        :supports-skip-messages="canSkipMessages"
+        :supports-clear-backlog="canClearBacklog"
+        :supports-peek-messages="canPeekMessages"
+        :supports-expire-messages="canExpireMessages"
+        @subscription-selected="handleSubscriptionSelected"
+      />
+      <MonitoringPanel v-else-if="activeTab === 'monitoring'" :connection-id="connectionId" :topic="selectedTopic" :tenant="effectiveTenant" :namespace="effectiveNamespace" />
+      <ProducerConsumerPanel v-else-if="activeTab === 'clients'" :connection-id="connectionId" :topic="selectedTopic" :tenant="effectiveTenant" :namespace="effectiveNamespace" :read-only="readOnly" :selected-subscription="selectedSubscriptionName" :is-kafka-cluster="isKafkaCluster" />
+      <SendMessagePanel v-else-if="activeTab === 'messages' && canSendMessage" :connection-id="connectionId" :tenant="effectiveTenant" :namespace="effectiveNamespace" :topic="selectedTopic" :read-only="readOnly" :is-kafka-cluster="isKafkaCluster" :supports-peek-messages="canPeekMessages" />
+      <BrokerPanel v-else-if="activeTab === 'broker'" :connection-id="connectionId" :read-only="readOnly" />
+      <PoliciesPanel
+        v-else-if="activeTab === 'policies' && canManagePolicies"
+        :connection-id="connectionId"
+        :topic="selectedTopic"
+        :tenant="effectiveTenant"
+        :namespace="effectiveNamespace"
+        :read-only="readOnly"
+        :is-kafka-cluster="isKafkaCluster"
+        :supports-rate-limits="canManageRateLimits"
+        :supports-backlog-quota="canManageBacklogQuota"
+        :supports-retention="canManageRetention"
+      />
+      <PermissionsPanel v-else-if="activeTab === 'permissions' && canManagePermissions" :connection-id="connectionId" :topic="selectedTopic" :tenant="effectiveTenant" :namespace="effectiveNamespace" :read-only="readOnly" />
+      <RawApiPanel v-else-if="activeTab === 'raw' && canUseRawApi" :connection-id="connectionId" :tenant="selectedTenant" :namespace="selectedNamespace" :topic="selectedTopic" :read-only="readOnly" />
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.mq-admin-console {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+  background: var(--color-background);
+}
+
+.mq-toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 8px 16px;
+  border-bottom: 1px solid var(--color-border);
+  background: var(--color-background-secondary);
+}
+
+.mq-breadcrumb {
+  display: flex;
+  align-items: center;
+  font-size: 14px;
+  color: var(--color-text-secondary);
+}
+
+.cluster-info {
+  font-weight: 600;
+  color: var(--color-primary);
+  margin-right: 8px;
+}
+
+.breadcrumb-separator {
+  margin: 0 8px;
+  color: var(--color-text-tertiary);
+}
+
+.breadcrumb-item {
+  color: var(--color-text);
+  font-weight: 500;
+}
+
+.breadcrumb-button {
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: var(--color-text);
+  cursor: pointer;
+  font: inherit;
+  font-weight: 500;
+  padding: 2px 4px;
+}
+
+.breadcrumb-button:hover {
+  background: var(--color-hover);
+  color: var(--color-primary);
+}
+
+.toolbar-error {
+  color: var(--color-error);
+  font-size: 13px;
+}
+
+.toolbar-status {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.readonly-badge {
+  padding: 2px 8px;
+  border: 1px solid var(--color-warning);
+  border-radius: 4px;
+  color: var(--color-warning);
+  font-size: 12px;
+  font-weight: 500;
+}
+
+.mq-tabs {
+  display: flex;
+  border-bottom: 1px solid var(--color-border);
+  background: var(--color-background-secondary);
+  overflow-x: auto;
+}
+
+.mq-tabs button {
+  padding: 10px 20px;
+  border: none;
+  background: transparent;
+  cursor: pointer;
+  color: var(--color-text-secondary);
+  border-bottom: 2px solid transparent;
+  font-size: 14px;
+  font-weight: 500;
+  transition: all 0.2s;
+}
+
+.mq-tabs button:hover {
+  color: var(--color-text);
+  background: var(--color-hover);
+}
+
+.mq-tabs button.active {
+  color: var(--color-primary);
+  border-bottom-color: var(--color-primary);
+  background: var(--color-background);
+}
+
+.mq-content {
+  flex: 1;
+  overflow: hidden;
+}
+
+.mq-content :deep(table) {
+  border-collapse: collapse;
+}
+
+.mq-content :deep(thead th) {
+  border-bottom: 1px solid var(--color-border);
+}
+
+.mq-content :deep(tbody td) {
+  border-bottom: 1px solid var(--color-border);
+}
+
+.mq-content :deep(tbody tr:last-child td) {
+  border-bottom: 1px solid var(--color-border);
+}
+</style>
diff --git a/apps/desktop/src/components/mq/NamespacesPanel.vue b/apps/desktop/src/components/mq/NamespacesPanel.vue
new file mode 100644
index 0000000..585a790
--- /dev/null
+++ b/apps/desktop/src/components/mq/NamespacesPanel.vue
@@ -0,0 +1,473 @@
+<script setup lang="ts">
+import { formatError } from "@/lib/backend/errorUtils";
+import { ref, watch } from "vue";
+import type { NamespaceRef, NamespaceInfo, NamespaceConfig } from "@/types/mq";
+import { mqListNamespaces, mqCreateNamespace, mqDeleteNamespace } from "@/lib/backend/api";
+
+interface Props {
+  connectionId: string;
+  tenant?: string;
+  supportsNamespaces: boolean;
+  readOnly?: boolean;
+}
+
+const props = defineProps<Props>();
+const emit = defineEmits<{
+  namespaceSelected: [namespace: string];
+  namespaceRolesSelected: [namespace: string];
+}>();
+
+const namespaces = ref<NamespaceInfo[]>([]);
+const loading = ref(false);
+const error = ref<string>();
+const showCreateDialog = ref(false);
+const selectedNamespace = ref<string>();
+
+const formData = ref({
+  namespace: "",
+});
+
+const readOnlyMessage = "当前连接为只读模式，不能执行写操作";
+
+function guardWritable() {
+  if (props.readOnly) {
+    error.value = readOnlyMessage;
+    return false;
+  }
+  return true;
+}
+
+async function loadNamespaces() {
+  if (!props.tenant) {
+    namespaces.value = [];
+    return;
+  }
+  loading.value = true;
+  error.value = undefined;
+  try {
+    namespaces.value = await mqListNamespaces(props.connectionId, props.tenant);
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function openCreateDialog() {
+  if (!guardWritable()) return;
+  formData.value = {
+    namespace: "",
+  };
+  showCreateDialog.value = true;
+}
+
+async function handleCreate() {
+  if (!guardWritable()) return;
+  if (!formData.value.namespace.trim() || !props.tenant) {
+    error.value = "Namespace name is required";
+    return;
+  }
+  loading.value = true;
+  error.value = undefined;
+  try {
+    const ns: NamespaceRef = {
+      tenant: props.tenant,
+      namespace: formData.value.namespace,
+    };
+    const config: NamespaceConfig = {};
+    await mqCreateNamespace(props.connectionId, ns, config);
+    showCreateDialog.value = false;
+    await loadNamespaces();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function handleDelete(ns: NamespaceInfo) {
+  if (!guardWritable()) return;
+  if (!confirm(`确定要删除命名空间 "${ns.namespace}" 吗？此操作不可逆。`)) return;
+  if (!props.tenant) return;
+  loading.value = true;
+  error.value = undefined;
+  try {
+    const nsRef: NamespaceRef = {
+      tenant: props.tenant,
+      namespace: ns.namespace,
+    };
+    await mqDeleteNamespace(props.connectionId, nsRef, false);
+    if (selectedNamespace.value === ns.namespace) {
+      selectedNamespace.value = undefined;
+    }
+    await loadNamespaces();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function selectNamespace(ns: NamespaceInfo) {
+  selectedNamespace.value = ns.namespace;
+  emit("namespaceSelected", ns.namespace);
+}
+
+function editNamespaceRoles(ns: NamespaceInfo) {
+  selectedNamespace.value = ns.namespace;
+  emit("namespaceRolesSelected", ns.namespace);
+}
+
+watch(
+  () => props.tenant,
+  () => {
+    selectedNamespace.value = undefined;
+    loadNamespaces();
+  },
+  { immediate: true },
+);
+</script>
+
+<template>
+  <div class="namespaces-panel">
+    <div class="panel-toolbar">
+      <h3>命名空间管理</h3>
+      <button @click="openCreateDialog" :disabled="loading || readOnly || !tenant" class="btn-primary">+ 创建命名空间</button>
+    </div>
+
+    <div v-if="!supportsNamespaces" class="panel-placeholder">当前消息队列系统不支持命名空间管理</div>
+
+    <div v-else-if="!tenant" class="panel-placeholder">请先选择一个租户</div>
+
+    <div v-else-if="error" class="panel-error">{{ error }}</div>
+
+    <div v-else-if="loading && !namespaces.length" class="panel-loading">加载中...</div>
+
+    <div v-else class="namespaces-table">
+      <table>
+        <thead>
+          <tr>
+            <th>名称</th>
+            <th>租户</th>
+            <th>管理角色</th>
+            <th>操作</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-for="ns in namespaces" :key="ns.namespace" :class="{ selected: selectedNamespace === ns.namespace }" @click="selectNamespace(ns)">
+            <td class="namespace-name">{{ ns.namespace }}</td>
+            <td>{{ ns.tenant }}</td>
+            <td>
+              <span v-if="ns.adminRoles.length" class="tag-list">
+                <span v-for="role in ns.adminRoles" :key="role" class="tag">{{ role }}</span>
+              </span>
+              <span v-else class="text-muted">无</span>
+            </td>
+            <td class="actions">
+              <button @click.stop="editNamespaceRoles(ns)" class="btn-sm">编辑角色</button>
+              <button @click.stop="handleDelete(ns)" :disabled="readOnly" class="btn-sm btn-danger">删除</button>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+
+    <!-- Create Dialog -->
+    <div v-if="showCreateDialog" class="dialog-overlay" @click="showCreateDialog = false">
+      <div class="dialog" @click.stop>
+        <div class="dialog-header">
+          <h3>创建命名空间</h3>
+          <button @click="showCreateDialog = false" class="btn-close">×</button>
+        </div>
+        <div class="dialog-body">
+          <div class="form-group">
+            <label>租户</label>
+            <input type="text" :value="tenant" disabled />
+          </div>
+          <div class="form-group">
+            <label>命名空间名称*</label>
+            <input v-model="formData.namespace" type="text" placeholder="例如: my-namespace" :disabled="readOnly" />
+          </div>
+          <div v-if="error" class="form-error">{{ error }}</div>
+        </div>
+        <div class="dialog-footer">
+          <button @click="showCreateDialog = false" class="btn-secondary">取消</button>
+          <button @click="handleCreate" :disabled="loading || readOnly" class="btn-primary">创建</button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.namespaces-panel {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.panel-toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.panel-toolbar h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.panel-placeholder,
+.panel-error,
+.panel-loading {
+  padding: 24px;
+  text-align: center;
+  color: var(--color-text-secondary);
+}
+
+.panel-error {
+  color: var(--color-error);
+}
+
+.namespaces-table {
+  flex: 1;
+  overflow: auto;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+thead {
+  position: sticky;
+  top: 0;
+  background: var(--color-background-secondary);
+  z-index: 1;
+}
+
+th {
+  padding: 10px 12px;
+  text-align: left;
+  font-weight: 600;
+  font-size: 13px;
+  color: var(--color-text-secondary);
+  border-bottom: 1px solid var(--color-border);
+}
+
+tbody tr {
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+tbody tr:hover {
+  background: var(--color-hover);
+}
+
+tbody tr.selected {
+  background: var(--color-primary-alpha);
+}
+
+td {
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--color-border-light);
+}
+
+.namespace-name {
+  font-weight: 500;
+}
+
+.text-muted {
+  color: var(--color-text-tertiary);
+  font-style: italic;
+}
+
+.actions {
+  display: flex;
+  gap: 8px;
+}
+
+.btn-primary,
+.btn-secondary,
+.btn-sm,
+.btn-danger {
+  padding: 6px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: 13px;
+  transition: all 0.2s;
+}
+
+.btn-primary {
+  background: var(--color-primary);
+  color: white;
+  border-color: var(--color-primary);
+}
+
+.btn-primary:hover:not(:disabled) {
+  opacity: 0.9;
+}
+
+.btn-danger {
+  color: var(--color-error);
+  border-color: var(--color-error);
+}
+
+.btn-danger:hover:not(:disabled) {
+  background: var(--color-error);
+  color: white;
+}
+
+.btn-sm {
+  padding: 4px 8px;
+  font-size: 12px;
+}
+
+button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.tag-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  margin-top: 8px;
+}
+
+.tag {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  padding: 2px 8px;
+  background: var(--color-primary-alpha);
+  color: var(--color-primary);
+  border-radius: 4px;
+  font-size: 12px;
+}
+
+.tag-remove {
+  border: none;
+  background: none;
+  color: inherit;
+  cursor: pointer;
+  padding: 0;
+  font-size: 14px;
+  line-height: 1;
+}
+
+/* Dialog styles */
+.dialog-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.5);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+}
+
+.dialog {
+  background: var(--color-background);
+  border-radius: 8px;
+  width: 90%;
+  max-width: 500px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+}
+
+.dialog-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 16px 20px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.dialog-header h3 {
+  margin: 0;
+  font-size: 18px;
+}
+
+.btn-close {
+  border: none;
+  background: none;
+  font-size: 24px;
+  cursor: pointer;
+  color: var(--color-text-secondary);
+  padding: 0;
+  line-height: 1;
+}
+
+.dialog-body {
+  padding: 20px;
+  max-height: 60vh;
+  overflow-y: auto;
+}
+
+.form-group {
+  margin-bottom: 16px;
+}
+
+.form-group label {
+  display: block;
+  margin-bottom: 6px;
+  font-weight: 500;
+  font-size: 13px;
+}
+
+.form-group input[type="text"],
+.form-group input[type="number"] {
+  width: 100%;
+  padding: 8px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  font-size: 14px;
+  box-sizing: border-box;
+}
+
+.form-group input:disabled {
+  background: var(--color-background-secondary);
+  color: var(--color-text-secondary);
+}
+
+.input-with-button {
+  display: flex;
+  gap: 8px;
+}
+
+.input-with-button input {
+  flex: 1;
+}
+
+.form-hint {
+  margin-top: 4px;
+  font-size: 12px;
+  color: var(--color-text-tertiary);
+}
+
+.form-error {
+  margin-top: 12px;
+  padding: 8px 12px;
+  background: var(--color-error-bg);
+  color: var(--color-error);
+  border-radius: 4px;
+  font-size: 13px;
+}
+
+.dialog-footer {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  padding: 16px 20px;
+  border-top: 1px solid var(--color-border);
+}
+</style>
diff --git a/apps/desktop/src/components/mq/PermissionsPanel.vue b/apps/desktop/src/components/mq/PermissionsPanel.vue
new file mode 100644
index 0000000..bcaf3f2
--- /dev/null
+++ b/apps/desktop/src/components/mq/PermissionsPanel.vue
@@ -0,0 +1,833 @@
+<script setup lang="ts">
+import { formatError } from "@/lib/backend/errorUtils";
+import { computed, nextTick, ref, watch } from "vue";
+import type { AuthAction, MqIssuedToken, MqTokenRecord, PermissionMap, PolicyScope, TopicInfo } from "@/types/mq";
+import { mqGrantPermission, mqIssueToken, mqListPermissions, mqListTokenRecords, mqRevokePermission } from "@/lib/backend/api";
+import { formatMqTokenIssueError, type MqTokenIssueErrorView } from "@/lib/mq/mqTokenErrors";
+
+interface Props {
+  connectionId: string;
+  tenant?: string;
+  namespace?: string;
+  topic?: TopicInfo;
+  readOnly?: boolean;
+}
+
+const props = defineProps<Props>();
+
+const actionOptions: AuthAction[] = ["produce", "consume", "functions", "sources", "sinks", "packages"];
+
+const permissions = ref<PermissionMap>({});
+const loading = ref(false);
+const error = ref<string>();
+const notice = ref<string>();
+const roleName = ref("");
+const roleNameInput = ref<HTMLInputElement | null>(null);
+const roleNameError = ref("");
+const selectedActions = ref<AuthAction[]>(["produce", "consume"]);
+const actionsError = ref("");
+const tokenRole = ref("");
+const tokenActions = ref<AuthAction[]>([]);
+const tokenExpiresUnlimited = ref(true);
+const tokenExpiresDays = ref(30);
+const tokenNote = ref("");
+const tokenRecords = ref<MqTokenRecord[]>([]);
+const tokenLoading = ref(false);
+const tokenError = ref<string>();
+const tokenIssueError = ref<MqTokenIssueErrorView>();
+const issuedToken = ref<MqIssuedToken>();
+const showTokenDialog = ref(false);
+const readOnlyMessage = "当前连接为只读模式，不能执行写操作";
+
+const scope = computed<PolicyScope | null>(() => {
+  if (!props.tenant || !props.namespace) return null;
+  if (props.topic) {
+    return {
+      level: "topic",
+      tenant: props.tenant,
+      namespace: props.namespace,
+      topic: props.topic.shortName,
+      persistent: props.topic.persistent,
+    };
+  }
+  return {
+    level: "namespace",
+    tenant: props.tenant,
+    namespace: props.namespace,
+  };
+});
+
+const scopeLabel = computed(() => {
+  const current = scope.value;
+  if (!current) return "";
+  if (current.level === "topic") {
+    return `${current.tenant}/${current.namespace}/${current.topic}`;
+  }
+  return `${current.tenant}/${current.namespace}`;
+});
+
+const permissionRows = computed(() => {
+  return Object.entries(permissions.value).map(([role, actions]) => ({ role, actions }));
+});
+
+function guardWritable() {
+  if (props.readOnly) {
+    error.value = readOnlyMessage;
+    notice.value = undefined;
+    return false;
+  }
+  return true;
+}
+
+async function loadPermissions() {
+  const current = scope.value;
+  permissions.value = {};
+  notice.value = undefined;
+  error.value = undefined;
+  if (!current) return;
+
+  loading.value = true;
+  try {
+    permissions.value = await mqListPermissions(props.connectionId, current);
+  } catch (e: unknown) {
+    const msg = formatError(e);
+    // Gracefully handle Kafka brokers without an authorizer configured.
+    if (msg.includes("SecurityDisabled") || msg.includes("No Authorizer") || msg.includes("authorizer")) {
+      error.value = undefined;
+      notice.value = "当前 Kafka 集群未启用权限管理（Authorizer 未配置）。如需 ACL 功能，请在 Broker 配置中添加 authorizer.class.name。";
+    } else {
+      error.value = msg;
+    }
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function grantPermission() {
+  if (!guardWritable()) return;
+  const current = scope.value;
+  const role = roleName.value.trim();
+  roleNameError.value = "";
+  actionsError.value = "";
+  if (!current) {
+    error.value = "请先选择命名空间或主题";
+    return;
+  }
+  if (!role) {
+    error.value = undefined;
+    roleNameError.value = "请输入角色名";
+    await nextTick();
+    roleNameInput.value?.focus();
+    return;
+  }
+  if (!selectedActions.value.length) {
+    error.value = undefined;
+    actionsError.value = "请至少选择一个权限动作";
+    return;
+  }
+
+  loading.value = true;
+  error.value = undefined;
+  notice.value = undefined;
+  try {
+    await mqGrantPermission(props.connectionId, current, role, [...selectedActions.value]);
+    notice.value = `已授权 ${role}`;
+    roleName.value = "";
+    await loadPermissions();
+  } catch (e: unknown) {
+    const msg = formatError(e);
+    if (msg.includes("SecurityDisabled") || msg.includes("No Authorizer") || msg.includes("authorizer")) {
+      error.value = "当前 Kafka 集群未启用权限管理，无法执行授权操作。请在 Broker 配置中启用 Authorizer。";
+    } else {
+      error.value = msg;
+    }
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function revokePermission(role: string) {
+  if (!guardWritable()) return;
+  const current = scope.value;
+  if (!current) {
+    error.value = "请先选择命名空间或主题";
+    return;
+  }
+  if (!confirm(`确定要撤销角色 "${role}" 的权限吗？`)) return;
+
+  loading.value = true;
+  error.value = undefined;
+  notice.value = undefined;
+  try {
+    await mqRevokePermission(props.connectionId, current, role);
+    notice.value = `已撤销 ${role}`;
+    await loadPermissions();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function openTokenDialog(role: string) {
+  const row = permissionRows.value.find((item) => item.role === role);
+  tokenRole.value = role;
+  tokenActions.value = row?.actions?.length ? [...row.actions] : ["produce", "consume"];
+  tokenExpiresUnlimited.value = true;
+  tokenExpiresDays.value = 30;
+  tokenNote.value = "";
+  tokenError.value = undefined;
+  tokenIssueError.value = undefined;
+  issuedToken.value = undefined;
+  tokenRecords.value = [];
+  showTokenDialog.value = true;
+  void loadTokenRecords();
+}
+
+function closeTokenDialog() {
+  showTokenDialog.value = false;
+  issuedToken.value = undefined;
+}
+
+async function loadTokenRecords() {
+  if (!tokenRole.value) return;
+  tokenLoading.value = true;
+  tokenError.value = undefined;
+  try {
+    tokenRecords.value = await mqListTokenRecords(props.connectionId, tokenRole.value);
+  } catch (e: unknown) {
+    if (isTokenRecordListUnavailable(e)) {
+      tokenRecords.value = [];
+      return;
+    }
+    tokenError.value = formatError(e);
+  } finally {
+    tokenLoading.value = false;
+  }
+}
+
+async function issueToken() {
+  if (props.readOnly) {
+    tokenError.value = readOnlyMessage;
+    tokenIssueError.value = undefined;
+    return;
+  }
+  const current = scope.value;
+  if (!current) {
+    tokenError.value = "请先选择命名空间或主题";
+    tokenIssueError.value = undefined;
+    return;
+  }
+  const subject = tokenRole.value.trim();
+  if (!subject) {
+    tokenError.value = "角色名不能为空";
+    tokenIssueError.value = undefined;
+    return;
+  }
+  let expiresInSeconds: number | undefined;
+  if (!tokenExpiresUnlimited.value) {
+    const days = Number(tokenExpiresDays.value);
+    if (!Number.isFinite(days) || days <= 0) {
+      tokenError.value = "有效期必须大于 0 天";
+      tokenIssueError.value = undefined;
+      return;
+    }
+    expiresInSeconds = Math.round(days * 24 * 60 * 60);
+  }
+
+  tokenLoading.value = true;
+  tokenError.value = undefined;
+  tokenIssueError.value = undefined;
+  issuedToken.value = undefined;
+  try {
+    issuedToken.value = await mqIssueToken(props.connectionId, {
+      subject,
+      expiresInSeconds,
+      scope: current,
+      actions: [...tokenActions.value],
+      note: tokenNote.value.trim() || undefined,
+    });
+    await loadTokenRecords();
+  } catch (e: unknown) {
+    const formatted = formatMqTokenIssueError(e);
+    if (formatted.kind === "missingSigningKey") {
+      tokenIssueError.value = formatted;
+      tokenError.value = undefined;
+    } else {
+      tokenError.value = formatted.message;
+    }
+  } finally {
+    tokenLoading.value = false;
+  }
+}
+
+async function copyIssuedToken() {
+  if (!issuedToken.value?.token) return;
+  await navigator.clipboard?.writeText(issuedToken.value.token);
+}
+
+function formatDate(value?: string) {
+  if (!value) return "长期";
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? value : date.toLocaleString();
+}
+
+function shortFingerprint(value: string) {
+  if (value.length <= 22) return value;
+  return `${value.slice(0, 14)}...${value.slice(-8)}`;
+}
+
+function isTokenRecordListUnavailable(e: unknown) {
+  const message = e instanceof Error ? formatError(e) : String(e ?? "");
+  return message.includes("/api/mq/tokens/list returned 404");
+}
+
+watch(roleName, (value) => {
+  if (value.trim()) {
+    roleNameError.value = "";
+  }
+});
+
+watch(selectedActions, (value) => {
+  if (value.length) {
+    actionsError.value = "";
+  }
+});
+
+watch(
+  () => [props.tenant, props.namespace, props.topic?.name, props.topic?.persistent],
+  () => {
+    loadPermissions();
+  },
+  { immediate: true },
+);
+</script>
+
+<template>
+  <div class="permissions-panel">
+    <div class="panel-toolbar">
+      <div>
+        <h3>权限管理</h3>
+        <div v-if="scopeLabel" class="scope-label">{{ scopeLabel }}</div>
+      </div>
+      <button @click="loadPermissions" :disabled="loading || !scope" class="btn-sm">
+        {{ loading ? "刷新中..." : "刷新" }}
+      </button>
+    </div>
+
+    <div v-if="!scope" class="panel-placeholder">请先选择命名空间或主题</div>
+
+    <div v-else class="permissions-content">
+      <div v-if="readOnly" class="readonly-hint">当前连接为只读模式，授权和撤销已禁用。</div>
+      <div v-if="error" class="panel-error">{{ error }}</div>
+      <div v-if="notice" class="panel-notice">{{ notice }}</div>
+
+      <section class="grant-panel">
+        <h4>授权角色</h4>
+        <div class="grant-row">
+          <label>
+            角色名
+            <input ref="roleNameInput" v-model="roleName" type="text" placeholder="例如: app-producer" :disabled="readOnly" :class="{ invalid: roleNameError }" :aria-invalid="!!roleNameError" />
+            <span v-if="roleNameError" class="field-error">{{ roleNameError }}</span>
+          </label>
+          <div class="actions-group" :class="{ invalid: actionsError }">
+            <span>权限动作</span>
+            <label v-for="action in actionOptions" :key="action" class="checkbox-label">
+              <input v-model="selectedActions" type="checkbox" :value="action" :disabled="readOnly" />
+              {{ action }}
+            </label>
+            <span v-if="actionsError" class="field-error actions-error">{{ actionsError }}</span>
+          </div>
+          <button @click="grantPermission" :disabled="loading || readOnly" class="btn-primary">授权</button>
+        </div>
+      </section>
+
+      <section class="permissions-table">
+        <h4>当前权限</h4>
+        <table v-if="permissionRows.length">
+          <thead>
+            <tr>
+              <th>角色</th>
+              <th>动作</th>
+              <th>操作</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="row in permissionRows" :key="row.role">
+              <td class="role-cell">{{ row.role }}</td>
+              <td>
+                <span class="tag-list">
+                  <span v-for="action in row.actions" :key="action" class="tag">{{ action }}</span>
+                </span>
+              </td>
+              <td class="row-actions">
+                <button @click="openTokenDialog(row.role)" class="btn-sm">Token</button>
+                <button @click="revokePermission(row.role)" :disabled="readOnly" class="btn-sm btn-danger">撤销</button>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+        <div v-else class="empty-state">暂无权限记录</div>
+      </section>
+    </div>
+
+    <div v-if="showTokenDialog" class="dialog-overlay" @click="closeTokenDialog">
+      <div class="dialog" @click.stop>
+        <div class="dialog-header">
+          <h3>客户端 Token: {{ tokenRole }}</h3>
+          <button @click="closeTokenDialog" class="btn-close">×</button>
+        </div>
+        <div class="dialog-body">
+          <div v-if="tokenError" class="panel-error">{{ tokenError }}</div>
+          <div v-if="tokenIssueError" class="token-config-error" role="alert">
+            <strong>{{ tokenIssueError.title }}</strong>
+            <span>{{ tokenIssueError.message }}</span>
+            <small>{{ tokenIssueError.detail }}</small>
+          </div>
+          <div v-if="issuedToken" class="issued-token-box">
+            <div class="token-warning">Token 仅显示一次，请立即复制并保存好。</div>
+            <textarea :value="issuedToken.token" readonly class="token-textarea" />
+            <button class="btn-sm" @click="copyIssuedToken">复制 Token</button>
+          </div>
+
+          <section class="token-section">
+            <h4>签发新 Token</h4>
+            <div class="token-form">
+              <label>
+                角色
+                <input v-model="tokenRole" type="text" />
+              </label>
+              <div class="expiry-control">
+                <label class="checkbox-label expiry-toggle">
+                  <input v-model="tokenExpiresUnlimited" type="checkbox" />
+                  永不过期
+                </label>
+                <label :class="{ muted: tokenExpiresUnlimited }">
+                  有效期（天）
+                  <input v-model.number="tokenExpiresDays" type="number" min="1" step="1" :disabled="tokenExpiresUnlimited" />
+                </label>
+              </div>
+              <div class="actions-group token-actions">
+                <span>权限动作</span>
+                <label v-for="action in actionOptions" :key="action" class="checkbox-label">
+                  <input v-model="tokenActions" type="checkbox" :value="action" />
+                  {{ action }}
+                </label>
+              </div>
+              <label>
+                备注
+                <input v-model="tokenNote" type="text" placeholder="例如: 发给 rt-erp-server" />
+              </label>
+              <button @click="issueToken" :disabled="tokenLoading || readOnly" class="btn-primary">
+                {{ tokenLoading ? "签发中..." : "生成 Token" }}
+              </button>
+            </div>
+            <p class="token-message">撤销角色权限不会让已签发 JWT 立即失效；需要等待过期，或轮换 Broker 签发密钥。</p>
+          </section>
+
+          <section class="token-section">
+            <h4>签发记录</h4>
+            <table v-if="tokenRecords.length">
+              <thead>
+                <tr>
+                  <th>时间</th>
+                  <th>算法</th>
+                  <th>过期</th>
+                  <th>指纹</th>
+                  <th>备注</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr v-for="record in tokenRecords" :key="record.id">
+                  <td>{{ formatDate(record.createdAt) }}</td>
+                  <td>{{ record.algorithm.toUpperCase() }}</td>
+                  <td>{{ formatDate(record.expiresAt) }}</td>
+                  <td :title="record.tokenFingerprint">{{ shortFingerprint(record.tokenFingerprint) }}</td>
+                  <td>{{ record.note || "-" }}</td>
+                </tr>
+              </tbody>
+            </table>
+            <div v-else class="empty-state">{{ tokenLoading ? "加载中..." : "暂无签发记录" }}</div>
+          </section>
+        </div>
+        <div class="dialog-footer">
+          <button @click="closeTokenDialog" class="btn-secondary">关闭</button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.permissions-panel {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.panel-toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.panel-toolbar h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.scope-label {
+  margin-top: 4px;
+  color: var(--color-text-secondary);
+  font-size: 12px;
+}
+
+.permissions-content {
+  flex: 1;
+  overflow: auto;
+  padding: 16px;
+}
+
+.grant-panel,
+.permissions-table {
+  padding: 14px;
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-background-secondary);
+}
+
+.permissions-table {
+  margin-top: 16px;
+}
+
+h4 {
+  margin: 0 0 12px;
+  font-size: 14px;
+  font-weight: 600;
+}
+
+.grant-row {
+  display: grid;
+  grid-template-columns: minmax(220px, 1fr) minmax(280px, 2fr) auto;
+  gap: 16px;
+  align-items: end;
+}
+
+label {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  color: var(--color-text-secondary);
+  font-size: 13px;
+}
+
+input[type="text"],
+input[type="number"] {
+  width: 100%;
+  padding: 7px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  box-sizing: border-box;
+}
+
+input.invalid {
+  border-color: var(--color-error);
+  box-shadow: 0 0 0 2px var(--color-error-bg);
+}
+
+.field-error {
+  color: var(--color-error);
+  font-size: 12px;
+  line-height: 1.4;
+}
+
+.actions-group {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px 12px;
+  color: var(--color-text-secondary);
+  font-size: 13px;
+}
+
+.actions-group.invalid {
+  padding: 8px;
+  border: 1px solid var(--color-error);
+  border-radius: 6px;
+  background: var(--color-error-bg);
+}
+
+.actions-group > span {
+  width: 100%;
+}
+
+.actions-error {
+  width: 100%;
+}
+
+.checkbox-label {
+  flex-direction: row;
+  align-items: center;
+  gap: 6px;
+}
+
+.expiry-control {
+  display: grid;
+  gap: 8px;
+}
+
+.expiry-toggle {
+  min-height: 30px;
+}
+
+.muted {
+  color: var(--color-text-tertiary);
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+th,
+td {
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--color-border-light);
+  text-align: left;
+}
+
+th {
+  color: var(--color-text-secondary);
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.role-cell {
+  font-weight: 500;
+}
+
+.row-actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.tag-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+
+.tag {
+  padding: 2px 8px;
+  border-radius: 4px;
+  background: var(--color-primary-alpha);
+  color: var(--color-primary);
+  font-size: 12px;
+}
+
+.empty-state,
+.panel-placeholder {
+  padding: 24px;
+  color: var(--color-text-secondary);
+  text-align: center;
+}
+
+.panel-error,
+.panel-notice,
+.readonly-hint {
+  padding: 12px 16px;
+  margin-bottom: 12px;
+  border-radius: 6px;
+  font-size: 13px;
+}
+
+.panel-error {
+  background: var(--color-error-bg);
+  color: var(--color-error);
+}
+
+.panel-notice {
+  background: var(--color-success-alpha);
+  color: var(--color-success);
+}
+
+.readonly-hint {
+  background: var(--color-warning-alpha);
+  color: var(--color-warning);
+}
+
+.btn-primary,
+.btn-secondary,
+.btn-sm,
+.btn-danger {
+  padding: 6px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: 13px;
+}
+
+.btn-primary {
+  background: var(--color-primary);
+  border-color: var(--color-primary);
+  color: white;
+}
+
+.btn-danger {
+  color: var(--color-error);
+  border-color: var(--color-error);
+}
+
+.dialog-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 1000;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgba(0, 0, 0, 0.45);
+}
+
+.dialog {
+  width: min(760px, 92vw);
+  max-height: 86vh;
+  display: flex;
+  flex-direction: column;
+  border-radius: 8px;
+  background: var(--color-background);
+  box-shadow: 0 12px 32px rgba(0, 0, 0, 0.18);
+}
+
+.dialog-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  padding: 16px 20px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.dialog-header h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.btn-close {
+  border: none;
+  background: none;
+  color: var(--color-text-secondary);
+  cursor: pointer;
+  font-size: 22px;
+  line-height: 1;
+}
+
+.dialog-body {
+  padding: 18px 20px;
+  overflow: auto;
+}
+
+.token-message {
+  margin: 0;
+  color: var(--color-text-secondary);
+  font-size: 13px;
+  line-height: 1.6;
+}
+
+.issued-token-box {
+  display: grid;
+  gap: 10px;
+  padding: 12px;
+  margin-bottom: 16px;
+  border: 1px solid var(--color-warning);
+  border-radius: 6px;
+  background: var(--color-warning-alpha);
+}
+
+.token-config-error {
+  display: grid;
+  gap: 6px;
+  padding: 12px 14px;
+  margin-bottom: 16px;
+  border: 1px solid var(--color-warning);
+  border-left-width: 4px;
+  border-radius: 6px;
+  background: var(--color-warning-alpha);
+  color: var(--color-text);
+  font-size: 13px;
+  line-height: 1.5;
+}
+
+.token-config-error strong {
+  color: var(--color-warning);
+  font-size: 14px;
+  font-weight: 700;
+}
+
+.token-config-error small {
+  color: var(--color-text-secondary);
+  font-size: 12px;
+  line-height: 1.5;
+}
+
+.token-warning {
+  color: var(--color-warning);
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.token-textarea {
+  min-height: 96px;
+  padding: 8px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+  font-size: 12px;
+  resize: vertical;
+}
+
+.token-section {
+  margin-top: 16px;
+}
+
+.token-form {
+  display: grid;
+  grid-template-columns: minmax(160px, 1fr) minmax(120px, 0.6fr);
+  gap: 12px;
+  align-items: end;
+}
+
+.token-actions {
+  grid-column: 1 / -1;
+}
+
+.dialog-footer {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  padding: 14px 20px;
+  border-top: 1px solid var(--color-border);
+}
+
+button:disabled,
+input:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+@media (max-width: 800px) {
+  .grant-row,
+  .token-form {
+    grid-template-columns: 1fr;
+  }
+}
+</style>
diff --git a/apps/desktop/src/components/mq/PoliciesPanel.vue b/apps/desktop/src/components/mq/PoliciesPanel.vue
new file mode 100644
index 0000000..b9e55ed
--- /dev/null
+++ b/apps/desktop/src/components/mq/PoliciesPanel.vue
@@ -0,0 +1,426 @@
+<script setup lang="ts">
+import { formatError } from "@/lib/backend/errorUtils";
+import { computed, ref, watch } from "vue";
+import type { BacklogQuota, DispatchRate, PolicyScope, PublishRate, RetentionPolicy, SubscribeRate, TopicInfo } from "@/types/mq";
+import { mqGetEffectivePolicies, mqSetBacklogQuota, mqSetDispatchRate, mqSetPublishRate, mqSetRetention, mqSetSubscribeRate } from "@/lib/backend/api";
+import { defaultMqPolicyForms, policyFormsFromEffectivePolicies } from "@/lib/mq/mqPolicyForms";
+
+interface Props {
+  connectionId: string;
+  tenant?: string;
+  namespace?: string;
+  topic?: TopicInfo;
+  readOnly?: boolean;
+  isKafkaCluster?: boolean;
+  supportsRateLimits?: boolean;
+  supportsBacklogQuota?: boolean;
+  supportsRetention?: boolean;
+}
+
+const props = defineProps<Props>();
+
+const policies = ref<unknown>();
+const loading = ref(false);
+const error = ref<string>();
+const notice = ref<string>();
+const readOnlyMessage = "当前连接为只读模式，不能执行写操作";
+const defaultForms = defaultMqPolicyForms();
+
+const publishForm = ref<PublishRate>({ ...defaultForms.publishForm });
+
+const dispatchForm = ref<DispatchRate>({ ...defaultForms.dispatchForm });
+
+const subscribeForm = ref<SubscribeRate>({ ...defaultForms.subscribeForm });
+
+const backlogForm = ref<BacklogQuota>({ ...defaultForms.backlogForm });
+
+const retentionForm = ref<RetentionPolicy>({ ...defaultForms.retentionForm });
+
+const scope = computed<PolicyScope | null>(() => {
+  if (!props.tenant || !props.namespace) return null;
+  if (props.isKafkaCluster && !props.topic) return null;
+  if (props.topic) {
+    return {
+      level: "topic",
+      tenant: props.tenant,
+      namespace: props.namespace,
+      topic: props.topic.shortName,
+      persistent: props.topic.persistent,
+    };
+  }
+  return {
+    level: "namespace",
+    tenant: props.tenant,
+    namespace: props.namespace,
+  };
+});
+
+const scopePlaceholderMessage = computed(() => (props.isKafkaCluster ? "请先选择主题" : "请选择命名空间或主题"));
+
+const scopeLabel = computed(() => {
+  const current = scope.value;
+  if (!current) return "";
+  if (current.level === "topic") {
+    return `${current.tenant}/${current.namespace}/${current.topic}`;
+  }
+  return `${current.tenant}/${current.namespace}`;
+});
+
+const formattedPolicies = computed(() => JSON.stringify(policies.value ?? {}, null, 2));
+
+function guardWritable() {
+  if (props.readOnly) {
+    error.value = readOnlyMessage;
+    notice.value = undefined;
+    return false;
+  }
+  return true;
+}
+
+async function loadPolicies() {
+  const current = scope.value;
+  policies.value = undefined;
+  notice.value = undefined;
+  error.value = undefined;
+  if (!current) return;
+
+  loading.value = true;
+  try {
+    const loaded = await mqGetEffectivePolicies(props.connectionId, current);
+    policies.value = loaded;
+    const hydrated = policyFormsFromEffectivePolicies(loaded, defaultMqPolicyForms());
+    applyPolicyForms(hydrated);
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function applyPolicy(kind: string, action: (current: PolicyScope) => Promise<void>) {
+  if (!guardWritable()) return;
+  const current = scope.value;
+  if (!current) {
+    error.value = scopePlaceholderMessage.value;
+    return;
+  }
+
+  loading.value = true;
+  error.value = undefined;
+  notice.value = undefined;
+  try {
+    await action(current);
+    notice.value = `${kind}已保存`;
+    await loadPolicies();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function savePublishRate() {
+  return applyPolicy("发布限速", (scope) => mqSetPublishRate(props.connectionId, scope, { ...publishForm.value }));
+}
+
+function saveDispatchRate() {
+  return applyPolicy("派发限速", (scope) => mqSetDispatchRate(props.connectionId, scope, { ...dispatchForm.value }));
+}
+
+function saveSubscribeRate() {
+  return applyPolicy("订阅限速", (scope) => mqSetSubscribeRate(props.connectionId, scope, { ...subscribeForm.value }));
+}
+
+function saveBacklogQuota() {
+  return applyPolicy("积压配额", (scope) => mqSetBacklogQuota(props.connectionId, scope, { ...backlogForm.value }));
+}
+
+function saveRetention() {
+  return applyPolicy("保留策略", (scope) => mqSetRetention(props.connectionId, scope, { ...retentionForm.value }));
+}
+
+function currentPolicyForms() {
+  return {
+    publishForm: { ...publishForm.value },
+    dispatchForm: { ...dispatchForm.value },
+    subscribeForm: { ...subscribeForm.value },
+    backlogForm: { ...backlogForm.value },
+    retentionForm: { ...retentionForm.value },
+  };
+}
+
+function applyPolicyForms(forms: ReturnType<typeof currentPolicyForms>) {
+  publishForm.value = forms.publishForm;
+  dispatchForm.value = forms.dispatchForm;
+  subscribeForm.value = forms.subscribeForm;
+  backlogForm.value = forms.backlogForm;
+  retentionForm.value = forms.retentionForm;
+}
+
+watch(
+  () => [props.tenant, props.namespace, props.topic?.name, props.topic?.persistent],
+  () => {
+    loadPolicies();
+  },
+  { immediate: true },
+);
+</script>
+
+<template>
+  <div class="policies-panel">
+    <div class="panel-toolbar">
+      <div>
+        <h3>策略管理</h3>
+        <div v-if="scopeLabel" class="scope-label">{{ scopeLabel }}</div>
+      </div>
+      <button @click="loadPolicies" :disabled="loading || !scope" class="btn-sm">
+        {{ loading ? "刷新中..." : "刷新" }}
+      </button>
+    </div>
+
+    <div v-if="!scope" class="panel-placeholder">{{ scopePlaceholderMessage }}</div>
+
+    <div v-else class="policies-content">
+      <div v-if="readOnly" class="readonly-hint">当前连接为只读模式，策略编辑已禁用。</div>
+      <div v-if="error" class="panel-error">{{ error }}</div>
+      <div v-if="notice" class="panel-notice">{{ notice }}</div>
+
+      <div class="policy-grid">
+        <section v-if="supportsRateLimits !== false" class="policy-section">
+          <h4>发布限速</h4>
+          <label>
+            消息数 / 秒
+            <input v-model.number="publishForm.publishThrottlingRateInMsg" type="number" :disabled="readOnly" />
+          </label>
+          <label>
+            字节数 / 秒
+            <input v-model.number="publishForm.publishThrottlingRateInByte" type="number" :disabled="readOnly" />
+          </label>
+          <button @click="savePublishRate" :disabled="loading || readOnly" class="btn-primary">保存</button>
+        </section>
+
+        <section v-if="supportsRateLimits !== false" class="policy-section">
+          <h4>派发限速</h4>
+          <label>
+            消息数 / 周期
+            <input v-model.number="dispatchForm.dispatchThrottlingRateInMsg" type="number" :disabled="readOnly" />
+          </label>
+          <label>
+            字节数 / 周期
+            <input v-model.number="dispatchForm.dispatchThrottlingRateInByte" type="number" :disabled="readOnly" />
+          </label>
+          <label>
+            周期（秒）
+            <input v-model.number="dispatchForm.ratePeriodInSecond" type="number" min="1" :disabled="readOnly" />
+          </label>
+          <button @click="saveDispatchRate" :disabled="loading || readOnly" class="btn-primary">保存</button>
+        </section>
+
+        <section v-if="supportsRateLimits !== false" class="policy-section">
+          <h4>订阅限速</h4>
+          <label>
+            每消费者消息数 / 周期
+            <input v-model.number="subscribeForm.subscribeThrottlingRatePerConsumer" type="number" :disabled="readOnly" />
+          </label>
+          <label>
+            周期（秒）
+            <input v-model.number="subscribeForm.ratePeriodInSecond" type="number" min="1" :disabled="readOnly" />
+          </label>
+          <button @click="saveSubscribeRate" :disabled="loading || readOnly" class="btn-primary">保存</button>
+        </section>
+
+        <section v-if="supportsBacklogQuota !== false" class="policy-section">
+          <h4>积压配额</h4>
+          <label>
+            大小限制（字节）
+            <input v-model.number="backlogForm.limitSize" type="number" :disabled="readOnly" />
+          </label>
+          <label>
+            时间限制（秒）
+            <input v-model.number="backlogForm.limitTime" type="number" :disabled="readOnly" />
+          </label>
+          <label>
+            策略
+            <select v-model="backlogForm.policy" :disabled="readOnly">
+              <option value="producer_request_hold">producer_request_hold</option>
+              <option value="producer_exception">producer_exception</option>
+              <option value="consumer_backlog_eviction">consumer_backlog_eviction</option>
+            </select>
+          </label>
+          <label>
+            类型
+            <input v-model="backlogForm.quotaType" type="text" :disabled="readOnly" />
+          </label>
+          <button @click="saveBacklogQuota" :disabled="loading || readOnly" class="btn-primary">保存</button>
+        </section>
+
+        <section v-if="supportsRetention !== false" class="policy-section">
+          <h4>消息保留</h4>
+          <label>
+            保留时间（分钟）
+            <input v-model.number="retentionForm.retentionTimeInMinutes" type="number" :disabled="readOnly" />
+          </label>
+          <label>
+            保留大小（MB）
+            <input v-model.number="retentionForm.retentionSizeInMb" type="number" :disabled="readOnly" />
+          </label>
+          <button @click="saveRetention" :disabled="loading || readOnly" class="btn-primary">保存</button>
+        </section>
+      </div>
+
+      <section class="json-section">
+        <h4>当前有效策略</h4>
+        <pre>{{ formattedPolicies }}</pre>
+      </section>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.policies-panel {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.panel-toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.panel-toolbar h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.scope-label {
+  margin-top: 4px;
+  color: var(--color-text-secondary);
+  font-size: 12px;
+}
+
+.policies-content {
+  flex: 1;
+  overflow: auto;
+  padding: 16px;
+}
+
+.policy-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(260px, 1fr));
+  gap: 12px;
+}
+
+.policy-section,
+.json-section {
+  padding: 14px;
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-background-secondary);
+}
+
+.policy-section h4,
+.json-section h4 {
+  margin: 0 0 12px;
+  font-size: 14px;
+  font-weight: 600;
+}
+
+label {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin-bottom: 10px;
+  color: var(--color-text-secondary);
+  font-size: 13px;
+}
+
+input,
+select {
+  width: 100%;
+  padding: 7px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  box-sizing: border-box;
+}
+
+input:disabled,
+select:disabled {
+  opacity: 0.65;
+  cursor: not-allowed;
+}
+
+.json-section {
+  margin-top: 16px;
+}
+
+pre {
+  margin: 0;
+  padding: 12px;
+  max-height: 360px;
+  overflow: auto;
+  border-radius: 6px;
+  background: var(--color-background);
+  color: var(--color-text);
+  font-size: 12px;
+}
+
+.panel-placeholder,
+.panel-error,
+.panel-notice,
+.readonly-hint {
+  padding: 12px 16px;
+  margin-bottom: 12px;
+  border-radius: 6px;
+  font-size: 13px;
+}
+
+.panel-placeholder {
+  margin: 24px;
+  color: var(--color-text-secondary);
+  text-align: center;
+}
+
+.panel-error {
+  background: var(--color-error-bg);
+  color: var(--color-error);
+}
+
+.panel-notice {
+  background: var(--color-success-alpha);
+  color: var(--color-success);
+}
+
+.readonly-hint {
+  background: var(--color-warning-alpha);
+  color: var(--color-warning);
+}
+
+.btn-primary,
+.btn-sm {
+  padding: 6px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: 13px;
+}
+
+.btn-primary {
+  background: var(--color-primary);
+  border-color: var(--color-primary);
+  color: white;
+}
+
+button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+</style>
diff --git a/apps/desktop/src/components/mq/ProducerConsumerPanel.vue b/apps/desktop/src/components/mq/ProducerConsumerPanel.vue
new file mode 100644
index 0000000..eb20cad
--- /dev/null
+++ b/apps/desktop/src/components/mq/ProducerConsumerPanel.vue
@@ -0,0 +1,743 @@
+<script setup lang="ts">
+import { formatError } from "@/lib/backend/errorUtils";
+import { computed, ref, watch } from "vue";
+import type { ConsumerInfo, ProducerInfo, SubscriptionInfo, TopicInfo, TopicRef, TopicStats } from "@/types/mq";
+import { mqGetTopicStats, mqListConsumers, mqListProducers, mqListSubscriptions, mqUnloadTopic } from "@/lib/backend/api";
+
+interface Props {
+  connectionId: string;
+  topic?: TopicInfo;
+  tenant?: string;
+  namespace?: string;
+  readOnly?: boolean;
+  selectedSubscription?: string;
+  isKafkaCluster?: boolean;
+}
+
+const props = defineProps<Props>();
+
+interface PartitionClientRow {
+  name: string;
+  shortName: string;
+  msgRateIn: number;
+  msgRateOut: number;
+  producerCount: number;
+  subscriptionCount: number;
+  consumerCount: number;
+  producers: ProducerInfo[];
+  subscriptions: SubscriptionInfo[];
+}
+
+interface KafkaPartitionRow {
+  partition: number;
+  beginOffset: number;
+  endOffset: number;
+  messageCount: number;
+  leader: number;
+  replicas: number[];
+  isr: number[];
+}
+
+const producers = ref<ProducerInfo[]>([]);
+const subscriptions = ref<SubscriptionInfo[]>([]);
+const stats = ref<TopicStats>();
+const selectedSubscription = ref("");
+const selectedPartitionName = ref("");
+const loading = ref(false);
+const unloading = ref(false);
+const error = ref<string>();
+
+let runtimeLoadSeq = 0;
+let consumerLoadSeq = 0;
+
+const topicRef = computed<TopicRef | null>(() => {
+  if (!props.topic || !props.tenant || !props.namespace) return null;
+  return {
+    tenant: props.tenant,
+    namespace: props.namespace,
+    topic: props.topic.shortName,
+    persistent: props.topic.persistent,
+    partitioned: props.topic.partitioned,
+  };
+});
+
+const partitionRows = computed(() => extractPartitionClientRows(stats.value?.raw));
+const kafkaPartitionRows = computed(() => extractKafkaPartitionRows(stats.value?.raw));
+const isKafkaStats = computed(() => kafkaPartitionRows.value.length > 0);
+const selectedPartition = computed(() => {
+  if (!partitionRows.value.length) return undefined;
+  return partitionRows.value.find((row) => row.name === selectedPartitionName.value) ?? partitionRows.value[0];
+});
+const subscriptionOptions = computed(() => mergeSubscriptionOptions(subscriptions.value, partitionRows.value));
+const selectedPartitionSubscription = computed(() => selectedPartition.value?.subscriptions.find((sub) => sub.name === selectedSubscription.value));
+const aggregateConsumers = computed(() => subscriptions.value.find((sub) => sub.name === selectedSubscription.value)?.consumers ?? []);
+const displayedProducers = computed(() => selectedPartition.value?.producers ?? producers.value);
+const displayedConsumers = computed(() => {
+  if (selectedPartition.value) return selectedPartitionSubscription.value?.consumers ?? [];
+  return aggregateConsumers.value;
+});
+const selectedScopeLabel = computed(() => selectedPartition.value?.shortName ?? "聚合 topic");
+
+async function loadRuntimeClients() {
+  const loadSeq = ++runtimeLoadSeq;
+  consumerLoadSeq++;
+  const current = topicRef.value;
+  if (!current) {
+    producers.value = [];
+    subscriptions.value = [];
+    stats.value = undefined;
+    selectedSubscription.value = "";
+    selectedPartitionName.value = "";
+    loading.value = false;
+    error.value = undefined;
+    return;
+  }
+  const currentKey = topicRefKey(current);
+
+  loading.value = true;
+  error.value = undefined;
+  try {
+    const statsData = await mqGetTopicStats(props.connectionId, current);
+    if (!isRuntimeLoadCurrent(loadSeq, currentKey)) return;
+    stats.value = statsData;
+    const parsedProducers = extractProducersFromStats(statsData.raw);
+    producers.value = parsedProducers.length ? parsedProducers : await mqListProducers(props.connectionId, current);
+    if (!isRuntimeLoadCurrent(loadSeq, currentKey)) return;
+    const parsedSubscriptions = extractSubscriptionsFromStats(statsData.raw);
+    const partitionSubscriptions = mergeSubscriptionOptions([], extractPartitionClientRows(statsData.raw));
+    subscriptions.value = parsedSubscriptions.length || partitionSubscriptions.length ? mergeSubscriptionOptions(parsedSubscriptions, extractPartitionClientRows(statsData.raw)) : await mqListSubscriptions(props.connectionId, current);
+    if (!isRuntimeLoadCurrent(loadSeq, currentKey)) return;
+    const subscriptionChanged = syncSelectedSubscription();
+    syncSelectedPartition();
+    if (selectedSubscription.value && !subscriptionChanged && !hasConsumersForSelectedSubscription()) {
+      await loadSelectedSubscriptionConsumers({ retryIfEmpty: true });
+      if (!isRuntimeLoadCurrent(loadSeq, currentKey)) return;
+      syncSelectedPartition();
+    }
+  } catch (e: unknown) {
+    if (isRuntimeLoadCurrent(loadSeq, currentKey)) {
+      error.value = formatError(e) || String(e);
+    }
+  } finally {
+    if (loadSeq === runtimeLoadSeq) {
+      loading.value = false;
+    }
+  }
+}
+
+async function unloadTopic() {
+  const current = topicRef.value;
+  if (!current || props.readOnly || unloading.value) return;
+  if (!confirm("确认卸载当前主题？活跃生产者和消费者会重新连接。")) return;
+
+  unloading.value = true;
+  error.value = undefined;
+  try {
+    await mqUnloadTopic(props.connectionId, current);
+    await loadRuntimeClients();
+  } catch (e: unknown) {
+    error.value = formatError(e) || String(e);
+  } finally {
+    unloading.value = false;
+  }
+}
+
+function formatRate(value: number): string {
+  return `${value.toFixed(2)} msg/s`;
+}
+
+function formatBytes(value: number): string {
+  if (!value) return "0 B/s";
+  const units = ["B/s", "KB/s", "MB/s", "GB/s", "TB/s"];
+  const index = Math.min(Math.floor(Math.log(value) / Math.log(1024)), units.length - 1);
+  return `${(value / 1024 ** index).toFixed(2)} ${units[index]}`;
+}
+
+function formatOptionalRate(value: number): string {
+  return isKafkaStats.value ? "-" : formatRate(value);
+}
+
+function formatOptionalBytes(value: number): string {
+  return isKafkaStats.value ? "-" : formatBytes(value);
+}
+
+function syncSelectedSubscription(): boolean {
+  const previous = selectedSubscription.value;
+  const options = subscriptionOptions.value;
+  if (props.selectedSubscription && options.some((sub) => sub.name === props.selectedSubscription)) {
+    selectedSubscription.value = props.selectedSubscription;
+  } else if (!options.some((sub) => sub.name === selectedSubscription.value)) {
+    selectedSubscription.value = options[0]?.name ?? "";
+  }
+  return previous !== selectedSubscription.value;
+}
+
+function syncSelectedPartition() {
+  const rows = partitionRows.value;
+  if (!rows.length) {
+    selectedPartitionName.value = "";
+    return;
+  }
+  const current = rows.find((row) => row.name === selectedPartitionName.value);
+  if (current?.subscriptions.some((sub) => sub.name === selectedSubscription.value)) return;
+
+  const withActiveConsumers = rows.find((row) => row.subscriptions.some((sub) => sub.name === selectedSubscription.value && sub.consumers.length > 0));
+  const withSubscription = rows.find((row) => row.subscriptions.some((sub) => sub.name === selectedSubscription.value));
+  selectedPartitionName.value = (withActiveConsumers ?? withSubscription ?? current ?? rows[0]).name;
+}
+
+function syncSelectedSubscriptionForPartition() {
+  const partition = selectedPartition.value;
+  if (!partition) return;
+  if (selectedSubscription.value && partition.subscriptions.some((sub) => sub.name === selectedSubscription.value)) return;
+
+  const active = partition.subscriptions.find((sub) => sub.consumers.length > 0);
+  selectedSubscription.value = (active ?? partition.subscriptions[0])?.name ?? selectedSubscription.value;
+}
+
+interface LoadConsumersOptions {
+  retryIfEmpty?: boolean;
+}
+
+async function loadSelectedSubscriptionConsumers(options: LoadConsumersOptions = {}): Promise<ConsumerInfo[]> {
+  const current = topicRef.value;
+  const subscriptionName = selectedSubscription.value;
+  if (!current || !subscriptionName) return [];
+
+  const loadSeq = ++consumerLoadSeq;
+  const currentKey = topicRefKey(current);
+  let consumers = await mqListConsumers(props.connectionId, current, subscriptionName);
+  if (!isConsumerLoadCurrent(loadSeq, currentKey, subscriptionName)) return [];
+  applySubscriptionConsumers(subscriptionName, consumers);
+
+  if (options.retryIfEmpty && consumers.length === 0) {
+    await sleep(700);
+    if (!isConsumerLoadCurrent(loadSeq, currentKey, subscriptionName)) return consumers;
+    consumers = await mqListConsumers(props.connectionId, current, subscriptionName);
+    if (!isConsumerLoadCurrent(loadSeq, currentKey, subscriptionName)) return [];
+    applySubscriptionConsumers(subscriptionName, consumers);
+  }
+
+  return consumers;
+}
+
+function applySubscriptionConsumers(subscriptionName: string, consumers: ConsumerInfo[]) {
+  subscriptions.value = subscriptions.value.map((sub) => (sub.name === subscriptionName ? { ...sub, consumers } : sub));
+}
+
+function hasConsumersForSelectedSubscription(): boolean {
+  return subscriptions.value.some((sub) => sub.name === selectedSubscription.value && sub.consumers.length > 0);
+}
+
+function topicRefKey(topic: TopicRef): string {
+  return [topic.tenant, topic.namespace, topic.topic, topic.persistent ? "1" : "0", topic.partitioned ? "1" : "0"].join("|");
+}
+
+function isRuntimeLoadCurrent(loadSeq: number, topicKey: string): boolean {
+  return loadSeq === runtimeLoadSeq && isCurrentTopic(topicKey);
+}
+
+function isConsumerLoadCurrent(loadSeq: number, topicKey: string, subscriptionName: string): boolean {
+  return loadSeq === consumerLoadSeq && selectedSubscription.value === subscriptionName && isCurrentTopic(topicKey);
+}
+
+function isCurrentTopic(topicKey: string): boolean {
+  const current = topicRef.value;
+  return !!current && topicRefKey(current) === topicKey;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function extractProducersFromStats(raw: unknown): ProducerInfo[] {
+  const root = objectRecord(raw);
+  const producers = arrayObjects(root.publishers).map(parseProducer);
+  for (const partition of extractPartitionClientRows(raw)) {
+    producers.push(...partition.producers);
+  }
+  return producers;
+}
+
+function extractSubscriptionsFromStats(raw: unknown): SubscriptionInfo[] {
+  return Object.entries(objectRecord(objectRecord(raw).subscriptions)).map(([name, body]) => parseSubscription(name, body));
+}
+
+function extractPartitionClientRows(raw: unknown): PartitionClientRow[] {
+  return Object.entries(objectRecord(objectRecord(raw).partitions)).map(([name, value]) => {
+    const body = objectRecord(value);
+    const partitionSubscriptions = Object.entries(objectRecord(body.subscriptions)).map(([subscriptionName, subscriptionBody]) => parseSubscription(subscriptionName, subscriptionBody));
+    const partitionProducers = arrayObjects(body.publishers).map(parseProducer);
+    return {
+      name,
+      shortName: partitionShortName(name),
+      msgRateIn: numberField(body.msgRateIn) ?? 0,
+      msgRateOut: numberField(body.msgRateOut) ?? 0,
+      producerCount: partitionProducers.length,
+      subscriptionCount: partitionSubscriptions.length,
+      consumerCount: partitionSubscriptions.reduce((sum, sub) => sum + sub.consumers.length, 0),
+      producers: partitionProducers,
+      subscriptions: partitionSubscriptions,
+    };
+  });
+}
+
+function extractKafkaPartitionRows(raw: unknown): KafkaPartitionRow[] {
+  return arrayObjects(objectRecord(raw).partitionStats)
+    .map((body) => ({
+      partition: numberField(body.partition) ?? 0,
+      beginOffset: numberField(body.beginOffset) ?? 0,
+      endOffset: numberField(body.endOffset) ?? 0,
+      messageCount: numberField(body.messageCount) ?? 0,
+      leader: numberField(body.leader) ?? -1,
+      replicas: numberArrayField(body.replicas),
+      isr: numberArrayField(body.isr),
+    }))
+    .sort((a, b) => a.partition - b.partition);
+}
+
+function mergeSubscriptionOptions(base: SubscriptionInfo[], partitions: PartitionClientRow[]): SubscriptionInfo[] {
+  const byName = new Map<string, SubscriptionInfo>();
+  for (const sub of base) {
+    byName.set(sub.name, { ...sub, consumers: [...sub.consumers] });
+  }
+  for (const partition of partitions) {
+    for (const sub of partition.subscriptions) {
+      const existing = byName.get(sub.name);
+      if (!existing) {
+        byName.set(sub.name, { ...sub, consumers: [...sub.consumers] });
+        continue;
+      }
+      existing.msgBacklog = Math.max(existing.msgBacklog, sub.msgBacklog);
+      existing.msgRateOut = Math.max(existing.msgRateOut, sub.msgRateOut);
+      existing.msgThroughputOut = Math.max(existing.msgThroughputOut, sub.msgThroughputOut);
+      existing.consumers = [...existing.consumers, ...sub.consumers];
+      if (!existing.subType && sub.subType) existing.subType = sub.subType;
+    }
+  }
+  return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+function parseSubscription(name: string, value: unknown): SubscriptionInfo {
+  const body = objectRecord(value);
+  return {
+    name,
+    subType: stringField(body.type),
+    msgBacklog: numberField(body.msgBacklog) ?? 0,
+    msgRateOut: numberField(body.msgRateOut) ?? 0,
+    msgThroughputOut: numberField(body.msgThroughputOut) ?? 0,
+    consumers: arrayObjects(body.consumers).map(parseConsumer),
+  };
+}
+
+function parseProducer(value: unknown): ProducerInfo {
+  const body = objectRecord(value);
+  return {
+    producerId: numberField(body.producerId) ?? 0,
+    producerName: stringField(body.producerName),
+    msgRateIn: numberField(body.msgRateIn) ?? 0,
+    msgThroughputIn: numberField(body.msgThroughputIn) ?? 0,
+    address: stringField(body.address),
+    clientVersion: stringField(body.clientVersion),
+  };
+}
+
+function parseConsumer(value: unknown): ConsumerInfo {
+  const body = objectRecord(value);
+  return {
+    consumerName: stringField(body.consumerName),
+    msgRateOut: numberField(body.msgRateOut) ?? 0,
+    msgThroughputOut: numberField(body.msgThroughputOut) ?? 0,
+    availablePermits: numberField(body.availablePermits) ?? 0,
+    address: stringField(body.address),
+    clientVersion: stringField(body.clientVersion),
+  };
+}
+
+function partitionShortName(name: string): string {
+  const path = name.includes("://") ? name.split("://", 2)[1] || name : name;
+  return path.split("/").slice(-1)[0] || name;
+}
+
+function objectRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+function arrayObjects(value: unknown): Record<string, unknown>[] {
+  return Array.isArray(value) ? value.filter((item): item is Record<string, unknown> => !!item && typeof item === "object" && !Array.isArray(item)) : [];
+}
+
+function numberField(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return undefined;
+}
+
+function numberArrayField(value: unknown): number[] {
+  return Array.isArray(value) ? value.map(numberField).filter((item): item is number => item !== undefined) : [];
+}
+
+function stringField(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+watch(
+  () => [props.connectionId, props.topic?.name, props.topic?.partitioned, props.tenant, props.namespace],
+  () => {
+    void loadRuntimeClients();
+  },
+  { immediate: true },
+);
+
+watch(selectedSubscription, () => {
+  syncSelectedPartition();
+  void loadSelectedSubscriptionConsumers({ retryIfEmpty: true }).catch((e: unknown) => {
+    error.value = formatError(e) || String(e);
+  });
+});
+
+watch(selectedPartitionName, () => {
+  syncSelectedSubscriptionForPartition();
+});
+
+watch(
+  () => props.selectedSubscription,
+  (subscription) => {
+    if (subscription && subscriptionOptions.value.some((sub) => sub.name === subscription)) {
+      selectedSubscription.value = subscription;
+    }
+  },
+);
+</script>
+
+<template>
+  <div class="producer-consumer-panel">
+    <div class="panel-toolbar">
+      <h3>生产者 / 消费者</h3>
+      <div class="toolbar-actions">
+        <button v-if="!isKafkaCluster" class="btn-sm danger" :disabled="readOnly || !topic || unloading" @click="unloadTopic">
+          {{ unloading ? "卸载中..." : "卸载主题" }}
+        </button>
+        <button class="btn-sm" :disabled="loading || !topic" @click="loadRuntimeClients">
+          {{ loading ? "刷新中..." : "刷新" }}
+        </button>
+      </div>
+    </div>
+
+    <div v-if="!topic" class="panel-placeholder">请先选择一个 topic</div>
+    <div v-else-if="error" class="panel-error">{{ error }}</div>
+
+    <div v-else class="runtime-content">
+      <section v-if="isKafkaStats" class="runtime-section">
+        <div class="section-heading">
+          <h4>Kafka 分区状态</h4>
+          <span>{{ kafkaPartitionRows.length }} 个分区</span>
+        </div>
+        <table class="runtime-table partition-table">
+          <thead>
+            <tr>
+              <th>分区</th>
+              <th>起始 offset</th>
+              <th>最新 offset</th>
+              <th>消息数</th>
+              <th>Leader</th>
+              <th>Replicas</th>
+              <th>ISR</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="partition in kafkaPartitionRows" :key="partition.partition">
+              <td>{{ partition.partition }}</td>
+              <td>{{ partition.beginOffset }}</td>
+              <td>{{ partition.endOffset }}</td>
+              <td>{{ partition.messageCount }}</td>
+              <td>{{ partition.leader }}</td>
+              <td>{{ partition.replicas.join(", ") || "-" }}</td>
+              <td>{{ partition.isr.join(", ") || "-" }}</td>
+            </tr>
+          </tbody>
+        </table>
+      </section>
+
+      <section v-else-if="partitionRows.length" class="runtime-section">
+        <div class="section-heading">
+          <h4>分区客户端</h4>
+          <span>{{ partitionRows.length }} 个分区</span>
+        </div>
+        <table class="runtime-table partition-table">
+          <thead>
+            <tr>
+              <th>分区</th>
+              <th>入站速率</th>
+              <th>出站速率</th>
+              <th>生产者</th>
+              <th>订阅</th>
+              <th>消费者</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="partition in partitionRows" :key="partition.name" :class="{ selected: selectedPartition?.name === partition.name }" @click="selectedPartitionName = partition.name">
+              <td :title="partition.name">{{ partition.shortName }}</td>
+              <td>{{ formatRate(partition.msgRateIn) }}</td>
+              <td>{{ formatRate(partition.msgRateOut) }}</td>
+              <td>{{ partition.producerCount }}</td>
+              <td>{{ partition.subscriptionCount }}</td>
+              <td>{{ partition.consumerCount }}</td>
+            </tr>
+          </tbody>
+        </table>
+      </section>
+
+      <section class="runtime-section">
+        <div class="section-heading">
+          <h4>活跃生产者</h4>
+          <div class="heading-meta">
+            <span v-if="selectedPartition" class="scope-chip">{{ selectedScopeLabel }}</span>
+            <span>{{ displayedProducers.length }}</span>
+          </div>
+        </div>
+        <div v-if="!displayedProducers.length && !loading" class="empty-state">当前没有活跃生产者</div>
+        <table v-else class="runtime-table">
+          <thead>
+            <tr>
+              <th>名称</th>
+              <th>ID</th>
+              <th>地址</th>
+              <th>版本</th>
+              <th>速率</th>
+              <th>吞吐</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="producer in displayedProducers" :key="`${selectedScopeLabel}-${producer.producerId}-${producer.producerName}`">
+              <td>{{ producer.producerName || "-" }}</td>
+              <td>{{ producer.producerId }}</td>
+              <td>{{ producer.address || "-" }}</td>
+              <td>{{ producer.clientVersion || "-" }}</td>
+              <td>{{ formatOptionalRate(producer.msgRateIn) }}</td>
+              <td>{{ formatOptionalBytes(producer.msgThroughputIn) }}</td>
+            </tr>
+          </tbody>
+        </table>
+      </section>
+
+      <section class="runtime-section">
+        <div class="section-heading">
+          <h4>活跃消费者</h4>
+          <div class="subscription-selector">
+            <span v-if="selectedPartition" class="scope-chip">{{ selectedScopeLabel }}</span>
+            <span>{{ displayedConsumers.length }}</span>
+            <select v-if="!isKafkaStats && partitionRows.length" v-model="selectedPartitionName" :disabled="loading">
+              <option v-for="partition in partitionRows" :key="partition.name" :value="partition.name">{{ partition.shortName }}</option>
+            </select>
+            <select v-model="selectedSubscription" :disabled="loading || !subscriptionOptions.length">
+              <option v-for="sub in subscriptionOptions" :key="sub.name" :value="sub.name">{{ sub.name }}</option>
+            </select>
+          </div>
+        </div>
+        <div v-if="!subscriptionOptions.length && !loading" class="empty-state">当前 topic 没有订阅</div>
+        <div v-else-if="!displayedConsumers.length && !loading" class="empty-state">
+          {{ selectedPartition ? "当前分区订阅没有活跃消费者" : "当前订阅没有活跃消费者" }}
+        </div>
+        <table v-else class="runtime-table">
+          <thead>
+            <tr>
+              <th>名称</th>
+              <th>地址</th>
+              <th>版本</th>
+              <th>速率</th>
+              <th>吞吐</th>
+              <th>Permits</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="consumer in displayedConsumers" :key="`${selectedScopeLabel}-${selectedSubscription}-${consumer.consumerName}-${consumer.address}`">
+              <td>{{ consumer.consumerName || "-" }}</td>
+              <td>{{ consumer.address || "-" }}</td>
+              <td>{{ consumer.clientVersion || "-" }}</td>
+              <td>{{ formatOptionalRate(consumer.msgRateOut) }}</td>
+              <td>{{ formatOptionalBytes(consumer.msgThroughputOut) }}</td>
+              <td>{{ consumer.availablePermits }}</td>
+            </tr>
+          </tbody>
+        </table>
+      </section>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.producer-consumer-panel {
+  display: flex;
+  flex-direction: column;
+  height: 100%;
+}
+
+.panel-toolbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.panel-toolbar h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.toolbar-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.btn-sm {
+  padding: 6px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: 13px;
+}
+
+.btn-sm:hover:not(:disabled) {
+  background: var(--color-hover);
+}
+
+.btn-sm.danger {
+  border-color: var(--color-error);
+  color: var(--color-error);
+}
+
+.btn-sm:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.runtime-content {
+  flex: 1;
+  overflow-y: auto;
+  padding: 16px;
+}
+
+.runtime-section {
+  margin-bottom: 24px;
+}
+
+.section-heading {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-bottom: 10px;
+}
+
+.section-heading h4 {
+  margin: 0;
+  font-size: 14px;
+  font-weight: 600;
+  color: var(--color-text-secondary);
+}
+
+.section-heading span {
+  color: var(--color-text-tertiary);
+  font-size: 13px;
+}
+
+.heading-meta {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.scope-chip {
+  max-width: 260px;
+  display: inline-flex;
+  align-items: center;
+  min-height: 24px;
+  padding: 2px 8px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background-secondary);
+  color: var(--color-text-secondary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.subscription-selector {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.subscription-selector select {
+  min-width: 180px;
+  max-width: 320px;
+  height: 30px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  font-size: 13px;
+}
+
+.runtime-table {
+  width: 100%;
+  border-collapse: collapse;
+  border: 1px solid var(--color-border);
+  font-size: 13px;
+}
+
+.runtime-table th,
+.runtime-table td {
+  padding: 9px 10px;
+  border-bottom: 1px solid var(--color-border);
+  text-align: left;
+  vertical-align: top;
+}
+
+.runtime-table th {
+  background: var(--color-background-secondary);
+  color: var(--color-text-secondary);
+  font-weight: 600;
+}
+
+.runtime-table td {
+  color: var(--color-text);
+  word-break: break-word;
+}
+
+.partition-table tbody tr {
+  cursor: pointer;
+}
+
+.partition-table tbody tr:hover,
+.partition-table tbody tr.selected {
+  background: var(--color-hover);
+}
+
+.partition-table tbody tr.selected td:first-child {
+  color: var(--color-primary);
+  font-weight: 600;
+}
+
+.empty-state,
+.panel-placeholder,
+.panel-error {
+  padding: 24px;
+  text-align: center;
+  color: var(--color-text-secondary);
+}
+
+.panel-error {
+  color: var(--color-error);
+}
+</style>
diff --git a/apps/desktop/src/components/mq/README.md b/apps/desktop/src/components/mq/README.md
new file mode 100644
index 0000000..859f88b
--- /dev/null
+++ b/apps/desktop/src/components/mq/README.md
@@ -0,0 +1,30 @@
+# Message Queue Admin Components
+
+消息队列管理 UI 组件集。
+
+## 组件列表
+
+- **MqAdminConsole.vue** - 主控制台框架
+- **TenantsPanel.vue** - 租户管理
+- **NamespacesPanel.vue** - 命名空间管理
+- **TopicsPanel.vue** - 主题管理
+- **SubscriptionsPanel.vue** - 订阅管理
+- **MonitoringPanel.vue** - 监控统计
+
+## 使用方式
+
+```vue
+<template>
+  <MqAdminConsole :connection-id="connectionId" />
+</template>
+
+<script setup lang="ts">
+import MqAdminConsole from '@/components/mq/MqAdminConsole.vue'
+
+const connectionId = 'your-mq-connection-id'
+</script>
+```
+
+## 文档
+
+完整文档请参考：`docs/mq-index.md`
diff --git a/apps/desktop/src/components/mq/RawApiPanel.vue b/apps/desktop/src/components/mq/RawApiPanel.vue
new file mode 100644
index 0000000..e8e75d1
--- /dev/null
+++ b/apps/desktop/src/components/mq/RawApiPanel.vue
@@ -0,0 +1,554 @@
+<script setup lang="ts">
+import { formatError } from "@/lib/backend/errorUtils";
+import { computed, ref } from "vue";
+import type { MqRawResponse, TopicInfo } from "@/types/mq";
+import { mqRawRequest } from "@/lib/backend/api";
+import { safeJsonFormat } from "@/lib/common/safeJsonFormat";
+
+interface Props {
+  connectionId: string;
+  tenant?: string;
+  namespace?: string;
+  topic?: TopicInfo;
+  readOnly?: boolean;
+}
+
+const props = defineProps<Props>();
+
+const methods = ["GET", "HEAD", "OPTIONS", "POST", "PUT", "PATCH", "DELETE"];
+type RawApiPreset = {
+  label: string;
+  description: string;
+  method: string;
+  path: string;
+  query?: Record<string, string>;
+  body?: unknown;
+  unavailable?: boolean;
+};
+
+const method = ref("GET");
+const path = ref("/admin/v2/");
+const queryText = ref("");
+const bodyText = ref("");
+const response = ref<MqRawResponse>();
+const loading = ref(false);
+const error = ref<string>();
+const presetsCollapsed = ref(true);
+const readOnlyMessage = "当前连接为只读模式，不能执行写操作";
+
+const isReadMethod = computed(() => method.value === "GET" || method.value === "HEAD" || method.value === "OPTIONS");
+const requestDisabled = computed(() => loading.value || (props.readOnly && !isReadMethod.value));
+const formattedBody = computed(() => JSON.stringify(response.value?.body ?? null, null, 2));
+const bodyTextareaRows = computed(() => Math.min(24, Math.max(8, bodyText.value.split(/\r?\n/).length + 1)));
+const topicDomain = computed(() => (props.topic?.persistent === false ? "non-persistent" : "persistent"));
+const topicPath = computed(() => {
+  if (!props.tenant || !props.namespace || !props.topic) return undefined;
+  return `/admin/v2/${topicDomain.value}/${pathSegment(props.tenant)}/${pathSegment(props.namespace)}/${pathSegment(props.topic.shortName)}`;
+});
+const namespacePath = computed(() => {
+  if (!props.tenant || !props.namespace) return undefined;
+  return `/admin/v2/namespaces/${pathSegment(props.tenant)}/${pathSegment(props.namespace)}`;
+});
+const tenantPath = computed(() => {
+  if (!props.tenant) return undefined;
+  return `/admin/v2/tenants/${pathSegment(props.tenant)}`;
+});
+const presets = computed<RawApiPreset[]>(() => {
+  const tenant = tenantPath.value;
+  const namespace = namespacePath.value;
+  const topic = topicPath.value;
+  return [
+    {
+      label: "Broker 版本",
+      description: "查看 broker 暴露的版本字符串",
+      method: "GET",
+      path: "/admin/v2/brokers/version",
+    },
+    {
+      label: "集群列表",
+      description: "列出 Pulsar 已配置的 clusters",
+      method: "GET",
+      path: "/admin/v2/clusters",
+    },
+    {
+      label: "租户详情",
+      description: "查看 adminRoles / allowedClusters",
+      method: "GET",
+      path: tenant ?? "/admin/v2/tenants/{tenant}",
+      unavailable: !tenant,
+    },
+    {
+      label: "命名空间策略",
+      description: "查看 namespace policies 原始结构",
+      method: "GET",
+      path: namespace ?? "/admin/v2/namespaces/{tenant}/{namespace}",
+      unavailable: !namespace,
+    },
+    {
+      label: "Bundle 列表",
+      description: "查看 namespace bundle 分布",
+      method: "GET",
+      path: namespace ? `${namespace}/bundles` : "/admin/v2/namespaces/{tenant}/{namespace}/bundles",
+      unavailable: !namespace,
+    },
+    {
+      label: "Topic 内部状态",
+      description: "查看 ledger / cursor / backlog 细节",
+      method: "GET",
+      path: topic ? `${topic}/internalStats` : "/admin/v2/persistent/{tenant}/{namespace}/{topic}/internalStats",
+      unavailable: !topic,
+    },
+    {
+      label: "分区明细指标",
+      description: "按分区返回速率、生产者和消费者指标",
+      method: "GET",
+      path: topic ? `${topic}/partitioned-stats` : "/admin/v2/persistent/{tenant}/{namespace}/{topic}/partitioned-stats",
+      query: { perPartition: "true" },
+      unavailable: !topic,
+    },
+    {
+      label: "Schema 最新版本",
+      description: "查看 topic 当前 schema 定义",
+      method: "GET",
+      path: props.tenant && props.namespace && props.topic ? `/admin/v2/schemas/${pathSegment(props.tenant)}/${pathSegment(props.namespace)}/${pathSegment(props.topic.shortName)}/schema` : "/admin/v2/schemas/{tenant}/{namespace}/{topic}/schema",
+      unavailable: !topic,
+    },
+  ];
+});
+
+function pathSegment(value: string) {
+  return encodeURIComponent(value);
+}
+
+function parseQuery() {
+  const query: Record<string, string> = {};
+  for (const rawLine of queryText.value.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const separator = line.indexOf("=");
+    if (separator === -1) {
+      query[line] = "";
+      continue;
+    }
+    query[line.slice(0, separator).trim()] = line.slice(separator + 1).trim();
+  }
+  return Object.keys(query).length ? query : undefined;
+}
+
+function parseBody() {
+  const text = bodyText.value.trim();
+  if (!text) return undefined;
+  return JSON.parse(text);
+}
+
+function formatQuery(query?: Record<string, string>) {
+  return query
+    ? Object.entries(query)
+        .map(([key, value]) => `${key}=${value}`)
+        .join("\n")
+    : "";
+}
+
+function formatBody(body?: unknown) {
+  return body === undefined ? "" : JSON.stringify(body, null, 2);
+}
+
+function formatJsonBody() {
+  const text = bodyText.value.trim();
+  if (!text) return;
+  try {
+    bodyText.value = safeJsonFormat(text, 2);
+    error.value = undefined;
+  } catch (e: unknown) {
+    error.value = `JSON Body 格式错误: ${formatError(e)}`;
+  }
+}
+
+function applyPreset(preset: RawApiPreset) {
+  if (preset.unavailable) return;
+  method.value = preset.method;
+  path.value = preset.path;
+  queryText.value = formatQuery(preset.query);
+  bodyText.value = formatBody(preset.body);
+  response.value = undefined;
+  error.value = undefined;
+}
+
+async function executeRequest() {
+  error.value = undefined;
+  response.value = undefined;
+
+  if (props.readOnly && !isReadMethod.value) {
+    error.value = readOnlyMessage;
+    return;
+  }
+  if (!path.value.trim()) {
+    error.value = "请输入请求路径";
+    return;
+  }
+
+  loading.value = true;
+  try {
+    response.value = await mqRawRequest(props.connectionId, {
+      method: method.value,
+      path: path.value.trim(),
+      query: parseQuery(),
+      body: isReadMethod.value ? undefined : parseBody(),
+    });
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+</script>
+
+<template>
+  <div class="raw-api-panel">
+    <div class="panel-toolbar">
+      <h3>Raw API</h3>
+      <button @click="executeRequest" :disabled="requestDisabled" class="btn-primary">
+        {{ loading ? "请求中..." : "发送请求" }}
+      </button>
+    </div>
+
+    <div class="raw-content">
+      <div v-if="readOnly" class="readonly-hint">当前连接为只读模式，仅允许 GET、HEAD 和 OPTIONS 请求。</div>
+      <div v-if="error" class="panel-error">{{ error }}</div>
+
+      <section class="preset-panel" :class="{ collapsed: presetsCollapsed }">
+        <button type="button" class="preset-header" @click="presetsCollapsed = !presetsCollapsed">
+          <h4>常用端点</h4>
+          <span>按当前选择填充请求</span>
+          <span class="preset-toggle">{{ presetsCollapsed ? "展开" : "收起" }}</span>
+        </button>
+        <div v-if="!presetsCollapsed" class="preset-grid">
+          <button v-for="preset in presets" :key="preset.label" type="button" class="preset-button" :disabled="preset.unavailable" @click="applyPreset(preset)">
+            <span class="preset-method">{{ preset.method }}</span>
+            <span class="preset-copy">
+              <strong>{{ preset.label }}</strong>
+              <small>{{ preset.description }}</small>
+            </span>
+          </button>
+        </div>
+      </section>
+
+      <section class="request-panel">
+        <div class="request-line">
+          <label>
+            方法
+            <select v-model="method">
+              <option v-for="item in methods" :key="item" :value="item">{{ item }}</option>
+            </select>
+          </label>
+          <label class="path-field">
+            路径
+            <input v-model="path" type="text" placeholder="/admin/v2/..." />
+          </label>
+        </div>
+
+        <label>
+          查询参数
+          <textarea v-model="queryText" rows="4" placeholder="key=value，每行一个"></textarea>
+        </label>
+
+        <label>
+          <span class="field-header">
+            <span>JSON Body</span>
+            <button type="button" class="btn-secondary compact" :disabled="isReadMethod || !bodyText.trim()" @click="formatJsonBody">格式化</button>
+          </span>
+          <textarea v-model="bodyText" class="json-body-textarea" :rows="bodyTextareaRows" placeholder='例如: {"key":"value"}' :disabled="isReadMethod"></textarea>
+        </label>
+      </section>
+
+      <section class="response-panel">
+        <h4>响应</h4>
+        <div v-if="response" class="response-meta">
+          <span>HTTP {{ response.status }}</span>
+          <span v-if="response.text">文本响应</span>
+        </div>
+        <pre v-if="response">{{ response.text || formattedBody }}</pre>
+        <div v-else class="empty-state">尚未发送请求</div>
+      </section>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.raw-api-panel {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.panel-toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.panel-toolbar h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.raw-content {
+  flex: 1;
+  overflow: auto;
+  padding: 16px;
+}
+
+.request-panel,
+.preset-panel,
+.response-panel {
+  padding: 14px;
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-background-secondary);
+}
+
+.request-panel {
+  margin-top: 16px;
+}
+
+.response-panel {
+  margin-top: 16px;
+}
+
+.preset-header {
+  display: flex;
+  width: 100%;
+  gap: 12px;
+  align-items: center;
+  margin: 0;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: var(--color-text);
+  text-align: left;
+  cursor: pointer;
+}
+
+.preset-panel:not(.collapsed) .preset-header {
+  margin-bottom: 12px;
+}
+
+.preset-header h4 {
+  margin: 0;
+}
+
+.preset-header span {
+  color: var(--color-text-secondary);
+  font-size: 12px;
+}
+
+.preset-header span:nth-child(2) {
+  margin-left: auto;
+}
+
+.preset-toggle {
+  color: var(--color-primary) !important;
+  font-size: 12px;
+}
+
+.preset-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(210px, 1fr));
+  gap: 8px;
+}
+
+.preset-button {
+  display: grid;
+  grid-template-columns: 48px minmax(0, 1fr);
+  gap: 10px;
+  align-items: start;
+  min-height: 58px;
+  padding: 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: var(--color-background);
+  color: var(--color-text);
+  text-align: left;
+  cursor: pointer;
+}
+
+.preset-button:hover:not(:disabled) {
+  border-color: var(--color-primary);
+}
+
+.preset-method {
+  display: inline-flex;
+  justify-content: center;
+  padding: 2px 6px;
+  border-radius: 4px;
+  background: var(--color-primary-alpha);
+  color: var(--color-primary);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+  font-size: 11px;
+  font-weight: 600;
+}
+
+.preset-copy {
+  display: flex;
+  min-width: 0;
+  flex-direction: column;
+  gap: 3px;
+}
+
+.preset-copy strong {
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.preset-copy small {
+  color: var(--color-text-secondary);
+  font-size: 12px;
+  line-height: 1.35;
+}
+
+.request-line {
+  display: grid;
+  grid-template-columns: 140px minmax(260px, 1fr);
+  gap: 12px;
+}
+
+label {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  margin-bottom: 12px;
+  color: var(--color-text-secondary);
+  font-size: 13px;
+}
+
+.field-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+}
+
+input,
+select,
+textarea {
+  width: 100%;
+  padding: 8px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  box-sizing: border-box;
+  font: inherit;
+}
+
+textarea,
+pre {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+  font-size: 12px;
+}
+
+textarea {
+  resize: vertical;
+}
+
+.json-body-textarea {
+  min-height: 180px;
+  max-height: 56vh;
+}
+
+textarea:disabled {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+h4 {
+  margin: 0 0 12px;
+  font-size: 14px;
+  font-weight: 600;
+}
+
+.response-meta {
+  display: flex;
+  gap: 8px;
+  margin-bottom: 8px;
+  color: var(--color-text-secondary);
+  font-size: 12px;
+}
+
+pre {
+  margin: 0;
+  padding: 12px;
+  max-height: 420px;
+  overflow: auto;
+  border-radius: 6px;
+  background: var(--color-background);
+  color: var(--color-text);
+}
+
+.empty-state {
+  padding: 24px;
+  color: var(--color-text-secondary);
+  text-align: center;
+}
+
+.panel-error,
+.readonly-hint {
+  padding: 12px 16px;
+  margin-bottom: 12px;
+  border-radius: 6px;
+  font-size: 13px;
+}
+
+.panel-error {
+  background: var(--color-error-bg);
+  color: var(--color-error);
+}
+
+.readonly-hint {
+  background: var(--color-warning-alpha);
+  color: var(--color-warning);
+}
+
+.btn-primary {
+  padding: 6px 12px;
+  border: 1px solid var(--color-primary);
+  border-radius: 4px;
+  background: var(--color-primary);
+  color: white;
+  cursor: pointer;
+  font-size: 13px;
+}
+
+.btn-secondary {
+  padding: 5px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: 12px;
+}
+
+.btn-secondary:hover:not(:disabled) {
+  border-color: var(--color-primary);
+  color: var(--color-primary);
+}
+
+.btn-secondary.compact {
+  padding: 3px 8px;
+}
+
+button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+@media (max-width: 700px) {
+  .request-line {
+    grid-template-columns: 1fr;
+  }
+}
+</style>
diff --git a/apps/desktop/src/components/mq/SendMessagePanel.vue b/apps/desktop/src/components/mq/SendMessagePanel.vue
new file mode 100644
index 0000000..2fae77e
--- /dev/null
+++ b/apps/desktop/src/components/mq/SendMessagePanel.vue
@@ -0,0 +1,760 @@
+<script setup lang="ts">
+import { computed, onUnmounted, ref, watch } from "vue";
+import type { PeekedMessage, TopicInfo, TopicRef, SendMessageRequest, SendMessageResponse } from "@/types/mq";
+import { mqSendMessage, mqListTopics, mqPeekMessages } from "@/lib/backend/api";
+import { formatError } from "@/lib/backend/errorUtils";
+
+interface Props {
+  connectionId: string;
+  tenant?: string;
+  namespace?: string;
+  topic?: TopicInfo;
+  readOnly?: boolean;
+  isKafkaCluster?: boolean;
+  supportsPeekMessages?: boolean;
+}
+
+const props = defineProps<Props>();
+
+const topicName = ref("");
+const messageKey = ref("");
+const messageValue = ref("");
+const headersText = ref("");
+const loading = ref(false);
+const error = ref<string>();
+const success = ref<SendMessageResponse>();
+const availableTopics = ref<TopicInfo[]>([]);
+const topicsLoading = ref(false);
+const headersExpanded = ref(false);
+const peekLoading = ref(false);
+const peekError = ref<string>();
+const peekMessages = ref<PeekedMessage[]>([]);
+const peekPartition = ref(0);
+const peekOffset = ref(0);
+const peekCount = ref(20);
+
+let successTimer: ReturnType<typeof setTimeout> | undefined;
+
+const readOnlyMessage = "当前连接为只读模式，不能发送消息";
+
+const topicOptions = computed(() => {
+  return availableTopics.value.map((t) => ({
+    value: t.shortName,
+    label: t.shortName,
+    partitions: t.partitions,
+  }));
+});
+
+const selectedTopicRef = computed<TopicRef | null>(() => {
+  const topic = topicName.value.trim();
+  if (!topic || !props.tenant || !props.namespace) return null;
+  const selected = availableTopics.value.find((item) => item.shortName === topic);
+  return {
+    tenant: props.tenant,
+    namespace: props.namespace,
+    topic,
+    persistent: selected?.persistent ?? true,
+    partitioned: selected?.partitioned,
+  };
+});
+
+const canBrowseMessages = computed(() => props.isKafkaCluster === true && props.supportsPeekMessages !== false);
+const topicListId = computed(() => `mq-topic-options-${props.connectionId}`);
+
+function clearSuccessLater() {
+  if (successTimer) clearTimeout(successTimer);
+  successTimer = setTimeout(() => {
+    success.value = undefined;
+  }, 4000);
+}
+
+onUnmounted(() => {
+  if (successTimer) clearTimeout(successTimer);
+});
+
+function guardWritable() {
+  if (props.readOnly) {
+    error.value = readOnlyMessage;
+    return false;
+  }
+  return true;
+}
+
+async function loadTopics() {
+  if (!props.tenant || !props.namespace) return;
+  topicsLoading.value = true;
+  try {
+    availableTopics.value = await mqListTopics(
+      props.connectionId,
+      {
+        tenant: props.tenant,
+        namespace: props.namespace,
+      },
+      { includeNonPersistent: false },
+    );
+    if (props.topic && !topicName.value) {
+      topicName.value = props.topic.shortName;
+    }
+  } catch (e: unknown) {
+    console.warn("Failed to load topics:", e);
+  } finally {
+    topicsLoading.value = false;
+  }
+}
+
+function parseHeaders(): Record<string, string> {
+  const result: Record<string, string> = {};
+  if (!headersText.value.trim()) return result;
+  for (const line of headersText.value.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.includes(":")) continue;
+    const colonIndex = trimmed.indexOf(":");
+    const key = trimmed.slice(0, colonIndex).trim();
+    const value = trimmed.slice(colonIndex + 1).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+
+async function sendMessage() {
+  if (!guardWritable()) return;
+  error.value = undefined;
+  success.value = undefined;
+
+  const topic = topicName.value.trim();
+  if (!topic) {
+    error.value = "请选择目标主题";
+    return;
+  }
+  if (!messageValue.value) {
+    error.value = "消息内容不能为空";
+    return;
+  }
+
+  loading.value = true;
+  try {
+    const headers = parseHeaders();
+    const payloadBase64 = btoa(unescape(encodeURIComponent(messageValue.value)));
+    const req: SendMessageRequest = {
+      topic,
+      key: messageKey.value.trim() || undefined,
+      payloadBase64,
+      payloadText: messageValue.value,
+      headers,
+    };
+    success.value = await mqSendMessage(props.connectionId, req);
+    if (canBrowseMessages.value) {
+      peekPartition.value = success.value.partition;
+      peekOffset.value = success.value.offset;
+      void loadMessages();
+    }
+    messageValue.value = "";
+    messageKey.value = "";
+    clearSuccessLater();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function loadMessages() {
+  const topic = selectedTopicRef.value;
+  if (!topic) {
+    peekError.value = "Select a topic before loading messages";
+    return;
+  }
+  peekLoading.value = true;
+  peekError.value = undefined;
+  try {
+    const count = Math.max(1, Math.min(100, Number(peekCount.value) || 20));
+    const partition = Math.max(0, Number(peekPartition.value) || 0);
+    const offset = Math.max(0, Number(peekOffset.value) || 0);
+    peekCount.value = count;
+    peekPartition.value = partition;
+    peekOffset.value = offset;
+    peekMessages.value = await mqPeekMessages(props.connectionId, topic, "__dbx_kafka_viewer__", count, { partition, offset });
+  } catch (e: unknown) {
+    peekError.value = formatError(e);
+  } finally {
+    peekLoading.value = false;
+  }
+}
+
+function messagePayload(message: PeekedMessage): string {
+  return message.payloadText ?? message.payloadBase64;
+}
+
+function formatMessageTimestamp(value?: string): string {
+  if (!value) return "-";
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return value;
+  return new Date(numeric).toLocaleString();
+}
+
+function formatJson() {
+  try {
+    const parsed = JSON.parse(messageValue.value);
+    messageValue.value = JSON.stringify(parsed, null, 2);
+  } catch {
+    // Not valid JSON, leave as-is
+  }
+}
+
+function clearForm() {
+  topicName.value = "";
+  messageKey.value = "";
+  messageValue.value = "";
+  headersText.value = "";
+  error.value = undefined;
+  success.value = undefined;
+}
+
+watch(
+  () => [props.tenant, props.namespace],
+  () => {
+    loadTopics();
+  },
+  { immediate: true },
+);
+
+watch(topicName, () => {
+  peekError.value = undefined;
+  peekMessages.value = [];
+});
+
+watch(
+  () => props.topic,
+  (newTopic) => {
+    if (newTopic) {
+      topicName.value = newTopic.shortName;
+    }
+  },
+);
+</script>
+
+<template>
+  <div class="send-message-panel">
+    <div class="panel-toolbar">
+      <h3>发送消息</h3>
+      <button @click="clearForm" :disabled="loading" class="btn-sm">清空</button>
+    </div>
+
+    <div v-if="!tenant || !namespace" class="panel-placeholder">请先选择命名空间或主题</div>
+
+    <div v-else class="send-form">
+      <div v-if="readOnly" class="readonly-hint">{{ readOnlyMessage }}</div>
+      <div v-if="error" class="panel-error">{{ error }}</div>
+      <div v-if="success" class="panel-success">
+        <span class="success-icon">✓</span>
+        <span>消息发送成功 — 分区: {{ success.partition }}，偏移: {{ success.offset }}</span>
+      </div>
+
+      <!-- 主题选择 -->
+      <div class="form-group">
+        <label>目标主题 <span class="required">*</span></label>
+        <div class="topic-select-row">
+          <input v-model="topicName" :list="topicListId" :disabled="readOnly || topicsLoading" class="topic-input" :placeholder="topicsLoading ? '加载中...' : '输入或搜索主题...'" autocomplete="off" />
+          <datalist :id="topicListId">
+            <option v-for="t in topicOptions" :key="t.value" :value="t.value" :label="t.partitions != null ? `${t.label} (${t.partitions} 分区)` : t.label" />
+          </datalist>
+          <button @click="loadTopics" :disabled="topicsLoading" class="btn-icon" title="刷新主题列表">
+            <span v-if="topicsLoading" class="spin">⟳</span>
+            <span v-else>⟳</span>
+          </button>
+        </div>
+        <div v-if="!availableTopics.length && !topicsLoading" class="form-hint">暂无可用主题</div>
+        <div v-else class="form-hint">可输入关键词搜索，也可以直接粘贴 topic 名称。</div>
+      </div>
+
+      <!-- 消息键 -->
+      <div class="form-group">
+        <label>消息键 (Key)</label>
+        <input v-model="messageKey" type="text" placeholder="可选" :disabled="readOnly" />
+      </div>
+
+      <!-- 消息内容 -->
+      <div class="form-group">
+        <div class="label-row">
+          <label>消息内容 <span class="required">*</span></label>
+          <button @click="formatJson" :disabled="readOnly || !messageValue" class="btn-sm">格式化 JSON</button>
+        </div>
+        <textarea v-model="messageValue" :disabled="readOnly" placeholder='{"key": "value"}' rows="8" class="code-textarea" />
+      </div>
+
+      <!-- 消息头（可折叠） -->
+      <div class="form-group">
+        <button type="button" class="collapse-toggle" @click="headersExpanded = !headersExpanded">
+          <span class="collapse-arrow" :class="{ expanded: headersExpanded }">▶</span>
+          <span>消息头 (Headers)</span>
+          <span v-if="headersText.trim() && !headersExpanded" class="collapse-badge">·</span>
+        </button>
+        <div v-if="headersExpanded" class="collapse-body">
+          <textarea v-model="headersText" :disabled="readOnly" placeholder="key: value（每行一个）" rows="3" class="headers-textarea" />
+        </div>
+      </div>
+
+      <!-- 发送按钮 -->
+      <div class="form-actions">
+        <button @click="sendMessage" :disabled="loading || readOnly || !topicName || !messageValue" class="btn-primary">
+          {{ loading ? "发送中..." : "发送消息" }}
+        </button>
+      </div>
+
+      <section v-if="canBrowseMessages" class="message-browser">
+        <div class="message-browser-header">
+          <h4>消息列表</h4>
+          <button type="button" class="btn-sm" :disabled="peekLoading || !selectedTopicRef" @click="loadMessages">
+            {{ peekLoading ? "加载中..." : "加载消息" }}
+          </button>
+        </div>
+
+        <div class="peek-controls">
+          <label>
+            <span>分区</span>
+            <input v-model.number="peekPartition" type="number" min="0" :disabled="peekLoading" />
+          </label>
+          <label>
+            <span>Offset</span>
+            <input v-model.number="peekOffset" type="number" min="0" :disabled="peekLoading" />
+          </label>
+          <label>
+            <span>数量</span>
+            <input v-model.number="peekCount" type="number" min="1" max="100" :disabled="peekLoading" />
+          </label>
+        </div>
+
+        <div v-if="peekError" class="panel-error">{{ peekError }}</div>
+        <div v-else-if="peekLoading" class="message-empty">消息加载中...</div>
+        <div v-else-if="!peekMessages.length" class="message-empty">暂无消息</div>
+        <div v-else class="message-list">
+          <article v-for="message in peekMessages" :key="message.messageId || message.position" class="message-row">
+            <div class="message-meta">
+              <span>#{{ message.position }}</span>
+              <span>offset {{ message.messageId || "-" }}</span>
+              <span v-if="message.key">key {{ message.key }}</span>
+              <span>{{ formatMessageTimestamp(message.publishTime) }}</span>
+            </div>
+            <pre class="message-payload">{{ messagePayload(message) }}</pre>
+            <div v-if="Object.keys(message.headers || {}).length" class="message-headers">
+              <span v-for="(value, key) in message.headers" :key="key">{{ key }}: {{ value }}</span>
+            </div>
+          </article>
+        </div>
+      </section>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.send-message-panel {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.panel-toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.panel-toolbar h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.panel-placeholder {
+  padding: 40px 24px;
+  text-align: center;
+  color: var(--color-text-secondary);
+  font-size: 14px;
+}
+
+.send-form {
+  flex: 1;
+  overflow: auto;
+  padding: 14px 16px;
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+
+.readonly-hint {
+  padding: 10px 14px;
+  border-radius: 6px;
+  background: var(--color-warning-alpha);
+  color: var(--color-warning);
+  font-size: 13px;
+}
+
+.panel-error {
+  padding: 10px 14px;
+  border-radius: 6px;
+  background: var(--color-error-bg);
+  color: var(--color-error);
+  font-size: 13px;
+}
+
+.panel-success {
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+  padding: 14px 18px;
+  border: 1px solid color-mix(in srgb, var(--color-success) 34%, transparent);
+  border-left: 4px solid var(--color-success);
+  border-radius: 8px;
+  background: color-mix(in srgb, var(--color-success) 13%, var(--color-background));
+  color: var(--color-success);
+  font-size: 15px;
+  font-weight: 700;
+  box-shadow: 0 8px 22px rgba(0, 0, 0, 0.08);
+}
+
+.success-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 auto;
+  width: 28px;
+  height: 28px;
+  border-radius: 999px;
+  background: var(--color-success);
+  color: #fff;
+  font-size: 16px;
+  line-height: 1;
+}
+
+.panel-success span:last-child {
+  padding-top: 3px;
+  line-height: 1.45;
+}
+
+.form-group {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.label-row {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 8px;
+}
+
+.form-group label {
+  font-weight: 500;
+  font-size: 13px;
+  color: var(--color-text-secondary);
+}
+
+.required {
+  color: var(--color-error);
+}
+
+.topic-select-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.topic-input {
+  flex: 1;
+  padding: 7px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: var(--color-background);
+  color: var(--color-text);
+  font-size: 13px;
+  min-width: 0;
+}
+
+.topic-input:focus {
+  outline: none;
+  border-color: var(--color-primary);
+  box-shadow: 0 0 0 2px var(--color-primary-alpha);
+}
+
+.btn-icon {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 32px;
+  height: 32px;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: var(--color-background);
+  color: var(--color-text-secondary);
+  cursor: pointer;
+  font-size: 16px;
+  transition: all 0.15s;
+  flex-shrink: 0;
+}
+
+.btn-icon:hover:not(:disabled) {
+  background: var(--color-background-secondary);
+  color: var(--color-text);
+}
+
+.spin {
+  display: inline-block;
+  animation: spin-anim 0.8s linear infinite;
+}
+
+@keyframes spin-anim {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+input[type="text"],
+input[type="number"] {
+  padding: 7px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: var(--color-background);
+  color: var(--color-text);
+  font-size: 13px;
+  box-sizing: border-box;
+}
+
+input[type="text"]:focus,
+input[type="number"]:focus {
+  outline: none;
+  border-color: var(--color-primary);
+  box-shadow: 0 0 0 2px var(--color-primary-alpha);
+}
+
+.code-textarea,
+.headers-textarea {
+  width: 100%;
+  padding: 8px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: var(--color-background);
+  color: var(--color-text);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 13px;
+  resize: vertical;
+  box-sizing: border-box;
+  line-height: 1.5;
+}
+
+.code-textarea:focus,
+.headers-textarea:focus {
+  outline: none;
+  border-color: var(--color-primary);
+  box-shadow: 0 0 0 2px var(--color-primary-alpha);
+}
+
+.headers-textarea {
+  font-family: inherit;
+}
+
+.form-hint {
+  font-size: 12px;
+  color: var(--color-text-tertiary);
+  line-height: 1.4;
+}
+
+.collapse-toggle {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  padding: 0;
+  border: none;
+  background: none;
+  color: var(--color-text-secondary);
+  font-size: 13px;
+  font-weight: 500;
+  cursor: pointer;
+  user-select: none;
+}
+
+.collapse-arrow {
+  font-size: 10px;
+  transition: transform 0.15s;
+  display: inline-block;
+}
+
+.collapse-arrow.expanded {
+  transform: rotate(90deg);
+}
+
+.collapse-badge {
+  color: var(--color-primary);
+  font-weight: 700;
+}
+
+.collapse-body {
+  margin-top: 6px;
+}
+
+.form-actions {
+  display: flex;
+  gap: 8px;
+  padding-top: 4px;
+}
+
+.btn-primary,
+.btn-sm {
+  padding: 7px 16px;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: var(--color-background);
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: 13px;
+  transition: all 0.15s;
+}
+
+.btn-sm {
+  padding: 4px 10px;
+  font-size: 12px;
+}
+
+.btn-primary {
+  background: var(--color-primary);
+  border-color: var(--color-primary);
+  color: white;
+  font-weight: 500;
+  min-width: 100px;
+}
+
+.btn-primary:hover:not(:disabled) {
+  opacity: 0.9;
+}
+
+.message-browser {
+  margin-top: 4px;
+  padding: 14px;
+  border: 1px solid var(--color-border);
+  border-radius: 8px;
+  background: var(--color-background-secondary);
+}
+
+.message-browser-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-bottom: 12px;
+}
+
+.message-browser-header h4 {
+  margin: 0;
+  color: var(--color-text);
+  font-size: 14px;
+  font-weight: 600;
+}
+
+.peek-controls {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 10px;
+  margin-bottom: 12px;
+}
+
+.peek-controls label {
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+  color: var(--color-text-secondary);
+  font-size: 12px;
+  font-weight: 500;
+}
+
+.peek-controls input {
+  width: 100%;
+}
+
+.message-empty {
+  padding: 18px;
+  border: 1px dashed var(--color-border);
+  border-radius: 6px;
+  color: var(--color-text-tertiary);
+  text-align: center;
+  font-size: 13px;
+}
+
+.message-list {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  max-height: 360px;
+  overflow: auto;
+}
+
+.message-row {
+  padding: 10px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: var(--color-background);
+}
+
+.message-meta {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  flex-wrap: wrap;
+  color: var(--color-text-tertiary);
+  font-size: 12px;
+}
+
+.message-meta span:first-child {
+  color: var(--color-primary);
+  font-weight: 700;
+}
+
+.message-payload {
+  margin: 8px 0 0;
+  padding: 10px;
+  max-height: 160px;
+  overflow: auto;
+  border-radius: 6px;
+  background: var(--color-background-tertiary, var(--color-background-secondary));
+  color: var(--color-text);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+  font-size: 12px;
+  line-height: 1.5;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+.message-headers {
+  display: flex;
+  gap: 6px;
+  flex-wrap: wrap;
+  margin-top: 8px;
+}
+
+.message-headers span {
+  padding: 2px 6px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  color: var(--color-text-secondary);
+  background: var(--color-background-secondary);
+  font-size: 12px;
+}
+
+@media (max-width: 720px) {
+  .peek-controls {
+    grid-template-columns: 1fr;
+  }
+}
+
+button:disabled,
+input:disabled,
+textarea:disabled,
+select:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+</style>
diff --git a/apps/desktop/src/components/mq/SubscriptionsPanel.vue b/apps/desktop/src/components/mq/SubscriptionsPanel.vue
new file mode 100644
index 0000000..8e094c3
--- /dev/null
+++ b/apps/desktop/src/components/mq/SubscriptionsPanel.vue
@@ -0,0 +1,848 @@
+<script setup lang="ts">
+import { formatError } from "@/lib/backend/errorUtils";
+import { ref, watch } from "vue";
+import type { TopicRef, TopicInfo, SubscriptionInfo, ResetPosition, SkipCount, PeekedMessage } from "@/types/mq";
+import { mqListSubscriptions, mqCreateSubscription, mqDeleteSubscription, mqResetCursor, mqSkipMessages, mqClearBacklog, mqPeekMessages, mqExpireMessages } from "@/lib/backend/api";
+
+interface Props {
+  connectionId: string;
+  topic?: TopicInfo;
+  tenant?: string;
+  namespace?: string;
+  readOnly?: boolean;
+  supportsCreateSubscription?: boolean;
+  supportsResetCursor?: boolean;
+  supportsSkipMessages?: boolean;
+  supportsClearBacklog?: boolean;
+  supportsPeekMessages?: boolean;
+  supportsExpireMessages?: boolean;
+}
+
+const props = defineProps<Props>();
+const emit = defineEmits<{
+  subscriptionSelected: [subscription: string];
+}>();
+
+const subscriptions = ref<SubscriptionInfo[]>([]);
+const loading = ref(false);
+const error = ref<string>();
+const showCreateDialog = ref(false);
+const showResetDialog = ref(false);
+const showSkipDialog = ref(false);
+const showPeekDialog = ref(false);
+const showExpireDialog = ref(false);
+const selectedSub = ref<SubscriptionInfo>();
+const peekedMessages = ref<PeekedMessage[]>([]);
+const peekLoading = ref(false);
+const peekCount = ref(5);
+
+const formData = ref({
+  subName: "",
+  startFrom: "latest" as "earliest" | "latest",
+});
+
+const resetFormData = ref({
+  position: "latest" as "earliest" | "latest" | "timestamp",
+  timestampMs: Date.now(),
+});
+
+const skipFormData = ref({
+  mode: "count" as "count" | "all",
+  count: 100,
+});
+
+const expireSeconds = ref(3600);
+const readOnlyMessage = "当前连接为只读模式，不能执行写操作";
+
+function guardWritable() {
+  if (props.readOnly) {
+    error.value = readOnlyMessage;
+    return false;
+  }
+  return true;
+}
+
+function getTopicRef(): TopicRef | null {
+  if (!props.topic || !props.tenant || !props.namespace) return null;
+  return {
+    tenant: props.tenant,
+    namespace: props.namespace,
+    topic: props.topic.shortName,
+    persistent: props.topic.persistent,
+    partitioned: props.topic.partitioned,
+  };
+}
+
+async function loadSubscriptions() {
+  const topicRef = getTopicRef();
+  if (!topicRef) {
+    subscriptions.value = [];
+    return;
+  }
+  loading.value = true;
+  error.value = undefined;
+  try {
+    subscriptions.value = await mqListSubscriptions(props.connectionId, topicRef);
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function openCreateDialog() {
+  if (!guardWritable()) return;
+  formData.value = {
+    subName: "",
+    startFrom: "latest",
+  };
+  showCreateDialog.value = true;
+}
+
+function openResetDialog(sub: SubscriptionInfo) {
+  if (!guardWritable()) return;
+  selectedSub.value = sub;
+  resetFormData.value = {
+    position: "latest",
+    timestampMs: Date.now(),
+  };
+  showResetDialog.value = true;
+}
+
+function openSkipDialog(sub: SubscriptionInfo) {
+  if (!guardWritable()) return;
+  selectedSub.value = sub;
+  skipFormData.value = {
+    mode: "count",
+    count: 100,
+  };
+  showSkipDialog.value = true;
+}
+
+async function openPeekDialog(sub: SubscriptionInfo) {
+  selectedSub.value = sub;
+  peekCount.value = 5;
+  peekedMessages.value = [];
+  showPeekDialog.value = true;
+  await handlePeekMessages();
+}
+
+function openExpireDialog(sub: SubscriptionInfo) {
+  if (!guardWritable()) return;
+  selectedSub.value = sub;
+  expireSeconds.value = 3600;
+  showExpireDialog.value = true;
+}
+
+function selectSubscription(sub: SubscriptionInfo) {
+  selectedSub.value = sub;
+  emit("subscriptionSelected", sub.name);
+}
+
+async function handleCreate() {
+  if (!guardWritable()) return;
+  const topicRef = getTopicRef();
+  if (!formData.value.subName.trim() || !topicRef) {
+    error.value = "Subscription name is required";
+    return;
+  }
+  loading.value = true;
+  error.value = undefined;
+  try {
+    const pos: ResetPosition = { kind: formData.value.startFrom };
+    await mqCreateSubscription(props.connectionId, topicRef, formData.value.subName, pos);
+    showCreateDialog.value = false;
+    await loadSubscriptions();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function handleDelete(sub: SubscriptionInfo) {
+  if (!guardWritable()) return;
+  if (!confirm(`确定要删除订阅 "${sub.name}" 吗？此操作不可逆。`)) return;
+  const topicRef = getTopicRef();
+  if (!topicRef) return;
+  loading.value = true;
+  error.value = undefined;
+  try {
+    await mqDeleteSubscription(props.connectionId, topicRef, sub.name, false);
+    await loadSubscriptions();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function handleResetCursor() {
+  if (!guardWritable()) return;
+  const topicRef = getTopicRef();
+  if (!selectedSub.value || !topicRef) return;
+  loading.value = true;
+  error.value = undefined;
+  try {
+    let pos: ResetPosition;
+    if (resetFormData.value.position === "timestamp") {
+      pos = { kind: "timestamp", timestampMs: resetFormData.value.timestampMs };
+    } else {
+      pos = { kind: resetFormData.value.position };
+    }
+    await mqResetCursor(props.connectionId, topicRef, selectedSub.value.name, pos);
+    showResetDialog.value = false;
+    await loadSubscriptions();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function handleSkipMessages() {
+  if (!guardWritable()) return;
+  const topicRef = getTopicRef();
+  if (!selectedSub.value || !topicRef) return;
+  loading.value = true;
+  error.value = undefined;
+  try {
+    const count: SkipCount = skipFormData.value.mode === "all" ? { kind: "all" } : { kind: "count", count: skipFormData.value.count };
+    await mqSkipMessages(props.connectionId, topicRef, selectedSub.value.name, count);
+    showSkipDialog.value = false;
+    await loadSubscriptions();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function handleClearBacklog(sub: SubscriptionInfo) {
+  if (!guardWritable()) return;
+  if (!confirm(`确定要清空订阅 "${sub.name}" 的所有积压消息吗？`)) return;
+  const topicRef = getTopicRef();
+  if (!topicRef) return;
+  loading.value = true;
+  error.value = undefined;
+  try {
+    await mqClearBacklog(props.connectionId, topicRef, sub.name);
+    await loadSubscriptions();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function handlePeekMessages() {
+  const topicRef = getTopicRef();
+  if (!selectedSub.value || !topicRef) return;
+  const count = Math.max(1, Math.min(100, Number(peekCount.value) || 1));
+  peekCount.value = count;
+  peekLoading.value = true;
+  error.value = undefined;
+  try {
+    peekedMessages.value = await mqPeekMessages(props.connectionId, topicRef, selectedSub.value.name, count);
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    peekLoading.value = false;
+  }
+}
+
+async function handleExpireMessages() {
+  if (!guardWritable()) return;
+  const topicRef = getTopicRef();
+  if (!selectedSub.value || !topicRef) return;
+  loading.value = true;
+  error.value = undefined;
+  try {
+    await mqExpireMessages(props.connectionId, topicRef, selectedSub.value.name, expireSeconds.value);
+    showExpireDialog.value = false;
+    await loadSubscriptions();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+watch(
+  () => props.topic,
+  () => {
+    selectedSub.value = undefined;
+    loadSubscriptions();
+  },
+  { immediate: true },
+);
+</script>
+
+<template>
+  <div class="subscriptions-panel">
+    <div class="panel-toolbar">
+      <h3>订阅管理</h3>
+      <button v-if="supportsCreateSubscription !== false" @click="openCreateDialog" :disabled="loading || readOnly || !topic" class="btn-primary">+ 创建订阅</button>
+    </div>
+
+    <div v-if="!topic" class="panel-placeholder">请先选择一个主题</div>
+
+    <div v-else-if="error" class="panel-error">{{ error }}</div>
+
+    <div v-else-if="loading && !subscriptions.length" class="panel-loading">加载中...</div>
+
+    <div v-else-if="!subscriptions.length" class="panel-placeholder">该主题暂无订阅</div>
+
+    <div v-else class="subscriptions-table">
+      <table>
+        <thead>
+          <tr>
+            <th>订阅名称</th>
+            <th>类型</th>
+            <th>积压消息</th>
+            <th>消费速率</th>
+            <th>消费者</th>
+            <th>操作</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-for="sub in subscriptions" :key="sub.name" :class="{ selected: selectedSub?.name === sub.name }" @click="selectSubscription(sub)">
+            <td class="sub-name">{{ sub.name }}</td>
+            <td>
+              <span class="badge">{{ sub.subType }}</span>
+            </td>
+            <td>
+              <span :class="{ 'text-warning': sub.msgBacklog > 1000 }">
+                {{ sub.msgBacklog.toLocaleString() }}
+              </span>
+            </td>
+            <td>{{ sub.msgRateOut.toFixed(2) }} msg/s</td>
+            <td>{{ sub.consumers.length }} 个</td>
+            <td class="actions">
+              <button v-if="supportsResetCursor !== false" @click.stop="openResetDialog(sub)" :disabled="readOnly" class="btn-sm">重置游标</button>
+              <button v-if="supportsSkipMessages !== false" @click.stop="openSkipDialog(sub)" :disabled="readOnly" class="btn-sm">跳过消息</button>
+              <button v-if="supportsClearBacklog !== false" @click.stop="handleClearBacklog(sub)" :disabled="readOnly" class="btn-sm">清空积压</button>
+              <button v-if="supportsPeekMessages" @click.stop="openPeekDialog(sub)" class="btn-sm">Peek</button>
+              <button v-if="supportsExpireMessages !== false" @click.stop="openExpireDialog(sub)" :disabled="readOnly" class="btn-sm">过期消息</button>
+              <button @click.stop="handleDelete(sub)" :disabled="readOnly" class="btn-sm btn-danger">删除</button>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+
+    <!-- Create Dialog -->
+    <div v-if="showCreateDialog" class="dialog-overlay" @click="showCreateDialog = false">
+      <div class="dialog" @click.stop>
+        <div class="dialog-header">
+          <h3>创建订阅</h3>
+          <button @click="showCreateDialog = false" class="btn-close">×</button>
+        </div>
+        <div class="dialog-body">
+          <div class="form-group">
+            <label>主题</label>
+            <input type="text" :value="topic?.shortName" disabled />
+          </div>
+          <div class="form-group">
+            <label>订阅名称*</label>
+            <input v-model="formData.subName" type="text" placeholder="例如: my-subscription" :disabled="readOnly" />
+          </div>
+          <div class="form-group">
+            <label>起始位置</label>
+            <div class="radio-group">
+              <label class="radio-label">
+                <input type="radio" v-model="formData.startFrom" value="earliest" :disabled="readOnly" />
+                从最早消息开始（Earliest）
+              </label>
+              <label class="radio-label">
+                <input type="radio" v-model="formData.startFrom" value="latest" :disabled="readOnly" />
+                从最新消息开始（Latest）
+              </label>
+            </div>
+          </div>
+          <div v-if="error" class="form-error">{{ error }}</div>
+        </div>
+        <div class="dialog-footer">
+          <button @click="showCreateDialog = false" class="btn-secondary">取消</button>
+          <button @click="handleCreate" :disabled="loading || readOnly" class="btn-primary">创建</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Reset Cursor Dialog -->
+    <div v-if="showResetDialog" class="dialog-overlay" @click="showResetDialog = false">
+      <div class="dialog" @click.stop>
+        <div class="dialog-header">
+          <h3>重置游标: {{ selectedSub?.name }}</h3>
+          <button @click="showResetDialog = false" class="btn-close">×</button>
+        </div>
+        <div class="dialog-body">
+          <div class="form-group">
+            <label>重置到</label>
+            <div class="radio-group">
+              <label class="radio-label">
+                <input type="radio" v-model="resetFormData.position" value="earliest" :disabled="readOnly" />
+                最早消息（Earliest）
+              </label>
+              <label class="radio-label">
+                <input type="radio" v-model="resetFormData.position" value="latest" :disabled="readOnly" />
+                最新消息（Latest）
+              </label>
+              <label class="radio-label">
+                <input type="radio" v-model="resetFormData.position" value="timestamp" :disabled="readOnly" />
+                指定时间戳
+              </label>
+            </div>
+          </div>
+          <div v-if="resetFormData.position === 'timestamp'" class="form-group">
+            <label>时间戳（毫秒）</label>
+            <input v-model.number="resetFormData.timestampMs" type="number" :disabled="readOnly" />
+            <div class="form-hint">当前时间: {{ new Date(resetFormData.timestampMs).toLocaleString() }}</div>
+          </div>
+          <div v-if="error" class="form-error">{{ error }}</div>
+        </div>
+        <div class="dialog-footer">
+          <button @click="showResetDialog = false" class="btn-secondary">取消</button>
+          <button @click="handleResetCursor" :disabled="loading || readOnly" class="btn-primary">重置</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Skip Messages Dialog -->
+    <div v-if="showSkipDialog" class="dialog-overlay" @click="showSkipDialog = false">
+      <div class="dialog" @click.stop>
+        <div class="dialog-header">
+          <h3>跳过消息: {{ selectedSub?.name }}</h3>
+          <button @click="showSkipDialog = false" class="btn-close">×</button>
+        </div>
+        <div class="dialog-body">
+          <div class="form-group">
+            <label>跳过模式</label>
+            <div class="radio-group">
+              <label class="radio-label">
+                <input type="radio" v-model="skipFormData.mode" value="count" :disabled="readOnly" />
+                跳过指定数量
+              </label>
+              <label class="radio-label">
+                <input type="radio" v-model="skipFormData.mode" value="all" :disabled="readOnly" />
+                跳过全部积压
+              </label>
+            </div>
+          </div>
+          <div v-if="skipFormData.mode === 'count'" class="form-group">
+            <label>跳过数量</label>
+            <input v-model.number="skipFormData.count" type="number" min="1" :disabled="readOnly" />
+          </div>
+          <div v-if="error" class="form-error">{{ error }}</div>
+        </div>
+        <div class="dialog-footer">
+          <button @click="showSkipDialog = false" class="btn-secondary">取消</button>
+          <button @click="handleSkipMessages" :disabled="loading || readOnly" class="btn-primary">跳过</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Peek Messages Dialog -->
+    <div v-if="showPeekDialog" class="dialog-overlay" @click="showPeekDialog = false">
+      <div class="dialog dialog-wide" @click.stop>
+        <div class="dialog-header">
+          <h3>Peek 消息: {{ selectedSub?.name }}</h3>
+          <button @click="showPeekDialog = false" class="btn-close">×</button>
+        </div>
+        <div class="dialog-body">
+          <div class="peek-toolbar">
+            <label>
+              数量
+              <input v-model.number="peekCount" type="number" min="1" max="100" />
+            </label>
+            <button @click="handlePeekMessages" :disabled="peekLoading" class="btn-sm">
+              {{ peekLoading ? "加载中..." : "刷新" }}
+            </button>
+          </div>
+          <div v-if="error" class="form-error">{{ error }}</div>
+          <div v-else-if="peekLoading && !peekedMessages.length" class="panel-loading">加载中...</div>
+          <div v-else-if="!peekedMessages.length" class="panel-placeholder">没有可查看的消息</div>
+          <div v-else class="peek-results">
+            <div v-for="message in peekedMessages" :key="message.position" class="peek-message">
+              <div class="peek-message-header">
+                <span>#{{ message.position }}</span>
+                <span v-if="message.messageId">{{ message.messageId }}</span>
+                <span v-if="message.key">key={{ message.key }}</span>
+              </div>
+              <div v-if="Object.keys(message.properties).length" class="peek-properties">
+                <span v-for="(value, key) in message.properties" :key="key">{{ key }}={{ value }}</span>
+              </div>
+              <pre class="peek-payload">{{ message.payloadText ?? message.payloadBase64 }}</pre>
+            </div>
+          </div>
+        </div>
+        <div class="dialog-footer">
+          <button @click="showPeekDialog = false" class="btn-secondary">关闭</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Expire Messages Dialog -->
+    <div v-if="showExpireDialog" class="dialog-overlay" @click="showExpireDialog = false">
+      <div class="dialog" @click.stop>
+        <div class="dialog-header">
+          <h3>过期消息: {{ selectedSub?.name }}</h3>
+          <button @click="showExpireDialog = false" class="btn-close">×</button>
+        </div>
+        <div class="dialog-body">
+          <div class="form-group">
+            <label>过期时间（秒）</label>
+            <input v-model.number="expireSeconds" type="number" min="1" :disabled="readOnly" />
+            <div class="form-hint">将删除所有早于 {{ expireSeconds }} 秒的消息</div>
+          </div>
+          <div v-if="error" class="form-error">{{ error }}</div>
+        </div>
+        <div class="dialog-footer">
+          <button @click="showExpireDialog = false" class="btn-secondary">取消</button>
+          <button @click="handleExpireMessages" :disabled="loading || readOnly" class="btn-primary">过期</button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.subscriptions-panel {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.panel-toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.panel-toolbar h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.panel-placeholder,
+.panel-error,
+.panel-loading {
+  padding: 24px;
+  text-align: center;
+  color: var(--color-text-secondary);
+}
+
+.panel-error {
+  color: var(--color-error);
+}
+
+.subscriptions-table {
+  flex: 1;
+  overflow: auto;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+thead {
+  position: sticky;
+  top: 0;
+  background: var(--color-background-secondary);
+  z-index: 1;
+}
+
+th {
+  padding: 10px 12px;
+  text-align: left;
+  font-weight: 600;
+  font-size: 13px;
+  color: var(--color-text-secondary);
+  border-bottom: 1px solid var(--color-border);
+}
+
+tbody tr {
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+tbody tr:hover {
+  background: var(--color-hover);
+}
+
+tbody tr.selected {
+  background: var(--color-primary-alpha);
+}
+
+td {
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--color-border-light);
+}
+
+.sub-name {
+  font-weight: 500;
+}
+
+.badge {
+  display: inline-block;
+  padding: 2px 8px;
+  border-radius: 4px;
+  font-size: 11px;
+  font-weight: 500;
+  background: var(--color-background-secondary);
+  color: var(--color-text-secondary);
+}
+
+.text-warning {
+  color: var(--color-warning);
+  font-weight: 500;
+}
+
+.actions {
+  display: flex;
+  gap: 4px;
+  flex-wrap: wrap;
+}
+
+.btn-primary,
+.btn-secondary,
+.btn-sm,
+.btn-danger {
+  padding: 6px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: 13px;
+  transition: all 0.2s;
+  white-space: nowrap;
+}
+
+.btn-primary {
+  background: var(--color-primary);
+  color: white;
+  border-color: var(--color-primary);
+}
+
+.btn-primary:hover:not(:disabled) {
+  opacity: 0.9;
+}
+
+.btn-danger {
+  color: var(--color-error);
+  border-color: var(--color-error);
+}
+
+.btn-danger:hover:not(:disabled) {
+  background: var(--color-error);
+  color: white;
+}
+
+.btn-sm {
+  padding: 4px 8px;
+  font-size: 12px;
+}
+
+button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+/* Dialog styles */
+.dialog-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.5);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+}
+
+.dialog {
+  background: var(--color-background);
+  border-radius: 8px;
+  width: 90%;
+  max-width: 500px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+}
+
+.dialog-wide {
+  max-width: 760px;
+}
+
+.dialog-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 16px 20px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.dialog-header h3 {
+  margin: 0;
+  font-size: 18px;
+}
+
+.btn-close {
+  border: none;
+  background: none;
+  font-size: 24px;
+  cursor: pointer;
+  color: var(--color-text-secondary);
+  padding: 0;
+  line-height: 1;
+}
+
+.dialog-body {
+  padding: 20px;
+  max-height: 60vh;
+  overflow-y: auto;
+}
+
+.form-group {
+  margin-bottom: 16px;
+}
+
+.form-group label {
+  display: block;
+  margin-bottom: 6px;
+  font-weight: 500;
+  font-size: 13px;
+}
+
+.form-group input[type="text"],
+.form-group input[type="number"] {
+  width: 100%;
+  padding: 8px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  font-size: 14px;
+  box-sizing: border-box;
+}
+
+.form-group input:disabled {
+  background: var(--color-background-secondary);
+  color: var(--color-text-secondary);
+}
+
+.radio-group {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.radio-label {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  cursor: pointer;
+  padding: 8px;
+  border-radius: 4px;
+  transition: background 0.2s;
+}
+
+.radio-label:hover {
+  background: var(--color-hover);
+}
+
+.radio-label input[type="radio"] {
+  cursor: pointer;
+}
+
+.form-hint {
+  margin-top: 4px;
+  font-size: 12px;
+  color: var(--color-text-tertiary);
+}
+
+.form-error {
+  margin-top: 12px;
+  padding: 8px 12px;
+  background: var(--color-error-bg);
+  color: var(--color-error);
+  border-radius: 4px;
+  font-size: 13px;
+}
+
+.peek-toolbar {
+  display: flex;
+  align-items: end;
+  gap: 12px;
+  margin-bottom: 12px;
+}
+
+.peek-toolbar label {
+  display: grid;
+  gap: 6px;
+  font-size: 13px;
+}
+
+.peek-toolbar input {
+  width: 96px;
+  padding: 6px 8px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+}
+
+.peek-results {
+  display: grid;
+  gap: 12px;
+}
+
+.peek-message {
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: var(--color-background-secondary);
+  overflow: hidden;
+}
+
+.peek-message-header,
+.peek-properties {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  padding: 8px 10px;
+  font-size: 12px;
+  color: var(--color-text-secondary);
+}
+
+.peek-message-header {
+  border-bottom: 1px solid var(--color-border-light);
+  font-weight: 600;
+}
+
+.peek-properties {
+  border-bottom: 1px solid var(--color-border-light);
+}
+
+.peek-payload {
+  margin: 0;
+  max-height: 220px;
+  overflow: auto;
+  padding: 10px;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+  font-size: 12px;
+  line-height: 1.5;
+  color: var(--color-text);
+}
+
+.dialog-footer {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  padding: 16px 20px;
+  border-top: 1px solid var(--color-border);
+}
+</style>
diff --git a/apps/desktop/src/components/mq/TenantsPanel.vue b/apps/desktop/src/components/mq/TenantsPanel.vue
new file mode 100644
index 0000000..1a6f199
--- /dev/null
+++ b/apps/desktop/src/components/mq/TenantsPanel.vue
@@ -0,0 +1,760 @@
+<script setup lang="ts">
+import { formatError } from "@/lib/backend/errorUtils";
+import { computed, ref, onBeforeUnmount, onMounted, watch } from "vue";
+import type { TenantInfo, TenantConfig } from "@/types/mq";
+import { mqListTenants, mqCreateTenant, mqUpdateTenant, mqDeleteTenant } from "@/lib/backend/api";
+import { defaultTenantConfig, normalizeClusterOptions, validateTenantForm } from "@/lib/mq/mqTenantForm";
+
+interface Props {
+  connectionId: string;
+  supportsTenants: boolean;
+  readOnly?: boolean;
+  clusterOptions?: string[];
+}
+
+const props = defineProps<Props>();
+const emit = defineEmits<{
+  tenantSelected: [tenant: string];
+}>();
+
+const tenants = ref<TenantInfo[]>([]);
+const loading = ref(false);
+const error = ref<string>();
+const showCreateDialog = ref(false);
+const showEditDialog = ref(false);
+const editingTenant = ref<TenantInfo>();
+const selectedTenant = ref<string>();
+
+const formData = ref<{ name: string; config: TenantConfig }>({
+  name: "",
+  config: {
+    adminRoles: [],
+    allowedClusters: [],
+  },
+});
+
+const newRole = ref("");
+const newCluster = ref("");
+const clusterDropdownOpen = ref(false);
+const clusterSelectRef = ref<HTMLElement | null>(null);
+const readOnlyMessage = "当前连接为只读模式，不能执行写操作";
+const normalizedClusterOptions = computed(() => normalizeClusterOptions(props.clusterOptions ?? []));
+const clusterOptionSet = computed(() => new Set(normalizedClusterOptions.value));
+const selectedAllowedClusters = computed(() => normalizeClusterOptions(formData.value.config.allowedClusters));
+const displayedSelectedClusters = computed(() => [...normalizedClusterOptions.value.filter((cluster) => selectedAllowedClusters.value.includes(cluster)), ...selectedAllowedClusters.value.filter((cluster) => !clusterOptionSet.value.has(cluster))]);
+const canSubmitTenant = computed(() => Boolean(formData.value.name.trim()) && selectedAllowedClusters.value.length > 0);
+
+function guardWritable() {
+  if (props.readOnly) {
+    error.value = readOnlyMessage;
+    return false;
+  }
+  return true;
+}
+
+async function loadTenants() {
+  loading.value = true;
+  error.value = undefined;
+  try {
+    tenants.value = await mqListTenants(props.connectionId);
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function openCreateDialog() {
+  if (!guardWritable()) return;
+  formData.value = {
+    name: "",
+    config: defaultTenantConfig(normalizedClusterOptions.value),
+  };
+  newRole.value = "";
+  newCluster.value = "";
+  clusterDropdownOpen.value = false;
+  showCreateDialog.value = true;
+}
+
+function openEditDialog(tenant: TenantInfo) {
+  if (!guardWritable()) return;
+  editingTenant.value = tenant;
+  formData.value = {
+    name: tenant.name,
+    config: {
+      adminRoles: [...tenant.adminRoles],
+      allowedClusters: normalizeClusterOptions(tenant.allowedClusters),
+    },
+  };
+  newRole.value = "";
+  newCluster.value = "";
+  clusterDropdownOpen.value = false;
+  showEditDialog.value = true;
+}
+
+async function handleCreate() {
+  if (!guardWritable()) return;
+  const validationError = validateTenantForm(formData.value.name, formData.value.config);
+  if (validationError) {
+    error.value = validationError;
+    return;
+  }
+  loading.value = true;
+  error.value = undefined;
+  try {
+    formData.value.config.allowedClusters = selectedAllowedClusters.value;
+    await mqCreateTenant(props.connectionId, formData.value.name, formData.value.config);
+    showCreateDialog.value = false;
+    await loadTenants();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function handleUpdate() {
+  if (!guardWritable()) return;
+  if (!editingTenant.value) return;
+  const validationError = validateTenantForm(formData.value.name, formData.value.config);
+  if (validationError) {
+    error.value = validationError;
+    return;
+  }
+  loading.value = true;
+  error.value = undefined;
+  try {
+    formData.value.config.allowedClusters = selectedAllowedClusters.value;
+    await mqUpdateTenant(props.connectionId, editingTenant.value.name, formData.value.config);
+    showEditDialog.value = false;
+    await loadTenants();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function handleDelete(tenant: TenantInfo) {
+  if (!guardWritable()) return;
+  if (!confirm(`确定要删除租户 "${tenant.name}" 吗？此操作不可逆。`)) return;
+  loading.value = true;
+  error.value = undefined;
+  try {
+    await mqDeleteTenant(props.connectionId, tenant.name, false);
+    if (selectedTenant.value === tenant.name) {
+      selectedTenant.value = undefined;
+    }
+    await loadTenants();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function addRole() {
+  const role = newRole.value.trim();
+  if (role && !formData.value.config.adminRoles.includes(role)) {
+    formData.value.config.adminRoles.push(role);
+    newRole.value = "";
+  }
+}
+
+function removeRole(role: string) {
+  formData.value.config.adminRoles = formData.value.config.adminRoles.filter((r) => r !== role);
+}
+
+function addCluster() {
+  const cluster = newCluster.value.trim();
+  if (cluster && !formData.value.config.allowedClusters.includes(cluster)) {
+    formData.value.config.allowedClusters.push(cluster);
+    newCluster.value = "";
+  }
+}
+
+function removeCluster(cluster: string) {
+  formData.value.config.allowedClusters = formData.value.config.allowedClusters.filter((c) => c !== cluster);
+}
+
+function toggleCluster(cluster: string) {
+  const selected = new Set(selectedAllowedClusters.value);
+  if (selected.has(cluster)) {
+    selected.delete(cluster);
+  } else {
+    selected.add(cluster);
+  }
+  formData.value.config.allowedClusters = [...selected];
+}
+
+function isClusterSelected(cluster: string) {
+  return selectedAllowedClusters.value.includes(cluster);
+}
+
+function handleDocumentPointerDown(event: PointerEvent) {
+  if (!clusterDropdownOpen.value) return;
+  const target = event.target;
+  if (!(target instanceof Node)) return;
+  if (clusterSelectRef.value?.contains(target)) return;
+  clusterDropdownOpen.value = false;
+}
+
+function selectTenant(tenant: TenantInfo) {
+  selectedTenant.value = tenant.name;
+  emit("tenantSelected", tenant.name);
+}
+
+onMounted(() => {
+  document.addEventListener("pointerdown", handleDocumentPointerDown, true);
+  if (props.supportsTenants) {
+    loadTenants();
+  }
+});
+
+onBeforeUnmount(() => {
+  document.removeEventListener("pointerdown", handleDocumentPointerDown, true);
+});
+
+watch(normalizedClusterOptions, (clusters) => {
+  if (showCreateDialog.value && formData.value.config.allowedClusters.length === 0) {
+    formData.value.config.allowedClusters = [...clusters];
+  }
+});
+</script>
+
+<template>
+  <div class="tenants-panel">
+    <div class="panel-toolbar">
+      <h3>租户管理</h3>
+      <button @click="openCreateDialog" :disabled="loading || readOnly" class="btn-primary">+ 创建租户</button>
+    </div>
+
+    <div v-if="!supportsTenants" class="panel-placeholder">当前消息队列系统不支持租户管理</div>
+
+    <div v-else-if="error" class="panel-error">{{ error }}</div>
+
+    <div v-else-if="loading && !tenants.length" class="panel-loading">加载中...</div>
+
+    <div v-else class="tenants-table">
+      <table>
+        <thead>
+          <tr>
+            <th>名称</th>
+            <th>管理角色</th>
+            <th>允许集群</th>
+            <th>操作</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-for="tenant in tenants" :key="tenant.name" :class="{ selected: selectedTenant === tenant.name }" @click="selectTenant(tenant)">
+            <td class="tenant-name">{{ tenant.name }}</td>
+            <td>
+              <span v-if="tenant.adminRoles.length" class="tag-list">
+                <span v-for="role in tenant.adminRoles" :key="role" class="tag">{{ role }}</span>
+              </span>
+              <span v-else class="text-muted">无</span>
+            </td>
+            <td>
+              <span v-if="tenant.allowedClusters.length" class="tag-list">
+                <span v-for="cluster in tenant.allowedClusters" :key="cluster" class="tag">{{ cluster }}</span>
+              </span>
+              <span v-else class="text-muted">无</span>
+            </td>
+            <td class="actions">
+              <button @click.stop="openEditDialog(tenant)" :disabled="readOnly" class="btn-sm">编辑</button>
+              <button @click.stop="handleDelete(tenant)" :disabled="readOnly" class="btn-sm btn-danger">删除</button>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+
+    <!-- Create Dialog -->
+    <div v-if="showCreateDialog" class="dialog-overlay" @click="showCreateDialog = false">
+      <div class="dialog" @click.stop>
+        <div class="dialog-header">
+          <h3>创建租户</h3>
+          <button @click="showCreateDialog = false" class="btn-close">×</button>
+        </div>
+        <div class="dialog-body">
+          <div class="form-group">
+            <label>租户名称*</label>
+            <input v-model="formData.name" type="text" placeholder="例如: my-tenant" :disabled="readOnly" />
+          </div>
+          <div class="form-group">
+            <label>管理角色</label>
+            <div class="input-with-button">
+              <input v-model="newRole" type="text" placeholder="添加角色" :disabled="readOnly" @keyup.enter="addRole" />
+              <button @click="addRole" :disabled="readOnly" class="btn-sm">添加</button>
+            </div>
+            <div v-if="formData.config.adminRoles.length" class="tag-list">
+              <span v-for="role in formData.config.adminRoles" :key="role" class="tag">
+                {{ role }}
+                <button @click="removeRole(role)" :disabled="readOnly" class="tag-remove">×</button>
+              </span>
+            </div>
+          </div>
+          <div class="form-group">
+            <label>允许集群*</label>
+            <div ref="clusterSelectRef" class="cluster-select-wrap">
+              <button type="button" class="cluster-select-trigger" :class="{ open: clusterDropdownOpen }" :disabled="readOnly" @click="clusterDropdownOpen = !clusterDropdownOpen">
+                <span v-if="displayedSelectedClusters.length" class="cluster-selected-tags">
+                  <span v-for="cluster in displayedSelectedClusters" :key="cluster" class="tag">
+                    {{ cluster }}
+                    <span class="tag-remove" role="button" tabindex="0" @click.stop="removeCluster(cluster)" @keyup.enter.stop="removeCluster(cluster)">×</span>
+                  </span>
+                </span>
+                <span v-else class="cluster-placeholder">{{ normalizedClusterOptions.length ? "请选择允许集群" : "未探测到集群，可手动添加" }}</span>
+                <span class="cluster-arrow">{{ clusterDropdownOpen ? "⌃" : "⌄" }}</span>
+              </button>
+              <div v-if="clusterDropdownOpen" class="cluster-options">
+                <button v-for="cluster in normalizedClusterOptions" :key="cluster" type="button" class="cluster-option" :class="{ selected: isClusterSelected(cluster) }" @click="toggleCluster(cluster)">
+                  <span>{{ cluster }}</span>
+                  <span v-if="isClusterSelected(cluster)" class="cluster-check">✓</span>
+                </button>
+                <div v-if="!normalizedClusterOptions.length" class="cluster-empty">当前连接未返回集群列表</div>
+              </div>
+            </div>
+            <div class="input-with-button cluster-manual">
+              <input v-model="newCluster" type="text" placeholder="手动添加集群" :disabled="readOnly" @keyup.enter="addCluster" />
+              <button @click="addCluster" :disabled="readOnly" class="btn-sm">添加</button>
+            </div>
+            <div v-if="!selectedAllowedClusters.length" class="form-hint form-hint-error">至少选择或添加一个允许集群</div>
+          </div>
+          <div v-if="error" class="form-error">{{ error }}</div>
+        </div>
+        <div class="dialog-footer">
+          <button @click="showCreateDialog = false" class="btn-secondary">取消</button>
+          <button @click="handleCreate" :disabled="loading || readOnly || !canSubmitTenant" class="btn-primary">创建</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Edit Dialog -->
+    <div v-if="showEditDialog" class="dialog-overlay" @click="showEditDialog = false">
+      <div class="dialog" @click.stop>
+        <div class="dialog-header">
+          <h3>编辑租户: {{ editingTenant?.name }}</h3>
+          <button @click="showEditDialog = false" class="btn-close">×</button>
+        </div>
+        <div class="dialog-body">
+          <div class="form-group">
+            <label>管理角色</label>
+            <div class="input-with-button">
+              <input v-model="newRole" type="text" placeholder="添加角色" :disabled="readOnly" @keyup.enter="addRole" />
+              <button @click="addRole" :disabled="readOnly" class="btn-sm">添加</button>
+            </div>
+            <div v-if="formData.config.adminRoles.length" class="tag-list">
+              <span v-for="role in formData.config.adminRoles" :key="role" class="tag">
+                {{ role }}
+                <button @click="removeRole(role)" :disabled="readOnly" class="tag-remove">×</button>
+              </span>
+            </div>
+          </div>
+          <div class="form-group">
+            <label>允许集群*</label>
+            <div ref="clusterSelectRef" class="cluster-select-wrap">
+              <button type="button" class="cluster-select-trigger" :class="{ open: clusterDropdownOpen }" :disabled="readOnly" @click="clusterDropdownOpen = !clusterDropdownOpen">
+                <span v-if="displayedSelectedClusters.length" class="cluster-selected-tags">
+                  <span v-for="cluster in displayedSelectedClusters" :key="cluster" class="tag">
+                    {{ cluster }}
+                    <span class="tag-remove" role="button" tabindex="0" @click.stop="removeCluster(cluster)" @keyup.enter.stop="removeCluster(cluster)">×</span>
+                  </span>
+                </span>
+                <span v-else class="cluster-placeholder">{{ normalizedClusterOptions.length ? "请选择允许集群" : "未探测到集群，可手动添加" }}</span>
+                <span class="cluster-arrow">{{ clusterDropdownOpen ? "⌃" : "⌄" }}</span>
+              </button>
+              <div v-if="clusterDropdownOpen" class="cluster-options">
+                <button v-for="cluster in normalizedClusterOptions" :key="cluster" type="button" class="cluster-option" :class="{ selected: isClusterSelected(cluster) }" @click="toggleCluster(cluster)">
+                  <span>{{ cluster }}</span>
+                  <span v-if="isClusterSelected(cluster)" class="cluster-check">✓</span>
+                </button>
+                <div v-if="!normalizedClusterOptions.length" class="cluster-empty">当前连接未返回集群列表</div>
+              </div>
+            </div>
+            <div class="input-with-button cluster-manual">
+              <input v-model="newCluster" type="text" placeholder="手动添加集群" :disabled="readOnly" @keyup.enter="addCluster" />
+              <button @click="addCluster" :disabled="readOnly" class="btn-sm">添加</button>
+            </div>
+            <div v-if="!selectedAllowedClusters.length" class="form-hint form-hint-error">至少选择或添加一个允许集群</div>
+          </div>
+          <div v-if="error" class="form-error">{{ error }}</div>
+        </div>
+        <div class="dialog-footer">
+          <button @click="showEditDialog = false" class="btn-secondary">取消</button>
+          <button @click="handleUpdate" :disabled="loading || readOnly || !canSubmitTenant" class="btn-primary">保存</button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.tenants-panel {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.panel-toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.panel-toolbar h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+}
+
+.panel-placeholder,
+.panel-error,
+.panel-loading {
+  padding: 24px;
+  text-align: center;
+  color: var(--color-text-secondary);
+}
+
+.panel-error {
+  color: var(--color-error);
+}
+
+.tenants-table {
+  flex: 1;
+  overflow: auto;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+thead {
+  position: sticky;
+  top: 0;
+  background: var(--color-background-secondary);
+  z-index: 1;
+}
+
+th {
+  padding: 10px 12px;
+  text-align: left;
+  font-weight: 600;
+  font-size: 13px;
+  color: var(--color-text-secondary);
+  border-bottom: 1px solid var(--color-border);
+}
+
+tbody tr {
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+tbody tr:hover {
+  background: var(--color-hover);
+}
+
+tbody tr.selected {
+  background: var(--color-primary-alpha);
+}
+
+td {
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--color-border-light);
+}
+
+.tenant-name {
+  font-weight: 500;
+}
+
+.tag-list {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+
+.tag {
+  display: inline-flex;
+  align-items: center;
+  gap: 4px;
+  padding: 2px 8px;
+  background: var(--color-primary-alpha);
+  color: var(--color-primary);
+  border-radius: 4px;
+  font-size: 12px;
+}
+
+.tag-remove {
+  border: none;
+  background: none;
+  color: inherit;
+  cursor: pointer;
+  padding: 0;
+  font-size: 14px;
+  line-height: 1;
+}
+
+.text-muted {
+  color: var(--color-text-tertiary);
+  font-style: italic;
+}
+
+.actions {
+  display: flex;
+  gap: 8px;
+}
+
+.btn-primary,
+.btn-secondary,
+.btn-sm,
+.btn-danger {
+  padding: 6px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: 13px;
+  transition: all 0.2s;
+}
+
+.btn-primary {
+  background: var(--color-primary);
+  color: white;
+  border-color: var(--color-primary);
+}
+
+.btn-primary:hover:not(:disabled) {
+  opacity: 0.9;
+}
+
+.btn-danger {
+  color: var(--color-error);
+  border-color: var(--color-error);
+}
+
+.btn-danger:hover:not(:disabled) {
+  background: var(--color-error);
+  color: white;
+}
+
+.btn-sm {
+  padding: 4px 8px;
+  font-size: 12px;
+}
+
+button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+/* Dialog styles */
+.dialog-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.5);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+}
+
+.dialog {
+  background: var(--color-background);
+  border-radius: 8px;
+  width: 90%;
+  max-width: 500px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+}
+
+.dialog-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 16px 20px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.dialog-header h3 {
+  margin: 0;
+  font-size: 18px;
+}
+
+.btn-close {
+  border: none;
+  background: none;
+  font-size: 24px;
+  cursor: pointer;
+  color: var(--color-text-secondary);
+  padding: 0;
+  line-height: 1;
+}
+
+.dialog-body {
+  padding: 20px;
+  max-height: 60vh;
+  overflow-y: auto;
+}
+
+.form-group {
+  margin-bottom: 16px;
+}
+
+.form-group label {
+  display: block;
+  margin-bottom: 6px;
+  font-weight: 500;
+  font-size: 13px;
+}
+
+.form-group input[type="text"] {
+  width: 100%;
+  padding: 8px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  font-size: 14px;
+  box-sizing: border-box;
+}
+
+.input-with-button {
+  display: flex;
+  gap: 8px;
+  margin-bottom: 8px;
+}
+
+.input-with-button input {
+  flex: 1;
+}
+
+.cluster-select-wrap {
+  position: relative;
+  margin-bottom: 8px;
+}
+
+.cluster-select-trigger {
+  width: 100%;
+  min-height: 38px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 6px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  cursor: pointer;
+  text-align: left;
+}
+
+.cluster-select-trigger.open {
+  border-color: var(--color-primary);
+  box-shadow: 0 0 0 2px var(--color-primary-alpha);
+}
+
+.cluster-selected-tags {
+  display: flex;
+  flex: 1;
+  flex-wrap: wrap;
+  gap: 4px;
+}
+
+.cluster-placeholder {
+  flex: 1;
+  color: var(--color-text-tertiary);
+  font-size: 13px;
+}
+
+.cluster-arrow {
+  color: var(--color-text-tertiary);
+  font-size: 13px;
+}
+
+.cluster-options {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: calc(100% + 4px);
+  z-index: 20;
+  max-height: 180px;
+  overflow-y: auto;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  box-shadow: 0 8px 20px rgba(0, 0, 0, 0.12);
+}
+
+.cluster-option {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 10px 12px;
+  border: none;
+  border-bottom: 1px solid var(--color-border-light);
+  background: transparent;
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: 14px;
+  text-align: left;
+}
+
+.cluster-option:hover,
+.cluster-option.selected {
+  background: var(--color-primary-alpha);
+  color: var(--color-primary);
+}
+
+.cluster-option:last-child {
+  border-bottom: none;
+}
+
+.cluster-check {
+  color: var(--color-primary);
+  font-weight: 600;
+}
+
+.cluster-empty {
+  padding: 10px 12px;
+  color: var(--color-text-tertiary);
+  font-size: 13px;
+}
+
+.cluster-manual {
+  margin-top: 8px;
+}
+
+.form-hint {
+  margin-top: 4px;
+  font-size: 12px;
+  color: var(--color-text-tertiary);
+}
+
+.form-hint-error {
+  color: var(--color-error);
+}
+
+.form-error {
+  margin-top: 12px;
+  padding: 8px 12px;
+  background: var(--color-error-bg);
+  color: var(--color-error);
+  border-radius: 4px;
+  font-size: 13px;
+}
+
+.dialog-footer {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  padding: 16px 20px;
+  border-top: 1px solid var(--color-border);
+}
+</style>
diff --git a/apps/desktop/src/components/mq/TopicsPanel.vue b/apps/desktop/src/components/mq/TopicsPanel.vue
new file mode 100644
index 0000000..41ae424
--- /dev/null
+++ b/apps/desktop/src/components/mq/TopicsPanel.vue
@@ -0,0 +1,726 @@
+<script setup lang="ts">
+import { ref, watch, computed } from "vue";
+import { useI18n } from "vue-i18n";
+import type { NamespaceRef, TopicRef, TopicInfo, ListTopicsOpts } from "@/types/mq";
+import { mqListTopics, mqCreateTopic, mqDeleteTopic, mqUpdatePartitions } from "@/lib/backend/api";
+import { formatError } from "@/lib/backend/errorUtils";
+
+interface Props {
+  connectionId: string;
+  tenant?: string;
+  namespace?: string;
+  readOnly?: boolean;
+  supportsPartitionedTopics?: boolean;
+  isKafkaCluster?: boolean;
+}
+
+const props = defineProps<Props>();
+const emit = defineEmits<{
+  topicSelected: [topic: TopicInfo];
+}>();
+
+const { t } = useI18n();
+
+const topics = ref<TopicInfo[]>([]);
+const loading = ref(false);
+const error = ref<string>();
+const dialogError = ref<string>();
+const showCreateDialog = ref(false);
+const showPartitionsDialog = ref(false);
+const selectedTopic = ref<TopicInfo>();
+const editingTopic = ref<TopicInfo>();
+const topicSearch = ref("");
+
+const formData = ref({
+  topicName: "",
+  persistent: true,
+  partitioned: false,
+  partitions: 4,
+});
+
+const newPartitions = ref(4);
+
+const includeNonPersistent = ref(false);
+
+const filteredTopics = computed(() => {
+  const query = topicSearch.value.trim().toLowerCase();
+  if (!query) return topics.value;
+  return topics.value.filter((topic) => {
+    return topic.name.toLowerCase().includes(query) || topic.shortName.toLowerCase().includes(query);
+  });
+});
+const editingCurrentPartitions = computed(() => editingTopic.value?.partitions ?? 0);
+const canSubmitPartitionUpdate = computed(() => {
+  const current = editingCurrentPartitions.value;
+  return !props.readOnly && current > 0 && Number.isFinite(newPartitions.value) && newPartitions.value > current;
+});
+
+function guardWritable() {
+  if (props.readOnly) {
+    error.value = t("mqTopics.readOnly");
+    return false;
+  }
+  return true;
+}
+
+async function loadTopics() {
+  if (!props.tenant || !props.namespace) {
+    topics.value = [];
+    return;
+  }
+  loading.value = true;
+  error.value = undefined;
+  try {
+    const ns: NamespaceRef = {
+      tenant: props.tenant,
+      namespace: props.namespace,
+    };
+    const opts: ListTopicsOpts = {
+      includeNonPersistent: includeNonPersistent.value,
+    };
+    topics.value = await mqListTopics(props.connectionId, ns, opts);
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function openCreateDialog() {
+  if (!guardWritable()) return;
+  dialogError.value = undefined;
+  formData.value = {
+    topicName: "",
+    persistent: true,
+    partitioned: props.isKafkaCluster ?? false,
+    partitions: 4,
+  };
+  showCreateDialog.value = true;
+}
+
+function openPartitionsDialog(topic: TopicInfo) {
+  if (!guardWritable()) return;
+  dialogError.value = undefined;
+  if (!topic.partitions || topic.partitions < 1) {
+    error.value = t("mqTopics.currentPartitionsUnknown");
+    return;
+  }
+  editingTopic.value = topic;
+  newPartitions.value = topic.partitions + 1;
+  showPartitionsDialog.value = true;
+}
+
+async function handleCreate() {
+  if (!guardWritable()) return;
+  if (!formData.value.topicName.trim() || !props.tenant || !props.namespace) {
+    dialogError.value = t("mqTopics.topicNameRequired");
+    return;
+  }
+  loading.value = true;
+  error.value = undefined;
+  try {
+    const topicRef: TopicRef = {
+      tenant: props.tenant,
+      namespace: props.namespace,
+      topic: formData.value.topicName,
+      persistent: formData.value.persistent,
+    };
+    const partitions = props.supportsPartitionedTopics !== false && formData.value.partitioned ? formData.value.partitions : undefined;
+    await mqCreateTopic(props.connectionId, topicRef, partitions);
+    showCreateDialog.value = false;
+    dialogError.value = undefined;
+    await loadTopics();
+  } catch (e: unknown) {
+    dialogError.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function handleDelete(topic: TopicInfo) {
+  if (!guardWritable()) return;
+  if (!confirm(t("mqTopics.confirmDelete", { name: topic.shortName }))) return;
+  if (!props.tenant || !props.namespace) return;
+  loading.value = true;
+  error.value = undefined;
+  try {
+    const topicRef: TopicRef = {
+      tenant: props.tenant,
+      namespace: props.namespace,
+      topic: topic.shortName,
+      persistent: topic.persistent,
+    };
+    await mqDeleteTopic(props.connectionId, topicRef, false);
+    if (selectedTopic.value?.name === topic.name) {
+      selectedTopic.value = undefined;
+    }
+    await loadTopics();
+  } catch (e: unknown) {
+    error.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function handleUpdatePartitions() {
+  if (!guardWritable()) return;
+  if (!editingTopic.value || !props.tenant || !props.namespace) return;
+  const currentPartitions = editingTopic.value.partitions;
+  if (!currentPartitions || currentPartitions < 1) {
+    dialogError.value = t("mqTopics.currentPartitionsUnknown");
+    return;
+  }
+  if (newPartitions.value <= currentPartitions) {
+    dialogError.value = t("mqTopics.partitionMustIncrease");
+    return;
+  }
+  loading.value = true;
+  error.value = undefined;
+  try {
+    const topicRef: TopicRef = {
+      tenant: props.tenant,
+      namespace: props.namespace,
+      topic: editingTopic.value.shortName,
+      persistent: editingTopic.value.persistent,
+    };
+    await mqUpdatePartitions(props.connectionId, topicRef, newPartitions.value);
+    showPartitionsDialog.value = false;
+    dialogError.value = undefined;
+    await loadTopics();
+  } catch (e: unknown) {
+    dialogError.value = formatError(e);
+  } finally {
+    loading.value = false;
+  }
+}
+
+function selectTopic(topic: TopicInfo) {
+  selectedTopic.value = topic;
+  emit("topicSelected", topic);
+}
+
+function normalizePartitionInput() {
+  const min = editingCurrentPartitions.value + 1;
+  if (!showPartitionsDialog.value || min <= 1) return;
+  if (!Number.isFinite(Number(newPartitions.value)) || Number(newPartitions.value) < min) {
+    newPartitions.value = min;
+  }
+}
+
+watch(
+  () => [props.tenant, props.namespace],
+  () => {
+    selectedTopic.value = undefined;
+    loadTopics();
+  },
+  { immediate: true },
+);
+
+watch(includeNonPersistent, () => {
+  loadTopics();
+});
+
+watch(newPartitions, () => {
+  if (dialogError.value === t("mqTopics.partitionMustIncrease") && canSubmitPartitionUpdate.value) {
+    dialogError.value = undefined;
+  }
+});
+</script>
+
+<template>
+  <div class="topics-panel">
+    <div class="panel-toolbar">
+      <div class="toolbar-left">
+        <h3>{{ t("mqTopics.title") }}</h3>
+        <input v-model="topicSearch" type="search" class="topic-search" :placeholder="t('mqTopics.searchPlaceholder')" :disabled="loading && !topics.length" />
+        <span v-if="topics.length" class="topic-count">{{ filteredTopics.length }} / {{ topics.length }}</span>
+        <label class="checkbox-label">
+          <input type="checkbox" v-model="includeNonPersistent" />
+          {{ t("mqTopics.includeNonPersistent") }}
+        </label>
+      </div>
+      <div class="toolbar-actions">
+        <button @click="loadTopics" :disabled="loading || !tenant || !namespace" class="btn-secondary">
+          {{ loading ? t("mqTopics.refreshing") : t("mqTopics.refresh") }}
+        </button>
+        <button @click="openCreateDialog" :disabled="loading || readOnly || !tenant || !namespace" class="btn-primary">+ {{ t("mqTopics.createTopic") }}</button>
+      </div>
+    </div>
+
+    <div v-if="!tenant || !namespace" class="panel-placeholder">{{ t("mqTopics.selectTenantNamespace") }}</div>
+
+    <div v-else-if="error" class="panel-error">{{ error }}</div>
+
+    <div v-else-if="loading && !topics.length" class="panel-loading">{{ t("mqTopics.loading") }}</div>
+
+    <div v-else-if="!topics.length" class="panel-placeholder">{{ t("mqTopics.noTopics") }}</div>
+
+    <div v-else-if="!filteredTopics.length" class="panel-placeholder">{{ t("mqTopics.noMatches") }}</div>
+
+    <div v-else class="topics-table">
+      <table>
+        <thead>
+          <tr>
+            <th>{{ t("mqTopics.name") }}</th>
+            <th>{{ t("mqTopics.type") }}</th>
+            <th>{{ t("mqTopics.partitions") }}</th>
+            <th>{{ t("mqTopics.actions") }}</th>
+          </tr>
+        </thead>
+        <tbody>
+          <tr v-for="topic in filteredTopics" :key="topic.name" :class="{ selected: selectedTopic?.name === topic.name }" @click="selectTopic(topic)">
+            <td class="topic-name">
+              <div class="topic-name-cell">
+                <span>{{ topic.shortName }}</span>
+                <span v-if="!topic.persistent" class="badge badge-warning">{{ t("mqTopics.nonPersistent") }}</span>
+              </div>
+            </td>
+            <td>
+              <span class="badge" :class="topic.partitioned ? 'badge-info' : 'badge-default'">
+                {{ topic.partitioned ? t("mqTopics.partitionedTopic") : t("mqTopics.normalTopic") }}
+              </span>
+            </td>
+            <td>
+              <span v-if="topic.partitioned">{{ topic.partitions ? t("mqTopics.partitionCount", { count: topic.partitions }) : t("mqTopics.partitionsUnknown") }}</span>
+              <span v-else class="text-muted">-</span>
+            </td>
+            <td class="actions">
+              <button v-if="topic.partitioned && supportsPartitionedTopics !== false" @click.stop="openPartitionsDialog(topic)" :disabled="readOnly || !topic.partitions" class="btn-sm">
+                {{ t("mqTopics.adjustPartitions") }}
+              </button>
+              <button @click.stop="handleDelete(topic)" :disabled="readOnly" class="btn-sm btn-danger">{{ t("mqTopics.delete") }}</button>
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+
+    <!-- Create Dialog -->
+    <div v-if="showCreateDialog" class="dialog-overlay" @click="showCreateDialog = false">
+      <div class="dialog" @click.stop>
+        <div class="dialog-header">
+          <h3>{{ t("mqTopics.createTopic") }}</h3>
+          <button @click="showCreateDialog = false" class="btn-close">×</button>
+        </div>
+        <div class="dialog-body">
+          <div v-if="!isKafkaCluster" class="form-group">
+            <label>{{ t("mqTopics.tenantNamespace") }}</label>
+            <input type="text" :value="`${tenant} / ${namespace}`" disabled />
+          </div>
+          <div class="form-group">
+            <label>{{ t("mqTopics.topicName") }}*</label>
+            <input v-model="formData.topicName" type="text" :placeholder="t('mqTopics.topicNamePlaceholder')" :disabled="readOnly" />
+          </div>
+          <div class="form-group">
+            <label class="checkbox-label">
+              <input type="checkbox" v-model="formData.persistent" :disabled="readOnly" />
+              {{ t("mqTopics.persistentRecommended") }}
+            </label>
+            <div class="form-hint">{{ t("mqTopics.persistentHint") }}</div>
+          </div>
+          <div v-if="supportsPartitionedTopics !== false" class="form-group">
+            <label class="checkbox-label">
+              <input type="checkbox" v-model="formData.partitioned" :disabled="readOnly" />
+              {{ t("mqTopics.enablePartitions") }}
+            </label>
+            <div v-if="formData.partitioned" class="form-subgroup">
+              <label>{{ t("mqTopics.partitionQuantity") }}*</label>
+              <input v-model.number="formData.partitions" type="number" min="1" max="256" :disabled="readOnly" />
+              <div class="form-hint">{{ t("mqTopics.partitionHint") }}</div>
+            </div>
+          </div>
+          <div v-if="dialogError" class="form-error">{{ dialogError }}</div>
+        </div>
+        <div class="dialog-footer">
+          <button @click="showCreateDialog = false" class="btn-secondary">{{ t("mqTopics.cancel") }}</button>
+          <button @click="handleCreate" :disabled="loading || readOnly" class="btn-primary">{{ t("mqTopics.create") }}</button>
+        </div>
+      </div>
+    </div>
+
+    <!-- Update Partitions Dialog -->
+    <div v-if="showPartitionsDialog" class="dialog-overlay" @click="showPartitionsDialog = false">
+      <div class="dialog" @click.stop>
+        <div class="dialog-header">
+          <h3>{{ t("mqTopics.updatePartitionsTitle", { name: editingTopic?.shortName }) }}</h3>
+          <button @click="showPartitionsDialog = false" class="btn-close">×</button>
+        </div>
+        <div class="dialog-body">
+          <div class="form-group">
+            <label>{{ t("mqTopics.currentPartitions") }}</label>
+            <input type="number" :value="editingTopic?.partitions" disabled />
+          </div>
+          <div class="form-group">
+            <label>{{ t("mqTopics.newPartitions") }}*</label>
+            <input v-model.number="newPartitions" type="number" :min="editingCurrentPartitions + 1" max="256" :disabled="readOnly" @change="normalizePartitionInput" @blur="normalizePartitionInput" />
+            <div class="form-hint">{{ t("mqTopics.partitionMinHint", { min: editingCurrentPartitions + 1 }) }}</div>
+          </div>
+          <div v-if="dialogError" class="form-error">{{ dialogError }}</div>
+        </div>
+        <div class="dialog-footer">
+          <button @click="showPartitionsDialog = false" class="btn-secondary">{{ t("mqTopics.cancel") }}</button>
+          <button @click="handleUpdatePartitions" :disabled="loading || !canSubmitPartitionUpdate" class="btn-primary">{{ t("mqTopics.update") }}</button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.topics-panel {
+  --topics-surface: var(--card, var(--color-background, #ffffff));
+  --topics-header-bg: color-mix(in srgb, var(--secondary, #f5f5f5) 86%, var(--card, #ffffff));
+  --topics-border: var(--border, var(--color-border, #e5e7eb));
+  --topics-border-light: color-mix(in srgb, var(--topics-border) 68%, transparent);
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+}
+
+.panel-toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 12px 16px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.toolbar-left {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  min-width: 0;
+}
+
+.toolbar-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.toolbar-left h3 {
+  margin: 0;
+  font-size: 16px;
+  font-weight: 600;
+  flex: 0 0 auto;
+}
+
+.topic-search {
+  width: min(320px, 32vw);
+  min-width: 180px;
+  padding: 6px 10px;
+  border: 1px solid var(--color-border);
+  border-radius: 6px;
+  background: var(--color-background);
+  color: var(--color-text);
+  font-size: 13px;
+}
+
+.topic-search:focus {
+  outline: none;
+  border-color: var(--color-primary);
+  box-shadow: 0 0 0 2px var(--color-primary-alpha);
+}
+
+.topic-count {
+  flex: 0 0 auto;
+  color: var(--color-text-tertiary);
+  font-size: 12px;
+}
+
+.checkbox-label {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 13px;
+  cursor: pointer;
+}
+
+.checkbox-label input[type="checkbox"] {
+  cursor: pointer;
+}
+
+.panel-placeholder,
+.panel-error,
+.panel-loading {
+  padding: 24px;
+  text-align: center;
+  color: var(--color-text-secondary);
+}
+
+.panel-error {
+  color: var(--color-error);
+}
+
+.topics-table {
+  position: relative;
+  flex: 1;
+  overflow: auto;
+  background: var(--topics-surface);
+}
+
+.topics-table::before {
+  content: "";
+  position: sticky;
+  top: 0;
+  display: block;
+  height: 38px;
+  margin-bottom: -38px;
+  background: var(--topics-header-bg);
+  z-index: 9;
+  box-shadow:
+    0 1px 0 var(--topics-border),
+    0 2px 8px rgba(0, 0, 0, 0.05);
+  pointer-events: none;
+}
+
+table {
+  position: relative;
+  width: 100%;
+  border-collapse: separate;
+  border-spacing: 0;
+}
+
+thead {
+  position: sticky;
+  top: 0;
+  background: var(--topics-header-bg);
+  z-index: 10;
+}
+
+th {
+  position: sticky;
+  top: 0;
+  z-index: 11;
+  padding: 10px 12px;
+  text-align: left;
+  font-weight: 600;
+  font-size: 13px;
+  color: var(--color-text-secondary);
+  background: var(--topics-header-bg);
+  border-bottom: 1px solid var(--topics-border);
+  background-clip: padding-box;
+  box-shadow:
+    0 1px 0 var(--topics-border),
+    0 2px 6px rgba(0, 0, 0, 0.04);
+}
+
+tbody tr {
+  cursor: pointer;
+  transition: background 0.2s;
+}
+
+tbody tr:hover {
+  background: var(--color-hover);
+}
+
+tbody tr:hover td {
+  background: var(--color-hover);
+}
+
+tbody tr.selected {
+  background: var(--color-primary-alpha);
+}
+
+tbody tr.selected td {
+  background: var(--color-primary-alpha);
+}
+
+td {
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--topics-border-light);
+  background: var(--topics-surface);
+}
+
+.topic-name-cell {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+
+.topic-name {
+  font-weight: 500;
+}
+
+.badge {
+  display: inline-block;
+  padding: 2px 8px;
+  border-radius: 4px;
+  font-size: 11px;
+  font-weight: 500;
+}
+
+.badge-default {
+  background: var(--color-background-secondary);
+  color: var(--color-text-secondary);
+}
+
+.badge-info {
+  background: var(--color-info-alpha);
+  color: var(--color-info);
+}
+
+.badge-warning {
+  background: var(--color-warning-alpha);
+  color: var(--color-warning);
+}
+
+.text-muted {
+  color: var(--color-text-tertiary);
+  font-style: italic;
+}
+
+.actions {
+  display: flex;
+  gap: 8px;
+}
+
+.btn-primary,
+.btn-secondary,
+.btn-sm,
+.btn-danger {
+  padding: 6px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  background: var(--color-background);
+  color: var(--color-text);
+  cursor: pointer;
+  font-size: 13px;
+  transition: all 0.2s;
+}
+
+.btn-primary {
+  background: var(--color-primary);
+  color: white;
+  border-color: var(--color-primary);
+}
+
+.btn-primary:hover:not(:disabled) {
+  opacity: 0.9;
+}
+
+.btn-danger {
+  color: var(--color-error);
+  border-color: var(--color-error);
+}
+
+.btn-danger:hover:not(:disabled) {
+  background: var(--color-error);
+  color: white;
+}
+
+.btn-sm {
+  padding: 4px 8px;
+  font-size: 12px;
+}
+
+button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+/* Dialog styles */
+.dialog-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.5);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 1000;
+}
+
+.dialog {
+  background: var(--color-background);
+  border-radius: 8px;
+  width: 90%;
+  max-width: 500px;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+}
+
+.dialog-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 16px 20px;
+  border-bottom: 1px solid var(--color-border);
+}
+
+.dialog-header h3 {
+  margin: 0;
+  font-size: 18px;
+}
+
+.btn-close {
+  border: none;
+  background: none;
+  font-size: 24px;
+  cursor: pointer;
+  color: var(--color-text-secondary);
+  padding: 0;
+  line-height: 1;
+}
+
+.dialog-body {
+  padding: 20px;
+  max-height: 60vh;
+  overflow-y: auto;
+}
+
+.form-group {
+  margin-bottom: 16px;
+}
+
+.form-group label {
+  display: block;
+  margin-bottom: 6px;
+  font-weight: 500;
+  font-size: 13px;
+}
+
+.form-group input[type="text"],
+.form-group input[type="number"] {
+  width: 100%;
+  padding: 8px 12px;
+  border: 1px solid var(--color-border);
+  border-radius: 4px;
+  font-size: 14px;
+  box-sizing: border-box;
+}
+
+.form-group input:disabled {
+  background: var(--color-background-secondary);
+  color: var(--color-text-secondary);
+}
+
+.form-subgroup {
+  margin-top: 12px;
+  padding-left: 24px;
+}
+
+.form-hint {
+  margin-top: 4px;
+  font-size: 12px;
+  color: var(--color-text-tertiary);
+}
+
+.form-error {
+  margin-top: 12px;
+  padding: 8px 12px;
+  background: var(--color-error-bg);
+  color: var(--color-error);
+  border-radius: 4px;
+  font-size: 13px;
+}
+
+.dialog-footer {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+  padding: 16px 20px;
+  border-top: 1px solid var(--color-border);
+}
+</style>
diff --git a/apps/desktop/src/components/nacos/NacosAdminConsole.vue b/apps/desktop/src/components/nacos/NacosAdminConsole.vue
new file mode 100644
index 0000000..68f26fb
--- /dev/null
+++ b/apps/desktop/src/components/nacos/NacosAdminConsole.vue
@@ -0,0 +1,1284 @@
+<script setup lang="ts">
+import { computed, nextTick, onBeforeUnmount, onMounted, ref, shallowRef, watch } from "vue";
+import { Compartment, type Extension } from "@codemirror/state";
+import { StreamLanguage } from "@codemirror/language";
+import type { EditorView } from "@codemirror/view";
+import { CheckCircle2, Clipboard, Download, FileClock, FileText, Loader2, Network, Plus, RefreshCw, Save, Send, Server, Trash2 } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import EditorSearchPanel from "@/components/editor/EditorSearchPanel.vue";
+import NacosConfigDiffDialog from "@/components/nacos/NacosConfigDiffDialog.vue";
+import NacosConfigHistoryDialog from "@/components/nacos/NacosConfigHistoryDialog.vue";
+import { useToast } from "@/composables/useToast";
+import { useNacosConfigListColumnResize } from "@/composables/useNacosConfigListColumnResize";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useI18n } from "vue-i18n";
+import * as api from "@/lib/backend/api";
+import { buildNacosConfigDeleteConfirm, buildNacosConfigExportFileName, buildNacosConfigHistoryRollbackConfirm, buildNacosInstanceConfirm, createNacosSaveAsCopy, resolveNacosConfigCopyText } from "@/lib/nacos/nacosAdmin";
+import { copyToClipboard, readTextFromClipboard } from "@/lib/common/clipboard";
+import { trimmedSelectionLayer } from "@/lib/editor/codemirrorTrimmedSelectionLayer";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+import { editorFontTheme, loadEditorTheme } from "@/lib/editor/editorThemes";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useTheme } from "@/composables/useTheme";
+import type { NacosConfigHistoryItem, NacosConfigItem, NacosConfigKey, NacosConnectionInfo, NacosInstanceInfo, NacosServiceInfo } from "@/types/nacos";
+import { Splitpanes, Pane } from "splitpanes";
+import "splitpanes/dist/splitpanes.css";
+
+const props = defineProps<{
+  connectionId: string;
+  namespace?: string;
+  namespaceName?: string;
+  readOnly?: boolean;
+}>();
+
+type AdminTab = "configs" | "services";
+
+const { toast } = useToast();
+const { t } = useI18n();
+const settingsStore = useSettingsStore();
+const connectionStore = useConnectionStore();
+const { isDark, themePalette } = useTheme();
+const activeTab = ref<AdminTab>("configs");
+const connectionInfo = ref<NacosConnectionInfo | null>(null);
+const connectionError = ref("");
+const infoLoading = ref(false);
+
+const configLoading = ref(false);
+const configError = ref("");
+const configGroup = ref("");
+const configDataId = ref("");
+const configAppName = ref("");
+const configPageNo = ref(1);
+const configPageSize = ref(20);
+const configs = ref<NacosConfigItem[]>([]);
+const configTotal = ref(0);
+const selectedConfig = ref<NacosConfigItem | null>(null);
+const selectedConfigOriginalKey = ref<NacosConfigKey | null>(null);
+const configContent = ref("");
+const originalConfigContent = ref("");
+const configType = ref("text");
+const savingConfig = ref(false);
+const deletingConfig = ref(false);
+const configAdvancedOpen = ref(false);
+const configSaveNotice = ref("");
+const pendingConfigSave = ref(false);
+const pendingDeleteConfig = ref<NacosConfigItem | null>(null);
+const historyOpen = ref(false);
+const historyLoading = ref(false);
+const historyError = ref("");
+const historyItems = ref<NacosConfigHistoryItem[]>([]);
+const historyPageNo = ref(1);
+const historyPageSize = ref(20);
+const historyTotal = ref(0);
+const historyViewingItem = ref<NacosConfigHistoryItem | null>(null);
+const historyViewingContent = ref("");
+const historyViewingLoading = ref(false);
+const historyCompareOpen = ref(false);
+const historyCompareCurrent = ref("");
+const historyCompareContent = ref("");
+const historyCompareLoading = ref(false);
+const historyCompareItem = ref<NacosConfigHistoryItem | null>(null);
+const pendingHistoryRollback = ref<NacosConfigHistoryItem | null>(null);
+const rollingBackHistory = ref(false);
+const configFormatOptions = ["text", "json", "xml", "yaml", "html", "properties", "toml"];
+const configEditorHost = ref<HTMLDivElement | null>(null);
+const configEditorView = shallowRef<EditorView | null>(null);
+const configSearchPanelRef = ref<InstanceType<typeof EditorSearchPanel>>();
+const knownConfigFormats = ref<Record<string, string>>({});
+const configEditorTheme = new Compartment();
+const configEditorFontTheme = new Compartment();
+const configEditorLanguage = new Compartment();
+
+const servicesLoading = ref(false);
+const servicesError = ref("");
+const serviceGroup = ref("");
+const serviceName = ref("");
+const serviceCluster = ref("");
+const servicePageNo = ref(1);
+const servicePageSize = ref(20);
+const services = ref<NacosServiceInfo[]>([]);
+const serviceTotal = ref(0);
+const selectedService = ref<NacosServiceInfo | null>(null);
+const instances = ref<NacosInstanceInfo[]>([]);
+const instancesLoading = ref(false);
+const instancesError = ref("");
+const updatingInstanceKey = ref("");
+const pendingInstanceUpdate = ref<{ instance: NacosInstanceInfo; patch: Partial<NacosInstanceInfo> } | null>(null);
+
+const NACOS_SPLIT_SIZE_KEY = "dbx-nacos-admin-split-size";
+const savedNacosSplitSize = Number(safeLocalStorageGet(NACOS_SPLIT_SIZE_KEY));
+const nacosSplitSize = ref(savedNacosSplitSize >= 20 && savedNacosSplitSize <= 80 ? savedNacosSplitSize : 42);
+const CONNECTION_NOT_FOUND_RETRY_DELAYS_MS = [150, 350, 700];
+const { gridTemplateColumns: configListGridTemplate, minWidth: configListMinWidth, resizingColumnIndex: configListResizingColumnIndex, onResizeStart: onConfigListColumnResizeStart } = useNacosConfigListColumnResize();
+
+const namespace = computed(() => props.namespace ?? connectionInfo.value?.namespace ?? "");
+const namespaceLabel = computed(() => props.namespaceName || namespace.value || "public");
+const namespaceIdLabel = computed(() => {
+  if (!namespace.value || namespace.value === namespaceLabel.value) return "";
+  return namespace.value;
+});
+const configTotalPages = computed(() => Math.max(1, Math.ceil(configTotal.value / Math.max(1, configPageSize.value))));
+const serviceTotalPages = computed(() => Math.max(1, Math.ceil(serviceTotal.value / Math.max(1, servicePageSize.value))));
+const isCreatingConfig = computed(() => !!selectedConfig.value && !selectedConfigOriginalKey.value);
+const isConfigDirty = computed(() => !!selectedConfig.value && (configContent.value !== originalConfigContent.value || configFormatValue(selectedConfig.value) !== configType.value));
+const pendingDeleteDetails = computed(() => (pendingDeleteConfig.value ? buildNacosConfigDeleteConfirm(pendingDeleteConfig.value, namespace.value) : ""));
+const pendingHistoryRollbackDetails = computed(() => (pendingHistoryRollback.value ? buildNacosConfigHistoryRollbackConfirm(pendingHistoryRollback.value, namespace.value) : ""));
+const pendingInstanceDetails = computed(() => (pendingInstanceUpdate.value && selectedService.value ? buildNacosInstanceConfirm(selectedService.value, pendingInstanceUpdate.value.instance, pendingInstanceUpdate.value.patch, serviceGroup.value, namespace.value) : ""));
+const selectedConfigKey = computed<NacosConfigKey | null>(() => {
+  if (selectedConfigOriginalKey.value) return selectedConfigOriginalKey.value;
+  if (!selectedConfig.value) return null;
+  return {
+    namespace: selectedConfig.value.namespace || namespace.value || undefined,
+    dataId: selectedConfig.value.dataId,
+    group: selectedConfig.value.group,
+  };
+});
+
+function editorThemeAppearance() {
+  return isDark.value ? "dark" : "light";
+}
+
+function currentCustomThemeColors() {
+  const settings = settingsStore.editorSettings;
+  if (settings.theme !== "custom") return settings.customThemeColors;
+  const activeTheme = settings.customThemes?.find((theme) => theme.id === settings.activeCustomThemeId) || settings.customThemes?.[0];
+  return activeTheme?.colors ?? settings.customThemeColors;
+}
+
+async function configLanguageExtension(format: string): Promise<Extension[]> {
+  switch (format) {
+    case "json": {
+      const { json } = await import("@codemirror/lang-json");
+      return [json()];
+    }
+    case "yaml": {
+      const { yaml } = await import("@codemirror/lang-yaml");
+      return [yaml()];
+    }
+    case "xml": {
+      const { xml } = await import("@codemirror/lang-xml");
+      return [xml()];
+    }
+    case "html": {
+      const { html } = await import("@codemirror/lang-html");
+      return [html({ matchClosingTags: false })];
+    }
+    case "properties": {
+      const { properties } = await import("@codemirror/legacy-modes/mode/properties");
+      return [StreamLanguage.define(properties)];
+    }
+    case "toml": {
+      const { toml } = await import("@codemirror/legacy-modes/mode/toml");
+      return [StreamLanguage.define(toml)];
+    }
+    default:
+      return [];
+  }
+}
+
+async function mountConfigEditor() {
+  await nextTick();
+  if (!configEditorHost.value || configEditorView.value || !selectedConfig.value) return;
+  const [{ EditorState, Prec }, { EditorView, keymap }, { basicSetup }, { defaultKeymap, historyKeymap, indentWithTab }, { search: cmSearch }, language] = await Promise.all([
+    import("@codemirror/state"),
+    import("@codemirror/view"),
+    import("codemirror"),
+    import("@codemirror/commands"),
+    import("@codemirror/search"),
+    configLanguageExtension(configType.value),
+  ]);
+  const editorSettings = settingsStore.editorSettings;
+  const theme = await loadEditorTheme(editorSettings.theme, editorThemeAppearance(), currentCustomThemeColors(), themePalette.value);
+  const view = new EditorView({
+    parent: configEditorHost.value,
+    state: EditorState.create({
+      doc: configContent.value,
+      extensions: [
+        cmSearch({
+          top: true,
+          createPanel: () => {
+            const dom = document.createElement("span");
+            dom.style.display = "none";
+            return { dom };
+          },
+        }),
+        basicSetup,
+        trimmedSelectionLayer(),
+        Prec.highest(keymap.of([{ key: "Mod-f", run: () => configSearchPanelRef.value?.openSearch() ?? false, preventDefault: true }, { key: "Mod-h", run: () => configSearchPanelRef.value?.openReplace() ?? false, preventDefault: true }, indentWithTab])),
+        keymap.of([...defaultKeymap, ...historyKeymap]),
+        configEditorLanguage.of(language),
+        configEditorTheme.of(theme),
+        configEditorFontTheme.of(editorFontTheme(EditorView, editorSettings.fontSize, editorSettings.fontFamily, { fixedHeight: true, scrollable: true })),
+        EditorView.lineWrapping,
+        EditorState.readOnly.of(!!props.readOnly),
+        EditorView.editable.of(!props.readOnly),
+        EditorView.updateListener.of((update) => {
+          if (!update.docChanged) return;
+          configContent.value = update.state.doc.toString();
+          configSaveNotice.value = "";
+        }),
+        EditorView.theme({
+          "&": {
+            height: "100%",
+          },
+          ".cm-scroller": {
+            overflow: "auto",
+          },
+          ".cm-content": {
+            minHeight: "100%",
+            userSelect: "text",
+            WebkitUserSelect: "text",
+          },
+          ".cm-lineNumbers .cm-gutterElement": {
+            padding: "0 10px 0 8px",
+          },
+        }),
+      ],
+    }),
+  });
+  configEditorView.value = view;
+}
+
+function destroyConfigEditor() {
+  configEditorView.value?.destroy();
+  configEditorView.value = null;
+}
+
+async function refreshConfigEditor() {
+  destroyConfigEditor();
+  await mountConfigEditor();
+}
+
+function handleNacosSplitResized(payload: { panes?: { size: number }[] }) {
+  const size = payload.panes?.[0]?.size;
+  if (typeof size !== "number" || size < 20 || size > 80) return;
+  nacosSplitSize.value = size;
+  safeLocalStorageSet(NACOS_SPLIT_SIZE_KEY, String(size));
+}
+
+function inferConfigFormat(dataId: string): string {
+  const ext = dataId.trim().toLowerCase().split(".").pop() || "";
+  if (ext === "yml") return "yaml";
+  if (["yaml", "json", "xml", "html", "properties", "text"].includes(ext)) return ext;
+  if (ext === "txt") return "text";
+  return "";
+}
+
+function configFormatValue(item: Pick<NacosConfigItem, "dataId" | "configType">): string {
+  const value = normalizeConfigFormat(item.configType);
+  return value || inferConfigFormat(item.dataId);
+}
+
+function normalizeConfigFormat(value?: string): string {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return "";
+  if (normalized === "txt") return "text";
+  if (normalized === "yml") return "yaml";
+  if (normalized === "props") return "properties";
+  return normalized;
+}
+
+function normalizeConfigItemFormat<T extends NacosConfigItem>(item: T): T {
+  const value = normalizeConfigFormat(item.configType);
+  if (!value || value === item.configType) return item;
+  return { ...item, configType: value };
+}
+
+function configFormatCacheKey(key: { namespace?: string; dataId: string; group: string }): string {
+  return [props.connectionId, key.namespace || namespace.value || "", key.dataId, key.group || "DEFAULT_GROUP"].join("\u0000");
+}
+
+function rememberConfigFormat(item: { namespace?: string; dataId: string; group: string; configType?: string }) {
+  const value = configFormatValue(item);
+  if (!value) return;
+  knownConfigFormats.value = {
+    ...knownConfigFormats.value,
+    [configFormatCacheKey(item)]: value,
+  };
+}
+
+function applyKnownConfigFormats(items: NacosConfigItem[]): NacosConfigItem[] {
+  return items.map((item) => {
+    const existingFormat = configFormatValue(item);
+    if (existingFormat) {
+      rememberConfigFormat({ ...item, configType: existingFormat });
+      return item.configType === existingFormat ? item : { ...item, configType: existingFormat };
+    }
+    const knownFormat = knownConfigFormats.value[configFormatCacheKey(item)];
+    return knownFormat ? { ...item, configType: knownFormat } : item;
+  });
+}
+
+function configFormatDisplayLabel(value: string): string {
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) return "-";
+  if (normalized === "properties") return "Properties";
+  return normalized.toUpperCase();
+}
+
+function configFormatLabel(item: Pick<NacosConfigItem, "dataId" | "configType">): string {
+  return configFormatDisplayLabel(configFormatValue(item));
+}
+
+function delay(ms: number) {
+  return new Promise((resolve) => window.setTimeout(resolve, ms));
+}
+
+function isConnectionNotFoundError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /\bConnection not found\b/i.test(message);
+}
+
+function isSameConfigKey(item: NacosConfigItem, key: NacosConfigKey): boolean {
+  return (item.namespace || namespace.value || "") === (key.namespace || namespace.value || "") && item.dataId === key.dataId && item.group === key.group;
+}
+
+function upsertConfigInList(item: NacosConfigItem) {
+  item = normalizeConfigItemFormat(item);
+  const key = {
+    namespace: item.namespace || namespace.value || undefined,
+    dataId: item.dataId,
+    group: item.group,
+  };
+  const existingIndex = configs.value.findIndex((candidate) => isSameConfigKey(candidate, key));
+  if (existingIndex >= 0) {
+    configs.value.splice(existingIndex, 1, { ...configs.value[existingIndex], ...item });
+    return;
+  }
+  configs.value = [item, ...configs.value];
+  configTotal.value = Math.max(configTotal.value, configs.value.length);
+}
+
+async function loadInfo() {
+  infoLoading.value = true;
+  connectionError.value = "";
+  try {
+    connectionInfo.value = await api.nacosTestConnection(props.connectionId);
+  } catch (error) {
+    connectionError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    infoLoading.value = false;
+  }
+}
+
+async function loadConfigs(page = configPageNo.value) {
+  configLoading.value = true;
+  configError.value = "";
+  configPageNo.value = page;
+  try {
+    const result = await api.nacosListConfigs(props.connectionId, {
+      namespace: namespace.value || undefined,
+      group: configGroup.value.trim() || undefined,
+      dataId: configDataId.value.trim() || undefined,
+      appName: configAppName.value.trim() || undefined,
+      pageNo: configPageNo.value,
+      pageSize: configPageSize.value,
+    });
+    configs.value = applyKnownConfigFormats(result.items.map(normalizeConfigItemFormat));
+    configTotal.value = result.totalCount;
+  } catch (error) {
+    configError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    configLoading.value = false;
+  }
+}
+
+async function loadConfigsWithRetry(page = configPageNo.value) {
+  for (let attempt = 0; ; attempt += 1) {
+    await loadConfigs(page);
+    if (!isConnectionNotFoundError(configError.value) || attempt >= CONNECTION_NOT_FOUND_RETRY_DELAYS_MS.length) return;
+    await delay(CONNECTION_NOT_FOUND_RETRY_DELAYS_MS[attempt]);
+  }
+}
+
+async function selectConfig(item: NacosConfigItem) {
+  destroyConfigEditor();
+  configSaveNotice.value = "";
+  selectedConfigOriginalKey.value = {
+    namespace: item.namespace || namespace.value || undefined,
+    dataId: item.dataId,
+    group: item.group,
+  };
+  selectedConfig.value = item;
+  configContent.value = item.content || "";
+  originalConfigContent.value = configContent.value;
+  configType.value = configFormatValue(item) || "text";
+  try {
+    const detail = await api.nacosGetConfig(props.connectionId, {
+      namespace: item.namespace || namespace.value || undefined,
+      dataId: item.dataId,
+      group: item.group,
+    });
+    const normalizedDetail = normalizeConfigItemFormat(detail);
+    selectedConfig.value = normalizedDetail;
+    selectedConfigOriginalKey.value = {
+      namespace: normalizedDetail.namespace || item.namespace || namespace.value || undefined,
+      dataId: normalizedDetail.dataId || item.dataId,
+      group: normalizedDetail.group || item.group,
+    };
+    rememberConfigFormat({
+      ...normalizedDetail,
+      namespace: selectedConfigOriginalKey.value.namespace,
+      dataId: selectedConfigOriginalKey.value.dataId,
+      group: selectedConfigOriginalKey.value.group,
+    });
+    configContent.value = normalizedDetail.content || "";
+    originalConfigContent.value = configContent.value;
+    configType.value = configFormatValue(normalizedDetail) || configFormatValue(item) || "text";
+    await refreshConfigEditor();
+  } catch (error) {
+    configError.value = error instanceof Error ? error.message : String(error);
+    await refreshConfigEditor();
+  }
+}
+
+function newConfig() {
+  destroyConfigEditor();
+  configSaveNotice.value = "";
+  selectedConfigOriginalKey.value = null;
+  selectedConfig.value = {
+    namespace: namespace.value,
+    dataId: configDataId.value.trim(),
+    group: configGroup.value.trim() || "DEFAULT_GROUP",
+    configType: inferConfigFormat(configDataId.value) || "text",
+    content: "",
+    appName: "",
+    desc: "",
+    tags: "",
+  };
+  configContent.value = "";
+  originalConfigContent.value = "";
+  configType.value = selectedConfig.value.configType || "text";
+  configAdvancedOpen.value = false;
+  void mountConfigEditor();
+}
+
+function saveConfigAsCopy() {
+  if (!selectedConfig.value) return;
+  const copy = createNacosSaveAsCopy({ ...selectedConfig.value, content: configContent.value, configType: configType.value });
+  destroyConfigEditor();
+  selectedConfigOriginalKey.value = null;
+  selectedConfig.value = copy;
+  configContent.value = copy.content || "";
+  originalConfigContent.value = "";
+  configType.value = copy.configType || configType.value || "text";
+  configSaveNotice.value = "";
+  void mountConfigEditor();
+}
+
+async function copyConfigIdentity() {
+  if (!selectedConfig.value) return;
+  const view = configEditorView.value;
+  const selection = view?.state.sliceDoc(view.state.selection.main.from, view.state.selection.main.to) || "";
+  const text = resolveNacosConfigCopyText(selection, view?.state.doc.toString(), configContent.value);
+  try {
+    await copyToClipboard(text);
+    try {
+      const copiedText = await readTextFromClipboard();
+      if (copiedText !== text) {
+        throw new Error(t("nacos.copyVerifyFailed"));
+      }
+    } catch (verifyError) {
+      if (isTauriRuntime()) throw verifyError;
+    }
+    toast(t("nacos.copied"), 2000);
+  } catch (error) {
+    toast(t("grid.copyFailed", { message: error instanceof Error ? error.message : String(error) }), 5000);
+  }
+}
+
+async function downloadConfigText(content: string, fileName: string) {
+  const blob = new Blob([content], { type: "text/plain;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = fileName;
+  anchor.click();
+  URL.revokeObjectURL(url);
+}
+
+async function exportConfig() {
+  if (!selectedConfig.value) return;
+  const item = { ...selectedConfig.value, configType: configType.value };
+  const fileName = buildNacosConfigExportFileName(item);
+  try {
+    if (isTauriRuntime()) {
+      const { save } = await import("@tauri-apps/plugin-dialog");
+      const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+      const path = await save({
+        defaultPath: fileName,
+        filters: [{ name: configFormatDisplayLabel(configType.value || item.configType || "text"), extensions: [fileName.split(".").pop() || "txt"] }],
+      });
+      if (!path) return;
+      await writeTextFile(path, configContent.value);
+      toast(t("nacos.exportedTo", { path }), 2000);
+      return;
+    }
+    await downloadConfigText(configContent.value, fileName);
+    toast(t("nacos.exported"), 2000);
+  } catch (error) {
+    toast(t("nacos.exportFailed", { message: error instanceof Error ? error.message : String(error) }), 5000);
+  }
+}
+
+function historyKeyFor(item: NacosConfigHistoryItem) {
+  return {
+    namespace: item.namespace || namespace.value || undefined,
+    dataId: item.dataId,
+    group: item.group,
+    historyId: item.historyId,
+    nid: item.nid,
+  };
+}
+
+async function openConfigHistory() {
+  if (!selectedConfigOriginalKey.value || !selectedConfig.value) return;
+  historyOpen.value = true;
+  await loadConfigHistory(1);
+}
+
+async function loadConfigHistory(page = historyPageNo.value) {
+  if (!selectedConfigOriginalKey.value) return;
+  historyLoading.value = true;
+  historyError.value = "";
+  historyPageNo.value = page;
+  try {
+    const result = await api.nacosListConfigHistory(props.connectionId, {
+      ...selectedConfigOriginalKey.value,
+      pageNo: historyPageNo.value,
+      pageSize: historyPageSize.value,
+    });
+    historyItems.value = result.items;
+    historyTotal.value = result.totalCount;
+  } catch (error) {
+    historyError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    historyLoading.value = false;
+  }
+}
+
+async function loadHistoryDetail(item: NacosConfigHistoryItem): Promise<NacosConfigItem | null> {
+  try {
+    return await api.nacosGetConfigHistory(props.connectionId, historyKeyFor(item));
+  } catch (error) {
+    historyError.value = error instanceof Error ? error.message : String(error);
+    return null;
+  }
+}
+
+async function viewConfigHistory(item: NacosConfigHistoryItem) {
+  historyViewingItem.value = null;
+  await nextTick();
+  historyViewingItem.value = item;
+  historyViewingContent.value = "";
+  historyViewingLoading.value = true;
+  const detail = await loadHistoryDetail(item);
+  historyViewingContent.value = detail?.content || "";
+  historyViewingLoading.value = false;
+}
+
+function closeHistoryDetail() {
+  historyViewingItem.value = null;
+  historyViewingContent.value = "";
+  historyViewingLoading.value = false;
+}
+
+async function compareConfigHistory(item: NacosConfigHistoryItem) {
+  if (!selectedConfigOriginalKey.value) return;
+  historyCompareLoading.value = true;
+  historyCompareOpen.value = true;
+  historyCompareItem.value = item;
+  historyCompareCurrent.value = "";
+  historyCompareContent.value = "";
+  try {
+    const [current, history] = await Promise.all([api.nacosGetConfig(props.connectionId, selectedConfigOriginalKey.value), api.nacosGetConfigHistory(props.connectionId, historyKeyFor(item))]);
+    historyCompareCurrent.value = current.content || "";
+    historyCompareContent.value = history.content || "";
+  } catch (error) {
+    historyError.value = error instanceof Error ? error.message : String(error);
+    historyCompareOpen.value = false;
+  } finally {
+    historyCompareLoading.value = false;
+  }
+}
+
+function requestRollbackComparedHistory() {
+  if (!historyCompareItem.value || props.readOnly) return;
+  historyCompareOpen.value = false;
+  requestRollbackHistory(historyCompareItem.value);
+}
+
+function requestRollbackHistory(item: NacosConfigHistoryItem) {
+  if (props.readOnly) return;
+  pendingHistoryRollback.value = item;
+}
+
+async function rollbackConfigHistory() {
+  if (!pendingHistoryRollback.value || props.readOnly) return;
+  rollingBackHistory.value = true;
+  try {
+    await api.nacosRollbackConfig(props.connectionId, historyKeyFor(pendingHistoryRollback.value));
+    pendingHistoryRollback.value = null;
+    configSaveNotice.value = t("nacos.rollbackSuccess");
+    if (selectedConfigOriginalKey.value) {
+      const detail = await api.nacosGetConfig(props.connectionId, selectedConfigOriginalKey.value);
+      const normalizedDetail = normalizeConfigItemFormat(detail);
+      selectedConfig.value = normalizedDetail;
+      configContent.value = normalizedDetail.content || "";
+      originalConfigContent.value = configContent.value;
+      configType.value = configFormatValue(normalizedDetail) || "text";
+      await refreshConfigEditor();
+    }
+    await Promise.all([loadConfigs(configPageNo.value), loadConfigHistory(historyPageNo.value)]);
+  } catch (error) {
+    historyError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    rollingBackHistory.value = false;
+  }
+}
+
+async function setConfigFormat(format: string) {
+  configType.value = format;
+  if (selectedConfig.value) selectedConfig.value.configType = format;
+  if (selectedConfigOriginalKey.value) rememberConfigFormat({ ...selectedConfigOriginalKey.value, configType: format });
+  configSaveNotice.value = "";
+  await refreshConfigEditor();
+}
+
+function requestSaveConfig() {
+  if (!selectedConfig.value || props.readOnly) return;
+  if (!isCreatingConfig.value && configContent.value !== originalConfigContent.value) {
+    pendingConfigSave.value = true;
+    return;
+  }
+  void saveConfig();
+}
+
+async function saveConfig() {
+  if (!selectedConfig.value || props.readOnly) return;
+  pendingConfigSave.value = false;
+  const originalKey = selectedConfigOriginalKey.value;
+  const wasCreating = !originalKey;
+  const dataId = selectedConfig.value.dataId.trim();
+  const group = selectedConfig.value.group.trim() || "DEFAULT_GROUP";
+  if (!dataId) {
+    configError.value = t("nacos.dataIdRequired");
+    return;
+  }
+  savingConfig.value = true;
+  configError.value = "";
+  configSaveNotice.value = "";
+  try {
+    await api.nacosPublishConfig(props.connectionId, {
+      namespace: originalKey?.namespace || selectedConfig.value.namespace || namespace.value || undefined,
+      dataId,
+      group,
+      content: configContent.value,
+      configType: configType.value || undefined,
+      appName: selectedConfig.value.appName,
+      desc: selectedConfig.value.desc,
+      tags: selectedConfig.value.tags,
+    });
+    const savedConfig = { ...selectedConfig.value, dataId, group, content: configContent.value, configType: configType.value };
+    selectedConfig.value = savedConfig;
+    rememberConfigFormat({ ...savedConfig, namespace: savedConfig.namespace || namespace.value || undefined });
+    originalConfigContent.value = configContent.value;
+    selectedConfigOriginalKey.value = {
+      namespace: savedConfig.namespace || namespace.value || undefined,
+      dataId,
+      group,
+    };
+    configAdvancedOpen.value = false;
+    configSaveNotice.value = t(wasCreating ? "nacos.createdAndLoaded" : "nacos.savedAndLoaded", { dataId });
+    toast(t("nacos.saved"), 2000);
+    await loadConfigsWithRetry(wasCreating ? 1 : configPageNo.value);
+    upsertConfigInList(savedConfig);
+  } catch (error) {
+    configError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    savingConfig.value = false;
+  }
+}
+
+function requestDeleteConfig() {
+  if (!selectedConfig.value || props.readOnly) return;
+  pendingDeleteConfig.value = selectedConfig.value;
+}
+
+async function deleteConfig() {
+  const key = selectedConfigKey.value;
+  if (!key || props.readOnly) return;
+  deletingConfig.value = true;
+  configError.value = "";
+  configSaveNotice.value = "";
+  try {
+    await api.nacosDeleteConfig(props.connectionId, key);
+    selectedConfig.value = null;
+    selectedConfigOriginalKey.value = null;
+    configContent.value = "";
+    originalConfigContent.value = "";
+    pendingDeleteConfig.value = null;
+    destroyConfigEditor();
+    await loadConfigs();
+    toast(t("nacos.deleted"), 2000);
+  } catch (error) {
+    configError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    deletingConfig.value = false;
+  }
+}
+
+async function loadServices(page = servicePageNo.value) {
+  servicesLoading.value = true;
+  servicesError.value = "";
+  servicePageNo.value = page;
+  try {
+    const result = await api.nacosListServices(props.connectionId, {
+      namespace: namespace.value || undefined,
+      groupName: serviceGroup.value.trim() || undefined,
+      serviceName: serviceName.value.trim() || undefined,
+      pageNo: servicePageNo.value,
+      pageSize: servicePageSize.value,
+    });
+    services.value = result.items;
+    serviceTotal.value = result.totalCount;
+  } catch (error) {
+    servicesError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    servicesLoading.value = false;
+  }
+}
+
+async function loadServicesWithRetry(page = servicePageNo.value) {
+  for (let attempt = 0; ; attempt += 1) {
+    await loadServices(page);
+    if (!isConnectionNotFoundError(servicesError.value) || attempt >= CONNECTION_NOT_FOUND_RETRY_DELAYS_MS.length) return;
+    await delay(CONNECTION_NOT_FOUND_RETRY_DELAYS_MS[attempt]);
+  }
+}
+
+async function selectService(service: NacosServiceInfo) {
+  selectedService.value = service;
+  await loadInstances();
+}
+
+async function loadInstances() {
+  if (!selectedService.value) return;
+  instancesLoading.value = true;
+  instancesError.value = "";
+  try {
+    instances.value = await api.nacosListInstances(props.connectionId, {
+      namespace: namespace.value || undefined,
+      serviceName: selectedService.value.serviceName,
+      groupName: selectedService.value.groupName || serviceGroup.value || undefined,
+      clusters: serviceCluster.value.trim() || undefined,
+    });
+  } catch (error) {
+    instancesError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    instancesLoading.value = false;
+  }
+}
+
+function requestUpdateInstance(instance: NacosInstanceInfo, patch: Partial<NacosInstanceInfo>) {
+  if (!selectedService.value || props.readOnly) return;
+  pendingInstanceUpdate.value = { instance, patch };
+}
+
+async function updateInstance(instance: NacosInstanceInfo, patch: Partial<NacosInstanceInfo>) {
+  if (!selectedService.value || props.readOnly) return;
+  updatingInstanceKey.value = `${instance.ip}:${instance.port}`;
+  try {
+    await api.nacosUpdateInstance(props.connectionId, {
+      namespace: namespace.value || undefined,
+      serviceName: selectedService.value.serviceName,
+      groupName: instance.groupName || selectedService.value.groupName || serviceGroup.value || undefined,
+      clusterName: instance.clusterName,
+      ip: instance.ip,
+      port: instance.port,
+      healthy: patch.healthy ?? instance.healthy,
+      enabled: patch.enabled ?? instance.enabled,
+      ephemeral: patch.ephemeral ?? instance.ephemeral,
+      weight: patch.weight ?? instance.weight,
+      metadata: instance.metadata,
+    });
+    pendingInstanceUpdate.value = null;
+    await loadInstances();
+  } catch (error) {
+    instancesError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    updatingInstanceKey.value = "";
+  }
+}
+
+watch(historyCompareOpen, (value) => {
+  if (!value && !historyCompareLoading.value) historyCompareItem.value = null;
+});
+
+watch(
+  [() => settingsStore.editorSettings, () => isDark.value, () => themePalette.value],
+  async ([settings]) => {
+    const view = configEditorView.value;
+    if (!view) return;
+    const [{ EditorView }, theme] = await Promise.all([import("@codemirror/view"), loadEditorTheme(settings.theme, editorThemeAppearance(), currentCustomThemeColors(), themePalette.value)]);
+    if (configEditorView.value !== view) return;
+    view.dispatch({
+      effects: [configEditorTheme.reconfigure(theme), configEditorFontTheme.reconfigure(editorFontTheme(EditorView, settings.fontSize, settings.fontFamily, { fixedHeight: true, scrollable: true }))],
+    });
+  },
+  { deep: true },
+);
+
+watch(
+  () => [props.connectionId, props.namespace] as const,
+  async () => {
+    selectedConfig.value = null;
+    selectedConfigOriginalKey.value = null;
+    configContent.value = "";
+    originalConfigContent.value = "";
+    destroyConfigEditor();
+    selectedService.value = null;
+    try {
+      await connectionStore.ensureConnected(props.connectionId);
+    } catch (e) {
+      console.warn("[DBX] ensureConnected failed for", props.connectionId, e);
+    }
+    await loadInfo();
+    await Promise.all([loadConfigsWithRetry(1), loadServicesWithRetry(1)]);
+  },
+);
+
+onMounted(async () => {
+  try {
+    await connectionStore.ensureConnected(props.connectionId);
+  } catch (e) {
+    console.warn("[DBX] ensureConnected failed for", props.connectionId, e);
+  }
+  await loadInfo();
+  await Promise.all([loadConfigsWithRetry(1), loadServicesWithRetry(1)]);
+});
+
+onBeforeUnmount(() => {
+  destroyConfigEditor();
+});
+</script>
+
+<template>
+  <div class="flex h-full min-h-0 flex-col bg-background">
+    <div class="flex shrink-0 items-center justify-between gap-3 border-b px-3 py-2">
+      <div class="flex min-w-0 items-center gap-2 text-sm">
+        <Network class="h-4 w-4 text-sky-600" />
+        <span class="truncate font-medium">{{ connectionInfo?.displayServerAddr || connectionInfo?.serverAddr || "Nacos" }}</span>
+        <Badge v-if="connectionInfo?.serverVersion" variant="secondary">{{ connectionInfo.serverVersion }}</Badge>
+        <Badge variant="outline">{{ namespaceLabel }}</Badge>
+        <Badge v-if="namespaceIdLabel" variant="outline" class="max-w-72 truncate font-mono">{{ namespaceIdLabel }}</Badge>
+        <Badge v-if="readOnly" variant="outline">{{ t("nacos.readOnly") }}</Badge>
+      </div>
+      <div class="flex items-center gap-2">
+        <span v-if="connectionError" class="max-w-96 truncate text-xs text-destructive">{{ connectionError }}</span>
+        <Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="infoLoading" @click="loadInfo">
+          <Loader2 v-if="infoLoading" class="h-3.5 w-3.5 animate-spin" />
+          <RefreshCw v-else class="h-3.5 w-3.5" />
+          {{ t("nacos.test") }}
+        </Button>
+      </div>
+    </div>
+
+    <div class="flex shrink-0 items-center gap-1 border-b px-3 py-1.5">
+      <button class="rounded px-3 py-1.5 text-sm" :class="activeTab === 'configs' ? 'bg-accent font-medium' : 'text-muted-foreground hover:bg-accent/60'" @click="activeTab = 'configs'">{{ t("nacos.configs") }}</button>
+      <button class="rounded px-3 py-1.5 text-sm" :class="activeTab === 'services' ? 'bg-accent font-medium' : 'text-muted-foreground hover:bg-accent/60'" @click="activeTab = 'services'">{{ t("nacos.services") }}</button>
+    </div>
+
+    <Splitpanes v-if="activeTab === 'configs'" class="nacos-admin-splitpanes min-h-0 flex-1" @resized="handleNacosSplitResized">
+      <Pane :size="nacosSplitSize" min-size="24">
+        <div class="flex h-full min-h-0 flex-col">
+          <div class="grid shrink-0 grid-cols-[minmax(0,1fr)_minmax(0,1fr)_minmax(0,1fr)_auto_auto] gap-2 border-b p-2">
+            <Input v-model="configDataId" class="h-8 min-w-0" placeholder="dataId" @keyup.enter="loadConfigsWithRetry(1)" />
+            <Input v-model="configGroup" class="h-8 min-w-0" :placeholder="t('nacos.allGroups')" @keyup.enter="loadConfigsWithRetry(1)" />
+            <Input v-model="configAppName" class="h-8 min-w-0" :placeholder="t('nacos.application')" @keyup.enter="loadConfigsWithRetry(1)" />
+            <Button size="sm" variant="outline" class="h-8 w-9 px-0" :title="t('nacos.load')" :disabled="configLoading" @click="loadConfigsWithRetry(1)">
+              <Loader2 v-if="configLoading" class="h-3.5 w-3.5 animate-spin" />
+              <RefreshCw v-else class="h-3.5 w-3.5" />
+            </Button>
+            <Button size="sm" class="h-8 w-9 px-0" :disabled="readOnly" @click="newConfig">
+              <Plus class="h-3.5 w-3.5" />
+            </Button>
+          </div>
+          <div v-if="configError" class="border-b px-3 py-2 text-xs text-destructive">{{ configError }}</div>
+          <div class="min-h-0 flex-1 overflow-auto">
+            <div class="min-w-max" :style="{ minWidth: configListMinWidth }">
+              <div class="sticky top-0 z-20 grid border-b bg-muted px-3 py-2 text-[11px] font-medium uppercase tracking-wide text-muted-foreground shadow-sm" :style="{ gridTemplateColumns: configListGridTemplate }">
+                <div class="relative min-w-0 border-r border-border/70 pr-3 last:border-r-0">
+                  <span class="block truncate">dataID</span>
+                  <div data-column-resize-handle class="absolute -right-1 top-0 z-10 h-full w-2 cursor-col-resize" :class="configListResizingColumnIndex === 0 ? 'bg-primary/10' : ''" @mousedown="onConfigListColumnResizeStart(0, $event)" />
+                </div>
+                <div class="relative min-w-0 border-r border-border/70 pr-3 last:border-r-0">
+                  <span class="block truncate">{{ t("nacos.group") }}</span>
+                  <div data-column-resize-handle class="absolute -right-1 top-0 z-10 h-full w-2 cursor-col-resize" :class="configListResizingColumnIndex === 1 ? 'bg-primary/10' : ''" @mousedown="onConfigListColumnResizeStart(1, $event)" />
+                </div>
+                <div class="relative min-w-0 border-r border-border/70 pr-3 last:border-r-0">
+                  <span class="block truncate">{{ t("nacos.application") }}</span>
+                  <div data-column-resize-handle class="absolute -right-1 top-0 z-10 h-full w-2 cursor-col-resize" :class="configListResizingColumnIndex === 2 ? 'bg-primary/10' : ''" @mousedown="onConfigListColumnResizeStart(2, $event)" />
+                </div>
+                <div class="relative min-w-0 border-r border-border/70 pr-3 last:border-r-0">
+                  <span class="block truncate">{{ t("nacos.format") }}</span>
+                  <div data-column-resize-handle class="absolute -right-1 top-0 z-10 h-full w-2 cursor-col-resize" :class="configListResizingColumnIndex === 3 ? 'bg-primary/10' : ''" @mousedown="onConfigListColumnResizeStart(3, $event)" />
+                </div>
+              </div>
+              <button
+                v-for="item in configs"
+                :key="`${item.namespace}:${item.group}:${item.dataId}`"
+                type="button"
+                class="grid w-full items-center border-b px-3 py-2.5 text-left text-sm transition-colors hover:bg-accent/50"
+                :class="{ 'bg-accent': selectedConfig?.dataId === item.dataId && selectedConfig?.group === item.group }"
+                :style="{ gridTemplateColumns: configListGridTemplate }"
+                @click="selectConfig(item)"
+              >
+                <span class="flex min-w-0 items-center gap-2 border-r border-border/50 pr-3 last:border-r-0" :title="item.dataId">
+                  <FileText class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+                  <span class="truncate font-medium text-foreground">{{ item.dataId }}</span>
+                </span>
+                <span class="truncate border-r border-border/50 pr-3 text-xs text-muted-foreground last:border-r-0" :title="item.group || 'DEFAULT_GROUP'">{{ item.group || "DEFAULT_GROUP" }}</span>
+                <span class="truncate border-r border-border/50 pr-3 text-xs text-muted-foreground last:border-r-0" :title="item.appName || '-'">{{ item.appName || "-" }}</span>
+                <span class="truncate text-xs text-muted-foreground" :title="configFormatLabel(item)">{{ configFormatLabel(item) }}</span>
+              </button>
+            </div>
+            <div v-if="!configLoading && configs.length === 0" class="flex h-full items-center justify-center text-sm text-muted-foreground">{{ t("nacos.noConfigs") }}</div>
+          </div>
+          <div class="flex shrink-0 items-center justify-between border-t px-3 py-2 text-xs text-muted-foreground">
+            <span>{{ t("nacos.total", { count: configTotal }) }}</span>
+            <div class="flex items-center gap-2">
+              <Button size="sm" variant="outline" class="h-7" :disabled="configPageNo <= 1 || configLoading" @click="loadConfigs(configPageNo - 1)">{{ t("nacos.prev") }}</Button>
+              <span>{{ configPageNo }} / {{ configTotalPages }}</span>
+              <Button size="sm" variant="outline" class="h-7" :disabled="configPageNo >= configTotalPages || configLoading" @click="loadConfigs(configPageNo + 1)">{{ t("nacos.next") }}</Button>
+            </div>
+          </div>
+        </div>
+      </Pane>
+
+      <Pane :size="100 - nacosSplitSize" min-size="20">
+        <div class="flex h-full min-h-0 flex-col">
+          <div v-if="selectedConfig" class="shrink-0 border-b p-3">
+            <div class="grid grid-cols-[96px_minmax(0,1fr)] items-center gap-x-3 gap-y-2">
+              <Label class="text-right text-xs text-muted-foreground">{{ t("nacos.namespace") }}</Label>
+              <div class="truncate text-sm font-medium">{{ namespaceLabel }}</div>
+
+              <Label class="text-right text-xs">
+                <span class="text-destructive">*</span>
+                {{ t("nacos.dataId") }}
+              </Label>
+              <Input v-model="selectedConfig.dataId" class="h-8" :readonly="!isCreatingConfig" :class="{ 'bg-muted text-muted-foreground': !isCreatingConfig }" @input="configSaveNotice = ''" />
+
+              <Label class="text-right text-xs">
+                <span class="text-destructive">*</span>
+                {{ t("nacos.group") }}
+              </Label>
+              <Input v-model="selectedConfig.group" class="h-8" :readonly="!isCreatingConfig" :class="{ 'bg-muted text-muted-foreground': !isCreatingConfig }" @input="configSaveNotice = ''" />
+
+              <span />
+              <button type="button" class="w-fit text-xs font-medium text-primary hover:underline" @click="configAdvancedOpen = !configAdvancedOpen">
+                {{ configAdvancedOpen ? t("nacos.collapse") : t("nacos.advanced") }}
+              </button>
+
+              <template v-if="configAdvancedOpen">
+                <Label class="text-right text-xs text-muted-foreground">{{ t("nacos.tags") }}</Label>
+                <Input v-model="selectedConfig.tags" class="h-8" placeholder="tag1,tag2" @input="configSaveNotice = ''" />
+
+                <Label class="text-right text-xs text-muted-foreground">{{ t("nacos.application") }}</Label>
+                <Input v-model="selectedConfig.appName" class="h-8" @input="configSaveNotice = ''" />
+
+                <Label class="text-right text-xs text-muted-foreground">{{ t("nacos.description") }}</Label>
+                <Input v-model="selectedConfig.desc" class="h-8" @input="configSaveNotice = ''" />
+              </template>
+
+              <Label class="text-right text-xs">
+                <span class="text-destructive">*</span>
+                {{ t("nacos.format") }}
+              </Label>
+              <div class="flex min-w-0 flex-wrap gap-2">
+                <button
+                  v-for="format in configFormatOptions"
+                  :key="format"
+                  type="button"
+                  class="rounded-md border px-2.5 py-1 text-xs font-medium transition-colors"
+                  :class="configType === format ? 'border-primary bg-primary text-primary-foreground' : 'border-border bg-background hover:bg-accent'"
+                  @click="setConfigFormat(format)"
+                >
+                  {{ configFormatDisplayLabel(format) }}
+                </button>
+              </div>
+            </div>
+            <div class="mt-3 flex items-center justify-between gap-3">
+              <div v-if="configSaveNotice" class="flex min-w-0 items-center gap-1.5 text-xs text-emerald-600">
+                <CheckCircle2 class="h-3.5 w-3.5 shrink-0" />
+                <span class="truncate">{{ configSaveNotice }}</span>
+              </div>
+              <span v-else />
+              <div class="flex shrink-0 gap-2">
+                <Button size="sm" variant="outline" class="h-8 gap-1.5" @click="copyConfigIdentity">
+                  <Clipboard class="h-3.5 w-3.5" />
+                  {{ t("nacos.copy") }}
+                </Button>
+                <Button size="sm" variant="outline" class="h-8 gap-1.5" @click="exportConfig">
+                  <Download class="h-3.5 w-3.5" />
+                  {{ t("nacos.export") }}
+                </Button>
+                <Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="!selectedConfigOriginalKey" @click="openConfigHistory">
+                  <FileClock class="h-3.5 w-3.5" />
+                  {{ t("nacos.history") }}
+                </Button>
+                <Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="readOnly" @click="saveConfigAsCopy">
+                  <Save class="h-3.5 w-3.5" />
+                  {{ t("nacos.saveAs") }}
+                </Button>
+                <Button size="sm" class="h-8 gap-1.5" :disabled="readOnly || savingConfig || !isConfigDirty" @click="requestSaveConfig">
+                  <Loader2 v-if="savingConfig" class="h-3.5 w-3.5 animate-spin" />
+                  <Send v-else class="h-3.5 w-3.5" />
+                  {{ savingConfig ? t("nacos.saving") : t("nacos.save") }}
+                </Button>
+                <Button size="sm" variant="outline" class="h-8" :disabled="readOnly || deletingConfig" @click="requestDeleteConfig">
+                  <Loader2 v-if="deletingConfig" class="h-3.5 w-3.5 animate-spin" />
+                  <Trash2 v-else class="h-3.5 w-3.5" />
+                </Button>
+              </div>
+            </div>
+          </div>
+          <div v-if="selectedConfig" class="relative min-h-0 flex-1 overflow-hidden bg-background">
+            <div ref="configEditorHost" class="nacos-config-editor h-full min-h-0 overflow-hidden" />
+            <EditorSearchPanel ref="configSearchPanelRef" :view="configEditorView" tone="editor" />
+          </div>
+          <div v-else class="flex h-full items-center justify-center text-sm text-muted-foreground">{{ t("nacos.selectConfig") }}</div>
+        </div>
+      </Pane>
+    </Splitpanes>
+
+    <Splitpanes v-else-if="activeTab === 'services'" class="nacos-admin-splitpanes min-h-0 flex-1" @resized="handleNacosSplitResized">
+      <Pane :size="nacosSplitSize" min-size="24">
+        <div class="flex h-full min-h-0 flex-col">
+          <div class="grid shrink-0 grid-cols-[minmax(0,1fr)_minmax(0,1fr)_minmax(0,1fr)_auto] gap-2 border-b p-2">
+            <Input v-model="serviceName" class="h-8 min-w-0" :placeholder="t('nacos.service')" @keyup.enter="loadServicesWithRetry(1)" />
+            <Input v-model="serviceGroup" class="h-8 min-w-0" :placeholder="t('nacos.allGroups')" @keyup.enter="loadServicesWithRetry(1)" />
+            <Input v-model="serviceCluster" class="h-8 min-w-0" :placeholder="t('nacos.cluster')" @keyup.enter="loadInstances" />
+            <Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="servicesLoading" @click="loadServicesWithRetry(1)">
+              <Loader2 v-if="servicesLoading" class="h-3.5 w-3.5 animate-spin" />
+              <RefreshCw v-else class="h-3.5 w-3.5" />
+              {{ t("nacos.load") }}
+            </Button>
+          </div>
+          <div v-if="servicesError" class="border-b px-3 py-2 text-xs text-destructive">{{ servicesError }}</div>
+          <div class="min-h-0 flex-1 overflow-auto">
+            <button
+              v-for="service in services"
+              :key="`${service.groupName}:${service.serviceName}`"
+              type="button"
+              class="grid w-full gap-1 border-b px-3 py-2 text-left text-sm hover:bg-accent/60"
+              :class="{ 'bg-accent': selectedService?.serviceName === service.serviceName && selectedService?.groupName === service.groupName }"
+              @click="selectService(service)"
+            >
+              <span class="truncate font-medium">{{ service.serviceName }}</span>
+              <span class="flex items-center gap-2 text-xs text-muted-foreground">
+                <Server class="h-3.5 w-3.5" />
+                {{ service.groupName || serviceGroup }}
+                <span v-if="service.ipCount != null">· {{ t("nacos.instanceCount", { count: service.ipCount }) }}</span>
+              </span>
+            </button>
+            <div v-if="!servicesLoading && services.length === 0" class="flex h-full items-center justify-center text-sm text-muted-foreground">{{ t("nacos.noServices") }}</div>
+          </div>
+          <div class="flex shrink-0 items-center justify-between border-t px-3 py-2 text-xs text-muted-foreground">
+            <span>{{ t("nacos.total", { count: serviceTotal }) }}</span>
+            <div class="flex items-center gap-2">
+              <Button size="sm" variant="outline" class="h-7" :disabled="servicePageNo <= 1 || servicesLoading" @click="loadServices(servicePageNo - 1)">{{ t("nacos.prev") }}</Button>
+              <span>{{ servicePageNo }} / {{ serviceTotalPages }}</span>
+              <Button size="sm" variant="outline" class="h-7" :disabled="servicePageNo >= serviceTotalPages || servicesLoading" @click="loadServices(servicePageNo + 1)">{{ t("nacos.next") }}</Button>
+            </div>
+          </div>
+        </div>
+      </Pane>
+
+      <Pane :size="100 - nacosSplitSize" min-size="20">
+        <div class="flex h-full min-h-0 flex-col">
+          <div class="flex shrink-0 items-center justify-between border-b px-3 py-2">
+            <div class="truncate text-sm font-medium">{{ selectedService?.serviceName || t("nacos.instances") }}</div>
+            <Button size="sm" variant="outline" class="h-8 gap-1.5" :disabled="!selectedService || instancesLoading" @click="loadInstances">
+              <Loader2 v-if="instancesLoading" class="h-3.5 w-3.5 animate-spin" />
+              <RefreshCw v-else class="h-3.5 w-3.5" />
+              {{ t("nacos.refresh") }}
+            </Button>
+          </div>
+          <div v-if="instancesError" class="border-b px-3 py-2 text-xs text-destructive">{{ instancesError }}</div>
+          <div class="min-h-0 flex-1 overflow-auto">
+            <table v-if="instances.length" class="w-full text-left text-sm">
+              <thead class="sticky top-0 bg-muted/80 text-xs text-muted-foreground">
+                <tr>
+                  <th class="px-3 py-2 font-medium">{{ t("nacos.address") }}</th>
+                  <th class="px-3 py-2 font-medium">{{ t("nacos.cluster") }}</th>
+                  <th class="px-3 py-2 font-medium">{{ t("nacos.weight") }}</th>
+                  <th class="px-3 py-2 font-medium">metadata</th>
+                  <th class="px-3 py-2 font-medium">{{ t("nacos.state") }}</th>
+                  <th class="px-3 py-2 text-right font-medium">{{ t("nacos.actions") }}</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr v-for="instance in instances" :key="`${instance.ip}:${instance.port}`" class="border-b">
+                  <td class="px-3 py-2 font-mono text-xs">{{ instance.ip }}:{{ instance.port }}</td>
+                  <td class="px-3 py-2">{{ instance.clusterName || "-" }}</td>
+                  <td class="px-3 py-2">
+                    <Input
+                      :model-value="instance.weight ?? 1"
+                      type="number"
+                      min="0"
+                      step="0.1"
+                      class="h-7 w-20 text-xs"
+                      :disabled="readOnly || updatingInstanceKey === `${instance.ip}:${instance.port}`"
+                      @change="(event: Event) => requestUpdateInstance(instance, { weight: Number((event.target as HTMLInputElement).value) })"
+                    />
+                  </td>
+                  <td class="max-w-56 truncate px-3 py-2 font-mono text-xs" :title="JSON.stringify(instance.metadata ?? null)">{{ JSON.stringify(instance.metadata ?? null) }}</td>
+                  <td class="px-3 py-2">
+                    <div class="flex flex-wrap gap-1">
+                      <Badge :variant="instance.healthy === false ? 'outline' : 'secondary'">{{ instance.healthy === false ? t("nacos.unhealthy") : t("nacos.healthy") }}</Badge>
+                      <Badge :variant="instance.enabled === false ? 'outline' : 'secondary'">{{ instance.enabled === false ? t("nacos.offline") : t("nacos.enabled") }}</Badge>
+                      <Badge v-if="instance.ephemeral != null" variant="outline">{{ instance.ephemeral ? t("nacos.ephemeral") : t("nacos.persistent") }}</Badge>
+                    </div>
+                  </td>
+                  <td class="px-3 py-2 text-right">
+                    <div class="inline-flex gap-2">
+                      <Button size="sm" variant="outline" class="h-7 gap-1" :disabled="readOnly || updatingInstanceKey === `${instance.ip}:${instance.port}`" @click="requestUpdateInstance(instance, { enabled: !instance.enabled })">
+                        <Loader2 v-if="updatingInstanceKey === `${instance.ip}:${instance.port}`" class="h-3 w-3 animate-spin" />
+                        {{ instance.enabled === false ? t("nacos.enable") : t("nacos.disable") }}
+                      </Button>
+                      <Button size="sm" variant="outline" class="h-7" :disabled="readOnly || updatingInstanceKey === `${instance.ip}:${instance.port}`" @click="requestUpdateInstance(instance, { healthy: !instance.healthy })">
+                        {{ instance.healthy === false ? t("nacos.markHealthy") : t("nacos.markUnhealthy") }}
+                      </Button>
+                    </div>
+                  </td>
+                </tr>
+              </tbody>
+            </table>
+            <div v-else class="flex h-full items-center justify-center text-sm text-muted-foreground">{{ t("nacos.selectService") }}</div>
+          </div>
+        </div>
+      </Pane>
+    </Splitpanes>
+
+    <NacosConfigDiffDialog v-model:open="pendingConfigSave" :before="originalConfigContent" :after="configContent" :loading="savingConfig" @confirm="saveConfig" />
+
+    <NacosConfigHistoryDialog
+      v-model:open="historyOpen"
+      :config="selectedConfig"
+      :items="historyItems"
+      :loading="historyLoading"
+      :error="historyError"
+      :page-no="historyPageNo"
+      :page-size="historyPageSize"
+      :total-count="historyTotal"
+      :read-only="readOnly"
+      :viewing-item="historyViewingItem"
+      :viewing-content="historyViewingContent"
+      :viewing-loading="historyViewingLoading"
+      @load="loadConfigHistory"
+      @view="viewConfigHistory"
+      @close-detail="closeHistoryDetail"
+      @compare="compareConfigHistory"
+      @rollback="requestRollbackHistory"
+    />
+
+    <NacosConfigDiffDialog
+      v-model:open="historyCompareOpen"
+      :title="t('nacos.historyCompareTitle')"
+      :before-label="t('nacos.currentPublishedContent')"
+      :after-label="t('nacos.historyVersionContent')"
+      :before="historyCompareCurrent"
+      :after="historyCompareContent"
+      :loading="historyCompareLoading"
+      :show-confirm="!readOnly"
+      :confirm-label="t('nacos.rollback')"
+      confirm-variant="destructive"
+      @confirm="requestRollbackComparedHistory"
+    />
+
+    <DangerConfirmDialog
+      :open="!!pendingDeleteConfig"
+      :title="t('nacos.confirmDeleteTitle')"
+      :message="t('nacos.confirmDeleteMessage')"
+      :details="pendingDeleteDetails"
+      :confirm-label="t('nacos.delete')"
+      :loading="deletingConfig"
+      :close-on-confirm="false"
+      @update:open="
+        (value: boolean) => {
+          if (!value && !deletingConfig) pendingDeleteConfig = null;
+        }
+      "
+      @confirm="deleteConfig"
+    />
+
+    <DangerConfirmDialog
+      :open="!!pendingHistoryRollback"
+      :title="t('nacos.confirmRollbackTitle')"
+      :message="t('nacos.confirmRollbackMessage')"
+      :details="pendingHistoryRollbackDetails"
+      :confirm-label="t('nacos.rollback')"
+      :loading="rollingBackHistory"
+      :close-on-confirm="false"
+      @update:open="
+        (value: boolean) => {
+          if (!value && !rollingBackHistory) pendingHistoryRollback = null;
+        }
+      "
+      @confirm="rollbackConfigHistory"
+    />
+
+    <DangerConfirmDialog
+      :open="!!pendingInstanceUpdate"
+      :title="t('nacos.confirmInstanceTitle')"
+      :message="t('nacos.confirmInstanceMessage')"
+      :details="pendingInstanceDetails"
+      :confirm-label="t('dangerDialog.confirm')"
+      :loading="!!updatingInstanceKey"
+      :close-on-confirm="false"
+      @update:open="
+        (value: boolean) => {
+          if (!value && !updatingInstanceKey) pendingInstanceUpdate = null;
+        }
+      "
+      @confirm="pendingInstanceUpdate && updateInstance(pendingInstanceUpdate.instance, pendingInstanceUpdate.patch)"
+    />
+  </div>
+</template>
+
+<style scoped>
+.nacos-config-editor :deep(.cm-content),
+.nacos-config-editor :deep(.cm-line) {
+  cursor: text;
+  user-select: text !important;
+  -webkit-user-select: text !important;
+}
+
+.nacos-config-editor :deep(.cm-selectionBackground),
+.nacos-config-editor :deep(.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground),
+.nacos-config-editor :deep(.cm-trimmedSelection) {
+  display: block !important;
+  background: var(--dbx-editor-selection-background, rgba(59, 130, 246, 0.35)) !important;
+}
+
+.nacos-config-editor :deep(.cm-content ::selection) {
+  background: var(--dbx-editor-selection-background, rgba(59, 130, 246, 0.35)) !important;
+}
+
+.nacos-admin-splitpanes :deep(.splitpanes--vertical > .splitpanes__splitter) {
+  width: 4px !important;
+  border-left: 1px solid var(--border);
+  background: transparent;
+  cursor: col-resize;
+}
+
+.nacos-admin-splitpanes :deep(.splitpanes__splitter:hover) {
+  background: oklch(0.6 0.15 250) !important;
+}
+</style>
diff --git a/apps/desktop/src/components/nacos/NacosConfigDiffDialog.vue b/apps/desktop/src/components/nacos/NacosConfigDiffDialog.vue
new file mode 100644
index 0000000..b88ece3
--- /dev/null
+++ b/apps/desktop/src/components/nacos/NacosConfigDiffDialog.vue
@@ -0,0 +1,209 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { Loader2 } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { buildNacosInlineDiff, buildNacosSideBySideDiff, summarizeNacosConfigDiff, type NacosDiffLineType, type NacosInlineSegment } from "@/lib/nacos/nacosAdmin";
+
+const open = defineModel<boolean>("open", { default: false });
+
+const props = withDefaults(
+  defineProps<{
+    before: string;
+    after: string;
+    title?: string;
+    beforeLabel?: string;
+    afterLabel?: string;
+    confirmLabel?: string;
+    confirmVariant?: "default" | "destructive";
+    showConfirm?: boolean;
+    loading?: boolean;
+  }>(),
+  {
+    title: "",
+    beforeLabel: "",
+    afterLabel: "",
+    confirmLabel: "",
+    confirmVariant: "default",
+    showConfirm: true,
+    loading: false,
+  },
+);
+
+const emit = defineEmits<{
+  confirm: [];
+}>();
+
+const { t } = useI18n();
+const inlineCompare = ref(false);
+const rows = computed(() => buildNacosSideBySideDiff(props.before, props.after));
+const inlineRows = computed(() => buildNacosInlineDiff(props.before, props.after));
+const summary = computed(() => summarizeNacosConfigDiff(props.before, props.after));
+
+const dialogOpen = computed({
+  get: () => open.value,
+  set: (value) => {
+    if (props.loading && !value) return;
+    open.value = value;
+  },
+});
+
+function lineClass(type: NacosDiffLineType, side: "left" | "right") {
+  return {
+    "bg-red-500/20 text-red-50": type === "delete" || (type === "modify" && side === "left"),
+    "bg-emerald-500/18 text-emerald-50": type === "insert" || (type === "modify" && side === "right"),
+    "text-zinc-200": type === "equal",
+    "bg-zinc-900/80 text-zinc-600": type === "padding",
+  };
+}
+
+function gutterClass(type: NacosDiffLineType, side: "left" | "right") {
+  return {
+    "text-red-300": type === "delete" || (type === "modify" && side === "left"),
+    "text-emerald-300": type === "insert" || (type === "modify" && side === "right"),
+    "text-zinc-500": type === "equal" || type === "padding",
+  };
+}
+
+function prefix(type: NacosDiffLineType, side: "left" | "right") {
+  if (type === "delete" || (type === "modify" && side === "left")) return "-";
+  if (type === "insert" || (type === "modify" && side === "right")) return "+";
+  return "";
+}
+
+function inlineSegments(content: string, segments: NacosInlineSegment[]) {
+  return segments.length ? segments : [{ value: content, changed: false }];
+}
+
+function inlineClass(type: NacosDiffLineType, changed: boolean) {
+  if (!changed) return "";
+  if (type === "delete" || type === "modify") return "nacos-inline-change rounded-[2px] bg-red-500/80 text-red-50";
+  if (type === "insert") return "nacos-inline-change rounded-[2px] bg-emerald-500/75 text-emerald-50";
+  return "";
+}
+
+function rightInlineClass(type: NacosDiffLineType, changed: boolean) {
+  if (!changed) return "";
+  if (type === "modify" || type === "insert") return "nacos-inline-change rounded-[2px] bg-emerald-500/75 text-emerald-50";
+  return inlineClass(type, changed);
+}
+
+function inlineRowClass(type: "equal" | "delete" | "insert") {
+  return {
+    "bg-red-500/20 text-red-50": type === "delete",
+    "bg-emerald-500/18 text-emerald-50": type === "insert",
+    "text-zinc-200": type === "equal",
+  };
+}
+
+function inlineGutterClass(type: "equal" | "delete" | "insert") {
+  return {
+    "text-red-300": type === "delete",
+    "text-emerald-300": type === "insert",
+    "text-zinc-500": type === "equal",
+  };
+}
+
+function inlinePrefix(type: "equal" | "delete" | "insert") {
+  if (type === "delete") return "-";
+  if (type === "insert") return "+";
+  return "";
+}
+
+function inlineRowSegmentClass(type: "equal" | "delete" | "insert", changed: boolean) {
+  if (!changed) return "";
+  if (type === "delete") return "nacos-inline-change rounded-[2px] bg-red-500/80 text-red-50";
+  if (type === "insert") return "nacos-inline-change rounded-[2px] bg-emerald-500/75 text-emerald-50";
+  return "";
+}
+
+function onConfirm() {
+  if (props.loading) return;
+  emit("confirm");
+}
+</script>
+
+<template>
+  <Dialog v-model:open="dialogOpen">
+    <DialogContent :show-close-button="false" class="nacos-config-diff-dialog flex h-[min(88vh,900px)] flex-col gap-0 overflow-hidden rounded-lg p-0 shadow-2xl">
+      <DialogHeader class="shrink-0 border-b px-5 py-4">
+        <div class="flex items-center justify-between gap-4">
+          <DialogTitle class="text-lg font-semibold">{{ title || t("nacos.configDiffTitle") }}</DialogTitle>
+          <button type="button" class="text-2xl leading-none text-muted-foreground hover:text-foreground" :disabled="loading" @click="open = false">×</button>
+        </div>
+        <div class="mt-3 flex flex-wrap items-center justify-between gap-3">
+          <label class="inline-flex items-center gap-2 text-sm text-muted-foreground">
+            <input v-model="inlineCompare" type="checkbox" class="h-4 w-4 rounded border-border" />
+            <span>{{ t("nacos.inlineCompare") }}</span>
+          </label>
+          <div class="text-xs text-muted-foreground">{{ t("nacos.confirmSaveMessage", { added: summary.addedLines, removed: summary.removedLines }) }}</div>
+        </div>
+      </DialogHeader>
+
+      <div v-if="!inlineCompare" class="grid min-h-0 flex-1 grid-cols-1 gap-4 bg-background px-5 py-4 lg:grid-cols-2">
+        <section class="flex min-w-0 min-h-0 flex-col">
+          <div class="mb-2 text-sm font-medium text-foreground">{{ beforeLabel || t("nacos.currentVersionContent") }}</div>
+          <div class="min-h-0 flex-1 overflow-auto rounded-sm border border-zinc-700 bg-[#1f1f1f] font-mono text-[13px] leading-6 text-zinc-200">
+            <div v-for="row in rows" :key="`${row.id}-left`" class="grid min-w-max grid-cols-[52px_22px_minmax(48rem,1fr)]" :class="lineClass(row.leftType, 'left')">
+              <span class="select-none border-r border-white/8 pr-2 text-right" :class="gutterClass(row.leftType, 'left')">{{ row.leftLineNumber ?? "" }}</span>
+              <span class="select-none pl-2" :class="gutterClass(row.leftType, 'left')">{{ prefix(row.leftType, "left") }}</span>
+              <pre class="whitespace-pre px-2"><template v-for="(segment, index) in inlineSegments(row.leftContent, row.leftInline)" :key="index"><span :class="inlineClass(row.leftType, segment.changed)">{{ segment.value }}</span></template></pre>
+            </div>
+          </div>
+        </section>
+
+        <section class="flex min-w-0 min-h-0 flex-col">
+          <div class="mb-2 text-sm font-medium text-foreground">{{ afterLabel || t("nacos.publishVersionContent") }}</div>
+          <div class="min-h-0 flex-1 overflow-auto rounded-sm border border-zinc-700 bg-[#1f1f1f] font-mono text-[13px] leading-6 text-zinc-200">
+            <div v-for="row in rows" :key="`${row.id}-right`" class="grid min-w-max grid-cols-[52px_22px_minmax(48rem,1fr)]" :class="lineClass(row.rightType, 'right')">
+              <span class="select-none border-r border-white/8 pr-2 text-right" :class="gutterClass(row.rightType, 'right')">{{ row.rightLineNumber ?? "" }}</span>
+              <span class="select-none pl-2" :class="gutterClass(row.rightType, 'right')">{{ prefix(row.rightType, "right") }}</span>
+              <pre class="whitespace-pre px-2"><template v-for="(segment, index) in inlineSegments(row.rightContent, row.rightInline)" :key="index"><span :class="rightInlineClass(row.rightType, segment.changed)">{{ segment.value }}</span></template></pre>
+            </div>
+          </div>
+        </section>
+      </div>
+
+      <div v-else class="min-h-0 flex-1 bg-background px-5 py-4">
+        <section class="flex h-full min-h-0 flex-col">
+          <div class="mb-2 text-sm font-medium text-foreground">{{ t("nacos.inlineCompare") }}</div>
+          <div class="min-h-0 flex-1 overflow-auto rounded-sm border border-zinc-700 bg-[#1f1f1f] font-mono text-[13px] leading-6 text-zinc-200">
+            <div v-for="row in inlineRows" :key="row.id" class="grid min-w-max grid-cols-[52px_22px_minmax(96rem,1fr)]" :class="inlineRowClass(row.type)">
+              <span class="select-none border-r border-white/8 pr-2 text-right" :class="inlineGutterClass(row.type)">{{ row.lineNumber ?? "" }}</span>
+              <span class="select-none pl-2" :class="inlineGutterClass(row.type)">{{ inlinePrefix(row.type) }}</span>
+              <pre class="whitespace-pre px-2"><template v-for="(segment, index) in row.segments" :key="index"><span :class="inlineRowSegmentClass(row.type, segment.changed)">{{ segment.value }}</span></template></pre>
+            </div>
+          </div>
+        </section>
+      </div>
+
+      <DialogFooter class="shrink-0 gap-3 border-t bg-muted/20 px-5 pb-6 pt-4">
+        <Button v-if="showConfirm" :variant="confirmVariant" class="min-w-24 gap-1.5 px-5" :disabled="loading" @click="onConfirm">
+          <Loader2 v-if="loading" class="h-3.5 w-3.5 animate-spin" />
+          {{ confirmLabel || t("nacos.publish") }}
+        </Button>
+        <Button variant="outline" class="min-w-24 px-5" :disabled="loading" @click="open = false">{{ t("dangerDialog.cancel") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
+
+<style>
+.nacos-config-diff-dialog {
+  width: min(96vw, 1440px) !important;
+  max-width: min(96vw, 1440px) !important;
+}
+
+.nacos-inline-change {
+  box-decoration-break: clone;
+  padding: 0 1px;
+}
+
+@media (max-width: 1023px) {
+  .nacos-config-diff-dialog {
+    width: min(96vw, 760px) !important;
+    max-width: min(96vw, 760px) !important;
+  }
+}
+</style>
diff --git a/apps/desktop/src/components/nacos/NacosConfigHistoryDialog.vue b/apps/desktop/src/components/nacos/NacosConfigHistoryDialog.vue
new file mode 100644
index 0000000..ac23cce
--- /dev/null
+++ b/apps/desktop/src/components/nacos/NacosConfigHistoryDialog.vue
@@ -0,0 +1,224 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { Clock3, Eye, FileText, GitCompare, Loader2, RefreshCw, RotateCcw, X } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import type { NacosConfigHistoryItem, NacosConfigItem } from "@/types/nacos";
+
+const open = defineModel<boolean>("open", { default: false });
+
+const props = withDefaults(
+  defineProps<{
+    config: NacosConfigItem | null;
+    items: NacosConfigHistoryItem[];
+    loading?: boolean;
+    error?: string;
+    pageNo: number;
+    pageSize: number;
+    totalCount: number;
+    readOnly?: boolean;
+    viewingItem?: NacosConfigHistoryItem | null;
+    viewingContent?: string;
+    viewingLoading?: boolean;
+  }>(),
+  {
+    items: () => [],
+    loading: false,
+    error: "",
+    readOnly: false,
+    viewingItem: null,
+    viewingContent: "",
+    viewingLoading: false,
+  },
+);
+
+const emit = defineEmits<{
+  load: [pageNo: number];
+  view: [item: NacosConfigHistoryItem];
+  "close-detail": [];
+  compare: [item: NacosConfigHistoryItem];
+  rollback: [item: NacosConfigHistoryItem];
+}>();
+
+const { t } = useI18n();
+const detailOpen = ref(false);
+const totalPages = computed(() => Math.max(1, Math.ceil(props.totalCount / Math.max(1, props.pageSize))));
+const historyTitle = computed(() => {
+  if (!props.config) return t("nacos.configHistory");
+  return `${props.config.dataId} / ${props.config.group || "DEFAULT_GROUP"}`;
+});
+const namespaceLabel = computed(() => props.config?.namespace || "public");
+const dataIdLabel = computed(() => props.config?.dataId || "-");
+const groupLabel = computed(() => props.config?.group || "DEFAULT_GROUP");
+
+watch(
+  () => props.viewingItem,
+  (item) => {
+    if (item) detailOpen.value = true;
+  },
+);
+
+watch(detailOpen, (value) => {
+  if (!value) emit("close-detail");
+});
+
+function display(value?: string | null) {
+  const trimmed = value?.trim();
+  return trimmed || "-";
+}
+
+function operationLabel(value?: string) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return "-";
+  if (["i", "insert", "create", "add"].includes(normalized)) return t("nacos.historyCreate");
+  if (["u", "update", "modify", "publish"].includes(normalized)) return t("nacos.historyUpdate");
+  if (["d", "delete", "remove"].includes(normalized)) return t("nacos.historyDelete");
+  if (["rollback", "recover"].includes(normalized)) return t("nacos.historyRollback");
+  return value || "-";
+}
+
+function loadPage(pageNo: number) {
+  if (props.loading || pageNo < 1 || pageNo > totalPages.value) return;
+  emit("load", pageNo);
+}
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent :show-close-button="false" class="nacos-config-history-dialog flex h-[min(82vh,760px)] flex-col gap-0 overflow-hidden rounded-lg p-0 shadow-2xl">
+      <DialogHeader class="shrink-0 border-b bg-muted/20 px-5 py-4">
+        <div class="flex items-center justify-between gap-4">
+          <div class="flex min-w-0 items-start gap-3">
+            <div class="mt-0.5 flex h-9 w-9 shrink-0 items-center justify-center rounded-md border bg-background text-primary">
+              <Clock3 class="h-4 w-4" />
+            </div>
+            <div class="min-w-0">
+              <DialogTitle class="truncate text-lg font-semibold">{{ t("nacos.configHistory") }}</DialogTitle>
+              <div class="mt-2 flex min-w-0 flex-wrap items-center gap-1.5 text-xs">
+                <Badge variant="outline" class="max-w-64 truncate font-mono">namespace={{ namespaceLabel }}</Badge>
+                <Badge variant="secondary" class="max-w-72 truncate font-mono">dataId={{ dataIdLabel }}</Badge>
+                <Badge variant="outline" class="max-w-48 truncate font-mono">group={{ groupLabel }}</Badge>
+              </div>
+              <div class="sr-only">{{ historyTitle }}</div>
+            </div>
+          </div>
+          <Button variant="ghost" size="icon" class="h-8 w-8 shrink-0" @click="open = false">
+            <X class="h-4 w-4" />
+          </Button>
+        </div>
+      </DialogHeader>
+
+      <div v-if="error" class="shrink-0 border-b px-5 py-2 text-xs text-destructive">{{ error }}</div>
+      <div class="min-h-0 flex-1 overflow-auto">
+        <table class="w-full text-left text-sm">
+          <thead class="sticky top-0 z-10 bg-muted/85 text-xs text-muted-foreground">
+            <tr>
+              <th class="px-4 py-2 font-medium">Data ID</th>
+              <th class="px-4 py-2 font-medium">Group</th>
+              <th class="px-4 py-2 font-medium">{{ t("nacos.updatedAt") }}</th>
+              <th class="px-4 py-2 font-medium">{{ t("nacos.application") }}</th>
+              <th class="px-4 py-2 font-medium">{{ t("nacos.operationType") }}</th>
+              <th class="px-4 py-2 font-medium">{{ t("nacos.operator") }}</th>
+              <th class="px-4 py-2 text-right font-medium">{{ t("nacos.actions") }}</th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr v-for="item in items" :key="`${item.historyId}:${item.nid ?? ''}`" class="border-b">
+              <td class="max-w-72 truncate px-4 py-2 font-medium" :title="item.dataId">{{ item.dataId }}</td>
+              <td class="max-w-44 truncate px-4 py-2 text-xs text-muted-foreground" :title="item.group">{{ item.group || "DEFAULT_GROUP" }}</td>
+              <td class="whitespace-nowrap px-4 py-2 text-xs text-muted-foreground">{{ display(item.lastModifiedTime) }}</td>
+              <td class="max-w-40 truncate px-4 py-2 text-xs text-muted-foreground" :title="item.appName || ''">{{ display(item.appName) }}</td>
+              <td class="px-4 py-2">
+                <Badge variant="outline">{{ operationLabel(item.operation) }}</Badge>
+              </td>
+              <td class="max-w-40 truncate px-4 py-2 text-xs text-muted-foreground" :title="item.operator || ''">{{ display(item.operator) }}</td>
+              <td class="px-4 py-2 text-right">
+                <div class="inline-flex items-center gap-1.5">
+                  <Button size="sm" variant="ghost" class="h-7 gap-1 px-2" :disabled="loading" @click="emit('view', item)">
+                    <Eye class="h-3.5 w-3.5" />
+                    {{ t("nacos.view") }}
+                  </Button>
+                  <Button size="sm" variant="ghost" class="h-7 gap-1 px-2" :disabled="loading" @click="emit('compare', item)">
+                    <GitCompare class="h-3.5 w-3.5" />
+                    {{ t("nacos.compare") }}
+                  </Button>
+                  <Button size="sm" variant="ghost" class="h-7 gap-1 px-2 text-destructive hover:text-destructive" :disabled="readOnly || loading" @click="emit('rollback', item)">
+                    <RotateCcw class="h-3.5 w-3.5" />
+                    {{ t("nacos.rollback") }}
+                  </Button>
+                </div>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+        <div v-if="loading" class="flex h-44 items-center justify-center text-sm text-muted-foreground">
+          <Loader2 class="mr-2 h-4 w-4 animate-spin" />
+          {{ t("nacos.loadingHistory") }}
+        </div>
+        <div v-else-if="items.length === 0" class="flex h-52 flex-col items-center justify-center gap-2 text-sm text-muted-foreground">
+          <div class="flex h-10 w-10 items-center justify-center rounded-md border bg-muted/30">
+            <FileText class="h-4 w-4" />
+          </div>
+          <div class="font-medium text-foreground">{{ t("nacos.noHistory") }}</div>
+          <div class="text-xs">{{ t("nacos.noHistoryHint") }}</div>
+        </div>
+      </div>
+
+      <DialogFooter class="shrink-0 items-center justify-between gap-3 border-t bg-muted/20 px-5 pb-5 pt-4">
+        <Button variant="outline" size="sm" class="h-8 gap-1.5" :disabled="loading" @click="loadPage(pageNo)">
+          <RefreshCw class="h-3.5 w-3.5" />
+          {{ t("nacos.refresh") }}
+        </Button>
+        <div class="flex items-center gap-2 rounded-md border bg-background px-2 py-1 text-xs text-muted-foreground">
+          <span>{{ t("nacos.total", { count: totalCount }) }}</span>
+          <Button size="sm" variant="outline" class="h-7" :disabled="pageNo <= 1 || loading" @click="loadPage(pageNo - 1)">{{ t("nacos.prev") }}</Button>
+          <span>{{ pageNo }} / {{ totalPages }}</span>
+          <Button size="sm" variant="outline" class="h-7" :disabled="pageNo >= totalPages || loading" @click="loadPage(pageNo + 1)">{{ t("nacos.next") }}</Button>
+        </div>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="detailOpen">
+    <DialogContent class="nacos-config-history-detail-dialog flex h-[min(88vh,900px)] flex-col gap-0 overflow-hidden p-0">
+      <DialogHeader class="shrink-0 border-b px-5 py-4">
+        <DialogTitle class="truncate text-base font-semibold">{{ t("nacos.historyDetail") }}</DialogTitle>
+        <div v-if="viewingItem" class="mt-2 grid gap-1.5 text-xs text-muted-foreground sm:grid-cols-2">
+          <div class="min-w-0 truncate font-mono" :title="viewingItem.namespace || 'public'">namespace={{ viewingItem.namespace || "public" }}</div>
+          <div class="min-w-0 truncate font-mono" :title="viewingItem.dataId">dataId={{ viewingItem.dataId }}</div>
+          <div class="min-w-0 truncate font-mono" :title="viewingItem.group || 'DEFAULT_GROUP'">group={{ viewingItem.group || "DEFAULT_GROUP" }}</div>
+          <div class="min-w-0 truncate" :title="display(viewingItem.lastModifiedTime)">{{ t("nacos.updatedAt") }}={{ display(viewingItem.lastModifiedTime) }}</div>
+        </div>
+      </DialogHeader>
+      <div class="min-h-0 flex-1 overflow-auto bg-muted/20 p-4">
+        <div v-if="viewingLoading" class="flex h-full items-center justify-center text-sm text-muted-foreground">
+          <Loader2 class="mr-2 h-4 w-4 animate-spin" />
+          {{ t("nacos.loadingHistory") }}
+        </div>
+        <pre v-else class="min-h-full rounded-md border bg-background p-3 font-mono text-xs leading-5">{{ viewingContent || "" }}</pre>
+      </div>
+      <DialogFooter class="m-0 shrink-0 rounded-none border-t bg-background px-5 py-5 sm:py-4">
+        <Button variant="outline" @click="detailOpen = false">{{ t("dangerDialog.cancel") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
+
+<style>
+.nacos-config-history-dialog {
+  width: min(96vw, 1280px) !important;
+  max-width: min(96vw, 1280px) !important;
+}
+
+.nacos-config-history-detail-dialog {
+  width: min(92vw, 1180px) !important;
+  max-width: min(92vw, 1180px) !important;
+}
+
+.nacos-config-history-detail-dialog pre {
+  min-width: max-content;
+  white-space: pre;
+}
+</style>
diff --git a/apps/desktop/src/components/objects/DdlViewDialog.vue b/apps/desktop/src/components/objects/DdlViewDialog.vue
new file mode 100644
index 0000000..ac25a17
--- /dev/null
+++ b/apps/desktop/src/components/objects/DdlViewDialog.vue
@@ -0,0 +1,243 @@
+<script setup lang="ts">
+import { nextTick, onUnmounted, ref, shallowRef, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Clipboard, Loader2, RefreshCw } from "@lucide/vue";
+import { useToast } from "@/composables/useToast";
+import { useTheme } from "@/composables/useTheme";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { loadEditorTheme, editorFontTheme } from "@/lib/editor/editorThemes";
+import { createDbxCodeMirrorSqlDialect } from "@/lib/editor/codemirrorSqlDialect";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { formatSqlForDisplay, type SqlFormatDialect } from "@/lib/sql/sqlFormatter";
+import * as api from "@/lib/backend/api";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import EditorSearchPanel from "@/components/editor/EditorSearchPanel.vue";
+import type { EditorView } from "@codemirror/view";
+import type { ObjectSourceKind } from "@/types/database";
+
+const props = withDefaults(
+  defineProps<{
+    open: boolean;
+    connectionId: string;
+    database: string;
+    schema?: string;
+    tableName: string;
+    objectType?: ObjectSourceKind;
+    /** SQL dialect for syntax highlighting. Non-PG/non-MSSQL databases fall back to MySQL (same as QueryEditor's source viewer). */
+    dialect: "mysql" | "postgres" | "sqlserver";
+    /** SQL formatter dialect. Kept separate from the syntax-highlighting dialect because several PG-compatible DBs highlight as MySQL. */
+    formatDialect?: SqlFormatDialect;
+  }>(),
+  {},
+);
+
+const emit = defineEmits<{
+  "update:open": [value: boolean];
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+const { isDark, themePalette } = useTheme();
+const settingsStore = useSettingsStore();
+
+const ddlContent = ref("");
+const ddlLoading = ref(false);
+const ddlError = ref("");
+const ddlEditorContainer = ref<HTMLDivElement>();
+const ddlSearchPanelRef = ref<InstanceType<typeof EditorSearchPanel>>();
+const ddlEditorView = shallowRef<EditorView | null>(null);
+
+/** Fetches the table DDL when the dialog opens. */
+watch(
+  () => props.open,
+  async (open) => {
+    if (!open) return;
+    ddlContent.value = "";
+    ddlError.value = "";
+    ddlLoading.value = true;
+    try {
+      const schema = props.schema || props.database;
+      const ddl = await api.getTableDdl(props.connectionId, props.database, schema, props.tableName, props.objectType);
+      ddlContent.value = await formatSqlForDisplay(ddl, props.formatDialect ?? props.dialect, settingsStore.editorSettings.sqlFormatter);
+    } catch (e: any) {
+      ddlError.value = e?.message || String(e);
+    } finally {
+      ddlLoading.value = false;
+    }
+  },
+  { immediate: true },
+);
+
+/**
+ * Creates a lightweight read-only CodeMirror editor inside the dialog.
+ *
+ * Follows the same pattern as QueryEditor:
+ * - cmSearch with hidden createPanel replaces the default search UI,
+ *   so EditorSearchPanel is the only visible search panel.
+ * - Prec.highest overrides Cmd+F to open EditorSearchPanel.
+ * - Editor theme/font are loaded from user settings for consistent appearance.
+ */
+async function initDdlEditor(content: string) {
+  if (!ddlEditorContainer.value) return;
+  destroyDdlEditor();
+  const [{ EditorView, keymap }, { EditorState, Prec }, langSql, { basicSetup }, { search: cmSearch }] = await Promise.all([import("@codemirror/view"), import("@codemirror/state"), import("@codemirror/lang-sql"), import("codemirror"), import("@codemirror/search")]);
+  const editorTheme = settingsStore.editorSettings.theme;
+  const appAppearance = isDark.value ? "dark" : "light";
+  const fontSize = settingsStore.editorSettings.fontSize;
+  const fontFamily = settingsStore.editorSettings.fontFamily;
+  const themeExt = await loadEditorTheme(editorTheme, appAppearance, undefined, themePalette.value);
+  const fontExt = editorFontTheme(EditorView, fontSize, fontFamily, { fixedHeight: true, scrollable: true });
+  const dialect = createDbxCodeMirrorSqlDialect(langSql, props.dialect);
+  const state = EditorState.create({
+    doc: content,
+    extensions: [
+      // Enable search functionality but hide the default panel —
+      // EditorSearchPanel provides the visible search UI instead, same as QueryEditor.
+      cmSearch({
+        top: true,
+        createPanel: () => {
+          const dom = document.createElement("span");
+          dom.style.display = "none";
+          return { dom };
+        },
+      }),
+      basicSetup,
+      langSql.sql({ dialect }),
+      themeExt,
+      fontExt,
+      // Intercept Cmd+F at highest precedence so EditorSearchPanel opens
+      // instead of the default search panel (which is hidden above).
+      Prec.highest(keymap.of([{ key: "Mod-f", run: () => ddlSearchPanelRef.value?.openSearch() ?? false, preventDefault: true }])),
+      // Remove CodeMirror's default 1px dotted focus outline,
+      // which is visible below the content when the DDL is short.
+      EditorView.theme({
+        "&.cm-focused": { outline: "none" },
+        ".cm-content": {
+          cursor: "text",
+          userSelect: "text",
+          WebkitUserSelect: "text",
+        },
+        ".cm-line": {
+          userSelect: "text",
+          WebkitUserSelect: "text",
+        },
+      }),
+      EditorState.readOnly.of(true),
+    ],
+  });
+  const editorView = new EditorView({ state, parent: ddlEditorContainer.value });
+  ddlEditorView.value = editorView;
+  editorView.focus();
+}
+
+/** Tears down the CodeMirror instance when the dialog closes. */
+function destroyDdlEditor() {
+  ddlEditorView.value?.destroy();
+  ddlEditorView.value = null;
+}
+
+/** Copies the DDL text to clipboard. */
+function copyDdlContent() {
+  if (ddlContent.value) {
+    copyToClipboard(ddlContent.value);
+    toast(t("contextMenu.ddlCopied"), 2000);
+  }
+}
+
+// When DDL finishes loading, create the editor inside the dialog.
+watch(ddlLoading, (loading) => {
+  if (!loading && ddlContent.value && props.open) {
+    nextTick(() => initDdlEditor(ddlContent.value));
+  }
+});
+
+// Destroy CodeMirror when the dialog hides, so the editor's event listeners
+// and DOM aren't consuming resources while the dialog is closed.
+// The editor is re-created on next open via the ddlLoading watch.
+watch(
+  () => props.open,
+  (open) => {
+    if (!open) destroyDdlEditor();
+  },
+);
+
+// Safety net: destroy editor when component eventually unmounts.
+onUnmounted(() => {
+  destroyDdlEditor();
+});
+
+function retry() {
+  ddlError.value = "";
+  ddlLoading.value = true;
+  ddlContent.value = "";
+  const schema = props.schema || props.database;
+  api
+    .getTableDdl(props.connectionId, props.database, schema, props.tableName, props.objectType)
+    .then(async (ddl) => {
+      ddlContent.value = await formatSqlForDisplay(ddl, props.formatDialect ?? props.dialect, settingsStore.editorSettings.sqlFormatter);
+    })
+    .catch((e: any) => {
+      ddlError.value = e?.message || String(e);
+    })
+    .finally(() => {
+      ddlLoading.value = false;
+    });
+}
+
+function onClose() {
+  emit("update:open", false);
+}
+</script>
+
+<template>
+  <Dialog :open="props.open" @update:open="onClose">
+    <DialogContent class="sm:max-w-190">
+      <DialogHeader>
+        <DialogTitle>DDL - {{ props.tableName }}</DialogTitle>
+      </DialogHeader>
+      <div class="grid gap-3">
+        <div v-if="ddlLoading" class="flex min-h-80 items-center justify-center gap-2 text-sm text-muted-foreground">
+          <Loader2 class="h-4 w-4 animate-spin" />
+          <span>{{ t("contextMenu.viewDdlLoading") }}</span>
+        </div>
+        <div v-else-if="ddlError" class="flex min-h-80 flex-col items-center justify-center gap-3 text-sm">
+          <p class="text-destructive">{{ ddlError }}</p>
+          <Button variant="outline" size="sm" @click="retry">
+            <RefreshCw />
+            {{ t("common.retry") }}
+          </Button>
+        </div>
+        <div v-else class="ddl-view-editor relative min-h-80 max-h-[60vh] overflow-hidden rounded border">
+          <div ref="ddlEditorContainer" class="h-full" />
+          <EditorSearchPanel v-if="ddlEditorView" ref="ddlSearchPanelRef" :view="ddlEditorView" />
+        </div>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" @click="onClose">{{ t("common.close") }}</Button>
+        <Button variant="outline" :disabled="!ddlContent" @click="copyDdlContent">
+          <Clipboard class="h-4 w-4" />
+          {{ t("grid.copyDdl") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
+
+<style scoped>
+.ddl-view-editor :deep(.cm-content),
+.ddl-view-editor :deep(.cm-line) {
+  cursor: text;
+  user-select: text !important;
+  -webkit-user-select: text !important;
+}
+
+.ddl-view-editor :deep(.cm-selectionBackground),
+.ddl-view-editor :deep(.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground) {
+  background: var(--dbx-editor-selection-background, rgba(59, 130, 246, 0.35)) !important;
+}
+
+.ddl-view-editor :deep(.cm-content ::selection) {
+  background: var(--dbx-editor-selection-background, rgba(59, 130, 246, 0.35)) !important;
+}
+</style>
diff --git a/apps/desktop/src/components/objects/InstallExtensionDialog.vue b/apps/desktop/src/components/objects/InstallExtensionDialog.vue
new file mode 100644
index 0000000..702e1c3
--- /dev/null
+++ b/apps/desktop/src/components/objects/InstallExtensionDialog.vue
@@ -0,0 +1,172 @@
+<script setup lang="ts">
+import { ref } from "vue";
+import { Loader2, Package, Plus, Trash2 } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { buildCreateExtensionSql, buildDropExtensionSql } from "@/lib/database/dbAdminSql";
+import * as api from "@/lib/backend/api";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import { useToast } from "@/composables/useToast";
+import { translateBackendError } from "@/i18n/backend-errors";
+import type { ExtensionInfo, TreeNode } from "@/types/database";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const connectionStore = useConnectionStore();
+
+const props = defineProps<{
+  node: TreeNode;
+}>();
+
+const emit = defineEmits<{
+  close: [];
+}>();
+
+const open = ref(false);
+const available = ref<ExtensionInfo[]>([]);
+const installed = ref<ExtensionInfo[]>([]);
+const loading = ref(false);
+const installing = ref<string | null>(null);
+const dropping = ref<string | null>(null);
+
+function show() {
+  open.value = true;
+  void loadData();
+}
+
+async function loadData() {
+  if (!props.node.connectionId || !props.node.database) return;
+  loading.value = true;
+  try {
+    const [avail, inst] = await Promise.all([api.listAvailableExtensions(props.node.connectionId, props.node.database).catch(() => [] as ExtensionInfo[]), api.listExtensions(props.node.connectionId, props.node.database, props.node.schema || "public").catch(() => [] as ExtensionInfo[])]);
+    available.value = avail;
+    installed.value = inst;
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  } finally {
+    loading.value = false;
+  }
+}
+
+async function installExtension(name: string) {
+  if (!props.node.connectionId || !props.node.database) return;
+  installing.value = name;
+  try {
+    const sql = buildCreateExtensionSql(name, props.node.schema ?? null);
+    const result = await executeWithProductionSqlGuard({
+      connection: connectionStore.getConfig(props.node.connectionId),
+      database: props.node.database,
+      sql,
+      source: t("production.sourceExtension"),
+      execute: () => api.executeQuery(props.node.connectionId!, props.node.database!, sql, props.node.schema ?? undefined),
+    });
+    if (!result) return;
+    await loadData();
+    emit("close");
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  } finally {
+    installing.value = null;
+  }
+}
+
+async function dropExtension(name: string) {
+  if (!props.node.connectionId || !props.node.database) return;
+  dropping.value = name;
+  try {
+    const sql = buildDropExtensionSql(name, false);
+    const result = await executeWithProductionSqlGuard({
+      connection: connectionStore.getConfig(props.node.connectionId),
+      database: props.node.database,
+      sql,
+      source: t("production.sourceExtension"),
+      execute: () => api.executeQuery(props.node.connectionId!, props.node.database!, sql, props.node.schema ?? undefined),
+    });
+    if (!result) return;
+    await loadData();
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  } finally {
+    dropping.value = null;
+  }
+}
+
+defineExpose({ show });
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent class="h-[min(760px,calc(100dvh-2rem))] flex flex-col overflow-hidden sm:max-w-3xl">
+      <DialogHeader>
+        <DialogTitle>{{ t("extension.manageTitle") }}</DialogTitle>
+      </DialogHeader>
+
+      <div v-if="loading" class="flex items-center justify-center py-12">
+        <Loader2 class="h-6 w-6 animate-spin text-muted-foreground" />
+      </div>
+
+      <div v-else class="grid flex-1 min-h-0 grid-cols-1 gap-4 sm:grid-cols-2">
+        <!-- Left: Available -->
+        <div class="flex min-h-0 flex-col">
+          <div class="flex items-center gap-1.5 mb-2 text-sm font-medium text-muted-foreground">
+            <Package class="h-4 w-4" />
+            {{ t("extension.available") }}
+            <span class="ml-auto text-xs">({{ available.length }})</span>
+          </div>
+          <ScrollArea class="min-h-0 flex-1 rounded-md border">
+            <div v-if="available.length === 0" class="flex items-center justify-center py-12 text-sm text-muted-foreground">
+              {{ t("extension.noAvailable") }}
+            </div>
+            <div v-else class="divide-y">
+              <div v-for="ext in available" :key="ext.name" class="flex items-center justify-between gap-2 px-3 py-2">
+                <div class="min-w-0 flex-1">
+                  <div class="text-sm font-medium truncate">{{ ext.name }}</div>
+                  <div class="text-xs text-muted-foreground">{{ ext.comment || ext.version }}</div>
+                </div>
+                <Button size="sm" variant="outline" :disabled="installing === ext.name" @click="installExtension(ext.name)">
+                  <Loader2 v-if="installing === ext.name" class="mr-1 h-3 w-3 animate-spin" />
+                  <Plus v-else class="mr-1 h-3 w-3" />
+                  {{ t("extension.install") }}
+                </Button>
+              </div>
+            </div>
+          </ScrollArea>
+        </div>
+
+        <!-- Right: Installed -->
+        <div class="flex min-h-0 flex-col">
+          <div class="flex items-center gap-1.5 mb-2 text-sm font-medium text-muted-foreground">
+            <Package class="h-4 w-4" />
+            {{ t("extension.installed") }}
+            <span class="ml-auto text-xs">({{ installed.length }})</span>
+          </div>
+          <ScrollArea class="min-h-0 flex-1 rounded-md border">
+            <div v-if="installed.length === 0" class="flex items-center justify-center py-12 text-sm text-muted-foreground">
+              {{ t("extension.noInstalled") }}
+            </div>
+            <div v-else class="divide-y">
+              <div v-for="ext in installed" :key="ext.name" class="flex items-center justify-between gap-2 px-3 py-2">
+                <div class="min-w-0 flex-1">
+                  <div class="text-sm font-medium truncate">{{ ext.name }}</div>
+                  <div class="text-xs text-muted-foreground">{{ ext.version }}{{ ext.comment ? ` — ${ext.comment}` : "" }}</div>
+                </div>
+                <Button size="sm" variant="outline" :disabled="dropping === ext.name" @click="dropExtension(ext.name)">
+                  <Loader2 v-if="dropping === ext.name" class="mr-1 h-3 w-3 animate-spin" />
+                  <Trash2 v-else class="mr-1 h-3 w-3" />
+                  {{ t("extension.drop") }}
+                </Button>
+              </div>
+            </div>
+          </ScrollArea>
+        </div>
+      </div>
+
+      <DialogFooter>
+        <Button variant="outline" @click="open = false">{{ t("common.close") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/objects/ObjectBrowser.vue b/apps/desktop/src/components/objects/ObjectBrowser.vue
new file mode 100644
index 0000000..1d5d1e0
--- /dev/null
+++ b/apps/desktop/src/components/objects/ObjectBrowser.vue
@@ -0,0 +1,3168 @@
+<script setup lang="ts">
+import { computed, nextTick, onActivated, onBeforeUnmount, ref, watch, type Component } from "vue";
+import { RecycleScroller } from "vue-virtual-scroller";
+import { useSqlHighlighter } from "@/composables/useSqlHighlighter";
+import {
+  ArrowDown,
+  ArrowRightLeft,
+  ArrowUp,
+  Braces,
+  CheckSquare,
+  Clipboard,
+  Code2,
+  Copy,
+  CopyPlus,
+  ChevronDown,
+  ChevronRight,
+  Columns3Cog,
+  Download,
+  Eraser,
+  Eye,
+  FileCode,
+  GripVertical,
+  KeyRound,
+  LayoutGrid,
+  Link2,
+  List,
+  ListTree,
+  Upload,
+  Loader2,
+  Network,
+  Pencil,
+  PencilLine,
+  PencilRuler,
+  Play,
+  Package,
+  RefreshCw,
+  RotateCcw,
+  Scissors,
+  Search,
+  ScrollText,
+  Square,
+  Table2,
+  TableProperties,
+  TerminalSquare,
+  Trash2,
+  WrapText,
+  X,
+} from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { SearchableSelect } from "@/components/ui/searchable-select";
+import CustomContextMenu, { type ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import ProcedureExecutionDialog from "@/components/objects/ProcedureExecutionDialog.vue";
+import * as api from "@/lib/backend/api";
+import type { ColumnInfo, ConnectionConfig, ForeignKeyInfo, IndexInfo, ObjectBrowserViewMode, ObjectBrowserViewport, ObjectInfo, ObjectSourceKind, ObjectStatistics, TableInfoTab, TriggerInfo } from "@/types/database";
+import { sortTablesByFkDependency, type TableWithFk } from "@/lib/table/tableDependencySort";
+import { isSchemaAware } from "@/lib/database/databaseCapabilities";
+import { supportsSchemaDiagram, supportsTableImport, supportsTableStructureEditing, supportsTableTruncate } from "@/lib/database/databaseFeatureSupport";
+import { codeMirrorSqlDialect, connectionUsesDatabaseObjectTreeMode, effectiveDatabaseTypeForConnection, tableStructureDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import { getTableMetadataCapabilities, type TableMetadataCapabilities } from "@/lib/table/tableMetadataCapabilities";
+import { buildTableSelectSql } from "@/lib/table/tableSelectSql";
+import { buildDropObjectSql, buildDropTableSql, buildDuplicateTableStructureSql, buildCopyTableDataSql, buildEmptyTableSql, buildTruncateTableSql, supportsDropTableCascade, supportsTruncateTableCascade, type TableAdminSqlOptions } from "@/lib/database/dbAdminSql";
+import { useToast } from "@/composables/useToast";
+import { buildExecutableObjectSourceStatements, buildRoutineRenameObjectSourceStatements, executeObjectSourceSave, supportsSourceBackedRoutineRename } from "@/lib/table/objectSourceEditor";
+import { buildRenameObjectSql, supportsObjectRename } from "@/lib/table/objectRenameSql";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { generateDatabaseExportId } from "@/lib/export/databaseExport";
+import { copyToClipboard, eventTargetAllowsAppClipboardShortcut } from "@/lib/common/clipboard";
+import { defaultPasteTableMode, pasteTableModeCopiesData, supportsWholeRowTableDataCopy, tableClipboardMatchesTarget, tableDataCopyColumnOptions, type PasteTableMode, type TableClipboardContext } from "@/lib/table/tableClipboard";
+import { formatSqlInsert } from "@/lib/export/exportFormats";
+import { buildSingleDdlExportFileContent } from "@/lib/export/ddlExport";
+import { fetchTableDataForExport } from "@/lib/table/tableDataExport";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useExportTracker, type ExportTask } from "@/composables/useExportTracker";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useQueryStore } from "@/stores/queryStore";
+import QueryEditor from "@/components/editor/QueryEditor.vue";
+import { sqlFormatDialectForDbType, type SqlFormatDialect } from "@/lib/sql/sqlFormatter";
+import { isCancelSearchShortcut } from "@/lib/editor/keyboardShortcuts";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import { batchTableEmptyFeedback, buildBatchTableEmptyPlan, runBatchTableEmpty, type BatchTableEmptyPlanItem } from "@/lib/sidebar/batchTableEmpty";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import {
+  buildObjectBrowserRows,
+  filterObjectBrowserRows,
+  formatObjectBrowserBytes,
+  formatObjectBrowserCount,
+  formatObjectBrowserTimestamp,
+  initialObjectBrowserSortDirection,
+  sortObjectBrowserRows,
+  type ObjectBrowserRow,
+  type ObjectBrowserSortDirection,
+  type ObjectBrowserSortKey,
+} from "@/lib/table/objectBrowserRows";
+import { resolveRowClickAction, shouldDeferSingleClick, type ObjectBrowserRowAction } from "@/lib/table/objectBrowserRowAction";
+import { createSidePanelRequestGuard } from "@/lib/table/sidePanelRequestGuard";
+import { runBatchTableTruncate } from "@/lib/table/batchTableTruncate";
+
+type ObjectFilter = "all" | "tables" | "views" | "materializedViews" | "procedures" | "functions" | "sequences" | "packages";
+type ObjectBrowserColumnKey = "select" | "name" | "type" | "estimatedRows" | "totalBytes" | "created_at" | "updated_at" | "comment";
+
+const props = defineProps<{
+  connection: ConnectionConfig;
+  database: string;
+  catalog?: string;
+  schema?: string;
+  viewport?: ObjectBrowserViewport;
+}>();
+
+const emit = defineEmits<{
+  openTable: [target: { tableName: string; schema?: string; tableType?: string; catalog?: string }];
+  schemaChange: [schema: string | undefined];
+  viewportChange: [viewport: ObjectBrowserViewport];
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+const { highlight } = useSqlHighlighter();
+const connectionStore = useConnectionStore();
+const queryStore = useQueryStore();
+const settingsStore = useSettingsStore();
+
+const schemas = ref<string[]>([]);
+const selectedSchema = ref<string | undefined>(props.schema);
+const rows = ref<ObjectBrowserRow[]>([]);
+const rootRef = ref<HTMLElement>();
+const search = ref("");
+const objectFilter = ref<ObjectFilter>("all");
+const userHasSelectedFilter = ref(false);
+const sortKey = ref<ObjectBrowserSortKey>("name");
+const sortDirection = ref<ObjectBrowserSortDirection>("asc");
+const loadingSchemas = ref(false);
+const loadingObjects = ref(false);
+const sourceLoading = ref(false);
+const sourceContent = ref("");
+const sourceError = ref("");
+const sourceRow = ref<ObjectBrowserRow | null>(null);
+const sourceEditing = ref(false);
+const sourceCanEdit = ref(true);
+// --- Right-side panel state ---
+// Unified panel: either "table-info" (for tables) or "source" (for views/procedures/etc.)
+const sidePanelRow = ref<ObjectBrowserRow | null>(null);
+const sidePanelMode = ref<"table-info" | "source">("source");
+// Table info panel state
+const tableInfoTab = ref<TableInfoTab>("ddl");
+const tableColumns = ref<ColumnInfo[]>([]);
+const tableColumnsLoading = ref(false);
+const tableDdlContent = ref("");
+const tableDdlLoading = ref(false);
+const tableIndexes = ref<IndexInfo[]>([]);
+const tableIndexesLoading = ref(false);
+const tableForeignKeys = ref<ForeignKeyInfo[]>([]);
+const tableForeignKeysLoading = ref(false);
+const tableTriggers = ref<TriggerInfo[]>([]);
+const tableTriggersLoading = ref(false);
+const tableInfoSearchQuery = ref("");
+const tableInfoWrap = ref(true);
+const tableInfoDdlPreRef = ref<HTMLPreElement | null>(null);
+const SIDE_PANEL_MIN_WIDTH = 280;
+const SIDE_PANEL_MAX_WIDTH = 900;
+const sidePanelWidth = ref(settingsStore.editorSettings.tableInfoDrawerWidth || 420);
+let sidePanelResizeStartX = 0;
+let sidePanelResizeStartWidth = 0;
+const isResizingSidePanel = ref(false);
+const sidePanelGuard = createSidePanelRequestGuard();
+const tableMetadataCapabilities = computed<TableMetadataCapabilities>(() => getTableMetadataCapabilities(effectiveDatabaseType.value));
+const effectiveDatabaseType = computed(() => effectiveDatabaseTypeForConnection(props.connection) ?? props.connection.db_type);
+const tableStructureDatabaseType = computed(() => tableStructureDatabaseTypeForConnection(props.connection) ?? props.connection.db_type);
+const sourceEditableText = ref("");
+const sourceDraft = ref("");
+const sourceSaving = ref(false);
+const sourceSaveError = ref("");
+const error = ref("");
+const showDropConfirm = ref(false);
+const dropTarget = ref<ObjectBrowserRow | null>(null);
+const dropPreviewSql = ref("");
+const dropTableCascade = ref(false);
+const batchDropCascade = ref(false);
+const showRenameDialog = ref(false);
+const renameTarget = ref<ObjectBrowserRow | null>(null);
+const renameInput = ref("");
+const renameError = ref("");
+const renamePreviewSqlText = ref("");
+const showTruncateConfirm = ref(false);
+const truncateTarget = ref<ObjectBrowserRow | null>(null);
+const truncatePreviewSql = ref("");
+const truncateTableCascade = ref(false);
+const showEmptyConfirm = ref(false);
+const emptyTarget = ref<ObjectBrowserRow | null>(null);
+const emptyPreviewSql = ref("");
+const showDuplicateDialog = ref(false);
+const duplicateTarget = ref<ObjectBrowserRow | null>(null);
+const duplicateTableName = ref("");
+const showProcedureExecutionConfirm = ref(false);
+const procedureExecutionTarget = ref<ObjectBrowserRow | null>(null);
+const selectedTableIds = ref<Set<string>>(new Set());
+const expandedPartitionParentIds = ref<Set<string>>(new Set());
+const showBatchDropConfirm = ref(false);
+const batchDropPreviewSql = ref("");
+const showBatchTruncateConfirm = ref(false);
+const batchTruncatePreviewSql = ref("");
+const batchTruncateCascade = ref(false);
+const showBatchEmptyConfirm = ref(false);
+const batchEmptyPreviewSql = ref("");
+const batchEmptyPlan = ref<BatchTableEmptyPlanItem<ObjectBrowserRow>[]>([]);
+// Paste table dialog state
+const showPasteDialog = ref(false);
+const pasteTableMode = ref<PasteTableMode>("structure-and-data");
+const pasteTableEntries = ref<{ sourceName: string; targetName: string; schema?: string }[]>([]);
+const pasteTableDataCopySupported = computed(() => supportsWholeRowTableDataCopy(effectiveDatabaseType.value));
+const objectColumnWidths = ref<Record<ObjectBrowserColumnKey, number>>({
+  select: 34,
+  name: 260,
+  type: 110,
+  estimatedRows: 110,
+  totalBytes: 100,
+  created_at: 150,
+  updated_at: 150,
+  comment: 260,
+});
+let loadId = 0;
+let stopColumnResize: (() => void) | null = null;
+let preserveObjectFilterScrollOnce = false;
+
+// Export via background tracker
+const { addTask: addExportTask } = useExportTracker();
+
+const needsSchema = computed(() => isSchemaAware(props.connection.db_type) && !connectionUsesDatabaseObjectTreeMode(props.connection));
+const canDropTargetCascade = computed(() => dropTarget.value?.type === "TABLE" && supportsDropTableCascade(effectiveDatabaseType.value));
+const canTruncateTargetCascade = computed(() => !!truncateTarget.value && supportsTruncateTableCascade(effectiveDatabaseType.value));
+const tableCount = computed(() => rows.value.filter((row) => row.type === "TABLE").length);
+const viewCount = computed(() => rows.value.filter((row) => row.type === "VIEW").length);
+const materializedViewCount = computed(() => rows.value.filter((row) => row.type === "MATERIALIZED_VIEW").length);
+const procedureCount = computed(() => rows.value.filter((row) => row.type === "PROCEDURE").length);
+const functionCount = computed(() => rows.value.filter((row) => row.type === "FUNCTION").length);
+const sequenceCount = computed(() => rows.value.filter((row) => row.type === "SEQUENCE").length);
+const packageCount = computed(() => rows.value.filter((row) => row.type === "PACKAGE" || row.type === "PACKAGE_BODY").length);
+const canOpenStructureEditor = computed(() => supportsTableStructureEditing(tableStructureDatabaseType.value));
+const canOpenDiagram = computed(() => !!props.database && supportsSchemaDiagram(effectiveDatabaseType.value));
+const canOpenTableImport = computed(() => !!props.database && supportsTableImport(effectiveDatabaseType.value));
+const supportsTruncateTable = computed(() => supportsTableTruncate(effectiveDatabaseType.value));
+const sourceDialect = computed(() => codeMirrorSqlDialect(effectiveDatabaseType.value));
+const sourceFormatDialect = computed<SqlFormatDialect>(() => sqlFormatDialectForDbType(effectiveDatabaseType.value));
+const objectFilters = computed<ObjectFilter[]>(() =>
+  (
+    [
+      ["all", rows.value.length],
+      ["tables", tableCount.value],
+      ["views", viewCount.value],
+      ["materializedViews", materializedViewCount.value],
+      ["procedures", procedureCount.value],
+      ["functions", functionCount.value],
+      ["sequences", sequenceCount.value],
+      ["packages", packageCount.value],
+    ] as Array<[ObjectFilter, number]>
+  )
+    .filter(([filter, count]) => filter === "all" || count > 0)
+    .map(([filter]) => filter),
+);
+const showObjectFilter = computed(() => objectFilters.value.length > 2);
+const hasCreatedAt = computed(() => rows.value.some((row) => row.created_at?.trim()));
+const hasUpdatedAt = computed(() => rows.value.some((row) => row.updated_at?.trim()));
+const hasAnyComment = computed(() => rows.value.some((row) => row.comment?.trim()));
+const isListView = computed(() => settingsStore.editorSettings.objectBrowserViewMode !== "grid");
+
+type ObjectBrowserScroller =
+  | HTMLElement
+  | {
+      scrollToItem?: (index: number) => void;
+      scrollToPosition?: (position: number) => void;
+      $el?: HTMLElement;
+      el?: HTMLElement | { value?: HTMLElement | null };
+    };
+
+// RecycleScroller exposes scroll helpers on its component instance. Keep the
+// type loose because vue-virtual-scroller does not ship complete ref typings.
+const listScrollerRef = ref<ObjectBrowserScroller | null>(null);
+const gridScrollerRef = ref<ObjectBrowserScroller | null>(null);
+let viewportFrame = 0;
+let restoreViewportFrame = 0;
+
+function objectBrowserViewMode(): ObjectBrowserViewMode {
+  return isListView.value ? "list" : "grid";
+}
+
+function activeScroller() {
+  return isListView.value ? listScrollerRef.value : gridScrollerRef.value;
+}
+
+function scrollerElement(scroller: ObjectBrowserScroller | null = activeScroller()): HTMLElement | null {
+  if (!scroller) return null;
+  if (scroller instanceof HTMLElement) return scroller;
+  if (scroller.$el instanceof HTMLElement) return scroller.$el;
+  if (scroller.el instanceof HTMLElement) return scroller.el;
+  if (scroller.el?.value instanceof HTMLElement) return scroller.el.value;
+  return null;
+}
+
+function emitViewportChange(scrollTop: number) {
+  const viewport: ObjectBrowserViewport = {
+    scrollTop: Math.max(0, Math.round(scrollTop)),
+    viewMode: objectBrowserViewMode(),
+  };
+  if (props.viewport?.scrollTop === viewport.scrollTop && props.viewport.viewMode === viewport.viewMode) return;
+  emit("viewportChange", viewport);
+}
+
+function onObjectsScroll() {
+  if (viewportFrame) return;
+  viewportFrame = window.requestAnimationFrame(() => {
+    viewportFrame = 0;
+    const el = scrollerElement();
+    if (!el) return;
+    emitViewportChange(el.scrollTop);
+  });
+}
+
+function applyObjectBrowserScrollTop(scrollTop: number) {
+  const scroller = activeScroller();
+  if (scroller && !(scroller instanceof HTMLElement)) {
+    scroller.scrollToPosition?.(scrollTop);
+    if (scrollTop === 0) scroller.scrollToItem?.(0);
+  }
+  const el = scrollerElement(scroller);
+  if (el) el.scrollTop = scrollTop;
+}
+
+function restoreObjectBrowserViewport() {
+  const viewport = props.viewport;
+  if (!viewport || viewport.viewMode !== objectBrowserViewMode()) return;
+  if (restoreViewportFrame) window.cancelAnimationFrame(restoreViewportFrame);
+  const scrollTop = Math.max(0, viewport.scrollTop);
+  nextTick(() => {
+    applyObjectBrowserScrollTop(scrollTop);
+    restoreViewportFrame = window.requestAnimationFrame(() => {
+      applyObjectBrowserScrollTop(scrollTop);
+      restoreViewportFrame = 0;
+    });
+  });
+}
+
+function scrollObjectsToTop() {
+  // Read the active scroller inside nextTick so that after a list <-> grid
+  // switch the (re)mounted scroller is the one we reset.
+  emitViewportChange(0);
+  nextTick(() => {
+    applyObjectBrowserScrollTop(0);
+  });
+}
+
+watch(
+  [listScrollerRef, gridScrollerRef, isListView],
+  (_value, _oldValue, onCleanup) => {
+    const el = scrollerElement();
+    if (!el) return;
+    el.addEventListener("scroll", onObjectsScroll, { passive: true });
+    restoreObjectBrowserViewport();
+    onCleanup(() => el.removeEventListener("scroll", onObjectsScroll));
+  },
+  { flush: "post" },
+);
+
+onActivated(() => {
+  restoreObjectBrowserViewport();
+});
+
+function setViewMode(mode: "list" | "grid") {
+  settingsStore.updateEditorSettings({ objectBrowserViewMode: mode });
+  scrollObjectsToTop();
+}
+
+// Re-sorting reorders the rows; jump to the top so the new head is visible
+// instead of leaving the view parked at a stale mid-scroll position.
+// Note: watch(sortKeyOptions) may reset sortKey during setup when the persisted key
+// is no longer valid, triggering this watcher before any scroller is mounted —
+// scrollObjectsToTop() handles that safely via optional chaining.
+watch([sortKey, sortDirection], () => scrollObjectsToTop());
+
+// Also jump to the top when the search query or object-type filter changes —
+// filtered results bear no relation to the previous scroll position.
+watch(search, () => scrollObjectsToTop());
+watch(objectFilter, () => {
+  if (preserveObjectFilterScrollOnce) {
+    preserveObjectFilterScrollOnce = false;
+    return;
+  }
+  scrollObjectsToTop();
+});
+
+const showCheckboxColumn = computed(() => settingsStore.editorSettings.objectBrowserShowCheckbox || selectedTableCount.value > 0);
+
+function toggleCheckboxColumn() {
+  const next = !settingsStore.editorSettings.objectBrowserShowCheckbox;
+  settingsStore.updateEditorSettings({ objectBrowserShowCheckbox: next });
+  if (!next) clearTableSelection();
+}
+
+const objectBrowserColumns = computed<ObjectBrowserColumnKey[]>(() => {
+  const columns: ObjectBrowserColumnKey[] = [];
+  if (showCheckboxColumn.value) columns.push("select");
+  columns.push("name", "type", "estimatedRows", "totalBytes");
+  if (hasCreatedAt.value) columns.push("created_at");
+  if (hasUpdatedAt.value) columns.push("updated_at");
+  columns.push("comment");
+  return columns;
+});
+const gridTemplateColumns = computed(() => {
+  return objectBrowserColumns.value
+    .map((key, index, columns) => {
+      const width = objectColumnWidths.value[key];
+      if (key === "select") return `${width}px`;
+      if (index === columns.length - 1) return `minmax(${width}px,1fr)`;
+      return `${width}px`;
+    })
+    .join(" ");
+});
+const objectGridMinWidth = computed(() => {
+  return objectBrowserColumns.value.reduce((total, key) => total + objectColumnWidths.value[key], 0) + Math.max(0, objectBrowserColumns.value.length - 1) * 12 + 24;
+});
+const partitionRowsByParentId = computed(() => {
+  const groups = new Map<string, ObjectBrowserRow[]>();
+  for (const row of rows.value) {
+    if (!row.partitionParentId) continue;
+    const group = groups.get(row.partitionParentId) ?? [];
+    group.push(row);
+    groups.set(row.partitionParentId, group);
+  }
+  return groups;
+});
+const filteredRows = computed(() => groupedFilteredRows());
+const selectableRows = computed(() => rows.value.filter((row) => row.type === "TABLE"));
+
+// ---- Grid (tile) view virtualization ----
+// The grid view chunks filteredRows into fixed-height rows and hands them to
+// RecycleScroller, mirroring the list view so only visible rows are mounted.
+// The previous flat `v-for` rendered every card (plus its CustomContextMenu)
+// at once, which stalls the UI on schemas with thousands of objects.
+const OBJECT_GRID_MIN_CARD_WIDTH = 160; // former `minmax(160px, 1fr)` floor
+const OBJECT_GRID_GAP = 12; // 0.75rem, former grid gap (both axes)
+// Card height is variable: only timestamp/comment rows that actually appear in
+// the current dataset contribute. objectGridRowHeight (below) adapts accordingly
+// so the row slot is as tight as possible instead of always using the worst case.
+//   Base: p-3 top+bottom(24) + icon h-11(44) + name(18) + type/bytes(18) + gap-1×2(8) = 112
+//   + optional timestamp row: text-[10px](15) + gap-1(4) = 19
+//   + optional comment row:   text-[10px](15) + gap-1(4) = 19
+// If the card gains a new metadata row, add a matching constant and include it below.
+const OBJECT_GRID_CARD_BASE_H = 112;
+const OBJECT_GRID_CARD_TIMESTAMP_H = 19;
+const OBJECT_GRID_CARD_COMMENT_H = 19;
+const OBJECT_GRID_CARD_SAFETY = 6; // buffer for sub-pixel font differences
+
+const objectGridRowHeight = computed(() => {
+  let cardH = OBJECT_GRID_CARD_BASE_H;
+  if (hasCreatedAt.value || hasUpdatedAt.value) cardH += OBJECT_GRID_CARD_TIMESTAMP_H;
+  if (hasAnyComment.value) cardH += OBJECT_GRID_CARD_COMMENT_H;
+  return cardH + OBJECT_GRID_GAP + OBJECT_GRID_CARD_SAFETY;
+});
+const gridContainerRef = ref<HTMLElement | null>(null);
+const gridColumns = ref(1);
+let gridResizeObserver: ResizeObserver | null = null;
+
+function recomputeGridColumns(width: number) {
+  gridColumns.value = Math.max(1, Math.floor((width + OBJECT_GRID_GAP) / (OBJECT_GRID_MIN_CARD_WIDTH + OBJECT_GRID_GAP)));
+}
+
+// The grid container lives inside a v-else, so it mounts/unmounts when the user
+// toggles list <-> grid. Watch the template ref to (re)attach the observer each
+// time the node appears, instead of once in onMounted (which would miss the
+// case where the browser starts in list mode).
+watch(
+  gridContainerRef,
+  (el, prevEl) => {
+    if (prevEl) {
+      gridResizeObserver?.disconnect();
+      gridResizeObserver = null;
+    }
+    if (!el) return;
+    // Use the content-box width (excluding padding) to match what ResizeObserver
+    // delivers via entry.contentRect.width, avoiding a 1-frame column jump on mount.
+    const style = getComputedStyle(el);
+    recomputeGridColumns(el.clientWidth - parseFloat(style.paddingLeft) - parseFloat(style.paddingRight));
+    gridResizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) recomputeGridColumns(entry.contentRect.width);
+    });
+    gridResizeObserver.observe(el);
+  },
+  { flush: "post" },
+);
+
+onBeforeUnmount(() => {
+  gridResizeObserver?.disconnect();
+  gridResizeObserver = null;
+  if (viewportFrame) window.cancelAnimationFrame(viewportFrame);
+  if (restoreViewportFrame) window.cancelAnimationFrame(restoreViewportFrame);
+  window.removeEventListener("mousemove", onSidePanelResizeMove);
+  window.removeEventListener("mouseup", onSidePanelResizeEnd);
+  if (singleClickTimer) {
+    clearTimeout(singleClickTimer);
+    singleClickTimer = null;
+  }
+});
+
+const gridRows = computed(() => {
+  const cols = gridColumns.value;
+  const cards = filteredRows.value;
+  const rows: Array<{ key: string; cards: ObjectBrowserRow[] }> = [];
+  for (let i = 0; i < cards.length; i += cols) {
+    rows.push({ key: `row-${i}`, cards: cards.slice(i, i + cols) });
+  }
+  return rows;
+});
+const visibleSelectableRows = computed(() => filteredRows.value.filter((row) => row.type === "TABLE"));
+const selectedTableRows = computed(() => {
+  const ids = selectedTableIds.value;
+  return selectableRows.value.filter((row) => ids.has(row.id));
+});
+const selectedTableCount = computed(() => selectedTableRows.value.length);
+const canBatchDropCascade = computed(() => selectedTableCount.value > 0 && supportsDropTableCascade(effectiveDatabaseType.value));
+const canBatchTruncateCascade = computed(() => selectedTableCount.value > 0 && supportsTruncateTableCascade(effectiveDatabaseType.value));
+const allVisibleTablesSelected = computed(() => visibleSelectableRows.value.length > 0 && visibleSelectableRows.value.every((row) => selectedTableIds.value.has(row.id)));
+
+function iconFor(row: ObjectBrowserRow) {
+  if (row.type === "VIEW" || row.type === "MATERIALIZED_VIEW") return Eye;
+  if (row.type === "PROCEDURE") return ScrollText;
+  if (row.type === "FUNCTION") return Braces;
+  if (row.type === "SEQUENCE") return ListTree;
+  if (row.type === "PACKAGE" || row.type === "PACKAGE_BODY") return Package;
+  return Table2;
+}
+
+function typeLabel(type: ObjectBrowserRow["type"]) {
+  if (type === "MATERIALIZED_VIEW") return t("common.materializedView");
+  if (type === "VIEW") return t("objects.view");
+  if (type === "PROCEDURE") return t("objects.procedure");
+  if (type === "FUNCTION") return t("objects.function");
+  if (type === "SEQUENCE") return t("objects.sequence");
+  if (type === "PACKAGE") return t("objects.package");
+  if (type === "PACKAGE_BODY") return t("objects.packageBody");
+  return t("objects.table");
+}
+
+function sortIconFor(key: ObjectBrowserSortKey) {
+  if (sortKey.value !== key) return null;
+  return sortDirection.value === "asc" ? ArrowUp : ArrowDown;
+}
+
+function toggleSort(key: ObjectBrowserSortKey) {
+  if (sortKey.value === key) {
+    sortDirection.value = sortDirection.value === "asc" ? "desc" : "asc";
+    return;
+  }
+  sortKey.value = key;
+  sortDirection.value = initialObjectBrowserSortDirection(key);
+}
+
+const sortKeyOptions = computed<ObjectBrowserSortKey[]>(() => {
+  const options: ObjectBrowserSortKey[] = ["name", "type", "estimatedRows", "totalBytes"];
+  if (hasCreatedAt.value) options.push("created_at");
+  if (hasUpdatedAt.value) options.push("updated_at");
+  options.push("comment");
+  return options;
+});
+
+watch(sortKeyOptions, (options) => {
+  if (!options.includes(sortKey.value)) {
+    sortKey.value = "name";
+    sortDirection.value = "asc";
+  }
+});
+
+function sortKeyLabel(key: ObjectBrowserSortKey): string {
+  if (key === "name") return t("objects.name");
+  if (key === "type") return t("objects.type");
+  if (key === "estimatedRows") return t("objects.rows");
+  if (key === "totalBytes") return t("objects.size");
+  if (key === "created_at") return t("objects.createdAt");
+  if (key === "updated_at") return t("objects.updatedAt");
+  if (key === "comment") return t("objects.comment");
+  return key;
+}
+
+function onSortKeyChange(key: ObjectBrowserSortKey) {
+  toggleSort(key);
+}
+
+function minimumColumnWidth(key: ObjectBrowserColumnKey) {
+  if (key === "select") return 34;
+  if (key === "name" || key === "comment") return 120;
+  return 72;
+}
+
+function onObjectColumnResizeStart(key: ObjectBrowserColumnKey, event: MouseEvent) {
+  event.preventDefault();
+  event.stopPropagation();
+  stopColumnResize?.();
+
+  const startX = event.clientX;
+  const startWidth = objectColumnWidths.value[key];
+  const minWidth = minimumColumnWidth(key);
+  document.body.classList.add("select-none", "cursor-col-resize");
+
+  const onMove = (moveEvent: MouseEvent) => {
+    objectColumnWidths.value = {
+      ...objectColumnWidths.value,
+      [key]: Math.max(minWidth, startWidth + moveEvent.clientX - startX),
+    };
+  };
+  const onUp = () => {
+    document.removeEventListener("mousemove", onMove);
+    document.removeEventListener("mouseup", onUp);
+    document.body.classList.remove("select-none", "cursor-col-resize");
+    stopColumnResize = null;
+  };
+
+  stopColumnResize = onUp;
+  document.addEventListener("mousemove", onMove);
+  document.addEventListener("mouseup", onUp);
+}
+
+function resetObjectColumnWidth(key: ObjectBrowserColumnKey, width: number, event: MouseEvent) {
+  event.preventDefault();
+  event.stopPropagation();
+  objectColumnWidths.value = {
+    ...objectColumnWidths.value,
+    [key]: width,
+  };
+}
+
+function rowMatchesObjectFilter(row: ObjectBrowserRow) {
+  if (objectFilter.value === "tables") return row.type === "TABLE";
+  if (objectFilter.value === "views") return row.type === "VIEW";
+  if (objectFilter.value === "materializedViews") return row.type === "MATERIALIZED_VIEW";
+  if (objectFilter.value === "procedures") return row.type === "PROCEDURE";
+  if (objectFilter.value === "functions") return row.type === "FUNCTION";
+  if (objectFilter.value === "sequences") return row.type === "SEQUENCE";
+  if (objectFilter.value === "packages") return row.type === "PACKAGE" || row.type === "PACKAGE_BODY";
+  return true;
+}
+
+function groupedFilteredRows() {
+  const query = search.value.trim();
+  const candidateRows = rows.value.filter(rowMatchesObjectFilter);
+  const candidateIds = new Set(candidateRows.map((row) => row.id));
+  const matchingRows = filterObjectBrowserRows(candidateRows, query);
+  const matchingIds = new Set(matchingRows.map((row) => row.id));
+  const parentIdsWithMatchingPartitions = new Set(matchingRows.flatMap((row) => (row.partitionParentId ? [row.partitionParentId] : [])));
+  const rootRows = candidateRows.filter((row) => {
+    if (row.partitionParentId) return false;
+    if (!query) return true;
+    return matchingIds.has(row.id) || parentIdsWithMatchingPartitions.has(row.id);
+  });
+  const sortedRoots = sortObjectBrowserRows(rootRows, sortKey.value, sortDirection.value);
+  const result: ObjectBrowserRow[] = [];
+
+  for (const row of sortedRoots) {
+    result.push(row);
+    const partitions = partitionRowsByParentId.value.get(row.id)?.filter((partition) => candidateIds.has(partition.id));
+    if (!partitions?.length) continue;
+    const parentMatches = matchingIds.has(row.id);
+    const shouldShowPartitions = expandedPartitionParentIds.value.has(row.id) || !!query;
+    if (!shouldShowPartitions) continue;
+    const visiblePartitions = query && !parentMatches ? partitions.filter((partition) => matchingIds.has(partition.id)) : partitions;
+    result.push(...sortObjectBrowserRows(visiblePartitions, sortKey.value, sortDirection.value));
+  }
+
+  return result;
+}
+
+function iconClass(type: ObjectBrowserRow["type"]) {
+  if (type === "VIEW" || type === "MATERIALIZED_VIEW") return "text-purple-500";
+  if (type === "PROCEDURE") return "text-blue-500";
+  if (type === "FUNCTION") return "text-amber-500";
+  if (type === "SEQUENCE") return "text-emerald-500";
+  if (type === "PACKAGE" || type === "PACKAGE_BODY") return "text-cyan-500";
+  return "text-green-500";
+}
+
+function iconBgClass(type: ObjectBrowserRow["type"]) {
+  if (type === "VIEW" || type === "MATERIALIZED_VIEW") return "object-browser-icon-bg object-browser-icon-bg-view";
+  if (type === "PROCEDURE") return "object-browser-icon-bg object-browser-icon-bg-procedure";
+  if (type === "FUNCTION") return "object-browser-icon-bg object-browser-icon-bg-function";
+  if (type === "SEQUENCE") return "object-browser-icon-bg object-browser-icon-bg-sequence";
+  if (type === "PACKAGE" || type === "PACKAGE_BODY") return "object-browser-icon-bg object-browser-icon-bg-package";
+  return "object-browser-icon-bg object-browser-icon-bg-table";
+}
+
+function isPartitionParentExpanded(row: ObjectBrowserRow) {
+  return expandedPartitionParentIds.value.has(row.id);
+}
+
+function togglePartitionParent(row: ObjectBrowserRow) {
+  if (!row.partitionCount) return;
+  const next = new Set(expandedPartitionParentIds.value);
+  if (next.has(row.id)) next.delete(row.id);
+  else next.add(row.id);
+  expandedPartitionParentIds.value = next;
+}
+
+function canRename(row: ObjectBrowserRow) {
+  return supportsObjectRename(effectiveDatabaseType.value, row.type) || supportsSourceBackedRoutineRename(effectiveDatabaseType.value, row.type as ObjectSourceKind);
+}
+
+function sourceTitle(row: ObjectBrowserRow | null) {
+  if (!row) return t("objects.source");
+  return `${row.name} ${t("objects.source")}`;
+}
+
+const SINGLE_CLICK_DELAY = 250;
+let singleClickTimer: ReturnType<typeof setTimeout> | null = null;
+
+function executeRowAction(row: ObjectBrowserRow, action: ObjectBrowserRowAction) {
+  switch (action) {
+    case "table-info":
+      void openTableInfo(row);
+      break;
+    case "open-table":
+      emit("openTable", { tableName: row.name, schema: row.schema, catalog: props.catalog });
+      break;
+    case "open-source":
+      void openSource(row);
+      break;
+  }
+}
+
+function onRowClick(row: ObjectBrowserRow, event: MouseEvent) {
+  const activation = settingsStore.editorSettings.sidebarActivation;
+  const { action, isDouble } = resolveRowClickAction(row, event.detail, activation);
+  // Double click: cancel any pending single-click and fire immediately
+  if (isDouble) {
+    if (singleClickTimer) {
+      clearTimeout(singleClickTimer);
+      singleClickTimer = null;
+    }
+    executeRowAction(row, action);
+    return;
+  }
+  // Single click: defer when the row has a distinct double-click action so a
+  // following second click can cancel it (e.g. TABLE single→table-info, double→open-table).
+  if (shouldDeferSingleClick(row, action)) {
+    if (singleClickTimer) clearTimeout(singleClickTimer);
+    singleClickTimer = setTimeout(() => {
+      singleClickTimer = null;
+      executeRowAction(row, action);
+    }, SINGLE_CLICK_DELAY);
+    return;
+  }
+  executeRowAction(row, action);
+}
+
+// --- Table info panel (replicates DataGrid table-info-drawer) ---
+
+type TableInfoTabItem = { id: TableInfoTab; label: string; icon: Component; count?: number };
+
+const tableInfoTabs = computed<TableInfoTabItem[]>(() => {
+  const tabs: TableInfoTabItem[] = [];
+  if (tableMetadataCapabilities.value.ddl) {
+    tabs.push({ id: "ddl", label: "DDL", icon: Code2 });
+  }
+  if (tableMetadataCapabilities.value.columns) {
+    tabs.push({ id: "columns", label: t("grid.tableInfoColumns"), icon: ListTree, count: tableColumns.value.length });
+  }
+  if (tableMetadataCapabilities.value.indexes) {
+    tabs.push({ id: "indexes", label: t("grid.tableInfoIndexes"), icon: KeyRound, count: tableIndexes.value.length });
+  }
+  if (tableMetadataCapabilities.value.foreignKeys) {
+    tabs.push({ id: "foreignKeys", label: t("grid.tableInfoForeignKeys"), icon: Link2, count: tableForeignKeys.value.length });
+  }
+  if (tableMetadataCapabilities.value.triggers) {
+    tabs.push({ id: "triggers", label: t("grid.tableInfoTriggers"), icon: RotateCcw, count: tableTriggers.value.length });
+  }
+  return tabs;
+});
+
+const tableInfoTabListStyle = computed(() => ({
+  gridTemplateColumns: `repeat(${tableInfoTabs.value.length}, minmax(0, 1fr))`,
+}));
+
+const filteredTableColumns = computed(() => {
+  if (!tableInfoSearchQuery.value) return tableColumns.value;
+  const q = tableInfoSearchQuery.value.toLowerCase();
+  return tableColumns.value.filter((c) => c.name.toLowerCase().includes(q) || c.data_type.toLowerCase().includes(q));
+});
+
+const filteredTableIndexes = computed(() => {
+  if (!tableInfoSearchQuery.value) return tableIndexes.value;
+  const q = tableInfoSearchQuery.value.toLowerCase();
+  return tableIndexes.value.filter((i) => i.name.toLowerCase().includes(q) || i.columns.some((c) => c.toLowerCase().includes(q)));
+});
+
+const filteredTableForeignKeys = computed(() => {
+  if (!tableInfoSearchQuery.value) return tableForeignKeys.value;
+  const q = tableInfoSearchQuery.value.toLowerCase();
+  return tableForeignKeys.value.filter((fk) => fk.name.toLowerCase().includes(q) || fk.column.toLowerCase().includes(q) || fk.ref_table.toLowerCase().includes(q) || fk.ref_column.toLowerCase().includes(q));
+});
+
+const filteredTableTriggers = computed(() => {
+  if (!tableInfoSearchQuery.value) return tableTriggers.value;
+  const q = tableInfoSearchQuery.value.toLowerCase();
+  return tableTriggers.value.filter((tr) => tr.name.toLowerCase().includes(q));
+});
+
+const filteredTableDdlContent = computed(() => {
+  if (!tableDdlContent.value) return "";
+  const html = highlight(tableDdlContent.value);
+  if (!tableInfoSearchQuery.value) return html;
+  const escaped = tableInfoSearchQuery.value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const regex = new RegExp(`(${escaped})`, "gi");
+  return html.replace(/>([^<]*)</g, (_, text) => {
+    return `>${text.replace(regex, "<mark>$1</mark>")}<`;
+  });
+});
+
+async function openTableInfo(row: ObjectBrowserRow, initialTab?: TableInfoTab) {
+  // Toggle off if clicking the same table
+  if (sidePanelRow.value?.id === row.id && sidePanelMode.value === "table-info" && !initialTab) {
+    closeSidePanel();
+    return;
+  }
+  sidePanelRow.value = row;
+  sidePanelMode.value = "table-info";
+  sidePanelGuard.bump();
+  // Reset state
+  tableColumns.value = [];
+  tableDdlContent.value = "";
+  tableIndexes.value = [];
+  tableForeignKeys.value = [];
+  tableTriggers.value = [];
+  tableInfoSearchQuery.value = "";
+  // Determine initial tab: explicit request > first available > ddl
+  const firstTab = initialTab ?? tableInfoTabs.value[0]?.id ?? "ddl";
+  await selectTableInfoTab(firstTab);
+}
+
+async function selectTableInfoTab(tab: TableInfoTab) {
+  const nextTab = tableInfoTabs.value.some((item) => item.id === tab) ? tab : tableInfoTabs.value[0]?.id;
+  if (!nextTab) return;
+  tableInfoTab.value = nextTab;
+  tableInfoSearchQuery.value = "";
+  if (nextTab === "ddl") await fetchTableDdl();
+  else if (nextTab === "columns") await fetchTableColumns();
+  else if (nextTab === "indexes") await fetchTableIndexes();
+  else if (nextTab === "foreignKeys") await fetchTableForeignKeys();
+  else if (nextTab === "triggers") await fetchTableTriggers();
+}
+
+async function fetchTableDdl() {
+  const row = sidePanelRow.value;
+  if (!row) return;
+  const epoch = sidePanelGuard.capture();
+  tableDdlLoading.value = true;
+  try {
+    const schema = row.schema || selectedSchema.value || props.database;
+    const ddl = await api.getTableDdl(props.connection.id, props.database || "", schema, row.name, tableDdlObjectType(row.type));
+    if (sidePanelGuard.isStale(epoch)) return;
+    tableDdlContent.value = ddl;
+  } catch (e: any) {
+    if (sidePanelGuard.isStale(epoch)) return;
+    tableDdlContent.value = `-- Error: ${e?.message || e}`;
+  } finally {
+    if (sidePanelGuard.isFresh(epoch)) tableDdlLoading.value = false;
+  }
+}
+
+async function fetchTableColumns() {
+  const row = sidePanelRow.value;
+  if (!row || tableColumns.value.length > 0) return;
+  const epoch = sidePanelGuard.capture();
+  tableColumnsLoading.value = true;
+  try {
+    const schema = row.schema || selectedSchema.value || props.database;
+    const columns = await api.getColumns(props.connection.id, props.database || "", schema, row.name);
+    if (sidePanelGuard.isStale(epoch)) return;
+    tableColumns.value = columns;
+  } catch {
+    if (sidePanelGuard.isStale(epoch)) return;
+    tableColumns.value = [];
+  } finally {
+    if (sidePanelGuard.isFresh(epoch)) tableColumnsLoading.value = false;
+  }
+}
+
+async function fetchTableIndexes() {
+  const row = sidePanelRow.value;
+  if (!row || tableIndexes.value.length > 0) return;
+  const epoch = sidePanelGuard.capture();
+  tableIndexesLoading.value = true;
+  try {
+    const schema = row.schema || selectedSchema.value || props.database;
+    const indexes = await api.listIndexes(props.connection.id, props.database || "", schema, row.name);
+    if (sidePanelGuard.isStale(epoch)) return;
+    tableIndexes.value = indexes;
+  } catch {
+    if (sidePanelGuard.isStale(epoch)) return;
+    tableIndexes.value = [];
+  } finally {
+    if (sidePanelGuard.isFresh(epoch)) tableIndexesLoading.value = false;
+  }
+}
+
+async function fetchTableForeignKeys() {
+  const row = sidePanelRow.value;
+  if (!row || tableForeignKeys.value.length > 0) return;
+  const epoch = sidePanelGuard.capture();
+  tableForeignKeysLoading.value = true;
+  try {
+    const schema = row.schema || selectedSchema.value || props.database;
+    const fks = await api.listForeignKeys(props.connection.id, props.database || "", schema, row.name);
+    if (sidePanelGuard.isStale(epoch)) return;
+    tableForeignKeys.value = fks;
+  } catch {
+    if (sidePanelGuard.isStale(epoch)) return;
+    tableForeignKeys.value = [];
+  } finally {
+    if (sidePanelGuard.isFresh(epoch)) tableForeignKeysLoading.value = false;
+  }
+}
+
+async function fetchTableTriggers() {
+  const row = sidePanelRow.value;
+  if (!row || tableTriggers.value.length > 0) return;
+  const epoch = sidePanelGuard.capture();
+  tableTriggersLoading.value = true;
+  try {
+    const schema = row.schema || selectedSchema.value || props.database;
+    const triggers = await api.listTriggers(props.connection.id, props.database || "", schema, row.name);
+    if (sidePanelGuard.isStale(epoch)) return;
+    tableTriggers.value = triggers;
+  } catch {
+    if (sidePanelGuard.isStale(epoch)) return;
+    tableTriggers.value = [];
+  } finally {
+    if (sidePanelGuard.isFresh(epoch)) tableTriggersLoading.value = false;
+  }
+}
+
+function copyTableDdl() {
+  void copyToClipboard(tableDdlContent.value);
+  toast(t("grid.copyDdl"), 2000);
+}
+
+function onTableInfoDdlKeydown(e: KeyboardEvent) {
+  if ((e.ctrlKey || e.metaKey) && e.key === "a") {
+    e.preventDefault();
+    const el = tableInfoDdlPreRef.value;
+    if (!el) return;
+    const range = document.createRange();
+    range.selectNodeContents(el);
+    const sel = window.getSelection();
+    sel?.removeAllRanges();
+    sel?.addRange(range);
+  }
+}
+
+// --- Side panel resize ---
+function onSidePanelResizeStart(event: MouseEvent) {
+  isResizingSidePanel.value = true;
+  sidePanelResizeStartX = event.clientX;
+  sidePanelResizeStartWidth = sidePanelWidth.value;
+  window.addEventListener("mousemove", onSidePanelResizeMove);
+  window.addEventListener("mouseup", onSidePanelResizeEnd);
+}
+
+function onSidePanelResizeMove(event: MouseEvent) {
+  if (!isResizingSidePanel.value) return;
+  const delta = sidePanelResizeStartX - event.clientX;
+  const next = Math.min(SIDE_PANEL_MAX_WIDTH, Math.max(SIDE_PANEL_MIN_WIDTH, sidePanelResizeStartWidth + delta));
+  sidePanelWidth.value = next;
+}
+
+function onSidePanelResizeEnd() {
+  isResizingSidePanel.value = false;
+  window.removeEventListener("mousemove", onSidePanelResizeMove);
+  window.removeEventListener("mouseup", onSidePanelResizeEnd);
+  settingsStore.updateEditorSettings({ tableInfoDrawerWidth: sidePanelWidth.value });
+}
+
+function closeSidePanel() {
+  sidePanelRow.value = null;
+  sidePanelMode.value = "source";
+  sidePanelGuard.bump();
+}
+
+const canOpenTableStructureEditor = computed(() => sidePanelRow.value?.type === "TABLE" && canOpenStructureEditor.value);
+
+function openTableStructureEditor() {
+  const row = sidePanelRow.value;
+  if (!row || row.type !== "TABLE" || !canOpenTableStructureEditor.value) return;
+  queryStore.openTableStructure(props.connection.id, props.database, row.schema || selectedSchema.value, row.name, tableInfoTab.value);
+}
+
+async function openSource(row: ObjectBrowserRow) {
+  // Toggle off if clicking the same source row
+  if (sidePanelRow.value?.id === row.id && sidePanelMode.value === "source") {
+    closeSidePanel();
+    return;
+  }
+  // Starting a different object must invalidate slower source requests before
+  // any state is reset, otherwise an old response can populate the new row.
+  const epoch = sidePanelGuard.start();
+  sidePanelRow.value = row;
+  sidePanelMode.value = "source";
+  sourceRow.value = row;
+  sourceContent.value = "";
+  sourceError.value = "";
+  sourceEditing.value = false;
+  sourceCanEdit.value = true;
+  sourceEditableText.value = "";
+  sourceDraft.value = "";
+  sourceSaveError.value = "";
+  sourceLoading.value = true;
+  const connectionId = props.connection.id;
+  const database = props.database;
+  const schema = row.schema || selectedSchema.value || database;
+  try {
+    const result = await api.getObjectSource(connectionId, database, schema, row.name, row.type as ObjectSourceKind);
+    if (sidePanelGuard.isStale(epoch)) return;
+    sourceCanEdit.value = result.editable !== false && row.type !== "SEQUENCE";
+    const editable = await api.buildEditableObjectSource({
+      databaseType: effectiveDatabaseType.value,
+      objectType: row.type as ObjectSourceKind,
+      schema,
+      name: row.name,
+      source: result.source,
+    });
+    if (sidePanelGuard.isStale(epoch)) return;
+    // Viewing database source must preserve its original whitespace and comments;
+    // formatting remains an explicit editor action instead of altering it on open.
+    sourceEditableText.value = editable;
+    sourceContent.value = editable;
+    sourceDraft.value = editable;
+    sourceEditing.value = sourceCanEdit.value;
+    if (!sourceCanEdit.value && row.type !== "SEQUENCE") {
+      toast(t("objects.sourceReadOnly"), 3000);
+    }
+  } catch (e: any) {
+    if (sidePanelGuard.isStale(epoch)) return;
+    sourceError.value = e?.message || String(e);
+  } finally {
+    if (sidePanelGuard.isFresh(epoch)) sourceLoading.value = false;
+  }
+}
+
+async function openNewQuery(row: ObjectBrowserRow) {
+  const tabId = queryStore.createTab(props.connection.id, props.database, row.name);
+  queryStore.updateSql(
+    tabId,
+    await buildTableSelectSql({
+      databaseType: effectiveDatabaseType.value,
+      schema: row.schema || selectedSchema.value,
+      tableName: row.name,
+      limit: 100,
+    }),
+  );
+}
+
+function openProcedureExecution(row: ObjectBrowserRow) {
+  if (row.type !== "PROCEDURE") return;
+  procedureExecutionTarget.value = row;
+  showProcedureExecutionConfirm.value = true;
+}
+
+function openProcedureExecutionSql(sql: string) {
+  const row = procedureExecutionTarget.value;
+  if (!row || !sql) return;
+  const schema = row.schema || selectedSchema.value;
+  const tabId = queryStore.createTab(props.connection.id, props.database, `Execute - ${row.name}`, "query", schema);
+  queryStore.updateSql(tabId, sql);
+}
+
+async function executeProcedureSql(sql: string) {
+  const row = procedureExecutionTarget.value;
+  if (!row || !sql) return;
+  const schema = row.schema || selectedSchema.value;
+  const tabId = queryStore.createTab(props.connection.id, props.database, `Execute - ${row.name}`, "query", schema);
+  queryStore.updateSql(tabId, sql);
+  await queryStore.executeTabSql(tabId, sql);
+}
+
+function requestDrop(row: ObjectBrowserRow) {
+  dropTarget.value = row;
+  dropPreviewSql.value = "";
+  dropTableCascade.value = false;
+  showDropConfirm.value = true;
+  void refreshDropPreviewSql();
+}
+
+function requestRename(row: ObjectBrowserRow) {
+  renameTarget.value = row;
+  renameInput.value = row.name;
+  renameError.value = "";
+  renamePreviewSqlText.value = "";
+  showRenameDialog.value = true;
+}
+
+let renamePreviewRequestId = 0;
+
+async function refreshRenamePreviewSql() {
+  const requestId = ++renamePreviewRequestId;
+  const row = renameTarget.value;
+  const newName = renameInput.value.trim();
+  if (!showRenameDialog.value || !row || !newName || newName === row.name) {
+    renamePreviewSqlText.value = "";
+    return;
+  }
+  if (supportsSourceBackedRoutineRename(effectiveDatabaseType.value, row.type as ObjectSourceKind)) {
+    renamePreviewSqlText.value = `-- Recreate ${row.type} from source, then drop the original object.`;
+    return;
+  }
+  try {
+    const sql = await buildRenameObjectSql({
+      databaseType: effectiveDatabaseType.value,
+      objectType: row.type,
+      schema: row.schema || selectedSchema.value,
+      oldName: row.name,
+      newName,
+    });
+    if (requestId === renamePreviewRequestId) renamePreviewSqlText.value = sql;
+  } catch {
+    if (requestId === renamePreviewRequestId) renamePreviewSqlText.value = "";
+  }
+}
+
+watch([showRenameDialog, renameTarget, renameInput, selectedSchema], () => {
+  void refreshRenamePreviewSql();
+});
+
+async function confirmRename() {
+  const row = renameTarget.value;
+  const newName = renameInput.value.trim();
+  if (!row || !newName || newName === row.name) return;
+  renameError.value = "";
+  try {
+    const schema = row.schema || selectedSchema.value || props.database;
+    if (supportsSourceBackedRoutineRename(effectiveDatabaseType.value, row.type as ObjectSourceKind)) {
+      const source = await api.getObjectSource(props.connection.id, props.database, schema, row.name, row.type as ObjectSourceKind);
+      const statements = await buildRoutineRenameObjectSourceStatements({
+        databaseType: effectiveDatabaseType.value,
+        objectType: row.type as ObjectSourceKind,
+        schema,
+        name: row.name,
+        newName,
+        source: source.source,
+      });
+      const executed = await executeObjectBrowserSqlWithProductionGuard(statements.join(";\n"), async () => {
+        for (const sql of statements) {
+          await api.executeQuery(props.connection.id, props.database, sql, schema);
+        }
+        return true;
+      });
+      if (!executed) return;
+    } else {
+      const sql = await buildRenameObjectSql({
+        databaseType: effectiveDatabaseType.value,
+        objectType: row.type,
+        schema,
+        oldName: row.name,
+        newName,
+      });
+      const executed = await executeObjectBrowserSqlWithProductionGuard(sql, () => api.executeQuery(props.connection.id, props.database, sql, schema));
+      if (!executed) return;
+    }
+    toast(t("contextMenu.renameObjectSuccess", { oldName: row.name, newName }));
+    showRenameDialog.value = false;
+    if (sourceRow.value?.id === row.id) closeSource();
+    await reload();
+    await connectionStore.refreshObjectListTreeNode(props.connection.id, props.database, row.schema || selectedSchema.value);
+  } catch (e: any) {
+    renameError.value = e?.message || String(e);
+  }
+}
+
+async function confirmDrop() {
+  if (!dropTarget.value) return;
+  const row = dropTarget.value;
+  try {
+    const sql = dropPreviewSql.value || (await buildDropSqlForRow(row, { cascade: canDropTargetCascade.value && dropTableCascade.value }));
+    const executed = await executeObjectBrowserSqlWithProductionGuard(sql, () => api.executeQuery(props.connection.id, props.database, sql));
+    if (!executed) return;
+    const successKey = row.type === "VIEW" ? "contextMenu.dropViewSuccess" : row.type === "PROCEDURE" ? "contextMenu.dropProcedureSuccess" : row.type === "FUNCTION" ? "contextMenu.dropFunctionSuccess" : "contextMenu.dropTableSuccess";
+    toast(t(successKey, { name: row.name }));
+    closeDroppedTableObjectTabsForRow(row);
+    await reload();
+    await connectionStore.refreshObjectListTreeNode(props.connection.id, props.database, row.schema || selectedSchema.value);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+  dropTarget.value = null;
+  dropPreviewSql.value = "";
+  dropTableCascade.value = false;
+}
+
+async function buildDropSqlForRow(row: ObjectBrowserRow, options?: { cascade?: boolean }): Promise<string> {
+  if (row.type === "TABLE") {
+    return buildDropTableSql(tableAdminSqlOptions(row, { cascade: options?.cascade && supportsDropTableCascade(effectiveDatabaseType.value) }));
+  }
+  return buildDropObjectSql({
+    databaseType: effectiveDatabaseType.value,
+    objectType: row.type,
+    schema: row.schema || selectedSchema.value,
+    name: row.name,
+  });
+}
+
+let dropPreviewRequestId = 0;
+
+async function refreshDropPreviewSql() {
+  const requestId = ++dropPreviewRequestId;
+  const row = dropTarget.value;
+  if (!row) {
+    dropPreviewSql.value = "";
+    return;
+  }
+  dropPreviewSql.value = "";
+  const sql = await buildDropSqlForRow(row, { cascade: canDropTargetCascade.value && dropTableCascade.value }).catch(() => "");
+  if (requestId === dropPreviewRequestId) dropPreviewSql.value = sql;
+}
+
+function dropConfirmTitle(): string {
+  if (!dropTarget.value) return "";
+  const type = dropTarget.value.type;
+  if (type === "VIEW" || type === "MATERIALIZED_VIEW") return t("contextMenu.confirmDropViewTitle");
+  if (type === "PROCEDURE") return t("contextMenu.confirmDropProcedureTitle");
+  if (type === "FUNCTION") return t("contextMenu.confirmDropFunctionTitle");
+  return t("contextMenu.confirmDropTableTitle");
+}
+
+function dropConfirmMessage(): string {
+  if (!dropTarget.value) return "";
+  const name = dropTarget.value.name;
+  const type = dropTarget.value.type;
+  if (type === "VIEW" || type === "MATERIALIZED_VIEW") return t("contextMenu.confirmDropViewMessage", { name });
+  if (type === "PROCEDURE") return t("contextMenu.confirmDropProcedureMessage", { name });
+  if (type === "FUNCTION") return t("contextMenu.confirmDropFunctionMessage", { name });
+  return t("contextMenu.confirmDropTableMessage", { name });
+}
+
+function closeSource() {
+  sourceRow.value = null;
+  sidePanelRow.value = null;
+  sourceContent.value = "";
+  sourceError.value = "";
+  sourceEditing.value = false;
+  sourceEditableText.value = "";
+  sourceDraft.value = "";
+  sourceSaveError.value = "";
+}
+
+async function saveFileContent(content: string, defaultFileName: string, filterName: string, filterExt: string) {
+  if (isTauriRuntime()) {
+    const { save } = await import("@tauri-apps/plugin-dialog");
+    const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+    const path = await save({
+      defaultPath: defaultFileName,
+      filters: [{ name: filterName, extensions: [filterExt] }],
+    });
+    if (path) await writeTextFile(path, content);
+  } else {
+    const blob = new Blob([content], { type: "text/plain" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = defaultFileName;
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+}
+
+function openViewData(row: ObjectBrowserRow) {
+  emit("openTable", { tableName: row.name, schema: row.schema, tableType: row.type, catalog: props.catalog });
+}
+
+function openStructureEditor(row: ObjectBrowserRow) {
+  if (row.type !== "TABLE") return;
+  queryStore.openTableStructure(props.connection.id, props.database, row.schema || selectedSchema.value, row.name);
+}
+
+function droppedTableObjectTypeForRow(row: ObjectBrowserRow): "TABLE" | "VIEW" | "MATERIALIZED_VIEW" | null {
+  if (row.type === "TABLE") return "TABLE";
+  if (row.type === "VIEW") return "VIEW";
+  if (row.type === "MATERIALIZED_VIEW") return "MATERIALIZED_VIEW";
+  return null;
+}
+
+function closeDroppedTableObjectTabsForRow(row: ObjectBrowserRow) {
+  const objectType = droppedTableObjectTypeForRow(row);
+  if (!objectType) return;
+  queryStore.closeDroppedTableObjectTabs({
+    connectionId: props.connection.id,
+    database: props.database,
+    schema: row.schema || selectedSchema.value,
+    name: row.name,
+    objectType,
+  });
+}
+
+function openDiagram(row: ObjectBrowserRow) {
+  connectionStore.diagramSource = {
+    connectionId: props.connection.id,
+    database: props.database,
+    schema: row.schema || selectedSchema.value,
+    tableName: row.type === "TABLE" ? row.name : undefined,
+  };
+}
+
+function openTableImport(row: ObjectBrowserRow) {
+  if (row.type !== "TABLE") return;
+  connectionStore.tableImportSource = {
+    connectionId: props.connection.id,
+    database: props.database,
+    schema: row.schema || selectedSchema.value,
+    tableName: row.name,
+  };
+}
+
+function openDataCompare(row: ObjectBrowserRow) {
+  connectionStore.dataCompareSource = {
+    connectionId: props.connection.id,
+    database: props.database,
+    schema: row.schema || selectedSchema.value,
+    tableName: row.type === "TABLE" ? row.name : undefined,
+  };
+}
+
+function openDatabaseExport(row: ObjectBrowserRow) {
+  connectionStore.databaseExportSource = {
+    connectionId: props.connection.id,
+    database: props.database,
+    schema: row.schema || selectedSchema.value,
+    tableName: row.type === "TABLE" || row.type === "VIEW" || row.type === "MATERIALIZED_VIEW" ? row.name : undefined,
+  };
+}
+
+function setSelectedTableIds(ids: Set<string>) {
+  selectedTableIds.value = new Set(ids);
+}
+
+function toggleTableSelection(row: ObjectBrowserRow) {
+  if (row.type !== "TABLE") return;
+  const next = new Set(selectedTableIds.value);
+  if (next.has(row.id)) {
+    next.delete(row.id);
+  } else {
+    next.add(row.id);
+  }
+  setSelectedTableIds(next);
+}
+
+function toggleVisibleTableSelection() {
+  const next = new Set(selectedTableIds.value);
+  if (allVisibleTablesSelected.value) {
+    for (const row of visibleSelectableRows.value) next.delete(row.id);
+  } else {
+    for (const row of visibleSelectableRows.value) next.add(row.id);
+  }
+  setSelectedTableIds(next);
+}
+
+function clearTableSelection() {
+  setSelectedTableIds(new Set());
+}
+
+function openBatchDatabaseExport() {
+  const selectedTables = selectedTableRows.value.map((row) => row.name);
+  if (selectedTables.length === 0) return;
+  connectionStore.databaseExportSource = {
+    connectionId: props.connection.id,
+    database: props.database,
+    schema: selectedTableRows.value[0]?.schema || selectedSchema.value,
+    tableNames: selectedTables,
+  };
+}
+
+async function fetchSortedTableRowsForDrop(): Promise<ObjectBrowserRow[]> {
+  const rows = [...selectedTableRows.value];
+  if (rows.length <= 1) return rows;
+
+  const fkResults = await Promise.all(rows.map((row) => api.listForeignKeys(props.connection.id, props.database, row.schema || selectedSchema.value || "", row.name).catch(() => [] as ForeignKeyInfo[])));
+
+  const tablesWithFk: TableWithFk[] = rows.map((row, i) => ({
+    name: row.name,
+    schema: row.schema || selectedSchema.value,
+    foreignKeys: fkResults[i] ?? [],
+  }));
+
+  const sorted = sortTablesByFkDependency(tablesWithFk);
+  const nameToRow = new Map(rows.map((r) => [r.name, r]));
+  return sorted.map((t) => nameToRow.get(t.name)!).filter(Boolean);
+}
+
+async function refreshBatchDropPreviewSql() {
+  const statements: string[] = [];
+  const sortedRows = await fetchSortedTableRowsForDrop();
+  const useCascade = canBatchDropCascade.value && batchDropCascade.value;
+  for (const row of sortedRows) {
+    const sql = await buildDropTableSql(tableAdminSqlOptions(row, { cascade: useCascade })).catch(() => "");
+    if (sql) statements.push(sql);
+  }
+  batchDropPreviewSql.value = statements.join("\n");
+}
+
+function requestBatchDropTables() {
+  if (selectedTableCount.value === 0) return;
+  batchDropCascade.value = false;
+  batchDropPreviewSql.value = "";
+  void refreshBatchDropPreviewSql();
+  showBatchDropConfirm.value = true;
+}
+
+async function confirmBatchDropTables() {
+  const targets = await fetchSortedTableRowsForDrop();
+  if (targets.length === 0) return;
+  try {
+    const useCascade = canBatchDropCascade.value && batchDropCascade.value;
+    const statements = await Promise.all(
+      targets.map(async (row) => ({
+        row,
+        sql: await buildDropTableSql(tableAdminSqlOptions(row, { cascade: useCascade })),
+      })),
+    );
+    const executed = await executeObjectBrowserSqlWithProductionGuard(statements.map(({ sql }) => sql).join(";\n"), async () => {
+      for (const { row, sql } of statements) {
+        await api.executeQuery(props.connection.id, props.database, sql);
+        closeDroppedTableObjectTabsForRow(row);
+      }
+      return true;
+    });
+    if (!executed) return;
+    toast(t("objects.batchDropSuccess", { count: targets.length }));
+    clearTableSelection();
+    await reload();
+    await connectionStore.refreshObjectListTreeNode(props.connection.id, props.database, selectedSchema.value);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function refreshBatchTruncatePreviewSql() {
+  const statements: string[] = [];
+  const useCascade = canBatchTruncateCascade.value && batchTruncateCascade.value;
+  for (const row of selectedTableRows.value) {
+    const sql = await buildTruncateTableSql(tableAdminSqlOptions(row, { cascade: useCascade })).catch(() => "");
+    if (sql) statements.push(sql);
+  }
+  batchTruncatePreviewSql.value = statements.join("\n");
+}
+
+function requestBatchTruncateTables() {
+  if (selectedTableCount.value === 0 || !supportsTruncateTable.value) return;
+  batchTruncateCascade.value = false;
+  batchTruncatePreviewSql.value = "";
+  void refreshBatchTruncatePreviewSql();
+  showBatchTruncateConfirm.value = true;
+}
+
+function tableDataRefreshTargetForRow(row: ObjectBrowserRow) {
+  return {
+    connectionId: props.connection.id,
+    database: props.database,
+    schema: row.schema || selectedSchema.value,
+    schemaCandidates: [row.schema, selectedSchema.value],
+    catalog: props.catalog,
+    name: row.name,
+  };
+}
+
+async function refreshMutatedTableDataTabsForRows(rows: readonly ObjectBrowserRow[]) {
+  for (const row of rows) {
+    const target = tableDataRefreshTargetForRow(row);
+    try {
+      await queryStore.refreshDataTabsForTable(target);
+    } catch (error) {
+      console.warn("[DBX][table-data-refresh-after-mutation:error]", { target, error });
+    }
+  }
+}
+
+async function confirmBatchTruncateTables() {
+  const targets = [...selectedTableRows.value];
+  if (targets.length === 0) return;
+  try {
+    const useCascade = canBatchTruncateCascade.value && batchTruncateCascade.value;
+    const statements = await Promise.all(
+      targets.map(async (row) => ({
+        row,
+        sql: await buildTruncateTableSql(tableAdminSqlOptions(row, { cascade: useCascade })),
+      })),
+    );
+    const executed = await executeObjectBrowserSqlWithProductionGuard(statements.map(({ sql }) => sql).join(";\n"), async () => {
+      await runBatchTableTruncate(
+        statements,
+        async ({ sql }) => {
+          await api.executeQuery(props.connection.id, props.database, sql);
+        },
+        async (succeeded) => refreshMutatedTableDataTabsForRows(succeeded.map(({ row }) => row)),
+      );
+      return true;
+    });
+    if (!executed) return;
+    toast(t("objects.batchTruncateSuccess", { count: targets.length }));
+    clearTableSelection();
+    showBatchTruncateConfirm.value = false;
+    await reload();
+    await connectionStore.refreshObjectListTreeNode(props.connection.id, props.database, selectedSchema.value);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function refreshBatchEmptyPreviewSql(targets: ObjectBrowserRow[]) {
+  const plan = await buildBatchTableEmptyPlan(targets, (row) => buildEmptyTableSql(tableAdminSqlOptions(row)));
+  // Freeze the reviewed SQL with its target so confirmation cannot execute a different destructive statement.
+  batchEmptyPlan.value = plan;
+  batchEmptyPreviewSql.value = plan.map(({ sql }) => sql).join("\n");
+}
+
+function requestBatchEmptyTables() {
+  const targets = [...selectedTableRows.value];
+  if (targets.length === 0) return;
+  batchEmptyPlan.value = [];
+  batchEmptyPreviewSql.value = "";
+  void refreshBatchEmptyPreviewSql(targets)
+    .then(() => {
+      showBatchEmptyConfirm.value = true;
+    })
+    .catch((e: any) => {
+      batchEmptyPlan.value = [];
+      toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+    });
+}
+
+async function confirmBatchEmptyTables() {
+  const plan = batchEmptyPlan.value.slice();
+  if (plan.length === 0) return;
+  const asynchronousMutation = effectiveDatabaseType.value === "clickhouse";
+  const reviewSql = plan.map(({ sql }) => sql).join(";\n");
+  const result = await executeObjectBrowserSqlWithProductionGuard(reviewSql, () => {
+    return runBatchTableEmpty(plan, async ({ sql }) => {
+      await api.executeQuery(props.connection.id, props.database, sql);
+    });
+  });
+  if (!result) return;
+  for (const failure of result.failed) {
+    console.error(`Failed to empty table "${failure.target.target.name}":`, failure.error);
+  }
+  const feedback = batchTableEmptyFeedback(result, asynchronousMutation);
+  if (feedback === "success") {
+    toast(t("contextMenu.batchEmptySuccess", { count: result.succeeded.length }), 3000);
+  } else if (feedback === "submitted") {
+    toast(t("contextMenu.batchEmptySubmitted", { count: result.succeeded.length }), 3000);
+  } else if (feedback === "submitted-partial") {
+    toast(t("contextMenu.batchEmptySubmittedPartial", { success: result.succeeded.length, failed: result.failed.length }), 5000);
+  } else {
+    toast(t("contextMenu.batchEmptyPartialFail", { success: result.succeeded.length, failed: result.failed.length }), 5000);
+  }
+  batchEmptyPlan.value = [];
+  showBatchEmptyConfirm.value = false;
+  if (result.succeeded.length > 0) {
+    clearTableSelection();
+    await reload();
+    await connectionStore.refreshObjectListTreeNode(props.connection.id, props.database, selectedSchema.value);
+  }
+}
+
+async function exportStructure(row: ObjectBrowserRow) {
+  try {
+    const schema = row.schema || selectedSchema.value || props.database;
+    const ddl = await api.getTableDdl(props.connection.id, props.database, schema, row.name, tableDdlObjectType(row.type));
+    await saveFileContent(buildSingleDdlExportFileContent(ddl), `${row.name}.sql`, "SQL", "sql");
+  } catch (e: any) {
+    console.error("Export structure failed:", e);
+  }
+}
+
+function tableDdlObjectType(type: ObjectBrowserRow["type"]): ObjectSourceKind | undefined {
+  if (type === "VIEW" || type === "MATERIALIZED_VIEW") return type;
+  return undefined;
+}
+
+async function exportDataLegacy(row: ObjectBrowserRow, format: "json" | "sql") {
+  try {
+    const schema = row.schema || selectedSchema.value;
+    const tableColumns = format === "sql" ? await api.getColumns(props.connection.id, props.database, schema || props.database, row.name) : undefined;
+    const queryColumns = props.connection.db_type === "neo4j" ? (tableColumns ?? (await api.getColumns(props.connection.id, props.database, schema || props.database, row.name))).map((column) => column.name) : undefined;
+    const result = await fetchTableDataForExport({
+      databaseType: effectiveDatabaseType.value,
+      schema,
+      tableName: row.name,
+      columns: queryColumns,
+      executePage: (sql) => api.executeQuery(props.connection.id, props.database, sql),
+    });
+
+    if (format === "json") {
+      let outputPath = `${row.name}.json`;
+      if (isTauriRuntime()) {
+        const { save } = await import("@tauri-apps/plugin-dialog");
+        const path = await save({
+          defaultPath: outputPath,
+          filters: [{ name: "JSON", extensions: ["json"] }],
+        });
+        if (!path) return;
+        outputPath = path as string;
+      }
+      await api.exportQueryResultJson(outputPath, result.columns, result.rows);
+      toast(t("grid.exported"));
+      return;
+    }
+
+    const content = await formatSqlInsert({
+      databaseType: effectiveDatabaseType.value,
+      schema,
+      tableName: row.name,
+      columns: result.columns,
+      columnTypes: tableColumns ? columnTypesForResultColumns(result.columns, tableColumns) : undefined,
+      rows: result.rows,
+    });
+    await saveFileContent(content, `${row.name}.sql`, "SQL", "sql");
+    toast(t("grid.exported"));
+  } catch (e: any) {
+    toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function columnTypesForResultColumns(columns: string[], tableColumns: Array<{ name: string; data_type: string }>): Array<string | undefined> {
+  const typesByName = new Map(tableColumns.map((column) => [column.name.toLocaleLowerCase(), column.data_type]));
+  return columns.map((column) => typesByName.get(column.toLocaleLowerCase()));
+}
+
+async function exportData(row: ObjectBrowserRow, format: "csv" | "json" | "sql") {
+  if (format === "csv") {
+    await exportTableData(row, "csv");
+    return;
+  }
+  await exportDataLegacy(row, format);
+}
+
+async function exportDataXlsx(row: ObjectBrowserRow) {
+  await exportTableData(row, "xlsx");
+}
+
+async function exportTableData(row: ObjectBrowserRow, format: "csv" | "xlsx") {
+  const schema = row.schema || selectedSchema.value;
+
+  // Save dialog first
+  let filePath = "";
+  const defaultName = `${row.name}.${format}`;
+
+  if (isTauriRuntime()) {
+    try {
+      const { save } = await import("@tauri-apps/plugin-dialog");
+      const filter = format === "csv" ? { name: "CSV", extensions: ["csv"] } : { name: "Excel", extensions: ["xlsx"] };
+      const path = await save({
+        defaultPath: defaultName,
+        filters: [filter],
+      });
+      if (!path) return;
+      filePath = path as string;
+    } catch (e: any) {
+      toast(e?.message || String(e), 5000);
+      return;
+    }
+  } else {
+    const webExportId = generateDatabaseExportId();
+    filePath = `__web_export_${webExportId}.${format}`;
+  }
+
+  let task: ExportTask | null = null;
+  try {
+    const queryColumns = props.connection.db_type === "neo4j" ? (await api.getColumns(props.connection.id, props.database, schema || props.database, row.name)).map((column) => column.name) : undefined;
+
+    task = addExportTask(row.name, format, filePath);
+    const currentTask = task;
+    const rowLimit = settingsStore.editorSettings.exportRowLimitEnabled ? settingsStore.editorSettings.exportRowLimit : null;
+    const request: api.TableExportRequest = {
+      exportId: currentTask.exportId,
+      connectionId: props.connection.id,
+      database: props.database,
+      schema,
+      tableName: row.name,
+      filePath,
+      format,
+      columns: queryColumns,
+      batchSize: settingsStore.editorSettings.exportBatchSize,
+      rowLimit,
+    };
+
+    const terminalProgress = await api.startTableExport(request, (progress) => {
+      currentTask.rowsExported = progress.rowsExported;
+      currentTask.totalRows = progress.totalRows;
+      currentTask.status = progress.status;
+      currentTask.errorMessage = progress.errorMessage || null;
+    });
+    if (terminalProgress.status === "Done") {
+      toast(t("grid.exported"));
+    }
+  } catch (e: any) {
+    if (task) {
+      task.status = "Error";
+      task.errorMessage = e?.message || String(e);
+    }
+    toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function requestDuplicateStructure(row: ObjectBrowserRow) {
+  duplicateTarget.value = row;
+  duplicateTableName.value = `${row.name}_copy`;
+  showDuplicateDialog.value = true;
+}
+
+async function confirmDuplicateStructure() {
+  const row = duplicateTarget.value;
+  const newName = duplicateTableName.value.trim();
+  if (!row || !newName) return;
+  showDuplicateDialog.value = false;
+  try {
+    const schema = row.schema || selectedSchema.value;
+    const sql = await buildDuplicateTableStructureSql({
+      databaseType: effectiveDatabaseType.value,
+      schema,
+      sourceName: row.name,
+      targetName: newName,
+    });
+    const executed = await executeObjectBrowserSqlWithProductionGuard(sql, () => api.executeQuery(props.connection.id, props.database, sql, schema));
+    if (!executed) return;
+    toast(t("contextMenu.duplicateStructureSuccess", { name: newName }));
+    await reload();
+    await connectionStore.refreshObjectListTreeNode(props.connection.id, props.database, schema);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function copySelectedTablesToClipboard() {
+  const selectedRows = selectedTableRows.value;
+  if (selectedRows.length === 0) return;
+  connectionStore.treeClipboard = {
+    kind: "table-copy",
+    tables: selectedRows.map((row) => ({
+      connectionId: props.connection.id,
+      database: props.database,
+      schema: row.schema || selectedSchema.value,
+      tableName: row.name,
+    })),
+  };
+  toast(t("contextMenu.pasteTableClipboardUpdated"), 2000);
+}
+
+function canPasteTableClipboard(): boolean {
+  const clipboard = connectionStore.treeClipboard;
+  return clipboard?.kind === "table-copy" && tableClipboardMatchesTarget(clipboard.tables, pasteTableTargetContext());
+}
+
+function pasteTableTargetContext(): TableClipboardContext {
+  return {
+    connectionId: props.connection.id,
+    database: props.database,
+    schema: selectedSchema.value,
+  };
+}
+
+function copySingleTableToClipboard(row: ObjectBrowserRow) {
+  connectionStore.treeClipboard = {
+    kind: "table-copy",
+    tables: [
+      {
+        connectionId: props.connection.id,
+        database: props.database,
+        schema: row.schema || selectedSchema.value,
+        tableName: row.name,
+      },
+    ],
+  };
+  toast(t("contextMenu.pasteTableClipboardUpdated"), 2000);
+}
+
+function openPasteTableDialog() {
+  const clipboard = connectionStore.treeClipboard;
+  if (!canPasteTableClipboard() || clipboard?.kind !== "table-copy") {
+    toast(t("contextMenu.noTableToPaste"), 2000);
+    return;
+  }
+  pasteTableMode.value = defaultPasteTableMode(effectiveDatabaseType.value);
+  pasteTableEntries.value = clipboard.tables.map((entry) => ({
+    sourceName: entry.tableName,
+    targetName: `${entry.tableName}_copy`,
+    schema: entry.schema,
+  }));
+  showPasteDialog.value = true;
+}
+
+function onObjectBrowserKeydown(event: KeyboardEvent) {
+  if (event.defaultPrevented) return;
+  if (eventTargetAllowsAppClipboardShortcut(event, "c")) {
+    if (selectedTableCount.value === 0) return;
+    event.preventDefault();
+    event.stopPropagation();
+    copySelectedTablesToClipboard();
+    return;
+  }
+  if (eventTargetAllowsAppClipboardShortcut(event, "v")) {
+    if (!canPasteTableClipboard()) return;
+    event.preventDefault();
+    event.stopPropagation();
+    openPasteTableDialog();
+  }
+}
+
+async function confirmPasteTable() {
+  const entries = pasteTableEntries.value.filter((entry) => entry.targetName.trim());
+  if (entries.length === 0) return;
+  const mode = pasteTableMode.value;
+  const copyData = pasteTableModeCopiesData(mode) && pasteTableDataCopySupported.value;
+  showPasteDialog.value = false;
+  let successCount = 0;
+  let failCount = 0;
+  for (const entry of entries) {
+    const targetName = entry.targetName.trim();
+    const schema = entry.schema || selectedSchema.value;
+    try {
+      if (mode === "structure-and-data" || mode === "structure-only") {
+        const structureSql = await buildDuplicateTableStructureSql({
+          databaseType: effectiveDatabaseType.value,
+          schema,
+          sourceName: entry.sourceName,
+          targetName,
+        });
+        const executed = await executeObjectBrowserSqlWithProductionGuard(structureSql, () => api.executeQuery(props.connection.id, props.database, structureSql, schema));
+        if (!executed) return;
+      }
+      if (copyData) {
+        const sourceColumns = await api.getColumns(props.connection.id, props.database, schema || "", entry.sourceName);
+        const dataCopyColumnOptions = tableDataCopyColumnOptions(effectiveDatabaseType.value, sourceColumns);
+        if (dataCopyColumnOptions.columns.length === 0) {
+          throw new Error("No writable columns available for table data copy.");
+        }
+        const dataSql = await buildCopyTableDataSql({
+          databaseType: effectiveDatabaseType.value,
+          schema,
+          sourceName: entry.sourceName,
+          targetName,
+          ...dataCopyColumnOptions,
+        });
+        const executed = await executeObjectBrowserSqlWithProductionGuard(dataSql, () => api.executeQuery(props.connection.id, props.database, dataSql, schema));
+        if (!executed) return;
+      }
+      successCount++;
+    } catch (e: any) {
+      failCount++;
+      console.error(`Failed to paste table "${entry.sourceName}" -> "${targetName}":`, e);
+    }
+  }
+  if (failCount === 0) {
+    toast(t("contextMenu.batchPasteSuccess", { count: successCount }), 3000);
+  } else {
+    toast(t("contextMenu.batchPastePartialFail", { success: successCount, failed: failCount }), 5000);
+  }
+  await reload();
+  await connectionStore.refreshObjectListTreeNode(props.connection.id, props.database, selectedSchema.value);
+}
+
+function tableAdminSqlOptions(row: ObjectBrowserRow, options?: { cascade?: boolean }): TableAdminSqlOptions {
+  const result: TableAdminSqlOptions = {
+    databaseType: effectiveDatabaseType.value,
+    schema: row.schema || selectedSchema.value,
+    tableName: row.name,
+  };
+  if (options?.cascade) result.cascade = true;
+  return result;
+}
+
+/**
+ * Routes Object Browser writes through the shared production gate. The SQL is
+ * assessed before the callback runs so generated DDL cannot bypass protection
+ * via executable comments, EXPLAIN ANALYZE, or qualified production targets.
+ */
+async function executeObjectBrowserSqlWithProductionGuard<T>(sql: string, execute: () => Promise<T>): Promise<T | undefined> {
+  return executeWithProductionSqlGuard({
+    connection: props.connection,
+    database: props.database,
+    sql,
+    source: t("production.sourceObjectBrowser"),
+    execute,
+  });
+}
+
+async function refreshTruncatePreviewSql(row: ObjectBrowserRow) {
+  truncatePreviewSql.value = "";
+  truncatePreviewSql.value = await buildTruncateTableSql(tableAdminSqlOptions(row, { cascade: canTruncateTargetCascade.value && truncateTableCascade.value })).catch(() => "");
+}
+
+function requestTruncateTable(row: ObjectBrowserRow) {
+  truncateTarget.value = row;
+  truncateTableCascade.value = false;
+  void refreshTruncatePreviewSql(row);
+  showTruncateConfirm.value = true;
+}
+
+async function confirmTruncateTable() {
+  const row = truncateTarget.value;
+  if (!row) return;
+  try {
+    const sql = truncatePreviewSql.value || (await buildTruncateTableSql(tableAdminSqlOptions(row, { cascade: canTruncateTargetCascade.value && truncateTableCascade.value })));
+    const executed = await executeObjectBrowserSqlWithProductionGuard(sql, () => api.executeQuery(props.connection.id, props.database, sql));
+    if (!executed) return;
+    toast(t("contextMenu.truncateTableSuccess", { name: row.name }));
+    await refreshMutatedTableDataTabsForRows([row]);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+  truncateTarget.value = null;
+}
+
+async function refreshEmptyPreviewSql(row: ObjectBrowserRow) {
+  emptyPreviewSql.value = "";
+  emptyPreviewSql.value = await buildEmptyTableSql(tableAdminSqlOptions(row)).catch(() => "");
+}
+
+function requestEmptyTable(row: ObjectBrowserRow) {
+  emptyTarget.value = row;
+  void refreshEmptyPreviewSql(row);
+  showEmptyConfirm.value = true;
+}
+
+async function confirmEmptyTable() {
+  const row = emptyTarget.value;
+  if (!row) return;
+  try {
+    const sql = emptyPreviewSql.value || (await buildEmptyTableSql(tableAdminSqlOptions(row)));
+    const executed = await executeObjectBrowserSqlWithProductionGuard(sql, () => api.executeQuery(props.connection.id, props.database, sql));
+    if (!executed) return;
+    toast(t("contextMenu.emptyTableSuccess", { name: row.name }));
+    await refreshMutatedTableDataTabsForRows([row]);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+  emptyTarget.value = null;
+}
+
+async function copyName(row: ObjectBrowserRow) {
+  try {
+    await copyToClipboard(row.name);
+    toast(t("connection.copied"), 2000);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function copySource() {
+  if (!sourceContent.value) return;
+  try {
+    await copyToClipboard(sourceContent.value);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function editSource() {
+  if (!sourceRow.value || !sourceEditableText.value) return;
+  if (!sourceCanEdit.value) {
+    toast(t("objects.sourceReadOnly"), 3000);
+    return;
+  }
+  sourceDraft.value = sourceEditableText.value;
+  sourceSaveError.value = "";
+  sourceEditing.value = true;
+}
+
+function cancelEditSource() {
+  sourceEditing.value = false;
+  sourceDraft.value = "";
+  sourceSaveError.value = "";
+}
+
+async function saveSource() {
+  if (!sourceCanEdit.value) {
+    toast(t("objects.sourceReadOnly"), 3000);
+    return;
+  }
+  if (!sourceRow.value || !sourceDraft.value.trim()) return;
+  const row = sourceRow.value;
+  const epoch = sidePanelGuard.capture();
+  const connectionId = props.connection.id;
+  const database = props.database;
+  const schema = row.schema || selectedSchema.value || database;
+  sourceSaving.value = true;
+  sourceSaveError.value = "";
+  try {
+    const statements = await buildExecutableObjectSourceStatements({
+      databaseType: effectiveDatabaseType.value,
+      objectType: row.type as ObjectSourceKind,
+      schema,
+      name: row.name,
+      source: sourceDraft.value,
+    });
+    const executableSql = statements.filter((sql) => sql.trim()).join(";\n");
+    if (executableSql.trim()) {
+      const saved = await executeWithProductionSqlGuard({
+        connection: props.connection,
+        database,
+        sql: executableSql,
+        source: t("production.sourceObjectSource"),
+        execute: async () => {
+          await executeObjectSourceSave(connectionId, database, effectiveDatabaseType.value, statements, schema);
+          return true;
+        },
+      });
+      if (!saved || sidePanelGuard.isStale(epoch)) return;
+    } else {
+      await executeObjectSourceSave(connectionId, database, effectiveDatabaseType.value, statements, schema);
+      if (sidePanelGuard.isStale(epoch)) return;
+    }
+    toast(t("objects.sourceSaved"));
+    sourceEditing.value = false;
+    sourceDraft.value = "";
+    await openSource(row);
+  } catch (e: any) {
+    if (sidePanelGuard.isStale(epoch)) return;
+    sourceSaveError.value = e?.message || String(e);
+  } finally {
+    if (sidePanelGuard.isFresh(epoch)) sourceSaving.value = false;
+  }
+}
+
+async function loadSchemas() {
+  if (!needsSchema.value) {
+    schemas.value = [];
+    selectedSchema.value = undefined;
+    return;
+  }
+  loadingSchemas.value = true;
+  try {
+    const names = await api.listSchemas(props.connection.id, props.database);
+    schemas.value = names;
+    if (!selectedSchema.value || !names.includes(selectedSchema.value)) {
+      selectedSchema.value = names.includes("public") ? "public" : names[0];
+    }
+  } finally {
+    loadingSchemas.value = false;
+  }
+}
+
+async function loadObjects() {
+  const id = ++loadId;
+  loadingObjects.value = true;
+  error.value = "";
+  rows.value = [];
+  try {
+    const schema = needsSchema.value ? selectedSchema.value || "" : props.database;
+    const objects: ObjectInfo[] = await api.listObjects(props.connection.id, props.database, schema, undefined, undefined, undefined, undefined, props.catalog);
+    if (id !== loadId) return;
+    rows.value = buildObjectBrowserRows({
+      objects,
+      database: props.database,
+      fallbackSchema: schema,
+      needsSchema: needsSchema.value,
+    });
+    const availableTableIds = new Set(rows.value.filter((row) => row.type === "TABLE").map((row) => row.id));
+    setSelectedTableIds(new Set([...selectedTableIds.value].filter((id) => availableTableIds.has(id))));
+    expandedPartitionParentIds.value = new Set([...expandedPartitionParentIds.value].filter((id) => rows.value.some((row) => row.id === id && row.partitionCount)));
+    void loadObjectStatistics(id, schema);
+  } catch (e: any) {
+    if (id !== loadId) return;
+    error.value = e?.message || String(e);
+  } finally {
+    if (id === loadId) {
+      loadingObjects.value = false;
+      if (!userHasSelectedFilter.value && tableCount.value > 0) {
+        // The default table filter is a presentation choice, not a user query
+        // change, so preserve the tab's saved scroll offset across remounts.
+        preserveObjectFilterScrollOnce = objectFilter.value !== "tables";
+        objectFilter.value = "tables";
+      }
+      restoreObjectBrowserViewport();
+    }
+  }
+}
+
+async function loadObjectStatistics(id: number, schema: string) {
+  if (!rows.value.some((row) => row.type === "TABLE")) return;
+  try {
+    const stats = await api.listObjectStatistics(props.connection.id, props.database, schema);
+    if (id !== loadId || stats.length === 0) return;
+    mergeObjectStatistics(stats, schema);
+  } catch (e) {
+    console.debug("[ObjectBrowser] table statistics unavailable", e);
+  }
+}
+
+function mergeObjectStatistics(stats: ObjectStatistics[], fallbackSchema: string) {
+  const statsByKey = new Map(stats.map((stat) => [objectStatisticKey(stat.schema || fallbackSchema, stat.name), stat]));
+  rows.value = rows.value.map((row) => {
+    if (row.type !== "TABLE") return row;
+    const stat = statsByKey.get(objectStatisticKey(row.schema || fallbackSchema, row.name));
+    if (!stat) return row;
+    return {
+      ...row,
+      estimatedRows: normalizeStatisticNumber(stat.estimated_rows),
+      totalBytes: normalizeStatisticNumber(stat.total_bytes),
+    };
+  });
+}
+
+function objectStatisticKey(schema: string | undefined, name: string) {
+  return `${schema || ""}\0${name}`.toLowerCase();
+}
+
+function normalizeStatisticNumber(value: number | null | undefined): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+async function reload() {
+  await loadSchemas();
+  await loadObjects();
+}
+
+function onSchemaChange(value: any) {
+  selectedSchema.value = typeof value === "string" && value ? value : undefined;
+  emit("schemaChange", selectedSchema.value);
+  userHasSelectedFilter.value = false;
+  objectFilter.value = "all";
+  void loadObjects();
+}
+
+function filterCount(filter: ObjectFilter) {
+  if (filter === "tables") return tableCount.value;
+  if (filter === "views") return viewCount.value;
+  if (filter === "materializedViews") return materializedViewCount.value;
+  if (filter === "procedures") return procedureCount.value;
+  if (filter === "functions") return functionCount.value;
+  if (filter === "sequences") return sequenceCount.value;
+  if (filter === "packages") return packageCount.value;
+  return rows.value.length;
+}
+
+function filterLabel(filter: ObjectFilter) {
+  const key =
+    filter === "tables"
+      ? "objects.tables"
+      : filter === "views"
+        ? "objects.views"
+        : filter === "materializedViews"
+          ? "tree.materializedViews"
+          : filter === "procedures"
+            ? "objects.procedures"
+            : filter === "functions"
+              ? "objects.functions"
+              : filter === "sequences"
+                ? "objects.sequences"
+                : filter === "packages"
+                  ? "objects.packages"
+                  : "objects.all";
+  return `${t(key)} ${filterCount(filter)}`;
+}
+
+function getSearchInput(): HTMLInputElement | null {
+  return rootRef.value?.querySelector<HTMLInputElement>("[data-object-search-input]") ?? null;
+}
+
+function focusSearch(): boolean {
+  const input = getSearchInput();
+  if (!input) return false;
+  input.focus();
+  input.select();
+  return true;
+}
+
+function onSearchKeydown(event: KeyboardEvent) {
+  if (!isCancelSearchShortcut(event)) return;
+  event.preventDefault();
+  search.value = "";
+}
+
+defineExpose({ focusSearch });
+
+onBeforeUnmount(() => {
+  stopColumnResize?.();
+});
+
+watch(
+  () => [props.connection.id, props.database, props.schema] as const,
+  async () => {
+    selectedSchema.value = props.schema;
+    userHasSelectedFilter.value = false;
+    objectFilter.value = "all";
+    clearTableSelection();
+    // Close side panel and invalidate any pending source/table-info requests
+    // so stale results from the old context don't overwrite new state.
+    closeSidePanel();
+    sourceRow.value = null;
+    sourceContent.value = "";
+    sourceError.value = "";
+    sourceLoading.value = false;
+    sourceEditing.value = false;
+    sourceSaving.value = false;
+    try {
+      await connectionStore.ensureConnected(props.connection.id);
+    } catch (e) {
+      console.warn("[DBX] ensureConnected failed for", props.connection.id, e);
+    }
+    void reload();
+  },
+  { immediate: true },
+);
+
+// ---- CustomContextMenu helpers ----
+
+function exportDataSubmenu(item: ObjectBrowserRow): ContextMenuItem {
+  return {
+    label: t("contextMenu.exportData"),
+    icon: Upload,
+    children: [
+      { label: "CSV", action: () => exportData(item, "csv") },
+      { label: "JSON", action: () => exportData(item, "json") },
+      { label: "SQL INSERT", action: () => exportData(item, "sql") },
+      { label: "XLSX", action: () => exportDataXlsx(item) },
+    ],
+  };
+}
+
+function isSelectedBatchTableContext(item: ObjectBrowserRow): boolean {
+  return item.type === "TABLE" && selectedTableCount.value > 1 && selectedTableIds.value.has(item.id);
+}
+
+function selectedBatchTableCountLabel(key: "batchDrop" | "batchTruncate" | "batchEmpty"): string {
+  return t(`contextMenu.${key}`, { count: selectedTableCount.value });
+}
+
+function getTableMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {
+  const useBatchActions = isSelectedBatchTableContext(item);
+  return [
+    { label: t("contextMenu.viewData"), action: () => openViewData(item), icon: Table2 },
+    {
+      label: t("contextMenu.viewDdl"),
+      action: () => openTableInfo(item, "ddl"),
+      icon: FileCode,
+    },
+    ...(canOpenStructureEditor.value ? [{ label: t("contextMenu.editStructure"), action: () => openStructureEditor(item), icon: PencilRuler }] : []),
+    ...(canRename(item) ? [{ label: t("contextMenu.renameObject"), action: () => requestRename(item), icon: Pencil }] : []),
+    { label: t("contextMenu.newQuery"), action: () => openNewQuery(item), icon: TerminalSquare },
+    ...(canOpenDiagram.value ? [{ label: t("diagram.open"), action: () => openDiagram(item), icon: Network }] : []),
+    ...(canOpenTableImport.value ? [{ label: t("contextMenu.importData"), action: () => openTableImport(item), icon: Download }] : []),
+    { label: t("dataCompare.title"), action: () => openDataCompare(item), icon: ArrowRightLeft },
+    { label: "", separator: true },
+    exportDataSubmenu(item),
+    { label: t("contextMenu.exportDatabase"), action: () => openDatabaseExport(item), icon: Upload },
+    { label: t("contextMenu.exportStructure"), action: () => exportStructure(item), icon: FileCode },
+    { label: "", separator: true },
+    { label: t("contextMenu.duplicateStructure"), action: () => requestDuplicateStructure(item), icon: CopyPlus },
+    { label: t("contextMenu.copyTable"), action: () => copySingleTableToClipboard(item), icon: Copy },
+    { label: "", separator: true },
+    ...(supportsTruncateTable.value
+      ? [
+          {
+            label: useBatchActions ? selectedBatchTableCountLabel("batchTruncate") : t("contextMenu.truncateTable"),
+            action: useBatchActions ? requestBatchTruncateTables : () => requestTruncateTable(item),
+            icon: Scissors,
+            variant: "destructive" as const,
+          },
+        ]
+      : []),
+    {
+      label: useBatchActions ? selectedBatchTableCountLabel("batchEmpty") : t("contextMenu.emptyTable"),
+      action: useBatchActions ? requestBatchEmptyTables : () => requestEmptyTable(item),
+      icon: Eraser,
+      variant: "destructive" as const,
+    },
+    {
+      label: useBatchActions ? selectedBatchTableCountLabel("batchDrop") : t("contextMenu.dropTable"),
+      action: useBatchActions ? requestBatchDropTables : () => requestDrop(item),
+      icon: Trash2,
+      variant: "destructive" as const,
+    },
+    { label: "", separator: true },
+    { label: t("contextMenu.copyName"), action: () => copyName(item), icon: Copy },
+  ];
+}
+
+function getViewMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {
+  return [
+    { label: t("contextMenu.viewData"), action: () => openViewData(item), icon: Table2 },
+    { label: t("contextMenu.editView"), action: () => openSource(item), icon: PencilLine },
+    { label: t("contextMenu.viewSource"), action: () => openSource(item), icon: Code2 },
+    {
+      label: t("contextMenu.viewDdl"),
+      action: () => openTableInfo(item, "ddl"),
+      icon: ScrollText,
+    },
+    ...(canRename(item) ? [{ label: t("contextMenu.renameObject"), action: () => requestRename(item), icon: Pencil }] : []),
+    { label: t("contextMenu.newQuery"), action: () => openNewQuery(item), icon: TerminalSquare },
+    ...(canOpenDiagram.value ? [{ label: t("diagram.open"), action: () => openDiagram(item), icon: Network }] : []),
+    { label: "", separator: true },
+    exportDataSubmenu(item),
+    { label: t("contextMenu.exportDatabase"), action: () => openDatabaseExport(item), icon: Upload },
+    { label: t("contextMenu.exportStructure"), action: () => exportStructure(item), icon: FileCode },
+    { label: "", separator: true },
+    {
+      label: t("contextMenu.dropView"),
+      action: () => requestDrop(item),
+      icon: Trash2,
+      variant: "destructive" as const,
+    },
+    { label: "", separator: true },
+    { label: t("contextMenu.copyName"), action: () => copyName(item), icon: Copy },
+  ];
+}
+
+function getProcFuncMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {
+  return [
+    ...(item.type === "PROCEDURE" ? [{ label: t("contextMenu.executeProcedure"), action: () => openProcedureExecution(item), icon: Play }] : []),
+    { label: t("contextMenu.viewSource"), action: () => openSource(item), icon: Code2 },
+    ...(canRename(item) ? [{ label: t("contextMenu.renameObject"), action: () => requestRename(item), icon: Pencil }] : []),
+    { label: "", separator: true },
+    {
+      label: item.type === "PROCEDURE" ? t("contextMenu.dropProcedure") : t("contextMenu.dropFunction"),
+      action: () => requestDrop(item),
+      icon: Trash2,
+      variant: "destructive" as const,
+    },
+    { label: "", separator: true },
+    { label: t("contextMenu.copyName"), action: () => copyName(item), icon: Copy },
+  ];
+}
+
+function getPackageMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {
+  return [
+    { label: t("contextMenu.viewSource"), action: () => openSource(item), icon: Code2 },
+    { label: "", separator: true },
+    { label: t("contextMenu.copyName"), action: () => copyName(item), icon: Copy },
+  ];
+}
+
+function getObjectBrowserMenuItems(item: ObjectBrowserRow): ContextMenuItem[] {
+  if (item.type === "TABLE") return getTableMenuItems(item);
+  if (item.type === "VIEW" || item.type === "MATERIALIZED_VIEW") return getViewMenuItems(item);
+  if (item.type === "SEQUENCE") return getPackageMenuItems(item);
+  if (item.type === "PACKAGE" || item.type === "PACKAGE_BODY") return getPackageMenuItems(item);
+  return getProcFuncMenuItems(item);
+}
+</script>
+
+<template>
+  <div ref="rootRef" data-object-browser-root class="flex h-full min-h-0 min-w-0 flex-col bg-background outline-none" tabindex="0" @keydown="onObjectBrowserKeydown">
+    <div class="flex h-10 shrink-0 items-center gap-2 border-b px-3">
+      <div class="flex min-w-0 items-center gap-2">
+        <span class="inline-flex max-w-[14rem] min-w-0 items-center rounded border border-border bg-muted/50 px-2 py-0.5 text-xs font-medium truncate" :title="selectedSchema || props.database">
+          {{ selectedSchema || props.database }}
+        </span>
+        <span v-if="selectedSchema" class="inline-flex max-w-[14rem] min-w-0 items-center rounded border border-border bg-muted/30 px-2 py-0.5 text-xs text-muted-foreground truncate" :title="props.database">
+          {{ props.database }}
+        </span>
+      </div>
+      <div class="flex min-w-0 flex-1 items-center gap-2">
+        <div class="relative min-w-0 flex-1">
+          <Search class="pointer-events-none absolute left-2.5 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground" />
+          <Input v-model="search" data-object-search-input class="h-7 pl-8 text-xs" :placeholder="t('objects.search')" @keydown="onSearchKeydown" />
+        </div>
+        <div v-if="showObjectFilter" class="flex h-7 shrink-0 items-center rounded border bg-muted/20 p-0.5">
+          <button
+            v-for="filter in objectFilters"
+            :key="filter"
+            type="button"
+            class="h-6 rounded-sm px-2 text-xs text-muted-foreground transition-colors hover:text-foreground"
+            :class="{ 'bg-background text-foreground shadow-sm': objectFilter === filter }"
+            @click="
+              userHasSelectedFilter = true;
+              objectFilter = filter;
+            "
+          >
+            {{ filterLabel(filter) }}
+          </button>
+        </div>
+      </div>
+      <SearchableSelect
+        v-if="needsSchema"
+        :model-value="selectedSchema || ''"
+        :options="schemas"
+        :placeholder="t('objects.schema')"
+        :search-placeholder="t('editor.searchSchema')"
+        :empty-text="t('grid.noSearchResults')"
+        :loading-text="t('objects.loadingSchemas')"
+        :loading="loadingSchemas"
+        :disabled="loadingSchemas"
+        trigger-variant="outline"
+        trigger-class="h-7 w-36 max-w-36 px-2 text-xs font-normal"
+        content-class="w-56"
+        @update:model-value="onSchemaChange"
+      />
+      <!-- Sort selector -->
+      <div class="flex h-7 shrink-0 items-center rounded border bg-muted/20 p-0.5">
+        <select
+          class="h-6 cursor-pointer appearance-none rounded-sm bg-transparent px-1.5 text-xs text-muted-foreground outline-none hover:text-foreground focus:text-foreground"
+          :value="sortKey"
+          :aria-label="t('objects.sortBy')"
+          @change="onSortKeyChange(($event.target as HTMLSelectElement).value as ObjectBrowserSortKey)"
+        >
+          <option v-for="key in sortKeyOptions" :key="key" :value="key" class="bg-background text-foreground">
+            {{ sortKeyLabel(key) }}
+          </option>
+        </select>
+        <button type="button" class="flex h-6 w-6 items-center justify-center rounded-sm text-muted-foreground transition-colors hover:text-foreground" :title="sortDirection === 'asc' ? t('objects.sortAsc') : t('objects.sortDesc')" @click="sortDirection = sortDirection === 'asc' ? 'desc' : 'asc'">
+          <ArrowUp v-if="sortDirection === 'asc'" class="h-3 w-3" />
+          <ArrowDown v-else class="h-3 w-3" />
+        </button>
+      </div>
+      <div class="flex h-7 shrink-0 items-center rounded border bg-muted/20 p-0.5">
+        <button type="button" class="flex h-6 w-6 items-center justify-center rounded-sm text-muted-foreground transition-colors hover:text-foreground" :class="{ 'bg-background text-foreground shadow-sm': isListView }" :title="t('objects.viewList')" @click="setViewMode('list')">
+          <List class="h-3.5 w-3.5" />
+        </button>
+        <button type="button" class="flex h-6 w-6 items-center justify-center rounded-sm text-muted-foreground transition-colors hover:text-foreground" :class="{ 'bg-background text-foreground shadow-sm': !isListView }" :title="t('objects.viewGrid')" @click="setViewMode('grid')">
+          <LayoutGrid class="h-3.5 w-3.5" />
+        </button>
+      </div>
+      <Button variant="ghost" size="icon" class="h-7 w-7" :class="{ 'text-primary': settingsStore.editorSettings.objectBrowserShowCheckbox }" :title="t('objects.toggleCheckbox')" @click="toggleCheckboxColumn">
+        <CheckSquare v-if="settingsStore.editorSettings.objectBrowserShowCheckbox" class="h-3.5 w-3.5" />
+        <Square v-else class="h-3.5 w-3.5" />
+      </Button>
+      <Button variant="ghost" size="icon" class="h-7 w-7" :disabled="loadingObjects" @click="reload">
+        <RefreshCw class="h-3.5 w-3.5" :class="{ 'animate-spin': loadingObjects }" />
+      </Button>
+      <Button v-if="canPasteTableClipboard()" variant="ghost" size="sm" class="h-7 px-2 text-xs" @click="openPasteTableDialog">
+        <Clipboard class="mr-1.5 h-3.5 w-3.5" />
+        {{ t("objects.pasteTableSelected") }}
+      </Button>
+    </div>
+    <div v-if="selectedTableCount > 0" class="flex h-9 shrink-0 items-center gap-2 overflow-x-auto border-b bg-muted/30 px-3 text-xs">
+      <div class="min-w-0 flex-1 truncate text-muted-foreground">
+        {{ t("objects.selectedTables", { count: selectedTableCount }) }}
+      </div>
+      <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" @click="openBatchDatabaseExport">
+        <Upload class="mr-1.5 h-3.5 w-3.5" />
+        {{ t("objects.exportSelected") }}
+      </Button>
+      <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" @click="copySelectedTablesToClipboard">
+        <Clipboard class="mr-1.5 h-3.5 w-3.5" />
+        {{ t("objects.copyTableSelected") }}
+      </Button>
+      <Button v-if="supportsTruncateTable" variant="ghost" size="sm" class="h-7 px-2 text-xs text-destructive" @click="requestBatchTruncateTables">
+        <Scissors class="mr-1.5 h-3.5 w-3.5" />
+        {{ t("objects.truncateSelected") }}
+      </Button>
+      <Button variant="ghost" size="sm" class="h-7 px-2 text-xs text-destructive" @click="requestBatchEmptyTables">
+        <Eraser class="mr-1.5 h-3.5 w-3.5" />
+        {{ t("contextMenu.batchEmpty", { count: selectedTableCount }) }}
+      </Button>
+      <Button variant="ghost" size="sm" class="h-7 px-2 text-xs text-destructive" @click="requestBatchDropTables">
+        <Trash2 class="mr-1.5 h-3.5 w-3.5" />
+        {{ t("objects.dropSelected") }}
+      </Button>
+      <Button variant="ghost" size="sm" class="h-7 px-2 text-xs" @click="clearTableSelection">
+        <X class="mr-1.5 h-3.5 w-3.5" />
+        {{ t("objects.clearSelection") }}
+      </Button>
+    </div>
+
+    <div v-if="loadingObjects" class="flex flex-1 items-center justify-center gap-2 text-sm text-muted-foreground">
+      <Loader2 class="h-4 w-4 animate-spin" />
+      {{ t("objects.loading") }}
+    </div>
+    <div v-else-if="error" class="flex flex-1 items-center justify-center px-6 text-center text-sm text-destructive">
+      {{ error }}
+    </div>
+    <div v-else-if="filteredRows.length === 0" class="flex flex-1 items-center justify-center text-sm text-muted-foreground">
+      {{ t("objects.empty") }}
+    </div>
+    <div v-else class="flex min-h-0 min-w-0 flex-1">
+      <div class="flex min-h-0 min-w-0 flex-1 flex-col">
+        <div v-if="isListView" class="object-browser-table flex min-h-0 min-w-0 flex-1 flex-col overflow-x-auto overflow-y-hidden">
+          <div class="grid h-7 shrink-0 items-center gap-3 border-b bg-muted/40 px-3 text-xs font-medium text-muted-foreground" :style="{ gridTemplateColumns, minWidth: `${objectGridMinWidth}px` }">
+            <div v-if="showCheckboxColumn" class="relative flex min-w-0 items-center">
+              <button class="flex h-6 w-6 items-center justify-center rounded-sm hover:bg-accent" type="button" :disabled="visibleSelectableRows.length === 0" @click="toggleVisibleTableSelection">
+                <CheckSquare v-if="allVisibleTablesSelected" class="h-3.5 w-3.5 text-primary" />
+                <Square v-else class="h-3.5 w-3.5" />
+              </button>
+              <div class="absolute -right-2 top-0 bottom-0 z-10 flex w-3 cursor-col-resize items-center justify-center text-muted-foreground/70 hover:bg-primary/30 hover:text-primary" @mousedown="onObjectColumnResizeStart('select', $event)" @dblclick="resetObjectColumnWidth('select', 34, $event)">
+                <GripVertical class="h-3 w-3" />
+              </div>
+            </div>
+            <div class="relative flex min-w-0 items-center">
+              <button class="flex min-w-0 items-center gap-1 truncate pr-4 text-left" type="button" @click="toggleSort('name')">
+                <span class="truncate">{{ t("objects.name") }}</span>
+                <component :is="sortIconFor('name')" v-if="sortIconFor('name')" class="h-3 w-3 shrink-0" />
+              </button>
+              <div class="absolute -right-2 top-0 bottom-0 z-10 flex w-3 cursor-col-resize items-center justify-center text-muted-foreground/70 hover:bg-primary/30 hover:text-primary" @mousedown="onObjectColumnResizeStart('name', $event)" @dblclick="resetObjectColumnWidth('name', 260, $event)">
+                <GripVertical class="h-3 w-3" />
+              </div>
+            </div>
+            <div class="relative flex min-w-0 items-center">
+              <button class="flex min-w-0 items-center gap-1 truncate pr-4 text-left" type="button" @click="toggleSort('type')">
+                <span class="truncate">{{ t("objects.type") }}</span>
+                <component :is="sortIconFor('type')" v-if="sortIconFor('type')" class="h-3 w-3 shrink-0" />
+              </button>
+              <div class="absolute -right-2 top-0 bottom-0 z-10 flex w-3 cursor-col-resize items-center justify-center text-muted-foreground/70 hover:bg-primary/30 hover:text-primary" @mousedown="onObjectColumnResizeStart('type', $event)" @dblclick="resetObjectColumnWidth('type', 110, $event)">
+                <GripVertical class="h-3 w-3" />
+              </div>
+            </div>
+            <div class="relative flex min-w-0 items-center">
+              <button class="flex min-w-0 items-center gap-1 truncate pr-4 text-left" type="button" :title="t('objects.statisticsHint')" @click="toggleSort('estimatedRows')">
+                <span class="truncate">{{ t("objects.rows") }}</span>
+                <component :is="sortIconFor('estimatedRows')" v-if="sortIconFor('estimatedRows')" class="h-3 w-3 shrink-0" />
+              </button>
+              <div
+                class="absolute -right-2 top-0 bottom-0 z-10 flex w-3 cursor-col-resize items-center justify-center text-muted-foreground/70 hover:bg-primary/30 hover:text-primary"
+                @mousedown="onObjectColumnResizeStart('estimatedRows', $event)"
+                @dblclick="resetObjectColumnWidth('estimatedRows', 110, $event)"
+              >
+                <GripVertical class="h-3 w-3" />
+              </div>
+            </div>
+            <div class="relative flex min-w-0 items-center">
+              <button class="flex min-w-0 items-center gap-1 truncate pr-4 text-left" type="button" :title="t('objects.statisticsHint')" @click="toggleSort('totalBytes')">
+                <span class="truncate">{{ t("objects.size") }}</span>
+                <component :is="sortIconFor('totalBytes')" v-if="sortIconFor('totalBytes')" class="h-3 w-3 shrink-0" />
+              </button>
+              <div
+                class="absolute -right-2 top-0 bottom-0 z-10 flex w-3 cursor-col-resize items-center justify-center text-muted-foreground/70 hover:bg-primary/30 hover:text-primary"
+                @mousedown="onObjectColumnResizeStart('totalBytes', $event)"
+                @dblclick="resetObjectColumnWidth('totalBytes', 100, $event)"
+              >
+                <GripVertical class="h-3 w-3" />
+              </div>
+            </div>
+            <div v-if="hasCreatedAt" class="relative flex min-w-0 items-center">
+              <button class="flex min-w-0 items-center gap-1 truncate pr-4 text-left" type="button" @click="toggleSort('created_at')">
+                <span class="truncate">{{ t("objects.createdAt") }}</span>
+                <component :is="sortIconFor('created_at')" v-if="sortIconFor('created_at')" class="h-3 w-3 shrink-0" />
+              </button>
+              <div
+                class="absolute -right-2 top-0 bottom-0 z-10 flex w-3 cursor-col-resize items-center justify-center text-muted-foreground/70 hover:bg-primary/30 hover:text-primary"
+                @mousedown="onObjectColumnResizeStart('created_at', $event)"
+                @dblclick="resetObjectColumnWidth('created_at', 150, $event)"
+              >
+                <GripVertical class="h-3 w-3" />
+              </div>
+            </div>
+            <div v-if="hasUpdatedAt" class="relative flex min-w-0 items-center">
+              <button class="flex min-w-0 items-center gap-1 truncate pr-4 text-left" type="button" @click="toggleSort('updated_at')">
+                <span class="truncate">{{ t("objects.updatedAt") }}</span>
+                <component :is="sortIconFor('updated_at')" v-if="sortIconFor('updated_at')" class="h-3 w-3 shrink-0" />
+              </button>
+              <div
+                class="absolute -right-2 top-0 bottom-0 z-10 flex w-3 cursor-col-resize items-center justify-center text-muted-foreground/70 hover:bg-primary/30 hover:text-primary"
+                @mousedown="onObjectColumnResizeStart('updated_at', $event)"
+                @dblclick="resetObjectColumnWidth('updated_at', 150, $event)"
+              >
+                <GripVertical class="h-3 w-3" />
+              </div>
+            </div>
+            <div class="relative flex min-w-0 items-center">
+              <button class="flex min-w-0 items-center gap-1 truncate pr-4 text-left" type="button" @click="toggleSort('comment')">
+                <span class="truncate">{{ t("objects.comment") }}</span>
+                <component :is="sortIconFor('comment')" v-if="sortIconFor('comment')" class="h-3 w-3 shrink-0" />
+              </button>
+              <div
+                class="absolute -right-2 top-0 bottom-0 z-10 flex w-3 cursor-col-resize items-center justify-center text-muted-foreground/70 hover:bg-primary/30 hover:text-primary"
+                @mousedown="onObjectColumnResizeStart('comment', $event)"
+                @dblclick="resetObjectColumnWidth('comment', 260, $event)"
+              >
+                <GripVertical class="h-3 w-3" />
+              </div>
+            </div>
+          </div>
+          <RecycleScroller ref="listScrollerRef" class="object-browser-scroller min-h-0 flex-1" :style="{ minWidth: `${objectGridMinWidth}px` }" :items="filteredRows" :item-size="34" :buffer="600" :skip-hover="true" key-field="id">
+            <template #default="{ item }">
+              <CustomContextMenu :items="getObjectBrowserMenuItems(item)" v-slot="{ onContextMenu }">
+                <div
+                  class="grid h-[34px] cursor-pointer items-center gap-3 border-b px-3 hover:bg-accent/50"
+                  :class="{
+                    'bg-accent/40': sourceRow?.id === item.id,
+                    'bg-primary/5': selectedTableIds.has(item.id),
+                  }"
+                  :style="{ gridTemplateColumns }"
+                  @click="onRowClick(item, $event)"
+                  @contextmenu="onContextMenu"
+                >
+                  <button v-if="showCheckboxColumn" class="flex h-6 w-6 items-center justify-center rounded-sm text-muted-foreground hover:bg-accent hover:text-foreground" type="button" :class="{ invisible: item.type !== 'TABLE' }" @click.stop="toggleTableSelection(item)">
+                    <CheckSquare v-if="selectedTableIds.has(item.id)" class="h-3.5 w-3.5 text-primary" />
+                    <Square v-else class="h-3.5 w-3.5" />
+                  </button>
+                  <div class="flex min-w-0 items-center gap-2">
+                    <button
+                      v-if="item.partitionCount"
+                      type="button"
+                      class="flex h-5 w-5 shrink-0 items-center justify-center rounded-sm text-muted-foreground hover:bg-accent hover:text-foreground"
+                      :aria-label="t('objects.partitions', { count: item.partitionCount })"
+                      @click.stop="togglePartitionParent(item)"
+                    >
+                      <ChevronDown v-if="isPartitionParentExpanded(item)" class="h-3.5 w-3.5" />
+                      <ChevronRight v-else class="h-3.5 w-3.5" />
+                    </button>
+                    <span v-else-if="item.partitionParentId" class="ml-4 h-5 w-5 shrink-0" />
+                    <component :is="iconFor(item)" class="h-3.5 w-3.5 shrink-0" :class="iconClass(item.type)" />
+                    <span class="truncate text-[13px] font-medium text-foreground" :title="item.displayName">{{ item.displayName }}</span>
+                    <span v-if="item.partitionCount" class="shrink-0 rounded border bg-muted/40 px-1.5 py-0.5 text-[10px] font-medium leading-none text-muted-foreground">
+                      {{ t("objects.partitions", { count: item.partitionCount }) }}
+                    </span>
+                  </div>
+                  <div class="truncate text-xs text-muted-foreground">{{ typeLabel(item.type) }}</div>
+                  <div class="truncate text-xs tabular-nums text-muted-foreground" :title="item.estimatedRows == null ? '' : formatObjectBrowserCount(item.estimatedRows)">
+                    {{ formatObjectBrowserCount(item.estimatedRows) }}
+                  </div>
+                  <div class="truncate text-xs tabular-nums text-muted-foreground" :title="item.totalBytes == null ? '' : formatObjectBrowserBytes(item.totalBytes)">
+                    {{ formatObjectBrowserBytes(item.totalBytes) }}
+                  </div>
+                  <div v-if="hasCreatedAt" class="truncate text-xs tabular-nums text-muted-foreground" :title="formatObjectBrowserTimestamp(item.created_at)">
+                    {{ formatObjectBrowserTimestamp(item.created_at) }}
+                  </div>
+                  <div v-if="hasUpdatedAt" class="truncate text-xs tabular-nums text-muted-foreground" :title="formatObjectBrowserTimestamp(item.updated_at)">
+                    {{ formatObjectBrowserTimestamp(item.updated_at) }}
+                  </div>
+                  <div class="truncate text-xs text-muted-foreground" :title="item.comment || ''">
+                    {{ item.comment || "" }}
+                  </div>
+                </div>
+              </CustomContextMenu>
+            </template>
+          </RecycleScroller>
+        </div>
+        <div v-else ref="gridContainerRef" class="object-browser-grid-wrapper min-h-0 flex-1 p-2">
+          <RecycleScroller ref="gridScrollerRef" v-if="gridRows.length > 0" class="object-browser-grid-scroller h-full" :items="gridRows" :item-size="objectGridRowHeight" :buffer="600" :skip-hover="true" key-field="key">
+            <template #default="{ item: row }">
+              <div class="object-browser-grid-row" :style="{ gridTemplateColumns: `repeat(${gridColumns}, minmax(0, 1fr))`, height: `${objectGridRowHeight - OBJECT_GRID_GAP}px` }">
+                <CustomContextMenu v-for="item in row.cards" :key="item.id" :items="getObjectBrowserMenuItems(item)" v-slot="{ onContextMenu }">
+                  <div
+                    class="relative flex cursor-pointer flex-col items-center gap-1 rounded-lg border bg-card p-3 text-center transition-all hover:border-primary/40 hover:shadow-sm"
+                    :class="{
+                      'border-primary bg-primary/5': selectedTableIds.has(item.id),
+                      'border-primary/60': sourceRow?.id === item.id && !selectedTableIds.has(item.id),
+                    }"
+                    :title="item.displayName"
+                    @click="onRowClick(item, $event)"
+                    @contextmenu="onContextMenu"
+                  >
+                    <button v-if="showCheckboxColumn" class="absolute right-1 top-1 flex h-5 w-5 items-center justify-center rounded-sm text-muted-foreground hover:bg-accent hover:text-foreground" type="button" :class="{ invisible: item.type !== 'TABLE' }" @click.stop="toggleTableSelection(item)">
+                      <CheckSquare v-if="selectedTableIds.has(item.id)" class="h-3.5 w-3.5 text-primary" />
+                      <Square v-else class="h-3.5 w-3.5" />
+                    </button>
+                    <div class="flex h-11 w-11 shrink-0 items-center justify-center rounded-full shadow-sm" :class="iconBgClass(item.type)">
+                      <component :is="iconFor(item)" class="h-6 w-6" :class="iconClass(item.type)" />
+                    </div>
+                    <span class="w-full truncate text-sm font-medium leading-tight text-foreground">{{ item.displayName }}</span>
+                    <div class="flex items-center gap-1.5">
+                      <span class="text-xs text-muted-foreground">{{ typeLabel(item.type) }}</span>
+                      <span v-if="item.estimatedRows != null && item.estimatedRows > 0" class="object-browser-stat-badge object-browser-stat-badge-rows rounded-full bg-primary/10 px-1.5 py-0.5 text-[10px] font-medium tabular-nums text-primary">{{
+                        formatObjectBrowserCount(item.estimatedRows)
+                      }}</span>
+                      <span v-if="item.totalBytes != null && item.totalBytes > 0" class="object-browser-stat-badge object-browser-stat-badge-bytes rounded-full bg-muted px-1.5 py-0.5 text-[10px] font-medium tabular-nums text-muted-foreground">{{ formatObjectBrowserBytes(item.totalBytes) }}</span>
+                    </div>
+                    <div v-if="item.created_at?.trim() || item.updated_at?.trim()" class="flex items-center gap-1 text-[10px] text-muted-foreground/70">
+                      <span v-if="item.created_at?.trim()">{{ formatObjectBrowserTimestamp(item.created_at) }}</span>
+                      <span v-if="item.created_at?.trim() && item.updated_at?.trim()">·</span>
+                      <span v-if="item.updated_at?.trim()">{{ formatObjectBrowserTimestamp(item.updated_at) }}</span>
+                    </div>
+                    <div v-if="item.comment?.trim()" class="w-full truncate text-[10px] text-muted-foreground/60" :title="item.comment">
+                      {{ item.comment }}
+                    </div>
+                  </div>
+                </CustomContextMenu>
+              </div>
+            </template>
+          </RecycleScroller>
+        </div>
+      </div>
+      <!-- Right-side panel: table info or source -->
+      <div v-if="sidePanelRow" class="object-browser-side-panel relative flex min-h-0 shrink-0 flex-col border-l bg-background" :class="{ 'side-panel-resizing': isResizingSidePanel }" :style="{ width: `${sidePanelWidth}px` }">
+        <div class="absolute left-0 top-0 bottom-0 z-20 w-1.5 -translate-x-1/2 cursor-col-resize hover:bg-primary/30" @mousedown.prevent="onSidePanelResizeStart" />
+        <!-- Table info mode -->
+        <template v-if="sidePanelMode === 'table-info'">
+          <div class="flex items-center gap-2 px-3 py-1.5 border-b shrink-0 bg-muted/20 h-9">
+            <TableProperties class="w-3.5 h-3.5 text-muted-foreground" />
+            <span class="text-xs font-medium flex-1 min-w-0 truncate">{{ sidePanelRow?.name }}</span>
+            <div v-if="tableInfoTab === 'ddl'" class="table-info-actions flex min-w-0 shrink-0 items-center gap-1">
+              <Button variant="ghost" size="sm" class="table-info-action-button h-6 px-2 text-xs" :title="t('grid.copyDdl')" :aria-label="t('grid.copyDdl')" @click="copyTableDdl">
+                <Copy class="w-3 h-3" />
+                <span class="table-info-action-label">{{ t("grid.copyDdl") }}</span>
+              </Button>
+              <Button variant="ghost" size="icon" class="h-6 w-6" :class="{ 'bg-accent': tableInfoWrap }" @click="tableInfoWrap = !tableInfoWrap">
+                <WrapText class="w-3 h-3" />
+              </Button>
+            </div>
+            <Button v-if="canOpenTableStructureEditor" variant="ghost" size="sm" class="table-info-action-button h-6 px-2 text-xs" :title="t('contextMenu.editStructure')" :aria-label="t('contextMenu.editStructure')" @click="openTableStructureEditor">
+              <Columns3Cog class="w-3 h-3" />
+              <span class="table-info-action-label">{{ t("contextMenu.editStructure") }}</span>
+            </Button>
+            <Button variant="ghost" size="icon" class="h-5 w-5" @click="closeSidePanel">
+              <X class="w-3 h-3" />
+            </Button>
+          </div>
+          <div class="grid border-b bg-background shrink-0" :style="tableInfoTabListStyle">
+            <button
+              v-for="tab in tableInfoTabs"
+              :key="tab.id"
+              class="h-9 min-w-0 px-1.5 text-[11px] border-b-2 transition-colors"
+              :class="tableInfoTab === tab.id ? 'border-primary bg-gray-300/80 text-foreground dark:bg-gray-700/80' : 'border-transparent text-muted-foreground hover:bg-gray-200 hover:text-foreground dark:hover:bg-gray-800/50'"
+              :title="tab.label"
+              @click="selectTableInfoTab(tab.id)"
+            >
+              <component :is="tab.icon" class="mx-auto h-3.5 w-3.5" />
+              <span class="block truncate">{{ tab.label }}</span>
+            </button>
+          </div>
+          <div class="px-2 py-1.5 border-b shrink-0 bg-background">
+            <div class="relative">
+              <Search class="absolute left-2 top-1/2 -translate-y-1/2 w-3.5 h-3.5 text-muted-foreground" />
+              <input v-model="tableInfoSearchQuery" :placeholder="t('grid.tableInfoSearch')" class="w-full h-7 pl-7 pr-6 text-xs bg-muted/50 rounded border border-border focus:outline-none focus:border-primary/50" @keydown.escape="tableInfoSearchQuery = ''" />
+              <button v-if="tableInfoSearchQuery" class="absolute right-1.5 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground" @click="tableInfoSearchQuery = ''">
+                <X class="w-3 h-3" />
+              </button>
+            </div>
+          </div>
+          <div v-if="tableInfoTab === 'columns'" class="flex-1 min-h-0 overflow-auto">
+            <div v-if="tableColumnsLoading" class="h-full flex items-center justify-center">
+              <Loader2 class="w-4 h-4 animate-spin text-muted-foreground" />
+            </div>
+            <div v-else-if="tableInfoSearchQuery && filteredTableColumns.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+              {{ t("grid.tableInfoNoResults") }}
+            </div>
+            <table v-else class="w-full text-xs">
+              <thead class="sticky top-0 bg-muted text-muted-foreground">
+                <tr class="border-b">
+                  <th class="text-left text-nowrap font-medium px-3 py-2 w-8">#</th>
+                  <th class="text-left text-nowrap font-medium px-3 py-2">{{ t("grid.columnName") }}</th>
+                  <th class="text-left text-nowrap font-medium px-3 py-2">{{ t("grid.columnType") }}</th>
+                  <th class="text-left text-nowrap font-medium px-3 py-2">{{ t("grid.tableInfoNullable") }}</th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr v-for="(column, index) in filteredTableColumns" :key="column.name" class="border-b hover:bg-gray-200 dark:hover:bg-gray-800/30" :title="column.name">
+                  <td class="px-3 py-2 text-muted-foreground w-8">{{ index + 1 }}</td>
+                  <td class="px-3 py-2 font-medium">
+                    <span class="inline-flex items-center gap-1.5">
+                      <KeyRound v-if="column.is_primary_key" class="h-3 w-3 text-amber-500" />
+                      {{ column.name }}
+                    </span>
+                    <div v-if="column.comment" class="mt-0.5 text-[11px] text-muted-foreground truncate">
+                      {{ column.comment }}
+                    </div>
+                  </td>
+                  <td class="px-3 py-2 font-mono text-[11px] text-muted-foreground">{{ column.data_type }}</td>
+                  <td class="px-3 py-2">{{ column.is_nullable ? "YES" : "NO" }}</td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+          <div v-else-if="tableInfoTab === 'indexes'" class="flex-1 min-h-0 overflow-auto">
+            <div v-if="tableIndexesLoading" class="h-full flex items-center justify-center">
+              <Loader2 class="w-4 h-4 animate-spin text-muted-foreground" />
+            </div>
+            <div v-else-if="tableInfoSearchQuery && filteredTableIndexes.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+              {{ t("grid.tableInfoNoResults") }}
+            </div>
+            <div v-else-if="tableIndexes.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+              {{ t("grid.tableInfoEmpty") }}
+            </div>
+            <div v-else class="divide-y">
+              <div v-for="index in filteredTableIndexes" :key="index.name" class="p-3 text-xs">
+                <div class="flex items-start gap-2">
+                  <div class="min-w-0 flex-1">
+                    <div class="font-medium truncate">{{ index.name }}</div>
+                    <div class="mt-1 flex flex-wrap gap-1">
+                      <span v-if="index.is_primary" class="rounded bg-amber-500/10 px-1.5 py-0.5 text-amber-600">PK</span>
+                      <span v-if="index.is_unique" class="rounded bg-emerald-500/10 px-1.5 py-0.5 text-emerald-600">UNIQUE</span>
+                      <span v-if="index.index_type" class="rounded bg-muted px-1.5 py-0.5 text-muted-foreground">{{ index.index_type }}</span>
+                    </div>
+                    <div class="mt-2 font-mono text-[11px] text-muted-foreground break-all">
+                      {{ index.columns.join(", ") }}
+                    </div>
+                  </div>
+                </div>
+              </div>
+            </div>
+          </div>
+          <div v-else-if="tableInfoTab === 'foreignKeys'" class="flex-1 min-h-0 overflow-auto">
+            <div v-if="tableForeignKeysLoading" class="h-full flex items-center justify-center">
+              <Loader2 class="w-4 h-4 animate-spin text-muted-foreground" />
+            </div>
+            <div v-else-if="tableInfoSearchQuery && filteredTableForeignKeys.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+              {{ t("grid.tableInfoNoResults") }}
+            </div>
+            <div v-else-if="tableForeignKeys.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+              {{ t("grid.tableInfoEmpty") }}
+            </div>
+            <div v-else class="divide-y">
+              <div v-for="fk in filteredTableForeignKeys" :key="`${fk.name}:${fk.column}`" class="p-3 text-xs">
+                <div class="font-medium truncate">{{ fk.name }}</div>
+                <div class="mt-1 font-mono text-[11px] text-muted-foreground break-all">{{ fk.column }} -> {{ fk.ref_table }}.{{ fk.ref_column }}</div>
+              </div>
+            </div>
+          </div>
+          <div v-else-if="tableInfoTab === 'triggers'" class="flex-1 min-h-0 overflow-auto">
+            <div v-if="tableTriggersLoading" class="h-full flex items-center justify-center">
+              <Loader2 class="w-4 h-4 animate-spin text-muted-foreground" />
+            </div>
+            <div v-else-if="tableInfoSearchQuery && filteredTableTriggers.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+              {{ t("grid.tableInfoNoResults") }}
+            </div>
+            <div v-else-if="tableTriggers.length === 0" class="p-6 text-center text-xs text-muted-foreground">
+              {{ t("grid.tableInfoEmpty") }}
+            </div>
+            <div v-else class="divide-y">
+              <div v-for="trigger in filteredTableTriggers" :key="trigger.name" class="p-3 text-xs">
+                <div class="font-medium truncate">{{ trigger.name }}</div>
+                <div class="mt-1 text-[11px] text-muted-foreground">{{ trigger.timing }} {{ trigger.event }}</div>
+              </div>
+            </div>
+          </div>
+          <pre
+            v-else-if="tableInfoTab === 'ddl' && !tableDdlLoading"
+            ref="tableInfoDdlPreRef"
+            data-native-clipboard
+            tabindex="0"
+            class="flex-1 min-w-0 text-xs font-mono p-3 overflow-auto ddl-code leading-5 select-text outline-none"
+            :class="tableInfoWrap ? 'whitespace-pre-wrap break-words' : 'whitespace-pre'"
+            v-html="filteredTableDdlContent"
+            @keydown="onTableInfoDdlKeydown"
+          ></pre>
+          <div v-else class="flex-1 flex items-center justify-center">
+            <Loader2 class="w-4 h-4 animate-spin text-muted-foreground" />
+          </div>
+        </template>
+        <!-- Source mode (views, procedures, functions, sequences) -->
+        <template v-else>
+          <div class="flex h-8 shrink-0 items-center gap-2 border-b bg-muted/20 px-3">
+            <Code2 class="h-3.5 w-3.5 text-muted-foreground" />
+            <span class="min-w-0 flex-1 truncate text-xs font-medium">{{ sourceTitle(sourceRow) }}</span>
+            <Button v-if="sourceEditing" variant="ghost" size="sm" class="h-6 px-2 text-xs" :disabled="sourceSaving || !sourceDraft.trim()" @click="saveSource">
+              <Loader2 v-if="sourceSaving" class="mr-1 h-3 w-3 animate-spin" />
+              {{ t("objects.saveSource") }}
+            </Button>
+            <Button v-if="sourceEditing" variant="ghost" size="sm" class="h-6 px-2 text-xs" :disabled="sourceSaving" @click="cancelEditSource">
+              {{ t("objects.cancelEdit") }}
+            </Button>
+            <Button v-if="!sourceEditing" variant="ghost" size="icon" class="h-5 w-5" :disabled="!sourceContent" @click="copySource">
+              <Copy class="h-3 w-3" />
+            </Button>
+            <Button v-if="!sourceEditing && sourceCanEdit" variant="ghost" size="icon" class="h-5 w-5" :disabled="!sourceContent" @click="editSource">
+              <PencilLine class="h-3 w-3" />
+            </Button>
+            <Button variant="ghost" size="icon" class="h-5 w-5" @click="closeSource">
+              <X class="h-3 w-3" />
+            </Button>
+          </div>
+          <div v-if="sourceLoading" class="flex flex-1 items-center justify-center">
+            <Loader2 class="h-4 w-4 animate-spin text-muted-foreground" />
+          </div>
+          <div v-else-if="sourceError" class="flex flex-1 items-center justify-center px-4 text-sm text-destructive">
+            {{ sourceError }}
+          </div>
+          <div v-else-if="sourceEditing" class="flex min-h-0 flex-1 flex-col" data-object-source-editor>
+            <QueryEditor
+              v-model="sourceDraft"
+              class="min-h-0 flex-1"
+              :connection-id="props.connection.id"
+              :database="props.database"
+              :schema="selectedSchema"
+              :database-type="props.connection.db_type"
+              :dialect="sourceDialect"
+              :format-dialect="sourceFormatDialect"
+              force-word-wrap
+              @save="saveSource"
+            />
+            <div v-if="sourceSaveError" class="shrink-0 border-t px-3 py-2 text-xs text-destructive">
+              {{ sourceSaveError }}
+            </div>
+          </div>
+          <QueryEditor
+            v-else
+            :key="`source-preview-${sourceRow?.id}`"
+            :model-value="sourceContent"
+            class="min-h-0 flex-1"
+            :connection-id="props.connection.id"
+            :database="props.database"
+            :schema="selectedSchema"
+            :database-type="props.connection.db_type"
+            :dialect="sourceDialect"
+            :format-dialect="sourceFormatDialect"
+            force-word-wrap
+            read-only
+            data-object-source-preview
+          />
+        </template>
+      </div>
+    </div>
+  </div>
+
+  <DangerConfirmDialog v-model:open="showDropConfirm" :title="dropConfirmTitle()" :message="dropConfirmMessage()" :sql="dropPreviewSql" :confirm-label="t('dangerDialog.deleteConfirm')" @confirm="confirmDrop">
+    <template v-if="canDropTargetCascade" #options>
+      <label class="mb-3 flex items-start gap-2 rounded-md border bg-muted/20 px-3 py-2 text-sm">
+        <input v-model="dropTableCascade" type="checkbox" class="mt-0.5 h-3.5 w-3.5 shrink-0 accent-primary" @change="refreshDropPreviewSql()" />
+        <span class="grid gap-0.5">
+          <span class="font-medium text-foreground">{{ t("contextMenu.dropTableCascade") }}</span>
+          <span class="text-xs leading-5 text-muted-foreground">{{ t("contextMenu.dropTableCascadeHint") }}</span>
+        </span>
+      </label>
+    </template>
+  </DangerConfirmDialog>
+
+  <DangerConfirmDialog v-model:open="showBatchDropConfirm" :title="t('objects.confirmBatchDropTitle')" :message="t('objects.confirmBatchDropMessage', { count: selectedTableCount })" :sql="batchDropPreviewSql" :confirm-label="t('objects.dropSelected')" @confirm="confirmBatchDropTables">
+    <template v-if="canBatchDropCascade" #options>
+      <label class="mb-3 flex items-start gap-2 rounded-md border bg-muted/20 px-3 py-2 text-sm">
+        <input v-model="batchDropCascade" type="checkbox" class="mt-0.5 h-3.5 w-3.5 shrink-0 accent-primary" @change="refreshBatchDropPreviewSql()" />
+        <span class="grid gap-0.5">
+          <span class="font-medium text-foreground">{{ t("contextMenu.dropTableCascade") }}</span>
+          <span class="text-xs leading-5 text-muted-foreground">{{ t("contextMenu.dropTableCascadeHint") }}</span>
+        </span>
+      </label>
+    </template>
+  </DangerConfirmDialog>
+
+  <DangerConfirmDialog
+    v-model:open="showBatchTruncateConfirm"
+    :title="t('objects.confirmBatchTruncateTitle')"
+    :message="t('objects.confirmBatchTruncateMessage', { count: selectedTableCount })"
+    :sql="batchTruncatePreviewSql"
+    :confirm-label="t('objects.truncateSelected')"
+    @confirm="confirmBatchTruncateTables"
+  >
+    <template v-if="canBatchTruncateCascade" #options>
+      <label class="mb-3 flex items-start gap-2 rounded-md border bg-muted/20 px-3 py-2 text-sm">
+        <input v-model="batchTruncateCascade" type="checkbox" class="mt-0.5 h-3.5 w-3.5 shrink-0 accent-primary" @change="refreshBatchTruncatePreviewSql()" />
+        <span class="grid gap-0.5">
+          <span class="font-medium text-foreground">{{ t("contextMenu.truncateTableCascade") }}</span>
+          <span class="text-xs leading-5 text-muted-foreground">{{ t("contextMenu.truncateTableCascadeHint") }}</span>
+        </span>
+      </label>
+    </template>
+  </DangerConfirmDialog>
+
+  <DangerConfirmDialog
+    v-model:open="showBatchEmptyConfirm"
+    :title="t('contextMenu.confirmBatchEmptyTitle', { count: batchEmptyPlan.length })"
+    :message="t('contextMenu.confirmBatchEmptyMessage', { count: batchEmptyPlan.length })"
+    :sql="batchEmptyPreviewSql"
+    :confirm-label="t('contextMenu.batchEmpty', { count: batchEmptyPlan.length })"
+    @confirm="confirmBatchEmptyTables"
+  />
+
+  <Dialog v-model:open="showRenameDialog">
+    <DialogContent class="sm:max-w-[420px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("contextMenu.renameObjectTitle") }}</DialogTitle>
+      </DialogHeader>
+      <div class="grid gap-3">
+        <Input v-model="renameInput" :placeholder="t('contextMenu.renameObjectNamePlaceholder')" @keydown.enter.prevent="confirmRename" />
+        <pre v-if="renamePreviewSqlText" class="max-h-32 overflow-auto rounded bg-muted p-3 text-xs whitespace-pre-wrap" v-html="highlight(renamePreviewSqlText)"></pre>
+        <p v-if="renameError" class="text-sm text-destructive">{{ renameError }}</p>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" @click="showRenameDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="!renameInput.trim() || renameInput.trim() === renameTarget?.name" @click="confirmRename">
+          {{ t("contextMenu.renameObject") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <DangerConfirmDialog
+    v-model:open="showTruncateConfirm"
+    :title="t('contextMenu.confirmTruncateTableTitle')"
+    :message="t('contextMenu.confirmTruncateTableMessage', { name: truncateTarget?.name ?? '' })"
+    :sql="truncatePreviewSql"
+    :confirm-label="t('contextMenu.truncateTable')"
+    @confirm="confirmTruncateTable"
+  >
+    <template v-if="canTruncateTargetCascade" #options>
+      <label class="mb-3 flex items-start gap-2 rounded-md border bg-muted/20 px-3 py-2 text-sm">
+        <input v-model="truncateTableCascade" type="checkbox" class="mt-0.5 h-3.5 w-3.5 shrink-0 accent-primary" @change="truncateTarget && refreshTruncatePreviewSql(truncateTarget)" />
+        <span class="grid gap-0.5">
+          <span class="font-medium text-foreground">{{ t("contextMenu.truncateTableCascade") }}</span>
+          <span class="text-xs leading-5 text-muted-foreground">{{ t("contextMenu.truncateTableCascadeHint") }}</span>
+        </span>
+      </label>
+    </template>
+  </DangerConfirmDialog>
+
+  <DangerConfirmDialog v-model:open="showEmptyConfirm" :title="t('contextMenu.confirmEmptyTableTitle')" :message="t('contextMenu.confirmEmptyTableMessage', { name: emptyTarget?.name ?? '' })" :sql="emptyPreviewSql" :confirm-label="t('contextMenu.emptyTable')" @confirm="confirmEmptyTable" />
+
+  <ProcedureExecutionDialog
+    v-if="procedureExecutionTarget"
+    v-model:open="showProcedureExecutionConfirm"
+    :connection-id="props.connection.id"
+    :database="props.database"
+    :database-type="props.connection.db_type"
+    :schema="procedureExecutionTarget.schema || selectedSchema"
+    :routine-name="procedureExecutionTarget.name"
+    @open-sql="openProcedureExecutionSql"
+    @execute="executeProcedureSql"
+  />
+
+  <Dialog v-model:open="showDuplicateDialog">
+    <DialogContent class="sm:max-w-[400px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("contextMenu.duplicateNameTitle") }}</DialogTitle>
+      </DialogHeader>
+      <Input v-model="duplicateTableName" :placeholder="t('contextMenu.duplicateNamePlaceholder')" @keydown.enter.prevent="confirmDuplicateStructure" />
+      <DialogFooter>
+        <Button variant="outline" @click="showDuplicateDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="!duplicateTableName.trim()" @click="confirmDuplicateStructure">
+          {{ t("dangerDialog.confirm") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showPasteDialog">
+    <DialogContent class="sm:max-w-[500px]">
+      <DialogHeader>
+        <DialogTitle>{{ pasteTableEntries.length > 1 ? t("contextMenu.batchPasteTitle") : t("contextMenu.pasteTableConfirmTitle") }}</DialogTitle>
+      </DialogHeader>
+      <div class="space-y-4">
+        <div class="flex gap-2">
+          <label class="flex items-center gap-1.5 text-sm cursor-pointer" :class="{ 'opacity-50 cursor-not-allowed': !pasteTableDataCopySupported }">
+            <input v-model="pasteTableMode" type="radio" value="structure-and-data" class="accent-primary" :disabled="!pasteTableDataCopySupported" />
+            {{ t("contextMenu.pasteOptionStructureAndData") }}
+          </label>
+          <label class="flex items-center gap-1.5 text-sm cursor-pointer">
+            <input v-model="pasteTableMode" type="radio" value="structure-only" class="accent-primary" />
+            {{ t("contextMenu.pasteOptionStructureOnly") }}
+          </label>
+          <label class="flex items-center gap-1.5 text-sm cursor-pointer" :class="{ 'opacity-50 cursor-not-allowed': !pasteTableDataCopySupported }">
+            <input v-model="pasteTableMode" type="radio" value="data-only" class="accent-primary" :disabled="!pasteTableDataCopySupported" />
+            {{ t("contextMenu.pasteOptionDataOnly") }}
+          </label>
+        </div>
+        <div class="space-y-2 max-h-64 overflow-y-auto">
+          <div v-for="(entry, idx) in pasteTableEntries" :key="idx" class="flex items-center gap-2">
+            <span class="text-sm text-muted-foreground truncate min-w-0 flex-shrink basis-1/3" :title="entry.sourceName">{{ entry.sourceName }}</span>
+            <span class="text-xs text-muted-foreground flex-shrink-0">&rarr;</span>
+            <Input v-model="entry.targetName" class="flex-1 h-8 text-sm" :placeholder="t('contextMenu.duplicateNamePlaceholder')" />
+          </div>
+        </div>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" @click="showPasteDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="pasteTableEntries.every((e) => !e.targetName.trim())" @click="confirmPasteTable">{{ t("dangerDialog.confirm") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
+
+<style scoped>
+.object-browser-table {
+  scrollbar-width: thin;
+}
+
+.object-browser-scroller {
+  will-change: scroll-position;
+  contain: content;
+}
+
+.object-browser-scroller :deep(.vue-recycle-scroller__item-view) {
+  contain: layout style paint;
+}
+
+.object-browser-grid-wrapper {
+  scrollbar-width: thin;
+}
+
+.object-browser-grid-scroller {
+  will-change: scroll-position;
+  contain: content;
+  scrollbar-width: thin;
+}
+
+.object-browser-grid-scroller :deep(.vue-recycle-scroller__item-view) {
+  contain: layout style paint;
+}
+
+.object-browser-grid-row {
+  display: grid;
+  column-gap: 12px;
+  align-items: start;
+}
+
+.object-browser-icon-bg-table {
+  background-color: rgba(34, 197, 94, 0.1);
+}
+
+.object-browser-icon-bg-view {
+  background-color: rgba(168, 85, 247, 0.1);
+}
+
+.object-browser-icon-bg-procedure {
+  background-color: rgba(59, 130, 246, 0.1);
+}
+
+.object-browser-icon-bg-function {
+  background-color: rgba(245, 158, 11, 0.1);
+}
+
+.object-browser-icon-bg-sequence {
+  background-color: rgba(16, 185, 129, 0.1);
+}
+
+.object-browser-icon-bg-package {
+  background-color: rgba(6, 182, 212, 0.1);
+}
+
+.object-browser-stat-badge {
+  display: inline-flex;
+  align-items: center;
+  max-width: 100%;
+  line-height: 1rem;
+  white-space: nowrap;
+}
+
+.object-browser-stat-badge-rows {
+  color: var(--primary);
+  background-color: rgba(23, 23, 23, 0.1);
+}
+
+.object-browser-stat-badge-bytes {
+  color: var(--muted-foreground);
+  background-color: var(--muted);
+}
+
+:global(.dark) .object-browser-stat-badge-rows {
+  background-color: rgba(208, 208, 214, 0.12);
+}
+
+.side-panel-resizing {
+  user-select: none;
+  pointer-events: none;
+}
+
+.ddl-code {
+  container-type: inline-size;
+}
+
+.object-browser-side-panel {
+  container-type: inline-size;
+}
+
+.table-info-action-button {
+  gap: 0.25rem;
+  max-width: 8rem;
+  overflow: hidden;
+  transition:
+    max-width 180ms ease,
+    padding-inline 180ms ease;
+}
+
+.table-info-action-label {
+  min-width: 0;
+  max-width: 6rem;
+  overflow: hidden;
+  white-space: nowrap;
+  opacity: 1;
+  transition:
+    max-width 180ms ease,
+    opacity 120ms ease;
+}
+
+@container (max-width: 360px) {
+  .table-info-action-button {
+    width: 1.5rem;
+    max-width: 1.5rem;
+    padding-inline: 0;
+  }
+
+  .table-info-action-label {
+    max-width: 0;
+    opacity: 0;
+  }
+}
+</style>
diff --git a/apps/desktop/src/components/objects/ObjectSourceDialog.vue b/apps/desktop/src/components/objects/ObjectSourceDialog.vue
new file mode 100644
index 0000000..8f72693
--- /dev/null
+++ b/apps/desktop/src/components/objects/ObjectSourceDialog.vue
@@ -0,0 +1,267 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Clipboard, Loader2, PencilLine, RefreshCw } from "@lucide/vue";
+import { useToast } from "@/composables/useToast";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { formatSqlForDisplay, type SqlFormatDialect } from "@/lib/sql/sqlFormatter";
+import { buildEditableObjectSource, buildExecutableObjectSourceStatements, executeObjectSourceSave } from "@/lib/table/objectSourceEditor";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+import * as api from "@/lib/backend/api";
+import QueryEditor from "@/components/editor/QueryEditor.vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import type { DatabaseType, ObjectSourceKind } from "@/types/database";
+
+const props = withDefaults(
+  defineProps<{
+    open: boolean;
+    connectionId: string;
+    database: string;
+    schema?: string;
+    name: string;
+    signature?: string;
+    objectType: ObjectSourceKind;
+    databaseType?: DatabaseType;
+    dialect: "mysql" | "postgres" | "sqlserver";
+    formatDialect?: SqlFormatDialect;
+    initialEditing?: boolean;
+  }>(),
+  {
+    initialEditing: false,
+  },
+);
+
+const emit = defineEmits<{
+  "update:open": [value: boolean];
+  saved: [];
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+const connectionStore = useConnectionStore();
+const settingsStore = useSettingsStore();
+
+const content = ref("");
+const editableText = ref("");
+const draft = ref("");
+const loading = ref(false);
+const saving = ref(false);
+const editing = ref(false);
+const sourceEditable = ref(true);
+const error = ref("");
+const saveError = ref("");
+let loadSerial = 0;
+
+const canEdit = computed(() => sourceEditable.value && props.objectType !== "SEQUENCE");
+const title = computed(() => `${editing.value ? t("contextMenu.editView") : t("contextMenu.viewSource")} - ${props.name}`);
+
+watch(
+  () => [props.open, props.connectionId, props.database, props.schema, props.name, props.signature, props.objectType, props.initialEditing] as const,
+  () => {
+    if (props.open) void loadSource();
+  },
+  { immediate: true },
+);
+
+async function loadSource(nextEditing = props.initialEditing && canEdit.value) {
+  const serial = ++loadSerial;
+  content.value = "";
+  editableText.value = "";
+  draft.value = "";
+  error.value = "";
+  saveError.value = "";
+  sourceEditable.value = true;
+  editing.value = false;
+  loading.value = true;
+  try {
+    if (!props.databaseType) throw new Error("Connection type is unavailable.");
+    const schema = props.schema || props.database;
+    const result = await api.getObjectSource(props.connectionId, props.database, schema, props.name, props.objectType, props.signature);
+    const editableAllowed = result.editable !== false;
+    const editable = await buildEditableObjectSource({
+      databaseType: props.databaseType,
+      objectType: props.objectType,
+      schema,
+      name: props.name,
+      source: result.source,
+    });
+    if (serial !== loadSerial) return;
+    sourceEditable.value = editableAllowed;
+    const formatted = await formatSqlForDisplay(editable, props.formatDialect ?? props.dialect, settingsStore.editorSettings.sqlFormatter);
+    editableText.value = editable;
+    content.value = formatted;
+    draft.value = nextEditing && canEdit.value ? editable : "";
+    editing.value = nextEditing && canEdit.value;
+    if (nextEditing && !canEdit.value) {
+      toast(t("objects.sourceReadOnly"), 3000);
+    }
+  } catch (e: any) {
+    if (serial === loadSerial) error.value = e?.message || String(e);
+  } finally {
+    if (serial === loadSerial) loading.value = false;
+  }
+}
+
+async function copySource() {
+  if (!content.value) return;
+  try {
+    await copyToClipboard(content.value);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function editSource() {
+  if (!canEdit.value || !editableText.value) {
+    if (!canEdit.value) toast(t("objects.sourceReadOnly"), 3000);
+    return;
+  }
+  draft.value = editableText.value;
+  saveError.value = "";
+  editing.value = true;
+}
+
+function cancelEditSource() {
+  editing.value = false;
+  draft.value = "";
+  saveError.value = "";
+}
+
+async function saveSource() {
+  if (!canEdit.value) {
+    toast(t("objects.sourceReadOnly"), 3000);
+    return;
+  }
+  if (!draft.value.trim() || !props.databaseType) return;
+  const databaseType = props.databaseType;
+  const schema = props.schema || props.database;
+  saving.value = true;
+  saveError.value = "";
+  try {
+    const statements = await buildExecutableObjectSourceStatements({
+      databaseType,
+      objectType: props.objectType,
+      schema,
+      name: props.name,
+      source: draft.value,
+    });
+    const executableSql = statements.filter((sql) => sql.trim()).join(";\n");
+    if (executableSql.trim()) {
+      const saved = await executeWithProductionSqlGuard({
+        connection: connectionStore.getConfig(props.connectionId),
+        database: props.database,
+        sql: executableSql,
+        source: t("production.sourceObjectSource"),
+        execute: async () => {
+          await executeObjectSourceSave(props.connectionId, props.database, databaseType, statements, schema);
+          return true;
+        },
+      });
+      if (!saved) return;
+    } else {
+      await executeObjectSourceSave(props.connectionId, props.database, databaseType, statements, schema);
+    }
+    toast(t("objects.sourceSaved"));
+    emit("saved");
+    await loadSource(false);
+  } catch (e: any) {
+    saveError.value = e?.message || String(e);
+  } finally {
+    saving.value = false;
+  }
+}
+
+function closeDialog() {
+  emit("update:open", false);
+}
+</script>
+
+<template>
+  <Dialog :open="props.open" @update:open="(value) => emit('update:open', value)">
+    <DialogContent class="h-[min(760px,calc(100dvh-2rem))] grid-rows-[auto_minmax(0,1fr)_auto] sm:max-w-[900px]">
+      <DialogHeader>
+        <DialogTitle>{{ title }}</DialogTitle>
+      </DialogHeader>
+
+      <div v-if="loading" class="flex min-h-0 items-center justify-center gap-2 text-sm text-muted-foreground">
+        <Loader2 class="h-4 w-4 animate-spin" />
+        <span>{{ t("common.loading") }}</span>
+      </div>
+      <div v-else-if="error" class="flex min-h-0 flex-col items-center justify-center gap-3 text-sm">
+        <p class="text-destructive">{{ error }}</p>
+        <Button variant="outline" size="sm" @click="loadSource()">
+          <RefreshCw class="h-4 w-4" />
+          {{ t("common.retry") }}
+        </Button>
+      </div>
+      <div v-else-if="editing" class="object-source-dialog-editor flex min-h-0 flex-col overflow-hidden rounded border" data-object-source-editor>
+        <QueryEditor
+          v-model="draft"
+          class="min-h-0 flex-1"
+          :connection-id="props.connectionId"
+          :database="props.database"
+          :schema="props.schema || props.database"
+          :database-type="props.databaseType"
+          :dialect="props.dialect"
+          :format-dialect="props.formatDialect"
+          force-word-wrap
+          hide-execution-controls
+          @save="saveSource"
+        />
+        <div v-if="saveError" class="shrink-0 border-t px-3 py-2 text-xs text-destructive">
+          {{ saveError }}
+        </div>
+      </div>
+      <QueryEditor
+        v-else
+        :key="`${props.connectionId}:${props.database}:${props.schema || ''}:${props.name}:${props.objectType}`"
+        :model-value="content"
+        class="object-source-dialog-editor min-h-0 overflow-hidden rounded border"
+        :connection-id="props.connectionId"
+        :database="props.database"
+        :schema="props.schema || props.database"
+        :database-type="props.databaseType"
+        :dialect="props.dialect"
+        :format-dialect="props.formatDialect"
+        force-word-wrap
+        read-only
+        hide-execution-controls
+        data-object-source-preview
+      />
+
+      <DialogFooter>
+        <Button variant="outline" @click="closeDialog">{{ t("common.close") }}</Button>
+        <Button v-if="!editing" variant="outline" :disabled="!content" @click="copySource">
+          <Clipboard class="h-4 w-4" />
+          {{ t("grid.copy") }}
+        </Button>
+        <Button v-if="!editing && canEdit" variant="outline" :disabled="!editableText" @click="editSource">
+          <PencilLine class="h-4 w-4" />
+          {{ t("contextMenu.editView") }}
+        </Button>
+        <Button v-if="editing" variant="outline" :disabled="saving" @click="cancelEditSource">
+          {{ t("objects.cancelEdit") }}
+        </Button>
+        <Button v-if="editing" :disabled="saving || !draft.trim()" @click="saveSource">
+          <Loader2 v-if="saving" class="h-4 w-4 animate-spin" />
+          {{ t("objects.saveSource") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
+
+<style scoped>
+.object-source-dialog-editor :deep(.cm-editor),
+.object-source-dialog-editor :deep(.cm-scroller) {
+  height: 100%;
+}
+
+.object-source-dialog-editor :deep(.cm-scroller) {
+  overflow: auto !important;
+}
+</style>
diff --git a/apps/desktop/src/components/objects/ProcedureExecutionDialog.vue b/apps/desktop/src/components/objects/ProcedureExecutionDialog.vue
new file mode 100644
index 0000000..fae7475
--- /dev/null
+++ b/apps/desktop/src/components/objects/ProcedureExecutionDialog.vue
@@ -0,0 +1,229 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { CircleHelp, Loader2 } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import LightTooltip from "@/components/ui/LightTooltip.vue";
+import { loadRoutineParameters } from "@/lib/table/routineParameters";
+import { acceptsRoutineInput, buildProcedureExecutionSql, buildProcedureExecutionSqlFromValues, type RoutineParameterValue } from "@/lib/table/routineExecutionSql";
+import type { DatabaseType } from "@/types/database";
+
+const { t } = useI18n();
+
+const open = defineModel<boolean>("open", { default: false });
+
+const props = defineProps<{
+  connectionId: string;
+  database: string;
+  databaseType?: DatabaseType;
+  schema?: string;
+  routineName: string;
+}>();
+
+const emit = defineEmits<{
+  execute: [sql: string];
+  openSql: [sql: string];
+}>();
+
+const loading = ref(false);
+const loadError = ref("");
+const parameters = ref<RoutineParameterValue[]>([]);
+const sqlDraft = ref("");
+const manualSqlDirty = ref(false);
+let loadToken = 0;
+
+const generatedSql = computed(() => {
+  if (parameters.value.length) {
+    return buildProcedureExecutionSqlFromValues({
+      databaseType: props.databaseType,
+      schema: props.schema,
+      routineName: props.routineName,
+      parameters: parameters.value,
+    });
+  }
+  return buildProcedureExecutionSql({
+    databaseType: props.databaseType,
+    schema: props.schema,
+    routineName: props.routineName,
+  });
+});
+
+const inputParameterCount = computed(() => parameters.value.filter(acceptsRoutineInput).length);
+const outputParameterCount = computed(() => parameters.value.filter((parameter) => parameter.mode === "OUT").length);
+
+watch(
+  () => [open.value, props.connectionId, props.database, props.databaseType, props.schema, props.routineName] as const,
+  ([isOpen]) => {
+    if (!isOpen || !props.connectionId || !props.database || !props.routineName) return;
+    void refreshParameters();
+  },
+  { immediate: true },
+);
+
+watch(
+  generatedSql,
+  (sql) => {
+    if (!manualSqlDirty.value) sqlDraft.value = sql;
+  },
+  { immediate: true },
+);
+
+async function refreshParameters() {
+  const token = ++loadToken;
+  loading.value = true;
+  loadError.value = "";
+  parameters.value = [];
+  manualSqlDirty.value = false;
+  sqlDraft.value = generatedSql.value;
+  try {
+    const loaded = await loadRoutineParameters({
+      connectionId: props.connectionId,
+      database: props.database,
+      databaseType: props.databaseType,
+      schema: props.schema,
+      routineName: props.routineName,
+    });
+    if (token !== loadToken) return;
+    parameters.value = loaded.map((parameter) => ({
+      ...parameter,
+      value: "",
+      useNull: false,
+      useDefault: !!parameter.hasDefault,
+    }));
+    sqlDraft.value = generatedSql.value;
+  } catch (e: any) {
+    if (token !== loadToken) return;
+    loadError.value = e?.message || String(e);
+    sqlDraft.value = generatedSql.value;
+  } finally {
+    if (token === loadToken) loading.value = false;
+  }
+}
+
+function onSqlInput(event: Event) {
+  manualSqlDirty.value = true;
+  sqlDraft.value = (event.target as HTMLTextAreaElement).value;
+}
+
+function resetSqlPreview() {
+  manualSqlDirty.value = false;
+  sqlDraft.value = generatedSql.value;
+}
+
+function close() {
+  open.value = false;
+}
+
+function openSql() {
+  const sql = sqlDraft.value.trim();
+  if (!sql) return;
+  close();
+  emit("openSql", sql);
+}
+
+function execute() {
+  const sql = sqlDraft.value.trim();
+  if (!sql) return;
+  close();
+  emit("execute", sql);
+}
+
+function canEditParameter(parameter: RoutineParameterValue): boolean {
+  return acceptsRoutineInput(parameter);
+}
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent class="max-h-[86vh] border border-border !bg-background text-foreground shadow-2xl !backdrop-blur-none sm:max-w-[780px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("contextMenu.confirmExecuteProcedureTitle") }}</DialogTitle>
+      </DialogHeader>
+
+      <div class="grid max-h-[calc(86vh-8rem)] gap-4 overflow-y-auto pr-1">
+        <div class="flex min-w-0 items-start justify-between gap-3">
+          <div class="min-w-0 space-y-1">
+            <p class="truncate text-sm text-muted-foreground">
+              {{ t("contextMenu.confirmExecuteProcedureMessage", { name: props.routineName }) }}
+            </p>
+            <p class="truncate font-mono text-xs text-muted-foreground">
+              {{ props.schema ? `${props.schema}.${props.routineName}` : props.routineName }}
+            </p>
+          </div>
+          <div class="flex shrink-0 items-center gap-2">
+            <Badge v-if="inputParameterCount" variant="outline">
+              {{ t("contextMenu.inputParameters", { count: inputParameterCount }) }}
+            </Badge>
+            <Badge v-if="outputParameterCount" variant="outline">
+              {{ t("contextMenu.outputParameters", { count: outputParameterCount }) }}
+            </Badge>
+          </div>
+        </div>
+
+        <div v-if="loading" class="flex items-center gap-2 rounded-md border bg-muted/30 px-3 py-2 text-sm text-muted-foreground">
+          <Loader2 class="h-4 w-4 animate-spin" />
+          {{ t("contextMenu.loadingProcedureParameters") }}
+        </div>
+
+        <div v-else-if="parameters.length" class="overflow-x-auto rounded-md border bg-background">
+          <div class="min-w-[650px]">
+            <div class="grid grid-cols-[minmax(120px,1.2fr)_minmax(96px,1fr)_72px_minmax(160px,1.5fr)_64px_86px] border-b bg-muted px-3 py-2 text-xs font-medium text-muted-foreground">
+              <div>{{ t("contextMenu.parameterName") }}</div>
+              <div>{{ t("contextMenu.parameterType") }}</div>
+              <div>{{ t("contextMenu.parameterMode") }}</div>
+              <div>{{ t("contextMenu.parameterValue") }}</div>
+              <div>{{ t("contextMenu.parameterNull") }}</div>
+              <div class="flex items-center gap-1">
+                {{ t("contextMenu.parameterDefault") }}
+                <LightTooltip :text="t('contextMenu.parameterDefaultHint')" side="top" :delay="150">
+                  <button type="button" class="inline-flex h-4 w-4 items-center justify-center rounded-full text-muted-foreground hover:bg-background hover:text-foreground" :aria-label="t('contextMenu.parameterDefaultHint')">
+                    <CircleHelp class="h-3.5 w-3.5" />
+                  </button>
+                </LightTooltip>
+              </div>
+            </div>
+            <div v-for="parameter in parameters" :key="`${parameter.ordinal}:${parameter.name}`" class="grid grid-cols-[minmax(120px,1.2fr)_minmax(96px,1fr)_72px_minmax(160px,1.5fr)_64px_86px] items-center gap-2 border-b px-3 py-2 text-sm last:border-b-0">
+              <div class="min-w-0 truncate font-medium">{{ parameter.name }}</div>
+              <div class="min-w-0 truncate text-muted-foreground">{{ parameter.dataType || "-" }}</div>
+              <div class="text-xs text-muted-foreground">{{ parameter.mode }}</div>
+              <Input v-model="parameter.value" class="h-8 bg-background font-mono text-xs" :disabled="!canEditParameter(parameter) || parameter.useNull || parameter.useDefault" :placeholder="canEditParameter(parameter) ? t('contextMenu.parameterValuePlaceholder') : t('contextMenu.outputOnly')" />
+              <input type="checkbox" class="h-4 w-4 accent-primary" :checked="!!parameter.useNull" :disabled="!canEditParameter(parameter) || parameter.useDefault" @change="(event: Event) => (parameter.useNull = (event.target as HTMLInputElement).checked)" />
+              <input type="checkbox" class="h-4 w-4 accent-primary" :checked="!!parameter.useDefault" :disabled="!canEditParameter(parameter) || !parameter.hasDefault || parameter.useNull" @change="(event: Event) => (parameter.useDefault = (event.target as HTMLInputElement).checked)" />
+            </div>
+          </div>
+        </div>
+
+        <p v-else-if="loadError" class="rounded-md border border-amber-200 bg-amber-50 px-3 py-2 text-sm text-amber-800">
+          {{ t("contextMenu.procedureParametersUnavailable") }}
+        </p>
+
+        <p v-else class="rounded-md border bg-muted/30 px-3 py-2 text-sm text-muted-foreground">
+          {{ t("contextMenu.noProcedureParameters") }}
+        </p>
+
+        <div class="grid gap-2">
+          <div class="flex items-center justify-between gap-2">
+            <div class="text-xs font-medium text-muted-foreground">{{ t("contextMenu.sqlPreview") }}</div>
+            <Button v-if="manualSqlDirty" variant="ghost" size="sm" class="h-7 px-2 text-xs" @click="resetSqlPreview">
+              {{ t("contextMenu.resetSqlPreview") }}
+            </Button>
+          </div>
+          <textarea :value="sqlDraft" class="min-h-28 w-full resize-y rounded-md border border-input bg-background px-3 py-2 font-mono text-xs outline-none transition-colors focus:border-ring focus:ring-1 focus:ring-ring/40" spellcheck="false" @input="onSqlInput"></textarea>
+        </div>
+      </div>
+
+      <DialogFooter>
+        <Button variant="outline" @click="close">{{ t("dangerDialog.cancel") }}</Button>
+        <Button variant="outline" :disabled="!sqlDraft.trim()" @click="openSql">
+          {{ t("contextMenu.openInSqlEditor") }}
+        </Button>
+        <Button :disabled="!sqlDraft.trim()" @click="execute">
+          {{ t("contextMenu.executeProcedure") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/quick-open/QuickOpenDialog.vue b/apps/desktop/src/components/quick-open/QuickOpenDialog.vue
new file mode 100644
index 0000000..e69d4b9
--- /dev/null
+++ b/apps/desktop/src/components/quick-open/QuickOpenDialog.vue
@@ -0,0 +1,191 @@
+<script setup lang="ts">
+import { computed, ref, watch, nextTick } from "vue";
+import { useI18n } from "vue-i18n";
+import { Command } from "@lucide/vue";
+import { Dialog, DialogContent } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { useQuickOpen, type QuickOpenItem } from "@/composables/useQuickOpen";
+
+const props = defineProps<{
+  open: boolean;
+}>();
+
+const emit = defineEmits<{
+  "update:open": [value: boolean];
+  select: [item: QuickOpenItem];
+}>();
+
+const { t } = useI18n();
+const { searchQuery, filteredItems, selectedIndex, selectedItem, selectNext, selectPrevious, setQuery } = useQuickOpen();
+const inputRef = ref<HTMLInputElement | null>(null);
+
+const dialogOpen = computed({
+  get: () => props.open,
+  set: (value) => emit("update:open", value),
+});
+
+function handleKeyDown(e: KeyboardEvent): void {
+  if (e.key === "ArrowDown") {
+    e.preventDefault();
+    selectNext();
+  } else if (e.key === "ArrowUp") {
+    e.preventDefault();
+    selectPrevious();
+  } else if (e.key === "Enter" && selectedItem.value) {
+    e.preventDefault();
+    handleSelect(selectedItem.value);
+  } else if (e.key === "Escape") {
+    e.preventDefault();
+    dialogOpen.value = false;
+  }
+}
+
+function handleSelect(item: QuickOpenItem): void {
+  emit("select", item);
+  dialogOpen.value = false;
+}
+
+function getHighlightedLabel(item: any): (string | { text: string; highlight: boolean })[] {
+  if (!searchQuery.value.trim() || !item.matchIndices) {
+    return [item.label];
+  }
+
+  const indices = new Set(item.matchIndices);
+  const parts: (string | { text: string; highlight: boolean })[] = [];
+  let current = "";
+  let isHighlighting = false;
+
+  for (let i = 0; i < item.label.length; i++) {
+    const char = item.label[i];
+    const shouldHighlight = indices.has(i);
+
+    if (shouldHighlight !== isHighlighting) {
+      if (current) {
+        parts.push({
+          text: current,
+          highlight: isHighlighting,
+        });
+      }
+      current = char;
+      isHighlighting = shouldHighlight;
+    } else {
+      current += char;
+    }
+  }
+
+  if (current) {
+    parts.push({
+      text: current,
+      highlight: isHighlighting,
+    });
+  }
+
+  return parts;
+}
+
+function getTypeLabel(type: string): string {
+  switch (type) {
+    case "connection":
+      return t("common.connection");
+    case "database":
+      return t("common.database");
+    case "schema":
+      return t("common.schema");
+    case "table":
+      return t("common.table");
+    case "view":
+      return t("common.view");
+    case "materialized_view":
+      return t("common.materializedView");
+    case "procedure":
+      return t("common.procedure");
+    case "function":
+      return t("common.function");
+    case "sequence":
+      return t("common.sequence");
+    case "package":
+      return t("common.package");
+    case "package-body":
+      return t("common.packageBody");
+    default:
+      return type;
+  }
+}
+
+watch(
+  () => props.open,
+  (newOpen) => {
+    if (newOpen) {
+      setQuery("");
+      nextTick(() => {
+        inputRef.value?.focus();
+      });
+    }
+  },
+);
+</script>
+
+<template>
+  <Dialog :open="dialogOpen" @update:open="dialogOpen = $event">
+    <DialogContent class="max-w-2xl p-0 gap-0 rounded-lg overflow-hidden">
+      <div class="flex flex-col bg-background">
+        <!-- Search Input -->
+        <div class="flex items-center gap-3 px-4 py-3 border-b">
+          <Command class="h-5 w-5 text-muted-foreground" />
+          <Input ref="inputRef" v-model="searchQuery" type="text" :placeholder="t('quickOpen.placeholder')" class="flex-1 border-0 bg-transparent p-0 placeholder:text-muted-foreground focus-visible:ring-0 focus-visible:outline-none" @keydown="handleKeyDown" />
+        </div>
+
+        <!-- Results List -->
+        <div class="max-h-[400px] overflow-y-auto">
+          <div v-if="filteredItems.length === 0" class="px-4 py-8 text-center text-muted-foreground">
+            <p v-if="!searchQuery.trim()">{{ t("quickOpen.emptyPlaceholder") }}</p>
+            <p v-else>{{ t("quickOpen.noResults") }}</p>
+          </div>
+
+          <div v-else class="divide-y">
+            <div v-for="(item, index) in filteredItems" :key="item.id" :class="['px-4 py-2 cursor-pointer', index === selectedIndex ? 'bg-accent' : 'hover:bg-muted']" @click="handleSelect(item)" @mouseenter="selectedIndex = index">
+              <div class="flex items-center justify-between gap-3">
+                <div class="flex-1 min-w-0">
+                  <div class="text-sm font-medium truncate">
+                    <template v-for="(part, i) in getHighlightedLabel(item)" :key="i">
+                      <span v-if="typeof part === 'object'" :class="{ 'bg-yellow-200 dark:bg-yellow-800 font-semibold': part.highlight }">
+                        {{ part.text }}
+                      </span>
+                      <span v-else>{{ part }}</span>
+                    </template>
+                  </div>
+                  <div v-if="item.description" class="text-xs text-muted-foreground truncate">
+                    {{ item.description }}
+                  </div>
+                </div>
+                <div class="text-xs px-2 py-1 rounded bg-muted text-muted-foreground whitespace-nowrap">
+                  {{ getTypeLabel(item.type) }}
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <!-- Footer -->
+        <div class="px-4 py-2 border-t text-xs text-muted-foreground flex justify-between">
+          <div>{{ filteredItems.length }} {{ t("quickOpen.results") }}</div>
+          <div class="flex gap-4">
+            <span><kbd class="px-2 py-1 rounded bg-muted">↑↓</kbd> {{ t("quickOpen.navigate") }}</span>
+            <span><kbd class="px-2 py-1 rounded bg-muted">⏎</kbd> {{ t("quickOpen.select") }}</span>
+            <span><kbd class="px-2 py-1 rounded bg-muted">ESC</kbd> {{ t("quickOpen.close") }}</span>
+          </div>
+        </div>
+      </div>
+    </DialogContent>
+  </Dialog>
+</template>
+
+<style scoped>
+:deep(.bg-yellow-200) {
+  background-color: rgb(254 227 92);
+}
+
+:deep(.dark .bg-yellow-800) {
+  background-color: rgb(92 51 0);
+}
+</style>
diff --git a/apps/desktop/src/components/redis/RedisDashboard.vue b/apps/desktop/src/components/redis/RedisDashboard.vue
new file mode 100644
index 0000000..ce67a27
--- /dev/null
+++ b/apps/desktop/src/components/redis/RedisDashboard.vue
@@ -0,0 +1,480 @@
+<script setup lang="ts">
+import { ref, computed, onMounted, onUnmounted, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { RefreshCw, Loader2, Search, ChevronDown, ChevronRight, Clock, Info, HardDrive, Activity, Target, Database, Users, Terminal, AlertCircle } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Tooltip, TooltipTrigger, TooltipContent } from "@/components/ui/tooltip";
+import * as api from "@/lib/backend/api";
+import type { RedisNodeEndpoint, RedisCommandResult } from "@/lib/backend/api";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useToast } from "@/composables/useToast";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+interface InfoEntry {
+  key: string;
+  value: string;
+}
+
+interface InfoSection {
+  name: string;
+  entries: InfoEntry[];
+}
+
+// ---------------------------------------------------------------------------
+// Props
+// ---------------------------------------------------------------------------
+const props = defineProps<{
+  connectionId: string;
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+const connectionStore = useConnectionStore();
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+const loading = ref(true);
+const fetching = ref(false);
+const error = ref<string | null>(null);
+const rawSections = ref<InfoSection[]>([]);
+const masterNodes = ref<RedisNodeEndpoint[]>([]);
+const selectedNodeIndex = ref("0"); // string for Select compatibility
+const searchQuery = ref("");
+const collapsedSections = ref<Set<string>>(new Set());
+const autoRefreshInterval = ref<number>(0); // 0 = off, 5, 10, 30, 60 (seconds)
+
+let refreshTimer: ReturnType<typeof setInterval> | null = null;
+
+// ---------------------------------------------------------------------------
+// Connection mode
+// ---------------------------------------------------------------------------
+const connectionMode = computed(() => {
+  return connectionStore.getConfig(props.connectionId)?.redis_connection_mode;
+});
+
+const isClusterMode = computed(() => connectionMode.value === "cluster");
+const showNodeSelector = computed(() => isClusterMode.value);
+
+const nodeOptions = computed(() => {
+  return masterNodes.value.map((n) => `${n.host}:${n.port}`);
+});
+
+// ---------------------------------------------------------------------------
+// Parsing helpers
+// ---------------------------------------------------------------------------
+function parseInfoText(text: string): InfoSection[] {
+  const sections: InfoSection[] = [];
+  let current: InfoSection | null = null;
+  for (const line of text.split("\n")) {
+    if (line.startsWith("# ")) {
+      current = { name: line.slice(2).trim(), entries: [] };
+      sections.push(current);
+    } else if (current && line.includes(":")) {
+      const idx = line.indexOf(":");
+      current.entries.push({ key: line.slice(0, idx), value: line.slice(idx + 1).replace(/\r$/, "") });
+    }
+  }
+  return sections;
+}
+
+// ---------------------------------------------------------------------------
+// Data fetching
+// ---------------------------------------------------------------------------
+async function fetchInfo() {
+  if (fetching.value) return;
+  fetching.value = true;
+  loading.value = true;
+  error.value = null;
+  try {
+    const result: RedisCommandResult = await api.redisExecuteCommand(props.connectionId, 0, "INFO ALL");
+
+    let infoText = "";
+
+    if (isClusterMode.value && Array.isArray(result.value)) {
+      // Cluster mode: result is [[addr, infoText], ...]
+      const pairs: [string, string][] = result.value.map((item: any) => {
+        if (Array.isArray(item) && item.length >= 2) return [String(item[0]), String(item[1])];
+        return ["", ""];
+      });
+      // Populate masterNodes from INFO response on first load if fetchClusterNodes failed
+      if (masterNodes.value.length === 0) {
+        masterNodes.value = pairs.map(([addr]) => {
+          const [host, portStr] = addr.split(":");
+          return { host, port: parseInt(portStr, 10) || 6379 };
+        });
+      }
+      // Match selected node by address, fall back to first node
+      const selectedAddr = nodeOptions.value[Number(selectedNodeIndex.value)];
+      const found = pairs.find(([addr]) => addr === selectedAddr);
+      if (found) {
+        infoText = found[1];
+      } else if (pairs.length > 0) {
+        infoText = pairs[0][1];
+      }
+    } else if (typeof result.value === "string") {
+      infoText = result.value;
+    }
+
+    rawSections.value = parseInfoText(infoText);
+    // Default all sections to collapsed (only on first load to preserve user interactions)
+    if (collapsedSections.value.size === 0) {
+      collapsedSections.value = new Set(rawSections.value.map((s) => s.name));
+    }
+  } catch (e: any) {
+    error.value = e?.message || String(e);
+    rawSections.value = [];
+  } finally {
+    loading.value = false;
+    fetching.value = false;
+  }
+}
+
+async function fetchClusterNodes() {
+  if (!isClusterMode.value) return;
+  try {
+    masterNodes.value = await api.redisClusterMasterNodes(props.connectionId);
+  } catch (e: any) {
+    // Nodes will be populated from the INFO response instead
+    console.warn("Failed to fetch cluster master nodes:", e?.message || e);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Stat card helpers
+// ---------------------------------------------------------------------------
+function findValue(sectionName: string, key: string): string | undefined {
+  for (const sec of rawSections.value) {
+    if (sec.name === sectionName) {
+      for (const entry of sec.entries) {
+        if (entry.key === key) return entry.value;
+      }
+    }
+  }
+  return undefined;
+}
+
+const totalMemory = computed(() => {
+  return findValue("Memory", "total_system_memory_human") || findValue("Memory", "maxmemory_human") || "N/A";
+});
+
+const usedMemory = computed(() => {
+  return findValue("Memory", "used_memory_human") || "N/A";
+});
+
+const operation = computed(() => {
+  const val = findValue("Stats", "total_commands_processed");
+  if (val === undefined) return "N/A";
+  const num = parseInt(val, 10);
+  if (isNaN(num)) return val;
+  return num.toLocaleString();
+});
+
+const hitRatio = computed(() => {
+  const hits = findValue("Stats", "keyspace_hits");
+  const misses = findValue("Stats", "keyspace_misses");
+  if (hits === undefined || misses === undefined) return "N/A";
+  const h = parseInt(hits, 10);
+  const m = parseInt(misses, 10);
+  if (isNaN(h) || isNaN(m) || h + m === 0) return "N/A";
+  return `${((h / (h + m)) * 100).toFixed(2)}%`;
+});
+
+const keyCount = computed(() => {
+  const keyspaceSec = rawSections.value.find((s) => s.name === "Keyspace");
+  if (!keyspaceSec) return "N/A";
+  let total = 0;
+  for (const entry of keyspaceSec.entries) {
+    const match = entry.value.match(/keys=(\d+)/);
+    if (match) total += parseInt(match[1], 10);
+  }
+  return total.toLocaleString();
+});
+
+const connectedClients = computed(() => {
+  const val = findValue("Clients", "connected_clients");
+  if (val === undefined) return "N/A";
+  const num = parseInt(val, 10);
+  if (isNaN(num)) return val;
+  return num.toLocaleString();
+});
+
+// ---------------------------------------------------------------------------
+// Search / filter
+// ---------------------------------------------------------------------------
+const filteredSections = computed(() => {
+  const q = searchQuery.value.trim().toLowerCase();
+  if (!q) return rawSections.value;
+  return rawSections.value
+    .map((sec) => ({
+      ...sec,
+      entries: sec.entries.filter((e) => e.key.toLowerCase().includes(q)),
+    }))
+    .filter((sec) => sec.entries.length > 0);
+});
+
+function toggleSection(name: string) {
+  const next = new Set(collapsedSections.value);
+  if (next.has(name)) next.delete(name);
+  else next.add(name);
+  collapsedSections.value = next;
+}
+
+function isCollapsed(name: string): boolean {
+  return collapsedSections.value.has(name);
+}
+
+// ---------------------------------------------------------------------------
+// Auto-refresh
+// ---------------------------------------------------------------------------
+function startAutoRefresh() {
+  stopAutoRefresh();
+  if (autoRefreshInterval.value > 0) {
+    refreshTimer = setInterval(() => {
+      fetchInfo();
+    }, autoRefreshInterval.value * 1000);
+  }
+}
+
+function stopAutoRefresh() {
+  if (refreshTimer !== null) {
+    clearInterval(refreshTimer);
+    refreshTimer = null;
+  }
+}
+
+watch(autoRefreshInterval, () => {
+  startAutoRefresh();
+});
+
+// ---------------------------------------------------------------------------
+// Lifecycle
+// ---------------------------------------------------------------------------
+onMounted(async () => {
+  try {
+    await connectionStore.ensureConnected(props.connectionId);
+  } catch (e) {
+    console.warn("[DBX] ensureConnected failed for", props.connectionId, e);
+  }
+  await fetchClusterNodes();
+  await fetchInfo();
+});
+
+onUnmounted(() => {
+  stopAutoRefresh();
+});
+
+// ---------------------------------------------------------------------------
+// Refresh button
+// ---------------------------------------------------------------------------
+async function handleRefresh() {
+  // Re-fetch cluster nodes only if in cluster mode
+  if (isClusterMode.value) {
+    await fetchClusterNodes();
+  }
+  await fetchInfo();
+}
+
+// ---------------------------------------------------------------------------
+// Copy helpers
+// ---------------------------------------------------------------------------
+function copyToClipboard(text: string) {
+  navigator.clipboard
+    .writeText(text)
+    .then(() => {
+      toast("Copied", 1500);
+    })
+    .catch(() => {
+      // Fallback for environments without clipboard API
+      const ta = document.createElement("textarea");
+      ta.value = text;
+      ta.style.position = "fixed";
+      ta.style.opacity = "0";
+      document.body.appendChild(ta);
+      ta.select();
+      document.execCommand("copy");
+      document.body.removeChild(ta);
+    });
+}
+
+function copyEntryKey(entry: InfoEntry) {
+  copyToClipboard(entry.key);
+}
+
+function copyEntryValue(entry: InfoEntry) {
+  copyToClipboard(entry.value);
+}
+</script>
+
+<template>
+  <div class="h-full flex flex-col bg-background">
+    <!-- Header toolbar -->
+    <div class="shrink-0 border-b bg-muted/20 px-4 py-2">
+      <!-- Top row: node selector (cluster only) + refresh controls -->
+      <div class="flex items-center justify-between gap-2">
+        <div class="flex items-center gap-2 min-w-0">
+          <div v-if="showNodeSelector && nodeOptions.length > 0" class="flex items-center gap-2">
+            <span class="text-xs text-muted-foreground whitespace-nowrap">Node:</span>
+            <Select v-model="selectedNodeIndex" @update:model-value="fetchInfo">
+              <SelectTrigger class="h-7 w-auto min-w-[140px] text-xs">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem v-for="(node, i) in nodeOptions" :key="i" :value="String(i)" class="text-xs">
+                  {{ node }}
+                </SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+        </div>
+        <div class="flex items-center gap-1 shrink-0">
+          <!-- Auto-refresh select -->
+          <Select v-model="autoRefreshInterval">
+            <SelectTrigger class="h-7 w-auto min-w-[80px] text-xs">
+              <Clock class="mr-1 h-3 w-3" />
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem :value="0" class="text-xs">Off</SelectItem>
+              <SelectItem :value="1" class="text-xs">1s</SelectItem>
+              <SelectItem :value="5" class="text-xs">5s</SelectItem>
+              <SelectItem :value="15" class="text-xs">15s</SelectItem>
+              <SelectItem :value="30" class="text-xs">30s</SelectItem>
+            </SelectContent>
+          </Select>
+          <!-- Refresh button -->
+          <Tooltip>
+            <TooltipTrigger as-child>
+              <Button variant="ghost" size="icon" class="h-7 w-7 shrink-0" :disabled="loading" @click="handleRefresh">
+                <Loader2 v-if="loading" class="h-3.5 w-3.5 animate-spin" />
+                <RefreshCw v-else class="h-3.5 w-3.5" />
+              </Button>
+            </TooltipTrigger>
+            <TooltipContent>Refresh</TooltipContent>
+          </Tooltip>
+        </div>
+      </div>
+    </div>
+
+    <!-- Error banner -->
+    <div v-if="error" class="shrink-0 mx-4 mt-2 flex items-center gap-2 rounded-md border border-destructive/30 bg-destructive/5 px-3 py-2 text-xs text-destructive">
+      <AlertCircle class="h-3.5 w-3.5 shrink-0" />
+      <span>{{ error }}</span>
+    </div>
+
+    <!-- Scrollable content -->
+    <div class="flex-1 min-h-0 overflow-auto">
+      <!-- Stat cards -->
+      <div class="grid grid-cols-6 gap-3 px-4 pt-3 pb-2">
+        <!-- Total Memory -->
+        <div class="rounded-lg border bg-card text-card-foreground p-3">
+          <div class="flex items-center gap-1.5 text-xs text-muted-foreground mb-1">
+            <HardDrive class="h-3.5 w-3.5" />
+            <span>Total Memory</span>
+          </div>
+          <div class="text-xl font-semibold tabular-nums dbx-editor-font-family truncate" :title="totalMemory">
+            {{ totalMemory }}
+          </div>
+        </div>
+        <!-- Used Memory -->
+        <div class="rounded-lg border bg-card text-card-foreground p-3">
+          <div class="flex items-center gap-1.5 text-xs text-muted-foreground mb-1">
+            <Activity class="h-3.5 w-3.5" />
+            <span>Used Memory</span>
+          </div>
+          <div class="text-xl font-semibold tabular-nums dbx-editor-font-family truncate" :title="usedMemory">
+            {{ usedMemory }}
+          </div>
+        </div>
+        <!-- Operation -->
+        <div class="rounded-lg border bg-card text-card-foreground p-3">
+          <div class="flex items-center gap-1.5 text-xs text-muted-foreground mb-1">
+            <Terminal class="h-3.5 w-3.5" />
+            <span>Operations</span>
+          </div>
+          <div class="text-xl font-semibold tabular-nums dbx-editor-font-family truncate" :title="operation">
+            {{ operation }}
+          </div>
+        </div>
+        <!-- Hit Ratio -->
+        <div class="rounded-lg border bg-card text-card-foreground p-3">
+          <div class="flex items-center gap-1.5 text-xs text-muted-foreground mb-1">
+            <Target class="h-3.5 w-3.5" />
+            <span>Hit Ratio</span>
+          </div>
+          <div class="text-xl font-semibold tabular-nums dbx-editor-font-family truncate" :title="hitRatio">
+            {{ hitRatio }}
+          </div>
+        </div>
+        <!-- Key Count -->
+        <div class="rounded-lg border bg-card text-card-foreground p-3">
+          <div class="flex items-center gap-1.5 text-xs text-muted-foreground mb-1">
+            <Database class="h-3.5 w-3.5" />
+            <span>Key Count</span>
+          </div>
+          <div class="text-xl font-semibold tabular-nums dbx-editor-font-family truncate" :title="keyCount">
+            {{ keyCount }}
+          </div>
+        </div>
+        <!-- Clients -->
+        <div class="rounded-lg border bg-card text-card-foreground p-3">
+          <div class="flex items-center gap-1.5 text-xs text-muted-foreground mb-1">
+            <Users class="h-3.5 w-3.5" />
+            <span>Clients</span>
+          </div>
+          <div class="text-xl font-semibold tabular-nums dbx-editor-font-family truncate" :title="connectedClients">
+            {{ connectedClients }}
+          </div>
+        </div>
+      </div>
+
+      <!-- Search bar -->
+      <div class="px-4 pb-2">
+        <div class="relative">
+          <Search class="absolute left-2.5 top-1/2 -translate-y-1/2 h-3.5 w-3.5 text-muted-foreground pointer-events-none" />
+          <Input v-model="searchQuery" class="h-8 pl-7 text-xs" placeholder="Search indicators..." />
+        </div>
+      </div>
+
+      <!-- Loading state -->
+      <div v-if="loading && rawSections.length === 0" class="flex items-center justify-center py-12 text-xs text-muted-foreground">
+        <Loader2 class="mr-2 h-4 w-4 animate-spin" />
+        {{ t("common.loading") }}
+      </div>
+
+      <!-- Info sections -->
+      <div v-else-if="filteredSections.length > 0" class="px-4 pb-4 space-y-1">
+        <div v-for="section in filteredSections" :key="section.name" class="rounded-lg border overflow-hidden" :class="[!isCollapsed(section.name) ? 'bg-muted/60' : '']">
+          <!-- Section header (clickable) -->
+          <button class="w-full flex items-center gap-2 px-3 py-2 text-xs font-semibold text-foreground hover:bg-muted/50 transition-colors text-left" @click="toggleSection(section.name)">
+            <component :is="isCollapsed(section.name) ? ChevronRight : ChevronDown" class="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+            <span>{{ section.name }}</span>
+            <span class="ml-auto text-muted-foreground font-normal">{{ section.entries.length }}</span>
+          </button>
+          <!-- Section body -->
+          <div v-if="!isCollapsed(section.name)" class="border-t">
+            <table class="w-full text-xs border-collapse">
+              <tbody>
+                <tr v-for="(entry, ei) in section.entries" :key="ei" class="hover:bg-muted/20">
+                  <td class="w-1/2 border-r border-b px-3 py-1.5 text-muted-foreground select-text break-all cursor-context-menu" :title="t('common.copy') || 'Copy'" @contextmenu.prevent="copyEntryKey(entry)">{{ entry.key }}</td>
+                  <td class="w-1/2 border-b px-3 py-1.5 dbx-editor-font-family tabular-nums select-text break-all cursor-context-menu" :title="t('common.copy') || 'Copy'" @contextmenu.prevent="copyEntryValue(entry)">{{ entry.value }}</td>
+                </tr>
+              </tbody>
+            </table>
+          </div>
+        </div>
+      </div>
+
+      <!-- Empty / no data -->
+      <div v-else-if="!loading" class="flex flex-col items-center justify-center py-12 text-xs text-muted-foreground">
+        <Info class="mb-2 h-5 w-5" />
+        <span v-if="searchQuery">No matching indicators</span>
+        <span v-else>No data available</span>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/redis/RedisKeyBrowser.vue b/apps/desktop/src/components/redis/RedisKeyBrowser.vue
new file mode 100644
index 0000000..0c9ea00
--- /dev/null
+++ b/apps/desktop/src/components/redis/RedisKeyBrowser.vue
@@ -0,0 +1,1473 @@
+<script setup lang="ts">
+import { computed, nextTick, ref, onMounted, onUnmounted, onActivated, onDeactivated, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { Search, RefreshCw, Loader2, ChevronRight, ChevronDown, FolderClosed, FolderOpen, Trash2, Plus, KeyRound, TerminalSquare, Asterisk, History, Radio, Clock, Copy } from "@lucide/vue";
+import { RecycleScroller } from "vue-virtual-scroller";
+import "vue-virtual-scroller/dist/vue-virtual-scroller.css";
+import { Splitpanes, Pane } from "splitpanes";
+import "splitpanes/dist/splitpanes.css";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Badge } from "@/components/ui/badge";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { OptionHelpPanel } from "@/components/ui/option-help-panel";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { Switch } from "@/components/ui/switch";
+import CustomContextMenu, { type ContextMenuItem } from "@/components/ui/CustomContextMenu.vue";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import RedisValueViewer from "./RedisValueViewer.vue";
+import RedisPubSubPanel from "./RedisPubSubPanel.vue";
+import RedisSlowlogPanel from "./RedisSlowlogPanel.vue";
+import * as api from "@/lib/backend/api";
+import type { RedisKeyInfo, RedisScanResult, RedisValue, HistoryEntry } from "@/lib/backend/api";
+import { uuid } from "@/lib/common/utils";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { buildRedisKeyTree, collectExpandedGroupIds, collectRedisGroupKeyRaws, flattenVisibleRedisKeyTree, mergeKeysIntoRedisKeyTree, redisKeyNameCopyText, redisKeyToFlatTreeRow, type RedisKeyTreeNode } from "@/lib/redis/redisKeyTree";
+import { classifyRedisCommandSafety } from "@/lib/redis/redisCommandSafety";
+import { isRedisMutatingCommand } from "@/lib/redis/redisCommandTable";
+import { isRedisClearScreenCommand, nextRedisCommandDb, redisKeyTextToRaw } from "@/lib/redis/redisCommandSession";
+import { formatRedisConsoleValue, redisValuePreview, redisValueSize } from "@/lib/redis/redisValuePresentation";
+import { isCancelSearchShortcut } from "@/lib/editor/keyboardShortcuts";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { useEditorFontFamilyStyle } from "@/composables/useEditorFontFamilyStyle";
+import { useToast } from "@/composables/useToast";
+import { redisKeySearchPattern } from "@/lib/redis/redisKeyPattern";
+import { REDIS_SCAN_PAGE_SIZE_DEFAULT } from "@/lib/redis/redisKeyPattern";
+import { getRedisCreateKeyTypeHelp, redisCreateKeyTypeHelpOptionOnOpen, shouldActivateRedisCreateKeyTypeHelpOnFocus } from "@/lib/redis/redisCreateKeyTypeHelp";
+import { optionHelpPanelOffsetTop } from "@/lib/common/optionHelpPanelOffset";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const connectionStore = useConnectionStore();
+const editorFontFamilyStyle = useEditorFontFamilyStyle();
+
+type RedisSearchMode = "key" | "value" | "all";
+type RedisCreateKeyType = "string" | "hash" | "list" | "set" | "zset" | "stream" | "json";
+
+interface CreateKeyEntry {
+  id: number;
+  value: string;
+  field?: string;
+  score?: string;
+}
+type RedisSidePanel = "detail" | "command" | "pubsub" | "slowlog";
+type RedisCommandHistoryEntry = {
+  id: number;
+  prompt: string;
+  command: string;
+  output: string;
+  error: boolean;
+};
+
+const props = defineProps<{
+  connectionId: string;
+  db: number;
+  blockDangerousRedisCommands: boolean;
+}>();
+
+const flatKeys = ref<RedisKeyInfo[]>([]);
+const treeKeys = ref<RedisKeyTreeNode[]>([]);
+const loading = ref(false);
+const loadingMore = ref(false);
+const isFetchingAll = ref(false);
+const rootRef = ref<HTMLElement>();
+const commandTerminalRef = ref<HTMLElement>();
+const searchPattern = ref("");
+const searchMode = ref<RedisSearchMode>("key");
+const fuzzyKeySearch = ref(false);
+const selectedKeyRaw = ref<string | null>(null);
+const hasMore = ref(false);
+const scanCursor = ref(0);
+const expandedGroupIds = ref<Set<string>>(new Set());
+const checkedKeys = ref<Set<string>>(new Set());
+const pendingDanger = ref<{ kind: "delete-keys"; title: string; keyRaws: string[] } | { kind: "command"; command: string } | null>(null);
+const showDangerConfirm = ref(false);
+const commandText = ref("");
+const commandRunning = ref(false);
+const commandDb = ref(props.db);
+const commandHistory = ref<RedisCommandHistoryEntry[]>([]);
+const commandHistoryIndex = ref(-1);
+const activeSidePanel = ref<RedisSidePanel>("detail");
+const showCreateKeyDialog = ref(false);
+const creatingKey = ref(false);
+const createKeyName = ref("");
+const createKeyType = ref<RedisCreateKeyType>("string");
+const createKeyValue = ref("");
+const createKeyField = ref("");
+const createKeyScore = ref("0");
+const createKeyError = ref("");
+const createKeyTtl = ref("");
+const createKeyEntries = ref<CreateKeyEntry[]>([]);
+const createKeyRawMode = ref(false);
+const createKeyEntryId = ref("*");
+const jsonModuleAvailable = ref<boolean | null>(null);
+const checkingJsonModule = ref(false);
+const activeCreateKeyTypeHelp = ref<RedisCreateKeyType>();
+const createKeyTypeKeyboardNavigation = ref(false);
+const createKeyTypeOpenedByArrow = ref(false);
+const createKeyTypeListCard = ref<HTMLElement>();
+const createKeyTypeHelpPanel = ref<{ element?: HTMLElement }>();
+const createKeyTypeHelpOffsetTop = ref(0);
+let nextEntryId = 0;
+let searchRequestId = 0;
+let redisBrowserIsActive = true;
+let redisDbFlushedListenerRegistered = false;
+const loadedKeyRaws = new Set<string>();
+
+const valueQuery = computed(() => searchPattern.value.trim());
+const isValueSearchMode = computed(() => searchMode.value === "value" || searchMode.value === "all");
+const effectivePattern = computed(() => (searchMode.value === "key" ? redisKeySearchPattern(searchPattern.value, fuzzyKeySearch.value) : "*"));
+const isSearchMode = computed(() => (searchMode.value === "key" ? effectivePattern.value !== "*" : valueQuery.value !== ""));
+const useFlatKeySearchRows = computed(() => searchMode.value === "key" && isSearchMode.value);
+const searchPlaceholder = computed(() => {
+  if (searchMode.value === "key") return fuzzyKeySearch.value ? t("redis.fuzzyPattern") : t("redis.pattern");
+  return searchMode.value === "all" ? t("redis.allSearchPlaceholder") : t("redis.valueSearchPlaceholder");
+});
+const loadingEmptyText = computed(() => (isValueSearchMode.value && valueQuery.value ? t(searchMode.value === "all" ? "redis.searchingAll" : "redis.searchingValues") : t("redis.loadingKeys")));
+const redisKeySeparator = computed(() => connectionStore.getConfig(props.connectionId)?.redis_key_separator ?? ":");
+const redisScanPageSize = computed(() => connectionStore.getConfig(props.connectionId)?.redis_scan_page_size ?? REDIS_SCAN_PAGE_SIZE_DEFAULT);
+watch(redisKeySeparator, () => {
+  if (flatKeys.value.length > 0) rebuildTree(false);
+});
+const lastTotalKeys = ref(0);
+const fetchAllProgressText = computed(() => {
+  if (!isFetchingAll.value) return "";
+  if (lastTotalKeys.value > 0) {
+    return t("redis.fetchAllProgress", { loaded: flatKeys.value.length, total: lastTotalKeys.value });
+  }
+  return t("redis.fetchAllProgressUnknown", { loaded: flatKeys.value.length });
+});
+const keyCountText = computed(() => {
+  if (loading.value && flatKeys.value.length === 0) return loadingEmptyText.value;
+  if (!isSearchMode.value && lastTotalKeys.value > 0) {
+    return t("redis.loadedKeys", { loaded: flatKeys.value.length, total: lastTotalKeys.value });
+  }
+  return t("redis.keys", { count: flatKeys.value.length });
+});
+const selectedKey = computed(() => flatKeys.value.find((key) => key.key_raw === selectedKeyRaw.value) ?? null);
+const dangerDetails = computed(() => {
+  if (!pendingDanger.value) return "";
+  if (pendingDanger.value.kind === "delete-keys") {
+    return t("redis.deleteGroupDetails", {
+      target: pendingDanger.value.title,
+      count: pendingDanger.value.keyRaws.length,
+    });
+  }
+  return pendingDanger.value.command;
+});
+const dangerConfirmLabel = computed(() => {
+  if (pendingDanger.value?.kind === "command") return t("dangerDialog.confirm");
+  return t("dangerDialog.deleteConfirm");
+});
+const dangerMessage = computed(() => {
+  // Redis write commands such as SET/HSET are mutating but not necessarily delete operations.
+  if (pendingDanger.value?.kind === "command") return t("dangerDialog.redisCommandMessage");
+  return t("dangerDialog.deleteMessage");
+});
+const commandPrompt = computed(() => `db${commandDb.value}>`);
+const createKeyTypeOptions = computed<{ value: RedisCreateKeyType; label: string }[]>(() => [
+  { value: "string", label: "String" },
+  { value: "hash", label: "Hash" },
+  { value: "list", label: "List" },
+  { value: "set", label: "Set" },
+  { value: "zset", label: "Sorted Set" },
+  { value: "stream", label: "Stream" },
+  { value: "json", label: "JSON" },
+]);
+function createKeyTypeTooltip(type: RedisCreateKeyType): string | undefined {
+  const help = getRedisCreateKeyTypeHelp(type);
+  return help ? t(`redis.createKeyTypeHelp.${help.key}`) : undefined;
+}
+const activeCreateKeyTypeHelpContent = computed(() => (activeCreateKeyTypeHelp.value ? createKeyTypeTooltip(activeCreateKeyTypeHelp.value) : undefined));
+
+function activateCreateKeyTypeHelp(type: RedisCreateKeyType) {
+  activeCreateKeyTypeHelp.value = createKeyTypeTooltip(type) ? type : undefined;
+}
+
+function onCreateKeyTypeSelectOpen(open: boolean) {
+  if (open) {
+    activeCreateKeyTypeHelp.value = redisCreateKeyTypeHelpOptionOnOpen(createKeyType.value);
+    return;
+  }
+  activeCreateKeyTypeHelp.value = undefined;
+  createKeyTypeKeyboardNavigation.value = false;
+  createKeyTypeOpenedByArrow.value = false;
+}
+
+function onCreateKeyTypeTriggerKeydown(event: KeyboardEvent) {
+  if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
+  createKeyTypeOpenedByArrow.value = true;
+  createKeyTypeKeyboardNavigation.value = true;
+}
+
+function onCreateKeyTypeSelectKeydown(event: KeyboardEvent) {
+  if (event.key !== "ArrowDown" && event.key !== "ArrowUp") return;
+  createKeyTypeKeyboardNavigation.value = true;
+}
+
+function onCreateKeyTypeOptionFocus(type: RedisCreateKeyType) {
+  if (!shouldActivateRedisCreateKeyTypeHelpOnFocus({ openedByArrow: createKeyTypeOpenedByArrow.value, keyboardNavigating: createKeyTypeKeyboardNavigation.value })) return;
+  activateCreateKeyTypeHelp(type);
+  createKeyTypeOpenedByArrow.value = false;
+  createKeyTypeKeyboardNavigation.value = false;
+}
+
+async function updateCreateKeyTypeHelpOffset() {
+  if (!activeCreateKeyTypeHelp.value) {
+    createKeyTypeHelpOffsetTop.value = 0;
+    return;
+  }
+  await nextTick();
+  const card = createKeyTypeListCard.value;
+  const panel = createKeyTypeHelpPanel.value?.element;
+  const option = card?.querySelector<HTMLElement>(`[data-option-help-value="${activeCreateKeyTypeHelp.value}"]`);
+  if (!card || !panel || !option) {
+    createKeyTypeHelpOffsetTop.value = 0;
+    return;
+  }
+  createKeyTypeHelpOffsetTop.value = optionHelpPanelOffsetTop({
+    activeItemTop: option.getBoundingClientRect().top - card.getBoundingClientRect().top,
+    listCardHeight: card.clientHeight,
+    panelHeight: panel.clientHeight,
+  });
+}
+
+watch(activeCreateKeyTypeHelp, () => {
+  void updateCreateKeyTypeHelpOffset();
+});
+const visibleRows = computed(() => {
+  const rows = useFlatKeySearchRows.value ? flatKeys.value.map((key) => redisKeyToFlatTreeRow(key, props.db)) : flattenVisibleRedisKeyTree(treeKeys.value, expandedGroupIds.value);
+  return rows.map((row) => ({
+    ...row,
+    id: row.node.id,
+  }));
+});
+let commandHistoryId = 0;
+
+function countLeaves(node: RedisKeyTreeNode): number {
+  if (node.kind === "leaf") return 1;
+  return node.children.reduce((sum, child) => sum + countLeaves(child), 0);
+}
+
+function rebuildTree(expandAll = false) {
+  const nextTree = buildRedisKeyTree(flatKeys.value, props.db, redisKeySeparator.value);
+  treeKeys.value = nextTree;
+
+  const nextExpanded = new Set<string>();
+  const availableExpanded = collectExpandedGroupIds(nextTree);
+  if (expandAll) {
+    for (const id of availableExpanded) nextExpanded.add(id);
+  } else {
+    for (const id of expandedGroupIds.value) {
+      if (availableExpanded.has(id)) nextExpanded.add(id);
+    }
+  }
+  expandedGroupIds.value = nextExpanded;
+
+  if (selectedKeyRaw.value && !flatKeys.value.some((key) => key.key_raw === selectedKeyRaw.value)) {
+    selectedKeyRaw.value = null;
+  }
+}
+
+function mergeTree(newKeys: RedisKeyInfo[]) {
+  if (newKeys.length === 0) return;
+  treeKeys.value = mergeKeysIntoRedisKeyTree(treeKeys.value, newKeys, props.db, redisKeySeparator.value);
+
+  const availableExpanded = collectExpandedGroupIds(treeKeys.value);
+  const nextExpanded = new Set<string>();
+  for (const id of expandedGroupIds.value) {
+    if (availableExpanded.has(id)) nextExpanded.add(id);
+  }
+  expandedGroupIds.value = nextExpanded;
+
+  if (selectedKeyRaw.value && !flatKeys.value.some((key) => key.key_raw === selectedKeyRaw.value)) {
+    selectedKeyRaw.value = null;
+  }
+}
+
+async function fetchScanPage(requestId = searchRequestId): Promise<RedisScanResult> {
+  const pageSize = redisScanPageSize.value;
+  if (isValueSearchMode.value) {
+    return api.redisScanValues(props.connectionId, props.db, scanCursor.value, "*", valueQuery.value, pageSize, searchMode.value === "all");
+  }
+
+  // Keep each backend call small so a changed search can cancel between calls.
+  // The total COUNT budget bounds Redis work while giving sparse MATCH patterns
+  // substantially more coverage than a fixed number of SCAN calls.
+  const scanCountBudget = 50_000;
+  const iterationsPerCall = 8;
+  const maxIterations = Math.max(1, Math.ceil(scanCountBudget / Math.max(1, pageSize)));
+  let completedIterations = 0;
+  let cursor = scanCursor.value;
+  let totalKeys = 0;
+
+  while (completedIterations < maxIterations) {
+    if (requestId !== searchRequestId) {
+      return { cursor, keys: [], total_keys: totalKeys };
+    }
+    const iterations = Math.min(iterationsPerCall, maxIterations - completedIterations);
+    const result = await api.redisScanKeysBatch(props.connectionId, props.db, cursor, effectivePattern.value, pageSize, iterations, false);
+    if (totalKeys === 0) totalKeys = result.total_keys;
+    if (result.keys.length > 0 || result.cursor === 0) {
+      return { ...result, total_keys: totalKeys };
+    }
+    cursor = result.cursor;
+    completedIterations += iterations;
+  }
+
+  return { cursor, keys: [], total_keys: totalKeys };
+}
+
+/// Batch-scan variant that performs multiple SCAN iterations server-side.
+/// Dramatically reduces frontend↔backend roundtrips for bulk loading.
+async function fetchScanBatchPage(maxIterations: number, options: { count?: number; includeTypes?: boolean } = {}): Promise<RedisScanResult> {
+  const pageSize = options.count ?? redisScanPageSize.value;
+  // Value search cannot be batched because each key requires a GET.
+  if (isValueSearchMode.value) {
+    return api.redisScanValues(props.connectionId, props.db, scanCursor.value, "*", valueQuery.value, pageSize, searchMode.value === "all");
+  }
+  return api.redisScanKeysBatch(props.connectionId, props.db, scanCursor.value, effectivePattern.value, pageSize, maxIterations, options.includeTypes ?? false);
+}
+
+function appendScanResult(result: RedisScanResult, options: { updateTree?: boolean } = {}) {
+  const newKeys: RedisKeyInfo[] = [];
+  for (const key of result.keys) {
+    if (loadedKeyRaws.has(key.key_raw)) continue;
+    loadedKeyRaws.add(key.key_raw);
+    newKeys.push(key);
+  }
+  if (newKeys.length > 0) {
+    flatKeys.value = [...flatKeys.value, ...newKeys];
+  }
+  scanCursor.value = result.cursor;
+  hasMore.value = result.cursor !== 0;
+  // DBSIZE is only called on the first batch page (cursor==0); subsequent
+  // pages return total_keys=0. Preserve the previously-fetched total when
+  // we get a zero from a continuation. A truly empty DB returns cursor==0
+  // and keys==[] along with total_keys==0, which we do record.
+  if (result.total_keys > 0 || (result.cursor === 0 && result.keys.length === 0)) {
+    lastTotalKeys.value = result.total_keys;
+  }
+
+  if (options.updateTree ?? true) {
+    if (useFlatKeySearchRows.value) {
+      treeKeys.value = [];
+      expandedGroupIds.value = new Set();
+    } else if (treeKeys.value.length === 0) {
+      rebuildTree(isSearchMode.value);
+    } else {
+      mergeTree(newKeys);
+    }
+  }
+
+  connectionStore.updateRedisDbKeyStats(props.connectionId, props.db, {
+    loaded: isSearchMode.value ? undefined : flatKeys.value.length,
+    total: result.total_keys > 0 || (result.cursor === 0 && result.keys.length === 0) ? result.total_keys : undefined,
+  });
+}
+
+async function scanNextPage(requestId = searchRequestId): Promise<boolean> {
+  const result = await fetchScanPage(requestId);
+  if (requestId !== searchRequestId) return false;
+  appendScanResult(result);
+  return true;
+}
+
+async function streamValueSearch(requestId: number) {
+  while (requestId === searchRequestId && isValueSearchMode.value && valueQuery.value && hasMore.value) {
+    const applied = await scanNextPage(requestId);
+    if (!applied) return;
+  }
+}
+
+async function loadKeys() {
+  if (!redisBrowserIsActive) return;
+  const requestId = ++searchRequestId;
+  isFetchingAll.value = false;
+  loading.value = true;
+  loadedKeyRaws.clear();
+  flatKeys.value = [];
+  treeKeys.value = [];
+  selectedKeyRaw.value = null;
+  checkedKeys.value = new Set();
+  expandedGroupIds.value = new Set();
+  scanCursor.value = 0;
+  lastTotalKeys.value = 0;
+  try {
+    if (isValueSearchMode.value && !valueQuery.value) {
+      hasMore.value = false;
+      return;
+    }
+    const applied = await scanNextPage(requestId);
+    if (applied && isValueSearchMode.value) {
+      await streamValueSearch(requestId);
+    }
+  } finally {
+    if (requestId === searchRequestId) {
+      loading.value = false;
+    }
+  }
+}
+
+async function loadMore() {
+  if (!hasMore.value || loadingMore.value) return;
+  const requestId = searchRequestId;
+  loadingMore.value = true;
+  try {
+    await scanNextPage(requestId);
+  } finally {
+    loadingMore.value = false;
+  }
+}
+
+// Fetch-all uses large key-only SCAN pages and rebuilds the tree once at the
+// end; per-page tree sorting dominates runtime on million-key pattern scans.
+const FETCH_ALL_SCAN_COUNT = 50000;
+const FETCH_ALL_BATCH_ITERATIONS = 1;
+
+async function fetchAll() {
+  if (!hasMore.value || isFetchingAll.value) return;
+  const requestId = searchRequestId;
+  isFetchingAll.value = true;
+  let changed = false;
+  try {
+    while (requestId === searchRequestId && isFetchingAll.value && hasMore.value) {
+      const result = await fetchScanBatchPage(FETCH_ALL_BATCH_ITERATIONS, {
+        count: FETCH_ALL_SCAN_COUNT,
+        includeTypes: false,
+      });
+      if (requestId !== searchRequestId) break;
+      appendScanResult(result, { updateTree: false });
+      changed = true;
+    }
+  } finally {
+    if (requestId === searchRequestId) {
+      if (changed && !useFlatKeySearchRows.value) rebuildTree(isSearchMode.value);
+      isFetchingAll.value = false;
+    }
+  }
+}
+
+function stopFetchAll() {
+  isFetchingAll.value = false;
+}
+
+function toggleGroup(groupId: string) {
+  const next = new Set(expandedGroupIds.value);
+  if (next.has(groupId)) next.delete(groupId);
+  else next.add(groupId);
+  expandedGroupIds.value = next;
+}
+
+function onRowClick(node: RedisKeyTreeNode) {
+  if (node.kind === "group") {
+    toggleGroup(node.id);
+    return;
+  }
+
+  selectedKeyRaw.value = node.keyRaw;
+  activeSidePanel.value = "detail";
+}
+
+function onKeyDeleted() {
+  if (!selectedKeyRaw.value) return;
+  loadedKeyRaws.delete(selectedKeyRaw.value);
+  flatKeys.value = flatKeys.value.filter((key) => key.key_raw !== selectedKeyRaw.value);
+  selectedKeyRaw.value = null;
+  rebuildTree(false);
+  connectionStore.updateRedisDbKeyStats(props.connectionId, props.db, {
+    loaded: isSearchMode.value ? undefined : flatKeys.value.length,
+    totalDelta: -1,
+  });
+}
+
+function redisValueToKeyInfo(value: RedisValue): RedisKeyInfo {
+  return {
+    key_display: value.key_display,
+    key_raw: value.key_raw,
+    key_type: value.redis_type,
+    ttl: value.ttl,
+    size: redisValueSize(value),
+    value_preview: redisValuePreview(value),
+  };
+}
+
+function onKeyLoaded(value: RedisValue) {
+  const keyInfo = redisValueToKeyInfo(value);
+  const existingIndex = flatKeys.value.findIndex((key) => key.key_raw === keyInfo.key_raw);
+  if (existingIndex < 0) return;
+  flatKeys.value = flatKeys.value.map((key, index) => (index === existingIndex ? keyInfo : key));
+  loadedKeyRaws.add(keyInfo.key_raw);
+  rebuildTree(false);
+}
+
+function toggleCheck(keyRaw: string, event: Event) {
+  event.stopPropagation();
+  const next = new Set(checkedKeys.value);
+  if (next.has(keyRaw)) next.delete(keyRaw);
+  else next.add(keyRaw);
+  checkedKeys.value = next;
+}
+
+function requestBatchDelete() {
+  if (checkedKeys.value.size === 0) return;
+  pendingDanger.value = { kind: "delete-keys", title: t("redis.selectedKeys"), keyRaws: [...checkedKeys.value] };
+  showDangerConfirm.value = true;
+}
+
+function requestGroupDelete(node: RedisKeyTreeNode, event: Event) {
+  event.stopPropagation();
+  if (node.kind !== "group") return;
+  const keyRaws = collectRedisGroupKeyRaws(node);
+  if (keyRaws.length === 0) return;
+  pendingDanger.value = { kind: "delete-keys", title: node.pathSegments.join(":"), keyRaws };
+  showDangerConfirm.value = true;
+}
+
+async function copyRedisKeyName(keyName: string) {
+  try {
+    await copyToClipboard(keyName);
+    toast(t("redis.copied"), 2000);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function redisKeyContextMenuItems(node: RedisKeyTreeNode): ContextMenuItem[] {
+  const copyText = redisKeyNameCopyText(node);
+  if (copyText === null) return [];
+  return [
+    {
+      label: t("redis.copyKeyName"),
+      icon: Copy,
+      action: () => copyRedisKeyName(copyText),
+    },
+  ];
+}
+
+function onRedisRowContextMenu(event: MouseEvent, node: RedisKeyTreeNode, openContextMenu: (event: MouseEvent) => void) {
+  if (node.kind !== "leaf") return;
+  selectedKeyRaw.value = node.keyRaw;
+  openContextMenu(event);
+}
+
+function resetLoadedKeys() {
+  loadedKeyRaws.clear();
+  flatKeys.value = [];
+  treeKeys.value = [];
+  selectedKeyRaw.value = null;
+  checkedKeys.value = new Set();
+  expandedGroupIds.value = new Set();
+  hasMore.value = false;
+  lastTotalKeys.value = 0;
+}
+
+async function deleteKeyRaws(keys: string[]) {
+  const deletedCount = await api.redisDeleteKeys(props.connectionId, props.db, keys);
+  const deleted = new Set(keys);
+  for (const key of deleted) loadedKeyRaws.delete(key);
+  flatKeys.value = flatKeys.value.filter((k) => !deleted.has(k.key_raw));
+  if (selectedKeyRaw.value && deleted.has(selectedKeyRaw.value)) {
+    selectedKeyRaw.value = null;
+  }
+  checkedKeys.value = new Set();
+  rebuildTree(false);
+  connectionStore.updateRedisDbKeyStats(props.connectionId, props.db, {
+    loaded: isSearchMode.value ? undefined : flatKeys.value.length,
+    totalDelta: -deletedCount,
+  });
+}
+
+function scrollCommandTerminalToEnd() {
+  void nextTick(() => {
+    if (!commandTerminalRef.value) return;
+    commandTerminalRef.value.scrollTop = commandTerminalRef.value.scrollHeight;
+  });
+}
+
+function appendCommandHistory(entry: Omit<RedisCommandHistoryEntry, "id">) {
+  commandHistory.value = [...commandHistory.value, { id: ++commandHistoryId, ...entry }];
+  scrollCommandTerminalToEnd();
+}
+
+function appendCommandOutput(entry: Omit<RedisCommandHistoryEntry, "id">) {
+  // 显示输出但不记入历史（用于错误提示、空命令提示等）
+  const tempEntry = { id: ++commandHistoryId, ...entry };
+  commandHistory.value = [...commandHistory.value, tempEntry];
+  scrollCommandTerminalToEnd();
+  // 1秒后自动移除提示
+  setTimeout(() => {
+    commandHistory.value = commandHistory.value.filter((e) => e.id !== tempEntry.id);
+  }, 1000);
+}
+
+async function runRedisCommand(command: string) {
+  const prompt = commandPrompt.value;
+  commandRunning.value = true;
+  try {
+    const result = await api.redisExecuteCommand(props.connectionId, commandDb.value, command, !props.blockDangerousRedisCommands);
+    appendCommandHistory({
+      prompt,
+      command,
+      output: formatRedisConsoleValue(result.value),
+      error: false,
+    });
+    // The db this command ran on — capture before nextRedisCommandDb() advances it.
+    const executedDb = commandDb.value;
+    commandDb.value = nextRedisCommandDb(commandDb.value, command, result.value);
+    // Drop the cached key-name completion for this db so the editor's autocomplete
+    // reflects keys added/removed/renamed by SET/DEL/RENAME/...
+    const mutatesKeys = isRedisMutatingCommand(command);
+    if (mutatesKeys) {
+      await loadKeys();
+      connectionStore.invalidateCompletionCache(props.connectionId, String(executedDb));
+      // Refresh the sidebar db key counts (INFO keyspace) so `dbN (count)` stays accurate
+      // after the write. Fire-and-forget so the terminal stays responsive.
+      void connectionStore.refreshRedisDbKeyCounts(props.connectionId);
+    }
+    // Persist to history
+    persistRedisHistory(command, true, result.value);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    appendCommandHistory({
+      prompt,
+      command,
+      output: errorMessage,
+      error: true,
+    });
+    // Persist failed command too
+    persistRedisHistory(command, false, null, errorMessage);
+  } finally {
+    commandRunning.value = false;
+    scrollCommandTerminalToEnd();
+  }
+}
+
+function persistRedisHistory(command: string, success: boolean, resultValue?: unknown, errorMessage?: string) {
+  const connName = connectionStore.getConfig(props.connectionId)?.name || "";
+  const entry: HistoryEntry = {
+    id: uuid(),
+    connection_id: props.connectionId,
+    connection_name: connName,
+    database: String(commandDb.value),
+    sql: command,
+    executed_at: new Date().toISOString(),
+    execution_time_ms: 0,
+    success,
+    error: errorMessage,
+    activity_kind: "redis_command",
+    operation: command.split(" ")[0].toUpperCase(),
+    target: "",
+    affected_rows: null,
+    rollback_sql: null,
+    details_json: resultValue != null ? JSON.stringify(resultValue) : null,
+  };
+  void api.saveHistory(entry);
+}
+
+async function openCommandPanel() {
+  activeSidePanel.value = "command";
+  await nextTick();
+  getCommandInput()?.focus();
+}
+
+function makeEntry(): CreateKeyEntry {
+  return { id: nextEntryId++, value: "", field: "", score: "0" };
+}
+
+function resetEntries() {
+  createKeyEntries.value = [makeEntry()];
+}
+
+function addEntry() {
+  createKeyEntries.value.push(makeEntry());
+}
+
+function removeEntry(idx: number) {
+  if (createKeyEntries.value.length > 1) {
+    createKeyEntries.value.splice(idx, 1);
+  }
+}
+
+function resetCreateKeyForm() {
+  createKeyName.value = "";
+  createKeyType.value = "string";
+  createKeyValue.value = "";
+  createKeyField.value = "";
+  createKeyScore.value = "0";
+  createKeyError.value = "";
+  createKeyTtl.value = "";
+  createKeyRawMode.value = false;
+  createKeyEntryId.value = "*";
+  jsonModuleAvailable.value = null;
+  checkingJsonModule.value = false;
+  activeCreateKeyTypeHelp.value = undefined;
+  createKeyTypeKeyboardNavigation.value = false;
+  createKeyTypeOpenedByArrow.value = false;
+  resetEntries();
+}
+
+function onCreateKeyTypeChange(type: any) {
+  createKeyType.value = (type || "string") as RedisCreateKeyType;
+  createKeyRawMode.value = false;
+  jsonModuleAvailable.value = null;
+  checkingJsonModule.value = false;
+  activeCreateKeyTypeHelp.value = undefined;
+  createKeyTypeKeyboardNavigation.value = false;
+  createKeyTypeOpenedByArrow.value = false;
+  resetEntries();
+  if (createKeyType.value === "json") {
+    createKeyError.value = "";
+    checkingJsonModule.value = true;
+    api
+      .redisCheckJsonModule(props.connectionId, props.db)
+      .then((ok) => {
+        jsonModuleAvailable.value = ok;
+        if (!ok) {
+          createKeyError.value = t("redis.jsonModuleNotAvailable");
+        }
+      })
+      .catch(() => {
+        jsonModuleAvailable.value = false;
+        createKeyError.value = t("redis.jsonModuleNotAvailable");
+      })
+      .finally(() => {
+        checkingJsonModule.value = false;
+      });
+  } else {
+    createKeyError.value = "";
+  }
+}
+
+function openCreateKeyDialog() {
+  resetCreateKeyForm();
+  showCreateKeyDialog.value = true;
+}
+
+function upsertCreatedKey(value: RedisValue) {
+  const keyInfo: RedisKeyInfo = {
+    key_display: value.key_display,
+    key_raw: value.key_raw,
+    key_type: value.redis_type,
+    ttl: value.ttl,
+    size: redisValueSize(value),
+    value_preview: redisValuePreview(value),
+  };
+  const existingIndex = flatKeys.value.findIndex((key) => key.key_raw === keyInfo.key_raw);
+  if (existingIndex >= 0) {
+    flatKeys.value = flatKeys.value.map((key, index) => (index === existingIndex ? keyInfo : key));
+  } else {
+    flatKeys.value = [keyInfo, ...flatKeys.value];
+  }
+  loadedKeyRaws.add(keyInfo.key_raw);
+  selectedKeyRaw.value = keyInfo.key_raw;
+  rebuildTree(isSearchMode.value);
+  connectionStore.updateRedisDbKeyStats(props.connectionId, props.db, {
+    loaded: isSearchMode.value ? undefined : flatKeys.value.length,
+    totalDelta: existingIndex >= 0 ? 0 : 1,
+  });
+}
+
+async function createRedisKey() {
+  const keyName = createKeyName.value.trim();
+  if (!keyName) {
+    createKeyError.value = t("redis.createKeyNameRequired");
+    toast(t("redis.createKeyNameRequired"), 3000);
+    return;
+  }
+
+  creatingKey.value = true;
+  createKeyError.value = "";
+  try {
+    const keyRaw = redisKeyTextToRaw(keyName);
+    const ttl = createKeyTtl.value ? Number.parseInt(createKeyTtl.value) || undefined : undefined;
+
+    if (createKeyType.value === "string" || createKeyType.value === "json" || createKeyRawMode.value) {
+      // Raw text/JSON mode — single value
+      if (createKeyType.value === "string") {
+        await api.redisSetString(props.connectionId, props.db, keyRaw, createKeyValue.value, ttl);
+      } else if (createKeyType.value === "json") {
+        await api.redisJsonSet(props.connectionId, props.db, keyRaw, createKeyValue.value, ttl);
+      } else if (createKeyType.value === "hash") {
+        await api.redisHashSet(props.connectionId, props.db, keyRaw, createKeyField.value, createKeyValue.value, ttl);
+      } else if (createKeyType.value === "list") {
+        await api.redisListPush(props.connectionId, props.db, keyRaw, createKeyValue.value, ttl);
+      } else if (createKeyType.value === "set") {
+        await api.redisSetAdd(props.connectionId, props.db, keyRaw, createKeyValue.value, ttl);
+      } else if (createKeyType.value === "zset") {
+        const score = Number.parseFloat(createKeyScore.value || "0");
+        await api.redisZadd(props.connectionId, props.db, keyRaw, createKeyValue.value, score, ttl);
+      }
+    } else {
+      // Structured entries mode — insert each entry, then set TTL once
+      if (createKeyType.value === "hash") {
+        for (const entry of createKeyEntries.value) {
+          if (entry.field && entry.field.trim()) {
+            await api.redisHashSet(props.connectionId, props.db, keyRaw, entry.field, entry.value);
+          }
+        }
+      } else if (createKeyType.value === "list") {
+        for (const entry of createKeyEntries.value) {
+          if (entry.value) {
+            await api.redisListPush(props.connectionId, props.db, keyRaw, entry.value);
+          }
+        }
+      } else if (createKeyType.value === "set") {
+        for (const entry of createKeyEntries.value) {
+          if (entry.value) {
+            await api.redisSetAdd(props.connectionId, props.db, keyRaw, entry.value);
+          }
+        }
+      } else if (createKeyType.value === "zset") {
+        for (const entry of createKeyEntries.value) {
+          if (entry.value) {
+            const s = Number.parseFloat(entry.score || "0");
+            if (!Number.isNaN(s)) {
+              await api.redisZadd(props.connectionId, props.db, keyRaw, entry.value, s);
+            }
+          }
+        }
+      } else if (createKeyType.value === "stream") {
+        const fields: [string, string][] = createKeyEntries.value.filter((e) => e.field && e.field.trim()).map((e) => [e.field!.trim(), e.value]);
+        if (fields.length > 0) {
+          const entryId = createKeyEntryId.value.trim() || "*";
+          await api.redisStreamAdd(props.connectionId, props.db, keyRaw, entryId, fields, ttl);
+        }
+      }
+      if (ttl) {
+        await api.redisSetTtl(props.connectionId, props.db, keyRaw, ttl);
+      }
+    }
+
+    const created = await api.redisGetValue(props.connectionId, props.db, keyRaw);
+    upsertCreatedKey(created);
+    showCreateKeyDialog.value = false;
+  } catch (error) {
+    createKeyError.value = error instanceof Error ? error.message : String(error);
+  } finally {
+    creatingKey.value = false;
+  }
+}
+
+async function executeCommand() {
+  const command = commandText.value.trim();
+  if (!command) {
+    // 空命令显示提示但不记入历史
+    appendCommandOutput({
+      prompt: commandPrompt.value,
+      command: "",
+      output: t("redis.commandEmpty"),
+      error: true,
+    });
+    return;
+  }
+  if (isRedisClearScreenCommand(command)) {
+    commandHistory.value = [];
+    commandText.value = "";
+    commandHistoryIndex.value = -1;
+    scrollCommandTerminalToEnd();
+    return;
+  }
+
+  const safety = classifyRedisCommandSafety(command);
+  if (safety === "blocked") {
+    if (!props.blockDangerousRedisCommands) {
+      // 安全模式已关闭，放行 blocked 命令
+      commandText.value = "";
+      commandHistoryIndex.value = -1;
+      await runRedisCommand(command);
+      return;
+    }
+    appendCommandHistory({
+      prompt: commandPrompt.value,
+      command,
+      output: t("redis.commandBlocked"),
+      error: true,
+    });
+    commandText.value = "";
+    commandHistoryIndex.value = -1;
+    return;
+  }
+  if (safety === "confirm") {
+    if (!props.blockDangerousRedisCommands) {
+      // 安全模式已关闭，跳过确认弹窗直接执行
+      commandText.value = "";
+      commandHistoryIndex.value = -1;
+      await runRedisCommand(command);
+      return;
+    }
+    pendingDanger.value = { kind: "command", command };
+    showDangerConfirm.value = true;
+    commandText.value = "";
+    commandHistoryIndex.value = -1;
+    return;
+  }
+  commandText.value = "";
+  commandHistoryIndex.value = -1;
+  await runRedisCommand(command);
+}
+
+async function applyDangerAction() {
+  const pending = pendingDanger.value;
+  pendingDanger.value = null;
+  showDangerConfirm.value = false;
+  if (!pending) return;
+
+  if (pending.kind === "delete-keys") {
+    await deleteKeyRaws(pending.keyRaws);
+  } else {
+    await runRedisCommand(pending.command);
+  }
+}
+
+function typeColor(type: string): string {
+  switch (type) {
+    case "string":
+      return "text-green-500";
+    case "list":
+      return "text-blue-500";
+    case "set":
+      return "text-purple-500";
+    case "zset":
+      return "text-amber-500";
+    case "hash":
+      return "text-orange-500";
+    case "stream":
+      return "text-teal-500";
+    default:
+      return "text-muted-foreground";
+  }
+}
+
+let searchTimer: ReturnType<typeof setTimeout> | null = null;
+let hasAutoFocusedSearch = false;
+
+function onSearchInput() {
+  if (searchTimer) clearTimeout(searchTimer);
+  searchTimer = setTimeout(loadKeys, 400);
+}
+
+function setSearchMode(mode: RedisSearchMode) {
+  if (searchMode.value === mode) return;
+  searchMode.value = mode;
+  void loadKeys();
+}
+
+function toggleFuzzyKeySearch() {
+  fuzzyKeySearch.value = !fuzzyKeySearch.value;
+  if (searchMode.value === "key") void loadKeys();
+}
+
+function getSearchInput(): HTMLInputElement | null {
+  return rootRef.value?.querySelector<HTMLInputElement>("[data-redis-search-input]") ?? null;
+}
+
+async function autofocusSearchOnce() {
+  if (hasAutoFocusedSearch) return;
+  await nextTick();
+  const input = getSearchInput();
+  if (!input) return;
+  hasAutoFocusedSearch = true;
+  input.focus({ preventScroll: true });
+}
+
+function getCommandInput(): HTMLInputElement | null {
+  return rootRef.value?.querySelector<HTMLInputElement>("[data-redis-command-input]") ?? null;
+}
+
+function focusSearch(): boolean {
+  const input = getSearchInput();
+  if (!input) return false;
+  input.focus();
+  input.select();
+  return true;
+}
+
+function onSearchKeydown(event: KeyboardEvent) {
+  if (event.key === "Enter") {
+    void loadKeys();
+    return;
+  }
+  if (!isCancelSearchShortcut(event)) return;
+  event.preventDefault();
+  searchPattern.value = "";
+  void loadKeys();
+}
+
+function onRedisDbFlushed(event: Event) {
+  const detail = (event as CustomEvent<{ connectionId: string; db: number }>).detail;
+  if (!detail || detail.connectionId !== props.connectionId || detail.db !== props.db) return;
+  resetLoadedKeys();
+}
+
+function registerRedisDbFlushedListener() {
+  if (redisDbFlushedListenerRegistered) return;
+  window.addEventListener("dbx-redis-db-flushed", onRedisDbFlushed);
+  redisDbFlushedListenerRegistered = true;
+}
+
+function unregisterRedisDbFlushedListener() {
+  if (!redisDbFlushedListenerRegistered) return;
+  window.removeEventListener("dbx-redis-db-flushed", onRedisDbFlushed);
+  redisDbFlushedListenerRegistered = false;
+}
+
+function pauseRedisBrowserBackgroundWork() {
+  redisBrowserIsActive = false;
+  searchRequestId++;
+  isFetchingAll.value = false;
+  loading.value = false;
+  loadingMore.value = false;
+  if (searchTimer) clearTimeout(searchTimer);
+  searchTimer = null;
+  unregisterRedisDbFlushedListener();
+}
+
+function resumeRedisBrowserBackgroundWork() {
+  redisBrowserIsActive = true;
+  registerRedisDbFlushedListener();
+}
+
+async function clearInMemoryHistory() {
+  commandHistory.value = [];
+}
+
+function onCommandAreaClick() {
+  // 只有在没有选中文本时才聚焦输入框，避免清除用户的文本选择
+  const selection = window.getSelection();
+  if (!selection || selection.toString().length === 0) {
+    getCommandInput()?.focus();
+  }
+}
+
+function onCommandInputKeydown(event: KeyboardEvent) {
+  // 上下键切换历史命令
+  if (event.key === "ArrowUp") {
+    event.preventDefault();
+    if (commandHistory.value.length === 0) return;
+
+    if (commandHistoryIndex.value === -1) {
+      // 首次按上键，从最后一条开始
+      commandHistoryIndex.value = commandHistory.value.length - 1;
+    } else if (commandHistoryIndex.value > 0) {
+      // 继续往前
+      commandHistoryIndex.value--;
+    }
+    commandText.value = commandHistory.value[commandHistoryIndex.value].command;
+  } else if (event.key === "ArrowDown") {
+    event.preventDefault();
+    if (commandHistoryIndex.value === -1) return;
+
+    if (commandHistoryIndex.value < commandHistory.value.length - 1) {
+      // 往后
+      commandHistoryIndex.value++;
+      commandText.value = commandHistory.value[commandHistoryIndex.value].command;
+    } else {
+      // 到达末尾，清空输入
+      commandHistoryIndex.value = -1;
+      commandText.value = "";
+    }
+  } else if (event.key === "Enter") {
+    event.preventDefault();
+    executeCommand();
+  }
+}
+
+onMounted(async () => {
+  resumeRedisBrowserBackgroundWork();
+  void autofocusSearchOnce();
+  try {
+    await connectionStore.ensureConnected(props.connectionId);
+  } catch (e) {
+    console.warn("[DBX] ensureConnected failed for", props.connectionId, e);
+  }
+  void loadKeys();
+});
+
+onActivated(async () => {
+  resumeRedisBrowserBackgroundWork();
+  void autofocusSearchOnce();
+  // Ensure the connection is still alive after reactivation (e.g. tab switch).
+  // If keys failed to load previously (empty list), retry loading.
+  try {
+    await connectionStore.ensureConnected(props.connectionId);
+  } catch (e) {
+    console.warn("[DBX] ensureConnected failed for", props.connectionId, e);
+  }
+  if (flatKeys.value.length === 0 && !loading.value) {
+    void loadKeys();
+  }
+});
+
+onDeactivated(pauseRedisBrowserBackgroundWork);
+
+onUnmounted(pauseRedisBrowserBackgroundWork);
+
+watch(
+  () => props.db,
+  (db) => {
+    commandDb.value = db;
+  },
+);
+
+defineExpose({ focusSearch });
+</script>
+
+<template>
+  <div ref="rootRef" class="h-full" :style="editorFontFamilyStyle">
+    <Splitpanes class="redis-workspace-splitpanes h-full">
+      <!-- Key tree (left) -->
+      <Pane :size="36" :min-size="24">
+        <div class="relative h-full flex flex-col overflow-hidden">
+          <!-- Toolbar -->
+          <div class="border-b px-2 py-2 shrink-0">
+            <div class="flex flex-wrap items-start gap-1.5">
+              <div class="flex min-w-0 flex-1 flex-wrap rounded-md border bg-muted/30 p-0.5" role="group">
+                <button type="button" class="h-5 px-2 text-xs rounded-sm transition-colors" :class="searchMode === 'key' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'" @click="setSearchMode('key')">
+                  {{ t("redis.searchByKey") }}
+                </button>
+                <button type="button" class="h-5 px-2 text-xs rounded-sm transition-colors" :class="searchMode === 'value' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'" @click="setSearchMode('value')">
+                  {{ t("redis.searchByValue") }}
+                </button>
+                <button type="button" class="h-5 px-2 text-xs rounded-sm transition-colors" :class="searchMode === 'all' ? 'bg-background text-foreground shadow-sm' : 'text-muted-foreground hover:text-foreground'" @click="setSearchMode('all')">
+                  {{ t("redis.searchByAll") }}
+                </button>
+              </div>
+              <div class="ml-auto flex min-w-0 flex-wrap items-center justify-end gap-1">
+                <span class="min-w-0 max-w-full truncate text-xs text-muted-foreground" :title="keyCountText">{{ keyCountText }}</span>
+                <Button v-if="checkedKeys.size > 0" variant="ghost" size="sm" class="h-6 shrink-0 text-xs text-destructive" @click="requestBatchDelete"> <Trash2 class="w-3 h-3 mr-1" />{{ checkedKeys.size }} </Button>
+                <Button variant="ghost" size="icon" class="h-6 w-6 shrink-0" @click="loadKeys">
+                  <Loader2 v-if="loading" class="h-3 w-3 animate-spin" />
+                  <RefreshCw v-else class="h-3 w-3" />
+                </Button>
+                <Button variant="ghost" size="icon" class="h-6 w-6 shrink-0" :title="t('redis.createKey')" @click="openCreateKeyDialog">
+                  <Plus class="h-3 w-3" />
+                </Button>
+              </div>
+            </div>
+            <div class="mt-2 flex min-w-0 flex-wrap items-center gap-1.5">
+              <div class="relative min-w-[120px] flex-1 basis-[180px]">
+                <Search class="pointer-events-none absolute left-2.5 top-1/2 h-3.5 w-3.5 -translate-y-1/2 text-muted-foreground/80" />
+                <Input
+                  v-model="searchPattern"
+                  data-redis-search-input
+                  class="h-8 border-border/70 bg-background pl-8 pr-3 text-xs shadow-sm caret-primary placeholder:text-muted-foreground/80 focus-visible:border-primary/60 focus-visible:ring-2 focus-visible:ring-primary/20"
+                  :placeholder="searchPlaceholder"
+                  @input="onSearchInput"
+                  @keydown="onSearchKeydown"
+                />
+              </div>
+              <Button
+                v-if="searchMode === 'key'"
+                variant="ghost"
+                size="sm"
+                class="h-8 max-w-full shrink-0 px-2 text-xs"
+                :class="fuzzyKeySearch ? 'bg-accent text-accent-foreground' : 'border border-dashed border-border/70 text-muted-foreground hover:text-foreground'"
+                :title="t('redis.fuzzyMatchTitle')"
+                :aria-pressed="fuzzyKeySearch"
+                @click="toggleFuzzyKeySearch"
+              >
+                <Asterisk class="h-3 w-3 mr-1" />
+                {{ t("redis.fuzzyMatch") }}
+              </Button>
+            </div>
+          </div>
+
+          <div v-if="flatKeys.length === 0 && !loading" class="flex-1 flex flex-col items-center justify-center text-muted-foreground text-xs p-4 text-center">
+            <template v-if="hasMore">
+              <span class="mb-3">{{ t("redis.noKeysInScanHint") }}</span>
+              <Button variant="outline" size="sm" class="h-7 text-xs" :disabled="loadingMore" @click="loadMore">
+                <Loader2 v-if="loadingMore" class="w-3 h-3 mr-1.5 animate-spin" />
+                {{ t("redis.loadMoreKeys") }}
+              </Button>
+            </template>
+            <template v-else>
+              {{ t("redis.noKeys") }}
+            </template>
+          </div>
+          <div v-else-if="loading && flatKeys.length === 0" class="flex-1 flex items-center justify-center gap-2 text-muted-foreground text-xs">
+            <Loader2 class="w-3.5 h-3.5 animate-spin" />
+            <span>{{ loadingEmptyText }}</span>
+          </div>
+          <RecycleScroller v-else class="redis-key-scroller flex-1" :items="visibleRows" :item-size="30" :buffer="600" :skip-hover="true" key-field="id">
+            <template #default="{ item: row }">
+              <CustomContextMenu :items="redisKeyContextMenuItems(row.node)" v-slot="{ onContextMenu }">
+                <div
+                  class="flex items-center gap-2 border-b px-3 text-[13px] cursor-pointer hover:bg-accent/50 group"
+                  :class="{ 'bg-accent': row.node.kind === 'leaf' && selectedKeyRaw === row.node.keyRaw }"
+                  :style="{ height: '30px' }"
+                  @click="onRowClick(row.node)"
+                  @contextmenu="(event) => onRedisRowContextMenu(event, row.node, onContextMenu)"
+                >
+                  <div class="min-w-0 flex flex-1 items-center gap-1 overflow-hidden" :style="{ paddingLeft: `${12 + row.depth * 16}px` }">
+                    <template v-if="row.node.kind === 'group'">
+                      <component :is="expandedGroupIds.has(row.node.id) ? ChevronDown : ChevronRight" class="w-3 h-3 shrink-0 text-muted-foreground" />
+                      <component :is="expandedGroupIds.has(row.node.id) ? FolderOpen : FolderClosed" class="w-3 h-3 shrink-0 text-amber-500" />
+                      <span class="dbx-editor-font-family truncate">{{ row.node.label }}</span>
+                      <span class="text-muted-foreground ml-1">({{ countLeaves(row.node) }})</span>
+                    </template>
+                    <template v-else>
+                      <span class="relative flex h-4 w-4 shrink-0 items-center justify-center">
+                        <KeyRound class="h-3.5 w-3.5 text-muted-foreground/70 transition-opacity group-hover:opacity-0" :class="{ 'opacity-0': checkedKeys.has(row.node.keyRaw) }" />
+                        <input type="checkbox" class="absolute h-3.5 w-3.5 accent-primary cursor-pointer opacity-0 group-hover:opacity-100" :class="{ 'opacity-100': checkedKeys.has(row.node.keyRaw) }" :checked="checkedKeys.has(row.node.keyRaw)" @click="toggleCheck(row.node.keyRaw, $event)" />
+                      </span>
+                      <span class="dbx-editor-font-family truncate">{{ row.node.label }}</span>
+                    </template>
+                  </div>
+
+                  <div class="flex shrink-0 items-center justify-end gap-1">
+                    <Badge v-if="row.node.kind === 'leaf' && row.node.keyType" variant="outline" class="text-xs px-1.5 py-0" :class="typeColor(row.node.keyType)">{{ row.node.keyType }}</Badge>
+                    <Button v-if="row.node.kind === 'group'" variant="ghost" size="icon" class="h-5 w-5 shrink-0 text-destructive opacity-0 group-hover:opacity-100" :title="t('redis.deleteGroup')" @click="requestGroupDelete(row.node, $event)">
+                      <Trash2 class="h-3 w-3" />
+                    </Button>
+                  </div>
+                </div>
+              </CustomContextMenu>
+            </template>
+          </RecycleScroller>
+          <div v-if="hasMore && !isFetchingAll" class="shrink-0 border-t px-2 py-1.5 flex items-center gap-1.5">
+            <Button variant="outline" size="sm" class="h-7 text-xs flex-1" :disabled="loadingMore || loading" @click="loadMore">
+              <Loader2 v-if="loadingMore" class="w-3 h-3 mr-1.5 animate-spin" />
+              {{ t("redis.loadMoreKeys") }}
+            </Button>
+            <Button variant="outline" size="sm" class="h-7 text-xs flex-1" :disabled="loading || !hasMore" @click="fetchAll">
+              {{ t("redis.fetchAllKeys") }}
+            </Button>
+          </div>
+          <div v-if="isFetchingAll" class="shrink-0 border-t px-2 py-1.5 space-y-1">
+            <div class="text-xs text-muted-foreground text-center">
+              {{ fetchAllProgressText }}
+            </div>
+            <Button variant="destructive" size="sm" class="h-7 text-xs w-full" @click="stopFetchAll">
+              {{ t("redis.stopFetchAll") }}
+            </Button>
+          </div>
+        </div>
+      </Pane>
+
+      <!-- Workspace (right) -->
+      <Pane :size="64" :min-size="36">
+        <div class="h-full min-w-0 bg-background flex flex-col overflow-hidden">
+          <Tabs v-model="activeSidePanel" :unmount-on-hide="false" class="h-full min-h-0 gap-0">
+            <div class="h-9 shrink-0 border-b bg-background px-3 flex items-center justify-between">
+              <TabsList class="h-7 gap-1 p-0.5">
+                <TabsTrigger value="detail" class="h-6 flex-none gap-1.5 rounded-md px-2 text-xs">
+                  <KeyRound class="size-3.5" />
+                  {{ t("redis.keyDetail") }}
+                </TabsTrigger>
+                <TabsTrigger value="command" class="h-6 flex-none gap-1.5 rounded-md px-2 text-xs" @click="openCommandPanel">
+                  <TerminalSquare class="size-3.5" />
+                  {{ t("redis.commandLine") }}
+                </TabsTrigger>
+                <TabsTrigger value="pubsub" class="h-6 flex-none gap-1.5 rounded-md px-2 text-xs">
+                  <Radio class="size-3.5" />
+                  {{ t("redis.pubsub") }}
+                </TabsTrigger>
+                <TabsTrigger value="slowlog" class="h-6 flex-none gap-1.5 rounded-md px-2 text-xs">
+                  <Clock class="size-3.5" />
+                  {{ t("redis.slowlog") }}
+                </TabsTrigger>
+              </TabsList>
+              <Button v-if="activeSidePanel === 'command'" variant="ghost" size="icon" class="h-6 w-6" :title="t('redis.clearHistory')" @click="clearInMemoryHistory">
+                <History class="size-3.5" />
+              </Button>
+            </div>
+
+            <TabsContent value="detail" class="m-0 min-h-0 flex-1 flex flex-col">
+              <RedisValueViewer v-if="selectedKey" :key="selectedKey.key_raw" :connection-id="connectionId" :db="db" :key-display="selectedKey.key_display" :key-raw="selectedKey.key_raw" :metadata="selectedKey" @deleted="onKeyDeleted" @loaded="onKeyLoaded" />
+              <div v-else class="flex-1 flex items-center justify-center text-xs text-muted-foreground">
+                {{ t("redis.selectKeyForDetail") }}
+              </div>
+            </TabsContent>
+
+            <TabsContent value="command" class="m-0 min-h-0 flex-1 flex flex-col">
+              <div class="dbx-editor-font-family relative flex min-h-0 flex-1 flex-col bg-[#171b21] text-[13px] leading-5 text-slate-200" @click="onCommandAreaClick">
+                <div ref="commandTerminalRef" class="redis-command-terminal min-h-0 flex-1 overflow-auto px-4 pb-3 pt-4">
+                  <div class="mb-4 text-slate-400">
+                    <span class="text-slate-200">{{ t("redis.commandWelcome") }}</span>
+                  </div>
+
+                  <div v-for="entry in commandHistory" :key="entry.id" class="mb-2">
+                    <div class="flex min-w-0 items-start gap-2 whitespace-pre-wrap break-words">
+                      <span class="shrink-0 text-[#d7ba7d]">{{ entry.prompt }}</span>
+                      <span class="min-w-0 text-slate-200">{{ entry.command }}</span>
+                    </div>
+                    <pre v-if="entry.output" class="ml-0 whitespace-pre-wrap break-words pl-0" :class="entry.error ? 'text-[#ff6b6b]' : 'text-slate-300'">{{ entry.output }}</pre>
+                  </div>
+                </div>
+
+                <form class="flex shrink-0 items-center gap-2 border-t border-white/10 bg-[#171b21] px-4 py-2" @submit.prevent="executeCommand">
+                  <span class="shrink-0 text-[#d7ba7d]">{{ commandPrompt }}</span>
+                  <input
+                    v-model="commandText"
+                    data-redis-command-input
+                    class="dbx-editor-font-family min-w-0 flex-1 border-0 bg-transparent p-0 text-[13px] text-slate-200 caret-[#d7ba7d] outline-none placeholder:text-slate-500"
+                    :class="{ 'opacity-50': commandRunning }"
+                    :readonly="commandRunning"
+                    autocomplete="off"
+                    autocapitalize="off"
+                    spellcheck="false"
+                    @keydown="onCommandInputKeydown"
+                  />
+                  <Loader2 v-if="commandRunning" class="h-3.5 w-3.5 shrink-0 animate-spin text-slate-500" />
+                </form>
+              </div>
+            </TabsContent>
+
+            <TabsContent value="pubsub" class="m-0 min-h-0 flex-1 flex flex-col">
+              <RedisPubSubPanel :connection-id="connectionId" :db="db" />
+            </TabsContent>
+
+            <TabsContent value="slowlog" class="m-0 min-h-0 flex-1 flex flex-col">
+              <RedisSlowlogPanel :connection-id="connectionId" :db="db" />
+            </TabsContent>
+          </Tabs>
+        </div>
+      </Pane>
+    </Splitpanes>
+
+    <DangerConfirmDialog v-model:open="showDangerConfirm" :message="dangerMessage" :details="dangerDetails" :confirm-label="dangerConfirmLabel" @confirm="applyDangerAction" />
+
+    <Dialog v-model:open="showCreateKeyDialog">
+      <DialogContent class="sm:max-w-md" :style="editorFontFamilyStyle">
+        <DialogHeader>
+          <DialogTitle>{{ t("redis.createKey") }}</DialogTitle>
+        </DialogHeader>
+
+        <div class="grid gap-3">
+          <label class="grid gap-1.5 text-xs font-medium">
+            <span>{{ t("redis.createKeyName") }}</span>
+            <Input v-model="createKeyName" class="dbx-editor-font-family h-8 text-xs" :placeholder="t('redis.createKeyNamePlaceholder')" @keydown.enter="createRedisKey" />
+          </label>
+
+          <label class="grid gap-1.5 text-xs font-medium">
+            <span>{{ t("redis.createKeyType") }}</span>
+            <Select :model-value="createKeyType" @update:open="onCreateKeyTypeSelectOpen" @update:model-value="onCreateKeyTypeChange">
+              <SelectTrigger class="h-8 text-xs" @keydown.capture="onCreateKeyTypeTriggerKeydown">
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent data-naked-surface class="w-auto max-w-[calc(100vw-1rem)] border-0 bg-transparent p-0 shadow-none ring-0">
+                <div class="flex min-w-0 flex-col gap-2 sm:flex-row sm:items-start" @keydown.capture="onCreateKeyTypeSelectKeydown">
+                  <div ref="createKeyTypeListCard" class="min-w-40 rounded-md border bg-popover p-1 shadow-md" @scroll="updateCreateKeyTypeHelpOffset">
+                    <SelectItem v-for="option in createKeyTypeOptions" :key="option.value" :value="option.value" :data-option-help-value="option.value" @pointerenter="activateCreateKeyTypeHelp(option.value)" @focus="onCreateKeyTypeOptionFocus(option.value)">
+                      {{ option.label }}
+                    </SelectItem>
+                  </div>
+                  <OptionHelpPanel v-if="activeCreateKeyTypeHelpContent" ref="createKeyTypeHelpPanel" :content="activeCreateKeyTypeHelpContent" :offset-top="createKeyTypeHelpOffsetTop" />
+                </div>
+              </SelectContent>
+            </Select>
+          </label>
+
+          <label v-if="createKeyType === 'hash' && createKeyRawMode" class="grid gap-1.5 text-xs font-medium">
+            <span>{{ t("redis.createField") }}</span>
+            <Input v-model="createKeyField" class="dbx-editor-font-family h-8 text-xs" :placeholder="t('redis.createFieldPlaceholder')" @keydown.enter="createRedisKey" />
+          </label>
+
+          <label v-if="createKeyType === 'zset' && createKeyRawMode" class="grid gap-1.5 text-xs font-medium">
+            <span>{{ t("redis.createScore") }}</span>
+            <Input v-model="createKeyScore" class="dbx-editor-font-family h-8 text-xs" placeholder="0" @keydown.enter="createRedisKey" />
+          </label>
+
+          <!-- TTL input -- always visible -->
+          <label class="grid gap-1.5 text-xs font-medium">
+            <span>{{ t("redis.createKeyTtl") }}</span>
+            <Input v-model="createKeyTtl" class="dbx-editor-font-family h-8 text-xs" type="number" min="0" :placeholder="t('redis.createKeyTtlPlaceholder')" @keydown.enter="createRedisKey" />
+          </label>
+
+          <!-- Raw mode toggle (non-string, non-stream, non-json types) -->
+          <div v-if="createKeyType !== 'string' && createKeyType !== 'stream' && createKeyType !== 'json'" class="flex items-center justify-end gap-1.5">
+            <label class="flex items-center gap-1.5 text-xs text-muted-foreground">
+              <span>{{ t("redis.createKeyRawMode") }}</span>
+              <Switch size="sm" v-model="createKeyRawMode" />
+            </label>
+          </div>
+
+          <!-- Structured entries (non-string, non-json, non-raw mode) -->
+          <template v-if="createKeyType !== 'string' && createKeyType !== 'json' && !createKeyRawMode">
+            <!-- Stream entry ID -->
+            <label v-if="createKeyType === 'stream'" class="grid gap-1.5 text-xs font-medium">
+              <span>{{ t("redis.createKeyEntryId") }}</span>
+              <Input v-model="createKeyEntryId" class="dbx-editor-font-family h-8 text-xs font-mono" placeholder="*" />
+            </label>
+
+            <div class="grid gap-2">
+              <div class="flex items-center justify-between">
+                <span class="text-xs font-medium">{{ t("redis.createKeyEntries") }}</span>
+                <Button variant="outline" size="sm" class="h-6 gap-1 text-xs" @click="addEntry">
+                  <Plus class="h-3 w-3" />
+                  {{ t("redis.createKeyAddEntry") }}
+                </Button>
+              </div>
+              <div v-for="(entry, idx) in createKeyEntries" :key="entry.id" class="flex items-start gap-2">
+                <!-- Hash / Stream: field + value -->
+                <template v-if="createKeyType === 'hash' || createKeyType === 'stream'">
+                  <Input v-model="entry.field" class="dbx-editor-font-family h-8 w-2/5 text-xs" :placeholder="t('redis.createFieldPlaceholder')" />
+                  <Input v-model="entry.value" class="dbx-editor-font-family h-8 flex-1 text-xs" :placeholder="t('redis.createValuePlaceholder')" />
+                </template>
+                <!-- ZSet: score + member -->
+                <template v-else-if="createKeyType === 'zset'">
+                  <Input v-model="entry.score" class="dbx-editor-font-family h-8 w-20 text-xs" type="number" step="any" placeholder="0" />
+                  <Input v-model="entry.value" class="dbx-editor-font-family h-8 flex-1 text-xs" :placeholder="t('redis.createMember')" />
+                </template>
+                <!-- List / Set: single value -->
+                <template v-else>
+                  <Input v-model="entry.value" class="dbx-editor-font-family h-8 flex-1 text-xs" :placeholder="t('redis.createValuePlaceholder')" />
+                </template>
+                <Button variant="ghost" size="sm" class="h-8 w-8 shrink-0 p-0 text-muted-foreground hover:text-destructive" :disabled="createKeyEntries.length <= 1" @click="removeEntry(idx)">
+                  <Trash2 class="h-3.5 w-3.5" />
+                </Button>
+              </div>
+            </div>
+          </template>
+
+          <!-- Raw value textarea (string, json, or raw mode for other types) -->
+          <label v-if="createKeyType === 'string' || createKeyType === 'json' || createKeyRawMode" class="grid gap-1.5 text-xs font-medium">
+            <span>{{ t(createKeyType === "set" || createKeyType === "zset" ? "redis.createMember" : "redis.createValue") }}</span>
+            <textarea v-model="createKeyValue" class="dbx-editor-font-family min-h-28 resize-y rounded-md border bg-background p-2 text-xs outline-none focus-visible:ring-1 focus-visible:ring-ring" spellcheck="false" :placeholder="t('redis.createValuePlaceholder')" />
+          </label>
+
+          <p v-if="createKeyError" class="text-xs text-destructive">{{ createKeyError }}</p>
+        </div>
+
+        <DialogFooter>
+          <Button variant="ghost" :disabled="creatingKey" @click="showCreateKeyDialog = false">
+            {{ t("dangerDialog.cancel") }}
+          </Button>
+          <Button :disabled="creatingKey || checkingJsonModule || (createKeyType === 'json' && jsonModuleAvailable !== true)" @click="createRedisKey">
+            <Loader2 v-if="creatingKey" class="h-4 w-4 animate-spin" />
+            <Plus v-else class="h-4 w-4" />
+            {{ t("redis.createKeySubmit") }}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  </div>
+</template>
+
+<style scoped>
+.redis-key-scroller {
+  will-change: scroll-position;
+  contain: content;
+}
+
+.redis-key-scroller :deep(.vue-recycle-scroller__item-view) {
+  contain: layout style paint;
+}
+
+.redis-workspace-splitpanes :deep(.splitpanes--vertical > .splitpanes__splitter) {
+  width: 1px !important;
+  border-left: 0;
+  background: var(--border);
+}
+
+.redis-workspace-splitpanes :deep(.splitpanes__splitter:hover) {
+  background: var(--primary) !important;
+}
+
+.redis-command-terminal {
+  user-select: text;
+  -webkit-user-select: text;
+}
+</style>
diff --git a/apps/desktop/src/components/redis/RedisPubSubPanel.vue b/apps/desktop/src/components/redis/RedisPubSubPanel.vue
new file mode 100644
index 0000000..e2239ca
--- /dev/null
+++ b/apps/desktop/src/components/redis/RedisPubSubPanel.vue
@@ -0,0 +1,272 @@
+<script setup lang="ts">
+import { ref, nextTick, onBeforeUnmount } from "vue";
+import { useI18n } from "vue-i18n";
+import * as api from "@/lib/backend/api";
+import { useToast } from "@/composables/useToast";
+
+const props = defineProps<{
+  connectionId: string;
+  db: number;
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+
+// State
+const channels = ref<string[]>([]);
+const patterns = ref<string[]>([]);
+const newChannel = ref("");
+const newPattern = ref("");
+
+const publishChannel = ref("");
+const publishMessage = ref("");
+
+interface PubSubEntry {
+  id: number;
+  channel: string;
+  pattern: string | null;
+  payload: string;
+  timestamp: Date;
+}
+const messages = ref<PubSubEntry[]>([]);
+let nextId = 0;
+
+let ws: WebSocket | null = null;
+const connected = ref(false);
+const connecting = ref(false);
+
+const messagesContainer = ref<HTMLElement | null>(null);
+
+function scrollToBottom() {
+  void nextTick(() => {
+    if (messagesContainer.value) {
+      messagesContainer.value.scrollTop = messagesContainer.value.scrollHeight;
+    }
+  });
+}
+
+function addMessage(channel: string, pattern: string | null, payload: string) {
+  messages.value.push({
+    id: ++nextId,
+    channel,
+    pattern,
+    payload,
+    timestamp: new Date(),
+  });
+  // Keep max 500 messages
+  if (messages.value.length > 500) {
+    messages.value.shift();
+  }
+  scrollToBottom();
+}
+
+// Connect WebSocket
+async function connect() {
+  if (ws && ws.readyState === WebSocket.OPEN) return;
+  connecting.value = true;
+  try {
+    const socket = await api.redisPubSubConnect(props.connectionId);
+    ws = socket;
+
+    socket.onopen = () => {
+      if (ws !== socket) return;
+      connected.value = true;
+      connecting.value = false;
+      // Re-subscribe existing channels
+      if (channels.value.length > 0) {
+        socket.send(JSON.stringify({ type: "subscribe", channels: channels.value }));
+      }
+      if (patterns.value.length > 0) {
+        socket.send(JSON.stringify({ type: "psubscribe", patterns: patterns.value }));
+      }
+    };
+
+    socket.onmessage = (event) => {
+      if (ws !== socket) return;
+      try {
+        const data = JSON.parse(event.data as string);
+        if (data.error) {
+          toast(data.error, 5000);
+          return;
+        }
+        addMessage(data.channel, data.pattern ?? null, data.payload);
+      } catch {
+        // Non-JSON message, skip
+      }
+    };
+
+    socket.onclose = () => {
+      if (ws !== socket) return;
+      connected.value = false;
+      connecting.value = false;
+      ws = null;
+    };
+
+    socket.onerror = () => {
+      if (ws !== socket) return;
+      connected.value = false;
+      connecting.value = false;
+      ws = null;
+    };
+  } catch (e) {
+    connecting.value = false;
+    toast(t("redis.pubsubWsConnectFailed", { error: e instanceof Error ? e.message : String(e) }), 5000);
+  }
+}
+
+function disconnect() {
+  const socket = ws;
+  ws = null;
+  connected.value = false;
+  connecting.value = false;
+  if (socket) socket.close();
+}
+
+function subscribe() {
+  const ch = newChannel.value.trim();
+  if (!ch) return;
+  if (channels.value.includes(ch)) return;
+  channels.value.push(ch);
+  newChannel.value = "";
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: "subscribe", channels: [ch] }));
+  }
+}
+
+function psubscribe() {
+  const pat = newPattern.value.trim();
+  if (!pat) return;
+  if (patterns.value.includes(pat)) return;
+  patterns.value.push(pat);
+  newPattern.value = "";
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: "psubscribe", patterns: [pat] }));
+  }
+}
+
+function unsubscribe(channel: string) {
+  channels.value = channels.value.filter((c) => c !== channel);
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: "unsubscribe", channels: [channel] }));
+  }
+}
+
+function punsubscribe(pattern: string) {
+  patterns.value = patterns.value.filter((p) => p !== pattern);
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify({ type: "punsubscribe", patterns: [pattern] }));
+  }
+}
+
+async function publish() {
+  const ch = publishChannel.value.trim();
+  const msg = publishMessage.value;
+  if (!ch || !msg) return;
+  try {
+    await api.redisPubSubPublish(props.connectionId, props.db, ch, msg);
+    publishMessage.value = "";
+  } catch (e) {
+    toast(t("redis.pubsubPublishFailed", { error: e instanceof Error ? e.message : String(e) }), 3000);
+  }
+}
+
+function clearMessages() {
+  messages.value = [];
+}
+
+onBeforeUnmount(() => {
+  disconnect();
+});
+</script>
+
+<template>
+  <div class="flex flex-col h-full">
+    <!-- Connection bar -->
+    <div class="flex items-center gap-2 px-3 py-1.5 border-b bg-muted/30 min-h-0 shrink-0">
+      <span class="text-xs font-medium whitespace-nowrap">{{ t("redis.pubsub") }}</span>
+      <span class="flex-1"></span>
+      <span class="inline-flex items-center gap-1 text-xs whitespace-nowrap" :class="connected ? 'text-green-600' : 'text-muted-foreground'">
+        <span class="inline-block w-2 h-2 rounded-full" :class="connected ? 'bg-green-500' : 'bg-gray-400'"></span>
+        {{ connected ? t("redis.pubsubConnected") : connecting ? t("redis.pubsubConnecting") : t("redis.pubsubDisconnected") }}
+      </span>
+      <button v-if="!connected" class="text-xs px-2 py-0.5 rounded border border-transparent bg-primary text-primary-foreground hover:bg-primary/90" :disabled="connecting" @click="connect">
+        {{ t("redis.pubsubConnect") }}
+      </button>
+      <button v-else class="text-xs px-2 py-0.5 rounded border hover:bg-muted" @click="disconnect">
+        {{ t("redis.pubsubDisconnect") }}
+      </button>
+    </div>
+
+    <!-- Subscriptions -->
+    <div class="px-3 py-2 border-b space-y-2" :class="{ 'opacity-50 pointer-events-none': !connected }">
+      <!-- Channel subscriptions -->
+      <div>
+        <div class="text-xs font-medium mb-1">{{ t("redis.pubsubChannels") }}</div>
+        <div class="flex gap-1 mb-1">
+          <input v-model="newChannel" type="text" :disabled="!connected" autocomplete="off" autocapitalize="off" autocorrect="off" spellcheck="false" class="flex-1 h-7 px-2 text-xs border rounded bg-background" :placeholder="t('redis.pubsubChannelPlaceholder')" @keydown.enter="subscribe" />
+          <button :disabled="!connected" class="text-xs px-2 py-0.5 rounded bg-primary text-primary-foreground hover:bg-primary/90 disabled:opacity-50" @click="subscribe">
+            {{ t("redis.pubsubSubscribe") }}
+          </button>
+        </div>
+        <div v-if="channels.length > 0" class="flex flex-wrap gap-1">
+          <span v-for="ch in channels" :key="ch" class="inline-flex items-center gap-1 text-xs px-1.5 py-0.5 rounded bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-200">
+            {{ ch }}
+            <button class="hover:text-red-500" @click="unsubscribe(ch)">×</button>
+          </span>
+        </div>
+      </div>
+
+      <!-- Pattern subscriptions -->
+      <div>
+        <div class="text-xs font-medium mb-1">{{ t("redis.pubsubPatterns") }}</div>
+        <div class="flex gap-1 mb-1">
+          <input v-model="newPattern" type="text" :disabled="!connected" autocomplete="off" autocapitalize="off" autocorrect="off" spellcheck="false" class="flex-1 h-7 px-2 text-xs border rounded bg-background" :placeholder="t('redis.pubsubPatternPlaceholder')" @keydown.enter="psubscribe" />
+          <button :disabled="!connected" class="text-xs px-2 py-0.5 rounded bg-primary text-primary-foreground hover:bg-primary/90 disabled:opacity-50" @click="psubscribe">
+            {{ t("redis.pubsubPsubscribe") }}
+          </button>
+        </div>
+        <div v-if="patterns.length > 0" class="flex flex-wrap gap-1">
+          <span v-for="pat in patterns" :key="pat" class="inline-flex items-center gap-1 text-xs px-1.5 py-0.5 rounded bg-purple-100 text-purple-800 dark:bg-purple-900 dark:text-purple-200">
+            {{ pat }}
+            <button class="hover:text-red-500" @click="punsubscribe(pat)">×</button>
+          </span>
+        </div>
+      </div>
+    </div>
+
+    <!-- Messages -->
+    <div class="flex-1 flex flex-col min-h-0">
+      <div class="flex items-center gap-2 px-3 py-1 border-b">
+        <span class="text-xs font-medium">{{ t("redis.pubsubMessages") }}</span>
+        <span class="text-xs text-muted-foreground">({{ messages.length }})</span>
+        <span class="flex-1"></span>
+        <button class="text-xs px-2 py-0.5 rounded border hover:bg-muted" @click="clearMessages">
+          {{ t("redis.pubsubClear") }}
+        </button>
+      </div>
+      <div ref="messagesContainer" class="flex-1 overflow-auto px-3 py-1 font-mono text-xs">
+        <div v-if="messages.length === 0" class="text-muted-foreground py-4 text-center">
+          {{ t("redis.pubsubEmpty") }}
+        </div>
+        <div v-for="msg in messages" :key="msg.id" class="py-0.5 border-b border-dashed border-border/50">
+          <span class="text-muted-foreground">{{ msg.timestamp.toLocaleTimeString() }}</span>
+          <span class="ml-2 font-semibold text-blue-600 dark:text-blue-400">{{ msg.channel }}</span>
+          <span v-if="msg.pattern" class="ml-1 text-purple-500">({{ msg.pattern }})</span>
+          <span class="ml-2">{{ msg.payload }}</span>
+        </div>
+      </div>
+    </div>
+
+    <!-- Publish -->
+    <div class="px-3 py-2 border-t space-y-1.5">
+      <div class="text-xs font-medium">{{ t("redis.pubsubPublish") }}</div>
+      <input v-model="publishChannel" type="text" class="w-full h-7 px-2 text-xs border rounded bg-background" :placeholder="t('redis.pubsubPublishChannel')" autocomplete="off" autocapitalize="off" autocorrect="off" spellcheck="false" />
+      <div class="flex gap-1">
+        <input v-model="publishMessage" type="text" autocomplete="off" autocapitalize="off" autocorrect="off" spellcheck="false" class="flex-1 h-7 px-2 text-xs border rounded bg-background" :placeholder="t('redis.pubsubPublishMessage')" @keydown.enter="publish" />
+        <button class="text-xs px-3 py-0.5 rounded bg-primary text-primary-foreground hover:bg-primary/90" @click="publish">
+          {{ t("redis.pubsubSend") }}
+        </button>
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/redis/RedisSlowlogPanel.vue b/apps/desktop/src/components/redis/RedisSlowlogPanel.vue
new file mode 100644
index 0000000..fae2f9a
--- /dev/null
+++ b/apps/desktop/src/components/redis/RedisSlowlogPanel.vue
@@ -0,0 +1,246 @@
+<script setup lang="ts">
+import { ref, computed, onMounted } from "vue";
+import { useI18n } from "vue-i18n";
+import { Loader2, Search } from "@lucide/vue";
+import { RecycleScroller } from "vue-virtual-scroller";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { Dialog, DialogContent, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import * as api from "@/lib/backend/api";
+import type { RedisSlowlogEntry, RedisNodeEndpoint } from "@/lib/backend/api";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useToast } from "@/composables/useToast";
+
+const props = defineProps<{
+  connectionId: string;
+  db: number;
+}>();
+
+const { t } = useI18n();
+const { toast } = useToast();
+const connectionStore = useConnectionStore();
+
+// --- State ---
+const count = ref(100);
+const nodes = ref<RedisNodeEndpoint[]>([]);
+const selectedNodeIndex = ref(-1);
+const entries = ref<RedisSlowlogEntry[]>([]);
+const sortField = ref<keyof RedisSlowlogEntry>("id");
+const sortOrder = ref<"asc" | "desc">("asc");
+const loading = ref(false);
+const showDetailDialog = ref(false);
+const selectedEntry = ref<RedisSlowlogEntry | null>(null);
+
+// --- Connection mode ---
+const connectionMode = computed(() => {
+  return connectionStore.getConfig(props.connectionId)?.redis_connection_mode;
+});
+
+const showNodeSelector = computed(() => {
+  // Cluster mode needs node selection; sentinel connections use Direct path (no selector needed)
+  return connectionMode.value === "cluster";
+});
+
+const nodeOptions = computed(() => {
+  return nodes.value.map((n) => `${n.host}:${n.port}`);
+});
+
+const selectedEndpoint = computed(() => {
+  if (selectedNodeIndex.value < 0) return null;
+  return nodes.value[selectedNodeIndex.value] ?? null;
+});
+
+const showClientColumns = computed(() => {
+  return entries.value.some((e) => e.client_addr != null || e.client_name != null);
+});
+
+// --- Load cluster nodes on mount ---
+onMounted(async () => {
+  if (connectionMode.value === "cluster") {
+    try {
+      await connectionStore.ensureConnected(props.connectionId);
+      nodes.value = await api.redisClusterMasterNodes(props.connectionId);
+    } catch (e) {
+      console.warn("[DBX] ensureConnected failed for", props.connectionId, e);
+    }
+  }
+});
+
+// --- Sorted entries ---
+const sortedEntries = computed(() => {
+  const field = sortField.value;
+  const order = sortOrder.value === "asc" ? 1 : -1;
+  return [...entries.value].sort((a, b) => {
+    const aVal = a[field];
+    const bVal = b[field];
+    if (aVal == null && bVal == null) return 0;
+    if (aVal == null) return 1;
+    if (bVal == null) return -1;
+    if (typeof aVal === "string" && typeof bVal === "string") {
+      return aVal.localeCompare(bVal) * order;
+    }
+    return (aVal < bVal ? -1 : aVal > bVal ? 1 : 0) * order;
+  });
+});
+
+// --- Methods ---
+function sortBy(field: keyof RedisSlowlogEntry) {
+  if (sortField.value === field) {
+    sortOrder.value = sortOrder.value === "asc" ? "desc" : "asc";
+  } else {
+    sortField.value = field;
+    sortOrder.value = "asc";
+  }
+}
+
+function sortIndicator(field: keyof RedisSlowlogEntry): string {
+  if (sortField.value !== field) return "";
+  return sortOrder.value === "asc" ? " ↑" : " ↓";
+}
+
+function formatTimestamp(ts: number): string {
+  if (ts <= 0) return "NIL";
+  const d = new Date(ts * 1000);
+  const pad = (n: number) => n.toString().padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+
+function displayValue(val: string | null): string {
+  return val ?? "NIL";
+}
+
+async function querySlowlog() {
+  if (showNodeSelector.value && selectedNodeIndex.value < 0) {
+    toast(t("redis.slowlogNodeRequired"), 3000);
+    return;
+  }
+
+  loading.value = true;
+  try {
+    let result: RedisSlowlogEntry[];
+    if (showNodeSelector.value && selectedEndpoint.value) {
+      result = await api.redisSlowlogGet(props.connectionId, count.value, selectedEndpoint.value.host, selectedEndpoint.value.port);
+    } else {
+      result = await api.redisSlowlogGet(props.connectionId, count.value);
+    }
+    entries.value = result;
+    // Default sort by id ascending
+    sortField.value = "id";
+    sortOrder.value = "asc";
+  } catch (e) {
+    toast(t("redis.slowlogFetchFailed", { error: e instanceof Error ? e.message : String(e) }), 5000);
+  } finally {
+    loading.value = false;
+  }
+}
+</script>
+
+<template>
+  <div class="flex flex-col h-full">
+    <!-- Top bar: count input, node dropdown, query button -->
+    <div class="flex items-center gap-2 px-3 py-1.5 border-b bg-muted/30 min-h-0 shrink-0">
+      <label class="text-xs font-medium whitespace-nowrap shrink-0">{{ t("redis.slowlogCount") }}</label>
+      <Input v-model.number="count" type="number" min="1" max="10000" class="h-7 w-20 text-xs" :placeholder="t('redis.slowlogCount')" />
+      <template v-if="showNodeSelector">
+        <label class="text-xs font-medium whitespace-nowrap shrink-0 ml-1">{{ t("redis.slowlogNode") }}</label>
+        <Select v-model="selectedNodeIndex">
+          <SelectTrigger class="h-7 w-auto min-w-[140px] text-xs">
+            <SelectValue :placeholder="t('redis.slowlogSelectNode')" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem v-for="(node, idx) in nodeOptions" :key="idx" :value="idx" class="text-xs">
+              {{ node }}
+            </SelectItem>
+          </SelectContent>
+        </Select>
+      </template>
+      <span class="flex-1"></span>
+      <Button size="sm" class="h-7 text-xs gap-1" :disabled="loading" @click="querySlowlog">
+        <Loader2 v-if="loading" class="size-3.5 animate-spin" />
+        <Search v-else class="size-3.5" />
+        {{ t("redis.slowlogQuery") }}
+      </Button>
+    </div>
+
+    <!-- Results table -->
+    <div class="flex-1 flex flex-col min-h-0 relative">
+      <!-- Empty state -->
+      <div v-if="entries.length === 0 && !loading" class="flex-1 flex items-center justify-center text-xs text-muted-foreground">
+        {{ t("redis.slowlogEmpty") }}
+      </div>
+
+      <!-- Table header -->
+      <div v-if="entries.length > 0" class="flex items-center gap-2 px-3 py-1 border-b shrink-0 bg-background">
+        <span class="text-xs font-medium">{{ t("redis.slowlog") }}</span>
+        <span class="text-xs text-muted-foreground">({{ t("redis.slowlogTotal", { count: entries.length }) }})</span>
+      </div>
+
+      <!-- Sortable column headers -->
+      <div v-if="entries.length > 0" class="flex items-center border-b px-3 shrink-0 bg-muted/20 text-xs font-medium text-muted-foreground select-none" style="height: 28px">
+        <button class="w-16 shrink-0 text-left hover:text-foreground transition-colors text-xs font-medium" @click="sortBy('id')">{{ t("redis.slowlogColumnId") }}<span v-html="sortIndicator('id')"></span></button>
+        <button class="w-40 shrink-0 text-left hover:text-foreground transition-colors text-xs font-medium" @click="sortBy('timestamp')">{{ t("redis.slowlogColumnTimestamp") }}<span v-html="sortIndicator('timestamp')"></span></button>
+        <button class="w-24 shrink-0 text-left hover:text-foreground transition-colors text-xs font-medium" @click="sortBy('duration_micros')">{{ t("redis.slowlogColumnDuration") }}<span v-html="sortIndicator('duration_micros')"></span></button>
+        <button class="flex-1 min-w-0 text-left hover:text-foreground transition-colors text-xs font-medium" @click="sortBy('command')">{{ t("redis.slowlogColumnCommand") }}<span v-html="sortIndicator('command')"></span></button>
+        <button v-if="showClientColumns" class="w-32 shrink-0 text-left hover:text-foreground transition-colors text-xs font-medium" @click="sortBy('client_addr')">{{ t("redis.slowlogColumnClientAddr") }}<span v-html="sortIndicator('client_addr')"></span></button>
+        <button v-if="showClientColumns" class="w-32 shrink-0 text-left hover:text-foreground transition-colors text-xs font-medium" @click="sortBy('client_name')">{{ t("redis.slowlogColumnClientName") }}<span v-html="sortIndicator('client_name')"></span></button>
+      </div>
+
+      <!-- Table with virtual scrolling -->
+      <div v-if="entries.length > 0" class="flex-1 overflow-hidden">
+        <RecycleScroller class="h-full" :items="sortedEntries" :item-size="32" :buffer="400" key-field="id" v-slot="{ item }: { item: RedisSlowlogEntry }">
+          <div
+            class="flex items-center border-b border-dashed border-border/50 px-3 text-xs hover:bg-muted/30 cursor-pointer"
+            style="height: 32px"
+            @click="
+              selectedEntry = item;
+              showDetailDialog = true;
+            "
+          >
+            <span class="w-16 shrink-0 text-muted-foreground tabular-nums">{{ item.id }}</span>
+            <span class="w-40 shrink-0 font-mono tabular-nums">{{ formatTimestamp(item.timestamp) }}</span>
+            <span class="w-24 shrink-0 font-mono tabular-nums text-muted-foreground">{{ item.duration_micros }}</span>
+            <span class="flex-1 min-w-0 truncate font-mono" :title="item.command">{{ item.command }}</span>
+            <span v-if="showClientColumns" class="w-32 shrink-0 text-muted-foreground truncate" :title="displayValue(item.client_addr)">{{ displayValue(item.client_addr) }}</span>
+            <span v-if="showClientColumns" class="w-32 shrink-0 text-muted-foreground truncate" :title="displayValue(item.client_name)">{{ displayValue(item.client_name) }}</span>
+          </div>
+        </RecycleScroller>
+      </div>
+
+      <!-- Loading overlay -->
+      <div v-if="loading" class="absolute inset-0 flex items-center justify-center bg-background/60 z-10">
+        <Loader2 class="size-5 animate-spin text-muted-foreground" />
+      </div>
+    </div>
+
+    <!-- Detail dialog -->
+    <Dialog v-model:open="showDetailDialog">
+      <DialogContent class="sm:max-w-2xl">
+        <DialogHeader>
+          <DialogTitle class="text-sm">{{ t("redis.slowlogDetailTitle", { id: selectedEntry?.id ?? "" }) }}</DialogTitle>
+        </DialogHeader>
+        <div v-if="selectedEntry" class="grid gap-3 text-xs">
+          <div class="grid grid-cols-[80px_1fr] gap-x-3 gap-y-2">
+            <span class="font-medium text-muted-foreground">{{ t("redis.slowlogColumnId") }}</span>
+            <span class="font-mono">{{ selectedEntry.id }}</span>
+
+            <span class="font-medium text-muted-foreground">{{ t("redis.slowlogColumnTimestamp") }}</span>
+            <span class="font-mono">{{ formatTimestamp(selectedEntry.timestamp) }}</span>
+
+            <span class="font-medium text-muted-foreground">{{ t("redis.slowlogColumnDuration") }}</span>
+            <span class="font-mono">{{ selectedEntry.duration_micros }} μs</span>
+
+            <span class="font-medium text-muted-foreground">{{ t("redis.slowlogColumnCommand") }}</span>
+            <pre class="font-mono whitespace-pre-wrap break-words bg-muted rounded p-2 m-0 max-h-48 overflow-auto">{{ selectedEntry.command }}</pre>
+
+            <span class="font-medium text-muted-foreground">{{ t("redis.slowlogColumnClientAddr") }}</span>
+            <span class="font-mono">{{ displayValue(selectedEntry.client_addr) }}</span>
+
+            <span class="font-medium text-muted-foreground">{{ t("redis.slowlogColumnClientName") }}</span>
+            <span class="font-mono">{{ displayValue(selectedEntry.client_name) }}</span>
+          </div>
+        </div>
+      </DialogContent>
+    </Dialog>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/redis/RedisValueViewer.vue b/apps/desktop/src/components/redis/RedisValueViewer.vue
new file mode 100644
index 0000000..dd65e7c
--- /dev/null
+++ b/apps/desktop/src/components/redis/RedisValueViewer.vue
@@ -0,0 +1,1616 @@
+<script setup lang="ts">
+import { computed, ref, nextTick, onBeforeUnmount, onMounted } from "vue";
+import { useI18n } from "vue-i18n";
+import { onClickOutside } from "@vueuse/core";
+import { DynamicScroller, DynamicScrollerItem, RecycleScroller } from "vue-virtual-scroller";
+import { Copy, Eye, Terminal, Trash2, Save, RefreshCw, Plus, Loader2, Pencil, WrapText, IndentIncrease, IndentDecrease, ArrowUp, ArrowDown, ArrowUpDown, Search, Clock } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Badge } from "@/components/ui/badge";
+import { Switch } from "@/components/ui/switch";
+import { Sheet, SheetContent, SheetFooter, SheetHeader, SheetTitle } from "@/components/ui/sheet";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import JsonTree from "@/components/common/JsonTree.vue";
+import * as api from "@/lib/backend/api";
+import type { RedisBlob, RedisHashItem, RedisKeyInfo, RedisListItem, RedisSetItem, RedisStreamEntry, RedisValue, RedisZsetItem } from "@/lib/backend/api";
+import { useToast } from "@/composables/useToast";
+import { useTheme } from "@/composables/useTheme";
+import { useEditorFontFamilyStyle } from "@/composables/useEditorFontFamilyStyle";
+import { createShikiJsonHighlighter, type JsonHighlighter } from "@/lib/common/shikiJsonHighlighter";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { formatTtl } from "@/lib/common/ttlFormat";
+import { computeAutoRefreshTick, computeDisplayTtl, shouldStopAutoRefresh } from "@/lib/redis/redisAutoRefresh";
+import {
+  canRenderRedisValueFormat,
+  canEditRedisMemberDetail,
+  clampRedisMemberDetailSheetWidth,
+  formatRedisMemberDetail,
+  getRedisMemberSelectionKey,
+  isRedisBlob,
+  preferredRedisValueFormat,
+  REDIS_VALUE_FORMAT_DISPLAY_ORDER,
+  redisBlobText,
+  redisCollectionPageItems,
+  redisMemberCopyText,
+  redisValueCopyText,
+  redisValueCollectionItems,
+  redisValueCollectionScanCursor,
+  redisValueCollectionTotal,
+  type RedisCollectionItem,
+  type RedisValueFormat,
+} from "@/lib/redis/redisValuePresentation";
+import { safeJsonFormat } from "@/lib/common/safeJsonFormat";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const { isDark } = useTheme();
+const editorFontFamilyStyle = useEditorFontFamilyStyle();
+
+const props = defineProps<{
+  connectionId: string;
+  db: number;
+  keyDisplay: string;
+  keyRaw: string;
+  metadata?: RedisKeyInfo | null;
+}>();
+
+const emit = defineEmits<{ deleted: []; loaded: [value: RedisValue] }>();
+
+const REDIS_JSON_WRAP_STORAGE_KEY = "dbx-redis-json-word-wrap";
+const REDIS_VALUE_FORMAT_STORAGE_KEY = "dbx-redis-value-format";
+const REDIS_COLLECTION_ROW_HEIGHT = 32;
+const REDIS_STREAM_MIN_ROW_HEIGHT = 96;
+
+const data = ref<RedisValue | null>(null);
+const loading = ref(false);
+const loadingMore = ref(false);
+const editValue = ref("");
+const isEditing = ref(false);
+const newField = ref("");
+const newValue = ref("");
+const newScore = ref("");
+const showDeleteConfirm = ref(false);
+const showMemberDetail = ref(false);
+const editingTtl = ref(false);
+const ttlInput = ref("");
+const ttlInputEl = ref<InstanceType<typeof Input>>();
+const editTtlWrapper = ref<HTMLElement>();
+onClickOutside(editTtlWrapper, () => {
+  if (editingTtl.value) cancelEditTtl();
+});
+const collectionItems = ref<RedisCollectionItem[]>([]);
+const scanCursor = ref<number | undefined>(undefined);
+const selectedMemberTitle = ref("");
+const selectedMemberRaw = ref<unknown>("");
+const selectedMemberKey = ref("");
+const selectedMemberContext = ref<RedisMemberContext | null>(null);
+const isEditingMember = ref(false);
+const savingMember = ref(false);
+const memberEditValue = ref("");
+const memberDetailSheetWidth = ref(420);
+const isResizingMemberSheet = ref(false);
+const hashTableRef = ref<HTMLElement | null>(null);
+const hashFieldWidth = ref(280);
+const isResizingHashColumns = ref(false);
+const zsetTableRef = ref<HTMLElement | null>(null);
+const zsetScoreWidth = ref(220);
+const isResizingZsetColumns = ref(false);
+const stringValueView = ref<RedisValueFormat>(readPreferredRedisValueFormat());
+const memberValueView = ref<RedisValueFormat>(readPreferredRedisValueFormat());
+const redisJsonView = ref<"raw" | "tree">("raw");
+const redisJsonWordWrap = ref(readRedisJsonWordWrap());
+const redisJsonHighlighter = ref<JsonHighlighter>();
+
+// Auto-refresh
+const autoRefreshEnabled = ref(true);
+const countdownTtl = ref(0);
+let autoRefreshTimer: ReturnType<typeof setInterval> | null = null;
+
+function toggleAutoRefresh() {
+  autoRefreshEnabled.value = !autoRefreshEnabled.value;
+  if (autoRefreshEnabled.value) {
+    startAutoRefresh();
+  } else {
+    stopAutoRefresh();
+  }
+}
+
+function startAutoRefresh() {
+  stopAutoRefresh();
+  if (data.value && data.value.ttl > 0) {
+    countdownTtl.value = data.value.ttl;
+  }
+  autoRefreshTimer = setInterval(() => {
+    const action = computeAutoRefreshTick(autoRefreshEnabled.value, countdownTtl.value, loading.value);
+    if (action.type === "decrement") {
+      countdownTtl.value--;
+      return;
+    }
+    if (action.type === "refresh") {
+      load()
+        .then(() => {
+          if (!autoRefreshEnabled.value) return;
+          if (!data.value || shouldStopAutoRefresh(data.value.ttl)) {
+            stopAutoRefresh();
+            autoRefreshEnabled.value = false;
+          }
+        })
+        .catch(() => {
+          // Network / connection error — stop auto-refresh to avoid tight retry loop
+          if (autoRefreshEnabled.value) {
+            stopAutoRefresh();
+            autoRefreshEnabled.value = false;
+          }
+        });
+    }
+  }, 1000);
+}
+
+function stopAutoRefresh() {
+  if (autoRefreshTimer !== null) {
+    clearInterval(autoRefreshTimer);
+    autoRefreshTimer = null;
+  }
+}
+
+const hashSortBy = ref<"field" | "value" | null>(null);
+const hashSortDir = ref<"asc" | "desc">("asc");
+const hashSearchQuery = ref("");
+const activeHashSearchQuery = ref("");
+const searchLoading = ref(false);
+
+function toggleHashSort(column: "field" | "value") {
+  if (hashSortBy.value === column && hashSortDir.value === "desc") {
+    hashSortBy.value = null;
+  } else if (hashSortBy.value === column) {
+    hashSortDir.value = "desc";
+  } else {
+    hashSortBy.value = column;
+    hashSortDir.value = "asc";
+  }
+}
+
+const redisKind = computed(() => data.value?.data.kind ?? "unknown");
+const isStringLikeKind = computed(() => redisKind.value === "string");
+const stringBlob = computed<RedisBlob | null>(() => {
+  const value = data.value;
+  if (!value) return null;
+  return value.data.kind === "string" ? value.data.content : null;
+});
+const stringValueDetail = computed(() => (stringBlob.value ? formatRedisMemberDetail(stringBlob.value, { allowJsonText: true }) : null));
+const redisJsonValue = computed(() => (data.value?.data.kind === "json" ? data.value.data.value : null));
+const selectedMemberDetail = computed(() => formatRedisMemberDetail(selectedMemberRaw.value, { allowJsonText: true }));
+const redisJsonAppearance = computed(() => (isDark.value ? "dark" : "light"));
+const isBinaryStringValue = computed(() => Boolean(stringValueDetail.value?.binary));
+const selectedMemberCanEdit = computed(() => selectedMemberContext.value?.canEdit ?? false);
+const canEditCurrentStringFormat = computed(() => Boolean(stringValueDetail.value?.editable) && stringValueView.value === "utf8");
+const showStringEditActions = computed(() => canEditCurrentStringFormat.value);
+const originalStringEditValue = computed(() => (stringBlob.value ? rawRedisValueText(stringBlob.value) : ""));
+const stringValueChanged = computed(() => canEditCurrentStringFormat.value && editValue.value !== originalStringEditValue.value);
+const canEditCurrentMemberFormat = computed(() => selectedMemberCanEdit.value && memberValueView.value === "utf8");
+const hasMore = computed(() => scanCursor.value != null && scanCursor.value > 0);
+const collectionTotal = computed(() => (data.value ? redisValueCollectionTotal(data.value) : null));
+const hashGridStyle = computed(() => ({
+  gridTemplateColumns: `${hashFieldWidth.value}px minmax(12rem, 1fr) 84px`,
+}));
+const zsetGridStyle = computed(() => ({
+  gridTemplateColumns: `${zsetScoreWidth.value}px minmax(0, 1fr) 84px`,
+}));
+const metadataSizeLabel = computed(() => {
+  const metadata = props.metadata;
+  const size = metadata?.size ?? 0;
+  if (!metadata || size <= 0) return "";
+  if (metadata.key_type === "string") {
+    if (size >= 1024) return `${(size / 1024).toFixed(1)} KB`;
+    return `${size} B`;
+  }
+  return String(size);
+});
+const streamRows = computed<RedisStreamRow[]>(() => {
+  if (data.value?.data.kind !== "stream") return [];
+  return data.value.data.entries.map((entry, index) => ({
+    id: `${index}:${entry.id}`,
+    index,
+    entry,
+  }));
+});
+
+const sortedHashItems = computed<RedisHashItem[]>(() => {
+  if (redisKind.value !== "hash") return [];
+  const items = [...(collectionItems.value as RedisHashItem[])];
+  if (!hashSortBy.value) return items;
+  const multiplier = hashSortDir.value === "asc" ? 1 : -1;
+  const key = hashSortBy.value;
+  items.sort((a, b) => {
+    const av = key === "field" ? formatRedisMemberDetail(a.field).rawText : formatRedisMemberDetail(a.value).rawText;
+    const bv = key === "field" ? formatRedisMemberDetail(b.field).rawText : formatRedisMemberDetail(b.value).rawText;
+    return av.localeCompare(bv) * multiplier;
+  });
+  return items;
+});
+
+const hashCollectionRows = computed<RedisCollectionRow<RedisHashItem>[]>(() =>
+  sortedHashItems.value.map((value, index) => ({
+    id: `hash-${index}`,
+    index,
+    value,
+  })),
+);
+
+const listRows = computed<RedisCollectionRow<RedisListItem>[]>(() =>
+  redisKind.value === "list"
+    ? (collectionItems.value as RedisListItem[]).map((value, index) => ({
+        id: collectionRowId(value, index),
+        index,
+        value,
+      }))
+    : [],
+);
+const setRows = computed<RedisCollectionRow<RedisSetItem>[]>(() =>
+  redisKind.value === "set"
+    ? (collectionItems.value as RedisSetItem[]).map((value, index) => ({
+        id: collectionRowId(value, index),
+        index,
+        value,
+      }))
+    : [],
+);
+const zsetRows = computed<RedisCollectionRow<RedisZsetItem>[]>(() =>
+  redisKind.value === "zset"
+    ? (collectionItems.value as RedisZsetItem[]).map((value, index) => ({
+        id: collectionRowId(value, index),
+        index,
+        value,
+      }))
+    : [],
+);
+
+let hashSearchTimer: ReturnType<typeof setTimeout> | null = null;
+let hashSearchRequestId = 0;
+let memberSheetResizeStartX = 0;
+let memberSheetResizeStartWidth = 0;
+let hashResizeStartX = 0;
+let hashResizeStartWidth = 0;
+let zsetResizeStartX = 0;
+let zsetResizeStartWidth = 0;
+
+type PendingDelete = { kind: "key" } | { kind: "hash"; field: string } | { kind: "list"; index: number } | { kind: "set"; member: string } | { kind: "zset"; member: string };
+const pendingDelete = ref<PendingDelete | null>(null);
+
+type RedisMemberContext =
+  | { kind: "list"; index: number; canEdit: boolean }
+  | { kind: "set"; member: string | null; canEdit: boolean }
+  | { kind: "hash"; field: string | null; canEdit: boolean }
+  | { kind: "zset"; member: string | null; score: string; canEdit: boolean }
+  | { kind: "stream"; field: string; canEdit: false };
+
+type RedisCollectionRow<T> = {
+  id: string;
+  index: number;
+  value: T;
+};
+
+type RedisStreamRow = {
+  id: string;
+  index: number;
+  entry: RedisStreamEntry;
+};
+
+function collectionCountLabel(kind: "items" | "fields" | "members", loaded: number, total?: number | null) {
+  if (total == null || total === loaded) return t(`redis.${kind}`, { count: loaded });
+  return t(`redis.loaded${kind[0].toUpperCase()}${kind.slice(1)}`, { loaded, total });
+}
+
+function onHashSearchInput() {
+  if (hashSearchTimer) clearTimeout(hashSearchTimer);
+  hashSearchTimer = setTimeout(() => void onHashSearch(), 400);
+}
+
+function onHashSearchKeydown(event: KeyboardEvent) {
+  if (event.key === "Enter") {
+    if (hashSearchTimer) clearTimeout(hashSearchTimer);
+    hashSearchTimer = null;
+    void onHashSearch();
+    return;
+  }
+  if (event.key === "Escape") {
+    if (hashSearchTimer) clearTimeout(hashSearchTimer);
+    hashSearchTimer = null;
+    hashSearchQuery.value = "";
+    void onHashSearch();
+  }
+}
+
+async function onHashSearch() {
+  const query = hashSearchQuery.value.trim();
+  if (redisKind.value !== "hash") return;
+  const requestId = ++hashSearchRequestId;
+  searchLoading.value = true;
+  try {
+    const result = await api.redisLoadMore(props.connectionId, props.db, props.keyRaw, "hash", 0, 200, query || undefined);
+    if (requestId !== hashSearchRequestId || result.kind !== "hash") return;
+    activeHashSearchQuery.value = query;
+    collectionItems.value = result.items;
+    scanCursor.value = result.scan_cursor ?? undefined;
+    clearSelectedMember();
+  } finally {
+    if (requestId === hashSearchRequestId) searchLoading.value = false;
+  }
+}
+
+function readRedisJsonWordWrap(): boolean {
+  try {
+    return localStorage.getItem(REDIS_JSON_WRAP_STORAGE_KEY) !== "false";
+  } catch {
+    return true;
+  }
+}
+
+function setRedisJsonWordWrap(value: boolean) {
+  redisJsonWordWrap.value = value;
+  try {
+    localStorage.setItem(REDIS_JSON_WRAP_STORAGE_KEY, value ? "true" : "false");
+  } catch {
+    // Ignore storage failures; the toggle still works for the current session.
+  }
+}
+
+function readPreferredRedisValueFormat(): RedisValueFormat {
+  try {
+    const stored = localStorage.getItem(REDIS_VALUE_FORMAT_STORAGE_KEY);
+    if (stored === "raw") return "utf8";
+    return stored === "utf8" || stored === "ascii" || stored === "binary" || stored === "json" || stored === "javaserialize" || stored === "hex" || stored === "base64" ? stored : "utf8";
+  } catch {
+    return "utf8";
+  }
+}
+
+function formatJsonText(raw: string): string | null {
+  try {
+    return safeJsonFormat(raw, 2);
+  } catch {
+    return null;
+  }
+}
+
+function compressJsonText(raw: string): string | null {
+  try {
+    return safeJsonFormat(raw);
+  } catch {
+    return null;
+  }
+}
+
+function rememberRedisValueFormat(format: RedisValueFormat) {
+  try {
+    localStorage.setItem(REDIS_VALUE_FORMAT_STORAGE_KEY, format);
+  } catch {
+    // Ignore storage failures; the toggle still works for the current session.
+  }
+}
+
+function setStringValueFormat(format: RedisValueFormat) {
+  stringValueView.value = format;
+  if (stringValueDetail.value && canRenderRedisValueFormat(stringValueDetail.value, format)) {
+    rememberRedisValueFormat(format);
+  }
+}
+
+function setMemberValueFormat(format: RedisValueFormat) {
+  memberValueView.value = format;
+  if (canRenderRedisValueFormat(selectedMemberDetail.value, format)) {
+    rememberRedisValueFormat(format);
+  }
+}
+
+function redisFormatLabel(format: RedisValueFormat, rawLabel?: string): string {
+  switch (format) {
+    case "utf8":
+      return "UTF-8";
+    case "ascii":
+      return "ASCII";
+    case "binary":
+      return "Binary";
+    case "json":
+      return t("redis.jsonView");
+    case "javaserialize":
+      return "Java Serialized";
+    case "hex":
+      return t("grid.hexViewerHex");
+    case "base64":
+      return "Base64";
+    default:
+      return rawLabel || t("redis.rawContent");
+  }
+}
+
+function isTextRedisFormat(format: RedisValueFormat): boolean {
+  return format === "utf8" || format === "ascii" || format === "binary";
+}
+
+function highlightRedisJson(json: string): string {
+  return redisJsonHighlighter.value?.(json, redisJsonAppearance.value) ?? escapeHtml(json);
+}
+
+function escapeHtml(value: string): string {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+function detailTextForFormat(detail: ReturnType<typeof formatRedisMemberDetail>, format: RedisValueFormat): string {
+  switch (format) {
+    case "utf8":
+      return detail.utf8Text;
+    case "ascii":
+      return detail.asciiText;
+    case "binary":
+      return detail.binaryText;
+    case "json":
+      return detail.json?.formattedText ?? detail.rawText;
+    case "javaserialize":
+      return detail.javaSerialized?.formattedText ?? detail.rawText;
+    case "hex":
+      return detail.hexRows.map((row) => row.hex).join("\n");
+    case "base64":
+      return detail.base64Text;
+    default:
+      return detail.rawText;
+  }
+}
+
+function detailTextClass(format: RedisValueFormat): string {
+  if (!redisJsonWordWrap.value) return "whitespace-pre";
+  return format === "ascii" || format === "binary" ? "whitespace-pre-wrap break-all" : "whitespace-pre-wrap break-words";
+}
+
+function rawRedisValueText(value: unknown): string {
+  return formatRedisMemberDetail(value).rawText;
+}
+
+const deleteDetails = computed(() => {
+  const pending = pendingDelete.value;
+  if (!pending) return "";
+  const key = formatValue(props.keyDisplay);
+  if (pending.kind === "key") return t("dangerDialog.redisKeyDetails", { key });
+  if (pending.kind === "hash") return t("dangerDialog.redisHashFieldDetails", { key, field: formatValue(pending.field) });
+  if (pending.kind === "list") return t("dangerDialog.redisListItemDetails", { key, index: pending.index });
+  if (pending.kind === "zset") return t("dangerDialog.redisSetMemberDetails", { key, member: formatValue(pending.member) });
+  return t("dangerDialog.redisSetMemberDetails", { key, member: formatValue(pending.member) });
+});
+
+async function load(options: { selectDefaultMember?: boolean } = {}) {
+  const shouldSelectDefaultMember = options.selectDefaultMember ?? true;
+  if (hashSearchTimer) clearTimeout(hashSearchTimer);
+  hashSearchTimer = null;
+  hashSearchRequestId++;
+  hashSearchQuery.value = "";
+  activeHashSearchQuery.value = "";
+  searchLoading.value = false;
+  loading.value = true;
+  try {
+    const loadedValue = await api.redisGetValue(props.connectionId, props.db, props.keyRaw);
+    data.value = loadedValue;
+    emit("loaded", loadedValue);
+    scanCursor.value = redisValueCollectionScanCursor(loadedValue);
+    collectionItems.value = redisValueCollectionItems(loadedValue);
+    isEditing.value = false;
+
+    if (loadedValue.data.kind === "string") {
+      const detail = formatRedisMemberDetail(loadedValue.data.content, { allowJsonText: true });
+      editValue.value = detail.rawText;
+      stringValueView.value = preferredRedisValueFormat(loadedValue.data.content, readPreferredRedisValueFormat(), { allowJsonText: true });
+      clearSelectedMember();
+    } else if (loadedValue.data.kind === "json") {
+      editValue.value = JSON.stringify(loadedValue.data.value, null, 2);
+      redisJsonView.value = "raw";
+      clearSelectedMember();
+    } else if (loadedValue.data.kind === "stream") {
+      if (shouldSelectDefaultMember) selectDefaultMember(loadedValue);
+    } else if (["list", "set", "hash", "zset"].includes(loadedValue.data.kind)) {
+      if (shouldSelectDefaultMember) selectDefaultMember(loadedValue);
+    } else {
+      clearSelectedMember();
+    }
+  } finally {
+    loading.value = false;
+    if (autoRefreshEnabled.value && data.value && data.value.ttl > 0) {
+      startAutoRefresh();
+    }
+  }
+}
+
+async function loadMore() {
+  if (!data.value || !hasMore.value || loadingMore.value || (redisKind.value === "hash" && searchLoading.value)) return;
+  if (!(redisKind.value === "list" || redisKind.value === "set" || redisKind.value === "hash" || redisKind.value === "zset")) return;
+  const keyType = redisKind.value;
+  const hashFilter = keyType === "hash" ? activeHashSearchQuery.value || undefined : undefined;
+  const requestId = hashSearchRequestId;
+  loadingMore.value = true;
+  try {
+    const result = await api.redisLoadMore(props.connectionId, props.db, props.keyRaw, keyType, scanCursor.value!, 200, hashFilter);
+    if (keyType === "hash" && requestId !== hashSearchRequestId) return;
+    const newItems = redisCollectionPageItems(result);
+    collectionItems.value = [...collectionItems.value, ...newItems];
+    scanCursor.value = result.scan_cursor ?? undefined;
+  } finally {
+    loadingMore.value = false;
+  }
+}
+
+async function saveString() {
+  if (!data.value || !stringBlob.value || isBinaryStringValue.value || !stringValueChanged.value) return;
+  await api.redisSetString(props.connectionId, props.db, props.keyRaw, editValue.value);
+  isEditing.value = false;
+  await load();
+}
+
+function handleStringInput() {
+  if (canEditCurrentStringFormat.value) {
+    isEditing.value = stringValueChanged.value;
+  }
+}
+
+function discardStringEdit() {
+  isEditing.value = false;
+  editValue.value = originalStringEditValue.value;
+}
+
+async function saveJson() {
+  if (!data.value || data.value.data.kind !== "json") return;
+  await api.redisJsonSet(props.connectionId, props.db, props.keyRaw, editValue.value);
+  isEditing.value = false;
+  await load();
+}
+
+function handleJsonInput() {
+  if (redisJsonView.value === "raw") {
+    isEditing.value = true;
+  }
+}
+
+function handleFormatJsonEditor() {
+  const result = formatJsonText(editValue.value);
+  if (result != null) {
+    editValue.value = result;
+    isEditing.value = true;
+  } else {
+    toast(t("redis.jsonFormatError"), 3000);
+  }
+}
+
+function handleCompressJsonEditor() {
+  const result = compressJsonText(editValue.value);
+  if (result != null) {
+    editValue.value = result;
+    isEditing.value = true;
+  } else {
+    toast(t("redis.jsonFormatError"), 3000);
+  }
+}
+
+async function applyDeleteKey() {
+  await api.redisDeleteKey(props.connectionId, props.db, props.keyRaw);
+  emit("deleted");
+}
+
+function requestDeleteKey() {
+  pendingDelete.value = { kind: "key" };
+  showDeleteConfirm.value = true;
+}
+
+async function copyValue() {
+  if (!data.value) return;
+  const text = redisValueCopyText(data.value, collectionItems.value);
+  try {
+    await copyToClipboard(text);
+    toast(t("redis.copied"), 2000);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function copyText(text: string) {
+  try {
+    await copyToClipboard(text);
+    toast(t("redis.copied"), 2000);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function escapeRedisArg(val: string): string {
+  return `"${val.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function blobWriteText(blob: RedisBlob): string | null {
+  return redisBlobText(blob);
+}
+
+function generateInsertStatements(): string | null {
+  if (!data.value) return null;
+
+  const key = data.value.key_display;
+  const commands: string[] = [];
+  const total = collectionTotal.value;
+  if (total != null && total > collectionItems.value.length) {
+    commands.push(`-- Note: Only ${collectionItems.value.length} of ${total} items included`);
+  }
+
+  switch (data.value.data.kind) {
+    case "string": {
+      const text = blobWriteText(data.value.data.content);
+      if (text == null) return null;
+      commands.push(`SET ${escapeRedisArg(key)} ${escapeRedisArg(text)}`);
+      break;
+    }
+    case "json": {
+      commands.push(`JSON.SET ${escapeRedisArg(key)} $ ${escapeRedisArg(JSON.stringify(data.value.data.value))}`);
+      break;
+    }
+    case "list": {
+      const items = (collectionItems.value as RedisListItem[]).map((item) => blobWriteText(item.value));
+      if (items.some((item) => item == null)) return null;
+      commands.push(`RPUSH ${escapeRedisArg(key)} ${(items as string[]).map(escapeRedisArg).join(" ")}`);
+      break;
+    }
+    case "set": {
+      const items = (collectionItems.value as RedisSetItem[]).map((item) => blobWriteText(item.member));
+      if (items.some((item) => item == null)) return null;
+      commands.push(`SADD ${escapeRedisArg(key)} ${(items as string[]).map(escapeRedisArg).join(" ")}`);
+      break;
+    }
+    case "zset": {
+      const pairs = (collectionItems.value as RedisZsetItem[]).map((item) => {
+        const member = blobWriteText(item.member);
+        return member == null ? null : `${item.score} ${escapeRedisArg(member)}`;
+      });
+      if (pairs.some((item) => item == null)) return null;
+      commands.push(`ZADD ${escapeRedisArg(key)} ${(pairs as string[]).join(" ")}`);
+      break;
+    }
+    case "hash": {
+      const pairs = (collectionItems.value as RedisHashItem[]).map((item) => {
+        const field = blobWriteText(item.field);
+        const value = blobWriteText(item.value);
+        return field == null || value == null ? null : `${escapeRedisArg(field)} ${escapeRedisArg(value)}`;
+      });
+      if (pairs.some((item) => item == null)) return null;
+      commands.push(`HSET ${escapeRedisArg(key)} ${(pairs as string[]).join(" ")}`);
+      break;
+    }
+    case "stream": {
+      for (const entry of data.value.data.entries) {
+        const fields = entry.fields.map(({ field, value }) => `${escapeRedisArg(field)} ${escapeRedisArg(value)}`).join(" ");
+        commands.push(`XADD ${escapeRedisArg(key)} * ${fields}`);
+      }
+      break;
+    }
+    default:
+      return null;
+  }
+
+  if (data.value.ttl > 0) {
+    commands.push(`EXPIRE ${escapeRedisArg(key)} ${data.value.ttl}`);
+  }
+
+  return commands.join("\n");
+}
+
+async function copyInsertStatement() {
+  const stmt = generateInsertStatements();
+  if (!stmt) {
+    toast(t("redis.copyInsertStatementBinary"), 3000);
+    return;
+  }
+  try {
+    await copyToClipboard(stmt);
+    toast(t("redis.copyInsertStatement"), 2000);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function copyMember(value: unknown) {
+  void copyText(redisMemberCopyText(value));
+}
+
+function selectMember(title: string, value: unknown, context: RedisMemberContext, identity?: string) {
+  const detail = formatRedisMemberDetail(value, { allowJsonText: true });
+  selectedMemberTitle.value = title;
+  selectedMemberRaw.value = value;
+  selectedMemberKey.value = getRedisMemberSelectionKey(title, value, identity);
+  selectedMemberContext.value = context;
+  isEditingMember.value = false;
+  memberEditValue.value = detail.rawText;
+  memberValueView.value = preferredRedisValueFormat(value, readPreferredRedisValueFormat(), { allowJsonText: true });
+}
+
+function clearSelectedMember() {
+  selectedMemberTitle.value = "";
+  selectedMemberRaw.value = "";
+  selectedMemberKey.value = "";
+  selectedMemberContext.value = null;
+  isEditingMember.value = false;
+  memberEditValue.value = "";
+}
+
+function isSelectedMember(title: string, value: unknown, identity?: string) {
+  return selectedMemberKey.value === getRedisMemberSelectionKey(title, value, identity);
+}
+
+function viewMember(title: string, value: unknown, context: RedisMemberContext, identity?: string) {
+  selectMember(title, value, context, identity);
+  showMemberDetail.value = true;
+}
+
+function handleMemberDetailOpenChange(open: boolean) {
+  showMemberDetail.value = open;
+  if (!open) isEditingMember.value = false;
+}
+
+function finishMemberDetailClose() {
+  isEditingMember.value = false;
+}
+
+function stopResizeMemberSheet() {
+  isResizingMemberSheet.value = false;
+  window.removeEventListener("pointermove", resizeMemberSheet);
+  window.removeEventListener("pointerup", stopResizeMemberSheet);
+}
+
+function resizeMemberSheet(event: PointerEvent) {
+  if (!isResizingMemberSheet.value) return;
+  const delta = memberSheetResizeStartX - event.clientX;
+  memberDetailSheetWidth.value = clampRedisMemberDetailSheetWidth(memberSheetResizeStartWidth + delta, window.innerWidth);
+}
+
+function startResizeMemberSheet(event: PointerEvent) {
+  isResizingMemberSheet.value = true;
+  memberSheetResizeStartX = event.clientX;
+  memberSheetResizeStartWidth = memberDetailSheetWidth.value;
+  window.addEventListener("pointermove", resizeMemberSheet);
+  window.addEventListener("pointerup", stopResizeMemberSheet);
+}
+
+function clampHashFieldWidth(width: number) {
+  const containerWidth = hashTableRef.value?.clientWidth ?? 900;
+  const min = 120;
+  const max = Math.max(min, containerWidth - 220);
+  return Math.min(max, Math.max(min, width));
+}
+
+function stopResizeHashColumns() {
+  isResizingHashColumns.value = false;
+  window.removeEventListener("pointermove", resizeHashColumns);
+  window.removeEventListener("pointerup", stopResizeHashColumns);
+}
+
+function resizeHashColumns(event: PointerEvent) {
+  if (!isResizingHashColumns.value) return;
+  const delta = event.clientX - hashResizeStartX;
+  hashFieldWidth.value = clampHashFieldWidth(hashResizeStartWidth + delta);
+}
+
+function startResizeHashColumns(event: PointerEvent) {
+  isResizingHashColumns.value = true;
+  hashResizeStartX = event.clientX;
+  hashResizeStartWidth = hashFieldWidth.value;
+  window.addEventListener("pointermove", resizeHashColumns);
+  window.addEventListener("pointerup", stopResizeHashColumns);
+}
+
+function clampZsetScoreWidth(width: number) {
+  const containerWidth = zsetTableRef.value?.clientWidth ?? 900;
+  const min = 120;
+  const max = Math.max(min, containerWidth - 220);
+  return Math.min(max, Math.max(min, width));
+}
+
+function stopResizeZsetColumns() {
+  isResizingZsetColumns.value = false;
+  window.removeEventListener("pointermove", resizeZsetColumns);
+  window.removeEventListener("pointerup", stopResizeZsetColumns);
+}
+
+function resizeZsetColumns(event: PointerEvent) {
+  if (!isResizingZsetColumns.value) return;
+  const delta = event.clientX - zsetResizeStartX;
+  zsetScoreWidth.value = clampZsetScoreWidth(zsetResizeStartWidth + delta);
+}
+
+function startResizeZsetColumns(event: PointerEvent) {
+  isResizingZsetColumns.value = true;
+  zsetResizeStartX = event.clientX;
+  zsetResizeStartWidth = zsetScoreWidth.value;
+  window.addEventListener("pointermove", resizeZsetColumns);
+  window.addEventListener("pointerup", stopResizeZsetColumns);
+}
+
+function startEditMember() {
+  if (!canEditCurrentMemberFormat.value) return;
+  memberEditValue.value = selectedMemberDetail.value.rawText;
+  isEditingMember.value = true;
+}
+
+function cancelEditMember() {
+  memberEditValue.value = selectedMemberDetail.value.rawText;
+  isEditingMember.value = false;
+}
+
+async function saveMemberEdit() {
+  const context = selectedMemberContext.value;
+  if (!context || !canEditCurrentMemberFormat.value) return;
+  let nextContext: RedisMemberContext = context;
+  savingMember.value = true;
+  try {
+    if (context.kind === "list") {
+      await api.redisListSet(props.connectionId, props.db, props.keyRaw, context.index, memberEditValue.value);
+    } else if (context.kind === "hash") {
+      if (!context.field) return;
+      await api.redisHashSet(props.connectionId, props.db, props.keyRaw, context.field, memberEditValue.value);
+    } else if (context.kind === "set") {
+      if (!context.member) return;
+      await api.redisSetRemove(props.connectionId, props.db, props.keyRaw, context.member);
+      await api.redisSetAdd(props.connectionId, props.db, props.keyRaw, memberEditValue.value);
+      nextContext = { kind: "set", member: memberEditValue.value, canEdit: true };
+    } else if (context.kind === "zset") {
+      if (!context.member) return;
+      await api.redisZrem(props.connectionId, props.db, props.keyRaw, context.member);
+      await api.redisZadd(props.connectionId, props.db, props.keyRaw, memberEditValue.value, Number(context.score));
+      nextContext = { kind: "zset", member: memberEditValue.value, score: context.score, canEdit: true };
+    }
+    const editedValue = memberEditValue.value;
+    isEditingMember.value = false;
+    await load({ selectDefaultMember: false });
+    restoreSelectedMember(nextContext, editedValue);
+  } finally {
+    savingMember.value = false;
+  }
+}
+
+function selectDefaultMember(redisValue: RedisValue) {
+  switch (redisValue.data.kind) {
+    case "list": {
+      const first = redisValue.data.items[0];
+      if (!first) return clearSelectedMember();
+      return selectMember(`#${first.index}`, first.value, { kind: "list", index: first.index, canEdit: canEditRedisMemberDetail("list", first.value) });
+    }
+    case "set": {
+      const first = redisValue.data.items[0];
+      if (!first) return clearSelectedMember();
+      const member = redisBlobText(first.member);
+      return selectMember(t("redis.member"), first.member, { kind: "set", member, canEdit: member != null && canEditRedisMemberDetail("set", first.member) });
+    }
+    case "hash": {
+      const first = redisValue.data.items[0];
+      if (!first) return clearSelectedMember();
+      const field = redisBlobText(first.field);
+      return selectMember(formatValue(first.field), first.value, { kind: "hash", field, canEdit: field != null && canEditRedisMemberDetail("hash", first.value) });
+    }
+    case "zset": {
+      const first = redisValue.data.items[0];
+      if (!first) return clearSelectedMember();
+      const member = redisBlobText(first.member);
+      return selectMember(first.score, first.member, { kind: "zset", member, score: first.score, canEdit: member != null && canEditRedisMemberDetail("zset", first.member) });
+    }
+    case "stream": {
+      const firstEntry = redisValue.data.entries[0];
+      const firstField = firstEntry?.fields[0];
+      if (!firstField) return clearSelectedMember();
+      return selectMember(firstField.field, firstField.value, { kind: "stream", field: firstField.field, canEdit: false }, streamFieldSelectionIdentity(firstEntry.id, 0));
+    }
+    default:
+      clearSelectedMember();
+  }
+}
+
+function streamFieldCount(row: RedisStreamRow): number {
+  return row.entry.fields.length;
+}
+
+function streamFieldSelectionIdentity(entryId: string, fieldIndex: string | number): string {
+  return `stream:${entryId}:${fieldIndex}`;
+}
+
+function collectionRowId(value: RedisCollectionItem, index: number): string {
+  if ("index" in value) return `list-${value.index}`;
+  if ("field" in value) return `hash-${value.field.raw_base64}-${index}`;
+  if ("score" in value) return `zset-${value.member.raw_base64}-${index}`;
+  return `set-${value.member.raw_base64}-${index}`;
+}
+
+function canDeleteHashItem(item: RedisHashItem): boolean {
+  return redisBlobText(item.field) != null;
+}
+
+function canDeleteSetItem(item: RedisSetItem): boolean {
+  return redisBlobText(item.member) != null;
+}
+
+function canDeleteZsetItem(item: RedisZsetItem): boolean {
+  return redisBlobText(item.member) != null;
+}
+
+function restoreSelectedMember(context: RedisMemberContext, fallbackValue: string) {
+  const restored = resolveSelectedMember(context);
+  if (restored) {
+    selectMember(restored.title, restored.value, restored.context);
+    return;
+  }
+  const title = context.kind === "list" ? `#${context.index}` : context.kind === "set" ? t("redis.member") : context.kind === "hash" ? (context.field ?? selectedMemberTitle.value) : context.kind === "zset" ? context.score : context.field;
+  selectMember(title, fallbackValue, context);
+}
+
+function resolveSelectedMember(context: RedisMemberContext): { title: string; value: unknown; context: RedisMemberContext } | null {
+  switch (context.kind) {
+    case "list": {
+      if (redisKind.value !== "list") return null;
+      const item = (collectionItems.value as RedisListItem[]).find((candidate) => candidate.index === context.index);
+      if (!item) return null;
+      return {
+        title: `#${item.index}`,
+        value: item.value,
+        context: { kind: "list", index: item.index, canEdit: canEditRedisMemberDetail("list", item.value) },
+      };
+    }
+    case "set": {
+      if (redisKind.value !== "set" || !context.member) return null;
+      const item = (collectionItems.value as RedisSetItem[]).find((candidate) => redisBlobText(candidate.member) === context.member);
+      if (!item) return null;
+      const member = redisBlobText(item.member);
+      return {
+        title: t("redis.member"),
+        value: item.member,
+        context: { kind: "set", member, canEdit: member != null && canEditRedisMemberDetail("set", item.member) },
+      };
+    }
+    case "hash": {
+      if (redisKind.value !== "hash" || !context.field) return null;
+      const item = (collectionItems.value as RedisHashItem[]).find((candidate) => redisBlobText(candidate.field) === context.field);
+      if (!item) return null;
+      const field = redisBlobText(item.field);
+      return {
+        title: formatValue(item.field),
+        value: item.value,
+        context: { kind: "hash", field, canEdit: field != null && canEditRedisMemberDetail("hash", item.value) },
+      };
+    }
+    case "zset": {
+      if (redisKind.value !== "zset" || !context.member) return null;
+      const item = (collectionItems.value as RedisZsetItem[]).find((candidate) => redisBlobText(candidate.member) === context.member && candidate.score === context.score);
+      if (!item) return null;
+      const member = redisBlobText(item.member);
+      return {
+        title: item.score,
+        value: item.member,
+        context: { kind: "zset", member, score: item.score, canEdit: member != null && canEditRedisMemberDetail("zset", item.member) },
+      };
+    }
+    case "stream":
+      return null;
+  }
+}
+
+function requestHashDel(field: string | null) {
+  if (!field) return;
+  pendingDelete.value = { kind: "hash", field };
+  showDeleteConfirm.value = true;
+}
+
+function requestSetRemove(member: string | null) {
+  if (!member) return;
+  pendingDelete.value = { kind: "set", member };
+  showDeleteConfirm.value = true;
+}
+
+function requestZsetRemove(member: string | null) {
+  if (!member) return;
+  pendingDelete.value = { kind: "zset", member };
+  showDeleteConfirm.value = true;
+}
+
+// TTL
+function startEditTtl() {
+  if (!data.value) return;
+  ttlInput.value = data.value.ttl > 0 ? String(data.value.ttl) : "";
+  editingTtl.value = true;
+  void nextTick(() => ttlInputEl.value?.$el?.focus());
+}
+
+async function saveTtl() {
+  const val = ttlInput.value.trim();
+  const ttl = val === "" || val === "-1" ? -1 : parseInt(val, 10);
+  if (isNaN(ttl)) {
+    toast(t("redis.ttlInvalid"), 3000);
+    return;
+  }
+  await api.redisSetTtl(props.connectionId, props.db, props.keyRaw, ttl);
+  editingTtl.value = false;
+  await load();
+}
+
+function cancelEditTtl() {
+  editingTtl.value = false;
+}
+
+// Hash
+async function hashSet() {
+  if (!newField.value.trim()) {
+    toast(t("redis.fieldRequired"), 3000);
+    return;
+  }
+  await api.redisHashSet(props.connectionId, props.db, props.keyRaw, newField.value, newValue.value);
+  newField.value = "";
+  newValue.value = "";
+  await load();
+}
+async function applyHashDel(field: string) {
+  await api.redisHashDel(props.connectionId, props.db, props.keyRaw, field);
+  await load();
+}
+
+// List
+async function listPush() {
+  if (!newValue.value.trim()) {
+    toast(t("redis.valueRequired"), 3000);
+    return;
+  }
+  await api.redisListPush(props.connectionId, props.db, props.keyRaw, newValue.value);
+  newValue.value = "";
+  await load();
+}
+async function applyListRemove(index: number) {
+  await api.redisListRemove(props.connectionId, props.db, props.keyRaw, index);
+  await load();
+}
+function requestListRemove(index: number) {
+  pendingDelete.value = { kind: "list", index };
+  showDeleteConfirm.value = true;
+}
+
+// Set
+async function setAdd() {
+  if (!newValue.value.trim()) {
+    toast(t("redis.memberRequired"), 3000);
+    return;
+  }
+  await api.redisSetAdd(props.connectionId, props.db, props.keyRaw, newValue.value);
+  newValue.value = "";
+  await load();
+}
+async function applySetRemove(member: string) {
+  await api.redisSetRemove(props.connectionId, props.db, props.keyRaw, member);
+  await load();
+}
+
+// ZSet
+async function zsetAdd() {
+  if (!newValue.value.trim()) {
+    toast(t("redis.memberRequired"), 3000);
+    return;
+  }
+  const score = parseFloat(newScore.value || "0");
+  await api.redisZadd(props.connectionId, props.db, props.keyRaw, newValue.value, score);
+  newValue.value = "";
+  newScore.value = "";
+  await load();
+}
+async function applyZsetRemove(member: string) {
+  await api.redisZrem(props.connectionId, props.db, props.keyRaw, member);
+  await load();
+}
+
+async function confirmDelete() {
+  const pending = pendingDelete.value;
+  if (!pending) return;
+  if (pending.kind === "key") await applyDeleteKey();
+  else if (pending.kind === "hash") await applyHashDel(pending.field);
+  else if (pending.kind === "list") await applyListRemove(pending.index);
+  else if (pending.kind === "set") await applySetRemove(pending.member);
+  else if (pending.kind === "zset") await applyZsetRemove(pending.member);
+  pendingDelete.value = null;
+}
+
+function formatValue(val: unknown): string {
+  if (isRedisBlob(val)) return formatRedisMemberDetail(val).text;
+  if (typeof val === "string") return formatRedisMemberDetail(val).text;
+  return JSON.stringify(val, null, 2);
+}
+
+onMounted(() => {
+  void load();
+  void createShikiJsonHighlighter({
+    appearance: () => redisJsonAppearance.value,
+  })
+    .then((highlight) => {
+      redisJsonHighlighter.value = highlight;
+    })
+    .catch(() => {
+      redisJsonHighlighter.value = undefined;
+    });
+});
+onBeforeUnmount(() => {
+  stopAutoRefresh();
+  stopResizeMemberSheet();
+  stopResizeHashColumns();
+  stopResizeZsetColumns();
+  if (hashSearchTimer) clearTimeout(hashSearchTimer);
+});
+</script>
+
+<template>
+  <div class="h-full flex flex-col overflow-hidden" :style="editorFontFamilyStyle">
+    <div v-if="loading" class="flex-1 flex items-center justify-center text-muted-foreground">
+      {{ t("common.loading") }}
+    </div>
+
+    <template v-else-if="data">
+      <!-- Header -->
+      <div class="shrink-0 border-b bg-background">
+        <div class="flex h-9 items-center gap-2 px-4">
+          <span class="dbx-editor-font-family min-w-0 flex-1 truncate text-sm font-semibold">{{ formatValue(data.key_display) }}</span>
+          <Button variant="ghost" size="icon" class="h-7 w-7 shrink-0 animate-none" @click="load"><RefreshCw class="h-3.5 w-3.5 animate-none" /></Button>
+          <Button variant="ghost" size="icon" class="h-7 w-7 shrink-0" @click="copyValue"><Copy class="h-3.5 w-3.5" /></Button>
+          <Button variant="ghost" size="icon" class="h-7 w-7 shrink-0" :title="t('redis.copyInsertStatement')" @click="copyInsertStatement"><Terminal class="h-3.5 w-3.5" /></Button>
+          <Button variant="ghost" size="icon" class="h-7 w-7 shrink-0 text-destructive" @click="requestDeleteKey"><Trash2 class="h-3.5 w-3.5" /></Button>
+        </div>
+
+        <div class="flex min-h-7 flex-wrap items-center gap-2 px-4 pb-1">
+          <Badge variant="secondary" class="dbx-editor-font-family text-xs uppercase">{{ data.redis_type }}</Badge>
+          <Badge v-if="metadataSizeLabel" variant="outline" class="text-xs text-muted-foreground"> {{ t("redis.columnSize") }}: {{ metadataSizeLabel }} </Badge>
+          <template v-if="!editingTtl">
+            <Badge v-if="data.ttl > 0" variant="outline" class="text-xs cursor-pointer text-muted-foreground hover:bg-accent" @click="startEditTtl">TTL: {{ formatTtl(computeDisplayTtl(autoRefreshEnabled, countdownTtl, data.ttl), t) }}</Badge>
+            <Badge v-else-if="data.ttl === -1" variant="outline" class="text-xs cursor-pointer text-muted-foreground hover:bg-accent" @click="startEditTtl">{{ t("redis.noExpiry") }}</Badge>
+          </template>
+          <div ref="editTtlWrapper" v-else class="flex items-center gap-1">
+            <Input ref="ttlInputEl" v-model="ttlInput" class="h-6 w-20 text-xs" placeholder="seconds (-1=no expiry)" @keydown.enter="saveTtl" @keydown.escape="cancelEditTtl" />
+            <Button variant="ghost" size="icon" class="h-6 w-6" @click="saveTtl"><Save class="h-3 w-3" /></Button>
+          </div>
+          <Button variant="ghost" size="icon" class="h-6 w-6 shrink-0" :class="{ 'text-primary bg-accent': autoRefreshEnabled }" :title="t('redis.autoRefresh')" @click="toggleAutoRefresh">
+            <Clock class="h-3.5 w-3.5" />
+          </Button>
+        </div>
+      </div>
+
+      <!-- String -->
+      <div v-if="isStringLikeKind && stringValueDetail" class="flex-1 flex flex-col overflow-hidden">
+        <div class="flex h-9 items-center gap-2 border-b px-4 text-xs shrink-0">
+          <div class="flex max-w-full overflow-x-auto rounded-md border bg-muted/20 p-0.5">
+            <Button
+              v-for="format in REDIS_VALUE_FORMAT_DISPLAY_ORDER"
+              :key="format"
+              variant="ghost"
+              size="sm"
+              class="h-6 shrink-0 rounded-[5px] px-2 text-xs"
+              :class="{ 'bg-background shadow-sm': stringValueView === format }"
+              :disabled="!canRenderRedisValueFormat(stringValueDetail, format)"
+              @click="setStringValueFormat(format)"
+            >
+              {{ redisFormatLabel(format, stringValueDetail.rawLabel) }}
+            </Button>
+          </div>
+          <span class="flex-1" />
+          <label v-if="isTextRedisFormat(stringValueView)" class="flex items-center gap-1.5 text-muted-foreground">
+            <WrapText class="h-3.5 w-3.5" />
+            {{ t("redis.wordWrap") }}
+            <Switch size="sm" :model-value="redisJsonWordWrap" @update:model-value="setRedisJsonWordWrap(Boolean($event))" />
+          </label>
+        </div>
+        <div v-if="stringValueView === 'json' && stringValueDetail.json" class="dbx-editor-font-family min-h-0 flex-1 overflow-auto bg-background p-4 text-sm leading-6">
+          <JsonTree :value="stringValueDetail.json.value" :word-wrap="redisJsonWordWrap" :highlight-json="highlightRedisJson" />
+        </div>
+        <div v-else-if="stringValueView === 'javaserialize' && stringValueDetail.javaSerialized" class="dbx-editor-font-family min-h-0 flex-1 overflow-auto bg-background p-4 text-sm leading-6">
+          <JsonTree :value="stringValueDetail.javaSerialized.value" :word-wrap="redisJsonWordWrap" :highlight-json="highlightRedisJson" />
+        </div>
+        <div v-else-if="stringValueView === 'hex'" class="min-h-0 flex-1 overflow-auto bg-background p-4 text-xs leading-5">
+          <div class="mb-3 flex items-center justify-between text-muted-foreground">
+            <span>{{ t("grid.hexViewer") }}</span>
+            <span>{{ t("grid.hexViewerByteCount", { count: stringValueDetail.byteCount }) }}</span>
+          </div>
+          <pre v-if="stringValueDetail.hexRows.length > 0" class="dbx-editor-font-family w-full min-w-0 max-w-full select-all whitespace-pre-wrap break-all">{{ detailTextForFormat(stringValueDetail, "hex") }}</pre>
+          <div v-else class="text-muted-foreground">{{ t("grid.hexViewerEmpty") }}</div>
+        </div>
+        <pre v-else-if="stringValueView === 'base64'" class="dbx-editor-font-family min-h-0 w-full min-w-0 max-w-full flex-1 overflow-auto bg-background p-4 text-sm leading-6 whitespace-pre-wrap break-all">{{ stringValueDetail.base64Text }}</pre>
+        <textarea
+          v-else-if="stringValueView === 'utf8' && canEditCurrentStringFormat"
+          v-model="editValue"
+          class="dbx-editor-font-family flex-1 resize-none bg-background p-4 text-sm outline-none"
+          :class="redisJsonWordWrap ? 'whitespace-pre-wrap break-words' : 'whitespace-pre'"
+          :readonly="!canEditCurrentStringFormat"
+          spellcheck="false"
+          @input="handleStringInput"
+        />
+        <pre v-else-if="stringValueView === 'utf8'" class="dbx-editor-font-family min-h-0 w-full min-w-0 max-w-full flex-1 overflow-auto bg-background p-4 text-sm leading-6" :class="detailTextClass(stringValueView)">{{ detailTextForFormat(stringValueDetail, stringValueView) }}</pre>
+        <pre v-else class="dbx-editor-font-family min-h-0 w-full min-w-0 max-w-full flex-1 overflow-auto bg-background p-4 text-sm leading-6" :class="detailTextClass(stringValueView)">{{ detailTextForFormat(stringValueDetail, stringValueView) }}</pre>
+        <div v-if="isBinaryStringValue" class="px-4 py-2 border-t text-xs text-muted-foreground shrink-0">
+          {{ t("redis.binaryStringReadonlyHint") }}
+        </div>
+        <div v-if="showStringEditActions" class="px-4 py-2 border-t flex justify-end gap-2 shrink-0">
+          <Button variant="ghost" size="sm" :disabled="!stringValueChanged" @click="discardStringEdit">{{ t("grid.discard") }}</Button>
+          <Button size="sm" :disabled="!stringValueChanged" @click="saveString"><Save class="w-3 h-3 mr-1" /> {{ t("grid.save") }}</Button>
+        </div>
+      </div>
+
+      <!-- Redis JSON -->
+      <div v-else-if="redisKind === 'json' && redisJsonValue != null" class="flex-1 flex flex-col overflow-hidden">
+        <div class="flex h-9 items-center gap-2 border-b px-4 text-xs shrink-0">
+          <div class="flex overflow-hidden rounded-md border bg-muted/20 p-0.5">
+            <Button variant="ghost" size="sm" class="h-6 rounded-[5px] px-2 text-xs" :class="{ 'bg-background shadow-sm': redisJsonView === 'raw' }" @click="redisJsonView = 'raw'">
+              {{ t("redis.rawContent") }}
+            </Button>
+            <Button variant="ghost" size="sm" class="h-6 rounded-[5px] px-2 text-xs" :class="{ 'bg-background shadow-sm': redisJsonView === 'tree' }" @click="redisJsonView = 'tree'">
+              {{ t("redis.jsonView") }}
+            </Button>
+          </div>
+          <span class="flex-1" />
+          <Button v-if="redisJsonView === 'raw'" variant="ghost" size="sm" class="h-6 rounded-[5px] px-2 text-xs" :title="t('redis.formatJson')" @click="handleFormatJsonEditor">
+            <IndentIncrease class="h-3.5 w-3.5" />
+          </Button>
+          <Button v-if="redisJsonView === 'raw'" variant="ghost" size="sm" class="h-6 rounded-[5px] px-2 text-xs" :title="t('redis.compressJson')" @click="handleCompressJsonEditor">
+            <IndentDecrease class="h-3.5 w-3.5" />
+          </Button>
+          <label v-if="redisJsonView === 'raw'" class="flex items-center gap-1.5 text-muted-foreground">
+            <WrapText class="h-3.5 w-3.5" />
+            {{ t("redis.wordWrap") }}
+            <Switch size="sm" :model-value="redisJsonWordWrap" @update:model-value="setRedisJsonWordWrap(Boolean($event))" />
+          </label>
+        </div>
+        <div v-if="redisJsonView === 'tree'" class="dbx-editor-font-family min-h-0 flex-1 overflow-auto bg-background p-4 text-sm leading-6">
+          <JsonTree :value="redisJsonValue" :word-wrap="redisJsonWordWrap" :highlight-json="highlightRedisJson" />
+        </div>
+        <textarea v-else v-model="editValue" class="dbx-editor-font-family flex-1 resize-none bg-background p-4 text-sm outline-none" :class="redisJsonWordWrap ? 'whitespace-pre-wrap break-words' : 'whitespace-pre'" spellcheck="false" @input="handleJsonInput" />
+        <div v-if="isEditing" class="px-4 py-2 border-t flex justify-end gap-2 shrink-0">
+          <Button
+            variant="ghost"
+            size="sm"
+            @click="
+              isEditing = false;
+              editValue = JSON.stringify(redisJsonValue, null, 2);
+            "
+            >{{ t("grid.discard") }}</Button
+          >
+          <Button size="sm" @click="saveJson"><Save class="w-3 h-3 mr-1" /> {{ t("grid.save") }}</Button>
+        </div>
+      </div>
+
+      <!-- List -->
+      <div v-else-if="redisKind === 'list'" class="flex-1 flex flex-col overflow-hidden">
+        <div class="flex items-center gap-2 px-4 py-1.5 border-b shrink-0">
+          <span class="text-xs text-muted-foreground">{{ collectionCountLabel("items", listRows.length, collectionTotal) }}</span>
+          <span class="flex-1" />
+          <Input v-model="newValue" class="h-6 w-40 text-xs" placeholder="value" @keydown.enter="listPush" />
+          <Button variant="ghost" size="sm" class="h-6 text-xs" @click="listPush"><Plus class="w-3 h-3 mr-1" />Push</Button>
+        </div>
+        <div class="grid grid-cols-[60px_1fr_84px] border-b bg-muted/50 shrink-0">
+          <div class="px-3 py-1 text-xs font-medium text-muted-foreground border-r">#</div>
+          <div class="px-3 py-1 text-xs font-medium text-muted-foreground">Value</div>
+          <div />
+        </div>
+        <RecycleScroller class="flex-1 overflow-y-auto" :items="listRows" :item-size="REDIS_COLLECTION_ROW_HEIGHT" :buffer="600" :skip-hover="true" key-field="id">
+          <template #default="{ item: row }">
+            <div
+              data-redis-value-row
+              class="dbx-editor-font-family grid grid-cols-[60px_1fr_84px] border-b text-sm hover:bg-accent/50 group cursor-pointer"
+              :class="{ 'bg-accent/60': isSelectedMember(`#${row.value.index}`, row.value.value) }"
+              :style="{ height: `${REDIS_COLLECTION_ROW_HEIGHT}px` }"
+              @click="viewMember(`#${row.value.index}`, row.value.value, { kind: 'list', index: row.value.index, canEdit: canEditRedisMemberDetail('list', row.value.value) })"
+            >
+              <div class="px-3 py-1.5 text-xs text-muted-foreground border-r">{{ row.value.index }}</div>
+              <div class="px-3 py-1.5 truncate">{{ formatValue(row.value.value) }}</div>
+              <div class="flex items-center justify-center gap-1">
+                <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100" :title="t('redis.viewMember')" @click.stop="viewMember(`#${row.value.index}`, row.value.value, { kind: 'list', index: row.value.index, canEdit: canEditRedisMemberDetail('list', row.value.value) })"
+                  ><Eye class="w-3 h-3"
+                /></Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100" :title="t('redis.copyMember')" @click.stop="copyMember(row.value.value)"><Copy class="w-3 h-3" /></Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100 text-destructive" @click.stop="requestListRemove(row.value.index)"><Trash2 class="w-3 h-3" /></Button>
+              </div>
+            </div>
+          </template>
+          <template #after>
+            <div v-if="hasMore" class="p-2">
+              <Button variant="outline" size="sm" class="w-full h-7 text-xs" :disabled="loadingMore" @click="loadMore">
+                <Loader2 v-if="loadingMore" class="w-3 h-3 mr-1.5 animate-spin" />
+                {{ t("redis.loadMoreKeys") }}
+              </Button>
+            </div>
+          </template>
+        </RecycleScroller>
+      </div>
+
+      <!-- Set -->
+      <div v-else-if="redisKind === 'set'" class="flex-1 flex flex-col overflow-hidden">
+        <div class="flex items-center gap-2 px-4 py-1.5 border-b shrink-0">
+          <span class="text-xs text-muted-foreground">{{ collectionCountLabel("items", setRows.length, collectionTotal) }}</span>
+          <span class="flex-1" />
+          <Input v-model="newValue" class="h-6 w-40 text-xs" placeholder="member" @keydown.enter="setAdd" />
+          <Button variant="ghost" size="sm" class="h-6 text-xs" @click="setAdd"><Plus class="w-3 h-3 mr-1" />Add</Button>
+        </div>
+        <div class="grid grid-cols-[1fr_84px] border-b bg-muted/50 shrink-0">
+          <div class="px-3 py-1 text-xs font-medium text-muted-foreground">Member</div>
+          <div />
+        </div>
+        <RecycleScroller class="flex-1 overflow-y-auto" :items="setRows" :item-size="REDIS_COLLECTION_ROW_HEIGHT" :buffer="600" :skip-hover="true" key-field="id">
+          <template #default="{ item: row }">
+            <div
+              data-redis-value-row
+              class="dbx-editor-font-family grid grid-cols-[1fr_84px] border-b text-sm hover:bg-accent/50 group cursor-pointer"
+              :class="{ 'bg-accent/60': isSelectedMember(t('redis.member'), row.value.member) }"
+              :style="{ height: `${REDIS_COLLECTION_ROW_HEIGHT}px` }"
+              @click="viewMember(t('redis.member'), row.value.member, { kind: 'set', member: redisBlobText(row.value.member), canEdit: redisBlobText(row.value.member) != null && canEditRedisMemberDetail('set', row.value.member) })"
+            >
+              <div class="px-3 py-1.5 truncate">{{ formatValue(row.value.member) }}</div>
+              <div class="flex items-center justify-center gap-1">
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  class="h-5 w-5 opacity-0 group-hover:opacity-100"
+                  :title="t('redis.viewMember')"
+                  @click.stop="viewMember(t('redis.member'), row.value.member, { kind: 'set', member: redisBlobText(row.value.member), canEdit: redisBlobText(row.value.member) != null && canEditRedisMemberDetail('set', row.value.member) })"
+                  ><Eye class="w-3 h-3"
+                /></Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100" :title="t('redis.copyMember')" @click.stop="copyMember(row.value.member)"><Copy class="w-3 h-3" /></Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100 text-destructive" :disabled="!canDeleteSetItem(row.value)" @click.stop="requestSetRemove(redisBlobText(row.value.member))"><Trash2 class="w-3 h-3" /></Button>
+              </div>
+            </div>
+          </template>
+          <template #after>
+            <div v-if="hasMore" class="p-2">
+              <Button variant="outline" size="sm" class="w-full h-7 text-xs" :disabled="loadingMore" @click="loadMore">
+                <Loader2 v-if="loadingMore" class="w-3 h-3 mr-1.5 animate-spin" />
+                {{ t("redis.loadMoreKeys") }}
+              </Button>
+            </div>
+          </template>
+        </RecycleScroller>
+      </div>
+
+      <!-- Hash -->
+      <div v-else-if="redisKind === 'hash'" ref="hashTableRef" class="flex-1 flex flex-col overflow-hidden">
+        <div class="flex items-center gap-2 px-4 py-1.5 border-b shrink-0">
+          <span class="text-xs text-muted-foreground shrink-0">{{ collectionCountLabel("fields", hashCollectionRows.length, activeHashSearchQuery ? null : collectionTotal) }}</span>
+          <div class="relative flex-1 max-w-60">
+            <Search class="pointer-events-none absolute left-1.5 top-1/2 h-3 w-3 -translate-y-1/2 text-muted-foreground/80" />
+            <Input v-model="hashSearchQuery" class="h-6 w-full pl-5 pr-2 text-xs" :placeholder="t('redis.searchFields')" @input="onHashSearchInput" @keydown="onHashSearchKeydown" />
+          </div>
+          <span class="flex-1" />
+          <Input v-model="newField" class="h-6 w-24 text-xs" placeholder="field" />
+          <Input v-model="newValue" class="h-6 w-32 text-xs" placeholder="value" @keydown.enter="hashSet" />
+          <Button variant="ghost" size="sm" class="h-6 text-xs" @click="hashSet"><Plus class="w-3 h-3 mr-1" />Set</Button>
+        </div>
+        <div class="grid border-b bg-muted/50 shrink-0" :style="hashGridStyle">
+          <div
+            class="relative px-3 py-1 text-xs font-medium text-muted-foreground border-r select-none cursor-pointer hover:bg-accent/50 flex items-center gap-1"
+            role="columnheader"
+            :aria-sort="hashSortBy === 'field' ? (hashSortDir === 'asc' ? 'ascending' : 'descending') : 'none'"
+            @click="toggleHashSort('field')"
+          >
+            Field
+            <ArrowUp v-if="hashSortBy === 'field' && hashSortDir === 'asc'" class="h-3 w-3 shrink-0" />
+            <ArrowDown v-else-if="hashSortBy === 'field' && hashSortDir === 'desc'" class="h-3 w-3 shrink-0" />
+            <ArrowUpDown v-else class="h-3 w-3 shrink-0 text-muted-foreground/40" />
+            <div class="absolute -right-1 top-0 h-full w-2 cursor-col-resize touch-none" @pointerdown.prevent="startResizeHashColumns" />
+          </div>
+          <div class="px-3 py-1 text-xs font-medium text-muted-foreground cursor-pointer hover:bg-accent/50 flex items-center gap-1 select-none" role="columnheader" :aria-sort="hashSortBy === 'value' ? (hashSortDir === 'asc' ? 'ascending' : 'descending') : 'none'" @click="toggleHashSort('value')">
+            Value
+            <ArrowUp v-if="hashSortBy === 'value' && hashSortDir === 'asc'" class="h-3 w-3 shrink-0" />
+            <ArrowDown v-else-if="hashSortBy === 'value' && hashSortDir === 'desc'" class="h-3 w-3 shrink-0" />
+            <ArrowUpDown v-else class="h-3 w-3 shrink-0 text-muted-foreground/40" />
+          </div>
+          <div />
+        </div>
+        <RecycleScroller class="flex-1 overflow-y-auto" :items="hashCollectionRows" :item-size="REDIS_COLLECTION_ROW_HEIGHT" :buffer="600" :skip-hover="true" key-field="id">
+          <template #default="{ item: row }">
+            <div
+              data-redis-value-row
+              class="dbx-editor-font-family grid border-b text-sm hover:bg-accent/50 group cursor-pointer"
+              :style="{ ...hashGridStyle, height: `${REDIS_COLLECTION_ROW_HEIGHT}px` }"
+              :class="{ 'bg-accent/60': isSelectedMember(formatValue(row.value.field), row.value.value) }"
+              @click="viewMember(formatValue(row.value.field), row.value.value, { kind: 'hash', field: redisBlobText(row.value.field), canEdit: redisBlobText(row.value.field) != null && canEditRedisMemberDetail('hash', row.value.value) })"
+            >
+              <div class="px-3 py-1.5 text-blue-500 truncate border-r">{{ formatValue(row.value.field) }}</div>
+              <div class="px-3 py-1.5 truncate text-muted-foreground">{{ formatValue(row.value.value) }}</div>
+              <div class="flex items-center justify-center gap-1">
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  class="h-5 w-5 opacity-0 group-hover:opacity-100"
+                  :title="t('redis.viewMember')"
+                  @click.stop="viewMember(formatValue(row.value.field), row.value.value, { kind: 'hash', field: redisBlobText(row.value.field), canEdit: redisBlobText(row.value.field) != null && canEditRedisMemberDetail('hash', row.value.value) })"
+                  ><Eye class="w-3 h-3"
+                /></Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100" :title="t('redis.copyMember')" @click.stop="copyMember(row.value.value)"><Copy class="w-3 h-3" /></Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100 text-destructive" :disabled="!canDeleteHashItem(row.value)" @click.stop="requestHashDel(redisBlobText(row.value.field))"><Trash2 class="w-3 h-3" /></Button>
+              </div>
+            </div>
+          </template>
+          <template #after>
+            <div v-if="hasMore" class="p-2">
+              <Button variant="outline" size="sm" class="w-full h-7 text-xs" :disabled="loadingMore || searchLoading" @click="loadMore">
+                <Loader2 v-if="loadingMore" class="w-3 h-3 mr-1.5 animate-spin" />
+                {{ t("redis.loadMoreKeys") }}
+              </Button>
+            </div>
+          </template>
+        </RecycleScroller>
+      </div>
+
+      <!-- Sorted Set -->
+      <div v-else-if="redisKind === 'zset'" ref="zsetTableRef" class="flex-1 flex flex-col overflow-hidden">
+        <div class="flex items-center gap-2 px-4 py-1.5 border-b shrink-0">
+          <span class="text-xs text-muted-foreground">{{ collectionCountLabel("members", zsetRows.length, collectionTotal) }}</span>
+          <span class="flex-1" />
+          <Input v-model="newScore" class="h-6 w-20 text-xs" placeholder="score" />
+          <Input v-model="newValue" class="h-6 w-32 text-xs" placeholder="member" @keydown.enter="zsetAdd" />
+          <Button variant="ghost" size="sm" class="h-6 text-xs" @click="zsetAdd"><Plus class="w-3 h-3 mr-1" />Add</Button>
+        </div>
+        <div class="grid border-b bg-muted/50 shrink-0" :style="zsetGridStyle">
+          <div class="relative px-3 py-1 text-xs font-medium text-muted-foreground border-r select-none">
+            Score
+            <div class="absolute -right-1 top-0 h-full w-2 cursor-col-resize touch-none" @pointerdown.prevent="startResizeZsetColumns" />
+          </div>
+          <div class="px-3 py-1 text-xs font-medium text-muted-foreground min-w-0">Member</div>
+          <div />
+        </div>
+        <RecycleScroller class="flex-1 overflow-y-auto" :items="zsetRows" :item-size="REDIS_COLLECTION_ROW_HEIGHT" :buffer="600" :skip-hover="true" key-field="id">
+          <template #default="{ item: row }">
+            <div
+              data-redis-value-row
+              class="dbx-editor-font-family grid border-b text-sm hover:bg-accent/50 group cursor-pointer"
+              :class="{ 'bg-accent/60': isSelectedMember(String(row.value.score), row.value.member) }"
+              :style="{ ...zsetGridStyle, height: `${REDIS_COLLECTION_ROW_HEIGHT}px` }"
+              @click="viewMember(row.value.score, row.value.member, { kind: 'zset', member: redisBlobText(row.value.member), score: row.value.score, canEdit: redisBlobText(row.value.member) != null && canEditRedisMemberDetail('zset', row.value.member) })"
+            >
+              <div class="px-3 py-1.5 text-muted-foreground text-xs border-r min-w-0 truncate" :title="String(row.value.score)">
+                {{ row.value.score }}
+              </div>
+              <div class="px-3 py-1.5 min-w-0 truncate" :title="formatValue(row.value.member)">
+                {{ formatValue(row.value.member) }}
+              </div>
+              <div class="flex items-center justify-center gap-1">
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  class="h-5 w-5 opacity-0 group-hover:opacity-100"
+                  :title="t('redis.viewMember')"
+                  @click.stop="viewMember(row.value.score, row.value.member, { kind: 'zset', member: redisBlobText(row.value.member), score: row.value.score, canEdit: redisBlobText(row.value.member) != null && canEditRedisMemberDetail('zset', row.value.member) })"
+                  ><Eye class="w-3 h-3"
+                /></Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100" :title="t('redis.copyMember')" @click.stop="copyMember(row.value.member)"><Copy class="w-3 h-3" /></Button>
+                <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100 text-destructive" :disabled="!canDeleteZsetItem(row.value)" @click.stop="requestZsetRemove(redisBlobText(row.value.member))"><Trash2 class="w-3 h-3" /></Button>
+              </div>
+            </div>
+          </template>
+          <template #after>
+            <div v-if="hasMore" class="p-2">
+              <Button variant="outline" size="sm" class="w-full h-7 text-xs" :disabled="loadingMore" @click="loadMore">
+                <Loader2 v-if="loadingMore" class="w-3 h-3 mr-1.5 animate-spin" />
+                {{ t("redis.loadMoreKeys") }}
+              </Button>
+            </div>
+          </template>
+        </RecycleScroller>
+      </div>
+
+      <!-- Stream (readonly) -->
+      <div v-else-if="redisKind === 'stream'" class="flex-1 flex flex-col overflow-hidden">
+        <div class="px-4 py-1 text-xs text-muted-foreground border-b shrink-0">
+          {{ t("redis.entries", { count: streamRows.length }) }}
+        </div>
+        <DynamicScroller class="flex-1 overflow-y-auto" :items="streamRows" :min-item-size="REDIS_STREAM_MIN_ROW_HEIGHT" :buffer="600" key-field="id">
+          <template #default="{ item: row, active }">
+            <DynamicScrollerItem :item="row" :active="active" :size-dependencies="[streamFieldCount(row)]" :data-index="row.index">
+              <div data-redis-stream-entry class="dbx-editor-font-family px-4 py-2 border-b text-sm hover:bg-accent/50">
+                <div class="mb-1 text-xs text-muted-foreground">{{ row.entry.id }}</div>
+                <div
+                  v-for="(field, fieldIndex) in row.entry.fields"
+                  :key="`${row.id}:${field.field}:${fieldIndex}`"
+                  class="grid grid-cols-[minmax(6rem,0.35fr)_1fr_56px] gap-3 py-0.5 group cursor-pointer"
+                  :class="{ 'bg-accent/60': isSelectedMember(field.field, field.value, streamFieldSelectionIdentity(row.entry.id, fieldIndex)) }"
+                  @click="viewMember(field.field, field.value, { kind: 'stream', field: field.field, canEdit: false }, streamFieldSelectionIdentity(row.entry.id, fieldIndex))"
+                >
+                  <span class="truncate text-blue-500">{{ field.field }}</span>
+                  <span class="truncate text-muted-foreground">{{ field.value }}</span>
+                  <span class="flex justify-end gap-1">
+                    <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100" :title="t('redis.viewMember')" @click.stop="viewMember(field.field, field.value, { kind: 'stream', field: field.field, canEdit: false }, streamFieldSelectionIdentity(row.entry.id, fieldIndex))"
+                      ><Eye class="w-3 h-3"
+                    /></Button>
+                    <Button variant="ghost" size="icon" class="h-5 w-5 opacity-0 group-hover:opacity-100" :title="t('redis.copyMember')" @click.stop="copyMember(field.value)"><Copy class="w-3 h-3" /></Button>
+                  </span>
+                </div>
+              </div>
+            </DynamicScrollerItem>
+          </template>
+        </DynamicScroller>
+      </div>
+
+      <!-- Unknown -->
+      <div v-else class="flex-1 overflow-auto p-4">
+        <pre class="dbx-editor-font-family text-sm whitespace-pre-wrap">{{ formatValue(data.data) }}</pre>
+      </div>
+    </template>
+
+    <DangerConfirmDialog v-model:open="showDeleteConfirm" :message="t('dangerDialog.deleteMessage')" :details="deleteDetails" :confirm-label="t('dangerDialog.deleteConfirm')" @confirm="confirmDelete" />
+
+    <Sheet :open="showMemberDetail" @update:open="handleMemberDetailOpenChange">
+      <SheetContent
+        side="right"
+        class="gap-0 p-0 sm:max-w-[calc(100vw-2rem)]"
+        :class="{ 'select-none': isResizingMemberSheet }"
+        :style="[editorFontFamilyStyle, { width: `${memberDetailSheetWidth}px`, maxWidth: 'calc(100vw - 2rem)' }]"
+        @close-auto-focus="finishMemberDetailClose"
+        @pointer-down-outside.prevent
+        @interact-outside.prevent
+      >
+        <div class="absolute inset-y-0 left-0 z-10 w-2 -translate-x-1 cursor-col-resize border-l border-transparent hover:border-primary/60" @pointerdown.prevent="startResizeMemberSheet" />
+        <SheetHeader class="border-b px-5 py-4 pr-12">
+          <SheetTitle class="flex items-center gap-2">
+            <span class="truncate">{{ selectedMemberTitle ? formatValue(selectedMemberTitle) : t("redis.memberDetail") }}</span>
+            <Badge variant="outline" class="shrink-0 text-xs">{{ redisFormatLabel(memberValueView, selectedMemberDetail.rawLabel) }}</Badge>
+          </SheetTitle>
+        </SheetHeader>
+        <template v-if="isEditingMember">
+          <textarea v-model="memberEditValue" class="dbx-editor-font-family min-h-0 flex-1 resize-none bg-background p-5 text-[13px] leading-6 outline-none" spellcheck="false" />
+        </template>
+        <template v-else>
+          <div class="flex h-9 items-center gap-2 border-b px-5 text-xs">
+            <div class="flex max-w-full overflow-x-auto rounded-md border bg-muted/20 p-0.5">
+              <Button
+                v-for="format in REDIS_VALUE_FORMAT_DISPLAY_ORDER"
+                :key="format"
+                variant="ghost"
+                size="sm"
+                class="h-6 shrink-0 rounded-[5px] px-2 text-xs"
+                :class="{ 'bg-background shadow-sm': memberValueView === format }"
+                :disabled="!canRenderRedisValueFormat(selectedMemberDetail, format)"
+                @click="setMemberValueFormat(format)"
+              >
+                {{ redisFormatLabel(format, selectedMemberDetail.rawLabel) }}
+              </Button>
+            </div>
+            <span class="flex-1" />
+            <label v-if="isTextRedisFormat(memberValueView)" class="flex items-center gap-1.5 text-muted-foreground">
+              <WrapText class="h-3.5 w-3.5" />
+              {{ t("redis.wordWrap") }}
+              <Switch size="sm" :model-value="redisJsonWordWrap" @update:model-value="setRedisJsonWordWrap(Boolean($event))" />
+            </label>
+          </div>
+          <div v-if="memberValueView === 'json' && selectedMemberDetail.json" class="dbx-editor-font-family min-h-0 flex-1 overflow-auto bg-background p-5 text-[13px] leading-6">
+            <JsonTree :value="selectedMemberDetail.json.value" :word-wrap="redisJsonWordWrap" :highlight-json="highlightRedisJson" />
+          </div>
+          <div v-else-if="memberValueView === 'javaserialize' && selectedMemberDetail.javaSerialized" class="dbx-editor-font-family min-h-0 flex-1 overflow-auto bg-background p-5 text-[13px] leading-6">
+            <JsonTree :value="selectedMemberDetail.javaSerialized.value" :word-wrap="redisJsonWordWrap" :highlight-json="highlightRedisJson" />
+          </div>
+          <div v-else-if="memberValueView === 'hex'" class="min-h-0 flex-1 overflow-auto bg-background p-5 text-xs leading-5">
+            <div class="mb-3 flex items-center justify-between text-muted-foreground">
+              <span>{{ t("grid.hexViewer") }}</span>
+              <span>{{ t("grid.hexViewerByteCount", { count: selectedMemberDetail.byteCount }) }}</span>
+            </div>
+            <pre v-if="selectedMemberDetail.hexRows.length > 0" class="dbx-editor-font-family w-full min-w-0 max-w-full select-all whitespace-pre-wrap break-all">{{ detailTextForFormat(selectedMemberDetail, "hex") }}</pre>
+            <div v-else class="text-muted-foreground">{{ t("grid.hexViewerEmpty") }}</div>
+          </div>
+          <pre v-else-if="memberValueView === 'base64'" class="dbx-editor-font-family min-h-0 w-full min-w-0 max-w-full flex-1 overflow-auto bg-background p-5 text-[13px] leading-6 whitespace-pre-wrap break-all">{{ selectedMemberDetail.base64Text }}</pre>
+          <pre v-else class="dbx-editor-font-family min-h-0 w-full min-w-0 max-w-full flex-1 overflow-auto bg-background p-5 text-[13px] leading-6" :class="detailTextClass(memberValueView)">{{ detailTextForFormat(selectedMemberDetail, memberValueView) }}</pre>
+        </template>
+        <SheetFooter class="shrink-0 border-t px-5 py-3">
+          <template v-if="isEditingMember">
+            <Button variant="ghost" :disabled="savingMember" @click="cancelEditMember">
+              {{ t("grid.discard") }}
+            </Button>
+            <Button :disabled="savingMember" @click="saveMemberEdit">
+              <Loader2 v-if="savingMember" class="h-4 w-4 animate-spin" />
+              <Save v-else class="h-4 w-4" />
+              {{ t("grid.save") }}
+            </Button>
+          </template>
+          <Button v-else-if="canEditCurrentMemberFormat" variant="outline" @click="startEditMember">
+            <Pencil class="h-4 w-4" />
+            {{ t("redis.editMember") }}
+          </Button>
+          <Button variant="outline" @click="copyText(detailTextForFormat(selectedMemberDetail, memberValueView))">
+            <Copy class="h-4 w-4" />
+            {{ t("redis.copyMember") }}
+          </Button>
+        </SheetFooter>
+      </SheetContent>
+    </Sheet>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/search/DatabaseSearchDialog.vue b/apps/desktop/src/components/search/DatabaseSearchDialog.vue
new file mode 100644
index 0000000..2ec22b3
--- /dev/null
+++ b/apps/desktop/src/components/search/DatabaseSearchDialog.vue
@@ -0,0 +1,362 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { uuid } from "@/lib/common/utils";
+import { useI18n } from "vue-i18n";
+import { AlertCircle, Loader2, Search, Square, Table2 } from "@lucide/vue";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogFooter, DialogHeader, DialogScrollContent, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { useConnectionStore } from "@/stores/connectionStore";
+import * as api from "@/lib/backend/api";
+import { buildDatabaseSearchSql, buildSearchResultWhere, findMatchedSearchColumns } from "@/lib/database/databaseSearch";
+import type { DatabaseType, TableInfo } from "@/types/database";
+import { isSchemaAware } from "@/lib/database/databaseCapabilities";
+
+const props = defineProps<{
+  open: boolean;
+  prefillConnectionId: string;
+  prefillDatabase: string;
+  prefillSchema?: string;
+}>();
+
+const emit = defineEmits<{
+  "update:open": [value: boolean];
+  "open-target": [
+    value: {
+      connectionId: string;
+      database: string;
+      schema?: string;
+      tableName: string;
+      tableType?: string;
+      whereInput?: string;
+    },
+  ];
+}>();
+
+const { t } = useI18n();
+const connectionStore = useConnectionStore();
+const dialogOpen = computed({
+  get: () => props.open,
+  set: (value) => emit("update:open", value),
+});
+
+type SearchResultItem = {
+  id: string;
+  schema?: string;
+  tableName: string;
+  tableType?: string;
+  matchedColumns: string[];
+  preview: string;
+  whereInput: string;
+};
+
+type SearchTableTask = {
+  schema?: string;
+  table: TableInfo;
+};
+
+const SYSTEM_SCHEMAS = new Set(["information_schema", "pg_catalog", "sys", "system", "mysql", "performance_schema", "xdb", "outln", "dbsnmp"]);
+const MAX_TABLES = 200;
+
+const keyword = ref("");
+const perTableLimit = ref(20);
+const running = ref(false);
+const cancelled = ref(false);
+const loadingTables = ref(false);
+const progressDone = ref(0);
+const progressTotal = ref(0);
+const results = ref<SearchResultItem[]>([]);
+const tableErrors = ref<Array<{ tableName: string; message: string }>>([]);
+const generalError = ref("");
+const limitedTables = ref(false);
+const currentExecutionId = ref("");
+let runId = 0;
+
+const connection = computed(() => (props.prefillConnectionId ? connectionStore.getConfig(props.prefillConnectionId) : undefined));
+const scopeLabel = computed(() => [connection.value?.name, props.prefillDatabase, props.prefillSchema].filter(Boolean).join(" / "));
+const canSearch = computed(() => Boolean(props.prefillConnectionId && props.prefillDatabase && keyword.value.trim() && !running.value));
+const progressLabel = computed(() => t("databaseSearch.progress", { done: progressDone.value, total: progressTotal.value }));
+
+watch(
+  dialogOpen,
+  (open) => {
+    if (open) {
+      resetSearchState();
+    } else {
+      stopSearch();
+    }
+  },
+  { immediate: true },
+);
+
+function resetSearchState() {
+  running.value = false;
+  cancelled.value = false;
+  loadingTables.value = false;
+  progressDone.value = 0;
+  progressTotal.value = 0;
+  results.value = [];
+  tableErrors.value = [];
+  generalError.value = "";
+  limitedTables.value = false;
+  currentExecutionId.value = "";
+}
+
+function isSearchableTable(table: TableInfo): boolean {
+  const type = table.table_type.toUpperCase();
+  return type.includes("TABLE") && !type.includes("VIEW");
+}
+
+function filterSearchSchemas(schemas: string[]): string[] {
+  return schemas.filter((schema) => !SYSTEM_SCHEMAS.has(schema.toLowerCase()));
+}
+
+function makeExecutionId(): string {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) return `database-search-${uuid()}`;
+  return `database-search-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function valuePreview(value: unknown): string {
+  if (value === null || value === undefined) return "NULL";
+  const text = String(value).replace(/\s+/g, " ").trim();
+  return text.length > 90 ? `${text.slice(0, 90)}...` : text;
+}
+
+function rowPreview(columns: string[], row: unknown[], matchedColumns: string[]): string {
+  const matched = matchedColumns
+    .slice(0, 3)
+    .map((column) => {
+      const index = columns.findIndex((name) => name.toLowerCase() === column.toLowerCase());
+      return index >= 0 ? `${column}: ${valuePreview(row[index])}` : "";
+    })
+    .filter(Boolean);
+
+  if (matched.length) return matched.join(" · ");
+
+  return columns
+    .slice(0, 3)
+    .map((column, index) => `${column}: ${valuePreview(row[index])}`)
+    .join(" · ");
+}
+
+async function listSearchTables(): Promise<SearchTableTask[]> {
+  if (!connection.value || !props.prefillConnectionId || !props.prefillDatabase) return [];
+  const databaseType = connection.value.db_type;
+  const schemaNames = props.prefillSchema ? [props.prefillSchema] : isSchemaAware(databaseType) ? filterSearchSchemas(await api.listSchemas(props.prefillConnectionId, props.prefillDatabase)) : [props.prefillDatabase];
+
+  const tasks: SearchTableTask[] = [];
+  for (const schema of schemaNames) {
+    const tables = await api.listTables(props.prefillConnectionId, props.prefillDatabase, schema);
+    for (const table of tables.filter(isSearchableTable)) {
+      tasks.push({ schema, table });
+    }
+  }
+
+  if (tasks.length > MAX_TABLES) {
+    limitedTables.value = true;
+    return tasks.slice(0, MAX_TABLES);
+  }
+  return tasks;
+}
+
+async function startSearch() {
+  if (!canSearch.value || !connection.value) return;
+  const currentRun = ++runId;
+  resetSearchState();
+  running.value = true;
+  loadingTables.value = true;
+
+  try {
+    await connectionStore.ensureConnected(props.prefillConnectionId);
+    const tasks = await listSearchTables();
+    if (currentRun !== runId || cancelled.value) return;
+    progressTotal.value = tasks.length;
+    loadingTables.value = false;
+
+    for (const task of tasks) {
+      if (currentRun !== runId || cancelled.value) break;
+      await searchTable(task, connection.value.db_type, currentRun);
+      progressDone.value += 1;
+    }
+  } catch (error: any) {
+    if (!cancelled.value) generalError.value = error?.message || String(error);
+  } finally {
+    if (currentRun === runId) {
+      running.value = false;
+      loadingTables.value = false;
+      currentExecutionId.value = "";
+    }
+  }
+}
+
+async function searchTable(task: SearchTableTask, databaseType: DatabaseType, currentRun: number) {
+  const tableLabel = task.schema ? `${task.schema}.${task.table.name}` : task.table.name;
+  try {
+    const schema = task.schema || props.prefillDatabase;
+    const columns = await api.getColumns(props.prefillConnectionId, props.prefillDatabase, schema, task.table.name);
+    const query = await buildDatabaseSearchSql({
+      databaseType,
+      schema: task.schema,
+      tableName: task.table.name,
+      columns,
+      term: keyword.value,
+      limit: perTableLimit.value,
+    });
+    if (!query || currentRun !== runId || cancelled.value) return;
+
+    const executionId = makeExecutionId();
+    currentExecutionId.value = executionId;
+    const result = await api.executeQuery(props.prefillConnectionId, props.prefillDatabase, query.sql, undefined, executionId);
+    if (currentExecutionId.value === executionId) currentExecutionId.value = "";
+    if (currentRun !== runId || cancelled.value) return;
+
+    for (const [rowIndex, row] of result.rows.entries()) {
+      const matchedColumns = findMatchedSearchColumns(result.columns, row, columns, keyword.value);
+      const whereInput = await buildSearchResultWhere({
+        databaseType,
+        columns,
+        resultColumns: result.columns,
+        row,
+        matchedColumns,
+      });
+      results.value.push({
+        id: `${tableLabel}:${rowIndex}:${results.value.length}`,
+        schema: task.schema,
+        tableName: task.table.name,
+        tableType: task.table.table_type,
+        matchedColumns,
+        preview: rowPreview(result.columns, row, matchedColumns),
+        whereInput,
+      });
+    }
+  } catch (error: any) {
+    if (!cancelled.value) {
+      tableErrors.value.push({ tableName: tableLabel, message: error?.message || String(error) });
+    }
+  }
+}
+
+async function stopSearch() {
+  cancelled.value = true;
+  runId++;
+  running.value = false;
+  loadingTables.value = false;
+  const executionId = currentExecutionId.value;
+  currentExecutionId.value = "";
+  if (executionId) {
+    try {
+      await api.cancelQuery(executionId);
+    } catch {
+      // Best effort; some drivers may finish before cancellation arrives.
+    }
+  }
+}
+
+function openResult(item: SearchResultItem) {
+  emit("open-target", {
+    connectionId: props.prefillConnectionId,
+    database: props.prefillDatabase,
+    schema: item.schema,
+    tableName: item.tableName,
+    tableType: item.tableType,
+    whereInput: item.whereInput,
+  });
+}
+</script>
+
+<template>
+  <Dialog v-model:open="dialogOpen">
+    <DialogScrollContent class="max-w-4xl gap-0 p-0">
+      <DialogHeader class="border-b px-5 py-4">
+        <DialogTitle class="flex items-center gap-2">
+          <Search class="h-5 w-5" />
+          {{ t("databaseSearch.title") }}
+        </DialogTitle>
+        <div class="flex flex-wrap items-center gap-2 text-xs text-muted-foreground">
+          <span>{{ scopeLabel }}</span>
+          <Badge v-if="props.prefillSchema" variant="secondary">{{ props.prefillSchema }}</Badge>
+        </div>
+      </DialogHeader>
+
+      <div class="space-y-4 px-5 py-4">
+        <div class="grid gap-3 md:grid-cols-[1fr_9rem_auto]">
+          <div class="space-y-1.5">
+            <Label class="text-xs">{{ t("databaseSearch.keyword") }}</Label>
+            <Input v-model="keyword" class="h-9" :placeholder="t('databaseSearch.keywordPlaceholder')" :disabled="running" @keydown.enter.prevent="startSearch" />
+          </div>
+          <div class="space-y-1.5">
+            <Label class="text-xs">{{ t("databaseSearch.limitPerTable") }}</Label>
+            <Input v-model.number="perTableLimit" class="h-9" type="number" min="1" max="100" :disabled="running" />
+          </div>
+          <div class="flex items-end gap-2">
+            <Button class="h-9" :disabled="!canSearch" @click="startSearch">
+              <Loader2 v-if="running" class="h-4 w-4 animate-spin" />
+              <Search v-else class="h-4 w-4" />
+              {{ running ? t("databaseSearch.searching") : t("databaseSearch.search") }}
+            </Button>
+            <Button v-if="running" variant="destructive" class="h-9" @click="stopSearch">
+              <Square class="h-4 w-4 fill-current" />
+              {{ t("databaseSearch.stop") }}
+            </Button>
+          </div>
+        </div>
+
+        <div class="rounded-md border bg-muted/20 px-3 py-2 text-xs text-muted-foreground">
+          {{ t("databaseSearch.hint") }}
+        </div>
+
+        <div v-if="running || progressTotal" class="flex flex-wrap items-center gap-3 text-xs text-muted-foreground">
+          <span>{{ loadingTables ? t("databaseSearch.loadingTables") : progressLabel }}</span>
+          <span>{{ t("databaseSearch.resultCount", { count: results.length }) }}</span>
+          <span v-if="limitedTables" class="text-amber-600">{{ t("databaseSearch.limitedTables", { count: 200 }) }}</span>
+        </div>
+
+        <div v-if="generalError" class="flex items-start gap-2 rounded-md border border-destructive/30 bg-destructive/5 px-3 py-2 text-sm text-destructive">
+          <AlertCircle class="mt-0.5 h-4 w-4" />
+          <span>{{ generalError }}</span>
+        </div>
+
+        <div class="space-y-2">
+          <div class="flex items-center justify-between">
+            <div class="text-sm font-medium">{{ t("databaseSearch.results") }}</div>
+            <Badge variant="outline">{{ results.length }}</Badge>
+          </div>
+          <div v-if="results.length" class="max-h-[360px] space-y-2 overflow-auto pr-1">
+            <button v-for="item in results" :key="item.id" class="flex w-full items-start gap-3 rounded-md border bg-background px-3 py-2 text-left hover:bg-muted/40" @click="openResult(item)">
+              <Table2 class="mt-0.5 h-4 w-4 shrink-0 text-muted-foreground" />
+              <div class="min-w-0 flex-1">
+                <div class="flex min-w-0 flex-wrap items-center gap-2">
+                  <span class="truncate font-medium">{{ item.schema ? `${item.schema}.${item.tableName}` : item.tableName }}</span>
+                  <Badge v-for="column in item.matchedColumns" :key="column" variant="secondary">{{ column }}</Badge>
+                </div>
+                <div class="mt-1 truncate text-xs text-muted-foreground">{{ item.preview }}</div>
+              </div>
+              <span class="shrink-0 text-xs text-primary">{{ t("databaseSearch.openResult") }}</span>
+            </button>
+          </div>
+          <div v-else class="rounded-md border border-dashed py-10 text-center text-sm text-muted-foreground">
+            {{ running ? t("databaseSearch.waiting") : t("databaseSearch.noResults") }}
+          </div>
+        </div>
+
+        <div v-if="tableErrors.length" class="space-y-2">
+          <div class="text-sm font-medium text-muted-foreground">
+            {{ t("databaseSearch.errors") }}
+          </div>
+          <div class="max-h-24 space-y-1 overflow-auto rounded-md border bg-muted/20 p-2 text-xs text-muted-foreground">
+            <div v-for="error in tableErrors" :key="`${error.tableName}:${error.message}`">
+              <span class="font-medium text-foreground">{{ error.tableName }}</span
+              >: {{ error.message }}
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <DialogFooter class="border-t px-5 py-3">
+        <Button variant="outline" @click="dialogOpen = false">{{ t("common.close") }}</Button>
+      </DialogFooter>
+    </DialogScrollContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/sidebar/ConnectionTree.vue b/apps/desktop/src/components/sidebar/ConnectionTree.vue
new file mode 100644
index 0000000..86dfafc
--- /dev/null
+++ b/apps/desktop/src/components/sidebar/ConnectionTree.vue
@@ -0,0 +1,1229 @@
+<script setup lang="ts">
+import { ref, computed, nextTick, watch, provide, onMounted, onUnmounted, type Component, type CSSProperties } from "vue";
+import { useI18n } from "vue-i18n";
+import { Search, X, ListFilter, Crosshair, Server, Database, FolderTree, Table2, Eye, RotateCcw } from "@lucide/vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useToast } from "@/composables/useToast";
+import type { TreeNode, TreeNodeType } from "@/types/database";
+import { filterSidebarSearchRootsByConnectionState, filterSidebarTree } from "@/lib/sidebar/sidebarSearchTree";
+import { isCancelSearchShortcut, isCopySidebarSelectionShortcut, isEditSidebarConnectionShortcut, isPasteSidebarSelectionShortcut } from "@/lib/editor/keyboardShortcuts";
+import { copyNameForTreeNode } from "@/lib/sidebar/treeNodeClick";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { connectionPasteTargetGroupId, selectedConnectionClipboardNodes, selectedConnectionEditTarget } from "@/lib/sidebar/sidebarConnectionSelection";
+import { isEditableSidebarTypeSearchTarget, sidebarTypeSearchNextQuery } from "@/lib/sidebar/sidebarTypeSearch";
+import { usesTreeSchemaMode } from "@/lib/database/databaseFeatureSupport";
+import { connectionUsesDatabaseObjectTreeMode, effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import { activeTabSidebarTarget, findSidebarNodeForActiveTab, findSidebarNodeForTarget, findNodePathForTarget, scrollTopForSidebarNode, shouldScrollActiveSidebarSelection, type ActiveTabSidebarTarget, type SidebarNodeScrollAlign } from "@/lib/sidebar/sidebarActiveTabTarget";
+import { findLoadedTableTargetForCandidate, queryContextTargetFromCandidate, queryCursorTableCandidate, type QueryCursorTableCandidate } from "@/lib/sql/queryCursorTableTarget";
+import { SIDEBAR_TREE_ROW_HEIGHT, SIDEBAR_TREE_PRERENDER_COUNT, SIDEBAR_TREE_SCROLL_BUFFER, flattenTree, shouldVirtualizeFlatTree, type FlatTreeNode } from "@/composables/useFlatTree";
+import { sidebarTreeContextKey } from "@/lib/sidebar/sidebarTreeContext";
+import { insertSidebarTableSearchControls, isSidebarTableSearchControlNode } from "@/lib/sidebar/sidebarTableSearchControl";
+import TreeItem from "./TreeItem.vue";
+import { RecycleScroller } from "vue-virtual-scroller";
+import "vue-virtual-scroller/dist/vue-virtual-scroller.css";
+import LightDropdown from "@/components/ui/LightDropdown.vue";
+
+const { t } = useI18n();
+const store = useConnectionStore();
+const queryStore = useQueryStore();
+const settingsStore = useSettingsStore();
+const { toast } = useToast();
+const searchQuery = ref("");
+const deferredSearchQuery = ref("");
+const searchInputRef = ref<HTMLInputElement>();
+const rootRef = ref<HTMLElement>();
+const pointerInsideTree = ref(false);
+const treeScrollerRef = ref<InstanceType<typeof RecycleScroller> | null>(null);
+const plainTreeScrollerRef = ref<HTMLElement | null>(null);
+const sidebarScrollbarTrackRef = ref<HTMLElement | null>(null);
+type SearchScope = "connection" | "database" | "schema" | "table" | "view";
+const selectedSearchScopes = ref<SearchScope[]>([]);
+const searchCollapsedIds = ref<Set<string>>(new Set());
+const searchRefreshedNodeIds = new Set<string>();
+let searchTimer: number | undefined;
+const tableSearchTimers = new Map<string, number>();
+const tableSearchFocusRestoreTokens = new Map<string, number>();
+let tableSearchFocusRestoreTokenSeq = 0;
+let latestTableSearchInteractionParentId: string | null = null;
+
+watch(
+  searchQuery,
+  (value) => {
+    const normalized = value.trim().toLowerCase();
+    window.clearTimeout(searchTimer);
+
+    if (!normalized) {
+      deferredSearchQuery.value = "";
+      return;
+    }
+
+    searchTimer = window.setTimeout(() => {
+      deferredSearchQuery.value = normalized;
+    }, 300);
+  },
+  { flush: "sync" },
+);
+
+function refreshActiveSidebarTableSearches() {
+  if (isFiltering.value) return;
+  for (const parentNodeId of Object.keys(store.sidebarTableSearchQueries)) {
+    scheduleSidebarTableSearchRefresh(parentNodeId);
+  }
+}
+
+watch(
+  () => settingsStore.editorSettings.sidebarTableSearchEnabled,
+  (enabled) => {
+    if (enabled) return;
+    const parentNodeIds = Object.keys(store.sidebarTableSearchQueries);
+    if (parentNodeIds.length === 0) return;
+
+    for (const parentNodeId of parentNodeIds) {
+      window.clearTimeout(tableSearchTimers.get(parentNodeId));
+      tableSearchTimers.delete(parentNodeId);
+      tableSearchFocusRestoreTokens.delete(parentNodeId);
+      store.setSidebarTableSearchQuery(parentNodeId, "");
+    }
+    latestTableSearchInteractionParentId = null;
+    void Promise.all(parentNodeIds.map((parentNodeId) => store.refreshSidebarTableSearch(parentNodeId))).catch(() => {});
+  },
+);
+
+watch(deferredSearchQuery, (newQuery, oldQuery) => {
+  store.sidebarSearchQuery = newQuery;
+  const tasks: Promise<void>[] = [];
+  for (const root of store.treeNodes) {
+    collectExpandedObjectSearchTargets(root, tasks, newQuery ? searchRefreshedNodeIds : undefined);
+  }
+  if (!newQuery && oldQuery) {
+    searchRefreshedNodeIds.clear();
+  }
+  Promise.all(tasks)
+    .then(() => {
+      if (!newQuery && oldQuery) refreshActiveSidebarTableSearches();
+    })
+    .catch(() => {});
+});
+
+const searchableObjectGroupTypes = new Set<TreeNodeType>(["group-tables", "group-views", "group-materialized-views", "group-procedures", "group-functions", "group-sequences", "group-packages"]);
+const simpleObjectParentTypes = new Set<TreeNodeType>(["database", "schema", "linked-server-schema"]);
+const simpleObjectChildTypes = new Set<TreeNodeType>(["table", "view", "materialized_view", "procedure", "function", "sequence", "package", "package-body", "load-more"]);
+
+function isSimpleObjectSearchParent(node: TreeNode): boolean {
+  return settingsStore.editorSettings.sidebarObjectDisplay === "simple" && simpleObjectParentTypes.has(node.type) && node.isExpanded === true && (!!node.children?.some((child) => simpleObjectChildTypes.has(child.type)) || !!store.sidebarTableSearchQueries[node.id]?.trim());
+}
+
+function collectExpandedObjectSearchTargets(node: TreeNode, tasks: Promise<void>[], refreshedNodeIds?: Set<string>) {
+  if (refreshedNodeIds && isSimpleObjectSearchParent(node)) {
+    refreshedNodeIds.add(node.id);
+    tasks.push(store.refreshTreeNode(node));
+    return;
+  }
+  if (refreshedNodeIds && node.isExpanded && node.children) {
+    for (const child of node.children) {
+      if (child.connectionId && searchableObjectGroupTypes.has(child.type)) {
+        refreshedNodeIds.add(child.id);
+        tasks.push(store.loadObjectGroupChildren(child, { force: true }));
+      }
+    }
+  } else if (!refreshedNodeIds && searchRefreshedNodeIds.has(node.id)) {
+    if (searchableObjectGroupTypes.has(node.type)) {
+      tasks.push(store.loadObjectGroupChildren(node, { force: true }));
+    } else if (simpleObjectParentTypes.has(node.type)) {
+      tasks.push(store.refreshTreeNode(node));
+    }
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      collectExpandedObjectSearchTargets(child, tasks, refreshedNodeIds);
+    }
+  }
+}
+
+const isSearching = computed(() => !!deferredSearchQuery.value);
+const isFiltering = computed(() => !!searchQuery.value.trim() || hasSearchScopeFilter.value);
+
+const SEARCH_SCOPE_TO_NODE_TYPES: Record<SearchScope, TreeNodeType[]> = {
+  connection: ["connection"],
+  database: ["database", "redis-db", "mq-tenant", "nacos-namespace", "mongo-db"],
+  schema: ["schema"],
+  table: ["table", "mongo-collection", "mongo-bucket", "vector-collection", "elasticsearch-index"],
+  view: ["view"],
+};
+
+// Sticky-row container types. When browsing a large number of children (e.g.
+// hundreds of tables) under one of these and scrolling down, the row is kept
+// pinned at the top so the active container stays identifiable and can be
+// collapsed with one click.
+//
+// Database-level containers are always preferred. Schema is only a fallback,
+// used when the upward path has NO database-level ancestor at all: Dameng /
+// Oracle / oceanbase-oracle expose `connection -> schema -> tables` (no database
+// node, via connectionUsesVisibleSchemaFilter). For Postgres/SQLServer, whose
+// tree is `connection -> database -> schema -> tables`, the sticky walk prefers
+// the database node, so schema never shadows it.
+const DATABASE_LEVEL_TYPES = new Set<TreeNodeType>(SEARCH_SCOPE_TO_NODE_TYPES.database);
+const SCHEMA_LEVEL_TYPES = new Set<TreeNodeType>(["schema"]);
+
+const searchScopeOptions = computed(() => {
+  return [
+    { scope: "connection", label: t("sidebar.searchScopeConnection"), icon: Server },
+    { scope: "database", label: t("sidebar.searchScopeDatabase"), icon: Database },
+    { scope: "schema", label: t("sidebar.searchScopeSchema"), icon: FolderTree },
+    { scope: "table", label: t("sidebar.searchScopeTable"), icon: Table2 },
+    { scope: "view", label: t("sidebar.searchScopeView"), icon: Eye },
+  ] as const satisfies ReadonlyArray<{ scope: SearchScope; label: string; icon: Component }>;
+});
+const searchScopeMenuItems = computed(() => [
+  ...searchScopeOptions.value.map((item) => ({
+    value: item.scope,
+    label: item.label,
+    icon: item.icon,
+  })),
+  ...(hasSearchScopeFilter.value
+    ? [
+        {
+          value: "__clear",
+          label: t("sidebar.clearFilter"),
+          icon: RotateCcw,
+          separatorBefore: true,
+        },
+      ]
+    : []),
+]);
+
+const hasSearchScopeFilter = computed(() => selectedSearchScopes.value.length > 0);
+const searchableNodeTypes = computed<Set<TreeNodeType> | undefined>(() => {
+  if (!hasSearchScopeFilter.value) return undefined;
+  const types = new Set<TreeNodeType>();
+  for (const scope of selectedSearchScopes.value) {
+    for (const nodeType of SEARCH_SCOPE_TO_NODE_TYPES[scope]) {
+      types.add(nodeType);
+    }
+  }
+  return types;
+});
+
+function toggleSearchScope(scope: SearchScope) {
+  const idx = selectedSearchScopes.value.indexOf(scope);
+  if (idx >= 0) {
+    selectedSearchScopes.value.splice(idx, 1);
+  } else {
+    selectedSearchScopes.value.push(scope);
+  }
+}
+
+function selectSearchScopeMenuItem(value: string) {
+  if (value === "__clear") {
+    clearSearchScopeFilter();
+    return;
+  }
+  toggleSearchScope(value as SearchScope);
+}
+
+function clearSearchScopeFilter() {
+  selectedSearchScopes.value = [];
+}
+
+function scheduleSidebarTableSearchRefresh(parentNodeId: string, options?: { restoreFocus?: boolean }) {
+  window.clearTimeout(tableSearchTimers.get(parentNodeId));
+  if (isFiltering.value) return;
+  const restoreToken = options?.restoreFocus ? ++tableSearchFocusRestoreTokenSeq : 0;
+  if (restoreToken) {
+    tableSearchFocusRestoreTokens.clear();
+    tableSearchFocusRestoreTokens.set(parentNodeId, restoreToken);
+  }
+  const timer = window.setTimeout(() => {
+    tableSearchTimers.delete(parentNodeId);
+    void store.refreshSidebarTableSearch(parentNodeId).then(() => {
+      if (!restoreToken) return;
+      if (tableSearchFocusRestoreTokens.get(parentNodeId) !== restoreToken) return;
+      tableSearchFocusRestoreTokens.delete(parentNodeId);
+      if (latestTableSearchInteractionParentId !== parentNodeId) return;
+      if (document.activeElement === document.body || activeTableSearchParentId() === parentNodeId) {
+        focusTableSearchInput(parentNodeId);
+      }
+    });
+  }, 250);
+  tableSearchTimers.set(parentNodeId, timer);
+}
+
+function activeTableSearchParentId(): string | null {
+  const active = document.activeElement;
+  if (!(active instanceof HTMLElement)) return null;
+  return active.dataset.sidebarTableSearchParentId || null;
+}
+
+function focusTableSearchInput(parentNodeId: string) {
+  void nextTick(() => {
+    const root = rootRef.value;
+    if (!root) return;
+    const input = Array.from(root.querySelectorAll<HTMLInputElement>("[data-sidebar-table-search-parent-id]")).find((item) => item.dataset.sidebarTableSearchParentId === parentNodeId);
+    if (!input) return;
+    input.focus({ preventScroll: true });
+    const end = input.value.length;
+    input.setSelectionRange(end, end);
+  });
+}
+
+const filteredNodes = computed(() => {
+  let nodes = store.treeNodes;
+
+  const q = deferredSearchQuery.value;
+  if (q) {
+    nodes = filterSidebarTree(nodes, q, searchCollapsedIds.value, searchableNodeTypes.value);
+    nodes = filterSidebarSearchRootsByConnectionState(nodes, store.connectedIds);
+  }
+
+  return nodes;
+});
+
+const flatNodes = computed<FlatTreeNode[]>(() =>
+  insertSidebarTableSearchControls(flattenTree(filteredNodes.value), {
+    enabled: settingsStore.editorSettings.sidebarTableSearchEnabled && !isFiltering.value,
+    sidebarObjectDisplay: settingsStore.editorSettings.sidebarObjectDisplay,
+    activeQueries: store.sidebarTableSearchQueries,
+  }),
+);
+const visibleNodes = computed<TreeNode[]>(() => flatNodes.value.map((item) => item.node));
+const selectableVisibleNodes = computed<TreeNode[]>(() => visibleNodes.value.filter((node) => !isSidebarTableSearchControlNode(node)));
+const selectableVisibleNodeIndexById = computed(() => {
+  const next = new Map<string, number>();
+  selectableVisibleNodes.value.forEach((node, index) => next.set(node.id, index));
+  return next;
+});
+const useVirtualTree = computed(() => shouldVirtualizeFlatTree(flatNodes.value.length));
+const activeTab = computed(() => queryStore.tabs.find((tab) => tab.id === queryStore.activeTabId));
+
+// --- Sticky database header ---
+// RecycleScroller positions each row absolutely, so CSS `position: sticky` on
+// a database row can't work. Instead we overlay a pinned row from this parent
+// component, tracking scroll offset to find the topmost visible database-level
+// ancestor. The overlay reuses <TreeItem>, so collapse/expand comes for free.
+const stickyScrollTop = ref(0);
+const sidebarScrollMetrics = ref({ scrollTop: 0, clientHeight: 0, scrollHeight: 0 });
+const isScrollingSidebar = ref(false);
+const isDraggingSidebarScrollbar = ref(false);
+let sidebarScrollbarResizeObserver: ResizeObserver | null = null;
+let sidebarScrollbarAnimationFrame = 0;
+let sidebarScrollbarDragOffset = 0;
+let sidebarScrollingTimer = 0;
+
+function updateSidebarScrollMetrics() {
+  const scroller = currentTreeScroller();
+  if (!scroller) {
+    sidebarScrollMetrics.value = { scrollTop: 0, clientHeight: 0, scrollHeight: 0 };
+    return;
+  }
+
+  if (useVirtualTree.value) stickyScrollTop.value = scroller.scrollTop;
+  sidebarScrollMetrics.value = {
+    scrollTop: scroller.scrollTop,
+    clientHeight: scroller.clientHeight,
+    scrollHeight: scroller.scrollHeight,
+  };
+}
+
+function scheduleSidebarScrollMetricsUpdate() {
+  window.cancelAnimationFrame(sidebarScrollbarAnimationFrame);
+  sidebarScrollbarAnimationFrame = window.requestAnimationFrame(updateSidebarScrollMetrics);
+}
+
+function onTreeScroll() {
+  isScrollingSidebar.value = true;
+  window.clearTimeout(sidebarScrollingTimer);
+  sidebarScrollingTimer = window.setTimeout(() => {
+    isScrollingSidebar.value = false;
+  }, 700);
+  scheduleSidebarScrollMetricsUpdate();
+}
+
+// RecycleScroller only emits scrollStart/scrollEnd, not continuous scroll, so
+// attach a native passive listener on its root element once it mounts.
+watch(
+  treeScrollerRef,
+  (scroller, _old, onCleanup) => {
+    const el = (scroller?.$el as HTMLElement | undefined) ?? null;
+    if (!el) return;
+    el.addEventListener("scroll", onTreeScroll, { passive: true });
+    onCleanup(() => el.removeEventListener("scroll", onTreeScroll));
+  },
+  { flush: "post" },
+);
+
+watch(
+  [treeScrollerRef, plainTreeScrollerRef, useVirtualTree],
+  (_value, _oldValue, onCleanup) => {
+    sidebarScrollbarResizeObserver?.disconnect();
+    sidebarScrollbarResizeObserver = null;
+
+    const scroller = currentTreeScroller();
+    if (!scroller) return;
+
+    sidebarScrollbarResizeObserver = new ResizeObserver(scheduleSidebarScrollMetricsUpdate);
+    sidebarScrollbarResizeObserver.observe(scroller);
+    scheduleSidebarScrollMetricsUpdate();
+
+    onCleanup(() => {
+      sidebarScrollbarResizeObserver?.disconnect();
+      sidebarScrollbarResizeObserver = null;
+    });
+  },
+  { flush: "post" },
+);
+
+const stickyNode = computed<FlatTreeNode | null>(() => {
+  if (!useVirtualTree.value || isFiltering.value) return null;
+  const nodes = flatNodes.value;
+  const len = nodes.length;
+  if (len === 0) return null;
+
+  const topIndex = Math.min(Math.floor(stickyScrollTop.value / SIDEBAR_TREE_ROW_HEIGHT), len - 1);
+  // flatNodes is a DFS preorder spanning ALL connections, so walking up from a
+  // leaf visits `... -> schema -> database -> connection -> <other connection>`.
+  // Stop at the connection boundary so the sticky row never leaks across into a
+  // different connection's subtree (e.g. MySQL's last database sticking while
+  // scrolling Dameng). Within one connection: track both candidates and prefer
+  // database-level; only fall back to schema when the whole path has no
+  // database-level container (Dameng/Oracle-style trees).
+  let schemaCandidate: FlatTreeNode | null = null;
+  let schemaCandidateTop = 0;
+  for (let i = topIndex; i >= 0; i--) {
+    const item = nodes[i];
+    if (item.type === "connection" || item.type === "connection-group") break;
+    if (DATABASE_LEVEL_TYPES.has(item.type)) {
+      const rowTop = i * SIDEBAR_TREE_ROW_HEIGHT;
+      return stickyScrollTop.value > rowTop ? item : null;
+    }
+    if (item.type === "schema" && !schemaCandidate) {
+      schemaCandidate = item;
+      schemaCandidateTop = i * SIDEBAR_TREE_ROW_HEIGHT;
+    }
+  }
+  if (!schemaCandidate) return null;
+  return stickyScrollTop.value > schemaCandidateTop ? schemaCandidate : null;
+});
+
+const stickyHeaderStyle = computed<CSSProperties>(() => {
+  const node = stickyNode.value;
+  if (!node) return {};
+  const nodes = flatNodes.value;
+  const currentIndex = nodes.findIndex((item) => item.id === node.id);
+  if (currentIndex < 0) return {};
+  // Look forward for the next sibling container at the SAME level as the sticky
+  // node so the push-up only fires when a peer scrolls in (database-to-database,
+  // or schema-to-schema for Dameng/Oracle), never schema-into-database. Stop at
+  // the connection boundary so we never reach into the next connection's rows.
+  const nextTypes = SCHEMA_LEVEL_TYPES.has(node.type) ? SCHEMA_LEVEL_TYPES : DATABASE_LEVEL_TYPES;
+  let nextDatabaseIndex = -1;
+  for (let i = currentIndex + 1; i < nodes.length; i++) {
+    const item = nodes[i];
+    if (item.type === "connection" || item.type === "connection-group") break;
+    if (nextTypes.has(item.type)) {
+      nextDatabaseIndex = i;
+      break;
+    }
+  }
+  if (nextDatabaseIndex < 0) return {};
+  const distanceToNext = nextDatabaseIndex * SIDEBAR_TREE_ROW_HEIGHT - stickyScrollTop.value;
+  if (distanceToNext >= SIDEBAR_TREE_ROW_HEIGHT) return {};
+  return {
+    transform: `translateY(${Math.min(0, distanceToNext - SIDEBAR_TREE_ROW_HEIGHT)}px)`,
+  };
+});
+
+// Reset tracking when the tree rebuilds (connect/disconnect/collapse) so a
+// stale scrollTop doesn't keep the overlay mounted after a structural change.
+watch(flatNodes, () => {
+  stickyScrollTop.value = 0;
+  void nextTick(scheduleSidebarScrollMetricsUpdate);
+});
+
+const sidebarTreeOverflowClass = computed(() => (settingsStore.editorSettings.sidebarAllowHorizontalScroll ? "overflow-x-auto sidebar-tree-horizontal-scroll" : "overflow-x-hidden"));
+
+const hasSidebarVerticalOverflow = computed(() => sidebarScrollMetrics.value.scrollHeight > sidebarScrollMetrics.value.clientHeight + 1);
+
+function sidebarScrollbarGeometry() {
+  const { scrollTop, clientHeight, scrollHeight } = sidebarScrollMetrics.value;
+  const trackHeight = sidebarScrollbarTrackRef.value?.clientHeight ?? Math.max(0, clientHeight - 8);
+  if (trackHeight <= 0 || scrollHeight <= clientHeight) {
+    return { thumbTop: 0, thumbHeight: 0, maxThumbTop: 0, maxScrollTop: 0 };
+  }
+
+  const thumbHeight = Math.max(24, Math.min(trackHeight, (clientHeight / scrollHeight) * trackHeight));
+  const maxThumbTop = Math.max(0, trackHeight - thumbHeight);
+  const maxScrollTop = Math.max(1, scrollHeight - clientHeight);
+  const thumbTop = Math.min(maxThumbTop, Math.max(0, (scrollTop / maxScrollTop) * maxThumbTop));
+  return { thumbTop, thumbHeight, maxThumbTop, maxScrollTop };
+}
+
+const sidebarScrollbarThumbStyle = computed<CSSProperties>(() => {
+  const { thumbTop, thumbHeight } = sidebarScrollbarGeometry();
+  return {
+    height: `${thumbHeight}px`,
+    transform: `translateY(${thumbTop}px)`,
+  };
+});
+
+function setSidebarScrollFromPointer(clientY: number, offset: number) {
+  const scroller = currentTreeScroller();
+  const track = sidebarScrollbarTrackRef.value;
+  if (!scroller || !track) return;
+
+  const rect = track.getBoundingClientRect();
+  const { maxThumbTop, maxScrollTop } = sidebarScrollbarGeometry();
+  if (maxThumbTop <= 0) return;
+
+  const thumbTop = Math.min(maxThumbTop, Math.max(0, clientY - rect.top - offset));
+  scroller.scrollTop = (thumbTop / maxThumbTop) * maxScrollTop;
+  updateSidebarScrollMetrics();
+}
+
+function stopSidebarScrollbarDrag() {
+  isDraggingSidebarScrollbar.value = false;
+  window.removeEventListener("pointermove", onSidebarScrollbarPointerMove);
+  window.removeEventListener("pointerup", stopSidebarScrollbarDrag);
+  window.removeEventListener("pointercancel", stopSidebarScrollbarDrag);
+}
+
+function onSidebarScrollbarPointerMove(event: PointerEvent) {
+  event.preventDefault();
+  setSidebarScrollFromPointer(event.clientY, sidebarScrollbarDragOffset);
+}
+
+function onSidebarScrollbarTrackPointerDown(event: PointerEvent) {
+  if (event.button !== 0) return;
+  event.preventDefault();
+  const { thumbHeight } = sidebarScrollbarGeometry();
+  sidebarScrollbarDragOffset = thumbHeight / 2;
+  setSidebarScrollFromPointer(event.clientY, sidebarScrollbarDragOffset);
+  isDraggingSidebarScrollbar.value = true;
+  window.addEventListener("pointermove", onSidebarScrollbarPointerMove);
+  window.addEventListener("pointerup", stopSidebarScrollbarDrag);
+  window.addEventListener("pointercancel", stopSidebarScrollbarDrag);
+}
+
+function onSidebarScrollbarThumbPointerDown(event: PointerEvent) {
+  if (event.button !== 0) return;
+  event.preventDefault();
+  const track = sidebarScrollbarTrackRef.value;
+  if (!track) return;
+
+  const rect = track.getBoundingClientRect();
+  const { thumbTop } = sidebarScrollbarGeometry();
+  sidebarScrollbarDragOffset = event.clientY - rect.top - thumbTop;
+  isDraggingSidebarScrollbar.value = true;
+  window.addEventListener("pointermove", onSidebarScrollbarPointerMove);
+  window.addEventListener("pointerup", stopSidebarScrollbarDrag);
+  window.addEventListener("pointercancel", stopSidebarScrollbarDrag);
+}
+
+provide(sidebarTreeContextKey, {
+  getVisibleNodes: () => selectableVisibleNodes.value,
+  getVisibleNodeIndex: (id: string) => selectableVisibleNodeIndexById.value.get(id) ?? -1,
+  setTableSearchQuery: (parentNodeId, query) => {
+    latestTableSearchInteractionParentId = parentNodeId;
+    store.setSidebarTableSearchQuery(parentNodeId, query);
+    scheduleSidebarTableSearchRefresh(parentNodeId, { restoreFocus: true });
+  },
+});
+
+const pendingRenameGroupId = ref<string | null>(null);
+const highlightedNodeId = ref<string | null>(null);
+let highlightTimer: number | undefined;
+
+// 等待虚拟列表渲染后再高亮。
+function waitForSidebarRenderFrame(): Promise<void> {
+  return new Promise((resolve) => {
+    window.requestAnimationFrame(() => resolve());
+  });
+}
+
+// 重新触发定位高亮，支持连续定位同一节点。
+async function flashSidebarNode(nodeId: string) {
+  window.clearTimeout(highlightTimer);
+  highlightedNodeId.value = null;
+  await nextTick();
+  await waitForSidebarRenderFrame();
+
+  highlightedNodeId.value = nodeId;
+  highlightTimer = window.setTimeout(() => {
+    if (highlightedNodeId.value === nodeId) highlightedNodeId.value = null;
+  }, 1800);
+}
+
+function topOcclusionHeightForSidebarNode(nodeId: string): number {
+  const sticky = stickyNode.value;
+  if (!useVirtualTree.value || !sticky || sticky.id === nodeId) return 0;
+  return SIDEBAR_TREE_ROW_HEIGHT;
+}
+
+async function scrollToSidebarNode(nodeId: string, options?: { align?: SidebarNodeScrollAlign }) {
+  await nextTick();
+
+  const index = flatNodes.value.findIndex((item) => item.id === nodeId);
+  const scroller = currentTreeScroller();
+  if (!scroller || index < 0) return;
+
+  const nextScrollTop = scrollTopForSidebarNode({
+    index,
+    currentScrollTop: scroller.scrollTop,
+    viewportHeight: scroller.clientHeight,
+    topOcclusionHeight: topOcclusionHeightForSidebarNode(nodeId),
+    ...(options?.align ? { align: options.align } : {}),
+  });
+  if (nextScrollTop !== scroller.scrollTop) {
+    scroller.scrollTop = nextScrollTop;
+  }
+}
+
+function clearSidebarSelection() {
+  // Clicking the blank area of the tree clears the current selection. Row
+  // clicks call event.stopPropagation(), so this only fires for blank clicks
+  // (issue #681 — selection wasn't cleared in double-click activation mode).
+  store.connectionMultiSelectActive = false;
+  store.selectedTreeNodeId = null;
+  store.selectedTreeNodeIds = [];
+  store.treeSelectionAnchorId = null;
+}
+
+async function createNewGroup() {
+  const groupId = store.createConnectionGroup(t("connectionGroup.newGroupDefault"));
+  await startRenamingCreatedGroup(groupId);
+}
+
+async function startRenamingCreatedGroup(groupId: string) {
+  pendingRenameGroupId.value = groupId;
+  store.selectedTreeNodeId = groupId;
+  if (isFiltering.value) {
+    searchQuery.value = "";
+    deferredSearchQuery.value = "";
+    clearSearchScopeFilter();
+  }
+
+  await scrollToSidebarNode(groupId);
+  store.selectedTreeNodeId = groupId;
+}
+
+async function locateActiveTabInSidebar() {
+  const tab = activeTab.value;
+  if (!tab) return;
+
+  const connId = tab.connectionId;
+
+  // Reconnect if the connection was disconnected (children are cleared on disconnect)
+  if (connId && !store.connectedIds.has(connId)) {
+    const config = store.getConfig(connId);
+    if (!config) return;
+    try {
+      await store.connect(config);
+    } catch {
+      return;
+    }
+  }
+
+  const config = connId ? store.getConfig(connId) : undefined;
+  const cursorCandidate = queryCursorTableCandidate(tab, effectiveDatabaseTypeForConnection(config));
+  const fallbackTarget = queryContextTargetFromCandidate(tab, cursorCandidate) ?? activeTabSidebarTarget(tab);
+  const initialTarget = cursorCandidate ? tableTargetFromCandidate(cursorCandidate) : fallbackTarget;
+  if (!initialTarget) return;
+
+  // Ensure the tree is loaded deep enough to contain the preferred target.
+  await ensureTreeLoadedForTarget(initialTarget);
+
+  // Clear any active search filter so the node is visible
+  if (isFiltering.value) {
+    searchQuery.value = "";
+    deferredSearchQuery.value = "";
+    clearSearchScopeFilter();
+  }
+
+  let target = resolveLoadedLocateTarget(initialTarget, cursorCandidate);
+  let nodePath = target ? findNodePathForTarget(target, store.treeNodes) : null;
+  if (!nodePath) {
+    // The first load may have served a stale schema cache whose async refresh
+    // replaced the database node before its tables finished loading, so the
+    // table isn't in the tree yet. Force a synchronous reload and retry once so
+    // locate reaches the table, not just the database (issue #715).
+    await ensureTreeLoadedForTarget(initialTarget, { force: true });
+    target = resolveLoadedLocateTarget(initialTarget, cursorCandidate);
+    nodePath = target ? findNodePathForTarget(target, store.treeNodes) : null;
+  }
+
+  if (!nodePath && cursorCandidate) {
+    await store.loadTableForLocate(cursorCandidate);
+    target = resolveLoadedLocateTarget(initialTarget, cursorCandidate);
+    nodePath = target ? findNodePathForTarget(target, store.treeNodes) : null;
+  }
+
+  if (!nodePath && cursorCandidate && fallbackTarget) {
+    await ensureTreeLoadedForTarget(fallbackTarget);
+    target = fallbackTarget;
+    nodePath = findNodePathForTarget(fallbackTarget, store.treeNodes);
+  }
+
+  if (!nodePath) return;
+
+  for (const ancestor of nodePath) {
+    if (!ancestor.isExpanded) {
+      ancestor.isExpanded = true;
+    }
+  }
+
+  await nextTick();
+
+  const match = target ? findSidebarNodeForTarget(target, flatNodes.value) : null;
+  if (!match) return;
+
+  store.selectedTreeNodeId = match.id;
+  store.selectedTreeNodeIds = [match.id];
+  store.treeSelectionAnchorId = match.id;
+  await nextTick();
+
+  await scrollToSidebarNode(match.id, { align: "smart" });
+  await flashSidebarNode(match.id);
+}
+
+function tableTargetFromCandidate(candidate: QueryCursorTableCandidate): ActiveTabSidebarTarget {
+  return {
+    type: "table",
+    connectionId: candidate.connectionId,
+    database: candidate.database,
+    schema: candidate.schema,
+    tableName: candidate.tableName,
+  };
+}
+
+function resolveLoadedLocateTarget(target: ActiveTabSidebarTarget, candidate: QueryCursorTableCandidate | null): ActiveTabSidebarTarget | null {
+  if (!candidate) return target;
+  return findLoadedTableTargetForCandidate(store.treeNodes, candidate);
+}
+
+async function ensureTreeLoadedForTarget(target: ActiveTabSidebarTarget, opts?: { force?: boolean }) {
+  if (target.type === "saved-sql-file" || target.type === "etcd-root" || target.type === "zookeeper-root") return;
+  const connId = target.connectionId;
+  if (!connId) return;
+
+  const config = store.getConfig(connId);
+  if (!config) return;
+
+  // When forcing, bypass the cached children check so we reload from the
+  // source. A stale schema cache otherwise serves children and triggers an
+  // async background refresh that can replace nodes mid-flight, leaving the
+  // tree without the target table by the time we search for it (issue #715).
+  const force = opts?.force ?? false;
+  const loadOptions = force ? { force: true } : undefined;
+
+  // Ensure databases are loaded under the connection
+  const connNode = store.treeNodes.find((n) => n.id === connId);
+  if (connNode && (force || !connNode.children || connNode.children.length === 0)) {
+    try {
+      if (config.db_type === "redis") {
+        await store.loadRedisDatabases(connId);
+      } else if (config.db_type === "mongodb") {
+        await store.loadMongoDatabases(connId);
+      } else if (config.db_type === "elasticsearch") {
+        await store.loadElasticsearchIndices(connId);
+      } else if (config.db_type === "qdrant" || config.db_type === "milvus" || config.db_type === "weaviate" || config.db_type === "chromadb") {
+        await store.loadVectorCollections(connId);
+      } else if (config.db_type === "mq") {
+        await store.loadMqTenants(connId, loadOptions);
+      } else if (config.db_type === "nacos") {
+        await store.loadNacosNamespaces(connId, loadOptions);
+      } else {
+        await store.loadDatabases(connId, loadOptions);
+      }
+    } catch {
+      return;
+    }
+  }
+
+  if (config.db_type === "mq" || config.db_type === "nacos") return;
+  if (!("database" in target) || !target.database) return;
+
+  // Find the database node
+  const dbNode = findDatabaseNode(store.treeNodes, connId, target.database);
+  if (!dbNode) return;
+  const targetSchema = "schema" in target ? target.schema : undefined;
+  const databaseChildrenLoaded = !!dbNode.children && dbNode.children.length > 0;
+  const effectiveDbType = effectiveDatabaseTypeForConnection(config);
+  const usesSchemaTree = usesTreeSchemaMode(effectiveDbType) && !connectionUsesDatabaseObjectTreeMode(config);
+  const shouldLoadSchemaTables = target.type === "table" && !!targetSchema && usesSchemaTree;
+  if (!force && databaseChildrenLoaded && !shouldLoadSchemaTables) return;
+
+  // Load database contents
+  try {
+    if (config.db_type === "sqlserver") {
+      if (force || !databaseChildrenLoaded) {
+        await store.loadSqlServerDatabaseObjects(connId, target.database, loadOptions);
+      }
+    } else if (usesSchemaTree) {
+      if (force || !databaseChildrenLoaded) {
+        await store.loadSchemas(connId, target.database, loadOptions);
+      }
+      // If we have a schema, also load tables under that schema
+      if (targetSchema) {
+        const schemaNode = findSchemaNode(store.treeNodes, connId, target.database, targetSchema);
+        if (schemaNode && (force || !schemaNode.children || schemaNode.children.length === 0)) {
+          await store.loadTables(connId, target.database, targetSchema, loadOptions);
+        }
+      }
+    } else {
+      await store.loadTables(connId, target.database, undefined, loadOptions);
+    }
+
+    if (target.type === "table") {
+      await ensureTableObjectGroupsLoaded(target, loadOptions);
+    }
+  } catch {
+    // Node just won't have children loaded
+  }
+}
+
+async function ensureTableObjectGroupsLoaded(target: Extract<ActiveTabSidebarTarget, { type: "table" }>, options?: { force?: boolean }) {
+  const groups = findTableObjectGroupNodes(store.treeNodes, target);
+  for (const group of groups) {
+    if (!options?.force && group.children && group.children.length > 0) continue;
+    await store.loadObjectGroupChildren(group, options);
+  }
+}
+
+function findTableObjectGroupNodes(nodes: TreeNode[], target: Extract<ActiveTabSidebarTarget, { type: "table" }>): TreeNode[] {
+  const matches: TreeNode[] = [];
+  for (const node of nodes) {
+    if ((node.type === "group-tables" || node.type === "group-views" || node.type === "group-materialized-views") && node.connectionId === target.connectionId && sameTreeName(node.database, target.database) && (!target.schema || sameTreeName(node.schema, target.schema))) {
+      matches.push(node);
+    }
+    if (node.children) {
+      matches.push(...findTableObjectGroupNodes(node.children, target));
+    }
+  }
+  return matches;
+}
+
+function sameTreeName(left: string | undefined, right: string | undefined): boolean {
+  return (left || "").toLowerCase() === (right || "").toLowerCase();
+}
+
+function findDatabaseNode(nodes: TreeNode[], connId: string, database: string): TreeNode | null {
+  for (const node of nodes) {
+    if (node.type === "database" && node.connectionId === connId && sameTreeName(node.database, database)) {
+      return node;
+    }
+    if (node.children) {
+      const found = findDatabaseNode(node.children, connId, database);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+function findSchemaNode(nodes: TreeNode[], connId: string, database: string, schema: string): TreeNode | null {
+  for (const node of nodes) {
+    if (node.type === "schema" && node.connectionId === connId && sameTreeName(node.database, database) && sameTreeName(node.label, schema)) {
+      return node;
+    }
+    if (node.children) {
+      const found = findSchemaNode(node.children, connId, database, schema);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+function onSearchToggle(node: TreeNode) {
+  if (!isSearching.value || !node.children) return;
+  const next = new Set(searchCollapsedIds.value);
+  if (node.isExpanded) next.add(node.id);
+  else next.delete(node.id);
+  searchCollapsedIds.value = next;
+}
+
+function collapseAllTreeNodes() {
+  store.collapseAllTreeNodes();
+  if (isSearching.value) {
+    searchCollapsedIds.value = new Set(flatNodes.value.filter((item) => item.node.children?.length).map((item) => item.id));
+  }
+}
+
+function currentTreeScroller(): HTMLElement | null {
+  return ((useVirtualTree.value ? treeScrollerRef.value?.$el : plainTreeScrollerRef.value) as HTMLElement | undefined) ?? null;
+}
+
+async function selectActiveTabSidebarNode(options: { scroll: boolean }) {
+  if (!settingsStore.editorSettings.autoSelectActiveSidebarNode) return;
+  const match = findSidebarNodeForActiveTab(activeTab.value, flatNodes.value);
+  if (!match) return;
+
+  store.selectedTreeNodeId = match.id;
+  if (!options.scroll) return;
+
+  await nextTick();
+
+  const index = flatNodes.value.findIndex((item) => item.id === match.id);
+  const scroller = currentTreeScroller();
+  if (!scroller || index < 0) return;
+
+  const nextScrollTop = scrollTopForSidebarNode({
+    index,
+    currentScrollTop: scroller.scrollTop,
+    viewportHeight: scroller.clientHeight,
+    topOcclusionHeight: topOcclusionHeightForSidebarNode(match.id),
+  });
+  if (nextScrollTop !== scroller.scrollTop) {
+    scroller.scrollTop = nextScrollTop;
+  }
+}
+
+watch(
+  [() => activeTab.value?.id ?? null, flatNodes, () => settingsStore.editorSettings.autoSelectActiveSidebarNode],
+  ([activeTabId, _nodes, autoSelectEnabled], [previousActiveTabId, _previousNodes, previousAutoSelectEnabled]) => {
+    void selectActiveTabSidebarNode({
+      scroll: shouldScrollActiveSidebarSelection({
+        activeTabId,
+        previousActiveTabId,
+        autoSelectEnabled,
+        previousAutoSelectEnabled,
+      }),
+    });
+  },
+  { flush: "post" },
+);
+
+function focusSearch(): boolean {
+  const input = searchInputRef.value;
+  if (!input) return false;
+  input.focus();
+  input.select();
+  return true;
+}
+
+function onSearchKeydown(event: KeyboardEvent) {
+  if (!isCancelSearchShortcut(event)) return;
+  event.preventDefault();
+  searchQuery.value = "";
+}
+
+function focusSearchAtEnd() {
+  nextTick(() => {
+    const input = searchInputRef.value;
+    if (!input) return;
+    input.focus();
+    const end = input.value.length;
+    input.setSelectionRange(end, end);
+  });
+}
+
+function onWindowKeydown(event: KeyboardEvent) {
+  if (event.defaultPrevented) return;
+  if (sidebarShortcutTargetIsActive(event.target)) {
+    if (sidebarShortcutTargetAllowsAppShortcut(event.target) && isEditConnectionShortcut(event)) {
+      if (requestSelectedConnectionEdit()) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+      return;
+    }
+    if (sidebarShortcutTargetAllowsAppShortcut(event.target) && isCopySidebarSelectionShortcut(event, settingsStore.editorSettings.shortcuts)) {
+      if (copySelectedSidebarNames()) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+      return;
+    }
+    if (sidebarShortcutTargetAllowsAppShortcut(event.target) && isPasteSidebarSelectionShortcut(event, settingsStore.editorSettings.shortcuts)) {
+      if (requestSelectedSidebarPaste()) {
+        event.preventDefault();
+        event.stopPropagation();
+      }
+      return;
+    }
+  }
+
+  if (!pointerInsideTree.value || isEditableSidebarTypeSearchTarget(event.target) || isEditableSidebarTypeSearchTarget(document.activeElement)) return;
+  if (isCancelSearchShortcut(event)) {
+    if (!searchQuery.value) return;
+    event.preventDefault();
+    searchQuery.value = "";
+    focusSearchAtEnd();
+    return;
+  }
+  const nextQuery = sidebarTypeSearchNextQuery(searchQuery.value, event);
+  if (nextQuery == null) return;
+  event.preventDefault();
+  searchQuery.value = nextQuery;
+  focusSearchAtEnd();
+}
+
+function sidebarShortcutTargetIsActive(target: EventTarget | null): boolean {
+  const root = rootRef.value;
+  if (!root) return false;
+  if (target instanceof Node && root.contains(target)) return true;
+  const active = document.activeElement;
+  return pointerInsideTree.value && (!active || active === document.body || root.contains(active));
+}
+
+function sidebarShortcutTargetAllowsAppShortcut(target: EventTarget | null): boolean {
+  if (!(target instanceof HTMLElement)) return true;
+  return !(target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target.isContentEditable || !!target.closest("[contenteditable='true'], [role='textbox']"));
+}
+
+function selectedSidebarNodesInVisibleOrder(): TreeNode[] {
+  const selectedIds = new Set(store.selectedTreeNodeIds);
+  return visibleNodes.value.filter((node) => selectedIds.has(node.id));
+}
+
+function isEditConnectionShortcut(event: KeyboardEvent): boolean {
+  return isEditSidebarConnectionShortcut(event, settingsStore.editorSettings.shortcuts);
+}
+
+function requestSelectedConnectionEdit(): boolean {
+  const selectedNodeId = store.selectedTreeNodeId;
+  const currentNode = selectedNodeId ? visibleNodes.value.find((node) => node.id === selectedNodeId) : null;
+  if (!currentNode) return false;
+  const editTarget = selectedConnectionEditTarget(currentNode, selectedSidebarNodesInVisibleOrder());
+  if (!editTarget) return false;
+  store.startEditing(editTarget.connectionId);
+  return true;
+}
+
+function copySelectedSidebarNames(): boolean {
+  const nodes = selectedSidebarNodesInVisibleOrder();
+  if (nodes.length === 0) return false;
+  const connectionNodes = selectedConnectionClipboardNodes(nodes);
+  if (connectionNodes.length > 0) {
+    const copiedCount = store.copyConnectionsToTreeClipboard(connectionNodes.map((node) => node.connectionId));
+    if (copiedCount > 0) toast(t("connection.copied"), 2000);
+    return copiedCount > 0;
+  }
+  const tableNodes = nodes.filter((node) => node.type === "table" && !!node.connectionId && !!node.database);
+  store.treeClipboard =
+    tableNodes.length > 0
+      ? {
+          kind: "table-copy",
+          tables: tableNodes.map((node) => ({
+            connectionId: node.connectionId!,
+            database: node.database!,
+            schema: node.schema,
+            tableName: node.label,
+          })),
+        }
+      : null;
+  copyToClipboard(nodes.map(copyNameForTreeNode).join("\n"))
+    .then(() => toast(t("connection.copied"), 2000))
+    .catch((e: any) => toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000));
+  return true;
+}
+
+function requestSelectedSidebarPaste(): boolean {
+  const clipboard = store.treeClipboard;
+  const selectedNodeId = store.selectedTreeNodeId;
+  if (clipboard?.kind === "connection-copy") {
+    const selectedNode = selectedNodeId ? visibleNodes.value.find((node) => node.id === selectedNodeId) : null;
+    const targetGroupId = connectionPasteTargetGroupId(selectedNode, (connectionId) => store.groupIdForConnection(connectionId));
+    void store
+      .pasteConnectionClipboard(targetGroupId)
+      .then((count) => {
+        if (count > 0) toast(count > 1 ? t("connection.duplicatedSelected", { count }) : t("connection.duplicated"), 2000);
+      })
+      .catch((e: any) => toast(t("connection.saveFailed", { message: e?.message || String(e) }), 5000));
+    return true;
+  }
+  if (clipboard?.kind !== "table-copy" || clipboard.tables.length === 0 || !selectedNodeId) return false;
+  window.dispatchEvent(new CustomEvent("dbx:sidebar-request-paste-table", { detail: { nodeId: selectedNodeId } }));
+  return true;
+}
+
+onMounted(() => {
+  window.addEventListener("keydown", onWindowKeydown);
+});
+
+onUnmounted(() => {
+  window.removeEventListener("keydown", onWindowKeydown);
+  for (const timer of tableSearchTimers.values()) {
+    window.clearTimeout(timer);
+  }
+  tableSearchTimers.clear();
+  tableSearchFocusRestoreTokens.clear();
+  latestTableSearchInteractionParentId = null;
+  stopSidebarScrollbarDrag();
+  sidebarScrollbarResizeObserver?.disconnect();
+  window.cancelAnimationFrame(sidebarScrollbarAnimationFrame);
+  window.clearTimeout(sidebarScrollingTimer);
+});
+
+defineExpose({ focusSearch, createNewGroup, collapseAllTreeNodes });
+</script>
+
+<template>
+  <div ref="rootRef" class="h-full min-h-0 flex flex-col text-sm select-none" @pointerenter="pointerInsideTree = true" @pointerleave="pointerInsideTree = false">
+    <div class="connection-tree-search sticky top-0 z-10 bg-background px-2 py-1">
+      <div class="relative flex items-center gap-1">
+        <div class="relative flex-1">
+          <Search class="absolute left-2 top-1/2 -translate-y-1/2 h-3 w-3 text-muted-foreground" />
+          <input
+            ref="searchInputRef"
+            v-model="searchQuery"
+            autocapitalize="off"
+            autocorrect="off"
+            spellcheck="false"
+            class="w-full h-6 pl-7 pr-6 text-xs rounded border border-border bg-background focus:outline-none focus:ring-1 focus:ring-ring"
+            :placeholder="t('grid.search')"
+            @keydown="onSearchKeydown"
+          />
+          <button v-if="searchQuery" class="absolute right-1.5 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground" @click="searchQuery = ''">
+            <X class="h-3 w-3" />
+          </button>
+        </div>
+        <button class="shrink-0 h-6 w-6 flex items-center justify-center rounded border border-border text-muted-foreground hover:bg-accent hover:text-foreground" :title="t('sidebar.locateActiveTab')" @click="locateActiveTabInSidebar">
+          <Crosshair class="h-3.5 w-3.5" />
+        </button>
+        <LightDropdown
+          v-if="searchScopeOptions.length > 0"
+          model-value=""
+          :items="searchScopeMenuItems"
+          :selected-values="selectedSearchScopes"
+          :aria-label="t('sidebar.filterByType')"
+          :label="t('sidebar.filterByType')"
+          :trigger-title="t('sidebar.filterByType')"
+          :trigger-icon="ListFilter"
+          :trigger-class="['shrink-0 h-6 w-6 flex items-center justify-center rounded border border-border hover:bg-accent', hasSearchScopeFilter ? 'text-primary bg-primary/10 border-primary/30' : 'text-muted-foreground'].join(' ')"
+          trigger-icon-class="h-3.5 w-3.5"
+          item-icon-class="h-3.5 w-3.5"
+          content-class="w-max min-w-0"
+          selected-item-class="bg-primary/10 text-primary"
+          selected-check-class="text-primary"
+          :show-trigger-label="false"
+          :show-chevron="false"
+          :close-on-select="false"
+          align="end"
+          @update:model-value="selectSearchScopeMenuItem"
+        />
+      </div>
+    </div>
+    <div v-if="flatNodes.length > 0 && useVirtualTree" class="connection-tree-scroll-shell relative min-h-0 flex-1">
+      <RecycleScroller
+        ref="treeScrollerRef"
+        class="sidebar-tree connection-tree-scroller h-full overflow-y-auto"
+        :class="sidebarTreeOverflowClass"
+        @click="clearSidebarSelection"
+        :items="flatNodes"
+        :item-size="SIDEBAR_TREE_ROW_HEIGHT"
+        :buffer="SIDEBAR_TREE_SCROLL_BUFFER"
+        :prerender="SIDEBAR_TREE_PRERENDER_COUNT"
+        :skip-hover="true"
+        key-field="id"
+        type-field="poolType"
+        flow-mode
+      >
+        <template #default="{ item }">
+          <TreeItem
+            :node="item.node"
+            :depth="item.depth"
+            :drag-disabled="isFiltering"
+            :pending-rename="pendingRenameGroupId === item.node.id"
+            :highlighted="highlightedNodeId === item.node.id"
+            @search-toggle="onSearchToggle"
+            @rename-started="pendingRenameGroupId = null"
+            @group-created="startRenamingCreatedGroup"
+          />
+        </template>
+      </RecycleScroller>
+      <div v-if="stickyNode" class="sticky-database-header pointer-events-auto absolute inset-x-0 top-0 z-[5] border-b border-border/60" :style="stickyHeaderStyle">
+        <TreeItem :node="stickyNode.node" :depth="stickyNode.depth" :drag-disabled="true" @search-toggle="onSearchToggle" />
+      </div>
+      <div v-if="hasSidebarVerticalOverflow" ref="sidebarScrollbarTrackRef" class="sidebar-tree-scrollbar" :class="{ 'sidebar-tree-scrollbar--scrolling': isScrollingSidebar, 'sidebar-tree-scrollbar--dragging': isDraggingSidebarScrollbar }" @pointerdown="onSidebarScrollbarTrackPointerDown">
+        <div class="sidebar-tree-scrollbar__thumb" :style="sidebarScrollbarThumbStyle" @pointerdown.stop="onSidebarScrollbarThumbPointerDown" />
+      </div>
+    </div>
+    <div v-else-if="flatNodes.length > 0" class="connection-tree-scroll-shell relative min-h-0 flex-1">
+      <div ref="plainTreeScrollerRef" class="sidebar-tree connection-tree-scroller h-full overflow-y-auto" :class="sidebarTreeOverflowClass" @click="clearSidebarSelection" @scroll.passive="onTreeScroll">
+        <TreeItem
+          v-for="item in flatNodes"
+          :key="item.id"
+          :node="item.node"
+          :depth="item.depth"
+          :drag-disabled="isFiltering"
+          :pending-rename="pendingRenameGroupId === item.node.id"
+          :highlighted="highlightedNodeId === item.id"
+          @search-toggle="onSearchToggle"
+          @rename-started="pendingRenameGroupId = null"
+          @group-created="startRenamingCreatedGroup"
+        />
+      </div>
+      <div v-if="hasSidebarVerticalOverflow" ref="sidebarScrollbarTrackRef" class="sidebar-tree-scrollbar" :class="{ 'sidebar-tree-scrollbar--scrolling': isScrollingSidebar, 'sidebar-tree-scrollbar--dragging': isDraggingSidebarScrollbar }" @pointerdown="onSidebarScrollbarTrackPointerDown">
+        <div class="sidebar-tree-scrollbar__thumb" :style="sidebarScrollbarThumbStyle" @pointerdown.stop="onSidebarScrollbarThumbPointerDown" />
+      </div>
+    </div>
+    <div v-if="store.treeNodes.length === 0" class="px-3 py-8 text-center text-muted-foreground text-xs">
+      {{ t("sidebar.noConnections") }}
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.sticky-database-header {
+  background-color: var(--background);
+}
+
+.connection-tree-scroller {
+  will-change: scroll-position;
+  contain: content;
+  scrollbar-width: none;
+  -ms-overflow-style: none;
+}
+
+.connection-tree-scroller::-webkit-scrollbar {
+  width: 0;
+  height: 0;
+}
+
+.connection-tree-scroller :deep(.vue-recycle-scroller__item-view) {
+  min-width: 100%;
+  contain: style;
+}
+
+.connection-tree-scroller.sidebar-tree-horizontal-scroll :deep(.vue-recycle-scroller__item-view) {
+  width: max-content;
+}
+
+.sidebar-tree-scrollbar {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  z-index: 10;
+  width: 12px;
+  cursor: default;
+  opacity: 0;
+  transition: opacity 120ms ease;
+}
+
+.sidebar-tree-scrollbar--scrolling,
+.sidebar-tree-scrollbar:hover,
+.sidebar-tree-scrollbar--dragging {
+  opacity: 1;
+}
+
+.sidebar-tree-scrollbar__thumb {
+  position: absolute;
+  right: 2px;
+  width: 6px;
+  min-height: 24px;
+  border-radius: 999px;
+  background: color-mix(in oklch, var(--foreground) 30%, transparent);
+  transition:
+    background-color 120ms ease,
+    width 120ms ease,
+    right 120ms ease;
+}
+
+.sidebar-tree-scrollbar:hover .sidebar-tree-scrollbar__thumb,
+.sidebar-tree-scrollbar--dragging .sidebar-tree-scrollbar__thumb {
+  right: 1px;
+  width: 8px;
+  background: color-mix(in oklch, var(--foreground) 48%, transparent);
+}
+</style>
diff --git a/apps/desktop/src/components/sidebar/TreeItem.vue b/apps/desktop/src/components/sidebar/TreeItem.vue
new file mode 100644
index 0000000..3558077
--- /dev/null
+++ b/apps/desktop/src/components/sidebar/TreeItem.vue
@@ -0,0 +1,6082 @@
+<script setup lang="ts">
+import { ref, computed, nextTick, watch, onMounted, onBeforeUnmount, inject, type Component } from "vue";
+import { useSqlHighlighter } from "@/composables/useSqlHighlighter";
+import { useI18n } from "vue-i18n";
+import { translateBackendError } from "@/i18n/backend-errors";
+import {
+  Database,
+  Table,
+  Columns3,
+  Eye,
+  ChevronRight,
+  ChevronDown,
+  ChevronsDown,
+  Loader2,
+  FolderOpen,
+  FolderClosed,
+  Trash2,
+  TerminalSquare,
+  RefreshCw,
+  Copy,
+  TableProperties,
+  Key,
+  Link,
+  Zap,
+  ListTree,
+  Pencil,
+  Play,
+  Plug,
+  Unplug,
+  Pin,
+  ArrowRightLeft,
+  Download,
+  Upload,
+  FileCode,
+  Network,
+  Server,
+  PencilRuler,
+  Search,
+  FolderInput,
+  FolderPlus,
+  Eraser,
+  Scissors,
+  CopyPlus,
+  Plus,
+  ScrollText,
+  Braces,
+  Code2,
+  ListFilter,
+  Package,
+  Clipboard,
+  Check,
+  UsersRound,
+  CalendarClock,
+  Lock,
+  HardDriveDownload,
+  FilePlus,
+  SquarePen,
+  ListX,
+  Info,
+  Archive,
+  Square,
+  X,
+} from "@lucide/vue";
+import CustomContextMenu from "@/components/ui/CustomContextMenu.vue";
+import { CONNECTION_ATTEMPT_CANCELLED_MESSAGE, useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useSavedSqlStore } from "@/stores/savedSqlStore";
+import { useToast } from "@/composables/useToast";
+import { useDatabaseOptions } from "@/composables/useDatabaseOptions";
+import type { ColumnInfo, ConnectionConfig, DatabaseType, ObjectSourceKind, TreeNode, TreeNodeType } from "@/types/database";
+import * as api from "@/lib/backend/api";
+import { uuid } from "@/lib/common/utils";
+import { resolveDefaultDatabase } from "@/lib/database/defaultDatabase";
+import { canTreeNodePin, canTreeNodeShowExpander, treeItemPaddingLeft, usesFullWidthTreeLabel } from "@/lib/sidebar/sidebarTreeItemLayout";
+import { buildTableSelectSql } from "@/lib/table/tableSelectSql";
+import { buildTableDeleteTemplate, buildTableInsertTemplate, buildTableSelectTemplate, buildTableUpdateTemplate } from "@/lib/table/tableSqlTemplates";
+import { connectionFilePath, defaultSqliteBackupFileName, isMemorySqlitePath, sqliteBackupSourcePath } from "@/lib/connection/connectionFile";
+import { revealPathInFileManager } from "@/lib/backend/tauri";
+import { clearActiveTableReferencePayload, createTableReferencePayload, createTableReferenceDropEvent, setActiveTableReferencePayload, type QueryEditorTableReferencePayload } from "@/lib/editor/queryEditorTableDrop";
+import { usesSyntheticRowIdKey } from "@/lib/table/tableEditing";
+import { tableOpenPageLimit } from "@/lib/table/tableOpenPageLimit";
+import { getCachedTableMetadata, loadTableMetadata, TABLE_METADATA_CACHE_TTL_MS, tableMetadataToDataTabMeta } from "@/lib/metadata/tableMetadataCache";
+import {
+  canCreateConnectionNamespace,
+  canCreateDatabaseNodeNamespace,
+  canEditDatabaseProperties as canEditDatabasePropertiesForNode,
+  connectionNamespaceCreationTarget,
+  editableDatabasePropertyGroups,
+  supportsDatabaseCreation,
+  supportsDatabaseSearch,
+  supportsFieldLineage,
+  supportsObjectBrowserTreeNode,
+  supportsSchemaDiagram,
+  supportsSqlFileExecution,
+  supportsTableImport,
+  supportsTableTruncate,
+  supportsTableStructureEditing,
+  usesTreeSchemaMode,
+} from "@/lib/database/databaseCapabilities";
+import { copyNameForTreeNode, isDocumentBrowserTreeNode, objectSourceKindForTreeNode, shouldRunTreeNodeRowAction, treeNodeRowAction, treeNodeRowDoubleClickAction } from "@/lib/sidebar/treeNodeClick";
+import { isCopySidebarSelectionShortcut, isEditSidebarConnectionShortcut, isPasteSidebarSelectionShortcut } from "@/lib/editor/keyboardShortcuts";
+import { formatSqlInsert } from "@/lib/export/exportFormats";
+import { joinExportedDdls } from "@/lib/export/ddlExport";
+import { fetchTableDataForExport } from "@/lib/table/tableDataExport";
+import { canActivateExistingDataTableTab } from "@/lib/tabs/dataTabActivation";
+import { buildCreateDatabaseSql, buildDuckDbAttachDatabaseSql, duckDbAttachedDatabaseNameFromPath, supportsCreateDatabaseCharset, uniqueDuckDbAttachedDatabaseName } from "@/lib/database/createDatabaseSql";
+import {
+  buildCreateSchemaSql,
+  buildDropDatabaseSql,
+  buildDropObjectSql,
+  buildDropSchemaSql,
+  buildGetDatabaseCommentSql,
+  buildGetSchemaCommentSql,
+  buildUpdateDatabasePropertiesSql,
+  buildDropTableSql,
+  buildDropTableChildObjectSql,
+  buildDuplicateTableStructureSql,
+  buildCopyTableDataSql,
+  buildEmptyTableSql,
+  buildTruncateTableSql,
+  supportsDropTableCascade,
+  supportsTruncateTableCascade,
+  supportsSchemaComment,
+  type DropTableChildObjectSqlOptions,
+  type DropObjectSqlOptions,
+  type TableChildObjectType,
+  type TableAdminSqlOptions,
+} from "@/lib/database/dbAdminSql";
+import { buildRenameObjectSql, supportsObjectRename, type RenameableObjectType } from "@/lib/table/objectRenameSql";
+import { buildRoutineRenameObjectSourceStatements, supportsSourceBackedRoutineRename } from "@/lib/table/objectSourceEditor";
+import { buildViewDdl } from "@/lib/table/viewDdl";
+import { formatSqlForDisplay, sqlFormatDialectForDbType } from "@/lib/sql/sqlFormatter";
+import DdlViewDialog from "@/components/objects/DdlViewDialog.vue";
+import ObjectSourceDialog from "@/components/objects/ObjectSourceDialog.vue";
+import { getTableStructureCapabilities } from "@/lib/table/tableStructureCapabilities";
+import { codeMirrorSqlDialect, connectionObjectTreeNodeSchema, connectionObjectTreeQuerySchema, connectionUsesDatabaseObjectTreeMode, effectiveDatabaseTypeForConnection, tableStructureDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import { hexToRgba } from "@/lib/common/color";
+import { focusSidebarRenameInput } from "@/lib/sidebar/sidebarRenameFocus";
+import { hasTreeNodeDatabaseContext } from "@/lib/sidebar/treeNodeContext";
+import { defaultPasteTableMode, pasteTableModeCopiesData, supportsWholeRowTableDataCopy, tableClipboardMatchesTarget, tableDataCopyColumnOptions, type PasteTableMode, type TableClipboardContext } from "@/lib/table/tableClipboard";
+import { sidebarDisplayTableName } from "@/lib/sidebar/sidebarTableNameDisplay";
+import { shouldMeasureSidebarLabelOverflow } from "@/lib/sidebar/sidebarLabelTooltip";
+import { selectedTreeNodesInVisibleOrder as orderSelectedTreeNodes, treeSelectionRangeIdsByIndex, treeSelectionRangeIds } from "@/lib/sidebar/sidebarTreeSelection";
+import { connectionPasteTargetGroupId, selectedConnectionClipboardTargets, selectedConnectionDeleteTargets, selectedConnectionDuplicateTargets, selectedConnectionEditTarget } from "@/lib/sidebar/sidebarConnectionSelection";
+import { supportsDatabaseUserAdmin } from "@/lib/database/databaseUserAdmin";
+import { canCloseSidebarDatabaseConnection, isSidebarDatabaseOpened } from "@/lib/sidebar/sidebarDatabaseOpenState";
+import { sidebarTreeContextKey } from "@/lib/sidebar/sidebarTreeContext";
+import { batchTableEmptyFeedback, runBatchTableEmpty } from "@/lib/sidebar/batchTableEmpty";
+import { runBatchTableTruncate } from "@/lib/table/batchTableTruncate";
+import DangerConfirmDialog from "@/components/editor/DangerConfirmDialog.vue";
+import ProcedureExecutionDialog from "@/components/objects/ProcedureExecutionDialog.vue";
+import InstallExtensionDialog from "@/components/objects/InstallExtensionDialog.vue";
+import { useExportTracker, type ExportTask } from "@/composables/useExportTracker";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { hasEnabledTransportLayers } from "@/lib/backend/connectionTransport";
+import { isWindows } from "@/lib/backend/platform";
+import { rankSavedSqlHistory, type SavedSqlHistoryScope } from "@/lib/savedSql/savedSqlHistory";
+import { isSqlServerLinkedNode } from "@/lib/database/sqlServerLinkedServers";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import ConnectionErrorIndicator from "@/components/connection/ConnectionErrorIndicator.vue";
+import ProductionContextBadge from "@/components/common/ProductionContextBadge.vue";
+import { isSchemaAware } from "@/lib/database/databaseFeatureSupport";
+import VisibleDatabasesDialog from "@/components/sidebar/VisibleDatabasesDialog.vue";
+import SchemaFilterDialog from "@/components/sidebar/VisibleSchemasDialog.vue";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Input } from "@/components/ui/input";
+import { SearchableSelect } from "@/components/ui/searchable-select";
+import LightTooltip from "@/components/ui/LightTooltip.vue";
+import { flattenTree } from "@/composables/useFlatTree";
+import { createDatabaseCollationOptionsForCharset, fallbackCreateDatabaseCharsetMetadata, nextCreateDatabaseCollation, normalizeCreateDatabaseCharset, parseCreateDatabaseCharsetMetadata } from "@/lib/database/createDatabaseCharsetOptions";
+import { productionContextForDatabase } from "@/lib/database/productionSafety";
+import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
+
+const { t } = useI18n();
+const labelRef = ref<HTMLElement>();
+const rowRef = ref<HTMLElement>();
+const labelOverflowing = ref(false);
+let labelResizeObserver: ResizeObserver | null = null;
+let labelMeasureFrame = 0;
+
+interface ContextMenuItem {
+  label: string;
+  action?: () => void;
+  disabled?: boolean;
+  separator?: boolean;
+  icon?: Component;
+  iconClass?: string;
+  shortcut?: string;
+  variant?: "default" | "destructive";
+  visible?: boolean;
+  children?: ContextMenuItem[];
+}
+
+function cancelLabelOverflowMeasure() {
+  if (!labelMeasureFrame) return;
+  window.cancelAnimationFrame(labelMeasureFrame);
+  labelMeasureFrame = 0;
+}
+
+function measureLabelOverflow(): boolean {
+  const el = labelRef.value;
+  if (!el || !shouldMeasureLabelOverflow()) return false;
+  const style = window.getComputedStyle(el);
+  if (style.overflowX === "visible" || style.textOverflow !== "ellipsis") return false;
+  return el.scrollWidth - el.clientWidth > 2;
+}
+
+function updateLabelOverflow() {
+  labelOverflowing.value = measureLabelOverflow();
+}
+
+function scheduleLabelOverflowMeasure() {
+  if (typeof window === "undefined") {
+    updateLabelOverflow();
+    return;
+  }
+  cancelLabelOverflowMeasure();
+  // Keep synchronous layout reads out of the hover path; they are expensive in
+  // large virtualized sidebar trees, especially on Linux WebKitGTK without GPU help.
+  labelMeasureFrame = window.requestAnimationFrame(() => {
+    labelMeasureFrame = 0;
+    updateLabelOverflow();
+  });
+}
+
+function observeLabelOverflow() {
+  labelResizeObserver?.disconnect();
+  labelResizeObserver = null;
+  if (!shouldMeasureLabelOverflow()) {
+    labelOverflowing.value = false;
+    return;
+  }
+  if (typeof ResizeObserver !== "undefined" && labelRef.value) {
+    labelResizeObserver = new ResizeObserver(scheduleLabelOverflowMeasure);
+    labelResizeObserver.observe(labelRef.value);
+  }
+  scheduleLabelOverflowMeasure();
+}
+const connectionStore = useConnectionStore();
+const queryStore = useQueryStore();
+const settingsStore = useSettingsStore();
+const savedSqlStore = useSavedSqlStore();
+const { toast } = useToast();
+const { highlight } = useSqlHighlighter();
+const useWindowsSidebarCommentFont = isWindows();
+
+type StructureCopyFormat = "tsv" | "markdown";
+type DuplicateStructureSource = TreeNode & { connectionId: string; database: string };
+const DATA_TAB_METADATA_TTL_MS = TABLE_METADATA_CACHE_TTL_MS;
+const { getDatabaseOptions } = useDatabaseOptions();
+const showVisibleDatabasesDialog = ref(false);
+const showVisibleSchemasDialog = ref(false);
+const { addTask: addExportTask } = useExportTracker();
+
+const props = defineProps<{
+  node: TreeNode;
+  depth: number;
+  dragDisabled?: boolean;
+  pendingRename?: boolean;
+  highlighted?: boolean;
+}>();
+
+const emit = defineEmits<{
+  "rename-started": [];
+  "group-created": [groupId: string];
+  "node-toggled": [node: TreeNode, wasExpanded: boolean];
+  "search-toggle": [node: TreeNode];
+}>();
+
+const usesFullWidthLabel = computed(() => usesFullWidthTreeLabel(props.node.type, settingsStore.editorSettings.sidebarAllowHorizontalScroll));
+const sidebarTreeContext = inject(sidebarTreeContextKey, null);
+const rowWidthClass = computed(() => (usesFullWidthLabel.value ? "w-max min-w-full" : "w-full min-w-0"));
+const labelWidthClass = computed(() => (usesFullWidthLabel.value ? "shrink-0 whitespace-nowrap" : "min-w-0 truncate"));
+const nodeProductionContext = computed(() => {
+  const connectionId = props.node.connectionId;
+  return productionContextForDatabase(connectionId ? connectionStore.getConfig(connectionId) : undefined, props.node.database);
+});
+const showProductionBadge = computed(() => nodeProductionContext.value.active && ["connection", "database", "redis-db", "mongo-db"].includes(props.node.type));
+
+function currentDatabaseType(): DatabaseType | undefined {
+  return props.node.connectionId ? effectiveDatabaseTypeForConnection(connectionStore.getConfig(props.node.connectionId)) : undefined;
+}
+
+function currentTableStructureDatabaseType(): DatabaseType | undefined {
+  return props.node.connectionId ? tableStructureDatabaseTypeForConnection(connectionStore.getConfig(props.node.connectionId)) : undefined;
+}
+
+function rawDatabaseType(): DatabaseType | undefined {
+  return props.node.connectionId ? connectionStore.getConfig(props.node.connectionId)?.db_type : undefined;
+}
+
+function databaseTypeForNode(node: TreeNode): DatabaseType | undefined {
+  return node.connectionId ? effectiveDatabaseTypeForConnection(connectionStore.getConfig(node.connectionId)) : undefined;
+}
+
+function tableStructureDatabaseTypeForNode(node: TreeNode): DatabaseType | undefined {
+  return node.connectionId ? tableStructureDatabaseTypeForConnection(connectionStore.getConfig(node.connectionId)) : undefined;
+}
+
+function hasNodeDatabaseContext(node: TreeNode): node is TreeNode & { connectionId: string; database: string } {
+  return !!node.connectionId && hasTreeNodeDatabaseContext(node);
+}
+
+function getIconInfo(node: TreeNode): { icon: any; colorClass: string } | null {
+  switch (node.type) {
+    case "connection":
+      return null;
+    case "connection-group":
+      return { icon: node.isExpanded ? FolderOpen : FolderClosed, colorClass: "text-amber-500" };
+    case "database":
+      return { icon: Database, colorClass: "text-yellow-500" };
+    case "linked-server-root":
+      return { icon: Network, colorClass: "text-blue-500" };
+    case "linked-server":
+      return { icon: Server, colorClass: "text-blue-400" };
+    case "linked-server-catalog":
+      return { icon: Database, colorClass: "text-yellow-500" };
+    case "linked-server-schema":
+      return { icon: FolderOpen, colorClass: "text-sky-400" };
+    case "schema":
+      return { icon: FolderOpen, colorClass: "text-sky-400" };
+    case "table":
+      return { icon: Table, colorClass: "text-green-500" };
+    case "view":
+      return { icon: Eye, colorClass: "text-purple-500" };
+    case "materialized_view":
+      return { icon: Eye, colorClass: "text-indigo-500" };
+    case "column":
+      if ((node.meta as ColumnInfo).is_primary_key) {
+        return { icon: Columns3, colorClass: "text-orange-400" };
+      } else {
+        return { icon: Columns3, colorClass: "text-muted-foreground" };
+      }
+    case "group-columns":
+      return { icon: ListTree, colorClass: "text-green-400" };
+    case "group-indexes":
+      return { icon: Key, colorClass: "text-amber-500" };
+    case "group-fkeys":
+      return { icon: Link, colorClass: "text-blue-400" };
+    case "group-triggers":
+      return { icon: Zap, colorClass: "text-orange-400" };
+    case "object-browser":
+      return { icon: TableProperties, colorClass: "text-primary" };
+    case "user-admin":
+      return { icon: UsersRound, colorClass: "text-primary" };
+    case "dameng-job-admin":
+      return { icon: CalendarClock, colorClass: "text-primary" };
+    case "index":
+      return { icon: Key, colorClass: "text-amber-400" };
+    case "fkey":
+      return { icon: Link, colorClass: "text-blue-300" };
+    case "trigger":
+      return { icon: Zap, colorClass: "text-orange-300" };
+    case "redis-db":
+      return { icon: Database, colorClass: "text-red-400" };
+    case "mq-tenant":
+      return { icon: FolderOpen, colorClass: "text-sky-400" };
+    case "nacos-namespace":
+      return { icon: FolderOpen, colorClass: "text-sky-500" };
+    case "etcd-root":
+      return { icon: Database, colorClass: "text-sky-500" };
+    case "zookeeper-root":
+      return { icon: Database, colorClass: "text-blue-500" };
+    case "mongo-db":
+      return { icon: Database, colorClass: "text-yellow-500" };
+    case "mongo-gridfs":
+    case "mongo-buckets":
+      return { icon: Archive, colorClass: "text-cyan-500" };
+    case "mongo-bucket":
+      return { icon: Archive, colorClass: "text-cyan-400" };
+    case "mongo-collection":
+      return { icon: Table, colorClass: "text-green-400" };
+    case "vector-collection":
+      return { icon: TableProperties, colorClass: "text-cyan-400" };
+    case "elasticsearch-index":
+      return { icon: Table, colorClass: "text-emerald-400" };
+    case "procedure":
+      return { icon: ScrollText, colorClass: "text-blue-500" };
+    case "function":
+      return { icon: Braces, colorClass: "text-amber-500" };
+    case "sequence":
+      return { icon: ListTree, colorClass: "text-emerald-500" };
+    case "package":
+      return { icon: Package, colorClass: "text-cyan-500" };
+    case "package-body":
+      return { icon: FileCode, colorClass: "text-cyan-400" };
+    case "group-tables":
+      return { icon: Table, colorClass: "text-green-500" };
+    case "group-views":
+      return { icon: Eye, colorClass: "text-purple-500" };
+    case "group-materialized-views":
+      return { icon: Eye, colorClass: "text-indigo-500" };
+    case "group-procedures":
+      return { icon: ScrollText, colorClass: "text-blue-500" };
+    case "group-functions":
+      return { icon: Braces, colorClass: "text-amber-500" };
+    case "group-sequences":
+      return { icon: ListTree, colorClass: "text-emerald-500" };
+    case "group-packages":
+      return { icon: Package, colorClass: "text-cyan-500" };
+    case "group-partitions":
+      return { icon: node.isExpanded ? FolderOpen : FolderClosed, colorClass: "text-green-400" };
+    case "group-extensions":
+      return { icon: Package, colorClass: "text-violet-500" };
+    case "extension":
+      return { icon: Package, colorClass: "text-violet-400" };
+    case "load-more":
+      return { icon: Plus, colorClass: "text-primary" };
+    default:
+      return { icon: Database, colorClass: "text-muted-foreground" };
+  }
+}
+
+const groupTypes: Set<TreeNodeType> = new Set(["group-columns", "group-indexes", "group-fkeys", "group-triggers", "group-tables", "group-views", "group-materialized-views", "group-procedures", "group-functions", "group-sequences", "group-packages", "group-partitions", "group-extensions"]);
+function isGroupLabel(node: TreeNode): boolean {
+  return groupTypes.has(node.type);
+}
+
+function displayLabel(node: TreeNode): string {
+  if (node.type === "load-more") return t(node.label);
+  if (node.type === "object-browser") return t(node.label, { count: node.objectCount ?? 0 });
+  if (node.type === "user-admin" || node.type === "dameng-job-admin") return t(node.label);
+  if (node.type === "linked-server-root") return t(node.label);
+  if (node.label === "tree.defaultDatabase") return t(node.label);
+  return isGroupLabel(node) ? t(node.label) : node.label;
+}
+
+function visibleLabel(node: TreeNode): string {
+  if (node.type === "table" || node.type === "view" || node.type === "materialized_view" || node.type === "mongo-collection" || node.type === "vector-collection" || node.type === "elasticsearch-index") {
+    return sidebarDisplayTableName(node.label, settingsStore.editorSettings.sidebarHiddenTablePrefixes);
+  }
+  return displayLabel(node);
+}
+
+type DetailTooltipRow = {
+  label: string;
+  value: string;
+  multiline?: boolean;
+};
+
+function cleanTooltipValue(value: string | number | null | undefined): string {
+  return String(value ?? "").trim();
+}
+
+function isLocalFileConnection(config: Pick<ConnectionConfig, "db_type" | "port">): boolean {
+  return config.db_type === "sqlite" || config.db_type === "duckdb" || config.db_type === "access" || (config.db_type === "h2" && config.port === 0);
+}
+
+function redactedConnectionString(value: string): string {
+  return value.replace(/(:\/\/[^/\s:@?#;]+):([^@\s/?#;]+)@/g, "$1:***@").replace(/([?&;](?:password|pwd|pass|token|secret|key)=)[^&;]*/gi, "$1***");
+}
+
+function connectionTooltipScheme(config: Pick<ConnectionConfig, "db_type" | "ssl">): string {
+  switch (config.db_type) {
+    case "postgres":
+    case "gaussdb":
+    case "kwdb":
+    case "yashandb":
+    case "redshift":
+    case "questdb":
+      return "postgresql";
+    case "sqlserver":
+      return "mssql";
+    case "elasticsearch":
+    case "qdrant":
+    case "milvus":
+    case "weaviate":
+    case "chromadb":
+    case "rqlite":
+    case "turso":
+    case "mq":
+      return config.ssl ? "https" : "http";
+    case "cloudflare-d1":
+      return "https";
+    case "dameng":
+      return "dm";
+    default:
+      return config.db_type;
+  }
+}
+
+function hostForDisplay(host: string): string {
+  if (!host.includes(":") || host.startsWith("[") || host.includes("://")) return host;
+  return `[${host}]`;
+}
+
+function connectionTooltipUrl(config: ConnectionConfig): string {
+  const explicit = cleanTooltipValue(config.connection_string);
+  if (explicit) return redactedConnectionString(explicit);
+
+  const host = cleanTooltipValue(config.host);
+  if (!host) return "";
+  if (host.includes("://")) return redactedConnectionString(host);
+
+  if (isLocalFileConnection(config)) {
+    if (config.db_type === "access") return `jdbc:ucanaccess://${host}`;
+    return `${config.db_type}://${host}`;
+  }
+
+  const scheme = connectionTooltipScheme(config);
+  const port = Number(config.port) > 0 ? `:${config.port}` : "";
+  const user = cleanTooltipValue(config.username);
+  const userInfo = user ? `${encodeURIComponent(user)}@` : "";
+  const database = cleanTooltipValue(config.database);
+  const path = database ? `/${encodeURIComponent(database)}` : "";
+  const params = cleanTooltipValue(config.url_params);
+  const query = params ? (params.startsWith("?") ? params : `?${params}`) : "";
+  return redactedConnectionString(`${scheme}://${userInfo}${hostForDisplay(host)}${port}${path}${query}`);
+}
+
+const connectionInfoTooltip = computed(() => {
+  const node = props.node;
+  if (node.type !== "connection" || !node.connectionId) return null;
+  const config = connectionStore.getConfig(node.connectionId);
+  if (!config) return null;
+
+  const hostLabel = isLocalFileConnection(config) ? t("connection.filePath") : t("connection.host");
+  const rows: DetailTooltipRow[] = [
+    { label: t("connection.name"), value: cleanTooltipValue(config.name) },
+    { label: "URL", value: connectionTooltipUrl(config), multiline: true },
+    { label: hostLabel, value: cleanTooltipValue(config.host), multiline: isLocalFileConnection(config) },
+    { label: "Port", value: Number(config.port) > 0 ? String(config.port) : "" },
+    { label: t("connection.database"), value: cleanTooltipValue(config.database) },
+    { label: t("connection.user"), value: cleanTooltipValue(config.username) },
+    { label: t("connection.type"), value: config.driver_label || config.driver_profile || config.db_type },
+  ].filter((row) => row.value);
+
+  return { rows };
+});
+
+const objectCommentTooltip = computed(() => {
+  const node = props.node;
+  const comment = node.type === "column" && node.meta && "comment" in node.meta ? (node.meta as ColumnInfo).comment : node.comment;
+  if (!comment || (node.type !== "schema" && node.type !== "table" && node.type !== "view" && node.type !== "column")) return null;
+  const rows: DetailTooltipRow[] = [
+    { label: t("connection.name"), value: visibleLabel(node) },
+    { label: t("structureEditor.comment"), value: cleanTooltipValue(comment), multiline: true },
+  ].filter((row) => row.value);
+  return { rows };
+});
+
+const detailTooltip = computed(() => connectionInfoTooltip.value ?? objectCommentTooltip.value);
+
+function isTooltipDisabled(): boolean {
+  if (detailTooltip.value?.rows.length) return isRenamingGroup.value;
+  return isRenamingGroup.value || !labelOverflowing.value;
+}
+
+async function toggle() {
+  const node = props.node;
+  if (node.isLoading) {
+    return;
+  }
+  emit("search-toggle", node);
+  const wasExpanded = !!node.isExpanded;
+
+  if (node.type === "connection-group") {
+    node.isExpanded = !node.isExpanded;
+    connectionStore.toggleConnectionGroupCollapsed(node.id);
+    emit("node-toggled", node, wasExpanded);
+    return;
+  }
+
+  if (node.type === "group-partitions") {
+    node.isExpanded = !node.isExpanded;
+    emit("node-toggled", node, wasExpanded);
+    return;
+  }
+
+  const databaseObjectGroup = node.type === "group-tables" || node.type === "group-views" || node.type === "group-materialized-views" || node.type === "group-procedures" || node.type === "group-functions" || node.type === "group-sequences" || node.type === "group-packages";
+  if (databaseObjectGroup && connectionStore.isTreeNodeChildrenLoaded(node.id)) {
+    node.isExpanded = !node.isExpanded;
+    emit("node-toggled", node, wasExpanded);
+    return;
+  }
+
+  if (node.isExpanded) {
+    node.isExpanded = false;
+    emit("node-toggled", node, wasExpanded);
+    return;
+  }
+
+  try {
+    if (node.type === "connection" && node.connectionId) {
+      const config = connectionStore.getConfig(node.connectionId);
+      if (config?.db_type === "redis") {
+        await connectionStore.loadRedisDatabases(node.connectionId);
+      } else if (config?.db_type === "etcd") {
+        await connectionStore.loadEtcdRoot(node.connectionId);
+      } else if (config?.db_type === "zookeeper") {
+        await connectionStore.loadZooKeeperRoot(node.connectionId);
+      } else if (config?.db_type === "mongodb") {
+        await connectionStore.loadMongoDatabases(node.connectionId);
+      } else if (config?.db_type === "elasticsearch") {
+        await connectionStore.loadElasticsearchIndices(node.connectionId);
+      } else if (config?.db_type === "milvus") {
+        await connectionStore.loadMilvusDatabases(node.connectionId);
+      } else if (config?.db_type === "qdrant" || config?.db_type === "weaviate" || config?.db_type === "chromadb") {
+        await connectionStore.loadVectorCollections(node.connectionId);
+      } else if (config?.db_type === "mq") {
+        await connectionStore.loadMqTenants(node.connectionId);
+      } else if (config?.db_type === "nacos") {
+        await connectionStore.loadNacosNamespaces(node.connectionId);
+      } else {
+        await connectionStore.loadDatabases(node.connectionId);
+      }
+    } else if (node.type === "redis-db" && node.connectionId && node.database) {
+      await connectionStore.ensureConnected(node.connectionId);
+      const tabTitle = `${connectionStore.getConfig(node.connectionId)?.name || "Redis"}:db${node.database}`;
+      queryStore.createTab(node.connectionId, node.database, tabTitle, "redis");
+    } else if (node.type === "mq-tenant" && node.connectionId) {
+      await connectionStore.ensureConnected(node.connectionId);
+      queryStore.openMqAdmin(node.connectionId, { tenant: node.mqTenant || node.label, initialTab: node.mqInitialTab });
+    } else if (node.type === "nacos-namespace" && node.connectionId) {
+      await connectionStore.ensureConnected(node.connectionId);
+      queryStore.openNacosAdmin(node.connectionId, { namespace: node.nacosNamespace || "", namespaceName: node.nacosNamespaceName || node.label });
+    } else if (node.type === "etcd-root" && node.connectionId) {
+      await connectionStore.ensureConnected(node.connectionId);
+      const tabTitle = `${connectionStore.getConfig(node.connectionId)?.name || "etcd"}:keys`;
+      queryStore.createTab(node.connectionId, "", tabTitle, "etcd");
+      refreshActiveKvBrowserAfterOpen("etcd", node.connectionId);
+    } else if (node.type === "zookeeper-root" && node.connectionId) {
+      await connectionStore.ensureConnected(node.connectionId);
+      const tabTitle = `${connectionStore.getConfig(node.connectionId)?.name || "ZooKeeper"}:keys`;
+      queryStore.createTab(node.connectionId, "", tabTitle, "zookeeper");
+      refreshActiveKvBrowserAfterOpen("zookeeper", node.connectionId);
+    } else if (node.type === "user-admin" && node.connectionId) {
+      await connectionStore.ensureConnected(node.connectionId);
+      queryStore.openUserAdmin(node.connectionId);
+    } else if (node.type === "dameng-job-admin" && node.connectionId) {
+      await connectionStore.ensureConnected(node.connectionId);
+      queryStore.openDamengJobAdmin(node.connectionId);
+    } else if (node.type === "mongo-db" && node.connectionId && node.database) {
+      await connectionStore.loadMongoCollections(node.connectionId, node.database);
+    } else if (node.type === "vector-database" && node.connectionId && node.database) {
+      await connectionStore.loadVectorCollections(node.connectionId, node.database);
+    } else if (node.type === "mongo-collection" && node.connectionId && node.database) {
+      await connectionStore.loadTableGroups(node.connectionId, node.database, node.label, node.schema, node.id);
+    } else if (node.type === "elasticsearch-index" && node.connectionId) {
+      await connectionStore.ensureConnected(node.connectionId);
+      const tab = queryStore.createTab(node.connectionId, node.database || "default", node.label, "mongo");
+      queryStore.updateSql(tab, node.label);
+    } else if (node.type === "vector-collection" && node.connectionId) {
+      await connectionStore.ensureConnected(node.connectionId);
+      const collectionRef = (node.meta as { collectionId?: string } | undefined)?.collectionId ?? node.label;
+      const tab = queryStore.createTab(node.connectionId, node.database || "default", node.label, "vector");
+      queryStore.updateSql(tab, collectionRef);
+      api
+        .vectorGetCollectionDetail(node.connectionId, node.database || "default", collectionRef)
+        .then((info) => {
+          if (info.dimension != null) {
+            if (node.meta) {
+              (node.meta as Record<string, unknown>).dimension = info.dimension;
+            } else {
+              node.meta = { dimension: info.dimension } as any;
+            }
+          }
+        })
+        .catch(() => {});
+    } else if (node.type === "database" && node.connectionId && hasTreeNodeDatabaseContext(node)) {
+      if (node.catalog && node.catalog !== "internal") {
+        await connectionStore.loadDorisCatalogTables(node);
+      } else {
+        const config = connectionStore.getConfig(node.connectionId);
+        const effectiveDbType = effectiveDatabaseTypeForConnection(config);
+        if (config?.db_type === "sqlserver") {
+          await connectionStore.loadSqlServerDatabaseObjects(node.connectionId, node.database);
+        } else if (usesTreeSchemaMode(effectiveDbType) && !connectionUsesDatabaseObjectTreeMode(config)) {
+          await connectionStore.loadSchemas(node.connectionId, node.database);
+        } else {
+          await connectionStore.loadTables(node.connectionId, node.database);
+        }
+      }
+    } else if (node.type === "doris-catalog" && node.connectionId) {
+      await connectionStore.loadDorisCatalogDatabases(node);
+    } else if (node.type === "schema" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.schema) {
+      await connectionStore.loadTables(node.connectionId, node.database, node.schema);
+    } else if (node.type === "linked-server-root" && node.connectionId) {
+      await connectionStore.loadSqlServerLinkedServers(node.connectionId);
+    } else if (node.type === "linked-server" && node.connectionId) {
+      await connectionStore.loadSqlServerLinkedServerCatalogs(node);
+    } else if (node.type === "linked-server-catalog" && node.connectionId) {
+      await connectionStore.loadSqlServerLinkedServerSchemas(node);
+    } else if (node.type === "linked-server-schema" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.schema) {
+      await connectionStore.loadTables(node.connectionId, node.database, node.schema);
+    } else if ((node.type === "table" || node.type === "view" || node.type === "materialized_view") && node.connectionId && hasTreeNodeDatabaseContext(node)) {
+      await connectionStore.loadTableGroups(node.connectionId, node.database, node.label, node.schema, node.id, node.catalog);
+    } else if (node.type === "group-columns" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.tableName) {
+      await connectionStore.loadColumns(node.connectionId, node.database, node.tableName, node.schema, node.id, node.catalog);
+    } else if (node.type === "group-indexes" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.tableName) {
+      await connectionStore.loadIndexes(node.connectionId, node.database, node.tableName, node.schema, node.id, node.catalog);
+    } else if (node.type === "group-fkeys" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.tableName) {
+      await connectionStore.loadForeignKeys(node.connectionId, node.database, node.tableName, node.schema, node.id, node.catalog);
+    } else if (node.type === "group-triggers" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.tableName) {
+      await connectionStore.loadTriggers(node.connectionId, node.database, node.tableName, node.schema, node.id, node.catalog);
+    } else if (databaseObjectGroup) {
+      await connectionStore.loadObjectGroupChildren(node);
+    }
+    emit("node-toggled", node, wasExpanded);
+  } catch (e: any) {
+    if (!wasExpanded) node.isExpanded = false;
+    const errMsg = e?.message || String(e);
+    if (errMsg.includes(CONNECTION_ATTEMPT_CANCELLED_MESSAGE)) return;
+    toast(t("connection.connectFailed", { message: translateBackendError(t, errMsg) }), 5000);
+    if (errMsg.includes("driver is not installed") || errMsg.includes("is not installed")) {
+      window.dispatchEvent(new Event("dbx-open-driver-store"));
+    }
+  }
+}
+
+function runRowClickAction(clickDetail: number) {
+  const node = props.node;
+  if (node.type === "load-more") {
+    if (clickDetail > 1) return;
+    void loadMoreObjectGroupChildren();
+    return;
+  }
+  if (node.type === "object-browser") {
+    if (clickDetail > 1) return;
+    void openObjectBrowser();
+    return;
+  }
+  if (node.type === "mongo-gridfs") {
+    openMongoTreeData(node);
+    return;
+  }
+  const action = treeNodeRowAction(node.type, canExpand.value, settingsStore.editorSettings.sidebarActivation);
+  if (!shouldRunTreeNodeRowAction(action, clickDetail)) return;
+  if (action === "open-data") {
+    openData();
+  } else if (isDocumentBrowserTreeNode(node.type)) {
+    openMongoTreeData(node);
+  } else if (node.type === "procedure" || node.type === "function" || node.type === "sequence" || node.type === "package" || node.type === "package-body") {
+    openObjectSourceDialog(false);
+  } else if (action === "toggle") {
+    toggle();
+  }
+}
+
+function refreshActiveKvBrowserAfterOpen(mode: "etcd" | "zookeeper", connectionId: string) {
+  void nextTick(() => {
+    window.dispatchEvent(new CustomEvent("dbx-refresh-active-kv-browser", { detail: { mode, connectionId } }));
+  });
+}
+
+async function loadMoreObjectGroupChildren() {
+  try {
+    await connectionStore.loadMoreObjectGroupChildren(props.node);
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+async function loadAllObjectGroupChildren() {
+  try {
+    await connectionStore.loadAllObjectGroupChildren(props.node);
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+function onToggleClick() {
+  selectSingleTreeNode(props.node);
+  rowRef.value?.focus({ preventScroll: true });
+  void toggle();
+}
+
+function onToggleMouseDown(event: MouseEvent) {
+  if (event.button !== 0) return;
+  selectSingleTreeNode(props.node);
+  rowRef.value?.focus({ preventScroll: true });
+}
+
+function visibleTreeNodes(): TreeNode[] {
+  if (sidebarTreeContext) return sidebarTreeContext.getVisibleNodes();
+  return flattenTree(connectionStore.treeNodes).map((item) => item.node);
+}
+
+function selectedTreeNodesInVisibleOrder(): TreeNode[] {
+  return orderSelectedTreeNodes(visibleTreeNodes(), connectionStore.selectedTreeNodeIds);
+}
+
+function selectSingleTreeNode(node: TreeNode) {
+  // Re-clicking the selected row should not replace the selection array and
+  // force visible tree rows to recompute.
+  if (!connectionStore.connectionMultiSelectActive && connectionStore.selectedTreeNodeId === node.id && connectionStore.treeSelectionAnchorId === node.id && connectionStore.selectedTreeNodeIds.length === 1 && connectionStore.selectedTreeNodeIds[0] === node.id) {
+    return;
+  }
+  connectionStore.connectionMultiSelectActive = false;
+  connectionStore.selectedTreeNodeId = node.id;
+  connectionStore.selectedTreeNodeIds = [node.id];
+  connectionStore.treeSelectionAnchorId = node.id;
+}
+
+function toggleTreeNodeSelection(node: TreeNode) {
+  connectionStore.connectionMultiSelectActive = false;
+  const ids = new Set(connectionStore.selectedTreeNodeIds);
+  if (ids.has(node.id)) ids.delete(node.id);
+  else ids.add(node.id);
+  connectionStore.selectedTreeNodeIds = ids.size ? [...ids] : [node.id];
+  connectionStore.selectedTreeNodeId = node.id;
+  connectionStore.treeSelectionAnchorId = node.id;
+}
+
+function selectTreeNodeRange(node: TreeNode) {
+  connectionStore.connectionMultiSelectActive = false;
+  const visible = visibleTreeNodes();
+  const anchorId = connectionStore.treeSelectionAnchorId || connectionStore.selectedTreeNodeId || node.id;
+  const currentIndex = sidebarTreeContext ? sidebarTreeContext.getVisibleNodeIndex(node.id) : -1;
+  const anchorIndex = sidebarTreeContext ? sidebarTreeContext.getVisibleNodeIndex(anchorId) : -1;
+
+  if (sidebarTreeContext && currentIndex >= 0 && anchorIndex >= 0) {
+    connectionStore.selectedTreeNodeIds = treeSelectionRangeIdsByIndex(visible, currentIndex, anchorIndex, node.id);
+    connectionStore.selectedTreeNodeId = node.id;
+    return;
+  }
+
+  if (!visible.some((item) => item.id === anchorId) || !visible.some((item) => item.id === node.id)) {
+    selectSingleTreeNode(node);
+    return;
+  }
+
+  const rangeIds = treeSelectionRangeIds(visible, node.id, anchorId, connectionStore.selectedTreeNodeId);
+  connectionStore.selectedTreeNodeIds = rangeIds;
+  connectionStore.selectedTreeNodeId = node.id;
+}
+
+function selectedConnectionIdsForAction(): string[] {
+  const connectionIds = new Set(connectionStore.connections.map((connection) => connection.id));
+  return connectionStore.selectedTreeNodeIds.filter((id) => connectionIds.has(id));
+}
+
+const isConnectionSelectionChecked = computed(() => {
+  if (!connectionStore.connectionMultiSelectActive || props.node.type !== "connection" || !props.node.connectionId) return false;
+  return connectionStore.selectedTreeNodeIds.includes(props.node.connectionId);
+});
+
+function toggleConnectionMultiSelection(event: MouseEvent) {
+  event.preventDefault();
+  event.stopPropagation();
+  if (props.node.type !== "connection" || !props.node.connectionId) return;
+
+  // Keep connection-id normalization off the row render path; this handler only
+  // runs when the checkbox is clicked, while the checked state updates often.
+  const next = new Set(connectionStore.connectionMultiSelectActive ? selectedConnectionIdsForAction() : []);
+  if (next.has(props.node.connectionId)) next.delete(props.node.connectionId);
+  else next.add(props.node.connectionId);
+
+  const ids = [...next];
+  connectionStore.selectedTreeNodeIds = ids;
+  connectionStore.selectedTreeNodeId = ids.includes(props.node.connectionId) ? props.node.connectionId : (ids[0] ?? null);
+  connectionStore.treeSelectionAnchorId = props.node.connectionId;
+  connectionStore.connectionMultiSelectActive = ids.length > 0;
+  rowRef.value?.focus({ preventScroll: true });
+}
+
+function onClick(event: MouseEvent) {
+  if (suppressNextTableReferenceClick) {
+    suppressNextTableReferenceClick = false;
+    event.preventDefault();
+    event.stopPropagation();
+    return;
+  }
+  // Row clicks must not bubble to the tree container, whose click handler
+  // clears the selection when the blank area is clicked (issue #681).
+  event.stopPropagation();
+  if (event.shiftKey) {
+    selectTreeNodeRange(props.node);
+    rowRef.value?.focus({ preventScroll: true });
+    return;
+  }
+  if (event.metaKey || event.ctrlKey) {
+    toggleTreeNodeSelection(props.node);
+    rowRef.value?.focus({ preventScroll: true });
+    return;
+  }
+  selectSingleTreeNode(props.node);
+  rowRef.value?.focus({ preventScroll: true });
+  if (settingsStore.editorSettings.sidebarActivation === "double") return;
+  runRowClickAction(event.detail);
+}
+
+function onTreeItemContextMenu(event: MouseEvent, openContextMenu: (event: MouseEvent) => void) {
+  if (!connectionStore.selectedTreeNodeIds.includes(props.node.id)) {
+    selectSingleTreeNode(props.node);
+  } else {
+    connectionStore.selectedTreeNodeId = props.node.id;
+  }
+  rowRef.value?.focus({ preventScroll: true });
+  openContextMenu(event);
+}
+
+function isEditableShortcutTarget(target: EventTarget | null): boolean {
+  if (!(target instanceof HTMLElement)) return false;
+  return target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target.isContentEditable || !!target.closest("[contenteditable='true']");
+}
+
+function onKeydown(event: KeyboardEvent) {
+  if ((!isSelected.value && !isMultiSelected.value) || isEditableShortcutTarget(event.target)) return;
+  if (isPasteTreeClipboardShortcut(event)) {
+    if (!requestPasteTreeClipboard()) return;
+    event.preventDefault();
+    event.stopPropagation();
+    return;
+  }
+  if (isEditConnectionShortcut(event)) {
+    if (!requestEditSelectedConnection()) return;
+    event.preventDefault();
+    event.stopPropagation();
+    return;
+  }
+  if (!event.metaKey && !event.ctrlKey && !event.altKey && !event.shiftKey && event.key === "F2") {
+    if (!requestRenameSelectedNode()) return;
+    event.preventDefault();
+    event.stopPropagation();
+    return;
+  }
+  if (!event.metaKey && !event.ctrlKey && !event.altKey && !event.shiftKey && event.key === "F5") {
+    if (!requestRefreshSelectedNode()) return;
+    event.preventDefault();
+    event.stopPropagation();
+    return;
+  }
+  if (!event.metaKey && !event.ctrlKey && !event.altKey && !event.shiftKey && isDeleteTreeNodeShortcut(event)) {
+    if (!requestDeleteSelectedNode()) return;
+    event.preventDefault();
+    event.stopPropagation();
+    return;
+  }
+  if (!isCopyTreeSelectionShortcut(event)) return;
+  event.preventDefault();
+  event.stopPropagation();
+  copySelectedNames();
+}
+
+function isDeleteTreeNodeShortcut(event: KeyboardEvent): boolean {
+  return event.key === "Delete" || event.key === "Backspace";
+}
+
+function isPasteTreeClipboardShortcut(event: KeyboardEvent): boolean {
+  return isPasteSidebarSelectionShortcut(event, settingsStore.editorSettings.shortcuts);
+}
+
+function isEditConnectionShortcut(event: KeyboardEvent): boolean {
+  return isEditSidebarConnectionShortcut(event, settingsStore.editorSettings.shortcuts);
+}
+
+function isCopyTreeSelectionShortcut(event: KeyboardEvent): boolean {
+  return isCopySidebarSelectionShortcut(event, settingsStore.editorSettings.shortcuts);
+}
+
+function pasteTableTargetContext(): TableClipboardContext | null {
+  if (!props.node.connectionId || !props.node.database) return null;
+  return {
+    connectionId: props.node.connectionId,
+    database: props.node.database,
+    schema: props.node.schema,
+  };
+}
+
+function canPasteTreeClipboardToCurrentNode(): boolean {
+  const clipboard = connectionStore.treeClipboard;
+  return clipboard?.kind === "table-copy" && tableClipboardMatchesTarget(clipboard.tables, pasteTableTargetContext());
+}
+
+function requestPasteTreeClipboard(): boolean {
+  const clipboard = connectionStore.treeClipboard;
+  if (clipboard?.kind === "connection-copy") {
+    const targetGroupId = connectionPasteTargetGroupId(props.node, (connectionId) => connectionStore.groupIdForConnection(connectionId));
+    void connectionStore
+      .pasteConnectionClipboard(targetGroupId)
+      .then((count) => {
+        if (count > 0) toast(count > 1 ? t("connection.duplicatedSelected", { count }) : t("connection.duplicated"), 2000);
+      })
+      .catch((e: any) => toast(t("connection.saveFailed", { message: e?.message || String(e) }), 5000));
+    return true;
+  }
+  if (clipboard?.kind !== "table-copy" || !canPasteTreeClipboardToCurrentNode()) return false;
+  pasteTableMode.value = defaultPasteTableMode(currentDatabaseType());
+  pasteTableEntries.value = clipboard.tables.map((entry) => ({
+    sourceName: entry.tableName,
+    targetName: `${entry.tableName}_copy`,
+    connectionId: entry.connectionId,
+    database: entry.database,
+    schema: entry.schema,
+  }));
+  showPasteDialog.value = true;
+  return true;
+}
+
+function onSidebarRequestPasteTable(event: Event) {
+  const nodeId = (event as CustomEvent<{ nodeId?: string }>).detail?.nodeId;
+  if (nodeId !== props.node.id) return;
+  requestPasteTreeClipboard();
+}
+
+function requestRefreshSelectedNode(): boolean {
+  if (!canRefreshTreeNodeShortcut()) return false;
+  void refresh();
+  return true;
+}
+
+function canRefreshTreeNodeShortcut(): boolean {
+  const type = props.node.type;
+  if (type === "connection" || type === "database" || type === "schema" || type === "table" || type === "view") {
+    return true;
+  }
+  return isGroupLabel(props.node) && type !== "group-partitions";
+}
+
+function requestRenameSelectedNode(): boolean {
+  const selected = selectedTreeNodesInVisibleOrder();
+  if (selected.length > 1 && selected.some((node) => node.id === props.node.id)) return false;
+  const editTarget = selectedConnectionEditTarget(props.node, selected);
+  if (editTarget) {
+    connectionStore.startEditing(editTarget.connectionId);
+    return true;
+  }
+  if (canRenameObject.value) {
+    openRenameObjectDialog();
+    return true;
+  }
+  if (props.node.type === "connection-group") {
+    startRenameGroup();
+    return true;
+  }
+  return false;
+}
+
+function requestEditSelectedConnection(): boolean {
+  const editTarget = selectedConnectionEditTarget(props.node, selectedTreeNodesInVisibleOrder());
+  if (!editTarget) return false;
+  connectionStore.startEditing(editTarget.connectionId);
+  return true;
+}
+
+function requestDeleteSelectedNode(): boolean {
+  if (requestDropSelectedNodes()) return true;
+  if (props.node.type === "connection") {
+    deleteConnection();
+    return true;
+  }
+  if (props.node.type === "connection-group") {
+    deleteConnectionGroup();
+    return true;
+  }
+  if (canDropDatabase.value) {
+    dropDatabase();
+    return true;
+  }
+  if (canDropMongoDatabase.value) {
+    dropDatabase();
+    return true;
+  }
+  if (canDropMongoCollection.value) {
+    dropMongoCollection();
+    return true;
+  }
+  if (canDropSchema.value) {
+    dropSchema();
+    return true;
+  }
+  return false;
+}
+
+function onDoubleClick() {
+  const action = treeNodeRowDoubleClickAction(props.node.type, canOpenObjectBrowser.value, settingsStore.editorSettings.sidebarActivation, canExpand.value);
+  if (action === "open-object-browser") {
+    void openObjectBrowser();
+  } else if (action === "open-object-browser-and-expand") {
+    void openObjectBrowser();
+    if (!props.node.isExpanded) void toggle();
+  } else if (action === "open-data") {
+    openData();
+  } else if (action === "open-source") {
+    openObjectSourceDialog(false);
+  } else if (action === "open-saved-sql") {
+    openSavedSqlFile();
+  } else if (action === "toggle" && (props.node.type === "mongo-gridfs" || isDocumentBrowserTreeNode(props.node.type))) {
+    openMongoTreeData(props.node);
+  } else if (action === "toggle") {
+    toggle();
+  }
+}
+
+function openMongoTreeData(node: TreeNode) {
+  if (!node.connectionId || !node.database) return;
+  if (node.type === "mongo-gridfs") {
+    queryStore.openMongoGridFs(node.connectionId, node.database);
+    return;
+  }
+  const tabTitle = `${node.database}.${node.label}`;
+  if (node.type === "mongo-bucket") {
+    queryStore.openMongoBucket(node.connectionId, node.database, node.label);
+    return;
+  }
+  if (node.type !== "mongo-collection") return;
+  const tab = queryStore.createTab(node.connectionId, node.database, tabTitle, "mongo");
+  queryStore.updateSql(tab, node.label);
+}
+
+async function openSavedSqlFile() {
+  const node = props.node;
+  if (node.type !== "saved-sql-file" || !node.savedSqlId) return;
+  const file = await savedSqlStore.ensureFileContent(node.savedSqlId);
+  if (!file) return;
+  queryStore.openSavedSql(file);
+  connectionStore.activeConnectionId = file.connectionId;
+  void savedSqlStore.recordFileUsage(file.id);
+}
+
+async function openObjectBrowser() {
+  const node = props.node;
+  if (!node.connectionId) return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    connectionStore.activeConnectionId = node.connectionId;
+
+    if (hasTreeNodeDatabaseContext(node)) {
+      queryStore.openObjectBrowser(node.connectionId, node.database, node.schema, node.catalog);
+      return;
+    }
+
+    const connection = connectionStore.getConfig(node.connectionId);
+    if (!connection) return;
+    const options = await getDatabaseOptions(node.connectionId);
+    const database = resolveDefaultDatabase(connection, options);
+    if (database) {
+      queryStore.openObjectBrowser(node.connectionId, database);
+    } else {
+      await toggle();
+    }
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+    if (e?.message?.includes("driver is not installed") || (e?.message?.includes("JRE") && e?.message?.includes("not installed"))) {
+      window.dispatchEvent(new Event("dbx-open-driver-store"));
+    }
+  }
+}
+
+async function openUserAdmin() {
+  const node = props.node;
+  if (!node.connectionId) return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    connectionStore.activeConnectionId = node.connectionId;
+    queryStore.openUserAdmin(node.connectionId);
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+async function openDamengJobAdmin() {
+  const node = props.node;
+  if (!node.connectionId) return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    connectionStore.activeConnectionId = node.connectionId;
+    queryStore.openDamengJobAdmin(node.connectionId);
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+async function openData() {
+  const node = props.node;
+  if (!(node.type === "table" || node.type === "view" || node.type === "materialized_view") || !hasNodeDatabaseContext(node)) return;
+  const config = connectionStore.getConfig(node.connectionId);
+  const traceId = uuid().slice(0, 8);
+  const startedAt = performance.now();
+  let lastPhaseAt = startedAt;
+  const elapsed = () => `${Math.round(performance.now() - startedAt)}ms`;
+  const logPhase = (phase: string, extra: Record<string, unknown> = {}) => {
+    const now = performance.now();
+    console.info("[DBX][openData:phase]", {
+      traceId,
+      phase,
+      deltaMs: Math.round(now - lastPhaseAt),
+      totalMs: Math.round(now - startedAt),
+      ...extra,
+    });
+    lastPhaseAt = now;
+  };
+  console.info("[DBX][openData:start]", {
+    traceId,
+    type: node.type,
+    connectionId: node.connectionId,
+    database: node.database,
+    schema: node.schema,
+    table: node.label,
+    dbType: config?.db_type,
+  });
+  const tableSchema = connectionObjectTreeNodeSchema(config, node.database, node.schema);
+  const tableType = node.type === "view" ? "VIEW" : node.type === "materialized_view" ? "MATERIALIZED_VIEW" : (node.tableType ?? "TABLE");
+  const querySchema = config ? connectionObjectTreeQuerySchema(config, node.database, tableSchema) : (tableSchema ?? "");
+  const effectiveDbType = effectiveDatabaseTypeForConnection(config);
+  const metadataDatabaseType = effectiveDbType || config?.db_type || "";
+  const isSameDataTableTab = (tab: (typeof queryStore.tabs)[number]) =>
+    tab.mode === "data" && tab.connectionId === node.connectionId && tab.database === node.database && (tab.tableMeta?.catalog || "") === (node.catalog || "") && (tab.schema || "") === (tableSchema || "") && (tab.tableMeta?.tableName || tab.title) === node.label;
+  const existingSameTableTab = queryStore.tabs.find(isSameDataTableTab);
+  const resetReusedDataTabState = (tab: (typeof queryStore.tabs)[number]) => {
+    tab.title = node.label;
+    tab.schema = tableSchema;
+    tab.whereInput = undefined;
+    tab.orderByInput = undefined;
+    tab.previewSql = undefined;
+    tab.resultSortColumn = undefined;
+    tab.resultSortColumnIndex = undefined;
+    tab.resultSortDirection = undefined;
+    tab.resultSortMode = undefined;
+    tab.resultLocalSortOriginalRows = undefined;
+    tab.resultLocalSortOriginalMongoDocuments = undefined;
+    tab.resultSortedSql = undefined;
+    tab.resultPageSql = undefined;
+    tab.resultPageLimit = undefined;
+    tab.resultPageOffset = undefined;
+    tab.resultTotalRowCount = undefined;
+    tab.resultTotalRowCountLoading = undefined;
+    tab.queryAnalysis = undefined;
+    tab.querySourceColumns = undefined;
+    tab.queryEditabilityReason = undefined;
+  };
+
+  if (existingSameTableTab && canActivateExistingDataTableTab(existingSameTableTab)) {
+    queryStore.switchTab(existingSameTableTab.id);
+    logPhase("existing-tab-activated", { table: node.label });
+    return;
+  }
+
+  const tabId = (() => {
+    if (existingSameTableTab) {
+      queryStore.switchTab(existingSameTableTab.id);
+      resetReusedDataTabState(existingSameTableTab);
+      return existingSameTableTab.id;
+    }
+    if (settingsStore.editorSettings.reuseDataTab) {
+      const existing = queryStore.tabs.find((tab) => tab.mode === "data" && tab.connectionId === node.connectionId && tab.database === node.database);
+      if (existing) {
+        queryStore.switchTab(existing.id);
+        resetReusedDataTabState(existing);
+        return existing.id;
+      }
+    }
+    return queryStore.createTab(node.connectionId, node.database, node.label, "data", tableSchema);
+  })();
+  console.info("[DBX][openData:tab-created]", { traceId, tabId, elapsed: elapsed() });
+  logPhase("tab-created", { tabId });
+
+  // Cancel any previous execution on this tab before starting a new one
+  const existingTab = queryStore.tabs.find((t) => t.id === tabId);
+  if (existingTab?.isExecuting && existingTab.executionId) {
+    await queryStore.cancelTabExecution(tabId);
+    logPhase("previous-execution-cancelled", { tabId });
+  }
+
+  const openDataId = uuid();
+  // Clear previous result so DataGrid doesn't show its internal loading overlay (without stop button)
+  const tab = queryStore.tabs.find((t) => t.id === tabId);
+  if (tab) {
+    tab.result = undefined;
+    tab.results = undefined;
+  }
+  const existingTableMeta = tab?.tableMeta;
+  const existingTableMetaAgeMs = tab?.tableMetaUpdatedAt ? Date.now() - tab.tableMetaUpdatedAt : Number.POSITIVE_INFINITY;
+  const sharedCachedTableMeta = config
+    ? getCachedTableMetadata({
+        connectionId: node.connectionId,
+        database: node.database,
+        schema: querySchema,
+        tableName: node.label,
+        tableType,
+        databaseType: metadataDatabaseType,
+        driverProfile: config.driver_profile || config.db_type,
+        catalog: node.catalog,
+      })
+    : undefined;
+  const tabCachedTableMeta =
+    existingTableMeta?.tableName === node.label && (existingTableMeta.catalog || "") === (node.catalog || "") && existingTableMeta.schema === tableSchema && existingTableMeta.tableType === tableType && existingTableMeta.columns.length > 0 && existingTableMetaAgeMs < DATA_TAB_METADATA_TTL_MS
+      ? existingTableMeta
+      : undefined;
+  const cachedTableMeta = sharedCachedTableMeta ? tableMetadataToDataTabMeta(sharedCachedTableMeta.metadata, tableSchema) : tabCachedTableMeta;
+  const cachedTableMetaAgeMs = sharedCachedTableMeta?.ageMs ?? existingTableMetaAgeMs;
+  const cachedTableMetaSource = sharedCachedTableMeta ? "shared" : tabCachedTableMeta ? "tab" : undefined;
+  queryStore.setTableMeta(
+    tabId,
+    cachedTableMeta ?? {
+      catalog: node.catalog,
+      schema: tableSchema,
+      tableName: node.label,
+      tableType,
+      columns: [],
+      primaryKeys: [],
+    },
+  );
+  queryStore.setExecutingWithId(tabId, openDataId);
+  logPhase("state-prepared", { tabId });
+
+  // Helper to check if this openData call is still active (not superseded by a newer click)
+  const isActive = () => queryStore.tabs.find((t) => t.id === tabId)?.executionId === openDataId;
+  const isCurrentDataTab = () => {
+    const current = queryStore.tabs.find((t) => t.id === tabId);
+    return current?.mode === "data" && current.connectionId === node.connectionId && current.database === node.database && current.schema === tableSchema && current.title === node.label;
+  };
+
+  try {
+    console.info("[DBX][openData:ensure-connected:start]", { traceId, elapsed: elapsed() });
+    await connectionStore.ensureConnected(node.connectionId);
+    if (!isActive()) {
+      logPhase("superseded-after-ensure-connected", { tabId });
+      return;
+    }
+    console.info("[DBX][openData:ensure-connected:done]", { traceId, elapsed: elapsed() });
+    logPhase("ensure-connected", { tabId });
+    if (!config) throw new Error("Connection config not found");
+
+    const limit = tableOpenPageLimit();
+    const refreshTableMetaInBackground = async () => {
+      const metadataStartedAt = performance.now();
+      console.info("[DBX][openData:metadata:start]", {
+        traceId,
+        database: node.database,
+        schema: querySchema,
+        table: node.label,
+        elapsed: elapsed(),
+      });
+      try {
+        const loadedMetadata = await loadTableMetadata({
+          connectionId: node.connectionId,
+          database: node.database,
+          schema: querySchema,
+          tableName: node.label,
+          tableType,
+          databaseType: metadataDatabaseType,
+          driverProfile: config.driver_profile || config.db_type,
+          catalog: node.catalog,
+          traceLogger: (event) => console.debug("[DBX][openData:metadata:trace]", { sourceTraceId: traceId, ...event }),
+        });
+        if (!isCurrentDataTab()) {
+          console.info("[DBX][openData:metadata:stale]", {
+            traceId,
+            tabId,
+            columnCount: loadedMetadata.metadata.columns.length,
+            elapsed: elapsed(),
+          });
+          return;
+        }
+        const nextTableMeta = tableMetadataToDataTabMeta(loadedMetadata.metadata, tableSchema);
+        queryStore.setTableMeta(tabId, nextTableMeta);
+        console.info("[DBX][openData:metadata:done]", {
+          traceId,
+          tabId,
+          columnCount: nextTableMeta.columns.length,
+          primaryKeyCount: nextTableMeta.primaryKeys.length,
+          cacheStatus: loadedMetadata.cacheStatus,
+          ageMs: Math.round(loadedMetadata.ageMs),
+          elapsed: elapsed(),
+          metadataMs: Math.round(performance.now() - metadataStartedAt),
+        });
+      } catch (error) {
+        console.warn("[DBX][openData:metadata:error]", { traceId, tabId, elapsed: elapsed(), error });
+      }
+    };
+    const shouldRefreshTableMeta = !cachedTableMeta;
+    if (cachedTableMeta) {
+      console.info("[DBX][openData:metadata:cache-hit]", {
+        traceId,
+        tabId,
+        columnCount: cachedTableMeta.columns.length,
+        primaryKeyCount: cachedTableMeta.primaryKeys.length,
+        source: cachedTableMetaSource,
+        ageMs: Math.round(cachedTableMetaAgeMs),
+        elapsed: elapsed(),
+      });
+    } else {
+      logPhase("metadata-deferred", { tabId });
+    }
+
+    // Check if superseded by a newer openData call
+    if (!isActive()) {
+      logPhase("superseded-before-build-sql", { tabId });
+      return;
+    }
+
+    const columns = cachedTableMeta?.columns ?? [];
+    const primaryKeys = cachedTableMeta?.primaryKeys ?? [];
+    const includeRowId = usesSyntheticRowIdKey(effectiveDbType, primaryKeys, tableType);
+    const sql = await buildTableSelectSql({
+      databaseType: effectiveDbType,
+      schema: tableSchema,
+      tableName: node.label,
+      tableType,
+      catalog: node.catalog,
+      columns: columns.map((column) => column.name),
+      primaryKeys,
+      limit,
+      includeRowId,
+    });
+    console.info("[DBX][openData:sql-built]", {
+      traceId,
+      primaryKeys,
+      includeRowId,
+      sql,
+      elapsed: elapsed(),
+    });
+    logPhase("sql-built", { tabId, columnCount: columns.length, primaryKeyCount: primaryKeys.length });
+    queryStore.updateSql(tabId, sql);
+    logPhase("sql-updated", { tabId });
+
+    console.info("[DBX][openData:execute:start]", { traceId, tabId, elapsed: elapsed() });
+    await queryStore.executeTabSql(tabId, sql, {
+      sourceTraceId: traceId,
+      skipEnsureConnected: true,
+      pagination: { limit, offset: 0 },
+    });
+    console.info("[DBX][openData:execute:done]", { traceId, tabId, elapsed: elapsed() });
+    logPhase("execute-tab-sql", { tabId });
+    if (shouldRefreshTableMeta && isCurrentDataTab()) {
+      void refreshTableMetaInBackground();
+      logPhase("metadata-started", { tabId });
+    }
+  } catch (e: any) {
+    if (!isActive()) {
+      logPhase("superseded-after-error", { tabId });
+      return;
+    }
+    console.error("[DBX][openData:error]", { traceId, elapsed: elapsed(), error: e });
+    logPhase("error", { tabId });
+    queryStore.setErrorResult(tabId, e);
+  }
+}
+
+async function newQuery() {
+  const node = props.node;
+  if (!node.connectionId) return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    connectionStore.activeConnectionId = node.connectionId;
+    if (hasTreeNodeDatabaseContext(node)) {
+      if (node.type === "table" || node.type === "view" || node.type === "materialized_view") {
+        await newSelectTemplate();
+        return;
+      }
+      queryStore.createTab(node.connectionId, node.database, undefined, "query", node.schema);
+      return;
+    }
+    const connection = connectionStore.getConfig(node.connectionId);
+    if (!connection) return;
+    const options = await getDatabaseOptions(node.connectionId);
+    queryStore.createTab(node.connectionId, resolveDefaultDatabase(connection, options), undefined, "query");
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+    if (e?.message?.includes("driver is not installed") || (e?.message?.includes("JRE") && e?.message?.includes("not installed"))) {
+      window.dispatchEvent(new Event("dbx-open-driver-store"));
+    }
+  }
+}
+
+// SQL template helpers have been extracted to @/lib/tableSqlTemplates.ts
+// ---- Template actions ----
+
+function openRedisInstanceInfo() {
+  const node = props.node;
+  if (!node.connectionId) return;
+  const config = connectionStore.getConfig(node.connectionId);
+  const dbName = config?.name || "Redis";
+  queryStore.createTab(node.connectionId, "0", `${dbName} - ${t("contextMenu.instanceInfo")}`, "redis-dashboard");
+}
+
+async function loadTemplateContext(allowView = false) {
+  const node = props.node;
+  if (!node.connectionId || !hasTreeNodeDatabaseContext(node)) return null;
+  const isTableNode = node.type === "table";
+  const isReadableObject = isTableNode || (allowView && (node.type === "view" || node.type === "materialized_view"));
+  if (!isReadableObject) return null;
+
+  await connectionStore.ensureConnected(node.connectionId);
+  connectionStore.activeConnectionId = node.connectionId;
+  const config = connectionStore.getConfig(node.connectionId);
+  const dbType = config ? effectiveDatabaseTypeForConnection(config) : undefined;
+  const tableSchema = node.schema || node.database;
+  let columns: ColumnInfo[] = [];
+  try {
+    const querySchema = connectionObjectTreeQuerySchema(config, node.database, tableSchema);
+    columns = await api.getColumns(node.connectionId, node.database, querySchema, node.label);
+  } catch (e) {
+    console.warn("[DBX][tableSqlTemplate:getColumns:error]", e);
+  }
+
+  let tableType = node.tableType;
+  if (dbType === "tdengine") {
+    try {
+      const querySchema = connectionObjectTreeQuerySchema(config, node.database, tableSchema);
+      const tables = await api.listTables(node.connectionId, node.database, querySchema, node.label, 200);
+      const matched = tables.find((table) => table.name.toLowerCase() === node.label.toLowerCase());
+      if (matched?.table_type) tableType = matched.table_type;
+    } catch (e) {
+      console.warn("[DBX][tableSqlTemplate:listTables:error]", e);
+    }
+  }
+
+  return { node, dbType, tableSchema, columns, tableType };
+}
+
+function openSqlTemplateTab(connectionId: string, database: string, schema: string | undefined, sql: string, title?: string) {
+  const tabId = queryStore.createTab(connectionId, database, title, "query", schema);
+  queryStore.updateSql(tabId, sql);
+}
+
+async function newSelectTemplate() {
+  try {
+    const context = await loadTemplateContext(true);
+    if (!context) return;
+    const sql = buildTableSelectTemplate({
+      databaseType: context.dbType,
+      schema: context.tableSchema,
+      tableName: context.node.label,
+      columns: context.columns,
+    });
+    openSqlTemplateTab(context.node.connectionId!, context.node.database!, context.node.schema, sql);
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+async function newInsertTemplate() {
+  try {
+    const context = await loadTemplateContext(false);
+    if (!context) return;
+    const sql = buildTableInsertTemplate({
+      databaseType: context.dbType,
+      schema: context.tableSchema,
+      tableName: context.node.label,
+      columns: context.columns,
+      tableType: context.tableType,
+    });
+    openSqlTemplateTab(context.node.connectionId!, context.node.database!, context.node.schema, sql);
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+async function newUpdateTemplate() {
+  try {
+    const context = await loadTemplateContext(false);
+    if (!context) return;
+    const sql = buildTableUpdateTemplate({
+      databaseType: context.dbType,
+      schema: context.tableSchema,
+      tableName: context.node.label,
+      columns: context.columns,
+    });
+    openSqlTemplateTab(context.node.connectionId!, context.node.database!, context.node.schema, sql);
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+async function newDeleteTemplate() {
+  try {
+    const context = await loadTemplateContext(false);
+    if (!context) return;
+    const sql = buildTableDeleteTemplate({
+      databaseType: context.dbType,
+      schema: context.tableSchema,
+      tableName: context.node.label,
+      columns: context.columns,
+    });
+    openSqlTemplateTab(context.node.connectionId!, context.node.database!, context.node.schema, sql);
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+async function generateDdlTemplate() {
+  const node = props.node;
+  if (!node.connectionId || !hasTreeNodeDatabaseContext(node)) return;
+  if (node.type !== "table" && node.type !== "view" && node.type !== "materialized_view") return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    connectionStore.activeConnectionId = node.connectionId;
+    const schema = node.schema || node.database;
+    let ddl: string;
+    if (node.type === "table") {
+      ddl = await api.getTableDdl(node.connectionId, node.database, schema, node.label);
+    } else if (node.type === "materialized_view") {
+      ddl = await api.getTableDdl(node.connectionId, node.database, schema, node.label, "MATERIALIZED_VIEW");
+    } else {
+      const result = await api.getObjectSource(node.connectionId, node.database, schema, node.label, "VIEW");
+      ddl = await buildViewDdl({
+        databaseType: currentDatabaseType(),
+        schema,
+        name: node.label,
+        source: result.source,
+      });
+    }
+    const formatted = await formatSqlForDisplay(ddl, sqlFormatDialectForDbType(currentDatabaseType()), settingsStore.editorSettings.sqlFormatter);
+    openSqlTemplateTab(node.connectionId, node.database, node.schema, formatted, `DDL - ${node.label}`);
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  }
+}
+
+async function setNodeAsDefaultDatabase() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  try {
+    await connectionStore.setDefaultDatabase(node.connectionId, node.database);
+  } catch (e: any) {
+    toast(t("connection.saveFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function clearNodeDefaultDatabase() {
+  const node = props.node;
+  if (!node.connectionId) return;
+  try {
+    await connectionStore.clearDefaultDatabase(node.connectionId);
+  } catch (e: any) {
+    toast(t("connection.saveFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function refresh() {
+  try {
+    await connectionStore.refreshTreeNode(props.node);
+  } catch (e: any) {
+    toast(t("connection.connectFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+    if (e?.message?.includes("driver is not installed") || (e?.message?.includes("JRE") && e?.message?.includes("not installed"))) {
+      window.dispatchEvent(new Event("dbx-open-driver-store"));
+    }
+  }
+}
+
+const showDeleteConfirm = ref(false);
+
+function connectionDeleteTargets() {
+  return selectedConnectionDeleteTargets(props.node, selectedTreeNodesInVisibleOrder());
+}
+
+function connectionDeleteMenuLabel(): string {
+  const count = connectionDeleteTargets().length;
+  return count > 1 ? t("contextMenu.deleteSelectedConnections", { count }) : t("contextMenu.deleteConnection");
+}
+
+function connectionDuplicateTargets() {
+  return selectedConnectionDuplicateTargets(props.node, selectedTreeNodesInVisibleOrder());
+}
+
+function connectionDuplicateMenuLabel(): string {
+  const count = connectionDuplicateTargets().length;
+  return count > 1 ? t("contextMenu.duplicateSelectedConnections", { count }) : t("contextMenu.duplicateConnection");
+}
+
+function connectionDeleteConfirmMessage(): string {
+  const targets = connectionDeleteTargets();
+  return targets.length > 1 ? t("contextMenu.confirmDeleteSelectedMessage", { count: targets.length }) : t("contextMenu.confirmDeleteMessage", { name: props.node.label });
+}
+
+function deleteConnection() {
+  if (!connectionDeleteTargets().length) return;
+  showDeleteConfirm.value = true;
+}
+
+async function confirmDelete() {
+  const targets = connectionDeleteTargets();
+  if (!targets.length) return;
+  const connectionIds = targets.map((target) => target.connectionId);
+  try {
+    await connectionStore.removeConnections(connectionIds);
+    for (const connectionId of connectionIds) {
+      connectionStore.disconnect(connectionId).catch((error) => {
+        console.warn("[DBX][connection:delete:disconnect-failed]", { connectionId, error });
+      });
+    }
+    toast(targets.length > 1 ? t("connection.deletedSelected", { count: targets.length }) : t("connection.deleted"), 2000);
+  } catch (e: any) {
+    toast(t("connection.saveFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function copyName() {
+  updateTreeClipboardForNodes([props.node]);
+  try {
+    await copyToClipboard(copyNameForTreeNode(props.node));
+    toast(t("connection.copied"), 2000);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function copyFinalProxyPort() {
+  const connectionId = props.node.connectionId;
+  const config = connectionId ? connectionStore.getConfig(connectionId) : undefined;
+  if (!config || !hasEnabledTransportLayers(config)) return;
+
+  try {
+    const port = await api.connectionFinalProxyPort(config);
+    await copyToClipboard(String(port));
+    toast(t("contextMenu.finalProxyPortCopied", { port }), 2000);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  }
+}
+
+async function copySelectedNames() {
+  const selectedNodes = selectedTreeNodesInVisibleOrder();
+  const nodes = selectedNodes.length > 1 && selectedNodes.some((node) => node.id === props.node.id) ? selectedNodes : [props.node];
+  const connectionTargets = selectedConnectionClipboardTargets(props.node, nodes);
+  if (connectionTargets.length > 0) {
+    const copiedCount = connectionStore.copyConnectionsToTreeClipboard(connectionTargets.map((node) => node.connectionId));
+    if (copiedCount > 0) toast(t("connection.copied"), 2000);
+    return;
+  }
+  updateTreeClipboardForNodes(nodes);
+  try {
+    await copyToClipboard(nodes.map(copyNameForTreeNode).join("\n"));
+    toast(t("connection.copied"), 2000);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function updateTreeClipboardForNodes(nodes: TreeNode[]) {
+  const tableNodes = nodes.filter((node): node is DuplicateStructureSource => node.type === "table" && !!node.connectionId && !!node.database && typeof node.label === "string");
+  if (tableNodes.length === 0) {
+    connectionStore.treeClipboard = null;
+    return;
+  }
+  connectionStore.treeClipboard = {
+    kind: "table-copy",
+    tables: tableNodes.map((node) => ({
+      connectionId: node.connectionId,
+      database: node.database,
+      schema: node.schema,
+      tableName: node.label,
+    })),
+  };
+}
+
+async function duplicateConnection() {
+  const targets = connectionDuplicateTargets();
+  if (!targets.length) return;
+  let duplicatedCount = 0;
+  for (const target of targets) {
+    const config = connectionStore.getConfig(target.connectionId);
+    if (!config) continue;
+    const newConfig = { ...config, id: uuid(), name: `${config.name} (Copy)` };
+    await connectionStore.addConnection(newConfig, connectionStore.groupIdForConnection(target.connectionId));
+    duplicatedCount += 1;
+  }
+  if (!duplicatedCount) return;
+  toast(duplicatedCount > 1 ? t("connection.duplicatedSelected", { count: duplicatedCount }) : t("connection.duplicated"), 2000);
+}
+
+// --- Table Management Operations ---
+const showDropTableConfirm = ref(false);
+const showDropTableChildObjectConfirm = ref(false);
+const showBatchDropConfirm = ref(false);
+const showBatchEmptyConfirm = ref(false);
+const showBatchTruncateConfirm = ref(false);
+const showStructurePreviewDialog = ref(false);
+const showStructureDocCopyDialog = ref(false);
+const structurePreviewSql = ref("");
+const structurePreviewTitle = ref("");
+const structurePreviewDefaultFileName = ref("structure.sql");
+const structurePreviewError = ref("");
+const structureDocCopyText = ref("");
+const structureDocCopyTitle = ref("");
+const isLoadingStructurePreview = ref(false);
+const showEmptyTableConfirm = ref(false);
+const showTruncateTableConfirm = ref(false);
+const showRenameObjectDialog = ref(false);
+const renameObjectName = ref("");
+const renameObjectError = ref("");
+const renameObjectPreviewSql = ref("");
+const dropTablePreviewSql = ref("");
+const dropTableCascade = ref(false);
+const batchDropCascade = ref(false);
+const emptyTablePreviewSql = ref("");
+const truncateTablePreviewSql = ref("");
+const truncateTableCascade = ref(false);
+const dropObjectPreviewSql = ref("");
+const dropTableChildObjectPreviewSql = ref("");
+const batchDropPreviewSql = ref("");
+const batchEmptyPreviewSql = ref("");
+const batchEmptyTargets = ref<TreeNode[]>([]);
+const batchTruncatePreviewSql = ref("");
+const batchTruncateCascade = ref(false);
+const dropDatabasePreviewSql = ref("");
+const dropSchemaPreviewSql = ref("");
+const showDuplicateDialog = ref(false);
+const duplicateTableName = ref("");
+const duplicateStructureSource = ref<DuplicateStructureSource | null>(null);
+
+// Paste table dialog state
+const showPasteDialog = ref(false);
+const pasteTableMode = ref<PasteTableMode>("structure-and-data");
+const pasteTableEntries = ref<{ sourceName: string; targetName: string; connectionId: string; database: string; schema?: string }[]>([]);
+const pasteTableDataCopySupported = computed(() => supportsWholeRowTableDataCopy(currentDatabaseType()));
+
+const ddlTarget = ref<TreeNode | null>(null);
+const showDdlDialog = ref(false);
+const ddlDialect = computed(() => {
+  if (!ddlTarget.value?.connectionId) return "mysql";
+  return codeMirrorSqlDialect(effectiveDatabaseTypeForConnection(connectionStore.getConfig(ddlTarget.value.connectionId)));
+});
+const ddlFormatDialect = computed(() => {
+  if (!ddlTarget.value?.connectionId) return "generic";
+  return sqlFormatDialectForDbType(effectiveDatabaseTypeForConnection(connectionStore.getConfig(ddlTarget.value.connectionId)));
+});
+const objectSourceTarget = ref<{ node: TreeNode; initialEditing: boolean } | null>(null);
+const showObjectSourceDialog = ref(false);
+const objectSourceType = computed(() => (objectSourceTarget.value ? objectSourceKindForTreeNode(objectSourceTarget.value.node.type) : null));
+const objectSourceDatabaseType = computed(() => {
+  const connectionId = objectSourceTarget.value?.node.connectionId;
+  return connectionId ? effectiveDatabaseTypeForConnection(connectionStore.getConfig(connectionId)) : undefined;
+});
+const objectSourceDialect = computed(() => codeMirrorSqlDialect(objectSourceDatabaseType.value));
+const objectSourceFormatDialect = computed(() => sqlFormatDialectForDbType(objectSourceDatabaseType.value));
+const showCreateDatabaseDialog = ref(false);
+const createDatabaseName = ref("");
+const createDatabaseCharset = ref("utf8mb4");
+const createDatabaseCollation = ref("utf8mb4_unicode_ci");
+const showCreateNacosNamespaceDialog = ref(false);
+const createNacosNamespaceId = ref("");
+const createNacosNamespaceName = ref("");
+const createNacosNamespaceDesc = ref("");
+const createNacosNamespaceLoading = ref(false);
+const showEditNacosNamespaceDialog = ref(false);
+const editNacosNamespaceName = ref("");
+const editNacosNamespaceDesc = ref("");
+const editNacosNamespaceLoading = ref(false);
+const fallbackCreateDatabaseCharset = fallbackCreateDatabaseCharsetMetadata();
+const createDatabaseCharsetOptions = ref<string[]>(fallbackCreateDatabaseCharset.charsets);
+const createDatabaseCollationsByCharset = ref<Record<string, string[]>>(fallbackCreateDatabaseCharset.collationsByCharset);
+const createDatabaseCharsetLoading = ref(false);
+const showDropDatabaseConfirm = ref(false);
+const dropDatabaseLoading = ref(false);
+const showDropMongoCollectionConfirm = ref(false);
+const dropMongoCollectionLoading = ref(false);
+const showDropMongoIndexConfirm = ref(false);
+const dropMongoIndexLoading = ref(false);
+const showDropAllMongoIndexesConfirm = ref(false);
+const dropAllMongoIndexesLoading = ref(false);
+const showFlushRedisDbConfirm = ref(false);
+const showCreateSchemaDialog = ref(false);
+const createSchemaName = ref("");
+const showDropSchemaConfirm = ref(false);
+const showEditDatabasePropertiesDialog = ref(false);
+const editDatabasePropertiesLoading = ref(false);
+const editDatabasePropertiesPreviewSql = ref("");
+const editDatabaseCharset = ref("utf8mb4");
+const editDatabaseCollation = ref("utf8mb4_unicode_ci");
+const editDatabaseCommentText = ref("");
+const showEditSchemaCommentDialog = ref(false);
+const schemaCommentText = ref("");
+const schemaCommentLoading = ref(false);
+
+// --- Extension Management ---
+const installExtensionDialogRef = ref<InstanceType<typeof InstallExtensionDialog> | null>(null);
+
+function openInstallExtensionDialog(_node: TreeNode) {
+  installExtensionDialogRef.value?.show();
+}
+
+// --- Procedure / Function Management ---
+const showDropObjectConfirm = ref(false);
+const showProcedureExecutionConfirm = ref(false);
+
+function dropObjectSqlOptions(): DropObjectSqlOptions | null {
+  return dropObjectSqlOptionsForNode(props.node);
+}
+
+function dropObjectSqlOptionsForNode(node: TreeNode): DropObjectSqlOptions | null {
+  if (node.type !== "view" && node.type !== "materialized_view" && node.type !== "procedure" && node.type !== "function") return null;
+  return {
+    databaseType: tableStructureDatabaseTypeForNode(node),
+    objectType: node.type === "view" ? "VIEW" : node.type === "materialized_view" ? "MATERIALIZED_VIEW" : node.type === "procedure" ? "PROCEDURE" : "FUNCTION",
+    schema: node.schema,
+    name: node.objectName || node.label,
+    signature: node.signature,
+  };
+}
+
+function tableChildDropObjectType(type: TreeNodeType): TableChildObjectType | null {
+  if (type === "column") return "COLUMN";
+  if (type === "index") return "INDEX";
+  if (type === "fkey") return "FOREIGN_KEY";
+  if (type === "trigger") return "TRIGGER";
+  return null;
+}
+
+function tableChildDropObjectName(node: TreeNode): string {
+  if (node.type === "column") return node.meta && "name" in node.meta ? node.meta.name : node.label.replace(/\s+\(.+\)$/, "");
+  if (node.type === "index") return node.meta && "name" in node.meta ? node.meta.name : node.label.replace(/\s+\(.+\)$/, "");
+  if (node.type === "fkey") return node.meta && "name" in node.meta ? node.meta.name : node.label;
+  if (node.type === "trigger") return node.meta && "name" in node.meta ? node.meta.name : node.label.replace(/\s+\(.+\)$/, "");
+  return node.label;
+}
+
+function dropTableChildObjectSqlOptions(): DropTableChildObjectSqlOptions | null {
+  return dropTableChildObjectSqlOptionsForNode(props.node);
+}
+
+function dropTableChildObjectSqlOptionsForNode(node: TreeNode): DropTableChildObjectSqlOptions | null {
+  const objectType = tableChildDropObjectType(node.type);
+  if (!objectType || !node.tableName) return null;
+  const name = tableChildDropObjectName(node).trim();
+  if (!name) return null;
+  return {
+    databaseType: databaseTypeForNode(node),
+    objectType,
+    schema: node.schema,
+    tableName: node.tableName,
+    name,
+  };
+}
+
+const canDropTableChildObject = computed(() => {
+  return canDropTableChildObjectNode(props.node);
+});
+
+function canDropTableChildObjectNode(node: TreeNode): boolean {
+  const options = dropTableChildObjectSqlOptionsForNode(node);
+  if (!options) return false;
+  const capabilities = getTableStructureCapabilities(options.databaseType);
+  if (options.objectType === "COLUMN") return capabilities.dropColumn;
+  if (options.objectType === "INDEX") return capabilities.dropIndex;
+  return true;
+}
+
+function dropObjectMenuLabel(): string {
+  if (props.node.type === "view") return t("contextMenu.dropView");
+  if (props.node.type === "materialized_view") return t("contextMenu.dropView");
+  if (props.node.type === "procedure") return t("contextMenu.dropProcedure");
+  if (props.node.type === "function") return t("contextMenu.dropFunction");
+  return t("contextMenu.dropObject");
+}
+
+function dropObjectConfirmTitle(): string {
+  if (props.node.type === "view") return t("contextMenu.confirmDropViewTitle");
+  if (props.node.type === "materialized_view") return t("contextMenu.confirmDropViewTitle");
+  if (props.node.type === "procedure") return t("contextMenu.confirmDropProcedureTitle");
+  if (props.node.type === "function") return t("contextMenu.confirmDropFunctionTitle");
+  return t("contextMenu.confirmDropObjectTitle");
+}
+
+function dropObjectConfirmMessage(): string {
+  if (props.node.type === "view") return t("contextMenu.confirmDropViewMessage", { name: props.node.label });
+  if (props.node.type === "materialized_view") return t("contextMenu.confirmDropViewMessage", { name: props.node.label });
+  if (props.node.type === "procedure") return t("contextMenu.confirmDropProcedureMessage", { name: props.node.label });
+  if (props.node.type === "function") return t("contextMenu.confirmDropFunctionMessage", { name: props.node.label });
+  return t("contextMenu.confirmDropObjectMessage", { name: props.node.label });
+}
+
+function dropTableChildObjectMenuLabel(): string {
+  if (props.node.type === "column") return t("contextMenu.dropColumn");
+  if (props.node.type === "index") return t("contextMenu.dropIndex");
+  if (props.node.type === "fkey") return t("contextMenu.dropForeignKey");
+  if (props.node.type === "trigger") return t("contextMenu.dropTrigger");
+  return t("contextMenu.dropObject");
+}
+
+function dropTableChildObjectConfirmTitle(): string {
+  if (props.node.type === "column") return t("contextMenu.confirmDropColumnTitle");
+  if (props.node.type === "index") return t("contextMenu.confirmDropIndexTitle");
+  if (props.node.type === "fkey") return t("contextMenu.confirmDropForeignKeyTitle");
+  if (props.node.type === "trigger") return t("contextMenu.confirmDropTriggerTitle");
+  return t("contextMenu.confirmDropObjectTitle");
+}
+
+function dropTableChildObjectConfirmMessage(): string {
+  return t("contextMenu.confirmDropTableChildObjectMessage", {
+    name: tableChildDropObjectName(props.node),
+    table: props.node.tableName || "",
+  });
+}
+
+async function refreshDropObjectPreviewSql() {
+  const options = dropObjectSqlOptions();
+  dropObjectPreviewSql.value = "";
+  dropObjectPreviewSql.value = options ? await buildDropObjectSql(options).catch(() => "") : "";
+}
+
+async function refreshDropTableChildObjectPreviewSql() {
+  const options = dropTableChildObjectSqlOptions();
+  dropTableChildObjectPreviewSql.value = "";
+  dropTableChildObjectPreviewSql.value = options ? await buildDropTableChildObjectSql(options).catch(() => "") : "";
+}
+
+function openObjectSourceDialog(initialEditing: boolean) {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  const objectType = objectSourceKindForTreeNode(node.type);
+  if (!objectType) return;
+  void connectionStore
+    .ensureConnected(node.connectionId)
+    .then(() => {
+      connectionStore.activeConnectionId = node.connectionId!;
+      objectSourceTarget.value = { node, initialEditing };
+      showObjectSourceDialog.value = true;
+    })
+    .catch((e: any) => {
+      toast(e?.message || String(e), 5000);
+    });
+}
+
+function openProcedureExecution() {
+  const node = props.node;
+  if (node.type !== "procedure" || !node.connectionId || !node.database) return;
+  showProcedureExecutionConfirm.value = true;
+}
+
+function openProcedureExecutionSql(sql: string) {
+  const node = props.node;
+  if (node.type !== "procedure" || !node.connectionId || !node.database || !sql) return;
+  const tabId = queryStore.createTab(node.connectionId, node.database, `Execute - ${node.label}`, "query", node.schema);
+  queryStore.updateSql(tabId, sql);
+}
+
+async function executeProcedureSql(sql: string) {
+  const node = props.node;
+  if (node.type !== "procedure" || !node.connectionId || !node.database || !sql) return;
+  const tabId = queryStore.createTab(node.connectionId, node.database, `Execute - ${node.label}`, "query", node.schema);
+  queryStore.updateSql(tabId, sql);
+  await queryStore.executeTabSql(tabId, sql);
+}
+
+function requestDropObject() {
+  void refreshDropObjectPreviewSql();
+  showDropObjectConfirm.value = true;
+}
+
+function requestDropTableChildObject() {
+  if (!canDropTableChildObject.value) return;
+  void refreshDropTableChildObjectPreviewSql();
+  showDropTableChildObjectConfirm.value = true;
+}
+
+function canDropTreeNode(node: TreeNode): boolean {
+  if (isSqlServerLinkedNode(node)) return false;
+  if (node.type === "table") return !!node.connectionId && !!node.database;
+  if (node.type === "view" || node.type === "materialized_view" || node.type === "procedure" || node.type === "function") {
+    return !!node.connectionId && !!node.database && !!dropObjectSqlOptionsForNode(node);
+  }
+  if (canDropMongoIndexNode(node)) return true;
+  return canDropTableChildObjectNode(node);
+}
+
+function droppedTableObjectTypeForNode(node: TreeNode): "TABLE" | "VIEW" | "MATERIALIZED_VIEW" | null {
+  if (node.type === "table") return "TABLE";
+  if (node.type === "view") return "VIEW";
+  if (node.type === "materialized_view") return "MATERIALIZED_VIEW";
+  return null;
+}
+
+function closeDroppedTableObjectTabsForNode(node: TreeNode) {
+  const objectType = droppedTableObjectTypeForNode(node);
+  if (!objectType || !node.connectionId || !node.database) return;
+  const config = connectionStore.getConfig(node.connectionId);
+  const dataTabSchema = connectionObjectTreeNodeSchema(config, node.database, node.schema);
+  queryStore.closeDroppedTableObjectTabs({
+    connectionId: node.connectionId,
+    database: node.database,
+    schema: dataTabSchema,
+    schemaCandidates: [node.schema, dataTabSchema],
+    name: node.label,
+    objectType,
+  });
+}
+
+function tableDataRefreshTargetForNode(node: TreeNode) {
+  if (!node.connectionId || !node.database) return null;
+  const config = connectionStore.getConfig(node.connectionId);
+  const dataTabSchema = connectionObjectTreeNodeSchema(config, node.database, node.schema);
+  return {
+    connectionId: node.connectionId,
+    database: node.database,
+    schema: dataTabSchema,
+    schemaCandidates: [node.schema, dataTabSchema],
+    catalog: node.catalog,
+    name: node.label,
+  };
+}
+
+async function refreshMutatedTableDataTabsForNode(node: TreeNode) {
+  const target = tableDataRefreshTargetForNode(node);
+  if (!target) return;
+  try {
+    await queryStore.refreshDataTabsForTable(target);
+  } catch (error) {
+    console.warn("[DBX][table-data-refresh-after-mutation:error]", { target, error });
+  }
+}
+
+async function refreshMutatedTableDataTabsForNodes(nodes: readonly TreeNode[]) {
+  for (const target of nodes) {
+    await refreshMutatedTableDataTabsForNode(target);
+  }
+}
+
+function selectedBatchDropTargets(): TreeNode[] {
+  const selected = selectedTreeNodesInVisibleOrder();
+  if (selected.length <= 1 || !selected.some((node) => node.id === props.node.id)) return [];
+  const first = selected[0];
+  if (!first?.connectionId || !first.database || !selected.every((node) => node.type === first.type)) return [];
+  if (!selected.every((node) => node.connectionId === first.connectionId && node.database === first.database && canDropTreeNode(node))) {
+    return [];
+  }
+  return selected;
+}
+
+function selectedBatchTableTargets(): TreeNode[] {
+  const targets = selectedBatchDropTargets();
+  return targets.length > 1 && targets.every((node) => node.type === "table") ? targets : [];
+}
+
+function selectedBatchTruncateTargets(): TreeNode[] {
+  const targets = selectedBatchTableTargets();
+  return targets.every((node) => supportsTableTruncate(databaseTypeForNode(node))) ? targets : [];
+}
+
+function selectedBatchEmptyTargets(): TreeNode[] {
+  return selectedBatchTableTargets();
+}
+
+function selectedBatchMongoIndexTargets(): TreeNode[] {
+  const targets = selectedBatchDropTargets();
+  return targets.length > 1 && targets.every((node) => canDropMongoIndexNode(node)) ? targets : [];
+}
+
+function selectedBatchIndexTableName(targets: TreeNode[]): string | null {
+  const first = targets[0];
+  if (!first) return null;
+  const table = first.tableName || first.label;
+  return table && targets.every((node) => (node.tableName || node.label) === table) ? table : null;
+}
+
+function batchDropMenuLabel(): string {
+  const targets = selectedBatchDropTargets();
+  if (targets.length > 1 && targets.every((node) => node.type === "index")) {
+    return t("contextMenu.batchDropIndexes", { count: targets.length });
+  }
+  return t("contextMenu.batchDrop", { count: targets.length });
+}
+
+function batchDropConfirmTitle(): string {
+  const targets = selectedBatchDropTargets();
+  if (targets.length > 1 && targets.every((node) => node.type === "index")) {
+    return t("contextMenu.confirmDropIndexTitle");
+  }
+  return t("contextMenu.confirmBatchDropTitle", { count: targets.length });
+}
+
+function batchDropConfirmMessage(): string {
+  const targets = selectedBatchDropTargets();
+  const table = selectedBatchIndexTableName(targets);
+  if (targets.length > 1 && targets.every((node) => node.type === "index") && table) {
+    return t("contextMenu.confirmDropBatchIndexesMessage", { count: targets.length, table });
+  }
+  return t("contextMenu.confirmBatchDropMessage", { count: targets.length });
+}
+
+function batchTruncateMenuLabel(): string {
+  return t("contextMenu.batchTruncate", { count: selectedBatchTruncateTargets().length });
+}
+
+function batchEmptyMenuLabel(): string {
+  return t("contextMenu.batchEmpty", { count: selectedBatchEmptyTargets().length });
+}
+
+function batchEmptyConfirmTitle(): string {
+  return t("contextMenu.confirmBatchEmptyTitle", { count: batchEmptyTargets.value.length });
+}
+
+function batchEmptyConfirmMessage(): string {
+  return t("contextMenu.confirmBatchEmptyMessage", { count: batchEmptyTargets.value.length });
+}
+
+function batchEmptyConfirmLabel(): string {
+  return t("contextMenu.batchEmpty", { count: batchEmptyTargets.value.length });
+}
+
+function batchTruncateConfirmTitle(): string {
+  return t("contextMenu.confirmBatchTruncateTitle", { count: selectedBatchTruncateTargets().length });
+}
+
+function batchTruncateConfirmMessage(): string {
+  return t("contextMenu.confirmBatchTruncateMessage", { count: selectedBatchTruncateTargets().length });
+}
+
+async function dropSqlForTreeNode(node: TreeNode, options?: { cascade?: boolean }): Promise<string | null> {
+  if (node.type === "table" && node.connectionId && node.database) {
+    return buildDropTableSql({
+      databaseType: databaseTypeForNode(node),
+      schema: node.schema,
+      tableName: node.label,
+      cascade: options?.cascade && supportsDropTableCascade(databaseTypeForNode(node)),
+    });
+  }
+  const objectOptions = dropObjectSqlOptionsForNode(node);
+  if (objectOptions) return buildDropObjectSql(objectOptions);
+  if (canDropMongoIndexNode(node)) {
+    return `db.getCollection("${(node.tableName || "").replace(/\\/g, "\\\\").replace(/"/g, '\\"')}").dropIndex(${JSON.stringify(mongoIndexNameForNode(node))})`;
+  }
+  const childOptions = dropTableChildObjectSqlOptionsForNode(node);
+  if (childOptions && canDropTableChildObjectNode(node)) return buildDropTableChildObjectSql(childOptions);
+  return null;
+}
+
+async function truncateSqlForTreeNode(node: TreeNode, options?: { cascade?: boolean }): Promise<string | null> {
+  if (node.type !== "table" || !node.connectionId || !node.database || !supportsTableTruncate(databaseTypeForNode(node))) return null;
+  return buildTruncateTableSql({
+    databaseType: databaseTypeForNode(node),
+    schema: node.schema,
+    tableName: node.label,
+    cascade: options?.cascade && supportsTruncateTableCascade(databaseTypeForNode(node)),
+  });
+}
+
+async function emptySqlForTreeNode(node: TreeNode): Promise<string | null> {
+  if (node.type !== "table" || !node.connectionId || !node.database) return null;
+  return buildEmptyTableSql({
+    databaseType: databaseTypeForNode(node),
+    schema: node.schema,
+    tableName: node.label,
+  });
+}
+
+async function refreshBatchDropPreviewSql() {
+  const targets = selectedBatchDropTargets();
+  const mongoIndexTargets = selectedBatchMongoIndexTargets();
+  if (mongoIndexTargets.length) {
+    batchDropPreviewSql.value = mongoIndexTargets.map((target) => mongoIndexDropPreview(target, mongoIndexNameForNode(target))).join("\n");
+    return;
+  }
+  const statements: string[] = [];
+  const useCascade = canBatchDropCascade.value && batchDropCascade.value;
+  for (const target of targets) {
+    const sql = await dropSqlForTreeNode(target, { cascade: useCascade });
+    if (sql) statements.push(sql);
+  }
+  batchDropPreviewSql.value = statements.join("\n");
+}
+
+async function refreshBatchTruncatePreviewSql() {
+  const targets = selectedBatchTruncateTargets();
+  const statements: string[] = [];
+  const useCascade = canBatchTruncateCascade.value && batchTruncateCascade.value;
+  for (const target of targets) {
+    const sql = await truncateSqlForTreeNode(target, { cascade: useCascade });
+    if (sql) statements.push(sql);
+  }
+  batchTruncatePreviewSql.value = statements.join("\n");
+}
+
+async function refreshBatchEmptyPreviewSql(targets: TreeNode[]) {
+  const statements: string[] = [];
+  for (const target of targets) {
+    const sql = await emptySqlForTreeNode(target);
+    if (sql) statements.push(sql);
+  }
+  batchEmptyPreviewSql.value = statements.join("\n");
+}
+
+function requestBatchDrop() {
+  if (!selectedBatchDropTargets().length) return;
+  batchDropCascade.value = false;
+  void refreshBatchDropPreviewSql();
+  showBatchDropConfirm.value = true;
+}
+
+function requestBatchTruncate() {
+  if (!selectedBatchTruncateTargets().length) return;
+  batchTruncateCascade.value = false;
+  void refreshBatchTruncatePreviewSql();
+  showBatchTruncateConfirm.value = true;
+}
+
+function requestBatchEmpty() {
+  const targets = selectedBatchEmptyTargets();
+  if (!targets.length) return;
+  batchEmptyTargets.value = targets.slice();
+  batchEmptyPreviewSql.value = "";
+  void refreshBatchEmptyPreviewSql(batchEmptyTargets.value)
+    .then(() => {
+      if (!batchEmptyPreviewSql.value.trim()) throw new Error("Empty table SQL preview is unavailable");
+      showBatchEmptyConfirm.value = true;
+    })
+    .catch((e: any) => {
+      batchEmptyTargets.value = [];
+      toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+    });
+}
+
+function requestDropSelectedNodes(): boolean {
+  const selected = selectedTreeNodesInVisibleOrder();
+  if (selected.length > 1 && selected.some((node) => node.id === props.node.id)) {
+    if (!selectedBatchDropTargets().length) return false;
+    requestBatchDrop();
+    return true;
+  }
+  return requestDropSelectedNode();
+}
+
+function requestDropSelectedNode(): boolean {
+  if (props.node.type === "table") {
+    dropTable();
+    return true;
+  }
+  if (props.node.type === "view" || props.node.type === "procedure" || props.node.type === "function") {
+    requestDropObject();
+    return true;
+  }
+  if (canDropMongoIndex.value) {
+    dropMongoIndex();
+    return true;
+  }
+  if (canDropTableChildObject.value) {
+    requestDropTableChildObject();
+    return true;
+  }
+  return false;
+}
+
+function nodeRenameObjectType(): RenameableObjectType | null {
+  if (props.node.type === "table") return "TABLE";
+  if (props.node.type === "view") return "VIEW";
+  if (props.node.type === "materialized_view") return "MATERIALIZED_VIEW";
+  if (props.node.type === "procedure") return "PROCEDURE";
+  if (props.node.type === "function") return "FUNCTION";
+  return null;
+}
+
+const canRenameObject = computed(() => {
+  const objectType = nodeRenameObjectType();
+  return !!objectType && (supportsObjectRename(currentDatabaseType(), objectType) || supportsSourceBackedRoutineRename(currentDatabaseType(), objectType as any));
+});
+
+function openRenameObjectDialog() {
+  renameObjectName.value = props.node.label;
+  renameObjectError.value = "";
+  renameObjectPreviewSql.value = "";
+  showRenameObjectDialog.value = true;
+}
+
+async function executeTreeNodeSqlWithProductionGuard(node: Pick<TreeNode, "connectionId" | "database" | "schema">, sql: string, options: { database?: string; schema?: string } = {}) {
+  if (!node.connectionId) return undefined;
+  const database = options.database ?? node.database ?? "";
+  return executeWithProductionSqlGuard({
+    connection: connectionStore.getConfig(node.connectionId),
+    database,
+    sql,
+    source: t("production.sourceSidebar"),
+    execute: () => api.executeQuery(node.connectionId!, database, sql, options.schema ?? node.schema),
+  });
+}
+
+let renameObjectPreviewRequestId = 0;
+
+async function refreshRenameObjectPreviewSql() {
+  const requestId = ++renameObjectPreviewRequestId;
+  const objectType = nodeRenameObjectType();
+  const newName = renameObjectName.value.trim();
+  if (!showRenameObjectDialog.value || !objectType || !newName || newName === props.node.label) {
+    renameObjectPreviewSql.value = "";
+    return;
+  }
+  if (supportsSourceBackedRoutineRename(currentDatabaseType(), objectType as any)) {
+    renameObjectPreviewSql.value = `-- Recreate ${objectType} from source, then drop the original object.`;
+    return;
+  }
+  try {
+    const sql = await buildRenameObjectSql({
+      databaseType: currentDatabaseType(),
+      objectType,
+      schema: props.node.schema,
+      oldName: props.node.label,
+      newName,
+    });
+    if (requestId === renameObjectPreviewRequestId) renameObjectPreviewSql.value = sql;
+  } catch {
+    if (requestId === renameObjectPreviewRequestId) renameObjectPreviewSql.value = "";
+  }
+}
+
+watch([showRenameObjectDialog, renameObjectName, () => props.node.label, () => props.node.schema, () => props.node.type, () => currentDatabaseType()], () => {
+  void refreshRenameObjectPreviewSql();
+});
+
+async function confirmRenameObject() {
+  const node = props.node;
+  const objectType = nodeRenameObjectType();
+  const newName = renameObjectName.value.trim();
+  if (!objectType || !newName || newName === node.label || !node.connectionId || !node.database) return;
+  renameObjectError.value = "";
+  try {
+    const dbType = currentDatabaseType();
+    await connectionStore.ensureConnected(node.connectionId);
+    if (supportsSourceBackedRoutineRename(dbType, objectType as any)) {
+      const schema = node.schema || node.database;
+      const source = await api.getObjectSource(node.connectionId, node.database, schema, node.objectName || node.label, objectType as any, node.signature);
+      const statements = await buildRoutineRenameObjectSourceStatements({
+        databaseType: dbType!,
+        objectType: objectType as any,
+        schema,
+        name: node.label,
+        newName,
+        source: source.source,
+      });
+      for (const sql of statements) {
+        await executeTreeNodeSqlWithProductionGuard(node, sql, { database: node.database, schema });
+      }
+    } else {
+      const sql = await buildRenameObjectSql({
+        databaseType: dbType,
+        objectType,
+        schema: node.schema,
+        oldName: node.label,
+        newName,
+      });
+      await executeTreeNodeSqlWithProductionGuard(node, sql, { database: node.database, schema: node.schema });
+    }
+    toast(t("contextMenu.renameObjectSuccess", { oldName: node.label, newName }), 3000);
+    showRenameObjectDialog.value = false;
+    await refreshTableList(node);
+  } catch (e: any) {
+    renameObjectError.value = e?.message || String(e);
+  }
+}
+
+async function confirmDropObject() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  const options = dropObjectSqlOptions();
+  if (!options) return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const sql = dropObjectPreviewSql.value || (await buildDropObjectSql(options));
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: node.database, schema: node.schema });
+    const msgKey = node.type === "view" ? "contextMenu.dropViewSuccess" : node.type === "materialized_view" ? "contextMenu.dropViewSuccess" : node.type === "procedure" ? "contextMenu.dropProcedureSuccess" : "contextMenu.dropFunctionSuccess";
+    toast(t(msgKey, { name: node.label }), 3000);
+    closeDroppedTableObjectTabsForNode(node);
+    if (node.type === "view" || node.type === "materialized_view") {
+      connectionStore.removeTreeNode(node.id);
+    } else {
+      await refreshTableList(node);
+    }
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function confirmDropTableChildObject() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  const options = dropTableChildObjectSqlOptions();
+  if (!options) return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const sql = dropTableChildObjectPreviewSql.value || (await buildDropTableChildObjectSql(options));
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: node.database, schema: node.schema });
+    toast(t("contextMenu.dropTableChildObjectSuccess", { name: options.name }), 3000);
+    connectionStore.removeTreeNode(node.id);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function confirmBatchDrop() {
+  const targets = selectedBatchDropTargets();
+  if (!targets.length) return;
+  try {
+    const mongoIndexTargets = selectedBatchMongoIndexTargets();
+    if (mongoIndexTargets.length) {
+      const grouped = new Map<string, TreeNode[]>();
+      for (const target of mongoIndexTargets) {
+        const key = `${target.connectionId}:${target.database}:${target.tableName || ""}`;
+        const list = grouped.get(key) ?? [];
+        list.push(target);
+        grouped.set(key, list);
+      }
+      let droppedCount = 0;
+      for (const groupTargets of grouped.values()) {
+        const first = groupTargets[0];
+        if (!first?.connectionId || !first.database || !first.tableName) continue;
+        await connectionStore.ensureConnected(first.connectionId);
+        const names = groupTargets.map((target) => mongoIndexNameForNode(target));
+        const result = await api.mongoDropIndexes(first.connectionId, first.database, first.tableName, JSON.stringify(names.length === 1 ? names[0] : names), false);
+        const dropped = new Set(result.dropped_names);
+        droppedCount += result.dropped_names.length;
+        for (const target of groupTargets) {
+          if (dropped.has(mongoIndexNameForNode(target))) connectionStore.removeTreeNode(target.id);
+        }
+      }
+      toast(t("contextMenu.batchDropSuccess", { count: droppedCount }), 3000);
+      showBatchDropConfirm.value = false;
+      return;
+    }
+    const useCascade = canBatchDropCascade.value && batchDropCascade.value;
+    for (const target of targets) {
+      if (!target.connectionId || !target.database) continue;
+      await connectionStore.ensureConnected(target.connectionId);
+      const sql = await dropSqlForTreeNode(target, { cascade: useCascade });
+      if (!sql) continue;
+      await executeTreeNodeSqlWithProductionGuard(target, sql, { database: target.database, schema: target.schema });
+      closeDroppedTableObjectTabsForNode(target);
+      connectionStore.removeTreeNode(target.id);
+    }
+    toast(t("contextMenu.batchDropSuccess", { count: targets.length }), 3000);
+    showBatchDropConfirm.value = false;
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function confirmBatchTruncate() {
+  const targets = selectedBatchTruncateTargets();
+  if (!targets.length) return;
+  try {
+    const useCascade = canBatchTruncateCascade.value && batchTruncateCascade.value;
+    await runBatchTableTruncate(
+      targets,
+      async (target) => {
+        if (!target.connectionId || !target.database) return false;
+        await connectionStore.ensureConnected(target.connectionId);
+        const sql = await truncateSqlForTreeNode(target, { cascade: useCascade });
+        if (!sql) return false;
+        const result = await executeTreeNodeSqlWithProductionGuard(target, sql, { database: target.database, schema: target.schema });
+        return result === undefined ? false : undefined;
+      },
+      refreshMutatedTableDataTabsForNodes,
+    );
+    toast(t("contextMenu.batchTruncateSuccess", { count: targets.length }), 3000);
+    showBatchTruncateConfirm.value = false;
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function confirmBatchEmpty() {
+  const targets = batchEmptyTargets.value.slice();
+  if (!targets.length) return;
+  const asynchronousMutation = targets.every((target) => databaseTypeForNode(target) === "clickhouse");
+  const result = await runBatchTableEmpty(targets, async (target) => {
+    if (!target.connectionId || !target.database) throw new Error("Missing table connection context");
+    await connectionStore.ensureConnected(target.connectionId);
+    const sql = await emptySqlForTreeNode(target);
+    if (!sql) throw new Error("Empty table SQL is unavailable");
+    await executeTreeNodeSqlWithProductionGuard(target, sql, { database: target.database, schema: target.schema });
+  });
+  for (const failure of result.failed) {
+    console.error(`Failed to empty table "${failure.target.label}":`, failure.error);
+  }
+  const feedback = batchTableEmptyFeedback(result, asynchronousMutation);
+  if (feedback === "success") {
+    toast(t("contextMenu.batchEmptySuccess", { count: result.succeeded.length }), 3000);
+  } else if (feedback === "submitted") {
+    toast(t("contextMenu.batchEmptySubmitted", { count: result.succeeded.length }), 3000);
+  } else if (feedback === "submitted-partial") {
+    toast(t("contextMenu.batchEmptySubmittedPartial", { success: result.succeeded.length, failed: result.failed.length }), 5000);
+  } else {
+    toast(t("contextMenu.batchEmptyPartialFail", { success: result.succeeded.length, failed: result.failed.length }), 5000);
+  }
+  await refreshMutatedTableDataTabsForNodes(result.succeeded);
+  batchEmptyTargets.value = [];
+  showBatchEmptyConfirm.value = false;
+}
+
+const isTableNotView = computed(() => props.node.type === "table" && !isSqlServerLinkedNode(props.node));
+
+const supportsTruncate = computed(() => {
+  return supportsTableTruncate(currentDatabaseType());
+});
+
+const canCreateTable = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return (props.node.type === "database" || props.node.type === "schema" || props.node.type === "group-tables") && !isSqlServerLinkedNode(props.node) && !!props.node.database && supportsTableStructureEditing(tableStructureDatabaseTypeForConnection(config));
+});
+
+const canCreateDatabase = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return props.node.type === "connection" && canCreateConnectionNamespace(config);
+});
+
+const canCreateNacosNamespace = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return props.node.type === "connection" && config?.db_type === "nacos" && !config.read_only;
+});
+
+const canEditNacosNamespace = computed(() => {
+  if (props.node.type !== "nacos-namespace" || !props.node.connectionId || !props.node.nacosNamespace) return false;
+  const config = connectionStore.getConfig(props.node.connectionId);
+  return config?.db_type === "nacos" && !config.read_only;
+});
+
+const isDuckDbConnection = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return props.node.type === "connection" && connectionNamespaceCreationTarget(config) === "attach";
+});
+
+const isConnectionSchemaCreation = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return props.node.type === "connection" && connectionNamespaceCreationTarget(config) === "schema";
+});
+
+const canSetCreateDatabaseCharset = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return connectionNamespaceCreationTarget(config) === "database" && supportsCreateDatabaseCharset(config?.db_type, config?.driver_profile);
+});
+
+const canDropDatabase = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return props.node.type === "database" && !isSqlServerLinkedNode(props.node) && supportsDatabaseCreation(config?.db_type);
+});
+
+const databasePropertyGroups = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return editableDatabasePropertyGroups(config, props.node);
+});
+
+const canEditDatabaseProperties = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return canEditDatabasePropertiesForNode(config, props.node) && !isSqlServerLinkedNode(props.node);
+});
+
+const canEditDatabaseCharsetCollation = computed(() => databasePropertyGroups.value.includes("charsetCollation"));
+const canEditDatabaseComment = computed(() => databasePropertyGroups.value.includes("databaseComment"));
+
+const canDropMongoDatabase = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return props.node.type === "mongo-db" && !!props.node.database && config?.driver_profile !== "mongodb-legacy";
+});
+
+const canDropMongoCollection = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return props.node.type === "mongo-collection" && !!props.node.database && config?.driver_profile !== "mongodb-legacy";
+});
+
+function mongoIndexNameForNode(node: TreeNode): string {
+  if (node.type !== "index") return "";
+  return node.meta && "name" in node.meta ? node.meta.name : node.label.replace(/\s+\(.+\)$/, "");
+}
+
+function canDropMongoIndexNode(node: TreeNode): boolean {
+  if (node.type !== "index" || !node.connectionId || !node.database || !node.tableName) return false;
+  const config = connectionStore.getConfig(node.connectionId);
+  return config?.db_type === "mongodb" && config.driver_profile !== "mongodb-legacy" && mongoIndexNameForNode(node) !== "_id_";
+}
+
+const canDropMongoIndex = computed(() => canDropMongoIndexNode(props.node));
+
+function mongoIndexDropPreview(node: Pick<TreeNode, "tableName">, indexName: string): string {
+  return `db.getCollection(${JSON.stringify(node.tableName || "")}).dropIndex(${JSON.stringify(indexName)})`;
+}
+
+const canDropAllMongoIndexes = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return props.node.type === "mongo-collection" && !!props.node.database && config?.db_type === "mongodb" && config.driver_profile !== "mongodb-legacy";
+});
+
+function mongoDropAllIndexesPreview(node: Pick<TreeNode, "label">): string {
+  return `db.getCollection(${JSON.stringify(node.label)}).dropIndexes()`;
+}
+
+const canCreateSchema = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return canCreateDatabaseNodeNamespace(config, props.node) && !isSqlServerLinkedNode(props.node) && !connectionUsesDatabaseObjectTreeMode(config);
+});
+
+const canDropSchema = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return props.node.type === "schema" && !isSqlServerLinkedNode(props.node) && usesTreeSchemaMode(effectiveDatabaseTypeForConnection(config)) && !connectionUsesDatabaseObjectTreeMode(config);
+});
+
+const canEditSchemaComment = computed(() => {
+  const config = props.node.connectionId ? connectionStore.getConfig(props.node.connectionId) : undefined;
+  return props.node.type === "schema" && !!props.node.database && !config?.read_only && supportsSchemaComment(effectiveDatabaseTypeForConnection(config));
+});
+
+const canDropTableCascade = computed(() => props.node.type === "table" && supportsDropTableCascade(currentDatabaseType()));
+const canTruncateTableCascade = computed(() => props.node.type === "table" && supportsTruncateTableCascade(currentDatabaseType()));
+const canBatchDropCascade = computed(() => {
+  const targets = selectedBatchTableTargets();
+  return targets.length > 1 && targets.every((node) => supportsDropTableCascade(databaseTypeForNode(node)));
+});
+const canBatchTruncateCascade = computed(() => {
+  const targets = selectedBatchTruncateTargets();
+  return targets.length > 1 && targets.every((node) => supportsTruncateTableCascade(databaseTypeForNode(node)));
+});
+
+function tableAdminSqlOptions(options?: { cascade?: boolean }): TableAdminSqlOptions {
+  const result: TableAdminSqlOptions = {
+    databaseType: currentDatabaseType(),
+    schema: props.node.schema,
+    tableName: props.node.label,
+  };
+  if (options?.cascade) result.cascade = true;
+  return result;
+}
+
+function dropTableSqlOptions(): TableAdminSqlOptions {
+  return tableAdminSqlOptions({ cascade: canDropTableCascade.value && dropTableCascade.value });
+}
+
+function truncateTableSqlOptions(): TableAdminSqlOptions {
+  return tableAdminSqlOptions({ cascade: canTruncateTableCascade.value && truncateTableCascade.value });
+}
+
+async function refreshDropTablePreviewSql() {
+  dropTablePreviewSql.value = "";
+  dropTablePreviewSql.value = await buildDropTableSql(dropTableSqlOptions()).catch(() => "");
+}
+
+async function refreshEmptyTablePreviewSql() {
+  emptyTablePreviewSql.value = "";
+  emptyTablePreviewSql.value = await buildEmptyTableSql(tableAdminSqlOptions()).catch(() => "");
+}
+
+async function refreshTruncateTablePreviewSql() {
+  truncateTablePreviewSql.value = "";
+  truncateTablePreviewSql.value = await buildTruncateTableSql(truncateTableSqlOptions()).catch(() => "");
+}
+
+function dropTable() {
+  dropTableCascade.value = false;
+  void refreshDropTablePreviewSql();
+  showDropTableConfirm.value = true;
+}
+
+async function refreshTableList(node: TreeNode) {
+  if (!node.connectionId || !node.database) return;
+  await connectionStore.refreshObjectListTreeNode(node.connectionId, node.database, node.schema);
+}
+
+async function confirmDropTable() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const sql = dropTablePreviewSql.value || (await buildDropTableSql(dropTableSqlOptions()));
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: node.database, schema: node.schema });
+    toast(t("contextMenu.dropTableSuccess", { name: node.label }), 3000);
+    closeDroppedTableObjectTabsForNode(node);
+    connectionStore.removeTreeNode(node.id);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function emptyTable() {
+  void refreshEmptyTablePreviewSql();
+  showEmptyTableConfirm.value = true;
+}
+
+async function confirmEmptyTable() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const sql = emptyTablePreviewSql.value || (await buildEmptyTableSql(tableAdminSqlOptions()));
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: node.database, schema: node.schema });
+    const messageKey = currentDatabaseType() === "clickhouse" ? "contextMenu.emptyTableSubmitted" : "contextMenu.emptyTableSuccess";
+    toast(t(messageKey, { name: node.label }), 3000);
+    await refreshMutatedTableDataTabsForNode(node);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function truncateTable() {
+  truncateTableCascade.value = false;
+  void refreshTruncateTablePreviewSql();
+  showTruncateTableConfirm.value = true;
+}
+
+async function confirmTruncateTable() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const sql = truncateTablePreviewSql.value || (await buildTruncateTableSql(truncateTableSqlOptions()));
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: node.database, schema: node.schema });
+    toast(t("contextMenu.truncateTableSuccess", { name: node.label }), 3000);
+    await refreshMutatedTableDataTabsForNode(node);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function refreshDropDatabasePreviewSql() {
+  if (props.node.type === "mongo-db") {
+    dropDatabasePreviewSql.value = `db.getSiblingDB(${JSON.stringify(props.node.label)}).dropDatabase();`;
+    return;
+  }
+  dropDatabasePreviewSql.value = "";
+  dropDatabasePreviewSql.value = await buildDropDatabaseSql({
+    databaseType: currentDatabaseType(),
+    name: props.node.label,
+  }).catch(() => "");
+}
+
+async function refreshDropSchemaPreviewSql() {
+  dropSchemaPreviewSql.value = "";
+  dropSchemaPreviewSql.value = await buildDropSchemaSql({
+    databaseType: currentDatabaseType(),
+    name: props.node.label,
+  }).catch(() => "");
+}
+
+function databasePropertyName(): string {
+  return props.node.database || props.node.label;
+}
+
+function resultColumnValue(result: { columns?: string[]; rows?: unknown[] }, names: string[]): string {
+  const firstRow = result.rows?.[0];
+  if (Array.isArray(firstRow)) {
+    const lowerNames = names.map((name) => name.toLowerCase());
+    const index = Math.max(0, result.columns?.findIndex((column) => lowerNames.includes(column.toLowerCase())) ?? 0);
+    return firstRow[index] == null ? "" : String(firstRow[index]);
+  }
+  if (firstRow && typeof firstRow === "object") {
+    const record = firstRow as Record<string, unknown>;
+    const key = Object.keys(record).find((column) => names.some((name) => name.toLowerCase() === column.toLowerCase()));
+    const value = key ? record[key] : undefined;
+    return value == null ? "" : String(value);
+  }
+  return "";
+}
+
+function databasePropertyEditOptions() {
+  if (!canEditDatabaseProperties.value) return null;
+  const base = {
+    databaseType: currentDatabaseType(),
+    driverProfile: props.node.connectionId ? connectionStore.getConfig(props.node.connectionId)?.driver_profile : undefined,
+    target: "database" as const,
+    name: databasePropertyName(),
+  };
+  if (canEditDatabaseCharsetCollation.value) {
+    return {
+      ...base,
+      charset: editDatabaseCharset.value,
+      collation: editDatabaseCollation.value,
+    };
+  }
+  if (canEditDatabaseComment.value) {
+    return {
+      ...base,
+      comment: editDatabaseCommentText.value,
+    };
+  }
+  return null;
+}
+
+async function refreshEditDatabasePropertiesPreviewSql() {
+  editDatabasePropertiesPreviewSql.value = "";
+  const options = databasePropertyEditOptions();
+  if (!options) return;
+  editDatabasePropertiesPreviewSql.value = await buildUpdateDatabasePropertiesSql(options).catch(() => "");
+}
+
+async function loadDatabaseCharsetProperties() {
+  const node = props.node;
+  if (!node.connectionId) return;
+  const sql = `SELECT DEFAULT_CHARACTER_SET_NAME AS charset, DEFAULT_COLLATION_NAME AS collation FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = '${databasePropertyName().replace(/'/g, "''")}';`;
+  const result = await api.executeQuery(node.connectionId, databasePropertyName(), sql, undefined, undefined, { maxRows: 1 });
+  const charset = resultColumnValue(result, ["charset", "DEFAULT_CHARACTER_SET_NAME"]);
+  const collation = resultColumnValue(result, ["collation", "DEFAULT_COLLATION_NAME"]);
+  if (charset) editDatabaseCharset.value = charset;
+  if (collation) editDatabaseCollation.value = collation;
+}
+
+async function loadDatabaseCommentProperty() {
+  const node = props.node;
+  if (!node.connectionId) return;
+  const sql = buildGetDatabaseCommentSql({
+    databaseType: currentDatabaseType(),
+    name: databasePropertyName(),
+  });
+  const result = await api.executeQuery(node.connectionId, databasePropertyName(), sql, undefined, undefined, { maxRows: 1 });
+  editDatabaseCommentText.value = resultColumnValue(result, ["comment"]);
+}
+
+async function openEditDatabasePropertiesDialog() {
+  const node = props.node;
+  if (!canEditDatabaseProperties.value || !node.connectionId) return;
+  editDatabasePropertiesLoading.value = true;
+  editDatabaseCharset.value = "utf8mb4";
+  editDatabaseCollation.value = "utf8mb4_unicode_ci";
+  editDatabaseCommentText.value = "";
+  editDatabasePropertiesPreviewSql.value = "";
+  createDatabaseCharsetOptions.value = fallbackCreateDatabaseCharset.charsets;
+  createDatabaseCollationsByCharset.value = fallbackCreateDatabaseCharset.collationsByCharset;
+  showEditDatabasePropertiesDialog.value = true;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    if (canEditDatabaseCharsetCollation.value) {
+      await loadCreateDatabaseCharsetMetadata("edit");
+      await loadDatabaseCharsetProperties().catch(() => undefined);
+    } else if (canEditDatabaseComment.value) {
+      await loadDatabaseCommentProperty().catch(() => undefined);
+    }
+    await refreshEditDatabasePropertiesPreviewSql();
+  } finally {
+    editDatabasePropertiesLoading.value = false;
+  }
+}
+
+async function confirmEditDatabaseProperties() {
+  const node = props.node;
+  if (!canEditDatabaseProperties.value || !node.connectionId || editDatabasePropertiesLoading.value) return;
+  editDatabasePropertiesLoading.value = true;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const options = databasePropertyEditOptions();
+    if (!options) return;
+    const sql = await buildUpdateDatabasePropertiesSql(options);
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: databasePropertyName() });
+    toast(t("contextMenu.editDatabasePropertiesSuccess", { name: node.label }), 3000);
+    showEditDatabasePropertiesDialog.value = false;
+    await connectionStore.loadDatabases(node.connectionId, { force: true });
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  } finally {
+    editDatabasePropertiesLoading.value = false;
+  }
+}
+
+watch([editDatabaseCharset, editDatabaseCollation, editDatabaseCommentText], () => {
+  if (showEditDatabasePropertiesDialog.value) void refreshEditDatabasePropertiesPreviewSql();
+});
+
+const schemaCommentPreviewSql = ref("");
+
+async function refreshSchemaCommentPreviewSql() {
+  if (!canEditSchemaComment.value) {
+    schemaCommentPreviewSql.value = "";
+    return;
+  }
+  schemaCommentPreviewSql.value = await buildUpdateDatabasePropertiesSql({
+    databaseType: currentDatabaseType(),
+    target: "schema",
+    name: props.node.schema || props.node.label,
+    comment: schemaCommentText.value,
+  }).catch(() => "");
+}
+
+watch(schemaCommentText, () => {
+  if (showEditSchemaCommentDialog.value) void refreshSchemaCommentPreviewSql();
+});
+
+function schemaCommentFromResult(result: { columns?: string[]; rows?: unknown[] }): string {
+  return resultColumnValue(result, ["comment"]);
+}
+
+async function openEditSchemaCommentDialog() {
+  const node = props.node;
+  if (!canEditSchemaComment.value || !node.connectionId || !node.database) return;
+  schemaCommentText.value = "";
+  schemaCommentLoading.value = true;
+  showEditSchemaCommentDialog.value = true;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const sql = buildGetSchemaCommentSql({
+      databaseType: currentDatabaseType(),
+      name: node.schema || node.label,
+    });
+    const result = await api.executeQuery(node.connectionId, node.database, sql, node.schema, undefined, { maxRows: 1 });
+    schemaCommentText.value = schemaCommentFromResult(result);
+    await refreshSchemaCommentPreviewSql();
+  } catch {
+    schemaCommentText.value = "";
+    await refreshSchemaCommentPreviewSql();
+  } finally {
+    schemaCommentLoading.value = false;
+  }
+}
+
+async function confirmEditSchemaComment() {
+  const node = props.node;
+  if (!canEditSchemaComment.value || !node.connectionId || !node.database || schemaCommentLoading.value) return;
+  schemaCommentLoading.value = true;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const sql = await buildUpdateDatabasePropertiesSql({
+      databaseType: currentDatabaseType(),
+      target: "schema",
+      name: node.schema || node.label,
+      comment: schemaCommentText.value,
+    });
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: node.database, schema: node.schema });
+    toast(t("contextMenu.editSchemaCommentSuccess", { name: node.label }), 3000);
+    showEditSchemaCommentDialog.value = false;
+    await connectionStore.loadSchemas(node.connectionId, node.database, { force: true });
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  } finally {
+    schemaCommentLoading.value = false;
+  }
+}
+
+async function openCreateDatabase() {
+  if (isDuckDbConnection.value) {
+    await createDuckDbAttachedDatabaseFile();
+    return;
+  }
+  openCreateDatabaseDialog();
+}
+
+function openCreateDatabaseDialog() {
+  createDatabaseName.value = "";
+  createDatabaseCharset.value = "utf8mb4";
+  createDatabaseCollation.value = "utf8mb4_unicode_ci";
+  createDatabaseCharsetOptions.value = fallbackCreateDatabaseCharset.charsets;
+  createDatabaseCollationsByCharset.value = fallbackCreateDatabaseCharset.collationsByCharset;
+  showCreateDatabaseDialog.value = true;
+  if (canSetCreateDatabaseCharset.value) {
+    void loadCreateDatabaseCharsetMetadata();
+  }
+}
+
+function openConnectionNamespaceCreation() {
+  if (isConnectionSchemaCreation.value) {
+    openCreateSchemaDialog();
+    return;
+  }
+  void openCreateDatabase();
+}
+
+function connectionNamespaceCreationLabel() {
+  if (isDuckDbConnection.value) return t("contextMenu.createDuckDbFile");
+  if (isConnectionSchemaCreation.value) return t("contextMenu.createSchema");
+  return t("contextMenu.createDatabase");
+}
+
+function updateCreateDatabaseCharset(value: string) {
+  const previousCharset = createDatabaseCharset.value;
+  createDatabaseCharset.value = value;
+  createDatabaseCollation.value = nextCreateDatabaseCollation(value, previousCharset, createDatabaseCollation.value, createDatabaseCollationsByCharset.value);
+}
+
+function updateEditDatabaseCharset(value: string) {
+  const previousCharset = editDatabaseCharset.value;
+  editDatabaseCharset.value = value;
+  editDatabaseCollation.value = nextCreateDatabaseCollation(value, previousCharset, editDatabaseCollation.value, createDatabaseCollationsByCharset.value);
+}
+
+async function loadCreateDatabaseCharsetMetadata(target: "create" | "edit" = "create") {
+  const node = props.node;
+  if (!node.connectionId || createDatabaseCharsetLoading.value) return;
+  createDatabaseCharsetLoading.value = true;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const [charsetResult, collationResult] = await Promise.all([api.executeQuery(node.connectionId, "", "SHOW CHARACTER SET", undefined, undefined, { maxRows: 1000 }), api.executeQuery(node.connectionId, "", "SHOW COLLATION", undefined, undefined, { maxRows: 10000 })]);
+    if (target === "create" && !showCreateDatabaseDialog.value) return;
+    if (target === "edit" && !showEditDatabasePropertiesDialog.value) return;
+    const metadata = parseCreateDatabaseCharsetMetadata(charsetResult, collationResult);
+    createDatabaseCharsetOptions.value = metadata.charsets;
+    createDatabaseCollationsByCharset.value = metadata.collationsByCharset;
+    const selectedCharset = target === "create" ? createDatabaseCharset.value : editDatabaseCharset.value;
+    if (!createDatabaseCharsetOptions.value.includes(selectedCharset) && createDatabaseCharsetOptions.value.length) {
+      if (target === "create") {
+        updateCreateDatabaseCharset(createDatabaseCharsetOptions.value[0]);
+      } else {
+        updateEditDatabaseCharset(createDatabaseCharsetOptions.value[0]);
+      }
+    } else {
+      if (target === "create") {
+        createDatabaseCollation.value = nextCreateDatabaseCollation(createDatabaseCharset.value, createDatabaseCharset.value, createDatabaseCollation.value, createDatabaseCollationsByCharset.value);
+      } else {
+        editDatabaseCollation.value = nextCreateDatabaseCollation(editDatabaseCharset.value, editDatabaseCharset.value, editDatabaseCollation.value, createDatabaseCollationsByCharset.value);
+      }
+    }
+  } catch {
+    createDatabaseCharsetOptions.value = fallbackCreateDatabaseCharset.charsets;
+    createDatabaseCollationsByCharset.value = fallbackCreateDatabaseCharset.collationsByCharset;
+  } finally {
+    createDatabaseCharsetLoading.value = false;
+  }
+}
+
+function openCreateNacosNamespaceDialog() {
+  createNacosNamespaceId.value = "";
+  createNacosNamespaceName.value = "";
+  createNacosNamespaceDesc.value = "";
+  showCreateNacosNamespaceDialog.value = true;
+}
+
+async function confirmCreateNacosNamespace() {
+  const node = props.node;
+  const namespaceName = createNacosNamespaceName.value.trim();
+  if (!node.connectionId || !namespaceName || createNacosNamespaceLoading.value) return;
+  createNacosNamespaceLoading.value = true;
+  try {
+    await api.nacosCreateNamespace(node.connectionId, {
+      namespaceId: createNacosNamespaceId.value.trim() || undefined,
+      namespaceName,
+      namespaceDesc: createNacosNamespaceDesc.value.trim() || namespaceName,
+    });
+    showCreateNacosNamespaceDialog.value = false;
+    await connectionStore.loadNacosNamespaces(node.connectionId, { force: true });
+    node.isExpanded = true;
+    toast(t("nacos.namespaceCreated", { name: namespaceName }), 3000);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  } finally {
+    createNacosNamespaceLoading.value = false;
+  }
+}
+
+function openEditNacosNamespaceDialog() {
+  editNacosNamespaceName.value = props.node.nacosNamespaceName || props.node.label;
+  editNacosNamespaceDesc.value = props.node.comment || "";
+  showEditNacosNamespaceDialog.value = true;
+}
+
+async function confirmEditNacosNamespace() {
+  const node = props.node;
+  const namespaceId = node.nacosNamespace?.trim() || "";
+  const namespaceName = editNacosNamespaceName.value.trim();
+  if (!node.connectionId || !namespaceId || !namespaceName || editNacosNamespaceLoading.value) return;
+  editNacosNamespaceLoading.value = true;
+  try {
+    await api.nacosUpdateNamespace(node.connectionId, {
+      namespaceId,
+      namespaceName,
+      namespaceDesc: editNacosNamespaceDesc.value.trim() || namespaceName,
+    });
+    showEditNacosNamespaceDialog.value = false;
+    await connectionStore.loadNacosNamespaces(node.connectionId, { force: true });
+    toast(t("nacos.namespaceUpdated", { name: namespaceName }), 3000);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: translateBackendError(t, e?.message || String(e)) }), 5000);
+  } finally {
+    editNacosNamespaceLoading.value = false;
+  }
+}
+
+function ensureDuckDbFileExtension(path: string): string {
+  return /\.(duckdb|db)$/i.test(path) ? path : `${path}.duckdb`;
+}
+
+async function createDuckDbAttachedDatabaseFile() {
+  const node = props.node;
+  if (!node.connectionId) return;
+  if (!isTauriRuntime()) {
+    toast(t("contextMenu.createDuckDbFileDesktopOnly"), 4000);
+    return;
+  }
+
+  try {
+    const { save } = await import("@tauri-apps/plugin-dialog");
+    const selectedPath = await save({
+      defaultPath: "database.duckdb",
+      filters: [{ name: "DuckDB", extensions: ["duckdb", "db"] }],
+    });
+    if (!selectedPath) return;
+
+    const path = ensureDuckDbFileExtension(selectedPath);
+    await connectionStore.ensureConnected(node.connectionId);
+    const existingDatabases = await api.listDatabases(node.connectionId);
+    const name = uniqueDuckDbAttachedDatabaseName(
+      duckDbAttachedDatabaseNameFromPath(path),
+      existingDatabases.map((database) => database.name),
+    );
+    const sql = await buildDuckDbAttachDatabaseSql(path, name);
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: "" });
+
+    const config = connectionStore.getConfig(node.connectionId);
+    if (config) {
+      await connectionStore.updateConnection({
+        ...config,
+        attached_databases: [...(config.attached_databases ?? []), { name, path }],
+      });
+    }
+    await connectionStore.ensureVisibleDatabase(node.connectionId, name);
+    await connectionStore.loadDatabases(node.connectionId, { force: true });
+    connectionStore.selectedTreeNodeId = `${node.connectionId}:${name}`;
+    toast(t("contextMenu.createDuckDbFileSuccess", { name }), 3000);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function confirmCreateDatabase() {
+  const node = props.node;
+  const name = createDatabaseName.value.trim();
+  if (!name || !node.connectionId) return;
+  showCreateDatabaseDialog.value = false;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const config = connectionStore.getConfig(node.connectionId);
+    if (config?.db_type === "mongodb") {
+      await api.mongoCreateDatabase(node.connectionId, name);
+      toast(t("contextMenu.createDatabaseSuccess", { name }), 3000);
+      await connectionStore.ensureVisibleDatabase(node.connectionId, name);
+      await connectionStore.loadMongoDatabases(node.connectionId);
+      return;
+    }
+    const sql = await buildCreateDatabaseSql({
+      databaseType: config?.db_type,
+      driverProfile: config?.driver_profile,
+      target: "database",
+      name,
+      charset: createDatabaseCharset.value,
+      collation: createDatabaseCollation.value,
+    });
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: "" });
+    toast(t("contextMenu.createDatabaseSuccess", { name }), 3000);
+    await connectionStore.ensureVisibleDatabase(node.connectionId, name);
+    await connectionStore.loadDatabases(node.connectionId, { force: true });
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function dropDatabase() {
+  void refreshDropDatabasePreviewSql();
+  dropDatabaseLoading.value = false;
+  showDropDatabaseConfirm.value = true;
+}
+
+function dropMongoCollection() {
+  dropMongoCollectionLoading.value = false;
+  showDropMongoCollectionConfirm.value = true;
+}
+
+function dropMongoIndex() {
+  dropMongoIndexLoading.value = false;
+  showDropMongoIndexConfirm.value = true;
+}
+
+function dropAllMongoIndexes() {
+  dropAllMongoIndexesLoading.value = false;
+  showDropAllMongoIndexesConfirm.value = true;
+}
+
+function flushRedisDb() {
+  showFlushRedisDbConfirm.value = true;
+}
+
+async function confirmFlushRedisDb() {
+  const node = props.node;
+  if (node.type !== "redis-db" || !node.connectionId || !node.database) return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    await api.redisFlushDb(node.connectionId, Number(node.database));
+    connectionStore.updateRedisDbKeyStats(node.connectionId, Number(node.database), { loaded: 0, total: 0 });
+    window.dispatchEvent(
+      new CustomEvent("dbx-redis-db-flushed", {
+        detail: { connectionId: node.connectionId, db: Number(node.database) },
+      }),
+    );
+    toast(t("redis.flushDbSuccess", { db: node.database }), 3000);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function confirmDropDatabase() {
+  const node = props.node;
+  if (!node.connectionId || dropDatabaseLoading.value) return;
+  dropDatabaseLoading.value = true;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    if (node.type === "mongo-db" && node.database) {
+      await api.mongoDropDatabase(node.connectionId, node.database);
+      toast(t("contextMenu.dropDatabaseSuccess", { name: node.label }), 3000);
+      await connectionStore.loadMongoDatabases(node.connectionId);
+      showDropDatabaseConfirm.value = false;
+      return;
+    }
+    const sql =
+      dropDatabasePreviewSql.value ||
+      (await buildDropDatabaseSql({
+        databaseType: currentDatabaseType(),
+        name: node.label,
+      }));
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: "" });
+    toast(t("contextMenu.dropDatabaseSuccess", { name: node.label }), 3000);
+    await connectionStore.loadDatabases(node.connectionId, { force: true });
+    showDropDatabaseConfirm.value = false;
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  } finally {
+    dropDatabaseLoading.value = false;
+  }
+}
+
+async function confirmDropMongoCollection() {
+  const node = props.node;
+  if (node.type !== "mongo-collection" || !node.connectionId || !node.database || dropMongoCollectionLoading.value) return;
+  dropMongoCollectionLoading.value = true;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    await api.mongoDropCollection(node.connectionId, node.database, node.label);
+    toast(t("contextMenu.dropCollectionSuccess", { name: node.label }), 3000);
+    await connectionStore.loadMongoCollections(node.connectionId, node.database);
+    showDropMongoCollectionConfirm.value = false;
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  } finally {
+    dropMongoCollectionLoading.value = false;
+  }
+}
+
+function mongoIndexesGroupNodeId(node: Pick<TreeNode, "connectionId" | "database" | "schema" | "tableName" | "label">): string | null {
+  if (!node.connectionId || !node.database) return null;
+  const tableName = node.tableName || node.label;
+  return node.schema ? `${node.connectionId}:${node.database}:${node.schema}:${tableName}:__indexes` : `${node.connectionId}:${node.database}:${tableName}:__indexes`;
+}
+
+async function refreshMongoIndexTree(node: Pick<TreeNode, "connectionId" | "database" | "schema" | "tableName" | "label">) {
+  const nodeId = mongoIndexesGroupNodeId(node);
+  if (!node.connectionId || !node.database || !nodeId) return;
+  await connectionStore.loadIndexes(node.connectionId, node.database, node.tableName || node.label, node.schema, nodeId);
+}
+
+async function confirmDropMongoIndex() {
+  const node = props.node;
+  if (!canDropMongoIndexNode(node) || !node.connectionId || !node.database || !node.tableName || dropMongoIndexLoading.value) return;
+  dropMongoIndexLoading.value = true;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const indexName = mongoIndexNameForNode(node);
+    await api.mongoDropIndexes(node.connectionId, node.database, node.tableName, JSON.stringify(indexName), true);
+    toast(t("contextMenu.dropTableChildObjectSuccess", { name: indexName }), 3000);
+    showDropMongoIndexConfirm.value = false;
+    await refreshMongoIndexTree(node);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  } finally {
+    dropMongoIndexLoading.value = false;
+  }
+}
+
+async function confirmDropAllMongoIndexes() {
+  const node = props.node;
+  if (node.type !== "mongo-collection" || !node.connectionId || !node.database || dropAllMongoIndexesLoading.value) return;
+  dropAllMongoIndexesLoading.value = true;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const result = await api.mongoDropIndexes(node.connectionId, node.database, node.label, undefined, false);
+    toast(t("contextMenu.dropAllIndexesSuccess", { count: result.dropped_names.length, name: node.label }), 3000);
+    showDropAllMongoIndexesConfirm.value = false;
+    await refreshMongoIndexTree(node);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  } finally {
+    dropAllMongoIndexesLoading.value = false;
+  }
+}
+
+function openCreateSchemaDialog() {
+  createSchemaName.value = "";
+  showCreateSchemaDialog.value = true;
+}
+
+async function confirmCreateSchema() {
+  const node = props.node;
+  const name = createSchemaName.value.trim();
+  const config = node.connectionId ? connectionStore.getConfig(node.connectionId) : undefined;
+  const isConnectionLevelSchemaCreation = node.type === "connection" && connectionNamespaceCreationTarget(config) === "schema";
+  const targetDatabase = isConnectionLevelSchemaCreation ? "" : node.database;
+  if (!name || !node.connectionId || (!targetDatabase && !isConnectionLevelSchemaCreation)) return;
+  showCreateSchemaDialog.value = false;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const sql = await buildCreateSchemaSql({
+      databaseType: effectiveDatabaseTypeForConnection(config),
+      name,
+    });
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: targetDatabase || "" });
+    toast(t("contextMenu.createSchemaSuccess", { name }), 3000);
+    if (isConnectionLevelSchemaCreation) {
+      await connectionStore.loadDatabases(node.connectionId, { force: true });
+    } else if (config?.db_type === "sqlserver") {
+      await connectionStore.loadSqlServerDatabaseObjects(node.connectionId, targetDatabase || "", { force: true });
+    } else {
+      await connectionStore.loadSchemas(node.connectionId, targetDatabase || "", { force: true });
+    }
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function dropSchema() {
+  void refreshDropSchemaPreviewSql();
+  showDropSchemaConfirm.value = true;
+}
+
+async function confirmDropSchema() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const sql =
+      dropSchemaPreviewSql.value ||
+      (await buildDropSchemaSql({
+        databaseType: currentDatabaseType(),
+        name: node.label,
+      }));
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: node.database });
+    toast(t("contextMenu.dropSchemaSuccess", { name: node.label }), 3000);
+    const config = connectionStore.getConfig(node.connectionId);
+    if (config?.db_type === "sqlserver") {
+      await connectionStore.loadSqlServerDatabaseObjects(node.connectionId, node.database, { force: true });
+    } else {
+      await connectionStore.loadSchemas(node.connectionId, node.database, { force: true });
+    }
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function duplicateStructure(source: TreeNode = props.node) {
+  if (!isDuplicateStructureSource(source)) return;
+  duplicateStructureSource.value = source;
+  duplicateTableName.value = `${source.label}_copy`;
+  showDuplicateDialog.value = true;
+}
+
+function isDuplicateStructureSource(node: TreeNode): node is DuplicateStructureSource {
+  return node.type === "table" && !!node.connectionId && !!node.database;
+}
+
+async function confirmDuplicateStructure() {
+  const node = duplicateStructureSource.value || (isDuplicateStructureSource(props.node) ? props.node : null);
+  const newName = duplicateTableName.value.trim();
+  if (!newName || !node) return;
+  showDuplicateDialog.value = false;
+  try {
+    await connectionStore.ensureConnected(node.connectionId);
+    const databaseType = databaseTypeForNode(node);
+    const sql = await buildDuplicateTableStructureSql({
+      databaseType,
+      schema: node.schema,
+      sourceName: node.label,
+      targetName: newName,
+    });
+    await executeTreeNodeSqlWithProductionGuard(node, sql, { database: node.database, schema: node.schema });
+    toast(t("contextMenu.duplicateStructureSuccess", { name: newName }), 3000);
+    await refreshTableList(node);
+  } catch (e: any) {
+    toast(t("contextMenu.tableOperationFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function confirmPasteTable() {
+  const entries = pasteTableEntries.value.filter((entry) => entry.targetName.trim());
+  if (entries.length === 0) return;
+  const mode = pasteTableMode.value;
+  const copyData = pasteTableModeCopiesData(mode) && pasteTableDataCopySupported.value;
+  showPasteDialog.value = false;
+  let successCount = 0;
+  let failCount = 0;
+  const refreshedConnections = new Set<string>();
+  for (const entry of entries) {
+    const targetName = entry.targetName.trim();
+    try {
+      await connectionStore.ensureConnected(entry.connectionId);
+      const databaseType = entry.connectionId ? effectiveDatabaseTypeForConnection(connectionStore.getConfig(entry.connectionId)) : undefined;
+      if (mode === "structure-and-data" || mode === "structure-only") {
+        const structureSql = await buildDuplicateTableStructureSql({
+          databaseType,
+          schema: entry.schema,
+          sourceName: entry.sourceName,
+          targetName,
+        });
+        await executeTreeNodeSqlWithProductionGuard(entry, structureSql, { database: entry.database, schema: entry.schema });
+      }
+      if (copyData) {
+        const sourceColumns = await api.getColumns(entry.connectionId, entry.database, entry.schema || "", entry.sourceName);
+        const dataCopyColumnOptions = tableDataCopyColumnOptions(databaseType, sourceColumns);
+        if (dataCopyColumnOptions.columns.length === 0) {
+          throw new Error("No writable columns available for table data copy.");
+        }
+        const dataSql = await buildCopyTableDataSql({
+          databaseType,
+          schema: entry.schema,
+          sourceName: entry.sourceName,
+          targetName,
+          ...dataCopyColumnOptions,
+        });
+        await executeTreeNodeSqlWithProductionGuard(entry, dataSql, { database: entry.database, schema: entry.schema });
+      }
+      successCount++;
+      const refreshKey = `${entry.connectionId}:${entry.database}:${entry.schema || ""}`;
+      if (!refreshedConnections.has(refreshKey)) {
+        refreshedConnections.add(refreshKey);
+        await connectionStore.refreshObjectListTreeNode(entry.connectionId, entry.database, entry.schema);
+      }
+    } catch (e: any) {
+      failCount++;
+      console.error(`Failed to paste table "${entry.sourceName}" -> "${targetName}":`, e);
+    }
+  }
+  if (failCount === 0) {
+    toast(t("contextMenu.batchPasteSuccess", { count: successCount }), 3000);
+  } else {
+    toast(t("contextMenu.batchPastePartialFail", { success: successCount, failed: failCount }), 5000);
+  }
+}
+
+function copyTableToClipboard() {
+  const node = props.node;
+  if (node.type !== "table" || !node.connectionId || !node.database) return;
+  connectionStore.treeClipboard = {
+    kind: "table-copy",
+    tables: [
+      {
+        connectionId: node.connectionId,
+        database: node.database,
+        schema: node.schema,
+        tableName: node.label,
+      },
+    ],
+  };
+  toast(t("contextMenu.pasteTableClipboardUpdated"), 2000);
+}
+
+function openPasteTableDialog() {
+  const clipboard = connectionStore.treeClipboard;
+  if (clipboard?.kind !== "table-copy" || !canPasteTreeClipboardToCurrentNode()) {
+    toast(t("contextMenu.noTableToPaste"), 2000);
+    return;
+  }
+  pasteTableMode.value = defaultPasteTableMode(currentDatabaseType());
+  pasteTableEntries.value = clipboard.tables.map((entry) => ({
+    sourceName: entry.tableName,
+    targetName: `${entry.tableName}_copy`,
+    connectionId: entry.connectionId,
+    database: entry.database,
+    schema: entry.schema,
+  }));
+  showPasteDialog.value = true;
+}
+
+function createTable() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  queryStore.openTableStructure(node.connectionId, node.database, node.schema, "");
+}
+
+function createView() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  connectionStore.activeConnectionId = node.connectionId;
+  const viewName = "new_view";
+  const effectiveDbType = effectiveDatabaseTypeForConnection(connectionStore.getConfig(node.connectionId));
+  const viewSqlName = effectiveDbType === "informix" || !node.schema ? viewName : `${node.schema}.${viewName}`;
+  const tabId = queryStore.createTab(node.connectionId, node.database, t("contextMenu.createView"), "query", node.schema);
+  queryStore.updateSql(tabId, `CREATE VIEW ${viewSqlName} AS\nSELECT\n  *\nFROM table_name;\n`);
+  queryStore.setObjectSource(tabId, {
+    schema: node.schema,
+    name: viewName,
+    objectType: "VIEW",
+  });
+}
+
+async function saveFileContent(content: string, defaultFileName: string, filterName: string, filterExt: string) {
+  if (isTauriRuntime()) {
+    const { save } = await import("@tauri-apps/plugin-dialog");
+    const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+    const path = await save({
+      defaultPath: defaultFileName,
+      filters: [{ name: filterName, extensions: [filterExt] }],
+    });
+    if (path) await writeTextFile(path, content);
+  } else {
+    const blob = new Blob([content], { type: "text/plain" });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = defaultFileName;
+    a.click();
+    URL.revokeObjectURL(url);
+  }
+}
+
+async function exportStructure() {
+  const targets = structureExportTargets();
+  if (!targets.length) return;
+  isLoadingStructurePreview.value = true;
+  structurePreviewError.value = "";
+  structurePreviewSql.value = "";
+  structurePreviewTitle.value = targets.length === 1 ? t("contextMenu.exportStructurePreviewTitle", { name: targets[0]!.label }) : t("contextMenu.exportStructurePreviewTitleMultiple", { count: targets.length });
+  structurePreviewDefaultFileName.value = targets.length === 1 ? `${targets[0]!.label}.sql` : "structures.sql";
+  showStructurePreviewDialog.value = true;
+  try {
+    const parts: string[] = [];
+    for (const target of targets) {
+      await connectionStore.ensureConnected(target.connectionId);
+      const ddl = await api.getTableDdl(target.connectionId, target.database, target.schema || target.database, target.label, tableDdlObjectTypeForNode(target.type));
+      parts.push(ddl.trim());
+    }
+    structurePreviewSql.value = joinExportedDdls(parts);
+  } catch (e: any) {
+    structurePreviewError.value = e?.message || String(e);
+    console.error("Export structure failed:", e);
+  } finally {
+    isLoadingStructurePreview.value = false;
+  }
+}
+
+function canExportStructureNode(node: TreeNode): node is TreeNode & { connectionId: string; database: string } {
+  return (node.type === "table" || node.type === "view" || node.type === "materialized_view") && !!node.connectionId && !!node.database;
+}
+
+function tableDdlObjectTypeForNode(type: TreeNodeType): ObjectSourceKind | undefined {
+  if (type === "view") return "VIEW";
+  if (type === "materialized_view") return "MATERIALIZED_VIEW";
+  return undefined;
+}
+
+function selectedStructureNodes(): TreeNode[] {
+  const selectedIds = new Set(connectionStore.selectedTreeNodeIds);
+  if (!selectedIds.size) return [];
+  const nodes: TreeNode[] = [];
+  const visit = (items: TreeNode[]) => {
+    for (const item of items) {
+      if (selectedIds.has(item.id) && canExportStructureNode(item)) nodes.push(item);
+      if (item.children) visit(item.children);
+    }
+  };
+  visit(connectionStore.treeNodes);
+  return nodes;
+}
+
+function structureExportTargets(): Array<TreeNode & { connectionId: string; database: string }> {
+  if (!canExportStructureNode(props.node)) return [];
+  const selected = selectedStructureNodes().filter((node): node is TreeNode & { connectionId: string; database: string } => canExportStructureNode(node) && node.connectionId === props.node.connectionId && node.database === props.node.database);
+  return selected.some((node) => node.id === props.node.id) ? selected : [props.node];
+}
+
+function structureTargetName(target: TreeNode): string {
+  return target.schema ? `${target.schema}.${target.label}` : target.label;
+}
+
+function columnDocValue(value: unknown): string {
+  return value === null || value === undefined ? "" : String(value);
+}
+
+function tsvCell(value: unknown): string {
+  return columnDocValue(value).replace(/\t/g, " ").replace(/\r?\n/g, " ").trim();
+}
+
+function markdownCell(value: unknown): string {
+  return columnDocValue(value).replace(/\|/g, "\\|").replace(/\r?\n/g, "<br>").trim();
+}
+
+function columnDocHeaders(includeTable: boolean): string[] {
+  const headers = [t("contextMenu.structureDocColumn"), t("contextMenu.structureDocType"), t("contextMenu.structureDocPrimaryKey"), t("contextMenu.structureDocNullable"), t("contextMenu.structureDocDefault"), t("contextMenu.structureDocComment")];
+  return includeTable ? [t("contextMenu.structureDocTable"), ...headers] : headers;
+}
+
+function columnDocCells(target: TreeNode, column: ColumnInfo, includeTable: boolean): unknown[] {
+  const cells = [column.name, column.data_type, column.is_primary_key ? t("contextMenu.structureDocYes") : t("contextMenu.structureDocNo"), column.is_nullable ? t("contextMenu.structureDocYes") : t("contextMenu.structureDocNo"), column.column_default, column.comment];
+  return includeTable ? [structureTargetName(target), ...cells] : cells;
+}
+
+async function tableColumnsForStructureCopy(target: TreeNode & { connectionId: string; database: string }): Promise<ColumnInfo[]> {
+  await connectionStore.ensureConnected(target.connectionId);
+  return (await api.getColumns(target.connectionId, target.database, target.schema || target.database, target.label)) as ColumnInfo[];
+}
+
+async function buildStructureCopyText(format: StructureCopyFormat): Promise<string> {
+  const targets = structureExportTargets();
+  if (!targets.length) return "";
+  const includeTable = targets.length > 1;
+  const headers = columnDocHeaders(includeTable);
+
+  if (format === "tsv") {
+    const lines = [headers.map(tsvCell).join("\t")];
+    for (const target of targets) {
+      const columns = await tableColumnsForStructureCopy(target);
+      for (const column of columns) {
+        lines.push(columnDocCells(target, column, includeTable).map(tsvCell).join("\t"));
+      }
+    }
+    return `${lines.join("\n")}\n`;
+  }
+
+  const tables: string[] = [];
+  const markdownHeaders = columnDocHeaders(false);
+  for (const target of targets) {
+    const columns = await tableColumnsForStructureCopy(target);
+    const tableLines = [`### ${markdownCell(structureTargetName(target))}`, "", `| ${markdownHeaders.map(markdownCell).join(" | ")} |`, `| ${markdownHeaders.map(() => "---").join(" | ")} |`, ...columns.map((column) => `| ${columnDocCells(target, column, false).map(markdownCell).join(" | ")} |`)];
+    tables.push(tableLines.join("\n"));
+  }
+  return `${tables.join("\n\n")}\n`;
+}
+
+async function copyStructureAs(format: StructureCopyFormat) {
+  let text = "";
+  try {
+    text = await buildStructureCopyText(format);
+    if (!text) return;
+    await copyToClipboard(text);
+    toast(t("contextMenu.structureDocCopied"), 2000);
+  } catch (e: any) {
+    if (text) {
+      structureDocCopyText.value = text;
+      structureDocCopyTitle.value = format === "tsv" ? t("contextMenu.copyStructureAsTsv") : t("contextMenu.copyStructureAsMarkdown");
+      showStructureDocCopyDialog.value = true;
+      return;
+    }
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function copyStructureDocText() {
+  if (!structureDocCopyText.value) return;
+  try {
+    await copyToClipboard(structureDocCopyText.value);
+    toast(t("contextMenu.structureDocCopied"), 2000);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function selectTextareaContent(event: FocusEvent) {
+  if (event.target instanceof HTMLTextAreaElement) event.target.select();
+}
+
+async function copyStructurePreview() {
+  if (!structurePreviewSql.value) return;
+  try {
+    await copyToClipboard(structurePreviewSql.value);
+    toast(t("contextMenu.exportStructureCopied"), 2000);
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function saveStructurePreview() {
+  if (!structurePreviewSql.value) return;
+  try {
+    await saveFileContent(structurePreviewSql.value, structurePreviewDefaultFileName.value, "SQL", "sql");
+    toast(t("grid.exported"));
+  } catch (e: any) {
+    toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function exportDataLegacy(format: "csv" | "json" | "sql") {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  const connectionId = node.connectionId;
+  const database = node.database;
+  const config = connectionStore.getConfig(node.connectionId);
+  if (!config) return;
+
+  try {
+    await connectionStore.ensureConnected(connectionId);
+    const tableColumns = format === "sql" ? await api.getColumns(connectionId, database, node.schema || database, node.label) : undefined;
+    const queryColumns = config.db_type === "neo4j" ? (tableColumns ?? (await api.getColumns(connectionId, database, node.schema || database, node.label))).map((column) => column.name) : undefined;
+    const effectiveDbType = effectiveDatabaseTypeForConnection(config);
+    const result = await fetchTableDataForExport({
+      databaseType: effectiveDbType,
+      schema: node.schema,
+      tableName: node.label,
+      tableType: node.tableType,
+      columns: queryColumns,
+      executePage: (sql) => api.executeQuery(connectionId, database, sql),
+    });
+
+    if (format === "csv") {
+      let outputPath = `${node.label}.csv`;
+      if (isTauriRuntime()) {
+        const { save } = await import("@tauri-apps/plugin-dialog");
+        const path = await save({
+          defaultPath: outputPath,
+          filters: [{ name: "CSV", extensions: ["csv"] }],
+        });
+        if (!path) return;
+        outputPath = path as string;
+      }
+      await api.exportQueryResultCsv(outputPath, result.columns, result.rows);
+      toast(t("grid.exported"));
+      return;
+    }
+
+    if (format === "json") {
+      let outputPath = `${node.label}.json`;
+      if (isTauriRuntime()) {
+        const { save } = await import("@tauri-apps/plugin-dialog");
+        const path = await save({
+          defaultPath: outputPath,
+          filters: [{ name: "JSON", extensions: ["json"] }],
+        });
+        if (!path) return;
+        outputPath = path as string;
+      }
+      await api.exportQueryResultJson(outputPath, result.columns, result.rows);
+      toast(t("grid.exported"));
+      return;
+    }
+
+    const content = await formatSqlInsert({
+      databaseType: effectiveDbType,
+      schema: node.schema,
+      tableName: node.label,
+      columns: result.columns,
+      columnTypes: tableColumns ? columnTypesForResultColumns(result.columns, tableColumns) : undefined,
+      rows: result.rows,
+    });
+    await saveFileContent(content, `${node.label}.sql`, "SQL", "sql");
+    toast(t("grid.exported"));
+  } catch (e: any) {
+    toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function columnTypesForResultColumns(columns: string[], tableColumns: ColumnInfo[]): Array<string | undefined> {
+  const typesByName = new Map(tableColumns.map((column) => [column.name.toLocaleLowerCase(), column.data_type]));
+  return columns.map((column) => typesByName.get(column.toLocaleLowerCase()));
+}
+
+async function exportData(format: "csv" | "json" | "sql") {
+  if (format !== "csv") {
+    await exportDataLegacy(format);
+    return;
+  }
+  await exportTableData("csv");
+}
+
+async function exportTableData(format: "csv" | "xlsx") {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  const connectionId = node.connectionId;
+  const database = node.database;
+  const config = connectionStore.getConfig(node.connectionId);
+  if (!config) return;
+
+  let task: ExportTask | null = null;
+  try {
+    await connectionStore.ensureConnected(connectionId);
+
+    // Step 1: Open save dialog FIRST
+    let outputPath = `${node.label}.${format}`;
+    if (isTauriRuntime()) {
+      const { save } = await import("@tauri-apps/plugin-dialog");
+      const path = await save({
+        defaultPath: outputPath,
+        filters: [{ name: format === "csv" ? "CSV" : "Excel", extensions: [format] }],
+      });
+      if (!path) return;
+      outputPath = path as string;
+    }
+
+    // Step 2: Register task in export tracker (background)
+    task = addExportTask(node.label, format, outputPath);
+    const currentTask = task;
+
+    // Step 3: Get query columns for neo4j
+    const queryColumns = config.db_type === "neo4j" ? (await api.getColumns(connectionId, database, node.schema || database, node.label)).map((c) => c.name) : undefined;
+
+    // Step 4: Start streaming export (background, non-blocking)
+    const rowLimit = settingsStore.editorSettings.exportRowLimitEnabled ? settingsStore.editorSettings.exportRowLimit : null;
+    const request: api.TableExportRequest = {
+      exportId: currentTask.exportId,
+      connectionId,
+      database,
+      schema: node.schema || undefined,
+      tableName: node.label,
+      filePath: outputPath,
+      format,
+      columns: queryColumns,
+      batchSize: settingsStore.editorSettings.exportBatchSize,
+      rowLimit,
+    };
+
+    await api.startTableExport(request, (progress) => {
+      currentTask.rowsExported = progress.rowsExported;
+      currentTask.totalRows = progress.totalRows;
+      currentTask.status = progress.status;
+      currentTask.errorMessage = progress.errorMessage || null;
+      if (progress.status === "Done") {
+        toast(t("grid.exported"));
+      } else if (progress.status === "Error") {
+        toast(t("grid.exportFailed", { message: progress.errorMessage || "" }), 5000);
+      }
+    });
+  } catch (e: any) {
+    if (task) {
+      task.status = "Error";
+      task.errorMessage = e?.message || String(e);
+    }
+    toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function exportDataXlsx() {
+  await exportTableData("xlsx");
+}
+
+function editConnection() {
+  if (props.node.connectionId) {
+    connectionStore.startEditing(props.node.connectionId);
+  }
+}
+
+const revealConnectionFilePath = computed<string | null>(() => {
+  if (props.node.type !== "connection" || !props.node.connectionId) return null;
+  const config = connectionStore.getConfig(props.node.connectionId);
+  if (!config) return null;
+  return connectionFilePath(config);
+});
+
+async function revealDatabaseFile() {
+  const path = revealConnectionFilePath.value;
+  if (!path) return;
+  try {
+    await revealPathInFileManager(path);
+  } catch (e: any) {
+    const message = typeof e === "string" ? e : e?.message || String(e);
+    toast(message, 5000);
+  }
+}
+
+const sqliteBackupSource = computed<string | null>(() => {
+  if (props.node.type !== "connection" || !props.node.connectionId) return null;
+  const config = connectionStore.getConfig(props.node.connectionId);
+  if (!config) return null;
+  return sqliteBackupSourcePath(config);
+});
+
+const canBackupSqliteDatabase = computed(() => {
+  const source = sqliteBackupSource.value;
+  if (!source || !props.node.connectionId) return false;
+  return isTauriRuntime() && (!isMemorySqlitePath(source) || connectionStore.connectedIds.has(props.node.connectionId));
+});
+
+async function backupSqliteDatabase() {
+  const connId = props.node.connectionId;
+  const config = connId ? connectionStore.getConfig(connId) : undefined;
+  const sourcePath = sqliteBackupSource.value;
+  if (!connId || !config || !sourcePath) return;
+
+  try {
+    const { save } = await import("@tauri-apps/plugin-dialog");
+    const destinationPath = await save({
+      defaultPath: defaultSqliteBackupFileName(config),
+      filters: [{ name: "SQLite", extensions: ["db", "sqlite", "sqlite3"] }],
+    });
+    if (!destinationPath) return;
+
+    toast(t("contextMenu.backupSqliteDatabaseInProgress"), 2000);
+    if (!isMemorySqlitePath(sourcePath)) {
+      await connectionStore.ensureConnected(connId);
+    }
+    await api.backupSqliteDatabase(connId, destinationPath);
+    toast(t("contextMenu.backupSqliteDatabaseSuccess"), 3000);
+  } catch (e: any) {
+    toast(t("contextMenu.backupSqliteDatabaseFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function disconnectConnection() {
+  if (props.node.connectionId) {
+    try {
+      await connectionStore.disconnect(props.node.connectionId);
+      props.node.isExpanded = false;
+      props.node.children = [];
+      toast(t("connection.disconnected"), 2000);
+    } catch (e: any) {
+      toast(t("connection.saveFailed", { message: e?.message || String(e) }), 5000);
+    }
+  }
+}
+
+async function cancelConnectionAttempt() {
+  if (!props.node.connectionId) return;
+  try {
+    const cancelled = await connectionStore.cancelConnecting(props.node.connectionId);
+    if (cancelled) toast(t("connection.connectCancelled"), 2000);
+  } catch (e: any) {
+    toast(t("connection.saveFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+async function closeDatabaseConnection() {
+  const node = props.node;
+  if (node.type !== "database" || !node.connectionId || node.database == null) return;
+  try {
+    await connectionStore.closeDatabaseConnection(node.connectionId, node.database);
+    toast(t("connection.databaseConnectionClosed", { name: node.label }), 2000);
+  } catch (e: any) {
+    toast(t("connection.saveFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function openTransfer() {
+  if (props.node.connectionId) {
+    connectionStore.transferSource = {
+      connectionId: props.node.connectionId,
+      database: props.node.database ?? "",
+    };
+  }
+}
+
+function openSchemaDiff() {
+  if (props.node.connectionId) {
+    connectionStore.schemaDiffSource = {
+      connectionId: props.node.connectionId,
+      database: props.node.database ?? "",
+      schema: props.node.schema,
+    };
+  }
+}
+
+function openDataCompare() {
+  if (props.node.connectionId) {
+    connectionStore.dataCompareSource = {
+      connectionId: props.node.connectionId,
+      database: props.node.database ?? "",
+      schema: props.node.schema,
+      tableName: props.node.type === "table" ? props.node.label : undefined,
+    };
+  }
+}
+
+function openSqlFileExecution() {
+  if (props.node.connectionId) {
+    connectionStore.sqlFileSource = {
+      connectionId: props.node.connectionId,
+      database: props.node.database ?? "",
+    };
+  }
+}
+
+function openDiagram() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  connectionStore.diagramSource = {
+    connectionId: node.connectionId,
+    database: node.database,
+    schema: node.schema,
+    tableName: node.type === "table" ? node.label : undefined,
+  };
+}
+
+function openDatabaseSearch() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  connectionStore.databaseSearchSource = {
+    connectionId: node.connectionId,
+    database: node.database,
+    schema: node.type === "schema" ? node.schema : undefined,
+  };
+}
+
+function openDatabaseExport() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  connectionStore.databaseExportSource = {
+    connectionId: node.connectionId,
+    database: node.database,
+    schema: node.type === "schema" || node.type === "table" || node.type === "view" || node.type === "materialized_view" ? node.schema : undefined,
+    tableName: node.type === "table" || node.type === "view" || node.type === "materialized_view" ? node.label : undefined,
+  };
+}
+
+function openAllDatabasesExport() {
+  const node = props.node;
+  if (node.type !== "connection" || !node.connectionId) return;
+  connectionStore.databaseExportSource = {
+    connectionId: node.connectionId,
+    database: "",
+    allDatabases: true,
+  };
+}
+
+function openTableImport() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  connectionStore.tableImportSource = {
+    connectionId: node.connectionId,
+    database: node.database,
+    schema: node.schema,
+    tableName: node.type === "table" ? node.label : undefined,
+  };
+}
+
+function openStructureEditor() {
+  const node = props.node;
+  if (!node.connectionId || !node.database) return;
+  if (node.type === "table") {
+    queryStore.openTableStructure(node.connectionId, node.database, node.schema, node.label);
+    return;
+  }
+  if (node.type === "column" && node.tableName) {
+    const columnName = tableChildDropObjectName(node).trim();
+    if (!columnName) return;
+    queryStore.openTableStructure(node.connectionId, node.database, node.schema, node.tableName, "columns", { kind: "column", name: columnName });
+    return;
+  }
+  if (node.type === "index" && node.tableName) {
+    const indexName = tableChildDropObjectName(node).trim();
+    if (!indexName) return;
+    queryStore.openTableStructure(node.connectionId, node.database, node.schema, node.tableName, "indexes", { kind: "index", name: indexName });
+  }
+}
+
+function openFieldLineage() {
+  const node = props.node;
+  const column = node.type === "column" && node.meta && "name" in node.meta ? node.meta.name : node.label;
+  if (node.type !== "column" || !node.connectionId || !node.database || !node.tableName || !column) return;
+  connectionStore.fieldLineageSource = {
+    connectionId: node.connectionId,
+    database: node.database,
+    schema: node.schema,
+    tableName: node.tableName,
+    columnName: column,
+  };
+}
+
+const canExpand = computed(() =>
+  canTreeNodeShowExpander({
+    type: props.node.type,
+    childCount: props.node.children?.length ?? 0,
+  }),
+);
+const canPin = computed(() => canTreeNodePin(props.node.type));
+const canOpenSqlFileExecution = computed(() => {
+  return supportsSqlFileExecution(rawDatabaseType());
+});
+const canExportAllDatabases = computed(() => {
+  if (props.node.type !== "connection" || !props.node.connectionId) return false;
+  const dbType = connectionStore.getConfig(props.node.connectionId)?.db_type;
+  return !["redis", "mongodb", "elasticsearch", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "mq", "nacos"].includes(dbType || "");
+});
+const canOpenDiagram = computed(() => {
+  return !!props.node.database && supportsSchemaDiagram(currentDatabaseType());
+});
+const canOpenDatabaseSearch = computed(() => {
+  return !!props.node.database && supportsDatabaseSearch(currentDatabaseType());
+});
+const canOpenObjectBrowser = computed(() => {
+  return supportsObjectBrowserTreeNode(rawDatabaseType(), props.node.type);
+});
+const canOpenTableImport = computed(() => {
+  const node = props.node;
+  const supportedNode = node.type === "table" || ((node.type === "database" || node.type === "schema" || node.type === "group-tables") && canCreateTable.value);
+  return supportedNode && !isSqlServerLinkedNode(node) && !!node.connectionId && !!node.database && supportsTableImport(currentDatabaseType());
+});
+const canOpenStructureEditor = computed(() => {
+  const editableNode = props.node.type === "table" || ((props.node.type === "column" || props.node.type === "index") && !!props.node.tableName);
+  return editableNode && !isSqlServerLinkedNode(props.node) && !!props.node.connectionId && !!props.node.database && supportsTableStructureEditing(currentTableStructureDatabaseType());
+});
+const canOpenFieldLineage = computed(() => {
+  return props.node.type === "column" && !!props.node.database && !!props.node.tableName && supportsFieldLineage(currentDatabaseType());
+});
+const isPinned = computed(() => props.node.pinned || connectionStore.isTreeNodePinned(props.node.id));
+const isNodeDefaultDatabase = computed(() => (props.node.type === "database" || props.node.type === "redis-db" || props.node.type === "mongo-db") && !!props.node.connectionId && !!props.node.database && connectionStore.isDefaultDatabase(props.node.connectionId, props.node.database));
+const hasTypeMenu = computed(() => {
+  const t = props.node.type;
+  return t === "connection" || t === "database" || t === "schema" || t === "table" || t === "view" || t === "column" || t === "procedure" || t === "function" || t === "package" || t === "package-body" || isGroupLabel(props.node);
+});
+const columnComment = computed(() => (!settingsStore.editorSettings.sidebarHideTableComments && props.node.type === "column" && props.node.meta && "comment" in props.node.meta ? (props.node.meta as any).comment : null));
+const tableComment = computed(() =>
+  !settingsStore.editorSettings.sidebarHideTableComments &&
+  (props.node.type === "schema" || props.node.type === "table" || props.node.type === "view" || props.node.type === "mongo-collection" || props.node.type === "vector-collection" || props.node.type === "elasticsearch-index") &&
+  props.node.comment
+    ? props.node.comment
+    : null,
+);
+const paddingLeft = computed(() => treeItemPaddingLeft(props.depth));
+const tableSearchParentId = computed(() => props.node.tableSearchParentId || "");
+const tableSearchValue = computed(() => {
+  const parentId = tableSearchParentId.value;
+  return parentId ? connectionStore.sidebarTableSearchQueries[parentId] || "" : "";
+});
+const isConnected = computed(() => props.node.type === "connection" && !!props.node.connectionId && connectionStore.connectedIds.has(props.node.connectionId));
+const isConnecting = computed(() => props.node.type === "connection" && !!props.node.connectionId && connectionStore.connectingIds.has(props.node.connectionId));
+const isConnectionReadonly = computed(() => props.node.type === "connection" && !!props.node.connectionId && (connectionStore.getConfig(props.node.connectionId)?.read_only ?? false));
+const isOpenedDatabase = computed(() => isSidebarDatabaseOpened(props.node, connectionStore.isTreeNodeChildrenLoaded));
+const showsDatabaseOpenIndicator = computed(() => props.node.type === "database" && (isOpenedDatabase.value || (!!props.node.connectionId && props.node.database != null && queryStore.isDatabaseOpen(props.node.connectionId, props.node.database))));
+const canCloseDatabaseConnection = computed(() => canCloseSidebarDatabaseConnection(props.node, connectionStore.isTreeNodeChildrenLoaded));
+const nodeIconClass = computed(() => {
+  const infoClass = getIconInfo(props.node)?.colorClass;
+  if (props.node.type !== "database") return infoClass;
+  return isOpenedDatabase.value ? infoClass : "text-muted-foreground/65";
+});
+
+const canConfigureVisibleDatabases = computed(() => {
+  if (props.node.type !== "connection" || !props.node.connectionId) return false;
+  const dbType = connectionStore.getConfig(props.node.connectionId)?.db_type;
+  return dbType !== "elasticsearch" && dbType !== "qdrant" && dbType !== "milvus" && dbType !== "weaviate" && dbType !== "chromadb" && dbType !== "etcd" && dbType !== "mq" && dbType !== "nacos";
+});
+
+const canConfigureVisibleSchemas = computed(() => {
+  if (props.node.type === "database" && props.node.connectionId && props.node.database != null) {
+    const dbType = connectionStore.getConfig(props.node.connectionId)?.db_type;
+    return isSchemaAware(dbType);
+  }
+  if (props.node.type === "connection" && props.node.connectionId) {
+    const dbType = connectionStore.getConfig(props.node.connectionId)?.db_type;
+    return isSchemaAware(dbType) && !usesTreeSchemaMode(dbType);
+  }
+  return false;
+});
+
+const canCopyFinalProxyPort = computed(() => {
+  if (props.node.type !== "connection" || !props.node.connectionId) return false;
+  return hasEnabledTransportLayers(connectionStore.getConfig(props.node.connectionId));
+});
+
+function connectionIconType(connectionId?: string) {
+  const config = connectionId ? connectionStore.getConfig(connectionId) : undefined;
+  return config?.driver_profile || config?.db_type || "postgres";
+}
+
+const connectionColor = computed(() => {
+  const connectionId = props.node.connectionId;
+  return connectionId ? connectionStore.getConfig(connectionId)?.color || "" : "";
+});
+const isActiveConnectionScope = computed(() => !!props.node.connectionId && connectionStore.activeConnectionId === props.node.connectionId);
+const isSelected = computed(() => connectionStore.selectedTreeNodeId === props.node.id);
+const isMultiSelected = computed(() => connectionStore.selectedTreeNodeIds.includes(props.node.id));
+const isTreeRowSelected = computed(() => isSelected.value || isMultiSelected.value);
+const usesSelectionSetHighlight = computed(() => connectionStore.connectionMultiSelectActive || connectionStore.selectedTreeNodeIds.length > 1);
+const rowStyle = computed(() => {
+  const color = connectionColor.value;
+  const backgroundColor = hexToRgba(color, isActiveConnectionScope.value ? 0.14 : 0.08);
+  return {
+    paddingLeft: paddingLeft.value,
+    "--tree-connection-row-bg": backgroundColor,
+    "--tree-connection-row-hover-bg": hexToRgba(color, isActiveConnectionScope.value ? 0.18 : 0.12),
+    "--tree-connection-active-bg": hexToRgba(color, 0.18),
+    "--tree-connection-active-focus-bg": hexToRgba(color, 0.22),
+  };
+});
+const tableSearchStyle = computed(() => {
+  const color = connectionColor.value;
+  const rowBackgroundColor = color ? hexToRgba(color, isActiveConnectionScope.value ? 0.14 : 0.08) : "transparent";
+  return {
+    paddingLeft: paddingLeft.value,
+    "--tree-table-search-row-bg": rowBackgroundColor,
+    "--tree-table-search-input-bg": color ? hexToRgba(color, isActiveConnectionScope.value ? 0.05 : 0.03) : "hsl(var(--background) / 0.56)",
+    "--tree-table-search-border": color ? hexToRgba(color, isActiveConnectionScope.value ? 0.12 : 0.08) : "hsl(var(--border) / 0.36)",
+  };
+});
+
+function togglePin() {
+  connectionStore.toggleTreeNodePin(props.node.id);
+}
+
+function updateTableSearchQuery(value: string | number) {
+  const parentId = tableSearchParentId.value;
+  if (!parentId) return;
+  const query = String(value);
+  if (sidebarTreeContext?.setTableSearchQuery) {
+    sidebarTreeContext.setTableSearchQuery(parentId, query);
+    return;
+  }
+  connectionStore.setSidebarTableSearchQuery(parentId, query);
+  void connectionStore.refreshSidebarTableSearch(parentId);
+}
+
+function clearTableSearchQuery() {
+  updateTableSearchQuery("");
+}
+
+function openVisibleDatabasesDialog() {
+  showVisibleDatabasesDialog.value = true;
+}
+
+function openVisibleSchemasDialog() {
+  showVisibleSchemasDialog.value = true;
+}
+
+// --- Connection Group Management ---
+const isRenamingGroup = ref(false);
+const renameInput = ref("");
+const renameInputRef = ref<HTMLInputElement>();
+
+function shouldMeasureLabelOverflow(): boolean {
+  return shouldMeasureSidebarLabelOverflow({
+    hasDetailTooltip: !!detailTooltip.value?.rows.length,
+    isRenaming: isRenamingGroup.value,
+    usesFullWidthLabel: usesFullWidthLabel.value,
+  });
+}
+
+function startRenameGroup() {
+  renameInput.value = props.node.label;
+  isRenamingGroup.value = true;
+  emit("rename-started");
+  nextTick(() => {
+    focusSidebarRenameInput(() => (isRenamingGroup.value ? renameInputRef.value : undefined));
+  });
+}
+
+watch(
+  () => props.pendingRename,
+  (val) => {
+    if (val && props.node.type === "connection-group") {
+      startRenameGroup();
+    }
+  },
+  { immediate: true },
+);
+
+watch(
+  [() => props.node.id, () => visibleLabel(props.node), () => usesFullWidthLabel.value, () => detailTooltip.value?.rows.length ?? 0, isRenamingGroup],
+  () => {
+    nextTick(observeLabelOverflow);
+  },
+  { flush: "post", immediate: true },
+);
+
+function finishRenameGroup() {
+  // Guard against double invocation: pressing Enter sets isRenamingGroup=false
+  // and unmounts the input, which then fires @blur -> finishRenameGroup again.
+  // The first call can rebuild the tree and recycle props.node onto a different
+  // group, so a second run would act on the wrong group and cascade across
+  // groups (issue #681).
+  if (!isRenamingGroup.value) return;
+  isRenamingGroup.value = false;
+  const trimmed = renameInput.value.trim();
+  // An empty name cancels the rename and keeps the group as-is — never delete
+  // here. Deleting a group is done explicitly via the context menu (issue #681).
+  if (!trimmed || trimmed === props.node.label) return;
+  connectionStore.renameConnectionGroup(props.node.id, trimmed);
+}
+
+function deleteConnectionGroup() {
+  showDeleteGroupConfirm.value = true;
+}
+
+function newConnectionInGroup() {
+  connectionStore.startCreatingConnectionInGroup(props.node.id);
+}
+
+function newSubgroup() {
+  const groupId = connectionStore.createConnectionGroup(t("connectionGroup.newGroupDefault"), props.node.id);
+  connectionStore.selectedTreeNodeId = groupId;
+  emit("group-created", groupId);
+}
+
+function confirmDeleteGroup() {
+  connectionStore.deleteConnectionGroup(props.node.id);
+  showDeleteGroupConfirm.value = false;
+  toast(t("connection.groupDeleted"), 2000);
+}
+
+const showDeleteGroupConfirm = ref(false);
+
+function moveToGroup(groupId: string | null) {
+  if (props.node.connectionId) {
+    connectionStore.moveConnectionToGroup(props.node.connectionId, groupId);
+  }
+}
+
+const showMoveToNewGroupDialog = ref(false);
+const moveToNewGroupName = ref("");
+
+function moveToNewGroup() {
+  moveToNewGroupName.value = "";
+  showMoveToNewGroupDialog.value = true;
+}
+
+function confirmMoveToNewGroup() {
+  const name = moveToNewGroupName.value.trim();
+  if (name && props.node.connectionId) {
+    const groupId = connectionStore.createConnectionGroup(name);
+    connectionStore.moveConnectionToGroup(props.node.connectionId, groupId);
+  }
+  showMoveToNewGroupDialog.value = false;
+}
+
+const availableGroups = computed(() => connectionStore.sidebarLayout.groups);
+
+const currentGroupId = computed(() => {
+  if (props.node.type !== "connection" || !props.node.connectionId) return null;
+  const find = (entries: typeof connectionStore.sidebarLayout.order): string | null => {
+    for (const entry of entries) {
+      if (entry.type !== "group") continue;
+      if ((entry.children ?? entry.connectionIds?.map((id) => ({ type: "connection" as const, id })) ?? []).some((child) => child.type === "connection" && child.id === props.node.connectionId)) {
+        return entry.id;
+      }
+      const found = find(entry.children ?? []);
+      if (found) return found;
+    }
+    return null;
+  };
+  return find(connectionStore.sidebarLayout.order);
+});
+
+// --- Drag and Drop ---
+import { useDragSort } from "@/composables/useDragSort";
+
+const {
+  state: dragState,
+  startDrag,
+  updateTarget,
+  clearTarget,
+} = useDragSort((draggedId, targetId, position) => {
+  // If the grabbed row is part of a multi-selection, move all selected rows
+  // together; otherwise just the grabbed one (issue #681).
+  const selected = connectionStore.selectedTreeNodeIds;
+  const draggedIds = selected.length > 1 && selected.includes(draggedId) ? [...selected] : [draggedId];
+  connectionStore.reorderSidebarEntries(draggedIds, targetId, position);
+});
+
+const isDraggable = computed(() => {
+  if (props.dragDisabled) return false;
+  return props.node.type === "connection" || props.node.type === "connection-group";
+});
+
+const isDropTarget = computed(() => props.node.type === "connection" || props.node.type === "connection-group");
+
+const showDropBefore = computed(() => dragState.active && dragState.targetId === props.node.id && dragState.dropPosition === "before");
+const showDropAfter = computed(() => dragState.active && dragState.targetId === props.node.id && dragState.dropPosition === "after");
+const showDropInside = computed(() => dragState.active && dragState.targetId === props.node.id && dragState.dropPosition === "inside");
+const isDragging = computed(() => dragState.active && dragState.draggedId === props.node.id);
+const TABLE_REFERENCE_DRAG_THRESHOLD = 5;
+const TABLE_REFERENCE_DRAGGING_CLASS = "dbx-table-reference-dragging";
+const canDragTableReference = computed(() => {
+  if (props.dragDisabled || !props.node.connectionId) return false;
+  if (props.node.type === "database") return typeof props.node.database === "string" && props.node.database.trim().length > 0;
+  if (props.node.database == null) return false;
+  if (props.node.type === "table" || props.node.type === "view" || props.node.type === "materialized_view") return true;
+  return props.node.type === "column" && !!props.node.tableName;
+});
+
+let pendingTableReferenceDrag: {
+  payload: QueryEditorTableReferencePayload;
+  startX: number;
+  startY: number;
+} | null = null;
+let draggingTableReferencePayload: QueryEditorTableReferencePayload | null = null;
+let suppressNextTableReferenceClick = false;
+
+function tableReferenceDragPayload(): QueryEditorTableReferencePayload | null {
+  if (!canDragTableReference.value) return null;
+  if (props.node.type === "database") {
+    return createTableReferencePayload({
+      connectionId: props.node.connectionId,
+      database: props.node.database,
+      referenceType: "database",
+      databaseType: currentDatabaseType(),
+    });
+  }
+  if (props.node.type === "column") {
+    const columnName = columnNameForDrag(props.node);
+    if (!props.node.tableName || !columnName) return null;
+    return createTableReferencePayload({
+      connectionId: props.node.connectionId,
+      database: props.node.database,
+      schema: props.node.schema,
+      tableName: props.node.tableName,
+      columnName,
+      databaseType: currentDatabaseType(),
+    });
+  }
+  const payload = createTableReferencePayload({
+    connectionId: props.node.connectionId,
+    database: props.node.database,
+    schema: props.node.schema,
+    tableName: props.node.label,
+    databaseType: currentDatabaseType(),
+  });
+  return payload;
+}
+
+function columnNameForDrag(node: TreeNode): string {
+  const column = node.meta as Partial<ColumnInfo> | undefined;
+  if (typeof column?.name === "string" && column.name) return column.name;
+  return node.label.replace(/\s+\([^()]*\)$/, "");
+}
+
+function startTableReferenceDrag(payload: QueryEditorTableReferencePayload) {
+  draggingTableReferencePayload = payload;
+  setActiveTableReferencePayload(payload);
+  document.getSelection()?.removeAllRanges();
+  document.body.style.cursor = "copy";
+}
+
+function finishTableReferenceDrag() {
+  clearActiveTableReferencePayload(draggingTableReferencePayload);
+  pendingTableReferenceDrag = null;
+  draggingTableReferencePayload = null;
+  document.body.classList.remove(TABLE_REFERENCE_DRAGGING_CLASS);
+  document.body.style.cursor = "";
+  document.removeEventListener("mousemove", onTableReferenceMouseMove, true);
+  document.removeEventListener("mouseup", onTableReferenceMouseUp, true);
+}
+
+function onTableReferenceMouseMove(event: MouseEvent) {
+  if (!pendingTableReferenceDrag && !draggingTableReferencePayload) return;
+  if (pendingTableReferenceDrag && !draggingTableReferencePayload) {
+    const dx = event.clientX - pendingTableReferenceDrag.startX;
+    const dy = event.clientY - pendingTableReferenceDrag.startY;
+    if (Math.abs(dx) < TABLE_REFERENCE_DRAG_THRESHOLD && Math.abs(dy) < TABLE_REFERENCE_DRAG_THRESHOLD) return;
+    startTableReferenceDrag(pendingTableReferenceDrag.payload);
+  }
+  if (draggingTableReferencePayload) {
+    event.preventDefault();
+    document.getSelection()?.removeAllRanges();
+  }
+}
+
+function onTableReferenceMouseUp(event: MouseEvent) {
+  const payload = draggingTableReferencePayload;
+  if (payload) {
+    suppressNextTableReferenceClick = true;
+    const target = document.elementFromPoint(event.clientX, event.clientY);
+    if (target instanceof Element && target.closest("[data-query-editor-root]")) {
+      window.dispatchEvent(
+        createTableReferenceDropEvent({
+          payload,
+          clientX: event.clientX,
+          clientY: event.clientY,
+        }),
+      );
+    }
+  }
+  finishTableReferenceDrag();
+}
+
+function startTableReferenceMouseDrag(event: MouseEvent) {
+  if (event.button !== 0) return;
+  const payload = tableReferenceDragPayload();
+  if (!payload) return;
+  event.preventDefault();
+  document.getSelection()?.removeAllRanges();
+  document.body.classList.add(TABLE_REFERENCE_DRAGGING_CLASS);
+  pendingTableReferenceDrag = { payload, startX: event.clientX, startY: event.clientY };
+  document.addEventListener("mousemove", onTableReferenceMouseMove, true);
+  document.addEventListener("mouseup", onTableReferenceMouseUp, true);
+}
+
+function onRowMouseDown(event: MouseEvent) {
+  if (isDraggable.value) {
+    startDrag(event, props.node.id, props.node.type);
+  } else if (canDragTableReference.value) {
+    startTableReferenceMouseDrag(event);
+  }
+}
+
+onMounted(() => {
+  observeLabelOverflow();
+  window.addEventListener("dbx:sidebar-request-paste-table", onSidebarRequestPasteTable);
+});
+
+onBeforeUnmount(() => {
+  labelResizeObserver?.disconnect();
+  labelResizeObserver = null;
+  cancelLabelOverflowMeasure();
+  window.removeEventListener("dbx:sidebar-request-paste-table", onSidebarRequestPasteTable);
+  finishTableReferenceDrag();
+});
+
+// ---- CustomContextMenu ----
+
+const shortcutCopyName = computed(() => settingsStore.editorSettings.shortcuts.copySidebarSelection);
+const shortcutEditConnection = computed(() => settingsStore.editorSettings.shortcuts.editSidebarConnection);
+const shortcutRename = "F2";
+const shortcutRefresh = "F5";
+const shortcutDelete = "Delete";
+
+function exportDataSubmenu(): ContextMenuItem {
+  return {
+    label: t("contextMenu.exportData"),
+    icon: Upload,
+    children: [
+      { label: "CSV", action: () => exportData("csv") },
+      { label: "JSON", action: () => exportData("json") },
+      { label: "SQL INSERT", action: () => exportData("sql") },
+      { label: "XLSX", action: () => exportDataXlsx() },
+    ],
+  };
+}
+
+function copyStructureAsSubmenu(): ContextMenuItem {
+  return {
+    label: t("contextMenu.copyStructureAs"),
+    icon: Clipboard,
+    children: [
+      { label: t("contextMenu.copyStructureAsTsv"), action: () => copyStructureAs("tsv") },
+      { label: t("contextMenu.copyStructureAsMarkdown"), action: () => copyStructureAs("markdown") },
+    ],
+  };
+}
+
+function moreActionsSubmenu(children: ContextMenuItem[]): ContextMenuItem {
+  return {
+    label: t("common.more"),
+    icon: ListTree,
+    children,
+  };
+}
+
+function savedSqlHistoryScopeForNode(node: TreeNode): SavedSqlHistoryScope | null {
+  if (!node.connectionId) return null;
+  if (node.type === "connection") {
+    return { connectionId: node.connectionId };
+  }
+  if ((node.type === "database" || node.type === "schema") && hasTreeNodeDatabaseContext(node)) {
+    return {
+      connectionId: node.connectionId,
+      database: node.database,
+      schema: node.type === "schema" ? node.schema : undefined,
+    };
+  }
+  if ((node.type === "table" || node.type === "view") && hasTreeNodeDatabaseContext(node)) {
+    return {
+      connectionId: node.connectionId,
+      database: node.database,
+      schema: node.schema,
+      tableName: node.label,
+    };
+  }
+  return null;
+}
+
+async function openSavedSqlHistoryFile(fileId: string) {
+  const file = await savedSqlStore.ensureFileContent(fileId);
+  if (!file) return;
+  queryStore.openSavedSql(file);
+  connectionStore.activeConnectionId = file.connectionId;
+  void savedSqlStore.recordFileUsage(file.id);
+}
+
+function savedSqlHistorySubmenu(): ContextMenuItem | null {
+  const scope = savedSqlHistoryScopeForNode(props.node);
+  if (!scope) return null;
+  const files = rankSavedSqlHistory(savedSqlStore.allFiles, { ...scope, limit: 10 });
+  return {
+    label: t("contextMenu.sqlHistory"),
+    icon: ScrollText,
+    children:
+      files.length > 0
+        ? files.map((file) => ({
+            label: file.name,
+            action: () => openSavedSqlHistoryFile(file.id),
+            icon: FileCode,
+          }))
+        : [
+            {
+              label: t("contextMenu.noSqlHistory"),
+              disabled: true,
+            },
+          ],
+  };
+}
+
+function treeItemMenuItems(): ContextMenuItem[] {
+  const node = props.node;
+  const items: ContextMenuItem[] = [];
+  const batchDropCount = selectedBatchDropTargets().length;
+  const batchEmptyCount = selectedBatchEmptyTargets().length;
+  const batchTruncateCount = selectedBatchTruncateTargets().length;
+  const deleteMenuLabel = (singleLabel: string) => (batchDropCount > 1 ? batchDropMenuLabel() : singleLabel);
+  const deleteMenuAction = (singleAction: () => void) => (batchDropCount > 1 ? requestBatchDrop : singleAction);
+  const truncateMenuLabel = (singleLabel: string) => (batchTruncateCount > 1 ? batchTruncateMenuLabel() : singleLabel);
+  const truncateMenuAction = (singleAction: () => void) => (batchTruncateCount > 1 ? requestBatchTruncate : singleAction);
+  const emptyMenuLabel = (singleLabel: string) => (batchEmptyCount > 1 ? batchEmptyMenuLabel() : singleLabel);
+  const emptyMenuAction = (singleAction: () => void) => (batchEmptyCount > 1 ? requestBatchEmpty : singleAction);
+
+  // 1. Pin toggle
+  if (canPin.value) {
+    items.push({
+      label: isPinned.value ? t("contextMenu.unpin") : t("contextMenu.pin"),
+      action: togglePin,
+      icon: Pin,
+    });
+    if (hasTypeMenu.value) items.push({ label: "", separator: true });
+  }
+
+  // 2. Connection
+  if (node.type === "connection") {
+    if (isConnecting.value) {
+      items.push({ label: t("connection.cancelConnecting"), action: cancelConnectionAttempt, icon: X });
+    } else if (!isConnected.value) {
+      items.push({ label: t("contextMenu.openConnection"), action: toggle, icon: Plug });
+    } else {
+      items.push({ label: t("contextMenu.closeConnection"), action: disconnectConnection, icon: Unplug });
+    }
+    items.push({ label: t("contextMenu.newQuery"), action: newQuery, icon: TerminalSquare });
+    if (currentDatabaseType() === "redis") {
+      items.push({ label: t("contextMenu.instanceInfo"), action: openRedisInstanceInfo, icon: Info });
+    }
+    const sqlHistoryMenu = savedSqlHistorySubmenu();
+    if (sqlHistoryMenu) items.push(sqlHistoryMenu);
+    if (supportsDatabaseUserAdmin(currentDatabaseType())) {
+      items.push({ label: t("contextMenu.userAdmin"), action: openUserAdmin, icon: UsersRound });
+    }
+    if (currentDatabaseType() === "dameng") {
+      items.push({ label: t("contextMenu.damengJobAdmin"), action: openDamengJobAdmin, icon: CalendarClock });
+    }
+    if (canCopyFinalProxyPort.value) {
+      items.push({ label: t("contextMenu.copyFinalProxyPort"), action: copyFinalProxyPort, icon: Network });
+    }
+    if (canOpenSqlFileExecution.value) {
+      items.push({ label: t("sqlFile.title"), action: openSqlFileExecution, icon: FileCode });
+    }
+    if (canExportAllDatabases.value) {
+      items.push({ label: t("contextMenu.exportAllDatabases"), action: openAllDatabasesExport, icon: Upload });
+    }
+    if (canCreateDatabase.value) {
+      items.push({
+        label: connectionNamespaceCreationLabel(),
+        action: openConnectionNamespaceCreation,
+        icon: Plus,
+      });
+    }
+    if (canCreateNacosNamespace.value) {
+      items.push({
+        label: t("nacos.createNamespace"),
+        action: openCreateNacosNamespaceDialog,
+        icon: FolderPlus,
+      });
+    }
+    items.push({ label: "", separator: true });
+    if (availableGroups.value.length > 0 || currentGroupId.value) {
+      const groupChildren: ContextMenuItem[] = availableGroups.value.map((group: { id: string; name: string }) => ({
+        label: group.name,
+        action: () => moveToGroup(group.id),
+        icon: FolderOpen,
+        disabled: group.id === currentGroupId.value,
+      }));
+      if (currentGroupId.value) {
+        groupChildren.push({ label: "", separator: true });
+        groupChildren.push({ label: t("connectionGroup.ungrouped"), action: () => moveToGroup(null) });
+      }
+      groupChildren.push({ label: "", separator: true });
+      groupChildren.push({ label: t("connectionGroup.newGroup"), action: moveToNewGroup, icon: FolderPlus });
+      items.push({ label: t("connectionGroup.moveToGroup"), icon: FolderInput, children: groupChildren });
+    } else {
+      items.push({ label: t("connectionGroup.moveToNewGroup"), action: moveToNewGroup, icon: FolderPlus });
+    }
+    items.push({
+      label: t("contextMenu.refreshChildren"),
+      action: refresh,
+      icon: RefreshCw,
+      shortcut: shortcutRefresh,
+    });
+    if (canConfigureVisibleDatabases.value) {
+      items.push({
+        label: t("contextMenu.configureVisibleObjects"),
+        action: openVisibleDatabasesDialog,
+        icon: ListFilter,
+      });
+    } else if (canConfigureVisibleSchemas.value) {
+      items.push({
+        label: t("visibleSchemas.title"),
+        action: openVisibleSchemasDialog,
+        icon: ListFilter,
+      });
+    }
+    if (canConfigureVisibleSchemas.value) {
+      items.push({
+        label: t("visibleSchemas.title"),
+        action: openVisibleSchemasDialog,
+        icon: ListFilter,
+      });
+    }
+    items.push({ label: t("contextMenu.editConnection"), action: editConnection, icon: Pencil, shortcut: shortcutEditConnection.value });
+    if (revealConnectionFilePath.value) {
+      items.push({
+        label: t("contextMenu.revealDatabaseFile"),
+        action: revealDatabaseFile,
+        icon: FolderOpen,
+      });
+    }
+    if (canBackupSqliteDatabase.value) {
+      items.push({
+        label: t("contextMenu.backupSqliteDatabase"),
+        action: backupSqliteDatabase,
+        icon: HardDriveDownload,
+      });
+    }
+    items.push({ label: connectionDuplicateMenuLabel(), action: duplicateConnection, icon: CopyPlus });
+    items.push({ label: "", separator: true });
+    items.push({
+      label: connectionDeleteMenuLabel(),
+      action: deleteConnection,
+      icon: Trash2,
+      shortcut: shortcutDelete,
+      variant: "destructive" as const,
+    });
+    return items;
+  }
+
+  // 3. Connection Group
+  if (node.type === "connection-group") {
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    items.push({ label: "", separator: true });
+    items.push({ label: t("toolbar.newConnection"), action: newConnectionInGroup, icon: Plus });
+    items.push({ label: t("connectionGroup.newGroup"), action: newSubgroup, icon: FolderPlus });
+    items.push({ label: "", separator: true });
+    items.push({
+      label: t("connectionGroup.renameGroup"),
+      action: startRenameGroup,
+      icon: Pencil,
+      shortcut: shortcutRename,
+    });
+    items.push({ label: "", separator: true });
+    items.push({
+      label: t("connectionGroup.deleteGroup"),
+      action: deleteConnectionGroup,
+      icon: Trash2,
+      shortcut: shortcutDelete,
+      variant: "destructive" as const,
+    });
+    return items;
+  }
+
+  // 4. Database / Schema
+  if (node.type === "database" || node.type === "schema") {
+    if (canCloseDatabaseConnection.value) {
+      items.push({ label: t("contextMenu.closeDatabaseConnection"), action: closeDatabaseConnection, icon: Unplug });
+      items.push({ label: "", separator: true });
+    }
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    items.push({ label: "", separator: true });
+    if (canOpenObjectBrowser.value) {
+      items.push({ label: t("contextMenu.openObjectBrowser"), action: openObjectBrowser, icon: TableProperties });
+    }
+    items.push({ label: t("contextMenu.newQuery"), action: newQuery, icon: TerminalSquare });
+    const sqlHistoryMenu = savedSqlHistorySubmenu();
+    if (sqlHistoryMenu) items.push(sqlHistoryMenu);
+    if (node.type === "database" && currentDatabaseType() !== "cloudflare-d1") {
+      if (!isNodeDefaultDatabase.value) {
+        items.push({ label: t("contextMenu.setDefaultDatabase"), action: setNodeAsDefaultDatabase, icon: Database });
+      } else {
+        items.push({ label: t("contextMenu.clearDefaultDatabase"), action: clearNodeDefaultDatabase, icon: Database });
+      }
+    }
+    if (canEditDatabaseProperties.value) {
+      items.push({ label: t("contextMenu.editDatabaseProperties"), action: openEditDatabasePropertiesDialog, icon: SquarePen });
+    }
+    if (canCreateTable.value) {
+      items.push({ label: t("contextMenu.createTable"), action: createTable, icon: Plus });
+    }
+    if (canOpenTableImport.value) {
+      items.push({ label: t("contextMenu.importData"), action: openTableImport, icon: Download });
+    }
+    if (canCreateSchema.value) {
+      items.push({ label: t("contextMenu.createSchema"), action: openCreateSchemaDialog, icon: Plus });
+    }
+    if (canEditSchemaComment.value) {
+      items.push({ label: t("contextMenu.editSchemaComment"), action: openEditSchemaCommentDialog, icon: SquarePen });
+    }
+    if (canOpenSqlFileExecution.value) {
+      items.push({ label: t("sqlFile.title"), action: openSqlFileExecution, icon: FileCode });
+    }
+    if (canOpenDiagram.value) {
+      items.push({ label: t("diagram.open"), action: openDiagram, icon: Network });
+    }
+    if (canOpenDatabaseSearch.value) {
+      items.push({ label: t("databaseSearch.open"), action: openDatabaseSearch, icon: Search });
+    }
+    items.push({
+      label: t("contextMenu.refreshChildren"),
+      action: refresh,
+      icon: RefreshCw,
+      shortcut: shortcutRefresh,
+    });
+    if (canConfigureVisibleSchemas.value) {
+      items.push({
+        label: t("visibleSchemas.title"),
+        action: openVisibleSchemasDialog,
+        icon: ListFilter,
+      });
+    }
+    items.push({ label: "", separator: true });
+    items.push({ label: t("transfer.dataTransfer"), action: openTransfer, icon: ArrowRightLeft });
+    items.push({ label: t("diff.title"), action: openSchemaDiff, icon: ArrowRightLeft });
+    items.push({ label: t("dataCompare.title"), action: openDataCompare, icon: ArrowRightLeft });
+    items.push({ label: t("contextMenu.exportDatabase"), action: openDatabaseExport, icon: Upload });
+    const destructiveActions: ContextMenuItem[] = [];
+    if (canDropDatabase.value) {
+      destructiveActions.push({
+        label: t("contextMenu.dropDatabase"),
+        action: dropDatabase,
+        icon: Trash2,
+        shortcut: shortcutDelete,
+        variant: "destructive" as const,
+      });
+    }
+    if (destructiveActions.length > 0) {
+      items.push({ label: "", separator: true });
+      items.push(moreActionsSubmenu(destructiveActions));
+    }
+    if (canDropSchema.value) {
+      items.push({ label: "", separator: true });
+    }
+    if (canDropSchema.value) {
+      items.push({
+        label: t("contextMenu.dropSchema"),
+        action: dropSchema,
+        icon: Trash2,
+        shortcut: shortcutDelete,
+        variant: "destructive" as const,
+      });
+    }
+    return items;
+  }
+
+  // 5. Redis DB / Mongo DB
+  if (node.type === "etcd-root" || node.type === "zookeeper-root") {
+    items.push({ label: t("contextMenu.openConnection"), action: toggle, icon: Database });
+    return items;
+  }
+
+  if (node.type === "user-admin") {
+    items.push({ label: t("contextMenu.openUserAdmin"), action: openUserAdmin, icon: UsersRound });
+    return items;
+  }
+
+  if (node.type === "dameng-job-admin") {
+    items.push({ label: t("contextMenu.openDamengJobAdmin"), action: openDamengJobAdmin, icon: CalendarClock });
+    return items;
+  }
+
+  if (node.type === "redis-db" || node.type === "mongo-db") {
+    items.push({ label: t("contextMenu.newQuery"), action: newQuery, icon: TerminalSquare });
+    if (!isNodeDefaultDatabase.value) {
+      items.push({ label: t("contextMenu.setDefaultDatabase"), action: setNodeAsDefaultDatabase, icon: Database });
+    } else {
+      items.push({ label: t("contextMenu.clearDefaultDatabase"), action: clearNodeDefaultDatabase, icon: Database });
+    }
+    if (node.type === "mongo-db") {
+      items.push({ label: "", separator: true });
+      items.push({ label: t("transfer.dataTransfer"), action: openTransfer, icon: ArrowRightLeft });
+    }
+    if (node.type === "redis-db") {
+      items.push({ label: "", separator: true });
+      items.push({ label: t("redis.flushDb"), action: flushRedisDb, icon: Eraser, variant: "destructive" as const });
+    }
+    if (canDropMongoDatabase.value) {
+      items.push({ label: "", separator: true });
+      items.push(
+        moreActionsSubmenu([
+          {
+            label: t("contextMenu.dropDatabase"),
+            action: dropDatabase,
+            icon: Trash2,
+            shortcut: shortcutDelete,
+            variant: "destructive" as const,
+          },
+        ]),
+      );
+    }
+    return items;
+  }
+
+  if (node.type === "nacos-namespace") {
+    items.push({ label: t("contextMenu.openConnection"), action: toggle, icon: FolderOpen });
+    if (canEditNacosNamespace.value) {
+      items.push({ label: t("nacos.editNamespace"), action: openEditNacosNamespaceDialog, icon: Pencil });
+    }
+    items.push({
+      label: t("contextMenu.refreshChildren"),
+      action: refresh,
+      icon: RefreshCw,
+      shortcut: shortcutRefresh,
+    });
+    items.push({ label: "", separator: true });
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    return items;
+  }
+
+  if (node.type === "mongo-collection") {
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    items.push({ label: "", separator: true });
+    items.push({ label: t("contextMenu.viewData"), action: toggle, icon: TableProperties });
+    items.push({ label: t("contextMenu.newQuery"), action: newQuery, icon: TerminalSquare });
+    if (canDropAllMongoIndexes.value || canDropMongoCollection.value) {
+      items.push({ label: "", separator: true });
+      if (canDropAllMongoIndexes.value) {
+        items.push({ label: t("contextMenu.dropAllIndexes"), action: dropAllMongoIndexes, icon: Trash2, variant: "destructive" as const });
+      }
+      if (canDropMongoCollection.value) {
+        items.push({ label: t("contextMenu.dropCollection"), action: dropMongoCollection, icon: Trash2, shortcut: shortcutDelete, variant: "destructive" as const });
+      }
+    }
+    return items;
+  }
+
+  if (node.type === "elasticsearch-index" || node.type === "vector-collection") {
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    items.push({ label: "", separator: true });
+    items.push({ label: t("contextMenu.viewData"), action: toggle, icon: TableProperties });
+    items.push({ label: t("contextMenu.newQuery"), action: newQuery, icon: TerminalSquare });
+    return items;
+  }
+
+  // 6. Table / View / Materialized View
+  if (node.type === "table" || node.type === "view" || node.type === "materialized_view") {
+    const destructiveActions: ContextMenuItem[] = [];
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    items.push({ label: "", separator: true });
+    items.push({ label: t("contextMenu.viewData"), action: openData, icon: TableProperties });
+    if (node.type === "table") {
+      items.push({
+        label: t("contextMenu.viewDdl"),
+        action: () => {
+          ddlTarget.value = node;
+          showDdlDialog.value = true;
+        },
+        icon: FileCode,
+      });
+    }
+    if (node.type === "view" || node.type === "materialized_view") {
+      items.push({ label: t("contextMenu.editView"), action: () => openObjectSourceDialog(true), icon: Pencil });
+      items.push({ label: t("contextMenu.viewSource"), action: () => openObjectSourceDialog(false), icon: Code2 });
+      items.push({
+        label: t("contextMenu.viewDdl"),
+        action: () => {
+          ddlTarget.value = node;
+          showDdlDialog.value = true;
+        },
+        icon: FileCode,
+      });
+    }
+    if (canOpenStructureEditor.value) {
+      items.push({ label: t("contextMenu.editStructure"), action: openStructureEditor, icon: PencilRuler });
+    }
+    if (canRenameObject.value) {
+      items.push({
+        label: t("contextMenu.renameObject"),
+        action: openRenameObjectDialog,
+        icon: Pencil,
+        shortcut: shortcutRename,
+      });
+    }
+    if (node.type === "view" || node.type === "materialized_view") {
+      destructiveActions.push({
+        label: deleteMenuLabel(t("contextMenu.dropView")),
+        action: deleteMenuAction(requestDropObject),
+        icon: Trash2,
+        shortcut: shortcutDelete,
+        variant: "destructive" as const,
+      });
+    }
+    items.push({
+      label: t("contextMenu.generateSql"),
+      icon: FilePlus,
+      children: isTableNotView.value
+        ? [
+            { label: "SELECT", action: newSelectTemplate, icon: TerminalSquare },
+            { label: "INSERT", action: newInsertTemplate, icon: FilePlus },
+            { label: "UPDATE", action: newUpdateTemplate, icon: SquarePen },
+            { label: "DELETE", action: newDeleteTemplate, icon: ListX },
+            { label: "DDL", action: generateDdlTemplate, icon: FileCode },
+          ]
+        : [
+            { label: "SELECT", action: newSelectTemplate, icon: TerminalSquare },
+            { label: "DDL", action: generateDdlTemplate, icon: FileCode },
+          ],
+    });
+    const sqlHistoryMenu = savedSqlHistorySubmenu();
+    if (sqlHistoryMenu) items.push(sqlHistoryMenu);
+    if (canOpenDiagram.value) {
+      items.push({ label: t("diagram.open"), action: openDiagram, icon: Network });
+    }
+    if (canOpenTableImport.value) {
+      items.push({ label: t("contextMenu.importData"), action: openTableImport, icon: Download });
+    }
+    if (isTableNotView.value) {
+      items.push({ label: t("dataCompare.title"), action: openDataCompare, icon: ArrowRightLeft });
+    }
+    items.push({ label: "", separator: true });
+    items.push(exportDataSubmenu());
+    items.push({ label: t("contextMenu.exportDatabase"), action: openDatabaseExport, icon: Upload });
+    items.push({ label: t("contextMenu.exportStructure"), action: exportStructure, icon: FileCode });
+    items.push(copyStructureAsSubmenu());
+    if (isTableNotView.value) {
+      items.push({ label: "", separator: true });
+      items.push({ label: t("contextMenu.duplicateStructure"), action: duplicateStructure, icon: CopyPlus });
+      items.push({ label: t("contextMenu.copyTable"), action: copyTableToClipboard, icon: Copy });
+      if (supportsTruncate.value) {
+        destructiveActions.push({
+          label: truncateMenuLabel(t("contextMenu.truncateTable")),
+          action: truncateMenuAction(truncateTable),
+          icon: Scissors,
+          variant: "destructive" as const,
+        });
+      }
+      destructiveActions.push({
+        label: emptyMenuLabel(t("contextMenu.emptyTable")),
+        action: emptyMenuAction(emptyTable),
+        icon: Eraser,
+        variant: "destructive" as const,
+      });
+      destructiveActions.push({
+        label: deleteMenuLabel(t("contextMenu.dropTable")),
+        action: deleteMenuAction(dropTable),
+        icon: Trash2,
+        shortcut: shortcutDelete,
+        variant: "destructive" as const,
+      });
+    }
+    if (destructiveActions.length > 0) {
+      items.push({ label: "", separator: true });
+      items.push(moreActionsSubmenu(destructiveActions));
+    }
+    items.push({ label: "", separator: true });
+    items.push({
+      label: t("contextMenu.refreshChildren"),
+      action: refresh,
+      icon: RefreshCw,
+      shortcut: shortcutRefresh,
+    });
+    return items;
+  }
+
+  // 7. Column
+  if (node.type === "column") {
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    const columnActions: ContextMenuItem[] = [];
+    if (canOpenStructureEditor.value) {
+      columnActions.push({ label: t("contextMenu.editColumn"), action: openStructureEditor, icon: PencilRuler });
+    }
+    if (canOpenFieldLineage.value) {
+      columnActions.push({ label: t("lineage.open"), action: openFieldLineage, icon: Network });
+    }
+    if (columnActions.length > 0) {
+      items.push({ label: "", separator: true });
+      items.push(...columnActions);
+    }
+    if (canDropTableChildObject.value) {
+      items.push({ label: "", separator: true });
+      items.push({
+        label: deleteMenuLabel(dropTableChildObjectMenuLabel()),
+        action: deleteMenuAction(requestDropTableChildObject),
+        icon: Trash2,
+        shortcut: shortcutDelete,
+        variant: "destructive" as const,
+      });
+    }
+    return items;
+  }
+
+  if (node.type === "index" || node.type === "fkey" || node.type === "trigger") {
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    if (node.type === "index" && canOpenStructureEditor.value) {
+      items.push({ label: "", separator: true });
+      items.push({ label: t("contextMenu.editIndex"), action: openStructureEditor, icon: PencilRuler });
+    }
+    if (node.type === "index" && canDropMongoIndex.value) {
+      items.push({ label: "", separator: true });
+      items.push({
+        label: deleteMenuLabel(t("contextMenu.dropIndex")),
+        action: deleteMenuAction(dropMongoIndex),
+        icon: Trash2,
+        shortcut: shortcutDelete,
+        variant: "destructive" as const,
+      });
+    } else if (canDropTableChildObject.value) {
+      items.push({ label: "", separator: true });
+      items.push({
+        label: deleteMenuLabel(dropTableChildObjectMenuLabel()),
+        action: deleteMenuAction(requestDropTableChildObject),
+        icon: Trash2,
+        shortcut: shortcutDelete,
+        variant: "destructive" as const,
+      });
+    }
+    return items;
+  }
+
+  // 8. Procedure / Function / Package
+  if (node.type === "procedure" || node.type === "function") {
+    if (node.type === "procedure") {
+      items.push({ label: t("contextMenu.executeProcedure"), action: openProcedureExecution, icon: Play });
+    }
+    items.push({ label: t("contextMenu.viewSource"), action: () => openObjectSourceDialog(false), icon: Code2 });
+    if (canRenameObject.value) {
+      items.push({
+        label: t("contextMenu.renameObject"),
+        action: openRenameObjectDialog,
+        icon: Pencil,
+        shortcut: shortcutRename,
+      });
+    }
+    items.push({ label: "", separator: true });
+    items.push({
+      label: deleteMenuLabel(node.type === "procedure" ? t("contextMenu.dropProcedure") : t("contextMenu.dropFunction")),
+      action: deleteMenuAction(requestDropObject),
+      icon: Trash2,
+      shortcut: shortcutDelete,
+      variant: "destructive" as const,
+    });
+    return items;
+  }
+
+  if (node.type === "sequence") {
+    items.push({ label: t("contextMenu.viewSource"), action: () => openObjectSourceDialog(false), icon: Code2 });
+    items.push({ label: "", separator: true });
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    return items;
+  }
+
+  if (node.type === "package" || node.type === "package-body") {
+    items.push({ label: t("contextMenu.viewSource"), action: () => openObjectSourceDialog(false), icon: Code2 });
+    items.push({ label: "", separator: true });
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    return items;
+  }
+
+  // 8.5 Extension
+  if (node.type === "extension") {
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+    return items;
+  }
+
+  // 9. Group Labels (group-columns, group-tables, etc.)
+  if (isGroupLabel(node)) {
+    const hasGroupCreateAction = (node.type === "group-tables" && canCreateTable.value) || (node.type === "group-views" && !!node.connectionId && !!node.database);
+    const canLoadAllObjectGroup = node.type === "group-tables" || node.type === "group-views" || node.type === "group-materialized-views";
+    if (node.type === "group-tables" && canCreateTable.value) {
+      items.push({ label: t("contextMenu.createTable"), action: createTable, icon: Plus });
+      if (canOpenTableImport.value) {
+        items.push({ label: t("contextMenu.importData"), action: openTableImport, icon: Upload });
+      }
+      if (canPasteTreeClipboardToCurrentNode()) {
+        items.push({ label: t("contextMenu.pasteTable"), action: openPasteTableDialog, icon: Clipboard });
+      }
+    }
+    if (node.type === "group-views" && node.connectionId && node.database) {
+      items.push({ label: t("contextMenu.createView"), action: createView, icon: Plus });
+    }
+    if (hasGroupCreateAction) {
+      items.push({ label: "", separator: true });
+    }
+    if (node.type === "group-extensions") {
+      items.push({
+        label: t("contextMenu.manageExtension"),
+        action: () => openInstallExtensionDialog(node),
+        icon: Plus,
+      });
+      items.push({ label: "", separator: true });
+    }
+    if (canLoadAllObjectGroup) {
+      items.push({
+        label: t("contextMenu.expandAll"),
+        action: loadAllObjectGroupChildren,
+        icon: ChevronsDown,
+        disabled: node.isLoading,
+      });
+    }
+    if (node.type !== "group-partitions") {
+      items.push({
+        label: t("contextMenu.refreshChildren"),
+        action: refresh,
+        icon: RefreshCw,
+        shortcut: shortcutRefresh,
+      });
+    }
+    return items;
+  }
+
+  // 10. Universal Copy Name (for all types except connection)
+  if (hasTypeMenu.value) {
+    items.push({ label: "", separator: true });
+    items.push({ label: t("contextMenu.copyName"), action: copyName, icon: Copy, shortcut: shortcutCopyName.value });
+  }
+
+  return items;
+}
+</script>
+
+<template>
+  <div v-if="node.type === 'table-search-control'" class="tree-table-search-control flex h-7 items-center py-0.5 pr-2" :style="tableSearchStyle" @click.stop @dblclick.stop @mousedown.stop @keydown.stop>
+    <div class="relative w-full min-w-0">
+      <Search class="pointer-events-none absolute left-2 top-1/2 h-3 w-3 -translate-y-1/2 text-muted-foreground" />
+      <Input
+        :model-value="tableSearchValue"
+        autocapitalize="off"
+        autocorrect="off"
+        spellcheck="false"
+        class="h-6 w-full rounded border pl-7 pr-6 text-xs shadow-none focus-visible:ring-1"
+        :style="{ backgroundColor: 'var(--tree-table-search-input-bg)', borderColor: 'var(--tree-table-search-border)' }"
+        :placeholder="t(node.label)"
+        :aria-label="t(node.label)"
+        :data-sidebar-table-search-parent-id="tableSearchParentId"
+        @update:model-value="updateTableSearchQuery"
+      />
+      <button v-if="tableSearchValue" type="button" class="absolute right-1.5 top-1/2 flex h-4 w-4 -translate-y-1/2 items-center justify-center rounded text-muted-foreground hover:bg-muted hover:text-foreground" :aria-label="t('sidebar.clearTableSearch')" @click.stop="clearTableSearchQuery">
+        <X class="h-3 w-3" />
+      </button>
+    </div>
+  </div>
+
+  <CustomContextMenu v-else :items="treeItemMenuItems" v-slot="contextMenuSlot">
+    <div @contextmenu="onTreeItemContextMenu($event, contextMenuSlot.onContextMenu)">
+      <LightTooltip :text="displayLabel(node)" :disabled="isTooltipDisabled()" side="right" :side-offset="8" :delay="0" :close-delay="0" :surface="detailTooltip ? 'popover' : 'foreground'">
+        <div
+          ref="rowRef"
+          class="group flex items-center gap-1.5 py-1 px-2 cursor-pointer relative outline-none"
+          style="contain: layout style"
+          :class="[
+            rowWidthClass,
+            {
+              'group/sidebar-row': true,
+              'ring-1 ring-primary/50 bg-primary/5': showDropInside,
+              'opacity-50': isDragging,
+              'tree-item-connection-tint': connectionColor,
+              'hover:bg-accent': node.type !== 'connection',
+              'hover:bg-secondary/60': node.type === 'connection',
+              rounded: !isTreeRowSelected,
+              'tree-item-active': isTreeRowSelected,
+              'tree-item-active--selection-set': usesSelectionSetHighlight && isTreeRowSelected,
+              'tree-item-highlight': highlighted,
+            },
+          ]"
+          :tabindex="isSelected || isMultiSelected ? 0 : -1"
+          :style="rowStyle"
+          @click="onClick"
+          @dblclick="onDoubleClick"
+          @keydown="onKeydown"
+          @mousedown="onRowMouseDown"
+          @mousemove="isDropTarget ? updateTarget($event, node.id, node.type) : undefined"
+          @mouseleave="clearTarget(node.id)"
+        >
+          <div v-if="showDropBefore" class="absolute right-2 top-0 h-0.5 bg-primary rounded-full pointer-events-none" :style="{ left: paddingLeft }" />
+          <div v-if="showDropAfter" class="absolute right-2 bottom-0 h-0.5 bg-primary rounded-full pointer-events-none" :style="{ left: paddingLeft }" />
+          <template v-if="canExpand">
+            <button type="button" class="-m-0.5 flex h-4 w-4 shrink-0 items-center justify-center rounded-sm text-muted-foreground hover:bg-muted hover:text-foreground" @mousedown.stop="onToggleMouseDown" @click.stop="onToggleClick">
+              <Loader2 v-if="node.isLoading" class="w-3.5 h-3.5 animate-spin" />
+              <ChevronDown v-else-if="node.isExpanded" class="w-3.5 h-3.5" />
+              <ChevronRight v-else class="w-3.5 h-3.5" />
+            </button>
+          </template>
+          <span v-else class="w-3.5 h-3.5 shrink-0" />
+          <DatabaseIcon v-if="node.type === 'connection'" :db-type="connectionIconType(node.connectionId)" class="h-3.5 w-3.5 shrink-0" />
+          <Loader2 v-else-if="node.type === 'load-more' && node.isLoading" class="w-3.5 h-3.5 shrink-0 animate-spin text-primary" />
+          <component v-else :is="getIconInfo(node)?.icon || Database" class="w-3.5 h-3.5 shrink-0" :class="nodeIconClass" />
+          <input
+            v-if="isRenamingGroup"
+            ref="renameInputRef"
+            v-model="renameInput"
+            class="min-w-0 flex-1 truncate bg-transparent border border-primary/50 rounded px-1 outline-none"
+            @blur="finishRenameGroup"
+            @keydown.enter.prevent="finishRenameGroup"
+            @keydown.escape.prevent="isRenamingGroup = false"
+            @click.stop
+          />
+          <span v-else ref="labelRef" :class="labelWidthClass">{{ visibleLabel(node) }}</span>
+          <ProductionContextBadge v-if="showProductionBadge" compact />
+          <span
+            v-if="
+              (node.type === 'group-tables' || node.type === 'group-views' || node.type === 'group-materialized-views' || node.type === 'group-procedures' || node.type === 'group-functions' || node.type === 'group-sequences' || node.type === 'group-packages' || node.type === 'group-partitions') &&
+              node.objectCount != null
+            "
+            class="text-muted-foreground text-[10px] shrink-0"
+            >{{ node.objectCount }}</span
+          >
+          <Badge v-if="isNodeDefaultDatabase" variant="secondary" class="h-4 px-1.5 text-[10px]">
+            {{ t("editor.defaultDatabase") }}
+          </Badge>
+          <span v-if="columnComment" class="sidebar-object-comment ml-auto max-w-[20%] shrink-0 truncate text-right" :class="{ 'sidebar-object-comment--windows': useWindowsSidebarCommentFont }">{{ columnComment }}</span>
+          <span v-if="tableComment" class="sidebar-object-comment ml-auto max-w-[20%] shrink-0 truncate text-right" :class="{ 'sidebar-object-comment--windows': useWindowsSidebarCommentFont }">{{ tableComment }}</span>
+          <span v-if="node.type === 'connection' && node.connectionId && connectionStore.connectedIds.has(node.connectionId)" class="w-1.5 h-1.5 rounded-full bg-green-500 shrink-0" />
+          <span v-if="showsDatabaseOpenIndicator" class="w-1.5 h-1.5 rounded-full bg-green-500 shrink-0" />
+          <Badge v-if="isConnectionReadonly" variant="secondary" class="h-4 px-1.5 text-[10px] gap-0.5"><Lock class="w-2.5 h-2.5" />{{ t("connection.readOnlyBadge") }}</Badge>
+          <ConnectionErrorIndicator v-if="node.type === 'connection'" :connection-id="node.connectionId" trigger-class="h-4 w-4" />
+          <Pin v-if="isPinned" class="w-3 h-3 shrink-0 text-primary fill-current" aria-hidden="true" />
+          <button
+            v-if="isConnecting"
+            type="button"
+            class="ml-auto flex h-4 w-4 shrink-0 items-center justify-center rounded text-muted-foreground transition-colors hover:bg-secondary/45 hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring"
+            :aria-label="t('connection.cancelConnecting')"
+            :title="t('connection.cancelConnecting')"
+            @mousedown.stop
+            @click.stop="cancelConnectionAttempt"
+          >
+            <X class="h-3 w-3" />
+          </button>
+          <button
+            v-if="node.type === 'connection'"
+            type="button"
+            class="flex h-4 w-4 shrink-0 items-center justify-center rounded text-muted-foreground/55 opacity-0 transition-colors transition-opacity hover:bg-secondary/45 hover:text-foreground focus-visible:opacity-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring group-hover/sidebar-row:opacity-100"
+            :class="[{ 'opacity-100': isConnectionSelectionChecked || connectionStore.connectionMultiSelectActive }, isConnecting ? '' : 'ml-auto']"
+            :aria-label="isConnectionSelectionChecked ? t('connectionGroup.deselectConnection') : t('connectionGroup.selectConnection')"
+            @mousedown.stop
+            @click="toggleConnectionMultiSelection"
+          >
+            <Check v-if="isConnectionSelectionChecked" class="h-3 w-3 text-primary" />
+            <Square v-else class="h-3 w-3 stroke-[1.7]" />
+          </button>
+        </div>
+        <template v-if="detailTooltip" #content>
+          <div class="w-max min-w-40 max-w-[min(28rem,calc(100vw-24px))] rounded-md border border-border bg-popover p-2 text-popover-foreground shadow-lg">
+            <div class="space-y-1">
+              <div v-for="row in detailTooltip.rows" :key="row.label" class="grid grid-cols-[max-content_minmax(0,1fr)] gap-2 text-xs leading-5">
+                <span class="text-muted-foreground">{{ row.label }}</span>
+                <span v-if="row.multiline" class="max-h-20 overflow-hidden whitespace-pre-wrap break-words text-foreground/90">
+                  {{ row.value }}
+                </span>
+                <span v-else class="truncate font-mono text-foreground/90" :title="row.value">{{ row.value }}</span>
+              </div>
+            </div>
+          </div>
+        </template>
+      </LightTooltip>
+    </div>
+  </CustomContextMenu>
+
+  <VisibleDatabasesDialog v-if="node.type === 'connection' && node.connectionId" v-model:open="showVisibleDatabasesDialog" :connection-id="node.connectionId" :connection-name="node.label" />
+
+  <SchemaFilterDialog v-if="node.type === 'database' && node.connectionId && node.database != null" v-model:open="showVisibleSchemasDialog" :connection-id="node.connectionId" :connection-name="node.label" :database="node.database ?? ''" />
+
+  <SchemaFilterDialog v-else-if="node.type === 'connection' && node.connectionId && canConfigureVisibleSchemas" v-model:open="showVisibleSchemasDialog" :connection-id="node.connectionId" :connection-name="node.label" :database="connectionStore.getConfig(node.connectionId)?.database || ''" />
+
+  <Dialog v-model:open="showDeleteConfirm">
+    <DialogContent class="sm:max-w-[400px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("contextMenu.confirmDeleteTitle") }}</DialogTitle>
+      </DialogHeader>
+      <p class="text-sm text-muted-foreground">
+        {{ connectionDeleteConfirmMessage() }}
+      </p>
+      <DialogFooter>
+        <Button variant="outline" @click="showDeleteConfirm = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button
+          variant="destructive"
+          @click="
+            showDeleteConfirm = false;
+            confirmDelete();
+          "
+          >{{ connectionDeleteMenuLabel() }}</Button
+        >
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showMoveToNewGroupDialog">
+    <DialogContent class="sm:max-w-[360px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("connectionGroup.createGroup") }}</DialogTitle>
+      </DialogHeader>
+      <Input v-model="moveToNewGroupName" :placeholder="t('connectionGroup.groupNamePlaceholder')" @keydown.enter.prevent="confirmMoveToNewGroup" />
+      <DialogFooter>
+        <Button variant="outline" @click="showMoveToNewGroupDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="!moveToNewGroupName.trim()" @click="confirmMoveToNewGroup">{{ t("connectionGroup.createGroup") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showDeleteGroupConfirm">
+    <DialogContent class="sm:max-w-[400px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("connectionGroup.deleteGroupConfirmTitle") }}</DialogTitle>
+      </DialogHeader>
+      <p class="text-sm text-muted-foreground">
+        {{ t("connectionGroup.deleteGroupConfirmMessage", { name: node.label }) }}
+      </p>
+      <DialogFooter>
+        <Button variant="outline" @click="showDeleteGroupConfirm = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button variant="destructive" @click="confirmDeleteGroup">{{ t("connectionGroup.deleteGroup") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showRenameObjectDialog">
+    <DialogContent class="sm:max-w-[420px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("contextMenu.renameObjectTitle") }}</DialogTitle>
+      </DialogHeader>
+      <div class="grid gap-3">
+        <Input v-model="renameObjectName" :placeholder="t('contextMenu.renameObjectNamePlaceholder')" @keydown.enter.prevent="confirmRenameObject" />
+        <pre v-if="renameObjectPreviewSql" class="max-h-32 overflow-auto rounded bg-muted p-3 text-xs whitespace-pre-wrap" v-html="highlight(renameObjectPreviewSql)"></pre>
+        <p v-if="renameObjectError" class="text-sm text-destructive">{{ renameObjectError }}</p>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" @click="showRenameObjectDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="!renameObjectName.trim() || renameObjectName.trim() === node.label" @click="confirmRenameObject">
+          {{ t("contextMenu.renameObject") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showStructurePreviewDialog">
+    <DialogContent class="sm:max-w-[760px]">
+      <DialogHeader>
+        <DialogTitle>{{ structurePreviewTitle || t("contextMenu.exportStructure") }}</DialogTitle>
+      </DialogHeader>
+      <div class="grid gap-3">
+        <div v-if="isLoadingStructurePreview" class="flex items-center gap-2 text-sm text-muted-foreground">
+          <Loader2 class="h-4 w-4 animate-spin" />
+          <span>{{ t("contextMenu.exportStructureLoading") }}</span>
+        </div>
+        <p v-else-if="structurePreviewError" class="text-sm text-destructive">{{ structurePreviewError }}</p>
+        <pre v-else class="max-h-[56vh] min-h-64 overflow-auto rounded bg-muted p-3 text-xs whitespace-pre-wrap" v-html="highlight(structurePreviewSql)"></pre>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" @click="showStructurePreviewDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button variant="outline" :disabled="isLoadingStructurePreview || !structurePreviewSql" @click="copyStructurePreview">
+          <Clipboard class="h-4 w-4" />
+          {{ t("contextMenu.copyStructure") }}
+        </Button>
+        <Button :disabled="isLoadingStructurePreview || !structurePreviewSql" @click="saveStructurePreview">
+          <Upload class="h-4 w-4" />
+          {{ t("contextMenu.saveStructure") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showStructureDocCopyDialog">
+    <DialogContent class="sm:max-w-[760px]">
+      <DialogHeader>
+        <DialogTitle>{{ structureDocCopyTitle || t("contextMenu.copyStructureAs") }}</DialogTitle>
+      </DialogHeader>
+      <div class="grid gap-3">
+        <p class="text-sm text-muted-foreground">{{ t("contextMenu.structureDocCopyFallbackHint") }}</p>
+        <textarea readonly class="max-h-[56vh] min-h-64 resize-y overflow-auto rounded bg-muted p-3 font-mono text-xs whitespace-pre" :value="structureDocCopyText" @focus="selectTextareaContent"></textarea>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" @click="showStructureDocCopyDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="!structureDocCopyText" @click="copyStructureDocText">
+          <Clipboard class="h-4 w-4" />
+          {{ t("contextMenu.copyStructure") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <DangerConfirmDialog v-model:open="showDropTableConfirm" :title="t('contextMenu.confirmDropTableTitle')" :message="t('contextMenu.confirmDropTableMessage', { name: node.label })" :sql="dropTablePreviewSql" :confirm-label="t('contextMenu.dropTable')" @confirm="confirmDropTable">
+    <template v-if="canDropTableCascade" #options>
+      <label class="mb-3 flex items-start gap-2 rounded-md border bg-muted/20 px-3 py-2 text-sm">
+        <input v-model="dropTableCascade" type="checkbox" class="mt-0.5 h-3.5 w-3.5 shrink-0 accent-primary" @change="refreshDropTablePreviewSql()" />
+        <span class="grid gap-0.5">
+          <span class="font-medium text-foreground">{{ t("contextMenu.dropTableCascade") }}</span>
+          <span class="text-xs leading-5 text-muted-foreground">{{ t("contextMenu.dropTableCascadeHint") }}</span>
+        </span>
+      </label>
+    </template>
+  </DangerConfirmDialog>
+
+  <DangerConfirmDialog v-model:open="showEmptyTableConfirm" :title="t('contextMenu.confirmEmptyTableTitle')" :message="t('contextMenu.confirmEmptyTableMessage', { name: node.label })" :sql="emptyTablePreviewSql" :confirm-label="t('contextMenu.emptyTable')" @confirm="confirmEmptyTable" />
+
+  <DangerConfirmDialog v-model:open="showBatchEmptyConfirm" :title="batchEmptyConfirmTitle()" :message="batchEmptyConfirmMessage()" :sql="batchEmptyPreviewSql" :confirm-label="batchEmptyConfirmLabel()" @confirm="confirmBatchEmpty" />
+
+  <DangerConfirmDialog
+    v-model:open="showTruncateTableConfirm"
+    :title="t('contextMenu.confirmTruncateTableTitle')"
+    :message="t('contextMenu.confirmTruncateTableMessage', { name: node.label })"
+    :sql="truncateTablePreviewSql"
+    :confirm-label="t('contextMenu.truncateTable')"
+    @confirm="confirmTruncateTable"
+  >
+    <template v-if="canTruncateTableCascade" #options>
+      <label class="mb-3 flex items-start gap-2 rounded-md border bg-muted/20 px-3 py-2 text-sm">
+        <input v-model="truncateTableCascade" type="checkbox" class="mt-0.5 h-3.5 w-3.5 shrink-0 accent-primary" @change="refreshTruncateTablePreviewSql()" />
+        <span class="grid gap-0.5">
+          <span class="font-medium text-foreground">{{ t("contextMenu.truncateTableCascade") }}</span>
+          <span class="text-xs leading-5 text-muted-foreground">{{ t("contextMenu.truncateTableCascadeHint") }}</span>
+        </span>
+      </label>
+    </template>
+  </DangerConfirmDialog>
+
+  <DangerConfirmDialog v-model:open="showDropObjectConfirm" :title="dropObjectConfirmTitle()" :message="dropObjectConfirmMessage()" :sql="dropObjectPreviewSql" :confirm-label="dropObjectMenuLabel()" @confirm="confirmDropObject" />
+
+  <DangerConfirmDialog v-model:open="showDropTableChildObjectConfirm" :title="dropTableChildObjectConfirmTitle()" :message="dropTableChildObjectConfirmMessage()" :sql="dropTableChildObjectPreviewSql" :confirm-label="dropTableChildObjectMenuLabel()" @confirm="confirmDropTableChildObject" />
+
+  <DangerConfirmDialog v-model:open="showBatchDropConfirm" :title="batchDropConfirmTitle()" :message="batchDropConfirmMessage()" :sql="batchDropPreviewSql" :confirm-label="batchDropMenuLabel()" @confirm="confirmBatchDrop">
+    <template v-if="canBatchDropCascade" #options>
+      <label class="mb-3 flex items-start gap-2 rounded-md border bg-muted/20 px-3 py-2 text-sm">
+        <input v-model="batchDropCascade" type="checkbox" class="mt-0.5 h-3.5 w-3.5 shrink-0 accent-primary" @change="refreshBatchDropPreviewSql()" />
+        <span class="grid gap-0.5">
+          <span class="font-medium text-foreground">{{ t("contextMenu.dropTableCascade") }}</span>
+          <span class="text-xs leading-5 text-muted-foreground">{{ t("contextMenu.dropTableCascadeHint") }}</span>
+        </span>
+      </label>
+    </template>
+  </DangerConfirmDialog>
+
+  <DangerConfirmDialog v-model:open="showBatchTruncateConfirm" :title="batchTruncateConfirmTitle()" :message="batchTruncateConfirmMessage()" :sql="batchTruncatePreviewSql" :confirm-label="batchTruncateMenuLabel()" @confirm="confirmBatchTruncate">
+    <template v-if="canBatchTruncateCascade" #options>
+      <label class="mb-3 flex items-start gap-2 rounded-md border bg-muted/20 px-3 py-2 text-sm">
+        <input v-model="batchTruncateCascade" type="checkbox" class="mt-0.5 h-3.5 w-3.5 shrink-0 accent-primary" @change="refreshBatchTruncatePreviewSql()" />
+        <span class="grid gap-0.5">
+          <span class="font-medium text-foreground">{{ t("contextMenu.truncateTableCascade") }}</span>
+          <span class="text-xs leading-5 text-muted-foreground">{{ t("contextMenu.truncateTableCascadeHint") }}</span>
+        </span>
+      </label>
+    </template>
+  </DangerConfirmDialog>
+
+  <ProcedureExecutionDialog
+    v-if="node.type === 'procedure' && node.connectionId && node.database"
+    v-model:open="showProcedureExecutionConfirm"
+    :connection-id="node.connectionId"
+    :database="node.database"
+    :database-type="currentDatabaseType()"
+    :schema="node.schema"
+    :routine-name="node.label"
+    @open-sql="openProcedureExecutionSql"
+    @execute="executeProcedureSql"
+  />
+
+  <Dialog v-model:open="showDuplicateDialog">
+    <DialogContent class="sm:max-w-[400px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("contextMenu.duplicateNameTitle") }}</DialogTitle>
+      </DialogHeader>
+      <Input v-model="duplicateTableName" :placeholder="t('contextMenu.duplicateNamePlaceholder')" @keydown.enter.prevent="confirmDuplicateStructure" />
+      <DialogFooter>
+        <Button variant="outline" @click="showDuplicateDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="!duplicateTableName.trim()" @click="confirmDuplicateStructure">{{ t("dangerDialog.confirm") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showPasteDialog">
+    <DialogContent class="sm:max-w-[500px]">
+      <DialogHeader>
+        <DialogTitle>{{ pasteTableEntries.length > 1 ? t("contextMenu.batchPasteTitle") : t("contextMenu.pasteTableConfirmTitle") }}</DialogTitle>
+      </DialogHeader>
+      <div class="space-y-4">
+        <div class="flex gap-2">
+          <label class="flex items-center gap-1.5 text-sm cursor-pointer" :class="{ 'opacity-50 cursor-not-allowed': !pasteTableDataCopySupported }">
+            <input v-model="pasteTableMode" type="radio" value="structure-and-data" class="accent-primary" :disabled="!pasteTableDataCopySupported" />
+            {{ t("contextMenu.pasteOptionStructureAndData") }}
+          </label>
+          <label class="flex items-center gap-1.5 text-sm cursor-pointer">
+            <input v-model="pasteTableMode" type="radio" value="structure-only" class="accent-primary" />
+            {{ t("contextMenu.pasteOptionStructureOnly") }}
+          </label>
+          <label class="flex items-center gap-1.5 text-sm cursor-pointer" :class="{ 'opacity-50 cursor-not-allowed': !pasteTableDataCopySupported }">
+            <input v-model="pasteTableMode" type="radio" value="data-only" class="accent-primary" :disabled="!pasteTableDataCopySupported" />
+            {{ t("contextMenu.pasteOptionDataOnly") }}
+          </label>
+        </div>
+        <div class="space-y-2 max-h-64 overflow-y-auto">
+          <div v-for="(entry, idx) in pasteTableEntries" :key="idx" class="flex items-center gap-2">
+            <span class="text-sm text-muted-foreground truncate min-w-0 flex-shrink basis-1/3" :title="entry.sourceName">{{ entry.sourceName }}</span>
+            <span class="text-xs text-muted-foreground flex-shrink-0">&rarr;</span>
+            <Input v-model="entry.targetName" class="flex-1 h-8 text-sm" :placeholder="t('contextMenu.duplicateNamePlaceholder')" />
+          </div>
+        </div>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" @click="showPasteDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="pasteTableEntries.every((e) => !e.targetName.trim())" @click="confirmPasteTable">{{ t("dangerDialog.confirm") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showCreateDatabaseDialog">
+    <DialogContent class="sm:max-w-[400px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("contextMenu.createDatabase") }}</DialogTitle>
+      </DialogHeader>
+      <Input v-model="createDatabaseName" :placeholder="t('contextMenu.createDatabaseNamePlaceholder')" @keydown.enter.prevent="confirmCreateDatabase" />
+      <div v-if="canSetCreateDatabaseCharset" class="grid gap-2">
+        <div class="grid gap-1.5">
+          <label class="text-xs font-medium text-muted-foreground">{{ t("contextMenu.createDatabaseCharset") }}</label>
+          <SearchableSelect
+            :model-value="createDatabaseCharset"
+            :options="createDatabaseCharsetOptions"
+            :placeholder="t('contextMenu.createDatabaseCharsetPlaceholder')"
+            :search-placeholder="t('contextMenu.createDatabaseCharsetSearchPlaceholder')"
+            :empty-text="t('contextMenu.createDatabaseCharsetEmpty')"
+            :loading-text="t('contextMenu.createDatabaseCharsetLoading')"
+            :loading="createDatabaseCharsetLoading"
+            :normalize-custom="normalizeCreateDatabaseCharset"
+            allow-custom
+            trigger-variant="outline"
+            trigger-class="h-9 w-full max-w-none justify-between border bg-background px-3 text-sm shadow-xs hover:bg-accent"
+            content-class="w-[var(--reka-popover-trigger-width)]"
+            @update:model-value="updateCreateDatabaseCharset"
+          >
+            <template #custom-option-label="{ value }">
+              <span class="truncate">{{ t("contextMenu.createDatabaseCharsetCustomOption", { value }) }}</span>
+            </template>
+          </SearchableSelect>
+        </div>
+        <div class="grid gap-1.5">
+          <label class="text-xs font-medium text-muted-foreground">{{ t("contextMenu.createDatabaseCollation") }}</label>
+          <SearchableSelect
+            v-model="createDatabaseCollation"
+            :options="createDatabaseCollationOptionsForCharset(createDatabaseCharset, createDatabaseCollationsByCharset)"
+            :placeholder="t('contextMenu.createDatabaseCollationPlaceholder')"
+            :search-placeholder="t('contextMenu.createDatabaseCollationSearchPlaceholder')"
+            :empty-text="t('contextMenu.createDatabaseCollationEmpty')"
+            :loading-text="t('contextMenu.createDatabaseCollationLoading')"
+            :loading="createDatabaseCharsetLoading"
+            :normalize-custom="normalizeCreateDatabaseCharset"
+            allow-custom
+            trigger-variant="outline"
+            trigger-class="h-9 w-full max-w-none justify-between border bg-background px-3 text-sm shadow-xs hover:bg-accent"
+            content-class="w-[var(--reka-popover-trigger-width)]"
+          >
+            <template #custom-option-label="{ value }">
+              <span class="truncate">{{ t("contextMenu.createDatabaseCollationCustomOption", { value }) }}</span>
+            </template>
+          </SearchableSelect>
+        </div>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" @click="showCreateDatabaseDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="!createDatabaseName.trim()" @click="confirmCreateDatabase">{{ t("dangerDialog.confirm") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showEditDatabasePropertiesDialog">
+    <DialogContent class="sm:max-w-[460px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("contextMenu.editDatabasePropertiesTitle", { name: node.label }) }}</DialogTitle>
+      </DialogHeader>
+      <div class="grid gap-3">
+        <div v-if="canEditDatabaseCharsetCollation" class="grid gap-3">
+          <div class="grid gap-1.5">
+            <label class="text-xs font-medium text-muted-foreground">{{ t("contextMenu.createDatabaseCharset") }}</label>
+            <SearchableSelect
+              :model-value="editDatabaseCharset"
+              :options="createDatabaseCharsetOptions"
+              :placeholder="t('contextMenu.createDatabaseCharsetPlaceholder')"
+              :search-placeholder="t('contextMenu.createDatabaseCharsetSearchPlaceholder')"
+              :empty-text="t('contextMenu.createDatabaseCharsetEmpty')"
+              :loading-text="t('contextMenu.createDatabaseCharsetLoading')"
+              :loading="createDatabaseCharsetLoading"
+              :normalize-custom="normalizeCreateDatabaseCharset"
+              allow-custom
+              trigger-variant="outline"
+              trigger-class="h-9 w-full max-w-none justify-between border bg-background px-3 text-sm shadow-xs hover:bg-accent"
+              content-class="w-[var(--reka-popover-trigger-width)]"
+              @update:model-value="updateEditDatabaseCharset"
+            >
+              <template #custom-option-label="{ value }">
+                <span class="truncate">{{ t("contextMenu.createDatabaseCharsetCustomOption", { value }) }}</span>
+              </template>
+            </SearchableSelect>
+          </div>
+          <div class="grid gap-1.5">
+            <label class="text-xs font-medium text-muted-foreground">{{ t("contextMenu.createDatabaseCollation") }}</label>
+            <SearchableSelect
+              v-model="editDatabaseCollation"
+              :options="createDatabaseCollationOptionsForCharset(editDatabaseCharset, createDatabaseCollationsByCharset)"
+              :placeholder="t('contextMenu.createDatabaseCollationPlaceholder')"
+              :search-placeholder="t('contextMenu.createDatabaseCollationSearchPlaceholder')"
+              :empty-text="t('contextMenu.createDatabaseCollationEmpty')"
+              :loading-text="t('contextMenu.createDatabaseCollationLoading')"
+              :loading="createDatabaseCharsetLoading"
+              :normalize-custom="normalizeCreateDatabaseCharset"
+              allow-custom
+              trigger-variant="outline"
+              trigger-class="h-9 w-full max-w-none justify-between border bg-background px-3 text-sm shadow-xs hover:bg-accent"
+              content-class="w-[var(--reka-popover-trigger-width)]"
+            >
+              <template #custom-option-label="{ value }">
+                <span class="truncate">{{ t("contextMenu.createDatabaseCollationCustomOption", { value }) }}</span>
+              </template>
+            </SearchableSelect>
+          </div>
+        </div>
+        <div v-if="canEditDatabaseComment" class="grid gap-1.5">
+          <label class="text-xs font-medium text-muted-foreground">{{ t("contextMenu.editDatabaseComment") }}</label>
+          <textarea
+            v-model="editDatabaseCommentText"
+            class="min-h-28 w-full resize-y rounded-md border border-input bg-background px-3 py-2 text-sm outline-none transition-colors focus:border-ring focus:ring-1 focus:ring-ring/40"
+            :placeholder="t('contextMenu.editDatabaseCommentPlaceholder')"
+            :disabled="editDatabasePropertiesLoading"
+            @keydown.meta.enter.prevent="confirmEditDatabaseProperties"
+            @keydown.ctrl.enter.prevent="confirmEditDatabaseProperties"
+          ></textarea>
+        </div>
+        <pre v-if="editDatabasePropertiesPreviewSql" class="max-h-32 overflow-auto rounded bg-muted p-3 text-xs whitespace-pre-wrap" v-html="highlight(editDatabasePropertiesPreviewSql)"></pre>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" :disabled="editDatabasePropertiesLoading" @click="showEditDatabasePropertiesDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="editDatabasePropertiesLoading" @click="confirmEditDatabaseProperties">
+          {{ editDatabasePropertiesLoading ? t("contextMenu.editDatabasePropertiesSaving") : t("dangerDialog.confirm") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showCreateNacosNamespaceDialog">
+    <DialogContent class="sm:max-w-[420px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("nacos.createNamespace") }}</DialogTitle>
+      </DialogHeader>
+      <div class="grid gap-3">
+        <div class="grid gap-1.5">
+          <label class="text-xs font-medium text-muted-foreground">{{ t("nacos.namespaceId") }}</label>
+          <Input v-model="createNacosNamespaceId" :placeholder="t('nacos.namespaceIdPlaceholder')" @keydown.enter.prevent="confirmCreateNacosNamespace" />
+        </div>
+        <div class="grid gap-1.5">
+          <label class="text-xs font-medium text-muted-foreground">{{ t("nacos.namespaceName") }}</label>
+          <Input v-model="createNacosNamespaceName" :placeholder="t('nacos.namespaceNamePlaceholder')" @keydown.enter.prevent="confirmCreateNacosNamespace" />
+        </div>
+        <div class="grid gap-1.5">
+          <label class="text-xs font-medium text-muted-foreground">{{ t("nacos.namespaceDesc") }}</label>
+          <Input v-model="createNacosNamespaceDesc" :placeholder="t('nacos.namespaceDescPlaceholder')" @keydown.enter.prevent="confirmCreateNacosNamespace" />
+        </div>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" :disabled="createNacosNamespaceLoading" @click="showCreateNacosNamespaceDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="!createNacosNamespaceName.trim() || createNacosNamespaceLoading" @click="confirmCreateNacosNamespace">
+          {{ createNacosNamespaceLoading ? t("nacos.creatingNamespace") : t("dangerDialog.confirm") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showEditNacosNamespaceDialog">
+    <DialogContent class="sm:max-w-[420px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("nacos.editNamespace") }}</DialogTitle>
+      </DialogHeader>
+      <div class="grid gap-3">
+        <div class="grid gap-1.5">
+          <label class="text-xs font-medium text-muted-foreground">{{ t("nacos.namespaceName") }}</label>
+          <Input v-model="editNacosNamespaceName" :placeholder="t('nacos.namespaceNamePlaceholder')" @keydown.enter.prevent="confirmEditNacosNamespace" />
+        </div>
+        <div class="grid gap-1.5">
+          <label class="text-xs font-medium text-muted-foreground">{{ t("nacos.namespaceDesc") }}</label>
+          <Input v-model="editNacosNamespaceDesc" :placeholder="t('nacos.namespaceDescPlaceholder')" @keydown.enter.prevent="confirmEditNacosNamespace" />
+        </div>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" :disabled="editNacosNamespaceLoading" @click="showEditNacosNamespaceDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="!editNacosNamespaceName.trim() || editNacosNamespaceLoading" @click="confirmEditNacosNamespace">
+          {{ editNacosNamespaceLoading ? t("nacos.updatingNamespace") : t("dangerDialog.confirm") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <DangerConfirmDialog
+    v-model:open="showDropDatabaseConfirm"
+    :title="t('contextMenu.confirmDropDatabaseTitle')"
+    :message="t('contextMenu.confirmDropDatabaseMessage', { name: node.label })"
+    :sql="dropDatabasePreviewSql"
+    :confirm-label="t('contextMenu.dropDatabase')"
+    :loading="dropDatabaseLoading"
+    :close-on-confirm="false"
+    @confirm="confirmDropDatabase"
+  />
+
+  <DangerConfirmDialog
+    v-model:open="showDropMongoCollectionConfirm"
+    :title="t('contextMenu.confirmDropCollectionTitle')"
+    :message="t('contextMenu.confirmDropCollectionMessage', { name: node.label })"
+    :confirm-label="t('contextMenu.dropCollection')"
+    :loading="dropMongoCollectionLoading"
+    :close-on-confirm="false"
+    @confirm="confirmDropMongoCollection"
+  />
+
+  <DangerConfirmDialog
+    v-model:open="showDropMongoIndexConfirm"
+    :title="t('contextMenu.confirmDropIndexTitle')"
+    :message="t('contextMenu.confirmDropMongoIndexMessage', { name: mongoIndexNameForNode(node), collection: node.tableName || '' })"
+    :details="mongoIndexDropPreview(node, mongoIndexNameForNode(node))"
+    :confirm-label="t('contextMenu.dropIndex')"
+    :loading="dropMongoIndexLoading"
+    :close-on-confirm="false"
+    @confirm="confirmDropMongoIndex"
+  />
+
+  <DangerConfirmDialog
+    v-model:open="showDropAllMongoIndexesConfirm"
+    :title="t('contextMenu.dropAllIndexes')"
+    :message="t('contextMenu.confirmDropMongoAllIndexesMessage', { name: node.label })"
+    :details-text="t('contextMenu.confirmDropMongoAllIndexesDetails')"
+    :sql="mongoDropAllIndexesPreview(node)"
+    :confirm-label="t('contextMenu.dropAllIndexes')"
+    :loading="dropAllMongoIndexesLoading"
+    :close-on-confirm="false"
+    @confirm="confirmDropAllMongoIndexes"
+  />
+
+  <DangerConfirmDialog v-model:open="showFlushRedisDbConfirm" :title="t('redis.flushDb')" :message="t('redis.flushDbMessage')" :details="t('redis.flushDbDetails', { db: node.database })" :confirm-label="t('redis.flushDbConfirm')" @confirm="confirmFlushRedisDb" />
+
+  <Dialog v-model:open="showCreateSchemaDialog">
+    <DialogContent class="sm:max-w-[400px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("contextMenu.createSchema") }}</DialogTitle>
+      </DialogHeader>
+      <Input v-model="createSchemaName" :placeholder="t('contextMenu.createSchemaNamePlaceholder')" @keydown.enter.prevent="confirmCreateSchema" />
+      <DialogFooter>
+        <Button variant="outline" @click="showCreateSchemaDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="!createSchemaName.trim()" @click="confirmCreateSchema">{{ t("dangerDialog.confirm") }}</Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="showEditSchemaCommentDialog">
+    <DialogContent class="sm:max-w-[520px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("contextMenu.editSchemaCommentTitle", { name: node.label }) }}</DialogTitle>
+      </DialogHeader>
+      <div class="grid gap-3">
+        <textarea
+          v-model="schemaCommentText"
+          class="min-h-28 w-full resize-y rounded-md border border-input bg-background px-3 py-2 text-sm outline-none transition-colors focus:border-ring focus:ring-1 focus:ring-ring/40"
+          :placeholder="t('contextMenu.schemaCommentPlaceholder')"
+          :disabled="schemaCommentLoading"
+          @keydown.meta.enter.prevent="confirmEditSchemaComment"
+          @keydown.ctrl.enter.prevent="confirmEditSchemaComment"
+        ></textarea>
+        <pre v-if="schemaCommentPreviewSql" class="max-h-32 overflow-auto rounded bg-muted p-3 text-xs whitespace-pre-wrap" v-html="highlight(schemaCommentPreviewSql)"></pre>
+      </div>
+      <DialogFooter>
+        <Button variant="outline" :disabled="schemaCommentLoading" @click="showEditSchemaCommentDialog = false">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="schemaCommentLoading" @click="confirmEditSchemaComment">
+          {{ schemaCommentLoading ? t("contextMenu.schemaCommentSaving") : t("dangerDialog.confirm") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <DangerConfirmDialog v-model:open="showDropSchemaConfirm" :title="t('contextMenu.confirmDropSchemaTitle')" :message="t('contextMenu.confirmDropSchemaMessage', { name: node.label })" :sql="dropSchemaPreviewSql" :confirm-label="t('contextMenu.dropSchema')" @confirm="confirmDropSchema" />
+
+  <DdlViewDialog
+    v-if="ddlTarget"
+    :connection-id="ddlTarget.connectionId!"
+    :database="ddlTarget.database!"
+    :schema="ddlTarget.schema"
+    :table-name="ddlTarget.label"
+    :object-type="tableDdlObjectTypeForNode(ddlTarget.type)"
+    :dialect="ddlDialect"
+    :format-dialect="ddlFormatDialect"
+    v-model:open="showDdlDialog"
+  />
+
+  <ObjectSourceDialog
+    v-if="objectSourceTarget && objectSourceType"
+    v-model:open="showObjectSourceDialog"
+    :connection-id="objectSourceTarget.node.connectionId!"
+    :database="objectSourceTarget.node.database!"
+    :schema="objectSourceTarget.node.schema"
+    :name="objectSourceTarget.node.objectName || objectSourceTarget.node.label"
+    :signature="objectSourceTarget.node.signature"
+    :object-type="objectSourceType"
+    :database-type="objectSourceDatabaseType"
+    :dialect="objectSourceDialect"
+    :format-dialect="objectSourceFormatDialect"
+    :initial-editing="objectSourceTarget.initialEditing"
+    @saved="refresh"
+  />
+
+  <InstallExtensionDialog ref="installExtensionDialogRef" :node="node" @close="refresh" />
+</template>
+
+<style>
+.sidebar-object-comment {
+  color: var(--muted-foreground);
+  font-size: 10px;
+  line-height: 1rem;
+  opacity: 0.6;
+  /* Sidebar rows repaint on hover; avoid heavier font shaping and fallback here. */
+  text-rendering: auto;
+}
+
+.sidebar-object-comment--windows {
+  font-family: "Microsoft YaHei UI", "Microsoft YaHei", "Segoe UI", system-ui, sans-serif;
+  font-size: 12px;
+  font-weight: 500;
+  opacity: 1;
+}
+
+.tree-item-connection-tint {
+  isolation: isolate;
+  background-color: transparent !important;
+}
+
+.tree-item-connection-tint::before {
+  content: "";
+  position: absolute;
+  inset: 0 -9999px;
+  z-index: 0;
+  background-color: var(--tree-connection-row-bg);
+  border-radius: inherit;
+  pointer-events: none;
+}
+
+.tree-item-connection-tint > * {
+  position: relative;
+  z-index: 1;
+}
+
+.tree-item-connection-tint:hover,
+.tree-item-connection-tint.tree-item-active,
+.tree-item-connection-tint.tree-item-active:focus {
+  background-color: transparent !important;
+}
+
+.tree-item-connection-tint:hover::before {
+  background-color: var(--tree-connection-row-hover-bg, var(--tree-connection-row-bg));
+}
+
+.tree-item-connection-tint.tree-item-active::before {
+  background-color: var(--tree-connection-active-bg, var(--tree-connection-row-bg));
+}
+
+.tree-item-connection-tint.tree-item-active:focus::before {
+  background-color: var(--tree-connection-active-focus-bg, var(--tree-connection-active-bg));
+}
+
+.tree-item-connection-tint.tree-item-active--selection-set:focus::before {
+  background-color: var(--tree-connection-active-bg, var(--tree-connection-row-bg));
+}
+
+.tree-table-search-control {
+  position: relative;
+  isolation: isolate;
+  background-color: transparent;
+}
+
+.tree-table-search-control::before {
+  content: "";
+  position: absolute;
+  inset: 0 -9999px;
+  z-index: 0;
+  background-color: var(--tree-table-search-row-bg);
+  pointer-events: none;
+}
+
+.tree-table-search-control > * {
+  position: relative;
+  z-index: 1;
+}
+
+/* Unfocused: subtle gray */
+.tree-item-active {
+  background-color: var(--tree-connection-active-bg, rgb(235 235 235)) !important;
+}
+:root.dark .tree-item-active {
+  background-color: var(--tree-connection-active-bg, rgb(36 36 36)) !important;
+}
+
+/* Focused: soft blue */
+.tree-item-active:focus {
+  background-color: var(--tree-connection-active-focus-bg, rgb(211 227 245)) !important;
+}
+:root.dark .tree-item-active:focus {
+  background-color: var(--tree-connection-active-focus-bg, rgb(33 60 89)) !important;
+}
+
+/* Multi-selection treats every selected row as equal; keep focus neutral. */
+.tree-item-active--selection-set:focus {
+  background-color: var(--tree-connection-active-bg, rgb(235 235 235)) !important;
+  box-shadow: inset 0 0 0 1px hsl(var(--foreground) / 0.14);
+}
+:root.dark .tree-item-active--selection-set:focus {
+  background-color: var(--tree-connection-active-bg, rgb(36 36 36)) !important;
+  box-shadow: inset 0 0 0 1px hsl(var(--foreground) / 0.18);
+}
+
+/* Locate highlight: instant amber, then fade on removal */
+.tree-item-highlight {
+  background-color: rgb(253 225 167) !important;
+  background-color: oklch(0.92 0.08 85) !important;
+  transition: background-color 0.28s ease-out;
+}
+
+:root.dark .tree-item-highlight {
+  background-color: rgb(110 67 0) !important;
+  background-color: oklch(0.42 0.12 80) !important;
+  transition: background-color 0.28s ease-out;
+}
+
+.tree-item-connection-tint.tree-item-highlight::before {
+  background-color: rgb(253 225 167) !important;
+  background-color: oklch(0.92 0.08 85) !important;
+}
+
+:root.dark .tree-item-connection-tint.tree-item-highlight::before {
+  background-color: rgb(110 67 0) !important;
+  background-color: oklch(0.42 0.12 80) !important;
+}
+</style>
diff --git a/apps/desktop/src/components/sidebar/VisibleDatabasesDialog.vue b/apps/desktop/src/components/sidebar/VisibleDatabasesDialog.vue
new file mode 100644
index 0000000..d90bf4d
--- /dev/null
+++ b/apps/desktop/src/components/sidebar/VisibleDatabasesDialog.vue
@@ -0,0 +1,230 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { CheckSquare, Loader2, Search, Square } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { canSaveVisibleDatabaseSelection, connectionUsesVisibleSchemaFilter, filterDatabaseNamesForVisiblePicker, isSystemDatabaseName, normalizeVisibleDatabaseSelection } from "@/lib/database/visibleDatabases";
+import * as api from "@/lib/backend/api";
+
+const props = defineProps<{
+  open: boolean;
+  connectionId: string;
+  connectionName: string;
+}>();
+
+const emit = defineEmits<{
+  "update:open": [value: boolean];
+}>();
+
+const { t } = useI18n();
+const connectionStore = useConnectionStore();
+
+type FilterMode = "database" | "schema";
+
+const objectNames = ref<string[]>([]);
+const selectedNames = ref<Set<string>>(new Set());
+const searchText = ref("");
+const showSystemDatabases = ref(false);
+const isLoading = ref(false);
+const errorMessage = ref("");
+
+const connection = computed(() => connectionStore.getConfig(props.connectionId));
+const filterMode = computed<FilterMode>(() => (connectionUsesVisibleSchemaFilter(connection.value) ? "schema" : "database"));
+const databaseKey = computed(() => connection.value?.database || "");
+const isSchemaFilterMode = computed(() => filterMode.value === "schema");
+const titleKey = computed(() => (isSchemaFilterMode.value ? "visibleSchemas.title" : "visibleDatabases.title"));
+const descriptionKey = computed(() => (isSchemaFilterMode.value ? "visibleSchemas.description" : "visibleDatabases.description"));
+const searchPlaceholderKey = computed(() => (isSchemaFilterMode.value ? "visibleSchemas.searchPlaceholder" : "visibleDatabases.searchPlaceholder"));
+const emptySelectionKey = computed(() => (isSchemaFilterMode.value ? "visibleSchemas.emptySelection" : "visibleDatabases.emptySelection"));
+const loadFailedKey = computed(() => (isSchemaFilterMode.value ? "visibleSchemas.loadFailed" : "visibleDatabases.loadFailed"));
+const listedObjectNames = computed(() => {
+  if (isSchemaFilterMode.value) return objectNames.value;
+  if (showSystemDatabases.value) return objectNames.value;
+  return filterDatabaseNamesForVisiblePicker(objectNames.value, connection.value);
+});
+const filteredObjectNames = computed(() => {
+  const query = searchText.value.trim().toLowerCase();
+  if (!query) return listedObjectNames.value;
+  return listedObjectNames.value.filter((name) => name.toLowerCase().includes(query));
+});
+const selectedCount = computed(() => selectedNames.value.size);
+const totalCount = computed(() => listedObjectNames.value.length);
+const canSaveSelection = computed(() => canSaveVisibleDatabaseSelection([...selectedNames.value]));
+const hasSystemDatabases = computed(() => !isSchemaFilterMode.value && objectNames.value.some((database) => isSystemDatabaseName(connection.value?.db_type, database)));
+const showAllDisabled = computed(() => {
+  if (isSchemaFilterMode.value) {
+    return !connection.value?.visible_schemas?.[databaseKey.value];
+  }
+  return !Array.isArray(connection.value?.visible_databases);
+});
+
+watch(
+  () => props.open,
+  (open) => {
+    if (!open) return;
+    loadDatabases().catch(() => {});
+  },
+);
+
+watch(showSystemDatabases, (show) => {
+  if (show) return;
+  selectedNames.value = new Set([...selectedNames.value].filter((database) => !isSystemDatabaseName(connection.value?.db_type, database)));
+});
+
+async function loadDatabases() {
+  isLoading.value = true;
+  errorMessage.value = "";
+  searchText.value = "";
+  try {
+    const names = await loadObjectNames();
+    objectNames.value = names;
+    const configured = isSchemaFilterMode.value ? connection.value?.visible_schemas?.[databaseKey.value] : connection.value?.visible_databases;
+    const initialSelection = Array.isArray(configured) ? normalizeVisibleDatabaseSelection(configured, names) : listedObjectNames.value;
+    selectedNames.value = new Set(initialSelection);
+    showSystemDatabases.value = !isSchemaFilterMode.value && initialSelection.some((database) => isSystemDatabaseName(connection.value?.db_type, database));
+  } catch (e: any) {
+    objectNames.value = [];
+    selectedNames.value = new Set();
+    showSystemDatabases.value = false;
+    errorMessage.value = String(e?.message || e);
+  } finally {
+    isLoading.value = false;
+  }
+}
+
+async function loadObjectNames(): Promise<string[]> {
+  const config = connection.value;
+  if (isSchemaFilterMode.value) {
+    await connectionStore.ensureConnected(props.connectionId);
+    return api.listSchemas(props.connectionId, config?.database || "");
+  }
+  await connectionStore.ensureConnected(props.connectionId);
+  if (config?.db_type === "redis") {
+    return (await api.redisListDatabases(props.connectionId)).map((database) => String(database.db));
+  }
+  if (config?.db_type === "mongodb") {
+    return api.mongoListDatabases(props.connectionId);
+  }
+  return (await api.listDatabases(props.connectionId)).map((database) => database.name);
+}
+
+function toggleObject(name: string) {
+  const next = new Set(selectedNames.value);
+  if (next.has(name)) next.delete(name);
+  else next.add(name);
+  selectedNames.value = next;
+}
+
+const isSearching = computed(() => searchText.value.trim().length > 0);
+
+function selectAll() {
+  selectedNames.value = new Set(listedObjectNames.value);
+}
+
+function selectFiltered() {
+  selectedNames.value = new Set(filteredObjectNames.value);
+}
+
+function clearSelection() {
+  selectedNames.value = new Set();
+}
+
+async function showAllDatabases() {
+  if (isSchemaFilterMode.value) {
+    await connectionStore.clearVisibleSchemas(props.connectionId, databaseKey.value);
+  } else {
+    await connectionStore.clearVisibleDatabases(props.connectionId);
+  }
+  emit("update:open", false);
+}
+
+async function saveSelection() {
+  if (!canSaveSelection.value) return;
+  if (isSchemaFilterMode.value) {
+    await connectionStore.setVisibleSchemas(props.connectionId, databaseKey.value, normalizeVisibleDatabaseSelection([...selectedNames.value], objectNames.value));
+  } else {
+    await connectionStore.setVisibleDatabases(props.connectionId, [...selectedNames.value]);
+  }
+  emit("update:open", false);
+}
+</script>
+
+<template>
+  <Dialog :open="open" @update:open="(value: boolean) => emit('update:open', value)">
+    <DialogContent class="sm:max-w-[460px]">
+      <DialogHeader>
+        <DialogTitle>{{ t(titleKey) }}</DialogTitle>
+        <p class="text-sm text-muted-foreground">
+          {{ t(descriptionKey, { connection: connectionName }) }}
+        </p>
+      </DialogHeader>
+
+      <div class="flex items-center gap-2 rounded-md border bg-background px-2">
+        <Search class="h-4 w-4 shrink-0 text-muted-foreground" />
+        <Input v-model="searchText" :placeholder="t(searchPlaceholderKey)" class="h-8 border-0 px-0 shadow-none focus-visible:ring-0" :disabled="isLoading || !!errorMessage" />
+      </div>
+
+      <div class="flex items-center justify-between text-xs text-muted-foreground">
+        <span>{{ t("visibleDatabases.selectedCount", { selected: selectedCount, total: totalCount }) }}</span>
+        <div class="flex items-center gap-2">
+          <button class="hover:text-foreground disabled:opacity-50" :disabled="isLoading" @click="selectAll">
+            {{ t("visibleDatabases.selectAll") }}
+          </button>
+          <button v-if="isSearching" class="hover:text-foreground disabled:opacity-50" :disabled="isLoading" @click="selectFiltered">
+            {{ t("visibleDatabases.selectFiltered") }}
+          </button>
+          <button class="hover:text-foreground disabled:opacity-50" :disabled="isLoading" @click="clearSelection">
+            {{ t("visibleDatabases.clear") }}
+          </button>
+          <button class="hover:text-foreground disabled:opacity-50" :disabled="isLoading || showAllDisabled" @click="showAllDatabases">
+            {{ t("visibleDatabases.showAll") }}
+          </button>
+        </div>
+      </div>
+      <p v-if="!isLoading && !errorMessage && !canSaveSelection" class="text-xs text-destructive">
+        {{ t(emptySelectionKey) }}
+      </p>
+
+      <label v-if="hasSystemDatabases" class="flex h-8 items-center gap-2 rounded-md px-1 text-xs text-muted-foreground">
+        <input v-model="showSystemDatabases" type="checkbox" class="h-3.5 w-3.5 accent-primary" :disabled="isLoading || !!errorMessage" />
+        <span>{{ t("visibleDatabases.showSystemDatabases") }}</span>
+      </label>
+
+      <div class="h-72 overflow-y-auto rounded-md border bg-background/50 p-1">
+        <div v-if="isLoading" class="flex h-full items-center justify-center gap-2 text-sm text-muted-foreground">
+          <Loader2 class="h-4 w-4 animate-spin" />
+          {{ t("common.loading") }}
+        </div>
+        <div v-else-if="errorMessage" class="p-3 text-sm text-destructive">
+          {{ t(loadFailedKey, { message: errorMessage }) }}
+        </div>
+        <div v-else-if="!filteredObjectNames.length" class="p-3 text-sm text-muted-foreground">
+          {{ t("grid.noSearchResults") }}
+        </div>
+        <template v-else>
+          <button
+            v-for="name in filteredObjectNames"
+            :key="name"
+            type="button"
+            class="flex h-8 w-full min-w-0 items-center gap-2 rounded-sm px-2 text-left text-sm hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground focus-visible:outline-none"
+            @click="toggleObject(name)"
+          >
+            <CheckSquare v-if="selectedNames.has(name)" class="h-4 w-4 shrink-0 text-primary" />
+            <Square v-else class="h-4 w-4 shrink-0 text-muted-foreground" />
+            <span class="truncate">{{ name }}</span>
+          </button>
+        </template>
+      </div>
+
+      <DialogFooter>
+        <Button variant="outline" @click="emit('update:open', false)">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="isLoading || !!errorMessage || !canSaveSelection" @click="saveSelection">
+          {{ t("visibleDatabases.save") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/sidebar/VisibleSchemasDialog.vue b/apps/desktop/src/components/sidebar/VisibleSchemasDialog.vue
new file mode 100644
index 0000000..367ee37
--- /dev/null
+++ b/apps/desktop/src/components/sidebar/VisibleSchemasDialog.vue
@@ -0,0 +1,235 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { CheckSquare, Loader2, Search, Square } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { normalizeVisibleSchemaSelection } from "@/lib/database/visibleDatabases";
+import * as api from "@/lib/backend/api";
+
+const props = defineProps<{
+  open: boolean;
+  connectionId: string;
+  connectionName: string;
+  database: string;
+  /** Draft mode: parent provides schemas/loading/error externally. Component emits events instead of calling store. */
+  draftMode?: boolean;
+  draftSchemaNames?: string[];
+  draftInitialSelection?: string[];
+  draftLoading?: boolean;
+  draftError?: string;
+}>();
+
+const emit = defineEmits<{
+  "update:open": [value: boolean];
+  "draft:save": [selectedNames: string[]];
+  "draft:showAll": [];
+}>();
+
+const { t } = useI18n();
+const connectionStore = useConnectionStore();
+
+const schemaNames = ref<string[]>([]);
+const selectedNames = ref<Set<string>>(new Set());
+const searchText = ref("");
+const isLoading = ref(false);
+const errorMessage = ref("");
+
+const isDraftMode = computed(() => props.draftMode);
+const isLoadingState = computed(() => (isDraftMode.value ? props.draftLoading : isLoading.value));
+const errorMessageState = computed(() => (isDraftMode.value ? props.draftError || "" : errorMessage.value));
+
+const filteredSchemaNames = computed(() => {
+  const query = searchText.value.trim().toLowerCase();
+  const names = isDraftMode.value ? props.draftSchemaNames || [] : schemaNames.value;
+  if (!query) return names;
+  return names.filter((name) => name.toLowerCase().includes(query));
+});
+const selectedCount = computed(() => selectedNames.value.size);
+const totalCount = computed(() => {
+  const names = isDraftMode.value ? props.draftSchemaNames || [] : schemaNames.value;
+  return names.length;
+});
+const canSaveSelection = computed(() => selectedNames.value.size > 0);
+
+watch(
+  () => props.open,
+  (open) => {
+    if (!open) return;
+    if (isDraftMode.value) {
+      initDraftMode();
+    } else {
+      loadSchemas().catch(() => {});
+    }
+  },
+);
+
+function initDraftMode() {
+  searchText.value = "";
+  const names = props.draftSchemaNames || [];
+  const configured = props.draftInitialSelection;
+  if (configured && configured.length > 0) {
+    const visibleSet = new Set(normalizeVisibleSchemaSelection(configured, names));
+    selectedNames.value = new Set(names.filter((name) => visibleSet.has(name)));
+  } else {
+    selectedNames.value = new Set(names);
+  }
+}
+
+async function loadSchemas() {
+  isLoading.value = true;
+  errorMessage.value = "";
+  searchText.value = "";
+  try {
+    const config = connectionStore.getConfig(props.connectionId);
+    const database = props.database || config?.database || "";
+    await connectionStore.ensureConnected(props.connectionId);
+    const names = await api.listSchemas(props.connectionId, database);
+    schemaNames.value = names;
+    const configured = config?.visible_schemas?.[database || ""];
+    if (Array.isArray(configured)) {
+      const visibleSet = new Set(normalizeVisibleSchemaSelection(configured, names));
+      selectedNames.value = new Set(names.filter((name) => visibleSet.has(name)));
+    } else {
+      selectedNames.value = new Set(names);
+    }
+  } catch (e: any) {
+    schemaNames.value = [];
+    selectedNames.value = new Set();
+    errorMessage.value = String(e?.message || e);
+  } finally {
+    isLoading.value = false;
+  }
+}
+
+function toggleSchema(schema: string) {
+  const next = new Set(selectedNames.value);
+  if (next.has(schema)) next.delete(schema);
+  else next.add(schema);
+  selectedNames.value = next;
+}
+
+const isSearching = computed(() => searchText.value.trim().length > 0);
+
+function selectAll() {
+  const names = isDraftMode.value ? props.draftSchemaNames || [] : schemaNames.value;
+  selectedNames.value = new Set(names);
+}
+
+function selectFiltered() {
+  const next = new Set(selectedNames.value);
+  for (const name of filteredSchemaNames.value) {
+    next.add(name);
+  }
+  selectedNames.value = next;
+}
+
+function clearSelection() {
+  selectedNames.value = new Set();
+}
+
+async function showAllSchemas() {
+  if (isDraftMode.value) {
+    selectedNames.value = new Set(props.draftSchemaNames || []);
+    emit("draft:showAll");
+    emit("update:open", false);
+    return;
+  }
+  const config = connectionStore.getConfig(props.connectionId);
+  const database = props.database || config?.database || "";
+  if (config?.visible_schemas?.[database || ""]) {
+    await connectionStore.clearVisibleSchemas(props.connectionId, database);
+  }
+  selectedNames.value = new Set(schemaNames.value);
+  emit("update:open", false);
+}
+
+async function saveSelection() {
+  if (!canSaveSelection.value) return;
+  const names = isDraftMode.value ? props.draftSchemaNames || [] : schemaNames.value;
+  const normalized = normalizeVisibleSchemaSelection([...selectedNames.value], names);
+  if (isDraftMode.value) {
+    emit("draft:save", normalized);
+    emit("update:open", false);
+    return;
+  }
+  const config = connectionStore.getConfig(props.connectionId);
+  const database = props.database || config?.database || "";
+  await connectionStore.setVisibleSchemas(props.connectionId, database, normalized);
+  emit("update:open", false);
+}
+</script>
+
+<template>
+  <Dialog :open="open" @update:open="(value: boolean) => emit('update:open', value)">
+    <DialogContent class="sm:max-w-[460px]">
+      <DialogHeader>
+        <DialogTitle>{{ t("visibleSchemas.title") }}</DialogTitle>
+        <p class="text-sm text-muted-foreground">
+          {{ t("visibleSchemas.description", { connection: connectionName }) }}
+        </p>
+      </DialogHeader>
+
+      <div class="flex items-center gap-2 rounded-md border bg-background px-2">
+        <Search class="h-4 w-4 shrink-0 text-muted-foreground" />
+        <Input v-model="searchText" :placeholder="t('visibleSchemas.searchPlaceholder')" class="h-8 border-0 px-0 shadow-none focus-visible:ring-0" :disabled="isLoadingState || !!errorMessageState" />
+      </div>
+
+      <div class="flex items-center justify-between text-xs text-muted-foreground">
+        <span>{{ t("visibleSchemas.selectedCount", { selected: selectedCount, total: totalCount }) }}</span>
+        <div class="flex items-center gap-2">
+          <button class="hover:text-foreground disabled:opacity-50" :disabled="isLoadingState" @click="selectAll">
+            {{ t("visibleSchemas.selectAll") }}
+          </button>
+          <button v-if="isSearching" class="hover:text-foreground disabled:opacity-50" :disabled="isLoadingState" @click="selectFiltered">
+            {{ t("visibleSchemas.selectFiltered") }}
+          </button>
+          <button class="hover:text-foreground disabled:opacity-50" :disabled="isLoadingState" @click="clearSelection">
+            {{ t("visibleSchemas.clear") }}
+          </button>
+          <button class="hover:text-foreground disabled:opacity-50" :disabled="isLoadingState" @click="showAllSchemas">
+            {{ t("visibleSchemas.showAll") }}
+          </button>
+        </div>
+      </div>
+      <p v-if="!isLoadingState && !errorMessageState && !canSaveSelection" class="text-xs text-destructive">
+        {{ t("visibleSchemas.emptySelection") }}
+      </p>
+
+      <div class="h-72 overflow-y-auto rounded-md border bg-background/50 p-1">
+        <div v-if="isLoadingState" class="flex h-full items-center justify-center gap-2 text-sm text-muted-foreground">
+          <Loader2 class="h-4 w-4 animate-spin" />
+          {{ t("common.loading") }}
+        </div>
+        <div v-else-if="errorMessageState" class="p-3 text-sm text-destructive">
+          {{ t("visibleSchemas.loadFailed", { message: errorMessageState }) }}
+        </div>
+        <div v-else-if="!filteredSchemaNames.length" class="p-3 text-sm text-muted-foreground">
+          {{ t("grid.noSearchResults") }}
+        </div>
+        <template v-else>
+          <button
+            v-for="schema in filteredSchemaNames"
+            :key="schema"
+            type="button"
+            class="flex h-8 w-full min-w-0 items-center gap-2 rounded-sm px-2 text-left text-sm hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground focus-visible:outline-none"
+            @click="toggleSchema(schema)"
+          >
+            <CheckSquare v-if="selectedNames.has(schema)" class="h-4 w-4 shrink-0 text-primary" />
+            <Square v-else class="h-4 w-4 shrink-0 text-muted-foreground" />
+            <span class="truncate">{{ schema }}</span>
+          </button>
+        </template>
+      </div>
+
+      <DialogFooter>
+        <Button variant="outline" @click="emit('update:open', false)">{{ t("dangerDialog.cancel") }}</Button>
+        <Button :disabled="isLoadingState || !!errorMessageState || !canSaveSelection" @click="saveSelection">
+          {{ t("visibleSchemas.save") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/sql-file/SqlFileExecutionDialog.vue b/apps/desktop/src/components/sql-file/SqlFileExecutionDialog.vue
new file mode 100644
index 0000000..ab1bddd
--- /dev/null
+++ b/apps/desktop/src/components/sql-file/SqlFileExecutionDialog.vue
@@ -0,0 +1,621 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { uuid } from "@/lib/common/utils";
+import { useI18n } from "vue-i18n";
+import { useSqlHighlighter } from "@/composables/useSqlHighlighter";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { Dialog, DialogFooter, DialogHeader, DialogScrollContent, DialogTitle } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import { useToast } from "@/composables/useToast";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
+import { productionContextForDatabase } from "@/lib/database/productionSafety";
+import { databaseOptionsForConnection } from "@/composables/useDatabaseOptions";
+import { requiresSqlFileTargetDatabaseSelection } from "@/lib/connection/connectionLevelDatabaseBootstrap";
+import { cancelSqlFileExecution, executeSqlFile, listenSqlFileProgress, listDatabases, previewSqlFile, type SqlFilePreview, type SqlFileProgress, type SqlFileStatus } from "@/lib/backend/api";
+import { useExportTracker } from "@/composables/useExportTracker";
+import { Check, CheckSquare, FileCode, FolderOpen, Loader2, Play, Square, X } from "@lucide/vue";
+
+const { t } = useI18n();
+const { toast } = useToast();
+const { highlight } = useSqlHighlighter();
+const { addSqlFileTask, updateSqlFileTask } = useExportTracker();
+const open = defineModel<boolean>("open", { default: false });
+
+const props = defineProps<{
+  prefillConnectionId?: string;
+  prefillDatabase?: string;
+  prefillFilePath?: string;
+}>();
+
+const store = useConnectionStore();
+const productionSafetyStore = useProductionSafetyStore();
+
+const fileInput = ref<HTMLInputElement | null>(null);
+const filePath = ref("");
+const preview = ref<SqlFilePreview | null>(null);
+const selectingFile = ref(false);
+const loadingPreview = ref(false);
+const connectionId = ref("");
+const database = ref("");
+const databaseOptions = ref<string[]>([]);
+const loadingDatabases = ref(false);
+const continueOnError = ref(false);
+
+const running = ref(false);
+const cancelling = ref(false);
+const cancelRequested = ref(false);
+const executionStarted = ref(false);
+const executionId = ref("");
+const progress = ref<SqlFileProgress | null>(null);
+const terminalStatus = ref<SqlFileStatus | "idle">("idle");
+const terminalError = ref("");
+const refreshedTarget = ref(false);
+
+const sqlConnections = computed(() => store.connections.filter((c) => !["redis", "mongodb", "elasticsearch", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "mq", "nacos"].includes(c.db_type)));
+
+const selectedConnection = computed(() => sqlConnections.value.find((c) => c.id === connectionId.value));
+
+const canStart = computed(() => {
+  const connection = selectedConnection.value;
+  if (!preview.value || !connection || running.value || loadingPreview.value || loadingDatabases.value) return false;
+  return !!database.value.trim() || !requiresSqlFileTargetDatabaseSelection(connection, preview.value.canExecuteWithoutSelectedDatabase);
+});
+
+const statusTone = computed(() => {
+  if (terminalStatus.value === "done") return "text-green-600";
+  if (terminalStatus.value === "error") return "text-destructive";
+  if (terminalStatus.value === "cancelled") return "text-yellow-600";
+  if (running.value) return "text-primary";
+  return "text-muted-foreground";
+});
+
+const statusIcon = computed(() => {
+  if (running.value) return Loader2;
+  if (terminalStatus.value === "done") return Check;
+  if (terminalStatus.value === "error" || terminalStatus.value === "cancelled") return X;
+  return FileCode;
+});
+
+const progressPercent = computed(() => {
+  if (!progress.value) return 0;
+  if (terminalStatus.value === "done") return 100;
+  const attempted = progress.value.successCount + progress.value.failureCount;
+  const current = Math.max(progress.value.statementIndex, attempted);
+  if (current <= 0) return running.value ? 8 : 0;
+  return Math.min(95, Math.max(8, Math.round((attempted / current) * 100)));
+});
+const previewLineCount = computed(() => preview.value?.preview.split(/\r\n|\r|\n/).length ?? 0);
+const previewLineNumbers = computed(() => Array.from({ length: previewLineCount.value }, (_, index) => index + 1));
+const previewIsTruncated = computed(() => {
+  if (!preview.value) return false;
+  return preview.value.sizeBytes > preview.value.preview.length;
+});
+const previewLineSummary = computed(() => (previewIsTruncated.value ? t("sqlFile.previewingFirstLines", { count: previewLineCount.value }) : t("sqlFile.previewingLines", { count: previewLineCount.value })));
+
+function connectionIconType(id: string) {
+  const config = store.getConfig(id);
+  return config?.driver_profile || config?.db_type || "mysql";
+}
+
+function formatBytes(bytes: number) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB"];
+  let value = bytes / 1024;
+  let unit = units[0];
+  for (let i = 1; i < units.length && value >= 1024; i += 1) {
+    value /= 1024;
+    unit = units[i];
+  }
+  return `${value >= 10 ? value.toFixed(1) : value.toFixed(2)} ${unit}`;
+}
+
+function formatElapsed(ms: number) {
+  if (ms < 1000) return `${ms} ms`;
+  const seconds = ms / 1000;
+  if (seconds < 60) return `${seconds.toFixed(1)} s`;
+  const minutes = Math.floor(seconds / 60);
+  return `${minutes}m ${Math.round(seconds % 60)}s`;
+}
+
+function statusLabel(status: SqlFileStatus | "idle") {
+  return t(`sqlFile.status.${status}`);
+}
+
+function isTerminalStatus(status: SqlFileStatus | "idle") {
+  return status === "done" || status === "error" || status === "cancelled";
+}
+
+function resolveInitialConnectionId() {
+  if (props.prefillConnectionId && sqlConnections.value.some((c) => c.id === props.prefillConnectionId)) {
+    return props.prefillConnectionId;
+  }
+  return sqlConnections.value[0]?.id ?? "";
+}
+
+function chooseDatabase(names: string[], id: string) {
+  const configDatabase = store.getConfig(id)?.database ?? "";
+  if (names.length > 0) {
+    if (props.prefillDatabase && names.includes(props.prefillDatabase)) return props.prefillDatabase;
+    if (configDatabase && names.includes(configDatabase)) return configDatabase;
+    return names.length === 1 ? names[0] : "";
+  }
+  return props.prefillDatabase ?? configDatabase;
+}
+
+function resetExecution() {
+  running.value = false;
+  cancelling.value = false;
+  cancelRequested.value = false;
+  executionStarted.value = false;
+  executionId.value = "";
+  progress.value = null;
+  terminalStatus.value = "idle";
+  terminalError.value = "";
+  refreshedTarget.value = false;
+}
+
+function resetState() {
+  filePath.value = "";
+  preview.value = null;
+  selectingFile.value = false;
+  loadingPreview.value = false;
+  connectionId.value = resolveInitialConnectionId();
+  database.value = "";
+  databaseOptions.value = [];
+  loadingDatabases.value = false;
+  continueOnError.value = false;
+  resetExecution();
+}
+
+let databaseLoadToken = 0;
+
+async function loadDatabasesForConnection(id: string) {
+  const token = databaseLoadToken + 1;
+  databaseLoadToken = token;
+  databaseOptions.value = [];
+
+  if (!sqlConnections.value.some((c) => c.id === id)) {
+    database.value = "";
+    return;
+  }
+
+  loadingDatabases.value = true;
+  try {
+    await store.ensureConnected(id);
+    const names = databaseOptionsForConnection(
+      (await listDatabases(id)).map((db) => db.name),
+      store.getConfig(id),
+    );
+    if (token !== databaseLoadToken) return;
+    databaseOptions.value = names;
+    database.value = chooseDatabase(names, id);
+  } catch {
+    if (token !== databaseLoadToken) return;
+    databaseOptions.value = [];
+    database.value = chooseDatabase([], id);
+  } finally {
+    if (token === databaseLoadToken) {
+      loadingDatabases.value = false;
+    }
+  }
+}
+
+async function previewSelectedSqlFile(fileOrPath: string | File) {
+  if (isTauriRuntime()) {
+    return previewSqlFile(fileOrPath as string);
+  }
+  const { previewSqlFile: previewWebSqlFile } = await import("@/lib/backend/http");
+  return previewWebSqlFile(fileOrPath as File);
+}
+
+async function loadPreview(fileOrPath: string | File) {
+  loadingPreview.value = true;
+  preview.value = null;
+  try {
+    preview.value = await previewSelectedSqlFile(fileOrPath);
+    filePath.value = preview.value.filePath;
+    resetExecution();
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    loadingPreview.value = false;
+  }
+}
+
+async function selectFile() {
+  if (running.value) return;
+  if (!isTauriRuntime()) {
+    fileInput.value?.click();
+    return;
+  }
+  selectingFile.value = true;
+  try {
+    const { open } = await import("@tauri-apps/plugin-dialog");
+    const selected = await open({
+      multiple: false,
+      filters: [{ name: "SQL", extensions: ["sql"] }],
+    });
+    if (typeof selected === "string") {
+      await loadPreview(selected);
+    }
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  } finally {
+    selectingFile.value = false;
+  }
+}
+
+async function handleFileInputChange(event: Event) {
+  const input = event.target as HTMLInputElement;
+  const file = input.files?.[0];
+  input.value = "";
+  if (!file || running.value) return;
+  selectingFile.value = true;
+  try {
+    await loadPreview(file);
+  } finally {
+    selectingFile.value = false;
+  }
+}
+
+async function listenProgress(id: string, handler: (next: SqlFileProgress) => void): Promise<() => void> {
+  if (isTauriRuntime()) {
+    return listenSqlFileProgress(handler);
+  }
+  const { listenSqlFileProgressById } = await import("@/lib/sql/httpSqlFileProgress");
+  return listenSqlFileProgressById(id, handler);
+}
+
+async function refreshTargetAfterImport() {
+  if (refreshedTarget.value) return;
+  refreshedTarget.value = true;
+  try {
+    await store.refreshDatabaseTreeNode(connectionId.value, database.value.trim());
+  } catch (e: any) {
+    toast(e?.message || String(e), 5000);
+  }
+}
+
+async function startExecution() {
+  if (!canStart.value || !preview.value) return;
+  const productionContext = productionContextForDatabase(selectedConnection.value, database.value);
+  if (productionContext.active) {
+    // File previews are truncated, so production file execution is always reviewed instead of inferring safety from a partial preview.
+    const confirmed = await productionSafetyStore.requestConfirmation({
+      sql: preview.value.preview,
+      connectionName: selectedConnection.value?.name,
+      database: database.value,
+      productionDatabases: productionContext.databases,
+      source: t("production.sourceSqlFile"),
+    });
+    if (!confirmed) return;
+  }
+
+  const id = uuid();
+  executionId.value = id;
+  running.value = true;
+  cancelling.value = false;
+  cancelRequested.value = false;
+  executionStarted.value = false;
+  terminalStatus.value = "running";
+  terminalError.value = "";
+  progress.value = null;
+  addSqlFileTask(id, preview.value.fileName, preview.value.filePath);
+
+  let unlisten: (() => void) | undefined;
+  try {
+    await store.ensureConnected(connectionId.value);
+    if (cancelRequested.value) {
+      terminalStatus.value = "cancelled";
+      return;
+    }
+
+    unlisten = await listenProgress(id, (next) => {
+      if (next.executionId !== id) return;
+      progress.value = next;
+      terminalStatus.value = next.status;
+      terminalError.value = next.error ?? terminalError.value;
+      updateSqlFileTask(id, next);
+      if (isTerminalStatus(next.status)) {
+        running.value = false;
+        cancelling.value = false;
+      }
+      if (next.status === "done") {
+        void refreshTargetAfterImport();
+      }
+    });
+
+    if (cancelRequested.value) {
+      terminalStatus.value = "cancelled";
+      return;
+    }
+
+    executionStarted.value = true;
+    await executeSqlFile({
+      executionId: id,
+      connectionId: connectionId.value,
+      database: database.value.trim(),
+      filePath: preview.value.filePath,
+      continueOnError: continueOnError.value,
+    });
+    if (!isTerminalStatus(terminalStatus.value)) {
+      terminalStatus.value = cancelRequested.value ? "cancelled" : "done";
+      const lastProgress = progress.value as SqlFileProgress | null;
+      updateSqlFileTask(id, {
+        executionId: id,
+        status: terminalStatus.value,
+        statementIndex: lastProgress?.statementIndex ?? 0,
+        successCount: lastProgress?.successCount ?? 0,
+        failureCount: lastProgress?.failureCount ?? 0,
+        affectedRows: lastProgress?.affectedRows ?? 0,
+        elapsedMs: lastProgress?.elapsedMs ?? 0,
+        statementSummary: lastProgress?.statementSummary ?? "",
+        error: lastProgress?.error ?? null,
+      });
+      if (terminalStatus.value === "done") {
+        await refreshTargetAfterImport();
+      }
+    }
+  } catch (e: any) {
+    terminalStatus.value = cancelRequested.value ? "cancelled" : "error";
+    terminalError.value = e?.message || String(e);
+    const lastProgress = progress.value as SqlFileProgress | null;
+    updateSqlFileTask(id, {
+      executionId: id,
+      status: terminalStatus.value,
+      statementIndex: lastProgress?.statementIndex ?? 0,
+      successCount: lastProgress?.successCount ?? 0,
+      failureCount: lastProgress?.failureCount ?? 0,
+      affectedRows: lastProgress?.affectedRows ?? 0,
+      elapsedMs: lastProgress?.elapsedMs ?? 0,
+      statementSummary: lastProgress?.statementSummary ?? "",
+      error: terminalError.value,
+    });
+    if (!cancelRequested.value) {
+      toast(terminalError.value, 5000);
+    }
+  } finally {
+    unlisten?.();
+    running.value = false;
+    cancelling.value = false;
+    executionStarted.value = false;
+  }
+}
+
+async function cancelExecution() {
+  if (!executionId.value || !running.value || cancelling.value) return;
+  cancelRequested.value = true;
+  cancelling.value = true;
+  if (!executionStarted.value) return;
+  try {
+    const cancelled = await cancelSqlFileExecution(executionId.value);
+    if (!cancelled) {
+      throw new Error("Cancel request was not accepted");
+    }
+  } catch (e: any) {
+    cancelRequested.value = false;
+    cancelling.value = false;
+    toast(e?.message || String(e), 5000);
+  }
+}
+
+function handleOpenChange(nextOpen: boolean) {
+  open.value = nextOpen;
+}
+
+watch(connectionId, (id) => {
+  loadDatabasesForConnection(id);
+});
+
+watch(sqlConnections, () => {
+  if (!open.value || running.value || selectedConnection.value) return;
+  connectionId.value = resolveInitialConnectionId();
+});
+
+watch(
+  open,
+  (value) => {
+    if (!value) return;
+    if (running.value) return;
+    resetState();
+    if (connectionId.value) {
+      loadDatabasesForConnection(connectionId.value);
+    }
+    // When opened from the SQL Files panel with a pre-selected file, load its
+    // preview automatically so the user can review statements before running.
+    if (props.prefillFilePath) {
+      void loadPreview(props.prefillFilePath);
+    }
+  },
+  { immediate: true },
+);
+</script>
+
+<template>
+  <Dialog :open="open" @update:open="handleOpenChange">
+    <DialogScrollContent class="sm:max-w-[860px] min-w-0 overflow-hidden" :trap-focus="false" @interact-outside.prevent>
+      <DialogHeader>
+        <DialogTitle class="flex items-center gap-2">
+          <FileCode class="w-4 h-4" />
+          {{ t("sqlFile.title") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="grid min-w-0 gap-4 py-3">
+        <div class="min-w-0 space-y-3">
+          <div class="text-xs font-medium text-muted-foreground uppercase tracking-wider">
+            {{ t("sqlFile.file") }}
+          </div>
+
+          <div class="flex items-center gap-2">
+            <input ref="fileInput" type="file" accept=".sql,text/sql" class="hidden" @change="handleFileInputChange" />
+            <Input :model-value="filePath" readonly class="h-8 text-xs font-mono" :placeholder="t('sqlFile.selectSqlFile')" />
+            <Button variant="outline" size="sm" class="h-8 shrink-0" :disabled="running || selectingFile" @click="selectFile">
+              <Loader2 v-if="selectingFile || loadingPreview" class="w-3.5 h-3.5 mr-1.5 animate-spin" />
+              <FolderOpen v-else class="w-3.5 h-3.5 mr-1.5" />
+              {{ t("sqlFile.browse") }}
+            </Button>
+          </div>
+
+          <div v-if="preview" class="min-w-0 max-w-full overflow-hidden rounded-md border">
+            <div class="flex items-center justify-between gap-3 px-3 py-2 text-xs border-b bg-muted/40">
+              <div class="min-w-0 flex items-center gap-2">
+                <FileCode class="w-3.5 h-3.5 text-muted-foreground shrink-0" />
+                <span class="font-medium truncate">{{ preview.fileName }}</span>
+              </div>
+              <div class="flex shrink-0 items-center gap-2 text-muted-foreground">
+                <span>{{ previewLineSummary }}</span>
+                <span class="h-3 w-px bg-border" />
+                <span>{{ formatBytes(preview.sizeBytes) }}</span>
+              </div>
+            </div>
+            <div class="sql-file-preview-viewer flex min-h-56 max-h-[min(42vh,360px)] max-w-full overflow-auto bg-muted/15 text-xs">
+              <div class="sticky left-0 z-10 select-none border-r bg-background/95 px-2 py-3 text-right font-mono leading-5 text-muted-foreground/70">
+                <div v-for="lineNumber in previewLineNumbers" :key="lineNumber">{{ lineNumber }}</div>
+              </div>
+              <pre class="min-w-max flex-1 p-3 font-mono leading-5 whitespace-pre" v-html="highlight(preview.preview)"></pre>
+            </div>
+          </div>
+        </div>
+
+        <div class="min-w-0 space-y-3">
+          <div class="text-xs font-medium text-muted-foreground uppercase tracking-wider">
+            {{ t("sqlFile.target") }}
+          </div>
+
+          <div class="grid grid-cols-2 gap-3">
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("sqlFile.connection") }}</Label>
+              <Select v-model="connectionId" :disabled="running">
+                <SelectTrigger class="h-8 text-xs">
+                  <div v-if="connectionId" class="flex items-center gap-1.5 min-w-0">
+                    <DatabaseIcon :db-type="connectionIconType(connectionId)" class="w-3.5 h-3.5 shrink-0" />
+                    <span class="truncate">{{ selectedConnection?.name ?? connectionId }}</span>
+                  </div>
+                  <SelectValue v-else :placeholder="t('sqlFile.selectConnection')" />
+                </SelectTrigger>
+                <SelectContent position="popper">
+                  <SelectItem v-for="c in sqlConnections" :key="c.id" :value="c.id">
+                    <div class="flex items-center gap-1.5">
+                      <DatabaseIcon :db-type="c.driver_profile || c.db_type" class="w-3.5 h-3.5" />
+                      {{ c.name }}
+                    </div>
+                  </SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("sqlFile.database") }}</Label>
+              <Select v-if="databaseOptions.length" v-model="database" :disabled="running || loadingDatabases">
+                <SelectTrigger class="h-8 text-xs">
+                  <SelectValue :placeholder="t('sqlFile.selectDatabase')" />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem v-for="db in databaseOptions" :key="db" :value="db">{{ db }}</SelectItem>
+                </SelectContent>
+              </Select>
+              <div v-else class="relative">
+                <Input v-model="database" class="h-8 text-xs" :disabled="running || loadingDatabases" :placeholder="t('sqlFile.databasePlaceholder')" />
+                <Loader2 v-if="loadingDatabases" class="absolute right-2 top-2 w-3.5 h-3.5 animate-spin text-muted-foreground" />
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <div class="min-w-0 space-y-2.5">
+          <div class="text-xs font-medium text-muted-foreground uppercase tracking-wider">
+            {{ t("sqlFile.options") }}
+          </div>
+
+          <button type="button" class="flex items-center gap-2 text-xs text-left" :disabled="running" @click="continueOnError = !continueOnError">
+            <CheckSquare v-if="continueOnError" class="w-3.5 h-3.5 text-primary shrink-0" />
+            <Square v-else class="w-3.5 h-3.5 text-muted-foreground/40 shrink-0" />
+            {{ t("sqlFile.continueOnError") }}
+          </button>
+        </div>
+
+        <div v-if="running || terminalStatus !== 'idle' || progress" class="min-w-0 space-y-3">
+          <div class="flex items-center justify-between gap-3 text-xs">
+            <div class="flex items-center gap-1.5 min-w-0" :class="statusTone">
+              <component :is="statusIcon" class="w-3.5 h-3.5 shrink-0" :class="{ 'animate-spin': running }" />
+              <span class="font-medium truncate">
+                {{ cancelling ? t("sqlFile.cancelling") : statusLabel(terminalStatus) }}
+              </span>
+            </div>
+            <span v-if="progress" class="text-muted-foreground shrink-0">
+              {{ formatElapsed(progress.elapsedMs) }}
+            </span>
+          </div>
+
+          <div class="w-full bg-muted rounded-full h-2 overflow-hidden">
+            <div class="h-full rounded-full transition-[width] duration-300" :class="terminalStatus === 'error' ? 'bg-destructive' : terminalStatus === 'cancelled' ? 'bg-yellow-500' : 'bg-primary'" :style="{ width: `${progressPercent}%` }" />
+          </div>
+
+          <div class="grid grid-cols-2 sm:grid-cols-4 gap-2 text-xs">
+            <div class="border rounded-md px-2 py-1.5 min-w-0">
+              <div class="text-muted-foreground truncate">{{ t("sqlFile.statement") }}</div>
+              <div class="font-medium truncate">{{ progress?.statementIndex ?? 0 }}</div>
+            </div>
+            <div class="border rounded-md px-2 py-1.5 min-w-0">
+              <div class="text-muted-foreground truncate">{{ t("sqlFile.succeeded") }}</div>
+              <div class="font-medium text-green-600 truncate">
+                {{ progress?.successCount ?? 0 }}
+              </div>
+            </div>
+            <div class="border rounded-md px-2 py-1.5 min-w-0">
+              <div class="text-muted-foreground truncate">{{ t("sqlFile.failed") }}</div>
+              <div class="font-medium text-destructive truncate">
+                {{ progress?.failureCount ?? 0 }}
+              </div>
+            </div>
+            <div class="border rounded-md px-2 py-1.5 min-w-0">
+              <div class="text-muted-foreground truncate">{{ t("sqlFile.affectedRows") }}</div>
+              <div class="font-medium truncate">
+                {{ (progress?.affectedRows ?? 0).toLocaleString() }}
+              </div>
+            </div>
+          </div>
+
+          <div v-if="progress?.statementSummary" class="space-y-1">
+            <Label class="text-xs">{{ t("sqlFile.currentStatement") }}</Label>
+            <div class="max-h-20 max-w-full overflow-auto rounded-md border bg-muted/15 p-2 text-xs font-mono whitespace-pre">
+              {{ progress.statementSummary }}
+            </div>
+          </div>
+
+          <div v-if="progress?.error || terminalError" class="max-w-full overflow-auto rounded-md border bg-destructive/5 p-2 text-xs text-destructive whitespace-pre-wrap">
+            {{ progress?.error || terminalError }}
+          </div>
+        </div>
+      </div>
+
+      <DialogFooter>
+        <template v-if="running">
+          <Button variant="outline" size="sm" @click="open = false">
+            {{ t("sqlFile.runInBackground") }}
+          </Button>
+          <Button variant="destructive" size="sm" :disabled="cancelling" @click="cancelExecution">
+            <Loader2 v-if="cancelling" class="w-3.5 h-3.5 mr-1.5 animate-spin" />
+            <X v-else class="w-3.5 h-3.5 mr-1.5" />
+            {{ cancelling ? t("sqlFile.cancelling") : t("sqlFile.cancel") }}
+          </Button>
+        </template>
+        <template v-else>
+          <Button variant="outline" size="sm" @click="open = false">
+            {{ t("common.close") }}
+          </Button>
+          <Button size="sm" :disabled="!canStart" @click="startExecution">
+            <Play class="w-3.5 h-3.5 mr-1.5" />
+            {{ t("sqlFile.execute") }}
+          </Button>
+        </template>
+      </DialogFooter>
+    </DialogScrollContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/structure/TableStructureEditor.vue b/apps/desktop/src/components/structure/TableStructureEditor.vue
new file mode 100644
index 0000000..3c4f191
--- /dev/null
+++ b/apps/desktop/src/components/structure/TableStructureEditor.vue
@@ -0,0 +1,3203 @@
+<script setup lang="ts">
+import { computed, nextTick, onActivated, onBeforeUnmount, onDeactivated, onMounted, ref, watch } from "vue";
+import { uuid } from "@/lib/common/utils";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Badge } from "@/components/ui/badge";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { AlertTriangle, Check, ChevronDown, ChevronUp, Copy, Database, Info, KeyRound, ListChevronsUpDown, Loader2, Maximize2, Plus, RefreshCw, Save, Search, Settings, SlidersHorizontal, Trash2, X } from "@lucide/vue";
+import { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuItem, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { SearchableSelect } from "@/components/ui/searchable-select";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
+import { productionContextForDatabase } from "@/lib/database/productionSafety";
+import { useQueryStore } from "@/stores/queryStore";
+import { useHistoryStore } from "@/stores/historyStore";
+import { useSettingsStore, type StructureEditorDensity } from "@/stores/settingsStore";
+import { useTheme } from "@/composables/useTheme";
+import { useToast } from "@/composables/useToast";
+import { type SqlHighlighter, createShikiSqlHighlighter } from "@/lib/sql/sqlHighlighter";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { formatSqlForDisplay, sqlFormatDialectForDbType } from "@/lib/sql/sqlFormatter";
+import { queryTimeoutSecsForConnection } from "@/lib/sql/queryTimeout";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+import { type BuildTableStructureChangeSqlOptions, type EditableStructureColumn, type EditableStructureForeignKey, type EditableStructureIndex, type EditableStructureTrigger } from "@/lib/table/tableStructureEditorSql";
+import { PRESET_FIELDS_TEMPLATE_ID, createTableColumnTemplateDrafts } from "@/lib/table/tableColumnTemplates";
+import { getMysqlDataTypeHelp } from "@/lib/table/mysqlDataTypeHelp";
+import { getPostgresDataTypeHelp } from "@/lib/table/postgresDataTypeHelp";
+import { getSqliteDataTypeHelp } from "@/lib/table/sqliteDataTypeHelp";
+import { getTableMetadataCapabilities, firstStructureMetadataTab, isStructureMetadataTabSupported } from "@/lib/table/tableMetadataCapabilities";
+import { canAddTableStructureColumn, getTableStructureCapabilities, hasLocalTableColumnOrderChange, isPhysicalTableColumnOrderChange, supportsLocalTableColumnReorder } from "@/lib/table/tableStructureCapabilities";
+import { orderedColumnIndexes, uniqueDataGridColumnOrderKeys } from "@/lib/dataGrid/dataGridColumnOrder";
+import { loadTableDataGridColumnOrder, notifyTableDataGridColumnOrderChanged, removeTableDataGridColumnOrder, saveTableDataGridColumnOrder, tableDataGridColumnOrderScopeKey } from "@/lib/dataGrid/dataGridColumnLayoutStorage";
+import { connectionObjectTreeQuerySchema, tableStructureDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import type { TableInfoTab, TableStructureEditorDraft, TableStructureEditorTarget, TableStructureEditorViewport } from "@/types/database";
+import {
+  applyManticoreDdlColumnExtras,
+  buildStructureTargetLabel,
+  canEditManticoreColumnProperties,
+  combineDataTypeForDatabase,
+  createColumnDrafts,
+  createForeignKeyDrafts,
+  createIndexDrafts,
+  createTriggerDrafts,
+  dataTypeLengthInputValue,
+  defaultNewColumnDataType,
+  generateIndexName,
+  generateUniqueIndexName,
+  getColumnEditorControls,
+  getDataTypeOptions,
+  getDefaultLengthForType,
+  hasExistingColumnTypeChange,
+  isDataTypeLengthDisabled,
+  isDamengIdentityCompatibleDataType,
+  isMysqlEnumDataType,
+  isMysqlCharacterDataType,
+  isProtectedManticoreIdColumn,
+  isSqlServerIdentityCompatibleDataType,
+  mysqlEnumDataType,
+  parseExtraToColumnExtra,
+  rehydrateColumnDraftsFromMetadata,
+  splitDataType,
+  toColumnNames,
+} from "@/lib/table/tableStructureEditorState";
+import { CREATE_DATABASE_CHARSET_OPTIONS, createDatabaseCollationOptionsForCharset, fallbackCreateDatabaseCharsetMetadata, normalizeCreateDatabaseCharsetKey, parseCreateDatabaseCharsetMetadata } from "@/lib/database/createDatabaseCharsetOptions";
+import type { CreateDatabaseCharsetMetadata } from "@/lib/database/createDatabaseCharsetOptions";
+import * as api from "@/lib/backend/api";
+
+const { t } = useI18n();
+const { isDark } = useTheme();
+const store = useConnectionStore();
+const productionSafetyStore = useProductionSafetyStore();
+const queryStore = useQueryStore();
+const historyStore = useHistoryStore();
+const settingsStore = useSettingsStore();
+const { toast } = useToast();
+const rootRef = ref<HTMLElement>();
+type StructureScrollerRef = HTMLElement | { $el?: HTMLElement };
+const columnsScrollerRef = ref<StructureScrollerRef>();
+const indexesScrollerRef = ref<StructureScrollerRef>();
+const foreignKeysScrollerRef = ref<StructureScrollerRef>();
+const triggersScrollerRef = ref<StructureScrollerRef>();
+const ddlScrollerRef = ref<StructureScrollerRef>();
+const dynamicDataTypeOptionsCache = new Map<string, string[]>();
+
+const sqlHighlighter = ref<SqlHighlighter>();
+onMounted(async () => {
+  sqlHighlighter.value = await createShikiSqlHighlighter({
+    appearance: () => (isDark.value ? "dark" : "light"),
+  });
+});
+
+const highlightedSql = computed(() => {
+  if (!pendingStatements.value.length) return "";
+  const sql = pendingStatements.value.join("\n");
+  return sqlHighlighter.value?.(sql) ?? sql;
+});
+const previewSqlText = computed(() => pendingStatements.value.join("\n"));
+
+const props = defineProps<{
+  connectionId: string;
+  database: string;
+  schema?: string;
+  tableName: string;
+  initialTab?: TableInfoTab;
+  initialTabRequestId?: number;
+  initialTarget?: TableStructureEditorTarget;
+  draft?: TableStructureEditorDraft;
+}>();
+
+const emit = defineEmits<{
+  "update:draft": [draft: TableStructureEditorDraft | undefined];
+  saved: [commentChanged: boolean];
+  close: [];
+  openSettings: [initialTab?: string, initialSection?: string];
+}>();
+
+const activeTab = ref<TableInfoTab>("columns");
+const loading = ref(false);
+const saving = ref(false);
+const postSaveRefreshing = ref(false);
+const sqlPreviewLoading = ref(false);
+const indexesLoading = ref(false);
+const foreignKeysLoading = ref(false);
+const triggersLoading = ref(false);
+const ddlContent = ref("");
+const ddlLoading = ref(false);
+const ddlPreRef = ref<HTMLPreElement | null>(null);
+function onDdlKeydown(e: KeyboardEvent) {
+  if ((e.ctrlKey || e.metaKey) && e.key === "a") {
+    e.preventDefault();
+    const el = ddlPreRef.value;
+    if (!el) return;
+    const range = document.createRange();
+    range.selectNodeContents(el);
+    const sel = window.getSelection();
+    sel?.removeAllRanges();
+    sel?.addRange(range);
+  }
+}
+const ddlFetched = ref(false);
+
+async function fetchDdl() {
+  if (!props.connectionId || !props.database || !props.tableName || ddlFetched.value || !tableMetadataCapabilities.value.ddl) return;
+  ddlLoading.value = true;
+  try {
+    const ddl = await api.getTableDdl(props.connectionId, props.database, metadataSchema.value, props.tableName);
+    ddlContent.value = await formatSqlForDisplay(ddl, sqlFormatDialectForDbType(databaseType.value), settingsStore.editorSettings.sqlFormatter);
+    ddlFetched.value = true;
+  } catch (e: any) {
+    ddlContent.value = `-- Error: ${e?.message || e}`;
+    ddlFetched.value = true;
+  } finally {
+    ddlLoading.value = false;
+  }
+}
+const errorMessage = ref("");
+const columns = ref<EditableStructureColumn[]>([]);
+const indexes = ref<EditableStructureIndex[]>([]);
+const pendingStatements = ref<string[]>([]);
+const warnings = ref<string[]>([]);
+const sqliteSchemaRevision = ref<string>();
+const foreignKeys = ref<EditableStructureForeignKey[]>([]);
+const triggers = ref<EditableStructureTrigger[]>([]);
+const secondaryMetadataLoading = computed(() => indexesLoading.value || foreignKeysLoading.value || triggersLoading.value);
+
+interface StructureRefreshScope {
+  columns: boolean;
+  indexes: boolean;
+  foreignKeys: boolean;
+  triggers: boolean;
+  tableComment: boolean;
+}
+
+const FULL_STRUCTURE_REFRESH_SCOPE: StructureRefreshScope = {
+  columns: true,
+  indexes: true,
+  foreignKeys: true,
+  triggers: true,
+  tableComment: true,
+};
+
+function sameList(left: string[] | null | undefined, right: string[] | null | undefined): boolean {
+  const a = left ?? [];
+  const b = right ?? [];
+  return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+
+function sameText(left: string | null | undefined, right: string | null | undefined): boolean {
+  return (left ?? "") === (right ?? "");
+}
+
+function columnChanged(column: EditableStructureColumn, index: number): boolean {
+  if (!column.original || column.markedForDrop) return true;
+  const original = column.original;
+  return (
+    isPhysicalTableColumnOrderChange(databaseType.value, connection.value?.db_type, column.originalPosition, index) ||
+    column.name !== original.name ||
+    column.dataType !== original.data_type ||
+    column.isNullable !== original.is_nullable ||
+    !sameText(column.defaultValue, original.column_default) ||
+    !sameText(column.comment, original.comment) ||
+    column.isPrimaryKey !== original.is_primary_key ||
+    !sameText(column.characterSet, original.character_set) ||
+    !sameText(column.collation, original.collation) ||
+    JSON.stringify(column.extra) !== JSON.stringify(parseExtraToColumnExtra(original.extra, databaseType.value))
+  );
+}
+
+function indexChanged(index: EditableStructureIndex): boolean {
+  if (!index.original || index.markedForDrop) return true;
+  const original = index.original;
+  return (
+    index.name !== original.name ||
+    !sameList(index.columns, original.columns) ||
+    index.isUnique !== original.is_unique ||
+    !sameText(index.filter, original.filter) ||
+    !sameText(index.indexType, original.index_type) ||
+    !sameList(index.includedColumns, original.included_columns) ||
+    !sameText(index.comment, original.comment)
+  );
+}
+
+function foreignKeyChanged(foreignKey: EditableStructureForeignKey): boolean {
+  if (!foreignKey.original || foreignKey.markedForDrop) return true;
+  const original = foreignKey.original;
+  return (
+    foreignKey.name !== original.name ||
+    foreignKey.column !== original.column ||
+    !sameText(foreignKey.refSchema, original.ref_schema) ||
+    foreignKey.refTable !== original.ref_table ||
+    foreignKey.refColumn !== original.ref_column ||
+    !sameText(foreignKey.onUpdate, original.on_update) ||
+    !sameText(foreignKey.onDelete, original.on_delete)
+  );
+}
+
+function triggerChanged(trigger: EditableStructureTrigger): boolean {
+  if (!trigger.original || trigger.markedForDrop) return true;
+  const original = trigger.original;
+  return trigger.name !== original.name || trigger.timing !== original.timing || trigger.event !== original.event || !sameText(trigger.statement, original.statement);
+}
+
+function captureStructureRefreshScope(): StructureRefreshScope {
+  return {
+    columns: columns.value.some(columnChanged),
+    indexes: indexes.value.some(indexChanged),
+    foreignKeys: foreignKeys.value.some(foreignKeyChanged),
+    triggers: triggers.value.some(triggerChanged),
+    tableComment: tableComment.value !== originalTableComment.value,
+  };
+}
+
+function isPlainModShortcut(event: KeyboardEvent, key: string): boolean {
+  if (event.isComposing || event.altKey || event.shiftKey) return false;
+  if (!event.metaKey && !event.ctrlKey) return false;
+  return event.key.toLowerCase() === key;
+}
+
+const structureDensityValues: StructureEditorDensity[] = ["compact", "standard", "comfortable"];
+const STRUCTURE_COLUMNS_WIDTHS_STORAGE_KEY = "dbx-structure-editor-column-widths";
+const STRUCTURE_INDEX_COLUMNS_WIDTHS_STORAGE_KEY = "dbx-structure-editor-index-column-widths";
+const STRUCTURE_SQL_PREVIEW_COLLAPSED_STORAGE_KEY = "dbx-structure-editor-sql-preview-collapsed";
+const STRUCTURE_COLUMN_WIDTH_COUNT = 12;
+const STRUCTURE_INDEX_COLUMN_WIDTH_COUNT = 8;
+const PERSISTED_STRUCTURE_INDEX_COLUMN_WIDTHS = new Set([0, 1, 6]);
+const structureDensityMetrics: Record<
+  StructureEditorDensity,
+  {
+    columns: number[];
+    indexes: number[];
+    minColumnWidth: number;
+    minIndexColumnWidth: number;
+    actionButtonWidth: number;
+    fontSize: number;
+    shellPadding: number;
+    cellPaddingX: number;
+    cellPaddingY: number;
+    headerPaddingY: number;
+    controlHeight: number;
+    controlPaddingX: number;
+    iconSize: number;
+    checkboxSize: number;
+    lineHeight: number;
+  }
+> = {
+  compact: {
+    columns: [28, 168, 136, 82, 60, 52, 108, 220, 80, 120, 144, 108],
+    indexes: [120, 180, 60, 88, 124, 144, 120, 70],
+    minColumnWidth: 24,
+    minIndexColumnWidth: 48,
+    actionButtonWidth: 24,
+    fontSize: 11,
+    shellPadding: 10,
+    cellPaddingX: 6,
+    cellPaddingY: 4,
+    headerPaddingY: 5,
+    controlHeight: 24,
+    controlPaddingX: 8,
+    iconSize: 14,
+    checkboxSize: 13,
+    lineHeight: 1.35,
+  },
+  standard: {
+    columns: [32, 200, 160, 104, 72, 64, 128, 260, 90, 140, 160, 136],
+    indexes: [148, 224, 72, 108, 148, 180, 148, 84],
+    minColumnWidth: 28,
+    minIndexColumnWidth: 60,
+    actionButtonWidth: 28,
+    fontSize: 12,
+    shellPadding: 12,
+    cellPaddingX: 8,
+    cellPaddingY: 5,
+    headerPaddingY: 7,
+    controlHeight: 28,
+    controlPaddingX: 10,
+    iconSize: 15,
+    checkboxSize: 14,
+    lineHeight: 1.4,
+  },
+  comfortable: {
+    columns: [36, 232, 188, 116, 84, 76, 152, 300, 100, 160, 188, 148],
+    indexes: [176, 260, 84, 124, 176, 216, 176, 104],
+    minColumnWidth: 32,
+    minIndexColumnWidth: 64,
+    actionButtonWidth: 32,
+    fontSize: 13,
+    shellPadding: 16,
+    cellPaddingX: 10,
+    cellPaddingY: 7,
+    headerPaddingY: 9,
+    controlHeight: 32,
+    controlPaddingX: 12,
+    iconSize: 16,
+    checkboxSize: 16,
+    lineHeight: 1.5,
+  },
+};
+
+function isStructureEditorDensity(value: unknown): value is StructureEditorDensity {
+  return structureDensityValues.includes(value as StructureEditorDensity);
+}
+
+function metricsForDensity(density: StructureEditorDensity) {
+  return structureDensityMetrics[density];
+}
+
+function normalizeStructureColumnWidths(value: unknown, density: StructureEditorDensity): number[] | null {
+  if (!Array.isArray(value)) return null;
+  let widths = value.map((item) => Number(item));
+  if (widths.some((item) => !Number.isFinite(item))) return null;
+  // Backward compatibility: pad old 11-column persisted layout to 12 by inserting
+  // a default collation width at index 9.
+  if (widths.length === STRUCTURE_COLUMN_WIDTH_COUNT - 1) {
+    const defaultWidths = metricsForDensity(density).columns;
+    widths = [...widths.slice(0, 9), defaultWidths[9], ...widths.slice(9)];
+  }
+  if (widths.length !== STRUCTURE_COLUMN_WIDTH_COUNT) return null;
+  const minWidth = metricsForDensity(density).minColumnWidth;
+  return widths.map((item) => Math.max(minWidth, item));
+}
+
+function normalizeStructureIndexColumnWidths(value: unknown, density: StructureEditorDensity): number[] | null {
+  if (!Array.isArray(value) || value.length !== STRUCTURE_INDEX_COLUMN_WIDTH_COUNT) return null;
+  const minWidth = metricsForDensity(density).minIndexColumnWidth;
+  const widths = value.map((item) => Number(item));
+  if (widths.some((item) => !Number.isFinite(item))) return null;
+  return widths.map((item) => Math.max(minWidth, item));
+}
+
+function loadStructureWidthsByDensity(storageKey: string, density: StructureEditorDensity): unknown {
+  const raw = safeLocalStorageGet(storageKey);
+  if (!raw) return undefined;
+  try {
+    const parsed = JSON.parse(raw) as Partial<Record<StructureEditorDensity, unknown>>;
+    return parsed?.[density];
+  } catch {
+    return undefined;
+  }
+}
+
+function loadStructureColumnWidths(density: StructureEditorDensity): number[] {
+  const fallback = [...metricsForDensity(density).columns];
+  const stored = loadStructureWidthsByDensity(STRUCTURE_COLUMNS_WIDTHS_STORAGE_KEY, density);
+  return normalizeStructureColumnWidths(stored, density) ?? fallback;
+}
+
+function loadStructureIndexColumnWidths(density: StructureEditorDensity): number[] {
+  const fallback = [...metricsForDensity(density).indexes];
+  const stored = normalizeStructureIndexColumnWidths(loadStructureWidthsByDensity(STRUCTURE_INDEX_COLUMNS_WIDTHS_STORAGE_KEY, density), density);
+  if (!stored) return fallback;
+  return fallback.map((width, index) => (PERSISTED_STRUCTURE_INDEX_COLUMN_WIDTHS.has(index) ? stored[index] : width));
+}
+
+function saveStructureWidthsByDensity(storageKey: string, density: StructureEditorDensity, widths: readonly number[]) {
+  let payload: Partial<Record<StructureEditorDensity, number[]>> = {};
+  const raw = safeLocalStorageGet(storageKey);
+  if (raw) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object") payload = parsed;
+    } catch {
+      payload = {};
+    }
+  }
+  payload[density] = [...widths];
+  safeLocalStorageSet(storageKey, JSON.stringify(payload));
+}
+
+function saveStructureColumnWidths(density: StructureEditorDensity, widths: readonly number[]) {
+  const normalized = normalizeStructureColumnWidths([...widths], density);
+  if (!normalized) return;
+  saveStructureWidthsByDensity(STRUCTURE_COLUMNS_WIDTHS_STORAGE_KEY, density, normalized);
+}
+
+function saveStructureIndexColumnWidths(density: StructureEditorDensity, widths: readonly number[]) {
+  const normalized = normalizeStructureIndexColumnWidths([...widths], density);
+  if (!normalized) return;
+  const fallback = metricsForDensity(density).indexes;
+  const stored = fallback.map((width, index) => (PERSISTED_STRUCTURE_INDEX_COLUMN_WIDTHS.has(index) ? normalized[index] : width));
+  saveStructureWidthsByDensity(STRUCTURE_INDEX_COLUMNS_WIDTHS_STORAGE_KEY, density, stored);
+}
+
+function loadSqlPreviewCollapsed(): boolean {
+  return safeLocalStorageGet(STRUCTURE_SQL_PREVIEW_COLLAPSED_STORAGE_KEY) === "true";
+}
+
+const structureDensity = computed(() => settingsStore.editorSettings.structureEditorDensity);
+const localStructureDensity = ref<StructureEditorDensity>(structureDensity.value);
+const structureDensityMetric = computed(() => metricsForDensity(localStructureDensity.value));
+const structureDensityOptions = computed(() => [
+  { value: "compact", label: t("structureEditor.densityCompact") },
+  { value: "standard", label: t("structureEditor.densityStandard") },
+  { value: "comfortable", label: t("structureEditor.densityComfortable") },
+]);
+const structureDensityStyle = computed(() => {
+  const metric = structureDensityMetric.value;
+  return {
+    "--structure-font-size": `${metric.fontSize}px`,
+    "--structure-shell-padding": `${metric.shellPadding}px`,
+    "--structure-cell-px": `${metric.cellPaddingX}px`,
+    "--structure-cell-py": `${metric.cellPaddingY}px`,
+    "--structure-header-py": `${metric.headerPaddingY}px`,
+    "--structure-control-height": `${metric.controlHeight}px`,
+    "--structure-control-px": `${metric.controlPaddingX}px`,
+    "--structure-icon-size": `${metric.iconSize}px`,
+    "--structure-checkbox-size": `${metric.checkboxSize}px`,
+    "--structure-line-height": String(metric.lineHeight),
+  };
+});
+const structureControlClass = "h-[var(--structure-control-height)] min-w-0 rounded-[6px] px-[var(--structure-control-px)] py-0 text-[length:var(--structure-font-size)] focus-visible:border-ring/50 focus-visible:ring-1 focus-visible:ring-ring/25";
+const structureMonoControlClass = `${structureControlClass} font-mono`;
+const structureToolbarButtonClass = "h-[var(--structure-control-height)] gap-1 px-[var(--structure-control-px)] text-[length:var(--structure-font-size)]";
+const structureIconButtonClass = "h-[var(--structure-control-height)] w-[var(--structure-control-height)]";
+const structureIconClass = "h-[var(--structure-icon-size)] w-[var(--structure-icon-size)]";
+const structureCheckboxClass = "h-[var(--structure-checkbox-size)] w-[var(--structure-checkbox-size)]";
+const structureHeaderCellClass = "relative min-w-0 overflow-hidden border-b border-r px-[var(--structure-cell-px)] py-[var(--structure-header-py)] text-left";
+const structureCellClass = "min-w-0 overflow-hidden border-b border-r px-[var(--structure-cell-px)] py-[var(--structure-cell-py)]";
+const structureLastCellClass = "min-w-0 overflow-hidden border-b px-[var(--structure-cell-px)] py-[var(--structure-cell-py)]";
+const structurePropertyListClass = "flex min-w-0 items-center gap-0 overflow-hidden";
+const structurePropertyLabelClass = "flex min-w-0 items-center gap-1 whitespace-nowrap";
+const structureActionButtonClass = `${structureIconButtonClass} shrink-0`;
+const structureDensityMenuOpen = ref(false);
+const structureDensityMenuRef = ref<HTMLElement>();
+
+function applyStructureDensityWidths(density: StructureEditorDensity) {
+  colWidths.value = loadStructureColumnWidths(density);
+  indexColWidths.value = loadStructureIndexColumnWidths(density);
+}
+
+function setStructureDensity(value: unknown) {
+  if (!isStructureEditorDensity(value)) return;
+  if (value === localStructureDensity.value) return;
+  localStructureDensity.value = value;
+}
+
+function selectStructureDensity(value: unknown) {
+  setStructureDensity(value);
+  structureDensityMenuOpen.value = false;
+}
+
+function toggleStructureDensityMenu() {
+  structureDensityMenuOpen.value = !structureDensityMenuOpen.value;
+}
+
+function focusStructureDensityOption(offset: number) {
+  const currentIndex = structureDensityValues.indexOf(localStructureDensity.value);
+  const nextIndex = (currentIndex + offset + structureDensityValues.length) % structureDensityValues.length;
+  selectStructureDensity(structureDensityValues[nextIndex]);
+}
+
+function onStructureDensityKeydown(event: KeyboardEvent) {
+  if (event.key === "Escape") {
+    structureDensityMenuOpen.value = false;
+    return;
+  }
+  if (event.key === "ArrowDown") {
+    event.preventDefault();
+    if (!structureDensityMenuOpen.value) {
+      structureDensityMenuOpen.value = true;
+      return;
+    }
+    focusStructureDensityOption(1);
+    return;
+  }
+  if (event.key === "ArrowUp") {
+    event.preventDefault();
+    if (!structureDensityMenuOpen.value) {
+      structureDensityMenuOpen.value = true;
+      return;
+    }
+    focusStructureDensityOption(-1);
+    return;
+  }
+  if (event.key === "Enter" || event.key === " ") {
+    event.preventDefault();
+    structureDensityMenuOpen.value = !structureDensityMenuOpen.value;
+  }
+}
+
+function onStructureDensityDocumentPointerdown(event: PointerEvent) {
+  if (!structureDensityMenuOpen.value) return;
+  const target = event.target;
+  if (target instanceof Node && structureDensityMenuRef.value?.contains(target)) return;
+  structureDensityMenuOpen.value = false;
+}
+
+function persistStructureDensity(density = localStructureDensity.value) {
+  if (settingsStore.editorSettings.structureEditorDensity === density) return;
+  settingsStore.updateEditorSettings({ structureEditorDensity: density });
+}
+
+const colWidths = ref(loadStructureColumnWidths(structureDensity.value));
+const colResizing = ref<{ col: number; startX: number; startW: number } | null>(null);
+const indexColWidths = ref(loadStructureIndexColumnWidths(structureDensity.value));
+const resizing = ref<{ col: number; startX: number; startW: number } | null>(null);
+const columnSearchInputRef = ref<InstanceType<typeof Input>>();
+const columnSearchText = ref("");
+const highlightedColumnId = ref<string | null>(null);
+const indexSearchInputRef = ref<InstanceType<typeof Input>>();
+const indexSearchText = ref("");
+const highlightedIndexId = ref<string | null>(null);
+const sqlPreviewCollapsed = ref(loadSqlPreviewCollapsed());
+let columnHighlightTimer: ReturnType<typeof window.setTimeout> | undefined;
+let indexHighlightTimer: ReturnType<typeof window.setTimeout> | undefined;
+
+watch(
+  structureDensity,
+  (density) => {
+    if (density === localStructureDensity.value) return;
+    localStructureDensity.value = density;
+  },
+  { flush: "sync" },
+);
+
+watch(localStructureDensity, (density, previousDensity) => {
+  if (density === previousDensity) return;
+  applyStructureDensityWidths(density);
+  persistStructureDensity(density);
+});
+
+function onColResize(e: MouseEvent, col: number) {
+  e.preventDefault();
+  const widthIndex = columnWidthIndex(col);
+  colResizing.value = { col: widthIndex, startX: e.clientX, startW: colWidths.value[widthIndex] };
+  const onMove = (ev: MouseEvent) => {
+    if (!colResizing.value) return;
+    const delta = ev.clientX - colResizing.value.startX;
+    colWidths.value[widthIndex] = Math.max(structureDensityMetric.value.minColumnWidth, colResizing.value.startW + delta);
+  };
+  const onUp = () => {
+    colResizing.value = null;
+    saveStructureColumnWidths(localStructureDensity.value, colWidths.value);
+    document.removeEventListener("mousemove", onMove);
+    document.removeEventListener("mouseup", onUp);
+  };
+  document.addEventListener("mousemove", onMove);
+  document.addEventListener("mouseup", onUp);
+}
+
+function onIndexColResize(e: MouseEvent, col: number) {
+  e.preventDefault();
+  resizing.value = { col, startX: e.clientX, startW: indexColWidths.value[col] };
+  const onMove = (ev: MouseEvent) => {
+    if (!resizing.value) return;
+    const delta = ev.clientX - resizing.value.startX;
+    indexColWidths.value[col] = Math.max(structureDensityMetric.value.minIndexColumnWidth, resizing.value.startW + delta);
+  };
+  const onUp = () => {
+    resizing.value = null;
+    if (PERSISTED_STRUCTURE_INDEX_COLUMN_WIDTHS.has(col)) {
+      saveStructureIndexColumnWidths(localStructureDensity.value, indexColWidths.value);
+    }
+    document.removeEventListener("mousemove", onMove);
+    document.removeEventListener("mouseup", onUp);
+  };
+  document.addEventListener("mousemove", onMove);
+  document.addEventListener("mouseup", onUp);
+}
+
+const connection = computed(() => (props.connectionId ? store.getConfig(props.connectionId) : undefined));
+const databaseType = computed(() => tableStructureDatabaseTypeForConnection(connection.value));
+const usesMysql8SafeDefaults = computed(() => databaseType.value === "mysql" && connection.value?.db_type === "mysql" && connection.value.driver_profile === "mysql");
+const structureCapabilities = computed(() => getTableStructureCapabilities(databaseType.value, connection.value?.db_type));
+const tableMetadataCapabilities = computed(() => getTableMetadataCapabilities(databaseType.value));
+const structureDialect = computed(() => structureCapabilities.value.dialect);
+const isTableCommentDisabled = computed(() => !structureCapabilities.value.comment);
+const dynamicDataTypeOptions = ref<string[]>([]);
+const dataTypeOptions = computed(() => mergeDataTypeOptions(dynamicDataTypeOptions.value, getDataTypeOptions(databaseType.value)));
+const columnEditorControls = computed(() => getColumnEditorControls(databaseType.value));
+
+const indexTypesByDb: Record<string, string[]> = {
+  postgres: ["BTREE", "HASH", "GIST", "SPGIST", "GIN", "BRIN"],
+  mysql: ["BTREE", "HASH", "FULLTEXT", "SPATIAL", "RTREE"],
+  sqlserver: ["CLUSTERED", "NONCLUSTERED", "COLUMNSTORE", "NONCLUSTERED COLUMNSTORE", "XML", "SPATIAL"],
+  oracle: ["NORMAL", "BITMAP", "FUNCTION-BASED NORMAL", "FUNCTION-BASED DOMAIN", "DOMAIN", "CLUSTER"],
+  sqlite: ["BTREE"],
+};
+const indexTypeOptions = computed(() => (structureCapabilities.value.indexType ? (indexTypesByDb[structureDialect.value] ?? []) : []));
+
+interface DefaultValuePreset {
+  label: string;
+  value: string;
+}
+
+const defaultValuePresets = computed((): DefaultValuePreset[] => {
+  const universal: DefaultValuePreset[] = [
+    { label: "''", value: "''" },
+    { label: "NULL", value: "NULL" },
+    { label: "0", value: "0" },
+    { label: "1", value: "1" },
+  ];
+
+  const dialectPresets: Record<string, DefaultValuePreset[]> = {
+    mysql: [
+      { label: "CURRENT_TIMESTAMP", value: "CURRENT_TIMESTAMP" },
+      { label: "CURRENT_DATE", value: "CURRENT_DATE" },
+      { label: "CURRENT_TIME", value: "CURRENT_TIME" },
+    ],
+    postgres: [
+      { label: "CURRENT_TIMESTAMP", value: "CURRENT_TIMESTAMP" },
+      { label: "CURRENT_DATE", value: "CURRENT_DATE" },
+      { label: "now()", value: "now()" },
+      { label: "gen_random_uuid()", value: "gen_random_uuid()" },
+    ],
+    sqlite: [
+      { label: "CURRENT_TIMESTAMP", value: "CURRENT_TIMESTAMP" },
+      { label: "CURRENT_DATE", value: "CURRENT_DATE" },
+      { label: "CURRENT_TIME", value: "CURRENT_TIME" },
+    ],
+    duckdb: [
+      { label: "CURRENT_TIMESTAMP", value: "CURRENT_TIMESTAMP" },
+      { label: "CURRENT_DATE", value: "CURRENT_DATE" },
+    ],
+    sqlserver: [
+      { label: "GETDATE()", value: "GETDATE()" },
+      { label: "GETUTCDATE()", value: "GETUTCDATE()" },
+      { label: "CURRENT_TIMESTAMP", value: "CURRENT_TIMESTAMP" },
+      { label: "NEWID()", value: "NEWID()" },
+    ],
+    oracle: [
+      { label: "SYSDATE", value: "SYSDATE" },
+      { label: "SYSTIMESTAMP", value: "SYSTIMESTAMP" },
+      { label: "CURRENT_TIMESTAMP", value: "CURRENT_TIMESTAMP" },
+    ],
+    h2: [
+      { label: "CURRENT_TIMESTAMP", value: "CURRENT_TIMESTAMP" },
+      { label: "CURRENT_DATE", value: "CURRENT_DATE" },
+    ],
+    clickhouse: [
+      { label: "now()", value: "now()" },
+      { label: "today()", value: "today()" },
+    ],
+    informix: [
+      { label: "CURRENT", value: "CURRENT" },
+      { label: "TODAY", value: "TODAY" },
+    ],
+  };
+
+  return [...universal, ...(dialectPresets[structureDialect.value] ?? [])];
+});
+
+function isPostgresIdentityType(dbType: string | undefined): boolean {
+  return dbType === "postgres" || dbType === "gaussdb" || dbType === "kwdb" || dbType === "opengauss" || dbType === "highgo" || dbType === "vastbase" || dbType === "kingbase";
+}
+
+const showExtendedProperties = computed(() => {
+  const dt = databaseType.value;
+  return dt === "mysql" || dt === "dameng" || dt === "manticoresearch" || isPostgresIdentityType(dt) || dt === "sqlserver";
+});
+const showCharacterSet = computed(() => structureDialect.value === "mysql");
+
+const serverCharsetMetadata = ref<CreateDatabaseCharsetMetadata>();
+const charsetMetadataLoading = ref(false);
+
+const mysqlCharsetOptions = computed<string[]>(() => {
+  const meta = serverCharsetMetadata.value;
+  return meta ? meta.charsets : ([...CREATE_DATABASE_CHARSET_OPTIONS] as string[]);
+});
+
+function collationOptionsForCharset(charset: string): string[] {
+  const meta = serverCharsetMetadata.value;
+  if (meta) {
+    return meta.collationsByCharset[normalizeCreateDatabaseCharsetKey(charset)] ?? [];
+  }
+  return createDatabaseCollationOptionsForCharset(charset);
+}
+
+async function loadCharsetMetadata() {
+  if (charsetMetadataLoading.value || !showCharacterSet.value) return;
+  charsetMetadataLoading.value = true;
+  try {
+    await store.ensureConnected(props.connectionId);
+    const [charsetResult, collationResult] = await Promise.all([api.executeQuery(props.connectionId, props.database, "SHOW CHARACTER SET"), api.executeQuery(props.connectionId, props.database, "SHOW COLLATION")]);
+    serverCharsetMetadata.value = parseCreateDatabaseCharsetMetadata(charsetResult, collationResult);
+  } catch {
+    serverCharsetMetadata.value = fallbackCreateDatabaseCharsetMetadata();
+  } finally {
+    charsetMetadataLoading.value = false;
+  }
+}
+
+function onCharsetChange(column: EditableStructureColumn, charset: string) {
+  column.characterSet = charset;
+  // If the collation is no longer valid for the new charset, clear it so the
+  // server picks its default (COLLATE is only emitted when explicitly chosen).
+  if (column.collation && !collationOptionsForCharset(charset).includes(column.collation)) {
+    column.collation = "";
+  }
+}
+
+function columnCharset(column: EditableStructureColumn): string {
+  return column.characterSet ?? "";
+}
+
+function columnCollation(column: EditableStructureColumn): string {
+  return column.collation ?? "";
+}
+
+const extendedPropertiesColumnIndex = 10;
+const actionButtonGap = 2;
+const columnActionButtonCount = computed(() => (canShowColumnDragControls.value ? 2 : 1));
+const columnActionsWidth = computed(() => {
+  const metric = structureDensityMetric.value;
+  const count = columnActionButtonCount.value;
+  return metric.actionButtonWidth * count + actionButtonGap * Math.max(0, count - 1) + metric.cellPaddingX * 2;
+});
+const visibleColumnIndexes = computed(() => colLabels.value.map((column) => column.widthIndex));
+const visibleColWidths = computed(() => colLabels.value.map((column) => (column.key === "actions" ? columnActionsWidth.value : (colWidths.value[column.widthIndex] ?? structureDensityMetric.value.minColumnWidth))));
+
+function columnWidthIndex(visibleIndex: number) {
+  return visibleColumnIndexes.value[visibleIndex] ?? visibleIndex;
+}
+
+const colLabels = computed(() => {
+  const labels = [
+    { key: "ordinal", label: "#", widthIndex: 0 },
+    { key: "name", label: t("structureEditor.columnName"), widthIndex: 1 },
+    { key: "type", label: t("structureEditor.dataType"), widthIndex: 2 },
+  ];
+  if (columnEditorControls.value.length) labels.push({ key: "length", label: t("structureEditor.length"), widthIndex: 3 });
+  if (columnEditorControls.value.nullable) labels.push({ key: "nullable", label: t("structureEditor.nullable"), widthIndex: 4 });
+  if (columnEditorControls.value.primaryKey) labels.push({ key: "primaryKey", label: t("structureEditor.primaryKey"), widthIndex: 5 });
+  if (columnEditorControls.value.defaultValue) labels.push({ key: "defaultValue", label: t("structureEditor.defaultValue"), widthIndex: 6 });
+  if (columnEditorControls.value.comment) labels.push({ key: "comment", label: t("structureEditor.comment"), widthIndex: 7 });
+  if (showCharacterSet.value) labels.push({ key: "characterSet", label: t("structureEditor.characterSet"), widthIndex: 8 });
+  if (showCharacterSet.value) labels.push({ key: "collation", label: t("structureEditor.collation"), widthIndex: 9 });
+  if (showExtendedProperties.value) {
+    labels.push({ key: "extendedProperties", label: t("structureEditor.extendedProperties"), widthIndex: extendedPropertiesColumnIndex });
+  }
+  labels.push({ key: "actions", label: t("structureEditor.actions"), widthIndex: 11 });
+  return labels;
+});
+const indexColLabels = computed(() => [t("structureEditor.indexName"), t("structureEditor.indexColumns"), t("structureEditor.unique"), t("structureEditor.indexType"), t("structureEditor.includedColumns"), t("structureEditor.filter"), t("structureEditor.comment"), t("structureEditor.actions")]);
+const filteredColumnRowIds = computed(() => {
+  const query = columnSearchText.value.trim().toLowerCase();
+  if (!query) return new Set<string>();
+  return new Set(
+    columns.value
+      .filter((column) =>
+        [column.name, column.comment].some((value) =>
+          String(value ?? "")
+            .toLowerCase()
+            .includes(query),
+        ),
+      )
+      .map((column) => column.id),
+  );
+});
+const columnSearchMatchCount = computed(() => (columnSearchText.value.trim() ? filteredColumnRowIds.value.size : 0));
+const filteredIndexRowIds = computed(() => {
+  const query = indexSearchText.value.trim().toLowerCase();
+  if (!query) return new Set<string>();
+  return new Set(indexes.value.filter((index) => indexMatchesSearch(index, query)).map((index) => index.id));
+});
+const indexSearchMatchCount = computed(() => (indexSearchText.value.trim() ? filteredIndexRowIds.value.size : 0));
+const foreignKeyActionOptions = ["", "CASCADE", "SET NULL", "RESTRICT", "NO ACTION"];
+const triggerTimingOptions = ["BEFORE", "AFTER"];
+const triggerEventOptions = ["INSERT", "UPDATE", "DELETE"];
+const metadataSchema = computed(() => connectionObjectTreeQuerySchema(connection.value, props.database, props.schema));
+const refreshVersion = computed(() => (props.connectionId && props.tableName ? queryStore.tableStructureRefreshVersion(props.connectionId, props.database, props.schema, props.tableName) : 0));
+const isCreateMode = computed(() => !props.tableName);
+const usesSqliteRebuildStrategy = computed(() => !isCreateMode.value && structureCapabilities.value.alterStrategy === "sqlite-rebuild");
+const hasSqliteTypeChange = computed(() => usesSqliteRebuildStrategy.value && hasExistingColumnTypeChange(columns.value));
+const canAddColumn = computed(() => canAddTableStructureColumn(databaseType.value, isCreateMode.value));
+const newTableName = ref("");
+const tableComment = ref("");
+const originalTableComment = ref("");
+const targetLabel = computed(() => buildStructureTargetLabel(connection.value?.name, props.database, props.schema, isCreateMode.value ? undefined : props.tableName));
+
+function isManticoreTextColumn(column: EditableStructureColumn): boolean {
+  if (databaseType.value !== "manticoresearch") return false;
+  const baseType = splitDataType(column.dataType).baseType.trim().toLowerCase();
+  return baseType === "text" || baseType === "string";
+}
+
+function isManticoreJsonColumn(column: EditableStructureColumn): boolean {
+  if (databaseType.value !== "manticoresearch") return false;
+  return splitDataType(column.dataType).baseType.trim().toLowerCase() === "json";
+}
+
+let sqlPreviewRequestId = 0;
+let structureLoadRequestId = 0;
+let dataTypeOptionsRequestId = 0;
+let sqlPreviewDebounceTimer: ReturnType<typeof setTimeout> | undefined;
+let deferredSqlPreviewRefresh = false;
+let keydownListenerRegistered = false;
+let skipNextRefreshVersion = false;
+let restoringDraft = false;
+let syncingDraft = false;
+let draftHydrated = false;
+let hydratingRestoredDraft = false;
+let structureScrollFrame = 0;
+// A context-menu target may arrive before metadata rows render, so search text
+// and row scrolling are tracked separately for each request.
+let appliedInitialTargetSearchKey = "";
+let appliedInitialTargetScrollKey = "";
+
+function cloneDraftValue<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+const structureScrollPositions = ref<Partial<Record<TableInfoTab, TableStructureEditorViewport>>>({});
+
+function structureScrollerElement(scroller: StructureScrollerRef | undefined): HTMLElement | undefined {
+  if (!scroller) return undefined;
+  if (scroller instanceof HTMLElement) return scroller;
+  return scroller.$el instanceof HTMLElement ? scroller.$el : undefined;
+}
+
+function structureScrollerForTab(tab: TableInfoTab): HTMLElement | undefined {
+  if (tab === "columns") return structureScrollerElement(columnsScrollerRef.value);
+  if (tab === "indexes") return structureScrollerElement(indexesScrollerRef.value);
+  if (tab === "foreignKeys") return structureScrollerElement(foreignKeysScrollerRef.value);
+  if (tab === "triggers") return structureScrollerElement(triggersScrollerRef.value);
+  if (tab === "ddl") return structureScrollerElement(ddlScrollerRef.value);
+  return undefined;
+}
+
+function restoreStructureScrollPosition(tab = activeTab.value) {
+  const position = structureScrollPositions.value[tab];
+  if (!position) return;
+  nextTick(() => {
+    const scroller = structureScrollerForTab(tab);
+    if (!scroller) return;
+    scroller.scrollTop = Math.max(0, position.scrollTop);
+    scroller.scrollLeft = Math.max(0, position.scrollLeft);
+  });
+}
+
+function onStructureContentScroll(tab: TableInfoTab, event: Event) {
+  const target = event.currentTarget;
+  if (!(target instanceof HTMLElement)) return;
+  const position: TableStructureEditorViewport = {
+    scrollTop: Math.max(0, Math.round(target.scrollTop)),
+    scrollLeft: Math.max(0, Math.round(target.scrollLeft)),
+  };
+  const previous = structureScrollPositions.value[tab];
+  if (previous?.scrollTop === position.scrollTop && previous.scrollLeft === position.scrollLeft) return;
+  structureScrollPositions.value = {
+    ...structureScrollPositions.value,
+    [tab]: position,
+  };
+  if (structureScrollFrame) return;
+  structureScrollFrame = window.requestAnimationFrame(() => {
+    structureScrollFrame = 0;
+    syncDraftToParent();
+  });
+}
+
+function createCurrentDraft(initialized = true): TableStructureEditorDraft {
+  return {
+    activeTab: activeTab.value as TableStructureEditorDraft["activeTab"],
+    newTableName: newTableName.value,
+    tableComment: tableComment.value,
+    originalTableComment: originalTableComment.value,
+    columns: cloneDraftValue(columns.value),
+    indexes: cloneDraftValue(indexes.value),
+    foreignKeys: cloneDraftValue(foreignKeys.value),
+    triggers: cloneDraftValue(triggers.value),
+    scrollPositions: cloneDraftValue(structureScrollPositions.value),
+    initialized,
+  };
+}
+
+function syncDraftToParent() {
+  if (!draftHydrated) return;
+  if (restoringDraft || syncingDraft) return;
+  syncingDraft = true;
+  emit("update:draft", createCurrentDraft());
+  syncingDraft = false;
+}
+
+function restoreDraft(draft: TableStructureEditorDraft) {
+  restoringDraft = true;
+  draftHydrated = false;
+  activeTab.value = draft.activeTab || "columns";
+  newTableName.value = draft.newTableName || "";
+  tableComment.value = draft.tableComment || "";
+  originalTableComment.value = draft.originalTableComment || "";
+  columns.value = cloneDraftValue(draft.columns || []);
+  indexes.value = cloneDraftValue(draft.indexes || []);
+  foreignKeys.value = cloneDraftValue(draft.foreignKeys || []);
+  triggers.value = cloneDraftValue(draft.triggers || []);
+  structureScrollPositions.value = cloneDraftValue(draft.scrollPositions || {});
+  restoringDraft = false;
+  draftHydrated = !needsColumnDraftMetadataHydration();
+  restoreStructureScrollPosition();
+}
+
+function needsColumnDraftMetadataHydration() {
+  return !isCreateMode.value && columns.value.some((column) => !column.original && !column.id.startsWith("new:") && !!column.name.trim());
+}
+
+async function hydrateRestoredDraftFromDatabase() {
+  if (!needsColumnDraftMetadataHydration() || hydratingRestoredDraft) return;
+  const connectionId = props.connectionId;
+  const database = props.database;
+  const schema = metadataSchema.value;
+  const tableName = props.tableName;
+  if (!connectionId || !database || !tableName) return;
+
+  hydratingRestoredDraft = true;
+  let shouldRefreshPreview = false;
+  try {
+    await store.ensureConnected(connectionId);
+    let nextColumns = await api.getColumns(connectionId, database, schema, tableName);
+    if (databaseType.value === "manticoresearch" && tableMetadataCapabilities.value.ddl) {
+      try {
+        const ddl = await api.getTableDdl(connectionId, database, schema, tableName);
+        ddlContent.value = await formatSqlForDisplay(ddl, sqlFormatDialectForDbType(databaseType.value), settingsStore.editorSettings.sqlFormatter);
+        ddlFetched.value = true;
+        nextColumns = applyManticoreDdlColumnExtras(nextColumns, ddl);
+      } catch {
+        /* ignore — Manticore column properties can still come from SHOW COLUMNS when available */
+      }
+    }
+    columns.value = rehydrateColumnDraftsFromMetadata(columns.value, nextColumns, databaseType.value);
+    markDraftHydratedAndSync();
+    shouldRefreshPreview = true;
+  } catch (e: any) {
+    console.warn("[DBX][structure-editor:draft-hydration-failed]", e);
+  } finally {
+    hydratingRestoredDraft = false;
+    if (shouldRefreshPreview) scheduleSqlPreviewRefresh();
+  }
+}
+
+function markDraftHydratedAndSync() {
+  draftHydrated = true;
+  syncDraftToParent();
+}
+
+function hasPendingStructureChanges(): boolean {
+  if (isCreateMode.value) {
+    return !!newTableName.value.trim() || !!tableComment.value.trim() || columns.value.length > 0 || indexes.value.length > 0 || foreignKeys.value.length > 0 || triggers.value.length > 0;
+  }
+  const scope = captureStructureRefreshScope();
+  return scope.columns || scope.indexes || scope.foreignKeys || scope.triggers || scope.tableComment;
+}
+
+function clearSqlPreviewState() {
+  if (sqlPreviewDebounceTimer) {
+    clearTimeout(sqlPreviewDebounceTimer);
+    sqlPreviewDebounceTimer = undefined;
+  }
+  sqlPreviewRequestId++;
+  deferredSqlPreviewRefresh = false;
+  sqlPreviewLoading.value = false;
+  pendingStatements.value = [];
+  warnings.value = [];
+  sqliteSchemaRevision.value = undefined;
+}
+
+function dataTypeOptionsCacheKey(connectionId: string, database: string) {
+  return `${connectionId}\u0000${database}`;
+}
+
+function mergeDataTypeOptions(primary: readonly string[], fallback: readonly string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const option of [...primary, ...fallback]) {
+    const trimmed = option.trim();
+    if (!trimmed) continue;
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(trimmed);
+  }
+  return result;
+}
+
+function mysqlDataTypeTooltip(option: string): string | undefined {
+  if (databaseType.value !== "mysql") return undefined;
+  const product = connection.value?.driver_profile === "mariadb" ? "mariadb" : connection.value?.driver_profile === "mysql" ? "mysql" : undefined;
+  const help = getMysqlDataTypeHelp(option, { product });
+  return help ? [help.key, ...(help.warningKeys ?? [])].map((key) => t(`structureEditor.mysqlDataTypeHelp.${key}`)).join("\n\n") : undefined;
+}
+
+function postgresDataTypeTooltip(option: string): string | undefined {
+  if (databaseType.value !== "postgres") return undefined;
+  const help = getPostgresDataTypeHelp(option);
+  return help ? t(`structureEditor.postgresDataTypeHelp.${help.key}`) : undefined;
+}
+
+function sqliteDataTypeTooltip(option: string): string | undefined {
+  if (databaseType.value !== "sqlite") return undefined;
+  const help = getSqliteDataTypeHelp(option);
+  return help ? t(`structureEditor.sqliteDataTypeHelp.${help.key}`) : undefined;
+}
+
+function dataTypeTooltip(option: string): string | undefined {
+  if (databaseType.value === "mysql") return mysqlDataTypeTooltip(option);
+  if (databaseType.value === "postgres") return postgresDataTypeTooltip(option);
+  if (databaseType.value === "sqlite") return sqliteDataTypeTooltip(option);
+  return undefined;
+}
+
+async function loadDynamicDataTypeOptions() {
+  const requestId = ++dataTypeOptionsRequestId;
+  const connectionId = props.connectionId;
+  const database = props.database;
+  if (!connectionId || !database) {
+    dynamicDataTypeOptions.value = [];
+    return;
+  }
+  const cacheKey = dataTypeOptionsCacheKey(connectionId, database);
+  const cached = dynamicDataTypeOptionsCache.get(cacheKey);
+  if (cached) {
+    dynamicDataTypeOptions.value = cached;
+    return;
+  }
+  dynamicDataTypeOptions.value = [];
+  try {
+    await store.ensureConnected(connectionId);
+    const options = await api.listDataTypes(connectionId, database);
+    if (requestId !== dataTypeOptionsRequestId) return;
+    const normalized = mergeDataTypeOptions(options, []);
+    if (normalized.length > 0) {
+      dynamicDataTypeOptionsCache.set(cacheKey, normalized);
+      dynamicDataTypeOptions.value = normalized;
+    } else {
+      dynamicDataTypeOptions.value = [];
+    }
+  } catch {
+    if (requestId === dataTypeOptionsRequestId) {
+      dynamicDataTypeOptions.value = [];
+    }
+  }
+}
+
+function scheduleSqlPreviewRefresh() {
+  if (sqlPreviewDebounceTimer) {
+    clearTimeout(sqlPreviewDebounceTimer);
+    sqlPreviewDebounceTimer = undefined;
+  }
+  sqlPreviewRequestId++;
+  deferredSqlPreviewRefresh = false;
+  pendingStatements.value = [];
+  warnings.value = [];
+  sqliteSchemaRevision.value = undefined;
+  if (!hasPendingStructureChanges()) {
+    sqlPreviewLoading.value = false;
+    return;
+  }
+  sqlPreviewLoading.value = true;
+  if (hydratingRestoredDraft || needsColumnDraftMetadataHydration()) return;
+  if (!isCreateMode.value && secondaryMetadataLoading.value) {
+    deferredSqlPreviewRefresh = true;
+    return;
+  }
+  sqlPreviewDebounceTimer = setTimeout(() => {
+    sqlPreviewDebounceTimer = undefined;
+    void refreshSqlPreview();
+  }, 80);
+}
+
+function structureChangeOptions(): BuildTableStructureChangeSqlOptions {
+  return {
+    databaseType: databaseType.value,
+    schema: props.schema,
+    tableName: isCreateMode.value ? newTableName.value : props.tableName || "",
+    columns: columns.value,
+    indexes: indexes.value,
+    foreignKeys: foreignKeys.value,
+    triggers: triggers.value,
+    tableComment: tableComment.value,
+    originalTableComment: isCreateMode.value ? undefined : originalTableComment.value,
+  };
+}
+
+async function refreshSqlPreview() {
+  const requestId = ++sqlPreviewRequestId;
+  if (!hasPendingStructureChanges()) {
+    pendingStatements.value = [];
+    warnings.value = [];
+    sqliteSchemaRevision.value = undefined;
+    sqlPreviewLoading.value = false;
+    return;
+  }
+  sqlPreviewLoading.value = true;
+  const options = structureChangeOptions();
+  try {
+    const result = isCreateMode.value ? await api.buildCreateTableSql(options) : hasSqliteTypeChange.value ? await api.previewSqliteTableStructureChange(props.connectionId, props.database, options) : await api.buildTableStructureChangeSql(options);
+    if (requestId !== sqlPreviewRequestId) return;
+    pendingStatements.value = result.statements;
+    warnings.value = result.warnings;
+    sqliteSchemaRevision.value = "schemaRevision" in result && typeof result.schemaRevision === "string" ? result.schemaRevision : undefined;
+  } catch (e: any) {
+    if (requestId !== sqlPreviewRequestId) return;
+    pendingStatements.value = [];
+    warnings.value = [e?.message || String(e)];
+    sqliteSchemaRevision.value = undefined;
+  } finally {
+    if (requestId === sqlPreviewRequestId) sqlPreviewLoading.value = false;
+  }
+}
+
+const canApply = computed(
+  () =>
+    !loading.value &&
+    !saving.value &&
+    !postSaveRefreshing.value &&
+    !secondaryMetadataLoading.value &&
+    !sqlPreviewLoading.value &&
+    pendingStatements.value.length > 0 &&
+    warnings.value.length === 0 &&
+    (!hasSqliteTypeChange.value || !!sqliteSchemaRevision.value) &&
+    !!props.connectionId &&
+    (isCreateMode.value ? !!newTableName.value.trim() : !!props.tableName),
+);
+
+function clearDraft() {
+  draftHydrated = false;
+  emit("update:draft", undefined);
+}
+
+function resetState() {
+  loading.value = false;
+  saving.value = false;
+  postSaveRefreshing.value = false;
+  sqlPreviewLoading.value = false;
+  indexesLoading.value = false;
+  foreignKeysLoading.value = false;
+  triggersLoading.value = false;
+  errorMessage.value = "";
+  columns.value = [];
+  indexes.value = [];
+  pendingStatements.value = [];
+  warnings.value = [];
+  sqliteSchemaRevision.value = undefined;
+  foreignKeys.value = [];
+  triggers.value = [];
+  ddlContent.value = "";
+  ddlFetched.value = false;
+  newTableName.value = "";
+  tableComment.value = "";
+  originalTableComment.value = "";
+  columnSearchText.value = "";
+  highlightedColumnId.value = null;
+  indexSearchText.value = "";
+  highlightedIndexId.value = null;
+  appliedInitialTargetSearchKey = "";
+  appliedInitialTargetScrollKey = "";
+  localColumnOrderNoticeShown.value = false;
+}
+
+async function reloadStructureFromDatabase() {
+  if (isCreateMode.value) return;
+  draftHydrated = false;
+  await loadStructure(false, FULL_STRUCTURE_REFRESH_SCOPE, true, { blockSecondaryMetadata: true });
+}
+
+function setSecondaryMetadataLoading(scope: StructureRefreshScope, value: boolean) {
+  if (scope.indexes && tableMetadataCapabilities.value.indexes) indexesLoading.value = value;
+  if (scope.foreignKeys && tableMetadataCapabilities.value.foreignKeys) foreignKeysLoading.value = value;
+  if (scope.triggers && tableMetadataCapabilities.value.triggers) triggersLoading.value = value;
+}
+
+async function fetchTableCommentValue(connectionId: string, database: string, schema: string, tableName: string): Promise<string | undefined> {
+  try {
+    return (await api.getTableComment(connectionId, database, schema, tableName)) || "";
+  } catch {
+    try {
+      const tables = await api.listTables(connectionId, database, schema);
+      const table = tables.find((t) => t.name.toLowerCase() === tableName.toLowerCase() && t.table_type !== "VIEW");
+      return table?.comment || "";
+    } catch {
+      return undefined;
+    }
+  }
+}
+
+async function loadStructure(silent = false, scope: StructureRefreshScope = FULL_STRUCTURE_REFRESH_SCOPE, showErrors = true, options: { blockSecondaryMetadata?: boolean; preserveDraft?: boolean } = {}) {
+  const connectionId = props.connectionId;
+  const database = props.database;
+  const schema = metadataSchema.value;
+  const tableName = props.tableName;
+  if (!connectionId || !database || !tableName) return;
+  const requestId = ++structureLoadRequestId;
+  if (!silent) loading.value = true;
+  setSecondaryMetadataLoading(scope, true);
+  errorMessage.value = "";
+  let secondaryMetadataScheduled = false;
+  let loadedSuccessfully = false;
+  try {
+    await store.ensureConnected(connectionId);
+
+    const columnsPromise = scope.columns ? api.getColumns(connectionId, database, schema, tableName) : Promise.resolve(undefined);
+    const indexesPromise = scope.indexes ? (tableMetadataCapabilities.value.indexes ? api.listIndexes(connectionId, database, schema, tableName).catch(() => []) : Promise.resolve([])) : Promise.resolve(undefined);
+    const foreignKeysPromise = scope.foreignKeys ? (tableMetadataCapabilities.value.foreignKeys ? api.listForeignKeys(connectionId, database, schema, tableName).catch(() => []) : Promise.resolve([])) : Promise.resolve(undefined);
+    const triggersPromise = scope.triggers ? (tableMetadataCapabilities.value.triggers ? api.listTriggers(connectionId, database, schema, tableName).catch(() => []) : Promise.resolve([])) : Promise.resolve(undefined);
+    const tableCommentPromise = scope.tableComment && structureCapabilities.value.comment ? fetchTableCommentValue(connectionId, database, schema, tableName) : Promise.resolve(undefined);
+
+    let nextColumns = await columnsPromise;
+    if (nextColumns) {
+      if (databaseType.value === "manticoresearch" && tableMetadataCapabilities.value.ddl) {
+        try {
+          const ddl = await api.getTableDdl(connectionId, database, schema, tableName);
+          ddlContent.value = await formatSqlForDisplay(ddl, sqlFormatDialectForDbType(databaseType.value), settingsStore.editorSettings.sqlFormatter);
+          ddlFetched.value = true;
+          nextColumns = applyManticoreDdlColumnExtras(nextColumns, ddl);
+        } catch {
+          /* ignore — Manticore column properties can still come from SHOW COLUMNS when available */
+        }
+      }
+      // Load live charset/collation metadata from the MySQL server so the column
+      // editor shows the correct options for the server version.
+      void loadCharsetMetadata();
+      columns.value = applyStoredLocalColumnOrder(createColumnDrafts(nextColumns, databaseType.value));
+    }
+
+    const nextTableComment = await tableCommentPromise;
+    if (nextTableComment !== undefined) {
+      originalTableComment.value = nextTableComment;
+      tableComment.value = nextTableComment;
+    }
+    const applySecondaryMetadata = async () => {
+      const [nextIndexes, nextForeignKeys, nextTriggers] = await Promise.all([indexesPromise, foreignKeysPromise, triggersPromise]);
+      if (requestId !== structureLoadRequestId) return;
+      if (nextIndexes) indexes.value = createIndexDrafts(nextIndexes);
+      if (nextForeignKeys) foreignKeys.value = createForeignKeyDrafts(nextForeignKeys);
+      if (nextTriggers) triggers.value = createTriggerDrafts(nextTriggers);
+    };
+
+    secondaryMetadataScheduled = true;
+    const secondaryMetadataPromise = applySecondaryMetadata()
+      .catch((error) => {
+        console.warn("[DBX][structure-editor:secondary-metadata-failed]", error);
+      })
+      .finally(() => {
+        if (requestId === structureLoadRequestId) setSecondaryMetadataLoading(scope, false);
+      });
+    if (options.blockSecondaryMetadata) {
+      await secondaryMetadataPromise;
+    }
+    loadedSuccessfully = true;
+  } catch (e: any) {
+    if (showErrors) {
+      errorMessage.value = e?.message || String(e);
+    } else {
+      console.warn("[DBX][structure-editor:refresh-failed]", e);
+    }
+  } finally {
+    if (!secondaryMetadataScheduled && requestId === structureLoadRequestId) {
+      setSecondaryMetadataLoading(scope, false);
+    }
+    if (!silent) loading.value = false;
+    if (!options.preserveDraft && loadedSuccessfully && requestId === structureLoadRequestId) {
+      markDraftHydratedAndSync();
+    }
+  }
+}
+
+async function refreshStructureAfterSave(scope: StructureRefreshScope) {
+  try {
+    await loadStructure(true, scope, false, { blockSecondaryMetadata: true });
+  } catch (e) {
+    console.warn("[DBX][structure-editor:post-save-refresh-failed]", e);
+  } finally {
+    postSaveRefreshing.value = false;
+    if (activeTab.value === "ddl") void fetchDdl();
+  }
+}
+
+async function addColumn() {
+  if (!canAddColumn.value) return;
+  activeTab.value = "columns";
+  const dataType = defaultNewColumnDataType(databaseType.value, dataTypeOptions.value);
+  const column: EditableStructureColumn = {
+    id: `new:${uuid()}`,
+    name: "",
+    dataType,
+    enumValues: [],
+    isNullable: true,
+    defaultValue: "",
+    comment: "",
+    isPrimaryKey: false,
+    characterSet: "",
+    collation: "",
+    extra: {},
+    markedForDrop: false,
+  };
+  columns.value.push(column);
+  await nextTick();
+  const newRows = rootRef.value?.querySelectorAll<HTMLElement>('[data-new-column-row="true"]');
+  const row = newRows?.[newRows.length - 1];
+  const input = row?.querySelector<HTMLInputElement>("[data-column-name-input]");
+  row?.scrollIntoView({ block: "nearest" });
+  input?.focus();
+  input?.select();
+}
+
+function applyColumnTemplate(templateId: string) {
+  if (!canAddColumn.value) return;
+  activeTab.value = "columns";
+  const templateColumns = createTableColumnTemplateDrafts({
+    templateId,
+    databaseType: databaseType.value,
+    columnNames: settingsStore.editorSettings.tableColumnTemplateFields,
+    existingColumnNames: columns.value.map((column) => column.name),
+    createId: uuid,
+  });
+  if (!templateColumns.length) return;
+  columns.value.push(...templateColumns);
+}
+
+function removeNewColumn(column: EditableStructureColumn) {
+  columns.value = columns.value.filter((item) => item.id !== column.id);
+}
+
+type ColumnDragState = {
+  columnId: string;
+  sourceIndex: number;
+  insertionIndex: number | null;
+};
+
+const columnDragState = ref<ColumnDragState | null>(null);
+const localColumnOrderNoticeShown = ref(false);
+let columnDragPreviousBodyUserSelect = "";
+let columnDragPreviousBodyCursor = "";
+let columnDragTracking = false;
+
+function canDragColumn(index: number): boolean {
+  if (loading.value || saving.value) return false;
+  if (!Number.isInteger(index) || index < 0 || index >= columns.value.length) return false;
+  const column = columns.value[index];
+  if (!column || column.markedForDrop) return false;
+  return canShowColumnDragControls.value;
+}
+
+function canDropColumnAt(sourceIndex: number, insertionIndex: number): boolean {
+  if (!canDragColumn(sourceIndex)) return false;
+  if (!Number.isInteger(insertionIndex) || insertionIndex < 0 || insertionIndex > columns.value.length) return false;
+  if (insertionIndex === sourceIndex || insertionIndex === sourceIndex + 1) return false;
+  const sourceColumn = columns.value[sourceIndex];
+  if (!sourceColumn) return false;
+  const crossedColumns = insertionIndex < sourceIndex ? columns.value.slice(insertionIndex, sourceIndex) : columns.value.slice(sourceIndex + 1, insertionIndex);
+  if (crossedColumns.some((column) => column.markedForDrop)) return false;
+  if (canShowColumnDragControls.value) return true;
+  if (sourceColumn.original) return false;
+  return crossedColumns.every((column) => !column.original);
+}
+
+const usesLocalTableColumnOrder = computed(() => !isCreateMode.value && supportsLocalTableColumnReorder(databaseType.value, connection.value?.db_type));
+const canShowColumnDragControls = computed(() => isCreateMode.value || structureCapabilities.value.reorderColumn || usesLocalTableColumnOrder.value);
+
+function localTableColumnOrderScopeKey(): string {
+  return tableDataGridColumnOrderScopeKey({
+    connectionId: props.connectionId,
+    database: props.database,
+    schema: props.schema,
+    tableName: props.tableName,
+  });
+}
+
+function localColumnOrderKeys(items: readonly EditableStructureColumn[]): string[] {
+  return uniqueDataGridColumnOrderKeys(items.map((column) => column.name));
+}
+
+const hasLocalColumnOrderChange = computed(() => {
+  if (!usesLocalTableColumnOrder.value) return false;
+  return hasLocalTableColumnOrderChange(columns.value);
+});
+
+function applyStoredLocalColumnOrder(items: EditableStructureColumn[]): EditableStructureColumn[] {
+  if (!usesLocalTableColumnOrder.value) return items;
+  const orderedKeys = loadTableDataGridColumnOrder(localTableColumnOrderScopeKey());
+  if (!orderedKeys.length) return items;
+  const columnKeys = uniqueDataGridColumnOrderKeys(items.map((column) => column.name));
+  const indexes = orderedColumnIndexes({
+    availableIndexes: items.map((_, index) => index),
+    columnKeys,
+    orderedKeys,
+  });
+  return indexes.map((index) => items[index]).filter((column): column is EditableStructureColumn => !!column);
+}
+
+function persistLocalColumnOrder(showNotice = true) {
+  if (!usesLocalTableColumnOrder.value) return;
+  const scopeKey = localTableColumnOrderScopeKey();
+  if (hasLocalColumnOrderChange.value) {
+    saveTableDataGridColumnOrder(scopeKey, localColumnOrderKeys(columns.value));
+  } else {
+    removeTableDataGridColumnOrder(scopeKey);
+  }
+  notifyTableDataGridColumnOrderChanged(scopeKey);
+  if (!showNotice || localColumnOrderNoticeShown.value) return;
+  localColumnOrderNoticeShown.value = true;
+  toast(t("structureEditor.localColumnOrderNotice"), 4000);
+}
+
+function isSqlServerIdentityChecked(column: EditableStructureColumn): boolean {
+  return !!column.extra.autoIncrement || !!column.extra.identity;
+}
+
+function canEditSqlServerIdentity(column: EditableStructureColumn): boolean {
+  return !column.original && !column.markedForDrop && isSqlServerIdentityCompatibleDataType(column.dataType);
+}
+
+function clearSqlServerIdentity(column: EditableStructureColumn) {
+  column.extra.autoIncrement = false;
+  column.extra.identity = undefined;
+}
+
+function syncSqlServerIdentityForDataType(column: EditableStructureColumn) {
+  if (databaseType.value !== "sqlserver") return;
+  if (!isSqlServerIdentityChecked(column)) return;
+  if (isSqlServerIdentityCompatibleDataType(column.dataType)) return;
+  clearSqlServerIdentity(column);
+}
+
+function ensureSqlServerIdentity(column: EditableStructureColumn) {
+  column.extra.autoIncrement = true;
+  column.extra.identity = {
+    seed: column.extra.identity?.seed ?? 1,
+    increment: column.extra.identity?.increment ?? 1,
+  };
+}
+
+function setSqlServerIdentity(column: EditableStructureColumn, checked: boolean) {
+  if (!canEditSqlServerIdentity(column)) return;
+  if (checked) {
+    ensureSqlServerIdentity(column);
+    column.isNullable = false;
+  } else {
+    clearSqlServerIdentity(column);
+  }
+}
+
+function parseOptionalNumberInput(value: string | number): number | undefined {
+  if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+  const trimmed = value.trim();
+  if (!trimmed) return undefined;
+  const numeric = Number(trimmed);
+  return Number.isFinite(numeric) ? numeric : undefined;
+}
+
+function updateSqlServerIdentitySeed(column: EditableStructureColumn, value: string | number) {
+  if (!canEditSqlServerIdentity(column)) return;
+  ensureSqlServerIdentity(column);
+  column.extra.identity!.seed = parseOptionalNumberInput(value);
+}
+
+function updateSqlServerIdentityIncrement(column: EditableStructureColumn, value: string | number) {
+  if (!canEditSqlServerIdentity(column)) return;
+  ensureSqlServerIdentity(column);
+  column.extra.identity!.increment = parseOptionalNumberInput(value);
+}
+
+function isDamengIdentityChecked(column: EditableStructureColumn): boolean {
+  return !!column.extra.autoIncrement || !!column.extra.identity;
+}
+
+function canEditDamengIdentity(column: EditableStructureColumn): boolean {
+  if (column.original || column.markedForDrop || !isDamengIdentityCompatibleDataType(column.dataType)) return false;
+  // DM8 permits only one identity column per table, so prevent creating an invalid draft in the editor.
+  return isDamengIdentityChecked(column) || !columns.value.some((candidate) => candidate !== column && !candidate.markedForDrop && isDamengIdentityChecked(candidate));
+}
+
+function clearDamengIdentity(column: EditableStructureColumn) {
+  column.extra.autoIncrement = false;
+  column.extra.identity = undefined;
+}
+
+function syncDamengIdentityForDataType(column: EditableStructureColumn) {
+  if (databaseType.value !== "dameng") return;
+  if (!isDamengIdentityChecked(column)) return;
+  if (isDamengIdentityCompatibleDataType(column.dataType)) return;
+  clearDamengIdentity(column);
+}
+
+function ensureDamengIdentity(column: EditableStructureColumn) {
+  column.extra.autoIncrement = true;
+  column.extra.identity = {
+    seed: column.extra.identity?.seed ?? 1,
+    increment: column.extra.identity?.increment ?? 1,
+  };
+}
+
+function setDamengIdentity(column: EditableStructureColumn, checked: boolean) {
+  if (!canEditDamengIdentity(column)) return;
+  if (checked) {
+    ensureDamengIdentity(column);
+    column.isNullable = false;
+  } else {
+    clearDamengIdentity(column);
+  }
+}
+
+function updateDamengIdentitySeed(column: EditableStructureColumn, value: string | number) {
+  if (!canEditDamengIdentity(column)) return;
+  ensureDamengIdentity(column);
+  column.extra.identity!.seed = parseOptionalNumberInput(value);
+}
+
+function updateDamengIdentityIncrement(column: EditableStructureColumn, value: string | number) {
+  if (!canEditDamengIdentity(column)) return;
+  ensureDamengIdentity(column);
+  column.extra.identity!.increment = parseOptionalNumberInput(value);
+}
+
+function updateColumnDataType(column: EditableStructureColumn, baseType: string) {
+  if (isMysqlEnumDataType(databaseType.value, baseType)) {
+    if (!column.enumValues?.length) column.enumValues = [""];
+    column.dataType = mysqlEnumDataType(column.enumValues);
+  } else {
+    column.dataType = combineDataTypeForDatabase(databaseType.value, baseType, getDefaultLengthForType(databaseType.value, baseType, { omitMysqlDeprecatedDefaults: usesMysql8SafeDefaults.value }));
+  }
+  syncSqlServerIdentityForDataType(column);
+  syncDamengIdentityForDataType(column);
+  // Clear charset/collation when switching to a non-character MySQL type
+  if (showCharacterSet.value && !isMysqlCharacterDataType(column.dataType)) {
+    column.characterSet = "";
+    column.collation = "";
+  }
+}
+
+function updateMysqlEnumValue(column: EditableStructureColumn, index: number, value: string | number) {
+  if (!column.enumValues || index < 0 || index >= column.enumValues.length) return;
+  column.enumValues[index] = String(value);
+  column.dataType = mysqlEnumDataType(column.enumValues);
+}
+
+function addMysqlEnumValue(column: EditableStructureColumn) {
+  column.enumValues ??= [];
+  column.enumValues.push("");
+  column.dataType = mysqlEnumDataType(column.enumValues);
+}
+
+function removeMysqlEnumValue(column: EditableStructureColumn, index: number) {
+  if (!column.enumValues || column.enumValues.length <= 1) return;
+  column.enumValues.splice(index, 1);
+  column.dataType = mysqlEnumDataType(column.enumValues);
+}
+
+function updateColumnDataTypeLength(column: EditableStructureColumn, value: string | number) {
+  column.dataType = combineDataTypeForDatabase(databaseType.value, splitDataType(column.dataType).baseType, String(value));
+  syncSqlServerIdentityForDataType(column);
+  syncDamengIdentityForDataType(column);
+}
+
+function moveColumnTo(index: number, insertionIndex: number) {
+  if (!canDropColumnAt(index, insertionIndex)) return;
+  const nextColumns = [...columns.value];
+  const [column] = nextColumns.splice(index, 1);
+  if (!column) return;
+  const adjustedInsertionIndex = insertionIndex > index ? insertionIndex - 1 : insertionIndex;
+  nextColumns.splice(adjustedInsertionIndex, 0, column);
+  columns.value = nextColumns;
+  persistLocalColumnOrder();
+}
+
+function onColumnDragPointerDown(index: number, event: PointerEvent) {
+  if (event.button !== 0 || !canDragColumn(index)) return;
+  const column = columns.value[index];
+  if (!column) return;
+  event.preventDefault();
+  event.stopPropagation();
+  columnDragState.value = {
+    columnId: column.id,
+    sourceIndex: index,
+    insertionIndex: null,
+  };
+  columnDragPreviousBodyUserSelect = document.body.style.userSelect;
+  columnDragPreviousBodyCursor = document.body.style.cursor;
+  columnDragTracking = true;
+  document.body.style.userSelect = "none";
+  document.body.style.cursor = "grabbing";
+  updateColumnDragInsertion(event.clientY);
+  window.addEventListener("pointermove", onColumnDragPointerMove, true);
+  window.addEventListener("pointerup", onColumnDragPointerUp, true);
+  window.addEventListener("pointercancel", onColumnDragPointerCancel, true);
+}
+
+function onColumnDragPointerMove(event: PointerEvent) {
+  if (!columnDragState.value) return;
+  event.preventDefault();
+  updateColumnDragInsertion(event.clientY);
+}
+
+function onColumnDragPointerUp(event: PointerEvent) {
+  event.preventDefault();
+  const state = columnDragState.value;
+  stopColumnDragTracking();
+  if (state && state.insertionIndex !== null && canDropColumnAt(state.sourceIndex, state.insertionIndex)) {
+    moveColumnTo(state.sourceIndex, state.insertionIndex);
+  }
+  columnDragState.value = null;
+}
+
+function onColumnDragPointerCancel() {
+  stopColumnDragTracking();
+  columnDragState.value = null;
+}
+
+function stopColumnDragTracking() {
+  if (!columnDragTracking) return;
+  columnDragTracking = false;
+  window.removeEventListener("pointermove", onColumnDragPointerMove, true);
+  window.removeEventListener("pointerup", onColumnDragPointerUp, true);
+  window.removeEventListener("pointercancel", onColumnDragPointerCancel, true);
+  document.body.style.userSelect = columnDragPreviousBodyUserSelect;
+  document.body.style.cursor = columnDragPreviousBodyCursor;
+}
+
+function updateColumnDragInsertion(clientY: number) {
+  const state = columnDragState.value;
+  if (!state) return;
+  const insertionIndex = columnDragInsertionIndexFromPoint(clientY);
+  state.insertionIndex = insertionIndex !== null && canDropColumnAt(state.sourceIndex, insertionIndex) ? insertionIndex : null;
+}
+
+function columnDragInsertionIndexFromPoint(clientY: number): number | null {
+  const rows = Array.from(rootRef.value?.querySelectorAll<HTMLElement>("[data-column-row-index]") ?? []);
+  if (!rows.length) return null;
+  const firstRect = rows[0].getBoundingClientRect();
+  if (clientY < firstRect.top) return 0;
+  for (const row of rows) {
+    const rowIndex = Number(row.dataset.columnRowIndex);
+    if (!Number.isInteger(rowIndex)) continue;
+    const rect = row.getBoundingClientRect();
+    if (clientY <= rect.bottom) {
+      return clientY > rect.top + rect.height / 2 ? rowIndex + 1 : rowIndex;
+    }
+  }
+  return rows.length;
+}
+
+function onColumnDragStart(index: number, event: DragEvent) {
+  if (!canDragColumn(index)) {
+    event.preventDefault();
+    return;
+  }
+  const column = columns.value[index];
+  if (!column) return;
+  columnDragState.value = {
+    columnId: column.id,
+    sourceIndex: index,
+    insertionIndex: null,
+  };
+  if (event.dataTransfer) {
+    event.dataTransfer.effectAllowed = "move";
+    event.dataTransfer.setData("text/plain", column.name || column.id);
+  }
+}
+
+function onColumnDragOver(index: number, event: DragEvent) {
+  const state = columnDragState.value;
+  if (!state || columns.value[index]?.markedForDrop) return;
+  const insertionIndex = columnDragInsertionIndex(index, event);
+  if (!canDropColumnAt(state.sourceIndex, insertionIndex)) return;
+  event.preventDefault();
+  state.insertionIndex = insertionIndex;
+  if (event.dataTransfer) event.dataTransfer.dropEffect = "move";
+}
+
+function onColumnDrop(index: number, event: DragEvent) {
+  const state = columnDragState.value;
+  if (!state) return;
+  event.preventDefault();
+  moveColumnTo(state.sourceIndex, columnDragInsertionIndex(index, event));
+  columnDragState.value = null;
+}
+
+function onColumnDragEnd() {
+  columnDragState.value = null;
+}
+
+function columnRowClass(column: EditableStructureColumn, index: number) {
+  const dragState = columnDragState.value;
+  const isSearchMatch = filteredColumnRowIds.value.has(column.id);
+  return {
+    "bg-destructive/5 opacity-60": column.markedForDrop,
+    "structure-column-search-match": isSearchMatch,
+    "structure-column-search-current": highlightedColumnId.value === column.id,
+    "opacity-55": dragState?.columnId === column.id,
+    "bg-primary/5": dragState && (dragState.insertionIndex === index || dragState.insertionIndex === index + 1),
+    "[&>td]:border-t-2 [&>td]:border-t-primary": dragState?.insertionIndex === index,
+    "[&>td]:border-b-2 [&>td]:border-b-primary": dragState?.insertionIndex === index + 1,
+  };
+}
+
+function columnMatchesSearch(column: EditableStructureColumn): boolean {
+  const query = columnSearchText.value.trim().toLowerCase();
+  if (!query) return false;
+  return [column.name, column.comment].some((value) =>
+    String(value ?? "")
+      .toLowerCase()
+      .includes(query),
+  );
+}
+
+function columnFieldMatchesSearch(value: string | null | undefined): boolean {
+  const query = columnSearchText.value.trim().toLowerCase();
+  return (
+    !!query &&
+    String(value ?? "")
+      .toLowerCase()
+      .includes(query)
+  );
+}
+
+function columnSearchFieldClass(column: EditableStructureColumn, value: string | null | undefined) {
+  const matches = columnFieldMatchesSearch(value);
+  return {
+    "!border-primary/60 !bg-primary/10": matches,
+    "!border-primary !ring-2 !ring-primary/30": matches && highlightedColumnId.value === column.id,
+  };
+}
+
+function focusColumnSearch() {
+  activeTab.value = "columns";
+  void nextTick(() => {
+    const input = columnSearchInputRef.value?.$el as HTMLInputElement | undefined;
+    input?.focus();
+    input?.select();
+  });
+}
+
+function scrollToColumnSearchMatch(direction: 1 | -1 = 1) {
+  const query = columnSearchText.value.trim();
+  if (!query) {
+    focusColumnSearch();
+    return;
+  }
+  const rows = Array.from(rootRef.value?.querySelectorAll<HTMLElement>("[data-column-row-index]") ?? []);
+  const matches = columns.value.map((column, index) => ({ column, index })).filter(({ column }) => columnMatchesSearch(column));
+  if (!matches.length) return;
+  const currentIndex = highlightedColumnId.value ? matches.findIndex(({ column }) => column.id === highlightedColumnId.value) : -1;
+  const nextMatch = matches[(currentIndex + direction + matches.length) % matches.length] ?? matches[0];
+  highlightedColumnId.value = nextMatch.column.id;
+  rows[nextMatch.index]?.scrollIntoView({ block: "center", inline: "nearest" });
+  if (columnHighlightTimer) window.clearTimeout(columnHighlightTimer);
+  columnHighlightTimer = window.setTimeout(() => {
+    highlightedColumnId.value = null;
+  }, 1800);
+}
+
+function onColumnSearchKeydown(event: KeyboardEvent) {
+  if (event.key !== "Enter") return;
+  event.preventDefault();
+  scrollToColumnSearchMatch(event.shiftKey ? -1 : 1);
+}
+
+function indexMatchesSearch(index: EditableStructureIndex, searchQuery = indexSearchText.value.trim().toLowerCase()): boolean {
+  if (!searchQuery) return false;
+  return [index.name, toColumnNames(index.columns), index.includedColumns.join(", "), index.indexType, index.filter, index.comment].some((value) =>
+    String(value ?? "")
+      .toLowerCase()
+      .includes(searchQuery),
+  );
+}
+
+function indexFieldMatchesSearch(value: string | null | undefined): boolean {
+  const query = indexSearchText.value.trim().toLowerCase();
+  return (
+    !!query &&
+    String(value ?? "")
+      .toLowerCase()
+      .includes(query)
+  );
+}
+
+function indexRowClass(index: EditableStructureIndex) {
+  const isSearchMatch = filteredIndexRowIds.value.has(index.id);
+  return {
+    "bg-destructive/5 opacity-60": index.markedForDrop,
+    "structure-column-search-match": isSearchMatch,
+    "structure-column-search-current": highlightedIndexId.value === index.id,
+  };
+}
+
+function indexSearchFieldClass(index: EditableStructureIndex, value: string | null | undefined) {
+  const matches = indexFieldMatchesSearch(value);
+  return {
+    "!border-primary/60 !bg-primary/10": matches,
+    "!border-primary !ring-2 !ring-primary/30": matches && highlightedIndexId.value === index.id,
+  };
+}
+
+function focusIndexSearch() {
+  activeTab.value = "indexes";
+  void nextTick(() => {
+    const input = indexSearchInputRef.value?.$el as HTMLInputElement | undefined;
+    input?.focus();
+    input?.select();
+  });
+}
+
+function scrollToIndexSearchMatch(direction: 1 | -1 = 1) {
+  const query = indexSearchText.value.trim();
+  if (!query) {
+    focusIndexSearch();
+    return;
+  }
+  const rows = Array.from(rootRef.value?.querySelectorAll<HTMLElement>("[data-index-row-index]") ?? []);
+  const matches = indexes.value.map((index, rowIndex) => ({ index, rowIndex })).filter(({ index }) => indexMatchesSearch(index));
+  if (!matches.length) return;
+  const currentIndex = highlightedIndexId.value ? matches.findIndex(({ index }) => index.id === highlightedIndexId.value) : -1;
+  const nextMatch = matches[(currentIndex + direction + matches.length) % matches.length] ?? matches[0];
+  highlightedIndexId.value = nextMatch.index.id;
+  rows[nextMatch.rowIndex]?.scrollIntoView({ block: "center", inline: "nearest" });
+  if (indexHighlightTimer) window.clearTimeout(indexHighlightTimer);
+  indexHighlightTimer = window.setTimeout(() => {
+    highlightedIndexId.value = null;
+  }, 1800);
+}
+
+function onIndexSearchKeydown(event: KeyboardEvent) {
+  if (event.key !== "Enter") return;
+  event.preventDefault();
+  scrollToIndexSearchMatch(event.shiftKey ? -1 : 1);
+}
+
+function columnDragInsertionIndex(index: number, event: DragEvent): number {
+  const target = event.currentTarget;
+  if (!(target instanceof HTMLElement)) return index;
+  const rect = target.getBoundingClientRect();
+  return event.clientY > rect.top + rect.height / 2 ? index + 1 : index;
+}
+
+function toggleDropColumn(column: EditableStructureColumn) {
+  if (!canDropColumn(column)) return;
+  column.markedForDrop = !column.markedForDrop;
+}
+
+function isColumnNameDisabled(column: EditableStructureColumn): boolean {
+  return column.markedForDrop || (!!column.original && !structureCapabilities.value.renameColumn);
+}
+
+function isColumnTypeDisabled(column: EditableStructureColumn): boolean {
+  return column.markedForDrop || (!!column.original && !structureCapabilities.value.alterType);
+}
+
+function isColumnLengthDisabled(column: EditableStructureColumn): boolean {
+  if (isColumnTypeDisabled(column)) {
+    return true;
+  }
+  const baseType = splitDataType(column.dataType).baseType.trim().toLowerCase();
+  return isDataTypeLengthDisabled(databaseType.value, baseType);
+}
+
+function isColumnNullableDisabled(column: EditableStructureColumn): boolean {
+  return column.markedForDrop || column.isPrimaryKey || (!!column.original && !structureCapabilities.value.alterNullability);
+}
+
+function isColumnDefaultDisabled(column: EditableStructureColumn): boolean {
+  return column.markedForDrop || (!!column.original && !structureCapabilities.value.alterDefault);
+}
+
+function isColumnCommentDisabled(column: EditableStructureColumn): boolean {
+  return column.markedForDrop || !structureCapabilities.value.comment;
+}
+
+function isColumnCharsetDisabled(column: EditableStructureColumn): boolean {
+  if (column.markedForDrop) return true;
+  if (!showCharacterSet.value) return true;
+  return !isMysqlCharacterDataType(column.dataType);
+}
+
+function isPrimaryKeyDisabled(column: EditableStructureColumn): boolean {
+  if (column.markedForDrop) return true;
+  if (!column.original) return false;
+  return !structureCapabilities.value.alterPrimaryKey;
+}
+
+function canDropColumn(column: EditableStructureColumn): boolean {
+  return !!column.original && !column.isPrimaryKey && !isProtectedManticoreIdColumn(databaseType.value, column.original.name) && structureCapabilities.value.dropColumn;
+}
+
+function isManticoreColumnPropertyDisabled(column: EditableStructureColumn): boolean {
+  return !canEditManticoreColumnProperties(databaseType.value, !!column.original) || column.markedForDrop;
+}
+
+function addIndex() {
+  if (!structureCapabilities.value.createIndex || indexesLoading.value) return;
+  activeTab.value = "indexes";
+  indexes.value.push({
+    id: `new:${uuid()}`,
+    name: "",
+    columns: [],
+    nameEdited: false,
+    isUnique: false,
+    isPrimary: false,
+    filter: "",
+    indexType: "",
+    includedColumns: [],
+    comment: "",
+    markedForDrop: false,
+  });
+  void nextTick(() => {
+    const indexRows = rootRef.value?.querySelectorAll<HTMLElement>('[data-new-index-row="true"]');
+    const row = indexRows?.[indexRows.length - 1];
+    const input = row?.querySelector<HTMLInputElement>("[data-index-name-input]");
+    row?.scrollIntoView({ block: "nearest" });
+    input?.focus();
+    input?.select();
+  });
+}
+
+function structureIndexTableName(): string {
+  return (isCreateMode.value ? newTableName.value : props.tableName).trim();
+}
+
+function existingIndexNamesForDraft(index: EditableStructureIndex): string[] {
+  return indexes.value.filter((item) => item.id !== index.id && !item.markedForDrop).map((item) => item.name);
+}
+
+function generatedIndexNameForDraft(index: EditableStructureIndex, columnsForName = index.columns): string {
+  return generateUniqueIndexName(structureIndexTableName(), columnsForName, existingIndexNamesForDraft(index));
+}
+
+function refreshAutoIndexName(index: EditableStructureIndex, previousColumns = index.columns) {
+  if (index.original || index.nameEdited) return;
+  const previousName = generateIndexName(structureIndexTableName(), previousColumns);
+  const previousUniqueName = generateUniqueIndexName(structureIndexTableName(), previousColumns, existingIndexNamesForDraft(index));
+  const currentName = index.name.trim();
+  if (currentName && currentName !== previousName && currentName !== previousUniqueName) return;
+  index.name = generatedIndexNameForDraft(index);
+}
+
+function onIndexNameInput(index: EditableStructureIndex, value: string | number) {
+  index.name = String(value ?? "");
+  index.nameEdited = true;
+}
+
+const availableColumnNames = computed(() =>
+  columns.value
+    .filter((c) => !c.markedForDrop)
+    .map((c) => c.name)
+    .filter(Boolean),
+);
+
+const colSearch = ref("");
+const filteredColumnNames = computed(() => {
+  const q = colSearch.value.toLowerCase().trim();
+  if (!q) return availableColumnNames.value;
+  return availableColumnNames.value.filter((c) => c.toLowerCase().includes(q));
+});
+
+function toggleIndexColumn(index: EditableStructureIndex, col: string) {
+  const previousColumns = [...index.columns];
+  const i = index.columns.indexOf(col);
+  if (i >= 0) index.columns.splice(i, 1);
+  else index.columns.push(col);
+  refreshAutoIndexName(index, previousColumns);
+}
+
+function toggleIncludedColumn(index: EditableStructureIndex, col: string) {
+  if (!structureCapabilities.value.indexInclude) return;
+  const i = index.includedColumns.indexOf(col);
+  if (i >= 0) index.includedColumns.splice(i, 1);
+  else index.includedColumns.push(col);
+}
+
+function removeNewIndex(index: EditableStructureIndex) {
+  indexes.value = indexes.value.filter((item) => item.id !== index.id);
+}
+
+function toggleDropIndex(index: EditableStructureIndex) {
+  if (!canDropIndex(index)) return;
+  index.markedForDrop = !index.markedForDrop;
+}
+
+function canEditIndexDraft(index: EditableStructureIndex): boolean {
+  if (indexesLoading.value) return false;
+  if (index.markedForDrop || index.isPrimary) return false;
+  if (!index.original) return structureCapabilities.value.createIndex;
+  return structureCapabilities.value.rebuildIndex && structureCapabilities.value.createIndex && structureCapabilities.value.dropIndex;
+}
+
+function canEditIndexFilter(index: EditableStructureIndex): boolean {
+  return canEditIndexDraft(index) && structureCapabilities.value.indexFilter;
+}
+
+function canEditIndexComment(index: EditableStructureIndex): boolean {
+  return canEditIndexDraft(index) && structureCapabilities.value.indexComment;
+}
+
+function canDropIndex(index: EditableStructureIndex): boolean {
+  if (indexesLoading.value) return false;
+  return !!index.original && !index.isPrimary && structureCapabilities.value.dropIndex;
+}
+
+const canEditForeignKeys = computed(() => structureCapabilities.value.foreignKey);
+const canEditMysqlTriggers = computed(() => structureDialect.value === "mysql");
+
+function generatedForeignKeyName(column = ""): string {
+  const table = structureIndexTableName() || "table";
+  const suffix = column || "column";
+  const base = `fk_${table}_${suffix}`
+    .replace(/[^a-zA-Z0-9_]+/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "");
+  const taken = new Set(foreignKeys.value.map((item) => item.name.trim().toLowerCase()).filter(Boolean));
+  if (!taken.has(base.toLowerCase())) return base;
+  for (let counter = 2; counter < 10_000; counter++) {
+    const candidate = `${base}_${counter}`;
+    if (!taken.has(candidate.toLowerCase())) return candidate;
+  }
+  return base;
+}
+
+function addForeignKey() {
+  if (!canEditForeignKeys.value || foreignKeysLoading.value) return;
+  activeTab.value = "foreignKeys";
+  foreignKeys.value.push({
+    id: `new:${uuid()}`,
+    name: generatedForeignKeyName(),
+    column: "",
+    refSchema: "",
+    refTable: "",
+    refColumn: "",
+    onUpdate: "",
+    onDelete: "",
+    markedForDrop: false,
+  });
+}
+
+function removeNewForeignKey(foreignKey: EditableStructureForeignKey) {
+  foreignKeys.value = foreignKeys.value.filter((item) => item.id !== foreignKey.id);
+}
+
+function toggleDropForeignKey(foreignKey: EditableStructureForeignKey) {
+  if (foreignKeysLoading.value || !foreignKey.original) return;
+  foreignKey.markedForDrop = !foreignKey.markedForDrop;
+}
+
+function canEditForeignKeyDraft(foreignKey: EditableStructureForeignKey): boolean {
+  return !foreignKeysLoading.value && canEditForeignKeys.value && !foreignKey.markedForDrop;
+}
+
+function addTrigger() {
+  if (!canEditMysqlTriggers.value || triggersLoading.value) return;
+  activeTab.value = "triggers";
+  triggers.value.push({
+    id: `new:${uuid()}`,
+    name: "",
+    timing: "BEFORE",
+    event: "INSERT",
+    statement: "BEGIN\n  \nEND",
+    markedForDrop: false,
+  });
+}
+
+function removeNewTrigger(trigger: EditableStructureTrigger) {
+  triggers.value = triggers.value.filter((item) => item.id !== trigger.id);
+}
+
+function toggleDropTrigger(trigger: EditableStructureTrigger) {
+  if (triggersLoading.value || !trigger.original) return;
+  trigger.markedForDrop = !trigger.markedForDrop;
+}
+
+function canEditTriggerDraft(trigger: EditableStructureTrigger): boolean {
+  return !triggersLoading.value && canEditMysqlTriggers.value && !trigger.markedForDrop;
+}
+
+function primarySqlOperation(sql: string): string {
+  const statement = sql
+    .split(";")
+    .map((part) => part.trim())
+    .find(Boolean);
+  return statement?.match(/^([a-z]+)/i)?.[1]?.toUpperCase() || "SQL";
+}
+
+async function recordStructureHistory(sql: string, start: number, success: boolean, result?: { affected_rows?: number }, error?: string) {
+  const connection = store.getConfig(props.connectionId);
+  try {
+    await historyStore.add({
+      connection_id: props.connectionId,
+      connection_name: connection?.name || "",
+      database: props.database,
+      sql,
+      execution_time_ms: Date.now() - start,
+      success,
+      error,
+      activity_kind: "schema_change",
+      operation: hasSqliteTypeChange.value ? "ALTER TABLE" : primarySqlOperation(sql),
+      target: isCreateMode.value ? newTableName.value.trim() : props.tableName,
+      affected_rows: success ? result?.affected_rows : undefined,
+    });
+  } catch (e) {
+    console.warn("[DBX][structure-history:save-failed]", e);
+  }
+}
+
+async function copyPreviewSql() {
+  if (!previewSqlText.value.trim()) return;
+  try {
+    await copyToClipboard(previewSqlText.value);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+
+function toggleSqlPreviewCollapsed() {
+  sqlPreviewCollapsed.value = !sqlPreviewCollapsed.value;
+  safeLocalStorageSet(STRUCTURE_SQL_PREVIEW_COLLAPSED_STORAGE_KEY, String(sqlPreviewCollapsed.value));
+}
+
+async function applyChanges() {
+  if (!canApply.value || !props.connectionId || !props.database) return;
+  const sql = previewSqlText.value;
+  const connection = store.getConfig(props.connectionId);
+  const productionContext = productionContextForDatabase(connection, props.database);
+  if (productionContext.active) {
+    const confirmed = await productionSafetyStore.requestConfirmation({
+      sql,
+      connectionName: connection?.name,
+      database: props.database,
+      productionDatabases: productionContext.databases,
+      source: t("production.sourceStructure"),
+    });
+    if (!confirmed) return;
+  }
+  saving.value = true;
+  errorMessage.value = "";
+  const refreshScope = captureStructureRefreshScope();
+  const startedAt = Date.now();
+  try {
+    const result = hasSqliteTypeChange.value
+      ? await api.applySqliteTableStructureChange(props.connectionId, props.database, structureChangeOptions(), sqliteSchemaRevision.value!)
+      : await api.executeBatch(props.connectionId, props.database, pendingStatements.value, props.schema, queryTimeoutSecsForConnection(connection));
+    await recordStructureHistory(sql, startedAt, true, result);
+    toast(t("structureEditor.saved"), 2500);
+    pendingStatements.value = [];
+    warnings.value = [];
+    sqliteSchemaRevision.value = undefined;
+    ddlFetched.value = false;
+    ddlContent.value = "";
+    if (isCreateMode.value) {
+      clearDraft();
+      emit("saved", tableComment.value !== originalTableComment.value);
+      emit("close");
+    } else {
+      // Refresh persisted keys after successful renames/additions before metadata reloads.
+      persistLocalColumnOrder(false);
+      saving.value = false;
+      postSaveRefreshing.value = true;
+      skipNextRefreshVersion = true;
+      emit("saved", tableComment.value !== originalTableComment.value);
+      void refreshStructureAfterSave(refreshScope);
+    }
+  } catch (e: any) {
+    errorMessage.value = e?.message || String(e);
+    await recordStructureHistory(sql, startedAt, false, undefined, errorMessage.value);
+  } finally {
+    saving.value = false;
+  }
+}
+
+function addItemForActiveTab(): boolean {
+  if (activeTab.value === "columns" && canAddColumn.value) {
+    void addColumn();
+    return true;
+  }
+  if (activeTab.value === "indexes" && structureCapabilities.value.createIndex) {
+    addIndex();
+    return true;
+  }
+  if (activeTab.value === "foreignKeys" && canEditForeignKeys.value) {
+    addForeignKey();
+    return true;
+  }
+  if (activeTab.value === "triggers" && canEditMysqlTriggers.value) {
+    addTrigger();
+    return true;
+  }
+  return false;
+}
+
+function onStructureEditorKeydown(event: KeyboardEvent) {
+  if (isPlainModShortcut(event, "f")) {
+    event.preventDefault();
+    event.stopPropagation();
+    if (activeTab.value === "columns") focusColumnSearch();
+    return;
+  }
+  if (isPlainModShortcut(event, "s")) {
+    event.preventDefault();
+    event.stopPropagation();
+    void applyChanges();
+    return;
+  }
+  if (isPlainModShortcut(event, "n")) {
+    event.preventDefault();
+    event.stopPropagation();
+    addItemForActiveTab();
+  }
+}
+
+function registerStructureEditorShortcuts() {
+  if (keydownListenerRegistered) return;
+  keydownListenerRegistered = true;
+  window.addEventListener("keydown", onStructureEditorKeydown);
+  document.addEventListener("pointerdown", onStructureDensityDocumentPointerdown, true);
+}
+
+function unregisterStructureEditorShortcuts() {
+  if (!keydownListenerRegistered) return;
+  keydownListenerRegistered = false;
+  window.removeEventListener("keydown", onStructureEditorKeydown);
+  document.removeEventListener("pointerdown", onStructureDensityDocumentPointerdown, true);
+}
+
+onMounted(() => {
+  resetState();
+  applyInitialStructureTab();
+  applyInitialStructureTarget();
+  registerStructureEditorShortcuts();
+  void loadDynamicDataTypeOptions();
+  if (props.draft?.initialized) {
+    restoreDraft(props.draft);
+    // A restored draft owns its saved tab unless navigation explicitly requested another one.
+    applyInitialStructureTab(false);
+    applyInitialStructureTarget();
+    void hydrateRestoredDraftFromDatabase().then(() => applyInitialStructureTarget());
+  } else if (isCreateMode.value) {
+    markDraftHydratedAndSync();
+  } else {
+    void loadStructure(false, FULL_STRUCTURE_REFRESH_SCOPE, true, { blockSecondaryMetadata: true }).then(() => applyInitialStructureTarget());
+  }
+});
+
+onActivated(() => {
+  registerStructureEditorShortcuts();
+  void loadDynamicDataTypeOptions();
+  if (props.draft?.initialized && !draftHydrated) {
+    restoreDraft(props.draft);
+    applyInitialStructureTarget();
+    void hydrateRestoredDraftFromDatabase().then(() => applyInitialStructureTarget());
+  }
+  restoreStructureScrollPosition();
+});
+onDeactivated(unregisterStructureEditorShortcuts);
+onBeforeUnmount(() => {
+  stopColumnDragTracking();
+  unregisterStructureEditorShortcuts();
+  clearSqlPreviewState();
+  if (columnHighlightTimer) window.clearTimeout(columnHighlightTimer);
+  if (indexHighlightTimer) window.clearTimeout(indexHighlightTimer);
+  if (structureScrollFrame) window.cancelAnimationFrame(structureScrollFrame);
+  persistStructureDensity();
+});
+
+function localFirstStructureMetadataTab(capabilities = tableMetadataCapabilities.value) {
+  return firstStructureMetadataTab(capabilities, isCreateMode.value);
+}
+
+function localIsStructureMetadataTabSupported(tab: TableInfoTab, capabilities = tableMetadataCapabilities.value) {
+  return isStructureMetadataTabSupported(tab, capabilities, isCreateMode.value);
+}
+
+function resolveStructureMetadataTab(tab: TableInfoTab | undefined, capabilities = tableMetadataCapabilities.value): TableInfoTab {
+  if (tab && localIsStructureMetadataTabSupported(tab, capabilities)) return tab;
+  return localFirstStructureMetadataTab(capabilities);
+}
+
+function applyInitialStructureTab(useDefault = true) {
+  if (props.initialTab) {
+    activeTab.value = resolveStructureMetadataTab(props.initialTab);
+  } else if (useDefault) {
+    activeTab.value = resolveStructureMetadataTab(undefined);
+  }
+}
+
+function initialTargetKey(target: TableStructureEditorTarget): string {
+  return `${props.initialTabRequestId ?? 0}:${target.kind}:${target.name}`;
+}
+
+function applyInitialStructureTarget() {
+  const target = props.initialTarget;
+  const targetName = target?.name.trim();
+  if (!target || !targetName) return;
+
+  const key = initialTargetKey(target);
+  if (appliedInitialTargetSearchKey !== key) {
+    if (target.kind === "column") {
+      activeTab.value = resolveStructureMetadataTab("columns");
+      columnSearchText.value = targetName;
+      highlightedColumnId.value = null;
+    } else {
+      activeTab.value = resolveStructureMetadataTab("indexes");
+      indexSearchText.value = targetName;
+      highlightedIndexId.value = null;
+    }
+    appliedInitialTargetSearchKey = key;
+  }
+
+  if (appliedInitialTargetScrollKey === key) return;
+  const hasMatch = target.kind === "column" ? columns.value.some((column) => columnMatchesSearch(column)) : indexes.value.some((index) => indexMatchesSearch(index));
+  if (!hasMatch) return;
+  appliedInitialTargetScrollKey = key;
+  void nextTick(() => {
+    if (target.kind === "column") {
+      scrollToColumnSearchMatch(1);
+    } else {
+      scrollToIndexSearchMatch(1);
+    }
+  });
+}
+
+watch(tableMetadataCapabilities, (capabilities) => {
+  if (!localIsStructureMetadataTabSupported(activeTab.value, capabilities)) activeTab.value = localFirstStructureMetadataTab(capabilities);
+});
+
+watch([() => props.initialTab, () => props.initialTabRequestId, () => props.initialTarget], () => {
+  if (props.initialTab) applyInitialStructureTab();
+  applyInitialStructureTarget();
+});
+
+watch([columns, indexes], () => {
+  applyInitialStructureTarget();
+});
+
+watch([() => props.connectionId, () => props.database, databaseType], () => {
+  void loadDynamicDataTypeOptions();
+});
+
+watch(
+  [isCreateMode, () => props.connectionId, () => props.database, databaseType, () => props.schema, () => props.tableName, newTableName, tableComment, columns, indexes, foreignKeys, triggers],
+  () => {
+    scheduleSqlPreviewRefresh();
+    syncDraftToParent();
+  },
+  { deep: true, immediate: true },
+);
+
+watch(activeTab, () => {
+  highlightedColumnId.value = null;
+  highlightedIndexId.value = null;
+  restoreStructureScrollPosition();
+  syncDraftToParent();
+});
+
+watch(secondaryMetadataLoading, (value) => {
+  if (value || !deferredSqlPreviewRefresh) return;
+  scheduleSqlPreviewRefresh();
+});
+
+watch([() => props.tableName, newTableName], () => {
+  for (const index of indexes.value) {
+    refreshAutoIndexName(index);
+  }
+});
+
+watch(refreshVersion, (version, previous) => {
+  if (version === previous || !version || isCreateMode.value) return;
+  if (skipNextRefreshVersion) {
+    skipNextRefreshVersion = false;
+    return;
+  }
+  void loadStructure(true);
+});
+
+watch(
+  activeTab,
+  (tab) => {
+    if (tab === "ddl") {
+      void fetchDdl();
+    }
+  },
+  { immediate: true },
+);
+
+watch([activeTab, ddlLoading], ([tab, loading]) => {
+  if (tab === "ddl" && !loading) {
+    void nextTick(() => {
+      ddlPreRef.value?.focus();
+    });
+  }
+});
+</script>
+
+<template>
+  <div ref="rootRef" class="flex h-full min-h-0 flex-col gap-2 overflow-hidden p-[var(--structure-shell-padding)] text-[length:var(--structure-font-size)]" :data-structure-density="localStructureDensity" :style="structureDensityStyle">
+    <div class="flex shrink-0 items-center gap-2 rounded-md border bg-muted/20 px-[var(--structure-cell-px)] py-[var(--structure-header-py)] text-[length:var(--structure-font-size)]">
+      <Database :class="[structureIconClass, 'text-muted-foreground']" />
+      <span class="min-w-0 flex-1 truncate font-medium">{{ targetLabel || t("editor.noDatabase") }}</span>
+      <Badge variant="outline">{{ connection?.driver_label || databaseType }}</Badge>
+      <Button v-if="!isCreateMode" variant="ghost" size="sm" :class="structureToolbarButtonClass" :disabled="loading || saving" @click="reloadStructureFromDatabase">
+        <RefreshCw :class="structureIconClass" />
+        {{ t("structureEditor.refresh") }}
+      </Button>
+    </div>
+
+    <div v-if="isCreateMode" class="flex shrink-0 items-center gap-2">
+      <label class="shrink-0 font-medium text-muted-foreground">{{ t("structureEditor.tableName") }}</label>
+      <Input v-model="newTableName" :placeholder="t('contextMenu.duplicateNamePlaceholder')" :class="[structureControlClass, 'max-w-[220px]']" />
+    </div>
+
+    <div class="flex shrink-0 items-center gap-2">
+      <label class="shrink-0 font-medium text-muted-foreground">{{ t("structureEditor.comment") }}</label>
+      <Input v-model="tableComment" :placeholder="t('structureEditor.tableCommentPlaceholder')" :class="[structureControlClass, 'max-w-[320px]']" :disabled="isTableCommentDisabled" />
+      <Tooltip v-if="isTableCommentDisabled">
+        <TooltipTrigger as-child>
+          <Info :class="[structureIconClass, 'shrink-0 text-muted-foreground']" />
+        </TooltipTrigger>
+        <TooltipContent>{{ t("structureEditor.tableCommentUnsupported") }}</TooltipContent>
+      </Tooltip>
+    </div>
+
+    <div v-if="loading" class="flex min-h-0 flex-1 items-center justify-center gap-2 text-[length:var(--structure-font-size)] text-muted-foreground">
+      <Loader2 class="h-4 w-4 animate-spin" />
+      {{ t("common.loading") }}
+    </div>
+
+    <div v-else class="flex min-h-0 flex-1 flex-col gap-2 overflow-hidden">
+      <div class="min-h-0 min-w-0 flex-1 overflow-hidden rounded-md border">
+        <Tabs v-model="activeTab" class="flex h-full min-h-0 flex-col">
+          <div class="flex shrink-0 items-center justify-between gap-2 border-b px-2 py-[var(--structure-header-py)]">
+            <TabsList>
+              <TabsTrigger v-if="tableMetadataCapabilities.ddl && !isCreateMode" value="ddl">DDL</TabsTrigger>
+              <TabsTrigger v-if="tableMetadataCapabilities.columns" value="columns">{{ t("structureEditor.columns") }}</TabsTrigger>
+              <TabsTrigger v-if="tableMetadataCapabilities.indexes" value="indexes">{{ t("structureEditor.indexes") }}</TabsTrigger>
+              <TabsTrigger v-if="tableMetadataCapabilities.foreignKeys" value="foreignKeys">{{ t("structureEditor.foreignKeys") }}</TabsTrigger>
+              <TabsTrigger v-if="tableMetadataCapabilities.triggers" value="triggers">{{ t("structureEditor.triggers") }}</TabsTrigger>
+            </TabsList>
+            <div class="flex shrink-0 items-center gap-1.5">
+              <div class="flex items-center gap-1.5">
+                <SlidersHorizontal :class="[structureIconClass, 'text-muted-foreground']" />
+                <div ref="structureDensityMenuRef" class="relative">
+                  <button
+                    type="button"
+                    class="grid h-[var(--structure-control-height)] min-w-[76px] grid-cols-[1fr_var(--structure-control-height)] items-center rounded-[6px] border bg-background pl-[var(--structure-control-px)] text-[length:var(--structure-font-size)] outline-none hover:bg-muted focus-visible:border-ring/50 focus-visible:ring-1 focus-visible:ring-ring/25"
+                    :aria-label="t('structureEditor.density')"
+                    :aria-expanded="structureDensityMenuOpen"
+                    aria-haspopup="listbox"
+                    @click="toggleStructureDensityMenu"
+                    @keydown="onStructureDensityKeydown"
+                  >
+                    <span class="min-w-0 text-center truncate">{{ structureDensityOptions.find((option) => option.value === localStructureDensity)?.label }}</span>
+                    <span class="flex h-full items-center justify-center">
+                      <ChevronDown :class="[structureIconClass, 'shrink-0 opacity-50']" />
+                    </span>
+                  </button>
+                  <div v-if="structureDensityMenuOpen" class="absolute right-0 top-[calc(100%+4px)] z-50 min-w-full rounded-[6px] bg-popover p-1 text-popover-foreground shadow-md ring-1 ring-foreground/10" role="listbox" :aria-label="t('structureEditor.density')">
+                    <button
+                      v-for="option in structureDensityOptions"
+                      :key="option.value"
+                      type="button"
+                      class="flex h-7 w-full items-center rounded-[6px] px-1.5 text-left text-[length:var(--structure-font-size)] outline-none hover:bg-accent hover:text-accent-foreground"
+                      :class="option.value === localStructureDensity ? 'bg-accent text-accent-foreground' : ''"
+                      role="option"
+                      :aria-selected="option.value === localStructureDensity"
+                      @click="selectStructureDensity(option.value)"
+                    >
+                      {{ option.label }}
+                    </button>
+                  </div>
+                </div>
+              </div>
+              <div v-if="activeTab === 'columns'" class="relative flex w-40 shrink-0 items-center">
+                <Search :class="[structureIconClass, 'pointer-events-none absolute left-2 text-muted-foreground']" />
+                <Input
+                  ref="columnSearchInputRef"
+                  v-model="columnSearchText"
+                  :placeholder="t('structureEditor.searchColumns')"
+                  :class="[structureControlClass, 'pl-7 pr-14 text-[length:var(--structure-font-size)] placeholder:text-[length:var(--structure-font-size)]']"
+                  @keydown="onColumnSearchKeydown"
+                />
+                <button
+                  v-if="columnSearchText"
+                  type="button"
+                  class="absolute right-1.5 top-1/2 -translate-y-1/2 rounded px-1 text-[length:var(--structure-font-size)] text-muted-foreground hover:bg-muted hover:text-foreground"
+                  :title="t('structureEditor.nextColumnMatch')"
+                  @click="scrollToColumnSearchMatch(1)"
+                >
+                  {{ columnSearchMatchCount }}
+                </button>
+              </div>
+              <Button v-if="activeTab === 'columns'" size="sm" :class="structureToolbarButtonClass" :disabled="!canAddColumn" @click="addColumn">
+                <Plus :class="structureIconClass" />
+                {{ t("structureEditor.addColumn") }}
+              </Button>
+              <Button v-if="isCreateMode && activeTab === 'columns'" size="sm" variant="outline" :class="structureToolbarButtonClass" :disabled="!canAddColumn" @click="applyColumnTemplate(PRESET_FIELDS_TEMPLATE_ID)">
+                <Copy :class="structureIconClass" />
+                {{ t("structureEditor.columnTemplates") }}
+              </Button>
+              <Tooltip v-if="isCreateMode && activeTab === 'columns'">
+                <TooltipTrigger as-child>
+                  <Button size="sm" variant="ghost" :class="structureToolbarButtonClass" :disabled="!canAddColumn" :aria-label="t('structureEditor.configureColumnTemplates')" @click="emit('openSettings', 'data', 'tableColumnTemplates')">
+                    <Settings :class="structureIconClass" />
+                  </Button>
+                </TooltipTrigger>
+                <TooltipContent>{{ t("structureEditor.configureColumnTemplates") }}</TooltipContent>
+              </Tooltip>
+              <div v-if="activeTab === 'indexes'" class="relative flex w-40 shrink-0 items-center">
+                <Search :class="[structureIconClass, 'pointer-events-none absolute left-2 text-muted-foreground']" />
+                <Input ref="indexSearchInputRef" v-model="indexSearchText" :placeholder="t('structureEditor.searchIndexes')" :class="[structureControlClass, 'pl-7 pr-14 text-[length:var(--structure-font-size)] placeholder:text-[length:var(--structure-font-size)]']" @keydown="onIndexSearchKeydown" />
+                <button
+                  v-if="indexSearchText"
+                  type="button"
+                  class="absolute right-1.5 top-1/2 -translate-y-1/2 rounded px-1 text-[length:var(--structure-font-size)] text-muted-foreground hover:bg-muted hover:text-foreground"
+                  :title="t('structureEditor.nextIndexMatch')"
+                  @click="scrollToIndexSearchMatch(1)"
+                >
+                  {{ indexSearchMatchCount }}
+                </button>
+              </div>
+              <Button v-if="activeTab === 'indexes'" size="sm" :class="structureToolbarButtonClass" :disabled="!structureCapabilities.createIndex || indexesLoading" @click="addIndex">
+                <Plus :class="structureIconClass" />
+                {{ t("structureEditor.addIndex") }}
+              </Button>
+              <Button v-if="activeTab === 'foreignKeys'" size="sm" :class="structureToolbarButtonClass" :disabled="!canEditForeignKeys || foreignKeysLoading" @click="addForeignKey">
+                <Plus :class="structureIconClass" />
+                {{ t("structureEditor.addForeignKey") }}
+              </Button>
+              <Button v-if="activeTab === 'triggers'" size="sm" :class="structureToolbarButtonClass" :disabled="!canEditMysqlTriggers || triggersLoading" @click="addTrigger">
+                <Plus :class="structureIconClass" />
+                {{ t("structureEditor.addTrigger") }}
+              </Button>
+            </div>
+          </div>
+
+          <TabsContent ref="columnsScrollerRef" v-if="tableMetadataCapabilities.columns" value="columns" class="m-0 min-h-0 flex-1 overflow-auto p-0" @scroll.passive="onStructureContentScroll('columns', $event)">
+            <table class="border-separate border-spacing-0 text-[length:var(--structure-font-size)] leading-[var(--structure-line-height)]" :style="{ minWidth: visibleColWidths.reduce((a, w) => a + w, 0) + 'px' }">
+              <thead class="sticky top-0 z-10 bg-background">
+                <tr>
+                  <th
+                    v-for="(columnLabel, i) in colLabels"
+                    :key="columnLabel.key"
+                    :class="[structureHeaderCellClass, { 'text-center': columnLabel.key === 'primaryKey' }]"
+                    :style="{
+                      width: visibleColWidths[i] + 'px',
+                      minWidth: visibleColWidths[i] + 'px',
+                    }"
+                  >
+                    {{ columnLabel.label }}
+                    <div v-if="i < colLabels.length - 1" class="absolute right-0 top-0 z-20 h-full w-1 cursor-col-resize hover:bg-primary/30" :class="colResizing?.col === columnWidthIndex(i) ? 'bg-primary/30' : ''" @mousedown="onColResize($event, i)" />
+                  </th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr v-for="(column, index) in columns" :key="column.id" :class="columnRowClass(column, index)" :data-new-column-row="!column.original ? 'true' : undefined" :data-column-row-index="index" @dragover="onColumnDragOver(index, $event)" @drop="onColumnDrop(index, $event)">
+                  <td :class="[structureCellClass, 'text-muted-foreground']">
+                    <div class="flex items-center gap-1">
+                      <span>{{ index + 1 }}</span>
+                      <KeyRound v-if="column.isPrimaryKey" :class="[structureIconClass, 'text-amber-500']" />
+                    </div>
+                  </td>
+                  <td :class="structureCellClass">
+                    <Input v-model="column.name" :class="[structureControlClass, columnSearchFieldClass(column, column.name)]" :disabled="isColumnNameDisabled(column)" data-column-name-input />
+                  </td>
+                  <td :class="structureCellClass">
+                    <SearchableSelect
+                      v-if="!isColumnTypeDisabled(column)"
+                      :model-value="splitDataType(column.dataType).baseType"
+                      :options="dataTypeOptions"
+                      :placeholder="t('structureEditor.typePlaceholder')"
+                      :search-placeholder="t('structureEditor.typePlaceholder')"
+                      :empty-text="t('structureEditor.noMatchingType')"
+                      :loading-text="t('common.loading')"
+                      :allow-custom="true"
+                      :option-tooltip="dataTypeTooltip"
+                      :trigger-class="[structureMonoControlClass, 'w-full']"
+                      @update:model-value="(v: string) => updateColumnDataType(column, v)"
+                    />
+                    <Input v-else :model-value="splitDataType(column.dataType).baseType" :class="[structureMonoControlClass, 'w-full']" disabled />
+                  </td>
+                  <td v-if="columnEditorControls.length" :class="structureCellClass">
+                    <Popover v-if="isMysqlEnumDataType(databaseType, column.dataType)">
+                      <PopoverTrigger as-child>
+                        <Button variant="outline" size="sm" :class="[structureMonoControlClass, 'w-full justify-between px-2']" :disabled="isColumnTypeDisabled(column)">
+                          <span>{{ t("structureEditor.enumValueCount", { count: column.enumValues?.length ?? 0 }) }}</span>
+                          <ListChevronsUpDown :class="structureIconClass" />
+                        </Button>
+                      </PopoverTrigger>
+                      <PopoverContent class="w-80 p-3" align="start">
+                        <div class="mb-2 flex items-center justify-between gap-2">
+                          <span class="text-sm font-medium">{{ t("structureEditor.enumValues") }}</span>
+                          <Button variant="outline" size="sm" class="h-7 px-2" @click="addMysqlEnumValue(column)">
+                            <Plus class="mr-1 h-3.5 w-3.5" />
+                            {{ t("structureEditor.addEnumValue") }}
+                          </Button>
+                        </div>
+                        <div class="max-h-64 space-y-1.5 overflow-y-auto pr-1">
+                          <div v-for="(value, valueIndex) in column.enumValues" :key="valueIndex" class="flex items-center gap-1.5">
+                            <Input :model-value="value" :class="structureMonoControlClass" :placeholder="t('structureEditor.enumValuePlaceholder')" @update:model-value="updateMysqlEnumValue(column, valueIndex, $event)" />
+                            <Button variant="ghost" size="icon" class="h-8 w-8 shrink-0" :disabled="(column.enumValues?.length ?? 0) <= 1" :title="t('structureEditor.removeEnumValue')" @click="removeMysqlEnumValue(column, valueIndex)">
+                              <Trash2 class="h-3.5 w-3.5" />
+                            </Button>
+                          </div>
+                        </div>
+                      </PopoverContent>
+                    </Popover>
+                    <Input v-else :model-value="dataTypeLengthInputValue(databaseType, column.dataType)" :class="structureMonoControlClass" :disabled="isColumnLengthDisabled(column)" @update:model-value="updateColumnDataTypeLength(column, $event)" />
+                  </td>
+                  <td v-if="columnEditorControls.nullable" :class="structureCellClass">
+                    <label class="flex items-center gap-1.5">
+                      <input v-model="column.isNullable" type="checkbox" :class="structureCheckboxClass" :disabled="isColumnNullableDisabled(column)" />
+                      <span>{{ column.isNullable ? t("structureEditor.yes") : t("structureEditor.no") }}</span>
+                    </label>
+                  </td>
+                  <td v-if="columnEditorControls.primaryKey" :class="[structureCellClass, 'text-center']">
+                    <input
+                      v-model="column.isPrimaryKey"
+                      type="checkbox"
+                      :class="structureCheckboxClass"
+                      :disabled="isPrimaryKeyDisabled(column)"
+                      @change="
+                        () => {
+                          if (column.isPrimaryKey) column.isNullable = false;
+                        }
+                      "
+                    />
+                  </td>
+                  <td v-if="columnEditorControls.defaultValue" :class="structureCellClass">
+                    <div class="flex min-w-0 items-center gap-1">
+                      <Input v-model="column.defaultValue" :class="[structureMonoControlClass, 'flex-1']" :disabled="isColumnDefaultDisabled(column)" />
+                      <DropdownMenu>
+                        <DropdownMenuTrigger as-child>
+                          <Button variant="ghost" size="icon" :class="[structureIconButtonClass, 'shrink-0']" :disabled="isColumnDefaultDisabled(column)" :aria-label="t('structureEditor.defaultValuePresets')" :title="t('structureEditor.defaultValuePresets')">
+                            <ChevronDown :class="structureIconClass" />
+                          </Button>
+                        </DropdownMenuTrigger>
+                        <DropdownMenuContent align="end" class="max-h-56 min-w-36 overflow-y-auto">
+                          <DropdownMenuItem v-for="preset in defaultValuePresets" :key="preset.value" @click="column.defaultValue = preset.value">
+                            <code class="font-mono text-[length:var(--structure-font-size)]">{{ preset.label }}</code>
+                          </DropdownMenuItem>
+                        </DropdownMenuContent>
+                      </DropdownMenu>
+                    </div>
+                  </td>
+                  <td v-if="columnEditorControls.comment" :class="structureCellClass">
+                    <div class="flex min-w-0 items-center gap-1">
+                      <Input v-model="column.comment" :class="[structureControlClass, 'flex-1', columnSearchFieldClass(column, column.comment)]" :disabled="isColumnCommentDisabled(column)" />
+                      <Popover>
+                        <PopoverTrigger as-child>
+                          <Button variant="ghost" size="icon" :class="[structureIconButtonClass, 'shrink-0']" :disabled="isColumnCommentDisabled(column)" :aria-label="t('structureEditor.editComment')" :title="t('structureEditor.editComment')">
+                            <Maximize2 :class="structureIconClass" />
+                          </Button>
+                        </PopoverTrigger>
+                        <PopoverContent align="end" class="w-[420px] p-2.5">
+                          <div class="mb-2 flex items-center justify-between gap-2">
+                            <span class="min-w-0 truncate text-xs font-medium">
+                              {{ t("structureEditor.editComment") }}
+                            </span>
+                            <span class="max-w-44 truncate font-mono text-[length:var(--structure-font-size)] text-muted-foreground">
+                              {{ column.name || t("structureEditor.columnName") }}
+                            </span>
+                          </div>
+                          <textarea
+                            v-model="column.comment"
+                            class="min-h-36 w-full resize-y rounded-[6px] border bg-background px-[var(--structure-control-px)] py-[var(--structure-cell-py)] text-[length:var(--structure-font-size)] leading-5 outline-none focus-visible:border-ring/50 focus-visible:ring-1 focus-visible:ring-ring/25 disabled:cursor-not-allowed disabled:opacity-50"
+                            :placeholder="t('structureEditor.commentPlaceholder')"
+                            :disabled="isColumnCommentDisabled(column)"
+                          />
+                        </PopoverContent>
+                      </Popover>
+                    </div>
+                  </td>
+                  <td v-if="showCharacterSet" :class="structureCellClass">
+                    <SearchableSelect
+                      :model-value="columnCharset(column)"
+                      :options="mysqlCharsetOptions"
+                      :placeholder="t('structureEditor.charsetPlaceholder')"
+                      :search-placeholder="t('structureEditor.charsetPlaceholder')"
+                      :empty-text="t('structureEditor.noMatchingType')"
+                      :allow-custom="true"
+                      :disabled="isColumnCharsetDisabled(column)"
+                      :trigger-class="[structureMonoControlClass, 'w-20']"
+                      @update:model-value="(v: string) => onCharsetChange(column, v)"
+                    />
+                  </td>
+                  <td v-if="showCharacterSet" :class="structureCellClass">
+                    <SearchableSelect
+                      :model-value="columnCollation(column)"
+                      :options="collationOptionsForCharset(columnCharset(column))"
+                      :placeholder="t('structureEditor.collationPlaceholder')"
+                      :search-placeholder="t('structureEditor.collationPlaceholder')"
+                      :empty-text="t('structureEditor.noMatchingType')"
+                      :allow-custom="true"
+                      :disabled="isColumnCharsetDisabled(column)"
+                      :trigger-class="[structureMonoControlClass, 'w-28']"
+                      @update:model-value="(v: string) => (column.collation = v)"
+                    />
+                  </td>
+                  <td v-if="showExtendedProperties" :class="structureCellClass">
+                    <div :class="structurePropertyListClass">
+                      <!-- Manticore Search: character data type properties -->
+                      <template v-if="databaseType === 'manticoresearch'">
+                        <template v-if="isManticoreTextColumn(column)">
+                          <label :class="structurePropertyLabelClass" title="indexed">
+                            <input :checked="!!column.extra.manticoreIndexed" type="checkbox" :class="[structureCheckboxClass, 'shrink-0']" :disabled="isManticoreColumnPropertyDisabled(column)" @change="column.extra.manticoreIndexed = ($event.target as HTMLInputElement).checked" />
+                            <span class="min-w-0 truncate">indexed</span>
+                          </label>
+                          <label :class="structurePropertyLabelClass" title="stored">
+                            <input :checked="!!column.extra.manticoreStored" type="checkbox" :class="[structureCheckboxClass, 'shrink-0']" :disabled="isManticoreColumnPropertyDisabled(column)" @change="column.extra.manticoreStored = ($event.target as HTMLInputElement).checked" />
+                            <span class="min-w-0 truncate">stored</span>
+                          </label>
+                          <label :class="structurePropertyLabelClass" title="attribute">
+                            <input :checked="!!column.extra.manticoreAttribute" type="checkbox" :class="[structureCheckboxClass, 'shrink-0']" :disabled="isManticoreColumnPropertyDisabled(column)" @change="column.extra.manticoreAttribute = ($event.target as HTMLInputElement).checked" />
+                            <span class="min-w-0 truncate">attribute</span>
+                          </label>
+                        </template>
+                        <template v-else-if="isManticoreJsonColumn(column)">
+                          <label :class="structurePropertyLabelClass" title="secondary_index">
+                            <input :checked="!!column.extra.manticoreSecondaryIndex" type="checkbox" :class="[structureCheckboxClass, 'shrink-0']" :disabled="isManticoreColumnPropertyDisabled(column)" @change="column.extra.manticoreSecondaryIndex = ($event.target as HTMLInputElement).checked" />
+                            <span class="min-w-0 truncate">secondary_index</span>
+                          </label>
+                        </template>
+                      </template>
+                      <!-- MySQL: AUTO_INCREMENT + ON UPDATE CURRENT_TIMESTAMP -->
+                      <template v-else-if="structureDialect === 'mysql'">
+                        <label :class="[structurePropertyLabelClass, 'shrink-0 pr-1']" :title="t('structureEditor.autoIncrement')">
+                          <input v-model="column.extra.autoIncrement" type="checkbox" :class="[structureCheckboxClass, 'shrink-0']" />
+                          <span>{{ t("structureEditor.autoIncrement") }}</span>
+                        </label>
+                        <label :class="[structurePropertyLabelClass, 'flex-1 basis-0']" :title="t('structureEditor.onUpdateCurrentTimestamp')">
+                          <input v-model="column.extra.onUpdateCurrentTimestamp" type="checkbox" :class="[structureCheckboxClass, 'shrink-0']" />
+                          <span class="min-w-0 truncate">{{ t("structureEditor.onUpdateCurrentTimestamp") }}</span>
+                        </label>
+                      </template>
+                      <!-- Dameng: IDENTITY -->
+                      <template v-else-if="databaseType === 'dameng'">
+                        <label :class="structurePropertyLabelClass" :title="t('structureEditor.identity')">
+                          <input :checked="isDamengIdentityChecked(column)" type="checkbox" :class="[structureCheckboxClass, 'shrink-0']" :disabled="!canEditDamengIdentity(column)" @change="setDamengIdentity(column, ($event.target as HTMLInputElement).checked)" />
+                          <span class="min-w-0 truncate">{{ t("structureEditor.autoIncrement") }}</span>
+                        </label>
+                        <template v-if="isDamengIdentityChecked(column)">
+                          <Input
+                            :model-value="column.extra.identity?.seed?.toString() ?? '1'"
+                            type="number"
+                            :class="[structureControlClass, 'w-14']"
+                            :placeholder="t('structureEditor.identitySeed')"
+                            :disabled="!canEditDamengIdentity(column)"
+                            @update:model-value="(v) => updateDamengIdentitySeed(column, v)"
+                          />
+                          <Input
+                            :model-value="column.extra.identity?.increment?.toString() ?? '1'"
+                            type="number"
+                            :class="[structureControlClass, 'w-14']"
+                            :placeholder="t('structureEditor.identityIncrement')"
+                            :disabled="!canEditDamengIdentity(column)"
+                            @update:model-value="(v) => updateDamengIdentityIncrement(column, v)"
+                          />
+                        </template>
+                      </template>
+                      <!-- PostgreSQL: IDENTITY -->
+                      <template v-else-if="structureDialect === 'postgres'">
+                        <Select
+                          :model-value="column.extra.identity?.generation ?? 'none'"
+                          @update:model-value="
+                            (value: any) => {
+                              const generation = String(value ?? '');
+                              if (generation && generation !== 'none') {
+                                column.extra.identity = {
+                                  ...column.extra.identity,
+                                  generation: generation as 'BY DEFAULT' | 'ALWAYS',
+                                };
+                              } else {
+                                column.extra.identity = undefined;
+                              }
+                            }
+                          "
+                        >
+                          <SelectTrigger class="h-[var(--structure-control-height)] w-28 rounded-[6px] px-[var(--structure-control-px)] text-[length:var(--structure-font-size)] focus-visible:border-ring/50 focus-visible:ring-1 focus-visible:ring-ring/25">
+                            <SelectValue />
+                          </SelectTrigger>
+                          <SelectContent>
+                            <SelectItem value="none">{{ t("structureEditor.no") }}</SelectItem>
+                            <SelectItem value="BY DEFAULT">BY DEFAULT</SelectItem>
+                            <SelectItem value="ALWAYS">ALWAYS</SelectItem>
+                          </SelectContent>
+                        </Select>
+                        <template v-if="column.extra.identity?.generation">
+                          <Input
+                            :model-value="column.extra.identity.seed?.toString() ?? ''"
+                            type="number"
+                            :class="[structureControlClass, 'w-14']"
+                            :placeholder="t('structureEditor.identitySeed')"
+                            @update:model-value="
+                              (v) => {
+                                if (column.extra.identity) {
+                                  column.extra.identity.seed = v ? Number(v) : undefined;
+                                }
+                              }
+                            "
+                          />
+                          <Input
+                            :model-value="column.extra.identity.increment?.toString() ?? ''"
+                            type="number"
+                            :class="[structureControlClass, 'w-14']"
+                            :placeholder="t('structureEditor.identityIncrement')"
+                            @update:model-value="
+                              (v) => {
+                                if (column.extra.identity) {
+                                  column.extra.identity.increment = v ? Number(v) : undefined;
+                                }
+                              }
+                            "
+                          />
+                        </template>
+                      </template>
+                      <!-- SQL Server: IDENTITY -->
+                      <template v-else-if="structureDialect === 'sqlserver'">
+                        <label :class="structurePropertyLabelClass" :title="canEditSqlServerIdentity(column) || isSqlServerIdentityChecked(column) ? t('structureEditor.identity') : t('structureEditor.sqlServerIdentityTypeHint')">
+                          <input :checked="isSqlServerIdentityChecked(column)" type="checkbox" :class="[structureCheckboxClass, 'shrink-0']" :disabled="!canEditSqlServerIdentity(column)" @change="setSqlServerIdentity(column, ($event.target as HTMLInputElement).checked)" />
+                          <span class="min-w-0 truncate">{{ t("structureEditor.autoIncrement") }}</span>
+                        </label>
+                        <template v-if="isSqlServerIdentityChecked(column)">
+                          <Input
+                            :model-value="column.extra.identity?.seed?.toString() ?? '1'"
+                            type="number"
+                            :class="[structureControlClass, 'w-14']"
+                            :placeholder="t('structureEditor.identitySeed')"
+                            :disabled="!canEditSqlServerIdentity(column)"
+                            @update:model-value="(v) => updateSqlServerIdentitySeed(column, v)"
+                          />
+                          <Input
+                            :model-value="column.extra.identity?.increment?.toString() ?? '1'"
+                            type="number"
+                            :class="[structureControlClass, 'w-14']"
+                            :placeholder="t('structureEditor.identityIncrement')"
+                            :disabled="!canEditSqlServerIdentity(column)"
+                            @update:model-value="(v) => updateSqlServerIdentityIncrement(column, v)"
+                          />
+                        </template>
+                      </template>
+                    </div>
+                  </td>
+                  <td :class="structureLastCellClass">
+                    <div class="flex min-w-0 items-center justify-start gap-0.5">
+                      <Button
+                        v-if="canShowColumnDragControls"
+                        type="button"
+                        variant="ghost"
+                        size="icon"
+                        :class="[structureActionButtonClass, canDragColumn(index) ? 'cursor-grab active:cursor-grabbing' : 'cursor-not-allowed', hasLocalColumnOrderChange ? 'border-primary/30 bg-primary/10 text-primary hover:bg-primary/15 hover:text-primary' : '']"
+                        :disabled="!canDragColumn(index)"
+                        :title="t('structureEditor.dragColumn')"
+                        :aria-label="t('structureEditor.dragColumn')"
+                        :draggable="canDragColumn(index)"
+                        @pointerdown="onColumnDragPointerDown(index, $event)"
+                        @dragstart="onColumnDragStart(index, $event)"
+                        @dragend="onColumnDragEnd"
+                      >
+                        <ListChevronsUpDown :class="structureIconClass" />
+                      </Button>
+                      <Button
+                        v-if="column.original"
+                        variant="ghost"
+                        size="icon"
+                        :class="structureActionButtonClass"
+                        :disabled="!canDropColumn(column)"
+                        :title="column.markedForDrop ? t('structureEditor.restore') : t('structureEditor.drop')"
+                        :aria-label="column.markedForDrop ? t('structureEditor.restore') : t('structureEditor.drop')"
+                        @click="toggleDropColumn(column)"
+                      >
+                        <RefreshCw v-if="column.markedForDrop" :class="structureIconClass" />
+                        <Trash2 v-else :class="structureIconClass" />
+                      </Button>
+                      <Button v-else variant="ghost" size="icon" :class="structureActionButtonClass" :title="t('structureEditor.remove')" :aria-label="t('structureEditor.remove')" @click="removeNewColumn(column)">
+                        <X :class="structureIconClass" />
+                      </Button>
+                    </div>
+                  </td>
+                </tr>
+              </tbody>
+            </table>
+          </TabsContent>
+
+          <TabsContent ref="indexesScrollerRef" v-if="tableMetadataCapabilities.indexes" value="indexes" class="m-0 min-h-0 flex-1 overflow-auto p-0" @scroll.passive="onStructureContentScroll('indexes', $event)">
+            <div v-if="indexesLoading" class="flex items-center justify-center gap-2 py-10 text-muted-foreground">
+              <Loader2 class="h-4 w-4 animate-spin" />
+              {{ t("common.loading") }}
+            </div>
+            <table v-else class="border-separate border-spacing-0 text-[length:var(--structure-font-size)] leading-[var(--structure-line-height)]" :style="{ minWidth: indexColWidths.reduce((a, w) => a + w, 0) + 'px' }">
+              <thead class="sticky top-0 z-10 bg-background">
+                <tr>
+                  <th
+                    v-for="(label, i) in indexColLabels"
+                    :key="i"
+                    :class="structureHeaderCellClass"
+                    :style="{
+                      width: indexColWidths[i] + 'px',
+                      minWidth: indexColWidths[i] + 'px',
+                    }"
+                  >
+                    {{ label }}
+                    <div v-if="i < indexColLabels.length - 1" class="absolute right-0 top-0 z-20 h-full w-1 cursor-col-resize hover:bg-primary/30" :class="resizing?.col === i ? 'bg-primary/30' : ''" @mousedown="onIndexColResize($event, i)" />
+                  </th>
+                </tr>
+              </thead>
+              <tbody>
+                <tr v-for="(index, rowIndex) in indexes" :key="index.id" :class="indexRowClass(index)" :data-new-index-row="!index.original ? 'true' : undefined" :data-index-row-index="rowIndex">
+                  <td :class="structureCellClass">
+                    <Input :model-value="index.name" :class="[structureControlClass, indexSearchFieldClass(index, index.name)]" :disabled="!canEditIndexDraft(index)" data-index-name-input @update:model-value="(value: string | number) => onIndexNameInput(index, value)" />
+                  </td>
+                  <td :class="[structureCellClass, 'overflow-hidden']">
+                    <DropdownMenu v-if="canEditIndexDraft(index)">
+                      <DropdownMenuTrigger as-child>
+                        <Button variant="outline" :class="[structureMonoControlClass, 'w-full justify-between']">
+                          <span class="truncate">{{ toColumnNames(index.columns) || t("structureEditor.indexColumnsPlaceholder") }}</span>
+                          <ChevronDown :class="[structureIconClass, 'ml-1 shrink-0 opacity-50']" />
+                        </Button>
+                      </DropdownMenuTrigger>
+                      <DropdownMenuContent class="max-h-56 min-w-44 overflow-y-auto" side="bottom" :side-offset="2" :avoid-collisions="false" @interactOutside="colSearch = ''">
+                        <div class="px-[var(--structure-cell-px)] pb-1 pt-0.5">
+                          <Input v-model="colSearch" :class="structureControlClass" :placeholder="t('grid.search')" @click.stop />
+                        </div>
+                        <DropdownMenuCheckboxItem v-for="col in filteredColumnNames" :key="col" :checked="index.columns.includes(col)" :class="index.columns.includes(col) ? 'bg-primary/10' : ''" @select.prevent @click="toggleIndexColumn(index, col)">
+                          {{ col }}
+                        </DropdownMenuCheckboxItem>
+                      </DropdownMenuContent>
+                    </DropdownMenu>
+                    <span v-else class="font-mono text-[length:var(--structure-font-size)] text-muted-foreground">{{ toColumnNames(index.columns) }}</span>
+                  </td>
+                  <td :class="structureCellClass">
+                    <label class="flex items-center gap-1.5">
+                      <input v-model="index.isUnique" type="checkbox" :class="structureCheckboxClass" :disabled="!canEditIndexDraft(index)" />
+                      <span>{{ index.isUnique ? t("structureEditor.yes") : t("structureEditor.no") }}</span>
+                    </label>
+                  </td>
+                  <td :class="structureCellClass">
+                    <Select v-if="indexTypeOptions.length > 0" :model-value="index.indexType || 'BTREE'" :disabled="!canEditIndexDraft(index)" @update:model-value="(v: any) => (index.indexType = String(v ?? ''))">
+                      <SelectTrigger class="h-[var(--structure-control-height)] w-full rounded-[6px] px-[var(--structure-control-px)] font-mono text-[length:var(--structure-font-size)] focus-visible:border-ring/50 focus-visible:ring-1 focus-visible:ring-ring/25">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem v-for="opt in indexTypeOptions" :key="opt" :value="opt">{{ opt }}</SelectItem>
+                      </SelectContent>
+                    </Select>
+                    <Input v-else v-model="index.indexType" :class="structureMonoControlClass" placeholder="BTREE" :disabled="!canEditIndexDraft(index) || !structureCapabilities.indexType" />
+                  </td>
+                  <td :class="[structureCellClass, 'overflow-hidden']">
+                    <DropdownMenu v-if="canEditIndexDraft(index) && structureCapabilities.indexInclude">
+                      <DropdownMenuTrigger as-child>
+                        <Button variant="outline" :class="[structureMonoControlClass, 'w-full justify-between']">
+                          <span class="truncate">{{ index.includedColumns.join(", ") || t("structureEditor.includedColumnsPlaceholder") }}</span>
+                          <ChevronDown :class="[structureIconClass, 'ml-1 shrink-0 opacity-50']" />
+                        </Button>
+                      </DropdownMenuTrigger>
+                      <DropdownMenuContent class="max-h-56 min-w-44 overflow-y-auto" side="bottom" :side-offset="2" :avoid-collisions="false" @interactOutside="colSearch = ''">
+                        <div class="px-[var(--structure-cell-px)] pb-1 pt-0.5">
+                          <Input v-model="colSearch" :class="structureControlClass" :placeholder="t('grid.search')" @click.stop />
+                        </div>
+                        <DropdownMenuCheckboxItem v-for="col in filteredColumnNames" :key="col" :checked="index.includedColumns.includes(col)" :class="index.includedColumns.includes(col) ? 'bg-primary/10' : ''" @select.prevent @click="toggleIncludedColumn(index, col)">
+                          {{ col }}
+                        </DropdownMenuCheckboxItem>
+                      </DropdownMenuContent>
+                    </DropdownMenu>
+                    <span v-else class="text-[length:var(--structure-font-size)] text-muted-foreground">{{ index.includedColumns.join(", ") }}</span>
+                  </td>
+                  <td :class="structureCellClass">
+                    <Input v-model="index.filter" :class="[structureMonoControlClass, indexSearchFieldClass(index, index.filter)]" :placeholder="index.original?.filter || ''" :disabled="!canEditIndexFilter(index)" />
+                  </td>
+                  <td :class="structureCellClass">
+                    <Input v-model="index.comment" :class="[structureControlClass, indexSearchFieldClass(index, index.comment)]" :disabled="!canEditIndexComment(index)" />
+                  </td>
+                  <td :class="structureLastCellClass">
+                    <Badge v-if="index.isPrimary" variant="outline">{{ t("structureEditor.primary") }}</Badge>
+                    <Button v-else-if="index.original" variant="ghost" size="sm" :class="structureToolbarButtonClass" :disabled="!canDropIndex(index)" @click="toggleDropIndex(index)">
+                      <Trash2 :class="structureIconClass" />
+                      {{ index.markedForDrop ? t("structureEditor.restore") : t("structureEditor.drop") }}
+                    </Button>
+                    <Button v-else variant="ghost" size="sm" :class="structureToolbarButtonClass" @click="removeNewIndex(index)">
+                      <X :class="structureIconClass" />
+                      {{ t("structureEditor.remove") }}
+                    </Button>
+                  </td>
+                </tr>
+              </tbody>
+            </table>
+          </TabsContent>
+
+          <TabsContent ref="foreignKeysScrollerRef" v-if="tableMetadataCapabilities.foreignKeys" value="foreignKeys" class="m-0 min-h-0 flex-1 overflow-auto p-[var(--structure-cell-px)]" @scroll.passive="onStructureContentScroll('foreignKeys', $event)">
+            <div v-if="foreignKeysLoading" class="flex items-center justify-center gap-2 py-10 text-muted-foreground">
+              <Loader2 class="h-4 w-4 animate-spin" />
+              {{ t("common.loading") }}
+            </div>
+            <div v-else-if="foreignKeys.length === 0" class="py-10 text-center text-muted-foreground">
+              {{ t("structureEditor.emptyReadonly") }}
+            </div>
+            <div v-else class="space-y-1.5">
+              <div v-for="fk in foreignKeys" :key="fk.id" class="rounded-md border px-[var(--structure-cell-px)] py-[var(--structure-header-py)] text-[length:var(--structure-font-size)]" :class="fk.markedForDrop ? 'bg-destructive/5 opacity-60' : ''">
+                <div class="grid grid-cols-[minmax(110px,1fr)_minmax(110px,1fr)_minmax(110px,1fr)_minmax(90px,0.8fr)_minmax(90px,0.8fr)_auto] gap-1.5">
+                  <Input v-model="fk.name" :class="structureControlClass" :placeholder="t('structureEditor.foreignKeyName')" :disabled="!canEditForeignKeyDraft(fk)" />
+                  <Input v-model="fk.column" :class="structureControlClass" :placeholder="t('structureEditor.columnName')" :disabled="!canEditForeignKeyDraft(fk)" />
+                  <Input v-model="fk.refTable" :class="structureControlClass" :placeholder="t('structureEditor.referencedTable')" :disabled="!canEditForeignKeyDraft(fk)" />
+                  <Input v-model="fk.refColumn" :class="structureControlClass" :placeholder="t('structureEditor.referencedColumn')" :disabled="!canEditForeignKeyDraft(fk)" />
+                  <Input v-model="fk.refSchema" :class="structureControlClass" :placeholder="t('structureEditor.referencedSchema')" :disabled="!canEditForeignKeyDraft(fk)" />
+                  <div class="flex items-center justify-end gap-1">
+                    <Button v-if="fk.original" variant="ghost" size="sm" :class="structureToolbarButtonClass" @click="toggleDropForeignKey(fk)">
+                      <Trash2 :class="structureIconClass" />
+                      {{ fk.markedForDrop ? t("structureEditor.restore") : t("structureEditor.drop") }}
+                    </Button>
+                    <Button v-else variant="ghost" size="sm" :class="structureToolbarButtonClass" @click="removeNewForeignKey(fk)">
+                      <X :class="structureIconClass" />
+                      {{ t("structureEditor.remove") }}
+                    </Button>
+                  </div>
+                </div>
+                <div class="mt-1.5 grid grid-cols-[minmax(110px,0.5fr)_minmax(110px,0.5fr)_1fr] gap-1.5">
+                  <Select :model-value="fk.onDelete || '__default'" :disabled="!canEditForeignKeyDraft(fk)" @update:model-value="(v: any) => (fk.onDelete = String(v === '__default' ? '' : (v ?? '')))">
+                    <SelectTrigger class="h-[var(--structure-control-height)] rounded-[6px] px-[var(--structure-control-px)] text-[length:var(--structure-font-size)] focus-visible:border-ring/50 focus-visible:ring-1 focus-visible:ring-ring/25">
+                      <SelectValue :placeholder="t('structureEditor.onDelete')" />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem v-for="action in foreignKeyActionOptions" :key="`delete-${action || 'default'}`" :value="action || '__default'">{{ action || t("structureEditor.defaultAction") }}</SelectItem>
+                    </SelectContent>
+                  </Select>
+                  <Select :model-value="fk.onUpdate || '__default'" :disabled="!canEditForeignKeyDraft(fk)" @update:model-value="(v: any) => (fk.onUpdate = String(v === '__default' ? '' : (v ?? '')))">
+                    <SelectTrigger class="h-[var(--structure-control-height)] rounded-[6px] px-[var(--structure-control-px)] text-[length:var(--structure-font-size)] focus-visible:border-ring/50 focus-visible:ring-1 focus-visible:ring-ring/25">
+                      <SelectValue :placeholder="t('structureEditor.onUpdate')" />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem v-for="action in foreignKeyActionOptions" :key="`update-${action || 'default'}`" :value="action || '__default'">{{ action || t("structureEditor.defaultAction") }}</SelectItem>
+                    </SelectContent>
+                  </Select>
+                  <div class="truncate font-mono text-muted-foreground">{{ fk.column }} -> {{ fk.refSchema ? `${fk.refSchema}.` : "" }}{{ fk.refTable }}.{{ fk.refColumn }}</div>
+                </div>
+              </div>
+            </div>
+          </TabsContent>
+
+          <TabsContent ref="triggersScrollerRef" v-if="tableMetadataCapabilities.triggers" value="triggers" class="m-0 min-h-0 flex-1 overflow-auto p-[var(--structure-cell-px)]" @scroll.passive="onStructureContentScroll('triggers', $event)">
+            <div v-if="triggersLoading" class="flex items-center justify-center gap-2 py-10 text-muted-foreground">
+              <Loader2 class="h-4 w-4 animate-spin" />
+              {{ t("common.loading") }}
+            </div>
+            <div v-else-if="triggers.length === 0" class="py-10 text-center text-muted-foreground">
+              {{ t("structureEditor.emptyReadonly") }}
+            </div>
+            <div v-else class="space-y-1.5">
+              <div v-for="trigger in triggers" :key="trigger.id" class="rounded-md border px-[var(--structure-cell-px)] py-[var(--structure-header-py)] text-[length:var(--structure-font-size)]" :class="trigger.markedForDrop ? 'bg-destructive/5 opacity-60' : ''">
+                <div class="grid grid-cols-[minmax(140px,1fr)_110px_110px_auto] gap-1.5">
+                  <Input v-model="trigger.name" :class="structureControlClass" :placeholder="t('structureEditor.triggerName')" :disabled="!canEditTriggerDraft(trigger)" />
+                  <Select v-model="trigger.timing" :disabled="!canEditTriggerDraft(trigger)">
+                    <SelectTrigger class="h-[var(--structure-control-height)] rounded-[6px] px-[var(--structure-control-px)] text-[length:var(--structure-font-size)] focus-visible:border-ring/50 focus-visible:ring-1 focus-visible:ring-ring/25">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem v-for="timing in triggerTimingOptions" :key="timing" :value="timing">{{ timing }}</SelectItem>
+                    </SelectContent>
+                  </Select>
+                  <Select v-model="trigger.event" :disabled="!canEditTriggerDraft(trigger)">
+                    <SelectTrigger class="h-[var(--structure-control-height)] rounded-[6px] px-[var(--structure-control-px)] text-[length:var(--structure-font-size)] focus-visible:border-ring/50 focus-visible:ring-1 focus-visible:ring-ring/25">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent>
+                      <SelectItem v-for="event in triggerEventOptions" :key="event" :value="event">{{ event }}</SelectItem>
+                    </SelectContent>
+                  </Select>
+                  <div class="flex items-center justify-end gap-1">
+                    <Button v-if="trigger.original" variant="ghost" size="sm" :class="structureToolbarButtonClass" @click="toggleDropTrigger(trigger)">
+                      <Trash2 :class="structureIconClass" />
+                      {{ trigger.markedForDrop ? t("structureEditor.restore") : t("structureEditor.drop") }}
+                    </Button>
+                    <Button v-else variant="ghost" size="sm" :class="structureToolbarButtonClass" @click="removeNewTrigger(trigger)">
+                      <X :class="structureIconClass" />
+                      {{ t("structureEditor.remove") }}
+                    </Button>
+                  </div>
+                </div>
+                <textarea
+                  v-model="trigger.statement"
+                  class="mt-1.5 min-h-28 w-full resize-y rounded-[6px] border bg-background px-[var(--structure-control-px)] py-[var(--structure-cell-py)] font-mono text-[length:var(--structure-font-size)] leading-5 outline-none focus-visible:border-ring/50 focus-visible:ring-1 focus-visible:ring-ring/25 disabled:cursor-not-allowed disabled:opacity-50"
+                  :placeholder="t('structureEditor.triggerStatement')"
+                  :disabled="!canEditTriggerDraft(trigger)"
+                />
+              </div>
+            </div>
+          </TabsContent>
+
+          <TabsContent ref="ddlScrollerRef" v-if="tableMetadataCapabilities.ddl" value="ddl" class="m-0 min-h-0 flex-1 overflow-auto p-[var(--structure-cell-px)]" @scroll.passive="onStructureContentScroll('ddl', $event)">
+            <div v-if="ddlLoading" class="flex items-center justify-center gap-2 py-10 text-muted-foreground">
+              <Loader2 class="h-4 w-4 animate-spin" />
+              {{ t("common.loading") }}
+            </div>
+            <pre v-else ref="ddlPreRef" tabindex="0" class="m-0 min-h-0 flex-1 whitespace-pre p-3 font-mono text-xs leading-5 select-text outline-none" v-html="ddlContent ? (sqlHighlighter?.(ddlContent) ?? ddlContent) : t('structureEditor.emptyReadonly')" @keydown="onDdlKeydown"></pre>
+          </TabsContent>
+        </Tabs>
+      </div>
+
+      <div :class="['flex min-w-0 shrink-0 flex-col overflow-hidden rounded-md border', sqlPreviewCollapsed ? '' : 'h-[28%] min-h-40 max-h-64']">
+        <div class="flex shrink-0 items-center justify-between border-b px-[var(--structure-cell-px)] py-[var(--structure-header-py)] text-[length:var(--structure-font-size)] font-medium">
+          <div class="flex items-center gap-1.5">
+            <span>{{ t("structureEditor.sqlPreview") }}</span>
+            <Badge v-if="!saving && pendingStatements.length && warnings.length === 0" variant="outline" class="h-4 px-1 text-[10px]">
+              <Check class="h-3 w-3" />
+              {{ t("structureEditor.ready") }}
+            </Badge>
+          </div>
+          <div class="flex items-center gap-1.5">
+            <Button
+              variant="ghost"
+              :class="structureIconButtonClass"
+              :aria-label="sqlPreviewCollapsed ? t('structureEditor.expandSqlPreview') : t('structureEditor.collapseSqlPreview')"
+              :title="sqlPreviewCollapsed ? t('structureEditor.expandSqlPreview') : t('structureEditor.collapseSqlPreview')"
+              @click="toggleSqlPreviewCollapsed"
+            >
+              <ChevronUp v-if="sqlPreviewCollapsed" :class="structureIconClass" />
+              <ChevronDown v-else :class="structureIconClass" />
+            </Button>
+            <Button variant="ghost" :class="structureToolbarButtonClass" :disabled="!previewSqlText.trim()" @click="copyPreviewSql">
+              <Copy :class="[structureIconClass, 'mr-1']" />
+              {{ t("structureEditor.copySql") }}
+            </Button>
+            <Badge variant="secondary">
+              <Loader2 v-if="sqlPreviewLoading" class="h-3 w-3 animate-spin" />
+              <span v-else>{{ pendingStatements.length }}</span>
+            </Badge>
+          </div>
+        </div>
+        <div v-if="!sqlPreviewCollapsed" class="min-h-0 flex-1 overflow-auto p-2.5">
+          <div v-if="hasSqliteTypeChange" class="mb-2 flex gap-1.5 rounded-md border border-blue-300/40 bg-blue-500/10 px-[var(--structure-cell-px)] py-[var(--structure-cell-py)] text-[length:var(--structure-font-size)] text-blue-700 dark:text-blue-300">
+            <Info :class="[structureIconClass, 'mt-0.5 shrink-0']" />
+            <span>{{ t("structureEditor.sqliteRebuildNotice") }}</span>
+          </div>
+          <div v-if="warnings.length" class="mb-2 space-y-1">
+            <div v-for="warning in warnings" :key="warning" class="flex gap-1.5 rounded-md border border-yellow-300/40 bg-yellow-500/10 px-[var(--structure-cell-px)] py-[var(--structure-cell-py)] text-[length:var(--structure-font-size)] text-yellow-700 dark:text-yellow-300">
+              <AlertTriangle :class="[structureIconClass, 'mt-0.5 shrink-0']" />
+              <span>{{ warning }}</span>
+            </div>
+          </div>
+          <pre v-if="pendingStatements.length" class="select-text whitespace-pre-wrap break-words rounded-md bg-muted/40 p-2.5 font-mono text-[calc(var(--structure-font-size)+1px)] leading-5" v-html="highlightedSql" />
+          <div v-else class="flex h-full items-center justify-center text-[length:var(--structure-font-size)] text-muted-foreground">
+            {{ t("structureEditor.noChanges") }}
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div v-if="errorMessage" class="shrink-0 rounded-md border border-destructive/30 bg-destructive/10 px-[var(--structure-cell-px)] py-[var(--structure-header-py)] text-[length:var(--structure-font-size)] text-destructive">
+      {{ errorMessage }}
+    </div>
+
+    <div class="flex shrink-0 items-center justify-end gap-2">
+      <Button :class="structureToolbarButtonClass" :disabled="!canApply" @click="applyChanges">
+        <Loader2 v-if="saving" :class="[structureIconClass, 'mr-1.5 animate-spin']" />
+        <Save v-else :class="[structureIconClass, 'mr-1.5']" />
+        {{ t("structureEditor.apply") }}
+      </Button>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.structure-column-search-match > td:first-child {
+  box-shadow: inset 3px 0 0 hsl(var(--primary) / 0.55);
+}
+
+.structure-column-search-current > td {
+  box-shadow:
+    inset 0 1px 0 hsl(var(--primary) / 0.55),
+    inset 0 -1px 0 hsl(var(--primary) / 0.55);
+}
+
+.structure-column-search-current > td:first-child {
+  box-shadow:
+    inset 3px 0 0 hsl(var(--primary)),
+    inset 0 1px 0 hsl(var(--primary) / 0.55),
+    inset 0 -1px 0 hsl(var(--primary) / 0.55);
+}
+</style>
diff --git a/apps/desktop/src/components/transfer/DataTransferDialog.vue b/apps/desktop/src/components/transfer/DataTransferDialog.vue
new file mode 100644
index 0000000..64ddb04
--- /dev/null
+++ b/apps/desktop/src/components/transfer/DataTransferDialog.vue
@@ -0,0 +1,601 @@
+<script setup lang="ts">
+import { computed, ref, watch } from "vue";
+import { uuid } from "@/lib/common/utils";
+import { useI18n } from "vue-i18n";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter } from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select";
+import SearchableSelect from "@/components/ui/searchable-select/SearchableSelect.vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import DatabaseIcon from "@/components/icons/DatabaseIcon.vue";
+import * as api from "@/lib/backend/api";
+import type { TransferMode, TransferTableNameCase } from "@/lib/backend/api";
+import type { DatabaseType } from "@/types/database";
+import { isSchemaAware, supportsTransfer } from "@/lib/database/databaseCapabilities";
+import { databaseOptionsForConnection } from "@/composables/useDatabaseOptions";
+import { useExportTracker } from "@/composables/useExportTracker";
+import { ArrowRightLeft, ArrowLeftRight, Loader2, Square, CheckSquare } from "@lucide/vue";
+
+const { t } = useI18n();
+const { startDataTransferTask } = useExportTracker();
+const open = defineModel<boolean>("open", { default: false });
+
+const props = defineProps<{
+  prefillConnectionId?: string;
+  prefillDatabase?: string;
+}>();
+
+const store = useConnectionStore();
+
+const sqlConnections = computed(() => store.connections.filter((c) => supportsTransfer(c.db_type)));
+
+// Source state
+const sourceConnectionId = ref("");
+const sourceDatabase = ref("");
+const sourceDatabases = ref<string[]>([]);
+const sourceSchemas = ref<string[]>([]);
+const sourceSchema = ref("");
+const sourceTables = ref<string[]>([]);
+const selectedTables = ref<Set<string>>(new Set());
+const tableSearch = ref("");
+const loadingTables = ref(false);
+
+// Target state
+const targetConnectionId = ref("");
+const targetDatabase = ref("");
+const targetDatabases = ref<string[]>([]);
+const targetSchemas = ref<string[]>([]);
+const targetSchema = ref("");
+
+// Options
+const createTable = ref(true);
+const transferMode = ref<TransferMode>("append");
+const targetTableNameCase = ref<TransferTableNameCase>("preserve");
+const batchSize = ref(1000);
+const isSubmitting = ref(false);
+const ownershipDialogOpen = ref(false);
+const ownershipMissingOwners = ref<string[]>([]);
+const ownershipTargetOwner = ref("");
+const pendingOwnershipRequest = ref<api.TransferRequest | null>(null);
+const pendingOwnershipRefresh = ref<{ targetConnection: string; targetDatabase: string; targetSchema: string; shouldRefreshTargetTree: boolean } | null>(null);
+
+const filteredTables = computed(() => {
+  const q = tableSearch.value.toLowerCase();
+  return q ? sourceTables.value.filter((t) => t.toLowerCase().includes(q)) : sourceTables.value;
+});
+
+const allSelected = computed(() => filteredTables.value.length > 0 && filteredTables.value.every((t) => selectedTables.value.has(t)));
+
+function connectionType(id: string): DatabaseType | undefined {
+  return store.connections.find((c) => c.id === id)?.db_type;
+}
+
+function isMongoConnection(id: string): boolean {
+  return connectionType(id) === "mongodb";
+}
+
+const canStart = computed(() => sourceConnectionId.value && sourceDatabase.value && targetConnectionId.value && targetDatabase.value && selectedTables.value.size > 0 && sourceConnectionId.value + sourceDatabase.value !== targetConnectionId.value + targetDatabase.value);
+
+function toggleSelectAll() {
+  if (allSelected.value) {
+    filteredTables.value.forEach((t) => selectedTables.value.delete(t));
+  } else {
+    filteredTables.value.forEach((t) => selectedTables.value.add(t));
+  }
+}
+
+function toggleTable(table: string) {
+  if (selectedTables.value.has(table)) {
+    selectedTables.value.delete(table);
+  } else {
+    selectedTables.value.add(table);
+  }
+}
+
+async function loadDatabases(connectionId: string, target: "source" | "target") {
+  if (!connectionId) return;
+  try {
+    await store.ensureConnected(connectionId);
+    const rawNames = isMongoConnection(connectionId) ? await api.mongoListDatabases(connectionId) : (await api.listDatabases(connectionId)).map((d) => d.name);
+    const names = databaseOptionsForConnection(rawNames, store.getConfig(connectionId));
+    if (target === "source") {
+      sourceDatabases.value = names;
+      sourceDatabase.value = names.length === 1 ? names[0] : "";
+    } else {
+      targetDatabases.value = names;
+      targetDatabase.value = names.length === 1 ? names[0] : "";
+    }
+  } catch {
+    if (target === "source") sourceDatabases.value = [];
+    else targetDatabases.value = [];
+  }
+}
+
+async function loadSchemas(connectionId: string, database: string, side: "source" | "target", preferredSchema = "") {
+  if (!connectionId || !database) return;
+  if (isMongoConnection(connectionId)) {
+    if (side === "source") {
+      sourceSchemas.value = [];
+      sourceSchema.value = database;
+    } else {
+      targetSchemas.value = [];
+      targetSchema.value = database;
+    }
+    return;
+  }
+  try {
+    const schemas = await api.listSchemas(connectionId, database);
+    const selected = preferredSchema && schemas.includes(preferredSchema) ? preferredSchema : schemas.includes("public") ? "public" : (schemas[0] ?? "");
+    if (side === "source") {
+      sourceSchemas.value = schemas;
+      sourceSchema.value = selected;
+    } else {
+      targetSchemas.value = schemas;
+      targetSchema.value = selected;
+    }
+  } catch {
+    if (side === "source") {
+      sourceSchemas.value = [];
+      sourceSchema.value = "";
+    } else {
+      targetSchemas.value = [];
+      targetSchema.value = "";
+    }
+  }
+}
+
+async function loadTables() {
+  if (!sourceConnectionId.value || !sourceDatabase.value) {
+    sourceTables.value = [];
+    return;
+  }
+  loadingTables.value = true;
+  try {
+    if (isMongoConnection(sourceConnectionId.value)) {
+      sourceTables.value = (await api.mongoListCollections(sourceConnectionId.value, sourceDatabase.value)).map((c) => c.name);
+      selectedTables.value = new Set(sourceTables.value);
+      return;
+    }
+    const config = store.getConfig(sourceConnectionId.value);
+    const needsSchema = isSchemaAware(config?.db_type);
+    const schema = needsSchema && sourceSchema.value ? sourceSchema.value : sourceDatabase.value;
+    const tables = await api.listTables(sourceConnectionId.value, sourceDatabase.value, schema);
+    sourceTables.value = tables.filter((t) => t.table_type === "TABLE" || t.table_type === "BASE TABLE").map((t) => t.name);
+    selectedTables.value = new Set(sourceTables.value);
+  } catch {
+    sourceTables.value = [];
+  } finally {
+    loadingTables.value = false;
+  }
+}
+
+const skipSourceWatch = ref(false);
+
+watch(sourceConnectionId, (id) => {
+  if (skipSourceWatch.value) {
+    skipSourceWatch.value = false;
+    return;
+  }
+  sourceDatabase.value = "";
+  sourceTables.value = [];
+  selectedTables.value.clear();
+  loadDatabases(id, "source");
+});
+
+watch(sourceDatabase, async (db) => {
+  if (db) {
+    const config = store.getConfig(sourceConnectionId.value);
+    if (isSchemaAware(config?.db_type)) {
+      await loadSchemas(sourceConnectionId.value, db, "source");
+    } else {
+      sourceSchema.value = db;
+    }
+  }
+});
+
+watch(sourceSchema, () => loadTables());
+
+watch(targetConnectionId, (id) => {
+  targetDatabase.value = "";
+  targetSchemas.value = [];
+  targetSchema.value = "";
+  loadDatabases(id, "target");
+});
+
+watch(targetDatabase, async (db) => {
+  if (db) {
+    const config = store.getConfig(targetConnectionId.value);
+    if (isSchemaAware(config?.db_type)) {
+      await loadSchemas(targetConnectionId.value, db, "target");
+    } else {
+      targetSchema.value = db;
+    }
+  }
+});
+
+watch(
+  open,
+  async (val) => {
+    if (val) {
+      resetState();
+      if (props.prefillConnectionId) {
+        skipSourceWatch.value = true;
+        sourceConnectionId.value = props.prefillConnectionId;
+        await loadDatabases(props.prefillConnectionId, "source");
+        if (props.prefillDatabase) {
+          sourceDatabase.value = props.prefillDatabase;
+        }
+      }
+    }
+  },
+  { immediate: true },
+);
+
+function resetState() {
+  sourceConnectionId.value = "";
+  sourceDatabase.value = "";
+  sourceDatabases.value = [];
+  sourceSchemas.value = [];
+  sourceSchema.value = "";
+  sourceTables.value = [];
+  selectedTables.value.clear();
+  tableSearch.value = "";
+  targetConnectionId.value = "";
+  targetDatabase.value = "";
+  targetDatabases.value = [];
+  targetSchemas.value = [];
+  targetSchema.value = "";
+  createTable.value = true;
+  transferMode.value = "append";
+  targetTableNameCase.value = "preserve";
+  batchSize.value = 1000;
+  isSubmitting.value = false;
+  ownershipDialogOpen.value = false;
+  ownershipMissingOwners.value = [];
+  ownershipTargetOwner.value = "";
+  pendingOwnershipRequest.value = null;
+  pendingOwnershipRefresh.value = null;
+}
+
+async function startTransfer() {
+  if (!canStart.value || isSubmitting.value) return;
+  isSubmitting.value = true;
+
+  const effectiveSourceSchema = sourceSchema.value || sourceDatabase.value;
+  const effectiveTargetSchema = targetSchema.value || targetDatabase.value;
+  const sourceDatabaseName = sourceDatabase.value;
+  const targetConnection = targetConnectionId.value;
+  const targetDatabaseName = targetDatabase.value;
+  const shouldRefreshTargetTree = createTable.value;
+
+  const request: api.TransferRequest = {
+    transferId: uuid(),
+    sourceConnectionId: sourceConnectionId.value,
+    sourceDatabase: sourceDatabaseName,
+    sourceSchema: effectiveSourceSchema,
+    targetConnectionId: targetConnection,
+    targetDatabase: targetDatabaseName,
+    targetSchema: effectiveTargetSchema,
+    tables: [...selectedTables.value],
+    createTable: createTable.value,
+    mode: transferMode.value,
+    targetTableNameCase: targetTableNameCase.value,
+    ownershipPolicy: "preserve",
+    batchSize: batchSize.value,
+  };
+
+  if (createTable.value) {
+    try {
+      const preview = await api.previewTransferOwnership(request);
+      if (preview.missingOwners.length > 0) {
+        ownershipMissingOwners.value = preview.missingOwners;
+        ownershipTargetOwner.value = preview.targetOwner;
+        pendingOwnershipRequest.value = request;
+        pendingOwnershipRefresh.value = {
+          targetConnection,
+          targetDatabase: targetDatabaseName,
+          targetSchema: effectiveTargetSchema,
+          shouldRefreshTargetTree,
+        };
+        ownershipDialogOpen.value = true;
+        isSubmitting.value = false;
+        return;
+      }
+    } catch {
+      isSubmitting.value = false;
+      return;
+    }
+  }
+
+  runTransfer(request, targetConnection, targetDatabaseName, effectiveTargetSchema, shouldRefreshTargetTree);
+}
+
+function runTransfer(request: api.TransferRequest, targetConnection: string, targetDatabaseName: string, effectiveTargetSchema: string, shouldRefreshTargetTree: boolean) {
+  isSubmitting.value = true;
+  startDataTransferTask(request, `${request.sourceDatabase} → ${targetDatabaseName}`, {
+    formatOverlapError: (tables) => t("transfer.targetTableBusy", { tables: tables.join(", ") }),
+    onDone: async () => {
+      if (shouldRefreshTargetTree) {
+        await store.refreshObjectListTreeNode(targetConnection, targetDatabaseName, effectiveTargetSchema);
+      }
+    },
+  });
+  open.value = false;
+  resetState();
+}
+
+function resolveOwnershipDecision(policy: api.TransferOwnershipPolicy | null) {
+  const request = pendingOwnershipRequest.value;
+  const refresh = pendingOwnershipRefresh.value;
+  pendingOwnershipRequest.value = null;
+  pendingOwnershipRefresh.value = null;
+  ownershipDialogOpen.value = false;
+  ownershipMissingOwners.value = [];
+  ownershipTargetOwner.value = "";
+  if (!policy || !request || !refresh) {
+    isSubmitting.value = false;
+    return;
+  }
+  runTransfer({ ...request, ownershipPolicy: policy }, refresh.targetConnection, refresh.targetDatabase, refresh.targetSchema, refresh.shouldRefreshTargetTree);
+}
+
+function getConnectionName(id: string) {
+  return store.connections.find((c) => c.id === id)?.name ?? id;
+}
+</script>
+
+<template>
+  <Dialog v-model:open="open">
+    <DialogContent class="sm:max-w-[780px] max-h-[80vh] flex flex-col overflow-hidden" @interact-outside.prevent>
+      <DialogHeader>
+        <DialogTitle class="flex items-center gap-2">
+          <ArrowRightLeft class="w-4 h-4" />
+          {{ t("transfer.title") }}
+        </DialogTitle>
+      </DialogHeader>
+
+      <div class="flex-1 min-h-0 overflow-auto">
+        <div class="grid gap-4 py-3">
+          <!-- Source / Target Side by Side -->
+          <div class="grid grid-cols-[1fr_auto_1fr] gap-4 items-start">
+            <!-- Source Section -->
+            <div class="space-y-3">
+              <div class="text-sm font-medium text-blue-500">
+                {{ t("transfer.source") }}
+              </div>
+
+              <div class="space-y-1.5">
+                <Label class="text-xs">{{ t("transfer.sourceConnection") }}</Label>
+                <SearchableSelect
+                  v-model="sourceConnectionId"
+                  :options="sqlConnections.map((c) => c.id)"
+                  :placeholder="t('transfer.selectConnection')"
+                  :search-placeholder="t('transfer.searchConnection')"
+                  :empty-text="t('common.noResults')"
+                  :display-name="getConnectionName"
+                  trigger-variant="outline"
+                  trigger-class="h-8 w-full justify-between text-xs"
+                  content-class="w-[var(--reka-popover-trigger-width)]"
+                >
+                  <template #option-label="{ option, label }">
+                    <div class="flex items-center gap-1.5">
+                      <DatabaseIcon :db-type="sqlConnections.find((c) => c.id === option)?.db_type ?? 'mysql'" class="w-3.5 h-3.5" />
+                      {{ label }}
+                    </div>
+                  </template>
+                </SearchableSelect>
+              </div>
+
+              <div class="space-y-1.5">
+                <Label class="text-xs">{{ t("transfer.sourceDatabase") }}</Label>
+                <SearchableSelect
+                  v-model="sourceDatabase"
+                  :options="sourceDatabases"
+                  :placeholder="t('transfer.selectDatabase')"
+                  :search-placeholder="t('transfer.searchDatabase')"
+                  :empty-text="t('common.noResults')"
+                  :disabled="!sourceDatabases.length"
+                  trigger-variant="outline"
+                  trigger-class="h-8 w-full justify-between text-xs"
+                  content-class="w-[var(--reka-popover-trigger-width)]"
+                />
+              </div>
+
+              <div v-if="sourceSchemas.length" class="space-y-1.5">
+                <Label class="text-xs">{{ t("transfer.sourceSchema") }}</Label>
+                <SearchableSelect
+                  v-model="sourceSchema"
+                  :options="sourceSchemas"
+                  :placeholder="t('transfer.selectSchema')"
+                  :search-placeholder="t('transfer.searchSchema')"
+                  :empty-text="t('common.noResults')"
+                  trigger-variant="outline"
+                  trigger-class="h-8 w-full justify-between text-xs"
+                  content-class="w-[var(--reka-popover-trigger-width)]"
+                />
+              </div>
+            </div>
+
+            <!-- Arrow -->
+            <div class="flex items-center pt-8">
+              <ArrowLeftRight class="w-5 h-5 text-muted-foreground" />
+            </div>
+
+            <!-- Target Section -->
+            <div class="space-y-3">
+              <div class="text-sm font-medium text-green-500">
+                {{ t("transfer.target") }}
+              </div>
+
+              <div class="space-y-1.5">
+                <Label class="text-xs">{{ t("transfer.targetConnection") }}</Label>
+                <SearchableSelect
+                  v-model="targetConnectionId"
+                  :options="sqlConnections.map((c) => c.id)"
+                  :placeholder="t('transfer.selectConnection')"
+                  :search-placeholder="t('transfer.searchConnection')"
+                  :empty-text="t('common.noResults')"
+                  :display-name="getConnectionName"
+                  trigger-variant="outline"
+                  trigger-class="h-8 w-full justify-between text-xs"
+                  content-class="w-[var(--reka-popover-trigger-width)]"
+                >
+                  <template #option-label="{ option, label }">
+                    <div class="flex items-center gap-1.5">
+                      <DatabaseIcon :db-type="sqlConnections.find((c) => c.id === option)?.db_type ?? 'mysql'" class="w-3.5 h-3.5" />
+                      {{ label }}
+                    </div>
+                  </template>
+                </SearchableSelect>
+              </div>
+
+              <div class="space-y-1.5">
+                <Label class="text-xs">{{ t("transfer.targetDatabase") }}</Label>
+                <SearchableSelect
+                  v-model="targetDatabase"
+                  :options="targetDatabases"
+                  :placeholder="t('transfer.selectDatabase')"
+                  :search-placeholder="t('transfer.searchDatabase')"
+                  :empty-text="t('common.noResults')"
+                  :disabled="!targetDatabases.length"
+                  trigger-variant="outline"
+                  trigger-class="h-8 w-full justify-between text-xs"
+                  content-class="w-[var(--reka-popover-trigger-width)]"
+                />
+              </div>
+
+              <div v-if="targetSchemas.length" class="space-y-1.5">
+                <Label class="text-xs">{{ t("transfer.targetSchema") }}</Label>
+                <SearchableSelect
+                  v-model="targetSchema"
+                  :options="targetSchemas"
+                  :placeholder="t('transfer.selectSchema')"
+                  :search-placeholder="t('transfer.searchSchema')"
+                  :empty-text="t('common.noResults')"
+                  trigger-variant="outline"
+                  trigger-class="h-8 w-full justify-between text-xs"
+                  content-class="w-[var(--reka-popover-trigger-width)]"
+                />
+              </div>
+            </div>
+          </div>
+
+          <!-- Tables Section -->
+          <div class="space-y-2">
+            <div class="flex items-center justify-between">
+              <div class="text-xs font-medium text-muted-foreground uppercase tracking-wider">
+                {{ t("transfer.tables") }}
+                <span v-if="sourceTables.length" class="text-muted-foreground/60">({{ selectedTables.size }}/{{ sourceTables.length }})</span>
+              </div>
+              <Button v-if="sourceTables.length" variant="ghost" size="sm" class="h-6 text-xs px-2" @click="toggleSelectAll">
+                {{ allSelected ? t("transfer.deselectAll") : t("transfer.selectAll") }}
+              </Button>
+            </div>
+
+            <Input v-if="sourceTables.length > 5" v-model="tableSearch" :placeholder="t('transfer.searchTables')" class="h-7 text-xs" />
+
+            <div v-if="loadingTables" class="flex items-center gap-2 text-xs text-muted-foreground py-4 justify-center">
+              <Loader2 class="w-3.5 h-3.5 animate-spin" />
+              {{ t("common.loading") }}
+            </div>
+            <div v-else-if="!sourceConnectionId || !sourceDatabase" class="text-xs text-muted-foreground py-4 text-center">
+              {{ t("transfer.selectSourceFirst") }}
+            </div>
+            <div v-else-if="sourceTables.length === 0" class="text-xs text-muted-foreground py-4 text-center">
+              {{ t("transfer.noTables") }}
+            </div>
+            <div v-else class="border rounded-md max-h-[200px] overflow-y-auto">
+              <div v-for="table in filteredTables" :key="table" class="flex items-center gap-2 px-2.5 py-1.5 hover:bg-muted/50 cursor-pointer text-xs" @click="toggleTable(table)">
+                <CheckSquare v-if="selectedTables.has(table)" class="w-3.5 h-3.5 text-primary shrink-0" />
+                <Square v-else class="w-3.5 h-3.5 text-muted-foreground/40 shrink-0" />
+                <span class="truncate">{{ table }}</span>
+              </div>
+            </div>
+          </div>
+
+          <!-- Options -->
+          <div class="space-y-2.5">
+            <div class="flex items-center gap-2 cursor-pointer text-xs" @click="createTable = !createTable">
+              <CheckSquare v-if="createTable" class="w-3.5 h-3.5 text-primary shrink-0" />
+              <Square v-else class="w-3.5 h-3.5 text-muted-foreground/40 shrink-0" />
+              {{ t("transfer.createTable") }}
+            </div>
+            <div class="flex items-center gap-3">
+              <Label class="text-xs shrink-0">{{ t("transfer.transferMode") }}</Label>
+              <Select v-model="transferMode">
+                <SelectTrigger class="h-7 text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="append">{{ t("transfer.modeAppend") }}</SelectItem>
+                  <SelectItem value="overwrite">{{ t("transfer.modeOverwrite") }}</SelectItem>
+                  <SelectItem value="upsert">{{ t("transfer.modeUpsert") }}</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+            <div class="flex items-center gap-3">
+              <Label class="text-xs shrink-0">{{ t("transfer.targetTableNameCase") }}</Label>
+              <Select v-model="targetTableNameCase">
+                <SelectTrigger class="h-7 text-xs">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="preserve">{{ t("transfer.tableNameCasePreserve") }}</SelectItem>
+                  <SelectItem value="lower">{{ t("transfer.tableNameCaseLower") }}</SelectItem>
+                  <SelectItem value="upper">{{ t("transfer.tableNameCaseUpper") }}</SelectItem>
+                </SelectContent>
+              </Select>
+            </div>
+            <div class="flex items-center gap-3">
+              <Label class="text-xs shrink-0">{{ t("transfer.batchSize") }}</Label>
+              <Input v-model.number="batchSize" type="number" min="100" max="10000" step="100" class="h-7 text-xs w-24" />
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <DialogFooter>
+        <Button variant="outline" size="sm" @click="open = false">
+          {{ t("transfer.cancel") }}
+        </Button>
+        <Button size="sm" :disabled="!canStart || isSubmitting" @click="startTransfer">
+          <Loader2 v-if="isSubmitting" class="w-3.5 h-3.5 mr-1.5 animate-spin" />
+          <ArrowRightLeft v-else class="w-3.5 h-3.5 mr-1.5" />
+          {{ t("transfer.start") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+
+  <Dialog v-model:open="ownershipDialogOpen">
+    <DialogContent class="sm:max-w-[520px]" @interact-outside.prevent>
+      <DialogHeader>
+        <DialogTitle>{{ t("transfer.ownershipTitle") }}</DialogTitle>
+      </DialogHeader>
+      <div class="space-y-3 text-sm">
+        <p class="text-muted-foreground">
+          {{ t("transfer.ownershipMessage", { owners: ownershipMissingOwners.join(", ") }) }}
+        </p>
+        <div class="rounded-md border bg-muted/30 px-3 py-2 text-xs text-muted-foreground">
+          {{ t("transfer.ownershipSkipDetails") }}
+        </div>
+        <div class="rounded-md border bg-muted/30 px-3 py-2 text-xs text-muted-foreground">
+          {{ t("transfer.ownershipTargetOwner", { owner: ownershipTargetOwner }) }}
+        </div>
+      </div>
+      <DialogFooter class="gap-2">
+        <Button variant="outline" size="sm" @click="resolveOwnershipDecision(null)">
+          {{ t("transfer.cancel") }}
+        </Button>
+        <Button variant="secondary" size="sm" @click="resolveOwnershipDecision('skip')">
+          {{ t("transfer.ownershipSkip") }}
+        </Button>
+        <Button size="sm" @click="resolveOwnershipDecision('reassignMissing')">
+          {{ t("transfer.ownershipConfirm") }}
+        </Button>
+      </DialogFooter>
+    </DialogContent>
+  </Dialog>
+</template>
diff --git a/apps/desktop/src/components/ui/CustomContextMenu.vue b/apps/desktop/src/components/ui/CustomContextMenu.vue
new file mode 100644
index 0000000..21e2354
--- /dev/null
+++ b/apps/desktop/src/components/ui/CustomContextMenu.vue
@@ -0,0 +1,316 @@
+<script setup lang="ts">
+import { ref, watch, onBeforeUnmount, nextTick, type Component } from "vue";
+import { ChevronRight } from "@lucide/vue";
+import { shortcutDisplayKeys } from "@/lib/editor/shortcutDisplay";
+
+export interface ContextMenuItem {
+  label: string;
+  action?: () => void;
+  disabled?: boolean;
+  separator?: boolean;
+  icon?: Component;
+  iconClass?: string;
+  // Raw shortcut syntax such as `Mod+C` or `Shift+Alt+U`; display formatting stays in this component.
+  shortcut?: string;
+  variant?: "default" | "destructive";
+  visible?: boolean;
+  children?: ContextMenuItem[];
+}
+
+type ContextMenuItemsSource = ContextMenuItem[] | (() => ContextMenuItem[]);
+
+const props = defineProps<{
+  items: ContextMenuItemsSource;
+}>();
+
+defineEmits<{
+  close: [];
+}>();
+
+defineSlots<{
+  default(props: { onContextMenu: (event: MouseEvent) => void }): any;
+}>();
+
+// ---- module-level singleton state ----
+const openMenus = new Set<() => void>();
+let globalSetup = false;
+
+function ensureGlobalListeners() {
+  if (globalSetup) return;
+  globalSetup = true;
+  const closeAll = () => {
+    for (const c of openMenus) c();
+    openMenus.clear();
+  };
+  document.addEventListener("contextmenu", closeAll, true);
+  document.addEventListener("scroll", closeAll, true);
+  window.addEventListener("resize", closeAll);
+}
+ensureGlobalListeners();
+// -------------------------------------
+
+const show = ref(false);
+const x = ref(0);
+const y = ref(0);
+const menuRef = ref<HTMLElement>();
+const activeItems = ref<ContextMenuItem[]>([]);
+
+// Submenu state
+const activeSubIndex = ref<number | null>(null);
+const subRef = ref<HTMLElement>();
+const subX = ref(0);
+const subY = ref(0);
+let subCloseTimer: ReturnType<typeof setTimeout> | null = null;
+let subAnchorRect: { left: number; right: number; top: number; bottom: number } | null = null;
+
+function close() {
+  activeSubIndex.value = null;
+  subAnchorRect = null;
+  activeItems.value = [];
+  show.value = false;
+}
+
+function onPointerDownOutside(e: PointerEvent) {
+  // Only respond to primary (left) button presses. This avoids a macOS
+  // issue where Ctrl+right-click generates a synthetic click event on
+  // mouseup. By using pointerdown (which fires on press, before
+  // contextmenu) instead of click, we never see that synthetic event.
+  if (e.button !== 0) return;
+  const target = e.target as Node;
+  const inMenu = menuRef.value?.contains(target);
+  const inSub = subRef.value?.contains(target);
+  if (!inMenu && !inSub) {
+    close();
+  }
+}
+
+function onScroll() {
+  close();
+}
+
+function onKeydown(e: KeyboardEvent) {
+  if (e.key === "Escape") close();
+}
+
+function onResize() {
+  close();
+}
+
+watch(show, (val) => {
+  if (val) {
+    openMenus.add(close);
+    document.addEventListener("pointerdown", onPointerDownOutside, true);
+    document.addEventListener("keydown", onKeydown);
+    document.addEventListener("scroll", onScroll, true);
+    window.addEventListener("resize", onResize);
+  } else {
+    openMenus.delete(close);
+    document.removeEventListener("pointerdown", onPointerDownOutside, true);
+    document.removeEventListener("keydown", onKeydown);
+    document.removeEventListener("scroll", onScroll, true);
+    window.removeEventListener("resize", onResize);
+  }
+});
+
+function handleItemClick(item: ContextMenuItem) {
+  if (item.disabled) return;
+  if (item.children?.length) return; // submenu trigger — do nothing on click
+  close();
+  item.action?.();
+}
+
+function handleSubItemClick(item: ContextMenuItem) {
+  if (item.disabled) return;
+  close();
+  item.action?.();
+}
+
+function onContextMenu(event: MouseEvent) {
+  // Some callers build large context menus; resolve them only for actual opens.
+  const items = typeof props.items === "function" ? props.items() : props.items;
+  if (items.length === 0) return;
+  activeItems.value = items;
+  event.preventDefault();
+  event.stopPropagation();
+  x.value = event.clientX;
+  y.value = event.clientY;
+  show.value = true;
+  nextTick(() => {
+    if (!menuRef.value) return;
+    const rect = menuRef.value.getBoundingClientRect();
+    const vw = window.innerWidth;
+    const vh = window.innerHeight;
+    if (rect.right > vw) x.value = Math.max(0, vw - rect.width - 8);
+    if (rect.bottom > vh) y.value = Math.max(0, vh - rect.height - 8);
+  });
+}
+
+// ---- submenu ----
+
+function onItemMouseEnter(index: number, event: MouseEvent) {
+  lastMouseX = event.clientX;
+  lastMouseY = event.clientY;
+  const item = activeItems.value[index];
+  if (!item?.children?.length || item.disabled) {
+    // Moving to an item without children — close submenu immediately, no delay needed
+    activeSubIndex.value = null;
+    return;
+  }
+  if (subCloseTimer) {
+    clearTimeout(subCloseTimer);
+    subCloseTimer = null;
+  }
+  const trigger = event.currentTarget as HTMLElement;
+  const rect = trigger.getBoundingClientRect();
+  subAnchorRect = { left: rect.left, right: rect.right, top: rect.top, bottom: rect.bottom };
+  subX.value = rect.right + 4;
+  subY.value = rect.top;
+  activeSubIndex.value = index;
+  nextTick(() => adjustSubPosition());
+}
+
+function onItemMouseLeave() {
+  if (activeSubIndex.value !== null) {
+    scheduleSubClose();
+  }
+}
+
+// Last known mouse position (from hover events, without a global mousemove listener)
+let lastMouseX = 0;
+let lastMouseY = 0;
+
+function isMouseOverSub(): boolean {
+  if (!subRef.value) return false;
+  const rect = subRef.value.getBoundingClientRect();
+  return lastMouseX >= rect.left && lastMouseX <= rect.right && lastMouseY >= rect.top && lastMouseY <= rect.bottom;
+}
+
+function scheduleSubClose() {
+  if (subCloseTimer) clearTimeout(subCloseTimer);
+  subCloseTimer = setTimeout(() => {
+    if (!isMouseOverSub()) {
+      activeSubIndex.value = null;
+    }
+  }, 150);
+}
+
+function onSubMouseEnter() {
+  if (subCloseTimer) {
+    clearTimeout(subCloseTimer);
+    subCloseTimer = null;
+  }
+}
+
+function onSubMouseLeave() {
+  activeSubIndex.value = null;
+}
+
+function adjustSubPosition() {
+  if (!subRef.value) return;
+  const rect = subRef.value.getBoundingClientRect();
+  const vw = window.innerWidth;
+  const vh = window.innerHeight;
+  const margin = 8;
+  const gap = 4;
+  if (subAnchorRect) {
+    const rightX = subAnchorRect.right + gap;
+    const leftX = subAnchorRect.left - rect.width - gap;
+    if (rightX + rect.width <= vw - margin) {
+      subX.value = rightX;
+    } else if (leftX >= margin) {
+      subX.value = leftX;
+    } else {
+      subX.value = Math.max(margin, Math.min(rightX, vw - rect.width - margin));
+    }
+  } else if (rect.right > vw - margin) {
+    subX.value = Math.max(margin, vw - rect.width - margin);
+  }
+  if (rect.bottom > vh - margin) {
+    subY.value = Math.max(margin, vh - rect.height - margin);
+  } else if (rect.top < margin) {
+    subY.value = margin;
+  }
+  // When the submenu flips left due to right-edge overflow, it may land
+  // under the mouse cursor. Since the mouse didn't move, mouseenter won't
+  // fire — cancel any pending close to prevent the submenu from flashing.
+  nextTick(() => {
+    if (isMouseOverSub() && subCloseTimer) {
+      clearTimeout(subCloseTimer);
+      subCloseTimer = null;
+    }
+  });
+}
+
+function itemButtonClass(variant?: "default" | "destructive") {
+  return [
+    "w-full gap-2 rounded-md px-2 py-1 text-[13px] leading-4 outline-hidden select-none text-left cursor-default flex items-center disabled:pointer-events-none disabled:opacity-50",
+    variant === "destructive" ? "text-destructive hover:bg-destructive/10 hover:text-destructive focus-visible:bg-destructive/10 focus-visible:text-destructive" : "hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground",
+  ];
+}
+
+function shortcutKeys(shortcut?: string): string[] {
+  return shortcutDisplayKeys(shortcut);
+}
+
+onBeforeUnmount(() => {
+  openMenus.delete(close);
+  document.removeEventListener("pointerdown", onPointerDownOutside, true);
+  document.removeEventListener("keydown", onKeydown);
+  document.removeEventListener("scroll", onScroll, true);
+  window.removeEventListener("resize", onResize);
+});
+</script>
+
+<template>
+  <slot :onContextMenu="onContextMenu" />
+  <!-- Main menu -->
+  <Teleport to="body">
+    <div v-if="show" ref="menuRef" :style="{ position: 'fixed', left: x + 'px', top: y + 'px', zIndex: 9999 }" class="bg-popover text-popover-foreground min-w-40 w-max max-w-[calc(100vw-16px)] rounded-[6px] p-1 overflow-y-auto ring-1 ring-foreground/10 shadow-lg">
+      <template v-for="(item, index) in activeItems" :key="index">
+        <template v-if="item.visible !== false">
+          <div v-if="item.separator" class="-mx-1 my-1 flex items-center px-1">
+            <div class="h-px flex-1 bg-border/70" />
+          </div>
+          <button v-else :disabled="item.disabled" :class="[...itemButtonClass(item.variant), activeSubIndex === index ? 'bg-accent text-accent-foreground' : '']" @click="handleItemClick(item)" @mouseenter="(e) => onItemMouseEnter(index, e)" @mouseleave="onItemMouseLeave">
+            <span class="flex size-4 shrink-0 items-center justify-center">
+              <component :is="item.icon" v-if="item.icon" :class="['size-4', item.iconClass]" />
+            </span>
+            <span class="flex-1 whitespace-nowrap">{{ item.label }}</span>
+            <span v-if="item.shortcut" class="ml-8 inline-flex shrink-0 items-center gap-1 text-muted-foreground">
+              <kbd v-for="key in shortcutKeys(item.shortcut)" :key="key" class="min-w-4 rounded border border-border/70 bg-muted/60 px-1 py-0.5 text-center font-mono text-[10px] leading-none text-muted-foreground shadow-xs">{{ key }}</kbd>
+            </span>
+            <ChevronRight v-if="item.children?.length" class="ml-auto size-4 text-muted-foreground/80" />
+          </button>
+        </template>
+      </template>
+    </div>
+  </Teleport>
+  <!-- Submenu -->
+  <Teleport to="body">
+    <div
+      v-if="show && activeSubIndex !== null && activeItems[activeSubIndex]?.children?.length"
+      ref="subRef"
+      :style="{ position: 'fixed', left: subX + 'px', top: subY + 'px', zIndex: 10000, maxHeight: 'min(420px, calc(100vh - 16px))' }"
+      class="bg-popover text-popover-foreground min-w-56 w-max max-w-[calc(100vw-16px)] rounded-[6px] p-1 overflow-y-auto ring-1 ring-foreground/10 shadow-lg"
+      @mouseenter="onSubMouseEnter"
+      @mouseleave="onSubMouseLeave"
+    >
+      <template v-for="(child, ci) in activeItems[activeSubIndex]!.children!" :key="ci">
+        <template v-if="child.visible !== false">
+          <div v-if="child.separator" class="-mx-1 my-1 flex items-center px-1">
+            <div class="h-px flex-1 bg-border/70" />
+          </div>
+          <button v-else :disabled="child.disabled" :class="itemButtonClass(child.variant)" @click="handleSubItemClick(child)">
+            <span class="flex size-4 shrink-0 items-center justify-center">
+              <component :is="child.icon" v-if="child.icon" :class="['size-4', child.iconClass]" />
+            </span>
+            <span class="flex-1 whitespace-nowrap">{{ child.label }}</span>
+            <span v-if="child.shortcut" class="ml-8 inline-flex shrink-0 items-center gap-1 text-muted-foreground">
+              <kbd v-for="key in shortcutKeys(child.shortcut)" :key="key" class="min-w-4 rounded border border-border/70 bg-muted/60 px-1 py-0.5 text-center font-mono text-[10px] leading-none text-muted-foreground shadow-xs">{{ key }}</kbd>
+            </span>
+          </button>
+        </template>
+      </template>
+    </div>
+  </Teleport>
+</template>
diff --git a/apps/desktop/src/components/ui/ErrorBanner.vue b/apps/desktop/src/components/ui/ErrorBanner.vue
new file mode 100644
index 0000000..1784012
--- /dev/null
+++ b/apps/desktop/src/components/ui/ErrorBanner.vue
@@ -0,0 +1,71 @@
+<script setup lang="ts">
+import { computed } from "vue";
+import { Copy, TriangleAlert } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { useToast } from "@/composables/useToast";
+
+const { t } = useI18n();
+const { toast } = useToast();
+
+const props = withDefaults(
+  defineProps<{
+    message: string;
+    variant?: "banner" | "centered";
+    title?: string;
+    dismissible?: boolean;
+    copyMode?: "icon" | "label";
+  }>(),
+  {
+    variant: "banner",
+    dismissible: false,
+    copyMode: "icon",
+  },
+);
+
+const emit = defineEmits<{
+  dismiss: [];
+}>();
+
+const displayTitle = computed(() => props.title ?? t("grid.queryError"));
+
+async function copy() {
+  try {
+    await copyToClipboard(props.message);
+    toast(t("grid.copied"));
+  } catch (e: any) {
+    toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+  }
+}
+</script>
+
+<template>
+  <!-- banner: 紧凑内联横幅 -->
+  <div v-if="variant === 'banner'" class="flex items-center gap-2 px-3 py-1.5 border-t bg-destructive/10 text-destructive text-xs shrink-0">
+    <span class="flex-1 min-w-0 break-all">{{ message }}</span>
+    <button v-if="copyMode === 'label'" type="button" class="shrink-0 hover:underline" :aria-label="t('grid.copy')" @click.stop="copy">
+      {{ t("grid.copy") }}
+    </button>
+    <Button v-else variant="ghost" size="icon-sm" class="h-5 w-5 shrink-0 text-destructive/70 hover:text-destructive" :aria-label="t('grid.copy')" @click.stop="copy">
+      <Copy class="h-3 w-3" />
+    </Button>
+    <button v-if="dismissible" type="button" class="shrink-0 hover:underline" @click.stop="emit('dismiss')">{{ t("grid.dismiss") }}</button>
+  </div>
+
+  <!-- centered: 居中占满 -->
+  <div v-else class="flex-1 min-h-0 flex flex-col items-center justify-center gap-2 px-6 py-4 text-center">
+    <TriangleAlert class="h-8 w-8 text-destructive/50" aria-hidden="true" />
+    <div class="min-h-0 max-h-48 max-w-lg overflow-auto space-y-1 select-text text-destructive" @mousedown.stop @click.stop>
+      <div class="text-sm font-medium">{{ displayTitle }}</div>
+      <div class="text-xs break-all cursor-text text-destructive/80 select-text">{{ message }}</div>
+    </div>
+    <div class="shrink-0 flex flex-wrap items-center justify-center gap-2 text-foreground">
+      <Button variant="outline" size="sm" class="h-7 gap-1.5 px-2 text-xs" @click.stop="copy">
+        <Copy class="h-3.5 w-3.5" />
+        {{ t("grid.copy") }}
+      </Button>
+      <slot name="actions" />
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/ui/LightDropdown.vue b/apps/desktop/src/components/ui/LightDropdown.vue
new file mode 100644
index 0000000..a209275
--- /dev/null
+++ b/apps/desktop/src/components/ui/LightDropdown.vue
@@ -0,0 +1,198 @@
+<script setup lang="ts">
+import { computed, nextTick, onBeforeUnmount, ref, type Component } from "vue";
+import { Check, ChevronDown } from "@lucide/vue";
+
+export interface LightDropdownItem {
+  label: string;
+  value: string;
+  title?: string;
+  icon?: Component;
+  iconClass?: string;
+  leadingText?: string;
+  disabled?: boolean;
+  separatorBefore?: boolean;
+}
+
+const props = withDefaults(
+  defineProps<{
+    modelValue: string;
+    items: LightDropdownItem[];
+    ariaLabel?: string;
+    contentClass?: string;
+    triggerClass?: string;
+    triggerTitle?: string;
+    triggerIcon?: Component;
+    triggerLabel?: string;
+    disabled?: boolean;
+    showTriggerLabel?: boolean;
+    showChevron?: boolean;
+    checkPosition?: "left" | "right" | "none";
+    align?: "start" | "end";
+    triggerIconClass?: string;
+    itemIconClass?: string;
+    itemClass?: string;
+    labelClass?: string;
+    selectedValues?: string[];
+    highlightSelected?: boolean;
+    selectedItemClass?: string;
+    selectedCheckClass?: string;
+    closeOnSelect?: boolean;
+    label?: string;
+    matchTriggerWidth?: boolean;
+  }>(),
+  {
+    ariaLabel: undefined,
+    contentClass: "",
+    triggerClass: "flex items-center gap-1 rounded-[6px] border px-2 py-0.5 text-[11px] text-muted-foreground hover:bg-muted hover:text-foreground",
+    triggerTitle: undefined,
+    triggerIcon: undefined,
+    triggerLabel: undefined,
+    disabled: false,
+    showTriggerLabel: true,
+    showChevron: true,
+    checkPosition: "left",
+    align: "start",
+    triggerIconClass: "h-3 w-3",
+    itemIconClass: "h-3 w-3",
+    itemClass: "",
+    labelClass: "text-muted-foreground px-1.5 py-1 text-xs font-medium",
+    selectedValues: undefined,
+    highlightSelected: true,
+    selectedItemClass: "bg-accent",
+    selectedCheckClass: "",
+    closeOnSelect: true,
+    label: undefined,
+    matchTriggerWidth: true,
+  },
+);
+
+const emit = defineEmits<{
+  "update:modelValue": [value: string];
+}>();
+
+const triggerRef = ref<HTMLButtonElement>();
+const menuRef = ref<HTMLElement>();
+const open = ref(false);
+const x = ref(0);
+const y = ref(0);
+const minWidth = ref(0);
+
+const selectedItem = computed(() => props.items.find((item) => item.value === props.modelValue));
+const triggerIcon = computed(() => props.triggerIcon ?? selectedItem.value?.icon);
+const menuStyle = computed(() => ({
+  left: `${x.value}px`,
+  top: `${y.value}px`,
+  minWidth: props.matchTriggerWidth ? `${minWidth.value}px` : undefined,
+}));
+
+function close() {
+  open.value = false;
+  document.removeEventListener("pointerdown", onOutsidePointerDown, true);
+  document.removeEventListener("keydown", onKeydown);
+  window.removeEventListener("scroll", close, true);
+  window.removeEventListener("resize", close);
+}
+
+function updatePosition() {
+  const trigger = triggerRef.value;
+  if (!trigger) return;
+  const rect = trigger.getBoundingClientRect();
+  x.value = Math.min(Math.max(8, rect.left), window.innerWidth - 8);
+  y.value = rect.bottom + 4;
+  minWidth.value = rect.width;
+}
+
+function fitPositionToViewport() {
+  const trigger = triggerRef.value;
+  const menu = menuRef.value;
+  if (!trigger || !menu) return;
+  const triggerRect = trigger.getBoundingClientRect();
+  const menuRect = menu.getBoundingClientRect();
+  const gap = 4;
+  const margin = 8;
+  const openBelow = triggerRect.bottom + gap + menuRect.height <= window.innerHeight - margin;
+  const preferredX = props.align === "end" ? triggerRect.right - menuRect.width : triggerRect.left;
+  x.value = Math.min(Math.max(margin, preferredX), Math.max(margin, window.innerWidth - menuRect.width - margin));
+  y.value = openBelow ? triggerRect.bottom + gap : Math.max(margin, triggerRect.top - menuRect.height - gap);
+}
+
+function openMenu() {
+  if (props.disabled) return;
+  updatePosition();
+  open.value = true;
+  nextTick(fitPositionToViewport);
+  document.addEventListener("pointerdown", onOutsidePointerDown, true);
+  document.addEventListener("keydown", onKeydown);
+  window.addEventListener("scroll", close, true);
+  window.addEventListener("resize", close);
+}
+
+function toggle() {
+  if (open.value) {
+    close();
+  } else {
+    openMenu();
+  }
+}
+
+function onOutsidePointerDown(event: PointerEvent) {
+  const target = event.target as Node;
+  if (triggerRef.value?.contains(target) || menuRef.value?.contains(target)) return;
+  close();
+}
+
+function onKeydown(event: KeyboardEvent) {
+  if (event.key === "Escape") {
+    event.preventDefault();
+    close();
+  }
+}
+
+function isItemSelected(item: LightDropdownItem) {
+  if (props.selectedValues) return props.selectedValues.includes(item.value);
+  return item.value === props.modelValue;
+}
+
+function selectItem(item: LightDropdownItem) {
+  if (item.disabled) return;
+  emit("update:modelValue", item.value);
+  if (props.closeOnSelect) close();
+}
+
+onBeforeUnmount(close);
+</script>
+
+<template>
+  <button ref="triggerRef" type="button" :class="triggerClass" :title="triggerTitle ?? selectedItem?.title" :aria-label="ariaLabel" :aria-expanded="open" :disabled="disabled" @click="toggle">
+    <component :is="triggerIcon" v-if="triggerIcon" :class="triggerIconClass" />
+    <span v-if="showTriggerLabel">{{ triggerLabel ?? selectedItem?.label }}</span>
+    <ChevronDown v-if="showChevron" class="h-3 w-3 opacity-50" />
+  </button>
+  <Teleport to="body">
+    <div v-if="open" ref="menuRef" class="fixed z-50 min-w-32 rounded-[6px] p-1 cn-menu-translucent text-popover-foreground" :class="contentClass" :style="menuStyle" role="menu">
+      <div v-if="label" :class="labelClass">{{ label }}</div>
+      <div v-if="label" class="bg-border -mx-1 my-1 h-px" />
+      <template v-for="item in items" :key="item.value">
+        <div v-if="item.separatorBefore" class="bg-border -mx-1 my-1 h-px" />
+        <button
+          type="button"
+          class="flex w-full items-center gap-1.5 rounded-md px-1.5 py-1 text-left text-sm outline-hidden hover:bg-accent hover:text-accent-foreground disabled:pointer-events-none disabled:opacity-50"
+          :class="[itemClass, highlightSelected && isItemSelected(item) ? selectedItemClass : '']"
+          :disabled="item.disabled"
+          :title="item.title"
+          role="menuitem"
+          @click="selectItem(item)"
+        >
+          <Check v-if="checkPosition === 'left'" class="h-3 w-3 shrink-0" :class="[isItemSelected(item) ? selectedCheckClass : 'opacity-0']" />
+          <span v-if="item.leadingText" class="inline-flex h-5 w-6 shrink-0 items-center justify-center text-sm font-medium leading-none">
+            {{ item.leadingText }}
+          </span>
+          <component :is="item.icon" v-if="item.icon" :class="[itemIconClass, 'shrink-0 text-muted-foreground', item.iconClass]" />
+          <span class="truncate">{{ item.label }}</span>
+          <Check v-if="checkPosition === 'right' && isItemSelected(item)" class="ml-auto h-4 w-4 shrink-0" :class="selectedCheckClass" />
+        </button>
+      </template>
+      <slot />
+    </div>
+  </Teleport>
+</template>
diff --git a/apps/desktop/src/components/ui/LightDropdownMenu.vue b/apps/desktop/src/components/ui/LightDropdownMenu.vue
new file mode 100644
index 0000000..9840ef3
--- /dev/null
+++ b/apps/desktop/src/components/ui/LightDropdownMenu.vue
@@ -0,0 +1,299 @@
+<script setup lang="ts">
+import type { Component, HTMLAttributes } from "vue";
+import { computed, nextTick, onBeforeUnmount, ref, watch } from "vue";
+import { Check, ChevronDown } from "@lucide/vue";
+import { cn } from "@/lib/common/utils";
+
+export interface LightDropdownMenuItem {
+  label: string;
+  value: string;
+  title?: string;
+  icon?: Component;
+  iconClass?: HTMLAttributes["class"];
+  leadingText?: string;
+  shortcut?: string;
+  disabled?: boolean;
+  separatorBefore?: boolean;
+  destructive?: boolean;
+  checked?: boolean;
+  closeOnSelect?: boolean;
+  onSelect?: () => void;
+}
+
+const props = withDefaults(
+  defineProps<{
+    items: LightDropdownMenuItem[];
+    ariaLabel?: string;
+    label?: string;
+    triggerLabel?: string;
+    triggerTitle?: string;
+    triggerIcon?: Component;
+    showTriggerLabel?: boolean;
+    showChevron?: boolean;
+    disabled?: boolean;
+    open?: boolean;
+    selectedValue?: string;
+    selectedValues?: string[];
+    checkPosition?: "left" | "right" | "none";
+    align?: "start" | "end";
+    side?: "top" | "bottom";
+    sideOffset?: number;
+    matchTriggerWidth?: boolean;
+    closeOnSelect?: boolean;
+    triggerClass?: HTMLAttributes["class"];
+    triggerIconClass?: HTMLAttributes["class"];
+    contentClass?: HTMLAttributes["class"];
+    labelClass?: HTMLAttributes["class"];
+    itemClass?: HTMLAttributes["class"];
+    itemIconClass?: HTMLAttributes["class"];
+    selectedItemClass?: HTMLAttributes["class"];
+    selectedCheckClass?: HTMLAttributes["class"];
+  }>(),
+  {
+    ariaLabel: undefined,
+    label: undefined,
+    triggerLabel: undefined,
+    triggerTitle: undefined,
+    triggerIcon: undefined,
+    showTriggerLabel: true,
+    showChevron: true,
+    disabled: false,
+    open: undefined,
+    selectedValue: undefined,
+    selectedValues: undefined,
+    checkPosition: "left",
+    align: "start",
+    side: "bottom",
+    sideOffset: 4,
+    matchTriggerWidth: true,
+    closeOnSelect: true,
+    triggerClass: "flex h-6 items-center gap-1 rounded-[6px] border border-border bg-background px-2 text-[11px] text-muted-foreground hover:bg-muted hover:text-foreground disabled:pointer-events-none disabled:opacity-50 aria-expanded:bg-muted aria-expanded:text-foreground",
+    triggerIconClass: "h-3 w-3",
+    contentClass: "",
+    labelClass: "",
+    itemClass: "",
+    itemIconClass: "h-3.5 w-3.5",
+    selectedItemClass: "bg-accent",
+    selectedCheckClass: "",
+  },
+);
+
+const emit = defineEmits<{
+  select: [value: string, item: LightDropdownMenuItem];
+  "update:open": [open: boolean];
+}>();
+
+const triggerRef = ref<HTMLElement>();
+const menuRef = ref<HTMLElement>();
+const internalOpen = ref(false);
+const x = ref(0);
+const y = ref(0);
+const minWidth = ref(0);
+let listenersAttached = false;
+
+const isOpen = computed(() => props.open ?? internalOpen.value);
+
+const menuStyle = computed(() => ({
+  left: `${x.value}px`,
+  top: `${y.value}px`,
+  minWidth: props.matchTriggerWidth ? `${minWidth.value}px` : undefined,
+  "--reka-dropdown-menu-trigger-width": `${minWidth.value}px`,
+  "--reka-dropdown-menu-content-available-height": "calc(100vh - 16px)",
+}));
+
+function setOpen(value: boolean) {
+  if (props.open === undefined) {
+    internalOpen.value = value;
+  }
+  emit("update:open", value);
+}
+
+function removeMenuListeners() {
+  if (!listenersAttached) return;
+  document.removeEventListener("pointerdown", onOutsidePointerDown, true);
+  document.removeEventListener("keydown", onKeydown);
+  window.removeEventListener("scroll", close, true);
+  window.removeEventListener("resize", close);
+  listenersAttached = false;
+}
+
+function close() {
+  setOpen(false);
+  removeMenuListeners();
+}
+
+function updatePosition() {
+  const trigger = triggerRef.value;
+  if (!trigger) return;
+
+  const rect = trigger.getBoundingClientRect();
+  x.value = Math.min(Math.max(8, rect.left), window.innerWidth - 8);
+  y.value = props.side === "top" ? rect.top - props.sideOffset : rect.bottom + props.sideOffset;
+  minWidth.value = rect.width;
+}
+
+function fitPositionToViewport() {
+  const trigger = triggerRef.value;
+  const menu = menuRef.value;
+  if (!trigger || !menu) return;
+
+  const triggerRect = trigger.getBoundingClientRect();
+  const menuRect = menu.getBoundingClientRect();
+  const margin = 8;
+  const preferredX = props.align === "end" ? triggerRect.right - menuRect.width : triggerRect.left;
+  const belowY = triggerRect.bottom + props.sideOffset;
+  const aboveY = triggerRect.top - menuRect.height - props.sideOffset;
+  const fitsBelow = belowY + menuRect.height <= window.innerHeight - margin;
+  const fitsAbove = aboveY >= margin;
+
+  x.value = Math.min(Math.max(margin, preferredX), Math.max(margin, window.innerWidth - menuRect.width - margin));
+  y.value = props.side === "top" && fitsAbove ? aboveY : props.side === "bottom" && fitsBelow ? belowY : fitsBelow ? belowY : Math.max(margin, aboveY);
+}
+
+function openMenu() {
+  if (props.disabled) return;
+  updatePosition();
+  setOpen(true);
+  nextTick(fitPositionToViewport);
+  removeMenuListeners();
+  document.addEventListener("pointerdown", onOutsidePointerDown, true);
+  document.addEventListener("keydown", onKeydown);
+  window.addEventListener("scroll", close, true);
+  window.addEventListener("resize", close);
+  listenersAttached = true;
+}
+
+function toggle() {
+  if (isOpen.value) {
+    close();
+  } else {
+    openMenu();
+  }
+}
+
+function onOutsidePointerDown(event: PointerEvent) {
+  const target = event.target as Node;
+  if (triggerRef.value?.contains(target) || menuRef.value?.contains(target)) return;
+  close();
+}
+
+function onKeydown(event: KeyboardEvent) {
+  if (event.key === "Escape") {
+    event.preventDefault();
+    close();
+  } else if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+    event.preventDefault();
+    focusMenuItem(event.key === "ArrowDown" ? 1 : -1);
+  } else if (event.key === "Home") {
+    event.preventDefault();
+    focusFirstMenuItem();
+  } else if (event.key === "End") {
+    event.preventDefault();
+    focusLastMenuItem();
+  }
+}
+
+function menuItems() {
+  return Array.from(menuRef.value?.querySelectorAll<HTMLButtonElement>("[role='menuitem']:not(:disabled)") ?? []);
+}
+
+function focusMenuItem(direction: 1 | -1) {
+  const items = menuItems();
+  if (items.length === 0) return;
+
+  const currentIndex = items.indexOf(document.activeElement as HTMLButtonElement);
+  const nextIndex = currentIndex === -1 ? (direction === 1 ? 0 : items.length - 1) : (currentIndex + direction + items.length) % items.length;
+  items[nextIndex]?.focus();
+}
+
+function focusFirstMenuItem() {
+  menuItems()[0]?.focus();
+}
+
+function focusLastMenuItem() {
+  const items = menuItems();
+  items[items.length - 1]?.focus();
+}
+
+function itemIsSelected(item: LightDropdownMenuItem) {
+  if (item.checked !== undefined) return item.checked;
+  if (props.selectedValues) return props.selectedValues.includes(item.value);
+  return props.selectedValue === item.value;
+}
+
+function selectItem(item: LightDropdownMenuItem) {
+  if (item.disabled) return;
+
+  emit("select", item.value, item);
+  item.onSelect?.();
+
+  if (item.closeOnSelect ?? props.closeOnSelect) {
+    close();
+  }
+}
+
+onBeforeUnmount(() => {
+  removeMenuListeners();
+});
+
+watch(
+  () => props.open,
+  (value) => {
+    if (value === false) {
+      removeMenuListeners();
+    }
+  },
+);
+</script>
+
+<template>
+  <span ref="triggerRef" class="inline-flex min-w-0" @click="toggle">
+    <slot name="trigger" :open="isOpen" :toggle="toggle" :disabled="disabled">
+      <button type="button" :class="triggerClass" :title="triggerTitle" :aria-label="ariaLabel" :aria-expanded="isOpen" :disabled="disabled">
+        <component :is="triggerIcon" v-if="triggerIcon" :class="triggerIconClass" />
+        <span v-if="showTriggerLabel && triggerLabel" class="truncate">{{ triggerLabel }}</span>
+        <ChevronDown v-if="showChevron" class="h-3 w-3 shrink-0 opacity-50" />
+      </button>
+    </slot>
+  </span>
+  <Teleport to="body">
+    <div
+      v-if="isOpen"
+      ref="menuRef"
+      class="ring-foreground/10 fixed z-50 max-h-(--reka-dropdown-menu-content-available-height) min-w-32 overflow-x-hidden overflow-y-auto rounded-[6px] p-1 ring-1 cn-menu-translucent text-popover-foreground"
+      :class="cn(matchTriggerWidth ? 'w-(--reka-dropdown-menu-trigger-width)' : '', contentClass)"
+      :style="menuStyle"
+      role="menu"
+    >
+      <div v-if="label" :class="cn('text-muted-foreground px-1.5 py-1 text-xs font-medium', labelClass)">{{ label }}</div>
+      <div v-if="label" class="bg-border -mx-1 my-1 h-px" />
+      <slot name="before-items" />
+      <template v-for="item in items" :key="item.value">
+        <div v-if="item.separatorBefore" class="bg-border -mx-1 my-1 h-px" />
+        <slot name="item" :item="item" :selected="itemIsSelected(item)" :select="selectItem">
+          <button
+            type="button"
+            class="group/dropdown-menu-item relative flex w-full cursor-default select-none items-center gap-1.5 rounded-md px-1.5 py-1 text-left text-sm outline-hidden hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*=size-])]:size-4"
+            :class="
+              cn(item.destructive ? 'text-destructive hover:bg-destructive/10 hover:text-destructive focus:bg-destructive/10 focus:text-destructive dark:hover:bg-destructive/20 dark:focus:bg-destructive/20 [&_svg]:text-destructive' : '', itemIsSelected(item) ? selectedItemClass : '', itemClass)
+            "
+            :disabled="item.disabled"
+            :title="item.title"
+            role="menuitem"
+            @click="selectItem(item)"
+          >
+            <Check v-if="checkPosition === 'left'" class="h-3 w-3 shrink-0" :class="itemIsSelected(item) ? selectedCheckClass : 'opacity-0'" />
+            <span v-if="item.leadingText" class="inline-flex h-5 w-6 shrink-0 items-center justify-center text-sm font-medium leading-none">
+              {{ item.leadingText }}
+            </span>
+            <component :is="item.icon" v-if="item.icon" :class="cn('shrink-0 text-muted-foreground', itemIconClass, item.iconClass)" />
+            <span class="min-w-0 flex-1 truncate">{{ item.label }}</span>
+            <span v-if="item.shortcut" class="ml-4 shrink-0 text-xs text-muted-foreground">{{ item.shortcut }}</span>
+            <Check v-if="checkPosition === 'right' && itemIsSelected(item)" class="ml-auto h-4 w-4 shrink-0" :class="selectedCheckClass" />
+          </button>
+        </slot>
+      </template>
+      <slot />
+    </div>
+  </Teleport>
+</template>
diff --git a/apps/desktop/src/components/ui/LightTooltip.vue b/apps/desktop/src/components/ui/LightTooltip.vue
new file mode 100644
index 0000000..dd8510e
--- /dev/null
+++ b/apps/desktop/src/components/ui/LightTooltip.vue
@@ -0,0 +1,261 @@
+<script setup lang="ts">
+import { computed, onBeforeUnmount, ref, watch } from "vue";
+
+const props = withDefaults(
+  defineProps<{
+    text: string;
+    disabled?: boolean | (() => boolean);
+    side?: "top" | "right" | "bottom" | "left";
+    sideOffset?: number;
+    delay?: number;
+    closeDelay?: number;
+    openOnFocus?: boolean;
+    nowrap?: boolean;
+    surface?: "foreground" | "popover";
+  }>(),
+  {
+    disabled: false,
+    side: "top",
+    sideOffset: 8,
+    delay: 300,
+    closeDelay: 100,
+    openOnFocus: true,
+    nowrap: false,
+    surface: "foreground",
+  },
+);
+
+const triggerRef = ref<HTMLElement>();
+const tooltipRef = ref<HTMLElement>();
+const show = ref(false);
+const x = ref(0);
+const y = ref(0);
+let timer: ReturnType<typeof setTimeout> | null = null;
+let closeTimer: ReturnType<typeof setTimeout> | null = null;
+let suppressOpenUntil = 0;
+let openSource: "hover" | "focus" | null = null;
+
+function clearCloseTimer() {
+  if (!closeTimer) return;
+  clearTimeout(closeTimer);
+  closeTimer = null;
+}
+
+function triggerElement(): HTMLElement | undefined {
+  const root = triggerRef.value;
+  const child = root?.firstElementChild;
+  return child instanceof HTMLElement ? child : root;
+}
+
+const tooltipTransformClass = computed(() => {
+  switch (props.side) {
+    case "right":
+      return "-translate-y-1/2";
+    case "left":
+      return "-translate-x-full -translate-y-1/2";
+    case "bottom":
+      return "-translate-x-1/2";
+    case "top":
+    default:
+      return "-translate-x-1/2 -translate-y-full";
+  }
+});
+
+const arrowClass = computed(() => {
+  switch (props.side) {
+    case "right":
+      return "absolute -left-1.25 top-1/2 -translate-y-1/2 border-b border-l";
+    case "left":
+      return "absolute -right-1.25 top-1/2 -translate-y-1/2 border-t border-r";
+    case "bottom":
+      return "absolute -top-1.25 left-1/2 -translate-x-1/2 border-t border-l";
+    case "top":
+    default:
+      return "absolute -bottom-1.25 left-1/2 -translate-x-1/2 border-b border-r";
+  }
+});
+
+const tooltipSurfaceClass = computed(() => (props.surface === "popover" ? "bg-popover text-popover-foreground" : "bg-foreground text-background"));
+
+const arrowSurfaceClass = computed(() => (props.surface === "popover" ? "bg-popover border-border" : "bg-foreground border-foreground"));
+
+function clearTimer() {
+  if (!timer) return;
+  clearTimeout(timer);
+  timer = null;
+}
+
+function isPointerActive(): boolean {
+  const el = triggerElement();
+  if (!el || !el.isConnected) return false;
+  return el.matches(":hover") || tooltipRef.value?.matches(":hover") || false;
+}
+
+function isFocusActive(): boolean {
+  const el = triggerElement();
+  const active = document.activeElement;
+  return !!el && active instanceof Node && el.contains(active);
+}
+
+function hasFocusVisible(): boolean {
+  const el = triggerElement();
+  const root = triggerRef.value;
+  if (!el || !root) return false;
+  try {
+    return el.matches(":focus-visible") || !!root.querySelector(":focus-visible");
+  } catch {
+    return false;
+  }
+}
+
+function isOpenSourceActive(): boolean {
+  return openSource === "focus" ? isFocusActive() : isPointerActive();
+}
+
+function isDisabled(): boolean {
+  return typeof props.disabled === "function" ? props.disabled() : props.disabled;
+}
+
+function updatePosition() {
+  const el = triggerElement();
+  if (!el) return;
+  const rect = el.getBoundingClientRect();
+  const offset = props.sideOffset;
+  switch (props.side) {
+    case "right":
+      x.value = Math.min(window.innerWidth - 8, rect.right + offset);
+      y.value = Math.min(Math.max(8, rect.top + rect.height / 2), window.innerHeight - 8);
+      break;
+    case "left":
+      x.value = Math.max(8, rect.left - offset);
+      y.value = Math.min(Math.max(8, rect.top + rect.height / 2), window.innerHeight - 8);
+      break;
+    case "bottom":
+      x.value = Math.min(Math.max(8, rect.left + rect.width / 2), window.innerWidth - 8);
+      y.value = Math.min(window.innerHeight - 8, rect.bottom + offset);
+      break;
+    case "top":
+    default:
+      x.value = Math.min(Math.max(8, rect.left + rect.width / 2), window.innerWidth - 8);
+      y.value = Math.max(8, rect.top - offset);
+      break;
+  }
+}
+
+function close() {
+  clearTimer();
+  clearCloseTimer();
+  show.value = false;
+  openSource = null;
+  removeGlobalListeners();
+}
+
+function suppressForContextMenu() {
+  suppressOpenUntil = Date.now() + 250;
+  close();
+}
+
+function closeIfTriggerInactive() {
+  if (isOpenSourceActive()) {
+    clearCloseTimer();
+  } else {
+    scheduleClose();
+  }
+}
+
+function scheduleClose() {
+  if (props.closeDelay <= 0) {
+    if (!isOpenSourceActive()) close();
+    return;
+  }
+  if (closeTimer) return;
+  closeTimer = setTimeout(() => {
+    closeTimer = null;
+    if (!isOpenSourceActive()) close();
+  }, props.closeDelay);
+}
+
+function onPointerDown(e: PointerEvent) {
+  if (tooltipRef.value?.contains(e.target as Node)) return;
+  close();
+}
+
+function addGlobalListeners() {
+  window.addEventListener("scroll", close, true);
+  window.addEventListener("resize", close);
+  window.addEventListener("blur", close);
+  document.addEventListener("visibilitychange", close);
+  document.addEventListener("pointermove", closeIfTriggerInactive, true);
+  document.addEventListener("pointerdown", onPointerDown, true);
+  document.addEventListener("contextmenu", close, true);
+}
+
+function removeGlobalListeners() {
+  window.removeEventListener("scroll", close, true);
+  window.removeEventListener("resize", close);
+  window.removeEventListener("blur", close);
+  document.removeEventListener("visibilitychange", close);
+  document.removeEventListener("pointermove", closeIfTriggerInactive, true);
+  document.removeEventListener("pointerdown", onPointerDown, true);
+  document.removeEventListener("contextmenu", close, true);
+}
+
+const slots = defineSlots<{ default(): any; content?(): any }>();
+const hasContent = computed(() => !!props.text || !!slots.content);
+
+function open(source: "hover" | "focus") {
+  if (Date.now() < suppressOpenUntil) return;
+  if (isDisabled() || !hasContent.value) return;
+  if (source === "focus" ? !hasFocusVisible() : !isPointerActive()) return;
+  updatePosition();
+  openSource = source;
+  show.value = true;
+  addGlobalListeners();
+}
+
+function scheduleOpen(source: "hover" | "focus" = "hover") {
+  if (Date.now() < suppressOpenUntil) return;
+  if (isDisabled() || !hasContent.value) return;
+  clearTimer();
+  timer = setTimeout(() => open(source), props.delay);
+}
+
+function scheduleFocusOpen() {
+  if (!props.openOnFocus) return;
+  if (!hasFocusVisible()) return;
+  scheduleOpen("focus");
+}
+
+onBeforeUnmount(() => {
+  close();
+});
+
+watch(
+  () => [props.disabled, props.text] as const,
+  () => {
+    if (isDisabled() || !props.text) close();
+    else if (show.value) updatePosition();
+  },
+);
+</script>
+
+<template>
+  <span ref="triggerRef" class="contents" @mouseenter="() => scheduleOpen('hover')" @mouseleave="scheduleClose" @focusin="scheduleFocusOpen" @focusout="close" @contextmenu.capture="suppressForContextMenu">
+    <slot />
+  </span>
+  <Teleport to="body">
+    <div
+      v-if="show"
+      ref="tooltipRef"
+      class="fixed z-50 rounded-md text-xs"
+      :class="[tooltipSurfaceClass, slots.content ? '' : ['inline-flex w-fit max-w-xs items-center gap-1.5 px-3 py-1.5', nowrap ? 'whitespace-nowrap' : ''], tooltipTransformClass]"
+      :style="{ left: `${x}px`, top: `${y}px` }"
+      role="tooltip"
+      @mouseenter="clearCloseTimer"
+      @mouseleave="scheduleClose"
+    >
+      <slot name="content">{{ text }}</slot>
+      <span :class="[arrowClass, arrowSurfaceClass, 'size-2.5 rotate-45 rounded-[2px]']" aria-hidden="true" />
+    </div>
+  </Teleport>
+</template>
diff --git a/apps/desktop/src/components/ui/PasswordInput.vue b/apps/desktop/src/components/ui/PasswordInput.vue
new file mode 100644
index 0000000..56fd198
--- /dev/null
+++ b/apps/desktop/src/components/ui/PasswordInput.vue
@@ -0,0 +1,52 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { Eye, EyeOff } from "@lucide/vue";
+import { Input } from "@/components/ui/input";
+
+const model = defineModel<string>();
+
+const props = withDefaults(
+  defineProps<{
+    placeholder?: string;
+    disabled?: boolean;
+    class?: string;
+    inputClass?: string;
+    showToggle?: boolean;
+    showLabel?: string;
+    hideLabel?: string;
+  }>(),
+  {
+    showToggle: true,
+  },
+);
+
+const visible = ref(false);
+const { t } = useI18n();
+const toggleLabel = computed(() => (visible.value ? props.hideLabel || t("common.hidePassword") : props.showLabel || t("common.showPassword")));
+</script>
+
+<template>
+  <div :class="props.class" class="relative">
+    <Input v-model="model" :type="visible ? 'text' : 'password'" :placeholder="placeholder" :disabled="disabled" :class="[props.inputClass, props.showToggle ? 'pr-8' : undefined]" v-bind="$attrs" />
+    <button v-if="props.showToggle" type="button" :disabled="disabled" class="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground disabled:pointer-events-none disabled:opacity-50" :aria-label="toggleLabel" :title="toggleLabel" @click="visible = !visible">
+      <Eye v-if="!visible" class="size-3.5" />
+      <EyeOff v-else class="size-3.5" />
+    </button>
+  </div>
+</template>
+
+<style scoped>
+:deep(input[type="password"]::-ms-reveal),
+:deep(input[type="password"]::-ms-clear) {
+  display: none;
+}
+
+:deep(input[type="password"]::-webkit-credentials-auto-fill-button),
+:deep(input[type="password"]::-webkit-caps-lock-indicator),
+:deep(input[type="password"]::-webkit-contacts-auto-fill-button) {
+  display: none !important;
+  visibility: hidden;
+  pointer-events: none;
+}
+</style>
diff --git a/apps/desktop/src/components/ui/TruncatedTextTooltip.vue b/apps/desktop/src/components/ui/TruncatedTextTooltip.vue
new file mode 100644
index 0000000..f69c23a
--- /dev/null
+++ b/apps/desktop/src/components/ui/TruncatedTextTooltip.vue
@@ -0,0 +1,43 @@
+<script setup lang="ts">
+import { ref } from "vue";
+import type { HTMLAttributes } from "vue";
+import LightTooltip from "@/components/ui/LightTooltip.vue";
+import { cn } from "@/lib/common/utils";
+
+const props = withDefaults(
+  defineProps<{
+    text: string;
+    class?: HTMLAttributes["class"];
+    tooltipClass?: HTMLAttributes["class"];
+    side?: "top" | "right" | "bottom" | "left";
+    sideOffset?: number;
+    delay?: number;
+    openOnFocus?: boolean;
+  }>(),
+  {
+    side: "top",
+    sideOffset: 8,
+    delay: 0,
+    openOnFocus: true,
+  },
+);
+
+const textRef = ref<HTMLElement>();
+
+function isTooltipDisabled(): boolean {
+  const el = textRef.value;
+  if (!el) return true;
+  return el.scrollWidth - el.clientWidth <= 2;
+}
+</script>
+
+<template>
+  <LightTooltip :text="text" :delay="delay" :disabled="isTooltipDisabled" :side="side" :side-offset="sideOffset" :open-on-focus="openOnFocus">
+    <span ref="textRef" :class="cn('truncate', props.class)">
+      <slot>{{ text }}</slot>
+    </span>
+    <template v-if="tooltipClass" #content>
+      <span :class="cn('block max-w-xs px-3 py-1.5', tooltipClass)">{{ text }}</span>
+    </template>
+  </LightTooltip>
+</template>
diff --git a/apps/desktop/src/components/ui/badge/Badge.vue b/apps/desktop/src/components/ui/badge/Badge.vue
new file mode 100644
index 0000000..6e7ee17
--- /dev/null
+++ b/apps/desktop/src/components/ui/badge/Badge.vue
@@ -0,0 +1,24 @@
+<script setup lang="ts">
+import type { PrimitiveProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import type { BadgeVariants } from ".";
+import { reactiveOmit } from "@vueuse/core";
+import { Primitive } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+import { badgeVariants } from ".";
+
+const props = defineProps<
+  PrimitiveProps & {
+    variant?: BadgeVariants["variant"];
+    class?: HTMLAttributes["class"];
+  }
+>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <Primitive data-slot="badge" :data-variant="variant" :class="cn(badgeVariants({ variant }), props.class)" v-bind="delegatedProps">
+    <slot />
+  </Primitive>
+</template>
diff --git a/apps/desktop/src/components/ui/badge/index.ts b/apps/desktop/src/components/ui/badge/index.ts
new file mode 100644
index 0000000..c0a8e59
--- /dev/null
+++ b/apps/desktop/src/components/ui/badge/index.ts
@@ -0,0 +1,24 @@
+import type { VariantProps } from "class-variance-authority";
+import { cva } from "class-variance-authority";
+
+export { default as Badge } from "./Badge.vue";
+
+export const badgeVariants = cva(
+  "h-5 gap-1 rounded-4xl border border-transparent px-2 py-0.5 text-xs font-medium transition-colors has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&>svg]:size-3! group/badge inline-flex w-fit shrink-0 items-center justify-center overflow-hidden whitespace-nowrap focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+        secondary: "bg-secondary text-secondary-foreground [a]:hover:bg-secondary/80",
+        destructive: "bg-destructive/10 [a]:hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 text-destructive dark:bg-destructive/20",
+        outline: "border-border text-foreground [a]:hover:bg-muted [a]:hover:text-muted-foreground",
+        ghost: "hover:bg-muted hover:text-muted-foreground dark:hover:bg-muted/50",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  },
+);
+export type BadgeVariants = VariantProps<typeof badgeVariants>;
diff --git a/apps/desktop/src/components/ui/button/Button.vue b/apps/desktop/src/components/ui/button/Button.vue
new file mode 100644
index 0000000..9cf6b51
--- /dev/null
+++ b/apps/desktop/src/components/ui/button/Button.vue
@@ -0,0 +1,24 @@
+<script setup lang="ts">
+import type { PrimitiveProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import type { ButtonVariants } from ".";
+import { Primitive } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+import { buttonVariants } from ".";
+
+interface Props extends PrimitiveProps {
+  variant?: ButtonVariants["variant"];
+  size?: ButtonVariants["size"];
+  class?: HTMLAttributes["class"];
+}
+
+const props = withDefaults(defineProps<Props>(), {
+  as: "button",
+});
+</script>
+
+<template>
+  <Primitive data-slot="button" :data-variant="variant" :data-size="size" :as="as" :as-child="asChild" :class="cn(buttonVariants({ variant, size }), props.class)">
+    <slot />
+  </Primitive>
+</template>
diff --git a/apps/desktop/src/components/ui/button/index.ts b/apps/desktop/src/components/ui/button/index.ts
new file mode 100644
index 0000000..8466b3f
--- /dev/null
+++ b/apps/desktop/src/components/ui/button/index.ts
@@ -0,0 +1,35 @@
+import type { VariantProps } from "class-variance-authority";
+import { cva } from "class-variance-authority";
+
+export { default as Button } from "./Button.vue";
+
+export const buttonVariants = cva(
+  "focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 rounded-[6px] border border-transparent bg-clip-padding text-sm font-medium focus-visible:ring-3 aria-invalid:ring-3 active:not-aria-[haspopup]:translate-y-px [&_svg:not([class*=size-])]:size-4 group/button inline-flex shrink-0 items-center justify-center whitespace-nowrap transition-colors outline-none select-none disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0",
+  {
+    variants: {
+      variant: {
+        default: "bg-primary text-primary-foreground [a]:hover:bg-primary/80",
+        outline: "border-border bg-background hover:bg-muted hover:text-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50 aria-expanded:bg-muted aria-expanded:text-foreground",
+        secondary: "bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground",
+        ghost: "hover:bg-muted hover:text-foreground dark:hover:bg-muted/50 aria-expanded:bg-muted aria-expanded:text-foreground",
+        destructive: "bg-destructive/10 hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/20 text-destructive focus-visible:border-destructive/40 dark:hover:bg-destructive/30",
+        link: "text-primary underline-offset-4 hover:underline",
+      },
+      size: {
+        default: "h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+        xs: "h-6 gap-1 rounded-[6px] px-2 text-xs in-data-[slot=button-group]:rounded-[6px] has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*=size-])]:size-3",
+        sm: "h-7 gap-1 rounded-[6px] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-[6px] has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*=size-])]:size-3.5",
+        lg: "h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2",
+        icon: "size-8",
+        "icon-xs": "size-6 rounded-[6px] in-data-[slot=button-group]:rounded-[6px] [&_svg:not([class*=size-])]:size-3",
+        "icon-sm": "size-7 rounded-[6px] in-data-[slot=button-group]:rounded-[6px]",
+        "icon-lg": "size-9",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default",
+    },
+  },
+);
+export type ButtonVariants = VariantProps<typeof buttonVariants>;
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenu.vue b/apps/desktop/src/components/ui/context-menu/ContextMenu.vue
new file mode 100644
index 0000000..e35c9ef
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenu.vue
@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import type { ContextMenuRootEmits, ContextMenuRootProps } from "reka-ui";
+import { ContextMenuRoot, useForwardPropsEmits } from "reka-ui";
+
+const props = withDefaults(defineProps<ContextMenuRootProps>(), {
+  modal: false,
+});
+const emits = defineEmits<ContextMenuRootEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <ContextMenuRoot data-slot="context-menu" v-bind="forwarded">
+    <slot />
+  </ContextMenuRoot>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuCheckboxItem.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuCheckboxItem.vue
new file mode 100644
index 0000000..ea53dd7
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuCheckboxItem.vue
@@ -0,0 +1,48 @@
+<script setup lang="ts">
+import type { ContextMenuCheckboxItemEmits, ContextMenuCheckboxItemProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { CheckIcon } from "@lucide/vue";
+import { ContextMenuCheckboxItem, ContextMenuItemIndicator, useForwardPropsEmits } from "reka-ui";
+import { shouldSuppressRepeatedActivation, suppressEvent, type ActionActivationGuard } from "@/lib/connection/actionActivation";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<ContextMenuCheckboxItemProps & { class?: HTMLAttributes["class"] }>();
+const emits = defineEmits<ContextMenuCheckboxItemEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+const activationGuard: ActionActivationGuard = {};
+
+function guardRepeatedClick(event: MouseEvent) {
+  if (props.disabled) return;
+  if (shouldSuppressRepeatedActivation(activationGuard)) {
+    suppressEvent(event);
+  }
+}
+</script>
+
+<template>
+  <ContextMenuCheckboxItem
+    data-slot="context-menu-checkbox-item"
+    v-bind="forwarded"
+    @click.capture="guardRepeatedClick"
+    :class="
+      cn(
+        'focus:bg-accent focus:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm data-inset:pl-7 [&_svg:not([class*=size-])]:size-4 relative flex cursor-default items-center outline-hidden select-none data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        props.class,
+      )
+    "
+  >
+    <span class="absolute right-2 pointer-events-none">
+      <ContextMenuItemIndicator>
+        <slot name="indicator-icon">
+          <CheckIcon />
+        </slot>
+      </ContextMenuItemIndicator>
+    </span>
+    <slot />
+  </ContextMenuCheckboxItem>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuContent.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuContent.vue
new file mode 100644
index 0000000..e324085
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuContent.vue
@@ -0,0 +1,35 @@
+<script setup lang="ts">
+import type { ContextMenuContentEmits, ContextMenuContentProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ContextMenuContent, ContextMenuPortal, useForwardPropsEmits } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+defineOptions({
+  inheritAttrs: false,
+});
+
+const props = defineProps<ContextMenuContentProps & { class?: HTMLAttributes["class"] }>();
+const emits = defineEmits<ContextMenuContentEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <ContextMenuPortal>
+    <ContextMenuContent
+      data-slot="context-menu-content"
+      v-bind="{ ...$attrs, ...forwarded }"
+      :class="
+        cn(
+          'data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 text-popover-foreground min-w-36 rounded-[6px] p-1 duration-100 cn-menu-translucent z-50 max-h-(--reka-context-menu-content-available-height) origin-(--reka-context-menu-content-transform-origin) overflow-x-hidden overflow-y-auto',
+          props.class,
+        )
+      "
+    >
+      <slot />
+    </ContextMenuContent>
+  </ContextMenuPortal>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuGroup.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuGroup.vue
new file mode 100644
index 0000000..863b446
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuGroup.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { ContextMenuGroupProps } from "reka-ui";
+import { ContextMenuGroup } from "reka-ui";
+
+const props = defineProps<ContextMenuGroupProps>();
+</script>
+
+<template>
+  <ContextMenuGroup data-slot="context-menu-group" v-bind="props">
+    <slot />
+  </ContextMenuGroup>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuItem.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuItem.vue
new file mode 100644
index 0000000..a454176
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuItem.vue
@@ -0,0 +1,52 @@
+<script setup lang="ts">
+import type { ContextMenuItemEmits, ContextMenuItemProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ContextMenuItem, useForwardPropsEmits } from "reka-ui";
+import { shouldSuppressRepeatedActivation, suppressEvent, type ActionActivationGuard } from "@/lib/connection/actionActivation";
+import { cn } from "@/lib/common/utils";
+
+const props = withDefaults(
+  defineProps<
+    ContextMenuItemProps & {
+      class?: HTMLAttributes["class"];
+      inset?: boolean;
+      variant?: "default" | "destructive";
+    }
+  >(),
+  {
+    variant: "default",
+  },
+);
+const emits = defineEmits<ContextMenuItemEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+const activationGuard: ActionActivationGuard = {};
+
+function guardRepeatedClick(event: MouseEvent) {
+  if (props.disabled) return;
+  if (shouldSuppressRepeatedActivation(activationGuard)) {
+    suppressEvent(event);
+  }
+}
+</script>
+
+<template>
+  <ContextMenuItem
+    data-slot="context-menu-item"
+    :data-inset="inset ? '' : undefined"
+    :data-variant="variant"
+    v-bind="forwarded"
+    @click.capture="guardRepeatedClick"
+    :class="
+      cn(
+        'focus:bg-accent focus:text-accent-foreground data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 dark:data-[variant=destructive]:focus:bg-destructive/20 data-[variant=destructive]:focus:text-destructive data-[variant=destructive]:*:[svg]:text-destructive focus:*:[svg]:text-accent-foreground gap-2 rounded-md px-2 py-1 text-[13px] data-inset:pl-7 [&_svg:not([class*=size-])]:size-4 group/context-menu-item relative flex cursor-default items-center outline-hidden select-none data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        props.class,
+      )
+    "
+  >
+    <slot />
+  </ContextMenuItem>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuLabel.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuLabel.vue
new file mode 100644
index 0000000..7af0459
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuLabel.vue
@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import type { ContextMenuLabelProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ContextMenuLabel } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<ContextMenuLabelProps & { class?: HTMLAttributes["class"]; inset?: boolean }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <ContextMenuLabel data-slot="context-menu-label" :data-inset="inset ? '' : undefined" v-bind="delegatedProps" :class="cn('text-muted-foreground px-1.5 py-1 text-xs font-medium data-inset:pl-7', props.class)">
+    <slot />
+  </ContextMenuLabel>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuPortal.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuPortal.vue
new file mode 100644
index 0000000..d727134
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuPortal.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { ContextMenuPortalProps } from "reka-ui";
+import { ContextMenuPortal } from "reka-ui";
+
+const props = defineProps<ContextMenuPortalProps>();
+</script>
+
+<template>
+  <ContextMenuPortal data-slot="context-menu-portal" v-bind="props">
+    <slot />
+  </ContextMenuPortal>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuRadioGroup.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuRadioGroup.vue
new file mode 100644
index 0000000..97eeabd
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuRadioGroup.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { ContextMenuRadioGroupEmits, ContextMenuRadioGroupProps } from "reka-ui";
+import { ContextMenuRadioGroup, useForwardPropsEmits } from "reka-ui";
+
+const props = defineProps<ContextMenuRadioGroupProps>();
+const emits = defineEmits<ContextMenuRadioGroupEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <ContextMenuRadioGroup data-slot="context-menu-radio-group" v-bind="forwarded">
+    <slot />
+  </ContextMenuRadioGroup>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuRadioItem.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuRadioItem.vue
new file mode 100644
index 0000000..739e3b8
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuRadioItem.vue
@@ -0,0 +1,48 @@
+<script setup lang="ts">
+import type { ContextMenuRadioItemEmits, ContextMenuRadioItemProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { CheckIcon } from "@lucide/vue";
+import { ContextMenuItemIndicator, ContextMenuRadioItem, useForwardPropsEmits } from "reka-ui";
+import { shouldSuppressRepeatedActivation, suppressEvent, type ActionActivationGuard } from "@/lib/connection/actionActivation";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<ContextMenuRadioItemProps & { class?: HTMLAttributes["class"] }>();
+const emits = defineEmits<ContextMenuRadioItemEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+const activationGuard: ActionActivationGuard = {};
+
+function guardRepeatedClick(event: MouseEvent) {
+  if (props.disabled) return;
+  if (shouldSuppressRepeatedActivation(activationGuard)) {
+    suppressEvent(event);
+  }
+}
+</script>
+
+<template>
+  <ContextMenuRadioItem
+    data-slot="context-menu-radio-item"
+    v-bind="forwarded"
+    @click.capture="guardRepeatedClick"
+    :class="
+      cn(
+        'focus:bg-accent focus:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm data-inset:pl-7 [&_svg:not([class*=size-])]:size-4 relative flex cursor-default items-center outline-hidden select-none data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        props.class,
+      )
+    "
+  >
+    <span class="absolute right-2 pointer-events-none">
+      <ContextMenuItemIndicator>
+        <slot name="indicator-icon">
+          <CheckIcon />
+        </slot>
+      </ContextMenuItemIndicator>
+    </span>
+    <slot />
+  </ContextMenuRadioItem>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuSeparator.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuSeparator.vue
new file mode 100644
index 0000000..c34c85d
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuSeparator.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { ContextMenuSeparatorProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ContextMenuSeparator } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<ContextMenuSeparatorProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <ContextMenuSeparator data-slot="context-menu-separator" v-bind="delegatedProps" :class="cn('bg-foreground/6 -mx-1 my-0.5 h-px', props.class)" />
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuShortcut.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuShortcut.vue
new file mode 100644
index 0000000..ac19bac
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuShortcut.vue
@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"];
+}>();
+</script>
+
+<template>
+  <span data-slot="context-menu-shortcut" :class="cn('text-muted-foreground group-focus/context-menu-item:text-accent-foreground ml-auto text-xs tracking-widest', props.class)">
+    <slot />
+  </span>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuSub.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuSub.vue
new file mode 100644
index 0000000..31bc7e0
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuSub.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { ContextMenuSubEmits, ContextMenuSubProps } from "reka-ui";
+import { ContextMenuSub, useForwardPropsEmits } from "reka-ui";
+
+const props = defineProps<ContextMenuSubProps>();
+const emits = defineEmits<ContextMenuSubEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <ContextMenuSub data-slot="context-menu-sub" v-bind="forwarded">
+    <slot />
+  </ContextMenuSub>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuSubContent.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuSubContent.vue
new file mode 100644
index 0000000..ce2fc26
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuSubContent.vue
@@ -0,0 +1,31 @@
+<script setup lang="ts">
+import type { DropdownMenuSubContentEmits, DropdownMenuSubContentProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ContextMenuPortal, ContextMenuSubContent, useForwardPropsEmits } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<DropdownMenuSubContentProps & { class?: HTMLAttributes["class"] }>();
+const emits = defineEmits<DropdownMenuSubContentEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <ContextMenuPortal>
+    <ContextMenuSubContent
+      data-slot="context-menu-sub-content"
+      v-bind="forwarded"
+      :class="
+        cn(
+          'data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 text-popover-foreground min-w-32 rounded-[6px] ring-foreground/10 ring-1 p-1 duration-100 cn-menu-translucent z-50 origin-(--reka-context-menu-content-transform-origin) overflow-hidden',
+          props.class,
+        )
+      "
+    >
+      <slot />
+    </ContextMenuSubContent>
+  </ContextMenuPortal>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuSubTrigger.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuSubTrigger.vue
new file mode 100644
index 0000000..0a40dc4
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuSubTrigger.vue
@@ -0,0 +1,32 @@
+<script setup lang="ts">
+import type { ContextMenuSubTriggerProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ChevronRightIcon } from "@lucide/vue";
+import { ContextMenuSubTrigger, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<ContextMenuSubTriggerProps & { class?: HTMLAttributes["class"]; inset?: boolean }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <ContextMenuSubTrigger
+    data-slot="context-menu-sub-trigger"
+    :data-inset="inset ? '' : undefined"
+    v-bind="forwardedProps"
+    :class="
+      cn(
+        'focus:bg-accent focus:text-accent-foreground data-open:bg-accent data-open:text-accent-foreground gap-2 rounded-md px-2 py-1 text-[13px] data-inset:pl-7 [&_svg:not([class*=size-])]:size-4 flex cursor-default items-center outline-hidden select-none [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        props.class,
+      )
+    "
+  >
+    <slot />
+    <ChevronRightIcon class="cn-rtl-flip ml-auto" />
+  </ContextMenuSubTrigger>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/ContextMenuTrigger.vue b/apps/desktop/src/components/ui/context-menu/ContextMenuTrigger.vue
new file mode 100644
index 0000000..838c643
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/ContextMenuTrigger.vue
@@ -0,0 +1,18 @@
+<script setup lang="ts">
+import type { ContextMenuTriggerProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ContextMenuTrigger, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<ContextMenuTriggerProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <ContextMenuTrigger data-slot="context-menu-trigger" v-bind="forwardedProps" :class="cn('select-none', props.class)">
+    <slot />
+  </ContextMenuTrigger>
+</template>
diff --git a/apps/desktop/src/components/ui/context-menu/index.ts b/apps/desktop/src/components/ui/context-menu/index.ts
new file mode 100644
index 0000000..947b5ba
--- /dev/null
+++ b/apps/desktop/src/components/ui/context-menu/index.ts
@@ -0,0 +1,14 @@
+export { default as ContextMenu } from "./ContextMenu.vue";
+export { default as ContextMenuCheckboxItem } from "./ContextMenuCheckboxItem.vue";
+export { default as ContextMenuContent } from "./ContextMenuContent.vue";
+export { default as ContextMenuGroup } from "./ContextMenuGroup.vue";
+export { default as ContextMenuItem } from "./ContextMenuItem.vue";
+export { default as ContextMenuLabel } from "./ContextMenuLabel.vue";
+export { default as ContextMenuRadioGroup } from "./ContextMenuRadioGroup.vue";
+export { default as ContextMenuRadioItem } from "./ContextMenuRadioItem.vue";
+export { default as ContextMenuSeparator } from "./ContextMenuSeparator.vue";
+export { default as ContextMenuShortcut } from "./ContextMenuShortcut.vue";
+export { default as ContextMenuSub } from "./ContextMenuSub.vue";
+export { default as ContextMenuSubContent } from "./ContextMenuSubContent.vue";
+export { default as ContextMenuSubTrigger } from "./ContextMenuSubTrigger.vue";
+export { default as ContextMenuTrigger } from "./ContextMenuTrigger.vue";
diff --git a/apps/desktop/src/components/ui/dialog/Dialog.vue b/apps/desktop/src/components/ui/dialog/Dialog.vue
new file mode 100644
index 0000000..add0798
--- /dev/null
+++ b/apps/desktop/src/components/ui/dialog/Dialog.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { DialogRootEmits, DialogRootProps } from "reka-ui";
+import { DialogRoot, useForwardPropsEmits } from "reka-ui";
+
+const props = defineProps<DialogRootProps>();
+const emits = defineEmits<DialogRootEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <DialogRoot v-slot="slotProps" data-slot="dialog" v-bind="forwarded">
+    <slot v-bind="slotProps" />
+  </DialogRoot>
+</template>
diff --git a/apps/desktop/src/components/ui/dialog/DialogClose.vue b/apps/desktop/src/components/ui/dialog/DialogClose.vue
new file mode 100644
index 0000000..98cd03c
--- /dev/null
+++ b/apps/desktop/src/components/ui/dialog/DialogClose.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { DialogCloseProps } from "reka-ui";
+import { DialogClose } from "reka-ui";
+
+const props = defineProps<DialogCloseProps>();
+</script>
+
+<template>
+  <DialogClose data-slot="dialog-close" v-bind="props">
+    <slot />
+  </DialogClose>
+</template>
diff --git a/apps/desktop/src/components/ui/dialog/DialogContent.vue b/apps/desktop/src/components/ui/dialog/DialogContent.vue
new file mode 100644
index 0000000..373d25b
--- /dev/null
+++ b/apps/desktop/src/components/ui/dialog/DialogContent.vue
@@ -0,0 +1,65 @@
+<script setup lang="ts">
+import type { DialogContentEmits, DialogContentProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { XIcon } from "@lucide/vue";
+import { DialogClose, DialogContent, DialogDescription, DialogPortal, VisuallyHidden, useForwardPropsEmits } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+import { Button } from "@/components/ui/button";
+import DialogOverlay from "./DialogOverlay.vue";
+
+defineOptions({
+  inheritAttrs: false,
+});
+
+const props = withDefaults(
+  defineProps<
+    DialogContentProps & {
+      class?: HTMLAttributes["class"];
+      overlayClass?: HTMLAttributes["class"];
+      portalClass?: HTMLAttributes["class"];
+      showCloseButton?: boolean;
+    }
+  >(),
+  {
+    showCloseButton: true,
+  },
+);
+const emits = defineEmits<DialogContentEmits>();
+
+const delegatedProps = reactiveOmit(props, "class", "overlayClass", "portalClass");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <DialogPortal>
+    <DialogOverlay :class="props.overlayClass" />
+    <div :class="cn('fixed inset-0 z-50 grid place-items-center p-4 pointer-events-none', props.portalClass)">
+      <DialogContent
+        data-slot="dialog-content"
+        v-bind="{ ...$attrs, ...forwarded }"
+        :class="
+          cn(
+            'bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 relative grid max-h-[calc(100dvh-2rem)] w-full max-w-sm gap-4 overflow-hidden rounded-xl border border-border p-4 text-sm shadow-lg duration-100 outline-none pointer-events-auto',
+            props.class,
+          )
+        "
+      >
+        <VisuallyHidden as-child>
+          <DialogDescription />
+        </VisuallyHidden>
+
+        <slot />
+
+        <DialogClose v-if="showCloseButton" data-slot="dialog-close" as-child>
+          <Button variant="ghost" class="absolute top-2 right-2" size="icon-sm">
+            <XIcon />
+            <span class="sr-only">Close</span>
+          </Button>
+        </DialogClose>
+      </DialogContent>
+    </div>
+  </DialogPortal>
+</template>
diff --git a/apps/desktop/src/components/ui/dialog/DialogDescription.vue b/apps/desktop/src/components/ui/dialog/DialogDescription.vue
new file mode 100644
index 0000000..337cfdb
--- /dev/null
+++ b/apps/desktop/src/components/ui/dialog/DialogDescription.vue
@@ -0,0 +1,19 @@
+<script setup lang="ts">
+import type { DialogDescriptionProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { DialogDescription, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<DialogDescriptionProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <DialogDescription data-slot="dialog-description" v-bind="forwardedProps" :style="{ wordBreak: 'break-all' }" :class="cn('text-muted-foreground *:[a]:hover:text-foreground text-sm *:[a]:underline *:[a]:underline-offset-3', props.class)">
+    <slot />
+  </DialogDescription>
+</template>
diff --git a/apps/desktop/src/components/ui/dialog/DialogFooter.vue b/apps/desktop/src/components/ui/dialog/DialogFooter.vue
new file mode 100644
index 0000000..26ace4e
--- /dev/null
+++ b/apps/desktop/src/components/ui/dialog/DialogFooter.vue
@@ -0,0 +1,25 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue";
+import { DialogClose } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+import { Button } from "@/components/ui/button";
+
+const props = withDefaults(
+  defineProps<{
+    class?: HTMLAttributes["class"];
+    showCloseButton?: boolean;
+  }>(),
+  {
+    showCloseButton: false,
+  },
+);
+</script>
+
+<template>
+  <div data-slot="dialog-footer" :class="cn('bg-muted/50 -mx-4 -mb-4 rounded-b-xl border-t p-4 flex flex-col-reverse gap-2 sm:flex-row sm:justify-end', props.class)">
+    <slot />
+    <DialogClose v-if="showCloseButton" as-child>
+      <Button variant="outline"> Close </Button>
+    </DialogClose>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/ui/dialog/DialogHeader.vue b/apps/desktop/src/components/ui/dialog/DialogHeader.vue
new file mode 100644
index 0000000..0fa50a1
--- /dev/null
+++ b/apps/desktop/src/components/ui/dialog/DialogHeader.vue
@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"];
+}>();
+</script>
+
+<template>
+  <div data-slot="dialog-header" :class="cn('gap-2 flex flex-col', props.class)">
+    <slot />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/ui/dialog/DialogOverlay.vue b/apps/desktop/src/components/ui/dialog/DialogOverlay.vue
new file mode 100644
index 0000000..123ec8a
--- /dev/null
+++ b/apps/desktop/src/components/ui/dialog/DialogOverlay.vue
@@ -0,0 +1,33 @@
+<script setup lang="ts">
+import type { DialogOverlayProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { DialogOverlay } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+
+const props = defineProps<DialogOverlayProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+const isDesktop = isTauriRuntime();
+
+async function startWindowDrag(event: PointerEvent) {
+  if (!isDesktop || event.button !== 0) return;
+  event.preventDefault();
+  event.stopPropagation();
+  const { getCurrentWindow } = await import("@tauri-apps/api/window");
+  const currentWindow = getCurrentWindow();
+  if (event.detail >= 2) {
+    await currentWindow.toggleMaximize().catch(() => {});
+    return;
+  }
+  await currentWindow.startDragging().catch(() => {});
+}
+</script>
+
+<template>
+  <DialogOverlay data-slot="dialog-overlay" v-bind="delegatedProps" :class="cn('data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-open:supports-backdrop-filter:backdrop-blur-xs bg-black/10 duration-100 fixed inset-0 isolate z-50', props.class)">
+    <div v-if="isDesktop" aria-hidden="true" class="fixed inset-x-0 top-0 h-10 pointer-events-auto" data-tauri-drag-region @pointerdown="startWindowDrag" />
+    <slot />
+  </DialogOverlay>
+</template>
diff --git a/apps/desktop/src/components/ui/dialog/DialogScrollContent.vue b/apps/desktop/src/components/ui/dialog/DialogScrollContent.vue
new file mode 100644
index 0000000..a833733
--- /dev/null
+++ b/apps/desktop/src/components/ui/dialog/DialogScrollContent.vue
@@ -0,0 +1,54 @@
+<script setup lang="ts">
+import type { DialogContentEmits, DialogContentProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { XIcon } from "@lucide/vue";
+import { DialogClose, DialogContent, DialogDescription, DialogPortal, VisuallyHidden, useForwardPropsEmits } from "reka-ui";
+import DialogOverlay from "./DialogOverlay.vue";
+import { cn } from "@/lib/common/utils";
+
+defineOptions({
+  inheritAttrs: false,
+});
+
+const props = defineProps<DialogContentProps & { class?: HTMLAttributes["class"] }>();
+const emits = defineEmits<DialogContentEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <DialogPortal>
+    <DialogOverlay />
+    <div class="fixed inset-0 z-50 grid place-items-center p-4 pointer-events-none">
+      <DialogContent
+        data-slot="dialog-content"
+        :class="cn('relative z-50 grid w-full max-w-lg my-8 gap-4 border border-border bg-background p-4 shadow-lg duration-200 sm:rounded-lg md:w-full pointer-events-auto', props.class)"
+        v-bind="{ ...$attrs, ...forwarded }"
+        @pointer-down-outside="
+          (event) => {
+            const originalEvent = event.detail.originalEvent;
+            const target = originalEvent.target as HTMLElement;
+            if (originalEvent.offsetX > target.clientWidth || originalEvent.offsetY > target.clientHeight) {
+              event.preventDefault();
+            }
+          }
+        "
+      >
+        <VisuallyHidden as-child>
+          <DialogDescription />
+        </VisuallyHidden>
+
+        <slot />
+
+        <DialogClose class="absolute top-4 right-4 p-0.5 transition-colors rounded-md hover:bg-secondary">
+          <XIcon class="w-4 h-4" />
+          <span class="sr-only">Close</span>
+        </DialogClose>
+      </DialogContent>
+    </div>
+  </DialogPortal>
+</template>
diff --git a/apps/desktop/src/components/ui/dialog/DialogTitle.vue b/apps/desktop/src/components/ui/dialog/DialogTitle.vue
new file mode 100644
index 0000000..63c48dc
--- /dev/null
+++ b/apps/desktop/src/components/ui/dialog/DialogTitle.vue
@@ -0,0 +1,19 @@
+<script setup lang="ts">
+import type { DialogTitleProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { DialogTitle, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<DialogTitleProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <DialogTitle data-slot="dialog-title" v-bind="forwardedProps" :class="cn('text-base leading-none font-medium cn-font-heading', props.class)">
+    <slot />
+  </DialogTitle>
+</template>
diff --git a/apps/desktop/src/components/ui/dialog/DialogTrigger.vue b/apps/desktop/src/components/ui/dialog/DialogTrigger.vue
new file mode 100644
index 0000000..24dbf1b
--- /dev/null
+++ b/apps/desktop/src/components/ui/dialog/DialogTrigger.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { DialogTriggerProps } from "reka-ui";
+import { DialogTrigger } from "reka-ui";
+
+const props = defineProps<DialogTriggerProps>();
+</script>
+
+<template>
+  <DialogTrigger data-slot="dialog-trigger" v-bind="props">
+    <slot />
+  </DialogTrigger>
+</template>
diff --git a/apps/desktop/src/components/ui/dialog/index.ts b/apps/desktop/src/components/ui/dialog/index.ts
new file mode 100644
index 0000000..6c411de
--- /dev/null
+++ b/apps/desktop/src/components/ui/dialog/index.ts
@@ -0,0 +1,10 @@
+export { default as Dialog } from "./Dialog.vue";
+export { default as DialogClose } from "./DialogClose.vue";
+export { default as DialogContent } from "./DialogContent.vue";
+export { default as DialogDescription } from "./DialogDescription.vue";
+export { default as DialogFooter } from "./DialogFooter.vue";
+export { default as DialogHeader } from "./DialogHeader.vue";
+export { default as DialogOverlay } from "./DialogOverlay.vue";
+export { default as DialogScrollContent } from "./DialogScrollContent.vue";
+export { default as DialogTitle } from "./DialogTitle.vue";
+export { default as DialogTrigger } from "./DialogTrigger.vue";
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenu.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenu.vue
new file mode 100644
index 0000000..93313f6
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenu.vue
@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import type { DropdownMenuRootEmits, DropdownMenuRootProps } from "reka-ui";
+import { DropdownMenuRoot, useForwardPropsEmits } from "reka-ui";
+
+const props = withDefaults(defineProps<DropdownMenuRootProps>(), {
+  modal: false,
+});
+const emits = defineEmits<DropdownMenuRootEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <DropdownMenuRoot v-slot="slotProps" data-slot="dropdown-menu" v-bind="forwarded">
+    <slot v-bind="slotProps" />
+  </DropdownMenuRoot>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuCheckboxItem.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuCheckboxItem.vue
new file mode 100644
index 0000000..881de1a
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuCheckboxItem.vue
@@ -0,0 +1,48 @@
+<script setup lang="ts">
+import type { DropdownMenuCheckboxItemEmits, DropdownMenuCheckboxItemProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { CheckIcon } from "@lucide/vue";
+import { DropdownMenuCheckboxItem, DropdownMenuItemIndicator, useForwardPropsEmits } from "reka-ui";
+import { shouldSuppressRepeatedActivation, suppressEvent, type ActionActivationGuard } from "@/lib/connection/actionActivation";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<DropdownMenuCheckboxItemProps & { class?: HTMLAttributes["class"] }>();
+const emits = defineEmits<DropdownMenuCheckboxItemEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+const activationGuard: ActionActivationGuard = {};
+
+function guardRepeatedClick(event: MouseEvent) {
+  if (props.disabled) return;
+  if (shouldSuppressRepeatedActivation(activationGuard)) {
+    suppressEvent(event);
+  }
+}
+</script>
+
+<template>
+  <DropdownMenuCheckboxItem
+    data-slot="dropdown-menu-checkbox-item"
+    v-bind="forwarded"
+    @click.capture="guardRepeatedClick"
+    :class="
+      cn(
+        'focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm data-inset:pl-7 [&_svg:not([class*=size-])]:size-4 relative flex cursor-default items-center outline-hidden select-none data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        props.class,
+      )
+    "
+  >
+    <span class="absolute right-2 flex items-center justify-center pointer-events-none" data-slot="dropdown-menu-checkbox-item-indicator">
+      <DropdownMenuItemIndicator>
+        <slot name="indicator-icon">
+          <CheckIcon />
+        </slot>
+      </DropdownMenuItemIndicator>
+    </span>
+    <slot />
+  </DropdownMenuCheckboxItem>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuContent.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuContent.vue
new file mode 100644
index 0000000..e82532b
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuContent.vue
@@ -0,0 +1,38 @@
+<script setup lang="ts">
+import type { DropdownMenuContentEmits, DropdownMenuContentProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { DropdownMenuContent, DropdownMenuPortal, useForwardPropsEmits } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+defineOptions({
+  inheritAttrs: false,
+});
+
+const props = withDefaults(defineProps<DropdownMenuContentProps & { class?: HTMLAttributes["class"] }>(), {
+  align: "start",
+  sideOffset: 4,
+});
+const emits = defineEmits<DropdownMenuContentEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <DropdownMenuPortal>
+    <DropdownMenuContent
+      data-slot="dropdown-menu-content"
+      v-bind="{ ...$attrs, ...forwarded }"
+      :class="
+        cn(
+          'data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 text-popover-foreground min-w-32 rounded-[6px] p-1 ring-1 duration-100 cn-menu-translucent z-50 max-h-(--reka-dropdown-menu-content-available-height) w-(--reka-dropdown-menu-trigger-width) origin-(--reka-dropdown-menu-content-transform-origin) overflow-x-hidden overflow-y-auto data-[state=closed]:overflow-hidden',
+          props.class,
+        )
+      "
+    >
+      <slot />
+    </DropdownMenuContent>
+  </DropdownMenuPortal>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuGroup.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuGroup.vue
new file mode 100644
index 0000000..d22b024
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuGroup.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { DropdownMenuGroupProps } from "reka-ui";
+import { DropdownMenuGroup } from "reka-ui";
+
+const props = defineProps<DropdownMenuGroupProps>();
+</script>
+
+<template>
+  <DropdownMenuGroup data-slot="dropdown-menu-group" v-bind="props">
+    <slot />
+  </DropdownMenuGroup>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuItem.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuItem.vue
new file mode 100644
index 0000000..c69e9c5
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuItem.vue
@@ -0,0 +1,51 @@
+<script setup lang="ts">
+import type { DropdownMenuItemProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { DropdownMenuItem, useForwardProps } from "reka-ui";
+import { shouldSuppressRepeatedActivation, suppressEvent, type ActionActivationGuard } from "@/lib/connection/actionActivation";
+import { cn } from "@/lib/common/utils";
+
+const props = withDefaults(
+  defineProps<
+    DropdownMenuItemProps & {
+      class?: HTMLAttributes["class"];
+      inset?: boolean;
+      variant?: "default" | "destructive";
+    }
+  >(),
+  {
+    variant: "default",
+  },
+);
+
+const delegatedProps = reactiveOmit(props, "inset", "variant", "class");
+
+const forwardedProps = useForwardProps(delegatedProps);
+const activationGuard: ActionActivationGuard = {};
+
+function guardRepeatedClick(event: MouseEvent) {
+  if (props.disabled) return;
+  if (shouldSuppressRepeatedActivation(activationGuard)) {
+    suppressEvent(event);
+  }
+}
+</script>
+
+<template>
+  <DropdownMenuItem
+    data-slot="dropdown-menu-item"
+    :data-inset="inset ? '' : undefined"
+    :data-variant="variant"
+    v-bind="forwardedProps"
+    @click.capture="guardRepeatedClick"
+    :class="
+      cn(
+        'focus:bg-accent focus:text-accent-foreground data-[variant=destructive]:text-destructive data-[variant=destructive]:focus:bg-destructive/10 dark:data-[variant=destructive]:focus:bg-destructive/20 data-[variant=destructive]:focus:text-destructive data-[variant=destructive]:*:[svg]:text-destructive not-data-[variant=destructive]:focus:**:text-accent-foreground gap-1.5 rounded-md px-1.5 py-1 text-sm data-inset:pl-7 [&_svg:not([class*=size-])]:size-4 group/dropdown-menu-item relative flex cursor-default items-center outline-hidden select-none data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        props.class,
+      )
+    "
+  >
+    <slot />
+  </DropdownMenuItem>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuLabel.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuLabel.vue
new file mode 100644
index 0000000..1ddff65
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuLabel.vue
@@ -0,0 +1,18 @@
+<script setup lang="ts">
+import type { DropdownMenuLabelProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { DropdownMenuLabel, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<DropdownMenuLabelProps & { class?: HTMLAttributes["class"]; inset?: boolean }>();
+
+const delegatedProps = reactiveOmit(props, "class", "inset");
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <DropdownMenuLabel data-slot="dropdown-menu-label" :data-inset="inset ? '' : undefined" v-bind="forwardedProps" :class="cn('text-muted-foreground px-1.5 py-1 text-xs font-medium data-inset:pl-7', props.class)">
+    <slot />
+  </DropdownMenuLabel>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuRadioGroup.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuRadioGroup.vue
new file mode 100644
index 0000000..32313a3
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuRadioGroup.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { DropdownMenuRadioGroupEmits, DropdownMenuRadioGroupProps } from "reka-ui";
+import { DropdownMenuRadioGroup, useForwardPropsEmits } from "reka-ui";
+
+const props = defineProps<DropdownMenuRadioGroupProps>();
+const emits = defineEmits<DropdownMenuRadioGroupEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <DropdownMenuRadioGroup data-slot="dropdown-menu-radio-group" v-bind="forwarded">
+    <slot />
+  </DropdownMenuRadioGroup>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuRadioItem.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuRadioItem.vue
new file mode 100644
index 0000000..ee70d9f
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuRadioItem.vue
@@ -0,0 +1,49 @@
+<script setup lang="ts">
+import type { DropdownMenuRadioItemEmits, DropdownMenuRadioItemProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { CheckIcon } from "@lucide/vue";
+import { DropdownMenuItemIndicator, DropdownMenuRadioItem, useForwardPropsEmits } from "reka-ui";
+import { shouldSuppressRepeatedActivation, suppressEvent, type ActionActivationGuard } from "@/lib/connection/actionActivation";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<DropdownMenuRadioItemProps & { class?: HTMLAttributes["class"] }>();
+
+const emits = defineEmits<DropdownMenuRadioItemEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+const activationGuard: ActionActivationGuard = {};
+
+function guardRepeatedClick(event: MouseEvent) {
+  if (props.disabled) return;
+  if (shouldSuppressRepeatedActivation(activationGuard)) {
+    suppressEvent(event);
+  }
+}
+</script>
+
+<template>
+  <DropdownMenuRadioItem
+    data-slot="dropdown-menu-radio-item"
+    v-bind="forwarded"
+    @click.capture="guardRepeatedClick"
+    :class="
+      cn(
+        'focus:bg-accent focus:text-accent-foreground focus:**:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm data-inset:pl-7 [&_svg:not([class*=size-])]:size-4 relative flex cursor-default items-center outline-hidden select-none data-disabled:pointer-events-none data-disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        props.class,
+      )
+    "
+  >
+    <span class="absolute right-2 flex items-center justify-center pointer-events-none" data-slot="dropdown-menu-radio-item-indicator">
+      <DropdownMenuItemIndicator>
+        <slot name="indicator-icon">
+          <CheckIcon />
+        </slot>
+      </DropdownMenuItemIndicator>
+    </span>
+    <slot />
+  </DropdownMenuRadioItem>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSeparator.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSeparator.vue
new file mode 100644
index 0000000..0d231db
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSeparator.vue
@@ -0,0 +1,19 @@
+<script setup lang="ts">
+import type { DropdownMenuSeparatorProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { DropdownMenuSeparator } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<
+  DropdownMenuSeparatorProps & {
+    class?: HTMLAttributes["class"];
+  }
+>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <DropdownMenuSeparator data-slot="dropdown-menu-separator" v-bind="delegatedProps" :class="cn('bg-border -mx-1 my-1 h-px', props.class)" />
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuShortcut.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuShortcut.vue
new file mode 100644
index 0000000..67783e5
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuShortcut.vue
@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"];
+}>();
+</script>
+
+<template>
+  <span data-slot="dropdown-menu-shortcut" :class="cn('text-muted-foreground group-focus/dropdown-menu-item:text-accent-foreground ml-auto text-xs tracking-widest', props.class)">
+    <slot />
+  </span>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSub.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSub.vue
new file mode 100644
index 0000000..22624e8
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSub.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { DropdownMenuSubEmits, DropdownMenuSubProps } from "reka-ui";
+import { DropdownMenuSub, useForwardPropsEmits } from "reka-ui";
+
+const props = defineProps<DropdownMenuSubProps>();
+const emits = defineEmits<DropdownMenuSubEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <DropdownMenuSub v-slot="slotProps" data-slot="dropdown-menu-sub" v-bind="forwarded">
+    <slot v-bind="slotProps" />
+  </DropdownMenuSub>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSubContent.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSubContent.vue
new file mode 100644
index 0000000..53434db
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSubContent.vue
@@ -0,0 +1,29 @@
+<script setup lang="ts">
+import type { DropdownMenuSubContentEmits, DropdownMenuSubContentProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { DropdownMenuSubContent, useForwardPropsEmits } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<DropdownMenuSubContentProps & { class?: HTMLAttributes["class"] }>();
+const emits = defineEmits<DropdownMenuSubContentEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <DropdownMenuSubContent
+    data-slot="dropdown-menu-sub-content"
+    v-bind="forwarded"
+    :class="
+      cn(
+        'data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 text-popover-foreground min-w-[96px] rounded-[6px] p-1 ring-1 duration-100 cn-menu-translucent z-50 origin-(--reka-dropdown-menu-content-transform-origin) overflow-hidden',
+        props.class,
+      )
+    "
+  >
+    <slot />
+  </DropdownMenuSubContent>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSubTrigger.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSubTrigger.vue
new file mode 100644
index 0000000..00b35ba
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuSubTrigger.vue
@@ -0,0 +1,31 @@
+<script setup lang="ts">
+import type { DropdownMenuSubTriggerProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ChevronRightIcon } from "@lucide/vue";
+import { DropdownMenuSubTrigger, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<DropdownMenuSubTriggerProps & { class?: HTMLAttributes["class"]; inset?: boolean }>();
+
+const delegatedProps = reactiveOmit(props, "class", "inset");
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <DropdownMenuSubTrigger
+    data-slot="dropdown-menu-sub-trigger"
+    :data-inset="inset ? '' : undefined"
+    v-bind="forwardedProps"
+    :class="
+      cn(
+        'focus:bg-accent focus:text-accent-foreground data-open:bg-accent data-open:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground gap-1.5 rounded-md px-1.5 py-1 text-sm data-inset:pl-7 [&_svg:not([class*=size-])]:size-4 flex cursor-default items-center outline-hidden select-none [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        props.class,
+      )
+    "
+  >
+    <slot />
+    <ChevronRightIcon class="cn-rtl-flip ml-auto" />
+  </DropdownMenuSubTrigger>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuTrigger.vue b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuTrigger.vue
new file mode 100644
index 0000000..d52d0b4
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/DropdownMenuTrigger.vue
@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import type { DropdownMenuTriggerProps } from "reka-ui";
+import { DropdownMenuTrigger, useForwardProps } from "reka-ui";
+
+const props = defineProps<DropdownMenuTriggerProps>();
+
+const forwardedProps = useForwardProps(props);
+</script>
+
+<template>
+  <DropdownMenuTrigger data-slot="dropdown-menu-trigger" v-bind="forwardedProps">
+    <slot />
+  </DropdownMenuTrigger>
+</template>
diff --git a/apps/desktop/src/components/ui/dropdown-menu/index.ts b/apps/desktop/src/components/ui/dropdown-menu/index.ts
new file mode 100644
index 0000000..9e57848
--- /dev/null
+++ b/apps/desktop/src/components/ui/dropdown-menu/index.ts
@@ -0,0 +1,16 @@
+export { default as DropdownMenu } from "./DropdownMenu.vue";
+
+export { default as DropdownMenuCheckboxItem } from "./DropdownMenuCheckboxItem.vue";
+export { default as DropdownMenuContent } from "./DropdownMenuContent.vue";
+export { default as DropdownMenuGroup } from "./DropdownMenuGroup.vue";
+export { default as DropdownMenuItem } from "./DropdownMenuItem.vue";
+export { default as DropdownMenuLabel } from "./DropdownMenuLabel.vue";
+export { default as DropdownMenuRadioGroup } from "./DropdownMenuRadioGroup.vue";
+export { default as DropdownMenuRadioItem } from "./DropdownMenuRadioItem.vue";
+export { default as DropdownMenuSeparator } from "./DropdownMenuSeparator.vue";
+export { default as DropdownMenuShortcut } from "./DropdownMenuShortcut.vue";
+export { default as DropdownMenuSub } from "./DropdownMenuSub.vue";
+export { default as DropdownMenuSubContent } from "./DropdownMenuSubContent.vue";
+export { default as DropdownMenuSubTrigger } from "./DropdownMenuSubTrigger.vue";
+export { default as DropdownMenuTrigger } from "./DropdownMenuTrigger.vue";
+export { DropdownMenuPortal } from "reka-ui";
diff --git a/apps/desktop/src/components/ui/input/Input.vue b/apps/desktop/src/components/ui/input/Input.vue
new file mode 100644
index 0000000..902c85d
--- /dev/null
+++ b/apps/desktop/src/components/ui/input/Input.vue
@@ -0,0 +1,37 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue";
+import { useVModel } from "@vueuse/core";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<{
+  defaultValue?: string | number;
+  modelValue?: string | number;
+  class?: HTMLAttributes["class"];
+}>();
+
+const emits = defineEmits<{
+  (e: "update:modelValue", payload: string | number): void;
+}>();
+
+const modelValue = useVModel(props, "modelValue", emits, {
+  passive: true,
+  defaultValue: props.defaultValue,
+});
+</script>
+
+<template>
+  <input
+    v-model="modelValue"
+    autocapitalize="off"
+    autocomplete="off"
+    autocorrect="off"
+    spellcheck="false"
+    data-slot="input"
+    :class="
+      cn(
+        'dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 disabled:bg-input/50 dark:disabled:bg-input/80 h-8 rounded-[6px] border bg-transparent px-2.5 py-1 text-base transition-colors file:h-6 file:text-sm file:font-medium focus-visible:ring-3 aria-invalid:ring-3 md:text-sm w-full min-w-0 outline-none file:inline-flex file:border-0 file:bg-transparent file:text-foreground placeholder:text-muted-foreground disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50',
+        props.class,
+      )
+    "
+  />
+</template>
diff --git a/apps/desktop/src/components/ui/input/index.ts b/apps/desktop/src/components/ui/input/index.ts
new file mode 100644
index 0000000..110f046
--- /dev/null
+++ b/apps/desktop/src/components/ui/input/index.ts
@@ -0,0 +1 @@
+export { default as Input } from "./Input.vue";
diff --git a/apps/desktop/src/components/ui/label/Label.vue b/apps/desktop/src/components/ui/label/Label.vue
new file mode 100644
index 0000000..9778bca
--- /dev/null
+++ b/apps/desktop/src/components/ui/label/Label.vue
@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import type { LabelProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { Label } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<LabelProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <Label data-slot="label" v-bind="delegatedProps" :class="cn('gap-2 text-sm leading-none font-medium group-data-[disabled=true]:opacity-50 peer-disabled:opacity-50 flex items-center select-none group-data-[disabled=true]:pointer-events-none peer-disabled:cursor-not-allowed', props.class)">
+    <slot />
+  </Label>
+</template>
diff --git a/apps/desktop/src/components/ui/label/index.ts b/apps/desktop/src/components/ui/label/index.ts
new file mode 100644
index 0000000..38eaa35
--- /dev/null
+++ b/apps/desktop/src/components/ui/label/index.ts
@@ -0,0 +1 @@
+export { default as Label } from "./Label.vue";
diff --git a/apps/desktop/src/components/ui/option-help-panel/OptionHelpPanel.vue b/apps/desktop/src/components/ui/option-help-panel/OptionHelpPanel.vue
new file mode 100644
index 0000000..254f928
--- /dev/null
+++ b/apps/desktop/src/components/ui/option-help-panel/OptionHelpPanel.vue
@@ -0,0 +1,21 @@
+<script setup lang="ts">
+import { ref } from "vue";
+import { OPTION_HELP_PANEL_CLASS } from "./optionHelpPanel";
+
+const props = withDefaults(
+  defineProps<{
+    content: string;
+    offsetTop?: number;
+  }>(),
+  { offsetTop: 0 },
+);
+
+const element = ref<HTMLElement>();
+defineExpose({ element });
+</script>
+
+<template>
+  <aside ref="element" data-slot="option-help-panel" role="note" :class="OPTION_HELP_PANEL_CLASS" :style="{ '--option-help-offset': `${offsetTop}px` }">
+    {{ content }}
+  </aside>
+</template>
diff --git a/apps/desktop/src/components/ui/option-help-panel/index.ts b/apps/desktop/src/components/ui/option-help-panel/index.ts
new file mode 100644
index 0000000..5afc697
--- /dev/null
+++ b/apps/desktop/src/components/ui/option-help-panel/index.ts
@@ -0,0 +1 @@
+export { default as OptionHelpPanel } from "./OptionHelpPanel.vue";
diff --git a/apps/desktop/src/components/ui/option-help-panel/optionHelpPanel.spec.ts b/apps/desktop/src/components/ui/option-help-panel/optionHelpPanel.spec.ts
new file mode 100644
index 0000000..8620b3e
--- /dev/null
+++ b/apps/desktop/src/components/ui/option-help-panel/optionHelpPanel.spec.ts
@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { OPTION_HELP_PANEL_CLASS } from "./optionHelpPanel";
+
+describe("OptionHelpPanel layout", () => {
+  it("keeps the panel compact at the top and scrolls long help content", () => {
+    expect(OPTION_HELP_PANEL_CLASS).toContain("self-start");
+    expect(OPTION_HELP_PANEL_CLASS).toContain("max-h-64");
+    expect(OPTION_HELP_PANEL_CLASS).toContain("overflow-y-auto");
+    expect(OPTION_HELP_PANEL_CLASS).toContain("rounded-md");
+    expect(OPTION_HELP_PANEL_CLASS).toContain("shadow-md");
+    expect(OPTION_HELP_PANEL_CLASS).toContain("sm:mt-[var(--option-help-offset)]");
+  });
+});
diff --git a/apps/desktop/src/components/ui/option-help-panel/optionHelpPanel.ts b/apps/desktop/src/components/ui/option-help-panel/optionHelpPanel.ts
new file mode 100644
index 0000000..68bafd5
--- /dev/null
+++ b/apps/desktop/src/components/ui/option-help-panel/optionHelpPanel.ts
@@ -0,0 +1 @@
+export const OPTION_HELP_PANEL_CLASS = "w-full shrink-0 self-start max-h-64 overflow-y-auto rounded-md border bg-popover px-3 py-2 text-xs leading-relaxed text-muted-foreground shadow-md sm:mt-[var(--option-help-offset)] sm:w-[min(26rem,calc(100vw-5rem))]";
diff --git a/apps/desktop/src/components/ui/popover/Popover.vue b/apps/desktop/src/components/ui/popover/Popover.vue
new file mode 100644
index 0000000..e43a385
--- /dev/null
+++ b/apps/desktop/src/components/ui/popover/Popover.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { PopoverRootEmits, PopoverRootProps } from "reka-ui";
+import { PopoverRoot, useForwardPropsEmits } from "reka-ui";
+
+const props = defineProps<PopoverRootProps>();
+const emits = defineEmits<PopoverRootEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <PopoverRoot v-slot="slotProps" data-slot="popover" v-bind="forwarded">
+    <slot v-bind="slotProps" />
+  </PopoverRoot>
+</template>
diff --git a/apps/desktop/src/components/ui/popover/PopoverAnchor.vue b/apps/desktop/src/components/ui/popover/PopoverAnchor.vue
new file mode 100644
index 0000000..44a4296
--- /dev/null
+++ b/apps/desktop/src/components/ui/popover/PopoverAnchor.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { PopoverAnchorProps } from "reka-ui";
+import { PopoverAnchor } from "reka-ui";
+
+const props = defineProps<PopoverAnchorProps>();
+</script>
+
+<template>
+  <PopoverAnchor data-slot="popover-anchor" v-bind="props">
+    <slot />
+  </PopoverAnchor>
+</template>
diff --git a/apps/desktop/src/components/ui/popover/PopoverContent.vue b/apps/desktop/src/components/ui/popover/PopoverContent.vue
new file mode 100644
index 0000000..7253650
--- /dev/null
+++ b/apps/desktop/src/components/ui/popover/PopoverContent.vue
@@ -0,0 +1,38 @@
+<script setup lang="ts">
+import type { PopoverContentEmits, PopoverContentProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { PopoverContent, PopoverPortal, useForwardPropsEmits } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+defineOptions({
+  inheritAttrs: false,
+});
+
+const props = withDefaults(defineProps<PopoverContentProps & { class?: HTMLAttributes["class"] }>(), {
+  align: "center",
+  sideOffset: 4,
+});
+const emits = defineEmits<PopoverContentEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <PopoverPortal>
+    <PopoverContent
+      data-slot="popover-content"
+      v-bind="{ ...$attrs, ...forwarded }"
+      :class="
+        cn(
+          'bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 flex flex-col gap-2.5 rounded-[6px] p-2.5 text-sm shadow-md ring-1 duration-100 z-50 w-72 origin-(--reka-popover-content-transform-origin) outline-hidden',
+          props.class,
+        )
+      "
+    >
+      <slot />
+    </PopoverContent>
+  </PopoverPortal>
+</template>
diff --git a/apps/desktop/src/components/ui/popover/PopoverDescription.vue b/apps/desktop/src/components/ui/popover/PopoverDescription.vue
new file mode 100644
index 0000000..4b612d8
--- /dev/null
+++ b/apps/desktop/src/components/ui/popover/PopoverDescription.vue
@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"];
+}>();
+</script>
+
+<template>
+  <p data-slot="popover-description" :class="cn('text-muted-foreground', props.class)">
+    <slot />
+  </p>
+</template>
diff --git a/apps/desktop/src/components/ui/popover/PopoverHeader.vue b/apps/desktop/src/components/ui/popover/PopoverHeader.vue
new file mode 100644
index 0000000..1524c27
--- /dev/null
+++ b/apps/desktop/src/components/ui/popover/PopoverHeader.vue
@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"];
+}>();
+</script>
+
+<template>
+  <div data-slot="popover-header" :class="cn('flex flex-col gap-0.5 text-sm', props.class)">
+    <slot />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/ui/popover/PopoverTitle.vue b/apps/desktop/src/components/ui/popover/PopoverTitle.vue
new file mode 100644
index 0000000..d1a03cf
--- /dev/null
+++ b/apps/desktop/src/components/ui/popover/PopoverTitle.vue
@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<{
+  class?: HTMLAttributes["class"];
+}>();
+</script>
+
+<template>
+  <div data-slot="popover-title" :class="cn('font-medium cn-font-heading', props.class)">
+    <slot />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/ui/popover/PopoverTrigger.vue b/apps/desktop/src/components/ui/popover/PopoverTrigger.vue
new file mode 100644
index 0000000..748f028
--- /dev/null
+++ b/apps/desktop/src/components/ui/popover/PopoverTrigger.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { PopoverTriggerProps } from "reka-ui";
+import { PopoverTrigger } from "reka-ui";
+
+const props = defineProps<PopoverTriggerProps>();
+</script>
+
+<template>
+  <PopoverTrigger data-slot="popover-trigger" v-bind="props">
+    <slot />
+  </PopoverTrigger>
+</template>
diff --git a/apps/desktop/src/components/ui/popover/index.ts b/apps/desktop/src/components/ui/popover/index.ts
new file mode 100644
index 0000000..810d158
--- /dev/null
+++ b/apps/desktop/src/components/ui/popover/index.ts
@@ -0,0 +1,7 @@
+export { default as Popover } from "./Popover.vue";
+export { default as PopoverAnchor } from "./PopoverAnchor.vue";
+export { default as PopoverContent } from "./PopoverContent.vue";
+export { default as PopoverDescription } from "./PopoverDescription.vue";
+export { default as PopoverHeader } from "./PopoverHeader.vue";
+export { default as PopoverTitle } from "./PopoverTitle.vue";
+export { default as PopoverTrigger } from "./PopoverTrigger.vue";
diff --git a/apps/desktop/src/components/ui/scroll-area/ScrollArea.vue b/apps/desktop/src/components/ui/scroll-area/ScrollArea.vue
new file mode 100644
index 0000000..f3a0435
--- /dev/null
+++ b/apps/desktop/src/components/ui/scroll-area/ScrollArea.vue
@@ -0,0 +1,22 @@
+<script setup lang="ts">
+import type { ScrollAreaRootProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ScrollAreaCorner, ScrollAreaRoot, ScrollAreaViewport } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+import ScrollBar from "./ScrollBar.vue";
+
+const props = defineProps<ScrollAreaRootProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <ScrollAreaRoot data-slot="scroll-area" v-bind="delegatedProps" :class="cn('relative', props.class)">
+    <ScrollAreaViewport data-slot="scroll-area-viewport" class="size-full overflow-auto rounded-[inherit] transition-[color,box-shadow] outline-none focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-1">
+      <slot />
+    </ScrollAreaViewport>
+    <ScrollBar />
+    <ScrollAreaCorner />
+  </ScrollAreaRoot>
+</template>
diff --git a/apps/desktop/src/components/ui/scroll-area/ScrollBar.vue b/apps/desktop/src/components/ui/scroll-area/ScrollBar.vue
new file mode 100644
index 0000000..3d44bcd
--- /dev/null
+++ b/apps/desktop/src/components/ui/scroll-area/ScrollBar.vue
@@ -0,0 +1,24 @@
+<script setup lang="ts">
+import type { ScrollAreaScrollbarProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ScrollAreaScrollbar, ScrollAreaThumb } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = withDefaults(defineProps<ScrollAreaScrollbarProps & { class?: HTMLAttributes["class"] }>(), {
+  orientation: "vertical",
+});
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <ScrollAreaScrollbar
+    data-slot="scroll-area-scrollbar"
+    :data-orientation="orientation"
+    v-bind="delegatedProps"
+    :class="cn('data-horizontal:h-2.5 data-horizontal:flex-col data-horizontal:border-t data-horizontal:border-t-transparent data-vertical:h-full data-vertical:w-2.5 data-vertical:border-l data-vertical:border-l-transparent flex touch-none p-px transition-colors select-none', props.class)"
+  >
+    <ScrollAreaThumb data-slot="scroll-area-thumb" class="rounded-full relative flex-1 bg-border" />
+  </ScrollAreaScrollbar>
+</template>
diff --git a/apps/desktop/src/components/ui/scroll-area/index.ts b/apps/desktop/src/components/ui/scroll-area/index.ts
new file mode 100644
index 0000000..cd655e0
--- /dev/null
+++ b/apps/desktop/src/components/ui/scroll-area/index.ts
@@ -0,0 +1,2 @@
+export { default as ScrollArea } from "./ScrollArea.vue";
+export { default as ScrollBar } from "./ScrollBar.vue";
diff --git a/apps/desktop/src/components/ui/searchable-select/SearchableSelect.vue b/apps/desktop/src/components/ui/searchable-select/SearchableSelect.vue
new file mode 100644
index 0000000..88ff1db
--- /dev/null
+++ b/apps/desktop/src/components/ui/searchable-select/SearchableSelect.vue
@@ -0,0 +1,351 @@
+<script setup lang="ts">
+import { computed, nextTick, ref, watch } from "vue";
+import type { HTMLAttributes } from "vue";
+import { Check, ChevronDown, Search, X } from "@lucide/vue";
+import { Button } from "@/components/ui/button";
+import type { ButtonVariants } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { OptionHelpPanel } from "@/components/ui/option-help-panel";
+import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { filterDatabaseOptions } from "@/lib/database/databaseOptionSearch";
+import { cn } from "@/lib/common/utils";
+import { optionHelpPanelOffsetTop } from "@/lib/common/optionHelpPanelOffset";
+import { SEARCHABLE_SELECT_HELP_PANEL_ALIGN, searchableSelectKeyboardTooltipOption, searchableSelectSelectedOrFirstHelpOption } from "@/lib/common/searchableSelectTooltip";
+
+const props = withDefaults(
+  defineProps<{
+    modelValue: string;
+    options: string[];
+    placeholder: string;
+    searchPlaceholder: string;
+    emptyText: string;
+    loadingText?: string;
+    loading?: boolean;
+    disabled?: boolean;
+    allowCustom?: boolean;
+    triggerVariant?: ButtonVariants["variant"];
+    triggerClass?: HTMLAttributes["class"];
+    triggerIconClass?: HTMLAttributes["class"];
+    contentClass?: HTMLAttributes["class"];
+    itemClass?: HTMLAttributes["class"];
+    displayName?: (option: string) => string;
+    optionTooltip?: (option: string) => string | undefined;
+    normalizeCustom?: (value: string) => string;
+    clearable?: boolean;
+  }>(),
+  {
+    loading: false,
+    disabled: false,
+    allowCustom: false,
+    clearable: false,
+    loadingText: "Loading...",
+    triggerVariant: "ghost",
+    triggerIconClass: "h-3 w-3",
+    displayName: (option: string) => option,
+    optionTooltip: () => undefined,
+    normalizeCustom: (value: string) => value,
+  },
+);
+
+const emit = defineEmits<{
+  "update:modelValue": [value: string];
+  "update:open": [value: boolean];
+}>();
+
+defineSlots<{
+  "trigger-label"?(props: { value: string; label: string; loading: boolean }): any;
+  "option-label"?(props: { option: string; label: string }): any;
+  "custom-option-label"?(props: { value: string }): any;
+}>();
+
+const open = ref(false);
+const searchText = ref("");
+const searchInput = ref<InstanceType<typeof Input>>();
+const listContainer = ref<HTMLDivElement>();
+const listCard = ref<HTMLElement>();
+const helpPanel = ref<{ element?: HTMLElement }>();
+const highlightIndex = ref(-1);
+const activeHelpOption = ref<string>();
+const helpPanelOffsetTop = ref(0);
+
+const selectedLabel = computed(() => {
+  if (!props.modelValue && !props.options.includes("")) return props.placeholder;
+  return props.displayName(props.modelValue);
+});
+
+const triggerBaseClass = computed(() =>
+  props.triggerVariant === "outline"
+    ? "dbx-searchable-select-trigger h-6 w-auto max-w-56 min-w-0 justify-between gap-1 px-2 text-xs font-normal shadow-none"
+    : "h-6 w-auto max-w-56 min-w-0 justify-between gap-1 border-0 bg-transparent px-1 text-xs font-normal shadow-none hover:bg-muted/50 focus-visible:ring-0",
+);
+
+const filteredOptions = computed(() => filterDatabaseOptions(props.options, searchText.value, props.displayName));
+const customOptionValue = computed(() => props.normalizeCustom(searchText.value.trim()));
+const canSelectCustom = computed(() => props.allowCustom && !!customOptionValue.value && !props.options.includes(customOptionValue.value));
+
+function highlightSelectedOption() {
+  const selectedIndex = filteredOptions.value.findIndex((option) => option === props.modelValue);
+  highlightIndex.value = selectedIndex >= 0 ? selectedIndex : 0;
+}
+
+async function scrollHighlightedOptionIntoView() {
+  await nextTick();
+  const container = listContainer.value;
+  if (!container || highlightIndex.value < 0) return;
+  const buttons = container.querySelectorAll("button");
+  const target = buttons[highlightIndex.value];
+  target?.scrollIntoView({ block: "nearest" });
+  void updateHelpPanelOffset();
+}
+
+function highlightAndScrollSelectedOption() {
+  highlightSelectedOption();
+  void scrollHighlightedOptionIntoView();
+}
+
+function activateInitialHelpOption() {
+  activeHelpOption.value = searchableSelectSelectedOrFirstHelpOption(filteredOptions.value, props.modelValue, props.optionTooltip);
+}
+
+watch(open, async (value) => {
+  emit("update:open", value);
+  if (!value) {
+    searchText.value = "";
+    highlightIndex.value = -1;
+    activeHelpOption.value = undefined;
+    return;
+  }
+  await nextTick();
+  const input = searchInput.value?.$el as HTMLInputElement | undefined;
+  input?.focus();
+  highlightAndScrollSelectedOption();
+  activateInitialHelpOption();
+});
+
+watch(searchText, () => {
+  highlightIndex.value = 0;
+  activeHelpOption.value = searchableSelectKeyboardTooltipOption(filteredOptions.value, 0, props.optionTooltip);
+});
+
+watch(
+  () => [props.modelValue, props.options],
+  () => {
+    if (!open.value || searchText.value) return;
+    activeHelpOption.value = undefined;
+    highlightAndScrollSelectedOption();
+    activateInitialHelpOption();
+  },
+  { deep: true },
+);
+
+watch([highlightIndex, filteredOptions], () => {
+  void scrollHighlightedOptionIntoView();
+});
+
+const activeHelpContent = computed(() => (activeHelpOption.value ? props.optionTooltip(activeHelpOption.value) : undefined));
+
+function activateHelpForHighlightedOption() {
+  activeHelpOption.value = searchableSelectKeyboardTooltipOption(filteredOptions.value, highlightIndex.value, props.optionTooltip);
+}
+
+function activateHelpForOption(option: string) {
+  activeHelpOption.value = props.optionTooltip(option) ? option : undefined;
+}
+
+async function updateHelpPanelOffset() {
+  if (!activeHelpOption.value) {
+    helpPanelOffsetTop.value = 0;
+    return;
+  }
+  await nextTick();
+  const card = listCard.value;
+  const panel = helpPanel.value?.element;
+  const optionIndex = filteredOptions.value.indexOf(activeHelpOption.value);
+  const option = optionIndex >= 0 ? listContainer.value?.querySelectorAll("button")[optionIndex] : undefined;
+  if (!card || !panel || !option) {
+    helpPanelOffsetTop.value = 0;
+    return;
+  }
+  helpPanelOffsetTop.value = optionHelpPanelOffsetTop({
+    activeItemTop: option.getBoundingClientRect().top - card.getBoundingClientRect().top,
+    listCardHeight: card.clientHeight,
+    panelHeight: panel.clientHeight,
+  });
+}
+
+watch([activeHelpOption, filteredOptions], () => {
+  void updateHelpPanelOffset();
+});
+
+function selectOption(option: string) {
+  emit("update:modelValue", option);
+  open.value = false;
+}
+
+function selectCustomOption() {
+  if (!canSelectCustom.value) return;
+  selectOption(customOptionValue.value);
+}
+
+function optionTitle(option: string) {
+  const label = props.displayName(option);
+  return label === option ? option : `${label}\n${option}`;
+}
+
+function optionCount() {
+  return filteredOptions.value.length + (canSelectCustom.value ? 1 : 0);
+}
+
+function handleKeydown(event: KeyboardEvent) {
+  if (event.key === "ArrowDown") {
+    event.preventDefault();
+    const total = optionCount();
+    if (total === 0) return;
+    highlightIndex.value = highlightIndex.value < total - 1 ? highlightIndex.value + 1 : 0;
+    activateHelpForHighlightedOption();
+  } else if (event.key === "ArrowUp") {
+    event.preventDefault();
+    const total = optionCount();
+    if (total === 0) return;
+    highlightIndex.value = highlightIndex.value > 0 ? highlightIndex.value - 1 : total - 1;
+    activateHelpForHighlightedOption();
+  } else if (event.key === "Enter") {
+    if (highlightIndex.value < 0 || highlightIndex.value >= optionCount()) return;
+    event.preventDefault();
+    if (highlightIndex.value < filteredOptions.value.length) {
+      selectOption(filteredOptions.value[highlightIndex.value]);
+    } else {
+      selectCustomOption();
+    }
+  } else if (event.key === "Escape") {
+    open.value = false;
+  }
+}
+</script>
+
+<template>
+  <Popover v-model:open="open">
+    <PopoverTrigger as-child>
+      <Button type="button" :variant="triggerVariant" :disabled="disabled" :title="selectedLabel" :class="cn(triggerBaseClass, triggerClass)">
+        <slot name="trigger-label" :value="modelValue" :label="selectedLabel" :loading="loading">
+          <span class="truncate">{{ loading ? loadingText : selectedLabel }}</span>
+        </slot>
+        <X v-if="clearable && !disabled && modelValue" :class="cn('shrink-0 opacity-60 hover:opacity-100', triggerIconClass)" @pointerdown.stop.prevent="emit('update:modelValue', '')" />
+        <ChevronDown v-else :class="cn('shrink-0 opacity-60', triggerIconClass)" />
+      </Button>
+    </PopoverTrigger>
+    <PopoverContent :align="SEARCHABLE_SELECT_HELP_PANEL_ALIGN" :class="cn('w-auto max-w-[calc(100vw-1rem)] border-0 bg-transparent p-0 shadow-none ring-0', contentClass)">
+      <div class="flex min-w-0 flex-col gap-2 sm:flex-row sm:items-start">
+        <div ref="listCard" class="w-52 shrink-0 rounded-md border bg-popover p-1.5 shadow-md">
+          <div class="relative rounded-sm border bg-background">
+            <Search class="pointer-events-none absolute left-2 top-1/2 h-3 w-3 -translate-y-1/2 text-muted-foreground" />
+            <span v-if="!searchText" class="pointer-events-none absolute left-[25px] top-1/2 -translate-y-1/2 text-sm text-muted-foreground">{{ searchPlaceholder }}</span>
+            <Input ref="searchInput" :model-value="searchText" class="h-6 border-0 pl-6 pr-2 text-sm caret-foreground shadow-none focus-visible:ring-0" @update:model-value="(value) => (searchText = String(value))" @keydown="handleKeydown" />
+          </div>
+          <div ref="listContainer" class="max-h-64 overflow-y-auto py-1" @scroll="updateHelpPanelOffset">
+            <div v-if="loading" class="px-2 py-2 text-sm text-muted-foreground">
+              {{ loadingText }}
+            </div>
+            <template v-else-if="filteredOptions.length">
+              <button
+                v-for="(option, index) in filteredOptions"
+                :key="option"
+                type="button"
+                :title="optionTooltip(option) ? undefined : optionTitle(option)"
+                :class="
+                  cn(
+                    'flex h-8 w-full min-w-0 items-center gap-2 rounded-sm px-2 text-left text-sm hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground focus-visible:outline-none',
+                    props.itemClass,
+                    index === highlightIndex && 'bg-accent text-accent-foreground',
+                  )
+                "
+                @pointerenter="activateHelpForOption(option)"
+                @click="selectOption(option)"
+              >
+                <Check :class="cn('h-3.5 w-3.5 shrink-0', option === modelValue ? 'opacity-100' : 'opacity-0')" />
+                <slot name="option-label" :option="option" :label="displayName?.(option)">
+                  <span class="truncate">{{ displayName?.(option) }}</span>
+                </slot>
+              </button>
+              <button
+                v-if="canSelectCustom"
+                type="button"
+                :title="customOptionValue"
+                :class="
+                  cn(
+                    'flex h-8 w-full min-w-0 items-center gap-2 rounded-sm px-2 text-left text-sm hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground focus-visible:outline-none',
+                    props.itemClass,
+                    filteredOptions.length === highlightIndex && 'bg-accent text-accent-foreground',
+                  )
+                "
+                @pointerenter="activateHelpForOption(customOptionValue)"
+                @click="selectCustomOption"
+              >
+                <Check class="h-3.5 w-3.5 shrink-0 opacity-0" />
+                <slot name="custom-option-label" :value="customOptionValue">
+                  <span class="truncate">{{ customOptionValue }}</span>
+                </slot>
+              </button>
+            </template>
+            <button
+              v-else-if="canSelectCustom"
+              type="button"
+              :title="customOptionValue"
+              :class="
+                cn(
+                  'flex h-8 w-full min-w-0 items-center gap-2 rounded-sm px-2 text-left text-sm hover:bg-accent hover:text-accent-foreground focus-visible:bg-accent focus-visible:text-accent-foreground focus-visible:outline-none',
+                  props.itemClass,
+                  0 === highlightIndex && 'bg-accent text-accent-foreground',
+                )
+              "
+              @pointerenter="activateHelpForOption(customOptionValue)"
+              @click="selectCustomOption"
+            >
+              <Check class="h-3.5 w-3.5 shrink-0 opacity-0" />
+              <slot name="custom-option-label" :value="customOptionValue">
+                <span class="truncate">{{ customOptionValue }}</span>
+              </slot>
+            </button>
+            <div v-else class="px-2 py-2 text-sm text-muted-foreground">
+              {{ emptyText }}
+            </div>
+          </div>
+        </div>
+        <OptionHelpPanel v-if="activeHelpContent" ref="helpPanel" :content="activeHelpContent" :offset-top="helpPanelOffsetTop" />
+      </div>
+    </PopoverContent>
+  </Popover>
+</template>
+
+<style>
+.dbx-searchable-select-trigger {
+  border: 1px solid rgb(229, 229, 229) !important;
+  background-color: rgb(255, 255, 255) !important;
+  box-shadow: none !important;
+}
+
+.dbx-searchable-select-trigger:hover {
+  background-color: rgb(250, 250, 250) !important;
+}
+
+.dbx-searchable-select-trigger[aria-expanded="true"],
+.dbx-searchable-select-trigger:focus-visible {
+  border-color: rgb(96, 165, 250) !important;
+  box-shadow: 0 0 0 2px rgba(96, 165, 250, 0.22) !important;
+}
+
+.dark .dbx-searchable-select-trigger {
+  border-color: rgba(255, 255, 255, 0.14) !important;
+  background-color: rgba(255, 255, 255, 0.08) !important;
+}
+
+.dark .dbx-searchable-select-trigger:hover {
+  background-color: rgba(255, 255, 255, 0.12) !important;
+}
+
+.dark .dbx-searchable-select-trigger[aria-expanded="true"],
+.dark .dbx-searchable-select-trigger:focus-visible {
+  border-color: rgb(147, 197, 253) !important;
+  box-shadow: 0 0 0 2px rgba(147, 197, 253, 0.24) !important;
+}
+</style>
diff --git a/apps/desktop/src/components/ui/searchable-select/index.ts b/apps/desktop/src/components/ui/searchable-select/index.ts
new file mode 100644
index 0000000..668e49b
--- /dev/null
+++ b/apps/desktop/src/components/ui/searchable-select/index.ts
@@ -0,0 +1 @@
+export { default as SearchableSelect } from "./SearchableSelect.vue";
diff --git a/apps/desktop/src/components/ui/select/Select.vue b/apps/desktop/src/components/ui/select/Select.vue
new file mode 100644
index 0000000..f58547d
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/Select.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { SelectRootEmits, SelectRootProps } from "reka-ui";
+import { SelectRoot, useForwardPropsEmits } from "reka-ui";
+
+const props = defineProps<SelectRootProps>();
+const emits = defineEmits<SelectRootEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <SelectRoot v-slot="slotProps" data-slot="select" v-bind="forwarded">
+    <slot v-bind="slotProps" />
+  </SelectRoot>
+</template>
diff --git a/apps/desktop/src/components/ui/select/SelectContent.vue b/apps/desktop/src/components/ui/select/SelectContent.vue
new file mode 100644
index 0000000..a95ab32
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/SelectContent.vue
@@ -0,0 +1,57 @@
+<script setup lang="ts">
+import type { SelectContentEmits, SelectContentProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { SelectContent, SelectPortal, SelectViewport, useForwardPropsEmits } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+import { SelectScrollDownButton, SelectScrollUpButton } from ".";
+
+defineOptions({
+  inheritAttrs: false,
+});
+
+const props = withDefaults(
+  defineProps<
+    SelectContentProps & {
+      class?: HTMLAttributes["class"];
+      disablePortal?: boolean;
+      disableOutsidePointerEvents?: boolean;
+      hideScrollButtons?: boolean;
+    }
+  >(),
+  {
+    position: "popper",
+    disablePortal: false,
+    disableOutsidePointerEvents: true,
+    hideScrollButtons: false,
+  },
+);
+const emits = defineEmits<SelectContentEmits>();
+
+const delegatedProps = reactiveOmit(props, "class", "disablePortal", "hideScrollButtons");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <SelectPortal :disabled="disablePortal">
+    <SelectContent
+      data-slot="select-content"
+      :data-align-trigger="position === 'item-aligned'"
+      v-bind="{ ...$attrs, ...forwarded }"
+      :class="
+        cn(
+          'text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 min-w-36 rounded-[6px] ring-1 duration-100 data-[side=inline-start]:slide-in-from-right-2 data-[side=inline-end]:slide-in-from-left-2 cn-menu-translucent relative z-50 max-h-(--reka-select-content-available-height) origin-(--reka-select-content-transform-origin) overflow-x-hidden overflow-y-auto data-[align-trigger=true]:animate-none',
+          position === 'popper' && 'w-fit min-w-[var(--reka-select-trigger-width)] data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1',
+          props.class,
+        )
+      "
+    >
+      <SelectScrollUpButton v-if="!hideScrollButtons" />
+      <SelectViewport :data-position="position" :class="cn('data-[position=popper]:h-[var(--reka-select-trigger-height)] data-[position=popper]:w-full')">
+        <slot />
+      </SelectViewport>
+      <SelectScrollDownButton v-if="!hideScrollButtons" />
+    </SelectContent>
+  </SelectPortal>
+</template>
diff --git a/apps/desktop/src/components/ui/select/SelectGroup.vue b/apps/desktop/src/components/ui/select/SelectGroup.vue
new file mode 100644
index 0000000..084161a
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/SelectGroup.vue
@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import type { SelectGroupProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { SelectGroup } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<SelectGroupProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <SelectGroup data-slot="select-group" v-bind="delegatedProps" :class="cn('scroll-my-1 p-1', props.class)">
+    <slot />
+  </SelectGroup>
+</template>
diff --git a/apps/desktop/src/components/ui/select/SelectItem.vue b/apps/desktop/src/components/ui/select/SelectItem.vue
new file mode 100644
index 0000000..017ffe2
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/SelectItem.vue
@@ -0,0 +1,40 @@
+<script setup lang="ts">
+import type { SelectItemProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { CheckIcon } from "@lucide/vue";
+import { SelectItem, SelectItemIndicator, SelectItemText, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<SelectItemProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <SelectItem
+    data-slot="select-item"
+    v-bind="forwardedProps"
+    :class="
+      cn(
+        'focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*=size-])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2 relative flex w-full cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        props.class,
+      )
+    "
+  >
+    <span class="pointer-events-none absolute right-2 flex size-4 items-center justify-center">
+      <SelectItemIndicator>
+        <slot name="indicator-icon">
+          <CheckIcon class="pointer-events-none" />
+        </slot>
+      </SelectItemIndicator>
+    </span>
+
+    <SelectItemText>
+      <slot />
+    </SelectItemText>
+  </SelectItem>
+</template>
diff --git a/apps/desktop/src/components/ui/select/SelectItemText.vue b/apps/desktop/src/components/ui/select/SelectItemText.vue
new file mode 100644
index 0000000..1ddc6d7
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/SelectItemText.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { SelectItemTextProps } from "reka-ui";
+import { SelectItemText } from "reka-ui";
+
+const props = defineProps<SelectItemTextProps>();
+</script>
+
+<template>
+  <SelectItemText data-slot="select-item-text" v-bind="props">
+    <slot />
+  </SelectItemText>
+</template>
diff --git a/apps/desktop/src/components/ui/select/SelectLabel.vue b/apps/desktop/src/components/ui/select/SelectLabel.vue
new file mode 100644
index 0000000..0320f57
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/SelectLabel.vue
@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import type { SelectLabelProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { SelectLabel } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<SelectLabelProps & { class?: HTMLAttributes["class"] }>();
+</script>
+
+<template>
+  <SelectLabel data-slot="select-label" :class="cn('text-muted-foreground px-1.5 py-1 text-xs', props.class)">
+    <slot />
+  </SelectLabel>
+</template>
diff --git a/apps/desktop/src/components/ui/select/SelectScrollDownButton.vue b/apps/desktop/src/components/ui/select/SelectScrollDownButton.vue
new file mode 100644
index 0000000..9007396
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/SelectScrollDownButton.vue
@@ -0,0 +1,23 @@
+<script setup lang="ts">
+import type { SelectScrollDownButtonProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ChevronDownIcon } from "@lucide/vue";
+import { SelectScrollDownButton, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<SelectScrollDownButtonProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <SelectScrollDownButton data-slot="select-scroll-down-button" v-bind="forwardedProps" :class="cn('bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4', props.class)">
+    <slot>
+      <ChevronDownIcon />
+    </slot>
+  </SelectScrollDownButton>
+</template>
diff --git a/apps/desktop/src/components/ui/select/SelectScrollUpButton.vue b/apps/desktop/src/components/ui/select/SelectScrollUpButton.vue
new file mode 100644
index 0000000..924813c
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/SelectScrollUpButton.vue
@@ -0,0 +1,23 @@
+<script setup lang="ts">
+import type { SelectScrollUpButtonProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ChevronUpIcon } from "@lucide/vue";
+import { SelectScrollUpButton, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<SelectScrollUpButtonProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <SelectScrollUpButton data-slot="select-scroll-up-button" v-bind="forwardedProps" :class="cn('bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4', props.class)">
+    <slot>
+      <ChevronUpIcon />
+    </slot>
+  </SelectScrollUpButton>
+</template>
diff --git a/apps/desktop/src/components/ui/select/SelectSeparator.vue b/apps/desktop/src/components/ui/select/SelectSeparator.vue
new file mode 100644
index 0000000..bb9f086
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/SelectSeparator.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { SelectSeparatorProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { SelectSeparator } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<SelectSeparatorProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <SelectSeparator data-slot="select-separator" v-bind="delegatedProps" :class="cn('bg-border -mx-1 my-1 h-px pointer-events-none', props.class)" />
+</template>
diff --git a/apps/desktop/src/components/ui/select/SelectTrigger.vue b/apps/desktop/src/components/ui/select/SelectTrigger.vue
new file mode 100644
index 0000000..ae16899
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/SelectTrigger.vue
@@ -0,0 +1,66 @@
+<script setup lang="ts">
+import type { SelectTriggerProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { ChevronDownIcon } from "@lucide/vue";
+import { SelectIcon, SelectTrigger, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = withDefaults(defineProps<SelectTriggerProps & { class?: HTMLAttributes["class"]; size?: "sm" | "default" }>(), { size: "default" });
+
+const delegatedProps = reactiveOmit(props, "class", "size");
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <SelectTrigger
+    data-slot="select-trigger"
+    :data-size="size"
+    v-bind="forwardedProps"
+    :class="
+      cn(
+        'dbx-select-trigger border-input data-placeholder:text-muted-foreground dark:bg-input/30 dark:hover:bg-input/50 focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 gap-1.5 rounded-[6px] border bg-transparent py-2 pr-2 pl-2.5 text-sm transition-colors select-none focus-visible:ring-3 aria-invalid:ring-3 data-[size=default]:h-8 data-[size=sm]:h-7 *:data-[slot=select-value]:gap-1.5 [&_svg:not([class*=size-])]:size-4 flex w-fit items-center justify-between whitespace-nowrap outline-none disabled:cursor-not-allowed disabled:opacity-50 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        props.class,
+      )
+    "
+  >
+    <slot />
+    <SelectIcon as-child>
+      <ChevronDownIcon class="text-muted-foreground size-4 pointer-events-none" />
+    </SelectIcon>
+  </SelectTrigger>
+</template>
+
+<style>
+.dbx-select-trigger:not(.border-0):not(.border-transparent) {
+  border: 1px solid rgb(229, 229, 229) !important;
+  background-color: rgb(255, 255, 255) !important;
+  box-shadow: none !important;
+}
+
+.dbx-select-trigger:not(.border-0):not(.border-transparent):hover {
+  background-color: rgb(250, 250, 250) !important;
+}
+
+.dbx-select-trigger:not(.border-0):not(.border-transparent)[data-state="open"],
+.dbx-select-trigger:not(.border-0):not(.border-transparent):focus-visible {
+  border-color: rgb(96, 165, 250) !important;
+  box-shadow: 0 0 0 2px rgba(96, 165, 250, 0.22) !important;
+}
+
+.dark .dbx-select-trigger:not(.border-0):not(.border-transparent) {
+  border-color: rgba(255, 255, 255, 0.14) !important;
+  background-color: rgba(255, 255, 255, 0.08) !important;
+}
+
+.dark .dbx-select-trigger:not(.border-0):not(.border-transparent):hover {
+  background-color: rgba(255, 255, 255, 0.12) !important;
+}
+
+.dark .dbx-select-trigger:not(.border-0):not(.border-transparent)[data-state="open"],
+.dark .dbx-select-trigger:not(.border-0):not(.border-transparent):focus-visible {
+  border-color: rgb(147, 197, 253) !important;
+  box-shadow: 0 0 0 2px rgba(147, 197, 253, 0.24) !important;
+}
+</style>
diff --git a/apps/desktop/src/components/ui/select/SelectValue.vue b/apps/desktop/src/components/ui/select/SelectValue.vue
new file mode 100644
index 0000000..3811528
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/SelectValue.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { SelectValueProps } from "reka-ui";
+import { SelectValue } from "reka-ui";
+
+const props = defineProps<SelectValueProps>();
+</script>
+
+<template>
+  <SelectValue data-slot="select-value" v-bind="props">
+    <slot />
+  </SelectValue>
+</template>
diff --git a/apps/desktop/src/components/ui/select/index.ts b/apps/desktop/src/components/ui/select/index.ts
new file mode 100644
index 0000000..d911c4e
--- /dev/null
+++ b/apps/desktop/src/components/ui/select/index.ts
@@ -0,0 +1,11 @@
+export { default as Select } from "./Select.vue";
+export { default as SelectContent } from "./SelectContent.vue";
+export { default as SelectGroup } from "./SelectGroup.vue";
+export { default as SelectItem } from "./SelectItem.vue";
+export { default as SelectItemText } from "./SelectItemText.vue";
+export { default as SelectLabel } from "./SelectLabel.vue";
+export { default as SelectScrollDownButton } from "./SelectScrollDownButton.vue";
+export { default as SelectScrollUpButton } from "./SelectScrollUpButton.vue";
+export { default as SelectSeparator } from "./SelectSeparator.vue";
+export { default as SelectTrigger } from "./SelectTrigger.vue";
+export { default as SelectValue } from "./SelectValue.vue";
diff --git a/apps/desktop/src/components/ui/separator/Separator.vue b/apps/desktop/src/components/ui/separator/Separator.vue
new file mode 100644
index 0000000..63ebc04
--- /dev/null
+++ b/apps/desktop/src/components/ui/separator/Separator.vue
@@ -0,0 +1,18 @@
+<script setup lang="ts">
+import type { SeparatorProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { Separator } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = withDefaults(defineProps<SeparatorProps & { class?: HTMLAttributes["class"] }>(), {
+  orientation: "horizontal",
+  decorative: true,
+});
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <Separator data-slot="separator" v-bind="delegatedProps" :class="cn('shrink-0 bg-border data-[orientation=horizontal]:h-px data-[orientation=horizontal]:w-full data-[orientation=vertical]:w-px data-[orientation=vertical]:self-stretch', props.class)" />
+</template>
diff --git a/apps/desktop/src/components/ui/separator/index.ts b/apps/desktop/src/components/ui/separator/index.ts
new file mode 100644
index 0000000..aae7f1a
--- /dev/null
+++ b/apps/desktop/src/components/ui/separator/index.ts
@@ -0,0 +1 @@
+export { default as Separator } from "./Separator.vue";
diff --git a/apps/desktop/src/components/ui/sheet/Sheet.vue b/apps/desktop/src/components/ui/sheet/Sheet.vue
new file mode 100644
index 0000000..ecdbffe
--- /dev/null
+++ b/apps/desktop/src/components/ui/sheet/Sheet.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { DialogRootEmits, DialogRootProps } from "reka-ui";
+import { DialogRoot, useForwardPropsEmits } from "reka-ui";
+
+const props = defineProps<DialogRootProps>();
+const emits = defineEmits<DialogRootEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <DialogRoot v-slot="slotProps" data-slot="sheet" v-bind="forwarded">
+    <slot v-bind="slotProps" />
+  </DialogRoot>
+</template>
diff --git a/apps/desktop/src/components/ui/sheet/SheetClose.vue b/apps/desktop/src/components/ui/sheet/SheetClose.vue
new file mode 100644
index 0000000..cc15741
--- /dev/null
+++ b/apps/desktop/src/components/ui/sheet/SheetClose.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { DialogCloseProps } from "reka-ui";
+import { DialogClose } from "reka-ui";
+
+const props = defineProps<DialogCloseProps>();
+</script>
+
+<template>
+  <DialogClose data-slot="sheet-close" v-bind="props">
+    <slot />
+  </DialogClose>
+</template>
diff --git a/apps/desktop/src/components/ui/sheet/SheetContent.vue b/apps/desktop/src/components/ui/sheet/SheetContent.vue
new file mode 100644
index 0000000..2488dbe
--- /dev/null
+++ b/apps/desktop/src/components/ui/sheet/SheetContent.vue
@@ -0,0 +1,59 @@
+<script setup lang="ts">
+import type { DialogContentEmits, DialogContentProps } from "reka-ui";
+
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { XIcon } from "@lucide/vue";
+import { DialogClose, DialogContent, DialogPortal, useForwardPropsEmits } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+import { Button } from "@/components/ui/button";
+import SheetOverlay from "./SheetOverlay.vue";
+
+interface SheetContentProps extends DialogContentProps {
+  class?: HTMLAttributes["class"];
+  side?: "top" | "right" | "bottom" | "left";
+  showCloseButton?: boolean;
+}
+
+defineOptions({
+  inheritAttrs: false,
+});
+
+const props = withDefaults(defineProps<SheetContentProps>(), {
+  side: "right",
+  showCloseButton: true,
+});
+const emits = defineEmits<DialogContentEmits>();
+
+const delegatedProps = reactiveOmit(props, "class", "side", "showCloseButton");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <DialogPortal>
+    <DialogClose as-child>
+      <SheetOverlay />
+    </DialogClose>
+    <DialogContent
+      data-slot="sheet-content"
+      :data-side="side"
+      :class="
+        cn(
+          'bg-popover text-popover-foreground fixed z-50 flex flex-col gap-4 bg-clip-padding text-sm shadow-lg transition duration-200 ease-in-out data-[side=bottom]:inset-x-0 data-[side=bottom]:bottom-0 data-[side=bottom]:h-auto data-[side=bottom]:border-t data-[side=left]:inset-y-0 data-[side=left]:left-0 data-[side=left]:h-full data-[side=left]:w-3/4 data-[side=left]:border-r data-[side=right]:inset-y-0 data-[side=right]:right-0 data-[side=right]:h-full data-[side=right]:w-3/4 data-[side=right]:border-l data-[side=top]:inset-x-0 data-[side=top]:top-0 data-[side=top]:h-auto data-[side=top]:border-b data-[side=left]:sm:max-w-sm data-[side=right]:sm:max-w-sm data-open:animate-in data-open:fade-in-0 data-[side=bottom]:data-open:slide-in-from-bottom-10 data-[side=left]:data-open:slide-in-from-left-10 data-[side=right]:data-open:slide-in-from-right-10 data-[side=top]:data-open:slide-in-from-top-10 data-closed:animate-out data-closed:fade-out-0 data-[side=bottom]:data-closed:slide-out-to-bottom-10 data-[side=left]:data-closed:slide-out-to-left-10 data-[side=right]:data-closed:slide-out-to-right-10 data-[side=top]:data-closed:slide-out-to-top-10',
+          props.class,
+        )
+      "
+      v-bind="{ ...$attrs, ...forwarded }"
+    >
+      <slot />
+
+      <DialogClose v-if="showCloseButton" data-slot="sheet-close" as-child>
+        <Button variant="ghost" class="absolute top-3 right-3" size="icon-sm">
+          <XIcon />
+          <span class="sr-only">Close</span>
+        </Button>
+      </DialogClose>
+    </DialogContent>
+  </DialogPortal>
+</template>
diff --git a/apps/desktop/src/components/ui/sheet/SheetDescription.vue b/apps/desktop/src/components/ui/sheet/SheetDescription.vue
new file mode 100644
index 0000000..dc96cc1
--- /dev/null
+++ b/apps/desktop/src/components/ui/sheet/SheetDescription.vue
@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import type { DialogDescriptionProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { DialogDescription } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<DialogDescriptionProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <DialogDescription data-slot="sheet-description" :class="cn('text-muted-foreground text-sm', props.class)" v-bind="delegatedProps">
+    <slot />
+  </DialogDescription>
+</template>
diff --git a/apps/desktop/src/components/ui/sheet/SheetFooter.vue b/apps/desktop/src/components/ui/sheet/SheetFooter.vue
new file mode 100644
index 0000000..1467f3c
--- /dev/null
+++ b/apps/desktop/src/components/ui/sheet/SheetFooter.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<{ class?: HTMLAttributes["class"] }>();
+</script>
+
+<template>
+  <div data-slot="sheet-footer" :class="cn('gap-2 p-4 mt-auto flex flex-col', props.class)">
+    <slot />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/ui/sheet/SheetHeader.vue b/apps/desktop/src/components/ui/sheet/SheetHeader.vue
new file mode 100644
index 0000000..fd7868a
--- /dev/null
+++ b/apps/desktop/src/components/ui/sheet/SheetHeader.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { HTMLAttributes } from "vue";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<{ class?: HTMLAttributes["class"] }>();
+</script>
+
+<template>
+  <div data-slot="sheet-header" :class="cn('gap-0.5 p-4 flex flex-col', props.class)">
+    <slot />
+  </div>
+</template>
diff --git a/apps/desktop/src/components/ui/sheet/SheetOverlay.vue b/apps/desktop/src/components/ui/sheet/SheetOverlay.vue
new file mode 100644
index 0000000..272f8ba
--- /dev/null
+++ b/apps/desktop/src/components/ui/sheet/SheetOverlay.vue
@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import type { DialogOverlayProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { DialogOverlay } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<DialogOverlayProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <DialogOverlay data-slot="sheet-overlay" :class="cn('bg-black/20 fixed inset-0 z-50 data-open:animate-in data-open:fade-in-0 data-open:duration-200', props.class)" v-bind="delegatedProps">
+    <slot />
+  </DialogOverlay>
+</template>
diff --git a/apps/desktop/src/components/ui/sheet/SheetTitle.vue b/apps/desktop/src/components/ui/sheet/SheetTitle.vue
new file mode 100644
index 0000000..9586328
--- /dev/null
+++ b/apps/desktop/src/components/ui/sheet/SheetTitle.vue
@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import type { DialogTitleProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { DialogTitle } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<DialogTitleProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <DialogTitle data-slot="sheet-title" :class="cn('text-foreground text-base font-medium cn-font-heading', props.class)" v-bind="delegatedProps">
+    <slot />
+  </DialogTitle>
+</template>
diff --git a/apps/desktop/src/components/ui/sheet/SheetTrigger.vue b/apps/desktop/src/components/ui/sheet/SheetTrigger.vue
new file mode 100644
index 0000000..a57258e
--- /dev/null
+++ b/apps/desktop/src/components/ui/sheet/SheetTrigger.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { DialogTriggerProps } from "reka-ui";
+import { DialogTrigger } from "reka-ui";
+
+const props = defineProps<DialogTriggerProps>();
+</script>
+
+<template>
+  <DialogTrigger data-slot="sheet-trigger" v-bind="props">
+    <slot />
+  </DialogTrigger>
+</template>
diff --git a/apps/desktop/src/components/ui/sheet/index.ts b/apps/desktop/src/components/ui/sheet/index.ts
new file mode 100644
index 0000000..b94a071
--- /dev/null
+++ b/apps/desktop/src/components/ui/sheet/index.ts
@@ -0,0 +1,8 @@
+export { default as Sheet } from "./Sheet.vue";
+export { default as SheetClose } from "./SheetClose.vue";
+export { default as SheetContent } from "./SheetContent.vue";
+export { default as SheetDescription } from "./SheetDescription.vue";
+export { default as SheetFooter } from "./SheetFooter.vue";
+export { default as SheetHeader } from "./SheetHeader.vue";
+export { default as SheetTitle } from "./SheetTitle.vue";
+export { default as SheetTrigger } from "./SheetTrigger.vue";
diff --git a/apps/desktop/src/components/ui/switch/Switch.vue b/apps/desktop/src/components/ui/switch/Switch.vue
new file mode 100644
index 0000000..a89e549
--- /dev/null
+++ b/apps/desktop/src/components/ui/switch/Switch.vue
@@ -0,0 +1,123 @@
+<script setup lang="ts">
+import type { SwitchRootEmits, SwitchRootProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { SwitchRoot, SwitchThumb, useForwardPropsEmits } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = withDefaults(
+  defineProps<
+    SwitchRootProps & {
+      class?: HTMLAttributes["class"];
+      size?: "sm" | "default";
+    }
+  >(),
+  {
+    size: "default",
+  },
+);
+
+const emits = defineEmits<SwitchRootEmits>();
+
+const delegatedProps = reactiveOmit(props, "class", "size");
+
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <SwitchRoot
+    v-slot="slotProps"
+    data-slot="switch"
+    :data-size="size"
+    v-bind="forwarded"
+    :class="
+      cn(
+        'dbx-switch data-checked:bg-primary data-unchecked:bg-input focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 dark:data-unchecked:bg-input/80 shrink-0 rounded-full border border-transparent focus-visible:ring-3 aria-invalid:ring-3 data-[size=default]:h-[18.4px] data-[size=default]:w-[32px] data-[size=sm]:h-[14px] data-[size=sm]:w-[24px] peer group/switch relative inline-flex items-center transition-colors outline-none after:absolute after:-inset-x-3 after:-inset-y-2 data-disabled:cursor-not-allowed data-disabled:opacity-50',
+        props.class,
+      )
+    "
+  >
+    <SwitchThumb data-slot="switch-thumb" class="dbx-switch-thumb bg-background dark:data-unchecked:bg-foreground dark:data-checked:bg-primary-foreground rounded-full group-data-[size=default]/switch:size-4 group-data-[size=sm]/switch:size-3 pointer-events-none block ring-0 transition-transform">
+      <slot name="thumb" v-bind="slotProps" />
+    </SwitchThumb>
+  </SwitchRoot>
+</template>
+
+<style>
+.dbx-switch {
+  box-sizing: border-box;
+  display: inline-flex !important;
+  align-items: center !important;
+  position: relative;
+  flex-shrink: 0;
+  overflow: hidden;
+  border: 1px solid rgba(120, 120, 128, 0.22) !important;
+  background-color: rgb(229, 229, 229) !important;
+  vertical-align: middle;
+}
+
+.dbx-switch[data-size="default"] {
+  width: 32px !important;
+  height: 18.4px !important;
+}
+
+.dbx-switch[data-size="sm"] {
+  width: 24px !important;
+  height: 14px !important;
+}
+
+.dbx-switch-thumb {
+  display: block !important;
+  border-radius: 9999px;
+  background-color: rgb(255, 255, 255) !important;
+  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.22);
+  transform: translateX(0) !important;
+}
+
+.dbx-switch[data-size="default"] .dbx-switch-thumb {
+  width: 16px !important;
+  height: 16px !important;
+}
+
+.dbx-switch[data-size="sm"] .dbx-switch-thumb {
+  width: 12px !important;
+  height: 12px !important;
+}
+
+.dbx-switch[data-state="checked"],
+.dbx-switch[data-checked],
+.dbx-switch[aria-checked="true"] {
+  border-color: rgb(23, 23, 23) !important;
+  background-color: rgb(23, 23, 23) !important;
+}
+
+.dbx-switch[data-size="default"][data-state="checked"] .dbx-switch-thumb,
+.dbx-switch[data-size="default"][data-checked] .dbx-switch-thumb,
+.dbx-switch[data-size="default"][aria-checked="true"] .dbx-switch-thumb {
+  transform: translateX(14px) !important;
+}
+
+.dbx-switch[data-size="sm"][data-state="checked"] .dbx-switch-thumb,
+.dbx-switch[data-size="sm"][data-checked] .dbx-switch-thumb,
+.dbx-switch[data-size="sm"][aria-checked="true"] .dbx-switch-thumb {
+  transform: translateX(10px) !important;
+}
+
+.dark .dbx-switch {
+  border-color: rgba(255, 255, 255, 0.16) !important;
+  background-color: rgba(255, 255, 255, 0.18) !important;
+}
+
+.dark .dbx-switch[data-state="checked"],
+.dark .dbx-switch[data-checked],
+.dark .dbx-switch[aria-checked="true"] {
+  border-color: rgb(245, 245, 245) !important;
+  background-color: rgb(245, 245, 245) !important;
+}
+
+.dark .dbx-switch[data-state="checked"] .dbx-switch-thumb,
+.dark .dbx-switch[data-checked] .dbx-switch-thumb,
+.dark .dbx-switch[aria-checked="true"] .dbx-switch-thumb {
+  background-color: rgb(23, 23, 23) !important;
+}
+</style>
diff --git a/apps/desktop/src/components/ui/switch/index.ts b/apps/desktop/src/components/ui/switch/index.ts
new file mode 100644
index 0000000..c986f8a
--- /dev/null
+++ b/apps/desktop/src/components/ui/switch/index.ts
@@ -0,0 +1 @@
+export { default as Switch } from "./Switch.vue";
diff --git a/apps/desktop/src/components/ui/tabs/Tabs.vue b/apps/desktop/src/components/ui/tabs/Tabs.vue
new file mode 100644
index 0000000..85dbe77
--- /dev/null
+++ b/apps/desktop/src/components/ui/tabs/Tabs.vue
@@ -0,0 +1,19 @@
+<script setup lang="ts">
+import type { TabsRootEmits, TabsRootProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { TabsRoot, useForwardPropsEmits } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<TabsRootProps & { class?: HTMLAttributes["class"] }>();
+const emits = defineEmits<TabsRootEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <TabsRoot v-slot="slotProps" data-slot="tabs" :data-orientation="forwarded.orientation || 'horizontal'" v-bind="forwarded" :class="cn('gap-2 group/tabs flex data-horizontal:flex-col', props.class)">
+    <slot v-bind="slotProps" />
+  </TabsRoot>
+</template>
diff --git a/apps/desktop/src/components/ui/tabs/TabsContent.vue b/apps/desktop/src/components/ui/tabs/TabsContent.vue
new file mode 100644
index 0000000..4091059
--- /dev/null
+++ b/apps/desktop/src/components/ui/tabs/TabsContent.vue
@@ -0,0 +1,17 @@
+<script setup lang="ts">
+import type { TabsContentProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { TabsContent } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<TabsContentProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <TabsContent data-slot="tabs-content" :class="cn('text-sm flex-1 outline-none', props.class)" v-bind="delegatedProps">
+    <slot />
+  </TabsContent>
+</template>
diff --git a/apps/desktop/src/components/ui/tabs/TabsList.vue b/apps/desktop/src/components/ui/tabs/TabsList.vue
new file mode 100644
index 0000000..0c122f7
--- /dev/null
+++ b/apps/desktop/src/components/ui/tabs/TabsList.vue
@@ -0,0 +1,29 @@
+<script setup lang="ts">
+import type { TabsListProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import type { TabsListVariants } from ".";
+import { reactiveOmit } from "@vueuse/core";
+import { TabsList } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+import { tabsListVariants } from ".";
+
+const props = withDefaults(
+  defineProps<
+    TabsListProps & {
+      class?: HTMLAttributes["class"];
+      variant?: TabsListVariants["variant"];
+    }
+  >(),
+  {
+    variant: "default",
+  },
+);
+
+const delegatedProps = reactiveOmit(props, "class", "variant");
+</script>
+
+<template>
+  <TabsList data-slot="tabs-list" :data-variant="variant" v-bind="delegatedProps" :class="cn(tabsListVariants({ variant }), props.class)">
+    <slot />
+  </TabsList>
+</template>
diff --git a/apps/desktop/src/components/ui/tabs/TabsTrigger.vue b/apps/desktop/src/components/ui/tabs/TabsTrigger.vue
new file mode 100644
index 0000000..20d1f8a
--- /dev/null
+++ b/apps/desktop/src/components/ui/tabs/TabsTrigger.vue
@@ -0,0 +1,31 @@
+<script setup lang="ts">
+import type { TabsTriggerProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { TabsTrigger, useForwardProps } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+const props = defineProps<TabsTriggerProps & { class?: HTMLAttributes["class"] }>();
+
+const delegatedProps = reactiveOmit(props, "class");
+
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <TabsTrigger
+    data-slot="tabs-trigger"
+    :class="
+      cn(
+        'gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg:not([class*=size-])]:size-4 has-data-[icon=inline-end]:pr-1 has-data-[icon=inline-start]:pl-1 relative inline-flex h-[calc(100%-1px)] flex-1 select-none items-center justify-center whitespace-nowrap text-foreground/60 transition-colors group-data-vertical/tabs:w-full group-data-vertical/tabs:justify-start hover:text-foreground focus-visible:border-ring focus-visible:ring-[3px] focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring disabled:pointer-events-none disabled:opacity-50 dark:text-muted-foreground dark:hover:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0',
+        'group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent',
+        'data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground',
+        'after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-horizontal/tabs:after:inset-x-0 group-data-horizontal/tabs:after:bottom-[-5px] group-data-horizontal/tabs:after:h-0.5 group-data-vertical/tabs:after:inset-y-0 group-data-vertical/tabs:after:-right-1 group-data-vertical/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100',
+        props.class,
+      )
+    "
+    v-bind="forwardedProps"
+  >
+    <slot />
+  </TabsTrigger>
+</template>
diff --git a/apps/desktop/src/components/ui/tabs/index.ts b/apps/desktop/src/components/ui/tabs/index.ts
new file mode 100644
index 0000000..4d74a95
--- /dev/null
+++ b/apps/desktop/src/components/ui/tabs/index.ts
@@ -0,0 +1,21 @@
+import type { VariantProps } from "class-variance-authority";
+import { cva } from "class-variance-authority";
+
+export { default as Tabs } from "./Tabs.vue";
+export { default as TabsContent } from "./TabsContent.vue";
+export { default as TabsList } from "./TabsList.vue";
+export { default as TabsTrigger } from "./TabsTrigger.vue";
+
+export const tabsListVariants = cva("rounded-[6px] p-[3px] group-data-horizontal/tabs:h-8 data-[variant=line]:rounded-none group/tabs-list inline-flex w-fit select-none items-center justify-center text-muted-foreground group-data-vertical/tabs:h-fit group-data-vertical/tabs:flex-col", {
+  variants: {
+    variant: {
+      default: "bg-muted",
+      line: "gap-1 bg-transparent",
+    },
+  },
+  defaultVariants: {
+    variant: "default",
+  },
+});
+
+export type TabsListVariants = VariantProps<typeof tabsListVariants>;
diff --git a/apps/desktop/src/components/ui/tooltip/HelpTooltip.vue b/apps/desktop/src/components/ui/tooltip/HelpTooltip.vue
new file mode 100644
index 0000000..6e9b1ff
--- /dev/null
+++ b/apps/desktop/src/components/ui/tooltip/HelpTooltip.vue
@@ -0,0 +1,39 @@
+<script setup lang="ts">
+import { CircleHelp } from "@lucide/vue";
+import LightTooltip from "@/components/ui/LightTooltip.vue";
+
+withDefaults(
+  defineProps<{
+    label: string;
+    side?: "top" | "right" | "bottom" | "left";
+    sideOffset?: number;
+    delay?: number;
+    closeDelay?: number;
+    openOnFocus?: boolean;
+    triggerClass?: string;
+    contentClass?: string;
+  }>(),
+  {
+    side: "top",
+    sideOffset: 8,
+    delay: 0,
+    closeDelay: 100,
+    openOnFocus: true,
+    triggerClass: "",
+    contentClass: "max-w-[320px]",
+  },
+);
+</script>
+
+<template>
+  <LightTooltip :text="label" :side="side" :side-offset="sideOffset" :delay="delay" :close-delay="closeDelay" :open-on-focus="openOnFocus">
+    <button type="button" class="inline-flex shrink-0 cursor-help items-center justify-center border-0 bg-transparent p-0 text-muted-foreground hover:text-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring" :class="triggerClass" :aria-label="label">
+      <CircleHelp class="h-3.5 w-3.5" aria-hidden="true" />
+    </button>
+    <template #content>
+      <div class="px-3 py-1.5 text-xs leading-relaxed" :class="contentClass">
+        <slot />
+      </div>
+    </template>
+  </LightTooltip>
+</template>
diff --git a/apps/desktop/src/components/ui/tooltip/Tooltip.vue b/apps/desktop/src/components/ui/tooltip/Tooltip.vue
new file mode 100644
index 0000000..4efee8c
--- /dev/null
+++ b/apps/desktop/src/components/ui/tooltip/Tooltip.vue
@@ -0,0 +1,15 @@
+<script setup lang="ts">
+import type { TooltipRootEmits, TooltipRootProps } from "reka-ui";
+import { TooltipRoot, useForwardPropsEmits } from "reka-ui";
+
+const props = defineProps<TooltipRootProps>();
+const emits = defineEmits<TooltipRootEmits>();
+
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <TooltipRoot v-slot="slotProps" data-slot="tooltip" v-bind="forwarded">
+    <slot v-bind="slotProps" />
+  </TooltipRoot>
+</template>
diff --git a/apps/desktop/src/components/ui/tooltip/TooltipContent.vue b/apps/desktop/src/components/ui/tooltip/TooltipContent.vue
new file mode 100644
index 0000000..7472567
--- /dev/null
+++ b/apps/desktop/src/components/ui/tooltip/TooltipContent.vue
@@ -0,0 +1,39 @@
+<script setup lang="ts">
+import type { TooltipContentEmits, TooltipContentProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { reactiveOmit } from "@vueuse/core";
+import { TooltipArrow, TooltipContent, TooltipPortal, useForwardPropsEmits } from "reka-ui";
+import { cn } from "@/lib/common/utils";
+
+defineOptions({
+  inheritAttrs: false,
+});
+
+const props = withDefaults(defineProps<TooltipContentProps & { class?: HTMLAttributes["class"] }>(), {
+  sideOffset: 0,
+});
+
+const emits = defineEmits<TooltipContentEmits>();
+
+const delegatedProps = reactiveOmit(props, "class");
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <TooltipPortal>
+    <TooltipContent
+      data-slot="tooltip-content"
+      v-bind="{ ...forwarded, ...$attrs }"
+      :class="
+        cn(
+          'data-open:animate-in data-open:fade-in-0 data-open:zoom-in-95 data-[state=delayed-open]:animate-in data-[state=delayed-open]:fade-in-0 data-[state=delayed-open]:zoom-in-95 data-closed:animate-out data-closed:fade-out-0 data-closed:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 inline-flex items-center gap-1.5 rounded-md px-3 py-1.5 text-xs has-data-[slot=kbd]:pr-1.5 **:data-[slot=kbd]:relative **:data-[slot=kbd]:isolate **:data-[slot=kbd]:z-50 **:data-[slot=kbd]:rounded-sm bg-foreground text-background z-50 w-fit max-w-xs origin-(--reka-tooltip-content-transform-origin)',
+          props.class,
+        )
+      "
+    >
+      <slot />
+
+      <TooltipArrow class="size-2.5 rotate-45 rounded-[2px] bg-foreground fill-foreground z-50 translate-y-[calc(-50%_-_2px)]" />
+    </TooltipContent>
+  </TooltipPortal>
+</template>
diff --git a/apps/desktop/src/components/ui/tooltip/TooltipProvider.vue b/apps/desktop/src/components/ui/tooltip/TooltipProvider.vue
new file mode 100644
index 0000000..7eb50dd
--- /dev/null
+++ b/apps/desktop/src/components/ui/tooltip/TooltipProvider.vue
@@ -0,0 +1,14 @@
+<script setup lang="ts">
+import type { TooltipProviderProps } from "reka-ui";
+import { TooltipProvider } from "reka-ui";
+
+const props = withDefaults(defineProps<TooltipProviderProps>(), {
+  delayDuration: 0,
+});
+</script>
+
+<template>
+  <TooltipProvider v-bind="props">
+    <slot />
+  </TooltipProvider>
+</template>
diff --git a/apps/desktop/src/components/ui/tooltip/TooltipTrigger.vue b/apps/desktop/src/components/ui/tooltip/TooltipTrigger.vue
new file mode 100644
index 0000000..e624a66
--- /dev/null
+++ b/apps/desktop/src/components/ui/tooltip/TooltipTrigger.vue
@@ -0,0 +1,12 @@
+<script setup lang="ts">
+import type { TooltipTriggerProps } from "reka-ui";
+import { TooltipTrigger } from "reka-ui";
+
+const props = defineProps<TooltipTriggerProps>();
+</script>
+
+<template>
+  <TooltipTrigger data-slot="tooltip-trigger" v-bind="props">
+    <slot />
+  </TooltipTrigger>
+</template>
diff --git a/apps/desktop/src/components/ui/tooltip/index.ts b/apps/desktop/src/components/ui/tooltip/index.ts
new file mode 100644
index 0000000..77ddbf1
--- /dev/null
+++ b/apps/desktop/src/components/ui/tooltip/index.ts
@@ -0,0 +1,5 @@
+export { default as Tooltip } from "./Tooltip.vue";
+export { default as TooltipContent } from "./TooltipContent.vue";
+export { default as TooltipProvider } from "./TooltipProvider.vue";
+export { default as TooltipTrigger } from "./TooltipTrigger.vue";
+export { default as HelpTooltip } from "./HelpTooltip.vue";
diff --git a/apps/desktop/src/components/vector/VectorBrowser.vue b/apps/desktop/src/components/vector/VectorBrowser.vue
new file mode 100644
index 0000000..c4c897b
--- /dev/null
+++ b/apps/desktop/src/components/vector/VectorBrowser.vue
@@ -0,0 +1,375 @@
+<script setup lang="ts">
+import { computed, ref, watch, defineAsyncComponent } from "vue";
+import { Play, RefreshCcw, RotateCcw, Save, Search, Trash2 } from "@lucide/vue";
+import { useI18n } from "vue-i18n";
+import { Button } from "@/components/ui/button";
+import ErrorBanner from "@/components/ui/ErrorBanner.vue";
+import QueryLoadingState from "@/components/common/QueryLoadingState.vue";
+import * as api from "@/lib/backend/api";
+import { uuid } from "@/lib/common/utils";
+import type { DatabaseType, QueryResult } from "@/types/database";
+
+const DataGrid = defineAsyncComponent(() => import("@/components/grid/DataGrid.vue"));
+const { t } = useI18n();
+
+type VectorOperationMode = "browse" | "upsert" | "delete" | "search";
+
+const props = defineProps<{
+  connectionId: string;
+  database: string;
+  collection: string;
+  collectionLabel?: string;
+  databaseType?: DatabaseType;
+  dimension?: number;
+}>();
+
+const loading = ref(false);
+const cancelling = ref(false);
+const executionId = ref("");
+const elapsedSeconds = ref("0.0");
+const error = ref("");
+const statusMessage = ref("");
+const result = ref<QueryResult>(emptyResult());
+const operationMode = ref<VectorOperationMode>("browse");
+const requestText = ref(defaultRequestText(props.databaseType, props.database, props.collection, operationMode.value));
+const searchVector = ref("");
+const searchTopK = ref(10);
+let loadingTimer: ReturnType<typeof setInterval> | undefined;
+
+const dim = computed(() => props.dimension || 4);
+function sampleVector(): number[] {
+  return Array.from({ length: dim.value }, (_, i) => parseFloat(((i + 1) / 10).toFixed(1)));
+}
+const productLabel = computed(() => {
+  switch (props.databaseType) {
+    case "milvus":
+      return "Milvus";
+    case "weaviate":
+      return "Weaviate";
+    case "chromadb":
+      return "ChromaDB";
+    default:
+      return "Qdrant";
+  }
+});
+const collectionLabel = computed(() => props.collectionLabel || props.collection || t("vector.collectionFallback"));
+const executeLabel = computed(() => {
+  switch (operationMode.value) {
+    case "browse":
+      return t("vector.run");
+    case "search":
+      return t("vector.search");
+    default:
+      return t("vector.apply");
+  }
+});
+const operationIcon = computed(() => {
+  switch (operationMode.value) {
+    case "delete":
+      return Trash2;
+    case "upsert":
+      return Save;
+    case "search":
+      return Search;
+    default:
+      return Play;
+  }
+});
+
+watch(
+  () => [props.databaseType, props.database, props.collection] as const,
+  ([databaseType, database, collection]) => {
+    requestText.value = defaultRequestText(databaseType, database, collection, operationMode.value);
+    result.value = emptyResult();
+    error.value = "";
+    statusMessage.value = "";
+  },
+);
+
+watch(
+  () => [operationMode.value, searchVector.value, searchTopK.value] as const,
+  () => {
+    if (operationMode.value === "search") {
+      requestText.value = defaultRequestText(props.databaseType, props.database, props.collection, operationMode.value);
+    }
+  },
+);
+
+function emptyResult(): QueryResult {
+  return {
+    columns: [],
+    column_types: [],
+    column_sortables: [],
+    rows: [],
+    affected_rows: 0,
+    execution_time_ms: 0,
+  };
+}
+
+function pathSegment(value: string): string {
+  return encodeURIComponent(value || "collection");
+}
+
+function defaultRequestText(databaseType: DatabaseType | undefined, database: string, collection: string, mode: VectorOperationMode): string {
+  if (databaseType === "milvus") {
+    const body =
+      mode === "delete"
+        ? {
+            dbName: database || "default",
+            collectionName: collection,
+            filter: "id in [1]",
+          }
+        : mode === "upsert"
+          ? {
+              dbName: database || "default",
+              collectionName: collection,
+              data: [
+                {
+                  id: 1,
+                  vector: sampleVector(),
+                  title: "updated vector",
+                  kind: "demo",
+                },
+              ],
+            }
+          : mode === "search"
+            ? {
+                dbName: database || "default",
+                collectionName: collection,
+                data: [tryParseVector(searchVector.value)],
+                limit: searchTopK.value,
+                outputFields: ["*"],
+              }
+            : {
+                dbName: database || "default",
+                collectionName: collection,
+                filter: "",
+                limit: 100,
+                outputFields: ["*"],
+              };
+    const endpoint = mode === "delete" ? "delete" : mode === "upsert" ? "upsert" : mode === "search" ? "search" : "query";
+    return `POST /v2/vectordb/entities/${endpoint}\n${JSON.stringify(body, null, 2)}`;
+  }
+  if (databaseType === "weaviate") {
+    const collectionName = collection || "Collection";
+    if (mode === "delete") {
+      return "DELETE /v1/objects/{id}";
+    }
+    if (mode === "upsert") {
+      return `POST /v1/objects\n${JSON.stringify(
+        {
+          class: collectionName,
+          properties: {
+            title: "updated vector",
+            kind: "demo",
+          },
+        },
+        null,
+        2,
+      )}`;
+    }
+    if (mode === "search") {
+      const vec = tryParseVector(searchVector.value);
+      const gql = `{ Get { ${collectionName}(limit: ${searchTopK.value}, nearVector: {vector: [${vec.join(",")}]}) { _additional { distance id } } } }`;
+      return `POST /v1/graphql\n${JSON.stringify({ query: gql }, null, 2)}`;
+    }
+    return `GET /v1/objects?class=${encodeURIComponent(collectionName)}&limit=100`;
+  }
+  if (databaseType === "chromadb") {
+    const collectionId = collection || "collection-id";
+    if (mode === "delete") {
+      return `POST /api/v2/tenants/default_tenant/databases/default_database/collections/${encodeURIComponent(collectionId)}/delete\n${JSON.stringify({ ids: ["id1"] }, null, 2)}`;
+    }
+    if (mode === "upsert") {
+      return `POST /api/v2/tenants/default_tenant/databases/default_database/collections/${encodeURIComponent(collectionId)}/upsert\n${JSON.stringify({ ids: ["id1"], embeddings: [sampleVector()], documents: ["sample document"], metadatas: [{}] }, null, 2)}`;
+    }
+    if (mode === "search") {
+      return `POST /api/v2/tenants/default_tenant/databases/default_database/collections/${encodeURIComponent(collectionId)}/query\n${JSON.stringify({ query_embeddings: [tryParseVector(searchVector.value)], n_results: searchTopK.value, include: ["documents", "metadatas", "distances"] }, null, 2)}`;
+    }
+    return `POST /api/v2/tenants/default_tenant/databases/default_database/collections/${encodeURIComponent(collectionId)}/get\n${JSON.stringify({ limit: 100, include: ["documents", "metadatas"] }, null, 2)}`;
+  }
+  const collectionPath = pathSegment(collection);
+  if (mode === "delete") {
+    return `POST /collections/${collectionPath}/points/delete?wait=true\n${JSON.stringify({ points: [1] }, null, 2)}`;
+  }
+  if (mode === "upsert") {
+    return `PUT /collections/${collectionPath}/points?wait=true\n${JSON.stringify(
+      {
+        points: [
+          {
+            id: 1,
+            vector: sampleVector(),
+            payload: {
+              title: "updated vector",
+              kind: "demo",
+            },
+          },
+        ],
+      },
+      null,
+      2,
+    )}`;
+  }
+  if (mode === "search") {
+    return `POST /collections/${collectionPath}/points/search\n${JSON.stringify({ vector: tryParseVector(searchVector.value), limit: searchTopK.value, with_payload: true, with_vector: false }, null, 2)}`;
+  }
+  return `POST /collections/${collectionPath}/points/scroll\n${JSON.stringify({ limit: 100, with_payload: true, with_vector: false }, null, 2)}`;
+}
+
+function tryParseVector(input: string): number[] {
+  try {
+    const parsed = JSON.parse(input);
+    if (Array.isArray(parsed)) return parsed;
+  } catch {}
+  return sampleVector();
+}
+
+function startTimer() {
+  stopTimer();
+  const startedAt = Date.now();
+  elapsedSeconds.value = "0.0";
+  loadingTimer = setInterval(() => {
+    elapsedSeconds.value = ((Date.now() - startedAt) / 1000).toFixed(1);
+  }, 100);
+}
+
+function stopTimer() {
+  if (loadingTimer) clearInterval(loadingTimer);
+  loadingTimer = undefined;
+}
+
+function firstResult(results: QueryResult[]): QueryResult {
+  return results.find((item) => item.columns.length > 0) ?? results[0] ?? emptyResult();
+}
+
+async function executeRequestText(text: string): Promise<QueryResult> {
+  const results = await api.executeMulti(props.connectionId, props.database || "default", text, undefined, executionId.value);
+  return firstResult(results);
+}
+
+async function refreshResult() {
+  if (loading.value) return;
+  const id = uuid();
+  executionId.value = id;
+  loading.value = true;
+  cancelling.value = false;
+  error.value = "";
+  statusMessage.value = "";
+  startTimer();
+  try {
+    const browseText = defaultRequestText(props.databaseType, props.database, props.collection, "browse");
+    const nextResult = await executeRequestText(browseText);
+    if (executionId.value === id) result.value = nextResult;
+  } catch (e: unknown) {
+    if (executionId.value === id) error.value = e instanceof Error ? e.message : String(e);
+  } finally {
+    if (executionId.value === id) {
+      loading.value = false;
+      stopTimer();
+    }
+  }
+}
+
+async function runRequest() {
+  if (loading.value) return;
+  const id = uuid();
+  executionId.value = id;
+  loading.value = true;
+  cancelling.value = false;
+  error.value = "";
+  statusMessage.value = "";
+  startTimer();
+  try {
+    const nextResult = await executeRequestText(requestText.value);
+    if (executionId.value !== id) return;
+    if (operationMode.value === "browse" || operationMode.value === "search") {
+      result.value = nextResult;
+    } else {
+      const browseText = defaultRequestText(props.databaseType, props.database, props.collection, "browse");
+      result.value = await executeRequestText(browseText);
+      statusMessage.value = t("vector.operationSuccess");
+    }
+  } catch (e: unknown) {
+    if (executionId.value === id) error.value = e instanceof Error ? e.message : String(e);
+  } finally {
+    if (executionId.value === id) {
+      loading.value = false;
+      stopTimer();
+    }
+  }
+}
+
+async function cancelRequest() {
+  if (!executionId.value) return;
+  cancelling.value = true;
+  await api.cancelQuery(executionId.value).catch(() => false);
+}
+
+function resetRequest() {
+  requestText.value = defaultRequestText(props.databaseType, props.database, props.collection, operationMode.value);
+}
+
+function setOperationMode(mode: VectorOperationMode) {
+  if (operationMode.value === mode) return;
+  operationMode.value = mode;
+  resetRequest();
+  error.value = "";
+  statusMessage.value = "";
+}
+</script>
+
+<template>
+  <div class="flex h-full min-h-0 flex-col bg-background">
+    <div class="flex shrink-0 items-center justify-between gap-3 border-b px-3 py-2">
+      <div class="min-w-0">
+        <div class="truncate text-sm font-semibold">{{ collectionLabel }}</div>
+        <div class="truncate text-xs text-muted-foreground">
+          {{ t("vector.productCollection", { product: productLabel }) }}
+          <span v-if="dimension != null" class="ml-1.5 inline-flex items-center rounded border bg-muted/50 px-1.5 py-px text-[11px] font-medium text-foreground/80">{{ dimension }}d</span>
+        </div>
+      </div>
+      <div class="flex shrink-0 items-center gap-1.5">
+        <div class="mr-1 flex h-7 overflow-hidden rounded-md border bg-muted/30 p-0.5">
+          <button type="button" class="h-6 px-2 text-xs transition-colors" :class="operationMode === 'browse' ? 'rounded bg-background font-medium shadow-sm' : 'text-muted-foreground hover:text-foreground'" :disabled="loading" @click="setOperationMode('browse')">{{ t("vector.browse") }}</button>
+          <button type="button" class="h-6 px-2 text-xs transition-colors" :class="operationMode === 'search' ? 'rounded bg-background font-medium shadow-sm' : 'text-muted-foreground hover:text-foreground'" :disabled="loading" @click="setOperationMode('search')">{{ t("vector.search") }}</button>
+          <button type="button" class="h-6 px-2 text-xs transition-colors" :class="operationMode === 'upsert' ? 'rounded bg-background font-medium shadow-sm' : 'text-muted-foreground hover:text-foreground'" :disabled="loading" @click="setOperationMode('upsert')">{{ t("vector.upsert") }}</button>
+          <button type="button" class="h-6 px-2 text-xs transition-colors" :class="operationMode === 'delete' ? 'rounded bg-background font-medium shadow-sm' : 'text-muted-foreground hover:text-foreground'" :disabled="loading" @click="setOperationMode('delete')">{{ t("vector.delete") }}</button>
+        </div>
+        <Button variant="outline" size="sm" class="h-7 gap-1.5 px-2" :disabled="loading" @click="resetRequest">
+          <RotateCcw class="h-3.5 w-3.5" />
+          {{ t("vector.reset") }}
+        </Button>
+        <Button variant="outline" size="sm" class="h-7 gap-1.5 px-2" :disabled="loading" @click="refreshResult">
+          <RefreshCcw class="h-3.5 w-3.5" />
+          {{ t("vector.refresh") }}
+        </Button>
+        <Button size="sm" class="h-7 gap-1.5 px-2" :disabled="loading || !requestText.trim()" @click="runRequest">
+          <component :is="operationIcon" class="h-3.5 w-3.5" />
+          {{ executeLabel }}
+        </Button>
+      </div>
+    </div>
+
+    <div v-if="operationMode === 'search'" class="flex shrink-0 flex-wrap items-center gap-3 border-b px-3 py-2">
+      <div class="flex items-center gap-1.5 text-xs text-muted-foreground">
+        <span>{{ t("vector.vectorLabel") }}</span>
+        <input v-model="searchVector" class="h-7 w-80 rounded border bg-muted/30 px-2 font-mono text-xs outline-none focus:border-primary" placeholder="[0.1, 0.2, ...]" spellcheck="false" />
+      </div>
+      <div class="flex items-center gap-1.5 text-xs text-muted-foreground">
+        <span>topK</span>
+        <input v-model.number="searchTopK" type="number" min="1" max="1000" class="h-7 w-16 rounded border bg-muted/30 px-2 text-xs outline-none focus:border-primary" />
+      </div>
+    </div>
+    <div class="grid min-h-0 flex-1 grid-rows-[minmax(9rem,15rem)_1fr]">
+      <div class="min-h-0 border-b">
+        <textarea v-model="requestText" class="dbx-editor-font-family h-full w-full resize-none bg-background px-3 py-2 text-xs leading-5 outline-none" :aria-label="t('vector.requestEditor')" spellcheck="false" autocomplete="off" autocapitalize="off" autocorrect="off" />
+      </div>
+      <div class="min-h-0">
+        <ErrorBanner v-if="error" :message="error" copy-mode="label" dismissible @dismiss="error = ''" />
+        <div v-else-if="statusMessage" class="border-b bg-emerald-50 px-3 py-1.5 text-xs text-emerald-700 dark:bg-emerald-950/30 dark:text-emerald-300">{{ statusMessage }}</div>
+        <QueryLoadingState v-if="loading && result.columns.length === 0" class="h-full" label-key="editor.fetching" :elapsed-seconds="elapsedSeconds" show-cancel :cancel-disabled="!executionId || cancelling" :cancelling="cancelling" @cancel="cancelRequest" />
+        <DataGrid v-else class="h-full" :result="result" context="results" :sql="requestText" :loading="loading" @reload="refreshResult" />
+      </div>
+    </div>
+  </div>
+</template>
diff --git a/apps/desktop/src/components/zookeeper/ZooKeeperKeyBrowser.vue b/apps/desktop/src/components/zookeeper/ZooKeeperKeyBrowser.vue
new file mode 100644
index 0000000..3dae253
--- /dev/null
+++ b/apps/desktop/src/components/zookeeper/ZooKeeperKeyBrowser.vue
@@ -0,0 +1,71 @@
+<script setup lang="ts">
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import KvKeyBrowser from "@/components/kv/KvKeyBrowser.vue";
+import * as api from "@/lib/backend/api";
+import type { KvCreateMode } from "@/lib/backend/api";
+
+const props = defineProps<{ connectionId: string }>();
+
+const { t } = useI18n();
+const browserRef = ref<InstanceType<typeof KvKeyBrowser> | null>(null);
+
+const zookeeperApi = {
+  listPrefix: api.zookeeperListPrefix,
+  get: api.zookeeperGet,
+  put: api.zookeeperPut,
+  deleteKey: api.zookeeperDelete,
+};
+
+const createModeOptions = computed<{ value: KvCreateMode; label: string }[]>(() => [
+  { value: "persistent", label: t("zookeeper.createModePersistent") },
+  { value: "ephemeral", label: t("zookeeper.createModeEphemeral") },
+  { value: "persistent_sequential", label: t("zookeeper.createModePersistentSequential") },
+  { value: "ephemeral_sequential", label: t("zookeeper.createModeEphemeralSequential") },
+]);
+
+const labels = computed(() => ({
+  prefixPlaceholder: t("zookeeper.prefixPlaceholder"),
+  newKey: t("zookeeper.newKey"),
+  loadingKeys: t("zookeeper.loadingKeys"),
+  empty: t("zookeeper.empty"),
+  loadMore: t("zookeeper.loadMore"),
+  selectKey: t("zookeeper.selectKey"),
+  loadingValue: t("zookeeper.loadingValue"),
+  notFound: t("zookeeper.notFound"),
+  edit: t("zookeeper.edit"),
+  editKey: t("zookeeper.editKey"),
+  delete: t("zookeeper.delete"),
+  deleteTitle: t("zookeeper.deleteTitle"),
+  keyPlaceholder: t("zookeeper.keyPlaceholder"),
+  keyRequired: t("zookeeper.keyRequired"),
+  rootReadonly: t("zookeeper.rootReadonly"),
+  saved: t("zookeeper.saved"),
+  deleted: t("zookeeper.deleted"),
+  base64Readonly: t("zookeeper.base64Readonly"),
+  createMode: t("zookeeper.createMode"),
+  add: t("zookeeper.add"),
+  value: t("zookeeper.value"),
+  metadata: t("zookeeper.metadata"),
+  prettyJson: t("zookeeper.prettyJson"),
+  invalidJson: t("zookeeper.invalidJson"),
+  summaryRevision: t("zookeeper.summaryRevision"),
+  summaryVersion: t("zookeeper.summaryVersion"),
+  summaryLease: t("zookeeper.summaryLease"),
+  summarySize: t("zookeeper.summarySize"),
+}));
+
+function focusSearch(): boolean {
+  return browserRef.value?.focusSearch() ?? false;
+}
+
+function refresh(): boolean {
+  return browserRef.value?.refresh() ?? false;
+}
+
+defineExpose({ focusSearch, refresh });
+</script>
+
+<template>
+  <KvKeyBrowser ref="browserRef" :connection-id="props.connectionId" :api="zookeeperApi" :labels="labels" supports-create-modes enable-node-actions metadata-style="zookeeper" lazy-hierarchy :create-mode-options="createModeOptions" />
+</template>
diff --git a/apps/desktop/src/composables/__tests__/useCellDetailEditor.spec.ts b/apps/desktop/src/composables/__tests__/useCellDetailEditor.spec.ts
new file mode 100644
index 0000000..b0b1329
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useCellDetailEditor.spec.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it, vi } from "vitest";
+import { EditorState } from "@codemirror/state";
+import { selectAllCellDetailText } from "@/lib/dataGrid/cellDetailSelection";
+
+describe("selectAllCellDetailText", () => {
+  it("selects the entire cell detail document", () => {
+    const state = EditorState.create({ doc: '{"name":"收入合同"}' });
+    const dispatch = vi.fn();
+
+    expect(selectAllCellDetailText({ state, dispatch } as any)).toBe(true);
+    expect(dispatch).toHaveBeenCalledWith({ selection: { anchor: 0, head: state.doc.length } });
+  });
+
+  it("handles empty cell values", () => {
+    const state = EditorState.create({ doc: "" });
+    const dispatch = vi.fn();
+
+    selectAllCellDetailText({ state, dispatch } as any);
+    expect(dispatch).toHaveBeenCalledWith({ selection: { anchor: 0, head: 0 } });
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/useDataGridActions.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridActions.spec.ts
new file mode 100644
index 0000000..f5743c0
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useDataGridActions.spec.ts
@@ -0,0 +1,88 @@
+import { computed } from "vue";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { useDataGridActions } from "@/composables/useDataGridActions";
+import type { QueryTab } from "@/types/database";
+
+const mocks = vi.hoisted(() => ({
+  buildSortedQuerySql: vi.fn(),
+  executeTabSql: vi.fn(),
+  getConfig: vi.fn(),
+}));
+
+vi.mock("vue-i18n", () => ({
+  useI18n: () => ({ t: (key: string) => key }),
+}));
+
+vi.mock("@/lib/backend/api", () => ({
+  buildSortedQuerySql: mocks.buildSortedQuerySql,
+}));
+
+vi.mock("@/stores/connectionStore", () => ({
+  useConnectionStore: () => ({
+    getConfig: mocks.getConfig,
+  }),
+}));
+
+vi.mock("@/stores/queryStore", () => ({
+  useQueryStore: () => ({
+    executeTabSql: mocks.executeTabSql,
+  }),
+}));
+
+vi.mock("@/stores/settingsStore", () => ({
+  useSettingsStore: () => ({
+    editorSettings: { pageSize: 100 },
+  }),
+}));
+
+vi.mock("@/composables/useToast", () => ({
+  useToast: () => ({ toast: vi.fn() }),
+}));
+
+describe("useDataGridActions", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.getConfig.mockReturnValue({ id: "postgres-1", db_type: "postgres" });
+    mocks.buildSortedQuerySql.mockResolvedValue({ ok: true, sql: "SELECT sorted" });
+  });
+
+  it("excludes hidden primary keys and remaps the selected column for database sorting", async () => {
+    const tab = {
+      id: "tab-1",
+      connectionId: "postgres-1",
+      database: "app",
+      title: "Query",
+      sql: "SELECT name, email FROM users",
+      resultBaseSql: "SELECT name, email FROM users",
+      result: {
+        columns: ["name", "__DBX_PK_0", "email"],
+        hidden_column_indexes: [1],
+        rows: [["Alice", 7, "alice@example.com"]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+      mode: "query",
+      isDirty: false,
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+    } as QueryTab;
+    const actions = useDataGridActions(computed(() => tab));
+
+    await actions.onSort("email", 2, "asc");
+
+    expect(mocks.executeTabSql).toHaveBeenCalledWith(
+      "tab-1",
+      "SELECT name, email FROM users",
+      expect.objectContaining({
+        resultBaseSql: "SELECT name, email FROM users",
+        querySort: {
+          resultColumns: ["name", "email"],
+          columnIndex: 1,
+          column: "email",
+          direction: "asc",
+        },
+      }),
+    );
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts
new file mode 100644
index 0000000..c03b60b
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useDataGridColumnResize.spec.ts
@@ -0,0 +1,94 @@
+import { computed, nextTick, ref } from "vue";
+import { describe, expect, it, vi } from "vitest";
+import { DATA_GRID_COL_AUTO_FIT_MAX_WIDTH, DATA_GRID_COL_MAX_WIDTH, DATA_GRID_COL_MIN_WIDTH } from "@/lib/dataGrid/dataGridColumnWidth";
+import { DATA_GRID_ROW_NUM_WIDTH, resizeDataGridColumnWidth, useDataGridColumnResize } from "@/composables/useDataGridColumnResize";
+
+function createResizeState(options: { columns: string[]; rows: Array<Array<string | number | boolean | null>>; columnIndexes?: number[]; density?: "compact" | "standard" | "comfortable"; compactColumnHeaderActions?: boolean }) {
+  const compact = ref(options.compactColumnHeaderActions ?? true);
+  const state = useDataGridColumnResize({
+    columns: computed(() => options.columns),
+    sourceRows: computed(() => options.rows),
+    columnIndexes: computed(() => options.columnIndexes ?? options.columns.map((_, index) => index)),
+    density: ref(options.density ?? "standard"),
+    compactColumnHeaderActions: computed(() => compact.value),
+  });
+  return {
+    ...state,
+    setCompact(v: boolean) {
+      compact.value = v;
+    },
+  };
+}
+
+describe("useDataGridColumnResize", () => {
+  it("keeps compact query result columns at content width instead of filling the viewport", () => {
+    const state = createResizeState({
+      columns: ["id", "user_id"],
+      rows: [
+        [1, 10],
+        [2, 20],
+      ],
+    });
+
+    state.initColumnWidths();
+
+    expect(state.renderedColumnWidths.value).toEqual(state.columnWidths.value);
+    expect(state.totalWidth.value).toBe(DATA_GRID_ROW_NUM_WIDTH + state.columnWidths.value.reduce((total, width) => total + width, 0));
+    expect(Math.max(...state.renderedColumnWidths.value)).toBeLessThan(200);
+  });
+
+  it("keeps default widths bounded but lets auto-fit use the wider cap", () => {
+    const state = createResizeState({
+      columns: ["description"],
+      rows: [["x".repeat(120)]],
+    });
+
+    state.initColumnWidths();
+    expect(state.columnWidths.value[0]).toBe(DATA_GRID_COL_MAX_WIDTH);
+
+    state.autoFitColumn(0);
+
+    expect(state.columnWidths.value[0]).toBeGreaterThan(DATA_GRID_COL_MAX_WIDTH);
+    expect(state.columnWidths.value[0]).toBeLessThanOrEqual(DATA_GRID_COL_AUTO_FIT_MAX_WIDTH);
+  });
+
+  it("clamps manual column resizing to the minimum width", () => {
+    expect(resizeDataGridColumnWidth(120, -200)).toBe(DATA_GRID_COL_MIN_WIDTH);
+    expect(resizeDataGridColumnWidth(120, 30)).toBe(150);
+  });
+
+  it("publishes a fresh rendered width array when a column is resized", () => {
+    const state = createResizeState({
+      columns: ["id", "name"],
+      rows: [[1, "Alice"]],
+    });
+
+    state.initColumnWidths();
+    const before = state.renderedColumnWidths.value;
+
+    state.columnWidths.value[1] = before[1] + 40;
+
+    expect(state.renderedColumnWidths.value).not.toBe(before);
+    expect(state.renderedColumnWidths.value[1]).toBe(before[1] + 40);
+  });
+
+  it("recalculates column widths when compactColumnHeaderActions changes", async () => {
+    const state = createResizeState({
+      columns: ["some_column_name_here"],
+      rows: [["a"]],
+      density: "compact",
+      compactColumnHeaderActions: true,
+    });
+
+    state.initColumnWidths();
+    const widthCompact = state.renderedColumnWidths.value[0];
+
+    state.setCompact(false);
+    await nextTick();
+
+    const widthNonCompact = state.renderedColumnWidths.value[0];
+    // compact: charWidth*nameLen + headerControlWidthCompact(20) = 7*21+20=167
+    // non-compact: 7*21+headerControlWidth(36)=183
+    expect(widthNonCompact).toBeGreaterThan(widthCompact);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/useDataGridExport.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridExport.spec.ts
new file mode 100644
index 0000000..2dfe3fd
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useDataGridExport.spec.ts
@@ -0,0 +1,169 @@
+import { computed, ref } from "vue";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { useDataGridExport, type UseDataGridExportOptions } from "@/composables/useDataGridExport";
+import { buildDataGridCopyInsertStatement, buildDataGridCopyUpdateStatements } from "@/lib/dataGrid/dataGridSql";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import type { DataGridTableMeta } from "@/lib/dataGrid/dataGridSql";
+
+const toast = vi.fn();
+
+vi.mock("vue-i18n", () => ({
+  useI18n: () => ({ t: (key: string, params?: { message?: string }) => (params?.message ? `${key}: ${params.message}` : key) }),
+}));
+
+vi.mock("@/composables/useToast", () => ({
+  useToast: () => ({ toast }),
+}));
+
+vi.mock("@/lib/common/clipboard", () => ({
+  copyToClipboard: vi.fn(),
+}));
+
+vi.mock("@/lib/dataGrid/dataGridSql", async (importOriginal) => {
+  const original = await importOriginal<typeof import("@/lib/dataGrid/dataGridSql")>();
+  return {
+    ...original,
+    buildDataGridCopyInsertStatement: vi.fn(),
+    buildDataGridCopyUpdateStatements: vi.fn(),
+  };
+});
+
+interface Deferred<T> {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (error: unknown) => void;
+}
+
+function deferred<T>(): Deferred<T> {
+  let resolve!: (value: T) => void;
+  let reject!: (error: unknown) => void;
+  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
+function row(data: unknown[]) {
+  return {
+    id: 1,
+    data,
+    isNew: false,
+    isDeleted: false,
+    isDirtyCol: data.map(() => false),
+    status: "",
+  };
+}
+
+function createExportState(tableMeta: DataGridTableMeta, columns = tableMeta.columns?.map((column) => column.name) ?? ["id", "name"]) {
+  const item = row(columns.map((column, index) => (column === "id" ? 1 : `value-${index}`)));
+  const options: UseDataGridExportOptions = {
+    columns: computed(() => columns),
+    displayItems: computed(() => [item]),
+    sql: computed(() => undefined),
+    tableMeta: computed(() => tableMeta),
+    databaseType: computed(() => "mysql"),
+    connectionId: computed(() => "connection-1"),
+    database: computed(() => "dbx"),
+    context: computed(() => "table-data"),
+    sourceColumns: computed(() => columns),
+    columnTypes: computed(() => columns.map(() => "varchar")),
+    whereInput: computed(() => undefined),
+    orderBy: computed(() => undefined),
+    exportBatchSize: computed(() => 1000),
+    hasCellSelection: computed(() => false),
+    selectedCells: computed(() => ({ columns: [], rows: [] })),
+    selectedRange: computed(() => null),
+    contextCell: ref({ rowId: item.id, rowIndex: 0, col: -1 }),
+    getRowItem: (rowId) => (rowId === item.id ? item : undefined),
+    selectedRowIds: ref(new Set<number>()),
+    hasRowSelection: computed(() => false),
+  };
+  return useDataGridExport(options);
+}
+
+const editableTable: DataGridTableMeta = {
+  tableName: "users",
+  primaryKeys: ["id"],
+  columns: [
+    { name: "id", data_type: "int", is_nullable: false, is_primary_key: true },
+    { name: "name", data_type: "varchar", is_nullable: false },
+  ],
+};
+
+describe("useDataGridExport prepared row statements", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("reuses an in-flight INSERT prefetch when the copy action runs", async () => {
+    const pending = deferred<string | undefined>();
+    vi.mocked(buildDataGridCopyInsertStatement).mockReturnValueOnce(pending.promise);
+    const state = createExportState(editableTable);
+
+    const prefetch = state.prefetchRowAsInsertStatement(false);
+    const copy = state.copyRowAsInsert();
+    await vi.waitFor(() => expect(buildDataGridCopyInsertStatement).toHaveBeenCalledTimes(1));
+    pending.resolve("INSERT INTO users VALUES (1, 'Alice');");
+
+    await Promise.all([prefetch, copy]);
+    expect(copyToClipboard).toHaveBeenCalledWith("INSERT INTO users VALUES (1, 'Alice');");
+  });
+
+  it("reuses an in-flight UPDATE prefetch on the first copy action", async () => {
+    const pending = deferred<string[]>();
+    vi.mocked(buildDataGridCopyUpdateStatements).mockReturnValueOnce(pending.promise);
+    const state = createExportState(editableTable);
+
+    const prefetch = state.prefetchRowAsUpdateStatement();
+    const copy = state.copyRowAsUpdate();
+    await vi.waitFor(() => expect(buildDataGridCopyUpdateStatements).toHaveBeenCalledTimes(1));
+    pending.resolve(["UPDATE users SET name = 'Alice' WHERE id = 1;"]);
+
+    await Promise.all([prefetch, copy]);
+    expect(copyToClipboard).toHaveBeenCalledWith("UPDATE users SET name = 'Alice' WHERE id = 1;");
+  });
+
+  it.each(["GENERATED ALWAYS AS (1)", "IDENTITY(1, 1)"])("disables copy-as-insert when every result column is non-insertable (%s)", (extra) => {
+    const state = createExportState(
+      {
+        tableName: "generated_values",
+        primaryKeys: [],
+        columns: [{ name: "computed_value", data_type: "int", is_nullable: true, extra }],
+      },
+      ["computed_value"],
+    );
+
+    expect(state.canCopyRowAsInsert.value).toBe(false);
+  });
+
+  it("reports a shared builder failure when the user invokes copy", async () => {
+    const pending = deferred<string | undefined>();
+    vi.mocked(buildDataGridCopyInsertStatement).mockReturnValueOnce(pending.promise);
+    const state = createExportState(editableTable);
+
+    const prefetch = state.prefetchRowAsInsertStatement(false);
+    const copy = state.copyRowAsInsert();
+    await vi.waitFor(() => expect(buildDataGridCopyInsertStatement).toHaveBeenCalledTimes(1));
+    pending.reject(new Error("builder unavailable"));
+
+    await Promise.all([prefetch, copy]);
+    expect(toast).toHaveBeenCalledWith("grid.copyFailed: builder unavailable", 5000);
+    expect(copyToClipboard).not.toHaveBeenCalled();
+  });
+
+  it("reports an UPDATE builder failure from the first copy action", async () => {
+    const pending = deferred<string[]>();
+    vi.mocked(buildDataGridCopyUpdateStatements).mockReturnValueOnce(pending.promise);
+    const state = createExportState(editableTable);
+
+    const prefetch = state.prefetchRowAsUpdateStatement();
+    const copy = state.copyRowAsUpdate();
+    await vi.waitFor(() => expect(buildDataGridCopyUpdateStatements).toHaveBeenCalledTimes(1));
+    pending.reject(new Error("update builder unavailable"));
+
+    await Promise.all([prefetch, copy]);
+    expect(toast).toHaveBeenCalledWith("grid.copyFailed: update builder unavailable", 5000);
+    expect(copyToClipboard).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/useDataGridSelection.spec.ts b/apps/desktop/src/composables/__tests__/useDataGridSelection.spec.ts
new file mode 100644
index 0000000..812bcd7
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useDataGridSelection.spec.ts
@@ -0,0 +1,119 @@
+import { computed, ref } from "vue";
+import { describe, expect, it } from "vitest";
+import { useDataGridSelection } from "@/composables/useDataGridSelection";
+
+function createSelection(options?: { getScrollElement?: () => HTMLElement | null; cellFromClientPoint?: (clientX: number, clientY: number) => { rowIndex: number; colIndex: number } | null }) {
+  const columns = computed(() => ["id", "name", "email"]);
+  const displayItems = computed(() =>
+    [1, 2, 3, 4].map((id, index) => ({
+      id,
+      sourceIndex: index,
+      data: [id, `name-${id}`, `user-${id}@example.com`],
+      isNew: false,
+      isDraft: false,
+      isDeleted: false,
+      isDirtyCol: [false, false, false],
+      status: "clean",
+    })),
+  );
+
+  return useDataGridSelection({
+    columns,
+    displayItems,
+    editingCell: ref(null),
+    showTranspose: ref(false),
+    transposeRowIndex: ref(null),
+    gridRef: ref(undefined),
+    getScrollElement: options?.getScrollElement,
+    cellFromClientPoint: options?.cellFromClientPoint,
+  });
+}
+
+function rowEvent(options: { meta?: boolean; shift?: boolean } = {}): MouseEvent {
+  return {
+    metaKey: !!options.meta,
+    ctrlKey: !!options.meta,
+    shiftKey: !!options.shift,
+  } as MouseEvent;
+}
+
+describe("useDataGridSelection", () => {
+  it("creates a whole-row cell range for contiguous meta row selections", () => {
+    const selection = createSelection();
+
+    selection.handleRowClick(1, 2, rowEvent({ meta: true }));
+    selection.handleRowClick(2, 3, rowEvent({ meta: true }));
+    selection.handleRowClick(3, 4, rowEvent({ meta: true }));
+
+    expect(selection.selectedRowIds.value).toEqual(new Set([2, 3, 4]));
+    expect(selection.selectedRange.value).toEqual({
+      startRow: 1,
+      endRow: 3,
+      startCol: 0,
+      endCol: 2,
+    });
+    expect(selection.hasCellSelection.value).toBe(true);
+  });
+
+  it("does not create a rectangular cell range for non-contiguous meta row selections", () => {
+    const selection = createSelection();
+
+    selection.handleRowClick(0, 1, rowEvent({ meta: true }));
+    selection.handleRowClick(2, 3, rowEvent({ meta: true }));
+
+    expect(selection.selectedRowIds.value).toEqual(new Set([1, 3]));
+    expect(selection.selectedRange.value).toBeNull();
+    expect(selection.hasCellSelection.value).toBe(false);
+  });
+
+  it("scrolls and extends the selection while dragging near an edge", () => {
+    const animationFrames: FrameRequestCallback[] = [];
+    const originalRequestAnimationFrame = globalThis.requestAnimationFrame;
+    const originalCancelAnimationFrame = globalThis.cancelAnimationFrame;
+    const originalDocument = globalThis.document;
+    const listeners = new Map<string, Set<EventListenerOrEventListenerObject>>();
+    const fakeDocument = {
+      addEventListener(type: string, listener: EventListenerOrEventListenerObject) {
+        const handlers = listeners.get(type) ?? new Set();
+        handlers.add(listener);
+        listeners.set(type, handlers);
+      },
+      removeEventListener(type: string, listener: EventListenerOrEventListenerObject) {
+        listeners.get(type)?.delete(listener);
+      },
+    } as Document;
+    Object.defineProperty(globalThis, "document", { configurable: true, value: fakeDocument });
+    globalThis.requestAnimationFrame = ((callback: FrameRequestCallback) => {
+      animationFrames.push(callback);
+      return animationFrames.length;
+    }) as typeof requestAnimationFrame;
+    globalThis.cancelAnimationFrame = (() => undefined) as typeof cancelAnimationFrame;
+
+    const scroller = { scrollLeft: 0, scrollTop: 0 } as HTMLElement;
+    scroller.getBoundingClientRect = () => ({ left: 0, top: 0, right: 300, bottom: 200, width: 300, height: 200, x: 0, y: 0, toJSON: () => ({}) });
+    const selection = createSelection({
+      getScrollElement: () => scroller,
+      cellFromClientPoint: () => ({ rowIndex: scroller.scrollTop > 0 ? 3 : 0, colIndex: 2 }),
+    });
+    const event = { button: 0, clientX: 100, clientY: 100, preventDefault() {} } as MouseEvent;
+
+    try {
+      selection.beginCellSelection(0, 0, event);
+      const moveEvent = { clientX: 295, clientY: 195 } as MouseEvent;
+      listeners.get("mousemove")?.forEach((listener) => {
+        if (typeof listener === "function") listener(moveEvent);
+        else listener.handleEvent(moveEvent);
+      });
+      animationFrames.shift()?.(0);
+
+      expect(scroller.scrollLeft).toBeGreaterThan(0);
+      expect(scroller.scrollTop).toBeGreaterThan(0);
+      expect(selection.selectedRange.value).toEqual({ startRow: 0, endRow: 3, startCol: 0, endCol: 2 });
+    } finally {
+      selection.finishCellSelection();
+      globalThis.requestAnimationFrame = originalRequestAnimationFrame;
+      globalThis.cancelAnimationFrame = originalCancelAnimationFrame;
+      Object.defineProperty(globalThis, "document", { configurable: true, value: originalDocument });
+    }
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/useQuickOpen.spec.ts b/apps/desktop/src/composables/__tests__/useQuickOpen.spec.ts
new file mode 100644
index 0000000..a889944
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useQuickOpen.spec.ts
@@ -0,0 +1,581 @@
+import { describe, expect, it, vi } from "vitest";
+import { useQuickOpen } from "@/composables/useQuickOpen";
+import { useConnectionStore } from "@/stores/connectionStore";
+
+vi.mock("@/stores/connectionStore", () => ({
+  useConnectionStore: vi.fn(),
+}));
+
+describe("useQuickOpen", () => {
+  describe("fuzzyMatch function", () => {
+    it("should return exact substring match with score 1", () => {
+      // Mock store with test data
+      const mockStore = {
+        connections: [{ id: "conn1", name: "MyConnection", type: "mssql" }],
+        treeNodes: [
+          {
+            connectionId: "conn1",
+            type: "database",
+            database: "MyDatabase",
+            label: "MyDatabase",
+          },
+        ],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("MyDatabase");
+
+      // After search, we should find the exact match
+      expect(filteredItems.value.length).toBeGreaterThan(0);
+      const result = filteredItems.value.find((item) => item.label === "MyDatabase");
+      expect(result).toBeDefined();
+      if (result) {
+        expect(result.matchScore).toBe(1); // Exact substring match score
+      }
+    });
+
+    it("should handle empty query by returning all items", () => {
+      const mockStore = {
+        connections: [
+          { id: "conn1", name: "Connection1", type: "mssql" },
+          { id: "conn2", name: "Connection2", type: "postgres" },
+        ],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("");
+
+      // Empty query should return all items
+      expect(filteredItems.value.length).toBe(2);
+      filteredItems.value.forEach((item) => {
+        expect(item.matchScore).toBe(Infinity);
+      });
+    });
+
+    it("should perform fuzzy matching for non-consecutive characters", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "MyConnection", type: "mssql" }],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("MyCo");
+
+      // Fuzzy match should find "MyConnection"
+      const result = filteredItems.value.find((item) => item.label === "MyConnection");
+      expect(result).toBeDefined();
+    });
+
+    it("should return null for non-matching query", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "MyConnection", type: "mssql" }],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("XYZ");
+
+      // No match should return empty results
+      expect(filteredItems.value.length).toBe(0);
+    });
+
+    it("should score consecutive characters higher than non-consecutive", () => {
+      const mockStore = {
+        connections: [
+          { id: "conn1", name: "user_login_table", type: "mssql" },
+          { id: "conn2", name: "user_data_login", type: "mssql" },
+        ],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("login");
+
+      // "user_login_table" has consecutive "login" match (better score)
+      // "user_data_login" has consecutive "login" match too
+      expect(filteredItems.value.length).toBe(2);
+      // Both should have score 1.0 (consecutive match: login appears consecutively)
+    });
+  });
+
+  describe("filtering and searching", () => {
+    it("indexes database objects under connection groups", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "Grouped PG", db_type: "postgres" }],
+        treeNodes: [
+          {
+            id: "group1",
+            type: "connection-group",
+            label: "Production",
+            children: [
+              {
+                id: "conn1",
+                connectionId: "conn1",
+                type: "connection",
+                label: "Grouped PG",
+                children: [
+                  {
+                    id: "conn1:postgres",
+                    connectionId: "conn1",
+                    type: "database",
+                    database: "postgres",
+                    label: "postgres",
+                    children: [
+                      {
+                        id: "conn1:postgres:public",
+                        connectionId: "conn1",
+                        type: "schema",
+                        database: "postgres",
+                        schema: "public",
+                        label: "public",
+                        children: [
+                          {
+                            id: "conn1:postgres:public:users",
+                            connectionId: "conn1",
+                            type: "table",
+                            database: "postgres",
+                            schema: "public",
+                            label: "users",
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("users");
+      expect(filteredItems.value.map((item) => item.label)).toContain("users");
+    });
+
+    it("includes schemas as quick open results", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "PG", db_type: "postgres" }],
+        treeNodes: [
+          {
+            id: "conn1",
+            connectionId: "conn1",
+            type: "connection",
+            label: "PG",
+            children: [
+              {
+                id: "conn1:postgres",
+                connectionId: "conn1",
+                type: "database",
+                database: "postgres",
+                label: "postgres",
+                children: [
+                  {
+                    id: "conn1:postgres:analytics",
+                    connectionId: "conn1",
+                    type: "schema",
+                    database: "postgres",
+                    schema: "analytics",
+                    label: "analytics",
+                    children: [],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("analytics");
+      expect(filteredItems.value).toEqual(expect.arrayContaining([expect.objectContaining({ type: "schema", label: "analytics" })]));
+    });
+
+    it("should filter items based on search query", () => {
+      const mockStore = {
+        connections: [
+          { id: "conn1", name: "ProdDB", type: "mssql" },
+          { id: "conn2", name: "DevDB", type: "mssql" },
+        ],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("Prod");
+
+      expect(filteredItems.value.length).toBe(1);
+      expect(filteredItems.value[0].label).toBe("ProdDB");
+    });
+
+    it("should be case-insensitive", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "MyConnection", type: "mssql" }],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("myconnection");
+
+      expect(filteredItems.value.length).toBe(1);
+      expect(filteredItems.value[0].label).toBe("MyConnection");
+    });
+
+    it("should search across connection name and database name", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "ProdConnection", type: "mssql" }],
+        treeNodes: [
+          {
+            connectionId: "conn1",
+            type: "database",
+            database: "UserDB",
+            label: "UserDB",
+          },
+        ],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      // Search by connection name
+      setQuery("Prod");
+      expect(filteredItems.value.length).toBeGreaterThan(0);
+    });
+
+    it("should sort by match score (lower scores first)", () => {
+      const mockStore = {
+        connections: [
+          { id: "conn1", name: "Database", type: "mssql" },
+          { id: "conn2", name: "MyDB", type: "mssql" },
+        ],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("db");
+
+      expect(filteredItems.value.length).toBe(2);
+      // First result should have better (lower) score
+      expect(filteredItems.value[0].matchScore).toBeLessThanOrEqual(filteredItems.value[1].matchScore);
+    });
+
+    it("should sort by type for equal match scores", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "test", type: "mssql" }],
+        treeNodes: [
+          {
+            connectionId: "conn1",
+            type: "database",
+            database: "test_db",
+            label: "test_db",
+          },
+        ],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("test");
+
+      // Connections should come before databases for the same query
+      if (filteredItems.value.length >= 2) {
+        const connectionItem = filteredItems.value.find((item) => item.type === "connection");
+        const databaseItem = filteredItems.value.find((item) => item.type === "database");
+
+        if (connectionItem && databaseItem) {
+          expect(filteredItems.value.indexOf(connectionItem)).toBeLessThan(filteredItems.value.indexOf(databaseItem));
+        }
+      }
+    });
+  });
+
+  describe("item selection navigation", () => {
+    it("should initialize with selectedIndex at 0", () => {
+      const mockStore = {
+        connections: [],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { selectedIndex } = useQuickOpen();
+      expect(selectedIndex.value).toBe(0);
+    });
+
+    it("should select next item", () => {
+      const mockStore = {
+        connections: [
+          { id: "conn1", name: "Conn1", type: "mssql" },
+          { id: "conn2", name: "Conn2", type: "mssql" },
+        ],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { selectNext, selectedIndex, setQuery } = useQuickOpen();
+
+      setQuery("");
+
+      expect(selectedIndex.value).toBe(0);
+      selectNext();
+      expect(selectedIndex.value).toBe(1);
+    });
+
+    it("should not exceed max index when selecting next", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "Conn1", type: "mssql" }],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { selectNext, selectedIndex, setQuery } = useQuickOpen();
+
+      setQuery("");
+
+      selectNext();
+      selectNext(); // Attempt to go beyond max
+      expect(selectedIndex.value).toBe(0); // Should stay at 0 (only 1 item)
+    });
+
+    it("should select previous item", () => {
+      const mockStore = {
+        connections: [
+          { id: "conn1", name: "Conn1", type: "mssql" },
+          { id: "conn2", name: "Conn2", type: "mssql" },
+        ],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { selectNext, selectPrevious, selectedIndex, setQuery } = useQuickOpen();
+
+      setQuery("");
+
+      selectNext();
+      expect(selectedIndex.value).toBe(1);
+      selectPrevious();
+      expect(selectedIndex.value).toBe(0);
+    });
+
+    it("should not go below 0 when selecting previous", () => {
+      const mockStore = {
+        connections: [],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { selectPrevious, selectedIndex } = useQuickOpen();
+
+      // Verify initial state
+      expect(selectedIndex.value).toBe(0);
+
+      selectPrevious();
+      expect(selectedIndex.value).toBe(0);
+    });
+
+    it("should return correct selectedItem", () => {
+      const mockStore = {
+        connections: [
+          { id: "conn1", name: "Conn1", type: "mssql" },
+          { id: "conn2", name: "Conn2", type: "mssql" },
+        ],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { selectNext, selectedItem, setQuery } = useQuickOpen();
+
+      setQuery("");
+
+      expect(selectedItem.value?.label).toBe("Conn1");
+      selectNext();
+      expect(selectedItem.value?.label).toBe("Conn2");
+    });
+
+    it("should return null selectedItem when index is out of bounds", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "Conn1", type: "mssql" }],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { selectedItem, selectedIndex } = useQuickOpen();
+
+      // Manually set invalid index
+      selectedIndex.value = 999;
+      expect(selectedItem.value).toBeNull();
+    });
+  });
+
+  describe("reset and query setting", () => {
+    it("should reset selection to 0 when setQuery is called", () => {
+      const mockStore = {
+        connections: [
+          { id: "conn1", name: "Conn1", type: "mssql" },
+          { id: "conn2", name: "Conn2", type: "mssql" },
+        ],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { selectNext, setQuery, selectedIndex } = useQuickOpen();
+
+      selectNext();
+      expect(selectedIndex.value).toBe(1);
+
+      setQuery("test");
+      expect(selectedIndex.value).toBe(0);
+    });
+
+    it("should update searchQuery when setQuery is called", () => {
+      const mockStore = {
+        connections: [],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { searchQuery, setQuery } = useQuickOpen();
+
+      setQuery("NewQuery");
+      expect(searchQuery.value).toBe("NewQuery");
+    });
+
+    it("should resetSelection to 0", () => {
+      const mockStore = {
+        connections: [
+          { id: "conn1", name: "Conn1", type: "mssql" },
+          { id: "conn2", name: "Conn2", type: "mssql" },
+        ],
+        treeNodes: [],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { resetSelection, selectNext, selectedIndex, setQuery } = useQuickOpen();
+
+      setQuery("");
+
+      selectNext();
+      expect(selectedIndex.value).toBe(1);
+
+      resetSelection();
+      expect(selectedIndex.value).toBe(0);
+    });
+  });
+
+  describe("allItems with different database object types", () => {
+    it("should include tables from tree nodes", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "MyConn", type: "mssql" }],
+        treeNodes: [
+          {
+            connectionId: "conn1",
+            type: "table",
+            database: "MyDB",
+            schema: "dbo",
+            label: "Users",
+          },
+        ],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("");
+
+      const tableItem = filteredItems.value.find((item) => item.type === "table");
+      expect(tableItem).toBeDefined();
+      expect(tableItem?.label).toBe("Users");
+    });
+
+    it("should include views from tree nodes", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "MyConn", type: "mssql" }],
+        treeNodes: [
+          {
+            connectionId: "conn1",
+            type: "view",
+            database: "MyDB",
+            schema: "dbo",
+            label: "UserView",
+          },
+        ],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("");
+
+      const viewItem = filteredItems.value.find((item) => item.type === "view");
+      expect(viewItem).toBeDefined();
+      expect(viewItem?.label).toBe("UserView");
+    });
+
+    it("should include procedures from tree nodes", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "MyConn", type: "mssql" }],
+        treeNodes: [
+          {
+            connectionId: "conn1",
+            type: "procedure",
+            database: "MyDB",
+            schema: "dbo",
+            label: "GetUsers",
+          },
+        ],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("");
+
+      const procItem = filteredItems.value.find((item) => item.type === "procedure");
+      expect(procItem).toBeDefined();
+      expect(procItem?.label).toBe("GetUsers");
+    });
+
+    it("should include functions from tree nodes", () => {
+      const mockStore = {
+        connections: [{ id: "conn1", name: "MyConn", type: "mssql" }],
+        treeNodes: [
+          {
+            connectionId: "conn1",
+            type: "function",
+            database: "MyDB",
+            schema: "dbo",
+            label: "ComputeAge",
+          },
+        ],
+      };
+      vi.mocked(useConnectionStore).mockReturnValue(mockStore as any);
+
+      const { filteredItems, setQuery } = useQuickOpen();
+
+      setQuery("");
+
+      const funcItem = filteredItems.value.find((item) => item.type === "function");
+      expect(funcItem).toBeDefined();
+      expect(funcItem?.label).toBe("ComputeAge");
+    });
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/useSchemaOptions.spec.ts b/apps/desktop/src/composables/__tests__/useSchemaOptions.spec.ts
new file mode 100644
index 0000000..59c2b7a
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useSchemaOptions.spec.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { schemaOptionsForConnection } from "@/composables/useSchemaOptions";
+
+describe("schemaOptionsForConnection", () => {
+  it("sorts schema names with numeric suffixes naturally", () => {
+    const schemaNames = ["WMWMSE16", "WMWMSE17", "WMWMSE18", "WMWMSE19", "WMWMSE2", "WMWMSE20", "WMWMSE1", "WMWMSE10"];
+
+    expect(schemaOptionsForConnection(schemaNames, undefined)).toEqual(["WMWMSE1", "WMWMSE2", "WMWMSE10", "WMWMSE16", "WMWMSE17", "WMWMSE18", "WMWMSE19", "WMWMSE20"]);
+    expect(schemaNames).toEqual(["WMWMSE16", "WMWMSE17", "WMWMSE18", "WMWMSE19", "WMWMSE2", "WMWMSE20", "WMWMSE1", "WMWMSE10"]);
+  });
+
+  it("sorts after applying the visible schema filter", () => {
+    const connection = {
+      db_type: "oracle" as const,
+      visible_schemas: {
+        ORCL: ["WMWMSE10", "WMWMSE2"],
+      },
+    };
+
+    expect(schemaOptionsForConnection(["WMWMSE10", "SYSTEM", "WMWMSE2", "WMWMSE1"], connection, "ORCL")).toEqual(["WMWMSE2", "WMWMSE10"]);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts b/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts
new file mode 100644
index 0000000..ae215a8
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts
@@ -0,0 +1,255 @@
+import { computed, ref } from "vue";
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { requiresDatabaseSelection, useSqlExecution } from "../useSqlExecution";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useHistoryStore } from "@/stores/historyStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
+import type { ConnectionConfig, QueryTab } from "@/types/database";
+
+vi.mock("vue-i18n", () => ({
+  createI18n: () => ({ global: { locale: { value: "en" }, setLocaleMessage: vi.fn() } }),
+  useI18n: () => ({ t: (key: string) => key }),
+}));
+
+vi.mock("@/lib/backend/api", () => ({
+  saveEditorSettings: vi.fn(),
+  saveHistory: vi.fn(),
+}));
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+}
+
+function connection(dbType: ConnectionConfig["db_type"]): ConnectionConfig {
+  return {
+    id: "conn-1",
+    name: "Local",
+    db_type: dbType,
+    host: "localhost",
+    port: 3306,
+    username: "root",
+    password: "",
+  };
+}
+
+function queryTab(database = ""): QueryTab {
+  return {
+    id: "tab-1",
+    connectionId: "conn-1",
+    database,
+    schema: undefined,
+    title: "SQL",
+    sql: "",
+    mode: "query",
+    isDirty: false,
+    isExecuting: false,
+    isCancelling: false,
+    isExplaining: false,
+  };
+}
+
+describe("requiresDatabaseSelection", () => {
+  beforeEach(() => {
+    installLocalStorage();
+    setActivePinia(createPinia());
+  });
+
+  it("allows MySQL CREATE DATABASE to run without a selected database", () => {
+    expect(requiresDatabaseSelection(queryTab(), connection("mysql"), "CREATE DATABASE app_db")).toBe(false);
+  });
+
+  it("allows MySQL CREATE SCHEMA with options to run without a selected database", () => {
+    expect(requiresDatabaseSelection(queryTab(), connection("mysql"), "CREATE SCHEMA `app-db` DEFAULT CHARACTER SET utf8mb4")).toBe(false);
+  });
+
+  it("allows MySQL install batches that switch databases before table DDL", () => {
+    expect(requiresDatabaseSelection(queryTab(), connection("mysql"), "CREATE DATABASE app_db; USE app_db; CREATE TABLE users(id INT PRIMARY KEY)")).toBe(false);
+  });
+
+  it("allows MySQL install batches with session setup before switching databases", () => {
+    expect(requiresDatabaseSelection(queryTab(), connection("mysql"), "SET NAMES utf8mb4; DROP DATABASE IF EXISTS app_db; CREATE DATABASE app_db; USE app_db; INSERT INTO users VALUES (1)")).toBe(false);
+  });
+
+  it("requires a database when MySQL batch statements never establish database context", () => {
+    expect(requiresDatabaseSelection(queryTab(), connection("mysql"), "CREATE DATABASE app_db; CREATE TABLE users(id INT)")).toBe(true);
+  });
+
+  it("requires a database when a USE statement is not a standalone database switch", () => {
+    expect(requiresDatabaseSelection(queryTab(), connection("mysql"), "CREATE DATABASE app_db; USE app_db SELECT 1; CREATE TABLE users(id INT)")).toBe(true);
+  });
+
+  it("still requires a database for ordinary MySQL queries", () => {
+    expect(requiresDatabaseSelection(queryTab(), connection("mysql"), "SELECT * FROM users")).toBe(true);
+  });
+
+  it("allows HANA with default database (empty string) to execute queries", () => {
+    expect(requiresDatabaseSelection(queryTab(""), connection("saphana"), "SELECT * FROM MOMX_MES.Z_SHIPMENT_INFORMATION")).toBe(false);
+  });
+
+  it("allows JDBC with default database (empty string) to execute queries", () => {
+    expect(requiresDatabaseSelection(queryTab(""), connection("jdbc"), "SELECT * FROM users")).toBe(false);
+  });
+
+  it("allows PostgreSQL with default database (empty string) to execute queries", () => {
+    expect(requiresDatabaseSelection(queryTab(""), connection("postgres"), "SELECT * FROM public.users")).toBe(false);
+  });
+});
+
+describe("useSqlExecution", () => {
+  beforeEach(() => {
+    installLocalStorage();
+    setActivePinia(createPinia());
+  });
+
+  it("sends native SET variables without client-side expansion", async () => {
+    const activeTab = ref<QueryTab | undefined>(queryTab("app"));
+    const activeConnection = ref<ConnectionConfig | undefined>(connection("mysql"));
+    const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result");
+    const queryStore = useQueryStore();
+    const historyStore = useHistoryStore();
+    const executeCurrentSql = vi.spyOn(queryStore, "executeCurrentSql").mockImplementation(async () => {
+      if (activeTab.value) activeTab.value.result = { columns: ["ok"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 };
+    });
+    vi.spyOn(historyStore, "add").mockResolvedValue(undefined);
+
+    const execution = useSqlExecution({
+      activeTab: computed(() => activeTab.value),
+      activeConnection: computed(() => activeConnection.value),
+      executableSql: computed(
+        () => `
+          set @date_start = '2026-07-04 00:00:00';
+
+          select * from sa_access_decision_log AS fp
+          where fp.create_at < @date_start;
+        `,
+      ),
+      activeOutputView,
+    });
+
+    await execution.tryExecute();
+
+    const executedSql = executeCurrentSql.mock.calls[0]?.[0] ?? "";
+    expect(executedSql).toContain("set @date_start = '2026-07-04 00:00:00'");
+    expect(executedSql).toContain("where fp.create_at < @date_start");
+  });
+
+  it("records a later MySQL batch error and skips metadata refresh", async () => {
+    const activeTab = ref<QueryTab | undefined>(queryTab("app"));
+    const activeConnection = ref<ConnectionConfig | undefined>(connection("mysql"));
+    const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result");
+    const queryStore = useQueryStore();
+    const historyStore = useHistoryStore();
+    const connectionStore = useConnectionStore();
+    vi.spyOn(queryStore, "executeCurrentSql").mockImplementation(async () => {
+      const tab = activeTab.value;
+      if (!tab) return;
+      const successfulResult = { columns: ["value"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 };
+      tab.result = successfulResult;
+      tab.results = [successfulResult, { columns: ["Error"], execution_error: true, rows: [["Duplicate entry '1'"]], affected_rows: 0, execution_time_ms: 1 }];
+      tab.activeResultIndex = 0;
+    });
+    const addHistory = vi.spyOn(historyStore, "add").mockResolvedValue(undefined);
+    const refreshObjects = vi.spyOn(connectionStore, "refreshObjectListTreeNode").mockResolvedValue(undefined);
+
+    const execution = useSqlExecution({
+      activeTab: computed(() => activeTab.value),
+      activeConnection: computed(() => activeConnection.value),
+      executableSql: computed(() => "SELECT 1 AS value; CREATE TABLE duplicate_target (id INT)"),
+      activeOutputView,
+    });
+
+    await execution.tryExecute();
+
+    expect(addHistory).toHaveBeenCalledWith(expect.objectContaining({ success: false, error: "Duplicate entry '1'", affected_rows: undefined }));
+    expect(refreshObjects).not.toHaveBeenCalled();
+  });
+
+  it("does not treat an unmarked MySQL Error alias as a batch failure", async () => {
+    const activeTab = ref<QueryTab | undefined>(queryTab("app"));
+    const activeConnection = ref<ConnectionConfig | undefined>(connection("mysql"));
+    const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result");
+    const queryStore = useQueryStore();
+    const historyStore = useHistoryStore();
+    vi.spyOn(queryStore, "executeCurrentSql").mockImplementation(async () => {
+      const tab = activeTab.value;
+      if (!tab) return;
+      const successfulResult = { columns: ["value"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 };
+      tab.result = successfulResult;
+      tab.results = [successfulResult, { columns: ["Error"], rows: [[2]], affected_rows: 0, execution_time_ms: 1 }];
+      tab.activeResultIndex = 0;
+    });
+    const addHistory = vi.spyOn(historyStore, "add").mockResolvedValue(undefined);
+
+    const execution = useSqlExecution({
+      activeTab: computed(() => activeTab.value),
+      activeConnection: computed(() => activeConnection.value),
+      executableSql: computed(() => "SELECT 1 AS value; SELECT 2 AS Error"),
+      activeOutputView,
+    });
+
+    await execution.tryExecute();
+
+    expect(addHistory).toHaveBeenCalledWith(expect.objectContaining({ success: true, error: undefined }));
+  });
+
+  it("continues to record active non-MySQL errors as failures", async () => {
+    const activeTab = ref<QueryTab | undefined>(queryTab("app"));
+    const activeConnection = ref<ConnectionConfig | undefined>(connection("postgres"));
+    const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result");
+    const queryStore = useQueryStore();
+    const historyStore = useHistoryStore();
+    vi.spyOn(queryStore, "executeCurrentSql").mockImplementation(async () => {
+      if (activeTab.value) activeTab.value.result = { columns: ["Error"], rows: [["relation does not exist"]], affected_rows: 0, execution_time_ms: 1 };
+    });
+    const addHistory = vi.spyOn(historyStore, "add").mockResolvedValue(undefined);
+
+    const execution = useSqlExecution({
+      activeTab: computed(() => activeTab.value),
+      activeConnection: computed(() => activeConnection.value),
+      executableSql: computed(() => "SELECT * FROM missing_table"),
+      activeOutputView,
+    });
+
+    await execution.tryExecute();
+
+    expect(addHistory).toHaveBeenCalledWith(expect.objectContaining({ success: false, error: "relation does not exist" }));
+  });
+
+  it("requires production confirmation even when ordinary danger prompts are disabled", async () => {
+    const activeTab = ref<QueryTab | undefined>(queryTab("prod_app"));
+    const activeConnection = ref<ConnectionConfig | undefined>({ ...connection("mysql"), production_databases: ["prod_app"] });
+    const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result");
+    const queryStore = useQueryStore();
+    const settingsStore = useSettingsStore();
+    const productionSafetyStore = useProductionSafetyStore();
+    const executeCurrentSql = vi.spyOn(queryStore, "executeCurrentSql").mockImplementation(async () => {
+      if (activeTab.value) activeTab.value.result = { columns: ["ok"], rows: [[1]], affected_rows: 1, execution_time_ms: 1 };
+    });
+    vi.spyOn(useHistoryStore(), "add").mockResolvedValue(undefined);
+    settingsStore.editorSettings.confirmDangerousSqlExecution = false;
+
+    const execution = useSqlExecution({
+      activeTab: computed(() => activeTab.value),
+      activeConnection: computed(() => activeConnection.value),
+      executableSql: computed(() => "UPDATE users SET active = 1 WHERE id = 7"),
+      activeOutputView,
+    });
+
+    const pendingExecution = execution.tryExecute();
+    await Promise.resolve();
+    expect(productionSafetyStore.pending?.sql).toContain("UPDATE users");
+    expect(executeCurrentSql).not.toHaveBeenCalled();
+
+    productionSafetyStore.confirm();
+    await pendingExecution;
+    expect(executeCurrentSql).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/desktop/src/composables/__tests__/useWindowControls.spec.ts b/apps/desktop/src/composables/__tests__/useWindowControls.spec.ts
new file mode 100644
index 0000000..e1c0068
--- /dev/null
+++ b/apps/desktop/src/composables/__tests__/useWindowControls.spec.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { macTrafficLightInsetPaddingForScale, macTrafficLightPositionForScale, shouldDrawDesktopWindowFrame, shouldReserveMacTrafficLightInset, shouldShowWindowControls } from "@/composables/useWindowControls";
+
+describe("window controls", () => {
+  it("shows custom controls for non-macOS desktop windows", () => {
+    expect(shouldShowWindowControls(false, true)).toBe(true);
+  });
+
+  it("keeps macOS on native traffic lights", () => {
+    expect(shouldShowWindowControls(true, true)).toBe(false);
+  });
+
+  it("does not show desktop controls in web runtime", () => {
+    expect(shouldShowWindowControls(false, false)).toBe(false);
+  });
+
+  it("draws an app frame only for self-decorated desktop windows", () => {
+    expect(shouldDrawDesktopWindowFrame(false, true)).toBe(true);
+    expect(shouldDrawDesktopWindowFrame(true, true)).toBe(false);
+    expect(shouldDrawDesktopWindowFrame(false, false)).toBe(false);
+  });
+
+  it("reserves traffic light inset only for non-fullscreen macOS desktop windows", () => {
+    expect(shouldReserveMacTrafficLightInset(true, false, true)).toBe(true);
+    expect(shouldReserveMacTrafficLightInset(true, true, true)).toBe(false);
+    expect(shouldReserveMacTrafficLightInset(false, false, true)).toBe(false);
+    expect(shouldReserveMacTrafficLightInset(true, false, false)).toBe(false);
+  });
+
+  it("keeps the macOS traffic light reserve visually stable across UI scales", () => {
+    expect(macTrafficLightInsetPaddingForScale(1)).toBe("70px");
+    expect(macTrafficLightInsetPaddingForScale(0.9)).toBe("78px");
+    expect(macTrafficLightInsetPaddingForScale(1.25)).toBe("56px");
+  });
+
+  it("adjusts macOS traffic lights vertically with the UI scale", () => {
+    expect(macTrafficLightPositionForScale(1)).toEqual({ x: 16, y: 18 });
+    expect(macTrafficLightPositionForScale(0.9)).toEqual({ x: 16, y: 16 });
+    expect(macTrafficLightPositionForScale(1.1)).toEqual({ x: 16, y: 20 });
+    expect(macTrafficLightPositionForScale(1.25)).toEqual({ x: 16, y: 23 });
+  });
+});
diff --git a/apps/desktop/src/composables/useAppUpdater.ts b/apps/desktop/src/composables/useAppUpdater.ts
new file mode 100644
index 0000000..130a676
--- /dev/null
+++ b/apps/desktop/src/composables/useAppUpdater.ts
@@ -0,0 +1,165 @@
+import { computed, ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { useToast } from "@/composables/useToast";
+import * as api from "@/lib/backend/api";
+import { useSettingsStore } from "@/stores/settingsStore";
+import type { UpdateDownloadSource as SettingsUpdateDownloadSource } from "@/stores/settingsStore";
+import type { UpdateDownloadProgress } from "@/lib/backend/tauri";
+import { currentLocale } from "@/i18n";
+
+export function shouldOpenUpdateDialog(options: { silent?: boolean }) {
+  return options.silent !== true;
+}
+
+export function canDownloadAndInstallUpdate(info: api.UpdateInfo | null, isDesktop: boolean) {
+  return isDesktop && info?.update_available === true && info.portable_mode !== true;
+}
+
+export function normalizeUpdateDownloadSource(value: unknown): SettingsUpdateDownloadSource {
+  if (value === "atomgit") return "atomgit";
+  return value === "cnb" ? "cnb" : "official";
+}
+
+export function tagVersion(version: string): string {
+  const trimmed = version.trim();
+  return trimmed.startsWith("v") ? trimmed : `v${trimmed}`;
+}
+
+export function resolveUpdateReleaseUrl(info: api.UpdateInfo | null, source: unknown, fallbackUrl: string): string {
+  const normalizedSource = normalizeUpdateDownloadSource(source);
+  if (normalizedSource === "cnb" && info?.latest_version) {
+    return `https://cnb.cool/dbxio.com/dbx/-/releases/tag/${tagVersion(info.latest_version)}`;
+  }
+  if (normalizedSource === "atomgit" && info?.latest_version) {
+    return `https://atomgit.com/t8y2/dbx/releases/${tagVersion(info.latest_version)}`;
+  }
+  return info?.release_url || fallbackUrl;
+}
+
+export async function resolveUpdaterProxy(): Promise<string | undefined> {
+  if (!isTauriRuntime()) return undefined;
+  try {
+    const proxy = await api.getSystemProxyUrl();
+    return proxy || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function useAppUpdater() {
+  const { t } = useI18n();
+  const { toast } = useToast();
+  const settingsStore = useSettingsStore();
+
+  const checkingUpdates = ref(false);
+  const updateInfo = ref<api.UpdateInfo | null>(null);
+  const updateCheckMessage = ref("");
+  const showUpdateDialog = ref(false);
+  const isDownloadingUpdate = ref(false);
+  const downloadProgress = ref(0);
+  const updateReady = ref(false);
+  const hasUpdateAvailable = computed(() => updateInfo.value?.update_available === true);
+  const latestReleaseUrl = "https://github.com/t8y2/dbx/releases/latest";
+
+  function openUrl(url: string) {
+    if (isTauriRuntime()) {
+      import("@tauri-apps/plugin-shell").then(({ open }) => open(url));
+    } else {
+      window.open(url, "_blank");
+    }
+  }
+
+  async function checkUpdates(options: { silent?: boolean } = {}) {
+    if (checkingUpdates.value) return;
+    checkingUpdates.value = true;
+    updateCheckMessage.value = "";
+    try {
+      const info = await api.checkForUpdates(currentLocale());
+      updateInfo.value = info;
+      if (info.update_available) {
+        if (shouldOpenUpdateDialog({ silent: options.silent })) {
+          showUpdateDialog.value = true;
+        }
+      } else if (!options.silent) {
+        updateCheckMessage.value = t("updates.upToDate", { version: info.current_version });
+        showUpdateDialog.value = true;
+      }
+    } catch (e: any) {
+      if (!options.silent) {
+        updateCheckMessage.value = formatUpdateError(String(e));
+        showUpdateDialog.value = true;
+      }
+    } finally {
+      checkingUpdates.value = false;
+    }
+  }
+
+  function formatUpdateError(message: string): string {
+    const lower = message.toLowerCase();
+    if (lower.includes("403") || lower.includes("rate limit")) {
+      return t("updates.rateLimited");
+    }
+    return t("updates.failed", { error: message });
+  }
+
+  function openLatestRelease() {
+    const url = resolveUpdateReleaseUrl(updateInfo.value, settingsStore.editorSettings.updateDownloadSource, latestReleaseUrl);
+    openUrl(url);
+  }
+
+  async function downloadAndInstallUpdate() {
+    if (!isTauriRuntime() || isDownloadingUpdate.value) return;
+    if (!canDownloadAndInstallUpdate(updateInfo.value, true)) {
+      openLatestRelease();
+      return;
+    }
+    isDownloadingUpdate.value = true;
+    downloadProgress.value = 0;
+    let unlisten: (() => void) | undefined;
+    const latestVersion = updateInfo.value?.latest_version;
+    try {
+      const { listen } = await import("@tauri-apps/api/event");
+      unlisten = await listen<UpdateDownloadProgress>("update-download-progress", (event) => {
+        const total = event.payload.total ?? 0;
+        downloadProgress.value = total > 0 ? Math.round((event.payload.downloaded / total) * 100) : 0;
+      });
+      await api.downloadAndInstallUpdate(normalizeUpdateDownloadSource(settingsStore.editorSettings.updateDownloadSource), latestVersion);
+      downloadProgress.value = 100;
+      updateReady.value = true;
+    } catch (e: any) {
+      toast(t("updates.downloadFailed", { error: e?.message || String(e) }), 5000);
+    } finally {
+      unlisten?.();
+      isDownloadingUpdate.value = false;
+    }
+  }
+
+  async function restartApp() {
+    if (!isTauriRuntime()) return;
+    try {
+      const { relaunch } = await import("@tauri-apps/plugin-process");
+      await relaunch();
+    } catch (e: any) {
+      toast(t("updates.restartFailed", { error: e?.message || String(e) }), 5000);
+    }
+  }
+
+  return {
+    checkingUpdates,
+    updateInfo,
+    updateCheckMessage,
+    showUpdateDialog,
+    isDownloadingUpdate,
+    downloadProgress,
+    updateReady,
+    hasUpdateAvailable,
+    latestReleaseUrl,
+    openUrl,
+    checkUpdates,
+    formatUpdateError,
+    openLatestRelease,
+    downloadAndInstallUpdate,
+    restartApp,
+  };
+}
diff --git a/apps/desktop/src/composables/useCellDetailEditor.ts b/apps/desktop/src/composables/useCellDetailEditor.ts
new file mode 100644
index 0000000..6d116be
--- /dev/null
+++ b/apps/desktop/src/composables/useCellDetailEditor.ts
@@ -0,0 +1,317 @@
+import { shallowRef, onBeforeUnmount, getCurrentInstance, type ShallowRef, createApp, watch } from "vue";
+import { EditorState, Compartment } from "@codemirror/state";
+import { EditorView, keymap, drawSelection, dropCursor, highlightSpecialChars, highlightActiveLine } from "@codemirror/view";
+import { json } from "@codemirror/lang-json";
+import { search as cmSearch } from "@codemirror/search";
+import { defaultKeymap, history, historyKeymap } from "@codemirror/commands";
+import { bracketMatching } from "@codemirror/language";
+import { trimmedSelectionLayer } from "@/lib/editor/codemirrorTrimmedSelectionLayer";
+import { EDITOR_FONT_FAMILY_CSS_VAR, EDITOR_FONT_SIZE_CSS_VAR, cellDetailActiveLineColor, loadEditorTheme, editorFontTheme } from "@/lib/editor/editorThemes";
+import { shortcutToCodeMirrorKey } from "@/lib/editor/shortcutRegistry";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { CELL_DETAIL_JSON_FORMAT_MAX_LENGTH, isJsonColumnType } from "@/lib/dataGrid/cellDetailPresentation";
+import { clampEditorFontSize, createEditorZoomCommitScheduler, fontSizeFromGestureScale, fontSizeFromWheelDelta } from "@/lib/editor/editorZoom";
+import i18n from "@/i18n";
+import EditorSearchPanel from "@/components/editor/EditorSearchPanel.vue";
+import type { EditorTheme } from "@/stores/settingsStore";
+import type { AppThemeAppearance, AppThemePalette } from "@/lib/app/appTheme";
+import { selectAllCellDetailText } from "@/lib/dataGrid/cellDetailSelection";
+
+export interface UseCellDetailEditorOptions {
+  onChange?: (value: string) => void;
+  onEscape?: () => void;
+  onBlur?: () => void;
+  language?: "auto" | "json";
+  readOnly?: boolean;
+  editorTheme: () => EditorTheme;
+  appAppearance: () => AppThemeAppearance;
+  appPalette: () => AppThemePalette;
+  fontSize: () => number;
+  fontFamily: () => string;
+}
+
+export interface UseCellDetailEditorReturn {
+  create: (parent: HTMLElement, initialValue: string, columnType?: string) => Promise<void>;
+  setValue: (value: string, columnType?: string) => void;
+  getValue: () => string;
+  openSearch: () => boolean;
+  openReplace: () => boolean;
+  destroy: () => void;
+  view: Readonly<ShallowRef<EditorView | null>>;
+}
+
+interface CellDetailEditorGestureEvent extends Event {
+  scale?: number;
+}
+
+function looksLikeJsonString(text: string): boolean {
+  const trimmed = text.trim();
+  return trimmed.startsWith("{") || trimmed.startsWith("[");
+}
+
+function shouldUseJsonMode(columnType?: string, value?: string): boolean {
+  if (value && value.length > CELL_DETAIL_JSON_FORMAT_MAX_LENGTH) return false;
+  if (isJsonColumnType(columnType)) return true;
+  if (value && looksLikeJsonString(value)) return true;
+  return false;
+}
+
+export function useCellDetailEditor(options: UseCellDetailEditorOptions): UseCellDetailEditorReturn {
+  const view = shallowRef<EditorView | null>(null) as ShallowRef<EditorView | null>;
+  const settingsStore = useSettingsStore();
+  const languageComp = new Compartment();
+  const themeComp = new Compartment();
+  const fontThemeComp = new Compartment();
+
+  let destroyed = false;
+  let currentIsJson = false;
+  let liveFontSize = clampEditorFontSize(options.fontSize());
+  let gestureStartFontSize = liveFontSize;
+  let isGestureZooming = false;
+  let pendingFontReconfig: { size: number; family: string } | null = null;
+  let fontReconfigScheduled = false;
+  let searchApp: ReturnType<typeof createApp> | null = null;
+  let searchInstance: InstanceType<typeof EditorSearchPanel> | null = null;
+  let wrapperEl: HTMLDivElement | null = null;
+
+  const zoomCommitScheduler = createEditorZoomCommitScheduler((fontSize) => {
+    if (settingsStore.editorSettings.fontSize === fontSize) return;
+    settingsStore.updateEditorSettings({ fontSize });
+  });
+
+  function syncEditorFontCssVars(fontSize = liveFontSize, fontFamily = options.fontFamily()) {
+    if (!wrapperEl) return;
+    wrapperEl.style.setProperty(EDITOR_FONT_SIZE_CSS_VAR, `${clampEditorFontSize(fontSize)}px`);
+    wrapperEl.style.setProperty(EDITOR_FONT_FAMILY_CSS_VAR, fontFamily);
+  }
+
+  function reconfigureFontTheme(size: number, family: string) {
+    const editor = view.value;
+    if (!editor) return;
+    editor.dispatch({
+      effects: fontThemeComp.reconfigure(editorFontTheme(EditorView, size, family, { fixedHeight: true, scrollable: true })),
+    });
+  }
+
+  function scheduleFontThemeReconfig(size: number, family: string) {
+    pendingFontReconfig = { size, family };
+    if (fontReconfigScheduled) return;
+    fontReconfigScheduled = true;
+    requestAnimationFrame(() => {
+      fontReconfigScheduled = false;
+      const pending = pendingFontReconfig;
+      if (!pending || destroyed) return;
+      pendingFontReconfig = null;
+      reconfigureFontTheme(pending.size, pending.family);
+    });
+  }
+
+  function applyLiveFontSize(size: number) {
+    const next = clampEditorFontSize(size);
+    if (liveFontSize === next) return;
+    liveFontSize = next;
+    syncEditorFontCssVars(next);
+    scheduleFontThemeReconfig(next, options.fontFamily());
+  }
+
+  function onEditorGestureStart(event: CellDetailEditorGestureEvent) {
+    event.preventDefault();
+    isGestureZooming = true;
+    gestureStartFontSize = liveFontSize;
+  }
+
+  function onEditorGestureChange(event: CellDetailEditorGestureEvent) {
+    if (typeof event.scale !== "number") return;
+    event.preventDefault();
+    applyLiveFontSize(fontSizeFromGestureScale(gestureStartFontSize, event.scale));
+  }
+
+  function onEditorGestureEnd(event: Event) {
+    event.preventDefault();
+    isGestureZooming = false;
+    zoomCommitScheduler.flush(liveFontSize);
+  }
+
+  watch([() => options.fontSize(), () => options.fontFamily(), () => options.editorTheme(), () => options.appAppearance(), () => options.appPalette()], async ([fontSize, fontFamily, editorTheme, appearance, palette]) => {
+    const editor = view.value;
+    if (!editor || destroyed) return;
+    if (!isGestureZooming && !zoomCommitScheduler.hasPendingCommit()) {
+      liveFontSize = clampEditorFontSize(fontSize);
+    }
+    syncEditorFontCssVars(liveFontSize, fontFamily);
+    const theme = await loadEditorTheme(editorTheme, appearance, undefined, palette);
+    if (!view.value || destroyed) return;
+    view.value.dispatch({
+      effects: [themeComp.reconfigure(theme), fontThemeComp.reconfigure(editorFontTheme(EditorView, liveFontSize, fontFamily, { fixedHeight: true, scrollable: true }))],
+    });
+  });
+
+  async function create(parent: HTMLElement, initialValue: string, columnType?: string): Promise<void> {
+    if (destroyed) return;
+
+    const doc = initialValue ?? "";
+    currentIsJson = options.language === "json" || shouldUseJsonMode(columnType, doc);
+
+    const theme = await loadEditorTheme(options.editorTheme(), options.appAppearance(), undefined, options.appPalette());
+    liveFontSize = clampEditorFontSize(options.fontSize());
+    const fontTheme = editorFontTheme(EditorView, liveFontSize, options.fontFamily(), { fixedHeight: true, scrollable: true });
+    const shortcuts = settingsStore.editorSettings.shortcuts;
+
+    const state = EditorState.create({
+      doc,
+      extensions: [
+        cmSearch({
+          createPanel: () => {
+            const dom = document.createElement("span");
+            dom.style.display = "none";
+            return { dom };
+          },
+        }),
+        // Minimal setup without line numbers
+        highlightSpecialChars(),
+        history(),
+        drawSelection(),
+        trimmedSelectionLayer(),
+        dropCursor(),
+        highlightActiveLine(),
+        EditorView.theme({
+          ".cm-activeLine": {
+            backgroundColor: cellDetailActiveLineColor(),
+          },
+        }),
+        EditorState.allowMultipleSelections.of(true),
+        bracketMatching(),
+        keymap.of([
+          ...defaultKeymap,
+          ...historyKeymap,
+          {
+            key: shortcutToCodeMirrorKey(shortcuts.find),
+            preventDefault: true,
+            run: () => openSearch(),
+          },
+          {
+            key: shortcutToCodeMirrorKey(shortcuts.replace),
+            preventDefault: true,
+            run: () => openReplace(),
+          },
+        ]),
+        languageComp.of(currentIsJson ? json() : []),
+        themeComp.of(theme),
+        fontThemeComp.of(fontTheme),
+        keymap.of([
+          {
+            key: "Mod-a",
+            run: selectAllCellDetailText,
+          },
+          {
+            key: "Escape",
+            run: () => {
+              if (searchInstance && (searchInstance as any).closeSearch()) return true;
+              options.onEscape?.();
+              return true;
+            },
+          },
+        ]),
+        EditorView.updateListener.of((update) => {
+          if (update.docChanged) {
+            options.onChange?.(update.state.doc.toString());
+          }
+        }),
+        EditorView.domEventHandlers({
+          wheel(event) {
+            if (!event.metaKey && !event.ctrlKey) return false;
+            event.preventDefault();
+            const next = fontSizeFromWheelDelta(liveFontSize, event.deltaY);
+            applyLiveFontSize(next);
+            zoomCommitScheduler.schedule(next);
+            return true;
+          },
+          blur: () => {
+            options.onBlur?.();
+          },
+        }),
+        EditorState.readOnly.of(!!options.readOnly),
+        EditorView.editable.of(!options.readOnly),
+        // Read-only CodeMirror content is not editable or focusable by default.
+        // Keep it keyboard-focusable so selection shortcuts stay inside the detail value.
+        EditorView.contentAttributes.of(options.readOnly ? { tabindex: "0" } : {}),
+      ],
+    });
+
+    wrapperEl = document.createElement("div");
+    wrapperEl.style.cssText = "position: relative; width: 100%; height: 100%;";
+    wrapperEl.addEventListener("gesturestart", onEditorGestureStart);
+    wrapperEl.addEventListener("gesturechange", onEditorGestureChange);
+    wrapperEl.addEventListener("gestureend", onEditorGestureEnd);
+    parent.appendChild(wrapperEl);
+    syncEditorFontCssVars(liveFontSize, options.fontFamily());
+
+    view.value = new EditorView({ state, parent: wrapperEl });
+
+    // Mount search panel component
+    const searchMount = document.createElement("div");
+    wrapperEl.appendChild(searchMount);
+    searchApp = createApp(EditorSearchPanel, { view: view.value });
+    searchApp.use(i18n);
+    searchInstance = searchApp.mount(searchMount) as any;
+  }
+
+  function setValue(value: string, columnType?: string) {
+    const editor = view.value;
+    if (!editor || destroyed) return;
+
+    const text = value ?? "";
+    const newIsJson = options.language === "json" || shouldUseJsonMode(columnType, text);
+    const effects: ReturnType<typeof Compartment.prototype.reconfigure>[] = [];
+
+    if (newIsJson !== currentIsJson) {
+      effects.push(languageComp.reconfigure(newIsJson ? json() : []));
+      currentIsJson = newIsJson;
+    }
+
+    editor.dispatch({
+      changes: { from: 0, to: editor.state.doc.length, insert: text },
+      effects,
+    });
+  }
+
+  function getValue(): string {
+    return view.value?.state.doc.toString() ?? "";
+  }
+
+  function openSearch(): boolean {
+    return (searchInstance as any)?.openSearch?.() ?? false;
+  }
+
+  function openReplace(): boolean {
+    return (searchInstance as any)?.openReplace?.() ?? false;
+  }
+
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    searchApp?.unmount();
+    searchApp = null;
+    searchInstance = null;
+    view.value?.destroy();
+    view.value = null;
+    zoomCommitScheduler.dispose();
+    if (wrapperEl) {
+      wrapperEl.removeEventListener("gesturestart", onEditorGestureStart);
+      wrapperEl.removeEventListener("gesturechange", onEditorGestureChange);
+      wrapperEl.removeEventListener("gestureend", onEditorGestureEnd);
+    }
+    if (wrapperEl?.parentNode) {
+      wrapperEl.parentNode.removeChild(wrapperEl);
+    }
+    wrapperEl = null;
+  }
+
+  if (getCurrentInstance()) {
+    onBeforeUnmount(() => {
+      destroy();
+    });
+  }
+
+  return { create, setValue, getValue, openSearch, openReplace, destroy, view };
+}
diff --git a/apps/desktop/src/composables/useCloseActionPrompt.ts b/apps/desktop/src/composables/useCloseActionPrompt.ts
new file mode 100644
index 0000000..f128f7c
--- /dev/null
+++ b/apps/desktop/src/composables/useCloseActionPrompt.ts
@@ -0,0 +1,83 @@
+import { ref } from "vue";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import * as api from "@/lib/backend/api";
+
+export type AppCloseAction = "quit" | "hide";
+type AppCloseRequestTarget = "settings" | "quit";
+
+export interface AppCloseRequestOptions {
+  requireCloseActionChoice?: boolean;
+}
+
+interface AppCloseRequestPayload {
+  payload?: AppCloseRequestTarget;
+}
+
+export function useCloseActionPrompt(options: { requestClose: (action: AppCloseAction, requestOptions?: AppCloseRequestOptions) => void }) {
+  const settingsStore = useSettingsStore();
+  const showCloseActionPrompt = ref(false);
+  const unlistenHandles: Array<() => void> = [];
+
+  function actionForRequest(target: AppCloseRequestTarget): AppCloseAction {
+    if (target === "quit") return "quit";
+    return settingsStore.desktopSettings.quit_on_close ? "quit" : "hide";
+  }
+
+  async function performCloseAction(action: AppCloseAction) {
+    if (!isTauriRuntime()) return;
+    await api.completeAppClose(action);
+  }
+
+  function handleCloseRequest(target: AppCloseRequestTarget = "settings") {
+    const action = actionForRequest(target);
+    options.requestClose(action, {
+      requireCloseActionChoice: target === "settings" && !settingsStore.desktopSettings.close_action_prompted,
+    });
+  }
+
+  async function applyCloseChoice(action: AppCloseAction) {
+    showCloseActionPrompt.value = false;
+    await settingsStore.updateDesktopSettings({
+      quit_on_close: action === "quit",
+      close_action_prompted: true,
+    });
+    options.requestClose(action, { requireCloseActionChoice: false });
+  }
+
+  function chooseQuit() {
+    void applyCloseChoice("quit");
+  }
+
+  function chooseMinimize() {
+    void applyCloseChoice("hide");
+  }
+
+  function cancelCloseActionPrompt() {
+    showCloseActionPrompt.value = false;
+  }
+
+  function setupCloseActionPromptListener() {
+    if (!isTauriRuntime()) return;
+    void import("@tauri-apps/api/event").then(({ listen }) => {
+      listen<AppCloseRequestTarget>("dbx-app-close-requested", (event: AppCloseRequestPayload) => {
+        handleCloseRequest(event.payload === "quit" ? "quit" : "settings");
+      }).then((unlisten) => unlistenHandles.push(unlisten));
+    });
+  }
+
+  function cleanupCloseActionPromptListener() {
+    unlistenHandles.forEach((unlisten) => unlisten());
+    unlistenHandles.length = 0;
+  }
+
+  return {
+    showCloseActionPrompt,
+    chooseQuit,
+    chooseMinimize,
+    cancelCloseActionPrompt,
+    performCloseAction,
+    setupCloseActionPromptListener,
+    cleanupCloseActionPromptListener,
+  };
+}
diff --git a/apps/desktop/src/composables/useDataGridActions.ts b/apps/desktop/src/composables/useDataGridActions.ts
new file mode 100644
index 0000000..ae21c2f
--- /dev/null
+++ b/apps/desktop/src/composables/useDataGridActions.ts
@@ -0,0 +1,359 @@
+import { type ComputedRef } from "vue";
+import { useI18n } from "vue-i18n";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { buildTableSelectSql, quoteTableIdentifier } from "@/lib/table/tableSelectSql";
+import { editableRowIdentifierColumns, usesSyntheticRowIdKey } from "@/lib/table/tableEditing";
+import { tableMetaForDataTab } from "@/lib/table/tableDataTabMeta";
+import * as api from "@/lib/backend/api";
+import type { QueryTab } from "@/types/database";
+import { useToast } from "@/composables/useToast";
+import { effectiveDatabaseTypeForConnection, metadataSchemaForConnection } from "@/lib/database/jdbcDialect";
+import { applyMongoFindSort } from "@/lib/mongo/mongoShellCommand";
+import { uuid } from "@/lib/common/utils";
+import type { DataGridSortMode } from "@/lib/dataGrid/dataGridSort";
+import type { DataGridReloadIntent } from "@/lib/dataGrid/dataGridToolbar";
+import { queryResultBaseSql, queryResultExecutionSql } from "@/lib/tabs/tabPresentation";
+
+const DATA_TAB_METADATA_TTL_MS = 30_000;
+
+function visibleQuerySortColumns(columns: string[], hiddenColumnIndexes: number[] | undefined, columnIndex: number): { resultColumns: string[]; columnIndex: number } | undefined {
+  const hiddenIndexes = new Set(hiddenColumnIndexes ?? []);
+  const resultColumns: string[] = [];
+  let visibleColumnIndex: number | undefined;
+  for (const [index, resultColumn] of columns.entries()) {
+    if (hiddenIndexes.has(index)) continue;
+    if (index === columnIndex) visibleColumnIndex = resultColumns.length;
+    resultColumns.push(resultColumn);
+  }
+  if (visibleColumnIndex === undefined) return undefined;
+  return { resultColumns, columnIndex: visibleColumnIndex };
+}
+
+export function useDataGridActions(activeTab: ComputedRef<QueryTab | undefined>) {
+  const { t } = useI18n();
+  const { toast } = useToast();
+  const connectionStore = useConnectionStore();
+  const queryStore = useQueryStore();
+  const settingsStore = useSettingsStore();
+
+  function quoteIdent(tab: QueryTab, name: string): string {
+    const config = connectionStore.getConfig(tab.connectionId);
+    return quoteTableIdentifier(effectiveDatabaseTypeForConnection(config), name);
+  }
+
+  function buildTableSql(tab: QueryTab, options: { orderBy?: string; limit?: number; offset?: number; whereInput?: string } = {}): Promise<string> {
+    const config = connectionStore.getConfig(tab.connectionId);
+    const effectiveDbType = effectiveDatabaseTypeForConnection(config);
+    const tableMeta = tableMetaForDataTab(tab);
+    const primaryKeys = tab.tableMeta ? tab.tableMeta.primaryKeys : (tableMeta?.primaryKeys ?? []);
+    const useRowId = usesSyntheticRowIdKey(effectiveDbType, primaryKeys, tableMeta?.tableType);
+    return buildTableSelectSql({
+      databaseType: effectiveDbType,
+      schema: tableMeta?.schema,
+      tableName: tableMeta?.tableName ?? "",
+      tableType: tableMeta?.tableType,
+      catalog: tableMeta?.catalog,
+      columns: tableMeta?.columns.map((column) => column.name),
+      primaryKeys,
+      includeRowId: useRowId,
+      limit: options.limit ?? settingsStore.editorSettings.pageSize,
+      ...options,
+    });
+  }
+
+  async function refreshDataTabTableMeta(tab: QueryTab, trace?: { traceId: string; elapsed: () => string }): Promise<void> {
+    if (tab.mode !== "data" || !tab.connectionId || !tab.database) return;
+    const tableMeta = tableMetaForDataTab(tab);
+    if (!tableMeta?.tableName) return;
+    const target = {
+      tabId: tab.id,
+      connectionId: tab.connectionId,
+      database: tab.database,
+      catalog: tableMeta.catalog,
+      schema: tableMeta.schema,
+      tableName: tableMeta.tableName,
+      tableType: tableMeta.tableType,
+    };
+
+    console.info("[DBX][reloadData:metadata:ensure-connected:start]", { traceId: trace?.traceId, elapsed: trace?.elapsed() });
+    await connectionStore.ensureConnected(target.connectionId);
+    console.info("[DBX][reloadData:metadata:ensure-connected:done]", { traceId: trace?.traceId, elapsed: trace?.elapsed() });
+    const config = connectionStore.getConfig(target.connectionId);
+    const querySchema = metadataSchemaForConnection(config, target.database, target.schema);
+    console.info("[DBX][reloadData:metadata:get-columns:start]", { traceId: trace?.traceId, elapsed: trace?.elapsed(), schema: querySchema, table: target.tableName });
+    const columns = await api.getColumns(target.connectionId, target.database, querySchema, target.tableName, target.catalog);
+    const indexes = await api.listIndexes(target.connectionId, target.database, querySchema, target.tableName, target.catalog).catch(() => []);
+    console.info("[DBX][reloadData:metadata:get-columns:done]", { traceId: trace?.traceId, elapsed: trace?.elapsed(), columnCount: columns.length });
+    const current = queryStore.tabs.find((item) => item.id === target.tabId);
+    const currentMeta = current ? tableMetaForDataTab(current) : undefined;
+    if (!current || current.mode !== "data" || current.connectionId !== target.connectionId || current.database !== target.database || currentMeta?.tableName !== target.tableName || (currentMeta.schema ?? "") !== (target.schema ?? "") || (currentMeta.catalog ?? "") !== (target.catalog ?? "")) {
+      console.info("[DBX][reloadData:metadata:stale-tab]", { traceId: trace?.traceId, elapsed: trace?.elapsed(), table: target.tableName });
+      return;
+    }
+    const primaryKeys = editableRowIdentifierColumns(effectiveDatabaseTypeForConnection(config), columns, indexes, target.tableType);
+    queryStore.setTableMeta(target.tabId, {
+      catalog: target.catalog,
+      schema: target.schema,
+      tableName: target.tableName,
+      tableType: target.tableType,
+      columns,
+      primaryKeys,
+    });
+  }
+
+  async function onExecuteSql(sql: string) {
+    const tab = activeTab.value;
+    if (!tab) return;
+    queryStore.updateSql(tab.id, sql);
+    await queryStore.executeTabSql(tab.id, sql, { preserveResultDuringExecution: true });
+  }
+
+  async function onReloadData(sql?: string, _searchText?: string, whereInput?: string, orderBy?: string, limit?: number, offset?: number, intent?: DataGridReloadIntent) {
+    const tab = activeTab.value;
+    if (!tab) return;
+    const traceId = uuid().slice(0, 8);
+    const startedAt = performance.now();
+    const elapsed = () => `${Math.round(performance.now() - startedAt)}ms`;
+    if (tab.mode === "data" && tableMetaForDataTab(tab)) {
+      tab.whereInput = whereInput ?? "";
+      const pageLimit = limit ?? settingsStore.editorSettings.pageSize;
+      const pageOffset = offset ?? 0;
+      console.info("[DBX][reloadData:start]", {
+        traceId,
+        tabId: tab.id,
+        connectionId: tab.connectionId,
+        database: tab.database,
+        table: tableMetaForDataTab(tab)?.tableName,
+        elapsed: elapsed(),
+      });
+      queryStore.setExecuting(tab.id, true);
+      const tableMeta = tableMetaForDataTab(tab);
+      const metadataAgeMs = tab.tableMetaUpdatedAt ? Date.now() - tab.tableMetaUpdatedAt : Number.POSITIVE_INFINITY;
+      const shouldRefreshMetadata = !tab.tableMeta || !tableMeta?.columns.length || metadataAgeMs > DATA_TAB_METADATA_TTL_MS;
+      if (shouldRefreshMetadata) {
+        console.info("[DBX][reloadData:metadata:background:start]", { traceId, elapsed: elapsed(), reason: tableMeta?.columns.length ? "stale" : "missing", metadataAgeMs });
+        void refreshDataTabTableMeta(tab, { traceId, elapsed })
+          .then(() => {
+            console.info("[DBX][reloadData:metadata:background:done]", { traceId, elapsed: elapsed() });
+          })
+          .catch((e: any) => {
+            console.warn("[DBX][reloadData:metadata:background:error]", { traceId, elapsed: elapsed(), error: e });
+            toast(e?.message || String(e), 5000);
+          });
+      } else {
+        console.info("[DBX][reloadData:metadata:skip]", { traceId, elapsed: elapsed(), columnCount: tableMeta.columns.length, metadataAgeMs });
+      }
+      try {
+        console.info("[DBX][reloadData:build-sql:start]", { traceId, elapsed: elapsed() });
+        const nextSql = await buildTableSql(tab, { whereInput, orderBy, limit: pageLimit, offset: pageOffset });
+        console.info("[DBX][reloadData:build-sql:done]", { traceId, elapsed: elapsed() });
+        queryStore.updateSql(tab.id, nextSql);
+        console.info("[DBX][reloadData:execute:start]", { traceId, elapsed: elapsed() });
+        await queryStore.executeTabSql(tab.id, nextSql, {
+          pagination: { limit: pageLimit, offset: pageOffset },
+          preserveResultDuringExecution: true,
+        });
+        console.info("[DBX][reloadData:execute:done]", { traceId, elapsed: elapsed() });
+      } catch (e) {
+        console.error("[DBX][reloadData:error]", { traceId, elapsed: elapsed(), error: e });
+        queryStore.setExecuting(tab.id, false);
+        throw e;
+      }
+      return;
+    }
+    if (intent === "refresh" && tab.mode === "query" && (tab.results?.length ?? 0) > 1) {
+      const resultGroupSql = tab.resultBaseSql || tab.lastExecutedSql || tab.sql;
+      if (!resultGroupSql.trim()) return;
+      tab.resultSortColumn = undefined;
+      tab.resultSortColumnIndex = undefined;
+      tab.resultSortDirection = undefined;
+      tab.resultSortMode = undefined;
+      tab.resultSortedSql = undefined;
+      await queryStore.executeTabSql(tab.id, resultGroupSql, {
+        resultBaseSql: resultGroupSql,
+        resultSortedSql: undefined,
+        preserveResultDuringExecution: true,
+        preserveActiveResultIndex: true,
+      });
+      return;
+    }
+    if (tab.resultSortedSql) {
+      const sortColumns = visibleQuerySortColumns(tab.result?.columns ?? [], tab.result?.hidden_column_indexes, tab.resultSortColumnIndex ?? -1);
+      const rebuildHiddenKeySort = !!tab.result?.hidden_column_indexes?.length && tab.resultSortMode === "database" && !!tab.resultSortDirection && !!tab.resultSortColumn && !!sortColumns;
+      await queryStore.executeTabSql(tab.id, rebuildHiddenKeySort ? (tab.resultBaseSql ?? tab.sql) : tab.resultSortedSql, {
+        resultBaseSql: tab.resultBaseSql ?? tab.sql,
+        ...(rebuildHiddenKeySort
+          ? {
+              querySort: {
+                resultColumns: sortColumns.resultColumns,
+                columnIndex: sortColumns.columnIndex,
+                column: tab.resultSortColumn!,
+                direction: tab.resultSortDirection!,
+              },
+            }
+          : { resultSortedSql: tab.resultSortedSql }),
+        preserveResultDuringExecution: true,
+        preserveTotalRowCountDuringExecution: true,
+      });
+      return;
+    }
+    if (sql?.trim()) {
+      await queryStore.executeTabSql(tab.id, sql, {
+        resultBaseSql: sql,
+        resultSortedSql: undefined,
+        preserveResultDuringExecution: true,
+      });
+      return;
+    }
+    await queryStore.executeCurrentTab();
+  }
+
+  async function onPaginate(offset: number, limit: number, whereInput?: string, orderBy?: string) {
+    const tab = activeTab.value;
+    if (!tab) return;
+    if (tab.mode !== "data") {
+      const sortColumns = visibleQuerySortColumns(tab.result?.columns ?? [], tab.result?.hidden_column_indexes, tab.resultSortColumnIndex ?? -1);
+      const hasDatabaseSort = !!tab.result?.hidden_column_indexes?.length && tab.resultSortMode === "database" && !!tab.resultSortDirection && !!tab.resultSortColumn && !!sortColumns;
+      const baseSql = hasDatabaseSort ? queryResultBaseSql(tab) : queryResultExecutionSql(tab);
+      if (!baseSql.trim()) return;
+      const expectedNextOffset = (tab.resultPageOffset ?? 0) + (tab.resultPageLimit ?? limit);
+      const sessionId = tab.result?.has_more && tab.result?.session_id && offset === expectedNextOffset && limit === tab.resultPageLimit ? tab.result.session_id : undefined;
+      const resultBaseSql = queryResultBaseSql(tab);
+      await queryStore.executeTabSql(tab.id, baseSql, {
+        resultBaseSql,
+        resultSortedSql: tab.resultSortedSql,
+        ...(hasDatabaseSort
+          ? {
+              querySort: {
+                resultColumns: sortColumns.resultColumns,
+                columnIndex: sortColumns.columnIndex,
+                column: tab.resultSortColumn!,
+                direction: tab.resultSortDirection!,
+              },
+            }
+          : {}),
+        pagination: { offset, limit, sessionId },
+        preserveResultDuringExecution: true,
+        preserveTotalRowCountDuringExecution: true,
+        replaceActiveResultInGroup: true,
+      });
+      return;
+    }
+
+    if (!tableMetaForDataTab(tab)) return;
+    tab.whereInput = whereInput ?? "";
+    const sql = await buildTableSql(tab, { limit, offset, whereInput, orderBy });
+    queryStore.updateSql(tab.id, sql);
+    await queryStore.executeTabSql(tab.id, sql, {
+      pagination: { offset, limit },
+      preserveResultDuringExecution: true,
+      preserveTotalRowCountDuringExecution: true,
+    });
+  }
+
+  async function onSort(column: string, columnIndex: number, direction: "asc" | "desc" | null, whereInput?: string, mode: DataGridSortMode = "database") {
+    const tab = activeTab.value;
+    if (!tab) return;
+    tab.resultSortColumn = direction ? column : undefined;
+    tab.resultSortColumnIndex = direction ? columnIndex : undefined;
+    tab.resultSortDirection = direction ?? undefined;
+    tab.resultSortMode = direction ? mode : undefined;
+
+    if (mode === "local") {
+      if (tab.mode === "data") {
+        tab.whereInput = whereInput ?? "";
+        tab.orderByInput = undefined;
+      }
+      queryStore.sortTabResultLocally(tab.id, column, columnIndex, direction);
+      return;
+    }
+
+    if (tab.mode === "data") {
+      if (!tableMetaForDataTab(tab)) return;
+      tab.whereInput = whereInput ?? "";
+      const config = connectionStore.getConfig(tab.connectionId);
+      const quotedColumn = quoteIdent(tab, column);
+      const orderBy = direction ? `${config?.db_type === "neo4j" ? `n.${quotedColumn}` : quotedColumn} ${direction.toUpperCase()}` : undefined;
+      const sql = await buildTableSql(tab, { orderBy, whereInput });
+      queryStore.updateSql(tab.id, sql);
+      await queryStore.executeTabSql(tab.id, sql, { preserveResultDuringExecution: true });
+      return;
+    }
+
+    const baseSql = queryResultBaseSql(tab);
+    if (!baseSql.trim()) return;
+
+    if (!direction) {
+      await queryStore.executeTabSql(tab.id, baseSql, {
+        resultBaseSql: baseSql,
+        resultSortedSql: undefined,
+        preserveResultDuringExecution: true,
+        preserveTotalRowCountDuringExecution: true,
+        replaceActiveResultInGroup: true,
+      });
+      return;
+    }
+
+    const config = connectionStore.getConfig(tab.connectionId);
+    if (effectiveDatabaseTypeForConnection(config) === "mongodb") {
+      const sortedSql = applyMongoFindSort(baseSql, column, direction);
+      if (!sortedSql) {
+        toast(t("grid.sortUnsupported"), 5000);
+        return;
+      }
+      queryStore.updateSql(tab.id, sortedSql);
+      await queryStore.executeTabSql(tab.id, sortedSql, {
+        resultBaseSql: baseSql,
+        resultSortedSql: sortedSql,
+        preserveResultDuringExecution: true,
+        preserveTotalRowCountDuringExecution: true,
+        replaceActiveResultInGroup: true,
+      });
+      return;
+    }
+
+    const sortColumns = visibleQuerySortColumns(tab.result?.columns ?? [], tab.result?.hidden_column_indexes, columnIndex);
+    if (!sortColumns) {
+      toast(t("grid.sortUnsupported"), 5000);
+      return;
+    }
+    if (!tab.result?.hidden_column_indexes?.length) {
+      const built = await api.buildSortedQuerySql({
+        originalSql: baseSql,
+        databaseType: effectiveDatabaseTypeForConnection(config),
+        resultColumns: sortColumns.resultColumns,
+        columnIndex: sortColumns.columnIndex,
+        column,
+        direction,
+      });
+      if (!built.ok || !built.sql) {
+        toast(t("grid.sortUnsupported"), 5000);
+        return;
+      }
+      await queryStore.executeTabSql(tab.id, built.sql, {
+        resultBaseSql: baseSql,
+        resultSortedSql: built.sql,
+        preserveResultDuringExecution: true,
+        preserveTotalRowCountDuringExecution: true,
+        replaceActiveResultInGroup: true,
+      });
+      return;
+    }
+    await queryStore.executeTabSql(tab.id, baseSql, {
+      resultBaseSql: baseSql,
+      querySort: {
+        resultColumns: sortColumns.resultColumns,
+        columnIndex: sortColumns.columnIndex,
+        column,
+        direction,
+      },
+      preserveResultDuringExecution: true,
+      preserveTotalRowCountDuringExecution: true,
+      replaceActiveResultInGroup: true,
+    });
+  }
+
+  return { onExecuteSql, onReloadData, onPaginate, onSort };
+}
diff --git a/apps/desktop/src/composables/useDataGridColumnResize.ts b/apps/desktop/src/composables/useDataGridColumnResize.ts
new file mode 100644
index 0000000..0f77a0b
--- /dev/null
+++ b/apps/desktop/src/composables/useDataGridColumnResize.ts
@@ -0,0 +1,153 @@
+import { ref, computed, watch, type ComputedRef, type Ref } from "vue";
+import { calculateDataGridColumnWidth, DATA_GRID_AUTO_FIT_VALUE_TEXT_LIMIT, DATA_GRID_COL_AUTO_FIT_MAX_WIDTH, DATA_GRID_COL_MIN_WIDTH, COLUMN_WIDTH_DENSITY_PRESETS } from "@/lib/dataGrid/dataGridColumnWidth";
+import type { ColumnWidthDensity } from "@/stores/settingsStore";
+
+type CellValue = string | number | boolean | null;
+
+export const DATA_GRID_ROW_NUM_WIDTH = 48;
+
+export function resizeDataGridColumnWidth(startWidth: number, deltaX: number): number {
+  return Math.max(DATA_GRID_COL_MIN_WIDTH, startWidth + deltaX);
+}
+
+export interface UseDataGridColumnResizeOptions {
+  columns: ComputedRef<string[]>;
+  sourceRows: ComputedRef<CellValue[][]>;
+  columnIndexes: ComputedRef<number[]>;
+  density: Ref<ColumnWidthDensity>;
+  compactColumnHeaderActions: ComputedRef<boolean>;
+}
+
+export function useDataGridColumnResize(options: UseDataGridColumnResizeOptions) {
+  const { columns, sourceRows, columnIndexes, density, compactColumnHeaderActions } = options;
+
+  const columnWidths = ref<number[]>([]);
+  let isResizing = false;
+  let previousColumnIndexes: number[] = [];
+
+  function sampleColumnValues(visibleColIdx: number): CellValue[] {
+    const actualColIdx = columnIndexes.value[visibleColIdx];
+    const rows = sourceRows.value;
+    const preset = COLUMN_WIDTH_DENSITY_PRESETS[density.value];
+    const end = Math.min(rows.length, preset.sampleRows);
+    const values: CellValue[] = [];
+    for (let i = 0; i < end; i++) {
+      values.push(rows[i][actualColIdx] ?? null);
+    }
+    return values;
+  }
+
+  function initColumnWidths(force = false) {
+    const previousWidthsByColumnIndex = new Map<number, number>();
+    previousColumnIndexes.forEach((columnIndex, visibleIndex) => {
+      const width = columnWidths.value[visibleIndex];
+      if (width !== undefined) previousWidthsByColumnIndex.set(columnIndex, width);
+    });
+    const nextColumnIndexes = [...columnIndexes.value];
+    if (force || columnWidths.value.length !== columns.value.length || previousColumnIndexes.join("\0") !== nextColumnIndexes.join("\0")) {
+      columnWidths.value = columns.value.map((colName, colIdx) => {
+        if (!force) {
+          const existingWidth = previousWidthsByColumnIndex.get(nextColumnIndexes[colIdx]);
+          if (existingWidth !== undefined) return existingWidth;
+        }
+        return calculateDataGridColumnWidth({
+          columnName: colName,
+          sampleValues: sampleColumnValues(colIdx),
+          density: density.value,
+          compactColumnHeaderActions: compactColumnHeaderActions.value,
+        });
+      });
+    }
+    previousColumnIndexes = nextColumnIndexes;
+  }
+
+  function onResizeStart(colIdx: number, event: MouseEvent) {
+    event.preventDefault();
+    isResizing = true;
+    const startX = event.clientX;
+    const startWidth = columnWidths.value[colIdx] ?? DATA_GRID_COL_MIN_WIDTH;
+    let pendingClientX = startX;
+    let resizeFrame = 0;
+
+    const applyPendingWidth = () => {
+      resizeFrame = 0;
+      columnWidths.value[colIdx] = resizeDataGridColumnWidth(startWidth, pendingClientX - startX);
+    };
+
+    const scheduleWidthUpdate = (clientX: number) => {
+      pendingClientX = clientX;
+      if (resizeFrame) return;
+      resizeFrame = requestAnimationFrame(applyPendingWidth);
+    };
+
+    const cancelPendingFrame = () => {
+      if (!resizeFrame) return;
+      cancelAnimationFrame(resizeFrame);
+      resizeFrame = 0;
+    };
+
+    const onMove = (e: MouseEvent) => {
+      scheduleWidthUpdate(e.clientX);
+    };
+    const onUp = (e: MouseEvent) => {
+      document.removeEventListener("mousemove", onMove);
+      document.removeEventListener("mouseup", onUp);
+      cancelPendingFrame();
+      pendingClientX = e.clientX;
+      applyPendingWidth();
+      requestAnimationFrame(() => {
+        isResizing = false;
+      });
+    };
+    document.addEventListener("mousemove", onMove);
+    document.addEventListener("mouseup", onUp);
+  }
+
+  function autoFitColumn(colIdx: number) {
+    const colName = columns.value[colIdx];
+    if (!colName) return;
+    columnWidths.value[colIdx] = calculateDataGridColumnWidth({
+      columnName: colName,
+      sampleValues: sampleColumnValues(colIdx),
+      maxWidth: DATA_GRID_COL_AUTO_FIT_MAX_WIDTH,
+      valueTextLimit: DATA_GRID_AUTO_FIT_VALUE_TEXT_LIMIT,
+      density: density.value,
+      compactColumnHeaderActions: compactColumnHeaderActions.value,
+    });
+  }
+
+  const renderedColumnWidths = computed(() => columnWidths.value.slice());
+
+  const totalWidth = computed(() => renderedColumnWidths.value.reduce((a, b) => a + b, 0) + DATA_GRID_ROW_NUM_WIDTH);
+
+  const columnVars = computed(() => {
+    const vars: Record<string, string> = {};
+    renderedColumnWidths.value.forEach((w, i) => {
+      vars[`--col-w-${i}`] = `${w}px`;
+    });
+    vars["--row-num-w"] = `${DATA_GRID_ROW_NUM_WIDTH}px`;
+    vars["--total-w"] = `${totalWidth.value}px`;
+    return vars;
+  });
+
+  function getIsResizing() {
+    return isResizing;
+  }
+
+  watch(
+    () => columnIndexes.value.join("\0"),
+    () => initColumnWidths(),
+  );
+  watch([density, compactColumnHeaderActions], () => initColumnWidths(true));
+
+  return {
+    columnWidths,
+    initColumnWidths,
+    onResizeStart,
+    autoFitColumn,
+    renderedColumnWidths,
+    totalWidth,
+    columnVars,
+    getIsResizing,
+  };
+}
diff --git a/apps/desktop/src/composables/useDataGridEditor.ts b/apps/desktop/src/composables/useDataGridEditor.ts
new file mode 100644
index 0000000..5f0409e
--- /dev/null
+++ b/apps/desktop/src/composables/useDataGridEditor.ts
@@ -0,0 +1,1518 @@
+import { ref, computed, nextTick, watch, getCurrentInstance, onActivated, onBeforeUnmount, onDeactivated, onMounted, type ComputedRef, type Ref } from "vue";
+import * as api from "@/lib/backend/api";
+import type { CellValue } from "@/lib/dataGrid/cellValue";
+import { coerceDataGridCellValue, dataGridCellEditorText } from "@/lib/dataGrid/dataGridCellCoercion";
+import { normalizeDataGridSaveError } from "@/lib/dataGrid/dataGridSql";
+import { rowStatusFilterAfterAddingRow, type RowStatusFilter } from "@/lib/dataGrid/gridRowStatus";
+import { supportsDataGridTransaction } from "@/lib/table/tableEditing";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useHistoryStore } from "@/stores/historyStore";
+import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
+import { assessProductionSql, productionContextForDatabase } from "@/lib/database/productionSafety";
+import type { ColumnInfo, DatabaseType } from "@/types/database";
+import { DBX_NEO4J_ELEMENT_ID_COLUMN, DBX_ROWID_COLUMN } from "@/lib/table/tableEditing";
+import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+
+interface RowItem {
+  id: number;
+  sourceIndex?: number;
+  newIndex?: number;
+  data: CellValue[];
+  isNew: boolean;
+  isDraft?: boolean;
+  isDeleted: boolean;
+  isDirtyCol: boolean[];
+  status: string;
+}
+
+export const DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID = Number.MIN_SAFE_INTEGER;
+
+type RowKind = "none" | "existing" | "new" | "draft";
+
+type CommitEditResult =
+  | {
+      changed: false;
+      rowKind: RowKind;
+    }
+  | {
+      changed: true;
+      rowKind: Exclude<RowKind, "none">;
+    };
+
+interface CommitEditOptions {
+  promoteDraft?: boolean;
+  explicitValue?: string | null;
+}
+
+type GridScrollerRef =
+  | HTMLElement
+  | {
+      $el?: HTMLElement;
+      el?: HTMLElement | { value?: HTMLElement };
+      scrollToItem?: (index: number) => void;
+      scrollToPosition?: (position: number) => void;
+    };
+
+export interface CustomSaveHandler {
+  save: (changes: { dirtyRows: Map<number, Map<number, CellValue>>; newRows: CellValue[][]; deletedRows: Set<number>; columns: string[]; rows: CellValue[][] }) => Promise<void>;
+  applySavedChanges?: (changes: { dirtyRows: Map<number, Map<number, CellValue>>; columns: string[] }) => void;
+  preview?: (changes: { dirtyRows: Map<number, Map<number, CellValue>>; newRows: CellValue[][]; deletedRows: Set<number>; columns: string[]; rows: CellValue[][] }) => Promise<string[]>;
+  canInsert?: boolean;
+  canDelete?: boolean;
+  readonlyColumns?: string[];
+  supportsInsert?: boolean;
+  targetLabel?: string;
+}
+
+export interface UseDataGridEditorOptions {
+  result: ComputedRef<{ columns: string[]; rows: CellValue[][] }>;
+  editable: ComputedRef<boolean | undefined>;
+  databaseType: ComputedRef<DatabaseType | undefined>;
+  connectionId: ComputedRef<string | undefined>;
+  database: ComputedRef<string | undefined>;
+  tableMeta: ComputedRef<
+    | {
+        schema?: string;
+        tableName: string;
+        columns: ColumnInfo[];
+        primaryKeys: string[];
+      }
+    | undefined
+  >;
+  sourceColumns?: ComputedRef<Array<string | undefined> | undefined>;
+  canEditExistingRows?: ComputedRef<boolean>;
+  onExecuteSql: ComputedRef<((sql: string) => Promise<void>) | undefined>;
+  customSaveHandler?: ComputedRef<CustomSaveHandler | undefined>;
+  sql: ComputedRef<string | undefined>;
+  searchText: Ref<string>;
+  whereFilterInput: Ref<string>;
+  currentWhereInput: ComputedRef<string | undefined>;
+  orderByInput: Ref<string>;
+  rowStatusFilter: Ref<RowStatusFilter>;
+  dataGridQuickEntryEnabled?: ComputedRef<boolean>;
+  initialEditColumn?: ComputedRef<number>;
+  getRowItem: (rowId: number) => RowItem | undefined;
+  pageSize: Ref<number>;
+  currentPage: Ref<number>;
+  cacheKey?: ComputedRef<string | undefined>;
+  emit: {
+    (event: "reload", sql?: string, searchText?: string, whereInput?: string, orderBy?: string, limit?: number, offset?: number): void;
+  };
+}
+
+interface PendingChangesSnapshot {
+  newRows: CellValue[][];
+  quickEntryDraftRow?: CellValue[];
+  dirtyRows: Map<number, Map<number, CellValue>>;
+  deletedRows: Set<number>;
+  editingCell?: { rowId: number; col: number } | null;
+  editValue?: string;
+  transactionActive?: boolean;
+  scroll?: { top: number; left: number };
+  columnCount: number;
+  rowCount: number;
+}
+
+interface PendingSaveSnapshot {
+  newRows: CellValue[][];
+  newRowRefs: CellValue[][];
+  dirtyRows: Map<number, Map<number, CellValue>>;
+  deletedRows: Set<number>;
+}
+
+interface SaveChangesOptions {
+  autoSave?: boolean;
+}
+
+interface QueuedAutoSaveChange {
+  sourceIndex: number;
+  col: number;
+  value: CellValue;
+}
+
+type PendingChangesHistorySnapshot = Pick<PendingChangesSnapshot, "newRows" | "quickEntryDraftRow" | "dirtyRows" | "deletedRows" | "transactionActive">;
+
+const pendingChangesCache = new Map<string, PendingChangesSnapshot>();
+const closingPendingSnapshotTabs = new Set<string>();
+const BEFORE_TAB_SWITCH_EVENT = "dbx:before-tab-switch";
+const MAX_PENDING_CHANGES_HISTORY = 100;
+
+function dataGridRowsIdentityChanged(previousRows: CellValue[][] | undefined, nextRows: CellValue[][]): boolean {
+  if (!previousRows) return true;
+  if (previousRows.length !== nextRows.length) return true;
+  return previousRows.some((row, index) => row !== nextRows[index]);
+}
+
+function cacheKeyBelongsToTab(cacheKey: string, tabId: string) {
+  return cacheKey === tabId || cacheKey.startsWith(`${tabId}-`);
+}
+
+function closedTabIdForCacheKey(cacheKey: string): string | undefined {
+  for (const tabId of closingPendingSnapshotTabs) {
+    if (cacheKeyBelongsToTab(cacheKey, tabId)) return tabId;
+  }
+  return undefined;
+}
+
+export function clearDataGridPendingSnapshotsForTab(tabId: string) {
+  closingPendingSnapshotTabs.add(tabId);
+  if (typeof window !== "undefined") {
+    window.setTimeout(() => closingPendingSnapshotTabs.delete(tabId), 5000);
+  } else {
+    setTimeout(() => closingPendingSnapshotTabs.delete(tabId), 5000);
+  }
+  pendingChangesCache.delete(tabId);
+  for (const key of pendingChangesCache.keys()) {
+    if (cacheKeyBelongsToTab(key, tabId)) pendingChangesCache.delete(key);
+  }
+}
+
+export function useDataGridEditor(options: UseDataGridEditorOptions) {
+  const connectionStore = useConnectionStore();
+  const historyStore = useHistoryStore();
+  const productionSafetyStore = useProductionSafetyStore();
+
+  const {
+    result,
+    editable,
+    databaseType,
+    connectionId,
+    database,
+    tableMeta,
+    sourceColumns = computed(() => undefined),
+    canEditExistingRows = computed(() => true),
+    onExecuteSql,
+    customSaveHandler,
+    sql,
+    searchText,
+    orderByInput,
+    rowStatusFilter,
+    dataGridQuickEntryEnabled = computed(() => false),
+    initialEditColumn,
+    getRowItem,
+    pageSize,
+    currentPage,
+    cacheKey,
+  } = options;
+
+  const editingCell = ref<{ rowId: number; col: number } | null>(null);
+  const editValue = ref("");
+  const scrollerRef = ref<GridScrollerRef | null>(null);
+  const dirtyRows = ref<Map<number, Map<number, CellValue>>>(new Map());
+  const newRows = ref<CellValue[][]>([]);
+  const deletedRows = ref<Set<number>>(new Set());
+  const quickEntryDraftRow = ref<CellValue[]>([]);
+  const undoStack = ref<PendingChangesHistorySnapshot[]>([]);
+  const redoStack = ref<PendingChangesHistorySnapshot[]>([]);
+  const pendingChangesVersion = ref(0);
+  let restoredEditingCell = false;
+  let restoredTransactionActive = false;
+  let suppressNextBlurCommit = false;
+  let pendingAutoSaveRequested = false;
+  const queuedAutoSaveChanges = new Map<string, QueuedAutoSaveChange>();
+  let draftPromotionScheduled = false;
+  const savingNewRows = new WeakSet<CellValue[]>();
+  let pendingScrollRestore: PendingChangesSnapshot["scroll"] | undefined;
+  let saveScrollSnapshotTimer = 0;
+  let componentActive = true;
+
+  // Restore cached pending changes from a previous instance (e.g. after result eviction + reload)
+  const key = cacheKey?.value;
+  if (key) {
+    const cached = pendingChangesCache.get(key);
+    if (cached && cached.columnCount === result.value.columns.length && cached.rowCount === result.value.rows.length) {
+      newRows.value = cached.newRows;
+      quickEntryDraftRow.value = cached.quickEntryDraftRow ? [...cached.quickEntryDraftRow] : [];
+      dirtyRows.value = cached.dirtyRows;
+      deletedRows.value = cached.deletedRows;
+      editingCell.value = cached.editingCell ?? null;
+      editValue.value = cached.editValue ?? "";
+      restoredEditingCell = !!cached.editingCell;
+      restoredTransactionActive = cached.transactionActive === true;
+      pendingScrollRestore = cached.scroll;
+      pendingChangesCache.delete(key);
+    } else {
+      pendingChangesCache.delete(key);
+    }
+  }
+
+  const dirtyRowCount = computed(() => dirtyRows.value.size);
+  const newRowCount = computed(() => newRows.value.length);
+  const deletedRowCount = computed(() => deletedRows.value.size);
+  const pendingChangeCount = computed(() => dirtyRowCount.value + newRowCount.value + deletedRowCount.value);
+  const hasPendingChanges = computed(() => pendingChangeCount.value > 0);
+  const canUndoPendingChange = computed(() => undoStack.value.length > 0);
+  const canRedoPendingChange = computed(() => redoStack.value.length > 0);
+  const resolvedDatabaseType = computed(() => databaseType.value ?? effectiveDatabaseTypeForConnection(connectionStore.getConfig(connectionId.value ?? "")));
+
+  // --- Transaction state ---
+  const transactionActive = ref(false);
+  const isSaving = ref(false);
+  const saveError = ref("");
+
+  const hasBackendSaveTarget = computed(() => !!connectionId.value && !!tableMeta.value);
+  const useTransaction = computed(() => editable.value && supportsDataGridTransaction(resolvedDatabaseType.value) && (!!customSaveHandler?.value || hasBackendSaveTarget.value));
+
+  if (hasPendingChanges.value && useTransaction.value) {
+    transactionActive.value = true;
+  }
+  if (restoredTransactionActive && useTransaction.value) transactionActive.value = true;
+  if (restoredEditingCell) {
+    focusEditInput();
+  }
+
+  function focusEditInput(select = true) {
+    const focusInput = () => {
+      if (typeof document === "undefined") return;
+      const root = getScrollerElement()?.closest("[data-grid-root]");
+      const input = (root ?? document).querySelector(".cell-edit-input") as HTMLInputElement | HTMLTextAreaElement | null;
+      input?.focus();
+      if (select && input) {
+        if (input instanceof HTMLTextAreaElement && input.dataset.expandedCellEditor === "true") {
+          input.setSelectionRange?.(0, 0);
+          input.scrollTop = 0;
+        } else {
+          input.select();
+          input.setSelectionRange?.(0, input.value.length);
+        }
+      }
+    };
+    nextTick(() => {
+      focusInput();
+      if (typeof requestAnimationFrame === "undefined") return;
+      let attempts = 0;
+      const focusNextFrame = () => {
+        focusInput();
+        attempts += 1;
+        if (attempts < 3) requestAnimationFrame(focusNextFrame);
+      };
+      requestAnimationFrame(focusNextFrame);
+    });
+  }
+
+  function enterTransaction() {
+    transactionActive.value = true;
+  }
+
+  function exitTransaction() {
+    transactionActive.value = false;
+  }
+
+  function touchPendingChanges() {
+    pendingChangesVersion.value++;
+  }
+
+  function pendingChangesSnapshot(): PendingChangesHistorySnapshot {
+    return {
+      newRows: newRows.value.map((row) => [...row]),
+      quickEntryDraftRow: quickEntryDraftRow.value.length > 0 ? [...quickEntryDraftRow.value] : undefined,
+      dirtyRows: new Map([...dirtyRows.value].map(([rowIndex, changes]) => [rowIndex, new Map(changes)])),
+      deletedRows: new Set(deletedRows.value),
+      transactionActive: transactionActive.value,
+    };
+  }
+
+  function restorePendingChangesSnapshot(snapshot: PendingChangesHistorySnapshot) {
+    newRows.value = snapshot.newRows.map((row) => [...row]);
+    quickEntryDraftRow.value = snapshot.quickEntryDraftRow ? [...snapshot.quickEntryDraftRow] : emptyDraftRow();
+    dirtyRows.value = new Map([...snapshot.dirtyRows].map(([rowIndex, changes]) => [rowIndex, new Map(changes)]));
+    deletedRows.value = new Set(snapshot.deletedRows);
+    transactionActive.value = snapshot.transactionActive === true && useTransaction.value === true;
+    queuedAutoSaveChanges.clear();
+    editingCell.value = null;
+    touchPendingChanges();
+  }
+
+  function pushUndoSnapshot() {
+    undoStack.value = [...undoStack.value.slice(-MAX_PENDING_CHANGES_HISTORY + 1), pendingChangesSnapshot()];
+    redoStack.value = [];
+  }
+
+  function clearPendingChangeHistory() {
+    undoStack.value = [];
+    redoStack.value = [];
+  }
+
+  function undoPendingChange() {
+    const snapshot = undoStack.value[undoStack.value.length - 1];
+    if (!snapshot) return;
+    undoStack.value = undoStack.value.slice(0, -1);
+    redoStack.value = [...redoStack.value, pendingChangesSnapshot()];
+    restorePendingChangesSnapshot(snapshot);
+  }
+
+  function redoPendingChange() {
+    const snapshot = redoStack.value[redoStack.value.length - 1];
+    if (!snapshot) return;
+    redoStack.value = redoStack.value.slice(0, -1);
+    undoStack.value = [...undoStack.value, pendingChangesSnapshot()];
+    restorePendingChangesSnapshot(snapshot);
+  }
+
+  // --- Scroll helpers ---
+  let isCancelling = false;
+  let isCommitting = false;
+  let cancelScrollRestoreFrame = 0;
+  let resetScrollFrame = 0;
+  let resetScrollAfterResult = false;
+
+  function getScrollerElement(): HTMLElement | null {
+    const scroller = scrollerRef.value;
+    if (!scroller) return null;
+    if (scroller instanceof HTMLElement) return scroller;
+    if (scroller.$el instanceof HTMLElement) return scroller.$el;
+    if (scroller.el instanceof HTMLElement) return scroller.el;
+    if (scroller.el?.value instanceof HTMLElement) return scroller.el.value;
+    return null;
+  }
+
+  function scrollGridToTop() {
+    const scroller = scrollerRef.value;
+    if (scroller && !(scroller instanceof HTMLElement)) {
+      scroller.scrollToItem?.(0);
+      scroller.scrollToPosition?.(0);
+    }
+    const el = getScrollerElement();
+    if (el) el.scrollTop = 0;
+  }
+
+  function resetGridVerticalScroll(afterResult = false) {
+    if (afterResult) resetScrollAfterResult = true;
+    if (resetScrollFrame) cancelAnimationFrame(resetScrollFrame);
+    scrollGridToTop();
+    nextTick(() => {
+      scrollGridToTop();
+      resetScrollFrame = requestAnimationFrame(() => {
+        scrollGridToTop();
+        resetScrollFrame = 0;
+      });
+    });
+  }
+
+  function preserveScrollPosition() {
+    const el = getScrollerElement();
+    if (!el) return () => {};
+    const top = el.scrollTop;
+    const left = el.scrollLeft;
+    return () => {
+      el.scrollTop = top;
+      el.scrollLeft = left;
+    };
+  }
+
+  function readScrollPosition(): PendingChangesSnapshot["scroll"] | undefined {
+    const el = getScrollerElement();
+    if (!el) return undefined;
+    const top = Math.max(0, el.scrollTop);
+    const left = Math.max(0, el.scrollLeft);
+    if (top === 0 && left === 0) return undefined;
+    return { top, left };
+  }
+
+  function applyScrollPosition(scroll: PendingChangesSnapshot["scroll"] | undefined) {
+    if (!scroll) return;
+    const restoreScroll = () => {
+      const scroller = scrollerRef.value;
+      if (scroller && !(scroller instanceof HTMLElement)) {
+        scroller.scrollToPosition?.(scroll.top);
+      }
+      const el = getScrollerElement();
+      if (!el) return;
+      el.scrollTo?.({ top: scroll.top, left: scroll.left });
+      el.scrollTop = scroll.top;
+      el.scrollLeft = scroll.left;
+    };
+    restoreScrollAcrossFrames(restoreScroll);
+  }
+
+  function recordScrollPosition(scroll = readScrollPosition()) {
+    pendingScrollRestore = scroll;
+    const k = cacheKey?.value;
+    if (!k || typeof window === "undefined") return;
+    if (saveScrollSnapshotTimer) window.clearTimeout(saveScrollSnapshotTimer);
+    saveScrollSnapshotTimer = window.setTimeout(() => {
+      saveScrollSnapshotTimer = 0;
+      savePendingSnapshot(true, true);
+    }, 120);
+  }
+
+  function focusScrollerWithoutScrolling() {
+    const el = getScrollerElement();
+    if (!el) return;
+    if (!el.hasAttribute("tabindex")) el.setAttribute("tabindex", "-1");
+    el.focus({ preventScroll: true });
+  }
+
+  function restoreScrollAcrossFrames(restoreScroll: () => void) {
+    if (cancelScrollRestoreFrame) cancelAnimationFrame(cancelScrollRestoreFrame);
+    restoreScroll();
+    nextTick(() => {
+      restoreScroll();
+      let attempts = 0;
+      const restoreNextFrame = () => {
+        restoreScroll();
+        attempts += 1;
+        if (attempts >= 8) {
+          cancelScrollRestoreFrame = 0;
+          isCancelling = false;
+          return;
+        }
+        cancelScrollRestoreFrame = requestAnimationFrame(restoreNextFrame);
+      };
+      cancelScrollRestoreFrame = requestAnimationFrame(restoreNextFrame);
+    });
+  }
+
+  function getResetScrollAfterResult() {
+    return resetScrollAfterResult;
+  }
+
+  function clearResetScrollAfterResult() {
+    resetScrollAfterResult = false;
+  }
+
+  function cleanupFrames() {
+    if (resetScrollFrame) cancelAnimationFrame(resetScrollFrame);
+    if (cancelScrollRestoreFrame) cancelAnimationFrame(cancelScrollRestoreFrame);
+    if (saveScrollSnapshotTimer) window.clearTimeout(saveScrollSnapshotTimer);
+  }
+
+  // --- Cell value coercion ---
+  function coerceCellValue(value: string, oldValue: CellValue | undefined, columnIndex: number): CellValue {
+    return coerceDataGridCellValue({
+      value,
+      oldValue,
+      databaseType: resolvedDatabaseType.value,
+      columnInfo: tableColumnForGridColumn(columnIndex),
+    }) as CellValue;
+  }
+
+  function tableColumnForGridColumn(columnIndex: number): ColumnInfo | undefined {
+    const columnName = sourceColumns.value?.[columnIndex] ?? result.value.columns[columnIndex];
+    if (!columnName) return undefined;
+    return tableMeta.value?.columns.find((column) => column.name.toLowerCase() === columnName.toLowerCase());
+  }
+
+  function canEditColumn(columnIndex: number): boolean {
+    const sources = sourceColumns.value;
+    return !sources || sources[columnIndex] !== undefined;
+  }
+
+  // --- Row data helpers ---
+  function rowDataWithChanges(row: CellValue[], sourceIndex: number): CellValue[] {
+    const dirty = dirtyRows.value.get(sourceIndex);
+    if (!dirty?.size) return row;
+    return row.map((v, colIdx) => (dirty.has(colIdx) ? dirty.get(colIdx)! : v));
+  }
+
+  function editingSourceRowItem(rowId: number): RowItem | undefined {
+    if (!dataGridQuickEntryEnabled.value || rowId < 0) return undefined;
+    const row = result.value.rows[rowId];
+    if (!row || deletedRows.value.has(rowId)) return undefined;
+    const dirty = dirtyRows.value.get(rowId);
+    return {
+      id: rowId,
+      sourceIndex: rowId,
+      data: rowDataWithChanges(row, rowId),
+      isNew: false,
+      isDeleted: false,
+      isDirtyCol: result.value.columns.map((_, colIdx) => !!dirty?.has(colIdx)),
+      status: dirty?.size ? "edited" : "clean",
+    };
+  }
+
+  function emptyDraftRow(): CellValue[] {
+    return result.value.columns.map(() => null);
+  }
+
+  function ensureQuickEntryDraftRow() {
+    if (quickEntryDraftRow.value.length !== result.value.columns.length) {
+      quickEntryDraftRow.value = emptyDraftRow();
+    }
+  }
+
+  function draftRowHasValue(row = quickEntryDraftRow.value): boolean {
+    return row.some((value) => value !== null && String(value).trim() !== "");
+  }
+
+  function isSavingNewRow(item: Pick<RowItem, "isNew" | "data"> | undefined): boolean {
+    return !!item?.isNew && savingNewRows.has(item.data);
+  }
+
+  function queuedAutoSaveKey(sourceIndex: number, col: number): string {
+    return `${sourceIndex}:${col}`;
+  }
+
+  function rememberQueuedAutoSaveChange(sourceIndex: number, col: number, value: CellValue) {
+    queuedAutoSaveChanges.set(queuedAutoSaveKey(sourceIndex, col), { sourceIndex, col, value });
+  }
+
+  function applyQueuedAutoSaveChanges(savedSnapshot?: PendingSaveSnapshot) {
+    if (queuedAutoSaveChanges.size === 0) return false;
+    let applied = false;
+    for (const change of queuedAutoSaveChanges.values()) {
+      if (deletedRows.value.has(change.sourceIndex) || !canEditExistingRows.value) continue;
+      const oldVal = result.value.rows[change.sourceIndex]?.[change.col];
+      const savedChanges = savedSnapshot?.dirtyRows.get(change.sourceIndex);
+      const baseline = savedChanges?.has(change.col) ? savedChanges.get(change.col) : oldVal;
+      if (change.value !== baseline) {
+        if (!dirtyRows.value.has(change.sourceIndex)) dirtyRows.value.set(change.sourceIndex, new Map());
+        dirtyRows.value.get(change.sourceIndex)!.set(change.col, change.value);
+        applied = true;
+      } else {
+        const rowChanges = dirtyRows.value.get(change.sourceIndex);
+        rowChanges?.delete(change.col);
+        if (rowChanges?.size === 0) dirtyRows.value.delete(change.sourceIndex);
+      }
+    }
+    queuedAutoSaveChanges.clear();
+    dirtyRows.value = new Map(dirtyRows.value);
+    return applied;
+  }
+
+  async function promoteQuickEntryDraftRow() {
+    draftPromotionScheduled = false;
+    ensureQuickEntryDraftRow();
+    if (!draftRowHasValue()) {
+      quickEntryDraftRow.value = emptyDraftRow();
+      return;
+    }
+    rowStatusFilter.value = rowStatusFilterAfterAddingRow(rowStatusFilter.value);
+    newRows.value = [...newRows.value, [...quickEntryDraftRow.value]];
+    quickEntryDraftRow.value = emptyDraftRow();
+    if (useTransaction.value && !transactionActive.value) {
+      enterTransaction();
+    }
+    if (dataGridQuickEntryEnabled.value) {
+      await saveChanges({ autoSave: true });
+    }
+  }
+
+  function scheduleQuickEntryDraftPromotion() {
+    if (draftPromotionScheduled) return;
+    draftPromotionScheduled = true;
+    void Promise.resolve().then(promoteQuickEntryDraftRow);
+  }
+
+  // --- Inline editing ---
+  function startEdit(rowId: number, colIdx: number) {
+    if (!editable.value) return;
+    if (!canEditColumn(colIdx)) return;
+    const item = getRowItem(rowId);
+    if (!item || item.isDeleted) return;
+    if (!item.isNew && !item.isDraft && !canEditExistingRows.value) return;
+    if (isSavingNewRow(item)) return;
+    isCancelling = false;
+    suppressNextBlurCommit = false;
+    editingCell.value = { rowId, col: colIdx };
+    const val = item?.data[colIdx] ?? null;
+    editValue.value = dataGridCellEditorText({
+      value: val,
+      databaseType: resolvedDatabaseType.value,
+      columnInfo: tableColumnForGridColumn(colIdx),
+    });
+    focusEditInput();
+  }
+
+  function commitEdit(options: CommitEditOptions = {}): CommitEditResult {
+    if (isCancelling || isCommitting) return { changed: false, rowKind: "none" };
+    if (!editingCell.value) return { changed: false, rowKind: "none" };
+    isCommitting = true;
+    const { rowId, col } = editingCell.value;
+    const item = getRowItem(rowId) ?? editingSourceRowItem(rowId);
+    if (!item || item.isDeleted) {
+      editingCell.value = null;
+      isCommitting = false;
+      return { changed: false, rowKind: "none" };
+    }
+
+    if (item.isDraft) {
+      ensureQuickEntryDraftRow();
+      const oldVal = quickEntryDraftRow.value[col] ?? null;
+      const newVal = options.explicitValue !== undefined ? options.explicitValue : coerceCellValue(editValue.value, oldVal, col);
+      const nextDraftRow = [...quickEntryDraftRow.value];
+      nextDraftRow[col] = newVal;
+      if (newVal !== oldVal) pushUndoSnapshot();
+      quickEntryDraftRow.value = nextDraftRow;
+      editingCell.value = null;
+      isCommitting = false;
+      if (!draftRowHasValue(nextDraftRow)) {
+        quickEntryDraftRow.value = emptyDraftRow();
+        return { changed: false, rowKind: "draft" };
+      }
+      if (options.promoteDraft === false) {
+        return { changed: false, rowKind: "draft" };
+      }
+      rowStatusFilter.value = rowStatusFilterAfterAddingRow(rowStatusFilter.value);
+      newRows.value = [...newRows.value, nextDraftRow];
+      quickEntryDraftRow.value = emptyDraftRow();
+      touchPendingChanges();
+      if (useTransaction.value && !transactionActive.value) {
+        enterTransaction();
+      }
+      return { changed: true, rowKind: "draft" };
+    }
+
+    if (item.isNew && item.newIndex !== undefined) {
+      const oldVal = newRows.value[item.newIndex]?.[col];
+      const newVal = options.explicitValue !== undefined ? options.explicitValue : coerceCellValue(editValue.value, oldVal, col);
+      const changed = newVal !== oldVal;
+      if (changed) pushUndoSnapshot();
+      if (newRows.value[item.newIndex]) {
+        newRows.value[item.newIndex][col] = newVal;
+      }
+      newRows.value = [...newRows.value];
+      if (changed) touchPendingChanges();
+      editingCell.value = null;
+      isCommitting = false;
+      return changed ? { changed: true, rowKind: "new" } : { changed: false, rowKind: "new" };
+    }
+
+    if (item.sourceIndex === undefined) {
+      editingCell.value = null;
+      isCommitting = false;
+      return { changed: false, rowKind: "none" };
+    }
+    if (!canEditExistingRows.value) {
+      editingCell.value = null;
+      isCommitting = false;
+      return { changed: false, rowKind: "existing" };
+    }
+
+    const oldVal = result.value.rows[item.sourceIndex]?.[col];
+    const newVal = options.explicitValue !== undefined ? options.explicitValue : coerceCellValue(editValue.value, oldVal, col);
+    const changed = newVal !== item.data[col];
+    if (newVal !== oldVal) {
+      if (changed) pushUndoSnapshot();
+      if (!dirtyRows.value.has(item.sourceIndex)) dirtyRows.value.set(item.sourceIndex, new Map());
+      dirtyRows.value.get(item.sourceIndex)!.set(col, newVal);
+      if (useTransaction.value && !transactionActive.value) {
+        enterTransaction();
+      }
+    } else {
+      const rowChanges = dirtyRows.value.get(item.sourceIndex);
+      if (rowChanges?.has(col)) pushUndoSnapshot();
+      rowChanges?.delete(col);
+      if (rowChanges?.size === 0) dirtyRows.value.delete(item.sourceIndex);
+    }
+    dirtyRows.value = new Map(dirtyRows.value);
+    if (changed) touchPendingChanges();
+    editingCell.value = null;
+    isCommitting = false;
+    if (dataGridQuickEntryEnabled.value && isSaving.value && changed) {
+      rememberQueuedAutoSaveChange(item.sourceIndex, col, newVal);
+    }
+    return changed ? { changed: true, rowKind: "existing" } : { changed: false, rowKind: "existing" };
+  }
+
+  async function commitEditAndMaybeAutoSave(options: CommitEditOptions = {}) {
+    const result = commitEdit(options);
+    if (dataGridQuickEntryEnabled.value && options.promoteDraft !== false && result.changed) {
+      await saveChanges({ autoSave: true });
+    }
+  }
+
+  async function commitEditFromBlur(options: CommitEditOptions = {}) {
+    if (suppressNextBlurCommit) {
+      suppressNextBlurCommit = false;
+      return;
+    }
+    await commitEditAndMaybeAutoSave(options);
+  }
+
+  function applyCellValue(rowId: number, col: number, value: string | null) {
+    if (!canEditColumn(col)) return;
+    const item = getRowItem(rowId);
+    if (!item || item.isDeleted) return;
+
+    if (item.isDraft) {
+      ensureQuickEntryDraftRow();
+      const oldVal = quickEntryDraftRow.value[col] ?? null;
+      const nextDraftRow = [...quickEntryDraftRow.value];
+      nextDraftRow[col] = value === null ? null : coerceCellValue(value, oldVal, col);
+      if (nextDraftRow[col] === oldVal) return;
+      pushUndoSnapshot();
+      quickEntryDraftRow.value = draftRowHasValue(nextDraftRow) ? nextDraftRow : emptyDraftRow();
+      touchPendingChanges();
+      scheduleQuickEntryDraftPromotion();
+      return;
+    }
+
+    if (item.isNew && item.newIndex !== undefined) {
+      if (isSavingNewRow(item)) return;
+      const row = newRows.value[item.newIndex];
+      if (!row) return;
+      const oldVal = row[col];
+      const newVal = value === null ? null : coerceCellValue(value, oldVal, col);
+      if (newVal === oldVal) return;
+      pushUndoSnapshot();
+      row[col] = newVal;
+      newRows.value = [...newRows.value];
+      touchPendingChanges();
+      return;
+    }
+
+    if (item.sourceIndex === undefined) return;
+    if (!canEditExistingRows.value) return;
+
+    const oldVal = result.value.rows[item.sourceIndex]?.[col];
+    const rowChanges = dirtyRows.value.get(item.sourceIndex);
+    const hasPendingCellChange = rowChanges?.has(col) ?? false;
+    const currentVal = hasPendingCellChange ? rowChanges!.get(col) : oldVal;
+    const newVal = value === null ? null : coerceCellValue(value, oldVal, col);
+    if (newVal === currentVal) return;
+    if (newVal !== oldVal) {
+      pushUndoSnapshot();
+      if (!dirtyRows.value.has(item.sourceIndex)) dirtyRows.value.set(item.sourceIndex, new Map());
+      dirtyRows.value.get(item.sourceIndex)!.set(col, newVal);
+      if (useTransaction.value && !transactionActive.value) {
+        enterTransaction();
+      }
+    } else {
+      if (hasPendingCellChange) pushUndoSnapshot();
+      rowChanges?.delete(col);
+      if (rowChanges?.size === 0) dirtyRows.value.delete(item.sourceIndex);
+    }
+    dirtyRows.value = new Map(dirtyRows.value);
+    touchPendingChanges();
+  }
+
+  function restoreCellValue(rowId: number, col: number) {
+    if (!canEditColumn(col)) return;
+    const item = getRowItem(rowId);
+    if (!item || item.isDeleted) return;
+
+    if (item.isDraft) {
+      ensureQuickEntryDraftRow();
+      if (quickEntryDraftRow.value[col] === null) return;
+      pushUndoSnapshot();
+      const nextDraftRow = [...quickEntryDraftRow.value];
+      nextDraftRow[col] = null;
+      quickEntryDraftRow.value = draftRowHasValue(nextDraftRow) ? nextDraftRow : emptyDraftRow();
+      touchPendingChanges();
+      return;
+    }
+
+    if (item.isNew && item.newIndex !== undefined) {
+      if (isSavingNewRow(item)) return;
+      const row = newRows.value[item.newIndex];
+      if (!row || row[col] === null) return;
+      pushUndoSnapshot();
+      row[col] = null;
+      newRows.value = [...newRows.value];
+      touchPendingChanges();
+      return;
+    }
+
+    if (item.sourceIndex === undefined) return;
+    if (!canEditExistingRows.value) return;
+    const rowChanges = dirtyRows.value.get(item.sourceIndex);
+    if (!rowChanges?.has(col)) return;
+    pushUndoSnapshot();
+    rowChanges.delete(col);
+    if (rowChanges.size === 0) dirtyRows.value.delete(item.sourceIndex);
+    dirtyRows.value = new Map(dirtyRows.value);
+    touchPendingChanges();
+  }
+
+  function cancelEdit() {
+    const restoreScroll = preserveScrollPosition();
+    isCancelling = true;
+    focusScrollerWithoutScrolling();
+    editingCell.value = null;
+    restoreScrollAcrossFrames(restoreScroll);
+  }
+
+  function onEditKeydown(e: KeyboardEvent) {
+    const isExpandedTextarea = typeof HTMLTextAreaElement !== "undefined" && e.target instanceof HTMLTextAreaElement && e.target.dataset.expandedCellEditor === "true";
+    if (e.key === "Enter" && (!isExpandedTextarea || e.metaKey || e.ctrlKey)) {
+      e.preventDefault();
+      void commitEditAndMaybeAutoSave().finally(() => nextTick(focusScrollerWithoutScrolling));
+    } else if (e.key === "Escape") {
+      e.preventDefault();
+      e.stopPropagation();
+      cancelEdit();
+    }
+  }
+
+  function addRow() {
+    pushUndoSnapshot();
+    rowStatusFilter.value = rowStatusFilterAfterAddingRow(rowStatusFilter.value);
+    newRows.value.push(result.value.columns.map(() => null));
+    newRows.value = [...newRows.value];
+    touchPendingChanges();
+    if (useTransaction.value && !transactionActive.value) {
+      enterTransaction();
+    }
+    const rowId = -newRows.value.length;
+    nextTick(() => {
+      const el = getScrollerElement();
+      if (el) el.scrollTop = el.scrollHeight;
+      startEdit(rowId, initialEditColumn?.value ?? 0);
+    });
+  }
+
+  function clonedRowData(item: RowItem): CellValue[] {
+    const columnInfoByName = new Map((tableMeta.value?.columns ?? []).map((column) => [column.name.toLowerCase(), column]));
+    return item.data.map((val, i) => {
+      const columnName = result.value.columns[i];
+      const columnInfo = columnInfoByName.get(columnName.toLowerCase());
+      return shouldClearClonedColumn(columnName, columnInfo) ? null : val;
+    });
+  }
+
+  function shouldClearClonedColumn(columnName: string, columnInfo: ColumnInfo | undefined): boolean {
+    if (resolvedDatabaseType.value === "oracle" && columnName.toUpperCase() === DBX_ROWID_COLUMN) return true;
+    if (resolvedDatabaseType.value === "neo4j" && columnName === DBX_NEO4J_ELEMENT_ID_COLUMN) return true;
+    const extra = columnInfo?.extra ?? "";
+    const columnDefault = columnInfo?.column_default ?? "";
+    return /\b(auto_increment|autoincrement|identity|generated)\b/i.test(extra) || /\bnextval\s*\(/i.test(columnDefault);
+  }
+
+  function cloneRow(rowId: number) {
+    const item = getRowItem(rowId);
+    if (!item) return;
+    const clonedData = clonedRowData(item);
+    pushUndoSnapshot();
+    rowStatusFilter.value = rowStatusFilterAfterAddingRow(rowStatusFilter.value);
+    newRows.value.push(clonedData);
+    newRows.value = [...newRows.value];
+    touchPendingChanges();
+    if (useTransaction.value && !transactionActive.value) {
+      enterTransaction();
+    }
+    const newRowId = -newRows.value.length;
+    nextTick(() => {
+      const el = getScrollerElement();
+      if (el) el.scrollTop = el.scrollHeight;
+      startEdit(newRowId, initialEditColumn?.value ?? 0);
+    });
+  }
+
+  function cloneRows(rowIds: number[]) {
+    const rowsToClone = rowIds.map((rowId) => getRowItem(rowId)).filter(Boolean) as RowItem[];
+    if (rowsToClone.length === 0) return;
+    pushUndoSnapshot();
+    rowStatusFilter.value = rowStatusFilterAfterAddingRow(rowStatusFilter.value);
+    for (const item of rowsToClone) {
+      const clonedData = clonedRowData(item);
+      newRows.value.push(clonedData);
+    }
+    newRows.value = [...newRows.value];
+    touchPendingChanges();
+    if (useTransaction.value && !transactionActive.value) {
+      enterTransaction();
+    }
+  }
+
+  function applyDeleteRows(rowIds: number[]) {
+    const items = rowIds.map((rowId) => getRowItem(rowId)).filter((item): item is RowItem => !!item);
+    if (items.length === 0) return;
+
+    const newIndexes = new Set<number>();
+    const sourceIndexes = new Set<number>();
+    const deletedRowIds = new Set<number>();
+
+    for (const item of items) {
+      if (item.isNew && item.newIndex !== undefined) {
+        if (isSavingNewRow(item)) continue;
+        newIndexes.add(item.newIndex);
+        deletedRowIds.add(item.id);
+      } else if (item.sourceIndex !== undefined && canEditExistingRows.value) {
+        sourceIndexes.add(item.sourceIndex);
+        deletedRowIds.add(item.id);
+      }
+    }
+
+    if (newIndexes.size === 0 && sourceIndexes.size === 0) return;
+
+    // Batch row deletion into one reactive update so multi-row deletes do not
+    // rebuild the entire grid and undo history once per selected row.
+    pushUndoSnapshot();
+    if (newIndexes.size > 0) {
+      [...newIndexes]
+        .sort((a, b) => b - a)
+        .forEach((newIndex) => {
+          newRows.value.splice(newIndex, 1);
+        });
+      newRows.value = [...newRows.value];
+    }
+    if (sourceIndexes.size > 0) {
+      for (const sourceIndex of sourceIndexes) {
+        dirtyRows.value.delete(sourceIndex);
+        deletedRows.value.add(sourceIndex);
+      }
+      dirtyRows.value = new Map(dirtyRows.value);
+      deletedRows.value = new Set(deletedRows.value);
+    }
+    touchPendingChanges();
+    if (editingCell.value && deletedRowIds.has(editingCell.value.rowId)) editingCell.value = null;
+    if (useTransaction.value && !transactionActive.value) {
+      enterTransaction();
+    }
+  }
+
+  function applyDeleteRow(rowId: number) {
+    applyDeleteRows([rowId]);
+  }
+
+  const showDeleteRowConfirm = ref(false);
+  const pendingDeleteRowId = ref<number | null>(null);
+  const pendingDeleteRowIds = ref<number[]>([]);
+
+  function requestDeleteRow(rowId: number) {
+    pendingDeleteRowId.value = rowId;
+    showDeleteRowConfirm.value = true;
+  }
+
+  function requestDeleteRows(rowIds: number[]) {
+    pendingDeleteRowIds.value = rowIds;
+    showDeleteRowConfirm.value = true;
+  }
+
+  function confirmDeleteRow() {
+    if (pendingDeleteRowIds.value.length > 0) {
+      applyDeleteRows(pendingDeleteRowIds.value);
+      pendingDeleteRowIds.value = [];
+      return;
+    }
+    if (pendingDeleteRowId.value === null) return;
+    applyDeleteRow(pendingDeleteRowId.value);
+    pendingDeleteRowId.value = null;
+  }
+
+  function restoreRow(rowId: number) {
+    const item = getRowItem(rowId);
+    if (item?.sourceIndex !== undefined && deletedRows.value.has(item.sourceIndex)) {
+      pushUndoSnapshot();
+      deletedRows.value.delete(item.sourceIndex);
+      deletedRows.value = new Set(deletedRows.value);
+      touchPendingChanges();
+    }
+  }
+
+  function restoreRows(rowIds: number[]) {
+    const sourceIndexes = rowIds.map((rowId) => getRowItem(rowId)?.sourceIndex).filter((sourceIndex): sourceIndex is number => sourceIndex !== undefined && deletedRows.value.has(sourceIndex));
+    if (sourceIndexes.length === 0) return;
+    pushUndoSnapshot();
+    for (const sourceIndex of sourceIndexes) {
+      deletedRows.value.delete(sourceIndex);
+    }
+    deletedRows.value = new Set(deletedRows.value);
+    touchPendingChanges();
+  }
+
+  function deleteSelectedRow(contextCell: Ref<{ rowId: number; rowIndex: number; col: number } | null>) {
+    if (!contextCell.value) return;
+    requestDeleteRow(contextCell.value.rowId);
+  }
+
+  // --- Save/Discard ---
+  function snapshotPendingSaveChanges(): PendingSaveSnapshot {
+    const currentNewRows = [...newRows.value];
+    return {
+      dirtyRows: new Map([...dirtyRows.value.entries()].map(([rowIndex, changes]) => [rowIndex, new Map(changes)])),
+      newRows: currentNewRows.map((row) => [...row]),
+      newRowRefs: currentNewRows,
+      deletedRows: new Set(deletedRows.value),
+    };
+  }
+
+  function hasPendingSaveChanges(snapshot: PendingSaveSnapshot) {
+    return snapshot.newRows.length > 0 || snapshot.dirtyRows.size > 0 || snapshot.deletedRows.size > 0;
+  }
+
+  function applyDirtyRowsToResult(snapshot: PendingSaveSnapshot) {
+    for (const [sourceIndex, changes] of snapshot.dirtyRows) {
+      const row = result.value.rows[sourceIndex];
+      if (row) {
+        for (const [colIdx, value] of changes) {
+          row[colIdx] = value;
+        }
+      }
+    }
+  }
+
+  function clearSavedPendingChanges(snapshot: PendingSaveSnapshot) {
+    for (const [sourceIndex, changes] of snapshot.dirtyRows) {
+      const liveChanges = dirtyRows.value.get(sourceIndex);
+      if (!liveChanges) continue;
+      for (const [colIdx, savedValue] of changes) {
+        if (liveChanges.get(colIdx) === savedValue) {
+          liveChanges.delete(colIdx);
+        }
+      }
+      if (liveChanges.size === 0) {
+        dirtyRows.value.delete(sourceIndex);
+      }
+    }
+    dirtyRows.value = new Map(dirtyRows.value);
+
+    if (snapshot.newRows.length > 0) {
+      const savedNewRows = new Set(snapshot.newRowRefs);
+      newRows.value = newRows.value.filter((row) => !savedNewRows.has(row));
+    }
+
+    for (const sourceIndex of snapshot.deletedRows) {
+      deletedRows.value.delete(sourceIndex);
+    }
+    deletedRows.value = new Set(deletedRows.value);
+    touchPendingChanges();
+  }
+
+  async function finishSaveChanges(savedSnapshot?: PendingSaveSnapshot) {
+    isSaving.value = false;
+    if (pendingAutoSaveRequested && dataGridQuickEntryEnabled.value) {
+      applyQueuedAutoSaveChanges(savedSnapshot);
+    } else {
+      queuedAutoSaveChanges.clear();
+    }
+    if (!hasPendingChanges.value) {
+      pendingAutoSaveRequested = false;
+      return;
+    }
+    if (pendingAutoSaveRequested && dataGridQuickEntryEnabled.value) {
+      pendingAutoSaveRequested = false;
+      await saveChanges({ autoSave: true });
+    }
+  }
+
+  async function finishInterruptedSaveChanges(snapshot: PendingSaveSnapshot) {
+    snapshot.newRowRefs.forEach((row) => savingNewRows.delete(row));
+    await finishSaveChanges();
+  }
+
+  function saveStatementOptions(snapshot = snapshotPendingSaveChanges()) {
+    if (!tableMeta.value) return null;
+    return {
+      databaseType: resolvedDatabaseType.value,
+      tableMeta: tableMeta.value,
+      columns: result.value.columns,
+      sourceColumns: sourceColumns.value,
+      rows: result.value.rows,
+      dirtyRows: [...snapshot.dirtyRows.entries()].map(([rowIndex, changes]) => [rowIndex, [...changes.entries()]] as [number, Array<[number, CellValue]>]),
+      deletedRows: [...snapshot.deletedRows],
+      newRows: snapshot.newRows,
+    };
+  }
+
+  function tableHistoryTarget() {
+    if (!tableMeta.value) return "";
+    return [tableMeta.value.schema, tableMeta.value.tableName].filter(Boolean).join(".");
+  }
+
+  function dataChangeOperation(snapshot: PendingSaveSnapshot) {
+    const operations = [snapshot.newRows.length > 0 ? "INSERT" : "", snapshot.dirtyRows.size > 0 ? "UPDATE" : "", snapshot.deletedRows.size > 0 ? "DELETE" : ""].filter(Boolean);
+    return operations.length === 1 ? operations[0] : "DATA CHANGE";
+  }
+
+  async function recordDataGridHistory(statements: string[], rollbackStatements: string[], elapsed: number, snapshot: PendingSaveSnapshot, historyResult?: { affected_rows?: number; success?: boolean; error?: string }) {
+    if (!connectionId.value || !tableMeta.value) return;
+    const connName = connectionStore.getConfig(connectionId.value)?.name || "";
+    const success = historyResult?.success ?? true;
+    const details = {
+      schema: tableMeta.value.schema,
+      table: tableMeta.value.tableName,
+      inserted_rows: snapshot.newRows.length,
+      updated_rows: snapshot.dirtyRows.size,
+      deleted_rows: snapshot.deletedRows.size,
+      statements,
+      rollback_statements: success ? rollbackStatements : [],
+      error: success ? undefined : historyResult?.error,
+    };
+    await historyStore.add({
+      connection_id: connectionId.value,
+      connection_name: connName,
+      database: database.value ?? "",
+      sql: statements.join("\n"),
+      execution_time_ms: elapsed,
+      success,
+      error: success ? undefined : historyResult?.error,
+      activity_kind: "data_change",
+      operation: dataChangeOperation(snapshot),
+      target: tableHistoryTarget(),
+      affected_rows: success ? (historyResult?.affected_rows ?? statements.length) : undefined,
+      rollback_sql: success && rollbackStatements.length ? rollbackStatements.join("\n") : undefined,
+      details_json: JSON.stringify(details),
+    });
+  }
+
+  async function recordFailedDataGridHistory(statements: string[], rollbackStatements: string[], start: number, snapshot: PendingSaveSnapshot, error: unknown) {
+    const message = normalizeDataGridSaveError(databaseType.value, error);
+    try {
+      await recordDataGridHistory(statements, rollbackStatements, Date.now() - start, snapshot, {
+        success: false,
+        error: message,
+      });
+    } catch (historyError) {
+      console.warn("[DBX] failed to record data grid history", historyError);
+    }
+    return message;
+  }
+
+  function reloadCurrentData() {
+    options.emit("reload", sql.value, searchText.value, options.currentWhereInput.value, orderByInput.value.trim() || undefined, pageSize.value, (currentPage.value - 1) * pageSize.value);
+  }
+
+  async function saveChanges(saveOptions: SaveChangesOptions = {}) {
+    if (isSaving.value) {
+      if (saveOptions.autoSave) pendingAutoSaveRequested = true;
+      return;
+    }
+    const snapshot = snapshotPendingSaveChanges();
+    if (!hasPendingSaveChanges(snapshot)) {
+      return;
+    }
+    const customHandler = customSaveHandler?.value;
+    const connection = connectionStore.getConfig(connectionId.value ?? "");
+    const customHandlerProductionContext = productionContextForDatabase(connection, database.value);
+    if (customHandler && customHandlerProductionContext.active) {
+      // Custom data sources may not expose SQL, but their row mutations still need the same production interlock.
+      if (saveOptions.autoSave) {
+        return;
+      }
+      const confirmed = await productionSafetyStore.requestConfirmation({
+        sql: describeDataGridChanges(snapshot),
+        connectionName: connection?.name,
+        database: database.value,
+        productionDatabases: customHandlerProductionContext.databases,
+        source: "Data editor",
+      });
+      if (!confirmed) return;
+    }
+    if (customHandler && snapshot.newRows.length > 0 && customHandler.supportsInsert !== true && customHandler.canInsert !== true) {
+      saveError.value = "当前保存目标不支持新增行。";
+      return;
+    }
+    saveError.value = "";
+    isSaving.value = true;
+    snapshot.newRowRefs.forEach((row) => savingNewRows.add(row));
+    const shouldReloadAfterSave = snapshot.newRows.length > 0 || snapshot.deletedRows.size > 0;
+
+    if (customHandler) {
+      try {
+        await customHandler.save({
+          dirtyRows: snapshot.dirtyRows,
+          newRows: snapshot.newRows,
+          deletedRows: snapshot.deletedRows,
+          columns: result.value.columns,
+          rows: result.value.rows,
+        });
+      } catch (e: any) {
+        saveError.value = normalizeDataGridSaveError(databaseType.value, e);
+        await finishInterruptedSaveChanges(snapshot);
+        return;
+      }
+      snapshot.newRowRefs.forEach((row) => savingNewRows.delete(row));
+      customHandler.applySavedChanges?.({ dirtyRows: snapshot.dirtyRows, columns: result.value.columns });
+      applyDirtyRowsToResult(snapshot);
+      clearSavedPendingChanges(snapshot);
+      if (!hasPendingChanges.value) exitTransaction();
+      clearPendingChangeHistory();
+      if (shouldReloadAfterSave) {
+        reloadCurrentData();
+      }
+      await finishSaveChanges(snapshot);
+      return;
+    }
+
+    const stmtOptions = saveStatementOptions(snapshot);
+    let preparedSave: Awaited<ReturnType<typeof api.prepareDataGridSave>> | undefined;
+    if (stmtOptions) {
+      try {
+        preparedSave = await api.prepareDataGridSave(stmtOptions);
+      } catch (e: any) {
+        saveError.value = normalizeDataGridSaveError(databaseType.value, e);
+        await finishInterruptedSaveChanges(snapshot);
+        return;
+      }
+    }
+    if (preparedSave?.validationError) {
+      saveError.value = preparedSave.validationError;
+      await finishInterruptedSaveChanges(snapshot);
+      return;
+    }
+
+    const stmts = preparedSave?.statements ?? [];
+    if (stmts.length === 0) {
+      await finishInterruptedSaveChanges(snapshot);
+      return;
+    }
+    const rollbackStmts = preparedSave?.rollbackStatements ?? [];
+    const productionAssessment = assessProductionSql(stmts.join(";\n"), connection, database.value);
+    if (productionAssessment.active && productionAssessment.isMutation) {
+      // Autosave must never write production data without an operator reviewing the generated statements.
+      if (saveOptions.autoSave) {
+        await finishInterruptedSaveChanges(snapshot);
+        return;
+      }
+      const confirmed = await productionSafetyStore.requestConfirmation({
+        sql: stmts.join("\n"),
+        connectionName: connection?.name,
+        database: database.value,
+        productionDatabases: productionAssessment.databases,
+        source: "Data editor",
+      });
+      if (!confirmed) {
+        await finishInterruptedSaveChanges(snapshot);
+        return;
+      }
+    }
+    const start = Date.now();
+    let apiResult: { affected_rows?: number } | undefined;
+    console.info("[DBX][dataGrid:save-statements]", {
+      databaseType: databaseType.value,
+      table: tableMeta.value ? [tableMeta.value.schema, tableMeta.value.tableName].filter(Boolean).join(".") : undefined,
+      statements: stmts,
+      rollbackStatements: rollbackStmts,
+    });
+
+    if (useTransaction.value && hasBackendSaveTarget.value) {
+      try {
+        apiResult = await api.executeInTransaction(connectionId.value!, database.value ?? "", stmts, preparedSave?.executionSchema);
+      } catch (e: any) {
+        saveError.value = await recordFailedDataGridHistory(stmts, rollbackStmts, start, snapshot, e);
+        await finishInterruptedSaveChanges(snapshot);
+        return;
+      }
+    } else if (hasBackendSaveTarget.value) {
+      try {
+        apiResult = await api.executeBatch(connectionId.value!, database.value ?? "", stmts, preparedSave?.executionSchema);
+      } catch (e: any) {
+        saveError.value = await recordFailedDataGridHistory(stmts, rollbackStmts, start, snapshot, e);
+        await finishInterruptedSaveChanges(snapshot);
+        return;
+      }
+    } else if (onExecuteSql.value) {
+      try {
+        for (const sqlStmt of stmts) {
+          await onExecuteSql.value(sqlStmt);
+        }
+      } catch (e: any) {
+        saveError.value = await recordFailedDataGridHistory(stmts, rollbackStmts, start, snapshot, e);
+        await finishInterruptedSaveChanges(snapshot);
+        return;
+      }
+    }
+    try {
+      await recordDataGridHistory(stmts, rollbackStmts, Date.now() - start, snapshot, apiResult);
+    } catch (e) {
+      console.warn("[DBX] failed to record data grid history", e);
+    }
+    applyDirtyRowsToResult(snapshot);
+    snapshot.newRowRefs.forEach((row) => savingNewRows.delete(row));
+    clearSavedPendingChanges(snapshot);
+    if (!hasPendingChanges.value) exitTransaction();
+    clearPendingChangeHistory();
+    if (shouldReloadAfterSave) {
+      reloadCurrentData();
+    }
+    await finishSaveChanges(snapshot);
+  }
+
+  function discardChanges() {
+    dirtyRows.value.clear();
+    newRows.value = [];
+    deletedRows.value.clear();
+    quickEntryDraftRow.value = emptyDraftRow();
+    queuedAutoSaveChanges.clear();
+    editingCell.value = null;
+    clearPendingChangeHistory();
+    touchPendingChanges();
+    exitTransaction();
+  }
+
+  // Pending changes reference rows by sourceIndex. When the result set changes
+  // (e.g. different WHERE clause, pagination), stale indices point to wrong rows.
+  let previousResultRows = result.value.rows;
+  watch(
+    () => result.value.rows,
+    (rows) => {
+      if (!dataGridRowsIdentityChanged(previousResultRows, rows)) {
+        previousResultRows = rows;
+        return;
+      }
+      previousResultRows = rows;
+      pendingScrollRestore = undefined;
+      discardChanges();
+    },
+  );
+
+  function savePendingSnapshot(includeEditing = false, includeScroll = false) {
+    const k = cacheKey?.value;
+    if (!k) return;
+    if (closedTabIdForCacheKey(k)) {
+      pendingChangesCache.delete(k);
+      return;
+    }
+    const scroll = includeScroll ? (readScrollPosition() ?? pendingScrollRestore) : undefined;
+    if (includeScroll) pendingScrollRestore = scroll;
+    const quickEntryDraftRowSnapshot = draftRowHasValue() ? [...quickEntryDraftRow.value] : undefined;
+    if (!hasPendingChanges.value && !quickEntryDraftRowSnapshot && !(includeEditing && editingCell.value) && !scroll) {
+      pendingChangesCache.delete(k);
+      return;
+    }
+    pendingChangesCache.set(k, {
+      newRows: newRows.value.map((r) => [...r]),
+      quickEntryDraftRow: quickEntryDraftRowSnapshot,
+      dirtyRows: new Map([...dirtyRows.value].map(([i, m]) => [i, new Map(m)])),
+      deletedRows: new Set(deletedRows.value),
+      editingCell: includeEditing && editingCell.value ? { ...editingCell.value } : null,
+      editValue: editValue.value,
+      transactionActive: transactionActive.value,
+      scroll,
+      columnCount: result.value.columns.length,
+      rowCount: result.value.rows.length,
+    });
+  }
+
+  function restorePendingSnapshotFocus() {
+    suppressNextBlurCommit = false;
+    if (editingCell.value) focusEditInput(true);
+    applyScrollPosition(pendingScrollRestore);
+  }
+
+  function onBeforeTabSwitch() {
+    if (!componentActive) return;
+    savePendingSnapshot(true, true);
+    if (editingCell.value) suppressNextBlurCommit = true;
+  }
+
+  const componentInstance = getCurrentInstance();
+  if (componentInstance && typeof window !== "undefined") {
+    window.addEventListener(BEFORE_TAB_SWITCH_EVENT, onBeforeTabSwitch);
+  }
+
+  if (componentInstance) {
+    onMounted(() => {
+      componentActive = true;
+      applyScrollPosition(pendingScrollRestore);
+    });
+    onActivated(() => {
+      componentActive = true;
+      restorePendingSnapshotFocus();
+    });
+    onDeactivated(() => {
+      savePendingSnapshot(true, true);
+      componentActive = false;
+    });
+
+    // Save pending changes before the component is destroyed so they can be
+    // restored if a new DataGrid instance is created for the same tab
+    // (e.g. after result eviction + reload).
+    onBeforeUnmount(() => {
+      savePendingSnapshot(true, true);
+      if (typeof window !== "undefined") {
+        window.removeEventListener(BEFORE_TAB_SWITCH_EVENT, onBeforeTabSwitch);
+      }
+    });
+  }
+
+  // --- SQL Preview for pending changes ---
+  const previewStatements = ref<string[]>([]);
+  const isPreviewLoading = ref(false);
+
+  async function previewChanges(): Promise<string[]> {
+    isPreviewLoading.value = true;
+    previewStatements.value = [];
+    try {
+      if (customSaveHandler?.value) {
+        const preview = customSaveHandler.value.preview;
+        if (preview) return await preview({ dirtyRows: dirtyRows.value, newRows: newRows.value, deletedRows: deletedRows.value, columns: result.value.columns, rows: result.value.rows });
+        return [];
+      }
+      const stmtOptions = saveStatementOptions();
+      if (!stmtOptions) return [];
+      const prepared = await api.prepareDataGridSave(stmtOptions);
+      if (prepared?.validationError) {
+        saveError.value = prepared.validationError;
+        return [];
+      }
+      const stmts = prepared?.statements ?? [];
+      previewStatements.value = stmts;
+      return stmts;
+    } catch (e: any) {
+      saveError.value = normalizeDataGridSaveError(databaseType.value, e);
+      return [];
+    } finally {
+      isPreviewLoading.value = false;
+    }
+  }
+
+  return {
+    editingCell,
+    editValue,
+    scrollerRef,
+    dirtyRows,
+    newRows,
+    deletedRows,
+    quickEntryDraftRow,
+    quickEntryDraftRowId: DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID,
+    dirtyRowCount,
+    newRowCount,
+    deletedRowCount,
+    pendingChangesVersion,
+    pendingChangeCount,
+    hasPendingChanges,
+    transactionActive,
+    isSaving,
+    saveError,
+    useTransaction,
+    enterTransaction,
+    exitTransaction,
+    startEdit,
+    commitEdit,
+    commitEditAndMaybeAutoSave,
+    commitEditFromBlur,
+    applyCellValue,
+    restoreCellValue,
+    cancelEdit,
+    onEditKeydown,
+    addRow,
+    cloneRow,
+    cloneRows,
+    applyDeleteRows,
+    applyDeleteRow,
+    showDeleteRowConfirm,
+    pendingDeleteRowId,
+    pendingDeleteRowIds,
+    requestDeleteRow,
+    requestDeleteRows,
+    confirmDeleteRow,
+    restoreRow,
+    restoreRows,
+    deleteSelectedRow,
+    saveChanges,
+    discardChanges,
+    canUndoPendingChange,
+    canRedoPendingChange,
+    undoPendingChange,
+    redoPendingChange,
+    rowDataWithChanges,
+    ensureQuickEntryDraftRow,
+    draftRowHasValue,
+    isSavingNewRow,
+    coerceCellValue,
+    canEditColumn,
+    resetGridVerticalScroll,
+    getResetScrollAfterResult,
+    clearResetScrollAfterResult,
+    cleanupFrames,
+    recordScrollPosition,
+    previewStatements,
+    isPreviewLoading,
+    previewChanges,
+    savePendingSnapshot,
+    restorePendingSnapshotFocus,
+    syncHeaderScroll: (headerRef: Ref<HTMLDivElement | undefined>) => (e: Event) => {
+      if (headerRef.value) {
+        headerRef.value.scrollLeft = (e.target as HTMLElement).scrollLeft;
+      }
+    },
+  };
+}
+
+function describeDataGridChanges(snapshot: { newRows: unknown[]; dirtyRows: Map<unknown, unknown>; deletedRows: Set<unknown> }): string {
+  const changes = [snapshot.newRows.length ? `INSERT: ${snapshot.newRows.length} row(s)` : "", snapshot.dirtyRows.size ? `UPDATE: ${snapshot.dirtyRows.size} row(s)` : "", snapshot.deletedRows.size ? `DELETE: ${snapshot.deletedRows.size} row(s)` : ""].filter(Boolean);
+  return changes.join("\n") || "DATA GRID WRITE";
+}
diff --git a/apps/desktop/src/composables/useDataGridExport.ts b/apps/desktop/src/composables/useDataGridExport.ts
new file mode 100644
index 0000000..d5bffb4
--- /dev/null
+++ b/apps/desktop/src/composables/useDataGridExport.ts
@@ -0,0 +1,1289 @@
+import { computed, ref, type ComputedRef, type Ref } from "vue";
+import { useI18n } from "vue-i18n";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import * as api from "@/lib/backend/api";
+import { formatSelectionAsCsv, formatSelectionAsJson, formatSelectionAsSqlInList, formatSelectionAsTsv, type CellSelectionRange, type SelectionData } from "@/lib/dataGrid/gridSelection";
+import { useToast } from "@/composables/useToast";
+import { displayCellValue, type CellValue } from "@/lib/dataGrid/cellValue";
+import { tryStartExclusiveActivation, type ActionActivationGuard } from "@/lib/connection/actionActivation";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import { buildDataGridCopyInsertStatement, buildDataGridCopyUpdateStatements, type DataGridCopyInsertMode, type DataGridTableMeta } from "@/lib/dataGrid/dataGridSql";
+import { formatSqlInsert } from "@/lib/export/exportFormats";
+import { uuid } from "@/lib/common/utils";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { expandNestedJsonStringsForCopy } from "@/lib/common/jsonCopyValue";
+import { buildMongoCopyInsertDocument, formatMongoShellLiteral, type MongoInputValue } from "@/lib/mongo/mongoDocumentValues";
+import type { DatabaseType, QueryResult } from "@/types/database";
+import type { QueryResultExportRequest } from "@/lib/backend/api";
+import { DBX_ROWID_COLUMN } from "@/lib/table/tableEditing";
+
+interface RowItem {
+  id: number;
+  sourceIndex?: number;
+  newIndex?: number;
+  data: CellValue[];
+  isNew: boolean;
+  isDraft?: boolean;
+  isDeleted: boolean;
+  isDirtyCol: boolean[];
+  status: string;
+}
+
+export interface UseDataGridExportOptions {
+  columns: ComputedRef<string[]>;
+  displayItems: ComputedRef<RowItem[]>;
+  sql: ComputedRef<string | undefined>;
+  tableMeta: ComputedRef<DataGridTableMeta | undefined>;
+  copyInsertTargetLabel?: ComputedRef<string | undefined>;
+  databaseType: ComputedRef<DatabaseType | undefined>;
+  connectionId: ComputedRef<string | undefined>;
+  database: ComputedRef<string | undefined>;
+  context: ComputedRef<"results" | "table-data" | undefined>;
+  sourceColumns: ComputedRef<Array<string | undefined> | undefined>;
+  columnTypes: ComputedRef<Array<string | undefined> | undefined>;
+  whereInput: ComputedRef<string | undefined>;
+  orderBy: ComputedRef<string | undefined>;
+  exportBatchSize: ComputedRef<number>;
+  hasCellSelection: ComputedRef<boolean>;
+  selectedCells: ComputedRef<SelectionData>;
+  selectedRange: ComputedRef<CellSelectionRange | null>;
+  contextCell: Ref<{ rowId: number; rowIndex: number; col: number } | null> | ComputedRef<{ rowId: number; rowIndex: number; col: number } | null>;
+  getRowItem: (rowId: number) => RowItem | undefined;
+  selectedRowIds: Ref<Set<number>> | ComputedRef<Set<number>>;
+  hasRowSelection: ComputedRef<boolean>;
+  fullExportResult?: (onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void) => Promise<QueryResult | undefined>;
+  queryResultExportRequest?: (options: { exportId: string; filePath: string; format: "csv" | "xlsx" }) => Promise<QueryResultExportRequest | undefined>;
+  /**
+   * True when the in-memory result already holds the complete result set —
+   * i.e. the query ran without server-side pagination, was not truncated, and
+   * has no further pages. When true, full-result exports skip the re-executing
+   * backend/frontend streaming paths and write the local rows directly, so a
+   * slow query is never re-run just to export rows that are already on screen.
+   */
+  hasCompleteLocalResult?: ComputedRef<boolean>;
+  /**
+   * The raw in-memory QueryResult to use for "export all" when
+   * hasCompleteLocalResult is true. Exports the original query result (all
+   * rows, all columns, committed values) so the output matches the original
+   * re-run-SQL semantics — displayItems only covers visible columns and
+   * reflects client-side filters/search and unsaved edits, which would
+   * silently change what "export all data" produces.
+   */
+  completeLocalResult?: ComputedRef<QueryResult | undefined>;
+  allExportResults?: ComputedRef<Array<{ sheetName: string; result: QueryResult }> | undefined>;
+  currentResultLabel?: ComputedRef<string | undefined>;
+  exportFileBaseName?: ComputedRef<string | undefined>;
+  exportProgressDialog?: Ref<boolean>;
+  exportProgressState?: Ref<{
+    title: string;
+    tableName: string;
+    format: string;
+    rowsExported: number;
+    totalRows: number | null;
+    status: string;
+    errorMessage: string | null;
+  }>;
+  exportCancelHandler?: Ref<(() => Promise<void>) | null>;
+}
+
+interface CopyStatementCache {
+  key: string;
+  text: string;
+  loading: boolean;
+  ready: boolean;
+  promise?: Promise<string | undefined>;
+}
+
+export function useDataGridExport(options: UseDataGridExportOptions) {
+  const { t } = useI18n();
+  const { toast } = useToast();
+  const exportGuard: ActionActivationGuard = {};
+  const copyRowInsertCache = ref<CopyStatementCache>({
+    key: "",
+    text: "",
+    loading: false,
+    ready: false,
+  });
+  const copyRowInsertRowByRowCache = ref<CopyStatementCache>({
+    key: "",
+    text: "",
+    loading: false,
+    ready: false,
+  });
+  const copyRowInsertWithoutPrimaryKeysCache = ref<CopyStatementCache>({
+    key: "",
+    text: "",
+    loading: false,
+    ready: false,
+  });
+  const copyRowInsertWithoutPrimaryKeysRowByRowCache = ref<CopyStatementCache>({
+    key: "",
+    text: "",
+    loading: false,
+    ready: false,
+  });
+  const copyRowUpdateCache = ref<CopyStatementCache>({
+    key: "",
+    text: "",
+    loading: false,
+    ready: false,
+  });
+
+  const {
+    columns,
+    displayItems,
+    sql,
+    tableMeta,
+    copyInsertTargetLabel,
+    sourceColumns,
+    databaseType,
+    connectionId,
+    database,
+    context,
+    whereInput,
+    orderBy,
+    columnTypes,
+    exportBatchSize,
+    hasCellSelection,
+    selectedCells,
+    selectedRange,
+    contextCell,
+    getRowItem,
+    selectedRowIds,
+    hasRowSelection,
+    fullExportResult,
+    queryResultExportRequest,
+    hasCompleteLocalResult,
+    completeLocalResult,
+    allExportResults,
+    currentResultLabel,
+    exportFileBaseName,
+    exportProgressDialog,
+    exportProgressState,
+    exportCancelHandler,
+  } = options;
+
+  async function copyText(text: string) {
+    try {
+      await copyToClipboard(text);
+      toast(t("grid.copied"));
+    } catch (e: any) {
+      toast(t("grid.copyFailed", { message: e?.message || String(e) }), 5000);
+    }
+  }
+
+  function rowsToExport(rowIds?: number[]): RowItem[] {
+    if (rowIds === undefined) return displayItems.value.filter((item) => !item.isDraft);
+    const rowIdSet = new Set(rowIds);
+    return displayItems.value.filter((item) => rowIdSet.has(item.id) && !item.isDraft);
+  }
+
+  async function resultToExport(rowIds?: number[], onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void, useFullExport = true): Promise<{ columns: string[]; columnTypes: string[]; rows: CellValue[][] }> {
+    if (useFullExport && rowIds === undefined && fullExportResult && !hasCompleteLocalResult?.value) {
+      const result = await fullExportResult(onProgress);
+      if (result) return { columns: result.columns, columnTypes: result.column_types ?? [], rows: result.rows };
+    }
+    // The full result is already in memory — export the raw QueryResult (all
+    // rows, all columns, committed values) so "export all data" matches the
+    // original re-run-SQL semantics. displayItems only covers visible columns
+    // and reflects client-side filters/search and unsaved edits, which would
+    // silently change what the export contains.
+    if (useFullExport && rowIds === undefined && hasCompleteLocalResult?.value && completeLocalResult?.value) {
+      return { columns: completeLocalResult.value.columns, columnTypes: completeLocalResult.value.column_types ?? [], rows: completeLocalResult.value.rows };
+    }
+    return {
+      columns: columns.value,
+      columnTypes: (columnTypes.value ?? []).map((type) => type ?? ""),
+      rows: rowsToExport(rowIds).map((item) => item.data),
+    };
+  }
+
+  function currentXlsxSheetName(): string {
+    return currentResultLabel?.value || tableMeta.value?.tableName || "Export";
+  }
+
+  function targetedRows(): RowItem[] {
+    if (hasRowSelection.value && selectedRowIds.value.size > 0) {
+      return displayItems.value.filter((item) => selectedRowIds.value.has(item.id) && !item.isDraft);
+    }
+    const range = selectedRange.value;
+    if (range && range.startRow !== range.endRow) {
+      return displayItems.value.slice(range.startRow, range.endRow + 1).filter((item) => !item.isDraft);
+    }
+    if (!contextCell.value) return [];
+    const item = getRowItem(contextCell.value.rowId);
+    return item && !item.isDraft ? [item] : [];
+  }
+
+  function updateEligibleRows(): RowItem[] {
+    return targetedRows().filter((item) => !item.isNew && !item.isDraft && !item.isDeleted);
+  }
+
+  function updateCopyKey(): string {
+    const rows = copyStatementRowsKey(updateEligibleRows());
+    return JSON.stringify({
+      databaseType: databaseType.value ?? null,
+      schema: tableMeta.value?.schema ?? null,
+      tableName: tableMeta.value?.tableName ?? null,
+      primaryKeys: tableMeta.value?.primaryKeys ?? [],
+      columns: columns.value,
+      sourceColumns: sourceColumns.value ?? null,
+      rows,
+    });
+  }
+
+  function insertCopyKey(excludePrimaryKeys: boolean, insertMode: DataGridCopyInsertMode): string {
+    const rows = copyStatementRowsKey(insertEligibleRows());
+    return JSON.stringify({
+      databaseType: databaseType.value ?? null,
+      schema: tableMeta.value?.schema ?? null,
+      tableName: tableMeta.value?.tableName ?? null,
+      copyInsertTargetLabel: copyInsertTargetLabel?.value ?? null,
+      columns: columns.value,
+      columnTypes: columnTypes.value ?? null,
+      sourceColumns: sourceColumns.value ?? null,
+      excludePrimaryKeys,
+      insertMode,
+      rows,
+    });
+  }
+
+  function copyStatementRowsKey(rows: RowItem[]): Array<{ id: number; data: CellValue[] }> {
+    // Prepared copy SQL depends on current cell values; edited rows keep the same id while their data changes.
+    return rows.map((item) => ({ id: item.id, data: item.data }));
+  }
+
+  function insertCopyCache(excludePrimaryKeys: boolean, insertMode: DataGridCopyInsertMode): CopyStatementCache {
+    if (excludePrimaryKeys) {
+      return insertMode === "row-by-row" ? copyRowInsertWithoutPrimaryKeysRowByRowCache.value : copyRowInsertWithoutPrimaryKeysCache.value;
+    }
+    return insertMode === "row-by-row" ? copyRowInsertRowByRowCache.value : copyRowInsertCache.value;
+  }
+
+  function setInsertCopyCache(excludePrimaryKeys: boolean, insertMode: DataGridCopyInsertMode, cache: CopyStatementCache) {
+    if (excludePrimaryKeys) {
+      if (insertMode === "row-by-row") {
+        copyRowInsertWithoutPrimaryKeysRowByRowCache.value = cache;
+      } else {
+        copyRowInsertWithoutPrimaryKeysCache.value = cache;
+      }
+    } else if (insertMode === "row-by-row") {
+      copyRowInsertRowByRowCache.value = cache;
+    } else {
+      copyRowInsertCache.value = cache;
+    }
+  }
+
+  function setUpdateCopyCache(cache: CopyStatementCache) {
+    copyRowUpdateCache.value = cache;
+  }
+
+  async function prefetchRowAsInsertStatement(excludePrimaryKeys: boolean, insertMode: DataGridCopyInsertMode = "merged") {
+    try {
+      await prepareRowAsInsertStatement(excludePrimaryKeys, insertMode);
+    } catch {
+      // Prefetch failures are reported only if the user invokes the copy action.
+    }
+  }
+
+  async function prepareRowAsInsertStatement(excludePrimaryKeys: boolean, insertMode: DataGridCopyInsertMode = "merged"): Promise<string | undefined> {
+    const rows = insertEligibleRows();
+    if (!rows.length) {
+      setInsertCopyCache(excludePrimaryKeys, insertMode, {
+        key: "",
+        text: "",
+        loading: false,
+        ready: false,
+      });
+      return;
+    }
+    const key = insertCopyKey(excludePrimaryKeys, insertMode);
+    const current = insertCopyCache(excludePrimaryKeys, insertMode);
+    if (current.ready && current.key === key) return current.text;
+    if (current.loading && current.key === key && current.promise) return current.promise;
+
+    const promise = Promise.resolve().then(async () => {
+      const statement =
+        databaseType.value === "mongodb"
+          ? buildMongoCopyInsertStatement({
+              collection: copyInsertTargetLabel?.value || tableMeta.value?.tableName || "collection",
+              columns: columns.value,
+              sourceColumns: sourceColumns.value,
+              rows: rows.map((item) => item.data),
+              excludePrimaryKeys,
+              insertMode,
+            })
+          : await buildDataGridCopyInsertStatement({
+              databaseType: databaseType.value,
+              tableMeta: tableMeta.value,
+              columns: columns.value,
+              columnTypes: columnTypes.value,
+              sourceColumns: sourceColumns.value,
+              rows: rows.map((item) => item.data),
+              excludePrimaryKeys,
+              insertMode,
+            });
+      const latest = insertCopyCache(excludePrimaryKeys, insertMode);
+      if (latest.key !== key || latest.promise !== promise) return undefined;
+      setInsertCopyCache(excludePrimaryKeys, insertMode, {
+        key,
+        text: statement ?? "",
+        loading: false,
+        ready: !!statement,
+      });
+      return statement;
+    });
+
+    setInsertCopyCache(excludePrimaryKeys, insertMode, {
+      key,
+      text: "",
+      loading: true,
+      ready: false,
+      promise,
+    });
+
+    try {
+      return await promise;
+    } catch (error) {
+      const latest = insertCopyCache(excludePrimaryKeys, insertMode);
+      if (latest.key === key && latest.promise === promise) {
+        setInsertCopyCache(excludePrimaryKeys, insertMode, {
+          key,
+          text: "",
+          loading: false,
+          ready: false,
+        });
+      }
+      throw error;
+    }
+  }
+
+  function canCopyPreparedInsert(excludePrimaryKeys: boolean, insertMode: DataGridCopyInsertMode = "merged"): boolean {
+    const cache = insertCopyCache(excludePrimaryKeys, insertMode);
+    return cache.ready && cache.key === insertCopyKey(excludePrimaryKeys, insertMode);
+  }
+
+  async function copyPreparedRowAsInsert(excludePrimaryKeys: boolean, insertMode: DataGridCopyInsertMode = "merged"): Promise<boolean> {
+    try {
+      const statement = await prepareRowAsInsertStatement(excludePrimaryKeys, insertMode);
+      if (!statement) return false;
+      await copyText(statement);
+      return true;
+    } catch (error: any) {
+      toast(t("grid.copyFailed", { message: error?.message || String(error) }), 5000);
+      return false;
+    }
+  }
+
+  async function prefetchRowAsUpdateStatement() {
+    try {
+      await prepareRowAsUpdateStatement();
+    } catch {
+      // Prefetch failures are reported only if the user invokes the copy action.
+    }
+  }
+
+  async function prepareRowAsUpdateStatement(): Promise<string | undefined> {
+    const currentTableMeta = tableMeta.value;
+    if (!currentTableMeta?.primaryKeys.length) {
+      setUpdateCopyCache({
+        key: "",
+        text: "",
+        loading: false,
+        ready: false,
+      });
+      return;
+    }
+    const rows = updateEligibleRows();
+    if (!rows.length) {
+      setUpdateCopyCache({
+        key: "",
+        text: "",
+        loading: false,
+        ready: false,
+      });
+      return;
+    }
+    const key = updateCopyKey();
+    const current = copyRowUpdateCache.value;
+    if (current.ready && current.key === key) return current.text;
+    if (current.loading && current.key === key && current.promise) return current.promise;
+
+    const promise = Promise.resolve().then(async () => {
+      const statements = await buildDataGridCopyUpdateStatements({
+        databaseType: databaseType.value,
+        tableMeta: currentTableMeta,
+        columns: columns.value,
+        sourceColumns: sourceColumns.value,
+        rows: rows.map((item) => item.data),
+      });
+      const latest = copyRowUpdateCache.value;
+      if (latest.key !== key || latest.promise !== promise) return undefined;
+      const text = statements.join("\n");
+      setUpdateCopyCache({
+        key,
+        text,
+        loading: false,
+        ready: statements.length > 0,
+      });
+      return text || undefined;
+    });
+
+    setUpdateCopyCache({
+      key,
+      text: "",
+      loading: true,
+      ready: false,
+      promise,
+    });
+
+    try {
+      return await promise;
+    } catch (error) {
+      const latest = copyRowUpdateCache.value;
+      if (latest.key === key && latest.promise === promise) {
+        setUpdateCopyCache({
+          key,
+          text: "",
+          loading: false,
+          ready: false,
+        });
+      }
+      throw error;
+    }
+  }
+
+  function canCopyPreparedUpdate(): boolean {
+    const cache = copyRowUpdateCache.value;
+    return cache.ready && cache.key === updateCopyKey();
+  }
+
+  async function copyPreparedRowAsUpdate(): Promise<boolean> {
+    try {
+      const statement = await prepareRowAsUpdateStatement();
+      if (!statement) return false;
+      await copyText(statement);
+      return true;
+    } catch (error: any) {
+      toast(t("grid.copyFailed", { message: error?.message || String(error) }), 5000);
+      return false;
+    }
+  }
+
+  // --- Selection copy functions ---
+  async function copySelectionTsv() {
+    if (!hasCellSelection.value) return;
+    await copyText(formatSelectionAsTsv(selectedCells.value));
+  }
+
+  async function copySelectionTsvWithHeaders() {
+    if (!hasCellSelection.value) return;
+    await copyText(formatSelectionAsTsv(selectedCells.value, true));
+  }
+
+  async function copySelectionCsv() {
+    if (!hasCellSelection.value) return;
+    await copyText(formatSelectionAsCsv(selectedCells.value));
+  }
+
+  async function copySelectionJson() {
+    if (!hasCellSelection.value) return;
+    await copyText(formatSelectionAsJson(selectedCells.value));
+  }
+
+  async function copySelectionSqlInList() {
+    if (!hasCellSelection.value) return;
+    await copyText(formatSelectionAsSqlInList(selectedCells.value));
+  }
+
+  async function copySelectedRowsTsv() {
+    if (!hasRowSelection.value || selectedRowIds.value.size === 0) return;
+    const rows = displayItems.value.filter((item) => selectedRowIds.value.has(item.id) && !item.isDraft).map((item) => item.data);
+    if (rows.length === 0) return;
+    await copyText(formatSelectionAsTsv({ columns: columns.value, rows }));
+  }
+
+  async function copySelectedRowsTsvWithHeaders() {
+    if (!hasRowSelection.value || selectedRowIds.value.size === 0) return;
+    const rows = displayItems.value.filter((item) => selectedRowIds.value.has(item.id) && !item.isDraft).map((item) => item.data);
+    if (rows.length === 0) return;
+    await copyText(formatSelectionAsTsv({ columns: columns.value, rows }, true));
+  }
+
+  async function copyColumnNames() {
+    if (columns.value.length === 0) return;
+    await copyText(columns.value.join("\t"));
+  }
+
+  function rowToJsonObject(item: RowItem): Record<string, unknown> {
+    const obj: Record<string, unknown> = {};
+    columns.value.forEach((col, i) => {
+      obj[col] = item.data[i];
+    });
+    return obj;
+  }
+
+  async function copyRowsAsJson(items: RowItem[]) {
+    if (items.length === 0) return;
+    const value = items.length === 1 ? rowToJsonObject(items[0]) : items.map(rowToJsonObject);
+    const copyValue = options.databaseType.value === "mongodb" ? expandNestedJsonStringsForCopy(value) : value;
+    await copyText(JSON.stringify(copyValue, null, 2));
+  }
+
+  // --- Cell/row copy ---
+  async function copyCell() {
+    if (!contextCell.value || contextCell.value.col < 0) return;
+    const item = getRowItem(contextCell.value.rowId);
+    if (!item || item.isDraft) return;
+    const val = item?.data[contextCell.value.col] ?? null;
+    await copyText(displayCellValue(val));
+  }
+
+  async function copyRow() {
+    if (hasRowSelection.value && selectedRowIds.value.size > 0) {
+      const items = displayItems.value.filter((item) => selectedRowIds.value.has(item.id) && !item.isDraft);
+      await copyRowsAsJson(items);
+      return;
+    }
+    const range = selectedRange.value;
+    if (range && range.startRow !== range.endRow) {
+      const items = displayItems.value.slice(range.startRow, range.endRow + 1).filter((item) => !item.isDraft);
+      await copyRowsAsJson(items);
+      return;
+    }
+    if (!contextCell.value) return;
+    const item = getRowItem(contextCell.value.rowId);
+    if (!item || item.isDraft) return;
+    await copyRowsAsJson([item]);
+  }
+
+  function insertEligibleRows(): RowItem[] {
+    return targetedRows().filter((item) => !item.isDraft);
+  }
+
+  async function copyRowAsInsert(insertMode: DataGridCopyInsertMode = "merged") {
+    await copyPreparedRowAsInsert(false, insertMode);
+  }
+
+  async function copyRowAsInsertWithoutPrimaryKeys(insertMode: DataGridCopyInsertMode = "merged") {
+    await copyPreparedRowAsInsert(true, insertMode);
+  }
+
+  async function copyRowAsUpdate() {
+    await copyPreparedRowAsUpdate();
+  }
+
+  const canCopyRowAsUpdate = computed(() => {
+    if (!tableMeta.value?.primaryKeys.length) return false;
+    const rows = updateEligibleRows();
+    if (!rows.length) return false;
+    if (databaseType.value === "neo4j" || databaseType.value === "tdengine") return false;
+    const saveColumns = effectiveColumns(sourceColumns.value, columns.value);
+    const primaryKeys = tableMeta.value.primaryKeys;
+    if (primaryKeys.some((primaryKey) => findColumnIndex(saveColumns, primaryKey) === -1)) return false;
+    const primaryKeySet = new Set(primaryKeys.map(normalizeColumnName));
+    return saveColumns.some((column) => column && !primaryKeySet.has(normalizeColumnName(column)));
+  });
+
+  function insertableCopyColumnCount(excludePrimaryKeys: boolean): number {
+    const primaryKeySet = new Set((tableMeta.value?.primaryKeys ?? []).map(normalizeColumnName));
+    return effectiveColumns(sourceColumns.value, columns.value).filter((column): column is string => !!column && !isCopyInsertOmittedColumn(databaseType.value, column, tableMeta.value) && (!excludePrimaryKeys || !primaryKeySet.has(normalizeColumnName(column)))).length;
+  }
+
+  const canCopyRowAsInsert = computed(() => insertEligibleRows().length > 0 && insertableCopyColumnCount(false) > 0);
+
+  const canCopyRowAsInsertWithoutPrimaryKeys = computed(() => {
+    if (!tableMeta.value?.primaryKeys.length) return false;
+    const rows = insertEligibleRows();
+    if (!rows.length) return false;
+    const insertableCount = insertableCopyColumnCount(false);
+    const insertColumnsCount = insertableCopyColumnCount(true);
+    return insertColumnsCount > 0 && insertColumnsCount < insertableCount;
+  });
+
+  async function copyAll() {
+    const header = columns.value.join("\t");
+    const body = displayItems.value
+      .filter((item) => !item.isDraft)
+      .map((item) => item.data.map((c) => displayCellValue(c)).join("\t"))
+      .join("\n");
+    await copyText(`${header}\n${body}`);
+  }
+
+  // --- Export functions ---
+  async function runExclusiveExport(action: () => Promise<void>) {
+    const finish = tryStartExclusiveActivation(exportGuard);
+    if (!finish) return;
+    try {
+      await action();
+    } finally {
+      finish();
+    }
+  }
+
+  async function exportCsv(rowIds?: number[]) {
+    await runExclusiveExport(async () => {
+      try {
+        if (await exportQueryResultViaBackend("csv", rowIds)) return;
+        if (await exportFullTableDataViaBackend("csv", rowIds)) return;
+
+        const needsFullExport = rowIds === undefined && !!fullExportResult && !hasCompleteLocalResult?.value;
+        if (needsFullExport && exportProgressDialog && exportProgressState) {
+          exportProgressState.value = {
+            title: t("exportProgress.title"),
+            tableName: tableMeta.value?.tableName || "",
+            format: "csv",
+            rowsExported: 0,
+            totalRows: null,
+            status: "Running",
+            errorMessage: null,
+          };
+          exportProgressDialog.value = true;
+        }
+        const result = await resultToExport(rowIds, (info) => {
+          if (needsFullExport && exportProgressState && exportProgressState.value.status === "Running") {
+            // Guard against the COUNT estimate being too low: if the real
+            // fetched count exceeds it, bump totalRows so the progress bar
+            // never shows 100 % while data is still being fetched.
+            const adjustedTotal = info.totalRows !== null && info.rowsExported > info.totalRows ? info.rowsExported : info.totalRows;
+            exportProgressState.value = {
+              ...exportProgressState.value,
+              rowsExported: info.rowsExported,
+              totalRows: adjustedTotal,
+            };
+          }
+        });
+        // Hand the raw rows straight to the Rust command. Formatting (NULL→"",
+        // bool/number→text, etc.) happens there on a spawn_blocking thread, so
+        // we avoid mapping every cell synchronously on the UI thread.
+        const rows = result.rows;
+        if (needsFullExport && exportProgressState) {
+          exportProgressState.value = {
+            ...exportProgressState.value,
+            status: "Writing",
+            rowsExported: result.rows.length,
+            totalRows: result.rows.length,
+          };
+        }
+        let outputPath = exportFileName("export", "csv");
+        if (isTauriRuntime()) {
+          const { save } = await import("@tauri-apps/plugin-dialog");
+          const path = await save({
+            defaultPath: outputPath,
+            filters: [{ name: "CSV", extensions: ["csv"] }],
+          });
+          if (!path) {
+            if (exportProgressDialog) exportProgressDialog.value = false;
+            return;
+          }
+          outputPath = path as string;
+        }
+        await api.exportQueryResultCsv(outputPath, result.columns, rows);
+        if (needsFullExport && exportProgressState) {
+          exportProgressState.value = {
+            ...exportProgressState.value,
+            status: "Done",
+            rowsExported: result.rows.length,
+            totalRows: result.rows.length,
+          };
+        }
+        toast(t("grid.exported"));
+      } catch (e: any) {
+        if (exportProgressState) {
+          exportProgressState.value = {
+            ...exportProgressState.value,
+            status: "Error",
+            errorMessage: e?.message || String(e),
+          };
+        }
+        toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+      }
+    });
+  }
+
+  async function exportCurrentPageCsv() {
+    await runExclusiveExport(async () => {
+      try {
+        let outputPath = exportFileName("export-page", "csv", { page: true });
+        if (isTauriRuntime()) {
+          const { save } = await import("@tauri-apps/plugin-dialog");
+          const path = await save({
+            defaultPath: outputPath,
+            filters: [{ name: "CSV", extensions: ["csv"] }],
+          });
+          if (!path) return;
+          outputPath = path as string;
+        }
+        const result = await resultToExport(undefined, undefined, false);
+        await api.exportQueryResultCsv(outputPath, result.columns, result.rows);
+        toast(t("grid.exported"));
+      } catch (e: any) {
+        toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+      }
+    });
+  }
+
+  async function exportJson(rowIds?: number[]) {
+    await runExclusiveExport(async () => {
+      try {
+        if (await exportFullTableDataViaBackend("json", rowIds)) return;
+
+        let outputPath = exportFileName("export", "json");
+        if (isTauriRuntime()) {
+          const { save } = await import("@tauri-apps/plugin-dialog");
+          const path = await save({
+            defaultPath: outputPath,
+            filters: [{ name: "JSON", extensions: ["json"] }],
+          });
+          if (!path) return;
+          outputPath = path as string;
+        }
+        const result = await resultToExport(rowIds);
+        await api.exportQueryResultJson(outputPath, result.columns, result.rows);
+        toast(t("grid.exported"));
+      } catch (e: any) {
+        toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+      }
+    });
+  }
+
+  async function exportCurrentPageJson() {
+    await runExclusiveExport(async () => {
+      try {
+        let outputPath = exportFileName("export-page", "json", { page: true });
+        if (isTauriRuntime()) {
+          const { save } = await import("@tauri-apps/plugin-dialog");
+          const path = await save({
+            defaultPath: outputPath,
+            filters: [{ name: "JSON", extensions: ["json"] }],
+          });
+          if (!path) return;
+          outputPath = path as string;
+        }
+        const result = await resultToExport(undefined, undefined, false);
+        await api.exportQueryResultJson(outputPath, result.columns, result.rows);
+        toast(t("grid.exported"));
+      } catch (e: any) {
+        toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+      }
+    });
+  }
+
+  async function exportMarkdown(rowIds?: number[]) {
+    await runExclusiveExport(async () => {
+      try {
+        if (await exportFullTableDataViaBackend("markdown", rowIds)) return;
+
+        let outputPath = exportFileName("export", "md");
+        if (isTauriRuntime()) {
+          const { save } = await import("@tauri-apps/plugin-dialog");
+          const path = await save({
+            defaultPath: outputPath,
+            filters: [{ name: "Markdown", extensions: ["md"] }],
+          });
+          if (!path) return;
+          outputPath = path as string;
+        }
+        const result = await resultToExport(rowIds);
+        await api.exportQueryResultMarkdown(outputPath, result.columns, result.rows);
+        toast(t("grid.exported"));
+      } catch (e: any) {
+        toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+      }
+    });
+  }
+
+  async function exportCurrentPageMarkdown() {
+    await runExclusiveExport(async () => {
+      try {
+        let outputPath = exportFileName("export-page", "md", { page: true });
+        if (isTauriRuntime()) {
+          const { save } = await import("@tauri-apps/plugin-dialog");
+          const path = await save({
+            defaultPath: outputPath,
+            filters: [{ name: "Markdown", extensions: ["md"] }],
+          });
+          if (!path) return;
+          outputPath = path as string;
+        }
+        const result = await resultToExport(undefined, undefined, false);
+        await api.exportQueryResultMarkdown(outputPath, result.columns, result.rows);
+        toast(t("grid.exported"));
+      } catch (e: any) {
+        toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+      }
+    });
+  }
+
+  async function exportXlsx(rowIds?: number[]) {
+    await runExclusiveExport(async () => {
+      try {
+        if (await exportQueryResultViaBackend("xlsx", rowIds)) return;
+        if (await exportFullTableDataViaBackend("xlsx", rowIds)) return;
+
+        let outputPath = exportFileName("export", "xlsx");
+        if (isTauriRuntime()) {
+          const { save } = await import("@tauri-apps/plugin-dialog");
+          const path = await save({
+            defaultPath: outputPath,
+            filters: [{ name: "Excel", extensions: ["xlsx"] }],
+          });
+          if (!path) return;
+          outputPath = path as string;
+        }
+        const needsFullExport = rowIds === undefined && !!fullExportResult && !hasCompleteLocalResult?.value;
+        if (needsFullExport && exportProgressDialog && exportProgressState) {
+          exportProgressState.value = {
+            title: t("exportProgress.title"),
+            tableName: tableMeta.value?.tableName || "",
+            format: "xlsx",
+            rowsExported: 0,
+            totalRows: null,
+            status: "Running",
+            errorMessage: null,
+          };
+          exportProgressDialog.value = true;
+        }
+        const result = await resultToExport(rowIds, (info) => {
+          if (needsFullExport && exportProgressState && exportProgressState.value.status === "Running") {
+            const adjustedTotal = info.totalRows !== null && info.rowsExported > info.totalRows ? info.rowsExported : info.totalRows;
+            exportProgressState.value = {
+              ...exportProgressState.value,
+              rowsExported: info.rowsExported,
+              totalRows: adjustedTotal,
+            };
+          }
+        });
+        if (needsFullExport && exportProgressState) {
+          exportProgressState.value = {
+            ...exportProgressState.value,
+            status: "Writing",
+            rowsExported: result.rows.length,
+            totalRows: result.rows.length,
+          };
+        }
+        await api.exportQueryResultXlsx(outputPath, currentXlsxSheetName(), result.columns, result.columnTypes, result.rows);
+        if (needsFullExport && exportProgressState) {
+          exportProgressState.value = {
+            ...exportProgressState.value,
+            status: "Done",
+            rowsExported: result.rows.length,
+            totalRows: result.rows.length,
+          };
+        }
+        toast(t("grid.exported"));
+      } catch (e: any) {
+        if (exportProgressState) {
+          exportProgressState.value = {
+            ...exportProgressState.value,
+            status: "Error",
+            errorMessage: e?.message || String(e),
+          };
+        }
+        toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+      }
+    });
+  }
+
+  async function exportCurrentPageXlsx() {
+    await runExclusiveExport(async () => {
+      try {
+        let outputPath = exportFileName("export-page", "xlsx", { page: true });
+        if (isTauriRuntime()) {
+          const { save } = await import("@tauri-apps/plugin-dialog");
+          const path = await save({
+            defaultPath: outputPath,
+            filters: [{ name: "Excel", extensions: ["xlsx"] }],
+          });
+          if (!path) return;
+          outputPath = path as string;
+        }
+        const result = await resultToExport(undefined, undefined, false);
+        await api.exportQueryResultXlsx(outputPath, currentXlsxSheetName(), result.columns, result.columnTypes, result.rows);
+        toast(t("grid.exported"));
+      } catch (e: any) {
+        toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+      }
+    });
+  }
+
+  async function exportAllResultsXlsx() {
+    await runExclusiveExport(async () => {
+      try {
+        const sheets = (allExportResults?.value ?? []).filter((sheet) => sheet.result.columns.length > 0);
+        if (sheets.length === 0) return;
+
+        let outputPath = exportFileName("query-results", "xlsx", { allResults: true });
+        if (isTauriRuntime()) {
+          const { save } = await import("@tauri-apps/plugin-dialog");
+          const path = await save({
+            defaultPath: outputPath,
+            filters: [{ name: "Excel", extensions: ["xlsx"] }],
+          });
+          if (!path) return;
+          outputPath = path as string;
+        }
+
+        await api.exportQueryResultsXlsx(
+          outputPath,
+          sheets.map((sheet) => ({
+            sheetName: sheet.sheetName,
+            columns: sheet.result.columns,
+            columnTypes: sheet.result.column_types ?? [],
+            rows: sheet.result.rows,
+          })),
+        );
+        toast(t("grid.exported"));
+      } catch (e: any) {
+        toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+      }
+    });
+  }
+
+  async function exportFullTableDataViaBackend(format: "csv" | "xlsx" | "json" | "markdown" | "sql", rowIds?: number[]): Promise<boolean> {
+    const meta = tableMeta.value;
+    // The backend table exporter currently builds two-part table names. External
+    // Doris/StarRocks catalogs need the data-tab paginator's three-part SQL.
+    if (rowIds !== undefined || context.value !== "table-data" || !meta || meta.catalog || !connectionId.value || !database.value) {
+      return false;
+    }
+
+    const extension = format === "markdown" ? "md" : format;
+    const filterName = format === "csv" ? "CSV" : format === "xlsx" ? "Excel" : format === "json" ? "JSON" : format === "markdown" ? "Markdown" : "SQL";
+    let outputPath = exportFileName(meta.tableName || "export", extension, { preferFallback: true });
+    if (isTauriRuntime()) {
+      const { save } = await import("@tauri-apps/plugin-dialog");
+      const path = await save({
+        defaultPath: outputPath,
+        filters: [{ name: filterName, extensions: [extension] }],
+      });
+      if (!path) return true;
+      outputPath = path as string;
+    }
+
+    if (exportProgressState) {
+      exportProgressState.value = {
+        title: t("exportProgress.title"),
+        tableName: meta.tableName,
+        format,
+        rowsExported: 0,
+        totalRows: null,
+        status: "Running",
+        errorMessage: null,
+      };
+    }
+    if (exportProgressDialog) exportProgressDialog.value = true;
+
+    const exportId = uuid();
+    if (exportCancelHandler) {
+      exportCancelHandler.value = () => api.cancelTableExport(exportId);
+    }
+    const editorSettings = useSettingsStore().editorSettings;
+    const rowLimit = editorSettings.exportRowLimitEnabled ? editorSettings.exportRowLimit : null;
+
+    try {
+      const progress = await api.startTableExport(
+        {
+          exportId,
+          connectionId: connectionId.value,
+          database: database.value,
+          schema: meta.schema,
+          tableName: meta.tableName,
+          filePath: outputPath,
+          format,
+          columns: columns.value,
+          columnTypes: columnTypes.value,
+          primaryKeys: meta.primaryKeys,
+          whereInput: whereInput.value,
+          orderBy: orderBy.value,
+          skipCount: false,
+          batchSize: exportBatchSize.value,
+          rowLimit,
+        },
+        (progress) => {
+          if (exportProgressState) {
+            exportProgressState.value = {
+              ...exportProgressState.value,
+              tableName: progress.tableName || meta.tableName,
+              rowsExported: progress.rowsExported,
+              totalRows: progress.totalRows,
+              status: progress.status,
+              errorMessage: progress.errorMessage || null,
+            };
+          }
+        },
+      );
+      if (progress.status === "Done") {
+        toast(t("grid.exported"));
+      }
+    } finally {
+      if (exportCancelHandler) exportCancelHandler.value = null;
+    }
+    return true;
+  }
+
+  async function exportQueryResultViaBackend(format: "csv" | "xlsx", rowIds?: number[]): Promise<boolean> {
+    if (rowIds !== undefined || context.value !== "results" || !queryResultExportRequest) {
+      return false;
+    }
+    // The full result is already in memory — don't re-execute the query on the
+    // backend just to stream the same rows back to a file.
+    if (hasCompleteLocalResult?.value) return false;
+
+    const extension = format;
+    const filterName = format === "csv" ? "CSV" : "Excel";
+    let outputPath = exportFileName("query-result", extension);
+    if (isTauriRuntime()) {
+      const { save } = await import("@tauri-apps/plugin-dialog");
+      const path = await save({
+        defaultPath: outputPath,
+        filters: [{ name: filterName, extensions: [extension] }],
+      });
+      if (!path) return true;
+      outputPath = path as string;
+    }
+
+    const exportId = uuid();
+    const request = await queryResultExportRequest({ exportId, filePath: outputPath, format });
+    if (!request) throw new Error("Unable to build query result export request");
+
+    if (exportProgressState) {
+      exportProgressState.value = {
+        title: t("exportProgress.title"),
+        tableName: "Query Result",
+        format,
+        rowsExported: 0,
+        totalRows: request.totalRows ?? null,
+        status: "Running",
+        errorMessage: null,
+      };
+    }
+    if (exportProgressDialog) exportProgressDialog.value = true;
+    if (exportCancelHandler) {
+      exportCancelHandler.value = () => api.cancelQueryResultExport(exportId, request.executionId);
+    }
+
+    try {
+      const terminalProgress = await api.startQueryResultExport(request, (progress) => {
+        if (exportProgressState) {
+          const adjustedTotal = progress.totalRows !== null && progress.rowsExported > progress.totalRows ? progress.rowsExported : progress.totalRows;
+          exportProgressState.value = {
+            ...exportProgressState.value,
+            tableName: progress.tableName || "Query Result",
+            rowsExported: progress.rowsExported,
+            totalRows: adjustedTotal,
+            status: progress.status,
+            errorMessage: progress.errorMessage || null,
+          };
+        }
+      });
+      if (terminalProgress.status === "Done") {
+        toast(t("grid.exported"));
+      }
+    } finally {
+      if (exportCancelHandler) exportCancelHandler.value = null;
+    }
+    return true;
+  }
+
+  async function exportSql(rowIds?: number[]) {
+    await runExclusiveExport(async () => {
+      try {
+        if (await exportFullTableDataViaBackend("sql", rowIds)) return;
+
+        const result = await resultToExport(rowIds);
+        const exportData = sqlInsertExportData(result);
+        const content = await formatSqlInsert({
+          databaseType: databaseType.value,
+          schema: tableMeta.value?.schema,
+          tableName: tableMeta.value?.tableName || "table_name",
+          columns: exportData.columns,
+          columnTypes: exportData.columnTypes,
+          rows: exportData.rows,
+        });
+        await saveTextFile(content, exportFileName(tableMeta.value?.tableName || "export", "sql", { preferFallback: true }), "SQL", "sql");
+        toast(t("grid.exported"));
+      } catch (e: any) {
+        toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+      }
+    });
+  }
+
+  async function exportCurrentPageSql() {
+    await runExclusiveExport(async () => {
+      try {
+        const result = await resultToExport(undefined, undefined, false);
+        const exportData = sqlInsertExportData(result);
+        const content = await formatSqlInsert({
+          databaseType: databaseType.value,
+          schema: tableMeta.value?.schema,
+          tableName: tableMeta.value?.tableName || "table_name",
+          columns: exportData.columns,
+          columnTypes: exportData.columnTypes,
+          rows: exportData.rows,
+        });
+        await saveTextFile(content, exportFileName("export-page", "sql", { page: true }), "SQL", "sql");
+        toast(t("grid.exported"));
+      } catch (e: any) {
+        toast(t("grid.exportFailed", { message: e?.message || String(e) }), 5000);
+      }
+    });
+  }
+
+  async function copySql() {
+    if (!sql.value) return;
+    await copyText(sql.value);
+  }
+
+  function sqlInsertExportData(result: { columns: string[]; rows: CellValue[][] }): {
+    columns: string[];
+    columnTypes?: Array<string | undefined>;
+    rows: CellValue[][];
+  } {
+    const exportColumns = tableMeta.value ? effectiveColumns(sourceColumns.value, result.columns) : result.columns;
+    const columnIndexes = exportColumns.map((column, index) => ({ column, index })).filter((item): item is { column: string; index: number } => !!item.column);
+    const exportColumnTypes = columnTypes.value?.length === result.columns.length ? columnTypes.value : undefined;
+    return {
+      columns: columnIndexes.map((item) => item.column),
+      columnTypes: exportColumnTypes ? columnIndexes.map((item) => exportColumnTypes[item.index]) : undefined,
+      rows: result.rows.map((row) => columnIndexes.map((item) => row[item.index] ?? null)),
+    };
+  }
+
+  function exportFileName(fallbackBaseName: string, extension: string, options: { page?: boolean; allResults?: boolean; preferFallback?: boolean } = {}): string {
+    const rawBaseName = options.preferFallback ? fallbackBaseName : exportFileBaseName?.value || fallbackBaseName;
+    return defaultDataGridExportFileName(rawBaseName, fallbackBaseName, extension, options);
+  }
+
+  return {
+    copyText,
+    copyCell,
+    copyRow,
+    copyRowAsInsert,
+    copyRowAsInsertWithoutPrimaryKeys,
+    prefetchRowAsInsertStatement,
+    canCopyPreparedInsert,
+    copyPreparedRowAsInsert,
+    canCopyRowAsInsert,
+    prefetchRowAsUpdateStatement,
+    canCopyPreparedUpdate,
+    copyPreparedRowAsUpdate,
+    copyRowAsUpdate,
+    canCopyRowAsInsertWithoutPrimaryKeys,
+    canCopyRowAsUpdate,
+    copyAll,
+    copySelectionTsv,
+    copySelectionTsvWithHeaders,
+    copySelectionCsv,
+    copySelectionJson,
+    copySelectionSqlInList,
+    copySelectedRowsTsv,
+    copySelectedRowsTsvWithHeaders,
+    copyColumnNames,
+    exportCsv,
+    exportCurrentPageCsv,
+    exportJson,
+    exportCurrentPageJson,
+    exportMarkdown,
+    exportCurrentPageMarkdown,
+    exportXlsx,
+    exportCurrentPageXlsx,
+    exportAllResultsXlsx,
+    exportSql,
+    exportCurrentPageSql,
+    copySql,
+  };
+}
+
+async function saveTextFile(content: string, defaultFileName: string, filterName: string, filterExt: string) {
+  if (isTauriRuntime()) {
+    const { save } = await import("@tauri-apps/plugin-dialog");
+    const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+    const path = await save({
+      defaultPath: defaultFileName,
+      filters: [{ name: filterName, extensions: [filterExt] }],
+    });
+    if (path) await writeTextFile(path, content);
+    return;
+  }
+
+  const blob = new Blob([content], { type: "text/plain;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = defaultFileName;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+export function defaultDataGridExportFileName(baseName: string | undefined, fallbackBaseName: string, extension: string, options: { page?: boolean; allResults?: boolean } = {}): string {
+  const sanitizedBaseName = sanitizeExportBaseName(baseName || "") || sanitizeExportBaseName(fallbackBaseName) || "export";
+  const suffix = options.allResults ? "results" : options.page ? "page" : "";
+  return [sanitizedBaseName, suffix, compactLocalTimestamp()].filter(Boolean).join("_") + `.${extension}`;
+}
+
+function sanitizeExportBaseName(value: string): string {
+  return replaceControlCharacters(
+    value
+      .trim()
+      .replace(/\.[sS][qQ][lL]$/, "")
+      .replace(/[<>:"/\\|?*]/g, "_"),
+    "_",
+  )
+    .replace(/\s+/g, " ")
+    .replace(/[._\s-]+$/g, "")
+    .slice(0, 120);
+}
+
+function replaceControlCharacters(value: string, replacement: string): string {
+  return Array.from(value)
+    .map((char) => (char.charCodeAt(0) < 32 ? replacement : char))
+    .join("");
+}
+
+function buildMongoCopyInsertStatement(options: { collection: string; columns: string[]; sourceColumns?: Array<string | undefined>; rows: CellValue[][]; excludePrimaryKeys?: boolean; insertMode?: DataGridCopyInsertMode }): string | undefined {
+  const saveColumns = effectiveColumns(options.sourceColumns, options.columns);
+  const columnIndexes = saveColumns.map((column, index) => ({ column, index })).filter((item): item is { column: string; index: number } => !!item.column);
+  if (columnIndexes.length === 0 || options.rows.length === 0) return undefined;
+  const documentColumns = columnIndexes.map((item) => item.column);
+  const documents = options.rows.map((row) => buildMongoCopyInsertDocument(columnIndexes.map((item) => row[item.index]) as MongoInputValue[], documentColumns, { excludePrimaryKeys: options.excludePrimaryKeys }));
+  const collection = `db.getCollection(${JSON.stringify(options.collection)})`;
+  if (documents.length === 1) return `${collection}.insert(${formatMongoShellLiteral(documents[0])});`;
+  if (options.insertMode === "row-by-row") {
+    return documents.map((document) => `${collection}.insert(${formatMongoShellLiteral(document)});`).join("\n");
+  }
+  return `${collection}.insertMany(${formatMongoShellLiteral(documents)});`;
+}
+
+function compactLocalTimestamp(date = new Date()): string {
+  const yy = String(date.getFullYear() % 100).padStart(2, "0");
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hour = String(date.getHours()).padStart(2, "0");
+  const minute = String(date.getMinutes()).padStart(2, "0");
+  const second = String(date.getSeconds()).padStart(2, "0");
+  return `${yy}${month}${day}${hour}${minute}${second}`;
+}
+
+function effectiveColumns(sourceColumns: Array<string | undefined> | undefined, columns: string[]): Array<string | undefined> {
+  if (!sourceColumns || sourceColumns.length !== columns.length) return columns;
+  return sourceColumns;
+}
+
+function isCopyInsertOmittedColumn(databaseType: DatabaseType | undefined, column: string, tableMeta: DataGridTableMeta | undefined): boolean {
+  if (databaseType === "oracle" && column.toUpperCase() === DBX_ROWID_COLUMN) return true;
+  const columnInfo = tableMeta?.columns?.find((item) => normalizeColumnName(item.name) === normalizeColumnName(column));
+  const normalizedType = columnInfo?.data_type.trim().replace(/^"|"$/g, "").toLowerCase();
+  if (databaseType === "postgres" && (normalizedType === "tsvector" || normalizedType?.endsWith(".tsvector"))) return true;
+  const extra = columnInfo?.extra?.toLowerCase() ?? "";
+  return /\b(auto_increment|autoincrement|identity)\b/.test(extra) || (extra.includes("generated always as") && !extra.includes("identity"));
+}
+
+function findColumnIndex(columns: Array<string | undefined>, target: string): number {
+  const normalizedTarget = normalizeColumnName(target);
+  return columns.findIndex((column) => (column ? normalizeColumnName(column) : "") === normalizedTarget);
+}
+
+function normalizeColumnName(name: string): string {
+  return name.toUpperCase();
+}
diff --git a/apps/desktop/src/composables/useDataGridSelection.ts b/apps/desktop/src/composables/useDataGridSelection.ts
new file mode 100644
index 0000000..af12e3a
--- /dev/null
+++ b/apps/desktop/src/composables/useDataGridSelection.ts
@@ -0,0 +1,480 @@
+import { ref, computed, getCurrentScope, onScopeDispose, type ComputedRef, type Ref } from "vue";
+import { allCellsSelectionRange, extractColumnsSelection, extractSelection, isCellInSelection, normalizeSelectionRange, normalizeSelectedColumnIndexes, rowSelectionRange, type CellPosition, type CellSelectionRange, type SelectionData } from "@/lib/dataGrid/gridSelection";
+
+type CellValue = string | number | boolean | null;
+
+interface RowItem {
+  id: number;
+  sourceIndex?: number;
+  newIndex?: number;
+  data: CellValue[];
+  isNew: boolean;
+  isDraft?: boolean;
+  isDeleted: boolean;
+  isDirtyCol: boolean[];
+  status: string;
+}
+
+export interface UseDataGridSelectionOptions {
+  columns: ComputedRef<string[]>;
+  displayItems: ComputedRef<RowItem[]>;
+  editingCell: Ref<{ rowId: number; col: number } | null>;
+  showTranspose: Ref<boolean>;
+  transposeRowIndex: Ref<number | null>;
+  gridRef: Ref<HTMLDivElement | undefined>;
+  getScrollElement?: () => HTMLElement | null;
+  cellFromClientPoint?: (clientX: number, clientY: number) => CellPosition | null;
+}
+
+const AUTO_SCROLL_EDGE_SIZE = 40;
+const AUTO_SCROLL_MAX_SPEED = 28;
+
+export function useDataGridSelection(options: UseDataGridSelectionOptions) {
+  const { columns, displayItems, editingCell, showTranspose, transposeRowIndex, gridRef, getScrollElement, cellFromClientPoint } = options;
+
+  const selectionAnchor = ref<CellPosition | null>(null);
+  const selectionFocus = ref<CellPosition | null>(null);
+  const isSelectingCells = ref(false);
+  let selectionPointerClientX = 0;
+  let selectionPointerClientY = 0;
+  let selectionAutoScrollFrame = 0;
+
+  const isSelectingAll = ref(false);
+  const selectedCellKeys = ref<Set<string>>(new Set());
+  const selectedRowIds = ref<Set<number>>(new Set());
+  const selectedColumnIndexes = ref<Set<number>>(new Set());
+  const lastClickedRowIndex = ref<number | null>(null);
+  const lastClickedColumnIndex = ref<number | null>(null);
+  const hasRowSelection = computed(() => selectedRowIds.value.size > 0);
+  const selectedRowCount = computed(() => selectedRowIds.value.size);
+  const hasColumnSelection = computed(() => selectedColumnIndexes.value.size > 0);
+
+  const selectedRange = computed<CellSelectionRange | null>(() => {
+    if (!selectionAnchor.value || !selectionFocus.value) return null;
+    return normalizeSelectionRange(selectionAnchor.value, selectionFocus.value);
+  });
+
+  const selectedCells = computed<SelectionData>(() => {
+    if (hasColumnSelection.value) {
+      const rows = displayItems.value.filter((item) => !item.isDraft).map((item) => item.data);
+      return extractColumnsSelection(columns.value, rows, selectedColumnIndexes.value);
+    }
+    if (selectedCellKeys.value.size > 0) {
+      const selectableKeys = [...selectedCellKeys.value].filter((key) => {
+        const position = parseCellKey(key);
+        return !!position && !displayItems.value[position.rowIndex]?.isDraft;
+      });
+      return extractSelectedCellKeys(
+        columns.value,
+        displayItems.value.map((item) => item.data),
+        selectableKeys,
+      );
+    }
+    const range = selectedRange.value;
+    if (!range) return { columns: [], rows: [] };
+    const rows = displayItems.value
+      .slice(range.startRow, range.endRow + 1)
+      .filter((item) => !item.isDraft)
+      .map((item) => item.data);
+    return extractSelection(columns.value, rows, {
+      startRow: 0,
+      endRow: rows.length - 1,
+      startCol: range.startCol,
+      endCol: range.endCol,
+    });
+  });
+
+  const selectedCellCount = computed(() => selectedCells.value.rows.reduce((count, row) => count + row.length, 0));
+  const hasCellSelection = computed(() => selectedCellCount.value > 0);
+
+  function clearCellSelection() {
+    selectionAnchor.value = null;
+    selectionFocus.value = null;
+    selectedCellKeys.value = new Set();
+    selectedColumnIndexes.value = new Set();
+    isSelectingCells.value = false;
+    isSelectingAll.value = false;
+  }
+
+  function clearRowSelection() {
+    isSelectingAll.value = false;
+    selectedRowIds.value = new Set();
+    lastClickedRowIndex.value = null;
+  }
+
+  function selectSingleCell(rowIndex: number, colIndex: number) {
+    const cell = { rowIndex, colIndex };
+    selectedCellKeys.value = new Set();
+    selectionAnchor.value = cell;
+    selectionFocus.value = cell;
+  }
+
+  function selectRow(rowIndex: number) {
+    const range = rowSelectionRange(rowIndex, columns.value.length);
+    if (!range) return;
+    selectedCellKeys.value = new Set();
+    selectionAnchor.value = { rowIndex: range.startRow, colIndex: range.startCol };
+    selectionFocus.value = { rowIndex: range.endRow, colIndex: range.endCol };
+  }
+
+  function selectRows(startRow: number, endRow: number) {
+    const range = rowSelectionRange(startRow, columns.value.length, endRow);
+    if (!range) return;
+    selectedCellKeys.value = new Set();
+    selectionAnchor.value = { rowIndex: range.startRow, colIndex: range.startCol };
+    selectionFocus.value = { rowIndex: range.endRow, colIndex: range.endCol };
+  }
+
+  function selectColumns(startCol: number, endCol: number, options?: { merge?: boolean }) {
+    const normalizedColumns = normalizeSelectedColumnIndexes(Array.from({ length: Math.abs(endCol - startCol) + 1 }, (_, index) => Math.min(startCol, endCol) + index));
+    if (normalizedColumns.length === 0 || displayItems.value.length <= 0) return;
+    clearRowSelection();
+    selectedCellKeys.value = new Set();
+    selectionAnchor.value = null;
+    selectionFocus.value = null;
+    const next = options?.merge ? new Set(selectedColumnIndexes.value) : new Set<number>();
+    normalizedColumns.forEach((index) => next.add(index));
+    selectedColumnIndexes.value = next;
+    focusGridWithoutScrolling();
+  }
+
+  function selectColumn(colIndex: number, event?: MouseEvent) {
+    const isShift = Boolean(event?.shiftKey);
+    const isMeta = Boolean(event?.metaKey || event?.ctrlKey);
+    if (isShift && lastClickedColumnIndex.value !== null) {
+      selectColumns(lastClickedColumnIndex.value, colIndex, { merge: hasColumnSelection.value });
+    } else if (isMeta) {
+      clearRowSelection();
+      selectionAnchor.value = null;
+      selectionFocus.value = null;
+      selectedCellKeys.value = new Set();
+      const next = new Set(selectedColumnIndexes.value);
+      if (next.has(colIndex)) {
+        next.delete(colIndex);
+      } else {
+        next.add(colIndex);
+      }
+      selectedColumnIndexes.value = next;
+      focusGridWithoutScrolling();
+    } else {
+      selectColumns(colIndex, colIndex);
+    }
+    lastClickedColumnIndex.value = colIndex;
+  }
+
+  function selectAllCells() {
+    const range = allCellsSelectionRange(displayItems.value.length, columns.value.length);
+    if (!range) return;
+    clearRowSelection();
+    selectedColumnIndexes.value = new Set();
+    selectedCellKeys.value = new Set();
+    lastClickedColumnIndex.value = null;
+    selectionAnchor.value = { rowIndex: range.startRow, colIndex: range.startCol };
+    selectionFocus.value = { rowIndex: range.endRow, colIndex: range.endCol };
+    isSelectingAll.value = true;
+    focusGridWithoutScrolling();
+  }
+
+  function extendCellSelectionTo(rowIndex: number, colIndex: number) {
+    selectedCellKeys.value = new Set();
+    if (!selectionAnchor.value) {
+      selectSingleCell(rowIndex, colIndex);
+      return;
+    }
+    selectionFocus.value = { rowIndex, colIndex };
+  }
+
+  function toggleCellSelection(rowIndex: number, colIndex: number) {
+    const key = cellKey(rowIndex, colIndex);
+    const next = selectedCellKeys.value.size > 0 ? new Set(selectedCellKeys.value) : selectedRangeToCellKeys(selectedRange.value);
+    if (next.has(key)) {
+      next.delete(key);
+    } else {
+      next.add(key);
+    }
+    selectedCellKeys.value = next;
+    selectedColumnIndexes.value = new Set();
+    if (next.size > 0) {
+      selectionAnchor.value = { rowIndex, colIndex };
+      selectionFocus.value = null;
+    } else {
+      selectionAnchor.value = null;
+      selectionFocus.value = null;
+    }
+    isSelectingCells.value = false;
+    isSelectingAll.value = false;
+    lastClickedColumnIndex.value = colIndex;
+    if (showTranspose.value) transposeRowIndex.value = rowIndex;
+  }
+
+  function handleRowClick(rowIndex: number, rowId: number, event: MouseEvent) {
+    const isMeta = event.metaKey || event.ctrlKey;
+    const isShift = event.shiftKey;
+
+    clearCellSelection();
+
+    if (isMeta) {
+      const next = new Set(selectedRowIds.value);
+      if (next.has(rowId)) {
+        next.delete(rowId);
+      } else {
+        next.add(rowId);
+      }
+      selectedRowIds.value = next;
+      selectContiguousRowIds(next);
+      lastClickedRowIndex.value = rowIndex;
+    } else if (isShift && lastClickedRowIndex.value !== null) {
+      const start = Math.min(lastClickedRowIndex.value, rowIndex);
+      const end = Math.max(lastClickedRowIndex.value, rowIndex);
+      const next = new Set(selectedRowIds.value);
+      for (let i = start; i <= end; i++) {
+        const item = displayItems.value[i];
+        if (item) next.add(item.id);
+      }
+      selectedRowIds.value = next;
+      selectRows(start, end);
+    } else {
+      selectedRowIds.value = new Set([rowId]);
+      selectRow(rowIndex);
+      lastClickedRowIndex.value = rowIndex;
+    }
+  }
+
+  function selectContiguousRowIds(rowIds: Set<number>) {
+    if (rowIds.size === 0) {
+      clearCellSelection();
+      return;
+    }
+
+    const indexes = displayItems.value.reduce<number[]>((selectedIndexes, item, index) => {
+      if (rowIds.has(item.id)) selectedIndexes.push(index);
+      return selectedIndexes;
+    }, []);
+    if (indexes.length !== rowIds.size) {
+      clearCellSelection();
+      return;
+    }
+
+    const start = Math.min(...indexes);
+    const end = Math.max(...indexes);
+    if (end - start + 1 !== indexes.length) {
+      clearCellSelection();
+      return;
+    }
+    selectRows(start, end);
+  }
+
+  function finishCellSelection() {
+    isSelectingCells.value = false;
+    document.removeEventListener("mouseup", finishCellSelection);
+    document.removeEventListener("mousemove", handleSelectionPointerMove);
+    stopSelectionAutoScroll();
+  }
+
+  function stopSelectionAutoScroll() {
+    if (!selectionAutoScrollFrame) return;
+    cancelAnimationFrame(selectionAutoScrollFrame);
+    selectionAutoScrollFrame = 0;
+  }
+
+  function selectionScrollVelocity(pointer: number, start: number, end: number): number {
+    if (pointer < start + AUTO_SCROLL_EDGE_SIZE) {
+      return -AUTO_SCROLL_MAX_SPEED * Math.min(1, (start + AUTO_SCROLL_EDGE_SIZE - pointer) / AUTO_SCROLL_EDGE_SIZE);
+    }
+    if (pointer > end - AUTO_SCROLL_EDGE_SIZE) {
+      return AUTO_SCROLL_MAX_SPEED * Math.min(1, (pointer - (end - AUTO_SCROLL_EDGE_SIZE)) / AUTO_SCROLL_EDGE_SIZE);
+    }
+    return 0;
+  }
+
+  function updateSelectionFromPointer() {
+    const cell = cellFromClientPoint?.(selectionPointerClientX, selectionPointerClientY);
+    if (cell) extendCellSelection(cell.rowIndex, cell.colIndex);
+  }
+
+  function runSelectionAutoScroll() {
+    selectionAutoScrollFrame = 0;
+    if (!isSelectingCells.value) return;
+
+    const scroller = getScrollElement?.();
+    if (!scroller) return;
+    const rect = scroller.getBoundingClientRect();
+    const deltaX = selectionScrollVelocity(selectionPointerClientX, rect.left, rect.right);
+    const deltaY = selectionScrollVelocity(selectionPointerClientY, rect.top, rect.bottom);
+    const previousLeft = scroller.scrollLeft;
+    const previousTop = scroller.scrollTop;
+
+    scroller.scrollLeft += deltaX;
+    scroller.scrollTop += deltaY;
+    updateSelectionFromPointer();
+
+    if (scroller.scrollLeft !== previousLeft || scroller.scrollTop !== previousTop) {
+      selectionAutoScrollFrame = requestAnimationFrame(runSelectionAutoScroll);
+    }
+  }
+
+  function handleSelectionPointerMove(event: MouseEvent) {
+    if (!isSelectingCells.value) return;
+    selectionPointerClientX = event.clientX;
+    selectionPointerClientY = event.clientY;
+    updateSelectionFromPointer();
+    if (!selectionAutoScrollFrame) selectionAutoScrollFrame = requestAnimationFrame(runSelectionAutoScroll);
+  }
+
+  function focusGridWithoutScrolling() {
+    gridRef.value?.focus({ preventScroll: true });
+  }
+
+  function beginCellSelection(rowIndex: number, colIndex: number, event: MouseEvent) {
+    if (event.button !== 0) return;
+    if (editingCell.value) return;
+    event.preventDefault();
+    focusGridWithoutScrolling();
+    clearCellSelection();
+    selectSingleCell(rowIndex, colIndex);
+    isSelectingCells.value = true;
+    selectionPointerClientX = event.clientX;
+    selectionPointerClientY = event.clientY;
+    lastClickedColumnIndex.value = colIndex;
+    if (showTranspose.value) transposeRowIndex.value = rowIndex;
+    document.addEventListener("mouseup", finishCellSelection);
+    document.addEventListener("mousemove", handleSelectionPointerMove);
+  }
+
+  if (getCurrentScope()) onScopeDispose(finishCellSelection);
+
+  function extendCellSelection(rowIndex: number, colIndex: number) {
+    if (!isSelectingCells.value || !selectionAnchor.value) return;
+    selectionFocus.value = { rowIndex, colIndex };
+  }
+
+  function handleDataCellMousedown(rowIndex: number, colIndex: number, _rowId: number, event: MouseEvent) {
+    if (event.button !== 0) return;
+    if (editingCell.value) return;
+
+    const isMeta = event.metaKey || event.ctrlKey;
+    const isShift = event.shiftKey;
+
+    if (isMeta) {
+      event.preventDefault();
+      focusGridWithoutScrolling();
+      clearRowSelection();
+      toggleCellSelection(rowIndex, colIndex);
+      return;
+    }
+
+    if (isShift) {
+      event.preventDefault();
+      focusGridWithoutScrolling();
+      clearRowSelection();
+      extendCellSelectionTo(rowIndex, colIndex);
+      return;
+    }
+
+    clearRowSelection();
+    beginCellSelection(rowIndex, colIndex, event);
+  }
+
+  function isRowSelected(rowId: number): boolean {
+    return selectedRowIds.value.has(rowId);
+  }
+
+  function cellIsSelected(rowIndex: number, colIndex: number): boolean {
+    if (selectedCellKeys.value.size > 0) return selectedCellKeys.value.has(cellKey(rowIndex, colIndex));
+    if (hasColumnSelection.value) return rowIndex >= 0 && rowIndex < displayItems.value.length && selectedColumnIndexes.value.has(colIndex);
+    return isCellInSelection(rowIndex, colIndex, selectedRange.value);
+  }
+
+  function columnIsSelected(colIndex: number): boolean {
+    if (hasColumnSelection.value) return selectedColumnIndexes.value.has(colIndex);
+    const range = selectedRange.value;
+    if (!range) return false;
+    return range.startCol <= colIndex && range.endCol >= colIndex && range.startRow === 0 && range.endRow >= displayItems.value.length - 1;
+  }
+
+  function selectedRangeStart(): CellPosition | null {
+    const range = selectedRange.value;
+    if (!range) return null;
+    return { rowIndex: range.startRow, colIndex: range.startCol };
+  }
+
+  return {
+    selectionAnchor,
+    selectionFocus,
+    isSelectingCells,
+    selectedRange,
+    selectedCells,
+    selectedCellCount,
+    hasCellSelection,
+    isSelectingAll,
+    selectedCellKeys,
+    clearCellSelection,
+    selectSingleCell,
+    selectRow,
+    selectColumn,
+    selectColumns,
+    selectAllCells,
+    extendCellSelectionTo,
+    finishCellSelection,
+    beginCellSelection,
+    extendCellSelection,
+    cellIsSelected,
+    columnIsSelected,
+    selectedRangeStart,
+    selectedRowIds,
+    selectedColumnIndexes,
+    lastClickedRowIndex,
+    hasRowSelection,
+    selectedRowCount,
+    hasColumnSelection,
+    clearRowSelection,
+    handleRowClick,
+    handleDataCellMousedown,
+    isRowSelected,
+  };
+}
+
+function cellKey(rowIndex: number, colIndex: number): string {
+  return `${rowIndex}:${colIndex}`;
+}
+
+function parseCellKey(key: string): CellPosition | null {
+  const [row, col] = key.split(":");
+  const rowIndex = Number(row);
+  const colIndex = Number(col);
+  if (!Number.isInteger(rowIndex) || !Number.isInteger(colIndex) || rowIndex < 0 || colIndex < 0) return null;
+  return { rowIndex, colIndex };
+}
+
+function selectedRangeToCellKeys(range: CellSelectionRange | null): Set<string> {
+  const keys = new Set<string>();
+  if (!range) return keys;
+  for (let rowIndex = range.startRow; rowIndex <= range.endRow; rowIndex++) {
+    for (let colIndex = range.startCol; colIndex <= range.endCol; colIndex++) {
+      keys.add(cellKey(rowIndex, colIndex));
+    }
+  }
+  return keys;
+}
+
+function extractSelectedCellKeys(columns: readonly string[], rows: readonly CellValue[][], keys: Iterable<string>): SelectionData {
+  const positions = [...keys]
+    .map(parseCellKey)
+    .filter((position): position is CellPosition => !!position && position.rowIndex < rows.length && position.colIndex < columns.length)
+    .sort((a, b) => a.rowIndex - b.rowIndex || a.colIndex - b.colIndex);
+  const selectedColumnIndexes = normalizeSelectedColumnIndexes(positions.map((position) => position.colIndex)).filter((index) => index < columns.length);
+  const rowsByIndex = new Map<number, CellValue[]>();
+
+  for (const position of positions) {
+    const row = rows[position.rowIndex];
+    if (!row) continue;
+    const values = rowsByIndex.get(position.rowIndex) ?? [];
+    values.push(row[position.colIndex] ?? null);
+    rowsByIndex.set(position.rowIndex, values);
+  }
+
+  return {
+    columns: selectedColumnIndexes.map((index) => columns[index]),
+    rows: [...rowsByIndex.values()],
+  };
+}
diff --git a/apps/desktop/src/composables/useDatabaseOptions.ts b/apps/desktop/src/composables/useDatabaseOptions.ts
new file mode 100644
index 0000000..409295a
--- /dev/null
+++ b/apps/desktop/src/composables/useDatabaseOptions.ts
@@ -0,0 +1,55 @@
+import { ref } from "vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { filterDatabaseNamesForConnection } from "@/lib/database/visibleDatabases";
+import { usesTreeSchemaMode } from "@/lib/database/databaseCapabilities";
+import type { ConnectionConfig } from "@/types/database";
+import * as api from "@/lib/backend/api";
+
+export function databaseOptionsForConnection(databaseNames: string[], connection: Pick<ConnectionConfig, "db_type" | "visible_databases"> | undefined): string[] {
+  const names = filterDatabaseNamesForConnection(databaseNames, connection);
+  if (names.length === 0 && usesTreeSchemaMode(connection?.db_type)) return [""];
+  return names;
+}
+
+export function useDatabaseOptions() {
+  const connectionStore = useConnectionStore();
+
+  const databaseOptions = ref<Record<string, string[]>>({});
+  const loadingDatabaseOptions = ref<Record<string, boolean>>({});
+
+  async function loadDatabaseOptions(connectionId: string) {
+    const connection = connectionStore.getConfig(connectionId);
+    if (!connection || loadingDatabaseOptions.value[connectionId]) return;
+
+    loadingDatabaseOptions.value[connectionId] = true;
+    try {
+      await connectionStore.ensureConnected(connectionId);
+      if (connection.db_type === "redis") {
+        const dbs = await api.redisListDatabases(connectionId);
+        databaseOptions.value[connectionId] = databaseOptionsForConnection(
+          dbs.map((db) => String(db.db)),
+          connection,
+        );
+      } else if (connection.db_type === "mongodb") {
+        databaseOptions.value[connectionId] = filterDatabaseNamesForConnection(await api.mongoListDatabases(connectionId), connection);
+      } else {
+        const dbs = await api.listDatabases(connectionId);
+        databaseOptions.value[connectionId] = databaseOptionsForConnection(
+          dbs.map((db) => db.name),
+          connection,
+        );
+      }
+    } finally {
+      loadingDatabaseOptions.value[connectionId] = false;
+    }
+  }
+
+  async function getDatabaseOptions(connectionId: string): Promise<string[]> {
+    if (!databaseOptions.value[connectionId]) {
+      await loadDatabaseOptions(connectionId);
+    }
+    return databaseOptions.value[connectionId] ?? [];
+  }
+
+  return { databaseOptions, loadingDatabaseOptions, loadDatabaseOptions, getDatabaseOptions };
+}
diff --git a/apps/desktop/src/composables/useDialogSources.ts b/apps/desktop/src/composables/useDialogSources.ts
new file mode 100644
index 0000000..8d75230
--- /dev/null
+++ b/apps/desktop/src/composables/useDialogSources.ts
@@ -0,0 +1,351 @@
+import { ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useToast } from "@/composables/useToast";
+import type { SidebarLayout } from "@/types/database";
+
+const showTransferDialog = ref(false);
+const showSchemaDiffDialog = ref(false);
+const showDataCompareDialog = ref(false);
+const showSqlFileDialog = ref(false);
+const showDiagramDialog = ref(false);
+const showTableImportDialog = ref(false);
+const showTableDataGenerateDialog = ref(false);
+const showFieldLineageDialog = ref(false);
+const showDatabaseSearchDialog = ref(false);
+const showDatabaseExportDialog = ref(false);
+const showImportLayoutConfirm = ref(false);
+const pendingImportLayout = ref<SidebarLayout | null>(null);
+const showConfigPassphraseDialog = ref(false);
+const configPassphraseMode = ref<"export" | "import">("export");
+const configPassphraseError = ref("");
+const pendingImportContent = ref("");
+
+const transferPrefillConnectionId = ref("");
+const transferPrefillDatabase = ref("");
+const schemaDiffPrefillConnectionId = ref("");
+const schemaDiffPrefillDatabase = ref("");
+const schemaDiffPrefillSchema = ref("");
+const dataComparePrefillConnectionId = ref("");
+const dataComparePrefillDatabase = ref("");
+const dataComparePrefillSchema = ref("");
+const dataComparePrefillTable = ref("");
+const sqlFilePrefillConnectionId = ref("");
+const sqlFilePrefillDatabase = ref("");
+const sqlFilePrefillFilePath = ref("");
+const diagramPrefillConnectionId = ref("");
+const diagramPrefillDatabase = ref("");
+const diagramPrefillSchema = ref("");
+const diagramFocusTableName = ref("");
+const tableImportPrefillConnectionId = ref("");
+const tableImportPrefillDatabase = ref("");
+const tableImportPrefillSchema = ref("");
+const tableImportPrefillTable = ref("");
+const tableDataGeneratePrefillConnectionId = ref("");
+const tableDataGeneratePrefillDatabase = ref("");
+const tableDataGeneratePrefillSchema = ref("");
+const tableDataGeneratePrefillTable = ref("");
+const lineagePrefillConnectionId = ref("");
+const lineagePrefillDatabase = ref("");
+const lineagePrefillSchema = ref("");
+const lineagePrefillTable = ref("");
+const lineagePrefillColumn = ref("");
+const databaseSearchPrefillConnectionId = ref("");
+const databaseSearchPrefillDatabase = ref("");
+const databaseSearchPrefillSchema = ref("");
+const databaseExportPrefillConnectionId = ref("");
+const databaseExportPrefillDatabase = ref("");
+const databaseExportPrefillSchema = ref("");
+const databaseExportPrefillTable = ref("");
+const databaseExportPrefillTables = ref<string[]>([]);
+const databaseExportAllDatabases = ref(false);
+
+let watchersRegistered = false;
+
+export function useDialogSources() {
+  const { t } = useI18n();
+  const connectionStore = useConnectionStore();
+  const { toast } = useToast();
+
+  // Watchers for store source triggers (register only once)
+  if (!watchersRegistered) {
+    watchersRegistered = true;
+
+    watch(
+      () => connectionStore.transferSource,
+      (v) => {
+        if (v) {
+          transferPrefillConnectionId.value = v.connectionId;
+          transferPrefillDatabase.value = v.database;
+          showTransferDialog.value = true;
+          connectionStore.transferSource = null;
+        }
+      },
+    );
+
+    watch(
+      () => connectionStore.schemaDiffSource,
+      (v) => {
+        if (v) {
+          schemaDiffPrefillConnectionId.value = v.connectionId;
+          schemaDiffPrefillDatabase.value = v.database;
+          schemaDiffPrefillSchema.value = v.schema ?? "";
+          showSchemaDiffDialog.value = true;
+          connectionStore.schemaDiffSource = null;
+        }
+      },
+    );
+
+    watch(
+      () => connectionStore.dataCompareSource,
+      (v) => {
+        if (v) {
+          dataComparePrefillConnectionId.value = v.connectionId;
+          dataComparePrefillDatabase.value = v.database;
+          dataComparePrefillSchema.value = v.schema ?? "";
+          dataComparePrefillTable.value = v.tableName ?? "";
+          showDataCompareDialog.value = true;
+          connectionStore.dataCompareSource = null;
+        }
+      },
+    );
+
+    watch(
+      () => connectionStore.sqlFileSource,
+      (v) => {
+        if (v) {
+          sqlFilePrefillConnectionId.value = v.connectionId;
+          sqlFilePrefillDatabase.value = v.database;
+          sqlFilePrefillFilePath.value = v.filePath ?? "";
+          showSqlFileDialog.value = true;
+          connectionStore.sqlFileSource = null;
+        }
+      },
+    );
+
+    // Clear the pre-filled file path once the dialog closes so a later open
+    // via the toolbar (which doesn't go through sqlFileSource) doesn't re-load
+    // the previously previewed file. prefillConnectionId/database are harmless
+    // when stale (they only preselect dropdowns), but a stale path triggers an
+    // async file read + preview render — a visible side effect.
+    watch(showSqlFileDialog, (open) => {
+      if (!open) sqlFilePrefillFilePath.value = "";
+    });
+
+    watch(
+      () => connectionStore.diagramSource,
+      (v) => {
+        if (v) {
+          diagramPrefillConnectionId.value = v.connectionId;
+          diagramPrefillDatabase.value = v.database;
+          diagramPrefillSchema.value = v.schema ?? "";
+          diagramFocusTableName.value = v.tableName ?? "";
+          showDiagramDialog.value = true;
+          connectionStore.diagramSource = null;
+        }
+      },
+    );
+
+    watch(
+      () => connectionStore.tableImportSource,
+      (v) => {
+        if (v) {
+          tableImportPrefillConnectionId.value = v.connectionId;
+          tableImportPrefillDatabase.value = v.database;
+          tableImportPrefillSchema.value = v.schema ?? "";
+          tableImportPrefillTable.value = v.tableName ?? "";
+          showTableImportDialog.value = true;
+          connectionStore.tableImportSource = null;
+        }
+      },
+    );
+
+    watch(
+      () => connectionStore.tableDataGenerateSource,
+      (v) => {
+        if (v) {
+          tableDataGeneratePrefillConnectionId.value = v.connectionId;
+          tableDataGeneratePrefillDatabase.value = v.database;
+          tableDataGeneratePrefillSchema.value = v.schema ?? "";
+          tableDataGeneratePrefillTable.value = v.tableName;
+          showTableDataGenerateDialog.value = true;
+          connectionStore.tableDataGenerateSource = null;
+        }
+      },
+    );
+
+    watch(
+      () => connectionStore.fieldLineageSource,
+      (v) => {
+        if (v) {
+          lineagePrefillConnectionId.value = v.connectionId;
+          lineagePrefillDatabase.value = v.database;
+          lineagePrefillSchema.value = v.schema ?? "";
+          lineagePrefillTable.value = v.tableName;
+          lineagePrefillColumn.value = v.columnName;
+          showFieldLineageDialog.value = true;
+          connectionStore.fieldLineageSource = null;
+        }
+      },
+    );
+
+    watch(
+      () => connectionStore.databaseSearchSource,
+      (v) => {
+        if (v) {
+          databaseSearchPrefillConnectionId.value = v.connectionId;
+          databaseSearchPrefillDatabase.value = v.database;
+          databaseSearchPrefillSchema.value = v.schema ?? "";
+          showDatabaseSearchDialog.value = true;
+          connectionStore.databaseSearchSource = null;
+        }
+      },
+    );
+
+    watch(
+      () => connectionStore.databaseExportSource,
+      (v) => {
+        if (v) {
+          databaseExportPrefillConnectionId.value = v.connectionId;
+          databaseExportPrefillDatabase.value = v.database;
+          databaseExportPrefillSchema.value = v.schema ?? "";
+          databaseExportPrefillTable.value = v.tableName ?? "";
+          databaseExportPrefillTables.value = v.tableNames ?? [];
+          databaseExportAllDatabases.value = v.allDatabases ?? false;
+          showDatabaseExportDialog.value = true;
+          connectionStore.databaseExportSource = null;
+        }
+      },
+    );
+  } // end watchersRegistered
+
+  // Config export/import helpers
+  function onExportClick() {
+    configPassphraseMode.value = "export";
+    configPassphraseError.value = "";
+    showConfigPassphraseDialog.value = true;
+  }
+
+  async function onExportConfirm(passphrase: string) {
+    try {
+      await connectionStore.exportConnectionsToFile(passphrase);
+      showConfigPassphraseDialog.value = false;
+      toast(t("configExport.exportSuccess"), 2000);
+    } catch (e: any) {
+      configPassphraseError.value = e?.message === "crypto_unavailable" ? t("configExport.cryptoUnavailable") : e?.message || String(e);
+    }
+  }
+
+  async function onImportClick(source: "dbx" | "navicat" | "dbeaver" | "datagrip" = "dbx") {
+    try {
+      const result = await connectionStore.readImportFile(source);
+      if (!result) return;
+      pendingImportContent.value = result.content;
+      if (result.encrypted) {
+        configPassphraseMode.value = "import";
+        configPassphraseError.value = "";
+        showConfigPassphraseDialog.value = true;
+      } else {
+        const { count, layout } = await connectionStore.importConnectionsFromFile(result.content, null);
+        // For DataGrip imports, read Keychain passwords
+        let keychainFilled = 0;
+        if (source === "datagrip" && count > 0) {
+          keychainFilled = await connectionStore.applyDataGripKeychainPasswords();
+        }
+        toast(
+          count > 0
+            ? source === "navicat"
+              ? t("configExport.importNavicatSuccess", { count })
+              : source === "dbeaver"
+                ? t("configExport.importDbeaverSuccess", { count })
+                : source === "datagrip"
+                  ? t("configExport.importDatagripSuccess", { count: count, filled: keychainFilled })
+                  : t("configExport.importSuccess", { count })
+            : t("configExport.importNone"),
+          4000,
+        );
+        if (layout && count > 0) {
+          pendingImportLayout.value = layout;
+          showImportLayoutConfirm.value = true;
+        }
+      }
+    } catch (e: any) {
+      toast(e?.message || String(e), 4000);
+    }
+  }
+
+  async function onImportConfirm(passphrase: string) {
+    try {
+      const { count, layout } = await connectionStore.importConnectionsFromFile(pendingImportContent.value, passphrase);
+      showConfigPassphraseDialog.value = false;
+      toast(count > 0 ? t("configExport.importSuccess", { count }) : t("configExport.importNone"), 2000);
+      if (layout && count > 0) {
+        pendingImportLayout.value = layout;
+        showImportLayoutConfirm.value = true;
+      }
+    } catch (e: any) {
+      configPassphraseError.value = e?.message === "wrong_passphrase" ? t("configExport.wrongPassphrase") : e?.message === "crypto_unavailable" ? t("configExport.cryptoUnavailable") : e?.message || String(e);
+    }
+  }
+
+  return {
+    showTransferDialog,
+    showSchemaDiffDialog,
+    showDataCompareDialog,
+    showSqlFileDialog,
+    showDiagramDialog,
+    showTableImportDialog,
+    showTableDataGenerateDialog,
+    showFieldLineageDialog,
+    showDatabaseSearchDialog,
+    showDatabaseExportDialog,
+    showImportLayoutConfirm,
+    pendingImportLayout,
+    showConfigPassphraseDialog,
+    configPassphraseMode,
+    configPassphraseError,
+    pendingImportContent,
+    transferPrefillConnectionId,
+    transferPrefillDatabase,
+    schemaDiffPrefillConnectionId,
+    schemaDiffPrefillDatabase,
+    schemaDiffPrefillSchema,
+    dataComparePrefillConnectionId,
+    dataComparePrefillDatabase,
+    dataComparePrefillSchema,
+    dataComparePrefillTable,
+    sqlFilePrefillConnectionId,
+    sqlFilePrefillDatabase,
+    sqlFilePrefillFilePath,
+    diagramPrefillConnectionId,
+    diagramPrefillDatabase,
+    diagramPrefillSchema,
+    diagramFocusTableName,
+    tableImportPrefillConnectionId,
+    tableImportPrefillDatabase,
+    tableImportPrefillSchema,
+    tableImportPrefillTable,
+    tableDataGeneratePrefillConnectionId,
+    tableDataGeneratePrefillDatabase,
+    tableDataGeneratePrefillSchema,
+    tableDataGeneratePrefillTable,
+    lineagePrefillConnectionId,
+    lineagePrefillDatabase,
+    lineagePrefillSchema,
+    lineagePrefillTable,
+    lineagePrefillColumn,
+    databaseSearchPrefillConnectionId,
+    databaseSearchPrefillDatabase,
+    databaseSearchPrefillSchema,
+    databaseExportPrefillConnectionId,
+    databaseExportPrefillDatabase,
+    databaseExportPrefillSchema,
+    databaseExportPrefillTable,
+    databaseExportPrefillTables,
+    databaseExportAllDatabases,
+    onExportClick,
+    onExportConfirm,
+    onImportClick,
+    onImportConfirm,
+  };
+}
diff --git a/apps/desktop/src/composables/useDiffScrollSync.ts b/apps/desktop/src/composables/useDiffScrollSync.ts
new file mode 100644
index 0000000..48cc79e
--- /dev/null
+++ b/apps/desktop/src/composables/useDiffScrollSync.ts
@@ -0,0 +1,52 @@
+import { ref, type Ref } from "vue";
+import type { DiffHunk } from "@/components/diff/DiffHunkBuilder";
+
+export interface UseDiffScrollSyncOptions {
+  container: Ref<HTMLElement | undefined>;
+  leftPane: Ref<HTMLElement | undefined>;
+  rightPane: Ref<HTMLElement | undefined>;
+  hunks: Ref<DiffHunk[]>;
+}
+
+export function useDiffScrollSync({ container, leftPane, rightPane, hunks }: UseDiffScrollSyncOptions) {
+  const isSyncingScroll = ref(false);
+
+  function syncScroll(from: "left" | "right") {
+    if (isSyncingScroll.value) return;
+    const source = from === "left" ? leftPane.value : rightPane.value;
+    const target = from === "left" ? rightPane.value : leftPane.value;
+    if (!source || !target) return;
+    isSyncingScroll.value = true;
+    target.scrollTop = source.scrollTop;
+    isSyncingScroll.value = false;
+  }
+
+  function measureHunks() {
+    const outer = container.value;
+    const left = leftPane.value;
+    const right = rightPane.value;
+    if (!outer || !left || !right) return;
+
+    const outerRect = outer.getBoundingClientRect();
+
+    for (const hunk of hunks.value) {
+      const leftEl = left.querySelector(`[data-hunk-id="${hunk.id}"]`) as HTMLElement | null;
+      const rightEl = right.querySelector(`[data-hunk-id="${hunk.id}"]`) as HTMLElement | null;
+      if (leftEl) {
+        const rect = leftEl.getBoundingClientRect();
+        hunk.leftTop = rect.top - outerRect.top;
+        hunk.leftBottom = rect.bottom - outerRect.top;
+      }
+      if (rightEl) {
+        const rect = rightEl.getBoundingClientRect();
+        hunk.rightTop = rect.top - outerRect.top;
+        hunk.rightBottom = rect.bottom - outerRect.top;
+      }
+    }
+  }
+
+  return {
+    syncScroll,
+    measureHunks,
+  };
+}
diff --git a/apps/desktop/src/composables/useDragSort.ts b/apps/desktop/src/composables/useDragSort.ts
new file mode 100644
index 0000000..82cd2d0
--- /dev/null
+++ b/apps/desktop/src/composables/useDragSort.ts
@@ -0,0 +1,181 @@
+import { reactive, readonly } from "vue";
+
+export type DropPosition = "before" | "after" | "inside";
+
+interface DragState {
+  active: boolean;
+  draggedId: string | null;
+  draggedType: string | null;
+  targetId: string | null;
+  dropPosition: DropPosition | null;
+  startX: number;
+  startY: number;
+}
+
+const DRAG_THRESHOLD = 5;
+
+const state = reactive<DragState>({
+  active: false,
+  draggedId: null,
+  draggedType: null,
+  targetId: null,
+  dropPosition: null,
+  startX: 0,
+  startY: 0,
+});
+
+let pending: {
+  id: string;
+  type: string;
+  x: number;
+  y: number;
+  sourceEl: HTMLElement | null;
+} | null = null;
+let onDropCallback: ((draggedId: string, targetId: string, position: DropPosition) => void) | null = null;
+let ghostEl: HTMLElement | null = null;
+
+function createGhost(sourceEl: HTMLElement, x: number, y: number) {
+  const ghost = document.createElement("div");
+  const textNode = sourceEl.querySelector(".truncate");
+  ghost.textContent = textNode?.textContent || "";
+  ghost.style.cssText = `
+    position: fixed;
+    pointer-events: none;
+    z-index: 9999;
+    opacity: 0.9;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.12);
+    border-radius: 4px;
+    background: var(--background, #fff);
+    border: 1px solid var(--border, #e5e7eb);
+    max-width: 200px;
+    height: 24px;
+    padding: 0 8px;
+    font-size: 12px;
+    line-height: 24px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    left: ${x + 12}px;
+    top: ${y - 10}px;
+  `;
+  document.body.appendChild(ghost);
+  return ghost;
+}
+
+function moveGhost(x: number, y: number) {
+  if (!ghostEl) return;
+  ghostEl.style.left = `${x + 8}px`;
+  ghostEl.style.top = `${y - 12}px`;
+}
+
+function removeGhost() {
+  if (ghostEl) {
+    ghostEl.remove();
+    ghostEl = null;
+  }
+}
+
+function onMouseMove(event: MouseEvent) {
+  if (!pending && !state.active) return;
+
+  if (pending && !state.active) {
+    const dx = event.clientX - pending.x;
+    const dy = event.clientY - pending.y;
+    if (Math.abs(dx) < DRAG_THRESHOLD && Math.abs(dy) < DRAG_THRESHOLD) return;
+    state.active = true;
+    state.draggedId = pending.id;
+    state.draggedType = pending.type;
+    state.startX = pending.x;
+    state.startY = pending.y;
+    if (pending.sourceEl) {
+      ghostEl = createGhost(pending.sourceEl, event.clientX, event.clientY);
+    }
+    pending = null;
+    document.body.style.cursor = "grabbing";
+    document.body.style.userSelect = "none";
+  }
+
+  if (state.active) {
+    moveGhost(event.clientX, event.clientY);
+  }
+}
+
+function onMouseUp() {
+  if (state.active && state.draggedId && state.targetId && state.dropPosition && onDropCallback) {
+    onDropCallback(state.draggedId, state.targetId, state.dropPosition);
+  }
+  reset();
+}
+
+function reset() {
+  state.active = false;
+  state.draggedId = null;
+  state.draggedType = null;
+  state.targetId = null;
+  state.dropPosition = null;
+  state.startX = 0;
+  state.startY = 0;
+  pending = null;
+  removeGhost();
+  document.body.style.cursor = "";
+  document.body.style.userSelect = "";
+}
+
+let listenersAttached = false;
+
+function ensureListeners() {
+  if (listenersAttached) return;
+  document.addEventListener("mousemove", onMouseMove, true);
+  document.addEventListener("mouseup", onMouseUp, true);
+  listenersAttached = true;
+}
+
+export function useDragSort(onDrop: (draggedId: string, targetId: string, position: DropPosition) => void) {
+  ensureListeners();
+  onDropCallback = onDrop;
+
+  function startDrag(event: MouseEvent, nodeId: string, nodeType: string) {
+    if (event.button !== 0) return;
+    const el = (event.currentTarget as HTMLElement) || null;
+    pending = { id: nodeId, type: nodeType, x: event.clientX, y: event.clientY, sourceEl: el };
+  }
+
+  function updateTarget(event: MouseEvent, nodeId: string, nodeType: string) {
+    if (!state.active || nodeId === state.draggedId) {
+      if (state.targetId === nodeId) {
+        state.targetId = null;
+        state.dropPosition = null;
+      }
+      return;
+    }
+
+    state.targetId = nodeId;
+
+    const el = event.currentTarget as HTMLElement;
+    const rect = el.getBoundingClientRect();
+    const y = event.clientY - rect.top;
+    const third = rect.height / 3;
+
+    if (nodeType === "connection-group" && y > third && y < rect.height - third) {
+      state.dropPosition = "inside";
+    } else if (y < rect.height / 2) {
+      state.dropPosition = "before";
+    } else {
+      state.dropPosition = "after";
+    }
+  }
+
+  function clearTarget(nodeId: string) {
+    if (state.targetId === nodeId) {
+      state.targetId = null;
+      state.dropPosition = null;
+    }
+  }
+
+  return {
+    state: readonly(state),
+    startDrag,
+    updateTarget,
+    clearTarget,
+  };
+}
diff --git a/apps/desktop/src/composables/useEditorFontFamilyStyle.ts b/apps/desktop/src/composables/useEditorFontFamilyStyle.ts
new file mode 100644
index 0000000..5be1423
--- /dev/null
+++ b/apps/desktop/src/composables/useEditorFontFamilyStyle.ts
@@ -0,0 +1,11 @@
+import { computed } from "vue";
+import { EDITOR_FONT_FAMILY_CSS_VAR } from "@/lib/editor/editorThemes";
+import { useSettingsStore } from "@/stores/settingsStore";
+
+export function useEditorFontFamilyStyle() {
+  const settingsStore = useSettingsStore();
+
+  return computed<Record<string, string>>(() => ({
+    [EDITOR_FONT_FAMILY_CSS_VAR]: settingsStore.editorSettings.fontFamily,
+  }));
+}
diff --git a/apps/desktop/src/composables/useExportTracker.ts b/apps/desktop/src/composables/useExportTracker.ts
new file mode 100644
index 0000000..0313b34
--- /dev/null
+++ b/apps/desktop/src/composables/useExportTracker.ts
@@ -0,0 +1,330 @@
+import { reactive, computed } from "vue";
+import * as api from "@/lib/backend/api";
+import { isTerminalTransferProgress } from "@/lib/backend/transferProgress";
+
+export type BackgroundTaskKind = "table-export" | "database-export" | "sql-file" | "data-transfer";
+export type BackgroundTaskStatus = "Running" | "Writing" | "Done" | "Error" | "Cancelled";
+
+export interface ExportTask {
+  exportId: string;
+  kind: BackgroundTaskKind;
+  tableName: string;
+  format: string;
+  filePath: string;
+  rowsExported: number;
+  totalRows: number | null;
+  status: BackgroundTaskStatus;
+  errorMessage: string | null;
+  objectIndex?: number;
+  totalObjects?: number;
+  statementIndex?: number;
+  successCount?: number;
+  failureCount?: number;
+  affectedRows?: number;
+  elapsedMs?: number;
+  statementSummary?: string;
+  tableIndex?: number;
+  totalTables?: number;
+  currentTable?: string;
+  targetConnectionId?: string;
+  targetDatabase?: string;
+  targetSchema?: string;
+  targetTables?: string[];
+}
+
+const taskMap = reactive<Map<string, ExportTask>>(new Map());
+const activeTransferRuns = new Set<string>();
+
+function normalizeExportStatus(status: string): BackgroundTaskStatus {
+  if (status === "Writing" || status === "Done" || status === "Error" || status === "Cancelled") return status;
+  return "Running";
+}
+
+function normalizeSqlFileStatus(status: api.SqlFileStatus): BackgroundTaskStatus {
+  if (status === "done") return "Done";
+  if (status === "error") return "Error";
+  if (status === "cancelled") return "Cancelled";
+  return "Running";
+}
+
+function normalizeTransferStatus(status: api.TransferProgress["status"], terminal: boolean): BackgroundTaskStatus {
+  if (status === "done") return "Done";
+  if (status === "error") return terminal ? "Error" : "Running";
+  if (status === "cancelled") return "Cancelled";
+  return "Running";
+}
+
+function targetTableName(table: string, nameCase: api.TransferTableNameCase): string {
+  if (nameCase === "lower") return table.toLowerCase();
+  if (nameCase === "upper") return table.toUpperCase();
+  return table;
+}
+
+function findActiveOverlappingTransfer(request: api.TransferRequest): string[] {
+  const requestedTables = new Set(request.tables.map((table) => targetTableName(table, request.targetTableNameCase)));
+  for (const task of taskMap.values()) {
+    if (task.exportId === request.transferId) continue;
+    if (task.kind !== "data-transfer") continue;
+    if (task.status !== "Running" && task.status !== "Writing") continue;
+    if (task.targetConnectionId !== request.targetConnectionId) continue;
+    if (task.targetDatabase !== request.targetDatabase) continue;
+    if (task.targetSchema !== request.targetSchema) continue;
+
+    const overlappingTables = (task.targetTables ?? []).filter((table) => requestedTables.has(table));
+    if (overlappingTables.length > 0) return overlappingTables;
+  }
+  return [];
+}
+
+export function useExportTracker() {
+  const tasks = computed(() => Array.from(taskMap.values()));
+
+  const activeCount = computed(() => tasks.value.filter((t) => t.status === "Running" || t.status === "Writing").length);
+
+  const hasActive = computed(() => activeCount.value > 0);
+
+  function generateUUID() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    let buffer = new Uint8Array(16);
+    crypto.getRandomValues(buffer);
+    buffer[6] = (buffer[6] & 0x0f) | 0x40;
+    return Array.from(buffer, (b) => b.toString(16).padStart(2, "0"))
+      .join("")
+      .replace(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "$1-$2-$3-$4-$5");
+  }
+
+  function addTask(tableName: string, format: string, filePath: string): ExportTask {
+    const exportId = generateUUID();
+    const task = reactive<ExportTask>({
+      exportId,
+      kind: "table-export",
+      tableName,
+      format,
+      filePath,
+      rowsExported: 0,
+      totalRows: null,
+      status: "Running",
+      errorMessage: null,
+    });
+    taskMap.set(exportId, task);
+    return task;
+  }
+
+  function addDatabaseExportTask(exportId: string, label: string, filePath: string): ExportTask {
+    const task = reactive<ExportTask>({
+      exportId,
+      kind: "database-export",
+      tableName: label,
+      format: "sql",
+      filePath,
+      rowsExported: 0,
+      totalRows: null,
+      status: "Running",
+      errorMessage: null,
+      objectIndex: 0,
+      totalObjects: 0,
+    });
+    taskMap.set(exportId, task);
+    return task;
+  }
+
+  function addSqlFileTask(executionId: string, fileName: string, filePath: string): ExportTask {
+    const task = reactive<ExportTask>({
+      exportId: executionId,
+      kind: "sql-file",
+      tableName: fileName,
+      format: "sql",
+      filePath,
+      rowsExported: 0,
+      totalRows: null,
+      status: "Running",
+      errorMessage: null,
+      statementIndex: 0,
+      successCount: 0,
+      failureCount: 0,
+      affectedRows: 0,
+      elapsedMs: 0,
+      statementSummary: "",
+    });
+    taskMap.set(executionId, task);
+    return task;
+  }
+
+  function addDataTransferTask(transferId: string, label: string, totalTables: number): ExportTask {
+    const task = reactive<ExportTask>({
+      exportId: transferId,
+      kind: "data-transfer",
+      tableName: label,
+      format: "transfer",
+      filePath: "",
+      rowsExported: 0,
+      totalRows: null,
+      status: "Running",
+      errorMessage: null,
+      tableIndex: 0,
+      totalTables,
+      currentTable: "",
+    });
+    taskMap.set(transferId, task);
+    return task;
+  }
+
+  function startDataTransferTask(
+    request: api.TransferRequest,
+    label: string,
+    options: {
+      onDone?: () => void | Promise<void>;
+      formatOverlapError?: (tables: string[]) => string;
+    } = {},
+  ): ExportTask {
+    const existingTask = taskMap.get(request.transferId);
+    const task = existingTask ?? addDataTransferTask(request.transferId, label, request.tables.length);
+    task.targetConnectionId = request.targetConnectionId;
+    task.targetDatabase = request.targetDatabase;
+    task.targetSchema = request.targetSchema;
+    task.targetTables = request.tables.map((table) => targetTableName(table, request.targetTableNameCase));
+    if (activeTransferRuns.has(request.transferId)) return task;
+
+    const overlappingTables = findActiveOverlappingTransfer(request);
+    if (overlappingTables.length > 0) {
+      task.status = "Error";
+      const visibleTables = overlappingTables.slice(0, 5);
+      task.errorMessage = options.formatOverlapError?.(visibleTables) ?? `Another data transfer is already running for target table(s): ${visibleTables.join(", ")}`;
+      return task;
+    }
+
+    activeTransferRuns.add(request.transferId);
+    let terminalStatus: api.TransferProgress["status"] | null = null;
+
+    void (async () => {
+      try {
+        await api.startTransfer(request, (progress) => {
+          terminalStatus = isTerminalTransferProgress(progress) ? progress.status : terminalStatus;
+          updateDataTransferTask(progress.transferId, progress);
+        });
+
+        if (terminalStatus === "done" && task.status === "Done") {
+          await options.onDone?.();
+        }
+      } catch (e: any) {
+        updateDataTransferTask(request.transferId, {
+          transferId: request.transferId,
+          table: task.currentTable || "",
+          tableIndex: task.tableIndex ?? 0,
+          totalTables: task.totalTables ?? request.tables.length,
+          rowsTransferred: task.rowsExported,
+          totalRows: task.totalRows,
+          status: "error",
+          error: e?.message || String(e),
+          terminal: true,
+        });
+      } finally {
+        activeTransferRuns.delete(request.transferId);
+      }
+    })();
+
+    return task;
+  }
+
+  function updateTableExportTask(exportId: string, progress: api.TableExportProgress) {
+    const task = taskMap.get(exportId);
+    if (!task) return;
+    task.tableName = progress.tableName || task.tableName;
+    task.rowsExported = progress.rowsExported;
+    task.totalRows = progress.totalRows;
+    task.status = normalizeExportStatus(progress.status);
+    task.errorMessage = progress.errorMessage || null;
+  }
+
+  function updateDatabaseExportTask(exportId: string, progress: api.ExportProgress) {
+    const task = taskMap.get(exportId);
+    if (!task) return;
+    task.tableName = progress.currentObject || task.tableName;
+    task.rowsExported = progress.rowsExported;
+    task.totalRows = progress.totalRows;
+    task.status = normalizeExportStatus(progress.status);
+    task.errorMessage = progress.error || null;
+    task.objectIndex = progress.objectIndex;
+    task.totalObjects = progress.totalObjects;
+  }
+
+  function updateSqlFileTask(executionId: string, progress: api.SqlFileProgress) {
+    const task = taskMap.get(executionId);
+    if (!task) return;
+    task.status = normalizeSqlFileStatus(progress.status);
+    task.errorMessage = progress.error || null;
+    task.statementIndex = progress.statementIndex;
+    task.successCount = progress.successCount;
+    task.failureCount = progress.failureCount;
+    task.affectedRows = progress.affectedRows;
+    task.elapsedMs = progress.elapsedMs;
+    task.statementSummary = progress.statementSummary;
+    task.rowsExported = progress.successCount + progress.failureCount;
+    task.totalRows = Math.max(progress.statementIndex, progress.successCount + progress.failureCount) || null;
+  }
+
+  function updateDataTransferTask(transferId: string, progress: api.TransferProgress) {
+    const task = taskMap.get(transferId);
+    if (!task) return;
+    const nextStatus = normalizeTransferStatus(progress.status, progress.terminal);
+    const hadError = task.status === "Error";
+    task.status = hadError && nextStatus === "Done" ? "Error" : nextStatus;
+    task.errorMessage = progress.error || task.errorMessage || null;
+    task.tableIndex = progress.tableIndex;
+    task.totalTables = progress.totalTables;
+    task.currentTable = progress.table || task.currentTable;
+    if (progress.table || progress.rowsTransferred > 0 || task.rowsExported === 0) {
+      task.rowsExported = progress.rowsTransferred;
+    }
+    task.totalRows = progress.totalRows ?? task.totalRows;
+  }
+
+  function removeTask(exportId: string) {
+    taskMap.delete(exportId);
+  }
+
+  function clearFinished() {
+    for (const [id, task] of taskMap) {
+      if (task.status === "Done" || task.status === "Error" || task.status === "Cancelled") {
+        taskMap.delete(id);
+      }
+    }
+  }
+
+  async function cancelTask(exportId: string) {
+    const task = taskMap.get(exportId);
+    try {
+      if (task?.kind === "database-export") {
+        await api.cancelDatabaseExport(exportId);
+      } else if (task?.kind === "sql-file") {
+        await api.cancelSqlFileExecution(exportId);
+      } else if (task?.kind === "data-transfer") {
+        await api.cancelTransfer(exportId);
+      } else {
+        await api.cancelTableExport(exportId);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  return {
+    tasks,
+    activeCount,
+    hasActive,
+    addTask,
+    addDatabaseExportTask,
+    addSqlFileTask,
+    addDataTransferTask,
+    startDataTransferTask,
+    updateTableExportTask,
+    updateDatabaseExportTask,
+    updateSqlFileTask,
+    updateDataTransferTask,
+    removeTask,
+    clearFinished,
+    cancelTask,
+  };
+}
diff --git a/apps/desktop/src/composables/useFileDrop.ts b/apps/desktop/src/composables/useFileDrop.ts
new file mode 100644
index 0000000..67172a0
--- /dev/null
+++ b/apps/desktop/src/composables/useFileDrop.ts
@@ -0,0 +1,136 @@
+import { useI18n } from "vue-i18n";
+import { uuid } from "@/lib/common/utils";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useToast } from "@/composables/useToast";
+import * as api from "@/lib/backend/api";
+import type { ConnectionConfig } from "@/types/database";
+import { detectDatabaseFileType } from "@/lib/database/databaseFileDetection";
+
+function isSqlFilePath(path: string): boolean {
+  return /\.sql$/i.test(path);
+}
+
+function getDataFileQuery(path: string): Promise<string | undefined> {
+  return api.buildDroppedFilePreviewSql({ path });
+}
+
+export function useFileDrop() {
+  const { t } = useI18n();
+  const connectionStore = useConnectionStore();
+  const queryStore = useQueryStore();
+  const { toast } = useToast();
+
+  async function openDroppedSqlFile(name: string, content: string, path?: string) {
+    const connectionId = connectionStore.activeConnectionId || connectionStore.connections[0]?.id || "";
+    const connection = connectionId ? connectionStore.getConfig(connectionId) : undefined;
+    const database = connection?.database || "";
+    if (path) {
+      queryStore.openExternalSqlFile(connectionId, database, path, content);
+    } else {
+      const tabId = queryStore.createTab(connectionId, database, name, "query");
+      queryStore.updateSql(tabId, content);
+    }
+    toast(t("welcome.fileOpened", { name }));
+  }
+
+  async function setupFileDrop() {
+    if (isTauriRuntime()) {
+      const { getCurrentWebview } = await import("@tauri-apps/api/webview");
+      const webview = getCurrentWebview();
+      await webview.onDragDropEvent(async (event) => {
+        if (event.payload.type !== "drop") return;
+        for (const path of event.payload.paths) {
+          const name = path.split("/").pop()?.split("\\").pop() || path;
+
+          const dataQuery = await getDataFileQuery(path);
+          if (dataQuery) {
+            const config: ConnectionConfig = {
+              id: uuid(),
+              name: `[Preview] ${name}`,
+              db_type: "duckdb",
+              driver_profile: "duckdb",
+              driver_label: "DuckDB",
+              url_params: "",
+              host: ":memory:",
+              port: 0,
+              username: "",
+              password: "",
+            };
+            const connectionId = await api.connectDb(config);
+            connectionStore.addEphemeralConnection({ ...config, id: connectionId });
+            const tabId = queryStore.createTab(connectionId, "", name, "query");
+            queryStore.updateSql(tabId, dataQuery);
+            queryStore.executeCurrentTab();
+            toast(t("welcome.fileOpened", { name }));
+            continue;
+          }
+
+          if (isSqlFilePath(path)) {
+            try {
+              const content = await api.readExternalSqlFile(path);
+              await openDroppedSqlFile(name, content, path);
+            } catch (e: any) {
+              toast(t("toolbar.sqlOpenFailed", { message: e?.message || String(e) }), 5000);
+            }
+            continue;
+          }
+
+          const dbType = await detectDatabaseFileType(path);
+          if (!dbType) continue;
+          const config: ConnectionConfig = {
+            id: uuid(),
+            name,
+            db_type: dbType,
+            driver_profile: dbType,
+            driver_label: dbType === "duckdb" ? "DuckDB" : "SQLite",
+            url_params: "",
+            host: path,
+            port: 0,
+            username: "",
+            password: "",
+          };
+          try {
+            await connectionStore.addConnection(config);
+            void connectionStore.connect(config);
+            toast(t("welcome.fileOpened", { name }));
+          } catch (e: any) {
+            toast(t("connection.saveFailed", { message: e?.message || String(e) }), 5000);
+          }
+        }
+      });
+    } else {
+      document.addEventListener("drop", (event: DragEvent) => {
+        const files = event.dataTransfer?.files;
+        if (!files || files.length === 0) return;
+        event.preventDefault();
+        for (let i = 0; i < files.length; i++) {
+          const file = files[i];
+          if (!isSqlFilePath(file.name)) continue;
+          const reader = new FileReader();
+          reader.onload = () => {
+            if (typeof reader.result === "string") {
+              openDroppedSqlFile(file.name, reader.result).catch((e: any) => {
+                toast(t("toolbar.sqlOpenFailed", { message: e?.message || String(e) }), 5000);
+              });
+            }
+          };
+          reader.readAsText(file);
+        }
+      });
+      document.addEventListener("dragover", (event: DragEvent) => {
+        const files = event.dataTransfer?.files;
+        if (!files || files.length === 0) return;
+        for (let i = 0; i < files.length; i++) {
+          if (isSqlFilePath(files[i].name)) {
+            event.preventDefault();
+            return;
+          }
+        }
+      });
+    }
+  }
+
+  return { setupFileDrop };
+}
diff --git a/apps/desktop/src/composables/useFlatTree.ts b/apps/desktop/src/composables/useFlatTree.ts
new file mode 100644
index 0000000..81a95af
--- /dev/null
+++ b/apps/desktop/src/composables/useFlatTree.ts
@@ -0,0 +1,38 @@
+import type { TreeNode, TreeNodeType } from "@/types/database";
+
+export const SIDEBAR_TREE_ROW_HEIGHT = 28;
+export const SIDEBAR_TREE_SCROLL_BUFFER = 600;
+export const SIDEBAR_TREE_PRERENDER_COUNT = 48;
+
+export interface FlatTreeNode {
+  node: TreeNode;
+  depth: number;
+  id: string;
+  type: TreeNodeType;
+  poolType: string;
+}
+
+function walk(children: TreeNode[], depth: number, result: FlatTreeNode[]) {
+  for (const node of children) {
+    result.push({
+      node,
+      depth,
+      id: node.id,
+      type: node.type,
+      poolType: node.type === "connection-group" ? `${node.type}:${node.id}` : node.type,
+    });
+    if (node.isExpanded && node.children) {
+      walk(node.children, depth + 1, result);
+    }
+  }
+}
+
+export function flattenTree(nodes: TreeNode[]): FlatTreeNode[] {
+  const result: FlatTreeNode[] = [];
+  walk(nodes, 0, result);
+  return result;
+}
+
+export function shouldVirtualizeFlatTree(count: number): boolean {
+  return count > 0;
+}
diff --git a/apps/desktop/src/composables/useNacosConfigListColumnResize.ts b/apps/desktop/src/composables/useNacosConfigListColumnResize.ts
new file mode 100644
index 0000000..4577f01
--- /dev/null
+++ b/apps/desktop/src/composables/useNacosConfigListColumnResize.ts
@@ -0,0 +1,79 @@
+import { computed, ref } from "vue";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+
+export const NACOS_CONFIG_LIST_COLUMN_WIDTHS_STORAGE_KEY = "dbx-nacos-config-list-column-widths";
+export const DEFAULT_NACOS_CONFIG_LIST_COLUMN_WIDTHS = [280, 180, 180, 96] as const;
+const MIN_NACOS_CONFIG_LIST_COLUMN_WIDTHS = [180, 120, 120, 72] as const;
+
+function minWidthForColumn(index: number) {
+  return MIN_NACOS_CONFIG_LIST_COLUMN_WIDTHS[index] ?? MIN_NACOS_CONFIG_LIST_COLUMN_WIDTHS[MIN_NACOS_CONFIG_LIST_COLUMN_WIDTHS.length - 1];
+}
+
+function normalizeNacosConfigListColumnWidths(value: unknown): number[] | null {
+  if (!Array.isArray(value) || value.length !== DEFAULT_NACOS_CONFIG_LIST_COLUMN_WIDTHS.length) return null;
+  const widths = value.map((item) => Number(item));
+  if (widths.some((item) => !Number.isFinite(item))) return null;
+  return widths.map((width, index) => Math.max(minWidthForColumn(index), width));
+}
+
+function loadNacosConfigListColumnWidths(): number[] {
+  const raw = safeLocalStorageGet(NACOS_CONFIG_LIST_COLUMN_WIDTHS_STORAGE_KEY);
+  if (!raw) return [...DEFAULT_NACOS_CONFIG_LIST_COLUMN_WIDTHS];
+  try {
+    const normalized = normalizeNacosConfigListColumnWidths(JSON.parse(raw));
+    return normalized ?? [...DEFAULT_NACOS_CONFIG_LIST_COLUMN_WIDTHS];
+  } catch {
+    return [...DEFAULT_NACOS_CONFIG_LIST_COLUMN_WIDTHS];
+  }
+}
+
+function saveNacosConfigListColumnWidths(widths: readonly number[]) {
+  const normalized = normalizeNacosConfigListColumnWidths([...widths]);
+  if (!normalized) return;
+  safeLocalStorageSet(NACOS_CONFIG_LIST_COLUMN_WIDTHS_STORAGE_KEY, JSON.stringify(normalized));
+}
+
+function gridTemplateColumnsForWidths(widths: readonly number[]) {
+  return widths.map((width) => `${width}px`).join(" ");
+}
+
+export function useNacosConfigListColumnResize() {
+  const columnWidths = ref(loadNacosConfigListColumnWidths());
+  const resizingColumnIndex = ref<number | null>(null);
+  const gridTemplateColumns = computed(() => gridTemplateColumnsForWidths(columnWidths.value));
+  const totalWidth = computed(() => columnWidths.value.reduce((sum, width) => sum + width, 0));
+  const minWidth = computed(() => `${totalWidth.value}px`);
+
+  function onResizeStart(columnIndex: number, event: MouseEvent) {
+    if (columnIndex < 0 || columnIndex >= columnWidths.value.length) return;
+    event.preventDefault();
+    const startX = event.clientX;
+    const startWidth = columnWidths.value[columnIndex] ?? minWidthForColumn(columnIndex);
+    resizingColumnIndex.value = columnIndex;
+
+    const onMove = (moveEvent: MouseEvent) => {
+      const delta = moveEvent.clientX - startX;
+      columnWidths.value[columnIndex] = Math.max(minWidthForColumn(columnIndex), startWidth + delta);
+    };
+
+    const onUp = (moveEvent: MouseEvent) => {
+      onMove(moveEvent);
+      resizingColumnIndex.value = null;
+      saveNacosConfigListColumnWidths(columnWidths.value);
+      document.removeEventListener("mousemove", onMove);
+      document.removeEventListener("mouseup", onUp);
+    };
+
+    document.addEventListener("mousemove", onMove);
+    document.addEventListener("mouseup", onUp);
+  }
+
+  return {
+    columnWidths,
+    gridTemplateColumns,
+    totalWidth,
+    minWidth,
+    resizingColumnIndex,
+    onResizeStart,
+  };
+}
diff --git a/apps/desktop/src/composables/useNavigationTargets.ts b/apps/desktop/src/composables/useNavigationTargets.ts
new file mode 100644
index 0000000..5aa513a
--- /dev/null
+++ b/apps/desktop/src/composables/useNavigationTargets.ts
@@ -0,0 +1,215 @@
+import * as api from "@/lib/backend/api";
+import { effectiveDatabaseTypeForConnection, metadataSchemaForConnection } from "@/lib/database/jdbcDialect";
+import { isNoSnapshotErrorResult } from "@/lib/query/queryResultError";
+import { buildTableSelectSql } from "@/lib/table/tableSelectSql";
+import { editableRowIdentifierColumns, usesSyntheticRowIdKey } from "@/lib/table/tableEditing";
+import { tableOpenPageLimit } from "@/lib/table/tableOpenPageLimit";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import type { TableInfoTab } from "@/types/database";
+
+export type NavigationTarget = {
+  connectionId: string;
+  database: string;
+  catalog?: string;
+  schema?: string;
+  tableName: string;
+  tableType?: string;
+  columnName?: string;
+  whereInput?: string;
+};
+
+async function openTableTarget(target: NavigationTarget, options: { tableInfoTab?: TableInfoTab } = {}) {
+  const connectionStore = useConnectionStore();
+  const queryStore = useQueryStore();
+  const settingsStore = useSettingsStore();
+  const pageLimit = tableOpenPageLimit();
+
+  connectionStore.activeConnectionId = target.connectionId;
+  const config = connectionStore.getConfig(target.connectionId);
+  const tabTitle = target.catalog ? `${target.catalog}.${target.schema || target.database}.${target.tableName}` : target.schema ? `${target.schema}.${target.tableName}` : target.tableName;
+  if (config?.db_type === "qdrant" || config?.db_type === "milvus" || config?.db_type === "weaviate" || config?.db_type === "chromadb") {
+    await connectionStore.ensureConnected(target.connectionId);
+    const tabId = queryStore.createTab(target.connectionId, target.database || "default", tabTitle, "vector");
+    queryStore.updateSql(tabId, target.tableName);
+    return;
+  }
+  const tabId = (() => {
+    if (settingsStore.editorSettings.reuseDataTab) {
+      const existing = queryStore.tabs.find((tab) => tab.mode === "data" && tab.connectionId === target.connectionId && tab.database === target.database && (tab.tableMeta?.catalog || "") === (target.catalog || ""));
+      if (existing) {
+        existing.title = tabTitle;
+        existing.schema = target.schema;
+        existing.tableInfoTab = options.tableInfoTab;
+        queryStore.switchTab(existing.id);
+        return existing.id;
+      }
+    }
+    return queryStore.createTab(target.connectionId, target.database, tabTitle, "data", target.schema);
+  })();
+  const targetTab = queryStore.tabs.find((tab) => tab.id === tabId);
+  if (targetTab) targetTab.tableInfoTab = options.tableInfoTab;
+  queryStore.setExecuting(tabId, true);
+
+  try {
+    await connectionStore.ensureConnected(target.connectionId);
+    if (!config) throw new Error("Connection config not found");
+    const effectiveDbType = effectiveDatabaseTypeForConnection(config);
+    const querySchema = metadataSchemaForConnection(config, target.database, target.schema);
+    const targetTableType = target.tableType ?? "TABLE";
+    if (config.db_type === "neo4j") {
+      const columns = await api.getColumns(target.connectionId, target.database, querySchema, target.tableName);
+      const primaryKeys = editableRowIdentifierColumns(effectiveDbType, columns, undefined, targetTableType);
+      const sql = await buildTableSelectSql({
+        databaseType: effectiveDbType,
+        schema: target.schema,
+        catalog: target.catalog,
+        tableName: target.tableName,
+        tableType: targetTableType,
+        columns: columns.map((column) => column.name),
+        primaryKeys,
+        whereInput: target.whereInput,
+        limit: pageLimit,
+      });
+      queryStore.updateSql(tabId, sql);
+      queryStore.setTableMeta(tabId, {
+        catalog: target.catalog,
+        schema: target.schema,
+        tableName: target.tableName,
+        tableType: targetTableType,
+        columns,
+        primaryKeys,
+      });
+      await queryStore.executeTabSql(tabId, sql, { pagination: { limit: pageLimit, offset: 0 } });
+      return;
+    }
+    const sql = await buildTableSelectSql({
+      databaseType: effectiveDbType,
+      schema: target.schema,
+      catalog: target.catalog,
+      tableName: target.tableName,
+      tableType: targetTableType,
+      whereInput: target.whereInput,
+      limit: pageLimit,
+    });
+    queryStore.updateSql(tabId, sql);
+    queryStore.setTableMeta(tabId, {
+      schema: target.schema,
+      catalog: target.catalog,
+      tableName: target.tableName,
+      tableType: targetTableType,
+      columns: [],
+      primaryKeys: [],
+    });
+    await queryStore.executeTabSql(tabId, sql, { pagination: { limit: pageLimit, offset: 0 } });
+    // executeTabSql surfaces query failures as an "Error" result instead of throwing.
+    // A snapshot-less lake table fails the data preview above but its metadata still
+    // reads fine — retry with LIMIT 0 so the user sees the table structure (columns +
+    // empty grid) rather than a cryptic server error. The flag also skips the
+    // synthetic-row-id re-query below, which is another data read that would fail
+    // the same way on a snapshot-less table.
+    const fellBackToLimitZero = isNoSnapshotErrorResult(queryStore.tabs.find((tab) => tab.id === tabId)?.result);
+    if (fellBackToLimitZero) {
+      const emptySql = await buildTableSelectSql({
+        databaseType: effectiveDbType,
+        schema: target.schema,
+        catalog: target.catalog,
+        tableName: target.tableName,
+        tableType: targetTableType,
+        whereInput: target.whereInput,
+        limit: 0,
+      });
+      queryStore.updateSql(tabId, emptySql);
+      await queryStore.executeTabSql(tabId, emptySql, { pagination: { limit: pageLimit, offset: 0 } });
+    }
+    try {
+      const columns = await api.getColumns(target.connectionId, target.database, querySchema, target.tableName, target.catalog);
+      const indexes = await api.listIndexes(target.connectionId, target.database, querySchema, target.tableName, target.catalog).catch(() => []);
+      const primaryKeys = editableRowIdentifierColumns(effectiveDbType, columns, indexes, targetTableType);
+      const useRowId = usesSyntheticRowIdKey(effectiveDbType, primaryKeys, targetTableType);
+      queryStore.setTableMeta(tabId, {
+        schema: target.schema,
+        catalog: target.catalog,
+        tableName: target.tableName,
+        tableType: targetTableType,
+        columns,
+        primaryKeys,
+      });
+      if (!fellBackToLimitZero && (useRowId || config.db_type === "tdengine")) {
+        const newSql = await buildTableSelectSql({
+          databaseType: effectiveDbType,
+          schema: target.schema,
+          catalog: target.catalog,
+          tableName: target.tableName,
+          tableType: targetTableType,
+          whereInput: target.whereInput,
+          primaryKeys,
+          columns: columns.map((column) => column.name),
+          includeRowId: true,
+          limit: pageLimit,
+        });
+        queryStore.updateSql(tabId, newSql);
+        await queryStore.executeTabSql(tabId, newSql, { pagination: { limit: pageLimit, offset: 0 } });
+      }
+    } catch (reason) {
+      console.error("[DBX] ERROR fetching table metadata:", reason);
+    }
+  } catch (e: any) {
+    queryStore.setErrorResult(tabId, e);
+  }
+}
+
+export function useNavigationTargets(dialogs: { showFieldLineageDialog: { value: boolean }; showDatabaseSearchDialog: { value: boolean }; showDiagramDialog: { value: boolean } }) {
+  const connectionStore = useConnectionStore();
+  const queryStore = useQueryStore();
+
+  async function openLineageTarget(target: NavigationTarget) {
+    dialogs.showFieldLineageDialog.value = false;
+    await openTableTarget(target);
+  }
+
+  async function openDatabaseSearchTarget(target: NavigationTarget) {
+    dialogs.showDatabaseSearchDialog.value = false;
+    await openTableTarget(target);
+  }
+
+  async function openDiagramTarget(target: NavigationTarget) {
+    dialogs.showDiagramDialog.value = false;
+    await openTableTarget(target);
+  }
+
+  async function onStructureEditorSaved(reloadData: () => Promise<void>, toast: (msg: string, duration?: number) => void, context: { connectionId: string; database: string; schema?: string; tableName: string }, commentChanged?: boolean) {
+    if (!context.tableName) {
+      try {
+        await connectionStore.refreshObjectListTreeNode(context.connectionId, context.database, context.schema || undefined);
+      } catch {}
+      return;
+    }
+    if (commentChanged) {
+      try {
+        await connectionStore.refreshObjectListTreeNode(context.connectionId, context.database, context.schema || undefined);
+      } catch {}
+    }
+    queryStore.invalidateTableStructure(context.connectionId, context.database, context.schema, context.tableName);
+    const matchingDataTabs = queryStore.tabs.filter((tab) => tab.mode === "data" && tab.connectionId === context.connectionId && tab.database === context.database && tab.tableMeta?.tableName === context.tableName && (tab.tableMeta.schema || "") === (context.schema || ""));
+    for (const tab of matchingDataTabs) {
+      try {
+        const connection = connectionStore.getConfig(tab.connectionId);
+        const metadataSchema = metadataSchemaForConnection(connection, tab.database, tab.tableMeta?.schema);
+        const columns = await api.getColumns(tab.connectionId, tab.database, metadataSchema, tab.tableMeta!.tableName);
+        const indexes = await api.listIndexes(tab.connectionId, tab.database, metadataSchema, tab.tableMeta!.tableName).catch(() => []);
+        queryStore.setTableMeta(tab.id, {
+          ...tab.tableMeta!,
+          columns,
+          primaryKeys: editableRowIdentifierColumns(effectiveDatabaseTypeForConnection(connection), columns, indexes, tab.tableMeta!.tableType),
+        });
+        if (tab.id === queryStore.activeTabId) await reloadData();
+      } catch (e: any) {
+        toast(e?.message || String(e), 5000);
+      }
+    }
+  }
+
+  return { openLineageTarget, openDatabaseSearchTarget, openDiagramTarget, onStructureEditorSaved, openTableTarget };
+}
diff --git a/apps/desktop/src/composables/usePanelResize.ts b/apps/desktop/src/composables/usePanelResize.ts
new file mode 100644
index 0000000..9b46505
--- /dev/null
+++ b/apps/desktop/src/composables/usePanelResize.ts
@@ -0,0 +1,51 @@
+import { ref, type Ref } from "vue";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+
+export function usePanelResize() {
+  const sidebarWidth = ref(Number(safeLocalStorageGet("dbx-sidebar-width")) || 260);
+  const aiPanelWidth = ref(Number(safeLocalStorageGet("dbx-ai-panel-width")) || 360);
+  const historyWidth = ref(Number(safeLocalStorageGet("dbx-history-width")) || 288);
+  const sqlLibraryWidth = ref(Number(safeLocalStorageGet("dbx-sql-library-width")) || 288);
+  const sqlFilePanelWidth = ref(Number(safeLocalStorageGet("dbx-sql-file-panel-width")) || 288);
+
+  function startPanelResize(widthRef: Ref<number>, storageKey: string, direction: "left" | "right") {
+    return (e: MouseEvent) => {
+      e.preventDefault();
+      const startX = e.clientX;
+      const startWidth = widthRef.value;
+
+      const onMouseMove = (ev: MouseEvent) => {
+        const delta = ev.clientX - startX;
+        widthRef.value = Math.max(180, Math.min(800, startWidth + (direction === "right" ? delta : -delta)));
+      };
+
+      const onMouseUp = () => {
+        document.removeEventListener("mousemove", onMouseMove);
+        document.removeEventListener("mouseup", onMouseUp);
+        safeLocalStorageSet(storageKey, String(widthRef.value));
+      };
+
+      document.addEventListener("mousemove", onMouseMove);
+      document.addEventListener("mouseup", onMouseUp);
+    };
+  }
+
+  const startSidebarResize = startPanelResize(sidebarWidth, "dbx-sidebar-width", "right");
+  const startAiPanelResize = startPanelResize(aiPanelWidth, "dbx-ai-panel-width", "left");
+  const startHistoryResize = startPanelResize(historyWidth, "dbx-history-width", "left");
+  const startSqlLibraryResize = startPanelResize(sqlLibraryWidth, "dbx-sql-library-width", "left");
+  const startSqlFilePanelResize = startPanelResize(sqlFilePanelWidth, "dbx-sql-file-panel-width", "left");
+
+  return {
+    sidebarWidth,
+    aiPanelWidth,
+    historyWidth,
+    sqlLibraryWidth,
+    sqlFilePanelWidth,
+    startSidebarResize,
+    startAiPanelResize,
+    startHistoryResize,
+    startSqlLibraryResize,
+    startSqlFilePanelResize,
+  };
+}
diff --git a/apps/desktop/src/composables/useQuickOpen.ts b/apps/desktop/src/composables/useQuickOpen.ts
new file mode 100644
index 0000000..3e7ac0c
--- /dev/null
+++ b/apps/desktop/src/composables/useQuickOpen.ts
@@ -0,0 +1,374 @@
+import { computed, ref } from "vue";
+import type { ConnectionConfig } from "@/types/database";
+import { useConnectionStore } from "@/stores/connectionStore";
+
+export interface QuickOpenItem {
+  id: string;
+  type: "connection" | "database" | "schema" | "table" | "view" | "materialized_view" | "procedure" | "function" | "sequence" | "package" | "package-body";
+  label: string;
+  description?: string;
+  connectionId: string;
+  database?: string;
+  schema?: string;
+  objectName?: string; // For non-table objects (views, procedures, functions, sequences, packages)
+  tableName?: string; // Kept for backward compatibility
+  connectionName?: string;
+  searchText: string; // Lowercase text for searching
+}
+
+/**
+ * Fuzzy match function that checks if query matches text
+ * Returns the matched indices for highlighting
+ */
+function fuzzyMatch(query: string, text: string): { score: number; indices: number[] } | null {
+  const lowerQuery = query.toLowerCase();
+  const lowerText = text.toLowerCase();
+
+  if (!lowerQuery) return { score: Infinity, indices: [] };
+  if (lowerText.includes(lowerQuery)) {
+    // Exact substring match gets highest score
+    const startIdx = lowerText.indexOf(lowerQuery);
+    return {
+      score: 1,
+      indices: Array.from({ length: lowerQuery.length }, (_, i) => startIdx + i),
+    };
+  }
+
+  // Fuzzy match: find all characters in order
+  let queryIdx = 0;
+  const indices: number[] = [];
+  let score = 0;
+  let lastMatchIdx = -1;
+
+  for (let i = 0; i < lowerText.length && queryIdx < lowerQuery.length; i++) {
+    if (lowerText[i] === lowerQuery[queryIdx]) {
+      indices.push(i);
+      // Score based on proximity (consecutive chars score better)
+      score += lastMatchIdx === i - 1 ? 2 : 1;
+      lastMatchIdx = i;
+      queryIdx++;
+    }
+  }
+
+  if (queryIdx === lowerQuery.length) {
+    return { score: score / lowerQuery.length, indices };
+  }
+
+  return null;
+}
+
+interface MatchedItem extends QuickOpenItem {
+  matchScore: number;
+  matchIndices: number[];
+}
+
+export function useQuickOpen() {
+  const connectionStore = useConnectionStore();
+  const searchQuery = ref("");
+  const selectedIndex = ref(0);
+
+  const allItems = computed((): QuickOpenItem[] => {
+    const items: QuickOpenItem[] = [];
+    const connections = connectionStore.connections;
+    const treeNodes = connectionStore.treeNodes;
+
+    // Add connections
+    for (const conn of connections) {
+      items.push({
+        id: `conn-${conn.id}`,
+        type: "connection",
+        label: conn.name,
+        connectionId: conn.id,
+        connectionName: conn.name,
+        searchText: `${conn.name}`,
+      });
+    }
+
+    // Add databases and tables from tree nodes
+    // Filter tree nodes by connection
+    for (const conn of connections) {
+      // Connections may live under sidebar groups, so locate their tree recursively.
+      const connectionTreeNode = findConnectionTreeNode(treeNodes, conn.id);
+      const connectionTreeNodes = connectionTreeNode?.children || treeNodes.filter((node) => node.connectionId === conn.id);
+      if (connectionTreeNodes.length === 0) continue;
+
+      // Process tree nodes to extract databases and tables
+      processDatabaseTreeNodes(connectionTreeNodes, conn, items);
+    }
+
+    return items;
+  });
+
+  function processDatabaseTreeNodes(nodes: any[], conn: ConnectionConfig, items: QuickOpenItem[]): void {
+    for (const node of nodes) {
+      // Skip certain node types
+      if (node.type === "group" || node.type === "linked-server-root") {
+        if (node.children) {
+          processDatabaseTreeNodes(node.children, conn, items);
+        }
+        continue;
+      }
+
+      // Database nodes
+      if (node.type === "database" && node.database) {
+        items.push({
+          id: `db-${conn.id}-${node.database}`,
+          type: "database",
+          label: node.label || node.database,
+          description: conn.name,
+          connectionId: conn.id,
+          database: node.database,
+          connectionName: conn.name,
+          searchText: `${conn.name} ${node.database}`,
+        });
+      }
+
+      // Schema nodes are navigable results and also contain database objects.
+      if (node.type === "schema" && node.database && node.schema) {
+        items.push({
+          id: `schema-${conn.id}-${node.database}-${node.schema}`,
+          type: "schema",
+          label: node.label || node.schema,
+          description: `${conn.name} / ${node.database}`,
+          connectionId: conn.id,
+          database: node.database,
+          schema: node.schema,
+          connectionName: conn.name,
+          searchText: `${conn.name} ${node.database} ${node.schema}`,
+        });
+        if (node.children) processDatabaseTreeNodes(node.children, conn, items);
+        continue;
+      }
+
+      // Table nodes
+      if (node.type === "table" && node.database && node.label) {
+        items.push({
+          id: `table-${conn.id}-${node.database}-${node.schema || ""}-${node.label}`,
+          type: "table",
+          label: node.label,
+          description: `${conn.name} / ${node.database}${node.schema ? " / " + node.schema : ""}`,
+          connectionId: conn.id,
+          database: node.database,
+          schema: node.schema,
+          tableName: node.label,
+          connectionName: conn.name,
+          searchText: `${conn.name} ${node.database} ${node.schema || ""} ${node.label}`,
+        });
+      }
+
+      // View nodes
+      if (node.type === "view" && node.database && node.label) {
+        items.push({
+          id: `view-${conn.id}-${node.database}-${node.schema || ""}-${node.label}`,
+          type: "view",
+          label: node.label,
+          description: `${conn.name} / ${node.database}${node.schema ? " / " + node.schema : ""}`,
+          connectionId: conn.id,
+          database: node.database,
+          schema: node.schema,
+          objectName: node.label,
+          connectionName: conn.name,
+          searchText: `${conn.name} ${node.database} ${node.schema || ""} ${node.label}`,
+        });
+      }
+
+      // Materialized view nodes
+      if (node.type === "materialized_view" && node.database && node.label) {
+        items.push({
+          id: `mview-${conn.id}-${node.database}-${node.schema || ""}-${node.label}`,
+          type: "materialized_view",
+          label: node.label,
+          description: `${conn.name} / ${node.database}${node.schema ? " / " + node.schema : ""}`,
+          connectionId: conn.id,
+          database: node.database,
+          schema: node.schema,
+          objectName: node.label,
+          connectionName: conn.name,
+          searchText: `${conn.name} ${node.database} ${node.schema || ""} ${node.label}`,
+        });
+      }
+
+      // Procedure nodes
+      if (node.type === "procedure" && node.database && node.label) {
+        items.push({
+          id: `proc-${conn.id}-${node.database}-${node.schema || ""}-${node.label}`,
+          type: "procedure",
+          label: node.label,
+          description: `${conn.name} / ${node.database}${node.schema ? " / " + node.schema : ""}`,
+          connectionId: conn.id,
+          database: node.database,
+          schema: node.schema,
+          objectName: node.label,
+          connectionName: conn.name,
+          searchText: `${conn.name} ${node.database} ${node.schema || ""} ${node.label}`,
+        });
+      }
+
+      // Function nodes
+      if (node.type === "function" && node.database && node.label) {
+        items.push({
+          id: `func-${conn.id}-${node.database}-${node.schema || ""}-${node.label}`,
+          type: "function",
+          label: node.label,
+          description: `${conn.name} / ${node.database}${node.schema ? " / " + node.schema : ""}`,
+          connectionId: conn.id,
+          database: node.database,
+          schema: node.schema,
+          objectName: node.label,
+          connectionName: conn.name,
+          searchText: `${conn.name} ${node.database} ${node.schema || ""} ${node.label}`,
+        });
+      }
+
+      // Sequence nodes
+      if (node.type === "sequence" && node.database && node.label) {
+        items.push({
+          id: `seq-${conn.id}-${node.database}-${node.schema || ""}-${node.label}`,
+          type: "sequence",
+          label: node.label,
+          description: `${conn.name} / ${node.database}${node.schema ? " / " + node.schema : ""}`,
+          connectionId: conn.id,
+          database: node.database,
+          schema: node.schema,
+          objectName: node.label,
+          connectionName: conn.name,
+          searchText: `${conn.name} ${node.database} ${node.schema || ""} ${node.label}`,
+        });
+      }
+
+      // Package nodes
+      if (node.type === "package" && node.database && node.label) {
+        items.push({
+          id: `pkg-${conn.id}-${node.database}-${node.schema || ""}-${node.label}`,
+          type: "package",
+          label: node.label,
+          description: `${conn.name} / ${node.database}${node.schema ? " / " + node.schema : ""}`,
+          connectionId: conn.id,
+          database: node.database,
+          schema: node.schema,
+          objectName: node.label,
+          connectionName: conn.name,
+          searchText: `${conn.name} ${node.database} ${node.schema || ""} ${node.label}`,
+        });
+      }
+
+      // Package-body nodes
+      if (node.type === "package-body" && node.database && node.label) {
+        items.push({
+          id: `pkgbody-${conn.id}-${node.database}-${node.schema || ""}-${node.label}`,
+          type: "package-body",
+          label: node.label,
+          description: `${conn.name} / ${node.database}${node.schema ? " / " + node.schema : ""}`,
+          connectionId: conn.id,
+          database: node.database,
+          schema: node.schema,
+          objectName: node.label,
+          connectionName: conn.name,
+          searchText: `${conn.name} ${node.database} ${node.schema || ""} ${node.label}`,
+        });
+      }
+
+      // Process children recursively
+      if (node.children) {
+        processDatabaseTreeNodes(node.children, conn, items);
+      }
+    }
+  }
+
+  function findConnectionTreeNode(nodes: any[], connectionId: string): any | undefined {
+    for (const node of nodes) {
+      if (node.type === "connection" && node.connectionId === connectionId) return node;
+      if (node.children) {
+        const match = findConnectionTreeNode(node.children, connectionId);
+        if (match) return match;
+      }
+    }
+    return undefined;
+  }
+
+  const filteredItems = computed((): MatchedItem[] => {
+    if (!searchQuery.value.trim()) {
+      return allItems.value.map((item) => ({
+        ...item,
+        matchScore: Infinity,
+        matchIndices: [],
+      }));
+    }
+
+    const matched: MatchedItem[] = [];
+
+    for (const item of allItems.value) {
+      const result = fuzzyMatch(searchQuery.value, item.searchText);
+      if (result) {
+        matched.push({
+          ...item,
+          matchScore: result.score,
+          matchIndices: result.indices,
+        });
+      }
+    }
+
+    // Sort by score and type (connections > databases > tables > other objects for equal scores)
+    matched.sort((a, b) => {
+      if (a.matchScore !== b.matchScore) {
+        return a.matchScore - b.matchScore; // Lower scores (better matches) come first
+      }
+
+      const typeOrder = {
+        connection: 0,
+        database: 1,
+        schema: 2,
+        table: 3,
+        view: 4,
+        materialized_view: 5,
+        procedure: 6,
+        function: 7,
+        sequence: 8,
+        package: 9,
+        "package-body": 10,
+      };
+      return typeOrder[a.type] - typeOrder[b.type];
+    });
+
+    return matched;
+  });
+
+  const selectedItem = computed((): MatchedItem | null => {
+    if (selectedIndex.value < 0 || selectedIndex.value >= filteredItems.value.length) {
+      return null;
+    }
+    return filteredItems.value[selectedIndex.value];
+  });
+
+  function selectNext(): void {
+    if (selectedIndex.value < filteredItems.value.length - 1) {
+      selectedIndex.value++;
+    }
+  }
+
+  function selectPrevious(): void {
+    if (selectedIndex.value > 0) {
+      selectedIndex.value--;
+    }
+  }
+
+  function resetSelection(): void {
+    selectedIndex.value = 0;
+  }
+
+  function setQuery(query: string): void {
+    searchQuery.value = query;
+    resetSelection();
+  }
+
+  return {
+    searchQuery,
+    filteredItems,
+    selectedIndex,
+    selectedItem,
+    selectNext,
+    selectPrevious,
+    resetSelection,
+    setQuery,
+  };
+}
diff --git a/apps/desktop/src/composables/useSchemaDiffConfig.ts b/apps/desktop/src/composables/useSchemaDiffConfig.ts
new file mode 100644
index 0000000..23f27b6
--- /dev/null
+++ b/apps/desktop/src/composables/useSchemaDiffConfig.ts
@@ -0,0 +1,252 @@
+import { ref, computed, watch } from "vue";
+import { uuid } from "@/lib/common/utils";
+import type { SchemaDiffConfig, SchemaDiffCompareOptions } from "@/types/schemaDiff";
+import { createEmptyConfig, getDefaultOptionsForDbType } from "@/types/schemaDiff";
+
+const STORAGE_KEY = "dbx-schema-diff-configs";
+const HISTORY_KEY = "dbx-schema-diff-history";
+const MAX_HISTORY = 10;
+
+const configs = ref<SchemaDiffConfig[]>(loadConfigsFromStorage());
+const activeConfigId = ref<string>("");
+const recentConfigs = ref<SchemaDiffConfig[]>(loadHistoryFromStorage());
+
+function loadConfigsFromStorage(): SchemaDiffConfig[] {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw) as SchemaDiffConfig[];
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function loadHistoryFromStorage(): SchemaDiffConfig[] {
+  try {
+    const raw = localStorage.getItem(HISTORY_KEY);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw) as SchemaDiffConfig[];
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+function saveConfigsToStorage() {
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(configs.value));
+}
+
+function saveHistoryToStorage() {
+  localStorage.setItem(HISTORY_KEY, JSON.stringify(recentConfigs.value));
+}
+
+function createDefaultConfig(dbType?: string): SchemaDiffConfig {
+  const id = uuid();
+  const config = createEmptyConfig(id, "Default");
+  if (dbType) {
+    config.options = getDefaultOptionsForDbType(dbType);
+  }
+  return config;
+}
+
+export function useSchemaDiffConfig() {
+  const activeConfig = computed(() => configs.value.find((c) => c.id === activeConfigId.value) ?? configs.value[0] ?? null);
+
+  function ensureDefaultConfig(dbType?: string) {
+    if (configs.value.length === 0) {
+      const defaultConfig = createDefaultConfig(dbType);
+      configs.value.push(defaultConfig);
+      activeConfigId.value = defaultConfig.id;
+      saveConfigsToStorage();
+    } else if (!activeConfigId.value) {
+      activeConfigId.value = configs.value[0].id;
+    }
+  }
+
+  function createConfig(name: string, base?: SchemaDiffConfig, dbType?: string): SchemaDiffConfig {
+    const id = uuid();
+    const config = base ? { ...base, id, name, createdAt: Date.now(), updatedAt: Date.now() } : createEmptyConfig(id, name);
+    if (dbType && !base) {
+      config.options = getDefaultOptionsForDbType(dbType);
+    }
+    configs.value.push(config);
+    activeConfigId.value = id;
+    saveConfigsToStorage();
+    return config;
+  }
+
+  function updateConfig(id: string, updates: Partial<Omit<SchemaDiffConfig, "id" | "createdAt">>) {
+    const index = configs.value.findIndex((c) => c.id === id);
+    if (index === -1) return;
+    configs.value[index] = {
+      ...configs.value[index],
+      ...updates,
+      updatedAt: Date.now(),
+    };
+    saveConfigsToStorage();
+  }
+
+  function renameConfig(id: string, name: string) {
+    updateConfig(id, { name });
+  }
+
+  function deleteConfig(id: string) {
+    configs.value = configs.value.filter((c) => c.id !== id);
+    if (activeConfigId.value === id) {
+      activeConfigId.value = configs.value[0]?.id ?? "";
+    }
+    saveConfigsToStorage();
+  }
+
+  function duplicateConfig(id: string) {
+    const source = configs.value.find((c) => c.id === id);
+    if (!source) return;
+    let newName = `${source.name} (1)`;
+    let counter = 1;
+    while (configs.value.some((c) => c.name === newName)) {
+      counter++;
+      newName = `${source.name} (${counter})`;
+    }
+    createConfig(newName, source);
+  }
+
+  function exportConfigs(): string {
+    return JSON.stringify(configs.value, null, 2);
+  }
+
+  function exportActiveConfig(): string {
+    if (!activeConfig.value) return "";
+    return JSON.stringify(activeConfig.value, null, 2);
+  }
+
+  function importConfigs(
+    jsonText: string,
+    mode: "merge" | "replace" = "merge",
+  ): {
+    imported: number;
+    renamed: number;
+  } {
+    const parsed = JSON.parse(jsonText) as SchemaDiffConfig | SchemaDiffConfig[];
+    const items = Array.isArray(parsed) ? parsed : [parsed];
+    let renamed = 0;
+
+    if (mode === "replace") {
+      configs.value = [];
+    }
+
+    for (const item of items) {
+      let name = item.name;
+      if (configs.value.some((c) => c.name === name && c.id !== item.id)) {
+        let counter = 1;
+        let candidate = `${name} (${counter})`;
+        while (configs.value.some((c) => c.name === candidate)) {
+          counter++;
+          candidate = `${name} (${counter})`;
+        }
+        name = candidate;
+        renamed++;
+      }
+      const newId = uuid();
+      configs.value.push({
+        ...item,
+        id: newId,
+        name,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+    }
+
+    saveConfigsToStorage();
+    if (!activeConfigId.value && configs.value.length > 0) {
+      activeConfigId.value = configs.value[0].id;
+    }
+
+    return { imported: items.length, renamed };
+  }
+
+  function updateActiveConfigOptions(options: SchemaDiffCompareOptions) {
+    if (!activeConfig.value) return;
+    updateConfig(activeConfig.value.id, { options: { ...options } });
+  }
+
+  function updateActiveConfigConnection(updates: Partial<SchemaDiffConfig>) {
+    if (!activeConfig.value) return;
+    const filtered: Partial<SchemaDiffConfig> = {};
+    if (updates.sourceConnectionId !== undefined) filtered.sourceConnectionId = updates.sourceConnectionId;
+    if (updates.sourceDatabase !== undefined) filtered.sourceDatabase = updates.sourceDatabase;
+    if (updates.sourceSchema !== undefined) filtered.sourceSchema = updates.sourceSchema;
+    if (updates.targetConnectionId !== undefined) filtered.targetConnectionId = updates.targetConnectionId;
+    if (updates.targetDatabase !== undefined) filtered.targetDatabase = updates.targetDatabase;
+    if (updates.targetSchema !== undefined) filtered.targetSchema = updates.targetSchema;
+    updateConfig(activeConfig.value.id, filtered);
+  }
+
+  function saveToHistory(config: SchemaDiffConfig) {
+    // Check if same config already exists (same connection/db/schema)
+    const existingIndex = recentConfigs.value.findIndex(
+      (c) => c.sourceConnectionId === config.sourceConnectionId && c.sourceDatabase === config.sourceDatabase && c.sourceSchema === config.sourceSchema && c.targetConnectionId === config.targetConnectionId && c.targetDatabase === config.targetDatabase && c.targetSchema === config.targetSchema,
+    );
+
+    if (existingIndex !== -1) {
+      // Update existing entry
+      recentConfigs.value[existingIndex] = {
+        ...config,
+        id: recentConfigs.value[existingIndex].id,
+        updatedAt: Date.now(),
+      };
+      // Move to front
+      const updated = recentConfigs.value.splice(existingIndex, 1)[0];
+      recentConfigs.value.unshift(updated);
+    } else {
+      // Add new entry
+      recentConfigs.value.unshift({
+        ...config,
+        id: uuid(),
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+    }
+
+    // Keep only MAX_HISTORY items
+    if (recentConfigs.value.length > MAX_HISTORY) {
+      recentConfigs.value = recentConfigs.value.slice(0, MAX_HISTORY);
+    }
+
+    saveHistoryToStorage();
+  }
+
+  function loadFromHistory(configId: string) {
+    const config = recentConfigs.value.find((c) => c.id === configId);
+    if (!config) return null;
+    return config;
+  }
+
+  function deleteFromHistory(configId: string) {
+    recentConfigs.value = recentConfigs.value.filter((c) => c.id !== configId);
+    saveHistoryToStorage();
+  }
+
+  watch(configs, saveConfigsToStorage, { deep: true });
+
+  return {
+    configs: computed(() => configs.value),
+    activeConfigId,
+    activeConfig,
+    recentConfigs: computed(() => recentConfigs.value),
+    ensureDefaultConfig,
+    createConfig,
+    updateConfig,
+    renameConfig,
+    deleteConfig,
+    duplicateConfig,
+    exportConfigs,
+    exportActiveConfig,
+    importConfigs,
+    updateActiveConfigOptions,
+    updateActiveConfigConnection,
+    saveToHistory,
+    loadFromHistory,
+    deleteFromHistory,
+  };
+}
diff --git a/apps/desktop/src/composables/useSchemaOptions.ts b/apps/desktop/src/composables/useSchemaOptions.ts
new file mode 100644
index 0000000..0415547
--- /dev/null
+++ b/apps/desktop/src/composables/useSchemaOptions.ts
@@ -0,0 +1,69 @@
+import { ref } from "vue";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { isSchemaAware as isSchemaAwareType, isSingleDatabase, usesTreeSchemaMode } from "@/lib/database/databaseCapabilities";
+import { sortSidebarNames } from "@/lib/database/databaseTree";
+import { filterSchemaNamesForConnection } from "@/lib/database/visibleDatabases";
+import type { ConnectionConfig } from "@/types/database";
+import * as api from "@/lib/backend/api";
+
+export function hasSchemaOptionsCacheEntry(options: Record<string, string[]>, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(options, key);
+}
+
+export function schemaOptionsForConnection(schemaNames: string[], connection: Pick<ConnectionConfig, "db_type" | "driver_profile" | "visible_databases" | "visible_schemas"> | undefined, database = ""): string[] {
+  // Keep numeric schema suffixes in human order (SCHEMA2 before SCHEMA10), matching the database tree.
+  return sortSidebarNames(filterSchemaNamesForConnection(schemaNames, connection, database));
+}
+
+export function useSchemaOptions() {
+  const connectionStore = useConnectionStore();
+
+  const schemaOptions = ref<Record<string, string[]>>({});
+  const loadingSchemaOptions = ref<Record<string, boolean>>({});
+
+  function cacheKey(connectionId: string, database: string) {
+    return `${connectionId}:${database}`;
+  }
+
+  function isSchemaAware(connectionId: string): boolean {
+    return isSchemaAwareType(connectionStore.getConfig(connectionId)?.db_type);
+  }
+
+  async function loadSchemaOptions(connectionId: string, database: string) {
+    if (!isSchemaAware(connectionId)) return;
+    const connection = connectionStore.getConfig(connectionId);
+    const dbType = connection?.db_type;
+    if (!database && !isSingleDatabase(dbType) && !usesTreeSchemaMode(dbType)) return;
+    const key = cacheKey(connectionId, database);
+    if (hasSchemaOptionsCacheEntry(schemaOptions.value, key)) return;
+    if (loadingSchemaOptions.value[key]) return;
+
+    loadingSchemaOptions.value[key] = true;
+    try {
+      await connectionStore.ensureConnected(connectionId);
+      schemaOptions.value[key] = schemaOptionsForConnection(await api.listSchemas(connectionId, database), connection, database);
+    } catch (e) {
+      schemaOptions.value[key] = [];
+      throw e;
+    } finally {
+      loadingSchemaOptions.value[key] = false;
+    }
+  }
+
+  function getSchemaOptionsForDb(connectionId: string, database: string): string[] {
+    return schemaOptions.value[cacheKey(connectionId, database)] ?? [];
+  }
+
+  function isLoadingSchemas(connectionId: string, database: string): boolean {
+    return !!loadingSchemaOptions.value[cacheKey(connectionId, database)];
+  }
+
+  return {
+    schemaOptions,
+    loadingSchemaOptions,
+    loadSchemaOptions,
+    getSchemaOptionsForDb,
+    isLoadingSchemas,
+    isSchemaAware,
+  };
+}
diff --git a/apps/desktop/src/composables/useSqlExecution.ts b/apps/desktop/src/composables/useSqlExecution.ts
new file mode 100644
index 0000000..5fad05f
--- /dev/null
+++ b/apps/desktop/src/composables/useSqlExecution.ts
@@ -0,0 +1,291 @@
+import { ref, watch, type Ref, type ComputedRef } from "vue";
+import { useI18n } from "vue-i18n";
+import { useQueryStore } from "@/stores/queryStore";
+import { useHistoryStore } from "@/stores/historyStore";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useToast } from "@/composables/useToast";
+import { isSingleDatabase, usesTreeSchemaMode } from "@/lib/database/databaseCapabilities";
+import { canExecuteWithoutSelectedDatabase } from "@/lib/connection/connectionLevelDatabaseBootstrap";
+import { classifySqlActivityKind } from "@/lib/history/historyActivityKind";
+import { sqlMetadataRefreshTarget } from "@/lib/sql/sqlMetadataRefresh";
+import { isMysqlExecutionErrorResult, usesMysqlProtocolDatabaseType } from "@/lib/query/queryResultError";
+import { classifyRedisCommandSafety, firstRedisCommandToken } from "@/lib/redis/redisCommandSafety";
+import { isSqlExecutionSnapshot, resolveExecutableSql, type SqlExecutionOverride, type SqlExecutionSnapshot } from "@/lib/sql/sqlExecutionTarget";
+import { extractSqlParameterDescriptors, type SqlParameterDescriptor, type SqlParameterSyntax } from "@/lib/sql/sqlParameters";
+import { expandSqlVariables } from "@/lib/sql/sqlVariables";
+import { enabledSqlParameterSyntaxes, resolveSqlVariableSyntaxToggles } from "@/lib/sql/sqlVariableSyntax";
+import { assessProductionSql } from "@/lib/database/productionSafety";
+import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
+import type { ConnectionConfig, DatabaseType, QueryTab } from "@/types/database";
+
+const DANGER_RE = /^\s*(DROP|DELETE|TRUNCATE|ALTER|UPDATE|MERGE|REPLACE)\b/i;
+
+export function stripSqlComments(sql: string): string {
+  return sql
+    .replace(/\/\*[\s\S]*?\*\//g, " ")
+    .replace(/--.*$/gm, " ")
+    .replace(/#.*$/gm, " ");
+}
+
+export function isDangerousSql(sql: string): boolean {
+  const cleaned = stripSqlComments(sql);
+  return cleaned.split(";").some((stmt) => DANGER_RE.test(stmt));
+}
+
+function primarySqlOperation(sql: string): string {
+  const cleaned = stripSqlComments(sql);
+  const statement = cleaned
+    .split(";")
+    .map((part) => part.trim())
+    .find(Boolean);
+  return statement?.match(/^([a-z]+)/i)?.[1]?.toUpperCase() || "SQL";
+}
+
+function firstQueryExecutionError(tab: Pick<QueryTab, "result" | "results">, databaseType: DatabaseType | undefined) {
+  const activeResult = tab.result;
+  if (activeResult && isMysqlExecutionErrorResult(activeResult, databaseType)) return activeResult;
+  if (!usesMysqlProtocolDatabaseType(databaseType) && activeResult?.columns.includes("Error")) return activeResult;
+  if (!usesMysqlProtocolDatabaseType(databaseType)) return undefined;
+
+  const results = tab.results?.length ? tab.results : tab.result ? [tab.result] : [];
+  return results.find((result) => isMysqlExecutionErrorResult(result, databaseType));
+}
+
+export function useSqlExecution(deps: {
+  activeTab: ComputedRef<QueryTab | undefined>;
+  activeConnection: ComputedRef<ConnectionConfig | undefined>;
+  executableSql: ComputedRef<string>;
+  resolveExecutableSql?: (snapshot?: SqlExecutionSnapshot) => Promise<string>;
+  activeOutputView: Ref<"result" | "summary" | "explain" | "chart">;
+  blockDangerousRedisCommands?: Ref<boolean>;
+  onMissingDatabase?: () => void;
+}) {
+  const { t } = useI18n();
+  const queryStore = useQueryStore();
+  const historyStore = useHistoryStore();
+  const connectionStore = useConnectionStore();
+  const settingsStore = useSettingsStore();
+  const productionSafetyStore = useProductionSafetyStore();
+  const { toast } = useToast();
+
+  const dangerSql = ref("");
+  const pendingDangerSql = ref("");
+  const showDangerDialog = ref(false);
+  const suppressDangerConfirm = ref(false);
+  const explainMode = ref<"explain" | "autotrace">("explain");
+  const showSqlParameterDialog = ref(false);
+  const sqlParameterSourceSql = ref("");
+  const sqlParameterNames = ref<SqlParameterDescriptor[]>([]);
+  const sqlParameterDatabaseType = ref<DatabaseType | undefined>();
+  const sqlParameterEnabledSyntaxes = ref<SqlParameterSyntax[]>([]);
+
+  async function resolvedExecutableSql(source?: SqlExecutionOverride): Promise<string> {
+    const atSetEnabled = resolveSqlVariableSyntaxToggles(settingsStore.editorSettings.sqlVariableSyntaxOverrides, deps.activeConnection.value?.db_type).atSet;
+    const expand = (sql: string) => (atSetEnabled ? expandSqlVariables(sql).sql : sql);
+    if (typeof source === "string") return expand(source);
+    if (deps.resolveExecutableSql) return expand(await deps.resolveExecutableSql(source));
+    if (isSqlExecutionSnapshot(source)) return expand(resolveExecutableSql(source.fullSql, source.selectedSql, { cursorPos: source.cursorPos }));
+    return expand(deps.executableSql.value);
+  }
+
+  async function tryExecute(sqlOverride?: SqlExecutionOverride) {
+    const tab = deps.activeTab.value;
+    const sql = await resolvedExecutableSql(sqlOverride);
+    if (!tab || !sql.trim()) return;
+    if (requiresDatabaseSelection(tab, deps.activeConnection.value, sql)) {
+      deps.onMissingDatabase?.();
+      return;
+    }
+    if (supportsSqlTemplateParameters(deps.activeConnection.value) && prepareSqlParameterDialog(sql)) return;
+    await continueExecute(sql);
+  }
+
+  async function continueExecute(sql: string) {
+    // Redis: block dangerous commands when toggle is on (check each line for multi-line input)
+    if (deps.activeConnection.value?.db_type === "redis" && deps.blockDangerousRedisCommands?.value !== false) {
+      const commands = sql
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+      for (const cmd of commands) {
+        const safety = classifyRedisCommandSafety(cmd);
+        if (safety === "blocked") {
+          toast(t("redis.blockedCommand", { command: firstRedisCommandToken(cmd) }), 5000);
+          return;
+        }
+      }
+    }
+    const productionAssessment = assessProductionSql(sql, deps.activeConnection.value, deps.activeTab.value?.database);
+    if (productionAssessment.active && productionAssessment.isMutation) {
+      // Production writes always need a new explicit decision; editor preferences cannot suppress this gate.
+      const confirmed = await productionSafetyStore.requestConfirmation({
+        sql,
+        connectionName: deps.activeConnection.value?.name,
+        database: deps.activeTab.value?.database,
+        productionDatabases: productionAssessment.databases,
+        source: t("production.sourceSqlEditor"),
+      });
+      if (confirmed) await doExecute(sql);
+      return;
+    }
+    if (isDangerousSql(sql) && settingsStore.editorSettings.confirmDangerousSqlExecution) {
+      dangerSql.value = sql;
+      pendingDangerSql.value = sql;
+      suppressDangerConfirm.value = false;
+      showDangerDialog.value = true;
+    } else {
+      await doExecute(sql);
+    }
+  }
+
+  function prepareSqlParameterDialog(sql: string): boolean {
+    const databaseType = deps.activeConnection.value?.db_type;
+    const toggles = resolveSqlVariableSyntaxToggles(settingsStore.editorSettings.sqlVariableSyntaxOverrides, databaseType);
+    const enabledSyntaxes = enabledSqlParameterSyntaxes(toggles);
+    const parameters = extractSqlParameterDescriptors(sql, { databaseType, enabledSyntaxes });
+    if (!parameters.length) return false;
+    sqlParameterSourceSql.value = sql;
+    sqlParameterNames.value = parameters;
+    sqlParameterDatabaseType.value = databaseType;
+    sqlParameterEnabledSyntaxes.value = enabledSyntaxes;
+    showSqlParameterDialog.value = true;
+    return true;
+  }
+
+  async function doExecute(sql?: string) {
+    sql ??= await resolvedExecutableSql();
+    const tab = deps.activeTab.value;
+    if (!tab || !sql.trim()) return;
+    const executionConnection = connectionStore.getConfig(tab.connectionId) ?? deps.activeConnection.value;
+    const executionDatabaseType = executionConnection?.db_type;
+    if (requiresDatabaseSelection(tab, executionConnection, sql)) {
+      deps.onMissingDatabase?.();
+      return;
+    }
+    deps.activeOutputView.value = "result";
+    const connName = executionConnection?.name || "";
+    const start = Date.now();
+    const isRedis = executionDatabaseType === "redis";
+    await queryStore.executeCurrentSql(sql, isRedis ? { skipRedisSafetyCheck: deps.blockDangerousRedisCommands?.value === false } : undefined);
+    if (tab.result && !tab.result.columns.length && !tab.results?.some((result) => result.columns.length > 0)) {
+      deps.activeOutputView.value = "summary";
+    }
+    const elapsed = Date.now() - start;
+    const failure = firstQueryExecutionError(tab, executionDatabaseType);
+    const success = !failure;
+    historyStore.add({
+      connection_id: tab.connectionId,
+      connection_name: connName,
+      database: tab.database,
+      sql,
+      execution_time_ms: elapsed,
+      success,
+      error: failure ? String(failure.rows?.[0]?.[0] ?? "") : undefined,
+      activity_kind: classifySqlActivityKind(sql),
+      operation: primarySqlOperation(sql),
+      affected_rows: success ? tab.result?.affected_rows : undefined,
+    });
+    if (success) {
+      const refreshTarget = sqlMetadataRefreshTarget(sql, tab.schema);
+      if (refreshTarget.scope === "connection") {
+        await connectionStore.loadDatabases(tab.connectionId, { force: true });
+      } else if (refreshTarget.scope === "database") {
+        await connectionStore.refreshObjectListTreeNode(tab.connectionId, tab.database, refreshTarget.schema);
+      }
+    }
+  }
+
+  function cancelActiveExecution() {
+    const tab = deps.activeTab.value;
+    if (!tab) return;
+    if (tab.isExecuting) void queryStore.cancelTabExecution(tab.id);
+    else if (tab.isExplaining) void queryStore.cancelTabExplain(tab.id);
+  }
+
+  function explainReasonMessage(reason: string): string {
+    if (reason === "unsupported") return t("explain.unsupported");
+    if (reason === "unsafe") return t("explain.unsafe");
+    return t("explain.emptySql");
+  }
+
+  async function tryExplain(sqlOverride?: SqlExecutionOverride) {
+    const tab = deps.activeTab.value;
+    const sql = await resolvedExecutableSql(sqlOverride);
+    if (!tab || !sql.trim()) {
+      toast(t("explain.emptySql"));
+      return;
+    }
+
+    deps.activeOutputView.value = "explain";
+    const result = await queryStore.explainTabSql(tab.id, sql, deps.activeConnection.value?.db_type, explainMode.value);
+    if (!result.ok) {
+      toast(explainReasonMessage(result.reason), 5000);
+      return;
+    }
+
+    const current = deps.activeTab.value;
+    if (current?.explainError) toast(current.explainError, 5000);
+  }
+
+  async function onDangerConfirm() {
+    const sql = pendingDangerSql.value || (await resolvedExecutableSql());
+    if (suppressDangerConfirm.value) {
+      settingsStore.updateEditorSettings({ confirmDangerousSqlExecution: false });
+    }
+    suppressDangerConfirm.value = false;
+    pendingDangerSql.value = "";
+    await doExecute(sql);
+  }
+
+  async function onSqlParametersConfirm(sql: string) {
+    showSqlParameterDialog.value = false;
+    sqlParameterSourceSql.value = "";
+    sqlParameterNames.value = [];
+    sqlParameterDatabaseType.value = undefined;
+    sqlParameterEnabledSyntaxes.value = [];
+    await continueExecute(sql);
+  }
+
+  watch(showSqlParameterDialog, (open) => {
+    if (open) return;
+    sqlParameterSourceSql.value = "";
+    sqlParameterNames.value = [];
+    sqlParameterDatabaseType.value = undefined;
+    sqlParameterEnabledSyntaxes.value = [];
+  });
+
+  return {
+    dangerSql,
+    pendingDangerSql,
+    showDangerDialog,
+    suppressDangerConfirm,
+    tryExecute,
+    doExecute,
+    cancelActiveExecution,
+    tryExplain,
+    onDangerConfirm,
+    showSqlParameterDialog,
+    sqlParameterSourceSql,
+    sqlParameterNames,
+    sqlParameterDatabaseType,
+    sqlParameterEnabledSyntaxes,
+    onSqlParametersConfirm,
+    explainMode,
+  };
+}
+
+function supportsSqlTemplateParameters(connection: ConnectionConfig | undefined): boolean {
+  if (!connection) return false;
+  return connection.db_type !== "redis" && connection.db_type !== "mongodb";
+}
+
+export function requiresDatabaseSelection(tab: QueryTab, connection: ConnectionConfig | undefined, sql = ""): boolean {
+  if (tab.mode !== "query") return false;
+  if (!connection) return false;
+  if (tab.database) return false;
+  if (tab.database === "" && usesTreeSchemaMode(connection.db_type)) return false;
+  if (isSingleDatabase(connection.db_type)) return false;
+  if (canExecuteWithoutSelectedDatabase(connection, sql)) return false;
+  return !["elasticsearch", "qdrant", "milvus", "weaviate", "chromadb", "zookeeper"].includes(connection.db_type);
+}
diff --git a/apps/desktop/src/composables/useSqlHighlighter.ts b/apps/desktop/src/composables/useSqlHighlighter.ts
new file mode 100644
index 0000000..454a8e8
--- /dev/null
+++ b/apps/desktop/src/composables/useSqlHighlighter.ts
@@ -0,0 +1,20 @@
+import { onMounted, ref } from "vue";
+import { useTheme } from "@/composables/useTheme";
+import { type SqlHighlighter, createShikiSqlHighlighter } from "@/lib/sql/sqlHighlighter";
+
+export function useSqlHighlighter() {
+  const { isDark } = useTheme();
+  const sqlHighlighter = ref<SqlHighlighter>();
+
+  onMounted(async () => {
+    sqlHighlighter.value = await createShikiSqlHighlighter({
+      appearance: () => (isDark.value ? "dark" : "light"),
+    });
+  });
+
+  function highlight(sql: string): string {
+    return sqlHighlighter.value?.(sql) ?? sql;
+  }
+
+  return { highlight, sqlHighlighter };
+}
diff --git a/apps/desktop/src/composables/useTabDrag.ts b/apps/desktop/src/composables/useTabDrag.ts
new file mode 100644
index 0000000..1d5fca6
--- /dev/null
+++ b/apps/desktop/src/composables/useTabDrag.ts
@@ -0,0 +1,175 @@
+import { reactive, readonly } from "vue";
+
+export type TabDropPosition = "before" | "after";
+
+interface TabDragState {
+  active: boolean;
+  draggedId: string | null;
+  targetId: string | null;
+  dropPosition: TabDropPosition | null;
+  wasDragged: boolean;
+  startX: number;
+  startY: number;
+}
+
+const DRAG_THRESHOLD = 5;
+
+const state = reactive<TabDragState>({
+  active: false,
+  draggedId: null,
+  targetId: null,
+  dropPosition: null,
+  wasDragged: false,
+  startX: 0,
+  startY: 0,
+});
+
+let pending: {
+  id: string;
+  x: number;
+  y: number;
+  sourceEl: HTMLElement | null;
+} | null = null;
+let onDropCallback: ((draggedId: string, targetId: string, position: TabDropPosition) => void) | null = null;
+let ghostEl: HTMLElement | null = null;
+
+function createGhost(sourceEl: HTMLElement, x: number, y: number) {
+  const ghost = document.createElement("div");
+  const textNode = sourceEl.querySelector(".truncate");
+  ghost.textContent = textNode?.textContent || "";
+  ghost.style.cssText = `
+    position: fixed;
+    pointer-events: none;
+    z-index: 9999;
+    opacity: 0.9;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.15);
+    border-radius: 6px;
+    background: var(--background, #fff);
+    border: 1px solid var(--border, #e5e7eb);
+    max-width: 200px;
+    height: 28px;
+    padding: 0 12px;
+    font-size: 12px;
+    line-height: 28px;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    left: ${x + 12}px;
+    top: ${y - 14}px;
+  `;
+  document.body.appendChild(ghost);
+  return ghost;
+}
+
+function moveGhost(x: number, y: number) {
+  if (!ghostEl) return;
+  ghostEl.style.left = `${x + 8}px`;
+  ghostEl.style.top = `${y - 14}px`;
+}
+
+function removeGhost() {
+  if (ghostEl) {
+    ghostEl.remove();
+    ghostEl = null;
+  }
+}
+
+function onMouseMove(event: MouseEvent) {
+  if (!pending && !state.active) return;
+
+  if (pending && !state.active) {
+    const dx = event.clientX - pending.x;
+    const dy = event.clientY - pending.y;
+    if (Math.abs(dx) < DRAG_THRESHOLD && Math.abs(dy) < DRAG_THRESHOLD) return;
+    state.active = true;
+    state.wasDragged = true;
+    state.draggedId = pending.id;
+    state.startX = pending.x;
+    state.startY = pending.y;
+    if (pending.sourceEl) {
+      ghostEl = createGhost(pending.sourceEl, event.clientX, event.clientY);
+    }
+    pending = null;
+    document.body.style.cursor = "grabbing";
+    document.body.style.userSelect = "none";
+  }
+
+  if (state.active) {
+    moveGhost(event.clientX, event.clientY);
+  }
+}
+
+function onMouseUp() {
+  if (state.active && state.draggedId && state.targetId && state.dropPosition && onDropCallback) {
+    onDropCallback(state.draggedId, state.targetId, state.dropPosition);
+  }
+  reset();
+}
+
+function reset() {
+  state.active = false;
+  state.draggedId = null;
+  state.targetId = null;
+  state.dropPosition = null;
+  state.startX = 0;
+  state.startY = 0;
+  pending = null;
+  removeGhost();
+  document.body.style.cursor = "";
+  document.body.style.userSelect = "";
+}
+
+let listenersAttached = false;
+
+function ensureListeners() {
+  if (listenersAttached) return;
+  document.addEventListener("mousemove", onMouseMove, true);
+  document.addEventListener("mouseup", onMouseUp, true);
+  listenersAttached = true;
+}
+
+export function useTabDrag(onDrop: (draggedId: string, targetId: string, position: TabDropPosition) => void) {
+  ensureListeners();
+  onDropCallback = onDrop;
+
+  function startDrag(event: MouseEvent, tabId: string) {
+    if (event.button !== 0) return;
+    const target = event.target as HTMLElement;
+    if (target.closest("button, input, [data-tab-title-input]")) return;
+    state.wasDragged = false;
+    const el = (event.currentTarget as HTMLElement) || null;
+    pending = { id: tabId, x: event.clientX, y: event.clientY, sourceEl: el };
+  }
+
+  function updateTarget(event: MouseEvent, tabId: string) {
+    if (!state.active || tabId === state.draggedId) {
+      if (state.targetId === tabId) {
+        state.targetId = null;
+        state.dropPosition = null;
+      }
+      return;
+    }
+
+    state.targetId = tabId;
+
+    const el = event.currentTarget as HTMLElement;
+    const rect = el.getBoundingClientRect();
+    const x = event.clientX - rect.left;
+
+    state.dropPosition = x < rect.width / 2 ? "before" : "after";
+  }
+
+  function clearTarget(tabId: string) {
+    if (state.targetId === tabId) {
+      state.targetId = null;
+      state.dropPosition = null;
+    }
+  }
+
+  return {
+    state: readonly(state),
+    startDrag,
+    updateTarget,
+    clearTarget,
+  };
+}
diff --git a/apps/desktop/src/composables/useTabScroll.ts b/apps/desktop/src/composables/useTabScroll.ts
new file mode 100644
index 0000000..34fa07b
--- /dev/null
+++ b/apps/desktop/src/composables/useTabScroll.ts
@@ -0,0 +1,147 @@
+import { onBeforeUnmount, ref, watch, type Ref } from "vue";
+
+export function useTabScroll(tabsContainerRef: Ref<HTMLElement | null>) {
+  const hasTabOverflow = ref(false);
+  const scrollThumbLeftPercent = ref(0);
+  const scrollThumbWidthPercent = ref(100);
+  const isScrollbarDragging = ref(false);
+  let resizeObserver: ResizeObserver | null = null;
+  let updateFrame = 0;
+  let dragState: {
+    trackRect: DOMRect;
+    thumbOffsetPx: number;
+  } | null = null;
+
+  function updateScrollButtons() {
+    const el = tabsContainerRef.value;
+    if (!el) {
+      hasTabOverflow.value = false;
+      scrollThumbLeftPercent.value = 0;
+      scrollThumbWidthPercent.value = 100;
+      return;
+    }
+    const maxScrollLeft = Math.max(0, el.scrollWidth - el.clientWidth);
+    hasTabOverflow.value = maxScrollLeft > 1;
+    const rawThumbWidth = el.scrollWidth > 0 ? (el.clientWidth / el.scrollWidth) * 100 : 100;
+    const thumbWidth = Math.min(100, Math.max(8, rawThumbWidth));
+    const thumbTravel = Math.max(0, 100 - thumbWidth);
+    scrollThumbWidthPercent.value = thumbWidth;
+    scrollThumbLeftPercent.value = maxScrollLeft > 0 ? (el.scrollLeft / maxScrollLeft) * thumbTravel : 0;
+  }
+
+  function scheduleScrollButtonUpdate() {
+    if (updateFrame) return;
+    const update = () => {
+      updateFrame = 0;
+      updateScrollButtons();
+    };
+    if (typeof requestAnimationFrame === "function") {
+      updateFrame = requestAnimationFrame(update);
+    } else {
+      window.setTimeout(update, 0);
+    }
+  }
+
+  function onTabsWheel(event: WheelEvent) {
+    const el = tabsContainerRef.value;
+    if (!el) return;
+    const maxScrollLeft = Math.max(0, el.scrollWidth - el.clientWidth);
+    if (maxScrollLeft <= 1) return;
+
+    const delta = Math.abs(event.deltaX) > Math.abs(event.deltaY) ? event.deltaX : event.deltaY;
+    if (delta === 0) return;
+
+    const previousScrollLeft = el.scrollLeft;
+    el.scrollLeft = Math.min(maxScrollLeft, Math.max(0, previousScrollLeft + delta));
+    if (el.scrollLeft !== previousScrollLeft) {
+      event.preventDefault();
+      updateScrollButtons();
+    }
+  }
+
+  function applyScrollbarDrag(clientX: number) {
+    const el = tabsContainerRef.value;
+    if (!el || !dragState) return;
+
+    const maxScrollLeft = Math.max(0, el.scrollWidth - el.clientWidth);
+    if (maxScrollLeft <= 1) return;
+
+    const thumbWidthPx = dragState.trackRect.width * (scrollThumbWidthPercent.value / 100);
+    const maxThumbLeftPx = Math.max(1, dragState.trackRect.width - thumbWidthPx);
+    const thumbLeftPx = Math.min(maxThumbLeftPx, Math.max(0, clientX - dragState.trackRect.left - dragState.thumbOffsetPx));
+    el.scrollLeft = (thumbLeftPx / maxThumbLeftPx) * maxScrollLeft;
+    updateScrollButtons();
+  }
+
+  function onScrollbarPointerMove(event: PointerEvent) {
+    if (!dragState) return;
+    event.preventDefault();
+    applyScrollbarDrag(event.clientX);
+  }
+
+  function stopScrollbarDrag() {
+    if (!dragState) return;
+    dragState = null;
+    isScrollbarDragging.value = false;
+    window.removeEventListener("pointermove", onScrollbarPointerMove, true);
+    window.removeEventListener("pointerup", stopScrollbarDrag, true);
+    window.removeEventListener("pointercancel", stopScrollbarDrag, true);
+    document.body.style.userSelect = "";
+  }
+
+  function startScrollbarDrag(event: PointerEvent) {
+    const el = tabsContainerRef.value;
+    const track = event.currentTarget as HTMLElement | null;
+    if (!el || !track || !hasTabOverflow.value) return;
+
+    const trackRect = track.getBoundingClientRect();
+    const thumbLeftPx = trackRect.width * (scrollThumbLeftPercent.value / 100);
+    const thumbWidthPx = trackRect.width * (scrollThumbWidthPercent.value / 100);
+    const pointerX = event.clientX - trackRect.left;
+    const pointerInsideThumb = pointerX >= thumbLeftPx && pointerX <= thumbLeftPx + thumbWidthPx;
+
+    dragState = {
+      trackRect,
+      thumbOffsetPx: pointerInsideThumb ? pointerX - thumbLeftPx : thumbWidthPx / 2,
+    };
+    isScrollbarDragging.value = true;
+    document.body.style.userSelect = "none";
+    window.addEventListener("pointermove", onScrollbarPointerMove, true);
+    window.addEventListener("pointerup", stopScrollbarDrag, true);
+    window.addEventListener("pointercancel", stopScrollbarDrag, true);
+    event.preventDefault();
+    applyScrollbarDrag(event.clientX);
+  }
+
+  watch(
+    tabsContainerRef,
+    (el) => {
+      resizeObserver?.disconnect();
+      resizeObserver = null;
+      if (el && typeof ResizeObserver !== "undefined") {
+        resizeObserver = new ResizeObserver(scheduleScrollButtonUpdate);
+        resizeObserver.observe(el);
+      }
+      scheduleScrollButtonUpdate();
+    },
+    { flush: "post" },
+  );
+
+  onBeforeUnmount(() => {
+    resizeObserver?.disconnect();
+    stopScrollbarDrag();
+    if (updateFrame && typeof cancelAnimationFrame === "function") {
+      cancelAnimationFrame(updateFrame);
+    }
+  });
+
+  return {
+    hasTabOverflow,
+    scrollThumbLeftPercent,
+    scrollThumbWidthPercent,
+    isScrollbarDragging,
+    updateScrollButtons,
+    onTabsWheel,
+    startScrollbarDrag,
+  };
+}
diff --git a/apps/desktop/src/composables/useTauriEvents.ts b/apps/desktop/src/composables/useTauriEvents.ts
new file mode 100644
index 0000000..86dc779
--- /dev/null
+++ b/apps/desktop/src/composables/useTauriEvents.ts
@@ -0,0 +1,117 @@
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useQueryStore } from "@/stores/queryStore";
+import type { NavigationTarget } from "@/composables/useNavigationTargets";
+
+export function useTauriEvents(deps: { openTableTarget: (target: NavigationTarget) => Promise<void>; openSqlFilePath: (path: string) => Promise<void>; openDbFilePath: (path: string) => Promise<void>; openConnectionDeepLink: (url: string) => Promise<void> }) {
+  const connectionStore = useConnectionStore();
+  const queryStore = useQueryStore();
+  const unlistenHandles: Array<() => void> = [];
+
+  function focusCurrentWindow() {
+    void import("@tauri-apps/api/window").then(({ getCurrentWindow }) =>
+      getCurrentWindow()
+        .setFocus()
+        .catch(() => {}),
+    );
+  }
+
+  function setupTauriListeners() {
+    import("@tauri-apps/api/event")
+      .then(({ listen }) => {
+        listen<{ connection_id: string; database: string; schema?: string; table: string }>("mcp-open-table", async (event) => {
+          try {
+            const { connection_id, database, schema, table } = event.payload;
+            if (!connectionStore.connections.length) await connectionStore.initFromDisk();
+            const config = connectionStore.getConfig(connection_id);
+            if (!config) return;
+            connectionStore.activeConnectionId = connection_id;
+            await connectionStore.ensureConnected(connection_id);
+            if (config.db_type === "redis") {
+              queryStore.createTab(connection_id, database || "0", `db${database || "0"}`, "redis");
+            } else if (config.db_type === "mongodb") {
+              queryStore.createTab(connection_id, database, table, "mongo");
+            } else {
+              deps.openTableTarget({ connectionId: connection_id, database, schema, tableName: table });
+            }
+            focusCurrentWindow();
+          } catch (e) {
+            console.error("[DBX] mcp-open-table error:", e);
+          }
+        }).then((unlisten) => unlistenHandles.push(unlisten));
+
+        listen("mcp-reload-connections", async () => {
+          try {
+            await connectionStore.initFromDisk();
+          } catch (e) {
+            console.error("[DBX] mcp-reload-connections error:", e);
+          }
+        }).then((unlisten) => unlistenHandles.push(unlisten));
+
+        listen<{
+          connection_id: string;
+          database: string;
+          sql: string;
+          allow_writes?: boolean;
+          allow_dangerous?: boolean;
+        }>("mcp-execute-query", async (event) => {
+          try {
+            const { connection_id, database, sql, allow_writes, allow_dangerous } = event.payload;
+            if (!connectionStore.connections.length) await connectionStore.initFromDisk();
+            const config = connectionStore.getConfig(connection_id);
+            if (!config) return;
+            connectionStore.activeConnectionId = connection_id;
+            await connectionStore.ensureConnected(connection_id);
+            const tabId = queryStore.createTab(connection_id, database, undefined, "query");
+            queryStore.updateSql(tabId, sql);
+            await queryStore.executeTabSql(tabId, sql, {
+              mongoSafety: { allowWrites: !!allow_writes, allowDangerous: !!allow_dangerous },
+            });
+            focusCurrentWindow();
+          } catch (e) {
+            console.error("[DBX] mcp-execute-query error:", e);
+          }
+        }).then((unlisten) => unlistenHandles.push(unlisten));
+
+        listen<string[]>("dbx-open-sql-files", async (event) => {
+          try {
+            for (const path of event.payload) {
+              await deps.openSqlFilePath(path);
+            }
+            focusCurrentWindow();
+          } catch (e) {
+            console.error("[DBX] dbx-open-sql-files error:", e);
+          }
+        }).then((unlisten) => unlistenHandles.push(unlisten));
+
+        listen<string[]>("dbx-open-db-files", async (event) => {
+          try {
+            for (const path of event.payload) {
+              await deps.openDbFilePath(path);
+            }
+            focusCurrentWindow();
+          } catch (e) {
+            console.error("[DBX] dbx-open-db-files error:", e);
+          }
+        }).then((unlisten) => unlistenHandles.push(unlisten));
+
+        listen<string[]>("dbx-open-connection-links", async (event) => {
+          try {
+            for (const url of event.payload) {
+              await deps.openConnectionDeepLink(url);
+            }
+            focusCurrentWindow();
+          } catch (e) {
+            console.error("[DBX] dbx-open-connection-links error:", e);
+          }
+        }).then((unlisten) => unlistenHandles.push(unlisten));
+      })
+      .catch(() => {});
+  }
+
+  function cleanupTauriListeners() {
+    unlistenHandles.forEach((unlisten) => unlisten());
+    unlistenHandles.length = 0;
+  }
+
+  return { setupTauriListeners, cleanupTauriListeners };
+}
diff --git a/apps/desktop/src/composables/useTheme.ts b/apps/desktop/src/composables/useTheme.ts
new file mode 100644
index 0000000..42ceb48
--- /dev/null
+++ b/apps/desktop/src/composables/useTheme.ts
@@ -0,0 +1,101 @@
+import { computed, ref } from "vue";
+import {
+  APP_THEME_PALETTE_CLASS_NAMES,
+  APP_THEME_PALETTE_STORAGE_KEY,
+  APP_THEME_STORAGE_KEY,
+  getAppThemePaletteClass,
+  getTauriThemeForMode,
+  isSystemAppThemeMode,
+  normalizeAppThemeMode,
+  normalizeAppThemePalette,
+  resolveAppThemeAppearance,
+  type AppThemeMode,
+  type AppThemePalette,
+} from "@/lib/app/appTheme";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+
+const savedThemeMode = safeLocalStorageGet(APP_THEME_STORAGE_KEY);
+const themeMode = ref<AppThemeMode>(normalizeAppThemeMode(savedThemeMode));
+const savedThemePalette = safeLocalStorageGet(APP_THEME_PALETTE_STORAGE_KEY);
+const themePalette = ref<AppThemePalette>(normalizeAppThemePalette(savedThemePalette));
+if (savedThemeMode && savedThemeMode !== themeMode.value) safeLocalStorageSet(APP_THEME_STORAGE_KEY, themeMode.value);
+const systemPrefersDark = ref(readSystemPrefersDark());
+const isDark = computed(() => resolveAppThemeAppearance(themeMode.value, systemPrefersDark.value) === "dark");
+
+let mediaQuery: MediaQueryList | null = null;
+let isListeningForSystemTheme = false;
+let cachedTauriWindow: typeof import("@tauri-apps/api/window") | null = null;
+
+function readSystemPrefersDark() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return false;
+  return window.matchMedia("(prefers-color-scheme: dark)").matches;
+}
+
+function setupSystemThemeListener() {
+  if (isListeningForSystemTheme || typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+  mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+  systemPrefersDark.value = mediaQuery.matches;
+  const onChange = (event: MediaQueryListEvent) => {
+    systemPrefersDark.value = event.matches;
+    if (isSystemAppThemeMode(themeMode.value)) applyTheme();
+  };
+  mediaQuery.addEventListener("change", onChange);
+  isListeningForSystemTheme = true;
+}
+
+function applyTheme() {
+  if (typeof document === "undefined") return;
+
+  const doc = document.documentElement;
+  const dark = isDark.value;
+
+  doc.classList.add("disable-transitions");
+  doc.classList.toggle("dark", dark);
+  for (const className of APP_THEME_PALETTE_CLASS_NAMES) doc.classList.remove(className);
+  const paletteClass = getAppThemePaletteClass(themePalette.value);
+  if (paletteClass) doc.classList.add(paletteClass);
+  doc.style.colorScheme = dark ? "dark" : "light";
+
+  // force reflow so the class toggle takes effect before re-enabling transitions
+  doc.offsetHeight; // eslint-disable-line @typescript-eslint/no-unused-expressions
+  requestAnimationFrame(() => doc.classList.remove("disable-transitions"));
+
+  if (!isTauriRuntime()) return;
+  if (cachedTauriWindow) {
+    cachedTauriWindow
+      .getCurrentWindow()
+      .setTheme(getTauriThemeForMode(themeMode.value))
+      .catch(() => {});
+  } else {
+    import("@tauri-apps/api/window").then((mod) => {
+      cachedTauriWindow = mod;
+      mod
+        .getCurrentWindow()
+        .setTheme(getTauriThemeForMode(themeMode.value))
+        .catch(() => {});
+    });
+  }
+}
+
+function setThemeMode(mode: AppThemeMode) {
+  themeMode.value = mode;
+  safeLocalStorageSet(APP_THEME_STORAGE_KEY, mode);
+  applyTheme();
+}
+
+function setThemePalette(palette: AppThemePalette) {
+  themePalette.value = palette;
+  safeLocalStorageSet(APP_THEME_PALETTE_STORAGE_KEY, palette);
+  applyTheme();
+}
+
+export function useTheme() {
+  setupSystemThemeListener();
+
+  function toggleTheme() {
+    setThemeMode(isDark.value ? "light" : "dark");
+  }
+
+  return { isDark, themeMode, themePalette, applyTheme, setThemeMode, setThemePalette, toggleTheme };
+}
diff --git a/apps/desktop/src/composables/useToast.ts b/apps/desktop/src/composables/useToast.ts
new file mode 100644
index 0000000..c30eef2
--- /dev/null
+++ b/apps/desktop/src/composables/useToast.ts
@@ -0,0 +1,32 @@
+import { ref, type Ref } from "vue";
+
+type ToastState = {
+  message: Ref<string>;
+  visible: Ref<boolean>;
+  timer: number;
+};
+
+declare global {
+  var __DBX_TOAST_STATE__: ToastState | undefined;
+}
+
+const toastState =
+  globalThis.__DBX_TOAST_STATE__ ??
+  (globalThis.__DBX_TOAST_STATE__ = {
+    message: ref(""),
+    visible: ref(false),
+    timer: 0,
+  });
+
+export function useToast() {
+  function toast(msg: string, duration = 2000) {
+    toastState.message.value = msg;
+    toastState.visible.value = true;
+    clearTimeout(toastState.timer);
+    toastState.timer = window.setTimeout(() => {
+      toastState.visible.value = false;
+    }, duration);
+  }
+
+  return { message: toastState.message, visible: toastState.visible, toast };
+}
diff --git a/apps/desktop/src/composables/useVisibilityChange.ts b/apps/desktop/src/composables/useVisibilityChange.ts
new file mode 100644
index 0000000..801aa79
--- /dev/null
+++ b/apps/desktop/src/composables/useVisibilityChange.ts
@@ -0,0 +1,32 @@
+import { onMounted, onUnmounted } from "vue";
+import { refreshConnections } from "@/lib/backend/api";
+import { useQueryStore } from "@/stores/queryStore";
+
+let hiddenAt: number | null = null;
+
+function handleVisibilityChange() {
+  if (document.hidden) {
+    hiddenAt = Date.now();
+  } else {
+    const wasHidden = hiddenAt;
+    hiddenAt = null;
+    if (wasHidden && Date.now() - wasHidden > 30_000) {
+      refreshConnections().catch(() => {});
+      const queryStore = useQueryStore();
+      const stuckTabs = queryStore.tabs.filter((t) => t.isExecuting);
+      if (stuckTabs.length > 0) {
+        queryStore.notifyConnectionMayBeLost();
+      }
+    }
+  }
+}
+
+export function useVisibilityChange() {
+  onMounted(() => {
+    document.addEventListener("visibilitychange", handleVisibilityChange);
+  });
+
+  onUnmounted(() => {
+    document.removeEventListener("visibilitychange", handleVisibilityChange);
+  });
+}
diff --git a/apps/desktop/src/composables/useWebDavAutoUpload.ts b/apps/desktop/src/composables/useWebDavAutoUpload.ts
new file mode 100644
index 0000000..b318938
--- /dev/null
+++ b/apps/desktop/src/composables/useWebDavAutoUpload.ts
@@ -0,0 +1,69 @@
+import { onMounted, onUnmounted } from "vue";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { appendDebugLog } from "@/lib/backend/debugLog";
+import { webdavSyncUpload } from "@/lib/backend/api";
+import { readWebDavAutoUploadConfig, WEB_DAV_AUTO_UPLOAD_STORAGE_KEYS } from "@/lib/webdav/webdavAutoUploadConfig";
+
+export function useWebDavAutoUpload() {
+  const settingsStore = useSettingsStore();
+  let timer: ReturnType<typeof window.setInterval> | undefined;
+  let uploading = false;
+
+  function clearTimer() {
+    if (!timer) return;
+    window.clearInterval(timer);
+    timer = undefined;
+  }
+
+  function schedule() {
+    clearTimer();
+    const config = readWebDavAutoUploadConfig();
+    if (!config.enabled || !config.webDavConfig) return;
+
+    timer = window.setInterval(() => {
+      void runAutoUpload();
+    }, config.intervalMinutes * 60_000);
+  }
+
+  async function runAutoUpload() {
+    if (uploading) return;
+    const config = readWebDavAutoUploadConfig();
+    if (!config.enabled || !config.webDavConfig) return;
+
+    uploading = true;
+    try {
+      const summary = await webdavSyncUpload(config.webDavConfig, settingsStore.editorSettings);
+      appendDebugLog("info", "[DBX][webdav:auto-upload:success]", {
+        bytes: summary.bytes,
+        remotePath: summary.remotePath,
+        exportedAt: summary.exportedAt,
+      });
+    } catch (error) {
+      appendDebugLog("error", "[DBX][webdav:auto-upload:error]", error);
+    } finally {
+      uploading = false;
+    }
+  }
+
+  function onStorage(event: StorageEvent) {
+    if (event.key && !WEB_DAV_AUTO_UPLOAD_STORAGE_KEYS.includes(event.key as (typeof WEB_DAV_AUTO_UPLOAD_STORAGE_KEYS)[number])) return;
+    schedule();
+  }
+
+  onMounted(() => {
+    schedule();
+    window.addEventListener("storage", onStorage);
+    window.addEventListener("dbx:webdav-auto-upload-config-changed", schedule);
+  });
+
+  onUnmounted(() => {
+    clearTimer();
+    window.removeEventListener("storage", onStorage);
+    window.removeEventListener("dbx:webdav-auto-upload-config-changed", schedule);
+  });
+
+  return {
+    scheduleWebDavAutoUpload: schedule,
+    runWebDavAutoUpload: runAutoUpload,
+  };
+}
diff --git a/apps/desktop/src/composables/useWindowControls.ts b/apps/desktop/src/composables/useWindowControls.ts
new file mode 100644
index 0000000..4a8be83
--- /dev/null
+++ b/apps/desktop/src/composables/useWindowControls.ts
@@ -0,0 +1,100 @@
+import { ref, onMounted, onUnmounted } from "vue";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { isMacOS } from "@/lib/backend/platform";
+import * as api from "@/lib/backend/api";
+
+const MIN_UI_SCALE = 0.75;
+const MAX_UI_SCALE = 2;
+export const MAC_TRAFFIC_LIGHT_X = 16;
+export const MAC_TRAFFIC_LIGHT_BASE_Y = 18;
+const MAC_TRAFFIC_LIGHT_SCALE_DELTA_Y = 20;
+const MAC_TRAFFIC_LIGHT_RESERVED_INSET = 70;
+
+function normalizeTrafficLightUiScale(scale: number): number {
+  return Number.isFinite(scale) ? Math.min(MAX_UI_SCALE, Math.max(MIN_UI_SCALE, scale)) : 1;
+}
+
+export function macTrafficLightPositionForScale(scale: number): { x: number; y: number } {
+  const normalizedScale = normalizeTrafficLightUiScale(scale);
+  return {
+    x: MAC_TRAFFIC_LIGHT_X,
+    y: Math.round(MAC_TRAFFIC_LIGHT_BASE_Y + (normalizedScale - 1) * MAC_TRAFFIC_LIGHT_SCALE_DELTA_Y),
+  };
+}
+
+export function macTrafficLightInsetPaddingForScale(scale: number): string {
+  const normalizedScale = normalizeTrafficLightUiScale(scale);
+  return `${Math.ceil(MAC_TRAFFIC_LIGHT_RESERVED_INSET / normalizedScale)}px`;
+}
+
+export function shouldReserveMacTrafficLightInset(isMac: boolean, isFullscreen: boolean, isDesktop = true): boolean {
+  return isDesktop && isMac && !isFullscreen;
+}
+
+export function shouldShowWindowControls(isMac: boolean, isDesktop = true): boolean {
+  return isDesktop && !isMac;
+}
+
+export function shouldDrawDesktopWindowFrame(isMac: boolean, isDesktop = true): boolean {
+  return isDesktop && !isMac;
+}
+
+export function useWindowControls() {
+  const isMaximized = ref(false);
+  const isFullscreen = ref(false);
+  const isMac = isMacOS();
+  const isDesktop = isTauriRuntime();
+  const showControls = shouldShowWindowControls(isMac, isDesktop);
+
+  let unlisten: (() => void) | null = null;
+
+  async function updateWindowState() {
+    if (!isDesktop) return;
+    const { getCurrentWindow } = await import("@tauri-apps/api/window");
+    const currentWindow = getCurrentWindow();
+    const [maximized, fullscreen] = await Promise.all([currentWindow.isMaximized(), currentWindow.isFullscreen()]);
+    isMaximized.value = maximized;
+    isFullscreen.value = fullscreen;
+  }
+
+  async function minimize() {
+    const { getCurrentWindow } = await import("@tauri-apps/api/window");
+    await getCurrentWindow().minimize();
+  }
+
+  async function toggleMaximize() {
+    const { getCurrentWindow } = await import("@tauri-apps/api/window");
+    await getCurrentWindow().toggleMaximize();
+    setTimeout(updateWindowState, 50);
+  }
+
+  async function close() {
+    if (!isDesktop) return;
+    await api.requestAppClose();
+  }
+
+  onMounted(async () => {
+    if (!isDesktop) return;
+    await updateWindowState();
+    const { getCurrentWindow } = await import("@tauri-apps/api/window");
+    const unlistenFn = await getCurrentWindow().onResized(() => {
+      void updateWindowState();
+    });
+    unlisten = unlistenFn;
+  });
+
+  onUnmounted(() => {
+    unlisten?.();
+  });
+
+  return {
+    isMac,
+    isDesktop,
+    showControls,
+    isMaximized,
+    isFullscreen,
+    minimize,
+    toggleMaximize,
+    close,
+  };
+}
diff --git a/apps/desktop/src/env.d.ts b/apps/desktop/src/env.d.ts
new file mode 100644
index 0000000..c8d055a
--- /dev/null
+++ b/apps/desktop/src/env.d.ts
@@ -0,0 +1,15 @@
+/// <reference types="vite/client" />
+
+declare module "*.vue" {
+  import type { DefineComponent } from "vue";
+  const component: DefineComponent<{}, {}, any>;
+  export default component;
+}
+
+declare module "dom-to-image-more" {
+  const domtoimage: {
+    toPng(node: HTMLElement, options?: Record<string, any>): Promise<string>;
+    toBlob(node: HTMLElement, options?: Record<string, any>): Promise<Blob>;
+  };
+  export default domtoimage;
+}
diff --git a/apps/desktop/src/i18n/__tests__/sqliteRebuildNotice.spec.ts b/apps/desktop/src/i18n/__tests__/sqliteRebuildNotice.spec.ts
new file mode 100644
index 0000000..ce94335
--- /dev/null
+++ b/apps/desktop/src/i18n/__tests__/sqliteRebuildNotice.spec.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it as test } from "vitest";
+import en from "@/i18n/locales/en";
+import es from "@/i18n/locales/es";
+import it from "@/i18n/locales/it";
+import ja from "@/i18n/locales/ja";
+import ptBR from "@/i18n/locales/pt-BR";
+import zhCN from "@/i18n/locales/zh-CN";
+import zhTW from "@/i18n/locales/zh-TW";
+
+function sqliteRebuildNotice(messages: Record<string, unknown>): string {
+  const structureEditor = messages.structureEditor as Record<string, unknown>;
+  return String(structureEditor.sqliteRebuildNotice);
+}
+
+describe("SQLite rebuild notice", () => {
+  test.each([
+    ["English", en],
+    ["Spanish", es],
+    ["Italian", it],
+    ["Japanese", ja],
+    ["Brazilian Portuguese", ptBR],
+    ["Simplified Chinese", zhCN],
+    ["Traditional Chinese", zhTW],
+  ])("warns about retained backup, forced CAST conversion, lossy values, and rollback in %s", (_locale, messages) => {
+    const notice = sqliteRebuildNotice(messages);
+
+    expect(notice.length).toBeGreaterThan(30);
+    expect(notice).toContain("CAST");
+    expect(notice).toContain("0.0");
+  });
+});
diff --git a/apps/desktop/src/i18n/backend-errors.ts b/apps/desktop/src/i18n/backend-errors.ts
new file mode 100644
index 0000000..e0330a4
--- /dev/null
+++ b/apps/desktop/src/i18n/backend-errors.ts
@@ -0,0 +1,29 @@
+import type { ComposerTranslation } from "vue-i18n";
+
+const patterns: [RegExp, string][] = [
+  [/^(.+?) driver is not installed\. Please install it from the Driver Manager\.$/, "connection.driverNotInstalled"],
+  [/^JRE (.+?) runtime is not installed\. Please install it from the Driver Manager\.$/, "connection.jreNotInstalled"],
+  [/^System Java runtime was not found on PATH\. Please install Java or choose a custom Java executable\.$/, "connection.systemJavaNotFound"],
+  [/^Custom Java runtime path is empty\. Please choose a Java executable\.$/, "connection.customJavaPathEmpty"],
+  [/^Agent requires Java 21, but DBX started it with an older Java runtime\. Use DBX managed JRE 21 or select a Java 21 executable in Driver Manager\./, "connection.agentJavaTooOld"],
+  [/^JDBC plugin is not installed\. Install the optional JDBC plugin to use this connection\.$/, "connection.jdbcPluginNotInstalled"],
+];
+
+const paramNames: Record<string, string> = {
+  "connection.driverNotInstalled": "driver",
+  "connection.jreNotInstalled": "jre",
+};
+
+export function translateBackendError(t: ComposerTranslation, message: string): string {
+  for (const [regex, key] of patterns) {
+    const match = message.match(regex);
+    if (match) {
+      const name = paramNames[key];
+      if (name && match[1]) {
+        return t(key, { [name]: match[1] });
+      }
+      return t(key);
+    }
+  }
+  return message;
+}
diff --git a/apps/desktop/src/i18n/index.ts b/apps/desktop/src/i18n/index.ts
new file mode 100644
index 0000000..896cf78
--- /dev/null
+++ b/apps/desktop/src/i18n/index.ts
@@ -0,0 +1,110 @@
+import { createI18n } from "vue-i18n";
+import en from "./locales/en";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+
+export type Locale = "en" | "es" | "it" | "ja" | "pt-BR" | "zh-CN" | "zh-TW";
+type LocaleMessages = Record<string, unknown>;
+type I18nGlobal = {
+  locale: { value: Locale };
+  setLocaleMessage: (locale: Locale, messages: LocaleMessages) => void;
+};
+
+const supportedLocales: Locale[] = ["en", "es", "it", "ja", "pt-BR", "zh-CN", "zh-TW"];
+const defaultLocale: Locale = "en";
+const loadedLocales = new Set<Locale>([defaultLocale]);
+const localeLoaders: Record<Exclude<Locale, "en">, () => Promise<{ default: LocaleMessages }>> = {
+  es: () => import("./locales/es"),
+  it: () => import("./locales/it"),
+  ja: () => import("./locales/ja"),
+  "pt-BR": () => import("./locales/pt-BR"),
+  "zh-CN": () => import("./locales/zh-CN"),
+  "zh-TW": () => import("./locales/zh-TW"),
+};
+
+export function normalizeLocale(value: string | null): Locale | null {
+  if (value && supportedLocales.includes(value as Locale)) {
+    return value as Locale;
+  }
+  return null;
+}
+
+export function localeFromLanguageTag(value: string | null | undefined): Locale | null {
+  if (!value) return null;
+  const normalized = value.replace("_", "-").toLowerCase();
+  if (normalized === "zh" || normalized.startsWith("zh-")) {
+    if (normalized.includes("hant") || normalized.startsWith("zh-tw") || normalized.startsWith("zh-hk") || normalized.startsWith("zh-mo")) {
+      return "zh-TW";
+    }
+    return "zh-CN";
+  }
+  if (normalized === "en" || normalized.startsWith("en-")) return "en";
+  if (normalized === "es" || normalized.startsWith("es-")) return "es";
+  if (normalized === "it" || normalized.startsWith("it-")) return "it";
+  if (normalized === "ja" || normalized.startsWith("ja-")) return "ja";
+  if (normalized === "pt" || normalized.startsWith("pt-")) return "pt-BR";
+  return null;
+}
+
+export function detectLocaleFromLanguages(languages: readonly string[]): Locale {
+  for (const language of languages) {
+    const locale = normalizeLocale(language) ?? localeFromLanguageTag(language);
+    if (locale) return locale;
+  }
+  return defaultLocale;
+}
+
+function detectUserLocale(): Locale {
+  try {
+    const languages = globalThis.navigator?.languages;
+    const language = globalThis.navigator?.language;
+    const candidates = Array.isArray(languages) ? [...languages] : [];
+    if (language) candidates.push(language);
+    return detectLocaleFromLanguages(candidates);
+  } catch {
+    return defaultLocale;
+  }
+}
+
+const savedLocale = normalizeLocale(safeLocalStorageGet("dbx-locale"));
+const initialLocale = savedLocale ?? detectUserLocale();
+
+const i18n = createI18n({
+  legacy: false,
+  locale: initialLocale,
+  fallbackLocale: defaultLocale,
+  messages: {
+    en,
+  },
+});
+const i18nGlobal = i18n.global as unknown as I18nGlobal;
+
+export async function loadLocaleMessages(locale: Locale) {
+  if (loadedLocales.has(locale)) return;
+  const loader = localeLoaders[locale as Exclude<Locale, "en">];
+  if (!loader) return;
+  const messages = await loader();
+  i18nGlobal.setLocaleMessage(locale, messages.default);
+  loadedLocales.add(locale);
+}
+
+export async function loadSavedLocale() {
+  await loadLocaleMessages(initialLocale);
+}
+
+export async function setLocale(locale: Locale) {
+  await loadLocaleMessages(locale);
+  i18nGlobal.locale.value = locale;
+  safeLocalStorageSet("dbx-locale", locale);
+}
+
+export function currentLocale(): Locale {
+  return i18nGlobal.locale.value;
+}
+
+export function nextLocale(current: Locale): Locale {
+  const index = supportedLocales.indexOf(current);
+  const nextIndex = index === -1 ? 0 : (index + 1) % supportedLocales.length;
+  return supportedLocales[nextIndex];
+}
+
+export default i18n;
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
new file mode 100644
index 0000000..71fdf20
--- /dev/null
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -0,0 +1,3874 @@
+export default {
+  app: {
+    name: "DBX",
+  },
+  auth: {
+    setupTitle: "Set up access password",
+    setupDescription: "Set a password to protect your instance",
+    loginDescription: "Database management tool",
+    newPassword: "Enter new password",
+    confirmPassword: "Confirm password",
+    enterPassword: "Enter access password",
+    passwordMismatch: "Passwords do not match",
+    setPassword: "Set Password",
+    login: "Login",
+    processing: "Processing...",
+    loginFailed: "Incorrect password",
+    connectFailed: "Connection failed",
+    changePassword: "Change Password",
+    oldPassword: "Current password",
+    oldPasswordWrong: "Current password is incorrect",
+    passwordChanged: "Password changed successfully",
+    changePasswordFailed: "Failed to change password",
+    changePasswordDescription: "Enter your current password and choose a new one",
+  },
+  toolbar: {
+    newConnection: "New Connection",
+    newQuery: "New Query",
+    execute: "Execute",
+    executeShortcut: "Execute selection/query (Cmd+Enter)",
+    stopQuery: "Stop query",
+    explainPlan: "Explain plan",
+    stopExplain: "Stop explain",
+    formatSql: "Format SQL",
+    formatSqlFailed: "Failed to format SQL",
+    keywordCaseLower: "Use lower-case SQL keywords",
+    keywordCaseUpper: "Use upper-case SQL keywords",
+    autoCommit: "Auto Commit",
+    manualTransaction: "Manual Transaction",
+    autoCommitAgent: "Auto Commit (depends on Agent backend)",
+    manualTransactionAgent: "Manual Transaction (depends on Agent backend)",
+    commit: "Commit",
+    rollback: "Rollback",
+    txnAutoRolledBack: "Transaction auto-rolled back after 5 minutes of inactivity",
+    previewSql: "Preview SQL",
+    hidePreviewSql: "Hide SQL Preview",
+    saveSql: "Save to SQL Library",
+    openSql: "Open SQL file",
+    exPasteSqlInCondition: "ExPaste: paste as IN condition",
+    theme: "Theme",
+    themeLight: "Light",
+    themeDark: "Dark",
+    themeSystem: "Follow System",
+    sqlSaved: "SQL saved",
+    sqlOpenFailed: "Failed to open file: {message}",
+    sqlSaveFailed: "Failed to save file: {message}",
+    driverManager: "Driver Manager",
+    updatableDriverCount: "Updatable driver count",
+    blockDangerousRedisCommands: "Block dangerous commands",
+  },
+  updates: {
+    title: "Updates",
+    check: "Check for updates",
+    availableTitle: "Update available",
+    availableMessage: "DBX {latest} is available. You are using {current}.",
+    upToDate: "DBX is up to date ({version}).",
+    failed: "Failed to check updates: {error}",
+    rateLimited: "GitHub update checks are temporarily rate limited. You can still open the release page to check manually.",
+    openRelease: "Open Release",
+    downloadAndInstall: "Download & Install",
+    portableManualUpdate: "Portable builds cannot use the in-app installer. Download the portable ZIP from the release page, then extract it over the current DBX folder to keep portable.dbx and data.",
+    downloading: "Downloading {progress}%",
+    downloadFailed: "Update download failed: {error}",
+    restart: "Exit & Restart",
+    restartFailed: "Failed to restart app: {error}",
+    exitAndUpdate: "Exit & Update",
+    dockerUsersRun: "Docker users should run",
+    toUpdate: "to update",
+  },
+  sidebar: {
+    connections: "CONNECTIONS",
+    noConnections: "No connections yet",
+    import: "Import Connections",
+    importDbx: "Import DBX Config",
+    importNavicat: "Import Navicat NCX",
+    importDbeaver: "Import DBeaver",
+    importDatagrip: "Import DataGrip",
+    export: "Export Connections",
+    collapseAll: "Collapse all",
+    collapse: "Collapse sidebar",
+    expand: "Expand sidebar",
+    showMore: "Show {count} more...",
+    filterByType: "Filter by type",
+    searchScopeConnection: "Connection",
+    searchScopeDatabase: "Database",
+    searchScopeSchema: "Schema",
+    searchScopeTable: "Table",
+    searchScopeView: "View",
+    searchTablesInCurrentScope: "Search tables in this database...",
+    clearTableSearch: "Clear table search",
+    clearFilter: "Clear filter",
+    locateActiveTab: "Locate in sidebar",
+  },
+  savedSql: {
+    saveToLibrary: "Save to SQL Library",
+    saveToFile: "Save Locally",
+    save: "Save",
+    saved: "SQL saved",
+    saveFailed: "Failed to save SQL: {message}",
+    fileName: "File name",
+    folder: "Folder",
+    rootFolder: "SQL Library",
+    newQuery: "New Query",
+    newFolder: "New SQL Folder",
+    newFolderDefault: "New Folder",
+    renameFolder: "Rename Folder",
+    deleteFolder: "Delete Folder",
+    deleteFolderConfirm: "Delete “{name}” and the SQL files inside it?",
+    open: "Open SQL",
+    renameFile: "Rename SQL",
+    deleteFile: "Delete SQL",
+    deleteFileConfirm: "Delete “{name}”?",
+  },
+  sqlLibrary: {
+    title: "SQL Library",
+    empty: "No saved queries yet",
+    emptyFolder: "Empty folder",
+    unfiled: "Unfiled",
+    exportFile: "Export SQL",
+    exportFolder: "Export Folder",
+    exportLibrary: "Export SQL Library",
+    importDirectory: "Import Local Folder",
+    importIntoFolder: "Import Into Folder",
+    openStorageDirectory: "Open SQL Storage Directory",
+    chooseSyncDirectory: "Set Local Sync Directory",
+    disableSyncDirectory: "Disable Local Sync Directory",
+    syncDirectorySaved: "SQL local sync directory saved",
+    syncDirectoryDisabled: "SQL local sync disabled",
+    syncDirectoryFailed: "Failed to set sync directory: {message}",
+    openDirectoryFailed: "Failed to open directory: {message}",
+    noSyncDirectory: "Please set a local sync directory first",
+    exported: "Exported",
+    exportFailed: "Export failed: {message}",
+    importFailed: "Import failed: {message}",
+    importNone: "No .sql files found in the selected folder",
+    imported: "Imported {count} SQL files",
+    desktopOnly: "This feature is only available on desktop",
+    noConnection: "No connection is available for import",
+    batchDelete: "Batch Delete",
+    batchDeleteConfirm: "Are you sure you want to delete {count} selected items? This action cannot be undone.",
+    batchDeleteSuccess: "Successfully deleted {count} items",
+    moveToFolder: "Move to Folder...",
+    moveSelectedToFolder: "Move {count} SQL to Folder...",
+    moveSuccess: "Moved {count} SQL file(s)",
+    clearSelection: "Clear Selection",
+    sortByDate: "Sort by Date Modified",
+    sortByFolder: "Sort by Folder Structure",
+  },
+
+  connection: {
+    title: "New Connection",
+    name: "Name",
+    namePlaceholder: "Connection name, auto-generated if empty",
+    type: "Type",
+    host: "Host",
+    filePath: "File Path",
+    h2FileMode: "File",
+    h2TcpMode: "TCP",
+    h2FilePathRequired: "H2 file path cannot be empty",
+    createDuckDbFile: "Create DuckDB file",
+    createSqliteFile: "Create SQLite database",
+    memoryDatabasePathHint: "Use :memory: to create an in-memory SQLite or DuckDB database.",
+    sqliteCipherKey: "SQLCipher Key",
+    sqliteCipherKeyPlaceholder: "Leave empty for unencrypted SQLite",
+    sqliteExtensions: "SQLite Extensions",
+    sqliteExtensionsPlaceholder: "/path/to/regexp.dylib\n/path/to/text.dylib|sqlite3_text_init",
+    sqliteExtensionsHint: "One .dylib/.so/.dll per line. Use “path|entry point” when an entry point is required. Loaded on connect, then load_extension is disabled.",
+    sqliteExtensionBrowse: "Select SQLite extension",
+    user: "User",
+    password: "Password",
+    database: "Database",
+    databasePlaceholder: "Optional",
+    databasePlaceholderRequired: "Required, enter an existing database",
+    databasePlaceholderWithDefault: "Optional, defaults to {database}",
+    kingbaseDatabaseRequired: "Kingbase requires an existing database before connecting or loading the database list.",
+    defaultDatabase: "Default DB",
+    authDatabase: "Auth DB",
+    authDatabasePlaceholder: "Optional, often admin",
+    authMechanism: "Auth Mechanism",
+    authMechanismDefault: "Default",
+    driverMode: "Driver",
+    mongoDriverAuto: "Auto",
+    mongoDriverLegacy: "Legacy",
+    serviceName: "Service/SID",
+    serviceNameOnly: "Service Name",
+    version: "Version",
+    driverInstallHintPrefix: "Install the required driver from ",
+    driverInstallHintSuffix: " in the top toolbar before connecting.",
+    driverName: "Driver Name",
+    driverNamePlaceholder: "Vendor or environment name",
+    urlParams: "URL Params",
+    d1AccountId: "Account ID",
+    d1DatabaseId: "Database ID",
+    d1ApiToken: "API Token",
+    d1TokenHint: "The token needs D1 Read permission; writes, DDL, and imports also require D1 Write.",
+    d1FieldsRequired: "Cloudflare Account ID, D1 Database ID, and API Token are required.",
+    hiveAuthMode: "Auth",
+    hiveAuthNone: "None",
+    hivePrincipal: "Principal",
+    hiveKerberosPrincipalRequired: "Hive Kerberos principal is required",
+    hiveKrb5ConfBrowse: "Choose krb5.conf",
+    hiveJaasConfigBrowse: "Choose JAAS config",
+    hiveTicketCache: "Ticket Cache",
+    hiveTicketCacheFallback: "Set useSubjectCredsOnly=false",
+    hiveJvmOptions: "JVM Options",
+    hiveJvmOptionsPlaceholder: "-Dsun.security.krb5.debug=true",
+    gbaseServer: "GBASEDBTSERVER",
+    informixServer: "INFORMIXSERVER",
+    sslEnable: "Enable encrypted connection",
+    caCertPath: "CA Certificate",
+    caCertPathPlaceholder: "Optional, e.g. ~/.yandex/RootCA.crt",
+    caCertPathBrowse: "Browse certificate",
+    redisTlsInsecure: "Skip certificate verification",
+    redisTlsInsecureHint: "Equivalent to redis-cli --tls --insecure, for self-signed certificates or private CAs.",
+    mysqlTlsMode: "TLS Mode",
+    mysqlTlsModePreferred: "Preferred",
+    mysqlTlsModeDisabled: "Disabled",
+    mysqlTlsModeRequired: "Required",
+    mysqlTlsModeVerifyCa: "Verify CA",
+    mysqlTlsModeVerifyIdentity: "Verify Identity",
+    mysqlCleartextPasswordAuth: "Cleartext Password Auth",
+    mysqlCleartextPasswordAuthHint: "Enable only when the MySQL server requires the cleartext password authentication plugin.",
+    mysqlCaCertHint: "Required for Verify CA and Verify Identity when the server certificate uses a private CA.",
+    mysqlClientCert: "Client Auth",
+    mysqlClientCertPlaceholder: "/path/to/client.crt",
+    mysqlClientKeyPlaceholder: "/path/to/client.key",
+    mysqlClientCertHint: "Client certificate and private key must be provided together when MySQL requires mTLS.",
+    mysqlTlsConnectionFailureHint: "If the MySQL server does not require TLS, edit the connection, set TLS Mode to Disabled, and try again.",
+    mysqlClientCertBrowse: "Choose client certificate",
+    mysqlClientKeyBrowse: "Choose client private key",
+    postgresSslMode: "TLS Mode",
+    postgresSslModeDisable: "Disable",
+    postgresSslModePrefer: "Prefer",
+    postgresSslModeRequire: "Require",
+    postgresSslModeVerifyCa: "Verify CA",
+    postgresSslModeVerifyFull: "Verify Full",
+    postgresServerCert: "Server CA",
+    postgresRootCertPlaceholder: "/path/to/ca.crt",
+    postgresRootCertHint: "Use this for verify-ca or verify-full when the server certificate is signed by a private CA.",
+    postgresRootCertBrowse: "Choose CA certificate",
+    postgresClientCert: "Client Auth",
+    postgresClientCertPlaceholder: "/path/to/client.crt",
+    postgresClientKeyPlaceholder: "/path/to/client.key",
+    postgresClientCertHint: "Client certificate and private key must be provided together when PostgreSQL requires mTLS.",
+    postgresClientCertBrowse: "Choose client certificate",
+    postgresClientKeyBrowse: "Choose client private key",
+    connectionUrlOptional: "URL (optional)",
+    connectionUrlPlaceholder: "postgresql://user:pass{'@'}host:5432/db?sslmode=require",
+    parseConnectionUrl: "Parse connection URL",
+    parseConnectionUrlApplied: "Connection URL applied",
+    parseConnectionUrlFailed: "Failed to parse connection URL: {message}",
+    mode: "Connection Mode",
+    modeForm: "Form",
+    redisStandaloneMode: "Standalone",
+    redisSentinelMode: "Sentinel",
+    redisClusterMode: "Cluster",
+    oceanbaseMySQLMode: "MySQL Mode",
+    oceanbaseOracleMode: "Oracle Mode",
+    redisFirstSentinel: "First Sentinel",
+    redisFirstClusterNode: "First Seed Node",
+    redisSentinelNodes: "Sentinel Nodes",
+    redisClusterNodes: "Cluster Seed Nodes",
+    redisSentinelMaster: "Master Name",
+    redisSentinelUser: "Sentinel User",
+    redisSentinelPassword: "Sentinel Password",
+    redisSentinelTls: "Sentinel TLS",
+    redisSentinelTlsHint: "Use TLS when connecting to Sentinel nodes",
+    redisKeySeparator: "Key Namespace Separator",
+    etcdEndpoints: "Endpoints",
+    etcdEndpointsHint: "One endpoint per line. Leave blank to use the host and port above.",
+    etcdCaCertPlaceholder: "/path/to/ca.crt",
+    etcdCaCertBrowse: "Choose CA certificate",
+    etcdClientAuth: "Client Auth",
+    etcdClientCertPlaceholder: "/path/to/client.crt",
+    etcdClientKeyPlaceholder: "/path/to/client.key",
+    etcdClientCertHint: "Client certificate and private key must be provided together when etcd requires mTLS.",
+    etcdClientCertBrowse: "Choose client certificate",
+    etcdClientKeyBrowse: "Choose client private key",
+    etcdClientCertPairRequired: "Client certificate and private key must be provided together.",
+    zookeeperConnectString: "Connect String",
+    zookeeperConnectStringHint: "Comma or line separated host:port entries. Leave blank to use the host and port above.",
+    zookeeperCreateModePersistent: "Persistent",
+    zookeeperCreateModeEphemeral: "Ephemeral",
+    zookeeperCreateModePersistentSequential: "Persistent Sequential",
+    zookeeperCreateModeEphemeralSequential: "Ephemeral Sequential",
+    nacosConsoleUrl: "Console URL",
+    nacosConsoleUrlHint: "Use the Nacos console/admin API address. Nacos 3 Docker usually exposes the console on 8085; older deployments may share 8848 with the service port.",
+    nacosConsoleUrlRequired: "Nacos Console URL is required",
+    nacosConsoleUrlAutoAdjusted: "Adjusted Nacos Console URL from {from} to {to}.",
+    nacosNamespace: "Namespace",
+    nacosContextPath: "Context Path",
+    nacosContextPathPlaceholder: "Leave empty or /nacos",
+    nacosAuth: "Auth",
+    nacosAuthNone: "None",
+    nacosAuthUserPassword: "User / Password",
+    nacosUsernameRequired: "Nacos username is required",
+    nacosTls: "TLS",
+    nacosTlsSkipVerify: "Skip certificate verification",
+    nacosPageSize: "Page Size",
+    kafkaKerberosPrincipal: "Principal",
+    kafkaKerberosKeytab: "Keytab",
+    kafkaKerberosServiceName: "Service Name",
+    kafkaKerberosKrb5Conf: "krb5.conf",
+    kafkaKerberosPrincipalRequired: "Kafka Kerberos principal is required",
+    kafkaKerberosKeytabRequired: "Kafka Kerberos keytab path is required",
+    kafkaKerberosKeytabBrowse: "Choose Keytab",
+    kafkaKerberosKrb5ConfBrowse: "Choose krb5.conf",
+    kafkaKerberosKeytabPlaceholder: "Path on DBX Agent machine, e.g. /etc/security/keytabs/user.keytab",
+    kafkaKerberosKrb5ConfPlaceholder: "Optional path on DBX Agent machine, e.g. /etc/krb5.conf",
+    kafkaKerberosPathHint: "The keytab and krb5.conf paths are read by DBX Agent and must exist on the machine running DBX Agent; files are not uploaded from this browser.",
+    kafkaKerberosAuthHint: "Uses GSSAPI + keytab login. If the server requires encrypted transport, set Security to SASL_SSL; otherwise Auto or SASL_PLAINTEXT can be used.",
+    searchDatabasePlaceholder: "Search database types",
+    iconView: "Icon view",
+    listView: "List view",
+    selectedDatabase: "Selected",
+    noDatabaseMatches: "No matching databases",
+    next: "Next",
+    back: "Previous",
+    basicTab: "Connection",
+    tlsTab: "TLS/SSL",
+    test: "Test",
+    testing: "Testing...",
+    copyTestResult: "Copy test result",
+    sqlServerLegacyCompatibilityMode: "Legacy compatibility mode",
+    sqlServerLegacyCompatibilityModeEnable: "Use SQL Server legacy compatibility connection",
+    sqlServerLegacyCompatibilityModeEnabled: "SQL Server legacy compatibility mode is enabled.",
+    sqlServerLegacyCompatibilityModeHint:
+      "Applies to unencrypted, login-only encrypted, or TLS 1.0 legacy compatibility scenarios. If the compatibility component is not installed, DBX installs it before enabling this mode.\nSome native SQL Server features may be unavailable when fallback uses the compatibility component.\nUse it only on trusted networks, VPNs, or SSH tunnels",
+    sqlServerLegacyCompatibilityComponent: "SQL Server legacy compatibility component",
+    sqlServerLegacyCompatibilityComponentInstalling: "Installing SQL Server legacy compatibility component...",
+    saveAndConnect: "Save & Connect",
+    save: "Save",
+    editTitle: "Edit Connection",
+    testSuccess: "Connection successful",
+    connecting: "Connecting to {name}...",
+    connectSuccess: "Connected to {name}",
+    connectFailed: "Connection failed: {message}",
+    driverNotInstalled: "{driver} driver is not installed. Please install it from the Driver Manager.",
+    jreNotInstalled: "JRE {jre} runtime is not installed. Please install it from the Driver Manager.",
+    systemJavaNotFound: "System Java runtime was not found on PATH. Please install Java or choose a custom Java executable.",
+    customJavaPathEmpty: "Custom Java runtime path is empty. Please choose a Java executable.",
+    agentJavaTooOld: "This driver requires Java 21. Use DBX managed JRE 21 or select a Java 21 executable in Driver Manager.",
+    agentDriverUpdateConnectionHint: "A built-in driver update is available for this connection. The connection failure may be related to an outdated local driver. Update the corresponding driver in Driver Manager, then retry.",
+    jdbcPluginNotInstalled: "JDBC plugin is not installed. Install the optional JDBC plugin to use this connection.",
+    lastError: "Connection error",
+    clearError: "Clear connection error",
+    saveFailed: "Failed to save connection: {message}",
+    deleted: "Connection deleted",
+    deletedSelected: "{count} connections deleted",
+    copied: "Copied",
+    disconnected: "Disconnected",
+    databaseConnectionClosed: "Closed database connection: {name}",
+    duplicated: "Connection duplicated",
+    duplicatedSelected: "{count} connections duplicated",
+    groupDeleted: "Group deleted",
+    loadFailed: "Failed to load saved connections: {message}",
+    sshTunnel: "Tunnel / Proxy",
+    advancedTab: "Advanced",
+    sshEnable: "Use tunnel / proxy",
+    sshHost: "SSH Host",
+    sshHostPlaceholder: "ssh.example.com or an alias from ~/.ssh/config",
+    sshUser: "SSH User",
+    sshAuthMethod: "Login Method",
+    sshAuthMethodPassword: "Password",
+    sshAuthMethodKey: "Private Key",
+    sshAuthMethodNone: "None",
+    sshAuthMethodNoneHint: "No credentials will be sent. Use this for bastions or proxies that accept unauthenticated connections.",
+    sshAuthMethodAgentLegacy: "SSH Agent (legacy)",
+    sshPassword: "SSH Password",
+    sshPasswordPlaceholder: "Leave empty to use key",
+    sshKeyPath: "Key Path",
+    sshKeyPassphrase: "Key Passphrase",
+    sshKeyPassphrasePlaceholder: "Leave empty if key is not encrypted",
+    sshKeyPathBrowse: "Browse",
+    sshExposeLan: "Expose tunnel to LAN",
+    sshConnectTimeout: "SSH Timeout (seconds)",
+    sshHops: "Tunnel / Proxy Layers",
+    sshHopAdd: "Add SSH layer",
+    sshHopDuplicate: "Duplicate",
+    sshHopDelete: "Delete",
+    sshHopMoveUp: "Move up",
+    sshHopMoveDown: "Move down",
+    sshHopName: "Layer Name",
+    sshHopNamePlaceholder: "Bastion, jump host, production gateway",
+    sshHopDefaultName: "Layer {index}",
+    sshHopInvalidHost: "{hop}: SSH host is required",
+    sshHopInvalidUser: "{hop}: SSH user is required",
+    sshHopInvalidPort: "{hop}: SSH port must be between 1 and 65535",
+    sshHopInvalidAuth: "{hop}: password, key path, or ssh-agent is required",
+    sshUseAgent: "Use ssh-agent",
+    sshAgentSockPath: "Agent Socket Path",
+    sshAgentSockPathPlaceholder: "e.g. ~/.ssh/agent.sock",
+    sshHopInvalidTimeout: "{hop}: SSH timeout must be between 1 and 300 seconds",
+    connectTimeout: "Connection Timeout (seconds)",
+    queryTimeout: "Query Timeout (seconds)",
+    idleTimeout: "Idle Timeout (seconds)",
+    keepaliveInterval: "Keepalive Interval (seconds)",
+    readOnly: "Read Only",
+    readOnlyHint: "Block all write operations (INSERT, UPDATE, DELETE, etc.)",
+    readOnlyBadge: "Read-only",
+    proxy: "Proxy",
+    proxyEnable: "Connect database through proxy",
+    proxyType: "Proxy Type",
+    proxyHost: "Proxy Host",
+    proxyUsername: "Proxy User",
+    proxyUsernamePlaceholder: "Optional",
+    proxyPassword: "Proxy Password",
+    proxyPasswordPlaceholder: "Optional",
+    tunnelProfile: "Tunnel Profile",
+    tunnelProfileCustom: "Custom (this connection only)",
+    tunnelProfileManaged: "Managed by a shared tunnel profile. Edit it in Settings > Tunnels — changes apply to every connection using it on its next connection.",
+    tunnelProfileMissing: "The referenced tunnel profile no longer exists. Select another profile or switch to custom.",
+    tunnelProfileMissingName: "Missing tunnel profile",
+    tunnelProfileManage: "Manage",
+    httpTunnel: "HTTP Tunnel",
+    httpTunnelAdd: "Add HTTP tunnel",
+    httpTunnelUrl: "Tunnel Script URL",
+    httpTunnelToken: "Tunnel Token",
+    httpTunnelTokenPlaceholder: "Token configured in dbx_tunnel.php",
+    httpTunnelConnectTimeout: "Tunnel Timeout (seconds)",
+    httpTunnelDefaultName: "HTTP Tunnel {index}",
+    httpTunnelInvalidOrder: "{hop}: HTTP tunnel must be the first tunnel / proxy layer",
+    httpTunnelInvalidUrl: "{hop}: tunnel script URL is required",
+    httpTunnelInvalidTimeout: "{hop}: HTTP tunnel timeout must be between 1 and 300 seconds",
+    dremioArrowFlightSqlMode: "Arrow Flight SQL",
+    dremioLegacyJdbcMode: "Legacy JDBC",
+    jdbcUrl: "JDBC URL",
+    jdbcUrlPlaceholder: "jdbc:postgresql://localhost:5432/database",
+    jdbcDriverClass: "Driver Class (optional)",
+    jdbcDriverClassPlaceholder: "Most drivers auto-register; use com.vendor.jdbc.Driver if needed",
+    jdbcDriverPaths: "Driver JARs",
+    jdbcDriverSelectPlaceholder: "Choose imported driver",
+    jdbcManualClasspath: "Manual classpath",
+    jdbcManualClasspathCount: "{count} paths",
+    jdbcDriverPathsPlaceholder: "/path/to/driver.jar\n/path/to/another-driver.jar",
+    jdbcDriverBrowse: "Choose JDBC driver JAR",
+    jdbcDocs: "View JDBC docs",
+    jdbcPluginHint: "Install the DBX JDBC plugin first, then import the database vendor's JDBC driver JAR.",
+    dmCompatHint: "Requires DM8 ODBC driver installed on your system.",
+    dmDownload: "Download from Dameng",
+    mongoLegacyHint: "Use Legacy for older MongoDB servers, especially versions below 4.2. If authentication fails and the user was created in admin, set Auth DB to admin.",
+    mongoTlsAllowInvalidCertificates: "Disable TLS certificate verification",
+    mongoTlsAllowInvalidCertificatesHint: "Maps to tlsAllowInvalidCertificates=true and disables all certificate validation, not just hostname checks. This increases MITM risk. Commonly required for AWS DocumentDB over an SSH tunnel.",
+    mongoRetryWrites: "Retry writes",
+    mongoRetryWritesHint: "Maps to retryWrites. Disable for AWS DocumentDB, which does not support retryable writes.",
+    compatible: "Compatible",
+    mainstream: "Popular",
+    color: "Color",
+    colorNone: "No color",
+    colorGreen: "Green",
+    colorYellow: "Yellow",
+    colorOrange: "Orange",
+    colorRed: "Red",
+    colorBlue: "Blue",
+    colorPurple: "Purple",
+    colorCustom: "Custom color",
+    cancelConnecting: "Cancel connecting",
+    connectCancelled: "Connection cancelled",
+  },
+  editor: {
+    pressToExecute: "Press {mod}+Enter to execute",
+    pressToSaveSql: "Press {mod}+S to save SQL",
+    queryTimeoutError: "Query timed out ({seconds}s). Check whether the database connection is healthy.",
+    changeQueryTimeout: "Change query timeout",
+    connectionMayBeLost: "The connection may have been lost. Refresh data and try again.",
+    showResultsPane: "Show results",
+    hideResultsPane: "Hide results",
+    noDatabase: "No database selected",
+    unsavedChangesTitle: "Unsaved changes",
+    unsavedChangesMessage: '"{title}" has unsaved changes that will be lost if closed. Save before closing?',
+    unsavedChangesBatchCloseMessage: "Some tabs you are closing have unsaved changes that will be lost. Save before continuing?",
+    unsavedChangesBatchCloseMultipleMessage: '{count} SQL tabs you are closing have unsaved changes. DBX is currently showing "{title}". Save before continuing?',
+    unsavedChangesAppCloseMessage: '"{title}" has unsaved SQL changes that will be lost if you quit DBX. Save before quitting?',
+    unsavedChangesAppCloseMultipleMessage: '{count} SQL tabs have unsaved changes. DBX is currently showing "{title}". Save before quitting?',
+    unsavedChangesViewList: "View {count} tabs",
+    unsavedChangesListTitle: "Unsaved tabs ({count})",
+    discardChanges: "Discard",
+    discardAllChanges: "Discard all",
+    saveAllChanges: "Save all",
+    selectConnection: "Select connection",
+    searchConnection: "Search connections...",
+    selectDatabase: "Select database",
+    selectDatabaseRequired: "Select a database first",
+    searchDatabase: "Search databases...",
+    selectSchema: "Select schema",
+    searchSchema: "Search schemas...",
+    setDefaultDatabase: "Set Default",
+    defaultDatabase: "Default",
+    clearDatabase: "Clear database",
+    exPasteNoValues: "Clipboard has no values for an IN condition",
+    exPasteNotList: "No convertible multi-value list was detected",
+    exPasteTooLarge: "Clipboard content is too large. Maximum supported length is {limit} characters.",
+    exPasteTooManyValues: "Too many values. Maximum supported count is {limit}.",
+    exPasteClipboardReadFailed: "Failed to read clipboard: {message}",
+    exPastePasted: "Pasted {count} IN condition values",
+    completion: {
+      nullValue: "NULL value",
+      isNull: "Check if NULL",
+      isNotNull: "Check if not NULL",
+      stringLiteral: "String literal",
+      numericLiteral: "Numeric literal",
+      booleanValue: "Boolean value",
+      starExpansionColumns: "{count} columns",
+      functionDescriptions: {
+        COUNT: "Returns the number of rows",
+        SUM: "Returns the sum of a numeric column",
+        AVG: "Returns the average of a numeric column",
+        MIN: "Returns the minimum value",
+        MAX: "Returns the maximum value",
+        GROUP_CONCAT: "Concatenates group values into a string",
+        STRING_AGG: "Concatenates group strings",
+        CONCAT: "Concatenates multiple strings",
+        CONCAT_WS: "Concatenates strings with separator",
+        SUBSTRING: "Extracts a substring",
+        REPLACE: "Replaces content in a string",
+        TRIM: "Trims leading and trailing spaces",
+        UPPER: "Converts to uppercase",
+        LOWER: "Converts to lowercase",
+        LENGTH: "Returns the string length",
+        REGEXP_REPLACE: "Replaces using a regular expression",
+        DATE_FORMAT: "Formats a date with the given format",
+        DATEDIFF: "Calculates the difference between two dates",
+        DATE_ADD: "Adds an interval to a date",
+        DATE_SUB: "Subtracts an interval from a date",
+        EXTRACT: "Extracts a date part",
+        NOW: "Returns the current date and time",
+        ROUND: "Rounds to the specified decimal places",
+        FLOOR: "Rounds down",
+        CEIL: "Rounds up",
+        ABS: "Returns the absolute value",
+        MOD: "Returns the division remainder",
+        COALESCE: "Returns the first non-NULL argument",
+        IFNULL: "Returns a replacement value if NULL",
+        NULLIF: "Returns NULL if arguments are equal",
+        CAST: "Converts an expression to a target type",
+        JSON_EXTRACT: "Extracts a value from JSON",
+        JSON_VALUE: "Extracts a scalar value from JSON",
+        JSON_OBJECT: "Creates a JSON object",
+        JSON_ARRAY: "Creates a JSON array",
+      },
+    },
+    contextMenu: {
+      executeSelection: "Execute selection",
+      executeCurrent: "Execute SQL",
+      copySelection: "Copy selection",
+      sendToAi: "Send to AI",
+      uppercaseSelection: "Convert to uppercase",
+      lowercaseSelection: "Convert to lowercase",
+      selectAll: "Select all",
+    },
+    search: {
+      find: "Find",
+      replace: "Replace",
+      replaceAll: "Replace All",
+      caseSensitive: "Case sensitive",
+      regex: "Regular expression",
+      collapseReplace: "Collapse replace",
+      expandReplace: "Expand replace",
+      prevMatch: "Previous (Shift+Enter)",
+      nextMatch: "Next (Enter)",
+      close: "Close (Esc)",
+      noResults: "No results",
+    },
+    executionPicker: {
+      title: "Execution Target",
+      currentStatement: "Current SQL",
+      allStatements: "All SQL",
+      currentCommand: "Current command",
+      allCommands: "All commands",
+    },
+  },
+  tabs: {
+    sql: "SQL",
+    table: "Table",
+    tableData: "Table Data",
+    redis: "Redis",
+    etcd: "etcd",
+    zookeeper: "ZooKeeper",
+    mongo: "Mongo",
+    gridfs: "GridFS",
+    vector: "Vector",
+    objects: "Objects",
+    users: "Users & Privileges",
+    executionSummary: "Summary",
+    tooltipTitle: "Title:",
+    tooltipFilePath: "File Path:",
+    tooltipConnection: "Connection:",
+    tooltipDatabase: "Database:",
+    tooltipTable: "Table:",
+    tooltipCollection: "Collection:",
+    tooltipSchema: "Schema:",
+    resultN: "Result {n}",
+    runN: "Run {n}",
+    resultRuns: "Result runs",
+    removeRun: "Remove run {n}",
+    autoKeepResults: "Auto-keep query results",
+    autoKeepResultsEnabled: "Auto-keep results enabled",
+    autoKeepResultsDisabled: "Auto-keep results disabled",
+    autoRefresh: "Auto-refresh results",
+    autoRefreshShort: "Auto",
+    autoRefreshEvery: "Refresh every {seconds}s",
+    startAutoRefresh: "Start auto-refresh",
+    stopAutoRefresh: "Stop auto-refresh",
+    missingResultRun: "This result is no longer available",
+    exportResultArchive: "Save Result Archive",
+    importResultArchive: "Import Result Archive",
+    importedResultArchive: "Imported results",
+    resultArchiveExported: "Results exported",
+    resultArchiveImported: "Results imported",
+    resultArchiveUnavailable: "No saved results are available to export",
+    resultArchiveImportInvalid: "This result archive could not be opened",
+    resultArchiveExportFailed: "Failed to export results: {message}",
+    resultArchiveImportFailed: "Failed to import results: {message}",
+    scrollLeft: "Scroll tabs left",
+    scrollRight: "Scroll tabs right",
+    openTabs: "Open tabs",
+    fixedTabs: "Fixed tabs",
+    openDataTabs: "Open tables",
+  },
+  gridfsBrowser: {
+    bucketCount: "buckets",
+    fileCount: "files",
+    name: "Name",
+    totalSize: "Size",
+    chunkSize: "Chunk Size",
+    uploadDate: "Upload Date",
+    contentType: "Content Type",
+    metadata: "Metadata",
+    selectBucket: "Select a GridFS bucket to inspect or open it.",
+    selectFile: "Select a GridFS file to inspect or manage it.",
+    emptyBuckets: "No GridFS buckets found. Create one to start storing files.",
+    emptyFiles: "This bucket has no files yet. Upload one to get started.",
+    createBucket: "New Bucket",
+    openBucket: "Open Bucket",
+    deleteBucket: "Delete Bucket",
+    createTitle: "Create GridFS Bucket",
+    deleteTitle: "Delete GridFS Bucket",
+    deleteMessage: "Delete the selected GridFS bucket and all files inside it?",
+    bucketName: "Bucket Name",
+    bucketNamePlaceholder: "example_bucket",
+    bucketCreated: "Bucket {bucket} created.",
+    bucketDeleted: "Bucket {bucket} deleted.",
+    uploadFile: "Upload File",
+    downloadFile: "Download File",
+    downloadSelected: "Download Selected",
+    deleteFile: "Delete File",
+    selectedCount: "{count} selected",
+    deleteFileTitle: "Delete GridFS File",
+    deleteFileMessage: "Delete the selected file from this GridFS bucket?",
+    fileUploaded: "Uploaded {fileName}.",
+    fileDeleted: "Deleted {fileName}.",
+  },
+  executionSummary: {
+    empty: "No summary",
+    executing: "Executing...",
+    statement: "Statement",
+    type: "Type",
+    rows: "Rows",
+    affected: "Affected",
+    time: "Time",
+    success: "Success",
+    error: "Error",
+    returnedTable: "Returned a {count}-column result table",
+    noTable: "No result table returned",
+  },
+  chart: {
+    title: "Chart",
+    type: "Type",
+    line: "Line",
+    bar: "Bar",
+    pie: "Pie",
+    noNumericData: "No numeric data available for charting",
+  },
+  grid: {
+    rows: "{count} rows",
+    totalRows: "Total {count} rows",
+    totalRowCount: "({count} total)",
+    totalRowCountLoading: "(counting...)",
+    loadingMore: "Loading more data...",
+    allLoaded: "all loaded",
+    calculateTotalRows: "Count total rows",
+    calculateTotalRowsInline: "(count total rows)",
+    calculateTotalRowsFailed: "Count failed: {message}",
+    rowsAffected: "{count} rows affected",
+    querySuccess: "Query executed successfully",
+    noRows: "No data",
+    noRowsDescription: "This result set has no records.",
+    noSearchResults: "No matches",
+    noSearchResultsDescription: "Try a different keyword.",
+    noFilteredRows: "No rows match the filter",
+    noFilteredRowsDescription: "Adjust the search text or row status filter.",
+    copy: "Copy",
+    mongoJsonPreview: "JSON Preview",
+    mongoJsonPreviewEmpty: "Select a MongoDB document to preview.",
+    copyJson: "Copy JSON",
+    copyDdl: "Copy DDL",
+    copyCell: "Copy Cell",
+    copyRow: "Copy Row (JSON)",
+    copyColumnJson: "Copy Column (JSON)",
+    copyColumnNames: "Copy Column Names",
+    copyRowInsert: "Copy as INSERT",
+    copyRowInsertWithoutPrimaryKeys: "Copy as INSERT without Primary Keys",
+    copyRowUpdate: "Copy as UPDATE",
+    copyAll: "Copy All (TSV)",
+    selection: "Selection",
+    selectionSum: "SUM: {value}",
+    selectionCells: "{count} cells",
+    copySelectionTsv: "Copy Selection (TSV)",
+    copySelectionTsvWithHeaders: "Copy Selection with Headers (TSV)",
+    copySelectionCsv: "Copy Selection (CSV)",
+    copySelectionJson: "Copy Selection (JSON)",
+    copySelectionSql: "Copy Selection as SQL IN List",
+    clearSelection: "Clear Selection",
+    export: "Export",
+    exportCsv: "Export CSV",
+    exportXlsx: "Export XLSX",
+    exportCurrentPageCsv: "Export Current Page as CSV",
+    exportCurrentPageXlsx: "Export Current Page as XLSX",
+    exportCurrentPageJson: "Export Current Page as JSON",
+    exportCurrentPageMarkdown: "Export Current Page as Markdown",
+    exportCurrentPageSql: "Export Current Page as SQL INSERT",
+    exportCurrentResultCsv: "Export Current Result Set All Data as CSV",
+    exportCurrentResultXlsx: "Export Current Result Set All Data as XLSX",
+    exportCurrentResultJson: "Export Current Result Set All Data as JSON",
+    exportCurrentResultMarkdown: "Export Current Result Set All Data as Markdown",
+    exportCurrentResultSql: "Export Current Result Set All Data as SQL INSERT",
+    exportAllResultsXlsx: "Export This Run's All Result Sets as XLSX",
+    exportJson: "Export JSON",
+    exportMarkdown: "Export Markdown",
+    exportSql: "Export SQL INSERT",
+    exportSelectedRowsCsv: "Export Selected Rows as CSV",
+    exportSelectedRowsXlsx: "Export Selected Rows as XLSX",
+    exportSelectedRowsJson: "Export Selected Rows as JSON",
+    exportSelectedRowsMarkdown: "Export Selected Rows as Markdown",
+    exportSelectedRowsSql: "Export Selected Rows as SQL INSERT",
+    exported: "Exported",
+    exportFailed: "Export failed: {message}",
+    copied: "Copied",
+    copyFailed: "Copy failed: {message}",
+    previewSqlEmpty: "No pending SQL changes to preview",
+    renderMode: "Render Mode",
+    domRenderMode: "DOM",
+    canvasRenderMode: "Canvas",
+    renderModeHint: "Switch between Canvas rendering and the DOM fallback grid.",
+    tableFontSize: "Table font size",
+    filter: "Filter",
+    conditionHistoryEmpty: "No history yet",
+    conditionHistoryNoMatches: "No matching history",
+    filterBuilder: "Filters",
+    filterBuilderTitle: "Filters",
+    filterBuilderHint: "Build point-and-click conditions and combine them with the WHERE input.",
+    filterBuilderSummary: "{count} rules",
+    filterBuilderAddRule: "Add rule",
+    filterBuilderColumn: "Column",
+    filterBuilderSearchColumns: "Search columns...",
+    filterBuilderNoMatchingColumns: "No matching columns",
+    filterBuilderValue: "Value",
+    filterBuilderNoValue: "No value needed",
+    filterBuilderEmpty: "Add a rule to start filtering rows.",
+    resetFilterBuilder: "Reset rules",
+    filterBuilderEquals: "Equals",
+    filterBuilderNotEquals: "Does not equal",
+    filterBuilderContains: "Contains",
+    filterBuilderNotContains: "Does not contain",
+    filterBuilderGreaterThan: "Greater than",
+    filterBuilderLessThan: "Less than",
+    filterBuilderIsNull: "Is NULL",
+    filterBuilderIsNotNull: "Is not NULL",
+    columnActions: "Column actions",
+    localFilter: "Local value filter",
+    localFilterFor: "Local Values For '{column}'",
+    databaseValueFilter: "Database value filter",
+    databaseValueFilterFor: "Database Values For '{column}'",
+    columnFormatter: "Column formatter",
+    columnFormatterFor: "Formatter for '{column}'",
+    columnFormatterHint: "Formats display only; raw values stay unchanged.",
+    formatterType: "Type",
+    formatterDatetime: "Unix timestamp",
+    formatterJsonPath: "JSON path",
+    formatterMask: "Mask text",
+    formatterCustomTemplate: "Custom template",
+    formatterTimestampUnit: "Timestamp unit",
+    formatterUnitAuto: "Auto",
+    formatterUnitSeconds: "Seconds",
+    formatterUnitMilliseconds: "Milliseconds",
+    formatterDatetimePattern: "Datetime pattern",
+    formatterDatetimePatternPlaceholder: "Select or enter a datetime pattern",
+    formatterDatetimePatternEmpty: "Default ISO8601 format",
+    formatterJsonPathInput: "JSON path",
+    formatterMaskPrefix: "Visible prefix",
+    formatterMaskSuffix: "Visible suffix",
+    formatterSavedCustom: "Saved templates",
+    formatterNewCustom: "New template",
+    formatterCustomName: "Template name",
+    formatterCustomNamePlaceholder: "Example: User label",
+    formatterCustomTemplateInput: "Template",
+    formatterCustomTemplateHint: "Available variables: ${value}, ${upper}, ${lower}, ${length}. Give it a name to save it to the list.",
+    formatterPreview: "Preview",
+    saveFormatter: "Save",
+    clearFormatter: "Clear",
+    searchValues: "Search values...",
+    loadingValues: "Loading values...",
+    serverValuesLimited: "Showing first {count} values",
+    filterTypedValue: "Use '{value}'",
+    value: "Value",
+    count: "Count",
+    applyFilter: "Apply Filter",
+    clearLocalFilters: "Clear local value filters",
+    clearLocalFiltersShort: "Clear local",
+    localFiltersActive: "{count} local value filters",
+    localFilterMoreValues: " +{count} more",
+    columnVisibility: "Columns",
+    columnVisibilityHint: "At least one column stays visible.",
+    searchColumns: "Search columns...",
+    dragColumnToReorder: "Drag column header to reorder",
+    invertColumnVisibility: "Invert",
+    resetColumnOrder: "Reset order",
+    showAllColumns: "Show all",
+    viewOptions: "View options",
+    hideNullColumns: "Hide NULL",
+    hideNullColumnsHint: "Toggle columns whose values are all NULL in the current result.",
+    searchMode: "Search mode",
+    searchModeHint: "Choose whether Ctrl+F filters matching rows or keeps all rows visible and highlights matches.",
+    searchModeFilter: "Filter",
+    searchModeHighlight: "Highlight",
+    moreValues: "{count} more values, keep typing to narrow results",
+    filterByValue: "Filter by This Value",
+    filterExcludeValue: "Exclude This Value",
+    filterLike: "Contains Value",
+    filterNotLike: "Does Not Contain",
+    filterLessThan: "Less Than Value",
+    filterGreaterThan: "Greater Than Value",
+    filterIsNull: "Show NULL Values",
+    filterIsNotNull: "Show Non-NULL Values",
+    clearFilter: "Clear Filter",
+    sort: "Sort",
+    sortAscending: "Sort Ascending",
+    sortDescending: "Sort Descending",
+    sortCurrentPageAscending: "Sort Current Page Ascending",
+    sortCurrentPageDescending: "Sort Current Page Descending",
+    sortDatabaseAscending: "Sort Database Ascending",
+    sortDatabaseDescending: "Sort Database Descending",
+    clearSort: "Clear Sort",
+    pasted: "Pasted!",
+    search: "Search...",
+    searchOrWhere: "Search, or enter a WHERE clause...",
+    applyWhere: "Apply WHERE",
+    filterRows: "Filter rows",
+    filterAllRows: "All rows",
+    filterChangedRows: "Changed",
+    page: "Page {page}",
+    rowsPerPage: "Rows per page",
+    customRowsPerPage: "Custom rows",
+    applyPageSize: "Apply",
+    save: "Save",
+    discard: "Discard",
+    dismiss: "Dismiss",
+    addRow: "Add Row",
+    quickEntryDraftPlaceholder: "New",
+    cloneRow: "Clone as New Row",
+    deleteRow: "Delete Row",
+    deleteRows: "Delete {count} Rows",
+    cloneRows: "Clone {count} as New Rows",
+    restoreRows: "Restore {count} Rows",
+    copyRows: "Copy {count} Rows (JSON)",
+    copySelectedRowsTsv: "Copy {count} Rows (TSV)",
+    copySelectedRowsTsvWithHeaders: "Copy {count} Rows with Headers (TSV)",
+    copySelectedRowTsv: "Copy 1 Row (TSV)",
+    copySelectedRowTsvWithHeaders: "Copy 1 Row with Headers (TSV)",
+    copyColumnsJson: "Copy {count} Columns (JSON)",
+    copyRowsInsert: "Copy {count} Rows as INSERT",
+    copyRowsInsertMerged: "Copy {count} Rows as INSERT (Merged)",
+    copyRowsInsertRowByRow: "Copy {count} Rows as INSERT (Row by Row)",
+    copyRowsInsertWithoutPrimaryKeys: "Copy {count} Rows as INSERT without Primary Keys",
+    copyRowsInsertWithoutPrimaryKeysMerged: "Copy {count} Rows as INSERT without Primary Keys (Merged)",
+    copyRowsInsertWithoutPrimaryKeysRowByRow: "Copy {count} Rows as INSERT without Primary Keys (Row by Row)",
+    copyRowsUpdate: "Copy {count} Rows as UPDATE",
+    selectedRows: "{count} rows selected",
+    restoreRow: "Restore Row",
+    statusClean: "Clean",
+    statusNew: "New Items",
+    statusEdited: "Updated Items",
+    statusDeleted: "Deleted Items",
+    pendingChanges: "{count} pending",
+    selectedCells: "{count} selected",
+    bulkEditSelection: "Bulk Edit Selection",
+    bulkEditTitle: "Bulk Edit Selection",
+    bulkEditDescription: "Set {count} selected cell(s) to this value.",
+    bulkEditValuePlaceholder: "Value, or NULL",
+    applyBulkEdit: "Apply",
+    cellDetails: "Cell Details",
+    cellDetailLayoutBottom: "Move to Bottom",
+    cellDetailLayoutRight: "Move to Right",
+    openCellDetailsDialog: "Open Cell Details",
+    rowDetails: "Row Details",
+    rowDetailsFor: "Row {row} Details",
+    openRowDetailsDialog: "Open Row Details",
+    openColumnDetailsDialog: "Open Column Details",
+    columnDetailsFor: "{column} Column Details",
+    columnsCount: "{count} columns",
+    rowCount: "Rows",
+    rowsCount: "{count} rows",
+    fieldIndex: "No.",
+    cellValue: "Value",
+    valueEditor: "Value Editor",
+    hexViewer: "Hex Viewer",
+    hexViewerByteCount: "{count} bytes",
+    hexViewerOffset: "Offset",
+    hexViewerHex: "Hex",
+    hexViewerAscii: "ASCII",
+    hexViewerEmpty: "No binary bytes to display.",
+    imagePreview: "Image Preview",
+    imageLoadFailed: "Image failed to load",
+    geometryPreview: "Geometry Preview",
+    layerPreview: "Layer Preview",
+    zoomIn: "Zoom In",
+    zoomOut: "Zoom Out",
+    fitImage: "Fit to View",
+    openImage: "Open Image",
+    columnName: "Column",
+    columnType: "Type",
+    columnComment: "Comment",
+    rowNumber: "Row",
+    valueLength: "Length",
+    nullValue: "NULL",
+    emptyStringValue: "Empty string",
+    noComment: "No comment",
+    formattedJson: "Formatted JSON",
+    formattedValue: "Formatted Value",
+    detailSearchPlaceholder: "Search field or value…",
+    detailSearchNoMatch: "No matches",
+    rawValue: "Raw Value",
+    largeValuePreviewHint: "Previewing first {count} characters. Copy still uses the full value.",
+    copyValue: "Copy Value",
+    downloadBinaryValue: "Download Value",
+    downloadSaved: "Saved to {path}",
+    downloadStarted: "Download started: {fileName}",
+    binaryDownload: {
+      binary: "Raw binary",
+      utf8: "Decoded text (UTF-8)",
+      gbk: "Decoded text (GBK)",
+    },
+    copyRowTsv: "Copy Row (TSV)",
+    copyColumnValues: "Copy Column (JSON)",
+    copyColumnTsv: "Copy Column (TSV)",
+    editValue: "Edit Value",
+    formatJson: "Format JSON",
+    compactJson: "Compact JSON",
+    formattedJsonEditWarning: "You are editing formatted JSON. Saving will write it as JSON, so the original formatting may change.",
+    setNull: "Set NULL",
+    restoreOriginalValue: "Restore Original",
+    copyColumnName: "Copy Column Name",
+    copyAlterColumnSql: "Copy as SQL ALTER",
+    alterSqlCopied: "SQL ALTER copied to clipboard",
+    alterSqlCopiedWithWarnings: "SQL ALTER copied to clipboard ({count} warning(s))",
+    noAlterSqlAvailable: "No ALTER SQL available for this column",
+    copyAlterSqlFailed: "Copy failed: {message}",
+    copySqlCondition: "Copy SQL Condition",
+    transpose: "Transpose Row",
+    transposeMultiRowToggle: "Multi-row",
+    transposeSingleRow: "Current row",
+    transposeMultiRow: "Multi-row",
+    transposeMultiRowHint: "When enabled, transpose view shows multiple rows. When disabled, it only shows the current row.",
+    rowsPerPageShort: " rows",
+    columnDetails: "Column Details",
+    tableInfo: "Table Info",
+    tableInfoColumns: "Columns",
+    tableInfoIndexes: "Indexes",
+    tableInfoForeignKeys: "Foreign Keys",
+    tableInfoTriggers: "Triggers",
+    tableInfoNullable: "Nullable",
+    tableInfoEmpty: "No metadata",
+    tableInfoSearch: "Search...",
+    tableInfoNoResults: "No results",
+    goToColumn: "Go to column",
+    columnWidth: "Column Width",
+    columnWidthCompact: "Compact",
+    columnWidthStandard: "Standard",
+    columnWidthComfortable: "Comfortable",
+    searchColumn: "Search column/comment...",
+    noColumnsFound: "No columns found",
+    queryError: "Query Error",
+    dataUnavailable: "Table data needs to be reloaded.",
+    dataUnavailableHintPrefix: "Press ",
+    dataUnavailableHintSuffix: " or click Refresh below to reload.",
+    refresh: "Refresh",
+    undoChange: "Undo change",
+    redoChange: "Redo change",
+    commit: "Commit",
+    rollback: "Rollback",
+    transactionSaveHint: "Commit {count} pending change(s) in a transaction.",
+    nonTransactionalSaveHint: "Save {count} pending change(s) one by one. If one fails, earlier successful changes will not be rolled back.",
+    keylessEditWarning: "No primary key",
+    keylessEditWarningHint: "This table has no primary key. Updates and deletes use all original row values in the WHERE clause; exact duplicate rows may be affected together.",
+    queryEditReadOnly: "Read-only result",
+    queryEditUnsupported: {
+      "not-select": "Only SELECT query results can be edited directly.",
+      cte: "Queries with WITH/CTE are not editable yet. Use a simple single-table SELECT.",
+      "set-operation": "UNION, INTERSECT, or EXCEPT results cannot be mapped safely back to source rows.",
+      aggregation: "DISTINCT, GROUP BY, HAVING, and aggregate results cannot be edited directly.",
+      "external-source": "External files and table-function results cannot be written back directly. Import them into a database table before editing.",
+      "complex-source": "DBX could not identify exactly one safe writeback target table for this result.",
+      "computed-columns": "Computed expressions or function results cannot be written back. Select raw column names instead.",
+      "no-table": "No editable source table was detected.",
+      "no-primary-key": "The target table has no primary key, so rows cannot be updated or deleted safely.",
+      "primary-key-not-returned": "The result is missing the raw primary key column. Include it by its original column name.",
+      "aliased-columns": "Result columns use aliases or expressions. Select editable columns by their original names.",
+      "metadata-unavailable": "DBX could not load table metadata, so result editing is disabled.",
+    },
+    sortUnsupported: "This SQL does not support full-result sorting. Try again with a single SELECT query.",
+    truncatedHint: "Results truncated to {count} rows. Use the footer pagination or adjust rows per page.",
+  },
+  exportProgress: {
+    title: "Exporting Table Data",
+    fetching: "Fetching data from database...",
+    writing: "Writing to file...",
+    done: "Export completed!",
+    error: "Export failed",
+    cancelled: "Export cancelled.",
+    rowsCount: "{exported} / {total} rows",
+    rowsExported: "{count} rows exported",
+    rowsShort: "rows",
+    cancel: "Cancel",
+    close: "Close",
+    tooltip: "Background Tasks",
+    failedTooltip: "{count} background task failed | {count} background tasks failed",
+    popoverTitle: "Background Tasks",
+    noTasks: "No background tasks",
+    clearFinished: "Clear finished",
+    showMore: "Show {count} more",
+    showLess: "Show less",
+    delete: "Remove",
+    databaseExportTitle: "Database backup: {name}",
+    sqlFileTitle: "SQL file: {name}",
+    dataTransferTitle: "Data transfer: {name}",
+    objectsCount: "{current} / {total} objects",
+    tablesCount: "{current} / {total} tables",
+    statementsCount: "{done} succeeded, {failed} failed",
+  },
+  welcome: {
+    title: "Database Workspace",
+    subtitle: "Choose a connection on the left to browse schema, or open a query tab directly.",
+    connections: "Connections",
+    connected: "Connected",
+    databaseTypes: "Database Types",
+    quickConnections: "Quick Start",
+    quickConnectionsHint: "Click a connection to open a query tab.",
+    shortcuts: "Shortcuts",
+    shortcutsHint: "Start the next action from here.",
+    sqlHistory: "Query History",
+    sqlHistoryEmpty: "No SQL Library records yet",
+    sqlHistoryOpenCount: "Opened {count} times",
+    unknownConnection: "Unknown connection",
+    tip: "You can also expand connections on the left and right-click databases or tables for more actions.",
+    tipSidebar: "Click a table on the left to view data",
+    tipExecute: "to execute query",
+    fileOpened: "Opened {name}",
+    mcpTitle: "AI Agent Integration",
+    mcpDescription: "Beyond the built-in AI assistant, you can also use Claude Code, Cursor, and other coding agents to query your databases via MCP.",
+    mcpLearnMore: "Learn more",
+  },
+  common: {
+    language: "Language",
+    loading: "Loading...",
+    stopping: "Stopping...",
+    close: "Close",
+    cancel: "Cancel",
+    save: "Save",
+    copy: "Copy",
+    import: "Import",
+    remove: "Remove",
+    retry: "Retry",
+    more: "More",
+    decrease: "Decrease",
+    increase: "Increase",
+    showPassword: "Show password",
+    hidePassword: "Hide password",
+    done: "Done",
+    connection: "Connection",
+    database: "Database",
+    table: "Table",
+    view: "View",
+    materializedView: "Materialized View",
+    procedure: "Procedure",
+    function: "Function",
+    sequence: "Sequence",
+    package: "Package",
+    packageBody: "Package Body",
+    noResults: "No results",
+  },
+  quickOpen: {
+    placeholder: "Search connections, databases, tables, and other objects...",
+    emptyPlaceholder: "Start typing to search",
+    noResults: "No results found",
+    results: "results",
+    navigate: "Navigate",
+    select: "Select",
+    close: "Close",
+  },
+  explain: {
+    title: "Explain Plan",
+    standardTable: "Table",
+    tree: "Tree",
+    summary: "Summary",
+    running: "Reading explain plan...",
+    empty: "No explain plan",
+    nodeCount: "{count} nodes",
+    node: "Node",
+    relation: "Table",
+    index: "Index",
+    cost: "Cost",
+    rows: "Rows",
+    details: "Details",
+    unsupported: "Explain plan is not supported for this database yet",
+    emptySql: "No SQL to explain",
+    unsafe: "This first version only explains SELECT / WITH / TABLE / VALUES statements",
+  },
+  lineage: {
+    title: "Field Lineage",
+    open: "View Field Lineage",
+    loading: "Reading metadata {done}/{total}",
+    empty: "No related lineage found",
+    noFiltered: "No results match the current filters",
+    targetField: "Current Field",
+    searchPlaceholder: "Search tables, fields, views, or SQL snippets...",
+    showing: "Showing {shown}/{total} results",
+    all: "All",
+    certain: "Certain",
+    likely: "Likely",
+    possible: "Possible",
+    queryHistory: "Query History",
+    openTable: "Open table",
+    copy: "Copy name",
+    copied: "Copied",
+    kind: {
+      foreignKey: "Foreign Key",
+      viewReference: "View",
+      historyReference: "SQL History",
+      sameName: "Same Name",
+    },
+    description: {
+      foreignKeyIncoming: "{target} points to the current field through a foreign key. This is a verified dependency.",
+      foreignKeyOutgoing: "The current field references {target} through a foreign key. This is a verified dependency.",
+      viewLikely: "The view definition mentions both the target table and field, usually indicating query dependency.",
+      viewPossible: "The view definition mentions a same-name field but not the target table, so it needs confirmation.",
+      historyLikely: "A historical SQL statement mentions both the target table and field. Use it as impact-analysis context.",
+      historyPossible: "A historical SQL statement mentions a same-name field. It may be related but needs context.",
+      sameName: "Another table has a same-name field. This may share business meaning but is not a verified database dependency.",
+    },
+    cancel: "Cancel",
+    refresh: "Analyze Again",
+  },
+  connectionGroup: {
+    createGroup: "New Group",
+    groupNamePlaceholder: "Group name",
+    selectConnection: "Select connection",
+    deselectConnection: "Deselect connection",
+    selectAllConnections: "Select all connections",
+    deselectAllConnections: "Deselect all connections",
+    exitMultiSelect: "Exit selection",
+    renameGroup: "Rename Group",
+    deleteGroup: "Delete Group",
+    moveToGroup: "Move to Group",
+    moveToNewGroup: "Move to New Group",
+    ungrouped: "Ungrouped",
+    newGroup: "New Group...",
+    newGroupDefault: "New Group",
+    deleteGroupConfirmTitle: "Delete Group",
+    deleteGroupConfirmMessage: 'Delete group "{name}"? Connections inside will be moved to the top level.',
+  },
+  databaseSearch: {
+    title: "Search Database",
+    open: "Search Database",
+    keyword: "Keyword",
+    keywordPlaceholder: "Enter a user ID, email, order number...",
+    limitPerTable: "Per table",
+    search: "Search",
+    searching: "Searching",
+    stop: "Stop",
+    hint: "Scans regular tables in the current database or schema. Binary columns are skipped and each table is capped to avoid loading too much data at once.",
+    loadingTables: "Reading table list...",
+    progress: "Scanned {done}/{total} tables",
+    resultCount: "{count} matches",
+    limitedTables: "Large schema detected; only the first {count} tables are scanned",
+    results: "Results",
+    openResult: "Open",
+    waiting: "Waiting for matches...",
+    noResults: "No matches yet",
+    errors: "Some tables failed",
+  },
+  configExport: {
+    passphraseTitle: "Encrypt & Export",
+    passphraseImportTitle: "Decrypt & Import",
+    passphraseExportHint: "To include connection passwords in the export, set a passphrase for encryption. You will need the same passphrase to import.",
+    passphraseImportHint: "This file is encrypted. Enter the passphrase to decrypt and import.",
+    passphrase: "Passphrase",
+    passphraseConfirm: "Confirm Passphrase",
+    passphrasePlaceholder: "Enter passphrase",
+    passphraseConfirmPlaceholder: "Re-enter passphrase",
+    passphraseRequired: "Passphrase is required",
+    passphraseMismatch: "Passphrases do not match",
+    passphraseTooShort: "Passphrase must be at least 4 characters",
+    exportEncrypted: "Export",
+    decryptImport: "Decrypt & Import",
+    wrongPassphrase: "Wrong passphrase or corrupted file",
+    cryptoUnavailable: "Encrypted config import is unavailable in this browser context. Use HTTPS, localhost, or DBX Desktop.",
+    exportSuccess: "Connections exported successfully",
+    importSuccess: "Imported {count} connection(s)",
+    importNavicatSuccess: "Imported {count} Navicat connection(s). Fill in any connection whose password is still empty before testing.",
+    importDatagripSuccess: "Imported {count} DataGrip connection(s), filled {filled} password(s) from macOS Keychain.",
+    importDbeaverSuccess: "Imported {count} DBeaver connection(s). Fill in any connection whose password is still empty before testing.",
+    importNone: "No new connections to import",
+    importLayoutConfirm: "The imported file contains connection groups. Apply them?",
+    importLayoutTitle: "Import Groups",
+    importLayoutApply: "Apply",
+  },
+  ai: {
+    placeholder: "Describe your query in natural language...",
+    settings: "AI Settings",
+    noConfig: "AI is not configured. Please set up your AI provider in Settings > AI.",
+    provider: "Provider",
+    providerStatusActive: "Active",
+    providerStatusConfigured: "Configured",
+    switchProvider: "Switch Provider",
+    model: "Model",
+    browseModels: "Browse models",
+    refreshModels: "Refresh models",
+    loadingModels: "Loading models...",
+    searchModels: "Search models",
+    noModels: "No models loaded",
+    modelListHint: "Click refresh to load models from the provider.",
+    modelListUnsupported: "This provider does not support fetching a model list.",
+    modelListEndpointRequired: "Enter an endpoint before loading models.",
+    modelListApiKeyRequired: "Enter an API key before loading models.",
+    run: "Run",
+    readingSchema: "Reading schema",
+    noConnection: "No connection is available for this tab",
+    noSql: "No SQL to process",
+    sqlPreview: "SQL Preview",
+    copySql: "Copy SQL",
+    copyCode: "Copy Code",
+    executeSql: "Execute SQL",
+    tempRunSql: "Run without modifying editor",
+    copyAll: "Copy All",
+    copied: "Copied",
+    copyTestResult: "Copy test result",
+    replace: "Replace Editor",
+    append: "Append to Editor",
+    apply: "Apply to Editor",
+    clear: "Clear Chat",
+    welcome: "Tell me what you'd like to query, and I'll write the SQL",
+    newChat: "New Chat",
+    thinking: "Thinking...",
+    reasoningProcess: "Thinking process",
+    stopGenerating: "Stop generating",
+    scrollToBottom: "Back to bottom",
+    tableMentionEmpty: "No matching tables or SQL files",
+    tableMentionPlaceholderHint: "Type {'@'} to mention tables or SQL files for context",
+    tableMentionTypes: {
+      table: "Table",
+      view: "View",
+      systemTable: "System table",
+      temporaryTable: "Temporary table",
+    },
+    modes: {
+      ask: "Ask",
+      agent: "Agent",
+    },
+    modeHints: {
+      ask: "Generate SQL and explanations without auto-running them",
+      agent: "Use tools to query data and answer from real results",
+    },
+    fixWithAi: "Fix with AI",
+    truncated: "Context truncated",
+    contextSummary: "{database} · {tables} tables",
+    autoSqlBlocked: "The AI-generated SQL looked too risky to auto-execute. Review it manually before running.",
+    proposalConfirmYes: "Yes, proceed",
+    proposalConfirmNo: "No thanks",
+    proposalConfirmTitle: "Action confirmation required",
+    agentSteps: {
+      generated: "SQL generated",
+      noSql: "No SQL found",
+      safe: "Safety passed",
+      needsConfirm: "Needs confirmation",
+      blocked: "Blocked",
+      autoExecute: "Ready to run",
+      notRequested: "Run not requested",
+      skipped: "Not run",
+      callingTool: "Calling tool...",
+      toolDone: "Tool completed",
+      toolError: "Tool error",
+      executeSafe: "Safety check passed · Executed",
+      executeBlocked: "Blocked by safety check",
+      contextCompacted: "Context compressed",
+    },
+    agentStepTitles: {
+      riskCheck: "Risk check: {action} · {category} · {environment} · {reasons}",
+      blocked: "Execution was blocked by the risk policy. Review the SQL manually.",
+      requiresConfirmation: "This SQL requires confirmation before execution.",
+      askMode: "Ask mode does not auto-run SQL.",
+      unsupportedAction: "The current AI action does not auto-run SQL.",
+      noSql: "The response did not include an executable SQL code block.",
+      notRequested: "The user did not ask to run the SQL.",
+      skipped: "This step was not run.",
+    },
+    proxy: "Proxy",
+    proxyEnable: "Send AI requests through proxy",
+    proxyUrl: "Proxy URL",
+    enableThinking: "Thinking",
+    enableThinkingOn: "Enabled",
+    enableThinkingOff: "Disabled",
+    enableThinkingHint: "This option only takes effect on /chat/completions APIs and supported models. When disabled, it can significantly reduce token usage, but the quality of generated results may decrease slightly.",
+    anthropicMessagesHint: "Anthropic Messages compatible APIs usually use /v1/messages.",
+    contextWindow: "Context Window",
+    contextWindowAuto: "Auto (detect from model name)",
+    contextWindowHint: "Tokens. Leave empty to auto-detect. Set manually for local/custom models.",
+    codexCliPath: "Codex CLI Path",
+    codexCliPathHint: "Leave empty to use codex from PATH. Sign in separately with codex login.",
+    codexCliPathEnvError: "Codex CLI Path should contain only the executable path. Add environment variables below.",
+    codexCliEnv: "Environment variables",
+    codexCliEnvAdd: "Add variable",
+    codexCliEnvHint: "Optional variables passed to Codex CLI, such as HTTPS_PROXY, NO_PROXY, SSL_CERT_FILE, or CODEX_CA_CERTIFICATE.",
+    codexCliEnvKeyPlaceholder: "HTTPS_PROXY",
+    codexCliEnvValuePlaceholder: "http://proxy:9800",
+    codexCliEnvInvalidName: "Invalid environment variable name: {name}",
+    codexCliEnvReservedName: "{name} is managed by DBX for the MCP server and cannot be set here.",
+    codexMcpRequiredTitle: "DBX MCP Server required",
+    codexMcpRequiredDescription: "Codex CLI uses the DBX MCP Server to access database schema and query tools. Install it before using Codex in the AI assistant.",
+    reasoningLevel: "Reasoning level",
+    reasoningLevelDefault: "Default",
+    reasoningLevelMinimal: "Minimal",
+    reasoningLevelLow: "Low",
+    reasoningLevelMedium: "Medium",
+    reasoningLevelHigh: "High",
+    reasoningLevelHint: "Controls Codex CLI model_reasoning_effort. Default uses your Codex config.",
+    actions: {
+      general: "General",
+      generate: "Generate SQL",
+      explain: "Explain SQL",
+      optimize: "Optimize SQL",
+      fix: "Fix Error",
+      convert: "Convert Dialect",
+      sampleData: "Sample Data",
+      query: "Query Data",
+      exploreSchema: "Inspect Schema",
+      executeAndExplain: "Run & Explain",
+      generateNoExec: "Generate (no run)",
+    },
+    placeholders: {
+      general: "Ask me anything...",
+      generate: "Describe what you want to query, e.g. orders per user in the last 7 days",
+      explain: "Optional: add what you want to understand",
+      optimize: "Optional: add a goal, e.g. reduce full table scans",
+      fix: "Paste the error or describe the expected result",
+      convert: "e.g. convert to PostgreSQL / MySQL / SQL Server",
+      sampleData: "Describe the sample data or test statements to generate",
+      query: "Describe what to query or count, e.g. order totals by region this month",
+      exploreSchema: "Describe the table or structure to inspect, e.g. columns and indexes of orders",
+      executeAndExplain: "Optional: add what to focus on in the explanation",
+    },
+    editMessage: "Edit message",
+    editResend: "Resend",
+    editCancel: "Cancel",
+  },
+  contextMenu: {
+    openConnection: "Open Connection",
+    closeConnection: "Close Connection",
+    closeDatabaseConnection: "Close Database Connection",
+    deleteConnection: "Delete Connection",
+    deleteSelectedConnections: "Delete Selected {count} Connections",
+    confirmDeleteTitle: "Delete Connection",
+    confirmDeleteMessage: 'Are you sure you want to delete "{name}"? This cannot be undone.',
+    confirmDeleteSelectedMessage: "Are you sure you want to delete the selected {count} connections? This cannot be undone.",
+    editConnection: "Edit Connection",
+    revealDatabaseFile: "Reveal in File Manager",
+    selectVisibleDatabases: "Select Visible Databases",
+    configureVisibleObjects: "Visible Object Filter",
+    userAdmin: "Users & Privileges",
+    openUserAdmin: "Open Users & Privileges",
+    damengJobAdmin: "Dameng Agent Jobs",
+    openDamengJobAdmin: "Open Dameng Agent Jobs",
+    duplicateConnection: "Duplicate Connection",
+    duplicateSelectedConnections: "Duplicate Selected {count} Connections",
+    newQuery: "New Query",
+    instanceInfo: "Instance Info",
+    newSql: "New SQL",
+    generateSql: "Generate SQL",
+    newInsert: "New Insert",
+    newUpdate: "New Update",
+    sqlHistory: "Query History",
+    noSqlHistory: "No related SQL",
+    openObjectBrowser: "Browse Objects",
+    viewData: "View Data",
+    editStructure: "Edit Structure",
+    editColumn: "Edit Column",
+    editIndex: "Edit Index",
+    refreshChildren: "Refresh",
+    expandAll: "Expand All",
+    pin: "Pin",
+    unpin: "Unpin",
+    fixTab: "Fix Tab",
+    unfixTab: "Unfix Tab",
+    refreshTab: "Refresh Data",
+    renameTab: "Rename Tab",
+    duplicateTab: "Duplicate Tab",
+    compactTabTitle: "Shorten Tab Titles",
+    fullTabTitle: "Show Full Tab Titles",
+    closeTab: "Close Tab",
+    closeFixedTab: "Close Fixed Tab",
+    closeOtherTabs: "Close Other Tabs",
+    closeOtherRegularTabs: "Close Other Regular Tabs",
+    closeOtherFixedTabs: "Close Other Fixed Tabs",
+    closeAllTabs: "Close All Tabs",
+    closeAllRegularTabs: "Close All Regular Tabs",
+    closeAllFixedTabs: "Close All Fixed Tabs",
+    copyName: "Copy Name",
+    copyFinalProxyPort: "Copy Final Proxy Port",
+    finalProxyPortCopied: "Final proxy port {port} copied",
+    setDefaultDatabase: "Set as Default Database",
+    clearDefaultDatabase: "Clear Default Database",
+    exportDatabase: "Export Database",
+    exportAllDatabases: "Export All Databases",
+    exportDatabaseSuccess: "Exported {count} tables, up to {limit} rows each",
+    exportDatabaseFailed: "Failed to export database: {message}",
+    backupSqliteDatabase: "Backup SQLite Database",
+    backupSqliteDatabaseInProgress: "Backing up SQLite database...",
+    backupSqliteDatabaseSuccess: "SQLite database backed up",
+    backupSqliteDatabaseFailed: "Failed to backup SQLite database: {message}",
+    importData: "Import Data",
+    exportData: "Export Data",
+    exportStructure: "Export Structure",
+    exportStructurePreviewTitle: "Structure - {name}",
+    exportStructurePreviewTitleMultiple: "Structure - {count} objects",
+    exportStructureLoading: "Loading structure...",
+    copyStructure: "Copy Structure",
+    copyStructureAs: "Copy Structure As",
+    copyStructureAsTsv: "TSV (for Excel)",
+    copyStructureAsMarkdown: "Markdown Table",
+    structureDocTable: "Table",
+    structureDocColumn: "Column",
+    structureDocType: "Type",
+    structureDocPrimaryKey: "Primary Key",
+    structureDocNullable: "Nullable",
+    structureDocDefault: "Default",
+    structureDocComment: "Comment",
+    structureDocYes: "Yes",
+    structureDocNo: "No",
+    structureDocCopied: "Structure copied",
+    structureDocCopyFallbackHint: "Automatic copy was blocked. Click Copy again, or select the content below.",
+    saveStructure: "Save SQL",
+    exportStructureCopied: "Structure copied",
+    createTable: "Create Table",
+    createView: "Create View",
+    dropTable: "Drop Table",
+    emptyTable: "Empty Table",
+    truncateTable: "Truncate Table",
+    duplicateStructure: "Clone as New Table",
+    renameObject: "Rename",
+    renameObjectTitle: "Rename Object",
+    renameObjectNamePlaceholder: "New name",
+    renameObjectSuccess: '"{oldName}" renamed to "{newName}"',
+    confirmDropTableTitle: "Drop Table",
+    confirmDropTableMessage: 'Are you sure you want to drop "{name}"? This will permanently delete the table and all its data.',
+    dropTableCascade: "Use CASCADE",
+    dropTableCascadeHint: "Also drop dependent objects such as views. Leave off to use PostgreSQL's default RESTRICT behavior.",
+    truncateTableCascade: "Use CASCADE",
+    truncateTableCascadeHint: "Also truncate tables that reference this table through foreign keys. Leave off to use PostgreSQL's default RESTRICT behavior.",
+    confirmEmptyTableTitle: "Empty Table",
+    confirmEmptyTableMessage: 'Are you sure you want to delete all data from "{name}"?',
+    confirmTruncateTableTitle: "Truncate Table",
+    confirmTruncateTableMessage: 'Are you sure you want to truncate "{name}"? This will remove all rows.',
+    dropTableSuccess: 'Table "{name}" dropped',
+    editView: "Edit View",
+    viewSource: "View Source",
+    viewDdl: "View DDL",
+    viewDdlLoading: "Loading DDL...",
+    ddlCopied: "DDL copied",
+    dropObject: "Drop Object",
+    dropView: "Drop View",
+    dropColumn: "Drop Column",
+    dropIndex: "Drop Index",
+    dropAllIndexes: "Drop All Indexes",
+    dropForeignKey: "Drop Foreign Key",
+    dropTrigger: "Drop Trigger",
+    batchDrop: "Drop selected ({count})",
+    batchEmpty: "Empty selected ({count})",
+    batchTruncate: "Truncate selected ({count})",
+    batchDropIndexes: "Drop Indexes ({count})",
+    executeProcedure: "Execute Procedure",
+    confirmExecuteProcedureTitle: "Execute Procedure",
+    confirmExecuteProcedureMessage: 'Execute procedure "{name}"? You can fill or adjust parameter values first.',
+    loadingProcedureParameters: "Loading parameters...",
+    procedureParametersUnavailable: "Could not load parameter metadata. You can still edit the SQL below and execute it.",
+    noProcedureParameters: "No parameters were found. The current SQL will be executed as shown.",
+    inputParameters: "{count} input parameters",
+    outputParameters: "{count} output parameters",
+    parameterName: "Name",
+    parameterType: "Type",
+    parameterMode: "Mode",
+    parameterValue: "Value",
+    parameterNull: "NULL",
+    parameterDefault: "DEFAULT",
+    parameterDefaultHint: "When DEFAULT is checked, DBX omits that argument so the database uses the procedure default.",
+    parameterValuePlaceholder: "Enter value",
+    outputOnly: "Output only",
+    sqlPreview: "SQL Preview",
+    resetSqlPreview: "Reset SQL",
+    openInSqlEditor: "Open in Editor",
+    dropProcedure: "Drop Procedure",
+    dropFunction: "Drop Function",
+    manageExtension: "Manage Extensions...",
+    dropExtension: "Drop Extension",
+    confirmDropViewTitle: "Drop View",
+    confirmDropViewMessage: 'Are you sure you want to drop view "{name}"?',
+    confirmDropObjectTitle: "Drop Object",
+    confirmDropObjectMessage: 'Are you sure you want to drop "{name}"?',
+    confirmDropColumnTitle: "Drop Column",
+    confirmDropIndexTitle: "Drop Index",
+    confirmDropMongoIndexMessage: 'Are you sure you want to drop index "{name}" from collection "{collection}"?',
+    confirmDropMongoAllIndexesMessage: 'Are you sure you want to drop all removable indexes from collection "{name}"?',
+    confirmDropMongoAllIndexesDetails: 'MongoDB keeps the "_id_" index. Additional shard-key-required indexes may also remain; the result will list only the indexes actually dropped.',
+    confirmDropForeignKeyTitle: "Drop Foreign Key",
+    confirmDropTriggerTitle: "Drop Trigger",
+    confirmDropTableChildObjectMessage: 'Are you sure you want to drop "{name}" from "{table}"?',
+    confirmDropBatchIndexesMessage: 'Are you sure you want to drop {count} selected indexes from "{table}"? This cannot be undone.',
+    confirmBatchDropTitle: "Drop Selected Objects",
+    confirmBatchDropMessage: "Are you sure you want to drop {count} selected objects? This cannot be undone.",
+    confirmBatchEmptyTitle: "Empty Selected Tables",
+    confirmBatchEmptyMessage: "Are you sure you want to delete all data from {count} selected tables?",
+    confirmBatchTruncateTitle: "Truncate Selected Tables",
+    confirmBatchTruncateMessage: "Are you sure you want to truncate {count} selected tables? This will remove all rows.",
+    confirmDropProcedureTitle: "Drop Procedure",
+    confirmDropProcedureMessage: 'Are you sure you want to drop procedure "{name}"?',
+    confirmDropFunctionTitle: "Drop Function",
+    confirmDropFunctionMessage: 'Are you sure you want to drop function "{name}"?',
+    dropViewSuccess: 'View "{name}" dropped',
+    dropProcedureSuccess: 'Procedure "{name}" dropped',
+    dropFunctionSuccess: 'Function "{name}" dropped',
+    dropTableChildObjectSuccess: '"{name}" dropped',
+    dropAllIndexesSuccess: 'Dropped {count} indexes from "{name}"',
+    batchDropSuccess: "Dropped {count} objects",
+    batchEmptySuccess: "Emptied {count} tables",
+    batchEmptyPartialFail: "Emptied {success} tables, {failed} failed",
+    batchEmptySubmitted: "Submitted empty tasks for {count} tables",
+    batchEmptySubmittedPartial: "Submitted {success} empty tasks, {failed} failed",
+    batchTruncateSuccess: "Truncated {count} tables",
+    emptyTableSuccess: 'All data deleted from "{name}"',
+    emptyTableSubmitted: 'Empty task submitted for "{name}"',
+    truncateTableSuccess: 'Table "{name}" truncated',
+    duplicateStructureSuccess: 'Table cloned as "{name}"',
+    tableOperationFailed: "Operation failed: {message}",
+    duplicateNameTitle: "Clone as New Table",
+    duplicateNamePlaceholder: "New table name",
+    copyTable: "Copy Table",
+    pasteTable: "Paste Table",
+    pasteOptionStructureAndData: "Structure and Data",
+    pasteOptionStructureOnly: "Structure Only",
+    pasteOptionDataOnly: "Data Only",
+    pasteTableSuccess: 'Table pasted as "{name}"',
+    pasteTableConfirmTitle: "Paste Table",
+    pasteTableConfirmMessage: "Paste table from clipboard",
+    batchPasteTitle: "Paste Tables",
+    batchPasteSuccess: "Successfully pasted {count} tables",
+    batchPastePartialFail: "Pasted {success} tables, {failed} failed",
+    noTableToPaste: "No tables available to paste",
+    pasteTableClipboardUpdated: "Table copied to clipboard",
+    createDatabase: "Create Database",
+    createDuckDbFile: "Create Database File",
+    dropDatabase: "Drop Database",
+    confirmDropDatabaseTitle: "Drop Database",
+    confirmDropDatabaseMessage: 'Are you sure you want to drop database "{name}"? This will permanently delete the database and all its data.',
+    createDatabaseSuccess: 'Database "{name}" created',
+    editDatabaseProperties: "Edit Database Properties",
+    editDatabasePropertiesTitle: 'Edit Database Properties: "{name}"',
+    editDatabasePropertiesSaving: "Saving...",
+    editDatabasePropertiesSuccess: 'Database "{name}" properties updated',
+    editDatabaseComment: "Database comment",
+    editDatabaseCommentPlaceholder: "Enter database comment...",
+    createDuckDbFileSuccess: 'DuckDB database file "{name}" created and attached',
+    createDuckDbFileDesktopOnly: "Creating DuckDB database files is only available in the desktop app",
+    dropDatabaseSuccess: 'Database "{name}" dropped',
+    dropCollection: "Drop Collection",
+    confirmDropCollectionTitle: "Drop Collection",
+    confirmDropCollectionMessage: 'Are you sure you want to drop collection "{name}"? This will permanently delete the collection and all its documents.',
+    dropCollectionSuccess: 'Collection "{name}" dropped',
+    createDatabaseNamePlaceholder: "Database name",
+    createDatabaseCharset: "Character set",
+    createDatabaseCharsetPlaceholder: "e.g. utf8mb4",
+    createDatabaseCharsetSearchPlaceholder: "Search or type a character set",
+    createDatabaseCharsetEmpty: "No character sets found",
+    createDatabaseCharsetLoading: "Loading character sets...",
+    createDatabaseCharsetCustomOption: 'Use "{value}"',
+    createDatabaseCollation: "Collation",
+    createDatabaseCollationPlaceholder: "e.g. utf8mb4_unicode_ci",
+    createDatabaseCollationSearchPlaceholder: "Search or type a collation",
+    createDatabaseCollationEmpty: "No collations found",
+    createDatabaseCollationLoading: "Loading collations...",
+    createDatabaseCollationCustomOption: 'Use "{value}"',
+    createSchema: "Create Schema",
+    dropSchema: "Drop Schema",
+    confirmDropSchemaTitle: "Drop Schema",
+    confirmDropSchemaMessage: 'Are you sure you want to drop schema "{name}"? This will permanently delete the schema and all its objects.',
+    createSchemaSuccess: 'Schema "{name}" created',
+    dropSchemaSuccess: 'Schema "{name}" dropped',
+    createSchemaNamePlaceholder: "Schema name",
+    editSchemaComment: "Edit Comment",
+    editSchemaCommentTitle: 'Edit Comment: "{name}"',
+    schemaCommentPlaceholder: "Enter schema comment...",
+    schemaCommentSaving: "Saving...",
+    editSchemaCommentSuccess: 'Schema "{name}" comment updated',
+  },
+  visibleDatabases: {
+    title: "Visible Databases",
+    description: 'Choose which databases are shown under "{connection}".',
+    searchPlaceholder: "Search databases...",
+    selectedCount: "{selected}/{total} selected",
+    selectAll: "Select all",
+    selectFiltered: "Select search results",
+    clear: "Clear",
+    showAll: "Show all",
+    showSystemDatabases: "Show system databases",
+    save: "Save",
+    emptySelection: "Select at least one database, or use Show all to clear the filter.",
+    loadFailed: "Failed to load databases: {message}",
+  },
+  visibleSchemas: {
+    title: "Schema Filter",
+    description: 'Choose which schemas are shown under "{connection}".',
+    searchPlaceholder: "Search schemas...",
+    selectedCount: "{selected}/{total} selected",
+    selectAll: "Select all",
+    selectFiltered: "Select search results",
+    clear: "Clear",
+    showAll: "Show all",
+    save: "Save",
+    emptySelection: "Select at least one schema, or use Show all to clear the filter.",
+    loadFailed: "Failed to load schemas: {message}",
+  },
+  tree: {
+    savedSql: "SQL Library",
+    userAdmin: "Users & Privileges",
+    damengJobAdmin: "Agent Jobs",
+    linkedServers: "Linked Servers",
+    defaultDatabase: "Default DB",
+    columns: "Columns",
+    indexes: "Indexes",
+    foreignKeys: "Foreign Keys",
+    triggers: "Triggers",
+    tables: "Tables",
+    views: "Views",
+    materializedViews: "Materialized Views",
+    procedures: "Procedures",
+    functions: "Functions",
+    sequences: "Sequences",
+    packages: "Packages",
+    gridfs: "GridFS",
+    buckets: "Buckets",
+    partitions: "Partitions",
+    childTables: "Subtables",
+    loadMore: "Load more...",
+    objectBrowser: "Browse in Object Browser ({count})",
+    extensions: "Extensions",
+  },
+  extension: {
+    manageTitle: "Manage Extensions",
+    installTitle: "Install Extension",
+    name: "Extension name",
+    namePlaceholder: "e.g. pg_stat_statements",
+    install: "Install",
+    drop: "Drop",
+    available: "Available",
+    installed: "Installed",
+    noAvailable: "All available extensions are already installed.",
+    noInstalled: "No extensions installed.",
+  },
+  userAdmin: {
+    title: "Users & Privileges",
+    unsupported: "MySQL-compatible and PostgreSQL-compatible connections are supported. SQL Server, Oracle, and other permission models can be added next.",
+    newUser: "New User",
+    anonymous: "Anonymous",
+    roleName: "Role name",
+    allowLogin: "Allow login",
+    searchUser: "Search user or host",
+    loadingUsers: "Loading users...",
+    loadingGrants: "Loading grants...",
+    emptyUsers: "No users found, or the current account cannot read the user list.",
+    pluginUnknown: "Authentication plugin unknown",
+    grants: "Grants",
+    noGrants: "No grants found",
+    privilegeEditor: "Privilege Editor",
+    privilegeHint: "Choose privileges, database, and table, then preview SQL before applying. * means global or all tables.",
+    database: "Database",
+    schema: "Schema",
+    table: "Table",
+    scope: "Grant scope",
+    scopeDatabase: "Database",
+    scopeSchema: "Schema",
+    scopeTable: "Table",
+    scopeRole: "Role membership",
+    memberRole: "Member role",
+    privileges: "Privileges",
+    grantOption: "Allow further grants (WITH GRANT OPTION)",
+    adminOption: "Allow membership management (WITH ADMIN OPTION)",
+    grant: "Grant",
+    revoke: "Revoke",
+    username: "Username",
+    host: "Host",
+    changePassword: "Change Password",
+    newPassword: "New password",
+    lock: "Lock",
+    unlock: "Unlock",
+    disableLogin: "Disable Login",
+    enableLogin: "Enable Login",
+    dropUser: "Drop User",
+    previewSql: "Preview SQL",
+    sqlPreview: "SQL Preview",
+    applySql: "Apply SQL",
+    applySuccess: "User privileges updated",
+    applyFailed: "Execution failed: {message}",
+  },
+  damengJobAdmin: {
+    title: "Dameng Agent Jobs",
+    unsupported: "This page only supports Dameng connections.",
+    initEnvironment: "Initialize Job Environment",
+    environmentReady: "Job Environment Ready",
+    newJob: "New Job",
+    searchJob: "Search jobs",
+    loadFailed: "Load failed",
+    environmentMissingTitle: "Job environment is not initialized",
+    environmentMissingHint: "This database does not have the SYSJOB job environment yet.",
+    environmentMissingDescription: "Dameng agent jobs require system tables and views under the SYSJOB schema. Initialize the job environment first; administrator privileges are usually required.",
+    emptyJobs: "No jobs found, or the current account cannot read the job list.",
+    emptyDetails: "No detail rows",
+    selectJob: "Select a job",
+    enabled: "Enabled",
+    disabled: "Disabled",
+    running: "Running",
+    enable: "Enable",
+    disable: "Disable",
+    runAsync: "Run Now",
+    stopRunning: "Stop Current Run",
+    stopRunningDisabled: "Only currently running jobs can be stopped",
+    clearHistories: "Clear History",
+    dropJob: "Drop",
+    steps: "Steps",
+    schedules: "Schedules",
+    histories: "History",
+    noDescription: "No description",
+    jobName: "Job name",
+    description: "Description",
+    stepName: "Step name",
+    scheduleName: "Schedule name",
+    sqlCommand: "SQL script",
+    scheduleMode: "Schedule type",
+    daily: "Daily",
+    once: "Once",
+    startDate: "Start date",
+    startTime: "Start time",
+    endTime: "End time",
+    minuteInterval: "Minute interval",
+    previewSql: "Preview SQL",
+    sqlPreview: "SQL Preview",
+    applySql: "Apply SQL",
+    applySuccess: "Job operation applied",
+    applyFailed: "Execution failed: {message}",
+  },
+  objects: {
+    all: "All",
+    tables: "Tables",
+    views: "Views",
+    procedures: "Procedures",
+    functions: "Functions",
+    sequences: "Sequences",
+    packages: "Packages",
+    table: "Table",
+    partitions: "{count} partitions",
+    view: "View",
+    procedure: "Procedure",
+    function: "Function",
+    sequence: "Sequence",
+    package: "Package",
+    packageBody: "Package Body",
+    name: "Name",
+    type: "Type",
+    rows: "Rows",
+    size: "Size",
+    statisticsHint: "Estimated from database statistics; no COUNT(*) is executed.",
+    createdAt: "Created",
+    updatedAt: "Updated",
+    source: "Source",
+    saveSource: "Save",
+    cancelEdit: "Cancel",
+    sourceSaved: "Source saved",
+    sourceSaveFailed: "Failed to save source: {message}",
+    sourceReadOnly: "This source is read-only and cannot be edited.",
+    schemaColumn: "Schema",
+    comment: "Comment",
+    loadingSchemas: "Loading schemas...",
+    schema: "Schema",
+    search: "Search tables, views, functions, sequences, or procedures...",
+    loading: "Loading objects...",
+    empty: "No objects found",
+    selectedTables: "{count} tables selected",
+    exportSelected: "Export selected",
+    dropSelected: "Drop selected",
+    truncateSelected: "Truncate selected",
+    clearSelection: "Clear selection",
+    confirmBatchDropTitle: "Drop Selected Tables",
+    confirmBatchDropMessage: "Are you sure you want to drop {count} selected tables? This cannot be undone.",
+    confirmBatchTruncateTitle: "Truncate Selected Tables",
+    confirmBatchTruncateMessage: "Are you sure you want to truncate {count} selected tables? This will remove all rows.",
+    batchDropSuccess: "Dropped {count} tables",
+    batchTruncateSuccess: "Truncated {count} tables",
+    copyTableSelected: "Copy",
+    pasteTableSelected: "Paste",
+    toggleCheckbox: "Toggle multi-select",
+    viewList: "List view",
+    viewGrid: "Grid view",
+    sortAsc: "Ascending",
+    sortDesc: "Descending",
+    sortBy: "Sort by",
+  },
+  structureEditor: {
+    title: "Edit Table Structure",
+    createTitle: "Create Table",
+    editTabTitle: "Edit: {tableName}",
+    tableName: "Table Name",
+    refresh: "Refresh Structure",
+    density: "Density",
+    densityCompact: "Compact",
+    densityStandard: "Standard",
+    densityComfortable: "Comfortable",
+    columns: "Columns",
+    indexes: "Indexes",
+    foreignKeys: "Foreign Keys",
+    triggers: "Triggers",
+    ddl: "DDL",
+    addColumn: "Add Column",
+    columnTemplates: "Insert Preset Fields",
+    configureColumnTemplates: "Configure Preset Fields",
+    presetFieldsTemplate: "Preset Field Set",
+    searchColumns: "Search column/comment",
+    nextColumnMatch: "Go to next matching column",
+    searchIndexes: "Search index",
+    nextIndexMatch: "Go to next matching index",
+    addIndex: "Add Index",
+    addForeignKey: "Add Foreign Key",
+    addTrigger: "Add Trigger",
+    columnName: "Column",
+    dataType: "Type",
+    typePlaceholder: "Select or type...",
+    noMatchingType: "No matching type",
+    mysqlDataTypeHelp: {
+      tinyint: "1-byte integer. Signed range: -128 to 127; unsigned range: 0 to 255.",
+      smallint: "2-byte integer. Signed range: -32,768 to 32,767; unsigned range: 0 to 65,535.",
+      mediumint: "3-byte integer. Signed range: -8,388,608 to 8,388,607; unsigned range: 0 to 16,777,215.",
+      int: "4-byte integer. Signed range: -2,147,483,648 to 2,147,483,647; unsigned range: 0 to 4,294,967,295.",
+      bigint: "8-byte integer. Signed range: -2^63 to 2^63-1; unsigned range: 0 to 2^64-1.",
+      decimal: "Exact fixed-point number. MySQL supports precision up to 65 digits and scale up to 30 digits; MariaDB version limits can differ. Use it for money and other exact values.",
+      float: "Single-precision approximate number. Use DECIMAL when exact decimal values are required.",
+      double: "Double-precision approximate number. Use DECIMAL when exact decimal values are required.",
+      real: "Alias for DOUBLE by default; REAL_AS_FLOAT SQL mode makes it an alias for FLOAT.",
+      bit: "Bit field of 1 to 64 bits. The default width is 1 bit.",
+      boolean: "Alias for TINYINT(1): 0 represents false and nonzero values represent true.",
+      serial: "Convenience alias for BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE.",
+      date: "Calendar date. Supported range: 1000-01-01 through 9999-12-31.",
+      datetime: "Date and time without time-zone conversion. Supported range: 1000-01-01 00:00:00 through 9999-12-31 23:59:59; fractional-seconds precision is 0 to 6 (default 0).",
+      timestamp: "Date and time converted between the session time zone and UTC. Supported range: 1970-01-01 00:00:01 UTC through 2038-01-19 03:14:07 UTC; fractional-seconds precision is 0 to 6 (default 0).",
+      time: "Time of day or elapsed time. Supported range: -838:59:59 through 838:59:59; fractional-seconds precision is 0 to 6 (default 0).",
+      year: "Year value. Four-digit values range from 1901 to 2155, plus 0000.",
+      char: "Fixed-length character string, up to 255 characters. Stored values are right-padded with spaces.",
+      varchar: "Variable-length character string. Its practical maximum is constrained by row size and character set.",
+      tinytext: "Variable-length text, up to 255 bytes. Character set, row-size, and max_allowed_packet limits can impose lower practical limits.",
+      text: "Variable-length text, up to 65,535 bytes. Character set, row-size, and max_allowed_packet limits can impose lower practical limits.",
+      mediumtext: "Variable-length text, up to 16,777,215 bytes. Character set, row-size, and max_allowed_packet limits can impose lower practical limits.",
+      longtext: "Variable-length text, up to 4,294,967,295 bytes (about 4 GiB). Character set, row-size, and max_allowed_packet limits can impose lower practical limits.",
+      binary: "Fixed-length binary byte string, up to 255 bytes. Stored values are padded with 0x00.",
+      varbinary: "Variable-length binary byte string. Its practical maximum is constrained by row size.",
+      tinyblob: "Binary large object, up to 255 bytes. Row-size and max_allowed_packet limits can impose lower practical limits.",
+      blob: "Binary large object, up to 65,535 bytes. Row-size and max_allowed_packet limits can impose lower practical limits.",
+      mediumblob: "Binary large object, up to 16,777,215 bytes. Row-size and max_allowed_packet limits can impose lower practical limits.",
+      longblob: "Binary large object, up to 4,294,967,295 bytes (about 4 GiB). Row-size and max_allowed_packet limits can impose lower practical limits.",
+      enum: "One value selected from up to 65,535 declared literals. Changing literal order can change stored value semantics.",
+      set: "Zero or more values selected from up to 64 declared members.",
+      json: "Validated JSON document. Storage representation and JSON feature support depend on the connected server product and version; document size is also limited by max_allowed_packet.",
+      jsonMysql: "MySQL's native binary JSON document type with JSON functions and validation. Document size is limited by max_allowed_packet.",
+      jsonMariaDb: "MariaDB JSON is an alias for LONGTEXT with a JSON_VALID constraint and utf8mb4_bin collation; document size is limited by max_allowed_packet.",
+      nationalCharacter: "National character string alias. In MySQL it uses the predefined national character set (utf8mb3, deprecated); explicitly choose utf8mb4 for new schemas.",
+      geometry: "Spatial value of any supported geometry type. A MySQL InnoDB SPATIAL index requires a NOT NULL column with an SRID attribute.",
+      point: "Spatial point with one coordinate pair. A MySQL InnoDB SPATIAL index requires a NOT NULL column with an SRID attribute.",
+      linestring: "Spatial curve composed of one or more connected points. A MySQL InnoDB SPATIAL index requires a NOT NULL column with an SRID attribute.",
+      polygon: "Spatial surface enclosed by one or more rings. A MySQL InnoDB SPATIAL index requires a NOT NULL column with an SRID attribute.",
+      multipoint: "Collection of spatial points. A MySQL InnoDB SPATIAL index requires a NOT NULL column with an SRID attribute.",
+      multilinestring: "Collection of spatial curves. A MySQL InnoDB SPATIAL index requires a NOT NULL column with an SRID attribute.",
+      multipolygon: "Collection of spatial polygons. A MySQL InnoDB SPATIAL index requires a NOT NULL column with an SRID attribute.",
+      geometrycollection: "Collection that can contain mixed spatial geometry types. A MySQL InnoDB SPATIAL index requires a NOT NULL column with an SRID attribute.",
+      inet4: "MariaDB IPv4 address type (available from MariaDB 10.10); it stores an IPv4 address in four bytes.",
+      inet6: "MariaDB-compatible address type for IPv6 and mapped IPv4 values.",
+      uuid: "128-bit universally unique identifier type supplied by compatible servers.",
+      vector: "Vector data type for similarity or machine-learning workloads; availability and dimensions depend on the server version.",
+      xmltype: "XML data type supplied by compatible servers.",
+      integerDisplayWidth: "MySQL integer display width (for example INT(11)) is deprecated and does not limit the stored range. Do not add it to new MySQL 8 schemas.",
+      zerofill: "ZEROFILL is deprecated in MySQL 8. It also implicitly makes the column UNSIGNED; use explicit formatting in the application instead.",
+      unsignedNumeric: "UNSIGNED for DECIMAL, FLOAT, or DOUBLE is deprecated in MySQL 8. Use a CHECK constraint when a nonnegative domain is required.",
+      floatPrecision: "For FLOAT(p), p from 25 through 53 selects DOUBLE precision rather than FLOAT. Use DOUBLE explicitly when that is intended.",
+      floatingPointDisplay: "FLOAT(M,D) and DOUBLE(M,D) are deprecated in MySQL 8. Use FLOAT/DOUBLE without display parameters, or DECIMAL(M,D) for exact values.",
+    },
+    postgresDataTypeHelp: {
+      smallint: "2-byte signed integer, from -32,768 to 32,767.",
+      integer: "4-byte signed integer, from -2,147,483,648 to 2,147,483,647.",
+      bigint: "8-byte signed integer, from -2^63 to 2^63-1.",
+      serial: "Convenience syntax that creates an integer column, sequence, NOT NULL, and nextval default. It is not unique by itself and sequence values can have gaps; prefer IDENTITY for new schemas.",
+      numeric: "Exact decimal number with user-selected precision and scale. Use it for money and other values that must not use binary floating-point rounding.",
+      real: "4-byte single-precision floating-point number. FLOAT(p) with p from 1 through 24 selects this type.",
+      double: "8-byte double-precision floating-point number. FLOAT without precision is its alias; FLOAT(p) with p from 25 through 53 selects it.",
+      money: "Locale-formatted currency amount. Its output and parsing depend on lc_monetary; NUMERIC is usually safer for portable financial data.",
+      boolean: "Logical true, false, or null value. BOOL is an alias for BOOLEAN.",
+      char: "Fixed-length blank-padded character string. CHARACTER is an alias; avoid it when trailing spaces are significant.",
+      varchar: "Variable-length character string with an optional character limit. CHARACTER VARYING is an alias.",
+      text: "Variable-length character string without a declared limit; it has the same storage behavior as VARCHAR without a limit.",
+      bytea: "Variable-length binary string. Large values can be stored out of line by TOAST.",
+      date: "Calendar date without a time of day or time zone.",
+      time: "Time of day without a time zone, with optional fractional seconds precision.",
+      timetz: "Time of day plus a UTC offset. It has limited usefulness and is generally discouraged; use timestamptz for an instant in time.",
+      timestamp: "Date and time without time-zone conversion. Use it for local wall-clock values whose time zone is not part of the data.",
+      timestamptz: "Instant in time stored internally in UTC and displayed in the session time zone. It does not retain the original named time zone.",
+      interval: "Duration expressed in months, days, and microseconds. Calendar units are not fixed-length durations.",
+      uuid: "128-bit universally unique identifier.",
+      json: "JSON text preserved in the original input representation. Parsing is validated, but processing is generally slower than JSONB.",
+      jsonb: "Decomposed binary JSON representation optimized for processing and indexing. It does not preserve insignificant whitespace, key order, or duplicate keys.",
+      xml: "XML value with optional document or content validation depending on the XML option used.",
+      bit: "Fixed- or variable-length bit string. BIT VARYING and VARBIT are variable-length aliases.",
+      tsvector: "Normalized lexemes used as the searchable document side of PostgreSQL full-text search; commonly indexed with GIN or GiST.",
+      tsquery: "Boolean full-text search query evaluated against a tsvector.",
+      cidr: "IPv4 or IPv6 network with host bits constrained to zero.",
+      inet: "IPv4 or IPv6 host address, optionally with a network mask; unlike CIDR, host bits may be nonzero.",
+      macaddr: "MAC address. MACADDR stores 6-byte addresses and MACADDR8 stores 8-byte addresses.",
+      geometry: "Built-in two-dimensional geometric type. PostgreSQL geometry is planar and has no SRID; use PostGIS for geographic coordinates, projections, or advanced spatial operations.",
+      range: "Single continuous range with inclusive/exclusive bounds. Range values require a compatible subtype; use multirange types for multiple disjoint ranges.",
+      oid: "Unsigned object identifier. It is a system identifier, not a durable application primary key; use an ordinary integer or UUID for application data.",
+      array: "PostgreSQL array of any element type, including multi-dimensional arrays. Array dimensions are not enforced by the declared type and arrays are often less flexible than normalized child rows.",
+      multirange: "Set of non-overlapping ranges of the matching range subtype. PostgreSQL normalizes adjacent or overlapping members according to the subtype rules.",
+      jsonpath: "SQL/JSON path expression used by JSONB query and predicate functions.",
+      pgLsn: "Write-ahead log location used for replication and recovery coordinates; it is not an application sequence number.",
+      pgSnapshot: "Transaction visibility snapshot. Its text representation is intended for database snapshot operations, not general application data.",
+    },
+    sqliteDataTypeHelp: {
+      integer: "SQLite uses dynamic typing and INTEGER affinity; an ordinary column does not enforce the INTEGER storage class. Values are stored as signed integers when possible; INTEGER PRIMARY KEY (exact spelling) is the special alias for the rowid.",
+      real: "REAL affinity stores IEEE 754 floating-point values. It is appropriate for approximate measurements, not exact money or decimal calculations.",
+      text: "TEXT affinity stores text in the database encoding. VARCHAR(n) and CHAR(n) do not enforce n in SQLite; add a CHECK constraint when a length limit matters.",
+      blob: "BLOB affinity stores bytes exactly as supplied, without type conversion.",
+      numeric: "NUMERIC affinity attempts to convert well-formed numeric text to INTEGER first, then REAL; it is not a separate SQLite storage class. DATE, DATETIME, and TIME declarations also have NUMERIC affinity; store ISO-8601 TEXT, Julian-day REAL, or Unix-time INTEGER consistently.",
+    },
+    length: "Length",
+    enumValues: "Enum values",
+    enumValueCount: "{count} values",
+    addEnumValue: "Add value",
+    removeEnumValue: "Remove enum value",
+    enumValuePlaceholder: "Value (empty is allowed)",
+    nullable: "Nullable",
+    primaryKey: "Primary Key",
+    defaultValue: "Default",
+    defaultValuePresets: "Default value presets",
+    comment: "Comment",
+    characterSet: "Charset",
+    charsetPlaceholder: "Charset",
+    collation: "Collation",
+    collationPlaceholder: "Collation",
+    editComment: "Edit comment",
+    commentPlaceholder: "Enter column comment...",
+    tableCommentPlaceholder: "Enter table comment...",
+    tableCommentUnsupported: "Table comments are not supported by this database",
+    actions: "Actions",
+    indexName: "Index",
+    indexColumns: "Columns",
+    indexColumnsPlaceholder: "Select columns...",
+    unique: "Unique",
+    indexType: "Type",
+    includedColumns: "Included",
+    includedColumnsPlaceholder: "Select columns...",
+    filter: "Filter",
+    foreignKeyName: "Foreign key",
+    referencedSchema: "Ref schema",
+    referencedTable: "Ref table",
+    referencedColumn: "Ref column",
+    onDelete: "On delete",
+    onUpdate: "On update",
+    defaultAction: "Default",
+    triggerName: "Trigger",
+    triggerStatement: "Trigger statement",
+    primary: "Primary",
+    drop: "Drop",
+    restore: "Restore",
+    remove: "Remove",
+    moveColumnUp: "Move column up",
+    moveColumnDown: "Move column down",
+    dragColumn: "Drag to reorder column",
+    localColumnOrderNotice: "Column order is saved locally and does not change the database table structure.",
+    yes: "Yes",
+    no: "No",
+    emptyReadonly: "No records",
+    sqlPreview: "SQL Preview",
+    collapseSqlPreview: "Collapse SQL Preview",
+    expandSqlPreview: "Expand SQL Preview",
+    noChanges: "No changes",
+    apply: "Apply Changes",
+    ready: "Ready",
+    saved: "Table structure updated",
+    copySql: "Copy SQL",
+    sqliteRebuildNotice: "SQLite retains an inert data snapshot as a backup, then rebuilds the table in one transaction and forcibly CASTs changed columns. Unrepresentable values may become 0/0.0; failures roll back.",
+    extendedProperties: "Extended",
+    autoIncrement: "Auto Increment",
+    onUpdateCurrentTimestamp: "Auto Update Time",
+    identity: "Identity",
+    identityGeneration: "Generation",
+    identitySeed: "Seed",
+    identityIncrement: "Increment",
+    sqlServerIdentityTypeHint: "SQL Server identity only supports tinyint, smallint, int, bigint, and decimal/numeric with scale 0",
+  },
+  diagram: {
+    title: "Relationship Diagram",
+    open: "View Diagram",
+    selectConnection: "Select connection",
+    selectDatabase: "Select database",
+    selectSchema: "Select schema",
+    searchTables: "Search tables, columns, keys...",
+    refresh: "Refresh diagram",
+    loading: "Reading relationships...",
+    loadingProgress: "Reading relationships... {loaded}/{total}",
+    partialError: "Skipped metadata for {count} tables that failed to load",
+    selectTarget: "Select a connection and database",
+    empty: "No tables to display",
+    noMatches: "No matching tables",
+    tablesCount: "{count} tables",
+    relationshipsCount: "{count} relationships",
+    tableMode: "Table View",
+    engineeringMode: "Engineering ER",
+    modelRelationships: "Model Relationships",
+    copyJoinSql: "Copy SQL",
+    customRelationshipsCount: "{count} modeled",
+    relationshipName: "Name",
+    relationshipNamePlaceholder: "Optional",
+    sourceTable: "Source table",
+    sourceColumn: "Source column",
+    targetTable: "Target table",
+    targetColumn: "Target column",
+    cardinality: "Cardinality",
+    cardinalityOneToMany: "1:N",
+    cardinalityManyToOne: "N:1",
+    cardinalityOneToOne: "1:1",
+    addRelationship: "Add relationship",
+    removeRelationship: "Remove relationship",
+    relationshipIncomplete: "Select both source and target columns",
+    relationshipSelfInvalid: "A relationship cannot target the same column",
+    relationshipExists: "This relationship already exists",
+    relationshipAdded: "Relationship added",
+    noJoinSql: "No relationship SQL to copy",
+    allTables: "All Tables",
+    relatedTables: "Related Tables",
+    moreColumns: "+ {count} columns",
+    exportSvg: "Export SVG",
+    exportedSvg: "SVG exported",
+    exportSvgFailed: "Failed to export SVG: {message}",
+    zoomIn: "Zoom in",
+    zoomOut: "Zoom out",
+    resetLayout: "Reset layout",
+  },
+  etcd: {
+    prefixPlaceholder: "Prefix, e.g. /app/",
+    newKey: "New Key",
+    loadingKeys: "Loading keys...",
+    empty: "No keys found",
+    loadMore: "Load more",
+    selectKey: "Select a key to view its value",
+    loadingValue: "Loading value...",
+    notFound: "Key not found",
+    edit: "Edit",
+    editKey: "Edit Key",
+    delete: "Delete",
+    deleteTitle: "Delete etcd key",
+    keyPlaceholder: "/path/to/key",
+    keyRequired: "Key is required",
+    saved: "Key saved",
+    deleted: "Key deleted",
+    base64Readonly: "Base64 values are read-only in this version.",
+  },
+  zookeeper: {
+    prefixPlaceholder: "Path prefix, e.g. /app/",
+    newKey: "New Znode",
+    loadingKeys: "Loading znodes...",
+    empty: "No znodes found",
+    loadMore: "Load more",
+    selectKey: "Select a znode to view its value",
+    loadingValue: "Loading value...",
+    notFound: "Znode not found",
+    edit: "Edit",
+    editKey: "Edit Znode",
+    delete: "Delete",
+    deleteTitle: "Delete ZooKeeper znode",
+    keyPlaceholder: "/path/to/znode",
+    keyRequired: "Znode path is required",
+    rootReadonly: "Root znode cannot be modified. Enter a child znode path.",
+    saved: "Znode saved",
+    deleted: "Znode deleted",
+    base64Readonly: "Base64 values are read-only in this version.",
+    createMode: "Create Mode",
+    createModePersistent: "Persistent",
+    createModeEphemeral: "Ephemeral",
+    createModePersistentSequential: "Persistent Sequential",
+    createModeEphemeralSequential: "Ephemeral Sequential",
+    add: "Add",
+    value: "Value",
+    metadata: "Node Info",
+    prettyJson: "Pretty",
+    invalidJson: "Invalid JSON",
+    summaryRevision: "rev",
+    summaryVersion: "ver",
+    summaryLease: "lease",
+    summarySize: "size",
+  },
+  redis: {
+    selectKey: "Select a key to view its value",
+    noKeys: "No keys found",
+    noKeysInScanHint: "No keys found in current scan range",
+    pattern: "pattern (e.g. user:*)",
+    fuzzyPattern: "key contains...",
+    fuzzyMatch: "Fuzzy",
+    fuzzyMatchTitle: "Fuzzy match: search keys by plain text contains",
+    valueSearchPlaceholder: "value contains...",
+    allSearchPlaceholder: "key or value contains...",
+    searchByKey: "Key",
+    searchByValue: "Value",
+    searchByAll: "All",
+    searchFields: "Search fields and values",
+    keys: "{count} keys",
+    loadedKeys: "{loaded} / {total} keys loaded",
+    loadingKeys: "Loading keys...",
+    searchingValues: "Searching values...",
+    searchingAll: "Searching keys and values...",
+    loadMoreKeys: "Load more keys",
+    fetchAllKeys: "Fetch all",
+    stopFetchAll: "Stop",
+    fetchAllProgress: "{loaded} of {total} keys loaded",
+    fetchAllProgressUnknown: "{loaded} keys loaded",
+    items: "{count} items",
+    fields: "{count} fields",
+    members: "{count} members",
+    loadedItems: "{loaded} of {total} items loaded",
+    loadedFields: "{loaded} of {total} fields loaded",
+    loadedMembers: "{loaded} of {total} members loaded",
+    entries: "{count} entries",
+    noExpiry: "no expiry",
+    autoRefresh: "Auto-refresh countdown",
+    ttlDay: "{count}d",
+    columnType: "Type",
+    columnKey: "Key",
+    columnValue: "Value",
+    columnSize: "Size",
+    columnTTL: "TTL",
+    binaryStringReadonlyHint: "Binary string values are shown as escaped text in read-only mode; editing raw bytes is not supported.",
+    selectedKeys: "Selected keys",
+    deleteGroup: "Delete group",
+    deleteGroupDetails: "{target}\n{count} keys",
+    flushDb: "Clear current DB",
+    flushDbMessage: "This will delete every key in the current Redis database and cannot be undone. Continue?",
+    flushDbDetails: "Target: Redis db{db}\nScope: all keys in the current DB",
+    flushDbConfirm: "Clear DB",
+    flushDbSuccess: "Redis db{db} cleared",
+    keyDetail: "Key detail",
+    commandLine: "Command line",
+    selectKeyForDetail: "Select a key to view details",
+    commandWelcome: "Welcome to the Redis command console",
+    commandPlaceholder: "Redis command, e.g. GET user:1",
+    commandPrefix: "CMD",
+    commandHint: "Enter a Redis command, e.g. SMEMBERS feature:flags",
+    executeCommand: "Execute command",
+    commandEmpty: "Enter a Redis command",
+    commandEmptyResult: "Run a Redis command to see the result",
+    commandBlocked: "This Redis command is blocked for safety",
+    createKey: "Create key",
+    createKeyName: "Key",
+    createKeyNamePlaceholder: "user:1",
+    createKeyType: "Type",
+    createKeyTypeHelp: {
+      string: "Single binary-safe value up to 512 MB. Best for cached values, counters, flags, and simple serialized data.",
+      hash: "Flat field-value map. Efficient for individual fields, but reading a large hash in full is O(N).",
+      list: "Ordered sequence. Head and tail operations are efficient; random access in the middle is linear in the list length.",
+      set: "Unordered collection of unique members. Single-member operations are O(1), while enumerating or combining large sets is linear.",
+      zset: "Unique members ordered by floating-point scores. Writes are O(log N); members with equal scores are ordered lexicographically.",
+      stream: "Append-only event log. Consumer groups need XACK and pending-entry handling; trim the stream to control retention and memory.",
+      json: "Path-addressable JSON document. Requires RedisJSON/Redis Stack JSON.* support and usually has more overhead than String or Hash.",
+    },
+    createValue: "Value",
+    createMember: "Member",
+    createField: "Field",
+    createFieldPlaceholder: "name",
+    createScore: "Score",
+    createKeyTtl: "TTL (seconds)",
+    createKeyTtlPlaceholder: "empty = no expiry",
+    createKeyAddEntry: "Add entry",
+    createKeyEntryId: "Entry ID",
+    createKeyRawMode: "Raw input",
+    createKeyEntries: "Entries",
+    createValuePlaceholder: "value",
+    createKeySubmit: "Create",
+    createKeyNameRequired: "Enter a key name",
+    createFieldRequired: "Enter a hash field",
+    createScoreInvalid: "Enter a valid score",
+    jsonModuleNotAvailable: "ReJSON module is not loaded on this Redis server",
+    fieldRequired: "Enter a field name",
+    valueRequired: "Enter a value",
+    memberRequired: "Enter a member",
+    ttlInvalid: "Enter a valid TTL in seconds (-1 for no expiry)",
+    member: "Member",
+    memberDetail: "Member detail",
+    viewMember: "View full value",
+    copyMember: "Copy member",
+    copyKeyName: "Copy key name",
+    copied: "Copied",
+    copyInsertStatement: "Copy Insert Statement",
+    copyInsertStatementBinary: "Cannot generate insert statement for binary data",
+    editMember: "Edit",
+    jsonView: "JSON view",
+    rawContent: "Raw content",
+    wordWrap: "Word wrap",
+    formatJson: "Format",
+    compressJson: "Compress",
+    jsonFormatError: "Invalid JSON format",
+    clearHistory: "Clear command history",
+    historyCleared: "Redis command history cleared",
+    blockedCommand: "Command {command} is blocked for safety. Disable the shield icon in the toolbar to allow.",
+    pubsub: "Pub/Sub",
+    pubsubConnected: "Connected",
+    pubsubConnecting: "Connecting...",
+    pubsubDisconnected: "Disconnected",
+    pubsubConnect: "Connect",
+    pubsubDisconnect: "Disconnect",
+    pubsubChannels: "Channels",
+    pubsubChannelPlaceholder: "Channel name",
+    pubsubSubscribe: "Subscribe",
+    pubsubPatterns: "Patterns",
+    pubsubPatternPlaceholder: "Pattern (e.g. news:*)",
+    pubsubPsubscribe: "PSubscribe",
+    pubsubMessages: "Messages",
+    pubsubClear: "Clear",
+    pubsubEmpty: "No messages yet. Subscribe to a channel to receive messages.",
+    pubsubPublish: "Publish",
+    pubsubPublishChannel: "Channel",
+    pubsubPublishMessage: "Message",
+    pubsubSend: "Send",
+    pubsubPublishFailed: "Publish failed: {error}",
+    pubsubWsConnectFailed: "WebSocket connection failed: {error}",
+    slowlog: "Slow Log",
+    slowlogCount: "Count",
+    slowlogQuery: "Query",
+    slowlogNode: "Node",
+    slowlogSelectNode: "Select a node",
+    slowlogNodeRequired: "Please select a node first",
+    slowlogEmpty: "Click Query to fetch slow log entries",
+    slowlogFetchFailed: "Failed to fetch slow log: {error}",
+    slowlogColumnId: "ID",
+    slowlogColumnTimestamp: "Timestamp",
+    slowlogColumnDuration: "Duration (μs)",
+    slowlogColumnCommand: "Command",
+    slowlogColumnClientAddr: "Client",
+    slowlogColumnClientName: "Client Name",
+    slowlogTotal: "{count} entries",
+    slowlogDetailTitle: "Slow Log Entry #{id}",
+  },
+  mongo: {
+    documents: "{count} documents",
+    addField: "Add Field",
+    deleteField: "Delete Field",
+    field: "Field",
+    value: "Value",
+    fieldPlaceholder: "Field name",
+    emptyCollection: "Empty collection",
+    selectDocument: "Select a document",
+    readonlyId: "_id is read-only",
+    invalidJsonValue: "This cell is not a valid JSON value",
+    duplicateField: "Duplicate field name: {field}",
+    edit: "Edit",
+    documentView: "Document View",
+    tableView: "Table View",
+    filterPlaceholder: "Filter...",
+    sortPlaceholder: "Sort...",
+  },
+  vector: {
+    collectionFallback: "collection",
+    productCollection: "{product} collection",
+    browse: "Browse",
+    search: "Search",
+    upsert: "Upsert",
+    delete: "Delete",
+    reset: "Reset",
+    refresh: "Refresh",
+    run: "Run",
+    apply: "Apply",
+    requestEditor: "Vector request editor",
+    operationSuccess: "Operation completed. The collection preview has been refreshed.",
+    vectorLabel: "Vector",
+  },
+  history: {
+    title: "History",
+    search: "Search history...",
+    empty: "No history yet",
+    emptyFilteredRecent: "No matching records in the latest 200 execution history entries",
+    failed: "Failed",
+    success: "Succeeded",
+    restore: "Restore to editor",
+    copy: "Copy SQL",
+    delete: "Delete",
+    clear: "Clear History",
+    viewDetails: "View details",
+    analyzeWithAi: "Analyze with AI",
+    aiAnalyzeNoConnection: "Cannot analyze this history entry because its connection no longer exists.",
+    aiAnalysisTab: "History Analysis",
+    rollback: "Rollback",
+    rollbackSql: "Rollback SQL",
+    rollbackAvailable: "Available",
+    rollbackUnavailable: "No rollback SQL",
+    rollbackConfirm: "Execute the rollback SQL generated for this history entry?",
+    rollbackSuccess: "Rollback executed",
+    rollbackFailed: "Rollback failed: {message}",
+    confirmDelete: "Delete this history entry?",
+    confirmClear: "Clear all history?",
+    filters: {
+      all: "All",
+      query: "Queries",
+      data_change: "Data changes",
+      schema_change: "Schema changes",
+      failed: "Failed",
+    },
+    dateRange: {
+      title: "Time range",
+      label: "Execution time:",
+      start: "Start date",
+      end: "End date",
+      apply: "Apply",
+      clear: "Clear",
+      invalid: "Start date cannot be later than end date",
+      unboundedStart: "Start",
+      unboundedEnd: "End",
+    },
+    kinds: {
+      query: "Query",
+      data_change: "Data change",
+      schema_change: "Schema change",
+      import: "Import",
+      transfer: "Transfer",
+      redis_command: "Redis Command",
+    },
+    kindShort: {
+      query: "SQL",
+      data_change: "Data",
+      schema_change: "DDL",
+      import: "Import",
+      transfer: "Move",
+      redis_command: "Redis",
+    },
+    detail: {
+      kind: "Type",
+      operation: "Operation",
+      connection: "Connection",
+      database: "Database",
+      target: "Target",
+      time: "Time",
+      duration: "Duration",
+      affectedRows: "Affected rows",
+      rollback: "Rollback",
+      status: "Status",
+      error: "Error",
+    },
+  },
+  dangerDialog: {
+    title: "Dangerous Operation",
+    message: "This SQL statement may modify or delete data irreversibly. Are you sure you want to execute it?",
+    redisCommandMessage: "This Redis command may modify data and cannot be undone automatically. Continue?",
+    suppressFuturePrompts: "Do not ask again for dangerous SQL",
+    wrapLines: "Toggle word wrap",
+    deleteMessage: "This delete operation may be irreversible. Continue?",
+    deleteConfirm: "Confirm Delete",
+    deleteRowMessage: "This row will be marked for deletion and removed from the database after saving. Continue?",
+    deleteRowsMessage: "These {count} rows will be marked for deletion and removed from the database after saving. Continue?",
+    deleteRowDetails: "Table: {table}",
+    deleteRowDetailsNoTable: "Current result row",
+    redisKeyDetails: "Redis key: {key}",
+    redisHashFieldDetails: "Redis hash: {key}\nField: {field}",
+    redisListItemDetails: "Redis list: {key}\nIndex: {index}",
+    redisSetMemberDetails: "Redis set: {key}\nMember: {member}",
+    mongoDocumentDetails: "MongoDB collection: {collection}\nDocument _id: {id}",
+    mongoFieldDetails: "Field: {field}",
+    mongoArrayItemDetails: "Array item index: {index}",
+    cancel: "Cancel",
+    confirm: "Execute",
+  },
+  production: {
+    title: "Production environment",
+    connection: "Production connection",
+    enable: "Enable production safeguards",
+    disabledDescription: "Enable this to protect every database or selected databases.",
+    scope: "Protection scope",
+    allDatabases: "All databases",
+    selectedDatabases: "Selected databases",
+    singleDatabaseScopeHint: "This database type supports connection-level production safeguards only.",
+    databases: "Production databases",
+    connectionDescription: "Every database on this connection uses production safeguards.",
+    databaseDescription: "Choose the databases that need production safeguards. The first selection includes all databases.",
+    selectDatabases: "Select production databases",
+    noDatabasesSelected: "No databases selected",
+    databasesConfiguredCount: "{count} selected",
+    databasesSelectedCount: "{selected}/{total} selected",
+    databasePickerTitle: "Select production databases",
+    databasePickerDescription: 'Choose the databases on "{connection}" that need production safeguards.',
+    databaseSearchPlaceholder: "Search databases...",
+    databaseSelectionRequired: "Select at least one database.",
+    databaseLoadFailed: "Could not load databases: {message}",
+    noDatabasesAvailable: "No databases are available to select.",
+    retry: "Retry",
+    confirmTitle: "Confirm production write",
+    confirmMessage: "This operation changes a production database and requires explicit confirmation.",
+    confirmDetails: "Connection: {connection}\nDatabase: {database}\nSource: {source}",
+    confirmAction: "Execute in production",
+    sourceSqlEditor: "SQL editor",
+    sourceDataGrid: "Data editor",
+    sourceStructure: "Structure editor",
+    sourceSqlFile: "SQL file execution",
+    sourceObjectBrowser: "Object browser",
+    sourceSchemaDiff: "Schema diff",
+    sourceDataCompare: "Data compare",
+    sourceExtension: "Extension manager",
+    sourceSidebar: "Object tree",
+    sourceObjectSource: "Object source editor",
+    sourceDataGenerate: "Data generator",
+    sourceQueryHistory: "Query history rollback",
+    sourceAdmin: "Database administration",
+    aiReviewRequired: "Production SQL was added to the editor. Review it and run it manually to confirm.",
+  },
+  sqlParameters: {
+    title: "SQL Parameters",
+    description: "Fill values for SQL template placeholders. DBX replaces them before executing the SQL.",
+    name: "Parameter",
+    syntax: "Syntax",
+    type: "Type",
+    value: "Value",
+    valuePlaceholder: "Enter value",
+    preview: "SQL Preview",
+    execute: "Execute",
+    kind: {
+      string: "String",
+      number: "Number",
+      boolean: "Boolean",
+      null: "NULL",
+      raw: "Raw SQL",
+    },
+  },
+  transfer: {
+    title: "Data Transfer",
+    source: "Source",
+    target: "Target",
+    sourceConnection: "Source Connection",
+    sourceDatabase: "Source Database",
+    sourceSchema: "Source Schema",
+    targetConnection: "Target Connection",
+    targetDatabase: "Target Database",
+    targetSchema: "Target Schema",
+    tables: "Tables",
+    selectAll: "Select All",
+    deselectAll: "Deselect All",
+    createTable: "Create table if not exists",
+    transferMode: "Transfer mode",
+    modeAppend: "Append (INSERT)",
+    modeOverwrite: "Overwrite (TRUNCATE + INSERT)",
+    modeUpsert: "Upsert (INSERT or UPDATE by PK)",
+    targetTableNameCase: "Target table name case",
+    tableNameCasePreserve: "Preserve",
+    tableNameCaseLower: "Lowercase",
+    tableNameCaseUpper: "Uppercase",
+    batchSize: "Batch size",
+    start: "Start Transfer",
+    cancel: "Cancel",
+    progress: "Transferring...",
+    transferring: "Transferring {table}...",
+    completed: "Transfer completed",
+    completedWithErrors: "Completed with {count} failed table | Completed with {count} failed tables",
+    failed: "Transfer failed",
+    cancelled: "Transfer cancelled",
+    rowsTransferred: "{count} rows transferred",
+    tableProgress: "{current} / {total} tables",
+    noSqlConnections: "No SQL connections available",
+    selectTables: "Select tables to transfer",
+    searchTables: "Search tables...",
+    noTables: "No tables",
+    selectSourceFirst: "Select source connection and database first",
+    tableError: "Table {table} failed: {error}",
+    overallProgress: "Overall progress",
+    dataTransfer: "Data Transfer",
+    runInBackground: "Run in background",
+    newTask: "New transfer",
+    editConfig: "Edit config",
+    retry: "Retry",
+    targetTableBusy: "Another transfer is already writing target table(s): {tables}",
+    ownershipTitle: "Confirm ownership",
+    ownershipMessage: "The target database is missing these owner users or roles: {owners}. Applying the original ownership may fail.",
+    ownershipSkipDetails: "Skip will not run object ownership change statements. Table data and other structure synchronization will continue.",
+    ownershipTargetOwner: "Confirm will reassign objects with missing owners to the target connection user: {owner}.",
+    ownershipSkip: "Skip",
+    ownershipConfirm: "Confirm",
+    selectConnection: "Select connection",
+    selectDatabase: "Select database",
+    selectSchema: "Select schema",
+    searchConnection: "Search connections...",
+    searchDatabase: "Search databases...",
+    searchSchema: "Search schemas...",
+  },
+  tableImport: {
+    title: "Import Table Data",
+    target: "Target table",
+    selectFile: "Select File",
+    changeFile: "Change File",
+    noFileSelected: "No file selected",
+    sourceFile: "Source file",
+    sourceFormat: "Source format",
+    targetMode: "Target",
+    existingTable: "Existing table",
+    createTable: "Create table",
+    createTableHint: "Infer columns from the file",
+    targetTableName: "Table name",
+    noExistingTarget: "No table selected",
+    stepSource: "Source",
+    stepOptions: "Options",
+    stepMapping: "Mapping",
+    stepReview: "Review",
+    stepExecution: "Run",
+    formatCsv: "CSV",
+    formatCsvDescription: "Comma-separated text",
+    formatTsv: "TSV",
+    formatTsvDescription: "Tab-separated text",
+    formatDelimited: "Delimited",
+    formatDelimitedDescription: "Custom text delimiter",
+    formatJson: "JSON",
+    formatJsonDescription: "Object or array rows",
+    formatExcel: "Excel",
+    formatExcelDescription: "XLS, XLSX, XLSM",
+    previewRows: "Preview rows",
+    delimiter: "Delimiter",
+    hasHeader: "First row is header",
+    titleRow: "Title row (0 for none)",
+    dataStartRow: "Data start row",
+    lastDataRow: "Last data row (0 for end)",
+    trimValues: "Trim values",
+    emptyStringAsNull: "Empty string as NULL",
+    jsonShape: "JSON rows",
+    jsonShapeAuto: "Auto-detect",
+    jsonShapeObjects: "Objects",
+    jsonShapeArrays: "Arrays",
+    sheet: "Sheet",
+    firstSheet: "First sheet",
+    loadPreview: "Load Preview",
+    reloadPreview: "Reload Preview",
+    previewReady: "{rows} rows, {columns} columns",
+    file: "File",
+    rows: "Rows",
+    mapped: "Mapped",
+    mapping: "Column Mapping",
+    sourceColumn: "Source",
+    targetColumn: "Target",
+    targetDataType: "Type",
+    createColumns: "Columns to create",
+    skipColumn: "Skip",
+    preview: "Preview",
+    mode: "Import mode",
+    append: "Append data",
+    truncate: "Truncate then import",
+    progress: "Progress",
+    start: "Start Import",
+    success: "Imported {count} rows",
+    back: "Back",
+    next: "Next",
+    truncateWarning: "Existing rows in the target table will be removed before import starts.",
+    requiredUnmapped: "Required target columns are not mapped: {columns}",
+    status_idle: "Ready to import",
+    status_running: "Importing data",
+    status_done: "Import complete",
+    status_error: "Import failed",
+    status_cancelled: "Import cancelled",
+  },
+  dataGenerate: {
+    title: "Data Generation",
+    target: "Target",
+    rowCount: "Rows to generate",
+    columns: "Columns",
+    column: "Column",
+    type: "Type",
+    generator: "Generator",
+    columnProps: "Column Properties",
+    databaseObjects: "Database Objects",
+    selectTable: "Select a table from the left",
+    saveProfile: "Save Profile",
+    loadProfile: "Load Profile",
+    options: "Options",
+    generateOrder: "Generate Order",
+    nextStep: "Next",
+    insertSuccess: "Inserted {count} rows",
+    noData: "No data yet, please configure generation rules first",
+    noResult: "No execution results",
+    regenerate: "Regenerate",
+    first50Rows: "Showing first 50 rows, total {count} rows",
+    resultTitle: "Execution Results",
+    successLabel: "{count} succeeded",
+    failLabel: "{count} failed",
+    totalLabel: "/ {count} entries",
+    copyAllSql: "Copy All SQL",
+    prevStep: "Previous",
+    startInsert: "Start Insert",
+    confirm: "Confirm",
+    back: "Back",
+    reset: "Reset",
+    selectGenerator: "Select a generator...",
+    selectGeneratorHint: "Please select a generator",
+    preview: "Preview",
+    noValue: "(none)",
+    startDate: "Start Date",
+    endDate: "End Date",
+    allDay: "All day",
+    startTime: "Start Time",
+    endTime: "End Time",
+    weekday: "Weekday",
+    all: "All",
+    weekdayOnly: "Weekdays",
+    custom: "Custom",
+    values: "Values",
+    min: "Min",
+    max: "Max",
+    increment: "Increment",
+    cycle: "Cycle when exceeded",
+    includeDefault: "Include DEFAULT",
+    includeNull: "Include NULL",
+    unique: "Set unique",
+    disableLinks: "Disable data links between columns",
+    imageMode: "Mode",
+    generate: "Generate",
+    fromFolder: "From folder",
+    imageWidth: "Image Width",
+    imageHeight: "Image Height",
+    imageFormat: "Image Format",
+    folderPath: "Folder Path",
+    filterByExtension: "Filter by extensions",
+    errorContinue: "Continue on error",
+    truncateBefore: "Truncate table before generation",
+    useTransaction: "Use transaction",
+    extendedInsert: "Use extended INSERT",
+    ok: "OK",
+    noTablesSelected: "No tables selected",
+    orderHint: "Use arrow buttons to reorder",
+    gen: {
+      general: "General",
+      personal: "Personal",
+      payment: "Payment",
+      business: "Business",
+      location: "Location",
+      product: "Product",
+      computer: "Computer",
+      number: "Number",
+      datetime: "Date Time",
+      date: "Date",
+      time: "Time",
+      sequence: "Sequence",
+      enum: "Enum",
+      text: "Text",
+      image: "Image or Binary",
+      foreign_key: "Foreign Key",
+      uuid: "UUID",
+      regex: "Regex",
+      full_name: "Full Name",
+      gender: "Gender",
+      title: "Title",
+      marital_status: "Marital Status",
+      phone: "Phone",
+      email: "Email",
+      job_title: "Job Title",
+      social_id: "Social ID",
+      payment_method: "Payment Method",
+      credit_card_type: "Credit Card Type",
+      credit_card_number: "Credit Card Number",
+      credit_card_date: "Credit Card Date",
+      company_name: "Company Name",
+      department: "Department",
+      industry: "Industry",
+      address: "Address",
+      city: "City",
+      region: "Region",
+      product_name: "Product Name",
+      product_category: "Product Category",
+      color: "Color",
+      size: "Size",
+      weight_unit: "Weight Unit",
+      barcode: "Barcode",
+      sku: "SKU",
+      ip_address: "IP Address",
+      mac_address: "MAC Address",
+      file_path: "File Path",
+      file_name: "File Name",
+      file_extension: "File Extension",
+      url: "URL",
+      hostname: "Hostname",
+      id_number: "ID Number",
+    },
+    idTypes: {
+      title: "ID Type",
+      customPattern: "Custom Pattern",
+      customPatternPlaceholder: "e.g. ([A-Z]{2})-([0-9]{8})",
+      customPatternHint: "Supports simple patterns like [A-Z] letters, [0-9] digits, {n} repetitions, hyphens",
+      id_card: "Chinese ID Card",
+      passport: "Passport",
+      hk_macau_pass: "HK/Macau Permit",
+      taiwan_pass: "Taiwan Permit",
+      uscc: "Unified Social Credit Code",
+      bank_card: "Bank Card",
+      drivers_license: "Driver's License",
+      custom: "Custom",
+    },
+  },
+  tableToolbox: {
+    title: "Data Tools",
+    generateData: "Generate Data",
+    importData: "Import Data",
+    exportData: "Export Data",
+    generateDataComingSoon: "Coming soon",
+  },
+  sqlFile: {
+    title: "Execute SQL File",
+    file: "File",
+    selectSqlFile: "Select SQL file",
+    browse: "Browse",
+    previewingLines: "Previewing {count} lines",
+    previewingFirstLines: "Previewing first {count} lines",
+    target: "Target",
+    connection: "Connection",
+    selectConnection: "Select connection",
+    database: "Database",
+    selectDatabase: "Select database",
+    databasePlaceholder: "Database name",
+    options: "Options",
+    continueOnError: "Continue on error",
+    runInBackground: "Run in background",
+    cancelling: "Cancelling...",
+    cancel: "Cancel",
+    execute: "Execute",
+    statement: "Statement",
+    succeeded: "Succeeded",
+    failed: "Failed",
+    affectedRows: "Affected rows",
+    currentStatement: "Current statement",
+    status: {
+      idle: "Idle",
+      started: "Started",
+      running: "Running",
+      statementDone: "Statement done",
+      statementFailed: "Statement failed",
+      done: "Done",
+      error: "Error",
+      cancelled: "Cancelled",
+    },
+  },
+  sqlFileTree: {
+    title: "SQL Files",
+    openFolder: "Open Folder",
+    closePanel: "Close",
+    loading: "Loading...",
+    noFolder: "No folder opened",
+    noSqlFiles: "No SQL files found",
+    folderAlreadyOpen: "This folder is already open",
+    removeFolder: "Remove folder",
+    openFailed: "Failed to open folder: {message}",
+    loadFailed: "Failed to load SQL files: {message}",
+    desktopOnly: "This feature is only available on desktop",
+    refreshFolder: "Refresh folder",
+    refreshAll: "Refresh all",
+    refreshed: "Refreshed",
+    revealInFileManager: "Reveal in file manager",
+    revealFailed: "Failed to open file manager: {message}",
+    copyPath: "Copy path",
+    pathCopied: "Path copied",
+    copyFailed: "Failed to copy path",
+    openFile: "Open",
+    executeSqlFile: "Execute SQL file",
+    expandAll: "Expand all",
+    collapseAll: "Collapse all",
+  },
+  diff: {
+    title: "Compare Schemas",
+    source: "Source",
+    target: "Target",
+    selectConnection: "Select connection",
+    selectDatabase: "Select database",
+    selectSchema: "Select schema",
+    connection: "Connection",
+    database: "Database",
+    schema: "Schema",
+    recentConfigs: "Recent Configs",
+    selectRecentConfig: "Select recent config",
+    ignoreComments: "Ignore comment differences",
+    compare: "Compare",
+    comparing: "Comparing schemas...",
+    noDifferences: "No differences found",
+    table: "Table",
+    status: "Status",
+    details: "Details",
+    added: "Added",
+    removed: "Removed",
+    modified: "Modified",
+    indexes: "Indexes",
+    foreignKeys: "Foreign keys",
+    triggers: "Triggers",
+    comments: "Comments",
+    newTable: "New table",
+    dropTable: "Drop table",
+    generatedSql: "Sync SQL",
+    copySql: "Copy SQL",
+    executeSync: "Execute Sync",
+    syncSuccess: "Sync executed successfully",
+    swap: "Swap source and target",
+    syncProgress: "Executing: {current}/{total}",
+    syncSummary: "Succeeded {success}, failed {failed}",
+    configSaved: "Config saved",
+    configDeleted: "Config deleted",
+    sourceObject: "Source object",
+    targetObject: "Target object",
+    operation: "Operation",
+    selectedCount: "{selected} selected of {total}",
+    saveConfig: "Save config",
+    loadConfig: "Load config",
+    options: "Options",
+    ddlCompare: "DDL compare",
+    deployScript: "Deploy script",
+    deployScriptAll: "All deploy scripts",
+    deployScriptDesc: "SQL script for the selected object",
+    deployScriptAllDesc: "SQL script for all selected objects",
+    copy: "Copy",
+    execute: "Execute",
+    executeAll: "Execute all",
+    executeSuccess: "Executed successfully",
+    selectObjectToCompare: "Select an object to view DDL comparison",
+    noDdlAvailable: "No DDL available",
+    noDeployScript: "No deploy script",
+    noDeployScriptAll: "No deploy script for selected objects",
+    sourceDdl: "Source DDL",
+    targetDdl: "Target DDL",
+    objectNotExistsInSource: "This object does not exist in the source database",
+    objectNotExistsInTarget: "This object does not exist in the target database",
+    nextStepDeploy: "Next (Review Deploy)",
+    deployReview: "Deploy Review",
+    backToResult: "Back to Result",
+    copyScript: "Copy Script",
+    exportSql: "Export .sql",
+    deployToServer: "Deploy to Server",
+    deployConfirmTitle: "Final Confirmation",
+    deployConfirmMessage: "You are about to deploy the following changes to the target database",
+    targetServer: "Target Server",
+    dbVersion: "Database Version",
+    targetDatabase: "Target Database",
+    targetSchema: "Target Schema",
+    useTransaction: "Execute in transaction (auto-rollback on failure)",
+    confirmDeploy: "Confirm Deploy",
+    exportSuccess: "Export successful",
+    create: "Create",
+    delete: "Delete",
+    modify: "Modify",
+    cancel: "Cancel",
+    prevStep: "Previous",
+    recompare: "Compare again",
+    maximize: "Maximize",
+    restore: "Restore",
+    operationLabel: {
+      modify: "Objects to modify",
+      create: "Objects to create",
+      delete: "Objects to delete",
+      none: "No operation",
+    },
+    objectKindLabel: {
+      table: "Table",
+      view: "View",
+      function: "Function",
+      sequence: "Sequence",
+      rule: "Rule",
+      owner: "Owner",
+      index: "Index",
+      foreignKey: "Foreign Key",
+      trigger: "Trigger",
+    },
+    noObjectsSelected: "Please select objects to deploy",
+    deploySuccess: "Deploy Successful",
+    deployFailed: "Deploy Failed",
+    deploySuccessMessage: "SQL script executed successfully on target database",
+    deployFailedMessage: "An error occurred during execution",
+    affectedRows: "Affected Rows",
+    executedStatements: "Executed Statements",
+    serverVersion: "Server Version",
+    info: "Info",
+    connType: "Connection type",
+    connName: "Connection name",
+    host: "Host",
+    port: "Port",
+    copied: "Copied to clipboard",
+    saveConfigPrompt: "Please enter config name:",
+    close: "Close",
+    searchConnection: "Search connections...",
+    searchDatabase: "Search databases...",
+    searchSchema: "Search schemas...",
+  },
+  schemaDiff: {
+    optionsTitle: "Compare Options",
+    selectConfig: "Select config",
+    newConfigName: "New Config",
+    newConfig: "New Config",
+    renameConfig: "Rename Config",
+    duplicateConfig: "Duplicate Config",
+    deleteConfig: "Delete Config",
+    exportConfig: "Export Config",
+    exportAllConfigs: "Export All Configs",
+    importConfig: "Import Config",
+    importFromFile: "Import from File",
+    importFromText: "Import from Text",
+    importPlaceholder: "Paste JSON config...",
+    importInvalidJson: "Invalid JSON format",
+    configName: "Config Name",
+    tableFilter: "Table filter",
+    tableFilterHint: "Matches full table names with regex. Do not type /.../. ^ means starts with, $ means ends with, | means or.",
+    tableFilterHintShort: "Limit compare by table name regex",
+    tableFilterHelp: "Table filter help",
+    tableFilterHelpRule: "Matches full table names. Do not type /.../.",
+    tableFilterHelpBlank: "Blank include means all tables. Blank skip means no exclusions.",
+    tableFilterHelpExample: "^user_ means starts with user_; _bak$ means ends with _bak; a|b means a or b.",
+    tableIncludePattern: "Only compare matched tables",
+    tableIncludePatternPlaceholder: "e.g. ^user_",
+    tableExcludePattern: "Skip matched tables",
+    tableExcludePatternPlaceholder: "e.g. _bak$",
+    tableFilterPriority: "When both match",
+    tableFilterPriorityExclude: "Exclude wins",
+    tableFilterPriorityInclude: "Include wins",
+    options: {
+      tables: "Compare tables",
+      primaryKeys: "Compare primary keys",
+      foreignKeys: "Compare foreign keys",
+      uniqueKeys: "Compare unique keys",
+      checks: "Compare check constraints",
+      exclusions: "Compare exclusion constraints",
+      views: "Compare views",
+      functions: "Compare functions",
+      indexes: "Compare indexes",
+      sequences: "Compare sequences",
+      triggers: "Compare triggers",
+      rules: "Compare rules",
+      owners: "Compare owners",
+      cascadeDelete: "Use CASCADE delete",
+      sequenceLastValues: "Compare sequence last values",
+      compareColumnOrder: "Compare column order",
+    },
+  },
+  dataCompare: {
+    title: "Compare Data",
+    selectTable: "Select table",
+    searchTable: "Search tables...",
+    sourceTables: "Source tables",
+    targetTable: "Target table",
+    searchTables: "Search tables...",
+    selectedTables: "{selected}/{total} selected",
+    selectAllTables: "Select all",
+    deselectAllTables: "Deselect all",
+    selectSourceTables: "Select source connection and database first, then choose tables to compare",
+    noTables: "No tables available for compare",
+    autoMatchHint: "Batch mode automatically matches target tables by the same name",
+    matchedTables: "{matched}/{total} tables matched",
+    missingTargetTables: "Missing same-name target tables: {tables}",
+    keyColumns: "Key Columns",
+    keyColumnsPlaceholder: "Comma-separated primary or unique columns",
+    keyColumnsAutoHint: "Leave blank to auto-detect primary keys for single-table compare, or per table in batch compare.",
+    rowCounts: "Source {source} rows, target {target} rows; full compare completed",
+    previewLimitOption: "Preview {count}",
+    compare: "Compare Data",
+    summary: "Added {added}, removed {removed}, modified {modified}",
+    batchSummary: "Compared {tables} tables: {different} different, {same} identical, {failed} failed; added {added}, removed {removed}, modified {modified}",
+    comparingTable: "Comparing {current}/{total}: {table}",
+    keyColumnsInline: "Key columns: {columns}",
+    selectedInline: "Selected {selected}/{total}",
+    selectedSummary: "Selected: added {added}, removed {removed}, modified {modified}",
+    selectAllKind: "Select all {kind}",
+    clearKind: "Clear {kind}",
+    clearSelection: "Clear all selections",
+    showAllRows: "Show all {count}",
+    showLessRows: "Show less",
+    remainingRows: "{count} more rows hidden in preview",
+    planningSync: "Updating sync plan...",
+    noSelectedDifferences: "No differences are selected for execution",
+    planSummary: "Plan: {inserts} inserts, {updates} updates, {deletes} deletes, {statements} statements",
+    statusDifferent: "Different",
+    statusSame: "Same",
+    statusError: "Failed",
+    noKeyColumns: "Select at least one key column",
+    missingKeyColumns: "Key columns must exist in both source and target tables: {columns}",
+    noCommonColumns: "Source and target tables do not have common columns to compare",
+    targetTableMissing: "Target table not found: {table}",
+    noComparableTables: "No comparable tables found. Check whether same-name target tables exist.",
+    noDifferences: "Data is identical, no sync SQL needed",
+    syncSuccess: "Data sync executed successfully",
+  },
+  settings: {
+    title: "Settings",
+    editorTab: "Editor",
+    sqlFormatterTab: "SQL Formatter",
+    sqlFormatterImport: "Import config",
+    sqlFormatterExport: "Export config",
+    sqlFormatterImportSuccess: "Formatter config imported.",
+    sqlFormatterCopyJson: "Copy JSON",
+    sqlFormatterCopyJsonSuccess: "JSON copied.",
+    sqlFormatterCopyJsonFailed: "Copy failed: {message}",
+    sqlFormatterJsonEditorLoadFailed: "JSON editor failed to load. Switched to a basic input: {message}",
+    sqlFormatterRestoreDefaults: "Restore defaults",
+    sqlFormatterFormMode: "Form",
+    sqlFormatterJsonMode: "JSON",
+    sqlFormatterKeywordCase: "Keyword case",
+    sqlFormatterFunctionCase: "Function case",
+    sqlFormatterDataTypeCase: "Data type case",
+    sqlFormatterIdentifierCase: "Identifier case",
+    sqlFormatterCaseUpper: "Uppercase",
+    sqlFormatterCaseLower: "Lowercase",
+    sqlFormatterCasePreserve: "Preserve",
+    sqlFormatterIndent: "Indent",
+    sqlFormatterIndentSpaces: "Spaces",
+    sqlFormatterIndentTabs: "Tabs",
+    sqlFormatterTabWidth: "Tab width",
+    sqlFormatterIndentStyle: "Indent style",
+    sqlFormatterIndentStyleStandard: "Standard",
+    sqlFormatterIndentStyleTabularLeft: "Tabular left",
+    sqlFormatterIndentStyleTabularRight: "Tabular right",
+    sqlFormatterLogicalOperatorNewline: "Logical operator newline",
+    sqlFormatterLogicalBefore: "Before operator",
+    sqlFormatterLogicalAfter: "After operator",
+    sqlFormatterExpressionWidth: "Expression width",
+    sqlFormatterLinesBetweenQueries: "Lines between queries",
+    sqlFormatterDenseOperators: "Dense operators",
+    sqlFormatterNewlineBeforeSemicolon: "Semicolon on new line",
+    sqlFormatterAdvancedOptions: "Advanced options",
+    sqlFormatterParams: "Params",
+    sqlFormatterParamTypes: "Param types",
+    sqlFormatterEditorShortcuts: "Shortcuts",
+    sqlFormatterShortcutAction: "Action",
+    sqlFormatterShortcutEnabled: "Enabled",
+    sqlFormatterShortcutWindows: "Windows",
+    sqlFormatterShortcutLinux: "Linux",
+    sqlFormatterShortcutMacos: "macOS",
+    sqlFormatterShortcutFind: "Find",
+    sqlFormatterShortcutReplace: "Replace",
+    sqlFormatterShortcutIndentMore: "Indent more",
+    sqlFormatterShortcutIndentLess: "Indent less",
+    sqlFormatterShortcutDuplicateLine: "Duplicate current line",
+    sqlFormatterShortcutDeleteLine: "Delete current line",
+    sqlFormatterShortcutMoveLine: "Move line",
+    sqlFormatterShortcutMoveLineUp: "Move line up",
+    sqlFormatterShortcutMoveLineDown: "Move line down",
+    sqlFormatterShortcutCopyLine: "Copy line",
+    sqlFormatterShortcutCopyLineUp: "Copy line up",
+    sqlFormatterShortcutCopyLineDown: "Copy line down",
+    sqlFormatterShortcutUndo: "Undo",
+    sqlFormatterShortcutRedo: "Redo",
+    sqlFormatterShortcutSelectAll: "Select all",
+    sqlFormatterShortcutFormatJson: "Format JSON",
+    sqlFormatterShortcutApply: "Apply config",
+    sqlFormatterConfigErrorInvalidJson: "Invalid JSON.",
+    sqlFormatterConfigErrorObject: "Config must be a JSON object.",
+    sqlFormatterConfigErrorVersion: "Unsupported config version.",
+    sqlFormatterConfigErrorFormatter: "Unsupported formatter.",
+    sqlFormatterConfigErrorUnsupportedParams: "The params replacement option is not supported. SQL formatting will not replace placeholders.",
+    sqlFormatterConfigErrorOptionsObject: "Config options must be a JSON object.",
+    sqlFormatterConfigErrorEditorObject: "Editor config must be a JSON object.",
+    sqlFormatterConfigErrorEditorScope: "Unsupported editor scope.",
+    sqlFormatterConfigErrorEditorPlatforms: "Invalid editor platforms.",
+    sqlFormatterConfigErrorEditorShortcutsArray: "Editor shortcuts must be an array.",
+    sqlFormatterConfigErrorEditorShortcutValue: "Invalid editor shortcut.",
+    sqlFormatterConfigErrorUnknownOption: "Unknown formatter option: {option}.",
+    sqlFormatterConfigErrorInvalidOptionValue: "Invalid value for {option}.",
+    sqlFormatterConfigErrorUnknownEditorShortcut: "Unknown editor shortcut: {shortcut}.",
+    sqlFormatterConfigErrorInvalidEditorShortcut: "Invalid editor shortcut: {shortcut}.",
+    sqlFormatterConfigErrorDuplicateEditorShortcut: "Duplicate editor shortcut: {shortcut}.",
+    sqlFormatterConfigErrorInvalidConfig: "Invalid formatter config.",
+    appearanceTab: "Appearance",
+    navigationTab: "Navigation",
+    dataTab: "Data",
+    tunnelsTab: "Tunnels",
+    tunnelsDescription: "Reusable SSH / proxy / HTTP tunnel configurations. Configure once, then select the profile from a connection's tunnel tab; edits here apply to every connection using the profile.",
+    tunnelsEmpty: "No tunnel profiles yet. Create one here, then select it in a connection's tunnel settings.",
+    tunnelsAddSsh: "Add SSH",
+    tunnelsAddProxy: "Add Proxy",
+    tunnelsAddHttp: "Add HTTP Tunnel",
+    tunnelsProfileName: "Profile Name",
+    tunnelsProfileNamePlaceholder: "e.g. Office bastion",
+    tunnelsDelete: "Delete",
+    tunnelsUnnamedProfile: "Unnamed profile",
+    tunnelsSave: "Save",
+    tunnelsReset: "Reset",
+    tunnelsSaved: "Tunnel profiles saved",
+    tunnelsSaveFailed: "Failed to save tunnel profiles: {message}",
+    tunnelsUnsavedHint: "Unsaved changes",
+    redisTab: "Redis",
+    shortcutsTab: "Shortcuts",
+    snippetsTab: "Snippets",
+    syncTab: "Sync",
+    aiTab: "AI",
+    mcpTab: "MCP",
+    jdbcTab: "JDBC Drivers",
+    securityTab: "Security",
+    aboutTab: "About",
+    fontFamily: "Font Family",
+    uiFontFamily: "Interface Font",
+    uiFontAppDefault: "DBX Default",
+    uiFontSystemDefault: "System Default",
+    uiFontFamilyDescription: "Applies to app chrome such as the toolbar, tabs, sidebar, dialogs, and other non-editor UI.",
+    selectFont: "Select font...",
+    searchFont: "Search fonts...",
+    loadingFonts: "Loading fonts...",
+    noFontsFound: "No fonts found",
+    useCustomFont: "Use “{font}”",
+    languageTitle: "Language / 语言",
+    fontSize: "Font Size",
+    toolbarTitle: "Toolbar",
+    toolbarHiddenHint: 'Some hidden or overflowed buttons appear in the "More" dropdown.',
+    uiScale: "UI Scale",
+    uiScaleDescription: "Scale the entire desktop UI for high-DPI displays. Changes apply immediately and are restored on next launch.",
+    theme: "Theme",
+    selectTheme: "Select theme...",
+    colorTheme: "Color Theme",
+    selectColorTheme: "Select color theme...",
+    themePalettePearl: "White",
+    themePaletteMist: "Mist Gray",
+    themePaletteGraphite: "Titanium Gray",
+    themePaletteCobalt: "Cobalt Blue",
+    themePaletteSage: "Sage Green",
+    themePaletteAmber: "Warm Yellow",
+    themePaletteBlush: "Sakura Pink",
+    themePaletteVscode: "VS Code",
+    themePaletteIdea: "IDEA",
+    themePaletteXcode: "Xcode",
+    themePaletteJetbrains: "JetBrains",
+    themePaletteCursor: "Cursor",
+    themePaletteClaude: "Claude Code",
+    followAppTheme: "Follow app theme",
+    appLayout: "Interface Layout",
+    appLayoutSeparated: "Modern separated",
+    appLayoutSeparatedDescription: "Clear panel separation with block-style tabs.",
+    appLayoutClassic: "Classic compact",
+    appLayoutClassicDescription: "Continuous tab bar with compact panel headers.",
+    iconTheme: "Icon and logo style",
+    iconThemeDefault: "Default",
+    iconThemeDefaultDescription: "Use the color DBX app icon.",
+    iconThemeBlack: "Black",
+    iconThemeBlackDescription: "Use the black DBX logo in the app.",
+    iconThemeBlackDescriptionMac: "Use the black logo in the app; Dock uses a black plate, menu bar follows the system.",
+    showTrayIcon: "Show tray/menu bar icon",
+    showTrayIconDescription: "When disabled, no icon is shown, but closing the window still hides DBX in the background as before.",
+    quitOnClose: "Quit when closing window",
+    quitOnCloseDescription: "When enabled, clicking the close button exits DBX completely instead of hiding it to the tray. You can change this later in Appearance settings.",
+    closeActionPromptTitle: "Close window",
+    closeActionPromptDescription: "Choose what happens when you click the close button. You can change this later in Settings > Appearance.",
+    closeActionQuit: "Quit DBX",
+    closeActionMinimize: "Minimize to tray",
+    updateNotificationsEnabled: "Enable update reminders",
+    updateNotificationsEnabledDescription: "When disabled, DBX will not automatically check app or driver updates or show update badges. Manual checks are still available.",
+    updateDownloadSource: "Update download source",
+    updateDownloadSourceDescription: "Choose where app updates, database agents, drivers, and managed JREs are downloaded from. The official source is recommended; CNB or AtomGit can be faster on mainland China networks.",
+    updateDownloadSourceOfficial: "Official source (recommended)",
+    updateDownloadSourceCnb: "CNB",
+    updateDownloadSourceAtomgit: "AtomGit",
+    debugLoggingEnabled: "Enable debug logs",
+    debugLoggingEnabledDescription: "Record more detailed local user-side diagnostic logs while troubleshooting reports. Disabled by default.",
+    duckDbWorkerProcessIsolation: "DuckDB process isolation mode (Experimental)",
+    duckDbWorkerProcessIsolationDescription: "Runs DuckDB queries in a separate worker process. If a long query does not respond to cancellation, DBX can stop the worker process to release the database file lock.",
+    duckDbWorkerMaxProcesses: "DuckDB max concurrent workers",
+    duckDbWorkerMaxProcessesDescription: "Limits how many DuckDB worker processes DBX can run at the same time. Range: 1-16. Default: 4.",
+    duckDbWorkerProcessIsolationRestartRequired: "Restart DBX for this change to take effect.",
+    restartDbx: "Restart DBX",
+    restartDbxFailed: "Failed to restart DBX: {error}",
+    debugLogsCopy: "Copy logs",
+    debugLogsCopied: "Copied",
+    debugLogsDownload: "Download logs",
+    debugLogsDownloaded: "Downloaded",
+    debugLogsClear: "Clear logs",
+    tableStructureSection: "Table Structure",
+    dataGridDisplay: "Data grid display",
+    showColumnCommentsInHeader: "Show column comments under names",
+    showColumnCommentsInHeaderDescription: "Display table column comments directly below grid column names.",
+    showColumnTypesInHeader: "Show column types under names",
+    showColumnTypesInHeaderDescription: "Display each column's data type directly below grid column names.",
+    compactColumnHeaderActions: "Compact column header tools",
+    compactColumnHeaderActionsDescription: "Move formatter and local filter tools into a more menu so column names get priority.",
+    dataGridQuickEntry: "Quick grid entry",
+    dataGridQuickEntryDescription: "When enabled, editing a cell or filling the bottom blank row saves to the database as soon as focus leaves. Useful for frequent entry, but it can cause accidental writes.",
+    infiniteScroll: "Infinite scroll loading",
+    autoCalculateTotalRows: "Auto-calculate total row count",
+    autoCalculateTotalRowsDescription: "Run COUNT(*) automatically after each query to show the total matching rows. Off by default to keep large queries fast — calculate it on demand from the result footer.",
+    infiniteScrollDescription: "Automatically load the next page of data when scrolling to the bottom of the table.",
+    infiniteScrollMaxRows: "Infinite scroll max rows",
+    infiniteScrollMaxRowsDescription: "Maximum number of rows to load in infinite scroll mode (1000–50000).",
+    tableColumnTemplateFields: "New Table Preset Fields",
+    tableColumnTemplateFieldsDescription: "Choose a database type, then configure the preset field types used when creating new tables.",
+    tableColumnTemplateAdd: "Add Field",
+    tableColumnTemplateColumn: "Field",
+    tableColumnTemplateDatabase: "Database",
+    tableColumnTemplateType: "Type",
+    tableColumnTemplateLength: "Length",
+    tableColumnTemplateDefault: "Default",
+    tableColumnTemplateNoPresetType: "No preset type",
+    tableColumnTemplateRequired: "Required",
+    tableColumnTemplateComment: "Description",
+    tableColumnTemplateDragHandle: "Drag to reorder",
+    sidebarActivation: "Sidebar activation",
+    sidebarActivationSingle: "Single click",
+    sidebarActivationSingleDescription: "Open actionable sidebar items with one click.",
+    sidebarActivationDouble: "Double click",
+    sidebarActivationDoubleDescription: "Single click selects rows; double click opens items.",
+    sidebarObjectDisplay: "Sidebar object layout",
+    sidebarObjectDisplayGrouped: "Advanced view",
+    sidebarObjectDisplayGroupedDescription: "Group objects by tables, views, procedures, and functions for databases with more object types.",
+    sidebarObjectDisplaySimple: "Simple view",
+    sidebarObjectDisplaySimpleDescription: "List tables and views directly under each database or schema to reduce intermediate levels.",
+    autoSelectActiveSidebarNode: "Always select opened item",
+    autoSelectActiveSidebarNodeDescription: "When switching tabs, select the matching visible table, collection, or SQL file in the sidebar.",
+    openTabsRestoreMode: "Restore tabs on launch",
+    openTabsRestoreModeDescription: "Choose how DBX restores tabs that were open last time.",
+    openTabsRestoreModeAll: "Keep all tabs",
+    openTabsRestoreModePinned: "Keep pinned tabs only",
+    openTabsRestoreModeNone: "Do not keep tabs",
+    openTabsRestoreModeHint: "Pinned tabs stay on the left side of the tab bar and work well as frequent entry points.",
+    disconnectTabHandlingMode: "Tabs after disconnect",
+    disconnectTabHandlingModeDescription: "Choose how related tabs should be handled after closing a connection or database.",
+    disconnectTabHandlingModeCloseTabs: "Close all tabs",
+    disconnectTabHandlingModeCloseTabsDescription: "Close all related tabs for the connection or database.",
+    disconnectTabHandlingModeKeepTabsClearResults: "Close object tabs, keep SQL tabs",
+    disconnectTabHandlingModeKeepTabsClearResultsDescription: "Close table data, object browser, and structure tabs while keeping SQL query tabs and SQL text, and also clear execution state and result sessions.",
+    disconnectTabHandlingModeKeepTabsKeepResults: "Do not close related tabs",
+    disconnectTabHandlingModeKeepTabsKeepResultsDescription: "Keep related tabs, SQL text, and current results without extra cleanup.",
+    reuseDataTab: "Reuse data tab",
+    reuseDataTabDescription: "When clicking a table in the sidebar, reuse the existing data tab instead of creating a new one each time.",
+    sidebarHiddenTablePrefixes: "Hidden table name prefixes",
+    sidebarHiddenTablePrefixesDescription: "One prefix per line. Only sidebar table, view, and collection labels are shortened; tooltips and actions still use the full name.",
+    sidebarHiddenTablePrefixesPlaceholder: "Example:\nODS_\nT8Y2_LONG_",
+    sidebarTablePageSize: "Sidebar page size",
+    sidebarTablePageSizeDescription: "Maximum number of tables/objects loaded per page in the sidebar tree. Increase if you have many tables and want fewer pages.",
+    sidebarTableSearchEnabled: "Enable table search inside databases",
+    sidebarTableSearchEnabledDescription: "Show a local table search box under expanded databases, schemas, or table groups so each scope can filter tables independently.",
+    sidebarHideTableComments: "Hide table comments in sidebar",
+    sidebarHideTableCommentsDescription: "Hide the inline table/view comments shown next to names in the sidebar tree to save horizontal space.",
+    sidebarAllowHorizontalScroll: "Allow sidebar horizontal scroll",
+    sidebarAllowHorizontalScrollDescription: "Show long table, view, and collection names in full by allowing horizontal sidebar scrolling.",
+    snippetsDescription: "Customize SQL snippet templates triggered in the editor.",
+    snippetsAdd: "Add Snippet",
+    snippetsLabel: "Label",
+    snippetsPrefix: "Prefix",
+    snippetsStatus: "Status",
+    snippetsEnabled: "Enabled",
+    snippetsDisabled: "Disabled",
+    snippetsToggle: "Enable or disable snippet",
+    snippetsBody: "SQL Body",
+    snippetsLabelPlaceholder: "e.g. select *",
+    snippetsPrefixPlaceholder: "e.g. sel",
+    snippetsBodyPlaceholder: "SELECT *\nFROM table\nLIMIT 100;",
+    snippetsRestoreDefaults: "Restore Defaults",
+    snippetsAddTitle: "Add Snippet",
+    snippetsEditTitle: "Edit Snippet",
+    syncWebDavTitle: "WebDAV Sync",
+    syncWebDavDescription: "Upload or restore a DBX snapshot, including saved SQL library entries, from a WebDAV-compatible storage service.",
+    syncEndpoint: "WebDAV URL",
+    syncUsername: "Username",
+    syncPassword: "Password",
+    syncPasswordPlaceholder: "Enter password",
+    syncClearSavedPassword: "Clear saved password",
+    syncRememberWebDavPassword: "Remember WebDAV app password",
+    syncSavedPassword: "(saved)",
+    syncRememberWebDavPasswordDescription: "The password is encrypted and stored on this device only. It is not synced to WebDAV and does not replace the sync password.",
+    syncRemotePath: "Remote snapshot path",
+    syncRemotePathDescription: "DBX will create missing parent folders when uploading.",
+    syncSecretNotice: "By default, DBX syncs connection details and settings only. Database passwords, SSH passwords, proxy passwords, HTTP tunnel tokens, connection strings, and AI API keys stay local.",
+    syncSecrets: "Sync encrypted secrets",
+    syncSecretsDescription: "When enabled, DBX encrypts database passwords, SSH passwords, proxy passwords, HTTP tunnel tokens, and AI API keys before uploading them to remote storage.",
+    syncSecretsSharedDescription: "Applies to WebDAV, GitHub Gist, and Gitee snippets. Secrets are encrypted before being included in the snapshot.",
+    syncSecretsPassphrase: "Sync password",
+    syncSecretsPassphraseDescription: "This password is only used to encrypt and restore sensitive data. DBX does not save it; enter it again on each device.",
+    syncTest: "Test",
+    syncUpload: "Upload",
+    syncDownload: "Download",
+    syncTestSuccess: "WebDAV target is reachable.",
+    syncUploadSuccess: "Uploaded {bytes} bytes to {path}.",
+    syncAutoUpload: "Automatically upload snapshots",
+    syncAutoUploadInterval: "Every",
+    syncAutoUploadMinutes: "minutes",
+    syncAutoUploadDescription: "Runs while DBX is open. Downloads still require manual confirmation to avoid replacing local saved SQL unexpectedly.",
+    syncAutoUploadSuccess: "Auto-uploaded {bytes} bytes to {path}.",
+    syncDownloadSuccess: "Downloaded and applied {bytes} bytes from {path}.",
+    syncSecretsApplied: "Encrypted secrets were restored.",
+    syncSecretsSkipped: "Encrypted secrets were present but were not restored.",
+    syncDownloadConfirm: "Download and apply the remote DBX snapshot? Local metadata and saved SQL will be replaced.",
+    syncSnippetTitle: "GitHub / Gitee Snippet Sync",
+    syncSnippetDescription: "Store the same DBX snapshot in a private code snippet. The first upload creates a snippet and saves its ID.",
+    syncSnippetProvider: "Provider",
+    syncSnippetId: "Snippet ID",
+    syncSnippetIdPlaceholder: "Leave empty for the first upload",
+    syncSnippetToken: "Access token",
+    syncSnippetRememberToken: "Store encrypted on this device",
+    syncSnippetTokenDescription: "GitHub tokens need Gists write permission. Tokens are never included in the sync snapshot.",
+    syncSnippetTestSuccess: "The snippet sync target is accessible.",
+    syncSnippetUploadSuccess: "Uploaded {bytes} bytes to snippet {id}.",
+    syncSnippetDownloadSuccess: "Downloaded and applied {bytes} bytes from snippet {id}.",
+    syncSnippetGuide: "Setup guide",
+    apply: "Apply",
+    applyAndClose: "Apply and Close",
+    reset: "Reset",
+    resetDefaults: "Reset Defaults",
+    resetAllDefaults: "Reset All Defaults",
+    save: "Save",
+    cancel: "Cancel",
+    executeMode: "Execute Mode (Cmd+Enter)",
+    executeModeAll: "Execute all SQL",
+    executeModeCurrent: "Execute statement at cursor",
+    showExecutionTargetPicker: "Show execution target picker",
+    showExecutionTargetPickerDescription: "When enabled, running without a selection lets you choose between the current statement and all SQL.",
+    showStatementRunButtons: "Show left-side run buttons",
+    showStatementRunButtonsDescription: "Show per-statement run buttons in the SQL editor gutter. Keyboard shortcuts and context menu execution still work when disabled.",
+    showCurrentStatementFrame: "Show current statement frame",
+    showCurrentStatementFrameDescription: "When enabled, the SQL editor draws an outline around the current executable statement; when disabled, the outline is hidden.",
+    showInsertValueHints: "Show INSERT value column hints",
+    showInsertValueHintsDescription: "When enabled, the SQL editor shows column-name hints next to each value in INSERT ... VALUES clauses.",
+    previewStatementRunButton: "Preview statement run button",
+    wordWrap: "Word wrap",
+    wordWrapDescription: "Wrap long SQL lines within the editor width",
+    vimMode: "Vim mode",
+    vimModeDescription: "Use Vim-style modal editing in the SQL editor",
+    autoCloseBrackets: "Auto-close brackets",
+    autoCloseBracketsDescription: "Automatically insert closing brackets and quotes when typing an opening one",
+    sqlSemanticDiagnosticsEnabled: "SQL semantic diagnostics",
+    sqlSemanticDiagnosticsEnabledDescription: "When enabled, the editor reports semantic issues such as unknown tables and columns. Disable it to reduce parsing and metadata checks for large SQL.",
+    confirmDangerousSqlExecution: "Confirm before dangerous SQL",
+    confirmDangerousSqlExecutionDescription: "When disabled, ALTER, DROP, DELETE, TRUNCATE, and other dangerous SQL run without the warning dialog.",
+    confirmUnsavedSqlClose: "Confirm before closing unsaved SQL",
+    confirmUnsavedSqlCloseDescription: "When disabled, SQL tabs with unsaved edits close or quit without the save confirmation dialog.",
+    sqlVariableSyntax: "SQL variable & placeholder substitution",
+    sqlVariableSyntaxDescription: "Choose which variable and placeholder syntaxes DBX substitutes before running SQL, per database type. All are enabled by default.",
+    sqlVariableSyntax_positional: "Positional placeholder",
+    sqlVariableSyntax_positionalDescription: "Prompt for a value to substitute each positional placeholder in order.",
+    sqlVariableSyntax_named: "Named placeholder",
+    sqlVariableSyntax_namedDescription: "Prompt for a value to substitute named placeholders.",
+    sqlVariableSyntax_shell: "Shell-style placeholder",
+    sqlVariableSyntax_shellDescription: "Prompt for a value to substitute shell-style placeholders.",
+    sqlVariableSyntax_mybatis: "MyBatis-style placeholder",
+    sqlVariableSyntax_mybatisDescription: "Prompt for a value to substitute MyBatis-style placeholders.",
+    sqlVariableSyntax_sqlserver: "SQL Server-style placeholder",
+    sqlVariableSyntax_sqlserverDescription: "Prompt for a value to substitute SQL Server-style placeholders (may collide with session variables).",
+    sqlVariableSyntax_atSet: "Inline variable expansion",
+    sqlVariableSyntax_atSetDescription: "Expand inline variable declarations and substitute their values before running.",
+    autoAliasTables: "Automatically add table aliases",
+    autoAliasTablesDescription: "When selecting a table completion in FROM or JOIN, insert a generated alias such as order_items AS oi.",
+    redisScanPageSize: "Redis scan count",
+    redisScanPageSizeDescription: "Keys requested per Redis SCAN page when browsing keys.",
+    redisScanPageSizeOption: "{count} keys",
+    exportBatchSize: "Export batch size",
+    exportBatchSizeDescription: "Rows fetched per batch when exporting data (100-100000).",
+    exportRowLimitEnabled: "Limit exported rows",
+    exportRowLimitEnabledDescription: "When on, query result and table data exports stop at the row limit below.",
+    exportRowLimit: "Data export row limit",
+    exportRowLimitDescription: "Maximum rows for query result and table data exports.",
+    exportRowLimitUnlimited: "Unlimited",
+    queryExportKeysetOptimizationEnabled: "Try keyset optimization",
+    queryExportKeysetOptimizationEnabledDescription: "Only applies to safely recognized single-table queries; complex queries automatically fall back.",
+    exportSection: "Export",
+    shortcutExecuteSql: "Execute SQL",
+    shortcutFind: "Find",
+    shortcutReplace: "Replace",
+    shortcutSaveSql: "Save SQL",
+    shortcutAcceptCompletion: "Accept completion",
+    shortcutFormatSql: "Format SQL",
+    shortcutToggleLineComment: "Toggle line comment",
+    shortcutIndentMore: "Indent more",
+    shortcutIndentLess: "Indent less",
+    shortcutDuplicateLine: "Duplicate current line",
+    shortcutDeleteLine: "Delete current line",
+    shortcutMoveLineUp: "Move line up",
+    shortcutMoveLineDown: "Move line down",
+    shortcutCopyLineUp: "Copy line up",
+    shortcutCopyLineDown: "Copy line down",
+    shortcutUndo: "Undo",
+    shortcutRedo: "Redo",
+    shortcutSelectAll: "Select all",
+    shortcutCopyCurrentRow: "Copy current data row",
+    shortcutDeleteCurrentRow: "Delete current data row",
+    shortcutNewQuery: "New query",
+    shortcutOpenSettings: "Open settings",
+    shortcutCloseTab: "Close tab",
+    shortcutFocusSearch: "Focus search",
+    shortcutQuickOpen: "Quick open (search all database objects)",
+    shortcutSwitchToPreviousTab: "Switch to previous tab",
+    shortcutSwitchToNextTab: "Switch to next tab",
+    shortcutSwitchToTab1: "Switch to tab 1",
+    shortcutSwitchToTab2: "Switch to tab 2",
+    shortcutSwitchToTab3: "Switch to tab 3",
+    shortcutSwitchToTab4: "Switch to tab 4",
+    shortcutSwitchToTab5: "Switch to tab 5",
+    shortcutSwitchToTab6: "Switch to tab 6",
+    shortcutSwitchToTab7: "Switch to tab 7",
+    shortcutSwitchToTab8: "Switch to tab 8",
+    shortcutSwitchToTab9: "Switch to tab 9",
+    shortcutZoomInUi: "Zoom in UI",
+    shortcutZoomOutUi: "Zoom out UI",
+    shortcutResetUiZoom: "Reset UI zoom",
+    shortcutRefreshData: "Refresh data",
+    shortcutToggleTranspose: "Toggle transpose view",
+    shortcutCancelSearch: "Cancel search",
+    shortcutToggleSidebar: "Toggle sidebar",
+    shortcutCopySidebarSelection: "Copy sidebar selection",
+    shortcutPasteSidebarSelection: "Paste into sidebar",
+    shortcutEditSidebarConnection: "Edit sidebar connection",
+    shortcutSendSelectionToAi: "Send selection to AI",
+    shortcutScopeGlobal: "Global",
+    shortcutScopeEditor: "SQL editor",
+    shortcutScopeGrid: "Data grid",
+    shortcutScopeSearch: "Search fields",
+    shortcutScopeSidebar: "Sidebar",
+    shortcutPressShortcut: "Press shortcut",
+    shortcutSearchPlaceholder: "Search shortcuts",
+    shortcutSearchNoResults: "No shortcuts match your search.",
+    shortcutConflict: "This shortcut conflicts with another action in the same scope.",
+    shortcutClear: "Clear shortcut",
+    preview: "Live Preview",
+    customTheme: "Custom Theme",
+    customThemeConfigure: "Configure Custom Theme",
+    customThemeTitle: "Custom Theme Configuration",
+    customThemeMyThemes: "My Themes",
+    customThemeNewTheme: "New Theme",
+    customThemeVisualEdit: "Visual Editor",
+    customThemeJsonConfig: "JSON Config",
+    customThemeLivePreview: "Live Preview",
+    customThemePreviewExample: "-- Query Example",
+    customThemePreset: "Preset Theme",
+    customThemeSelectPreset: "Select preset theme...",
+    customThemeApply: "Apply",
+    customThemePasteImport: "Paste Import",
+    customThemeExportJson: "Export JSON",
+    customThemeSaveAndApply: "Save & Apply",
+    customThemeKeyword: "Keyword",
+    customThemeField: "Field/Variable",
+    customThemeFunction: "Function",
+    customThemeString: "String",
+    customThemeNumber: "Number",
+    customThemeComment: "Comment",
+    customThemeTable: "Table",
+    customThemeOperator: "Operator",
+    customThemeType: "Type",
+    customThemeBuiltin: "Builtin",
+    customThemeBackground: "Background",
+    customThemeForeground: "Foreground",
+    customThemeDefaultName: "Custom Theme",
+    customThemeCopySuffix: " Copy",
+    customThemeApplied: 'Applied "{name}" color scheme',
+    customThemeKeepOne: "Keep at least one theme",
+    customThemeJsonError: "Invalid JSON format, please check",
+    jdbcPlugin: "DBX JDBC plugin",
+    jdbcPluginInstall: "Install JDBC plugin",
+    jdbcPluginInstallSuccess: "JDBC plugin installed",
+    jdbcPluginUpdate: "Update",
+    jdbcPluginUninstall: "Uninstall",
+    jdbcPluginUninstallSuccess: "JDBC plugin uninstalled",
+    jdbcPluginInstalled: "Installed: v{version}",
+    jdbcPluginIncompatible: "Incompatible protocol",
+    jdbcPluginNotInstalled: "Not installed",
+    jdbcDrivers: "JDBC driver JARs",
+    jdbcImport: "Import JAR",
+    jdbcImportPath: "Import Path",
+    jdbcDriverPathPlaceholder: "/path/to/driver.jar",
+    jdbcImportSuccess: "Imported {count} driver file(s)",
+    jdbcDeleteSuccess: "Driver removed",
+    jdbcNoDrivers: "No JDBC drivers imported yet.",
+    mcpTitle: "MCP Server",
+    mcpDescription: "Check the DBX MCP Server installation and version used by Claude Code, Cursor, and other agents.",
+    mcpChecking: "Checking",
+    mcpStatusUnknown: "Not checked",
+    mcpStatusError: "Check failed",
+    mcpReady: "Ready",
+    mcpNotInstalled: "Not installed",
+    mcpUpdateAvailable: "Update available",
+    mcpCurrent: "Current version",
+    mcpLatest: "Latest version",
+    mcpVersionMissing: "No global install detected",
+    mcpVersionUnknown: "Unknown",
+    mcpAvailable: "Available",
+    mcpUnavailable: "Unavailable",
+    mcpBinPath: "Command path",
+    mcpInstallCommand: "Install command",
+    mcpUpdateCommand: "Upgrade command",
+    mcpInstallButton: "Install",
+    mcpUpdateButton: "Upgrade",
+    mcpUpToDate: "Up to date",
+    mcpInstalling: "Installing...",
+    mcpInstallSuccess: "Installation successful",
+    mcpInstallFailed: "Installation failed",
+    mcpConfig: "MCP config",
+    mcpConfigOptionsHint: "These options only update the generated config below. Copy it into your AI client and restart the MCP session to apply it.",
+    mcpCodexConfig: "Codex config",
+    mcpCodexConfigPath: "Codex can use ~/.codex/config.toml or a project-level .codex/config.toml.",
+    mcpCursorConfigPath: "Cursor can use .cursor/mcp.json in the project or ~/.cursor/mcp.json globally.",
+    mcpTraeConfigPath: "TRAE: Settings > MCP > Add > Add Manually, then paste the JSON configuration.",
+    mcpVsCodeConfigPath: "VS Code/Copilot can use .vscode/mcp.json in the workspace or mcp.json in the user profile.",
+    mcpWindsurfConfigPath: "Windsurf can use ~/.codeium/windsurf/mcp_config.json.",
+    mcpOpenCodeConfigPath: "~/.config/opencode/opencode.json globally, or opencode.json at the project level.",
+    mcpReadonlyMode: "Read-only mode",
+    mcpReadonlyModeDescription: "Adds DBX_MCP_ALLOW_WRITES=0 to the sample config so the MCP session stays query-only.",
+    mcpAllowDangerous: "Allow dangerous SQL",
+    mcpAllowDangerousDescription: "Adds DBX_MCP_ALLOW_DANGEROUS_SQL=1 to the sample config so DROP, TRUNCATE, ALTER, and similar statements are allowed.",
+    mcpDetectionTiming: "DBX checks automatically when this page opens; use Check again to refresh.",
+    mcpNpmBoundary: "DBX only checks and explains MCP status; installation and upgrades still run through npm.",
+    mcpRefresh: "Check again",
+    mcpGuide: "MCP guide",
+    supportInfoTitle: "Support information",
+    supportInfoDescription: "Copy these environment details when filing issues or asking for help.",
+    supportInfoCopy: "Copy support info",
+    supportInfoCopied: "Copied",
+    supportInfoLoading: "Loading support information...",
+    supportInfoLoadFailed: "Failed to load full support information: {message}",
+    supportInfoAppVersion: "DBX Version",
+    supportInfoRuntime: "Runtime",
+    supportInfoRuntimeDesktop: "Desktop",
+    supportInfoRuntimeWeb: "Web",
+    supportInfoOperatingSystem: "Operating System",
+    supportInfoArchitecture: "Architecture",
+    supportInfoUnknown: "Unknown",
+    community: "Community",
+    qqGroup: "QQ Group",
+    wechatGroup: "WeChat Group",
+    wechatGroupInvite: "Tencent Docs invite",
+    project: "Project",
+    openSource: "Open-source repository",
+    officialDocs: "Official docs",
+    shortcutUppercaseSelection: "Convert selection to uppercase",
+    shortcutLowercaseSelection: "Convert selection to lowercase",
+    shortcutExPasteSqlInCondition: "ExPaste: paste as IN condition",
+  },
+  driverStore: {
+    progressJreExtract: "Extracting JRE...",
+    progressDownloadJre: "Downloading JRE",
+    progressDownloadDriver: "Downloading driver",
+    progressDownloadJdbcPlugin: "Downloading JDBC plugin",
+    progressJdbcPluginExtract: "Installing JDBC plugin...",
+    usageTitle: "Storage usage",
+    usageTotal: "Total {size}",
+    usageTotalLabel: "Total",
+    calculating: "Calculating...",
+    usageManagedJre: "Managed JRE",
+    usageAgentDrivers: "Built-in driver agents",
+    usageDownloadCache: "Download cache",
+    usageJdbcPlugin: "JDBC plugin",
+    usageJdbcDriverJars: "JDBC driver JARs",
+    clearDownloadCache: "Clear cache",
+    downloadCacheClearSuccess: "Download cache cleared",
+    downloadCacheClearFailed: "Failed to clear download cache: {error}",
+    offlineDownloadHint: "For air-gapped environments, download offline driver packages on an internet-connected machine, then import them here.",
+    offlineDownloadLink: "Offline driver downloads",
+    searchDrivers: "Search driver name, type, version...",
+    searchJdbcDrivers: "Search JDBC driver name or path...",
+    jdbcMavenCoordinatePlaceholder: "Maven coordinate, e.g. org.postgresql:postgresql:42.7.7",
+    jdbcMavenInstall: "Install from Maven",
+    jdbcMavenInstallSuccess: "JDBC Maven driver installed",
+    jdbcSourceMaven: "Maven",
+    jdbcSourceManual: "Manual",
+    noMatchingDrivers: "No matching drivers.",
+    javaRuntimeSaved: "Java runtime settings saved",
+    javaRuntimeSaveFailed: "Failed to save Java runtime settings: {error}",
+    chooseJavaExecutable: "Choose Java executable",
+    driverInstallSuccess: "{label} driver installed",
+    driverInstallFailed: "Failed to install {label} driver: {error}",
+    driverUpdateBlocked: "Close these database connections before updating drivers: {labels}",
+    upgradeAllSuccess: "{count} driver(s) upgraded",
+    upgradeAllPartial: "{count} driver(s) upgraded. Skipped: {failed}",
+    upgradeAllFailed: "Batch upgrade failed: {error}",
+    driverUninstallSuccess: "{label} driver uninstalled",
+    driverUninstallFailed: "Failed to uninstall {label} driver: {error}",
+    chooseOfflineDriverPackage: "Choose offline driver package",
+    offlineImportSuccess: "Offline import complete. Installed {count} driver(s).",
+    offlineImportFailed: "Offline import failed: {error}",
+    driverImportSuccess: "{label} driver imported",
+    driverImportFailed: "Failed to import {label} driver: {error}",
+    chooseDriverJar: "Choose driver JAR file",
+    jreReinstallSuccess: "JRE {jre} reinstalled",
+    jreReinstallFailed: "Failed to reinstall JRE {jre}: {error}",
+    jreUninstallSuccess: "JRE {jre} uninstalled",
+    chooseJdbcPluginZip: "Choose JDBC plugin zip file",
+    agentDrivers: "Built-in Drivers",
+    jdbcDrivers: "JDBC Drivers",
+    importing: "Importing...",
+    importOfflinePackage: "Import offline package",
+    refresh: "Refresh",
+    javaRuntime: "Java Runtime",
+    javaRuntimeManaged: "DBX managed JRE",
+    javaRuntimeSystem: "System java",
+    javaRuntimeCustom: "Custom path",
+    saving: "Saving...",
+    customJavaPathPlaceholder: "/path/to/java or /path/to/jdk",
+    choose: "Choose",
+    systemJavaHint: "Use java from the current PATH.",
+    jreRuntimeTitle: "JRE {jre} Runtime",
+    notInstalled: "Not installed",
+    reinstalling: "Reinstalling",
+    installing: "Installing",
+    install: "Install",
+    reinstall: "Reinstall",
+    uninstall: "Uninstall",
+    jreRuntime: "JRE Runtime",
+    jreRuntimeAutoDownloadHint: "Downloaded automatically when installing a driver for the first time",
+    driversUpdatable: "{count} driver(s) can be updated",
+    upgradingProgress: "Upgrading ({current}/{total})",
+    upgradeAll: "Upgrade all",
+    queued: "Queued",
+    importLocalJar: "Import local JAR",
+    updating: "Updating",
+    update: "Update",
+    localInstall: "Local install",
+    runtimeDrivers: "Runtime",
+    storageTab: "Storage",
+    runtimeTitle: "Driver runtime",
+    runtimeHint: "Runtime metrics are collected only while this panel is open.",
+    runtimeRunning: "Running",
+    runtimeMemory: "Memory",
+    runtimeHealth: "Health",
+    runtimeHealth_healthy: "Healthy",
+    runtimeHealth_warning: "Warning",
+    runtimeHealth_error: "Error",
+    runtimeLastError: "Last error",
+    runtimeEmpty: "No driver runtimes yet. Open an agent-driven connection to start one.",
+    runtimeKindAgent: "Agent",
+    runtimeKindPlugin: "Plugin",
+    runtimeSourceDaemon: "Daemon",
+    runtimeSourceConnection: "Connection",
+    runtimeStatus_running: "Running",
+    runtimeStatus_stopped: "Stopped",
+    runtimeStatus_error: "Error",
+    runtimeStatus_unknown: "Unknown",
+    runtimePid: "PID",
+    runtimeUptime: "Uptime",
+    runtimeActions: "Actions",
+    runtimeStop: "Stop",
+    runtimeRestart: "Restart",
+    runtimeControlConnectionOwned: "Close the database connection to stop this runtime.",
+    runtimeStopSuccess: "{label} runtime stopped",
+    runtimeStopFailed: "Failed to stop {label}: {error}",
+    runtimeRestartSuccess: "{label} runtime restarted",
+    runtimeRestartFailed: "Failed to restart {label}: {error}",
+    driverStoreDir: "Driver Store Path",
+    driverStoreDirDescription: "Set separate storage locations for the JDBC plugin and Agent/JRE data. The app will restart automatically after migration.",
+    pluginStoreDir: "JDBC plugin directory",
+    pluginStoreDirDescription: "Stores the JDBC plugin, Maven resolver, and JDBC driver jars.",
+    agentStoreDir: "Agent / JRE directory",
+    agentStoreDirDescription: "Stores Agent driver packages, managed JREs, and runtime cache.",
+    driverStoreDirDefault: "Default (install directory)",
+    driverStoreDirChange: "Change",
+    driverStoreDirReset: "Reset to Default",
+    driverStoreDirMigrating: "Migrating {target}…",
+    driverStoreDirConfirm: "Changing {target} will migrate the related driver data to the new location. Related driver connections may be disconnected during migration. The app will restart automatically after migration. Continue?",
+    driverStoreDirMigrationFailed: "Driver store migration failed: {error}",
+    driverStoreDirDialogTitle: "Select {target}",
+    driverStoreDirSuccess: "{target} changed, restarting…",
+  },
+  databaseExport: {
+    title: "Export Database",
+    options: "Options",
+    includeStructure: "Table structure (DDL)",
+    dropTableIfExists: "Add DROP TABLE IF EXISTS before DDL",
+    includeData: "Table data (INSERT)",
+    includeObjects: "Views / Procedures / Functions / Sequences",
+    databaseSelection: "Databases",
+    selectedDatabases: "{selected}/{total} selected",
+    selectAllDatabases: "Select all",
+    filterDatabases: "Search databases...",
+    clearDatabases: "Clear",
+    tableSelection: "Tables",
+    selectedTables: "{selected}/{total} selected",
+    selectAllTables: "Select all",
+    filterTables: "Search tables...",
+    clearTables: "Clear",
+    loadingTables: "Loading tables...",
+    tableLoadError: "Failed to load tables: {error}",
+    noTables: "No tables found",
+    export: "Export",
+    exportAllDatabases: "Export All Databases",
+    exporting: "Exporting...",
+    selectExportDirectory: "Select export directory",
+    currentDatabase: "Database {current}/{total}",
+    currentTable: "Current: {table} ({current}/{total})",
+    rowsExported: "{count} rows exported",
+    exportSuccess: "Database exported successfully",
+    exportAllSuccess: "{count} databases exported successfully",
+    allDatabasesTask: "All databases ({count})",
+    exportError: "Export failed: {error}",
+    exportCancelled: "Export cancelled",
+    runInBackground: "Run in background",
+  },
+  mqTopics: {
+    title: "Topics",
+    searchPlaceholder: "Search topics",
+    includeNonPersistent: "Include non-persistent topics",
+    refresh: "Refresh",
+    refreshing: "Refreshing...",
+    createTopic: "Create Topic",
+    selectTenantNamespace: "Select a tenant and namespace first",
+    loading: "Loading...",
+    noTopics: "No topics in this namespace",
+    noMatches: "No matching topics",
+    name: "Name",
+    type: "Type",
+    partitions: "Partitions",
+    actions: "Actions",
+    nonPersistent: "Non-persistent",
+    partitionedTopic: "Partitioned topic",
+    normalTopic: "Normal topic",
+    partitionCount: "{count} partitions",
+    partitionsUnknown: "Unknown partitions",
+    adjustPartitions: "Adjust partitions",
+    delete: "Delete",
+    tenantNamespace: "Tenant / Namespace",
+    topicName: "Topic name",
+    topicNamePlaceholder: "e.g. my-topic",
+    persistentRecommended: "Persistent topic (recommended)",
+    persistentHint: "Persistent topics store messages on disk; non-persistent topics only keep them in memory.",
+    enablePartitions: "Enable partitions",
+    partitionQuantity: "Partition count",
+    partitionHint: "Partitions can improve concurrency but increase resource usage.",
+    cancel: "Cancel",
+    create: "Create",
+    updatePartitionsTitle: "Adjust partitions: {name}",
+    currentPartitions: "Current partitions",
+    newPartitions: "New partitions",
+    partitionMinHint: "Partitions can only be increased, not decreased. Minimum: {min}",
+    update: "Update",
+    readOnly: "This connection is read-only and cannot perform write operations.",
+    topicNameRequired: "Topic name is required",
+    currentPartitionsUnknown: "Current partition count is unknown, so partitions cannot be adjusted safely.",
+    partitionMustIncrease: "New partition count must be greater than the current partition count.",
+    confirmDelete: 'Delete topic "{name}"? This action cannot be undone.',
+  },
+  nacos: {
+    configs: "Configs",
+    services: "Services",
+    raw: "Raw",
+    namespace: "Namespace",
+    createNamespace: "Create Namespace",
+    editNamespace: "Edit Namespace",
+    creatingNamespace: "Creating...",
+    updatingNamespace: "Updating...",
+    namespaceCreated: 'Namespace "{name}" created',
+    namespaceUpdated: 'Namespace "{name}" updated',
+    namespaceId: "Namespace ID",
+    namespaceIdPlaceholder: "Leave empty for Nacos to generate",
+    namespaceName: "Namespace Name",
+    namespaceNamePlaceholder: "Enter a namespace name",
+    namespaceDesc: "Description",
+    namespaceDescPlaceholder: "Defaults to namespace name",
+    dataId: "Data ID",
+    group: "Group",
+    format: "Format",
+    content: "Content",
+    tags: "Tags",
+    application: "Application",
+    description: "Description",
+    advanced: "Advanced",
+    collapse: "Collapse",
+    load: "Load",
+    save: "Save",
+    saveAs: "Save as",
+    saving: "Saving...",
+    saved: "Config saved",
+    createdAndLoaded: "Created and loaded {dataId}",
+    savedAndLoaded: "Saved and refreshed {dataId}",
+    deleted: "Config deleted",
+    delete: "Delete",
+    copy: "Copy",
+    copied: "Copied",
+    copyVerifyFailed: "Clipboard verification failed after writing",
+    export: "Export",
+    exported: "Exported",
+    exportedTo: "Exported to {path}",
+    exportFailed: "Export failed: {message}",
+    history: "History",
+    configHistory: "Config history",
+    historyDetail: "History detail",
+    historyCompareTitle: "History Version Compare",
+    currentPublishedContent: "Current published content:",
+    historyVersionContent: "History version content:",
+    updatedAt: "Updated at",
+    operationType: "Operation",
+    operator: "Operator",
+    view: "View",
+    compare: "Compare",
+    rollback: "Rollback",
+    loadingHistory: "Loading history...",
+    noHistory: "No history versions",
+    noHistoryHint: "Refresh if this config was just published. Some Nacos versions may not expose history APIs.",
+    historyCreate: "Create",
+    historyUpdate: "Update",
+    historyDelete: "Delete",
+    historyRollback: "Rollback",
+    confirmRollbackTitle: "Rollback Nacos config",
+    confirmRollbackMessage: "This will roll the current config back to the selected history version.",
+    rollbackSuccess: "Config rolled back",
+    publish: "Publish",
+    dataIdRequired: "Data ID is required",
+    allGroups: "All groups",
+    noConfigs: "No configs",
+    selectConfig: "Select or create a config",
+    noServices: "No services",
+    selectService: "Select a service",
+    service: "Service",
+    instances: "Instances",
+    instanceCount: "{count} instances",
+    refresh: "Refresh",
+    address: "Address",
+    cluster: "Cluster",
+    weight: "Weight",
+    state: "State",
+    actions: "Actions",
+    query: "Query",
+    body: "Body",
+    response: "Response",
+    template: "Template",
+    configDiffTitle: "Config Content Compare",
+    inlineCompare: "Inline compare",
+    currentVersionContent: "Current official version:",
+    publishVersionContent: "This release content:",
+    confirmSaveTitle: "Review Nacos config changes",
+    confirmSaveMessage: "Save this config change? +{added} / -{removed} changed lines.",
+    confirmDeleteTitle: "Delete Nacos config",
+    confirmDeleteMessage: "This removes the selected config from Nacos.",
+    confirmInstanceTitle: "Update Nacos instance",
+    confirmInstanceMessage: "Confirm the target service instance state.",
+    confirmRawTitle: "Send mutating Raw API request",
+    confirmRawMessage: "This Raw API request can modify Nacos state.",
+    rawTemplate: {
+      serverState: "Server state",
+      namespaceList: "Namespace list",
+      configDetail: "Config detail",
+      serviceList: "Service list",
+      instanceList: "Instance list",
+    },
+    healthy: "Healthy",
+    unhealthy: "Unhealthy",
+    enabled: "Enabled",
+    offline: "Offline",
+    ephemeral: "Ephemeral",
+    persistent: "Persistent",
+    enable: "Enable",
+    disable: "Disable",
+    markHealthy: "Healthy",
+    markUnhealthy: "Unhealthy",
+    send: "Send",
+    total: "{count} total",
+    prev: "Prev",
+    next: "Next",
+    test: "Test",
+    readOnly: "Read only",
+  },
+};
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
new file mode 100644
index 0000000..e0eaad3
--- /dev/null
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -0,0 +1,3822 @@
+import { withEnglishFallback } from "./fallback";
+
+export default withEnglishFallback({
+  app: {
+    name: "DBX",
+  },
+  auth: {
+    setupTitle: "Configurar contraseña de acceso",
+    setupDescription: "Establece una contraseña para proteger tu instancia",
+    loginDescription: "Herramienta de administración de bases de datos",
+    newPassword: "Ingresa la nueva contraseña",
+    confirmPassword: "Confirmar contraseña",
+    enterPassword: "Ingresa la contraseña de acceso",
+    passwordMismatch: "Las contraseñas no coinciden",
+    setPassword: "Establecer contraseña",
+    login: "Iniciar sesión",
+    processing: "Procesando...",
+    loginFailed: "Contraseña incorrecta",
+    connectFailed: "Error de conexión",
+    changePassword: "Cambiar contraseña",
+    oldPassword: "Contraseña actual",
+    oldPasswordWrong: "La contraseña actual es incorrecta",
+    passwordChanged: "Contraseña cambiada exitosamente",
+    changePasswordFailed: "Error al cambiar la contraseña",
+    changePasswordDescription: "Ingresa tu contraseña actual y elige una nueva",
+  },
+  toolbar: {
+    newConnection: "Nueva conexión",
+    newQuery: "Nueva consulta",
+    execute: "Ejecutar",
+    executeShortcut: "Ejecutar selección/consulta (Cmd+Enter)",
+    stopQuery: "Detener consulta",
+    explainPlan: "Plan de ejecución",
+    stopExplain: "Detener análisis",
+    formatSql: "Formatear SQL",
+    formatSqlFailed: "Error al formatear el SQL",
+    keywordCaseLower: "Usar palabras clave SQL en minúsculas",
+    keywordCaseUpper: "Usar palabras clave SQL en mayúsculas",
+    autoCommit: "Auto Commit",
+    manualTransaction: "Transacción Manual",
+    autoCommitAgent: "Auto Commit (depende del backend del Agente)",
+    manualTransactionAgent: "Transacción Manual (depende del backend del Agente)",
+    commit: "Confirmar",
+    rollback: "Revertir",
+    txnAutoRolledBack: "Transacción revertida automáticamente tras 5 minutos de inactividad",
+    previewSql: "Vista previa de SQL",
+    hidePreviewSql: "Ocultar vista previa de SQL",
+    saveSql: "Guardar en biblioteca SQL",
+    openSql: "Abrir archivo SQL",
+    exPasteSqlInCondition: "ExPaste: pegar como condición IN",
+    theme: "Tema",
+    themeLight: "Claro",
+    themeDark: "Oscuro",
+    themeSystem: "Seguir sistema",
+    sqlSaved: "SQL guardado",
+    sqlOpenFailed: "Error al abrir el archivo: {message}",
+    sqlSaveFailed: "Error al guardar el archivo: {message}",
+    driverManager: "Administrador de drivers",
+    updatableDriverCount: "Cantidad de drivers actualizables",
+    blockDangerousRedisCommands: "Bloquear comandos peligrosos",
+  },
+  updates: {
+    title: "Actualizaciones",
+    check: "Buscar actualizaciones",
+    availableTitle: "Actualización disponible",
+    availableMessage: "DBX {latest} está disponible. Estás usando la versión {current}.",
+    upToDate: "DBX está actualizado ({version}).",
+    failed: "Error al buscar actualizaciones: {error}",
+    rateLimited: "Las verificaciones de actualizaciones de GitHub están temporalmente limitadas. Puedes abrir la página de lanzamientos para verificar manualmente.",
+    openRelease: "Abrir lanzamiento",
+    downloadAndInstall: "Descargar e instalar",
+    portableManualUpdate: "Las versiones portables no pueden usar el instalador integrado. Descarga el ZIP portable desde la página de lanzamiento y extráelo sobre la carpeta actual de DBX para conservar portable.dbx y data.",
+    downloading: "Descargando {progress}%",
+    downloadFailed: "Error al descargar la actualización: {error}",
+    restart: "Salir y reiniciar",
+    restartFailed: "Error al reiniciar la aplicación: {error}",
+    exitAndUpdate: "Salir y actualizar",
+    dockerUsersRun: "Los usuarios de Docker deben ejecutar",
+    toUpdate: "para actualizar",
+  },
+  sidebar: {
+    connections: "CONEXIONES",
+    noConnections: "Sin conexiones",
+    import: "Importar conexiones",
+    importDbx: "Importar configuración DBX",
+    importNavicat: "Importar Navicat NCX",
+    importDbeaver: "Importar DBeaver",
+    importDatagrip: "Importar DataGrip",
+    export: "Exportar conexiones",
+    collapseAll: "Contraer todo",
+    collapse: "Contraer barra lateral",
+    expand: "Expandir barra lateral",
+    showMore: "Mostrar {count} más...",
+    filterByType: "Filtrar por tipo",
+    searchScopeConnection: "Conexión",
+    searchScopeDatabase: "Base de datos",
+    searchScopeSchema: "Schema",
+    searchScopeTable: "Tabla",
+    searchScopeView: "Vista",
+    searchTablesInCurrentScope: "Buscar tablas en esta base de datos...",
+    clearTableSearch: "Limpiar búsqueda de tablas",
+    clearFilter: "Limpiar filtro",
+    locateActiveTab: "Localizar en la barra lateral",
+  },
+  savedSql: {
+    saveToLibrary: "Guardar en biblioteca SQL",
+    saveToFile: "Guardar localmente",
+    save: "Guardar",
+    saved: "SQL guardado",
+    saveFailed: "Error al guardar el SQL: {message}",
+    fileName: "Nombre de archivo",
+    folder: "Carpeta",
+    rootFolder: "Biblioteca SQL",
+    newQuery: "Nueva consulta",
+    newFolder: "Nueva carpeta SQL",
+    newFolderDefault: "Nueva carpeta",
+    renameFolder: "Renombrar carpeta",
+    deleteFolder: "Eliminar carpeta",
+    deleteFolderConfirm: "¿Eliminar “{name}” y los archivos SQL que contiene?",
+    open: "Abrir SQL",
+    renameFile: "Renombrar SQL",
+    deleteFile: "Eliminar SQL",
+    deleteFileConfirm: "¿Eliminar “{name}”?",
+  },
+  sqlLibrary: {
+    title: "Biblioteca SQL",
+    empty: "Sin consultas guardadas",
+    emptyFolder: "Carpeta vacía",
+    unfiled: "Sin categoría",
+    exportFile: "Exportar SQL",
+    exportFolder: "Exportar carpeta",
+    exportLibrary: "Exportar biblioteca SQL",
+    importDirectory: "Importar carpeta local",
+    importIntoFolder: "Importar a esta carpeta",
+    openStorageDirectory: "Abrir directorio de SQL",
+    chooseSyncDirectory: "Definir directorio de sincronización local",
+    disableSyncDirectory: "Desactivar sincronización local",
+    syncDirectorySaved: "Directorio de sincronización local de SQL guardado",
+    syncDirectoryDisabled: "Sincronización local de SQL desactivada",
+    syncDirectoryFailed: "Error al definir el directorio de sincronización: {message}",
+    openDirectoryFailed: "Error al abrir el directorio: {message}",
+    noSyncDirectory: "Primero defina un directorio de sincronización local",
+    exported: "Exportado",
+    exportFailed: "Error al exportar: {message}",
+    importFailed: "Error al importar: {message}",
+    importNone: "No se encontraron archivos .sql en la carpeta seleccionada",
+    imported: "Se importaron {count} archivos SQL",
+    desktopOnly: "Esta función solo está disponible en escritorio",
+    noConnection: "No hay conexión disponible para importar",
+    batchDelete: "Eliminación por lotes",
+    batchDeleteConfirm: "¿Está seguro de que desea eliminar {count} elementos seleccionados? Esta acción no se puede deshacer.",
+    batchDeleteSuccess: "Se eliminaron {count} elementos con éxito",
+    moveToFolder: "Mover a carpeta...",
+    moveSelectedToFolder: "Mover {count} SQL a carpeta...",
+    moveSuccess: "Se movieron {count} SQL",
+    clearSelection: "Limpiar selección",
+    sortByDate: "Ordenar por fecha de modificación",
+    sortByFolder: "Ordenar por estructura de carpetas",
+  },
+
+  connection: {
+    title: "Nueva conexión",
+    name: "Nombre",
+    namePlaceholder: "Nombre de conexión, se genera automáticamente si está vacío",
+    type: "Tipo",
+    host: "Host",
+    filePath: "Ruta del archivo",
+    h2FileMode: "Archivo",
+    h2TcpMode: "TCP",
+    h2FilePathRequired: "La ruta del archivo H2 no puede estar vacía",
+    createDuckDbFile: "Crear archivo DuckDB",
+    createSqliteFile: "Crear base de datos SQLite",
+    memoryDatabasePathHint: "Usa :memory: para crear una base de datos SQLite o DuckDB en memoria.",
+    sqliteCipherKey: "Clave SQLCipher",
+    sqliteCipherKeyPlaceholder: "Déjalo vacío para SQLite sin cifrar",
+    sqliteExtensions: "Extensiones de SQLite",
+    sqliteExtensionsPlaceholder: "/ruta/a/regexp.dylib\n/ruta/a/text.dylib|sqlite3_text_init",
+    sqliteExtensionsHint: 'Una .dylib/.so/.dll por línea. Usa "ruta|punto de entrada" cuando se requiera un punto de entrada. Se cargan al conectar, luego load_extension se deshabilita.',
+    sqliteExtensionBrowse: "Seleccionar extensión de SQLite",
+    user: "Usuario",
+    password: "Contraseña",
+    database: "Base de datos",
+    databasePlaceholder: "Opcional",
+    databasePlaceholderRequired: "Obligatorio, ingresa una base de datos existente",
+    databasePlaceholderWithDefault: "Opcional, por defecto {database}",
+    kingbaseDatabaseRequired: "Kingbase requiere una base de datos existente antes de conectar o cargar la lista de bases de datos.",
+    defaultDatabase: "BD predeterminada",
+    authDatabase: "BD de autenticación",
+    authDatabasePlaceholder: "Opcional, normalmente admin",
+    authMechanism: "Mecanismo de autenticación",
+    authMechanismDefault: "Predeterminado",
+    driverMode: "Controlador",
+    mongoDriverAuto: "Automático",
+    mongoDriverLegacy: "Legacy",
+    serviceName: "Servicio/SID",
+    serviceNameOnly: "Nombre de servicio",
+    version: "Versión",
+    driverInstallHintPrefix: "Instala el driver requerido desde ",
+    driverInstallHintSuffix: " en la barra superior antes de conectar.",
+    driverName: "Nombre del driver",
+    driverNamePlaceholder: "Nombre del proveedor o entorno",
+    urlParams: "Parámetros de URL",
+    d1AccountId: "ID de cuenta",
+    d1DatabaseId: "ID de base de datos",
+    d1ApiToken: "Token de API",
+    d1TokenHint: "El token necesita al menos el permiso D1 Read; las escrituras, el DDL y las importaciones también requieren D1 Write.",
+    d1FieldsRequired: "Se requieren el ID de cuenta de Cloudflare, el ID de la base de datos D1 y el token de API.",
+    gbaseServer: "GBASEDBTSERVER",
+    informixServer: "INFORMIXSERVER",
+    sslEnable: "Habilitar conexión cifrada",
+    caCertPath: "Certificado CA",
+    caCertPathPlaceholder: "Opcional, p. ej. ~/.yandex/RootCA.crt",
+    caCertPathBrowse: "Buscar certificado",
+    redisTlsInsecure: "Omitir verificación del certificado",
+    redisTlsInsecureHint: "Equivale a redis-cli --tls --insecure, para certificados autofirmados o CA privadas.",
+    mysqlTlsMode: "Modo TLS",
+    mysqlTlsModePreferred: "Preferido",
+    mysqlTlsModeDisabled: "Deshabilitado",
+    mysqlTlsModeRequired: "Requerido",
+    mysqlTlsModeVerifyCa: "Verificar CA",
+    mysqlTlsModeVerifyIdentity: "Verificar identidad",
+    mysqlCleartextPasswordAuth: "Autenticación de contraseña en claro",
+    mysqlCleartextPasswordAuthHint: "Actívala solo cuando el servidor MySQL requiera el plugin de autenticación de contraseña en claro.",
+    mysqlCaCertHint: "Requerido para Verificar CA e Identidad cuando el certificado usa una CA privada.",
+    mysqlClientCert: "Autenticación cliente",
+    mysqlClientCertPlaceholder: "/ruta/a/client.crt",
+    mysqlClientKeyPlaceholder: "/ruta/a/client.key",
+    mysqlClientCertHint: "El certificado y la clave privada deben indicarse juntos si MySQL requiere mTLS.",
+    mysqlTlsConnectionFailureHint: "Si el servidor MySQL no requiere TLS, edita la conexión, establece el Modo TLS en Deshabilitado e inténtalo de nuevo.",
+    mysqlClientCertBrowse: "Elegir certificado cliente",
+    mysqlClientKeyBrowse: "Elegir clave privada cliente",
+    postgresSslMode: "Modo TLS",
+    postgresSslModeDisable: "Deshabilitar",
+    postgresSslModePrefer: "Preferir",
+    postgresSslModeRequire: "Requerir",
+    postgresSslModeVerifyCa: "Verificar CA",
+    postgresSslModeVerifyFull: "Verificar completo",
+    postgresServerCert: "CA del servidor",
+    postgresRootCertPlaceholder: "/ruta/a/ca.crt",
+    postgresRootCertHint: "Úsalo con verify-ca o verify-full cuando el certificado del servidor use una CA privada.",
+    postgresRootCertBrowse: "Elegir certificado CA",
+    postgresClientCert: "Autenticación cliente",
+    postgresClientCertPlaceholder: "/ruta/a/client.crt",
+    postgresClientKeyPlaceholder: "/ruta/a/client.key",
+    postgresClientCertHint: "El certificado y la clave privada deben indicarse juntos si PostgreSQL requiere mTLS.",
+    postgresClientCertBrowse: "Elegir certificado cliente",
+    postgresClientKeyBrowse: "Elegir clave privada cliente",
+    connectionUrlOptional: "URL (opcional)",
+    connectionUrlPlaceholder: "postgresql://usuario:contraseña{'@'}host:5432/db?sslmode=require",
+    parseConnectionUrl: "Analizar URL de conexión",
+    parseConnectionUrlApplied: "URL de conexión aplicada",
+    parseConnectionUrlFailed: "Error al analizar la URL de conexión: {message}",
+    mode: "Modo de conexión",
+    modeForm: "Formulario",
+    redisStandaloneMode: "Directa",
+    redisSentinelMode: "Sentinel",
+    redisClusterMode: "Cluster",
+    oceanbaseMySQLMode: "Modo MySQL",
+    oceanbaseOracleMode: "Modo Oracle",
+    redisFirstSentinel: "Primer Sentinel",
+    redisFirstClusterNode: "Primer nodo semilla",
+    redisSentinelNodes: "Nodos Sentinel",
+    redisClusterNodes: "Nodos semilla del cluster",
+    redisSentinelMaster: "Nombre del master",
+    redisSentinelUser: "Usuario Sentinel",
+    redisSentinelPassword: "Contraseña Sentinel",
+    redisSentinelTls: "TLS Sentinel",
+    redisSentinelTlsHint: "Usar TLS al conectar con nodos Sentinel",
+    redisKeySeparator: "Separador de espacio de nombres de clave",
+    etcdEndpoints: "Endpoints",
+    etcdEndpointsHint: "Una entrada por línea. Déjalo en blanco para usar el host y puerto de arriba.",
+    etcdCaCertPlaceholder: "/ruta/a/ca.crt",
+    etcdCaCertBrowse: "Elegir certificado CA",
+    etcdClientAuth: "Autenticación de cliente",
+    etcdClientCertPlaceholder: "/ruta/a/client.crt",
+    etcdClientKeyPlaceholder: "/ruta/a/client.key",
+    etcdClientCertHint: "El certificado y la clave privada deben proporcionarse juntos cuando etcd requiere mTLS.",
+    etcdClientCertBrowse: "Elegir certificado de cliente",
+    etcdClientKeyBrowse: "Elegir clave privada de cliente",
+    etcdClientCertPairRequired: "El certificado y la clave privada deben proporcionarse juntos.",
+    zookeeperConnectString: "Cadena de conexión",
+    zookeeperConnectStringHint: "Entradas host:puerto separadas por coma o por línea. Déjalo en blanco para usar el host y puerto de arriba.",
+    zookeeperCreateModePersistent: "Persistente",
+    zookeeperCreateModeEphemeral: "Efímero",
+    zookeeperCreateModePersistentSequential: "Persistente secuencial",
+    zookeeperCreateModeEphemeralSequential: "Efímero secuencial",
+    nacosConsoleUrl: "URL de consola",
+    nacosConsoleUrlHint: "Usa la dirección de consola/admin API de Nacos. Nacos 3 Docker normalmente expone la consola en 8085; despliegues antiguos pueden compartir 8848 con el puerto de servicio.",
+    nacosConsoleUrlRequired: "La URL de consola de Nacos es obligatoria",
+    nacosConsoleUrlAutoAdjusted: "URL de consola de Nacos ajustada de {from} a {to}.",
+    nacosNamespace: "Namespace",
+    nacosContextPath: "Context Path",
+    nacosContextPathPlaceholder: "Dejar vacío o /nacos",
+    nacosAuth: "Autenticación",
+    nacosAuthNone: "Ninguna",
+    nacosAuthUserPassword: "Usuario / Contraseña",
+    nacosUsernameRequired: "El usuario de Nacos es obligatorio",
+    nacosTls: "TLS",
+    nacosTlsSkipVerify: "Omitir verificación de certificado",
+    nacosPageSize: "Tamaño de página",
+    searchDatabasePlaceholder: "Buscar tipos de bases de datos",
+    iconView: "Vista de íconos",
+    listView: "Vista de lista",
+    selectedDatabase: "Seleccionada",
+    noDatabaseMatches: "Sin bases de datos coincidentes",
+    next: "Siguiente",
+    back: "Anterior",
+    basicTab: "Conexión",
+    tlsTab: "TLS/SSL",
+    test: "Probar",
+    testing: "Probando...",
+    copyTestResult: "Copiar resultado de prueba",
+    sqlServerLegacyCompatibilityMode: "Modo de compatibilidad heredado",
+    sqlServerLegacyCompatibilityModeEnable: "Usar conexión de compatibilidad heredada de SQL Server",
+    sqlServerLegacyCompatibilityModeEnabled: "El modo de compatibilidad heredado de SQL Server está activado.",
+    sqlServerLegacyCompatibilityModeHint:
+      "Aplica a escenarios sin cifrado, con cifrado solo en el login o con compatibilidad heredada TLS 1.0. Si el componente de compatibilidad no está instalado, DBX lo instala antes de activar este modo.\nAl usar el componente de compatibilidad como fallback, algunas funciones nativas de SQL Server pueden no estar disponibles.\nÚsalo solo en redes de confianza, VPN o túneles SSH",
+    sqlServerLegacyCompatibilityComponent: "Componente de compatibilidad heredada de SQL Server",
+    sqlServerLegacyCompatibilityComponentInstalling: "Instalando componente de compatibilidad heredada de SQL Server...",
+    saveAndConnect: "Guardar y conectar",
+    save: "Guardar",
+    editTitle: "Editar conexión",
+    testSuccess: "Conexión exitosa",
+    connecting: "Conectando a {name}...",
+    connectSuccess: "Conectado a {name}",
+    connectFailed: "Error de conexión: {message}",
+    driverNotInstalled: "El controlador {driver} no está instalado. Instálelo desde el Administrador de controladores.",
+    jreNotInstalled: "El entorno JRE {jre} no está instalado. Instálelo desde el Administrador de controladores.",
+    systemJavaNotFound: "No se encontró Java en el PATH del sistema. Instale Java o elija un ejecutable personalizado.",
+    customJavaPathEmpty: "La ruta de Java personalizada está vacía. Elija un ejecutable de Java.",
+    agentJavaTooOld: "Este controlador requiere Java 21. Use el JRE 21 administrado por DBX o seleccione un ejecutable Java 21 en el Administrador de controladores.",
+    agentDriverUpdateConnectionHint:
+      "Hay una actualización de controlador integrada disponible para esta conexión. El error de conexión puede estar relacionado con un controlador local desactualizado. Actualiza el controlador correspondiente en el Administrador de controladores y vuelve a intentarlo.",
+    jdbcPluginNotInstalled: "El plugin JDBC no está instalado. Instale el plugin JDBC opcional para usar esta conexión.",
+    lastError: "Error de conexión",
+    clearError: "Limpiar error de conexión",
+    saveFailed: "Error al guardar la conexión: {message}",
+    deleted: "Conexión eliminada",
+    deletedSelected: "{count} conexiones eliminadas",
+    copied: "Copiado",
+    disconnected: "Desconectado",
+    databaseConnectionClosed: "Conexión de base de datos cerrada: {name}",
+    duplicated: "Conexión duplicada",
+    duplicatedSelected: "{count} conexiones duplicadas",
+    groupDeleted: "Grupo eliminado",
+    loadFailed: "Error al cargar las conexiones guardadas: {message}",
+    sshTunnel: "Túnel SSH / Proxy",
+    advancedTab: "Avanzado",
+    sshEnable: "Usar túnel SSH / proxy",
+    sshHost: "Host SSH",
+    sshHostPlaceholder: "ssh.example.com o un alias de ~/.ssh/config",
+    sshUser: "Usuario SSH",
+    sshAuthMethod: "Método de acceso",
+    sshAuthMethodPassword: "Contraseña",
+    sshAuthMethodKey: "Clave privada",
+    sshAuthMethodNone: "Ninguno",
+    sshAuthMethodNoneHint: "No se enviarán credenciales. Úsalo para bastiones o proxies que aceptan conexiones sin autenticación.",
+    sshAuthMethodAgentLegacy: "SSH Agent (heredado)",
+    sshPassword: "Contraseña SSH",
+    sshPasswordPlaceholder: "Dejar vacío para usar clave",
+    sshKeyPath: "Ruta de clave",
+    sshKeyPassphrase: "Frase de clave",
+    sshKeyPassphrasePlaceholder: "Dejar vacío si la clave no está cifrada",
+    sshKeyPathBrowse: "Examinar",
+    sshExposeLan: "Exponer túnel a la red local",
+    sshConnectTimeout: "Tiempo de espera SSH (segundos)",
+    sshHops: "Capas de túnel SSH / proxy",
+    sshHopAdd: "Agregar capa SSH",
+    sshHopDuplicate: "Duplicar",
+    sshHopDelete: "Eliminar",
+    sshHopMoveUp: "Subir",
+    sshHopMoveDown: "Bajar",
+    sshHopName: "Nombre de la capa",
+    sshHopNamePlaceholder: "Bastión, jump host, puerta de producción",
+    sshHopDefaultName: "Capa {index}",
+    sshHopInvalidHost: "{hop}: el host SSH es obligatorio",
+    sshHopInvalidUser: "{hop}: el usuario SSH es obligatorio",
+    sshHopInvalidPort: "{hop}: el puerto SSH debe estar entre 1 y 65535",
+    sshHopInvalidAuth: "{hop}: se requiere contraseña, ruta de clave o ssh-agent",
+    sshUseAgent: "Usar ssh-agent",
+    sshAgentSockPath: "Ruta del socket del agente",
+    sshAgentSockPathPlaceholder: "ej. ~/.ssh/agent.sock",
+    sshHopInvalidTimeout: "{hop}: el tiempo de espera SSH debe estar entre 1 y 300 segundos",
+    connectTimeout: "Tiempo de espera de conexión (segundos)",
+    queryTimeout: "Tiempo de espera de consulta (segundos)",
+    idleTimeout: "Tiempo de espera inactivo (segundos)",
+    keepaliveInterval: "Intervalo de keepalive (segundos)",
+    readOnly: "Solo lectura",
+    readOnlyHint: "Bloquear todas las operaciones de escritura (INSERT, UPDATE, DELETE, etc.)",
+    readOnlyBadge: "Solo lectura",
+    proxy: "Proxy",
+    proxyEnable: "Conectar la base de datos mediante proxy",
+    proxyType: "Tipo de proxy",
+    proxyHost: "Host del proxy",
+    proxyUsername: "Usuario del proxy",
+    proxyUsernamePlaceholder: "Opcional",
+    proxyPassword: "Contraseña del proxy",
+    proxyPasswordPlaceholder: "Opcional",
+    tunnelProfile: "Perfil de túnel",
+    tunnelProfileCustom: "Personalizado (solo esta conexión)",
+    tunnelProfileManaged: "Gestionado por un perfil de túnel compartido. Edítalo en Ajustes > Túneles; los cambios se aplican a todas las conexiones que lo usan en su próxima conexión.",
+    tunnelProfileMissing: "El perfil de túnel referenciado ya no existe. Selecciona otro perfil o cambia a personalizado.",
+    tunnelProfileMissingName: "Perfil de túnel no encontrado",
+    tunnelProfileManage: "Gestionar",
+    dremioArrowFlightSqlMode: "Arrow Flight SQL",
+    dremioLegacyJdbcMode: "JDBC heredado",
+    jdbcUrl: "URL JDBC",
+    jdbcUrlPlaceholder: "jdbc:postgresql://localhost:5432/base_de_datos",
+    jdbcDriverClass: "Clase del driver (opcional)",
+    jdbcDriverClassPlaceholder: "La mayoría de los drivers se registran automáticamente; usa com.vendor.jdbc.Driver si es necesario",
+    jdbcDriverPaths: "JARs del driver JDBC",
+    jdbcDriverSelectPlaceholder: "Seleccionar driver importado",
+    jdbcManualClasspath: "Classpath manual",
+    jdbcManualClasspathCount: "{count} rutas",
+    jdbcDriverPathsPlaceholder: "/ruta/al/driver.jar\n/ruta/a/otro-driver.jar",
+    jdbcDriverBrowse: "Seleccionar JAR del driver JDBC",
+    jdbcDocs: "Ver documentación JDBC",
+    jdbcPluginHint: "Instala primero el plugin JDBC de DBX y luego importa el JAR del driver JDBC del proveedor.",
+    dmCompatHint: "Requiere el driver ODBC DM8 instalado en el sistema.",
+    dmDownload: "Descargar desde Dameng",
+    mongoLegacyHint: "Usa Legacy para servidores MongoDB antiguos, especialmente versiones anteriores a 4.2. Si falla la autenticación y el usuario se creó en admin, define Auth DB como admin.",
+    mongoTlsAllowInvalidCertificates: "Desactivar verificación de certificado TLS",
+    mongoTlsAllowInvalidCertificatesHint: "Se asigna a tlsAllowInvalidCertificates=true y desactiva toda la validación de certificados, no solo la del nombre de host. Aumenta el riesgo de MITM. Suele ser necesario para AWS DocumentDB a través de un túnel SSH.",
+    mongoRetryWrites: "Reintentar escrituras",
+    mongoRetryWritesHint: "Se asigna a retryWrites. Desactívalo para AWS DocumentDB, que no admite escrituras reintentables.",
+    compatible: "Compatible",
+    mainstream: "Popular",
+    color: "Color",
+    colorNone: "Sin color",
+    colorGreen: "Verde",
+    colorYellow: "Amarillo",
+    colorOrange: "Naranja",
+    colorRed: "Rojo",
+    colorBlue: "Azul",
+    colorPurple: "Morado",
+    colorCustom: "Color personalizado",
+    cancelConnecting: "Cancelar conexión",
+    connectCancelled: "Conexión cancelada",
+    kafkaKerberosPrincipal: "Principal",
+    kafkaKerberosKeytab: "Keytab",
+    kafkaKerberosServiceName: "Nombre del servicio",
+    kafkaKerberosKrb5Conf: "krb5.conf",
+    kafkaKerberosPrincipalRequired: "Kafka Kerberos principal no puede estar vacío",
+    kafkaKerberosKeytabRequired: "La ruta del keytab de Kafka Kerberos no puede estar vacía",
+    kafkaKerberosKeytabBrowse: "Elegir Keytab",
+    kafkaKerberosKrb5ConfBrowse: "Elegir krb5.conf",
+    kafkaKerberosKeytabPlaceholder: "Ruta en la máquina donde se ejecuta DBX Agent, por ejemplo /etc/security/keytabs/user.keytab",
+    kafkaKerberosKrb5ConfPlaceholder: "Opcional, ruta en la máquina donde se ejecuta DBX Agent, por ejemplo /etc/krb5.conf",
+    kafkaKerberosPathHint: "Las rutas de keytab y krb5.conf son leídas por DBX Agent y deben existir en la máquina donde se ejecuta DBX Agent; no se subirán archivos desde el navegador actual.",
+    kafkaKerberosAuthHint: "Iniciar sesión con GSSAPI + keytab. Si el servidor requiere transmisión cifrada, configure Security como SASL_SSL; de lo contrario, puede usar Auto o SASL_PLAINTEXT.",
+  },
+  editor: {
+    pressToExecute: "Presiona {mod}+Enter para ejecutar",
+    pressToSaveSql: "Presiona {mod}+S para guardar el SQL",
+    queryTimeoutError: "La consulta agotó el tiempo ({seconds}s). Comprueba la conexión a la base de datos.",
+    changeQueryTimeout: "Cambiar tiempo de espera de consulta",
+    connectionMayBeLost: "Es posible que la conexión se haya perdido. Actualiza los datos e inténtalo de nuevo.",
+    showResultsPane: "Mostrar resultados",
+    hideResultsPane: "Ocultar resultados",
+    noDatabase: "Sin base de datos seleccionada",
+    unsavedChangesTitle: "Cambios sin guardar",
+    unsavedChangesMessage: '"{title}" tiene cambios sin guardar que se perderán si se cierra. ¿Guardar antes de cerrar?',
+    unsavedChangesBatchCloseMessage: "Algunas pestañas que vas a cerrar tienen cambios sin guardar que se perderán. ¿Guardar antes de continuar?",
+    unsavedChangesBatchCloseMultipleMessage: '{count} pestañas SQL que vas a cerrar tienen cambios sin guardar. DBX muestra actualmente "{title}". ¿Guardar antes de continuar?',
+    unsavedChangesAppCloseMessage: '"{title}" tiene cambios SQL sin guardar que se perderán si sales de DBX. ¿Guardar antes de salir?',
+    unsavedChangesAppCloseMultipleMessage: '{count} pestañas SQL tienen cambios sin guardar. DBX muestra actualmente "{title}". Se perderán si sales de DBX. ¿Guardar antes de salir?',
+    unsavedChangesViewList: "Ver {count} pestañas",
+    unsavedChangesListTitle: "Pestañas sin guardar ({count})",
+    discardChanges: "Descartar",
+    discardAllChanges: "Descartar todo",
+    saveAllChanges: "Guardar todo",
+    selectConnection: "Seleccionar conexión",
+    searchConnection: "Buscar conexiones...",
+    selectDatabase: "Seleccionar base de datos",
+    selectDatabaseRequired: "Selecciona una base de datos primero",
+    searchDatabase: "Buscar bases de datos...",
+    selectSchema: "Seleccionar esquema",
+    searchSchema: "Buscar esquemas...",
+    setDefaultDatabase: "Establecer como predeterminada",
+    defaultDatabase: "Predeterminada",
+    clearDatabase: "Limpiar base de datos",
+    exPasteNoValues: "El portapapeles no contiene valores para una condición IN",
+    exPasteNotList: "No se detectó una lista de varios valores convertible",
+    exPasteTooLarge: "El contenido del portapapeles es demasiado grande. Máximo {limit} caracteres.",
+    exPasteTooManyValues: "Demasiados valores. Máximo {limit}.",
+    exPasteClipboardReadFailed: "No se pudo leer el portapapeles: {message}",
+    exPastePasted: "Se pegaron {count} valores de condición IN",
+    completion: {
+      nullValue: "Valor NULL",
+      isNull: "Comprobar si es NULL",
+      isNotNull: "Comprobar si no es NULL",
+      stringLiteral: "Literal de cadena",
+      numericLiteral: "Literal numérico",
+      booleanValue: "Valor booleano",
+      starExpansionColumns: "{count} columnas",
+      functionDescriptions: {
+        COUNT: "Devuelve el número de filas",
+        SUM: "Devuelve la suma de una columna numérica",
+        AVG: "Devuelve el promedio de una columna numérica",
+        MIN: "Devuelve el valor mínimo",
+        MAX: "Devuelve el valor máximo",
+        GROUP_CONCAT: "Concatena valores de grupo en una cadena",
+        STRING_AGG: "Concatena cadenas de grupo",
+        CONCAT: "Concatena múltiples cadenas",
+        CONCAT_WS: "Concatena cadenas con separador",
+        SUBSTRING: "Extrae una subcadena",
+        REPLACE: "Reemplaza contenido en una cadena",
+        TRIM: "Elimina espacios al inicio y final",
+        UPPER: "Convierte a mayúsculas",
+        LOWER: "Convierte a minúsculas",
+        LENGTH: "Devuelve la longitud de la cadena",
+        REGEXP_REPLACE: "Reemplaza usando expresión regular",
+        DATE_FORMAT: "Formatea una fecha con el formato dado",
+        DATEDIFF: "Calcula la diferencia entre dos fechas",
+        DATE_ADD: "Añade un intervalo a una fecha",
+        DATE_SUB: "Resta un intervalo de una fecha",
+        EXTRACT: "Extrae una parte de la fecha",
+        NOW: "Devuelve la fecha y hora actual",
+        ROUND: "Redondea a los decimales especificados",
+        FLOOR: "Redondea hacia abajo",
+        CEIL: "Redondea hacia arriba",
+        ABS: "Devuelve el valor absoluto",
+        MOD: "Devuelve el resto de la división",
+        COALESCE: "Devuelve el primer argumento no NULL",
+        IFNULL: "Devuelve un valor de reemplazo si es NULL",
+        NULLIF: "Devuelve NULL si los argumentos son iguales",
+        CAST: "Convierte una expresión a un tipo de destino",
+        JSON_EXTRACT: "Extrae un valor de JSON",
+        JSON_VALUE: "Extrae un valor escalar de JSON",
+        JSON_OBJECT: "Crea un objeto JSON",
+        JSON_ARRAY: "Crea un array JSON",
+      },
+    },
+    contextMenu: {
+      executeSelection: "Ejecutar seleccion",
+      executeCurrent: "Ejecutar SQL",
+      copySelection: "Copiar seleccion",
+      sendToAi: "Enviar a IA",
+      uppercaseSelection: "Convertir a mayusculas",
+      lowercaseSelection: "Convertir a minusculas",
+      selectAll: "Seleccionar todo",
+    },
+    search: {
+      find: "Buscar",
+      replace: "Reemplazar",
+      replaceAll: "Reemplazar todo",
+      caseSensitive: "Distinguir mayúsculas",
+      regex: "Expresión regular",
+      collapseReplace: "Contraer reemplazo",
+      expandReplace: "Expandir reemplazo",
+      prevMatch: "Anterior (Shift+Enter)",
+      nextMatch: "Siguiente (Enter)",
+      close: "Cerrar (Esc)",
+      noResults: "Sin resultados",
+    },
+    executionPicker: {
+      title: "Execution Target",
+      currentStatement: "Current SQL",
+      allStatements: "All SQL",
+      currentCommand: "Current command",
+      allCommands: "All commands",
+    },
+  },
+  tabs: {
+    sql: "SQL",
+    table: "Tabla",
+    tableData: "Datos de tabla",
+    redis: "Redis",
+    etcd: "etcd",
+    zookeeper: "ZooKeeper",
+    vector: "Vector",
+    users: "Usuarios y Privilegios",
+    executionSummary: "Resumen",
+    mongo: "Mongo",
+    objects: "Objetos",
+    tooltipTitle: "Título:",
+    tooltipConnection: "Conexión:",
+    tooltipDatabase: "Base de datos:",
+    tooltipTable: "Tabla:",
+    tooltipCollection: "Colección:",
+    tooltipSchema: "Esquema:",
+    resultN: "Resultado {n}",
+    runN: "Ejecutar {n}",
+    resultRuns: "Ejecuciones de resultado",
+    removeRun: "Eliminar ejecución {n}",
+    autoKeepResults: "Conservar resultados automáticamente",
+    autoKeepResultsEnabled: "Conservación automática activada",
+    autoKeepResultsDisabled: "Conservación automática desactivada",
+    autoRefresh: "Actualizar resultados automáticamente",
+    autoRefreshShort: "Auto",
+    autoRefreshEvery: "Actualizar cada {seconds} s",
+    startAutoRefresh: "Iniciar actualización automática",
+    stopAutoRefresh: "Detener actualización automática",
+    missingResultRun: "Este resultado ya no está disponible",
+    exportResultArchive: "Guardar archivo de resultados",
+    importResultArchive: "Importar archivo de resultados",
+    importedResultArchive: "Resultados importados",
+    resultArchiveExported: "Resultados exportados",
+    resultArchiveImported: "Resultados importados",
+    resultArchiveUnavailable: "No hay resultados guardados disponibles para exportar",
+    resultArchiveImportInvalid: "No se pudo abrir este archivo de resultados",
+    resultArchiveExportFailed: "Error al exportar resultados: {message}",
+    resultArchiveImportFailed: "Error al importar resultados: {message}",
+    scrollLeft: "Desplazar pestañas a la izquierda",
+    scrollRight: "Desplazar pestañas a la derecha",
+    openTabs: "Pestañas abiertas",
+    fixedTabs: "Pestañas fijadas",
+    openDataTabs: "Tablas abiertas",
+    gridfs: "GridFS",
+  },
+  executionSummary: {
+    empty: "Sin resumen",
+    executing: "Ejecutando...",
+    statement: "Sentencia",
+    type: "Tipo",
+    rows: "Filas",
+    affected: "Afectadas",
+    time: "Tiempo",
+    success: "Éxito",
+    error: "Error",
+    returnedTable: "Devolvió una tabla de resultados de {count} columnas",
+    noTable: "No se devolvió ninguna tabla de resultados",
+  },
+  chart: {
+    title: "Gráfico",
+    type: "Tipo",
+    line: "Línea",
+    bar: "Barras",
+    pie: "Circular",
+    noNumericData: "No hay datos numéricos disponibles para graficar",
+  },
+  grid: {
+    rows: "{count} filas",
+    totalRows: "Total {count} filas",
+    totalRowCount: "({count} en total)",
+    totalRowCountLoading: "(contando...)",
+    loadingMore: "Cargando más datos...",
+    allLoaded: "todo cargado",
+    calculateTotalRows: "Contar filas totales",
+    calculateTotalRowsInline: "(contar filas totales)",
+    calculateTotalRowsFailed: "Error al contar: {message}",
+    rowsAffected: "{count} filas afectadas",
+    querySuccess: "Consulta ejecutada exitosamente",
+    noRows: "Sin datos",
+    noRowsDescription: "Este conjunto de resultados no tiene registros.",
+    noSearchResults: "Sin coincidencias",
+    noSearchResultsDescription: "Intenta con otra palabra clave.",
+    noFilteredRows: "Ninguna fila coincide con el filtro",
+    noFilteredRowsDescription: "Ajusta el texto de búsqueda o el filtro de estado de filas.",
+    copy: "Copiar",
+    mongoJsonPreview: "Vista previa de JSON",
+    mongoJsonPreviewEmpty: "Selecciona un documento de MongoDB para obtener una vista previa.",
+    copyJson: "Copiar JSON",
+    copyDdl: "Copiar DDL",
+    copyCell: "Copiar celda",
+    copyRow: "Copiar fila (JSON)",
+    copyColumnJson: "Copiar columna (JSON)",
+    copyColumnNames: "Copiar nombres de columnas",
+    copyRowInsert: "Copiar como INSERT",
+    copyRowInsertWithoutPrimaryKeys: "Copiar como INSERT sin claves primarias",
+    copyRowUpdate: "Copiar como UPDATE",
+    copyAll: "Copiar todo (TSV)",
+    selection: "Selección",
+    selectionSum: "SUM: {value}",
+    selectionCells: "{count} celdas",
+    copySelectionTsv: "Copiar selección (TSV)",
+    copySelectionTsvWithHeaders: "Copiar selección con encabezados (TSV)",
+    copySelectionCsv: "Copiar selección (CSV)",
+    copySelectionJson: "Copiar selección (JSON)",
+    copySelectionSql: "Copiar selección como lista SQL IN",
+    clearSelection: "Limpiar selección",
+    export: "Exportar",
+    exportCsv: "Exportar CSV",
+    exportXlsx: "Exportar XLSX",
+    exportCurrentPageCsv: "Exportar página actual como CSV",
+    exportCurrentPageXlsx: "Exportar página actual como XLSX",
+    exportCurrentPageJson: "Exportar página actual como JSON",
+    exportCurrentPageMarkdown: "Exportar página actual como Markdown",
+    exportCurrentPageSql: "Exportar página actual como SQL INSERT",
+    exportCurrentResultCsv: "Exportar todos los datos del resultado actual como CSV",
+    exportCurrentResultXlsx: "Exportar todos los datos del resultado actual como XLSX",
+    exportCurrentResultJson: "Exportar todos los datos del resultado actual como JSON",
+    exportCurrentResultMarkdown: "Exportar todos los datos del resultado actual como Markdown",
+    exportCurrentResultSql: "Exportar todos los datos del resultado actual como SQL INSERT",
+    exportAllResultsXlsx: "Exportar todos los resultados de esta ejecución como XLSX",
+    exportJson: "Exportar JSON",
+    exportMarkdown: "Exportar Markdown",
+    exportSql: "Exportar SQL INSERT",
+    exportSelectedRowsCsv: "Exportar filas seleccionadas como CSV",
+    exportSelectedRowsXlsx: "Exportar filas seleccionadas como XLSX",
+    exportSelectedRowsJson: "Exportar filas seleccionadas como JSON",
+    exportSelectedRowsMarkdown: "Exportar filas seleccionadas como Markdown",
+    exportSelectedRowsSql: "Exportar filas seleccionadas como SQL INSERT",
+    exported: "Exportado",
+    exportFailed: "Error al exportar: {message}",
+    copied: "Copiado",
+    copyFailed: "Error al copiar: {message}",
+    previewSqlEmpty: "No hay cambios SQL pendientes para previsualizar",
+    renderMode: "Modo de renderizado",
+    domRenderMode: "DOM",
+    canvasRenderMode: "Canvas",
+    renderModeHint: "Alterna entre el renderizado Canvas y la cuadrícula DOM de respaldo.",
+    tableFontSize: "Tamaño de fuente de la tabla",
+    filter: "Filtrar",
+    conditionHistoryEmpty: "Sin historial aún",
+    conditionHistoryNoMatches: "Sin historial coincidente",
+    filterBuilder: "Filtros",
+    filterBuilderTitle: "Filtros",
+    filterBuilderHint: "Crea condiciones visuales y combínalas con el campo WHERE.",
+    filterBuilderSummary: "{count} reglas",
+    filterBuilderAddRule: "Agregar regla",
+    filterBuilderColumn: "Columna",
+    filterBuilderValue: "Valor",
+    filterBuilderNoValue: "No requiere valor",
+    filterBuilderEmpty: "Agrega una regla para empezar a filtrar filas.",
+    resetFilterBuilder: "Restablecer reglas",
+    filterBuilderEquals: "Igual a",
+    filterBuilderNotEquals: "Distinto de",
+    filterBuilderContains: "Contiene",
+    filterBuilderNotContains: "No contiene",
+    filterBuilderGreaterThan: "Mayor que",
+    filterBuilderLessThan: "Menor que",
+    filterBuilderIsNull: "Es NULL",
+    filterBuilderIsNotNull: "No es NULL",
+    columnActions: "Acciones de columna",
+    localFilter: "Filtro local de valores",
+    localFilterFor: "Valores locales para '{column}'",
+    databaseValueFilter: "Filtro de valores de base de datos",
+    databaseValueFilterFor: "Valores de base de datos para '{column}'",
+    columnFormatter: "Formateador de columna",
+    columnFormatterFor: "Formateador para '{column}'",
+    columnFormatterHint: "Solo formatea la visualización; los valores sin procesar no cambian.",
+    formatterType: "Tipo",
+    formatterDatetime: "Marca de tiempo Unix",
+    formatterJsonPath: "Ruta JSON",
+    formatterMask: "Enmascarar texto",
+    formatterCustomTemplate: "Plantilla personalizada",
+    formatterTimestampUnit: "Unidad de marca de tiempo",
+    formatterUnitAuto: "Automático",
+    formatterUnitSeconds: "Segundos",
+    formatterUnitMilliseconds: "Milisegundos",
+    formatterDatetimePattern: "Patrón de fecha y hora",
+    formatterDatetimePatternPlaceholder: "Seleccionar o ingresar el formato de fecha y hora",
+    formatterDatetimePatternEmpty: "Formato ISO8601 por defecto",
+    formatterJsonPathInput: "Ruta JSON",
+    formatterMaskPrefix: "Prefijo visible",
+    formatterMaskSuffix: "Sufijo visible",
+    formatterSavedCustom: "Plantillas guardadas",
+    formatterNewCustom: "Nueva plantilla",
+    formatterCustomName: "Nombre de plantilla",
+    formatterCustomNamePlaceholder: "Ejemplo: Etiqueta de usuario",
+    formatterCustomTemplateInput: "Plantilla",
+    formatterCustomTemplateHint: "Variables disponibles: ${value}, ${upper}, ${lower}, ${length}. Asígnale un nombre para guardarla en la lista.",
+    formatterPreview: "Vista previa",
+    saveFormatter: "Guardar",
+    clearFormatter: "Limpiar",
+    searchValues: "Buscar valores...",
+    loadingValues: "Cargando valores...",
+    serverValuesLimited: "Mostrando los primeros {count} valores",
+    filterTypedValue: "Usar '{value}'",
+    value: "Valor",
+    count: "Conteo",
+    applyFilter: "Aplicar filtro",
+    clearLocalFilters: "Limpiar filtros locales de valores",
+    clearLocalFiltersShort: "Limpiar local",
+    localFiltersActive: "{count} filtros locales de valores",
+    localFilterMoreValues: " +{count} más",
+    columnVisibility: "Columnas",
+    columnVisibilityHint: "Al menos una columna permanece visible.",
+    searchColumns: "Buscar columnas...",
+    dragColumnToReorder: "Arrastra el encabezado para reordenar",
+    invertColumnVisibility: "Invertir",
+    resetColumnOrder: "Restablecer orden",
+    showAllColumns: "Mostrar todo",
+    viewOptions: "Opciones de vista",
+    hideNullColumns: "Ocultar NULL",
+    hideNullColumnsHint: "Alterna columnas cuyos valores son todos NULL en el resultado actual.",
+    moreValues: "{count} valores más, sigue escribiendo para acotar los resultados",
+    filterByValue: "Filtrar por este valor",
+    filterExcludeValue: "Excluir este valor",
+    filterLike: "Contiene este valor",
+    filterNotLike: "No contiene este valor",
+    filterLessThan: "Menor que este valor",
+    filterGreaterThan: "Mayor que este valor",
+    filterIsNull: "Mostrar valores NULL",
+    filterIsNotNull: "Mostrar valores no NULL",
+    clearFilter: "Limpiar filtro",
+    sort: "Ordenar",
+    sortAscending: "Orden ascendente",
+    sortDescending: "Orden descendente",
+    sortCurrentPageAscending: "Ordenar página actual ascendente",
+    sortCurrentPageDescending: "Ordenar página actual descendente",
+    sortDatabaseAscending: "Ordenar base de datos ascendente",
+    sortDatabaseDescending: "Ordenar base de datos descendente",
+    clearSort: "Limpiar orden",
+    pasted: "¡Pegado!",
+    search: "Buscar...",
+    searchOrWhere: "Buscar, o ingresar una cláusula WHERE...",
+    applyWhere: "Aplicar WHERE",
+    filterRows: "Filtrar filas",
+    filterAllRows: "Todas las filas",
+    filterChangedRows: "Modificadas",
+    page: "Página {page}",
+    rowsPerPage: "Filas por página",
+    customRowsPerPage: "Filas personalizadas",
+    applyPageSize: "Aplicar",
+    save: "Guardar",
+    discard: "Descartar",
+    dismiss: "Cerrar",
+    quickEntryDraftPlaceholder: "Nueva",
+    addRow: "Agregar fila",
+    cloneRow: "Clonar como fila nueva",
+    deleteRow: "Eliminar fila",
+    deleteRows: "Eliminar {count} filas",
+    cloneRows: "Clonar {count} como filas nuevas",
+    restoreRows: "Restaurar {count} filas",
+    copyRows: "Copiar {count} filas (JSON)",
+    copySelectedRowsTsv: "Copiar {count} filas (TSV)",
+    copySelectedRowsTsvWithHeaders: "Copiar {count} filas con encabezados (TSV)",
+    copySelectedRowTsv: "Copiar 1 fila (TSV)",
+    copySelectedRowTsvWithHeaders: "Copiar 1 fila con encabezados (TSV)",
+    copyColumnsJson: "Copiar {count} columnas (JSON)",
+    copyRowsInsert: "Copiar {count} filas como INSERT",
+    copyRowsInsertMerged: "Copiar {count} filas como INSERT (combinado)",
+    copyRowsInsertRowByRow: "Copiar {count} filas como INSERT (fila por fila)",
+    copyRowsInsertWithoutPrimaryKeys: "Copiar {count} filas como INSERT sin claves primarias",
+    copyRowsInsertWithoutPrimaryKeysMerged: "Copiar {count} filas como INSERT sin claves primarias (combinado)",
+    copyRowsInsertWithoutPrimaryKeysRowByRow: "Copiar {count} filas como INSERT sin claves primarias (fila por fila)",
+    copyRowsUpdate: "Copiar {count} filas como UPDATE",
+    selectedRows: "{count} filas seleccionadas",
+    restoreRow: "Restaurar fila",
+    statusClean: "Sin cambios",
+    statusNew: "Elementos nuevos",
+    statusEdited: "Elementos modificados",
+    statusDeleted: "Elementos eliminados",
+    pendingChanges: "{count} pendientes",
+    selectedCells: "{count} seleccionadas",
+    bulkEditSelection: "Edición masiva de selección",
+    bulkEditTitle: "Edición masiva de selección",
+    bulkEditDescription: "Establecer {count} celda(s) seleccionada(s) en este valor.",
+    bulkEditValuePlaceholder: "Valor, o NULL",
+    applyBulkEdit: "Aplicar",
+    cellDetails: "Detalles de celda",
+    cellDetailLayoutBottom: "Mover abajo",
+    cellDetailLayoutRight: "Mover a la derecha",
+    openCellDetailsDialog: "Abrir detalles de celda",
+    rowDetails: "Detalles de fila",
+    rowDetailsFor: "Detalles de fila {row}",
+    openRowDetailsDialog: "Abrir detalles de fila",
+    openColumnDetailsDialog: "Abrir detalles de columna",
+    columnDetailsFor: "Detalles de columna {column}",
+    columnsCount: "{count} columnas",
+    rowCount: "Filas",
+    rowsCount: "{count} filas",
+    fieldIndex: "N.º",
+    cellValue: "Valor",
+    valueEditor: "Editor de valor",
+    hexViewer: "Visor hexadecimal",
+    hexViewerByteCount: "{count} bytes",
+    hexViewerOffset: "Desplazamiento",
+    hexViewerHex: "Hex",
+    hexViewerAscii: "ASCII",
+    hexViewerEmpty: "No hay bytes binarios para mostrar.",
+    imagePreview: "Vista previa de imagen",
+    imageLoadFailed: "No se pudo cargar la imagen",
+    geometryPreview: "Vista previa de geometría",
+    layerPreview: "Vista previa de capa",
+    zoomIn: "Acercar",
+    zoomOut: "Alejar",
+    fitImage: "Ajustar a la vista",
+    openImage: "Abrir imagen",
+    columnName: "Columna",
+    columnType: "Tipo",
+    columnComment: "Comentario",
+    rowNumber: "Fila",
+    valueLength: "Longitud",
+    nullValue: "NULL",
+    noComment: "Sin comentario",
+    formattedJson: "JSON formateado",
+    formattedValue: "Valor formateado",
+    detailSearchPlaceholder: "Buscar campo o valor…",
+    detailSearchNoMatch: "Sin coincidencias",
+    rawValue: "Valor sin procesar",
+    largeValuePreviewHint: "Mostrando los primeros {count} caracteres. Copiar sigue usando el valor completo.",
+    copyValue: "Copiar valor",
+    downloadBinaryValue: "Descargar valor",
+    downloadSaved: "Guardado en {path}",
+    downloadStarted: "Descarga iniciada: {fileName}",
+    binaryDownload: {
+      binary: "Binario sin procesar",
+      utf8: "Texto decodificado (UTF-8)",
+      gbk: "Texto decodificado (GBK)",
+    },
+    copyRowTsv: "Copiar fila (TSV)",
+    copyColumnValues: "Copiar columna (JSON)",
+    copyColumnTsv: "Copiar columna (TSV)",
+    editValue: "Editar valor",
+    formatJson: "Formatear JSON",
+    compactJson: "Compactar JSON",
+    formattedJsonEditWarning: "Estás editando JSON formateado. Al guardar se escribirá como JSON, por lo que el formato original puede cambiar.",
+    setNull: "Establecer NULL",
+    restoreOriginalValue: "Restaurar original",
+    copyColumnName: "Copiar nombre de columna",
+    copySqlCondition: "Copiar condición SQL",
+    copyAlterColumnSql: "Copiar como SQL ALTER",
+    alterSqlCopied: "SQL ALTER copiado al portapapeles",
+    alterSqlCopiedWithWarnings: "SQL ALTER copiado al portapapeles ({count} advertencia(s))",
+    noAlterSqlAvailable: "No hay SQL ALTER disponible para esta columna",
+    copyAlterSqlFailed: "Error al copiar: {message}",
+    transpose: "Transponer fila",
+    transposeMultiRowToggle: "Varias filas",
+    transposeSingleRow: "Fila actual",
+    transposeMultiRow: "Varias filas",
+    transposeMultiRowHint: "Cuando está activado, la vista transpuesta muestra varias filas. Cuando está desactivado, solo muestra la fila actual.",
+    rowsPerPageShort: " filas",
+    columnDetails: "Detalles de columna",
+    tableInfoSearch: "Buscar...",
+    tableInfoNoResults: "Sin resultados",
+    goToColumn: "Ir a la columna",
+    columnWidth: "Ancho de columna",
+    columnWidthCompact: "Compacto",
+    columnWidthStandard: "Estándar",
+    columnWidthComfortable: "Amplio",
+    searchColumn: "Buscar columna/comentario...",
+    noColumnsFound: "No se encontraron columnas",
+    tableInfo: "Información de tabla",
+    tableInfoColumns: "Columnas",
+    tableInfoIndexes: "Índices",
+    tableInfoForeignKeys: "Claves foráneas",
+    tableInfoTriggers: "Disparadores",
+    tableInfoNullable: "Nulable",
+    tableInfoEmpty: "Sin metadatos",
+    queryError: "Error de consulta",
+    dataUnavailable: "Los datos de la tabla deben volver a cargarse.",
+    dataUnavailableHintPrefix: "Presiona ",
+    dataUnavailableHintSuffix: " o haz clic en Actualizar abajo para recargar.",
+    refresh: "Actualizar",
+    undoChange: "Deshacer cambio",
+    redoChange: "Rehacer cambio",
+    commit: "Confirmar",
+    rollback: "Revertir",
+    transactionSaveHint: "Confirma {count} cambio(s) pendiente(s) en una transacción.",
+    nonTransactionalSaveHint: "Guarda {count} cambio(s) pendiente(s) uno por uno. Si uno falla, los cambios anteriores correctos no se revierten.",
+    keylessEditWarning: "Sin clave primaria",
+    keylessEditWarningHint: "Esta tabla no tiene clave primaria. Las actualizaciones y eliminaciones usan todos los valores originales de la fila en WHERE; filas duplicadas exactas pueden verse afectadas juntas.",
+    queryEditReadOnly: "Resultado de solo lectura",
+    queryEditUnsupported: {
+      "not-select": "Solo los resultados de consultas SELECT pueden editarse directamente.",
+      cte: "Las consultas con WITH/CTE aún no son editables. Usa un SELECT simple de una sola tabla.",
+      "set-operation": "Los resultados de UNION, INTERSECT o EXCEPT no pueden asignarse de forma segura a las filas de origen.",
+      aggregation: "Los resultados con DISTINCT, GROUP BY, HAVING y agregaciones no pueden editarse directamente.",
+      "external-source": "Los archivos externos y los resultados de funciones de tabla no pueden escribirse directamente. Impórtalos a una tabla de base de datos antes de editarlos.",
+      "complex-source": "DBX no pudo identificar exactamente una tabla de destino segura para escribir este resultado.",
+      "computed-columns": "Las expresiones calculadas o los resultados de funciones no pueden escribirse de vuelta. Selecciona nombres de columna originales.",
+      "no-table": "No se detectó ninguna tabla de origen editable.",
+      "no-primary-key": "La tabla de destino no tiene clave primaria, por lo que las filas no pueden actualizarse o eliminarse de forma segura.",
+      "primary-key-not-returned": "Al resultado le falta la columna de clave primaria original. Inclúyela por su nombre de columna original.",
+      "aliased-columns": "Las columnas de resultado usan alias o expresiones. Selecciona columnas editables por sus nombres originales.",
+      "metadata-unavailable": "DBX no pudo cargar los metadatos de la tabla, por lo que la edición de resultados está deshabilitada.",
+    },
+    sortUnsupported: "Este SQL no admite ordenamiento del resultado completo. Intenta con una consulta SELECT simple.",
+    truncatedHint: "Los resultados están limitados a 10.000 filas. Usa LIMIT/OFFSET en tu consulta para paginar.",
+    filterBuilderSearchColumns: "Buscar columnas...",
+    filterBuilderNoMatchingColumns: "Sin columnas coincidentes",
+  },
+  exportProgress: {
+    title: "Exportando datos de la tabla",
+    fetching: "Obteniendo datos de la base de datos...",
+    writing: "Escribiendo en el archivo...",
+    done: "¡Exportación completada!",
+    error: "Error de exportación",
+    cancelled: "Exportación cancelada.",
+    rowsCount: "{exported} / {total} filas",
+    rowsExported: "{count} filas exportadas",
+    rowsShort: "filas",
+    cancel: "Cancelar",
+    close: "Cerrar",
+    tooltip: "Progreso de exportación",
+    popoverTitle: "Exportaciones",
+    noTasks: "Sin exportaciones",
+    clearFinished: "Limpiar finalizados",
+    showMore: "Mostrar {count} más",
+    showLess: "Mostrar menos",
+    failedTooltip: "{count} tarea en segundo plano fallida | {count} tareas en segundo plano fallidas",
+    databaseExportTitle: "Copia de seguridad: {name}",
+    sqlFileTitle: "Archivo SQL: {name}",
+    dataTransferTitle: "Transferencia de datos: {name}",
+    objectsCount: "{current} / {total} objetos",
+    tablesCount: "{current} / {total} tablas",
+    statementsCount: "{done} exitosas, {failed} fallidas",
+    delete: "Eliminar",
+  },
+  welcome: {
+    title: "Espacio de trabajo de base de datos",
+    subtitle: "Selecciona una conexión a la izquierda para explorar el esquema, o abre una pestaña de consulta directamente.",
+    connections: "Conexiones",
+    connected: "Conectado",
+    databaseTypes: "Tipos de bases de datos",
+    quickConnections: "Inicio rápido",
+    quickConnectionsHint: "Haz clic en una conexión para abrir una pestaña de consulta.",
+    shortcuts: "Atajos",
+    shortcutsHint: "Inicia la siguiente acción desde aquí.",
+    sqlHistory: "Historial de consultas",
+    sqlHistoryEmpty: "Aún no hay registros de la biblioteca SQL",
+    sqlHistoryOpenCount: "Abierto {count} veces",
+    unknownConnection: "Conexión desconocida",
+    tip: "También puedes expandir las conexiones a la izquierda y hacer clic derecho en bases de datos o tablas para más opciones.",
+    tipSidebar: "Haz clic en una tabla a la izquierda para ver los datos",
+    tipExecute: "para ejecutar la consulta",
+    fileOpened: "Abierto {name}",
+    mcpTitle: "Integración con agentes de IA",
+    mcpDescription: "Además del asistente de IA integrado, puedes usar Claude Code, Cursor y otros agentes de programación para consultar tus bases de datos mediante MCP.",
+    mcpLearnMore: "Más información",
+  },
+  common: {
+    language: "Idioma",
+    loading: "Cargando...",
+    stopping: "Deteniendo...",
+    close: "Cerrar",
+    cancel: "Cancelar",
+    save: "Guardar",
+    copy: "Copiar",
+    import: "Importar",
+    remove: "Eliminar",
+    retry: "Reintentar",
+    more: "Más",
+    decrease: "Reducir",
+    increase: "Aumentar",
+    showPassword: "Mostrar contraseña",
+    hidePassword: "Ocultar contraseña",
+    done: "Listo",
+    connection: "Conexión",
+    database: "Base de datos",
+    table: "Tabla",
+    view: "Vista",
+    materializedView: "Vista Materializada",
+    procedure: "Procedimiento",
+    function: "Función",
+    sequence: "Secuencia",
+    package: "Paquete",
+    packageBody: "Cuerpo del Paquete",
+    noResults: "Sin resultados",
+  },
+  quickOpen: {
+    placeholder: "Buscar conexiones, bases de datos, tablas y otros objetos...",
+    emptyPlaceholder: "Comienza a escribir para buscar",
+    noResults: "No se encontraron resultados",
+    results: "resultados",
+    navigate: "Navegar",
+    select: "Seleccionar",
+    close: "Cerrar",
+  },
+  explain: {
+    title: "Plan de ejecución",
+    standardTable: "Tabla",
+    tree: "Árbol",
+    summary: "Resumen",
+    running: "Leyendo plan de ejecución...",
+    empty: "Sin plan de ejecución",
+    nodeCount: "{count} nodos",
+    node: "Nodo",
+    relation: "Tabla",
+    index: "Índice",
+    cost: "Costo",
+    rows: "Filas",
+    details: "Detalles",
+    unsupported: "El plan de ejecución aún no está disponible para esta base de datos",
+    emptySql: "No hay SQL para analizar",
+    unsafe: "Esta versión solo analiza sentencias SELECT / WITH / TABLE / VALUES",
+  },
+  lineage: {
+    title: "Linaje de campo",
+    open: "Ver linaje de campo",
+    loading: "Leyendo metadatos {done}/{total}",
+    empty: "Sin linaje relacionado",
+    noFiltered: "Ningún resultado coincide con los filtros actuales",
+    targetField: "Campo actual",
+    searchPlaceholder: "Buscar tablas, campos, vistas o fragmentos SQL...",
+    showing: "Mostrando {shown}/{total} resultados",
+    all: "Todos",
+    certain: "Confirmado",
+    likely: "Probable",
+    possible: "Posible",
+    queryHistory: "Historial de consultas",
+    openTable: "Abrir tabla",
+    copy: "Copiar nombre",
+    copied: "Copiado",
+    kind: {
+      foreignKey: "Clave foránea",
+      viewReference: "Vista",
+      historyReference: "Historial SQL",
+      sameName: "Mismo nombre",
+    },
+    description: {
+      foreignKeyIncoming: "{target} apunta al campo actual mediante una clave foránea. Esta es una dependencia verificada.",
+      foreignKeyOutgoing: "El campo actual referencia a {target} mediante una clave foránea. Esta es una dependencia verificada.",
+      viewLikely: "La definición de la vista menciona tanto la tabla como el campo destino, lo que generalmente indica una dependencia de consulta.",
+      viewPossible: "La definición de la vista menciona un campo con el mismo nombre pero no la tabla destino, por lo que requiere confirmación.",
+      historyLikely: "Una sentencia SQL del historial menciona tanto la tabla como el campo destino. Úsala como contexto de análisis de impacto.",
+      historyPossible: "Una sentencia SQL del historial menciona un campo con el mismo nombre. Puede estar relacionado pero requiere verificación.",
+      sameName: "Otra tabla tiene un campo con el mismo nombre. Puede compartir significado de negocio, pero no es una dependencia verificada en la base de datos.",
+    },
+    cancel: "Cancelar",
+    refresh: "Analizar de nuevo",
+  },
+  connectionGroup: {
+    createGroup: "Nuevo grupo",
+    groupNamePlaceholder: "Nombre del grupo",
+    renameGroup: "Renombrar grupo",
+    deleteGroup: "Eliminar grupo",
+    moveToGroup: "Mover al grupo",
+    moveToNewGroup: "Mover a nuevo grupo",
+    ungrouped: "Sin grupo",
+    newGroup: "Nuevo grupo...",
+    newGroupDefault: "Nuevo grupo",
+    deleteGroupConfirmTitle: "Eliminar grupo",
+    deleteGroupConfirmMessage: '¿Eliminar el grupo "{name}"? Las conexiones dentro serán movidas al nivel superior.',
+    selectConnection: "Seleccionar conexión",
+    deselectConnection: "Deseleccionar conexión",
+    selectAllConnections: "Seleccionar todas las conexiones",
+    deselectAllConnections: "Deseleccionar todas las conexiones",
+    exitMultiSelect: "Salir de selección múltiple",
+  },
+  databaseSearch: {
+    title: "Buscar en base de datos",
+    open: "Buscar en base de datos",
+    keyword: "Palabra clave",
+    keywordPlaceholder: "Ingresa un ID de usuario, correo, número de orden...",
+    limitPerTable: "Por tabla",
+    search: "Buscar",
+    searching: "Buscando",
+    stop: "Detener",
+    hint: "Analiza las tablas regulares de la base de datos o esquema actual. Se omiten las columnas binarias y cada tabla tiene un límite para evitar cargar demasiados datos a la vez.",
+    loadingTables: "Leyendo lista de tablas...",
+    progress: "Analizadas {done}/{total} tablas",
+    resultCount: "{count} coincidencias",
+    limitedTables: "Esquema grande detectado; solo se analizan las primeras {count} tablas",
+    results: "Resultados",
+    openResult: "Abrir",
+    waiting: "Esperando coincidencias...",
+    noResults: "Sin coincidencias aún",
+    errors: "Algunas tablas fallaron",
+  },
+  configExport: {
+    passphraseTitle: "Cifrar y exportar",
+    passphraseImportTitle: "Descifrar e importar",
+    passphraseExportHint: "Para incluir las contraseñas de conexión en la exportación, define una frase de paso para el cifrado. Necesitarás la misma frase para importar.",
+    passphraseImportHint: "Este archivo está cifrado. Ingresa la frase de paso para descifrarlo e importarlo.",
+    passphrase: "Frase de paso",
+    passphraseConfirm: "Confirmar frase de paso",
+    passphrasePlaceholder: "Ingresa la frase de paso",
+    passphraseConfirmPlaceholder: "Vuelve a ingresar la frase de paso",
+    passphraseRequired: "La frase de paso es obligatoria",
+    passphraseMismatch: "Las frases de paso no coinciden",
+    passphraseTooShort: "La frase de paso debe tener al menos 4 caracteres",
+    exportEncrypted: "Exportar",
+    decryptImport: "Descifrar e importar",
+    wrongPassphrase: "Frase de paso incorrecta o archivo corrupto",
+    cryptoUnavailable: "La importación cifrada no está disponible en este navegador. Usa HTTPS, localhost o DBX Desktop.",
+    exportSuccess: "Conexiones exportadas exitosamente",
+    importSuccess: "Se importaron {count} conexión(es)",
+    importNavicatSuccess: "Se importaron {count} conexión(es) de Navicat. Completa la contraseña de las conexiones que aún la tengan vacía antes de probarlas.",
+    importDatagripSuccess: "Se importaron {count} conexión(es) de DataGrip, se llenaron {filled} contraseña(s) del Keychain.",
+    importDbeaverSuccess: "Se importaron {count} conexión(es) de DBeaver. Completa la contraseña de las conexiones que aún la tengan vacía antes de probarlas.",
+    importNone: "No hay nuevas conexiones para importar",
+    importLayoutConfirm: "El archivo importado contiene grupos de conexiones. ¿Deseas aplicarlos?",
+    importLayoutTitle: "Importar grupos",
+    importLayoutApply: "Aplicar",
+  },
+  ai: {
+    placeholder: "Describe tu consulta en lenguaje natural...",
+    settings: "Configuración de IA",
+    noConfig: "La IA no está configurada. Configura tu proveedor de IA en Ajustes > IA.",
+    provider: "Proveedor",
+    providerStatusActive: "Activo",
+    providerStatusConfigured: "Configurado",
+    switchProvider: "Cambiar proveedor",
+    model: "Modelo",
+    browseModels: "Explorar modelos",
+    refreshModels: "Actualizar modelos",
+    loadingModels: "Cargando modelos...",
+    searchModels: "Buscar modelos",
+    noModels: "No hay modelos cargados",
+    modelListHint: "Pulsa actualizar para cargar los modelos del proveedor.",
+    modelListUnsupported: "Este proveedor no admite obtener una lista de modelos.",
+    modelListEndpointRequired: "Ingresa un endpoint antes de cargar modelos.",
+    modelListApiKeyRequired: "Ingresa una clave API antes de cargar modelos.",
+    codexMcpRequiredTitle: "Se requiere DBX MCP Server",
+    codexMcpRequiredDescription: "Codex CLI usa DBX MCP Server para acceder al esquema de la base de datos y a las herramientas de consulta. Instálalo antes de usar Codex en el asistente de IA.",
+    codexCliPathEnvError: "Codex CLI Path debe contener solo la ruta del ejecutable. Agrega las variables de entorno abajo.",
+    codexCliEnv: "Variables de entorno",
+    codexCliEnvAdd: "Agregar variable",
+    codexCliEnvHint: "Variables opcionales para Codex CLI, como HTTPS_PROXY, NO_PROXY, SSL_CERT_FILE o CODEX_CA_CERTIFICATE.",
+    codexCliEnvKeyPlaceholder: "HTTPS_PROXY",
+    codexCliEnvValuePlaceholder: "http://proxy:9800",
+    codexCliEnvInvalidName: "Nombre de variable de entorno no válido: {name}",
+    codexCliEnvReservedName: "{name} lo administra DBX para MCP Server y no se puede configurar aquí.",
+    reasoningLevel: "Nivel de razonamiento",
+    reasoningLevelDefault: "Predeterminado",
+    reasoningLevelMinimal: "Mínimo",
+    reasoningLevelLow: "Bajo",
+    reasoningLevelMedium: "Medio",
+    reasoningLevelHigh: "Alto",
+    reasoningLevelHint: "Controla model_reasoning_effort de Codex CLI. Predeterminado usa tu configuración de Codex.",
+    run: "Ejecutar",
+    readingSchema: "Leyendo esquema",
+    noConnection: "No hay una conexión disponible para esta pestaña",
+    noSql: "No hay SQL para procesar",
+    sqlPreview: "Vista previa de SQL",
+    copySql: "Copiar SQL",
+    copyCode: "Copiar código",
+    executeSql: "Ejecutar SQL",
+    tempRunSql: "Ejecutar sin modificar",
+    copyAll: "Copiar todo",
+    copied: "Copiado",
+    copyTestResult: "Copiar resultado de prueba",
+    replace: "Reemplazar en el editor",
+    append: "Agregar al editor",
+    apply: "Aplicar al editor",
+    clear: "Limpiar chat",
+    welcome: "Dime qué quieres consultar y escribiré el SQL",
+    newChat: "Nuevo chat",
+    thinking: "Procesando...",
+    reasoningProcess: "Proceso de razonamiento",
+    stopGenerating: "Detener generación",
+    scrollToBottom: "Volver al final",
+    tableMentionEmpty: "Sin tablas ni archivos SQL coincidentes",
+    tableMentionPlaceholderHint: "Escribe {'@'} para mencionar tablas o archivos SQL como contexto",
+    tableMentionTypes: {
+      table: "Tabla",
+      view: "Vista",
+      systemTable: "Tabla del sistema",
+      temporaryTable: "Tabla temporal",
+    },
+    modes: {
+      ask: "Preguntar",
+      agent: "Agente",
+    },
+    modeHints: {
+      ask: "Genera SQL y explicaciones sin ejecutarlos automáticamente",
+      agent: "Ejecuta consultas seguras automáticamente cuando sea posible",
+    },
+    fixWithAi: "Corregir con IA",
+    truncated: "Contexto truncado",
+    contextSummary: "{database} · {tables} tablas",
+    autoSqlBlocked: "El SQL generado por la IA parecía demasiado riesgoso para ejecutarse automáticamente. Revísalo manualmente antes de ejecutar.",
+    proposalConfirmYes: "Sí, continuar",
+    proposalConfirmNo: "No, gracias",
+    proposalConfirmTitle: "Confirmación de acción requerida",
+    agentSteps: {
+      generated: "SQL generado",
+      noSql: "No se encontró SQL",
+      safe: "Verificación de seguridad superada",
+      needsConfirm: "Requiere confirmación",
+      blocked: "Bloqueado",
+      autoExecute: "Listo para ejecutar",
+      notRequested: "No se solicitó ejecución",
+      skipped: "No ejecutado",
+      callingTool: "Llamando herramienta...",
+      toolDone: "Herramienta completada",
+      toolError: "Error de herramienta",
+      executeSafe: "Verificación de seguridad superada · Ejecutado",
+      executeBlocked: "Bloqueado por verificación de seguridad",
+      contextCompacted: "Contexto comprimido",
+    },
+    agentStepTitles: {
+      riskCheck: "Verificación de riesgo: {action} · {category} · {environment} · {reasons}",
+      blocked: "La ejecución fue bloqueada por la política de riesgos. Revisa el SQL manualmente.",
+      requiresConfirmation: "Este SQL requiere confirmación antes de ejecutarse.",
+      askMode: "El modo Preguntar no ejecuta SQL automáticamente.",
+      unsupportedAction: "La acción de IA actual no ejecuta SQL automáticamente.",
+      noSql: "La respuesta no incluía un bloque de código SQL ejecutable.",
+      notRequested: "El usuario no solicitó ejecutar el SQL.",
+      skipped: "Este paso no se ejecutó.",
+    },
+    proxy: "Proxy",
+    proxyEnable: "Enviar solicitudes de IA mediante proxy",
+    proxyUrl: "URL del proxy",
+    enableThinking: "Razonamiento",
+    enableThinkingOn: "Activado",
+    enableThinkingOff: "Desactivado",
+    enableThinkingHint: "Esta opción solo tiene efecto en APIs /chat/completions y modelos compatibles. Cuando está desactivado, puede reducir significativamente el uso de tokens, pero la calidad de los resultados generados puede disminuir ligeramente.",
+    anthropicMessagesHint: "Las API compatibles con Anthropic Messages suelen usar /v1/messages.",
+    contextWindow: "Ventana de contexto",
+    contextWindowAuto: "Auto (detectar desde el nombre del modelo)",
+    contextWindowHint: "Tokens. Déjalo vacío para detección automática. Configúralo manualmente para modelos locales/personalizados.",
+    codexCliPath: "Ruta de Codex CLI",
+    codexCliPathHint: "Déjalo vacío para usar codex desde PATH. Inicia sesión por separado con codex login.",
+    actions: {
+      general: "General",
+      generate: "Generar SQL",
+      explain: "Explicar SQL",
+      optimize: "Optimizar SQL",
+      fix: "Corregir error",
+      convert: "Convertir dialecto",
+      sampleData: "Datos de ejemplo",
+      query: "Consultar datos",
+      exploreSchema: "Inspeccionar esquema",
+      executeAndExplain: "Ejecutar y explicar",
+      generateNoExec: "Generar (sin ejecutar)",
+    },
+    placeholders: {
+      general: "Pregunta lo que quieras...",
+      generate: "Describe lo que quieres consultar, p. ej. pedidos por usuario en los últimos 7 días",
+      explain: "Opcional: indica qué quieres entender",
+      optimize: "Opcional: indica un objetivo, p. ej. reducir los escaneos completos de tabla",
+      fix: "Pega el error o describe el resultado esperado",
+      convert: "P. ej. convertir a PostgreSQL / MySQL / SQL Server",
+      sampleData: "Describe los datos de ejemplo o sentencias de prueba a generar",
+      query: "Describe qué consultar o contar, p. ej. totales de pedidos por región este mes",
+      exploreSchema: "Describe la tabla o estructura a inspeccionar, p. ej. columnas e índices de orders",
+      executeAndExplain: "Opcional: indica en qué centrar la explicación",
+    },
+    editMessage: "Editar mensaje",
+    editResend: "Reenviar",
+    editCancel: "Cancelar",
+  },
+  contextMenu: {
+    openConnection: "Abrir conexión",
+    closeConnection: "Cerrar conexión",
+    closeDatabaseConnection: "Cerrar conexión de base de datos",
+    deleteConnection: "Eliminar conexión",
+    deleteSelectedConnections: "Eliminar {count} conexiones seleccionadas",
+    confirmDeleteTitle: "Eliminar conexión",
+    confirmDeleteMessage: '¿Estás seguro de que deseas eliminar "{name}"? Esta acción no se puede deshacer.',
+    confirmDeleteSelectedMessage: "¿Eliminar las {count} conexiones seleccionadas? Esta acción no se puede deshacer.",
+    editConnection: "Editar conexión",
+    revealDatabaseFile: "Mostrar en el explorador",
+    selectVisibleDatabases: "Seleccionar bases visibles",
+    configureVisibleObjects: "Filtro de objetos visibles",
+    userAdmin: "Usuarios y Privilegios",
+    openUserAdmin: "Abrir Usuarios y Privilegios",
+    damengJobAdmin: "Trabajos del agente Dameng",
+    openDamengJobAdmin: "Abrir trabajos del agente Dameng",
+    duplicateConnection: "Duplicar conexión",
+    duplicateSelectedConnections: "Duplicar {count} conexiones seleccionadas",
+    instanceInfo: "Información de la instancia",
+    newQuery: "Nueva consulta",
+    newSql: "Nuevo SQL",
+    generateSql: "Generar SQL",
+    newInsert: "Nueva Inserción",
+    newUpdate: "Nueva Actualización",
+    sqlHistory: "Historial de consultas",
+    noSqlHistory: "Sin SQL relacionado",
+    openObjectBrowser: "Explorar objetos",
+    viewData: "Ver datos",
+    editStructure: "Editar estructura",
+    editColumn: "Editar columna",
+    editIndex: "Editar índice",
+    refreshChildren: "Actualizar",
+    expandAll: "Expandir todo",
+    pin: "Fijar",
+    unpin: "Desfijar",
+    fixTab: "Fijar pestaña",
+    unfixTab: "Desfijar pestaña",
+    refreshTab: "Actualizar datos",
+    renameTab: "Renombrar pestaña",
+    duplicateTab: "Duplicar pestaña",
+    compactTabTitle: "Acortar títulos de pestañas",
+    fullTabTitle: "Mostrar títulos completos de pestañas",
+    closeTab: "Cerrar pestaña",
+    closeFixedTab: "Cerrar pestaña fijada",
+    closeOtherTabs: "Cerrar otras pestañas",
+    closeOtherRegularTabs: "Cerrar otras pestañas normales",
+    closeOtherFixedTabs: "Cerrar otras pestañas fijadas",
+    closeAllTabs: "Cerrar todas las pestañas",
+    closeAllRegularTabs: "Cerrar todas las pestañas normales",
+    closeAllFixedTabs: "Cerrar todas las pestañas fijadas",
+    copyName: "Copiar nombre",
+    copyFinalProxyPort: "Copiar puerto proxy final",
+    finalProxyPortCopied: "Puerto proxy final {port} copiado",
+    setDefaultDatabase: "Establecer como base de datos predeterminada",
+    clearDefaultDatabase: "Limpiar base de datos predeterminada",
+    exportDatabase: "Exportar base de datos",
+    exportAllDatabases: "Exportar todas las bases de datos",
+    exportDatabaseSuccess: "Se exportaron {count} tablas, hasta {limit} filas cada una",
+    exportDatabaseFailed: "Error al exportar la base de datos: {message}",
+    backupSqliteDatabase: "Backup SQLite Database",
+    backupSqliteDatabaseInProgress: "Backing up SQLite database...",
+    backupSqliteDatabaseSuccess: "SQLite database backed up",
+    backupSqliteDatabaseFailed: "Failed to backup SQLite database: {message}",
+    importData: "Importar datos",
+    exportData: "Exportar datos",
+    exportStructure: "Exportar estructura",
+    exportStructurePreviewTitle: "Estructura - {name}",
+    exportStructurePreviewTitleMultiple: "Estructura - {count} objetos",
+    exportStructureLoading: "Cargando estructura...",
+    copyStructure: "Copiar estructura",
+    copyStructureAs: "Copiar estructura como",
+    copyStructureAsTsv: "TSV (para Excel)",
+    copyStructureAsMarkdown: "Tabla Markdown",
+    structureDocTable: "Tabla",
+    structureDocColumn: "Columna",
+    structureDocType: "Tipo",
+    structureDocPrimaryKey: "Clave primaria",
+    structureDocNullable: "Permite NULL",
+    structureDocDefault: "Valor predeterminado",
+    structureDocComment: "Comentario",
+    structureDocYes: "Sí",
+    structureDocNo: "No",
+    structureDocCopied: "Estructura copiada",
+    structureDocCopyFallbackHint: "La copia automática fue bloqueada. Haz clic en Copiar de nuevo o selecciona el contenido inferior.",
+    saveStructure: "Guardar SQL",
+    exportStructureCopied: "Estructura copiada",
+    createTable: "Crear tabla",
+    createView: "Crear vista",
+    dropTable: "Eliminar tabla",
+    emptyTable: "Vaciar tabla",
+    truncateTable: "Truncar tabla",
+    duplicateStructure: "Clonar como tabla nueva",
+    renameObject: "Renombrar",
+    renameObjectTitle: "Renombrar objeto",
+    renameObjectNamePlaceholder: "Nuevo nombre",
+    renameObjectSuccess: '"{oldName}" renombrado a "{newName}"',
+    confirmDropTableTitle: "Eliminar tabla",
+    confirmDropTableMessage: '¿Estás seguro de que deseas eliminar "{name}"? Esto borrará permanentemente la tabla y todos sus datos.',
+    dropTableCascade: "Usar CASCADE",
+    dropTableCascadeHint: "También elimina objetos dependientes, como vistas. Desactívalo para usar el comportamiento RESTRICT predeterminado de PostgreSQL.",
+    truncateTableCascade: "Usar CASCADE",
+    truncateTableCascadeHint: "También trunca las tablas que hacen referencia a esta tabla mediante claves foráneas. Desactívalo para usar el comportamiento RESTRICT predeterminado de PostgreSQL.",
+    confirmEmptyTableTitle: "Vaciar tabla",
+    confirmEmptyTableMessage: '¿Estás seguro de que deseas eliminar todos los datos de "{name}"?',
+    confirmTruncateTableTitle: "Truncar tabla",
+    confirmTruncateTableMessage: '¿Estás seguro de que deseas truncar "{name}"? Esto eliminará todas las filas.',
+    dropTableSuccess: 'Tabla "{name}" eliminada',
+    editView: "Editar vista",
+    viewSource: "Ver código fuente",
+    viewDdl: "Ver DDL",
+    viewDdlLoading: "Cargando DDL...",
+    ddlCopied: "DDL copiado",
+    dropObject: "Eliminar objeto",
+    dropView: "Eliminar vista",
+    dropColumn: "Eliminar columna",
+    dropIndex: "Eliminar índice",
+    dropForeignKey: "Eliminar clave foránea",
+    dropTrigger: "Eliminar disparador",
+    batchDrop: "Eliminar seleccionados ({count})",
+    batchEmpty: "Vaciar seleccionadas ({count})",
+    batchTruncate: "Truncar seleccionadas ({count})",
+    executeProcedure: "Ejecutar procedimiento",
+    confirmExecuteProcedureTitle: "Ejecutar procedimiento",
+    confirmExecuteProcedureMessage: '¿Ejecutar el procedimiento "{name}"? Puedes completar o ajustar los valores de los parámetros primero.',
+    loadingProcedureParameters: "Cargando parámetros...",
+    procedureParametersUnavailable: "No se pudo cargar la metadata de parámetros. Aún puedes editar el SQL inferior y ejecutarlo.",
+    noProcedureParameters: "No se encontraron parámetros. El SQL actual se ejecutará tal como se muestra.",
+    inputParameters: "{count} parámetros de entrada",
+    outputParameters: "{count} parámetros de salida",
+    parameterName: "Name",
+    parameterType: "Type",
+    parameterMode: "Mode",
+    parameterValue: "Value",
+    parameterNull: "NULL",
+    parameterDefault: "DEFAULT",
+    parameterDefaultHint: "Cuando DEFAULT está marcado, DBX omite ese argumento para que la base de datos use el valor predeterminado.",
+    parameterValuePlaceholder: "Ingresa un valor",
+    outputOnly: "Solo salida",
+    sqlPreview: "Vista previa SQL",
+    resetSqlPreview: "Restablecer SQL",
+    openInSqlEditor: "Abrir en editor",
+    dropProcedure: "Eliminar procedimiento",
+    dropFunction: "Eliminar función",
+    dropAllIndexes: "Eliminar todos los índices",
+    batchDropIndexes: "Eliminar índices ({count})",
+    confirmDropViewTitle: "Eliminar vista",
+    confirmDropViewMessage: '¿Seguro que deseas eliminar la vista "{name}"?',
+    confirmDropObjectTitle: "Eliminar objeto",
+    confirmDropObjectMessage: '¿Seguro que deseas eliminar "{name}"?',
+    confirmDropColumnTitle: "Eliminar columna",
+    confirmDropIndexTitle: "Eliminar índice",
+    confirmDropMongoIndexMessage: '¿Seguro que deseas eliminar el índice "{name}" de la colección "{collection}"?',
+    confirmDropMongoAllIndexesMessage: '¿Seguro que deseas eliminar todos los índices removibles de la colección "{name}"?',
+    confirmDropMongoAllIndexesDetails: 'MongoDB conserva el índice "_id_". También pueden mantenerse índices adicionales requeridos por shard keys; el resultado solo mostrará los índices realmente eliminados.',
+    confirmDropForeignKeyTitle: "Eliminar clave foránea",
+    confirmDropTriggerTitle: "Eliminar disparador",
+    confirmDropTableChildObjectMessage: '¿Seguro que deseas eliminar "{name}" de "{table}"?',
+    confirmDropBatchIndexesMessage: '¿Seguro que deseas eliminar {count} índices seleccionados de "{table}"? Esta acción no se puede deshacer.',
+    confirmBatchDropTitle: "Eliminar objetos seleccionados",
+    confirmBatchDropMessage: "¿Seguro que deseas eliminar {count} objetos seleccionados? Esta acción no se puede deshacer.",
+    confirmBatchEmptyTitle: "Vaciar tablas seleccionadas",
+    confirmBatchEmptyMessage: "¿Seguro que deseas eliminar todos los datos de {count} tablas seleccionadas?",
+    confirmBatchTruncateTitle: "Truncar tablas seleccionadas",
+    confirmBatchTruncateMessage: "¿Seguro que deseas truncar {count} tablas seleccionadas? Esto eliminará todas las filas.",
+    confirmDropProcedureTitle: "Eliminar procedimiento",
+    confirmDropProcedureMessage: '¿Seguro que deseas eliminar el procedimiento "{name}"?',
+    confirmDropFunctionTitle: "Eliminar función",
+    confirmDropFunctionMessage: '¿Seguro que deseas eliminar la función "{name}"?',
+    dropViewSuccess: 'Vista "{name}" eliminada',
+    dropProcedureSuccess: 'Procedimiento "{name}" eliminado',
+    dropFunctionSuccess: 'Función "{name}" eliminada',
+    dropTableChildObjectSuccess: '"{name}" eliminado',
+    dropAllIndexesSuccess: 'Se eliminaron {count} índices de "{name}"',
+    batchDropSuccess: "{count} objetos eliminados",
+    batchEmptySuccess: "{count} tablas vaciadas",
+    batchEmptyPartialFail: "Se vaciaron {success} tablas; {failed} fallaron",
+    batchEmptySubmitted: "Se enviaron tareas para vaciar {count} tablas",
+    batchEmptySubmittedPartial: "Se enviaron {success} tareas; {failed} fallaron",
+    batchTruncateSuccess: "{count} tablas truncadas",
+    emptyTableSuccess: 'Todos los datos eliminados de "{name}"',
+    emptyTableSubmitted: 'Tarea de vaciado enviada para "{name}"',
+    truncateTableSuccess: 'Tabla "{name}" truncada',
+    duplicateStructureSuccess: 'Tabla clonada como "{name}"',
+    tableOperationFailed: "Error en la operación: {message}",
+    duplicateNameTitle: "Clonar como tabla nueva",
+    duplicateNamePlaceholder: "Nombre de la nueva tabla",
+    copyTable: "Copiar tabla",
+    pasteTable: "Pegar tabla",
+    pasteOptionStructureAndData: "Estructura y datos",
+    pasteOptionStructureOnly: "Solo estructura",
+    pasteOptionDataOnly: "Solo datos",
+    pasteTableSuccess: 'Tabla pegada como "{name}"',
+    pasteTableConfirmTitle: "Pegar tabla",
+    pasteTableConfirmMessage: "Pegar tabla desde el portapapeles",
+    batchPasteTitle: "Pegar tablas",
+    batchPasteSuccess: "{count} tablas pegadas correctamente",
+    batchPastePartialFail: "{success} tablas pegadas, {failed} fallidas",
+    noTableToPaste: "No hay tablas disponibles para pegar",
+    pasteTableClipboardUpdated: "Tabla copiada al portapapeles",
+    createDatabase: "Crear base de datos",
+    createDuckDbFile: "Crear archivo de base de datos",
+    dropDatabase: "Eliminar base de datos",
+    confirmDropDatabaseTitle: "Eliminar base de datos",
+    confirmDropDatabaseMessage: '¿Estás seguro de que deseas eliminar la base de datos "{name}"? Esto borrará permanentemente la base de datos y todos sus datos.',
+    createDatabaseSuccess: 'Base de datos "{name}" creada',
+    editDatabaseProperties: "Editar propiedades de base de datos",
+    editDatabasePropertiesTitle: 'Editar propiedades de base de datos: "{name}"',
+    editDatabasePropertiesSaving: "Guardando...",
+    editDatabasePropertiesSuccess: 'Propiedades de la base de datos "{name}" actualizadas',
+    editDatabaseComment: "Comentario de base de datos",
+    editDatabaseCommentPlaceholder: "Introduce el comentario de la base de datos...",
+    createDuckDbFileSuccess: 'Archivo de base de datos DuckDB "{name}" creado y adjuntado',
+    createDuckDbFileDesktopOnly: "Crear archivos de base de datos DuckDB solo está disponible en la app de escritorio",
+    dropDatabaseSuccess: 'Base de datos "{name}" eliminada',
+    dropCollection: "Eliminar colección",
+    confirmDropCollectionTitle: "Eliminar colección",
+    confirmDropCollectionMessage: '¿Estás seguro de que deseas eliminar la colección "{name}"? Esto borrará permanentemente la colección y todos sus documentos.',
+    dropCollectionSuccess: 'Colección "{name}" eliminada',
+    createDatabaseNamePlaceholder: "Nombre de la base de datos",
+    createDatabaseCharset: "Conjunto de caracteres",
+    createDatabaseCharsetPlaceholder: "ej. utf8mb4",
+    createDatabaseCharsetSearchPlaceholder: "Buscar o escribir un conjunto de caracteres",
+    createDatabaseCharsetEmpty: "No se encontraron conjuntos de caracteres",
+    createDatabaseCharsetLoading: "Cargando conjuntos de caracteres...",
+    createDatabaseCharsetCustomOption: 'Usar "{value}"',
+    createDatabaseCollation: "Cotejamiento",
+    createDatabaseCollationPlaceholder: "ej. utf8mb4_unicode_ci",
+    createDatabaseCollationSearchPlaceholder: "Buscar o escribir un cotejamiento",
+    createDatabaseCollationEmpty: "No se encontraron cotejamientos",
+    createDatabaseCollationLoading: "Cargando cotejamientos...",
+    createDatabaseCollationCustomOption: 'Usar "{value}"',
+    createSchema: "Crear esquema",
+    dropSchema: "Eliminar esquema",
+    confirmDropSchemaTitle: "Eliminar esquema",
+    confirmDropSchemaMessage: '¿Estás seguro de que deseas eliminar el esquema "{name}"? Esto borrará permanentemente el esquema y todos sus objetos.',
+    createSchemaSuccess: 'Esquema "{name}" creado',
+    dropSchemaSuccess: 'Esquema "{name}" eliminado',
+    createSchemaNamePlaceholder: "Nombre del esquema",
+    editSchemaComment: "Editar comentario",
+    editSchemaCommentTitle: 'Editar comentario: "{name}"',
+    schemaCommentPlaceholder: "Introduce un comentario del esquema...",
+    schemaCommentSaving: "Guardando...",
+    editSchemaCommentSuccess: 'Comentario del esquema "{name}" actualizado',
+    manageExtension: "Administrar extensión...",
+    dropExtension: "Eliminar extensión",
+  },
+  visibleDatabases: {
+    title: "Bases de datos visibles",
+    description: 'Elige qué bases de datos se muestran bajo "{connection}".',
+    searchPlaceholder: "Buscar bases de datos...",
+    selectedCount: "{selected}/{total} seleccionadas",
+    selectAll: "Seleccionar todo",
+    selectFiltered: "Seleccionar resultados de búsqueda",
+    clear: "Limpiar",
+    showAll: "Mostrar todo",
+    showSystemDatabases: "Mostrar bases de datos del sistema",
+    save: "Guardar",
+    emptySelection: "Selecciona al menos una base de datos, o usa Mostrar todo para quitar el filtro.",
+    loadFailed: "No se pudieron cargar las bases de datos: {message}",
+  },
+  visibleSchemas: {
+    title: "Filtro de Schema",
+    description: 'Elige qué schemas se muestran bajo "{connection}".',
+    searchPlaceholder: "Buscar schemas...",
+    selectedCount: "{selected}/{total} seleccionados",
+    selectAll: "Seleccionar todo",
+    selectFiltered: "Seleccionar resultados de búsqueda",
+    clear: "Limpiar",
+    showAll: "Mostrar todo",
+    save: "Guardar",
+    emptySelection: "Selecciona al menos un schema, o usa Mostrar todo para quitar el filtro.",
+    loadFailed: "No se pudieron cargar los schemas: {message}",
+  },
+  tree: {
+    savedSql: "Biblioteca SQL",
+    userAdmin: "Usuarios y Privilegios",
+    damengJobAdmin: "Trabajos del agente",
+    linkedServers: "Servidores vinculados",
+    defaultDatabase: "Base predeterminada",
+    columns: "Columnas",
+    indexes: "Índices",
+    foreignKeys: "Claves foráneas",
+    triggers: "Disparadores",
+    tables: "Tablas",
+    views: "Vistas",
+    materializedViews: "Vistas materializadas",
+    procedures: "Procedimientos",
+    functions: "Funciones",
+    sequences: "Secuencias",
+    packages: "Paquetes",
+    partitions: "Particiones",
+    childTables: "Subtablas",
+    loadMore: "Cargar más...",
+    objectBrowser: "Explorar en el navegador de objetos ({count})",
+    extensions: "Extensiones",
+  },
+  userAdmin: {
+    title: "Usuarios y Privilegios",
+    unsupported: "Se admiten conexiones compatibles con MySQL y PostgreSQL. Los modelos de permisos de SQL Server, Oracle y otros se pueden agregar próximamente.",
+    newUser: "Nuevo usuario",
+    anonymous: "Anónimo",
+    roleName: "Nombre del rol",
+    allowLogin: "Permitir inicio de sesión",
+    searchUser: "Buscar usuario o host",
+    loadingUsers: "Cargando usuarios...",
+    loadingGrants: "Cargando permisos...",
+    emptyUsers: "No se encontraron usuarios, o la cuenta actual no puede leer la lista de usuarios.",
+    pluginUnknown: "Plugin de autenticación desconocido",
+    grants: "Permisos",
+    noGrants: "No se encontraron permisos",
+    privilegeEditor: "Editor de privilegios",
+    privilegeHint: "Elige privilegios, base de datos y tabla, luego previsualiza el SQL antes de aplicar. * significa global o todas las tablas.",
+    database: "Base de datos",
+    schema: "Esquema",
+    table: "Tabla",
+    scope: "Ámbito de concesión",
+    scopeDatabase: "Base de datos",
+    scopeSchema: "Esquema",
+    scopeTable: "Tabla",
+    scopeRole: "Pertenencia a rol",
+    memberRole: "Rol miembro",
+    privileges: "Privilegios",
+    grantOption: "Permitir más concesiones (WITH GRANT OPTION)",
+    adminOption: "Permitir gestión de membresía (WITH ADMIN OPTION)",
+    grant: "Conceder",
+    revoke: "Revocar",
+    username: "Nombre de usuario",
+    host: "Host",
+    changePassword: "Cambiar contraseña",
+    newPassword: "Nueva contraseña",
+    lock: "Bloquear",
+    unlock: "Desbloquear",
+    disableLogin: "Deshabilitar inicio de sesión",
+    enableLogin: "Habilitar inicio de sesión",
+    dropUser: "Eliminar usuario",
+    previewSql: "Vista previa de SQL",
+    sqlPreview: "Vista previa de SQL",
+    applySql: "Aplicar SQL",
+    applySuccess: "Privilegios de usuario actualizados",
+    applyFailed: "Ejecución fallida: {message}",
+  },
+  damengJobAdmin: {
+    title: "Trabajos del agente Dameng",
+    unsupported: "Esta página solo admite conexiones Dameng.",
+    initEnvironment: "Inicializar entorno de trabajos",
+    environmentReady: "Entorno de trabajos inicializado",
+    newJob: "Nuevo trabajo",
+    searchJob: "Buscar trabajos",
+    loadFailed: "Error al cargar",
+    environmentMissingTitle: "El entorno de trabajos no está inicializado",
+    environmentMissingHint: "Esta base de datos aún no tiene el entorno de trabajos SYSJOB.",
+    environmentMissingDescription: "Los trabajos del agente Dameng dependen de tablas y vistas del sistema en el esquema SYSJOB. Inicializa primero el entorno de trabajos; normalmente se requieren privilegios de administrador.",
+    emptyJobs: "No se encontraron trabajos, o la cuenta actual no puede leer la lista de trabajos.",
+    emptyDetails: "No hay filas de detalle",
+    selectJob: "Selecciona un trabajo",
+    enabled: "Habilitado",
+    disabled: "Deshabilitado",
+    running: "En ejecución",
+    enable: "Habilitar",
+    disable: "Deshabilitar",
+    runAsync: "Ejecutar ahora",
+    stopRunning: "Detener ejecución actual",
+    stopRunningDisabled: "Solo se pueden detener trabajos que se estén ejecutando",
+    clearHistories: "Limpiar historial",
+    dropJob: "Eliminar",
+    steps: "Pasos",
+    schedules: "Programaciones",
+    histories: "Historial",
+    noDescription: "Sin descripción",
+    jobName: "Nombre del trabajo",
+    description: "Descripción",
+    stepName: "Nombre del paso",
+    scheduleName: "Nombre de programación",
+    sqlCommand: "Script SQL",
+    scheduleMode: "Tipo de programación",
+    daily: "Diario",
+    once: "Una vez",
+    startDate: "Fecha de inicio",
+    startTime: "Hora de inicio",
+    endTime: "Hora de fin",
+    minuteInterval: "Intervalo en minutos",
+    previewSql: "Vista previa de SQL",
+    sqlPreview: "Vista previa de SQL",
+    applySql: "Aplicar SQL",
+    applySuccess: "Operación de trabajo aplicada",
+    applyFailed: "Ejecución fallida: {message}",
+  },
+  objects: {
+    all: "Todos",
+    tables: "Tablas",
+    views: "Vistas",
+    procedures: "Procedimientos",
+    functions: "Funciones",
+    sequences: "Secuencias",
+    packages: "Paquetes",
+    table: "Tabla",
+    partitions: "{count} particiones",
+    view: "Vista",
+    procedure: "Procedimiento",
+    function: "Función",
+    sequence: "Secuencia",
+    package: "Paquete",
+    packageBody: "Cuerpo del paquete",
+    name: "Nombre",
+    type: "Tipo",
+    rows: "Filas",
+    size: "Tamaño",
+    statisticsHint: "Estimado desde estadísticas de la base de datos; no se ejecuta COUNT(*).",
+    createdAt: "Creado",
+    updatedAt: "Actualizado",
+    source: "Código fuente",
+    saveSource: "Guardar",
+    cancelEdit: "Cancelar",
+    sourceSaved: "Código fuente guardado",
+    sourceSaveFailed: "Error al guardar el código fuente: {message}",
+    schemaColumn: "Esquema",
+    comment: "Comentario",
+    loadingSchemas: "Cargando esquemas...",
+    schema: "Esquema",
+    search: "Buscar tablas, vistas, funciones, secuencias o procedimientos...",
+    loading: "Cargando objetos...",
+    empty: "No se encontraron objetos",
+    selectedTables: "{count} tablas seleccionadas",
+    exportSelected: "Exportar seleccionadas",
+    dropSelected: "Eliminar seleccionadas",
+    truncateSelected: "Truncar seleccionadas",
+    clearSelection: "Limpiar selección",
+    confirmBatchDropTitle: "Eliminar tablas seleccionadas",
+    confirmBatchDropMessage: "¿Seguro que quieres eliminar {count} tablas seleccionadas? Esta acción no se puede deshacer.",
+    confirmBatchTruncateTitle: "Truncar tablas seleccionadas",
+    confirmBatchTruncateMessage: "¿Seguro que quieres truncar {count} tablas seleccionadas? Esto eliminará todas las filas.",
+    batchDropSuccess: "{count} tablas eliminadas",
+    batchTruncateSuccess: "{count} tablas truncadas",
+    copyTableSelected: "Copiar",
+    pasteTableSelected: "Pegar",
+    toggleCheckbox: "Alternar selección múltiple",
+    viewList: "Vista de lista",
+    viewGrid: "Vista de cuadrícula",
+    sourceReadOnly: "Este código fuente es de solo lectura y no se puede editar.",
+    sortAsc: "ascendente",
+    sortDesc: "descendente",
+    sortBy: "ordenar por",
+  },
+  structureEditor: {
+    mysqlDataTypeHelp: {
+      tinyint: "Entero de 1 byte: con signo -128 a 127; sin signo 0 a 255.",
+      smallint: "Entero de 2 bytes: con signo -32.768 a 32.767; sin signo 0 a 65.535.",
+      mediumint: "Entero de 3 bytes: con signo -8.388.608 a 8.388.607; sin signo 0 a 16.777.215.",
+      int: "Entero de 4 bytes: con signo -2.147.483.648 a 2.147.483.647; sin signo 0 a 4.294.967.295.",
+      bigint: "Entero de 8 bytes: con signo -2^63 a 2^63-1; sin signo 0 a 2^64-1.",
+      decimal: "Número decimal exacto; MySQL admite hasta 65 dígitos y escala 30. Úselo para dinero.",
+      float: "Número aproximado de precisión simple; para decimales exactos use DECIMAL.",
+      double: "Número aproximado de doble precisión; para decimales exactos use DECIMAL.",
+      real: "Alias de DOUBLE por defecto; REAL_AS_FLOAT lo convierte en alias de FLOAT.",
+      bit: "Campo de 1 a 64 bits; el ancho predeterminado es 1.",
+      boolean: "Alias de TINYINT(1): 0 es falso y distinto de cero es verdadero.",
+      serial: "Alias práctico de BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE.",
+      date: "Fecha de calendario, de 1000-01-01 a 9999-12-31.",
+      datetime: "Fecha y hora sin conversión de zona; precisión fraccionaria 0 a 6, predeterminada 0.",
+      timestamp: "Fecha y hora convertida entre zona de sesión y UTC; precisión fraccionaria 0 a 6.",
+      time: "Hora o intervalo de -838:59:59 a 838:59:59; precisión fraccionaria 0 a 6.",
+      year: "Año de cuatro dígitos de 1901 a 2155, además de 0000.",
+      char: "Cadena de longitud fija de hasta 255 caracteres, rellenada con espacios.",
+      varchar: "Cadena de longitud variable; el máximo real depende de fila y juego de caracteres.",
+      tinytext: "Texto variable de hasta 255 bytes; fila, charset y max_allowed_packet pueden limitarlo.",
+      text: "Texto variable de hasta 65.535 bytes; fila, charset y max_allowed_packet pueden limitarlo.",
+      mediumtext: "Texto variable de hasta 16.777.215 bytes; fila, charset y max_allowed_packet pueden limitarlo.",
+      longtext: "Texto variable de hasta 4.294.967.295 bytes; fila, charset y max_allowed_packet pueden limitarlo.",
+      binary: "Cadena binaria fija de hasta 255 bytes, rellenada con 0x00.",
+      varbinary: "Cadena binaria variable; el máximo real depende del tamaño de fila.",
+      tinyblob: "Objeto binario de hasta 255 bytes; max_allowed_packet puede limitarlo.",
+      blob: "Objeto binario de hasta 65.535 bytes; max_allowed_packet puede limitarlo.",
+      mediumblob: "Objeto binario de hasta 16.777.215 bytes; max_allowed_packet puede limitarlo.",
+      longblob: "Objeto binario de hasta 4.294.967.295 bytes; max_allowed_packet puede limitarlo.",
+      enum: "Un valor entre hasta 65.535 literales; cambiar el orden puede alterar la semántica almacenada.",
+      set: "Cero o más valores entre hasta 64 miembros declarados.",
+      json: "Documento JSON validado; representación y funciones dependen del producto/versión; limitado por max_allowed_packet.",
+      jsonMysql: "JSON binario nativo de MySQL con validación y funciones JSON; limitado por max_allowed_packet.",
+      jsonMariaDb: "En MariaDB JSON es alias de LONGTEXT con JSON_VALID y colación utf8mb4_bin.",
+      nationalCharacter: "Alias de cadena nacional; MySQL usa utf8mb3, obsoleto; prefiera utf8mb4.",
+      geometry: "Geometría espacial; un índice SPATIAL InnoDB requiere NOT NULL y atributo SRID.",
+      point: "Punto espacial; SPATIAL InnoDB requiere NOT NULL y SRID.",
+      linestring: "Curva espacial; SPATIAL InnoDB requiere NOT NULL y SRID.",
+      polygon: "Superficie espacial; SPATIAL InnoDB requiere NOT NULL y SRID.",
+      multipoint: "Colección de puntos; SPATIAL InnoDB requiere NOT NULL y SRID.",
+      multilinestring: "Colección de curvas; SPATIAL InnoDB requiere NOT NULL y SRID.",
+      multipolygon: "Colección de polígonos; SPATIAL InnoDB requiere NOT NULL y SRID.",
+      geometrycollection: "Colección de geometrías mixtas; SPATIAL InnoDB requiere NOT NULL y SRID.",
+      inet4: "Tipo IPv4 de MariaDB desde 10.10; almacena la dirección en cuatro bytes.",
+      inet6: "Tipo compatible MariaDB para IPv6 e IPv4 mapeada.",
+      uuid: "Identificador único universal de 128 bits proporcionado por servidores compatibles.",
+      vector: "Tipo vector para similitud o ML; disponibilidad y dimensiones dependen de versión.",
+      xmltype: "Tipo XML proporcionado por servidores compatibles.",
+      integerDisplayWidth: "El ancho de visualización entero, por ejemplo INT(11), está obsoleto en MySQL y no limita el rango.",
+      zerofill: "ZEROFILL está obsoleto en MySQL 8 e implica UNSIGNED; formatee en la aplicación.",
+      unsignedNumeric: "UNSIGNED para DECIMAL, FLOAT o DOUBLE está obsoleto en MySQL 8; use CHECK para no negativos.",
+      floatPrecision: "En FLOAT(p), p de 25 a 53 selecciona DOUBLE; use DOUBLE explícitamente.",
+      floatingPointDisplay: "FLOAT(M,D) y DOUBLE(M,D) están obsoletos; use FLOAT/DOUBLE sin parámetros o DECIMAL(M,D).",
+    },
+    postgresDataTypeHelp: {
+      smallint: "Entero con signo de 2 bytes, de -32.768 a 32.767.",
+      integer: "Entero con signo de 4 bytes, de -2.147.483.648 a 2.147.483.647.",
+      bigint: "Entero con signo de 8 bytes, de -2^63 a 2^63-1.",
+      serial: "Sintaxis práctica que crea entero, secuencia, NOT NULL y nextval; no es único por sí mismo y puede tener huecos; prefiera IDENTITY.",
+      numeric: "Decimal exacto con precisión y escala; úselo para dinero y valores sin redondeo binario.",
+      real: "Flotante de precisión simple de 4 bytes; FLOAT(p) de 1 a 24 lo selecciona.",
+      double: "Flotante de doble precisión de 8 bytes; FLOAT sin precisión es alias y FLOAT(p) de 25 a 53 lo selecciona.",
+      money: "Importe monetario dependiente de lc_monetary; NUMERIC suele ser más seguro para datos portables.",
+      boolean: "Valor lógico verdadero, falso o nulo; BOOL es alias de BOOLEAN.",
+      char: "Cadena fija rellenada con espacios; CHARACTER es alias.",
+      varchar: "Cadena variable con límite opcional; CHARACTER VARYING es alias.",
+      text: "Cadena variable sin límite declarado; se almacena como VARCHAR sin límite.",
+      bytea: "Cadena binaria variable; TOAST puede almacenar valores grandes fuera de fila.",
+      date: "Fecha de calendario sin hora ni zona horaria.",
+      time: "Hora sin zona, con precisión fraccionaria opcional.",
+      timetz: "Hora con desplazamiento UTC; uso limitado, prefiera timestamptz para un instante.",
+      timestamp: "Fecha y hora sin conversión de zona para valores locales.",
+      timestamptz: "Instante almacenado en UTC y mostrado en la zona de sesión; no conserva la zona original.",
+      interval: "Duración en meses, días y microsegundos; las unidades de calendario no tienen duración fija.",
+      uuid: "Identificador único universal de 128 bits.",
+      json: "Texto JSON en representación original; se valida al analizar, pero suele ser más lento que JSONB.",
+      jsonb: "JSON binario descompuesto para procesamiento e índices; no conserva espacios, orden ni claves duplicadas.",
+      xml: "Valor XML con validación de documento o contenido según la opción.",
+      bit: "Cadena de bits fija o variable; BIT VARYING y VARBIT son alias variables.",
+      tsvector: "Lexemas normalizados para búsqueda de texto completo; suele indexarse con GIN o GiST.",
+      tsquery: "Consulta booleana de texto completo evaluada contra tsvector.",
+      cidr: "Red IPv4 o IPv6 con bits de host forzados a cero.",
+      inet: "Host IPv4 o IPv6 con máscara opcional; a diferencia de CIDR puede tener bits de host distintos de cero.",
+      macaddr: "Dirección MAC; MACADDR usa 6 bytes y MACADDR8 usa 8 bytes.",
+      geometry: "Geometría plana bidimensional sin SRID; use PostGIS para coordenadas geográficas y operaciones espaciales avanzadas.",
+      range: "Rango continuo con límites inclusivos/exclusivos; use multirange para rangos separados.",
+      oid: "Identificador de objeto sin signo del sistema; no es una clave primaria estable de aplicación.",
+      array: "Arreglo PostgreSQL de cualquier elemento, incluso multidimensional; las dimensiones declaradas no se fuerzan.",
+      multirange: "Conjunto de rangos no superpuestos; PostgreSQL normaliza miembros adyacentes o solapados.",
+      jsonpath: "Expresión de ruta SQL/JSON usada por consultas y predicados JSONB.",
+      pgLsn: "Ubicación WAL para replicación y recuperación; no es un número de secuencia de aplicación.",
+      pgSnapshot: "Instantánea de visibilidad de transacciones para operaciones de base de datos, no datos generales.",
+    },
+    sqliteDataTypeHelp: {
+      integer: "Afinidad INTEGER; una columna normal no fuerza esa clase. INTEGER PRIMARY KEY exacto es alias de rowid.",
+      real: "Afinidad REAL con IEEE 754; no apta para dinero exacto.",
+      text: "Afinidad TEXT; VARCHAR(n) y CHAR(n) no fuerzan n; use CHECK si importa la longitud.",
+      blob: "Afinidad BLOB: almacena bytes sin conversión.",
+      numeric: "Afinidad NUMERIC convierte texto numérico primero a INTEGER y luego a REAL; DATE, DATETIME y TIME también la usan.",
+    },
+    title: "Editar estructura de tabla",
+    createTitle: "Crear tabla",
+    editTabTitle: "Editar: {tableName}",
+    tableName: "Nombre de tabla",
+    refresh: "Actualizar estructura",
+    density: "Densidad",
+    densityCompact: "Compacta",
+    densityStandard: "Estándar",
+    densityComfortable: "Cómoda",
+    columns: "Columnas",
+    indexes: "Índices",
+    foreignKeys: "Claves foráneas",
+    triggers: "Disparadores",
+    ddl: "DDL",
+    addColumn: "Agregar columna",
+    columnTemplates: "Insertar campos predefinidos",
+    configureColumnTemplates: "Configurar campos predefinidos",
+    presetFieldsTemplate: "Conjunto de campos predefinidos",
+    searchColumns: "Buscar columna/comentario",
+    nextColumnMatch: "Ir a la siguiente columna coincidente",
+    searchIndexes: "Buscar índice",
+    nextIndexMatch: "Ir al siguiente índice coincidente",
+    addIndex: "Agregar índice",
+    addForeignKey: "Agregar clave foránea",
+    addTrigger: "Agregar disparador",
+    columnName: "Columna",
+    dataType: "Tipo",
+    typePlaceholder: "Seleccionar o escribir...",
+    noMatchingType: "Sin coincidencias",
+    length: "Longitud",
+    nullable: "Admite nulos",
+    primaryKey: "Clave primaria",
+    defaultValue: "Valor por defecto",
+    defaultValuePresets: "Valores predeterminados preestablecidos",
+    comment: "Comentario",
+    characterSet: "Conjunto de caracteres",
+    charsetPlaceholder: "Charset",
+    collation: "Cotejamiento",
+    collationPlaceholder: "Cotejamiento",
+    editComment: "Editar comentario",
+    commentPlaceholder: "Ingresar comentario de columna...",
+    tableCommentPlaceholder: "Ingresar comentario de tabla...",
+    tableCommentUnsupported: "La base de datos no admite comentarios de tabla",
+    actions: "Acciones",
+    indexName: "Índice",
+    indexColumns: "Columnas",
+    indexColumnsPlaceholder: "Seleccionar columnas...",
+    unique: "Único",
+    indexType: "Tipo",
+    includedColumns: "Incluidas",
+    includedColumnsPlaceholder: "Seleccionar columnas...",
+    filter: "Filtro",
+    foreignKeyName: "Clave foránea",
+    referencedSchema: "Esquema ref",
+    referencedTable: "Tabla ref",
+    referencedColumn: "Columna ref",
+    onDelete: "Al eliminar",
+    onUpdate: "Al actualizar",
+    defaultAction: "Predeterminado",
+    triggerName: "Disparador",
+    triggerStatement: "Sentencia del disparador",
+    primary: "Primaria",
+    drop: "Eliminar",
+    restore: "Restaurar",
+    remove: "Quitar",
+    moveColumnUp: "Mover columna arriba",
+    moveColumnDown: "Mover columna abajo",
+    dragColumn: "Arrastra para reordenar columnas",
+    localColumnOrderNotice: "El orden de las columnas se guarda solo localmente y no modifica la estructura de la base de datos.",
+    yes: "Sí",
+    no: "No",
+    emptyReadonly: "Sin registros",
+    sqlPreview: "Vista previa de SQL",
+    collapseSqlPreview: "Contraer vista previa de SQL",
+    expandSqlPreview: "Expandir vista previa de SQL",
+    noChanges: "Sin cambios",
+    apply: "Aplicar cambios",
+    ready: "Listo",
+    saved: "Estructura de tabla actualizada",
+    copySql: "Copiar SQL",
+    sqliteRebuildNotice: "SQLite conserva una instantánea de datos inerte como copia de seguridad, reconstruye la tabla en una sola transacción y fuerza CAST en las columnas modificadas. Los valores no representables pueden convertirse en 0/0.0; si ocurre un error, se revierte todo.",
+    extendedProperties: "Extendido",
+    autoIncrement: "Auto Incremento",
+    onUpdateCurrentTimestamp: "Actualización Auto",
+    identity: "Identidad",
+    identityGeneration: "Generación",
+    identitySeed: "Semilla",
+    identityIncrement: "Incremento",
+    sqlServerIdentityTypeHint: "La identidad de SQL Server solo admite tinyint, smallint, int, bigint y decimal/numeric con escala 0",
+  },
+  diagram: {
+    title: "Diagrama de relaciones",
+    open: "Ver diagrama",
+    selectConnection: "Seleccionar conexión",
+    selectDatabase: "Seleccionar base de datos",
+    selectSchema: "Seleccionar esquema",
+    searchTables: "Buscar tablas, columnas, claves...",
+    refresh: "Actualizar diagrama",
+    loading: "Leyendo relaciones...",
+    loadingProgress: "Leyendo relaciones... {loaded}/{total}",
+    partialError: "Se omitieron los metadatos de {count} tablas que no pudieron cargarse",
+    selectTarget: "Selecciona una conexión y base de datos",
+    empty: "No hay tablas para mostrar",
+    noMatches: "No hay tablas coincidentes",
+    tablesCount: "{count} tablas",
+    relationshipsCount: "{count} relaciones",
+    tableMode: "Vista de tabla",
+    engineeringMode: "ER de ingeniería",
+    allTables: "Todas las tablas",
+    relatedTables: "Tablas relacionadas",
+    moreColumns: "+ {count} columnas",
+    exportSvg: "Exportar SVG",
+    exportedSvg: "SVG exportado",
+    exportSvgFailed: "Error al exportar SVG: {message}",
+    zoomIn: "Acercar",
+    zoomOut: "Alejar",
+    resetLayout: "Restablecer diseño",
+    modelRelationships: "Relaciones de modelo",
+    copyJoinSql: "Copiar SQL",
+    customRelationshipsCount: "{count} modeladas",
+    relationshipName: "Nombre",
+    relationshipNamePlaceholder: "Opcional",
+    sourceTable: "Tabla de origen",
+    sourceColumn: "Columna de origen",
+    targetTable: "Tabla de destino",
+    targetColumn: "Columna de destino",
+    cardinality: "Cardinalidad",
+    cardinalityOneToMany: "1:N",
+    cardinalityManyToOne: "N:1",
+    cardinalityOneToOne: "1:1",
+    addRelationship: "Agregar relación",
+    removeRelationship: "Eliminar relación",
+    relationshipIncomplete: "Selecciona ambas columnas de origen y destino",
+    relationshipSelfInvalid: "Una relación no puede apuntar a la misma columna",
+    relationshipExists: "Esta relación ya existe",
+    relationshipAdded: "Relación agregada",
+    noJoinSql: "No hay SQL de relación para copiar",
+  },
+  etcd: {
+    prefixPlaceholder: "Prefijo, ej. /app/",
+    newKey: "Nueva clave",
+    loadingKeys: "Cargando claves...",
+    empty: "No se encontraron claves",
+    loadMore: "Cargar más",
+    selectKey: "Selecciona una clave para ver su valor",
+    loadingValue: "Cargando valor...",
+    notFound: "Clave no encontrada",
+    edit: "Editar",
+    editKey: "Editar clave",
+    delete: "Eliminar",
+    deleteTitle: "Eliminar clave de etcd",
+    keyPlaceholder: "/ruta/a/clave",
+    keyRequired: "La clave es obligatoria",
+    saved: "Clave guardada",
+    deleted: "Clave eliminada",
+    base64Readonly: "Los valores Base64 son de solo lectura en esta versión.",
+  },
+  zookeeper: {
+    prefixPlaceholder: "Prefijo de ruta, ej. /app/",
+    newKey: "Nuevo Znode",
+    loadingKeys: "Cargando znodes...",
+    empty: "No se encontraron znodes",
+    loadMore: "Cargar más",
+    selectKey: "Selecciona un znode para ver su valor",
+    loadingValue: "Cargando valor...",
+    notFound: "Znode no encontrado",
+    edit: "Editar",
+    editKey: "Editar Znode",
+    delete: "Eliminar",
+    deleteTitle: "Eliminar znode de ZooKeeper",
+    keyPlaceholder: "/ruta/a/znode",
+    keyRequired: "La ruta del znode es obligatoria",
+    rootReadonly: "El znode raíz no se puede modificar. Introduce una ruta de znode hijo.",
+    saved: "Znode guardado",
+    deleted: "Znode eliminado",
+    base64Readonly: "Los valores Base64 son de solo lectura en esta versión.",
+    createMode: "Modo de creación",
+    createModePersistent: "Persistente",
+    createModeEphemeral: "Efímero",
+    createModePersistentSequential: "Persistente secuencial",
+    createModeEphemeralSequential: "Efímero secuencial",
+    add: "Agregar",
+    value: "Valor",
+    metadata: "Información del nodo",
+    prettyJson: "Bonito",
+    invalidJson: "JSON no válido",
+    summaryRevision: "rev",
+    summaryVersion: "ver",
+    summaryLease: "lease",
+    summarySize: "tamaño",
+  },
+  redis: {
+    createKeyTypeHelp: {
+      string: "Valor único de hasta 512 MB; útil para caché y contadores.",
+      hash: "Mapa plano campo-valor; leer un Hash grande completo es O(N).",
+      list: "Secuencia ordenada; acceso intermedio lineal.",
+      set: "Miembros únicos sin orden; enumerar conjuntos grandes es lineal.",
+      zset: "Miembros únicos con puntuación flotante; escritura O(log N).",
+      stream: "Registro append-only; gestione XACK, pendientes y recorte.",
+      json: "JSON por ruta; requiere RedisJSON/Redis Stack y suele costar más que String o Hash.",
+    },
+    selectKey: "Selecciona una clave para ver su valor",
+    noKeys: "No se encontraron claves",
+    noKeysInScanHint: "No se encontraron claves en el rango de escaneo actual",
+    pattern: "patrón (p. ej. usuario:*)",
+    fuzzyPattern: "la clave contiene...",
+    fuzzyMatch: "Difusa",
+    fuzzyMatchTitle: "Coincidencia difusa: busca claves que contengan texto plano",
+    valueSearchPlaceholder: "el valor contiene...",
+    allSearchPlaceholder: "la clave o el valor contiene...",
+    searchByKey: "Clave",
+    searchByValue: "Valor",
+    searchByAll: "Todo",
+    searchFields: "Buscar campos y valores",
+    keys: "{count} claves",
+    loadedKeys: "{loaded} / {total} claves cargadas",
+    loadingKeys: "Cargando claves...",
+    searchingValues: "Buscando por valor...",
+    searchingAll: "Buscando claves y valores...",
+    loadMoreKeys: "Cargar más claves",
+    fetchAllKeys: "Cargar todas",
+    stopFetchAll: "Detener",
+    fetchAllProgress: "{loaded} de {total} claves cargadas",
+    fetchAllProgressUnknown: "{loaded} claves cargadas",
+    items: "{count} elementos",
+    fields: "{count} campos",
+    members: "{count} miembros",
+    loadedItems: "{loaded} de {total} elementos cargados",
+    loadedFields: "{loaded} de {total} campos cargados",
+    loadedMembers: "{loaded} de {total} miembros cargados",
+    entries: "{count} entradas",
+    noExpiry: "sin expiración",
+    autoRefresh: "Actualización automática",
+    ttlDay: "{count}d",
+    columnType: "Tipo",
+    columnKey: "Clave",
+    columnValue: "Valor",
+    columnSize: "Tamaño",
+    columnTTL: "TTL",
+    binaryStringReadonlyHint: "Los valores de cadena binaria se muestran como texto escapado en modo de solo lectura; la edición de bytes sin procesar no está disponible.",
+    selectedKeys: "Claves seleccionadas",
+    deleteGroup: "Eliminar grupo",
+    deleteGroupDetails: "{target}\n{count} claves",
+    flushDb: "Limpiar DB actual",
+    flushDbMessage: "Esto eliminará todas las claves de la base de datos Redis actual y no se puede deshacer. ¿Continuar?",
+    flushDbDetails: "Destino: Redis db{db}\nAlcance: todas las claves de la DB actual",
+    flushDbConfirm: "Limpiar DB",
+    flushDbSuccess: "Redis db{db} limpiada",
+    keyDetail: "Detalle de clave",
+    commandLine: "Línea de comandos",
+    selectKeyForDetail: "Selecciona una clave para ver detalles",
+    commandWelcome: "Bienvenido a la consola de comandos Redis",
+    commandPlaceholder: "Comando Redis, p. ej. GET user:1",
+    commandPrefix: "CMD",
+    commandHint: "Ingresa un comando Redis, p. ej. SMEMBERS feature:flags",
+    executeCommand: "Ejecutar comando",
+    commandEmpty: "Ingresa un comando Redis",
+    commandEmptyResult: "Ejecuta un comando Redis para ver el resultado",
+    commandBlocked: "Este comando Redis está bloqueado por seguridad",
+    createKey: "Crear clave",
+    createKeyName: "Clave",
+    createKeyNamePlaceholder: "user:1",
+    createKeyType: "Tipo",
+    createValue: "Valor",
+    createMember: "Miembro",
+    createField: "Campo",
+    createFieldPlaceholder: "name",
+    createScore: "Puntuación",
+    createKeyTtl: "TTL (segundos)",
+    createKeyTtlPlaceholder: "vacío = sin expiración",
+    createKeyAddEntry: "Agregar entrada",
+    createKeyEntryId: "ID de entrada",
+    createKeyRawMode: "Entrada bruta",
+    createKeyEntries: "Entradas",
+    createValuePlaceholder: "valor",
+    jsonModuleNotAvailable: "El módulo ReJSON no está cargado en este servidor Redis",
+    createKeySubmit: "Crear",
+    createKeyNameRequired: "Ingresa una clave",
+    createFieldRequired: "Ingresa un campo hash",
+    createScoreInvalid: "Ingresa una puntuación válida",
+    fieldRequired: "Ingresa un nombre de campo",
+    valueRequired: "Ingresa un valor",
+    memberRequired: "Ingresa un miembro",
+    ttlInvalid: "Ingresa un TTL válido en segundos (-1 para sin caducidad)",
+    member: "Miembro",
+    memberDetail: "Detalle del miembro",
+    viewMember: "Ver valor completo",
+    copyMember: "Copiar miembro",
+    copyKeyName: "Copiar nombre de clave",
+    copied: "Copiado",
+    editMember: "Editar",
+    jsonView: "Vista JSON",
+    rawContent: "Contenido original",
+    wordWrap: "Ajuste de línea",
+    clearHistory: "Borrar historial de comandos",
+    historyCleared: "Historial de comandos Redis borrado",
+    blockedCommand: "El comando {command} está bloqueado por seguridad. Desactiva el icono de escudo en la barra de herramientas para permitirlo.",
+    pubsub: "Pub/Sub",
+    pubsubConnected: "Conectado",
+    pubsubConnecting: "Conectando...",
+    pubsubDisconnected: "Desconectado",
+    pubsubConnect: "Conectar",
+    pubsubDisconnect: "Desconectar",
+    pubsubChannels: "Canales",
+    pubsubChannelPlaceholder: "Nombre del canal",
+    pubsubSubscribe: "Suscribirse",
+    pubsubPatterns: "Patrones",
+    pubsubPatternPlaceholder: "Patrón (ej. news:*)",
+    pubsubPsubscribe: "PSuscribirse",
+    pubsubMessages: "Mensajes",
+    pubsubClear: "Limpiar",
+    pubsubEmpty: "Sin mensajes. Suscríbete a un canal para recibir mensajes.",
+    pubsubPublish: "Publicar",
+    pubsubPublishChannel: "Canal",
+    pubsubPublishMessage: "Mensaje",
+    pubsubSend: "Enviar",
+    pubsubPublishFailed: "Publicación fallida: {error}",
+    pubsubWsConnectFailed: "Conexión WebSocket fallida: {error}",
+    copyInsertStatement: "Copiar sentencia INSERT",
+    copyInsertStatementBinary: "No se puede generar una sentencia INSERT para datos binarios",
+    formatJson: "Formatear",
+    compressJson: "Comprimir",
+    jsonFormatError: "Formato JSON no válido",
+    slowlog: "Slow Log",
+    slowlogCount: "Conteo",
+    slowlogQuery: "Consulta",
+    slowlogNode: "Nodo",
+    slowlogSelectNode: "Seleccionar un nodo",
+    slowlogNodeRequired: "Selecciona un nodo primero",
+    slowlogEmpty: "Haz clic en Consultar para obtener entradas del slow log",
+    slowlogFetchFailed: "Error al obtener slow log: {error}",
+    slowlogColumnId: "ID",
+    slowlogColumnTimestamp: "Marca de tiempo",
+    slowlogColumnDuration: "Duración (μs)",
+    slowlogColumnCommand: "Comando",
+    slowlogColumnClientAddr: "Cliente",
+    slowlogColumnClientName: "Nombre del cliente",
+    slowlogTotal: "{count} entradas",
+    slowlogDetailTitle: "Entrada de Slow Log #{id}",
+  },
+  mongo: {
+    documents: "{count} documentos",
+    addField: "Agregar campo",
+    deleteField: "Eliminar campo",
+    field: "Campo",
+    value: "Valor",
+    fieldPlaceholder: "Nombre del campo",
+    emptyCollection: "Colección vacía",
+    selectDocument: "Selecciona un documento",
+    readonlyId: "_id es de solo lectura",
+    invalidJsonValue: "Esta celda no contiene un valor JSON válido",
+    duplicateField: "Nombre de campo duplicado: {field}",
+    edit: "Editar",
+    documentView: "Vista de documento",
+    tableView: "Vista de tabla",
+    filterPlaceholder: "Filtro...",
+    sortPlaceholder: "Orden...",
+  },
+  vector: {
+    collectionFallback: "colección",
+    productCollection: "Colección de {product}",
+    browse: "Examinar",
+    search: "Buscar",
+    upsert: "Upsert",
+    delete: "Eliminar",
+    reset: "Restablecer",
+    refresh: "Actualizar",
+    run: "Ejecutar",
+    apply: "Aplicar",
+    requestEditor: "Editor de solicitudes vectoriales",
+    operationSuccess: "Operación completada. La vista previa de la colección se ha actualizado.",
+    vectorLabel: "Vector",
+  },
+  history: {
+    title: "Historial",
+    search: "Buscar en historial...",
+    empty: "Sin historial aún",
+    emptyFilteredRecent: "No hay registros coincidentes en las últimas 200 entradas del historial de ejecución",
+    failed: "Fallida",
+    success: "Exitosa",
+    restore: "Restaurar en el editor",
+    copy: "Copiar SQL",
+    delete: "Eliminar",
+    clear: "Limpiar historial",
+    viewDetails: "Ver detalles",
+    analyzeWithAi: "Analizar con IA",
+    aiAnalyzeNoConnection: "No se puede analizar esta entrada porque su conexión ya no existe.",
+    aiAnalysisTab: "Análisis del historial",
+    rollback: "Revertir",
+    rollbackSql: "SQL de reversión",
+    rollbackAvailable: "Disponible",
+    rollbackUnavailable: "Sin SQL de reversión",
+    rollbackConfirm: "¿Ejecutar el SQL de reversión generado para esta entrada del historial?",
+    rollbackSuccess: "Reversión ejecutada",
+    rollbackFailed: "Error al revertir: {message}",
+    confirmDelete: "¿Eliminar esta entrada del historial?",
+    confirmClear: "¿Limpiar todo el historial?",
+    filters: {
+      all: "Todas",
+      query: "Consultas",
+      data_change: "Cambios de datos",
+      schema_change: "Cambios de esquema",
+      failed: "Fallidas",
+    },
+    dateRange: {
+      title: "Rango de tiempo",
+      label: "Hora de ejecución:",
+      start: "Fecha inicial",
+      end: "Fecha final",
+      apply: "Aplicar",
+      clear: "Limpiar",
+      invalid: "La fecha inicial no puede ser posterior a la fecha final",
+      unboundedStart: "Inicio",
+      unboundedEnd: "Fin",
+    },
+    kinds: {
+      query: "Consulta",
+      data_change: "Cambio de datos",
+      schema_change: "Cambio de esquema",
+      import: "Importación",
+      transfer: "Transferencia",
+      redis_command: "Comando Redis",
+    },
+    kindShort: {
+      query: "SQL",
+      data_change: "Datos",
+      schema_change: "DDL",
+      import: "Import",
+      transfer: "Mover",
+      redis_command: "Redis",
+    },
+    detail: {
+      kind: "Tipo",
+      operation: "Operación",
+      connection: "Conexión",
+      database: "Base de datos",
+      target: "Destino",
+      time: "Hora",
+      duration: "Duración",
+      affectedRows: "Filas afectadas",
+      rollback: "Reversión",
+      status: "Estado",
+      error: "Error",
+    },
+  },
+  dangerDialog: {
+    title: "Operación peligrosa",
+    message: "Esta sentencia SQL puede modificar o eliminar datos de forma irreversible. ¿Estás seguro de que deseas ejecutarla?",
+    redisCommandMessage: "Este comando de Redis puede modificar datos y no se puede deshacer automáticamente. ¿Continuar?",
+    suppressFuturePrompts: "No volver a preguntar para SQL peligroso",
+    wrapLines: "Alternar ajuste de línea",
+    deleteMessage: "Esta operación de eliminación puede ser irreversible. ¿Continuar?",
+    deleteConfirm: "Confirmar eliminación",
+    deleteRowMessage: "Esta fila quedará marcada para eliminación y se borrará de la base de datos al guardar. ¿Continuar?",
+    deleteRowsMessage: "Estas {count} filas se marcarán para eliminación y se eliminarán de la base de datos después de guardar. ¿Continuar?",
+    deleteRowDetails: "Tabla: {table}",
+    deleteRowDetailsNoTable: "Fila actual del resultado",
+    redisKeyDetails: "Clave Redis: {key}",
+    redisHashFieldDetails: "Hash Redis: {key}\nCampo: {field}",
+    redisListItemDetails: "Lista Redis: {key}\nÍndice: {index}",
+    redisSetMemberDetails: "Conjunto Redis: {key}\nMiembro: {member}",
+    mongoDocumentDetails: "Colección MongoDB: {collection}\nDocumento _id: {id}",
+    mongoFieldDetails: "Campo: {field}",
+    mongoArrayItemDetails: "Índice del elemento del arreglo: {index}",
+    cancel: "Cancelar",
+    confirm: "Ejecutar",
+  },
+  sqlParameters: {
+    title: "Parámetros SQL",
+    description: "Completa valores para marcadores de plantilla SQL. DBX los reemplaza antes de ejecutar el SQL.",
+    name: "Parámetro",
+    syntax: "Sintaxis",
+    type: "Tipo",
+    value: "Valor",
+    valuePlaceholder: "Introduce un valor",
+    preview: "Vista previa SQL",
+    execute: "Ejecutar",
+    kind: {
+      string: "Cadena",
+      number: "Número",
+      boolean: "Booleano",
+      null: "NULL",
+      raw: "SQL sin procesar",
+    },
+  },
+  transfer: {
+    title: "Transferencia de datos",
+    source: "Origen",
+    target: "Destino",
+    sourceConnection: "Conexión de origen",
+    sourceDatabase: "Base de datos de origen",
+    targetConnection: "Conexión de destino",
+    targetDatabase: "Base de datos de destino",
+    tables: "Tablas",
+    selectAll: "Seleccionar todas",
+    deselectAll: "Deseleccionar todas",
+    createTable: "Crear tabla si no existe",
+    transferMode: "Modo de transferencia",
+    modeAppend: "Agregar (INSERT)",
+    modeOverwrite: "Sobrescribir (TRUNCATE + INSERT)",
+    modeUpsert: "Upsert (INSERT o UPDATE por PK)",
+    targetTableNameCase: "Mayúsculas/minúsculas de tabla destino",
+    tableNameCasePreserve: "Conservar",
+    tableNameCaseLower: "Convertir a minúsculas",
+    tableNameCaseUpper: "Convertir a mayúsculas",
+    batchSize: "Tamaño de lote",
+    start: "Iniciar transferencia",
+    cancel: "Cancelar",
+    progress: "Transfiriendo...",
+    transferring: "Transfiriendo {table}...",
+    completed: "Transferencia completada",
+    completedWithErrors: "Completada con {count} tabla con error | Completada con {count} tablas con error",
+    failed: "Error en la transferencia",
+    cancelled: "Transferencia cancelada",
+    rowsTransferred: "{count} filas transferidas",
+    tableProgress: "{current} / {total} tablas",
+    noSqlConnections: "No hay conexiones SQL disponibles",
+    selectTables: "Selecciona las tablas a transferir",
+    searchTables: "Buscar tablas...",
+    noTables: "Sin tablas",
+    selectSourceFirst: "Selecciona primero la conexión y base de datos de origen",
+    tableError: "Error en tabla {table}: {error}",
+    overallProgress: "Progreso general",
+    dataTransfer: "Transferencia de datos",
+    sourceSchema: "Esquema de origen",
+    targetSchema: "Esquema de destino",
+    runInBackground: "Ejecutar en segundo plano",
+    newTask: "Nueva transferencia",
+    editConfig: "Editar config",
+    retry: "Reintentar",
+    targetTableBusy: "Otra transferencia ya está escribiendo en la(s) tabla(s) de destino: {tables}",
+    ownershipTitle: "Confirmar propietario",
+    ownershipMessage: "La base de datos de destino no tiene estos usuarios o roles propietarios: {owners}. Aplicar el propietario original puede fallar.",
+    ownershipSkipDetails: "Omitir no ejecutará las sentencias de cambio de propietario de objetos. Los datos de tablas y otras estructuras seguirán sincronizándose.",
+    ownershipTargetOwner: "Confirmar reasignará los objetos con propietarios ausentes al usuario de conexión de destino: {owner}.",
+    ownershipSkip: "Omitir",
+    ownershipConfirm: "Confirmar",
+    selectConnection: "Seleccionar conexión",
+    selectDatabase: "Seleccionar base de datos",
+    selectSchema: "Seleccionar esquema",
+    searchConnection: "Buscar conexiones...",
+    searchDatabase: "Buscar bases de datos...",
+    searchSchema: "Buscar esquemas...",
+  },
+  tableImport: {
+    title: "Importar datos a tabla",
+    target: "Tabla destino",
+    selectFile: "Seleccionar archivo",
+    changeFile: "Change File",
+    noFileSelected: "No file selected",
+    sourceFile: "Source file",
+    sourceFormat: "Source format",
+    stepSource: "Source",
+    stepOptions: "Options",
+    stepMapping: "Mapping",
+    stepReview: "Review",
+    stepExecution: "Run",
+    formatCsv: "CSV",
+    formatCsvDescription: "Comma-separated text",
+    formatTsv: "TSV",
+    formatTsvDescription: "Tab-separated text",
+    formatDelimited: "Delimited",
+    formatDelimitedDescription: "Custom text delimiter",
+    formatJson: "JSON",
+    formatJsonDescription: "Object or array rows",
+    formatExcel: "Excel",
+    formatExcelDescription: "XLS, XLSX, XLSM",
+    previewRows: "Preview rows",
+    delimiter: "Delimiter",
+    hasHeader: "First row is header",
+    trimValues: "Trim values",
+    emptyStringAsNull: "Empty string as NULL",
+    jsonShape: "JSON rows",
+    jsonShapeAuto: "Auto-detect",
+    jsonShapeObjects: "Objects",
+    jsonShapeArrays: "Arrays",
+    sheet: "Sheet",
+    firstSheet: "First sheet",
+    loadPreview: "Load Preview",
+    reloadPreview: "Reload Preview",
+    previewReady: "{rows} rows, {columns} columns",
+    file: "Archivo",
+    rows: "Filas",
+    mapped: "Mapeadas",
+    mapping: "Mapeo de columnas",
+    sourceColumn: "Origen",
+    targetColumn: "Destino",
+    targetDataType: "Tipo",
+    createColumns: "Columnas a crear",
+    skipColumn: "Omitir",
+    preview: "Vista previa",
+    mode: "Modo de importación",
+    append: "Agregar datos",
+    truncate: "Truncar e importar",
+    progress: "Progreso",
+    start: "Iniciar importación",
+    success: "Se importaron {count} filas",
+    back: "Back",
+    next: "Next",
+    truncateWarning: "Existing rows in the target table will be removed before import starts.",
+    requiredUnmapped: "Required target columns are not mapped: {columns}",
+    status_idle: "Ready to import",
+    status_running: "Importing data",
+    status_done: "Import complete",
+    status_error: "Import failed",
+    status_cancelled: "Import cancelled",
+  },
+  dataGenerate: {
+    title: "Generación de datos",
+    target: "Destino",
+    rowCount: "Filas a generar",
+    columns: "Columnas",
+    column: "Columna",
+    type: "Tipo",
+    generator: "Generador",
+    columnProps: "Propiedades de columna",
+    databaseObjects: "Objetos de base de datos",
+    selectTable: "Seleccione una tabla a la izquierda",
+    saveProfile: "Guardar perfil",
+    loadProfile: "Cargar perfil",
+    options: "Opciones",
+    generateOrder: "Orden de generación",
+    nextStep: "Siguiente",
+    insertSuccess: "Se insertaron {count} filas",
+    noData: "No data yet, please configure generation rules first",
+    noResult: "No execution results",
+    regenerate: "Regenerate",
+    first50Rows: "Showing first 50 rows, total {count} rows",
+    resultTitle: "Resultados de ejecución",
+    successLabel: "{count} exitosas",
+    failLabel: "{count} fallidas",
+    totalLabel: "/ {count} filas",
+    copyAllSql: "Copy All SQL",
+    prevStep: "Anterior",
+    startInsert: "Start Insert",
+    confirm: "Confirmar",
+    back: "Volver",
+    reset: "Reset",
+    selectGenerator: "Select a generator...",
+    selectGeneratorHint: "Please select a generator",
+    preview: "Preview",
+    noValue: "(ninguno)",
+    startDate: "Start Date",
+    endDate: "End Date",
+    allDay: "All day",
+    startTime: "Start Time",
+    endTime: "End Time",
+    weekday: "Weekday",
+    all: "All",
+    weekdayOnly: "Weekdays",
+    custom: "Custom",
+    values: "Values",
+    min: "Min",
+    max: "Max",
+    increment: "Incremento",
+    cycle: "Cycle when exceeded",
+    includeDefault: "Include DEFAULT",
+    includeNull: "Include NULL",
+    unique: "Set unique",
+    disableLinks: "Disable data links between columns",
+    imageMode: "Mode",
+    generate: "Generate",
+    fromFolder: "From folder",
+    imageWidth: "Image Width",
+    imageHeight: "Image Height",
+    imageFormat: "Image Format",
+    folderPath: "Folder Path",
+    filterByExtension: "Filter by extensions",
+    errorContinue: "Continue on error",
+    truncateBefore: "Truncate table before generation",
+    useTransaction: "Use transaction",
+    extendedInsert: "Use extended INSERT",
+    ok: "OK",
+    noTablesSelected: "No tables selected",
+    orderHint: "Use arrow buttons to reorder",
+    gen: {
+      general: "General",
+      personal: "Personal",
+      payment: "Payment",
+      business: "Business",
+      location: "Location",
+      product: "Product",
+      computer: "Computer",
+      number: "Number",
+      datetime: "Date Time",
+      date: "Date",
+      time: "Time",
+      sequence: "Sequence",
+      enum: "Enum",
+      text: "Text",
+      image: "Image or Binary",
+      foreign_key: "Foreign Key",
+      uuid: "UUID",
+      regex: "Regex",
+      full_name: "Full Name",
+      gender: "Gender",
+      title: "Title",
+      marital_status: "Marital Status",
+      phone: "Phone",
+      email: "Email",
+      job_title: "Job Title",
+      social_id: "Social ID",
+      payment_method: "Payment Method",
+      credit_card_type: "Credit Card Type",
+      credit_card_number: "Credit Card Number",
+      credit_card_date: "Credit Card Date",
+      company_name: "Company Name",
+      department: "Department",
+      industry: "Industry",
+      address: "Address",
+      city: "City",
+      region: "Region",
+      product_name: "Product Name",
+      product_category: "Product Category",
+      color: "Color",
+      size: "Size",
+      weight_unit: "Weight Unit",
+      barcode: "Barcode",
+      sku: "SKU",
+      ip_address: "IP Address",
+      mac_address: "MAC Address",
+      file_path: "File Path",
+      file_name: "File Name",
+      file_extension: "File Extension",
+      url: "URL",
+      hostname: "Hostname",
+      id_number: "Número de documento",
+    },
+    idTypes: {
+      title: "Tipo de documento",
+      customPattern: "Patrón personalizado",
+      customPatternPlaceholder: "p. ej. ([A-Z]{2})-([0-9]{8})",
+      customPatternHint: "Admite patrones simples como [A-Z] letras, [0-9] dígitos, {n} repeticiones, guiones",
+      id_card: "DNI chino",
+      passport: "Pasaporte",
+      hk_macau_pass: "Permiso HK/Macao",
+      taiwan_pass: "Permiso Taiwán",
+      uscc: "Código social unificado",
+      bank_card: "Tarjeta bancaria",
+      drivers_license: "Carnet de conducir",
+      custom: "Personalizado",
+    },
+  },
+  tableToolbox: {
+    title: "Herramientas de datos",
+    generateData: "Generar datos",
+    importData: "Importar datos",
+    exportData: "Exportar datos",
+    generateDataComingSoon: "Próximamente",
+  },
+  sqlFile: {
+    title: "Ejecutar archivo SQL",
+    file: "Archivo",
+    selectSqlFile: "Seleccionar archivo SQL",
+    browse: "Examinar",
+    previewingLines: "Vista previa de {count} líneas",
+    previewingFirstLines: "Vista previa de las primeras {count} líneas",
+    target: "Destino",
+    connection: "Conexión",
+    selectConnection: "Seleccionar conexión",
+    database: "Base de datos",
+    selectDatabase: "Seleccionar base de datos",
+    databasePlaceholder: "Nombre de la base de datos",
+    options: "Opciones",
+    continueOnError: "Continuar en caso de error",
+    runInBackground: "Ejecutar en segundo plano",
+    cancelling: "Cancelando...",
+    cancel: "Cancelar",
+    execute: "Ejecutar",
+    statement: "Sentencia",
+    succeeded: "Exitosa",
+    failed: "Fallida",
+    affectedRows: "Filas afectadas",
+    currentStatement: "Sentencia actual",
+    status: {
+      idle: "Inactivo",
+      started: "Iniciado",
+      running: "En ejecución",
+      statementDone: "Sentencia completada",
+      statementFailed: "Sentencia fallida",
+      done: "Completado",
+      error: "Error",
+      cancelled: "Cancelado",
+    },
+  },
+  diff: {
+    title: "Comparar esquemas",
+    source: "Origen",
+    target: "Destino",
+    selectConnection: "Seleccionar conexión",
+    selectDatabase: "Seleccionar base de datos",
+    selectSchema: "Seleccionar esquema",
+    connection: "Conexión",
+    database: "Base de datos",
+    schema: "Esquema",
+    recentConfigs: "Configs recientes",
+    selectRecentConfig: "Seleccionar config reciente",
+    ignoreComments: "Ignorar diferencias de comentarios",
+    compare: "Comparar",
+    comparing: "Comparando esquemas...",
+    noDifferences: "No se encontraron diferencias",
+    table: "Tabla",
+    status: "Estado",
+    details: "Detalles",
+    added: "Agregada",
+    removed: "Eliminada",
+    modified: "Modificada",
+    indexes: "Índices",
+    foreignKeys: "Claves foráneas",
+    triggers: "Disparadores",
+    comments: "Comentarios",
+    newTable: "Nueva tabla",
+    dropTable: "Eliminar tabla",
+    generatedSql: "SQL de sincronización",
+    copySql: "Copiar SQL",
+    executeSync: "Ejecutar sincronización",
+    syncSuccess: "Sincronización ejecutada exitosamente",
+    swap: "Intercambiar origen y destino",
+    syncProgress: "Ejecutando: {current}/{total}",
+    syncSummary: "Exitosos {success}, fallidos {failed}",
+    configSaved: "Config guardada",
+    configDeleted: "Config eliminada",
+    sourceObject: "Objeto de origen",
+    targetObject: "Objeto de destino",
+    operation: "Operación",
+    selectedCount: "{selected} seleccionados de {total}",
+    saveConfig: "Guardar config",
+    loadConfig: "Cargar config",
+    options: "Opciones",
+    ddlCompare: "DDL comparar",
+    deployScript: "Script de despliegue",
+    deployScriptAll: "Todos los scripts de despliegue",
+    deployScriptDesc: "Script SQL para el objeto seleccionado",
+    deployScriptAllDesc: "Script SQL para todos los objetos seleccionados",
+    copy: "Copiar",
+    execute: "Ejecutar",
+    executeAll: "Ejecutar todo",
+    executeSuccess: "Ejecutado exitosamente",
+    selectObjectToCompare: "Selecciona un objeto para ver la comparación DDL",
+    noDdlAvailable: "No hay DDL disponible",
+    noDeployScript: "No hay script de despliegue",
+    noDeployScriptAll: "No hay script de despliegue para los objetos seleccionados",
+    sourceDdl: "DDL de origen",
+    targetDdl: "DDL de destino",
+    objectNotExistsInSource: "Este objeto no existe en la base de datos de origen",
+    objectNotExistsInTarget: "Este objeto no existe en la base de datos de destino",
+    nextStepDeploy: "Siguiente (Revisar despliegue)",
+    deployReview: "Revisión de despliegue",
+    backToResult: "Volver al resultado",
+    copyScript: "Copiar script",
+    exportSql: "Exportar .sql",
+    deployToServer: "Desplegar en servidor",
+    deployConfirmTitle: "Confirmación final",
+    deployConfirmMessage: "Estás a punto de desplegar los siguientes cambios en la base de datos de destino",
+    targetServer: "Servidor de destino",
+    dbVersion: "Versión de base de datos",
+    targetDatabase: "Base de datos de destino",
+    targetSchema: "Esquema de destino",
+    useTransaction: "Ejecutar en transacción (reversión automática en caso de error)",
+    confirmDeploy: "Confirmar despliegue",
+    exportSuccess: "Exportación exitosa",
+    create: "Crear",
+    delete: "Eliminar",
+    modify: "Modificar",
+    cancel: "Cancelar",
+    prevStep: "Anterior",
+    recompare: "Comparar de nuevo",
+    maximize: "Maximizar",
+    restore: "Restaurar",
+    operationLabel: {
+      modify: "Objetos a modificar",
+      create: "Objetos a crear",
+      delete: "Objetos a eliminar",
+      none: "Sin operación",
+    },
+    objectKindLabel: {
+      table: "Tabla",
+      view: "Vista",
+      function: "Función",
+      sequence: "Secuencia",
+      rule: "Regla",
+      owner: "Propietario",
+      index: "Índice",
+      foreignKey: "Clave foránea",
+      trigger: "Disparador",
+    },
+    noObjectsSelected: "Selecciona objetos para desplegar",
+    deploySuccess: "Despliegue exitoso",
+    deployFailed: "Despliegue fallido",
+    deploySuccessMessage: "Script SQL ejecutado exitosamente en la base de datos de destino",
+    deployFailedMessage: "Ocurrió un error durante la ejecución",
+    affectedRows: "Filas afectadas",
+    executedStatements: "Sentencias ejecutadas",
+    serverVersion: "Versión del servidor",
+    info: "Información",
+    connType: "Tipo de conexión",
+    connName: "Nombre de conexión",
+    host: "Host",
+    port: "Puerto",
+    copied: "Copiado al portapapeles",
+    saveConfigPrompt: "Por favor ingresa el nombre de la config:",
+    close: "Cerrar",
+    searchConnection: "Buscar conexiones...",
+    searchDatabase: "Buscar bases de datos...",
+    searchSchema: "Buscar esquemas...",
+  },
+  schemaDiff: {
+    optionsTitle: "Opciones de comparación",
+    selectConfig: "Select config",
+    newConfigName: "New Config",
+    newConfig: "New Config",
+    renameConfig: "Rename Config",
+    duplicateConfig: "Duplicate Config",
+    deleteConfig: "Delete Config",
+    exportConfig: "Export Config",
+    exportAllConfigs: "Export All Configs",
+    importConfig: "Import Config",
+    importFromFile: "Import from File",
+    importFromText: "Import from Text",
+    importPlaceholder: "Paste JSON config...",
+    importInvalidJson: "Invalid JSON format",
+    configName: "Config Name",
+    tableFilter: "Table filter",
+    tableFilterHint: "Matches table names with JavaScript regex. Empty include means all tables; empty exclude means no exclusions.",
+    tableFilterHintShort: "Limit compare by table name regex",
+    tableFilterHelp: "Table filter help",
+    tableFilterHelpRule: "Matches full table names. Do not type /.../.",
+    tableFilterHelpBlank: "Blank include means all tables. Blank skip means no exclusions.",
+    tableFilterHelpExample: "^user_ means starts with user_; _bak$ means ends with _bak; a|b means a or b.",
+    tableIncludePattern: "Include table regex",
+    tableIncludePatternPlaceholder: "e.g. ^user_",
+    tableExcludePattern: "Exclude table regex",
+    tableExcludePatternPlaceholder: "e.g. _bak$",
+    tableFilterPriority: "When both match",
+    tableFilterPriorityExclude: "Exclude wins",
+    tableFilterPriorityInclude: "Include wins",
+    options: {
+      tables: "Compare tables",
+      primaryKeys: "Compare primary keys",
+      foreignKeys: "Compare foreign keys",
+      uniqueKeys: "Compare unique keys",
+      checks: "Compare check constraints",
+      exclusions: "Compare exclusion constraints",
+      views: "Compare views",
+      functions: "Compare functions",
+      indexes: "Compare indexes",
+      sequences: "Compare sequences",
+      triggers: "Compare triggers",
+      rules: "Compare rules",
+      owners: "Compare owners",
+      cascadeDelete: "Use CASCADE delete",
+      sequenceLastValues: "Compare sequence last values",
+      compareColumnOrder: "Compare column order",
+    },
+  },
+  dataCompare: {
+    title: "Comparar datos",
+    selectTable: "Seleccionar tabla",
+    searchTable: "Buscar tablas...",
+    sourceTables: "Tablas de origen",
+    targetTable: "Tabla de destino",
+    searchTables: "Buscar tablas...",
+    selectedTables: "{selected}/{total} seleccionadas",
+    selectAllTables: "Seleccionar todo",
+    deselectAllTables: "Deseleccionar todo",
+    selectSourceTables: "Selecciona primero la conexión y base de datos de origen, luego las tablas a comparar",
+    noTables: "No hay tablas disponibles para comparar",
+    autoMatchHint: "El modo por lotes empareja automáticamente tablas de destino con el mismo nombre",
+    matchedTables: "{matched}/{total} tablas emparejadas",
+    missingTargetTables: "Faltan tablas de destino con el mismo nombre: {tables}",
+    keyColumns: "Columnas clave",
+    keyColumnsPlaceholder: "Columnas primarias o únicas separadas por comas",
+    keyColumnsAutoHint: "Déjalo vacío para detectar claves primarias automáticamente en comparación simple o por tabla en lote.",
+    rowCounts: "Origen {source} filas, destino {target} filas; comparación completa terminada",
+    previewLimitOption: "Vista previa {count}",
+    compare: "Comparar datos",
+    summary: "Agregadas {added}, eliminadas {removed}, modificadas {modified}",
+    batchSummary: "Se compararon {tables} tablas: {different} con diferencias, {same} iguales, {failed} con error; agregadas {added}, eliminadas {removed}, modificadas {modified}",
+    comparingTable: "Comparando {current}/{total}: {table}",
+    keyColumnsInline: "Columnas clave: {columns}",
+    selectedInline: "Seleccionadas {selected}/{total}",
+    selectedSummary: "Seleccionado: agregadas {added}, eliminadas {removed}, modificadas {modified}",
+    selectAllKind: "Seleccionar todas las {kind}",
+    clearKind: "Limpiar {kind}",
+    clearSelection: "Limpiar toda la selección",
+    showAllRows: "Mostrar las {count}",
+    showLessRows: "Mostrar menos",
+    remainingRows: "Quedan {count} filas fuera de la vista previa",
+    planningSync: "Actualizando el plan de sincronización...",
+    noSelectedDifferences: "No hay diferencias seleccionadas para ejecutar",
+    planSummary: "Plan: {inserts} inserciones, {updates} actualizaciones, {deletes} eliminaciones, {statements} sentencias",
+    statusDifferent: "Con diferencias",
+    statusSame: "Igual",
+    statusError: "Error",
+    noKeyColumns: "Selecciona al menos una columna clave",
+    missingKeyColumns: "Las columnas clave deben existir en las tablas de origen y destino: {columns}",
+    noCommonColumns: "Las tablas de origen y destino no tienen columnas en común para comparar",
+    targetTableMissing: "No se encontró la tabla de destino: {table}",
+    noComparableTables: "No se encontraron tablas comparables. Verifica si existen tablas de destino con el mismo nombre.",
+    noDifferences: "Los datos son idénticos, no se necesita SQL de sincronización",
+    syncSuccess: "Sincronización de datos ejecutada exitosamente",
+  },
+  settings: {
+    title: "Configuración",
+    editorTab: "Editor",
+    sqlFormatterTab: "Formateador SQL",
+    sqlFormatterImport: "Importar configuración",
+    sqlFormatterExport: "Exportar configuración",
+    sqlFormatterImportSuccess: "Configuración del formateador importada.",
+    sqlFormatterCopyJson: "Copiar JSON",
+    sqlFormatterCopyJsonSuccess: "JSON copiado.",
+    sqlFormatterCopyJsonFailed: "Error al copiar: {message}",
+    sqlFormatterJsonEditorLoadFailed: "No se pudo cargar el editor JSON. Se cambió a una entrada básica: {message}",
+    sqlFormatterRestoreDefaults: "Restaurar valores por defecto",
+    sqlFormatterFormMode: "Formulario",
+    sqlFormatterJsonMode: "JSON",
+    sqlFormatterKeywordCase: "Mayúsculas/minúsculas de palabras clave",
+    sqlFormatterFunctionCase: "Mayúsculas/minúsculas de funciones",
+    sqlFormatterDataTypeCase: "Mayúsculas/minúsculas de tipos de datos",
+    sqlFormatterIdentifierCase: "Mayúsculas/minúsculas de identificadores",
+    sqlFormatterCaseUpper: "Mayúsculas",
+    sqlFormatterCaseLower: "Minúsculas",
+    sqlFormatterCasePreserve: "Conservar",
+    sqlFormatterIndent: "Sangría",
+    sqlFormatterIndentSpaces: "Espacios",
+    sqlFormatterIndentTabs: "Tabulaciones",
+    sqlFormatterTabWidth: "Ancho de tabulación",
+    sqlFormatterIndentStyle: "Estilo de sangría",
+    sqlFormatterIndentStyleStandard: "Estándar",
+    sqlFormatterIndentStyleTabularLeft: "Tabular izquierda",
+    sqlFormatterIndentStyleTabularRight: "Tabular derecha",
+    sqlFormatterLogicalOperatorNewline: "Salto de línea en operador lógico",
+    sqlFormatterLogicalBefore: "Antes del operador",
+    sqlFormatterLogicalAfter: "Después del operador",
+    sqlFormatterExpressionWidth: "Ancho de expresión",
+    sqlFormatterLinesBetweenQueries: "Líneas entre consultas",
+    sqlFormatterDenseOperators: "Operadores compactos",
+    sqlFormatterNewlineBeforeSemicolon: "Punto y coma en nueva línea",
+    sqlFormatterAdvancedOptions: "Opciones avanzadas",
+    sqlFormatterParams: "Parámetros",
+    sqlFormatterParamTypes: "Tipos de parámetro",
+    sqlFormatterEditorShortcuts: "Atajos",
+    sqlFormatterShortcutAction: "Acción",
+    sqlFormatterShortcutEnabled: "Activo",
+    sqlFormatterShortcutWindows: "Windows",
+    sqlFormatterShortcutLinux: "Linux",
+    sqlFormatterShortcutMacos: "macOS",
+    sqlFormatterShortcutFind: "Buscar",
+    sqlFormatterShortcutReplace: "Reemplazar",
+    sqlFormatterShortcutIndentMore: "Aumentar sangría",
+    sqlFormatterShortcutIndentLess: "Reducir sangría",
+    sqlFormatterShortcutDuplicateLine: "Duplicar línea actual",
+    sqlFormatterShortcutDeleteLine: "Eliminar línea actual",
+    sqlFormatterShortcutMoveLine: "Mover línea",
+    sqlFormatterShortcutMoveLineUp: "Mover línea arriba",
+    sqlFormatterShortcutMoveLineDown: "Mover línea abajo",
+    sqlFormatterShortcutCopyLine: "Copiar línea",
+    sqlFormatterShortcutCopyLineUp: "Copiar línea arriba",
+    sqlFormatterShortcutCopyLineDown: "Copiar línea abajo",
+    sqlFormatterShortcutUndo: "Deshacer",
+    sqlFormatterShortcutRedo: "Rehacer",
+    sqlFormatterShortcutSelectAll: "Seleccionar todo",
+    sqlFormatterShortcutFormatJson: "Formatear JSON",
+    sqlFormatterShortcutApply: "Aplicar configuración",
+    sqlFormatterConfigErrorInvalidJson: "JSON no válido.",
+    sqlFormatterConfigErrorObject: "La configuración debe ser un objeto JSON.",
+    sqlFormatterConfigErrorVersion: "Versión de configuración no compatible.",
+    sqlFormatterConfigErrorFormatter: "Formateador no compatible.",
+    sqlFormatterConfigErrorUnsupportedParams: "La sustitución params no es compatible. El formateo SQL no reemplazará marcadores.",
+    sqlFormatterConfigErrorOptionsObject: "Las opciones de configuración deben ser un objeto JSON.",
+    sqlFormatterConfigErrorEditorObject: "La configuración del editor debe ser un objeto JSON.",
+    sqlFormatterConfigErrorEditorScope: "Ámbito de editor no compatible.",
+    sqlFormatterConfigErrorEditorPlatforms: "Plataformas de editor no válidas.",
+    sqlFormatterConfigErrorEditorShortcutsArray: "Los atajos del editor deben ser un array.",
+    sqlFormatterConfigErrorEditorShortcutValue: "Atajo de editor no válido.",
+    sqlFormatterConfigErrorUnknownOption: "Opción desconocida del formateador: {option}.",
+    sqlFormatterConfigErrorInvalidOptionValue: "Valor no válido para {option}.",
+    sqlFormatterConfigErrorUnknownEditorShortcut: "Atajo de editor desconocido: {shortcut}.",
+    sqlFormatterConfigErrorInvalidEditorShortcut: "Atajo de editor no válido: {shortcut}.",
+    sqlFormatterConfigErrorDuplicateEditorShortcut: "Atajo de editor duplicado: {shortcut}.",
+    sqlFormatterConfigErrorInvalidConfig: "Configuración del formateador no válida.",
+    appearanceTab: "Apariencia",
+    navigationTab: "Navegación",
+    dataTab: "Datos",
+    tunnelsTab: "Túneles",
+    tunnelsDescription: "Configuraciones reutilizables de túneles SSH / proxy / HTTP. Configura una vez y selecciona el perfil desde la pestaña de túnel de una conexión; los cambios aquí se aplican a todas las conexiones que usan el perfil.",
+    tunnelsEmpty: "Aún no hay perfiles de túnel. Crea uno aquí y selecciónalo en la configuración de túnel de una conexión.",
+    tunnelsAddSsh: "Añadir SSH",
+    tunnelsAddProxy: "Añadir proxy",
+    tunnelsAddHttp: "Añadir túnel HTTP",
+    tunnelsProfileName: "Nombre del perfil",
+    tunnelsProfileNamePlaceholder: "p. ej. Bastión de la oficina",
+    tunnelsDelete: "Eliminar",
+    tunnelsUnnamedProfile: "Perfil sin nombre",
+    tunnelsSave: "Guardar",
+    tunnelsReset: "Restablecer",
+    tunnelsSaved: "Perfiles de túnel guardados",
+    tunnelsSaveFailed: "Error al guardar los perfiles de túnel: {message}",
+    tunnelsUnsavedHint: "Cambios sin guardar",
+    redisTab: "Redis",
+    shortcutsTab: "Atajos",
+    snippetsTab: "Fragmentos",
+    syncTab: "Sync",
+    aiTab: "IA",
+    mcpTab: "MCP",
+    jdbcTab: "Drivers JDBC",
+    securityTab: "Seguridad",
+    aboutTab: "Acerca de",
+    fontFamily: "Familia tipográfica",
+    uiFontFamily: "Fuente de la interfaz",
+    uiFontAppDefault: "Predeterminada de DBX",
+    uiFontSystemDefault: "Predeterminada del sistema",
+    uiFontFamilyDescription: "Se aplica a la barra superior, pestañas, barra lateral, diálogos y demás UI fuera del editor.",
+    selectFont: "Seleccionar fuente...",
+    searchFont: "Buscar fuentes...",
+    loadingFonts: "Cargando fuentes...",
+    noFontsFound: "No se encontraron fuentes",
+    useCustomFont: "Usar “{font}”",
+    languageTitle: "Idioma / Language",
+    fontSize: "Tamaño de fuente",
+    toolbarTitle: "Barra de herramientas",
+    toolbarHiddenHint: "Algunos botones ocultos o desbordados aparecerán en el menú «Más».",
+    uiScale: "Escala de interfaz",
+    uiScaleDescription: "Escala toda la interfaz de escritorio para pantallas de alta densidad. Los cambios se aplican al instante y se restauran al volver a abrir.",
+    theme: "Tema",
+    selectTheme: "Seleccionar tema...",
+    colorTheme: "Tema de color",
+    selectColorTheme: "Seleccionar tema de color...",
+    themePalettePearl: "Blanco",
+    themePaletteMist: "Gris niebla",
+    themePaletteGraphite: "Gris titanio",
+    themePaletteCobalt: "Azul cobalto",
+    themePaletteSage: "Verde salvia",
+    themePaletteAmber: "Amarillo cálido",
+    themePaletteBlush: "Rosa sakura",
+    themePaletteVscode: "VS Code",
+    themePaletteIdea: "IDEA",
+    themePaletteXcode: "Xcode",
+    themePaletteJetbrains: "JetBrains",
+    themePaletteCursor: "Cursor",
+    themePaletteClaude: "Claude Code",
+    followAppTheme: "Seguir el tema de la aplicación",
+    appLayout: "Diseño de la interfaz",
+    appLayoutSeparated: "Moderno separado",
+    appLayoutSeparatedDescription: "Separación clara de paneles con pestañas en bloque.",
+    appLayoutClassic: "Clásico compacto",
+    appLayoutClassicDescription: "Barra de pestañas continua con encabezados de panel compactos.",
+    iconTheme: "Estilo de icono y logo",
+    iconThemeDefault: "Predeterminado",
+    iconThemeDefaultDescription: "Usar el icono de color de DBX.",
+    iconThemeBlack: "Negro",
+    iconThemeBlackDescription: "Usa el logo negro de DBX en la aplicación.",
+    iconThemeBlackDescriptionMac: "Usa el logo negro en la app; Dock usa fondo negro y la barra de menús sigue el sistema.",
+    showTrayIcon: "Mostrar icono en bandeja/barra de menú",
+    showTrayIconDescription: "Si está desactivado, no se muestra el icono, pero cerrar la ventana sigue ocultando DBX en segundo plano como antes.",
+    quitOnClose: "Salir al cerrar la ventana",
+    quitOnCloseDescription: "Si está activado, al pulsar el botón de cerrar DBX se cierra por completo en lugar de ocultarse en la bandeja.",
+    closeActionPromptTitle: "Cerrar ventana",
+    closeActionPromptDescription: "Elige qué ocurre al pulsar el botón de cerrar. Puedes cambiarlo después en Ajustes → Apariencia.",
+    closeActionQuit: "Salir de DBX",
+    closeActionMinimize: "Minimizar a la bandeja",
+    updateNotificationsEnabled: "Activar recordatorios de actualización",
+    updateNotificationsEnabledDescription: "Al desactivarlo, DBX no comprobará automáticamente actualizaciones de la app ni de los controladores, ni mostrará indicadores. Las comprobaciones manuales siguen disponibles.",
+    updateDownloadSource: "Origen de descarga de actualizaciones",
+    updateDownloadSourceDescription: "Elige de dónde se descargan los instaladores de actualización. Se recomienda la fuente oficial; CNB o AtomGit pueden ser más rápidos en redes de China continental.",
+    updateDownloadSourceOfficial: "Fuente oficial (recomendada)",
+    updateDownloadSourceCnb: "CNB",
+    updateDownloadSourceAtomgit: "AtomGit",
+    debugLoggingEnabled: "Activar logs de depuración",
+    debugLoggingEnabledDescription: "Registra logs de diagnóstico locales del lado del usuario al investigar reportes. Desactivado por defecto.",
+    duckDbWorkerProcessIsolation: "Modo de aislamiento de proceso de DuckDB (experimental)",
+    duckDbWorkerProcessIsolationDescription: "Ejecuta las consultas de DuckDB en un proceso worker independiente. Si una consulta larga no responde a la cancelación, DBX puede detener el proceso worker para liberar el bloqueo del archivo de base de datos.",
+    duckDbWorkerMaxProcesses: "Workers concurrentes máximos de DuckDB",
+    duckDbWorkerMaxProcessesDescription: "Limita cuántos procesos worker de DuckDB puede ejecutar DBX al mismo tiempo. Rango: 1-16. Predeterminado: 4.",
+    duckDbWorkerProcessIsolationRestartRequired: "Reinicia DBX para que este cambio surta efecto.",
+    restartDbx: "Reiniciar DBX",
+    restartDbxFailed: "No se pudo reiniciar DBX: {error}",
+    debugLogsCopy: "Copiar logs",
+    debugLogsCopied: "Copiado",
+    debugLogsDownload: "Descargar logs",
+    debugLogsDownloaded: "Descargado",
+    debugLogsClear: "Borrar logs",
+    tableStructureSection: "Estructura de tabla",
+    dataGridDisplay: "Visualización de la tabla",
+    showColumnCommentsInHeader: "Mostrar comentarios bajo los nombres",
+    showColumnCommentsInHeaderDescription: "Muestra los comentarios de columnas directamente debajo del nombre de la columna.",
+    showColumnTypesInHeader: "Mostrar tipos de columna bajo los nombres",
+    showColumnTypesInHeaderDescription: "Muestra el tipo de dato de cada columna directamente debajo del nombre de la columna.",
+    compactColumnHeaderActions: "Compactar herramientas del encabezado",
+    compactColumnHeaderActionsDescription: "Mueve formatear y filtrar a un menú de más acciones para priorizar el nombre de columna.",
+    dataGridQuickEntry: "Entrada rápida en grilla",
+    dataGridQuickEntryDescription: "Al activarlo, editar una celda o llenar la fila vacía inferior se guarda en la base de datos al perder el foco. Agiliza la captura frecuente, pero puede causar escrituras accidentales.",
+    infiniteScroll: "Carga de desplazamiento infinito",
+    autoCalculateTotalRows: "Calcular automáticamente el total de filas",
+    autoCalculateTotalRowsDescription: "Ejecuta COUNT(*) automáticamente tras cada consulta para mostrar el total de filas coincidentes. Desactivado por defecto para mantener rápidas las consultas grandes; puedes calcularlo cuando quieras desde el pie de resultados.",
+    infiniteScrollDescription: "Carga automáticamente la siguiente página de datos al desplazarse hasta el final de la tabla.",
+    infiniteScrollMaxRows: "Máximo de filas en desplazamiento infinito",
+    infiniteScrollMaxRowsDescription: "Número máximo de filas a cargar en modo desplazamiento infinito (1000–50000).",
+    tableColumnTemplateFields: "Campos predefinidos para tablas nuevas",
+    tableColumnTemplateFieldsDescription: "Elige un tipo de base de datos y configura los tipos de campo predefinidos usados al crear tablas nuevas.",
+    tableColumnTemplateAdd: "Agregar campo",
+    tableColumnTemplateColumn: "Campo",
+    tableColumnTemplateDatabase: "Base de datos",
+    tableColumnTemplateType: "Tipo",
+    tableColumnTemplateLength: "Longitud",
+    tableColumnTemplateDefault: "Valor por defecto",
+    tableColumnTemplateNoPresetType: "Sin tipo predefinido",
+    tableColumnTemplateRequired: "Obligatorio",
+    tableColumnTemplateComment: "Descripción",
+    tableColumnTemplateDragHandle: "Arrastrar para reordenar",
+    sidebarActivation: "Activación de la barra lateral",
+    sidebarActivationSingle: "Un clic",
+    sidebarActivationSingleDescription: "Abrir elementos accionables de la barra lateral con un clic.",
+    sidebarActivationDouble: "Doble clic",
+    sidebarActivationDoubleDescription: "Un clic selecciona la fila; doble clic abre elementos.",
+    sidebarObjectDisplay: "Diseño de objetos en la barra lateral",
+    sidebarObjectDisplayGrouped: "Vista avanzada",
+    sidebarObjectDisplayGroupedDescription: "Agrupa objetos por tablas, vistas, procedimientos y funciones para bases con más tipos de objeto.",
+    sidebarObjectDisplaySimple: "Vista simple",
+    sidebarObjectDisplaySimpleDescription: "Muestra tablas y vistas directamente bajo cada base de datos o esquema para reducir niveles intermedios.",
+    autoSelectActiveSidebarNode: "Seleccionar siempre el elemento abierto",
+    autoSelectActiveSidebarNodeDescription: "Al cambiar de pestaña, selecciona la tabla, colección o archivo SQL visible correspondiente en la barra lateral.",
+    openTabsRestoreMode: "Restaurar pestañas al iniciar",
+    openTabsRestoreModeDescription: "Elige cómo DBX restaura las pestañas que estaban abiertas la última vez.",
+    openTabsRestoreModeAll: "Conservar todas las pestañas",
+    openTabsRestoreModePinned: "Solo pestañas fijadas",
+    openTabsRestoreModeNone: "No conservar pestañas",
+    openTabsRestoreModeHint: "Las pestañas fijadas permanecen en el lado izquierdo de la barra de pestañas y son útiles como puntos de entrada frecuentes.",
+    disconnectTabHandlingMode: "Pestañas tras desconectar",
+    disconnectTabHandlingModeDescription: "Elige cómo conservar las pestañas relacionadas al cerrar una conexión o base de datos.",
+    disconnectTabHandlingModeCloseTabs: "Cerrar todas las pestañas",
+    disconnectTabHandlingModeCloseTabsDescription: "Cierra todas las pestañas relacionadas de la conexión o base de datos.",
+    disconnectTabHandlingModeKeepTabsClearResults: "Cerrar objetos y conservar SQL",
+    disconnectTabHandlingModeKeepTabsClearResultsDescription: "Cierra pestañas de datos, explorador de objetos y estructura, conserva las pestañas SQL y limpia el estado de ejecución y las sesiones.",
+    disconnectTabHandlingModeKeepTabsKeepResults: "No cerrar pestañas relacionadas",
+    disconnectTabHandlingModeKeepTabsKeepResultsDescription: "Conserva las pestañas relacionadas, el texto SQL y los resultados actuales sin limpieza adicional.",
+    reuseDataTab: "Reutilizar pestaña de datos",
+    reuseDataTabDescription: "Al hacer clic en una tabla en la barra lateral, reutiliza la pestaña de datos existente en lugar de crear una nueva cada vez.",
+    sidebarHiddenTablePrefixes: "Prefijos ocultos de tablas",
+    sidebarHiddenTablePrefixesDescription: "Un prefijo por linea. Solo acorta etiquetas de tablas, vistas y colecciones en la barra lateral; las acciones y ayudas usan el nombre completo.",
+    sidebarHiddenTablePrefixesPlaceholder: "Ejemplo:\nODS_\nT8Y2_LONG_",
+    sidebarTablePageSize: "Tamaño de página de la barra lateral",
+    sidebarTablePageSizeDescription: "Número máximo de tablas/objetos cargados por página en el árbol lateral. Auméntalo si tienes muchas tablas para reducir páginas.",
+    sidebarTableSearchEnabled: "Activar búsqueda de tablas por base",
+    sidebarTableSearchEnabledDescription: "Muestra un buscador local bajo bases de datos, schemas o grupos de tablas expandidos para filtrar tablas por separado.",
+    sidebarHideTableComments: "Ocultar comentarios de tablas en la barra lateral",
+    sidebarHideTableCommentsDescription: "Oculta los comentarios de tablas/vistas junto a los nombres en el árbol de la barra lateral para ahorrar espacio horizontal.",
+    sidebarAllowHorizontalScroll: "Permitir desplazamiento horizontal lateral",
+    sidebarAllowHorizontalScrollDescription: "Muestra completos los nombres largos de tablas, vistas y colecciones permitiendo desplazamiento horizontal en la barra lateral.",
+    snippetsDescription: "Personaliza plantillas SQL activadas en el editor.",
+    snippetsAdd: "Agregar fragmento",
+    snippetsLabel: "Etiqueta",
+    snippetsPrefix: "Prefijo",
+    snippetsStatus: "Estado",
+    snippetsEnabled: "Activado",
+    snippetsDisabled: "Desactivado",
+    snippetsToggle: "Activar o desactivar fragmento",
+    snippetsBody: "SQL",
+    snippetsLabelPlaceholder: "p. ej. select *",
+    snippetsPrefixPlaceholder: "p. ej. sel",
+    snippetsBodyPlaceholder: "SELECT *\nFROM table\nLIMIT 100;",
+    snippetsRestoreDefaults: "Restaurar valores por defecto",
+    snippetsAddTitle: "Agregar fragmento",
+    snippetsEditTitle: "Editar fragmento",
+    syncWebDavTitle: "Sincronización WebDAV",
+    syncWebDavDescription: "Sube o restaura una instantánea de DBX, incluida la biblioteca SQL guardada, desde almacenamiento compatible con WebDAV.",
+    syncEndpoint: "URL WebDAV",
+    syncUsername: "Usuario",
+    syncPassword: "Contraseña",
+    syncPasswordPlaceholder: "Introduce la contraseña",
+    syncClearSavedPassword: "Borrar contraseña guardada",
+    syncRememberWebDavPassword: "Recordar contraseña de app WebDAV",
+    syncSavedPassword: "(guardada)",
+    syncRememberWebDavPasswordDescription: "La contraseña se cifra y se guarda solo en este dispositivo. No se sincroniza a WebDAV ni reemplaza la contraseña de sync.",
+    syncRemotePath: "Ruta remota",
+    syncRemotePathDescription: "DBX creará las carpetas padre faltantes al subir.",
+    syncSecretNotice: "De forma predeterminada, DBX solo sincroniza detalles de conexión y ajustes. Las contraseñas de base de datos, SSH, proxy, cadenas de conexión y API keys de IA quedan locales.",
+    syncSecrets: "Sincronizar secretos cifrados",
+    syncSecretsDescription: "Al activarlo, DBX cifra contraseñas de base de datos, contraseñas SSH y API keys de IA antes de subirlas a WebDAV.",
+    syncSecretsPassphrase: "Contraseña de sync",
+    syncSecretsPassphraseDescription: "Esta contraseña solo se usa para cifrar y restaurar datos sensibles. DBX no la guarda; tendrás que ingresarla en cada dispositivo.",
+    syncTest: "Probar",
+    syncUpload: "Subir",
+    syncDownload: "Descargar",
+    syncTestSuccess: "El destino WebDAV está disponible.",
+    syncUploadSuccess: "Se subieron {bytes} bytes a {path}.",
+    syncAutoUpload: "Subir instantáneas automáticamente",
+    syncAutoUploadInterval: "Cada",
+    syncAutoUploadMinutes: "minutos",
+    syncAutoUploadDescription: "Se ejecuta mientras DBX está abierto. Las descargas aún requieren confirmación manual para evitar reemplazar SQL guardado localmente.",
+    syncAutoUploadSuccess: "Se subieron automáticamente {bytes} bytes a {path}.",
+    syncDownloadSuccess: "Se descargaron y aplicaron {bytes} bytes desde {path}.",
+    syncSecretsApplied: "Los secretos cifrados fueron restaurados.",
+    syncSecretsSkipped: "Había secretos cifrados, pero no fueron restaurados.",
+    syncDownloadConfirm: "¿Descargar y aplicar la instantánea remota de DBX? Se reemplazarán metadatos locales y SQL guardado.",
+    apply: "Aplicar",
+    applyAndClose: "Aplicar y cerrar",
+    reset: "Restablecer",
+    resetDefaults: "Restablecer valores por defecto",
+    resetAllDefaults: "Restablecer todos los valores por defecto",
+    save: "Guardar",
+    cancel: "Cancelar",
+    executeMode: "Modo de ejecución (Cmd+Enter)",
+    executeModeAll: "Ejecutar todo el SQL",
+    executeModeCurrent: "Ejecutar sentencia en el cursor",
+    showExecutionTargetPicker: "Mostrar selector de objetivo",
+    showExecutionTargetPickerDescription: "Al activarlo, ejecutar sin selección permite elegir entre la sentencia actual y todo el SQL.",
+    showStatementRunButtons: "Mostrar botones de ejecución laterales",
+    showStatementRunButtonsDescription: "Muestra botones para ejecutar cada sentencia en el margen del editor SQL. Los atajos de teclado y el menú contextual seguirán funcionando al desactivarlo.",
+    showCurrentStatementFrame: "Mostrar marco de la sentencia actual",
+    showCurrentStatementFrameDescription: "Al activarlo, el editor SQL dibuja un contorno alrededor de la sentencia ejecutable actual; al desactivarlo, se oculta.",
+    showInsertValueHints: "Mostrar pistas de columnas en VALUES de INSERT",
+    showInsertValueHintsDescription: "Al activarlo, el editor SQL muestra el nombre de columna junto a cada valor en cláusulas INSERT ... VALUES.",
+    previewStatementRunButton: "Botón de ejecución de sentencia en vista previa",
+    wordWrap: "Ajuste de línea",
+    wordWrapDescription: "Ajustar las líneas largas de SQL al ancho del editor",
+    vimMode: "Modo Vim",
+    vimModeDescription: "Usar edición modal estilo Vim en el editor SQL",
+    autoCloseBrackets: "Cerrar paréntesis automáticamente",
+    autoCloseBracketsDescription: "Insertar automáticamente paréntesis y comillas de cierre al escribir los de apertura",
+    sqlSemanticDiagnosticsEnabled: "Diagnóstico semántico de SQL",
+    sqlSemanticDiagnosticsEnabledDescription: "Al activarse, el editor informa de problemas semánticos como tablas y columnas desconocidas. Desactívalo para reducir el análisis y las comprobaciones de metadatos en SQL grandes.",
+    confirmDangerousSqlExecution: "Confirmar antes de SQL peligroso",
+    confirmDangerousSqlExecutionDescription: "Cuando se desactiva, ALTER, DROP, DELETE, TRUNCATE y otras sentencias peligrosas se ejecutan sin el diálogo de advertencia.",
+    confirmUnsavedSqlClose: "Confirmar antes de cerrar SQL sin guardar",
+    confirmUnsavedSqlCloseDescription: "Cuando se desactiva, las pestañas SQL con ediciones sin guardar se cierran o salen sin el diálogo de confirmación de guardado.",
+    sqlVariableSyntax: "Sustitución de variables y marcadores SQL",
+    sqlVariableSyntaxDescription: "Elige qué sintaxis de variables y marcadores sustituye DBX antes de ejecutar SQL, por tipo de base de datos. Todas están habilitadas de forma predeterminada.",
+    sqlVariableSyntax_positional: "Marcador posicional",
+    sqlVariableSyntax_positionalDescription: "Solicita un valor para sustituir cada marcador posicional en orden.",
+    sqlVariableSyntax_named: "Marcador con nombre",
+    sqlVariableSyntax_namedDescription: "Solicita un valor para sustituir los marcadores con nombre.",
+    sqlVariableSyntax_shell: "Marcador estilo shell",
+    sqlVariableSyntax_shellDescription: "Solicita un valor para sustituir los marcadores de estilo shell.",
+    sqlVariableSyntax_mybatis: "Marcador estilo MyBatis",
+    sqlVariableSyntax_mybatisDescription: "Solicita un valor para sustituir los marcadores de estilo MyBatis.",
+    sqlVariableSyntax_sqlserver: "Marcador estilo SQL Server",
+    sqlVariableSyntax_sqlserverDescription: "Solicita un valor para sustituir los marcadores de estilo SQL Server (pueden entrar en conflicto con variables de sesión).",
+    sqlVariableSyntax_atSet: "Expansión de variables en línea",
+    sqlVariableSyntax_atSetDescription: "Expande las declaraciones de variables en línea y sustituye sus valores antes de ejecutar.",
+    autoAliasTables: "Agregar alias de tabla automáticamente",
+    autoAliasTablesDescription: "Al seleccionar una tabla en FROM o JOIN, inserta un alias generado como order_items AS oi.",
+    redisScanPageSize: "Cantidad de escaneo Redis",
+    redisScanPageSizeDescription: "Claves solicitadas por página SCAN al explorar claves Redis.",
+    redisScanPageSizeOption: "{count} claves",
+    exportBatchSize: "Tamaño de lote de exportación",
+    exportBatchSizeDescription: "Filas obtenidas por lote al exportar datos de tabla (100-100000).",
+    exportRowLimitEnabled: "Limitar filas exportadas",
+    exportRowLimitEnabledDescription: "Cuando está activado, las exportaciones de resultados de consultas y datos de tabla se detienen en el límite de filas indicado abajo.",
+    exportRowLimit: "Límite de filas de exportación",
+    exportRowLimitDescription: "Máximo de filas para exportaciones de resultados de consultas y datos de tabla.",
+    exportRowLimitUnlimited: "Sin límite",
+    queryExportKeysetOptimizationEnabled: "Intentar optimización keyset",
+    queryExportKeysetOptimizationEnabledDescription: "Solo aplica a consultas de una sola tabla reconocidas de forma segura; las consultas complejas usan el método estándar automáticamente.",
+    exportSection: "Exportar",
+    shortcutExecuteSql: "Ejecutar SQL",
+    shortcutFind: "Buscar",
+    shortcutReplace: "Reemplazar",
+    shortcutSaveSql: "Guardar SQL",
+    shortcutAcceptCompletion: "Aceptar completado",
+    shortcutFormatSql: "Formatear SQL",
+    shortcutToggleLineComment: "Alternar comentario de línea",
+    shortcutIndentMore: "Aumentar sangría",
+    shortcutIndentLess: "Reducir sangría",
+    shortcutDuplicateLine: "Duplicar línea actual",
+    shortcutDeleteLine: "Eliminar línea actual",
+    shortcutMoveLineUp: "Mover línea arriba",
+    shortcutMoveLineDown: "Mover línea abajo",
+    shortcutCopyLineUp: "Copiar línea arriba",
+    shortcutCopyLineDown: "Copiar línea abajo",
+    shortcutUndo: "Deshacer",
+    shortcutRedo: "Rehacer",
+    shortcutSelectAll: "Seleccionar todo",
+    shortcutCopyCurrentRow: "Copiar fila de datos actual",
+    shortcutDeleteCurrentRow: "Eliminar fila de datos actual",
+    shortcutNewQuery: "Nueva consulta",
+    shortcutOpenSettings: "Abrir configuración",
+    shortcutCloseTab: "Cerrar pestaña",
+    shortcutToggleSidebar: "Alternar barra lateral",
+    shortcutFocusSearch: "Enfocar búsqueda",
+    shortcutQuickOpen: "Abrir rápido (buscar todos los objetos de base de datos)",
+    shortcutSwitchToPreviousTab: "Cambiar a la pestaña anterior",
+    shortcutSwitchToNextTab: "Cambiar a la pestaña siguiente",
+    shortcutSwitchToTab1: "Cambiar a la pestaña 1",
+    shortcutSwitchToTab2: "Cambiar a la pestaña 2",
+    shortcutSwitchToTab3: "Cambiar a la pestaña 3",
+    shortcutSwitchToTab4: "Cambiar a la pestaña 4",
+    shortcutSwitchToTab5: "Cambiar a la pestaña 5",
+    shortcutSwitchToTab6: "Cambiar a la pestaña 6",
+    shortcutSwitchToTab7: "Cambiar a la pestaña 7",
+    shortcutSwitchToTab8: "Cambiar a la pestaña 8",
+    shortcutSwitchToTab9: "Cambiar a la pestaña 9",
+    shortcutZoomInUi: "Ampliar interfaz",
+    shortcutZoomOutUi: "Reducir interfaz",
+    shortcutResetUiZoom: "Restablecer zoom de interfaz",
+    shortcutRefreshData: "Actualizar datos",
+    shortcutToggleTranspose: "Alternar vista transpuesta",
+    shortcutCancelSearch: "Cancelar búsqueda",
+    shortcutCopySidebarSelection: "Copiar selección de la barra lateral",
+    shortcutPasteSidebarSelection: "Pegar en la barra lateral",
+    shortcutEditSidebarConnection: "Editar conexión de la barra lateral",
+    shortcutSendSelectionToAi: "Enviar selección a IA",
+    shortcutScopeGlobal: "Global",
+    shortcutScopeEditor: "Editor SQL",
+    shortcutScopeGrid: "Cuadrícula de datos",
+    shortcutScopeSearch: "Campos de búsqueda",
+    shortcutScopeSidebar: "Barra lateral",
+    shortcutPressShortcut: "Presiona un atajo",
+    shortcutSearchPlaceholder: "Buscar atajos",
+    shortcutSearchNoResults: "Ningún atajo coincide con la búsqueda.",
+    shortcutConflict: "Este atajo entra en conflicto con otra acción del mismo ámbito.",
+    shortcutClear: "Borrar atajo",
+    preview: "Vista previa en tiempo real",
+    customTheme: "Tema personalizado",
+    customThemeConfigure: "Configurar tema personalizado",
+    customThemeTitle: "Configuración de tema personalizado",
+    customThemeMyThemes: "Mis temas",
+    customThemeNewTheme: "Nuevo tema",
+    customThemeVisualEdit: "Editor visual",
+    customThemeJsonConfig: "Configuración JSON",
+    customThemeLivePreview: "Vista previa en tiempo real",
+    customThemePreviewExample: "Ejemplo de consulta",
+    customThemePreset: "Tema predefinido",
+    customThemeSelectPreset: "Seleccionar tema predefinido...",
+    customThemeApply: "Aplicar",
+    customThemePasteImport: "Importar desde portapapeles",
+    customThemeExportJson: "Exportar JSON",
+    customThemeSaveAndApply: "Guardar y aplicar",
+    customThemeKeyword: "Palabra clave",
+    customThemeField: "Campo/Variable",
+    customThemeFunction: "Función",
+    customThemeString: "Cadena",
+    customThemeNumber: "Número",
+    customThemeComment: "Comentario",
+    customThemeTable: "Tabla",
+    customThemeOperator: "Operador",
+    customThemeType: "Tipo",
+    customThemeBuiltin: "Variable integrada",
+    customThemeBackground: "Color de fondo",
+    customThemeForeground: "Color de primer plano",
+    customThemeDefaultName: "Tema personalizado",
+    customThemeCopySuffix: " Copia",
+    customThemeApplied: 'Esquema de color "{name}" aplicado',
+    customThemeKeepOne: "Mantener al menos un tema",
+    customThemeJsonError: "Formato JSON inválido, por favor verifique",
+    jdbcPlugin: "Plugin JDBC de DBX",
+    jdbcPluginInstall: "Instalar plugin JDBC",
+    jdbcPluginInstallSuccess: "Plugin JDBC instalado",
+    jdbcPluginUpdate: "Actualizar",
+    jdbcPluginUninstall: "Desinstalar",
+    jdbcPluginUninstallSuccess: "Plugin JDBC desinstalado",
+    jdbcPluginInstalled: "Instalado: v{version}",
+    jdbcPluginIncompatible: "Protocolo incompatible",
+    jdbcPluginNotInstalled: "No instalado",
+    jdbcDrivers: "JARs de drivers JDBC",
+    jdbcImport: "Importar JAR",
+    jdbcImportPath: "Ruta de importación",
+    jdbcDriverPathPlaceholder: "/ruta/al/driver.jar",
+    jdbcImportSuccess: "Se importaron {count} archivo(s) de driver",
+    jdbcDeleteSuccess: "Driver eliminado",
+    jdbcNoDrivers: "Aún no se han importado drivers JDBC.",
+    mcpTitle: "MCP Server",
+    mcpDescription: "Comprueba la instalación y versión de DBX MCP Server para Claude Code, Cursor y otros agentes.",
+    mcpChecking: "Comprobando",
+    mcpStatusUnknown: "Sin comprobar",
+    mcpStatusError: "Error al comprobar",
+    mcpReady: "Listo",
+    mcpNotInstalled: "No instalado",
+    mcpUpdateAvailable: "Actualización disponible",
+    mcpCurrent: "Versión actual",
+    mcpLatest: "Última versión",
+    mcpVersionMissing: "No se detectó instalación global",
+    mcpVersionUnknown: "Desconocida",
+    mcpAvailable: "Disponible",
+    mcpUnavailable: "No disponible",
+    mcpBinPath: "Ruta del comando",
+    mcpInstallCommand: "Comando de instalación",
+    mcpUpdateCommand: "Comando de actualización",
+    mcpInstallButton: "Instalar",
+    mcpUpdateButton: "Actualizar",
+    mcpUpToDate: "Actualizado",
+    mcpInstalling: "Instalando...",
+    mcpInstallSuccess: "Instalación exitosa",
+    mcpInstallFailed: "Error de instalación",
+    mcpConfig: "Configuración de MCP",
+    mcpConfigOptionsHint: "Estas opciones solo actualizan la configuración generada. Cópiala al cliente de IA y reinicia la sesión MCP para aplicarla.",
+    mcpCodexConfig: "Configuración de Codex",
+    mcpCodexConfigPath: "Codex puede usar ~/.codex/config.toml o .codex/config.toml dentro del proyecto.",
+    mcpCursorConfigPath: "Cursor puede usar .cursor/mcp.json en el proyecto o ~/.cursor/mcp.json globalmente.",
+    mcpTraeConfigPath: "TRAE: Configuración > MCP > Agregar > Agregar manualmente; luego pega la configuración JSON.",
+    mcpVsCodeConfigPath: "VS Code/Copilot puede usar .vscode/mcp.json en el espacio de trabajo o mcp.json en el perfil de usuario.",
+    mcpWindsurfConfigPath: "Windsurf puede usar ~/.codeium/windsurf/mcp_config.json.",
+    mcpOpenCodeConfigPath: "~/.config/opencode/opencode.json global, o opencode.json a nivel de proyecto.",
+    mcpReadonlyMode: "Modo solo lectura",
+    mcpReadonlyModeDescription: "Añade DBX_MCP_ALLOW_WRITES=0 al ejemplo de configuración para que la sesión MCP solo permita consultas.",
+    mcpAllowDangerous: "Permitir SQL peligroso",
+    mcpAllowDangerousDescription: "Añade DBX_MCP_ALLOW_DANGEROUS_SQL=1 al ejemplo de configuración para permitir DROP, TRUNCATE, ALTER y sentencias similares.",
+    mcpDetectionTiming: "DBX comprueba automáticamente al abrir esta página; usa Comprobar de nuevo para actualizar.",
+    mcpNpmBoundary: "DBX solo comprueba y explica el estado de MCP; la instalación y actualización siguen usando npm.",
+    mcpRefresh: "Comprobar de nuevo",
+    mcpGuide: "Guía MCP",
+    supportInfoTitle: "Información de soporte",
+    supportInfoDescription: "Copia estos datos del entorno al crear issues o pedir ayuda.",
+    supportInfoCopy: "Copiar información",
+    supportInfoCopied: "Copiado",
+    supportInfoLoading: "Cargando información de soporte...",
+    supportInfoLoadFailed: "No se pudo cargar toda la información de soporte: {message}",
+    supportInfoAppVersion: "Versión de DBX",
+    supportInfoRuntime: "Entorno",
+    supportInfoRuntimeDesktop: "Escritorio",
+    supportInfoRuntimeWeb: "Web",
+    supportInfoOperatingSystem: "Sistema operativo",
+    supportInfoArchitecture: "Arquitectura",
+    supportInfoUnknown: "Desconocido",
+    community: "Comunidad",
+    qqGroup: "Grupo QQ",
+    wechatGroup: "Grupo WeChat",
+    wechatGroupInvite: "Invitación de Tencent Docs",
+    project: "Proyecto",
+    openSource: "Repositorio de código abierto",
+    officialDocs: "Documentación oficial",
+    shortcutUppercaseSelection: "Convertir selección a mayúsculas",
+    shortcutLowercaseSelection: "Convertir selección a minúsculas",
+    shortcutExPasteSqlInCondition: "ExPaste: pegar como condición IN",
+  },
+  driverStore: {
+    progressJreExtract: "Extrayendo JRE...",
+    progressDownloadJre: "Descargando JRE",
+    progressDownloadDriver: "Descargando driver",
+    progressDownloadJdbcPlugin: "Descargando plugin JDBC",
+    progressJdbcPluginExtract: "Instalando plugin JDBC...",
+    usageTitle: "Uso de almacenamiento",
+    usageTotal: "Total {size}",
+    usageTotalLabel: "Total",
+    calculating: "Calculando...",
+    usageManagedJre: "JRE administrado",
+    usageAgentDrivers: "Agentes de driver integrados",
+    usageDownloadCache: "Caché de descargas",
+    usageJdbcPlugin: "Plugin JDBC",
+    usageJdbcDriverJars: "JARs de driver JDBC",
+    clearDownloadCache: "Limpiar caché",
+    downloadCacheClearSuccess: "Caché de descargas limpiada",
+    downloadCacheClearFailed: "Error al limpiar la caché de descargas: {error}",
+    offlineDownloadHint: "Para entornos sin conexión a internet, descarga los paquetes de drivers offline en una máquina con conexión, luego impórtalos aquí.",
+    offlineDownloadLink: "Descargas de drivers offline",
+    searchDrivers: "Buscar nombre de driver, tipo, versión...",
+    searchJdbcDrivers: "Buscar nombre o ruta del driver JDBC...",
+    jdbcMavenCoordinatePlaceholder: "Coordenada Maven, ej. org.postgresql:postgresql:42.7.7",
+    jdbcMavenInstall: "Instalar desde Maven",
+    jdbcMavenInstallSuccess: "Driver JDBC Maven instalado",
+    jdbcSourceMaven: "Maven",
+    jdbcSourceManual: "Manual",
+    noMatchingDrivers: "Sin coincidencias.",
+    javaRuntimeSaved: "Ajustes de Java guardados",
+    javaRuntimeSaveFailed: "Error al guardar los ajustes de Java: {error}",
+    chooseJavaExecutable: "Seleccionar ejecutable Java",
+    driverInstallSuccess: "Driver {label} instalado",
+    driverInstallFailed: "Error al instalar el driver {label}: {error}",
+    driverUpdateBlocked: "Cierra estas conexiones de base de datos antes de actualizar drivers: {labels}",
+    upgradeAllSuccess: "{count} driver(s) actualizados",
+    upgradeAllPartial: "{count} driver(s) actualizados. Omitidos: {failed}",
+    upgradeAllFailed: "Error al actualizar en lote: {error}",
+    driverUninstallSuccess: "Driver {label} desinstalado",
+    driverUninstallFailed: "Error al desinstalar el driver {label}: {error}",
+    chooseOfflineDriverPackage: "Seleccionar paquete offline de drivers",
+    offlineImportSuccess: "Importación offline completada. Se instalaron {count} driver(s).",
+    offlineImportFailed: "Error en la importación offline: {error}",
+    driverImportSuccess: "Driver {label} importado",
+    driverImportFailed: "Error al importar el driver {label}: {error}",
+    chooseDriverJar: "Seleccionar archivo JAR del driver",
+    jreReinstallSuccess: "JRE {jre} reinstalado",
+    jreReinstallFailed: "Error al reinstalar JRE {jre}: {error}",
+    jreUninstallSuccess: "JRE {jre} desinstalado",
+    chooseJdbcPluginZip: "Seleccionar zip del plugin JDBC",
+    agentDrivers: "Drivers integrados",
+    jdbcDrivers: "Drivers JDBC",
+    importing: "Importando...",
+    importOfflinePackage: "Importar paquete offline",
+    refresh: "Actualizar",
+    javaRuntime: "Runtime Java",
+    javaRuntimeManaged: "JRE administrado por DBX",
+    javaRuntimeSystem: "java del sistema",
+    javaRuntimeCustom: "Ruta personalizada",
+    saving: "Guardando...",
+    customJavaPathPlaceholder: "/ruta/a/java o /ruta/a/jdk",
+    choose: "Seleccionar",
+    systemJavaHint: "Usa java del PATH actual.",
+    jreRuntimeTitle: "Runtime JRE {jre}",
+    notInstalled: "No instalado",
+    reinstalling: "Reinstalando",
+    installing: "Instalando",
+    install: "Instalar",
+    reinstall: "Reinstalar",
+    uninstall: "Desinstalar",
+    jreRuntime: "Runtime JRE",
+    jreRuntimeAutoDownloadHint: "Se descarga automáticamente al instalar un driver por primera vez",
+    driversUpdatable: "{count} driver(s) pueden actualizarse",
+    upgradingProgress: "Actualizando ({current}/{total})",
+    upgradeAll: "Actualizar todo",
+    queued: "En cola",
+    importLocalJar: "Importar JAR local",
+    updating: "Actualizando",
+    update: "Actualizar",
+    localInstall: "Instalación local",
+    runtimeDrivers: "Runtime",
+    storageTab: "Almacenamiento",
+    runtimeTitle: "Runtime de drivers",
+    runtimeHint: "Las métricas de runtime se recopilan solo mientras este panel está abierto.",
+    runtimeRunning: "En ejecución",
+    runtimeMemory: "Memoria",
+    runtimeHealth: "Salud",
+    runtimeHealth_healthy: "Correcto",
+    runtimeHealth_warning: "Advertencia",
+    runtimeHealth_error: "Error",
+    runtimeLastError: "Último error",
+    runtimeEmpty: "Aún no hay runtimes de drivers. Abre una conexión con driver Agent para iniciar uno.",
+    runtimeKindAgent: "Agent",
+    runtimeKindPlugin: "Plugin",
+    runtimeSourceDaemon: "Daemon",
+    runtimeSourceConnection: "Conexión",
+    runtimeStatus_running: "En ejecución",
+    runtimeStatus_stopped: "Detenido",
+    runtimeStatus_error: "Error",
+    runtimeStatus_unknown: "Desconocido",
+    runtimePid: "PID",
+    runtimeUptime: "Tiempo activo",
+    runtimeActions: "Acciones",
+    runtimeStop: "Detener",
+    runtimeRestart: "Reiniciar",
+    runtimeControlConnectionOwned: "Cierra la conexión de base de datos para detener este runtime.",
+    runtimeStopSuccess: "Runtime de {label} detenido",
+    runtimeStopFailed: "Error al detener {label}: {error}",
+    runtimeRestartSuccess: "Runtime de {label} reiniciado",
+    runtimeRestartFailed: "Error al reiniciar {label}: {error}",
+    driverStoreDir: "Ruta de almacenamiento de controladores",
+    driverStoreDirDescription: "Configura ubicaciones separadas para el plugin JDBC y los datos de Agent/JRE. La aplicación se reiniciará automáticamente después de la migración.",
+    pluginStoreDir: "Directorio del plugin JDBC",
+    pluginStoreDirDescription: "Almacena el plugin JDBC, Maven resolver y los jars de controladores JDBC.",
+    agentStoreDir: "Directorio Agent / JRE",
+    agentStoreDirDescription: "Almacena paquetes de controladores Agent, JRE gestionados y caché de runtime.",
+    driverStoreDirDefault: "Predeterminado (directorio de instalación)",
+    driverStoreDirChange: "Cambiar",
+    driverStoreDirReset: "Restablecer",
+    driverStoreDirMigrating: "Migrando {target}…",
+    driverStoreDirConfirm: "Cambiar {target} migrará los datos relacionados a la nueva ubicación. Las conexiones relacionadas pueden desconectarse durante la migración. La aplicación se reiniciará automáticamente después. ¿Continuar?",
+    driverStoreDirMigrationFailed: "Error en la migración de controladores: {error}",
+    driverStoreDirDialogTitle: "Seleccionar {target}",
+    driverStoreDirSuccess: "{target} cambiado, reiniciando…",
+  },
+  databaseExport: {
+    title: "Exportar base de datos",
+    options: "Opciones",
+    includeStructure: "Estructura de tablas (DDL)",
+    dropTableIfExists: "Agregar DROP TABLE IF EXISTS antes del DDL",
+    includeData: "Datos de tablas (INSERT)",
+    includeObjects: "Vistas / Procedimientos / Funciones / Secuencias",
+    databaseSelection: "Bases de datos",
+    selectedDatabases: "{selected}/{total} seleccionadas",
+    selectAllDatabases: "Seleccionar todo",
+    filterDatabases: "Buscar bases de datos...",
+    clearDatabases: "Limpiar",
+    tableSelection: "Tablas",
+    selectedTables: "{selected}/{total} seleccionadas",
+    selectAllTables: "Seleccionar todo",
+    clearTables: "Limpiar",
+    loadingTables: "Cargando tablas...",
+    tableLoadError: "Error al cargar tablas: {error}",
+    noTables: "No se encontraron tablas",
+    export: "Exportar",
+    exportAllDatabases: "Exportar todas las bases de datos",
+    exporting: "Exportando...",
+    selectExportDirectory: "Seleccionar directorio de exportación",
+    currentDatabase: "Base de datos {current}/{total}",
+    currentTable: "Actual: {table} ({current}/{total})",
+    rowsExported: "{count} filas exportadas",
+    exportSuccess: "Base de datos exportada exitosamente",
+    exportAllSuccess: "{count} bases de datos exportadas exitosamente",
+    allDatabasesTask: "Todas las bases de datos ({count})",
+    exportError: "Error al exportar: {error}",
+    exportCancelled: "Exportación cancelada",
+    filterTables: "Buscar tablas...",
+    runInBackground: "Ejecutar en segundo plano",
+  },
+  nacos: {
+    configs: "Configuraciones",
+    services: "Servicios",
+    raw: "Raw",
+    namespace: "Namespace",
+    createNamespace: "Crear Namespace",
+    editNamespace: "Editar Namespace",
+    creatingNamespace: "Creando...",
+    updatingNamespace: "Actualizando...",
+    namespaceCreated: 'Namespace "{name}" creado',
+    namespaceUpdated: 'Namespace "{name}" actualizado',
+    namespaceId: "ID del Namespace",
+    namespaceIdPlaceholder: "Déjalo vacío para que Nacos lo genere",
+    namespaceName: "Nombre del Namespace",
+    namespaceNamePlaceholder: "Ingresa un nombre de namespace",
+    namespaceDesc: "Descripción",
+    namespaceDescPlaceholder: "Por defecto, el nombre del namespace",
+    dataId: "Data ID",
+    group: "Grupo",
+    format: "Formato",
+    content: "Contenido",
+    tags: "Etiquetas",
+    application: "Aplicación",
+    description: "Descripción",
+    advanced: "Avanzado",
+    collapse: "Contraer",
+    load: "Cargar",
+    save: "Guardar",
+    saveAs: "Guardar como",
+    saving: "Guardando...",
+    saved: "Configuración guardada",
+    createdAndLoaded: "{dataId} creado y cargado",
+    savedAndLoaded: "{dataId} guardado y actualizado",
+    deleted: "Configuración eliminada",
+    delete: "Eliminar",
+    copy: "Copiar",
+    copied: "Copiado",
+    copyVerifyFailed: "La verificación del portapapeles falló después de escribir",
+    export: "Exportar",
+    exported: "Exportado",
+    exportedTo: "Exportado a {path}",
+    exportFailed: "Error al exportar: {message}",
+    history: "History",
+    configHistory: "Config history",
+    historyDetail: "History detail",
+    historyCompareTitle: "History Version Compare",
+    currentPublishedContent: "Current published content:",
+    historyVersionContent: "History version content:",
+    updatedAt: "Updated at",
+    operationType: "Operation",
+    operator: "Operator",
+    view: "View",
+    compare: "Compare",
+    rollback: "Rollback",
+    loadingHistory: "Loading history...",
+    noHistory: "No history versions",
+    noHistoryHint: "Refresh if this config was just published. Some Nacos versions may not expose history APIs.",
+    historyCreate: "Create",
+    historyUpdate: "Update",
+    historyDelete: "Delete",
+    historyRollback: "Rollback",
+    confirmRollbackTitle: "Rollback Nacos config",
+    confirmRollbackMessage: "This will roll the current config back to the selected history version.",
+    rollbackSuccess: "Config rolled back",
+    publish: "Publicar",
+    dataIdRequired: "Data ID es obligatorio",
+    allGroups: "Todos los grupos",
+    noConfigs: "Sin configuraciones",
+    selectConfig: "Selecciona o crea una configuración",
+    noServices: "Sin servicios",
+    selectService: "Selecciona un servicio",
+    service: "Servicio",
+    instances: "Instancias",
+    instanceCount: "{count} instancias",
+    refresh: "Actualizar",
+    address: "Dirección",
+    cluster: "Clúster",
+    weight: "Peso",
+    state: "Estado",
+    actions: "Acciones",
+    query: "Consulta",
+    body: "Cuerpo",
+    response: "Respuesta",
+    template: "Plantilla",
+    configDiffTitle: "Comparar contenido de configuración",
+    inlineCompare: "Comparación en línea",
+    currentVersionContent: "Versión oficial actual:",
+    publishVersionContent: "Contenido de esta publicación:",
+    confirmSaveTitle: "Revisar cambios de configuración Nacos",
+    confirmSaveMessage: "¿Guardar este cambio? +{added} / -{removed} líneas.",
+    confirmDeleteTitle: "Eliminar configuración Nacos",
+    confirmDeleteMessage: "Esto elimina la configuración seleccionada de Nacos.",
+    confirmInstanceTitle: "Actualizar instancia Nacos",
+    confirmInstanceMessage: "Confirma el estado objetivo de la instancia.",
+    confirmRawTitle: "Enviar solicitud Raw API modificadora",
+    confirmRawMessage: "Esta solicitud Raw API puede modificar el estado de Nacos.",
+    rawTemplate: {
+      serverState: "Estado del servidor",
+      namespaceList: "Lista de namespaces",
+      configDetail: "Detalle de configuración",
+      serviceList: "Lista de servicios",
+      instanceList: "Lista de instancias",
+    },
+    healthy: "Saludable",
+    unhealthy: "No saludable",
+    enabled: "Habilitado",
+    offline: "Offline",
+    ephemeral: "Efímera",
+    persistent: "Persistente",
+    enable: "Habilitar",
+    disable: "Deshabilitar",
+    markHealthy: "Marcar saludable",
+    markUnhealthy: "Marcar no saludable",
+    send: "Enviar",
+    total: "{count} en total",
+    prev: "Anterior",
+    next: "Siguiente",
+    test: "Probar",
+    readOnly: "Solo lectura",
+  },
+  gridfsBrowser: {
+    bucketCount: "Cantidad de buckets",
+    fileCount: "Archivos",
+    name: "Nombre",
+    totalSize: "Tamaño",
+    chunkSize: "Tamaño de fragmento",
+    uploadDate: "Fecha de carga",
+    contentType: "Tipo de contenido",
+    metadata: "Metadatos",
+    selectBucket: "Selecciona un bucket de GridFS para ver o abrir.",
+    selectFile: "Selecciona un archivo de GridFS para ver o administrar.",
+    emptyBuckets: "Actualmente no hay buckets de GridFS, puedes crear uno nuevo.",
+    emptyFiles: "El bucket actual aún no tiene archivos, puedes subir uno primero.",
+    createBucket: "Crear bucket",
+    openBucket: "Abrir bucket",
+    deleteBucket: "Eliminar bucket",
+    createTitle: "Crear bucket de GridFS",
+    deleteTitle: "Eliminar bucket de GridFS",
+    deleteMessage: "¿Estás seguro de eliminar el bucket de GridFS seleccionado y todos los archivos que contiene?",
+    bucketName: "Nombre del bucket",
+    bucketNamePlaceholder: "example_bucket",
+    bucketCreated: "Bucket {bucket} creado.",
+    bucketDeleted: "Bucket {bucket} eliminado.",
+    uploadFile: "Subir archivo",
+    downloadFile: "Descargar archivo",
+    downloadSelected: "Descargar seleccionados",
+    deleteFile: "Eliminar archivo",
+    selectedCount: "{count} seleccionados",
+    deleteFileTitle: "Eliminar archivo de GridFS",
+    deleteFileMessage: "¿Estás seguro de eliminar el archivo seleccionado del bucket de GridFS actual?",
+    fileUploaded: "Archivo {fileName} subido.",
+    fileDeleted: "Archivo {fileName} eliminado.",
+  },
+  extension: {
+    installTitle: "Instalar extensión",
+    manageTitle: "Administrar extensión",
+    name: "Nombre de la extensión",
+    namePlaceholder: "Por ejemplo: pg_stat_statements",
+    install: "Instalar",
+    drop: "Eliminar",
+    available: "Extensiones disponibles",
+    installed: "Extensiones instaladas",
+    noAvailable: "Todas las extensiones disponibles ya están instaladas.",
+    noInstalled: "Aún no hay extensiones instaladas.",
+  },
+  sqlFileTree: {
+    title: "Archivos SQL",
+    openFolder: "Abrir carpeta",
+    closePanel: "Cerrar",
+    loading: "Cargando...",
+    noFolder: "Sin carpeta abierta",
+    noSqlFiles: "No se encontraron archivos SQL",
+    folderAlreadyOpen: "Esta carpeta ya está abierta",
+    removeFolder: "Eliminar carpeta",
+    openFailed: "Error al abrir la carpeta: {message}",
+    loadFailed: "Error al cargar archivos SQL: {message}",
+    desktopOnly: "Esta función solo está disponible en la versión de escritorio",
+    refreshFolder: "Actualizar carpeta",
+    refreshAll: "Actualizar todo",
+    refreshed: "Actualizado",
+    revealInFileManager: "Mostrar en el explorador de archivos",
+    revealFailed: "Error al abrir el explorador de archivos: {message}",
+    copyPath: "Copiar ruta",
+    pathCopied: "Ruta copiada",
+    copyFailed: "Error al copiar la ruta",
+    openFile: "Abrir",
+    executeSqlFile: "Ejecutar archivo SQL",
+    expandAll: "Expandir todo",
+    collapseAll: "Contraer todo",
+  },
+  mqTopics: {
+    title: "Administración de temas",
+    searchPlaceholder: "Buscar topic",
+    includeNonPersistent: "Incluir temas no persistentes",
+    refresh: "Actualizar",
+    refreshing: "Actualizando...",
+    createTopic: "Crear tema",
+    selectTenantNamespace: "Seleccione primero el tenant y el namespace",
+    loading: "Cargando...",
+    noTopics: "No hay temas en este namespace",
+    noMatches: "No se encontraron temas coincidentes",
+    name: "Nombre",
+    type: "Tipo",
+    partitions: "Particiones",
+    actions: "Acciones",
+    nonPersistent: "No persistente",
+    partitionedTopic: "Tema particionado",
+    normalTopic: "Tema normal",
+    partitionCount: "{count} particiones",
+    partitionsUnknown: "Número de particiones desconocido",
+    adjustPartitions: "Ajustar particiones",
+    delete: "Eliminar",
+    tenantNamespace: "Tenant / Namespace",
+    topicName: "Nombre del tema",
+    topicNamePlaceholder: "Ejemplo: my-topic",
+    persistentRecommended: "Tema persistente (recomendado)",
+    persistentHint: "Los temas persistentes guardan los mensajes en disco, los no persistentes solo en memoria.",
+    enablePartitions: "Habilitar particiones",
+    partitionQuantity: "Cantidad de particiones",
+    partitionHint: "Las particiones pueden mejorar el rendimiento concurrente, pero aumentan el consumo de recursos.",
+    cancel: "Cancelar",
+    create: "Crear",
+    updatePartitionsTitle: "Ajustar número de particiones: {name}",
+    currentPartitions: "Particiones actuales",
+    newPartitions: "Nuevo número de particiones",
+    partitionMinHint: "El número de particiones solo puede aumentar, no disminuir. Mínimo: {min}",
+    update: "Actualizar",
+    readOnly: "La conexión actual es de solo lectura, no se pueden realizar operaciones de escritura.",
+    topicNameRequired: "El nombre del topic no puede estar vacío",
+    currentPartitionsUnknown: "Se desconoce el número actual de particiones, no se puede ajustar de forma segura.",
+    partitionMustIncrease: "El nuevo número de particiones debe ser mayor que el actual.",
+    confirmDelete: '¿Está seguro de que desea eliminar el tema "{name}"? Esta operación no se puede deshacer.',
+  },
+  production: {
+    title: "Entorno de producción",
+    connection: "Conexión de producción",
+    enable: "Activar protección del entorno de producción",
+    disabledDescription: "Al activar, puede elegir proteger todas las bases de datos o bases de datos específicas.",
+    scope: "Alcance de la protección",
+    allDatabases: "Todas las bases de datos",
+    selectedDatabases: "Bases de datos seleccionadas",
+    singleDatabaseScopeHint: "Este tipo de base de datos solo admite protección del entorno de producción a nivel de conexión.",
+    databases: "Bases de datos de producción",
+    connectionDescription: "Todas las bases de datos de esta conexión tendrán habilitada la protección de producción.",
+    databaseDescription: "Seleccione de la conexión las bases de datos que necesiten protección de producción. La primera vez, se seleccionan todas por defecto.",
+    selectDatabases: "Seleccionar bases de datos de producción",
+    noDatabasesSelected: "Ninguna seleccionada",
+    databasesConfiguredCount: "{count} seleccionadas",
+    databasesSelectedCount: "{selected}/{total} seleccionadas",
+    databasePickerTitle: "Seleccionar bases de datos de producción",
+    databasePickerDescription: "Seleccione las bases de datos en {connection} que necesiten protección de producción.",
+    databaseSearchPlaceholder: "Buscar bases de datos...",
+    databaseSelectionRequired: "Seleccione al menos una base de datos.",
+    databaseLoadFailed: "No se pudo cargar la lista de bases de datos: {message}",
+    noDatabasesAvailable: "No se encontraron bases de datos para seleccionar.",
+    retry: "Reintentar",
+    confirmTitle: "Confirmar escritura en el entorno de producción",
+    confirmMessage: "Esta operación modificará la base de datos de producción. Debe confirmar explícitamente para continuar.",
+    confirmDetails: "Conexión: {connection}\nBase de datos: {database}\nOrigen: {source}",
+    confirmAction: "Ejecutar en el entorno de producción",
+    sourceSqlEditor: "Editor SQL",
+    sourceDataGrid: "Editor de datos",
+    sourceStructure: "Editor de estructura",
+    sourceSqlFile: "Ejecución de archivo SQL",
+    sourceObjectBrowser: "Explorador de objetos",
+    sourceSchemaDiff: "Comparación de esquemas",
+    sourceDataCompare: "Comparación de datos",
+    sourceExtension: "Gestor de extensiones",
+    sourceSidebar: "Árbol de objetos",
+    sourceObjectSource: "Editor de código fuente de objetos",
+    sourceDataGenerate: "Generador de datos",
+    sourceQueryHistory: "Reversión del historial de consultas",
+    sourceAdmin: "Administración de bases de datos",
+    aiReviewRequired: "El SQL de producción se ha colocado en el editor. Revíselo primero y luego ejecútelo manualmente para confirmar.",
+  },
+});
diff --git a/apps/desktop/src/i18n/locales/fallback.ts b/apps/desktop/src/i18n/locales/fallback.ts
new file mode 100644
index 0000000..63c0d3b
--- /dev/null
+++ b/apps/desktop/src/i18n/locales/fallback.ts
@@ -0,0 +1,30 @@
+import en from "./en";
+
+type LocaleMessages = Record<string, unknown>;
+
+function cloneMessage(value: unknown): unknown {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return mergeMessages(value as LocaleMessages, {});
+  }
+  return value;
+}
+
+function mergeMessages(base: LocaleMessages, override: LocaleMessages): LocaleMessages {
+  const result: LocaleMessages = {};
+  for (const [key, value] of Object.entries(base)) {
+    result[key] = cloneMessage(value);
+  }
+  for (const [key, value] of Object.entries(override)) {
+    const baseValue = result[key];
+    if (baseValue && value && typeof baseValue === "object" && typeof value === "object" && !Array.isArray(baseValue) && !Array.isArray(value)) {
+      result[key] = mergeMessages(baseValue as LocaleMessages, value as LocaleMessages);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export function withEnglishFallback(messages: LocaleMessages): LocaleMessages {
+  return mergeMessages(en as LocaleMessages, messages);
+}
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
new file mode 100644
index 0000000..4b1d62e
--- /dev/null
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -0,0 +1,3820 @@
+import { withEnglishFallback } from "./fallback";
+export default withEnglishFallback({
+  app: {
+    name: "DBX",
+  },
+  auth: {
+    setupTitle: "Imposta la password di accesso",
+    setupDescription: "Imposta una password per proteggere la tua istanza",
+    loginDescription: "Strumento di gestione del database",
+    newPassword: "Inserisci la nuova password",
+    confirmPassword: "Conferma la password",
+    enterPassword: "Inserisci la password di accesso",
+    passwordMismatch: "Le password non corrispondono",
+    setPassword: "Imposta Password",
+    login: "Accedi",
+    processing: "Elaborazione...",
+    loginFailed: "Password errata",
+    connectFailed: "Connessione non riuscita",
+    changePassword: "Cambia Password",
+    oldPassword: "Password attuale",
+    oldPasswordWrong: "La password attuale non è corretta",
+    passwordChanged: "Password modificata con successo",
+    changePasswordFailed: "Impossibile modificare la password",
+    changePasswordDescription: "Inserisci la password attuale e scegline una nuova",
+  },
+  toolbar: {
+    newConnection: "Nuova Connessione",
+    newQuery: "Nuova Query",
+    execute: "Esegui",
+    executeShortcut: "Esegui selezione/query (Cmd+Enter)",
+    stopQuery: "Interrompi query",
+    explainPlan: "Spiega piano",
+    stopExplain: "Interrompi spiegazione",
+    formatSql: "Formatta SQL",
+    formatSqlFailed: "Impossibile formattare SQL",
+    keywordCaseLower: "Usa parole chiave SQL minuscole",
+    keywordCaseUpper: "Usa parole chiave SQL maiuscole",
+    autoCommit: "Auto Commit",
+    manualTransaction: "Transazione Manuale",
+    autoCommitAgent: "Auto Commit (dipende dal backend dell'Agente)",
+    manualTransactionAgent: "Transazione Manuale (dipende dal backend dell'Agente)",
+    commit: "Commit",
+    rollback: "Rollback",
+    txnAutoRolledBack: "Transazione annullata automaticamente dopo 5 minuti di inattività",
+    previewSql: "Anteprima SQL",
+    hidePreviewSql: "Nascondi anteprima SQL",
+    saveSql: "Salva nella Libreria SQL",
+    openSql: "Apri file SQL",
+    exPasteSqlInCondition: "ExPaste: incolla come condizione IN",
+    theme: "Tema",
+    themeLight: "Chiaro",
+    themeDark: "Scuro",
+    themeSystem: "Segui Sistema",
+    sqlSaved: "SQL salvato",
+    sqlOpenFailed: "Impossibile aprire il file: {message}",
+    sqlSaveFailed: "Impossibile salvare il file: {message}",
+    driverManager: "Gestione Driver",
+    updatableDriverCount: "Driver aggiornabili",
+    blockDangerousRedisCommands: "Blocca comandi pericolosi",
+  },
+  updates: {
+    title: "Aggiornamenti",
+    check: "Verifica aggiornamenti",
+    availableTitle: "Aggiornamento disponibile",
+    availableMessage: "DBX {latest} è disponibile. Stai usando la versione {current}.",
+    upToDate: "DBX è aggiornato ({version}).",
+    failed: "Verifica aggiornamenti non riuscita: {error}",
+    rateLimited: "Le verifiche degli aggiornamenti di GitHub sono temporaneamente limitate. Puoi comunque aprire la pagina delle release per verificare manualmente.",
+    openRelease: "Apri Release",
+    downloadAndInstall: "Scarica e Installa",
+    portableManualUpdate: "Le build portatili non possono utilizzare l'installer in-app. Scarica lo ZIP portatile dalla pagina delle release, quindi estrailo nella cartella DBX corrente per mantenere portable.dbx e i dati.",
+    downloading: "Download in corso {progress}%",
+    downloadFailed: "Download dell'aggiornamento non riuscito: {error}",
+    restart: "Esci e Riavvia",
+    restartFailed: "Impossibile riavviare l'app: {error}",
+    exitAndUpdate: "Esci e Aggiorna",
+    dockerUsersRun: "Gli utenti Docker dovrebbero eseguire",
+    toUpdate: "per aggiornare",
+  },
+  sidebar: {
+    connections: "CONNESSIONI",
+    noConnections: "Nessuna connessione",
+    import: "Importa Connessioni",
+    importDbx: "Importa Configurazione DBX",
+    importNavicat: "Importa Navicat NCX",
+    importDbeaver: "Importa DBeaver",
+    importDatagrip: "Importa DataGrip",
+    export: "Esporta Connessioni",
+    collapseAll: "Riduci tutto",
+    collapse: "Riduci barra laterale",
+    expand: "Espandi barra laterale",
+    showMore: "Mostra altri {count}...",
+    filterByType: "Filtra per tipo",
+    searchScopeConnection: "Connessione",
+    searchScopeDatabase: "Database",
+    searchScopeSchema: "Schema",
+    searchScopeTable: "Tabella",
+    searchScopeView: "Vista",
+    searchTablesInCurrentScope: "Cerca tabelle in questo database...",
+    clearTableSearch: "Cancella ricerca tabelle",
+    clearFilter: "Cancella filtro",
+    locateActiveTab: "Trova nella barra laterale",
+  },
+  savedSql: {
+    saveToLibrary: "Salva nella Libreria SQL",
+    saveToFile: "Salva localmente",
+    save: "Salva",
+    saved: "SQL salvato",
+    saveFailed: "Impossibile salvare SQL: {message}",
+    fileName: "Nome file",
+    folder: "Cartella",
+    rootFolder: "Libreria SQL",
+    newQuery: "Nuova query",
+    newFolder: "Nuova Cartella SQL",
+    newFolderDefault: "Nuova Cartella",
+    renameFolder: "Rinomina Cartella",
+    deleteFolder: "Elimina Cartella",
+    deleteFolderConfirm: "Eliminare “{name}” e tutti i file SQL al suo interno?",
+    open: "Apri SQL",
+    renameFile: "Rinomina SQL",
+    deleteFile: "Elimina SQL",
+    deleteFileConfirm: "Eliminare “{name}”?",
+  },
+  sqlLibrary: {
+    title: "Libreria SQL",
+    empty: "Nessuna query salvata",
+    emptyFolder: "Cartella vuota",
+    unfiled: "Non categorizzati",
+    exportFile: "Esporta SQL",
+    exportFolder: "Esporta cartella",
+    exportLibrary: "Esporta libreria SQL",
+    importDirectory: "Importa cartella locale",
+    importIntoFolder: "Importa in questa cartella",
+    openStorageDirectory: "Apri directory SQL",
+    chooseSyncDirectory: "Imposta directory di sincronizzazione locale",
+    disableSyncDirectory: "Disattiva sincronizzazione locale",
+    syncDirectorySaved: "Directory di sincronizzazione locale SQL salvata",
+    syncDirectoryDisabled: "Sincronizzazione locale SQL disattivata",
+    syncDirectoryFailed: "Impossibile impostare la directory di sincronizzazione: {message}",
+    openDirectoryFailed: "Impossibile aprire la directory: {message}",
+    noSyncDirectory: "Imposta prima una directory di sincronizzazione locale",
+    exported: "Esportato",
+    exportFailed: "Esportazione non riuscita: {message}",
+    importFailed: "Importazione non riuscita: {message}",
+    importNone: "Nessun file .sql trovato nella cartella selezionata",
+    imported: "Importati {count} file SQL",
+    desktopOnly: "Questa funzione è disponibile solo su desktop",
+    noConnection: "Nessuna connessione disponibile per l'importazione",
+    batchDelete: "Eliminazione in blocco",
+    batchDeleteConfirm: "Sei sicuro di voler eliminare {count} elementi selezionati? Questa azione non può essere annullata.",
+    batchDeleteSuccess: "{count} elementi eliminati con successo",
+    moveToFolder: "Sposta nella cartella...",
+    moveSelectedToFolder: "Sposta {count} SQL nella cartella...",
+    moveSuccess: "{count} SQL spostati",
+    clearSelection: "Cancella selezione",
+    sortByDate: "Ordina per data di modifica",
+    sortByFolder: "Ordina per struttura cartelle",
+  },
+
+  connection: {
+    title: "Nuova Connessione",
+    name: "Nome",
+    namePlaceholder: "Nome connessione, generato automaticamente se vuoto",
+    type: "Tipo",
+    host: "Host",
+    filePath: "Percorso File",
+    h2FileMode: "File",
+    h2TcpMode: "TCP",
+    h2FilePathRequired: "Il percorso del file H2 non può essere vuoto",
+    createDuckDbFile: "Crea file DuckDB",
+    createSqliteFile: "Crea database SQLite",
+    memoryDatabasePathHint: "Usa :memory: per creare un database SQLite o DuckDB in memoria.",
+    sqliteCipherKey: "Chiave SQLCipher",
+    sqliteCipherKeyPlaceholder: "Lascia vuoto per SQLite non cifrato",
+    sqliteExtensions: "Estensioni SQLite",
+    sqliteExtensionsPlaceholder: "/percorso/per/regexp.dylib\n/percorso/per/text.dylib|sqlite3_text_init",
+    sqliteExtensionsHint: "Una .dylib/.so/.dll per riga. Usa “percorso|punto di ingresso” quando è richiesto un punto di ingresso. Caricata alla connessione, poi load_extension viene disabilitata.",
+    sqliteExtensionBrowse: "Seleziona estensione SQLite",
+    user: "Utente",
+    password: "Password",
+    database: "Database",
+    databasePlaceholder: "Opzionale",
+    databasePlaceholderRequired: "Obbligatorio, inserisci un database esistente",
+    databasePlaceholderWithDefault: "Opzionale, predefinito {database}",
+    kingbaseDatabaseRequired: "Kingbase richiede un database esistente prima di connettersi o caricare l'elenco dei database.",
+    defaultDatabase: "DB Predefinito",
+    authDatabase: "DB di Autenticazione",
+    authDatabasePlaceholder: "Opzionale, spesso admin",
+    authMechanism: "Meccanismo di Autenticazione",
+    authMechanismDefault: "Predefinito",
+    driverMode: "Driver",
+    mongoDriverAuto: "Automatico",
+    mongoDriverLegacy: "Legacy",
+    serviceName: "Servizio/SID",
+    serviceNameOnly: "Nome Servizio",
+    version: "Versione",
+    driverInstallHintPrefix: "Installa il driver richiesto da ",
+    driverInstallHintSuffix: " nella barra degli strumenti superiore prima di connetterti.",
+    driverName: "Nome Driver",
+    driverNamePlaceholder: "Nome del fornitore o dell'ambiente",
+    urlParams: "Parametri URL",
+    d1AccountId: "ID account",
+    d1DatabaseId: "ID database",
+    d1ApiToken: "Token API",
+    d1TokenHint: "Il token richiede almeno l'autorizzazione D1 Read; per scritture, DDL e importazioni è necessaria anche D1 Write.",
+    d1FieldsRequired: "Sono obbligatori l'ID account Cloudflare, l'ID database D1 e il token API.",
+    gbaseServer: "GBASEDBTSERVER",
+    informixServer: "INFORMIXSERVER",
+    sslEnable: "Abilita connessione crittografata",
+    caCertPath: "Certificato CA",
+    caCertPathPlaceholder: "Opzionale, es. ~/.yandex/RootCA.crt",
+    caCertPathBrowse: "Sfoglia certificato",
+    redisTlsInsecure: "Salta verifica certificato",
+    redisTlsInsecureHint: "Equivalente a redis-cli --tls --insecure, per certificati auto-firmati o CA private.",
+    mysqlTlsMode: "Modalità TLS",
+    mysqlTlsModePreferred: "Preferita",
+    mysqlTlsModeDisabled: "Disabilitata",
+    mysqlTlsModeRequired: "Richiesta",
+    mysqlTlsModeVerifyCa: "Verifica CA",
+    mysqlTlsModeVerifyIdentity: "Verifica Identità",
+    mysqlCleartextPasswordAuth: "Autenticazione password in chiaro",
+    mysqlCleartextPasswordAuthHint: "Attiva solo quando il server MySQL richiede il plugin di autenticazione password in chiaro.",
+    mysqlCaCertHint: "Richiesto per Verifica CA e Verifica Identità quando il certificato del server usa una CA privata.",
+    mysqlClientCert: "Autenticazione Client",
+    mysqlClientCertPlaceholder: "/percorso/per/client.crt",
+    mysqlClientKeyPlaceholder: "/percorso/per/client.key",
+    mysqlClientCertHint: "Il certificato client e la chiave privata devono essere forniti insieme quando MySQL richiede mTLS.",
+    mysqlTlsConnectionFailureHint: "Se il server MySQL non richiede TLS, modifica la connessione, imposta la modalità TLS su Disabilitata e riprova.",
+    mysqlClientCertBrowse: "Scegli certificato client",
+    mysqlClientKeyBrowse: "Scegli chiave privata client",
+    postgresSslMode: "Modalità TLS",
+    postgresSslModeDisable: "Disabilita",
+    postgresSslModePrefer: "Preferisci",
+    postgresSslModeRequire: "Richiedi",
+    postgresSslModeVerifyCa: "Verifica CA",
+    postgresSslModeVerifyFull: "Verifica Completa",
+    postgresServerCert: "CA Server",
+    postgresRootCertPlaceholder: "/percorso/per/ca.crt",
+    postgresRootCertHint: "Usa questo per verifica-ca o verifica-completa quando il certificato del server è firmato da una CA privata.",
+    postgresRootCertBrowse: "Scegli certificato CA",
+    postgresClientCert: "Autenticazione Client",
+    postgresClientCertPlaceholder: "/percorso/per/client.crt",
+    postgresClientKeyPlaceholder: "/percorso/per/client.key",
+    postgresClientCertHint: "Il certificato client e la chiave privata devono essere forniti insieme quando PostgreSQL richiede mTLS.",
+    postgresClientCertBrowse: "Scegli certificato client",
+    postgresClientKeyBrowse: "Scegli chiave privata client",
+    connectionUrlOptional: "URL (opzionale)",
+    connectionUrlPlaceholder: "postgresql://utente:password{'@'}host:5432/db?sslmode=require",
+    parseConnectionUrl: "Analizza URL di connessione",
+    parseConnectionUrlApplied: "URL di connessione applicato",
+    parseConnectionUrlFailed: "Impossibile analizzare l'URL di connessione: {message}",
+    mode: "Modalità Connessione",
+    modeForm: "Modulo",
+    redisStandaloneMode: "Standalone",
+    redisSentinelMode: "Sentinel",
+    redisClusterMode: "Cluster",
+    oceanbaseMySQLMode: "Modalità MySQL",
+    oceanbaseOracleMode: "Modalità Oracle",
+    redisFirstSentinel: "Primo Sentinel",
+    redisFirstClusterNode: "Primo Nodo Seed",
+    redisSentinelNodes: "Nodi Sentinel",
+    redisClusterNodes: "Nodi Seed Cluster",
+    redisSentinelMaster: "Nome Master",
+    redisSentinelUser: "Utente Sentinel",
+    redisSentinelPassword: "Password Sentinel",
+    redisSentinelTls: "TLS Sentinel",
+    redisSentinelTlsHint: "Usa TLS quando ti connetti ai nodi Sentinel",
+    redisKeySeparator: "Separatore namespace chiavi",
+    etcdEndpoints: "Endpoint",
+    etcdEndpointsHint: "Un endpoint per riga. Lascia vuoto per usare l'host e la porta sopra.",
+    etcdCaCertPlaceholder: "/percorso/per/ca.crt",
+    etcdCaCertBrowse: "Scegli certificato CA",
+    etcdClientAuth: "Autenticazione Client",
+    etcdClientCertPlaceholder: "/percorso/per/client.crt",
+    etcdClientKeyPlaceholder: "/percorso/per/client.key",
+    etcdClientCertHint: "Il certificato client e la chiave privata devono essere forniti insieme quando etcd richiede mTLS.",
+    etcdClientCertBrowse: "Scegli certificato client",
+    etcdClientKeyBrowse: "Scegli chiave privata client",
+    etcdClientCertPairRequired: "Il certificato client e la chiave privata devono essere forniti insieme.",
+    zookeeperConnectString: "Stringa di connessione",
+    zookeeperConnectStringHint: "Voci host:porta separate da virgola o da riga. Lascia vuoto per usare l'host e la porta sopra.",
+    zookeeperCreateModePersistent: "Persistente",
+    zookeeperCreateModeEphemeral: "Effimero",
+    zookeeperCreateModePersistentSequential: "Persistente Sequenziale",
+    zookeeperCreateModeEphemeralSequential: "Effimero Sequenziale",
+    nacosConsoleUrl: "URL console",
+    nacosConsoleUrlHint: "Usa l'indirizzo console/admin API di Nacos. Nacos 3 Docker di solito espone la console su 8085; distribuzioni più vecchie possono condividere 8848 con la porta di servizio.",
+    nacosConsoleUrlRequired: "L'URL console Nacos è obbligatorio",
+    nacosConsoleUrlAutoAdjusted: "URL console Nacos regolato da {from} a {to}.",
+    nacosNamespace: "Namespace",
+    nacosContextPath: "Context Path",
+    nacosContextPathPlaceholder: "Lascia vuoto o /nacos",
+    nacosAuth: "Autenticazione",
+    nacosAuthNone: "Nessuna",
+    nacosAuthUserPassword: "Utente / Password",
+    nacosUsernameRequired: "Il nome utente Nacos è obbligatorio",
+    nacosTls: "TLS",
+    nacosTlsSkipVerify: "Salta verifica certificato",
+    nacosPageSize: "Dimensione pagina",
+    searchDatabasePlaceholder: "Cerca tipi di database",
+    iconView: "Vista icone",
+    listView: "Vista elenco",
+    selectedDatabase: "Selezionato",
+    noDatabaseMatches: "Nessun database corrispondente",
+    next: "Avanti",
+    back: "Precedente",
+    basicTab: "Connessione",
+    tlsTab: "TLS/SSL",
+    test: "Test",
+    testing: "Verifica in corso...",
+    copyTestResult: "Copia risultato test",
+    sqlServerLegacyCompatibilityMode: "Modalità compatibilità legacy",
+    sqlServerLegacyCompatibilityModeEnable: "Usa connessione di compatibilità legacy SQL Server",
+    sqlServerLegacyCompatibilityModeEnabled: "La modalità compatibilità legacy di SQL Server è abilitata.",
+    sqlServerLegacyCompatibilityModeHint:
+      "Si applica a scenari non crittografati, con crittografia solo al login o con compatibilità legacy TLS 1.0. Se il componente di compatibilità non è installato, DBX lo installa prima di abilitare questa modalità.\nQuando il fallback usa il componente di compatibilità, alcune funzionalità native di SQL Server potrebbero non essere disponibili.\nUsala solo su reti attendibili, VPN o tunnel SSH",
+    sqlServerLegacyCompatibilityComponent: "Componente di compatibilità legacy SQL Server",
+    sqlServerLegacyCompatibilityComponentInstalling: "Installazione componente di compatibilità legacy SQL Server...",
+    saveAndConnect: "Salva & Connetti",
+    save: "Salva",
+    editTitle: "Modifica Connessione",
+    testSuccess: "Connessione riuscita",
+    connecting: "Connessione a {name}...",
+    connectSuccess: "Connesso a {name}",
+    connectFailed: "Connessione non riuscita: {message}",
+    driverNotInstalled: "Il driver {driver} non è installato. Installalo da Gestione Driver.",
+    jreNotInstalled: "Il runtime JRE {jre} non è installato. Installalo da Gestione Driver.",
+    systemJavaNotFound: "Runtime Java di sistema non trovato in PATH. Installa Java o scegli un eseguibile Java personalizzato.",
+    customJavaPathEmpty: "Il percorso del runtime Java personalizzato è vuoto. Scegli un eseguibile Java.",
+    agentJavaTooOld: "Questo driver richiede Java 21. Usa il JRE 21 gestito da DBX o seleziona un eseguibile Java 21 in Gestione Driver.",
+    agentDriverUpdateConnectionHint: "È disponibile un aggiornamento del driver integrato per questa connessione. Il problema di connessione potrebbe essere correlato a un driver locale obsoleto. Aggiorna il driver corrispondente in Gestione Driver e riprova.",
+    jdbcPluginNotInstalled: "Il plugin JDBC non è installato. Installa il plugin JDBC opzionale per utilizzare questa connessione.",
+    lastError: "Errore di connessione",
+    clearError: "Cancella errore di connessione",
+    saveFailed: "Impossibile salvare la connessione: {message}",
+    deleted: "Connessione eliminata",
+    deletedSelected: "{count} connessioni eliminate",
+    copied: "Copiato",
+    disconnected: "Disconnesso",
+    databaseConnectionClosed: "Connessione al database chiusa: {name}",
+    duplicated: "Connessione duplicata",
+    duplicatedSelected: "{count} connessioni duplicate",
+    groupDeleted: "Gruppo eliminato",
+    loadFailed: "Impossibile caricare le connessioni salvate: {message}",
+    sshTunnel: "Tunnel SSH / Proxy",
+    advancedTab: "Avanzate",
+    sshEnable: "Usa tunnel SSH / proxy",
+    sshHost: "Host SSH",
+    sshHostPlaceholder: "ssh.example.com o un alias da ~/.ssh/config",
+    sshUser: "Utente SSH",
+    sshAuthMethod: "Metodo di accesso",
+    sshAuthMethodPassword: "Password",
+    sshAuthMethodKey: "Chiave privata",
+    sshAuthMethodNone: "Nessuno",
+    sshAuthMethodNoneHint: "Non verrà inviata alcuna credenziale. Usalo per bastion host o proxy che accettano connessioni senza autenticazione.",
+    sshAuthMethodAgentLegacy: "SSH Agent (legacy)",
+    sshPassword: "Password SSH",
+    sshPasswordPlaceholder: "Lascia vuoto per usare la chiave",
+    sshKeyPath: "Percorso Chiave",
+    sshKeyPassphrase: "Passphrase Chiave",
+    sshKeyPassphrasePlaceholder: "Lascia vuoto se la chiave non è crittografata",
+    sshKeyPathBrowse: "Sfoglia",
+    sshExposeLan: "Esponi tunnel alla LAN",
+    sshConnectTimeout: "Timeout SSH (secondi)",
+    sshHops: "Livelli tunnel SSH / proxy",
+    sshHopAdd: "Aggiungi livello SSH",
+    sshHopDuplicate: "Duplica",
+    sshHopDelete: "Elimina",
+    sshHopMoveUp: "Sposta su",
+    sshHopMoveDown: "Sposta giù",
+    sshHopName: "Nome livello",
+    sshHopNamePlaceholder: "Bastion, jump host, gateway di produzione",
+    sshHopDefaultName: "Livello {index}",
+    sshHopInvalidHost: "{hop}: Host SSH richiesto",
+    sshHopInvalidUser: "{hop}: Utente SSH richiesto",
+    sshHopInvalidPort: "{hop}: La porta SSH deve essere compresa tra 1 e 65535",
+    sshHopInvalidAuth: "{hop}: password, percorso chiave o ssh-agent richiesti",
+    sshUseAgent: "Usa ssh-agent",
+    sshAgentSockPath: "Percorso socket agent",
+    sshAgentSockPathPlaceholder: "es. ~/.ssh/agent.sock",
+    sshHopInvalidTimeout: "{hop}: Il timeout SSH deve essere compreso tra 1 e 300 secondi",
+    connectTimeout: "Timeout Connessione (secondi)",
+    queryTimeout: "Timeout Query (secondi)",
+    idleTimeout: "Timeout Inattività (secondi)",
+    keepaliveInterval: "Intervallo keepalive (secondi)",
+    readOnly: "Sola lettura",
+    readOnlyHint: "Blocca tutte le operazioni di scrittura (INSERT, UPDATE, DELETE, ecc.)",
+    readOnlyBadge: "Sola lettura",
+    proxy: "Proxy",
+    proxyEnable: "Connetti database tramite proxy",
+    proxyType: "Tipo Proxy",
+    proxyHost: "Host Proxy",
+    proxyUsername: "Utente Proxy",
+    proxyUsernamePlaceholder: "Opzionale",
+    proxyPassword: "Password Proxy",
+    proxyPasswordPlaceholder: "Opzionale",
+    tunnelProfile: "Profilo tunnel",
+    tunnelProfileCustom: "Personalizzato (solo questa connessione)",
+    tunnelProfileManaged: "Gestito da un profilo tunnel condiviso. Modificalo in Impostazioni > Tunnel; le modifiche si applicano a tutte le connessioni che lo usano alla prossima connessione.",
+    tunnelProfileMissing: "Il profilo tunnel a cui si fa riferimento non esiste più. Seleziona un altro profilo o passa a personalizzato.",
+    tunnelProfileMissingName: "Profilo tunnel mancante",
+    tunnelProfileManage: "Gestisci",
+    dremioArrowFlightSqlMode: "Arrow Flight SQL",
+    dremioLegacyJdbcMode: "JDBC legacy",
+    jdbcUrl: "URL JDBC",
+    jdbcUrlPlaceholder: "jdbc:postgresql://localhost:5432/database",
+    jdbcDriverClass: "Classe Driver (opzionale)",
+    jdbcDriverClassPlaceholder: "La maggior parte dei driver si registra automaticamente; usa com.vendor.jdbc.Driver si necessario",
+    jdbcDriverPaths: "JAR del Driver",
+    jdbcDriverSelectPlaceholder: "Scegli il driver importato",
+    jdbcManualClasspath: "Classpath manuale",
+    jdbcManualClasspathCount: "{count} percorsi",
+    jdbcDriverPathsPlaceholder: "/percorso/per/driver.jar\n/percorso/per/un-altro-driver.jar",
+    jdbcDriverBrowse: "Scegli file JAR del driver JDBC",
+    jdbcDocs: "Visualizza documentazione JDBC",
+    jdbcPluginHint: "Installa prima il plugin DBX JDBC, quindi importa il file JAR del driver JDBC del fornitore del database.",
+    dmCompatHint: "Richiede il driver ODBC DM8 installato sul sistema.",
+    dmDownload: "Scarica da Dameng",
+    mongoLegacyHint: "Usa Legacy per server MongoDB meno recenti, specialmente versioni precedenti alla 4.2. Se l'autenticazione fallisce e l'utente è stato creato in admin, imposta DB di Autenticazione su admin.",
+    mongoTlsAllowInvalidCertificates: "Disabilita verifica certificato TLS",
+    mongoTlsAllowInvalidCertificatesHint: "Corrisponde a tlsAllowInvalidCertificates=true e disabilita tutta la validazione del certificato, non solo il controllo dell'hostname. Aumenta il rischio MITM. Di solito è necessario per AWS DocumentDB tramite tunnel SSH.",
+    mongoRetryWrites: "Riprova scritture",
+    mongoRetryWritesHint: "Corrisponde a retryWrites. Disabilitalo per AWS DocumentDB, che non supporta scritture ripetibili.",
+    compatible: "Compatibile",
+    mainstream: "Popolare",
+    color: "Colore",
+    colorNone: "Nessun colore",
+    colorGreen: "Verde",
+    colorYellow: "Giallo",
+    colorOrange: "Arancione",
+    colorRed: "Rosso",
+    colorBlue: "Blu",
+    colorPurple: "Viola",
+    colorCustom: "Colore personalizzato",
+    cancelConnecting: "Annulla connessione",
+    connectCancelled: "Connessione annullata",
+    kafkaKerberosPrincipal: "Principal",
+    kafkaKerberosKeytab: "Keytab",
+    kafkaKerberosServiceName: "Nome del servizio",
+    kafkaKerberosKrb5Conf: "krb5.conf",
+    kafkaKerberosPrincipalRequired: "Kafka Kerberos principal non può essere vuoto",
+    kafkaKerberosKeytabRequired: "Il percorso del keytab Kafka Kerberos non può essere vuoto",
+    kafkaKerberosKeytabBrowse: "Scegli Keytab",
+    kafkaKerberosKrb5ConfBrowse: "Scegli krb5.conf",
+    kafkaKerberosKeytabPlaceholder: "Percorso sulla macchina DBX Agent, ad esempio /etc/security/keytabs/user.keytab",
+    kafkaKerberosKrb5ConfPlaceholder: "Opzionale, percorso sulla macchina DBX Agent, ad esempio /etc/krb5.conf",
+    kafkaKerberosPathHint: "I percorsi di keytab e krb5.conf vengono letti da DBX Agent e devono esistere sulla macchina in cui è in esecuzione DBX Agent; non vengono caricati file dal browser corrente.",
+    kafkaKerberosAuthHint: "Accedi con GSSAPI + keytab. Se il server richiede trasmissione crittografata, imposta Security su SASL_SSL; altrimenti puoi utilizzare Auto o SASL_PLAINTEXT.",
+  },
+  editor: {
+    pressToExecute: "Premi {mod}+Enter per eseguire",
+    pressToSaveSql: "Premi {mod}+S per salvare SQL",
+    queryTimeoutError: "Timeout della query ({seconds}s). Verifica se la connessione al database è integra.",
+    changeQueryTimeout: "Modifica timeout query",
+    connectionMayBeLost: "La connessione potrebbe essere andata perduta. Aggiorna i dati e riprova.",
+    showResultsPane: "Mostra risultati",
+    hideResultsPane: "Nascondi risultati",
+    noDatabase: "Nessun database selezionato",
+    unsavedChangesTitle: "Modifiche non salvate",
+    unsavedChangesMessage: '"{title}" ha modifiche non salvate che andranno perse se chiudi. Salvare prima di chiudere?',
+    unsavedChangesBatchCloseMessage: "Alcune schede che stai chiudendo hanno modifiche non salvate che andranno perse. Salvare prima di continuare?",
+    unsavedChangesBatchCloseMultipleMessage: '{count} schede SQL che stai chiudendo hanno modifiche non salvate. DBX mostra attualmente "{title}". Salvare prima di continuare?',
+    unsavedChangesAppCloseMessage: '"{title}" ha modifiche SQL non salvate che andranno perse se esci da DBX. Salvare prima di uscire?',
+    unsavedChangesAppCloseMultipleMessage: '{count} schede SQL hanno modifiche non salvate. DBX mostra attualmente "{title}". Andranno perse se esci da DBX. Salvare prima di uscire?',
+    unsavedChangesViewList: "Visualizza {count} schede",
+    unsavedChangesListTitle: "Schede non salvate ({count})",
+    discardChanges: "Scarta",
+    discardAllChanges: "Scarta tutto",
+    saveAllChanges: "Salva tutto",
+    selectConnection: "Seleziona connessione",
+    searchConnection: "Cerca connessioni...",
+    selectDatabase: "Seleziona database",
+    selectDatabaseRequired: "Seleziona prima un database",
+    searchDatabase: "Cerca database...",
+    selectSchema: "Seleziona schema",
+    searchSchema: "Cerca schemi...",
+    setDefaultDatabase: "Imposta Predefinito",
+    defaultDatabase: "Predefinito",
+    clearDatabase: "Cancella database",
+    exPasteNoValues: "Gli appunti non contengono valori per una condizione IN",
+    exPasteNotList: "Nessun elenco di più valori convertibile rilevato",
+    exPasteTooLarge: "Il contenuto degli appunti è troppo grande. Massimo {limit} caratteri.",
+    exPasteTooManyValues: "Troppi valori. Massimo {limit}.",
+    exPasteClipboardReadFailed: "Impossibile leggere gli appunti: {message}",
+    exPastePasted: "Incollati {count} valori per la condizione IN",
+    completion: {
+      nullValue: "Valore NULL",
+      isNull: "Verifica se NULL",
+      isNotNull: "Verifica se non NULL",
+      stringLiteral: "Costante stringa",
+      numericLiteral: "Costante numerica",
+      booleanValue: "Valore booleano",
+      starExpansionColumns: "{count} colonne",
+      functionDescriptions: {
+        COUNT: "Restituisce il numero di righe",
+        SUM: "Restituisce la somma di una colonna numerica",
+        AVG: "Restituisce la media di una colonna numerica",
+        MIN: "Restituisce il valore minimo",
+        MAX: "Restituisce il valore massimo",
+        GROUP_CONCAT: "Concatena i valori del gruppo in una stringa",
+        STRING_AGG: "Concatena le stringhe del gruppo",
+        CONCAT: "Concatena più stringhe",
+        CONCAT_WS: "Concatena le stringhe con un separatore",
+        SUBSTRING: "Estrae una sottostringa",
+        REPLACE: "Sostituisce il contenuto in una stringa",
+        TRIM: "Rimuove gli spazi iniziali e finali",
+        UPPER: "Converte in maiuscolo",
+        LOWER: "Converte in minuscolo",
+        LENGTH: "Restituisce la lunghezza della stringa",
+        REGEXP_REPLACE: "Sostituisce utilizzando un'espressione regolare",
+        DATE_FORMAT: "Formatta una data con il formato specificato",
+        DATEDIFF: "Calcola la differenza tra due date",
+        DATE_ADD: "Aggiunge un intervallo a una data",
+        DATE_SUB: "Sottrae un intervallo da una data",
+        EXTRACT: "Estrae una parte di data",
+        NOW: "Restituisce la data e l'ora correnti",
+        ROUND: "Arrotonda alla quantità specificata di decimali",
+        FLOOR: "Arrotonda per difetto",
+        CEIL: "Arrotonda per eccesso",
+        ABS: "Restituisce il valore assoluto",
+        MOD: "Restituisce il resto della divisione",
+        COALESCE: "Restituisce il primo argomento non NULL",
+        IFNULL: "Restituisce un valore sostitutivo se NULL",
+        NULLIF: "Restituisce NULL se gli argomenti sono uguali",
+        CAST: "Converte un'espressione in un tipo di destinazione",
+        JSON_EXTRACT: "Estrae un valore da JSON",
+        JSON_VALUE: "Estrae un valore scalare da JSON",
+        JSON_OBJECT: "Crea un oggetto JSON",
+        JSON_ARRAY: "Crea un array JSON",
+      },
+    },
+    contextMenu: {
+      executeSelection: "Esegui selezione",
+      executeCurrent: "Esegui SQL",
+      copySelection: "Copia selezione",
+      sendToAi: "Invia ad AI",
+      uppercaseSelection: "Converti in maiuscolo",
+      lowercaseSelection: "Converti in minuscolo",
+      selectAll: "Seleziona tutto",
+    },
+    search: {
+      find: "Trova",
+      replace: "Sostituisci",
+      replaceAll: "Sostituisci Tutto",
+      caseSensitive: "Maiuscole/Minuscole",
+      regex: "Espressione regolare",
+      collapseReplace: "Comprimi sostituzione",
+      expandReplace: "Espandi sostituzione",
+      prevMatch: "Precedente (Shift+Enter)",
+      nextMatch: "Successivo (Enter)",
+      close: "Chiudi (Esc)",
+      noResults: "Nessun risultato",
+    },
+    executionPicker: {
+      title: "Execution Target",
+      currentStatement: "Current SQL",
+      allStatements: "All SQL",
+      currentCommand: "Current command",
+      allCommands: "All commands",
+    },
+  },
+  tabs: {
+    sql: "SQL",
+    table: "Tabella",
+    tableData: "Dati Tabella",
+    redis: "Redis",
+    etcd: "etcd",
+    zookeeper: "ZooKeeper",
+    mongo: "Mongo",
+    vector: "Vector",
+    objects: "Oggetti",
+    users: "Utenti e Privilegi",
+    executionSummary: "Riepilogo",
+    tooltipTitle: "Titolo:",
+    tooltipConnection: "Connessione:",
+    tooltipDatabase: "Database:",
+    tooltipTable: "Tabella:",
+    tooltipCollection: "Collezione:",
+    tooltipSchema: "Schema:",
+    resultN: "Risultato {n}",
+    runN: "Esegui {n}",
+    resultRuns: "Esecuzioni risultati",
+    removeRun: "Rimuovi esecuzione {n}",
+    autoKeepResults: "Mantieni automaticamente i risultati",
+    autoKeepResultsEnabled: "Mantieni risultati abilitato",
+    autoKeepResultsDisabled: "Mantieni risultati disabilitato",
+    autoRefresh: "Aggiorna risultati automaticamente",
+    autoRefreshShort: "Auto",
+    autoRefreshEvery: "Aggiorna ogni {seconds} s",
+    startAutoRefresh: "Avvia aggiornamento automatico",
+    stopAutoRefresh: "Ferma aggiornamento automatico",
+    missingResultRun: "Questo risultato non e piu disponibile",
+    exportResultArchive: "Salva Archivio Risultati",
+    importResultArchive: "Importa Archivio Risultati",
+    importedResultArchive: "Risultati importati",
+    resultArchiveExported: "Risultati esportati",
+    resultArchiveImported: "Risultati importati",
+    resultArchiveUnavailable: "Nessun risultato salvato disponibile per l'esportazione",
+    resultArchiveImportInvalid: "Questo archivio risultati non puo essere aperto",
+    resultArchiveExportFailed: "Esportazione risultati non riuscita: {message}",
+    resultArchiveImportFailed: "Importazione risultati non riuscita: {message}",
+    scrollLeft: "Scorri schede a sinistra",
+    scrollRight: "Scorri schede a destra",
+    openTabs: "Schede aperte",
+    fixedTabs: "Schede bloccate",
+    openDataTabs: "Tabelle aperte",
+    gridfs: "GridFS",
+  },
+  executionSummary: {
+    empty: "Nessun riepilogo",
+    executing: "Esecuzione...",
+    statement: "Istruzione",
+    type: "Tipo",
+    rows: "Righe",
+    affected: "Interessate",
+    time: "Tempo",
+    success: "Riuscita",
+    error: "Errore",
+    returnedTable: "Restituita una tabella con {count} colonne",
+    noTable: "Nessuna tabella restituita",
+  },
+  chart: {
+    title: "Grafico",
+    type: "Tipo",
+    line: "Linea",
+    bar: "Barre",
+    pie: "Torta",
+    noNumericData: "Nessun dato numerico disponibile per il grafico",
+  },
+  grid: {
+    rows: "{count} righe",
+    totalRows: "Totale {count} righe",
+    totalRowCount: "({count} in totale)",
+    totalRowCountLoading: "(conteggio...)",
+    loadingMore: "Caricamento altri dati...",
+    allLoaded: "tutto caricato",
+    calculateTotalRows: "Conta righe totali",
+    calculateTotalRowsInline: "(conta righe totali)",
+    calculateTotalRowsFailed: "Conteggio non riuscito: {message}",
+    rowsAffected: "{count} righe interessate",
+    querySuccess: "Query eseguita con successo",
+    noRows: "Nessun dato",
+    noRowsDescription: "Questo set di risultati non contiene record.",
+    noSearchResults: "Nessuna corrispondenza",
+    noSearchResultsDescription: "Prova con un'altra parola chiave.",
+    noFilteredRows: "Nessuna riga corrisponde al filtro",
+    noFilteredRowsDescription: "Regola il testo di ricerca o il filtro dello stato della riga.",
+    copy: "Copia",
+    mongoJsonPreview: "Anteprima JSON",
+    mongoJsonPreviewEmpty: "Seleziona un documento MongoDB da visualizzare.",
+    copyJson: "Copia JSON",
+    copyDdl: "Copia DDL",
+    copyCell: "Copia Cella",
+    copyRow: "Copia Riga (JSON)",
+    copyColumnJson: "Copia Colonna (JSON)",
+    copyColumnNames: "Copia Nomi Colonne",
+    copyRowInsert: "Copia come INSERT",
+    copyRowInsertWithoutPrimaryKeys: "Copia come INSERT senza Chiavi Primarie",
+    copyRowUpdate: "Copia come UPDATE",
+    copyAll: "Copia Tutto (TSV)",
+    selection: "Selezione",
+    selectionSum: "SUM: {value}",
+    selectionCells: "{count} celle",
+    copySelectionTsv: "Copia Selezione (TSV)",
+    copySelectionTsvWithHeaders: "Copia Selezione con Intestazioni (TSV)",
+    copySelectionCsv: "Copia Selezione (CSV)",
+    copySelectionJson: "Copia Selezione (JSON)",
+    copySelectionSql: "Copia Selezione come elenco SQL IN",
+    clearSelection: "Cancella Selezione",
+    export: "Esporta",
+    exportCsv: "Esporta CSV",
+    exportXlsx: "Esporta XLSX",
+    exportCurrentPageCsv: "Esporta pagina corrente come CSV",
+    exportCurrentPageXlsx: "Esporta pagina corrente come XLSX",
+    exportCurrentPageJson: "Esporta pagina corrente come JSON",
+    exportCurrentPageMarkdown: "Esporta pagina corrente come Markdown",
+    exportCurrentPageSql: "Esporta pagina corrente come SQL INSERT",
+    exportCurrentResultCsv: "Esporta tutti i dati del risultato corrente come CSV",
+    exportCurrentResultXlsx: "Esporta tutti i dati del risultato corrente come XLSX",
+    exportCurrentResultJson: "Esporta tutti i dati del risultato corrente come JSON",
+    exportCurrentResultMarkdown: "Esporta tutti i dati del risultato corrente come Markdown",
+    exportCurrentResultSql: "Esporta tutti i dati del risultato corrente come SQL INSERT",
+    exportAllResultsXlsx: "Esporta tutti i set di risultati di questa esecuzione come XLSX",
+    exportJson: "Esporta JSON",
+    exportMarkdown: "Esporta Markdown",
+    exportSql: "Esporta SQL INSERT",
+    exportSelectedRowsCsv: "Esporta Righe Selezionate come CSV",
+    exportSelectedRowsXlsx: "Esporta Righe Selezionate come XLSX",
+    exportSelectedRowsJson: "Esporta Righe Selezionate come JSON",
+    exportSelectedRowsMarkdown: "Esporta Righe Selezionate come Markdown",
+    exportSelectedRowsSql: "Esporta Righe Selezionate come SQL INSERT",
+    exported: "Esportato",
+    exportFailed: "Esportazione non riuscita: {message}",
+    copied: "Copiato",
+    copyFailed: "Copia non riuscita: {message}",
+    previewSqlEmpty: "Nessuna modifica SQL in sospeso da visualizzare",
+    renderMode: "Modalità rendering",
+    domRenderMode: "DOM",
+    canvasRenderMode: "Canvas",
+    renderModeHint: "Passa dal rendering Canvas al grid di fallback DOM.",
+    tableFontSize: "Dimensione font tabella",
+    filter: "Filtra",
+    conditionHistoryEmpty: "Nessuna cronologia ancora",
+    conditionHistoryNoMatches: "Nessuna corrispondenza nella cronologia",
+    filterBuilder: "Filtri",
+    filterBuilderTitle: "Filtri",
+    filterBuilderHint: "Crea condizioni visive e combinale con l'input WHERE.",
+    filterBuilderSummary: "{count} regole",
+    filterBuilderAddRule: "Aggiungi regola",
+    filterBuilderColumn: "Colonna",
+    filterBuilderValue: "Valore",
+    filterBuilderNoValue: "Nessun valore richiesto",
+    filterBuilderEmpty: "Aggiungi una regola per iniziare a filtrare le righe.",
+    resetFilterBuilder: "Reimposta regole",
+    filterBuilderEquals: "Uguale a",
+    filterBuilderNotEquals: "Diverso da",
+    filterBuilderContains: "Contiene",
+    filterBuilderNotContains: "Non contiene",
+    filterBuilderGreaterThan: "Maggiore di",
+    filterBuilderLessThan: "Minore di",
+    filterBuilderIsNull: "È NULL",
+    filterBuilderIsNotNull: "Non è NULL",
+    columnActions: "Azioni colonna",
+    localFilter: "Filtro valori locale",
+    localFilterFor: "Valori locali per '{column}'",
+    databaseValueFilter: "Filtro valori database",
+    databaseValueFilterFor: "Valori database per '{column}'",
+    columnFormatter: "Formattatore colonna",
+    columnFormatterFor: "Formattatore per '{column}'",
+    columnFormatterHint: "Formatta solo la visualizzazione; i valori effettivi rimangono invariati.",
+    formatterType: "Tipo",
+    formatterDatetime: "Timestamp Unix",
+    formatterJsonPath: "Percorso JSON",
+    formatterMask: "Maschera testo",
+    formatterCustomTemplate: "Modello personalizzato",
+    formatterTimestampUnit: "Unità timestamp",
+    formatterUnitAuto: "Auto",
+    formatterUnitSeconds: "Secondi",
+    formatterUnitMilliseconds: "Millisecondi",
+    formatterDatetimePattern: "Formato data e orario",
+    formatterDatetimePatternPlaceholder: "Seleziona o inserisci un formato data e orario",
+    formatterDatetimePatternEmpty: "Formato ISO8601 predefinito",
+    formatterJsonPathInput: "Percorso JSON",
+    formatterMaskPrefix: "Prefisso visibile",
+    formatterMaskSuffix: "Suffisso visibile",
+    formatterSavedCustom: "Modelli salvati",
+    formatterNewCustom: "Nuovo modello",
+    formatterCustomName: "Nome modello",
+    formatterCustomNamePlaceholder: "Esempio: Etichetta utente",
+    formatterCustomTemplateInput: "Modello",
+    formatterCustomTemplateHint: "Variabili disponibili: ${value}, ${upper}, ${lower}, ${length}. Assegna un nome per salvarlo nell'elenco.",
+    formatterPreview: "Anteprima",
+    saveFormatter: "Salva",
+    clearFormatter: "Cancella",
+    searchValues: "Cerca valori...",
+    loadingValues: "Caricamento valori...",
+    serverValuesLimited: "Mostra i primi {count} valori",
+    filterTypedValue: "Usa '{value}'",
+    value: "Valore",
+    count: "Conteggio",
+    applyFilter: "Applica Filtro",
+    clearLocalFilters: "Cancella filtri valori locali",
+    clearLocalFiltersShort: "Cancella locali",
+    localFiltersActive: "{count} filtri valori locali",
+    localFilterMoreValues: " +{count} altri",
+    columnVisibility: "Colonne",
+    columnVisibilityHint: "Almeno una colonna deve rimanere visibile.",
+    searchColumns: "Cerca colonne...",
+    dragColumnToReorder: "Trascina l'intestazione per riordinare",
+    invertColumnVisibility: "Inverti",
+    resetColumnOrder: "Reimposta ordine",
+    showAllColumns: "Mostra tutte",
+    viewOptions: "Opzioni visualizzazione",
+    hideNullColumns: "Nascondi NULL",
+    hideNullColumnsHint: "Nascondi le colonne i cui valori sono tutti NULL nel risultato corrente.",
+    moreValues: "altri {count} valori, continua a digitare per restringere i risultati",
+    filterByValue: "Filtra per Questo Valore",
+    filterExcludeValue: "Escludi Questo Valore",
+    filterLike: "Contiene il Valore",
+    filterNotLike: "Non Contiene il Valore",
+    filterLessThan: "Minore del Valore",
+    filterGreaterThan: "Maggiore del Valore",
+    filterIsNull: "Mostra Valori NULL",
+    filterIsNotNull: "Mostra Valori Non-NULL",
+    clearFilter: "Cancella Filtro",
+    sort: "Ordina",
+    sortAscending: "Ordina in modo crescente",
+    sortDescending: "Ordina in modo decrescente",
+    sortCurrentPageAscending: "Ordina pagina corrente crescente",
+    sortCurrentPageDescending: "Ordina pagina corrente decrescente",
+    sortDatabaseAscending: "Ordina database crescente",
+    sortDatabaseDescending: "Ordina database decrescente",
+    clearSort: "Rimuovi Ordinamento",
+    pasted: "Incollato!",
+    search: "Cerca...",
+    searchOrWhere: "Cerca o inserisci una clausola WHERE...",
+    applyWhere: "Applica WHERE",
+    filterRows: "Filtra righe",
+    filterAllRows: "Tutte le righe",
+    filterChangedRows: "Modificate",
+    page: "Pagina {page}",
+    rowsPerPage: "Righe per pagina",
+    customRowsPerPage: "Righe personalizzate",
+    applyPageSize: "Applica",
+    save: "Salva",
+    discard: "Scarta",
+    dismiss: "Ignora",
+    addRow: "Aggiungi Riga",
+    quickEntryDraftPlaceholder: "Nuova",
+    cloneRow: "Clona come Nuova Riga",
+    deleteRow: "Elimina Riga",
+    deleteRows: "Elimina {count} Righe",
+    cloneRows: "Clona {count} come Nuove Righe",
+    restoreRows: "Ripristina {count} Righe",
+    copyRows: "Copia {count} Righe (JSON)",
+    copySelectedRowsTsv: "Copia {count} Righe (TSV)",
+    copySelectedRowsTsvWithHeaders: "Copia {count} Righe con Intestazioni (TSV)",
+    copySelectedRowTsv: "Copia 1 Riga (TSV)",
+    copySelectedRowTsvWithHeaders: "Copia 1 Riga con Intestazioni (TSV)",
+    copyColumnsJson: "Copia {count} Colonne (JSON)",
+    copyRowsInsert: "Copia {count} Righe come INSERT",
+    copyRowsInsertMerged: "Copia {count} Righe come INSERT (unito)",
+    copyRowsInsertRowByRow: "Copia {count} Righe come INSERT (riga per riga)",
+    copyRowsInsertWithoutPrimaryKeys: "Copia {count} Righe come INSERT senza Chiavi Primarie",
+    copyRowsInsertWithoutPrimaryKeysMerged: "Copia {count} Righe come INSERT senza Chiavi Primarie (unito)",
+    copyRowsInsertWithoutPrimaryKeysRowByRow: "Copia {count} Righe come INSERT senza Chiavi Primarie (riga per riga)",
+    copyRowsUpdate: "Copia {count} Righe come UPDATE",
+    selectedRows: "{count} righe selezionate",
+    restoreRow: "Ripristina Riga",
+    statusClean: "Pulito",
+    statusNew: "Nuovi Elementi",
+    statusEdited: "Elementi Aggiornati",
+    statusDeleted: "Elementi Eliminati",
+    pendingChanges: "{count} in sospeso",
+    selectedCells: "{count} selezionate",
+    bulkEditSelection: "Modifica di Massa Selezione",
+    bulkEditTitle: "Modifica di Massa Selezione",
+    bulkEditDescription: "Imposta le {count} celle selezionate su questo valore.",
+    bulkEditValuePlaceholder: "Valore, o NULL",
+    applyBulkEdit: "Applica",
+    cellDetails: "Dettagli Cella",
+    cellDetailLayoutBottom: "Sposta in Basso",
+    cellDetailLayoutRight: "Sposta a Destra",
+    openCellDetailsDialog: "Apri Dettagli Cella",
+    rowDetails: "Dettagli Riga",
+    rowDetailsFor: "Dettagli Riga {row}",
+    openRowDetailsDialog: "Apri Dettagli Riga",
+    openColumnDetailsDialog: "Apri Dettagli Colonna",
+    columnDetailsFor: "Dettagli Colonna {column}",
+    columnsCount: "{count} colonne",
+    rowCount: "Righe",
+    rowsCount: "{count} righe",
+    fieldIndex: "N.",
+    cellValue: "Valore",
+    valueEditor: "Editor dei Valori",
+    hexViewer: "Visualizzatore Hex",
+    hexViewerByteCount: "{count} byte",
+    hexViewerOffset: "Offset",
+    hexViewerHex: "Hex",
+    hexViewerAscii: "ASCII",
+    hexViewerEmpty: "Nessun byte binario da visualizzare.",
+    imagePreview: "Anteprima Immagine",
+    imageLoadFailed: "Caricamento immagine non riuscito",
+    geometryPreview: "Anteprima Geometria",
+    layerPreview: "Anteprima Layer",
+    zoomIn: "Ingrandisci",
+    zoomOut: "Rimpicciolisci",
+    fitImage: "Adatta alla Vista",
+    openImage: "Apri Immagine",
+    columnName: "Colonna",
+    columnType: "Tipo",
+    columnComment: "Commento",
+    rowNumber: "Riga",
+    valueLength: "Lunghezza",
+    nullValue: "NULL",
+    noComment: "Nessun commento",
+    formattedJson: "JSON Formattato",
+    formattedValue: "Valore Formattato",
+    detailSearchPlaceholder: "Cerca campo o valore…",
+    detailSearchNoMatch: "Nessun risultato",
+    rawValue: "Valore Grezzo",
+    largeValuePreviewHint: "Anteprima dei primi {count} caratteri. La copia utilizzerà comunque il valore completo.",
+    copyValue: "Copia Valore",
+    downloadBinaryValue: "Scarica Valore",
+    downloadSaved: "Salvato in {path}",
+    downloadStarted: "Download avviato: {fileName}",
+    binaryDownload: {
+      binary: "Binario grezzo",
+      utf8: "Testo decodificato (UTF-8)",
+      gbk: "Testo decodificato (GBK)",
+    },
+    copyRowTsv: "Copia Riga (TSV)",
+    copyColumnValues: "Copia Colonna (JSON)",
+    copyColumnTsv: "Copia Colonna (TSV)",
+    editValue: "Modifica Valore",
+    formatJson: "Formatta JSON",
+    compactJson: "Compatta JSON",
+    formattedJsonEditWarning: "Stai modificando JSON formattato. Salvando verrà scritto come JSON, quindi la formattazione originale potrebbe cambiare.",
+    setNull: "Imposta NULL",
+    restoreOriginalValue: "Ripristina Originale",
+    copyColumnName: "Copia Nome Colonna",
+    copyAlterColumnSql: "Copia come SQL ALTER",
+    alterSqlCopied: "SQL ALTER copiato negli appunti",
+    alterSqlCopiedWithWarnings: "SQL ALTER copiato negli appunti ({count} avviso/i)",
+    noAlterSqlAvailable: "Nessun SQL ALTER disponibile per questa colonna",
+    copyAlterSqlFailed: "Copia non riuscita: {message}",
+    copySqlCondition: "Copia Condizione SQL",
+    transpose: "Traspone Riga",
+    transposeMultiRowToggle: "Più righe",
+    transposeSingleRow: "Riga corrente",
+    transposeMultiRow: "Più righe",
+    transposeMultiRowHint: "Quando è attiva, la vista trasposta mostra più righe. Quando è disattiva, mostra solo la riga corrente.",
+    rowsPerPageShort: " righe",
+    columnDetails: "Dettagli Colonna",
+    tableInfo: "Informazioni Tabella",
+    tableInfoColumns: "Colonne",
+    tableInfoIndexes: "Indici",
+    tableInfoForeignKeys: "Chiavi Esterne",
+    tableInfoTriggers: "Trigger",
+    tableInfoNullable: "Nullabile",
+    tableInfoEmpty: "Nessun metadato",
+    tableInfoSearch: "Cerca...",
+    tableInfoNoResults: "Nessun risultato",
+    goToColumn: "Vai alla colonna",
+    columnWidth: "Larghezza colonna",
+    columnWidthCompact: "Compatto",
+    columnWidthStandard: "Standard",
+    columnWidthComfortable: "Ampio",
+    searchColumn: "Cerca colonna/commento...",
+    noColumnsFound: "Nessuna colonna trovata",
+    queryError: "Errore Query",
+    dataUnavailable: "I dati della tabella devono essere ricaricati.",
+    dataUnavailableHintPrefix: "Premi ",
+    dataUnavailableHintSuffix: " o fai clic su Aggiorna qui sotto per ricaricare.",
+    refresh: "Aggiorna",
+    undoChange: "Annulla modifica",
+    redoChange: "Ripeti modifica",
+    commit: "Commit",
+    rollback: "Rollback",
+    transactionSaveHint: "Applica {count} modifica/he in sospeso in una transazione.",
+    nonTransactionalSaveHint: "Salva {count} modifica/he in sospeso una ad una. In caso di errore, le modifiche salvate in precedenza non saranno annullate.",
+    keylessEditWarning: "Nessuna chiave primaria",
+    keylessEditWarningHint: "Questa tabella non ha chiavi primarie. Gli aggiornamenti e le eliminazioni utilizzano tutti i valori originali delle righe nella clausola WHERE; le righe duplicate esatte potrebbero essere influenzate contemporaneamente.",
+    queryEditReadOnly: "Risultato in sola lettura",
+    queryEditUnsupported: {
+      "not-select": "Only SELECT query results can be edited directly.",
+      cte: "Le query con WITH/CTE non sono ancora modificabili. Usa una semplice SELECT a tabella singola.",
+      "set-operation": "UNION, INTERSECT, or EXCEPT results cannot be mapped safely back to source rows.",
+      aggregation: "I risultati di DISTINCT, GROUP BY, HAVING e aggregazioni non possono essere modificati direttamente.",
+      "external-source": "External files and table-function results cannot be written back directly. Import them into a database table before editing.",
+      "complex-source": "DBX could not identify exactly one safe writeback target table for this result.",
+      "computed-columns": "Computed expressions or function results cannot be written back. Select raw column names instead.",
+      "no-table": "No editable source table was detected.",
+      "no-primary-key": "The target table has no primary key, so rows cannot be updated or deleted safely.",
+      "primary-key-not-returned": "The result is missing the raw primary key column. Include it by its original column name.",
+      "aliased-columns": "Result columns use aliases or expressions. Select editable columns by their original names.",
+      "metadata-unavailable": "DBX could not load table metadata, so result editing is disabled.",
+    },
+    sortUnsupported: "Questo SQL non supporta l'ordinamento sull'intero risultato. Riprova con una query SELECT semplice.",
+    truncatedHint: "Risultati troncati a {count} righe. Usa la paginazione a piè di pagina o regola le righe per pagina.",
+    filterBuilderSearchColumns: "Cerca campi...",
+    filterBuilderNoMatchingColumns: "Nessun campo corrispondente",
+  },
+  exportProgress: {
+    title: "Esportazione Dati Tabella",
+    fetching: "Recupero dati dal database...",
+    writing: "Scrittura su file...",
+    done: "Esportazione completata!",
+    error: "Esportazione non riuscita",
+    cancelled: "Esportazione annullata.",
+    rowsCount: "{exported} / {total} righe",
+    rowsExported: "{count} righe esportate",
+    rowsShort: "righe",
+    cancel: "Annulla",
+    close: "Chiudi",
+    tooltip: "Stato Esportazione",
+    failedTooltip: "{count} attività in background non riuscita | {count} attività in background non riuscite",
+    popoverTitle: "Esportazioni",
+    noTasks: "Nessuna esportazione",
+    clearFinished: "Cancella completate",
+    showMore: "Mostra altri {count}",
+    showLess: "Mostra meno",
+    delete: "Rimuovi",
+    databaseExportTitle: "Backup database: {name}",
+    sqlFileTitle: "File SQL: {name}",
+    dataTransferTitle: "Trasferimento dati: {name}",
+    objectsCount: "{current} / {total} oggetti",
+    tablesCount: "{current} / {total} tabelle",
+    statementsCount: "{done} riuscite, {failed} non riuscite",
+  },
+  welcome: {
+    title: "Area di Lavoro Database",
+    subtitle: "Scegli una connessione a sinistra per esplorare lo schema, oppure apri direttamente una scheda query.",
+    connections: "Connessioni",
+    connected: "Connesso",
+    databaseTypes: "Tipi Database",
+    quickConnections: "Avvio Rapido",
+    quickConnectionsHint: "Fai clic su una connessione per aprire una scheda query.",
+    shortcuts: "Scorciatoie",
+    shortcutsHint: "Avvia la prossima azione da qui.",
+    sqlHistory: "Cronologia Query",
+    sqlHistoryEmpty: "Nessun record nella Libreria SQL",
+    sqlHistoryOpenCount: "Aperto {count} volte",
+    unknownConnection: "Connessione sconosciuta",
+    tip: "Puoi anche espandere le connessioni a sinistra e fare clic con il tasto destro su database o tabelle per altre azioni.",
+    tipSidebar: "Fai clic su una tabella a sinistra per visualizzarne i dati",
+    tipExecute: "per eseguire la query",
+    fileOpened: "Aperto {name}",
+    mcpTitle: "Integrazione Agente AI",
+    mcpDescription: "Oltre all'assistente AI integrato, puoi utilizzare Claude Code, Cursor e altri agenti di sviluppo per interrogare i tuoi database tramite MCP.",
+    mcpLearnMore: "Scopri di più",
+  },
+  common: {
+    language: "Lingua",
+    loading: "Caricamento...",
+    stopping: "Interruzione...",
+    close: "Chiudi",
+    cancel: "Annulla",
+    save: "Salva",
+    copy: "Copia",
+    import: "Importa",
+    remove: "Rimuovi",
+    retry: "Riprova",
+    more: "Altro",
+    decrease: "Riduci",
+    increase: "Aumenta",
+    showPassword: "Mostra password",
+    hidePassword: "Nascondi password",
+    done: "Fatto",
+    connection: "Connessione",
+    database: "Database",
+    table: "Tabella",
+    view: "Vista",
+    materializedView: "Vista Materializzata",
+    procedure: "Procedura",
+    function: "Funzione",
+    sequence: "Sequenza",
+    package: "Pacchetto",
+    packageBody: "Corpo Pacchetto",
+    noResults: "Nessun risultato",
+  },
+  quickOpen: {
+    placeholder: "Cerca connessioni, database, tabelle e altri oggetti...",
+    emptyPlaceholder: "Inizia a digitare per cercare",
+    noResults: "Nessun risultato trovato",
+    results: "risultati",
+    navigate: "Naviga",
+    select: "Seleziona",
+    close: "Chiudi",
+  },
+  explain: {
+    title: "Piano di Spiegazione",
+    standardTable: "Tabella",
+    tree: "Albero",
+    summary: "Riepilogo",
+    running: "Lettura del piano di spiegazione...",
+    empty: "Nessun piano di spiegazione",
+    nodeCount: "{count} nodi",
+    node: "Nodo",
+    relation: "Tabella",
+    index: "Indice",
+    cost: "Costo",
+    rows: "Righe",
+    details: "Dettagli",
+    unsupported: "Il piano di spiegazione non è ancora supportato per questo database",
+    emptySql: "Nessun SQL da spiegare",
+    unsafe: "Questa prima versione spiega solo istruzioni SELECT / WITH / TABLE / VALUES",
+  },
+  lineage: {
+    title: "Lineage dei Campi",
+    open: "Visualizza Lineage dei Campi",
+    loading: "Lettura metadati in corso {done}/{total}",
+    empty: "Nessun lineage correlato trovato",
+    noFiltered: "Nessun risultato corrisponde ai filtri correnti",
+    targetField: "Campo Corrente",
+    searchPlaceholder: "Cerca tabelle, campi, viste o frammenti SQL...",
+    showing: "Mostrati {shown}/{total} risultati",
+    all: "Tutti",
+    certain: "Sicuro",
+    likely: "Probabile",
+    possible: "Possibile",
+    queryHistory: "Cronologia Query",
+    openTable: "Apri tabella",
+    copy: "Copia nome",
+    copied: "Copiato",
+    kind: {
+      foreignKey: "Chiave Esterna",
+      viewReference: "Vista",
+      historyReference: "Cronologia SQL",
+      sameName: "Stesso Nome",
+    },
+    description: {
+      foreignKeyIncoming: "{target} punta al campo corrente tramite una chiave esterna. Si tratta di una dipendenza verificata.",
+      foreignKeyOutgoing: "Il campo corrente fa riferimento a {target} tramite una chiave esterna. Si tratta di una dipendenza verificata.",
+      viewLikely: "La definizione della vista menziona sia la tabella che il campo di destinazione, indicando solitamente una dipendenza della query.",
+      viewPossible: "La definizione della vista menziona un campo con lo stesso nome ma non la tabella di destinazione, pertanto richiede conferma.",
+      historyLikely: "Un'istruzione SQL della cronologia menziona sia la tabella che il campo di destinazione. Utilizzalo come contesto per l'analisi dell'impatto.",
+      historyPossible: "Un'istruzione SQL della cronologia menziona un campo con lo stesso nome. Potrebbe essere correlata, ma necessita di contesto.",
+      sameName: "Un'altra tabella ha un campo con lo stesso nome. Potrebbe condividere il significato aziendale ma non è una dipendenza verificata del database.",
+    },
+    cancel: "Annulla",
+    refresh: "Analizza di Nuovo",
+  },
+  connectionGroup: {
+    createGroup: "Nuovo Gruppo",
+    groupNamePlaceholder: "Nome gruppo",
+    renameGroup: "Rinomina Gruppo",
+    deleteGroup: "Elimina Gruppo",
+    moveToGroup: "Sposta nel Gruppo",
+    moveToNewGroup: "Sposta in un Nuovo Gruppo",
+    ungrouped: "Non raggruppati",
+    newGroup: "Nuovo Gruppo...",
+    newGroupDefault: "Nuovo Gruppo",
+    deleteGroupConfirmTitle: "Elimina Gruppo",
+    deleteGroupConfirmMessage: 'Eliminare il gruppo "{name}"? Le connessioni al suo interno verranno spostate al livello principale.',
+    selectConnection: "Seleziona connessione",
+    deselectConnection: "Deseleziona connessione",
+    selectAllConnections: "Seleziona tutte le connessioni",
+    deselectAllConnections: "Deseleziona tutte le connessioni",
+    exitMultiSelect: "Esci dalla selezione multipla",
+  },
+  databaseSearch: {
+    title: "Cerca nel Database",
+    open: "Cerca nel Database",
+    keyword: "Parola chiave",
+    keywordPlaceholder: "Inserisci un ID utente, un'email, un numero d'ordine...",
+    limitPerTable: "Per tabella",
+    search: "Cerca",
+    searching: "Ricerca in corso",
+    stop: "Interrompi",
+    hint: "Scansiona le tabelle normali nel database o schema corrente. Le colonne binarie vengono saltate e ciascuna tabella è limitata per evitare il caricamento simultaneo di troppi dati.",
+    loadingTables: "Lettura dell'elenco delle tabelle...",
+    progress: "Scansionate {done}/{total} tabelle",
+    resultCount: "{count} corrispondenze",
+    limitedTables: "Rilevato schema di grandi dimensioni; vengono scansionate solo le prime {count} tabelle",
+    results: "Risultati",
+    openResult: "Apri",
+    waiting: "In attesa di corrispondenze...",
+    noResults: "Nessuna corrispondenza finora",
+    errors: "Alcune tabelle non sono riuscite",
+  },
+  configExport: {
+    passphraseTitle: "Crittografa ed Esporta",
+    passphraseImportTitle: "Decrittografa e Importa",
+    passphraseExportHint: "Per includere le password di connessione nell'esportazione, imposta una passphrase per la crittografia. Avrai bisogno della stessa passphrase per importare.",
+    passphraseImportHint: "Questo file è crittografato. Inserisci la passphrase per decrittografarlo e importarlo.",
+    passphrase: "Passphrase",
+    passphraseConfirm: "Conferma Passphrase",
+    passphrasePlaceholder: "Inserisci passphrase",
+    passphraseConfirmPlaceholder: "Re-inserisci passphrase",
+    passphraseRequired: "La passphrase è richiesta",
+    passphraseMismatch: "Le passphrase non corrispondono",
+    passphraseTooShort: "La passphrase deve essere di almeno 4 caratteri",
+    exportEncrypted: "Esporta",
+    decryptImport: "Decrittografa e Importa",
+    wrongPassphrase: "Passphrase errata o file corrotto",
+    cryptoUnavailable: "L'importazione cifrata non è disponibile in questo contesto del browser. Usa HTTPS, localhost o DBX Desktop.",
+    exportSuccess: "Connessioni esportate con successo",
+    importSuccess: "Importata/e {count} connessione/i",
+    importNavicatSuccess: "Importata/e {count} connessione/i Navicat. Inserisci le password mancanti prima di testare la connessione.",
+    importDatagripSuccess: "Importate {count} connessione/i DataGrip, riempite {filled} password dalla Keychain.",
+    importDbeaverSuccess: "Importata/e {count} connessione/i DBeaver. Inserisci le password mancanti prima di testare la connessione.",
+    importNone: "Nessuna nuova connessione da importare",
+    importLayoutConfirm: "Il file importato contiene gruppi di connessioni. Vuoi applicarli?",
+    importLayoutTitle: "Importa Gruppi",
+    importLayoutApply: "Applica",
+  },
+  ai: {
+    placeholder: "Descrivi la tua query in linguaggio naturale...",
+    settings: "Impostazioni AI",
+    noConfig: "L'AI non è configurata. Configura il tuo provider AI in Impostazioni > AI.",
+    provider: "Provider",
+    providerStatusActive: "Attivo",
+    providerStatusConfigured: "Configurato",
+    switchProvider: "Cambia provider",
+    model: "Modello",
+    browseModels: "Sfoglia modelli",
+    refreshModels: "Aggiorna modelli",
+    loadingModels: "Caricamento modelli...",
+    searchModels: "Cerca modelli",
+    noModels: "Nessun modello caricato",
+    modelListHint: "Fai clic su aggiorna per caricare i modelli dal provider.",
+    modelListUnsupported: "Questo provider non supporta il recupero di un elenco di modelli.",
+    modelListEndpointRequired: "Inserisci un endpoint prima di caricare i modelli.",
+    modelListApiKeyRequired: "Inserisci una chiave API prima di caricare i modelli.",
+    run: "Esegui",
+    readingSchema: "Lettura schema",
+    noConnection: "Nessuna connessione disponibile per questa scheda",
+    noSql: "Nessun SQL da elaborare",
+    sqlPreview: "Anteprima SQL",
+    copySql: "Copia SQL",
+    copyCode: "Copia Codice",
+    executeSql: "Esegui SQL",
+    tempRunSql: "Esegui senza modificare",
+    copyAll: "Copia Tutto",
+    copied: "Copiato",
+    copyTestResult: "Copia risultato test",
+    replace: "Sostituisci Editor",
+    append: "Accoda all'Editor",
+    apply: "Applica all'Editor",
+    clear: "Cancella Chat",
+    welcome: "Dimmi cosa vorresti interrogare e io scriverò il codice SQL",
+    newChat: "Nuova Chat",
+    thinking: "Riflessione...",
+    reasoningProcess: "Processo di riflessione",
+    stopGenerating: "Interrompi generazione",
+    scrollToBottom: "Torna in fondo",
+    tableMentionEmpty: "Nessuna tabella o file SQL corrispondente",
+    tableMentionPlaceholderHint: "Digita {'@'} per menzionare tabelle o file SQL per il contesto",
+    tableMentionTypes: {
+      table: "Tabella",
+      view: "Vista",
+      systemTable: "Tabella di sistema",
+      temporaryTable: "Tabella temporanea",
+    },
+    modes: {
+      ask: "Chiedi",
+      agent: "Agente",
+    },
+    modeHints: {
+      ask: "Genera SQL e spiegazioni senza eseguirli automaticamente",
+      agent: "Esegui automaticamente le query sicure quando possibile",
+    },
+    fixWithAi: "Correggi con AI",
+    truncated: "Contesto troncato",
+    contextSummary: "{database} · {tables} tabelle",
+    autoSqlBlocked: "L'SQL generato dall'AI è sembrato troppo rischioso per l'esecuzione automatica. Rivedilo manualmente prima di eseguirlo.",
+    proposalConfirmYes: "Sì, procedi",
+    proposalConfirmNo: "No, grazie",
+    proposalConfirmTitle: "Conferma azione richiesta",
+    agentSteps: {
+      generated: "SQL generato",
+      noSql: "Nessun SQL trovato",
+      safe: "Sicurezza superata",
+      needsConfirm: "Richiede conferma",
+      blocked: "Bloccato",
+      autoExecute: "Pronto per l'esecuzione",
+      notRequested: "Esecuzione non richiesta",
+      skipped: "Non eseguito",
+      callingTool: "Chiamata strumento...",
+      toolDone: "Strumento completato",
+      toolError: "Errore strumento",
+      executeSafe: "Controllo di sicurezza superato · Eseguito",
+      executeBlocked: "Bloccato dal controllo di sicurezza",
+      contextCompacted: "Contesto compresso",
+    },
+    agentStepTitles: {
+      riskCheck: "Controllo rischi: {action} · {category} · {environment} · {reasons}",
+      blocked: "L'esecuzione è stata bloccata dalla politica dei rischi. Rivedi l'SQL manualmente.",
+      requiresConfirmation: "Questo SQL richiede una conferma prima dell'esecuzione.",
+      askMode: "La modalità Chiedi non esegue automaticamente l'SQL.",
+      unsupportedAction: "L'azione AI corrente non esegue automaticamente l'SQL.",
+      noSql: "La risposta non includeva un blocco di codice SQL eseguibile.",
+      notRequested: "L'utente non ha richiesto l'esecuzione dell'SQL.",
+      skipped: "Questo passaggio non è stato eseguito.",
+    },
+    proxy: "Proxy",
+    proxyEnable: "Invia richieste AI tramite proxy",
+    proxyUrl: "URL Proxy",
+    enableThinking: "Pensiero (Thinking)",
+    enableThinkingOn: "Abilitato",
+    enableThinkingOff: "Disabilitato",
+    enableThinkingHint: "Questa opzione ha effetto solo sulle API /chat/completions e sui modelli supportati. Quando è disabilitata, può ridurre notevolmente l'uso dei token, ma la qualità dei risultati generati potrebbe diminuire leggermente.",
+    anthropicMessagesHint: "Le API compatibili con Anthropic Messages di solito usano /v1/messages.",
+    contextWindow: "Finestra di Contesto",
+    contextWindowAuto: "Auto (rileva dal nome del modello)",
+    contextWindowHint: "Token. Lascia vuoto per il rilevamento automatico. Imposta manualmente per modelli locali/personalizzati.",
+    codexCliPath: "Percorso Codex CLI",
+    codexCliPathHint: "Lascia vuoto per usare codex dal PATH. Esegui login separatamente con codex login.",
+    codexCliPathEnvError: "Codex CLI Path deve contenere solo il percorso dell'eseguibile. Aggiungi le variabili d'ambiente sotto.",
+    codexCliEnv: "Variabili d'ambiente",
+    codexCliEnvAdd: "Aggiungi variabile",
+    codexCliEnvHint: "Variabili opzionali passate a Codex CLI, come HTTPS_PROXY, NO_PROXY, SSL_CERT_FILE o CODEX_CA_CERTIFICATE.",
+    codexCliEnvKeyPlaceholder: "HTTPS_PROXY",
+    codexCliEnvValuePlaceholder: "http://proxy:9800",
+    codexCliEnvInvalidName: "Nome variabile d'ambiente non valido: {name}",
+    codexCliEnvReservedName: "{name} è gestita da DBX per MCP Server e non può essere impostata qui.",
+    codexMcpRequiredTitle: "DBX MCP Server richiesto",
+    codexMcpRequiredDescription: "Codex CLI usa il DBX MCP Server per accedere allo schema del database e agli strumenti di query. Installalo prima di usare Codex nell'assistente AI.",
+    reasoningLevel: "Livello di ragionamento",
+    reasoningLevelDefault: "Predefinito",
+    reasoningLevelMinimal: "Minimo",
+    reasoningLevelLow: "Basso",
+    reasoningLevelMedium: "Medio",
+    reasoningLevelHigh: "Alto",
+    reasoningLevelHint: "Controlla model_reasoning_effort di Codex CLI. Predefinito usa la configurazione Codex.",
+    actions: {
+      general: "Generale",
+      generate: "Genera SQL",
+      explain: "Spiega SQL",
+      optimize: "Ottimizza SQL",
+      fix: "Correggi Errore",
+      convert: "Converti Dialetto",
+      sampleData: "Dati di Esempio",
+      query: "Interroga dati",
+      exploreSchema: "Ispeziona schema",
+      executeAndExplain: "Esegui e spiega",
+      generateNoExec: "Genera (senza eseguire)",
+    },
+    placeholders: {
+      general: "Chiedi qualsiasi cosa...",
+      generate: "Descrivi cosa desideri interrogare, es. ordini per utente negli ultimi 7 giorni",
+      explain: "Opzionale: aggiungi cosa desideri comprendere",
+      optimize: "Opzionale: aggiungi un obiettivo, es. ridurre le scansioni complete della tabella",
+      fix: "Incolla l'errore o descrivi il risultato atteso",
+      convert: "es. converti in PostgreSQL / MySQL / SQL Server",
+      sampleData: "Descrivi i dati di esempio o le istruzioni di test da generare",
+      query: "Descrivi cosa interrogare o conteggiare, es. totali ordini per regione questo mese",
+      exploreSchema: "Descrivi la tabella o struttura da ispezionare, es. colonne e indici di orders",
+      executeAndExplain: "Opzionale: aggiungi su cosa concentrare la spiegazione",
+    },
+    editMessage: "Modifica messaggio",
+    editResend: "Invia di nuovo",
+    editCancel: "Annulla",
+  },
+  contextMenu: {
+    openConnection: "Apri Connessione",
+    closeConnection: "Chiudi Connessione",
+    closeDatabaseConnection: "Chiudi Connessione Database",
+    deleteConnection: "Elimina Connessione",
+    deleteSelectedConnections: "Elimina {count} connessioni selezionate",
+    confirmDeleteTitle: "Elimina Connessione",
+    confirmDeleteMessage: 'Sei sicuro di voler eliminare "{name}"? Questa azione non può essere annullata.',
+    confirmDeleteSelectedMessage: "Eliminare le {count} connessioni selezionate? Questa azione non può essere annullata.",
+    editConnection: "Modifica Connessione",
+    revealDatabaseFile: "Mostra nel file manager",
+    selectVisibleDatabases: "Seleziona Database Visibili",
+    configureVisibleObjects: "Filtro Oggetti Visibili",
+    userAdmin: "Utenti e Privilegi",
+    openUserAdmin: "Apri Utenti e Privilegi",
+    damengJobAdmin: "Job agente Dameng",
+    openDamengJobAdmin: "Apri job agente Dameng",
+    duplicateConnection: "Duplica Connessione",
+    duplicateSelectedConnections: "Duplica {count} connessioni selezionate",
+    newQuery: "Nuova Query",
+    instanceInfo: "Informazioni Istanza",
+    newSql: "Nuovo SQL",
+    generateSql: "Genera SQL",
+    newInsert: "Nuovo Insert",
+    newUpdate: "Nuovo Update",
+    sqlHistory: "Cronologia Query",
+    noSqlHistory: "Nessun SQL correlato",
+    openObjectBrowser: "Esplora Oggetti",
+    viewData: "Visualizza Dati",
+    editStructure: "Modifica Struttura",
+    editColumn: "Modifica Colonna",
+    editIndex: "Modifica Indice",
+    refreshChildren: "Aggiorna",
+    expandAll: "Espandi tutto",
+    pin: "Fissa",
+    unpin: "Sblocca",
+    fixTab: "Blocca scheda",
+    unfixTab: "Sblocca scheda",
+    refreshTab: "Aggiorna Dati",
+    renameTab: "Rinomina Scheda",
+    duplicateTab: "Duplica Scheda",
+    compactTabTitle: "Accorcia Titoli Schede",
+    fullTabTitle: "Mostra titoli completi delle schede",
+    closeTab: "Chiudi Scheda",
+    closeFixedTab: "Chiudi Scheda Fissa",
+    closeOtherTabs: "Chiudi Altre Schede",
+    closeOtherRegularTabs: "Chiudi Altre Schede Normali",
+    closeOtherFixedTabs: "Chiudi Altre Schede Fisse",
+    closeAllTabs: "Chiudi Tutte le Schede",
+    closeAllRegularTabs: "Chiudi Tutte le Schede Normali",
+    closeAllFixedTabs: "Chiudi Tutte le Schede Fisse",
+    copyName: "Copia Nome",
+    copyFinalProxyPort: "Copia porta proxy finale",
+    finalProxyPortCopied: "Porta proxy finale {port} copiata",
+    setDefaultDatabase: "Imposta come Database Predefinito",
+    clearDefaultDatabase: "Cancella Database Predefinito",
+    exportDatabase: "Esporta Database",
+    exportAllDatabases: "Esporta tutti i database",
+    exportDatabaseSuccess: "Esportate {count} tabelle, fino a {limit} righe ciascuna",
+    exportDatabaseFailed: "Impossibile esportare il database: {message}",
+    backupSqliteDatabase: "Backup SQLite Database",
+    backupSqliteDatabaseInProgress: "Backing up SQLite database...",
+    backupSqliteDatabaseSuccess: "SQLite database backed up",
+    backupSqliteDatabaseFailed: "Failed to backup SQLite database: {message}",
+    importData: "Importa Dati",
+    exportData: "Esporta Dati",
+    exportStructure: "Esporta Struttura",
+    exportStructurePreviewTitle: "Struttura - {name}",
+    exportStructurePreviewTitleMultiple: "Struttura - {count} oggetti",
+    exportStructureLoading: "Caricamento struttura...",
+    copyStructure: "Copia Struttura",
+    copyStructureAs: "Copia Struttura Come",
+    copyStructureAsTsv: "TSV (per Excel)",
+    copyStructureAsMarkdown: "Tabella Markdown",
+    structureDocTable: "Tabella",
+    structureDocColumn: "Colonna",
+    structureDocType: "Tipo",
+    structureDocPrimaryKey: "Chiave Primaria",
+    structureDocNullable: "Nullabile",
+    structureDocDefault: "Predefinito",
+    structureDocComment: "Commento",
+    structureDocYes: "Sì",
+    structureDocNo: "No",
+    structureDocCopied: "Struttura copiata",
+    structureDocCopyFallbackHint: "La copia automatica è stata bloccata. Fai di nuovo clic su Copia o seleziona il contenuto di seguito.",
+    saveStructure: "Salva SQL",
+    exportStructureCopied: "Struttura copiata",
+    createTable: "Crea Tabella",
+    createView: "Crea Vista",
+    dropTable: "Elimina Tabella (DROP)",
+    emptyTable: "Svuota Tabella",
+    truncateTable: "Tronca Tabella (TRUNCATE)",
+    duplicateStructure: "Clona come Nuova Tabella",
+    renameObject: "Rinomina",
+    renameObjectTitle: "Rinomina Oggetto",
+    renameObjectNamePlaceholder: "Nuovo nome",
+    renameObjectSuccess: '"{oldName}" rinominato in "{newName}"',
+    confirmDropTableTitle: "Elimina Tabella",
+    confirmDropTableMessage: 'Sei sicuro di voler eliminare (DROP) la tabella "{name}"? Questa operazione eliminerà permanentemente la tabella e tutti i suoi dati.',
+    dropTableCascade: "Usa CASCADE",
+    dropTableCascadeHint: "Elimina anche gli oggetti dipendenti, come le viste. Lascia disattivato per usare il comportamento RESTRICT predefinito di PostgreSQL.",
+    truncateTableCascade: "Usa CASCADE",
+    truncateTableCascadeHint: "Tronca anche le tabelle che fanno riferimento a questa tabella tramite chiavi esterne. Lascia disattivato per usare il comportamento RESTRICT predefinito di PostgreSQL.",
+    confirmEmptyTableTitle: "Svuota Tabella",
+    confirmEmptyTableMessage: 'Sei sicuro di voler eliminare tutti i dati da "{name}"?',
+    confirmTruncateTableTitle: "Tronca Tabella",
+    confirmTruncateTableMessage: 'Sei sicuro di voler troncare (TRUNCATE) la tabella "{name}"? Questa operazione rimuoverà tutte le righe.',
+    dropTableSuccess: 'Tabella "{name}" eliminata',
+    editView: "Modifica Vista",
+    viewSource: "Visualizza Origine",
+    viewDdl: "Visualizza DDL",
+    viewDdlLoading: "Caricamento DDL...",
+    ddlCopied: "DDL copiato",
+    dropObject: "Elimina Oggetto",
+    dropView: "Elimina Vista",
+    dropColumn: "Elimina Colonna",
+    dropIndex: "Elimina Indice",
+    dropAllIndexes: "Elimina tutti gli indici",
+    dropForeignKey: "Elimina Chiave Esterna",
+    dropTrigger: "Elimina Trigger",
+    batchDrop: "Elimina selezionati ({count})",
+    batchEmpty: "Svuota selezionate ({count})",
+    batchTruncate: "Tronca selezionate ({count})",
+    batchDropIndexes: "Elimina indici ({count})",
+    executeProcedure: "Esegui Procedura",
+    confirmExecuteProcedureTitle: "Esegui Procedura",
+    confirmExecuteProcedureMessage: 'Eseguire la procedura "{name}"? È possibile compilare o regolare i valori dei parametri prima.',
+    loadingProcedureParameters: "Caricamento parametri...",
+    procedureParametersUnavailable: "Impossibile caricare i metadati dei parametri. Puoi comunque modificare l'SQL di seguito ed eseguirlo.",
+    noProcedureParameters: "Nessun parametro trovato. L'SQL corrente verrà eseguito come mostrato.",
+    inputParameters: "{count} parametri di input",
+    outputParameters: "{count} parametri di output",
+    parameterName: "Nome",
+    parameterType: "Tipo",
+    parameterMode: "Modalità",
+    parameterValue: "Valore",
+    parameterNull: "NULL",
+    parameterDefault: "DEFAULT",
+    parameterDefaultHint: "Quando DEFAULT è selezionato, DBX omette quell'argomento in modo che il database utilizzi il valore predefinito della procedura.",
+    parameterValuePlaceholder: "Inserisci valore",
+    outputOnly: "Solo output",
+    sqlPreview: "Anteprima SQL",
+    resetSqlPreview: "Reimposta SQL",
+    openInSqlEditor: "Apri nell'Editor",
+    dropProcedure: "Elimina Procedura",
+    dropFunction: "Elimina Funzione",
+    confirmDropViewTitle: "Elimina Vista",
+    confirmDropViewMessage: 'Sei sicuro di voler eliminare la vista "{name}"?',
+    confirmDropObjectTitle: "Elimina Oggetto",
+    confirmDropObjectMessage: 'Sei sicuro di voler eliminare "{name}"?',
+    confirmDropColumnTitle: "Elimina Colonna",
+    confirmDropIndexTitle: "Elimina Indice",
+    confirmDropMongoIndexMessage: 'Vuoi eliminare l\'indice "{name}" dalla collection "{collection}"?',
+    confirmDropMongoAllIndexesMessage: 'Vuoi eliminare tutti gli indici rimovibili dalla collection "{name}"?',
+    confirmDropMongoAllIndexesDetails: 'MongoDB mantiene l\'indice "_id_". Altri indici richiesti dalla shard key potrebbero restare; il risultato elencherà solo quelli effettivamente eliminati.',
+    confirmDropForeignKeyTitle: "Elimina Chiave Esterna",
+    confirmDropTriggerTitle: "Elimina Trigger",
+    confirmDropTableChildObjectMessage: 'Sei sicuro di voler eliminare "{name}" da "{table}"?',
+    confirmDropBatchIndexesMessage: 'Sei sicuro di voler eliminare {count} indici selezionati da "{table}"? Questa azione non può essere annullata.',
+    confirmBatchDropTitle: "Elimina Oggetti Selezionati",
+    confirmBatchDropMessage: "Sei sicuro di voler eliminare {count} oggetti selezionati? Questa azione non può essere annullata.",
+    confirmBatchEmptyTitle: "Svuota Tabelle Selezionate",
+    confirmBatchEmptyMessage: "Sei sicuro di voler eliminare tutti i dati da {count} tabelle selezionate?",
+    confirmBatchTruncateTitle: "Tronca Tabelle Selezionate",
+    confirmBatchTruncateMessage: "Sei sicuro di voler troncare {count} tabelle selezionate? Questa operazione rimuoverà tutte le righe.",
+    confirmDropProcedureTitle: "Elimina Procedura",
+    confirmDropProcedureMessage: 'Sei sicuro di voler eliminare la procedura "{name}"?',
+    confirmDropFunctionTitle: "Elimina Funzione",
+    confirmDropFunctionMessage: 'Sei sicuro di voler eliminare la funzione "{name}"?',
+    dropViewSuccess: 'Vista "{name}" eliminata',
+    dropProcedureSuccess: 'Procedura "{name}" eliminata',
+    dropFunctionSuccess: 'Funzione "{name}" eliminata',
+    dropTableChildObjectSuccess: '"{name}" eliminato',
+    dropAllIndexesSuccess: 'Eliminati {count} indici da "{name}"',
+    batchDropSuccess: "Eliminati {count} oggetti",
+    batchEmptySuccess: "Svuotate {count} tabelle",
+    batchEmptyPartialFail: "Svuotate {success} tabelle, {failed} non riuscite",
+    batchEmptySubmitted: "Inviate attività di svuotamento per {count} tabelle",
+    batchEmptySubmittedPartial: "Inviate {success} attività, {failed} non riuscite",
+    batchTruncateSuccess: "Troncate {count} tabelle",
+    emptyTableSuccess: 'Tutti i dati eliminati da "{name}"',
+    emptyTableSubmitted: 'Attività di svuotamento inviata per "{name}"',
+    truncateTableSuccess: 'Tabella "{name}" troncata',
+    duplicateStructureSuccess: 'Tabella clonata come "{name}"',
+    tableOperationFailed: "Operazione non riuscita: {message}",
+    duplicateNameTitle: "Clona as Nuova Tabella",
+    duplicateNamePlaceholder: "Nuovo nome tabella",
+    copyTable: "Copia tabella",
+    pasteTable: "Incolla tabella",
+    pasteOptionStructureAndData: "Struttura e dati",
+    pasteOptionStructureOnly: "Solo struttura",
+    pasteOptionDataOnly: "Solo dati",
+    pasteTableSuccess: 'Tabella incollata come "{name}"',
+    pasteTableConfirmTitle: "Incolla tabella",
+    pasteTableConfirmMessage: "Incolla tabella dagli appunti",
+    batchPasteTitle: "Incolla tabelle",
+    batchPasteSuccess: "{count} tabelle incollate correttamente",
+    batchPastePartialFail: "{success} tabelle incollate, {failed} fallite",
+    noTableToPaste: "Nessuna tabella disponibile da incollare",
+    pasteTableClipboardUpdated: "Tabella copiata negli appunti",
+    createDatabase: "Crea Database",
+    createDuckDbFile: "Crea File Database",
+    dropDatabase: "Elimina Database",
+    confirmDropDatabaseTitle: "Elimina Database",
+    confirmDropDatabaseMessage: 'Sei sicuro di voler eliminare il database "{name}"? Questa operazione eliminerà permanentemente il database e tutti i suoi dati.',
+    createDatabaseSuccess: 'Database "{name}" creato',
+    editDatabaseProperties: "Modifica proprietà database",
+    editDatabasePropertiesTitle: 'Modifica proprietà database: "{name}"',
+    editDatabasePropertiesSaving: "Salvataggio...",
+    editDatabasePropertiesSuccess: 'Proprietà del database "{name}" aggiornate',
+    editDatabaseComment: "Commento database",
+    editDatabaseCommentPlaceholder: "Inserisci commento database...",
+    createDuckDbFileSuccess: 'File di database DuckDB "{name}" creato e collegato',
+    createDuckDbFileDesktopOnly: "La creazione di file di database DuckDB è disponibile solo nell'applicazione desktop",
+    dropDatabaseSuccess: 'Database "{name}" eliminato',
+    dropCollection: "Elimina Collection",
+    confirmDropCollectionTitle: "Elimina Collection",
+    confirmDropCollectionMessage: 'Sei sicuro di voler eliminare la collection "{name}"? Questa operazione eliminerà permanentemente la collection e tutti i suoi documenti.',
+    dropCollectionSuccess: 'Collection "{name}" eliminata',
+    createDatabaseNamePlaceholder: "Nome database",
+    createDatabaseCharset: "Set di caratteri",
+    createDatabaseCharsetPlaceholder: "es. utf8mb4",
+    createDatabaseCharsetSearchPlaceholder: "Cerca o digita un set di caratteri",
+    createDatabaseCharsetEmpty: "Nessun set di caratteri trovato",
+    createDatabaseCharsetLoading: "Caricamento set di caratteri...",
+    createDatabaseCharsetCustomOption: 'Usa "{value}"',
+    createDatabaseCollation: "Collation",
+    createDatabaseCollationPlaceholder: "es. utf8mb4_unicode_ci",
+    createDatabaseCollationSearchPlaceholder: "Cerca o digita una collation",
+    createDatabaseCollationEmpty: "Nessuna collation trovata",
+    createDatabaseCollationLoading: "Caricamento collation...",
+    createDatabaseCollationCustomOption: 'Usa "{value}"',
+    createSchema: "Crea Schema",
+    dropSchema: "Elimina Schema",
+    confirmDropSchemaTitle: "Elimina Schema",
+    confirmDropSchemaMessage: 'Sei sicuro di voler eliminare lo schema "{name}"? Questa operazione eliminerà permanentemente lo schema e tutti i suoi oggetti.',
+    createSchemaSuccess: 'Schema "{name}" creato',
+    dropSchemaSuccess: 'Schema "{name}" eliminato',
+    createSchemaNamePlaceholder: "Nome schema",
+    editSchemaComment: "Modifica commento",
+    editSchemaCommentTitle: 'Modifica commento: "{name}"',
+    schemaCommentPlaceholder: "Inserisci commento schema...",
+    schemaCommentSaving: "Salvataggio...",
+    editSchemaCommentSuccess: 'Commento dello schema "{name}" aggiornato',
+    manageExtension: "Gestisci estensione...",
+    dropExtension: "Elimina estensione",
+  },
+  visibleDatabases: {
+    title: "Database Visibili",
+    description: 'Scegli quali database mostrare sotto "{connection}".',
+    searchPlaceholder: "Cerca database...",
+    selectedCount: "{selected}/{total} selezionati",
+    selectAll: "Seleziona tutto",
+    selectFiltered: "Seleziona risultati ricerca",
+    clear: "Cancella",
+    showAll: "Mostra tutto",
+    showSystemDatabases: "Mostra database di sistema",
+    save: "Salva",
+    emptySelection: "Seleziona almeno un database, oppure usa Mostra tutto per rimuovere il filtro.",
+    loadFailed: "Impossibile caricare i database: {message}",
+  },
+  visibleSchemas: {
+    title: "Filtro Schema",
+    description: 'Scegli quali schema mostrare sotto "{connection}".',
+    searchPlaceholder: "Cerca schema...",
+    selectedCount: "{selected}/{total} selezionati",
+    selectAll: "Seleziona tutto",
+    selectFiltered: "Seleziona risultati ricerca",
+    clear: "Cancella",
+    showAll: "Mostra tutto",
+    save: "Salva",
+    emptySelection: "Seleziona almeno uno schema, oppure usa Mostra tutto per rimuovere il filtro.",
+    loadFailed: "Impossibile caricare gli schema: {message}",
+  },
+  tree: {
+    savedSql: "Libreria SQL",
+    userAdmin: "Utenti e Privilegi",
+    damengJobAdmin: "Job agente",
+    linkedServers: "Server Collegati",
+    defaultDatabase: "DB Predefinito",
+    columns: "Colonne",
+    indexes: "Indici",
+    foreignKeys: "Chiavi Esterne",
+    triggers: "Trigger",
+    tables: "Tabelle",
+    views: "Viste",
+    materializedViews: "Viste Materializzate",
+    procedures: "Procedure",
+    functions: "Funzioni",
+    sequences: "Sequenze",
+    packages: "Pacchetti",
+    partitions: "Partizioni",
+    childTables: "Sottotabelle",
+    loadMore: "Carica altro...",
+    objectBrowser: "Sfoglia in Esplora Oggetti ({count})",
+    extensions: "Estensioni",
+  },
+  userAdmin: {
+    title: "Utenti e Privilegi",
+    unsupported: "Connessioni compatibili con MySQL e PostgreSQL sono supportate. SQL Server, Oracle e altri modelli di autorizzazione possono essere aggiunti in seguito.",
+    newUser: "Nuovo Utente",
+    anonymous: "Anonimo",
+    roleName: "Nome ruolo",
+    allowLogin: "Consenti login",
+    searchUser: "Cerca utente o host",
+    loadingUsers: "Caricamento utenti...",
+    loadingGrants: "Caricamento privilegi...",
+    emptyUsers: "Nessun utente trovato, oppure l'account corrente non puo leggere l'elenco utenti.",
+    pluginUnknown: "Plugin di autenticazione sconosciuto",
+    grants: "Privilegi",
+    noGrants: "Nessun privilegio trovato",
+    privilegeEditor: "Editor Privilegi",
+    privilegeHint: "Scegli privilegi, database e tabella, quindi visualizza l'anteprima SQL prima di applicare. * indica globale o tutte le tabelle.",
+    database: "Database",
+    schema: "Schema",
+    table: "Tabella",
+    scope: "Ambito concessione",
+    scopeDatabase: "Database",
+    scopeSchema: "Schema",
+    scopeTable: "Tabella",
+    scopeRole: "Appartenenza ruolo",
+    memberRole: "Ruolo membro",
+    privileges: "Privilegi",
+    grantOption: "Consenti ulteriori concessioni (WITH GRANT OPTION)",
+    adminOption: "Consenti gestione appartenenza (WITH ADMIN OPTION)",
+    grant: "Concedi",
+    revoke: "Revoca",
+    username: "Nome utente",
+    host: "Host",
+    changePassword: "Cambia Password",
+    newPassword: "Nuova password",
+    lock: "Blocca",
+    unlock: "Sblocca",
+    disableLogin: "Disabilita Login",
+    enableLogin: "Abilita Login",
+    dropUser: "Elimina Utente",
+    previewSql: "Anteprima SQL",
+    sqlPreview: "Anteprima SQL",
+    applySql: "Applica SQL",
+    applySuccess: "Privilegi utente aggiornati",
+    applyFailed: "Esecuzione non riuscita: {message}",
+  },
+  damengJobAdmin: {
+    title: "Job agente Dameng",
+    unsupported: "Questa pagina supporta solo connessioni Dameng.",
+    initEnvironment: "Inizializza ambiente job",
+    environmentReady: "Ambiente job inizializzato",
+    newJob: "Nuovo job",
+    searchJob: "Cerca job",
+    loadFailed: "Caricamento non riuscito",
+    environmentMissingTitle: "Ambiente job non inizializzato",
+    environmentMissingHint: "Questo database non ha ancora l'ambiente SYSJOB.",
+    environmentMissingDescription: "I job agente Dameng dipendono da tabelle e viste di sistema nello schema SYSJOB. Inizializza prima l'ambiente job; di solito sono necessari privilegi amministrativi.",
+    emptyJobs: "Nessun job trovato, oppure l'account corrente non puo leggere l'elenco dei job.",
+    emptyDetails: "Nessuna riga di dettaglio",
+    selectJob: "Seleziona un job",
+    enabled: "Abilitato",
+    disabled: "Disabilitato",
+    running: "In esecuzione",
+    enable: "Abilita",
+    disable: "Disabilita",
+    runAsync: "Esegui ora",
+    stopRunning: "Ferma esecuzione corrente",
+    stopRunningDisabled: "Solo i job attualmente in esecuzione possono essere fermati",
+    clearHistories: "Cancella cronologia",
+    dropJob: "Elimina",
+    steps: "Passi",
+    schedules: "Pianificazioni",
+    histories: "Cronologia",
+    noDescription: "Nessuna descrizione",
+    jobName: "Nome job",
+    description: "Descrizione",
+    stepName: "Nome passo",
+    scheduleName: "Nome pianificazione",
+    sqlCommand: "Script SQL",
+    scheduleMode: "Tipo pianificazione",
+    daily: "Giornaliero",
+    once: "Una volta",
+    startDate: "Data inizio",
+    startTime: "Ora inizio",
+    endTime: "Ora fine",
+    minuteInterval: "Intervallo in minuti",
+    previewSql: "Anteprima SQL",
+    sqlPreview: "Anteprima SQL",
+    applySql: "Applica SQL",
+    applySuccess: "Operazione job applicata",
+    applyFailed: "Esecuzione non riuscita: {message}",
+  },
+  objects: {
+    all: "Tutti",
+    tables: "Tabelle",
+    views: "Viste",
+    procedures: "Procedure",
+    functions: "Funzioni",
+    sequences: "Sequenze",
+    packages: "Pacchetti",
+    table: "Tabella",
+    partitions: "{count} partizioni",
+    view: "Vista",
+    procedure: "Procedura",
+    function: "Funzione",
+    sequence: "Sequenza",
+    package: "Pacchetto",
+    packageBody: "Corpo del Pacchetto",
+    name: "Nome",
+    type: "Tipo",
+    rows: "Righe",
+    size: "Dimensione",
+    statisticsHint: "Stimato dalle statistiche del database; COUNT(*) non viene eseguito.",
+    createdAt: "Creato",
+    updatedAt: "Aggiornato",
+    source: "Codice Sorgente",
+    saveSource: "Salva",
+    cancelEdit: "Annulla",
+    sourceSaved: "Sorgente salvato",
+    sourceSaveFailed: "Impossibile salvare il sorgente: {message}",
+    schemaColumn: "Schema",
+    comment: "Commento",
+    loadingSchemas: "Caricamento schemi...",
+    schema: "Schema",
+    search: "Cerca tabelle, viste, funzioni, sequenze o procedure...",
+    loading: "Caricamento oggetti...",
+    empty: "Nessun oggetto trovato",
+    selectedTables: "{count} tabelle selezionate",
+    exportSelected: "Esporta selezionate",
+    dropSelected: "Elimina selezionate",
+    truncateSelected: "Tronca selezionate",
+    clearSelection: "Cancella selezione",
+    confirmBatchDropTitle: "Elimina Tabelle Selezionate",
+    confirmBatchDropMessage: "Sei sicuro di voler eliminare {count} tabelle selezionate? Questa azione non può essere annullata.",
+    confirmBatchTruncateTitle: "Tronca Tabelle Selezionate",
+    confirmBatchTruncateMessage: "Sei sicuro di voler troncare {count} tabelle selezionate? Questa operazione rimuoverà tutte le righe.",
+    batchDropSuccess: "Eliminate {count} tabelle",
+    batchTruncateSuccess: "Troncate {count} tabelle",
+    copyTableSelected: "Copia",
+    pasteTableSelected: "Incolla",
+    toggleCheckbox: "Attiva/disattiva selezione multipla",
+    viewList: "Vista elenco",
+    viewGrid: "Vista griglia",
+    sourceReadOnly: "Il codice sorgente è di sola lettura, non modificabile.",
+    sortAsc: "Crescente",
+    sortDesc: "Decrescente",
+    sortBy: "Ordina per",
+  },
+  structureEditor: {
+    mysqlDataTypeHelp: {
+      tinyint: "Intero da 1 byte: con segno da -128 a 127, senza segno da 0 a 255.",
+      smallint: "Intero da 2 byte: con segno da -32.768 a 32.767, senza segno da 0 a 65.535.",
+      mediumint: "Intero da 3 byte: con segno da -8.388.608 a 8.388.607, senza segno da 0 a 16.777.215.",
+      int: "Intero da 4 byte: con segno da -2.147.483.648 a 2.147.483.647, senza segno da 0 a 4.294.967.295.",
+      bigint: "Intero da 8 byte: con segno da -2^63 a 2^63-1, senza segno da 0 a 2^64-1.",
+      decimal: "Numero decimale esatto; MySQL supporta fino a 65 cifre e scala 30. Usarlo per denaro.",
+      float: "Numero approssimato a precisione singola; per decimali esatti usare DECIMAL.",
+      double: "Numero approssimato a doppia precisione; per decimali esatti usare DECIMAL.",
+      real: "Alias di DOUBLE per impostazione predefinita; REAL_AS_FLOAT lo rende alias di FLOAT.",
+      bit: "Campo da 1 a 64 bit; larghezza predefinita 1.",
+      boolean: "Alias di TINYINT(1): 0 è falso e un valore non zero è vero.",
+      serial: "Alias pratico di BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE.",
+      date: "Data di calendario da 1000-01-01 a 9999-12-31.",
+      datetime: "Data e ora senza conversione di fuso; precisione frazionaria da 0 a 6, predefinita 0.",
+      timestamp: "Data e ora convertita tra fuso sessione e UTC; precisione frazionaria da 0 a 6.",
+      time: "Ora o intervallo da -838:59:59 a 838:59:59; precisione frazionaria da 0 a 6.",
+      year: "Anno a quattro cifre da 1901 a 2155, oltre a 0000.",
+      char: "Stringa a lunghezza fissa fino a 255 caratteri, riempita con spazi.",
+      varchar: "Stringa a lunghezza variabile; il massimo dipende da riga e set di caratteri.",
+      tinytext: "Testo variabile fino a 255 byte; riga, charset e max_allowed_packet possono ridurlo.",
+      text: "Testo variabile fino a 65.535 byte; riga, charset e max_allowed_packet possono ridurlo.",
+      mediumtext: "Testo variabile fino a 16.777.215 byte; riga, charset e max_allowed_packet possono ridurlo.",
+      longtext: "Testo variabile fino a 4.294.967.295 byte; riga, charset e max_allowed_packet possono ridurlo.",
+      binary: "Stringa binaria fissa fino a 255 byte, riempita con 0x00.",
+      varbinary: "Stringa binaria variabile; il massimo dipende dalla dimensione della riga.",
+      tinyblob: "Oggetto binario fino a 255 byte; max_allowed_packet può limitarlo.",
+      blob: "Oggetto binario fino a 65.535 byte; max_allowed_packet può limitarlo.",
+      mediumblob: "Oggetto binario fino a 16.777.215 byte; max_allowed_packet può limitarlo.",
+      longblob: "Oggetto binario fino a 4.294.967.295 byte; max_allowed_packet può limitarlo.",
+      enum: "Un valore tra fino a 65.535 letterali; cambiare l'ordine può alterare il significato memorizzato.",
+      set: "Zero o più valori tra fino a 64 membri dichiarati.",
+      json: "Documento JSON validato; rappresentazione e funzioni dipendono da prodotto/versione; limitato da max_allowed_packet.",
+      jsonMysql: "JSON binario nativo MySQL con validazione e funzioni JSON; limitato da max_allowed_packet.",
+      jsonMariaDb: "In MariaDB JSON è alias di LONGTEXT con JSON_VALID e collazione utf8mb4_bin.",
+      nationalCharacter: "Alias di stringa nazionale; MySQL usa utf8mb3, deprecato; preferire utf8mb4.",
+      geometry: "Geometria spaziale; un indice SPATIAL InnoDB richiede NOT NULL e attributo SRID.",
+      point: "Punto spaziale; SPATIAL InnoDB richiede NOT NULL e SRID.",
+      linestring: "Curva spaziale; SPATIAL InnoDB richiede NOT NULL e SRID.",
+      polygon: "Superficie spaziale; SPATIAL InnoDB richiede NOT NULL e SRID.",
+      multipoint: "Raccolta di punti; SPATIAL InnoDB richiede NOT NULL e SRID.",
+      multilinestring: "Raccolta di curve; SPATIAL InnoDB richiede NOT NULL e SRID.",
+      multipolygon: "Raccolta di poligoni; SPATIAL InnoDB richiede NOT NULL e SRID.",
+      geometrycollection: "Raccolta di geometrie miste; SPATIAL InnoDB richiede NOT NULL e SRID.",
+      inet4: "Tipo IPv4 MariaDB disponibile da 10.10; memorizza l'indirizzo in quattro byte.",
+      inet6: "Tipo compatibile MariaDB per IPv6 e IPv4 mappato.",
+      uuid: "Identificatore universale univoco a 128 bit fornito da server compatibili.",
+      vector: "Tipo vettore per similarità o ML; disponibilità e dimensioni dipendono dalla versione.",
+      xmltype: "Tipo XML fornito da server compatibili.",
+      integerDisplayWidth: "La larghezza di visualizzazione intera, ad esempio INT(11), è deprecata e non limita l'intervallo.",
+      zerofill: "ZEROFILL è deprecato in MySQL 8 e implica UNSIGNED; formattare nell'applicazione.",
+      unsignedNumeric: "UNSIGNED per DECIMAL, FLOAT o DOUBLE è deprecato in MySQL 8; usare CHECK per valori non negativi.",
+      floatPrecision: "In FLOAT(p), p da 25 a 53 seleziona DOUBLE; usare DOUBLE esplicitamente.",
+      floatingPointDisplay: "FLOAT(M,D) e DOUBLE(M,D) sono deprecati; usare FLOAT/DOUBLE senza parametri o DECIMAL(M,D).",
+    },
+    postgresDataTypeHelp: {
+      smallint: "Intero con segno da 2 byte, da -32.768 a 32.767.",
+      integer: "Intero con segno da 4 byte, da -2.147.483.648 a 2.147.483.647.",
+      bigint: "Intero con segno da 8 byte, da -2^63 a 2^63-1.",
+      serial: "Sintassi pratica che crea intero, sequenza, NOT NULL e default nextval; non è unico da solo e può avere lacune; preferire IDENTITY.",
+      numeric: "Decimale esatto con precisione e scala; usarlo per denaro e valori senza arrotondamento binario.",
+      real: "Floating point a precisione singola da 4 byte; FLOAT(p) da 1 a 24 lo seleziona.",
+      double: "Floating point a doppia precisione da 8 byte; FLOAT senza precisione è alias e FLOAT(p) da 25 a 53 lo seleziona.",
+      money: "Importo monetario dipendente da lc_monetary; NUMERIC è più sicuro per dati finanziari portabili.",
+      boolean: "Valore logico vero, falso o nullo; BOOL è alias di BOOLEAN.",
+      char: "Stringa fissa riempita di spazi; CHARACTER è alias.",
+      varchar: "Stringa variabile con limite opzionale; CHARACTER VARYING è alias.",
+      text: "Stringa variabile senza limite dichiarato; stessa memorizzazione di VARCHAR senza limite.",
+      bytea: "Stringa binaria variabile; TOAST può memorizzare valori grandi fuori riga.",
+      date: "Data di calendario senza ora né fuso.",
+      time: "Ora senza fuso, con precisione frazionaria opzionale.",
+      timetz: "Ora con offset UTC; uso limitato, preferire timestamptz per un istante.",
+      timestamp: "Data e ora senza conversione di fuso per valori locali.",
+      timestamptz: "Istante memorizzato in UTC e mostrato nel fuso della sessione; non conserva il fuso originale.",
+      interval: "Durata in mesi, giorni e microsecondi; le unità di calendario non hanno durata fissa.",
+      uuid: "Identificatore universale univoco a 128 bit.",
+      json: "Testo JSON nella rappresentazione originale; validato al parsing ma generalmente più lento di JSONB.",
+      jsonb: "JSON binario decomposto ottimizzato per elaborazione e indici; non conserva spazi, ordine o chiavi duplicate.",
+      xml: "Valore XML con validazione di documento o contenuto secondo l'opzione.",
+      bit: "Stringa di bit fissa o variabile; BIT VARYING e VARBIT sono alias variabili.",
+      tsvector: "Lessemi normalizzati per ricerca full-text; spesso indicizzati con GIN o GiST.",
+      tsquery: "Query full-text booleana valutata contro un tsvector.",
+      cidr: "Rete IPv4 o IPv6 con bit host vincolati a zero.",
+      inet: "Host IPv4 o IPv6 con maschera opzionale; diversamente da CIDR può avere bit host non zero.",
+      macaddr: "Indirizzo MAC; MACADDR usa 6 byte e MACADDR8 usa 8 byte.",
+      geometry: "Tipo geometrico piano bidimensionale senza SRID; usare PostGIS per coordinate geografiche e operazioni avanzate.",
+      range: "Intervallo continuo con limiti inclusivi/esclusivi; usare multirange per intervalli separati.",
+      oid: "Identificatore oggetto senza segno di sistema; non è una chiave primaria applicativa durevole.",
+      array: "Array PostgreSQL di qualunque elemento, anche multidimensionale; le dimensioni dichiarate non sono imposte.",
+      multirange: "Insieme di intervalli non sovrapposti; PostgreSQL normalizza membri adiacenti o sovrapposti.",
+      jsonpath: "Espressione percorso SQL/JSON usata da query e predicati JSONB.",
+      pgLsn: "Posizione WAL per replica e recupero; non è un numero di sequenza applicativo.",
+      pgSnapshot: "Snapshot di visibilità delle transazioni per operazioni database, non dati applicativi generali.",
+    },
+    sqliteDataTypeHelp: {
+      integer: "Affinità INTEGER; una colonna normale non impone questa classe. INTEGER PRIMARY KEY esatto è alias di rowid.",
+      real: "Affinità REAL con IEEE 754; non adatta a denaro esatto.",
+      text: "Affinità TEXT; VARCHAR(n) e CHAR(n) non impongono n; usare CHECK se la lunghezza conta.",
+      blob: "Affinità BLOB: memorizza byte senza conversione.",
+      numeric: "Affinità NUMERIC converte testo numerico prima in INTEGER e poi in REAL; anche DATE, DATETIME e TIME la usano.",
+    },
+    title: "Modifica Struttura Tabella",
+    createTitle: "Crea Tabella",
+    editTabTitle: "Modifica: {tableName}",
+    tableName: "Nome Tabella",
+    refresh: "Aggiorna Struttura",
+    density: "Densità",
+    densityCompact: "Compatta",
+    densityStandard: "Standard",
+    densityComfortable: "Comoda",
+    columns: "Colonne",
+    indexes: "Indici",
+    foreignKeys: "Chiavi Esterne",
+    triggers: "Trigger",
+    ddl: "DDL",
+    addColumn: "Aggiungi Colonna",
+    columnTemplates: "Inserisci campi predefiniti",
+    configureColumnTemplates: "Configura campi predefiniti",
+    presetFieldsTemplate: "Set di campi predefiniti",
+    searchColumns: "Cerca colonna/commento",
+    nextColumnMatch: "Vai alla prossima colonna corrispondente",
+    searchIndexes: "Cerca indice",
+    nextIndexMatch: "Vai al prossimo indice corrispondente",
+    addIndex: "Aggiungi Indice",
+    addForeignKey: "Aggiungi Chiave Esterna",
+    addTrigger: "Aggiungi Trigger",
+    columnName: "Colonna",
+    dataType: "Tipo",
+    typePlaceholder: "Seleziona o digita...",
+    noMatchingType: "Nessun tipo corrispondente",
+    length: "Lunghezza",
+    nullable: "Nullabile",
+    primaryKey: "Chiave Primaria",
+    defaultValue: "Valore Predefinito",
+    defaultValuePresets: "Preimpostazioni valore predefinito",
+    comment: "Commento",
+    characterSet: "Set di caratteri",
+    charsetPlaceholder: "Charset",
+    collation: "Regole di confronto",
+    collationPlaceholder: "Regole di confronto",
+    editComment: "Modifica commento",
+    commentPlaceholder: "Inserisci commento colonna...",
+    tableCommentPlaceholder: "Inserisci commento tabella...",
+    tableCommentUnsupported: "I commenti della tabella non sono supportati da questo database",
+    actions: "Azioni",
+    indexName: "Indice",
+    indexColumns: "Colonne",
+    indexColumnsPlaceholder: "Seleziona colonne...",
+    unique: "Unico",
+    indexType: "Tipo",
+    includedColumns: "Incluse",
+    includedColumnsPlaceholder: "Seleziona colonne...",
+    filter: "Filtro",
+    foreignKeyName: "Chiave esterna",
+    referencedSchema: "Schema rif.",
+    referencedTable: "Tabella rif.",
+    referencedColumn: "Colonna rif.",
+    onDelete: "On delete",
+    onUpdate: "On update",
+    defaultAction: "Predefinito",
+    triggerName: "Trigger",
+    triggerStatement: "Istruzione trigger",
+    primary: "Primario",
+    drop: "Elimina",
+    restore: "Ripristina",
+    remove: "Rimuovi",
+    moveColumnUp: "Sposta colonna su",
+    moveColumnDown: "Sposta colonna giù",
+    dragColumn: "Trascina per riordinare la colonna",
+    localColumnOrderNotice: "L'ordine delle colonne viene salvato solo localmente e non modifica la struttura del database.",
+    yes: "Sì",
+    no: "No",
+    emptyReadonly: "Nessun record",
+    sqlPreview: "Anteprima SQL",
+    collapseSqlPreview: "Comprimi anteprima SQL",
+    expandSqlPreview: "Espandi anteprima SQL",
+    noChanges: "Nessuna modifica",
+    apply: "Applica Modifiche",
+    ready: "Pronto",
+    saved: "Struttura tabella aggiornata",
+    copySql: "Copia SQL",
+    sqliteRebuildNotice: "SQLite conserva uno snapshot di dati inerte come backup, ricostruisce la tabella in un'unica transazione e forza CAST sulle colonne modificate. I valori non rappresentabili possono diventare 0/0.0; in caso di errore, tutte le modifiche vengono annullate.",
+    extendedProperties: "Esteso",
+    autoIncrement: "Auto Incremento",
+    onUpdateCurrentTimestamp: "Aggiorna Ora Automaticamente",
+    identity: "Identità",
+    identityGeneration: "Generazione",
+    identitySeed: "Seed",
+    identityIncrement: "Incremento",
+    sqlServerIdentityTypeHint: "Identity di SQL Server supporta solo tinyint, smallint, int, bigint e decimal/numeric con scala 0",
+  },
+  diagram: {
+    title: "Diagramma delle Relazioni",
+    open: "Visualizza Diagramma",
+    selectConnection: "Seleziona connessione",
+    selectDatabase: "Seleziona database",
+    selectSchema: "Seleziona schema",
+    searchTables: "Cerca tabelle, colonne, chiavi...",
+    refresh: "Aggiorna diagramma",
+    loading: "Lettura relazioni...",
+    loadingProgress: "Lettura relazioni... {loaded}/{total}",
+    partialError: "Saltati i metadati per {count} tabelle che non è stato possibile caricare",
+    selectTarget: "Seleziona una connessione e un database",
+    empty: "Nessuna tabella da visualizzare",
+    noMatches: "Nessuna tabella corrispondente",
+    tablesCount: "{count} tabelle",
+    relationshipsCount: "{count} relazioni",
+    tableMode: "Visualizzazione Tabella",
+    engineeringMode: "ER Ingegneristico",
+    modelRelationships: "Relazioni Modello",
+    copyJoinSql: "Copia SQL",
+    customRelationshipsCount: "{count} modellati",
+    relationshipName: "Nome",
+    relationshipNamePlaceholder: "Opzionale",
+    sourceTable: "Tabella sorgente",
+    sourceColumn: "Colonna sorgente",
+    targetTable: "Tabella destinazione",
+    targetColumn: "Colonna destinazione",
+    cardinality: "Cardinalita",
+    cardinalityOneToMany: "1:N",
+    cardinalityManyToOne: "N:1",
+    cardinalityOneToOne: "1:1",
+    addRelationship: "Aggiungi relazione",
+    removeRelationship: "Rimuovi relazione",
+    relationshipIncomplete: "Seleziona sia la colonna sorgente che quella di destinazione",
+    relationshipSelfInvalid: "Una relazione non puo avere come destinazione la stessa colonna",
+    relationshipExists: "Questa relazione esiste gia",
+    relationshipAdded: "Relazione aggiunta",
+    noJoinSql: "Nessun SQL di relazione da copiare",
+    allTables: "Tutte le Tabelle",
+    relatedTables: "Tabelle Correlate",
+    moreColumns: "+ {count} colonne",
+    exportSvg: "Esporta SVG",
+    exportedSvg: "SVG esportato",
+    exportSvgFailed: "Impossibile esportare SVG: {message}",
+    zoomIn: "Ingrandisci",
+    zoomOut: "Rimpicciolisci",
+    resetLayout: "Reimposta layout",
+  },
+  etcd: {
+    prefixPlaceholder: "Prefisso, es. /app/",
+    newKey: "Nuova Chiave",
+    loadingKeys: "Caricamento chiavi...",
+    empty: "Nessuna chiave trovata",
+    loadMore: "Carica altro",
+    selectKey: "Seleziona una chiave per visualizzarne il valore",
+    loadingValue: "Caricamento valore...",
+    notFound: "Chiave non trovata",
+    edit: "Modifica",
+    editKey: "Modifica Chiave",
+    delete: "Elimina",
+    deleteTitle: "Elimina chiave etcd",
+    keyPlaceholder: "/percorso/per/la/chiave",
+    keyRequired: "La chiave e obbligatoria",
+    saved: "Chiave salvata",
+    deleted: "Chiave eliminata",
+    base64Readonly: "I valori Base64 sono in sola lettura in questa versione.",
+  },
+  zookeeper: {
+    prefixPlaceholder: "Prefisso percorso, es. /app/",
+    newKey: "Nuovo Znode",
+    loadingKeys: "Caricamento znodes...",
+    empty: "Nessuno znode trovato",
+    loadMore: "Carica altro",
+    selectKey: "Seleziona uno znode per visualizzarne il valore",
+    loadingValue: "Caricamento valore...",
+    notFound: "Znode non trovato",
+    edit: "Modifica",
+    editKey: "Modifica Znode",
+    delete: "Elimina",
+    deleteTitle: "Elimina znode ZooKeeper",
+    keyPlaceholder: "/percorso/per/znode",
+    keyRequired: "Il percorso znode e obbligatorio",
+    rootReadonly: "Lo znode radice non può essere modificato. Inserisci il percorso di uno znode figlio.",
+    saved: "Znode salvato",
+    deleted: "Znode eliminato",
+    base64Readonly: "I valori Base64 sono in sola lettura in questa versione.",
+    createMode: "Modalita Creazione",
+    createModePersistent: "Persistente",
+    createModeEphemeral: "Effimero",
+    createModePersistentSequential: "Persistente Sequenziale",
+    createModeEphemeralSequential: "Effimero Sequenziale",
+    add: "Aggiungi",
+    value: "Valore",
+    metadata: "Informazioni Nodo",
+    prettyJson: "Formatta",
+    invalidJson: "JSON non valido",
+    summaryRevision: "rev",
+    summaryVersion: "ver",
+    summaryLease: "lease",
+    summarySize: "dimensione",
+  },
+  redis: {
+    createKeyTypeHelp: {
+      string: "Valore singolo fino a 512 MB; utile per cache e contatori.",
+      hash: "Mappa campo-valore piatta; leggere un Hash grande intero è O(N).",
+      list: "Sequenza ordinata; accesso intermedio lineare.",
+      set: "Membri unici non ordinati; enumerare insiemi grandi è lineare.",
+      zset: "Membri unici con punteggio floating point; scrittura O(log N).",
+      stream: "Log append-only; gestire XACK, pendenti e trimming.",
+      json: "JSON per percorso; richiede RedisJSON/Redis Stack e costa di solito più di String o Hash.",
+    },
+    selectKey: "Seleziona una chiave per visualizzarne il valore",
+    noKeys: "Nessuna chiave trovata",
+    noKeysInScanHint: "Nessuna chiave trovata nell'intervallo di scansione corrente",
+    pattern: "pattern (es. user:*)",
+    fuzzyPattern: "la chiave contiene...",
+    fuzzyMatch: "Fuzzy",
+    fuzzyMatchTitle: "Corrispondenza fuzzy: cerca le chiavi per testo semplice contenuto",
+    valueSearchPlaceholder: "il valore contiene...",
+    allSearchPlaceholder: "la chiave o il valore contiene...",
+    searchByKey: "Chiave",
+    searchByValue: "Valore",
+    searchByAll: "Tutto",
+    searchFields: "Cerca campi e valori",
+    keys: "{count} chiavi",
+    loadedKeys: "{loaded} / {total} chiavi caricate",
+    loadingKeys: "Caricamento chiavi...",
+    searchingValues: "Ricerca nei valori...",
+    searchingAll: "Ricerca in chiavi e valori...",
+    loadMoreKeys: "Carica altre chiavi",
+    fetchAllKeys: "Recupera tutto",
+    stopFetchAll: "Interrompi",
+    fetchAllProgress: "{loaded} di {total} chiavi caricate",
+    fetchAllProgressUnknown: "{loaded} chiavi caricate",
+    items: "{count} elementi",
+    fields: "{count} campi",
+    members: "{count} membri",
+    loadedItems: "{loaded} di {total} elementi caricati",
+    loadedFields: "{loaded} di {total} campi caricati",
+    loadedMembers: "{loaded} di {total} membri caricati",
+    entries: "{count} voci",
+    noExpiry: "nessuna scadenza",
+    autoRefresh: "Aggiornamento automatico",
+    ttlDay: "{count}g",
+    columnType: "Tipo",
+    columnKey: "Chiave",
+    columnValue: "Valore",
+    columnSize: "Dimensione",
+    columnTTL: "TTL",
+    binaryStringReadonlyHint: "I valori delle stringhe binarie sono mostrati come testo con escape in modalità sola lettura; la modifica dei byte grezzi non è supportata.",
+    selectedKeys: "Chiavi selezionate",
+    deleteGroup: "Elimina gruppo",
+    deleteGroupDetails: "{target}\n{count} chiavi",
+    flushDb: "Pulisci DB corrente",
+    flushDbMessage: "Questo eliminerà ogni chiave nel database Redis corrente e non può essere annullato. Continuare?",
+    flushDbDetails: "Destinazione: Redis db{db}\nAmbito: tutte le chiavi nel DB corrente",
+    flushDbConfirm: "Pulisci DB",
+    flushDbSuccess: "Redis db{db} pulito",
+    keyDetail: "Dettaglio chiave",
+    commandLine: "Console dei comandi",
+    selectKeyForDetail: "Seleziona una chiave per visualizzare i dettagli",
+    commandWelcome: "Benvenuto nella console comandi di Redis",
+    commandPlaceholder: "Comando Redis, es. GET user:1",
+    commandPrefix: "CMD",
+    commandHint: "Inserisci un comando Redis, es. SMEMBERS feature:flags",
+    executeCommand: "Esegui comando",
+    commandEmpty: "Inserisci un comando Redis",
+    commandEmptyResult: "Esegui un comando Redis per vedere il risultato",
+    commandBlocked: "Questo comando Redis è bloccato per sicurezza",
+    createKey: "Crea chiave",
+    createKeyName: "Chiave",
+    createKeyNamePlaceholder: "user:1",
+    createKeyType: "Tipo",
+    createValue: "Valore",
+    createMember: "Membro",
+    createField: "Campo",
+    createFieldPlaceholder: "nome",
+    createScore: "Punteggio",
+    createKeyTtl: "TTL (secondi)",
+    createKeyTtlPlaceholder: "vuoto = senza scadenza",
+    createKeyAddEntry: "Aggiungi voce",
+    createKeyEntryId: "ID voce",
+    createKeyRawMode: "Input raw",
+    createKeyEntries: "Voci",
+    createValuePlaceholder: "valore",
+    createKeySubmit: "Crea",
+    createKeyNameRequired: "Inserisci un nome chiave",
+    createFieldRequired: "Inserisci un campo hash",
+    createScoreInvalid: "Inserisci un punteggio valido",
+    jsonModuleNotAvailable: "Il modulo ReJSON non è caricato su questo server Redis",
+    fieldRequired: "Inserisci un nome campo",
+    valueRequired: "Inserisci un valore",
+    memberRequired: "Inserisci un membro",
+    ttlInvalid: "Inserisci un TTL valido in secondi (-1 per nessuna scadenza)",
+    member: "Membro",
+    memberDetail: "Dettaglio membro",
+    viewMember: "Visualizza valore completo",
+    copyMember: "Copia membro",
+    copyKeyName: "Copia nome chiave",
+    copied: "Copiato",
+    copyInsertStatement: "Copia Istruzione di Inserimento",
+    copyInsertStatementBinary: "Impossibile generare l'istruzione di inserimento per dati binari",
+    editMember: "Modifica",
+    jsonView: "Visualizzazione JSON",
+    rawContent: "Contenuto grezzo",
+    wordWrap: "A capo automatico",
+    formatJson: "Formatta",
+    compressJson: "Comprimi",
+    jsonFormatError: "Formato JSON non valido",
+    clearHistory: "Cancella cronologia comandi",
+    historyCleared: "Cronologia comandi Redis cancellata",
+    blockedCommand: "Il comando {command} è bloccato per sicurezza. Disattiva l'icona scudo nella barra degli strumenti per consentirlo.",
+    pubsub: "Pub/Sub",
+    pubsubConnected: "Connesso",
+    pubsubConnecting: "Connessione in corso...",
+    pubsubDisconnected: "Disconnesso",
+    pubsubConnect: "Connetti",
+    pubsubDisconnect: "Disconnetti",
+    pubsubChannels: "Canali",
+    pubsubChannelPlaceholder: "Nome canale",
+    pubsubSubscribe: "Sottoscrivi",
+    pubsubPatterns: "Pattern",
+    pubsubPatternPlaceholder: "Pattern (es. news:*)",
+    pubsubPsubscribe: "PSottoscrivi",
+    pubsubMessages: "Messaggi",
+    pubsubClear: "Cancella",
+    pubsubEmpty: "Nessun messaggio. Sottoscrivi un canale per ricevere messaggi.",
+    pubsubPublish: "Pubblica",
+    pubsubPublishChannel: "Canale",
+    pubsubPublishMessage: "Messaggio",
+    pubsubSend: "Invia",
+    pubsubPublishFailed: "Pubblicazione fallita: {error}",
+    pubsubWsConnectFailed: "Connessione WebSocket fallita: {error}",
+    slowlog: "Slow Log",
+    slowlogCount: "Conteggio",
+    slowlogQuery: "Query",
+    slowlogNode: "Nodo",
+    slowlogSelectNode: "Seleziona un nodo",
+    slowlogNodeRequired: "Seleziona prima un nodo",
+    slowlogEmpty: "Fai clic su Query per recuperare le voci dello slow log",
+    slowlogFetchFailed: "Recupero slow log non riuscito: {error}",
+    slowlogColumnId: "ID",
+    slowlogColumnTimestamp: "Timestamp",
+    slowlogColumnDuration: "Durata (µs)",
+    slowlogColumnCommand: "Comando",
+    slowlogColumnClientAddr: "Client",
+    slowlogColumnClientName: "Nome Client",
+    slowlogTotal: "{count} voci",
+    slowlogDetailTitle: "Voce Slow Log #{id}",
+  },
+  mongo: {
+    documents: "{count} documenti",
+    addField: "Aggiungi Campo",
+    deleteField: "Elimina Campo",
+    field: "Campo",
+    value: "Valore",
+    fieldPlaceholder: "Nome campo",
+    emptyCollection: "Collezione vuota",
+    selectDocument: "Seleziona un documento",
+    readonlyId: "_id è in sola lettura",
+    invalidJsonValue: "Questa cella non contiene un valore JSON valido",
+    duplicateField: "Nome campo duplicato: {field}",
+    edit: "Modifica",
+    documentView: "Visualizzazione Documento",
+    tableView: "Visualizzazione Tabella",
+    filterPlaceholder: "Filtra...",
+    sortPlaceholder: "Ordina...",
+  },
+  vector: {
+    collectionFallback: "collezione",
+    productCollection: "Collezione {product}",
+    browse: "Sfoglia",
+    search: "Cerca",
+    upsert: "Upsert",
+    delete: "Elimina",
+    reset: "Reimposta",
+    refresh: "Aggiorna",
+    run: "Esegui",
+    apply: "Applica",
+    requestEditor: "Editor richieste vettoriali",
+    operationSuccess: "Operazione completata. L'anteprima della collezione e stata aggiornata.",
+    vectorLabel: "Vettore",
+  },
+  history: {
+    title: "Cronologia",
+    search: "Cerca nella cronologia...",
+    empty: "Ancora nessuna cronologia",
+    emptyFilteredRecent: "Nessun record corrispondente nelle ultime 200 voci della cronologia di esecuzione",
+    failed: "Non riuscita",
+    success: "Riuscita",
+    restore: "Ripristina nell'editor",
+    copy: "Copia SQL",
+    delete: "Elimina",
+    clear: "Cancella Cronologia",
+    viewDetails: "Visualizza dettagli",
+    analyzeWithAi: "Analizza con AI",
+    aiAnalyzeNoConnection: "Impossibile analizzare questa voce della cronologia poiché la sua connessione non esiste più.",
+    aiAnalysisTab: "Analisi Cronologia",
+    rollback: "Rollback",
+    rollbackSql: "SQL di Rollback",
+    rollbackAvailable: "Disponibile",
+    rollbackUnavailable: "Nessun SQL di rollback",
+    rollbackConfirm: "Eseguire l'SQL di rollback generato per questa voce della cronologia?",
+    rollbackSuccess: "Rollback eseguito",
+    rollbackFailed: "Rollback non riuscito: {message}",
+    confirmDelete: "Eliminare questa voce della cronologia?",
+    confirmClear: "Cancellare tutta la cronologia?",
+    filters: {
+      all: "Tutti",
+      query: "Query",
+      data_change: "Modifiche dati",
+      schema_change: "Modifiche schema",
+      failed: "Non riuscite",
+    },
+    dateRange: {
+      title: "Intervallo di tempo",
+      label: "Ora di esecuzione:",
+      start: "Data iniziale",
+      end: "Data finale",
+      apply: "Applica",
+      clear: "Cancella",
+      invalid: "La data iniziale non può essere successiva alla data finale",
+      unboundedStart: "Inizio",
+      unboundedEnd: "Fine",
+    },
+    kinds: {
+      query: "Query",
+      data_change: "Modifica dati",
+      schema_change: "Modifica schema",
+      import: "Importazione",
+      transfer: "Trasferimento",
+      redis_command: "Comando Redis",
+    },
+    kindShort: {
+      query: "SQL",
+      data_change: "Dati",
+      schema_change: "DDL",
+      import: "Importa",
+      transfer: "Sposta",
+      redis_command: "Redis",
+    },
+    detail: {
+      kind: "Tipo",
+      operation: "Operazione",
+      connection: "Connessione",
+      database: "Database",
+      target: "Destinazione",
+      time: "Ora",
+      duration: "Durata",
+      affectedRows: "Righe interessate",
+      rollback: "Rollback",
+      status: "Stato",
+      error: "Errore",
+    },
+  },
+  dangerDialog: {
+    title: "Operazione Pericolosa",
+    message: "Questa istruzione SQL potrebbe modificare o eliminare i dati in modo irreversibile. Sei sicuro di volerla eseguire?",
+    redisCommandMessage: "Questo comando Redis può modificare i dati e non può essere annullato automaticamente. Continuare?",
+    suppressFuturePrompts: "Non chiedere più per SQL pericolosi",
+    wrapLines: "Attiva/disattiva ritorno a capo",
+    deleteMessage: "Questa operazione di eliminazione potrebbe essere irreversibile. Continuare?",
+    deleteConfirm: "Conferma Eliminazione",
+    deleteRowMessage: "Questa riga verrà contrassegnata per l'eliminazione e rimossa dal database dopo il salvataggio. Continuare?",
+    deleteRowsMessage: "Queste {count} righe verranno contrassegnate per l'eliminazione e rimosse dal database dopo il salvataggio. Continuare?",
+    deleteRowDetails: "Tabella: {table}",
+    deleteRowDetailsNoTable: "Riga del risultato corrente",
+    redisKeyDetails: "Chiave Redis: {key}",
+    redisHashFieldDetails: "Hash Redis: {key}\nCampo: {field}",
+    redisListItemDetails: "Lista Redis: {key}\nIndice: {index}",
+    redisSetMemberDetails: "Set Redis: {key}\nMembro: {member}",
+    mongoDocumentDetails: "Collezione MongoDB: {collection}\n_id Documento: {id}",
+    mongoFieldDetails: "Campo: {field}",
+    mongoArrayItemDetails: "Indice elemento array: {index}",
+    cancel: "Annulla",
+    confirm: "Esegui",
+  },
+  sqlParameters: {
+    title: "Parametri SQL",
+    description: "Compila i valori per i segnaposto del template SQL. DBX li sostituisce prima di eseguire l'SQL.",
+    name: "Parametro",
+    syntax: "Sintassi",
+    type: "Tipo",
+    value: "Valore",
+    valuePlaceholder: "Inserisci valore",
+    preview: "Anteprima SQL",
+    execute: "Esegui",
+    kind: {
+      string: "Stringa",
+      number: "Numero",
+      boolean: "Booleano",
+      null: "NULL",
+      raw: "SQL grezzo",
+    },
+  },
+  transfer: {
+    title: "Trasferimento Dati",
+    source: "Sorgente",
+    target: "Destinazione",
+    sourceConnection: "Connessione Sorgente",
+    sourceDatabase: "Database Sorgente",
+    sourceSchema: "Schema Sorgente",
+    targetConnection: "Connessione Destinazione",
+    targetDatabase: "Database Destinazione",
+    targetSchema: "Schema Destinazione",
+    tables: "Tabelle",
+    selectAll: "Seleziona Tutto",
+    deselectAll: "Deseleziona Tutto",
+    createTable: "Crea tabella se non esiste",
+    transferMode: "Modalità trasferimento",
+    modeAppend: "Accoda (INSERT)",
+    modeOverwrite: "Sovrascrivi (TRUNCATE + INSERT)",
+    modeUpsert: "Aggiorna/Inserisci (INSERT o UPDATE per chiave primaria)",
+    targetTableNameCase: "Maiuscole/minuscole tabella destinazione",
+    tableNameCasePreserve: "Mantieni",
+    tableNameCaseLower: "Converti in minuscolo",
+    tableNameCaseUpper: "Converti in maiuscolo",
+    batchSize: "Dimensione lotto",
+    start: "Avvia Trasferimento",
+    cancel: "Annulla",
+    progress: "Trasferimento in corso...",
+    transferring: "Trasferimento di {table}...",
+    completed: "Trasferimento completato",
+    completedWithErrors: "Completato con {count} tabella non riuscita | Completato con {count} tabelle non riuscite",
+    failed: "Trasferimento non riuscito",
+    cancelled: "Trasferimento annullato",
+    rowsTransferred: "{count} righe trasferite",
+    tableProgress: "{current} / {total} tabelle",
+    noSqlConnections: "Nessuna connessione SQL disponibile",
+    selectTables: "Seleziona le tabelle da trasferire",
+    searchTables: "Cerca tabelle...",
+    noTables: "Nessuna tabella",
+    selectSourceFirst: "Seleziona prima la connessione e il database sorgente",
+    tableError: "Tabella {table} non riuscita: {error}",
+    overallProgress: "Progresso complessivo",
+    dataTransfer: "Trasferimento Dati",
+    runInBackground: "Esegui in background",
+    newTask: "Nuovo trasferimento",
+    editConfig: "Modifica config",
+    retry: "Riprova",
+    targetTableBusy: "Un altro trasferimento sta gia scrivendo le tabelle di destinazione: {tables}",
+    ownershipTitle: "Conferma proprietario",
+    ownershipMessage: "Nel database di destinazione mancano questi utenti o ruoli proprietari: {owners}. Applicare il proprietario originale potrebbe non riuscire.",
+    ownershipSkipDetails: "Salta non eseguirà le istruzioni di modifica del proprietario degli oggetti. I dati delle tabelle e le altre strutture continueranno a essere sincronizzati.",
+    ownershipTargetOwner: "Conferma riassegnerà gli oggetti con proprietari mancanti all'utente della connessione di destinazione: {owner}.",
+    ownershipSkip: "Salta",
+    ownershipConfirm: "Conferma",
+    selectConnection: "Seleziona connessione",
+    selectDatabase: "Seleziona database",
+    selectSchema: "Seleziona schema",
+    searchConnection: "Cerca connessioni...",
+    searchDatabase: "Cerca database...",
+    searchSchema: "Cerca schemi...",
+  },
+  tableImport: {
+    title: "Importa Dati Tabella",
+    target: "Tabella di destinazione",
+    selectFile: "Seleziona File",
+    changeFile: "Change File",
+    noFileSelected: "No file selected",
+    sourceFile: "Source file",
+    sourceFormat: "Source format",
+    stepSource: "Source",
+    stepOptions: "Options",
+    stepMapping: "Mapping",
+    stepReview: "Review",
+    stepExecution: "Run",
+    formatCsv: "CSV",
+    formatCsvDescription: "Comma-separated text",
+    formatTsv: "TSV",
+    formatTsvDescription: "Tab-separated text",
+    formatDelimited: "Delimited",
+    formatDelimitedDescription: "Custom text delimiter",
+    formatJson: "JSON",
+    formatJsonDescription: "Object or array rows",
+    formatExcel: "Excel",
+    formatExcelDescription: "XLS, XLSX, XLSM",
+    previewRows: "Preview rows",
+    delimiter: "Delimiter",
+    hasHeader: "First row is header",
+    trimValues: "Trim values",
+    emptyStringAsNull: "Empty string as NULL",
+    jsonShape: "JSON rows",
+    jsonShapeAuto: "Auto-detect",
+    jsonShapeObjects: "Objects",
+    jsonShapeArrays: "Arrays",
+    sheet: "Sheet",
+    firstSheet: "First sheet",
+    loadPreview: "Load Preview",
+    reloadPreview: "Reload Preview",
+    previewReady: "{rows} rows, {columns} columns",
+    file: "File",
+    rows: "Righe",
+    mapped: "Mappata",
+    mapping: "Mappatura Colonne",
+    sourceColumn: "Origine",
+    targetColumn: "Destinazione",
+    targetDataType: "Tipo",
+    createColumns: "Colonne da creare",
+    skipColumn: "Salta",
+    preview: "Anteprima",
+    mode: "Modalità importazione",
+    append: "Accoda dati",
+    truncate: "Tronca quindi importa",
+    progress: "Progresso",
+    start: "Avvia Importazione",
+    success: "Importate {count} righe",
+    back: "Back",
+    next: "Next",
+    truncateWarning: "Existing rows in the target table will be removed before import starts.",
+    requiredUnmapped: "Required target columns are not mapped: {columns}",
+    status_idle: "Ready to import",
+    status_running: "Importing data",
+    status_done: "Import complete",
+    status_error: "Import failed",
+    status_cancelled: "Import cancelled",
+  },
+  dataGenerate: {
+    title: "Generazione dati",
+    target: "Destinazione",
+    rowCount: "Righe da generare",
+    columns: "Colonne",
+    column: "Colonna",
+    type: "Tipo",
+    generator: "Generatore",
+    columnProps: "Proprietà colonna",
+    databaseObjects: "Oggetti database",
+    selectTable: "Seleziona una tabella a sinistra",
+    saveProfile: "Salva profilo",
+    loadProfile: "Carica profilo",
+    options: "Opzioni",
+    generateOrder: "Ordine generazione",
+    nextStep: "Avanti",
+    insertSuccess: "{count} righe inserite",
+    noData: "No data yet, please configure generation rules first",
+    noResult: "No execution results",
+    regenerate: "Rigenera",
+    first50Rows: "Mostra le prime 50 righe, totale {count} righe",
+    resultTitle: "Risultati esecuzione",
+    successLabel: "{count} riuscite",
+    failLabel: "{count} non riuscite",
+    totalLabel: "/ {count} righe",
+    copyAllSql: "Copia tutto SQL",
+    prevStep: "Precedente",
+    startInsert: "Avvia inserimento",
+    confirm: "Conferma",
+    back: "Indietro",
+    reset: "Reimposta",
+    selectGenerator: "Select a generator...",
+    selectGeneratorHint: "Please select a generator",
+    preview: "Anteprima",
+    noValue: "(nessuno)",
+    startDate: "Start Date",
+    endDate: "End Date",
+    allDay: "All day",
+    startTime: "Start Time",
+    endTime: "End Time",
+    weekday: "Weekday",
+    all: "All",
+    weekdayOnly: "Weekdays",
+    custom: "Custom",
+    values: "Values",
+    min: "Min",
+    max: "Max",
+    increment: "Incremento",
+    cycle: "Cycle when exceeded",
+    includeDefault: "Include DEFAULT",
+    includeNull: "Include NULL",
+    unique: "Set unique",
+    disableLinks: "Disable data links between columns",
+    imageMode: "Mode",
+    generate: "Generate",
+    fromFolder: "From folder",
+    imageWidth: "Image Width",
+    imageHeight: "Image Height",
+    imageFormat: "Image Format",
+    folderPath: "Folder Path",
+    filterByExtension: "Filter by extensions",
+    errorContinue: "Continue on error",
+    truncateBefore: "Truncate table before generation",
+    useTransaction: "Use transaction",
+    extendedInsert: "Use extended INSERT",
+    ok: "OK",
+    noTablesSelected: "No tables selected",
+    orderHint: "Use arrow buttons to reorder",
+    gen: {
+      general: "General",
+      personal: "Personal",
+      payment: "Payment",
+      business: "Business",
+      location: "Location",
+      product: "Product",
+      computer: "Computer",
+      number: "Number",
+      datetime: "Date Time",
+      date: "Date",
+      time: "Time",
+      sequence: "Sequence",
+      enum: "Enum",
+      text: "Text",
+      image: "Image or Binary",
+      foreign_key: "Foreign Key",
+      uuid: "UUID",
+      regex: "Regex",
+      full_name: "Full Name",
+      gender: "Gender",
+      title: "Title",
+      marital_status: "Marital Status",
+      phone: "Phone",
+      email: "Email",
+      job_title: "Job Title",
+      social_id: "Social ID",
+      payment_method: "Payment Method",
+      credit_card_type: "Credit Card Type",
+      credit_card_number: "Credit Card Number",
+      credit_card_date: "Credit Card Date",
+      company_name: "Company Name",
+      department: "Department",
+      industry: "Industry",
+      address: "Address",
+      city: "City",
+      region: "Region",
+      product_name: "Product Name",
+      product_category: "Product Category",
+      color: "Color",
+      size: "Size",
+      weight_unit: "Weight Unit",
+      barcode: "Barcode",
+      sku: "SKU",
+      ip_address: "IP Address",
+      mac_address: "MAC Address",
+      file_path: "File Path",
+      file_name: "File Name",
+      file_extension: "File Extension",
+      url: "URL",
+      hostname: "Hostname",
+      id_number: "Numero documento",
+    },
+    idTypes: {
+      title: "Tipo documento",
+      customPattern: "Pattern personalizzato",
+      customPatternPlaceholder: "es. ([A-Z]{2})-([0-9]{8})",
+      customPatternHint: "Supporta pattern semplici come [A-Z] lettere, [0-9] cifre, {n} ripetizioni, trattini",
+      id_card: "Carta d'identità cinese",
+      passport: "Passaporto",
+      hk_macau_pass: "Permesso HK/Macao",
+      taiwan_pass: "Permesso Taiwan",
+      uscc: "Codice sociale unificato",
+      bank_card: "Carta bancaria",
+      drivers_license: "Patente di guida",
+      custom: "Personalizzato",
+    },
+  },
+  tableToolbox: {
+    title: "Strumenti dati",
+    generateData: "Genera dati",
+    importData: "Importa dati",
+    exportData: "Esporta dati",
+    generateDataComingSoon: "Prossimamente",
+  },
+  sqlFile: {
+    title: "Esegui File SQL",
+    file: "File",
+    selectSqlFile: "Seleziona file SQL",
+    browse: "Sfoglia",
+    previewingLines: "Anteprima di {count} righe",
+    previewingFirstLines: "Anteprima delle prime {count} righe",
+    target: "Destinazione",
+    connection: "Connessione",
+    selectConnection: "Seleziona connessione",
+    database: "Database",
+    selectDatabase: "Seleziona database",
+    databasePlaceholder: "Nome database",
+    options: "Opzioni",
+    continueOnError: "Continua in caso di errore",
+    runInBackground: "Esegui in background",
+    cancelling: "Annullamento in corso...",
+    cancel: "Annulla",
+    execute: "Esegui",
+    statement: "Istruzione",
+    succeeded: "Riuscito",
+    failed: "Non riuscito",
+    affectedRows: "Righe interessate",
+    currentStatement: "Istruzione corrente",
+    status: {
+      idle: "Inattivo",
+      started: "Avviato",
+      running: "In esecuzione",
+      statementDone: "Istruzione completata",
+      statementFailed: "Istruzione non riuscita",
+      done: "Completato",
+      error: "Errore",
+      cancelled: "Annullato",
+    },
+  },
+  diff: {
+    title: "Confronta Schemi",
+    source: "Sorgente",
+    target: "Destinazione",
+    selectConnection: "Seleziona connessione",
+    selectDatabase: "Seleziona database",
+    selectSchema: "Seleziona schema",
+    connection: "Connessione",
+    database: "Database",
+    schema: "Schema",
+    recentConfigs: "Configurazioni Recenti",
+    selectRecentConfig: "Seleziona configurazione recente",
+    ignoreComments: "Ignora differenze nei commenti",
+    compare: "Confronta",
+    comparing: "Confronto degli schemi...",
+    noDifferences: "Nessuna differenza trovata",
+    table: "Tabella",
+    status: "Stato",
+    details: "Dettagli",
+    added: "Aggiunta",
+    removed: "Rimossa",
+    modified: "Modificata",
+    indexes: "Indici",
+    foreignKeys: "Chiavi esterne",
+    triggers: "Trigger",
+    comments: "Commenti",
+    newTable: "Nuova tabella",
+    dropTable: "Elimina tabella",
+    generatedSql: "SQL di Sincronizzazione",
+    copySql: "Copia SQL",
+    executeSync: "Esegui Sincronizzazione",
+    syncSuccess: "Sincronizzazione eseguita con successo",
+    swap: "Inverti sorgente e destinazione",
+    syncProgress: "Esecuzione in corso: {current}/{total}",
+    syncSummary: "Riuscite {success}, non riuscite {failed}",
+    configSaved: "Configurazione salvata",
+    configDeleted: "Configurazione eliminata",
+    sourceObject: "Oggetto sorgente",
+    targetObject: "Oggetto destinazione",
+    operation: "Operazione",
+    selectedCount: "{selected} selezionati di {total}",
+    saveConfig: "Salva configurazione",
+    loadConfig: "Carica configurazione",
+    options: "Opzioni",
+    ddlCompare: "Confronto DDL",
+    deployScript: "Script di deploy",
+    deployScriptAll: "Tutti gli script di deploy",
+    deployScriptDesc: "Script SQL per l'oggetto selezionato",
+    deployScriptAllDesc: "Script SQL per tutti gli oggetti selezionati",
+    copy: "Copia",
+    execute: "Esegui",
+    executeAll: "Esegui tutto",
+    executeSuccess: "Eseguito con successo",
+    selectObjectToCompare: "Seleziona un oggetto per visualizzare il confronto DDL",
+    noDdlAvailable: "Nessun DDL disponibile",
+    noDeployScript: "Nessuno script di deploy",
+    noDeployScriptAll: "Nessuno script di deploy per gli oggetti selezionati",
+    sourceDdl: "DDL Sorgente",
+    targetDdl: "DDL Destinazione",
+    objectNotExistsInSource: "Questo oggetto non esiste nel database sorgente",
+    objectNotExistsInTarget: "Questo oggetto non esiste nel database di destinazione",
+    nextStepDeploy: "Avanti (Revisiona Deploy)",
+    deployReview: "Revisione Deploy",
+    backToResult: "Torna al Risultato",
+    copyScript: "Copia Script",
+    exportSql: "Esporta .sql",
+    deployToServer: "Distribuisci sul Server",
+    deployConfirmTitle: "Conferma Finale",
+    deployConfirmMessage: "Stai per distribuire le seguenti modifiche al database di destinazione",
+    targetServer: "Server Destinazione",
+    dbVersion: "Versione Database",
+    targetDatabase: "Database Destinazione",
+    targetSchema: "Schema Destinazione",
+    useTransaction: "Esegui in transazione (rollback automatico in caso di errore)",
+    confirmDeploy: "Conferma Deploy",
+    exportSuccess: "Esportazione riuscita",
+    create: "Crea",
+    delete: "Elimina",
+    modify: "Modifica",
+    cancel: "Annulla",
+    prevStep: "Precedente",
+    recompare: "Confronta di nuovo",
+    maximize: "Massimizza",
+    restore: "Ripristina",
+    operationLabel: {
+      modify: "Oggetti da modificare",
+      create: "Oggetti da creare",
+      delete: "Oggetti da eliminare",
+      none: "Nessuna operazione",
+    },
+    objectKindLabel: {
+      table: "Tabella",
+      view: "Vista",
+      function: "Funzione",
+      sequence: "Sequenza",
+      rule: "Regola",
+      owner: "Proprietario",
+      index: "Indice",
+      foreignKey: "Chiave Esterna",
+      trigger: "Trigger",
+    },
+    noObjectsSelected: "Seleziona gli oggetti da distribuire",
+    deploySuccess: "Deploy Riuscito",
+    deployFailed: "Deploy Non Riuscito",
+    deploySuccessMessage: "Script SQL eseguito con successo sul database di destinazione",
+    deployFailedMessage: "Si e verificato un errore durante l'esecuzione",
+    affectedRows: "Righe Interessate",
+    executedStatements: "Istruzioni Eseguite",
+    serverVersion: "Versione Server",
+    info: "Info",
+    connType: "Tipo connessione",
+    connName: "Nome connessione",
+    host: "Host",
+    port: "Porta",
+    copied: "Copiato negli appunti",
+    saveConfigPrompt: "Inserisci nome configurazione:",
+    close: "Chiudi",
+    searchConnection: "Cerca connessioni...",
+    searchDatabase: "Cerca database...",
+    searchSchema: "Cerca schemi...",
+  },
+  schemaDiff: {
+    optionsTitle: "Opzioni di Confronto",
+    selectConfig: "Seleziona configurazione",
+    newConfigName: "Nuova Configurazione",
+    newConfig: "Nuova Configurazione",
+    renameConfig: "Rinomina Configurazione",
+    duplicateConfig: "Duplica Configurazione",
+    deleteConfig: "Elimina Configurazione",
+    exportConfig: "Esporta Configurazione",
+    exportAllConfigs: "Esporta Tutte le Configurazioni",
+    importConfig: "Importa Configurazione",
+    importFromFile: "Importa da File",
+    importFromText: "Importa da Testo",
+    importPlaceholder: "Incolla configurazione JSON...",
+    importInvalidJson: "Formato JSON non valido",
+    configName: "Nome Configurazione",
+    tableFilter: "Filtro tabella",
+    tableFilterHint: "Corrisponde ai nomi completi delle tabelle con regex. Non digitare /.../. ^ indica inizia con, $ indica finisce con, | indica o.",
+    tableFilterHintShort: "Limita confronto con regex nome tabella",
+    tableFilterHelp: "Aiuto filtro tabella",
+    tableFilterHelpRule: "Corrisponde ai nomi completi delle tabelle. Non digitare /.../.",
+    tableFilterHelpBlank: "Includi vuoto significa tutte le tabelle. Salta vuoto significa nessuna esclusione.",
+    tableFilterHelpExample: "^user_ significa inizia con user_; _bak$ significa finisce con _bak; a|b significa a o b.",
+    tableIncludePattern: "Confronta solo tabelle corrispondenti",
+    tableIncludePatternPlaceholder: "es. ^utente_",
+    tableExcludePattern: "Salta tabelle corrispondenti",
+    tableExcludePatternPlaceholder: "es. _bak$",
+    tableFilterPriority: "Quando entrambi corrispondono",
+    tableFilterPriorityExclude: "Escludi prevale",
+    tableFilterPriorityInclude: "Includi prevale",
+    options: {
+      tables: "Confronta tabelle",
+      primaryKeys: "Confronta chiavi primarie",
+      foreignKeys: "Confronta chiavi esterne",
+      uniqueKeys: "Confronta chiavi univoche",
+      checks: "Confronta vincoli check",
+      exclusions: "Confronta vincoli di esclusione",
+      views: "Confronta viste",
+      functions: "Confronta funzioni",
+      indexes: "Confronta indici",
+      sequences: "Confronta sequenze",
+      triggers: "Confronta trigger",
+      rules: "Confronta regole",
+      owners: "Confronta proprietari",
+      cascadeDelete: "Usa CASCADE delete",
+      sequenceLastValues: "Confronta ultimi valori sequenza",
+      compareColumnOrder: "Confronta ordine colonne",
+    },
+  },
+  dataCompare: {
+    title: "Confronta Dati",
+    selectTable: "Seleziona tabella",
+    searchTable: "Cerca tabelle...",
+    sourceTables: "Tabelle sorgente",
+    targetTable: "Tabella di destinazione",
+    searchTables: "Cerca tabelle...",
+    selectedTables: "{selected}/{total} selezionate",
+    selectAllTables: "Seleziona tutte",
+    deselectAllTables: "Deseleziona tutte",
+    selectSourceTables: "Seleziona prima la connessione e il database sorgente, quindi scegli le tabelle da confrontare",
+    noTables: "Nessuna tabella disponibile per il confronto",
+    autoMatchHint: "La modalità batch associa automaticamente le tabelle di destinazione con lo stesso nome",
+    matchedTables: "{matched}/{total} tabelle associate",
+    missingTargetTables: "Tabelle di destinazione con lo stesso nome mancanti: {tables}",
+    keyColumns: "Colonne Chiave",
+    keyColumnsPlaceholder: "Colonne primarie o uniche separate da virgola",
+    keyColumnsAutoHint: "Lascia vuoto per rilevare automaticamente le chiavi primarie per il confronto a tabella singola, o per tabella nel confronto batch.",
+    rowCounts: "Sorgente {source} righe, destinazione {target} righe; confronto completo completato",
+    previewLimitOption: "Anteprima {count}",
+    compare: "Confronta Dati",
+    summary: "Aggiunte {added}, rimosse {removed}, modificate {modified}",
+    batchSummary: "Confrontate {tables} tabelle: {different} diverse, {same} identiche, {failed} non riuscite; aggiunte {added}, rimosse {removed}, modificate {modified}",
+    comparingTable: "Confronto di {current}/{total}: {table}",
+    keyColumnsInline: "Colonne chiave: {columns}",
+    selectedInline: "Selezionate {selected}/{total}",
+    selectedSummary: "Selezionate: aggiunte {added}, rimosse {removed}, modificate {modified}",
+    selectAllKind: "Seleziona tutti i {kind}",
+    clearKind: "Cancella {kind}",
+    clearSelection: "Cancella tutte le selezioni",
+    showAllRows: "Mostra tutte le {count}",
+    showLessRows: "Mostra meno",
+    remainingRows: "altre {count} righe nascoste nell'anteprima",
+    planningSync: "Aggiornamento del piano di sincronizzazione...",
+    noSelectedDifferences: "Nessuna differenza selezionata per l'esecuzione",
+    planSummary: "Piano: {inserts} inserimenti, {updates} aggiornamenti, {deletes} eliminazioni, {statements} istruzioni",
+    statusDifferent: "Diverse",
+    statusSame: "Identiche",
+    statusError: "Non riuscite",
+    noKeyColumns: "Seleziona almeno una colonna chiave",
+    missingKeyColumns: "Le colonne chiave devono esistere sia nella tabella sorgente che in quella di destinazione: {columns}",
+    noCommonColumns: "Le tabelle sorgente e destinazione non hanno colonne comuni da confrontare",
+    targetTableMissing: "Tabella di destinazione non trovata: {table}",
+    noComparableTables: "Nessuna tabella confrontabile trovata. Verifica se esistono tabelle di destinazione con lo stesso nome.",
+    noDifferences: "I dati sono identici, nessun SQL di sincronizzazione necessario",
+    syncSuccess: "Sincronizzazione dei dati eseguita con successo",
+  },
+  settings: {
+    title: "Impostazioni",
+    editorTab: "Editor",
+    sqlFormatterTab: "Formattatore SQL",
+    sqlFormatterImport: "Importa configurazione",
+    sqlFormatterExport: "Esporta configurazione",
+    sqlFormatterImportSuccess: "Configurazione del formattatore importata.",
+    sqlFormatterCopyJson: "Copia JSON",
+    sqlFormatterCopyJsonSuccess: "JSON copiato.",
+    sqlFormatterCopyJsonFailed: "Copia non riuscita: {message}",
+    sqlFormatterJsonEditorLoadFailed: "Impossibile caricare l'editor JSON. Uso di un input di base: {message}",
+    sqlFormatterRestoreDefaults: "Ripristina predefiniti",
+    sqlFormatterFormMode: "Modulo",
+    sqlFormatterJsonMode: "JSON",
+    sqlFormatterKeywordCase: "Maiuscole/minuscole parole chiave",
+    sqlFormatterFunctionCase: "Maiuscole/minuscole funzioni",
+    sqlFormatterDataTypeCase: "Maiuscole/minuscole tipi di dati",
+    sqlFormatterIdentifierCase: "Maiuscole/minuscole identificatori",
+    sqlFormatterCaseUpper: "Maiuscolo",
+    sqlFormatterCaseLower: "Minuscolo",
+    sqlFormatterCasePreserve: "Mantieni",
+    sqlFormatterIndent: "Rientro",
+    sqlFormatterIndentSpaces: "Spazi",
+    sqlFormatterIndentTabs: "Tabulazioni",
+    sqlFormatterTabWidth: "Larghezza tab",
+    sqlFormatterIndentStyle: "Stile rientro",
+    sqlFormatterIndentStyleStandard: "Standard",
+    sqlFormatterIndentStyleTabularLeft: "Tabellare sinistra",
+    sqlFormatterIndentStyleTabularRight: "Tabellare destra",
+    sqlFormatterLogicalOperatorNewline: "Nuova riga operatore logico",
+    sqlFormatterLogicalBefore: "Prima dell'operatore",
+    sqlFormatterLogicalAfter: "Dopo l'operatore",
+    sqlFormatterExpressionWidth: "Larghezza espressione",
+    sqlFormatterLinesBetweenQueries: "Righe tra query",
+    sqlFormatterDenseOperators: "Operatori compatti",
+    sqlFormatterNewlineBeforeSemicolon: "Punto e virgola su nuova riga",
+    sqlFormatterAdvancedOptions: "Opzioni avanzate",
+    sqlFormatterParams: "Parametri",
+    sqlFormatterParamTypes: "Tipi parametro",
+    sqlFormatterEditorShortcuts: "Scorciatoie",
+    sqlFormatterShortcutAction: "Azione",
+    sqlFormatterShortcutEnabled: "Attiva",
+    sqlFormatterShortcutWindows: "Windows",
+    sqlFormatterShortcutLinux: "Linux",
+    sqlFormatterShortcutMacos: "macOS",
+    sqlFormatterShortcutFind: "Trova",
+    sqlFormatterShortcutReplace: "Sostituisci",
+    sqlFormatterShortcutIndentMore: "Aumenta rientro",
+    sqlFormatterShortcutIndentLess: "Riduci rientro",
+    sqlFormatterShortcutDuplicateLine: "Duplica riga corrente",
+    sqlFormatterShortcutDeleteLine: "Elimina riga corrente",
+    sqlFormatterShortcutMoveLine: "Sposta riga",
+    sqlFormatterShortcutMoveLineUp: "Sposta riga su",
+    sqlFormatterShortcutMoveLineDown: "Sposta riga giù",
+    sqlFormatterShortcutCopyLine: "Copia riga",
+    sqlFormatterShortcutCopyLineUp: "Copia riga su",
+    sqlFormatterShortcutCopyLineDown: "Copia riga giù",
+    sqlFormatterShortcutUndo: "Annulla",
+    sqlFormatterShortcutRedo: "Ripeti",
+    sqlFormatterShortcutSelectAll: "Seleziona tutto",
+    sqlFormatterShortcutFormatJson: "Formatta JSON",
+    sqlFormatterShortcutApply: "Applica configurazione",
+    sqlFormatterConfigErrorInvalidJson: "JSON non valido.",
+    sqlFormatterConfigErrorObject: "La configurazione deve essere un oggetto JSON.",
+    sqlFormatterConfigErrorVersion: "Versione configurazione non supportata.",
+    sqlFormatterConfigErrorFormatter: "Formattatore non supportato.",
+    sqlFormatterConfigErrorUnsupportedParams: "La sostituzione params non è supportata. La formattazione SQL non sostituirà i segnaposto.",
+    sqlFormatterConfigErrorOptionsObject: "Le opzioni di configurazione devono essere un oggetto JSON.",
+    sqlFormatterConfigErrorEditorObject: "La configurazione dell'editor deve essere un oggetto JSON.",
+    sqlFormatterConfigErrorEditorScope: "Ambito editor non supportato.",
+    sqlFormatterConfigErrorEditorPlatforms: "Piattaforme editor non valide.",
+    sqlFormatterConfigErrorEditorShortcutsArray: "Le scorciatoie editor devono essere un array.",
+    sqlFormatterConfigErrorEditorShortcutValue: "Scorciatoia editor non valida.",
+    sqlFormatterConfigErrorUnknownOption: "Opzione del formattatore sconosciuta: {option}.",
+    sqlFormatterConfigErrorInvalidOptionValue: "Valore non valido per {option}.",
+    sqlFormatterConfigErrorUnknownEditorShortcut: "Scorciatoia editor sconosciuta: {shortcut}.",
+    sqlFormatterConfigErrorInvalidEditorShortcut: "Scorciatoia editor non valida: {shortcut}.",
+    sqlFormatterConfigErrorDuplicateEditorShortcut: "Scorciatoia editor duplicata: {shortcut}.",
+    sqlFormatterConfigErrorInvalidConfig: "Configurazione del formattatore non valida.",
+    appearanceTab: "Aspetto",
+    navigationTab: "Navigazione",
+    dataTab: "Dati",
+    tunnelsTab: "Tunnel",
+    tunnelsDescription: "Configurazioni riutilizzabili di tunnel SSH / proxy / HTTP. Configura una volta, poi seleziona il profilo dalla scheda tunnel di una connessione; le modifiche qui si applicano a tutte le connessioni che usano il profilo.",
+    tunnelsEmpty: "Nessun profilo tunnel. Creane uno qui, poi selezionalo nelle impostazioni tunnel di una connessione.",
+    tunnelsAddSsh: "Aggiungi SSH",
+    tunnelsAddProxy: "Aggiungi proxy",
+    tunnelsAddHttp: "Aggiungi tunnel HTTP",
+    tunnelsProfileName: "Nome profilo",
+    tunnelsProfileNamePlaceholder: "es. Bastion dell'ufficio",
+    tunnelsDelete: "Elimina",
+    tunnelsUnnamedProfile: "Profilo senza nome",
+    tunnelsSave: "Salva",
+    tunnelsReset: "Ripristina",
+    tunnelsSaved: "Profili tunnel salvati",
+    tunnelsSaveFailed: "Impossibile salvare i profili tunnel: {message}",
+    tunnelsUnsavedHint: "Modifiche non salvate",
+    redisTab: "Redis",
+    shortcutsTab: "Scorciatoie",
+    snippetsTab: "Snippet",
+    syncTab: "Sincronizzazione",
+    aiTab: "AI",
+    mcpTab: "MCP",
+    jdbcTab: "Driver JDBC",
+    securityTab: "Sicurezza",
+    aboutTab: "Informazioni",
+    fontFamily: "Famiglia Carattere (Font)",
+    uiFontFamily: "Carattere interfaccia",
+    uiFontAppDefault: "Predefinito DBX",
+    uiFontSystemDefault: "Predefinito di sistema",
+    uiFontFamilyDescription: "Si applica a barra strumenti, schede, barra laterale, finestre di dialogo e altra UI fuori dall'editor.",
+    selectFont: "Seleziona font...",
+    searchFont: "Cerca font...",
+    loadingFonts: "Caricamento font...",
+    noFontsFound: "Nessun font trovato",
+    useCustomFont: "Usa “{font}”",
+    languageTitle: "Lingua / Language",
+    fontSize: "Dimensione Carattere",
+    toolbarTitle: "Barra degli strumenti",
+    toolbarHiddenHint: "Alcuni pulsanti nascosti o in eccesso appariranno nel menu «Altro».",
+    uiScale: "Scala UI",
+    uiScaleDescription: "Scala l'intera interfaccia utente desktop per display ad alta densità (High-DPI). Le modifiche si applicano immediatamente e vengono ripristinate al prossimo avvio.",
+    theme: "Tema",
+    selectTheme: "Seleziona tema...",
+    colorTheme: "Tema colore",
+    selectColorTheme: "Seleziona tema colore...",
+    themePalettePearl: "Bianco",
+    themePaletteMist: "Grigio nebbia",
+    themePaletteGraphite: "Grigio titanio",
+    themePaletteCobalt: "Blu cobalto",
+    themePaletteSage: "Verde salvia",
+    themePaletteAmber: "Giallo caldo",
+    themePaletteBlush: "Rosa sakura",
+    themePaletteVscode: "VS Code",
+    themePaletteIdea: "IDEA",
+    themePaletteXcode: "Xcode",
+    themePaletteJetbrains: "JetBrains",
+    themePaletteCursor: "Cursor",
+    themePaletteClaude: "Claude Code",
+    followAppTheme: "Segui il tema dell'applicazione",
+    appLayout: "Layout dell'Interfaccia",
+    appLayoutSeparated: "Separato moderno",
+    appLayoutSeparatedDescription: "Separazione chiara dei pannelli con schede stile blocco.",
+    appLayoutClassic: "Classico compatto",
+    appLayoutClassicDescription: "Barra delle schede continua con intestazioni di pannello compatte.",
+    iconTheme: "Stile icona e logo",
+    iconThemeDefault: "Predefinito",
+    iconThemeDefaultDescription: "Utilizza l'icona colorata dell'app DBX.",
+    iconThemeBlack: "Nero",
+    iconThemeBlackDescription: "Usa il logo DBX nero nell'app.",
+    iconThemeBlackDescriptionMac: "Usa il logo nero nell'app; il Dock usa una base nera e la barra menu segue il sistema.",
+    showTrayIcon: "Mostra icona nella barra delle applicazioni/menu",
+    showTrayIconDescription: "Se disattivato, non viene mostrata alcuna icona, ma la chiusura della finestra nasconderà comunque DBX in background.",
+    quitOnClose: "Esci alla chiusura della finestra",
+    quitOnCloseDescription: "Se attivato, il pulsante di chiusura termina completamente DBX invece di nasconderlo nella barra delle applicazioni.",
+    closeActionPromptTitle: "Chiudi finestra",
+    closeActionPromptDescription: "Scegli cosa succede quando clicchi il pulsante di chiusura. Puoi modificarlo in seguito in Impostazioni → Aspetto.",
+    closeActionQuit: "Esci da DBX",
+    closeActionMinimize: "Riduci a icona",
+    updateNotificationsEnabled: "Abilita promemoria aggiornamenti",
+    updateNotificationsEnabledDescription: "Se disattivato, DBX non controllerà automaticamente gli aggiornamenti dell'app o dei driver e non mostrerà badge. I controlli manuali restano disponibili.",
+    updateDownloadSource: "Fonte download aggiornamenti",
+    updateDownloadSourceDescription: "Scegli da dove scaricare gli installer degli aggiornamenti. La fonte ufficiale è consigliata; CNB o AtomGit possono essere più veloci sulle reti della Cina continentale.",
+    updateDownloadSourceOfficial: "Fonte ufficiale (consigliata)",
+    updateDownloadSourceCnb: "CNB",
+    updateDownloadSourceAtomgit: "AtomGit",
+    debugLoggingEnabled: "Abilita log di debug",
+    debugLoggingEnabledDescription: "Registra log diagnostici locali lato utente durante l'analisi delle segnalazioni. Disattivato per impostazione predefinita.",
+    duckDbWorkerProcessIsolation: "Modalità di isolamento del processo DuckDB (sperimentale)",
+    duckDbWorkerProcessIsolationDescription: "Esegue le query DuckDB in un processo worker separato. Se una query lunga non risponde all'annullamento, DBX può arrestare il processo worker per rilasciare il blocco del file di database.",
+    duckDbWorkerMaxProcesses: "Worker DuckDB simultanei massimi",
+    duckDbWorkerMaxProcessesDescription: "Limita quanti processi worker DuckDB DBX può eseguire contemporaneamente. Intervallo: 1-16. Predefinito: 4.",
+    duckDbWorkerProcessIsolationRestartRequired: "Riavvia DBX affinché questa modifica abbia effetto.",
+    restartDbx: "Riavvia DBX",
+    restartDbxFailed: "Impossibile riavviare DBX: {error}",
+    debugLogsCopy: "Copia log",
+    debugLogsCopied: "Copiati",
+    debugLogsDownload: "Scarica log",
+    debugLogsDownloaded: "Scaricati",
+    debugLogsClear: "Cancella log",
+    tableStructureSection: "Struttura tabella",
+    dataGridDisplay: "Visualizzazione griglia dati",
+    showColumnCommentsInHeader: "Mostra i commenti delle colonne sotto i nomi",
+    showColumnCommentsInHeaderDescription: "Visualizza i commenti delle colonne della tabella direttamente sotto i nomi delle colonne nella griglia.",
+    showColumnTypesInHeader: "Mostra i tipi di colonna sotto i nomi",
+    showColumnTypesInHeaderDescription: "Visualizza il tipo di dato di ciascuna colonna direttamente sotto i nomi delle colonne nella griglia.",
+    compactColumnHeaderActions: "Strumenti intestazione colonna compatti",
+    compactColumnHeaderActionsDescription: "Sposta gli strumenti del formattatore e dei filtri locali in un menu 'altro' in modo che i nomi delle colonne abbiano la priorità.",
+    dataGridQuickEntry: "Inserimento rapido griglia",
+    dataGridQuickEntryDescription: "Se attivo, la modifica di una cella o la compilazione della riga vuota in fondo viene salvata nel database appena il focus esce. Utile per inserimenti frequenti, ma può causare scritture accidentali.",
+    infiniteScroll: "Caricamento a scorrimento infinito",
+    autoCalculateTotalRows: "Calcola automaticamente il totale delle righe",
+    autoCalculateTotalRowsDescription: "Esegue COUNT(*) automaticamente dopo ogni query per mostrare il totale delle righe corrispondenti. Disattivato per impostazione predefinita per mantenere veloci le query grandi; puoi calcolarlo all'occorrenza dal piè di pagina dei risultati.",
+    infiniteScrollDescription: "Carica automaticamente la pagina successiva dei dati quando scorri fino in fondo alla tabella.",
+    infiniteScrollMaxRows: "Righe max a scorrimento infinito",
+    infiniteScrollMaxRowsDescription: "Numero massimo di righe da caricare in modalità scorrimento infinito (1000–50000).",
+    tableColumnTemplateFields: "Campi predefiniti per nuove tabelle",
+    tableColumnTemplateFieldsDescription: "Scegli un tipo di database e configura i tipi dei campi predefiniti usati durante la creazione di nuove tabelle.",
+    tableColumnTemplateAdd: "Aggiungi campo",
+    tableColumnTemplateColumn: "Campo",
+    tableColumnTemplateDatabase: "Database",
+    tableColumnTemplateType: "Tipo",
+    tableColumnTemplateLength: "Lunghezza",
+    tableColumnTemplateDefault: "Valore predefinito",
+    tableColumnTemplateNoPresetType: "Nessun tipo preimpostato",
+    tableColumnTemplateRequired: "Obbligatorio",
+    tableColumnTemplateComment: "Descrizione",
+    tableColumnTemplateDragHandle: "Trascina per riordinare",
+    sidebarActivation: "Attivazione barra laterale",
+    sidebarActivationSingle: "Singolo clic",
+    sidebarActivationSingleDescription: "Apri gli elementi della barra laterale con un solo clic.",
+    sidebarActivationDouble: "Doppio clic",
+    sidebarActivationDoubleDescription: "Un singolo clic seleziona le righe; un doppio clic apre gli elementi.",
+    sidebarObjectDisplay: "Layout oggetti barra laterale",
+    sidebarObjectDisplayGrouped: "Vista avanzata",
+    sidebarObjectDisplayGroupedDescription: "Raggruppa gli oggetti per tabelle, viste, procedure e funzioni per i database con più tipi di oggetti.",
+    sidebarObjectDisplaySimple: "Vista semplice",
+    sidebarObjectDisplaySimpleDescription: "Elenca tabelle e viste direttamente sotto ogni database o schema per ridurre i livelli intermedi.",
+    autoSelectActiveSidebarNode: "Seleziona sempre l'elemento aperto",
+    autoSelectActiveSidebarNodeDescription: "Quando passi da una scheda all'altra, seleziona la tabella, la collezione o il file SQL visibile corrispondente nella barra laterale.",
+    openTabsRestoreMode: "Ripristina schede all'avvio",
+    openTabsRestoreModeDescription: "Scegli come DBX ripristina le schede aperte l'ultima volta.",
+    openTabsRestoreModeAll: "Mantieni tutte le schede",
+    openTabsRestoreModePinned: "Solo schede fissate",
+    openTabsRestoreModeNone: "Non mantenere schede",
+    openTabsRestoreModeHint: "Le schede fissate restano sul lato sinistro della barra delle schede e sono utili come punti di accesso frequenti.",
+    disconnectTabHandlingMode: "Schede dopo la disconnessione",
+    disconnectTabHandlingModeDescription: "Scegli come gestire le schede correlate dopo la chiusura di una connessione o di un database.",
+    disconnectTabHandlingModeCloseTabs: "Chiudi tutte le schede",
+    disconnectTabHandlingModeCloseTabsDescription: "Chiudi tutte le schede correlate per la connessione o il database.",
+    disconnectTabHandlingModeKeepTabsClearResults: "Chiudi schede oggetti, mantieni schede SQL",
+    disconnectTabHandlingModeKeepTabsClearResultsDescription: "Chiudi i dati delle tabelle, l'esplorazione degli oggetti e le schede della struttura mantenendo le schede delle query SQL e il testo SQL, e cancella anche lo stato di esecuzione e le sessioni dei risultati.",
+    disconnectTabHandlingModeKeepTabsKeepResults: "Non chiudere le schede correlate",
+    disconnectTabHandlingModeKeepTabsKeepResultsDescription: "Mantieni le schede correlate, il testo SQL e i risultati correnti senza ulteriore pulizia.",
+    reuseDataTab: "Riusa scheda dati",
+    reuseDataTabDescription: "Quando fai clic su una tabella nella barra laterale, riutilizza la scheda dati esistente invece di crearne una nuova ogni volta.",
+    sidebarHiddenTablePrefixes: "Prefissi dei nomi delle tabelle nascosti",
+    sidebarHiddenTablePrefixesDescription: "Un prefisso per riga. Solo le etichette di tabelle, viste e collezioni della barra laterale vengono abbreviate; i suggerimenti e le azioni utilizzano ancora il nome completo.",
+    sidebarHiddenTablePrefixesPlaceholder: "Esempio:\nODS_\nT8Y2_LONG_",
+    sidebarTablePageSize: "Dimensione pagina barra laterale",
+    sidebarTablePageSizeDescription: "Numero massimo di tabelle/oggetti caricati per pagina nell'albero laterale. Aumentalo se hai molte tabelle per ridurre le pagine.",
+    sidebarTableSearchEnabled: "Abilita ricerca tabelle nel database",
+    sidebarTableSearchEnabledDescription: "Mostra una casella di ricerca locale sotto database, schema o gruppi di tabelle espansi per filtrare le tabelle separatamente.",
+    sidebarHideTableComments: "Nascondi i commenti delle tabelle nella barra laterale",
+    sidebarHideTableCommentsDescription: "Nascondi i commenti in linea delle tabelle/viste mostrati accanto ai nomi nell'albero della barra laterale per risparmiare spazio orizzontale.",
+    sidebarAllowHorizontalScroll: "Consenti scorrimento orizzontale barra laterale",
+    sidebarAllowHorizontalScrollDescription: "Mostra i nomi lunghi di tabelle, viste e collezioni per intero consentendo lo scorrimento orizzontale della barra laterale.",
+    snippetsDescription: "Personalizza i modelli di snippet SQL attivati nell'editor.",
+    snippetsAdd: "Aggiungi Snippet",
+    snippetsLabel: "Etichetta",
+    snippetsPrefix: "Prefisso",
+    snippetsStatus: "Stato",
+    snippetsEnabled: "Attivo",
+    snippetsDisabled: "Disattivo",
+    snippetsToggle: "Attiva o disattiva snippet",
+    snippetsBody: "Corpo SQL",
+    snippetsLabelPlaceholder: "es. select *",
+    snippetsPrefixPlaceholder: "es. sel",
+    snippetsBodyPlaceholder: "SELECT *\nFROM tabella\nLIMIT 100;",
+    snippetsRestoreDefaults: "Ripristina Predefiniti",
+    snippetsAddTitle: "Aggiungi Snippet",
+    snippetsEditTitle: "Modifica Snippet",
+    syncWebDavTitle: "Sincronizzazione WebDAV",
+    syncWebDavDescription: "Carica o ripristina uno snapshot di DBX, inclusa la libreria SQL salvata, da un servizio di archiviazione compatibile con WebDAV.",
+    syncEndpoint: "URL WebDAV",
+    syncUsername: "Nome utente",
+    syncPassword: "Password",
+    syncPasswordPlaceholder: "Inserisci password",
+    syncClearSavedPassword: "Cancella password salvata",
+    syncRememberWebDavPassword: "Ricorda la password dell'app WebDAV",
+    syncSavedPassword: "(salvata)",
+    syncRememberWebDavPasswordDescription: "La password viene crittografata e memorizzata solo su questo dispositivo. Non viene sincronizzata su WebDAV e non sostituisce la password di sincronizzazione.",
+    syncRemotePath: "Percorso snapshot remoto",
+    syncRemotePathDescription: "DBX creerà le cartelle superiori mancanti durante il caricamento.",
+    syncSecretNotice: "Per impostazione predefinita, DBX sincronizza solo i dettagli e le impostazioni di connessione. Le password dei database, le password SSH, le password proxy, le stringhe di connessione e le chiavi API AI rimangono locali.",
+    syncSecrets: "Sincronizza i segreti crittografati",
+    syncSecretsDescription: "Se abilitato, DBX crittografa le password del database, le password SSH e le chiavi API AI prima di caricarle su WebDAV.",
+    syncSecretsPassphrase: "Password di sincronizzazione",
+    syncSecretsPassphraseDescription: "Questa password viene utilizzata solo per crittografare e ripristinare i dati sensibili. DBX non la salva; inseriscila nuovamente su ciascun dispositivo.",
+    syncTest: "Verifica",
+    syncUpload: "Carica",
+    syncDownload: "Scarica",
+    syncTestSuccess: "La destinazione WebDAV è raggiungibile.",
+    syncUploadSuccess: "Caricati {bytes} byte su {path}.",
+    syncAutoUpload: "Carica automaticamente gli snapshot",
+    syncAutoUploadInterval: "Ogni",
+    syncAutoUploadMinutes: "minuti",
+    syncAutoUploadDescription: "Viene eseguito mentre DBX è aperto. I download richiedono ancora conferma manuale per evitare di sostituire SQL salvati localmente.",
+    syncAutoUploadSuccess: "Caricati automaticamente {bytes} byte su {path}.",
+    syncDownloadSuccess: "Scaricati e applicati {bytes} byte da {path}.",
+    syncSecretsApplied: "I segreti crittografati sono stati ripristinati.",
+    syncSecretsSkipped: "I segreti crittografati erano presenti ma non sono stati ripristinati.",
+    syncDownloadConfirm: "Scaricare e applicare lo snapshot DBX remoto? I metadati locali e i file SQL salvati verranno sostituiti.",
+    apply: "Applica",
+    applyAndClose: "Applica e Chiudi",
+    reset: "Reimposta",
+    resetDefaults: "Ripristina Predefiniti",
+    resetAllDefaults: "Ripristina Tutti i Predefiniti",
+    save: "Salva",
+    cancel: "Annulla",
+    executeMode: "Modalità Esecuzione (Cmd+Enter)",
+    executeModeAll: "Esegui tutto l'SQL",
+    executeModeCurrent: "Esegui istruzione al cursore",
+    showExecutionTargetPicker: "Mostra selettore destinazione",
+    showExecutionTargetPickerDescription: "Se attivo, l'esecuzione senza selezione permette di scegliere tra istruzione corrente e tutto l'SQL.",
+    showStatementRunButtons: "Mostra pulsanti di esecuzione laterali",
+    showStatementRunButtonsDescription: "Mostra nel margine dell'editor SQL i pulsanti per eseguire ogni istruzione. Scorciatoie da tastiera e menu contestuale continuano a funzionare quando disattivati.",
+    showCurrentStatementFrame: "Mostra cornice istruzione corrente",
+    showCurrentStatementFrameDescription: "Se attivo, l'editor SQL disegna un contorno intorno all'istruzione eseguibile corrente; se disattivato, il contorno è nascosto.",
+    showInsertValueHints: "Mostra suggerimenti colonne nei VALUES di INSERT",
+    showInsertValueHintsDescription: "Se attivo, l'editor SQL mostra il nome della colonna accanto a ogni valore nelle clausole INSERT ... VALUES.",
+    previewStatementRunButton: "Pulsante di esecuzione istruzione in anteprima",
+    wordWrap: "A capo automatico",
+    wordWrapDescription: "Incolonna le righe SQL lunghe entro la larghezza dell'editor",
+    vimMode: "Modalita Vim",
+    vimModeDescription: "Usa la modifica modale in stile Vim nell'editor SQL",
+    autoCloseBrackets: "Chiusura automatica parentesi",
+    autoCloseBracketsDescription: "Inserisci automaticamente parentesi e virgolette di chiusura quando digiti quelle di apertura",
+    sqlSemanticDiagnosticsEnabled: "Diagnostica semantica SQL",
+    sqlSemanticDiagnosticsEnabledDescription: "Se abilitata, l'editor segnala problemi semantici come tabelle e colonne sconosciute. Disabilitala per ridurre l'analisi e i controlli dei metadati per file SQL di grandi dimensioni.",
+    confirmDangerousSqlExecution: "Conferma prima di SQL pericoloso",
+    confirmDangerousSqlExecutionDescription: "Se disattivato, ALTER, DROP, DELETE, TRUNCATE e altri SQL pericolosi verranno eseguiti senza la finestra di avviso.",
+    confirmUnsavedSqlClose: "Conferma prima di chiudere SQL non salvato",
+    confirmUnsavedSqlCloseDescription: "Se disattivato, le schede SQL con modifiche non salvate verranno chiuse o usciranno senza la finestra di conferma di salvataggio.",
+    sqlVariableSyntax: "Sostituzione di variabili e segnaposto SQL",
+    sqlVariableSyntaxDescription: "Scegli quali sintassi di variabili e segnaposto DBX sostituisce prima di eseguire SQL, per tipo di database. Tutte abilitate per impostazione predefinita.",
+    sqlVariableSyntax_positional: "Segnaposto posizionale",
+    sqlVariableSyntax_positionalDescription: "Richiede un valore per sostituire ogni segnaposto posizionale in ordine.",
+    sqlVariableSyntax_named: "Segnaposto con nome",
+    sqlVariableSyntax_namedDescription: "Richiede un valore per sostituire i segnaposto con nome.",
+    sqlVariableSyntax_shell: "Segnaposto stile shell",
+    sqlVariableSyntax_shellDescription: "Richiede un valore per sostituire i segnaposto in stile shell.",
+    sqlVariableSyntax_mybatis: "Segnaposto stile MyBatis",
+    sqlVariableSyntax_mybatisDescription: "Richiede un valore per sostituire i segnaposto in stile MyBatis.",
+    sqlVariableSyntax_sqlserver: "Segnaposto stile SQL Server",
+    sqlVariableSyntax_sqlserverDescription: "Richiede un valore per sostituire i segnaposto in stile SQL Server (possono entrare in conflitto con le variabili di sessione).",
+    sqlVariableSyntax_atSet: "Espansione di variabili inline",
+    sqlVariableSyntax_atSetDescription: "Espande le dichiarazioni di variabili inline e ne sostituisce i valori prima dell'esecuzione.",
+    autoAliasTables: "Aggiungi alias tabella automaticamente",
+    autoAliasTablesDescription: "Quando scegli una tabella in FROM o JOIN, inserisce un alias generato come order_items AS oi.",
+    redisScanPageSize: "Conteggio scansione Redis",
+    redisScanPageSizeDescription: "Chiavi richieste per pagina SCAN di Redis durante la navigazione delle chiavi.",
+    redisScanPageSizeOption: "{count} chiavi",
+    exportBatchSize: "Dimensione del lotto di esportazione",
+    exportBatchSizeDescription: "Righe recuperate per lotto durante l'esportazione dei dati della tabella (100-100000).",
+    exportRowLimitEnabled: "Limita righe esportate",
+    exportRowLimitEnabledDescription: "Quando attivo, l'esportazione dei risultati di query e dei dati tabella si ferma al limite di righe sotto.",
+    exportRowLimit: "Limite righe esportazione dati",
+    exportRowLimitDescription: "Numero massimo di righe per l'esportazione dei risultati di query e dei dati tabella.",
+    exportRowLimitUnlimited: "Illimitato",
+    queryExportKeysetOptimizationEnabled: "Prova ottimizzazione keyset",
+    queryExportKeysetOptimizationEnabledDescription: "Si applica solo a query a tabella singola riconosciute in sicurezza; le query complesse ricadono automaticamente.",
+    exportSection: "Esportazione",
+    shortcutExecuteSql: "Esegui SQL",
+    shortcutFind: "Trova",
+    shortcutReplace: "Sostituisci",
+    shortcutSaveSql: "Salva SQL",
+    shortcutAcceptCompletion: "Accetta completamento",
+    shortcutFormatSql: "Formatta SQL",
+    shortcutToggleLineComment: "Attiva/disattiva commento di riga",
+    shortcutIndentMore: "Aumenta rientro",
+    shortcutIndentLess: "Riduci rientro",
+    shortcutDuplicateLine: "Duplica riga corrente",
+    shortcutDeleteLine: "Elimina riga corrente",
+    shortcutMoveLineUp: "Sposta riga su",
+    shortcutMoveLineDown: "Sposta riga giù",
+    shortcutCopyLineUp: "Copia riga su",
+    shortcutCopyLineDown: "Copia riga giù",
+    shortcutUndo: "Annulla",
+    shortcutRedo: "Ripeti",
+    shortcutSelectAll: "Seleziona tutto",
+    shortcutCopyCurrentRow: "Copia riga dati corrente",
+    shortcutDeleteCurrentRow: "Elimina riga dati corrente",
+    shortcutNewQuery: "Nuova query",
+    shortcutOpenSettings: "Apri impostazioni",
+    shortcutCloseTab: "Chiudi scheda",
+    shortcutFocusSearch: "Focalizza ricerca",
+    shortcutQuickOpen: "Apertura rapida (ricerca tutti gli oggetti del database)",
+    shortcutSwitchToPreviousTab: "Passa alla scheda precedente",
+    shortcutSwitchToNextTab: "Passa alla scheda successiva",
+    shortcutSwitchToTab1: "Passa alla scheda 1",
+    shortcutSwitchToTab2: "Passa alla scheda 2",
+    shortcutSwitchToTab3: "Passa alla scheda 3",
+    shortcutSwitchToTab4: "Passa alla scheda 4",
+    shortcutSwitchToTab5: "Passa alla scheda 5",
+    shortcutSwitchToTab6: "Passa alla scheda 6",
+    shortcutSwitchToTab7: "Passa alla scheda 7",
+    shortcutSwitchToTab8: "Passa alla scheda 8",
+    shortcutSwitchToTab9: "Passa alla scheda 9",
+    shortcutZoomInUi: "Ingrandisci UI",
+    shortcutZoomOutUi: "Rimpicciolisci UI",
+    shortcutResetUiZoom: "Reimposta zoom UI",
+    shortcutRefreshData: "Aggiorna dati",
+    shortcutToggleTranspose: "Attiva/disattiva vista trasposta",
+    shortcutCancelSearch: "Annulla ricerca",
+    shortcutToggleSidebar: "Attiva/disattiva barra laterale",
+    shortcutCopySidebarSelection: "Copia selezione barra laterale",
+    shortcutPasteSidebarSelection: "Incolla nella barra laterale",
+    shortcutEditSidebarConnection: "Modifica connessione barra laterale",
+    shortcutSendSelectionToAi: "Invia selezione ad AI",
+    shortcutScopeGlobal: "Globale",
+    shortcutScopeEditor: "Editor SQL",
+    shortcutScopeGrid: "Griglia dati",
+    shortcutScopeSearch: "Cerca campi",
+    shortcutScopeSidebar: "Barra laterale",
+    shortcutPressShortcut: "Premi scorciatoia",
+    shortcutSearchPlaceholder: "Cerca scorciatoie",
+    shortcutSearchNoResults: "Nessuna scorciatoia corrisponde alla ricerca.",
+    shortcutConflict: "Questa scorciatoia è in conflitto con un'altra azione nello stesso ambito.",
+    shortcutClear: "Cancella scorciatoia",
+    preview: "Anteprima in tempo reale",
+    customTheme: "Tema personalizzato",
+    customThemeConfigure: "Configura tema personalizzato",
+    customThemeTitle: "Configurazione tema personalizzato",
+    customThemeMyThemes: "I miei temi",
+    customThemeNewTheme: "Nuovo tema",
+    customThemeVisualEdit: "Editor visuale",
+    customThemeJsonConfig: "Configurazione JSON",
+    customThemeLivePreview: "Anteprima in tempo reale",
+    customThemePreviewExample: "Esempio di query",
+    customThemePreset: "Tema predefinito",
+    customThemeSelectPreset: "Seleziona tema predefinito...",
+    customThemeApply: "Applica",
+    customThemePasteImport: "Importa da testo incollato",
+    customThemeExportJson: "Esporta JSON",
+    customThemeSaveAndApply: "Salva e applica",
+    customThemeKeyword: "Parola chiave",
+    customThemeField: "Campo/Variabile",
+    customThemeFunction: "Funzione",
+    customThemeString: "Stringa",
+    customThemeNumber: "Numero",
+    customThemeComment: "Commento",
+    customThemeTable: "Tabella",
+    customThemeOperator: "Operatore",
+    customThemeType: "Tipo",
+    customThemeBuiltin: "Integrato",
+    customThemeBackground: "Sfondo",
+    customThemeForeground: "Primo piano",
+    customThemeDefaultName: "Tema personalizzato",
+    customThemeCopySuffix: " Copia",
+    customThemeApplied: 'Schema colori "{name}" applicato',
+    customThemeKeepOne: "Mantieni almeno un tema",
+    customThemeJsonError: "Formato JSON non valido, controlla",
+    jdbcPlugin: "Plugin DBX JDBC",
+    jdbcPluginInstall: "Installa plugin JDBC",
+    jdbcPluginInstallSuccess: "Plugin JDBC installato",
+    jdbcPluginUpdate: "Aggiorna",
+    jdbcPluginUninstall: "Disinstalla",
+    jdbcPluginUninstallSuccess: "Plugin JDBC disinstallato",
+    jdbcPluginInstalled: "Installato: v{version}",
+    jdbcPluginIncompatible: "Protocollo incompatibile",
+    jdbcPluginNotInstalled: "Non installato",
+    jdbcDrivers: "JAR del driver JDBC",
+    jdbcImport: "Importa JAR",
+    jdbcImportPath: "Percorso di importazione",
+    jdbcDriverPathPlaceholder: "/percorso/per/driver.jar",
+    jdbcImportSuccess: "Importato/i {count} file del driver",
+    jdbcDeleteSuccess: "Driver rimosso",
+    jdbcNoDrivers: "Nessun driver JDBC ancora importato.",
+    mcpTitle: "Server MCP",
+    mcpDescription: "Verifica l'installazione e la versione del Server DBX MCP utilizzata da Claude Code, Cursor e altri agenti.",
+    mcpChecking: "Verifica in corso",
+    mcpStatusUnknown: "Non verificato",
+    mcpStatusError: "Verifica non riuscita",
+    mcpReady: "Pronto",
+    mcpNotInstalled: "Non installato",
+    mcpUpdateAvailable: "Aggiornamento disponibile",
+    mcpCurrent: "Versione corrente",
+    mcpLatest: "Ultima versione",
+    mcpVersionMissing: "Nessuna installazione globale rilevata",
+    mcpVersionUnknown: "Sconosciuta",
+    mcpAvailable: "Disponibile",
+    mcpUnavailable: "Non disponibile",
+    mcpBinPath: "Comando path",
+    mcpInstallCommand: "Comando di installazione",
+    mcpUpdateCommand: "Comando di aggiornamento",
+    mcpInstallButton: "Installa",
+    mcpUpdateButton: "Aggiorna",
+    mcpUpToDate: "Aggiornato",
+    mcpInstalling: "Installazione...",
+    mcpInstallSuccess: "Installazione completata",
+    mcpInstallFailed: "Installazione fallita",
+    mcpConfig: "Configurazione MCP",
+    mcpConfigOptionsHint: "Queste opzioni aggiornano solo la configurazione generata. Copiala nel client AI e riavvia la sessione MCP per applicarla.",
+    mcpCodexConfig: "Configurazione Codex",
+    mcpCodexConfigPath: "Codex può utilizzare ~/.codex/config.toml o un .codex/config.toml a livello di progetto.",
+    mcpCursorConfigPath: "Cursor può usare .cursor/mcp.json nel progetto o ~/.cursor/mcp.json globalmente.",
+    mcpTraeConfigPath: "TRAE: Impostazioni > MCP > Aggiungi > Aggiungi manualmente, poi incolla la configurazione JSON.",
+    mcpVsCodeConfigPath: "VS Code/Copilot può usare .vscode/mcp.json nell'area di lavoro o mcp.json nel profilo utente.",
+    mcpWindsurfConfigPath: "Windsurf può usare ~/.codeium/windsurf/mcp_config.json.",
+    mcpOpenCodeConfigPath: "~/.config/opencode/opencode.json globalmente, o opencode.json a livello di progetto.",
+    mcpReadonlyMode: "Modalità sola lettura",
+    mcpReadonlyModeDescription: "Aggiunge DBX_MCP_ALLOW_WRITES=0 alla configurazione di esempio in modo che la sessione MCP rimanga di sola query.",
+    mcpAllowDangerous: "Consenti SQL pericoloso",
+    mcpAllowDangerousDescription: "Aggiunge DBX_MCP_ALLOW_DANGEROUS_SQL=1 alla configurazione di esempio in modo che siano consentite istruzioni come DROP, TRUNCATE, ALTER e simili.",
+    mcpDetectionTiming: "DBX esegue la verifica automaticamente all'apertura di questa pagina; usa di nuovo Verifica per aggiornare.",
+    mcpNpmBoundary: "DBX verifica e spiega solo lo stato di MCP; l'installazione e gli aggiornamenti vengono comunque eseguiti tramite npm.",
+    mcpRefresh: "Verifica di nuovo",
+    mcpGuide: "Guida MCP",
+    supportInfoTitle: "Informazioni di supporto",
+    supportInfoDescription: "Copia questi dettagli dell'ambiente quando apri issue o chiedi aiuto.",
+    supportInfoCopy: "Copia informazioni",
+    supportInfoCopied: "Copiato",
+    supportInfoLoading: "Caricamento informazioni di supporto...",
+    supportInfoLoadFailed: "Impossibile caricare tutte le informazioni di supporto: {message}",
+    supportInfoAppVersion: "Versione DBX",
+    supportInfoRuntime: "Ambiente",
+    supportInfoRuntimeDesktop: "Desktop",
+    supportInfoRuntimeWeb: "Web",
+    supportInfoOperatingSystem: "Sistema operativo",
+    supportInfoArchitecture: "Architettura",
+    supportInfoUnknown: "Sconosciuto",
+    community: "Community",
+    qqGroup: "Gruppo QQ",
+    wechatGroup: "Gruppo WeChat",
+    wechatGroupInvite: "Invito Tencent Docs",
+    project: "Progetto",
+    openSource: "Repository open-source",
+    officialDocs: "Documenti ufficiali",
+    shortcutUppercaseSelection: "Converti selezione in maiuscolo",
+    shortcutLowercaseSelection: "Converti selezione in minuscolo",
+    shortcutExPasteSqlInCondition: "ExPaste: incolla come condizione IN",
+  },
+  driverStore: {
+    progressJreExtract: "Estrazione JRE...",
+    progressDownloadJre: "Download JRE in corso",
+    progressDownloadDriver: "Download driver in corso",
+    progressDownloadJdbcPlugin: "Download plugin JDBC in corso",
+    progressJdbcPluginExtract: "Installazione plugin JDBC...",
+    usageTitle: "Utilizzo dello spazio di archiviazione",
+    usageTotal: "Totale {size}",
+    usageTotalLabel: "Totale",
+    calculating: "Calcolo in corso...",
+    usageManagedJre: "JRE gestito",
+    usageAgentDrivers: "Agenti driver integrati",
+    usageDownloadCache: "Cache download",
+    usageJdbcPlugin: "Plugin JDBC",
+    usageJdbcDriverJars: "JAR dei driver JDBC",
+    clearDownloadCache: "Pulisci cache",
+    downloadCacheClearSuccess: "Cache download pulita",
+    downloadCacheClearFailed: "Pulizia cache download non riuscita: {error}",
+    offlineDownloadHint: "Per ambienti air-gapped, scarica i pacchetti driver offline su una macchina connessa a Internet, quindi importali qui.",
+    offlineDownloadLink: "Download driver offline",
+    searchDrivers: "Cerca nome driver, tipo, versione...",
+    searchJdbcDrivers: "Cerca nome o percorso driver JDBC...",
+    jdbcMavenCoordinatePlaceholder: "Coordinata Maven, es. org.postgresql:postgresql:42.7.7",
+    jdbcMavenInstall: "Installa da Maven",
+    jdbcMavenInstallSuccess: "Driver JDBC Maven installato",
+    jdbcSourceMaven: "Maven",
+    jdbcSourceManual: "Manuale",
+    noMatchingDrivers: "Nessun driver corrispondente.",
+    javaRuntimeSaved: "Impostazioni Java Runtime salvate",
+    javaRuntimeSaveFailed: "Impossibile salvare le impostazioni del runtime Java: {error}",
+    chooseJavaExecutable: "Scegli l'eseguibile Java",
+    driverInstallSuccess: "Driver {label} installato",
+    driverInstallFailed: "Installazione del driver {label} non riuscita: {error}",
+    driverUpdateBlocked: "Chiudi queste connessioni al database prima di aggiornare i driver: {labels}",
+    upgradeAllSuccess: "{count} driver aggiornato/i",
+    upgradeAllPartial: "{count} driver aggiornato/i. Saltati: {failed}",
+    upgradeAllFailed: "Aggiornamento in blocco non riuscito: {error}",
+    driverUninstallSuccess: "Driver {label} disinstallato",
+    driverUninstallFailed: "Disinstillazione del driver {label} non riuscita: {error}",
+    chooseOfflineDriverPackage: "Scegli pacchetto driver offline",
+    offlineImportSuccess: "Importazione offline completata. Installato/i {count} driver.",
+    offlineImportFailed: "Importazione offline non riuscita: {error}",
+    driverImportSuccess: "Driver {label} importato",
+    driverImportFailed: "Importazione del driver {label} non riuscita: {error}",
+    chooseDriverJar: "Scegli il file JAR del driver",
+    jreReinstallSuccess: "JRE {jre} reinstallato",
+    jreReinstallFailed: "Reinstallazione del JRE {jre} non riuscita: {error}",
+    jreUninstallSuccess: "JRE {jre} disinstallato",
+    chooseJdbcPluginZip: "Scegli il file zip del plugin JDBC",
+    agentDrivers: "Driver integrati",
+    jdbcDrivers: "Driver JDBC",
+    importing: "Importazione in corso...",
+    importOfflinePackage: "Importa pacchetto offline",
+    refresh: "Aggiorna",
+    javaRuntime: "Java Runtime",
+    javaRuntimeManaged: "JRE gestito da DBX",
+    javaRuntimeSystem: "Java di sistema",
+    javaRuntimeCustom: "Percorso personalizzato",
+    saving: "Salvataggio...",
+    customJavaPathPlaceholder: "/percorso/per/java o /percorso/per/jdk",
+    choose: "Scegli",
+    systemJavaHint: "Usa java dal PATH corrente.",
+    jreRuntimeTitle: "Runtime JRE {jre}",
+    notInstalled: "Non installato",
+    reinstalling: "Reinstallazione in corso",
+    installing: "Installazione in corso",
+    install: "Installa",
+    reinstall: "Reinstalla",
+    uninstall: "Disinstalla",
+    jreRuntime: "Runtime JRE",
+    jreRuntimeAutoDownloadHint: "Scaricato automaticamente durante l'installazione di un driver per la prima volta",
+    driversUpdatable: "{count} driver può essere aggiornato | {count} driver possono essere aggiornati",
+    upgradingProgress: "Aggiornamento in corso ({current}/{total})",
+    upgradeAll: "Aggiorna tutti",
+    queued: "In coda",
+    importLocalJar: "Importa JAR locale",
+    updating: "Aggiornamento in corso",
+    update: "Aggiorna",
+    localInstall: "Installazione locale",
+    runtimeDrivers: "Runtime",
+    storageTab: "Archiviazione",
+    runtimeTitle: "Runtime del driver",
+    runtimeHint: "Le metriche di runtime vengono raccolte solo mentre questo pannello è aperto.",
+    runtimeRunning: "In esecuzione",
+    runtimeMemory: "Memoria",
+    runtimeHealth: "Stato",
+    runtimeHealth_healthy: "Sano",
+    runtimeHealth_warning: "Avviso",
+    runtimeHealth_error: "Errore",
+    runtimeLastError: "Ultimo errore",
+    runtimeEmpty: "Nessun runtime di driver ancora avviato. Apri una connessione guidata da agenti per avviarne uno.",
+    runtimeKindAgent: "Agente",
+    runtimeKindPlugin: "Plugin",
+    runtimeSourceDaemon: "Demone",
+    runtimeSourceConnection: "Connessione",
+    runtimeStatus_running: "In esecuzione",
+    runtimeStatus_stopped: "Arrestato",
+    runtimeStatus_error: "Errore",
+    runtimeStatus_unknown: "Sconosciuto",
+    runtimePid: "PID",
+    runtimeUptime: "Tempo di attività",
+    runtimeActions: "Azioni",
+    runtimeStop: "Arresta",
+    runtimeRestart: "Riavvia",
+    runtimeControlConnectionOwned: "Chiudi la connessione al database per arrestare questo runtime.",
+    runtimeStopSuccess: "Runtime {label} arrestato",
+    runtimeStopFailed: "Arresto di {label} non riuscito: {error}",
+    runtimeRestartSuccess: "Runtime {label} riavviato",
+    runtimeRestartFailed: "Riavvio di {label} non riuscito: {error}",
+    driverStoreDir: "Percorso archiviazione driver",
+    driverStoreDirDescription: "Configura percorsi separati per il plugin JDBC e i dati Agent/JRE. L'app si riavvierà automaticamente dopo la migrazione.",
+    pluginStoreDir: "Directory plugin JDBC",
+    pluginStoreDirDescription: "Archivia il plugin JDBC, Maven resolver e i jar dei driver JDBC.",
+    agentStoreDir: "Directory Agent / JRE",
+    agentStoreDirDescription: "Archivia pacchetti driver Agent, JRE gestiti e cache runtime.",
+    driverStoreDirDefault: "Predefinito (directory di installazione)",
+    driverStoreDirChange: "Cambia",
+    driverStoreDirReset: "Ripristina",
+    driverStoreDirMigrating: "Migrazione {target} in corso…",
+    driverStoreDirConfirm: "La modifica di {target} migrerà i dati correlati nella nuova posizione. Le connessioni correlate potrebbero essere disconnesse durante la migrazione. L'app si riavvierà automaticamente dopo. Continuare?",
+    driverStoreDirMigrationFailed: "Migrazione driver fallita: {error}",
+    driverStoreDirDialogTitle: "Seleziona {target}",
+    driverStoreDirSuccess: "{target} cambiato, riavvio in corso…",
+  },
+  databaseExport: {
+    title: "Esporta Database",
+    options: "Opzioni",
+    includeStructure: "Struttura tabella (DDL)",
+    dropTableIfExists: "Aggiungi DROP TABLE IF EXISTS prima del DDL",
+    includeData: "Dati tabella (INSERT)",
+    includeObjects: "Viste / Procedure / Funzioni / Sequenze",
+    databaseSelection: "Database",
+    selectedDatabases: "{selected}/{total} selezionati",
+    selectAllDatabases: "Seleziona tutti",
+    filterDatabases: "Cerca database...",
+    clearDatabases: "Cancella",
+    tableSelection: "Tabelle",
+    selectedTables: "{selected}/{total} selezionate",
+    selectAllTables: "Seleziona tutte",
+    filterTables: "Cerca tabelle...",
+    clearTables: "Cancella",
+    loadingTables: "Caricamento tabelle...",
+    tableLoadError: "Caricamento tabelle non riuscito: {error}",
+    noTables: "Nessuna tabella trovata",
+    export: "Esporta",
+    exportAllDatabases: "Esporta tutti i database",
+    exporting: "Esportazione in corso...",
+    selectExportDirectory: "Seleziona directory di esportazione",
+    currentDatabase: "Database {current}/{total}",
+    currentTable: "Corrente: {table} ({current}/{total})",
+    rowsExported: "{count} righe esportate",
+    exportSuccess: "Database esportato con successo",
+    exportAllSuccess: "{count} database esportati con successo",
+    allDatabasesTask: "Tutti i database ({count})",
+    exportError: "Esportazione non riuscita: {error}",
+    exportCancelled: "Esportazione annullata",
+    runInBackground: "Esegui in background",
+  },
+  nacos: {
+    configs: "Configurazioni",
+    services: "Servizi",
+    raw: "Raw",
+    namespace: "Namespace",
+    createNamespace: "Crea Namespace",
+    editNamespace: "Modifica Namespace",
+    creatingNamespace: "Creazione...",
+    updatingNamespace: "Aggiornamento...",
+    namespaceCreated: 'Namespace "{name}" creato',
+    namespaceUpdated: 'Namespace "{name}" aggiornato',
+    namespaceId: "ID Namespace",
+    namespaceIdPlaceholder: "Lascia vuoto per generazione automatica Nacos",
+    namespaceName: "Nome Namespace",
+    namespaceNamePlaceholder: "Inserisci un nome namespace",
+    namespaceDesc: "Descrizione",
+    namespaceDescPlaceholder: "Predefinito al nome namespace",
+    dataId: "Data ID",
+    group: "Gruppo",
+    format: "Formato",
+    content: "Contenuto",
+    tags: "Tag",
+    application: "Applicazione",
+    description: "Descrizione",
+    advanced: "Avanzate",
+    collapse: "Comprimi",
+    load: "Carica",
+    save: "Salva",
+    saveAs: "Salva come",
+    saving: "Salvataggio...",
+    saved: "Configurazione salvata",
+    createdAndLoaded: "{dataId} creato e caricato",
+    savedAndLoaded: "{dataId} salvato e aggiornato",
+    deleted: "Configurazione eliminata",
+    delete: "Elimina",
+    copy: "Copia",
+    copied: "Copiato",
+    copyVerifyFailed: "Verifica degli appunti non riuscita dopo la scrittura",
+    export: "Esporta",
+    exported: "Esportato",
+    exportedTo: "Esportato in {path}",
+    exportFailed: "Esportazione non riuscita: {message}",
+    history: "History",
+    configHistory: "Config history",
+    historyDetail: "History detail",
+    historyCompareTitle: "History Version Compare",
+    currentPublishedContent: "Current published content:",
+    historyVersionContent: "History version content:",
+    updatedAt: "Updated at",
+    operationType: "Operation",
+    operator: "Operator",
+    view: "View",
+    compare: "Compare",
+    rollback: "Rollback",
+    loadingHistory: "Loading history...",
+    noHistory: "No history versions",
+    noHistoryHint: "Refresh if this config was just published. Some Nacos versions may not expose history APIs.",
+    historyCreate: "Create",
+    historyUpdate: "Update",
+    historyDelete: "Delete",
+    historyRollback: "Rollback",
+    confirmRollbackTitle: "Rollback Nacos config",
+    confirmRollbackMessage: "This will roll the current config back to the selected history version.",
+    rollbackSuccess: "Config rolled back",
+    publish: "Pubblica",
+    dataIdRequired: "Data ID è obbligatorio",
+    allGroups: "Tutti i gruppi",
+    noConfigs: "Nessuna configurazione",
+    selectConfig: "Seleziona o crea una configurazione",
+    noServices: "Nessun servizio",
+    selectService: "Seleziona un servizio",
+    service: "Servizio",
+    instances: "Istanze",
+    instanceCount: "{count} istanze",
+    refresh: "Aggiorna",
+    address: "Indirizzo",
+    cluster: "Cluster",
+    weight: "Peso",
+    state: "Stato",
+    actions: "Azioni",
+    query: "Query",
+    body: "Corpo",
+    response: "Risposta",
+    template: "Template",
+    configDiffTitle: "Confronto contenuto configurazione",
+    inlineCompare: "Confronto inline",
+    currentVersionContent: "Versione ufficiale attuale:",
+    publishVersionContent: "Contenuto di questa pubblicazione:",
+    confirmSaveTitle: "Rivedi modifiche configurazione Nacos",
+    confirmSaveMessage: "Salvare questa modifica? +{added} / -{removed} righe.",
+    confirmDeleteTitle: "Elimina configurazione Nacos",
+    confirmDeleteMessage: "Questo rimuove la configurazione selezionata da Nacos.",
+    confirmInstanceTitle: "Aggiorna istanza Nacos",
+    confirmInstanceMessage: "Conferma lo stato di destinazione dell'istanza.",
+    confirmRawTitle: "Invia richiesta Raw API modificante",
+    confirmRawMessage: "Questa richiesta Raw API può modificare lo stato di Nacos.",
+    rawTemplate: {
+      serverState: "Stato server",
+      namespaceList: "Lista namespace",
+      configDetail: "Dettaglio configurazione",
+      serviceList: "Lista servizi",
+      instanceList: "Lista istanze",
+    },
+    healthy: "Sana",
+    unhealthy: "Non sana",
+    enabled: "Abilitata",
+    offline: "Offline",
+    ephemeral: "Effimera",
+    persistent: "Persistente",
+    enable: "Abilita",
+    disable: "Disabilita",
+    markHealthy: "Segna sana",
+    markUnhealthy: "Segna non sana",
+    send: "Invia",
+    total: "{count} totali",
+    prev: "Prec.",
+    next: "Succ.",
+    test: "Test",
+    readOnly: "Sola lettura",
+  },
+  gridfsBrowser: {
+    bucketCount: "Bucket",
+    fileCount: "File",
+    name: "Nome",
+    totalSize: "Dimensione",
+    chunkSize: "Dimensione chunk",
+    uploadDate: "Data di caricamento",
+    contentType: "Tipo di contenuto",
+    metadata: "Metadati",
+    selectBucket: "Seleziona un bucket GridFS per visualizzarlo o aprirlo.",
+    selectFile: "Seleziona un file GridFS per visualizzarlo o gestirlo.",
+    emptyBuckets: "Nessun bucket GridFS presente. Puoi crearne uno nuovo.",
+    emptyFiles: "Il bucket attuale non contiene file. Puoi caricarne uno.",
+    createBucket: "Crea bucket",
+    openBucket: "Apri bucket",
+    deleteBucket: "Elimina bucket",
+    createTitle: "Crea bucket GridFS",
+    deleteTitle: "Elimina bucket GridFS",
+    deleteMessage: "Sei sicuro di voler eliminare il bucket GridFS selezionato e tutti i file in esso contenuti?",
+    bucketName: "Nome bucket",
+    bucketNamePlaceholder: "example_bucket",
+    bucketCreated: "Bucket {bucket} creato.",
+    bucketDeleted: "Bucket {bucket} eliminato.",
+    uploadFile: "Carica file",
+    downloadFile: "Scarica file",
+    downloadSelected: "Scarica selezionati",
+    deleteFile: "Elimina file",
+    selectedCount: "{count} selezionati",
+    deleteFileTitle: "Elimina file GridFS",
+    deleteFileMessage: "Sei sicuro di voler eliminare il file selezionato dal bucket GridFS corrente?",
+    fileUploaded: "{fileName} caricato.",
+    fileDeleted: "{fileName} eliminato.",
+  },
+  extension: {
+    installTitle: "Installa estensione",
+    manageTitle: "Gestisci estensioni",
+    name: "Nome estensione",
+    namePlaceholder: "Es: pg_stat_statements",
+    install: "Installa",
+    drop: "Elimina",
+    available: "Estensioni disponibili",
+    installed: "Installate",
+    noAvailable: "Tutte le estensioni disponibili sono installate.",
+    noInstalled: "Nessuna estensione installata.",
+  },
+  sqlFileTree: {
+    title: "File SQL",
+    openFolder: "Apri cartella",
+    closePanel: "Chiudi",
+    loading: "Caricamento in corso...",
+    noFolder: "Nessuna cartella aperta",
+    noSqlFiles: "Nessun file SQL trovato",
+    folderAlreadyOpen: "Questa cartella è già aperta",
+    removeFolder: "Rimuovi cartella",
+    openFailed: "Apertura cartella fallita: {message}",
+    loadFailed: "Caricamento file SQL fallito: {message}",
+    desktopOnly: "Questa funzionalità è disponibile solo su desktop",
+    refreshFolder: "Aggiorna cartella",
+    refreshAll: "Aggiorna tutto",
+    refreshed: "Aggiornato",
+    revealInFileManager: "Mostra nel file manager",
+    revealFailed: "Apertura del file manager non riuscita: {message}",
+    copyPath: "Copia percorso",
+    pathCopied: "Percorso copiato",
+    copyFailed: "Copia del percorso non riuscita",
+    openFile: "Apri",
+    executeSqlFile: "Esegui file SQL",
+    expandAll: "Espandi tutto",
+    collapseAll: "Comprimi tutto",
+  },
+  mqTopics: {
+    title: "Gestione topic",
+    searchPlaceholder: "Cerca topic",
+    includeNonPersistent: "Includi topic non persistenti",
+    refresh: "Aggiorna",
+    refreshing: "Aggiornamento in corso...",
+    createTopic: "Crea topic",
+    selectTenantNamespace: "Seleziona prima tenant e namespace",
+    loading: "Caricamento in corso...",
+    noTopics: "Nessun topic in questo namespace",
+    noMatches: "Nessun topic corrispondente",
+    name: "Nome",
+    type: "Tipo",
+    partitions: "Partizioni",
+    actions: "Azioni",
+    nonPersistent: "Non persistente",
+    partitionedTopic: "Topic partizionato",
+    normalTopic: "Topic normale",
+    partitionCount: "{count} partizioni",
+    partitionsUnknown: "Numero di partizioni sconosciuto",
+    adjustPartitions: "Regola partizioni",
+    delete: "Elimina",
+    tenantNamespace: "Tenant / Namespace",
+    topicName: "Nome topic",
+    topicNamePlaceholder: "es. my-topic",
+    persistentRecommended: "Topic persistente (consigliato)",
+    persistentHint: "I topic persistenti salvano i messaggi su disco, quelli non persistenti solo in memoria.",
+    enablePartitions: "Abilita partizioni",
+    partitionQuantity: "Numero di partizioni",
+    partitionHint: "Le partizioni migliorano le prestazioni di concorrenza ma aumentano il consumo di risorse.",
+    cancel: "Annulla",
+    create: "Crea",
+    updatePartitionsTitle: "Regola numero partizioni: {name}",
+    currentPartitions: "Partizioni attuali",
+    newPartitions: "Nuove partizioni",
+    partitionMinHint: "Il numero di partizioni può solo aumentare, non diminuire. Minimo: {min}",
+    update: "Aggiorna",
+    readOnly: "La connessione corrente è in modalità sola lettura, impossibile eseguire operazioni di scrittura.",
+    topicNameRequired: "Il nome del topic non può essere vuoto",
+    currentPartitionsUnknown: "Numero di partizioni attuali sconosciuto, impossibile regolare le partizioni in modo sicuro.",
+    partitionMustIncrease: "Il nuovo numero di partizioni deve essere maggiore di quello attuale.",
+    confirmDelete: 'Confermi di eliminare il topic "{name}"? Questa operazione è irreversibile.',
+  },
+  production: {
+    title: "Ambiente di produzione",
+    connection: "Connessione di produzione",
+    enable: "Abilita protezione ambiente di produzione",
+    disabledDescription: "Dopo l'attivazione, è possibile scegliere di proteggere tutti i database o database specifici.",
+    scope: "Ambito di protezione",
+    allDatabases: "Tutti i database",
+    selectedDatabases: "Database selezionati",
+    singleDatabaseScopeHint: "Questo tipo di database supporta solo la protezione dell'ambiente di produzione a livello di connessione.",
+    databases: "Database di produzione",
+    connectionDescription: "Tutti i database su questa connessione avranno la protezione di produzione abilitata.",
+    databaseDescription: "Seleziona i database che necessitano di protezione di produzione dalla connessione. Alla prima apertura, sono selezionati tutti per impostazione predefinita.",
+    selectDatabases: "Seleziona database di produzione",
+    noDatabasesSelected: "Nessuno selezionato",
+    databasesConfiguredCount: "{count} selezionati",
+    databasesSelectedCount: "Selezionati {selected}/{total}",
+    databasePickerTitle: "Seleziona database di produzione",
+    databasePickerDescription: "Seleziona i database che necessitano di protezione di produzione in «{connection}».",
+    databaseSearchPlaceholder: "Cerca database...",
+    databaseSelectionRequired: "Selezionare almeno un database.",
+    databaseLoadFailed: "Impossibile caricare l'elenco dei database: {message}",
+    noDatabasesAvailable: "Nessun database selezionabile trovato.",
+    retry: "Riprova",
+    confirmTitle: "Conferma scrittura in ambiente di produzione",
+    confirmMessage: "Questa operazione modificherà il database di produzione; è necessario confermare esplicitamente per procedere.",
+    confirmDetails: "Connessione: {connection}\nDatabase: {database}\nOrigine: {source}",
+    confirmAction: "Esegui in ambiente di produzione",
+    sourceSqlEditor: "Editor SQL",
+    sourceDataGrid: "Editor dati",
+    sourceStructure: "Editor struttura",
+    sourceSqlFile: "Esecuzione file SQL",
+    sourceObjectBrowser: "Browser oggetti",
+    sourceSchemaDiff: "Confronto schema",
+    sourceDataCompare: "Confronto dati",
+    sourceExtension: "Gestione estensioni",
+    sourceSidebar: "Albero oggetti",
+    sourceObjectSource: "Editor sorgente oggetto",
+    sourceDataGenerate: "Generatore dati",
+    sourceQueryHistory: "Rollback cronologia query",
+    sourceAdmin: "Amministrazione database",
+    aiReviewRequired: "La SQL di produzione è stata inserita nell'editor. Controllare prima, quindi eseguire manualmente per confermare.",
+  },
+});
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
new file mode 100644
index 0000000..0131e57
--- /dev/null
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -0,0 +1,3821 @@
+import { withEnglishFallback } from "./fallback";
+
+export default withEnglishFallback({
+  app: {
+    name: "DBX",
+  },
+  auth: {
+    setupTitle: "アクセスパスワードを設定",
+    setupDescription: "インスタンスを保護するためのパスワードを設定してください",
+    loginDescription: "データベース管理ツール",
+    newPassword: "新しいパスワードを入力",
+    confirmPassword: "パスワードを確認",
+    enterPassword: "アクセスパスワードを入力",
+    passwordMismatch: "パスワードが一致しません",
+    setPassword: "パスワードを設定",
+    login: "ログイン",
+    processing: "処理中...",
+    loginFailed: "パスワードが正しくありません",
+    connectFailed: "接続に失敗しました",
+    changePassword: "パスワードを変更",
+    oldPassword: "現在のパスワード",
+    oldPasswordWrong: "現在のパスワードが正しくありません",
+    passwordChanged: "パスワードが変更されました",
+    changePasswordFailed: "パスワードの変更に失敗しました",
+    changePasswordDescription: "現在のパスワードと新しいパスワードを入力してください",
+  },
+  toolbar: {
+    newConnection: "新しい接続",
+    newQuery: "新しいクエリ",
+    execute: "実行",
+    executeShortcut: "選択範囲/クエリを実行 (Cmd+Enter)",
+    stopQuery: "クエリを停止",
+    explainPlan: "実行計画を表示",
+    stopExplain: "実行計画の表示を停止",
+    formatSql: "SQLをフォーマット",
+    formatSqlFailed: "SQLのフォーマットに失敗しました",
+    keywordCaseLower: "SQLキーワードを小文字にする",
+    keywordCaseUpper: "SQLキーワードを大文字にする",
+    autoCommit: "自動コミット",
+    manualTransaction: "手動トランザクション",
+    autoCommitAgent: "自動コミット（Agentバックエンドに依存）",
+    manualTransactionAgent: "手動トランザクション（Agentバックエンドに依存）",
+    commit: "コミット",
+    rollback: "ロールバック",
+    txnAutoRolledBack: "5分間操作がなかったため、トランザクションは自動的にロールバックされました",
+    previewSql: "SQLをプレビュー",
+    hidePreviewSql: "SQLプレビューを非表示",
+    saveSql: "SQLライブラリに保存",
+    openSql: "SQLファイルを開く",
+    exPasteSqlInCondition: "ExPaste: IN条件として貼り付け",
+    theme: "テーマ",
+    themeLight: "ライト",
+    themeDark: "ダーク",
+    themeSystem: "システム設定に従う",
+    sqlSaved: "SQLを保存しました",
+    sqlOpenFailed: "ファイルを開けませんでした: {message}",
+    sqlSaveFailed: "ファイルの保存に失敗しました: {message}",
+    driverManager: "ドライバーマネージャー",
+    updatableDriverCount: "更新可能なドライバー数",
+    blockDangerousRedisCommands: "危険なコマンドをブロック",
+  },
+  updates: {
+    title: "アップデート",
+    check: "アップデートを確認",
+    availableTitle: "アップデートがあります",
+    availableMessage: "DBX {latest} が利用可能です。現在のバージョンは {current} です。",
+    upToDate: "DBX は最新です ({version})。",
+    failed: "アップデートの確認に失敗しました: {error}",
+    rateLimited: "GitHubのアップデート確認が一時的に制限されています。リリースページで手動確認できます。",
+    openRelease: "リリースページを開く",
+    downloadAndInstall: "ダウンロード & インストール",
+    portableManualUpdate: "ポータブル版はアプリ内インストーラーを使用できません。リリースページからポータブルZIPをダウンロードし、現在のDBXフォルダに上書き展開してください。portable.dbxとデータは保持されます。",
+    downloading: "ダウンロード中 {progress}%",
+    downloadFailed: "アップデートのダウンロードに失敗しました: {error}",
+    restart: "終了して再起動",
+    restartFailed: "アプリの再起動に失敗しました: {error}",
+    exitAndUpdate: "終了してアップデート",
+    dockerUsersRun: "Dockerユーザーは以下を実行してください",
+    toUpdate: "更新するには",
+  },
+  sidebar: {
+    connections: "接続",
+    noConnections: "まだ接続がありません",
+    import: "接続をインポート",
+    importDbx: "DBX設定をインポート",
+    importNavicat: "Navicat NCXをインポート",
+    importDbeaver: "DBeaverをインポート",
+    importDatagrip: "DataGripをインポート",
+    export: "接続をエクスポート",
+    collapseAll: "すべて折りたたむ",
+    collapse: "サイドバーを折りたたむ",
+    expand: "サイドバーを展開",
+    showMore: "さらに{count}件表示...",
+    filterByType: "タイプでフィルター",
+    searchScopeConnection: "接続",
+    searchScopeDatabase: "データベース",
+    searchScopeSchema: "スキーマ",
+    searchScopeTable: "テーブル",
+    searchScopeView: "ビュー",
+    searchTablesInCurrentScope: "このデータベースのテーブルを検索...",
+    clearTableSearch: "テーブル検索をクリア",
+    clearFilter: "フィルターをクリア",
+    locateActiveTab: "サイドバーで表示",
+  },
+  savedSql: {
+    saveToLibrary: "SQLライブラリに保存",
+    saveToFile: "ローカルに保存",
+    save: "保存",
+    saved: "SQLを保存しました",
+    saveFailed: "SQLの保存に失敗しました: {message}",
+    fileName: "ファイル名",
+    folder: "フォルダ",
+    rootFolder: "SQLライブラリ",
+    newQuery: "新規クエリ",
+    newFolder: "新しいSQLフォルダ",
+    newFolderDefault: "新しいフォルダ",
+    renameFolder: "フォルダ名を変更",
+    deleteFolder: "フォルダを削除",
+    deleteFolderConfirm: "「{name}」とその中のSQLファイルを削除しますか？",
+    open: "SQLを開く",
+    renameFile: "SQLの名前を変更",
+    deleteFile: "SQLを削除",
+    deleteFileConfirm: "「{name}」を削除しますか？",
+  },
+  sqlLibrary: {
+    title: "SQLライブラリ",
+    empty: "保存されたクエリはまだありません",
+    emptyFolder: "空のフォルダ",
+    unfiled: "未分類",
+    exportFile: "SQLをエクスポート",
+    exportFolder: "フォルダをエクスポート",
+    exportLibrary: "SQLライブラリをエクスポート",
+    importDirectory: "ローカルフォルダをインポート",
+    importIntoFolder: "フォルダにインポート",
+    openStorageDirectory: "SQL保存ディレクトリを開く",
+    chooseSyncDirectory: "ローカル同期ディレクトリを設定",
+    disableSyncDirectory: "ローカル同期ディレクトリを無効化",
+    syncDirectorySaved: "SQLローカル同期ディレクトリを保存しました",
+    syncDirectoryDisabled: "SQLローカル同期を無効化しました",
+    syncDirectoryFailed: "同期ディレクトリの設定に失敗しました: {message}",
+    openDirectoryFailed: "ディレクトリを開けませんでした: {message}",
+    noSyncDirectory: "先にローカル同期ディレクトリを設定してください",
+    exported: "エクスポートしました",
+    exportFailed: "エクスポートに失敗しました: {message}",
+    importFailed: "インポートに失敗しました: {message}",
+    importNone: "選択されたフォルダに.sqlファイルが見つかりませんでした",
+    imported: "{count}件のSQLファイルをインポートしました",
+    desktopOnly: "この機能はデスクトップアプリでのみ利用可能です",
+    noConnection: "インポートに利用可能な接続がありません",
+    batchDelete: "一括削除",
+    batchDeleteConfirm: "選択した {count} 項目を削除してもよろしいですか？この操作は元に戻せません。",
+    batchDeleteSuccess: "{count} 項目を削除しました",
+    moveToFolder: "フォルダへ移動...",
+    moveSelectedToFolder: "選択した {count} 個の SQL をフォルダへ移動...",
+    moveSuccess: "{count} 個の SQL を移動しました",
+    clearSelection: "選択を解除",
+    sortByDate: "更新日時で並べ替え",
+    sortByFolder: "フォルダ構造で並べ替え",
+  },
+  connection: {
+    title: "新しい接続",
+    name: "名前",
+    namePlaceholder: "接続名（空の場合は自動生成）",
+    type: "タイプ",
+    host: "ホスト",
+    filePath: "ファイルパス",
+    h2FileMode: "ファイル",
+    h2TcpMode: "TCP",
+    h2FilePathRequired: "H2ファイルパスを指定してください",
+    createDuckDbFile: "DuckDBファイルを作成",
+    createSqliteFile: "SQLiteデータベースを作成",
+    memoryDatabasePathHint: "インメモリのSQLiteまたはDuckDBデータベースを作成するには :memory: を使用してください。",
+    sqliteCipherKey: "SQLCipherキー",
+    sqliteCipherKeyPlaceholder: "暗号化されていないSQLiteでは空のままにします",
+    sqliteExtensions: "SQLite拡張",
+    sqliteExtensionsPlaceholder: "/path/to/regexp.dylib\n/path/to/text.dylib|sqlite3_text_init",
+    sqliteExtensionsHint: "1行に1つの.dylib/.so/.dllファイルを指定します。エントリポイントが必要な場合は「パス|エントリポイント」形式で指定します。接続時に読み込まれ、その後load_extensionは無効になります。",
+    sqliteExtensionBrowse: "SQLite拡張を選択",
+    user: "ユーザー",
+    password: "パスワード",
+    database: "データベース",
+    databasePlaceholder: "任意",
+    databasePlaceholderRequired: "必須、既存のデータベースを入力",
+    databasePlaceholderWithDefault: "任意、デフォルトは {database}",
+    kingbaseDatabaseRequired: "Kingbase は接続またはデータベース一覧の読み込み前に、既存のデータベース名が必要です。",
+    defaultDatabase: "デフォルトDB",
+    authDatabase: "認証DB",
+    authDatabasePlaceholder: "任意、通常は admin",
+    authMechanism: "認証方式",
+    authMechanismDefault: "デフォルト",
+    driverMode: "ドライバー",
+    mongoDriverAuto: "自動",
+    mongoDriverLegacy: "レガシー",
+    serviceName: "サービス/SID",
+    serviceNameOnly: "サービス名",
+    version: "バージョン",
+    driverInstallHintPrefix: "接続前に上部ツールバーの",
+    driverInstallHintSuffix: "から必要なドライバーをインストールしてください。",
+    driverName: "ドライバー名",
+    driverNamePlaceholder: "ベンダー名または環境名",
+    urlParams: "URLパラメータ",
+    d1AccountId: "アカウントID",
+    d1DatabaseId: "データベースID",
+    d1ApiToken: "APIトークン",
+    d1TokenHint: "トークンには少なくともD1 Read権限が必要です。書き込み、DDL、インポートにはD1 Write権限も必要です。",
+    d1FieldsRequired: "CloudflareアカウントID、D1データベースID、APIトークンは必須です。",
+    gbaseServer: "GBASEDBTSERVER",
+    informixServer: "INFORMIXSERVER",
+    sslEnable: "暗号化接続を有効にする",
+    caCertPath: "CA証明書",
+    caCertPathPlaceholder: "任意、例: ~/.yandex/RootCA.crt",
+    caCertPathBrowse: "証明書を参照",
+    redisTlsInsecure: "証明書の検証をスキップ",
+    redisTlsInsecureHint: "自己署名証明書やプライベートCA用の、redis-cli --tls --insecure 相当の設定です。",
+    mysqlTlsMode: "TLSモード",
+    mysqlTlsModePreferred: "優先",
+    mysqlTlsModeDisabled: "無効",
+    mysqlTlsModeRequired: "必須",
+    mysqlTlsModeVerifyCa: "CA検証",
+    mysqlTlsModeVerifyIdentity: "ID検証",
+    mysqlCleartextPasswordAuth: "平文パスワード認証",
+    mysqlCleartextPasswordAuthHint: "MySQLサーバーがcleartext password認証プラグインを要求する場合のみ有効にしてください。",
+    mysqlCaCertHint: "サーバー証明書がプライベートCAで署名されている場合、CA検証とID検証に必要です。",
+    mysqlClientCert: "クライアント認証",
+    mysqlClientCertPlaceholder: "/path/to/client.crt",
+    mysqlClientKeyPlaceholder: "/path/to/client.key",
+    mysqlClientCertHint: "MySQLがmTLSを要求する場合、クライアント証明書と秘密鍵の両方を指定する必要があります。",
+    mysqlTlsConnectionFailureHint: "MySQLサーバーがTLSを要求しない場合は、接続を編集し、TLSモードを無効にしてから再試行してください。",
+    mysqlClientCertBrowse: "クライアント証明書を選択",
+    mysqlClientKeyBrowse: "クライアント秘密鍵を選択",
+    postgresSslMode: "TLSモード",
+    postgresSslModeDisable: "無効にする",
+    postgresSslModePrefer: "優先する",
+    postgresSslModeRequire: "必須にする",
+    postgresSslModeVerifyCa: "CA検証",
+    postgresSslModeVerifyFull: "完全検証",
+    postgresServerCert: "サーバーCA",
+    postgresRootCertPlaceholder: "/path/to/ca.crt",
+    postgresRootCertHint: "サーバー証明書がプライベートCAで署名されている場合、verify-caまたはverify-fullに使用します。",
+    postgresRootCertBrowse: "CA証明書を選択",
+    postgresClientCert: "クライアント認証",
+    postgresClientCertPlaceholder: "/path/to/client.crt",
+    postgresClientKeyPlaceholder: "/path/to/client.key",
+    postgresClientCertHint: "PostgreSQLがmTLSを要求する場合、クライアント証明書と秘密鍵の両方を指定する必要があります。",
+    postgresClientCertBrowse: "クライアント証明書を選択",
+    postgresClientKeyBrowse: "クライアント秘密鍵を選択",
+    connectionUrlOptional: "URL（任意）",
+    connectionUrlPlaceholder: "postgresql://user:pass{'@'}host:5432/db?sslmode=require",
+    parseConnectionUrl: "接続URLを解析",
+    parseConnectionUrlApplied: "接続URLを適用しました",
+    parseConnectionUrlFailed: "接続URLの解析に失敗しました: {message}",
+    mode: "接続モード",
+    modeForm: "フォーム",
+    redisStandaloneMode: "スタンドアロン",
+    redisSentinelMode: "センチネル",
+    redisClusterMode: "クラスター",
+    oceanbaseMySQLMode: "MySQLモード",
+    oceanbaseOracleMode: "Oracleモード",
+    redisFirstSentinel: "最初のセンチネル",
+    redisFirstClusterNode: "最初のシードノード",
+    redisSentinelNodes: "センチネルノード",
+    redisClusterNodes: "クラスターシードノード",
+    redisSentinelMaster: "マスター名",
+    redisSentinelUser: "センチネルユーザー",
+    redisSentinelPassword: "センチネルパスワード",
+    redisSentinelTls: "センチネルTLS",
+    redisSentinelTlsHint: "センチネルノード接続時にTLSを使用する",
+    redisKeySeparator: "キー名前空間セパレーター",
+    etcdEndpoints: "エンドポイント",
+    etcdEndpointsHint: "1行に1つのエンドポイント。空白の場合、上のホストとポートを使用します。",
+    etcdCaCertPlaceholder: "/path/to/ca.crt",
+    etcdCaCertBrowse: "CA証明書を選択",
+    etcdClientAuth: "クライアント認証",
+    etcdClientCertPlaceholder: "/path/to/client.crt",
+    etcdClientKeyPlaceholder: "/path/to/client.key",
+    etcdClientCertHint: "etcdがmTLSを要求する場合、クライアント証明書と秘密鍵の両方を指定する必要があります。",
+    etcdClientCertBrowse: "クライアント証明書を選択",
+    etcdClientKeyBrowse: "クライアント秘密鍵を選択",
+    etcdClientCertPairRequired: "クライアント証明書と秘密鍵の両方を指定する必要があります。",
+    nacosConsoleUrl: "コンソールURL",
+    nacosConsoleUrlHint: "Nacosのコンソール/admin APIアドレスを指定します。Nacos 3 Dockerでは通常8085、古い構成ではサービス用ポート8848と共用される場合があります。",
+    nacosConsoleUrlRequired: "NacosコンソールURLは必須です",
+    nacosConsoleUrlAutoAdjusted: "NacosコンソールURLを{from}から{to}に自動調整しました。",
+    nacosNamespace: "名前空間",
+    nacosContextPath: "Context Path",
+    nacosContextPathPlaceholder: "空欄または /nacos",
+    nacosAuth: "認証",
+    nacosAuthNone: "なし",
+    nacosAuthUserPassword: "ユーザー / パスワード",
+    nacosUsernameRequired: "Nacosユーザー名は必須です",
+    nacosTls: "TLS",
+    nacosTlsSkipVerify: "証明書検証をスキップ",
+    nacosPageSize: "ページサイズ",
+    searchDatabasePlaceholder: "データベースタイプを検索",
+    iconView: "アイコン表示",
+    listView: "リスト表示",
+    selectedDatabase: "選択中",
+    noDatabaseMatches: "一致するデータベースがありません",
+    next: "次へ",
+    back: "戻る",
+    basicTab: "接続",
+    tlsTab: "TLS/SSL",
+    test: "テスト",
+    testing: "テスト中...",
+    copyTestResult: "テスト結果をコピー",
+    sqlServerLegacyCompatibilityMode: "レガシー互換モード",
+    sqlServerLegacyCompatibilityModeEnable: "SQL Server レガシー互換接続を使用",
+    sqlServerLegacyCompatibilityModeEnabled: "SQL Server レガシー互換モードが有効です。",
+    sqlServerLegacyCompatibilityModeHint:
+      "非暗号化、ログイン時のみ暗号化、または TLS 1.0 レガシー互換シナリオに適用されます。互換コンポーネントが未インストールの場合、DBX はこのモードを有効にする前にインストールします。\n互換コンポーネントへフォールバックした場合、一部の SQL Server ネイティブ機能を利用できないことがあります。\n信頼できるネットワーク、VPN、SSH トンネルでのみ使用してください",
+    sqlServerLegacyCompatibilityComponent: "SQL Server レガシー互換コンポーネント",
+    sqlServerLegacyCompatibilityComponentInstalling: "SQL Server レガシー互換コンポーネントをインストールしています...",
+    saveAndConnect: "保存して接続",
+    save: "保存",
+    editTitle: "接続を編集",
+    testSuccess: "接続に成功しました",
+    connecting: "{name} に接続中...",
+    connectSuccess: "{name} に接続しました",
+    connectFailed: "接続に失敗しました: {message}",
+    driverNotInstalled: "{driver} ドライバーがインストールされていません。ドライバーマネージャーからインストールしてください。",
+    jreNotInstalled: "JRE {jre} ランタイムがインストールされていません。ドライバーマネージャーからインストールしてください。",
+    systemJavaNotFound: "システムJavaランタイムがPATHに見つかりませんでした。Javaをインストールするか、カスタムJava実行ファイルを選択してください。",
+    customJavaPathEmpty: "カスタムJavaランタイムのパスが空です。Java実行ファイルを選択してください。",
+    agentJavaTooOld: "このドライバーにはJava 21が必要です。ドライバーマネージャーでDBX管理JRE 21を使用するか、Java 21実行ファイルを選択してください。",
+    agentDriverUpdateConnectionHint: "この接続で使用中の内蔵ドライバに更新が利用可能です。接続失敗はローカルドライバの旧版が原因の可能性があります。ドライバマネージャーで該当ドライバを更新してから再試行してください。",
+    jdbcPluginNotInstalled: "JDBCプラグインがインストールされていません。この接続を使用するにはオプションのJDBCプラグインをインストールしてください。",
+    lastError: "接続エラー",
+    clearError: "接続エラーをクリア",
+    saveFailed: "接続の保存に失敗しました: {message}",
+    deleted: "接続を削除しました",
+    deletedSelected: "{count}件の接続を削除しました",
+    copied: "コピーしました",
+    disconnected: "切断しました",
+    databaseConnectionClosed: "データベース接続を閉じました: {name}",
+    duplicated: "接続を複製しました",
+    duplicatedSelected: "{count}件の接続を複製しました",
+    groupDeleted: "グループを削除しました",
+    loadFailed: "保存された接続の読み込みに失敗しました: {message}",
+    sshTunnel: "SSHトンネル / プロキシ",
+    advancedTab: "詳細",
+    sshEnable: "SSHトンネル/プロキシを使用する",
+    sshHost: "SSHホスト",
+    sshHostPlaceholder: "ssh.example.com または ~/.ssh/config のエイリアス",
+    sshUser: "SSHユーザー",
+    sshAuthMethod: "ログイン方式",
+    sshAuthMethodPassword: "パスワード",
+    sshAuthMethodKey: "秘密鍵",
+    sshAuthMethodNone: "なし",
+    sshAuthMethodNoneHint: "認証情報は送信されません。無認証接続を許可する踏み台やプロキシに使用してください。",
+    sshAuthMethodAgentLegacy: "SSH Agent(旧)",
+    sshPassword: "SSHパスワード",
+    sshPasswordPlaceholder: "鍵を使用する場合は空のまま",
+    sshKeyPath: "鍵パス",
+    sshKeyPassphrase: "鍵パスフレーズ",
+    sshKeyPassphrasePlaceholder: "鍵が暗号化されていない場合は空のまま",
+    sshKeyPathBrowse: "参照",
+    sshExposeLan: "トンネルをLANに公開",
+    sshConnectTimeout: "SSHタイムアウト（秒）",
+    sshHops: "SSHトンネル / プロキシ階層",
+    sshHopAdd: "SSH階層を追加",
+    sshHopDuplicate: "複製",
+    sshHopDelete: "削除",
+    sshHopMoveUp: "上に移動",
+    sshHopMoveDown: "下に移動",
+    sshHopName: "階層名",
+    sshHopNamePlaceholder: "要塞ホスト、ジャンプホスト、本番ゲートウェイ",
+    sshHopDefaultName: "階層 {index}",
+    sshHopInvalidHost: "{hop}: SSHホストは必須です",
+    sshHopInvalidUser: "{hop}: SSHユーザーは必須です",
+    sshHopInvalidPort: "{hop}: SSHポートは1〜65535の範囲で指定してください",
+    sshHopInvalidAuth: "{hop}: パスワード、鍵パス、またはssh-agentが必要です",
+    sshUseAgent: "ssh-agentを使用",
+    sshAgentSockPath: "Agentソケットパス",
+    sshAgentSockPathPlaceholder: "例: ~/.ssh/agent.sock",
+    sshHopInvalidTimeout: "{hop}: SSHタイムアウトは1〜300秒の範囲で指定してください",
+    connectTimeout: "接続タイムアウト（秒）",
+    queryTimeout: "クエリタイムアウト（秒）",
+    idleTimeout: "アイドルタイムアウト（秒）",
+    keepaliveInterval: "Keepalive 間隔（秒）",
+    readOnly: "読み取り専用",
+    readOnlyHint: "すべての書き込み操作（INSERT, UPDATE, DELETEなど）をブロックします",
+    readOnlyBadge: "読み取り専用",
+    proxy: "プロキシ",
+    proxyEnable: "プロキシ経由でデータベースに接続",
+    proxyType: "プロキシタイプ",
+    proxyHost: "プロキシホスト",
+    proxyUsername: "プロキシユーザー",
+    proxyUsernamePlaceholder: "任意",
+    proxyPassword: "プロキシパスワード",
+    proxyPasswordPlaceholder: "任意",
+    tunnelProfile: "トンネルプロファイル",
+    tunnelProfileCustom: "カスタム（この接続のみ）",
+    tunnelProfileManaged: "共有トンネルプロファイルで管理されています。設定 > トンネル で編集すると、次回接続時にこのプロファイルを使用するすべての接続に反映されます。",
+    tunnelProfileMissing: "参照しているトンネルプロファイルが存在しません。別のプロファイルを選択するか、カスタムに切り替えてください。",
+    tunnelProfileMissingName: "プロファイルが見つかりません",
+    tunnelProfileManage: "管理",
+    dremioArrowFlightSqlMode: "Arrow Flight SQL",
+    dremioLegacyJdbcMode: "Legacy JDBC",
+    jdbcUrl: "JDBC URL",
+    jdbcUrlPlaceholder: "jdbc:postgresql://localhost:5432/database",
+    jdbcDriverClass: "ドライバークラス（任意）",
+    jdbcDriverClassPlaceholder: "ほとんどのドライバーは自動登録されます。必要な場合は com.vendor.jdbc.Driver を指定",
+    jdbcDriverPaths: "ドライバーJAR",
+    jdbcDriverSelectPlaceholder: "インポート済みドライバーを選択",
+    jdbcManualClasspath: "手動クラスパス",
+    jdbcManualClasspathCount: "{count}件のパス",
+    jdbcDriverPathsPlaceholder: "/path/to/driver.jar\n/path/to/another-driver.jar",
+    jdbcDriverBrowse: "JDBCドライバーJARを選択",
+    jdbcDocs: "JDBCドキュメントを見る",
+    jdbcPluginHint: "最初にDBX JDBCプラグインをインストールし、次にデータベースベンダーのJDBCドライバーJARをインポートしてください。",
+    dmCompatHint: "システムにDM8 ODBCドライバーがインストールされている必要があります。",
+    dmDownload: "達夢からダウンロード",
+    mongoLegacyHint: "古いMongoDBサーバー（特に4.2未満）ではレガシーを使用してください。認証に失敗しユーザーがadminで作成された場合は、認証DBをadminに設定してください。",
+    mongoTlsAllowInvalidCertificates: "TLS 証明書検証を無効化",
+    mongoTlsAllowInvalidCertificatesHint: "tlsAllowInvalidCertificates=true に対応し、ホスト名だけでなくすべての証明書検証を無効化します。MITM 攻撃のリスクが高まります。SSH トンネル経由の AWS DocumentDB では通常必要です。",
+    mongoRetryWrites: "書き込み再試行",
+    mongoRetryWritesHint: "retryWrites に対応します。AWS DocumentDB は再試行可能な書き込みをサポートしないため、無効にしてください。",
+    compatible: "互換",
+    mainstream: "人気",
+    color: "色",
+    colorNone: "色なし",
+    colorGreen: "緑",
+    colorYellow: "黄",
+    colorOrange: "オレンジ",
+    colorRed: "赤",
+    colorBlue: "青",
+    colorPurple: "紫",
+    colorCustom: "カスタム色",
+    zookeeperConnectString: "接続文字列",
+    zookeeperConnectStringHint: "カンマまたは改行区切りの host:port エントリ。空欄の場合は上のホストとポートを使用します。",
+    zookeeperCreateModePersistent: "永続",
+    zookeeperCreateModeEphemeral: "エフェメラル",
+    zookeeperCreateModePersistentSequential: "永続順序",
+    zookeeperCreateModeEphemeralSequential: "エフェメラル順序",
+    cancelConnecting: "接続をキャンセル",
+    connectCancelled: "接続がキャンセルされました",
+    kafkaKerberosPrincipal: "プリンシパル",
+    kafkaKerberosKeytab: "Keytab",
+    kafkaKerberosServiceName: "サービス名",
+    kafkaKerberosKrb5Conf: "krb5.conf",
+    kafkaKerberosPrincipalRequired: "Kafka Kerberos プリンシパルは必須です",
+    kafkaKerberosKeytabRequired: "Kafka Kerberos keytab のパスは必須です",
+    kafkaKerberosKeytabBrowse: "Keytab を選択",
+    kafkaKerberosKrb5ConfBrowse: "krb5.conf を選択",
+    kafkaKerberosKeytabPlaceholder: "DBX Agent が動作するマシンのパス。例: /etc/security/keytabs/user.keytab",
+    kafkaKerberosKrb5ConfPlaceholder: "オプション。DBX Agent が動作するマシンのパス。例: /etc/krb5.conf",
+    kafkaKerberosPathHint: "keytab と krb5.conf のパスは DBX Agent が読み取るため、DBX Agent が動作するマシン上に存在する必要があります。ブラウザからファイルをアップロードすることはありません。",
+    kafkaKerberosAuthHint: "GSSAPI + keytab を使用してログインします。サーバーが暗号化転送を要求する場合は、Security を SASL_SSL に設定してください。それ以外の場合は Auto または SASL_PLAINTEXT を使用できます。",
+  },
+  editor: {
+    pressToExecute: "{mod}+Enter で実行",
+    pressToSaveSql: "{mod}+S でSQLを保存",
+    queryTimeoutError: "クエリがタイムアウトしました（{seconds}秒）。データベース接続が正常か確認してください。",
+    changeQueryTimeout: "クエリタイムアウトを変更",
+    connectionMayBeLost: "接続が失われた可能性があります。データを更新して再試行してください。",
+    showResultsPane: "結果を表示",
+    hideResultsPane: "結果を非表示",
+    noDatabase: "データベースが選択されていません",
+    unsavedChangesTitle: "未保存の変更",
+    unsavedChangesMessage: "「{title}」に未保存の変更があり、閉じると失われます。保存してから閉じますか？",
+    unsavedChangesBatchCloseMessage: "閉じようとしているタブに未保存の変更があり、閉じると失われます。保存してから続行しますか？",
+    unsavedChangesBatchCloseMultipleMessage: "閉じようとしている {count} 個の SQL タブに未保存の変更があります。現在「{title}」を表示中です。保存してから続行しますか？",
+    unsavedChangesAppCloseMessage: "「{title}」に未保存の SQL 変更があり、DBX の終了後に失われます。保存してから終了しますか？",
+    unsavedChangesAppCloseMultipleMessage: "{count} 個の SQL タブが未保存です。現在「{title}」を表示中です。DBX の終了後に失われます。保存してから終了しますか？",
+    unsavedChangesViewList: "{count} 個のタブを表示",
+    unsavedChangesListTitle: "未保存のタブ（{count}）",
+    discardChanges: "破棄",
+    discardAllChanges: "すべて破棄",
+    saveAllChanges: "すべて保存",
+    selectConnection: "接続を選択",
+    searchConnection: "接続を検索...",
+    selectDatabase: "データベースを選択",
+    searchDatabase: "データベースを検索...",
+    selectSchema: "スキーマを選択",
+    searchSchema: "スキーマを検索...",
+    setDefaultDatabase: "デフォルトに設定",
+    defaultDatabase: "デフォルト",
+    clearDatabase: "データベースをクリア",
+    exPasteNoValues: "クリップボードにIN条件で使える値がありません",
+    exPasteNotList: "変換可能な複数値リストを検出できませんでした",
+    exPasteTooLarge: "クリップボードの内容が大きすぎます。最大 {limit} 文字まで対応しています。",
+    exPasteTooManyValues: "値が多すぎます。最大 {limit} 件まで対応しています。",
+    exPasteClipboardReadFailed: "クリップボードの読み取りに失敗しました: {message}",
+    exPastePasted: "{count} 件のIN条件値を貼り付けました",
+    completion: {
+      nullValue: "NULL値",
+      isNull: "NULLかどうか",
+      isNotNull: "NULLでないかどうか",
+      stringLiteral: "文字列リテラル",
+      numericLiteral: "数値リテラル",
+      booleanValue: "真偽値",
+      starExpansionColumns: "{count}列",
+      functionDescriptions: {
+        COUNT: "行数を返す",
+        SUM: "数値列の合計を返す",
+        AVG: "数値列の平均を返す",
+        MIN: "最小値を返す",
+        MAX: "最大値を返す",
+        GROUP_CONCAT: "グループの値を文字列に連結",
+        STRING_AGG: "グループの文字列を連結",
+        CONCAT: "複数の文字列を連結",
+        CONCAT_WS: "区切り文字付きで文字列を連結",
+        SUBSTRING: "部分文字列を抽出",
+        REPLACE: "文字列内の内容を置換",
+        TRIM: "先頭と末尾の空白を削除",
+        UPPER: "大文字に変換",
+        LOWER: "小文字に変換",
+        LENGTH: "文字列の長さを返す",
+        REGEXP_REPLACE: "正規表現で置換",
+        DATE_FORMAT: "指定された形式で日付をフォーマット",
+        DATEDIFF: "二つの日付の差を計算",
+        DATE_ADD: "日付に間隔を加算",
+        DATE_SUB: "日付から間隔を減算",
+        EXTRACT: "日付の一部を抽出",
+        NOW: "現在の日時を返す",
+        ROUND: "指定された小数点以下桁数で丸める",
+        FLOOR: "切り捨て",
+        CEIL: "切り上げ",
+        ABS: "絶対値を返す",
+        MOD: "除算の余りを返す",
+        COALESCE: "最初の非NULL引数を返す",
+        IFNULL: "NULLの場合に代替値を返す",
+        NULLIF: "引数が等しい場合にNULLを返す",
+        CAST: "式を対象の型に変換",
+        JSON_EXTRACT: "JSONから値を抽出",
+        JSON_VALUE: "JSONからスカラー値を抽出",
+        JSON_OBJECT: "JSONオブジェクトを作成",
+        JSON_ARRAY: "JSON配列を作成",
+      },
+    },
+    contextMenu: {
+      executeSelection: "選択範囲を実行",
+      executeCurrent: "SQLを実行",
+      copySelection: "選択範囲をコピー",
+      sendToAi: "AIに送信",
+      uppercaseSelection: "大文字に変換",
+      lowercaseSelection: "小文字に変換",
+      selectAll: "すべて選択",
+    },
+    search: {
+      find: "検索",
+      replace: "置換",
+      replaceAll: "すべて置換",
+      caseSensitive: "大文字/小文字を区別",
+      regex: "正規表現",
+      collapseReplace: "置換を折りたたむ",
+      expandReplace: "置換を展開",
+      prevMatch: "前へ (Shift+Enter)",
+      nextMatch: "次へ (Enter)",
+      close: "閉じる (Esc)",
+      noResults: "結果なし",
+    },
+    executionPicker: {
+      title: "Execution Target",
+      currentStatement: "Current SQL",
+      allStatements: "All SQL",
+      currentCommand: "Current command",
+      allCommands: "All commands",
+    },
+    selectDatabaseRequired: "先にデータベースを選択してください",
+  },
+  tabs: {
+    sql: "SQL",
+    table: "テーブル",
+    tableData: "テーブルデータ",
+    redis: "Redis",
+    etcd: "etcd",
+    mongo: "Mongo",
+    objects: "オブジェクト",
+    users: "ユーザーと権限",
+    executionSummary: "サマリー",
+    tooltipTitle: "タイトル:",
+    tooltipFilePath: "ファイルパス:",
+    tooltipConnection: "接続:",
+    tooltipDatabase: "データベース:",
+    tooltipTable: "テーブル:",
+    tooltipCollection: "コレクション:",
+    tooltipSchema: "スキーマ:",
+    resultN: "結果 {n}",
+    runN: "実行 {n}",
+    resultRuns: "実行履歴",
+    removeRun: "実行 {n} を削除",
+    autoKeepResults: "クエリ結果を自動保持",
+    autoKeepResultsEnabled: "結果の自動保持をオンにしました",
+    autoKeepResultsDisabled: "結果の自動保持をオフにしました",
+    autoRefresh: "結果を自動更新",
+    autoRefreshShort: "自動",
+    autoRefreshEvery: "{seconds} 秒ごとに更新",
+    startAutoRefresh: "自動更新を開始",
+    stopAutoRefresh: "自動更新を停止",
+    missingResultRun: "この結果は利用できなくなりました",
+    exportResultArchive: "結果アーカイブを保存",
+    importResultArchive: "結果アーカイブをインポート",
+    importedResultArchive: "結果をインポートしました",
+    resultArchiveExported: "結果をエクスポートしました",
+    resultArchiveImported: "結果をインポートしました",
+    resultArchiveUnavailable: "エクスポート可能な保存済み結果がありません",
+    resultArchiveImportInvalid: "この結果アーカイブを開けませんでした",
+    resultArchiveExportFailed: "結果のエクスポートに失敗しました: {message}",
+    resultArchiveImportFailed: "結果のインポートに失敗しました: {message}",
+    scrollLeft: "タブを左にスクロール",
+    scrollRight: "タブを右にスクロール",
+    openTabs: "開いているタブ",
+    fixedTabs: "固定タブ",
+    openDataTabs: "開いているテーブル",
+    zookeeper: "ZooKeeper",
+    vector: "ベクター",
+    gridfs: "GridFS",
+  },
+  executionSummary: {
+    empty: "サマリーはありません",
+    executing: "実行中...",
+    statement: "ステートメント",
+    type: "タイプ",
+    rows: "行数",
+    affected: "影響行数",
+    time: "時間",
+    success: "成功",
+    error: "エラー",
+    returnedTable: "{count}列の結果テーブルを返しました",
+    noTable: "結果テーブルは返されませんでした",
+  },
+  chart: {
+    title: "グラフ",
+    type: "タイプ",
+    line: "折れ線",
+    bar: "棒",
+    pie: "円",
+    noNumericData: "グラフ化できる数値データがありません",
+  },
+  grid: {
+    rows: "{count}行",
+    totalRows: "合計 {count}行",
+    totalRowCount: "（合計 {count}）",
+    totalRowCountLoading: "（カウント中...）",
+    calculateTotalRows: "総行数をカウント",
+    calculateTotalRowsInline: "（総行数をカウント）",
+    calculateTotalRowsFailed: "カウントに失敗しました: {message}",
+    rowsAffected: "{count}行が影響を受けました",
+    querySuccess: "クエリが正常に実行されました",
+    noRows: "データなし",
+    noRowsDescription: "この結果セットにはレコードがありません。",
+    noSearchResults: "一致なし",
+    noSearchResultsDescription: "別のキーワードを試してください。",
+    noFilteredRows: "フィルターに一致する行がありません",
+    noFilteredRowsDescription: "検索テキストまたは行ステータスフィルターを調整してください。",
+    copy: "コピー",
+    mongoJsonPreview: "JSON プレビュー",
+    mongoJsonPreviewEmpty: "プレビューする MongoDB ドキュメントを選択してください。",
+    copyJson: "JSON をコピー",
+    copyDdl: "DDLをコピー",
+    copyCell: "セルをコピー",
+    copyRow: "行をコピー (JSON)",
+    copyColumnJson: "列をコピー (JSON)",
+    copyColumnNames: "列名をコピー",
+    copyRowInsert: "INSERTとしてコピー",
+    copyRowInsertWithoutPrimaryKeys: "主キーなしでINSERTとしてコピー",
+    copyRowUpdate: "UPDATEとしてコピー",
+    copyAll: "すべてコピー (TSV)",
+    selection: "選択範囲",
+    selectionSum: "SUM: {value}",
+    selectionCells: "{count} 個のセル",
+    copySelectionTsv: "選択範囲をコピー (TSV)",
+    copySelectionTsvWithHeaders: "ヘッダー付きで選択範囲をコピー (TSV)",
+    copySelectionCsv: "選択範囲をコピー (CSV)",
+    copySelectionJson: "選択範囲をコピー (JSON)",
+    copySelectionSql: "選択範囲をSQL INリストとしてコピー",
+    clearSelection: "選択をクリア",
+    export: "エクスポート",
+    exportCsv: "CSVエクスポート",
+    exportXlsx: "XLSXエクスポート",
+    exportCurrentPageCsv: "現在のページをCSVでエクスポート",
+    exportCurrentPageXlsx: "現在のページをXLSXでエクスポート",
+    exportCurrentPageJson: "現在のページをJSONでエクスポート",
+    exportCurrentPageMarkdown: "現在のページをMarkdownでエクスポート",
+    exportCurrentPageSql: "現在のページをSQL INSERTでエクスポート",
+    exportCurrentResultCsv: "現在の結果セット全データをCSVでエクスポート",
+    exportCurrentResultXlsx: "現在の結果セット全データをXLSXでエクスポート",
+    exportCurrentResultJson: "現在の結果セット全データをJSONでエクスポート",
+    exportCurrentResultMarkdown: "現在の結果セット全データをMarkdownでエクスポート",
+    exportCurrentResultSql: "現在の結果セット全データをSQL INSERTでエクスポート",
+    exportAllResultsXlsx: "今回実行の全結果セットをXLSXでエクスポート",
+    exportJson: "JSONエクスポート",
+    exportMarkdown: "Markdownエクスポート",
+    exportSql: "SQL INSERTエクスポート",
+    exportSelectedRowsCsv: "選択行をCSVでエクスポート",
+    exportSelectedRowsXlsx: "選択行をXLSXでエクスポート",
+    exportSelectedRowsJson: "選択行をJSONでエクスポート",
+    exportSelectedRowsMarkdown: "選択行をMarkdownでエクスポート",
+    exportSelectedRowsSql: "選択行をSQL INSERTでエクスポート",
+    exported: "エクスポートしました",
+    exportFailed: "エクスポートに失敗しました: {message}",
+    copied: "コピーしました",
+    copyFailed: "コピーに失敗しました: {message}",
+    domRenderMode: "DOM",
+    canvasRenderMode: "Canvas",
+    renderModeHint: "CanvasレンダリングとDOMフォールバックグリッドを切り替えます。",
+    tableFontSize: "テーブルのフォントサイズ",
+    filter: "フィルター",
+    conditionHistoryEmpty: "履歴はまだありません",
+    conditionHistoryNoMatches: "一致する履歴はありません",
+    filterBuilder: "フィルター",
+    filterBuilderTitle: "フィルター",
+    filterBuilderHint: "ポイントアンドクリックで条件を作成し、WHERE入力と組み合わせます。",
+    filterBuilderSummary: "{count}件のルール",
+    filterBuilderAddRule: "ルールを追加",
+    filterBuilderColumn: "列",
+    filterBuilderValue: "値",
+    filterBuilderNoValue: "値は不要です",
+    filterBuilderEmpty: "ルールを追加して行のフィルタリングを開始してください。",
+    resetFilterBuilder: "ルールをリセット",
+    filterBuilderEquals: "等しい",
+    filterBuilderNotEquals: "等しくない",
+    filterBuilderContains: "含む",
+    filterBuilderNotContains: "含まない",
+    filterBuilderGreaterThan: "より大きい",
+    filterBuilderLessThan: "より小さい",
+    filterBuilderIsNull: "NULLである",
+    filterBuilderIsNotNull: "NULLでない",
+    columnActions: "列の操作",
+    localFilter: "ローカル値フィルター",
+    localFilterFor: "'{column}'のローカル値",
+    databaseValueFilter: "データベース値フィルター",
+    databaseValueFilterFor: "'{column}'のデータベース値",
+    columnFormatter: "列フォーマッター",
+    columnFormatterFor: "'{column}'のフォーマッター",
+    columnFormatterHint: "表示のみをフォーマットし、実際の値は変更されません。",
+    formatterType: "タイプ",
+    formatterDatetime: "Unixタイムスタンプ",
+    formatterJsonPath: "JSONパス",
+    formatterMask: "テキストをマスク",
+    formatterCustomTemplate: "カスタムテンプレート",
+    formatterTimestampUnit: "タイムスタンプ単位",
+    formatterUnitAuto: "自動",
+    formatterUnitSeconds: "秒",
+    formatterUnitMilliseconds: "ミリ秒",
+    formatterDatetimePattern: "日時フォーマット",
+    formatterDatetimePatternPlaceholder: "日時フォーマットを選択または入力",
+    formatterDatetimePatternEmpty: "ISO8601フォーマット",
+    formatterJsonPathInput: "JSONパス",
+    formatterMaskPrefix: "表示する接頭辞",
+    formatterMaskSuffix: "表示する接尾辞",
+    formatterSavedCustom: "保存済みテンプレート",
+    formatterNewCustom: "新しいテンプレート",
+    formatterCustomName: "テンプレート名",
+    formatterCustomNamePlaceholder: "例: ユーザーラベル",
+    formatterCustomTemplateInput: "テンプレート",
+    formatterCustomTemplateHint: "利用可能な変数: ${value}, ${upper}, ${lower}, ${length}。名前を付けるとリストに保存されます。",
+    formatterPreview: "プレビュー",
+    saveFormatter: "保存",
+    clearFormatter: "クリア",
+    searchValues: "値を検索...",
+    loadingValues: "値を読み込み中...",
+    serverValuesLimited: "最初の{count}件の値を表示中",
+    filterTypedValue: "'{value}'を使用",
+    value: "値",
+    count: "件数",
+    applyFilter: "フィルターを適用",
+    clearLocalFilters: "ローカル値フィルターをクリア",
+    clearLocalFiltersShort: "ローカルをクリア",
+    localFiltersActive: "{count}件のローカル値フィルター",
+    localFilterMoreValues: " +{count}件以上",
+    columnVisibility: "列",
+    columnVisibilityHint: "少なくとも1列は表示されます。",
+    searchColumns: "列を検索...",
+    dragColumnToReorder: "列ヘッダーをドラッグして並べ替え",
+    invertColumnVisibility: "反転",
+    resetColumnOrder: "順序をリセット",
+    showAllColumns: "すべて表示",
+    viewOptions: "表示オプション",
+    hideNullColumns: "NULL列を非表示",
+    hideNullColumnsHint: "現在の結果ですべてNULLの列の表示を切り替えます。",
+    moreValues: "さらに{count}件の値があります。絞り込むには入力を続けてください",
+    filterByValue: "この値でフィルター",
+    filterExcludeValue: "この値を除外",
+    filterLike: "値を含む",
+    filterNotLike: "値を含まない",
+    filterLessThan: "値より小さい",
+    filterGreaterThan: "値より大きい",
+    filterIsNull: "NULL値を表示",
+    filterIsNotNull: "非NULL値を表示",
+    clearFilter: "フィルターをクリア",
+    sort: "並び替え",
+    sortAscending: "昇順",
+    sortDescending: "降順",
+    sortCurrentPageAscending: "現在のページを昇順に並び替え",
+    sortCurrentPageDescending: "現在のページを降順に並び替え",
+    sortDatabaseAscending: "データベースで昇順に並び替え",
+    sortDatabaseDescending: "データベースで降順に並び替え",
+    clearSort: "並び替えをクリア",
+    pasted: "貼り付けました！",
+    search: "検索...",
+    searchOrWhere: "検索、またはWHERE句を入力...",
+    applyWhere: "WHEREを適用",
+    filterRows: "行をフィルター",
+    filterAllRows: "すべての行",
+    filterChangedRows: "変更あり",
+    page: "{page}ページ",
+    rowsPerPage: "1ページあたりの行数",
+    customRowsPerPage: "カスタム行数",
+    applyPageSize: "適用",
+    save: "保存",
+    discard: "破棄",
+    dismiss: "閉じる",
+    addRow: "行を追加",
+    quickEntryDraftPlaceholder: "新規",
+    cloneRow: "新しい行として複製",
+    deleteRow: "行を削除",
+    deleteRows: "{count}行を削除",
+    cloneRows: "{count}行を新しい行として複製",
+    restoreRows: "{count}行を復元",
+    copyRows: "{count}行をコピー (JSON)",
+    copySelectedRowsTsv: "{count}行をコピー (TSV)",
+    copySelectedRowsTsvWithHeaders: "{count}行をヘッダー付きでコピー (TSV)",
+    copySelectedRowTsv: "1行をコピー (TSV)",
+    copySelectedRowTsvWithHeaders: "1行をヘッダー付きでコピー (TSV)",
+    copyColumnsJson: "{count}列をコピー (JSON)",
+    copyRowsInsert: "{count}行をINSERTとしてコピー",
+    copyRowsInsertMerged: "{count}行をINSERTとしてコピー（まとめて）",
+    copyRowsInsertRowByRow: "{count}行をINSERTとしてコピー（行ごと）",
+    copyRowsInsertWithoutPrimaryKeys: "{count}行を主キーなしでINSERTとしてコピー",
+    copyRowsInsertWithoutPrimaryKeysMerged: "{count}行を主キーなしでINSERTとしてコピー（まとめて）",
+    copyRowsInsertWithoutPrimaryKeysRowByRow: "{count}行を主キーなしでINSERTとしてコピー（行ごと）",
+    copyRowsUpdate: "{count}行をUPDATEとしてコピー",
+    selectedRows: "{count}行選択中",
+    restoreRow: "行を復元",
+    statusClean: "未変更",
+    statusNew: "新規",
+    statusEdited: "更新",
+    statusDeleted: "削除",
+    pendingChanges: "{count}件の保留中",
+    selectedCells: "{count}件選択中",
+    bulkEditSelection: "一括編集",
+    bulkEditTitle: "一括編集",
+    bulkEditDescription: "選択した{count}セルにこの値を設定します。",
+    bulkEditValuePlaceholder: "値、またはNULL",
+    applyBulkEdit: "適用",
+    cellDetails: "セル詳細",
+    cellDetailLayoutBottom: "下部に表示",
+    cellDetailLayoutRight: "右側に表示",
+    openCellDetailsDialog: "セル詳細を開く",
+    rowDetails: "行詳細",
+    rowDetailsFor: "行 {row} の詳細",
+    openRowDetailsDialog: "行詳細を開く",
+    openColumnDetailsDialog: "列詳細を開く",
+    columnDetailsFor: "{column} 列の詳細",
+    columnsCount: "{count}列",
+    rowCount: "行数",
+    rowsCount: "{count}行",
+    fieldIndex: "No.",
+    cellValue: "値",
+    valueEditor: "値エディタ",
+    hexViewer: "Hex ビューア",
+    hexViewerByteCount: "{count} バイト",
+    hexViewerOffset: "オフセット",
+    hexViewerHex: "Hex",
+    hexViewerAscii: "ASCII",
+    hexViewerEmpty: "表示できるバイナリバイトがありません。",
+    imagePreview: "画像プレビュー",
+    imageLoadFailed: "画像の読み込みに失敗しました",
+    geometryPreview: "ジオメトリプレビュー",
+    layerPreview: "レイヤープレビュー",
+    zoomIn: "拡大",
+    zoomOut: "縮小",
+    fitImage: "表示領域に合わせる",
+    openImage: "画像を開く",
+    columnName: "列",
+    columnType: "データ型",
+    columnComment: "コメント",
+    rowNumber: "行",
+    valueLength: "長さ",
+    nullValue: "NULL",
+    noComment: "コメントなし",
+    formattedJson: "フォーマット済みJSON",
+    formattedValue: "フォーマット済み値",
+    detailSearchPlaceholder: "フィールドまたは値を検索…",
+    detailSearchNoMatch: "一致なし",
+    rawValue: "生の値",
+    largeValuePreviewHint: "先頭{count}文字をプレビュー表示中です。コピー時は完全な値が使用されます。",
+    copyValue: "値をコピー",
+    downloadBinaryValue: "値をダウンロード",
+    downloadSaved: "{path} に保存しました",
+    downloadStarted: "ダウンロード開始: {fileName}",
+    binaryDownload: {
+      binary: "生バイナリ",
+      utf8: "デコード済みテキスト (UTF-8)",
+      gbk: "デコード済みテキスト (GBK)",
+    },
+    copyRowTsv: "行をコピー (TSV)",
+    copyColumnValues: "列をコピー (JSON)",
+    copyColumnTsv: "列をコピー (TSV)",
+    editValue: "値を編集",
+    formatJson: "JSONをフォーマット",
+    compactJson: "JSON を圧縮",
+    formattedJsonEditWarning: "フォーマット済みJSONを編集中です。保存するとJSONとして書き込まれるため、元の書式が変わる場合があります。",
+    setNull: "NULLに設定",
+    restoreOriginalValue: "元の値に戻す",
+    copyColumnName: "列名をコピー",
+    copyAlterColumnSql: "SQL ALTERとしてコピー",
+    alterSqlCopied: "SQL ALTERをクリップボードにコピーしました",
+    alterSqlCopiedWithWarnings: "SQL ALTERをクリップボードにコピーしました（{count}件の警告）",
+    noAlterSqlAvailable: "この列に利用可能なALTER SQLはありません",
+    copyAlterSqlFailed: "コピーに失敗しました: {message}",
+    copySqlCondition: "SQL条件をコピー",
+    transpose: "行を転置",
+    transposeMultiRowToggle: "複数行",
+    transposeSingleRow: "現在の行",
+    transposeMultiRow: "複数行",
+    transposeMultiRowHint: "有効時は転置ビューに複数行が表示されます。無効時は現在の行のみ表示されます。",
+    rowsPerPageShort: " 行",
+    columnDetails: "列詳細",
+    tableInfo: "テーブル情報",
+    tableInfoColumns: "列",
+    tableInfoIndexes: "インデックス",
+    tableInfoForeignKeys: "外部キー",
+    tableInfoTriggers: "トリガー",
+    tableInfoNullable: "NULL許容",
+    tableInfoEmpty: "メタデータなし",
+    tableInfoSearch: "検索...",
+    tableInfoNoResults: "結果なし",
+    goToColumn: "列へ移動",
+    columnWidth: "列幅",
+    columnWidthCompact: "コンパクト",
+    columnWidthStandard: "標準",
+    columnWidthComfortable: "ゆったり",
+    searchColumn: "列/コメントを検索...",
+    noColumnsFound: "列が見つかりません",
+    queryError: "クエリエラー",
+    dataUnavailable: "テーブルデータを再読み込みする必要があります。",
+    dataUnavailableHintPrefix: "",
+    dataUnavailableHintSuffix: " を押すか、下の更新ボタンをクリックして再読み込みしてください。",
+    refresh: "更新",
+    commit: "コミット",
+    rollback: "ロールバック",
+    transactionSaveHint: "{count}件の保留中の変更をトランザクションでコミットします。",
+    nonTransactionalSaveHint: "{count}件の保留中の変更を1件ずつ保存します。途中で失敗した場合、それまでの成功した変更はロールバックされません。",
+    keylessEditWarning: "主キーなし",
+    keylessEditWarningHint: "このテーブルには主キーがありません。更新と削除はWHERE句にすべての元の行値を使用します。完全に重複する行はまとめて影響を受ける可能性があります。",
+    queryEditReadOnly: "読み取り専用の結果",
+    queryEditUnsupported: {
+      "not-select": "SELECTクエリの結果のみ直接編集できます。",
+      cte: "WITH/CTEを使用したクエリはまだ編集できません。単純な単一テーブルSELECTを使用してください。",
+      "set-operation": "UNION、INTERSECT、EXCEPTの結果はソース行に安全にマッピングできません。",
+      aggregation: "DISTINCT、GROUP BY、HAVING、および集計結果は直接編集できません。",
+      "external-source": "外部ファイルとテーブル関数の結果は直接書き戻せません。編集前にデータベーステーブルにインポートしてください。",
+      "complex-source": "DBX はこの結果に対して安全に書き戻せる対象テーブルを 1 つに特定できませんでした。",
+      "computed-columns": "計算式や関数の結果は書き戻せません。代わりに生の列名を選択してください。",
+      "no-table": "編集可能なソーステーブルが検出されませんでした。",
+      "no-primary-key": "対象テーブルに主キーがないため、行を安全に更新または削除できません。",
+      "primary-key-not-returned": "結果に生の主キー列が含まれていません。元の列名で含めてください。",
+      "aliased-columns": "結果の列がエイリアスや式を使用しています。元の名前で編集可能な列を選択してください。",
+      "metadata-unavailable": "DBXがテーブルメタデータを読み込めなかったため、結果の編集は無効です。",
+    },
+    sortUnsupported: "このSQLは完全な結果の並び替えをサポートしていません。単一のSELECTクエリで再試行してください。",
+    truncatedHint: "結果は{count}行に切り詰められました。フッターのページネーションを使用するか、1ページあたりの行数を調整してください。",
+    loadingMore: "さらにデータを読み込み中...",
+    allLoaded: "すべて読み込み済み",
+    previewSqlEmpty: "プレビューする保留中のSQL変更はありません",
+    renderMode: "レンダーモード",
+    undoChange: "変更を元に戻す",
+    redoChange: "変更をやり直す",
+    filterBuilderSearchColumns: "フィールドを検索...",
+    filterBuilderNoMatchingColumns: "一致するフィールドがありません",
+  },
+  exportProgress: {
+    title: "テーブルデータをエクスポート中",
+    fetching: "データベースからデータを取得中...",
+    writing: "ファイルに書き込み中...",
+    done: "エクスポートが完了しました！",
+    error: "エクスポートに失敗しました",
+    cancelled: "エクスポートがキャンセルされました。",
+    rowsCount: "{exported} / {total} 行",
+    rowsExported: "{count}行をエクスポートしました",
+    rowsShort: "行",
+    cancel: "キャンセル",
+    close: "閉じる",
+    tooltip: "エクスポートの進行状況",
+    popoverTitle: "エクスポート",
+    noTasks: "エクスポートはありません",
+    clearFinished: "完了をクリア",
+    showMore: "さらに{count}件表示",
+    showLess: "少なく表示",
+    delete: "削除",
+    failedTooltip: "{count}件のバックグラウンドタスクが失敗しました",
+    databaseExportTitle: "データベースバックアップ: {name}",
+    sqlFileTitle: "SQLファイル: {name}",
+    dataTransferTitle: "データ転送: {name}",
+    objectsCount: "{current} / {total} オブジェクト",
+    tablesCount: "{current} / {total} テーブル",
+    statementsCount: "{done}成功、{failed}失敗",
+  },
+  welcome: {
+    title: "データベースワークスペース",
+    subtitle: "左側の接続を選択してスキーマを参照するか、直接クエリタブを開いてください。",
+    connections: "接続",
+    connected: "接続済み",
+    databaseTypes: "データベースタイプ",
+    quickConnections: "クイックスタート",
+    quickConnectionsHint: "接続をクリックしてクエリタブを開きます。",
+    shortcuts: "ショートカット",
+    shortcutsHint: "ここから次の操作を開始します。",
+    sqlHistory: "クエリ履歴",
+    sqlHistoryEmpty: "SQLライブラリの記録はまだありません",
+    sqlHistoryOpenCount: "{count}回開きました",
+    unknownConnection: "不明な接続",
+    tip: "左側の接続を展開し、データベースやテーブルを右クリックしてさらに操作できます。",
+    tipSidebar: "左側のテーブルをクリックしてデータを表示",
+    tipExecute: "でクエリを実行",
+    fileOpened: "{name} を開きました",
+    mcpTitle: "AIエージェント連携",
+    mcpDescription: "内蔵AIアシスタントに加えて、Claude Code、Cursor、その他のコーディングエージェントをMCP経由でデータベースクエリに使用できます。",
+    mcpLearnMore: "詳細を見る",
+  },
+  common: {
+    language: "言語",
+    loading: "読み込み中...",
+    stopping: "停止中...",
+    close: "閉じる",
+    cancel: "キャンセル",
+    save: "保存",
+    retry: "再試行",
+    more: "もっと見る",
+    decrease: "縮小",
+    increase: "拡大",
+    showPassword: "パスワードを表示",
+    hidePassword: "パスワードを隠す",
+    done: "完了",
+    connection: "接続",
+    database: "データベース",
+    table: "テーブル",
+    view: "ビュー",
+    materializedView: "マテリアライズドビュー",
+    procedure: "プロシージャ",
+    function: "関数",
+    sequence: "シーケンス",
+    package: "パッケージ",
+    packageBody: "パッケージ本体",
+    copy: "コピー",
+    import: "インポート",
+    remove: "削除",
+    noResults: "結果なし",
+  },
+  quickOpen: {
+    placeholder: "接続、データベース、テーブル、その他のオブジェクトを検索...",
+    emptyPlaceholder: "入力して検索を開始",
+    noResults: "結果が見つかりません",
+    results: "件の結果",
+    navigate: "ナビゲート",
+    select: "選択",
+    close: "閉じる",
+  },
+  explain: {
+    title: "実行計画",
+    standardTable: "標準テーブル",
+    tree: "ツリー",
+    summary: "サマリー",
+    running: "実行計画を読み取り中...",
+    empty: "実行計画がありません",
+    nodeCount: "{count}ノード",
+    node: "ノード",
+    relation: "テーブル",
+    index: "インデックス",
+    cost: "コスト",
+    rows: "行数",
+    details: "詳細",
+    unsupported: "このデータベースではまだ実行計画をサポートしていません",
+    emptySql: "実行計画を表示するSQLがありません",
+    unsafe: "この最初のバージョンではSELECT / WITH / TABLE / VALUES文のみの実行計画を表示します",
+  },
+  lineage: {
+    title: "フィールドリネージ",
+    open: "フィールドリネージを表示",
+    loading: "メタデータを読み取り中 {done}/{total}",
+    empty: "関連するリネージが見つかりません",
+    noFiltered: "現在のフィルターに一致する結果はありません",
+    targetField: "現在のフィールド",
+    searchPlaceholder: "テーブル、フィールド、ビュー、SQLスニペットを検索...",
+    showing: "{shown}/{total}件の結果を表示中",
+    all: "すべて",
+    certain: "確定",
+    likely: "可能性高",
+    possible: "可能性あり",
+    queryHistory: "クエリ履歴",
+    openTable: "テーブルを開く",
+    copy: "名前をコピー",
+    copied: "コピーしました",
+    kind: {
+      foreignKey: "外部キー",
+      viewReference: "ビュー",
+      historyReference: "SQL履歴",
+      sameName: "同名",
+    },
+    description: {
+      foreignKeyIncoming: "{target} は外部キーを通じて現在のフィールドを参照しています。これは検証済みの依存関係です。",
+      foreignKeyOutgoing: "現在のフィールドは外部キーを通じて {target} を参照しています。これは検証済みの依存関係です。",
+      viewLikely: "ビュー定義が対象テーブルとフィールドの両方に言及しています。通常はクエリ依存関係を示します。",
+      viewPossible: "ビュー定義が同名フィールドに言及していますが対象テーブルには言及していないため、確認が必要です。",
+      historyLikely: "履歴SQL文が対象テーブルとフィールドの両方に言及しています。影響分析のコンテキストとして使用してください。",
+      historyPossible: "履歴SQL文が同名フィールドに言及しています。関連している可能性がありますがコンテキストが必要です。",
+      sameName: "別のテーブルに同名フィールドがあります。ビジネス上の意味を共有している可能性がありますが、検証済みのデータベース依存関係ではありません。",
+    },
+    cancel: "キャンセル",
+    refresh: "再分析",
+  },
+  connectionGroup: {
+    createGroup: "新しいグループ",
+    groupNamePlaceholder: "グループ名",
+    renameGroup: "グループ名を変更",
+    deleteGroup: "グループを削除",
+    moveToGroup: "グループに移動",
+    moveToNewGroup: "新しいグループに移動",
+    ungrouped: "グループなし",
+    newGroup: "新しいグループ...",
+    newGroupDefault: "新しいグループ",
+    deleteGroupConfirmTitle: "グループを削除",
+    deleteGroupConfirmMessage: "グループ「{name}」を削除しますか？グループ内の接続はトップレベルに移動されます。",
+    selectConnection: "接続を選択",
+    deselectConnection: "接続の選択を解除",
+    selectAllConnections: "すべての接続を選択",
+    deselectAllConnections: "すべての接続の選択を解除",
+    exitMultiSelect: "複数選択を終了",
+  },
+  databaseSearch: {
+    title: "データベース検索",
+    open: "データベース検索",
+    keyword: "キーワード",
+    keywordPlaceholder: "ユーザーID、メールアドレス、注文番号などを入力...",
+    limitPerTable: "テーブルあたり",
+    search: "検索",
+    searching: "検索中",
+    stop: "停止",
+    hint: "現在のデータベースまたはスキーマ内の通常テーブルをスキャンします。バイナリ列はスキップされ、一度に過剰なデータを読み込まないよう各テーブルに上限が設定されています。",
+    loadingTables: "テーブル一覧を読み取り中...",
+    progress: "{done}/{total}テーブルをスキャンしました",
+    resultCount: "{count}件の一致",
+    limitedTables: "大規模スキーマが検出されました。最初の{count}テーブルのみスキャンされます",
+    results: "結果",
+    openResult: "開く",
+    waiting: "一致を待機中...",
+    noResults: "一致する結果はまだありません",
+    errors: "一部のテーブルで失敗しました",
+  },
+  configExport: {
+    passphraseTitle: "暗号化してエクスポート",
+    passphraseImportTitle: "復号してインポート",
+    passphraseExportHint: "エクスポートに接続パスワードを含めるには、暗号化用のパスフレーズを設定してください。インポート時に同じパスフレーズが必要です。",
+    passphraseImportHint: "このファイルは暗号化されています。復号してインポートするためにパスフレーズを入力してください。",
+    passphrase: "パスフレーズ",
+    passphraseConfirm: "パスフレーズを確認",
+    passphrasePlaceholder: "パスフレーズを入力",
+    passphraseConfirmPlaceholder: "パスフレーズを再入力",
+    passphraseRequired: "パスフレーズは必須です",
+    passphraseMismatch: "パスフレーズが一致しません",
+    passphraseTooShort: "パスフレーズは4文字以上必要です",
+    exportEncrypted: "エクスポート",
+    decryptImport: "復号してインポート",
+    wrongPassphrase: "パスフレーズが間違っているか、ファイルが破損しています",
+    cryptoUnavailable: "暗号化設定のインポートはこのブラウザ環境では利用できません。HTTPS、localhost、またはDBX Desktopを使用してください。",
+    exportSuccess: "接続を正常にエクスポートしました",
+    importSuccess: "{count}件の接続をインポートしました",
+    importNavicatSuccess: "{count}件のNavicat接続をインポートしました。テスト前にパスワードが空の接続を入力してください。",
+    importDatagripSuccess: "{count}件のDataGrip接続をインポートし、macOSキーチェーンから{filled}件のパスワードを復元しました。",
+    importDbeaverSuccess: "{count}件のDBeaver接続をインポートしました。テスト前にパスワードが空の接続を入力してください。",
+    importNone: "インポートする新しい接続はありません",
+    importLayoutConfirm: "インポートされたファイルに接続グループが含まれています。適用しますか？",
+    importLayoutTitle: "グループをインポート",
+    importLayoutApply: "適用",
+  },
+  ai: {
+    placeholder: "自然言語でクエリを説明してください...",
+    settings: "AI設定",
+    noConfig: "AIが設定されていません。設定 > AIでAIプロバイダーを設定してください。",
+    provider: "プロバイダー",
+    providerStatusActive: "使用中",
+    providerStatusConfigured: "設定済み",
+    switchProvider: "プロバイダーを切替",
+    model: "モデル",
+    browseModels: "モデルを参照",
+    refreshModels: "モデルを更新",
+    loadingModels: "モデルを読み込み中...",
+    searchModels: "モデルを検索",
+    noModels: "モデルが読み込まれていません",
+    modelListHint: "更新をクリックしてプロバイダーからモデルを読み込んでください。",
+    modelListUnsupported: "このプロバイダーはモデル一覧の取得をサポートしていません。",
+    modelListEndpointRequired: "モデルを読み込む前にエンドポイントを入力してください。",
+    modelListApiKeyRequired: "モデルを読み込む前にAPIキーを入力してください。",
+    codexMcpRequiredTitle: "DBX MCP Serverが必要です",
+    codexMcpRequiredDescription: "Codex CLIはDBX MCP Server経由でデータベーススキーマとクエリツールにアクセスします。AIアシスタントでCodexを使う前にインストールしてください。",
+    codexCliPathEnvError: "Codex CLI Pathには実行ファイルのパスのみを入力してください。環境変数は下に追加してください。",
+    codexCliEnv: "環境変数",
+    codexCliEnvAdd: "変数を追加",
+    codexCliEnvHint: "HTTPS_PROXY、NO_PROXY、SSL_CERT_FILE、CODEX_CA_CERTIFICATEなど、Codex CLIに渡す任意の変数。",
+    codexCliEnvKeyPlaceholder: "HTTPS_PROXY",
+    codexCliEnvValuePlaceholder: "http://proxy:9800",
+    codexCliEnvInvalidName: "無効な環境変数名: {name}",
+    codexCliEnvReservedName: "{name}はMCP Server用にDBXが管理しているため、ここでは設定できません。",
+    contextWindow: "コンテキストウィンドウ",
+    contextWindowAuto: "自動（モデル名から検出）",
+    contextWindowHint: "トークン数。空欄で自動検出。ローカル/カスタムモデルは手動設定してください。",
+    codexCliPath: "Codex CLI パス",
+    codexCliPathHint: "空欄の場合はPATHからcodexを使用します。codex loginで別途サインインしてください。",
+    reasoningLevel: "推論レベル",
+    reasoningLevelDefault: "デフォルト",
+    reasoningLevelMinimal: "最小",
+    reasoningLevelLow: "低",
+    reasoningLevelMedium: "中",
+    reasoningLevelHigh: "高",
+    reasoningLevelHint: "Codex CLIのmodel_reasoning_effortを制御します。デフォルトではCodex設定を使用します。",
+    run: "実行",
+    readingSchema: "スキーマを読み取り中",
+    noConnection: "このタブに利用可能な接続がありません",
+    noSql: "処理するSQLがありません",
+    sqlPreview: "SQLプレビュー",
+    copySql: "SQLをコピー",
+    copyCode: "コードをコピー",
+    executeSql: "SQLを実行",
+    tempRunSql: "編集せずに実行",
+    copyAll: "すべてコピー",
+    copied: "コピーしました",
+    copyTestResult: "テスト結果をコピー",
+    replace: "エディタを置換",
+    append: "エディタに追加",
+    apply: "エディタに適用",
+    clear: "チャットをクリア",
+    welcome: "クエリしたい内容を教えてください。SQLを作成します",
+    newChat: "新しいチャット",
+    thinking: "思考中...",
+    reasoningProcess: "思考プロセス",
+    stopGenerating: "生成を停止",
+    scrollToBottom: "一番下へ戻る",
+    tableMentionEmpty: "一致するテーブルまたは SQL ファイルがありません",
+    tableMentionPlaceholderHint: "{'@'}を入力してコンテキスト用のテーブルまたは SQL ファイルを指定",
+    tableMentionTypes: {
+      table: "テーブル",
+      view: "ビュー",
+      systemTable: "システムテーブル",
+      temporaryTable: "一時テーブル",
+    },
+    modes: {
+      ask: "質問",
+      agent: "エージェント",
+    },
+    modeHints: {
+      ask: "SQLと説明を生成します（自動実行しません）",
+      agent: "可能な場合に安全なクエリを自動実行します",
+    },
+    fixWithAi: "AIで修正",
+    truncated: "コンテキストが切り詰められました",
+    contextSummary: "{database} · {tables}テーブル",
+    autoSqlBlocked: "AIが生成したSQLは自動実行するにはリスクが高すぎると判断されました。実行前に手動で確認してください。",
+    proposalConfirmYes: "はい、続行",
+    proposalConfirmNo: "いいえ",
+    proposalConfirmTitle: "操作の確認",
+    agentSteps: {
+      generated: "SQL生成完了",
+      noSql: "SQLが見つかりません",
+      safe: "安全性チェック合格",
+      needsConfirm: "確認が必要",
+      blocked: "ブロックされました",
+      autoExecute: "実行準備完了",
+      notRequested: "実行は要求されていません",
+      skipped: "未実行",
+      callingTool: "ツールを呼び出し中...",
+      toolDone: "ツール完了",
+      toolError: "ツールエラー",
+      executeSafe: "安全チェック通過 · 実行済み",
+      executeBlocked: "安全チェックによりブロック",
+      contextCompacted: "コンテキストを圧縮しました",
+    },
+    agentStepTitles: {
+      riskCheck: "リスクチェック: {action} · {category} · {environment} · {reasons}",
+      blocked: "リスクポリシーにより実行がブロックされました。SQLを手動で確認してください。",
+      requiresConfirmation: "このSQLは実行前に確認が必要です。",
+      askMode: "質問モードではSQLを自動実行しません。",
+      unsupportedAction: "現在のAIアクションではSQLを自動実行しません。",
+      noSql: "応答に実行可能なSQLコードブロックが含まれていませんでした。",
+      notRequested: "ユーザーがSQLの実行を要求しませんでした。",
+      skipped: "このステップは実行されませんでした。",
+    },
+    proxy: "プロキシ",
+    proxyEnable: "プロキシ経由でAIリクエストを送信",
+    proxyUrl: "プロキシURL",
+    enableThinking: "思考",
+    enableThinkingOn: "有効",
+    enableThinkingOff: "無効",
+    enableThinkingHint: "このオプションは/chat/completions APIとサポートされているモデルでのみ有効です。無効にするとトークン使用量を大幅に削減できますが、生成結果の品質が若干低下する可能性があります。",
+    anthropicMessagesHint: "Anthropic Messages 互換 API は通常 /v1/messages を使用します。",
+    actions: {
+      general: "一般的な質問",
+      generate: "SQLを生成",
+      explain: "SQLを説明",
+      optimize: "SQLを最適化",
+      fix: "エラーを修正",
+      convert: "方言を変換",
+      sampleData: "サンプルデータ",
+      query: "データを照会",
+      exploreSchema: "スキーマを確認",
+      executeAndExplain: "実行して解説",
+      generateNoExec: "生成のみ（実行しない）",
+    },
+    placeholders: {
+      general: "何でも聞いてください...",
+      generate: "クエリしたい内容を説明してください（例: 過去7日間のユーザーごとの注文数）",
+      explain: "任意: 理解したい内容を追加",
+      optimize: "任意: 目標を追加（例: フルテーブルスキャンを減らす）",
+      fix: "エラーを貼り付けるか、期待する結果を説明してください",
+      convert: "例: PostgreSQL / MySQL / SQL Serverに変換",
+      sampleData: "生成するサンプルデータやテスト文を説明してください",
+      query: "照会や集計するデータを入力（例: 今月の地域別注文合計）",
+      exploreSchema: "確認したいテーブルや構造を入力（例: orders テーブルのカラムとインデックス）",
+      executeAndExplain: "任意: 解説の重点を追加",
+    },
+    editMessage: "メッセージを編集",
+    editResend: "再送信",
+    editCancel: "キャンセル",
+  },
+  contextMenu: {
+    openConnection: "接続を開く",
+    closeConnection: "接続を閉じる",
+    closeDatabaseConnection: "データベース接続を閉じる",
+    deleteConnection: "接続を削除",
+    deleteSelectedConnections: "選択した{count}件の接続を削除",
+    confirmDeleteTitle: "接続を削除",
+    confirmDeleteMessage: "本当に「{name}」を削除しますか？この操作は取り消せません。",
+    confirmDeleteSelectedMessage: "選択した{count}件の接続を削除しますか？この操作は取り消せません。",
+    editConnection: "接続を編集",
+    revealDatabaseFile: "ファイルマネージャーで表示",
+    selectVisibleDatabases: "表示するデータベースを選択",
+    userAdmin: "ユーザーと権限",
+    openUserAdmin: "ユーザーと権限を開く",
+    damengJobAdmin: "Dameng エージェントジョブ",
+    openDamengJobAdmin: "Dameng エージェントジョブを開く",
+    duplicateConnection: "接続を複製",
+    duplicateSelectedConnections: "選択した{count}件の接続を複製",
+    newQuery: "新しいクエリ",
+    newSql: "新しいSQL",
+    generateSql: "SQLを生成",
+    newInsert: "新しいINSERT",
+    newUpdate: "新しいUPDATE",
+    sqlHistory: "クエリ履歴",
+    noSqlHistory: "関連するSQLはありません",
+    openObjectBrowser: "オブジェクトを参照",
+    viewData: "データを表示",
+    editStructure: "構造を編集",
+    editColumn: "列を編集",
+    editIndex: "インデックスを編集",
+    refreshChildren: "更新",
+    expandAll: "すべて展開",
+    pin: "ピン留め",
+    unpin: "ピン留め解除",
+    fixTab: "タブを固定",
+    unfixTab: "タブの固定を解除",
+    refreshTab: "データを更新",
+    renameTab: "タブ名を変更",
+    duplicateTab: "タブを複製",
+    compactTabTitle: "タブタイトルを短縮",
+    fullTabTitle: "タブの完全なタイトルを表示",
+    closeTab: "タブを閉じる",
+    closeFixedTab: "固定タブを閉じる",
+    closeOtherTabs: "他のタブを閉じる",
+    closeOtherRegularTabs: "他の通常タブを閉じる",
+    closeOtherFixedTabs: "他の固定タブを閉じる",
+    closeAllTabs: "すべてのタブを閉じる",
+    closeAllRegularTabs: "すべての通常タブを閉じる",
+    closeAllFixedTabs: "すべての固定タブを閉じる",
+    copyName: "名前をコピー",
+    copyFinalProxyPort: "最終プロキシポートをコピー",
+    finalProxyPortCopied: "最終プロキシポート {port} をコピーしました",
+    setDefaultDatabase: "デフォルトデータベースに設定",
+    clearDefaultDatabase: "デフォルトデータベースをクリア",
+    exportDatabase: "データベースをエクスポート",
+    exportAllDatabases: "すべてのデータベースをエクスポート",
+    exportDatabaseSuccess: "{count}テーブルをエクスポートしました（各{limit}行まで）",
+    exportDatabaseFailed: "データベースのエクスポートに失敗しました: {message}",
+    backupSqliteDatabase: "SQLiteデータベースをバックアップ",
+    backupSqliteDatabaseInProgress: "SQLiteデータベースをバックアップ中...",
+    backupSqliteDatabaseSuccess: "SQLiteデータベースをバックアップしました",
+    backupSqliteDatabaseFailed: "SQLiteデータベースのバックアップに失敗しました: {message}",
+    importData: "データをインポート",
+    exportData: "データをエクスポート",
+    exportStructure: "構造をエクスポート",
+    exportStructurePreviewTitle: "構造 - {name}",
+    exportStructurePreviewTitleMultiple: "構造 - {count}オブジェクト",
+    exportStructureLoading: "構造を読み込み中...",
+    copyStructure: "構造をコピー",
+    copyStructureAs: "構造をコピー（形式指定）",
+    copyStructureAsTsv: "TSV（Excel用）",
+    copyStructureAsMarkdown: "Markdownテーブル",
+    structureDocTable: "テーブル",
+    structureDocColumn: "列",
+    structureDocType: "タイプ",
+    structureDocPrimaryKey: "主キー",
+    structureDocNullable: "NULL許容",
+    structureDocDefault: "デフォルト",
+    structureDocComment: "コメント",
+    structureDocYes: "はい",
+    structureDocNo: "いいえ",
+    structureDocCopied: "構造をコピーしました",
+    structureDocCopyFallbackHint: "自動コピーがブロックされました。再度コピーをクリックするか、下の内容を選択してください。",
+    saveStructure: "SQLを保存",
+    exportStructureCopied: "構造をコピーしました",
+    createTable: "テーブルを作成",
+    createView: "ビューを作成",
+    dropTable: "テーブルを削除",
+    emptyTable: "テーブルを空にする",
+    truncateTable: "テーブルをトランケート",
+    duplicateStructure: "新しいテーブルとして複製",
+    renameObject: "名前を変更",
+    renameObjectTitle: "オブジェクト名を変更",
+    renameObjectNamePlaceholder: "新しい名前",
+    renameObjectSuccess: "「{oldName}」の名前を「{newName}」に変更しました",
+    confirmDropTableTitle: "テーブルを削除",
+    confirmDropTableMessage: "本当にテーブル「{name}」をドロップ（削除）しますか？テーブルとすべてのデータが永久に削除されます。",
+    dropTableCascade: "CASCADE を使用",
+    dropTableCascadeHint: "ビューなど、このテーブルに依存するオブジェクトも削除します。オフの場合は PostgreSQL の既定の RESTRICT を使用します。",
+    truncateTableCascade: "CASCADE を使用",
+    truncateTableCascadeHint: "外部キーでこのテーブルを参照するテーブルもトランケートします。オフの場合は PostgreSQL の既定の RESTRICT を使用します。",
+    confirmEmptyTableTitle: "テーブルを空にする",
+    confirmEmptyTableMessage: "本当に「{name}」のすべてのデータを削除しますか？",
+    confirmTruncateTableTitle: "テーブルをトランケート",
+    confirmTruncateTableMessage: "本当に「{name}」をトランケート（空に）しますか？すべての行が削除されます。",
+    dropTableSuccess: "テーブル「{name}」をドロップ（削除）しました",
+    editView: "ビューを編集",
+    viewSource: "ソースを表示",
+    viewDdl: "DDLを表示",
+    dropObject: "オブジェクトを削除",
+    dropView: "ビューを削除",
+    dropColumn: "列を削除",
+    dropIndex: "インデックスを削除",
+    dropForeignKey: "外部キーを削除",
+    dropTrigger: "トリガーを削除",
+    batchDrop: "選択を削除（{count}件）",
+    batchEmpty: "選択したテーブルを空にする（{count}件）",
+    batchTruncate: "選択をトランケート（{count}件）",
+    executeProcedure: "プロシージャを実行",
+    confirmExecuteProcedureTitle: "プロシージャを実行",
+    confirmExecuteProcedureMessage: "プロシージャ「{name}」を実行しますか？実行前に入力パラメータの値を設定・調整できます。",
+    loadingProcedureParameters: "パラメータを読み込み中...",
+    procedureParametersUnavailable: "パラメータメタデータを読み込めませんでした。以下のSQLを編集して実行することはできます。",
+    noProcedureParameters: "パラメータが見つかりませんでした。現在のSQLがそのまま実行されます。",
+    inputParameters: "{count}個の入力パラメータ",
+    outputParameters: "{count}個の出力パラメータ",
+    parameterName: "名前",
+    parameterType: "タイプ",
+    parameterMode: "モード",
+    parameterValue: "値",
+    parameterNull: "NULL",
+    parameterDefault: "DEFAULT",
+    parameterDefaultHint: "DEFAULTがチェックされている場合、DBXはその引数を省略し、データベースがプロシージャのデフォルト値を使用します。",
+    parameterValuePlaceholder: "値を入力",
+    outputOnly: "出力のみ",
+    sqlPreview: "SQLプレビュー",
+    resetSqlPreview: "SQLをリセット",
+    openInSqlEditor: "エディタで開く",
+    dropProcedure: "プロシージャを削除",
+    dropFunction: "関数を削除",
+    dropAllIndexes: "すべてのインデックスを削除",
+    batchDropIndexes: "インデックスを削除 ({count})",
+    confirmDropViewTitle: "ビューを削除",
+    confirmDropViewMessage: "本当にビュー「{name}」を削除しますか？",
+    confirmDropObjectTitle: "オブジェクトを削除",
+    confirmDropObjectMessage: "本当に「{name}」を削除しますか？",
+    confirmDropColumnTitle: "列を削除",
+    confirmDropIndexTitle: "インデックスを削除",
+    confirmDropMongoIndexMessage: "コレクション「{collection}」からインデックス「{name}」を削除しますか？",
+    confirmDropMongoAllIndexesMessage: "コレクション「{name}」から削除可能なインデックスをすべて削除しますか？",
+    confirmDropMongoAllIndexesDetails: "MongoDB は「_id_」インデックスを保持します。shard key の制約で追加のインデックスが残る場合があり、結果には実際に削除されたインデックスのみ表示されます。",
+    confirmDropForeignKeyTitle: "外部キーを削除",
+    confirmDropTriggerTitle: "トリガーを削除",
+    confirmDropTableChildObjectMessage: "本当に「{table}」から「{name}」を削除しますか？",
+    confirmDropBatchIndexesMessage: "本当に「{table}」から選択した {count} 個のインデックスを削除しますか？この操作は取り消せません。",
+    confirmBatchDropTitle: "選択したオブジェクトを削除",
+    confirmBatchDropMessage: "選択した{count}個のオブジェクトを削除しますか？この操作は取り消せません。",
+    confirmBatchEmptyTitle: "選択したテーブルを空にする",
+    confirmBatchEmptyMessage: "選択した{count}テーブルのすべてのデータを削除しますか？",
+    confirmBatchTruncateTitle: "選択したテーブルをトランケート",
+    confirmBatchTruncateMessage: "選択した{count}テーブルをトランケートしますか？すべての行が削除されます。",
+    confirmDropProcedureTitle: "プロシージャを削除",
+    confirmDropProcedureMessage: "本当にプロシージャ「{name}」を削除しますか？",
+    confirmDropFunctionTitle: "関数を削除",
+    confirmDropFunctionMessage: "本当に関数「{name}」を削除しますか？",
+    dropViewSuccess: "ビュー「{name}」を削除しました",
+    dropProcedureSuccess: "プロシージャ「{name}」を削除しました",
+    dropFunctionSuccess: "関数「{name}」を削除しました",
+    dropTableChildObjectSuccess: "「{name}」を削除しました",
+    dropAllIndexesSuccess: "「{name}」から {count} 個のインデックスを削除しました",
+    batchDropSuccess: "{count}個のオブジェクトを削除しました",
+    batchEmptySuccess: "{count}テーブルを空にしました",
+    batchEmptyPartialFail: "{success}テーブルを空にし、{failed}テーブルは失敗しました",
+    batchEmptySubmitted: "{count}テーブルの空化タスクを送信しました",
+    batchEmptySubmittedPartial: "{success}件の空化タスクを送信し、{failed}件は失敗しました",
+    batchTruncateSuccess: "{count}テーブルをトランケートしました",
+    emptyTableSuccess: "「{name}」のすべてのデータを削除しました",
+    emptyTableSubmitted: "「{name}」の空化タスクを送信しました",
+    truncateTableSuccess: "テーブル「{name}」をトランケートしました",
+    duplicateStructureSuccess: "テーブルを「{name}」として複製しました",
+    tableOperationFailed: "操作に失敗しました: {message}",
+    duplicateNameTitle: "新しいテーブルとして複製",
+    duplicateNamePlaceholder: "新しいテーブル名",
+    copyTable: "テーブルをコピー",
+    pasteTable: "テーブルを貼り付け",
+    pasteOptionStructureAndData: "構造とデータ",
+    pasteOptionStructureOnly: "構造のみ",
+    pasteOptionDataOnly: "データのみ",
+    pasteTableSuccess: "テーブルを「{name}」として貼り付けました",
+    pasteTableConfirmTitle: "テーブルの貼り付け",
+    pasteTableConfirmMessage: "クリップボードからテーブルを貼り付け",
+    batchPasteTitle: "テーブルの貼り付け",
+    batchPasteSuccess: "{count}テーブルを貼り付けました",
+    batchPastePartialFail: "{success}テーブルを貼り付け、{failed}テーブルに失敗しました",
+    noTableToPaste: "貼り付け可能なテーブルがありません",
+    pasteTableClipboardUpdated: "テーブルをクリップボードにコピーしました",
+    createDatabase: "データベースを作成",
+    createDuckDbFile: "データベースファイルを作成",
+    dropDatabase: "データベースを削除",
+    confirmDropDatabaseTitle: "データベースを削除",
+    confirmDropDatabaseMessage: "本当にデータベース「{name}」をドロップ（削除）しますか？データベースとすべてのデータが永久に削除されます。",
+    createDatabaseSuccess: "データベース「{name}」を作成しました",
+    editDatabaseProperties: "データベースプロパティを編集",
+    editDatabasePropertiesTitle: "データベースプロパティを編集: 「{name}」",
+    editDatabasePropertiesSaving: "保存中...",
+    editDatabasePropertiesSuccess: "データベース「{name}」のプロパティを更新しました",
+    editDatabaseComment: "データベースコメント",
+    editDatabaseCommentPlaceholder: "データベースコメントを入力...",
+    createDuckDbFileSuccess: "DuckDBデータベースファイル「{name}」を作成し、アタッチしました",
+    createDuckDbFileDesktopOnly: "DuckDBデータベースファイルの作成はデスクトップアプリでのみ利用可能です",
+    dropDatabaseSuccess: "データベース「{name}」を削除しました",
+    dropCollection: "コレクションを削除",
+    confirmDropCollectionTitle: "コレクションを削除",
+    confirmDropCollectionMessage: "本当にコレクション「{name}」を削除しますか？コレクションとすべてのドキュメントが永久に削除されます。",
+    dropCollectionSuccess: "コレクション「{name}」を削除しました",
+    createDatabaseNamePlaceholder: "データベース名",
+    createDatabaseCharset: "文字セット",
+    createDatabaseCharsetPlaceholder: "例: utf8mb4",
+    createDatabaseCharsetSearchPlaceholder: "文字セットを検索または入力",
+    createDatabaseCharsetEmpty: "文字セットが見つかりません",
+    createDatabaseCharsetLoading: "文字セットを読み込み中...",
+    createDatabaseCharsetCustomOption: "「{value}」を使用",
+    createDatabaseCollation: "照合順序",
+    createDatabaseCollationPlaceholder: "例: utf8mb4_unicode_ci",
+    createDatabaseCollationSearchPlaceholder: "照合順序を検索または入力",
+    createDatabaseCollationEmpty: "照合順序が見つかりません",
+    createDatabaseCollationLoading: "照合順序を読み込み中...",
+    createDatabaseCollationCustomOption: "「{value}」を使用",
+    createSchema: "スキーマを作成",
+    dropSchema: "スキーマを削除",
+    confirmDropSchemaTitle: "スキーマを削除",
+    confirmDropSchemaMessage: "本当にスキーマ「{name}」を削除しますか？スキーマとすべてのオブジェクトが永久に削除されます。",
+    createSchemaSuccess: "スキーマ「{name}」を作成しました",
+    dropSchemaSuccess: "スキーマ「{name}」を削除しました",
+    createSchemaNamePlaceholder: "スキーマ名",
+    editSchemaComment: "コメントを編集",
+    editSchemaCommentTitle: "コメントを編集: 「{name}」",
+    schemaCommentPlaceholder: "スキーマコメントを入力...",
+    schemaCommentSaving: "保存中...",
+    editSchemaCommentSuccess: "スキーマ「{name}」のコメントを更新しました",
+    configureVisibleObjects: "表示オブジェクトフィルター",
+    instanceInfo: "インスタンス情報",
+    viewDdlLoading: "DDLを読み込み中...",
+    ddlCopied: "DDLをコピーしました",
+    manageExtension: "拡張機能を管理...",
+    dropExtension: "拡張機能を削除",
+  },
+  visibleDatabases: {
+    title: "表示するデータベース",
+    description: "「{connection}」の下に表示するデータベースを選択してください。",
+    searchPlaceholder: "データベースを検索...",
+    selectedCount: "{selected}/{total}件選択中",
+    selectAll: "すべて選択",
+    selectFiltered: "検索結果を選択",
+    clear: "クリア",
+    showAll: "すべて表示",
+    showSystemDatabases: "システムデータベースを表示",
+    save: "保存",
+    emptySelection: "少なくとも1つのデータベースを選択するか、すべて表示でフィルターをクリアしてください。",
+    loadFailed: "データベースの読み込みに失敗しました: {message}",
+  },
+  visibleSchemas: {
+    title: "スキーマフィルター",
+    description: "「{connection}」の下に表示するスキーマを選択してください。",
+    searchPlaceholder: "スキーマを検索...",
+    selectedCount: "{selected}/{total}件選択中",
+    selectAll: "すべて選択",
+    selectFiltered: "検索結果を選択",
+    clear: "クリア",
+    showAll: "すべて表示",
+    save: "保存",
+    emptySelection: "少なくとも1つのスキーマを選択するか、すべて表示でフィルターをクリアしてください。",
+    loadFailed: "スキーマの読み込みに失敗しました: {message}",
+  },
+  tree: {
+    savedSql: "SQLライブラリ",
+    userAdmin: "ユーザーと権限",
+    damengJobAdmin: "エージェントジョブ",
+    defaultDatabase: "デフォルトDB",
+    columns: "列",
+    indexes: "インデックス",
+    foreignKeys: "外部キー",
+    triggers: "トリガー",
+    tables: "テーブル",
+    views: "ビュー",
+    procedures: "プロシージャ",
+    functions: "関数",
+    sequences: "シーケンス",
+    packages: "パッケージ",
+    partitions: "パーティション",
+    childTables: "子テーブル",
+    loadMore: "もっと読み込む...",
+    objectBrowser: "オブジェクトブラウザで参照（{count}件）",
+    linkedServers: "リンクサーバー",
+    materializedViews: "マテリアライズドビュー",
+    extensions: "拡張機能",
+  },
+  zookeeper: {
+    prefixPlaceholder: "パスプレフィックス（例: /app/）",
+    newKey: "新しいZnode",
+    loadingKeys: "znodeを読み込み中...",
+    empty: "znodeが見つかりません",
+    loadMore: "さらに読み込む",
+    selectKey: "znodeを選択して値を表示",
+    loadingValue: "値を読み込み中...",
+    notFound: "znodeが見つかりません",
+    edit: "編集",
+    editKey: "Znodeを編集",
+    delete: "削除",
+    deleteTitle: "ZooKeeper znodeを削除",
+    keyPlaceholder: "/path/to/znode",
+    keyRequired: "Znodeパスは必須です",
+    rootReadonly: "ルートznodeは変更できません。子znodeのパスを入力してください。",
+    saved: "Znodeを保存しました",
+    deleted: "Znodeを削除しました",
+    base64Readonly: "Base64値はこのバージョンでは読み取り専用です。",
+    createMode: "作成モード",
+    createModePersistent: "永続",
+    createModeEphemeral: "エフェメラル",
+    createModePersistentSequential: "永続順序",
+    createModeEphemeralSequential: "エフェメラル順序",
+    add: "追加",
+    value: "値",
+    metadata: "ノード情報",
+    prettyJson: "整形",
+    invalidJson: "無効なJSON",
+    summaryRevision: "rev",
+    summaryVersion: "ver",
+    summaryLease: "リース",
+    summarySize: "サイズ",
+  },
+  userAdmin: {
+    title: "ユーザーと権限",
+    unsupported: "MySQL互換およびPostgreSQL互換の接続がサポートされています。SQL Server、Oracle、その他の権限モデルは今後追加予定です。",
+    newUser: "新しいユーザー",
+    anonymous: "匿名",
+    roleName: "ロール名",
+    allowLogin: "ログインを許可",
+    searchUser: "ユーザーまたはホストを検索",
+    loadingUsers: "ユーザーを読み込み中...",
+    loadingGrants: "権限を読み込み中...",
+    emptyUsers: "ユーザーが見つからないか、現在のアカウントにユーザー一覧の読み取り権限がありません。",
+    pluginUnknown: "認証プラグインが不明です",
+    grants: "権限",
+    noGrants: "権限が見つかりません",
+    privilegeEditor: "権限エディタ",
+    privilegeHint: "権限、データベース、テーブルを選択し、適用前にSQLをプレビューしてください。* はグローバルまたは全テーブルを意味します。",
+    database: "データベース",
+    schema: "スキーマ",
+    table: "テーブル",
+    scope: "権限スコープ",
+    scopeDatabase: "データベース",
+    scopeSchema: "スキーマ",
+    scopeTable: "テーブル",
+    scopeRole: "ロールメンバーシップ",
+    memberRole: "メンバーロール",
+    privileges: "権限",
+    grantOption: "さらなる権限付与を許可 (WITH GRANT OPTION)",
+    adminOption: "メンバーシップ管理を許可 (WITH ADMIN OPTION)",
+    grant: "付与",
+    revoke: "取り消し",
+    username: "ユーザー名",
+    host: "ホスト",
+    changePassword: "パスワードを変更",
+    newPassword: "新しいパスワード",
+    lock: "ロック",
+    unlock: "ロック解除",
+    disableLogin: "ログインを無効化",
+    enableLogin: "ログインを有効化",
+    dropUser: "ユーザーを削除",
+    previewSql: "SQLをプレビュー",
+    sqlPreview: "SQLプレビュー",
+    applySql: "SQLを適用",
+    applySuccess: "ユーザー権限を更新しました",
+    applyFailed: "実行に失敗しました: {message}",
+  },
+  damengJobAdmin: {
+    title: "Dameng エージェントジョブ",
+    unsupported: "このページは Dameng 接続のみ対応しています。",
+    initEnvironment: "ジョブ環境を初期化",
+    environmentReady: "ジョブ環境は初期化済みです",
+    newJob: "新しいジョブ",
+    searchJob: "ジョブを検索",
+    loadFailed: "読み込みに失敗しました",
+    environmentMissingTitle: "ジョブ環境が初期化されていません",
+    environmentMissingHint: "このデータベースにはまだ SYSJOB ジョブ環境がありません。",
+    environmentMissingDescription: "Dameng エージェントジョブは SYSJOB スキーマ配下のシステムテーブルとビューに依存します。先にジョブ環境を初期化してください。通常は管理者権限が必要です。",
+    emptyJobs: "ジョブが見つからないか、現在のアカウントにジョブ一覧の読み取り権限がありません。",
+    emptyDetails: "詳細行はありません",
+    selectJob: "ジョブを選択してください",
+    enabled: "有効",
+    disabled: "無効",
+    running: "実行中",
+    enable: "有効化",
+    disable: "無効化",
+    runAsync: "今すぐ実行",
+    stopRunning: "現在の実行を停止",
+    stopRunningDisabled: "現在実行中のジョブのみ停止できます",
+    clearHistories: "履歴をクリア",
+    dropJob: "削除",
+    steps: "ステップ",
+    schedules: "スケジュール",
+    histories: "履歴",
+    noDescription: "説明なし",
+    jobName: "ジョブ名",
+    description: "説明",
+    stepName: "ステップ名",
+    scheduleName: "スケジュール名",
+    sqlCommand: "SQLスクリプト",
+    scheduleMode: "スケジュール種別",
+    daily: "毎日",
+    once: "1回",
+    startDate: "開始日",
+    startTime: "開始時刻",
+    endTime: "終了時刻",
+    minuteInterval: "分間隔",
+    previewSql: "SQLをプレビュー",
+    sqlPreview: "SQLプレビュー",
+    applySql: "SQLを適用",
+    applySuccess: "ジョブ操作を適用しました",
+    applyFailed: "実行に失敗しました: {message}",
+  },
+  objects: {
+    all: "すべて",
+    tables: "テーブル",
+    views: "ビュー",
+    procedures: "プロシージャ",
+    functions: "関数",
+    sequences: "シーケンス",
+    packages: "パッケージ",
+    table: "テーブル",
+    partitions: "{count}パーティション",
+    view: "ビュー",
+    procedure: "プロシージャ",
+    function: "関数",
+    sequence: "シーケンス",
+    package: "パッケージ",
+    packageBody: "パッケージボディ",
+    name: "名前",
+    type: "タイプ",
+    rows: "行数",
+    size: "サイズ",
+    statisticsHint: "データベース統計からの推定値です。COUNT(*) は実行しません。",
+    createdAt: "作成日時",
+    updatedAt: "更新日時",
+    source: "ソース",
+    saveSource: "保存",
+    cancelEdit: "キャンセル",
+    sourceSaved: "ソースを保存しました",
+    sourceSaveFailed: "ソースの保存に失敗しました: {message}",
+    schemaColumn: "スキーマ",
+    comment: "コメント",
+    loadingSchemas: "スキーマを読み込み中...",
+    schema: "スキーマ",
+    search: "テーブル、ビュー、関数、シーケンス、プロシージャを検索...",
+    loading: "オブジェクトを読み込み中...",
+    empty: "オブジェクトが見つかりません",
+    selectedTables: "{count}テーブル選択中",
+    exportSelected: "選択をエクスポート",
+    dropSelected: "選択を削除",
+    truncateSelected: "選択をトランケート",
+    clearSelection: "選択をクリア",
+    confirmBatchDropTitle: "選択したテーブルを削除",
+    confirmBatchDropMessage: "選択した{count}テーブルを削除しますか？この操作は取り消せません。",
+    confirmBatchTruncateTitle: "選択したテーブルをトランケート",
+    confirmBatchTruncateMessage: "選択した{count}テーブルをトランケートしますか？すべての行が削除されます。",
+    batchDropSuccess: "{count}テーブルを削除しました",
+    batchTruncateSuccess: "{count}テーブルをトランケートしました",
+    copyTableSelected: "コピー",
+    pasteTableSelected: "貼り付け",
+    toggleCheckbox: "複数選択の切り替え",
+    viewList: "リスト表示",
+    viewGrid: "グリッド表示",
+    sourceReadOnly: "このソースは読み取り専用で、編集できません。",
+    sortAsc: "昇順",
+    sortDesc: "降順",
+    sortBy: "並べ替え",
+  },
+  structureEditor: {
+    mysqlDataTypeHelp: {
+      tinyint: "1 バイト整数。符号付きは -128～127、符号なしは 0～255 です。",
+      smallint: "2 バイト整数。符号付きは -32,768～32,767、符号なしは 0～65,535 です。",
+      mediumint: "3 バイト整数。符号付きは -8,388,608～8,388,607、符号なしは 0～16,777,215 です。",
+      int: "4 バイト整数。符号付きは -2,147,483,648～2,147,483,647、符号なしは 0～4,294,967,295 です。",
+      bigint: "8 バイト整数。符号付きは -2^63～2^63-1、符号なしは 0～2^64-1 です。",
+      decimal: "精度と小数部桁数を指定できる正確な 10 進数です。MySQL では最大 65 桁、小数部は最大 30 桁で、金額に適します。",
+      float: "単精度の近似数値です。正確な小数値には DECIMAL を使用してください。",
+      double: "倍精度の近似数値です。正確な小数値には DECIMAL を使用してください。",
+      real: "既定では DOUBLE の別名です。REAL_AS_FLOAT を有効にすると FLOAT の別名になります。",
+      bit: "1～64 ビットのビット列です。既定の幅は 1 です。",
+      boolean: "TINYINT(1) の別名です。0 は偽、0 以外は真として扱われます。",
+      serial: "BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE の簡略別名です。",
+      date: "1000-01-01～9999-12-31 の暦日です。",
+      datetime: "タイムゾーン変換を行わない日時です。小数秒精度は 0～6、既定値は 0 です。",
+      timestamp: "セッションのタイムゾーンと UTC の間で変換される日時です。小数秒精度は 0～6 です。",
+      time: "-838:59:59～838:59:59 の時刻または時間間隔です。小数秒精度は 0～6 です。",
+      year: "1901～2155 と 0000 を格納する 4 桁の年です。",
+      char: "最大 255 文字の固定長文字列です。末尾は空白で埋められます。",
+      varchar: "可変長文字列です。実際の最大長は行サイズと文字セットに依存します。",
+      tinytext: "最大 255 バイトの可変長テキストです。行サイズ、文字セット、max_allowed_packet により制限される場合があります。",
+      text: "最大 65,535 バイトの可変長テキストです。行サイズ、文字セット、max_allowed_packet により制限される場合があります。",
+      mediumtext: "最大 16,777,215 バイトの可変長テキストです。行サイズ、文字セット、max_allowed_packet により制限される場合があります。",
+      longtext: "最大 4,294,967,295 バイトの可変長テキストです。行サイズ、文字セット、max_allowed_packet により制限される場合があります。",
+      binary: "最大 255 バイトの固定長バイナリ文字列です。末尾は 0x00 で埋められます。",
+      varbinary: "可変長バイナリ文字列です。実際の最大長は行サイズに依存します。",
+      tinyblob: "最大 255 バイトのバイナリオブジェクトです。max_allowed_packet により制限される場合があります。",
+      blob: "最大 65,535 バイトのバイナリオブジェクトです。max_allowed_packet により制限される場合があります。",
+      mediumblob: "最大 16,777,215 バイトのバイナリオブジェクトです。max_allowed_packet により制限される場合があります。",
+      longblob: "最大 4,294,967,295 バイトのバイナリオブジェクトです。max_allowed_packet により制限される場合があります。",
+      enum: "最大 65,535 個のリテラルから 1 つを選ぶ値です。定義順を変えると保存済み値の意味が変わることがあります。",
+      set: "宣言した最大 64 個のメンバーから、0 個以上を選ぶ値です。",
+      json: "検証済み JSON ドキュメントです。内部表現と関数は製品・バージョンに依存し、max_allowed_packet の制限を受けます。",
+      jsonMysql: "MySQL のネイティブなバイナリ JSON です。検証と JSON 関数を備え、max_allowed_packet の制限を受けます。",
+      jsonMariaDb: "MariaDB では JSON は JSON_VALID と utf8mb4_bin 照合順序を持つ LONGTEXT の別名です。",
+      nationalCharacter: "国別文字列型の別名です。MySQL では非推奨の utf8mb3 を使用するため、utf8mb4 を推奨します。",
+      geometry: "空間ジオメトリです。InnoDB の SPATIAL インデックスには NOT NULL と SRID 属性が必要です。",
+      point: "空間上の点です。InnoDB の SPATIAL インデックスには NOT NULL と SRID が必要です。",
+      linestring: "空間上の曲線です。InnoDB の SPATIAL インデックスには NOT NULL と SRID が必要です。",
+      polygon: "空間上の面です。InnoDB の SPATIAL インデックスには NOT NULL と SRID が必要です。",
+      multipoint: "点のコレクションです。InnoDB の SPATIAL インデックスには NOT NULL と SRID が必要です。",
+      multilinestring: "曲線のコレクションです。InnoDB の SPATIAL インデックスには NOT NULL と SRID が必要です。",
+      multipolygon: "ポリゴンのコレクションです。InnoDB の SPATIAL インデックスには NOT NULL と SRID が必要です。",
+      geometrycollection: "異なる種類のジオメトリのコレクションです。InnoDB の SPATIAL インデックスには NOT NULL と SRID が必要です。",
+      inet4: "MariaDB 10.10 以降で利用できる IPv4 型です。アドレスを 4 バイトで保存します。",
+      inet6: "IPv6 および IPv4 マップドアドレス向けの MariaDB 互換型です。",
+      uuid: "対応サーバーが提供する 128 ビットの UUID です。",
+      vector: "類似検索や機械学習向けのベクトル型です。利用可否と次元数はバージョンに依存します。",
+      xmltype: "対応サーバーが提供する XML 型です。",
+      integerDisplayWidth: "INT(11) のような整数の表示幅は MySQL で非推奨であり、値の範囲を制限しません。",
+      zerofill: "ZEROFILL は MySQL 8 で非推奨で、UNSIGNED を暗黙に指定します。表示はアプリケーション側で整形してください。",
+      unsignedNumeric: "DECIMAL、FLOAT、DOUBLE の UNSIGNED は MySQL 8 で非推奨です。非負値の制約には CHECK を使用してください。",
+      floatPrecision: "FLOAT(p) では p が 25～53 の場合に DOUBLE が選ばれます。DOUBLE を明示的に使用してください。",
+      floatingPointDisplay: "FLOAT(M,D) と DOUBLE(M,D) は非推奨です。引数なしの FLOAT/DOUBLE または DECIMAL(M,D) を使用してください。",
+    },
+    postgresDataTypeHelp: {
+      smallint: "2 バイトの符号付き整数で、範囲は -32,768～32,767 です。",
+      integer: "4 バイトの符号付き整数で、範囲は -2,147,483,648～2,147,483,647 です。",
+      bigint: "8 バイトの符号付き整数で、範囲は -2^63～2^63-1 です。",
+      serial: "整数型、シーケンス、NOT NULL、nextval の既定値を作る簡略構文です。単独では一意でなく欠番も発生するため、IDENTITY を推奨します。",
+      numeric: "精度と小数部桁数を持つ正確な 10 進数です。金額やバイナリ丸めを避ける値に適します。",
+      real: "4 バイトの単精度浮動小数点数です。FLOAT(p) の p が 1～24 の場合に選ばれます。",
+      double: "8 バイトの倍精度浮動小数点数です。精度指定なしの FLOAT は別名で、FLOAT(p) の p が 25～53 の場合に選ばれます。",
+      money: "lc_monetary に依存する通貨額です。移植性のある金額データには NUMERIC の方が安全です。",
+      boolean: "真、偽、NULL を取る論理値です。BOOL は BOOLEAN の別名です。",
+      char: "空白で埋める固定長文字列です。CHARACTER は別名です。",
+      varchar: "任意の長さ上限を持てる可変長文字列です。CHARACTER VARYING は別名です。",
+      text: "宣言上の長さ上限がない可変長文字列です。長さ指定なしの VARCHAR と同じ形式で保存されます。",
+      bytea: "可変長バイナリ文字列です。TOAST により大きな値を行外に保存できます。",
+      date: "時刻やタイムゾーンを含まない暦日です。",
+      time: "タイムゾーンを含まない時刻で、小数秒精度は任意です。",
+      timetz: "UTC オフセットを持つ時刻です。用途は限定的で、ある時点を表すには timestamptz を推奨します。",
+      timestamp: "ローカルな日時に用いる、タイムゾーン変換を行わない日時です。",
+      timestamptz: "UTC で保存しセッションのタイムゾーンで表示する時点です。元のタイムゾーン名は保持しません。",
+      interval: "月、日、マイクロ秒で表す期間です。暦上の単位には固定の長さがありません。",
+      uuid: "128 ビットの UUID です。",
+      json: "元の表現を保持する JSON テキストです。解析時に検証されますが、通常は JSONB より低速です。",
+      jsonb: "処理とインデックス用に分解されたバイナリ JSON です。空白、キーの順序、重複キーは保持しません。",
+      xml: "オプションに応じて文書またはコンテンツを検証する XML 値です。",
+      bit: "固定長または可変長のビット列です。BIT VARYING と VARBIT は可変長の別名です。",
+      tsvector: "全文検索用に正規化された語彙素です。通常は GIN または GiST でインデックスします。",
+      tsquery: "tsvector に対して評価する全文検索の論理クエリです。",
+      cidr: "ホスト部ビットを 0 に固定した IPv4 または IPv6 ネットワークです。",
+      inet: "任意のマスクを持てる IPv4 または IPv6 ホストです。CIDR と異なり、ホスト部ビットは 0 以外にできます。",
+      macaddr: "MAC アドレスです。MACADDR は 6 バイト、MACADDR8 は 8 バイトを使用します。",
+      geometry: "SRID を持たない 2 次元平面ジオメトリです。地理座標や高度な空間演算には PostGIS を使用してください。",
+      range: "包含・非包含の境界を持つ連続範囲です。分離した範囲には multirange を使用してください。",
+      oid: "システムの符号なしオブジェクト識別子です。安定したアプリケーションの主キーではありません。",
+      array: "任意の要素型の PostgreSQL 配列で、多次元にもできます。宣言した次元数は強制されません。",
+      multirange: "重複しない範囲の集合です。PostgreSQL は隣接または重複する要素を正規化します。",
+      jsonpath: "JSONB のクエリや述語に使う SQL/JSON パス式です。",
+      pgLsn: "レプリケーションと復旧に使う WAL の位置です。アプリケーション用の連番ではありません。",
+      pgSnapshot: "一般的なアプリケーションデータではなく、データベース操作で使うトランザクション可視性のスナップショットです。",
+    },
+    sqliteDataTypeHelp: {
+      integer: "INTEGER アフィニティです。通常の列はこのストレージクラスを強制しません。正確に INTEGER PRIMARY KEY と宣言すると rowid の別名になります。",
+      real: "IEEE 754 を用いる REAL アフィニティです。正確な金額には適しません。",
+      text: "TEXT アフィニティです。VARCHAR(n) と CHAR(n) は n を強制しないため、長さが重要なら CHECK を使用してください。",
+      blob: "BLOB アフィニティです。バイト列を変換せずに保存します。",
+      numeric: "NUMERIC アフィニティは数値テキストをまず INTEGER、次に REAL に変換します。DATE、DATETIME、TIME もこのアフィニティを持ちます。",
+    },
+    title: "テーブル構造を編集",
+    createTitle: "テーブルを作成",
+    editTabTitle: "編集: {tableName}",
+    tableName: "テーブル名",
+    refresh: "構造を更新",
+    density: "密度",
+    densityCompact: "コンパクト",
+    densityStandard: "標準",
+    densityComfortable: "快適",
+    columns: "列",
+    indexes: "インデックス",
+    foreignKeys: "外部キー",
+    triggers: "トリガー",
+    ddl: "DDL",
+    addColumn: "列を追加",
+    columnTemplates: "プリセット列を挿入",
+    configureColumnTemplates: "プリセット列を設定",
+    presetFieldsTemplate: "プリセット列セット",
+    searchColumns: "列/コメントを検索",
+    nextColumnMatch: "次の一致する列へ移動",
+    searchIndexes: "インデックスを検索",
+    nextIndexMatch: "次の一致するインデックスへ移動",
+    addIndex: "インデックスを追加",
+    addForeignKey: "外部キーを追加",
+    addTrigger: "トリガーを追加",
+    columnName: "列",
+    dataType: "データ型",
+    typePlaceholder: "選択または入力...",
+    noMatchingType: "一致する型がありません",
+    length: "長さ",
+    nullable: "NULL許容",
+    primaryKey: "主キー",
+    defaultValue: "デフォルト",
+    defaultValuePresets: "デフォルト値プリセット",
+    comment: "コメント",
+    characterSet: "文字セット",
+    charsetPlaceholder: "文字セット",
+    collation: "照合順序",
+    collationPlaceholder: "照合順序",
+    editComment: "コメントを編集",
+    commentPlaceholder: "列コメントを入力...",
+    tableCommentPlaceholder: "テーブルコメントを入力...",
+    tableCommentUnsupported: "このデータベースではテーブルコメントはサポートされていません",
+    actions: "操作",
+    indexName: "インデックス",
+    indexColumns: "列",
+    indexColumnsPlaceholder: "列を選択...",
+    unique: "一意",
+    indexType: "タイプ",
+    includedColumns: "付加列",
+    includedColumnsPlaceholder: "列を選択...",
+    filter: "フィルター",
+    foreignKeyName: "外部キー",
+    referencedSchema: "参照スキーマ",
+    referencedTable: "参照テーブル",
+    referencedColumn: "参照列",
+    onDelete: "削除時",
+    onUpdate: "更新時",
+    defaultAction: "デフォルト",
+    triggerName: "トリガー",
+    triggerStatement: "トリガー文",
+    primary: "主キー",
+    drop: "削除",
+    restore: "復元",
+    remove: "削除",
+    moveColumnUp: "列を上に移動",
+    moveColumnDown: "列を下に移動",
+    dragColumn: "ドラッグして列の順序を変更",
+    localColumnOrderNotice: "列の順序はローカルにのみ保存され、データベースのテーブル構造は変更されません。",
+    yes: "はい",
+    no: "いいえ",
+    emptyReadonly: "レコードなし",
+    sqlPreview: "SQLプレビュー",
+    collapseSqlPreview: "SQLプレビューを折りたたむ",
+    expandSqlPreview: "SQLプレビューを展開",
+    noChanges: "変更なし",
+    apply: "変更を適用",
+    ready: "準備完了",
+    saved: "テーブル構造を更新しました",
+    copySql: "SQLをコピー",
+    sqliteRebuildNotice: "SQLite は制約が動作しないデータスナップショットをバックアップとして保持し、1 つのトランザクション内でテーブルを再構築して、変更された列を CAST で強制変換します。表現できない値は 0/0.0 になる場合があり、失敗時はすべてロールバックされます。",
+    extendedProperties: "拡張",
+    autoIncrement: "自動採番",
+    onUpdateCurrentTimestamp: "自動更新時刻",
+    identity: "ID列",
+    identityGeneration: "生成",
+    identitySeed: "開始値",
+    identityIncrement: "増分",
+    sqlServerIdentityTypeHint: "SQL Server の ID 列は tinyint、smallint、int、bigint、scale 0 の decimal/numeric のみ対応します",
+  },
+  diagram: {
+    title: "リレーション図",
+    open: "図を表示",
+    selectConnection: "接続を選択",
+    selectDatabase: "データベースを選択",
+    selectSchema: "スキーマを選択",
+    searchTables: "テーブル、列、キーを検索...",
+    refresh: "図を更新",
+    loading: "リレーションを読み取り中...",
+    loadingProgress: "リレーションを読み取り中... {loaded}/{total}",
+    partialError: "読み込みに失敗した{count}テーブルのメタデータをスキップしました",
+    selectTarget: "接続とデータベースを選択してください",
+    empty: "表示するテーブルがありません",
+    noMatches: "一致するテーブルがありません",
+    tablesCount: "{count}テーブル",
+    relationshipsCount: "{count}リレーション",
+    tableMode: "テーブルビュー",
+    engineeringMode: "エンジニアリングER",
+    modelRelationships: "モデル関係",
+    copyJoinSql: "SQLをコピー",
+    customRelationshipsCount: "{count}件モデル化",
+    relationshipName: "名前",
+    relationshipNamePlaceholder: "任意",
+    sourceTable: "ソーステーブル",
+    sourceColumn: "ソース列",
+    targetTable: "ターゲットテーブル",
+    targetColumn: "ターゲット列",
+    cardinality: "カーディナリティ",
+    cardinalityOneToMany: "1:N",
+    cardinalityManyToOne: "N:1",
+    cardinalityOneToOne: "1:1",
+    addRelationship: "関係を追加",
+    removeRelationship: "関係を削除",
+    relationshipIncomplete: "ソース列とターゲット列を選択してください",
+    relationshipSelfInvalid: "同じ列への関係は作成できません",
+    relationshipExists: "この関係はすでに存在します",
+    relationshipAdded: "関係を追加しました",
+    noJoinSql: "コピーできる関係SQLがありません",
+    allTables: "全テーブル",
+    relatedTables: "関連テーブル",
+    moreColumns: "+ {count}列",
+    exportSvg: "SVGエクスポート",
+    exportedSvg: "SVGをエクスポートしました",
+    exportSvgFailed: "SVGのエクスポートに失敗しました: {message}",
+    zoomIn: "拡大",
+    zoomOut: "縮小",
+    resetLayout: "レイアウトをリセット",
+  },
+  etcd: {
+    prefixPlaceholder: "プレフィックス、例: /app/",
+    newKey: "新しいキー",
+    loadingKeys: "キーを読み込み中...",
+    empty: "キーが見つかりません",
+    loadMore: "もっと読み込む",
+    selectKey: "キーを選択して値を表示",
+    loadingValue: "値を読み込み中...",
+    notFound: "キーが見つかりません",
+    edit: "編集",
+    editKey: "キーを編集",
+    delete: "削除",
+    deleteTitle: "etcdキーを削除",
+    keyPlaceholder: "/path/to/key",
+    keyRequired: "キーは必須です",
+    saved: "キーを保存しました",
+    deleted: "キーを削除しました",
+    base64Readonly: "Base64値はこのバージョンでは読み取り専用です。",
+  },
+  redis: {
+    createKeyTypeHelp: {
+      string: "最大 512 MB の単一値。キャッシュやカウンター向けです。",
+      hash: "フラットなフィールド値マップ。大きな Hash 全読込は O(N) です。",
+      list: "順序付き列。途中へのランダムアクセスは線形です。",
+      set: "順不同の一意メンバー集合。大集合の列挙は線形です。",
+      zset: "浮動小数スコア付き一意メンバー。書込みは O(log N) です。",
+      stream: "追記専用ログ。XACK、pending、トリミングを管理します。",
+      json: "パス指定 JSON。RedisJSON/Redis Stack が必要で、String/Hash より負荷が高めです。",
+    },
+    selectKey: "キーを選択して値を表示",
+    noKeys: "キーが見つかりません",
+    pattern: "パターン（例: user:*）",
+    fuzzyPattern: "キーを含む...",
+    fuzzyMatch: "あいまい",
+    fuzzyMatchTitle: "あいまい検索: プレーンテキストの部分一致でキーを検索",
+    valueSearchPlaceholder: "値を含む...",
+    allSearchPlaceholder: "キーまたは値を含む...",
+    searchByKey: "キー",
+    searchByValue: "値",
+    searchByAll: "すべて",
+    searchFields: "フィールドまたは値を検索",
+    keys: "{count}キー",
+    loadedKeys: "{loaded}/{total}キー読み込み完了",
+    loadingKeys: "キーを読み込み中...",
+    searchingValues: "値を検索中...",
+    searchingAll: "キーと値を検索中...",
+    noKeysInScanHint: "現在のスキャン範囲で一致するキーは見つかりません",
+    loadMoreKeys: "さらにキーを読み込む",
+    fetchAllKeys: "すべて取得",
+    stopFetchAll: "停止",
+    fetchAllProgress: "{loaded}/{total}キー読み込み完了",
+    fetchAllProgressUnknown: "{loaded}キー読み込み完了",
+    items: "{count}アイテム",
+    fields: "{count}フィールド",
+    members: "{count}メンバー",
+    loadedItems: "{loaded}/{total}アイテム読み込み完了",
+    loadedFields: "{loaded}/{total}フィールド読み込み完了",
+    loadedMembers: "{loaded}/{total}メンバー読み込み完了",
+    entries: "{count}エントリ",
+    noExpiry: "期限なし",
+    autoRefresh: "自動更新（カウントダウン）",
+    ttlDay: "{count}日",
+    columnType: "型",
+    columnKey: "キー",
+    columnValue: "値",
+    columnSize: "サイズ",
+    columnTTL: "TTL",
+    binaryStringReadonlyHint: "バイナリ文字列値は読み取り専用モードでエスケープテキストとして表示されます。生バイトの編集はサポートされていません。",
+    selectedKeys: "選択中のキー",
+    deleteGroup: "グループを削除",
+    deleteGroupDetails: "{target}\n{count}個のキー",
+    flushDb: "現在のDBをクリア",
+    flushDbMessage: "現在のRedisデータベース内のすべてのキーが削除されます。この操作は取り消せません。続行しますか？",
+    flushDbDetails: "対象: Redis db{db}\n範囲: 現在のDB内のすべてのキー",
+    flushDbConfirm: "DBをクリア",
+    flushDbSuccess: "Redis db{db}をクリアしました",
+    keyDetail: "キー詳細",
+    commandLine: "コマンドライン",
+    selectKeyForDetail: "キーを選択して詳細を表示",
+    commandWelcome: "Redisコマンドコンソールへようこそ",
+    commandPlaceholder: "Redisコマンド（例: GET user:1）",
+    commandPrefix: "CMD",
+    commandHint: "Redisコマンドを入力（例: SMEMBERS feature:flags）",
+    executeCommand: "コマンドを実行",
+    commandEmpty: "Redisコマンドを入力してください",
+    commandEmptyResult: "Redisコマンドを実行すると結果が表示されます",
+    commandBlocked: "このRedisコマンドは安全のためブロックされています",
+    createKey: "キーを作成",
+    createKeyName: "キー",
+    createKeyNamePlaceholder: "user:1",
+    createKeyType: "タイプ",
+    createValue: "値",
+    createMember: "メンバー",
+    createField: "フィールド",
+    createFieldPlaceholder: "name",
+    createScore: "スコア",
+    createKeyTtl: "TTL（秒）",
+    createKeyTtlPlaceholder: "空 = 期限なし",
+    createKeyAddEntry: "エントリを追加",
+    createKeyEntryId: "エントリID",
+    createKeyRawMode: "直接入力",
+    createKeyEntries: "エントリ",
+    createValuePlaceholder: "value",
+    createKeySubmit: "作成",
+    createKeyNameRequired: "キー名を入力してください",
+    createFieldRequired: "ハッシュフィールドを入力してください",
+    createScoreInvalid: "有効なスコアを入力してください",
+    jsonModuleNotAvailable: "このRedisサーバーにReJSONモジュールがロードされていません",
+    fieldRequired: "フィールド名を入力してください",
+    valueRequired: "値を入力してください",
+    memberRequired: "メンバーを入力してください",
+    ttlInvalid: "有効なTTLを秒で入力してください（-1で期限なし）",
+    member: "メンバー",
+    memberDetail: "メンバー詳細",
+    viewMember: "完全な値を表示",
+    copyMember: "メンバーをコピー",
+    copyKeyName: "キー名をコピー",
+    copied: "コピーしました",
+    copyInsertStatement: "INSERT文をコピー",
+    copyInsertStatementBinary: "バイナリデータのINSERT文は生成できません",
+    editMember: "編集",
+    jsonView: "JSONビュー",
+    rawContent: "生コンテンツ",
+    wordWrap: "折り返し",
+    formatJson: "フォーマット",
+    compressJson: "圧縮",
+    jsonFormatError: "不正なJSON形式です",
+    clearHistory: "コマンド履歴をクリア",
+    historyCleared: "Redisコマンド履歴をクリアしました",
+    blockedCommand: "コマンド {command} は安全のためブロックされています。許可するにはツールバーのシールドアイコンを無効にしてください。",
+    pubsub: "Pub/Sub",
+    pubsubConnected: "接続済み",
+    pubsubConnecting: "接続中...",
+    pubsubDisconnected: "切断しました",
+    pubsubConnect: "接続",
+    pubsubDisconnect: "切断",
+    pubsubChannels: "チャンネル",
+    pubsubChannelPlaceholder: "チャンネル名",
+    pubsubSubscribe: "購読",
+    pubsubPatterns: "パターン",
+    pubsubPatternPlaceholder: "パターン（例: news:*）",
+    pubsubPsubscribe: "パターン購読",
+    pubsubMessages: "メッセージ",
+    pubsubClear: "クリア",
+    pubsubEmpty: "まだメッセージはありません。チャンネルを購読してメッセージを受信してください。",
+    pubsubPublish: "発行",
+    pubsubPublishChannel: "チャンネル",
+    pubsubPublishMessage: "メッセージ",
+    pubsubSend: "送信",
+    pubsubPublishFailed: "発行に失敗しました: {error}",
+    pubsubWsConnectFailed: "WebSocket接続に失敗しました: {error}",
+    slowlog: "スローログ",
+    slowlogCount: "件数",
+    slowlogQuery: "クエリ",
+    slowlogNode: "ノード",
+    slowlogSelectNode: "ノードを選択",
+    slowlogNodeRequired: "先にノードを選択してください",
+    slowlogEmpty: "クエリをクリックしてスローログエントリを取得",
+    slowlogFetchFailed: "スローログの取得に失敗しました: {error}",
+    slowlogColumnId: "ID",
+    slowlogColumnTimestamp: "タイムスタンプ",
+    slowlogColumnDuration: "実行時間 (μs)",
+    slowlogColumnCommand: "コマンド",
+    slowlogColumnClientAddr: "クライアント",
+    slowlogColumnClientName: "クライアント名",
+    slowlogTotal: "{count} エントリ",
+    slowlogDetailTitle: "スローログエントリ #{id}",
+  },
+  mongo: {
+    documents: "{count}ドキュメント",
+    addField: "フィールドを追加",
+    deleteField: "フィールドを削除",
+    field: "フィールド",
+    value: "値",
+    fieldPlaceholder: "フィールド名",
+    emptyCollection: "空のコレクション",
+    selectDocument: "ドキュメントを選択",
+    readonlyId: "_idは読み取り専用です",
+    invalidJsonValue: "このセルは有効なJSON値ではありません",
+    duplicateField: "重複するフィールド名: {field}",
+    edit: "編集",
+    documentView: "ドキュメントビュー",
+    tableView: "テーブルビュー",
+    filterPlaceholder: "フィルター...",
+    sortPlaceholder: "並び替え...",
+  },
+  vector: {
+    collectionFallback: "コレクション",
+    productCollection: "{product} コレクション",
+    browse: "参照",
+    search: "検索",
+    upsert: "Upsert",
+    delete: "削除",
+    reset: "リセット",
+    refresh: "更新",
+    run: "実行",
+    apply: "適用",
+    requestEditor: "ベクターリクエストエディタ",
+    operationSuccess: "操作が完了しました。コレクションプレビューが更新されました。",
+    vectorLabel: "ベクトル",
+  },
+  history: {
+    title: "履歴",
+    search: "履歴を検索...",
+    empty: "まだ履歴がありません",
+    emptyFilteredRecent: "最近 200 件の実行履歴に一致する記録はありません",
+    failed: "失敗",
+    success: "成功",
+    restore: "エディタに復元",
+    copy: "SQLをコピー",
+    delete: "削除",
+    clear: "履歴をクリア",
+    viewDetails: "詳細を表示",
+    analyzeWithAi: "AIで分析",
+    aiAnalyzeNoConnection: "接続が存在しないため、この履歴エントリを分析できません。",
+    aiAnalysisTab: "履歴分析",
+    rollback: "ロールバック",
+    rollbackSql: "ロールバックSQL",
+    rollbackAvailable: "利用可能",
+    rollbackUnavailable: "ロールバックSQLなし",
+    rollbackConfirm: "この履歴エントリ用に生成されたロールバックSQLを実行しますか？",
+    rollbackSuccess: "ロールバックを実行しました",
+    rollbackFailed: "ロールバックに失敗しました: {message}",
+    confirmDelete: "この履歴エントリを削除しますか？",
+    confirmClear: "すべての履歴をクリアしますか？",
+    filters: {
+      all: "すべて",
+      query: "クエリ",
+      data_change: "データ変更",
+      schema_change: "スキーマ変更",
+      failed: "失敗",
+    },
+    dateRange: {
+      title: "時間範囲",
+      label: "実行時間:",
+      start: "開始日",
+      end: "終了日",
+      apply: "適用",
+      clear: "クリア",
+      invalid: "開始日は終了日より後にできません",
+      unboundedStart: "開始",
+      unboundedEnd: "終了",
+    },
+    kinds: {
+      query: "クエリ",
+      data_change: "データ変更",
+      schema_change: "スキーマ変更",
+      import: "インポート",
+      transfer: "転送",
+      redis_command: "Redisコマンド",
+    },
+    kindShort: {
+      query: "SQL",
+      data_change: "データ",
+      schema_change: "DDL",
+      import: "インポート",
+      transfer: "移動",
+      redis_command: "Redis",
+    },
+    detail: {
+      kind: "タイプ",
+      operation: "操作",
+      connection: "接続",
+      database: "データベース",
+      target: "対象",
+      time: "時間",
+      duration: "所要時間",
+      affectedRows: "影響行数",
+      rollback: "ロールバック",
+      status: "ステータス",
+      error: "エラー",
+    },
+  },
+  dangerDialog: {
+    title: "危険な操作",
+    message: "このSQL文はデータを不可逆的に変更または削除する可能性があります。実行してもよろしいですか？",
+    redisCommandMessage: "このRedisコマンドはデータを変更し、自動的に元に戻せない可能性があります。続行しますか？",
+    suppressFuturePrompts: "危険なSQLの確認を今後表示しない",
+    wrapLines: "折り返し表示を切り替え",
+    deleteMessage: "この削除操作は元に戻せない可能性があります。続行しますか？",
+    deleteConfirm: "削除を確認",
+    deleteRowMessage: "この行は削除対象としてマークされ、保存後にデータベースから削除されます。続行しますか？",
+    deleteRowsMessage: "これら{count}行は削除対象としてマークされ、保存後にデータベースから削除されます。続行しますか？",
+    deleteRowDetails: "テーブル: {table}",
+    deleteRowDetailsNoTable: "現在の結果行",
+    redisKeyDetails: "Redisキー: {key}",
+    redisHashFieldDetails: "Redisハッシュ: {key}\nフィールド: {field}",
+    redisListItemDetails: "Redisリスト: {key}\nインデックス: {index}",
+    redisSetMemberDetails: "Redisセット: {key}\nメンバー: {member}",
+    mongoDocumentDetails: "MongoDBコレクション: {collection}\nドキュメント _id: {id}",
+    mongoFieldDetails: "フィールド: {field}",
+    mongoArrayItemDetails: "配列アイテムインデックス: {index}",
+    cancel: "キャンセル",
+    confirm: "実行",
+  },
+  sqlParameters: {
+    title: "SQLパラメーター",
+    description: "SQLテンプレートのプレースホルダーに値を入力します。DBXは実行前にSQLリテラルへ置換します。",
+    name: "パラメーター",
+    syntax: "Syntax",
+    type: "型",
+    value: "値",
+    valuePlaceholder: "値を入力",
+    preview: "SQLプレビュー",
+    execute: "実行",
+    kind: {
+      string: "文字列",
+      number: "数値",
+      boolean: "真偽値",
+      null: "NULL",
+      raw: "Raw SQL",
+    },
+  },
+  transfer: {
+    title: "データ転送",
+    source: "ソース",
+    target: "対象",
+    sourceConnection: "ソース接続",
+    sourceDatabase: "ソースデータベース",
+    sourceSchema: "ソーススキーマ",
+    targetConnection: "ターゲット接続",
+    targetDatabase: "ターゲットデータベース",
+    targetSchema: "ターゲットスキーマ",
+    tables: "テーブル",
+    selectAll: "すべて選択",
+    deselectAll: "すべて解除",
+    createTable: "テーブルがなければ作成",
+    transferMode: "転送モード",
+    modeAppend: "追加 (INSERT)",
+    modeOverwrite: "上書き (TRUNCATE + INSERT)",
+    modeUpsert: "アップサート (主キーでINSERT or UPDATE)",
+    targetTableNameCase: "対象テーブル名の大小文字",
+    tableNameCasePreserve: "そのまま",
+    tableNameCaseLower: "小文字に変換",
+    tableNameCaseUpper: "大文字に変換",
+    batchSize: "バッチサイズ",
+    start: "転送開始",
+    cancel: "キャンセル",
+    progress: "転送中...",
+    transferring: "{table} を転送中...",
+    completed: "転送が完了しました",
+    completedWithErrors: "{count}テーブル失敗で完了 | {count}テーブル失敗で完了",
+    failed: "転送に失敗しました",
+    cancelled: "転送がキャンセルされました",
+    rowsTransferred: "{count}行を転送しました",
+    tableProgress: "{current} / {total} テーブル",
+    noSqlConnections: "利用可能なSQL接続がありません",
+    selectTables: "転送するテーブルを選択してください",
+    searchTables: "テーブルを検索...",
+    noTables: "テーブルがありません",
+    selectSourceFirst: "先にソース接続とデータベースを選択してください",
+    tableError: "テーブル {table} が失敗しました: {error}",
+    overallProgress: "全体の進捗",
+    dataTransfer: "データ転送",
+    runInBackground: "バックグラウンドで実行",
+    newTask: "新規転送",
+    editConfig: "設定を編集",
+    retry: "リトライ",
+    targetTableBusy: "別の転送がすでにターゲットテーブルに書き込み中です: {tables}",
+    ownershipTitle: "所有者の確認",
+    ownershipMessage: "対象データベースに次の所有者ユーザーまたはロールがありません: {owners}。元の所有者を適用すると失敗する可能性があります。",
+    ownershipSkipDetails: "スキップすると、オブジェクト所有者の変更ステートメントは実行されません。テーブルデータとその他の構造の同期は続行されます。",
+    ownershipTargetOwner: "確認すると、所有者が存在しないオブジェクトは対象接続ユーザーに再割り当てされます: {owner}。",
+    ownershipSkip: "スキップ",
+    ownershipConfirm: "確認",
+    selectConnection: "接続を選択",
+    selectDatabase: "データベースを選択",
+    selectSchema: "スキーマを選択",
+    searchConnection: "接続を検索...",
+    searchDatabase: "データベースを検索...",
+    searchSchema: "スキーマを検索...",
+  },
+  tableImport: {
+    title: "テーブルデータをインポート",
+    target: "対象テーブル",
+    selectFile: "ファイルを選択",
+    changeFile: "Change File",
+    noFileSelected: "No file selected",
+    sourceFile: "Source file",
+    sourceFormat: "Source format",
+    stepSource: "Source",
+    stepOptions: "Options",
+    stepMapping: "Mapping",
+    stepReview: "Review",
+    stepExecution: "Run",
+    formatCsv: "CSV",
+    formatCsvDescription: "Comma-separated text",
+    formatTsv: "TSV",
+    formatTsvDescription: "Tab-separated text",
+    formatDelimited: "Delimited",
+    formatDelimitedDescription: "Custom text delimiter",
+    formatJson: "JSON",
+    formatJsonDescription: "Object or array rows",
+    formatExcel: "Excel",
+    formatExcelDescription: "XLS, XLSX, XLSM",
+    previewRows: "Preview rows",
+    delimiter: "Delimiter",
+    hasHeader: "First row is header",
+    trimValues: "Trim values",
+    emptyStringAsNull: "Empty string as NULL",
+    jsonShape: "JSON rows",
+    jsonShapeAuto: "Auto-detect",
+    jsonShapeObjects: "Objects",
+    jsonShapeArrays: "Arrays",
+    sheet: "Sheet",
+    firstSheet: "First sheet",
+    loadPreview: "Load Preview",
+    reloadPreview: "Reload Preview",
+    previewReady: "{rows} rows, {columns} columns",
+    file: "ファイル",
+    rows: "行数",
+    mapped: "マッピング済み",
+    mapping: "列マッピング",
+    sourceColumn: "ソース",
+    targetColumn: "ターゲット",
+    targetDataType: "型",
+    createColumns: "作成する列",
+    skipColumn: "スキップ",
+    preview: "プレビュー",
+    mode: "インポートモード",
+    append: "データを追加",
+    truncate: "トランケートしてからインポート",
+    progress: "進捗",
+    start: "インポート開始",
+    success: "{count}行をインポートしました",
+    back: "Back",
+    next: "Next",
+    truncateWarning: "Existing rows in the target table will be removed before import starts.",
+    requiredUnmapped: "Required target columns are not mapped: {columns}",
+    status_idle: "Ready to import",
+    status_running: "Importing data",
+    status_done: "Import complete",
+    status_error: "Import failed",
+    status_cancelled: "Import cancelled",
+  },
+  dataGenerate: {
+    title: "データ生成",
+    target: "対象",
+    rowCount: "生成行数",
+    columns: "列",
+    column: "列",
+    type: "タイプ",
+    generator: "ジェネレーター",
+    columnProps: "列プロパティ",
+    databaseObjects: "データベースオブジェクト",
+    selectTable: "左からテーブルを選択してください",
+    saveProfile: "プロファイルを保存",
+    loadProfile: "プロファイルを読み込む",
+    options: "オプション",
+    generateOrder: "生成順序",
+    nextStep: "次へ",
+    insertSuccess: "{count}行を挿入しました",
+    noData: "まだデータがありません。先に生成ルールを設定してください",
+    noResult: "実行結果がありません",
+    regenerate: "再生成",
+    first50Rows: "先頭50行を表示中、合計{count}行",
+    resultTitle: "実行結果",
+    successLabel: "{count}件成功",
+    failLabel: "{count}件失敗",
+    totalLabel: "/ {count}エントリ",
+    copyAllSql: "すべてのSQLをコピー",
+    prevStep: "戻る",
+    startInsert: "挿入開始",
+    confirm: "確認",
+    back: "戻る",
+    reset: "リセット",
+    selectGenerator: "ジェネレーターを選択...",
+    selectGeneratorHint: "ジェネレーターを選択してください",
+    preview: "プレビュー",
+    noValue: "(なし)",
+    startDate: "開始日",
+    endDate: "終了日",
+    allDay: "終日",
+    startTime: "開始時刻",
+    endTime: "終了時刻",
+    weekday: "曜日",
+    all: "すべて",
+    weekdayOnly: "平日",
+    custom: "カスタム",
+    values: "値",
+    min: "最小",
+    max: "最大",
+    increment: "増分",
+    cycle: "超過時に循環",
+    includeDefault: "DEFAULTを含める",
+    includeNull: "NULLを含める",
+    unique: "一意に設定",
+    disableLinks: "列間のデータリンクを無効化",
+    imageMode: "モード",
+    generate: "生成",
+    fromFolder: "フォルダから",
+    imageWidth: "画像幅",
+    imageHeight: "画像高さ",
+    imageFormat: "画像形式",
+    folderPath: "フォルダパス",
+    filterByExtension: "拡張子でフィルター",
+    errorContinue: "エラー時に続行",
+    truncateBefore: "生成前にテーブルをトランケート",
+    useTransaction: "トランザクションを使用",
+    extendedInsert: "拡張INSERTを使用",
+    ok: "OK",
+    noTablesSelected: "テーブルが選択されていません",
+    orderHint: "矢印ボタンで並び替え",
+    gen: {
+      general: "一般",
+      personal: "個人",
+      payment: "支払い",
+      business: "ビジネス",
+      location: "場所",
+      product: "製品",
+      computer: "コンピューター",
+      number: "数値",
+      datetime: "日時",
+      date: "日付",
+      time: "時間",
+      sequence: "シーケンス",
+      enum: "列挙",
+      text: "テキスト",
+      image: "画像/バイナリ",
+      foreign_key: "外部キー",
+      uuid: "UUID",
+      regex: "正規表現",
+      full_name: "氏名",
+      gender: "性別",
+      title: "敬称",
+      marital_status: "婚姻状況",
+      phone: "電話番号",
+      email: "メールアドレス",
+      job_title: "役職",
+      social_id: "ソーシャルID",
+      payment_method: "支払方法",
+      credit_card_type: "クレジットカード種類",
+      credit_card_number: "クレジットカード番号",
+      credit_card_date: "クレジットカード有効期限",
+      company_name: "会社名",
+      department: "部署",
+      industry: "業界",
+      address: "住所",
+      city: "市区町村",
+      region: "都道府県",
+      product_name: "製品名",
+      product_category: "製品カテゴリ",
+      color: "色",
+      size: "サイズ",
+      weight_unit: "重量単位",
+      barcode: "バーコード",
+      sku: "SKU",
+      ip_address: "IPアドレス",
+      mac_address: "MACアドレス",
+      file_path: "ファイルパス",
+      file_name: "ファイル名",
+      file_extension: "ファイル拡張子",
+      url: "URL",
+      hostname: "ホスト名",
+      id_number: "証明書番号",
+    },
+    idTypes: {
+      title: "証明書の種類",
+      customPattern: "カスタムパターン",
+      customPatternPlaceholder: "例: ([A-Z]{2})-([0-9]{8})",
+      customPatternHint: "[A-Z] 英字、[0-9] 数字、{n} 繰り返し、ハイフンなどの簡単なパターンに対応",
+      id_card: "中国身分証",
+      passport: "パスポート",
+      hk_macau_pass: "港澳通行証",
+      taiwan_pass: "台湾通行証",
+      uscc: "統一社会信用コード",
+      bank_card: "銀行カード",
+      drivers_license: "運転免許証",
+      custom: "カスタム",
+    },
+  },
+  tableToolbox: {
+    title: "データツール",
+    generateData: "データを生成",
+    importData: "データをインポート",
+    exportData: "データをエクスポート",
+    generateDataComingSoon: "近日公開",
+  },
+  sqlFile: {
+    runInBackground: "バックグラウンドで実行",
+    title: "SQLファイルを実行",
+    file: "ファイル",
+    selectSqlFile: "SQLファイルを選択",
+    browse: "参照",
+    previewingLines: "{count}行をプレビュー中",
+    previewingFirstLines: "先頭{count}行をプレビュー中",
+    target: "対象",
+    connection: "接続",
+    selectConnection: "接続を選択",
+    database: "データベース",
+    selectDatabase: "データベースを選択",
+    databasePlaceholder: "データベース名",
+    options: "オプション",
+    continueOnError: "エラー時に続行",
+    cancelling: "キャンセル中...",
+    cancel: "キャンセル",
+    execute: "実行",
+    statement: "ステートメント",
+    succeeded: "成功",
+    failed: "失敗",
+    affectedRows: "影響行数",
+    currentStatement: "現在の文",
+    status: {
+      idle: "待機中",
+      started: "開始",
+      running: "実行中",
+      statementDone: "ステートメント完了",
+      statementFailed: "ステートメント失敗",
+      done: "完了",
+      error: "エラー",
+      cancelled: "キャンセル済み",
+    },
+  },
+  diff: {
+    title: "スキーマを比較",
+    source: "ソース",
+    target: "対象",
+    selectConnection: "接続を選択",
+    selectDatabase: "データベースを選択",
+    selectSchema: "スキーマを選択",
+    connection: "接続",
+    database: "データベース",
+    schema: "スキーマ",
+    recentConfigs: "最近の設定",
+    selectRecentConfig: "最近の設定を選択",
+    ignoreComments: "コメントの差分を無視",
+    compare: "比較",
+    comparing: "スキーマを比較中...",
+    noDifferences: "差分が見つかりません",
+    table: "テーブル",
+    status: "ステータス",
+    details: "詳細",
+    added: "追加",
+    removed: "削除",
+    modified: "変更",
+    indexes: "インデックス",
+    foreignKeys: "外部キー",
+    triggers: "トリガー",
+    comments: "コメント",
+    newTable: "新しいテーブル",
+    dropTable: "テーブル削除",
+    generatedSql: "同期SQL",
+    copySql: "SQLをコピー",
+    executeSync: "同期を実行",
+    syncSuccess: "同期が正常に実行されました",
+    swap: "ソースとターゲットを入れ替え",
+    syncProgress: "実行中: {current}/{total}",
+    syncSummary: "成功 {success}、失敗 {failed}",
+    configSaved: "設定を保存しました",
+    selectObjectToCompare: "DDL比較を表示するにはオブジェクトを選択してください",
+    noDdlAvailable: "利用可能なDDLがありません",
+    sourceDdl: "ソースDDL",
+    targetDdl: "ターゲットDDL",
+    objectNotExistsInSource: "このオブジェクトはソースデータベースに存在しません",
+    objectNotExistsInTarget: "このオブジェクトはターゲットデータベースに存在しません",
+    nextStepDeploy: "次へ（デプロイ確認）",
+    deployReview: "デプロイ確認",
+    backToResult: "結果に戻る",
+    copyScript: "スクリプトをコピー",
+    exportSql: ".sqlをエクスポート",
+    deployToServer: "サーバーにデプロイ",
+    deployConfirmTitle: "最終確認",
+    deployConfirmMessage: "以下の変更をターゲットデータベースにデプロイしようとしています",
+    targetServer: "ターゲットサーバー",
+    dbVersion: "データベースバージョン",
+    targetDatabase: "ターゲットデータベース",
+    targetSchema: "ターゲットスキーマ",
+    useTransaction: "トランザクションで実行（失敗時に自動ロールバック）",
+    confirmDeploy: "デプロイを確認",
+    exportSuccess: "エクスポート成功",
+    create: "作成",
+    delete: "削除",
+    modify: "変更",
+    cancel: "キャンセル",
+    operationLabel: {
+      modify: "変更するオブジェクト",
+      create: "作成するオブジェクト",
+      delete: "削除するオブジェクト",
+      none: "操作なし",
+    },
+    objectKindLabel: {
+      table: "テーブル",
+      view: "ビュー",
+      function: "関数",
+      sequence: "シーケンス",
+      rule: "ルール",
+      owner: "所有者",
+      index: "インデックス",
+      foreignKey: "外部キー",
+      trigger: "トリガー",
+    },
+    noObjectsSelected: "デプロイするオブジェクトを選択してください",
+    deploySuccess: "デプロイ成功",
+    deployFailed: "デプロイ失敗",
+    deploySuccessMessage: "SQLスクリプトがターゲットデータベースで正常に実行されました",
+    deployFailedMessage: "実行中にエラーが発生しました",
+    affectedRows: "影響行数",
+    executedStatements: "実行された文",
+    serverVersion: "サーバーバージョン",
+    close: "閉じる",
+    configDeleted: "設定を削除しました",
+    sourceObject: "ソースオブジェクト",
+    targetObject: "ターゲットオブジェクト",
+    operation: "操作",
+    selectedCount: "{selected}/{total} 選択中",
+    saveConfig: "設定を保存",
+    loadConfig: "設定を読み込む",
+    options: "オプション",
+    ddlCompare: "DDL比較",
+    deployScript: "デプロイスクリプト",
+    deployScriptAll: "全デプロイスクリプト",
+    deployScriptDesc: "選択したオブジェクトのSQLスクリプト",
+    deployScriptAllDesc: "選択した全オブジェクトのSQLスクリプト",
+    copy: "コピー",
+    execute: "実行",
+    executeAll: "すべて実行",
+    executeSuccess: "正常に実行されました",
+    noDeployScript: "デプロイスクリプトがありません",
+    noDeployScriptAll: "選択したオブジェクトにデプロイスクリプトがありません",
+    prevStep: "前へ",
+    recompare: "再比較",
+    maximize: "最大化",
+    restore: "復元",
+    info: "情報",
+    connType: "接続タイプ",
+    connName: "接続名",
+    host: "ホスト",
+    port: "ポート",
+    copied: "クリップボードにコピーしました",
+    saveConfigPrompt: "設定名を入力してください:",
+    searchConnection: "接続を検索...",
+    searchDatabase: "データベースを検索...",
+    searchSchema: "スキーマを検索...",
+  },
+  schemaDiff: {
+    optionsTitle: "比較オプション",
+    selectConfig: "設定を選択",
+    newConfigName: "新しい設定",
+    newConfig: "新しい設定",
+    renameConfig: "設定名を変更",
+    duplicateConfig: "設定を複製",
+    deleteConfig: "設定を削除",
+    exportConfig: "設定をエクスポート",
+    exportAllConfigs: "すべての設定をエクスポート",
+    importConfig: "設定をインポート",
+    importFromFile: "ファイルからインポート",
+    importFromText: "テキストからインポート",
+    importPlaceholder: "JSON設定を貼り付け...",
+    importInvalidJson: "不正なJSON形式です",
+    configName: "設定名",
+    tableFilter: "テーブルフィルター",
+    tableFilterHint: "テーブル名をJavaScript正規表現で照合します。包含が空なら全テーブル、除外が空なら除外なしです。",
+    tableFilterHintShort: "テーブル名の正規表現で比較範囲を絞り込み",
+    tableFilterHelp: "テーブルフィルターのヘルプ",
+    tableFilterHelpRule: "完全なテーブル名に一致します。/.../ は入力しません。",
+    tableFilterHelpBlank: "包含が空なら全テーブル、スキップが空なら除外なしです。",
+    tableFilterHelpExample: "^user_ は user_ で始まる名前、_bak$ は _bak で終わる名前、a|b は a または b を表します。",
+    tableIncludePattern: "含めるテーブル名の正規表現",
+    tableIncludePatternPlaceholder: "例: ^user_",
+    tableExcludePattern: "除外するテーブル名の正規表現",
+    tableExcludePatternPlaceholder: "例: _bak$",
+    tableFilterPriority: "両方に一致した場合",
+    tableFilterPriorityExclude: "除外を優先",
+    tableFilterPriorityInclude: "包含を優先",
+    options: {
+      tables: "テーブルを比較",
+      primaryKeys: "主キーを比較",
+      foreignKeys: "外部キーを比較",
+      uniqueKeys: "一意キーを比較",
+      checks: "チェック制約を比較",
+      exclusions: "排他制約を比較",
+      views: "ビューを比較",
+      functions: "関数を比較",
+      indexes: "インデックスを比較",
+      sequences: "シーケンスを比較",
+      triggers: "トリガーを比較",
+      rules: "ルールを比較",
+      owners: "所有者を比較",
+      cascadeDelete: "CASCADE削除を使用",
+      sequenceLastValues: "シーケンス最終値を比較",
+      compareColumnOrder: "列順序を比較",
+    },
+  },
+  dataCompare: {
+    title: "データを比較",
+    selectTable: "テーブルを選択",
+    searchTable: "テーブルを検索...",
+    sourceTables: "ソーステーブル",
+    targetTable: "対象テーブル",
+    searchTables: "テーブルを検索...",
+    selectedTables: "{selected}/{total}件選択中",
+    selectAllTables: "すべて選択",
+    deselectAllTables: "すべて解除",
+    selectSourceTables: "先にソース接続とデータベースを選択し、比較するテーブルを選んでください",
+    noTables: "比較可能なテーブルがありません",
+    autoMatchHint: "バッチモードでは同じ名前のターゲットテーブルを自動的にマッチングします",
+    matchedTables: "{matched}/{total}テーブルがマッチしました",
+    missingTargetTables: "同名のターゲットテーブルが見つかりません: {tables}",
+    keyColumns: "キー列",
+    keyColumnsPlaceholder: "カンマ区切りの主キーまたは一意列",
+    keyColumnsAutoHint: "単一テーブル比較では空白で主キーを自動検出、バッチ比較ではテーブルごとに指定します。",
+    rowCounts: "ソース {source}行、ターゲット {target}行、完全比較が完了しました",
+    previewLimitOption: "{count}件プレビュー",
+    compare: "データを比較",
+    summary: "追加 {added}、削除 {removed}、変更 {modified}",
+    batchSummary: "{tables}テーブルを比較: {different}不一致、{same}一致、{failed}失敗; 追加 {added}、削除 {removed}、変更 {modified}",
+    comparingTable: "比較中 {current}/{total}: {table}",
+    keyColumnsInline: "キー列: {columns}",
+    selectedInline: "選択済み {selected}/{total}",
+    selectedSummary: "選択: 追加 {added}、削除 {removed}、変更 {modified}",
+    selectAllKind: "すべての{kind}を選択",
+    clearKind: "{kind}をクリア",
+    clearSelection: "すべての選択をクリア",
+    showAllRows: "{count}件すべて表示",
+    showLessRows: "少なく表示",
+    remainingRows: "プレビューでさらに{count}行が非表示",
+    planningSync: "同期計画を更新中...",
+    noSelectedDifferences: "実行する差分が選択されていません",
+    planSummary: "計画: {inserts}件のINSERT、{updates}件のUPDATE、{deletes}件のDELETE、{statements}文",
+    statusDifferent: "差異あり",
+    statusSame: "同一",
+    statusError: "失敗",
+    noKeyColumns: "少なくとも1つのキー列を選択してください",
+    missingKeyColumns: "キー列はソースとターゲットの両方のテーブルに存在する必要があります: {columns}",
+    noCommonColumns: "ソースとターゲットテーブルに比較可能な共通列がありません",
+    targetTableMissing: "ターゲットテーブルが見つかりません: {table}",
+    noComparableTables: "比較可能なテーブルが見つかりません。同名のターゲットテーブルが存在するか確認してください。",
+    noDifferences: "データは同一です。同期SQLは不要です",
+    syncSuccess: "データ同期が正常に実行されました",
+  },
+  settings: {
+    title: "設定",
+    editorTab: "エディタ",
+    sqlFormatterTab: "SQLフォーマッター",
+    sqlFormatterImport: "設定をインポート",
+    sqlFormatterExport: "設定をエクスポート",
+    sqlFormatterImportSuccess: "フォーマッター設定をインポートしました。",
+    sqlFormatterCopyJson: "JSONをコピー",
+    sqlFormatterCopyJsonSuccess: "JSONをコピーしました。",
+    sqlFormatterCopyJsonFailed: "コピーに失敗しました: {message}",
+    sqlFormatterJsonEditorLoadFailed: "JSONエディタの読み込みに失敗しました。基本入力に切り替えました: {message}",
+    sqlFormatterRestoreDefaults: "デフォルトに戻す",
+    sqlFormatterFormMode: "フォーム",
+    sqlFormatterJsonMode: "JSON",
+    sqlFormatterKeywordCase: "キーワードの大文字/小文字",
+    sqlFormatterFunctionCase: "関数の大文字/小文字",
+    sqlFormatterDataTypeCase: "データ型の大文字/小文字",
+    sqlFormatterIdentifierCase: "識別子の大文字/小文字",
+    sqlFormatterCaseUpper: "大文字",
+    sqlFormatterCaseLower: "小文字",
+    sqlFormatterCasePreserve: "保持",
+    sqlFormatterIndent: "インデント",
+    sqlFormatterIndentSpaces: "スペース",
+    sqlFormatterIndentTabs: "タブ",
+    sqlFormatterTabWidth: "タブ幅",
+    sqlFormatterIndentStyle: "インデントスタイル",
+    sqlFormatterIndentStyleStandard: "標準",
+    sqlFormatterIndentStyleTabularLeft: "表形式左寄せ",
+    sqlFormatterIndentStyleTabularRight: "表形式右寄せ",
+    sqlFormatterLogicalOperatorNewline: "論理演算子の改行",
+    sqlFormatterLogicalBefore: "演算子の前",
+    sqlFormatterLogicalAfter: "演算子の後",
+    sqlFormatterExpressionWidth: "式の幅",
+    sqlFormatterLinesBetweenQueries: "クエリ間の行数",
+    sqlFormatterDenseOperators: "演算子を詰める",
+    sqlFormatterNewlineBeforeSemicolon: "セミコロンを新しい行に",
+    sqlFormatterAdvancedOptions: "詳細オプション",
+    sqlFormatterParams: "パラメータ",
+    sqlFormatterParamTypes: "パラメータ型",
+    sqlFormatterEditorShortcuts: "ショートカット",
+    sqlFormatterShortcutAction: "アクション",
+    sqlFormatterShortcutEnabled: "有効",
+    sqlFormatterShortcutWindows: "Windows",
+    sqlFormatterShortcutLinux: "Linux",
+    sqlFormatterShortcutMacos: "macOS",
+    sqlFormatterShortcutFind: "検索",
+    sqlFormatterShortcutReplace: "置換",
+    sqlFormatterShortcutIndentMore: "インデントを増やす",
+    sqlFormatterShortcutIndentLess: "インデントを減らす",
+    sqlFormatterShortcutDuplicateLine: "現在行を複製",
+    sqlFormatterShortcutDeleteLine: "現在行を削除",
+    sqlFormatterShortcutMoveLine: "行を移動",
+    sqlFormatterShortcutMoveLineUp: "行を上に移動",
+    sqlFormatterShortcutMoveLineDown: "行を下に移動",
+    sqlFormatterShortcutCopyLine: "行をコピー",
+    sqlFormatterShortcutCopyLineUp: "行を上にコピー",
+    sqlFormatterShortcutCopyLineDown: "行を下にコピー",
+    sqlFormatterShortcutUndo: "元に戻す",
+    sqlFormatterShortcutRedo: "やり直す",
+    sqlFormatterShortcutSelectAll: "すべて選択",
+    sqlFormatterShortcutFormatJson: "JSONをフォーマット",
+    sqlFormatterShortcutApply: "設定を適用",
+    sqlFormatterConfigErrorInvalidJson: "無効なJSONです。",
+    sqlFormatterConfigErrorObject: "設定はJSONオブジェクトである必要があります。",
+    sqlFormatterConfigErrorVersion: "サポートされていない設定バージョンです。",
+    sqlFormatterConfigErrorFormatter: "サポートされていないフォーマッターです。",
+    sqlFormatterConfigErrorUnsupportedParams: "パラメータ置換オプションはサポートされていません。SQLフォーマットはプレースホルダーを置換しません。",
+    sqlFormatterConfigErrorOptionsObject: "設定オプションはJSONオブジェクトである必要があります。",
+    sqlFormatterConfigErrorEditorObject: "エディタ設定はJSONオブジェクトである必要があります。",
+    sqlFormatterConfigErrorEditorScope: "サポートされていないエディタスコープです。",
+    sqlFormatterConfigErrorEditorPlatforms: "無効なエディタプラットフォームです。",
+    sqlFormatterConfigErrorEditorShortcutsArray: "エディタショートカットは配列である必要があります。",
+    sqlFormatterConfigErrorEditorShortcutValue: "無効なエディタショートカットです。",
+    sqlFormatterConfigErrorUnknownOption: "不明なフォーマッターオプション: {option}。",
+    sqlFormatterConfigErrorInvalidOptionValue: "{option}の値が無効です。",
+    sqlFormatterConfigErrorUnknownEditorShortcut: "不明なエディタショートカット: {shortcut}。",
+    sqlFormatterConfigErrorInvalidEditorShortcut: "無効なエディタショートカット: {shortcut}。",
+    sqlFormatterConfigErrorDuplicateEditorShortcut: "重複するエディタショートカット: {shortcut}。",
+    sqlFormatterConfigErrorInvalidConfig: "無効なフォーマッター設定です。",
+    appearanceTab: "外観",
+    navigationTab: "ナビゲーション",
+    dataTab: "データ",
+    tunnelsTab: "トンネル",
+    tunnelsDescription: "再利用可能な SSH / プロキシ / HTTP トンネル設定です。一度設定すれば、接続のトンネルタブからプロファイルを選択するだけで使えます。ここでの編集は、このプロファイルを使用するすべての接続に反映されます。",
+    tunnelsEmpty: "トンネルプロファイルがまだありません。ここで作成し、接続のトンネル設定で選択してください。",
+    tunnelsAddSsh: "SSH を追加",
+    tunnelsAddProxy: "プロキシを追加",
+    tunnelsAddHttp: "HTTP トンネルを追加",
+    tunnelsProfileName: "プロファイル名",
+    tunnelsProfileNamePlaceholder: "例：オフィスの踏み台サーバー",
+    tunnelsDelete: "削除",
+    tunnelsUnnamedProfile: "名称未設定のプロファイル",
+    tunnelsSave: "保存",
+    tunnelsReset: "リセット",
+    tunnelsSaved: "トンネルプロファイルを保存しました",
+    tunnelsSaveFailed: "トンネルプロファイルの保存に失敗しました: {message}",
+    tunnelsUnsavedHint: "未保存の変更があります",
+    redisTab: "Redis",
+    shortcutsTab: "ショートカット",
+    snippetsTab: "スニペット",
+    syncTab: "同期",
+    aiTab: "AI",
+    mcpTab: "MCP",
+    jdbcTab: "JDBCドライバー",
+    securityTab: "セキュリティ",
+    aboutTab: "バージョン情報",
+    fontFamily: "フォントファミリー",
+    uiFontFamily: "インターフェイスフォント",
+    uiFontAppDefault: "DBX デフォルト",
+    uiFontSystemDefault: "システムデフォルト",
+    uiFontFamilyDescription: "ツールバー、タブ、サイドバー、ダイアログなど、エディター以外のUIに適用します。",
+    selectFont: "フォントを選択...",
+    searchFont: "フォントを検索...",
+    loadingFonts: "フォントを読み込み中...",
+    noFontsFound: "フォントが見つかりません",
+    useCustomFont: "「{font}」を使用",
+    languageTitle: "言語 / Language",
+    fontSize: "フォントサイズ",
+    toolbarTitle: "ツールバー",
+    toolbarHiddenHint: "非表示または幅が足りない一部のボタンは、「もっと見る」ドロップダウン内に表示されます。",
+    uiScale: "UIスケール",
+    uiScaleDescription: "高DPIディスプレイ向けにデスクトップUI全体をスケーリングします。変更は即座に適用され、次回起動時に復元されます。",
+    theme: "テーマ",
+    selectTheme: "テーマを選択...",
+    colorTheme: "配色テーマ",
+    selectColorTheme: "配色テーマを選択...",
+    themePalettePearl: "白",
+    themePaletteMist: "霧灰",
+    themePaletteGraphite: "チタングレー",
+    themePaletteCobalt: "コバルトブルー",
+    themePaletteSage: "セージグリーン",
+    themePaletteAmber: "暖黄",
+    themePaletteBlush: "桜ピンク",
+    themePaletteVscode: "VS Code",
+    themePaletteIdea: "IDEA",
+    themePaletteXcode: "Xcode",
+    themePaletteJetbrains: "JetBrains",
+    themePaletteCursor: "Cursor",
+    themePaletteClaude: "Claude Code",
+    followAppTheme: "アプリテーマに従う",
+    appLayout: "インターフェースレイアウト",
+    appLayoutSeparated: "モダン分離型",
+    appLayoutSeparatedDescription: "ブロックスタイルのタブで明確なパネル分離。",
+    appLayoutClassic: "クラシックコンパクト",
+    appLayoutClassicDescription: "連続タブバーとコンパクトなパネルヘッダー。",
+    iconTheme: "アイコンとロゴのスタイル",
+    iconThemeDefault: "デフォルト",
+    iconThemeDefaultDescription: "カラーDBXアプリアイコンを使用。",
+    iconThemeBlack: "黒",
+    iconThemeBlackDescription: "アプリ内で黒いDBXロゴを使用。",
+    iconThemeBlackDescriptionMac: "アプリ内は黒いロゴ、Dockは黒い背景、メニューバーはシステムに従います。",
+    showTrayIcon: "トレイ/メニューバーアイコンを表示",
+    showTrayIconDescription: "無効時はアイコンが表示されませんが、ウィンドウを閉じると従来通りDBXはバックグラウンドに隠れます。",
+    quitOnClose: "ウィンドウを閉じるときに終了",
+    quitOnCloseDescription: "有効にすると、閉じるボタンでトレイに隠すのではなく、DBXを完全に終了します。",
+    closeActionPromptTitle: "ウィンドウを閉じる",
+    closeActionPromptDescription: "閉じるボタンの動作を選択してください。後から「設定 → 外観」で変更できます。",
+    closeActionQuit: "DBXを終了",
+    closeActionMinimize: "トレイに最小化",
+    updateNotificationsEnabled: "アップデート通知を有効にする",
+    updateNotificationsEnabledDescription: "無効時、DBXはアプリやドライバーのアップデートを自動確認せず、アップデートバッジも表示しません。手動確認は引き続き利用可能です。",
+    debugLoggingEnabled: "デバッグログを有効にする",
+    debugLoggingEnabledDescription: "トラブルシューティング時に、より詳細なローカル診断ログを記録します。デフォルトでは無効です。",
+    duckDbWorkerProcessIsolation: "DuckDB プロセス分離モード（実験的）",
+    duckDbWorkerProcessIsolationDescription: "DuckDB クエリを独立した worker プロセスで実行します。長時間クエリがキャンセルに応答しない場合、DBX は worker プロセスを停止してデータベースファイルのロックを解放できます。",
+    duckDbWorkerMaxProcesses: "DuckDB の最大同時 worker 数",
+    duckDbWorkerMaxProcessesDescription: "DBX が同時に実行できる DuckDB worker プロセス数を制限します。範囲: 1-16。既定値: 4。",
+    duckDbWorkerProcessIsolationRestartRequired: "この変更を有効にするには DBX を再起動してください。",
+    restartDbx: "DBX を再起動",
+    restartDbxFailed: "DBX の再起動に失敗しました: {error}",
+    debugLogsCopy: "ログをコピー",
+    debugLogsCopied: "コピーしました",
+    debugLogsDownload: "ログをダウンロード",
+    debugLogsDownloaded: "ダウンロードしました",
+    debugLogsClear: "ログをクリア",
+    tableStructureSection: "テーブル構造",
+    dataGridDisplay: "データグリッド表示",
+    showColumnCommentsInHeader: "列名の下にコメントを表示",
+    showColumnCommentsInHeaderDescription: "グリッド列名の直下にテーブル列コメントを表示します。",
+    showColumnTypesInHeader: "列名の下にデータ型を表示",
+    showColumnTypesInHeaderDescription: "グリッド列名の直下に各列のデータ型を表示します。",
+    compactColumnHeaderActions: "列ヘッダーツールをコンパクトに",
+    compactColumnHeaderActionsDescription: "フォーマッターとローカルフィルターツールをもっと見るメニューに移動し、列名を優先表示します。",
+    dataGridQuickEntry: "グリッド高速入力",
+    dataGridQuickEntryDescription: "有効にすると、セル編集や下部の空行入力はフォーカスが外れた時点でデータベースに保存されます。頻繁な入力に便利ですが、誤操作による書き込みのリスクがあります。",
+    tableColumnTemplateFields: "新規テーブルのプリセット列",
+    tableColumnTemplateFieldsDescription: "データベース種別を選択し、新規テーブル作成時に使うプリセット列の型を設定します。",
+    tableColumnTemplateAdd: "列を追加",
+    tableColumnTemplateColumn: "列",
+    tableColumnTemplateDatabase: "データベース",
+    tableColumnTemplateType: "型",
+    tableColumnTemplateLength: "長さ",
+    tableColumnTemplateDefault: "デフォルト",
+    tableColumnTemplateNoPresetType: "プリセット型なし",
+    tableColumnTemplateRequired: "必須",
+    tableColumnTemplateComment: "説明",
+    tableColumnTemplateDragHandle: "ドラッグして並べ替え",
+    sidebarActivation: "サイドバーのアクティベーション",
+    sidebarActivationSingle: "シングルクリック",
+    sidebarActivationSingleDescription: "1クリックでサイドバー項目を開きます。",
+    sidebarActivationDouble: "ダブルクリック",
+    sidebarActivationDoubleDescription: "シングルクリックで行を選択、ダブルクリックで項目を開きます。",
+    sidebarObjectDisplay: "サイドバーオブジェクトレイアウト",
+    sidebarObjectDisplayGrouped: "詳細表示",
+    sidebarObjectDisplayGroupedDescription: "オブジェクトタイプが多いデータベース向けに、テーブル、ビュー、プロシージャ、関数でグループ化します。",
+    sidebarObjectDisplaySimple: "シンプル表示",
+    sidebarObjectDisplaySimpleDescription: "中間レベルを減らすために、各データベースまたはスキーマの直下にテーブルとビューを一覧表示します。",
+    autoSelectActiveSidebarNode: "開いた項目を常に選択",
+    autoSelectActiveSidebarNodeDescription: "タブ切替時に、サイドバーで一致する表示中のテーブル、コレクション、またはSQLファイルを選択します。",
+    openTabsRestoreMode: "起動時にタブを復元",
+    openTabsRestoreModeDescription: "DBX 起動時に前回開いていたタブをどのように復元するかを選択します。",
+    openTabsRestoreModeAll: "すべてのタブを保持",
+    openTabsRestoreModePinned: "ピン留めタブのみ保持",
+    openTabsRestoreModeNone: "タブを保持しない",
+    openTabsRestoreModeHint: "ピン留めタブはタブバーの左側に配置され、頻繁に使う作業の入り口として便利です。",
+    disconnectTabHandlingMode: "切断後のタブ",
+    disconnectTabHandlingModeDescription: "接続またはデータベースを閉じた後の関連タブの処理方法を選択します。",
+    disconnectTabHandlingModeCloseTabs: "すべてのタブを閉じる",
+    disconnectTabHandlingModeCloseTabsDescription: "接続またはデータベースの関連タブをすべて閉じます。",
+    disconnectTabHandlingModeKeepTabsClearResults: "オブジェクトタブを閉じ、SQLタブを保持",
+    disconnectTabHandlingModeKeepTabsClearResultsDescription: "テーブルデータ、オブジェクトブラウザ、構造タブを閉じ、SQLクエリタブとSQLテキストを保持し、実状態と結果セッションもクリアします。",
+    disconnectTabHandlingModeKeepTabsKeepResults: "関連タブを閉じない",
+    disconnectTabHandlingModeKeepTabsKeepResultsDescription: "関連タブ、SQLテキスト、現在の結果を追加のクリーンアップなしで保持します。",
+    reuseDataTab: "データタブを再利用",
+    reuseDataTabDescription: "サイドバーでテーブルをクリックした際、毎回新しいタブを作成せずに既存のデータタブを再利用します。",
+    sidebarHiddenTablePrefixes: "非表示テーブル名プレフィックス",
+    sidebarHiddenTablePrefixesDescription: "1行に1つのプレフィックス。サイドバーのテーブル、ビュー、コレクションラベルのみ短縮されます。ツールチップと操作は完全な名前を使用します。",
+    sidebarHiddenTablePrefixesPlaceholder: "Example:\nODS_\nT8Y2_LONG_",
+    sidebarTablePageSize: "サイドバーのページサイズ",
+    sidebarTablePageSizeDescription: "サイドバーツリーで1ページあたりに読み込むテーブル/オブジェクトの最大数です。テーブルが多い場合は増やすとページ切り替えが減ります。",
+    sidebarTableSearchEnabled: "データベース内のテーブル検索を有効化",
+    sidebarTableSearchEnabledDescription: "展開済みのデータベース、schema、またはテーブルグループの下にローカル検索ボックスを表示し、スコープごとにテーブルを絞り込みます。",
+    sidebarHideTableComments: "サイドバーのテーブルコメントを非表示",
+    sidebarHideTableCommentsDescription: "横のスペースを節約するため、サイドバーツリーで名前の横に表示されるテーブル/ビューコメントを非表示にします。",
+    sidebarAllowHorizontalScroll: "サイドバーの横スクロールを許可",
+    sidebarAllowHorizontalScrollDescription: "サイドバーの横スクロールを許可して、長いテーブル、ビュー、コレクション名を完全に表示します。",
+    snippetsDescription: "エディタでトリガーされるSQLスニペットテンプレートをカスタマイズします。",
+    snippetsAdd: "スニペットを追加",
+    snippetsLabel: "ラベル",
+    snippetsPrefix: "プレフィックス",
+    snippetsStatus: "ステータス",
+    snippetsEnabled: "有効",
+    snippetsDisabled: "無効",
+    snippetsToggle: "スニペットを有効または無効にする",
+    snippetsBody: "SQL本文",
+    snippetsLabelPlaceholder: "例: select *",
+    snippetsPrefixPlaceholder: "例: sel",
+    snippetsBodyPlaceholder: "SELECT *\nFROM table\nLIMIT 100;",
+    snippetsRestoreDefaults: "デフォルトに戻す",
+    snippetsAddTitle: "スニペットを追加",
+    snippetsEditTitle: "スニペットを編集",
+    syncWebDavTitle: "WebDAV同期",
+    syncWebDavDescription: "保存済みSQLライブラリを含むDBXスナップショットをWebDAV互換ストレージへアップロードまたは復元します。",
+    syncEndpoint: "WebDAV URL",
+    syncUsername: "ユーザー名",
+    syncPassword: "パスワード",
+    syncPasswordPlaceholder: "パスワードを入力",
+    syncClearSavedPassword: "保存されたパスワードをクリア",
+    syncRememberWebDavPassword: "WebDAVアプリパスワードを記憶",
+    syncSavedPassword: "（保存済み）",
+    syncRememberWebDavPasswordDescription: "パスワードは暗号化され、このデバイスにのみ保存されます。WebDAVには同期されず、同期パスワードを置き換えるものでもありません。",
+    syncRemotePath: "リモートスナップショットパス",
+    syncRemotePathDescription: "アップロード時に不足している親フォルダをDBXが作成します。",
+    syncSecretNotice: "デフォルトでは、DBXは接続詳細と設定のみを同期します。データベースパスワード、SSHパスワード、プロキシパスワード、接続文字列、AI APIキーはローカルに保持されます。",
+    syncSecrets: "暗号化されたシークレットを同期",
+    syncSecretsDescription: "有効時、DBXはデータベースパスワード、SSHパスワード、AI APIキーを暗号化してからWebDAVにアップロードします。",
+    syncSecretsPassphrase: "同期パスワード",
+    syncSecretsPassphraseDescription: "このパスワードは機密データの暗号化と復元にのみ使用されます。DBXは保存せず、各デバイスで再度入力する必要があります。",
+    syncTest: "テスト",
+    syncUpload: "アップロード",
+    syncDownload: "ダウンロード",
+    syncTestSuccess: "WebDAVターゲットに到達可能です。",
+    syncUploadSuccess: "{bytes}バイトを{path}にアップロードしました。",
+    syncAutoUpload: "スナップショットを自動アップロード",
+    syncAutoUploadInterval: "間隔",
+    syncAutoUploadMinutes: "分",
+    syncAutoUploadDescription: "DBXを開いている間だけ実行されます。ローカルの保存済みSQLを誤って置き換えないよう、ダウンロードは手動確認が必要です。",
+    syncAutoUploadSuccess: "{bytes}バイトを{path}に自動アップロードしました。",
+    syncDownloadSuccess: "{path}から{bytes}バイトをダウンロードして適用しました。",
+    syncSecretsApplied: "暗号化されたシークレットが復元されました。",
+    syncSecretsSkipped: "暗号化されたシークレットが存在しましたが復元されませんでした。",
+    syncDownloadConfirm: "リモートDBXスナップショットをダウンロードして適用しますか？ローカルのメタデータと保存済みSQLが置き換えられます。",
+    apply: "適用",
+    applyAndClose: "適用して閉じる",
+    reset: "リセット",
+    resetDefaults: "デフォルトにリセット",
+    resetAllDefaults: "すべての設定をリセット",
+    save: "保存",
+    cancel: "キャンセル",
+    executeMode: "実行モード (Cmd+Enter)",
+    executeModeAll: "すべてのSQLを実行",
+    executeModeCurrent: "カーソル位置の文を実行",
+    showExecutionTargetPicker: "実行対象ピッカーを表示",
+    showExecutionTargetPickerDescription: "有効にすると、選択なしで実行するときに現在の文とすべてのSQLを一時的に選べます。",
+    showStatementRunButtons: "左側の実行ボタンを表示",
+    showStatementRunButtonsDescription: "SQLエディタのガターに文ごとの実行ボタンを表示します。無効にしてもキーボードショートカットとコンテキストメニューからの実行は引き続き使えます。",
+    showCurrentStatementFrame: "現在の文の枠線を表示",
+    showCurrentStatementFrameDescription: "有効にすると、SQLエディタで現在実行可能な文を枠線で示します。無効にすると枠線を表示しません。",
+    showInsertValueHints: "INSERT 値の列名ヒントを表示",
+    showInsertValueHintsDescription: "有効にすると、INSERT ... VALUES 句の各値の横に対応する列名ヒントを表示します。",
+    previewStatementRunButton: "文の実行ボタンのプレビュー",
+    wordWrap: "折り返し",
+    wordWrapDescription: "長いSQL行をエディタ幅内で折り返します",
+    vimMode: "Vimモード",
+    vimModeDescription: "SQLエディタでVim形式のモーダル編集を使用します",
+    autoCloseBrackets: "自動括弧補完",
+    autoCloseBracketsDescription: "左括弧や左引用符を入力すると、対応する右括弧や右引用符を自動的に挿入します",
+    sqlSemanticDiagnosticsEnabled: "SQLセマンティック診断",
+    sqlSemanticDiagnosticsEnabledDescription: "有効時、エディタは不明なテーブルや列などの意味的な問題を表示します。大きなSQLの解析とメタデータ確認の負荷を減らすには無効にします。",
+    confirmDangerousSqlExecution: "危険なSQLの前に確認",
+    confirmDangerousSqlExecutionDescription: "無効時、ALTER、DROP、DELETE、TRUNCATEなどの危険なSQLが警告ダイアログなしで実行されます。",
+    confirmUnsavedSqlClose: "未保存のSQLを閉じる前に確認",
+    confirmUnsavedSqlCloseDescription: "無効時、未保存の編集があるSQLタブは保存確認ダイアログなしで閉じるか終了します。",
+    sqlVariableSyntax: "SQL 変数・プレースホルダー置換",
+    sqlVariableSyntaxDescription: "SQL 実行前に置換する変数・プレースホルダー構文をデータベース種別ごとに選択します。既定ではすべて有効です。",
+    sqlVariableSyntax_positional: "位置プレースホルダー",
+    sqlVariableSyntax_positionalDescription: "各位置プレースホルダーを順番に置き換える値の入力を求めます。",
+    sqlVariableSyntax_named: "名前付きプレースホルダー",
+    sqlVariableSyntax_namedDescription: "名前付きプレースホルダーを置き換える値の入力を求めます。",
+    sqlVariableSyntax_shell: "シェル形式プレースホルダー",
+    sqlVariableSyntax_shellDescription: "シェル形式プレースホルダーを置き換える値の入力を求めます。",
+    sqlVariableSyntax_mybatis: "MyBatis 形式プレースホルダー",
+    sqlVariableSyntax_mybatisDescription: "MyBatis 形式プレースホルダーを置き換える値の入力を求めます。",
+    sqlVariableSyntax_sqlserver: "SQL Server 形式プレースホルダー",
+    sqlVariableSyntax_sqlserverDescription: "SQL Server 形式プレースホルダーを置き換える値の入力を求めます（セッション変数と競合する場合があります）。",
+    sqlVariableSyntax_atSet: "インライン変数展開",
+    sqlVariableSyntax_atSetDescription: "実行前にインライン変数宣言を展開し、その値をインライン化します。",
+    autoAliasTables: "テーブル別名を自動追加",
+    autoAliasTablesDescription: "FROM または JOIN でテーブル補完を選択すると、order_items AS oi のような生成済み別名を挿入します。",
+    redisScanPageSize: "Redisスキャンカウント",
+    redisScanPageSizeDescription: "キー参照時のRedis SCANページあたりの要求キー数。",
+    redisScanPageSizeOption: "{count}キー",
+    exportBatchSize: "エクスポートバッチサイズ",
+    exportBatchSizeDescription: "テーブルデータエクスポート時のバッチあたりの取得行数（100〜100000）。",
+    exportSection: "エクスポート",
+    shortcutExecuteSql: "SQLを実行",
+    shortcutFind: "検索",
+    shortcutReplace: "置換",
+    shortcutSaveSql: "SQLを保存",
+    shortcutAcceptCompletion: "補完を受け入れる",
+    shortcutFormatSql: "SQLをフォーマット",
+    shortcutToggleLineComment: "行コメントを切り替え",
+    shortcutIndentMore: "インデントを増やす",
+    shortcutIndentLess: "インデントを減らす",
+    shortcutDuplicateLine: "現在行を複製",
+    shortcutDeleteLine: "現在行を削除",
+    shortcutMoveLineUp: "行を上に移動",
+    shortcutMoveLineDown: "行を下に移動",
+    shortcutCopyLineUp: "行を上にコピー",
+    shortcutCopyLineDown: "行を下にコピー",
+    shortcutUndo: "元に戻す",
+    shortcutRedo: "やり直す",
+    shortcutSelectAll: "すべて選択",
+    shortcutCopyCurrentRow: "現在のデータ行をコピー",
+    shortcutDeleteCurrentRow: "現在のデータ行を削除",
+    shortcutNewQuery: "新しいクエリ",
+    shortcutOpenSettings: "設定を開く",
+    shortcutCloseTab: "タブを閉じる",
+    shortcutFocusSearch: "検索にフォーカス",
+    shortcutQuickOpen: "クイックオープン (すべてのデータベースオブジェクトを検索)",
+    shortcutSwitchToPreviousTab: "前のタブに切り替え",
+    shortcutSwitchToNextTab: "次のタブに切り替え",
+    shortcutSwitchToTab1: "タブ 1 に切り替え",
+    shortcutSwitchToTab2: "タブ 2 に切り替え",
+    shortcutSwitchToTab3: "タブ 3 に切り替え",
+    shortcutSwitchToTab4: "タブ 4 に切り替え",
+    shortcutSwitchToTab5: "タブ 5 に切り替え",
+    shortcutSwitchToTab6: "タブ 6 に切り替え",
+    shortcutSwitchToTab7: "タブ 7 に切り替え",
+    shortcutSwitchToTab8: "タブ 8 に切り替え",
+    shortcutSwitchToTab9: "タブ 9 に切り替え",
+    shortcutZoomInUi: "UIを拡大",
+    shortcutZoomOutUi: "UIを縮小",
+    shortcutResetUiZoom: "UIズームをリセット",
+    shortcutRefreshData: "データを更新",
+    shortcutToggleTranspose: "転置ビューを切替",
+    shortcutCancelSearch: "検索をキャンセル",
+    shortcutToggleSidebar: "サイドバーを切替",
+    shortcutCopySidebarSelection: "サイドバーの選択をコピー",
+    shortcutPasteSidebarSelection: "サイドバーに貼り付け",
+    shortcutEditSidebarConnection: "サイドバー接続を編集",
+    shortcutSendSelectionToAi: "選択範囲をAIに送信",
+    shortcutScopeGlobal: "グローバル",
+    shortcutScopeEditor: "SQLエディタ",
+    shortcutScopeGrid: "データグリッド",
+    shortcutScopeSearch: "フィールド検索",
+    shortcutScopeSidebar: "サイドバー",
+    shortcutPressShortcut: "ショートカットを押してください",
+    shortcutSearchPlaceholder: "ショートカットを検索",
+    shortcutSearchNoResults: "一致するショートカットはありません。",
+    shortcutConflict: "このショートカットは同じスコープ内の別のアクションと競合しています。",
+    shortcutClear: "ショートカットをクリア",
+    preview: "ライブプレビュー",
+    customTheme: "カスタムテーマ",
+    customThemeConfigure: "カスタムテーマを設定",
+    customThemeTitle: "カスタムテーマ設定",
+    customThemeMyThemes: "マイテーマ",
+    customThemeNewTheme: "新しいテーマ",
+    customThemeVisualEdit: "ビジュアルエディタ",
+    customThemeJsonConfig: "JSON設定",
+    customThemeLivePreview: "ライブプレビュー",
+    customThemePreviewExample: "-- クエリ例",
+    customThemePreset: "プリセットテーマ",
+    customThemeSelectPreset: "プリセットテーマを選択...",
+    customThemeApply: "適用",
+    customThemePasteImport: "貼り付けインポート",
+    customThemeExportJson: "JSONエクスポート",
+    customThemeSaveAndApply: "保存して適用",
+    customThemeKeyword: "キーワード",
+    customThemeField: "フィールド/変数",
+    customThemeFunction: "関数",
+    customThemeString: "文字列",
+    customThemeNumber: "数値",
+    customThemeComment: "コメント",
+    customThemeTable: "テーブル",
+    customThemeOperator: "演算子",
+    customThemeType: "タイプ",
+    customThemeBuiltin: "組み込み",
+    customThemeBackground: "背景",
+    customThemeForeground: "前景",
+    customThemeDefaultName: "カスタムテーマ",
+    customThemeCopySuffix: "コピー",
+    customThemeApplied: "配色テーマ「{name}」を適用しました",
+    customThemeKeepOne: "少なくとも1つのテーマを保持してください",
+    customThemeJsonError: "無効なJSON形式です。確認してください",
+    jdbcPlugin: "DBX JDBCプラグイン",
+    jdbcPluginInstall: "JDBCプラグインをインストール",
+    jdbcPluginInstallSuccess: "JDBCプラグインがインストールされました",
+    jdbcPluginUpdate: "更新",
+    jdbcPluginUninstall: "アンインストール",
+    jdbcPluginUninstallSuccess: "JDBCプラグインがアンインストールされました",
+    jdbcPluginInstalled: "インストール済み: v{version}",
+    jdbcPluginIncompatible: "互換性のないプロトコル",
+    jdbcPluginNotInstalled: "未インストール",
+    jdbcDrivers: "JDBCドライバーJAR",
+    jdbcImport: "JARをインポート",
+    jdbcImportPath: "インポートパス",
+    jdbcDriverPathPlaceholder: "/path/to/driver.jar",
+    jdbcImportSuccess: "{count}件のドライバーファイルをインポートしました",
+    jdbcDeleteSuccess: "ドライバーを削除しました",
+    jdbcNoDrivers: "まだJDBCドライバーがインポートされていません。",
+    mcpTitle: "MCPサーバー",
+    mcpDescription: "Claude Code、Cursor、その他のエージェントが使用するDBX MCPサーバーのインストールとバージョンを確認します。",
+    mcpChecking: "確認中",
+    mcpStatusUnknown: "未確認",
+    mcpStatusError: "確認失敗",
+    mcpReady: "準備完了",
+    mcpNotInstalled: "未インストール",
+    mcpUpdateAvailable: "アップデートがあります",
+    mcpCurrent: "現在のバージョン",
+    mcpLatest: "最新バージョン",
+    mcpVersionMissing: "グローバルインストールが検出されませんでした",
+    mcpVersionUnknown: "不明",
+    mcpAvailable: "利用可能",
+    mcpUnavailable: "利用不可",
+    mcpBinPath: "コマンドパス",
+    mcpInstallCommand: "インストールコマンド",
+    mcpUpdateCommand: "アップグレードコマンド",
+    mcpInstallButton: "インストール",
+    mcpUpdateButton: "アップグレード",
+    mcpUpToDate: "最新です",
+    mcpInstalling: "インストール中...",
+    mcpInstallSuccess: "インストール成功",
+    mcpInstallFailed: "インストール失敗",
+    mcpConfig: "MCP設定",
+    mcpConfigOptionsHint: "これらのオプションは下の生成設定だけを更新します。AIクライアントにコピーした後、MCPセッションを再起動してください。",
+    mcpCodexConfig: "Codex設定",
+    mcpCodexConfigPath: "Codexは ~/.codex/config.toml またはプロジェクトレベルの .codex/config.toml を使用できます。",
+    mcpCursorConfigPath: "Cursorはプロジェクトの .cursor/mcp.json またはグローバル ~/.cursor/mcp.json を使用できます。",
+    mcpTraeConfigPath: "TRAE: 設定 > MCP > 追加 > 手動で追加 からJSON設定を貼り付けます。",
+    mcpVsCodeConfigPath: "VS Code/Copilotはワークスペースの .vscode/mcp.json またはユーザープロファイルの mcp.json を使用できます。",
+    mcpWindsurfConfigPath: "Windsurfは ~/.codeium/windsurf/mcp_config.json を使用できます。",
+    mcpOpenCodeConfigPath: "グローバル ~/.config/opencode/opencode.json、プロジェクト opencode.json。",
+    mcpReadonlyMode: "読み取り専用モード",
+    mcpReadonlyModeDescription: "サンプル設定にDBX_MCP_ALLOW_WRITES=0を追加し、MCPセッションをクエリのみに制限します。",
+    mcpAllowDangerous: "危険なSQLを許可",
+    mcpAllowDangerousDescription: "サンプル設定にDBX_MCP_ALLOW_DANGEROUS_SQL=1を追加し、DROP、TRUNCATE、ALTERなどの文を許可します。",
+    mcpDetectionTiming: "このページを開くとDBXが自動的に確認します。更新するには再確認を使用してください。",
+    mcpNpmBoundary: "DBXはMCPステータスの確認と説明のみを行います。インストールとアップグレードはnpmを通じて実行されます。",
+    mcpRefresh: "再確認",
+    mcpGuide: "MCPガイド",
+    updateDownloadSource: "アップデートのダウンロード元",
+    updateDownloadSourceDescription: "アプリ内アップデートのインストーラーのダウンロード元を選択します。公式ソース推奨。中国本土ではCNBまたはAtomGitの方が高速な場合があります。",
+    updateDownloadSourceOfficial: "公式ソース（推奨）",
+    updateDownloadSourceCnb: "CNB",
+    updateDownloadSourceAtomgit: "AtomGit",
+    infiniteScroll: "無限スクロール読み込み",
+    autoCalculateTotalRows: "総行数を自動計算",
+    autoCalculateTotalRowsDescription: "クエリごとに COUNT(*) を自動実行し、一致する総行数を表示します。大きなクエリを高速に保つため既定はオフです。結果フッターから必要に応じて計算できます。",
+    infiniteScrollDescription: "テーブルのスクロール時に次のページのデータを自動読み込みします。",
+    infiniteScrollMaxRows: "無限スクロールの最大行数",
+    infiniteScrollMaxRowsDescription: "無限スクロールモードで読み込む最大行数（1000〜50000）。",
+    exportRowLimitEnabled: "エクスポート行数を制限",
+    exportRowLimitEnabledDescription: "有効時、クエリ結果とテーブルデータのエクスポートは以下の行数制限で停止します。",
+    exportRowLimit: "データエクスポートの行数制限",
+    exportRowLimitDescription: "クエリ結果とテーブルデータのエクスポートの最大行数。",
+    exportRowLimitUnlimited: "無制限",
+    queryExportKeysetOptimizationEnabled: "キーセット最適化を試行",
+    queryExportKeysetOptimizationEnabledDescription: "安全に認識された単一テーブルクエリにのみ適用。複雑なクエリは自動的にフォールバックします。",
+    supportInfoTitle: "サポート情報",
+    supportInfoDescription: "Issueの作成や問い合わせ時に、この環境情報をコピーできます。",
+    supportInfoCopy: "サポート情報をコピー",
+    supportInfoCopied: "コピーしました",
+    supportInfoLoading: "サポート情報を読み込み中...",
+    supportInfoLoadFailed: "完全なサポート情報の読み込みに失敗しました: {message}",
+    supportInfoAppVersion: "DBXバージョン",
+    supportInfoRuntime: "実行環境",
+    supportInfoRuntimeDesktop: "デスクトップ",
+    supportInfoRuntimeWeb: "Web",
+    supportInfoOperatingSystem: "オペレーティングシステム",
+    supportInfoArchitecture: "アーキテクチャ",
+    supportInfoUnknown: "不明",
+    community: "コミュニティ",
+    qqGroup: "QQグループ",
+    wechatGroup: "WeChatグループ",
+    wechatGroupInvite: "Tencent Docs招待",
+    project: "プロジェクト",
+    openSource: "オープンソースリポジトリ",
+    officialDocs: "公式ドキュメント",
+    shortcutUppercaseSelection: "選択範囲を大文字に変換",
+    shortcutLowercaseSelection: "選択範囲を小文字に変換",
+    shortcutExPasteSqlInCondition: "ExPaste: IN条件として貼り付け",
+  },
+  driverStore: {
+    progressJreExtract: "JREを展開中...",
+    progressDownloadJre: "JREをダウンロード中",
+    progressDownloadDriver: "ドライバーをダウンロード中",
+    progressDownloadJdbcPlugin: "JDBCプラグインをダウンロード中",
+    progressJdbcPluginExtract: "JDBCプラグインをインストール中...",
+    usageTitle: "ストレージ使用量",
+    usageTotal: "合計 {size}",
+    usageTotalLabel: "合計",
+    calculating: "計算中...",
+    usageManagedJre: "管理対象JRE",
+    usageAgentDrivers: "組み込みドライバーエージェント",
+    usageDownloadCache: "ダウンロードキャッシュ",
+    usageJdbcPlugin: "JDBCプラグイン",
+    usageJdbcDriverJars: "JDBCドライバーJAR",
+    clearDownloadCache: "キャッシュを削除",
+    downloadCacheClearSuccess: "ダウンロードキャッシュを削除しました",
+    downloadCacheClearFailed: "ダウンロードキャッシュの削除に失敗しました: {error}",
+    offlineDownloadHint: "エアギャップ環境の場合は、インターネット接続されたマシンでオフラインドライバーパッケージをダウンロードし、ここでインポートしてください。",
+    offlineDownloadLink: "オフラインドライバーダウンロード",
+    searchDrivers: "ドライバー名、タイプ、バージョンを検索...",
+    searchJdbcDrivers: "JDBCドライバー名またはパスを検索...",
+    jdbcMavenCoordinatePlaceholder: "Maven座標（例: org.postgresql:postgresql:42.7.7）",
+    jdbcMavenInstall: "Mavenからインストール",
+    jdbcMavenInstallSuccess: "JDBC Mavenドライバーをインストールしました",
+    jdbcSourceMaven: "Maven",
+    jdbcSourceManual: "手動",
+    noMatchingDrivers: "一致するドライバーがありません。",
+    javaRuntimeSaved: "Javaランタイム設定を保存しました",
+    javaRuntimeSaveFailed: "Javaランタイム設定の保存に失敗しました: {error}",
+    chooseJavaExecutable: "Java実行ファイルを選択",
+    driverInstallSuccess: "{label} ドライバーをインストールしました",
+    driverInstallFailed: "{label} ドライバーのインストールに失敗しました: {error}",
+    driverUpdateBlocked: "ドライバーを更新する前にこれらのデータベース接続を閉じてください: {labels}",
+    upgradeAllSuccess: "{count}件のドライバーをアップグレードしました",
+    upgradeAllPartial: "{count}件のドライバーをアップグレードしました。スキップ: {failed}",
+    upgradeAllFailed: "一括アップグレードに失敗しました: {error}",
+    driverUninstallSuccess: "{label} ドライバーをアンインストールしました",
+    driverUninstallFailed: "{label} ドライバーのアンインストールに失敗しました: {error}",
+    chooseOfflineDriverPackage: "オフラインドライバーパッケージを選択",
+    offlineImportSuccess: "オフラインインポートが完了しました。{count}件のドライバーをインストールしました。",
+    offlineImportFailed: "オフラインインポートに失敗しました: {error}",
+    driverImportSuccess: "{label} ドライバーをインポートしました",
+    driverImportFailed: "{label} ドライバーのインポートに失敗しました: {error}",
+    chooseDriverJar: "ドライバーJARファイルを選択",
+    jreReinstallSuccess: "JRE {jre} を再インストールしました",
+    jreReinstallFailed: "JRE {jre} の再インストールに失敗しました: {error}",
+    jreUninstallSuccess: "JRE {jre} をアンインストールしました",
+    chooseJdbcPluginZip: "JDBCプラグインzipファイルを選択",
+    agentDrivers: "組み込みドライバー",
+    jdbcDrivers: "JDBCドライバー",
+    importing: "インポート中...",
+    importOfflinePackage: "オフラインパッケージをインポート",
+    refresh: "更新",
+    javaRuntime: "Javaランタイム",
+    javaRuntimeManaged: "DBX管理JRE",
+    javaRuntimeSystem: "システムJava",
+    javaRuntimeCustom: "カスタムパス",
+    saving: "保存中...",
+    customJavaPathPlaceholder: "/path/to/java or /path/to/jdk",
+    choose: "選択",
+    systemJavaHint: "現在のPATHからJavaを使用します。",
+    jreRuntimeTitle: "JRE {jre} ランタイム",
+    notInstalled: "未インストール",
+    reinstalling: "再インストール中",
+    installing: "インストール中",
+    install: "インストール",
+    reinstall: "再インストール",
+    uninstall: "アンインストール",
+    jreRuntime: "JREランタイム",
+    jreRuntimeAutoDownloadHint: "初回ドライバーインストール時に自動ダウンロードされます",
+    driversUpdatable: "{count}件のドライバーを更新できます",
+    upgradingProgress: "アップグレード中 ({current}/{total})",
+    upgradeAll: "すべてアップグレード",
+    queued: "待機中",
+    importLocalJar: "ローカルJARをインポート",
+    updating: "更新中",
+    update: "更新",
+    localInstall: "ローカルインストール",
+    runtimeDrivers: "ランタイム",
+    storageTab: "ストレージ",
+    runtimeTitle: "ドライバーランタイム",
+    runtimeHint: "ランタイムメトリクスはこのパネルが開いている間のみ収集されます。",
+    runtimeRunning: "実行中",
+    runtimeMemory: "メモリ",
+    runtimeHealth: "状態",
+    runtimeHealth_healthy: "正常",
+    runtimeHealth_warning: "警告",
+    runtimeHealth_error: "エラー",
+    runtimeLastError: "最終エラー",
+    runtimeEmpty: "まだドライバーランタイムがありません。エージェント駆動接続を開いて開始してください。",
+    runtimeKindAgent: "エージェント",
+    runtimeKindPlugin: "プラグイン",
+    runtimeSourceDaemon: "デーモン",
+    runtimeSourceConnection: "接続",
+    runtimeStatus_running: "実行中",
+    runtimeStatus_stopped: "停止",
+    runtimeStatus_error: "エラー",
+    runtimeStatus_unknown: "不明",
+    runtimePid: "PID",
+    runtimeUptime: "稼働時間",
+    runtimeActions: "操作",
+    runtimeStop: "停止",
+    runtimeRestart: "再起動",
+    runtimeControlConnectionOwned: "このランタイムを停止するにはデータベース接続を閉じてください。",
+    runtimeStopSuccess: "{label} ランタイムを停止しました",
+    runtimeStopFailed: "{label} の停止に失敗しました: {error}",
+    runtimeRestartSuccess: "{label} ランタイムを再起動しました",
+    runtimeRestartFailed: "{label} の再起動に失敗しました: {error}",
+    driverStoreDir: "ドライバーストアパス",
+    driverStoreDirDescription: "JDBCプラグインとエージェント/JREデータの保存場所を個別に設定します。移行後にアプリは自動的に再起動します。",
+    pluginStoreDir: "JDBCプラグインディレクトリ",
+    pluginStoreDirDescription: "JDBCプラグイン、Mavenリゾルバー、JDBCドライバーJARを保存します。",
+    agentStoreDir: "エージェント / JREディレクトリ",
+    agentStoreDirDescription: "エージェントドライバーパッケージ、管理対象JRE、ランタイムキャッシュを保存します。",
+    driverStoreDirDefault: "デフォルト（インストールディレクトリ）",
+    driverStoreDirChange: "変更",
+    driverStoreDirReset: "デフォルトにリセット",
+    driverStoreDirMigrating: "{target}を移行中…",
+    driverStoreDirConfirm: "{target}を変更すると関連ドライバーデータが新しい場所に移行されます。移行中に関連ドライバー接続が切断される可能性があります。移行後にアプリは自動的に再起動します。続行しますか？",
+    driverStoreDirMigrationFailed: "ドライバーストアの移行に失敗しました: {error}",
+    driverStoreDirDialogTitle: "{target}を選択",
+    driverStoreDirSuccess: "{target}を変更しました。再起動中…",
+  },
+  databaseExport: {
+    runInBackground: "バックグラウンドで実行",
+    title: "データベースをエクスポート",
+    options: "オプション",
+    includeStructure: "テーブル構造 (DDL)",
+    dropTableIfExists: "DDLの前にDROP TABLE IF EXISTSを追加",
+    includeData: "テーブルデータ (INSERT)",
+    includeObjects: "ビュー / プロシージャ / 関数 / シーケンス",
+    databaseSelection: "データベース",
+    selectedDatabases: "{selected}/{total}件選択中",
+    selectAllDatabases: "すべて選択",
+    filterDatabases: "データベースを検索...",
+    clearDatabases: "クリア",
+    tableSelection: "テーブル",
+    selectedTables: "{selected}/{total}件選択中",
+    selectAllTables: "すべて選択",
+    filterTables: "テーブルを検索...",
+    clearTables: "クリア",
+    loadingTables: "テーブルを読み込み中...",
+    tableLoadError: "テーブルの読み込みに失敗しました: {error}",
+    noTables: "テーブルが見つかりません",
+    export: "エクスポート",
+    exportAllDatabases: "すべてのデータベースをエクスポート",
+    exporting: "エクスポート中...",
+    selectExportDirectory: "エクスポート先ディレクトリを選択",
+    currentDatabase: "データベース {current}/{total}",
+    currentTable: "現在: {table} ({current}/{total})",
+    rowsExported: "{count}行をエクスポートしました",
+    exportSuccess: "データベースを正常にエクスポートしました",
+    exportAllSuccess: "{count}個のデータベースを正常にエクスポートしました",
+    allDatabasesTask: "すべてのデータベース ({count})",
+    exportError: "エクスポートに失敗しました: {error}",
+    exportCancelled: "エクスポートがキャンセルされました",
+  },
+  nacos: {
+    configs: "設定",
+    services: "サービス",
+    raw: "Raw",
+    namespace: "名前空間",
+    dataId: "Data ID",
+    group: "Group",
+    format: "設定形式",
+    content: "設定内容",
+    tags: "タグ",
+    application: "アプリケーション",
+    description: "説明",
+    advanced: "詳細設定",
+    collapse: "閉じる",
+    load: "読み込み",
+    save: "保存",
+    saveAs: "別名で保存",
+    saving: "保存中...",
+    saved: "設定を保存しました",
+    createdAndLoaded: "{dataId}を作成して読み込みました",
+    savedAndLoaded: "{dataId}を保存して更新しました",
+    deleted: "設定を削除しました",
+    delete: "削除",
+    copy: "コピー",
+    copied: "コピーしました",
+    copyVerifyFailed: "クリップボード書き込み後の検証に失敗しました",
+    export: "エクスポート",
+    exported: "エクスポートしました",
+    exportedTo: "{path} にエクスポートしました",
+    exportFailed: "エクスポートに失敗しました: {message}",
+    history: "History",
+    configHistory: "Config history",
+    historyDetail: "History detail",
+    historyCompareTitle: "History Version Compare",
+    currentPublishedContent: "Current published content:",
+    historyVersionContent: "History version content:",
+    updatedAt: "Updated at",
+    operationType: "Operation",
+    operator: "Operator",
+    view: "View",
+    compare: "Compare",
+    rollback: "Rollback",
+    loadingHistory: "Loading history...",
+    noHistory: "No history versions",
+    noHistoryHint: "Refresh if this config was just published. Some Nacos versions may not expose history APIs.",
+    historyCreate: "Create",
+    historyUpdate: "Update",
+    historyDelete: "Delete",
+    historyRollback: "Rollback",
+    confirmRollbackTitle: "Rollback Nacos config",
+    confirmRollbackMessage: "This will roll the current config back to the selected history version.",
+    rollbackSuccess: "Config rolled back",
+    publish: "公開",
+    dataIdRequired: "Data ID は必須です",
+    allGroups: "すべてのグループ",
+    noConfigs: "設定がありません",
+    selectConfig: "設定を選択または作成",
+    noServices: "サービスがありません",
+    selectService: "サービスを選択",
+    service: "サービス",
+    instances: "インスタンス",
+    instanceCount: "{count}件のインスタンス",
+    refresh: "更新",
+    address: "アドレス",
+    cluster: "クラスター",
+    weight: "重み",
+    state: "状態",
+    actions: "操作",
+    query: "クエリ",
+    body: "本文",
+    response: "レスポンス",
+    template: "テンプレート",
+    configDiffTitle: "設定内容の比較",
+    inlineCompare: "行内比較",
+    currentVersionContent: "現在の正式バージョン：",
+    publishVersionContent: "今回の公開内容：",
+    confirmSaveTitle: "Nacos設定の変更を確認",
+    confirmSaveMessage: "この設定変更を保存しますか？ +{added} / -{removed} 行。",
+    confirmDeleteTitle: "Nacos設定を削除",
+    confirmDeleteMessage: "選択した設定をNacosから削除します。",
+    confirmInstanceTitle: "Nacosインスタンスを更新",
+    confirmInstanceMessage: "対象サービスインスタンスの状態を確認してください。",
+    confirmRawTitle: "変更系Raw APIリクエストを送信",
+    confirmRawMessage: "このRaw APIリクエストはNacos状態を変更する可能性があります。",
+    rawTemplate: {
+      serverState: "サーバー状態",
+      namespaceList: "名前空間一覧",
+      configDetail: "設定詳細",
+      serviceList: "サービス一覧",
+      instanceList: "インスタンス一覧",
+    },
+    healthy: "正常",
+    unhealthy: "異常",
+    enabled: "有効",
+    offline: "オフライン",
+    ephemeral: "一時",
+    persistent: "永続",
+    enable: "有効化",
+    disable: "無効化",
+    markHealthy: "正常にする",
+    markUnhealthy: "異常にする",
+    send: "送信",
+    total: "合計 {count} 件",
+    prev: "前へ",
+    next: "次へ",
+    test: "テスト",
+    readOnly: "読み取り専用",
+    createNamespace: "名前空間を作成",
+    editNamespace: "名前空間を編集",
+    creatingNamespace: "作成中...",
+    updatingNamespace: "更新中...",
+    namespaceCreated: "名前空間「{name}」を作成しました",
+    namespaceUpdated: "名前空間「{name}」を更新しました",
+    namespaceId: "名前空間ID",
+    namespaceIdPlaceholder: "空欄の場合はNacosが生成",
+    namespaceName: "名前空間名",
+    namespaceNamePlaceholder: "名前空間名を入力",
+    namespaceDesc: "説明",
+    namespaceDescPlaceholder: "デフォルトは名前空間名",
+  },
+  gridfsBrowser: {
+    bucketCount: "バケット",
+    fileCount: "ファイル",
+    name: "名前",
+    totalSize: "サイズ",
+    chunkSize: "チャンクサイズ",
+    uploadDate: "アップロード日",
+    contentType: "コンテンツタイプ",
+    metadata: "メタデータ",
+    selectBucket: "GridFS バケットを選択して表示または開きます。",
+    selectFile: "GridFS ファイルを選択して表示または管理します。",
+    emptyBuckets: "現在 GridFS バケットがありません。新しく作成できます。",
+    emptyFiles: "現在のバケットにはファイルがありません。アップロードできます。",
+    createBucket: "バケットを新規作成",
+    openBucket: "バケットを開く",
+    deleteBucket: "バケットを削除",
+    createTitle: "新規 GridFS バケット作成",
+    deleteTitle: "GridFS バケットの削除",
+    deleteMessage: "選択した GridFS バケットとその中のすべてのファイルを削除してもよろしいですか？",
+    bucketName: "バケット名",
+    bucketNamePlaceholder: "example_bucket",
+    bucketCreated: "バケット {bucket} を作成しました。",
+    bucketDeleted: "バケット {bucket} を削除しました。",
+    uploadFile: "ファイルをアップロード",
+    downloadFile: "ファイルをダウンロード",
+    downloadSelected: "選択項目をダウンロード",
+    deleteFile: "ファイルを削除",
+    selectedCount: "{count} 件選択",
+    deleteFileTitle: "GridFS ファイルの削除",
+    deleteFileMessage: "現在の GridFS バケットから選択したファイルを削除してもよろしいですか？",
+    fileUploaded: "{fileName} をアップロードしました。",
+    fileDeleted: "{fileName} を削除しました。",
+  },
+  extension: {
+    installTitle: "拡張機能のインストール",
+    manageTitle: "拡張機能の管理",
+    name: "拡張機能名",
+    namePlaceholder: "例: pg_stat_statements",
+    install: "インストール",
+    drop: "削除",
+    available: "利用可能な拡張機能",
+    installed: "インストール済み",
+    noAvailable: "すべての利用可能な拡張機能がインストールされています。",
+    noInstalled: "インストールされている拡張機能はありません。",
+  },
+  sqlFileTree: {
+    title: "SQL ファイル",
+    openFolder: "フォルダを開く",
+    closePanel: "閉じる",
+    loading: "読み込み中...",
+    noFolder: "フォルダが開かれていません",
+    noSqlFiles: "SQL ファイルが見つかりません",
+    folderAlreadyOpen: "このフォルダは既に開いています",
+    removeFolder: "フォルダを削除",
+    openFailed: "フォルダを開くのに失敗しました: {message}",
+    loadFailed: "SQL ファイルの読み込みに失敗しました: {message}",
+    desktopOnly: "この機能はデスクトップ版のみで利用可能です",
+    refreshFolder: "フォルダーをリフレッシュ",
+    refreshAll: "すべてをリフレッシュ",
+    refreshed: "リフレッシュ済み",
+    revealInFileManager: "ファイルマネージャーで表示",
+    revealFailed: "ファイルマネージャーを開けませんでした: {message}",
+    copyPath: "パスをコピー",
+    pathCopied: "パスをコピーしました",
+    copyFailed: "パスのコピーに失敗しました",
+    openFile: "開く",
+    executeSqlFile: "SQLファイルを実行",
+    expandAll: "すべて展開",
+    collapseAll: "すべて折りたたむ",
+  },
+  mqTopics: {
+    title: "トピック管理",
+    searchPlaceholder: "トピックを検索",
+    includeNonPersistent: "非永続トピックを含める",
+    refresh: "更新",
+    refreshing: "更新中...",
+    createTopic: "トピックを作成",
+    selectTenantNamespace: "テナントと名前空間を先に選択してください",
+    loading: "読み込み中...",
+    noTopics: "この名前空間にはトピックがありません",
+    noMatches: "一致するトピックはありません",
+    name: "名前",
+    type: "タイプ",
+    partitions: "パーティション",
+    actions: "操作",
+    nonPersistent: "非永続",
+    partitionedTopic: "パーティショントピック",
+    normalTopic: "通常トピック",
+    partitionCount: "{count} パーティション",
+    partitionsUnknown: "パーティション数不明",
+    adjustPartitions: "パーティションを調整",
+    delete: "削除",
+    tenantNamespace: "テナント / 名前空間",
+    topicName: "トピック名",
+    topicNamePlaceholder: "例: my-topic",
+    persistentRecommended: "永続トピック（推奨）",
+    persistentHint: "永続トピックはメッセージをディスクに保存しますが、非永続トピックはメモリのみに保存されます。",
+    enablePartitions: "パーティションを有効にする",
+    partitionQuantity: "パーティション数",
+    partitionHint: "パーティションは並列性パフォーマンスを向上させますが、リソース消費が増加します。",
+    cancel: "キャンセル",
+    create: "作成",
+    updatePartitionsTitle: "パーティション数の調整: {name}",
+    currentPartitions: "現在のパーティション数",
+    newPartitions: "新しいパーティション数",
+    partitionMinHint: "パーティション数は増やすことのみ可能で、減らすことはできません。最小値: {min}",
+    update: "更新",
+    readOnly: "現在の接続は読み取り専用モードです。書き込み操作は実行できません。",
+    topicNameRequired: "トピック名は必須です",
+    currentPartitionsUnknown: "現在のパーティション数が不明なため、安全にパーティションを調整できません。",
+    partitionMustIncrease: "新しいパーティション数は現在のパーティション数より大きくなければなりません。",
+    confirmDelete: "トピック「{name}」を削除してもよろしいですか？この操作は元に戻せません。",
+  },
+  production: {
+    title: "本番環境",
+    connection: "本番接続",
+    enable: "本番環境保護を有効にする",
+    disabledDescription: "有効にすると、すべてのデータベースまたは指定されたデータベースを保護するように選択できます。",
+    scope: "保護範囲",
+    allDatabases: "すべてのデータベース",
+    selectedDatabases: "データベースを選択",
+    singleDatabaseScopeHint: "このデータベースタイプでは、接続レベルの本番環境保護のみがサポートされています。",
+    databases: "本番データベース",
+    connectionDescription: "この接続上のすべてのデータベースで本番保護が有効になります。",
+    databaseDescription: "接続から本番保護が必要なデータベースを選択します。初回起動時はデフォルトで全選択されています。",
+    selectDatabases: "本番データベースを選択",
+    noDatabasesSelected: "まだ選択されていません",
+    databasesConfiguredCount: "{count} 個選択済み",
+    databasesSelectedCount: "{selected}/{total} 選択済み",
+    databasePickerTitle: "本番データベースを選択",
+    databasePickerDescription: "「{connection}」で本番保護が必要なデータベースを選択してください。",
+    databaseSearchPlaceholder: "データベースを検索...",
+    databaseSelectionRequired: "少なくとも1つのデータベースを選択してください。",
+    databaseLoadFailed: "データベースリストを読み込めませんでした：{message}",
+    noDatabasesAvailable: "選択可能なデータベースが見つかりません。",
+    retry: "再試行",
+    confirmTitle: "本番環境への書き込みを確認",
+    confirmMessage: "この操作は本番データベースを変更します。続行するには明示的な確認が必要です。",
+    confirmDetails: "接続：{connection}\nデータベース：{database}\nソース：{source}",
+    confirmAction: "本番環境で実行",
+    sourceSqlEditor: "SQL エディター",
+    sourceDataGrid: "データエディター",
+    sourceStructure: "構造エディター",
+    sourceSqlFile: "SQL ファイル実行",
+    sourceObjectBrowser: "オブジェクトブラウザー",
+    sourceSchemaDiff: "スキーマ差分",
+    sourceDataCompare: "データ比較",
+    sourceExtension: "拡張機能マネージャー",
+    sourceSidebar: "オブジェクトツリー",
+    sourceObjectSource: "オブジェクトソースエディター",
+    sourceDataGenerate: "データジェネレーター",
+    sourceQueryHistory: "クエリ履歴のロールバック",
+    sourceAdmin: "データベース管理",
+    aiReviewRequired: "本番SQLがエディターに配置されました。まず確認し、手動で実行して確定してください。",
+  },
+});
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
new file mode 100644
index 0000000..6a32db4
--- /dev/null
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -0,0 +1,3822 @@
+import { withEnglishFallback } from "./fallback";
+
+export default withEnglishFallback({
+  app: {
+    name: "DBX",
+  },
+  auth: {
+    setupTitle: "Configurar senha de acesso",
+    setupDescription: "Defina uma senha para proteger sua instância",
+    loginDescription: "Ferramenta de gerenciamento de banco de dados",
+    newPassword: "Digite a nova senha",
+    confirmPassword: "Confirmar senha",
+    enterPassword: "Digite a senha de acesso",
+    passwordMismatch: "As senhas não coincidem",
+    setPassword: "Definir Senha",
+    login: "Entrar",
+    processing: "Processando...",
+    loginFailed: "Senha incorreta",
+    connectFailed: "Falha na conexão",
+    changePassword: "Alterar Senha",
+    oldPassword: "Senha atual",
+    oldPasswordWrong: "A senha atual está incorreta",
+    passwordChanged: "Senha alterada com sucesso",
+    changePasswordFailed: "Falha ao alterar a senha",
+    changePasswordDescription: "Digite sua senha atual e escolha uma nova",
+  },
+  toolbar: {
+    newConnection: "Nova Conexão",
+    newQuery: "Nova Consulta",
+    execute: "Executar",
+    executeShortcut: "Executar seleção/consulta (Cmd+Enter)",
+    stopQuery: "Parar consulta",
+    explainPlan: "Explicar plano",
+    stopExplain: "Parar explicação",
+    formatSql: "Formatar SQL",
+    formatSqlFailed: "Falha ao formatar SQL",
+    keywordCaseLower: "Usar palavras-chave SQL em minúsculas",
+    keywordCaseUpper: "Usar palavras-chave SQL em maiúsculas",
+    autoCommit: "Auto Commit",
+    manualTransaction: "Transação Manual",
+    autoCommitAgent: "Auto Commit (depende do backend do Agente)",
+    manualTransactionAgent: "Transação Manual (depende do backend do Agente)",
+    commit: "Confirmar",
+    rollback: "Reverter",
+    txnAutoRolledBack: "Transação revertida automaticamente após 5 minutos de inatividade",
+    previewSql: "Visualizar SQL",
+    hidePreviewSql: "Ocultar Visualização SQL",
+    saveSql: "Salvar na Biblioteca SQL",
+    openSql: "Abrir arquivo SQL",
+    exPasteSqlInCondition: "ExPaste: colar como condição IN",
+    theme: "Tema",
+    themeLight: "Claro",
+    themeDark: "Escuro",
+    themeSystem: "Seguir o sistema",
+    sqlSaved: "SQL salvo",
+    sqlOpenFailed: "Falha ao abrir o arquivo: {message}",
+    sqlSaveFailed: "Falha ao salvar o arquivo: {message}",
+    driverManager: "Gerenciador de Drivers",
+    updatableDriverCount: "Quantidade de drivers atualizáveis",
+    blockDangerousRedisCommands: "Bloquear comandos perigosos",
+  },
+  updates: {
+    title: "Atualizações",
+    check: "Verificar atualizações",
+    availableTitle: "Atualização disponível",
+    availableMessage: "DBX {latest} está disponível. Você está usando {current}.",
+    upToDate: "O DBX está atualizado ({version}).",
+    failed: "Falha ao verificar atualizações: {error}",
+    rateLimited: "As verificações de atualização do GitHub estão temporariamente limitadas. Você ainda pode abrir a página de lançamento para verificar manualmente.",
+    openRelease: "Abrir Lançamento",
+    downloadAndInstall: "Baixar e Instalar",
+    portableManualUpdate: "Versões portáteis não podem usar o instalador interno. Baixe o ZIP portátil da página de lançamento e extraia-o sobre a pasta atual do DBX para manter o portable.dbx e os dados.",
+    downloading: "Baixando {progress}%",
+    downloadFailed: "Falha ao baixar a atualização: {error}",
+    restart: "Sair e Reiniciar",
+    restartFailed: "Falha ao reiniciar o aplicativo: {error}",
+    exitAndUpdate: "Sair e Atualizar",
+    dockerUsersRun: "Usuários do Docker devem executar",
+    toUpdate: "para atualizar",
+  },
+  sidebar: {
+    connections: "CONEXÕES",
+    noConnections: "Nenhuma conexão ainda",
+    import: "Importar Conexões",
+    importDbx: "Importar Configuração DBX",
+    importNavicat: "Importar Navicat NCX",
+    importDbeaver: "Importar DBeaver",
+    importDatagrip: "Importar DataGrip",
+    export: "Exportar Conexões",
+    collapseAll: "Recolher tudo",
+    collapse: "Recolher barra lateral",
+    expand: "Expandir barra lateral",
+    showMore: "Mostrar mais {count}...",
+    filterByType: "Filtrar por tipo",
+    searchScopeConnection: "Conexão",
+    searchScopeDatabase: "Banco de dados",
+    searchScopeSchema: "Schema",
+    searchScopeTable: "Tabela",
+    searchScopeView: "Visão",
+    searchTablesInCurrentScope: "Pesquisar tabelas neste banco...",
+    clearTableSearch: "Limpar busca de tabelas",
+    clearFilter: "Limpar filtro",
+    locateActiveTab: "Localizar na barra lateral",
+  },
+  savedSql: {
+    saveToLibrary: "Salvar na Biblioteca SQL",
+    saveToFile: "Salvar localmente",
+    save: "Salvar",
+    saved: "SQL salvo",
+    saveFailed: "Falha ao salvar SQL: {message}",
+    fileName: "Nome do arquivo",
+    folder: "Pasta",
+    rootFolder: "Biblioteca SQL",
+    newQuery: "Nova Consulta",
+    newFolder: "Nova Pasta SQL",
+    newFolderDefault: "Nova Pasta",
+    renameFolder: "Renomear Pasta",
+    deleteFolder: "Excluir Pasta",
+    deleteFolderConfirm: "Excluir “{name}” e os arquivos SQL dentro dela?",
+    open: "Abrir SQL",
+    renameFile: "Renomear SQL",
+    deleteFile: "Excluir SQL",
+    deleteFileConfirm: "Excluir “{name}”?",
+  },
+  sqlLibrary: {
+    title: "Biblioteca SQL",
+    empty: "Nenhuma consulta salva",
+    emptyFolder: "Pasta vazia",
+    unfiled: "Sem categoria",
+    exportFile: "Exportar SQL",
+    exportFolder: "Exportar pasta",
+    exportLibrary: "Exportar biblioteca SQL",
+    importDirectory: "Importar pasta local",
+    importIntoFolder: "Importar para esta pasta",
+    openStorageDirectory: "Abrir diretório de SQL",
+    chooseSyncDirectory: "Definir diretório de sincronização local",
+    disableSyncDirectory: "Desativar sincronização local",
+    syncDirectorySaved: "Diretório de sincronização local de SQL salvo",
+    syncDirectoryDisabled: "Sincronização local de SQL desativada",
+    syncDirectoryFailed: "Falha ao definir diretório de sincronização: {message}",
+    openDirectoryFailed: "Falha ao abrir diretório: {message}",
+    noSyncDirectory: "Defina um diretório de sincronização local primeiro",
+    exported: "Exportado",
+    exportFailed: "Falha na exportação: {message}",
+    importFailed: "Falha na importação: {message}",
+    importNone: "Nenhum arquivo .sql encontrado na pasta selecionada",
+    imported: "Importados {count} arquivos SQL",
+    desktopOnly: "Este recurso está disponível apenas no desktop",
+    noConnection: "Nenhuma conexão disponível para importar",
+    batchDelete: "Exclusão em lote",
+    batchDeleteConfirm: "Tem certeza de que deseja excluir {count} itens selecionados? Esta ação não pode ser desfeita.",
+    batchDeleteSuccess: "{count} itens excluídos com sucesso",
+    moveToFolder: "Mover para pasta...",
+    moveSelectedToFolder: "Mover {count} SQL para pasta...",
+    moveSuccess: "{count} SQL movidos",
+    clearSelection: "Limpar seleção",
+    sortByDate: "Ordenar por data de modificação",
+    sortByFolder: "Ordenar por estrutura de pastas",
+  },
+
+  connection: {
+    title: "Nova Conexão",
+    name: "Nome",
+    namePlaceholder: "Nome da conexão, gerado automaticamente se vazio",
+    type: "Tipo",
+    host: "Host",
+    filePath: "Caminho do Arquivo",
+    h2FileMode: "Arquivo",
+    h2TcpMode: "TCP",
+    h2FilePathRequired: "O caminho do arquivo H2 não pode ficar vazio",
+    createDuckDbFile: "Criar arquivo DuckDB",
+    createSqliteFile: "Criar banco de dados SQLite",
+    memoryDatabasePathHint: "Use :memory: para criar um banco de dados SQLite ou DuckDB na memória.",
+    sqliteCipherKey: "Chave SQLCipher",
+    sqliteCipherKeyPlaceholder: "Deixe vazio para SQLite não criptografado",
+    sqliteExtensions: "Extensões SQLite",
+    sqliteExtensionsPlaceholder: "/caminho/para/regexp.dylib\n/caminho/para/text.dylib|sqlite3_text_init",
+    sqliteExtensionsHint: "Um .dylib/.so/.dll por linha. Use “caminho|ponto de entrada” quando um ponto de entrada for necessário. Carregado ao conectar, depois load_extension é desabilitado.",
+    sqliteExtensionBrowse: "Selecionar extensão SQLite",
+    user: "Usuário",
+    password: "Senha",
+    database: "Banco de dados",
+    databasePlaceholder: "Opcional",
+    databasePlaceholderRequired: "Obrigatório, informe um banco de dados existente",
+    databasePlaceholderWithDefault: "Opcional, padrão é {database}",
+    kingbaseDatabaseRequired: "Kingbase exige um banco de dados existente antes de conectar ou carregar a lista de bancos de dados.",
+    defaultDatabase: "BD padrão",
+    authDatabase: "BD de autenticação",
+    authDatabasePlaceholder: "Opcional, geralmente admin",
+    authMechanism: "Mecanismo de Autenticação",
+    authMechanismDefault: "Padrão",
+    driverMode: "Driver",
+    mongoDriverAuto: "Automático",
+    mongoDriverLegacy: "Legacy",
+    serviceName: "Service/SID",
+    serviceNameOnly: "Service Name",
+    version: "Versão",
+    driverInstallHintPrefix: "Instale o driver necessário em ",
+    driverInstallHintSuffix: " na barra de ferramentas superior antes de conectar.",
+    driverName: "Nome do Driver",
+    driverNamePlaceholder: "Nome do fornecedor ou ambiente",
+    urlParams: "Parâmetros da URL",
+    d1AccountId: "ID da conta",
+    d1DatabaseId: "ID do banco de dados",
+    d1ApiToken: "Token da API",
+    d1TokenHint: "O token precisa de pelo menos a permissão D1 Read; gravações, DDL e importações também exigem D1 Write.",
+    d1FieldsRequired: "O ID da conta Cloudflare, o ID do banco de dados D1 e o token da API são obrigatórios.",
+    gbaseServer: "GBASEDBTSERVER",
+    informixServer: "INFORMIXSERVER",
+    sslEnable: "Habilitar conexão criptografada",
+    caCertPath: "Certificado CA",
+    caCertPathPlaceholder: "Opcional, ex.: ~/.yandex/RootCA.crt",
+    caCertPathBrowse: "Procurar certificado",
+    redisTlsInsecure: "Ignorar verificação de certificado",
+    redisTlsInsecureHint: "Equivalente a redis-cli --tls --insecure, para certificados autoassinados ou CAs privadas.",
+    mysqlTlsMode: "Modo TLS",
+    mysqlTlsModePreferred: "Preferencial",
+    mysqlTlsModeDisabled: "Desabilitado",
+    mysqlTlsModeRequired: "Obrigatório",
+    mysqlTlsModeVerifyCa: "Verificar CA",
+    mysqlTlsModeVerifyIdentity: "Verificar Identidade",
+    mysqlCleartextPasswordAuth: "Autenticação de senha em texto claro",
+    mysqlCleartextPasswordAuthHint: "Ative somente quando o servidor MySQL exigir o plugin de autenticação de senha em texto claro.",
+    mysqlCaCertHint: "Necessário para Verificar CA e Verificar Identidade quando o certificado do servidor usa uma CA privada.",
+    mysqlClientCert: "Autenticação do Cliente",
+    mysqlClientCertPlaceholder: "/caminho/para/client.crt",
+    mysqlClientKeyPlaceholder: "/caminho/para/client.key",
+    mysqlClientCertHint: "O certificado e a chave privada do cliente devem ser fornecidos juntos quando o MySQL exige mTLS.",
+    mysqlTlsConnectionFailureHint: "Se o servidor MySQL não exigir TLS, edite a conexão, defina o Modo TLS como Desabilitado e tente novamente.",
+    mysqlClientCertBrowse: "Escolher certificado do cliente",
+    mysqlClientKeyBrowse: "Escolher chave privada do cliente",
+    postgresSslMode: "Modo TLS",
+    postgresSslModeDisable: "Desabilitar",
+    postgresSslModePrefer: "Preferencial",
+    postgresSslModeRequire: "Obrigatório",
+    postgresSslModeVerifyCa: "Verificar CA",
+    postgresSslModeVerifyFull: "Verificar Completo",
+    postgresServerCert: "CA do Servidor",
+    postgresRootCertPlaceholder: "/caminho/para/ca.crt",
+    postgresRootCertHint: "Use isto para verify-ca ou verify-full quando o certificado do servidor é assinado por uma CA privada.",
+    postgresRootCertBrowse: "Escolher certificado CA",
+    postgresClientCert: "Autenticação do Cliente",
+    postgresClientCertPlaceholder: "/caminho/para/client.crt",
+    postgresClientKeyPlaceholder: "/caminho/para/client.key",
+    postgresClientCertHint: "O certificado e a chave privada do cliente devem ser fornecidos juntos quando o PostgreSQL exige mTLS.",
+    postgresClientCertBrowse: "Escolher certificado do cliente",
+    postgresClientKeyBrowse: "Escolher chave privada do cliente",
+    connectionUrlOptional: "URL (opcional)",
+    connectionUrlPlaceholder: "postgresql://user:pass{'@'}host:5432/db?sslmode=require",
+    parseConnectionUrl: "Analisar URL de conexão",
+    parseConnectionUrlApplied: "URL de conexão aplicada",
+    parseConnectionUrlFailed: "Falha ao analisar a URL de conexão: {message}",
+    mode: "Modo de Conexão",
+    modeForm: "Formulário",
+    redisStandaloneMode: "Standalone",
+    redisSentinelMode: "Sentinel",
+    redisClusterMode: "Cluster",
+    oceanbaseMySQLMode: "Modo MySQL",
+    oceanbaseOracleMode: "Modo Oracle",
+    redisFirstSentinel: "Primeiro Sentinel",
+    redisFirstClusterNode: "Primeiro Nó Semente",
+    redisSentinelNodes: "Nós Sentinel",
+    redisClusterNodes: "Nós Semente do Cluster",
+    redisSentinelMaster: "Nome do Master",
+    redisSentinelUser: "Usuário do Sentinel",
+    redisSentinelPassword: "Senha do Sentinel",
+    redisSentinelTls: "TLS do Sentinel",
+    redisSentinelTlsHint: "Usar TLS ao conectar aos nós Sentinel",
+    redisKeySeparator: "Separador de namespace de chave",
+    etcdEndpoints: "Endpoints",
+    etcdEndpointsHint: "Um endpoint por linha. Deixe em branco para usar o host e porta acima.",
+    etcdCaCertPlaceholder: "/caminho/para/ca.crt",
+    etcdCaCertBrowse: "Escolher certificado CA",
+    etcdClientAuth: "Autenticação do Cliente",
+    etcdClientCertPlaceholder: "/caminho/para/client.crt",
+    etcdClientKeyPlaceholder: "/caminho/para/client.key",
+    etcdClientCertHint: "O certificado e a chave privada do cliente devem ser fornecidos juntos quando o etcd exige mTLS.",
+    etcdClientCertBrowse: "Escolher certificado do cliente",
+    etcdClientKeyBrowse: "Escolher chave privada do cliente",
+    etcdClientCertPairRequired: "O certificado e a chave privada do cliente devem ser fornecidos juntos.",
+    zookeeperConnectString: "String de Conexão",
+    zookeeperConnectStringHint: "Entradas host:porta separadas por vírgula ou linha. Deixe em branco para usar o host e porta acima.",
+    zookeeperCreateModePersistent: "Persistente",
+    zookeeperCreateModeEphemeral: "Efêmero",
+    zookeeperCreateModePersistentSequential: "Persistente Sequencial",
+    zookeeperCreateModeEphemeralSequential: "Efêmero Sequencial",
+    nacosConsoleUrl: "URL do console",
+    nacosConsoleUrlHint: "Use o endereço do console/admin API do Nacos. O Nacos 3 Docker geralmente expõe o console em 8085; implantações antigas podem compartilhar 8848 com a porta de serviço.",
+    nacosConsoleUrlRequired: "A URL do console Nacos é obrigatória",
+    nacosConsoleUrlAutoAdjusted: "URL do console Nacos ajustada de {from} para {to}.",
+    nacosNamespace: "Namespace",
+    nacosContextPath: "Context Path",
+    nacosContextPathPlaceholder: "Deixe vazio ou /nacos",
+    nacosAuth: "Autenticação",
+    nacosAuthNone: "Nenhuma",
+    nacosAuthUserPassword: "Usuário / Senha",
+    nacosUsernameRequired: "O usuário Nacos é obrigatório",
+    nacosTls: "TLS",
+    nacosTlsSkipVerify: "Ignorar verificação do certificado",
+    nacosPageSize: "Tamanho da página",
+    searchDatabasePlaceholder: "Pesquisar tipos de banco de dados",
+    iconView: "Visualização em ícones",
+    listView: "Visualização em lista",
+    selectedDatabase: "Selecionado",
+    noDatabaseMatches: "Nenhum banco de dados correspondente",
+    next: "Próximo",
+    back: "Anterior",
+    basicTab: "Conexão",
+    tlsTab: "TLS/SSL",
+    test: "Testar",
+    testing: "Testando...",
+    copyTestResult: "Copiar resultado do teste",
+    sqlServerLegacyCompatibilityMode: "Modo de compatibilidade legado",
+    sqlServerLegacyCompatibilityModeEnable: "Usar conexão de compatibilidade legada do SQL Server",
+    sqlServerLegacyCompatibilityModeEnabled: "O modo de compatibilidade legado do SQL Server está ativado.",
+    sqlServerLegacyCompatibilityModeHint:
+      "Aplica-se a cenários sem criptografia, com criptografia apenas no login ou compatibilidade legada TLS 1.0. Se o componente de compatibilidade não estiver instalado, o DBX o instala antes de ativar este modo.\nQuando o fallback usa o componente de compatibilidade, alguns recursos nativos do SQL Server podem ficar indisponíveis.\nUse apenas em redes confiáveis, VPNs ou túneis SSH",
+    sqlServerLegacyCompatibilityComponent: "Componente de compatibilidade legada do SQL Server",
+    sqlServerLegacyCompatibilityComponentInstalling: "Instalando componente de compatibilidade legada do SQL Server...",
+    saveAndConnect: "Salvar e Conectar",
+    save: "Salvar",
+    editTitle: "Editar Conexão",
+    testSuccess: "Conexão bem-sucedida",
+    connecting: "Conectando a {name}...",
+    connectSuccess: "Conectado a {name}",
+    connectFailed: "Falha na conexão: {message}",
+    driverNotInstalled: "O driver {driver} não está instalado. Instale-o pelo Gerenciador de Drivers.",
+    jreNotInstalled: "O runtime JRE {jre} não está instalado. Instale-o pelo Gerenciador de Drivers.",
+    systemJavaNotFound: "O runtime Java do sistema não foi encontrado no PATH. Instale o Java ou escolha um executável Java personalizado.",
+    customJavaPathEmpty: "O caminho do runtime Java personalizado está vazio. Escolha um executável Java.",
+    agentJavaTooOld: "Este driver requer Java 21. Use o JRE 21 gerenciado pelo DBX ou selecione um executável Java 21 no Gerenciador de Drivers.",
+    agentDriverUpdateConnectionHint: "Há uma atualização de driver integrada disponível para esta conexão. A falha de conexão pode estar relacionada a um driver local desatualizado. Atualize o driver correspondente no Gerenciador de Drivers e tente novamente.",
+    jdbcPluginNotInstalled: "O plugin JDBC não está instalado. Instale o plugin JDBC opcional para usar esta conexão.",
+    lastError: "Erro de conexão",
+    clearError: "Limpar erro de conexão",
+    saveFailed: "Falha ao salvar a conexão: {message}",
+    deleted: "Conexão excluída",
+    deletedSelected: "{count} conexões excluídas",
+    copied: "Copiado",
+    disconnected: "Desconectado",
+    databaseConnectionClosed: "Conexão de banco de dados fechada: {name}",
+    duplicated: "Conexão duplicada",
+    duplicatedSelected: "{count} conexões duplicadas",
+    groupDeleted: "Grupo excluído",
+    loadFailed: "Falha ao carregar as conexões salvas: {message}",
+    sshTunnel: "Túnel SSH / Proxy",
+    advancedTab: "Avançado",
+    sshEnable: "Usar túnel SSH / proxy",
+    sshHost: "Host SSH",
+    sshHostPlaceholder: "ssh.example.com ou um alias de ~/.ssh/config",
+    sshUser: "Usuário SSH",
+    sshAuthMethod: "Método de login",
+    sshAuthMethodPassword: "Senha",
+    sshAuthMethodKey: "Chave privada",
+    sshAuthMethodNone: "Nenhum",
+    sshAuthMethodNoneHint: "Nenhuma credencial será enviada. Use para bastiões ou proxies que aceitam conexões sem autenticação.",
+    sshAuthMethodAgentLegacy: "SSH Agent (legado)",
+    sshPassword: "Senha SSH",
+    sshPasswordPlaceholder: "Deixe vazio para usar a chave",
+    sshKeyPath: "Caminho da Chave",
+    sshKeyPassphrase: "Frase-senha da Chave",
+    sshKeyPassphrasePlaceholder: "Deixe vazio se a chave não estiver criptografada",
+    sshKeyPathBrowse: "Procurar",
+    sshExposeLan: "Expor túnel à LAN",
+    sshConnectTimeout: "Timeout SSH (segundos)",
+    sshHops: "Camadas de túnel SSH / proxy",
+    sshHopAdd: "Adicionar camada SSH",
+    sshHopDuplicate: "Duplicar",
+    sshHopDelete: "Excluir",
+    sshHopMoveUp: "Mover para cima",
+    sshHopMoveDown: "Mover para baixo",
+    sshHopName: "Nome da Camada",
+    sshHopNamePlaceholder: "Bastion, host de salto, gateway de produção",
+    sshHopDefaultName: "Camada {index}",
+    sshHopInvalidHost: "{hop}: o host SSH é obrigatório",
+    sshHopInvalidUser: "{hop}: o usuário SSH é obrigatório",
+    sshHopInvalidPort: "{hop}: a porta SSH deve estar entre 1 e 65535",
+    sshHopInvalidAuth: "{hop}: senha, caminho da chave ou ssh-agent é obrigatório",
+    sshUseAgent: "Usar ssh-agent",
+    sshAgentSockPath: "Caminho do socket do agente",
+    sshAgentSockPathPlaceholder: "ex. ~/.ssh/agent.sock",
+    sshHopInvalidTimeout: "{hop}: o timeout SSH deve estar entre 1 e 300 segundos",
+    connectTimeout: "Timeout de Conexão (segundos)",
+    queryTimeout: "Timeout de Consulta (segundos)",
+    idleTimeout: "Timeout de Inatividade (segundos)",
+    keepaliveInterval: "Intervalo de keepalive (segundos)",
+    readOnly: "Somente leitura",
+    readOnlyHint: "Bloquear todas as operações de escrita (INSERT, UPDATE, DELETE, etc.)",
+    readOnlyBadge: "Somente leitura",
+    proxy: "Proxy",
+    proxyEnable: "Conectar ao banco de dados via proxy",
+    proxyType: "Tipo de Proxy",
+    proxyHost: "Host do Proxy",
+    proxyUsername: "Usuário do Proxy",
+    proxyUsernamePlaceholder: "Opcional",
+    proxyPassword: "Senha do Proxy",
+    proxyPasswordPlaceholder: "Opcional",
+    tunnelProfile: "Perfil de túnel",
+    tunnelProfileCustom: "Personalizado (somente esta conexão)",
+    tunnelProfileManaged: "Gerenciado por um perfil de túnel compartilhado. Edite-o em Configurações > Túneis; as alterações se aplicam a todas as conexões que o usam na próxima conexão.",
+    tunnelProfileMissing: "O perfil de túnel referenciado não existe mais. Selecione outro perfil ou mude para personalizado.",
+    tunnelProfileMissingName: "Perfil de túnel ausente",
+    tunnelProfileManage: "Gerenciar",
+    dremioArrowFlightSqlMode: "Arrow Flight SQL",
+    dremioLegacyJdbcMode: "JDBC legado",
+    jdbcUrl: "URL JDBC",
+    jdbcUrlPlaceholder: "jdbc:postgresql://localhost:5432/database",
+    jdbcDriverClass: "Classe do Driver (opcional)",
+    jdbcDriverClassPlaceholder: "A maioria dos drivers se registra automaticamente; use com.vendor.jdbc.Driver se necessário",
+    jdbcDriverPaths: "JARs do Driver",
+    jdbcDriverSelectPlaceholder: "Escolher driver importado",
+    jdbcManualClasspath: "Classpath manual",
+    jdbcManualClasspathCount: "{count} caminhos",
+    jdbcDriverPathsPlaceholder: "/caminho/para/driver.jar\n/caminho/para/outro-driver.jar",
+    jdbcDriverBrowse: "Escolher JAR do driver JDBC",
+    jdbcDocs: "Ver documentação JDBC",
+    jdbcPluginHint: "Instale primeiro o plugin JDBC do DBX e depois importe o JAR do driver JDBC do fornecedor do banco de dados.",
+    dmCompatHint: "Requer o driver ODBC DM8 instalado no seu sistema.",
+    dmDownload: "Baixar da Dameng",
+    mongoLegacyHint: "Use Legacy para servidores MongoDB antigos, especialmente versões anteriores à 4.2. Se a autenticação falhar e o usuário foi criado em admin, defina o BD de autenticação como admin.",
+    mongoTlsAllowInvalidCertificates: "Desativar verificação de certificado TLS",
+    mongoTlsAllowInvalidCertificatesHint: "Corresponde a tlsAllowInvalidCertificates=true e desativa toda a validação de certificados, não apenas a do hostname. Aumenta o risco de MITM. Geralmente é necessário para AWS DocumentDB via túnel SSH.",
+    mongoRetryWrites: "Repetir gravações",
+    mongoRetryWritesHint: "Corresponde a retryWrites. Desative para AWS DocumentDB, que não suporta gravações repetíveis.",
+    compatible: "Compatível",
+    mainstream: "Popular",
+    color: "Cor",
+    colorNone: "Sem cor",
+    colorGreen: "Verde",
+    colorYellow: "Amarelo",
+    colorOrange: "Laranja",
+    colorRed: "Vermelho",
+    colorBlue: "Azul",
+    colorPurple: "Roxo",
+    colorCustom: "Cor personalizada",
+    cancelConnecting: "Cancelar conexão",
+    connectCancelled: "Conexão cancelada",
+    kafkaKerberosPrincipal: "Principal",
+    kafkaKerberosKeytab: "Keytab",
+    kafkaKerberosServiceName: "Nome do serviço",
+    kafkaKerberosKrb5Conf: "krb5.conf",
+    kafkaKerberosPrincipalRequired: "O principal do Kafka Kerberos não pode estar vazio",
+    kafkaKerberosKeytabRequired: "O caminho do keytab do Kafka Kerberos não pode estar vazio",
+    kafkaKerberosKeytabBrowse: "Escolher Keytab",
+    kafkaKerberosKrb5ConfBrowse: "Escolher krb5.conf",
+    kafkaKerberosKeytabPlaceholder: "Caminho na máquina do DBX Agent, por exemplo /etc/security/keytabs/user.keytab",
+    kafkaKerberosKrb5ConfPlaceholder: "Opcional, caminho na máquina do DBX Agent, por exemplo /etc/krb5.conf",
+    kafkaKerberosPathHint: "Os caminhos do keytab e do krb5.conf são lidos pelo DBX Agent e devem existir na máquina onde o DBX Agent é executado; os arquivos não são enviados do navegador atual.",
+    kafkaKerberosAuthHint: "Faça login usando GSSAPI + keytab. Se o servidor exigir transmissão criptografada, defina Security como SASL_SSL; caso contrário, você pode usar Auto ou SASL_PLAINTEXT.",
+  },
+  editor: {
+    pressToExecute: "Pressione {mod}+Enter para executar",
+    pressToSaveSql: "Pressione {mod}+S para salvar o SQL",
+    queryTimeoutError: "A consulta expirou ({seconds}s). Verifique se a conexão com o banco de dados está saudável.",
+    changeQueryTimeout: "Alterar tempo limite da consulta",
+    connectionMayBeLost: "A conexão pode ter sido perdida. Atualize os dados e tente novamente.",
+    showResultsPane: "Mostrar resultados",
+    hideResultsPane: "Ocultar resultados",
+    noDatabase: "Nenhum banco de dados selecionado",
+    unsavedChangesTitle: "Alterações não salvas",
+    unsavedChangesMessage: '"{title}" tem alterações não salvas que serão perdidas se fechada. Salvar antes de fechar?',
+    unsavedChangesBatchCloseMessage: "Algumas abas que você está fechando têm alterações não salvas que serão perdidas. Salvar antes de continuar?",
+    unsavedChangesBatchCloseMultipleMessage: '{count} abas SQL que você está fechando têm alterações não salvas. O DBX está mostrando "{title}" no momento. Salvar antes de continuar?',
+    unsavedChangesAppCloseMessage: '"{title}" tem alterações SQL não salvas que serão perdidas se você sair do DBX. Salvar antes de sair?',
+    unsavedChangesAppCloseMultipleMessage: '{count} abas SQL têm alterações não salvas. O DBX está mostrando "{title}" no momento. Serão perdidas se você sair do DBX. Salvar antes de sair?',
+    unsavedChangesViewList: "Ver {count} abas",
+    unsavedChangesListTitle: "Abas não salvas ({count})",
+    discardChanges: "Descartar",
+    discardAllChanges: "Descartar tudo",
+    saveAllChanges: "Salvar tudo",
+    selectConnection: "Selecionar conexão",
+    searchConnection: "Pesquisar conexões...",
+    selectDatabase: "Selecionar banco de dados",
+    selectDatabaseRequired: "Selecione um banco de dados primeiro",
+    searchDatabase: "Pesquisar bancos de dados...",
+    selectSchema: "Selecionar schema",
+    searchSchema: "Pesquisar schemas...",
+    setDefaultDatabase: "Definir Padrão",
+    defaultDatabase: "Padrão",
+    clearDatabase: "Limpar banco de dados",
+    exPasteNoValues: "A área de transferência não contém valores para uma condição IN",
+    exPasteNotList: "Nenhuma lista de múltiplos valores conversível foi detectada",
+    exPasteTooLarge: "O conteúdo da área de transferência é grande demais. Máximo de {limit} caracteres.",
+    exPasteTooManyValues: "Valores demais. Máximo de {limit}.",
+    exPasteClipboardReadFailed: "Falha ao ler a área de transferência: {message}",
+    exPastePasted: "{count} valores de condição IN colados",
+    completion: {
+      nullValue: "Valor NULL",
+      isNull: "Verificar se é NULL",
+      isNotNull: "Verificar se não é NULL",
+      stringLiteral: "Literal de string",
+      numericLiteral: "Literal numérico",
+      booleanValue: "Valor booleano",
+      starExpansionColumns: "{count} colunas",
+      functionDescriptions: {
+        COUNT: "Retorna o número de linhas",
+        SUM: "Retorna a soma de uma coluna numérica",
+        AVG: "Retorna a média de uma coluna numérica",
+        MIN: "Retorna o valor mínimo",
+        MAX: "Retorna o valor máximo",
+        GROUP_CONCAT: "Concatena valores de grupo em uma string",
+        STRING_AGG: "Concatena strings de grupo",
+        CONCAT: "Concatena múltiplas strings",
+        CONCAT_WS: "Concatena strings com separador",
+        SUBSTRING: "Extrai uma substring",
+        REPLACE: "Substitui conteúdo em uma string",
+        TRIM: "Remove espaços no início e no fim",
+        UPPER: "Converte para maiúsculas",
+        LOWER: "Converte para minúsculas",
+        LENGTH: "Retorna o comprimento da string",
+        REGEXP_REPLACE: "Substitui usando uma expressão regular",
+        DATE_FORMAT: "Formata uma data com o formato informado",
+        DATEDIFF: "Calcula a diferença entre duas datas",
+        DATE_ADD: "Adiciona um intervalo a uma data",
+        DATE_SUB: "Subtrai um intervalo de uma data",
+        EXTRACT: "Extrai uma parte da data",
+        NOW: "Retorna a data e hora atuais",
+        ROUND: "Arredonda para o número de casas decimais especificado",
+        FLOOR: "Arredonda para baixo",
+        CEIL: "Arredonda para cima",
+        ABS: "Retorna o valor absoluto",
+        MOD: "Retorna o resto da divisão",
+        COALESCE: "Retorna o primeiro argumento não NULL",
+        IFNULL: "Retorna um valor de substituição se for NULL",
+        NULLIF: "Retorna NULL se os argumentos forem iguais",
+        CAST: "Converte uma expressão para um tipo de destino",
+        JSON_EXTRACT: "Extrai um valor de um JSON",
+        JSON_VALUE: "Extrai um valor escalar de um JSON",
+        JSON_OBJECT: "Cria um objeto JSON",
+        JSON_ARRAY: "Cria um array JSON",
+      },
+    },
+    contextMenu: {
+      executeSelection: "Executar seleção",
+      executeCurrent: "Executar SQL",
+      copySelection: "Copiar seleção",
+      sendToAi: "Enviar para IA",
+      uppercaseSelection: "Converter para maiúsculas",
+      lowercaseSelection: "Converter para minúsculas",
+      selectAll: "Selecionar tudo",
+    },
+    search: {
+      find: "Localizar",
+      replace: "Substituir",
+      replaceAll: "Substituir Tudo",
+      caseSensitive: "Diferenciar maiúsculas/minúsculas",
+      regex: "Expressão regular",
+      collapseReplace: "Recolher substituição",
+      expandReplace: "Expandir substituição",
+      prevMatch: "Anterior (Shift+Enter)",
+      nextMatch: "Próximo (Enter)",
+      close: "Fechar (Esc)",
+      noResults: "Nenhum resultado",
+    },
+    executionPicker: {
+      title: "Execution Target",
+      currentStatement: "Current SQL",
+      allStatements: "All SQL",
+      currentCommand: "Current command",
+      allCommands: "All commands",
+    },
+  },
+  tabs: {
+    sql: "SQL",
+    table: "Tabela",
+    tableData: "Dados da Tabela",
+    redis: "Redis",
+    etcd: "etcd",
+    zookeeper: "ZooKeeper",
+    mongo: "Mongo",
+    vector: "Vector",
+    objects: "Objetos",
+    users: "Usuários e Privilégios",
+    executionSummary: "Resumo",
+    tooltipTitle: "Título:",
+    tooltipFilePath: "Caminho do arquivo:",
+    tooltipConnection: "Conexão:",
+    tooltipDatabase: "Banco de dados:",
+    tooltipTable: "Tabela:",
+    tooltipCollection: "Coleção:",
+    tooltipSchema: "Schema:",
+    resultN: "Resultado {n}",
+    runN: "Executar {n}",
+    resultRuns: "Execuções de resultado",
+    removeRun: "Remover execução {n}",
+    autoKeepResults: "Manter resultados automaticamente",
+    autoKeepResultsEnabled: "Manutenção automática de resultados ativada",
+    autoKeepResultsDisabled: "Manutenção automática de resultados desativada",
+    autoRefresh: "Atualizar resultados automaticamente",
+    autoRefreshShort: "Auto",
+    autoRefreshEvery: "Atualizar a cada {seconds} s",
+    startAutoRefresh: "Iniciar atualização automática",
+    stopAutoRefresh: "Parar atualização automática",
+    missingResultRun: "Este resultado não está mais disponível",
+    exportResultArchive: "Salvar Arquivo de Resultados",
+    importResultArchive: "Importar Arquivo de Resultados",
+    importedResultArchive: "Resultados importados",
+    resultArchiveExported: "Resultados exportados",
+    resultArchiveImported: "Resultados importados",
+    resultArchiveUnavailable: "Nenhum resultado salvo disponível para exportar",
+    resultArchiveImportInvalid: "Este arquivo de resultados não pôde ser aberto",
+    resultArchiveExportFailed: "Falha ao exportar resultados: {message}",
+    resultArchiveImportFailed: "Falha ao importar resultados: {message}",
+    scrollLeft: "Rolar abas para a esquerda",
+    scrollRight: "Rolar abas para a direita",
+    openTabs: "Abas abertas",
+    fixedTabs: "Abas fixadas",
+    openDataTabs: "Tabelas abertas",
+    gridfs: "GridFS",
+  },
+  executionSummary: {
+    empty: "Nenhum resumo",
+    executing: "Executando...",
+    statement: "Instrução",
+    type: "Tipo",
+    rows: "Linhas",
+    affected: "Afetadas",
+    time: "Tempo",
+    success: "Sucesso",
+    error: "Erro",
+    returnedTable: "Retornou uma tabela de resultado com {count} colunas",
+    noTable: "Nenhuma tabela de resultado retornada",
+  },
+  chart: {
+    title: "Gráfico",
+    type: "Tipo",
+    line: "Linha",
+    bar: "Barra",
+    pie: "Pizza",
+    noNumericData: "Nenhum dado numérico disponível para gerar o gráfico",
+  },
+  grid: {
+    rows: "{count} linhas",
+    totalRows: "Total de {count} linhas",
+    totalRowCount: "({count} no total)",
+    totalRowCountLoading: "(contando...)",
+    loadingMore: "Carregando mais dados...",
+    allLoaded: "tudo carregado",
+    calculateTotalRows: "Contar total de linhas",
+    calculateTotalRowsInline: "(contar total de linhas)",
+    calculateTotalRowsFailed: "Falha ao contar: {message}",
+    rowsAffected: "{count} linhas afetadas",
+    querySuccess: "Consulta executada com sucesso",
+    noRows: "Sem dados",
+    noRowsDescription: "Este conjunto de resultados não possui registros.",
+    noSearchResults: "Nenhuma correspondência",
+    noSearchResultsDescription: "Tente uma palavra-chave diferente.",
+    noFilteredRows: "Nenhuma linha corresponde ao filtro",
+    noFilteredRowsDescription: "Ajuste o texto de pesquisa ou o filtro de status das linhas.",
+    copy: "Copiar",
+    mongoJsonPreview: "Visualização JSON",
+    mongoJsonPreviewEmpty: "Selecione um documento MongoDB para visualizar.",
+    copyJson: "Copiar JSON",
+    copyDdl: "Copiar DDL",
+    copyCell: "Copiar Célula",
+    copyRow: "Copiar Linha (JSON)",
+    copyColumnJson: "Copiar Coluna (JSON)",
+    copyColumnNames: "Copiar Nomes das Colunas",
+    copyRowInsert: "Copiar como INSERT",
+    copyRowInsertWithoutPrimaryKeys: "Copiar como INSERT sem Chaves Primárias",
+    copyRowUpdate: "Copiar como UPDATE",
+    copyAll: "Copiar Tudo (TSV)",
+    selection: "Seleção",
+    selectionSum: "SUM: {value}",
+    selectionCells: "{count} células",
+    copySelectionTsv: "Copiar Seleção (TSV)",
+    copySelectionTsvWithHeaders: "Copiar Seleção com Cabeçalhos (TSV)",
+    copySelectionCsv: "Copiar Seleção (CSV)",
+    copySelectionJson: "Copiar Seleção (JSON)",
+    copySelectionSql: "Copiar Seleção como Lista IN do SQL",
+    clearSelection: "Limpar Seleção",
+    export: "Exportar",
+    exportCsv: "Exportar CSV",
+    exportXlsx: "Exportar XLSX",
+    exportCurrentPageCsv: "Exportar página atual como CSV",
+    exportCurrentPageXlsx: "Exportar página atual como XLSX",
+    exportCurrentPageJson: "Exportar página atual como JSON",
+    exportCurrentPageMarkdown: "Exportar página atual como Markdown",
+    exportCurrentPageSql: "Exportar página atual como SQL INSERT",
+    exportCurrentResultCsv: "Exportar todos os dados do resultado atual como CSV",
+    exportCurrentResultXlsx: "Exportar todos os dados do resultado atual como XLSX",
+    exportCurrentResultJson: "Exportar todos os dados do resultado atual como JSON",
+    exportCurrentResultMarkdown: "Exportar todos os dados do resultado atual como Markdown",
+    exportCurrentResultSql: "Exportar todos os dados do resultado atual como SQL INSERT",
+    exportAllResultsXlsx: "Exportar todos os conjuntos de resultados desta execução como XLSX",
+    exportJson: "Exportar JSON",
+    exportMarkdown: "Exportar Markdown",
+    exportSql: "Exportar SQL INSERT",
+    exportSelectedRowsCsv: "Exportar Linhas Selecionadas como CSV",
+    exportSelectedRowsXlsx: "Exportar Linhas Selecionadas como XLSX",
+    exportSelectedRowsJson: "Exportar Linhas Selecionadas como JSON",
+    exportSelectedRowsMarkdown: "Exportar Linhas Selecionadas como Markdown",
+    exportSelectedRowsSql: "Exportar Linhas Selecionadas como SQL INSERT",
+    exported: "Exportado",
+    exportFailed: "Falha na exportação: {message}",
+    copied: "Copiado",
+    copyFailed: "Falha ao copiar: {message}",
+    previewSqlEmpty: "Nenhuma alteração SQL pendente para visualizar",
+    renderMode: "Modo de renderização",
+    domRenderMode: "DOM",
+    canvasRenderMode: "Canvas",
+    renderModeHint: "Alterne entre a renderização Canvas e a grade DOM alternativa.",
+    tableFontSize: "Tamanho da fonte da tabela",
+    filter: "Filtrar",
+    conditionHistoryEmpty: "Sem histórico ainda",
+    conditionHistoryNoMatches: "Sem histórico correspondente",
+    filterBuilder: "Filtros",
+    filterBuilderTitle: "Filtros",
+    filterBuilderHint: "Crie condições com cliques e combine-as com a entrada WHERE.",
+    filterBuilderSummary: "{count} regras",
+    filterBuilderAddRule: "Adicionar regra",
+    filterBuilderColumn: "Coluna",
+    filterBuilderValue: "Valor",
+    filterBuilderNoValue: "Nenhum valor necessário",
+    filterBuilderEmpty: "Adicione uma regra para começar a filtrar linhas.",
+    resetFilterBuilder: "Redefinir regras",
+    filterBuilderEquals: "Igual a",
+    filterBuilderNotEquals: "Diferente de",
+    filterBuilderContains: "Contém",
+    filterBuilderNotContains: "Não contém",
+    filterBuilderGreaterThan: "Maior que",
+    filterBuilderLessThan: "Menor que",
+    filterBuilderIsNull: "É NULL",
+    filterBuilderIsNotNull: "Não é NULL",
+    columnActions: "Ações da coluna",
+    localFilter: "Filtro local de valores",
+    localFilterFor: "Valores locais para '{column}'",
+    databaseValueFilter: "Filtro de valores do banco de dados",
+    databaseValueFilterFor: "Valores do banco de dados para '{column}'",
+    columnFormatter: "Formatador de coluna",
+    columnFormatterFor: "Formatador para '{column}'",
+    columnFormatterHint: "Formata apenas a exibição; os valores brutos permanecem inalterados.",
+    formatterType: "Tipo",
+    formatterDatetime: "Timestamp Unix",
+    formatterJsonPath: "Caminho JSON",
+    formatterMask: "Mascarar texto",
+    formatterCustomTemplate: "Template personalizado",
+    formatterTimestampUnit: "Unidade do timestamp",
+    formatterUnitAuto: "Automático",
+    formatterUnitSeconds: "Segundos",
+    formatterUnitMilliseconds: "Milissegundos",
+    formatterDatetimePattern: "Formato de data e horário",
+    formatterDatetimePatternPlaceholder: "Selecione ou insira um formato de data e horário",
+    formatterDatetimePatternEmpty: "Padrão ISO8601",
+    formatterJsonPathInput: "Caminho JSON",
+    formatterMaskPrefix: "Prefixo visível",
+    formatterMaskSuffix: "Sufixo visível",
+    formatterSavedCustom: "Templates salvos",
+    formatterNewCustom: "Novo template",
+    formatterCustomName: "Nome do template",
+    formatterCustomNamePlaceholder: "Exemplo: Rótulo do usuário",
+    formatterCustomTemplateInput: "Template",
+    formatterCustomTemplateHint: "Variáveis disponíveis: ${value}, ${upper}, ${lower}, ${length}. Dê um nome para salvá-lo na lista.",
+    formatterPreview: "Visualização",
+    saveFormatter: "Salvar",
+    clearFormatter: "Limpar",
+    searchValues: "Pesquisar valores...",
+    loadingValues: "Carregando valores...",
+    serverValuesLimited: "Mostrando os primeiros {count} valores",
+    filterTypedValue: "Usar '{value}'",
+    value: "Valor",
+    count: "Contagem",
+    applyFilter: "Aplicar Filtro",
+    clearLocalFilters: "Limpar filtros locais de valores",
+    clearLocalFiltersShort: "Limpar local",
+    localFiltersActive: "{count} filtros locais de valores",
+    localFilterMoreValues: " +{count} mais",
+    columnVisibility: "Colunas",
+    columnVisibilityHint: "Pelo menos uma coluna permanece visível.",
+    searchColumns: "Pesquisar colunas...",
+    dragColumnToReorder: "Arraste o cabeçalho para reordenar",
+    invertColumnVisibility: "Inverter",
+    resetColumnOrder: "Redefinir ordem",
+    showAllColumns: "Mostrar todas",
+    viewOptions: "Opções de visualização",
+    hideNullColumns: "Ocultar NULL",
+    hideNullColumnsHint: "Alterna colunas cujos valores são todos NULL no resultado atual.",
+    moreValues: "Mais {count} valores, continue digitando para refinar os resultados",
+    filterByValue: "Filtrar Por Este Valor",
+    filterExcludeValue: "Excluir Este Valor",
+    filterLike: "Contém o Valor",
+    filterNotLike: "Não Contém",
+    filterLessThan: "Menor Que o Valor",
+    filterGreaterThan: "Maior Que o Valor",
+    filterIsNull: "Mostrar Valores NULL",
+    filterIsNotNull: "Mostrar Valores Não NULL",
+    clearFilter: "Limpar Filtro",
+    sort: "Ordenar",
+    sortAscending: "Ordenar de Forma Crescente",
+    sortDescending: "Ordenar de Forma Decrescente",
+    sortCurrentPageAscending: "Ordenar Página Atual Crescente",
+    sortCurrentPageDescending: "Ordenar Página Atual Decrescente",
+    sortDatabaseAscending: "Ordenar Banco de Dados Crescente",
+    sortDatabaseDescending: "Ordenar Banco de Dados Decrescente",
+    clearSort: "Limpar Ordenação",
+    pasted: "Colado!",
+    search: "Pesquisar...",
+    searchOrWhere: "Pesquise, ou insira uma cláusula WHERE...",
+    applyWhere: "Aplicar WHERE",
+    filterRows: "Filtrar linhas",
+    filterAllRows: "Todas as linhas",
+    filterChangedRows: "Alteradas",
+    page: "Página {page}",
+    rowsPerPage: "Linhas por página",
+    customRowsPerPage: "Linhas personalizadas",
+    applyPageSize: "Aplicar",
+    save: "Salvar",
+    discard: "Descartar",
+    dismiss: "Dispensar",
+    addRow: "Adicionar Linha",
+    quickEntryDraftPlaceholder: "Nova",
+    cloneRow: "Clonar como Nova Linha",
+    deleteRow: "Excluir Linha",
+    deleteRows: "Excluir {count} Linhas",
+    cloneRows: "Clonar {count} como Novas Linhas",
+    restoreRows: "Restaurar {count} Linhas",
+    copyRows: "Copiar {count} Linhas (JSON)",
+    copySelectedRowsTsv: "Copiar {count} Linhas (TSV)",
+    copySelectedRowsTsvWithHeaders: "Copiar {count} Linhas com Cabeçalhos (TSV)",
+    copySelectedRowTsv: "Copiar 1 Linha (TSV)",
+    copySelectedRowTsvWithHeaders: "Copiar 1 Linha com Cabeçalhos (TSV)",
+    copyColumnsJson: "Copiar {count} Colunas (JSON)",
+    copyRowsInsert: "Copiar {count} Linhas como INSERT",
+    copyRowsInsertMerged: "Copiar {count} Linhas como INSERT (mesclado)",
+    copyRowsInsertRowByRow: "Copiar {count} Linhas como INSERT (linha por linha)",
+    copyRowsInsertWithoutPrimaryKeys: "Copiar {count} Linhas como INSERT sem Chaves Primárias",
+    copyRowsInsertWithoutPrimaryKeysMerged: "Copiar {count} Linhas como INSERT sem Chaves Primárias (mesclado)",
+    copyRowsInsertWithoutPrimaryKeysRowByRow: "Copiar {count} Linhas como INSERT sem Chaves Primárias (linha por linha)",
+    copyRowsUpdate: "Copiar {count} Linhas como UPDATE",
+    selectedRows: "{count} linhas selecionadas",
+    restoreRow: "Restaurar Linha",
+    statusClean: "Sem alterações",
+    statusNew: "Itens Novos",
+    statusEdited: "Itens Atualizados",
+    statusDeleted: "Itens Excluídos",
+    pendingChanges: "{count} pendentes",
+    selectedCells: "{count} selecionadas",
+    bulkEditSelection: "Edição em Massa da Seleção",
+    bulkEditTitle: "Edição em Massa da Seleção",
+    bulkEditDescription: "Definir {count} célula(s) selecionada(s) para este valor.",
+    bulkEditValuePlaceholder: "Valor, ou NULL",
+    applyBulkEdit: "Aplicar",
+    cellDetails: "Detalhes da Célula",
+    cellDetailLayoutBottom: "Mover para Baixo",
+    cellDetailLayoutRight: "Mover para a Direita",
+    openCellDetailsDialog: "Abrir Detalhes da Célula",
+    rowDetails: "Detalhes da Linha",
+    rowDetailsFor: "Detalhes da Linha {row}",
+    openRowDetailsDialog: "Abrir Detalhes da Linha",
+    openColumnDetailsDialog: "Abrir Detalhes da Coluna",
+    columnDetailsFor: "Detalhes da Coluna {column}",
+    columnsCount: "{count} colunas",
+    rowCount: "Linhas",
+    rowsCount: "{count} linhas",
+    fieldIndex: "Nº",
+    cellValue: "Valor",
+    valueEditor: "Editor de Valor",
+    hexViewer: "Visualizador Hex",
+    hexViewerByteCount: "{count} bytes",
+    hexViewerOffset: "Offset",
+    hexViewerHex: "Hex",
+    hexViewerAscii: "ASCII",
+    hexViewerEmpty: "Nenhum byte binário para exibir.",
+    imagePreview: "Visualização de Imagem",
+    imageLoadFailed: "Falha ao carregar a imagem",
+    geometryPreview: "Visualização de Geometria",
+    layerPreview: "Visualização de Camada",
+    zoomIn: "Aproximar",
+    zoomOut: "Afastar",
+    fitImage: "Ajustar à Visualização",
+    openImage: "Abrir Imagem",
+    columnName: "Coluna",
+    columnType: "Tipo",
+    columnComment: "Comentário",
+    rowNumber: "Linha",
+    valueLength: "Comprimento",
+    nullValue: "NULL",
+    noComment: "Sem comentário",
+    formattedJson: "JSON Formatado",
+    formattedValue: "Valor Formatado",
+    detailSearchPlaceholder: "Buscar campo ou valor…",
+    detailSearchNoMatch: "Nenhuma correspondência",
+    rawValue: "Valor Bruto",
+    largeValuePreviewHint: "Visualizando os primeiros {count} caracteres. A cópia ainda usa o valor completo.",
+    copyValue: "Copiar Valor",
+    downloadBinaryValue: "Baixar Valor",
+    downloadSaved: "Salvo em {path}",
+    downloadStarted: "Download iniciado: {fileName}",
+    binaryDownload: {
+      binary: "Binário bruto",
+      utf8: "Texto decodificado (UTF-8)",
+      gbk: "Texto decodificado (GBK)",
+    },
+    copyRowTsv: "Copiar Linha (TSV)",
+    copyColumnValues: "Copiar Coluna (JSON)",
+    copyColumnTsv: "Copiar Coluna (TSV)",
+    editValue: "Editar Valor",
+    formatJson: "Formatar JSON",
+    compactJson: "Compactar JSON",
+    formattedJsonEditWarning: "Você está editando JSON formatado. Ao salvar, ele será gravado como JSON, então a formatação original pode mudar.",
+    setNull: "Definir NULL",
+    restoreOriginalValue: "Restaurar Original",
+    copyColumnName: "Copiar Nome da Coluna",
+    copyAlterColumnSql: "Copiar como SQL ALTER",
+    alterSqlCopied: "SQL ALTER copiado para a área de transferência",
+    alterSqlCopiedWithWarnings: "SQL ALTER copiado para a área de transferência ({count} aviso(s))",
+    noAlterSqlAvailable: "Nenhum SQL ALTER disponível para esta coluna",
+    copyAlterSqlFailed: "Falha ao copiar: {message}",
+    copySqlCondition: "Copiar Condição SQL",
+    transpose: "Transpor Linha",
+    transposeMultiRowToggle: "Várias linhas",
+    transposeSingleRow: "Linha atual",
+    transposeMultiRow: "Várias linhas",
+    transposeMultiRowHint: "Quando ativado, a visualização transposta mostra várias linhas. Quando desativado, mostra apenas a linha atual.",
+    rowsPerPageShort: " linhas",
+    columnDetails: "Detalhes da Coluna",
+    tableInfo: "Informações da Tabela",
+    tableInfoColumns: "Colunas",
+    tableInfoIndexes: "Índices",
+    tableInfoForeignKeys: "Chaves Estrangeiras",
+    tableInfoTriggers: "Gatilhos",
+    tableInfoNullable: "Permite Nulo",
+    tableInfoEmpty: "Sem metadados",
+    tableInfoSearch: "Pesquisar...",
+    tableInfoNoResults: "Nenhum resultado",
+    goToColumn: "Ir para a coluna",
+    columnWidth: "Largura da coluna",
+    columnWidthCompact: "Compacto",
+    columnWidthStandard: "Padrão",
+    columnWidthComfortable: "Amplo",
+    searchColumn: "Buscar coluna/comentário...",
+    noColumnsFound: "Nenhuma coluna encontrada",
+    queryError: "Erro na Consulta",
+    dataUnavailable: "Os dados da tabela precisam ser recarregados.",
+    dataUnavailableHintPrefix: "Pressione ",
+    dataUnavailableHintSuffix: " ou clique em Atualizar abaixo para recarregar.",
+    refresh: "Atualizar",
+    undoChange: "Desfazer alteração",
+    redoChange: "Refazer alteração",
+    commit: "Confirmar",
+    rollback: "Reverter",
+    transactionSaveHint: "Confirmar {count} alteração(ões) pendente(s) em uma transação.",
+    nonTransactionalSaveHint: "Salvar {count} alteração(ões) pendente(s) uma a uma. Se uma falhar, as alterações bem-sucedidas anteriores não serão revertidas.",
+    keylessEditWarning: "Sem chave primária",
+    keylessEditWarningHint: "Esta tabela não possui chave primária. Atualizações e exclusões usam todos os valores originais da linha na cláusula WHERE; linhas exatamente duplicadas podem ser afetadas juntas.",
+    queryEditReadOnly: "Resultado somente leitura",
+    queryEditUnsupported: {
+      "not-select": "Apenas resultados de consultas SELECT podem ser editados diretamente.",
+      cte: "Consultas com WITH/CTE ainda não são editáveis. Use um SELECT simples de tabela única.",
+      "set-operation": "Resultados de UNION, INTERSECT ou EXCEPT não podem ser mapeados com segurança de volta às linhas de origem.",
+      aggregation: "Resultados de DISTINCT, GROUP BY, HAVING e agregações não podem ser editados diretamente.",
+      "external-source": "Arquivos externos e resultados de funções de tabela não podem ser gravados de volta diretamente. Importe-os para uma tabela do banco de dados antes de editar.",
+      "complex-source": "O DBX não conseguiu identificar exatamente uma tabela de destino segura para gravar este resultado.",
+      "computed-columns": "Expressões computadas ou resultados de funções não podem ser gravados de volta. Selecione os nomes brutos das colunas em vez disso.",
+      "no-table": "Nenhuma tabela de origem editável foi detectada.",
+      "no-primary-key": "A tabela de destino não possui chave primária, portanto as linhas não podem ser atualizadas ou excluídas com segurança.",
+      "primary-key-not-returned": "O resultado está sem a coluna bruta da chave primária. Inclua-a pelo seu nome de coluna original.",
+      "aliased-columns": "As colunas do resultado usam aliases ou expressões. Selecione colunas editáveis pelos seus nomes originais.",
+      "metadata-unavailable": "O DBX não conseguiu carregar os metadados da tabela, portanto a edição do resultado está desabilitada.",
+    },
+    sortUnsupported: "Este SQL não suporta a ordenação do resultado completo. Tente novamente com uma única consulta SELECT.",
+    truncatedHint: "Resultados truncados em {count} linhas. Use a paginação no rodapé ou ajuste as linhas por página.",
+    filterBuilderSearchColumns: "Pesquisar campos...",
+    filterBuilderNoMatchingColumns: "Nenhum campo correspondente",
+  },
+  exportProgress: {
+    title: "Exportando Dados da Tabela",
+    fetching: "Buscando dados do banco de dados...",
+    writing: "Gravando no arquivo...",
+    done: "Exportação concluída!",
+    error: "Falha na exportação",
+    cancelled: "Exportação cancelada.",
+    rowsCount: "{exported} / {total} linhas",
+    rowsExported: "{count} linhas exportadas",
+    rowsShort: "linhas",
+    cancel: "Cancelar",
+    close: "Fechar",
+    tooltip: "Progresso da Exportação",
+    failedTooltip: "{count} tarefa em segundo plano falhou | {count} tarefas em segundo plano falharam",
+    popoverTitle: "Exportações",
+    noTasks: "Nenhuma exportação",
+    clearFinished: "Limpar concluídas",
+    showMore: "Mostrar mais {count}",
+    showLess: "Mostrar menos",
+    delete: "Remover",
+    databaseExportTitle: "Backup de banco de dados: {name}",
+    sqlFileTitle: "Arquivo SQL: {name}",
+    dataTransferTitle: "Transferência de dados: {name}",
+    objectsCount: "{current} / {total} objetos",
+    tablesCount: "{current} / {total} tabelas",
+    statementsCount: "{done} com sucesso, {failed} com falha",
+  },
+  welcome: {
+    title: "Área de Trabalho do Banco de Dados",
+    subtitle: "Escolha uma conexão à esquerda para navegar pelo schema ou abra uma aba de consulta diretamente.",
+    connections: "Conexões",
+    connected: "Conectado",
+    databaseTypes: "Tipos de Banco de Dados",
+    quickConnections: "Início Rápido",
+    quickConnectionsHint: "Clique em uma conexão para abrir uma aba de consulta.",
+    shortcuts: "Atalhos",
+    shortcutsHint: "Inicie a próxima ação a partir daqui.",
+    sqlHistory: "Histórico de Consultas",
+    sqlHistoryEmpty: "Nenhum registro da Biblioteca SQL ainda",
+    sqlHistoryOpenCount: "Aberto {count} vezes",
+    unknownConnection: "Conexão desconhecida",
+    tip: "Você também pode expandir as conexões à esquerda e clicar com o botão direito em bancos de dados ou tabelas para mais ações.",
+    tipSidebar: "Clique em uma tabela à esquerda para visualizar os dados",
+    tipExecute: "para executar a consulta",
+    fileOpened: "{name} aberto",
+    mcpTitle: "Integração com Agente de IA",
+    mcpDescription: "Além do assistente de IA integrado, você também pode usar Claude Code, Cursor e outros agentes de codificação para consultar seus bancos de dados via MCP.",
+    mcpLearnMore: "Saiba mais",
+  },
+  common: {
+    language: "Idioma",
+    loading: "Carregando...",
+    stopping: "Parando...",
+    close: "Fechar",
+    cancel: "Cancelar",
+    save: "Salvar",
+    retry: "Tentar novamente",
+    more: "Mais",
+    decrease: "Diminuir",
+    increase: "Aumentar",
+    showPassword: "Mostrar senha",
+    hidePassword: "Ocultar senha",
+    done: "Concluído",
+    copy: "Copiar",
+    import: "Importar",
+    remove: "Remover",
+    connection: "Conexão",
+    database: "Banco de dados",
+    table: "Tabela",
+    view: "Visualização",
+    materializedView: "Visualização Materializada",
+    procedure: "Procedimento",
+    function: "Função",
+    sequence: "Sequência",
+    package: "Pacote",
+    packageBody: "Corpo do Pacote",
+    noResults: "Sem resultados",
+  },
+  quickOpen: {
+    placeholder: "Pesquisar conexões, bancos de dados, tabelas e outros objetos...",
+    emptyPlaceholder: "Comece a digitar para pesquisar",
+    noResults: "Nenhum resultado encontrado",
+    results: "resultados",
+    navigate: "Navegar",
+    select: "Selecionar",
+    close: "Fechar",
+  },
+  explain: {
+    title: "Plano de Execução",
+    standardTable: "Tabela",
+    tree: "Árvore",
+    summary: "Resumo",
+    running: "Lendo plano de execução...",
+    empty: "Nenhum plano de execução",
+    nodeCount: "{count} nós",
+    node: "Nó",
+    relation: "Tabela",
+    index: "Índice",
+    cost: "Custo",
+    rows: "Linhas",
+    details: "Detalhes",
+    unsupported: "O plano de execução ainda não é suportado para este banco de dados",
+    emptySql: "Nenhum SQL para explicar",
+    unsafe: "Esta primeira versão explica apenas instruções SELECT / WITH / TABLE / VALUES",
+  },
+  lineage: {
+    title: "Linhagem de Campo",
+    open: "Visualizar Linhagem de Campo",
+    loading: "Lendo metadados {done}/{total}",
+    empty: "Nenhuma linhagem relacionada encontrada",
+    noFiltered: "Nenhum resultado corresponde aos filtros atuais",
+    targetField: "Campo Atual",
+    searchPlaceholder: "Pesquisar tabelas, campos, visões ou trechos de SQL...",
+    showing: "Mostrando {shown}/{total} resultados",
+    all: "Todos",
+    certain: "Certo",
+    likely: "Provável",
+    possible: "Possível",
+    queryHistory: "Histórico de Consultas",
+    openTable: "Abrir tabela",
+    copy: "Copiar nome",
+    copied: "Copiado",
+    kind: {
+      foreignKey: "Chave Estrangeira",
+      viewReference: "Visão",
+      historyReference: "Histórico de SQL",
+      sameName: "Mesmo Nome",
+    },
+    description: {
+      foreignKeyIncoming: "{target} aponta para o campo atual através de uma chave estrangeira. Esta é uma dependência verificada.",
+      foreignKeyOutgoing: "O campo atual referencia {target} através de uma chave estrangeira. Esta é uma dependência verificada.",
+      viewLikely: "A definição da visão menciona tanto a tabela quanto o campo de destino, geralmente indicando dependência de consulta.",
+      viewPossible: "A definição da visão menciona um campo de mesmo nome, mas não a tabela de destino, então precisa de confirmação.",
+      historyLikely: "Uma instrução SQL histórica menciona tanto a tabela quanto o campo de destino. Use-a como contexto de análise de impacto.",
+      historyPossible: "Uma instrução SQL histórica menciona um campo de mesmo nome. Pode estar relacionado, mas precisa de contexto.",
+      sameName: "Outra tabela possui um campo de mesmo nome. Isso pode compartilhar significado de negócio, mas não é uma dependência verificada do banco de dados.",
+    },
+    cancel: "Cancelar",
+    refresh: "Analisar Novamente",
+  },
+  connectionGroup: {
+    createGroup: "Novo Grupo",
+    groupNamePlaceholder: "Nome do grupo",
+    renameGroup: "Renomear Grupo",
+    deleteGroup: "Excluir Grupo",
+    moveToGroup: "Mover para Grupo",
+    moveToNewGroup: "Mover para Novo Grupo",
+    ungrouped: "Sem grupo",
+    newGroup: "Novo Grupo...",
+    newGroupDefault: "Novo Grupo",
+    deleteGroupConfirmTitle: "Excluir Grupo",
+    deleteGroupConfirmMessage: 'Excluir o grupo "{name}"? As conexões dentro dele serão movidas para o nível superior.',
+    selectConnection: "Selecionar conexão",
+    deselectConnection: "Desmarcar conexão",
+    selectAllConnections: "Selecionar todas as conexões",
+    deselectAllConnections: "Desmarcar todas as conexões",
+    exitMultiSelect: "Sair da seleção múltipla",
+  },
+  databaseSearch: {
+    title: "Pesquisar no Banco de Dados",
+    open: "Pesquisar no Banco de Dados",
+    keyword: "Palavra-chave",
+    keywordPlaceholder: "Digite um ID de usuário, e-mail, número de pedido...",
+    limitPerTable: "Por tabela",
+    search: "Pesquisar",
+    searching: "Pesquisando",
+    stop: "Parar",
+    hint: "Verifica tabelas comuns no banco de dados ou schema atual. Colunas binárias são ignoradas e cada tabela é limitada para evitar carregar dados em excesso de uma só vez.",
+    loadingTables: "Lendo lista de tabelas...",
+    progress: "{done}/{total} tabelas verificadas",
+    resultCount: "{count} correspondências",
+    limitedTables: "Schema grande detectado; apenas as primeiras {count} tabelas são verificadas",
+    results: "Resultados",
+    openResult: "Abrir",
+    waiting: "Aguardando correspondências...",
+    noResults: "Nenhuma correspondência ainda",
+    errors: "Algumas tabelas falharam",
+  },
+  configExport: {
+    passphraseTitle: "Criptografar e Exportar",
+    passphraseImportTitle: "Descriptografar e Importar",
+    passphraseExportHint: "Para incluir as senhas de conexão na exportação, defina uma frase secreta para a criptografia. Você precisará da mesma frase secreta para importar.",
+    passphraseImportHint: "Este arquivo está criptografado. Digite a frase secreta para descriptografar e importar.",
+    passphrase: "Frase secreta",
+    passphraseConfirm: "Confirmar Frase Secreta",
+    passphrasePlaceholder: "Digite a frase secreta",
+    passphraseConfirmPlaceholder: "Digite novamente a frase secreta",
+    passphraseRequired: "A frase secreta é obrigatória",
+    passphraseMismatch: "As frases secretas não coincidem",
+    passphraseTooShort: "A frase secreta deve ter pelo menos 4 caracteres",
+    exportEncrypted: "Exportar",
+    decryptImport: "Descriptografar e Importar",
+    wrongPassphrase: "Frase secreta incorreta ou arquivo corrompido",
+    cryptoUnavailable: "A importação criptografada não está disponível neste contexto do navegador. Use HTTPS, localhost ou DBX Desktop.",
+    exportSuccess: "Conexões exportadas com sucesso",
+    importSuccess: "{count} conexão(ões) importada(s)",
+    importNavicatSuccess: "{count} conexão(ões) do Navicat importada(s). Preencha qualquer conexão cuja senha ainda esteja vazia antes de testar.",
+    importDatagripSuccess: "{count} conexão(ões) DataGrip importada(s), {filled} senha(s) preenchida(s) do Keychain.",
+    importDbeaverSuccess: "{count} conexão(ões) do DBeaver importada(s). Preencha qualquer conexão cuja senha ainda esteja vazia antes de testar.",
+    importNone: "Nenhuma conexão nova para importar",
+    importLayoutConfirm: "O arquivo importado contém grupos de conexões. Aplicá-los?",
+    importLayoutTitle: "Importar Grupos",
+    importLayoutApply: "Aplicar",
+  },
+  ai: {
+    placeholder: "Descreva sua consulta em linguagem natural...",
+    settings: "Configurações de AI",
+    noConfig: "A AI não está configurada. Configure seu provedor de AI em Configurações > AI.",
+    provider: "Provedor",
+    providerStatusActive: "Ativo",
+    providerStatusConfigured: "Configurado",
+    switchProvider: "Trocar provedor",
+    model: "Modelo",
+    browseModels: "Explorar modelos",
+    refreshModels: "Atualizar modelos",
+    loadingModels: "Carregando modelos...",
+    searchModels: "Pesquisar modelos",
+    noModels: "Nenhum modelo carregado",
+    modelListHint: "Clique em atualizar para carregar os modelos do provedor.",
+    modelListUnsupported: "Este provedor não oferece suporte à obtenção de uma lista de modelos.",
+    modelListEndpointRequired: "Informe um endpoint antes de carregar os modelos.",
+    modelListApiKeyRequired: "Informe uma API key antes de carregar os modelos.",
+    codexMcpRequiredTitle: "DBX MCP Server obrigatório",
+    codexMcpRequiredDescription: "O Codex CLI usa o DBX MCP Server para acessar o schema do banco e as ferramentas de consulta. Instale-o antes de usar o Codex no assistente de AI.",
+    codexCliPath: "Caminho do Codex CLI",
+    codexCliPathHint: "Deixe vazio para usar o codex do PATH. Faça login separadamente com codex login.",
+    codexCliPathEnvError: "Codex CLI Path deve conter apenas o caminho do executável. Adicione variáveis de ambiente abaixo.",
+    codexCliEnv: "Variáveis de ambiente",
+    codexCliEnvAdd: "Adicionar variável",
+    codexCliEnvHint: "Variáveis opcionais passadas ao Codex CLI, como HTTPS_PROXY, NO_PROXY, SSL_CERT_FILE ou CODEX_CA_CERTIFICATE.",
+    codexCliEnvKeyPlaceholder: "HTTPS_PROXY",
+    codexCliEnvValuePlaceholder: "http://proxy:9800",
+    codexCliEnvInvalidName: "Nome de variável de ambiente inválido: {name}",
+    codexCliEnvReservedName: "{name} é gerenciada pelo DBX para o MCP Server e não pode ser definida aqui.",
+    reasoningLevel: "Nível de raciocínio",
+    reasoningLevelDefault: "Padrão",
+    reasoningLevelMinimal: "Mínimo",
+    reasoningLevelLow: "Baixo",
+    reasoningLevelMedium: "Médio",
+    reasoningLevelHigh: "Alto",
+    reasoningLevelHint: "Controla model_reasoning_effort do Codex CLI. Padrão usa sua configuração do Codex.",
+    run: "Executar",
+    readingSchema: "Lendo schema",
+    noConnection: "Nenhuma conexão disponível para esta aba",
+    noSql: "Nenhum SQL para processar",
+    sqlPreview: "Pré-visualização do SQL",
+    copySql: "Copiar SQL",
+    copyCode: "Copiar Código",
+    executeSql: "Executar SQL",
+    tempRunSql: "Executar sem modificar",
+    copyAll: "Copiar Tudo",
+    copied: "Copiado",
+    copyTestResult: "Copiar resultado do teste",
+    replace: "Substituir Editor",
+    append: "Anexar ao Editor",
+    apply: "Aplicar ao Editor",
+    clear: "Limpar Conversa",
+    welcome: "Diga o que você gostaria de consultar e eu escreverei o SQL",
+    newChat: "Nova Conversa",
+    thinking: "Pensando...",
+    reasoningProcess: "Processo de raciocínio",
+    stopGenerating: "Parar geração",
+    scrollToBottom: "Voltar ao fim",
+    tableMentionEmpty: "Nenhuma tabela ou arquivo SQL correspondente",
+    tableMentionPlaceholderHint: "Digite {'@'} para mencionar tabelas ou arquivos SQL como contexto",
+    tableMentionTypes: {
+      table: "Tabela",
+      view: "Visão",
+      systemTable: "Tabela do sistema",
+      temporaryTable: "Tabela temporária",
+    },
+    modes: {
+      ask: "Perguntar",
+      agent: "Agente",
+    },
+    modeHints: {
+      ask: "Gera SQL e explicações sem executá-los automaticamente",
+      agent: "Executa automaticamente consultas seguras quando possível",
+    },
+    fixWithAi: "Corrigir com AI",
+    truncated: "Contexto truncado",
+    contextSummary: "{database} · {tables} tabelas",
+    autoSqlBlocked: "O SQL gerado pela AI pareceu arriscado demais para execução automática. Revise-o manualmente antes de executar.",
+    proposalConfirmYes: "Sim, continuar",
+    proposalConfirmNo: "Não, obrigado",
+    proposalConfirmTitle: "Confirmação de ação necessária",
+    agentSteps: {
+      generated: "SQL gerado",
+      noSql: "Nenhum SQL encontrado",
+      safe: "Verificação de segurança aprovada",
+      needsConfirm: "Requer confirmação",
+      blocked: "Bloqueado",
+      autoExecute: "Pronto para executar",
+      notRequested: "Execução não solicitada",
+      skipped: "Não executado",
+      callingTool: "Chamando ferramenta...",
+      toolDone: "Ferramenta concluída",
+      toolError: "Erro da ferramenta",
+      executeSafe: "Verificação de segurança aprovada · Executado",
+      executeBlocked: "Bloqueado pela verificação de segurança",
+      contextCompacted: "Contexto compactado",
+    },
+    agentStepTitles: {
+      riskCheck: "Verificação de risco: {action} · {category} · {environment} · {reasons}",
+      blocked: "A execução foi bloqueada pela política de risco. Revise o SQL manualmente.",
+      requiresConfirmation: "Este SQL requer confirmação antes da execução.",
+      askMode: "O modo Perguntar não executa SQL automaticamente.",
+      unsupportedAction: "A ação atual de AI não executa SQL automaticamente.",
+      noSql: "A resposta não incluiu um bloco de código SQL executável.",
+      notRequested: "O usuário não solicitou a execução do SQL.",
+      skipped: "Esta etapa não foi executada.",
+    },
+    proxy: "Proxy",
+    proxyEnable: "Enviar requisições de AI através do proxy",
+    proxyUrl: "URL do Proxy",
+    anthropicMessagesHint: "APIs compatíveis com Anthropic Messages geralmente usam /v1/messages.",
+    contextWindow: "Janela de Contexto",
+    contextWindowAuto: "Automático (detectar pelo nome do modelo)",
+    contextWindowHint: "Tokens. Deixe vazio para detecção automática. Defina manualmente para modelos locais/personalizados.",
+    enableThinking: "Raciocínio",
+    enableThinkingOn: "Ativado",
+    enableThinkingOff: "Desativado",
+    enableThinkingHint: "Esta opção só tem efeito em APIs /chat/completions e modelos compatíveis. Quando desativada, pode reduzir significativamente o uso de tokens, mas a qualidade dos resultados gerados pode diminuir ligeiramente.",
+    actions: {
+      general: "Geral",
+      generate: "Gerar SQL",
+      explain: "Explicar SQL",
+      optimize: "Otimizar SQL",
+      fix: "Corrigir Erro",
+      convert: "Converter Dialeto",
+      sampleData: "Dados de Exemplo",
+      query: "Consultar dados",
+      exploreSchema: "Inspecionar esquema",
+      executeAndExplain: "Executar e explicar",
+      generateNoExec: "Gerar (sem executar)",
+    },
+    placeholders: {
+      general: "Pergunte qualquer coisa...",
+      generate: "Descreva o que você quer consultar, por exemplo, pedidos por usuário nos últimos 7 dias",
+      explain: "Opcional: adicione o que você quer entender",
+      optimize: "Opcional: adicione um objetivo, por exemplo, reduzir varreduras completas de tabela",
+      fix: "Cole o erro ou descreva o resultado esperado",
+      convert: "por exemplo, converter para PostgreSQL / MySQL / SQL Server",
+      sampleData: "Descreva os dados de exemplo ou instruções de teste a gerar",
+      query: "Descreva o que consultar ou contar, por exemplo, totais de pedidos por região este mês",
+      exploreSchema: "Descreva a tabela ou estrutura a inspecionar, por exemplo, colunas e índices de orders",
+      executeAndExplain: "Opcional: adicione o foco da explicação",
+    },
+    editMessage: "Editar mensagem",
+    editResend: "Reenviar",
+    editCancel: "Cancelar",
+  },
+  contextMenu: {
+    openConnection: "Abrir Conexão",
+    closeConnection: "Fechar Conexão",
+    closeDatabaseConnection: "Fechar Conexão do Banco de Dados",
+    deleteConnection: "Excluir Conexão",
+    deleteSelectedConnections: "Excluir {count} conexões selecionadas",
+    confirmDeleteTitle: "Excluir Conexão",
+    confirmDeleteMessage: 'Tem certeza de que deseja excluir "{name}"? Esta ação não pode ser desfeita.',
+    confirmDeleteSelectedMessage: "Excluir as {count} conexões selecionadas? Esta ação não pode ser desfeita.",
+    editConnection: "Editar Conexão",
+    revealDatabaseFile: "Mostrar no gerenciador de arquivos",
+    selectVisibleDatabases: "Selecionar Bancos de Dados Visíveis",
+    configureVisibleObjects: "Filtro de Objetos Visíveis",
+    userAdmin: "Usuários e Privilégios",
+    openUserAdmin: "Abrir Usuários e Privilégios",
+    damengJobAdmin: "Jobs do agente Dameng",
+    openDamengJobAdmin: "Abrir jobs do agente Dameng",
+    duplicateConnection: "Duplicar Conexão",
+    duplicateSelectedConnections: "Duplicar {count} conexões selecionadas",
+    instanceInfo: "Informações da Instância",
+    newQuery: "Nova Consulta",
+    newSql: "Novo SQL",
+    generateSql: "Gerar SQL",
+    newInsert: "Novo Insert",
+    newUpdate: "Novo Update",
+    sqlHistory: "Histórico de Consultas",
+    noSqlHistory: "Nenhum SQL relacionado",
+    openObjectBrowser: "Explorar Objetos",
+    viewData: "Ver Dados",
+    editStructure: "Editar Estrutura",
+    editColumn: "Editar Coluna",
+    editIndex: "Editar Índice",
+    refreshChildren: "Atualizar",
+    expandAll: "Expandir tudo",
+    pin: "Fixar",
+    unpin: "Desafixar",
+    fixTab: "Fixar aba",
+    unfixTab: "Desafixar aba",
+    refreshTab: "Atualizar Dados",
+    renameTab: "Renomear Aba",
+    duplicateTab: "Duplicar Aba",
+    compactTabTitle: "Encurtar Títulos das Abas",
+    fullTabTitle: "Mostrar títulos completos das abas",
+    closeTab: "Fechar Aba",
+    closeFixedTab: "Fechar Aba Fixa",
+    closeOtherTabs: "Fechar Outras Abas",
+    closeOtherRegularTabs: "Fechar Outras Abas Normais",
+    closeOtherFixedTabs: "Fechar Outras Abas Fixas",
+    closeAllTabs: "Fechar Todas as Abas",
+    closeAllRegularTabs: "Fechar Todas as Abas Normais",
+    closeAllFixedTabs: "Fechar Todas as Abas Fixas",
+    copyFinalProxyPort: "Copiar porta final do proxy",
+    finalProxyPortCopied: "Porta final do proxy {port} copiada",
+    copyName: "Copiar Nome",
+    setDefaultDatabase: "Definir como Banco de Dados Padrão",
+    clearDefaultDatabase: "Limpar Banco de Dados Padrão",
+    exportDatabase: "Exportar Banco de Dados",
+    exportAllDatabases: "Exportar todos os bancos de dados",
+    exportDatabaseSuccess: "{count} tabelas exportadas, até {limit} linhas cada",
+    exportDatabaseFailed: "Falha ao exportar banco de dados: {message}",
+    backupSqliteDatabase: "Backup SQLite Database",
+    backupSqliteDatabaseInProgress: "Backing up SQLite database...",
+    backupSqliteDatabaseSuccess: "SQLite database backed up",
+    backupSqliteDatabaseFailed: "Failed to backup SQLite database: {message}",
+    importData: "Importar Dados",
+    exportData: "Exportar Dados",
+    exportStructure: "Exportar Estrutura",
+    exportStructurePreviewTitle: "Estrutura - {name}",
+    exportStructurePreviewTitleMultiple: "Estrutura - {count} objetos",
+    exportStructureLoading: "Carregando estrutura...",
+    copyStructure: "Copiar Estrutura",
+    copyStructureAs: "Copiar Estrutura Como",
+    copyStructureAsTsv: "TSV (para Excel)",
+    copyStructureAsMarkdown: "Tabela Markdown",
+    structureDocTable: "Tabela",
+    structureDocColumn: "Coluna",
+    structureDocType: "Tipo",
+    structureDocPrimaryKey: "Chave Primária",
+    structureDocNullable: "Anulável",
+    structureDocDefault: "Padrão",
+    structureDocComment: "Comentário",
+    structureDocYes: "Sim",
+    structureDocNo: "Não",
+    structureDocCopied: "Estrutura copiada",
+    structureDocCopyFallbackHint: "A cópia automática foi bloqueada. Clique em Copiar novamente ou selecione o conteúdo abaixo.",
+    saveStructure: "Salvar SQL",
+    exportStructureCopied: "Estrutura copiada",
+    createTable: "Criar Tabela",
+    createView: "Criar Visão",
+    dropTable: "Remover Tabela",
+    emptyTable: "Esvaziar Tabela",
+    truncateTable: "Truncar Tabela",
+    duplicateStructure: "Clonar como Nova Tabela",
+    renameObject: "Renomear",
+    renameObjectTitle: "Renomear Objeto",
+    renameObjectNamePlaceholder: "Novo nome",
+    renameObjectSuccess: '"{oldName}" renomeado para "{newName}"',
+    confirmDropTableTitle: "Remover Tabela",
+    confirmDropTableMessage: 'Tem certeza de que deseja remover "{name}"? Isso excluirá permanentemente a tabela e todos os seus dados.',
+    dropTableCascade: "Usar CASCADE",
+    dropTableCascadeHint: "Também remove objetos dependentes, como views. Deixe desmarcado para usar o comportamento RESTRICT padrão do PostgreSQL.",
+    truncateTableCascade: "Usar CASCADE",
+    truncateTableCascadeHint: "Também trunca tabelas que referenciam esta tabela por chaves estrangeiras. Deixe desmarcado para usar o comportamento RESTRICT padrão do PostgreSQL.",
+    confirmEmptyTableTitle: "Esvaziar Tabela",
+    confirmEmptyTableMessage: 'Tem certeza de que deseja excluir todos os dados de "{name}"?',
+    confirmTruncateTableTitle: "Truncar Tabela",
+    confirmTruncateTableMessage: 'Tem certeza de que deseja truncar "{name}"? Isso removerá todas as linhas.',
+    dropTableSuccess: 'Tabela "{name}" removida',
+    editView: "Editar Visão",
+    viewSource: "Ver Código-fonte",
+    viewDdl: "Ver DDL",
+    viewDdlLoading: "Carregando DDL...",
+    ddlCopied: "DDL copiado",
+    dropObject: "Remover Objeto",
+    dropView: "Remover Visão",
+    dropColumn: "Remover Coluna",
+    dropIndex: "Remover Índice",
+    dropForeignKey: "Remover Chave Estrangeira",
+    dropTrigger: "Remover Gatilho",
+    batchDrop: "Remover selecionados ({count})",
+    batchEmpty: "Esvaziar selecionadas ({count})",
+    batchTruncate: "Truncar selecionadas ({count})",
+    executeProcedure: "Executar Procedimento",
+    confirmExecuteProcedureTitle: "Executar Procedimento",
+    confirmExecuteProcedureMessage: 'Executar o procedimento "{name}"? Você pode preencher ou ajustar os valores dos parâmetros primeiro.',
+    loadingProcedureParameters: "Carregando parâmetros...",
+    procedureParametersUnavailable: "Não foi possível carregar os metadados dos parâmetros. Você ainda pode editar o SQL abaixo e executá-lo.",
+    noProcedureParameters: "Nenhum parâmetro foi encontrado. O SQL atual será executado como exibido.",
+    inputParameters: "{count} parâmetros de entrada",
+    outputParameters: "{count} parâmetros de saída",
+    parameterName: "Nome",
+    parameterType: "Tipo",
+    parameterMode: "Modo",
+    parameterValue: "Valor",
+    parameterNull: "NULL",
+    parameterDefault: "DEFAULT",
+    parameterDefaultHint: "Quando DEFAULT está marcado, o DBX omite esse argumento para que o banco de dados use o padrão do procedimento.",
+    parameterValuePlaceholder: "Digite o valor",
+    outputOnly: "Apenas saída",
+    sqlPreview: "Pré-visualização do SQL",
+    resetSqlPreview: "Redefinir SQL",
+    openInSqlEditor: "Abrir no Editor",
+    dropProcedure: "Remover Procedimento",
+    dropFunction: "Remover Função",
+    dropAllIndexes: "Remover todos os índices",
+    batchDropIndexes: "Remover índices ({count})",
+    confirmDropViewTitle: "Remover Visão",
+    confirmDropViewMessage: 'Tem certeza de que deseja remover a visão "{name}"?',
+    confirmDropObjectTitle: "Remover Objeto",
+    confirmDropObjectMessage: 'Tem certeza de que deseja remover "{name}"?',
+    confirmDropColumnTitle: "Remover Coluna",
+    confirmDropIndexTitle: "Remover Índice",
+    confirmDropMongoIndexMessage: 'Tem certeza de que deseja remover o índice "{name}" da coleção "{collection}"?',
+    confirmDropMongoAllIndexesMessage: 'Tem certeza de que deseja remover todos os índices removíveis da coleção "{name}"?',
+    confirmDropMongoAllIndexesDetails: 'O MongoDB mantém o índice "_id_". Índices adicionais exigidos por shard key também podem permanecer; o resultado listará apenas os índices realmente removidos.',
+    confirmDropForeignKeyTitle: "Remover Chave Estrangeira",
+    confirmDropTriggerTitle: "Remover Gatilho",
+    confirmDropTableChildObjectMessage: 'Tem certeza de que deseja remover "{name}" de "{table}"?',
+    confirmDropBatchIndexesMessage: 'Tem certeza de que deseja remover {count} índices selecionados de "{table}"? Esta ação não pode ser desfeita.',
+    confirmBatchDropTitle: "Remover Objetos Selecionados",
+    confirmBatchDropMessage: "Tem certeza de que deseja remover {count} objetos selecionados? Esta ação não pode ser desfeita.",
+    confirmBatchEmptyTitle: "Esvaziar tabelas selecionadas",
+    confirmBatchEmptyMessage: "Tem certeza de que deseja excluir todos os dados de {count} tabelas selecionadas?",
+    confirmBatchTruncateTitle: "Truncar tabelas selecionadas",
+    confirmBatchTruncateMessage: "Tem certeza de que deseja truncar {count} tabelas selecionadas? Isso removerá todas as linhas.",
+    confirmDropProcedureTitle: "Remover Procedimento",
+    confirmDropProcedureMessage: 'Tem certeza de que deseja remover o procedimento "{name}"?',
+    confirmDropFunctionTitle: "Remover Função",
+    confirmDropFunctionMessage: 'Tem certeza de que deseja remover a função "{name}"?',
+    dropViewSuccess: 'Visão "{name}" removida',
+    dropProcedureSuccess: 'Procedimento "{name}" removido',
+    dropFunctionSuccess: 'Função "{name}" removida',
+    dropTableChildObjectSuccess: '"{name}" removido',
+    dropAllIndexesSuccess: 'Removidos {count} índices de "{name}"',
+    batchDropSuccess: "{count} objetos removidos",
+    batchEmptySuccess: "{count} tabelas esvaziadas",
+    batchEmptyPartialFail: "{success} tabelas esvaziadas; {failed} falharam",
+    batchEmptySubmitted: "Tarefas de esvaziamento enviadas para {count} tabelas",
+    batchEmptySubmittedPartial: "{success} tarefas enviadas; {failed} falharam",
+    batchTruncateSuccess: "{count} tabelas truncadas",
+    emptyTableSuccess: 'Todos os dados excluídos de "{name}"',
+    emptyTableSubmitted: 'Tarefa de esvaziamento enviada para "{name}"',
+    truncateTableSuccess: 'Tabela "{name}" truncada',
+    duplicateStructureSuccess: 'Tabela clonada como "{name}"',
+    tableOperationFailed: "Falha na operação: {message}",
+    duplicateNameTitle: "Clonar como Nova Tabela",
+    duplicateNamePlaceholder: "Nome da nova tabela",
+    copyTable: "Copiar tabela",
+    pasteTable: "Colar tabela",
+    pasteOptionStructureAndData: "Estrutura e dados",
+    pasteOptionStructureOnly: "Apenas estrutura",
+    pasteOptionDataOnly: "Apenas dados",
+    pasteTableSuccess: 'Tabela colada como "{name}"',
+    pasteTableConfirmTitle: "Colar tabela",
+    pasteTableConfirmMessage: "Colar tabela da área de transferência",
+    batchPasteTitle: "Colar tabelas",
+    batchPasteSuccess: "{count} tabelas coladas com sucesso",
+    batchPastePartialFail: "{success} tabelas coladas, {failed} falharam",
+    noTableToPaste: "Nenhuma tabela disponível para colar",
+    pasteTableClipboardUpdated: "Tabela copiada para a área de transferência",
+    createDatabase: "Criar Banco de Dados",
+    createDuckDbFile: "Criar Arquivo de Banco de Dados",
+    dropDatabase: "Remover Banco de Dados",
+    confirmDropDatabaseTitle: "Remover Banco de Dados",
+    confirmDropDatabaseMessage: 'Tem certeza de que deseja remover o banco de dados "{name}"? Isso excluirá permanentemente o banco de dados e todos os seus dados.',
+    createDatabaseSuccess: 'Banco de dados "{name}" criado',
+    editDatabaseProperties: "Editar propriedades do banco de dados",
+    editDatabasePropertiesTitle: 'Editar propriedades do banco de dados: "{name}"',
+    editDatabasePropertiesSaving: "Salvando...",
+    editDatabasePropertiesSuccess: 'Propriedades do banco de dados "{name}" atualizadas',
+    editDatabaseComment: "Comentário do banco de dados",
+    editDatabaseCommentPlaceholder: "Insira o comentário do banco de dados...",
+    createDuckDbFileSuccess: 'Arquivo de banco de dados DuckDB "{name}" criado e anexado',
+    createDuckDbFileDesktopOnly: "A criação de arquivos de banco de dados DuckDB só está disponível no aplicativo desktop",
+    dropDatabaseSuccess: 'Banco de dados "{name}" removido',
+    dropCollection: "Remover coleção",
+    confirmDropCollectionTitle: "Remover coleção",
+    confirmDropCollectionMessage: 'Tem certeza de que deseja remover a coleção "{name}"? Isso excluirá permanentemente a coleção e todos os seus documentos.',
+    dropCollectionSuccess: 'Coleção "{name}" removida',
+    createDatabaseNamePlaceholder: "Nome do banco de dados",
+    createDatabaseCharset: "Conjunto de caracteres",
+    createDatabaseCharsetPlaceholder: "por exemplo, utf8mb4",
+    createDatabaseCharsetSearchPlaceholder: "Pesquise ou digite um conjunto de caracteres",
+    createDatabaseCharsetEmpty: "Nenhum conjunto de caracteres encontrado",
+    createDatabaseCharsetLoading: "Carregando conjuntos de caracteres...",
+    createDatabaseCharsetCustomOption: 'Usar "{value}"',
+    createDatabaseCollation: "Collation",
+    createDatabaseCollationPlaceholder: "por exemplo, utf8mb4_unicode_ci",
+    createDatabaseCollationSearchPlaceholder: "Pesquise ou digite uma collation",
+    createDatabaseCollationEmpty: "Nenhuma collation encontrada",
+    createDatabaseCollationLoading: "Carregando collations...",
+    createDatabaseCollationCustomOption: 'Usar "{value}"',
+    createSchema: "Criar Schema",
+    dropSchema: "Remover Schema",
+    confirmDropSchemaTitle: "Remover Schema",
+    confirmDropSchemaMessage: 'Tem certeza de que deseja remover o schema "{name}"? Isso excluirá permanentemente o schema e todos os seus objetos.',
+    createSchemaSuccess: 'Schema "{name}" criado',
+    dropSchemaSuccess: 'Schema "{name}" removido',
+    createSchemaNamePlaceholder: "Nome do schema",
+    editSchemaComment: "Editar comentário",
+    editSchemaCommentTitle: 'Editar comentário: "{name}"',
+    schemaCommentPlaceholder: "Digite o comentário do schema...",
+    schemaCommentSaving: "Salvando...",
+    editSchemaCommentSuccess: 'Comentário do schema "{name}" atualizado',
+    manageExtension: "Gerenciar extensão...",
+    dropExtension: "Remover extensão",
+  },
+  visibleDatabases: {
+    title: "Bancos de dados visíveis",
+    description: 'Escolha quais bancos de dados são exibidos em "{connection}".',
+    searchPlaceholder: "Pesquisar bancos de dados...",
+    selectedCount: "{selected}/{total} selecionados",
+    selectAll: "Selecionar todos",
+    selectFiltered: "Selecionar resultados da pesquisa",
+    clear: "Limpar",
+    showAll: "Mostrar todos",
+    showSystemDatabases: "Mostrar bancos de dados do sistema",
+    save: "Salvar",
+    emptySelection: "Selecione pelo menos um banco de dados, ou use Mostrar todos para limpar o filtro.",
+    loadFailed: "Falha ao carregar bancos de dados: {message}",
+  },
+  visibleSchemas: {
+    title: "Filtro de Schema",
+    description: 'Escolha quais schemas são exibidos em "{connection}".',
+    searchPlaceholder: "Pesquisar schemas...",
+    selectedCount: "{selected}/{total} selecionados",
+    selectAll: "Selecionar todos",
+    selectFiltered: "Selecionar resultados da pesquisa",
+    clear: "Limpar",
+    showAll: "Mostrar todos",
+    save: "Salvar",
+    emptySelection: "Selecione pelo menos um schema, ou use Mostrar todos para limpar o filtro.",
+    loadFailed: "Falha ao carregar schemas: {message}",
+  },
+  tree: {
+    savedSql: "Biblioteca SQL",
+    userAdmin: "Usuários e Privilégios",
+    damengJobAdmin: "Jobs do agente",
+    linkedServers: "Servidores Vinculados",
+    materializedViews: "Visualizações Materializadas",
+    defaultDatabase: "Banco padrão",
+    columns: "Colunas",
+    indexes: "Índices",
+    foreignKeys: "Chaves estrangeiras",
+    triggers: "Triggers",
+    tables: "Tabelas",
+    views: "Visões",
+    procedures: "Procedimentos",
+    functions: "Funções",
+    sequences: "Sequências",
+    packages: "Pacotes",
+    partitions: "Partições",
+    childTables: "Subtabelas",
+    loadMore: "Carregar mais...",
+    objectBrowser: "Navegar no Navegador de Objetos ({count})",
+    extensions: "Extensões",
+  },
+  userAdmin: {
+    title: "Usuários e Privilégios",
+    unsupported: "Conexões compatíveis com MySQL e PostgreSQL são suportadas. SQL Server, Oracle e outros modelos de permissão podem ser adicionados em seguida.",
+    newUser: "Novo Usuário",
+    anonymous: "Anônimo",
+    roleName: "Nome da função",
+    allowLogin: "Permitir login",
+    searchUser: "Pesquisar usuário ou host",
+    loadingUsers: "Carregando usuários...",
+    loadingGrants: "Carregando permissões...",
+    emptyUsers: "Nenhum usuário encontrado, ou a conta atual não pode ler a lista de usuários.",
+    pluginUnknown: "Plugin de autenticação desconhecido",
+    grants: "Permissões",
+    noGrants: "Nenhuma permissão encontrada",
+    privilegeEditor: "Editor de Privilégios",
+    privilegeHint: "Escolha privilégios, banco de dados e tabela, então visualize o SQL antes de aplicar. * significa global ou todas as tabelas.",
+    database: "Banco de dados",
+    schema: "Schema",
+    table: "Tabela",
+    scope: "Escopo da concessão",
+    scopeDatabase: "Banco de dados",
+    scopeSchema: "Schema",
+    scopeTable: "Tabela",
+    scopeRole: "Associação de função",
+    memberRole: "Função membro",
+    privileges: "Privilégios",
+    grantOption: "Permitir mais concessões (WITH GRANT OPTION)",
+    adminOption: "Permitir gerenciamento de associação (WITH ADMIN OPTION)",
+    grant: "Conceder",
+    revoke: "Revogar",
+    username: "Nome de usuário",
+    host: "Host",
+    changePassword: "Alterar Senha",
+    newPassword: "Nova senha",
+    lock: "Bloquear",
+    unlock: "Desbloquear",
+    disableLogin: "Desabilitar Login",
+    enableLogin: "Habilitar Login",
+    dropUser: "Remover Usuário",
+    previewSql: "Visualizar SQL",
+    sqlPreview: "Visualização SQL",
+    applySql: "Aplicar SQL",
+    applySuccess: "Privilégios do usuário atualizados",
+    applyFailed: "Execução falhou: {message}",
+  },
+  damengJobAdmin: {
+    title: "Jobs do agente Dameng",
+    unsupported: "Esta página oferece suporte apenas a conexões Dameng.",
+    initEnvironment: "Inicializar ambiente de jobs",
+    environmentReady: "Ambiente de jobs inicializado",
+    newJob: "Novo job",
+    searchJob: "Pesquisar jobs",
+    loadFailed: "Falha ao carregar",
+    environmentMissingTitle: "O ambiente de jobs não foi inicializado",
+    environmentMissingHint: "Este banco de dados ainda não tem o ambiente de jobs SYSJOB.",
+    environmentMissingDescription: "Os jobs do agente Dameng dependem de tabelas e visões do sistema no schema SYSJOB. Inicialize primeiro o ambiente de jobs; normalmente são necessários privilégios de administrador.",
+    emptyJobs: "Nenhum job encontrado, ou a conta atual não pode ler a lista de jobs.",
+    emptyDetails: "Nenhuma linha de detalhe",
+    selectJob: "Selecione um job",
+    enabled: "Habilitado",
+    disabled: "Desabilitado",
+    running: "Em execução",
+    enable: "Habilitar",
+    disable: "Desabilitar",
+    runAsync: "Executar agora",
+    stopRunning: "Parar execução atual",
+    stopRunningDisabled: "Somente jobs em execução podem ser parados",
+    clearHistories: "Limpar histórico",
+    dropJob: "Remover",
+    steps: "Etapas",
+    schedules: "Agendamentos",
+    histories: "Histórico",
+    noDescription: "Sem descrição",
+    jobName: "Nome do job",
+    description: "Descrição",
+    stepName: "Nome da etapa",
+    scheduleName: "Nome do agendamento",
+    sqlCommand: "Script SQL",
+    scheduleMode: "Tipo de agendamento",
+    daily: "Diário",
+    once: "Uma vez",
+    startDate: "Data de início",
+    startTime: "Hora de início",
+    endTime: "Hora de término",
+    minuteInterval: "Intervalo em minutos",
+    previewSql: "Visualizar SQL",
+    sqlPreview: "Visualização SQL",
+    applySql: "Aplicar SQL",
+    applySuccess: "Operação de job aplicada",
+    applyFailed: "Execução falhou: {message}",
+  },
+  objects: {
+    all: "Todos",
+    tables: "Tabelas",
+    views: "Visões",
+    procedures: "Procedimentos",
+    functions: "Funções",
+    sequences: "Sequências",
+    packages: "Pacotes",
+    table: "Tabela",
+    partitions: "{count} partições",
+    view: "Visão",
+    procedure: "Procedimento",
+    function: "Função",
+    sequence: "Sequência",
+    package: "Pacote",
+    packageBody: "Corpo do pacote",
+    name: "Nome",
+    type: "Tipo",
+    rows: "Linhas",
+    size: "Tamanho",
+    statisticsHint: "Estimado pelas estatísticas do banco de dados; COUNT(*) não é executado.",
+    createdAt: "Criado em",
+    updatedAt: "Atualizado em",
+    source: "Código-fonte",
+    saveSource: "Salvar",
+    cancelEdit: "Cancelar",
+    sourceSaved: "Código-fonte salvo",
+    sourceSaveFailed: "Falha ao salvar código-fonte: {message}",
+    schemaColumn: "Schema",
+    comment: "Comentário",
+    loadingSchemas: "Carregando schemas...",
+    schema: "Schema",
+    search: "Pesquisar tabelas, visões, funções, sequências ou procedimentos...",
+    loading: "Carregando objetos...",
+    empty: "Nenhum objeto encontrado",
+    selectedTables: "{count} tabelas selecionadas",
+    exportSelected: "Exportar selecionados",
+    dropSelected: "Remover selecionados",
+    truncateSelected: "Truncar selecionadas",
+    clearSelection: "Limpar seleção",
+    confirmBatchDropTitle: "Remover tabelas selecionadas",
+    confirmBatchDropMessage: "Tem certeza de que deseja remover {count} tabelas selecionadas? Esta ação não pode ser desfeita.",
+    confirmBatchTruncateTitle: "Truncar tabelas selecionadas",
+    confirmBatchTruncateMessage: "Tem certeza de que deseja truncar {count} tabelas selecionadas? Isso removerá todas as linhas.",
+    batchDropSuccess: "{count} tabelas removidas",
+    batchTruncateSuccess: "{count} tabelas truncadas",
+    copyTableSelected: "Copiar",
+    pasteTableSelected: "Colar",
+    toggleCheckbox: "Alternar seleção múltipla",
+    viewList: "Visualização em lista",
+    viewGrid: "Visualização em grade",
+    sourceReadOnly: "O código fonte é somente leitura e não pode ser editado.",
+    sortAsc: "Crescente",
+    sortDesc: "Decrescente",
+    sortBy: "Ordenar por",
+  },
+  structureEditor: {
+    mysqlDataTypeHelp: {
+      tinyint: "Inteiro de 1 byte: com sinal, de -128 a 127; sem sinal, de 0 a 255.",
+      smallint: "Inteiro de 2 bytes: com sinal, de -32.768 a 32.767; sem sinal, de 0 a 65.535.",
+      mediumint: "Inteiro de 3 bytes: com sinal, de -8.388.608 a 8.388.607; sem sinal, de 0 a 16.777.215.",
+      int: "Inteiro de 4 bytes: com sinal, de -2.147.483.648 a 2.147.483.647; sem sinal, de 0 a 4.294.967.295.",
+      bigint: "Inteiro de 8 bytes: com sinal, de -2^63 a 2^63-1; sem sinal, de 0 a 2^64-1.",
+      decimal: "Número decimal exato; o MySQL aceita até 65 dígitos e escala 30. Use para valores monetários.",
+      float: "Número aproximado de precisão simples; para decimais exatos, use DECIMAL.",
+      double: "Número aproximado de dupla precisão; para decimais exatos, use DECIMAL.",
+      real: "Alias de DOUBLE por padrão; REAL_AS_FLOAT faz dele um alias de FLOAT.",
+      bit: "Campo de 1 a 64 bits; a largura padrão é 1.",
+      boolean: "Alias de TINYINT(1): 0 é falso e qualquer valor diferente de zero é verdadeiro.",
+      serial: "Alias prático de BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE.",
+      date: "Data de calendário de 1000-01-01 a 9999-12-31.",
+      datetime: "Data e hora sem conversão de fuso; precisão fracionária de 0 a 6, padrão 0.",
+      timestamp: "Data e hora convertida entre o fuso da sessão e UTC; precisão fracionária de 0 a 6.",
+      time: "Hora ou intervalo de -838:59:59 a 838:59:59; precisão fracionária de 0 a 6.",
+      year: "Ano de quatro dígitos de 1901 a 2155, além de 0000.",
+      char: "String de tamanho fixo de até 255 caracteres, preenchida com espaços.",
+      varchar: "String de tamanho variável; o máximo efetivo depende da linha e do conjunto de caracteres.",
+      tinytext: "Texto variável de até 255 bytes; linha, charset e max_allowed_packet podem reduzi-lo.",
+      text: "Texto variável de até 65.535 bytes; linha, charset e max_allowed_packet podem reduzi-lo.",
+      mediumtext: "Texto variável de até 16.777.215 bytes; linha, charset e max_allowed_packet podem reduzi-lo.",
+      longtext: "Texto variável de até 4.294.967.295 bytes; linha, charset e max_allowed_packet podem reduzi-lo.",
+      binary: "String binária fixa de até 255 bytes, preenchida com 0x00.",
+      varbinary: "String binária de tamanho variável; o máximo efetivo depende do tamanho da linha.",
+      tinyblob: "Objeto binário de até 255 bytes; max_allowed_packet pode limitá-lo.",
+      blob: "Objeto binário de até 65.535 bytes; max_allowed_packet pode limitá-lo.",
+      mediumblob: "Objeto binário de até 16.777.215 bytes; max_allowed_packet pode limitá-lo.",
+      longblob: "Objeto binário de até 4.294.967.295 bytes; max_allowed_packet pode limitá-lo.",
+      enum: "Um valor entre até 65.535 literais; alterar a ordem pode mudar o significado armazenado.",
+      set: "Zero ou mais valores entre até 64 membros declarados.",
+      json: "Documento JSON validado; a representação e as funções dependem do produto e da versão; limitado por max_allowed_packet.",
+      jsonMysql: "JSON binário nativo do MySQL, com validação e funções JSON; limitado por max_allowed_packet.",
+      jsonMariaDb: "No MariaDB, JSON é um alias de LONGTEXT com JSON_VALID e collation utf8mb4_bin.",
+      nationalCharacter: "Alias de string nacional; o MySQL usa utf8mb3, que está obsoleto; prefira utf8mb4.",
+      geometry: "Geometria espacial; um índice SPATIAL do InnoDB requer NOT NULL e atributo SRID.",
+      point: "Ponto espacial; SPATIAL do InnoDB requer NOT NULL e SRID.",
+      linestring: "Curva espacial; SPATIAL do InnoDB requer NOT NULL e SRID.",
+      polygon: "Superfície espacial; SPATIAL do InnoDB requer NOT NULL e SRID.",
+      multipoint: "Coleção de pontos; SPATIAL do InnoDB requer NOT NULL e SRID.",
+      multilinestring: "Coleção de curvas; SPATIAL do InnoDB requer NOT NULL e SRID.",
+      multipolygon: "Coleção de polígonos; SPATIAL do InnoDB requer NOT NULL e SRID.",
+      geometrycollection: "Coleção de geometrias mistas; SPATIAL do InnoDB requer NOT NULL e SRID.",
+      inet4: "Tipo IPv4 do MariaDB disponível desde a versão 10.10; armazena o endereço em quatro bytes.",
+      inet6: "Tipo compatível com MariaDB para IPv6 e IPv4 mapeado.",
+      uuid: "Identificador universalmente único de 128 bits fornecido por servidores compatíveis.",
+      vector: "Tipo de vetor para similaridade ou ML; disponibilidade e dimensões dependem da versão.",
+      xmltype: "Tipo XML fornecido por servidores compatíveis.",
+      integerDisplayWidth: "A largura de exibição de inteiros, como INT(11), está obsoleta no MySQL e não limita o intervalo.",
+      zerofill: "ZEROFILL está obsoleto no MySQL 8 e implica UNSIGNED; formate na aplicação.",
+      unsignedNumeric: "UNSIGNED para DECIMAL, FLOAT ou DOUBLE está obsoleto no MySQL 8; use CHECK para valores não negativos.",
+      floatPrecision: "Em FLOAT(p), p de 25 a 53 seleciona DOUBLE; use DOUBLE explicitamente.",
+      floatingPointDisplay: "FLOAT(M,D) e DOUBLE(M,D) estão obsoletos; use FLOAT/DOUBLE sem parâmetros ou DECIMAL(M,D).",
+    },
+    postgresDataTypeHelp: {
+      smallint: "Inteiro com sinal de 2 bytes, de -32.768 a 32.767.",
+      integer: "Inteiro com sinal de 4 bytes, de -2.147.483.648 a 2.147.483.647.",
+      bigint: "Inteiro com sinal de 8 bytes, de -2^63 a 2^63-1.",
+      serial: "Sintaxe prática que cria inteiro, sequência, NOT NULL e nextval; não é único por si só e pode ter lacunas; prefira IDENTITY.",
+      numeric: "Decimal exato com precisão e escala; use para valores monetários e valores sem arredondamento binário.",
+      real: "Ponto flutuante de precisão simples de 4 bytes; FLOAT(p) de 1 a 24 o seleciona.",
+      double: "Ponto flutuante de dupla precisão de 8 bytes; FLOAT sem precisão é um alias e FLOAT(p) de 25 a 53 o seleciona.",
+      money: "Valor monetário dependente de lc_monetary; NUMERIC costuma ser mais seguro para dados portáveis.",
+      boolean: "Valor lógico verdadeiro, falso ou nulo; BOOL é um alias de BOOLEAN.",
+      char: "String fixa preenchida com espaços; CHARACTER é um alias.",
+      varchar: "String de tamanho variável com limite opcional; CHARACTER VARYING é um alias.",
+      text: "String de tamanho variável sem limite declarado; é armazenada como VARCHAR sem limite.",
+      bytea: "String binária de tamanho variável; TOAST pode armazenar valores grandes fora da linha.",
+      date: "Data de calendário sem hora nem fuso horário.",
+      time: "Hora sem fuso horário, com precisão fracionária opcional.",
+      timetz: "Hora com deslocamento UTC; tem uso limitado, prefira timestamptz para representar um instante.",
+      timestamp: "Data e hora sem conversão de fuso para valores locais.",
+      timestamptz: "Instante armazenado em UTC e exibido no fuso da sessão; não preserva o fuso original.",
+      interval: "Duração em meses, dias e microssegundos; unidades de calendário não têm duração fixa.",
+      uuid: "Identificador universalmente único de 128 bits.",
+      json: "Texto JSON na representação original; é validado ao ser analisado, mas costuma ser mais lento que JSONB.",
+      jsonb: "JSON binário decomposto para processamento e índices; não preserva espaços, ordem nem chaves duplicadas.",
+      xml: "Valor XML com validação de documento ou conteúdo conforme a opção.",
+      bit: "String de bits fixa ou variável; BIT VARYING e VARBIT são aliases de tamanho variável.",
+      tsvector: "Lexemas normalizados para busca de texto completo; normalmente indexados com GIN ou GiST.",
+      tsquery: "Consulta booleana de texto completo avaliada contra tsvector.",
+      cidr: "Rede IPv4 ou IPv6 com os bits de host forçados a zero.",
+      inet: "Host IPv4 ou IPv6 com máscara opcional; ao contrário de CIDR, pode ter bits de host diferentes de zero.",
+      macaddr: "Endereço MAC; MACADDR usa 6 bytes e MACADDR8 usa 8 bytes.",
+      geometry: "Geometria plana bidimensional sem SRID; use PostGIS para coordenadas geográficas e operações espaciais avançadas.",
+      range: "Intervalo contínuo com limites inclusivos ou exclusivos; use multirange para intervalos separados.",
+      oid: "Identificador de objeto sem sinal do sistema; não é uma chave primária estável para aplicações.",
+      array: "Array PostgreSQL de qualquer tipo de elemento, inclusive multidimensional; as dimensões declaradas não são impostas.",
+      multirange: "Conjunto de intervalos não sobrepostos; o PostgreSQL normaliza membros adjacentes ou sobrepostos.",
+      jsonpath: "Expressão de caminho SQL/JSON usada em consultas e predicados JSONB.",
+      pgLsn: "Posição do WAL para replicação e recuperação; não é um número de sequência da aplicação.",
+      pgSnapshot: "Instantâneo de visibilidade de transações para operações de banco de dados, não para dados gerais.",
+    },
+    sqliteDataTypeHelp: {
+      integer: "Afinidade INTEGER; uma coluna comum não impõe essa classe de armazenamento. INTEGER PRIMARY KEY exato é um alias de rowid.",
+      real: "Afinidade REAL com IEEE 754; não é adequada para valores monetários exatos.",
+      text: "Afinidade TEXT; VARCHAR(n) e CHAR(n) não impõem n; use CHECK se o tamanho for importante.",
+      blob: "Afinidade BLOB: armazena bytes sem conversão.",
+      numeric: "A afinidade NUMERIC converte texto numérico primeiro em INTEGER e depois em REAL; DATE, DATETIME e TIME também a usam.",
+    },
+    title: "Editar estrutura da tabela",
+    createTitle: "Criar tabela",
+    editTabTitle: "Editar: {tableName}",
+    tableName: "Nome da tabela",
+    refresh: "Atualizar estrutura",
+    density: "Densidade",
+    densityCompact: "Compacta",
+    densityStandard: "Padrão",
+    densityComfortable: "Confortável",
+    columns: "Colunas",
+    indexes: "Índices",
+    foreignKeys: "Chaves estrangeiras",
+    triggers: "Triggers",
+    ddl: "DDL",
+    addColumn: "Adicionar coluna",
+    columnTemplates: "Inserir campos predefinidos",
+    configureColumnTemplates: "Configurar campos predefinidos",
+    presetFieldsTemplate: "Conjunto de campos predefinidos",
+    searchColumns: "Pesquisar coluna/comentário",
+    nextColumnMatch: "Ir para a próxima coluna correspondente",
+    searchIndexes: "Pesquisar índice",
+    nextIndexMatch: "Ir para o próximo índice correspondente",
+    addIndex: "Adicionar índice",
+    addForeignKey: "Adicionar chave estrangeira",
+    addTrigger: "Adicionar trigger",
+    columnName: "Coluna",
+    dataType: "Tipo",
+    typePlaceholder: "Selecione ou digite...",
+    noMatchingType: "Nenhum tipo correspondente",
+    length: "Comprimento",
+    nullable: "Permite nulo",
+    primaryKey: "Chave primária",
+    defaultValue: "Padrão",
+    defaultValuePresets: "Predefinições de valor padrão",
+    comment: "Comentário",
+    characterSet: "Conjunto de caracteres",
+    charsetPlaceholder: "Charset",
+    collation: "Collation",
+    collationPlaceholder: "Collation",
+    editComment: "Editar comentário",
+    commentPlaceholder: "Insira o comentário da coluna...",
+    tableCommentPlaceholder: "Insira o comentário da tabela...",
+    tableCommentUnsupported: "Comentários de tabela não são suportados por este banco de dados",
+    actions: "Ações",
+    indexName: "Índice",
+    indexColumns: "Colunas",
+    indexColumnsPlaceholder: "Selecione as colunas...",
+    unique: "Único",
+    indexType: "Tipo",
+    includedColumns: "Incluídas",
+    includedColumnsPlaceholder: "Selecione as colunas...",
+    filter: "Filtro",
+    foreignKeyName: "Chave estrangeira",
+    referencedSchema: "Schema ref.",
+    referencedTable: "Tabela ref.",
+    referencedColumn: "Coluna ref.",
+    onDelete: "Ao excluir",
+    onUpdate: "Ao atualizar",
+    defaultAction: "Padrão",
+    triggerName: "Trigger",
+    triggerStatement: "Comando do trigger",
+    primary: "Primária",
+    drop: "Remover",
+    restore: "Restaurar",
+    remove: "Remover",
+    moveColumnUp: "Mover coluna para cima",
+    moveColumnDown: "Mover coluna para baixo",
+    dragColumn: "Arraste para reordenar colunas",
+    localColumnOrderNotice: "A ordem das colunas é salva apenas localmente e não altera a estrutura do banco de dados.",
+    yes: "Sim",
+    no: "Não",
+    emptyReadonly: "Nenhum registro",
+    sqlPreview: "Pré-visualização do SQL",
+    collapseSqlPreview: "Recolher pré-visualização do SQL",
+    expandSqlPreview: "Expandir pré-visualização do SQL",
+    noChanges: "Nenhuma alteração",
+    apply: "Aplicar alterações",
+    ready: "Pronto",
+    saved: "Estrutura da tabela atualizada",
+    copySql: "Copiar SQL",
+    sqliteRebuildNotice: "O SQLite mantém um snapshot de dados inerte como backup, reconstrói a tabela em uma única transação e força CAST nas colunas alteradas. Valores não representáveis podem se tornar 0/0.0; em caso de falha, todas as alterações são revertidas.",
+    extendedProperties: "Estendidas",
+    autoIncrement: "Auto incremento",
+    onUpdateCurrentTimestamp: "Atualizar hora automaticamente",
+    identity: "Identidade",
+    identityGeneration: "Geração",
+    identitySeed: "Valor inicial",
+    identityIncrement: "Incremento",
+    sqlServerIdentityTypeHint: "A identidade do SQL Server só aceita tinyint, smallint, int, bigint e decimal/numeric com escala 0",
+  },
+  diagram: {
+    title: "Diagrama de relacionamentos",
+    open: "Ver diagrama",
+    selectConnection: "Selecionar conexão",
+    selectDatabase: "Selecionar banco de dados",
+    selectSchema: "Selecionar schema",
+    searchTables: "Pesquisar tabelas, colunas, chaves...",
+    refresh: "Atualizar diagrama",
+    loading: "Lendo relacionamentos...",
+    loadingProgress: "Lendo relacionamentos... {loaded}/{total}",
+    partialError: "Metadados ignorados para {count} tabelas que falharam ao carregar",
+    selectTarget: "Selecione uma conexão e um banco de dados",
+    empty: "Nenhuma tabela para exibir",
+    noMatches: "Nenhuma tabela correspondente",
+    tablesCount: "{count} tabelas",
+    relationshipsCount: "{count} relacionamentos",
+    tableMode: "Visão de tabelas",
+    engineeringMode: "ER de engenharia",
+    modelRelationships: "Relacionamentos Modelados",
+    copyJoinSql: "Copiar SQL",
+    customRelationshipsCount: "{count} modelados",
+    relationshipName: "Nome",
+    relationshipNamePlaceholder: "Opcional",
+    sourceTable: "Tabela de origem",
+    sourceColumn: "Coluna de origem",
+    targetTable: "Tabela de destino",
+    targetColumn: "Coluna de destino",
+    cardinality: "Cardinalidade",
+    cardinalityOneToMany: "1:N",
+    cardinalityManyToOne: "N:1",
+    cardinalityOneToOne: "1:1",
+    addRelationship: "Adicionar relacionamento",
+    removeRelationship: "Remover relacionamento",
+    relationshipIncomplete: "Selecione as colunas de origem e destino",
+    relationshipSelfInvalid: "Um relacionamento não pode ter como alvo a mesma coluna",
+    relationshipExists: "Este relacionamento já existe",
+    relationshipAdded: "Relacionamento adicionado",
+    noJoinSql: "Nenhum SQL de relacionamento para copiar",
+    allTables: "Todas as tabelas",
+    relatedTables: "Tabelas relacionadas",
+    moreColumns: "+ {count} colunas",
+    exportSvg: "Exportar SVG",
+    exportedSvg: "SVG exportado",
+    exportSvgFailed: "Falha ao exportar SVG: {message}",
+    zoomIn: "Aumentar zoom",
+    zoomOut: "Diminuir zoom",
+    resetLayout: "Redefinir layout",
+  },
+  etcd: {
+    prefixPlaceholder: "Prefixo, ex.: /app/",
+    newKey: "Nova Chave",
+    loadingKeys: "Carregando chaves...",
+    empty: "Nenhuma chave encontrada",
+    loadMore: "Carregar mais",
+    selectKey: "Selecione uma chave para ver seu valor",
+    loadingValue: "Carregando valor...",
+    notFound: "Chave não encontrada",
+    edit: "Editar",
+    editKey: "Editar Chave",
+    delete: "Excluir",
+    deleteTitle: "Excluir chave etcd",
+    keyPlaceholder: "/caminho/para/chave",
+    keyRequired: "Chave é obrigatória",
+    saved: "Chave salva",
+    deleted: "Chave excluída",
+    base64Readonly: "Valores Base64 são somente leitura nesta versão.",
+  },
+  zookeeper: {
+    prefixPlaceholder: "Prefixo de caminho, ex.: /app/",
+    newKey: "Novo Znode",
+    loadingKeys: "Carregando znodes...",
+    empty: "Nenhum znode encontrado",
+    loadMore: "Carregar mais",
+    selectKey: "Selecione um znode para ver seu valor",
+    loadingValue: "Carregando valor...",
+    notFound: "Znode não encontrado",
+    edit: "Editar",
+    editKey: "Editar Znode",
+    delete: "Excluir",
+    deleteTitle: "Excluir znode do ZooKeeper",
+    keyPlaceholder: "/caminho/para/znode",
+    keyRequired: "Caminho do znode é obrigatório",
+    rootReadonly: "O znode raiz não pode ser modificado. Informe o caminho de um znode filho.",
+    saved: "Znode salvo",
+    deleted: "Znode excluído",
+    base64Readonly: "Valores Base64 são somente leitura nesta versão.",
+    createMode: "Modo de Criação",
+    createModePersistent: "Persistente",
+    createModeEphemeral: "Efêmero",
+    createModePersistentSequential: "Persistente Sequencial",
+    createModeEphemeralSequential: "Efêmero Sequencial",
+    add: "Adicionar",
+    value: "Valor",
+    metadata: "Informações do Nó",
+    prettyJson: "Formatado",
+    invalidJson: "JSON inválido",
+    summaryRevision: "rev",
+    summaryVersion: "ver",
+    summaryLease: "lease",
+    summarySize: "tamanho",
+  },
+  redis: {
+    createKeyTypeHelp: {
+      string: "Valor único de até 512 MB; útil para cache e contadores.",
+      hash: "Mapa plano campo-valor; ler um Hash grande inteiro é O(N).",
+      list: "Sequência ordenada; acesso no meio é linear.",
+      set: "Membros únicos sem ordem; enumerar conjuntos grandes é linear.",
+      zset: "Membros únicos com pontuação de ponto flutuante; escrita O(log N).",
+      stream: "Log somente de acréscimo; gerencie XACK, pendências e corte.",
+      json: "JSON por caminho; requer RedisJSON/Redis Stack e costuma custar mais que String ou Hash.",
+    },
+    selectKey: "Selecione uma chave para ver seu valor",
+    noKeys: "Nenhuma chave encontrada",
+    noKeysInScanHint: "Nenhuma chave encontrada no intervalo atual de verificação",
+    pattern: "padrão (ex.: user:*)",
+    fuzzyPattern: "a chave contém...",
+    fuzzyMatch: "Aproximado",
+    fuzzyMatchTitle: "Correspondência aproximada: pesquisa chaves por texto contido",
+    valueSearchPlaceholder: "o valor contém...",
+    allSearchPlaceholder: "a chave ou o valor contém...",
+    searchByKey: "Chave",
+    searchByValue: "Valor",
+    searchByAll: "Tudo",
+    searchFields: "Pesquisar campos e valores",
+    keys: "{count} chaves",
+    loadedKeys: "{loaded} / {total} chaves carregadas",
+    loadingKeys: "Carregando chaves...",
+    searchingValues: "Pesquisando valores...",
+    searchingAll: "Pesquisando chaves e valores...",
+    loadMoreKeys: "Carregar mais chaves",
+    fetchAllKeys: "Buscar todas",
+    stopFetchAll: "Parar",
+    fetchAllProgress: "{loaded} de {total} chaves carregadas",
+    fetchAllProgressUnknown: "{loaded} chaves carregadas",
+    items: "{count} itens",
+    fields: "{count} campos",
+    members: "{count} membros",
+    loadedItems: "{loaded} de {total} itens carregados",
+    loadedFields: "{loaded} de {total} campos carregados",
+    loadedMembers: "{loaded} de {total} membros carregados",
+    entries: "{count} entradas",
+    noExpiry: "sem expiração",
+    autoRefresh: "Atualização automática",
+    ttlDay: "{count}d",
+    columnType: "Tipo",
+    columnKey: "Chave",
+    columnValue: "Valor",
+    columnSize: "Tamanho",
+    columnTTL: "TTL",
+    binaryStringReadonlyHint: "Valores de string binária são exibidos como texto escapado no modo somente leitura; a edição de bytes brutos não é suportada.",
+    selectedKeys: "Chaves selecionadas",
+    deleteGroup: "Excluir grupo",
+    deleteGroupDetails: "{target}\n{count} chaves",
+    flushDb: "Limpar DB atual",
+    flushDbMessage: "Isto excluirá todas as chaves do banco de dados Redis atual e não pode ser desfeito. Continuar?",
+    flushDbDetails: "Alvo: Redis db{db}\nEscopo: todas as chaves do DB atual",
+    flushDbConfirm: "Limpar DB",
+    flushDbSuccess: "Redis db{db} limpo",
+    keyDetail: "Detalhe da chave",
+    commandLine: "Linha de comando",
+    selectKeyForDetail: "Selecione uma chave para ver os detalhes",
+    commandWelcome: "Bem-vindo ao console de comandos do Redis",
+    commandPlaceholder: "Comando Redis, ex.: GET user:1",
+    commandPrefix: "CMD",
+    commandHint: "Insira um comando Redis, ex.: SMEMBERS feature:flags",
+    executeCommand: "Executar comando",
+    commandEmpty: "Insira um comando Redis",
+    commandEmptyResult: "Execute um comando Redis para ver o resultado",
+    commandBlocked: "Este comando Redis está bloqueado por segurança",
+    createKey: "Criar chave",
+    createKeyName: "Chave",
+    createKeyNamePlaceholder: "user:1",
+    createKeyType: "Tipo",
+    createValue: "Valor",
+    createMember: "Membro",
+    createField: "Campo",
+    createFieldPlaceholder: "nome",
+    createScore: "Pontuação",
+    createKeyTtl: "TTL (segundos)",
+    createKeyTtlPlaceholder: "vazio = sem expiração",
+    createKeyAddEntry: "Adicionar entrada",
+    createKeyEntryId: "ID da entrada",
+    createKeyRawMode: "Entrada bruta",
+    createKeyEntries: "Entradas",
+    createValuePlaceholder: "valor",
+    jsonModuleNotAvailable: "Módulo ReJSON não está carregado neste servidor Redis",
+    createKeySubmit: "Criar",
+    createKeyNameRequired: "Insira um nome de chave",
+    createFieldRequired: "Insira um campo de hash",
+    createScoreInvalid: "Insira uma pontuação válida",
+    fieldRequired: "Insira um nome de campo",
+    valueRequired: "Insira um valor",
+    memberRequired: "Insira um membro",
+    ttlInvalid: "Insira um TTL válido em segundos (-1 para sem expiração)",
+    member: "Membro",
+    memberDetail: "Detalhe do membro",
+    viewMember: "Ver valor completo",
+    copyMember: "Copiar membro",
+    copyKeyName: "Copiar nome da chave",
+    copied: "Copiado",
+    copyInsertStatement: "Copiar instrução de inserção",
+    copyInsertStatementBinary: "Não é possível gerar instrução de inserção para dados binários",
+    editMember: "Editar",
+    jsonView: "Visão JSON",
+    rawContent: "Conteúdo bruto",
+    wordWrap: "Quebra de linha",
+    formatJson: "Formatar",
+    compressJson: "Comprimir",
+    jsonFormatError: "Formato JSON inválido",
+    clearHistory: "Limpar histórico de comandos",
+    historyCleared: "Histórico de comandos Redis limpo",
+    blockedCommand: "O comando {command} está bloqueado por segurança. Desative o ícone de escudo na barra de ferramentas para permiti-lo.",
+    slowlog: "Slow Log",
+    slowlogCount: "Contagem",
+    slowlogQuery: "Consultar",
+    slowlogNode: "Nó",
+    slowlogSelectNode: "Selecione um nó",
+    slowlogNodeRequired: "Selecione um nó primeiro",
+    slowlogEmpty: "Clique em Consultar para obter entradas do slow log",
+    slowlogFetchFailed: "Falha ao buscar slow log: {error}",
+    slowlogColumnId: "ID",
+    slowlogColumnTimestamp: "Timestamp",
+    slowlogColumnDuration: "Duração (μs)",
+    slowlogColumnCommand: "Comando",
+    slowlogColumnClientAddr: "Cliente",
+    slowlogColumnClientName: "Nome do Cliente",
+    slowlogTotal: "{count} entradas",
+    slowlogDetailTitle: "Entrada de Slow Log #{id}",
+    pubsub: "Pub/Sub",
+    pubsubConnected: "Conectado",
+    pubsubConnecting: "Conectando...",
+    pubsubDisconnected: "Desconectado",
+    pubsubConnect: "Conectar",
+    pubsubDisconnect: "Desconectar",
+    pubsubChannels: "Canais",
+    pubsubChannelPlaceholder: "Nome do canal",
+    pubsubSubscribe: "Inscrever-se",
+    pubsubPatterns: "Padrões",
+    pubsubPatternPlaceholder: "Padrão (ex. news:*)",
+    pubsubPsubscribe: "PInscrever-se",
+    pubsubMessages: "Mensagens",
+    pubsubClear: "Limpar",
+    pubsubEmpty: "Nenhuma mensagem. Inscreva-se em um canal para receber mensagens.",
+    pubsubPublish: "Publicar",
+    pubsubPublishChannel: "Canal",
+    pubsubPublishMessage: "Mensagem",
+    pubsubSend: "Enviar",
+    pubsubPublishFailed: "Publicação falhou: {error}",
+    pubsubWsConnectFailed: "Conexão WebSocket falhou: {error}",
+  },
+  mongo: {
+    documents: "{count} documentos",
+    addField: "Adicionar campo",
+    deleteField: "Excluir campo",
+    field: "Campo",
+    value: "Valor",
+    fieldPlaceholder: "Nome do campo",
+    emptyCollection: "Coleção vazia",
+    selectDocument: "Selecione um documento",
+    readonlyId: "_id é somente leitura",
+    invalidJsonValue: "Esta célula não é um valor JSON válido",
+    duplicateField: "Nome de campo duplicado: {field}",
+    edit: "Editar",
+    documentView: "Visão de documento",
+    tableView: "Visão de tabela",
+    filterPlaceholder: "Filtrar...",
+    sortPlaceholder: "Ordenar...",
+  },
+  vector: {
+    collectionFallback: "coleção",
+    productCollection: "coleção {product}",
+    browse: "Navegar",
+    search: "Pesquisar",
+    upsert: "Upsert",
+    delete: "Excluir",
+    reset: "Redefinir",
+    refresh: "Atualizar",
+    run: "Executar",
+    apply: "Aplicar",
+    requestEditor: "Editor de requisição de vetor",
+    operationSuccess: "Operação concluída. A pré-visualização da coleção foi atualizada.",
+    vectorLabel: "Vetor",
+  },
+  history: {
+    title: "Histórico",
+    search: "Pesquisar histórico...",
+    empty: "Nenhum histórico ainda",
+    emptyFilteredRecent: "Nenhum registro correspondente nas 200 entradas mais recentes do histórico de execução",
+    failed: "Falhou",
+    success: "Concluído",
+    restore: "Restaurar no editor",
+    copy: "Copiar SQL",
+    delete: "Excluir",
+    clear: "Limpar histórico",
+    viewDetails: "Ver detalhes",
+    analyzeWithAi: "Analisar com IA",
+    aiAnalyzeNoConnection: "Não é possível analisar esta entrada de histórico porque sua conexão não existe mais.",
+    aiAnalysisTab: "Análise do histórico",
+    rollback: "Reverter",
+    rollbackSql: "SQL de reversão",
+    rollbackAvailable: "Disponível",
+    rollbackUnavailable: "Sem SQL de reversão",
+    rollbackConfirm: "Executar o SQL de reversão gerado para esta entrada de histórico?",
+    rollbackSuccess: "Reversão executada",
+    rollbackFailed: "Falha na reversão: {message}",
+    confirmDelete: "Excluir esta entrada de histórico?",
+    confirmClear: "Limpar todo o histórico?",
+    filters: {
+      all: "Todos",
+      query: "Consultas",
+      data_change: "Alterações de dados",
+      schema_change: "Alterações de schema",
+      failed: "Falhou",
+    },
+    dateRange: {
+      title: "Intervalo de tempo",
+      label: "Hora de execução:",
+      start: "Data inicial",
+      end: "Data final",
+      apply: "Aplicar",
+      clear: "Limpar",
+      invalid: "A data inicial não pode ser posterior à data final",
+      unboundedStart: "Início",
+      unboundedEnd: "Fim",
+    },
+    kinds: {
+      query: "Consulta",
+      data_change: "Alteração de dados",
+      schema_change: "Alteração de schema",
+      import: "Importação",
+      transfer: "Transferência",
+      redis_command: "Comando Redis",
+    },
+    kindShort: {
+      query: "SQL",
+      data_change: "Dados",
+      schema_change: "DDL",
+      import: "Importar",
+      transfer: "Mover",
+      redis_command: "Redis",
+    },
+    detail: {
+      kind: "Tipo",
+      operation: "Operação",
+      connection: "Conexão",
+      database: "Banco de dados",
+      target: "Alvo",
+      time: "Hora",
+      duration: "Duração",
+      affectedRows: "Linhas afetadas",
+      rollback: "Reversão",
+      status: "Status",
+      error: "Erro",
+    },
+  },
+  dangerDialog: {
+    title: "Operação perigosa",
+    message: "Esta instrução SQL pode modificar ou excluir dados de forma irreversível. Tem certeza de que deseja executá-la?",
+    redisCommandMessage: "Este comando Redis pode modificar dados e não pode ser desfeito automaticamente. Continuar?",
+    suppressFuturePrompts: "Não perguntar novamente para SQL perigoso",
+    wrapLines: "Alternar quebra de linha",
+    deleteMessage: "Esta operação de exclusão pode ser irreversível. Continuar?",
+    deleteConfirm: "Confirmar exclusão",
+    deleteRowMessage: "Esta linha será marcada para exclusão e removida do banco de dados após salvar. Continuar?",
+    deleteRowsMessage: "Estas {count} linhas serão marcadas para exclusão e removidas do banco de dados após salvar. Continuar?",
+    deleteRowDetails: "Tabela: {table}",
+    deleteRowDetailsNoTable: "Linha de resultado atual",
+    redisKeyDetails: "Chave Redis: {key}",
+    redisHashFieldDetails: "Hash Redis: {key}\nCampo: {field}",
+    redisListItemDetails: "Lista Redis: {key}\nÍndice: {index}",
+    redisSetMemberDetails: "Set Redis: {key}\nMembro: {member}",
+    mongoDocumentDetails: "Coleção MongoDB: {collection}\nDocumento _id: {id}",
+    mongoFieldDetails: "Campo: {field}",
+    mongoArrayItemDetails: "Índice do item do array: {index}",
+    cancel: "Cancelar",
+    confirm: "Executar",
+  },
+  sqlParameters: {
+    title: "Parâmetros SQL",
+    description: "Preencha valores para marcadores de template SQL. O DBX substitui antes de executar o SQL.",
+    name: "Parâmetro",
+    syntax: "Sintaxe",
+    type: "Tipo",
+    value: "Valor",
+    valuePlaceholder: "Digite o valor",
+    preview: "Prévia SQL",
+    execute: "Executar",
+    kind: {
+      string: "Texto",
+      number: "Número",
+      boolean: "Booleano",
+      null: "NULL",
+      raw: "SQL bruto",
+    },
+  },
+  transfer: {
+    title: "Transferência de Dados",
+    source: "Origem",
+    target: "Destino",
+    sourceConnection: "Conexão de origem",
+    sourceDatabase: "Banco de dados de origem",
+    sourceSchema: "Schema de origem",
+    targetConnection: "Conexão de destino",
+    targetDatabase: "Banco de dados de destino",
+    targetSchema: "Schema de destino",
+    tables: "Tabelas",
+    selectAll: "Selecionar tudo",
+    deselectAll: "Desmarcar tudo",
+    createTable: "Criar tabela se não existir",
+    transferMode: "Modo de transferência",
+    modeAppend: "Anexar (INSERT)",
+    modeOverwrite: "Sobrescrever (TRUNCATE + INSERT)",
+    modeUpsert: "Upsert (INSERT ou UPDATE por PK)",
+    targetTableNameCase: "Maiúsculas/minúsculas da tabela de destino",
+    tableNameCasePreserve: "Preservar",
+    tableNameCaseLower: "Converter para minúsculas",
+    tableNameCaseUpper: "Converter para maiúsculas",
+    batchSize: "Tamanho do lote",
+    start: "Iniciar transferência",
+    cancel: "Cancelar",
+    progress: "Transferindo...",
+    transferring: "Transferindo {table}...",
+    completed: "Transferência concluída",
+    completedWithErrors: "Concluído com {count} tabela com falha | Concluído com {count} tabelas com falha",
+    failed: "Falha na transferência",
+    cancelled: "Transferência cancelada",
+    rowsTransferred: "{count} linhas transferidas",
+    tableProgress: "{current} / {total} tabelas",
+    noSqlConnections: "Nenhuma conexão SQL disponível",
+    selectTables: "Selecione as tabelas para transferir",
+    searchTables: "Pesquisar tabelas...",
+    noTables: "Nenhuma tabela",
+    selectSourceFirst: "Selecione primeiro a conexão e o banco de dados de origem",
+    tableError: "Falha na tabela {table}: {error}",
+    overallProgress: "Progresso geral",
+    dataTransfer: "Transferência de Dados",
+    runInBackground: "Executar em segundo plano",
+    newTask: "Nova transferência",
+    editConfig: "Editar configuração",
+    retry: "Tentar novamente",
+    targetTableBusy: "Outra transferência já está gravando na(s) tabela(s) de destino: {tables}",
+    ownershipTitle: "Confirmar proprietário",
+    ownershipMessage: "O banco de dados de destino não tem estes usuários ou roles proprietários: {owners}. Aplicar o proprietário original pode falhar.",
+    ownershipSkipDetails: "Pular não executará as instruções de alteração de proprietário dos objetos. Os dados das tabelas e outras estruturas continuarão sendo sincronizados.",
+    ownershipTargetOwner: "Confirmar reatribuirá os objetos com proprietários ausentes ao usuário da conexão de destino: {owner}.",
+    ownershipSkip: "Pular",
+    ownershipConfirm: "Confirmar",
+    selectConnection: "Selecionar conexão",
+    selectDatabase: "Selecionar banco de dados",
+    selectSchema: "Selecionar schema",
+    searchConnection: "Pesquisar conexões...",
+    searchDatabase: "Pesquisar bancos de dados...",
+    searchSchema: "Pesquisar schemas...",
+  },
+  tableImport: {
+    title: "Importar Dados da Tabela",
+    target: "Tabela de destino",
+    selectFile: "Selecionar arquivo",
+    changeFile: "Change File",
+    noFileSelected: "No file selected",
+    sourceFile: "Source file",
+    sourceFormat: "Source format",
+    stepSource: "Source",
+    stepOptions: "Options",
+    stepMapping: "Mapping",
+    stepReview: "Review",
+    stepExecution: "Run",
+    formatCsv: "CSV",
+    formatCsvDescription: "Comma-separated text",
+    formatTsv: "TSV",
+    formatTsvDescription: "Tab-separated text",
+    formatDelimited: "Delimited",
+    formatDelimitedDescription: "Custom text delimiter",
+    formatJson: "JSON",
+    formatJsonDescription: "Object or array rows",
+    formatExcel: "Excel",
+    formatExcelDescription: "XLS, XLSX, XLSM",
+    previewRows: "Preview rows",
+    delimiter: "Delimiter",
+    hasHeader: "First row is header",
+    trimValues: "Trim values",
+    emptyStringAsNull: "Empty string as NULL",
+    jsonShape: "JSON rows",
+    jsonShapeAuto: "Auto-detect",
+    jsonShapeObjects: "Objects",
+    jsonShapeArrays: "Arrays",
+    sheet: "Sheet",
+    firstSheet: "First sheet",
+    loadPreview: "Load Preview",
+    reloadPreview: "Reload Preview",
+    previewReady: "{rows} rows, {columns} columns",
+    file: "Arquivo",
+    rows: "Linhas",
+    mapped: "Mapeado",
+    mapping: "Mapeamento de Colunas",
+    sourceColumn: "Origem",
+    targetColumn: "Destino",
+    targetDataType: "Tipo",
+    createColumns: "Colunas a criar",
+    skipColumn: "Pular",
+    preview: "Pré-visualização",
+    mode: "Modo de importação",
+    append: "Anexar dados",
+    truncate: "Truncar e depois importar",
+    progress: "Progresso",
+    start: "Iniciar importação",
+    success: "{count} linhas importadas",
+    back: "Back",
+    next: "Next",
+    truncateWarning: "Existing rows in the target table will be removed before import starts.",
+    requiredUnmapped: "Required target columns are not mapped: {columns}",
+    status_idle: "Ready to import",
+    status_running: "Importing data",
+    status_done: "Import complete",
+    status_error: "Import failed",
+    status_cancelled: "Import cancelled",
+  },
+  dataGenerate: {
+    title: "Geração de dados",
+    target: "Destino",
+    rowCount: "Linhas a gerar",
+    columns: "Colunas",
+    column: "Coluna",
+    type: "Tipo",
+    generator: "Gerador",
+    columnProps: "Propriedades da coluna",
+    databaseObjects: "Objetos do banco",
+    selectTable: "Selecione uma tabela à esquerda",
+    saveProfile: "Salvar perfil",
+    loadProfile: "Carregar perfil",
+    options: "Opções",
+    generateOrder: "Ordem de geração",
+    nextStep: "Próximo",
+    insertSuccess: "{count} linhas inseridas",
+    noData: "No data yet, please configure generation rules first",
+    noResult: "No execution results",
+    regenerate: "Regenerate",
+    first50Rows: "Showing first 50 rows, total {count} rows",
+    resultTitle: "Resultados da execução",
+    successLabel: "{count} bem-sucedidas",
+    failLabel: "{count} falhas",
+    totalLabel: "/ {count} linhas",
+    copyAllSql: "Copy All SQL",
+    prevStep: "Anterior",
+    startInsert: "Start Insert",
+    confirm: "Confirmar",
+    back: "Voltar",
+    reset: "Reset",
+    selectGenerator: "Select a generator...",
+    selectGeneratorHint: "Please select a generator",
+    preview: "Preview",
+    noValue: "(nenhum)",
+    startDate: "Start Date",
+    endDate: "End Date",
+    allDay: "All day",
+    startTime: "Start Time",
+    endTime: "End Time",
+    weekday: "Weekday",
+    all: "All",
+    weekdayOnly: "Weekdays",
+    custom: "Custom",
+    values: "Values",
+    min: "Min",
+    max: "Max",
+    increment: "Incremento",
+    cycle: "Cycle when exceeded",
+    includeDefault: "Include DEFAULT",
+    includeNull: "Include NULL",
+    unique: "Set unique",
+    disableLinks: "Disable data links between columns",
+    imageMode: "Mode",
+    generate: "Generate",
+    fromFolder: "From folder",
+    imageWidth: "Image Width",
+    imageHeight: "Image Height",
+    imageFormat: "Image Format",
+    folderPath: "Folder Path",
+    filterByExtension: "Filter by extensions",
+    errorContinue: "Continue on error",
+    truncateBefore: "Truncate table before generation",
+    useTransaction: "Use transaction",
+    extendedInsert: "Use extended INSERT",
+    ok: "OK",
+    noTablesSelected: "No tables selected",
+    orderHint: "Use arrow buttons to reorder",
+    gen: {
+      general: "General",
+      personal: "Personal",
+      payment: "Payment",
+      business: "Business",
+      location: "Location",
+      product: "Product",
+      computer: "Computer",
+      number: "Number",
+      datetime: "Date Time",
+      date: "Date",
+      time: "Time",
+      sequence: "Sequence",
+      enum: "Enum",
+      text: "Text",
+      image: "Image or Binary",
+      foreign_key: "Foreign Key",
+      uuid: "UUID",
+      regex: "Regex",
+      full_name: "Full Name",
+      gender: "Gender",
+      title: "Title",
+      marital_status: "Marital Status",
+      phone: "Phone",
+      email: "Email",
+      job_title: "Job Title",
+      social_id: "Social ID",
+      payment_method: "Payment Method",
+      credit_card_type: "Credit Card Type",
+      credit_card_number: "Credit Card Number",
+      credit_card_date: "Credit Card Date",
+      company_name: "Company Name",
+      department: "Department",
+      industry: "Industry",
+      address: "Address",
+      city: "City",
+      region: "Region",
+      product_name: "Product Name",
+      product_category: "Product Category",
+      color: "Color",
+      size: "Size",
+      weight_unit: "Weight Unit",
+      barcode: "Barcode",
+      sku: "SKU",
+      ip_address: "IP Address",
+      mac_address: "MAC Address",
+      file_path: "File Path",
+      file_name: "File Name",
+      file_extension: "File Extension",
+      url: "URL",
+      hostname: "Hostname",
+      id_number: "Número de documento",
+    },
+    idTypes: {
+      title: "Tipo de documento",
+      customPattern: "Padrão personalizado",
+      customPatternPlaceholder: "ex.: ([A-Z]{2})-([0-9]{8})",
+      customPatternHint: "Suporta padrões simples como [A-Z] letras, [0-9] dígitos, {n} repetições, hífens",
+      id_card: "CPF chinês",
+      passport: "Passaporte",
+      hk_macau_pass: "Permissão HK/Macau",
+      taiwan_pass: "Permissão Taiwan",
+      uscc: "Código social unificado",
+      bank_card: "Cartão bancário",
+      drivers_license: "Carteira de motorista",
+      custom: "Personalizado",
+    },
+  },
+  tableToolbox: {
+    title: "Ferramentas de dados",
+    generateData: "Gerar dados",
+    importData: "Importar dados",
+    exportData: "Exportar dados",
+    generateDataComingSoon: "Em breve",
+  },
+  sqlFile: {
+    title: "Executar Arquivo SQL",
+    file: "Arquivo",
+    selectSqlFile: "Selecionar arquivo SQL",
+    browse: "Procurar",
+    previewingLines: "Pré-visualizando {count} linhas",
+    previewingFirstLines: "Pré-visualizando as primeiras {count} linhas",
+    target: "Destino",
+    connection: "Conexão",
+    selectConnection: "Selecionar conexão",
+    database: "Banco de dados",
+    selectDatabase: "Selecionar banco de dados",
+    databasePlaceholder: "Nome do banco de dados",
+    options: "Opções",
+    continueOnError: "Continuar em caso de erro",
+    runInBackground: "Executar em segundo plano",
+    cancelling: "Cancelando...",
+    cancel: "Cancelar",
+    execute: "Executar",
+    statement: "Instrução",
+    succeeded: "Bem-sucedido",
+    failed: "Falhou",
+    affectedRows: "Linhas afetadas",
+    currentStatement: "Instrução atual",
+    status: {
+      idle: "Ocioso",
+      started: "Iniciado",
+      running: "Em execução",
+      statementDone: "Instrução concluída",
+      statementFailed: "Instrução falhou",
+      done: "Concluído",
+      error: "Erro",
+      cancelled: "Cancelado",
+    },
+  },
+  diff: {
+    title: "Comparar Esquemas",
+    source: "Origem",
+    target: "Destino",
+    selectConnection: "Selecionar conexão",
+    selectDatabase: "Selecionar banco de dados",
+    selectSchema: "Selecionar schema",
+    ignoreComments: "Ignorar diferenças de comentários",
+    compare: "Comparar",
+    comparing: "Comparando schemas...",
+    noDifferences: "Nenhuma diferença encontrada",
+    table: "Tabela",
+    status: "Status",
+    details: "Detalhes",
+    added: "Adicionado",
+    removed: "Removido",
+    modified: "Modificado",
+    indexes: "Índices",
+    foreignKeys: "Chaves estrangeiras",
+    triggers: "Gatilhos",
+    comments: "Comentários",
+    newTable: "Nova tabela",
+    dropTable: "Excluir tabela",
+    generatedSql: "Sincronizar SQL",
+    copySql: "Copiar SQL",
+    executeSync: "Executar sincronização",
+    syncSuccess: "Sincronização executada com sucesso",
+    swap: "Trocar origem e destino",
+    syncProgress: "Executando: {current}/{total}",
+    syncSummary: "{success} bem-sucedidas, {failed} com falha",
+    connection: "Conexão",
+    database: "Banco de dados",
+    schema: "Schema",
+    recentConfigs: "Configurações Recentes",
+    selectRecentConfig: "Selecionar configuração recente",
+    configSaved: "Configuração salva",
+    configDeleted: "Configuração excluída",
+    sourceObject: "Objeto de origem",
+    targetObject: "Objeto de destino",
+    operation: "Operação",
+    selectedCount: "{selected} selecionados de {total}",
+    saveConfig: "Salvar configuração",
+    loadConfig: "Carregar configuração",
+    options: "Opções",
+    ddlCompare: "Comparação DDL",
+    deployScript: "Script de implantação",
+    deployScriptAll: "Todos os scripts de implantação",
+    deployScriptDesc: "Script SQL para o objeto selecionado",
+    deployScriptAllDesc: "Script SQL para todos os objetos selecionados",
+    copy: "Copiar",
+    execute: "Executar",
+    executeAll: "Executar todos",
+    executeSuccess: "Executado com sucesso",
+    selectObjectToCompare: "Selecione um objeto para ver a comparação DDL",
+    noDdlAvailable: "Nenhum DDL disponível",
+    noDeployScript: "Nenhum script de implantação",
+    noDeployScriptAll: "Nenhum script de implantação para os objetos selecionados",
+    sourceDdl: "DDL de origem",
+    targetDdl: "DDL de destino",
+    objectNotExistsInSource: "Este objeto não existe no banco de dados de origem",
+    objectNotExistsInTarget: "Este objeto não existe no banco de dados de destino",
+    nextStepDeploy: "Próximo (Revisar Implantação)",
+    deployReview: "Revisão de Implantação",
+    backToResult: "Voltar ao Resultado",
+    copyScript: "Copiar Script",
+    exportSql: "Exportar .sql",
+    deployToServer: "Implantar no Servidor",
+    deployConfirmTitle: "Confirmação Final",
+    deployConfirmMessage: "Você está prestes a implantar as seguintes alterações no banco de dados de destino",
+    targetServer: "Servidor de Destino",
+    dbVersion: "Versão do Banco de Dados",
+    targetDatabase: "Banco de Dados de Destino",
+    targetSchema: "Schema de Destino",
+    useTransaction: "Executar em transação (rollback automático em caso de falha)",
+    confirmDeploy: "Confirmar Implantação",
+    exportSuccess: "Exportação bem-sucedida",
+    create: "Criar",
+    delete: "Excluir",
+    modify: "Modificar",
+    cancel: "Cancelar",
+    prevStep: "Anterior",
+    recompare: "Comparar novamente",
+    maximize: "Maximizar",
+    restore: "Restaurar",
+    operationLabel: {
+      modify: "Objetos a modificar",
+      create: "Objetos a criar",
+      delete: "Objetos a excluir",
+      none: "Nenhuma operação",
+    },
+    objectKindLabel: {
+      table: "Tabela",
+      view: "Visão",
+      function: "Função",
+      sequence: "Sequência",
+      rule: "Regra",
+      owner: "Proprietário",
+      index: "Índice",
+      foreignKey: "Chave Estrangeira",
+      trigger: "Gatilho",
+    },
+    noObjectsSelected: "Selecione objetos para implantar",
+    deploySuccess: "Implantação Bem-sucedida",
+    deployFailed: "Implantação Falhou",
+    deploySuccessMessage: "Script SQL executado com sucesso no banco de dados de destino",
+    deployFailedMessage: "Ocorreu um erro durante a execução",
+    affectedRows: "Linhas Afetadas",
+    executedStatements: "Instruções Executadas",
+    serverVersion: "Versão do Servidor",
+    info: "Informações",
+    connType: "Tipo de conexão",
+    connName: "Nome da conexão",
+    host: "Host",
+    port: "Porta",
+    copied: "Copiado para a área de transferência",
+    saveConfigPrompt: "Digite o nome da configuração:",
+    close: "Fechar",
+    searchConnection: "Pesquisar conexões...",
+    searchDatabase: "Pesquisar bancos de dados...",
+    searchSchema: "Pesquisar schemas...",
+  },
+  schemaDiff: {
+    optionsTitle: "Opções de Comparação",
+    selectConfig: "Selecionar configuração",
+    newConfigName: "Nova Configuração",
+    newConfig: "Nova Configuração",
+    renameConfig: "Renomear Configuração",
+    duplicateConfig: "Duplicar Configuração",
+    deleteConfig: "Excluir Configuração",
+    exportConfig: "Exportar Configuração",
+    exportAllConfigs: "Exportar Todas as Configurações",
+    importConfig: "Importar Configuração",
+    importFromFile: "Importar de Arquivo",
+    importFromText: "Importar de Texto",
+    importPlaceholder: "Cole o JSON da configuração...",
+    importInvalidJson: "Formato JSON inválido",
+    configName: "Nome da Configuração",
+    tableFilter: "Filtro de tabela",
+    tableFilterHint: "Corresponde a nomes completos de tabela com regex. Não digite /.../. ^ significa começa com, $ significa termina com, | significa ou.",
+    tableFilterHintShort: "Limitar comparação por regex de nome de tabela",
+    tableFilterHelp: "Ajuda do filtro de tabela",
+    tableFilterHelpRule: "Corresponde a nomes completos de tabela. Não digite /.../.",
+    tableFilterHelpBlank: "Incluir em branco significa todas as tabelas. Pular em branco significa sem exclusões.",
+    tableFilterHelpExample: "^user_ significa começa com user_; _bak$ significa termina com _bak; a|b significa a ou b.",
+    tableIncludePattern: "Comparar apenas tabelas correspondidas",
+    tableIncludePatternPlaceholder: "ex.: ^user_",
+    tableExcludePattern: "Pular tabelas correspondidas",
+    tableExcludePatternPlaceholder: "ex.: _bak$",
+    tableFilterPriority: "Quando ambos correspondem",
+    tableFilterPriorityExclude: "Exclusão vence",
+    tableFilterPriorityInclude: "Inclusão vence",
+    options: {
+      tables: "Comparar tabelas",
+      primaryKeys: "Comparar chaves primárias",
+      foreignKeys: "Comparar chaves estrangeiras",
+      uniqueKeys: "Comparar chaves únicas",
+      checks: "Comparar constraints CHECK",
+      exclusions: "Comparar constraints de exclusão",
+      views: "Comparar visões",
+      functions: "Comparar funções",
+      indexes: "Comparar índices",
+      sequences: "Comparar sequências",
+      triggers: "Comparar gatilhos",
+      rules: "Comparar regras",
+      owners: "Comparar proprietários",
+      cascadeDelete: "Usar CASCADE delete",
+      sequenceLastValues: "Comparar últimos valores de sequência",
+      compareColumnOrder: "Comparar ordem das colunas",
+    },
+  },
+  dataCompare: {
+    title: "Comparar Dados",
+    selectTable: "Selecionar tabela",
+    searchTable: "Pesquisar tabelas...",
+    sourceTables: "Tabelas de origem",
+    targetTable: "Tabela de destino",
+    searchTables: "Pesquisar tabelas...",
+    selectedTables: "{selected}/{total} selecionadas",
+    selectAllTables: "Selecionar tudo",
+    deselectAllTables: "Desmarcar tudo",
+    selectSourceTables: "Selecione primeiro a conexão e o banco de dados de origem, depois escolha as tabelas para comparar",
+    noTables: "Nenhuma tabela disponível para comparação",
+    autoMatchHint: "O modo em lote corresponde automaticamente as tabelas de destino pelo mesmo nome",
+    matchedTables: "{matched}/{total} tabelas correspondidas",
+    missingTargetTables: "Tabelas de destino de mesmo nome ausentes: {tables}",
+    keyColumns: "Colunas-Chave",
+    keyColumnsPlaceholder: "Colunas primárias ou únicas separadas por vírgula",
+    keyColumnsAutoHint: "Deixe em branco para detectar automaticamente as chaves primárias na comparação de tabela única, ou por tabela na comparação em lote.",
+    rowCounts: "Origem com {source} linhas, destino com {target} linhas; comparação completa concluída",
+    previewLimitOption: "Pré-visualizar {count}",
+    compare: "Comparar Dados",
+    summary: "{added} adicionados, {removed} removidos, {modified} modificados",
+    batchSummary: "{tables} tabelas comparadas: {different} diferentes, {same} idênticas, {failed} com falha; {added} adicionados, {removed} removidos, {modified} modificados",
+    comparingTable: "Comparando {current}/{total}: {table}",
+    keyColumnsInline: "Colunas-chave: {columns}",
+    selectedInline: "Selecionados {selected}/{total}",
+    selectedSummary: "Selecionados: {added} adicionados, {removed} removidos, {modified} modificados",
+    selectAllKind: "Selecionar todos {kind}",
+    clearKind: "Limpar {kind}",
+    clearSelection: "Limpar todas as seleções",
+    showAllRows: "Mostrar todas as {count}",
+    showLessRows: "Mostrar menos",
+    remainingRows: "{count} linhas a mais ocultas na pré-visualização",
+    planningSync: "Atualizando plano de sincronização...",
+    noSelectedDifferences: "Nenhuma diferença foi selecionada para execução",
+    planSummary: "Plano: {inserts} inserções, {updates} atualizações, {deletes} exclusões, {statements} instruções",
+    statusDifferent: "Diferente",
+    statusSame: "Igual",
+    statusError: "Falhou",
+    noKeyColumns: "Selecione pelo menos uma coluna-chave",
+    missingKeyColumns: "As colunas-chave devem existir nas tabelas de origem e de destino: {columns}",
+    noCommonColumns: "As tabelas de origem e de destino não têm colunas em comum para comparar",
+    targetTableMissing: "Tabela de destino não encontrada: {table}",
+    noComparableTables: "Nenhuma tabela comparável encontrada. Verifique se existem tabelas de destino de mesmo nome.",
+    noDifferences: "Os dados são idênticos, nenhum SQL de sincronização é necessário",
+    syncSuccess: "Sincronização de dados executada com sucesso",
+  },
+  settings: {
+    title: "Configurações",
+    editorTab: "Editor",
+    sqlFormatterTab: "Formatador SQL",
+    sqlFormatterImport: "Importar configuração",
+    sqlFormatterExport: "Exportar configuração",
+    sqlFormatterImportSuccess: "Configuração do formatador importada.",
+    sqlFormatterCopyJson: "Copiar JSON",
+    sqlFormatterCopyJsonSuccess: "JSON copiado.",
+    sqlFormatterCopyJsonFailed: "Falha ao copiar: {message}",
+    sqlFormatterJsonEditorLoadFailed: "Falha ao carregar o editor JSON. Alternado para uma entrada básica: {message}",
+    sqlFormatterRestoreDefaults: "Restaurar padrões",
+    sqlFormatterFormMode: "Formulário",
+    sqlFormatterJsonMode: "JSON",
+    sqlFormatterKeywordCase: "Maiúsculas/minúsculas de palavras-chave",
+    sqlFormatterFunctionCase: "Maiúsculas/minúsculas de funções",
+    sqlFormatterDataTypeCase: "Maiúsculas/minúsculas de tipos de dados",
+    sqlFormatterIdentifierCase: "Maiúsculas/minúsculas de identificadores",
+    sqlFormatterCaseUpper: "Maiúsculas",
+    sqlFormatterCaseLower: "Minúsculas",
+    sqlFormatterCasePreserve: "Preservar",
+    sqlFormatterIndent: "Recuo",
+    sqlFormatterIndentSpaces: "Espaços",
+    sqlFormatterIndentTabs: "Tabulações",
+    sqlFormatterTabWidth: "Largura do tab",
+    sqlFormatterIndentStyle: "Estilo de recuo",
+    sqlFormatterIndentStyleStandard: "Padrão",
+    sqlFormatterIndentStyleTabularLeft: "Tabular esquerda",
+    sqlFormatterIndentStyleTabularRight: "Tabular direita",
+    sqlFormatterLogicalOperatorNewline: "Quebra de linha no operador lógico",
+    sqlFormatterLogicalBefore: "Antes do operador",
+    sqlFormatterLogicalAfter: "Depois do operador",
+    sqlFormatterExpressionWidth: "Largura da expressão",
+    sqlFormatterLinesBetweenQueries: "Linhas entre consultas",
+    sqlFormatterDenseOperators: "Operadores compactos",
+    sqlFormatterNewlineBeforeSemicolon: "Ponto e vírgula em nova linha",
+    sqlFormatterAdvancedOptions: "Opções avançadas",
+    sqlFormatterParams: "Parâmetros",
+    sqlFormatterParamTypes: "Tipos de parâmetro",
+    sqlFormatterEditorShortcuts: "Atalhos",
+    sqlFormatterShortcutAction: "Ação",
+    sqlFormatterShortcutEnabled: "Ativo",
+    sqlFormatterShortcutWindows: "Windows",
+    sqlFormatterShortcutLinux: "Linux",
+    sqlFormatterShortcutMacos: "macOS",
+    sqlFormatterShortcutFind: "Localizar",
+    sqlFormatterShortcutReplace: "Substituir",
+    sqlFormatterShortcutIndentMore: "Aumentar recuo",
+    sqlFormatterShortcutIndentLess: "Reduzir recuo",
+    sqlFormatterShortcutDuplicateLine: "Duplicar linha atual",
+    sqlFormatterShortcutDeleteLine: "Excluir linha atual",
+    sqlFormatterShortcutMoveLine: "Mover linha",
+    sqlFormatterShortcutMoveLineUp: "Mover linha para cima",
+    sqlFormatterShortcutMoveLineDown: "Mover linha para baixo",
+    sqlFormatterShortcutCopyLine: "Copiar linha",
+    sqlFormatterShortcutCopyLineUp: "Copiar linha para cima",
+    sqlFormatterShortcutCopyLineDown: "Copiar linha para baixo",
+    sqlFormatterShortcutUndo: "Desfazer",
+    sqlFormatterShortcutRedo: "Refazer",
+    sqlFormatterShortcutSelectAll: "Selecionar tudo",
+    sqlFormatterShortcutFormatJson: "Formatar JSON",
+    sqlFormatterShortcutApply: "Aplicar configuração",
+    sqlFormatterConfigErrorInvalidJson: "JSON inválido.",
+    sqlFormatterConfigErrorObject: "A configuração deve ser um objeto JSON.",
+    sqlFormatterConfigErrorVersion: "Versão de configuração não compatível.",
+    sqlFormatterConfigErrorFormatter: "Formatador não compatível.",
+    sqlFormatterConfigErrorUnsupportedParams: "A substituição params não é compatível. A formatação SQL não substituirá marcadores.",
+    sqlFormatterConfigErrorOptionsObject: "As opções de configuração devem ser um objeto JSON.",
+    sqlFormatterConfigErrorEditorObject: "A configuração do editor deve ser um objeto JSON.",
+    sqlFormatterConfigErrorEditorScope: "Escopo de editor não compatível.",
+    sqlFormatterConfigErrorEditorPlatforms: "Plataformas de editor inválidas.",
+    sqlFormatterConfigErrorEditorShortcutsArray: "Os atalhos do editor devem ser um array.",
+    sqlFormatterConfigErrorEditorShortcutValue: "Atalho de editor inválido.",
+    sqlFormatterConfigErrorUnknownOption: "Opção desconhecida do formatador: {option}.",
+    sqlFormatterConfigErrorInvalidOptionValue: "Valor inválido para {option}.",
+    sqlFormatterConfigErrorUnknownEditorShortcut: "Atalho de editor desconhecido: {shortcut}.",
+    sqlFormatterConfigErrorInvalidEditorShortcut: "Atalho de editor inválido: {shortcut}.",
+    sqlFormatterConfigErrorDuplicateEditorShortcut: "Atalho de editor duplicado: {shortcut}.",
+    sqlFormatterConfigErrorInvalidConfig: "Configuração do formatador inválida.",
+    appearanceTab: "Aparência",
+    navigationTab: "Navegação",
+    dataTab: "Dados",
+    tunnelsTab: "Túneis",
+    tunnelsDescription: "Configurações reutilizáveis de túneis SSH / proxy / HTTP. Configure uma vez e selecione o perfil na aba de túnel de uma conexão; as edições aqui se aplicam a todas as conexões que usam o perfil.",
+    tunnelsEmpty: "Ainda não há perfis de túnel. Crie um aqui e selecione-o nas configurações de túnel de uma conexão.",
+    tunnelsAddSsh: "Adicionar SSH",
+    tunnelsAddProxy: "Adicionar proxy",
+    tunnelsAddHttp: "Adicionar túnel HTTP",
+    tunnelsProfileName: "Nome do perfil",
+    tunnelsProfileNamePlaceholder: "ex.: Bastion do escritório",
+    tunnelsDelete: "Excluir",
+    tunnelsUnnamedProfile: "Perfil sem nome",
+    tunnelsSave: "Salvar",
+    tunnelsReset: "Redefinir",
+    tunnelsSaved: "Perfis de túnel salvos",
+    tunnelsSaveFailed: "Falha ao salvar os perfis de túnel: {message}",
+    tunnelsUnsavedHint: "Alterações não salvas",
+    redisTab: "Redis",
+    shortcutsTab: "Atalhos",
+    snippetsTab: "Snippets",
+    syncTab: "Sincronização",
+    aiTab: "IA",
+    mcpTab: "MCP",
+    jdbcTab: "Drivers JDBC",
+    securityTab: "Segurança",
+    aboutTab: "Sobre",
+    fontFamily: "Família da fonte",
+    uiFontFamily: "Fonte da interface",
+    uiFontAppDefault: "Padrão do DBX",
+    uiFontSystemDefault: "Padrão do sistema",
+    uiFontFamilyDescription: "Aplica-se à barra superior, abas, barra lateral, diálogos e demais UI fora do editor.",
+    selectFont: "Selecionar fonte...",
+    searchFont: "Pesquisar fontes...",
+    loadingFonts: "Carregando fontes...",
+    noFontsFound: "Nenhuma fonte encontrada",
+    useCustomFont: "Usar “{font}”",
+    languageTitle: "Idioma / 语言",
+    fontSize: "Tamanho da fonte",
+    toolbarTitle: "Barra de ferramentas",
+    toolbarHiddenHint: "Alguns botões ocultos ou excedentes aparecerão no menu «Mais».",
+    uiScale: "Escala da UI",
+    uiScaleDescription: "Dimensione toda a UI do desktop para telas de alta resolução (high-DPI). As alterações são aplicadas imediatamente e restauradas na próxima inicialização.",
+    theme: "Tema",
+    selectTheme: "Selecionar tema...",
+    colorTheme: "Tema de cores",
+    selectColorTheme: "Selecionar tema de cores...",
+    themePalettePearl: "Branco",
+    themePaletteMist: "Cinza névoa",
+    themePaletteGraphite: "Cinza titânio",
+    themePaletteCobalt: "Azul cobalto",
+    themePaletteSage: "Verde sálvia",
+    themePaletteAmber: "Amarelo quente",
+    themePaletteBlush: "Rosa sakura",
+    themePaletteVscode: "VS Code",
+    themePaletteIdea: "IDEA",
+    themePaletteXcode: "Xcode",
+    themePaletteJetbrains: "JetBrains",
+    themePaletteCursor: "Cursor",
+    themePaletteClaude: "Claude Code",
+    followAppTheme: "Seguir o tema do app",
+    appLayout: "Layout da interface",
+    appLayoutSeparated: "Separado moderno",
+    appLayoutSeparatedDescription: "Separação clara de painéis com abas em estilo de bloco.",
+    appLayoutClassic: "Clássico compacto",
+    appLayoutClassicDescription: "Barra de abas contínua com cabeçalhos de painel compactos.",
+    iconTheme: "Estilo do ícone e do logo",
+    iconThemeDefault: "Padrão",
+    iconThemeDefaultDescription: "Usar o ícone colorido do app DBX.",
+    iconThemeBlack: "Preto",
+    iconThemeBlackDescription: "Use o logo preto da DBX no app.",
+    iconThemeBlackDescriptionMac: "No app, usa o logo preto; o Dock usa base preta e a barra de menus segue o sistema.",
+    showTrayIcon: "Mostrar ícone na bandeja/barra de menus",
+    showTrayIconDescription: "Quando desativado, nenhum ícone é exibido, mas fechar a janela ainda oculta o DBX em segundo plano como antes.",
+    quitOnClose: "Sair ao fechar a janela",
+    quitOnCloseDescription: "Quando ativado, o botão de fechar encerra o DBX completamente em vez de minimizar para a bandeja.",
+    closeActionPromptTitle: "Fechar janela",
+    closeActionPromptDescription: "Escolha o que acontece ao clicar no botão de fechar. Você pode alterar depois em Configurações → Aparência.",
+    closeActionQuit: "Sair do DBX",
+    closeActionMinimize: "Minimizar para a bandeja",
+    updateNotificationsEnabled: "Ativar lembretes de atualização",
+    updateNotificationsEnabledDescription: "Quando desativado, o DBX não verificará automaticamente atualizações do app ou dos drivers nem mostrará indicadores. Verificações manuais continuam disponíveis.",
+    updateDownloadSource: "Fonte de download de atualização",
+    updateDownloadSourceDescription: "Escolha de onde os instaladores de atualização no aplicativo são baixados. A fonte oficial é recomendada; CNB ou AtomGit podem ser mais rápidos em redes da China continental.",
+    updateDownloadSourceOfficial: "Fonte oficial (recomendada)",
+    updateDownloadSourceCnb: "CNB",
+    updateDownloadSourceAtomgit: "AtomGit",
+    debugLoggingEnabled: "Ativar logs de depuração",
+    debugLoggingEnabledDescription: "Registra logs locais de diagnóstico do lado do usuário ao investigar relatos. Desativado por padrão.",
+    duckDbWorkerProcessIsolation: "Modo de isolamento de processo do DuckDB (experimental)",
+    duckDbWorkerProcessIsolationDescription: "Executa consultas DuckDB em um processo worker separado. Se uma consulta longa não responder ao cancelamento, o DBX pode encerrar o processo worker para liberar o bloqueio do arquivo de banco de dados.",
+    duckDbWorkerMaxProcesses: "Máximo de workers simultâneos do DuckDB",
+    duckDbWorkerMaxProcessesDescription: "Limita quantos processos worker do DuckDB o DBX pode executar ao mesmo tempo. Intervalo: 1-16. Padrão: 4.",
+    duckDbWorkerProcessIsolationRestartRequired: "Reinicie o DBX para que esta alteração entre em vigor.",
+    restartDbx: "Reiniciar DBX",
+    restartDbxFailed: "Falha ao reiniciar o DBX: {error}",
+    debugLogsCopy: "Copiar logs",
+    debugLogsCopied: "Copiado",
+    debugLogsDownload: "Baixar logs",
+    debugLogsDownloaded: "Baixado",
+    debugLogsClear: "Limpar logs",
+    tableStructureSection: "Estrutura da tabela",
+    dataGridDisplay: "Exibição da grade de dados",
+    showColumnCommentsInHeader: "Mostrar comentários de coluna sob os nomes",
+    showColumnCommentsInHeaderDescription: "Exibir comentários de colunas da tabela diretamente abaixo dos nomes das colunas da grade.",
+    showColumnTypesInHeader: "Mostrar tipos de coluna sob os nomes",
+    showColumnTypesInHeaderDescription: "Exibir o tipo de dado de cada coluna diretamente abaixo dos nomes das colunas da grade.",
+    compactColumnHeaderActions: "Ferramentas compactas no cabeçalho da coluna",
+    compactColumnHeaderActionsDescription: "Mover as ferramentas de formatação e filtro local para um menu de mais opções para que os nomes das colunas tenham prioridade.",
+    dataGridQuickEntry: "Entrada rápida na grade",
+    dataGridQuickEntryDescription: "Quando ativado, editar uma célula ou preencher a linha vazia inferior salva no banco de dados assim que o foco sai. Ajuda na entrada frequente, mas pode causar gravações acidentais.",
+    infiniteScroll: "Carregamento por rolagem infinita",
+    autoCalculateTotalRows: "Calcular automaticamente o total de linhas",
+    autoCalculateTotalRowsDescription: "Executa COUNT(*) automaticamente após cada consulta para mostrar o total de linhas correspondentes. Desativado por padrão para manter consultas grandes rápidas; você pode calculá-lo quando quiser no rodapé dos resultados.",
+    infiniteScrollDescription: "Carregar automaticamente a próxima página de dados ao rolar até o final da tabela.",
+    infiniteScrollMaxRows: "Máximo de linhas em rolagem infinita",
+    infiniteScrollMaxRowsDescription: "Número máximo de linhas a carregar no modo de rolagem infinita (1000–50000).",
+    tableColumnTemplateFields: "Campos predefinidos para novas tabelas",
+    tableColumnTemplateFieldsDescription: "Escolha um tipo de banco de dados e configure os tipos dos campos predefinidos usados ao criar novas tabelas.",
+    tableColumnTemplateAdd: "Adicionar campo",
+    tableColumnTemplateColumn: "Campo",
+    tableColumnTemplateDatabase: "Banco de dados",
+    tableColumnTemplateType: "Tipo",
+    tableColumnTemplateLength: "Comprimento",
+    tableColumnTemplateDefault: "Padrão",
+    tableColumnTemplateNoPresetType: "Sem tipo predefinido",
+    tableColumnTemplateRequired: "Obrigatório",
+    tableColumnTemplateComment: "Descrição",
+    tableColumnTemplateDragHandle: "Arraste para reordenar",
+    sidebarActivation: "Ativação da barra lateral",
+    sidebarActivationSingle: "Clique único",
+    sidebarActivationSingleDescription: "Abrir itens acionáveis da barra lateral com um clique.",
+    sidebarActivationDouble: "Clique duplo",
+    sidebarActivationDoubleDescription: "Clique único seleciona linhas; clique duplo abre itens.",
+    sidebarObjectDisplay: "Layout de objetos da barra lateral",
+    sidebarObjectDisplayGrouped: "Visualização avançada",
+    sidebarObjectDisplayGroupedDescription: "Agrupar objetos por tabelas, views, procedures e funções para bancos de dados com mais tipos de objetos.",
+    sidebarObjectDisplaySimple: "Visualização simples",
+    sidebarObjectDisplaySimpleDescription: "Listar tabelas e views diretamente sob cada banco de dados ou schema para reduzir os níveis intermediários.",
+    autoSelectActiveSidebarNode: "Sempre selecionar o item aberto",
+    autoSelectActiveSidebarNodeDescription: "Ao alternar abas, selecionar a tabela, coleção ou arquivo SQL correspondente visível na barra lateral.",
+    openTabsRestoreMode: "Restaurar abas ao iniciar",
+    openTabsRestoreModeDescription: "Escolha como o DBX restaura as abas que estavam abertas na última vez.",
+    openTabsRestoreModeAll: "Manter todas as abas",
+    openTabsRestoreModePinned: "Apenas abas fixadas",
+    openTabsRestoreModeNone: "Não manter abas",
+    openTabsRestoreModeHint: "As abas fixadas permanecem no lado esquerdo da barra de abas e funcionam bem como pontos de entrada frequentes.",
+    disconnectTabHandlingMode: "Abas após desconectar",
+    disconnectTabHandlingModeDescription: "Escolha como as abas relacionadas devem ser tratadas após fechar uma conexão ou banco de dados.",
+    disconnectTabHandlingModeCloseTabs: "Fechar todas as abas",
+    disconnectTabHandlingModeCloseTabsDescription: "Fechar todas as abas relacionadas à conexão ou ao banco de dados.",
+    disconnectTabHandlingModeKeepTabsClearResults: "Fechar abas de objetos, manter abas SQL",
+    disconnectTabHandlingModeKeepTabsClearResultsDescription: "Fechar abas de dados de tabela, navegador de objetos e estrutura, mantendo as abas de consultas SQL e o texto SQL, e também limpar o estado de execução e as sessões de resultados.",
+    disconnectTabHandlingModeKeepTabsKeepResults: "Não fechar abas relacionadas",
+    disconnectTabHandlingModeKeepTabsKeepResultsDescription: "Manter abas relacionadas, texto SQL e resultados atuais sem limpeza adicional.",
+    reuseDataTab: "Reutilizar aba de dados",
+    reuseDataTabDescription: "Ao clicar em uma tabela na barra lateral, reutilizar a aba de dados existente em vez de criar uma nova a cada vez.",
+    sidebarHiddenTablePrefixes: "Prefixos de nome de tabela ocultos",
+    sidebarHiddenTablePrefixesDescription: "Um prefixo por linha. Apenas os rótulos de tabela, view e coleção da barra lateral são encurtados; tooltips e ações ainda usam o nome completo.",
+    sidebarHiddenTablePrefixesPlaceholder: "Exemplo:\nODS_\nT8Y2_LONG_",
+    sidebarTablePageSize: "Tamanho da página da barra lateral",
+    sidebarTablePageSizeDescription: "Número máximo de tabelas/objetos carregados por página na árvore lateral. Aumente se tiver muitas tabelas para reduzir páginas.",
+    sidebarTableSearchEnabled: "Ativar busca de tabelas por banco",
+    sidebarTableSearchEnabledDescription: "Mostra uma busca local sob bancos, schemas ou grupos de tabelas expandidos para filtrar tabelas separadamente.",
+    sidebarHideTableComments: "Ocultar comentários de tabela na barra lateral",
+    sidebarHideTableCommentsDescription: "Ocultar os comentários inline de tabela/view exibidos ao lado dos nomes na árvore da barra lateral para economizar espaço horizontal.",
+    sidebarAllowHorizontalScroll: "Permitir rolagem horizontal da barra lateral",
+    sidebarAllowHorizontalScrollDescription: "Mostrar nomes longos de tabelas, views e coleções por completo, permitindo a rolagem horizontal da barra lateral.",
+    snippetsDescription: "Personalize os modelos de snippets SQL acionados no editor.",
+    snippetsAdd: "Adicionar snippet",
+    snippetsLabel: "Rótulo",
+    snippetsPrefix: "Prefixo",
+    snippetsStatus: "Status",
+    snippetsEnabled: "Ativo",
+    snippetsDisabled: "Desativado",
+    snippetsToggle: "Ativar ou desativar snippet",
+    snippetsBody: "Corpo SQL",
+    snippetsLabelPlaceholder: "ex.: select *",
+    snippetsPrefixPlaceholder: "ex.: sel",
+    snippetsBodyPlaceholder: "SELECT *\nFROM table\nLIMIT 100;",
+    snippetsRestoreDefaults: "Restaurar padrões",
+    snippetsAddTitle: "Adicionar snippet",
+    snippetsEditTitle: "Editar snippet",
+    syncWebDavTitle: "Sincronização WebDAV",
+    syncWebDavDescription: "Envie ou restaure um snapshot do DBX, incluindo a biblioteca SQL salva, a partir de um serviço de armazenamento compatível com WebDAV.",
+    syncEndpoint: "URL do WebDAV",
+    syncUsername: "Nome de usuário",
+    syncPassword: "Senha",
+    syncPasswordPlaceholder: "Digite a senha",
+    syncClearSavedPassword: "Limpar senha salva",
+    syncRememberWebDavPassword: "Lembrar senha do app WebDAV",
+    syncSavedPassword: "(salva)",
+    syncRememberWebDavPasswordDescription: "A senha é criptografada e armazenada apenas neste dispositivo. Ela não é sincronizada para o WebDAV e não substitui a senha de sincronização.",
+    syncRemotePath: "Caminho remoto do snapshot",
+    syncRemotePathDescription: "O DBX criará as pastas pai ausentes ao enviar.",
+    syncSecretNotice: "Por padrão, o DBX sincroniza apenas detalhes de conexão e configurações. Senhas de banco de dados, senhas SSH, senhas de proxy, strings de conexão e chaves de API de IA permanecem locais.",
+    syncSecrets: "Sincronizar segredos criptografados",
+    syncSecretsDescription: "Quando ativado, o DBX criptografa senhas de banco de dados, senhas SSH e chaves de API de IA antes de enviá-las para o WebDAV.",
+    syncSecretsPassphrase: "Senha de sincronização",
+    syncSecretsPassphraseDescription: "Esta senha é usada apenas para criptografar e restaurar dados sensíveis. O DBX não a salva; digite-a novamente em cada dispositivo.",
+    syncTest: "Testar",
+    syncUpload: "Enviar",
+    syncDownload: "Baixar",
+    syncTestSuccess: "O destino WebDAV está acessível.",
+    syncUploadSuccess: "Enviados {bytes} bytes para {path}.",
+    syncAutoUpload: "Enviar snapshots automaticamente",
+    syncAutoUploadInterval: "A cada",
+    syncAutoUploadMinutes: "minutos",
+    syncAutoUploadDescription: "Executa enquanto o DBX está aberto. Downloads ainda exigem confirmação manual para evitar substituir SQL salvos localmente.",
+    syncAutoUploadSuccess: "Enviados automaticamente {bytes} bytes para {path}.",
+    syncDownloadSuccess: "Baixados e aplicados {bytes} bytes de {path}.",
+    syncSecretsApplied: "Os segredos criptografados foram restaurados.",
+    syncSecretsSkipped: "Havia segredos criptografados, mas não foram restaurados.",
+    syncDownloadConfirm: "Baixar e aplicar o snapshot remoto do DBX? Os metadados locais e os SQL salvos serão substituídos.",
+    apply: "Aplicar",
+    applyAndClose: "Aplicar e fechar",
+    reset: "Redefinir",
+    resetDefaults: "Redefinir padrões",
+    resetAllDefaults: "Redefinir todos os padrões",
+    save: "Salvar",
+    cancel: "Cancelar",
+    executeMode: "Modo de execução (Cmd+Enter)",
+    executeModeAll: "Executar todo o SQL",
+    executeModeCurrent: "Executar instrução no cursor",
+    showExecutionTargetPicker: "Mostrar seletor de destino",
+    showExecutionTargetPickerDescription: "Quando ativado, executar sem seleção permite escolher entre a instrução atual e todo o SQL.",
+    showStatementRunButtons: "Mostrar botões de execução laterais",
+    showStatementRunButtonsDescription: "Mostra botões para executar cada instrução na margem do editor SQL. Atalhos de teclado e execução pelo menu de contexto continuam funcionando quando desativado.",
+    showCurrentStatementFrame: "Mostrar moldura da instrução atual",
+    showCurrentStatementFrameDescription: "Quando ativado, o editor SQL desenha um contorno ao redor da instrução executável atual; quando desativado, o contorno fica oculto.",
+    showInsertValueHints: "Mostrar dicas de colunas em VALUES de INSERT",
+    showInsertValueHintsDescription: "Quando ativado, o editor SQL mostra o nome da coluna ao lado de cada valor em cláusulas INSERT ... VALUES.",
+    previewStatementRunButton: "Botão de execução de instrução na prévia",
+    wordWrap: "Quebra de linha",
+    wordWrapDescription: "Quebrar linhas SQL longas dentro da largura do editor",
+    vimMode: "Modo Vim",
+    vimModeDescription: "Usar edição modal no estilo Vim no editor SQL",
+    autoCloseBrackets: "Fechar parênteses automaticamente",
+    autoCloseBracketsDescription: "Inserir automaticamente parênteses e aspas de fechamento ao digitar os de abertura",
+    sqlSemanticDiagnosticsEnabled: "Diagnóstico semântico de SQL",
+    sqlSemanticDiagnosticsEnabledDescription: "Quando ativado, o editor relata problemas semânticos como tabelas e colunas desconhecidas. Desative para reduzir a análise e verificações de metadados em SQL grande.",
+    confirmDangerousSqlExecution: "Confirmar antes de SQL perigoso",
+    confirmDangerousSqlExecutionDescription: "Quando desativado, ALTER, DROP, DELETE, TRUNCATE e outros SQL perigosos são executados sem a caixa de diálogo de aviso.",
+    confirmUnsavedSqlClose: "Confirmar antes de fechar SQL não salvo",
+    confirmUnsavedSqlCloseDescription: "Quando desativado, abas SQL com edições não salvas são fechadas ou o app é encerrado sem a caixa de diálogo de confirmação de salvamento.",
+    sqlVariableSyntax: "Substituição de variáveis e espaços reservados SQL",
+    sqlVariableSyntaxDescription: "Escolha quais sintaxes de variáveis e espaços reservados o DBX substitui antes de executar SQL, por tipo de banco de dados. Todas ativadas por padrão.",
+    sqlVariableSyntax_positional: "Espaço reservado posicional",
+    sqlVariableSyntax_positionalDescription: "Solicita um valor para substituir cada espaço reservado posicional em ordem.",
+    sqlVariableSyntax_named: "Espaço reservado nomeado",
+    sqlVariableSyntax_namedDescription: "Solicita um valor para substituir os espaços reservados nomeados.",
+    sqlVariableSyntax_shell: "Espaço reservado estilo shell",
+    sqlVariableSyntax_shellDescription: "Solicita um valor para substituir os espaços reservados de estilo shell.",
+    sqlVariableSyntax_mybatis: "Espaço reservado estilo MyBatis",
+    sqlVariableSyntax_mybatisDescription: "Solicita um valor para substituir os espaços reservados de estilo MyBatis.",
+    sqlVariableSyntax_sqlserver: "Espaço reservado estilo SQL Server",
+    sqlVariableSyntax_sqlserverDescription: "Solicita um valor para substituir os espaços reservados de estilo SQL Server (podem colidir com variáveis de sessão).",
+    sqlVariableSyntax_atSet: "Expansão de variáveis inline",
+    sqlVariableSyntax_atSetDescription: "Expande as declarações de variáveis inline e substitui seus valores antes de executar.",
+    autoAliasTables: "Adicionar alias de tabela automaticamente",
+    autoAliasTablesDescription: "Ao escolher uma tabela em FROM ou JOIN, insere um alias gerado como order_items AS oi.",
+    redisScanPageSize: "Contagem de scan do Redis",
+    redisScanPageSizeDescription: "Chaves solicitadas por página do Redis SCAN ao navegar pelas chaves.",
+    redisScanPageSizeOption: "{count} chaves",
+    exportBatchSize: "Tamanho do lote de exportação",
+    exportBatchSizeDescription: "Linhas buscadas por lote ao exportar dados da tabela (100-100000).",
+    exportRowLimitEnabled: "Limitar linhas exportadas",
+    exportRowLimitEnabledDescription: "Quando ativado, as exportações de resultados de consulta e dados de tabela param no limite de linhas abaixo.",
+    exportRowLimit: "Limite de linhas da exportação",
+    exportRowLimitDescription: "Máximo de linhas para exportações de resultados de consulta e dados de tabela.",
+    exportRowLimitUnlimited: "Ilimitado",
+    queryExportKeysetOptimizationEnabled: "Tentar otimização keyset",
+    queryExportKeysetOptimizationEnabledDescription: "Aplica-se apenas a consultas de tabela única reconhecidas com segurança; consultas complexas recuam automaticamente.",
+    exportSection: "Exportar",
+    shortcutExecuteSql: "Executar SQL",
+    shortcutFind: "Localizar",
+    shortcutReplace: "Substituir",
+    shortcutSaveSql: "Salvar SQL",
+    shortcutAcceptCompletion: "Aceitar autocompletar",
+    shortcutFormatSql: "Formatar SQL",
+    shortcutToggleLineComment: "Alternar comentário de linha",
+    shortcutIndentMore: "Aumentar recuo",
+    shortcutIndentLess: "Reduzir recuo",
+    shortcutDuplicateLine: "Duplicar linha atual",
+    shortcutDeleteLine: "Excluir linha atual",
+    shortcutMoveLineUp: "Mover linha para cima",
+    shortcutMoveLineDown: "Mover linha para baixo",
+    shortcutCopyLineUp: "Copiar linha para cima",
+    shortcutCopyLineDown: "Copiar linha para baixo",
+    shortcutUndo: "Desfazer",
+    shortcutRedo: "Refazer",
+    shortcutSelectAll: "Selecionar tudo",
+    shortcutCopyCurrentRow: "Copiar linha de dados atual",
+    shortcutDeleteCurrentRow: "Excluir linha de dados atual",
+    shortcutNewQuery: "Nova consulta",
+    shortcutOpenSettings: "Abrir configurações",
+    shortcutCloseTab: "Fechar aba",
+    shortcutToggleSidebar: "Alternar barra lateral",
+    shortcutFocusSearch: "Focar na pesquisa",
+    shortcutQuickOpen: "Abrir rapidamente (pesquisar todos os objetos do banco de dados)",
+    shortcutSwitchToPreviousTab: "Alternar para a aba anterior",
+    shortcutSwitchToNextTab: "Alternar para a próxima aba",
+    shortcutSwitchToTab1: "Alternar para a aba 1",
+    shortcutSwitchToTab2: "Alternar para a aba 2",
+    shortcutSwitchToTab3: "Alternar para a aba 3",
+    shortcutSwitchToTab4: "Alternar para a aba 4",
+    shortcutSwitchToTab5: "Alternar para a aba 5",
+    shortcutSwitchToTab6: "Alternar para a aba 6",
+    shortcutSwitchToTab7: "Alternar para a aba 7",
+    shortcutSwitchToTab8: "Alternar para a aba 8",
+    shortcutSwitchToTab9: "Alternar para a aba 9",
+    shortcutZoomInUi: "Aumentar zoom da UI",
+    shortcutZoomOutUi: "Diminuir zoom da UI",
+    shortcutResetUiZoom: "Redefinir zoom da UI",
+    shortcutRefreshData: "Atualizar dados",
+    shortcutToggleTranspose: "Alternar visualização transposta",
+    shortcutCancelSearch: "Cancelar pesquisa",
+    shortcutCopySidebarSelection: "Copiar seleção da barra lateral",
+    shortcutPasteSidebarSelection: "Colar na barra lateral",
+    shortcutEditSidebarConnection: "Editar conexão da barra lateral",
+    shortcutSendSelectionToAi: "Enviar seleção para IA",
+    shortcutScopeGlobal: "Global",
+    shortcutScopeEditor: "Editor SQL",
+    shortcutScopeGrid: "Grade de dados",
+    shortcutScopeSearch: "Campos de pesquisa",
+    shortcutScopeSidebar: "Barra lateral",
+    shortcutPressShortcut: "Pressione o atalho",
+    shortcutSearchPlaceholder: "Pesquisar atalhos",
+    shortcutSearchNoResults: "Nenhum atalho corresponde à pesquisa.",
+    shortcutConflict: "Este atalho conflita com outra ação no mesmo escopo.",
+    shortcutClear: "Limpar atalho",
+    preview: "Pré-visualização ao vivo",
+    customTheme: "Tema personalizado",
+    customThemeConfigure: "Configurar tema personalizado",
+    customThemeTitle: "Configuração do tema personalizado",
+    customThemeMyThemes: "Meus temas",
+    customThemeNewTheme: "Novo tema",
+    customThemeVisualEdit: "Editor visual",
+    customThemeJsonConfig: "Configuração JSON",
+    customThemeLivePreview: "Pré-visualização ao vivo",
+    customThemePreviewExample: "Exemplo de consulta",
+    customThemePreset: "Tema predefinido",
+    customThemeSelectPreset: "Selecionar tema predefinido...",
+    customThemeApply: "Aplicar",
+    customThemePasteImport: "Importar colado",
+    customThemeExportJson: "Exportar JSON",
+    customThemeSaveAndApply: "Salvar e aplicar",
+    customThemeKeyword: "Palavra-chave",
+    customThemeField: "Campo/Variável",
+    customThemeFunction: "Função",
+    customThemeString: "String",
+    customThemeNumber: "Número",
+    customThemeComment: "Comentário",
+    customThemeTable: "Tabela",
+    customThemeOperator: "Operador",
+    customThemeType: "Tipo",
+    customThemeBuiltin: "Integrado",
+    customThemeBackground: "Plano de fundo",
+    customThemeForeground: "Primeiro plano",
+    customThemeDefaultName: "Tema personalizado",
+    customThemeCopySuffix: " Cópia",
+    customThemeApplied: 'Esquema de cores "{name}" aplicado',
+    customThemeKeepOne: "Mantenha pelo menos um tema",
+    customThemeJsonError: "Formato JSON inválido, verifique",
+    jdbcPlugin: "Plugin JDBC do DBX",
+    jdbcPluginInstall: "Instalar plugin JDBC",
+    jdbcPluginInstallSuccess: "Plugin JDBC instalado",
+    jdbcPluginUpdate: "Atualizar",
+    jdbcPluginUninstall: "Desinstalar",
+    jdbcPluginUninstallSuccess: "Plugin JDBC desinstalado",
+    jdbcPluginInstalled: "Instalado: v{version}",
+    jdbcPluginIncompatible: "Protocolo incompatível",
+    jdbcPluginNotInstalled: "Não instalado",
+    jdbcDrivers: "JARs de driver JDBC",
+    jdbcImport: "Importar JAR",
+    jdbcImportPath: "Caminho de importação",
+    jdbcDriverPathPlaceholder: "/caminho/para/driver.jar",
+    jdbcImportSuccess: "{count} arquivo(s) de driver importado(s)",
+    jdbcDeleteSuccess: "Driver removido",
+    jdbcNoDrivers: "Nenhum driver JDBC importado ainda.",
+    mcpTitle: "Servidor MCP",
+    mcpDescription: "Verifique a instalação e a versão do Servidor MCP do DBX usado pelo Claude Code, Cursor e outros agentes.",
+    mcpChecking: "Verificando",
+    mcpStatusUnknown: "Não verificado",
+    mcpStatusError: "Falha na verificação",
+    mcpReady: "Pronto",
+    mcpNotInstalled: "Não instalado",
+    mcpUpdateAvailable: "Atualização disponível",
+    mcpCurrent: "Versão atual",
+    mcpLatest: "Versão mais recente",
+    mcpVersionMissing: "Nenhuma instalação global detectada",
+    mcpVersionUnknown: "Desconhecida",
+    mcpAvailable: "Disponível",
+    mcpUnavailable: "Indisponível",
+    mcpBinPath: "Caminho do comando",
+    mcpInstallCommand: "Comando de instalação",
+    mcpUpdateCommand: "Comando de atualização",
+    mcpInstallButton: "Instalar",
+    mcpUpdateButton: "Atualizar",
+    mcpUpToDate: "Atualizado",
+    mcpInstalling: "Instalando...",
+    mcpInstallSuccess: "Instalação bem-sucedida",
+    mcpInstallFailed: "Falha na instalação",
+    mcpConfig: "Configuração do MCP",
+    mcpConfigOptionsHint: "Estas opções atualizam apenas a configuração gerada. Copie-a para o cliente de IA e reinicie a sessão MCP para aplicá-la.",
+    mcpCodexConfig: "Configuração do Codex",
+    mcpCodexConfigPath: "O Codex pode usar ~/.codex/config.toml ou um .codex/config.toml no nível do projeto.",
+    mcpCursorConfigPath: "O Cursor pode usar .cursor/mcp.json no projeto ou ~/.cursor/mcp.json globalmente.",
+    mcpTraeConfigPath: "TRAE: Configurações > MCP > Adicionar > Adicionar manualmente; depois cole a configuração JSON.",
+    mcpVsCodeConfigPath: "O VS Code/Copilot pode usar .vscode/mcp.json no workspace ou mcp.json no perfil do usuário.",
+    mcpWindsurfConfigPath: "O Windsurf pode usar ~/.codeium/windsurf/mcp_config.json.",
+    mcpOpenCodeConfigPath: "~/.config/opencode/opencode.json globalmente, ou opencode.json no nível do projeto.",
+    mcpReadonlyMode: "Modo somente leitura",
+    mcpReadonlyModeDescription: "Adiciona DBX_MCP_ALLOW_WRITES=0 à configuração de exemplo para que a sessão MCP permaneça apenas para consultas.",
+    mcpAllowDangerous: "Permitir SQL perigoso",
+    mcpAllowDangerousDescription: "Adiciona DBX_MCP_ALLOW_DANGEROUS_SQL=1 à configuração de exemplo para que instruções como DROP, TRUNCATE, ALTER e similares sejam permitidas.",
+    mcpDetectionTiming: "O DBX verifica automaticamente quando esta página é aberta; use Verificar novamente para atualizar.",
+    mcpNpmBoundary: "O DBX apenas verifica e explica o status do MCP; a instalação e as atualizações ainda são feitas pelo npm.",
+    mcpRefresh: "Verificar novamente",
+    mcpGuide: "Guia do MCP",
+    supportInfoTitle: "Informações de suporte",
+    supportInfoDescription: "Copie estes detalhes do ambiente ao abrir issues ou pedir ajuda.",
+    supportInfoCopy: "Copiar informações",
+    supportInfoCopied: "Copiado",
+    supportInfoLoading: "Carregando informações de suporte...",
+    supportInfoLoadFailed: "Falha ao carregar todas as informações de suporte: {message}",
+    supportInfoAppVersion: "Versão do DBX",
+    supportInfoRuntime: "Ambiente",
+    supportInfoRuntimeDesktop: "Desktop",
+    supportInfoRuntimeWeb: "Web",
+    supportInfoOperatingSystem: "Sistema operacional",
+    supportInfoArchitecture: "Arquitetura",
+    supportInfoUnknown: "Desconhecido",
+    community: "Comunidade",
+    qqGroup: "Grupo do QQ",
+    wechatGroup: "Grupo do WeChat",
+    wechatGroupInvite: "Convite do Tencent Docs",
+    project: "Projeto",
+    openSource: "Repositório de código aberto",
+    officialDocs: "Documentação oficial",
+    shortcutUppercaseSelection: "Converter seleção em maiúsculas",
+    shortcutLowercaseSelection: "Converter seleção em minúsculas",
+    shortcutExPasteSqlInCondition: "ExPaste: colar como condição IN",
+  },
+  driverStore: {
+    progressJreExtract: "Extraindo JRE...",
+    progressDownloadJre: "Baixando JRE",
+    progressDownloadDriver: "Baixando driver",
+    progressDownloadJdbcPlugin: "Baixando plugin JDBC",
+    progressJdbcPluginExtract: "Instalando plugin JDBC...",
+    usageTitle: "Uso de armazenamento",
+    usageTotal: "Total {size}",
+    usageTotalLabel: "Total",
+    calculating: "Calculando...",
+    usageManagedJre: "JRE gerenciada",
+    usageAgentDrivers: "Agentes de driver integrados",
+    usageDownloadCache: "Cache de downloads",
+    usageJdbcPlugin: "Plugin JDBC",
+    usageJdbcDriverJars: "JARs de driver JDBC",
+    clearDownloadCache: "Limpar cache",
+    downloadCacheClearSuccess: "Cache de downloads limpo",
+    downloadCacheClearFailed: "Falha ao limpar cache de downloads: {error}",
+    offlineDownloadHint: "Para ambientes sem internet, baixe pacotes de driver offline em uma máquina com acesso à internet e importe-os aqui.",
+    offlineDownloadLink: "Downloads de driver offline",
+    searchDrivers: "Pesquisar nome, tipo, versão do driver...",
+    searchJdbcDrivers: "Pesquisar nome ou caminho do driver JDBC...",
+    jdbcMavenCoordinatePlaceholder: "Coordenada Maven, ex.: org.postgresql:postgresql:42.7.7",
+    jdbcMavenInstall: "Instalar do Maven",
+    jdbcMavenInstallSuccess: "Driver JDBC Maven instalado",
+    jdbcSourceMaven: "Maven",
+    jdbcSourceManual: "Manual",
+    noMatchingDrivers: "Nenhum driver correspondente.",
+    javaRuntimeSaved: "Configurações de runtime do Java salvas",
+    javaRuntimeSaveFailed: "Falha ao salvar configurações de runtime do Java: {error}",
+    chooseJavaExecutable: "Escolher executável do Java",
+    driverInstallSuccess: "Driver {label} instalado",
+    driverInstallFailed: "Falha ao instalar o driver {label}: {error}",
+    driverUpdateBlocked: "Feche estas conexões de banco de dados antes de atualizar os drivers: {labels}",
+    upgradeAllSuccess: "{count} driver(s) atualizado(s)",
+    upgradeAllPartial: "{count} driver(s) atualizado(s). Ignorados: {failed}",
+    upgradeAllFailed: "Falha na atualização em lote: {error}",
+    driverUninstallSuccess: "Driver {label} desinstalado",
+    driverUninstallFailed: "Falha ao desinstalar o driver {label}: {error}",
+    chooseOfflineDriverPackage: "Escolher pacote de driver offline",
+    offlineImportSuccess: "Importação offline concluída. {count} driver(s) instalado(s).",
+    offlineImportFailed: "Falha na importação offline: {error}",
+    driverImportSuccess: "Driver {label} importado",
+    driverImportFailed: "Falha ao importar o driver {label}: {error}",
+    chooseDriverJar: "Escolher arquivo JAR do driver",
+    jreReinstallSuccess: "JRE {jre} reinstalada",
+    jreReinstallFailed: "Falha ao reinstalar a JRE {jre}: {error}",
+    jreUninstallSuccess: "JRE {jre} desinstalada",
+    chooseJdbcPluginZip: "Escolher arquivo zip do plugin JDBC",
+    agentDrivers: "Drivers integrados",
+    jdbcDrivers: "Drivers JDBC",
+    importing: "Importando...",
+    importOfflinePackage: "Importar pacote offline",
+    refresh: "Atualizar",
+    javaRuntime: "Runtime do Java",
+    javaRuntimeManaged: "JRE gerenciada pelo DBX",
+    javaRuntimeSystem: "Java do sistema",
+    javaRuntimeCustom: "Caminho personalizado",
+    saving: "Salvando...",
+    customJavaPathPlaceholder: "/caminho/para/java ou /caminho/para/jdk",
+    choose: "Escolher",
+    systemJavaHint: "Usar o java do PATH atual.",
+    jreRuntimeTitle: "Runtime da JRE {jre}",
+    notInstalled: "Não instalado",
+    reinstalling: "Reinstalando",
+    installing: "Instalando",
+    install: "Instalar",
+    reinstall: "Reinstalar",
+    uninstall: "Desinstalar",
+    jreRuntime: "Runtime da JRE",
+    jreRuntimeAutoDownloadHint: "Baixada automaticamente ao instalar um driver pela primeira vez",
+    driversUpdatable: "{count} driver(s) pode(m) ser atualizado(s)",
+    upgradingProgress: "Atualizando ({current}/{total})",
+    upgradeAll: "Atualizar todos",
+    queued: "Na fila",
+    importLocalJar: "Importar JAR local",
+    updating: "Atualizando",
+    update: "Atualizar",
+    localInstall: "Instalação local",
+    runtimeDrivers: "Runtime",
+    storageTab: "Armazenamento",
+    runtimeTitle: "Runtime do driver",
+    runtimeHint: "As métricas de runtime são coletadas apenas enquanto este painel está aberto.",
+    runtimeRunning: "Em execução",
+    runtimeMemory: "Memória",
+    runtimeHealth: "Integridade",
+    runtimeHealth_healthy: "Saudável",
+    runtimeHealth_warning: "Aviso",
+    runtimeHealth_error: "Erro",
+    runtimeLastError: "Último erro",
+    runtimeEmpty: "Nenhum runtime de driver ainda. Abra uma conexão baseada em agente para iniciar um.",
+    runtimeKindAgent: "Agente",
+    runtimeKindPlugin: "Plugin",
+    runtimeSourceDaemon: "Daemon",
+    runtimeSourceConnection: "Conexão",
+    runtimeStatus_running: "Em execução",
+    runtimeStatus_stopped: "Parado",
+    runtimeStatus_error: "Erro",
+    runtimeStatus_unknown: "Desconhecido",
+    runtimePid: "PID",
+    runtimeUptime: "Tempo ativo",
+    runtimeActions: "Ações",
+    runtimeStop: "Parar",
+    runtimeRestart: "Reiniciar",
+    runtimeControlConnectionOwned: "Feche a conexão de banco de dados para parar este runtime.",
+    runtimeStopSuccess: "Runtime {label} parado",
+    runtimeStopFailed: "Falha ao parar {label}: {error}",
+    runtimeRestartSuccess: "Runtime {label} reiniciado",
+    runtimeRestartFailed: "Falha ao reiniciar {label}: {error}",
+    driverStoreDir: "Caminho de armazenamento de drivers",
+    driverStoreDirDescription: "Configure locais separados para o plugin JDBC e dados de Agent/JRE. O app será reiniciado automaticamente após a migração.",
+    pluginStoreDir: "Diretório do plugin JDBC",
+    pluginStoreDirDescription: "Armazena o plugin JDBC, Maven resolver e jars de drivers JDBC.",
+    agentStoreDir: "Diretório Agent / JRE",
+    agentStoreDirDescription: "Armazena pacotes de drivers Agent, JREs gerenciados e cache de runtime.",
+    driverStoreDirDefault: "Padrão (diretório de instalação)",
+    driverStoreDirChange: "Alterar",
+    driverStoreDirReset: "Restaurar padrão",
+    driverStoreDirMigrating: "Migrando {target}…",
+    driverStoreDirConfirm: "Alterar {target} migrará os dados relacionados para o novo local. Conexões relacionadas podem ser desconectadas durante a migração. O app será reiniciado automaticamente após. Continuar?",
+    driverStoreDirMigrationFailed: "Falha na migração de drivers: {error}",
+    driverStoreDirDialogTitle: "Selecionar {target}",
+    driverStoreDirSuccess: "{target} alterado, reiniciando…",
+  },
+  databaseExport: {
+    title: "Exportar banco de dados",
+    options: "Opções",
+    includeStructure: "Estrutura da tabela (DDL)",
+    dropTableIfExists: "Adicionar DROP TABLE IF EXISTS antes do DDL",
+    includeData: "Dados da tabela (INSERT)",
+    includeObjects: "Views / Procedures / Funções / Sequências",
+    databaseSelection: "Bancos de dados",
+    selectedDatabases: "{selected}/{total} selecionados",
+    selectAllDatabases: "Selecionar todos",
+    filterDatabases: "Pesquisar bancos de dados...",
+    clearDatabases: "Limpar",
+    runInBackground: "Executar em segundo plano",
+    tableSelection: "Tabelas",
+    selectedTables: "{selected}/{total} selecionadas",
+    selectAllTables: "Selecionar todas",
+    filterTables: "Pesquisar tabelas...",
+    clearTables: "Limpar",
+    loadingTables: "Carregando tabelas...",
+    tableLoadError: "Falha ao carregar tabelas: {error}",
+    noTables: "Nenhuma tabela encontrada",
+    export: "Exportar",
+    exportAllDatabases: "Exportar todos os bancos de dados",
+    exporting: "Exportando...",
+    selectExportDirectory: "Selecionar diretório de exportação",
+    currentDatabase: "Banco de dados {current}/{total}",
+    currentTable: "Atual: {table} ({current}/{total})",
+    rowsExported: "{count} linhas exportadas",
+    exportSuccess: "Banco de dados exportado com sucesso",
+    exportAllSuccess: "{count} bancos de dados exportados com sucesso",
+    allDatabasesTask: "Todos os bancos de dados ({count})",
+    exportError: "Falha na exportação: {error}",
+    exportCancelled: "Exportação cancelada",
+  },
+  nacos: {
+    configs: "Configurações",
+    services: "Serviços",
+    raw: "Raw",
+    namespace: "Namespace",
+    createNamespace: "Criar Namespace",
+    editNamespace: "Editar Namespace",
+    creatingNamespace: "Criando...",
+    updatingNamespace: "Atualizando...",
+    namespaceCreated: 'Namespace "{name}" criado',
+    namespaceUpdated: 'Namespace "{name}" atualizado',
+    namespaceId: "ID do Namespace",
+    namespaceIdPlaceholder: "Deixe vazio para o Nacos gerar",
+    namespaceName: "Nome do Namespace",
+    namespaceNamePlaceholder: "Digite um nome de namespace",
+    namespaceDesc: "Descrição",
+    namespaceDescPlaceholder: "Padrão é o nome do namespace",
+    dataId: "Data ID",
+    group: "Grupo",
+    format: "Formato",
+    content: "Conteúdo",
+    tags: "Tags",
+    application: "Aplicação",
+    description: "Descrição",
+    advanced: "Avançado",
+    collapse: "Recolher",
+    load: "Carregar",
+    save: "Salvar",
+    saveAs: "Salvar como",
+    saving: "Salvando...",
+    saved: "Configuração salva",
+    createdAndLoaded: "{dataId} criado e carregado",
+    savedAndLoaded: "{dataId} salvo e atualizado",
+    deleted: "Configuração excluída",
+    delete: "Excluir",
+    copy: "Copiar",
+    copied: "Copiado",
+    copyVerifyFailed: "A verificação da área de transferência falhou após a gravação",
+    export: "Exportar",
+    exported: "Exportado",
+    exportedTo: "Exportado para {path}",
+    exportFailed: "Falha ao exportar: {message}",
+    history: "History",
+    configHistory: "Config history",
+    historyDetail: "History detail",
+    historyCompareTitle: "History Version Compare",
+    currentPublishedContent: "Current published content:",
+    historyVersionContent: "History version content:",
+    updatedAt: "Updated at",
+    operationType: "Operation",
+    operator: "Operator",
+    view: "View",
+    compare: "Compare",
+    rollback: "Rollback",
+    loadingHistory: "Loading history...",
+    noHistory: "No history versions",
+    noHistoryHint: "Refresh if this config was just published. Some Nacos versions may not expose history APIs.",
+    historyCreate: "Create",
+    historyUpdate: "Update",
+    historyDelete: "Delete",
+    historyRollback: "Rollback",
+    confirmRollbackTitle: "Rollback Nacos config",
+    confirmRollbackMessage: "This will roll the current config back to the selected history version.",
+    rollbackSuccess: "Config rolled back",
+    publish: "Publicar",
+    dataIdRequired: "Data ID é obrigatório",
+    allGroups: "Todos os grupos",
+    noConfigs: "Nenhuma configuração",
+    selectConfig: "Selecione ou crie uma configuração",
+    noServices: "Nenhum serviço",
+    selectService: "Selecione um serviço",
+    service: "Serviço",
+    instances: "Instâncias",
+    instanceCount: "{count} instâncias",
+    refresh: "Atualizar",
+    address: "Endereço",
+    cluster: "Cluster",
+    weight: "Peso",
+    state: "Estado",
+    actions: "Ações",
+    query: "Query",
+    body: "Corpo",
+    response: "Resposta",
+    template: "Modelo",
+    configDiffTitle: "Comparar conteúdo da configuração",
+    inlineCompare: "Comparação inline",
+    currentVersionContent: "Versão oficial atual:",
+    publishVersionContent: "Conteúdo desta publicação:",
+    confirmSaveTitle: "Revisar alterações da configuração Nacos",
+    confirmSaveMessage: "Salvar esta alteração? +{added} / -{removed} linhas.",
+    confirmDeleteTitle: "Excluir configuração Nacos",
+    confirmDeleteMessage: "Isso remove a configuração selecionada do Nacos.",
+    confirmInstanceTitle: "Atualizar instância Nacos",
+    confirmInstanceMessage: "Confirme o estado de destino da instância.",
+    confirmRawTitle: "Enviar solicitação Raw API mutável",
+    confirmRawMessage: "Esta solicitação Raw API pode modificar o estado do Nacos.",
+    rawTemplate: {
+      serverState: "Estado do servidor",
+      namespaceList: "Lista de namespaces",
+      configDetail: "Detalhe da configuração",
+      serviceList: "Lista de serviços",
+      instanceList: "Lista de instâncias",
+    },
+    healthy: "Saudável",
+    unhealthy: "Não saudável",
+    enabled: "Ativado",
+    offline: "Offline",
+    ephemeral: "Efêmera",
+    persistent: "Persistente",
+    enable: "Ativar",
+    disable: "Desativar",
+    markHealthy: "Marcar saudável",
+    markUnhealthy: "Marcar não saudável",
+    send: "Enviar",
+    total: "{count} no total",
+    prev: "Anterior",
+    next: "Próximo",
+    test: "Testar",
+    readOnly: "Somente leitura",
+  },
+  gridfsBrowser: {
+    bucketCount: "Buckets",
+    fileCount: "Arquivos",
+    name: "Nome",
+    totalSize: "Tamanho",
+    chunkSize: "Tamanho do chunk",
+    uploadDate: "Data de upload",
+    contentType: "Tipo de conteúdo",
+    metadata: "Metadados",
+    selectBucket: "Selecione um bucket GridFS para visualizar ou abrir.",
+    selectFile: "Selecione um arquivo GridFS para visualizar ou gerenciar.",
+    emptyBuckets: "Nenhum bucket GridFS no momento. Você pode criar um.",
+    emptyFiles: "O bucket atual ainda não tem arquivos. Você pode fazer upload de um.",
+    createBucket: "Criar bucket",
+    openBucket: "Abrir bucket",
+    deleteBucket: "Excluir bucket",
+    createTitle: "Criar bucket GridFS",
+    deleteTitle: "Excluir bucket GridFS",
+    deleteMessage: "Tem certeza de que deseja excluir o bucket GridFS selecionado e todos os seus arquivos?",
+    bucketName: "Nome do bucket",
+    bucketNamePlaceholder: "example_bucket",
+    bucketCreated: "Bucket {bucket} criado.",
+    bucketDeleted: "Bucket {bucket} excluído.",
+    uploadFile: "Fazer upload de arquivo",
+    downloadFile: "Baixar arquivo",
+    downloadSelected: "Baixar selecionados",
+    deleteFile: "Excluir arquivo",
+    selectedCount: "{count} selecionados",
+    deleteFileTitle: "Excluir arquivo GridFS",
+    deleteFileMessage: "Tem certeza de que deseja excluir o arquivo selecionado do bucket GridFS atual?",
+    fileUploaded: "Arquivo {fileName} enviado.",
+    fileDeleted: "Arquivo {fileName} excluído.",
+  },
+  extension: {
+    installTitle: "Instalar extensão",
+    manageTitle: "Gerenciar extensão",
+    name: "Nome da extensão",
+    namePlaceholder: "Exemplo: pg_stat_statements",
+    install: "Instalar",
+    drop: "Remover",
+    available: "Extensões disponíveis",
+    installed: "Instaladas",
+    noAvailable: "Todas as extensões disponíveis já estão instaladas.",
+    noInstalled: "Nenhuma extensão instalada.",
+  },
+  sqlFileTree: {
+    title: "Arquivos SQL",
+    openFolder: "Abrir pasta",
+    closePanel: "Fechar",
+    loading: "Carregando...",
+    noFolder: "Nenhuma pasta aberta",
+    noSqlFiles: "Nenhum arquivo SQL encontrado",
+    folderAlreadyOpen: "Esta pasta já está aberta",
+    removeFolder: "Remover pasta",
+    openFailed: "Falha ao abrir a pasta: {message}",
+    loadFailed: "Falha ao carregar arquivos SQL: {message}",
+    desktopOnly: "Recurso disponível apenas no desktop",
+    refreshFolder: "Atualizar pasta",
+    refreshAll: "Atualizar tudo",
+    refreshed: "Atualizado",
+    revealInFileManager: "Mostrar no gerenciador de arquivos",
+    revealFailed: "Falha ao abrir o gerenciador de arquivos: {message}",
+    copyPath: "Copiar caminho",
+    pathCopied: "Caminho copiado",
+    copyFailed: "Falha ao copiar caminho",
+    openFile: "Abrir",
+    executeSqlFile: "Executar arquivo SQL",
+    expandAll: "Expandir todos",
+    collapseAll: "Recolher todos",
+  },
+  mqTopics: {
+    title: "Gerenciamento de tópicos",
+    searchPlaceholder: "Pesquisar tópico",
+    includeNonPersistent: "Incluir tópicos não persistentes",
+    refresh: "Atualizar",
+    refreshing: "Atualizando...",
+    createTopic: "Criar tópico",
+    selectTenantNamespace: "Selecione primeiro o locatário e o namespace",
+    loading: "Carregando...",
+    noTopics: "Nenhum tópico neste namespace",
+    noMatches: "Nenhum tópico correspondente",
+    name: "Nome",
+    type: "Tipo",
+    partitions: "Partições",
+    actions: "Ações",
+    nonPersistent: "Não persistente",
+    partitionedTopic: "Tópico particionado",
+    normalTopic: "Tópico normal",
+    partitionCount: "{count} partições",
+    partitionsUnknown: "Número de partições desconhecido",
+    adjustPartitions: "Ajustar partições",
+    delete: "Excluir",
+    tenantNamespace: "Locatário / Namespace",
+    topicName: "Nome do tópico",
+    topicNamePlaceholder: "Por exemplo: my-topic",
+    persistentRecommended: "Tópico persistente (recomendado)",
+    persistentHint: "Tópicos persistentes salvam as mensagens em disco, tópicos não persistentes salvam apenas na memória.",
+    enablePartitions: "Habilitar partições",
+    partitionQuantity: "Número de partições",
+    partitionHint: "As partições melhoram o desempenho de concorrência, mas aumentam o consumo de recursos.",
+    cancel: "Cancelar",
+    create: "Criar",
+    updatePartitionsTitle: "Ajustar número de partições: {name}",
+    currentPartitions: "Partições atuais",
+    newPartitions: "Novas partições",
+    partitionMinHint: "O número de partições só pode ser aumentado, não reduzido. Mínimo: {min}",
+    update: "Atualizar",
+    readOnly: "A conexão atual é somente leitura, não é possível executar operações de gravação.",
+    topicNameRequired: "O nome do tópico não pode estar vazio",
+    currentPartitionsUnknown: "O número atual de partições é desconhecido, não é possível ajustar com segurança.",
+    partitionMustIncrease: "O novo número de partições deve ser maior que o atual.",
+    confirmDelete: 'Tem certeza de que deseja excluir o tópico "{name}"? Esta operação é irreversível.',
+  },
+  production: {
+    title: "Ambiente de Produção",
+    connection: "Conexão de Produção",
+    enable: "Ativar proteção de ambiente de produção",
+    disabledDescription: "Após ativar, é possível escolher proteger todos os bancos de dados ou bancos específicos.",
+    scope: "Escopo da proteção",
+    allDatabases: "Todos os bancos de dados",
+    selectedDatabases: "Selecionar bancos de dados",
+    singleDatabaseScopeHint: "Este tipo de banco de dados suporta apenas proteção de ambiente de produção em nível de conexão.",
+    databases: "Bancos de dados de produção",
+    connectionDescription: "Todos os bancos de dados nesta conexão terão proteção de produção ativada.",
+    databaseDescription: "Selecione os bancos de dados da conexão que precisam de proteção de produção. Na primeira abertura, todos são selecionados por padrão.",
+    selectDatabases: "Selecionar bancos de dados de produção",
+    noDatabasesSelected: "Nenhum selecionado ainda",
+    databasesConfiguredCount: "{count} selecionado(s)",
+    databasesSelectedCount: "{selected}/{total} selecionado(s)",
+    databasePickerTitle: "Selecionar bancos de dados de produção",
+    databasePickerDescription: "Selecione os bancos de dados em «{connection}» que precisam de proteção de produção.",
+    databaseSearchPlaceholder: "Buscar bancos de dados...",
+    databaseSelectionRequired: "Por favor, selecione pelo menos um banco de dados.",
+    databaseLoadFailed: "Não foi possível carregar a lista de bancos de dados: {message}",
+    noDatabasesAvailable: "Nenhum banco de dados disponível encontrado.",
+    retry: "Tentar novamente",
+    confirmTitle: "Confirmar gravação em ambiente de produção",
+    confirmMessage: "Esta operação irá modificar o banco de dados de produção. É necessário confirmar explicitamente para continuar.",
+    confirmDetails: "Conexão: {connection}\nBanco de dados: {database}\nOrigem: {source}",
+    confirmAction: "Executar em produção",
+    sourceSqlEditor: "Editor SQL",
+    sourceDataGrid: "Editor de dados",
+    sourceStructure: "Editor de estrutura",
+    sourceSqlFile: "Execução de arquivo SQL",
+    sourceObjectBrowser: "Navegador de objetos",
+    sourceSchemaDiff: "Comparação de esquemas",
+    sourceDataCompare: "Comparação de dados",
+    sourceExtension: "Gerenciador de extensões",
+    sourceSidebar: "Árvore de objetos",
+    sourceObjectSource: "Editor de código-fonte de objetos",
+    sourceDataGenerate: "Gerador de dados",
+    sourceQueryHistory: "Reversão do histórico de consultas",
+    sourceAdmin: "Administração de banco de dados",
+    aiReviewRequired: "O SQL de produção foi colocado no editor. Verifique-o primeiro e execute manualmente para confirmar.",
+  },
+});
diff --git a/apps/desktop/src/i18n/locales/typeHelpOverrides.spec.ts b/apps/desktop/src/i18n/locales/typeHelpOverrides.spec.ts
new file mode 100644
index 0000000..768396e
--- /dev/null
+++ b/apps/desktop/src/i18n/locales/typeHelpOverrides.spec.ts
@@ -0,0 +1,109 @@
+import { describe, expect, it } from "vitest";
+import en from "./en";
+import esMessages from "./es";
+import itMessages from "./it";
+import jaMessages from "./ja";
+import ptBRMessages from "./pt-BR";
+import zhTWMessages from "./zh-TW";
+
+type TypeHelpLocale = { structureEditor: Record<string, Record<string, string>>; redis: Record<string, Record<string, string>> };
+
+const english = en as unknown as TypeHelpLocale;
+const es = esMessages as unknown as TypeHelpLocale;
+const itLocale = itMessages as unknown as TypeHelpLocale;
+const ja = jaMessages as unknown as TypeHelpLocale;
+const ptBR = ptBRMessages as unknown as TypeHelpLocale;
+const zhTW = zhTWMessages as unknown as TypeHelpLocale;
+const locales = { es, it: itLocale, ja, "pt-BR": ptBR, "zh-TW": zhTW };
+const directories = [
+  ["structureEditor", "mysqlDataTypeHelp"],
+  ["structureEditor", "postgresDataTypeHelp"],
+  ["structureEditor", "sqliteDataTypeHelp"],
+  ["redis", "createKeyTypeHelp"],
+] as const;
+
+describe("localized type help", () => {
+  it("provides every English help key directly in each supported locale", () => {
+    for (const [localeName, locale] of Object.entries(locales)) {
+      for (const [section, directory] of directories) {
+        const localized = (locale as unknown as Record<string, Record<string, Record<string, unknown>>>)[section]?.[directory] ?? {};
+        for (const key of Object.keys(english[section]![directory]!)) {
+          expect(localized[key], `${localeName}.${section}.${directory}.${key}`).toEqual(expect.any(String));
+        }
+      }
+    }
+  });
+
+  it("does not silently use the English copy for representative entries", () => {
+    for (const locale of Object.values(locales)) {
+      expect(locale.structureEditor.mysqlDataTypeHelp.int).not.toBe(english.structureEditor.mysqlDataTypeHelp.int);
+      expect(locale.structureEditor.postgresDataTypeHelp.jsonb).not.toBe(english.structureEditor.postgresDataTypeHelp.jsonb);
+      expect(locale.structureEditor.sqliteDataTypeHelp.integer).not.toBe(english.structureEditor.sqliteDataTypeHelp.integer);
+      expect(locale.redis.createKeyTypeHelp.string).not.toBe(english.redis.createKeyTypeHelp.string);
+    }
+  });
+
+  it("keeps concrete database facts in the Spanish translations", () => {
+    expect(es.structureEditor.mysqlDataTypeHelp.int).toContain("4 bytes");
+    expect(es.structureEditor.mysqlDataTypeHelp.jsonMysql).toContain("max_allowed_packet");
+    expect(es.structureEditor.mysqlDataTypeHelp.geometry).toContain("SRID");
+    expect(es.structureEditor.postgresDataTypeHelp.jsonb).toContain("índices");
+    expect(es.structureEditor.sqliteDataTypeHelp.integer).toContain("rowid");
+    expect(es.redis.createKeyTypeHelp.stream).toContain("XACK");
+  });
+
+  it("keeps concrete database facts in the Italian translations", () => {
+    expect(itLocale.structureEditor.mysqlDataTypeHelp.int).toContain("4 byte");
+    expect(itLocale.structureEditor.mysqlDataTypeHelp.jsonMysql).toContain("max_allowed_packet");
+    expect(itLocale.structureEditor.mysqlDataTypeHelp.geometry).toContain("SRID");
+    expect(itLocale.structureEditor.postgresDataTypeHelp.jsonb).toContain("indici");
+    expect(itLocale.structureEditor.sqliteDataTypeHelp.integer).toContain("rowid");
+    expect(itLocale.redis.createKeyTypeHelp.stream).toContain("XACK");
+  });
+
+  it("keeps concrete database facts in the Japanese translations", () => {
+    expect(ja.structureEditor.mysqlDataTypeHelp.int).toContain("4 バイト");
+    expect(ja.structureEditor.mysqlDataTypeHelp.jsonMariaDb).toContain("LONGTEXT");
+    expect(ja.structureEditor.mysqlDataTypeHelp.geometry).toContain("SRID");
+    expect(ja.structureEditor.mysqlDataTypeHelp.integerDisplayWidth).toContain("非推奨");
+    expect(ja.structureEditor.postgresDataTypeHelp.jsonb).toContain("重複キー");
+    expect(ja.structureEditor.postgresDataTypeHelp.pgLsn).toContain("WAL");
+    expect(ja.structureEditor.sqliteDataTypeHelp.integer).toContain("rowid");
+    expect(ja.structureEditor.sqliteDataTypeHelp.text).toContain("CHECK");
+    expect(ja.redis.createKeyTypeHelp.stream).toContain("XACK");
+  });
+
+  it("keeps concrete database facts in the Brazilian Portuguese translations", () => {
+    for (const directory of [ptBR.structureEditor.mysqlDataTypeHelp, ptBR.structureEditor.postgresDataTypeHelp, ptBR.structureEditor.sqliteDataTypeHelp]) {
+      expect(Object.values(directory)).not.toContain(expect.stringContaining("{type}"));
+    }
+    expect(ptBR.structureEditor.mysqlDataTypeHelp.int).toContain("4 bytes");
+    expect(ptBR.structureEditor.mysqlDataTypeHelp.jsonMysql).toContain("max_allowed_packet");
+    expect(ptBR.structureEditor.mysqlDataTypeHelp.jsonMariaDb).toContain("LONGTEXT");
+    expect(ptBR.structureEditor.mysqlDataTypeHelp.geometry).toContain("SRID");
+    expect(ptBR.structureEditor.mysqlDataTypeHelp.integerDisplayWidth).toContain("obsoleta");
+    expect(ptBR.structureEditor.postgresDataTypeHelp.jsonb).toContain("chaves duplicadas");
+    expect(ptBR.structureEditor.postgresDataTypeHelp.bytea).toContain("TOAST");
+    expect(ptBR.structureEditor.postgresDataTypeHelp.pgLsn).toContain("WAL");
+    expect(ptBR.structureEditor.sqliteDataTypeHelp.integer).toContain("rowid");
+    expect(ptBR.structureEditor.sqliteDataTypeHelp.text).toContain("CHECK");
+    expect(ptBR.redis.createKeyTypeHelp.stream).toContain("XACK");
+  });
+
+  it("keeps concrete database facts in the Traditional Chinese translations", () => {
+    for (const directory of [zhTW.structureEditor.mysqlDataTypeHelp, zhTW.structureEditor.postgresDataTypeHelp, zhTW.structureEditor.sqliteDataTypeHelp]) {
+      expect(Object.values(directory)).not.toContain(expect.stringContaining("{type}"));
+    }
+    expect(zhTW.structureEditor.mysqlDataTypeHelp.int).toContain("4 位元組");
+    expect(zhTW.structureEditor.mysqlDataTypeHelp.jsonMysql).toContain("max_allowed_packet");
+    expect(zhTW.structureEditor.mysqlDataTypeHelp.jsonMariaDb).toContain("LONGTEXT");
+    expect(zhTW.structureEditor.mysqlDataTypeHelp.geometry).toContain("SRID");
+    expect(zhTW.structureEditor.mysqlDataTypeHelp.integerDisplayWidth).toContain("淘汰");
+    expect(zhTW.structureEditor.postgresDataTypeHelp.jsonb).toContain("重複鍵");
+    expect(zhTW.structureEditor.postgresDataTypeHelp.bytea).toContain("TOAST");
+    expect(zhTW.structureEditor.postgresDataTypeHelp.pgLsn).toContain("WAL");
+    expect(zhTW.structureEditor.sqliteDataTypeHelp.integer).toContain("rowid");
+    expect(zhTW.structureEditor.sqliteDataTypeHelp.text).toContain("CHECK");
+    expect(zhTW.redis.createKeyTypeHelp.stream).toContain("XACK");
+  });
+});
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
new file mode 100644
index 0000000..f3670b7
--- /dev/null
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -0,0 +1,3873 @@
+import { withEnglishFallback } from "./fallback";
+
+export default withEnglishFallback({
+  app: {
+    name: "DBX",
+  },
+  auth: {
+    setupTitle: "设置访问密码",
+    setupDescription: "设置密码以保护您的实例",
+    loginDescription: "数据库管理工具",
+    newPassword: "输入新密码",
+    confirmPassword: "确认密码",
+    enterPassword: "请输入访问密码",
+    passwordMismatch: "两次输入的密码不一致",
+    setPassword: "设置密码",
+    login: "登录",
+    processing: "处理中...",
+    loginFailed: "密码错误",
+    connectFailed: "连接失败",
+    changePassword: "修改密码",
+    oldPassword: "当前密码",
+    oldPasswordWrong: "当前密码不正确",
+    passwordChanged: "密码修改成功",
+    changePasswordFailed: "密码修改失败",
+    changePasswordDescription: "输入当前密码并设置新密码",
+  },
+  toolbar: {
+    newConnection: "新建连接",
+    newQuery: "新建查询",
+    execute: "执行",
+    executeShortcut: "执行选中/全部 (Cmd+Enter)",
+    stopQuery: "停止执行",
+    explainPlan: "执行计划",
+    stopExplain: "停止执行计划",
+    formatSql: "格式化 SQL",
+    formatSqlFailed: "SQL 格式化失败",
+    keywordCaseLower: "使用小写 SQL 关键字",
+    keywordCaseUpper: "使用大写 SQL 关键字",
+    autoCommit: "自动提交",
+    manualTransaction: "手动事务",
+    autoCommitAgent: "自动提交（取决于 Agent 后端数据库）",
+    manualTransactionAgent: "手动事务（取决于 Agent 后端数据库）",
+    commit: "提交",
+    rollback: "回滚",
+    txnAutoRolledBack: "事务已因 5 分钟无操作而自动回滚",
+    previewSql: "预览 SQL",
+    hidePreviewSql: "隐藏 SQL 预览",
+    saveSql: "保存到 SQL 库",
+    openSql: "打开 SQL 文件",
+    exPasteSqlInCondition: "ExPaste：粘贴为 IN 条件",
+    theme: "主题",
+    themeLight: "亮色",
+    themeDark: "暗色",
+    themeSystem: "跟随系统",
+    sqlSaved: "SQL 已保存",
+    sqlOpenFailed: "打开文件失败：{message}",
+    sqlSaveFailed: "保存文件失败：{message}",
+    driverManager: "驱动管理",
+    updatableDriverCount: "可更新驱动数量",
+    blockDangerousRedisCommands: "拦截危险命令",
+  },
+  updates: {
+    title: "更新",
+    check: "检查更新",
+    availableTitle: "发现新版本",
+    availableMessage: "DBX {latest} 已发布，当前版本为 {current}。",
+    upToDate: "DBX 已是最新版本 ({version})。",
+    failed: "检查更新失败：{error}",
+    rateLimited: "GitHub 更新检查暂时触发频率限制。你仍然可以打开下载页手动查看。",
+    openRelease: "打开下载页",
+    downloadAndInstall: "下载并安装",
+    portableManualUpdate: "便携版不能使用应用内安装器更新。请从 release 下载便携版 ZIP，并解压覆盖当前 DBX 目录，以保留 portable.dbx 和 data。",
+    downloading: "下载中 {progress}%",
+    downloadFailed: "更新下载失败：{error}",
+    restart: "退出并重启",
+    restartFailed: "重启应用失败：{error}",
+    exitAndUpdate: "退出并更新",
+    dockerUsersRun: "Docker 用户请运行",
+    toUpdate: "更新",
+  },
+  sidebar: {
+    connections: "连接",
+    noConnections: "暂无连接",
+    import: "导入连接",
+    importDbx: "导入 DBX 配置",
+    importNavicat: "导入 Navicat NCX",
+    importDbeaver: "导入 DBeaver",
+    importDatagrip: "导入 DataGrip",
+    export: "导出连接",
+    collapseAll: "一键折叠",
+    collapse: "收起侧边栏",
+    expand: "展开侧边栏",
+    showMore: "加载更多 ({count})...",
+    filterByType: "按类型筛选",
+    searchScopeConnection: "连接",
+    searchScopeDatabase: "数据库",
+    searchScopeSchema: "Schema",
+    searchScopeTable: "表",
+    searchScopeView: "视图",
+    searchTablesInCurrentScope: "搜索当前库的表...",
+    clearTableSearch: "清除表搜索",
+    clearFilter: "清除筛选",
+    locateActiveTab: "在侧边栏中定位",
+  },
+  savedSql: {
+    saveToLibrary: "保存到 SQL 库",
+    saveToFile: "保存到本地",
+    save: "保存",
+    saved: "SQL 已保存",
+    saveFailed: "保存 SQL 失败：{message}",
+    fileName: "文件名",
+    folder: "文件夹",
+    rootFolder: "SQL 库",
+    newQuery: "新建查询",
+    newFolder: "新建 SQL 文件夹",
+    newFolderDefault: "新建文件夹",
+    renameFolder: "重命名文件夹",
+    deleteFolder: "删除文件夹",
+    deleteFolderConfirm: "确定删除“{name}”以及其中的 SQL 文件吗？",
+    open: "打开 SQL",
+    renameFile: "重命名 SQL",
+    deleteFile: "删除 SQL",
+    deleteFileConfirm: "确定删除“{name}”吗？",
+  },
+  sqlLibrary: {
+    title: "SQL 库",
+    empty: "暂无已保存的查询",
+    emptyFolder: "空文件夹",
+    unfiled: "未分类",
+    exportFile: "导出 SQL",
+    exportFolder: "导出文件夹",
+    exportLibrary: "导出 SQL 库",
+    importDirectory: "导入本地文件夹",
+    importIntoFolder: "导入到当前文件夹",
+    openStorageDirectory: "打开 SQL 存储目录",
+    chooseSyncDirectory: "设置本地同步目录",
+    disableSyncDirectory: "关闭本地同步目录",
+    syncDirectorySaved: "SQL 本地同步目录已设置",
+    syncDirectoryDisabled: "SQL 本地同步已关闭",
+    syncDirectoryFailed: "设置同步目录失败：{message}",
+    openDirectoryFailed: "打开目录失败：{message}",
+    noSyncDirectory: "请先设置本地同步目录",
+    exported: "导出完成",
+    exportFailed: "导出失败：{message}",
+    importFailed: "导入失败：{message}",
+    importNone: "所选文件夹中没有 .sql 文件",
+    imported: "已导入 {count} 个 SQL 文件",
+    desktopOnly: "该功能仅桌面端可用",
+    noConnection: "当前没有可用于导入的连接",
+    batchDelete: "批量删除",
+    batchDeleteConfirm: "确定要删除选中的 {count} 项吗？此操作无法撤销。",
+    batchDeleteSuccess: "成功删除 {count} 项",
+    moveToFolder: "分类至...",
+    moveSelectedToFolder: "分类选中的 {count} 个 SQL 至...",
+    moveSuccess: "已分类 {count} 个 SQL",
+    clearSelection: "清除选择",
+    sortByDate: "按修改日期排序",
+    sortByFolder: "按文件夹结构排序",
+  },
+
+  connection: {
+    title: "新建连接",
+    name: "名称",
+    namePlaceholder: "连接名称，留空则自动生成",
+    type: "类型",
+    host: "主机",
+    filePath: "文件路径",
+    h2FileMode: "文件",
+    h2TcpMode: "TCP",
+    h2FilePathRequired: "H2 文件路径不能为空",
+    createDuckDbFile: "新建 DuckDB 文件",
+    createSqliteFile: "新建 SQLite 数据库",
+    memoryDatabasePathHint: "输入 :memory: 可创建 SQLite 或 DuckDB 内存数据库。",
+    sqliteCipherKey: "SQLCipher 密码（密钥）",
+    sqliteCipherKeyPlaceholder: "未加密 SQLite 留空",
+    sqliteExtensions: "SQLite 扩展库",
+    sqliteExtensionsPlaceholder: "/path/to/regexp.dylib\n/path/to/text.dylib|sqlite3_text_init",
+    sqliteExtensionsHint: "每行一个 .dylib/.so/.dll；需要入口函数时使用“路径|入口函数”。连接时加载，加载后会关闭 load_extension。",
+    sqliteExtensionBrowse: "选择 SQLite 扩展库",
+    user: "用户名",
+    password: "密码",
+    database: "数据库",
+    databasePlaceholder: "可选",
+    databasePlaceholderRequired: "必填，请填写已存在的数据库",
+    databasePlaceholderWithDefault: "可选，默认 {database}",
+    kingbaseDatabaseRequired: "Kingbase 需要先填写一个已存在的数据库后才能连接或加载数据库列表。",
+    defaultDatabase: "默认库",
+    authDatabase: "认证库",
+    authDatabasePlaceholder: "可选，通常为 admin",
+    authMechanism: "认证机制",
+    authMechanismDefault: "默认",
+    driverMode: "驱动",
+    mongoDriverAuto: "自动",
+    mongoDriverLegacy: "旧版兼容",
+    serviceName: "服务名/SID",
+    serviceNameOnly: "服务名",
+    version: "版本",
+    driverInstallHintPrefix: "需要在顶部导航栏「",
+    driverInstallHintSuffix: "」中安装对应的驱动才能连接。",
+    driverName: "驱动名称",
+    driverNamePlaceholder: "厂商或环境名称",
+    urlParams: "URL 参数",
+    d1AccountId: "Account ID",
+    d1DatabaseId: "Database ID",
+    d1ApiToken: "API Token",
+    d1TokenHint: "Token 至少需要 D1 Read 权限；执行写入、DDL 或导入时还需要 D1 Write 权限。",
+    d1FieldsRequired: "必须填写 Cloudflare Account ID、D1 Database ID 和 API Token。",
+    hiveAuthMode: "认证",
+    hiveAuthNone: "无",
+    hivePrincipal: "Principal",
+    hiveKerberosPrincipalRequired: "Hive Kerberos principal 不能为空",
+    hiveKrb5ConfBrowse: "选择 krb5.conf",
+    hiveJaasConfigBrowse: "选择 JAAS 配置",
+    hiveTicketCache: "票据缓存",
+    hiveTicketCacheFallback: "设置 useSubjectCredsOnly=false",
+    hiveJvmOptions: "JVM 参数",
+    hiveJvmOptionsPlaceholder: "-Dsun.security.krb5.debug=true",
+    gbaseServer: "GBASEDBTSERVER",
+    informixServer: "INFORMIXSERVER",
+    sslEnable: "启用加密连接",
+    caCertPath: "CA 证书",
+    caCertPathPlaceholder: "可选，例如 ~/.yandex/RootCA.crt",
+    caCertPathBrowse: "选择证书",
+    redisTlsInsecure: "跳过证书验证",
+    redisTlsInsecureHint: "等价于 redis-cli --tls --insecure，适用于自签名证书或私有 CA。",
+    mysqlTlsMode: "TLS 模式",
+    mysqlTlsModePreferred: "优先使用",
+    mysqlTlsModeDisabled: "禁用",
+    mysqlTlsModeRequired: "必须使用",
+    mysqlTlsModeVerifyCa: "验证 CA",
+    mysqlTlsModeVerifyIdentity: "验证身份",
+    mysqlCleartextPasswordAuth: "明文密码认证",
+    mysqlCleartextPasswordAuthHint: "仅在 MySQL 服务端要求明文密码认证插件时开启。",
+    mysqlCaCertHint: "服务端证书由私有 CA 签发时，Verify CA / Verify Identity 模式需要填写。",
+    mysqlClientCert: "客户端认证",
+    mysqlClientCertPlaceholder: "/path/to/client.crt",
+    mysqlClientKeyPlaceholder: "/path/to/client.key",
+    mysqlClientCertHint: "MySQL 要求 mTLS 时，客户端证书和私钥必须一起填写。",
+    mysqlTlsConnectionFailureHint: "如果 MySQL 服务端不要求 TLS，请编辑连接，在 TLS 模式中选择“禁用”后重试。",
+    mysqlClientCertBrowse: "选择客户端证书",
+    mysqlClientKeyBrowse: "选择客户端私钥",
+    postgresSslMode: "TLS 模式",
+    postgresSslModeDisable: "禁用",
+    postgresSslModePrefer: "优先使用",
+    postgresSslModeRequire: "必须使用",
+    postgresSslModeVerifyCa: "验证 CA",
+    postgresSslModeVerifyFull: "完整验证",
+    postgresServerCert: "服务端 CA",
+    postgresRootCertPlaceholder: "/path/to/ca.crt",
+    postgresRootCertHint: "服务端证书由私有 CA 签发时，在 verify-ca 或 verify-full 模式下填写。",
+    postgresRootCertBrowse: "选择 CA 证书",
+    postgresClientCert: "客户端认证",
+    postgresClientCertPlaceholder: "/path/to/client.crt",
+    postgresClientKeyPlaceholder: "/path/to/client.key",
+    postgresClientCertHint: "PostgreSQL 要求 mTLS 时，客户端证书和私钥必须一起填写。",
+    postgresClientCertBrowse: "选择客户端证书",
+    postgresClientKeyBrowse: "选择客户端私钥",
+    connectionUrlOptional: "URL（可选）",
+    connectionUrlPlaceholder: "postgresql://user:pass{'@'}host:5432/db?sslmode=require",
+    parseConnectionUrl: "解析连接 URL",
+    parseConnectionUrlApplied: "已应用连接 URL",
+    parseConnectionUrlFailed: "解析连接 URL 失败：{message}",
+    mode: "连接方式",
+    modeForm: "表单",
+    redisStandaloneMode: "直连",
+    redisSentinelMode: "哨兵",
+    redisClusterMode: "集群",
+    oceanbaseMySQLMode: "MySQL 模式",
+    oceanbaseOracleMode: "Oracle 模式",
+    redisFirstSentinel: "首个哨兵",
+    redisFirstClusterNode: "首个种子节点",
+    redisSentinelNodes: "哨兵节点",
+    redisClusterNodes: "集群种子节点",
+    redisSentinelMaster: "Master 名称",
+    redisSentinelUser: "哨兵用户名",
+    redisSentinelPassword: "哨兵密码",
+    redisSentinelTls: "哨兵 TLS",
+    redisSentinelTlsHint: "连接 Sentinel 节点时使用 TLS",
+    redisKeySeparator: "键名分隔符（可选）",
+    etcdEndpoints: "Endpoints",
+    etcdEndpointsHint: "每行一个 endpoint。留空时使用上面的 host 和端口。",
+    etcdCaCertPlaceholder: "/path/to/ca.crt",
+    etcdCaCertBrowse: "选择 CA 证书",
+    etcdClientAuth: "客户端认证",
+    etcdClientCertPlaceholder: "/path/to/client.crt",
+    etcdClientKeyPlaceholder: "/path/to/client.key",
+    etcdClientCertHint: "etcd 要求 mTLS 时，客户端证书和私钥必须一起填写。",
+    etcdClientCertBrowse: "选择客户端证书",
+    etcdClientKeyBrowse: "选择客户端私钥",
+    etcdClientCertPairRequired: "客户端证书和私钥必须一起填写。",
+    zookeeperConnectString: "Connect String",
+    zookeeperConnectStringHint: "可用逗号或换行分隔 host:port；留空时使用上面的 host 和端口。",
+    zookeeperCreateModePersistent: "持久节点",
+    zookeeperCreateModeEphemeral: "临时节点",
+    zookeeperCreateModePersistentSequential: "持久顺序节点",
+    zookeeperCreateModeEphemeralSequential: "临时顺序节点",
+    nacosConsoleUrl: "控制台 URL",
+    nacosConsoleUrlHint: "填写 Nacos 控制台/admin API 地址。Nacos 3 Docker 通常是 8085；如果旧版控制台和服务共用 8848，也可以填 8848。",
+    nacosConsoleUrlRequired: "Nacos 控制台 URL 不能为空",
+    nacosConsoleUrlAutoAdjusted: "已自动将 Nacos 控制台 URL 从 {from} 调整为 {to}。",
+    nacosNamespace: "命名空间",
+    nacosContextPath: "Context Path",
+    nacosContextPathPlaceholder: "留空或填写 /nacos",
+    nacosAuth: "认证",
+    nacosAuthNone: "无",
+    nacosAuthUserPassword: "用户名 / 密码",
+    nacosUsernameRequired: "Nacos 用户名不能为空",
+    nacosTls: "TLS",
+    nacosTlsSkipVerify: "跳过证书验证",
+    nacosPageSize: "分页大小",
+    kafkaKerberosPrincipal: "Principal",
+    kafkaKerberosKeytab: "Keytab",
+    kafkaKerberosServiceName: "服务名",
+    kafkaKerberosKrb5Conf: "krb5.conf",
+    kafkaKerberosPrincipalRequired: "Kafka Kerberos principal 不能为空",
+    kafkaKerberosKeytabRequired: "Kafka Kerberos keytab 路径不能为空",
+    kafkaKerberosKeytabBrowse: "选择 Keytab",
+    kafkaKerberosKrb5ConfBrowse: "选择 krb5.conf",
+    kafkaKerberosKeytabPlaceholder: "DBX Agent 所在机器路径，例如 /etc/security/keytabs/user.keytab",
+    kafkaKerberosKrb5ConfPlaceholder: "可选，DBX Agent 所在机器路径，例如 /etc/krb5.conf",
+    kafkaKerberosPathHint: "keytab 和 krb5.conf 路径由 DBX Agent 读取，必须存在于运行 DBX Agent 的机器上；不会从当前浏览器上传文件。",
+    kafkaKerberosAuthHint: "使用 GSSAPI + keytab 登录。若服务端要求加密传输，请将 Security 设为 SASL_SSL；否则可使用 Auto 或 SASL_PLAINTEXT。",
+    searchDatabasePlaceholder: "搜索数据库类型",
+    iconView: "图标视图",
+    listView: "列表视图",
+    selectedDatabase: "已选择",
+    noDatabaseMatches: "没有匹配的数据库",
+    next: "下一步",
+    back: "上一步",
+    basicTab: "连接信息",
+    tlsTab: "TLS/SSL",
+    test: "测试",
+    testing: "测试中...",
+    copyTestResult: "复制测试结果",
+    sqlServerLegacyCompatibilityMode: "旧版兼容模式",
+    sqlServerLegacyCompatibilityModeEnable: "使用 SQL Server 旧版兼容连接",
+    sqlServerLegacyCompatibilityModeEnabled: "已启用 SQL Server 旧版兼容模式。",
+    sqlServerLegacyCompatibilityModeHint: "适用于非加密、仅登录阶段加密或 TLS 1.0 旧版兼容场景。若兼容组件未安装，DBX 会先安装再启用该模式\n若回退到兼容组件，部分 SQL Server 原生能力可能不可用\n请仅在可信内网、VPN 或 SSH 隧道中使用",
+    sqlServerLegacyCompatibilityComponent: "SQL Server 旧版兼容组件",
+    sqlServerLegacyCompatibilityComponentInstalling: "正在安装 SQL Server 旧版兼容组件...",
+    saveAndConnect: "保存并连接",
+    save: "保存",
+    editTitle: "编辑连接",
+    testSuccess: "连接成功",
+    connecting: "正在连接 {name}...",
+    cancelConnecting: "取消连接",
+    connectCancelled: "连接已取消",
+    connectSuccess: "已连接 {name}",
+    connectFailed: "连接失败：{message}",
+    driverNotInstalled: "{driver} 驱动未安装，请在驱动管理器中安装。",
+    jreNotInstalled: "JRE {jre} 运行环境未安装，请在驱动管理器中安装。",
+    systemJavaNotFound: "未在 PATH 中找到系统 Java 运行环境，请安装 Java 或选择自定义 Java 可执行文件。",
+    customJavaPathEmpty: "自定义 Java 运行环境路径为空，请选择 Java 可执行文件。",
+    agentJavaTooOld: "该驱动需要 Java 21。请在驱动管理器中使用 DBX 托管 JRE 21，或选择 Java 21 可执行文件。",
+    agentDriverUpdateConnectionHint: "当前连接使用的内置驱动有可用更新，连接失败可能与本地驱动版本过旧有关。请在「驱动管理」中更新对应驱动后重试。",
+    jdbcPluginNotInstalled: "JDBC 插件未安装，请先安装 JDBC 插件再使用此连接。",
+    lastError: "连接错误",
+    clearError: "清除连接错误",
+    saveFailed: "保存连接失败：{message}",
+    deleted: "连接已删除",
+    deletedSelected: "已删除 {count} 个连接",
+    copied: "已复制",
+    disconnected: "已断开连接",
+    databaseConnectionClosed: "已关闭数据库连接：{name}",
+    duplicated: "连接已复制",
+    duplicatedSelected: "已复制 {count} 个连接",
+    groupDeleted: "分组已删除",
+    loadFailed: "加载已保存连接失败：{message}",
+    sshTunnel: "隧道/代理",
+    advancedTab: "高级",
+    sshEnable: "使用隧道/代理连接",
+    sshHost: "SSH 主机",
+    sshHostPlaceholder: "ssh.example.com 或 ~/.ssh/config 中的别名",
+    sshUser: "SSH 用户",
+    sshAuthMethod: "登录方式",
+    sshAuthMethodPassword: "密码",
+    sshAuthMethodKey: "私钥",
+    sshAuthMethodNone: "无认证",
+    sshAuthMethodNoneHint: "不会发送任何凭据,适用于接受无认证连接的 bastion 或代理。",
+    sshAuthMethodAgentLegacy: "SSH Agent(旧版)",
+    sshPassword: "SSH 密码",
+    sshPasswordPlaceholder: "留空则使用密钥",
+    sshKeyPath: "密钥路径",
+    sshKeyPassphrase: "密钥密码",
+    sshKeyPassphrasePlaceholder: "密钥未加密则留空",
+    sshKeyPathBrowse: "浏览",
+    sshExposeLan: "允许局域网访问隧道",
+    sshConnectTimeout: "SSH 超时时间（秒）",
+    sshHops: "隧道/代理层级",
+    sshHopAdd: "添加 SSH 层",
+    sshHopDuplicate: "复制",
+    sshHopDelete: "删除",
+    sshHopMoveUp: "上移",
+    sshHopMoveDown: "下移",
+    sshHopName: "连接层名称",
+    sshHopNamePlaceholder: "堡垒机、跳板机、生产网关",
+    sshHopDefaultName: "第 {index} 层",
+    sshHopInvalidHost: "{hop}：SSH 主机不能为空",
+    sshHopInvalidUser: "{hop}：SSH 用户不能为空",
+    sshHopInvalidPort: "{hop}：SSH 端口必须在 1 到 65535 之间",
+    sshHopInvalidAuth: "{hop}：需要填写密码、密钥路径或勾选使用 ssh-agent",
+    sshUseAgent: "使用 ssh-agent",
+    sshAgentSockPath: "Agent Socket 路径",
+    sshAgentSockPathPlaceholder: "如 ~/.ssh/agent.sock",
+    sshHopInvalidTimeout: "{hop}：SSH 超时时间必须在 1 到 300 秒之间",
+    connectTimeout: "连接超时（秒）",
+    queryTimeout: "查询超时（秒）",
+    idleTimeout: "空闲超时（秒）",
+    keepaliveInterval: "保持连接间隔（秒）",
+    readOnly: "只读模式",
+    readOnlyHint: "阻止所有写操作（INSERT、UPDATE、DELETE 等）",
+    readOnlyBadge: "只读",
+    proxy: "代理",
+    proxyEnable: "通过代理连接数据库",
+    proxyType: "代理类型",
+    proxyHost: "代理主机",
+    proxyUsername: "代理用户",
+    proxyUsernamePlaceholder: "可选",
+    proxyPassword: "代理密码",
+    proxyPasswordPlaceholder: "可选",
+    tunnelProfile: "隧道档案",
+    tunnelProfileCustom: "自定义（仅此连接）",
+    tunnelProfileManaged: "由共享隧道档案管理。请在 设置 > 隧道维护 中编辑，修改会在下次连接时对所有使用该档案的连接生效。",
+    tunnelProfileMissing: "引用的隧道档案已不存在。请选择其他档案或切换为自定义配置。",
+    tunnelProfileMissingName: "档案已删除",
+    tunnelProfileManage: "管理",
+    httpTunnel: "HTTP 隧道",
+    httpTunnelAdd: "添加 HTTP 隧道",
+    httpTunnelUrl: "隧道脚本 URL",
+    httpTunnelToken: "隧道 Token",
+    httpTunnelTokenPlaceholder: "dbx_tunnel.php 中配置的 token",
+    httpTunnelConnectTimeout: "隧道超时（秒）",
+    httpTunnelDefaultName: "HTTP 隧道 {index}",
+    httpTunnelInvalidOrder: "{hop}：HTTP 隧道必须位于隧道/代理第一层",
+    httpTunnelInvalidUrl: "{hop}：隧道脚本 URL 不能为空",
+    httpTunnelInvalidTimeout: "{hop}：HTTP 隧道超时时间必须在 1 到 300 秒之间",
+    dremioArrowFlightSqlMode: "Arrow Flight SQL",
+    dremioLegacyJdbcMode: "Legacy JDBC",
+    jdbcUrl: "JDBC URL",
+    jdbcUrlPlaceholder: "jdbc:postgresql://localhost:5432/database",
+    jdbcDriverClass: "驱动类（可选）",
+    jdbcDriverClassPlaceholder: "多数驱动可自动识别；需要时填写 com.vendor.jdbc.Driver",
+    jdbcDriverPaths: "驱动 JAR",
+    jdbcDriverSelectPlaceholder: "选择已导入驱动",
+    jdbcManualClasspath: "手动 classpath",
+    jdbcManualClasspathCount: "{count} 个路径",
+    jdbcDriverPathsPlaceholder: "/path/to/driver.jar\n/path/to/another-driver.jar",
+    jdbcDriverBrowse: "选择 JDBC 驱动 JAR",
+    jdbcDocs: "查看 JDBC 文档",
+    jdbcPluginHint: "先安装 DBX JDBC 插件，再导入数据库厂商提供的 JDBC 驱动 JAR。",
+    dmCompatHint: "需要在系统上安装达梦 DM8 ODBC 驱动程序。",
+    dmDownload: "前往达梦官网下载",
+    mongoLegacyHint: "旧版 MongoDB（尤其是 4.2 以下版本）请选择旧版兼容。若账号创建在 admin 且认证失败，请将认证库设为 admin。",
+    mongoTlsAllowInvalidCertificates: "禁用 TLS 证书校验",
+    mongoTlsAllowInvalidCertificatesHint: "对应 tlsAllowInvalidCertificates=true，会禁用全部证书校验（不仅是主机名），存在中间人攻击风险。经 SSH 隧道访问 AWS DocumentDB 时通常需要开启。",
+    mongoRetryWrites: "重试写入",
+    mongoRetryWritesHint: "对应 retryWrites。AWS DocumentDB 不支持可重试写入，请关闭。",
+    compatible: "兼容",
+    mainstream: "主流",
+    color: "颜色",
+    colorNone: "无颜色",
+    colorGreen: "绿色",
+    colorYellow: "黄色",
+    colorOrange: "橙色",
+    colorRed: "红色",
+    colorBlue: "蓝色",
+    colorPurple: "紫色",
+    colorCustom: "自定义颜色",
+  },
+  editor: {
+    pressToExecute: "按 {mod}+Enter 执行查询",
+    pressToSaveSql: "按 {mod}+S 保存 SQL",
+    queryTimeoutError: "查询超时 ({seconds}s)，请检查数据库连接是否正常",
+    changeQueryTimeout: "修改查询超时时间",
+    connectionMayBeLost: "连接可能已断开，请刷新数据重试",
+    showResultsPane: "显示结果",
+    hideResultsPane: "收起",
+    noDatabase: "未选择数据库",
+    unsavedChangesTitle: "未保存的更改",
+    unsavedChangesMessage: "「{title}」有未保存的更改，关闭后将丢失。是否保存后再关闭？",
+    unsavedChangesBatchCloseMessage: "待关闭的标签页中有未保存的更改，关闭后将丢失。是否保存后再继续关闭？",
+    unsavedChangesBatchCloseMultipleMessage: "待关闭的 {count} 个 SQL 标签有未保存更改，当前已定位到「{title}」。是否保存后继续关闭？",
+    unsavedChangesAppCloseMessage: "「{title}」有未保存的 SQL 更改，退出 DBX 后将丢失。是否保存后再退出？",
+    unsavedChangesAppCloseMultipleMessage: "当前有 {count} 个 SQL 标签未保存，当前已定位到「{title}」。退出 DBX 后将丢失，是否保存后再退出？",
+    unsavedChangesViewList: "查看 {count} 个标签",
+    unsavedChangesListTitle: "未保存的标签（{count}）",
+    discardChanges: "不保存",
+    discardAllChanges: "全部不保存",
+    saveAllChanges: "全部保存",
+    selectConnection: "选择连接",
+    searchConnection: "搜索连接...",
+    selectDatabase: "选择数据库",
+    selectDatabaseRequired: "请先选择数据库",
+    searchDatabase: "搜索数据库...",
+    selectSchema: "选择模式",
+    searchSchema: "搜索模式...",
+    setDefaultDatabase: "设为默认",
+    defaultDatabase: "默认库",
+    clearDatabase: "清除数据库选择",
+    exPasteNoValues: "剪贴板中没有可用于 IN 条件的值",
+    exPasteNotList: "未识别到可转换的多值列表",
+    exPasteTooLarge: "剪贴板内容过大，最多支持 {limit} 字符",
+    exPasteTooManyValues: "值过多，最多支持 {limit} 个",
+    exPasteClipboardReadFailed: "读取剪贴板失败：{message}",
+    exPastePasted: "已粘贴 {count} 个 IN 条件值",
+    completion: {
+      nullValue: "空值",
+      isNull: "判断是否为 NULL",
+      isNotNull: "判断是否不为 NULL",
+      stringLiteral: "字符串字面量",
+      numericLiteral: "数值字面量",
+      booleanValue: "布尔值",
+      starExpansionColumns: "{count} 列",
+      functionDescriptions: {
+        COUNT: "返回行数",
+        SUM: "返回数值列的总和",
+        AVG: "返回数值列的平均值",
+        MIN: "返回最小值",
+        MAX: "返回最大值",
+        GROUP_CONCAT: "将分组中的值连接为字符串",
+        STRING_AGG: "将分组中的字符串连接起来",
+        CONCAT: "连接多个字符串",
+        CONCAT_WS: "使用分隔符连接多个字符串",
+        SUBSTRING: "提取子字符串",
+        REPLACE: "替换字符串中的内容",
+        TRIM: "去除首尾空格",
+        UPPER: "转换为大写",
+        LOWER: "转换为小写",
+        LENGTH: "返回字符串长度",
+        REGEXP_REPLACE: "使用正则表达式替换",
+        DATE_FORMAT: "按指定格式格式化日期",
+        DATEDIFF: "计算两个日期的差值",
+        DATE_ADD: "对日期进行加法运算",
+        DATE_SUB: "对日期进行减法运算",
+        EXTRACT: "提取日期中的指定部分",
+        NOW: "返回当前日期时间",
+        ROUND: "四舍五入到指定小数位",
+        FLOOR: "向下取整",
+        CEIL: "向上取整",
+        ABS: "返回绝对值",
+        MOD: "返回除法余数",
+        COALESCE: "返回第一个非 NULL 的参数",
+        IFNULL: "如果为 NULL 则返回替代值",
+        NULLIF: "如果相等则返回 NULL",
+        CAST: "将表达式转换为指定类型",
+        JSON_EXTRACT: "从 JSON 中提取值",
+        JSON_VALUE: "从 JSON 中提取标量值",
+        JSON_OBJECT: "创建 JSON 对象",
+        JSON_ARRAY: "创建 JSON 数组",
+      },
+    },
+    contextMenu: {
+      executeSelection: "执行选中 SQL",
+      executeCurrent: "执行 SQL",
+      copySelection: "复制选中内容",
+      sendToAi: "发送到 AI",
+      uppercaseSelection: "转为大写",
+      lowercaseSelection: "转为小写",
+      selectAll: "全选",
+    },
+    search: {
+      find: "查找",
+      replace: "替换",
+      replaceAll: "全部替换",
+      caseSensitive: "区分大小写",
+      regex: "正则表达式",
+      collapseReplace: "收起替换",
+      expandReplace: "展开替换",
+      prevMatch: "上一个 (Shift+Enter)",
+      nextMatch: "下一个 (Enter)",
+      close: "关闭 (Esc)",
+      noResults: "无结果",
+    },
+    executionPicker: {
+      title: "执行目标",
+      currentStatement: "当前 SQL",
+      allStatements: "全部 SQL",
+      currentCommand: "当前命令",
+      allCommands: "全部命令",
+    },
+  },
+  tabs: {
+    sql: "SQL",
+    table: "表",
+    tableData: "数据表",
+    redis: "Redis",
+    etcd: "etcd",
+    zookeeper: "ZooKeeper",
+    mongo: "Mongo",
+    gridfs: "GridFS",
+    vector: "向量",
+    objects: "对象",
+    users: "用户与权限",
+    executionSummary: "摘要",
+    tooltipTitle: "标题：",
+    tooltipFilePath: "文件路径：",
+    tooltipConnection: "连接：",
+    tooltipDatabase: "数据库：",
+    tooltipTable: "表：",
+    tooltipCollection: "集合：",
+    tooltipSchema: "Schema：",
+    resultN: "结果 {n}",
+    runN: "执行 {n}",
+    resultRuns: "执行结果",
+    removeRun: "删除执行 {n}",
+    autoKeepResults: "自动保留查询结果",
+    autoKeepResultsEnabled: "已开启自动保留结果",
+    autoKeepResultsDisabled: "已关闭自动保留结果",
+    autoRefresh: "自动刷新结果",
+    autoRefreshShort: "自动",
+    autoRefreshEvery: "每 {seconds} 秒刷新",
+    startAutoRefresh: "开始自动刷新",
+    stopAutoRefresh: "停止自动刷新",
+    missingResultRun: "此结果已不可用",
+    exportResultArchive: "保存结果归档",
+    importResultArchive: "导入结果归档",
+    importedResultArchive: "导入的结果",
+    resultArchiveExported: "结果已导出",
+    resultArchiveImported: "结果已导入",
+    resultArchiveUnavailable: "没有可导出的已保存结果",
+    resultArchiveImportInvalid: "无法打开此结果归档",
+    resultArchiveExportFailed: "导出结果失败：{message}",
+    resultArchiveImportFailed: "导入结果失败：{message}",
+    scrollLeft: "向左滚动标签页",
+    scrollRight: "向右滚动标签页",
+    openTabs: "已打开的标签页",
+    fixedTabs: "固定标签页",
+    openDataTabs: "已打开的数据表",
+  },
+  gridfsBrowser: {
+    bucketCount: "\u5b58\u50a8\u6876",
+    fileCount: "\u6587\u4ef6",
+    name: "\u540d\u79f0",
+    totalSize: "\u5927\u5c0f",
+    chunkSize: "\u5757\u5927\u5c0f",
+    uploadDate: "\u4e0a\u4f20\u65e5\u671f",
+    contentType: "\u5185\u5bb9\u7c7b\u578b",
+    metadata: "\u5143\u6570\u636e",
+    selectBucket: "\u9009\u62e9\u4e00\u4e2a GridFS \u5b58\u50a8\u6876\u4ee5\u67e5\u770b\u6216\u6253\u5f00\u3002",
+    selectFile: "\u9009\u62e9\u4e00\u4e2a GridFS \u6587\u4ef6\u4ee5\u67e5\u770b\u6216\u7ba1\u7406\u3002",
+    emptyBuckets: "\u5f53\u524d\u6ca1\u6709 GridFS \u5b58\u50a8\u6876\uff0c\u53ef\u4ee5\u5148\u65b0\u5efa\u4e00\u4e2a\u3002",
+    emptyFiles: "\u5f53\u524d\u5b58\u50a8\u6876\u8fd8\u6ca1\u6709\u6587\u4ef6\uff0c\u53ef\u4ee5\u5148\u4e0a\u4f20\u4e00\u4e2a\u3002",
+    createBucket: "\u65b0\u5efa\u5b58\u50a8\u6876",
+    openBucket: "\u6253\u5f00\u5b58\u50a8\u6876",
+    deleteBucket: "\u5220\u9664\u5b58\u50a8\u6876",
+    createTitle: "\u65b0\u5efa GridFS \u5b58\u50a8\u6876",
+    deleteTitle: "\u5220\u9664 GridFS \u5b58\u50a8\u6876",
+    deleteMessage: "\u786e\u5b9a\u5220\u9664\u9009\u4e2d\u7684 GridFS \u5b58\u50a8\u6876\u53ca\u5176\u4e2d\u7684\u6240\u6709\u6587\u4ef6\u5417\uff1f",
+    bucketName: "\u5b58\u50a8\u6876\u540d\u79f0",
+    bucketNamePlaceholder: "example_bucket",
+    bucketCreated: "\u5df2\u521b\u5efa\u5b58\u50a8\u6876 {bucket}\u3002",
+    bucketDeleted: "\u5df2\u5220\u9664\u5b58\u50a8\u6876 {bucket}\u3002",
+    uploadFile: "\u4e0a\u4f20\u6587\u4ef6",
+    downloadFile: "\u4e0b\u8f7d\u6587\u4ef6",
+    downloadSelected: "\u4e0b\u8f7d\u9009\u4e2d",
+    deleteFile: "\u5220\u9664\u6587\u4ef6",
+    selectedCount: "\u5df2\u9009 {count} \u4e2a",
+    deleteFileTitle: "\u5220\u9664 GridFS \u6587\u4ef6",
+    deleteFileMessage: "\u786e\u5b9a\u4ece\u5f53\u524d GridFS \u5b58\u50a8\u6876\u4e2d\u5220\u9664\u9009\u4e2d\u6587\u4ef6\u5417\uff1f",
+    fileUploaded: "\u5df2\u4e0a\u4f20 {fileName}\u3002",
+    fileDeleted: "\u5df2\u5220\u9664 {fileName}\u3002",
+  },
+  executionSummary: {
+    empty: "暂无摘要",
+    executing: "正在执行...",
+    statement: "语句",
+    type: "类型",
+    rows: "返回行",
+    affected: "影响行",
+    time: "耗时",
+    success: "成功",
+    error: "错误",
+    returnedTable: "返回 {count} 列结果表",
+    noTable: "未返回结果表",
+  },
+  chart: {
+    title: "图表",
+    type: "类型",
+    line: "折线图",
+    bar: "柱状图",
+    pie: "饼图",
+    noNumericData: "没有可用于图表的数值数据",
+  },
+  grid: {
+    rows: "{count} 行",
+    totalRows: "共 {count} 行",
+    totalRowCount: "（总计 {count} 行）",
+    totalRowCountLoading: "（统计中...）",
+    loadingMore: "加载更多数据...",
+    allLoaded: "已全部加载",
+    calculateTotalRows: "统计总行数",
+    calculateTotalRowsInline: "（统计总行数）",
+    calculateTotalRowsFailed: "统计失败：{message}",
+    rowsAffected: "影响 {count} 行",
+    querySuccess: "查询执行成功",
+    noRows: "暂无数据",
+    noRowsDescription: "当前结果集没有任何记录。",
+    noSearchResults: "没有匹配结果",
+    noSearchResultsDescription: "换个关键词试试。",
+    noFilteredRows: "没有符合条件的行",
+    noFilteredRowsDescription: "调整搜索词或状态筛选试试。",
+    copy: "复制",
+    mongoJsonPreview: "JSON 预览",
+    mongoJsonPreviewEmpty: "选择一条 MongoDB 文档以预览。",
+    copyJson: "复制 JSON",
+    copyDdl: "复制 DDL",
+    copyCell: "复制单元格",
+    copyRow: "复制行 (JSON)",
+    copyColumnJson: "复制列 (JSON)",
+    copyColumnNames: "复制全部列名",
+    copyRowInsert: "复制为 INSERT 语句",
+    copyRowInsertWithoutPrimaryKeys: "复制为 INSERT 语句（不含主键）",
+    copyRowUpdate: "复制为 UPDATE 语句",
+    copyAll: "复制全部 (TSV)",
+    selection: "选区",
+    selectionSum: "SUM: {value}",
+    selectionCells: "{count} 个单元",
+    copySelectionTsv: "复制选区 (TSV)",
+    copySelectionTsvWithHeaders: "复制选区含表头 (TSV)",
+    copySelectionCsv: "复制选区 (CSV)",
+    copySelectionJson: "复制选区 (JSON)",
+    copySelectionSql: "复制选区为 SQL IN 列表",
+    clearSelection: "清除选区",
+    export: "导出",
+    exportCsv: "导出 CSV",
+    exportXlsx: "导出 XLSX",
+    exportCurrentPageCsv: "导出当前页 CSV",
+    exportCurrentPageXlsx: "导出当前页 XLSX",
+    exportCurrentPageJson: "导出当前页 JSON",
+    exportCurrentPageMarkdown: "导出当前页 Markdown",
+    exportCurrentPageSql: "导出当前页 SQL INSERT",
+    exportCurrentResultCsv: "导出当前结果集全部数据 CSV",
+    exportCurrentResultXlsx: "导出当前结果集全部数据 XLSX",
+    exportCurrentResultJson: "导出当前结果集全部数据 JSON",
+    exportCurrentResultMarkdown: "导出当前结果集全部数据 Markdown",
+    exportCurrentResultSql: "导出当前结果集全部数据 SQL INSERT",
+    exportAllResultsXlsx: "导出本次执行全部结果集为 XLSX",
+    exportJson: "导出 JSON",
+    exportMarkdown: "导出 Markdown",
+    exportSql: "导出 SQL INSERT",
+    exportSelectedRowsCsv: "导出选中行为 CSV",
+    exportSelectedRowsXlsx: "导出选中行为 XLSX",
+    exportSelectedRowsJson: "导出选中行为 JSON",
+    exportSelectedRowsMarkdown: "导出选中行为 Markdown",
+    exportSelectedRowsSql: "导出选中行为 SQL INSERT",
+    exported: "导出完成",
+    exportFailed: "导出失败：{message}",
+    copied: "已复制",
+    copyFailed: "复制失败：{message}",
+    previewSqlEmpty: "暂无待预览的 SQL 更改",
+    renderMode: "渲染模式",
+    domRenderMode: "DOM",
+    canvasRenderMode: "Canvas",
+    renderModeHint: "在 Canvas 渲染和 DOM 兜底表格之间切换。",
+    tableFontSize: "表格字号",
+    filter: "筛选",
+    conditionHistoryEmpty: "暂无历史记录",
+    conditionHistoryNoMatches: "没有匹配的历史记录",
+    filterBuilder: "筛选器",
+    filterBuilderTitle: "筛选器",
+    filterBuilderHint: "点选筛选条件，并与手写 WHERE 一起生效。",
+    filterBuilderSummary: "{count} 条规则",
+    filterBuilderAddRule: "新增条件",
+    filterBuilderColumn: "字段",
+    filterBuilderSearchColumns: "搜索字段...",
+    filterBuilderNoMatchingColumns: "没有匹配的字段",
+    filterBuilderValue: "值",
+    filterBuilderNoValue: "无需输入值",
+    filterBuilderEmpty: "新增一条条件后即可开始筛选。",
+    resetFilterBuilder: "重置条件",
+    filterBuilderEquals: "等于",
+    filterBuilderNotEquals: "不等于",
+    filterBuilderContains: "包含",
+    filterBuilderNotContains: "不包含",
+    filterBuilderGreaterThan: "大于",
+    filterBuilderLessThan: "小于",
+    filterBuilderIsNull: "为空",
+    filterBuilderIsNotNull: "不为空",
+    columnActions: "字段操作",
+    localFilter: "本地值筛选",
+    localFilterFor: "本地值筛选“{column}”",
+    databaseValueFilter: "数据库值筛选",
+    databaseValueFilterFor: "数据库值筛选“{column}”",
+    columnFormatter: "列格式化",
+    columnFormatterFor: "格式化“{column}”",
+    columnFormatterHint: "仅改变显示效果，原始值保持不变。",
+    formatterType: "类型",
+    formatterDatetime: "Unix 时间戳",
+    formatterJsonPath: "JSON 路径",
+    formatterMask: "文本脱敏",
+    formatterCustomTemplate: "自定义模板",
+    formatterTimestampUnit: "时间戳单位",
+    formatterUnitAuto: "自动",
+    formatterUnitSeconds: "秒",
+    formatterUnitMilliseconds: "毫秒",
+    formatterDatetimePattern: "日期时间格式",
+    formatterDatetimePatternPlaceholder: "选择或输入日期时间格式",
+    formatterDatetimePatternEmpty: "默认 ISO8601 格式",
+    formatterJsonPathInput: "JSON 路径",
+    formatterMaskPrefix: "前缀保留",
+    formatterMaskSuffix: "后缀保留",
+    formatterSavedCustom: "已保存模板",
+    formatterNewCustom: "新建模板",
+    formatterCustomName: "模板名称",
+    formatterCustomNamePlaceholder: "例如：用户标签",
+    formatterCustomTemplateInput: "模板",
+    formatterCustomTemplateHint: "可用变量：${value}、${upper}、${lower}、${length}。填写名称后会保存到列表。",
+    formatterPreview: "预览",
+    saveFormatter: "保存",
+    clearFormatter: "清除",
+    searchValues: "搜索值...",
+    loadingValues: "正在加载值...",
+    serverValuesLimited: "仅显示前 {count} 个值",
+    filterTypedValue: "使用“{value}”筛选",
+    value: "值",
+    count: "数量",
+    applyFilter: "应用筛选",
+    clearLocalFilters: "清除本地值筛选",
+    clearLocalFiltersShort: "清除本地",
+    localFiltersActive: "{count} 个本地值筛选",
+    localFilterMoreValues: "，还有 {count} 个",
+    columnVisibility: "字段筛选",
+    columnVisibilityHint: "至少保留一列可见。",
+    searchColumns: "搜索字段...",
+    dragColumnToReorder: "拖拽列头调整顺序",
+    invertColumnVisibility: "反选",
+    resetColumnOrder: "重置顺序",
+    showAllColumns: "显示全部",
+    viewOptions: "视图选项",
+    hideNullColumns: "隐藏 NULL 列",
+    hideNullColumnsHint: "切换隐藏当前结果中整列均为 NULL 的字段。",
+    searchMode: "搜索模式",
+    searchModeHint: "选择 Ctrl+F 搜索时过滤匹配行，或保留全部行并高亮定位命中项。",
+    searchModeFilter: "过滤",
+    searchModeHighlight: "高亮",
+    moreValues: "还有 {count} 个值，输入关键词继续缩小范围",
+    filterByValue: "筛选此值",
+    filterExcludeValue: "排除此值",
+    filterLike: "包含此值",
+    filterNotLike: "不包含此值",
+    filterLessThan: "小于此值",
+    filterGreaterThan: "大于此值",
+    filterIsNull: "仅显示 NULL",
+    filterIsNotNull: "仅显示非 NULL",
+    clearFilter: "清除筛选",
+    sort: "排序",
+    sortAscending: "升序排序",
+    sortDescending: "降序排序",
+    sortCurrentPageAscending: "当前页升序排序",
+    sortCurrentPageDescending: "当前页降序排序",
+    sortDatabaseAscending: "数据库升序排序",
+    sortDatabaseDescending: "数据库降序排序",
+    clearSort: "清除排序",
+    pasted: "已粘贴!",
+    search: "搜索...",
+    searchOrWhere: "搜索，或输入 WHERE 条件...",
+    applyWhere: "应用 WHERE",
+    filterRows: "筛选行",
+    filterAllRows: "全部行",
+    filterChangedRows: "变更项",
+    page: "第 {page} 页",
+    rowsPerPage: "每页行数",
+    customRowsPerPage: "自定义行数",
+    applyPageSize: "应用",
+    save: "保存",
+    discard: "放弃",
+    dismiss: "关闭",
+    addRow: "新增行",
+    quickEntryDraftPlaceholder: "新增",
+    cloneRow: "克隆为新行",
+    deleteRow: "删除行",
+    deleteRows: "删除 {count} 行",
+    cloneRows: "克隆 {count} 行为新行",
+    restoreRows: "恢复 {count} 行",
+    copyRows: "复制 {count} 行 (JSON)",
+    copySelectedRowsTsv: "复制 {count} 行 (TSV)",
+    copySelectedRowsTsvWithHeaders: "复制 {count} 行含表头 (TSV)",
+    copySelectedRowTsv: "复制 1 行 (TSV)",
+    copySelectedRowTsvWithHeaders: "复制 1 行含表头 (TSV)",
+    copyColumnsJson: "复制 {count} 列 (JSON)",
+    copyRowsInsert: "复制 {count} 行为 INSERT",
+    copyRowsInsertMerged: "复制 {count} 行为 INSERT（合并）",
+    copyRowsInsertRowByRow: "复制 {count} 行为 INSERT（逐行）",
+    copyRowsInsertWithoutPrimaryKeys: "复制 {count} 行为 INSERT（不含主键）",
+    copyRowsInsertWithoutPrimaryKeysMerged: "复制 {count} 行为 INSERT（不含主键，合并）",
+    copyRowsInsertWithoutPrimaryKeysRowByRow: "复制 {count} 行为 INSERT（不含主键，逐行）",
+    copyRowsUpdate: "复制 {count} 行为 UPDATE",
+    selectedRows: "已选 {count} 行",
+    restoreRow: "恢复行",
+    statusClean: "未改",
+    statusNew: "新增项",
+    statusEdited: "更新项",
+    statusDeleted: "删除项",
+    pendingChanges: "{count} 项待保存",
+    selectedCells: "已选 {count} 个单元格",
+    bulkEditSelection: "批量修改所选",
+    bulkEditTitle: "批量修改所选",
+    bulkEditDescription: "将已选 {count} 个单元格设置为这个值。",
+    bulkEditValuePlaceholder: "输入值，或 NULL",
+    applyBulkEdit: "应用",
+    cellDetails: "单元格详情",
+    cellDetailLayoutBottom: "移动到底部",
+    cellDetailLayoutRight: "移动到右侧",
+    openCellDetailsDialog: "单元格详情",
+    rowDetails: "行详情",
+    rowDetailsFor: "第 {row} 行详情",
+    openRowDetailsDialog: "行详情",
+    openColumnDetailsDialog: "列详情",
+    columnDetailsFor: "“{column}”列详情",
+    columnsCount: "{count} 列",
+    rowCount: "行数",
+    rowsCount: "{count} 行",
+    fieldIndex: "序号",
+    cellValue: "值",
+    valueEditor: "值编辑器",
+    hexViewer: "Hex 查看器",
+    hexViewerByteCount: "{count} 字节",
+    hexViewerOffset: "偏移",
+    hexViewerHex: "Hex",
+    hexViewerAscii: "ASCII",
+    hexViewerEmpty: "没有可显示的二进制字节。",
+    imagePreview: "图片预览",
+    imageLoadFailed: "图片加载失败",
+    geometryPreview: "图形预览",
+    layerPreview: "图层预览",
+    zoomIn: "放大",
+    zoomOut: "缩小",
+    fitImage: "适合显示区域",
+    openImage: "打开图片",
+    columnName: "列名",
+    columnType: "类型",
+    columnComment: "注释",
+    rowNumber: "行号",
+    valueLength: "长度",
+    nullValue: "NULL",
+    emptyStringValue: "空字符串",
+    noComment: "暂无注释",
+    formattedJson: "格式化 JSON",
+    formattedValue: "格式化值",
+    detailSearchPlaceholder: "搜索字段名或值…",
+    detailSearchNoMatch: "无匹配项",
+    rawValue: "原始值",
+    largeValuePreviewHint: "仅预览前 {count} 个字符，复制仍会使用完整值。",
+    copyValue: "复制值",
+    downloadBinaryValue: "下载值",
+    downloadSaved: "已保存到 {path}",
+    downloadStarted: "已交给浏览器下载：{fileName}",
+    binaryDownload: {
+      binary: "原始二进制",
+      utf8: "解码文本 (UTF-8)",
+      gbk: "解码文本 (GBK)",
+    },
+    copyRowTsv: "复制行 (TSV)",
+    copyColumnValues: "复制列 (JSON)",
+    copyColumnTsv: "复制列 (TSV)",
+    editValue: "编辑值",
+    formatJson: "格式化 JSON",
+    compactJson: "压缩 JSON",
+    formattedJsonEditWarning: "正在编辑格式化后的 JSON。保存后会以JSON格式写入，原始排版可能变化。",
+    setNull: "设为 NULL",
+    restoreOriginalValue: "恢复原值",
+    copyColumnName: "复制列名",
+    copyAlterColumnSql: "复制为SQL ALTER",
+    alterSqlCopied: "SQL ALTER 已复制到剪贴板",
+    alterSqlCopiedWithWarnings: "SQL ALTER 已复制到剪贴板（含 {count} 条警告）",
+    noAlterSqlAvailable: "该列无 ALTER SQL 可复制",
+    copyAlterSqlFailed: "复制失败：{message}",
+    copySqlCondition: "复制 SQL 条件",
+    transpose: "转置查看",
+    transposeMultiRowToggle: "多行转置",
+    transposeSingleRow: "当前行",
+    transposeMultiRow: "多行",
+    transposeMultiRowHint: "开启后，转置视图会同时显示多行；关闭时仅显示当前行。",
+    rowsPerPageShort: " 行/页",
+    columnDetails: "列详情",
+    tableInfo: "表属性",
+    tableInfoColumns: "字段",
+    tableInfoIndexes: "索引",
+    tableInfoForeignKeys: "外键",
+    tableInfoTriggers: "触发器",
+    tableInfoNullable: "可空",
+    tableInfoEmpty: "暂无元数据",
+    tableInfoSearch: "搜索...",
+    tableInfoNoResults: "无匹配结果",
+    goToColumn: "跳转列",
+    columnWidth: "列宽",
+    columnWidthCompact: "紧凑",
+    columnWidthStandard: "标准",
+    columnWidthComfortable: "宽松",
+    searchColumn: "搜索列/注释...",
+    noColumnsFound: "未找到列",
+    queryError: "查询出错",
+    dataUnavailable: "表数据需要重新加载。",
+    dataUnavailableHintPrefix: "按 ",
+    dataUnavailableHintSuffix: " 或点击下方刷新按钮重新加载。",
+    refresh: "刷新",
+    undoChange: "撤销更改",
+    redoChange: "重做更改",
+    commit: "提交",
+    rollback: "回滚",
+    transactionSaveHint: "在事务中提交 {count} 项待保存更改。",
+    nonTransactionalSaveHint: "逐条保存 {count} 项更改；如果中途失败，前面已成功的更改不会回滚。",
+    keylessEditWarning: "无主键定位",
+    keylessEditWarningHint: "这张表没有主键。保存更新或删除时会使用整行原始值作为 WHERE 条件；如果存在完全重复的行，可能会影响多行。",
+    queryEditReadOnly: "只读结果",
+    queryEditUnsupported: {
+      "not-select": "只有 SELECT 查询结果可以直接编辑。",
+      cte: "包含 WITH/CTE 的查询暂不支持直接回写。请改为简单单表 SELECT。",
+      "set-operation": "包含 UNION、INTERSECT 或 EXCEPT 的结果无法安全定位原表行。",
+      aggregation: "包含 DISTINCT、GROUP BY、HAVING 或聚合结果，无法直接编辑原始数据。",
+      "external-source": "外部文件或表函数查询结果无法直接回写，请先导入到数据库表后再编辑。",
+      "complex-source": "无法为此结果唯一确定一个安全的回写目标表。",
+      "computed-columns": "结果列包含表达式或函数，无法安全回写。请查询原始列名。",
+      "no-table": "未识别到可编辑的数据表。",
+      "no-primary-key": "目标表没有主键，无法安全定位要更新或删除的行。",
+      "primary-key-not-returned": "结果中缺少原始主键列。请把主键列按原列名一起查询出来。",
+      "aliased-columns": "结果列使用了别名或表达式。请使用原始列名查询需要编辑的列。",
+      "metadata-unavailable": "无法读取目标表元数据，暂不能启用结果编辑。",
+    },
+    sortUnsupported: "当前 SQL 不支持全量排序，请改为单条 SELECT 查询后再尝试。",
+    truncatedHint: "结果已截断，仅显示前 {count} 行。可通过底部分页继续加载，或调整每页行数。",
+  },
+  exportProgress: {
+    title: "导出表数据",
+    fetching: "正在从数据库获取数据...",
+    writing: "正在写入文件...",
+    done: "导出完成！",
+    error: "导出失败",
+    cancelled: "导出已取消。",
+    rowsCount: "已导出 {exported} / {total} 行",
+    rowsExported: "已导出 {count} 行",
+    rowsShort: "行",
+    cancel: "取消",
+    close: "关闭",
+    tooltip: "后台任务",
+    failedTooltip: "{count} 个后台任务失败",
+    popoverTitle: "后台任务",
+    noTasks: "暂无后台任务",
+    clearFinished: "清除已完成",
+    showMore: "展开其余 {count} 个",
+    showLess: "收起",
+    delete: "删除",
+    databaseExportTitle: "数据库备份：{name}",
+    sqlFileTitle: "SQL 文件：{name}",
+    dataTransferTitle: "数据传输：{name}",
+    objectsCount: "{current} / {total} 个对象",
+    tablesCount: "{current} / {total} 张表",
+    statementsCount: "成功 {done}，失败 {failed}",
+  },
+  welcome: {
+    title: "数据库工作台",
+    subtitle: "选择左侧连接开始浏览结构，或直接创建查询标签页。DBX 支持多种数据库、查询历史、数据表格编辑和 AI SQL 助手。",
+    connections: "连接",
+    connected: "已连接",
+    databaseTypes: "数据库类型",
+    quickConnections: "快速开始",
+    quickConnectionsHint: "点击连接即可新建查询标签页。",
+    shortcuts: "常用操作",
+    shortcutsHint: "从这里开始你的下一步。",
+    sqlHistory: "历史查询",
+    sqlHistoryEmpty: "暂无 SQL 库记录",
+    sqlHistoryOpenCount: "打开 {count} 次",
+    unknownConnection: "未知连接",
+    tip: "也可以在左侧展开连接，右键数据库或表查看更多操作。",
+    tipSidebar: "点击左侧表名查看数据",
+    tipExecute: "执行查询",
+    fileOpened: "已打开 {name}",
+    mcpTitle: "AI 编程助手集成",
+    mcpDescription: "除了内置 AI 助手，还可以通过 MCP 让 Claude Code、Cursor 等编程助手直接使用这里的数据库连接。",
+    mcpLearnMore: "了解更多",
+  },
+  common: {
+    language: "语言",
+    loading: "加载中...",
+    stopping: "正在停止...",
+    close: "关闭",
+    cancel: "取消",
+    save: "保存",
+    copy: "复制",
+    import: "导入",
+    remove: "移除",
+    retry: "重试",
+    more: "更多",
+    decrease: "减小",
+    increase: "增大",
+    showPassword: "显示密码",
+    hidePassword: "隐藏密码",
+    done: "完成",
+    connection: "连接",
+    database: "数据库",
+    table: "表",
+    view: "视图",
+    materializedView: "物化视图",
+    procedure: "存储过程",
+    function: "函数",
+    sequence: "序列",
+    package: "包",
+    packageBody: "包体",
+    noResults: "无结果",
+  },
+  quickOpen: {
+    placeholder: "搜索连接、数据库、表和其他对象...",
+    emptyPlaceholder: "开始输入进行搜索",
+    noResults: "未找到结果",
+    results: "个结果",
+    navigate: "导航",
+    select: "选择",
+    close: "关闭",
+  },
+  explain: {
+    title: "执行计划",
+    standardTable: "标准表格",
+    tree: "树",
+    summary: "摘要",
+    running: "正在读取执行计划...",
+    empty: "暂无执行计划",
+    nodeCount: "{count} 个节点",
+    node: "节点",
+    relation: "表",
+    index: "索引",
+    cost: "Cost",
+    rows: "行数",
+    details: "详情",
+    unsupported: "当前数据库暂不支持执行计划",
+    emptySql: "当前没有可分析的 SQL",
+    unsafe: "第一版执行计划仅支持 SELECT / WITH / TABLE / VALUES",
+  },
+  lineage: {
+    title: "字段血缘",
+    open: "查看字段血缘",
+    loading: "正在读取元数据 {done}/{total}",
+    empty: "没有找到相关血缘",
+    noFiltered: "当前筛选条件下没有结果",
+    targetField: "当前字段",
+    searchPlaceholder: "搜索表、字段、视图或 SQL 片段...",
+    showing: "显示 {shown}/{total} 条结果",
+    all: "全部",
+    certain: "确定",
+    likely: "高置信",
+    possible: "可能相关",
+    queryHistory: "查询历史",
+    openTable: "打开对应表",
+    copy: "复制名称",
+    copied: "已复制",
+    kind: {
+      foreignKey: "外键",
+      viewReference: "视图",
+      historyReference: "历史 SQL",
+      sameName: "同名字段",
+    },
+    description: {
+      foreignKeyIncoming: "{target} 通过外键指向当前字段，这是已确认的依赖。",
+      foreignKeyOutgoing: "当前字段通过外键引用 {target}，这是已确认的依赖。",
+      viewLikely: "视图定义同时提到目标表和字段，通常表示查询依赖。",
+      viewPossible: "视图定义提到了同名字段，但没有同时命中目标表，需要人工确认。",
+      historyLikely: "历史 SQL 同时提到目标表和字段，可作为排查影响面的参考。",
+      historyPossible: "历史 SQL 提到了同名字段，可能相关但需要确认上下文。",
+      sameName: "其他表存在同名字段，可能代表相同业务含义，但不是已验证的数据库依赖。",
+    },
+    cancel: "取消读取",
+    refresh: "重新分析",
+  },
+  connectionGroup: {
+    createGroup: "新建分组",
+    groupNamePlaceholder: "分组名称",
+    selectConnection: "选择连接",
+    deselectConnection: "取消选择连接",
+    selectAllConnections: "全选连接",
+    deselectAllConnections: "取消全选连接",
+    exitMultiSelect: "退出多选",
+    renameGroup: "重命名分组",
+    deleteGroup: "删除分组",
+    moveToGroup: "移至分组",
+    moveToNewGroup: "移至新分组",
+    ungrouped: "取消分组",
+    newGroup: "新建分组...",
+    newGroupDefault: "新分组",
+    deleteGroupConfirmTitle: "删除分组",
+    deleteGroupConfirmMessage: "删除分组「{name}」？其中的连接将移到顶层。",
+  },
+  databaseSearch: {
+    title: "在数据库中查找",
+    open: "在数据库中查找",
+    keyword: "关键词",
+    keywordPlaceholder: "输入用户 ID、邮箱、订单号等...",
+    limitPerTable: "每表最多",
+    search: "开始查找",
+    searching: "查找中",
+    stop: "停止",
+    hint: "会扫描当前数据库或 schema 的普通表；默认跳过二进制列，并限制每张表返回数量，避免大库一次性拉取过多数据。",
+    loadingTables: "正在读取表列表...",
+    progress: "已扫描 {done}/{total} 张表",
+    resultCount: "{count} 条命中",
+    limitedTables: "表数量较多，本次仅扫描前 {count} 张表",
+    results: "查找结果",
+    openResult: "打开",
+    waiting: "等待命中结果...",
+    noResults: "暂无命中结果",
+    errors: "部分表查找失败",
+  },
+  configExport: {
+    passphraseTitle: "加密导出",
+    passphraseImportTitle: "解密导入",
+    passphraseExportHint: "如需导出连接密码，请设置密码短语进行加密保护。导入时需要输入相同的密码短语才能解密。",
+    passphraseImportHint: "此文件已加密，请输入密码短语来解密并导入。",
+    passphrase: "密码短语",
+    passphraseConfirm: "确认密码短语",
+    passphrasePlaceholder: "输入密码短语",
+    passphraseConfirmPlaceholder: "再次输入密码短语",
+    passphraseRequired: "请输入密码短语",
+    passphraseMismatch: "两次输入的密码短语不一致",
+    passphraseTooShort: "密码短语至少需要 4 个字符",
+    exportEncrypted: "导出",
+    decryptImport: "解密并导入",
+    wrongPassphrase: "密码短语错误或文件已损坏",
+    cryptoUnavailable: "当前浏览器环境不支持加密配置导入，请使用 HTTPS、localhost 或 DBX 桌面版。",
+    exportSuccess: "连接配置导出成功",
+    importSuccess: "已导入 {count} 个连接",
+    importNavicatSuccess: "已导入 {count} 个 Navicat 连接，若个别连接密码为空请补填后测试连接",
+    importDatagripSuccess: "已导入 {count} 个 DataGrip 连接，已自动读取 {filled} 个密码（来自 macOS 钥匙串）",
+    importDbeaverSuccess: "已导入 {count} 个 DBeaver 连接，若个别连接密码为空请补填后测试连接",
+    importNone: "没有新的连接需要导入",
+    importLayoutConfirm: "导入文件包含连接分组信息，是否一并应用？",
+    importLayoutTitle: "导入分组",
+    importLayoutApply: "应用",
+  },
+  ai: {
+    placeholder: "描述你想查什么...",
+    settings: "AI 设置",
+    noConfig: "AI 尚未配置。请在 设置 > AI 中配置你的 AI 服务。",
+    provider: "提供商",
+    providerStatusActive: "当前",
+    providerStatusConfigured: "已配置",
+    switchProvider: "切换服务商",
+    model: "模型",
+    browseModels: "浏览模型",
+    refreshModels: "刷新模型",
+    loadingModels: "加载模型中...",
+    searchModels: "搜索模型",
+    noModels: "暂无模型",
+    modelListHint: "点击刷新从服务端拉取模型列表。",
+    modelListUnsupported: "当前提供商不支持自动获取模型列表。",
+    modelListEndpointRequired: "填写 Endpoint 后再获取模型列表。",
+    modelListApiKeyRequired: "填写 API Key 后再获取模型列表。",
+    run: "执行",
+    readingSchema: "读取结构",
+    noConnection: "当前标签页没有可用连接",
+    noSql: "当前没有 SQL 可处理",
+    sqlPreview: "SQL 预览",
+    copySql: "复制 SQL",
+    copyCode: "复制代码",
+    executeSql: "立即执行",
+    tempRunSql: "临时运行",
+    copyAll: "复制全部",
+    copied: "已复制",
+    copyTestResult: "复制测试结果",
+    replace: "替换编辑器",
+    append: "追加到编辑器",
+    apply: "应用到编辑器",
+    clear: "清空对话",
+    welcome: "聊聊你想查什么，我来写 SQL",
+    newChat: "新对话",
+    thinking: "思考中...",
+    reasoningProcess: "思考过程",
+    stopGenerating: "停止生成",
+    scrollToBottom: "回到底部",
+    tableMentionEmpty: "没有匹配的表或 SQL 文件",
+    tableMentionPlaceholderHint: "输入 {'@'} 可选择表或 SQL 文件并带入上下文",
+    tableMentionTypes: {
+      table: "表",
+      view: "视图",
+      systemTable: "系统表",
+      temporaryTable: "临时表",
+    },
+    modes: {
+      ask: "Ask",
+      agent: "Agent",
+    },
+    modeHints: {
+      ask: "只生成 SQL 和说明，不自动执行",
+      agent: "使用工具查询数据并基于真实结果回答",
+    },
+    fixWithAi: "用 AI 修复",
+    truncated: "上下文已截断",
+    contextSummary: "{database} · {tables} 张表",
+    autoSqlBlocked: "AI 生成的 SQL 风险较高，已阻止自动执行，请手动检查后再运行。",
+    proposalConfirmYes: "是，请继续",
+    proposalConfirmNo: "不用了",
+    proposalConfirmTitle: "需要确认是否执行以下操作",
+    agentSteps: {
+      generated: "已生成 SQL",
+      noSql: "未找到 SQL",
+      safe: "安全检查通过",
+      needsConfirm: "需要确认",
+      blocked: "已阻止",
+      autoExecute: "准备执行",
+      notRequested: "未请求执行",
+      skipped: "未执行",
+      callingTool: "正在调用工具...",
+      toolDone: "工具调用完成",
+      toolError: "工具调用出错",
+      executeSafe: "安全检查通过 · 已执行",
+      executeBlocked: "安全检查拦截",
+      contextCompacted: "上下文已压缩",
+    },
+    agentStepTitles: {
+      riskCheck: "风险检查：{action} · {category} · {environment} · {reasons}",
+      blocked: "风险策略阻止执行，请手动检查 SQL。",
+      requiresConfirmation: "此 SQL 需要确认后执行。",
+      askMode: "Ask 模式不会自动执行 SQL。",
+      unsupportedAction: "当前 AI 动作不会自动执行 SQL。",
+      noSql: "回复中没有可执行的 SQL 代码块。",
+      notRequested: "用户没有表达执行意图。",
+      skipped: "此步骤未执行。",
+    },
+    proxy: "代理",
+    proxyEnable: "AI 请求通过代理发送",
+    proxyUrl: "代理地址",
+    enableThinking: "Thinking",
+    enableThinkingOn: "已启用",
+    enableThinkingOff: "已禁用",
+    enableThinkingHint: "此选项仅对 /chat/completions API 且部分支持的模型生效。设为禁用后可大幅节省 token，但生成结果质量可能会略微下降。",
+    anthropicMessagesHint: "Anthropic Messages 兼容 API 通常使用 /v1/messages。",
+    contextWindow: "上下文窗口",
+    contextWindowAuto: "自动（根据模型名称推断）",
+    contextWindowHint: "单位：token。留空自动推断，本地/自定义模型建议手动设置。",
+    codexCliPath: "Codex CLI 路径",
+    codexCliPathHint: "留空则使用 PATH 中的 codex。请先在终端执行 codex login 登录。",
+    codexCliPathEnvError: "Codex CLI 路径只能填写可执行文件路径。请在下方添加环境变量。",
+    codexCliEnv: "环境变量",
+    codexCliEnvAdd: "添加变量",
+    codexCliEnvHint: "传递给 Codex CLI 的可选变量，例如 HTTPS_PROXY、NO_PROXY、SSL_CERT_FILE 或 CODEX_CA_CERTIFICATE。",
+    codexCliEnvKeyPlaceholder: "HTTPS_PROXY",
+    codexCliEnvValuePlaceholder: "http://proxy:9800",
+    codexCliEnvInvalidName: "环境变量名称无效：{name}",
+    codexCliEnvReservedName: "{name} 由 DBX 用于 MCP Server，不能在这里设置。",
+    codexMcpRequiredTitle: "需要 DBX MCP Server",
+    codexMcpRequiredDescription: "Codex CLI 通过 DBX MCP Server 访问数据库结构和查询工具。请先安装后再在 AI 助手中使用 Codex。",
+    reasoningLevel: "推理级别",
+    reasoningLevelDefault: "默认",
+    reasoningLevelMinimal: "最小",
+    reasoningLevelLow: "低",
+    reasoningLevelMedium: "中",
+    reasoningLevelHigh: "高",
+    reasoningLevelHint: "控制 Codex CLI 的 model_reasoning_effort。默认使用你的 Codex 配置。",
+    actions: {
+      general: "通用问答",
+      generate: "生成 SQL",
+      explain: "解释 SQL",
+      optimize: "优化 SQL",
+      fix: "修复错误",
+      convert: "转换方言",
+      sampleData: "生成样例",
+      query: "查询数据",
+      exploreSchema: "查看表结构",
+      executeAndExplain: "执行并解释",
+      generateNoExec: "生成但不执行",
+    },
+    placeholders: {
+      general: "问我任何问题...",
+      generate: "描述你想查询什么，例如：统计最近 7 天每个用户的订单数",
+      explain: "可留空，或补充你关心的点",
+      optimize: "可留空，或说明优化目标，例如：减少全表扫描",
+      fix: "粘贴报错或说明期望结果",
+      convert: "例如：转换成 PostgreSQL / MySQL / SQL Server",
+      sampleData: "描述要生成的样例数据或测试语句",
+      query: "描述要查询或统计的数据，例如：本月各区域订单总额",
+      exploreSchema: "描述想了解的表或结构，例如：orders 表的字段和索引",
+      executeAndExplain: "可留空，或补充想重点解释的部分",
+    },
+    editMessage: "编辑消息",
+    editResend: "重新发送",
+    editCancel: "取消",
+  },
+  contextMenu: {
+    openConnection: "打开连接",
+    closeConnection: "关闭连接",
+    closeDatabaseConnection: "关闭数据库连接",
+    deleteConnection: "删除连接",
+    deleteSelectedConnections: "删除选中的 {count} 个连接",
+    confirmDeleteTitle: "删除连接",
+    confirmDeleteMessage: "确定要删除「{name}」吗？此操作不可撤销。",
+    confirmDeleteSelectedMessage: "确定要删除选中的{count}个连接吗？",
+    editConnection: "编辑连接",
+    revealDatabaseFile: "在文件管理器中显示",
+    selectVisibleDatabases: "选择显示数据库",
+    configureVisibleObjects: "可见对象过滤器",
+    duplicateConnection: "复制连接",
+    duplicateSelectedConnections: "复制选中的 {count} 个连接",
+    userAdmin: "用户与权限",
+    openUserAdmin: "打开用户与权限",
+    damengJobAdmin: "达梦代理作业",
+    openDamengJobAdmin: "打开达梦代理作业",
+    newQuery: "新建查询",
+    instanceInfo: "实例信息",
+    newInsert: "新建新增",
+    newSql: "新建 SQL",
+    generateSql: "生成 SQL",
+    newUpdate: "新建更新",
+    sqlHistory: "历史查询",
+    noSqlHistory: "暂无关联 SQL",
+    openObjectBrowser: "浏览对象",
+    viewData: "查看数据",
+    editStructure: "编辑表结构",
+    editColumn: "编辑字段",
+    editIndex: "编辑索引",
+    refreshChildren: "刷新",
+    expandAll: "展开全部",
+    pin: "置顶",
+    unpin: "取消置顶",
+    fixTab: "固定标签页",
+    unfixTab: "取消固定标签页",
+    refreshTab: "刷新数据",
+    renameTab: "重命名标签页",
+    duplicateTab: "复制标签页",
+    compactTabTitle: "缩短标签标题",
+    fullTabTitle: "完整标签标题",
+    closeTab: "关闭标签页",
+    closeFixedTab: "关闭固定标签页",
+    closeOtherTabs: "关闭其他标签页",
+    closeOtherRegularTabs: "关闭其他普通标签页",
+    closeOtherFixedTabs: "关闭其他固定标签页",
+    closeAllTabs: "关闭全部标签页",
+    closeAllRegularTabs: "关闭全部普通标签页",
+    closeAllFixedTabs: "关闭全部固定标签页",
+    copyName: "复制名称",
+    copyFinalProxyPort: "复制最终代理端口",
+    finalProxyPortCopied: "最终代理端口 {port} 已复制",
+    setDefaultDatabase: "设为默认数据库",
+    clearDefaultDatabase: "取消默认数据库",
+    exportDatabase: "导出数据库",
+    exportAllDatabases: "导出全部数据库",
+    exportDatabaseSuccess: "已导出 {count} 张表，每表最多 {limit} 行",
+    exportDatabaseFailed: "导出数据库失败：{message}",
+    backupSqliteDatabase: "备份 SQLite 数据库",
+    backupSqliteDatabaseInProgress: "正在备份 SQLite 数据库...",
+    backupSqliteDatabaseSuccess: "SQLite 数据库已备份",
+    backupSqliteDatabaseFailed: "备份 SQLite 数据库失败：{message}",
+    importData: "导入数据",
+    exportData: "导出数据",
+    exportStructure: "导出表结构",
+    exportStructurePreviewTitle: "表结构 - {name}",
+    exportStructurePreviewTitleMultiple: "表结构 - {count} 个对象",
+    exportStructureLoading: "正在读取表结构...",
+    copyStructure: "复制表结构",
+    copyStructureAs: "复制表结构为",
+    copyStructureAsTsv: "TSV（粘贴到 Excel）",
+    copyStructureAsMarkdown: "Markdown 表格",
+    structureDocTable: "表",
+    structureDocColumn: "字段名称",
+    structureDocType: "类型",
+    structureDocPrimaryKey: "主键",
+    structureDocNullable: "允许为空",
+    structureDocDefault: "默认值",
+    structureDocComment: "注释",
+    structureDocYes: "是",
+    structureDocNo: "否",
+    structureDocCopied: "表结构已复制",
+    structureDocCopyFallbackHint: "自动复制被系统拦截。请再次点击复制，或选中下方内容手动复制。",
+    saveStructure: "保存 SQL",
+    exportStructureCopied: "表结构已复制",
+    createTable: "新建表",
+    createView: "新建视图",
+    dropTable: "删除表",
+    emptyTable: "清空数据",
+    truncateTable: "截断表",
+    duplicateStructure: "克隆为新表",
+    renameObject: "重命名",
+    renameObjectTitle: "重命名对象",
+    renameObjectNamePlaceholder: "新名称",
+    renameObjectSuccess: "已将「{oldName}」重命名为「{newName}」",
+    confirmDropTableTitle: "删除表",
+    confirmDropTableMessage: "确定要删除「{name}」吗？这将永久删除表及其所有数据。",
+    dropTableCascade: "使用 CASCADE 强制删除",
+    dropTableCascadeHint: "同时删除依赖该表的对象（如视图）。未勾选时使用 PostgreSQL 默认的 RESTRICT。",
+    truncateTableCascade: "使用 CASCADE 强制截断",
+    truncateTableCascadeHint: "同时截断通过外键引用该表的表。未勾选时使用 PostgreSQL 默认的 RESTRICT。",
+    confirmEmptyTableTitle: "清空数据",
+    confirmEmptyTableMessage: "确定要删除「{name}」中的所有数据吗？",
+    confirmTruncateTableTitle: "截断表",
+    confirmTruncateTableMessage: "确定要截断「{name}」吗？这将删除所有行。",
+    dropTableSuccess: "表「{name}」已删除",
+    editView: "编辑视图",
+    viewSource: "查看源码",
+    viewDdl: "查看 DDL",
+    viewDdlLoading: "正在读取 DDL...",
+    ddlCopied: "DDL 已复制",
+    dropObject: "删除对象",
+    dropView: "删除视图",
+    dropColumn: "删除字段",
+    dropIndex: "删除索引",
+    dropAllIndexes: "删除全部索引",
+    dropForeignKey: "删除外键",
+    dropTrigger: "删除触发器",
+    batchDrop: "删除所选（{count}）",
+    batchEmpty: "清空所选（{count}）",
+    batchTruncate: "截断所选（{count}）",
+    batchDropIndexes: "删除索引（{count}）",
+    executeProcedure: "执行过程",
+    confirmExecuteProcedureTitle: "执行存储过程",
+    confirmExecuteProcedureMessage: "确认执行存储过程「{name}」？可先补充或调整参数值。",
+    loadingProcedureParameters: "正在读取参数...",
+    procedureParametersUnavailable: "未能读取参数信息，仍可直接编辑下方 SQL 后执行。",
+    noProcedureParameters: "未读取到参数，确认后将直接执行当前 SQL。",
+    inputParameters: "{count} 个输入参数",
+    outputParameters: "{count} 个输出参数",
+    parameterName: "Name",
+    parameterType: "Type",
+    parameterMode: "Mode",
+    parameterValue: "Value",
+    parameterNull: "NULL",
+    parameterDefault: "DEFAULT",
+    parameterDefaultHint: "勾选 DEFAULT 时会省略该参数，让数据库使用过程定义里的默认值。",
+    parameterValuePlaceholder: "输入参数值",
+    outputOnly: "输出参数",
+    sqlPreview: "SQL 预览",
+    resetSqlPreview: "重置 SQL",
+    openInSqlEditor: "打开到编辑器",
+    dropProcedure: "删除存储过程",
+    dropFunction: "删除函数",
+    manageExtension: "管理扩展...",
+    dropExtension: "删除扩展",
+    confirmDropViewTitle: "删除视图",
+    confirmDropViewMessage: "确定要删除视图「{name}」吗？",
+    confirmDropObjectTitle: "删除对象",
+    confirmDropObjectMessage: "确定要删除「{name}」吗？",
+    confirmDropColumnTitle: "删除字段",
+    confirmDropIndexTitle: "删除索引",
+    confirmDropMongoIndexMessage: "确定要从集合「{collection}」删除索引「{name}」吗？",
+    confirmDropMongoAllIndexesMessage: "确定要删除集合「{name}」中所有可删除的索引吗？",
+    confirmDropMongoAllIndexesDetails: "MongoDB 会保留 “_id_” 索引。若服务端因 shard key 规则保留了额外索引，最终结果将仅列出实际删除的索引。",
+    confirmDropForeignKeyTitle: "删除外键",
+    confirmDropTriggerTitle: "删除触发器",
+    confirmDropTableChildObjectMessage: "确定要从「{table}」删除「{name}」吗？",
+    confirmDropBatchIndexesMessage: "确定要从「{table}」删除已选择的 {count} 个索引吗？此操作不可撤销。",
+    confirmBatchDropTitle: "删除所选对象",
+    confirmBatchDropMessage: "确定要删除已选择的 {count} 个对象吗？此操作不可撤销。",
+    confirmBatchEmptyTitle: "清空所选表",
+    confirmBatchEmptyMessage: "确定要删除已选择的 {count} 张表中的所有数据吗？",
+    confirmBatchTruncateTitle: "截断所选表",
+    confirmBatchTruncateMessage: "确定要截断已选择的 {count} 张表吗？这将删除所有行。",
+    confirmDropProcedureTitle: "删除存储过程",
+    confirmDropProcedureMessage: "确定要删除存储过程「{name}」吗？",
+    confirmDropFunctionTitle: "删除函数",
+    confirmDropFunctionMessage: "确定要删除函数「{name}」吗？",
+    dropViewSuccess: "视图「{name}」已删除",
+    dropProcedureSuccess: "存储过程「{name}」已删除",
+    dropFunctionSuccess: "函数「{name}」已删除",
+    dropTableChildObjectSuccess: "「{name}」已删除",
+    dropAllIndexesSuccess: "已从「{name}」删除 {count} 个索引",
+    batchDropSuccess: "已删除 {count} 个对象",
+    batchEmptySuccess: "已清空 {count} 张表",
+    batchEmptyPartialFail: "已清空 {success} 张表，{failed} 张失败",
+    batchEmptySubmitted: "已提交 {count} 张表的清空任务",
+    batchEmptySubmittedPartial: "已提交 {success} 张表的清空任务，{failed} 张提交失败",
+    batchTruncateSuccess: "已截断 {count} 张表",
+    emptyTableSuccess: "已清空「{name}」的所有数据",
+    emptyTableSubmitted: "已提交「{name}」的清空任务",
+    truncateTableSuccess: "表「{name}」已截断",
+    duplicateStructureSuccess: "已克隆为新表「{name}」",
+    tableOperationFailed: "操作失败：{message}",
+    duplicateNameTitle: "克隆为新表",
+    duplicateNamePlaceholder: "新表名",
+    copyTable: "复制表",
+    pasteTable: "粘贴表",
+    pasteOptionStructureAndData: "结构和数据",
+    pasteOptionStructureOnly: "仅结构",
+    pasteOptionDataOnly: "仅数据",
+    pasteTableSuccess: "已将表粘贴为「{name}」",
+    pasteTableConfirmTitle: "粘贴表",
+    pasteTableConfirmMessage: "从剪贴板粘贴表",
+    batchPasteTitle: "粘贴表",
+    batchPasteSuccess: "成功粘贴 {count} 张表",
+    batchPastePartialFail: "粘贴成功 {success} 张表，{failed} 张失败",
+    noTableToPaste: "没有可粘贴的表",
+    pasteTableClipboardUpdated: "表已复制到剪贴板",
+    createDatabase: "新建数据库",
+    createDuckDbFile: "新建数据库文件",
+    dropDatabase: "删除数据库",
+    confirmDropDatabaseTitle: "删除数据库",
+    confirmDropDatabaseMessage: "确定要删除数据库「{name}」吗？这将永久删除该数据库及其所有数据。",
+    createDatabaseSuccess: "数据库「{name}」已创建",
+    editDatabaseProperties: "编辑数据库属性",
+    editDatabasePropertiesTitle: "编辑数据库属性：「{name}」",
+    editDatabasePropertiesSaving: "正在保存...",
+    editDatabasePropertiesSuccess: "数据库「{name}」属性已更新",
+    editDatabaseComment: "数据库注释",
+    editDatabaseCommentPlaceholder: "输入数据库注释...",
+    createDuckDbFileSuccess: "DuckDB 数据库文件「{name}」已创建并附加",
+    createDuckDbFileDesktopOnly: "新建 DuckDB 数据库文件仅支持桌面端",
+    dropDatabaseSuccess: "数据库「{name}」已删除",
+    dropCollection: "删除集合",
+    confirmDropCollectionTitle: "删除集合",
+    confirmDropCollectionMessage: "确定要删除集合「{name}」吗？这将永久删除该集合及其所有文档。",
+    dropCollectionSuccess: "集合「{name}」已删除",
+    createDatabaseNamePlaceholder: "数据库名称",
+    createDatabaseCharset: "字符集",
+    createDatabaseCharsetPlaceholder: "例如 utf8mb4",
+    createDatabaseCharsetSearchPlaceholder: "搜索或输入字符集",
+    createDatabaseCharsetEmpty: "未找到字符集",
+    createDatabaseCharsetLoading: "正在加载字符集...",
+    createDatabaseCharsetCustomOption: "使用“{value}”",
+    createDatabaseCollation: "排序规则",
+    createDatabaseCollationPlaceholder: "例如 utf8mb4_unicode_ci",
+    createDatabaseCollationSearchPlaceholder: "搜索或输入排序规则",
+    createDatabaseCollationEmpty: "未找到排序规则",
+    createDatabaseCollationLoading: "正在加载排序规则...",
+    createDatabaseCollationCustomOption: "使用“{value}”",
+    createSchema: "新建 Schema",
+    dropSchema: "删除 Schema",
+    confirmDropSchemaTitle: "删除 Schema",
+    confirmDropSchemaMessage: "确定要删除 Schema「{name}」吗？这将永久删除该 Schema 及其所有对象。",
+    createSchemaSuccess: "Schema「{name}」已创建",
+    dropSchemaSuccess: "Schema「{name}」已删除",
+    createSchemaNamePlaceholder: "Schema 名称",
+    editSchemaComment: "编辑注释",
+    editSchemaCommentTitle: "编辑注释：「{name}」",
+    schemaCommentPlaceholder: "输入 Schema 注释...",
+    schemaCommentSaving: "正在保存...",
+    editSchemaCommentSuccess: "Schema「{name}」注释已更新",
+  },
+  visibleDatabases: {
+    title: "显示数据库",
+    description: "选择「{connection}」下要在侧边栏显示的数据库。",
+    searchPlaceholder: "搜索数据库...",
+    selectedCount: "已选择 {selected}/{total}",
+    selectAll: "全选",
+    selectFiltered: "选中搜索结果",
+    clear: "清空",
+    showAll: "显示全部",
+    showSystemDatabases: "显示系统库",
+    save: "保存",
+    emptySelection: "至少选择一个数据库，或使用「显示全部」清除过滤。",
+    loadFailed: "加载数据库失败：{message}",
+  },
+  visibleSchemas: {
+    title: "Schema 过滤器",
+    description: "选择「{connection}」下要在侧边栏显示的 Schema。",
+    searchPlaceholder: "搜索 Schema...",
+    selectedCount: "已选择 {selected}/{total}",
+    selectAll: "全选",
+    selectFiltered: "选中搜索结果",
+    clear: "清空",
+    showAll: "显示全部",
+    save: "保存",
+    emptySelection: "至少选择一个 Schema，或使用「显示全部」清除过滤。",
+    loadFailed: "加载 Schema 失败：{message}",
+  },
+  tree: {
+    savedSql: "SQL 库",
+    userAdmin: "用户与权限",
+    damengJobAdmin: "代理作业",
+    linkedServers: "链接服务器",
+    defaultDatabase: "默认库",
+    columns: "字段",
+    indexes: "索引",
+    foreignKeys: "外键",
+    triggers: "触发器",
+    tables: "表",
+    views: "视图",
+    materializedViews: "物化视图",
+    procedures: "存储过程",
+    functions: "函数",
+    sequences: "序列",
+    packages: "包",
+    partitions: "分区",
+    childTables: "子表",
+    loadMore: "加载更多...",
+    objectBrowser: "在对象浏览器中查看 ({count})",
+    extensions: "扩展",
+  },
+  extension: {
+    installTitle: "安装扩展",
+    manageTitle: "管理扩展",
+    name: "扩展名称",
+    namePlaceholder: "例如: pg_stat_statements",
+    install: "安装",
+    drop: "删除",
+    available: "可用扩展",
+    installed: "已安装",
+    noAvailable: "所有可用扩展均已安装。",
+    noInstalled: "暂无已安装的扩展。",
+  },
+  userAdmin: {
+    title: "用户与权限",
+    unsupported: "当前支持 MySQL 兼容与 PostgreSQL 兼容连接。SQL Server、Oracle 等会按各自权限模型继续扩展。",
+    newUser: "新建用户",
+    anonymous: "匿名用户",
+    roleName: "角色名",
+    allowLogin: "允许登录",
+    searchUser: "搜索用户或 Host",
+    loadingUsers: "正在加载用户...",
+    loadingGrants: "正在加载授权...",
+    emptyUsers: "暂无用户，或当前账号没有读取用户列表的权限。",
+    pluginUnknown: "认证插件未知",
+    grants: "授权",
+    noGrants: "暂无授权信息",
+    privilegeEditor: "权限编辑",
+    privilegeHint: "选择权限、数据库和表，预览 SQL 后执行。* 表示全局或全部表。",
+    database: "数据库",
+    schema: "Schema",
+    table: "表",
+    scope: "授权范围",
+    scopeDatabase: "数据库",
+    scopeSchema: "Schema",
+    scopeTable: "表",
+    scopeRole: "角色成员",
+    memberRole: "成员角色",
+    privileges: "权限",
+    grantOption: "允许继续授权 (WITH GRANT OPTION)",
+    adminOption: "允许管理成员关系 (WITH ADMIN OPTION)",
+    grant: "授权",
+    revoke: "撤权",
+    username: "用户名",
+    host: "Host",
+    changePassword: "修改密码",
+    newPassword: "新密码",
+    lock: "锁定",
+    unlock: "解锁",
+    disableLogin: "禁止登录",
+    enableLogin: "允许登录",
+    dropUser: "删除用户",
+    previewSql: "预览 SQL",
+    sqlPreview: "SQL 预览",
+    applySql: "执行 SQL",
+    applySuccess: "用户权限已更新",
+    applyFailed: "执行失败：{message}",
+  },
+  damengJobAdmin: {
+    title: "达梦代理作业",
+    unsupported: "当前页面仅支持达梦数据库连接。",
+    initEnvironment: "初始化作业环境",
+    environmentReady: "作业环境已初始化",
+    newJob: "新建作业",
+    searchJob: "搜索作业",
+    loadFailed: "加载失败",
+    environmentMissingTitle: "未初始化作业环境",
+    environmentMissingHint: "当前库还没有 SYSJOB 作业环境。",
+    environmentMissingDescription: "达梦代理作业依赖 SYSJOB 模式下的系统表和视图。可以先执行初始化作业环境，通常需要管理员权限。",
+    emptyJobs: "暂无作业，或当前账号没有读取作业列表的权限。",
+    emptyDetails: "暂无明细数据",
+    selectJob: "请选择一个作业",
+    enabled: "启用",
+    disabled: "停用",
+    running: "运行中",
+    enable: "启用",
+    disable: "停用",
+    runAsync: "立即执行",
+    stopRunning: "停止当前执行",
+    stopRunningDisabled: "仅作业正在执行时可停止",
+    clearHistories: "清理历史",
+    dropJob: "删除",
+    steps: "步骤",
+    schedules: "调度",
+    histories: "历史",
+    noDescription: "暂无描述",
+    jobName: "作业名",
+    description: "描述",
+    stepName: "步骤名",
+    scheduleName: "调度名",
+    sqlCommand: "SQL 脚本",
+    scheduleMode: "调度类型",
+    daily: "每天",
+    once: "一次",
+    startDate: "开始日期",
+    startTime: "开始时间",
+    endTime: "结束时间",
+    minuteInterval: "分钟间隔",
+    previewSql: "预览 SQL",
+    sqlPreview: "SQL 预览",
+    applySql: "执行 SQL",
+    applySuccess: "作业操作已执行",
+    applyFailed: "执行失败：{message}",
+  },
+  objects: {
+    all: "全部",
+    tables: "表",
+    views: "视图",
+    procedures: "存储过程",
+    functions: "函数",
+    sequences: "序列",
+    packages: "包",
+    table: "表",
+    partitions: "{count} 个分区",
+    view: "视图",
+    procedure: "存储过程",
+    function: "函数",
+    sequence: "序列",
+    package: "包",
+    packageBody: "包体",
+    name: "名称",
+    type: "类型",
+    rows: "行数",
+    size: "大小",
+    statisticsHint: "来自数据库统计信息的估算值，不执行 COUNT(*)。",
+    createdAt: "创建时间",
+    updatedAt: "更新时间",
+    source: "源代码",
+    saveSource: "保存",
+    cancelEdit: "取消",
+    sourceSaved: "源码已保存",
+    sourceSaveFailed: "保存源码失败：{message}",
+    sourceReadOnly: "该源码为只读，不能编辑。",
+    schemaColumn: "Schema",
+    comment: "注释",
+    loadingSchemas: "加载 Schema...",
+    schema: "Schema",
+    search: "搜索表、视图、函数、序列或存储过程...",
+    loading: "正在加载对象...",
+    empty: "没有找到对象",
+    selectedTables: "已选择 {count} 张表",
+    exportSelected: "导出所选",
+    dropSelected: "删除所选",
+    truncateSelected: "截断所选",
+    clearSelection: "清空选择",
+    confirmBatchDropTitle: "删除所选表",
+    confirmBatchDropMessage: "确定要删除已选择的 {count} 张表吗？此操作不可撤销。",
+    confirmBatchTruncateTitle: "截断所选表",
+    confirmBatchTruncateMessage: "确定要截断已选择的 {count} 张表吗？这将删除所有行。",
+    batchDropSuccess: "已删除 {count} 张表",
+    batchTruncateSuccess: "已截断 {count} 张表",
+    copyTableSelected: "复制",
+    pasteTableSelected: "粘贴",
+    toggleCheckbox: "切换多选模式",
+    viewList: "列表视图",
+    viewGrid: "平铺视图",
+    sortAsc: "升序",
+    sortDesc: "降序",
+    sortBy: "排序方式",
+  },
+  structureEditor: {
+    title: "编辑表结构",
+    createTitle: "新建表",
+    editTabTitle: "编辑: {tableName}",
+    tableName: "表名",
+    refresh: "刷新结构",
+    density: "密度",
+    densityCompact: "紧凑",
+    densityStandard: "标准",
+    densityComfortable: "宽松",
+    columns: "字段",
+    indexes: "索引",
+    foreignKeys: "外键",
+    triggers: "触发器",
+    ddl: "DDL",
+    addColumn: "新增字段",
+    columnTemplates: "插入预设字段",
+    configureColumnTemplates: "配置预设字段",
+    presetFieldsTemplate: "预设字段组合",
+    searchColumns: "搜索字段/注释",
+    nextColumnMatch: "定位下一个匹配字段",
+    searchIndexes: "搜索索引",
+    nextIndexMatch: "定位下一个匹配索引",
+    addIndex: "新增索引",
+    addForeignKey: "新增外键",
+    addTrigger: "新增触发器",
+    columnName: "字段名",
+    dataType: "类型",
+    length: "长度",
+    enumValues: "枚举值",
+    enumValueCount: "{count} 个值",
+    addEnumValue: "添加值",
+    removeEnumValue: "删除枚举值",
+    enumValuePlaceholder: "枚举值（允许空字符串）",
+    typePlaceholder: "选择或输入...",
+    noMatchingType: "无匹配类型",
+    mysqlDataTypeHelp: {
+      tinyint: "1 字节整数。有符号范围：-128 到 127；无符号范围：0 到 255。",
+      smallint: "2 字节整数。有符号范围：-32768 到 32767；无符号范围：0 到 65535。",
+      mediumint: "3 字节整数。有符号范围：-8388608 到 8388607；无符号范围：0 到 16777215。",
+      int: "4 字节整数。有符号范围：-2147483648 到 2147483647；无符号范围：0 到 4294967295。",
+      bigint: "8 字节整数。有符号范围：-2^63 到 2^63-1；无符号范围：0 到 2^64-1。",
+      decimal: "精确的定点数。MySQL 总精度最多 65 位、小数位最多 30 位；MariaDB 的版本限制可能不同。金额等需要精确计算的值应使用此类型。",
+      float: "单精度近似数值。需要精确小数值时请使用 DECIMAL。",
+      double: "双精度近似数值。需要精确小数值时请使用 DECIMAL。",
+      real: "默认是 DOUBLE 的别名；启用 REAL_AS_FLOAT SQL 模式后是 FLOAT 的别名。",
+      bit: "位字段，长度为 1 到 64 位，默认长度为 1 位。",
+      boolean: "TINYINT(1) 的别名：0 表示假，非零表示真。",
+      serial: "BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE 的便捷别名。",
+      date: "日历日期，支持范围为 1000-01-01 到 9999-12-31。",
+      datetime: "不进行时区转换的日期和时间，支持范围为 1000-01-01 00:00:00 到 9999-12-31 23:59:59；小数秒精度为 0 到 6，默认 0。",
+      timestamp: "会在会话时区和 UTC 间转换的日期时间，支持范围为 1970-01-01 00:00:01 UTC 到 2038-01-19 03:14:07 UTC；小数秒精度为 0 到 6，默认 0。",
+      time: "时间或时间间隔，支持范围为 -838:59:59 到 838:59:59；小数秒精度为 0 到 6，默认 0。",
+      year: "年份值。四位年份范围为 1901 到 2155，另支持 0000。",
+      char: "定长字符串，最多 255 个字符；存储时会在右侧补空格。",
+      varchar: "变长字符串；实际最大长度受行大小和字符集约束。",
+      tinytext: "变长文本，最多 255 字节；字符集、行大小和 max_allowed_packet 可能使实际限制更小。",
+      text: "变长文本，最多 65535 字节；字符集、行大小和 max_allowed_packet 可能使实际限制更小。",
+      mediumtext: "变长文本，最多 16777215 字节；字符集、行大小和 max_allowed_packet 可能使实际限制更小。",
+      longtext: "变长文本，最多 4294967295 字节（约 4 GiB）；字符集、行大小和 max_allowed_packet 可能使实际限制更小。",
+      binary: "定长二进制字节串，最多 255 字节；存储时以 0x00 补齐。",
+      varbinary: "变长二进制字节串；实际最大长度受行大小约束。",
+      tinyblob: "二进制大对象，最多 255 字节；行大小和 max_allowed_packet 可能使实际限制更小。",
+      blob: "二进制大对象，最多 65535 字节；行大小和 max_allowed_packet 可能使实际限制更小。",
+      mediumblob: "二进制大对象，最多 16777215 字节；行大小和 max_allowed_packet 可能使实际限制更小。",
+      longblob: "二进制大对象，最多 4294967295 字节（约 4 GiB）；行大小和 max_allowed_packet 可能使实际限制更小。",
+      enum: "从最多 65535 个声明字面量中选择一个值；调整字面量顺序可能改变已存储值的语义。",
+      set: "从最多 64 个声明成员中选择零个或多个值。",
+      json: "经过校验的 JSON 文档；存储形式和 JSON 功能取决于所连接的服务端产品及版本，文档大小还受 max_allowed_packet 限制。",
+      jsonMysql: "MySQL 原生二进制 JSON 文档类型，支持 JSON 函数和有效性校验；文档大小受 max_allowed_packet 限制。",
+      jsonMariaDb: "MariaDB 的 JSON 是带 JSON_VALID 约束和 utf8mb4_bin 排序规则的 LONGTEXT 别名；文档大小受 max_allowed_packet 限制。",
+      nationalCharacter: "国家字符集字符串别名。在 MySQL 中会使用预定义国家字符集 utf8mb3（已弃用）；新建表应显式选择 utf8mb4。",
+      geometry: "可存储任意受支持空间几何类型的值。MySQL InnoDB 的 SPATIAL 索引要求列为 NOT NULL 且指定 SRID 属性。",
+      point: "由一对坐标构成的空间点。MySQL InnoDB 的 SPATIAL 索引要求列为 NOT NULL 且指定 SRID 属性。",
+      linestring: "由一个或多个相连点构成的空间曲线。MySQL InnoDB 的 SPATIAL 索引要求列为 NOT NULL 且指定 SRID 属性。",
+      polygon: "由一个或多个环围成的空间区域。MySQL InnoDB 的 SPATIAL 索引要求列为 NOT NULL 且指定 SRID 属性。",
+      multipoint: "空间点的集合。MySQL InnoDB 的 SPATIAL 索引要求列为 NOT NULL 且指定 SRID 属性。",
+      multilinestring: "空间曲线的集合。MySQL InnoDB 的 SPATIAL 索引要求列为 NOT NULL 且指定 SRID 属性。",
+      multipolygon: "空间多边形的集合。MySQL InnoDB 的 SPATIAL 索引要求列为 NOT NULL 且指定 SRID 属性。",
+      geometrycollection: "可包含混合空间几何类型的集合。MySQL InnoDB 的 SPATIAL 索引要求列为 NOT NULL 且指定 SRID 属性。",
+      inet4: "MariaDB 的 IPv4 地址类型（MariaDB 10.10 起提供），以 4 字节存储 IPv4 地址。",
+      inet6: "MariaDB 兼容的地址类型，用于 IPv6 和映射后的 IPv4 值。",
+      uuid: "兼容服务提供的 128 位通用唯一标识符类型。",
+      vector: "用于相似度检索或机器学习负载的向量类型；是否可用及维度取决于服务端版本。",
+      xmltype: "兼容服务提供的 XML 数据类型。",
+      integerDisplayWidth: "MySQL 整数显示宽度（如 INT(11)）已弃用，且不会限制实际存储范围；MySQL 8 新表不应再添加此参数。",
+      zerofill: "ZEROFILL 已在 MySQL 8 中弃用，并会隐式使字段成为 UNSIGNED；应改在应用层处理补零展示。",
+      unsignedNumeric: "DECIMAL、FLOAT 或 DOUBLE 的 UNSIGNED 已在 MySQL 8 中弃用；需要非负取值范围时请使用 CHECK 约束。",
+      floatPrecision: "FLOAT(p) 中 p 为 25 到 53 时实际选择 DOUBLE 精度，而不是 FLOAT；需要双精度时应显式使用 DOUBLE。",
+      floatingPointDisplay: "FLOAT(M,D) 和 DOUBLE(M,D) 已在 MySQL 8 中弃用；请使用无显示参数的 FLOAT/DOUBLE，或对精确数值使用 DECIMAL(M,D)。",
+    },
+    postgresDataTypeHelp: {
+      smallint: "2 字节有符号整数，范围为 -32768 到 32767。",
+      integer: "4 字节有符号整数，范围为 -2147483648 到 2147483647。",
+      bigint: "8 字节有符号整数，范围为 -2^63 到 2^63-1。",
+      serial: "便利语法：创建整数列、序列、NOT NULL 和 nextval 默认值。它本身不保证唯一且序列值可能断号；新建表建议使用 IDENTITY。",
+      numeric: "可指定精度和小数位的精确十进制数。金额等不能接受二进制浮点舍入的值应使用此类型。",
+      real: "4 字节单精度浮点数。FLOAT(p) 的 p 为 1 到 24 时选择此类型。",
+      double: "8 字节双精度浮点数。未指定精度的 FLOAT 是它的别名；FLOAT(p) 的 p 为 25 到 53 时选择它。",
+      money: "受区域格式影响的货币金额，输出和解析依赖 lc_monetary；需要可移植财务数据时通常应使用 NUMERIC。",
+      boolean: "逻辑真、假或空值；BOOL 是 BOOLEAN 的别名。",
+      char: "定长、以空格补齐的字符串。CHARACTER 是别名；若尾随空格有业务含义应谨慎使用。",
+      varchar: "可选长度限制的变长字符串；CHARACTER VARYING 是其别名。",
+      text: "无声明长度限制的变长字符串；存储行为与无长度限制的 VARCHAR 相同。",
+      bytea: "变长二进制字符串；大值可由 TOAST 移到行外存储。",
+      date: "不含时间和时区的日历日期。",
+      time: "不含时区的时间，可指定小数秒精度。",
+      timetz: "带 UTC 偏移的时间；用途有限且通常不推荐。表示时间点应使用 timestamptz。",
+      timestamp: "不进行时区转换的日期时间。适用于时区不属于数据本身的本地钟表时间。",
+      timestamptz: "时间点内部以 UTC 存储，并按会话时区显示；不会保留原始命名时区。",
+      interval: "以月、日和微秒表示的时间间隔；日历单位不是固定时长。",
+      uuid: "128 位通用唯一标识符。",
+      json: "保留原始输入表示的 JSON 文本，解析会校验有效性，但处理通常比 JSONB 慢。",
+      jsonb: "适合处理和索引的分解二进制 JSON；不会保留无意义空白、键顺序或重复键。",
+      xml: "XML 值；是否按文档或内容校验取决于所用 XML 选项。",
+      bit: "定长或变长位串。BIT VARYING 和 VARBIT 是变长形式的别名。",
+      tsvector: "PostgreSQL 全文检索中用于被检索文档的标准化词位；通常使用 GIN 或 GiST 索引。",
+      tsquery: "针对 tsvector 求值的布尔全文检索查询。",
+      cidr: "IPv4 或 IPv6 网络，主机位必须全为零。",
+      inet: "IPv4 或 IPv6 主机地址，可带网络掩码；与 CIDR 不同，主机位可以非零。",
+      macaddr: "MAC 地址。MACADDR 存储 6 字节地址，MACADDR8 存储 8 字节地址。",
+      geometry: "内置二维平面几何类型，无 SRID。地理坐标、投影或高级空间操作应使用 PostGIS。",
+      range: "带开闭边界的单一连续范围，值必须使用兼容子类型；多个不连续范围应使用 multirange。",
+      oid: "无符号对象标识符，是系统标识而非稳定的业务主键；业务数据应使用普通整数或 UUID。",
+      array: "任意元素类型的 PostgreSQL 数组，支持多维。声明类型不会强制数组维度；相较规范化子表，数组通常灵活性更低。",
+      multirange: "同一范围子类型的一组不重叠范围。PostgreSQL 会按子类型规则规范化相邻或重叠成员。",
+      jsonpath: "供 JSONB 查询和谓词函数使用的 SQL/JSON 路径表达式。",
+      pgLsn: "用于复制和恢复坐标的 WAL 位置，不是业务序列号。",
+      pgSnapshot: "事务可见性快照，其文本表示用于数据库快照操作，不适合作为一般业务数据。",
+    },
+    sqliteDataTypeHelp: {
+      integer: "SQLite 使用动态类型和 INTEGER 亲和性；普通列并不强制 INTEGER 存储类。可转换时按有符号整数存储；精确拼写的 INTEGER PRIMARY KEY 是 rowid 的特殊别名。",
+      real: "REAL 亲和性存储 IEEE 754 浮点数。适合近似测量值，不适合精确金额或十进制计算。",
+      text: "TEXT 亲和性按数据库编码存储文本。SQLite 中 VARCHAR(n) 和 CHAR(n) 不会强制 n；若长度重要，请增加 CHECK 约束。",
+      blob: "BLOB 亲和性原样存储字节，不进行类型转换。",
+      numeric: "NUMERIC 亲和性会尝试先将格式正确的数字文本转换为 INTEGER，再转换为 REAL；它不是独立的 SQLite 存储类。DATE、DATETIME 和 TIME 声明同样具有 NUMERIC 亲和性；应统一使用 ISO-8601 TEXT、儒略日 REAL 或 Unix 时间 INTEGER。",
+    },
+    nullable: "可为空",
+    primaryKey: "主键",
+    defaultValue: "默认值",
+    defaultValuePresets: "默认值预设",
+    comment: "注释",
+    characterSet: "字符集",
+    charsetPlaceholder: "字符集",
+    collation: "排序规则",
+    collationPlaceholder: "排序规则",
+    editComment: "编辑注释",
+    commentPlaceholder: "输入字段注释...",
+    tableCommentPlaceholder: "输入表注释...",
+    tableCommentUnsupported: "当前数据库不支持表注释",
+    actions: "操作",
+    indexName: "索引名",
+    indexColumns: "字段列表",
+    indexColumnsPlaceholder: "选择列...",
+    unique: "唯一",
+    indexType: "类型",
+    includedColumns: "包含列",
+    includedColumnsPlaceholder: "选择列...",
+    filter: "过滤条件",
+    foreignKeyName: "外键名",
+    referencedSchema: "引用库",
+    referencedTable: "引用表",
+    referencedColumn: "引用字段",
+    onDelete: "删除时",
+    onUpdate: "更新时",
+    defaultAction: "默认",
+    triggerName: "触发器名",
+    triggerStatement: "触发语句",
+    primary: "主键",
+    drop: "删除",
+    restore: "恢复",
+    remove: "移除",
+    moveColumnUp: "上移字段",
+    moveColumnDown: "下移字段",
+    dragColumn: "拖拽调整字段顺序",
+    localColumnOrderNotice: "字段顺序仅保存在本地，不会修改数据库表结构。",
+    yes: "是",
+    no: "否",
+    emptyReadonly: "暂无记录",
+    sqlPreview: "SQL 预览",
+    collapseSqlPreview: "收起 SQL 预览",
+    expandSqlPreview: "展开 SQL 预览",
+    noChanges: "暂无变更",
+    apply: "应用变更",
+    ready: "可执行",
+    saved: "表结构已更新",
+    copySql: "复制 SQL",
+    sqliteRebuildNotice: "SQLite 会保留一张不带活动约束的数据快照作为备份表，再在同一事务内重建原表，使用 CAST 强制转换类型已修改的字段；无法表示的值可能变为 0/0.0，执行失败则整体回滚。",
+    extendedProperties: "扩展属性",
+    autoIncrement: "自增",
+    onUpdateCurrentTimestamp: "自动更新时间",
+    identity: "标识列",
+    identityGeneration: "生成方式",
+    identitySeed: "起始值",
+    identityIncrement: "增量",
+    sqlServerIdentityTypeHint: "SQL Server 自增仅支持 tinyint、smallint、int、bigint、decimal/numeric(小数位为 0)",
+  },
+  diagram: {
+    title: "关系图",
+    open: "查看关系图",
+    selectConnection: "选择连接",
+    selectDatabase: "选择数据库",
+    selectSchema: "选择模式",
+    searchTables: "搜索表/字段/外键...",
+    refresh: "刷新关系图",
+    loading: "正在读取关系...",
+    loadingProgress: "正在读取关系... {loaded}/{total}",
+    partialError: "{count} 张表的元数据读取失败，已跳过",
+    selectTarget: "请选择连接和数据库",
+    empty: "暂无可展示的表",
+    noMatches: "没有匹配的表",
+    tablesCount: "{count} 张表",
+    relationshipsCount: "{count} 条关系",
+    tableMode: "表结构图",
+    engineeringMode: "工程 ER 图",
+    modelRelationships: "建模关系",
+    copyJoinSql: "复制 SQL",
+    customRelationshipsCount: "{count} 条建模",
+    relationshipName: "名称",
+    relationshipNamePlaceholder: "可选",
+    sourceTable: "源表",
+    sourceColumn: "源字段",
+    targetTable: "目标表",
+    targetColumn: "目标字段",
+    cardinality: "基数",
+    cardinalityOneToMany: "1:N",
+    cardinalityManyToOne: "N:1",
+    cardinalityOneToOne: "1:1",
+    addRelationship: "添加关系",
+    removeRelationship: "删除关系",
+    relationshipIncomplete: "请选择源字段和目标字段",
+    relationshipSelfInvalid: "关系不能指向同一个字段",
+    relationshipExists: "该关系已存在",
+    relationshipAdded: "关系已添加",
+    noJoinSql: "暂无可复制的关系 SQL",
+    allTables: "全部表",
+    relatedTables: "相关表",
+    moreColumns: "+ {count} 个字段",
+    exportSvg: "导出 SVG",
+    exportedSvg: "SVG 已导出",
+    exportSvgFailed: "导出 SVG 失败：{message}",
+    zoomIn: "放大",
+    zoomOut: "缩小",
+    resetLayout: "重置布局",
+  },
+  etcd: {
+    prefixPlaceholder: "Prefix，例如 /app/",
+    newKey: "新建 Key",
+    loadingKeys: "正在加载 Key...",
+    empty: "未找到 Key",
+    loadMore: "加载更多",
+    selectKey: "选择一个 Key 查看值",
+    loadingValue: "正在加载值...",
+    notFound: "Key 不存在",
+    edit: "编辑",
+    editKey: "编辑 Key",
+    delete: "删除",
+    deleteTitle: "删除 etcd Key",
+    keyPlaceholder: "/path/to/key",
+    keyRequired: "Key 不能为空",
+    saved: "Key 已保存",
+    deleted: "Key 已删除",
+    base64Readonly: "Base64 值当前版本只读。",
+  },
+  zookeeper: {
+    prefixPlaceholder: "路径前缀，例如 /app/",
+    newKey: "新建 Znode",
+    loadingKeys: "正在加载 znode...",
+    empty: "未找到 znode",
+    loadMore: "加载更多",
+    selectKey: "选择一个 znode 查看值",
+    loadingValue: "正在加载值...",
+    notFound: "未找到 znode",
+    edit: "编辑",
+    editKey: "编辑 Znode",
+    delete: "删除",
+    deleteTitle: "删除 ZooKeeper znode",
+    keyPlaceholder: "/path/to/znode",
+    keyRequired: "Znode 路径不能为空",
+    rootReadonly: "根 znode 不能被修改，请填写子节点路径",
+    saved: "Znode 已保存",
+    deleted: "Znode 已删除",
+    base64Readonly: "Base64 值当前版本只读。",
+    createMode: "创建模式",
+    createModePersistent: "持久节点",
+    createModeEphemeral: "临时节点",
+    createModePersistentSequential: "持久顺序节点",
+    createModeEphemeralSequential: "临时顺序节点",
+    add: "添加",
+    value: "值",
+    metadata: "节点信息",
+    prettyJson: "美化",
+    invalidJson: "不是合法的 JSON",
+    summaryRevision: "修订",
+    summaryVersion: "版本",
+    summaryLease: "租约",
+    summarySize: "大小",
+  },
+  redis: {
+    selectKey: "选择一个 key 查看值",
+    noKeys: "未找到 key",
+    noKeysInScanHint: "当前扫描范围内未命中匹配的 key",
+    pattern: "匹配模式 (如 user:*)",
+    fuzzyPattern: "输入关键字搜索 key",
+    fuzzyMatch: "模糊",
+    fuzzyMatchTitle: "模糊匹配：自动按包含关系搜索 key",
+    valueSearchPlaceholder: "按值内容搜索...",
+    allSearchPlaceholder: "按 key 或值搜索...",
+    searchByKey: "键",
+    searchByValue: "值",
+    searchByAll: "全部",
+    searchFields: "搜索字段或值",
+    keys: "{count} 个 key",
+    loadedKeys: "已加载 {loaded} / 共 {total} 个 key",
+    loadingKeys: "正在加载 key...",
+    searchingValues: "正在按值搜索...",
+    searchingAll: "正在搜索 key 和值...",
+    loadMoreKeys: "加载更多",
+    fetchAllKeys: "获取全部",
+    stopFetchAll: "停止",
+    fetchAllProgress: "已加载 {loaded} / 共 {total} 条 key",
+    fetchAllProgressUnknown: "已加载 {loaded} 条 key",
+    items: "{count} 个元素",
+    fields: "{count} 个字段",
+    members: "{count} 个成员",
+    loadedItems: "已加载 {loaded} / 共 {total} 个元素",
+    loadedFields: "已加载 {loaded} / 共 {total} 个字段",
+    loadedMembers: "已加载 {loaded} / 共 {total} 个成员",
+    entries: "{count} 条记录",
+    noExpiry: "永不过期",
+    autoRefresh: "自动刷新（倒计时）",
+    ttlDay: "{count}天",
+    columnType: "类型",
+    columnKey: "键",
+    columnValue: "值",
+    columnSize: "大小",
+    columnTTL: "TTL",
+    binaryStringReadonlyHint: "二进制字符串按转义文本只读展示；当前不支持直接编辑原始字节值。",
+    selectedKeys: "已选择的 key",
+    deleteGroup: "删除分组",
+    deleteGroupDetails: "{target}\n{count} 个 key",
+    flushDb: "清空当前 DB",
+    flushDbMessage: "这会删除当前 Redis 数据库中的所有 key，且不可撤销。确认继续？",
+    flushDbDetails: "目标: Redis db{db}\n范围: 当前 DB 的所有 key",
+    flushDbConfirm: "清空 DB",
+    flushDbSuccess: "Redis db{db} 已清空",
+    keyDetail: "键详情",
+    commandLine: "命令行",
+    selectKeyForDetail: "选择一个 key 查看详情",
+    commandWelcome: "欢迎使用 Redis 命令行控制台",
+    commandPlaceholder: "Redis 命令，如 GET user:1",
+    commandPrefix: "命令",
+    commandHint: "输入 Redis 命令，如 SMEMBERS feature:flags",
+    executeCommand: "执行命令",
+    commandEmpty: "请输入 Redis 命令",
+    commandEmptyResult: "执行 Redis 命令后会在这里显示结果",
+    commandBlocked: "出于安全考虑，此 Redis 命令已被阻止",
+    createKey: "新增 key",
+    createKeyName: "Key",
+    createKeyNamePlaceholder: "user:1",
+    createKeyType: "类型",
+    createKeyTypeHelp: {
+      string: "单个二进制安全值，最大 512 MB。适合缓存值、计数器、标记及简单序列化数据。",
+      hash: "扁平的字段-值映射。单字段操作高效，但完整读取大 Hash 是 O(N)。",
+      list: "有序序列。头尾操作高效；中间随机访问的复杂度随列表长度线性增长。",
+      set: "无序且成员唯一的集合。单成员操作是 O(1)，枚举或运算大集合则为线性复杂度。",
+      zset: "按浮点分值排序的唯一成员集合。写入为 O(log N)；同分成员按字典序排序。",
+      stream: "追加式事件日志。消费组需要处理 XACK 与待处理消息；应裁剪 Stream 以控制保留量和内存。",
+      json: "可按路径读写的 JSON 文档。需要 RedisJSON/Redis Stack 的 JSON.* 支持，通常比 String 或 Hash 开销更高。",
+    },
+    createValue: "值",
+    createMember: "成员",
+    createField: "字段",
+    createFieldPlaceholder: "name",
+    createScore: "分数",
+    createKeyTtl: "TTL（秒）",
+    createKeyTtlPlaceholder: "留空表示永不过期",
+    createKeyAddEntry: "添加条目",
+    createKeyEntryId: "条目 ID",
+    createKeyRawMode: "原始输入",
+    createKeyEntries: "条目",
+    createValuePlaceholder: "value",
+    createKeySubmit: "新增",
+    createKeyNameRequired: "请输入 key 名称",
+    createFieldRequired: "请输入 hash 字段",
+    createScoreInvalid: "请输入有效分数",
+    jsonModuleNotAvailable: "该 Redis 服务器未加载 ReJSON 模块",
+    fieldRequired: "请输入字段名",
+    valueRequired: "请输入值",
+    memberRequired: "请输入成员",
+    ttlInvalid: "请输入有效的 TTL（秒数，-1 表示永不过期）",
+    member: "成员",
+    memberDetail: "成员详情",
+    viewMember: "查看完整内容",
+    copyMember: "复制成员",
+    copyKeyName: "复制键名",
+    copied: "已复制",
+    copyInsertStatement: "复制插入语句",
+    copyInsertStatementBinary: "二进制数据无法生成插入语句",
+    editMember: "编辑",
+    jsonView: "JSON 视图",
+    rawContent: "原始内容",
+    wordWrap: "自动换行",
+    formatJson: "格式化",
+    compressJson: "压缩",
+    jsonFormatError: "JSON 格式不合法",
+    clearHistory: "清除命令历史",
+    historyCleared: "Redis 命令历史已清除",
+    blockedCommand: "命令 {command} 因安全原因已被拦截。点击工具栏盾牌图标可关闭拦截。",
+    pubsub: "发布/订阅",
+    pubsubConnected: "已连接",
+    pubsubConnecting: "连接中...",
+    pubsubDisconnected: "未连接",
+    pubsubConnect: "连接",
+    pubsubDisconnect: "断开",
+    pubsubChannels: "频道",
+    pubsubChannelPlaceholder: "频道名称",
+    pubsubSubscribe: "订阅",
+    pubsubPatterns: "模式匹配",
+    pubsubPatternPlaceholder: "模式 (如 news:*)",
+    pubsubPsubscribe: "模式订阅",
+    pubsubMessages: "消息",
+    pubsubClear: "清空",
+    pubsubEmpty: "暂无消息，订阅一个频道来接收消息。",
+    pubsubPublish: "发布消息",
+    pubsubPublishChannel: "频道",
+    pubsubPublishMessage: "消息内容",
+    pubsubSend: "发送",
+    pubsubPublishFailed: "发布失败: {error}",
+    pubsubWsConnectFailed: "WebSocket 连接失败: {error}",
+    slowlog: "慢日志",
+    slowlogCount: "条数",
+    slowlogQuery: "查询",
+    slowlogNode: "节点",
+    slowlogSelectNode: "请选择节点",
+    slowlogNodeRequired: "请先选择一个节点",
+    slowlogEmpty: "点击查询获取慢日志",
+    slowlogFetchFailed: "获取慢日志失败: {error}",
+    slowlogColumnId: "ID",
+    slowlogColumnTimestamp: "时间",
+    slowlogColumnDuration: "耗时 (μs)",
+    slowlogColumnCommand: "命令",
+    slowlogColumnClientAddr: "来源",
+    slowlogColumnClientName: "客户端名称",
+    slowlogTotal: "共 {count} 条",
+    slowlogDetailTitle: "慢日志条目 #{id}",
+  },
+  mongo: {
+    documents: "{count} 个文档",
+    addField: "添加字段",
+    deleteField: "删除字段",
+    field: "字段",
+    value: "值",
+    fieldPlaceholder: "字段名",
+    emptyCollection: "空集合",
+    selectDocument: "选择一个文档",
+    readonlyId: "_id 只读",
+    invalidJsonValue: "当前单元格不是合法 JSON 值",
+    duplicateField: "字段名重复：{field}",
+    edit: "编辑",
+    documentView: "文档视图",
+    tableView: "表格视图",
+    filterPlaceholder: "过滤条件...",
+    sortPlaceholder: "排序条件...",
+  },
+  vector: {
+    collectionFallback: "集合",
+    productCollection: "{product} 集合",
+    browse: "浏览",
+    search: "搜索",
+    upsert: "写入",
+    delete: "删除",
+    reset: "重置",
+    refresh: "刷新",
+    run: "运行",
+    apply: "应用",
+    requestEditor: "向量请求编辑器",
+    operationSuccess: "操作已完成，集合预览已刷新。",
+    vectorLabel: "向量",
+  },
+  history: {
+    title: "历史",
+    search: "搜索历史...",
+    empty: "暂无历史记录",
+    emptyFilteredRecent: "最近 200 条执行历史中没有匹配记录",
+    failed: "失败",
+    success: "成功",
+    restore: "恢复到编辑器",
+    copy: "复制 SQL",
+    delete: "删除",
+    clear: "清空历史",
+    viewDetails: "查看详情",
+    analyzeWithAi: "AI 分析",
+    aiAnalyzeNoConnection: "无法分析这条历史记录：对应连接已不存在。",
+    aiAnalysisTab: "历史分析",
+    rollback: "回滚",
+    rollbackSql: "回滚 SQL",
+    rollbackAvailable: "可回滚",
+    rollbackUnavailable: "无回滚 SQL",
+    rollbackConfirm: "将执行这条历史记录生成的回滚 SQL，确认继续吗？",
+    rollbackSuccess: "回滚已执行",
+    rollbackFailed: "回滚失败：{message}",
+    confirmDelete: "确认删除这条历史记录吗？",
+    confirmClear: "确认清空所有历史记录吗？",
+    filters: {
+      all: "全部",
+      query: "查询",
+      data_change: "数据变更",
+      schema_change: "结构变更",
+      failed: "失败",
+    },
+    dateRange: {
+      title: "时间范围",
+      label: "执行时间：",
+      start: "开始日期",
+      end: "结束日期",
+      apply: "应用",
+      clear: "清除",
+      invalid: "开始日期不能晚于结束日期",
+      unboundedStart: "开始",
+      unboundedEnd: "结束",
+    },
+    kinds: {
+      query: "查询",
+      data_change: "数据变更",
+      schema_change: "结构变更",
+      import: "导入",
+      transfer: "传输",
+      redis_command: "Redis 命令",
+    },
+    kindShort: {
+      query: "查询",
+      data_change: "变更",
+      schema_change: "结构",
+      import: "导入",
+      transfer: "传输",
+      redis_command: "Redis",
+    },
+    detail: {
+      kind: "类型",
+      operation: "操作",
+      connection: "连接",
+      database: "数据库",
+      target: "对象",
+      time: "时间",
+      duration: "耗时",
+      affectedRows: "影响行数",
+      rollback: "回滚",
+      status: "状态",
+      error: "错误",
+    },
+  },
+  dangerDialog: {
+    title: "危险操作",
+    message: "此 SQL 语句可能不可逆地修改或删除数据，确认要执行吗？",
+    redisCommandMessage: "此 Redis 命令可能会修改数据，且无法自动撤销，确认要继续吗？",
+    suppressFuturePrompts: "以后执行危险 SQL 不再提示",
+    wrapLines: "切换自动换行",
+    deleteMessage: "此删除操作可能不可逆，确认要继续吗？",
+    deleteConfirm: "确认删除",
+    deleteRowMessage: "此行将被标记为删除，保存后会从数据库删除，确认要继续吗？",
+    deleteRowsMessage: "这 {count} 行将被标记为删除，保存后会从数据库删除，确认要继续吗？",
+    deleteRowDetails: "数据表：{table}",
+    deleteRowDetailsNoTable: "当前结果集中的行",
+    redisKeyDetails: "Redis key：{key}",
+    redisHashFieldDetails: "Redis hash：{key}\n字段：{field}",
+    redisListItemDetails: "Redis list：{key}\n索引：{index}",
+    redisSetMemberDetails: "Redis set：{key}\n成员：{member}",
+    mongoDocumentDetails: "MongoDB 集合：{collection}\n文档 _id：{id}",
+    mongoFieldDetails: "字段：{field}",
+    mongoArrayItemDetails: "数组项索引：{index}",
+    cancel: "取消",
+    confirm: "执行",
+  },
+  production: {
+    title: "生产环境",
+    connection: "生产连接",
+    enable: "启用生产环境保护",
+    disabledDescription: "开启后可选择保护全部数据库或指定数据库。",
+    scope: "保护范围",
+    allDatabases: "全部数据库",
+    selectedDatabases: "选择数据库",
+    singleDatabaseScopeHint: "此数据库类型仅支持连接级生产环境保护。",
+    databases: "生产数据库",
+    connectionDescription: "此连接上的所有数据库都会启用生产保护。",
+    databaseDescription: "从连接中选择需要生产保护的数据库。首次打开默认全选。",
+    selectDatabases: "选择生产数据库",
+    noDatabasesSelected: "尚未选择",
+    databasesConfiguredCount: "已选择 {count} 个",
+    databasesSelectedCount: "已选择 {selected}/{total}",
+    databasePickerTitle: "选择生产数据库",
+    databasePickerDescription: "选择「{connection}」中需要生产保护的数据库。",
+    databaseSearchPlaceholder: "搜索数据库...",
+    databaseSelectionRequired: "请至少选择一个数据库。",
+    databaseLoadFailed: "无法加载数据库列表：{message}",
+    noDatabasesAvailable: "未找到可选择的数据库。",
+    retry: "重试",
+    confirmTitle: "确认生产环境写入",
+    confirmMessage: "该操作将变更生产数据库，必须明确确认后才能继续。",
+    confirmDetails: "连接：{connection}\n数据库：{database}\n入口：{source}",
+    confirmAction: "在生产环境执行",
+    sourceSqlEditor: "SQL 编辑器",
+    sourceDataGrid: "数据编辑器",
+    sourceStructure: "结构编辑器",
+    sourceSqlFile: "SQL 文件执行",
+    sourceObjectBrowser: "对象浏览器",
+    sourceSchemaDiff: "结构对比",
+    sourceDataCompare: "数据对比",
+    sourceExtension: "扩展管理",
+    sourceSidebar: "对象树",
+    sourceObjectSource: "对象源码编辑器",
+    sourceDataGenerate: "数据生成器",
+    sourceQueryHistory: "查询历史回滚",
+    sourceAdmin: "数据库管理",
+    aiReviewRequired: "生产 SQL 已放入编辑器。请先检查，再手动执行以确认。",
+  },
+  sqlParameters: {
+    title: "SQL 参数",
+    description: "为 SQL 模板占位符填写参数值，DBX 会在执行前替换为 SQL 字面量。",
+    name: "参数名",
+    syntax: "Syntax",
+    type: "类型",
+    value: "参数值",
+    valuePlaceholder: "输入参数值",
+    preview: "SQL 预览",
+    execute: "执行",
+    kind: {
+      string: "字符串",
+      number: "数字",
+      boolean: "布尔值",
+      null: "NULL",
+      raw: "原始 SQL",
+    },
+  },
+  transfer: {
+    title: "数据传输",
+    source: "源",
+    target: "目标",
+    sourceConnection: "源连接",
+    sourceDatabase: "源数据库",
+    sourceSchema: "源 Schema",
+    targetConnection: "目标连接",
+    targetDatabase: "目标数据库",
+    targetSchema: "目标 Schema",
+    tables: "表",
+    selectAll: "全选",
+    deselectAll: "取消全选",
+    createTable: "目标表不存在时自动建表",
+    transferMode: "传输模式",
+    modeAppend: "追加 (INSERT)",
+    modeOverwrite: "覆盖 (TRUNCATE + INSERT)",
+    modeUpsert: "更新插入 (按主键 INSERT 或 UPDATE)",
+    targetTableNameCase: "目标表名大小写",
+    tableNameCasePreserve: "保持原样",
+    tableNameCaseLower: "转为小写",
+    tableNameCaseUpper: "转为大写",
+    batchSize: "每批行数",
+    start: "开始传输",
+    cancel: "取消",
+    progress: "传输中...",
+    transferring: "正在传输 {table}...",
+    completed: "传输完成",
+    completedWithErrors: "传输完成，{count} 个表失败",
+    failed: "传输失败",
+    cancelled: "传输已取消",
+    rowsTransferred: "已传输 {count} 行",
+    tableProgress: "{current} / {total} 张表",
+    noSqlConnections: "暂无可用的 SQL 连接",
+    selectTables: "选择要传输的表",
+    searchTables: "搜索表名...",
+    noTables: "暂无表",
+    selectSourceFirst: "请先选择源连接和数据库",
+    tableError: "表 {table} 传输失败：{error}",
+    overallProgress: "整体进度",
+    dataTransfer: "数据传输",
+    runInBackground: "后台运行",
+    newTask: "新建传输",
+    editConfig: "编辑配置",
+    retry: "重新传输",
+    targetTableBusy: "已有传输任务正在写入目标表：{tables}",
+    ownershipTitle: "归属用户确认",
+    ownershipMessage: "目标端缺少以下归属用户或角色：{owners}。按原归属用户应用可能失败。",
+    ownershipSkipDetails: "选择跳过后，将不执行对象归属变更语句，表数据和其它结构同步会继续执行。",
+    ownershipTargetOwner: "选择确认后，缺失归属用户对应的对象会重归属至目标连接用户：{owner}。",
+    ownershipSkip: "跳过",
+    ownershipConfirm: "确认",
+    selectConnection: "选择连接",
+    selectDatabase: "选择数据库",
+    selectSchema: "选择模式",
+    searchConnection: "搜索连接...",
+    searchDatabase: "搜索数据库...",
+    searchSchema: "搜索模式...",
+  },
+  tableImport: {
+    title: "导入表数据",
+    target: "目标表",
+    selectFile: "选择文件",
+    changeFile: "更换文件",
+    noFileSelected: "未选择文件",
+    sourceFile: "源文件",
+    sourceFormat: "源格式",
+    targetMode: "目标",
+    existingTable: "现有表",
+    createTable: "创建新表",
+    createTableHint: "根据文件推断字段",
+    targetTableName: "表名",
+    noExistingTarget: "未选择表",
+    stepSource: "来源",
+    stepOptions: "选项",
+    stepMapping: "映射",
+    stepReview: "确认",
+    stepExecution: "执行",
+    formatCsv: "CSV",
+    formatCsvDescription: "逗号分隔文本",
+    formatTsv: "TSV",
+    formatTsvDescription: "制表符分隔文本",
+    formatDelimited: "分隔文本",
+    formatDelimitedDescription: "自定义文本分隔符",
+    formatJson: "JSON",
+    formatJsonDescription: "对象行或数组行",
+    formatExcel: "Excel",
+    formatExcelDescription: "XLS、XLSX、XLSM",
+    previewRows: "预览行数",
+    delimiter: "分隔符",
+    hasHeader: "首行为表头",
+    titleRow: "标题行（0 表示无）",
+    dataStartRow: "数据开始行",
+    lastDataRow: "最后数据行（0 表示末尾）",
+    trimValues: "裁剪空白",
+    emptyStringAsNull: "空字符串作为 NULL",
+    jsonShape: "JSON 行结构",
+    jsonShapeAuto: "自动检测",
+    jsonShapeObjects: "对象",
+    jsonShapeArrays: "数组",
+    sheet: "工作表",
+    firstSheet: "第一个工作表",
+    loadPreview: "加载预览",
+    reloadPreview: "重新加载预览",
+    previewReady: "{rows} 行，{columns} 列",
+    file: "文件",
+    rows: "行数",
+    mapped: "已映射",
+    mapping: "字段映射",
+    sourceColumn: "来源字段",
+    targetColumn: "目标字段",
+    targetDataType: "目标类型",
+    createColumns: "将创建的字段",
+    skipColumn: "跳过",
+    preview: "预览",
+    mode: "导入模式",
+    append: "追加数据",
+    truncate: "清空后导入",
+    progress: "进度",
+    start: "开始导入",
+    success: "已导入 {count} 行",
+    back: "上一步",
+    next: "下一步",
+    truncateWarning: "导入开始前会先删除目标表中的现有数据。",
+    requiredUnmapped: "以下必填目标列未映射：{columns}",
+    status_idle: "准备导入",
+    status_running: "正在导入数据",
+    status_done: "导入完成",
+    status_error: "导入失败",
+    status_cancelled: "导入已取消",
+  },
+  dataGenerate: {
+    title: "数据生成",
+    target: "目标",
+    rowCount: "生成的行数",
+    columns: "字段",
+    column: "列名",
+    type: "类型",
+    generator: "生成器",
+    columnProps: "字段属性",
+    databaseObjects: "数据库对象",
+    selectTable: "请从左侧选择表",
+    saveProfile: "保存配置文件",
+    loadProfile: "加载配置文件",
+    options: "选项",
+    generateOrder: "生成顺序",
+    nextStep: "下一步",
+    insertSuccess: "已插入 {count} 行",
+    noData: "暂无数据，请先配置生成规则",
+    noResult: "暂无执行结果",
+    regenerate: "重新生成",
+    first50Rows: "仅显示前 50 行，共 {count} 行",
+    resultTitle: "执行结果",
+    successLabel: "{count} 成功",
+    failLabel: "{count} 失败",
+    totalLabel: "/ {count} 条",
+    copyAllSql: "复制全部 SQL",
+    prevStep: "上一步",
+    startInsert: "开始插入",
+    confirm: "确定",
+    back: "返回",
+    reset: "重置",
+    selectGenerator: "选择生成器...",
+    selectGeneratorHint: "请选择一个生成器",
+    preview: "预览",
+    noValue: "(无)",
+    startDate: "开始日期",
+    endDate: "结束日期",
+    allDay: "一整天",
+    startTime: "开始时间",
+    endTime: "结束时间",
+    weekday: "星期",
+    all: "全部",
+    weekdayOnly: "工作日",
+    custom: "自定义",
+    values: "值",
+    min: "最小",
+    max: "最大",
+    increment: "递增",
+    cycle: "超出后循环",
+    includeDefault: "包含默认值",
+    includeNull: "包含 NULL",
+    unique: "设置唯一",
+    disableLinks: "禁用字段之间的数据链接",
+    imageMode: "模式",
+    generate: "生成",
+    fromFolder: "从文件夹",
+    imageWidth: "图像宽度",
+    imageHeight: "图像高度",
+    imageFormat: "图像格式",
+    folderPath: "文件夹路径",
+    filterByExtension: "使用扩展名筛选",
+    errorContinue: "遇到错误时继续",
+    truncateBefore: "生成数据前清空表",
+    useTransaction: "使用事务",
+    extendedInsert: "使用扩展插入语句",
+    ok: "确定",
+    noTablesSelected: "暂无已选中的表",
+    orderHint: "使用上下箭头调整顺序",
+    gen: {
+      general: "通用",
+      personal: "个人",
+      payment: "支付",
+      business: "商业",
+      location: "位置",
+      product: "产品",
+      computer: "电脑",
+      number: "数字",
+      datetime: "日期时间",
+      date: "日期",
+      time: "时间",
+      sequence: "序列",
+      enum: "枚举",
+      text: "文本",
+      image: "图像或二进制",
+      foreign_key: "外键",
+      uuid: "UUID",
+      regex: "正则表达式",
+      full_name: "姓名",
+      gender: "性别",
+      title: "称谓",
+      marital_status: "婚姻状况",
+      phone: "电话号码",
+      email: "电子邮箱",
+      job_title: "职位名称",
+      social_id: "社交网络ID",
+      payment_method: "支付方式",
+      credit_card_type: "信用卡类型",
+      credit_card_number: "信用卡卡号",
+      credit_card_date: "信用卡日期",
+      company_name: "公司名称",
+      department: "部门",
+      industry: "行业",
+      address: "地址",
+      city: "城市",
+      region: "地区",
+      product_name: "产品名称",
+      product_category: "产品类别",
+      color: "颜色",
+      size: "尺寸",
+      weight_unit: "重量单位",
+      barcode: "条码",
+      sku: "SKU",
+      ip_address: "IP地址",
+      mac_address: "MAC地址",
+      file_path: "文件路径",
+      file_name: "文件名称",
+      file_extension: "文件扩展名",
+      url: "网址",
+      hostname: "主机名",
+      id_number: "证件号",
+    },
+    idTypes: {
+      title: "证件类型",
+      customPattern: "自定义模式",
+      customPatternPlaceholder: "如 ([A-Z]{2})-([0-9]{8})",
+      customPatternHint: "支持 [A-Z] 字母、[0-9] 数字、{n} 重复、连字符等简单模式",
+      id_card: "身份证号",
+      passport: "护照号",
+      hk_macau_pass: "港澳通行证",
+      taiwan_pass: "台湾通行证",
+      uscc: "统一社会信用代码",
+      bank_card: "银行卡号",
+      drivers_license: "驾驶证号",
+      custom: "自定义",
+    },
+  },
+  tableToolbox: {
+    title: "数据工具",
+    generateData: "生成数据",
+    importData: "导入数据",
+    exportData: "导出数据",
+    generateDataComingSoon: "即将推出",
+  },
+  sqlFile: {
+    title: "执行 SQL 文件",
+    file: "文件",
+    selectSqlFile: "选择 SQL 文件",
+    browse: "浏览",
+    previewingLines: "预览 {count} 行",
+    previewingFirstLines: "预览前 {count} 行",
+    target: "目标",
+    connection: "连接",
+    selectConnection: "选择连接",
+    database: "数据库",
+    selectDatabase: "选择数据库",
+    databasePlaceholder: "数据库名称",
+    options: "选项",
+    continueOnError: "出错后继续",
+    runInBackground: "后台运行",
+    cancelling: "正在取消...",
+    cancel: "取消",
+    execute: "执行",
+    statement: "语句",
+    succeeded: "成功",
+    failed: "失败",
+    affectedRows: "影响行数",
+    currentStatement: "当前语句",
+    status: {
+      idle: "空闲",
+      started: "已开始",
+      running: "执行中",
+      statementDone: "语句完成",
+      statementFailed: "语句失败",
+      done: "完成",
+      error: "错误",
+      cancelled: "已取消",
+    },
+  },
+  sqlFileTree: {
+    title: "SQL 文件",
+    openFolder: "打开文件夹",
+    closePanel: "关闭",
+    loading: "加载中...",
+    noFolder: "未打开文件夹",
+    noSqlFiles: "未找到 SQL 文件",
+    folderAlreadyOpen: "此文件夹已打开",
+    removeFolder: "移除文件夹",
+    openFailed: "打开文件夹失败: {message}",
+    loadFailed: "加载 SQL 文件失败: {message}",
+    desktopOnly: "此功能仅在桌面端可用",
+    refreshFolder: "刷新文件夹",
+    refreshAll: "刷新全部",
+    refreshed: "已刷新",
+    revealInFileManager: "在文件管理器中显示",
+    revealFailed: "打开文件管理器失败: {message}",
+    copyPath: "复制路径",
+    pathCopied: "路径已复制",
+    copyFailed: "复制路径失败",
+    openFile: "打开",
+    executeSqlFile: "执行 SQL 文件",
+    expandAll: "全部展开",
+    collapseAll: "全部折叠",
+  },
+  diff: {
+    title: "比较架构",
+    source: "源数据库",
+    target: "目标数据库",
+    selectConnection: "选择连接",
+    selectDatabase: "选择数据库",
+    selectSchema: "选择 Schema",
+    connection: "连接",
+    database: "数据库",
+    schema: "模式",
+    recentConfigs: "最近配置",
+    selectRecentConfig: "选择最近配置",
+    ignoreComments: "忽略注释差异",
+    compare: "开始比较",
+    comparing: "正在比较结构...",
+    noDifferences: "两个数据库结构完全一致",
+    table: "表名",
+    status: "状态",
+    details: "详情",
+    added: "新增",
+    removed: "删除",
+    modified: "修改",
+    indexes: "索引",
+    foreignKeys: "外键",
+    triggers: "触发器",
+    comments: "注释",
+    newTable: "新增表",
+    dropTable: "删除表",
+    generatedSql: "同步 SQL",
+    copySql: "复制 SQL",
+    executeSync: "执行同步",
+    syncSuccess: "同步执行成功",
+    swap: "交换源和目标",
+    syncProgress: "执行中: {current}/{total}",
+    syncSummary: "成功 {success} 条，失败 {failed} 条",
+    sourceObject: "源对象",
+    targetObject: "目标对象",
+    operation: "操作",
+    selectedCount: "已选择 {selected} 个 (共 {total} 个)",
+    saveConfig: "保存配置",
+    loadConfig: "加载配置",
+    options: "选项",
+    ddlCompare: "DDL 比较",
+    deployScript: "部署脚本",
+    deployScriptDesc: "所选对象的 SQL 脚本",
+    selectObjectToCompare: "选择对象查看 DDL 对比",
+    noDdlAvailable: "无可用的 DDL",
+    noDeployScript: "暂无部署脚本",
+    objectNotExistsInSource: "此对象在源库中不存在",
+    objectNotExistsInTarget: "此对象在目标库中不存在",
+    sourceDdl: "源 DDL",
+    targetDdl: "目标 DDL",
+    deployScriptAll: "全部部署脚本",
+    deployScriptAllDesc: "所有选中对象的 SQL 脚本",
+    copyScript: "复制脚本",
+    copy: "复制",
+    execute: "执行",
+    executeAll: "全部执行",
+    executeSuccess: "执行成功",
+    prevStep: "上一步",
+    recompare: "重新比较",
+    maximize: "最大化",
+    restore: "还原",
+    nextStepDeploy: "下一步（审核部署）",
+    deployReview: "部署审核",
+    backToResult: "返回结果",
+    exportSql: "导出 .sql",
+    deployToServer: "部署到服务器",
+    deployConfirmTitle: "最终确认",
+    deployConfirmMessage: "您即将在目标数据库执行以下部署操作",
+    targetServer: "目标服务器",
+    dbVersion: "数据库版本",
+    targetDatabase: "目标数据库",
+    targetSchema: "目标 Schema",
+    useTransaction: "在事务中执行（失败自动回滚）",
+    confirmDeploy: "确认部署",
+    exportSuccess: "导出成功",
+    create: "创建",
+    delete: "删除",
+    modify: "修改",
+    cancel: "取消",
+    operationLabel: {
+      modify: "要修改的对象",
+      create: "要创建的对象",
+      delete: "要删除的对象",
+      none: "无操作",
+    },
+    objectKindLabel: {
+      table: "表",
+      view: "视图",
+      function: "函数",
+      sequence: "序列",
+      rule: "规则",
+      owner: "所有者",
+      index: "索引",
+      foreignKey: "外键",
+      trigger: "触发器",
+    },
+    noObjectsSelected: "请选择要部署的对象",
+    deploySuccess: "部署成功",
+    deployFailed: "部署失败",
+    deploySuccessMessage: "SQL 脚本已成功执行到目标数据库",
+    deployFailedMessage: "执行过程中发生错误",
+    affectedRows: "影响行数",
+    executedStatements: "执行语句数",
+    close: "关闭",
+    info: "信息",
+    connType: "连接类型",
+    connName: "连接名称",
+    host: "主机",
+    port: "端口",
+    serverVersion: "服务器版本",
+    copied: "已复制到剪贴板",
+    configSaved: "配置已保存",
+    configDeleted: "配置已删除",
+    noDeployScriptAll: "暂无所选对象的部署脚本",
+    saveConfigPrompt: "请输入配置名称:",
+    searchConnection: "搜索连接...",
+    searchDatabase: "搜索数据库...",
+    searchSchema: "搜索模式...",
+  },
+  schemaDiff: {
+    optionsTitle: "比较选项",
+    selectConfig: "选择配置",
+    newConfigName: "新配置",
+    newConfig: "新建配置",
+    renameConfig: "重命名配置",
+    duplicateConfig: "复制配置",
+    deleteConfig: "删除配置",
+    exportConfig: "导出配置",
+    exportAllConfigs: "导出全部配置",
+    importConfig: "导入配置",
+    importFromFile: "从文件导入",
+    importFromText: "从文本导入",
+    importPlaceholder: "粘贴 JSON 配置...",
+    importInvalidJson: "无效的 JSON 格式",
+    configName: "配置名称",
+    tableFilter: "表名过滤",
+    tableFilterHint: "按完整表名匹配正则。不用写 /.../；^ 表示开头，$ 表示结尾，| 表示或。",
+    tableFilterHintShort: "按表名正则缩小比较范围",
+    tableFilterHelp: "表名过滤说明",
+    tableFilterHelpRule: "匹配完整表名，不用写 /.../。",
+    tableFilterHelpBlank: "只比较为空表示全部表；跳过为空表示不排除。",
+    tableFilterHelpExample: "^user_ 表示 user_ 开头；_bak$ 表示 _bak 结尾；a|b 表示 a 或 b。",
+    tableIncludePattern: "只比较匹配的表",
+    tableIncludePatternPlaceholder: "如 ^user_",
+    tableExcludePattern: "跳过匹配的表",
+    tableExcludePatternPlaceholder: "如 _bak$",
+    tableFilterPriority: "同时匹配时",
+    tableFilterPriorityExclude: "排除优先",
+    tableFilterPriorityInclude: "包含优先",
+    options: {
+      tables: "比较表",
+      primaryKeys: "比较主键",
+      foreignKeys: "比较外键",
+      uniqueKeys: "比较唯一键",
+      checks: "比较检查约束",
+      exclusions: "比较排除约束",
+      views: "比较视图",
+      functions: "比较函数",
+      indexes: "比较索引",
+      sequences: "比较序列",
+      triggers: "比较触发器",
+      rules: "比较规则",
+      owners: "比较所有者",
+      cascadeDelete: "使用级联删除",
+      sequenceLastValues: "比较序列最后值",
+      compareColumnOrder: "比较字段顺序",
+    },
+  },
+  dataCompare: {
+    title: "比较数据",
+    selectTable: "选择表",
+    searchTable: "搜索表名...",
+    sourceTables: "源表",
+    targetTable: "目标表",
+    searchTables: "搜索表名...",
+    selectedTables: "已选择 {selected}/{total}",
+    selectAllTables: "全选",
+    deselectAllTables: "取消全选",
+    selectSourceTables: "请先选择源连接和数据库，再选择要比较的表",
+    noTables: "暂无可比较的表",
+    autoMatchHint: "多表模式会按同名表自动匹配目标表",
+    matchedTables: "已匹配 {matched}/{total} 张表",
+    missingTargetTables: "目标端缺少同名表：{tables}",
+    keyColumns: "匹配字段",
+    keyColumnsPlaceholder: "用逗号分隔主键或唯一键字段",
+    keyColumnsAutoHint: "留空时，单表会自动推断主键；多表会对每张表分别自动推断。",
+    rowCounts: "源表 {source} 行，目标表 {target} 行；已完成全量比较",
+    previewLimitOption: "预览 {count}",
+    compare: "开始比较数据",
+    summary: "新增 {added} 行，删除 {removed} 行，修改 {modified} 行",
+    batchSummary: "已比较 {tables} 张表：存在差异 {different} 张，一致 {same} 张，失败 {failed} 张；累计新增 {added} 行，删除 {removed} 行，修改 {modified} 行",
+    comparingTable: "正在比较 {current}/{total}：{table}",
+    keyColumnsInline: "匹配字段：{columns}",
+    selectedInline: "已选择 {selected}/{total}",
+    selectedSummary: "当前选择：新增 {added} 行，删除 {removed} 行，修改 {modified} 行",
+    selectAllKind: "全选{kind}",
+    clearKind: "清空{kind}",
+    clearSelection: "清空全部选择",
+    showAllRows: "显示全部 {count} 条",
+    showLessRows: "收起",
+    remainingRows: "还有 {count} 条未在预览中展开",
+    planningSync: "正在更新同步计划...",
+    noSelectedDifferences: "当前没有选中任何要执行的差异",
+    planSummary: "执行计划：新增 {inserts} 条，更新 {updates} 条，删除 {deletes} 条，共 {statements} 条 SQL",
+    statusDifferent: "有差异",
+    statusSame: "一致",
+    statusError: "失败",
+    noKeyColumns: "请至少选择一个匹配字段",
+    missingKeyColumns: "匹配字段在源表和目标表中都必须存在：{columns}",
+    noCommonColumns: "源表和目标表没有可比较的同名字段",
+    targetTableMissing: "目标端找不到表：{table}",
+    noComparableTables: "没有可比较的表，请检查目标端是否存在同名表",
+    noDifferences: "数据完全一致，无需生成同步 SQL",
+    syncSuccess: "数据同步执行成功",
+  },
+  settings: {
+    title: "设置",
+    editorTab: "编辑器",
+    sqlFormatterTab: "SQL 格式化",
+    sqlFormatterImport: "导入配置",
+    sqlFormatterExport: "导出配置",
+    sqlFormatterImportSuccess: "格式化配置已导入。",
+    sqlFormatterCopyJson: "复制 JSON",
+    sqlFormatterCopyJsonSuccess: "JSON 已复制。",
+    sqlFormatterCopyJsonFailed: "复制失败：{message}",
+    sqlFormatterJsonEditorLoadFailed: "JSON 编辑器加载失败，已切换为基础输入框：{message}",
+    sqlFormatterRestoreDefaults: "恢复默认",
+    sqlFormatterFormMode: "表单",
+    sqlFormatterJsonMode: "JSON",
+    sqlFormatterKeywordCase: "关键字大小写",
+    sqlFormatterFunctionCase: "函数名大小写",
+    sqlFormatterDataTypeCase: "数据类型大小写",
+    sqlFormatterIdentifierCase: "标识符大小写",
+    sqlFormatterCaseUpper: "大写",
+    sqlFormatterCaseLower: "小写",
+    sqlFormatterCasePreserve: "保持原样",
+    sqlFormatterIndent: "缩进",
+    sqlFormatterIndentSpaces: "空格",
+    sqlFormatterIndentTabs: "Tab",
+    sqlFormatterTabWidth: "缩进宽度",
+    sqlFormatterIndentStyle: "缩进风格",
+    sqlFormatterIndentStyleStandard: "标准",
+    sqlFormatterIndentStyleTabularLeft: "表格式左对齐",
+    sqlFormatterIndentStyleTabularRight: "表格式右对齐",
+    sqlFormatterLogicalOperatorNewline: "逻辑运算符换行",
+    sqlFormatterLogicalBefore: "运算符前换行",
+    sqlFormatterLogicalAfter: "运算符后换行",
+    sqlFormatterExpressionWidth: "表达式宽度",
+    sqlFormatterLinesBetweenQueries: "查询之间空行",
+    sqlFormatterDenseOperators: "紧凑运算符",
+    sqlFormatterNewlineBeforeSemicolon: "分号单独换行",
+    sqlFormatterAdvancedOptions: "高级选项",
+    sqlFormatterParams: "参数替换",
+    sqlFormatterParamTypes: "参数类型",
+    sqlFormatterEditorShortcuts: "快捷键",
+    sqlFormatterShortcutAction: "功能",
+    sqlFormatterShortcutEnabled: "启用",
+    sqlFormatterShortcutWindows: "Windows",
+    sqlFormatterShortcutLinux: "Linux",
+    sqlFormatterShortcutMacos: "macOS",
+    sqlFormatterShortcutFind: "查找",
+    sqlFormatterShortcutReplace: "替换",
+    sqlFormatterShortcutIndentMore: "增加缩进",
+    sqlFormatterShortcutIndentLess: "减少缩进",
+    sqlFormatterShortcutDuplicateLine: "复制当前行",
+    sqlFormatterShortcutDeleteLine: "删除当前行",
+    sqlFormatterShortcutMoveLine: "移动行",
+    sqlFormatterShortcutMoveLineUp: "当前行上移",
+    sqlFormatterShortcutMoveLineDown: "当前行下移",
+    sqlFormatterShortcutCopyLine: "复制行",
+    sqlFormatterShortcutCopyLineUp: "向上复制当前行",
+    sqlFormatterShortcutCopyLineDown: "向下复制当前行",
+    sqlFormatterShortcutUndo: "撤销",
+    sqlFormatterShortcutRedo: "重做",
+    sqlFormatterShortcutSelectAll: "全选",
+    sqlFormatterShortcutFormatJson: "格式化 JSON",
+    sqlFormatterShortcutApply: "应用配置",
+    sqlFormatterConfigErrorInvalidJson: "JSON 无效。",
+    sqlFormatterConfigErrorObject: "配置必须是 JSON 对象。",
+    sqlFormatterConfigErrorVersion: "不支持的配置版本。",
+    sqlFormatterConfigErrorFormatter: "不支持的格式化器。",
+    sqlFormatterConfigErrorUnsupportedParams: "不支持 params 参数替换。SQL 格式化不会替换占位符。",
+    sqlFormatterConfigErrorOptionsObject: "配置选项必须是 JSON 对象。",
+    sqlFormatterConfigErrorEditorObject: "编辑器配置必须是 JSON 对象。",
+    sqlFormatterConfigErrorEditorScope: "不支持的编辑器作用域。",
+    sqlFormatterConfigErrorEditorPlatforms: "编辑器平台配置无效。",
+    sqlFormatterConfigErrorEditorShortcutsArray: "编辑器快捷键必须是数组。",
+    sqlFormatterConfigErrorEditorShortcutValue: "编辑器快捷键无效。",
+    sqlFormatterConfigErrorUnknownOption: "未知格式化选项：{option}。",
+    sqlFormatterConfigErrorInvalidOptionValue: "“{option}”的值无效。",
+    sqlFormatterConfigErrorUnknownEditorShortcut: "未知编辑器快捷键：{shortcut}。",
+    sqlFormatterConfigErrorInvalidEditorShortcut: "编辑器快捷键无效：{shortcut}。",
+    sqlFormatterConfigErrorDuplicateEditorShortcut: "编辑器快捷键重复：{shortcut}。",
+    sqlFormatterConfigErrorInvalidConfig: "格式化配置无效。",
+    appearanceTab: "外观",
+    navigationTab: "导航",
+    dataTab: "数据",
+    tunnelsTab: "隧道维护",
+    tunnelsDescription: "可复用的 SSH / 代理 / HTTP 隧道配置。一次配置，之后在连接的隧道页签中选择档案即可；此处的修改会对所有使用该档案的连接生效。",
+    tunnelsEmpty: "还没有隧道档案。先在这里创建，然后在连接的隧道设置中选择使用。",
+    tunnelsAddSsh: "新增 SSH",
+    tunnelsAddProxy: "新增代理",
+    tunnelsAddHttp: "新增 HTTP 隧道",
+    tunnelsProfileName: "档案名称",
+    tunnelsProfileNamePlaceholder: "例如：办公室跳板机",
+    tunnelsDelete: "删除",
+    tunnelsUnnamedProfile: "未命名档案",
+    tunnelsSave: "保存",
+    tunnelsReset: "重置",
+    tunnelsSaved: "隧道档案已保存",
+    tunnelsSaveFailed: "保存隧道档案失败：{message}",
+    tunnelsUnsavedHint: "有未保存的修改",
+    redisTab: "Redis",
+    shortcutsTab: "快捷键",
+    snippetsTab: "代码片段",
+    syncTab: "同步",
+    aiTab: "AI",
+    mcpTab: "MCP",
+    jdbcTab: "JDBC 驱动",
+    securityTab: "安全",
+    aboutTab: "关于我们",
+    fontFamily: "字体",
+    uiFontFamily: "界面字体",
+    uiFontAppDefault: "DBX 默认",
+    uiFontSystemDefault: "系统默认",
+    uiFontFamilyDescription: "用于顶部栏、标签页、侧边栏、弹窗等非编辑器界面。",
+    selectFont: "选择字体...",
+    searchFont: "搜索字体...",
+    loadingFonts: "正在加载字体...",
+    noFontsFound: "未找到字体",
+    useCustomFont: "使用“{font}”",
+    languageTitle: "语言 / Language",
+    fontSize: "字号",
+    toolbarTitle: "工具栏",
+    toolbarHiddenHint: '部分关闭或空间不足的按钮会自动收进"更多"下拉菜单。',
+    uiScale: "界面缩放",
+    uiScaleDescription: "按比例缩放整个桌面端界面，适合高清屏；修改后立即生效，并在下次启动时恢复。",
+    theme: "主题",
+    selectTheme: "选择主题...",
+    colorTheme: "配色主题",
+    selectColorTheme: "选择配色主题...",
+    themePalettePearl: "洁白",
+    themePaletteMist: "雾灰",
+    themePaletteGraphite: "钛灰",
+    themePaletteCobalt: "钴蓝",
+    themePaletteSage: "青绿",
+    themePaletteAmber: "暖黄",
+    themePaletteBlush: "樱粉",
+    themePaletteVscode: "VS Code",
+    themePaletteIdea: "IDEA",
+    themePaletteXcode: "Xcode",
+    themePaletteJetbrains: "JetBrains",
+    themePaletteCursor: "Cursor",
+    themePaletteClaude: "Claude Code",
+    followAppTheme: "跟随应用主题",
+    appLayout: "界面布局",
+    appLayoutSeparated: "现代分隔",
+    appLayoutSeparatedDescription: "面板分隔更清晰，标签页为块状样式。",
+    appLayoutClassic: "经典紧凑",
+    appLayoutClassicDescription: "使用连续标签栏和更紧凑的面板标题。",
+    iconTheme: "图标与 Logo 样式",
+    iconThemeDefault: "默认",
+    iconThemeDefaultDescription: "使用彩色 DBX 应用图标。",
+    iconThemeBlack: "黑色",
+    iconThemeBlackDescription: "应用内使用黑色 DBX 标识。",
+    iconThemeBlackDescriptionMac: "应用内使用黑色标识；Dock 使用黑色底板，菜单栏跟随系统。",
+    showTrayIcon: "显示系统托盘/菜单栏图标",
+    showTrayIconDescription: "关闭后不显示图标，但关闭窗口仍会像之前一样隐藏到后台。",
+    quitOnClose: "关闭窗口时退出程序",
+    quitOnCloseDescription: "开启后，点击窗口关闭按钮将彻底退出 DBX，而不是隐藏到系统托盘。",
+    closeActionPromptTitle: "关闭窗口",
+    closeActionPromptDescription: "请选择点击关闭按钮时的行为。之后可在「设置 → 外观」中修改。",
+    closeActionQuit: "退出程序",
+    closeActionMinimize: "最小化到托盘",
+    updateNotificationsEnabled: "启用更新提醒",
+    updateNotificationsEnabledDescription: "关闭后，DBX 不会自动检查应用和驱动更新，也不会显示更新红点；仍可手动检查更新。",
+    updateDownloadSource: "更新下载源",
+    updateDownloadSourceDescription: "选择应用更新、数据库 Agent、驱动和托管 JRE 的下载来源。官方源为推荐选项，CNB 或 AtomGit 适合国内网络环境。",
+    updateDownloadSourceOfficial: "官方源（推荐）",
+    updateDownloadSourceCnb: "CNB",
+    updateDownloadSourceAtomgit: "AtomGit",
+    debugLoggingEnabled: "启用调试日志",
+    debugLoggingEnabledDescription: "开启后在本机记录更详细的用户侧诊断日志，反馈问题时可临时开启；默认关闭。",
+    duckDbWorkerProcessIsolation: "DuckDB 进程隔离模式（实验性）",
+    duckDbWorkerProcessIsolationDescription: "将 DuckDB 查询放到独立 worker 进程中运行。停止长查询时，如果 DuckDB 未及时响应取消请求，DBX 会结束 worker 进程以释放数据库文件锁。",
+    duckDbWorkerMaxProcesses: "DuckDB 最大并发 worker 数",
+    duckDbWorkerMaxProcessesDescription: "限制 DBX 同时运行的 DuckDB worker 进程数量。范围：1-16，默认：4。",
+    duckDbWorkerProcessIsolationRestartRequired: "重启 DBX 后生效。",
+    restartDbx: "重启 DBX",
+    restartDbxFailed: "重启 DBX 失败：{error}",
+    debugLogsCopy: "复制日志",
+    debugLogsCopied: "已复制",
+    debugLogsDownload: "下载日志",
+    debugLogsDownloaded: "已下载",
+    debugLogsClear: "清空日志",
+    tableStructureSection: "表结构",
+    dataGridDisplay: "数据表格显示",
+    showColumnCommentsInHeader: "在字段名下方显示注释",
+    showColumnCommentsInHeaderDescription: "把表字段注释直接显示在结果表头字段名下方。",
+    showColumnTypesInHeader: "在字段名下方显示数据类型",
+    showColumnTypesInHeaderDescription: "把每个字段的数据类型直接显示在结果表头字段名下方。",
+    compactColumnHeaderActions: "收起字段表头工具",
+    compactColumnHeaderActionsDescription: "将格式化、本地筛选收进更多菜单，优先显示字段名称。",
+    dataGridQuickEntry: "表格快捷录入",
+    dataGridQuickEntryDescription: "开启后，编辑单元格或填写底部空行并离焦会立即保存到数据库。便于高频录入，但存在误操作风险。",
+    infiniteScroll: "无限滚动加载",
+    autoCalculateTotalRows: "自动统计总行数",
+    autoCalculateTotalRowsDescription: "每次查询后自动执行 COUNT(*) 显示匹配的总行数。默认关闭以保证大查询速度 —— 可在结果栏按需手动统计。",
+    infiniteScrollDescription: "滚动到表格底部时自动加载下一页数据，无需手动翻页。",
+    infiniteScrollMaxRows: "无限滚动最大行数",
+    infiniteScrollMaxRowsDescription: "无限滚动模式下最多加载的行数（1000–50000）。",
+    tableColumnTemplateFields: "新建表预设字段",
+    tableColumnTemplateFieldsDescription: "先选择数据库类型，再配置新建表时使用的预设字段类型。",
+    tableColumnTemplateAdd: "新增字段",
+    tableColumnTemplateColumn: "字段",
+    tableColumnTemplateDatabase: "数据库",
+    tableColumnTemplateType: "类型",
+    tableColumnTemplateLength: "长度",
+    tableColumnTemplateDefault: "默认值",
+    tableColumnTemplateNoPresetType: "不预设类型",
+    tableColumnTemplateRequired: "必填",
+    tableColumnTemplateComment: "描述",
+    tableColumnTemplateDragHandle: "拖动调整顺序",
+    sidebarActivation: "侧边栏打开方式",
+    sidebarActivationSingle: "单击打开",
+    sidebarActivationSingleDescription: "单击即可打开侧边栏中的可操作项目。",
+    sidebarActivationDouble: "双击打开",
+    sidebarActivationDoubleDescription: "单击只选中高亮，双击打开项目。",
+    sidebarObjectDisplay: "侧边栏对象层级",
+    sidebarObjectDisplayGrouped: "高级视图",
+    sidebarObjectDisplayGroupedDescription: "按表、视图、过程、函数分组展示，适合对象类型较多的库。",
+    sidebarObjectDisplaySimple: "简单视图",
+    sidebarObjectDisplaySimpleDescription: "数据库或 schema 下直接平铺表和视图，减少中间层级。",
+    autoSelectActiveSidebarNode: "始终选中已打开项目",
+    autoSelectActiveSidebarNodeDescription: "切换标签页时，在侧边栏选中匹配的可见表、集合或 SQL 文件。",
+    openTabsRestoreMode: "启动时恢复标签页",
+    openTabsRestoreModeDescription: "选择 DBX 启动时如何恢复上次打开的标签页。",
+    openTabsRestoreModeAll: "保留所有标签",
+    openTabsRestoreModePinned: "仅保留固定标签",
+    openTabsRestoreModeNone: "不保留标签",
+    openTabsRestoreModeHint: "固定标签会显示在标签栏左侧，适合作为常用工作入口。",
+    disconnectTabHandlingMode: "关闭连接后的标签页处理",
+    disconnectTabHandlingModeDescription: "选择关闭连接或数据库后，相关标签页的保留策略。",
+    disconnectTabHandlingModeCloseTabs: "关闭全部页签",
+    disconnectTabHandlingModeCloseTabsDescription: "直接关闭对应连接或数据库下的全部相关页签。",
+    disconnectTabHandlingModeKeepTabsClearResults: "关闭表格页签，保留 SQL 页签",
+    disconnectTabHandlingModeKeepTabsClearResultsDescription: "关闭表数据、对象浏览和结构等页签，保留 SQL 查询页签和 SQL 文本，同时清理执行状态与结果会话。",
+    disconnectTabHandlingModeKeepTabsKeepResults: "不关闭相关页签",
+    disconnectTabHandlingModeKeepTabsKeepResultsDescription: "保留相关页签、SQL 文本和当前结果，不做额外处理。",
+    reuseDataTab: "复用数据标签页",
+    reuseDataTabDescription: "单击侧边栏表名时，复用已有的数据标签页而不是创建新标签页，避免打开过多标签。",
+    sidebarHiddenTablePrefixes: "隐藏表名前缀",
+    sidebarHiddenTablePrefixesDescription: "每行一个前缀，仅影响侧边栏表、视图和集合的显示名称，悬浮提示和实际操作仍使用完整名称。",
+    sidebarHiddenTablePrefixesPlaceholder: "例如：\nODS_\nT8Y2_LONG_",
+    sidebarTablePageSize: "侧边栏分页大小",
+    sidebarTablePageSizeDescription: "侧边栏树每页最多加载的表/对象数量。表多时可以调大减少翻页次数。",
+    sidebarTableSearchEnabled: "启用库下表搜索框",
+    sidebarTableSearchEnabledDescription: "在已展开的数据库、schema 或表分组下显示局部表搜索框，用于为不同库分别过滤表。",
+    sidebarHideTableComments: "隐藏侧边栏表注释",
+    sidebarHideTableCommentsDescription: "隐藏侧边栏中表名旁边显示的表/视图注释，以节省横向空间。",
+    sidebarAllowHorizontalScroll: "允许侧边栏横向滚动",
+    sidebarAllowHorizontalScrollDescription: "完整显示较长的表、视图和集合名称；默认关闭以保留省略号截断。",
+    snippetsDescription: "自定义编辑器中触发的 SQL 代码片段模板。",
+    snippetsAdd: "添加片段",
+    snippetsLabel: "显示名",
+    snippetsPrefix: "触发键",
+    snippetsStatus: "状态",
+    snippetsEnabled: "已启用",
+    snippetsDisabled: "已关闭",
+    snippetsToggle: "启用或关闭片段",
+    snippetsBody: "SQL 内容",
+    snippetsLabelPlaceholder: "如：select *",
+    snippetsPrefixPlaceholder: "如：sel",
+    snippetsBodyPlaceholder: "SELECT *\nFROM table\nLIMIT 100;",
+    snippetsRestoreDefaults: "恢复默认",
+    snippetsAddTitle: "添加片段",
+    snippetsEditTitle: "编辑片段",
+    syncWebDavTitle: "WebDAV 同步",
+    syncWebDavDescription: "将包含 SQL 库的 DBX 快照上传到兼容 WebDAV 的存储服务，或从远端恢复。",
+    syncEndpoint: "WebDAV 地址",
+    syncUsername: "用户名",
+    syncPassword: "密码",
+    syncPasswordPlaceholder: "输入密码",
+    syncClearSavedPassword: "清除已保存的密码",
+    syncRememberWebDavPassword: "记住 WebDAV 应用密码",
+    syncSavedPassword: "（已保存）",
+    syncRememberWebDavPasswordDescription: "密码会加密保存在本机，不会同步到 WebDAV，也不会替代同步密码。",
+    syncRemotePath: "远端快照路径",
+    syncRemotePathDescription: "上传时 DBX 会自动创建缺失的父目录。",
+    syncSecretNotice: "默认只同步连接信息和设置，不会同步数据库密码、SSH 密码、代理密码、HTTP 隧道 Token、连接串或 AI API Key。",
+    syncSecrets: "同步加密后的敏感信息",
+    syncSecretsDescription: "开启后，DBX 会先加密数据库密码、SSH 密码、代理密码、HTTP 隧道 Token 和 AI API Key，再上传到远端存储。",
+    syncSecretsSharedDescription: "适用于 WebDAV、GitHub Gist 和 Gitee 代码片段。开启后，敏感信息会加密后随快照同步。",
+    syncSecretsPassphrase: "同步密码",
+    syncSecretsPassphraseDescription: "这个密码只用于加密和恢复敏感信息，DBX 不会保存；换设备恢复时需要再次输入。",
+    syncTest: "测试",
+    syncUpload: "上传",
+    syncDownload: "下载",
+    syncTestSuccess: "WebDAV 目标可访问。",
+    syncUploadSuccess: "已上传 {bytes} 字节到 {path}。",
+    syncAutoUpload: "自动上传快照",
+    syncAutoUploadInterval: "每",
+    syncAutoUploadMinutes: "分钟",
+    syncAutoUploadDescription: "仅在 DBX 打开时运行。下载仍需手动确认，避免意外覆盖本地保存的 SQL。",
+    syncAutoUploadSuccess: "已自动上传 {bytes} 字节到 {path}。",
+    syncDownloadSuccess: "已从 {path} 下载并应用 {bytes} 字节。",
+    syncSecretsApplied: "已恢复加密敏感信息。",
+    syncSecretsSkipped: "远端包含加密敏感信息，但本次未恢复。",
+    syncDownloadConfirm: "要下载并应用远端 DBX 快照吗？本地元信息和保存的 SQL 会被替换。",
+    syncSnippetTitle: "GitHub / Gitee 代码片段同步",
+    syncSnippetDescription: "将同一份 DBX 快照保存到私有代码片段。首次上传会自动创建代码片段并保存其 ID。",
+    syncSnippetProvider: "平台",
+    syncSnippetId: "代码片段 ID",
+    syncSnippetIdPlaceholder: "首次上传可留空",
+    syncSnippetToken: "访问令牌",
+    syncSnippetRememberToken: "加密保存在本机",
+    syncSnippetTokenDescription: "GitHub 令牌需要 Gists 写权限；令牌不会写入同步快照。",
+    syncSnippetTestSuccess: "代码片段同步目标可访问。",
+    syncSnippetUploadSuccess: "已上传 {bytes} 字节到代码片段 {id}。",
+    syncSnippetDownloadSuccess: "已从代码片段 {id} 下载并应用 {bytes} 字节。",
+    syncSnippetGuide: "配置指南",
+    apply: "应用",
+    applyAndClose: "应用并关闭",
+    reset: "重置",
+    resetDefaults: "恢复默认",
+    resetAllDefaults: "恢复所有默认设置",
+    save: "保存",
+    cancel: "取消",
+    executeMode: "执行模式 (Cmd+Enter)",
+    executeModeAll: "执行全部 SQL",
+    executeModeCurrent: "执行光标所在语句",
+    showExecutionTargetPicker: "显示执行目标选择器",
+    showExecutionTargetPickerDescription: "开启后，无选区执行时可在当前语句和全部 SQL 之间临时选择。",
+    showStatementRunButtons: "显示左侧执行按钮",
+    showStatementRunButtonsDescription: "在 SQL 编辑器左侧显示按语句执行的快捷按钮。关闭后仍可通过快捷键和右键菜单执行。",
+    showCurrentStatementFrame: "显示当前语句外框线",
+    showCurrentStatementFrameDescription: "开启后，在 SQL 编辑器中用外框线标出当前可执行语句；关闭后不显示外框线。",
+    showInsertValueHints: "显示 INSERT 值列名提示",
+    showInsertValueHintsDescription: "开启后，在 INSERT ... VALUES 子句的每个值旁显示对应列名提示。",
+    previewStatementRunButton: "预览语句执行按钮",
+    wordWrap: "自动换行",
+    wordWrapDescription: "长 SQL 在编辑器宽度内自动折行显示",
+    vimMode: "Vim 模式",
+    vimModeDescription: "在 SQL 编辑器中使用 Vim 风格的模态编辑",
+    autoCloseBrackets: "自动成对补全",
+    autoCloseBracketsDescription: "输入左括号或左引号时自动补全对应的右括号或右引号",
+    sqlSemanticDiagnosticsEnabled: "SQL 语义诊断",
+    sqlSemanticDiagnosticsEnabledDescription: "开启后，编辑器会提示未知表、字段等语义问题；关闭可减少 SQL 解析和元数据检查的性能开销。",
+    confirmDangerousSqlExecution: "执行危险 SQL 前弹出确认",
+    confirmDangerousSqlExecutionDescription: "关闭后，ALTER、DROP、DELETE、TRUNCATE 等危险 SQL 将直接执行。",
+    confirmUnsavedSqlClose: "关闭未保存 SQL 前弹出确认",
+    confirmUnsavedSqlCloseDescription: "关闭后，有未保存内容的 SQL 标签页会直接关闭或退出，不再弹出保存确认。",
+    sqlVariableSyntax: "SQL 变量与占位符替换",
+    sqlVariableSyntaxDescription: "按数据库类型选择执行 SQL 前替换哪些变量与占位符语法，默认全部开启。",
+    sqlVariableSyntax_positional: "位置占位符",
+    sqlVariableSyntax_positionalDescription: "按顺序为每个位置占位符提示输入替换值。",
+    sqlVariableSyntax_named: "命名占位符",
+    sqlVariableSyntax_namedDescription: "为命名占位符提示输入替换值。",
+    sqlVariableSyntax_shell: "Shell 风格占位符",
+    sqlVariableSyntax_shellDescription: "为 Shell 风格占位符提示输入替换值。",
+    sqlVariableSyntax_mybatis: "MyBatis 风格占位符",
+    sqlVariableSyntax_mybatisDescription: "为 MyBatis 风格占位符提示输入替换值。",
+    sqlVariableSyntax_sqlserver: "SQL Server 风格占位符",
+    sqlVariableSyntax_sqlserverDescription: "为 SQL Server 风格占位符提示输入替换值（可能与会话变量冲突）。",
+    sqlVariableSyntax_atSet: "内联变量展开",
+    sqlVariableSyntax_atSetDescription: "执行前展开内联变量声明并就地代入其值。",
+    autoAliasTables: "自动添加表别名",
+    autoAliasTablesDescription: "在 FROM 或 JOIN 中选择表名补全时，自动插入类似 order_items AS oi 的表别名。",
+    redisScanPageSize: "Redis 扫描数量",
+    redisScanPageSizeDescription: "浏览 Redis Key 时每次 SCAN 请求的 Key 数量。",
+    redisScanPageSizeOption: "{count} 个 Key",
+    exportBatchSize: "导出批次大小",
+    exportBatchSizeDescription: "导出数据时每批读取的行数（100-100000）。",
+    exportRowLimitEnabled: "限制导出行数",
+    exportRowLimitEnabledDescription: "开启时，查询结果和表数据导出最多为下方设置的行数。",
+    exportRowLimit: "数据导出最多行数",
+    exportRowLimitDescription: "查询结果和表数据导出的总行数上限。",
+    exportRowLimitUnlimited: "无限制",
+    queryExportKeysetOptimizationEnabled: "尝试 keyset 优化",
+    queryExportKeysetOptimizationEnabledDescription: "仅对可安全识别的单表查询生效，复杂查询会自动回退。",
+    exportSection: "导出",
+    shortcutExecuteSql: "执行 SQL",
+    shortcutFind: "查找",
+    shortcutReplace: "替换",
+    shortcutSaveSql: "保存 SQL",
+    shortcutAcceptCompletion: "接受补全",
+    shortcutFormatSql: "格式化 SQL",
+    shortcutToggleLineComment: "切换行注释",
+    shortcutIndentMore: "增加缩进",
+    shortcutIndentLess: "减少缩进",
+    shortcutDuplicateLine: "复制当前行",
+    shortcutDeleteLine: "删除当前行",
+    shortcutMoveLineUp: "上移当前行",
+    shortcutMoveLineDown: "下移当前行",
+    shortcutCopyLineUp: "向上复制当前行",
+    shortcutCopyLineDown: "向下复制当前行",
+    shortcutUndo: "撤销",
+    shortcutRedo: "重做",
+    shortcutSelectAll: "全选",
+    shortcutUppercaseSelection: "选中内容转为大写",
+    shortcutLowercaseSelection: "选中内容转为小写",
+    shortcutExPasteSqlInCondition: "ExPaste：粘贴为 IN 条件",
+    shortcutCopyCurrentRow: "复制当前数据行",
+    shortcutDeleteCurrentRow: "删除当前数据行",
+    shortcutNewQuery: "新建查询",
+    shortcutOpenSettings: "打开设置",
+    shortcutCloseTab: "关闭标签页",
+    shortcutToggleSidebar: "切换侧边栏",
+    shortcutFocusSearch: "聚焦搜索",
+    shortcutQuickOpen: "快速打开 (搜索所有数据库对象)",
+    shortcutSwitchToPreviousTab: "切换到左侧标签页",
+    shortcutSwitchToNextTab: "切换到右侧标签页",
+    shortcutSwitchToTab1: "切换到第 1 个标签页",
+    shortcutSwitchToTab2: "切换到第 2 个标签页",
+    shortcutSwitchToTab3: "切换到第 3 个标签页",
+    shortcutSwitchToTab4: "切换到第 4 个标签页",
+    shortcutSwitchToTab5: "切换到第 5 个标签页",
+    shortcutSwitchToTab6: "切换到第 6 个标签页",
+    shortcutSwitchToTab7: "切换到第 7 个标签页",
+    shortcutSwitchToTab8: "切换到第 8 个标签页",
+    shortcutSwitchToTab9: "切换到第 9 个标签页",
+    shortcutZoomInUi: "放大全局界面",
+    shortcutZoomOutUi: "缩小全局界面",
+    shortcutResetUiZoom: "重置全局界面缩放",
+    shortcutRefreshData: "刷新数据",
+    shortcutToggleTranspose: "切换转置视图",
+    shortcutCancelSearch: "取消搜索",
+    shortcutCopySidebarSelection: "复制侧边栏选中项",
+    shortcutPasteSidebarSelection: "粘贴到侧边栏",
+    shortcutEditSidebarConnection: "编辑侧边栏连接",
+    shortcutSendSelectionToAi: "发送选中代码到 AI",
+    shortcutScopeGlobal: "全局",
+    shortcutScopeEditor: "SQL 编辑器",
+    shortcutScopeGrid: "数据表格",
+    shortcutScopeSearch: "搜索框",
+    shortcutScopeSidebar: "侧边栏",
+    shortcutPressShortcut: "按下快捷键",
+    shortcutSearchPlaceholder: "搜索快捷键",
+    shortcutSearchNoResults: "没有匹配的快捷键。",
+    shortcutConflict: "这个快捷键与同一作用域内的其他操作冲突。",
+    shortcutClear: "清除快捷键",
+    preview: "实时预览",
+    customTheme: "自定义主题",
+    customThemeConfigure: "自定义主题配置",
+    customThemeTitle: "自定义主题配置",
+    customThemeMyThemes: "我的主题",
+    customThemeNewTheme: "新建主题",
+    customThemeVisualEdit: "可视化编辑",
+    customThemeJsonConfig: "JSON 配置",
+    customThemeLivePreview: "实时预览",
+    customThemePreviewExample: "查询示例",
+    customThemePreset: "预设配色",
+    customThemeSelectPreset: "选择预设配色方案",
+    customThemeApply: "应用",
+    customThemePasteImport: "粘贴导入",
+    customThemeExportJson: "导出 JSON",
+    customThemeSaveAndApply: "保存并应用",
+    customThemeKeyword: "关键字",
+    customThemeField: "字段/变量",
+    customThemeFunction: "函数",
+    customThemeString: "字符串",
+    customThemeNumber: "数字",
+    customThemeComment: "注释",
+    customThemeTable: "表名",
+    customThemeOperator: "运算符",
+    customThemeType: "类型",
+    customThemeBuiltin: "内置变量",
+    customThemeBackground: "背景色",
+    customThemeForeground: "前景色",
+    customThemeDefaultName: "自定义主题",
+    customThemeCopySuffix: " 副本",
+    customThemeApplied: "已应用「{name}」配色方案",
+    customThemeKeepOne: "至少保留一个主题",
+    customThemeJsonError: "JSON 格式错误，请检查",
+    jdbcPlugin: "DBX JDBC 插件",
+    jdbcPluginInstall: "安装 JDBC 插件",
+    jdbcPluginInstallSuccess: "JDBC 插件已安装",
+    jdbcPluginUpdate: "更新",
+    jdbcPluginUninstall: "卸载",
+    jdbcPluginUninstallSuccess: "JDBC 插件已卸载",
+    jdbcPluginInstalled: "已安装：v{version}",
+    jdbcPluginIncompatible: "协议不兼容",
+    jdbcPluginNotInstalled: "未安装",
+    jdbcDrivers: "JDBC 驱动 JAR",
+    jdbcImport: "导入 JAR",
+    jdbcImportPath: "导入路径",
+    jdbcDriverPathPlaceholder: "/path/to/driver.jar",
+    jdbcImportSuccess: "已导入 {count} 个驱动文件",
+    jdbcDeleteSuccess: "驱动已删除",
+    jdbcNoDrivers: "还没有导入 JDBC 驱动。",
+    mcpTitle: "MCP Server",
+    mcpDescription: "检查 Claude Code、Cursor 等编程助手使用的 DBX MCP Server 安装与版本状态。",
+    mcpChecking: "检查中",
+    mcpStatusUnknown: "未检查",
+    mcpStatusError: "检查失败",
+    mcpReady: "可用",
+    mcpNotInstalled: "未安装",
+    mcpUpdateAvailable: "有更新",
+    mcpCurrent: "当前版本",
+    mcpLatest: "最新版本",
+    mcpVersionMissing: "未检测到全局安装",
+    mcpVersionUnknown: "未知",
+    mcpAvailable: "可用",
+    mcpUnavailable: "不可用",
+    mcpBinPath: "命令路径",
+    mcpInstallCommand: "安装命令",
+    mcpUpdateCommand: "升级命令",
+    mcpInstallButton: "安装",
+    mcpUpdateButton: "升级",
+    mcpUpToDate: "已是最新",
+    mcpInstalling: "安装中...",
+    mcpInstallSuccess: "安装成功",
+    mcpInstallFailed: "安装失败",
+    mcpConfig: "MCP 配置",
+    mcpConfigOptionsHint: "以下选项只会更新下方生成的配置文本。复制到 AI 客户端配置后，请重启对应 MCP 会话使其生效。",
+    mcpCodexConfig: "Codex 配置",
+    mcpCodexConfigPath: "Codex 可放在 ~/.codex/config.toml 或项目级 .codex/config.toml。",
+    mcpCursorConfigPath: "Cursor 可放在项目级 .cursor/mcp.json 或全局 ~/.cursor/mcp.json。",
+    mcpTraeConfigPath: "TRAE：设置 > MCP > 添加 > 手动添加，然后粘贴 JSON 配置。",
+    mcpVsCodeConfigPath: "VS Code/Copilot 可放在工作区 .vscode/mcp.json 或用户配置文件 mcp.json。",
+    mcpWindsurfConfigPath: "Windsurf 可放在 ~/.codeium/windsurf/mcp_config.json。",
+    mcpOpenCodeConfigPath: "全局 ~/.config/opencode/opencode.json，项目级 opencode.json。",
+    mcpReadonlyMode: "只读模式",
+    mcpReadonlyModeDescription: "开启后会为示例配置附加 DBX_MCP_ALLOW_WRITES=0，MCP 会话只允许查询。",
+    mcpAllowDangerous: "允许危险 SQL",
+    mcpAllowDangerousDescription: "开启后会为示例配置附加 DBX_MCP_ALLOW_DANGEROUS_SQL=1，允许 DROP、TRUNCATE、ALTER 等语句。",
+    mcpDetectionTiming: "打开此页时会自动检测，点击重新检查可刷新。",
+    mcpNpmBoundary: "DBX 只检测和提示 MCP 状态；安装与升级仍由 npm 完成。",
+    mcpRefresh: "重新检查",
+    mcpGuide: "MCP 指南",
+    supportInfoTitle: "支持信息",
+    supportInfoDescription: "提交 issue 或寻求帮助时，可复制这些环境信息。",
+    supportInfoCopy: "复制支持信息",
+    supportInfoCopied: "已复制",
+    supportInfoLoading: "正在加载支持信息...",
+    supportInfoLoadFailed: "完整支持信息加载失败：{message}",
+    supportInfoAppVersion: "DBX 版本",
+    supportInfoRuntime: "运行环境",
+    supportInfoRuntimeDesktop: "桌面端",
+    supportInfoRuntimeWeb: "Web 端",
+    supportInfoOperatingSystem: "操作系统",
+    supportInfoArchitecture: "系统架构",
+    supportInfoUnknown: "未知",
+    community: "社区",
+    qqGroup: "QQ 群",
+    wechatGroup: "微信交流群",
+    wechatGroupInvite: "腾讯文档邀请",
+    project: "项目",
+    openSource: "开源仓库",
+    officialDocs: "官方文档",
+  },
+  driverStore: {
+    progressJreExtract: "解压 JRE...",
+    progressDownloadJre: "下载 JRE",
+    progressDownloadDriver: "下载驱动",
+    progressDownloadJdbcPlugin: "下载 JDBC 插件",
+    progressJdbcPluginExtract: "安装 JDBC 插件...",
+    usageTitle: "空间占用明细",
+    usageTotal: "总计 {size}",
+    usageTotalLabel: "总计",
+    calculating: "统计中...",
+    usageManagedJre: "托管 JRE",
+    usageAgentDrivers: "内置驱动 Agent",
+    usageDownloadCache: "下载缓存",
+    usageJdbcPlugin: "JDBC 插件",
+    usageJdbcDriverJars: "JDBC 驱动 JAR",
+    clearDownloadCache: "清理缓存",
+    downloadCacheClearSuccess: "下载缓存已清理",
+    downloadCacheClearFailed: "下载缓存清理失败: {error}",
+    offlineDownloadHint: "内网环境可先在有网机器下载离线驱动包，再回到这里导入。",
+    offlineDownloadLink: "离线驱动下载",
+    searchDrivers: "搜索驱动名称、类型、版本...",
+    searchJdbcDrivers: "搜索 JDBC 驱动名称或路径...",
+    jdbcMavenCoordinatePlaceholder: "Maven 坐标，例如 org.postgresql:postgresql:42.7.7",
+    jdbcMavenInstall: "从 Maven 安装",
+    jdbcMavenInstallSuccess: "JDBC Maven 驱动已安装",
+    jdbcSourceMaven: "Maven",
+    jdbcSourceManual: "手动",
+    noMatchingDrivers: "没有匹配的驱动。",
+    javaRuntimeSaved: "Java 运行时设置已保存",
+    javaRuntimeSaveFailed: "Java 运行时设置失败: {error}",
+    chooseJavaExecutable: "选择 Java 可执行文件",
+    driverInstallSuccess: "{label} 驱动安装成功",
+    driverInstallFailed: "{label} 驱动安装失败: {error}",
+    driverUpdateBlocked: "请先关闭以下数据库连接后再更新驱动: {labels}",
+    upgradeAllSuccess: "{count} 个驱动升级完成",
+    upgradeAllPartial: "{count} 个驱动升级完成，以下驱动已跳过: {failed}",
+    upgradeAllFailed: "批量升级失败: {error}",
+    driverUninstallSuccess: "{label} 驱动已卸载",
+    driverUninstallFailed: "{label} 驱动卸载失败: {error}",
+    chooseOfflineDriverPackage: "选择离线驱动包",
+    offlineImportSuccess: "离线导入完成，已安装 {count} 个驱动",
+    offlineImportFailed: "离线导入失败: {error}",
+    driverImportSuccess: "{label} 驱动导入成功",
+    driverImportFailed: "{label} 驱动导入失败: {error}",
+    chooseDriverJar: "选择驱动 JAR 文件",
+    jreReinstallSuccess: "JRE {jre} 重新安装成功",
+    jreReinstallFailed: "JRE {jre} 重新安装失败: {error}",
+    jreUninstallSuccess: "JRE {jre} 已卸载",
+    chooseJdbcPluginZip: "选择 JDBC 插件 zip 文件",
+    agentDrivers: "内置驱动",
+    jdbcDrivers: "JDBC 驱动",
+    importing: "导入中...",
+    importOfflinePackage: "导入离线包",
+    refresh: "刷新",
+    javaRuntime: "Java 运行时",
+    javaRuntimeManaged: "DBX 托管 JRE",
+    javaRuntimeSystem: "系统 java",
+    javaRuntimeCustom: "自定义路径",
+    saving: "保存中...",
+    customJavaPathPlaceholder: "/path/to/java 或 /path/to/jdk",
+    choose: "选择",
+    systemJavaHint: "使用当前环境 PATH 中的 java。",
+    jreRuntimeTitle: "JRE {jre} 运行时",
+    notInstalled: "未安装",
+    reinstalling: "重装中",
+    installing: "安装中",
+    install: "安装",
+    reinstall: "重新安装",
+    uninstall: "卸载",
+    jreRuntime: "JRE 运行时",
+    jreRuntimeAutoDownloadHint: "首次安装驱动时自动下载",
+    driversUpdatable: "{count} 个驱动可更新",
+    upgradingProgress: "升级中 ({current}/{total})",
+    upgradeAll: "全部升级",
+    queued: "排队中",
+    importLocalJar: "导入本地 JAR",
+    updating: "更新中",
+    update: "更新",
+    localInstall: "本地安装",
+    runtimeDrivers: "运行时",
+    storageTab: "存储",
+    runtimeTitle: "驱动运行时",
+    runtimeHint: "仅在打开此面板时采集运行时指标。",
+    runtimeRunning: "运行中",
+    runtimeMemory: "内存",
+    runtimeHealth: "健康状态",
+    runtimeHealth_healthy: "正常",
+    runtimeHealth_warning: "警告",
+    runtimeHealth_error: "错误",
+    runtimeLastError: "最近错误",
+    runtimeEmpty: "暂无驱动运行时。打开一个 Agent 驱动连接后会自动启动。",
+    runtimeKindAgent: "Agent",
+    runtimeKindPlugin: "插件",
+    runtimeSourceDaemon: "守护进程",
+    runtimeSourceConnection: "连接",
+    runtimeStatus_running: "运行中",
+    runtimeStatus_stopped: "已停止",
+    runtimeStatus_error: "错误",
+    runtimeStatus_unknown: "未知",
+    runtimePid: "PID",
+    runtimeUptime: "运行时长",
+    runtimeActions: "操作",
+    runtimeStop: "停止",
+    runtimeRestart: "重启",
+    runtimeControlConnectionOwned: "关闭数据库连接后即可停止此运行时。",
+    runtimeStopSuccess: "{label} 运行时已停止",
+    runtimeStopFailed: "停止 {label} 失败: {error}",
+    runtimeRestartSuccess: "{label} 运行时已重启",
+    runtimeRestartFailed: "重启 {label} 失败: {error}",
+    driverStoreDir: "驱动存储路径",
+    driverStoreDirDescription: "JDBC 插件和 Agent/JRE 可分别指定存储位置，迁移后应用将自动重启。",
+    pluginStoreDir: "JDBC 插件目录",
+    pluginStoreDirDescription: "存放 JDBC 插件、Maven resolver 和 JDBC 驱动 jar。",
+    agentStoreDir: "Agent / JRE 目录",
+    agentStoreDirDescription: "存放 Agent 驱动包、托管 JRE 和运行时缓存。",
+    driverStoreDirDefault: "默认（安装目录）",
+    driverStoreDirChange: "更改",
+    driverStoreDirReset: "恢复默认",
+    driverStoreDirMigrating: "正在迁移 {target}…",
+    driverStoreDirConfirm: "更改 {target} 将迁移对应驱动数据到新位置，迁移期间可能会断开相关驱动连接。迁移完成后应用将自动重启。是否继续？",
+    driverStoreDirMigrationFailed: "驱动存储路径迁移失败：{error}",
+    driverStoreDirDialogTitle: "选择 {target}",
+    driverStoreDirSuccess: "{target} 已更改，正在重启…",
+  },
+  databaseExport: {
+    title: "导出数据库",
+    options: "选项",
+    includeStructure: "表结构 (DDL)",
+    dropTableIfExists: "导出前添加 DROP TABLE IF EXISTS",
+    includeData: "表数据 (INSERT)",
+    includeObjects: "视图 / 存储过程 / 函数 / 序列",
+    databaseSelection: "选择数据库",
+    selectedDatabases: "已选择 {selected}/{total}",
+    selectAllDatabases: "全选",
+    filterDatabases: "搜索数据库...",
+    clearDatabases: "清空",
+    tableSelection: "选择表",
+    selectedTables: "已选择 {selected}/{total}",
+    selectAllTables: "全选",
+    filterTables: "搜索表名...",
+    clearTables: "清空",
+    loadingTables: "正在加载表...",
+    tableLoadError: "加载表失败：{error}",
+    noTables: "未找到表",
+    export: "导出",
+    exportAllDatabases: "导出全部数据库",
+    exporting: "正在导出...",
+    selectExportDirectory: "选择导出目录",
+    currentDatabase: "数据库 {current}/{total}",
+    currentTable: "当前: {table} ({current}/{total})",
+    rowsExported: "已导出 {count} 行",
+    exportSuccess: "数据库导出成功",
+    exportAllSuccess: "已成功导出 {count} 个数据库",
+    allDatabasesTask: "全部数据库（{count}）",
+    exportError: "导出失败: {error}",
+    exportCancelled: "导出已取消",
+    runInBackground: "后台运行",
+  },
+  mqTopics: {
+    title: "主题管理",
+    searchPlaceholder: "搜索 topic",
+    includeNonPersistent: "包含非持久化主题",
+    refresh: "刷新",
+    refreshing: "刷新中...",
+    createTopic: "创建主题",
+    selectTenantNamespace: "请先选择租户和命名空间",
+    loading: "加载中...",
+    noTopics: "该命名空间下暂无主题",
+    noMatches: "没有匹配的主题",
+    name: "名称",
+    type: "类型",
+    partitions: "分区",
+    actions: "操作",
+    nonPersistent: "非持久化",
+    partitionedTopic: "分区主题",
+    normalTopic: "普通主题",
+    partitionCount: "{count} 个分区",
+    partitionsUnknown: "分区数未知",
+    adjustPartitions: "调整分区",
+    delete: "删除",
+    tenantNamespace: "租户 / 命名空间",
+    topicName: "主题名称",
+    topicNamePlaceholder: "例如: my-topic",
+    persistentRecommended: "持久化主题（推荐）",
+    persistentHint: "持久化主题会将消息保存到磁盘，非持久化主题仅保存在内存中。",
+    enablePartitions: "启用分区",
+    partitionQuantity: "分区数量",
+    partitionHint: "分区可以提高并发性能，但会增加资源消耗。",
+    cancel: "取消",
+    create: "创建",
+    updatePartitionsTitle: "调整分区数: {name}",
+    currentPartitions: "当前分区数",
+    newPartitions: "新分区数",
+    partitionMinHint: "分区数只能增加，不能减少。最小值：{min}",
+    update: "更新",
+    readOnly: "当前连接为只读模式，不能执行写操作。",
+    topicNameRequired: "Topic name 不能为空",
+    currentPartitionsUnknown: "当前分区数未知，无法安全调整分区。",
+    partitionMustIncrease: "新分区数必须大于当前分区数。",
+    confirmDelete: "确定要删除主题「{name}」吗？此操作不可逆。",
+  },
+  nacos: {
+    configs: "配置",
+    services: "服务",
+    raw: "Raw",
+    namespace: "命名空间",
+    createNamespace: "新建命名空间",
+    editNamespace: "编辑命名空间",
+    creatingNamespace: "正在创建...",
+    updatingNamespace: "正在更新...",
+    namespaceCreated: "命名空间「{name}」已创建",
+    namespaceUpdated: "命名空间「{name}」已更新",
+    namespaceId: "命名空间 ID",
+    namespaceIdPlaceholder: "留空则由 Nacos 自动生成",
+    namespaceName: "命名空间名",
+    namespaceNamePlaceholder: "请输入命名空间名",
+    namespaceDesc: "描述",
+    namespaceDescPlaceholder: "留空则使用命名空间名",
+    dataId: "Data ID",
+    group: "Group",
+    format: "配置格式",
+    content: "配置内容",
+    tags: "标签",
+    application: "归属应用",
+    description: "描述",
+    advanced: "高级配置",
+    collapse: "收起",
+    load: "加载",
+    save: "保存",
+    saveAs: "另存为",
+    saving: "保存中...",
+    saved: "配置已保存",
+    createdAndLoaded: "已创建并加载 {dataId}",
+    savedAndLoaded: "已保存并刷新 {dataId}",
+    deleted: "配置已删除",
+    delete: "删除",
+    copy: "复制",
+    copied: "已复制",
+    copyVerifyFailed: "剪贴板写入后校验失败",
+    export: "导出",
+    exported: "导出完成",
+    exportedTo: "已导出到 {path}",
+    exportFailed: "导出失败：{message}",
+    history: "历史",
+    configHistory: "配置历史",
+    historyDetail: "历史版本详情",
+    historyCompareTitle: "历史版本对比",
+    currentPublishedContent: "当前已发布内容：",
+    historyVersionContent: "历史版本内容：",
+    updatedAt: "更新时间",
+    operationType: "操作类型",
+    operator: "操作人",
+    view: "查看",
+    compare: "对比",
+    rollback: "回滚",
+    loadingHistory: "正在加载历史版本...",
+    noHistory: "暂无历史版本",
+    noHistoryHint: "如果刚发布过配置，请刷新；部分 Nacos 版本可能未开启历史记录接口。",
+    historyCreate: "新增",
+    historyUpdate: "更新",
+    historyDelete: "删除",
+    historyRollback: "回滚",
+    confirmRollbackTitle: "回滚 Nacos 配置",
+    confirmRollbackMessage: "该操作会将当前配置回滚到所选历史版本。",
+    rollbackSuccess: "配置已回滚",
+    publish: "发布",
+    dataIdRequired: "Data ID 不能为空",
+    allGroups: "全部分组",
+    noConfigs: "暂无配置",
+    selectConfig: "选择或新建配置",
+    noServices: "暂无服务",
+    selectService: "选择服务",
+    service: "服务",
+    instances: "实例",
+    instanceCount: "{count} 个实例",
+    refresh: "刷新",
+    address: "地址",
+    cluster: "集群",
+    weight: "权重",
+    state: "状态",
+    actions: "操作",
+    query: "查询参数",
+    body: "请求体",
+    response: "响应",
+    template: "模板",
+    configDiffTitle: "配置内容对比",
+    inlineCompare: "行内对比",
+    currentVersionContent: "当前正式版本内容：",
+    publishVersionContent: "本次发布内容：",
+    confirmSaveTitle: "确认保存 Nacos 配置",
+    confirmSaveMessage: "是否保存这次配置变更？新增 {added} 行，删除 {removed} 行。",
+    confirmDeleteTitle: "删除 Nacos 配置",
+    confirmDeleteMessage: "该操作会从 Nacos 删除所选配置。",
+    confirmInstanceTitle: "更新 Nacos 实例",
+    confirmInstanceMessage: "请确认目标服务实例状态。",
+    confirmRawTitle: "发送变更型 Raw API 请求",
+    confirmRawMessage: "该 Raw API 请求可能会修改 Nacos 状态。",
+    rawTemplate: {
+      serverState: "服务状态",
+      namespaceList: "命名空间列表",
+      configDetail: "配置详情",
+      serviceList: "服务列表",
+      instanceList: "实例列表",
+    },
+    healthy: "健康",
+    unhealthy: "不健康",
+    enabled: "已启用",
+    offline: "已下线",
+    ephemeral: "临时实例",
+    persistent: "持久实例",
+    enable: "启用",
+    disable: "禁用",
+    markHealthy: "标记健康",
+    markUnhealthy: "标记不健康",
+    send: "发送",
+    total: "共 {count} 条",
+    prev: "上一页",
+    next: "下一页",
+    test: "测试",
+    readOnly: "只读",
+  },
+});
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
new file mode 100644
index 0000000..775d3f0
--- /dev/null
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -0,0 +1,3821 @@
+import { withEnglishFallback } from "./fallback";
+
+export default withEnglishFallback({
+  app: {
+    name: "DBX",
+  },
+  auth: {
+    setupTitle: "設定存取密碼",
+    setupDescription: "設定密碼以保護您的實例",
+    loginDescription: "資料庫管理工具",
+    newPassword: "輸入新密碼",
+    confirmPassword: "確認密碼",
+    enterPassword: "請輸入存取密碼",
+    passwordMismatch: "兩次輸入的密碼不一致",
+    setPassword: "設定密碼",
+    login: "登入",
+    processing: "處理中……",
+    loginFailed: "密碼錯誤",
+    connectFailed: "連線失敗",
+    changePassword: "修改密碼",
+    oldPassword: "目前密碼",
+    oldPasswordWrong: "目前密碼不正確",
+    passwordChanged: "密碼修改成功",
+    changePasswordFailed: "密碼修改失敗",
+    changePasswordDescription: "輸入目前密碼並設定新密碼",
+  },
+  toolbar: {
+    newConnection: "建立連線",
+    newQuery: "建立查詢",
+    execute: "執行",
+    executeShortcut: "執行選取/全部 (Cmd+Enter)",
+    stopQuery: "停止執行",
+    explainPlan: "執行計畫",
+    stopExplain: "停止執行計畫",
+    formatSql: "格式化 SQL",
+    formatSqlFailed: "SQL 格式化失敗",
+    keywordCaseLower: "使用小寫 SQL 關鍵字",
+    keywordCaseUpper: "使用大寫 SQL 關鍵字",
+    autoCommit: "自動提交",
+    manualTransaction: "手動事務",
+    autoCommitAgent: "自動提交（取決於 Agent 後端資料庫）",
+    manualTransactionAgent: "手動事務（取決於 Agent 後端資料庫）",
+    commit: "提交",
+    rollback: "回溯",
+    txnAutoRolledBack: "事務已因 5 分鐘無操作而自動回溯",
+    previewSql: "預覽 SQL",
+    hidePreviewSql: "隱藏 SQL 預覽",
+    saveSql: "儲存到 SQL 庫",
+    openSql: "開啟 SQL 檔案",
+    exPasteSqlInCondition: "ExPaste：貼上為 IN 條件",
+    theme: "主題",
+    themeLight: "亮色",
+    themeDark: "暗色",
+    themeSystem: "跟隨系統",
+    sqlSaved: "SQL 已儲存",
+    sqlOpenFailed: "開啟檔案失敗：{message}",
+    sqlSaveFailed: "儲存檔案失敗：{message}",
+    driverManager: "驅動程式管理器",
+    updatableDriverCount: "可更新驅動程式數量",
+    blockDangerousRedisCommands: "攔截危險命令",
+  },
+  updates: {
+    title: "更新",
+    check: "檢查更新",
+    availableTitle: "發現新版本",
+    availableMessage: "DBX {latest} 已發布，目前版本為 {current}。",
+    upToDate: "DBX 已是最新版本 ({version})。",
+    failed: "檢查更新失敗：{error}",
+    rateLimited: "GitHub 更新檢查暫時觸發頻率限制。你仍然可以開啟下載頁手動檢視。",
+    openRelease: "開啟下載頁",
+    downloadAndInstall: "下載並安裝",
+    portableManualUpdate: "可攜版無法使用應用程式內建安裝器更新。請從發行頁下載可攜版 ZIP，並解壓縮覆蓋目前的 DBX 目錄，以保留 portable.dbx 和 data。",
+    downloading: "下載中 {progress}%",
+    downloadFailed: "更新下載失敗：{error}",
+    restart: "結束並重新啟動",
+    restartFailed: "重新啟動應用程式失敗：{error}",
+    exitAndUpdate: "結束並更新",
+    dockerUsersRun: "Docker 使用者請執行",
+    toUpdate: "更新",
+  },
+  sidebar: {
+    connections: "連線",
+    noConnections: "暫無連線",
+    import: "匯入連線",
+    importDbx: "匯入 DBX 設定",
+    importNavicat: "匯入 Navicat NCX",
+    importDbeaver: "匯入 DBeaver",
+    importDatagrip: "匯入 DataGrip",
+    export: "匯出連線",
+    collapseAll: "一鍵收合",
+    collapse: "收合側邊欄",
+    expand: "展開側邊欄",
+    showMore: "再顯示 {count} 個……",
+    filterByType: "依類型篩選",
+    searchScopeConnection: "連線",
+    searchScopeDatabase: "資料庫",
+    searchScopeSchema: "Schema",
+    searchScopeTable: "資料表",
+    searchScopeView: "檢視",
+    searchTablesInCurrentScope: "搜尋目前資料庫的資料表...",
+    clearTableSearch: "清除資料表搜尋",
+    clearFilter: "清除篩選",
+    locateActiveTab: "在側邊欄中定位",
+  },
+  savedSql: {
+    saveToLibrary: "儲存到 SQL 庫",
+    saveToFile: "儲存到本機",
+    save: "儲存",
+    saved: "SQL 已儲存",
+    saveFailed: "儲存 SQL 失敗：{message}",
+    fileName: "檔案名稱",
+    folder: "資料夾",
+    rootFolder: "SQL 庫",
+    newQuery: "新建查詢",
+    newFolder: "建立 SQL 資料夾",
+    newFolderDefault: "建立資料夾",
+    renameFolder: "重新命名資料夾",
+    deleteFolder: "刪除資料夾",
+    deleteFolderConfirm: "確定刪除「{name}」以及其中的 SQL 檔案嗎？",
+    open: "開啟 SQL",
+    renameFile: "重新命名 SQL",
+    deleteFile: "刪除 SQL",
+    deleteFileConfirm: "確定刪除「{name}」嗎？",
+  },
+  sqlLibrary: {
+    title: "SQL 庫",
+    empty: "暫無已儲存的查詢",
+    emptyFolder: "空資料夾",
+    unfiled: "未分類",
+    exportFile: "匯出 SQL",
+    exportFolder: "匯出資料夾",
+    exportLibrary: "匯出 SQL 庫",
+    importDirectory: "匯入本機資料夾",
+    importIntoFolder: "匯入到目前資料夾",
+    openStorageDirectory: "開啟 SQL 儲存目錄",
+    chooseSyncDirectory: "設定本機同步目錄",
+    disableSyncDirectory: "關閉本機同步目錄",
+    syncDirectorySaved: "SQL 本機同步目錄已設定",
+    syncDirectoryDisabled: "SQL 本機同步已關閉",
+    syncDirectoryFailed: "設定同步目錄失敗：{message}",
+    openDirectoryFailed: "開啟目錄失敗：{message}",
+    noSyncDirectory: "請先設定本機同步目錄",
+    exported: "匯出完成",
+    exportFailed: "匯出失敗：{message}",
+    importFailed: "匯入失敗：{message}",
+    importNone: "所選資料夾中沒有 .sql 檔案",
+    imported: "已匯入 {count} 個 SQL 檔案",
+    desktopOnly: "此功能僅桌面版可用",
+    noConnection: "目前沒有可用於匯入的連線",
+    batchDelete: "批次刪除",
+    batchDeleteConfirm: "確定要刪除選取的 {count} 項嗎？此操作無法復原。",
+    batchDeleteSuccess: "成功刪除 {count} 項",
+    moveToFolder: "分類至...",
+    moveSelectedToFolder: "分類選取的 {count} 個 SQL 至...",
+    moveSuccess: "已分類 {count} 個 SQL",
+    clearSelection: "清除選取",
+    sortByDate: "依修改日期排序",
+    sortByFolder: "依資料夾結構排序",
+  },
+
+  connection: {
+    title: "建立連線",
+    name: "名稱",
+    namePlaceholder: "連線名稱，留空則自動產生",
+    type: "類型",
+    host: "主機",
+    filePath: "檔案路徑",
+    h2FileMode: "檔案",
+    h2TcpMode: "TCP",
+    h2FilePathRequired: "H2 檔案路徑不能為空",
+    createDuckDbFile: "建立 DuckDB 檔案",
+    createSqliteFile: "建立 SQLite 資料庫",
+    memoryDatabasePathHint: "輸入 :memory: 可建立 SQLite 或 DuckDB 記憶體資料庫。",
+    sqliteCipherKey: "SQLCipher 密碼（密鑰）",
+    sqliteCipherKeyPlaceholder: "未加密 SQLite 留空",
+    sqliteExtensions: "SQLite 擴充庫",
+    sqliteExtensionsPlaceholder: "/path/to/regexp.dylib\n/path/to/text.dylib|sqlite3_text_init",
+    sqliteExtensionsHint: "每行一個 .dylib/.so/.dll；需要入口函式時使用「路徑|入口函式」。連線時載入，載入後會關閉 load_extension。",
+    sqliteExtensionBrowse: "選擇 SQLite 擴充庫",
+    user: "使用者名稱",
+    password: "密碼",
+    database: "資料庫",
+    databasePlaceholder: "可選",
+    databasePlaceholderRequired: "必填，請填寫已存在的資料庫",
+    databasePlaceholderWithDefault: "可選，預設 {database}",
+    kingbaseDatabaseRequired: "Kingbase 需要先填寫一個已存在的資料庫後才能連線或載入資料庫清單。",
+    defaultDatabase: "預設 DB",
+    authDatabase: "驗證 DB",
+    authDatabasePlaceholder: "可選，通常為 admin",
+    authMechanism: "認證機制",
+    authMechanismDefault: "預設",
+    driverMode: "驅動",
+    mongoDriverAuto: "自動",
+    mongoDriverLegacy: "舊版相容",
+    serviceName: "服務/SID",
+    serviceNameOnly: "服務名稱",
+    version: "版本",
+    driverInstallHintPrefix: "需要在上方導覽列「",
+    driverInstallHintSuffix: "」中安裝對應的驅動程式才能連線。",
+    driverName: "驅動程式名稱",
+    driverNamePlaceholder: "廠商或環境名稱",
+    urlParams: "URL 參數",
+    d1AccountId: "帳戶 ID",
+    d1DatabaseId: "資料庫 ID",
+    d1ApiToken: "API Token",
+    d1TokenHint: "Token 至少需要 D1 Read 權限；執行寫入、DDL 或匯入時還需要 D1 Write 權限。",
+    d1FieldsRequired: "必須填寫 Cloudflare Account ID、D1 Database ID 和 API Token。",
+    gbaseServer: "GBASEDBTSERVER",
+    informixServer: "INFORMIXSERVER",
+    sslEnable: "啟用加密連線",
+    caCertPath: "CA 憑證",
+    caCertPathPlaceholder: "可選，例如 ~/.yandex/RootCA.crt",
+    caCertPathBrowse: "瀏覽憑證",
+    redisTlsInsecure: "跳過憑證驗證",
+    redisTlsInsecureHint: "等價於 redis-cli --tls --insecure，適用於自簽名憑證或私有 CA。",
+    mysqlTlsMode: "TLS 模式",
+    mysqlTlsModePreferred: "優先使用",
+    mysqlTlsModeDisabled: "停用",
+    mysqlTlsModeRequired: "必須使用",
+    mysqlTlsModeVerifyCa: "驗證 CA",
+    mysqlTlsModeVerifyIdentity: "驗證身份",
+    mysqlCleartextPasswordAuth: "明文密碼認證",
+    mysqlCleartextPasswordAuthHint: "僅在 MySQL 伺服器要求明文密碼認證外掛時啟用。",
+    mysqlCaCertHint: "伺服器端憑證由私有 CA 簽發時，Verify CA / Verify Identity 模式需要填寫。",
+    mysqlClientCert: "用戶端認證",
+    mysqlClientCertPlaceholder: "/path/to/client.crt",
+    mysqlClientKeyPlaceholder: "/path/to/client.key",
+    mysqlClientCertHint: "MySQL 要求 mTLS 時，用戶端憑證和私鑰必須一起填寫。",
+    mysqlTlsConnectionFailureHint: "如果 MySQL 伺服器不要求 TLS，請編輯連線，在 TLS 模式中選擇「停用」後重試。",
+    mysqlClientCertBrowse: "選擇用戶端憑證",
+    mysqlClientKeyBrowse: "選擇用戶端私鑰",
+    postgresSslMode: "TLS 模式",
+    postgresSslModeDisable: "停用",
+    postgresSslModePrefer: "優先使用",
+    postgresSslModeRequire: "必須使用",
+    postgresSslModeVerifyCa: "驗證 CA",
+    postgresSslModeVerifyFull: "完整驗證",
+    postgresServerCert: "伺服器端 CA",
+    postgresRootCertPlaceholder: "/path/to/ca.crt",
+    postgresRootCertHint: "伺服器端憑證由私有 CA 簽發時，在 verify-ca 或 verify-full 模式下填寫。",
+    postgresRootCertBrowse: "選擇 CA 憑證",
+    postgresClientCert: "用戶端認證",
+    postgresClientCertPlaceholder: "/path/to/client.crt",
+    postgresClientKeyPlaceholder: "/path/to/client.key",
+    postgresClientCertHint: "PostgreSQL 要求 mTLS 時，用戶端憑證和私鑰必須一起填寫。",
+    postgresClientCertBrowse: "選擇用戶端憑證",
+    postgresClientKeyBrowse: "選擇用戶端私鑰",
+    connectionUrlOptional: "URL（可選）",
+    connectionUrlPlaceholder: "postgresql://user:pass{'@'}host:5432/db?sslmode=require",
+    parseConnectionUrl: "解析連線 URL",
+    parseConnectionUrlApplied: "已套用連線 URL",
+    parseConnectionUrlFailed: "解析連線 URL 失敗：{message}",
+    mode: "連線方式",
+    modeForm: "表單",
+    redisStandaloneMode: "直連",
+    redisSentinelMode: "Sentinel",
+    redisClusterMode: "叢集",
+    oceanbaseMySQLMode: "MySQL 模式",
+    oceanbaseOracleMode: "Oracle 模式",
+    redisFirstSentinel: "第一個 Sentinel",
+    redisFirstClusterNode: "第一個種子節點",
+    redisSentinelNodes: "Sentinel 節點",
+    redisClusterNodes: "叢集種子節點",
+    redisSentinelMaster: "Master 名稱",
+    redisSentinelUser: "Sentinel 使用者",
+    redisSentinelPassword: "Sentinel 密碼",
+    redisSentinelTls: "Sentinel TLS",
+    redisSentinelTlsHint: "連線 Sentinel 節點時使用 TLS",
+    redisKeySeparator: "鍵名分隔符（可選）",
+    etcdEndpoints: "端點",
+    etcdEndpointsHint: "每行一個端點。留空則使用上方的主機和連接埠。",
+    etcdCaCertPlaceholder: "/path/to/ca.crt",
+    etcdCaCertBrowse: "選擇 CA 憑證",
+    etcdClientAuth: "用戶端認證",
+    etcdClientCertPlaceholder: "/path/to/client.crt",
+    etcdClientKeyPlaceholder: "/path/to/client.key",
+    etcdClientCertHint: "etcd 要求 mTLS 時，用戶端憑證和私鑰必須一起填寫。",
+    etcdClientCertBrowse: "選擇用戶端憑證",
+    etcdClientKeyBrowse: "選擇用戶端私鑰",
+    etcdClientCertPairRequired: "用戶端憑證和私鑰必須一起填寫。",
+    zookeeperConnectString: "連線字串",
+    zookeeperConnectStringHint: "以逗號或換行分隔的 host:port 項目。留空則使用上方的主機和連接埠。",
+    zookeeperCreateModePersistent: "持久",
+    zookeeperCreateModeEphemeral: "臨時",
+    zookeeperCreateModePersistentSequential: "持久有序",
+    zookeeperCreateModeEphemeralSequential: "臨時有序",
+    nacosConsoleUrl: "控制台 URL",
+    nacosConsoleUrlHint: "填寫 Nacos 控制台/admin API 位址。Nacos 3 Docker 通常是 8085；如果舊版控制台和服務共用 8848，也可以填 8848。",
+    nacosConsoleUrlRequired: "Nacos 控制台 URL 不能為空",
+    nacosConsoleUrlAutoAdjusted: "已自動將 Nacos 控制台 URL 從 {from} 調整為 {to}。",
+    nacosNamespace: "命名空間",
+    nacosContextPath: "Context Path",
+    nacosContextPathPlaceholder: "留空或填寫 /nacos",
+    nacosAuth: "認證",
+    nacosAuthNone: "無",
+    nacosAuthUserPassword: "使用者名稱 / 密碼",
+    nacosUsernameRequired: "Nacos 使用者名稱不能為空",
+    nacosTls: "TLS",
+    nacosTlsSkipVerify: "跳過憑證驗證",
+    nacosPageSize: "分頁大小",
+    searchDatabasePlaceholder: "搜尋資料庫類型",
+    iconView: "圖示檢視",
+    listView: "清單檢視",
+    selectedDatabase: "已選擇",
+    noDatabaseMatches: "沒有相符的資料庫",
+    next: "下一步",
+    back: "上一步",
+    basicTab: "連線資訊",
+    tlsTab: "TLS/SSL",
+    test: "測試",
+    testing: "測試中……",
+    copyTestResult: "複製測試結果",
+    sqlServerLegacyCompatibilityMode: "舊版相容模式",
+    sqlServerLegacyCompatibilityModeEnable: "使用 SQL Server 舊版相容連線",
+    sqlServerLegacyCompatibilityModeEnabled: "已啟用 SQL Server 舊版相容模式。",
+    sqlServerLegacyCompatibilityModeHint: "適用於非加密、僅登入階段加密或 TLS 1.0 舊版相容場景。若相容元件未安裝，DBX 會先安裝再啟用此模式\n若回退到相容元件，部分 SQL Server 原生能力可能無法使用\n請僅在可信內網、VPN 或 SSH 隧道中使用",
+    sqlServerLegacyCompatibilityComponent: "SQL Server 舊版相容元件",
+    sqlServerLegacyCompatibilityComponentInstalling: "正在安裝 SQL Server 舊版相容元件...",
+    saveAndConnect: "儲存並連線",
+    save: "儲存",
+    editTitle: "編輯連線",
+    testSuccess: "連線成功",
+    connecting: "正在連線 {name}……",
+    connectSuccess: "已連線 {name}",
+    connectFailed: "連線失敗：{message}",
+    driverNotInstalled: "{driver} 驅動程式未安裝，請在驅動程式管理器中安裝。",
+    jreNotInstalled: "JRE {jre} 執行環境未安裝，請在驅動程式管理器中安裝。",
+    systemJavaNotFound: "未在 PATH 中找到系統 Java 執行環境，請安裝 Java 或選擇自訂 Java 可執行檔。",
+    customJavaPathEmpty: "自訂 Java 執行環境路徑為空，請選擇 Java 可執行檔。",
+    agentJavaTooOld: "此驅動程式需要 Java 21。請在驅動程式管理器中使用 DBX 託管 JRE 21，或選擇 Java 21 可執行檔。",
+    agentDriverUpdateConnectionHint: "目前連線使用的內建驅動有可用更新，連線失敗可能與本機驅動版本過舊有關。請在「驅動管理」中更新對應驅動後重試。",
+    jdbcPluginNotInstalled: "JDBC 外掛程式未安裝，請先安裝 JDBC 外掛程式再使用此連線。",
+    lastError: "連線錯誤",
+    clearError: "清除連線錯誤",
+    saveFailed: "儲存連線失敗：{message}",
+    deleted: "連線已刪除",
+    deletedSelected: "已刪除 {count} 個連線",
+    copied: "已複製",
+    disconnected: "已斷開連線",
+    databaseConnectionClosed: "已關閉資料庫連線：{name}",
+    duplicated: "連線已複製",
+    duplicatedSelected: "已複製 {count} 個連線",
+    groupDeleted: "群組已刪除",
+    loadFailed: "載入已儲存連線失敗：{message}",
+    sshTunnel: "SSH 隧道/代理",
+    advancedTab: "進階",
+    sshEnable: "使用 SSH 隧道/代理連線",
+    sshHost: "SSH 主機",
+    sshHostPlaceholder: "ssh.example.com 或 ~/.ssh/config 中的別名",
+    sshUser: "SSH 使用者",
+    sshAuthMethod: "登入方式",
+    sshAuthMethodPassword: "密碼",
+    sshAuthMethodKey: "私鑰",
+    sshAuthMethodNone: "無認證",
+    sshAuthMethodNoneHint: "不會傳送任何憑證,適用於接受無認證連線的 bastion 或代理伺服器。",
+    sshAuthMethodAgentLegacy: "SSH Agent(舊版)",
+    sshPassword: "SSH 密碼",
+    sshPasswordPlaceholder: "留空則使用金鑰",
+    sshKeyPath: "金鑰路徑",
+    sshKeyPassphrase: "金鑰密碼",
+    sshKeyPassphrasePlaceholder: "金鑰未加密則留空",
+    sshKeyPathBrowse: "瀏覽",
+    sshExposeLan: "允許區域網路存取隧道",
+    sshConnectTimeout: "SSH 逾時時間（秒）",
+    sshHops: "SSH 隧道/代理層級",
+    sshHopAdd: "新增 SSH 層",
+    sshHopDuplicate: "複製",
+    sshHopDelete: "刪除",
+    sshHopMoveUp: "上移",
+    sshHopMoveDown: "下移",
+    sshHopName: "連線層名稱",
+    sshHopNamePlaceholder: "堡壘機、跳板機、生產閘道器",
+    sshHopDefaultName: "第 {index} 層",
+    sshHopInvalidHost: "{hop}：SSH 主機不能為空",
+    sshHopInvalidUser: "{hop}：SSH 使用者不能為空",
+    sshHopInvalidPort: "{hop}：SSH 埠必須在 1 到 65535 之間",
+    sshHopInvalidAuth: "{hop}：需要填寫密碼、金鑰路徑或勾選使用 ssh-agent",
+    sshUseAgent: "使用 ssh-agent",
+    sshAgentSockPath: "Agent Socket 路徑",
+    sshAgentSockPathPlaceholder: "如 ~/.ssh/agent.sock",
+    sshHopInvalidTimeout: "{hop}：SSH 逾時時間必須在 1 到 300 秒之間",
+    connectTimeout: "連線逾時（秒）",
+    queryTimeout: "查詢逾時（秒）",
+    idleTimeout: "閒置逾時（秒）",
+    keepaliveInterval: "保持連線間隔（秒）",
+    readOnly: "唯讀模式",
+    readOnlyHint: "阻止所有寫入操作（INSERT、UPDATE、DELETE 等）",
+    readOnlyBadge: "唯讀",
+    proxy: "代理伺服器",
+    proxyEnable: "藉由代理伺服器連線資料庫",
+    proxyType: "代理伺服器類型",
+    proxyHost: "代理伺服器主機",
+    proxyUsername: "代理伺服器使用者",
+    proxyUsernamePlaceholder: "可選",
+    proxyPassword: "代理伺服器密碼",
+    proxyPasswordPlaceholder: "可選",
+    tunnelProfile: "隧道設定檔",
+    tunnelProfileCustom: "自訂（僅此連線）",
+    tunnelProfileManaged: "由共用隧道設定檔管理。請在 設定 > 隧道維護 中編輯，變更會在下次連線時套用到所有使用該設定檔的連線。",
+    tunnelProfileMissing: "引用的隧道設定檔已不存在。請選擇其他設定檔或切換為自訂。",
+    tunnelProfileMissingName: "設定檔已刪除",
+    tunnelProfileManage: "管理",
+    dremioArrowFlightSqlMode: "Arrow Flight SQL",
+    dremioLegacyJdbcMode: "Legacy JDBC",
+    jdbcUrl: "JDBC URL",
+    jdbcUrlPlaceholder: "jdbc:postgresql://localhost:5432/database",
+    jdbcDriverClass: "驅動程式類別（可選）",
+    jdbcDriverClassPlaceholder: "多數驅動程式可自動識別；需要時填寫 com.vendor.jdbc.Driver",
+    jdbcDriverPaths: "驅動程式 JAR",
+    jdbcDriverSelectPlaceholder: "選擇已匯入驅動程式",
+    jdbcManualClasspath: "手動 classpath",
+    jdbcManualClasspathCount: "{count} 個路徑",
+    jdbcDriverPathsPlaceholder: "/path/to/driver.jar\n/path/to/another-driver.jar",
+    jdbcDriverBrowse: "選擇 JDBC 驅動程式 JAR",
+    jdbcDocs: "檢視 JDBC 文件",
+    jdbcPluginHint: "先安裝 DBX JDBC 外掛程式，再匯入資料庫廠商提供的 JDBC 驅動程式 JAR。",
+    dmCompatHint: "需要在系統上安裝達夢 DM8 ODBC 驅動程式。",
+    dmDownload: "前往達夢官網下載",
+    mongoLegacyHint: "舊版 MongoDB（尤其是 4.2 以下版本）請選擇舊版相容。若帳號建立在 admin 且認證失敗，請將認證庫設為 admin。",
+    mongoTlsAllowInvalidCertificates: "停用 TLS 憑證校驗",
+    mongoTlsAllowInvalidCertificatesHint: "對應 tlsAllowInvalidCertificates=true，會停用全部憑證校驗（不只是主機名），存在中間人攻擊風險。經 SSH 隧道存取 AWS DocumentDB 時通常需要開啟。",
+    mongoRetryWrites: "重試寫入",
+    mongoRetryWritesHint: "對應 retryWrites。AWS DocumentDB 不支援可重試寫入，請關閉。",
+    compatible: "相容",
+    mainstream: "熱門",
+    color: "顏色",
+    colorNone: "無顏色",
+    colorGreen: "綠色",
+    colorYellow: "黃色",
+    colorOrange: "橙色",
+    colorRed: "紅色",
+    colorBlue: "藍色",
+    colorPurple: "紫色",
+    colorCustom: "自訂顏色",
+    cancelConnecting: "取消連接",
+    connectCancelled: "連接已取消",
+    kafkaKerberosPrincipal: "Principal",
+    kafkaKerberosKeytab: "Keytab",
+    kafkaKerberosServiceName: "服務名稱",
+    kafkaKerberosKrb5Conf: "krb5.conf",
+    kafkaKerberosPrincipalRequired: "Kafka Kerberos principal 不能為空",
+    kafkaKerberosKeytabRequired: "Kafka Kerberos keytab 路徑不能為空",
+    kafkaKerberosKeytabBrowse: "選擇 Keytab",
+    kafkaKerberosKrb5ConfBrowse: "選擇 krb5.conf",
+    kafkaKerberosKeytabPlaceholder: "DBX Agent 所在機器路徑，例如 /etc/security/keytabs/user.keytab",
+    kafkaKerberosKrb5ConfPlaceholder: "可選，DBX Agent 所在機器路徑，例如 /etc/krb5.conf",
+    kafkaKerberosPathHint: "keytab 和 krb5.conf 路徑由 DBX Agent 讀取，必須存在於執行 DBX Agent 的機器上；不會從當前瀏覽器上傳檔案。",
+    kafkaKerberosAuthHint: "使用 GSSAPI + keytab 登入。若伺服器端要求加密傳輸，請將 Security 設為 SASL_SSL；否則可使用 Auto 或 SASL_PLAINTEXT。",
+  },
+  editor: {
+    pressToExecute: "按 {mod}+Enter 執行查詢",
+    pressToSaveSql: "按 {mod}+S 儲存 SQL",
+    queryTimeoutError: "查詢逾時 ({seconds}s)，請檢查資料庫連線是否正常",
+    changeQueryTimeout: "修改查詢逾時時間",
+    connectionMayBeLost: "連線可能已斷開，請重新整理資料重試",
+    showResultsPane: "顯示結果",
+    hideResultsPane: "收起結果",
+    noDatabase: "未選擇資料庫",
+    unsavedChangesTitle: "未儲存的變更",
+    unsavedChangesMessage: "「{title}」有未儲存的變更，關閉後將遺失。儲存後再關閉嗎？",
+    unsavedChangesBatchCloseMessage: "待關閉的分頁中有未儲存的變更，關閉後將遺失。儲存後再繼續關閉嗎？",
+    unsavedChangesBatchCloseMultipleMessage: "待關閉的 {count} 個 SQL 分頁有未儲存的變更，目前已定位到「{title}」。儲存後繼續關閉嗎？",
+    unsavedChangesAppCloseMessage: "「{title}」有未儲存的 SQL 變更，結束 DBX 後將遺失。儲存後再結束嗎？",
+    unsavedChangesAppCloseMultipleMessage: "目前有 {count} 個 SQL 分頁未儲存，目前已定位到「{title}」。結束 DBX 後將遺失，儲存後再結束嗎？",
+    unsavedChangesViewList: "查看 {count} 個分頁",
+    unsavedChangesListTitle: "未儲存的分頁（{count}）",
+    discardChanges: "捨棄",
+    discardAllChanges: "全部捨棄",
+    saveAllChanges: "全部儲存",
+    selectConnection: "選擇連線",
+    searchConnection: "搜尋連線……",
+    selectDatabase: "選擇資料庫",
+    selectDatabaseRequired: "請先選擇資料庫",
+    searchDatabase: "搜尋資料庫……",
+    selectSchema: "選擇 Schema",
+    searchSchema: "搜尋 Schema...",
+    setDefaultDatabase: "設為預設",
+    defaultDatabase: "預設資料庫",
+    clearDatabase: "清除資料庫",
+    exPasteNoValues: "剪貼簿中沒有可用於 IN 條件的值",
+    exPasteNotList: "未識別到可轉換的多值列表",
+    exPasteTooLarge: "剪貼簿內容過大，最多支援 {limit} 個字元",
+    exPasteTooManyValues: "值過多，最多支援 {limit} 個",
+    exPasteClipboardReadFailed: "讀取剪貼簿失敗：{message}",
+    exPastePasted: "已貼上 {count} 個 IN 條件值",
+    completion: {
+      nullValue: "空值",
+      isNull: "判斷是否為 NULL",
+      isNotNull: "判斷是否不為 NULL",
+      stringLiteral: "字串常值",
+      numericLiteral: "數值常值",
+      booleanValue: "布林值",
+      starExpansionColumns: "{count} 欄",
+      functionDescriptions: {
+        COUNT: "回傳列數",
+        SUM: "回傳數值欄位的總和",
+        AVG: "回傳數值欄位的平均值",
+        MIN: "回傳最小值",
+        MAX: "回傳最大值",
+        GROUP_CONCAT: "將分組值串接成字串",
+        STRING_AGG: "串接分組字串",
+        CONCAT: "串接多個字串",
+        CONCAT_WS: "使用分隔符號串接字串",
+        SUBSTRING: "擷取子字串",
+        REPLACE: "取代字串中的內容",
+        TRIM: "移除前後空白",
+        UPPER: "轉換為大寫",
+        LOWER: "轉換為小寫",
+        LENGTH: "回傳字串長度",
+        REGEXP_REPLACE: "使用正規表示式取代",
+        DATE_FORMAT: "依指定格式格式化日期",
+        DATEDIFF: "計算兩個日期的差值",
+        DATE_ADD: "對日期進行加法運算",
+        DATE_SUB: "對日期進行減法運算",
+        EXTRACT: "擷取日期部分",
+        NOW: "回傳目前日期與時間",
+        ROUND: "四捨五入到指定小數位",
+        FLOOR: "向下捨入",
+        CEIL: "向上捨入",
+        ABS: "回傳絕對值",
+        MOD: "回傳除法餘數",
+        COALESCE: "回傳第一個非 NULL 參數",
+        IFNULL: "如果為 NULL，則回傳替代值",
+        NULLIF: "如果參數相等，則回傳 NULL",
+        CAST: "將運算式轉換為目標類型",
+        JSON_EXTRACT: "從 JSON 擷取值",
+        JSON_VALUE: "從 JSON 擷取純量值",
+        JSON_OBJECT: "建立 JSON 物件",
+        JSON_ARRAY: "建立 JSON 陣列",
+      },
+    },
+    contextMenu: {
+      executeSelection: "執行選取 SQL",
+      executeCurrent: "執行 SQL",
+      copySelection: "複製選取內容",
+      sendToAi: "傳送至 AI",
+      uppercaseSelection: "轉為大寫",
+      lowercaseSelection: "轉為小寫",
+      selectAll: "全選",
+    },
+    search: {
+      find: "尋找",
+      replace: "取代",
+      replaceAll: "全部取代",
+      caseSensitive: "區分大小寫",
+      regex: "正規表示式",
+      collapseReplace: "收起取代",
+      expandReplace: "展開取代",
+      prevMatch: "上一個 (Shift+Enter)",
+      nextMatch: "下一個 (Enter)",
+      close: "關閉 (Esc)",
+      noResults: "無結果",
+    },
+    executionPicker: {
+      title: "執行目標",
+      currentStatement: "當前 SQL",
+      allStatements: "全部 SQL",
+      currentCommand: "目前命令",
+      allCommands: "全部命令",
+    },
+  },
+  tabs: {
+    sql: "SQL",
+    table: "資料表",
+    tableData: "資料表",
+    redis: "Redis",
+    etcd: "etcd",
+    zookeeper: "ZooKeeper",
+    mongo: "Mongo",
+    vector: "向量",
+    objects: "物件",
+    users: "使用者與權限",
+    executionSummary: "摘要",
+    tooltipTitle: "標題：",
+    tooltipFilePath: "檔案路徑：",
+    tooltipConnection: "連線：",
+    tooltipDatabase: "資料庫：",
+    tooltipTable: "資料表：",
+    tooltipCollection: "集合：",
+    tooltipSchema: "Schema：",
+    resultN: "結果 {n}",
+    runN: "執行 {n}",
+    resultRuns: "執行結果",
+    removeRun: "移除執行 {n}",
+    autoKeepResults: "自動保留查詢結果",
+    autoKeepResultsEnabled: "自動保留結果已啟用",
+    autoKeepResultsDisabled: "自動保留結果已停用",
+    autoRefresh: "自動重新整理結果",
+    autoRefreshShort: "自動",
+    autoRefreshEvery: "每 {seconds} 秒重新整理",
+    startAutoRefresh: "開始自動重新整理",
+    stopAutoRefresh: "停止自動重新整理",
+    missingResultRun: "此結果已不再可用",
+    exportResultArchive: "儲存結果封存",
+    importResultArchive: "匯入結果封存",
+    importedResultArchive: "已匯入的結果",
+    resultArchiveExported: "結果已匯出",
+    resultArchiveImported: "結果已匯入",
+    resultArchiveUnavailable: "沒有可匯出的已儲存結果",
+    resultArchiveImportInvalid: "無法開啟此結果封存",
+    resultArchiveExportFailed: "匯出結果失敗：{message}",
+    resultArchiveImportFailed: "匯入結果失敗：{message}",
+    scrollLeft: "向左捲動分頁",
+    scrollRight: "向右捲動分頁",
+    openTabs: "已開啟的分頁",
+    fixedTabs: "固定分頁",
+    openDataTabs: "已開啟的資料表",
+    gridfs: "GridFS",
+  },
+  executionSummary: {
+    empty: "無摘要",
+    executing: "執行中...",
+    statement: "語句",
+    type: "類型",
+    rows: "列數",
+    affected: "影響",
+    time: "時間",
+    success: "成功",
+    error: "錯誤",
+    returnedTable: "回傳 {count} 欄的結果表",
+    noTable: "未回傳結果表",
+  },
+  chart: {
+    title: "圖表",
+    type: "類型",
+    line: "折線圖",
+    bar: "柱狀圖",
+    pie: "餅圖",
+    noNumericData: "沒有可用於圖表的數值資料",
+  },
+  grid: {
+    rows: "{count} 列",
+    totalRows: "共 {count} 筆",
+    totalRowCount: "（總計 {count} 筆）",
+    totalRowCountLoading: "（統計中...）",
+    loadingMore: "載入更多資料...",
+    allLoaded: "已全部載入",
+    calculateTotalRows: "統計總筆數",
+    calculateTotalRowsInline: "（統計總筆數）",
+    calculateTotalRowsFailed: "統計失敗：{message}",
+    rowsAffected: "影響 {count} 筆",
+    querySuccess: "查詢執行成功",
+    noRows: "暫無資料",
+    noRowsDescription: "目前結果集沒有任何記錄。",
+    noSearchResults: "沒有相符結果",
+    noSearchResultsDescription: "換個關鍵字試試。",
+    noFilteredRows: "沒有符合條件的資料",
+    noFilteredRowsDescription: "調整搜尋詞或狀態篩選試試。",
+    copy: "複製",
+    mongoJsonPreview: "JSON 預覽",
+    mongoJsonPreviewEmpty: "選擇一筆 MongoDB 文件以預覽。",
+    copyJson: "複製 JSON",
+    copyDdl: "複製 DDL",
+    copyCell: "複製儲存格",
+    copyRow: "複製整筆 (JSON)",
+    copyColumnJson: "複製欄 (JSON)",
+    copyColumnNames: "複製全部欄名",
+    copyRowInsert: "複製為 INSERT 語句",
+    copyRowInsertWithoutPrimaryKeys: "複製為 INSERT 語句（不含主鍵）",
+    copyRowUpdate: "複製為 UPDATE 語句",
+    copyAll: "複製全部 (TSV)",
+    selection: "選區",
+    selectionSum: "SUM: {value}",
+    selectionCells: "{count} 個儲存格",
+    copySelectionTsv: "複製選區 (TSV)",
+    copySelectionTsvWithHeaders: "複製選區含表頭 (TSV)",
+    copySelectionCsv: "複製選區 (CSV)",
+    copySelectionJson: "複製選區 (JSON)",
+    copySelectionSql: "複製選區為 SQL IN 清單",
+    clearSelection: "清除選區",
+    export: "匯出",
+    exportCsv: "匯出 CSV",
+    exportXlsx: "匯出 XLSX",
+    exportCurrentPageCsv: "匯出目前頁 CSV",
+    exportCurrentPageXlsx: "匯出目前頁 XLSX",
+    exportCurrentPageJson: "匯出目前頁 JSON",
+    exportCurrentPageMarkdown: "匯出目前頁 Markdown",
+    exportCurrentPageSql: "匯出目前頁 SQL INSERT",
+    exportCurrentResultCsv: "匯出目前結果集全部資料 CSV",
+    exportCurrentResultXlsx: "匯出目前結果集全部資料 XLSX",
+    exportCurrentResultJson: "匯出目前結果集全部資料 JSON",
+    exportCurrentResultMarkdown: "匯出目前結果集全部資料 Markdown",
+    exportCurrentResultSql: "匯出目前結果集全部資料 SQL INSERT",
+    exportAllResultsXlsx: "匯出本次執行全部結果集為 XLSX",
+    exportJson: "匯出 JSON",
+    exportMarkdown: "匯出 Markdown",
+    exportSql: "匯出 SQL INSERT",
+    exportSelectedRowsCsv: "匯出選取資料列為 CSV",
+    exportSelectedRowsXlsx: "匯出選取資料列為 XLSX",
+    exportSelectedRowsJson: "匯出選取資料列為 JSON",
+    exportSelectedRowsMarkdown: "匯出選取資料列為 Markdown",
+    exportSelectedRowsSql: "匯出選取資料列為 SQL INSERT",
+    exported: "匯出完成",
+    exportFailed: "匯出失敗：{message}",
+    copied: "已複製",
+    copyFailed: "複製失敗：{message}",
+    previewSqlEmpty: "沒有待預覽的 SQL 變更",
+    renderMode: "渲染模式",
+    domRenderMode: "DOM",
+    canvasRenderMode: "Canvas",
+    renderModeHint: "在 Canvas 渲染和 DOM 備援表格之間切換。",
+    tableFontSize: "表格字號",
+    filter: "篩選",
+    conditionHistoryEmpty: "暫無歷史記錄",
+    conditionHistoryNoMatches: "沒有符合的歷史記錄",
+    filterBuilder: "篩選器",
+    filterBuilderTitle: "篩選器",
+    filterBuilderHint: "點選篩選條件，並與手寫 WHERE 一起生效。",
+    filterBuilderSummary: "{count} 條規則",
+    filterBuilderAddRule: "新增條件",
+    filterBuilderColumn: "欄位",
+    filterBuilderValue: "值",
+    filterBuilderNoValue: "無需輸入值",
+    filterBuilderEmpty: "新增一條條件後即可開始篩選。",
+    resetFilterBuilder: "重設條件",
+    filterBuilderEquals: "等於",
+    filterBuilderNotEquals: "不等於",
+    filterBuilderContains: "包含",
+    filterBuilderNotContains: "不包含",
+    filterBuilderGreaterThan: "大於",
+    filterBuilderLessThan: "小於",
+    filterBuilderIsNull: "為空",
+    filterBuilderIsNotNull: "不為空",
+    columnActions: "欄位操作",
+    localFilter: "本機值篩選",
+    localFilterFor: "本機值篩選「{column}」",
+    databaseValueFilter: "資料庫值篩選",
+    databaseValueFilterFor: "資料庫值篩選「{column}」",
+    columnFormatter: "欄位格式設定",
+    columnFormatterFor: "格式化「{column}」",
+    columnFormatterHint: "僅改變顯示效果，原始值保持不變。",
+    formatterType: "類型",
+    formatterDatetime: "Unix 時間戳",
+    formatterJsonPath: "JSON 路徑",
+    formatterMask: "文字遮罩",
+    formatterCustomTemplate: "自訂範本",
+    formatterTimestampUnit: "時間戳單位",
+    formatterUnitAuto: "自動",
+    formatterUnitSeconds: "秒",
+    formatterUnitMilliseconds: "毫秒",
+    formatterDatetimePattern: "日期時間格式",
+    formatterDatetimePatternPlaceholder: "選擇或輸入日期時間格式",
+    formatterDatetimePatternEmpty: "預設 ISO8601 格式",
+    formatterJsonPathInput: "JSON 路徑",
+    formatterMaskPrefix: "字首保留",
+    formatterMaskSuffix: "字尾保留",
+    formatterSavedCustom: "已儲存範本",
+    formatterNewCustom: "建立範本",
+    formatterCustomName: "範本名稱",
+    formatterCustomNamePlaceholder: "例如：使用者標籤",
+    formatterCustomTemplateInput: "範本",
+    formatterCustomTemplateHint: "可用變數：${value}、${upper}、${lower}、${length}。填寫名稱後會儲存到清單。",
+    formatterPreview: "預覽",
+    saveFormatter: "儲存",
+    clearFormatter: "清除",
+    searchValues: "搜尋值……",
+    loadingValues: "正在載入值...",
+    serverValuesLimited: "僅顯示前 {count} 個值",
+    filterTypedValue: "使用「{value}」篩選",
+    value: "值",
+    count: "數量",
+    applyFilter: "套用篩選",
+    clearLocalFilters: "清除本機值篩選",
+    clearLocalFiltersShort: "清除本機",
+    localFiltersActive: "{count} 個本機值篩選",
+    localFilterMoreValues: "，還有 {count} 個",
+    columnVisibility: "欄位篩選",
+    columnVisibilityHint: "至少保留一欄可見。",
+    searchColumns: "搜尋欄位……",
+    dragColumnToReorder: "拖曳欄位標題調整順序",
+    invertColumnVisibility: "反選",
+    resetColumnOrder: "重設順序",
+    showAllColumns: "顯示全部",
+    viewOptions: "檢視選項",
+    hideNullColumns: "隱藏 NULL 欄",
+    hideNullColumnsHint: "切換隱藏目前結果中整欄皆為 NULL 的欄位。",
+    moreValues: "還有 {count} 個值，輸入關鍵字繼續縮小範圍",
+    filterByValue: "篩選此值",
+    filterExcludeValue: "排除此值",
+    filterLike: "包含此值",
+    filterNotLike: "不包含此值",
+    filterLessThan: "小於此值",
+    filterGreaterThan: "大於此值",
+    filterIsNull: "僅顯示 NULL",
+    filterIsNotNull: "僅顯示非 NULL",
+    clearFilter: "清除篩選",
+    sort: "排序",
+    sortAscending: "遞增排序",
+    sortDescending: "遞減排序",
+    sortCurrentPageAscending: "目前頁遞增排序",
+    sortCurrentPageDescending: "目前頁遞減排序",
+    sortDatabaseAscending: "資料庫遞增排序",
+    sortDatabaseDescending: "資料庫遞減排序",
+    clearSort: "清除排序",
+    pasted: "已貼上！",
+    search: "搜尋……",
+    searchOrWhere: "搜尋，或輸入 WHERE 條件……",
+    applyWhere: "套用 WHERE",
+    filterRows: "篩選列",
+    filterAllRows: "全部列",
+    filterChangedRows: "變更列",
+    page: "第 {page} 頁",
+    rowsPerPage: "每頁筆數",
+    customRowsPerPage: "自訂筆數",
+    applyPageSize: "套用",
+    save: "儲存",
+    discard: "放棄",
+    dismiss: "關閉",
+    addRow: "新增資料",
+    quickEntryDraftPlaceholder: "新增",
+    cloneRow: "複製為新資料",
+    deleteRow: "刪除資料",
+    deleteRows: "刪除 {count} 筆",
+    cloneRows: "複製 {count} 筆為新資料",
+    restoreRows: "復原 {count} 筆",
+    copyRows: "複製 {count} 筆 (JSON)",
+    copySelectedRowsTsv: "複製 {count} 筆 (TSV)",
+    copySelectedRowsTsvWithHeaders: "複製 {count} 筆含表頭 (TSV)",
+    copySelectedRowTsv: "複製 1 筆 (TSV)",
+    copySelectedRowTsvWithHeaders: "複製 1 筆含表頭 (TSV)",
+    copyColumnsJson: "複製 {count} 欄 (JSON)",
+    copyRowsInsert: "複製 {count} 筆為 INSERT",
+    copyRowsInsertMerged: "複製 {count} 筆為 INSERT（合併）",
+    copyRowsInsertRowByRow: "複製 {count} 筆為 INSERT（逐筆）",
+    copyRowsInsertWithoutPrimaryKeys: "複製 {count} 筆為 INSERT（不含主鍵）",
+    copyRowsInsertWithoutPrimaryKeysMerged: "複製 {count} 筆為 INSERT（不含主鍵，合併）",
+    copyRowsInsertWithoutPrimaryKeysRowByRow: "複製 {count} 筆為 INSERT（不含主鍵，逐筆）",
+    copyRowsUpdate: "複製 {count} 筆為 UPDATE",
+    selectedRows: "已選 {count} 筆",
+    restoreRow: "復原資料",
+    statusClean: "未改",
+    statusNew: "新增列",
+    statusEdited: "更新列",
+    statusDeleted: "刪除列",
+    pendingChanges: "{count} 項待儲存",
+    selectedCells: "已選 {count} 個儲存格",
+    bulkEditSelection: "批次修改所選",
+    bulkEditTitle: "批次修改所選",
+    bulkEditDescription: "將已選 {count} 個儲存格設定為這個值。",
+    bulkEditValuePlaceholder: "輸入值，或 NULL",
+    applyBulkEdit: "套用",
+    cellDetails: "儲存格詳情",
+    cellDetailLayoutBottom: "移到底部",
+    cellDetailLayoutRight: "移到右側",
+    openCellDetailsDialog: "儲存格詳情",
+    rowDetails: "資料詳情",
+    rowDetailsFor: "第 {row} 筆資料詳情",
+    openRowDetailsDialog: "資料詳情",
+    openColumnDetailsDialog: "欄位詳情",
+    columnDetailsFor: "「{column}」欄位詳情",
+    columnsCount: "{count} 欄",
+    rowCount: "筆數",
+    rowsCount: "{count} 筆",
+    fieldIndex: "序號",
+    cellValue: "值",
+    valueEditor: "儲存格編輯器",
+    hexViewer: "Hex 檢視器",
+    hexViewerByteCount: "{count} 位元組",
+    hexViewerOffset: "偏移",
+    hexViewerHex: "Hex",
+    hexViewerAscii: "ASCII",
+    hexViewerEmpty: "沒有可顯示的二進位位元組。",
+    imagePreview: "圖片預覽",
+    imageLoadFailed: "圖片載入失敗",
+    geometryPreview: "圖形預覽",
+    layerPreview: "圖層預覽",
+    zoomIn: "放大",
+    zoomOut: "縮小",
+    fitImage: "適合顯示區域",
+    openImage: "開啟圖片",
+    columnName: "欄位名稱",
+    columnType: "類型",
+    columnComment: "註解",
+    rowNumber: "行號",
+    valueLength: "長度",
+    nullValue: "NULL",
+    noComment: "暫無註解",
+    formattedJson: "格式化 JSON",
+    formattedValue: "格式化值",
+    detailSearchPlaceholder: "搜尋欄位名或值…",
+    detailSearchNoMatch: "無相符項目",
+    rawValue: "原始值",
+    largeValuePreviewHint: "僅預覽前 {count} 個字元，複製仍會使用完整值。",
+    copyValue: "複製值",
+    downloadBinaryValue: "下載值",
+    downloadSaved: "已儲存到 {path}",
+    downloadStarted: "已交給瀏覽器下載：{fileName}",
+    binaryDownload: {
+      binary: "原始二進位",
+      utf8: "文字編碼 (UTF-8)",
+      gbk: "文字編碼 (GBK)",
+    },
+    copyRowTsv: "複製整筆 (TSV)",
+    copyColumnValues: "複製欄 (JSON)",
+    copyColumnTsv: "複製欄 (TSV)",
+    editValue: "編輯值",
+    formatJson: "格式化 JSON",
+    compactJson: "壓縮 JSON",
+    formattedJsonEditWarning: "正在編輯格式化後的 JSON。儲存後會以 JSON 格式寫入，原始排版可能改變。",
+    setNull: "設為 NULL",
+    restoreOriginalValue: "復原資料",
+    copyColumnName: "複製欄位名稱",
+    copyAlterColumnSql: "複製為 SQL ALTER",
+    alterSqlCopied: "SQL ALTER 已複製到剪貼簿",
+    alterSqlCopiedWithWarnings: "SQL ALTER 已複製到剪貼簿（含 {count} 條警告）",
+    noAlterSqlAvailable: "此欄沒有可複製的 ALTER SQL",
+    copyAlterSqlFailed: "複製失敗：{message}",
+    copySqlCondition: "複製 SQL 條件",
+    transpose: "轉置檢視",
+    transposeMultiRowToggle: "多列轉置",
+    transposeSingleRow: "目前列",
+    transposeMultiRow: "多列",
+    transposeMultiRowHint: "開啟後，轉置檢視會同時顯示多列；關閉時僅顯示目前列。",
+    rowsPerPageShort: " 筆/頁",
+    columnDetails: "欄位詳情",
+    tableInfo: "資料表屬性",
+    tableInfoColumns: "欄位",
+    tableInfoIndexes: "索引",
+    tableInfoForeignKeys: "外鍵",
+    tableInfoTriggers: "觸發器",
+    tableInfoNullable: "可為空",
+    tableInfoEmpty: "無",
+    tableInfoSearch: "搜尋……",
+    tableInfoNoResults: "沒有相符結果",
+    goToColumn: "跳轉欄",
+    columnWidth: "列寬",
+    columnWidthCompact: "緊湊",
+    columnWidthStandard: "標準",
+    columnWidthComfortable: "寬鬆",
+    searchColumn: "搜尋欄/註解...",
+    noColumnsFound: "未找到欄",
+    dataUnavailable: "資料表資料需要重新載入。",
+    dataUnavailableHintPrefix: "按 ",
+    dataUnavailableHintSuffix: " 或點擊下方重新整理來重新載入。",
+    queryError: "查詢出錯",
+    refresh: "重新整理",
+    undoChange: "復原變更",
+    redoChange: "重做變更",
+    commit: "提交",
+    rollback: "回溯",
+    transactionSaveHint: "在事務中提交 {count} 項待儲存更改。",
+    nonTransactionalSaveHint: "逐條儲存 {count} 項更改；如果中途失敗，前面已成功的更改不會回溯。",
+    keylessEditWarning: "無主鍵定位",
+    keylessEditWarningHint: "此資料表沒有主鍵。更新與刪除會在 WHERE 子句中使用所有原始資料列值；完全重複的資料列可能會一起受到影響。",
+    queryEditReadOnly: "唯讀結果",
+    queryEditUnsupported: {
+      "not-select": "只有 SELECT 查詢結果可以直接編輯。",
+      cte: "包含 WITH/CTE 的查詢暫不支援直接回寫。請改為簡單的單一資料表 SELECT。",
+      "set-operation": "UNION、INTERSECT 或 EXCEPT 結果無法安全映射回來源資料列。",
+      aggregation: "包含 DISTINCT、GROUP BY、HAVING 或聚合結果，無法直接編輯原始資料。",
+      "external-source": "外部檔案和資料表函式結果無法直接回寫。請先匯入資料庫資料表再編輯。",
+      "complex-source": "DBX 無法為此結果唯一確定一個安全的回寫目標資料表。",
+      "computed-columns": "計算運算式或函式結果無法回寫。請改為選取原始欄位名稱。",
+      "no-table": "未識別到可編輯的資料表。",
+      "no-primary-key": "目標資料表沒有主鍵，因此無法安全地更新或刪除資料列。",
+      "primary-key-not-returned": "結果缺少原始主鍵欄位。請用原始欄位名稱將它一併查出。",
+      "aliased-columns": "結果欄位使用別名或運算式。請使用原始欄位名稱查詢可編輯欄位。",
+      "metadata-unavailable": "DBX 無法載入資料表 metadata，因此已停用結果編輯。",
+    },
+    sortUnsupported: "目前 SQL 不支援完整排序，請改為單條 SELECT 查詢後再嘗試。",
+    truncatedHint: "結果已截斷，僅顯示前 {count} 行。可經由底部分頁繼續載入，或調整每頁行數。",
+    filterBuilderSearchColumns: "搜尋欄位...",
+    filterBuilderNoMatchingColumns: "沒有匹配的欄位",
+  },
+  exportProgress: {
+    title: "匯出資料表資料",
+    fetching: "正在從資料庫擷取資料...",
+    writing: "正在寫入檔案...",
+    done: "匯出完成！",
+    error: "匯出失敗",
+    cancelled: "匯出已取消。",
+    rowsCount: "{exported} / {total} 列",
+    rowsExported: "已匯出 {count} 列",
+    rowsShort: "列",
+    cancel: "取消",
+    close: "關閉",
+    tooltip: "背景工作",
+    failedTooltip: "{count} 個背景工作失敗 | {count} 個背景工作失敗",
+    popoverTitle: "背景工作",
+    noTasks: "無背景工作",
+    clearFinished: "清除已完成",
+    showMore: "顯示 {count} 個更多",
+    showLess: "顯示較少",
+    delete: "移除",
+    databaseExportTitle: "資料庫備份：{name}",
+    sqlFileTitle: "SQL 檔案：{name}",
+    dataTransferTitle: "資料傳輸：{name}",
+    objectsCount: "{current} / {total} 個物件",
+    tablesCount: "{current} / {total} 張資料表",
+    statementsCount: "{done} 成功，{failed} 失敗",
+  },
+  welcome: {
+    title: "資料庫工作檯",
+    subtitle: "選擇左側連線以瀏覽結構，或直接開啟查詢分頁。",
+    connections: "連線",
+    connected: "已連線",
+    databaseTypes: "資料庫類型",
+    quickConnections: "快速開始",
+    quickConnectionsHint: "點選連線以開啟查詢分頁。",
+    shortcuts: "常用操作",
+    shortcutsHint: "從這裡開始你的下一步。",
+    sqlHistory: "歷史查詢",
+    sqlHistoryEmpty: "暫無 SQL 庫記錄",
+    sqlHistoryOpenCount: "開啟 {count} 次",
+    unknownConnection: "未知連線",
+    tip: "也可以在左側展開連線，並在資料庫或資料表上按右鍵查看更多操作。",
+    tipSidebar: "點選左側資料表以檢視資料",
+    tipExecute: "執行查詢",
+    fileOpened: "已開啟 {name}",
+    mcpTitle: "AI 程式設計助理整合",
+    mcpDescription: "除了內建 AI 助理，也可以藉由 MCP 讓 Claude Code、Cursor 等程式設計助理查詢你的資料庫。",
+    mcpLearnMore: "了解更多",
+  },
+  common: {
+    language: "語言",
+    loading: "載入中……",
+    stopping: "正在停止……",
+    close: "關閉",
+    cancel: "取消",
+    save: "保存",
+    copy: "複製",
+    import: "匯入",
+    remove: "移除",
+    retry: "重試",
+    more: "更多",
+    decrease: "縮小",
+    increase: "放大",
+    showPassword: "顯示密碼",
+    hidePassword: "隱藏密碼",
+    done: "完成",
+    connection: "連線",
+    database: "資料庫",
+    table: "資料表",
+    view: "檢視",
+    materializedView: "物化檢視",
+    procedure: "預存程序",
+    function: "函數",
+    sequence: "序列",
+    package: "套件",
+    packageBody: "套件本體",
+    noResults: "無結果",
+  },
+  quickOpen: {
+    placeholder: "搜尋連線、資料庫、資料表和其他物件……",
+    emptyPlaceholder: "開始輸入進行搜尋",
+    noResults: "找不到結果",
+    results: "個結果",
+    navigate: "導航",
+    select: "選擇",
+    close: "關閉",
+  },
+  explain: {
+    title: "執行計畫",
+    standardTable: "標準表格",
+    tree: "樹狀",
+    summary: "摘要",
+    running: "正在讀取執行計畫……",
+    empty: "暫無執行計畫",
+    nodeCount: "{count} 個節點",
+    node: "節點",
+    relation: "資料表",
+    index: "索引",
+    cost: "成本",
+    rows: "筆數",
+    details: "詳情",
+    unsupported: "目前資料庫暫不支援執行計畫",
+    emptySql: "目前沒有可分析的 SQL",
+    unsafe: "第一版執行計畫僅支援 SELECT / WITH / TABLE / VALUES",
+  },
+  lineage: {
+    title: "欄位血緣",
+    open: "檢視欄位血緣",
+    loading: "正在讀取 metadata {done}/{total}",
+    empty: "沒有找到相關血緣",
+    noFiltered: "目前篩選條件下沒有結果",
+    targetField: "目前欄位",
+    searchPlaceholder: "搜尋資料表、欄位、檢視或 SQL 片段……",
+    showing: "顯示 {shown}/{total} 條結果",
+    all: "全部",
+    certain: "確定",
+    likely: "高置信",
+    possible: "可能相關",
+    queryHistory: "查詢歷史",
+    openTable: "開啟對應資料表",
+    copy: "複製名稱",
+    copied: "已複製",
+    kind: {
+      foreignKey: "外鍵",
+      viewReference: "檢視",
+      historyReference: "歷史 SQL",
+      sameName: "同名欄位",
+    },
+    description: {
+      foreignKeyIncoming: "{target} 藉由外鍵指向目前欄位，這是已確認的依賴。",
+      foreignKeyOutgoing: "目前欄位藉由外鍵引用 {target}，這是已確認的依賴。",
+      viewLikely: "檢視定義同時提到目標資料表和欄位，通常表示查詢依賴。",
+      viewPossible: "檢視定義提到同名欄位，但沒有同時命中目標資料表，需要人工確認。",
+      historyLikely: "歷史 SQL 同時提到目標資料表和欄位，可作為排查影響面的參考。",
+      historyPossible: "歷史 SQL 提到了同名欄位，可能相關但需要確認上下文。",
+      sameName: "其他資料表存在同名欄位，可能代表相同業務含義，但不是已驗證的資料庫依賴。",
+    },
+    cancel: "取消讀取",
+    refresh: "重新分析",
+  },
+  connectionGroup: {
+    createGroup: "建立群組",
+    groupNamePlaceholder: "群組名稱",
+    renameGroup: "重新命名群組",
+    deleteGroup: "刪除群組",
+    moveToGroup: "移至群組",
+    moveToNewGroup: "移至新群組",
+    ungrouped: "取消群組",
+    newGroup: "新增群組……",
+    newGroupDefault: "新群組",
+    deleteGroupConfirmTitle: "刪除群組",
+    deleteGroupConfirmMessage: "刪除群組「{name}」？其中的連線將移到頂層。",
+    selectConnection: "選擇連接",
+    deselectConnection: "取消選擇連接",
+    selectAllConnections: "全選連接",
+    deselectAllConnections: "取消全選連接",
+    exitMultiSelect: "退出多選",
+  },
+  databaseSearch: {
+    title: "搜尋資料庫",
+    open: "搜尋資料庫",
+    keyword: "關鍵字",
+    keywordPlaceholder: "輸入使用者 ID、電子郵件、訂單號等……",
+    limitPerTable: "每表最多",
+    search: "搜尋",
+    searching: "搜尋中",
+    stop: "停止",
+    hint: "掃描目前資料庫或 schema 中的一般資料表。會跳過二進位欄位，並限制每張資料表的載入量，避免一次載入過多資料。",
+    loadingTables: "正在讀取表清單……",
+    progress: "已掃描 {done}/{total} 張資料表",
+    resultCount: "{count} 筆結果",
+    limitedTables: "偵測到大型 schema；僅掃描前 {count} 張資料表",
+    results: "搜尋結果",
+    openResult: "開啟",
+    waiting: "搜尋中……",
+    noResults: "暫無搜尋結果",
+    errors: "部分資料表搜尋失敗",
+  },
+  configExport: {
+    passphraseTitle: "加密匯出",
+    passphraseImportTitle: "解密匯入",
+    passphraseExportHint: "若要在匯出檔案中包含連線密碼，請設定一組加密密碼。匯入時您將需要使用相同的加密密碼。",
+    passphraseImportHint: "此檔案已加密，請輸入加密密碼來解密並匯入。",
+    passphrase: "加密密碼",
+    passphraseConfirm: "確認加密密碼",
+    passphrasePlaceholder: "輸入加密密碼",
+    passphraseConfirmPlaceholder: "再次輸入加密密碼",
+    passphraseRequired: "請輸入加密密碼",
+    passphraseMismatch: "兩次輸入的加密密碼不一致",
+    passphraseTooShort: "加密密碼至少需要 4 個字元",
+    exportEncrypted: "匯出",
+    decryptImport: "解密並匯入",
+    wrongPassphrase: "加密密碼錯誤或檔案已損壞",
+    cryptoUnavailable: "目前瀏覽器環境不支援加密設定匯入，請使用 HTTPS、localhost 或 DBX 桌面版。",
+    exportSuccess: "連線設定匯出成功",
+    importSuccess: "已匯入 {count} 個連線",
+    importNavicatSuccess: "已匯入 {count} 個 Navicat 連線，若個別連線密碼為空請補填後測試連線",
+    importDatagripSuccess: "已匯入 {count} 個 DataGrip 連線，已自動讀取 {filled} 個密碼（來自 macOS 鑰匙圈）",
+    importDbeaverSuccess: "已匯入 {count} 個 DBeaver 連線，若個別連線密碼為空請補填後測試連線",
+    importNone: "沒有新的連線需要匯入",
+    importLayoutConfirm: "匯入檔案包含連線群組資訊，是否一併套用？",
+    importLayoutTitle: "匯入群組",
+    importLayoutApply: "套用",
+  },
+  ai: {
+    placeholder: "描述你想查什麼……",
+    settings: "AI 設定",
+    noConfig: "AI 尚未設定。請在 設定 > AI 中設定你的 AI 服務。",
+    provider: "供應商",
+    providerStatusActive: "目前",
+    providerStatusConfigured: "已設定",
+    switchProvider: "切換服務商",
+    model: "模型",
+    browseModels: "瀏覽模型",
+    refreshModels: "重新整理模型",
+    loadingModels: "載入模型中……",
+    searchModels: "搜尋模型",
+    noModels: "尚未載入模型",
+    modelListHint: "點選重新整理以從供應商載入模型。",
+    modelListUnsupported: "此供應商不支援取得模型清單。",
+    modelListEndpointRequired: "填寫 Endpoint 後再取得模型清單。",
+    modelListApiKeyRequired: "填寫 API Key 後再取得模型清單。",
+    run: "執行",
+    readingSchema: "讀取結構",
+    noConnection: "目前分頁沒有可用連線",
+    noSql: "目前沒有 SQL 可處理",
+    sqlPreview: "SQL 預覽",
+    copySql: "複製 SQL",
+    copyCode: "複製程式碼",
+    executeSql: "立即執行",
+    tempRunSql: "臨時執行",
+    copyAll: "複製全部",
+    copied: "已複製",
+    copyTestResult: "複製測試結果",
+    replace: "取代編輯器",
+    append: "追加到編輯器",
+    apply: "套用到編輯器",
+    clear: "清空對話",
+    welcome: "告訴我你想查詢什麼，我會寫出 SQL",
+    newChat: "新對話",
+    thinking: "思考中……",
+    reasoningProcess: "思考過程",
+    stopGenerating: "停止產生",
+    scrollToBottom: "回到底部",
+    tableMentionEmpty: "沒有相符的資料表或 SQL 檔案",
+    tableMentionPlaceholderHint: "輸入 {'@'} 可提及資料表或 SQL 檔案作為脈絡",
+    tableMentionTypes: {
+      table: "資料表",
+      view: "檢視",
+      systemTable: "系統資料表",
+      temporaryTable: "暫存資料表",
+    },
+    modes: {
+      ask: "Ask",
+      agent: "Agent",
+    },
+    modeHints: {
+      ask: "只產生 SQL 和說明，不自動執行",
+      agent: "使用工具查詢資料並基於真實結果回答",
+    },
+    fixWithAi: "用 AI 修復",
+    truncated: "上下文已截斷",
+    contextSummary: "{database} · {tables} 張資料表",
+    autoSqlBlocked: "AI 產生的 SQL 風險較高，已阻止自動執行，請手動檢查後再執行。",
+    proposalConfirmYes: "是，請繼續",
+    proposalConfirmNo: "不用了",
+    proposalConfirmTitle: "需要確認是否執行以下操作",
+    agentSteps: {
+      generated: "已產生 SQL",
+      noSql: "未找到 SQL",
+      safe: "通過安全檢查",
+      needsConfirm: "需要確認",
+      blocked: "已阻止",
+      autoExecute: "準備執行",
+      notRequested: "未請求執行",
+      skipped: "未執行",
+      callingTool: "正在調用工具...",
+      toolDone: "工具調用完成",
+      toolError: "工具調用出錯",
+      executeSafe: "安全檢查通過 · 已執行",
+      executeBlocked: "安全檢查攔截",
+      contextCompacted: "上下文已壓縮",
+    },
+    agentStepTitles: {
+      riskCheck: "風險檢查：{action} · {category} · {environment} · {reasons}",
+      blocked: "風險策略阻止執行，請手動檢查 SQL。",
+      requiresConfirmation: "此 SQL 需要確認後執行。",
+      askMode: "Ask 模式不會自動執行 SQL。",
+      unsupportedAction: "目前 AI 動作不會自動執行 SQL。",
+      noSql: "回覆中沒有可執行的 SQL 程式碼區塊。",
+      notRequested: "使用者沒有表達執行意圖。",
+      skipped: "此步驟未執行。",
+    },
+    proxy: "代理伺服器",
+    proxyEnable: "經由代理伺服器發送 AI 請求",
+    proxyUrl: "代理伺服器地址",
+    enableThinking: "Thinking",
+    enableThinkingOn: "已啟用",
+    enableThinkingOff: "已停用",
+    enableThinkingHint: "此選項僅對 /chat/completions API 且部分支援的模型生效。設為停用後可大幅節省 token，但產生結果品質可能會略微下降。",
+    anthropicMessagesHint: "Anthropic Messages 相容 API 通常使用 /v1/messages。",
+    contextWindow: "Context Window",
+    contextWindowAuto: "自動（從模型名稱偵測）",
+    contextWindowHint: "Token 數。留空以自動偵測。本機/自訂模型請手動設定。",
+    codexCliPath: "Codex CLI 路徑",
+    codexCliPathHint: "留空以使用 PATH 中的 codex。請另外以 codex login 登入。",
+    codexMcpRequiredTitle: "需要 DBX MCP Server",
+    codexMcpRequiredDescription: "Codex CLI 會透過 DBX MCP Server 存取資料庫結構與查詢工具。請先安裝後再於 AI 助理中使用 Codex。",
+    codexCliPathEnvError: "Codex CLI 路徑只能填寫可執行檔路徑。請在下方新增環境變數。",
+    codexCliEnv: "環境變數",
+    codexCliEnvAdd: "新增變數",
+    codexCliEnvHint: "傳遞給 Codex CLI 的選用變數，例如 HTTPS_PROXY、NO_PROXY、SSL_CERT_FILE 或 CODEX_CA_CERTIFICATE。",
+    codexCliEnvKeyPlaceholder: "HTTPS_PROXY",
+    codexCliEnvValuePlaceholder: "http://proxy:9800",
+    codexCliEnvInvalidName: "環境變數名稱無效：{name}",
+    codexCliEnvReservedName: "{name} 由 DBX 用於 MCP Server，不能在這裡設定。",
+    reasoningLevel: "推理層級",
+    reasoningLevelDefault: "預設",
+    reasoningLevelMinimal: "最小",
+    reasoningLevelLow: "低",
+    reasoningLevelMedium: "中",
+    reasoningLevelHigh: "高",
+    reasoningLevelHint: "控制 Codex CLI 的 model_reasoning_effort。預設會使用你的 Codex 設定。",
+    actions: {
+      general: "通用問答",
+      generate: "產生 SQL",
+      explain: "解釋 SQL",
+      optimize: "最佳化 SQL",
+      fix: "修復錯誤",
+      convert: "轉換",
+      sampleData: "範例資料",
+      query: "查詢資料",
+      exploreSchema: "查看資料表結構",
+      executeAndExplain: "執行並解釋",
+      generateNoExec: "產生但不執行",
+    },
+    placeholders: {
+      general: "問我任何問題...",
+      generate: "描述你想查詢什麼，例如：統計最近 7 天每個使用者的訂單數",
+      explain: "可留空，或補充你關心的點",
+      optimize: "可留空，或說明最佳化目標，例如：減少全資料表掃描",
+      fix: "貼上錯誤或說明預期結果",
+      convert: "例如：轉換成 PostgreSQL / MySQL / SQL Server",
+      sampleData: "描述要產生的範例資料或測試語句",
+      query: "描述要查詢或統計的資料，例如：本月各區域訂單總額",
+      exploreSchema: "描述想了解的資料表或結構，例如：orders 表的欄位和索引",
+      executeAndExplain: "可留空，或補充想重點解釋的部分",
+    },
+    editMessage: "編輯訊息",
+    editResend: "重新傳送",
+    editCancel: "取消",
+  },
+  contextMenu: {
+    openConnection: "開啟連線",
+    closeConnection: "關閉連線",
+    closeDatabaseConnection: "關閉資料庫連線",
+    deleteConnection: "刪除連線",
+    deleteSelectedConnections: "刪除選取的 {count} 個連線",
+    confirmDeleteTitle: "刪除連線",
+    confirmDeleteMessage: "確定要刪除「{name}」嗎？此操作無法復原。",
+    confirmDeleteSelectedMessage: "確定要刪除選取的{count}個連線嗎？",
+    editConnection: "編輯連線",
+    revealDatabaseFile: "在檔案管理員中顯示",
+    selectVisibleDatabases: "選擇顯示資料庫",
+    configureVisibleObjects: "可見物件過濾",
+    userAdmin: "使用者與權限",
+    openUserAdmin: "開啟使用者與權限",
+    damengJobAdmin: "達夢代理作業",
+    openDamengJobAdmin: "開啟達夢代理作業",
+    duplicateConnection: "複製連線",
+    duplicateSelectedConnections: "複製選取的 {count} 個連線",
+    newQuery: "建立查詢",
+    instanceInfo: "實例資訊",
+    newSql: "新增 SQL",
+    generateSql: "產生 SQL",
+    newInsert: "建立新增",
+    newUpdate: "建立更新",
+    sqlHistory: "歷史查詢",
+    noSqlHistory: "暫無關聯 SQL",
+    openObjectBrowser: "瀏覽物件",
+    viewData: "檢視資料",
+    editStructure: "編輯資料表結構",
+    editColumn: "編輯欄位",
+    editIndex: "編輯索引",
+    refreshChildren: "重新整理",
+    expandAll: "展開全部",
+    pin: "置頂",
+    unpin: "取消置頂",
+    fixTab: "固定分頁",
+    unfixTab: "取消固定分頁",
+    refreshTab: "重新整理資料",
+    renameTab: "重新命名分頁",
+    duplicateTab: "複製分頁",
+    compactTabTitle: "縮短標籤標題",
+    fullTabTitle: "完整分頁標題",
+    closeTab: "關閉分頁",
+    closeFixedTab: "關閉固定分頁",
+    closeOtherTabs: "關閉其他分頁",
+    closeOtherRegularTabs: "關閉其他普通分頁",
+    closeOtherFixedTabs: "關閉其他固定分頁",
+    closeAllTabs: "關閉全部分頁",
+    closeAllRegularTabs: "關閉全部普通分頁",
+    closeAllFixedTabs: "關閉全部固定分頁",
+    copyName: "複製名稱",
+    copyFinalProxyPort: "複製最終代理連接埠",
+    finalProxyPortCopied: "最終代理連接埠 {port} 已複製",
+    setDefaultDatabase: "設為預設資料庫",
+    clearDefaultDatabase: "取消預設資料庫",
+    exportDatabase: "匯出資料庫",
+    exportAllDatabases: "匯出全部資料庫",
+    exportDatabaseSuccess: "已匯出 {count} 張資料表，每張最多 {limit} 行",
+    exportDatabaseFailed: "匯出資料庫失敗：{message}",
+    backupSqliteDatabase: "備份 SQLite 資料庫",
+    backupSqliteDatabaseInProgress: "正在備份 SQLite 資料庫...",
+    backupSqliteDatabaseSuccess: "SQLite 資料庫已備份",
+    backupSqliteDatabaseFailed: "備份 SQLite 資料庫失敗：{message}",
+    importData: "匯入資料",
+    exportData: "匯出資料",
+    exportStructure: "匯出資料表結構",
+    exportStructurePreviewTitle: "資料表結構 - {name}",
+    exportStructurePreviewTitleMultiple: "資料表結構 - {count} 個物件",
+    exportStructureLoading: "正在讀取資料表結構...",
+    copyStructure: "複製資料表結構",
+    copyStructureAs: "複製資料表結構為",
+    copyStructureAsTsv: "TSV（貼到 Excel）",
+    copyStructureAsMarkdown: "Markdown 表格",
+    structureDocTable: "資料表",
+    structureDocColumn: "欄位名稱",
+    structureDocType: "類型",
+    structureDocPrimaryKey: "主鍵",
+    structureDocNullable: "允許空值",
+    structureDocDefault: "預設值",
+    structureDocComment: "註解",
+    structureDocYes: "是",
+    structureDocNo: "否",
+    structureDocCopied: "資料表結構已複製",
+    structureDocCopyFallbackHint: "自動複製被系統阻擋。請再次點擊複製，或選取下方內容手動複製。",
+    saveStructure: "儲存 SQL",
+    exportStructureCopied: "資料表結構已複製",
+    createTable: "建立資料表",
+    createView: "建立檢視",
+    dropTable: "刪除資料表",
+    emptyTable: "清空資料",
+    truncateTable: "截斷資料表",
+    duplicateStructure: "克隆為新資料表",
+    renameObject: "重新命名",
+    renameObjectTitle: "重新命名物件",
+    renameObjectNamePlaceholder: "新名稱",
+    renameObjectSuccess: "已將「{oldName}」重新命名為「{newName}」",
+    confirmDropTableTitle: "刪除資料表",
+    confirmDropTableMessage: "確定要刪除「{name}」嗎？這將永久刪除資料表及其所有資料。",
+    dropTableCascade: "使用 CASCADE 強制刪除",
+    dropTableCascadeHint: "同時刪除依賴此資料表的物件（例如檢視）。未勾選時使用 PostgreSQL 預設的 RESTRICT。",
+    truncateTableCascade: "使用 CASCADE 強制截斷",
+    truncateTableCascadeHint: "同時截斷透過外鍵參照此資料表的資料表。未勾選時使用 PostgreSQL 預設的 RESTRICT。",
+    confirmEmptyTableTitle: "清空資料",
+    confirmEmptyTableMessage: "確定要刪除「{name}」中的所有資料嗎？",
+    confirmTruncateTableTitle: "截斷資料表",
+    confirmTruncateTableMessage: "確定要截斷「{name}」嗎？這將刪除所有行。",
+    dropTableSuccess: "資料表「{name}」已刪除",
+    editView: "編輯檢視",
+    viewSource: "檢視原始碼",
+    viewDdl: "檢視 DDL",
+    viewDdlLoading: "正在讀取 DDL...",
+    ddlCopied: "DDL 已複製",
+    dropObject: "刪除物件",
+    dropView: "刪除檢視",
+    dropColumn: "刪除欄位",
+    dropIndex: "刪除索引",
+    dropForeignKey: "刪除外鍵",
+    dropTrigger: "刪除觸發器",
+    batchDrop: "刪除所選（{count}）",
+    batchEmpty: "清空所選（{count}）",
+    batchTruncate: "截斷所選（{count}）",
+    executeProcedure: "執行預存程序",
+    confirmExecuteProcedureTitle: "執行預存程序",
+    confirmExecuteProcedureMessage: "確認執行預存程序「{name}」？可先補充或調整參數值。",
+    loadingProcedureParameters: "正在讀取參數……",
+    procedureParametersUnavailable: "未能讀取參數資訊，仍可直接編輯下方 SQL 後執行。",
+    noProcedureParameters: "未讀取到參數，確認後將直接執行目前 SQL。",
+    inputParameters: "{count} 個輸入參數",
+    outputParameters: "{count} 個輸出參數",
+    parameterName: "名稱",
+    parameterType: "類型",
+    parameterMode: "模式",
+    parameterValue: "值",
+    parameterNull: "NULL",
+    parameterDefault: "DEFAULT",
+    parameterDefaultHint: "勾選 DEFAULT 時會省略該參數，讓資料庫使用預存程序定義中的預設值。",
+    parameterValuePlaceholder: "輸入參數值",
+    outputOnly: "僅輸出",
+    sqlPreview: "SQL 預覽",
+    resetSqlPreview: "重設 SQL",
+    openInSqlEditor: "在編輯器中開啟",
+    dropProcedure: "刪除預存程序",
+    dropFunction: "刪除函式",
+    dropAllIndexes: "刪除全部索引",
+    batchDropIndexes: "刪除索引（{count}）",
+    confirmDropViewTitle: "刪除檢視",
+    confirmDropViewMessage: "確定要刪除檢視「{name}」嗎？",
+    confirmDropObjectTitle: "刪除物件",
+    confirmDropObjectMessage: "確定要刪除「{name}」嗎？",
+    confirmDropColumnTitle: "刪除欄位",
+    confirmDropIndexTitle: "刪除索引",
+    confirmDropMongoIndexMessage: "確定要從集合「{collection}」刪除索引「{name}」嗎？",
+    confirmDropMongoAllIndexesMessage: "確定要刪除集合「{name}」中所有可刪除的索引嗎？",
+    confirmDropMongoAllIndexesDetails: "MongoDB 會保留「_id_」索引。若服務端因 shard key 規則保留了額外索引，最終結果只會列出實際刪除的索引。",
+    confirmDropForeignKeyTitle: "刪除外鍵",
+    confirmDropTriggerTitle: "刪除觸發器",
+    confirmDropTableChildObjectMessage: "確定要從「{table}」刪除「{name}」嗎？",
+    confirmDropBatchIndexesMessage: "確定要從「{table}」刪除已選擇的 {count} 個索引嗎？此操作無法復原。",
+    confirmBatchDropTitle: "刪除所選物件",
+    confirmBatchDropMessage: "確定要刪除已選擇的 {count} 個物件嗎？此操作無法復原。",
+    confirmBatchEmptyTitle: "清空所選資料表",
+    confirmBatchEmptyMessage: "確定要刪除已選擇的 {count} 張資料表中的所有資料嗎？",
+    confirmBatchTruncateTitle: "截斷所選資料表",
+    confirmBatchTruncateMessage: "確定要截斷已選擇的 {count} 張資料表嗎？這將刪除所有行。",
+    confirmDropProcedureTitle: "刪除預存程序",
+    confirmDropProcedureMessage: "確定要刪除預存程序「{name}」嗎？",
+    confirmDropFunctionTitle: "刪除函式",
+    confirmDropFunctionMessage: "確定要刪除函式「{name}」嗎？",
+    dropViewSuccess: "檢視「{name}」已刪除",
+    dropProcedureSuccess: "預存程序「{name}」已刪除",
+    dropFunctionSuccess: "函式「{name}」已刪除",
+    dropTableChildObjectSuccess: "「{name}」已刪除",
+    dropAllIndexesSuccess: "已從「{name}」刪除 {count} 個索引",
+    batchDropSuccess: "已刪除 {count} 個物件",
+    batchEmptySuccess: "已清空 {count} 張資料表",
+    batchEmptyPartialFail: "已清空 {success} 張資料表，{failed} 張失敗",
+    batchEmptySubmitted: "已提交 {count} 張資料表的清空工作",
+    batchEmptySubmittedPartial: "已提交 {success} 張資料表的清空工作，{failed} 張提交失敗",
+    batchTruncateSuccess: "已截斷 {count} 張資料表",
+    emptyTableSuccess: "已清空「{name}」的所有資料",
+    emptyTableSubmitted: "已提交「{name}」的清空工作",
+    truncateTableSuccess: "資料表「{name}」已截斷",
+    duplicateStructureSuccess: "已克隆為新資料表「{name}」",
+    tableOperationFailed: "操作失敗：{message}",
+    duplicateNameTitle: "克隆為新資料表",
+    duplicateNamePlaceholder: "新資料表名稱",
+    copyTable: "複製資料表",
+    pasteTable: "貼上資料表",
+    pasteOptionStructureAndData: "結構和資料",
+    pasteOptionStructureOnly: "僅結構",
+    pasteOptionDataOnly: "僅資料",
+    pasteTableSuccess: "已將資料表貼上為「{name}」",
+    pasteTableConfirmTitle: "貼上資料表",
+    pasteTableConfirmMessage: "從剪貼簿貼上資料表",
+    batchPasteTitle: "貼上資料表",
+    batchPasteSuccess: "成功貼上 {count} 張資料表",
+    batchPastePartialFail: "貼上成功 {success} 張資料表，{failed} 張失敗",
+    noTableToPaste: "沒有可貼上的資料表",
+    pasteTableClipboardUpdated: "資料表已複製到剪貼簿",
+    createDatabase: "建立資料庫",
+    createDuckDbFile: "建立資料庫檔案",
+    dropDatabase: "刪除資料庫",
+    confirmDropDatabaseTitle: "刪除資料庫",
+    confirmDropDatabaseMessage: "確定要刪除資料庫「{name}」嗎？這將永久刪除該資料庫及其所有資料。",
+    createDatabaseSuccess: "資料庫「{name}」已建立",
+    editDatabaseProperties: "編輯資料庫屬性",
+    editDatabasePropertiesTitle: "編輯資料庫屬性：「{name}」",
+    editDatabasePropertiesSaving: "正在儲存...",
+    editDatabasePropertiesSuccess: "資料庫「{name}」屬性已更新",
+    editDatabaseComment: "資料庫註解",
+    editDatabaseCommentPlaceholder: "輸入資料庫註解...",
+    createDuckDbFileSuccess: "DuckDB 資料庫檔案「{name}」已建立並附加",
+    createDuckDbFileDesktopOnly: "建立 DuckDB 資料庫檔案僅支援桌面端",
+    dropDatabaseSuccess: "資料庫「{name}」已刪除",
+    dropCollection: "刪除集合",
+    confirmDropCollectionTitle: "刪除集合",
+    confirmDropCollectionMessage: "確定要刪除集合「{name}」嗎？這將永久刪除該集合及其所有文件。",
+    dropCollectionSuccess: "集合「{name}」已刪除",
+    createDatabaseNamePlaceholder: "資料庫名稱",
+    createDatabaseCharset: "字元集",
+    createDatabaseCharsetPlaceholder: "例如 utf8mb4",
+    createDatabaseCharsetSearchPlaceholder: "搜尋或輸入字元集",
+    createDatabaseCharsetEmpty: "找不到字元集",
+    createDatabaseCharsetLoading: "正在載入字元集...",
+    createDatabaseCharsetCustomOption: "使用「{value}」",
+    createDatabaseCollation: "排序規則",
+    createDatabaseCollationPlaceholder: "例如 utf8mb4_unicode_ci",
+    createDatabaseCollationSearchPlaceholder: "搜尋或輸入排序規則",
+    createDatabaseCollationEmpty: "找不到排序規則",
+    createDatabaseCollationLoading: "正在載入排序規則...",
+    createDatabaseCollationCustomOption: "使用「{value}」",
+    createSchema: "建立 Schema",
+    dropSchema: "刪除 Schema",
+    confirmDropSchemaTitle: "刪除 Schema",
+    confirmDropSchemaMessage: "確定要刪除 Schema「{name}」嗎？這將永久刪除該 Schema 及其所有物件。",
+    createSchemaSuccess: "Schema「{name}」已建立",
+    dropSchemaSuccess: "Schema「{name}」已刪除",
+    createSchemaNamePlaceholder: "Schema 名稱",
+    editSchemaComment: "編輯註解",
+    editSchemaCommentTitle: "編輯註解：「{name}」",
+    schemaCommentPlaceholder: "輸入 Schema 註解...",
+    schemaCommentSaving: "正在儲存...",
+    editSchemaCommentSuccess: "Schema「{name}」註解已更新",
+    manageExtension: "管理擴展...",
+    dropExtension: "刪除擴展",
+  },
+  visibleDatabases: {
+    title: "顯示資料庫",
+    description: "選擇「{connection}」下要在側邊欄顯示的資料庫。",
+    searchPlaceholder: "搜尋資料庫……",
+    selectedCount: "已選擇 {selected}/{total}",
+    selectAll: "全選",
+    selectFiltered: "選取搜尋結果",
+    clear: "清空",
+    showAll: "顯示全部",
+    showSystemDatabases: "顯示系統庫",
+    save: "儲存",
+    emptySelection: "至少選擇一個資料庫，或使用「顯示全部」清除篩選。",
+    loadFailed: "載入資料庫失敗：{message}",
+  },
+  visibleSchemas: {
+    title: "Schema 過濾器",
+    description: "選擇「{connection}」下要在側邊欄顯示的 Schema。",
+    searchPlaceholder: "搜尋 Schema……",
+    selectedCount: "已選擇 {selected}/{total}",
+    selectAll: "全選",
+    selectFiltered: "選取搜尋結果",
+    clear: "清空",
+    showAll: "顯示全部",
+    save: "儲存",
+    emptySelection: "至少選擇一個 Schema，或使用「顯示全部」清除篩選。",
+    loadFailed: "載入 Schema 失敗：{message}",
+  },
+  tree: {
+    savedSql: "SQL 庫",
+    userAdmin: "使用者與權限",
+    damengJobAdmin: "代理作業",
+    linkedServers: "連結伺服器",
+    materializedViews: "具體化檢視",
+    defaultDatabase: "預設庫",
+    columns: "欄位",
+    indexes: "索引",
+    foreignKeys: "外鍵",
+    triggers: "觸發器",
+    tables: "資料表",
+    views: "檢視",
+    procedures: "預存程序",
+    functions: "函式",
+    sequences: "序列",
+    packages: "套件",
+    partitions: "分割區",
+    childTables: "子表",
+    loadMore: "載入更多...",
+    objectBrowser: "在物件瀏覽器中檢視 ({count})",
+    extensions: "擴展",
+  },
+  objects: {
+    all: "全部",
+    tables: "資料表",
+    views: "檢視",
+    procedures: "預存程序",
+    functions: "函式",
+    sequences: "序列",
+    packages: "套件",
+    table: "資料表",
+    partitions: "{count} 個分割區",
+    view: "檢視",
+    procedure: "預存程序",
+    function: "函式",
+    sequence: "序列",
+    package: "套件",
+    packageBody: "套件主體",
+    name: "名稱",
+    type: "類型",
+    rows: "列數",
+    size: "大小",
+    statisticsHint: "來自資料庫統計資訊的估算值，不執行 COUNT(*)。",
+    createdAt: "建立時間",
+    updatedAt: "更新時間",
+    source: "原始碼",
+    saveSource: "儲存",
+    cancelEdit: "取消",
+    sourceSaved: "原始碼已儲存",
+    sourceSaveFailed: "儲存原始碼失敗：{message}",
+    sourceReadOnly: "此原始碼為唯讀，不能編輯。",
+    schemaColumn: "Schema",
+    comment: "註解",
+    loadingSchemas: "載入 Schema……",
+    schema: "Schema",
+    search: "搜尋資料表、檢視、函式、序列或預存程序……",
+    loading: "正在載入物件……",
+    empty: "沒有找到物件",
+    selectedTables: "已選擇 {count} 張資料表",
+    exportSelected: "匯出所選",
+    dropSelected: "刪除所選",
+    truncateSelected: "截斷所選",
+    clearSelection: "清空選擇",
+    confirmBatchDropTitle: "刪除所選資料表",
+    confirmBatchDropMessage: "確定要刪除已選擇的 {count} 張資料表嗎？此操作無法復原。",
+    confirmBatchTruncateTitle: "截斷所選資料表",
+    confirmBatchTruncateMessage: "確定要截斷已選擇的 {count} 張資料表嗎？這將刪除所有行。",
+    batchDropSuccess: "已刪除 {count} 張資料表",
+    batchTruncateSuccess: "已截斷 {count} 張資料表",
+    copyTableSelected: "複製",
+    pasteTableSelected: "貼上",
+    toggleCheckbox: "切換多選模式",
+    viewList: "列表檢視",
+    viewGrid: "平鋪檢視",
+    sortAsc: "升序",
+    sortDesc: "降序",
+    sortBy: "排序方式",
+  },
+  structureEditor: {
+    mysqlDataTypeHelp: {
+      tinyint: "1 位元組整數：有號範圍 -128 至 127；無號範圍 0 至 255。",
+      smallint: "2 位元組整數：有號範圍 -32,768 至 32,767；無號範圍 0 至 65,535。",
+      mediumint: "3 位元組整數：有號範圍 -8,388,608 至 8,388,607；無號範圍 0 至 16,777,215。",
+      int: "4 位元組整數：有號範圍 -2,147,483,648 至 2,147,483,647；無號範圍 0 至 4,294,967,295。",
+      bigint: "8 位元組整數：有號範圍 -2^63 至 2^63-1；無號範圍 0 至 2^64-1。",
+      decimal: "精確定點十進位數。MySQL 最多支援 65 位精度與 30 位小數位；MariaDB 的版本限制可能不同。適用於金額及其他精確值。",
+      float: "單精度近似數值；需要精確十進位值時請使用 DECIMAL。",
+      double: "雙精度近似數值；需要精確十進位值時請使用 DECIMAL。",
+      real: "預設為 DOUBLE 的別名；REAL_AS_FLOAT SQL 模式會使其成為 FLOAT 的別名。",
+      bit: "1 至 64 位元的位元欄位；預設寬度為 1 位元。",
+      boolean: "TINYINT(1) 的別名：0 表示 false，非 0 值表示 true。",
+      serial: "BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE 的便利別名。",
+      date: "日曆日期；支援範圍為 1000-01-01 至 9999-12-31。",
+      datetime: "不進行時區轉換的日期與時間；支援範圍為 1000-01-01 00:00:00 至 9999-12-31 23:59:59，小數秒精度為 0 至 6（預設 0）。",
+      timestamp: "在工作階段時區與 UTC 間轉換的日期與時間；支援範圍為 1970-01-01 00:00:01 UTC 至 2038-01-19 03:14:07 UTC，小數秒精度為 0 至 6（預設 0）。",
+      time: "一天中的時間或已耗時間；支援範圍為 -838:59:59 至 838:59:59，小數秒精度為 0 至 6（預設 0）。",
+      year: "年份值；四位數範圍為 1901 至 2155，另包含 0000。",
+      char: "固定長度字串，最多 255 個字元；儲存值會在右側以空白補齊。",
+      varchar: "可變長度字串；實際最大長度受列大小與字元集限制。",
+      tinytext: "可變長度文字，最多 255 位元組；字元集、列大小與 max_allowed_packet 可能使實際上限更低。",
+      text: "可變長度文字，最多 65,535 位元組；字元集、列大小與 max_allowed_packet 可能使實際上限更低。",
+      mediumtext: "可變長度文字，最多 16,777,215 位元組；字元集、列大小與 max_allowed_packet 可能使實際上限更低。",
+      longtext: "可變長度文字，最多 4,294,967,295 位元組（約 4 GiB）；字元集、列大小與 max_allowed_packet 可能使實際上限更低。",
+      binary: "固定長度二進位位元組字串，最多 255 位元組；儲存值會以 0x00 補齊。",
+      varbinary: "可變長度二進位位元組字串；實際最大長度受列大小限制。",
+      tinyblob: "二進位大型物件，最多 255 位元組；列大小與 max_allowed_packet 可能使實際上限更低。",
+      blob: "二進位大型物件，最多 65,535 位元組；列大小與 max_allowed_packet 可能使實際上限更低。",
+      mediumblob: "二進位大型物件，最多 16,777,215 位元組；列大小與 max_allowed_packet 可能使實際上限更低。",
+      longblob: "二進位大型物件，最多 4,294,967,295 位元組（約 4 GiB）；列大小與 max_allowed_packet 可能使實際上限更低。",
+      enum: "從最多 65,535 個已宣告常值中選擇一個值；改變常值順序可能改變已儲存值的語意。",
+      set: "從最多 64 個已宣告成員中選擇零個或多個值。",
+      json: "經驗證的 JSON 文件；儲存表示與 JSON 功能支援取決於所連線伺服器的產品及版本；文件大小亦受 max_allowed_packet 限制。",
+      jsonMysql: "MySQL 原生的二進位 JSON 文件類型，具備 JSON 函式與驗證；文件大小受 max_allowed_packet 限制。",
+      jsonMariaDb: "MariaDB 的 JSON 是帶有 JSON_VALID 約束與 utf8mb4_bin 定序的 LONGTEXT 別名；文件大小受 max_allowed_packet 限制。",
+      nationalCharacter: "國家字元字串別名；MySQL 使用預先定義的國家字元集（已淘汰的 utf8mb3），新綱要應明確選用 utf8mb4。",
+      geometry: "任何受支援幾何類型的空間值；MySQL InnoDB SPATIAL 索引要求欄位為 NOT NULL 並具有 SRID 屬性。",
+      point: "含一組座標的空間點；MySQL InnoDB SPATIAL 索引要求欄位為 NOT NULL 並具有 SRID 屬性。",
+      linestring: "由一或多個相連點組成的空間曲線；MySQL InnoDB SPATIAL 索引要求欄位為 NOT NULL 並具有 SRID 屬性。",
+      polygon: "由一或多個環封閉的空間面；MySQL InnoDB SPATIAL 索引要求欄位為 NOT NULL 並具有 SRID 屬性。",
+      multipoint: "空間點集合；MySQL InnoDB SPATIAL 索引要求欄位為 NOT NULL 並具有 SRID 屬性。",
+      multilinestring: "空間曲線集合；MySQL InnoDB SPATIAL 索引要求欄位為 NOT NULL 並具有 SRID 屬性。",
+      multipolygon: "空間多邊形集合；MySQL InnoDB SPATIAL 索引要求欄位為 NOT NULL 並具有 SRID 屬性。",
+      geometrycollection: "可包含混合空間幾何類型的集合；MySQL InnoDB SPATIAL 索引要求欄位為 NOT NULL 並具有 SRID 屬性。",
+      inet4: "MariaDB IPv4 位址類型（MariaDB 10.10 起可用）；以四個位元組儲存 IPv4 位址。",
+      inet6: "MariaDB 相容的 IPv6 與對應 IPv4 值位址類型。",
+      uuid: "相容伺服器提供的 128 位元通用唯一識別碼類型。",
+      vector: "用於相似度或機器學習工作負載的向量資料類型；可用性與維度取決於伺服器版本。",
+      xmltype: "相容伺服器提供的 XML 資料類型。",
+      integerDisplayWidth: "MySQL 整數顯示寬度（例如 INT(11)）已淘汰，且不會限制儲存範圍；不要在新的 MySQL 8 綱要中使用。",
+      zerofill: "ZEROFILL 在 MySQL 8 已淘汰，且會隱含使欄位成為 UNSIGNED；請改在應用程式中明確格式化。",
+      unsignedNumeric: "DECIMAL、FLOAT 或 DOUBLE 的 UNSIGNED 在 MySQL 8 已淘汰；需要非負值範圍時請使用 CHECK 約束。",
+      floatPrecision: "對於 FLOAT(p)，p 為 25 至 53 時會選擇 DOUBLE 精度而非 FLOAT；若需要此行為，請明確使用 DOUBLE。",
+      floatingPointDisplay: "FLOAT(M,D) 與 DOUBLE(M,D) 在 MySQL 8 已淘汰；請使用不含顯示參數的 FLOAT/DOUBLE，或以 DECIMAL(M,D) 表示精確值。",
+    },
+    postgresDataTypeHelp: {
+      smallint: "2 位元組有號整數，範圍為 -32,768 至 32,767。",
+      integer: "4 位元組有號整數，範圍為 -2,147,483,648 至 2,147,483,647。",
+      bigint: "8 位元組有號整數，範圍為 -2^63 至 2^63-1。",
+      serial: "便利語法，會建立整數欄位、序列、NOT NULL 與 nextval 預設值；本身不保證唯一且序列值可能有缺口，新綱要建議使用 IDENTITY。",
+      numeric: "可自訂精度與小數位的精確十進位數；適合金額及不能使用二進位浮點捨入的值。",
+      real: "4 位元組單精度浮點數；FLOAT(p) 的 p 為 1 至 24 時會選擇此類型。",
+      double: "8 位元組雙精度浮點數；未指定精度的 FLOAT 是其別名，FLOAT(p) 的 p 為 25 至 53 時會選擇此類型。",
+      money: "依地區格式化的貨幣金額；輸出與解析取決於 lc_monetary，NUMERIC 通常更適合可攜的財務資料。",
+      boolean: "邏輯 true、false 或 null 值；BOOL 是 BOOLEAN 的別名。",
+      char: "以空白補齊的固定長度字串；CHARACTER 是別名，尾端空白有意義時應避免使用。",
+      varchar: "可選擇字元長度上限的可變長度字串；CHARACTER VARYING 是別名。",
+      text: "未宣告長度上限的可變長度字串；儲存行為與不設長度上限的 VARCHAR 相同。",
+      bytea: "可變長度二進位字串；大型值可由 TOAST 儲存在列外。",
+      date: "不含一天中時間或時區的日曆日期。",
+      time: "不含時區的一天中時間，可選擇小數秒精度。",
+      timetz: "一天中時間加上 UTC 位移；實用性有限且通常不建議使用，表示某個時間點應使用 timestamptz。",
+      timestamp: "不進行時區轉換的日期與時間；適合時區不屬於資料一部分的本地時鐘值。",
+      timestamptz: "內部以 UTC 儲存、依工作階段時區顯示的時間點；不保留原始具名時區。",
+      interval: "以月、日和微秒表示的持續時間；日曆單位不是固定長度的持續時間。",
+      uuid: "128 位元通用唯一識別碼。",
+      json: "保留原始輸入表示的 JSON 文字；會驗證解析，但處理速度通常慢於 JSONB。",
+      jsonb: "為處理與索引最佳化的分解式二進位 JSON 表示；不保留無意義空白、鍵順序或重複鍵。",
+      xml: "XML 值；是否驗證文件或內容取決於所使用的 XML 選項。",
+      bit: "固定或可變長度位元字串；BIT VARYING 與 VARBIT 是可變長度別名。",
+      tsvector: "PostgreSQL 全文搜尋中作為可搜尋文件端的正規化詞素；通常以 GIN 或 GiST 建立索引。",
+      tsquery: "針對 tsvector 評估的布林全文搜尋查詢。",
+      cidr: "主機位元被限制為零的 IPv4 或 IPv6 網路。",
+      inet: "可選擇網路遮罩的 IPv4 或 IPv6 主機位址；不同於 CIDR，主機位元可以非零。",
+      macaddr: "MAC 位址；MACADDR 儲存 6 位元組位址，MACADDR8 儲存 8 位元組位址。",
+      geometry: "內建二維幾何類型；PostgreSQL 的 geometry 為平面且沒有 SRID，地理座標、投影或進階空間操作請使用 PostGIS。",
+      range: "具有含括／不含括邊界的單一連續範圍；範圍值需要相容子類型，多個不連續範圍請使用 multirange 類型。",
+      oid: "無號物件識別碼；它是系統識別碼而非持久的應用程式主鍵，應用資料請使用一般整數或 UUID。",
+      array: "任何元素類型的 PostgreSQL 陣列，包含多維陣列；宣告類型不會強制陣列維度，且陣列通常不如正規化子列彈性。",
+      multirange: "相符範圍子類型的不重疊範圍集合；PostgreSQL 會依子類型規則正規化相鄰或重疊成員。",
+      jsonpath: "供 JSONB 查詢與述詞函式使用的 SQL/JSON 路徑運算式。",
+      pgLsn: "用於複寫與復原座標的預寫式日誌（WAL）位置；不是應用程式序號。",
+      pgSnapshot: "交易可見性快照；其文字表示供資料庫快照操作使用，並非一般應用程式資料。",
+    },
+    sqliteDataTypeHelp: {
+      integer: "SQLite 使用動態型別與 INTEGER 親和性；一般欄位不會強制 INTEGER 儲存類別。值在可能時會儲存為有號整數；精確拼寫的 INTEGER PRIMARY KEY 是 rowid 的特殊別名。",
+      real: "REAL 親和性儲存 IEEE 754 浮點值；適合近似量測，不適合精確金額或十進位計算。",
+      text: "TEXT 親和性會以資料庫編碼儲存文字。SQLite 中 VARCHAR(n) 與 CHAR(n) 不會強制 n；長度上限重要時請加上 CHECK 約束。",
+      blob: "BLOB 親和性會完全依原樣儲存位元組，不進行型別轉換。",
+      numeric: "NUMERIC 親和性會先嘗試將格式正確的數值文字轉為 INTEGER，再轉為 REAL；它不是獨立的 SQLite 儲存類別。DATE、DATETIME 與 TIME 宣告也具有 NUMERIC 親和性；應一致地儲存 ISO-8601 TEXT、儒略日 REAL 或 Unix 時間 INTEGER。",
+    },
+    title: "編輯資料表結構",
+    createTitle: "建立資料表",
+    editTabTitle: "編輯： {tableName}",
+    tableName: "資料表名稱",
+    refresh: "重新整理結構",
+    density: "密度",
+    densityCompact: "緊湊",
+    densityStandard: "標準",
+    densityComfortable: "寬鬆",
+    columns: "欄位",
+    indexes: "索引",
+    foreignKeys: "外鍵",
+    triggers: "觸發器",
+    ddl: "DDL",
+    addColumn: "新增欄位",
+    columnTemplates: "插入預設欄位",
+    configureColumnTemplates: "設定預設欄位",
+    presetFieldsTemplate: "預設欄位組合",
+    searchColumns: "搜尋欄位/註解",
+    nextColumnMatch: "定位下一個符合欄位",
+    searchIndexes: "搜尋索引",
+    nextIndexMatch: "定位下一個符合索引",
+    addIndex: "新增索引",
+    addForeignKey: "新增外鍵",
+    addTrigger: "新增觸發器",
+    columnName: "欄位",
+    dataType: "類型",
+    length: "長度",
+    typePlaceholder: "選擇或輸入……",
+    noMatchingType: "沒有相符類型",
+    nullable: "可為空",
+    primaryKey: "主鍵",
+    defaultValue: "預設值",
+    defaultValuePresets: "預設值預設",
+    comment: "註解",
+    editComment: "編輯註解",
+    commentPlaceholder: "輸入欄位註解……",
+    tableCommentPlaceholder: "輸入資料表註解……",
+    tableCommentUnsupported: "此資料庫不支援資料表註解",
+    actions: "操作",
+    indexName: "索引",
+    indexColumns: "欄位清單",
+    indexColumnsPlaceholder: "選擇欄位……",
+    unique: "唯一",
+    indexType: "類型",
+    includedColumns: "包含",
+    includedColumnsPlaceholder: "選擇欄位……",
+    filter: "過濾條件",
+    foreignKeyName: "外鍵名稱",
+    referencedSchema: "引用資料庫",
+    referencedTable: "引用資料表",
+    referencedColumn: "引用欄位",
+    onDelete: "刪除時",
+    onUpdate: "更新時",
+    defaultAction: "預設",
+    triggerName: "觸發器名稱",
+    triggerStatement: "觸發語句",
+    primary: "主鍵",
+    drop: "刪除",
+    restore: "復原",
+    remove: "移除",
+    moveColumnUp: "上移欄位",
+    moveColumnDown: "下移欄位",
+    dragColumn: "拖曳調整欄位順序",
+    localColumnOrderNotice: "欄位順序僅儲存在本機，不會修改資料庫資料表結構。",
+    yes: "是",
+    no: "否",
+    emptyReadonly: "暫無記錄",
+    sqlPreview: "SQL 預覽",
+    collapseSqlPreview: "收合 SQL 預覽",
+    expandSqlPreview: "展開 SQL 預覽",
+    noChanges: "暫無變更",
+    apply: "套用變更",
+    ready: "可執行",
+    saved: "資料表結構已更新",
+    copySql: "複製 SQL",
+    sqliteRebuildNotice: "SQLite 會保留一張不含作用中約束的資料快照作為備份表，再於同一交易內重建原表，並使用 CAST 強制轉換已修改型別的欄位；無法表示的值可能變成 0/0.0，執行失敗則整體回復。",
+    extendedProperties: "擴充屬性",
+    autoIncrement: "自動遞增",
+    onUpdateCurrentTimestamp: "自動更新時間",
+    identity: "識別欄位",
+    identityGeneration: "產生方式",
+    identitySeed: "起始值",
+    identityIncrement: "增量",
+    sqlServerIdentityTypeHint: "SQL Server 自動遞增僅支援 tinyint、smallint、int、bigint、decimal/numeric（小數位為 0）",
+    characterSet: "字元集",
+    charsetPlaceholder: "字元集",
+    collationPlaceholder: "排序規則",
+    collation: "排序規則",
+  },
+  diagram: {
+    title: "關係圖",
+    open: "檢視關係圖",
+    selectConnection: "選擇連線",
+    selectDatabase: "選擇資料庫",
+    selectSchema: "選擇 Schema",
+    searchTables: "搜尋資料表/欄位/外鍵……",
+    refresh: "重新整理關係圖",
+    loading: "正在讀取關係……",
+    loadingProgress: "正在讀取關係…… {loaded}/{total}",
+    partialError: "{count} 張資料表的 metadata 讀取失敗，已跳過",
+    selectTarget: "請選擇連線和資料庫",
+    empty: "沒有可顯示的資料表",
+    noMatches: "沒有相符的資料表",
+    tablesCount: "{count} 張資料表",
+    relationshipsCount: "{count} 條關係",
+    tableMode: "資料表結構圖",
+    engineeringMode: "工程 ER 圖",
+    allTables: "全部資料表",
+    relatedTables: "相關資料表",
+    moreColumns: "+ {count} 個欄位",
+    exportSvg: "匯出 SVG",
+    exportedSvg: "SVG 已匯出",
+    exportSvgFailed: "匯出 SVG 失敗：{message}",
+    zoomIn: "放大",
+    zoomOut: "縮小",
+    resetLayout: "重設布局",
+    modelRelationships: "模型關係",
+    copyJoinSql: "複製 SQL",
+    customRelationshipsCount: "{count} 個已建模",
+    relationshipName: "名稱",
+    relationshipNamePlaceholder: "可選",
+    sourceTable: "來源資料表",
+    sourceColumn: "來源欄位",
+    targetTable: "目標資料表",
+    targetColumn: "目標欄位",
+    cardinality: "基數",
+    cardinalityOneToMany: "1:N",
+    cardinalityManyToOne: "N:1",
+    cardinalityOneToOne: "1:1",
+    addRelationship: "新增關係",
+    removeRelationship: "移除關係",
+    relationshipIncomplete: "請同時選擇來源和目標欄位",
+    relationshipSelfInvalid: "關係不能指向同一欄位",
+    relationshipExists: "此關係已存在",
+    relationshipAdded: "關係已新增",
+    noJoinSql: "沒有可複製的關係 SQL",
+  },
+  redis: {
+    createKeyTypeHelp: {
+      string: "最大 512 MB 的單一值；適合快取與計數器。",
+      hash: "扁平欄位值映射；完整讀取大型 Hash 為 O(N)。",
+      list: "有序序列；中間隨機存取為線性。",
+      set: "無序唯一成員集合；列舉大型集合為線性。",
+      zset: "含浮點分數的唯一成員；寫入為 O(log N)。",
+      stream: "追加式日誌；應處理 XACK、待處理項目與裁剪。",
+      json: "可依路徑存取 JSON；需要 RedisJSON/Redis Stack，通常比 String 或 Hash 開銷高。",
+    },
+    selectKey: "選擇一個 key 檢視值",
+    noKeys: "未找到 key",
+    noKeysInScanHint: "目前掃描範圍內未找到匹配的 key",
+    pattern: "模式 (例如 user:*)",
+    fuzzyPattern: "輸入關鍵字搜尋 key",
+    fuzzyMatch: "模糊",
+    fuzzyMatchTitle: "模糊匹配：自動按包含關係搜尋 key",
+    valueSearchPlaceholder: "值包含……",
+    allSearchPlaceholder: "鍵或值包含……",
+    searchByKey: "鍵",
+    searchByValue: "值",
+    searchByAll: "全部",
+    searchFields: "搜尋欄位或值",
+    keys: "{count} 個 key",
+    loadedKeys: "已載入 {loaded} / 共 {total} 個 key",
+    loadingKeys: "正在載入 key……",
+    searchingValues: "正在按值搜尋……",
+    searchingAll: "正在搜尋鍵和值……",
+    loadMoreKeys: "載入更多",
+    fetchAllKeys: "取得全部",
+    stopFetchAll: "停止",
+    fetchAllProgress: "已載入 {loaded} / 共 {total} 條 key",
+    fetchAllProgressUnknown: "已載入 {loaded} 條 key",
+    items: "{count} 個元素",
+    fields: "{count} 個欄位",
+    members: "{count} 個成員",
+    loadedItems: "已載入 {loaded} / 共 {total} 個元素",
+    loadedFields: "已載入 {loaded} / 共 {total} 個欄位",
+    loadedMembers: "已載入 {loaded} / 共 {total} 個成員",
+    entries: "{count} 筆項目",
+    noExpiry: "永不過期",
+    autoRefresh: "自動刷新（倒計時）",
+    ttlDay: "{count}天",
+    columnType: "類型",
+    columnKey: "鍵",
+    columnValue: "值",
+    columnSize: "大小",
+    columnTTL: "TTL",
+    binaryStringReadonlyHint: "二進位字串值會以逸出文字唯讀顯示；不支援編輯原始位元組。",
+    selectedKeys: "已選擇的 key",
+    deleteGroup: "刪除群組",
+    deleteGroupDetails: "{target}\n{count} 個 key",
+    flushDb: "清空目前 DB",
+    flushDbMessage: "這會刪除目前 Redis 資料庫中的所有 key，且無法復原。確認繼續？",
+    flushDbDetails: "目標： Redis db{db}\n範圍： 目前 DB 的所有 key",
+    flushDbConfirm: "清空 DB",
+    flushDbSuccess: "Redis db{db} 已清空",
+    keyDetail: "鍵詳情",
+    commandLine: "命令列",
+    selectKeyForDetail: "選擇一個 key 檢視詳情",
+    commandWelcome: "歡迎使用 Redis 命令列控制台",
+    commandPlaceholder: "Redis 命令，如 GET user:1",
+    commandPrefix: "命令",
+    commandHint: "輸入 Redis 命令，如 SMEMBERS feature:flags",
+    executeCommand: "執行命令",
+    commandEmpty: "請輸入 Redis 命令",
+    commandEmptyResult: "執行 Redis 命令後會在這裡顯示結果",
+    commandBlocked: "出於安全考慮，此 Redis 命令已被阻止",
+    createKey: "建立 key",
+    createKeyName: "Key",
+    createKeyNamePlaceholder: "user:1",
+    createKeyType: "類型",
+    createValue: "值",
+    createMember: "成員",
+    createField: "欄位",
+    createFieldPlaceholder: "name",
+    createScore: "分數",
+    createKeyTtl: "TTL（秒）",
+    createKeyTtlPlaceholder: "留空表示永不過期",
+    createKeyAddEntry: "新增項目",
+    createKeyEntryId: "項目 ID",
+    createKeyRawMode: "原始輸入",
+    createKeyEntries: "項目",
+    createValuePlaceholder: "value",
+    createKeySubmit: "建立",
+    createKeyNameRequired: "請輸入 key 名稱",
+    createFieldRequired: "請輸入 hash 欄位",
+    createScoreInvalid: "請輸入有效分數",
+    jsonModuleNotAvailable: "該 Redis 伺服器未載入 ReJSON 模組",
+    fieldRequired: "請輸入欄位名稱",
+    valueRequired: "請輸入值",
+    memberRequired: "請輸入成員",
+    ttlInvalid: "請輸入有效的 TTL（秒數，-1 表示永不過期）",
+    member: "成員",
+    memberDetail: "成員詳情",
+    viewMember: "檢視完整內容",
+    copyMember: "複製成員",
+    copyKeyName: "複製鍵名",
+    copied: "已複製",
+    copyInsertStatement: "複製為 INSERT 語句",
+    copyInsertStatementBinary: "無法為二進位資料產生 INSERT 語句",
+    editMember: "編輯",
+    jsonView: "JSON 檢視",
+    rawContent: "原始內容",
+    wordWrap: "自動換行",
+    formatJson: "格式化",
+    compressJson: "壓縮",
+    jsonFormatError: "無效的 JSON 格式",
+    clearHistory: "清除命令歷史",
+    historyCleared: "Redis 命令歷史已清除",
+    blockedCommand: "命令 {command} 因安全原因已被攔截。點擊工具列盾牌圖示可關閉攔截。",
+    slowlog: "慢日誌",
+    slowlogCount: "計數",
+    slowlogQuery: "查詢",
+    slowlogNode: "節點",
+    slowlogSelectNode: "選擇節點",
+    slowlogNodeRequired: "請先選擇節點",
+    slowlogEmpty: "點擊查詢以擷取慢日誌條目",
+    slowlogFetchFailed: "擷取慢日誌失敗：{error}",
+    slowlogColumnId: "ID",
+    slowlogColumnTimestamp: "時間戳",
+    slowlogColumnDuration: "耗時 (μs)",
+    slowlogColumnCommand: "命令",
+    slowlogColumnClientAddr: "用戶端",
+    slowlogColumnClientName: "用戶端名稱",
+    slowlogTotal: "{count} 條條目",
+    slowlogDetailTitle: "慢日誌條目 #{id}",
+    pubsub: "發布/訂閱",
+    pubsubConnected: "已連線",
+    pubsubConnecting: "連線中...",
+    pubsubDisconnected: "未連線",
+    pubsubConnect: "連線",
+    pubsubDisconnect: "斷開",
+    pubsubChannels: "頻道",
+    pubsubChannelPlaceholder: "頻道名稱",
+    pubsubSubscribe: "訂閱",
+    pubsubPatterns: "模式匹配",
+    pubsubPatternPlaceholder: "模式 (如 news:*)",
+    pubsubPsubscribe: "模式訂閱",
+    pubsubMessages: "訊息",
+    pubsubClear: "清空",
+    pubsubEmpty: "暫無訊息，訂閱一個頻道來接收訊息。",
+    pubsubPublish: "發布訊息",
+    pubsubPublishChannel: "頻道",
+    pubsubPublishMessage: "訊息內容",
+    pubsubSend: "傳送",
+    pubsubPublishFailed: "發布失敗: {error}",
+    pubsubWsConnectFailed: "WebSocket 連線失敗: {error}",
+  },
+  mongo: {
+    documents: "{count} 個文件",
+    addField: "新增欄位",
+    deleteField: "刪除欄位",
+    field: "欄位",
+    value: "值",
+    fieldPlaceholder: "欄位名",
+    emptyCollection: "空集合",
+    selectDocument: "選擇一個文件",
+    readonlyId: "_id 唯讀",
+    invalidJsonValue: "目前儲存格不是合法 JSON 值",
+    duplicateField: "欄位名重複：{field}",
+    edit: "編輯",
+    documentView: "文件檢視",
+    tableView: "表格檢視",
+    filterPlaceholder: "過濾條件……",
+    sortPlaceholder: "排序條件……",
+  },
+  vector: {
+    collectionFallback: "集合",
+    productCollection: "{product} 集合",
+    browse: "瀏覽",
+    search: "搜尋",
+    upsert: "寫入",
+    delete: "刪除",
+    reset: "重設",
+    refresh: "重新整理",
+    run: "執行",
+    apply: "套用",
+    requestEditor: "向量請求編輯器",
+    operationSuccess: "操作已完成，集合預覽已重新整理。",
+    vectorLabel: "向量",
+  },
+  history: {
+    title: "歷史",
+    search: "搜尋歷史……",
+    empty: "暫無歷史記錄",
+    emptyFilteredRecent: "最近 200 條執行歷史中沒有相符記錄",
+    failed: "失敗",
+    success: "成功",
+    restore: "復原到編輯器",
+    copy: "複製 SQL",
+    delete: "刪除",
+    clear: "清空歷史",
+    viewDetails: "檢視詳情",
+    analyzeWithAi: "AI 分析",
+    aiAnalyzeNoConnection: "無法分析這條歷史記錄：對應連線已不存在。",
+    aiAnalysisTab: "歷史分析",
+    rollback: "回溯",
+    rollbackSql: "回溯 SQL",
+    rollbackAvailable: "可回溯",
+    rollbackUnavailable: "無回溯 SQL",
+    rollbackConfirm: "將執行這條歷史記錄產生的回溯 SQL，確認繼續嗎？",
+    rollbackSuccess: "回溯已執行",
+    rollbackFailed: "回溯失敗：{message}",
+    confirmDelete: "確認刪除這條歷史記錄嗎？",
+    confirmClear: "確認清空所有歷史記錄嗎？",
+    filters: {
+      all: "全部",
+      query: "查詢",
+      data_change: "資料變更",
+      schema_change: "結構變更",
+      failed: "失敗",
+    },
+    dateRange: {
+      title: "時間範圍",
+      label: "執行時間：",
+      start: "開始日期",
+      end: "結束日期",
+      apply: "套用",
+      clear: "清除",
+      invalid: "開始日期不能晚於結束日期",
+      unboundedStart: "開始",
+      unboundedEnd: "結束",
+    },
+    kinds: {
+      query: "查詢",
+      data_change: "資料變更",
+      schema_change: "結構變更",
+      import: "匯入",
+      transfer: "傳輸",
+      redis_command: "Redis 命令",
+    },
+    kindShort: {
+      query: "查詢",
+      data_change: "變更",
+      schema_change: "結構",
+      import: "匯入",
+      transfer: "傳輸",
+      redis_command: "Redis",
+    },
+    detail: {
+      kind: "類型",
+      operation: "操作",
+      connection: "連線",
+      database: "資料庫",
+      target: "物件",
+      time: "時間",
+      duration: "耗時",
+      affectedRows: "影響筆數",
+      rollback: "回溯",
+      status: "狀態",
+      error: "錯誤",
+    },
+  },
+  dangerDialog: {
+    title: "危險操作",
+    message: "此 SQL 語句可能不可逆地修改或刪除資料，確認要執行嗎？",
+    redisCommandMessage: "此 Redis 命令可能會修改資料，且無法自動復原，確認要繼續嗎？",
+    suppressFuturePrompts: "之後執行危險 SQL 不再提示",
+    wrapLines: "切換自動換行",
+    deleteMessage: "此刪除操作可能不可逆，確認要繼續嗎？",
+    deleteConfirm: "確認刪除",
+    deleteRowMessage: "此列將被標記為刪除，儲存後會從資料庫刪除，確認要繼續嗎？",
+    deleteRowsMessage: "這 {count} 列將被標記為刪除，儲存後會從資料庫刪除，確認要繼續嗎？",
+    deleteRowDetails: "資料表：{table}",
+    deleteRowDetailsNoTable: "目前結果集中的列",
+    redisKeyDetails: "Redis key：{key}",
+    redisHashFieldDetails: "Redis hash：{key}\n欄位：{field}",
+    redisListItemDetails: "Redis list：{key}\n索引：{index}",
+    redisSetMemberDetails: "Redis set：{key}\n成員：{member}",
+    mongoDocumentDetails: "MongoDB 集合：{collection}\n文件 _id：{id}",
+    mongoFieldDetails: "欄位：{field}",
+    mongoArrayItemDetails: "陣列項索引：{index}",
+    cancel: "取消",
+    confirm: "執行",
+  },
+  sqlParameters: {
+    title: "SQL 參數",
+    description: "為 SQL 模板佔位符填寫參數值，DBX 會在執行前替換為 SQL 字面量。",
+    name: "參數名",
+    syntax: "Syntax",
+    type: "類型",
+    value: "參數值",
+    valuePlaceholder: "輸入參數值",
+    preview: "SQL 預覽",
+    execute: "執行",
+    kind: {
+      string: "字串",
+      number: "數字",
+      boolean: "布林值",
+      null: "NULL",
+      raw: "原始 SQL",
+    },
+  },
+  transfer: {
+    title: "資料傳輸",
+    source: "來源",
+    target: "目標",
+    sourceConnection: "來源連線",
+    sourceDatabase: "來源資料庫",
+    sourceSchema: "來源 Schema",
+    targetConnection: "目標連線",
+    targetDatabase: "目標資料庫",
+    targetSchema: "目標 Schema",
+    tables: "資料表",
+    selectAll: "全選",
+    deselectAll: "取消全選",
+    createTable: "目標資料表不存在時自動建立",
+    transferMode: "傳輸模式",
+    modeAppend: "追加 (INSERT)",
+    modeOverwrite: "覆蓋 (TRUNCATE + INSERT)",
+    modeUpsert: "更新插入 (按主鍵 INSERT 或 UPDATE)",
+    batchSize: "每批筆數",
+    start: "開始傳輸",
+    cancel: "取消",
+    progress: "傳輸中……",
+    transferring: "正在傳輸 {table}……",
+    completed: "傳輸完成",
+    completedWithErrors: "完成，但有 {count} 張資料表失敗 | 完成，但有 {count} 張資料表失敗",
+    failed: "傳輸失敗",
+    cancelled: "傳輸已取消",
+    rowsTransferred: "已傳輸 {count} 列",
+    tableProgress: "{current} / {total} 張資料表",
+    noSqlConnections: "暫無可用的 SQL 連線",
+    selectTables: "選擇要傳輸的表",
+    searchTables: "搜尋資料表名稱……",
+    noTables: "沒有資料表",
+    selectSourceFirst: "請先選擇來源連線和資料庫",
+    tableError: "資料表 {table} 傳輸失敗：{error}",
+    overallProgress: "整體進度",
+    dataTransfer: "資料傳輸",
+    targetTableNameCase: "目標資料表名稱大小寫",
+    tableNameCasePreserve: "保留",
+    tableNameCaseLower: "小寫",
+    tableNameCaseUpper: "大寫",
+    runInBackground: "背景執行",
+    newTask: "新增傳輸",
+    editConfig: "編輯配置",
+    retry: "重試",
+    targetTableBusy: "另一個傳輸正在寫入目標資料表：{tables}",
+    ownershipTitle: "歸屬使用者確認",
+    ownershipMessage: "目標端缺少以下歸屬使用者或角色：{owners}。依原歸屬使用者套用可能失敗。",
+    ownershipSkipDetails: "選擇跳過後，將不執行物件歸屬變更語句，資料表資料和其他結構同步會繼續執行。",
+    ownershipTargetOwner: "選擇確認後，缺失歸屬使用者對應的物件會重歸屬至目標連線使用者：{owner}。",
+    ownershipSkip: "跳過",
+    ownershipConfirm: "確認",
+    selectConnection: "選擇連線",
+    selectDatabase: "選擇資料庫",
+    selectSchema: "選擇結構描述",
+    searchConnection: "搜尋連線...",
+    searchDatabase: "搜尋資料庫...",
+    searchSchema: "搜尋結構描述...",
+  },
+  tableImport: {
+    title: "匯入資料表資料",
+    target: "目標資料表",
+    selectFile: "選擇檔案",
+    changeFile: "更換檔案",
+    noFileSelected: "未選擇檔案",
+    sourceFile: "來源檔案",
+    sourceFormat: "來源格式",
+    stepSource: "來源",
+    stepOptions: "選項",
+    stepMapping: "映射",
+    stepReview: "確認",
+    stepExecution: "執行",
+    formatCsv: "CSV",
+    formatCsvDescription: "逗號分隔文字",
+    formatTsv: "TSV",
+    formatTsvDescription: "定位字元分隔文字",
+    formatDelimited: "分隔文字",
+    formatDelimitedDescription: "自訂文字分隔符",
+    formatJson: "JSON",
+    formatJsonDescription: "物件列或陣列列",
+    formatExcel: "Excel",
+    formatExcelDescription: "XLS、XLSX、XLSM",
+    previewRows: "預覽列數",
+    delimiter: "分隔符",
+    hasHeader: "首列為標頭",
+    trimValues: "裁剪空白",
+    emptyStringAsNull: "空字串作為 NULL",
+    jsonShape: "JSON 列結構",
+    jsonShapeAuto: "自動偵測",
+    jsonShapeObjects: "物件",
+    jsonShapeArrays: "陣列",
+    sheet: "工作表",
+    firstSheet: "第一個工作表",
+    loadPreview: "載入預覽",
+    reloadPreview: "重新載入預覽",
+    previewReady: "{rows} 列，{columns} 欄",
+    file: "檔案",
+    rows: "列數",
+    mapped: "已映射",
+    mapping: "欄位映射",
+    sourceColumn: "來源欄位",
+    targetColumn: "目標欄位",
+    targetDataType: "目標類型",
+    createColumns: "將建立的欄位",
+    skipColumn: "跳過",
+    preview: "預覽",
+    mode: "匯入模式",
+    append: "追加資料",
+    truncate: "清空後匯入",
+    progress: "進度",
+    start: "開始匯入",
+    success: "已匯入 {count} 行",
+    back: "上一步",
+    next: "下一步",
+    truncateWarning: "匯入開始前會先刪除目標資料表中的現有資料。",
+    requiredUnmapped: "以下必填目標欄位未映射：{columns}",
+    status_idle: "準備匯入",
+    status_running: "正在匯入資料",
+    status_done: "匯入完成",
+    status_error: "匯入失敗",
+    status_cancelled: "匯入已取消",
+  },
+  dataGenerate: {
+    title: "資料生成",
+    target: "目標",
+    rowCount: "生成行數",
+    columns: "欄位",
+    column: "列名",
+    type: "類型",
+    generator: "生成器",
+    columnProps: "欄位屬性",
+    databaseObjects: "資料庫物件",
+    selectTable: "請從左側選擇表",
+    saveProfile: "儲存設定檔",
+    loadProfile: "載入設定檔",
+    options: "選項",
+    generateOrder: "生成順序",
+    nextStep: "下一步",
+    insertSuccess: "已插入 {count} 行",
+    noData: "暫無資料，請先配置生成規則",
+    noResult: "暫無執行結果",
+    regenerate: "重新生成",
+    first50Rows: "僅顯示前 50 行，共 {count} 行",
+    resultTitle: "執行結果",
+    successLabel: "{count} 成功",
+    failLabel: "{count} 失敗",
+    totalLabel: "/ {count} 條",
+    copyAllSql: "複製全部 SQL",
+    prevStep: "上一步",
+    startInsert: "開始插入",
+    confirm: "確定",
+    back: "返回",
+    reset: "重置",
+    selectGenerator: "選擇生成器...",
+    selectGeneratorHint: "請選擇一個生成器",
+    preview: "預覽",
+    noValue: "(無)",
+    startDate: "開始日期",
+    endDate: "結束日期",
+    allDay: "一整天",
+    startTime: "開始時間",
+    endTime: "結束時間",
+    weekday: "星期",
+    all: "全部",
+    weekdayOnly: "工作日",
+    custom: "自訂",
+    values: "值",
+    min: "最小",
+    max: "最大",
+    increment: "遞增",
+    cycle: "超出後循環",
+    includeDefault: "包含預設值",
+    includeNull: "包含 NULL",
+    unique: "設定唯一",
+    disableLinks: "禁用欄位之間的資料連結",
+    imageMode: "模式",
+    generate: "生成",
+    fromFolder: "從資料夾",
+    imageWidth: "影像寬度",
+    imageHeight: "影像高度",
+    imageFormat: "影像格式",
+    folderPath: "資料夾路徑",
+    filterByExtension: "使用副檔名篩選",
+    errorContinue: "遇到錯誤時繼續",
+    truncateBefore: "生成資料前清空表",
+    useTransaction: "使用事務",
+    extendedInsert: "使用擴充插入語句",
+    ok: "確定",
+    noTablesSelected: "暫無已選中的表",
+    orderHint: "使用上下箭頭調整順序",
+    gen: {
+      general: "通用",
+      personal: "個人",
+      payment: "支付",
+      business: "商業",
+      location: "位置",
+      product: "產品",
+      computer: "電腦",
+      number: "數字",
+      datetime: "日期時間",
+      date: "日期",
+      time: "時間",
+      sequence: "序列",
+      enum: "列舉",
+      text: "文字",
+      image: "圖片或二進位",
+      foreign_key: "外部鍵",
+      uuid: "UUID",
+      regex: "正規表達式",
+      full_name: "姓名",
+      gender: "性別",
+      title: "稱謂",
+      marital_status: "婚姻狀況",
+      phone: "電話號碼",
+      email: "電子郵件",
+      job_title: "職位名稱",
+      social_id: "社交網路ID",
+      payment_method: "支付方式",
+      credit_card_type: "信用卡類型",
+      credit_card_number: "信用卡卡號",
+      credit_card_date: "信用卡日期",
+      company_name: "公司名稱",
+      department: "部門",
+      industry: "行業",
+      address: "地址",
+      city: "城市",
+      region: "地區",
+      product_name: "產品名稱",
+      product_category: "產品類別",
+      color: "顏色",
+      size: "尺寸",
+      weight_unit: "重量單位",
+      barcode: "條碼",
+      sku: "SKU",
+      ip_address: "IP位址",
+      mac_address: "MAC位址",
+      file_path: "檔案路徑",
+      file_name: "檔案名稱",
+      file_extension: "檔案副檔名",
+      url: "網址",
+      hostname: "主機名稱",
+      id_number: "證件號",
+    },
+    idTypes: {
+      title: "證件類型",
+      customPattern: "自訂模式",
+      customPatternPlaceholder: "如 ([A-Z]{2})-([0-9]{8})",
+      customPatternHint: "支援 [A-Z] 字母、[0-9] 數字、{n} 重複、連字號等簡單模式",
+      id_card: "身份證號",
+      passport: "護照號",
+      hk_macau_pass: "港澳通行證",
+      taiwan_pass: "台灣通行證",
+      uscc: "統一社會信用代碼",
+      bank_card: "銀行卡號",
+      drivers_license: "駕駛證號",
+      custom: "自訂",
+    },
+  },
+  tableToolbox: {
+    title: "數據工具",
+    generateData: "產生資料",
+    importData: "匯入資料",
+    exportData: "匯出資料",
+    generateDataComingSoon: "即將推出",
+  },
+  sqlFile: {
+    title: "執行 SQL 檔案",
+    file: "檔案",
+    selectSqlFile: "選擇 SQL 檔案",
+    browse: "瀏覽",
+    previewingLines: "預覽 {count} 行",
+    previewingFirstLines: "預覽前 {count} 行",
+    target: "目標",
+    connection: "連線",
+    selectConnection: "選擇連線",
+    database: "資料庫",
+    selectDatabase: "選擇資料庫",
+    databasePlaceholder: "資料庫名稱",
+    options: "選項",
+    continueOnError: "錯誤後繼續",
+    cancelling: "正在取消……",
+    cancel: "取消",
+    execute: "執行",
+    statement: "語句",
+    succeeded: "成功",
+    failed: "失敗",
+    affectedRows: "影響列數",
+    currentStatement: "目前語句",
+    status: {
+      idle: "閒置",
+      started: "已開始",
+      running: "執行中",
+      statementDone: "語句完成",
+      statementFailed: "語句失敗",
+      done: "完成",
+      error: "錯誤",
+      cancelled: "已取消",
+    },
+    runInBackground: "背景執行",
+  },
+  diff: {
+    title: "比較架構",
+    source: "來源資料庫",
+    target: "目標資料庫",
+    selectConnection: "選擇連線",
+    selectDatabase: "選擇資料庫",
+    selectSchema: "選擇 Schema",
+    ignoreComments: "忽略註解差異",
+    compare: "開始比較",
+    comparing: "正在比較結構……",
+    noDifferences: "兩個資料庫結構完全一致",
+    table: "資料表",
+    status: "狀態",
+    details: "詳情",
+    added: "新增",
+    removed: "刪除",
+    modified: "修改",
+    indexes: "索引",
+    foreignKeys: "外鍵",
+    triggers: "觸發器",
+    comments: "註解",
+    newTable: "新增資料表",
+    dropTable: "刪除資料表",
+    generatedSql: "同步 SQL",
+    copySql: "複製 SQL",
+    executeSync: "執行同步",
+    syncSuccess: "同步執行成功",
+    swap: "交換來源與目標",
+    syncProgress: "執行中： {current}/{total}",
+    syncSummary: "成功 {success} 條，失敗 {failed} 條",
+    operationLabel: {
+      modify: "要修改的物件",
+      create: "要建立的物件",
+      delete: "要刪除的物件",
+      none: "無操作",
+    },
+    objectKindLabel: {
+      table: "資料表",
+      view: "視圖",
+      function: "函數",
+      sequence: "序列",
+      rule: "規則",
+      owner: "擁有者",
+      index: "索引",
+      foreignKey: "外鍵",
+      trigger: "觸發器",
+    },
+    recentConfigs: "最近配置",
+    selectRecentConfig: "選擇最近配置",
+    configSaved: "配置已儲存",
+    configDeleted: "配置已刪除",
+    sourceObject: "來源物件",
+    targetObject: "目標物件",
+    saveConfig: "儲存配置",
+    loadConfig: "載入配置",
+    ddlCompare: "DDL 比較",
+    deployScript: "部署腳本",
+    deployScriptAll: "全部部署腳本",
+    deployScriptDesc: "所選物件的 SQL 腳本",
+    deployScriptAllDesc: "所有已選物件的 SQL 腳本",
+    executeAll: "全部執行",
+    executeSuccess: "執行成功",
+    selectObjectToCompare: "選擇物件以檢視 DDL 比較",
+    noDdlAvailable: "無可用的 DDL",
+    noDeployScript: "無部署腳本",
+    noDeployScriptAll: "所選物件無部署腳本",
+    sourceDdl: "來源 DDL",
+    targetDdl: "目標 DDL",
+    objectNotExistsInSource: "此物件在來源資料庫中不存在",
+    objectNotExistsInTarget: "此物件在目標資料庫中不存在",
+    nextStepDeploy: "下一步（檢視部署）",
+    deployReview: "部署審查",
+    backToResult: "返回結果",
+    copyScript: "複製腳本",
+    deployToServer: "部署到伺服器",
+    deployConfirmTitle: "最終確認",
+    deployConfirmMessage: "您即將對目標資料庫部署以下變更",
+    targetServer: "目標伺服器",
+    dbVersion: "資料庫版本",
+    confirmDeploy: "確認部署",
+    recompare: "重新比較",
+    maximize: "最大化",
+    noObjectsSelected: "請選擇要部署的物件",
+    deploySuccess: "部署成功",
+    deployFailed: "部署失敗",
+    deploySuccessMessage: "SQL 腳本已在目標資料庫成功執行",
+    deployFailedMessage: "執行期間發生錯誤",
+    executedStatements: "已執行的語句",
+    serverVersion: "伺服器版本",
+    info: "資訊",
+    connType: "連線類型",
+    connName: "連線名稱",
+    port: "連接埠",
+    saveConfigPrompt: "請輸入配置名稱：",
+    connection: "連線",
+    database: "資料庫",
+    schema: "Schema",
+    operation: "操作",
+    selectedCount: "已選擇 {selected} 個（共 {total} 個）",
+    options: "選項",
+    copy: "複製",
+    execute: "執行",
+    exportSql: "匯出 .sql",
+    targetDatabase: "目標資料庫",
+    targetSchema: "目標 Schema",
+    useTransaction: "在事務中執行（失敗自動回滾）",
+    exportSuccess: "匯出成功",
+    create: "建立",
+    delete: "刪除",
+    modify: "修改",
+    cancel: "取消",
+    prevStep: "上一步",
+    restore: "還原",
+    affectedRows: "影響列數",
+    host: "主機",
+    copied: "已複製到剪貼簿",
+    close: "關閉",
+    searchConnection: "搜尋連線...",
+    searchDatabase: "搜尋資料庫...",
+    searchSchema: "搜尋結構描述...",
+  },
+  schemaDiff: {
+    optionsTitle: "比較選項",
+    selectConfig: "選擇配置",
+    newConfigName: "新配置",
+    newConfig: "新建配置",
+    renameConfig: "重新命名配置",
+    duplicateConfig: "複製配置",
+    deleteConfig: "刪除配置",
+    exportConfig: "匯出配置",
+    exportAllConfigs: "匯出全部配置",
+    importConfig: "匯入配置",
+    importFromFile: "從檔案匯入",
+    importFromText: "從文字匯入",
+    importPlaceholder: "貼上 JSON 配置...",
+    importInvalidJson: "無效的 JSON 格式",
+    configName: "配置名稱",
+    tableFilter: "資料表名稱篩選",
+    tableFilterHint: "依資料表名稱比對 JavaScript 正規表示式。包含為空表示全部資料表；排除為空表示不排除。",
+    tableFilterHintShort: "依資料表名稱正規表示式縮小比較範圍",
+    tableFilterHelp: "資料表名稱篩選說明",
+    tableFilterHelpRule: "比對完整資料表名稱，不用寫 /.../。",
+    tableFilterHelpBlank: "只比較為空表示全部資料表；跳過為空表示不排除。",
+    tableFilterHelpExample: "^user_ 表示 user_ 開頭；_bak$ 表示 _bak 結尾；a|b 表示 a 或 b。",
+    tableIncludePattern: "包含資料表名稱正規表示式",
+    tableIncludePatternPlaceholder: "例如 ^user_",
+    tableExcludePattern: "排除資料表名稱正規表示式",
+    tableExcludePatternPlaceholder: "例如 _bak$",
+    tableFilterPriority: "同時符合時",
+    tableFilterPriorityExclude: "排除優先",
+    tableFilterPriorityInclude: "包含優先",
+    options: {
+      tables: "比較資料表",
+      primaryKeys: "比較主鍵",
+      foreignKeys: "比較外鍵",
+      uniqueKeys: "比較唯一鍵",
+      checks: "比較檢查約束",
+      exclusions: "比較排除約束",
+      views: "比較視圖",
+      functions: "比較函數",
+      indexes: "比較索引",
+      sequences: "比較序列",
+      triggers: "比較觸發器",
+      rules: "比較規則",
+      owners: "比較擁有者",
+      cascadeDelete: "使用級聯刪除",
+      sequenceLastValues: "比較序列最後值",
+      compareColumnOrder: "比較欄位順序",
+    },
+  },
+  dataCompare: {
+    title: "比較資料",
+    selectTable: "選擇資料表",
+    searchTable: "搜尋資料表……",
+    sourceTables: "來源資料表",
+    targetTable: "目標資料表",
+    searchTables: "搜尋資料表名稱……",
+    selectedTables: "已選擇 {selected}/{total}",
+    selectAllTables: "全選",
+    deselectAllTables: "取消全選",
+    selectSourceTables: "請先選擇來源連線和資料庫，再選擇要比較的資料表",
+    noTables: "沒有可比較的資料表",
+    autoMatchHint: "批次模式會依同名資料表自動比對目標資料表",
+    matchedTables: "已比對 {matched}/{total} 張資料表",
+    missingTargetTables: "目標端缺少同名資料表：{tables}",
+    keyColumns: "鍵欄位",
+    keyColumnsPlaceholder: "以逗號分隔主鍵或唯一欄位",
+    keyColumnsAutoHint: "留空時，單一資料表會自動偵測主鍵；批次比較則會逐表偵測。",
+    rowCounts: "來源 {source} 列，目標 {target} 列；已完成完整比較",
+    previewLimitOption: "預覽 {count}",
+    compare: "開始比較資料",
+    summary: "新增 {added} 列，刪除 {removed} 列，修改 {modified} 列",
+    batchSummary: "已比較 {tables} 張資料表：{different} 張有差異，{same} 張一致，{failed} 張失敗；新增 {added} 列，刪除 {removed} 列，修改 {modified} 列",
+    comparingTable: "正在比較 {current}/{total}：{table}",
+    keyColumnsInline: "鍵欄位：{columns}",
+    selectedInline: "已選擇 {selected}/{total}",
+    selectedSummary: "目前選擇：新增 {added} 列，刪除 {removed} 列，修改 {modified} 列",
+    selectAllKind: "全選{kind}",
+    clearKind: "清空{kind}",
+    clearSelection: "清空全部選擇",
+    showAllRows: "顯示全部 {count} 條",
+    showLessRows: "收起",
+    remainingRows: "還有 {count} 條未在預覽中展開",
+    planningSync: "正在更新同步計畫……",
+    noSelectedDifferences: "目前沒有選取任何要執行的差異",
+    planSummary: "執行計畫：新增 {inserts} 條，更新 {updates} 條，刪除 {deletes} 條，共 {statements} 條 SQL",
+    statusDifferent: "有差異",
+    statusSame: "一致",
+    statusError: "失敗",
+    noKeyColumns: "請至少選擇一個鍵欄位",
+    missingKeyColumns: "鍵欄位必須同時存在於來源與目標資料表：{columns}",
+    noCommonColumns: "來源與目標資料表沒有可比較的共同欄位",
+    targetTableMissing: "找不到目標資料表：{table}",
+    noComparableTables: "沒有可比較的資料表。請檢查目標端是否存在同名資料表。",
+    noDifferences: "資料完全一致，不需要產生同步 SQL",
+    syncSuccess: "資料同步執行成功",
+  },
+  settings: {
+    title: "設定",
+    editorTab: "編輯器",
+    sqlFormatterTab: "SQL 格式化",
+    sqlFormatterImport: "匯入設定",
+    sqlFormatterExport: "匯出設定",
+    sqlFormatterImportSuccess: "格式化設定已匯入。",
+    sqlFormatterCopyJson: "複製 JSON",
+    sqlFormatterCopyJsonSuccess: "JSON 已複製。",
+    sqlFormatterCopyJsonFailed: "複製失敗：{message}",
+    sqlFormatterJsonEditorLoadFailed: "JSON 編輯器載入失敗，已切換為基本輸入框：{message}",
+    sqlFormatterRestoreDefaults: "還原預設",
+    sqlFormatterFormMode: "表單",
+    sqlFormatterJsonMode: "JSON",
+    sqlFormatterKeywordCase: "關鍵字大小寫",
+    sqlFormatterFunctionCase: "函式名稱大小寫",
+    sqlFormatterDataTypeCase: "資料型別大小寫",
+    sqlFormatterIdentifierCase: "識別符大小寫",
+    sqlFormatterCaseUpper: "大寫",
+    sqlFormatterCaseLower: "小寫",
+    sqlFormatterCasePreserve: "保持原樣",
+    sqlFormatterIndent: "縮排",
+    sqlFormatterIndentSpaces: "空格",
+    sqlFormatterIndentTabs: "Tab",
+    sqlFormatterTabWidth: "縮排寬度",
+    sqlFormatterIndentStyle: "縮排風格",
+    sqlFormatterIndentStyleStandard: "標準",
+    sqlFormatterIndentStyleTabularLeft: "表格式靠左",
+    sqlFormatterIndentStyleTabularRight: "表格式靠右",
+    sqlFormatterLogicalOperatorNewline: "邏輯運算子換行",
+    sqlFormatterLogicalBefore: "運算子前換行",
+    sqlFormatterLogicalAfter: "運算子後換行",
+    sqlFormatterExpressionWidth: "運算式寬度",
+    sqlFormatterLinesBetweenQueries: "查詢之間空行",
+    sqlFormatterDenseOperators: "緊湊運算子",
+    sqlFormatterNewlineBeforeSemicolon: "分號獨立換行",
+    sqlFormatterAdvancedOptions: "進階選項",
+    sqlFormatterParams: "參數替換",
+    sqlFormatterParamTypes: "參數類型",
+    sqlFormatterEditorShortcuts: "快速鍵",
+    sqlFormatterShortcutAction: "功能",
+    sqlFormatterShortcutEnabled: "啟用",
+    sqlFormatterShortcutWindows: "Windows",
+    sqlFormatterShortcutLinux: "Linux",
+    sqlFormatterShortcutMacos: "macOS",
+    sqlFormatterShortcutFind: "尋找",
+    sqlFormatterShortcutReplace: "取代",
+    sqlFormatterShortcutIndentMore: "增加縮排",
+    sqlFormatterShortcutIndentLess: "減少縮排",
+    sqlFormatterShortcutDuplicateLine: "複製目前行",
+    sqlFormatterShortcutDeleteLine: "刪除目前行",
+    sqlFormatterShortcutMoveLine: "移動行",
+    sqlFormatterShortcutMoveLineUp: "目前行上移",
+    sqlFormatterShortcutMoveLineDown: "目前行下移",
+    sqlFormatterShortcutCopyLine: "複製行",
+    sqlFormatterShortcutCopyLineUp: "向上複製目前行",
+    sqlFormatterShortcutCopyLineDown: "向下複製目前行",
+    sqlFormatterShortcutUndo: "復原",
+    sqlFormatterShortcutRedo: "重做",
+    sqlFormatterShortcutSelectAll: "全選",
+    sqlFormatterShortcutFormatJson: "格式化 JSON",
+    sqlFormatterShortcutApply: "套用設定",
+    sqlFormatterConfigErrorInvalidJson: "JSON 無效。",
+    sqlFormatterConfigErrorObject: "設定必須是 JSON 物件。",
+    sqlFormatterConfigErrorVersion: "不支援的設定版本。",
+    sqlFormatterConfigErrorFormatter: "不支援的格式化器。",
+    sqlFormatterConfigErrorUnsupportedParams: "不支援 params 參數替換。SQL 格式化不會替換佔位符。",
+    sqlFormatterConfigErrorOptionsObject: "設定選項必須是 JSON 物件。",
+    sqlFormatterConfigErrorEditorObject: "編輯器設定必須是 JSON 物件。",
+    sqlFormatterConfigErrorEditorScope: "不支援的編輯器作用域。",
+    sqlFormatterConfigErrorEditorPlatforms: "編輯器平台設定無效。",
+    sqlFormatterConfigErrorEditorShortcutsArray: "編輯器快速鍵必須是陣列。",
+    sqlFormatterConfigErrorEditorShortcutValue: "編輯器快速鍵無效。",
+    sqlFormatterConfigErrorUnknownOption: "未知格式化選項：{option}。",
+    sqlFormatterConfigErrorInvalidOptionValue: "「{option}」的值無效。",
+    sqlFormatterConfigErrorUnknownEditorShortcut: "未知編輯器快速鍵：{shortcut}。",
+    sqlFormatterConfigErrorInvalidEditorShortcut: "編輯器快速鍵無效：{shortcut}。",
+    sqlFormatterConfigErrorDuplicateEditorShortcut: "編輯器快速鍵重複：{shortcut}。",
+    sqlFormatterConfigErrorInvalidConfig: "格式化設定無效。",
+    appearanceTab: "外觀",
+    navigationTab: "導覽",
+    redisTab: "Redis",
+    shortcutsTab: "快速鍵",
+    snippetsTab: "程式碼片段",
+    syncTab: "同步",
+    aiTab: "AI",
+    jdbcTab: "JDBC 驅動程式",
+    securityTab: "安全",
+    aboutTab: "關於我們",
+    dataTab: "資料",
+    tunnelsTab: "隧道維護",
+    tunnelsDescription: "可重複使用的 SSH / 代理 / HTTP 隧道設定。一次設定，之後在連線的隧道頁籤中選擇設定檔即可；此處的變更會套用到所有使用該設定檔的連線。",
+    tunnelsEmpty: "還沒有隧道設定檔。先在這裡建立，然後在連線的隧道設定中選擇使用。",
+    tunnelsAddSsh: "新增 SSH",
+    tunnelsAddProxy: "新增代理",
+    tunnelsAddHttp: "新增 HTTP 隧道",
+    tunnelsProfileName: "設定檔名稱",
+    tunnelsProfileNamePlaceholder: "例如：辦公室跳板機",
+    tunnelsDelete: "刪除",
+    tunnelsUnnamedProfile: "未命名設定檔",
+    tunnelsSave: "儲存",
+    tunnelsReset: "重設",
+    tunnelsSaved: "隧道設定檔已儲存",
+    tunnelsSaveFailed: "儲存隧道設定檔失敗：{message}",
+    tunnelsUnsavedHint: "有未儲存的變更",
+    fontFamily: "字型",
+    uiFontFamily: "介面字型",
+    uiFontAppDefault: "DBX 預設",
+    uiFontSystemDefault: "系統預設",
+    uiFontFamilyDescription: "套用於工具列、分頁、側邊欄、對話框等非編輯器介面。",
+    selectFont: "選擇字型……",
+    searchFont: "搜尋字型……",
+    loadingFonts: "正在載入字型……",
+    noFontsFound: "未找到字型",
+    useCustomFont: "使用「{font}」",
+    languageTitle: "語言 / Language",
+    fontSize: "字級",
+    toolbarTitle: "工具列",
+    toolbarHiddenHint: "部分關閉或空間不足的按鈕會自動收進「更多」下拉選單。",
+    uiScale: "介面縮放",
+    uiScaleDescription: "按比例縮放整個桌面端介面，適合高 DPI 螢幕；修改後立即生效，並在下次啟動時復原。",
+    theme: "主題",
+    selectTheme: "選擇主題……",
+    colorTheme: "配色主題",
+    selectColorTheme: "選擇配色主題……",
+    themePalettePearl: "潔白",
+    themePaletteMist: "霧灰",
+    themePaletteGraphite: "鈦灰",
+    themePaletteCobalt: "鈷藍",
+    themePaletteSage: "青綠",
+    themePaletteAmber: "暖黃",
+    themePaletteBlush: "櫻粉",
+    themePaletteVscode: "VS Code",
+    themePaletteIdea: "IDEA",
+    themePaletteXcode: "Xcode",
+    themePaletteJetbrains: "JetBrains",
+    themePaletteCursor: "Cursor",
+    themePaletteClaude: "Claude Code",
+    followAppTheme: "跟隨應用程式主題",
+    appLayout: "介面配置",
+    appLayoutSeparated: "現代分隔",
+    appLayoutSeparatedDescription: "面板分隔更清晰，分頁為塊狀樣式。",
+    appLayoutClassic: "經典緊湊",
+    appLayoutClassicDescription: "使用連續標籤欄和更緊湊的面板標題。",
+    iconTheme: "圖示與 Logo 樣式",
+    iconThemeDefault: "預設",
+    iconThemeDefaultDescription: "使用彩色 DBX 應用程式圖示。",
+    iconThemeBlack: "黑色",
+    iconThemeBlackDescription: "應用程式內使用黑色 DBX 標誌。",
+    iconThemeBlackDescriptionMac: "應用程式內使用黑色標誌；Dock 使用黑色底板，選單列跟隨系統。",
+    showTrayIcon: "顯示系統匣/選單欄圖示",
+    showTrayIconDescription: "關閉後不顯示圖示，但關閉視窗仍會像之前一樣隱藏到後台。",
+    quitOnClose: "關閉視窗時退出程式",
+    quitOnCloseDescription: "開啟後，點擊視窗關閉按鈕將徹底退出 DBX，而不是隱藏到系統匣。",
+    closeActionPromptTitle: "關閉視窗",
+    closeActionPromptDescription: "請選擇點擊關閉按鈕時的行為。之後可在「設定 → 外觀」中修改。",
+    closeActionQuit: "退出程式",
+    closeActionMinimize: "最小化到系統匣",
+    updateNotificationsEnabled: "啟用更新提醒",
+    updateNotificationsEnabledDescription: "關閉後，DBX 不會自動檢查應用程式和驅動程式更新，也不會顯示更新紅點；仍可手動檢查更新。",
+    debugLoggingEnabled: "啟用偵錯日誌",
+    debugLoggingEnabledDescription: "開啟後在本機記錄更詳細的使用者側診斷日誌，回報問題時可暫時開啟；預設關閉。",
+    duckDbWorkerProcessIsolation: "DuckDB 進程隔離模式（實驗性）",
+    duckDbWorkerProcessIsolationDescription: "將 DuckDB 查詢放到獨立 worker 進程中執行。停止長查詢時，如果 DuckDB 未及時回應取消請求，DBX 會結束 worker 進程以釋放資料庫檔案鎖。",
+    duckDbWorkerMaxProcesses: "DuckDB 最大並行 worker 數",
+    duckDbWorkerMaxProcessesDescription: "限制 DBX 同時執行的 DuckDB worker 進程數量。範圍：1-16，預設：4。",
+    duckDbWorkerProcessIsolationRestartRequired: "重啟 DBX 後生效。",
+    restartDbx: "重啟 DBX",
+    restartDbxFailed: "重啟 DBX 失敗：{error}",
+    debugLogsCopy: "複製日誌",
+    debugLogsCopied: "已複製",
+    debugLogsDownload: "下載日誌",
+    debugLogsDownloaded: "已下載",
+    debugLogsClear: "清空日誌",
+    tableStructureSection: "表結構",
+    dataGridDisplay: "資料表格顯示",
+    showColumnCommentsInHeader: "在欄位名稱下方顯示註解",
+    showColumnCommentsInHeaderDescription: "直接在資料表格欄位名稱下方顯示資料表欄位註解。",
+    showColumnTypesInHeader: "在欄位名稱下方顯示資料類型",
+    showColumnTypesInHeaderDescription: "直接在資料表格欄位名稱下方顯示每個欄位的資料類型。",
+    compactColumnHeaderActions: "收起欄位表頭工具",
+    compactColumnHeaderActionsDescription: "將格式設定和本機篩選工具移到更多選單，讓欄位名稱優先顯示。",
+    dataGridQuickEntry: "表格快速輸入",
+    dataGridQuickEntryDescription: "開啟後，編輯儲存格或填寫底部空白列並離焦會立即儲存到資料庫。適合高頻輸入，但有誤操作風險。",
+    infiniteScroll: "無限滾動載入",
+    autoCalculateTotalRows: "自動統計總筆數",
+    autoCalculateTotalRowsDescription: "每次查詢後自動執行 COUNT(*) 顯示符合的總筆數。預設關閉以確保大型查詢速度 —— 可在結果列按需手動統計。",
+    infiniteScrollDescription: "滾動到表格底部時自動載入下一頁資料，無需手動翻頁。",
+    infiniteScrollMaxRows: "無限滾動最大筆數",
+    infiniteScrollMaxRowsDescription: "無限滾動模式下最多載入的筆數（1000–50000）。",
+    tableColumnTemplateFields: "新建表預設欄位",
+    tableColumnTemplateFieldsDescription: "先選擇資料庫類型，再設定新建表時使用的預設欄位類型。",
+    tableColumnTemplateAdd: "新增欄位",
+    tableColumnTemplateColumn: "欄位",
+    tableColumnTemplateDatabase: "資料庫",
+    tableColumnTemplateType: "類型",
+    tableColumnTemplateLength: "長度",
+    tableColumnTemplateDefault: "預設值",
+    tableColumnTemplateNoPresetType: "不預設類型",
+    tableColumnTemplateRequired: "必填",
+    tableColumnTemplateComment: "描述",
+    tableColumnTemplateDragHandle: "拖曳調整順序",
+    sidebarActivation: "側邊欄開啟方式",
+    sidebarActivationSingle: "單擊開啟",
+    sidebarActivationSingleDescription: "單擊即可開啟側邊欄中的可操作項目。",
+    sidebarActivationDouble: "雙擊開啟",
+    sidebarActivationDoubleDescription: "單擊選取項目，雙擊開啟項目。",
+    sidebarObjectDisplay: "側邊欄物件配置",
+    sidebarObjectDisplayGrouped: "進階檢視",
+    sidebarObjectDisplayGroupedDescription: "針對包含更多物件類型的資料庫，依資料表、檢視、預存程序和函式分組物件。",
+    sidebarObjectDisplaySimple: "簡單檢視",
+    sidebarObjectDisplaySimpleDescription: "直接在每個資料庫或 schema 下列出資料表與檢視，減少中間層級。",
+    autoSelectActiveSidebarNode: "一律選取已開啟項目",
+    autoSelectActiveSidebarNodeDescription: "切換分頁時，在側邊欄選取相符的可見資料表、集合或 SQL 檔案。",
+    openTabsRestoreMode: "啟動時還原分頁",
+    openTabsRestoreModeDescription: "選擇 DBX 啟動時如何還原上次開啟的分頁。",
+    openTabsRestoreModeAll: "保留所有分頁",
+    openTabsRestoreModePinned: "僅保留置頂分頁",
+    openTabsRestoreModeNone: "不保留分頁",
+    openTabsRestoreModeHint: "置頂分頁會顯示在分頁列左側，適合作為常用工作入口。",
+    disconnectTabHandlingMode: "關閉連線後的分頁處理",
+    disconnectTabHandlingModeDescription: "選擇關閉連線或資料庫後，相關分頁的保留策略。",
+    disconnectTabHandlingModeCloseTabs: "關閉全部分頁",
+    disconnectTabHandlingModeCloseTabsDescription: "直接關閉對應連線或資料庫下的全部相關分頁。",
+    disconnectTabHandlingModeKeepTabsClearResults: "關閉物件分頁，保留 SQL 分頁",
+    disconnectTabHandlingModeKeepTabsClearResultsDescription: "關閉資料表資料、物件瀏覽和結構等分頁，保留 SQL 查詢分頁與 SQL 文字，同時清理執行狀態與結果工作階段。",
+    disconnectTabHandlingModeKeepTabsKeepResults: "不關閉相關分頁",
+    disconnectTabHandlingModeKeepTabsKeepResultsDescription: "保留相關分頁、SQL 文字與目前結果，不另外做清理。",
+    reuseDataTab: "重複使用資料分頁",
+    reuseDataTabDescription: "點擊側邊欄資料表名稱時，重複使用現有的資料分頁而不是建立新分頁，避免開啟過多分頁。",
+    sidebarHiddenTablePrefixes: "隱藏資料表名稱字首",
+    sidebarHiddenTablePrefixesDescription: "每行一個字首。只縮短側邊欄中的資料表、檢視和集合標籤；工具提示和實際操作仍使用完整名稱。",
+    sidebarHiddenTablePrefixesPlaceholder: "範例：\nODS_\nT8Y2_LONG_",
+    sidebarTablePageSize: "側邊欄分頁大小",
+    sidebarTablePageSizeDescription: "側邊欄樹每頁最多載入的資料表/物件數量。資料表多時可調大減少翻頁次數。",
+    sidebarTableSearchEnabled: "啟用庫下資料表搜尋框",
+    sidebarTableSearchEnabledDescription: "在已展開的資料庫、schema 或資料表分組下顯示局部資料表搜尋框，用於為不同庫分別篩選資料表。",
+    sidebarHideTableComments: "隱藏側邊欄資料表註解",
+    sidebarHideTableCommentsDescription: "隱藏側邊欄樹狀清單中名稱旁的資料表/檢視註解，以節省橫向空間。",
+    sidebarAllowHorizontalScroll: "允許側邊欄水平捲動",
+    sidebarAllowHorizontalScrollDescription: "透過啟用側邊欄的水平捲動功能，完整顯示長表格、檢視和集合的名稱",
+    snippetsDescription: "自訂編輯器中觸發的 SQL 程式碼片段範本。",
+    snippetsAdd: "新增片段",
+    snippetsLabel: "顯示名",
+    snippetsPrefix: "觸發鍵",
+    snippetsStatus: "狀態",
+    snippetsEnabled: "已啟用",
+    snippetsDisabled: "已停用",
+    snippetsToggle: "啟用或停用片段",
+    snippetsBody: "SQL 內容",
+    snippetsLabelPlaceholder: "如：select *",
+    snippetsPrefixPlaceholder: "如：sel",
+    snippetsBodyPlaceholder: "SELECT *\nFROM table\nLIMIT 100;",
+    snippetsRestoreDefaults: "還原預設",
+    snippetsAddTitle: "新增片段",
+    snippetsEditTitle: "編輯片段",
+    syncWebDavTitle: "WebDAV 同步",
+    syncWebDavDescription: "上傳包含 SQL 庫的 DBX 快照到相容 WebDAV 的儲存服務，或從該服務還原快照。",
+    syncEndpoint: "WebDAV 地址",
+    syncUsername: "使用者名稱",
+    syncPassword: "密碼",
+    syncPasswordPlaceholder: "輸入密碼",
+    syncClearSavedPassword: "清除已儲存的密碼",
+    syncRememberWebDavPassword: "記住 WebDAV 應用密碼",
+    syncSavedPassword: "（已儲存）",
+    syncRememberWebDavPasswordDescription: "密碼會加密儲存在本機，不會同步到 WebDAV，也不會取代同步密碼。",
+    syncRemotePath: "遠端快照路徑",
+    syncRemotePathDescription: "上傳時 DBX 會自動建立缺失的父目錄。",
+    syncSecretNotice: "預設只同步連線詳細資料和設定。資料庫密碼、SSH 密碼、代理伺服器密碼、連線字串和 AI API Key 會保留在本機。",
+    syncSecrets: "同步加密後的敏感資訊",
+    syncSecretsDescription: "開啟後，DBX 會先加密資料庫密碼、SSH 密碼和 AI API Key，再上傳到 WebDAV。",
+    syncSecretsPassphrase: "同步密碼",
+    syncSecretsPassphraseDescription: "此密碼只用於加密和還原敏感資料。DBX 不會儲存；每台裝置都需要再次輸入。",
+    syncTest: "測試",
+    syncUpload: "上傳",
+    syncDownload: "下載",
+    syncTestSuccess: "WebDAV 目標可存取。",
+    syncUploadSuccess: "已上傳 {bytes} 位元組到 {path}。",
+    syncAutoUpload: "自動上傳快照",
+    syncAutoUploadInterval: "每",
+    syncAutoUploadMinutes: "分鐘",
+    syncAutoUploadDescription: "僅在 DBX 開啟時執行。下載仍需手動確認，避免意外覆蓋本機已儲存的 SQL。",
+    syncAutoUploadSuccess: "已自動上傳 {bytes} 位元組到 {path}。",
+    syncDownloadSuccess: "已從 {path} 下載並套用 {bytes} 位元組。",
+    syncSecretsApplied: "已還原加密敏感資訊。",
+    syncSecretsSkipped: "偵測到加密敏感資訊，但本次未還原。",
+    syncDownloadConfirm: "要下載並套用遠端 DBX 快照嗎？本機 metadata 和已儲存的 SQL 會被取代。",
+    apply: "套用",
+    applyAndClose: "套用並關閉",
+    reset: "重設",
+    resetDefaults: "還原預設",
+    resetAllDefaults: "還原所有預設設定",
+    save: "儲存",
+    cancel: "取消",
+    executeMode: "執行模式 (Cmd+Enter)",
+    executeModeAll: "執行全部 SQL",
+    executeModeCurrent: "執行指標所在語句",
+    showExecutionTargetPicker: "顯示執行目標選擇器",
+    showExecutionTargetPickerDescription: "啟用後，無選取執行時可在目前語句與全部 SQL 之間臨時選擇。",
+    showStatementRunButtons: "顯示左側執行按鈕",
+    showStatementRunButtonsDescription: "在 SQL 編輯器左側顯示按語句執行的快捷按鈕。關閉後仍可透過快捷鍵和右鍵選單執行。",
+    showCurrentStatementFrame: "顯示目前語句外框線",
+    showCurrentStatementFrameDescription: "啟用後，在 SQL 編輯器中用外框線標出目前可執行語句；關閉後不顯示外框線。",
+    showInsertValueHints: "顯示 INSERT 值欄位提示",
+    showInsertValueHintsDescription: "啟用後，在 INSERT ... VALUES 子句的每個值旁顯示對應欄位名稱提示。",
+    previewStatementRunButton: "預覽語句執行按鈕",
+    wordWrap: "自動換行",
+    wordWrapDescription: "長 SQL 在編輯器寬度內自動折行顯示",
+    vimMode: "Vim 模式",
+    vimModeDescription: "在 SQL 編輯器中使用 Vim 風格的模態編輯",
+    autoCloseBrackets: "自動成對補全",
+    autoCloseBracketsDescription: "輸入左括號或左引號時自動補全對應的右括號或右引號",
+    sqlSemanticDiagnosticsEnabled: "SQL 語意診斷",
+    sqlSemanticDiagnosticsEnabledDescription: "開啟後，編輯器會提示未知資料表、欄位等語意問題；關閉可減少 SQL 解析和中繼資料檢查的效能負擔。",
+    confirmDangerousSqlExecution: "執行危險 SQL 前彈出確認",
+    confirmDangerousSqlExecutionDescription: "關閉後，ALTER、DROP、DELETE、TRUNCATE 等危險 SQL 會直接執行。",
+    confirmUnsavedSqlClose: "關閉未儲存 SQL 前彈出確認",
+    confirmUnsavedSqlCloseDescription: "關閉後，有未儲存內容的 SQL 分頁會直接關閉或結束，不再彈出儲存確認。",
+    sqlVariableSyntax: "SQL 變數與佔位符替換",
+    sqlVariableSyntaxDescription: "依資料庫類型選擇執行 SQL 前替換哪些變數與佔位符語法，預設全部開啟。",
+    sqlVariableSyntax_positional: "位置佔位符",
+    sqlVariableSyntax_positionalDescription: "依序為每個位置佔位符提示輸入替換值。",
+    sqlVariableSyntax_named: "具名佔位符",
+    sqlVariableSyntax_namedDescription: "為具名佔位符提示輸入替換值。",
+    sqlVariableSyntax_shell: "Shell 風格佔位符",
+    sqlVariableSyntax_shellDescription: "為 Shell 風格佔位符提示輸入替換值。",
+    sqlVariableSyntax_mybatis: "MyBatis 風格佔位符",
+    sqlVariableSyntax_mybatisDescription: "為 MyBatis 風格佔位符提示輸入替換值。",
+    sqlVariableSyntax_sqlserver: "SQL Server 風格佔位符",
+    sqlVariableSyntax_sqlserverDescription: "為 SQL Server 風格佔位符提示輸入替換值（可能與工作階段變數衝突）。",
+    sqlVariableSyntax_atSet: "內聯變數展開",
+    sqlVariableSyntax_atSetDescription: "執行前展開內聯變數宣告並就地代入其值。",
+    autoAliasTables: "自動加入資料表別名",
+    autoAliasTablesDescription: "在 FROM 或 JOIN 中選擇資料表補全時，自動插入類似 order_items AS oi 的資料表別名。",
+    redisScanPageSize: "Redis 掃描數量",
+    redisScanPageSizeDescription: "瀏覽 Redis Key 時每次 SCAN 請求的 Key 數量。",
+    redisScanPageSizeOption: "{count} 個 Key",
+    shortcutExecuteSql: "執行 SQL",
+    shortcutFind: "尋找",
+    shortcutReplace: "取代",
+    shortcutSaveSql: "儲存 SQL",
+    shortcutAcceptCompletion: "接受補全",
+    shortcutFormatSql: "格式化 SQL",
+    shortcutToggleLineComment: "切換行註解",
+    shortcutIndentMore: "增加縮排",
+    shortcutIndentLess: "減少縮排",
+    shortcutDuplicateLine: "複製目前行",
+    shortcutDeleteLine: "刪除目前行",
+    shortcutMoveLineUp: "上移目前行",
+    shortcutMoveLineDown: "下移目前行",
+    shortcutCopyLineUp: "向上複製目前行",
+    shortcutCopyLineDown: "向下複製目前行",
+    shortcutUndo: "復原",
+    shortcutRedo: "重做",
+    shortcutSelectAll: "全選",
+    shortcutCopyCurrentRow: "複製目前資料列",
+    shortcutDeleteCurrentRow: "刪除目前資料列",
+    shortcutNewQuery: "建立查詢",
+    shortcutOpenSettings: "開啟設定",
+    shortcutCloseTab: "關閉分頁",
+    shortcutToggleSidebar: "切換側邊欄",
+    shortcutFocusSearch: "聚焦搜尋",
+    shortcutQuickOpen: "快速開啟 (搜尋所有資料庫物件)",
+    shortcutSwitchToPreviousTab: "切換到左側分頁",
+    shortcutSwitchToNextTab: "切換到右側分頁",
+    shortcutSwitchToTab1: "切換到第 1 個分頁",
+    shortcutSwitchToTab2: "切換到第 2 個分頁",
+    shortcutSwitchToTab3: "切換到第 3 個分頁",
+    shortcutSwitchToTab4: "切換到第 4 個分頁",
+    shortcutSwitchToTab5: "切換到第 5 個分頁",
+    shortcutSwitchToTab6: "切換到第 6 個分頁",
+    shortcutSwitchToTab7: "切換到第 7 個分頁",
+    shortcutSwitchToTab8: "切換到第 8 個分頁",
+    shortcutSwitchToTab9: "切換到第 9 個分頁",
+    shortcutZoomInUi: "放大全域介面",
+    shortcutZoomOutUi: "縮小全域介面",
+    shortcutResetUiZoom: "重設全域介面縮放",
+    shortcutRefreshData: "重新整理資料",
+    shortcutToggleTranspose: "切換轉置檢視",
+    shortcutCancelSearch: "取消搜尋",
+    shortcutCopySidebarSelection: "複製側邊欄選取項",
+    shortcutPasteSidebarSelection: "貼到側邊欄",
+    shortcutEditSidebarConnection: "編輯側邊欄連線",
+    shortcutSendSelectionToAi: "傳送選取程式碼至 AI",
+    shortcutScopeGlobal: "全域",
+    shortcutScopeEditor: "SQL 編輯器",
+    shortcutScopeGrid: "資料表格",
+    shortcutScopeSearch: "搜尋框",
+    shortcutScopeSidebar: "側邊欄",
+    shortcutPressShortcut: "按下快速鍵",
+    shortcutSearchPlaceholder: "搜尋快速鍵",
+    shortcutSearchNoResults: "沒有符合的快速鍵。",
+    shortcutConflict: "這個快速鍵與同一作用域內的其他操作衝突。",
+    shortcutClear: "清除快速鍵",
+    preview: "即時預覽",
+    customTheme: "自定義主題",
+    customThemeConfigure: "自定義主題配置",
+    customThemeTitle: "自定義主題配置",
+    customThemeMyThemes: "我的主題",
+    customThemeNewTheme: "新建主題",
+    customThemeVisualEdit: "可視化編輯",
+    customThemeJsonConfig: "JSON 配置",
+    customThemeLivePreview: "即時預覽",
+    customThemePreviewExample: "查詢示例",
+    customThemePreset: "預設配色",
+    customThemeSelectPreset: "選擇預設配色方案",
+    customThemeApply: "應用",
+    customThemePasteImport: "貼上導入",
+    customThemeExportJson: "導出 JSON",
+    customThemeSaveAndApply: "儲存並應用",
+    customThemeKeyword: "關鍵字",
+    customThemeField: "字段/變量",
+    customThemeFunction: "函數",
+    customThemeString: "字符串",
+    customThemeNumber: "數字",
+    customThemeComment: "註釋",
+    customThemeTable: "表名",
+    customThemeOperator: "運算符",
+    customThemeType: "類型",
+    customThemeBuiltin: "內置變量",
+    customThemeBackground: "背景色",
+    customThemeForeground: "前景色",
+    customThemeDefaultName: "自定義主題",
+    customThemeCopySuffix: " 副本",
+    customThemeApplied: "已應用「{name}」配色方案",
+    customThemeKeepOne: "至少保留一個主題",
+    customThemeJsonError: "JSON 格式錯誤，請檢查",
+    jdbcPlugin: "DBX JDBC 外掛程式",
+    jdbcPluginInstall: "安裝 JDBC 外掛程式",
+    jdbcPluginInstallSuccess: "JDBC 外掛程式已安裝",
+    jdbcPluginUpdate: "更新",
+    jdbcPluginUninstall: "解除安裝",
+    jdbcPluginUninstallSuccess: "JDBC 外掛程式已解除安裝",
+    jdbcPluginInstalled: "已安裝：v{version}",
+    jdbcPluginIncompatible: "協定不相容",
+    jdbcPluginNotInstalled: "未安裝",
+    jdbcDrivers: "JDBC 驅動程式 JAR",
+    jdbcImport: "匯入 JAR",
+    jdbcImportPath: "匯入路徑",
+    jdbcDriverPathPlaceholder: "/path/to/driver.jar",
+    jdbcImportSuccess: "已匯入 {count} 個驅動程式檔",
+    jdbcDeleteSuccess: "驅動程式已刪除",
+    jdbcNoDrivers: "還沒有匯入 JDBC 驅動程式。",
+    supportInfoTitle: "支援資訊",
+    supportInfoDescription: "提交 issue 或尋求協助時，可複製這些環境資訊。",
+    supportInfoCopy: "複製支援資訊",
+    supportInfoCopied: "已複製",
+    supportInfoLoading: "正在載入支援資訊...",
+    supportInfoLoadFailed: "完整支援資訊載入失敗：{message}",
+    supportInfoAppVersion: "DBX 版本",
+    supportInfoRuntime: "執行環境",
+    supportInfoRuntimeDesktop: "桌面端",
+    supportInfoRuntimeWeb: "Web 端",
+    supportInfoOperatingSystem: "作業系統",
+    supportInfoArchitecture: "系統架構",
+    supportInfoUnknown: "未知",
+    community: "社群",
+    qqGroup: "QQ 群",
+    wechatGroup: "微信交流群",
+    wechatGroupInvite: "騰訊文件邀請",
+    project: "專案",
+    openSource: "開源倉庫",
+    officialDocs: "官方文件",
+    mcpTab: "MCP",
+    mcpTitle: "MCP Server",
+    mcpDescription: "檢查 Claude Code、Cursor 等程式助理使用的 DBX MCP Server 安裝與版本狀態。",
+    mcpChecking: "檢查中",
+    mcpStatusUnknown: "未檢查",
+    mcpStatusError: "檢查失敗",
+    mcpReady: "可用",
+    mcpNotInstalled: "未安裝",
+    mcpUpdateAvailable: "有更新",
+    mcpCurrent: "當前版本",
+    mcpLatest: "最新版本",
+    mcpVersionMissing: "未檢測到全局安裝",
+    mcpVersionUnknown: "未知",
+    mcpAvailable: "可用",
+    mcpUnavailable: "不可用",
+    mcpBinPath: "命令路徑",
+    mcpInstallCommand: "安裝命令",
+    mcpUpdateCommand: "升級命令",
+    mcpInstallButton: "安裝",
+    mcpUpdateButton: "升級",
+    mcpUpToDate: "已是最新",
+    mcpInstalling: "安裝中...",
+    mcpInstallSuccess: "安裝成功",
+    mcpInstallFailed: "安裝失敗",
+    mcpConfig: "MCP 設定",
+    mcpConfigOptionsHint: "以下選項只會更新下方產生的設定文字。複製到 AI 用戶端設定後，請重新啟動對應的 MCP 工作階段。",
+    mcpCodexConfig: "Codex 設定",
+    mcpCodexConfigPath: "Codex 可放在 ~/.codex/config.toml 或專案級 .codex/config.toml。",
+    mcpCursorConfigPath: "Cursor 可放在專案級 .cursor/mcp.json 或全域 ~/.cursor/mcp.json。",
+    mcpTraeConfigPath: "TRAE：設定 > MCP > 新增 > 手動新增，然後貼上 JSON 設定。",
+    mcpVsCodeConfigPath: "VS Code/Copilot 可放在工作區 .vscode/mcp.json 或使用者設定檔 mcp.json。",
+    mcpWindsurfConfigPath: "Windsurf 可放在 ~/.codeium/windsurf/mcp_config.json。",
+    mcpOpenCodeConfigPath: "全域 ~/.config/opencode/opencode.json，專案級 opencode.json。",
+    mcpReadonlyMode: "唯讀模式",
+    mcpReadonlyModeDescription: "開啟後會為示例配置附加 DBX_MCP_ALLOW_WRITES=0，MCP 會話只允許查詢。",
+    mcpAllowDangerous: "允許危險 SQL",
+    mcpAllowDangerousDescription: "開啟後會為示例配置附加 DBX_MCP_ALLOW_DANGEROUS_SQL=1，允許 DROP、TRUNCATE、ALTER 等語句。",
+    mcpDetectionTiming: "打開此頁時會自動檢測，點擊重新檢查可刷新。",
+    mcpNpmBoundary: "DBX 只檢測和提示 MCP 狀態；安裝與升級仍由 npm 完成。",
+    mcpRefresh: "重新檢查",
+    mcpGuide: "MCP 指南",
+    updateDownloadSource: "更新下載來源",
+    updateDownloadSourceDescription: "選擇應用程式內更新安裝程式的下載來源。建議使用官方來源；CNB 或 AtomGit 在中國大陸網路環境下可能更快。",
+    updateDownloadSourceOfficial: "官方來源（建議）",
+    updateDownloadSourceCnb: "CNB",
+    updateDownloadSourceAtomgit: "AtomGit",
+    exportSection: "匯出",
+    exportBatchSize: "匯出批次大小",
+    exportBatchSizeDescription: "匯出資料時每批次擷取的列數（100-100000）。",
+    exportRowLimitEnabled: "限制匯出行數",
+    exportRowLimitEnabledDescription: "開啟後，查詢結果和資料表資料匯出將在下方設定的行數上限處停止。",
+    exportRowLimit: "資料匯出行數上限",
+    exportRowLimitDescription: "查詢結果和資料表資料匯出的最大行數。",
+    exportRowLimitUnlimited: "無限制",
+    queryExportKeysetOptimizationEnabled: "嘗試 keyset 最佳化",
+    queryExportKeysetOptimizationEnabledDescription: "僅適用於可安全識別的單表查詢；複雜查詢會自動回退。",
+    shortcutUppercaseSelection: "選取內容轉為大寫",
+    shortcutLowercaseSelection: "選取內容轉為小寫",
+    shortcutExPasteSqlInCondition: "ExPaste：貼上為 IN 條件",
+  },
+  driverStore: {
+    progressJreExtract: "解壓縮 JRE……",
+    progressDownloadJre: "下載 JRE",
+    progressDownloadDriver: "下載驅動程式",
+    usageTitle: "空間占用明細",
+    usageTotal: "總計 {size}",
+    usageTotalLabel: "總計",
+    calculating: "統計中……",
+    usageManagedJre: "託管 JRE",
+    usageAgentDrivers: "內建驅動程式 Agent",
+    usageDownloadCache: "下載快取",
+    usageJdbcPlugin: "JDBC 外掛程式",
+    usageJdbcDriverJars: "JDBC 驅動程式 JAR",
+    clearDownloadCache: "清理快取",
+    downloadCacheClearSuccess: "下載快取已清理",
+    downloadCacheClearFailed: "下載快取清理失敗： {error}",
+    javaRuntimeSaved: "Java 執行環境設定已儲存",
+    javaRuntimeSaveFailed: "Java 執行環境設定失敗： {error}",
+    chooseJavaExecutable: "選擇 Java 可執行檔",
+    driverInstallSuccess: "{label} 驅動程式安裝成功",
+    driverInstallFailed: "{label} 驅動程式安裝失敗： {error}",
+    driverUpdateBlocked: "請先關閉以下資料庫連線後再更新驅動程式： {labels}",
+    upgradeAllSuccess: "{count} 個驅動程式更新完成",
+    upgradeAllPartial: "{count} 個驅動程式更新完成，以下驅動程式已略過： {failed}",
+    upgradeAllFailed: "批次更新失敗： {error}",
+    driverUninstallSuccess: "{label} 驅動程式已解除安裝",
+    driverUninstallFailed: "{label} 驅動程式解除安裝失敗： {error}",
+    chooseOfflineDriverPackage: "選擇離線驅動程式包",
+    offlineImportSuccess: "離線匯入完成，已安裝 {count} 個驅動程式",
+    offlineImportFailed: "離線匯入失敗： {error}",
+    driverImportSuccess: "{label} 驅動程式匯入成功",
+    driverImportFailed: "{label} 驅動程式匯入失敗： {error}",
+    chooseDriverJar: "選擇驅動程式 JAR 檔案",
+    jreReinstallSuccess: "JRE {jre} 重新安裝成功",
+    jreReinstallFailed: "JRE {jre} 重新安裝失敗： {error}",
+    jreUninstallSuccess: "JRE {jre} 已解除安裝",
+    chooseJdbcPluginZip: "選擇 JDBC 外掛程式 zip 檔",
+    agentDrivers: "內建驅動程式",
+    jdbcDrivers: "JDBC 驅動程式",
+    importing: "匯入中……",
+    importOfflinePackage: "匯入離線包",
+    refresh: "重新整理",
+    javaRuntime: "Java 執行環境",
+    javaRuntimeManaged: "DBX 託管 JRE",
+    javaRuntimeSystem: "系統 Java",
+    javaRuntimeCustom: "自訂路徑",
+    saving: "儲存中……",
+    customJavaPathPlaceholder: "/path/to/java 或 /path/to/jdk",
+    choose: "選擇",
+    systemJavaHint: "使用目前環境 PATH 中的 java。",
+    jreRuntimeTitle: "JRE {jre} 執行環境",
+    notInstalled: "未安裝",
+    reinstalling: "重新安裝中",
+    installing: "安裝中",
+    install: "安裝",
+    reinstall: "重新安裝",
+    uninstall: "解除安裝",
+    jreRuntime: "JRE 執行環境",
+    jreRuntimeAutoDownloadHint: "首次安裝驅動程式時自動下載",
+    driversUpdatable: "{count} 個驅動程式可更新",
+    upgradingProgress: "更新中 ({current}/{total})",
+    upgradeAll: "全部更新",
+    queued: "排隊中",
+    importLocalJar: "匯入本機 JAR",
+    updating: "更新中",
+    update: "更新",
+    localInstall: "本機安裝",
+    runtimeDrivers: "執行環境",
+    storageTab: "儲存",
+    runtimeTitle: "驅動程式執行環境",
+    runtimeHint: "僅在開啟此面板時收集執行環境指標。",
+    runtimeRunning: "執行中",
+    runtimeMemory: "記憶體",
+    runtimeHealth: "健康狀態",
+    runtimeHealth_healthy: "正常",
+    runtimeHealth_warning: "警告",
+    runtimeHealth_error: "錯誤",
+    runtimeLastError: "最近錯誤",
+    runtimeEmpty: "暫無驅動程式執行環境。開啟一個 Agent 驅動連線後會自動啟動。",
+    runtimeKindAgent: "Agent",
+    runtimeKindPlugin: "外掛程式",
+    runtimeSourceDaemon: "守護程序",
+    runtimeSourceConnection: "連線",
+    runtimeStatus_running: "執行中",
+    runtimeStatus_stopped: "已停止",
+    runtimeStatus_error: "錯誤",
+    runtimeStatus_unknown: "未知",
+    runtimePid: "PID",
+    runtimeUptime: "執行時長",
+    runtimeActions: "操作",
+    runtimeStop: "停止",
+    runtimeRestart: "重新啟動",
+    runtimeControlConnectionOwned: "關閉資料庫連線後即可停止此執行環境。",
+    runtimeStopSuccess: "{label} 執行環境已停止",
+    runtimeStopFailed: "停止 {label} 失敗： {error}",
+    runtimeRestartSuccess: "{label} 執行環境已重新啟動",
+    runtimeRestartFailed: "重新啟動 {label} 失敗： {error}",
+    driverStoreDir: "驅動儲存路徑",
+    driverStoreDirDescription: "JDBC 外掛程式和 Agent/JRE 可分別指定儲存位置，遷移後應用將自動重啟。",
+    pluginStoreDir: "JDBC 外掛程式目錄",
+    pluginStoreDirDescription: "存放 JDBC 外掛程式、Maven resolver 和 JDBC 驅動 jar。",
+    agentStoreDir: "Agent / JRE 目錄",
+    agentStoreDirDescription: "存放 Agent 驅動包、託管 JRE 和執行環境快取。",
+    driverStoreDirDefault: "預設（安裝目錄）",
+    driverStoreDirChange: "更改",
+    driverStoreDirReset: "恢復預設",
+    driverStoreDirMigrating: "正在遷移 {target}…",
+    driverStoreDirConfirm: "更改 {target} 將遷移對應驅動資料到新位置，遷移期間可能會斷開相關驅動連線。遷移完成後應用將自動重啟。是否繼續？",
+    driverStoreDirMigrationFailed: "驅動儲存路徑遷移失敗：{error}",
+    driverStoreDirDialogTitle: "選擇 {target}",
+    driverStoreDirSuccess: "{target} 已更改，正在重啟…",
+    progressDownloadJdbcPlugin: "正在下載 JDBC 外掛程式",
+    progressJdbcPluginExtract: "正在安裝 JDBC 外掛程式...",
+    offlineDownloadHint: "對於離線環境，請在有網路的機器上下載離線驅動程式包，然後在此處匯入。",
+    offlineDownloadLink: "離線驅動程式下載",
+    searchDrivers: "搜尋驅動程式名稱、類型、版本...",
+    searchJdbcDrivers: "搜尋 JDBC 驅動程式名稱或路徑...",
+    jdbcMavenCoordinatePlaceholder: "Maven 座標，例如 org.postgresql:postgresql:42.7.7",
+    jdbcMavenInstall: "從 Maven 安裝",
+    jdbcMavenInstallSuccess: "JDBC Maven 驅動程式已安裝",
+    jdbcSourceMaven: "Maven",
+    jdbcSourceManual: "手動",
+    noMatchingDrivers: "沒有相符的驅動程式。",
+  },
+  databaseExport: {
+    title: "匯出資料庫",
+    options: "選項",
+    includeStructure: "資料表結構 (DDL)",
+    dropTableIfExists: "匯出前新增 DROP TABLE IF EXISTS",
+    includeData: "資料表資料 (INSERT)",
+    includeObjects: "檢視 / 預存程序 / 函式 / 序列",
+    databaseSelection: "選擇資料庫",
+    selectedDatabases: "已選擇 {selected}/{total}",
+    selectAllDatabases: "全選",
+    filterDatabases: "搜尋資料庫...",
+    clearDatabases: "清空",
+    tableSelection: "資料表",
+    selectedTables: "已選擇 {selected}/{total}",
+    selectAllTables: "全選",
+    filterTables: "搜尋資料表名稱……",
+    clearTables: "清空",
+    loadingTables: "正在載入資料表……",
+    tableLoadError: "載入資料表失敗：{error}",
+    noTables: "找不到資料表",
+    export: "匯出",
+    exportAllDatabases: "匯出全部資料庫",
+    exporting: "正在匯出……",
+    selectExportDirectory: "選擇匯出目錄",
+    currentDatabase: "資料庫 {current}/{total}",
+    currentTable: "目前： {table} ({current}/{total})",
+    rowsExported: "已匯出 {count} 列",
+    exportSuccess: "資料庫匯出成功",
+    exportAllSuccess: "已成功匯出 {count} 個資料庫",
+    allDatabasesTask: "全部資料庫（{count}）",
+    exportError: "匯出失敗： {error}",
+    exportCancelled: "匯出已取消",
+    runInBackground: "背景執行",
+  },
+  nacos: {
+    configs: "配置",
+    services: "服務",
+    raw: "Raw",
+    namespace: "命名空間",
+    dataId: "Data ID",
+    group: "Group",
+    format: "配置格式",
+    content: "配置內容",
+    tags: "標籤",
+    application: "歸屬應用",
+    description: "描述",
+    advanced: "進階配置",
+    collapse: "收起",
+    load: "載入",
+    save: "儲存",
+    saveAs: "另存為",
+    saving: "儲存中...",
+    saved: "配置已儲存",
+    createdAndLoaded: "已建立並載入 {dataId}",
+    savedAndLoaded: "已儲存並重新整理 {dataId}",
+    deleted: "配置已刪除",
+    delete: "刪除",
+    copy: "複製",
+    copied: "已複製",
+    copyVerifyFailed: "剪貼簿寫入後驗證失敗",
+    export: "匯出",
+    exported: "匯出完成",
+    exportedTo: "已匯出到 {path}",
+    exportFailed: "匯出失敗：{message}",
+    history: "歷史",
+    configHistory: "配置歷史",
+    historyDetail: "歷史版本詳情",
+    historyCompareTitle: "歷史版本對比",
+    currentPublishedContent: "目前已發布內容：",
+    historyVersionContent: "歷史版本內容：",
+    updatedAt: "更新時間",
+    operationType: "操作類型",
+    operator: "操作人",
+    view: "查看",
+    compare: "對比",
+    rollback: "回滾",
+    loadingHistory: "正在載入歷史版本...",
+    noHistory: "暫無歷史版本",
+    noHistoryHint: "如果剛發布過配置，請重新整理；部分 Nacos 版本可能未開啟歷史記錄介面。",
+    historyCreate: "新增",
+    historyUpdate: "更新",
+    historyDelete: "刪除",
+    historyRollback: "回滾",
+    confirmRollbackTitle: "回滾 Nacos 配置",
+    confirmRollbackMessage: "該操作會將目前配置回滾到所選歷史版本。",
+    rollbackSuccess: "配置已回滾",
+    publish: "發布",
+    dataIdRequired: "Data ID 不能為空",
+    allGroups: "全部分組",
+    noConfigs: "暫無配置",
+    selectConfig: "選擇或新增配置",
+    noServices: "暫無服務",
+    selectService: "選擇服務",
+    service: "服務",
+    instances: "實例",
+    instanceCount: "{count} 個實例",
+    refresh: "重新整理",
+    address: "位址",
+    cluster: "叢集",
+    weight: "權重",
+    state: "狀態",
+    actions: "操作",
+    query: "查詢參數",
+    body: "請求體",
+    response: "回應",
+    template: "模板",
+    configDiffTitle: "配置內容對比",
+    inlineCompare: "行內對比",
+    currentVersionContent: "目前正式版本內容：",
+    publishVersionContent: "本次發布內容：",
+    confirmSaveTitle: "確認儲存 Nacos 配置",
+    confirmSaveMessage: "是否儲存這次配置變更？新增 {added} 行，刪除 {removed} 行。",
+    confirmDeleteTitle: "刪除 Nacos 配置",
+    confirmDeleteMessage: "此操作會從 Nacos 刪除所選配置。",
+    confirmInstanceTitle: "更新 Nacos 實例",
+    confirmInstanceMessage: "請確認目標服務實例狀態。",
+    confirmRawTitle: "傳送變更型 Raw API 請求",
+    confirmRawMessage: "此 Raw API 請求可能會修改 Nacos 狀態。",
+    rawTemplate: {
+      serverState: "服務狀態",
+      namespaceList: "命名空間列表",
+      configDetail: "配置詳情",
+      serviceList: "服務列表",
+      instanceList: "實例列表",
+    },
+    healthy: "健康",
+    unhealthy: "不健康",
+    enabled: "已啟用",
+    offline: "已下線",
+    ephemeral: "臨時實例",
+    persistent: "持久實例",
+    enable: "啟用",
+    disable: "停用",
+    markHealthy: "標記健康",
+    markUnhealthy: "標記不健康",
+    send: "傳送",
+    total: "共 {count} 筆",
+    prev: "上一頁",
+    next: "下一頁",
+    test: "測試",
+    readOnly: "唯讀",
+    createNamespace: "建立命名空間",
+    editNamespace: "編輯命名空間",
+    creatingNamespace: "正在建立...",
+    updatingNamespace: "正在更新...",
+    namespaceCreated: "命名空間「{name}」已建立",
+    namespaceUpdated: "命名空間「{name}」已更新",
+    namespaceId: "命名空間 ID",
+    namespaceIdPlaceholder: "留空由 Nacos 自動產生",
+    namespaceName: "命名空間名稱",
+    namespaceNamePlaceholder: "輸入命名空間名稱",
+    namespaceDesc: "描述",
+    namespaceDescPlaceholder: "預設為命名空間名稱",
+  },
+  userAdmin: {
+    title: "使用者與權限",
+    unsupported: "支援 MySQL 相容和 PostgreSQL 相容連線。SQL Server、Oracle 等其他權限模型將在後續版本中新增。",
+    newUser: "新增使用者",
+    anonymous: "匿名",
+    roleName: "角色名稱",
+    allowLogin: "允許登入",
+    searchUser: "搜尋使用者或主機",
+    loadingUsers: "正在載入使用者...",
+    loadingGrants: "正在載入授權...",
+    emptyUsers: "未找到使用者，或目前帳號無法讀取使用者清單。",
+    pluginUnknown: "認證外掛程式未知",
+    grants: "授權",
+    noGrants: "未找到授權",
+    privilegeEditor: "權限編輯器",
+    privilegeHint: "選擇權限、資料庫和資料表，然後在套用前預覽 SQL。* 表示全域或所有資料表。",
+    database: "資料庫",
+    schema: "Schema",
+    table: "資料表",
+    scope: "授權範圍",
+    scopeDatabase: "資料庫",
+    scopeSchema: "Schema",
+    scopeTable: "資料表",
+    scopeRole: "角色成員",
+    memberRole: "成員角色",
+    privileges: "權限",
+    grantOption: "允許進一步授權（WITH GRANT OPTION）",
+    adminOption: "允許成員管理（WITH ADMIN OPTION）",
+    grant: "授予",
+    revoke: "撤銷",
+    username: "使用者名稱",
+    host: "主機",
+    changePassword: "變更密碼",
+    newPassword: "新密碼",
+    lock: "鎖定",
+    unlock: "解鎖",
+    disableLogin: "停用登入",
+    enableLogin: "啟用登入",
+    dropUser: "刪除使用者",
+    previewSql: "預覽 SQL",
+    sqlPreview: "SQL 預覽",
+    applySql: "套用 SQL",
+    applySuccess: "使用者權限已更新",
+    applyFailed: "執行失敗：{message}",
+  },
+  damengJobAdmin: {
+    title: "達夢代理作業",
+    unsupported: "目前頁面僅支援達夢資料庫連線。",
+    initEnvironment: "初始化作業環境",
+    environmentReady: "作業環境已初始化",
+    newJob: "新增作業",
+    searchJob: "搜尋作業",
+    loadFailed: "載入失敗",
+    environmentMissingTitle: "未初始化作業環境",
+    environmentMissingHint: "目前資料庫還沒有 SYSJOB 作業環境。",
+    environmentMissingDescription: "達夢代理作業依賴 SYSJOB Schema 下的系統資料表和檢視。可以先執行初始化作業環境，通常需要管理員權限。",
+    emptyJobs: "暫無作業，或目前帳號沒有讀取作業清單的權限。",
+    emptyDetails: "暫無明細資料",
+    selectJob: "請選擇一個作業",
+    enabled: "啟用",
+    disabled: "停用",
+    running: "執行中",
+    enable: "啟用",
+    disable: "停用",
+    runAsync: "立即執行",
+    stopRunning: "停止目前執行",
+    stopRunningDisabled: "僅作業正在執行時可停止",
+    clearHistories: "清理歷史",
+    dropJob: "刪除",
+    steps: "步驟",
+    schedules: "排程",
+    histories: "歷史",
+    noDescription: "暫無描述",
+    jobName: "作業名稱",
+    description: "描述",
+    stepName: "步驟名稱",
+    scheduleName: "排程名稱",
+    sqlCommand: "SQL 指令碼",
+    scheduleMode: "排程類型",
+    daily: "每天",
+    once: "一次",
+    startDate: "開始日期",
+    startTime: "開始時間",
+    endTime: "結束時間",
+    minuteInterval: "分鐘間隔",
+    previewSql: "預覽 SQL",
+    sqlPreview: "SQL 預覽",
+    applySql: "執行 SQL",
+    applySuccess: "作業操作已執行",
+    applyFailed: "執行失敗：{message}",
+  },
+  etcd: {
+    prefixPlaceholder: "前綴，例如 /app/",
+    newKey: "新增 Key",
+    loadingKeys: "正在載入 key...",
+    empty: "未找到 key",
+    loadMore: "載入更多",
+    selectKey: "選擇一個 key 以檢視其值",
+    loadingValue: "正在載入值...",
+    notFound: "Key 未找到",
+    edit: "編輯",
+    editKey: "編輯 Key",
+    delete: "刪除",
+    deleteTitle: "刪除 etcd key",
+    keyPlaceholder: "/path/to/key",
+    keyRequired: "Key 不能為空",
+    saved: "Key 已儲存",
+    deleted: "Key 已刪除",
+    base64Readonly: "Base64 值在此版本中為唯讀。",
+  },
+  zookeeper: {
+    prefixPlaceholder: "路徑前綴，例如 /app/",
+    newKey: "新增 Znode",
+    loadingKeys: "正在載入 znode...",
+    empty: "未找到 znode",
+    loadMore: "載入更多",
+    selectKey: "選擇一個 znode 以檢視其值",
+    loadingValue: "正在載入值...",
+    notFound: "Znode 未找到",
+    edit: "編輯",
+    editKey: "編輯 Znode",
+    delete: "刪除",
+    deleteTitle: "刪除 ZooKeeper znode",
+    keyPlaceholder: "/path/to/znode",
+    keyRequired: "Znode 路徑不能為空",
+    saved: "Znode 已儲存",
+    deleted: "Znode 已刪除",
+    base64Readonly: "Base64 值在此版本中為唯讀。",
+    createMode: "建立模式",
+    createModePersistent: "持久",
+    createModeEphemeral: "臨時",
+    createModePersistentSequential: "持久有序",
+    createModeEphemeralSequential: "臨時有序",
+    add: "新增",
+    value: "值",
+    metadata: "節點資訊",
+    prettyJson: "格式化",
+    invalidJson: "無效的 JSON",
+    summaryRevision: "修訂",
+    summaryVersion: "版本",
+    summaryLease: "租約",
+    summarySize: "大小",
+    rootReadonly: "根 znode 不能被修改，請填寫子節點路徑",
+  },
+  gridfsBrowser: {
+    bucketCount: "儲存桶",
+    fileCount: "檔案",
+    name: "名稱",
+    totalSize: "大小",
+    chunkSize: "區塊大小",
+    uploadDate: "上傳日期",
+    contentType: "內容類型",
+    metadata: "元資料",
+    selectBucket: "選擇一個 GridFS 儲存桶以查看或開啟。",
+    selectFile: "選擇一個 GridFS 檔案以查看或管理。",
+    emptyBuckets: "目前沒有 GridFS 儲存桶，可以先新增一個。",
+    emptyFiles: "目前儲存桶還沒有檔案，可以先上傳一個。",
+    createBucket: "新增儲存桶",
+    openBucket: "開啟儲存桶",
+    deleteBucket: "刪除儲存桶",
+    createTitle: "新增 GridFS 儲存桶",
+    deleteTitle: "刪除 GridFS 儲存桶",
+    deleteMessage: "確定刪除選中的 GridFS 儲存桶及其中的所有檔案嗎？",
+    bucketName: "儲存桶名稱",
+    bucketNamePlaceholder: "example_bucket",
+    bucketCreated: "已建立儲存桶 {bucket}。",
+    bucketDeleted: "已刪除儲存桶 {bucket}。",
+    uploadFile: "上傳檔案",
+    downloadFile: "下載檔案",
+    downloadSelected: "下載選取",
+    deleteFile: "刪除檔案",
+    selectedCount: "已選 {count} 個",
+    deleteFileTitle: "刪除 GridFS 檔案",
+    deleteFileMessage: "確定從目前 GridFS 儲存桶中刪除選中檔案嗎？",
+    fileUploaded: "已上傳 {fileName}。",
+    fileDeleted: "已刪除 {fileName}。",
+  },
+  extension: {
+    installTitle: "安裝擴展",
+    manageTitle: "管理擴展",
+    name: "擴展名稱",
+    namePlaceholder: "例如：pg_stat_statements",
+    install: "安裝",
+    drop: "刪除",
+    available: "可用擴展",
+    installed: "已安裝",
+    noAvailable: "所有可用擴展均已安裝。",
+    noInstalled: "暫無已安裝的擴展。",
+  },
+  sqlFileTree: {
+    title: "SQL 檔案",
+    openFolder: "開啟資料夾",
+    closePanel: "關閉",
+    loading: "載入中...",
+    noFolder: "未開啟資料夾",
+    noSqlFiles: "未找到 SQL 檔案",
+    folderAlreadyOpen: "此資料夾已開啟",
+    removeFolder: "移除資料夾",
+    openFailed: "開啟資料夾失敗: {message}",
+    loadFailed: "載入 SQL 檔案失敗: {message}",
+    desktopOnly: "此功能僅在桌面端可用",
+    refreshFolder: "重新整理資料夾",
+    refreshAll: "重新整理全部",
+    refreshed: "已重新整理",
+    revealInFileManager: "在檔案管理員中顯示",
+    revealFailed: "開啟檔案管理員失敗: {message}",
+    copyPath: "複製路徑",
+    pathCopied: "路徑已複製",
+    copyFailed: "複製路徑失敗",
+    openFile: "開啟",
+    executeSqlFile: "執行 SQL 檔案",
+    expandAll: "全部展開",
+    collapseAll: "全部摺疊",
+  },
+  mqTopics: {
+    title: "主題管理",
+    searchPlaceholder: "搜尋 topic",
+    includeNonPersistent: "包含非持久化主題",
+    refresh: "重新整理",
+    refreshing: "重新整理中...",
+    createTopic: "建立主題",
+    selectTenantNamespace: "請先選取租用戶和命名空間",
+    loading: "載入中...",
+    noTopics: "該命名空間下暫無主題",
+    noMatches: "沒有符合的主題",
+    name: "名稱",
+    type: "類型",
+    partitions: "分區",
+    actions: "操作",
+    nonPersistent: "非持久化",
+    partitionedTopic: "分區主題",
+    normalTopic: "一般主題",
+    partitionCount: "{count} 個分區",
+    partitionsUnknown: "分區數未知",
+    adjustPartitions: "調整分區",
+    delete: "刪除",
+    tenantNamespace: "租用戶 / 命名空間",
+    topicName: "主題名稱",
+    topicNamePlaceholder: "例如: my-topic",
+    persistentRecommended: "持久化主題（推薦）",
+    persistentHint: "持久化主題會將訊息儲存到磁碟，非持久化主題僅儲存在記憶體中。",
+    enablePartitions: "啟用分區",
+    partitionQuantity: "分區數量",
+    partitionHint: "分區可以提高並行效能，但會增加資源消耗。",
+    cancel: "取消",
+    create: "建立",
+    updatePartitionsTitle: "調整分區數: {name}",
+    currentPartitions: "目前分區數",
+    newPartitions: "新分區數",
+    partitionMinHint: "分區數只能增加，不能減少。最小值：{min}",
+    update: "更新",
+    readOnly: "目前連線為唯讀模式，無法執行寫入操作。",
+    topicNameRequired: "Topic name 不能為空",
+    currentPartitionsUnknown: "目前分區數未知，無法安全調整分區。",
+    partitionMustIncrease: "新分區數必須大於目前分區數。",
+    confirmDelete: "確定要刪除主題「{name}」嗎？此操作無法復原。",
+  },
+  production: {
+    title: "生產環境",
+    connection: "生產連線",
+    enable: "啟用生產環境保護",
+    disabledDescription: "開啟後可選擇保護全部資料庫或指定資料庫。",
+    scope: "保護範圍",
+    allDatabases: "全部資料庫",
+    selectedDatabases: "選擇資料庫",
+    singleDatabaseScopeHint: "此資料庫類型僅支援連線級生產環境保護。",
+    databases: "生產資料庫",
+    connectionDescription: "此連線上的所有資料庫都會啟用生產保護。",
+    databaseDescription: "從連線中選擇需要生產保護的資料庫。首次開啟預設全選。",
+    selectDatabases: "選擇生產資料庫",
+    noDatabasesSelected: "尚未選擇",
+    databasesConfiguredCount: "已選擇 {count} 個",
+    databasesSelectedCount: "已選擇 {selected}/{total}",
+    databasePickerTitle: "選擇生產資料庫",
+    databasePickerDescription: "選擇「{connection}」中需要生產保護的資料庫。",
+    databaseSearchPlaceholder: "搜尋資料庫...",
+    databaseSelectionRequired: "請至少選擇一個資料庫。",
+    databaseLoadFailed: "無法載入資料庫清單：{message}",
+    noDatabasesAvailable: "未找到可選擇的資料庫。",
+    retry: "重試",
+    confirmTitle: "確認生產環境寫入",
+    confirmMessage: "該操作將變更生產資料庫，必須明確確認後才能繼續。",
+    confirmDetails: "連線：{connection}\n資料庫：{database}\n入口：{source}",
+    confirmAction: "在生產環境執行",
+    sourceSqlEditor: "SQL 編輯器",
+    sourceDataGrid: "資料編輯器",
+    sourceStructure: "結構編輯器",
+    sourceSqlFile: "SQL 檔案執行",
+    sourceObjectBrowser: "物件瀏覽器",
+    sourceSchemaDiff: "結構比對",
+    sourceDataCompare: "資料比對",
+    sourceExtension: "擴充功能管理",
+    sourceSidebar: "物件樹",
+    sourceObjectSource: "物件原始碼編輯器",
+    sourceDataGenerate: "資料產生器",
+    sourceQueryHistory: "查詢歷史回復",
+    sourceAdmin: "資料庫管理",
+    aiReviewRequired: "生產 SQL 已放入編輯器。請先檢查，再手動執行以確認。",
+  },
+});
diff --git a/apps/desktop/src/lib/README.md b/apps/desktop/src/lib/README.md
new file mode 100644
index 0000000..2796f0d
--- /dev/null
+++ b/apps/desktop/src/lib/README.md
@@ -0,0 +1,15 @@
+# Desktop Library Layout
+
+`src/lib` is organized by product/runtime domain. Keep implementation modules inside a domain folder instead of adding new files at the root.
+
+- `backend`: Tauri, HTTP, platform, storage, and transport bridges.
+- `common`: generic helpers with no DBX feature ownership.
+- `app`, `tabs`, `sidebar`, `connection`: shell, navigation, and connection UI state helpers.
+- `database`, `metadata`, `schema`, `table`: relational database metadata, capabilities, DDL, and table-object helpers.
+- `sql`, `sql/semantic`, `editor`, `query`, `history`, `savedSql`: SQL editing, execution, diagnostics, history, and saved SQL behavior.
+- `dataGrid`: result/grid rendering, editing, previews, pagination, and export helpers tied to the grid.
+- `ai`, `mcp`: AI assistant and MCP configuration helpers.
+- `redis`, `mongo`, `elasticsearch`, `etcd`, `kv`, `mq`, `nacos`, `zookeeper`, `webdav`: non-relational or service-specific helpers.
+- `diagram`, `document`, `export`, `imports`: feature-specific utilities that are shared by more than one component.
+
+Tests under `src/lib/__tests__` mirror the same domain folders. When moving a module, update both runtime imports and colocated tests so stale root-level aliases do not return.
diff --git a/apps/desktop/src/lib/__tests__/ai/ai.spec.ts b/apps/desktop/src/lib/__tests__/ai/ai.spec.ts
new file mode 100644
index 0000000..25d8e1a
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/ai/ai.spec.ts
@@ -0,0 +1,34 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { buildSystemPrompt, type AiContext } from "@/lib/ai/ai";
+import { setLocale } from "@/i18n";
+
+function context(overrides: Partial<AiContext> = {}): AiContext {
+  return {
+    connectionId: "conn-1",
+    connectionName: "Postgres",
+    databaseType: "postgres",
+    database: "app",
+    currentSql: "",
+    tables: [],
+    sqlFiles: [],
+    truncated: false,
+    ...overrides,
+  };
+}
+
+describe("AI SQL dialect prompt", () => {
+  // buildSystemPrompt picks zh/en copy via currentLocale(); pin to en so the
+  // English-string assertions are deterministic regardless of the host OS locale.
+  beforeAll(async () => {
+    await setLocale("en");
+  });
+
+  it("pins identifier quoting to the active database type", () => {
+    const prompt = buildSystemPrompt("generate", context(), "ask");
+
+    expect(prompt).toContain("Database type: postgres");
+    expect(prompt).toContain("PostgreSQL/SQLite/Oracle");
+    expect(prompt).toContain('double quotes "name"');
+    expect(prompt).toContain("Do not switch dialects merely because the user mentions another database in prose.");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/ai/aiMarkdown.spec.ts b/apps/desktop/src/lib/__tests__/ai/aiMarkdown.spec.ts
new file mode 100644
index 0000000..212cf10
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/ai/aiMarkdown.spec.ts
@@ -0,0 +1,150 @@
+import { describe, expect, it } from "vitest";
+import { aiMarkdownLinkUrlFromClick, formatAiInlineMarkdown, handleAiMarkdownLinkClick, normalizeAiMarkdownLink } from "@/lib/ai/aiMarkdown";
+
+describe("formatAiInlineMarkdown", () => {
+  it("renders http links for external browser handling", () => {
+    const html = formatAiInlineMarkdown("See [docs](https://example.com/a?x=1&y=2).");
+
+    expect(html).toContain('href="https://example.com/a?x=1&amp;y=2"');
+    expect(html).toContain('target="_blank"');
+    expect(html).toContain('rel="noopener noreferrer"');
+  });
+
+  it("does not render unsafe link schemes", () => {
+    const html = formatAiInlineMarkdown("[run](javascript:alert(1))");
+
+    expect(html).toContain("run");
+    expect(html).not.toContain("javascript:");
+    expect(html).not.toContain("<a ");
+  });
+
+  it("escapes raw html from assistant text", () => {
+    const html = formatAiInlineMarkdown("<script>alert(1)</script>");
+
+    expect(html).toContain("&lt;script&gt;alert(1)&lt;/script&gt;");
+    expect(html).not.toContain("<script>");
+  });
+});
+
+describe("markdown table overflow wrapping", () => {
+  it("wraps tables in scroll container", () => {
+    const html = formatAiInlineMarkdown("| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |");
+
+    expect(html).toContain('<div class="ai-markdown-table-wrap">');
+    expect(html).toContain("<table>");
+    expect(html).toContain("<th");
+    expect(html).toContain("<td");
+    expect(html).toContain("<tbody>");
+  });
+
+  it("does not inject table wrapper when no table is present", () => {
+    const html = formatAiInlineMarkdown("Hello **world**.");
+
+    expect(html).not.toContain("ai-markdown-table-wrap");
+    expect(html).not.toContain("<table>");
+  });
+
+  it("preserves table column alignment", () => {
+    const html = formatAiInlineMarkdown("| a | b | c |\n| :--- | :---: | ---: |\n| 1 | 2 | 3 |");
+
+    expect(html).toContain('align="left"');
+    expect(html).toContain('align="center"');
+    expect(html).toContain('align="right"');
+  });
+
+  it("handles tables with only headers", () => {
+    const html = formatAiInlineMarkdown("| a | b |\n| --- | --- |");
+
+    expect(html).toContain('<div class="ai-markdown-table-wrap">');
+    expect(html).toContain("<thead>");
+    expect(html).toContain("<tbody>");
+    expect(html).not.toContain("<td");
+  });
+
+  it("handles inline formatting inside table cells", () => {
+    const html = formatAiInlineMarkdown("| a | b |\n| --- | --- |\n| **bold** | `code` |");
+
+    expect(html).toContain("<strong>bold</strong>");
+    expect(html).toContain("<code");
+    expect(html).toContain("code</code>");
+  });
+
+  it("handles multi-column, multi-row tables", () => {
+    const html = formatAiInlineMarkdown(["| a | b | c |", "| -- | -- | -- |", "| 1 | 2 | 3 |", "| 4 | 5 | 6 |"].join("\n"));
+
+    expect(html).toContain('<div class="ai-markdown-table-wrap">');
+    expect(html).toContain("<td>1</td>");
+    expect(html).toContain("<td>2</td>");
+    expect(html).toContain("<td>3</td>");
+    expect(html).toContain("<td>4</td>");
+    expect(html).toContain("<td>5</td>");
+    expect(html).toContain("<td>6</td>");
+  });
+});
+
+describe("normalizeAiMarkdownLink", () => {
+  it("accepts absolute http and https urls", () => {
+    expect(normalizeAiMarkdownLink("https://example.com/docs")).toBe("https://example.com/docs");
+    expect(normalizeAiMarkdownLink("http://example.com/docs")).toBe("http://example.com/docs");
+  });
+
+  it("rejects relative and non-browser-safe urls", () => {
+    expect(normalizeAiMarkdownLink("/docs")).toBeNull();
+    expect(normalizeAiMarkdownLink("mailto:test@example.com")).toBeNull();
+    expect(normalizeAiMarkdownLink("javascript:alert(1)")).toBeNull();
+  });
+});
+
+describe("ai markdown link clicks", () => {
+  it("finds anchors from a clicked child node", () => {
+    const anchor = anchorWithHref("https://example.com/docs");
+    const target = { closest: (selector: string) => (selector === "a[href]" ? anchor : null) };
+    const currentTarget = { contains: (node: unknown) => node === anchor };
+
+    expect(aiMarkdownLinkUrlFromClick(target, currentTarget)).toBe("https://example.com/docs");
+  });
+
+  it("prevents default navigation and opens external links", () => {
+    const anchor = anchorWithHref("https://example.com/docs");
+    const target = { closest: () => anchor };
+    const currentTarget = { contains: () => true };
+    let prevented = false;
+    let stopped = false;
+    let opened = "";
+
+    const handled = handleAiMarkdownLinkClick(
+      {
+        target,
+        currentTarget,
+        preventDefault: () => {
+          prevented = true;
+        },
+        stopPropagation: () => {
+          stopped = true;
+        },
+      },
+      (url) => {
+        opened = url;
+      },
+    );
+
+    expect(handled).toBe(true);
+    expect(prevented).toBe(true);
+    expect(stopped).toBe(true);
+    expect(opened).toBe("https://example.com/docs");
+  });
+
+  it("ignores unsafe and out-of-scope links", () => {
+    const unsafeAnchor = anchorWithHref("javascript:alert(1)");
+    expect(aiMarkdownLinkUrlFromClick({ closest: () => unsafeAnchor }, { contains: () => true })).toBeNull();
+
+    const outsideAnchor = anchorWithHref("https://example.com/docs");
+    expect(aiMarkdownLinkUrlFromClick({ closest: () => outsideAnchor }, { contains: () => false })).toBeNull();
+  });
+});
+
+function anchorWithHref(href: string) {
+  return {
+    getAttribute: (name: string) => (name === "href" ? href : null),
+  };
+}
diff --git a/apps/desktop/src/lib/__tests__/ai/aiMessageEdit.spec.ts b/apps/desktop/src/lib/__tests__/ai/aiMessageEdit.spec.ts
new file mode 100644
index 0000000..859044e
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/ai/aiMessageEdit.spec.ts
@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { visibleToActualIndex } from "@/lib/ai/aiMessageEdit";
+
+describe("visibleToActualIndex", () => {
+  it("maps visible index 0 to first non-summary message", () => {
+    const messages = [{ kind: undefined }, { kind: undefined }, { kind: undefined }];
+    expect(visibleToActualIndex(messages, 0)).toBe(0);
+  });
+
+  it("maps visible index 1 correctly with no summaries", () => {
+    const messages = [{ kind: undefined }, { kind: undefined }, { kind: undefined }];
+    expect(visibleToActualIndex(messages, 1)).toBe(1);
+  });
+
+  it("skips contextSummary messages when computing visible index", () => {
+    const messages = [{ kind: undefined }, { kind: "contextSummary" }, { kind: undefined }, { kind: undefined }];
+    // visible[0] → actual[0], visible[1] → actual[2], visible[2] → actual[3]
+    expect(visibleToActualIndex(messages, 0)).toBe(0);
+    expect(visibleToActualIndex(messages, 1)).toBe(2);
+    expect(visibleToActualIndex(messages, 2)).toBe(3);
+  });
+
+  it("skips multiple consecutive contextSummary messages", () => {
+    const messages = [{ kind: "contextSummary" }, { kind: "contextSummary" }, { kind: undefined }, { kind: undefined }];
+    expect(visibleToActualIndex(messages, 0)).toBe(2);
+    expect(visibleToActualIndex(messages, 1)).toBe(3);
+  });
+
+  it("returns -1 when visibleIndex is out of range", () => {
+    const messages = [{ kind: undefined }, { kind: undefined }];
+    expect(visibleToActualIndex(messages, 5)).toBe(-1);
+  });
+
+  it("returns -1 for empty messages array", () => {
+    expect(visibleToActualIndex([], 0)).toBe(-1);
+  });
+
+  it("returns -1 when all messages are contextSummary", () => {
+    const messages = [{ kind: "contextSummary" }, { kind: "contextSummary" }];
+    expect(visibleToActualIndex(messages, 0)).toBe(-1);
+  });
+
+  it("handles last visible message correctly", () => {
+    const messages = [{ kind: undefined }, { kind: "contextSummary" }, { kind: undefined }];
+    expect(visibleToActualIndex(messages, 1)).toBe(2);
+    expect(visibleToActualIndex(messages, 2)).toBe(-1);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/ai/aiMessageRender.spec.ts b/apps/desktop/src/lib/__tests__/ai/aiMessageRender.spec.ts
new file mode 100644
index 0000000..9bb6510
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/ai/aiMessageRender.spec.ts
@@ -0,0 +1,24 @@
+import { describe, expect, it, vi } from "vitest";
+import { createAiMessageRenderer } from "@/lib/ai/aiMessageRender";
+
+describe("createAiMessageRenderer", () => {
+  it("caches completed short messages", () => {
+    const markdown = vi.fn((text: string) => `<p>${text}</p>`);
+    const renderer = createAiMessageRenderer({ markdown, maxCacheableChars: 100 });
+
+    renderer.render("hello");
+    renderer.render("hello");
+
+    expect(markdown).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not retain long streaming message versions", () => {
+    const markdown = vi.fn((text: string) => `<p>${text}</p>`);
+    const renderer = createAiMessageRenderer({ markdown, maxCacheableChars: 5 });
+
+    renderer.render("long message");
+    renderer.render("long message");
+
+    expect(markdown).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/ai/aiModelPresentation.spec.ts b/apps/desktop/src/lib/__tests__/ai/aiModelPresentation.spec.ts
new file mode 100644
index 0000000..9fd6174
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/ai/aiModelPresentation.spec.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { formatAiModelOption, shouldShowAiModelSecondaryLabel } from "@/lib/ai/aiModelPresentation";
+
+describe("shouldShowAiModelSecondaryLabel", () => {
+  it("hides secondary text when display name only changes case", () => {
+    expect(shouldShowAiModelSecondaryLabel("GPT-5.5", "gpt-5.5")).toBe(false);
+  });
+
+  it("hides secondary text when display name only changes separators", () => {
+    expect(shouldShowAiModelSecondaryLabel("GPT-5.4-Mini", "gpt-5.4-mini")).toBe(false);
+  });
+
+  it("hides secondary text for exact matches", () => {
+    expect(shouldShowAiModelSecondaryLabel("gpt-5.3-codex", "gpt-5.3-codex")).toBe(false);
+  });
+
+  it("keeps secondary text when provider display name is meaningfully different", () => {
+    expect(shouldShowAiModelSecondaryLabel("Claude Sonnet 4", "claude-sonnet-4-20250514")).toBe(true);
+  });
+});
+
+describe("formatAiModelOption", () => {
+  it("returns a single-line Codex-style model option", () => {
+    expect(formatAiModelOption("GPT-5.5", "gpt-5.5")).toEqual({ primary: "GPT-5.5", secondary: undefined });
+  });
+
+  it("returns model id as secondary text only when useful", () => {
+    expect(formatAiModelOption("Claude Sonnet 4", "claude-sonnet-4-20250514")).toEqual({
+      primary: "Claude Sonnet 4",
+      secondary: "claude-sonnet-4-20250514",
+    });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/ai/aiProposalDetect.spec.ts b/apps/desktop/src/lib/__tests__/ai/aiProposalDetect.spec.ts
new file mode 100644
index 0000000..cfe5b02
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/ai/aiProposalDetect.spec.ts
@@ -0,0 +1,143 @@
+import { describe, expect, it } from "vitest";
+import { containsChinese, isShortAffirmative, isShortNegative, looksLikeActionProposal } from "@/lib/ai/aiProposalDetect";
+
+describe("looksLikeActionProposal", () => {
+  // ---- zh-CN proposals ----
+  it("detects zh proposal: 需要我执行这个查询吗？", () => {
+    expect(looksLikeActionProposal("需要我执行这个查询吗？")).toBe(true);
+  });
+
+  it("detects zh proposal: 要不要我拉取这两个表的数据？", () => {
+    expect(looksLikeActionProposal("要不要我拉取这两个表的数据？")).toBe(true);
+  });
+
+  it("detects zh proposal: 是否需要我帮你查一下订单表？", () => {
+    expect(looksLikeActionProposal("是否需要我帮你查一下订单表？")).toBe(true);
+  });
+
+  it("detects zh proposal: 我来执行这个 SQL？", () => {
+    expect(looksLikeActionProposal("我来执行这个 SQL？")).toBe(true);
+  });
+
+  it("detects zh proposal in last line of multi-line message", () => {
+    const multi = "我已经查看了 orders 表的结构。\n现在需要我查看一下 users 表吗？";
+    expect(looksLikeActionProposal(multi)).toBe(true);
+  });
+
+  it("detects zh proposal: 我去看看这两个表的数据？", () => {
+    expect(looksLikeActionProposal("需要我去看看这两个表的数据？")).toBe(true);
+  });
+
+  // ---- en proposals ----
+  it("detects en proposal: Should I execute this query?", () => {
+    expect(looksLikeActionProposal("Should I execute this query?")).toBe(true);
+  });
+
+  it("detects en proposal: Do you want me to fetch the data?", () => {
+    expect(looksLikeActionProposal("Do you want me to fetch the data?")).toBe(true);
+  });
+
+  it("detects en proposal: Shall I run the analysis?", () => {
+    expect(looksLikeActionProposal("Shall I run the analysis?")).toBe(true);
+  });
+
+  it("detects en proposal: Can I pull the sample data?", () => {
+    expect(looksLikeActionProposal("Can I pull the sample data?")).toBe(true);
+  });
+
+  // ---- negative cases (NOT proposals) ----
+  it("rejects generic clarifying question without action", () => {
+    expect(looksLikeActionProposal("请问 orders 表有哪些字段？")).toBe(false);
+  });
+
+  it("rejects zh question without ask phrase", () => {
+    expect(looksLikeActionProposal("这个查询的执行结果正确吗？")).toBe(false);
+  });
+
+  it("rejects en question without ask phrase", () => {
+    expect(looksLikeActionProposal("What columns does the orders table have?")).toBe(false);
+  });
+
+  it("rejects statement ending with period", () => {
+    expect(looksLikeActionProposal("需要我执行这个查询。")).toBe(false);
+  });
+
+  it("rejects empty content", () => {
+    expect(looksLikeActionProposal("")).toBe(false);
+  });
+
+  it("rejects en question with no actionable verb", () => {
+    expect(looksLikeActionProposal("Should I proceed?")).toBe(false);
+  });
+
+  it("rejects zh proposal ending with period", () => {
+    expect(looksLikeActionProposal("需要我查看订单表的数据。")).toBe(false);
+  });
+
+  it("rejects message with no question mark", () => {
+    expect(looksLikeActionProposal("需要我执行查询")).toBe(false);
+  });
+
+  it("rejects mixed punctuation but not a question", () => {
+    expect(looksLikeActionProposal("可以了，谢谢！")).toBe(false);
+  });
+});
+
+describe("isShortAffirmative", () => {
+  // zh
+  it("matches 需要", () => expect(isShortAffirmative("需要")).toBe(true));
+  it("matches 好", () => expect(isShortAffirmative("好")).toBe(true));
+  it("matches 好的", () => expect(isShortAffirmative("好的")).toBe(true));
+  it("matches 可以", () => expect(isShortAffirmative("可以")).toBe(true));
+  it("matches 是", () => expect(isShortAffirmative("是")).toBe(true));
+  it("matches 对", () => expect(isShortAffirmative("对")).toBe(true));
+  it("matches 嗯", () => expect(isShortAffirmative("嗯")).toBe(true));
+
+  // zh with punctuation
+  it("strips punctuation: 好！", () => expect(isShortAffirmative("好！")).toBe(true));
+  it("strips punctuation: 好的。", () => expect(isShortAffirmative("好的。")).toBe(true));
+
+  // en
+  it("matches yes", () => expect(isShortAffirmative("yes")).toBe(true));
+  it("matches Yes (capitalized)", () => expect(isShortAffirmative("Yes")).toBe(true));
+  it("matches ok", () => expect(isShortAffirmative("ok")).toBe(true));
+  it("matches OK", () => expect(isShortAffirmative("OK")).toBe(true));
+  it("matches sure", () => expect(isShortAffirmative("sure")).toBe(true));
+  it("matches go ahead", () => expect(isShortAffirmative("go ahead")).toBe(true));
+  it("matches do it", () => expect(isShortAffirmative("do it")).toBe(true));
+  it("matches proceed", () => expect(isShortAffirmative("proceed")).toBe(true));
+
+  // negative
+  it("rejects long message", () => expect(isShortAffirmative("好的，我来看看具体情况")).toBe(false));
+  it("rejects unrelated word", () => expect(isShortAffirmative("其他")).toBe(false));
+  it("rejects empty", () => expect(isShortAffirmative("")).toBe(false));
+});
+
+describe("isShortNegative", () => {
+  // zh
+  it("matches 不用", () => expect(isShortNegative("不用")).toBe(true));
+  it("matches 不用了", () => expect(isShortNegative("不用了")).toBe(true));
+  it("matches 不需要", () => expect(isShortNegative("不需要")).toBe(true));
+  it("matches 不要", () => expect(isShortNegative("不要")).toBe(true));
+  it("matches 先不", () => expect(isShortNegative("先不")).toBe(true));
+
+  // zh with punctuation
+  it("strips punctuation: 不用了。", () => expect(isShortNegative("不用了。")).toBe(true));
+
+  // en
+  it("matches no", () => expect(isShortNegative("no")).toBe(true));
+  it("matches nope", () => expect(isShortNegative("nope")).toBe(true));
+  it("matches not needed", () => expect(isShortNegative("not needed")).toBe(true));
+  it("matches don't", () => expect(isShortNegative("don't")).toBe(true));
+  it("matches cancel", () => expect(isShortNegative("cancel")).toBe(true));
+
+  // negative
+  it("rejects long message", () => expect(isShortNegative("不用了，谢谢，我自己来查")).toBe(false));
+  it("rejects empty", () => expect(isShortNegative("")).toBe(false));
+});
+
+describe("containsChinese", () => {
+  it("detects Chinese characters", () => expect(containsChinese("需要我执行")).toBe(true));
+  it("rejects pure ASCII", () => expect(containsChinese("Should I execute")).toBe(false));
+  it("handles mixed CJK punctuation-only", () => expect(containsChinese("？。，")).toBe(false));
+});
diff --git a/apps/desktop/src/lib/__tests__/ai/aiTableMentions.spec.ts b/apps/desktop/src/lib/__tests__/ai/aiTableMentions.spec.ts
new file mode 100644
index 0000000..51da0a8
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/ai/aiTableMentions.spec.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { AI_TABLE_MENTION_CANDIDATE_LIMIT, filterAiTableMentionCandidates, formatAiTableMention, parseAiTableMentions } from "@/lib/ai/aiTableMentions";
+
+describe("AI table mention parsing", () => {
+  it("parses plain and schema-qualified table mentions", () => {
+    expect(parseAiTableMentions("explain @public.users and @orders")).toEqual([
+      { raw: "@public.users", schema: "public", table: "users" },
+      { raw: "@orders", schema: undefined, table: "orders" },
+    ]);
+  });
+
+  it("formats quoted table mentions when identifiers need escaping", () => {
+    expect(formatAiTableMention("public", "order items")).toBe('@public."order items"');
+  });
+});
+
+describe("AI table mention candidates", () => {
+  it("keeps more than the old 20 item cap for a single schema", () => {
+    const candidates = tables(40);
+
+    expect(filterAiTableMentionCandidates(candidates, "")).toHaveLength(40);
+  });
+
+  it("filters by table name and can return matches after the first 20 entries", () => {
+    const candidates = [...tables(25, "order_"), ...tables(30, "audit_")];
+    const filtered = filterAiTableMentionCandidates(candidates, "audit_");
+
+    expect(filtered).toHaveLength(30);
+    expect(filtered[0].name).toBe("audit_000");
+    expect(filtered.at(-1)?.name).toBe("audit_029");
+  });
+
+  it("applies the global candidate cap after multi-schema results are merged", () => {
+    const merged = [...tables(120, "public_"), ...tables(120, "archive_")];
+    const filtered = filterAiTableMentionCandidates(merged, "");
+
+    expect(filtered).toHaveLength(AI_TABLE_MENTION_CANDIDATE_LIMIT);
+    expect(filtered[0].name).toBe("public_000");
+    expect(filtered.at(-1)?.name).toBe("archive_079");
+  });
+});
+
+function tables(count: number, prefix = "table_") {
+  return Array.from({ length: count }, (_, index) => ({ name: `${prefix}${String(index).padStart(3, "0")}` }));
+}
diff --git a/apps/desktop/src/lib/__tests__/app/pinnedItems.spec.ts b/apps/desktop/src/lib/__tests__/app/pinnedItems.spec.ts
new file mode 100644
index 0000000..b7ba65c
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/app/pinnedItems.spec.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { updatePinnedTreeNodeInPlace } from "@/lib/app/pinnedItems";
+import { buildTreeNodesFromLayout } from "@/lib/sidebar/sidebarLayout";
+import type { ConnectionConfig, SidebarLayout, TreeNode } from "@/types/database";
+
+describe("sidebar pinned tree nodes", () => {
+  it("reorders the pinned node within its parent", () => {
+    const tree: TreeNode[] = [
+      {
+        id: "conn",
+        label: "Connection",
+        type: "connection",
+        children: [
+          { id: "conn:db:a", label: "A", type: "database" },
+          { id: "conn:db:b", label: "B", type: "database" },
+        ],
+      },
+    ];
+
+    expect(updatePinnedTreeNodeInPlace(tree, "conn:db:b", true)).toBe("siblings");
+
+    expect(tree[0].children?.map((node) => node.id)).toEqual(["conn:db:b", "conn:db:a"]);
+    expect(tree[0].children?.[0].pinned).toBe(true);
+  });
+
+  it("reorders pinned root nodes in place", () => {
+    const tree: TreeNode[] = [
+      { id: "group-a", label: "A", type: "connection-group" },
+      { id: "group-b", label: "B", type: "connection-group" },
+    ];
+
+    expect(updatePinnedTreeNodeInPlace(tree, "group-b", true)).toBe("root");
+
+    expect(tree.map((node) => node.id)).toEqual(["group-b", "group-a"]);
+    expect(tree[0].pinned).toBe(true);
+  });
+
+  it("applies pinned state to connection groups when rebuilding from layout", () => {
+    const layout: SidebarLayout = {
+      groups: [
+        { id: "group-a", name: "A", collapsed: false },
+        { id: "group-b", name: "B", collapsed: false },
+      ],
+      order: [
+        { type: "group", id: "group-a", children: [] },
+        { type: "group", id: "group-b", children: [] },
+      ],
+    };
+    const connections: ConnectionConfig[] = [];
+
+    const nodes = buildTreeNodesFromLayout(layout, connections, new Set(["group-b"]));
+
+    expect(nodes.map((node) => node.id)).toEqual(["group-b", "group-a"]);
+    expect(nodes[0].pinned).toBe(true);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/common/elapsedTime.spec.ts b/apps/desktop/src/lib/__tests__/common/elapsedTime.spec.ts
new file mode 100644
index 0000000..e6e6488
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/common/elapsedTime.spec.ts
@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { formatElapsedSeconds } from "@/lib/common/elapsedTime";
+
+describe("formatElapsedSeconds", () => {
+  it("formats elapsed milliseconds with two fractional second digits", () => {
+    expect(formatElapsedSeconds(1234)).toBe("1.23");
+    expect(formatElapsedSeconds(5)).toBe("0.01");
+    expect(formatElapsedSeconds(0)).toBe("0.00");
+  });
+
+  it("clamps invalid elapsed values to zero", () => {
+    expect(formatElapsedSeconds(-100)).toBe("0.00");
+    expect(formatElapsedSeconds(Number.NaN)).toBe("0.00");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/common/optionHelpPanelOffset.spec.ts b/apps/desktop/src/lib/__tests__/common/optionHelpPanelOffset.spec.ts
new file mode 100644
index 0000000..e89a0e2
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/common/optionHelpPanelOffset.spec.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { optionHelpPanelOffsetTop } from "@/lib/common/optionHelpPanelOffset";
+
+describe("optionHelpPanelOffsetTop", () => {
+  it("aligns a help panel with the active option when there is room", () => {
+    expect(optionHelpPanelOffsetTop({ activeItemTop: 48, listCardHeight: 260, panelHeight: 80 })).toBe(48);
+  });
+
+  it("does not produce a negative offset", () => {
+    expect(optionHelpPanelOffsetTop({ activeItemTop: -12, listCardHeight: 260, panelHeight: 80 })).toBe(0);
+  });
+
+  it("clamps the panel upward at the list card bottom", () => {
+    expect(optionHelpPanelOffsetTop({ activeItemTop: 210, listCardHeight: 260, panelHeight: 80 })).toBe(180);
+  });
+
+  it("pins a panel taller than the list card to the top", () => {
+    expect(optionHelpPanelOffsetTop({ activeItemTop: 48, listCardHeight: 80, panelHeight: 120 })).toBe(0);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/common/searchableSelectTooltip.spec.ts b/apps/desktop/src/lib/__tests__/common/searchableSelectTooltip.spec.ts
new file mode 100644
index 0000000..2e87be7
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/common/searchableSelectTooltip.spec.ts
@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { SEARCHABLE_SELECT_HELP_PANEL_ALIGN, searchableSelectKeyboardTooltipOption, searchableSelectSelectedOrFirstHelpOption } from "@/lib/common/searchableSelectTooltip";
+
+describe("searchableSelectKeyboardTooltipOption", () => {
+  it("anchors the help panel to the trigger's left edge", () => {
+    expect(SEARCHABLE_SELECT_HELP_PANEL_ALIGN).toBe("start");
+  });
+
+  it("activates the highlighted option help during Arrow-key navigation", () => {
+    const optionTooltip = (option: string) => (option === "json" ? "Validated JSON document" : undefined);
+
+    // ArrowDown moves highlight from int (index 0) to json (index 1) while the search input retains focus.
+    expect(searchableSelectKeyboardTooltipOption(["int", "json"], 0, optionTooltip)).toBeUndefined();
+    expect(searchableSelectKeyboardTooltipOption(["int", "json"], 1, optionTooltip)).toBe("json");
+  });
+
+  it("does not activate help for the initial unhighlighted list state", () => {
+    const optionTooltip = () => "Type help";
+
+    expect(searchableSelectKeyboardTooltipOption(["int"], -1, optionTooltip)).toBeUndefined();
+  });
+
+  it("activates selected help on open and the first matching option after search", () => {
+    const optionTooltip = (option: string) => (option === "json" || option === "int" ? `${option} help` : undefined);
+
+    expect(searchableSelectSelectedOrFirstHelpOption(["int", "json"], "json", optionTooltip)).toBe("json");
+    expect(searchableSelectSelectedOrFirstHelpOption(["int", "json"], "unknown", optionTooltip)).toBe("int");
+    expect(searchableSelectSelectedOrFirstHelpOption(["custom"], "unknown", optionTooltip)).toBeUndefined();
+    expect(searchableSelectSelectedOrFirstHelpOption(["dynamic_unknown", "json"], "dynamic_unknown", optionTooltip)).toBe("json");
+  });
+
+  it("does not activate a tooltip when the optional callback is absent or returns no content", () => {
+    expect(searchableSelectKeyboardTooltipOption(["int", "json"], 1)).toBeUndefined();
+    expect(searchableSelectKeyboardTooltipOption(["int", "json"], 0, () => undefined)).toBeUndefined();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/common/ttlFormat.spec.ts b/apps/desktop/src/lib/__tests__/common/ttlFormat.spec.ts
new file mode 100644
index 0000000..25f2fae
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/common/ttlFormat.spec.ts
@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+import { formatTtl } from "@/lib/common/ttlFormat";
+
+// ---------------------------------------------------------------------------
+// Mock `t()` helpers — only the day unit needs localization
+// ---------------------------------------------------------------------------
+
+function enT(key: string, options?: Record<string, unknown>): string {
+  const messages: Record<string, string> = {
+    "redis.ttlDay": "{count}d",
+  };
+  const msg = messages[key] ?? key;
+  const count = (options as { count?: number })?.count;
+  if (count != null) return msg.replace("{count}", String(count));
+  return msg;
+}
+
+function zhT(key: string, options?: Record<string, unknown>): string {
+  const messages: Record<string, string> = {
+    "redis.ttlDay": "{count}天",
+  };
+  const msg = messages[key] ?? key;
+  const count = (options as { count?: number })?.count;
+  if (count != null) return msg.replace("{count}", String(count));
+  return msg;
+}
+
+function esT(key: string, options?: Record<string, unknown>): string {
+  const messages: Record<string, string> = {
+    "redis.ttlDay": "{count}d",
+  };
+  const msg = messages[key] ?? key;
+  const count = (options as { count?: number })?.count;
+  if (count != null) return msg.replace("{count}", String(count));
+  return msg;
+}
+
+function itT(key: string, options?: Record<string, unknown>): string {
+  const messages: Record<string, string> = {
+    "redis.ttlDay": "{count}g",
+  };
+  const msg = messages[key] ?? key;
+  const count = (options as { count?: number })?.count;
+  if (count != null) return msg.replace("{count}", String(count));
+  return msg;
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("formatTtl — special values", () => {
+  it("returns null for -1 (no expiry)", () => {
+    expect(formatTtl(-1, enT)).toBeNull();
+  });
+
+  it("returns null for 0", () => {
+    expect(formatTtl(0, enT)).toBeNull();
+    expect(formatTtl(0, zhT)).toBeNull();
+  });
+
+  it("returns null for negative values other than -1", () => {
+    expect(formatTtl(-2, enT)).toBeNull();
+  });
+});
+
+describe("formatTtl — sub-day, HH:mm:ss (no i18n)", () => {
+  it("formats 45s as 00:00:45", () => {
+    expect(formatTtl(45, enT)).toBe("00:00:45");
+  });
+
+  it("formats 1m as 00:01:00", () => {
+    expect(formatTtl(60, enT)).toBe("00:01:00");
+  });
+
+  it("formats 1m 30s as 00:01:30", () => {
+    expect(formatTtl(90, enT)).toBe("00:01:30");
+  });
+
+  it("formats 2m 5s as 00:02:05", () => {
+    expect(formatTtl(125, enT)).toBe("00:02:05");
+  });
+
+  it("formats 1h as 01:00:00", () => {
+    expect(formatTtl(3600, enT)).toBe("01:00:00");
+  });
+
+  it("formats 1h 1m 1s as 01:01:01", () => {
+    expect(formatTtl(3661, enT)).toBe("01:01:01");
+  });
+
+  it("formats 23h 59m 59s as 23:59:59", () => {
+    expect(formatTtl(86399, enT)).toBe("23:59:59");
+  });
+});
+
+describe("formatTtl — multi-day, {n}d HH:mm:ss (day unit localized)", () => {
+  it("formats exactly 1 day as 1d 00:00:00", () => {
+    expect(formatTtl(86400, enT)).toBe("1d 00:00:00");
+    expect(formatTtl(86400, zhT)).toBe("1天 00:00:00");
+  });
+
+  it("formats 7 days as 7d 00:00:00", () => {
+    expect(formatTtl(604800, enT)).toBe("7d 00:00:00");
+    expect(formatTtl(604800, zhT)).toBe("7天 00:00:00");
+  });
+
+  it("formats 365 days as 365d 00:00:00", () => {
+    expect(formatTtl(31536000, enT)).toBe("365d 00:00:00");
+    expect(formatTtl(31536000, zhT)).toBe("365天 00:00:00");
+  });
+
+  it("formats 1d 1h 1m 1s", () => {
+    expect(formatTtl(90061, enT)).toBe("1d 01:01:01");
+    expect(formatTtl(90061, zhT)).toBe("1天 01:01:01");
+  });
+
+  it("formats 2d 3h 4m 5s", () => {
+    const ttl = 2 * 86400 + 3 * 3600 + 4 * 60 + 5; // 183845
+    expect(formatTtl(ttl, enT)).toBe("2d 03:04:05");
+    expect(formatTtl(ttl, zhT)).toBe("2天 03:04:05");
+  });
+});
+
+describe("formatTtl — Spanish locale", () => {
+  it("formats sub-day values with no i18n", () => {
+    expect(formatTtl(45, esT)).toBe("00:00:45");
+    expect(formatTtl(3661, esT)).toBe("01:01:01");
+  });
+
+  it("formats multi-day with localized d", () => {
+    expect(formatTtl(86400, esT)).toBe("1d 00:00:00");
+    expect(formatTtl(604800, esT)).toBe("7d 00:00:00");
+  });
+
+  it("returns null for -1", () => {
+    expect(formatTtl(-1, esT)).toBeNull();
+  });
+
+  it("returns null for 0", () => {
+    expect(formatTtl(0, esT)).toBeNull();
+  });
+});
+
+describe("formatTtl — Italian locale", () => {
+  it("formats sub-day values with no i18n", () => {
+    expect(formatTtl(45, itT)).toBe("00:00:45");
+    expect(formatTtl(3661, itT)).toBe("01:01:01");
+  });
+
+  it("formats multi-day with localized g", () => {
+    expect(formatTtl(86400, itT)).toBe("1g 00:00:00");
+    expect(formatTtl(604800, itT)).toBe("7g 00:00:00");
+  });
+
+  it("returns null for -1", () => {
+    expect(formatTtl(-1, itT)).toBeNull();
+  });
+
+  it("returns null for 0", () => {
+    expect(formatTtl(0, itT)).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/common/webPath.spec.ts b/apps/desktop/src/lib/__tests__/common/webPath.spec.ts
new file mode 100644
index 0000000..e6ea717
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/common/webPath.spec.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { apiUrl, apiWebSocketUrl, dbxWebBasePath, webPath } from "@/lib/common/webPath";
+
+describe("webPath", () => {
+  it("keeps root deployments on root-relative API paths", () => {
+    expect(dbxWebBasePath("/", "/")).toBe("");
+    expect(apiUrl("/api/auth/check", "")).toBe("/api/auth/check");
+  });
+
+  it("uses an explicit build base path", () => {
+    expect(dbxWebBasePath("/", "/dbx/")).toBe("/dbx");
+    expect(webPath("/login", "/dbx")).toBe("/dbx/login");
+    expect(webPath("/", "/dbx")).toBe("/dbx/");
+    expect(webPath("/icons/database/mysql.svg", "/dbx")).toBe("/dbx/icons/database/mysql.svg");
+    expect(webPath("/icons/ai/openai.svg", "/dbx")).toBe("/dbx/icons/ai/openai.svg");
+    expect(apiUrl("/auth/check", "/dbx")).toBe("/dbx/api/auth/check");
+    expect(apiUrl("/api/auth/check", "/dbx")).toBe("/dbx/api/auth/check");
+    expect(apiUrl("api/auth/check", "/dbx")).toBe("/dbx/api/auth/check");
+  });
+
+  it("infers the runtime base path from the login URL for relative builds", () => {
+    expect(dbxWebBasePath("/dbx/login", "./")).toBe("/dbx");
+    expect(dbxWebBasePath("/tools/dbx/login", "./")).toBe("/tools/dbx");
+  });
+
+  it("infers the runtime base path from a mounted relative build", () => {
+    expect(dbxWebBasePath("/dbx/", "./")).toBe("/dbx");
+    expect(dbxWebBasePath("/tools/dbx/", "./")).toBe("/tools/dbx");
+  });
+
+  it("builds websocket URLs with the configured base path", () => {
+    expect(apiWebSocketUrl("/redis/session/123", "/dbx", { protocol: "https:", host: "example.test" })).toBe("wss://example.test/dbx/api/redis/session/123");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/connection/connectionAttemptTimeout.spec.ts b/apps/desktop/src/lib/__tests__/connection/connectionAttemptTimeout.spec.ts
new file mode 100644
index 0000000..a447b52
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/connection/connectionAttemptTimeout.spec.ts
@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import { ACCESS_AGENT_MIN_CONNECT_TIMEOUT_SECS, AGENT_DRIVER_MIN_CONNECT_TIMEOUT_SECS, connectionAttemptOriginalErrorMessage, connectionAttemptTimeoutMessage, connectionAttemptTimeoutMs, CONNECTION_ATTEMPT_TIMEOUT_BUFFER_MS } from "@/lib/connection/connectionAttemptTimeout";
+
+describe("connectionAttemptTimeout", () => {
+  it("uses a 10s default for regular database connections", () => {
+    expect(connectionAttemptTimeoutMs({ db_type: "mysql", connect_timeout_secs: undefined, transport_layers: [] })).toBe(12_000);
+  });
+
+  it("keeps explicit regular database timeout values", () => {
+    expect(connectionAttemptTimeoutMs({ db_type: "mysql", connect_timeout_secs: 5, transport_layers: [] })).toBe(7_000);
+  });
+
+  it("uses a 30s agent startup floor", () => {
+    expect(connectionAttemptTimeoutMs({ db_type: "oracle", connect_timeout_secs: 5, transport_layers: [] })).toBe(AGENT_DRIVER_MIN_CONNECT_TIMEOUT_SECS * 1000 + CONNECTION_ATTEMPT_TIMEOUT_BUFFER_MS);
+  });
+
+  it("uses the startup floor for PrestoSQL JDBC plugin connections", () => {
+    expect(connectionAttemptTimeoutMs({ db_type: "prestosql", connect_timeout_secs: 5, transport_layers: [] })).toBe(AGENT_DRIVER_MIN_CONNECT_TIMEOUT_SECS * 1000 + CONNECTION_ATTEMPT_TIMEOUT_BUFFER_MS);
+  });
+
+  it("uses the startup floor for generic JDBC plugin connections", () => {
+    expect(connectionAttemptTimeoutMs({ db_type: "jdbc", connect_timeout_secs: 5, transport_layers: [] })).toBe(AGENT_DRIVER_MIN_CONNECT_TIMEOUT_SECS * 1000 + CONNECTION_ATTEMPT_TIMEOUT_BUFFER_MS);
+  });
+
+  it("uses the startup floor for ZooKeeper agent connections", () => {
+    expect(connectionAttemptTimeoutMs({ db_type: "zookeeper", connect_timeout_secs: 5, transport_layers: [] })).toBe(AGENT_DRIVER_MIN_CONNECT_TIMEOUT_SECS * 1000 + CONNECTION_ATTEMPT_TIMEOUT_BUFFER_MS);
+  });
+
+  it("uses a 30s Access agent startup floor", () => {
+    expect(connectionAttemptTimeoutMs({ db_type: "access", connect_timeout_secs: 5, transport_layers: [] })).toBe(ACCESS_AGENT_MIN_CONNECT_TIMEOUT_SECS * 1000 + CONNECTION_ATTEMPT_TIMEOUT_BUFFER_MS);
+  });
+
+  it("respects a user configured Access timeout above the default floor", () => {
+    expect(connectionAttemptTimeoutMs({ db_type: "access", connect_timeout_secs: 45, transport_layers: [] })).toBe(47_000);
+  });
+
+  it("includes HTTP tunnel connection timeout values", () => {
+    expect(
+      connectionAttemptTimeoutMs({
+        db_type: "mysql",
+        connect_timeout_secs: 5,
+        transport_layers: [
+          {
+            type: "http_tunnel",
+            id: "http",
+            url: "https://dbx.example.com/dbx_tunnel.php",
+            connect_timeout_secs: 25,
+          },
+        ],
+      }),
+    ).toBe(27_000);
+  });
+
+  it("ignores disabled transport layer timeouts", () => {
+    expect(
+      connectionAttemptTimeoutMs({
+        db_type: "mysql",
+        connect_timeout_secs: 5,
+        transport_layers: [
+          {
+            type: "http_tunnel",
+            id: "http",
+            enabled: false,
+            url: "https://dbx.example.com/dbx_tunnel.php",
+            connect_timeout_secs: 60,
+          },
+        ],
+      }),
+    ).toBe(7_000);
+  });
+
+  it("adds late original database errors to timeout messages", () => {
+    const timeoutMessage = connectionAttemptTimeoutMessage(7_000);
+
+    expect(connectionAttemptOriginalErrorMessage(timeoutMessage, "MySQL connection failed: os error 10060")).toContain("MySQL connection failed: os error 10060");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/connection/connectionOpenTarget.spec.ts b/apps/desktop/src/lib/__tests__/connection/connectionOpenTarget.spec.ts
new file mode 100644
index 0000000..50ebcf6
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/connection/connectionOpenTarget.spec.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { quickConnectionOpenTarget } from "@/lib/connection/connectionOpenTarget";
+import type { ConnectionConfig } from "@/types/database";
+
+function connection(dbType: ConnectionConfig["db_type"]): ConnectionConfig {
+  return {
+    id: "conn",
+    name: "conn",
+    db_type: dbType,
+    host: "127.0.0.1",
+    port: 0,
+    user: "",
+    password: "",
+    database: "",
+    readonly: false,
+    read_only: false,
+    ssl_mode: "disabled",
+    color: "#888",
+  } as ConnectionConfig;
+}
+
+describe("quickConnectionOpenTarget", () => {
+  it("opens message queue connections in the MQ admin console", () => {
+    expect(quickConnectionOpenTarget(connection("mq"))).toEqual({ kind: "mq-admin" });
+  });
+
+  it("opens Nacos connections in the Nacos admin console", () => {
+    expect(quickConnectionOpenTarget(connection("nacos"))).toEqual({ kind: "nacos-admin" });
+  });
+
+  it("opens regular connections in a query tab", () => {
+    expect(quickConnectionOpenTarget({ ...connection("postgresql"), database: "app" })).toEqual({
+      kind: "query",
+      database: "app",
+    });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/connection/connectionUrl.dremio.spec.ts b/apps/desktop/src/lib/__tests__/connection/connectionUrl.dremio.spec.ts
new file mode 100644
index 0000000..7cf7da3
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/connection/connectionUrl.dremio.spec.ts
@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+import { parseConnectionUrl } from "@/lib/connection/connectionUrl";
+
+describe("Dremio JDBC connection URLs", () => {
+  it("parses legacy direct JDBC URLs into a Dremio JDBC profile", () => {
+    const parsed = parseConnectionUrl("jdbc:dremio:direct=dremio.example.com:31010;schema=analytics;user=admin;password=secret;ssl=true");
+
+    expect(parsed.dbType).toBe("jdbc");
+    expect(parsed.driverProfile).toBe("dremio");
+    expect(parsed.driverLabel).toBe("Dremio");
+    expect(parsed.host).toBe("dremio.example.com");
+    expect(parsed.port).toBe(31010);
+    expect(parsed.database).toBe("analytics");
+    expect(parsed.username).toBe("admin");
+    expect(parsed.password).toBe("secret");
+    expect(parsed.urlParams).toBe("ssl=true");
+    expect(parsed.connectionString).toBe("jdbc:dremio:direct=dremio.example.com:31010;schema=analytics;user=admin;password=secret;ssl=true");
+  });
+
+  it("uses the Dremio default port when the JDBC URL omits a port", () => {
+    const parsed = parseConnectionUrl("jdbc:dremio:direct=dremio.example.com");
+
+    expect(parsed.port).toBe(31010);
+    expect(parsed.database).toBeUndefined();
+  });
+
+  it("parses legacy ZooKeeper JDBC URLs into a Dremio JDBC profile", () => {
+    const parsed = parseConnectionUrl("jdbc:dremio:zk=zk.example.com;schema=analytics;tag=prod");
+
+    expect(parsed.dbType).toBe("jdbc");
+    expect(parsed.driverProfile).toBe("dremio");
+    expect(parsed.host).toBe("zk.example.com");
+    expect(parsed.port).toBe(2181);
+    expect(parsed.database).toBe("analytics");
+    expect(parsed.urlParams).toBe("tag=prod");
+  });
+
+  it("parses Arrow Flight SQL JDBC URLs into a Dremio JDBC profile", () => {
+    const parsed = parseConnectionUrl("jdbc:arrow-flight-sql://admin:secret@dremio.example.com:32010?schema=analytics&useEncryption=true");
+
+    expect(parsed.dbType).toBe("jdbc");
+    expect(parsed.driverProfile).toBe("dremio");
+    expect(parsed.driverLabel).toBe("Dremio");
+    expect(parsed.host).toBe("dremio.example.com");
+    expect(parsed.port).toBe(32010);
+    expect(parsed.database).toBe("analytics");
+    expect(parsed.username).toBe("admin");
+    expect(parsed.password).toBe("secret");
+    expect(parsed.urlParams).toBe("schema=analytics&useEncryption=true");
+    expect(parsed.ssl).toBe(true);
+    expect(parsed.connectionString).toBe("jdbc:arrow-flight-sql://admin:secret@dremio.example.com:32010?schema=analytics&useEncryption=true");
+  });
+
+  it("uses the Arrow Flight SQL default port when the JDBC URL omits a port", () => {
+    const parsed = parseConnectionUrl("jdbc:arrow-flight-sql://dremio.example.com");
+
+    expect(parsed.port).toBe(32010);
+    expect(parsed.database).toBeUndefined();
+  });
+
+  it("parses unencrypted Arrow Flight SQL JDBC URLs", () => {
+    const parsed = parseConnectionUrl("jdbc:arrow-flight-sql://dremio.example.com:32010?useEncryption=false");
+
+    expect(parsed.port).toBe(32010);
+    expect(parsed.urlParams).toBe("useEncryption=false");
+    expect(parsed.ssl).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/connection/connectionUrl.zookeeper.spec.ts b/apps/desktop/src/lib/__tests__/connection/connectionUrl.zookeeper.spec.ts
new file mode 100644
index 0000000..efd1c06
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/connection/connectionUrl.zookeeper.spec.ts
@@ -0,0 +1,8 @@
+import { describe, expect, it } from "vitest";
+import { parseConnectionUrl } from "@/lib/connection/connectionUrl";
+
+describe("ZooKeeper connection URLs", () => {
+  it("preserves the host:port chroot path as a ZooKeeper connect string", () => {
+    expect(parseConnectionUrl("zookeeper://zk-main:2181/app").connectionString).toBe("zk-main:2181/app");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/connection/kafkaBootstrapServers.spec.ts b/apps/desktop/src/lib/__tests__/connection/kafkaBootstrapServers.spec.ts
new file mode 100644
index 0000000..f102d32
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/connection/kafkaBootstrapServers.spec.ts
@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { normalizeKafkaBootstrapServers } from "@/lib/connection/kafkaBootstrapServers";
+
+describe("Kafka bootstrap servers", () => {
+  it("keeps comma-separated bootstrap servers", () => {
+    expect(normalizeKafkaBootstrapServers("broker1:9092, broker2:9092")).toBe("broker1:9092,broker2:9092");
+  });
+
+  it("normalizes common cluster address separators to commas", () => {
+    expect(normalizeKafkaBootstrapServers("broker1:9092；broker2:9092，broker3:9092\nbroker4:9092 broker5:9092")).toBe("broker1:9092,broker2:9092,broker3:9092,broker4:9092,broker5:9092");
+  });
+
+  it("keeps IPv6 bootstrap servers", () => {
+    expect(normalizeKafkaBootstrapServers("[::1]:9092;[2001:db8::1]:9092")).toBe("[::1]:9092,[2001:db8::1]:9092");
+  });
+
+  it("rejects bootstrap servers with URL schemes", () => {
+    expect(() => normalizeKafkaBootstrapServers("PLAINTEXT://broker1:9092,broker2:9092")).toThrow("Kafka bootstrap servers must be host:port values without a URL scheme");
+  });
+
+  it("rejects invalid bootstrap server values", () => {
+    expect(() => normalizeKafkaBootstrapServers("broker1:9092/path,broker2:9092")).toThrow("Kafka bootstrap servers are invalid");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/connection/sqlServerLegacyCompatibility.spec.ts b/apps/desktop/src/lib/__tests__/connection/sqlServerLegacyCompatibility.spec.ts
new file mode 100644
index 0000000..e20b90e
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/connection/sqlServerLegacyCompatibility.spec.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { isSqlServerLegacyCompatibilityMode, requiresSqlServerLegacyCompatibilityComponent, setSqlServerLegacyCompatibilityMode } from "@/lib/connection/sqlServerLegacyCompatibility";
+import type { ConnectionConfig } from "@/types/database";
+
+function connectionConfig(urlParams?: string): ConnectionConfig {
+  return {
+    id: "sqlserver",
+    name: "SQL Server",
+    db_type: "sqlserver",
+    driver_profile: "sqlserver",
+    driver_label: "SQL Server",
+    host: "127.0.0.1",
+    port: 1433,
+    username: "sa",
+    password: "secret",
+    database: "master",
+    url_params: urlParams,
+    ssl: false,
+    ssh_enabled: false,
+    read_only: false,
+    one_time: false,
+    transport_layers: [],
+    agent_java_options: [],
+  };
+}
+
+describe("SQL Server legacy compatibility", () => {
+  it("treats existing disabled encryption params as legacy compatibility opt-in", () => {
+    expect(isSqlServerLegacyCompatibilityMode("sqlserverEncryption=disabled")).toBe(true);
+    expect(isSqlServerLegacyCompatibilityMode("applicationName=dbx;encrypt=false")).toBe(true);
+    expect(isSqlServerLegacyCompatibilityMode("?Encrypt=0&applicationName=dbx")).toBe(true);
+    expect(isSqlServerLegacyCompatibilityMode("encrypt=true")).toBe(false);
+  });
+
+  it("updates URL params without keeping conflicting encryption params", () => {
+    expect(setSqlServerLegacyCompatibilityMode("applicationName=dbx;encrypt=true", true)).toBe("applicationName=dbx&sqlserverEncryption=disabled");
+    expect(setSqlServerLegacyCompatibilityMode("applicationName=dbx;sqlserverEncryption=disabled", false)).toBe("applicationName=dbx");
+  });
+
+  it("requires the hidden component only for SQL Server legacy compatibility connections", () => {
+    expect(requiresSqlServerLegacyCompatibilityComponent(connectionConfig("sqlserverEncryption=disabled"))).toBe(true);
+    expect(requiresSqlServerLegacyCompatibilityComponent(connectionConfig("encrypt=true"))).toBe(false);
+    expect(
+      requiresSqlServerLegacyCompatibilityComponent({
+        ...connectionConfig("sqlserverEncryption=disabled"),
+        db_type: "mysql",
+      }),
+    ).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/connection/tunnelProfiles.spec.ts b/apps/desktop/src/lib/__tests__/connection/tunnelProfiles.spec.ts
new file mode 100644
index 0000000..daf5f7a
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/connection/tunnelProfiles.spec.ts
@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { createTunnelProfile, detachTunnelProfileLayer, tunnelProfileReferenceLayer, tunnelProfileSummary } from "@/lib/connection/tunnelProfiles";
+import type { TunnelProfile } from "@/types/database";
+
+function sshProfile(overrides: Partial<TunnelProfile> = {}): TunnelProfile {
+  return {
+    ...createTunnelProfile("ssh"),
+    id: "profile-1",
+    name: "Bastion",
+    host: "bastion.example.com",
+    user: "deploy",
+    password: "s3cret",
+    ...overrides,
+  } as TunnelProfile;
+}
+
+describe("tunnelProfileSummary", () => {
+  it("formats ssh profiles as user@host:port", () => {
+    expect(tunnelProfileSummary(sshProfile())).toBe("deploy@bastion.example.com:22");
+  });
+
+  it("formats proxy profiles as scheme://host:port", () => {
+    const proxy = { ...createTunnelProfile("proxy"), host: "127.0.0.1", port: 1080 } as TunnelProfile;
+    expect(tunnelProfileSummary(proxy)).toBe("socks5://127.0.0.1:1080");
+  });
+
+  it("returns the url for http tunnel profiles", () => {
+    const http = { ...createTunnelProfile("http_tunnel"), url: "https://example.com/dbx_tunnel.php" } as TunnelProfile;
+    expect(tunnelProfileSummary(http)).toBe("https://example.com/dbx_tunnel.php");
+  });
+
+  it("returns an empty string when the target is not configured yet", () => {
+    expect(tunnelProfileSummary(createTunnelProfile("ssh"))).toBe("");
+  });
+});
+
+describe("tunnelProfileReferenceLayer", () => {
+  it("keeps only identity, enabled state, and the reference", () => {
+    const profile = sshProfile();
+    const stub = tunnelProfileReferenceLayer(profile, { id: "layer-1", enabled: false });
+
+    expect(stub.id).toBe("layer-1");
+    expect(stub.enabled).toBe(false);
+    expect(stub.profile_id).toBe("profile-1");
+    expect(stub.name).toBe("Bastion");
+    // Credentials must not be copied into the stub stored on the connection.
+    expect(stub.type).toBe("ssh");
+    if (stub.type === "ssh") {
+      expect(stub.host).toBe("");
+      expect(stub.password).toBe("");
+    }
+  });
+
+  it("generates a fresh id when there is no previous layer", () => {
+    const stub = tunnelProfileReferenceLayer(sshProfile());
+    expect(stub.id).toBeTruthy();
+    expect(stub.enabled).toBe(true);
+  });
+});
+
+describe("detachTunnelProfileLayer", () => {
+  it("copies the profile configuration onto the layer and drops the reference", () => {
+    const profile = sshProfile();
+    const stub = tunnelProfileReferenceLayer(profile, { id: "layer-1", enabled: true });
+    const detached = detachTunnelProfileLayer(stub, profile);
+
+    expect(detached.id).toBe("layer-1");
+    expect(detached.profile_id).toBeUndefined();
+    if (detached.type === "ssh") {
+      expect(detached.host).toBe("bastion.example.com");
+      expect(detached.password).toBe("s3cret");
+    } else {
+      throw new Error("expected ssh layer");
+    }
+  });
+
+  it("only drops the reference when the profile no longer exists", () => {
+    const stub = tunnelProfileReferenceLayer(sshProfile(), { id: "layer-1", enabled: true });
+    const detached = detachTunnelProfileLayer(stub, undefined);
+    expect(detached.profile_id).toBeUndefined();
+    expect(detached.id).toBe("layer-1");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/cellValue.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/cellValue.spec.ts
new file mode 100644
index 0000000..9518ce0
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/cellValue.spec.ts
@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import { firstLineCellDisplayValue } from "@/lib/dataGrid/cellValue";
+
+describe("firstLineCellDisplayValue", () => {
+  it("shows only the first line in fixed-height cells", () => {
+    expect(firstLineCellDisplayValue("111\n222")).toBe("111");
+    expect(firstLineCellDisplayValue("111\r\n222")).toBe("111");
+    expect(firstLineCellDisplayValue("111\r222")).toBe("111");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/chartData.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/chartData.spec.ts
new file mode 100644
index 0000000..825e462
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/chartData.spec.ts
@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { axisColumnLabel, chartableColumnIndexes, toChartNumber } from "@/lib/dataGrid/chartData";
+import type { QueryResult } from "@/types/database";
+
+function result(columns: string[], rows: QueryResult["rows"]): QueryResult {
+  return {
+    columns,
+    rows,
+    affected_rows: rows.length,
+    execution_time_ms: 1,
+  };
+}
+
+describe("chartData", () => {
+  it("accepts finite numbers and numeric strings", () => {
+    expect(toChartNumber(42)).toBe(42);
+    expect(toChartNumber("42.5")).toBe(42.5);
+    expect(toChartNumber(" 1e3 ")).toBe(1000);
+  });
+
+  it("rejects non-finite and non-numeric values", () => {
+    expect(toChartNumber("")).toBeNull();
+    expect(toChartNumber("abc")).toBeNull();
+    expect(toChartNumber(null)).toBeNull();
+    expect(toChartNumber(true)).toBeNull();
+  });
+
+  it("finds numeric columns returned as strings", () => {
+    expect(
+      chartableColumnIndexes(
+        result(
+          ["name", "decimal_total", "status"],
+          [
+            ["a", "12.34", "ok"],
+            ["b", "56.78", "ok"],
+          ],
+        ),
+      ),
+    ).toEqual([1]);
+  });
+
+  it("disambiguates duplicate axis labels by index", () => {
+    expect(axisColumnLabel(["amount", "amount"], 0)).toBe("amount #1");
+    expect(axisColumnLabel(["amount", "amount"], 1)).toBe("amount #2");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/dataGridCellCoercion.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/dataGridCellCoercion.spec.ts
new file mode 100644
index 0000000..42832db
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/dataGridCellCoercion.spec.ts
@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { dataGridCellDisplayText } from "@/lib/dataGrid/dataGridCellCoercion";
+
+describe("dataGridCellDisplayText", () => {
+  it("formats Oracle DATE values without RFC3339 separators", () => {
+    expect(
+      dataGridCellDisplayText({
+        value: "2022-08-25T09:58:43Z",
+        databaseType: "oracle",
+        columnInfo: { data_type: "DATE" },
+      }),
+    ).toBe("2022-08-25 09:58:43");
+  });
+
+  it("formats midnight Oracle DATE values as a date", () => {
+    expect(
+      dataGridCellDisplayText({
+        value: "2022-08-25T00:00:00Z",
+        databaseType: "oracle",
+        columnInfo: { data_type: "DATE" },
+      }),
+    ).toBe("2022-08-25");
+  });
+
+  it("does not format non-date Oracle strings", () => {
+    expect(
+      dataGridCellDisplayText({
+        value: "2022-08-25T09:58:43Z",
+        databaseType: "oracle",
+        columnInfo: { data_type: "VARCHAR2(64)" },
+      }),
+    ).toBeUndefined();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/dataGridColumnLayoutStorage.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/dataGridColumnLayoutStorage.spec.ts
new file mode 100644
index 0000000..b5aa47c
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/dataGridColumnLayoutStorage.spec.ts
@@ -0,0 +1,59 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { loadTableDataGridColumnOrder, notifyTableDataGridColumnOrderChanged, removeTableDataGridColumnOrder, saveTableDataGridColumnOrder, TABLE_DATA_GRID_COLUMN_ORDER_CHANGED_EVENT, tableDataGridColumnOrderScopeKey } from "@/lib/dataGrid/dataGridColumnLayoutStorage";
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: (key: string) => data.get(key) ?? null,
+    setItem: (key: string, value: string) => data.set(key, value),
+    removeItem: (key: string) => data.delete(key),
+  });
+}
+
+describe("table data grid column order storage", () => {
+  beforeEach(installLocalStorage);
+  afterEach(() => vi.unstubAllGlobals());
+
+  it("stores an order independently from the current result column signature", () => {
+    const scopeKey = tableDataGridColumnOrderScopeKey({
+      connectionId: "sqlserver-1",
+      database: "sales",
+      schema: "core",
+      tableName: "products",
+    });
+    const order = ["name\u00000", "id\u00000"];
+
+    saveTableDataGridColumnOrder(scopeKey, order);
+
+    expect(loadTableDataGridColumnOrder(scopeKey)).toEqual(order);
+  });
+
+  it("isolates tables and removes a saved order", () => {
+    const products = tableDataGridColumnOrderScopeKey({ connectionId: "sqlserver-1", database: "sales", schema: "core", tableName: "products" });
+    const orders = tableDataGridColumnOrderScopeKey({ connectionId: "sqlserver-1", database: "sales", schema: "core", tableName: "orders" });
+    saveTableDataGridColumnOrder(products, ["name\u00000", "id\u00000"]);
+
+    expect(loadTableDataGridColumnOrder(orders)).toEqual([]);
+    removeTableDataGridColumnOrder(products);
+    expect(loadTableDataGridColumnOrder(products)).toEqual([]);
+  });
+
+  it("normalizes a missing schema to the database namespace", () => {
+    const withoutSchema = tableDataGridColumnOrderScopeKey({ connectionId: "sqlite-1", database: "main", tableName: "products" });
+    const explicitMainSchema = tableDataGridColumnOrderScopeKey({ connectionId: "sqlite-1", database: "main", schema: "main", tableName: "products" });
+
+    expect(withoutSchema).toBe(explicitMainSchema);
+  });
+
+  it("notifies other open views when a table order changes", () => {
+    const dispatchEvent = vi.fn();
+    vi.stubGlobal("window", { dispatchEvent });
+
+    notifyTableDataGridColumnOrderChanged("table-scope");
+
+    expect(dispatchEvent).toHaveBeenCalledOnce();
+    const event = dispatchEvent.mock.calls[0]?.[0] as CustomEvent;
+    expect(event.type).toBe(TABLE_DATA_GRID_COLUMN_ORDER_CHANGED_EVENT);
+    expect(event.detail).toEqual({ scopeKey: "table-scope" });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/dataGridConditionSuggestionPosition.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/dataGridConditionSuggestionPosition.spec.ts
new file mode 100644
index 0000000..26b6f0b
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/dataGridConditionSuggestionPosition.spec.ts
@@ -0,0 +1,24 @@
+import { describe, expect, test } from "vitest";
+
+import { getDataGridConditionSuggestionPosition } from "@/lib/dataGrid/dataGridConditionSuggestionPosition";
+
+describe("getDataGridConditionSuggestionPosition", () => {
+  test("anchors the dropdown to the input instead of the caret", () => {
+    const position = getDataGridConditionSuggestionPosition({ left: 120, bottom: 40, width: 420 }, { viewportWidth: 1000 });
+
+    expect(position).toEqual({ left: 120, top: 42, width: 420 });
+  });
+
+  test("keeps long history rows inside the viewport", () => {
+    const position = getDataGridConditionSuggestionPosition({ left: 780, bottom: 40, width: 420 }, { viewportWidth: 1000 });
+
+    expect(position.left + position.width).toBeLessThanOrEqual(992);
+    expect(position.width).toBe(420);
+  });
+
+  test("uses a minimum width for narrow inputs", () => {
+    const position = getDataGridConditionSuggestionPosition({ left: 20, bottom: 40, width: 120 }, { viewportWidth: 1000 });
+
+    expect(position.width).toBe(180);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/dataGridInfiniteScroll.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/dataGridInfiniteScroll.spec.ts
new file mode 100644
index 0000000..3cf968c
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/dataGridInfiniteScroll.spec.ts
@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { dataGridBottomScrollTop, isDataGridAtScrollBottom } from "@/lib/dataGrid/dataGridInfiniteScroll";
+
+describe("data grid bottom anchoring", () => {
+  it("keeps DOM rows anchored when scrollbar padding increases the scroll height", () => {
+    const before = { scrollTop: 740, scrollHeight: 1000, clientHeight: 260 };
+    const after = { scrollHeight: 1010, clientHeight: 260 };
+
+    expect(isDataGridAtScrollBottom(before)).toBe(true);
+    expect(dataGridBottomScrollTop(after)).toBe(750);
+  });
+
+  it("keeps canvas rows anchored when scrollbar margin reduces the viewport", () => {
+    const before = { scrollTop: 740, scrollHeight: 1000, clientHeight: 260 };
+    const after = { scrollHeight: 1000, clientHeight: 250 };
+
+    expect(isDataGridAtScrollBottom(before)).toBe(true);
+    expect(dataGridBottomScrollTop(after)).toBe(750);
+  });
+
+  it("keeps the quick-entry draft row visible after the horizontal scrollbar appears", () => {
+    const before = { scrollTop: 766, scrollHeight: 1026, clientHeight: 260 };
+    const after = { scrollHeight: 1036, clientHeight: 260 };
+
+    expect(isDataGridAtScrollBottom(before)).toBe(true);
+    expect(dataGridBottomScrollTop(after)).toBe(776);
+  });
+
+  it("does not anchor a user who is away from the bottom", () => {
+    expect(isDataGridAtScrollBottom({ scrollTop: 700, scrollHeight: 1000, clientHeight: 260 })).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/dataGridTemporalEditor.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/dataGridTemporalEditor.spec.ts
new file mode 100644
index 0000000..e545585
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/dataGridTemporalEditor.spec.ts
@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { formatTemporalInputValue, parseTemporalInputValue, stepTemporalInputValue, temporalCellEditorConfig, temporalCellEditorKind } from "@/lib/dataGrid/dataGridTemporalEditor";
+
+describe("dataGridTemporalEditor", () => {
+  it("resolves temporal editor configs with fractional precision", () => {
+    expect(temporalCellEditorConfig("datetime(3)")).toEqual({ kind: "datetime", fractionPrecision: 3 });
+    expect(temporalCellEditorConfig("datetime2(7)")).toEqual({ kind: "datetime", fractionPrecision: 7 });
+    expect(temporalCellEditorConfig("timestamp(6)")).toEqual({ kind: "datetime", fractionPrecision: 6 });
+    expect(temporalCellEditorConfig("time(6)")).toEqual({ kind: "time", fractionPrecision: 6 });
+    expect(temporalCellEditorConfig("DateTime64(3)")).toEqual({ kind: "datetime", fractionPrecision: 3 });
+  });
+
+  it("uses column numeric scale for temporal fractional precision", () => {
+    expect(temporalCellEditorConfig({ data_type: "timestamp", numeric_scale: 6 })).toEqual({ kind: "datetime", fractionPrecision: 6 });
+    expect(temporalCellEditorConfig({ data_type: "time", numeric_scale: 3 })).toEqual({ kind: "time", fractionPrecision: 3 });
+    expect(temporalCellEditorConfig({ data_type: "timestamp(6)", numeric_scale: 2 })).toEqual({ kind: "datetime", fractionPrecision: 2 });
+  });
+
+  it("keeps the legacy kind-only helper", () => {
+    expect(temporalCellEditorKind("datetime(6)")).toBe("datetime");
+    expect(temporalCellEditorKind("date")).toBe("date");
+    expect(temporalCellEditorKind("varchar(64)")).toBeUndefined();
+  });
+
+  it("preserves fractional seconds when formatting and parsing datetime input", () => {
+    expect(formatTemporalInputValue("2026-07-09 12:34:56.123456", "datetime")).toBe("2026-07-09T12:34:56.123456");
+    expect(parseTemporalInputValue("2026-07-09T12:34:56.123456", "datetime")).toBe("2026-07-09 12:34:56.123456");
+  });
+
+  it("preserves fractional seconds when formatting and parsing time input", () => {
+    expect(formatTemporalInputValue("12:34:56.123456", "time")).toBe("12:34:56.123456");
+    expect(parseTemporalInputValue("12:34:56.123456", "time")).toBe("12:34:56.123456");
+  });
+
+  it("preserves fractional seconds while stepping date and time parts", () => {
+    const value = "2026-07-09 12:34:56.123456";
+
+    expect(stepTemporalInputValue(value, "datetime", "day", 1)).toBe("2026-07-10 12:34:56.123456");
+    expect(stepTemporalInputValue(value, "datetime", "hour", 1)).toBe("2026-07-09 13:34:56.123456");
+    expect(stepTemporalInputValue(value, "datetime", "second", 1)).toBe("2026-07-09 12:34:57.123456");
+  });
+
+  it("keeps ordinary datetime values at second precision", () => {
+    expect(temporalCellEditorConfig("datetime")).toEqual({ kind: "datetime", fractionPrecision: 0 });
+    expect(formatTemporalInputValue("2026-07-09 12:34:56", "datetime")).toBe("2026-07-09T12:34:56");
+    expect(parseTemporalInputValue("2026-07-09T12:34:56", "datetime")).toBe("2026-07-09 12:34:56");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/dataGridTranspose.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/dataGridTranspose.spec.ts
new file mode 100644
index 0000000..14bbd3b
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/dataGridTranspose.spec.ts
@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { averageTransposeRecordWidth, calculateTransposeRecordWidth, defaultTransposeRecordWidth, minTransposeFieldWidth, transposeFieldWidth, transposeRecordWidthsForDensity, visibleTransposeRecordWindow } from "@/lib/dataGrid/dataGridTranspose";
+
+describe("dataGridTranspose density widths", () => {
+  it("uses the shared density preset for record and field widths", () => {
+    const values = ["x".repeat(40)];
+    const columns = ["a_very_long_transpose_field_name"];
+
+    const compactRecord = calculateTransposeRecordWidth(values, "compact");
+    const standardRecord = calculateTransposeRecordWidth(values, "standard");
+    const comfortableRecord = calculateTransposeRecordWidth(values, "comfortable");
+    const compactField = transposeFieldWidth(columns, { density: "compact" });
+    const standardField = transposeFieldWidth(columns, { density: "standard" });
+    const comfortableField = transposeFieldWidth(columns, { density: "comfortable" });
+
+    expect(compactRecord).toBeLessThan(standardRecord);
+    expect(standardRecord).toBeLessThan(comfortableRecord);
+    expect(compactField).toBeLessThan(standardField);
+    expect(standardField).toBeLessThan(comfortableField);
+    expect(transposeFieldWidth([], { density: "compact" })).toBe(minTransposeFieldWidth("compact"));
+  });
+
+  it("recalculates automatic widths while preserving manual pixel overrides", () => {
+    const records = [["x".repeat(40)], ["y".repeat(20)]];
+    const standardWidths = transposeRecordWidthsForDensity({ records, density: "standard" });
+    const comfortableWidths = transposeRecordWidthsForDensity({
+      records,
+      density: "comfortable",
+      previousWidths: [333, standardWidths[1]],
+      manualWidthIndexes: new Set([0]),
+    });
+
+    expect(comfortableWidths[0]).toBe(333);
+    expect(comfortableWidths[1]).toBeGreaterThan(standardWidths[1]);
+  });
+
+  it("updates the virtual spacer estimate from recalculated density widths", () => {
+    const records = Array.from({ length: 20 }, (_, index) => [`row-${index}-${"x".repeat(20)}`]);
+    const compactWidths = transposeRecordWidthsForDensity({ records, density: "compact" });
+    const comfortableWidths = transposeRecordWidthsForDensity({ records, density: "comfortable" });
+    const compactWindow = visibleTransposeRecordWindow({
+      totalRecords: records.length,
+      scrollLeft: 500,
+      viewportWidth: 400,
+      pinnedWidth: transposeFieldWidth(["field"], { density: "compact" }),
+      recordWidth: averageTransposeRecordWidth(compactWidths, "compact"),
+      overscan: 0,
+    });
+    const comfortableWindow = visibleTransposeRecordWindow({
+      totalRecords: records.length,
+      scrollLeft: 500,
+      viewportWidth: 400,
+      pinnedWidth: transposeFieldWidth(["field"], { density: "comfortable" }),
+      recordWidth: averageTransposeRecordWidth(comfortableWidths, "comfortable"),
+      overscan: 0,
+    });
+
+    expect(averageTransposeRecordWidth(compactWidths, "compact")).toBeLessThan(averageTransposeRecordWidth(comfortableWidths, "comfortable"));
+    expect(compactWindow.beforeWidth).not.toBe(comfortableWindow.beforeWidth);
+    expect(compactWindow.afterWidth).not.toBe(comfortableWindow.afterWidth);
+    expect(averageTransposeRecordWidth([], "compact")).toBe(defaultTransposeRecordWidth("compact"));
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/geometryPreview.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/geometryPreview.spec.ts
new file mode 100644
index 0000000..9741469
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/geometryPreview.spec.ts
@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { wktToGeoJson } from "@/lib/dataGrid/geometryPreview";
+
+describe("wktToGeoJson", () => {
+  it("preserves polygon interior rings", () => {
+    const geometry = wktToGeoJson("POLYGON((0 0,10 0,10 10,0 10,0 0),(2 2,8 2,8 8,2 8,2 2))");
+
+    expect(geometry).toEqual({
+      type: "Polygon",
+      coordinates: [
+        [
+          [0, 0],
+          [10, 0],
+          [10, 10],
+          [0, 10],
+          [0, 0],
+        ],
+        [
+          [2, 2],
+          [8, 2],
+          [8, 8],
+          [2, 8],
+          [2, 2],
+        ],
+      ],
+    });
+  });
+
+  it("preserves multipolygon interior rings", () => {
+    const geometry = wktToGeoJson("MULTIPOLYGON(((0 0,10 0,10 10,0 10,0 0),(2 2,8 2,8 8,2 8,2 2)))");
+
+    expect(geometry).toEqual({
+      type: "MultiPolygon",
+      coordinates: [
+        [
+          [
+            [0, 0],
+            [10, 0],
+            [10, 10],
+            [0, 10],
+            [0, 0],
+          ],
+          [
+            [2, 2],
+            [8, 2],
+            [8, 8],
+            [2, 8],
+            [2, 2],
+          ],
+        ],
+      ],
+    });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/dataGrid/gridSelection.spec.ts b/apps/desktop/src/lib/__tests__/dataGrid/gridSelection.spec.ts
new file mode 100644
index 0000000..eafc1a0
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/dataGrid/gridSelection.spec.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import { formatSelectionAsTsv, summarizeSelection } from "@/lib/dataGrid/gridSelection";
+
+describe("gridSelection", () => {
+  it("formats TSV selections without headers by default", () => {
+    expect(
+      formatSelectionAsTsv({
+        columns: ["id", "name"],
+        rows: [
+          [1, "Ada"],
+          [2, "Lin"],
+        ],
+      }),
+    ).toBe("1\tAda\n2\tLin");
+  });
+
+  it("can include column headers in TSV selections", () => {
+    expect(
+      formatSelectionAsTsv(
+        {
+          columns: ["id", "name"],
+          rows: [
+            [1, "Ada"],
+            [2, "Lin"],
+          ],
+        },
+        true,
+      ),
+    ).toBe("id\tname\n1\tAda\n2\tLin");
+  });
+
+  it("summarizes empty selections", () => {
+    expect(summarizeSelection({ columns: [], rows: [] })).toEqual({
+      cellCount: 0,
+      rowCount: 0,
+      numericCount: 0,
+      sum: 0,
+    });
+  });
+
+  it("summarizes numeric selections", () => {
+    expect(
+      summarizeSelection({
+        columns: ["a", "b"],
+        rows: [
+          [1, 2],
+          [3, 4],
+        ],
+      }),
+    ).toEqual({
+      cellCount: 4,
+      rowCount: 2,
+      numericCount: 4,
+      sum: 10,
+    });
+  });
+
+  it("summarizes numeric strings and ignores non-numeric values", () => {
+    expect(
+      summarizeSelection({
+        columns: ["id", "value", "flag"],
+        rows: [
+          ["100", 2.5, true],
+          [null, "not a number", 3],
+        ],
+      }),
+    ).toEqual({
+      cellCount: 6,
+      rowCount: 2,
+      numericCount: 3,
+      sum: 105.5,
+    });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/database/createDatabaseCharsetOptions.spec.ts b/apps/desktop/src/lib/__tests__/database/createDatabaseCharsetOptions.spec.ts
new file mode 100644
index 0000000..1674d58
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/database/createDatabaseCharsetOptions.spec.ts
@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import { CREATE_DATABASE_CHARSET_OPTIONS, createDatabaseCollationOptionsForCharset, defaultCreateDatabaseCollationForCharset, normalizeCreateDatabaseCharset, parseCreateDatabaseCharsetMetadata, nextCreateDatabaseCollation } from "@/lib/database/createDatabaseCharsetOptions";
+
+describe("createDatabaseCharsetOptions", () => {
+  it("offers common MySQL character sets with utf8mb4 first", () => {
+    expect(CREATE_DATABASE_CHARSET_OPTIONS.slice(0, 4)).toEqual(["utf8mb4", "utf8", "gbk", "latin1"]);
+    expect(CREATE_DATABASE_CHARSET_OPTIONS).toEqual(expect.arrayContaining(["ascii", "big5", "gb2312", "utf16", "utf32"]));
+  });
+
+  it("normalizes typed custom values without changing their case", () => {
+    expect(normalizeCreateDatabaseCharset("  utf8mb3  ")).toBe("utf8mb3");
+    expect(normalizeCreateDatabaseCharset("Big5")).toBe("Big5");
+  });
+
+  it("offers common collations for the selected character set", () => {
+    expect(createDatabaseCollationOptionsForCharset("utf8mb4").slice(0, 3)).toEqual(["utf8mb4_unicode_ci", "utf8mb4_general_ci", "utf8mb4_bin"]);
+    expect(createDatabaseCollationOptionsForCharset("utf8mb4")).toEqual(expect.arrayContaining(["utf8mb4_bin"]));
+    expect(createDatabaseCollationOptionsForCharset("utf8mb4").some((collation) => collation.includes("0900"))).toBe(false);
+    expect(createDatabaseCollationOptionsForCharset("gbk")).toEqual(["gbk_chinese_ci", "gbk_bin"]);
+    expect(createDatabaseCollationOptionsForCharset("utf8")).toEqual(createDatabaseCollationOptionsForCharset("utf8mb3"));
+  });
+
+  it("parses server-provided character sets and collations", () => {
+    const metadata = parseCreateDatabaseCharsetMetadata(
+      {
+        columns: ["Charset", "Description", "Default collation", "Maxlen"],
+        rows: [
+          ["utf8mb4", "UTF-8 Unicode", "utf8mb4_general_ci", 4],
+          ["gbk", "GBK Simplified Chinese", "gbk_chinese_ci", 2],
+        ],
+      },
+      {
+        columns: ["Collation", "Charset", "Id", "Default", "Compiled", "Sortlen"],
+        rows: [
+          ["utf8mb4_general_ci", "utf8mb4", 45, "Yes", "Yes", 1],
+          ["utf8mb4_unicode_ci", "utf8mb4", 224, "", "Yes", 8],
+          ["gbk_chinese_ci", "gbk", 28, "Yes", "Yes", 1],
+        ],
+      },
+    );
+
+    expect(metadata.charsets).toEqual(["utf8mb4", "gbk"]);
+    expect(metadata.collationsByCharset.utf8mb4).toEqual(["utf8mb4_general_ci", "utf8mb4_unicode_ci"]);
+    expect(metadata.collationsByCharset.gbk).toEqual(["gbk_chinese_ci"]);
+  });
+
+  it("keeps server-provided MySQL 8 utf8mb4 collations", () => {
+    const metadata = parseCreateDatabaseCharsetMetadata(
+      {
+        columns: ["Charset", "Description", "Default collation", "Maxlen"],
+        rows: [["utf8mb4", "UTF-8 Unicode", "utf8mb4_0900_ai_ci", 4]],
+      },
+      {
+        columns: ["Collation", "Charset", "Id", "Default", "Compiled", "Sortlen"],
+        rows: [
+          ["utf8mb4_0900_ai_ci", "utf8mb4", 255, "Yes", "Yes", 0],
+          ["utf8mb4_general_ci", "utf8mb4", 45, "", "Yes", 1],
+          ["utf8mb4_unicode_ci", "utf8mb4", 224, "", "Yes", 8],
+          ["utf8mb4_unicode_520_ci", "utf8mb4", 246, "", "Yes", 8],
+          ["utf8mb4_bin", "utf8mb4", 46, "", "Yes", 1],
+        ],
+      },
+    );
+
+    expect(metadata.collationsByCharset.utf8mb4).toEqual(["utf8mb4_0900_ai_ci", "utf8mb4_general_ci", "utf8mb4_unicode_ci", "utf8mb4_unicode_520_ci", "utf8mb4_bin"]);
+  });
+
+  it("keeps custom collations unless the previous value was the old charset default", () => {
+    expect(defaultCreateDatabaseCollationForCharset("latin1")).toBe("latin1_swedish_ci");
+    expect(nextCreateDatabaseCollation("gbk", "utf8mb4", "utf8mb4_unicode_ci")).toBe("gbk_chinese_ci");
+    expect(nextCreateDatabaseCollation("gbk", "utf8mb4", "custom_ci")).toBe("custom_ci");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/database/damengJobAdmin.spec.ts b/apps/desktop/src/lib/__tests__/database/damengJobAdmin.spec.ts
new file mode 100644
index 0000000..f9f9eae
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/database/damengJobAdmin.spec.ts
@@ -0,0 +1,92 @@
+import { describe, expect, it } from "vitest";
+import { damengCreateJobSql, damengEnableJobSql, damengJobHistoriesSql, damengJobListSql, damengJobStepsSql, damengRunJobSql, isDamengJobEnvironmentMissingError, parseDamengJobEnvironmentReady, parseDamengJobs, quoteDamengString } from "@/lib/database/damengJobAdmin";
+import type { QueryResult } from "@/types/database";
+
+describe("damengJobAdmin", () => {
+  it("quotes Dameng string literals", () => {
+    expect(quoteDamengString("job's test")).toBe("'job''s test'");
+  });
+
+  it("builds job action sql with quoted names", () => {
+    expect(damengEnableJobSql("JOB_A", false)).toBe("SP_ENABLE_JOB('JOB_A', 0);");
+    expect(damengJobStepsSql("12")).toBe("SELECT * FROM SYSJOB.USER_JOBSTEPS_VIEW WHERE JOBID = 12");
+    expect(damengJobStepsSql("12", true)).toBe("SELECT * FROM SYSJOB.SYSJOBSTEPS WHERE JOBID = 12");
+    expect(damengJobHistoriesSql({ id: "12", name: "JOB'A" }, true)).toBe("SELECT * FROM SYSJOB.SYSJOBHISTORIES2 WHERE JOBID = 12");
+    expect(damengRunJobSql("12")).toBe("SP_DBMS_JOB_RUN_ASYNC(12);");
+  });
+
+  it("avoids DBA running view for normal user job list", () => {
+    expect(damengJobListSql()).toContain("FROM SYSJOB.USER_JOBS_VIEW J");
+    expect(damengJobListSql()).toContain("0 AS RUNNING");
+    expect(damengJobListSql()).not.toContain("DBA_JOBS_RUNNING");
+  });
+
+  it("uses system job tables with running state for SYSDBA job list", () => {
+    expect(damengJobListSql(true)).toContain("FROM SYSJOB.SYSJOBS J");
+    expect(damengJobListSql(true)).toContain("SYSJOB.DBA_JOBS_RUNNING");
+  });
+
+  it("builds simple sql job creation script", () => {
+    const sql = damengCreateJobSql({
+      name: "JOB_TEST",
+      enabled: true,
+      description: "demo",
+      stepName: "STEP1",
+      command: "SELECT 1;",
+      scheduleName: "SCHEDULE1",
+      scheduleMode: "daily",
+      startDate: "CURDATE",
+      startTime: "00:00:00",
+      minuteInterval: 5,
+    });
+
+    expect(sql).toContain("SP_CREATE_JOB('JOB_TEST', 1");
+    expect(sql).toContain("SP_ADD_JOB_STEP('JOB_TEST', 'STEP1', 0, 'SELECT 1;', 1, 1, 0, 0, NULL, 0);");
+    expect(sql).toContain("SP_ADD_JOB_SCHEDULE('JOB_TEST', 'SCHEDULE1', 1, 1, 1, 0, 5, '00:00:00', NULL, CURDATE, NULL, '');");
+    expect(sql).toContain("SP_JOB_CONFIG_COMMIT('JOB_TEST');");
+  });
+
+  it("parses job rows case-insensitively", () => {
+    const result: QueryResult = {
+      columns: ["id", "name", "enable", "username", "valid", "describe", "running", "running_sid"],
+      rows: [[12, "JOB_TEST", 1, "SYSDBA", "Y", "demo", 1, 1234]],
+      affected_rows: 0,
+      execution_time_ms: 1,
+    };
+
+    expect(parseDamengJobs(result)).toEqual([
+      {
+        id: "12",
+        name: "JOB_TEST",
+        enabled: true,
+        running: true,
+        runningSid: "1234",
+        owner: "SYSDBA",
+        valid: "Y",
+        createdAt: "",
+        modifiedAt: "",
+        description: "demo",
+        raw: {
+          id: 12,
+          name: "JOB_TEST",
+          enable: 1,
+          username: "SYSDBA",
+          valid: "Y",
+          describe: "demo",
+          running: 1,
+          running_sid: 1234,
+        },
+      },
+    ]);
+  });
+
+  it("parses job environment availability", () => {
+    expect(parseDamengJobEnvironmentReady({ columns: ["CNT"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 })).toBe(true);
+    expect(parseDamengJobEnvironmentReady({ columns: ["CNT"], rows: [[0]], affected_rows: 0, execution_time_ms: 1 })).toBe(false);
+  });
+
+  it("detects missing SYSJOB schema errors", () => {
+    expect(isDamengJobEnvironmentMissingError("无效的模式名[SYSJOB]")).toBe(true);
+    expect(isDamengJobEnvironmentMissingError("invalid schema name SYSJOB")).toBe(true);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/database/databaseDriverManifest.spec.ts b/apps/desktop/src/lib/__tests__/database/databaseDriverManifest.spec.ts
new file mode 100644
index 0000000..946e262
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/database/databaseDriverManifest.spec.ts
@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { databaseRuntimeMode, usesAgentCursorForQuery } from "@/lib/database/databaseDriverManifest";
+
+describe("databaseDriverManifest", () => {
+  it("uses agent cursor only for agent or external runtimes", () => {
+    expect(databaseRuntimeMode("gaussdb")).toBe("native");
+    expect(usesAgentCursorForQuery("gaussdb")).toBe(false);
+    expect(usesAgentCursorForQuery("mysql")).toBe(false);
+    expect(usesAgentCursorForQuery("jdbc")).toBe(true);
+    expect(usesAgentCursorForQuery("prestosql")).toBe(true);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/database/databaseFeatureSupport.spec.ts b/apps/desktop/src/lib/__tests__/database/databaseFeatureSupport.spec.ts
new file mode 100644
index 0000000..8bd1d8f
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/database/databaseFeatureSupport.spec.ts
@@ -0,0 +1,130 @@
+import { describe, expect, it } from "vitest";
+import { connectionNamespaceCreationTarget, databaseNodeNamespaceCreationTarget } from "@/lib/database/databaseNamespaceCreation";
+import { editableDatabasePropertyGroups, editableSchemaPropertyGroups } from "@/lib/database/databasePropertyEditing";
+import { buildGetDatabaseCommentSql } from "@/lib/database/dbAdminSql";
+import { supportsSqlInListPaste, supportsTransaction } from "@/lib/database/databaseFeatureSupport";
+
+describe("supportsTransaction", () => {
+  it("returns true for supported database types", () => {
+    expect(supportsTransaction("postgres")).toBe(true);
+    expect(supportsTransaction("mysql")).toBe(true);
+  });
+
+  it("returns false for unsupported database types", () => {
+    expect(supportsTransaction("redis")).toBe(false);
+    expect(supportsTransaction("mongodb")).toBe(false);
+    expect(supportsTransaction("duckdb")).toBe(false);
+    expect(supportsTransaction("qdrant")).toBe(false);
+    expect(supportsTransaction("turso")).toBe(false);
+    expect(supportsTransaction("cloudflare-d1")).toBe(false);
+    expect(supportsTransaction("sqlite")).toBe(false);
+    expect(supportsTransaction("clickhouse")).toBe(false);
+    expect(supportsTransaction("sqlserver")).toBe(false);
+    expect(supportsTransaction("oracle")).toBe(false);
+    expect(supportsTransaction("dameng")).toBe(false);
+    expect(supportsTransaction("rqlite")).toBe(false);
+    expect(supportsTransaction("agent")).toBe(false);
+  });
+
+  it("returns false for undefined or empty input", () => {
+    expect(supportsTransaction(undefined)).toBe(false);
+  });
+});
+
+describe("supportsSqlInListPaste", () => {
+  it("allows generic and SQL-like editors", () => {
+    expect(supportsSqlInListPaste(undefined)).toBe(true);
+    expect(supportsSqlInListPaste("mysql")).toBe(true);
+    expect(supportsSqlInListPaste("postgres")).toBe(true);
+    expect(supportsSqlInListPaste("oracle")).toBe(true);
+    expect(supportsSqlInListPaste("sqlserver")).toBe(true);
+    expect(supportsSqlInListPaste("sqlite")).toBe(true);
+    expect(supportsSqlInListPaste("cassandra")).toBe(true);
+    expect(supportsSqlInListPaste("tdengine")).toBe(true);
+    expect(supportsSqlInListPaste("iotdb")).toBe(true);
+    expect(supportsSqlInListPaste("jdbc")).toBe(true);
+  });
+
+  it("hides SQL IN list paste in non-SQL editors", () => {
+    expect(supportsSqlInListPaste("redis")).toBe(false);
+    expect(supportsSqlInListPaste("mongodb")).toBe(false);
+    expect(supportsSqlInListPaste("elasticsearch")).toBe(false);
+    expect(supportsSqlInListPaste("qdrant")).toBe(false);
+    expect(supportsSqlInListPaste("milvus")).toBe(false);
+    expect(supportsSqlInListPaste("weaviate")).toBe(false);
+    expect(supportsSqlInListPaste("chromadb")).toBe(false);
+    expect(supportsSqlInListPaste("etcd")).toBe(false);
+    expect(supportsSqlInListPaste("zookeeper")).toBe(false);
+    expect(supportsSqlInListPaste("mq")).toBe(false);
+    expect(supportsSqlInListPaste("nacos")).toBe(false);
+  });
+
+  it("excludes Neo4j because Cypher uses list syntax instead of SQL IN tuples", () => {
+    expect(supportsSqlInListPaste("neo4j")).toBe(false);
+  });
+});
+
+describe("database property editing", () => {
+  it("allows MySQL-compatible charset and collation edits on database nodes", () => {
+    expect(editableDatabasePropertyGroups({ db_type: "mysql" }, { type: "database", database: "app" })).toEqual(["charsetCollation"]);
+    expect(editableDatabasePropertyGroups({ db_type: "goldendb" }, { type: "database", database: "app" })).toEqual(["charsetCollation"]);
+    expect(editableDatabasePropertyGroups({ db_type: "jdbc", driver_profile: "mysql" }, { type: "database", database: "app" })).toEqual([]);
+  });
+
+  it("allows PostgreSQL-style comment edits on supported database and schema nodes", () => {
+    expect(editableDatabasePropertyGroups({ db_type: "postgres" }, { type: "database", database: "postgres" })).toEqual(["databaseComment"]);
+    expect(editableDatabasePropertyGroups({ db_type: "kingbase" }, { type: "database", database: "TEST" })).toEqual(["databaseComment"]);
+    expect(editableSchemaPropertyGroups({ db_type: "postgres" }, { type: "schema", database: "postgres", schema: "public" })).toEqual(["schemaComment"]);
+    expect(editableSchemaPropertyGroups({ db_type: "highgo" }, { type: "schema", database: "postgres", schema: "public" })).toEqual(["schemaComment"]);
+  });
+
+  it("hides property editing for read-only, unsupported, and wrong tree nodes", () => {
+    expect(editableDatabasePropertyGroups({ db_type: "mysql", read_only: true }, { type: "database", database: "app" })).toEqual([]);
+    expect(editableDatabasePropertyGroups({ db_type: "sqlite" }, { type: "database", database: "main" })).toEqual([]);
+    expect(editableDatabasePropertyGroups({ db_type: "sqlserver" }, { type: "database", database: "master" })).toEqual([]);
+    expect(editableDatabasePropertyGroups({ db_type: "postgres" }, { type: "connection" })).toEqual([]);
+    expect(editableSchemaPropertyGroups({ db_type: "postgres", read_only: true }, { type: "schema", database: "postgres", schema: "public" })).toEqual([]);
+    expect(editableSchemaPropertyGroups({ db_type: "postgres" }, { type: "database", database: "postgres" })).toEqual([]);
+  });
+
+  it("queries PostgreSQL database comments from shared object descriptions", () => {
+    expect(buildGetDatabaseCommentSql({ databaseType: "postgres", name: "app" })).toContain("shobj_description(db.oid, 'pg_database')");
+  });
+});
+
+describe("database namespace creation", () => {
+  it("allows connection-level database creation for verified database targets", () => {
+    expect(connectionNamespaceCreationTarget({ db_type: "mysql" })).toBe("database");
+    expect(connectionNamespaceCreationTarget({ db_type: "sqlserver" })).toBe("database");
+    expect(connectionNamespaceCreationTarget({ db_type: "clickhouse" })).toBe("database");
+    expect(connectionNamespaceCreationTarget({ db_type: "snowflake" })).toBe("database");
+    expect(connectionNamespaceCreationTarget({ db_type: "databend" })).toBe("database");
+    expect(connectionNamespaceCreationTarget({ db_type: "tdengine" })).toBe("database");
+  });
+
+  it("keeps non-database creation flows explicit", () => {
+    expect(connectionNamespaceCreationTarget({ db_type: "dameng" })).toBe("schema");
+    expect(connectionNamespaceCreationTarget({ db_type: "duckdb" })).toBe("attach");
+    expect(connectionNamespaceCreationTarget({ db_type: "mongodb" })).toBe("special");
+    expect(connectionNamespaceCreationTarget({ db_type: "mongodb", driver_profile: "mongodb-legacy" })).toBeNull();
+  });
+
+  it("hides creation for read-only, file-only, and unknown generic targets", () => {
+    expect(connectionNamespaceCreationTarget({ db_type: "mysql", read_only: true })).toBeNull();
+    expect(connectionNamespaceCreationTarget({ db_type: "sqlite" })).toBeNull();
+    expect(connectionNamespaceCreationTarget({ db_type: "jdbc" })).toBeNull();
+    expect(connectionNamespaceCreationTarget({ db_type: "oracle" })).toBeNull();
+  });
+
+  it("allows schema creation only on writable database nodes with schema targets", () => {
+    expect(databaseNodeNamespaceCreationTarget({ db_type: "postgres" }, { type: "database", database: "postgres" })).toBe("schema");
+    expect(databaseNodeNamespaceCreationTarget({ db_type: "sqlserver" }, { type: "database", database: "master" })).toBe("schema");
+    expect(databaseNodeNamespaceCreationTarget({ db_type: "db2" }, { type: "database", database: "SAMPLE" })).toBe("schema");
+    expect(databaseNodeNamespaceCreationTarget({ db_type: "postgres", read_only: true }, { type: "database", database: "postgres" })).toBeNull();
+    expect(databaseNodeNamespaceCreationTarget({ db_type: "postgres" }, { type: "connection" })).toBeNull();
+    expect(databaseNodeNamespaceCreationTarget({ db_type: "mysql" }, { type: "database", database: "app" })).toBeNull();
+    expect(databaseNodeNamespaceCreationTarget({ db_type: "goldendb" }, { type: "database", database: "app" })).toBeNull();
+    expect(databaseNodeNamespaceCreationTarget({ db_type: "duckdb" }, { type: "database", database: "main" })).toBeNull();
+    expect(databaseNodeNamespaceCreationTarget({ db_type: "jdbc" }, { type: "database", database: "main" })).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts b/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts
new file mode 100644
index 0000000..097f767
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/database/databaseObjectCapabilities.spec.ts
@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { normalizeSidebarObjectKind, sidebarObjectKindsForDatabase } from "@/lib/database/databaseObjectCapabilities";
+
+describe("databaseObjectCapabilities", () => {
+  it("exposes materialized views for Dameng", () => {
+    expect(sidebarObjectKindsForDatabase("dameng")).toContain("MATERIALIZED_VIEW");
+  });
+
+  it("normalizes space separated materialized view types", () => {
+    expect(normalizeSidebarObjectKind("MATERIALIZED VIEW")).toBe("MATERIALIZED_VIEW");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/database/databaseUserAdmin.spec.ts b/apps/desktop/src/lib/__tests__/database/databaseUserAdmin.spec.ts
new file mode 100644
index 0000000..7ed5862
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/database/databaseUserAdmin.spec.ts
@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { getDatabaseUserAdminProvider, kingbaseShowGrantsSql } from "@/lib/database/databaseUserAdmin";
+
+describe("database user admin providers", () => {
+  it("uses sys_catalog for Kingbase role metadata", () => {
+    const provider = getDatabaseUserAdminProvider("kingbase");
+
+    expect(provider).not.toBeNull();
+    expect(provider?.dialect).toBe("postgres");
+    expect(provider?.listUsersSql()).toContain("FROM sys_catalog.sys_roles r");
+    expect(provider?.listUsersSql()).not.toContain("pg_catalog");
+  });
+
+  it("builds Kingbase grant SQL without PostgreSQL catalog tables", () => {
+    const sql = kingbaseShowGrantsSql({ user: "role'o", host: "LOGIN" });
+
+    expect(sql).toContain("FROM sys_catalog.sys_roles r");
+    expect(sql).toContain("FROM sys_catalog.sys_auth_members m");
+    expect(sql).toContain("CROSS JOIN sys_catalog.sys_database d");
+    expect(sql).toContain("CROSS JOIN sys_catalog.sys_namespace n");
+    expect(sql).toContain("WHERE r.rolname = 'role''o'");
+    expect(sql).not.toContain("pg_catalog");
+    expect(sql).not.toContain("pg_roles");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/database/defaultDatabase.spec.ts b/apps/desktop/src/lib/__tests__/database/defaultDatabase.spec.ts
new file mode 100644
index 0000000..de584c5
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/database/defaultDatabase.spec.ts
@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { decodeSelectableDatabaseValue, EMPTY_DATABASE_SELECT_VALUE, encodeSelectableDatabaseValue, TREE_SCHEMA_DEFAULT_DATABASE_SELECT_VALUE } from "@/lib/database/defaultDatabase";
+
+describe("defaultDatabase selectable values", () => {
+  it("encodes empty tree-schema databases with the default database sentinel", () => {
+    expect(encodeSelectableDatabaseValue("postgres", "")).toBe(TREE_SCHEMA_DEFAULT_DATABASE_SELECT_VALUE);
+    expect(decodeSelectableDatabaseValue("postgres", TREE_SCHEMA_DEFAULT_DATABASE_SELECT_VALUE)).toBe("");
+  });
+
+  it("encodes empty non-tree-schema databases with a non-empty sentinel", () => {
+    expect(encodeSelectableDatabaseValue("access", "")).toBe(EMPTY_DATABASE_SELECT_VALUE);
+    expect(decodeSelectableDatabaseValue("access", EMPTY_DATABASE_SELECT_VALUE)).toBe("");
+  });
+
+  it("preserves non-empty database names", () => {
+    expect(encodeSelectableDatabaseValue("access", "653128SXB.mdb")).toBe("653128SXB.mdb");
+    expect(decodeSelectableDatabaseValue("access", "653128SXB.mdb")).toBe("653128SXB.mdb");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/database/dorisCatalogCapability.spec.ts b/apps/desktop/src/lib/__tests__/database/dorisCatalogCapability.spec.ts
new file mode 100644
index 0000000..5420839
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/database/dorisCatalogCapability.spec.ts
@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { connectionIsDorisFamilyCatalogCapable, isDorisFamilyCatalogCapable, isInternalDorisCatalog } from "@/lib/database/databaseFeatureSupport";
+import type { ConnectionConfig } from "@/types/database";
+
+function conn(db_type: ConnectionConfig["db_type"], driver_profile?: string | null): Pick<ConnectionConfig, "db_type" | "driver_profile"> {
+  return { db_type, driver_profile: driver_profile ?? null };
+}
+
+describe("isDorisFamilyCatalogCapable", () => {
+  it("matches Doris and StarRocks by db_type", () => {
+    expect(isDorisFamilyCatalogCapable("doris")).toBe(true);
+    expect(isDorisFamilyCatalogCapable("starrocks")).toBe(true);
+  });
+
+  it("matches Doris / SelectDB / StarRocks driver profiles", () => {
+    expect(isDorisFamilyCatalogCapable("mysql", "doris")).toBe(true);
+    expect(isDorisFamilyCatalogCapable("mysql", "selectdb")).toBe(true);
+    expect(isDorisFamilyCatalogCapable("mysql", "starrocks")).toBe(true);
+  });
+
+  it("excludes ManticoreSearch (no catalog concept)", () => {
+    expect(isDorisFamilyCatalogCapable("manticoresearch")).toBe(false);
+    expect(isDorisFamilyCatalogCapable("mysql", "manticoresearch")).toBe(false);
+  });
+
+  it("excludes plain MySQL / Postgres", () => {
+    expect(isDorisFamilyCatalogCapable("mysql")).toBe(false);
+    expect(isDorisFamilyCatalogCapable("postgres")).toBe(false);
+  });
+});
+
+describe("connectionIsDorisFamilyCatalogCapable", () => {
+  it("returns false for undefined connection", () => {
+    expect(connectionIsDorisFamilyCatalogCapable(undefined)).toBe(false);
+  });
+
+  it("returns true for a Doris connection", () => {
+    expect(connectionIsDorisFamilyCatalogCapable(conn("doris"))).toBe(true);
+  });
+
+  it("returns false for a plain MySQL connection", () => {
+    expect(connectionIsDorisFamilyCatalogCapable(conn("mysql"))).toBe(false);
+  });
+});
+
+describe("isInternalDorisCatalog", () => {
+  it("detects Doris internal catalog by type", () => {
+    expect(isInternalDorisCatalog("internal", "internal")).toBe(true);
+  });
+
+  it("detects StarRocks internal catalog by type (case-insensitive)", () => {
+    expect(isInternalDorisCatalog("Internal", "default_catalog")).toBe(true);
+    expect(isInternalDorisCatalog("INTERNAL", "default_catalog")).toBe(true);
+  });
+
+  it("treats external catalogs as non-internal", () => {
+    expect(isInternalDorisCatalog("iceberg", "iceberg_catalog")).toBe(false);
+    expect(isInternalDorisCatalog("hive", "hive_catalog")).toBe(false);
+    // A catalog literally named `internal` but with an external type is not built-in.
+    expect(isInternalDorisCatalog("iceberg", "internal")).toBe(false);
+  });
+
+  it("falls back to the Doris name when the type is absent", () => {
+    expect(isInternalDorisCatalog("", "internal")).toBe(true);
+    expect(isInternalDorisCatalog(null, "internal")).toBe(true);
+    expect(isInternalDorisCatalog("", "default_catalog")).toBe(false);
+    expect(isInternalDorisCatalog(undefined, undefined)).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/database/jdbcDialect.spec.ts b/apps/desktop/src/lib/__tests__/database/jdbcDialect.spec.ts
new file mode 100644
index 0000000..8c4ccdf
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/database/jdbcDialect.spec.ts
@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { connectionQueryExecutionSchema, effectiveDatabaseTypeForConnection, inferJdbcDialect } from "@/lib/database/jdbcDialect";
+
+describe("jdbc dialect inference", () => {
+  it("detects InterSystems IRIS and Caché JDBC connections", () => {
+    expect(
+      inferJdbcDialect({
+        db_type: "jdbc",
+        connection_string: "jdbc:IRIS://localhost:1972/USER",
+      }),
+    ).toBe("iris");
+    expect(
+      inferJdbcDialect({
+        db_type: "jdbc",
+        connection_string: "jdbc:Cache://localhost:1972/USER",
+      }),
+    ).toBe("iris");
+    expect(
+      inferJdbcDialect({
+        db_type: "jdbc",
+        jdbc_driver_class: "com.intersystems.jdbc.IRISDriver",
+      }),
+    ).toBe("iris");
+    expect(
+      inferJdbcDialect({
+        db_type: "jdbc",
+        jdbc_driver_paths: ["/drivers/intersystems-jdbc-3.10.5.jar"],
+      }),
+    ).toBe("iris");
+  });
+
+  it("uses IRIS table preview dialect for generic JDBC IRIS connections", () => {
+    expect(
+      effectiveDatabaseTypeForConnection({
+        db_type: "jdbc",
+        connection_string: "jdbc:IRIS://localhost:1972/USER",
+      }),
+    ).toBe("iris");
+  });
+
+  it("uses JDBC driver profiles when inferring dialect", () => {
+    expect(
+      inferJdbcDialect({
+        db_type: "jdbc",
+        driver_profile: "sqlserver",
+      }),
+    ).toBe("sqlserver");
+  });
+});
+
+describe("query execution schema", () => {
+  it.each(["spark", "hive"] as const)("uses the selected database as the %s execution schema", (dbType) => {
+    expect(connectionQueryExecutionSchema({ db_type: dbType }, "ai_test", undefined, false)).toBe("ai_test");
+  });
+
+  it("prefers an explicit schema for PostgreSQL", () => {
+    expect(connectionQueryExecutionSchema({ db_type: "postgres" }, "app", "reporting", false)).toBe("reporting");
+  });
+
+  it("does not send a schema for MySQL database context", () => {
+    expect(connectionQueryExecutionSchema({ db_type: "mysql" }, "app", undefined, false)).toBeUndefined();
+  });
+
+  it("does not change data-tab execution context", () => {
+    expect(connectionQueryExecutionSchema({ db_type: "spark" }, "ai_test", undefined, true)).toBeUndefined();
+  });
+
+  it("keeps generic JDBC Databend schema fallback", () => {
+    expect(connectionQueryExecutionSchema({ db_type: "jdbc", connection_string: "jdbc:databend://localhost:8000/default" }, "analytics", undefined, false)).toBe("analytics");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/database/mysqlConnectionOptions.spec.ts b/apps/desktop/src/lib/__tests__/database/mysqlConnectionOptions.spec.ts
new file mode 100644
index 0000000..69b087d
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/database/mysqlConnectionOptions.spec.ts
@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { mysqlCleartextPasswordAuthEnabled, setMysqlCleartextPasswordAuthEnabled } from "@/lib/database/mysqlConnectionOptions";
+
+describe("mysqlConnectionOptions", () => {
+  it("detects cleartext password auth aliases", () => {
+    expect(mysqlCleartextPasswordAuthEnabled("allowCleartextPasswords=true")).toBe(true);
+    expect(mysqlCleartextPasswordAuthEnabled("enable_cleartext_plugin=true")).toBe(true);
+    expect(mysqlCleartextPasswordAuthEnabled("?AllowCleartextPasswords=TRUE")).toBe(true);
+    expect(mysqlCleartextPasswordAuthEnabled("allowCleartextPasswords=false")).toBe(false);
+  });
+
+  it("enables the canonical cleartext password auth param and removes aliases", () => {
+    expect(setMysqlCleartextPasswordAuthEnabled("allowCleartextPasswords=true&charset=utf8mb4", true)).toBe("charset=utf8mb4&enable_cleartext_plugin=true");
+  });
+
+  it("disables cleartext password auth params while preserving unrelated params", () => {
+    expect(setMysqlCleartextPasswordAuthEnabled("allowCleartextPasswords=true&enable_cleartext_plugin=true&charset=utf8mb4&connect_timeout=10", false)).toBe("charset=utf8mb4&connect_timeout=10");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/database/prestoSqlBuiltinDriver.spec.ts b/apps/desktop/src/lib/__tests__/database/prestoSqlBuiltinDriver.spec.ts
new file mode 100644
index 0000000..e3dab87
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/database/prestoSqlBuiltinDriver.spec.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { PRESTOSQL_JDBC_DRIVER_COORDINATE, prestoSqlBuiltinDriverPaths, prestoSqlBuiltinDriverRow, prestoSqlMavenBundle } from "@/lib/database/prestoSqlBuiltinDriver";
+import type { JdbcMavenBundleInfo } from "@/types/database";
+
+function bundle(coordinate: string, version = "350"): JdbcMavenBundleInfo {
+  return {
+    id: `bundle:${coordinate}`,
+    coordinate,
+    scope: "runtime",
+    repositories: ["https://repo.maven.apache.org/maven2/"],
+    installed_at: "2026-06-18T00:00:00Z",
+    path: "drivers/jdbc",
+    artifacts: [
+      {
+        group_id: "io.prestosql",
+        artifact_id: "presto-jdbc",
+        version,
+        classifier: "",
+        extension: "jar",
+        file_name: `presto-jdbc-${version}.jar`,
+        path: `drivers/jdbc/presto-jdbc-${version}.jar`,
+        size: 12_345,
+        sha256: "abc",
+      },
+    ],
+  };
+}
+
+describe("prestoSqlBuiltinDriver", () => {
+  it("adds an uninstalled PrestoSQL row when the Maven bundle is absent", () => {
+    const row = prestoSqlBuiltinDriverRow([]);
+
+    expect(row.db_type).toBe("prestosql");
+    expect(row.label).toBe("PrestoSQL");
+    expect(row.version).toBe("350");
+    expect(row.installed).toBe(false);
+    expect(row.installed_version).toBeNull();
+    expect(row.jre).toBe("21");
+  });
+
+  it("marks PrestoSQL installed when its Maven coordinate is present", () => {
+    const installed = bundle(PRESTOSQL_JDBC_DRIVER_COORDINATE);
+    const row = prestoSqlBuiltinDriverRow([bundle("com.mysql:mysql-connector-j:9.2.0"), installed]);
+
+    expect(prestoSqlMavenBundle([installed])?.id).toBe(installed.id);
+    expect(prestoSqlBuiltinDriverPaths([installed])).toEqual(["drivers/jdbc/presto-jdbc-350.jar"]);
+    expect(row.installed).toBe(true);
+    expect(row.installed_version).toBe("350");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/editor/codemirrorSqlDialect.spec.ts b/apps/desktop/src/lib/__tests__/editor/codemirrorSqlDialect.spec.ts
new file mode 100644
index 0000000..f728d2d
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/editor/codemirrorSqlDialect.spec.ts
@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { PostgreSQL } from "@codemirror/lang-sql";
+import { postgresKeywordSyntaxTerms } from "@/lib/editor/codemirrorSqlDialect";
+
+describe("codemirrorSqlDialect", () => {
+  it("keeps common PostgreSQL identifier names out of keyword highlighting", () => {
+    const keywords = new Set(postgresKeywordSyntaxTerms(PostgreSQL.spec.keywords || "").split(/\s+/));
+
+    expect(keywords.has("select")).toBe(true);
+    expect(keywords.has("from")).toBe(true);
+    expect(keywords.has("where")).toBe(true);
+    expect(keywords.has("id")).toBe(false);
+    expect(keywords.has("name")).toBe(false);
+    expect(keywords.has("user")).toBe(false);
+    expect(keywords.has("count")).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/editor/editorSearchQuery.spec.ts b/apps/desktop/src/lib/__tests__/editor/editorSearchQuery.spec.ts
new file mode 100644
index 0000000..fc33d28
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/editor/editorSearchQuery.spec.ts
@@ -0,0 +1,28 @@
+import { EditorState } from "@codemirror/state";
+import { describe, expect, it } from "vitest";
+import { createEditorSearchQuery } from "@/lib/editor/editorSearchQuery";
+
+function matchedText(search: string, useRegex: boolean): string[] {
+  const state = EditorState.create({
+    doc: String.raw`SELECT '\n' AS escaped;
+SELECT 1 AS actual_line_break;`,
+  });
+  const cursor = createEditorSearchQuery({ search, caseSensitive: false, useRegex }).getCursor(state);
+  const matches: string[] = [];
+
+  for (let result = cursor.next(); !result.done; result = cursor.next()) {
+    matches.push(state.sliceDoc(result.value.from, result.value.to));
+  }
+
+  return matches;
+}
+
+describe("editorSearchQuery", () => {
+  it("treats escape sequences literally in normal search mode", () => {
+    expect(matchedText(String.raw`\n`, false)).toEqual([String.raw`\n`]);
+  });
+
+  it("allows regular expression mode to match actual line breaks", () => {
+    expect(matchedText(String.raw`\n`, true)).toEqual(["\n"]);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/editor/keyboardShortcuts.spec.ts b/apps/desktop/src/lib/__tests__/editor/keyboardShortcuts.spec.ts
new file mode 100644
index 0000000..0e6ea61
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/editor/keyboardShortcuts.spec.ts
@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { eventToShortcut, matchesShortcut } from "@/lib/editor/keyboardShortcuts";
+
+describe("keyboard shortcut matching", () => {
+  it("records the plus key without losing it to the separator", () => {
+    expect(eventToShortcut({ key: "+", ctrlKey: true })).toBe("Mod+Plus");
+    expect(eventToShortcut({ key: "+", ctrlKey: true, shiftKey: true })).toBe("Shift+Mod+Plus");
+  });
+
+  it("matches canonical plus-key shortcuts", () => {
+    expect(matchesShortcut({ key: "+", ctrlKey: true }, "Mod+Plus")).toBe(true);
+    expect(matchesShortcut({ key: "+", ctrlKey: true, shiftKey: true }, "Shift+Mod+Plus")).toBe(true);
+  });
+
+  it("matches legacy plus-key shortcuts saved with plus as a separator", () => {
+    expect(matchesShortcut({ key: "+", ctrlKey: true }, "Mod++")).toBe(true);
+    expect(matchesShortcut({ key: "+", ctrlKey: true, shiftKey: true }, "Shift+Mod++")).toBe(true);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/editor/queryEditorPointerSelection.spec.ts b/apps/desktop/src/lib/__tests__/editor/queryEditorPointerSelection.spec.ts
new file mode 100644
index 0000000..da263ec
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/editor/queryEditorPointerSelection.spec.ts
@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { startsQueryEditorRectangularSelection } from "@/lib/editor/queryEditorPointerSelection";
+
+describe("query editor pointer selection", () => {
+  it("starts rectangular selection for Alt+left drag", () => {
+    expect(startsQueryEditorRectangularSelection({ altKey: true, button: 0 })).toBe(true);
+  });
+
+  it("starts rectangular selection for middle-button drag", () => {
+    expect(startsQueryEditorRectangularSelection({ altKey: false, button: 1 })).toBe(true);
+  });
+
+  it("leaves ordinary left clicks to the normal cursor handler", () => {
+    expect(startsQueryEditorRectangularSelection({ altKey: false, button: 0 })).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/editor/queryEditorTableDrop.spec.ts b/apps/desktop/src/lib/__tests__/editor/queryEditorTableDrop.spec.ts
new file mode 100644
index 0000000..5a1209b
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/editor/queryEditorTableDrop.spec.ts
@@ -0,0 +1,27 @@
+import { describe, expect, it } from "vitest";
+import { createTableReferencePayload, parseTableReferencePayload, tableReferenceInsertText } from "@/lib/editor/queryEditorTableDrop";
+
+describe("query editor table reference drop", () => {
+  it("inserts a quoted database name for database references", () => {
+    const payload = createTableReferencePayload({
+      connectionId: "conn-1",
+      database: "app-db",
+      referenceType: "database",
+      databaseType: "mysql",
+    });
+
+    expect(payload).not.toBeNull();
+    expect(tableReferenceInsertText(payload!)).toBe("`app-db`");
+  });
+
+  it("round-trips database reference payloads", () => {
+    const payload = createTableReferencePayload({
+      connectionId: "conn-1",
+      database: "reporting",
+      referenceType: "database",
+      databaseType: "postgres",
+    })!;
+
+    expect(parseTableReferencePayload(JSON.stringify(payload))).toEqual(payload);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/editor/shortcutDisplay.spec.ts b/apps/desktop/src/lib/__tests__/editor/shortcutDisplay.spec.ts
new file mode 100644
index 0000000..e6e6de3
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/editor/shortcutDisplay.spec.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { formatShortcutDisplay, shortcutDisplayKeys } from "@/lib/editor/shortcutDisplay";
+
+describe("shortcut display", () => {
+  it("uses readable modifier labels on Windows", () => {
+    expect(shortcutDisplayKeys("Shift+Alt+U", "Win32")).toEqual(["Shift", "Alt", "U"]);
+  });
+
+  it("uses readable modifier labels on Linux", () => {
+    expect(shortcutDisplayKeys("Ctrl+Alt+Delete", "Linux x86_64")).toEqual(["Ctrl", "Alt", "Del"]);
+  });
+
+  it("uses Apple platform glyphs on macOS", () => {
+    expect(shortcutDisplayKeys("Mod+Alt+Enter", "MacIntel")).toEqual(["⌘", "⌥", "↵"]);
+  });
+
+  it("formats shortcut pills with platform separators", () => {
+    expect(formatShortcutDisplay("Shift+Alt+ArrowUp", "Win32")).toBe("Shift + Alt + ↑");
+    expect(formatShortcutDisplay("Shift+Alt+ArrowUp", "MacIntel")).toBe("⇧ ⌥ ↑");
+    expect(formatShortcutDisplay("Mod+Delete", "MacIntel")).toBe("⌘ ⌦");
+  });
+
+  it("orders Ctrl before Shift on Windows", () => {
+    expect(formatShortcutDisplay("Shift+Mod+F", "Win32")).toBe("Ctrl + Shift + F");
+    expect(formatShortcutDisplay("Shift+Mod+K", "Win32")).toBe("Ctrl + Shift + K");
+    expect(formatShortcutDisplay("Shift+Mod+Z", "Win32")).toBe("Ctrl + Shift + Z");
+  });
+
+  it("keeps macOS modifier order and glyphs", () => {
+    expect(formatShortcutDisplay("Shift+Mod+F", "MacIntel")).toBe("⇧ ⌘ F");
+  });
+
+  it("displays canonical and legacy plus-key shortcuts", () => {
+    expect(formatShortcutDisplay("Mod+Plus", "Win32")).toBe("Ctrl + +");
+    expect(formatShortcutDisplay("Shift+Mod++", "Win32")).toBe("Ctrl + Shift + +");
+  });
+
+  it("displays multi-stroke shortcuts", () => {
+    expect(formatShortcutDisplay("Ctrl+K Ctrl+C", "Win32")).toBe("Ctrl + K, Ctrl + C");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/editor/shortcutRegistry.spec.ts b/apps/desktop/src/lib/__tests__/editor/shortcutRegistry.spec.ts
new file mode 100644
index 0000000..edf2db0
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/editor/shortcutRegistry.spec.ts
@@ -0,0 +1,100 @@
+import { describe, expect, it } from "vitest";
+import { DEFAULT_SHORTCUT_SETTINGS, SHORTCUT_DEFINITIONS, findShortcutConflict, formatShortcut, normalizeShortcutSettings, shortcutToCodeMirrorKey, type ShortcutActionId } from "@/lib/editor/shortcutRegistry";
+
+describe("shortcutRegistry editor actions", () => {
+  const formatterEditorActionIds: ShortcutActionId[] = [
+    "formatSql",
+    "toggleLineComment",
+    "indentMore",
+    "indentLess",
+    "duplicateLine",
+    "deleteLine",
+    "moveLineUp",
+    "moveLineDown",
+    "copyLineUp",
+    "copyLineDown",
+    "undo",
+    "redo",
+    "selectAll",
+    "uppercaseSelection",
+    "lowercaseSelection",
+    "exPasteSqlInCondition",
+  ];
+  const sidebarShortcutActionIds: ShortcutActionId[] = ["copySidebarSelection", "pasteSidebarSelection", "editSidebarConnection"];
+
+  it("registers formatter editor shortcuts in the generic editor scope", () => {
+    for (const actionId of formatterEditorActionIds) {
+      const definition = SHORTCUT_DEFINITIONS.find((item) => item.id === actionId);
+
+      expect(definition?.scope).toBe("editor");
+      expect(DEFAULT_SHORTCUT_SETTINGS[actionId]).toBe(definition?.defaultShortcut);
+    }
+  });
+
+  it("normalizes missing formatter editor shortcuts to their generic defaults", () => {
+    const shortcuts = normalizeShortcutSettings({ executeSql: "Mod+Shift+Enter" });
+
+    expect(shortcuts.executeSql).toBe("Mod+Shift+Enter");
+    expect(shortcuts.formatSql).toBe("Shift+Mod+F");
+    expect(shortcuts.toggleLineComment).toBe("Mod+/");
+    expect(shortcuts.indentMore).toBe("");
+    expect(shortcuts.indentLess).toBe("Shift+Tab");
+    expect(shortcuts.duplicateLine).toBe("Mod+D");
+    expect(shortcuts.deleteLine).toBe("Shift+Mod+K");
+    expect(shortcuts.moveLineUp).toBe("Alt+ArrowUp");
+    expect(shortcuts.moveLineDown).toBe("Alt+ArrowDown");
+    expect(shortcuts.copyLineUp).toBe("Shift+Alt+ArrowUp");
+    expect(shortcuts.copyLineDown).toBe("Shift+Alt+ArrowDown");
+    expect(shortcuts.undo).toBe("Mod+Z");
+    expect(shortcuts.redo).toBe("Shift+Mod+Z");
+    expect(shortcuts.selectAll).toBe("Mod+A");
+    expect(shortcuts.uppercaseSelection).toBe("Shift+Alt+U");
+    expect(shortcuts.lowercaseSelection).toBe("Shift+Alt+L");
+    expect(shortcuts.exPasteSqlInCondition).toBe("");
+  });
+
+  it("detects conflicts between formatter editor shortcuts and other editor shortcuts", () => {
+    const shortcuts = normalizeShortcutSettings({ duplicateLine: "Mod+F" });
+
+    expect(findShortcutConflict("duplicateLine", shortcuts.duplicateLine, shortcuts)).toBe("find");
+  });
+
+  it("detects conflicts for SQL selection case shortcuts", () => {
+    const shortcuts = normalizeShortcutSettings({ uppercaseSelection: "Mod+A" });
+
+    expect(findShortcutConflict("uppercaseSelection", shortcuts.uppercaseSelection, shortcuts)).toBe("selectAll");
+  });
+
+  it("registers sidebar shortcuts in the sidebar scope", () => {
+    for (const actionId of sidebarShortcutActionIds) {
+      const definition = SHORTCUT_DEFINITIONS.find((item) => item.id === actionId);
+
+      expect(definition?.scope).toBe("sidebar");
+      expect(DEFAULT_SHORTCUT_SETTINGS[actionId]).toBe(definition?.defaultShortcut);
+    }
+  });
+
+  it("detects conflicts only within sidebar shortcuts", () => {
+    const shortcuts = normalizeShortcutSettings({ copySidebarSelection: "Mod+E" });
+
+    expect(findShortcutConflict("copySidebarSelection", shortcuts.copySidebarSelection, shortcuts)).toBe("editSidebarConnection");
+    expect(findShortcutConflict("copyCurrentRow", shortcuts.copyCurrentRow, shortcuts)).toBe(null);
+  });
+
+  it("formats Ctrl before Shift on Windows", () => {
+    expect(formatShortcut("Shift+Mod+F", "Win32")).toBe("Ctrl+Shift+F");
+  });
+
+  it("converts plus-key shortcuts for CodeMirror keymaps", () => {
+    expect(shortcutToCodeMirrorKey("Mod+Plus")).toBe("Mod-+");
+    expect(shortcutToCodeMirrorKey("Shift+Mod++")).toBe("Shift-Mod-+");
+  });
+
+  it("converts slash shortcuts for CodeMirror keymaps", () => {
+    expect(shortcutToCodeMirrorKey("Mod+/")).toBe("Mod-/");
+  });
+
+  it("converts multi-stroke shortcuts for CodeMirror keymaps", () => {
+    expect(shortcutToCodeMirrorKey("Ctrl+K Ctrl+C")).toBe("Ctrl-k Ctrl-c");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/editorThemes.spec.ts b/apps/desktop/src/lib/__tests__/editorThemes.spec.ts
new file mode 100644
index 0000000..9ae06ec
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/editorThemes.spec.ts
@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { resolveEditorTheme } from "@/lib/editor/editorThemes";
+import type { AppThemePalette } from "@/lib/app/appTheme";
+import type { EditorTheme } from "@/stores/settingsStore";
+
+describe("resolveEditorTheme", () => {
+  it("maps only the follow-app editor theme to application IDE palettes", () => {
+    expect(resolveEditorTheme("app", "light", "xcode")).toBe("xcode");
+    expect(resolveEditorTheme("app", "dark", "xcode")).toBe("xcode-dark");
+    expect(resolveEditorTheme("app", "light", "cursor")).toBe("cursor-light");
+    expect(resolveEditorTheme("app", "dark", "cursor")).toBe("cursor-dark");
+  });
+
+  it("keeps explicit editor themes unchanged across application palettes", () => {
+    const explicitThemes: Array<Exclude<EditorTheme, "app">> = [
+      "one-dark",
+      "vscode-dark",
+      "vscode-light",
+      "nord",
+      "okaidia",
+      "material",
+      "duotone-light",
+      "duotone-dark",
+      "xcode",
+      "xcode-dark",
+      "idea-light",
+      "idea-dark",
+      "jetbrains-light",
+      "jetbrains-dark",
+      "cursor-light",
+      "cursor-dark",
+      "claude-light",
+      "claude-dark",
+      "custom",
+    ];
+    const appPalettes: AppThemePalette[] = ["pearl", "vscode", "idea", "xcode", "jetbrains", "cursor", "claude"];
+
+    for (const theme of explicitThemes) {
+      for (const palette of appPalettes) {
+        expect(resolveEditorTheme(theme, "dark", palette)).toBe(theme);
+        expect(resolveEditorTheme(theme, "light", palette)).toBe(theme);
+      }
+    }
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/etcd/etcdKeyTree.spec.ts b/apps/desktop/src/lib/__tests__/etcd/etcdKeyTree.spec.ts
new file mode 100644
index 0000000..6abe025
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/etcd/etcdKeyTree.spec.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { buildEtcdKeyTree, flattenVisibleEtcdKeyTree } from "@/lib/etcd/etcdKeyTree";
+
+describe("etcd key tree", () => {
+  it("groups slash-delimited keys", () => {
+    const tree = buildEtcdKeyTree([
+      { key: "/app/config/name", modRevision: 3 },
+      { key: "/app/config/env", modRevision: 4 },
+      { key: "/service/api", modRevision: 5 },
+    ]);
+
+    expect(tree.map((node) => node.label)).toEqual(["app", "service"]);
+    const app = tree[0];
+    expect(app.kind).toBe("group");
+    if (app.kind === "group") {
+      expect(app.children.map((node) => node.label)).toEqual(["config"]);
+    }
+  });
+
+  it("flattens only expanded groups", () => {
+    const tree = buildEtcdKeyTree([{ key: "/app/config/name" }, { key: "/plain" }]);
+    const rows = flattenVisibleEtcdKeyTree(tree, new Set(["group:app"]));
+
+    expect(rows.map((row) => `${row.depth}:${row.node.label}`)).toEqual(["0:app", "1:config", "0:plain"]);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/imports/navicatImport.spec.ts b/apps/desktop/src/lib/__tests__/imports/navicatImport.spec.ts
new file mode 100644
index 0000000..64b04a6
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/imports/navicatImport.spec.ts
@@ -0,0 +1,100 @@
+import { describe, expect, it } from "vitest";
+import { parseNavicatConnections } from "@/lib/imports/navicatImport";
+
+class TestElement {
+  readonly tagName: string;
+  readonly attributes: { name: string; value: string }[];
+  readonly children: TestElement[] = [];
+  readonly textContent = "";
+
+  constructor(tagName: string, attributes: { name: string; value: string }[]) {
+    this.tagName = tagName;
+    this.attributes = attributes;
+  }
+}
+
+class TestDocument {
+  private readonly elements: TestElement[];
+
+  constructor(xml: string) {
+    this.elements = Array.from(xml.matchAll(/<Connection\b([\s\S]*?)\/>/gi)).map((match) => new TestElement("Connection", parseAttributes(match[1] || "")));
+  }
+
+  querySelector(selector: string) {
+    return selector === "parsererror" ? null : null;
+  }
+
+  querySelectorAll(selector: string) {
+    return selector === "*" ? this.elements : [];
+  }
+}
+
+class TestDOMParser {
+  parseFromString(xml: string) {
+    return new TestDocument(xml);
+  }
+}
+
+function parseAttributes(source: string) {
+  return Array.from(source.matchAll(/([^\s=]+)="([^"]*)"/g)).map((match) => ({ name: match[1] || "", value: match[2] || "" }));
+}
+
+if (!globalThis.DOMParser) {
+  globalThis.DOMParser = TestDOMParser as typeof DOMParser;
+}
+
+describe("parseNavicatConnections", () => {
+  it("imports SQLite DatabaseFile as both host and database", async () => {
+    const [connection] = await parseNavicatConnections(`<Connections>
+  <Connection ConnType="SQLite" Name="local-sqlite" DatabaseFile="C:\\Users\\Yang\\demo.db" />
+</Connections>`);
+
+    expect(connection?.db_type).toBe("sqlite");
+    expect(connection?.host).toBe("C:\\Users\\Yang\\demo.db");
+    expect(connection?.database).toBe("C:\\Users\\Yang\\demo.db");
+    expect(connection?.port).toBe(0);
+  });
+
+  it("imports SQLite numeric ConnType file name as host", async () => {
+    const [connection] = await parseNavicatConnections(`<Connections>
+  <Connection ConnType="3" Name="sqlite-by-code" DatabaseFileName="/home/yang/demo.sqlite" />
+</Connections>`);
+
+    expect(connection?.db_type).toBe("sqlite");
+    expect(connection?.host).toBe("/home/yang/demo.sqlite");
+  });
+
+  it("uses SQLite Database field as the file path", async () => {
+    const [connection] = await parseNavicatConnections(`<Connections>
+  <Connection ConnType="SQLite" Name="sqlite-database-field" Database="/tmp/app.data" />
+</Connections>`);
+
+    expect(connection?.db_type).toBe("sqlite");
+    expect(connection?.host).toBe("/tmp/app.data");
+    expect(connection?.database).toBe("/tmp/app.data");
+  });
+
+  it("keeps non-SQLite host and database mapping unchanged", async () => {
+    const [connection] = await parseNavicatConnections(`<Connections>
+  <Connection ConnType="PostgreSQL" Name="pg" Host="db.example.test" Database="appdb" Port="15432" />
+</Connections>`);
+
+    expect(connection?.db_type).toBe("postgres");
+    expect(connection?.host).toBe("db.example.test");
+    expect(connection?.database).toBe("appdb");
+    expect(connection?.port).toBe(15432);
+  });
+
+  it("prefers Navicat ConnType over Redis deployment Type", async () => {
+    const [connection] = await parseNavicatConnections(`<Connections>
+  <Connection ConnectionName="redis-standalone" ConnType="REDIS" ServiceProvider="Default" Type="Standalone" Host="redis.example.test" Port="16379" AuthenticationMode="UsernamePassword" UserName="default" />
+</Connections>`);
+
+    expect(connection?.db_type).toBe("redis");
+    expect(connection?.driver_profile).toBe("redis");
+    expect(connection?.name).toBe("redis-standalone");
+    expect(connection?.host).toBe("redis.example.test");
+    expect(connection?.port).toBe(16379);
+    expect(connection?.username).toBe("default");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/kv/kvKeyTree.spec.ts b/apps/desktop/src/lib/__tests__/kv/kvKeyTree.spec.ts
new file mode 100644
index 0000000..c0e6b08
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/kv/kvKeyTree.spec.ts
@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { buildKvKeyTree, collectKvGroupIds, flattenVisibleKvKeyTree, preserveKvExpandedGroupIds } from "@/lib/kv/kvKeyTree";
+
+describe("kv key tree", () => {
+  it("keeps root keys as leaf nodes", () => {
+    const tree = buildKvKeyTree([{ key: "/plain", version: 2 }, { key: "/" }]);
+
+    expect(tree.map((node) => `${node.kind}:${node.label}`)).toEqual(["leaf:/", "leaf:plain"]);
+    expect(tree[1]).toMatchObject({ kind: "leaf", key: "/plain", version: 2 });
+  });
+
+  it("groups slash-delimited keys and sorts groups before leaves", () => {
+    const tree = buildKvKeyTree([
+      { key: "/app/config/name", modRevision: 3 },
+      { key: "/plain", modRevision: 4 },
+      { key: "/app/config/env", modRevision: 5 },
+      { key: "/service/api", modRevision: 6 },
+    ]);
+
+    expect(tree.map((node) => node.label)).toEqual(["app", "service", "plain"]);
+    const app = tree[0];
+    expect(app.kind).toBe("group");
+    if (app.kind === "group") {
+      expect(app.children.map((node) => node.label)).toEqual(["config"]);
+    }
+  });
+
+  it("collects stable group ids", () => {
+    const tree = buildKvKeyTree([{ key: "/app/config/name" }, { key: "/service/api" }]);
+
+    expect([...collectKvGroupIds(tree)].sort()).toEqual(["group:app", "group:app\u0000config", "group:service"]);
+  });
+
+  it("flattens only expanded groups", () => {
+    const tree = buildKvKeyTree([{ key: "/app/config/name" }, { key: "/plain" }]);
+    const rows = flattenVisibleKvKeyTree(tree, new Set(["group:app"]));
+
+    expect(rows.map((row) => `${row.depth}:${row.node.label}`)).toEqual(["0:app", "1:config", "0:plain"]);
+  });
+
+  it("preserves only expanded groups still present after reload", () => {
+    const tree = buildKvKeyTree([{ key: "/app/config/name" }, { key: "/service/api" }]);
+    const next = preserveKvExpandedGroupIds(tree, new Set(["group:app", "group:missing"]));
+
+    expect([...next]).toEqual(["group:app"]);
+    expect([...preserveKvExpandedGroupIds(tree, new Set(), true)].sort()).toEqual(["group:app", "group:app\u0000config", "group:service"]);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/kv/kvRefreshSelection.spec.ts b/apps/desktop/src/lib/__tests__/kv/kvRefreshSelection.spec.ts
new file mode 100644
index 0000000..7945512
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/kv/kvRefreshSelection.spec.ts
@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { refreshedKvSelectionKey } from "@/lib/kv/kvRefreshSelection";
+import type { KvKeySummary } from "@/lib/backend/api";
+
+describe("kv refresh selection", () => {
+  const keys: KvKeySummary[] = [{ key: "/app/config" }, { key: "/app/feature" }];
+
+  it("keeps the previously selected key when it still exists after refresh", () => {
+    expect(refreshedKvSelectionKey("/app/config", keys)).toBe("/app/config");
+  });
+
+  it("clears the selected key when it no longer exists after refresh", () => {
+    expect(refreshedKvSelectionKey("/app/missing", keys)).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/kv/kvRootPresentation.spec.ts b/apps/desktop/src/lib/__tests__/kv/kvRootPresentation.spec.ts
new file mode 100644
index 0000000..6436a08
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/kv/kvRootPresentation.spec.ts
@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+import { kvRootNodeLabel } from "@/lib/kv/kvRootPresentation";
+
+describe("kv root presentation", () => {
+  it("keeps etcd under Keys but shows ZooKeeper as root path", () => {
+    expect(kvRootNodeLabel("etcd")).toBe("Keys");
+    expect(kvRootNodeLabel("zookeeper")).toBe("/");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/kv/kvValueDisplay.spec.ts b/apps/desktop/src/lib/__tests__/kv/kvValueDisplay.spec.ts
new file mode 100644
index 0000000..90b2e84
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/kv/kvValueDisplay.spec.ts
@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { formatZooKeeperMetadataRows, formatZooKeeperSummaryBadges, prettyPrintJsonText } from "@/lib/kv/kvValueDisplay";
+import type { KvKeyMetadata } from "@/lib/backend/api";
+
+describe("kv value display helpers", () => {
+  it("pretty prints valid JSON text", () => {
+    expect(prettyPrintJsonText('{"name":"张三","roles":["admin","reader"]}')).toEqual({
+      ok: true,
+      value: '{\n  "name": "张三",\n  "roles": [\n    "admin",\n    "reader"\n  ]\n}',
+    });
+  });
+
+  it("does not treat plain text as JSON", () => {
+    expect(prettyPrintJsonText("hello")).toEqual({
+      ok: false,
+      error: "invalid_json",
+    });
+  });
+
+  it("formats ZooKeeper summary badges with ZK fallbacks", () => {
+    const metadata: KvKeyMetadata = {
+      mzxid: 29,
+      version: 0,
+      lease: null,
+      dataLength: 291,
+    };
+
+    expect(formatZooKeeperSummaryBadges(metadata)).toEqual([
+      { label: "rev", value: "29" },
+      { label: "ver", value: "0" },
+      { label: "lease", value: "-" },
+      { label: "size", value: "291 B" },
+    ]);
+  });
+
+  it("formats ZooKeeper summary badges with localized labels", () => {
+    const metadata: KvKeyMetadata = {
+      mzxid: 373437,
+      version: 0,
+      lease: null,
+      dataLength: 291,
+    };
+
+    expect(
+      formatZooKeeperSummaryBadges(metadata, {
+        revision: "修订",
+        version: "版本",
+        lease: "租约",
+        size: "大小",
+      }),
+    ).toEqual([
+      { label: "修订", value: "373437" },
+      { label: "版本", value: "0" },
+      { label: "租约", value: "-" },
+      { label: "大小", value: "291 B" },
+    ]);
+  });
+
+  it("formats ZooKeeper stat rows using user-facing labels", () => {
+    const metadata: KvKeyMetadata = {
+      ephemeralOwner: 0,
+      ctime: 1780674584000,
+      mtime: 1780674585000,
+      mzxid: 27,
+      pzxid: 39825,
+      czxid: 27,
+      dataLength: 0,
+      numChildren: 5,
+      version: 0,
+      aversion: 0,
+      cversion: 5,
+    };
+
+    expect(formatZooKeeperMetadataRows(metadata).map((row) => [row.label, row.value])).toEqual([
+      ["ephemeralOwner", "0x0"],
+      ["mtime", expect.stringMatching(/^2026-06-05 \d{2}:49:45$/)],
+      ["ctime", expect.stringMatching(/^2026-06-05 \d{2}:49:44$/)],
+      ["mZxid", "0x1b"],
+      ["pZxid", "0x9b91"],
+      ["cZxid", "0x1b"],
+      ["dataLength", "0"],
+      ["numChildren", "5"],
+      ["dataVersion", "0"],
+      ["aclVersion", "0"],
+      ["cVersion", "5"],
+    ]);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/mcp/mcpConfigTemplates.spec.ts b/apps/desktop/src/lib/__tests__/mcp/mcpConfigTemplates.spec.ts
new file mode 100644
index 0000000..d425280
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/mcp/mcpConfigTemplates.spec.ts
@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+import { buildMcpCodexConfig, buildMcpJsonConfig, buildMcpOpenCodeConfig, buildMcpVsCodeConfig, type McpEnvEntry } from "@/lib/mcp/mcpConfigTemplates";
+
+describe("MCP config templates", () => {
+  it("builds the standard mcpServers JSON used by Claude, Cursor, TRAE, and Windsurf", () => {
+    const config = JSON.parse(buildMcpJsonConfig());
+
+    expect(config).toEqual({
+      mcpServers: {
+        dbx: {
+          command: "dbx-mcp-server",
+        },
+      },
+    });
+  });
+
+  it("adds DBX MCP env entries to standard JSON configs", () => {
+    const env: McpEnvEntry[] = [
+      ["DBX_MCP_ALLOW_WRITES", "0"],
+      ["DBX_MCP_ALLOW_DANGEROUS_SQL", "1"],
+    ];
+    const config = JSON.parse(buildMcpJsonConfig(env));
+
+    expect(config.mcpServers.dbx.env).toEqual({
+      DBX_MCP_ALLOW_WRITES: "0",
+      DBX_MCP_ALLOW_DANGEROUS_SQL: "1",
+    });
+  });
+
+  it("builds standard JSON configs with a direct node launch command", () => {
+    const config = JSON.parse(buildMcpJsonConfig([], { command: "C:\\Program Files\\nodejs\\node.exe", args: ["C:\\Users\\zhiyo\\AppData\\Roaming\\npm\\node_modules\\@dbx-app\\mcp-server\\dist\\index.js"] }));
+
+    expect(config).toEqual({
+      mcpServers: {
+        dbx: {
+          command: "C:\\Program Files\\nodejs\\node.exe",
+          args: ["C:\\Users\\zhiyo\\AppData\\Roaming\\npm\\node_modules\\@dbx-app\\mcp-server\\dist\\index.js"],
+        },
+      },
+    });
+  });
+
+  it("builds VS Code MCP config with the servers root", () => {
+    const config = JSON.parse(buildMcpVsCodeConfig([["DBX_MCP_ALLOW_WRITES", "0"]]));
+
+    expect(config).toEqual({
+      servers: {
+        dbx: {
+          type: "stdio",
+          command: "dbx-mcp-server",
+          env: {
+            DBX_MCP_ALLOW_WRITES: "0",
+          },
+        },
+      },
+    });
+  });
+
+  it("builds VS Code config with a direct node launch command", () => {
+    const config = JSON.parse(buildMcpVsCodeConfig([["DBX_MCP_ALLOW_WRITES", "0"]], { command: "node", args: ["C:\\dbx\\mcp\\dist\\index.js"] }));
+
+    expect(config).toEqual({
+      servers: {
+        dbx: {
+          type: "stdio",
+          command: "node",
+          args: ["C:\\dbx\\mcp\\dist\\index.js"],
+          env: {
+            DBX_MCP_ALLOW_WRITES: "0",
+          },
+        },
+      },
+    });
+  });
+
+  it("builds Codex TOML config with env entries", () => {
+    expect(buildMcpCodexConfig([["DBX_MCP_ALLOW_WRITES", "0"]])).toBe(["[mcp_servers.dbx]", 'command = "dbx-mcp-server"', "", "[mcp_servers.dbx.env]", 'DBX_MCP_ALLOW_WRITES = "0"'].join("\n"));
+  });
+
+  it("builds Codex TOML config with a direct node launch command", () => {
+    expect(buildMcpCodexConfig([["DBX_MCP_ALLOW_WRITES", "0"]], { command: "node", args: ["C:\\dbx\\mcp\\dist\\index.js"] })).toBe(["[mcp_servers.dbx]", 'command = "node"', 'args = ["C:\\\\dbx\\\\mcp\\\\dist\\\\index.js"]', "", "[mcp_servers.dbx.env]", 'DBX_MCP_ALLOW_WRITES = "0"'].join("\n"));
+  });
+
+  it("builds OpenCode config using environment entries", () => {
+    const config = JSON.parse(buildMcpOpenCodeConfig([["DBX_MCP_ALLOW_DANGEROUS_SQL", "1"]]));
+
+    expect(config).toEqual({
+      mcp: {
+        dbx: {
+          type: "local",
+          command: ["dbx-mcp-server"],
+          environment: {
+            DBX_MCP_ALLOW_DANGEROUS_SQL: "1",
+          },
+        },
+      },
+    });
+  });
+
+  it("builds OpenCode config with a direct node launch command", () => {
+    const config = JSON.parse(buildMcpOpenCodeConfig([], { command: "node", args: ["C:\\dbx\\mcp\\dist\\index.js"] }));
+
+    expect(config).toEqual({
+      mcp: {
+        dbx: {
+          type: "local",
+          command: ["node", "C:\\dbx\\mcp\\dist\\index.js"],
+        },
+      },
+    });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/metadata/completionMetadataPolicy.spec.ts b/apps/desktop/src/lib/__tests__/metadata/completionMetadataPolicy.spec.ts
new file mode 100644
index 0000000..a6528ee
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/metadata/completionMetadataPolicy.spec.ts
@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { usesLocalOnlyEditorCompletionMetadata, usesOnDemandOnlyEditorColumnMetadata } from "@/lib/metadata/completionMetadataPolicy";
+
+describe("completionMetadataPolicy", () => {
+  it("keeps Presto-like editor completion on local metadata", () => {
+    expect(usesLocalOnlyEditorCompletionMetadata("prestosql")).toBe(true);
+    expect(usesLocalOnlyEditorCompletionMetadata("trino")).toBe(true);
+  });
+
+  it("does not change regular database completion behavior", () => {
+    expect(usesLocalOnlyEditorCompletionMetadata("mysql")).toBe(false);
+    expect(usesLocalOnlyEditorCompletionMetadata("postgres")).toBe(false);
+    expect(usesLocalOnlyEditorCompletionMetadata("jdbc")).toBe(false);
+    expect(usesLocalOnlyEditorCompletionMetadata(undefined)).toBe(false);
+  });
+
+  it("keeps Presto-like editor column metadata on demand only", () => {
+    expect(usesOnDemandOnlyEditorColumnMetadata("prestosql")).toBe(true);
+    expect(usesOnDemandOnlyEditorColumnMetadata("trino")).toBe(true);
+    expect(usesOnDemandOnlyEditorColumnMetadata("mysql")).toBe(false);
+    expect(usesOnDemandOnlyEditorColumnMetadata(undefined)).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/metadata/completionTreeIndex.spec.ts b/apps/desktop/src/lib/__tests__/metadata/completionTreeIndex.spec.ts
new file mode 100644
index 0000000..a006a4f
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/metadata/completionTreeIndex.spec.ts
@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { completionSchemasFromTree, completionTablesFromTree } from "@/lib/metadata/completionTreeIndex";
+import type { TreeNode } from "@/types/database";
+
+describe("completionTreeIndex", () => {
+  it("extracts PrestoSQL schemas and loaded grouped tables from the sidebar tree", () => {
+    const tree: TreeNode[] = [
+      {
+        id: "conn",
+        label: "PrestoSQL",
+        type: "connection",
+        connectionId: "conn",
+        children: [
+          {
+            id: "conn:hive",
+            label: "hive",
+            type: "database",
+            connectionId: "conn",
+            database: "hive",
+            children: [
+              {
+                id: "conn:hive:sales_analytics",
+                label: "sales_analytics",
+                type: "schema",
+                connectionId: "conn",
+                database: "hive",
+                schema: "sales_analytics",
+                children: [
+                  {
+                    id: "conn:hive:sales_analytics:__tables",
+                    label: "tree.tables",
+                    type: "group-tables",
+                    connectionId: "conn",
+                    database: "hive",
+                    schema: "sales_analytics",
+                    children: [
+                      {
+                        id: "conn:hive:sales_analytics:__tables:daily_revenue",
+                        label: "daily_revenue",
+                        type: "table",
+                        connectionId: "conn",
+                        database: "hive",
+                        schema: "sales_analytics",
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    expect(completionSchemasFromTree(tree, "conn", "hive")).toEqual(["sales_analytics"]);
+    expect(completionTablesFromTree(tree, "conn", "hive", "sales_analytics")).toEqual([{ name: "daily_revenue", schema: "sales_analytics", type: "table" }]);
+    expect(completionTablesFromTree(tree, "conn", "hive")).toEqual([{ name: "daily_revenue", schema: "sales_analytics", type: "table" }]);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/mq/mqListPanels.spec.ts b/apps/desktop/src/lib/__tests__/mq/mqListPanels.spec.ts
new file mode 100644
index 0000000..4536bc6
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/mq/mqListPanels.spec.ts
@@ -0,0 +1,45 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+function componentSource(name: string): string {
+  return readFileSync(new URL(`../../../components/mq/${name}`, import.meta.url), "utf8");
+}
+
+describe("MQ list panels", () => {
+  it("does not issue per-tenant detail requests from the tenant list UI", () => {
+    const source = componentSource("TenantsPanel.vue");
+
+    expect(source).not.toContain("mqGetTenant");
+  });
+
+  it("does not issue per-namespace permission requests from the namespace list UI", () => {
+    const source = componentSource("NamespacesPanel.vue");
+
+    expect(source).not.toContain("mqListPermissions");
+  });
+
+  it("refreshing policies hydrates missing fields from defaults instead of dirty form values", () => {
+    const source = componentSource("PoliciesPanel.vue");
+
+    expect(source).not.toContain("policyFormsFromEffectivePolicies(loaded, currentPolicyForms())");
+    expect(source).toContain("policyFormsFromEffectivePolicies(loaded, defaultMqPolicyForms())");
+  });
+
+  it("raw api panel includes common endpoint presets that use the selected mq context", () => {
+    const rawSource = componentSource("RawApiPanel.vue");
+    const consoleSource = componentSource("MqAdminConsole.vue");
+
+    expect(rawSource).toContain("const presets = computed<RawApiPreset[]>");
+    expect(rawSource).toContain("/admin/v2/brokers/version");
+    expect(rawSource).toContain("/internalStats");
+    expect(rawSource).toContain("/partitioned-stats");
+    expect(rawSource).toContain("/schema");
+    expect(rawSource).toContain("presetsCollapsed");
+    expect(rawSource).toContain("formatJsonBody");
+    expect(rawSource).toContain("bodyTextareaRows");
+    expect(rawSource).toContain("body: isReadMethod.value ? undefined : parseBody()");
+    expect(consoleSource).toContain(':tenant="selectedTenant"');
+    expect(consoleSource).toContain(':namespace="selectedNamespace"');
+    expect(consoleSource).toContain(':topic="selectedTopic"');
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/mq/mqPinnedVersionOptions.spec.ts b/apps/desktop/src/lib/__tests__/mq/mqPinnedVersionOptions.spec.ts
new file mode 100644
index 0000000..c8c4e64
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/mq/mqPinnedVersionOptions.spec.ts
@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { MQ_PINNED_VERSION_AUTO, MQ_PINNED_VERSION_OPTIONS, pinnedVersionToSelection, selectionToPinnedVersion } from "@/lib/mq/mqPinnedVersionOptions";
+
+describe("mqPinnedVersionOptions", () => {
+  it("offers auto-detection and the supported Pulsar 3.x profile", () => {
+    expect(MQ_PINNED_VERSION_OPTIONS.map((option) => option.value)).toEqual([MQ_PINNED_VERSION_AUTO, "3.1.x"]);
+  });
+
+  it("normalizes existing Pulsar 3.x pinned values to the supported profile option", () => {
+    expect(pinnedVersionToSelection(undefined)).toBe(MQ_PINNED_VERSION_AUTO);
+    expect(pinnedVersionToSelection("")).toBe(MQ_PINNED_VERSION_AUTO);
+    expect(pinnedVersionToSelection("3.0.7")).toBe("3.1.x");
+    expect(pinnedVersionToSelection("3.1.2")).toBe("3.1.x");
+    expect(pinnedVersionToSelection("3.1.x")).toBe("3.1.x");
+  });
+
+  it("only persists an explicit version when a supported profile is selected", () => {
+    expect(selectionToPinnedVersion(MQ_PINNED_VERSION_AUTO)).toBeUndefined();
+    expect(selectionToPinnedVersion("3.1.x")).toBe("3.1.x");
+    expect(selectionToPinnedVersion("4.0.x")).toBeUndefined();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/mq/mqPolicyForms.spec.ts b/apps/desktop/src/lib/__tests__/mq/mqPolicyForms.spec.ts
new file mode 100644
index 0000000..82a1c40
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/mq/mqPolicyForms.spec.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { defaultMqPolicyForms, policyFormsFromEffectivePolicies } from "@/lib/mq/mqPolicyForms";
+
+describe("mqPolicyForms", () => {
+  it("hydrates forms from topic effective policies", () => {
+    const forms = policyFormsFromEffectivePolicies(
+      {
+        level: "topic",
+        topicPolicies: {
+          publishRate: {
+            publishThrottlingRateInMsg: 100,
+            publishThrottlingRateInByte: 2048,
+          },
+          dispatchRate: {
+            dispatchThrottlingRateInMsg: 50,
+            dispatchThrottlingRateInByte: 1024,
+            ratePeriodInSecond: 5,
+          },
+          backlogQuota: {
+            limitSize: 4096,
+            limitTime: 60,
+            policy: "producer_exception",
+            quotaType: "message_age",
+          },
+          retention: {
+            retentionTimeInMinutes: 120,
+            retentionSizeInMB: 512,
+          },
+        },
+      },
+      defaultMqPolicyForms(),
+    );
+
+    expect(forms.publishForm.publishThrottlingRateInMsg).toBe(100);
+    expect(forms.dispatchForm.ratePeriodInSecond).toBe(5);
+    expect(forms.backlogForm.quotaType).toBe("message_age");
+    expect(forms.retentionForm.retentionSizeInMb).toBe(512);
+  });
+
+  it("hydrates forms from namespace Pulsar policies shape", () => {
+    const forms = policyFormsFromEffectivePolicies(
+      {
+        publishRate: {
+          publishThrottlingRateInMsg: 20,
+          publishThrottlingRateInByte: 3000,
+        },
+        subscribeRate: {
+          subscribeThrottlingRatePerConsumer: 12,
+          ratePeriodInSecond: 3,
+        },
+        backlog_quota_map: {
+          destination_storage: {
+            limitSize: 999,
+            limitTime: 10,
+            policy: "consumer_backlog_eviction",
+          },
+        },
+        retention_policies: {
+          retentionTimeInMinutes: 30,
+          retentionSizeInMB: 64,
+        },
+      },
+      defaultMqPolicyForms(),
+    );
+
+    expect(forms.publishForm.publishThrottlingRateInByte).toBe(3000);
+    expect(forms.subscribeForm.ratePeriodInSecond).toBe(3);
+    expect(forms.backlogForm.limitSize).toBe(999);
+    expect(forms.backlogForm.quotaType).toBe("destination_storage");
+    expect(forms.retentionForm.retentionTimeInMinutes).toBe(30);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/mq/mqTenantForm.spec.ts b/apps/desktop/src/lib/__tests__/mq/mqTenantForm.spec.ts
new file mode 100644
index 0000000..c8377ff
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/mq/mqTenantForm.spec.ts
@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { defaultTenantConfig, mqClusterOptionsFromExtra, validateTenantForm } from "@/lib/mq/mqTenantForm";
+
+describe("mqTenantForm", () => {
+  it("extracts selectable cluster names from Pulsar cluster info extras", () => {
+    expect(mqClusterOptionsFromExtra({ clusters: ["standalone", "ec-pulsar", "standalone", "", 42] })).toEqual(["standalone", "ec-pulsar"]);
+    expect(mqClusterOptionsFromExtra({ clusters: "standalone" })).toEqual([]);
+    expect(mqClusterOptionsFromExtra(undefined)).toEqual([]);
+  });
+
+  it("prefills a new tenant with detected clusters", () => {
+    const config = defaultTenantConfig(["standalone", "ec-pulsar"]);
+
+    expect(config).toEqual({
+      adminRoles: [],
+      allowedClusters: ["standalone", "ec-pulsar"],
+    });
+  });
+
+  it("requires both a tenant name and at least one allowed cluster", () => {
+    expect(validateTenantForm("", { adminRoles: [], allowedClusters: ["standalone"] })).toBe("Tenant name is required");
+    expect(validateTenantForm("tenant-a", { adminRoles: [], allowedClusters: [] })).toBe("Allowed clusters are required");
+    expect(validateTenantForm("tenant-a", { adminRoles: [], allowedClusters: ["standalone"] })).toBeUndefined();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/mq/mqTokenErrors.spec.ts b/apps/desktop/src/lib/__tests__/mq/mqTokenErrors.spec.ts
new file mode 100644
index 0000000..25f9e6c
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/mq/mqTokenErrors.spec.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { formatMqTokenIssueError } from "@/lib/mq/mqTokenErrors";
+
+describe("MQ token errors", () => {
+  it("turns missing signing configuration backend errors into actionable Chinese copy", () => {
+    const result = formatMqTokenIssueError("/api/mq/tokens/issue returned 500: Token signing is not configured for this MQ connection");
+
+    expect(result.kind).toBe("missingSigningKey");
+    expect(result.title).toBe("未配置 Token 签发密钥");
+    expect(result.message).toContain("无法生成客户端 Token");
+    expect(result.detail).toContain("Broker Token 签发");
+  });
+
+  it("keeps unrelated errors as ordinary messages", () => {
+    const result = formatMqTokenIssueError("network failed");
+
+    expect(result.kind).toBe("generic");
+    expect(result.title).toBeUndefined();
+    expect(result.message).toBe("network failed");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/nacos/nacosAdmin.spec.ts b/apps/desktop/src/lib/__tests__/nacos/nacosAdmin.spec.ts
new file mode 100644
index 0000000..ba9e922
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/nacos/nacosAdmin.spec.ts
@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildNacosConfigExportFileName,
+  buildNacosConfigDeleteConfirm,
+  buildNacosInlineDiff,
+  buildNacosInstanceConfirm,
+  buildNacosRawRequest,
+  buildNacosSideBySideDiff,
+  isNacosRawMutation,
+  nacosConfigFileExtension,
+  parseNacosRawBody,
+  parseNacosRawQuery,
+  resolveNacosConfigCopyText,
+  sanitizeNacosConfigFileNameSegment,
+  summarizeNacosConfigDiff,
+} from "@/lib/nacos/nacosAdmin";
+
+describe("nacosAdmin helpers", () => {
+  it("parses raw query and body text", () => {
+    expect(parseNacosRawQuery("?dataId=a&group=DEFAULT_GROUP")).toEqual({ dataId: "a", group: "DEFAULT_GROUP" });
+    expect(parseNacosRawQuery("")).toBeUndefined();
+    expect(parseNacosRawBody('{"enabled":false}')).toEqual({ enabled: false });
+    expect(parseNacosRawBody("plain text")).toBe("plain text");
+  });
+
+  it("builds raw requests and detects mutations", () => {
+    const req = buildNacosRawRequest("post", " /v1/cs/configs ", "a=1", '{"b":2}');
+    expect(req).toEqual({ method: "post", path: "/v1/cs/configs", query: { a: "1" }, body: { b: 2 } });
+    expect(isNacosRawMutation("GET")).toBe(false);
+    expect(isNacosRawMutation("DELETE")).toBe(true);
+  });
+
+  it("summarizes config diffs", () => {
+    const diff = summarizeNacosConfigDiff("a\nb", "a\nc\nd");
+    expect(diff.changed).toBe(true);
+    expect(diff.removedLines).toBe(1);
+    expect(diff.addedLines).toBe(2);
+    expect(diff.preview).toContain("- b");
+    expect(diff.preview).toContain("+ c");
+  });
+
+  it("builds side-by-side config diff rows with inline segments", () => {
+    const rows = buildNacosSideBySideDiff('cloud:\n  secret: "aaa"\n', 'cloud:\n  secret: "aaa1"\n  enabled: true\n');
+    expect(rows[0]).toMatchObject({ leftLineNumber: 1, rightLineNumber: 1, leftType: "equal", rightType: "equal" });
+    expect(rows[1]).toMatchObject({ leftLineNumber: 2, rightLineNumber: 2, leftType: "modify", rightType: "modify" });
+    expect(rows[1].rightInline.some((segment) => segment.changed && segment.value === "1")).toBe(true);
+    expect(rows[2]).toMatchObject({ leftLineNumber: null, rightLineNumber: 3, leftType: "padding", rightType: "insert" });
+  });
+
+  it("builds inline config diff rows with character-level changed segments", () => {
+    const rows = buildNacosInlineDiff('secretId: "aaa1"\n', 'secretId: "aaa2"\n');
+    expect(rows).toHaveLength(2);
+    expect(rows[0]).toMatchObject({ lineNumber: 1, type: "delete" });
+    expect(rows[1]).toMatchObject({ lineNumber: 1, type: "insert" });
+    expect(rows[0].segments.some((segment) => segment.changed && segment.value === "1")).toBe(true);
+    expect(rows[1].segments.some((segment) => segment.changed && segment.value === "2")).toBe(true);
+  });
+
+  it("includes identifying fields in confirmations", () => {
+    expect(buildNacosConfigDeleteConfirm({ namespace: "", dataId: "app.yaml", group: "DEFAULT_GROUP" })).toContain("dataId=app.yaml");
+    const details = buildNacosInstanceConfirm({ serviceName: "DEFAULT_GROUP@@svc", groupName: "DEFAULT_GROUP" }, { ip: "127.0.0.1", port: 8080, enabled: true, metadata: null }, { enabled: false }, "", "public");
+    expect(details).toContain("serviceName=DEFAULT_GROUP@@svc");
+    expect(details).toContain("targetEnabled=false");
+  });
+
+  it("builds safe export file names from config data id and format", () => {
+    expect(sanitizeNacosConfigFileNameSegment("../prod:app?config")).toBe("prod_app_config");
+    expect(nacosConfigFileExtension("yaml")).toBe("yaml");
+    expect(nacosConfigFileExtension("props")).toBe("properties");
+    expect(buildNacosConfigExportFileName({ dataId: "application.yaml", configType: "text" })).toBe("application.yaml");
+    expect(buildNacosConfigExportFileName({ dataId: "service/config", configType: "json" })).toBe("service_config.json");
+    expect(buildNacosConfigExportFileName({ dataId: "", configType: "toml" })).toBe("nacos-config.toml");
+  });
+
+  it("copies selected config text before editor text and state text", () => {
+    expect(resolveNacosConfigCopyText("selected", "editor", "state")).toBe("selected");
+    expect(resolveNacosConfigCopyText("", "editor", "state")).toBe("editor");
+    expect(resolveNacosConfigCopyText("", "", "state")).toBe("state");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/query/oracleExplainPlan.spec.ts b/apps/desktop/src/lib/__tests__/query/oracleExplainPlan.spec.ts
new file mode 100644
index 0000000..bb67af5
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/query/oracleExplainPlan.spec.ts
@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { flattenExplainPlanNodes, parseOracleExplainText, supportsExplainPlan } from "@/lib/diagram/explainPlan";
+
+const ORACLE_PLAN = `Plan hash value: 321708281
+
+-----------------------------------------------------------------------------------------
+| Id  | Operation                     | Name    | Rows  | Bytes | Cost (%CPU)| Time     |
+-----------------------------------------------------------------------------------------
+|   0 | SELECT STATEMENT              |         |     1 |    34 |     5   (0)| 00:00:01 |
+|   1 |  NESTED LOOPS                 |         |     1 |    34 |     5   (0)| 00:00:01 |
+|   2 |   NESTED LOOPS                |         |     1 |    31 |     4   (0)| 00:00:01 |
+|*  3 |    TABLE ACCESS BY INDEX ROWID| USER$   |     1 |    28 |     3   (0)| 00:00:01 |
+|*  4 |     INDEX RANGE SCAN          | I_USER1 |     3 |       |     1   (0)| 00:00:01 |
+|   5 |    TABLE ACCESS CLUSTER       | TS$     |     1 |     3 |     1   (0)| 00:00:01 |
+|*  6 |     INDEX UNIQUE SCAN         | I_TS#   |     1 |       |     0   (0)| 00:00:01 |
+|   7 |   TABLE ACCESS CLUSTER        | TS$     |     1 |     3 |     1   (0)| 00:00:01 |
+|*  8 |    INDEX UNIQUE SCAN          | I_TS#   |     1 |       |     0   (0)| 00:00:01 |
+-----------------------------------------------------------------------------------------
+
+Predicate Information (identified by operation id):
+---------------------------------------------------
+
+   3 - filter("U"."TYPE#"=1 AND "U"."USER#">0)
+   4 - access("U"."NAME" LIKE 'S%' AND
+       "U"."CREATED_AT">=TO_DATE(' 2025-12-01 00:00:00',
+       'syyyy-mm-dd hh24:mi:ss'))
+       filter("U"."NAME" LIKE 'S%')`;
+
+describe("Oracle explain plan", () => {
+  it("is enabled by the driver capability manifest", () => {
+    expect(supportsExplainPlan("oracle")).toBe(true);
+  });
+
+  it("parses DBMS_XPLAN text into a hierarchy with predicates", () => {
+    const plan = parseOracleExplainText(ORACLE_PLAN);
+    const nodes = flattenExplainPlanNodes(plan.nodes);
+
+    expect(plan.databaseType).toBe("oracle");
+    expect(plan.raw).toBe(ORACLE_PLAN);
+    expect(plan.nodes).toHaveLength(1);
+    expect(plan.nodes[0].nodeType).toBe("SELECT STATEMENT");
+    expect(plan.nodes[0].children[0].nodeType).toBe("NESTED LOOPS");
+    expect(plan.nodes[0].children[0].children.map((node) => node.id)).toEqual(["2", "7"]);
+
+    const tableAccess = nodes.find((node) => node.id === "3");
+    expect(tableAccess).toMatchObject({ relation: "USER$", rows: "1", cost: "3   (0)" });
+    expect(tableAccess?.details).toContain('Predicate: filter("U"."TYPE#"=1 AND "U"."USER#">0)');
+
+    const indexScan = nodes.find((node) => node.id === "4");
+    expect(indexScan?.index).toBe("I_USER1");
+    expect(indexScan?.details).toEqual(["Time: 00:00:01", 'Predicate: access("U"."NAME" LIKE \'S%\' AND "U"."CREATED_AT">=TO_DATE(\' 2025-12-01 00:00:00\', \'syyyy-mm-dd hh24:mi:ss\'))', 'Predicate: filter("U"."NAME" LIKE \'S%\')']);
+  });
+
+  it("keeps unrecognized text available in the raw view", () => {
+    expect(parseOracleExplainText("Oracle plan unavailable")).toEqual({
+      databaseType: "oracle",
+      raw: "Oracle plan unavailable",
+      nodes: [],
+    });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/query/queryResultError.spec.ts b/apps/desktop/src/lib/__tests__/query/queryResultError.spec.ts
new file mode 100644
index 0000000..4d848da
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/query/queryResultError.spec.ts
@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+
+import type { QueryResult } from "@/types/database";
+
+import { isMysqlExecutionErrorResult, isNoSnapshotErrorResult } from "@/lib/query/queryResultError";
+
+function errorResult(message: string): QueryResult {
+  return { columns: ["Error"], rows: [[message]], affected_rows: 0, execution_time_ms: 0 };
+}
+
+function dataResult(columns: string[]): QueryResult {
+  return { columns, rows: [], affected_rows: 0, execution_time_ms: 0 };
+}
+
+describe("isNoSnapshotErrorResult", () => {
+  it("matches the StarRocks Paimon no-snapshot error surfaced via executeTabSql", () => {
+    const result = errorResult("Server error: `ERROR HY000 (1064): There is currently no snapshot.`");
+    expect(isNoSnapshotErrorResult(result)).toBe(true);
+  });
+
+  it("matches case-insensitively", () => {
+    const result = errorResult("there IS currently NO snapshot");
+    expect(isNoSnapshotErrorResult(result)).toBe(true);
+  });
+
+  it("does not match unrelated query errors", () => {
+    expect(isNoSnapshotErrorResult(errorResult("Unknown table 'tag_test.record_tag_t'"))).toBe(false);
+    expect(isNoSnapshotErrorResult(errorResult("ERROR 1142: SELECT command denied"))).toBe(false);
+  });
+
+  it("does not match successful data results", () => {
+    expect(isNoSnapshotErrorResult(dataResult(["id", "name"]))).toBe(false);
+    expect(isNoSnapshotErrorResult(dataResult(["Error"]))).toBe(false); // data column literally named Error, no rows
+  });
+
+  it("returns false for missing or empty results", () => {
+    expect(isNoSnapshotErrorResult(undefined)).toBe(false);
+    expect(isNoSnapshotErrorResult(null)).toBe(false);
+    expect(isNoSnapshotErrorResult({ ...errorResult("There is currently no snapshot."), rows: [] })).toBe(false);
+  });
+});
+
+describe("isMysqlExecutionErrorResult", () => {
+  it("recognizes an explicitly marked MySQL batch execution error", () => {
+    expect(isMysqlExecutionErrorResult({ ...errorResult("Duplicate entry '1'"), execution_error: true }, "mysql")).toBe(true);
+  });
+
+  it("does not mistake an unmarked Error alias without type metadata for an execution error", () => {
+    const result: QueryResult = {
+      columns: ["Error"],
+      rows: [["2"]],
+      affected_rows: 0,
+      execution_time_ms: 1,
+    };
+    expect(isMysqlExecutionErrorResult(result, "mysql")).toBe(false);
+  });
+
+  it("does not apply the native MySQL heuristic to JDBC connections", () => {
+    expect(isMysqlExecutionErrorResult({ ...errorResult("Duplicate entry '1'"), execution_error: true }, "jdbc")).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/redis/redisAutoRefresh.spec.ts b/apps/desktop/src/lib/__tests__/redis/redisAutoRefresh.spec.ts
new file mode 100644
index 0000000..c787da6
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/redis/redisAutoRefresh.spec.ts
@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+
+import { computeAutoRefreshTick, computeDisplayTtl, shouldStopAutoRefresh } from "@/lib/redis/redisAutoRefresh";
+
+describe("computeAutoRefreshTick", () => {
+  it("returns idle when auto-refresh is disabled", () => {
+    expect(computeAutoRefreshTick(false, 10, false)).toEqual({ type: "idle" });
+    // countdown value and loading flag don't matter when disabled
+    expect(computeAutoRefreshTick(false, 0, false)).toEqual({ type: "idle" });
+    expect(computeAutoRefreshTick(false, 5, true)).toEqual({ type: "idle" });
+  });
+
+  it("returns decrement while more than one second remains", () => {
+    expect(computeAutoRefreshTick(true, 10, false)).toEqual({ type: "decrement" });
+    // decrement even when loading — countdown should keep ticking
+    expect(computeAutoRefreshTick(true, 3, true)).toEqual({ type: "decrement" });
+  });
+
+  it("refreshes on the expiry tick instead of exposing a zero countdown", () => {
+    expect(computeAutoRefreshTick(true, 1, false)).toEqual({ type: "refresh" });
+    expect(computeAutoRefreshTick(true, 0, false)).toEqual({ type: "refresh" });
+    expect(computeAutoRefreshTick(true, -1, false)).toEqual({ type: "refresh" });
+  });
+
+  it("does not start another refresh when a load is already in flight", () => {
+    expect(computeAutoRefreshTick(true, 1, true)).toEqual({ type: "decrement" });
+    // This prevents concurrent load() calls
+    expect(computeAutoRefreshTick(true, 0, true)).toEqual({ type: "idle" });
+    expect(computeAutoRefreshTick(true, -1, true)).toEqual({ type: "idle" });
+  });
+});
+
+describe("shouldStopAutoRefresh", () => {
+  it("returns true when TTL is zero (key expired)", () => {
+    expect(shouldStopAutoRefresh(0)).toBe(true);
+  });
+
+  it("returns true when TTL is negative (no expiry or key deleted)", () => {
+    expect(shouldStopAutoRefresh(-1)).toBe(true);
+    expect(shouldStopAutoRefresh(-2)).toBe(true);
+  });
+
+  it("returns false when TTL is positive (key still alive)", () => {
+    expect(shouldStopAutoRefresh(1)).toBe(false);
+    expect(shouldStopAutoRefresh(3600)).toBe(false);
+  });
+});
+
+describe("computeDisplayTtl", () => {
+  it("returns server TTL when auto-refresh is disabled", () => {
+    expect(computeDisplayTtl(false, 3, 10)).toBe(10);
+  });
+
+  it("does not flash back to the stale server TTL at zero", () => {
+    expect(computeDisplayTtl(true, 0, 5)).toBe(0);
+  });
+
+  it("returns live countdown when auto-refresh is active and counting", () => {
+    expect(computeDisplayTtl(true, 5, 10)).toBe(5);
+    expect(computeDisplayTtl(true, 1, 10)).toBe(1);
+  });
+
+  it("clamps an active countdown below zero instead of showing stale data", () => {
+    expect(computeDisplayTtl(true, -1, 10)).toBe(0);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/redis/redisCreateKeyTypeHelp.spec.ts b/apps/desktop/src/lib/__tests__/redis/redisCreateKeyTypeHelp.spec.ts
new file mode 100644
index 0000000..2cead83
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/redis/redisCreateKeyTypeHelp.spec.ts
@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { REDIS_CREATE_KEY_TYPE_VALUES, getRedisCreateKeyTypeHelp, redisCreateKeyTypeHelpOptionOnOpen, shouldActivateRedisCreateKeyTypeHelpOnFocus } from "@/lib/redis/redisCreateKeyTypeHelp";
+import en from "@/i18n/locales/en";
+import zhCN from "@/i18n/locales/zh-CN";
+
+function redisCreateTypeHelpMessages(locale: unknown): Record<string, unknown> {
+  const messages = locale as { redis?: { createKeyTypeHelp?: Record<string, unknown> } };
+  return messages.redis?.createKeyTypeHelp ?? {};
+}
+
+describe("getRedisCreateKeyTypeHelp", () => {
+  it("covers every key type offered by the Create key dialog", () => {
+    for (const type of REDIS_CREATE_KEY_TYPE_VALUES) {
+      expect(getRedisCreateKeyTypeHelp(type)).toEqual({ key: type });
+    }
+  });
+
+  it("normalizes casing and leaves unsupported types undocumented", () => {
+    expect(getRedisCreateKeyTypeHelp(" ZSET ")).toEqual({ key: "zset" });
+    expect(getRedisCreateKeyTypeHelp("bitmap")).toBeUndefined();
+  });
+
+  it("activates help only for focus reached through Arrow navigation", () => {
+    expect(shouldActivateRedisCreateKeyTypeHelpOnFocus({ openedByArrow: true, keyboardNavigating: true })).toBe(true);
+    expect(shouldActivateRedisCreateKeyTypeHelpOnFocus({ openedByArrow: false, keyboardNavigating: true })).toBe(true);
+    expect(shouldActivateRedisCreateKeyTypeHelpOnFocus({ openedByArrow: false, keyboardNavigating: false })).toBe(false);
+  });
+
+  it("shows the selected offered type's help when the Select opens", () => {
+    expect(redisCreateKeyTypeHelpOptionOnOpen("string")).toBe("string");
+    expect(redisCreateKeyTypeHelpOptionOnOpen(" JSON ")).toBe("json");
+    expect(redisCreateKeyTypeHelpOptionOnOpen("bitmap")).toBeUndefined();
+  });
+
+  it("has English and Simplified Chinese copy for every offered type", () => {
+    const english = redisCreateTypeHelpMessages(en);
+    const chinese = redisCreateTypeHelpMessages(zhCN);
+
+    for (const type of REDIS_CREATE_KEY_TYPE_VALUES) {
+      expect(english[type], `English: ${type}`).toEqual(expect.any(String));
+      expect(chinese[type], `Simplified Chinese: ${type}`).toEqual(expect.any(String));
+    }
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/redis/redisValuePresentation.spec.ts b/apps/desktop/src/lib/__tests__/redis/redisValuePresentation.spec.ts
new file mode 100644
index 0000000..edeb7e4
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/redis/redisValuePresentation.spec.ts
@@ -0,0 +1,144 @@
+import { describe, expect, it } from "vitest";
+
+import { canRenderRedisValueFormat, formatRedisMemberDetail, formatRedisStringValue, getRedisMemberSelectionKey, preferredRedisValueFormat, redisMemberCopyText, sanitizeRedisDisplayText } from "@/lib/redis/redisValuePresentation";
+
+describe("redisValuePresentation", () => {
+  it("strips control bytes from display without mutating raw member text", () => {
+    const raw = "send_message_to_esb\x06\x16\x06\x16send_message_to_esb";
+
+    const detail = formatRedisMemberDetail(raw);
+
+    expect(detail.text).toBe("send_message_to_esbsend_message_to_esb");
+    expect(detail.rawText).toBe(raw);
+  });
+
+  it("preserves common whitespace in display text", () => {
+    expect(sanitizeRedisDisplayText("line1\nline2\tvalue\r\n")).toBe("line1\nline2\tvalue\r\n");
+  });
+
+  it("strips utf8 c1 control bytes for display", () => {
+    expect(sanitizeRedisDisplayText("before\u0085after")).toBe("beforeafter");
+  });
+
+  it("uses raw member text for selection keys", () => {
+    const raw = "send_message_to_esb\x06\x16";
+
+    expect(getRedisMemberSelectionKey("member", raw)).toBe(`member\n${raw}`);
+  });
+
+  it("can disambiguate duplicate stream fields with an explicit identity", () => {
+    expect(getRedisMemberSelectionKey("event", "login", "stream:1:0")).not.toBe(getRedisMemberSelectionKey("event", "login", "stream:1:1"));
+  });
+
+  it("formats string values for display without changing plain text", () => {
+    expect(formatRedisStringValue("plain-text")).toBe("plain-text");
+  });
+
+  it("labels raw text views by encoding instead of generic raw text", () => {
+    expect(formatRedisMemberDetail("plain-text").rawLabel).toBe("ASCII");
+    expect(
+      formatRedisMemberDetail({
+        raw_base64: Buffer.from("你好", "utf8").toString("base64"),
+        encoding: "utf8",
+      }).rawLabel,
+    ).toBe("UTF-8");
+    expect(
+      formatRedisMemberDetail({
+        raw_base64: "rO0ABQ==",
+        encoding: "binary",
+      }).rawLabel,
+    ).toBe("Binary");
+  });
+
+  it("orders supported formats with the recommended view first", () => {
+    expect(
+      formatRedisMemberDetail({
+        raw_base64: Buffer.from('{"id":1}', "utf8").toString("base64"),
+        encoding: "utf8",
+      }).availableFormats,
+    ).toEqual(["utf8", "ascii", "binary", "hex", "base64"]);
+    expect(
+      formatRedisMemberDetail({
+        raw_base64: "rO0ABQ==",
+        encoding: "binary",
+      }).availableFormats,
+    ).toEqual(["hex", "binary", "base64"]);
+  });
+
+  it("keeps a UTF-8 decoding available even for binary blobs", () => {
+    const detail = formatRedisMemberDetail({
+      raw_base64: "rO0ABQ==",
+      encoding: "binary",
+    });
+
+    expect(detail.utf8Text).toBe(new TextDecoder("utf-8").decode(Uint8Array.from([0xac, 0xed, 0x00, 0x05])));
+  });
+
+  it("only exposes JSON view when payload text explicitly opts in", () => {
+    expect(
+      formatRedisMemberDetail(
+        {
+          raw_base64: Buffer.from('{"id":1}', "utf8").toString("base64"),
+          encoding: "utf8",
+        },
+        { allowJsonText: true },
+      ).availableFormats,
+    ).toEqual(["utf8", "ascii", "binary", "json", "hex", "base64"]);
+  });
+
+  it("falls back to utf8 when a binary inspection view was stored for editable text", () => {
+    const blob = {
+      raw_base64: Buffer.from("Ada", "utf8").toString("base64"),
+      encoding: "utf8" as const,
+    };
+
+    expect(preferredRedisValueFormat(blob, "hex")).toBe("utf8");
+    expect(preferredRedisValueFormat(blob, "base64")).toBe("utf8");
+    expect(preferredRedisValueFormat(blob, "binary")).toBe("utf8");
+    expect(preferredRedisValueFormat(blob, "json", { allowJsonText: true })).toBe("utf8");
+  });
+
+  it("adds a Java serialized format when the blob uses Java object serialization", () => {
+    const detail = formatRedisMemberDetail({
+      raw_base64: "rO0ABXQACHNvbWV0ZXh0",
+      encoding: "binary",
+    });
+
+    expect(detail.availableFormats).toEqual(["javaserialize", "binary", "hex", "base64"]);
+    expect(detail.defaultFormat).toBe("javaserialize");
+    expect(detail.javaSerialized?.formattedText).toBe('"sometext"');
+    expect(canRenderRedisValueFormat(detail, "javaserialize")).toBe(true);
+    expect(canRenderRedisValueFormat(formatRedisMemberDetail("plain-text"), "javaserialize")).toBe(false);
+  });
+
+  it("keeps self-referential Java maps representable via refs", () => {
+    const detail = formatRedisMemberDetail({
+      raw_base64: "rO0ABXNyABFqYXZhLnV0aWwuSGFzaE1hcAUH2sHDFmDRAwACRgAKbG9hZEZhY3RvckkACXRocmVzaG9sZHhwP0AAAAAAAAx3CAAAABAAAAABdAAEc2VsZnEAfgABeA==",
+      encoding: "binary",
+    });
+
+    const normalized = detail.javaSerialized?.value as { map?: { $entries?: Array<{ value?: { $ref?: string } }> } } | undefined;
+    const entries = normalized?.map?.$entries;
+    expect(entries?.[0]?.value?.$ref).toBe("#1");
+  });
+
+  it("keeps editable text round-trippable while exposing separate ascii/binary views", () => {
+    const detail = formatRedisMemberDetail({
+      raw_base64: Buffer.from("send_message_to_esb\x06\x16", "latin1").toString("base64"),
+      encoding: "utf8",
+    });
+
+    expect(detail.rawText).toBe("send_message_to_esb\x06\x16");
+    expect(detail.asciiText).toBe("send_message_to_esb\\x06\\x16");
+    expect(detail.binaryText).toBe("011100110110010101101110011001000101111101101101011001010111001101110011011000010110011101100101010111110111010001101111010111110110010101110011011000100000011000010110");
+  });
+
+  it("copies binary blobs as escaped raw bytes", () => {
+    expect(
+      redisMemberCopyText({
+        raw_base64: "rO0ABQ==",
+        encoding: "binary",
+      }),
+    ).toBe("\\xac\\xed\\x00\\x05");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/savedSql/savedSqlFileName.spec.ts b/apps/desktop/src/lib/__tests__/savedSql/savedSqlFileName.spec.ts
new file mode 100644
index 0000000..b23cbd5
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/savedSql/savedSqlFileName.spec.ts
@@ -0,0 +1,20 @@
+import { describe, expect, it } from "vitest";
+import { ensureSqlExtension, stripSqlExtension } from "@/lib/savedSql/savedSqlFileName";
+
+describe("savedSqlFileName", () => {
+  it("appends .sql when missing", () => {
+    expect(ensureSqlExtension("report")).toBe("report.sql");
+  });
+
+  it("preserves lowercase .sql extension", () => {
+    expect(ensureSqlExtension("report.sql")).toBe("report.sql");
+  });
+
+  it("preserves uppercase .SQL extension without double-appending", () => {
+    expect(ensureSqlExtension("report.SQL")).toBe("report.SQL");
+  });
+
+  it("strips .sql extension case-insensitively", () => {
+    expect(stripSqlExtension("report.SQL")).toBe("report");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/savedSql/savedSqlFolderCounts.spec.ts b/apps/desktop/src/lib/__tests__/savedSql/savedSqlFolderCounts.spec.ts
new file mode 100644
index 0000000..ead33ac
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/savedSql/savedSqlFolderCounts.spec.ts
@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { savedSqlFolderBranchFileCount, type SavedSqlFolderCountNode } from "@/lib/savedSql/savedSqlFolderCounts";
+
+describe("savedSqlFolderBranchFileCount", () => {
+  const folders: SavedSqlFolderCountNode[] = [{ id: "root" }, { id: "child", parentFolderId: "root" }, { id: "grandchild", parentFolderId: "child" }, { id: "sibling", parentFolderId: "root" }, { id: "other" }];
+  const filesByFolder = new Map<string, unknown[]>([
+    ["root", ["root.sql"]],
+    ["child", []],
+    ["grandchild", ["nested.sql", "report.sql"]],
+    ["sibling", ["side.sql"]],
+    ["other", ["other.sql"]],
+  ]);
+
+  it("counts files in descendant folders", () => {
+    const count = savedSqlFolderBranchFileCount("root", folders, (folderId) => filesByFolder.get(folderId) ?? []);
+
+    expect(count).toBe(4);
+  });
+
+  it("does not count files outside the folder branch", () => {
+    const count = savedSqlFolderBranchFileCount("child", folders, (folderId) => filesByFolder.get(folderId) ?? []);
+
+    expect(count).toBe(2);
+  });
+
+  it("does not loop on cyclic folder data", () => {
+    const cyclicFolders: SavedSqlFolderCountNode[] = [
+      { id: "a", parentFolderId: "b" },
+      { id: "b", parentFolderId: "a" },
+    ];
+
+    const count = savedSqlFolderBranchFileCount("a", cyclicFolders, () => ["file.sql"]);
+
+    expect(count).toBe(2);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/savedSqlEditorPosition.spec.ts b/apps/desktop/src/lib/__tests__/savedSqlEditorPosition.spec.ts
new file mode 100644
index 0000000..e64fc2d
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/savedSqlEditorPosition.spec.ts
@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { __resetSavedSqlEditorPositionsForTests, createSavedSqlEditorPosition, forgetSavedSqlEditorPosition, restoreSavedSqlEditorPosition, saveSavedSqlEditorPosition } from "../app/savedSqlEditorPosition";
+
+vi.mock("@/lib/backend/api", () => ({
+  loadSavedSqlEditorPositions: vi.fn().mockResolvedValue(null),
+  saveSavedSqlEditorPositions: vi.fn().mockResolvedValue(undefined),
+}));
+
+const storage = new Map<string, string>();
+
+beforeEach(() => {
+  storage.clear();
+  __resetSavedSqlEditorPositionsForTests();
+  vi.stubGlobal("localStorage", {
+    getItem: (key: string) => storage.get(key) ?? null,
+    setItem: (key: string, value: string) => storage.set(key, value),
+    removeItem: (key: string) => storage.delete(key),
+  });
+});
+
+describe("savedSqlEditorPosition", () => {
+  it("restores the saved cursor and viewport when the file is unchanged", () => {
+    const sql = "select 1;\n\nselect 2;\n";
+    const head = sql.indexOf("select 2");
+
+    saveSavedSqlEditorPosition(
+      createSavedSqlEditorPosition({
+        savedSqlId: "file-a",
+        sql,
+        selection: { anchor: head, head },
+        viewport: { scrollTop: 320, scrollLeft: 12 },
+        now: 1,
+      }),
+    );
+
+    expect(restoreSavedSqlEditorPosition("file-a", sql)).toEqual({
+      selection: { anchor: head, head },
+      viewport: { scrollTop: 320, scrollLeft: 12 },
+    });
+  });
+
+  it("relocates the cursor by nearby SQL text when content is inserted before it", () => {
+    const sql = "select 1;\n\nselect 2;\n";
+    const head = sql.indexOf("select 2");
+    const nextSql = "-- inserted header\n" + sql;
+
+    saveSavedSqlEditorPosition(
+      createSavedSqlEditorPosition({
+        savedSqlId: "file-b",
+        sql,
+        selection: { anchor: head, head },
+        viewport: { scrollTop: 320, scrollLeft: 12 },
+        now: 1,
+      }),
+    );
+
+    expect(restoreSavedSqlEditorPosition("file-b", nextSql)).toEqual({
+      selection: { anchor: nextSql.indexOf("select 2"), head: nextSql.indexOf("select 2") },
+      viewport: undefined,
+    });
+  });
+
+  it("falls back to a safe offset when the previous context no longer exists", () => {
+    const sql = "select 1;\n\nselect 2;\n";
+    const head = sql.indexOf("select 2");
+
+    saveSavedSqlEditorPosition(
+      createSavedSqlEditorPosition({
+        savedSqlId: "file-c",
+        sql,
+        selection: { anchor: head, head },
+        now: 1,
+      }),
+    );
+
+    const restored = restoreSavedSqlEditorPosition("file-c", "select 1;");
+
+    expect(restored.selection).toEqual({ anchor: "select 1;".length, head: "select 1;".length });
+    expect(restored.viewport).toBeUndefined();
+  });
+
+  it("forgets a deleted saved SQL file position", () => {
+    saveSavedSqlEditorPosition(
+      createSavedSqlEditorPosition({
+        savedSqlId: "file-d",
+        sql: "select 1;",
+        selection: { anchor: 3, head: 3 },
+        now: 1,
+      }),
+    );
+
+    forgetSavedSqlEditorPosition("file-d");
+
+    expect(restoreSavedSqlEditorPosition("file-d", "select 1;")).toEqual({});
+  });
+
+  it("keeps only the most recent saved SQL file positions", () => {
+    for (let index = 0; index < 205; index += 1) {
+      saveSavedSqlEditorPosition(
+        createSavedSqlEditorPosition({
+          savedSqlId: `file-${index}`,
+          sql: "select 1;",
+          selection: { anchor: 0, head: 0 },
+          now: index,
+        }),
+      );
+    }
+
+    expect(restoreSavedSqlEditorPosition("file-0", "select 1;")).toEqual({});
+    expect(restoreSavedSqlEditorPosition("file-204", "select 1;").selection).toEqual({ anchor: 0, head: 0 });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/schema/schemaDiffMetadataLoad.spec.ts b/apps/desktop/src/lib/__tests__/schema/schemaDiffMetadataLoad.spec.ts
new file mode 100644
index 0000000..24e0a24
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/schema/schemaDiffMetadataLoad.spec.ts
@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import { createConcurrencyLimiter, mapWithConcurrency, schemaDiffMetadataConcurrency } from "@/lib/schema/schemaDiffMetadataLoad";
+
+function wait(ms: number) {
+  return new Promise<void>((resolve) => setTimeout(resolve, ms));
+}
+
+describe("schemaDiffMetadataLoad", () => {
+  it("uses adaptive metadata concurrency for MySQL-compatible databases", () => {
+    expect(schemaDiffMetadataConcurrency("mysql")).toBe(2);
+    expect(schemaDiffMetadataConcurrency("MariaDB")).toBe(2);
+    expect(schemaDiffMetadataConcurrency("mysql", 30)).toBe(4);
+    expect(schemaDiffMetadataConcurrency("mysql", 31)).toBe(2);
+    expect(schemaDiffMetadataConcurrency("MariaDB", 12)).toBe(4);
+    expect(schemaDiffMetadataConcurrency("postgres")).toBe(6);
+    expect(schemaDiffMetadataConcurrency("postgres", 100)).toBe(6);
+    expect(schemaDiffMetadataConcurrency(undefined)).toBe(6);
+  });
+
+  it("maps items with limited concurrency and preserves output order", async () => {
+    let active = 0;
+    let maxActive = 0;
+
+    const result = await mapWithConcurrency([30, 5, 10, 1], 2, async (delay, index) => {
+      active += 1;
+      maxActive = Math.max(maxActive, active);
+      await wait(delay);
+      active -= 1;
+      return `${index}:${delay}`;
+    });
+
+    expect(result).toEqual(["0:30", "1:5", "2:10", "3:1"]);
+    expect(maxActive).toBeLessThanOrEqual(2);
+  });
+
+  it("propagates the first worker error and stops scheduling new work", async () => {
+    const started: number[] = [];
+
+    await expect(
+      mapWithConcurrency([1, 2, 3], 1, async (item) => {
+        started.push(item);
+        if (item === 2) throw new Error("boom");
+        return item;
+      }),
+    ).rejects.toThrow("boom");
+
+    expect(started).toEqual([1, 2]);
+  });
+
+  it("limits arbitrary async tasks", async () => {
+    const runLimited = createConcurrencyLimiter(2);
+    let active = 0;
+    let maxActive = 0;
+
+    const result = await Promise.all(
+      [8, 6, 4, 2].map((delay, index) =>
+        runLimited(async () => {
+          active += 1;
+          maxActive = Math.max(maxActive, active);
+          await wait(delay);
+          active -= 1;
+          return index;
+        }),
+      ),
+    );
+
+    expect(result).toEqual([0, 1, 2, 3]);
+    expect(maxActive).toBeLessThanOrEqual(2);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sidebar/batchTableEmpty.spec.ts b/apps/desktop/src/lib/__tests__/sidebar/batchTableEmpty.spec.ts
new file mode 100644
index 0000000..1f3d15d
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sidebar/batchTableEmpty.spec.ts
@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { batchTableEmptyFeedback, buildBatchTableEmptyPlan, runBatchTableEmpty } from "@/lib/sidebar/batchTableEmpty";
+
+describe("batch table empty", () => {
+  it("executes the exact SQL captured for the confirmation preview", async () => {
+    const targets = [{ name: "orders" }, { name: "customers" }];
+    let schema = "public";
+    const plan = await buildBatchTableEmptyPlan(targets, async (target) => `TRUNCATE TABLE "${schema}"."${target.name}";`);
+    schema = "archive";
+
+    const executed: string[] = [];
+    await runBatchTableEmpty(plan, async ({ sql }) => {
+      executed.push(sql);
+    });
+
+    expect(plan.map(({ sql }) => sql).join("\n")).toBe('TRUNCATE TABLE "public"."orders";\nTRUNCATE TABLE "public"."customers";');
+    expect(executed).toEqual(['TRUNCATE TABLE "public"."orders";', 'TRUNCATE TABLE "public"."customers";']);
+  });
+
+  it("rejects the entire destructive plan when any preview SQL is unavailable", async () => {
+    await expect(buildBatchTableEmptyPlan(["orders", "customers"], async (target) => (target === "customers" ? "" : `TRUNCATE TABLE ${target};`))).rejects.toThrow("Empty table SQL preview is unavailable");
+  });
+
+  it("continues after a table fails and collects each result", async () => {
+    const executed: string[] = [];
+    const result = await runBatchTableEmpty(["orders", "locked", "customers"], async (table) => {
+      executed.push(table);
+      if (table === "locked") throw new Error("permission denied");
+    });
+
+    expect(executed).toEqual(["orders", "locked", "customers"]);
+    expect(result.succeeded).toEqual(["orders", "customers"]);
+    expect(result.failed.map(({ target }) => target)).toEqual(["locked"]);
+  });
+
+  it("uses submitted feedback for asynchronous mutations", () => {
+    const succeeded = { succeeded: ["events"], failed: [] };
+    const partial = { succeeded: ["events"], failed: [{ target: "logs", error: new Error("failed") }] };
+    const failed = { succeeded: [], failed: [{ target: "logs", error: new Error("failed") }] };
+
+    expect(batchTableEmptyFeedback(succeeded, true)).toBe("submitted");
+    expect(batchTableEmptyFeedback(partial, true)).toBe("submitted-partial");
+    expect(batchTableEmptyFeedback(failed, true)).toBe("submitted-partial");
+    expect(batchTableEmptyFeedback(succeeded, false)).toBe("success");
+    expect(batchTableEmptyFeedback(partial, false)).toBe("partial");
+    expect(batchTableEmptyFeedback(failed, false)).toBe("partial");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sidebar/sidebarConnectionSelection.spec.ts b/apps/desktop/src/lib/__tests__/sidebar/sidebarConnectionSelection.spec.ts
new file mode 100644
index 0000000..7c1068f
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sidebar/sidebarConnectionSelection.spec.ts
@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import { selectedConnectionDeleteTargets, selectedConnectionDuplicateTargets } from "@/lib/sidebar/sidebarConnectionSelection";
+import type { TreeNode } from "@/types/database";
+
+function node(id: string, type: TreeNode["type"] = "connection"): TreeNode {
+  return {
+    id,
+    label: id,
+    type,
+    connectionId: type === "connection" ? id : undefined,
+  };
+}
+
+describe("sidebar connection selection", () => {
+  it("uses all selected connections when the current connection is selected", () => {
+    const current = node("conn-2");
+    const selected = [node("conn-1"), current, node("conn-3")];
+
+    expect(selectedConnectionDuplicateTargets(current, selected).map((item) => item.connectionId)).toEqual(["conn-1", "conn-2", "conn-3"]);
+  });
+
+  it("falls back to the current connection when the selection is mixed", () => {
+    const current = node("conn-1");
+    const selected = [current, node("group-1", "connection-group")];
+
+    expect(selectedConnectionDuplicateTargets(current, selected).map((item) => item.connectionId)).toEqual(["conn-1"]);
+  });
+
+  it("keeps delete and duplicate target selection aligned", () => {
+    const current = node("conn-1");
+    const selected = [current, node("conn-2")];
+
+    expect(selectedConnectionDuplicateTargets(current, selected)).toEqual(selectedConnectionDeleteTargets(current, selected));
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sidebar/sidebarLabelTooltip.spec.ts b/apps/desktop/src/lib/__tests__/sidebar/sidebarLabelTooltip.spec.ts
new file mode 100644
index 0000000..546e4da
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sidebar/sidebarLabelTooltip.spec.ts
@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { shouldMeasureSidebarLabelOverflow } from "@/lib/sidebar/sidebarLabelTooltip";
+
+describe("shouldMeasureSidebarLabelOverflow", () => {
+  it("measures only plain truncated-label tooltip candidates", () => {
+    expect(shouldMeasureSidebarLabelOverflow({ hasDetailTooltip: false, isRenaming: false, usesFullWidthLabel: false })).toBe(true);
+    expect(shouldMeasureSidebarLabelOverflow({ hasDetailTooltip: true, isRenaming: false, usesFullWidthLabel: false })).toBe(false);
+    expect(shouldMeasureSidebarLabelOverflow({ hasDetailTooltip: false, isRenaming: true, usesFullWidthLabel: false })).toBe(false);
+    expect(shouldMeasureSidebarLabelOverflow({ hasDetailTooltip: false, isRenaming: false, usesFullWidthLabel: true })).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/currentStatementFrame.spec.ts b/apps/desktop/src/lib/__tests__/sql/currentStatementFrame.spec.ts
new file mode 100644
index 0000000..314e262
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/currentStatementFrame.spec.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { currentStatementFrameRangeTo, estimateInlineHintVisualColumns, isWideSqlChar, visualSqlColumns, visualSqlColumnsWithInlineHints } from "@/lib/sql/currentStatementFrame";
+import type { SqlTextRange } from "@/lib/sql/sqlStatementRanges";
+
+describe("currentStatementFrameRangeTo", () => {
+  it("includes a directly adjacent trailing semicolon in frame width calculations", () => {
+    const range: SqlTextRange = { from: 0, to: "SELECT 1".length, sql: "SELECT 1" };
+    expect(currentStatementFrameRangeTo(";", range)).toBe(range.to + 1);
+  });
+
+  it("does not extend the frame when the next character is not a semicolon", () => {
+    const range: SqlTextRange = { from: 0, to: "SELECT 1".length, sql: "SELECT 1" };
+    expect(currentStatementFrameRangeTo("\n", range)).toBe(range.to);
+  });
+});
+
+describe("visualSqlColumns", () => {
+  it("counts ASCII as one column, tabs as four, and CJK/fullwidth characters as two", () => {
+    expect(visualSqlColumns("A\t中Ｂ")).toBe(1 + 4 + 2 + 2);
+  });
+
+  it("recognizes common wide SQL text characters", () => {
+    expect(isWideSqlChar("中")).toBe(true);
+    expect(isWideSqlChar("Ａ")).toBe(true);
+    expect(isWideSqlChar("A")).toBe(false);
+  });
+});
+
+describe("visualSqlColumnsWithInlineHints", () => {
+  it("adds estimated columns for insert-value hints on the line", () => {
+    const text = "VALUES (12, 'a')";
+    const lineFrom = 0;
+    const lineTo = text.length;
+    const withoutHints = visualSqlColumns(text);
+    const withHints = visualSqlColumnsWithInlineHints(text, lineFrom, lineTo, [
+      { from: 8, column: "id" },
+      { from: 12, column: "name" },
+    ]);
+    expect(withHints).toBe(withoutHints + estimateInlineHintVisualColumns("id") + estimateInlineHintVisualColumns("name"));
+  });
+
+  it("ignores hints that belong to other lines", () => {
+    const text = "VALUES (1)";
+    expect(visualSqlColumnsWithInlineHints(text, 0, text.length, [{ from: 100, column: "id" }])).toBe(visualSqlColumns(text));
+  });
+
+  it("dedupes hints that share the same document offset", () => {
+    const text = "VALUES (1)";
+    const once = visualSqlColumnsWithInlineHints(text, 0, text.length, [{ from: 8, column: "id" }]);
+    const twice = visualSqlColumnsWithInlineHints(text, 0, text.length, [
+      { from: 8, column: "id" },
+      { from: 8, column: "id" },
+    ]);
+    expect(twice).toBe(once);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/editableQueryHiddenKeys.spec.ts b/apps/desktop/src/lib/__tests__/sql/editableQueryHiddenKeys.spec.ts
new file mode 100644
index 0000000..7355066
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/editableQueryHiddenKeys.spec.ts
@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+import { buildQueryWithHiddenPrimaryKeys, hiddenResultColumnIndexes } from "@/lib/sql/editableQueryHiddenKeys";
+import { analyzeEditableQueryEditability } from "@/lib/sql/sqlAnalysis";
+
+describe("editable query hidden primary keys", () => {
+  it("appends quoted MySQL primary keys without changing the visible projection", () => {
+    expect(
+      buildQueryWithHiddenPrimaryKeys({
+        sql: "SELECT name FROM users WHERE active = 1",
+        databaseType: "mysql",
+        primaryKeys: ["id"],
+        existingResultNames: ["name"],
+      }),
+    ).toEqual({
+      sql: "SELECT name, `id` AS `__DBX_PK_0` FROM users WHERE active = 1",
+      projections: [{ sourceName: "id", alias: "__DBX_PK_0" }],
+    });
+  });
+
+  it("supports PostgreSQL composite primary keys and avoids alias collisions", () => {
+    const result = buildQueryWithHiddenPrimaryKeys({
+      sql: 'SELECT "value"\nFROM "items"',
+      databaseType: "postgres",
+      primaryKeys: ["tenant_id", "item_id"],
+      existingResultNames: ["value", "__DBX_PK_0"],
+    });
+
+    expect(result?.sql).toBe('SELECT "value", "tenant_id" AS "__DBX_PK_1", "item_id" AS "__DBX_PK_2"\nFROM "items"');
+    expect(result?.projections.map((projection) => projection.alias)).toEqual(["__DBX_PK_1", "__DBX_PK_2"]);
+  });
+
+  it("preserves SQL Server TOP and Oracle optimizer hints", () => {
+    expect(
+      buildQueryWithHiddenPrimaryKeys({
+        sql: "SELECT TOP 10 name FROM dbo.users ORDER BY name",
+        databaseType: "sqlserver",
+        primaryKeys: ["id"],
+        existingResultNames: ["name"],
+      })?.sql,
+    ).toBe("SELECT TOP 10 name, [id] AS [__DBX_PK_0] FROM dbo.users ORDER BY name");
+
+    expect(
+      buildQueryWithHiddenPrimaryKeys({
+        sql: "SELECT /*+ INDEX(t IDX_USERS_NAME) */ t.NAME\nFROM USERS t",
+        databaseType: "oracle",
+        primaryKeys: ["ID"],
+        existingResultNames: ["NAME"],
+      })?.sql,
+    ).toBe('SELECT /*+ INDEX(t IDX_USERS_NAME) */ t.NAME, "ID" AS "__DBX_PK_0"\nFROM USERS t');
+  });
+
+  it("inserts hidden keys before a trailing line comment", () => {
+    expect(
+      buildQueryWithHiddenPrimaryKeys({
+        sql: "SELECT name -- visible user name\nFROM users",
+        databaseType: "mysql",
+        primaryKeys: ["id"],
+        existingResultNames: ["name"],
+      })?.sql,
+    ).toBe("SELECT name, `id` AS `__DBX_PK_0` -- visible user name\nFROM users");
+  });
+
+  it("analyzes SQL Server TOP projections as ordinary source columns", () => {
+    for (const sql of [
+      "SELECT TOP 2 name, note FROM dbo.users ORDER BY name",
+      "SELECT TOP(2) name, note FROM dbo.users ORDER BY name",
+      "SELECT TOP (2) name, note FROM dbo.users ORDER BY name",
+      "SELECT TOP 10 PERCENT name, note FROM dbo.users ORDER BY name",
+      "SELECT TOP (2) WITH TIES name, note FROM dbo.users ORDER BY name",
+    ]) {
+      const result = analyzeEditableQueryEditability(sql);
+      expect(result.editable, sql).toBe(true);
+      if (result.editable) expect(result.analysis.columns.map((column) => column.sourceName)).toEqual(["name", "note"]);
+    }
+  });
+
+  it("resolves appended aliases to result indexes", () => {
+    expect(
+      hiddenResultColumnIndexes(
+        ["name", "__DBX_PK_0", "__DBX_PK_1"],
+        [
+          { sourceName: "tenant_id", alias: "__DBX_PK_0" },
+          { sourceName: "item_id", alias: "__DBX_PK_1" },
+        ],
+      ),
+    ).toEqual([1, 2]);
+    expect(hiddenResultColumnIndexes(["name"], [{ sourceName: "id", alias: "__DBX_PK_0" }])).toEqual([]);
+    expect(
+      hiddenResultColumnIndexes(
+        ["name", "__DBX_PK_1"],
+        [
+          { sourceName: "tenant_id", alias: "__DBX_PK_0" },
+          { sourceName: "item_id", alias: "__DBX_PK_1" },
+        ],
+      ),
+    ).toEqual([1]);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/executableStatementRangeCache.spec.ts b/apps/desktop/src/lib/__tests__/sql/executableStatementRangeCache.spec.ts
new file mode 100644
index 0000000..3a0f9d7
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/executableStatementRangeCache.spec.ts
@@ -0,0 +1,106 @@
+import { Text } from "@codemirror/state";
+import { describe, expect, it, vi } from "vitest";
+import { executableStatementRangeAtCursor, executableStatementRangeCacheForDoc, executableStatementRangeStartingAt, type ExecutableStatementRangeParser } from "@/lib/sql/executableStatementRangeCache";
+
+describe("executableStatementRangeCacheForDoc", () => {
+  it("reuses parsed executable statement ranges for the same document and database type", () => {
+    const doc = Text.of(["SELECT 1;", "SELECT 2;"]);
+    const parse = vi.fn<ExecutableStatementRangeParser>(() => [
+      { from: 0, to: 8, sql: "SELECT 1" },
+      { from: 10, to: 18, sql: "SELECT 2" },
+    ]);
+
+    const first = executableStatementRangeCacheForDoc(null, doc, "mysql", parse);
+    const second = executableStatementRangeCacheForDoc(first, doc, "mysql", parse);
+
+    expect(second).toBe(first);
+    expect(parse).toHaveBeenCalledTimes(1);
+    expect(executableStatementRangeStartingAt(second, 10)?.sql).toBe("SELECT 2");
+  });
+
+  it("resolves the exact multi-line statement for a gutter run button", () => {
+    const doc = Text.of(["SELECT *", "FROM apis AS ap", "LIMIT 100;", "", "SELECT *", "FROM menus AS mn", "LIMIT 100;"]);
+
+    const cache = executableStatementRangeCacheForDoc(null, doc, "mysql");
+    const secondStatementLine = doc.line(5);
+
+    expect(executableStatementRangeStartingAt(cache, secondStatementLine.from)?.sql).toBe("SELECT *\nFROM menus AS mn\nLIMIT 100");
+  });
+
+  it("resolves statements with leading whitespace for gutter run buttons", () => {
+    const doc = Text.of([" SELECT 1;", "  SELECT 2;", "\t SELECT 3;", "", "    "]);
+    const cache = executableStatementRangeCacheForDoc(null, doc, "mysql");
+
+    expect(executableStatementRangeStartingAt(cache, doc.line(1).from)?.sql).toBe("SELECT 1");
+    expect(executableStatementRangeStartingAt(cache, doc.line(2).from)?.sql).toBe("SELECT 2");
+    expect(executableStatementRangeStartingAt(cache, doc.line(3).from)?.sql).toBe("SELECT 3");
+    expect(executableStatementRangeStartingAt(cache, doc.line(4).from)).toBeNull();
+    expect(executableStatementRangeStartingAt(cache, doc.line(5).from)).toBeNull();
+  });
+
+  it("does not resolve gutter run buttons when non-whitespace precedes the statement on the same line", () => {
+    const doc = Text.of(["/* comment */ SELECT 1;"]);
+    const cache = executableStatementRangeCacheForDoc(null, doc, "mysql");
+
+    expect(executableStatementRangeStartingAt(cache, doc.line(1).from)).toBeNull();
+    expect(executableStatementRangeStartingAt(cache, doc.toString().indexOf("SELECT"))?.sql).toBe("SELECT 1");
+  });
+
+  it("resolves the current statement from a cursor inside a continuation line", () => {
+    const doc = Text.of(["SELECT *", "FROM apis AS ap", "LIMIT 100;", "", "SELECT *", "FROM menus AS mn", "LIMIT 100;"]);
+    const cache = executableStatementRangeCacheForDoc(null, doc, "mysql");
+    const cursor = doc.toString().indexOf("menus");
+
+    expect(executableStatementRangeAtCursor(cache, cursor)?.sql).toBe("SELECT *\nFROM menus AS mn\nLIMIT 100");
+  });
+
+  it("keeps indentation and same-line semicolon gaps attached to the current statement", () => {
+    const doc = Text.of(["SELECT 1;", "    SELECT 2;"]);
+    const cache = executableStatementRangeCacheForDoc(null, doc, "mysql");
+    const indentationCursor = doc.line(2).from + 2;
+    const semicolonGapCursor = doc.toString().indexOf(";") + 1;
+
+    expect(executableStatementRangeAtCursor(cache, indentationCursor)?.sql).toBe("SELECT 2");
+    expect(executableStatementRangeAtCursor(cache, semicolonGapCursor)?.sql).toBe("SELECT 1");
+  });
+
+  it("returns null for blank and pure comment cursor lines", () => {
+    const doc = Text.of(["SELECT 1;", "-- comment", "/* block comment */", "", "SELECT 2;"]);
+    const cache = executableStatementRangeCacheForDoc(null, doc, "mysql");
+
+    expect(executableStatementRangeAtCursor(cache, doc.line(2).from + 3)).toBeNull();
+    expect(executableStatementRangeAtCursor(cache, doc.line(3).from + 3)).toBeNull();
+    expect(executableStatementRangeAtCursor(cache, doc.line(4).from)).toBeNull();
+  });
+
+  it("resolves SQL after a leading block comment on the same line", () => {
+    const doc = Text.of(["/* comment */ SELECT 1;"]);
+    const cache = executableStatementRangeCacheForDoc(null, doc, "mysql");
+
+    expect(executableStatementRangeAtCursor(cache, doc.toString().indexOf("SELECT"))?.sql).toBe("SELECT 1");
+    expect(executableStatementRangeAtCursor(cache, doc.toString().indexOf("comment"))).toBeNull();
+  });
+
+  it("rebuilds the cache when the document instance changes", () => {
+    const firstDoc = Text.of(["SELECT 1;"]);
+    const secondDoc = Text.of(["SELECT 1;"]);
+    const parse = vi.fn<ExecutableStatementRangeParser>(() => [{ from: 0, to: 8, sql: "SELECT 1" }]);
+
+    const first = executableStatementRangeCacheForDoc(null, firstDoc, "mysql", parse);
+    const second = executableStatementRangeCacheForDoc(first, secondDoc, "mysql", parse);
+
+    expect(second).not.toBe(first);
+    expect(parse).toHaveBeenCalledTimes(2);
+  });
+
+  it("rebuilds the cache when the database type changes", () => {
+    const doc = Text.of(["SELECT 1;"]);
+    const parse = vi.fn<ExecutableStatementRangeParser>(() => [{ from: 0, to: 8, sql: "SELECT 1" }]);
+
+    const mysql = executableStatementRangeCacheForDoc(null, doc, "mysql", parse);
+    const postgres = executableStatementRangeCacheForDoc(mysql, doc, "postgres", parse);
+
+    expect(postgres).not.toBe(mysql);
+    expect(parse).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/queryError.spec.ts b/apps/desktop/src/lib/__tests__/sql/queryError.spec.ts
new file mode 100644
index 0000000..5015d9a
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/queryError.spec.ts
@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { isQueryTimeoutErrorMessage } from "@/lib/sql/queryError";
+
+describe("isQueryTimeoutErrorMessage", () => {
+  it("detects DBX query timeout messages", () => {
+    expect(isQueryTimeoutErrorMessage("Query timed out after 30 seconds")).toBe(true);
+    expect(isQueryTimeoutErrorMessage("查询超时 (60s)，请检查数据库连接是否正常")).toBe(true);
+    expect(isQueryTimeoutErrorMessage("查詢逾時 (60s)，請檢查資料庫連線是否正常")).toBe(true);
+  });
+
+  it("detects statement timeout messages", () => {
+    expect(isQueryTimeoutErrorMessage("ERROR: canceling statement due to statement timeout")).toBe(true);
+    expect(isQueryTimeoutErrorMessage("ERROR: cancelling statement due to statement timeout")).toBe(true);
+    expect(isQueryTimeoutErrorMessage("Statement timed out after 10 seconds")).toBe(true);
+  });
+
+  it("detects generic query execution timeout messages", () => {
+    expect(isQueryTimeoutErrorMessage("SQL execution timed out after 30s")).toBe(true);
+    expect(isQueryTimeoutErrorMessage("Execution Timeout Expired. The timeout period elapsed prior to completion of the operation.")).toBe(true);
+    expect(isQueryTimeoutErrorMessage("Query exceeded maximum execution time")).toBe(true);
+  });
+
+  it("detects agent RPC client-side timeout", () => {
+    expect(isQueryTimeoutErrorMessage("Agent RPC call timed out (30s)")).toBe(true);
+    expect(isQueryTimeoutErrorMessage("Agent RPC call timed out (120s)")).toBe(true);
+    expect(isQueryTimeoutErrorMessage("Agent RPC error (-1): Agent RPC call timed out (120s)")).toBe(true);
+  });
+
+  it("does not classify unrelated errors as query timeouts", () => {
+    expect(isQueryTimeoutErrorMessage('syntax error at or near "select"')).toBe(false);
+    expect(isQueryTimeoutErrorMessage("Connection timed out while loading databases")).toBe(false);
+    expect(isQueryTimeoutErrorMessage("PostgreSQL connection pool checkout timed out (5s)")).toBe(false);
+    expect(isQueryTimeoutErrorMessage("Cancel request timed out after 10s.")).toBe(false);
+    expect(isQueryTimeoutErrorMessage("HTTP tunnel script read timed out")).toBe(false);
+    expect(isQueryTimeoutErrorMessage('invalid value for parameter "statement_timeout"')).toBe(false);
+    // Agent RPC errors that are not timeouts must not trigger the action.
+    expect(isQueryTimeoutErrorMessage('Agent RPC error (-1): syntax error at or near "select"')).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/queryResultSource.spec.ts b/apps/desktop/src/lib/__tests__/sql/queryResultSource.spec.ts
new file mode 100644
index 0000000..c72131c
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/queryResultSource.spec.ts
@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import { queryResultSourceLabel } from "@/lib/sql/queryResultSource";
+
+describe("queryResultSourceLabel", () => {
+  it("uses the current database for an unqualified table", () => {
+    expect(queryResultSourceLabel("SELECT * FROM users", { database: "app", databaseType: "mysql" })).toBe("app.users");
+  });
+
+  it("prefers the final explicit qualifier", () => {
+    expect(queryResultSourceLabel("SELECT * FROM analytics.events", { database: "app", databaseType: "mysql" })).toBe("analytics.events");
+    expect(queryResultSourceLabel("SELECT * FROM [ServerOne].[AppDb].[dbo].[Users]", { database: "fallback", databaseType: "sqlserver" })).toBe("dbo.Users");
+  });
+
+  it("preserves quoted identifier names", () => {
+    expect(queryResultSourceLabel('SELECT * FROM "Sales"."Orders"', { database: "app", databaseType: "postgres" })).toBe("Sales.Orders");
+    expect(queryResultSourceLabel("SELECT * FROM HR.EMPLOYEES", { database: "fallback", databaseType: "oracle" })).toBe("HR.EMPLOYEES");
+  });
+
+  it("labels aggregate joins with the first outer physical table", () => {
+    const sql = `SELECT
+      g.group_name AS GROUP_NAME,
+      COUNT(*) AS USER_COUNT,
+      SUM(CASE WHEN u.status = 1 THEN 1 ELSE 0 END) AS ACTIVE_USER_COUNT
+    FROM groups g
+    JOIN group_users gu ON gu.group_id = g.id
+    JOIN users u ON u.id = gu.user_id
+    GROUP BY g.id, g.group_name`;
+
+    expect(queryResultSourceLabel(sql, { database: "aaa", databaseType: "mysql" })).toBe("aaa.groups");
+  });
+
+  it("prefers mutation targets over other table sources", () => {
+    expect(queryResultSourceLabel("UPDATE users SET active = true FROM audit_events ae WHERE ae.user_id = users.id RETURNING users.id", { database: "app", databaseType: "postgres" })).toBe("app.users");
+    expect(queryResultSourceLabel("INSERT INTO audit.events (id) VALUES (1) RETURNING id", { database: "app", databaseType: "postgres" })).toBe("audit.events");
+    expect(queryResultSourceLabel("DELETE FROM users WHERE id = 1 RETURNING id", { database: "app", databaseType: "postgres" })).toBe("app.users");
+  });
+
+  it("ignores non-physical outer sources", () => {
+    expect(queryResultSourceLabel("WITH recent AS (SELECT * FROM orders) SELECT * FROM recent", { database: "app", databaseType: "postgres" })).toBeUndefined();
+    expect(queryResultSourceLabel("SELECT * FROM (SELECT * FROM users) nested", { database: "app", databaseType: "mysql" })).toBeUndefined();
+    expect(queryResultSourceLabel("SELECT * FROM read_csv('users.csv') csv", { database: "main", databaseType: "duckdb" })).toBeUndefined();
+    expect(queryResultSourceLabel("SELECT 1", { database: "app", databaseType: "mysql" })).toBeUndefined();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/semantic/completion.spec.ts b/apps/desktop/src/lib/__tests__/sql/semantic/completion.spec.ts
new file mode 100644
index 0000000..678eec4
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/semantic/completion.spec.ts
@@ -0,0 +1,150 @@
+import { describe, expect, it } from "vitest";
+import { buildSqlCompletionItemsFromContext, getSqlCompletionContext, type SqlCompletionColumn, type SqlCompletionProviderInput } from "@/lib/sql/sqlCompletion";
+import { sqlCompletionContextFromSemantic, sqlSemanticLocalColumnsByTable } from "@/lib/sql/semantic/completion";
+import { buildSqlSemanticModel } from "@/lib/sql/semantic/model";
+import { sqlFixtureCursor } from "@/lib/sql/semantic/fixtures";
+import type { DatabaseType } from "@/types/database";
+
+function mergeColumns(...maps: Array<Map<string, SqlCompletionColumn[]> | undefined>): Map<string, SqlCompletionColumn[]> {
+  const merged = new Map<string, SqlCompletionColumn[]>();
+  for (const map of maps) {
+    for (const [key, columns] of map ?? []) merged.set(key, columns);
+  }
+  return merged;
+}
+
+function semanticCompletion(markedSql: string, input: Partial<SqlCompletionProviderInput> = {}, options: { databaseType?: DatabaseType; dialect?: "mysql" | "postgres" | "sqlserver" } = {}) {
+  const { sql, cursor } = sqlFixtureCursor(markedSql);
+  const model = buildSqlSemanticModel(sql, cursor, options);
+  const context = sqlCompletionContextFromSemantic(model, getSqlCompletionContext(sql, cursor));
+  const columnsByTable = mergeColumns(sqlSemanticLocalColumnsByTable(model), input.columnsByTable);
+  const items = buildSqlCompletionItemsFromContext(context, {
+    tables: input.tables ?? [],
+    objects: input.objects ?? [],
+    columnsByTable,
+    foreignKeysByTable: input.foreignKeysByTable,
+    schemas: input.schemas,
+    translations: input.translations,
+    snippets: input.snippets,
+    dialect: options.dialect,
+    databaseType: options.databaseType,
+    keywordCase: input.keywordCase,
+    autoAliasTables: input.autoAliasTables,
+  });
+  return { sql, cursor, model, context, items };
+}
+
+describe("semantic SQL completion candidates", () => {
+  it("keeps alias-qualified column completion scoped to one row source", () => {
+    const columnsByTable = new Map<string, SqlCompletionColumn[]>([
+      ["users", ["id", "name", "email"].map((name) => ({ name, table: "users" }))],
+      ["orders", ["id", "total"].map((name) => ({ name, table: "orders" }))],
+    ]);
+
+    const { items } = semanticCompletion("SELECT * FROM users u JOIN orders o ON o.user_id = u.id WHERE u.|", { columnsByTable });
+
+    expect(items.filter((item) => item.type === "column").map((item) => item.label)).toEqual(["id", "name", "email"]);
+  });
+
+  it("uses CTE projected columns without remote metadata", () => {
+    const { items, context } = semanticCompletion("WITH recent_orders(id, total) AS (SELECT id, total FROM orders) SELECT * FROM recent_orders ro WHERE ro.|");
+
+    expect(context.exclusiveColumnSuggestions).toBe(true);
+    expect(items.filter((item) => item.type === "column").map((item) => item.label)).toEqual(["id", "total"]);
+  });
+
+  it("uses subquery projected columns without remote metadata", () => {
+    const { items } = semanticCompletion("SELECT * FROM (SELECT id, name AS user_name FROM users) sq WHERE sq.|");
+
+    expect(items.filter((item) => item.type === "column").map((item) => item.label)).toEqual(["id", "user_name"]);
+  });
+
+  it("expands alias star from only the qualified row source", () => {
+    const columnsByTable = new Map<string, SqlCompletionColumn[]>([
+      ["users", ["id", "name"].map((name) => ({ name, table: "users" }))],
+      ["orders", ["id", "total"].map((name) => ({ name, table: "orders" }))],
+    ]);
+
+    const { context, items } = semanticCompletion("SELECT u.*| FROM users u JOIN orders o ON o.user_id = u.id", { columnsByTable });
+    const star = items.find((item) => item.label === "* \u2192 columns");
+
+    expect(context.qualifier).toBe("u");
+    expect(star?.apply).toBe("id, u.name");
+  });
+
+  it("generates collision-free table aliases from semantic row sources", () => {
+    const { items } = semanticCompletion("SELECT * FROM order_items oi JOIN ord|", {
+      tables: [{ name: "order_items", type: "table" }],
+      autoAliasTables: true,
+    });
+
+    expect(items.find((item) => item.label === "order_items")?.apply).toBe("order_items AS oi2");
+  });
+
+  it("preserves dialect-aware identifier quoting in apply text", () => {
+    const columnsByTable = new Map<string, SqlCompletionColumn[]>([["Order Details", [{ name: "User Name", table: "Order Details" }]]]);
+
+    const { items } = semanticCompletion('SELECT od."User| FROM "Order Details" od', { columnsByTable }, { databaseType: "postgres", dialect: "postgres" });
+
+    expect(items.find((item) => item.label === "User Name")?.apply).toBe('"User Name"');
+  });
+
+  it("suggests all target columns for insert column lists", () => {
+    const columnsByTable = new Map<string, SqlCompletionColumn[]>([["users", ["id", "name", "email"].map((name) => ({ name, table: "users" }))]]);
+
+    const { context, items } = semanticCompletion("INSERT INTO users (|", { columnsByTable });
+
+    expect(context.insertTable).toBe("users");
+    expect(items.find((item) => item.type === "snippet" && item.label === "users.*")?.apply).toBe("id, name, email");
+  });
+
+  it("keeps partial INSERT INTO targets in table completion context", () => {
+    const { context, items } = semanticCompletion("INSERT INTO ex|", {
+      tables: [
+        { name: "express", type: "table" },
+        { name: "orders", type: "table" },
+      ],
+    });
+
+    expect(context.suggestTables).toBe(true);
+    expect(context.exclusiveTableSuggestions).toBe(true);
+    expect(context.suggestColumns).toBe(false);
+    expect(context.referencedTables).toEqual([]);
+    expect(items.filter((item) => item.type === "table").map((item) => item.label)).toEqual(["express"]);
+  });
+
+  it("keeps partial SELECT FROM targets in table completion context", () => {
+    const { context, items } = semanticCompletion("SELECT * FROM ex|", {
+      tables: [
+        { name: "express", type: "table" },
+        { name: "orders", type: "table" },
+      ],
+    });
+
+    expect(context.suggestTables).toBe(true);
+    expect(context.exclusiveTableSuggestions).toBe(true);
+    expect(context.qualifier).toBeUndefined();
+    expect(context.qualifierParts).toBeUndefined();
+    expect(items.filter((item) => item.type === "table").map((item) => item.label)).toEqual(["express"]);
+  });
+
+  it("keeps JOIN modifier completion in keyword context", () => {
+    const { context, items } = semanticCompletion("SELECT * FROM users left |", {
+      tables: [{ name: "orders", type: "table" }],
+    });
+
+    expect(context.suggestTables).toBe(false);
+    expect(context.preferredKeywords).toContain("JOIN");
+    expect(items[0]?.label).toBe("JOIN");
+    expect(items.some((item) => item.type === "table")).toBe(false);
+  });
+
+  it("keeps table completion after completed LEFT JOIN", () => {
+    const { context, items } = semanticCompletion("SELECT * FROM users left join |", {
+      tables: [{ name: "orders", type: "table" }],
+    });
+
+    expect(context.suggestTables).toBe(true);
+    expect(items.filter((item) => item.type === "table").map((item) => item.label)).toEqual(["orders"]);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/semantic/dbeaver-references.md b/apps/desktop/src/lib/__tests__/sql/semantic/dbeaver-references.md
new file mode 100644
index 0000000..88016b5
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/semantic/dbeaver-references.md
@@ -0,0 +1,28 @@
+# SQL Semantic Completion DBeaver References
+
+This change uses the local DBeaver checkout at `/Users/skyler/VsCodeProjects/dbeaver` as the behavioral reference for semantic SQL completion.
+
+Key files reviewed:
+
+- `plugins/org.jkiss.dbeaver.ui.editors.sql/src/org/jkiss/dbeaver/ui/editors/sql/syntax/SQLCompletionProcessor.java`
+  - Selects semantic, legacy, or combined completion paths and handles asynchronous proposal jobs.
+- `plugins/org.jkiss.dbeaver.model.sql/src/org/jkiss/dbeaver/model/sql/semantics/completion/SQLQueryCompletionContext.java`
+  - Builds completion proposals from syntax inspection, lexical scope, row-source context, and cursor offset.
+- `plugins/org.jkiss.dbeaver.model.sql/src/org/jkiss/dbeaver/model/sql/semantics/context/SQLQueryRowsSourceContext.java`
+  - Tracks table sources, aliases, dynamic CTE sources, unresolved sources, and known-source collections.
+- `plugins/org.jkiss.dbeaver.model.sql/src/org/jkiss/dbeaver/model/sql/semantics/completion/SQLQueryCompletionAnalyzer.java`
+  - Converts semantic completion items into editor proposals with replacement ranges, descriptions, images, and scoring.
+
+DBX intentionally implements a smaller frontend semantic model first. The immediate goal is not DBeaver parser parity; it is to move cursor intent, row-source resolution, CTE/subquery handling, and fallback confidence into one reusable layer before routing completion, diagnostics, and navigation through it.
+
+## Completion Assistant Field Audit
+
+The semantic completion scopes added in this change fit the existing DBX completion assistant and item-builder fields:
+
+- Table/schema/catalog lookup maps to `suggestTables`, `qualifier`, `qualifierParts`, `schemas`, and existing table metadata lookup methods.
+- Routine/package lookup maps to `suggestRoutines`, `exclusiveRoutineSuggestions`, `qualifier`, and existing completion object lookup methods.
+- Alias, CTE, subquery, INSERT target, UPDATE target, join, and star column lookup maps to `referencedTables`, `columns`, `insertTable`, `updateTarget`, `deleteTarget`, `onStar`, and `columnsByTable`.
+- Projection aliases map to `prioritizeSelectAliases` and `selectAliases`.
+- Fallback confidence maps to the existing legacy `getSqlCompletionContext()` path without requiring broad all-column scans.
+
+No backend/API field gap was found for the current semantic scopes. The implementation therefore keeps the Java/Rust assistant protocol unchanged and limits new work to frontend semantic context, conversion, and tests.
diff --git a/apps/desktop/src/lib/__tests__/sql/semantic/model.spec.ts b/apps/desktop/src/lib/__tests__/sql/semantic/model.spec.ts
new file mode 100644
index 0000000..a8f73c1
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/semantic/model.spec.ts
@@ -0,0 +1,156 @@
+import { describe, expect, it } from "vitest";
+import { sqlSemanticCompletionScope, sqlSemanticLocalColumnsByTable, sqlSemanticProjectionAliasColumns } from "@/lib/sql/semantic/completion";
+import { SQL_SEMANTIC_BASELINE_FIXTURES, sqlFixtureCursor } from "@/lib/sql/semantic/fixtures";
+import { buildSqlSemanticModel } from "@/lib/sql/semantic/model";
+
+describe("sqlSemanticModel baseline fixtures", () => {
+  for (const fixture of SQL_SEMANTIC_BASELINE_FIXTURES) {
+    it(fixture.name, () => {
+      const { sql, cursor } = sqlFixtureCursor(fixture.sql);
+      const model = buildSqlSemanticModel(sql, cursor, { databaseType: fixture.databaseType });
+      const scope = sqlSemanticCompletionScope(model);
+
+      expect(model.statement.kind).toBe(fixture.expected.statementKind);
+      expect(model.cursorIntent.kind).toBe(fixture.expected.cursorKind);
+      expect(scope.kind).toBe(fixture.expected.completionScope);
+      expect(model.cursorIntent.prefix).toBe(fixture.expected.prefix);
+      expect(model.cursorIntent.qualifierParts).toEqual(fixture.expected.qualifierParts ?? []);
+      expect(model.cursorIntent.confidence).toBe(fixture.expected.confidence);
+
+      for (const expectedSource of fixture.expected.rowSources ?? []) {
+        const expectedObject = Object.fromEntries(Object.entries(expectedSource).filter(([, value]) => value !== undefined));
+        expect(model.rowSources).toEqual(expect.arrayContaining([expect.objectContaining(expectedObject)]));
+      }
+
+      if (fixture.expected.completionLabels) {
+        const labels = [...sqlSemanticLocalColumnsByTable(model).values()].flat().map((column) => column.name);
+        expect(labels).toEqual(expect.arrayContaining(fixture.expected.completionLabels));
+      }
+    });
+  }
+
+  it("does not mix row sources from inactive statements", () => {
+    const { sql, cursor } = sqlFixtureCursor("select * from users u; select * from orders o where o.|");
+    const model = buildSqlSemanticModel(sql, cursor);
+
+    expect(model.rowSources.some((source) => source.name === "orders")).toBe(true);
+    expect(model.rowSources.some((source) => source.name === "users")).toBe(false);
+  });
+
+  it("does not expose CTE body tables as outer query row sources", () => {
+    const { sql, cursor } = sqlFixtureCursor("WITH recent_orders AS (SELECT id FROM orders) SELECT * FROM recent_orders ro WHERE ro.|");
+    const model = buildSqlSemanticModel(sql, cursor);
+
+    expect(model.rowSources.some((source) => source.name === "recent_orders")).toBe(true);
+    expect(model.rowSources.some((source) => source.name === "orders")).toBe(false);
+  });
+
+  it("does not expose subquery body tables as outer query row sources", () => {
+    const { sql, cursor } = sqlFixtureCursor("SELECT * FROM (SELECT id FROM users) sq WHERE sq.|");
+    const model = buildSqlSemanticModel(sql, cursor);
+
+    expect(model.rowSources).toEqual(expect.arrayContaining([expect.objectContaining({ name: "sq", kind: "subquery" })]));
+    expect(model.rowSources.some((source) => source.name === "users")).toBe(false);
+  });
+
+  it("suppresses completion inside string literals without metadata scope", () => {
+    const { sql, cursor } = sqlFixtureCursor("SELECT 'u.|' FROM users");
+    const model = buildSqlSemanticModel(sql, cursor);
+    const scope = sqlSemanticCompletionScope(model);
+
+    expect(model.cursorIntent.kind).toBe("suppressed");
+    expect(scope.useRemoteMetadata).toBe(false);
+  });
+
+  it("classifies table references after comma-separated table lists", () => {
+    const { sql, cursor } = sqlFixtureCursor("SELECT * FROM users u, ord|");
+    const model = buildSqlSemanticModel(sql, cursor);
+    const scope = sqlSemanticCompletionScope(model);
+
+    expect(model.cursorIntent.kind).toBe("table");
+    expect(model.cursorIntent.prefix).toBe("ord");
+    expect(scope.kind).toBe("table");
+  });
+
+  it("classifies alias-qualified star with replacement range", () => {
+    const { sql, cursor } = sqlFixtureCursor("SELECT u.*| FROM users u");
+    const model = buildSqlSemanticModel(sql, cursor);
+
+    expect(model.cursorIntent.kind).toBe("star");
+    expect(model.cursorIntent.prefix).toBe("*");
+    expect(model.cursorIntent.qualifierParts).toEqual(["u"]);
+    expect(sql.slice(model.cursorIntent.replacementRange.start, model.cursorIntent.replacementRange.end)).toBe("*");
+  });
+
+  it("returns low-confidence keyword fallback for unknown SQL", () => {
+    const { sql, cursor } = sqlFixtureCursor("explain analyze |");
+    const model = buildSqlSemanticModel(sql, cursor);
+    const scope = sqlSemanticCompletionScope(model);
+
+    expect(model.cursorIntent.kind).toBe("keyword");
+    expect(model.cursorIntent.confidence).toBe("low");
+    expect(scope.useRemoteMetadata).toBe(false);
+  });
+
+  it("exposes PostgreSQL projection aliases in ORDER BY but not WHERE", () => {
+    const orderBy = sqlFixtureCursor("select total_amount as total from orders order by to|");
+    const where = sqlFixtureCursor("select total_amount as total from orders where to|");
+
+    expect(sqlSemanticProjectionAliasColumns(buildSqlSemanticModel(orderBy.sql, orderBy.cursor, { databaseType: "postgres" })).map((column) => column.name)).toContain("total");
+    expect(sqlSemanticProjectionAliasColumns(buildSqlSemanticModel(where.sql, where.cursor, { databaseType: "postgres" })).map((column) => column.name)).not.toContain("total");
+  });
+
+  it("exposes MySQL projection aliases in GROUP BY and HAVING", () => {
+    const groupBy = sqlFixtureCursor("select total_amount as total from orders group by to|");
+    const having = sqlFixtureCursor("select total_amount as total from orders having to|");
+
+    expect(sqlSemanticProjectionAliasColumns(buildSqlSemanticModel(groupBy.sql, groupBy.cursor, { databaseType: "mysql" })).map((column) => column.name)).toContain("total");
+    expect(sqlSemanticProjectionAliasColumns(buildSqlSemanticModel(having.sql, having.cursor, { databaseType: "mysql" })).map((column) => column.name)).toContain("total");
+  });
+
+  it("keeps dialect-specific identifier normalization and qualifier scopes", () => {
+    const sqlServer = sqlFixtureCursor("SELECT * FROM [dbo].[Users] u WHERE u.|");
+    const postgres = sqlFixtureCursor('SELECT total AS "Order Total" FROM "Sales"."Orders" o ORDER BY "Order|');
+    const mysql = sqlFixtureCursor("SELECT * FROM `analytics`.`events` e WHERE e.|");
+    const sqlite = sqlFixtureCursor("SELECT * FROM main.users u WHERE u.|");
+
+    expect(buildSqlSemanticModel(sqlServer.sql, sqlServer.cursor, { databaseType: "sqlserver" }).rowSources[0]).toEqual(expect.objectContaining({ name: "Users", qualifierParts: ["dbo"], alias: "u" }));
+    expect(sqlSemanticProjectionAliasColumns(buildSqlSemanticModel(postgres.sql, postgres.cursor, { databaseType: "postgres" })).map((column) => column.name)).toContain("Order Total");
+    expect(buildSqlSemanticModel(mysql.sql, mysql.cursor, { databaseType: "mysql" }).rowSources[0]).toEqual(expect.objectContaining({ name: "events", qualifierParts: ["analytics"], alias: "e" }));
+    expect(buildSqlSemanticModel(sqlite.sql, sqlite.cursor, { databaseType: "sqlite" }).rowSources[0]).toEqual(expect.objectContaining({ name: "users", qualifierParts: ["main"], alias: "u" }));
+  });
+
+  it("covers SQL Server case-insensitive bracket and multi-part qualifier contexts", () => {
+    const { sql, cursor } = sqlFixtureCursor("SELECT * FROM [ServerOne].[AppDb].[dbo].[Users] U WHERE u.na|");
+    const model = buildSqlSemanticModel(sql, cursor, { databaseType: "sqlserver" });
+
+    expect(model.rowSources[0]).toEqual(expect.objectContaining({ name: "Users", qualifierParts: ["ServerOne", "AppDb", "dbo"], alias: "U" }));
+    expect(model.cursorIntent.kind).toBe("alias_column");
+    expect(model.cursorIntent.qualifierParts).toEqual(["u"]);
+  });
+
+  it("covers PostgreSQL lower-case folding with CTEs and ORDER BY projection aliases", () => {
+    const { sql, cursor } = sqlFixtureCursor("WITH RecentOrders AS (SELECT id, total FROM orders) SELECT total AS total_alias FROM RecentOrders ro ORDER BY total_|");
+    const model = buildSqlSemanticModel(sql, cursor, { databaseType: "postgres" });
+
+    expect(model.rowSources).toEqual(expect.arrayContaining([expect.objectContaining({ name: "recentorders", alias: "ro", columns: ["id", "total"] })]));
+    expect(sqlSemanticProjectionAliasColumns(model).map((column) => column.name)).toContain("total_alias");
+  });
+
+  it("covers MySQL database-qualified backticks and projection alias visibility", () => {
+    const groupBy = sqlFixtureCursor("SELECT amount AS total FROM `analytics`.`events` e GROUP BY to|");
+    const where = sqlFixtureCursor("SELECT amount AS total FROM `analytics`.`events` e WHERE to|");
+
+    expect(buildSqlSemanticModel(groupBy.sql, groupBy.cursor, { databaseType: "mysql" }).rowSources[0]).toEqual(expect.objectContaining({ name: "events", qualifierParts: ["analytics"], alias: "e" }));
+    expect(sqlSemanticProjectionAliasColumns(buildSqlSemanticModel(groupBy.sql, groupBy.cursor, { databaseType: "mysql" })).map((column) => column.name)).toContain("total");
+    expect(sqlSemanticProjectionAliasColumns(buildSqlSemanticModel(where.sql, where.cursor, { databaseType: "mysql" })).map((column) => column.name)).not.toContain("total");
+  });
+
+  it("covers SQLite and DuckDB schema-light local row-source behavior", () => {
+    const sqlite = sqlFixtureCursor("SELECT * FROM main.users u WHERE u.|");
+    const duckdb = sqlFixtureCursor("SELECT * FROM read_csv('users.csv') csv WHERE csv.|");
+
+    expect(sqlSemanticCompletionScope(buildSqlSemanticModel(sqlite.sql, sqlite.cursor, { databaseType: "sqlite" })).useRemoteMetadata).toBe(true);
+    expect(buildSqlSemanticModel(duckdb.sql, duckdb.cursor, { databaseType: "duckdb" }).rowSources[0]).toEqual(expect.objectContaining({ kind: "table_function", name: "csv", alias: "csv" }));
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/semantic/references.spec.ts b/apps/desktop/src/lib/__tests__/sql/semantic/references.spec.ts
new file mode 100644
index 0000000..ac93fcc
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/semantic/references.spec.ts
@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { buildSqlSemanticDiagnostics } from "@/lib/sql/semantic/diagnostics";
+import { buildSqlSemanticModel } from "@/lib/sql/semantic/model";
+import { sqlFixtureCursor } from "@/lib/sql/semantic/fixtures";
+import { resolveSqlSemanticNavigationTarget, mergeSqlSemanticReferenceAnalysis, sqlSemanticCompletionReferenceTables, sqlSemanticTableReferences } from "@/lib/sql/semantic/references";
+import { splitQualifiedIdentifier } from "@/lib/sql/sqlNavigation";
+import type { SqlReferenceAnalysis } from "@/types/database";
+
+const span = (startColumn: number, endColumn: number) => ({
+  start_line: 1,
+  start_column: startColumn,
+  end_line: 1,
+  end_column: endColumn,
+});
+
+describe("sqlSemanticReferences shared consumers", () => {
+  it("feeds CTE projected columns to diagnostics without physical table metadata", () => {
+    const { sql, cursor } = sqlFixtureCursor("WITH recent_orders(id, total) AS (SELECT id, total FROM orders) SELECT ro.missing FROM recent_orders ro WHERE ro.|");
+    const model = buildSqlSemanticModel(sql, cursor);
+    const analysis: SqlReferenceAnalysis = {
+      tables: [],
+      columns: [{ name: "missing", qualifier: "ro", span: span(sql.indexOf("missing") + 1, sql.indexOf("missing") + "missing".length) }],
+    };
+
+    const diagnostics = buildSqlSemanticDiagnostics(mergeSqlSemanticReferenceAnalysis(analysis, model), {
+      tables: [],
+      columnsByTable: new Map(),
+      sql,
+    });
+
+    expect(diagnostics.map((diagnostic) => diagnostic.message)).toEqual(["Unknown column ro.missing"]);
+  });
+
+  it("resolves navigation targets from subquery aliases and projected columns", () => {
+    const { sql, cursor } = sqlFixtureCursor("SELECT sq.user_| FROM (SELECT id, name AS user_name FROM users) sq");
+    const model = buildSqlSemanticModel(sql, cursor);
+    const target = resolveSqlSemanticNavigationTarget(model, splitQualifiedIdentifier("sq.user_name"));
+
+    expect(target).toEqual(expect.objectContaining({ name: "sq", alias: "sq", columns: ["id", "user_name"] }));
+    expect(target?.source.kind).toBe("subquery");
+  });
+
+  it("keeps completion diagnostics and navigation row-source resolution consistent", () => {
+    const { sql, cursor } = sqlFixtureCursor("WITH recent_orders(id, total) AS (SELECT id, total FROM orders) SELECT * FROM recent_orders ro WHERE ro.|");
+    const model = buildSqlSemanticModel(sql, cursor);
+    const completionRefs = sqlSemanticCompletionReferenceTables(model);
+    const diagnosticRefs = sqlSemanticTableReferences(model);
+    const navigationTarget = resolveSqlSemanticNavigationTarget(model, ["ro", "total"]);
+
+    expect(completionRefs).toEqual(expect.arrayContaining([expect.objectContaining({ name: "recent_orders", alias: "ro", columns: ["id", "total"] })]));
+    expect(diagnosticRefs).toEqual(expect.arrayContaining([expect.objectContaining({ name: "recent_orders", alias: "ro", columns: ["id", "total"] })]));
+    expect(navigationTarget).toEqual(expect.objectContaining({ name: "recent_orders", alias: "ro", columns: ["id", "total"] }));
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/semantic/tokens.spec.ts b/apps/desktop/src/lib/__tests__/sql/semantic/tokens.spec.ts
new file mode 100644
index 0000000..5b66d99
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/semantic/tokens.spec.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { findActiveSqlStatementSpan, isSuppressedSqlSemanticContext, tokenizeSqlSemantic, unquoteSqlSemanticIdentifier } from "@/lib/sql/semantic/tokens";
+
+describe("sqlSemanticTokens", () => {
+  it("tokenizes comments, strings, quoted identifiers, brackets, and backticks", () => {
+    const sql = "select [User Name], `order`, \"Mixed\" from users -- comment\nwhere name = 'it''s ok'";
+    const tokens = tokenizeSqlSemantic(sql);
+
+    expect(tokens.some((token) => token.kind === "quoted_identifier" && unquoteSqlSemanticIdentifier(token) === "User Name")).toBe(true);
+    expect(tokens.some((token) => token.kind === "quoted_identifier" && unquoteSqlSemanticIdentifier(token) === "order")).toBe(true);
+    expect(tokens.some((token) => token.kind === "quoted_identifier" && unquoteSqlSemanticIdentifier(token) === "Mixed")).toBe(true);
+    expect(tokens.some((token) => token.kind === "comment" && token.text.includes("comment"))).toBe(true);
+    expect(tokens.some((token) => token.kind === "string" && token.text === "'it''s ok'")).toBe(true);
+  });
+
+  it("marks comments and string literals as suppressed contexts", () => {
+    const sql = "select * from users -- user.";
+    const tokens = tokenizeSqlSemantic(sql);
+
+    expect(isSuppressedSqlSemanticContext(tokens, sql.length)).toBe(true);
+    expect(isSuppressedSqlSemanticContext(tokens, "select * from users".length)).toBe(false);
+  });
+
+  it("finds active statement spans across semicolon-separated scripts", () => {
+    const sql = "select * from users;\nselect * from orders where id = 1;";
+    const cursor = sql.indexOf("orders");
+    const span = findActiveSqlStatementSpan(sql, tokenizeSqlSemantic(sql), cursor);
+
+    expect(sql.slice(span.start, span.end)).toBe("select * from orders where id = 1");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlCompletion.context.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlCompletion.context.spec.ts
new file mode 100644
index 0000000..dd41413
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlCompletion.context.spec.ts
@@ -0,0 +1,367 @@
+import { describe, expect, it } from "vitest";
+import { buildSqlCompletionItems, getSqlCompletionContext, shouldAutoOpenSqlCompletion } from "@/lib/sql/sqlCompletion";
+
+describe("sqlCompletion keyword snippets", () => {
+  it("auto-opens and suggests SELECT when typing sel", () => {
+    const sql = "sel";
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      tables: [],
+      columnsByTable: new Map(),
+    });
+
+    expect(shouldAutoOpenSqlCompletion(sql, sql.length)).toBe(true);
+    expect(items).toEqual(expect.arrayContaining([expect.objectContaining({ label: "select *", type: "snippet" }), expect.objectContaining({ label: "SELECT", type: "keyword" })]));
+  });
+});
+
+describe("sqlCompletion quoted schema qualifiers", () => {
+  it("parses quoted PostgreSQL schema names before a dot", () => {
+    const sql = 'SELECT *\nFROM "order-management".';
+    const context = getSqlCompletionContext(sql, sql.length);
+
+    expect(context.qualifier).toBe("order-management");
+    expect(context.prefix).toBe("");
+    expect(context.suggestTables).toBe(true);
+    expect(context.exclusiveColumnSuggestions).toBe(false);
+  });
+
+  it("suggests tables after a quoted schema qualifier", () => {
+    const sql = 'SELECT *\nFROM "order-management".';
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      dialect: "postgres",
+      tables: [
+        { name: "orders", schema: "order-management", type: "table" },
+        { name: "shipments", schema: "order-management", type: "table" },
+      ],
+      columnsByTable: new Map(),
+    });
+
+    expect(items.some((item) => item.label === "orders" && item.type === "table")).toBe(true);
+    expect(items.some((item) => item.label === "shipments" && item.type === "table")).toBe(true);
+  });
+});
+
+describe("sqlCompletion table targets", () => {
+  it("does not suggest aliases while completing an empty FROM target before LIMIT", () => {
+    const sql = "SELECT *\nFROM \nLIMIT 100;";
+    const cursor = "SELECT *\nFROM ".length;
+    const items = buildSqlCompletionItems(sql, cursor, {
+      tables: [{ name: "users", type: "table" }],
+      columnsByTable: new Map(),
+    });
+
+    expect(items.some((item) => item.type === "snippet" && item.detail === "alias for LIMIT")).toBe(false);
+    expect(items.some((item) => item.type === "table" && item.label === "users")).toBe(true);
+  });
+});
+
+describe("sqlCompletion table aliases", () => {
+  it("applies generated aliases to table completions when enabled", () => {
+    const sql = "SELECT * FROM ord";
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      tables: [{ name: "order_items", type: "table" }],
+      columnsByTable: new Map(),
+      autoAliasTables: true,
+    });
+
+    const table = items.find((item) => item.label === "order_items" && item.type === "table");
+    expect(table?.apply).toBe("order_items AS oi");
+  });
+
+  it("omits AS from Oracle table alias completions", () => {
+    const sql = "SELECT * FROM ord";
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      tables: [{ name: "order_items", type: "table" }],
+      columnsByTable: new Map(),
+      databaseType: "oracle",
+      autoAliasTables: true,
+    });
+
+    const table = items.find((item) => item.label === "order_items" && item.type === "table");
+    expect(table?.apply).toBe("order_items oi");
+  });
+
+  it("keeps plain table completions when generated aliases are disabled", () => {
+    const sql = "SELECT * FROM ord";
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      tables: [{ name: "order_items", type: "table" }],
+      columnsByTable: new Map(),
+      autoAliasTables: false,
+    });
+
+    const table = items.find((item) => item.label === "order_items" && item.type === "table");
+    expect(table?.apply).toBe("order_items");
+  });
+
+  it("omits AS from Oracle alias suggestions", () => {
+    const sql = "SELECT * FROM order_items ";
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      tables: [{ name: "order_items", type: "table" }],
+      columnsByTable: new Map(),
+      databaseType: "oracle",
+    });
+
+    const alias = items.find((item) => item.type === "snippet" && item.detail === "alias for order_items");
+    expect(alias?.apply).toBe("oi ");
+  });
+
+  it("uses a numbered alias when the generated table alias already exists", () => {
+    const sql = "SELECT * FROM order_items oi JOIN ord";
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      tables: [{ name: "order_items", type: "table" }],
+      columnsByTable: new Map(),
+      autoAliasTables: true,
+    });
+
+    const table = items.find((item) => item.label === "order_items" && item.type === "table");
+    expect(table?.apply).toBe("order_items AS oi2");
+  });
+
+  it("applies generated aliases in comma-separated FROM table lists", () => {
+    const sql = "SELECT * FROM users u, ord";
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      tables: [{ name: "order_items", type: "table" }],
+      columnsByTable: new Map(),
+      autoAliasTables: true,
+    });
+
+    const table = items.find((item) => item.label === "order_items" && item.type === "table");
+    expect(table?.apply).toBe("order_items AS oi");
+  });
+
+  it("does not apply generated aliases to non-query table completions", () => {
+    const sql = "INSERT INTO ord";
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      tables: [{ name: "order_items", type: "table" }],
+      columnsByTable: new Map(),
+      autoAliasTables: true,
+    });
+
+    const table = items.find((item) => item.label === "order_items" && item.type === "table");
+    expect(table?.apply).toBe("order_items");
+  });
+});
+
+describe("sqlCompletion scoped context classification", () => {
+  it("classifies JOIN table contexts", () => {
+    const sql = "SELECT * FROM users u JOIN ";
+    const context = getSqlCompletionContext(sql, sql.length);
+
+    expect(context.contextKind).toBe("join");
+    expect(context.suggestTables).toBe(true);
+    expect(context.exclusiveTableSuggestions).toBe(true);
+  });
+
+  it("classifies alias-qualified column contexts", () => {
+    const sql = "SELECT * FROM users u WHERE u.";
+    const context = getSqlCompletionContext(sql, sql.length);
+
+    expect(context.contextKind).toBe("alias_column");
+    expect(context.qualifier).toBe("u");
+    expect(context.suggestColumns).toBe(true);
+  });
+
+  it("keeps alias-qualified column context after select-list subqueries", () => {
+    const sql = `
+      SELECT
+        p.id,
+        p.create_user_name 'creator',
+        (SELECT t.\`code\` FROM sys_user t WHERE t.user_id = p.apply_user_id) 'creator_code',
+        p.
+      FROM sys_process p
+      LIMIT 10
+    `;
+    const cursor = sql.indexOf("p.\n      FROM");
+    const context = getSqlCompletionContext(sql, cursor + 2);
+
+    expect(context.contextKind).toBe("alias_column");
+    expect(context.qualifier).toBe("p");
+    expect(context.suggestTables).toBe(false);
+    expect(context.exclusiveTableSuggestions).toBe(false);
+    expect(context.suggestColumns).toBe(true);
+  });
+
+  it("suggests alias columns after select-list subqueries instead of tables", () => {
+    const sql = `
+      SELECT
+        p.id,
+        p.create_user_name 'creator',
+        (SELECT t.\`code\` FROM sys_user t WHERE t.user_id = p.apply_user_id) 'creator_code',
+        p.
+      FROM sys_process p
+      LIMIT 10
+    `;
+    const cursor = sql.indexOf("p.\n      FROM") + 2;
+    const items = buildSqlCompletionItems(sql, cursor, {
+      dialect: "mysql",
+      tables: [
+        { name: "act_evt_log", type: "table" },
+        { name: "sys_process", type: "table" },
+        { name: "sys_user", type: "table" },
+      ],
+      columnsByTable: new Map([
+        [
+          "sys_process",
+          [
+            { name: "id", table: "sys_process" },
+            { name: "create_user_name", table: "sys_process" },
+            { name: "apply_user_id", table: "sys_process" },
+          ],
+        ],
+        ["sys_user", [{ name: "code", table: "sys_user" }]],
+      ]),
+    });
+
+    const columnLabels = items.filter((item) => item.type === "column").map((item) => item.label);
+    expect(columnLabels).toEqual(expect.arrayContaining(["id", "create_user_name", "apply_user_id"]));
+    expect(items[0]?.type).toBe("column");
+    expect(items.some((item) => item.type === "table")).toBe(false);
+    expect(items.some((item) => item.type === "keyword")).toBe(false);
+  });
+
+  it("classifies unqualified WHERE field input as column context", () => {
+    const sql = "SELECT * FROM A1User WHERE userc";
+    const context = getSqlCompletionContext(sql, sql.length);
+
+    expect(context.contextKind).toBe("column");
+    expect(context.prefix).toBe("userc");
+    expect(context.referencedTables).toEqual(expect.arrayContaining([expect.objectContaining({ name: "A1User" })]));
+    expect(context.suggestColumns).toBe(true);
+    expect(context.suggestRoutines).toBe(false);
+  });
+
+  it("auto-opens column completion after WHERE whitespace before LIMIT", () => {
+    const sql = "SELECT *\nFROM t_0001 AS t0 WHERE \nLIMIT 100;";
+    const cursor = "SELECT *\nFROM t_0001 AS t0 WHERE ".length;
+    const context = getSqlCompletionContext(sql, cursor);
+
+    expect(context.contextKind).toBe("column");
+    expect(context.prefix).toBe("");
+    expect(context.referencedTables).toEqual(expect.arrayContaining([expect.objectContaining({ name: "t_0001", alias: "t0" })]));
+    expect(context.suggestColumns).toBe(true);
+    expect(shouldAutoOpenSqlCompletion(sql, cursor)).toBe(true);
+  });
+
+  it("classifies CALL routine contexts", () => {
+    const sql = "CALL usp_";
+    const context = getSqlCompletionContext(sql, sql.length);
+
+    expect(context.contextKind).toBe("exec");
+    expect(context.suggestRoutines).toBe(true);
+    expect(context.exclusiveRoutineSuggestions).toBe(true);
+  });
+
+  it("classifies INSERT column-list contexts", () => {
+    const sql = "INSERT INTO dbo.Users (";
+    const context = getSqlCompletionContext(sql, sql.length);
+
+    expect(context.contextKind).toBe("column");
+    expect(context.insertSchema).toBe("dbo");
+    expect(context.insertTable).toBe("Users");
+    expect(context.exclusiveColumnSuggestions).toBe(true);
+  });
+
+  it("classifies UPDATE SET column contexts", () => {
+    const sql = "UPDATE dbo.Users SET ";
+    const context = getSqlCompletionContext(sql, sql.length);
+
+    expect(context.contextKind).toBe("column");
+    expect(context.updateTarget).toEqual({ schema: "dbo", table: "Users" });
+    expect(context.suggestColumns).toBe(true);
+  });
+
+  it("extracts statement-local table aliases", () => {
+    const sql = "SELECT * FROM dbo.Users u JOIN Orders AS o ON o.user_id = u.id WHERE u.";
+    const context = getSqlCompletionContext(sql, sql.length);
+
+    expect(context.referencedTables).toEqual(expect.arrayContaining([expect.objectContaining({ schema: "dbo", name: "Users", alias: "u" }), expect.objectContaining({ name: "Orders", alias: "o" })]));
+  });
+
+  it("treats schema-qualified table prefixes in FROM as table completion input", () => {
+    const sql = "SELECT * FROM dws_game_sdk_base.di";
+    const context = getSqlCompletionContext(sql, sql.length);
+
+    expect(context.qualifier).toBe("dws_game_sdk_base");
+    expect(context.prefix).toBe("di");
+    expect(context.suggestTables).toBe(true);
+    expect(context.exclusiveTableSuggestions).toBe(true);
+    expect(context.suggestColumns).toBe(true);
+  });
+
+  it("exposes CTEs as table-like referenced tables", () => {
+    const sql = "WITH recent_orders(id, total) AS (SELECT id, total FROM orders) SELECT * FROM recent_orders ro WHERE ro.";
+    const context = getSqlCompletionContext(sql, sql.length);
+
+    expect(context.referencedTables).toEqual(expect.arrayContaining([expect.objectContaining({ name: "recent_orders", columns: ["id", "total"] }), expect.objectContaining({ name: "recent_orders", alias: "ro" })]));
+  });
+
+  it("extracts subquery aliases and projected columns", () => {
+    const sql = "SELECT * FROM (SELECT id, name AS user_name FROM users) sq WHERE sq.";
+    const context = getSqlCompletionContext(sql, sql.length);
+
+    expect(context.referencedTables).toEqual(expect.arrayContaining([expect.objectContaining({ name: "sq", alias: "sq", columns: ["id", "user_name"] })]));
+  });
+
+  it("suggests columns for cross-database qualified table references", () => {
+    const sql = "SELECT * FROM current_orders WHERE reporting.orders.";
+    const context = getSqlCompletionContext(sql, sql.length);
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      tables: [],
+      columnsByTable: new Map([
+        [
+          "reporting.orders",
+          [
+            { name: "id", table: "orders", schema: "reporting", dataType: "int" },
+            { name: "status", table: "orders", schema: "reporting", dataType: "varchar" },
+          ],
+        ],
+        ["archive.orders", [{ name: "archived_at", table: "orders", schema: "archive", dataType: "datetime" }]],
+      ]),
+    });
+
+    expect(context.qualifier).toBe("reporting.orders");
+    expect(context.qualifierParts).toEqual(["reporting", "orders"]);
+    expect(context.suggestColumns).toBe(true);
+    expect(items).toEqual(expect.arrayContaining([expect.objectContaining({ label: "id", type: "column" }), expect.objectContaining({ label: "status", type: "column" })]));
+    expect(items.some((item) => item.label === "archived_at")).toBe(false);
+  });
+});
+
+describe("sqlCompletion scoped metadata ranking", () => {
+  it("ranks exact and prefix table matches ahead of contains/fuzzy matches", () => {
+    const sql = "SELECT * FROM Temp";
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      dialect: "sqlserver",
+      tables: [
+        { name: "ArchiveTempTable", schema: "dbo", type: "table" },
+        { name: "TempAudit", schema: "dbo", type: "table" },
+        { name: "Temp", schema: "dbo", type: "table" },
+        { name: "Template", schema: "dbo", type: "table" },
+      ],
+      columnsByTable: new Map(),
+    }).filter((item) => item.type === "table");
+
+    expect(items.map((item) => item.label).slice(0, 3)).toEqual(["Temp", "Template", "TempAudit"]);
+    expect(items.some((item) => item.label === "ArchiveTempTable")).toBe(true);
+  });
+
+  it("keeps large table catalogs bounded", () => {
+    const tables = Array.from({ length: 500 }, (_, index) => ({ name: `TempTable_${String(index).padStart(3, "0")}`, schema: "dbo", type: "table" as const }));
+    const sql = "SELECT * FROM Temp";
+    const items = buildSqlCompletionItems(sql, sql.length, { dialect: "sqlserver", tables, columnsByTable: new Map() }).filter((item) => item.type === "table");
+
+    expect(items.length).toBeLessThanOrEqual(200);
+    expect(items[0]?.label).toBe("TempTable_000");
+  });
+
+  it("ranks real Oracle tables before built-in table functions in FROM contexts", () => {
+    const sql = "SELECT * FROM ";
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      databaseType: "oracle",
+      tables: [{ name: "ORDERS_10K", schema: "DBX_TEST", type: "table" }],
+      columnsByTable: new Map(),
+    });
+
+    expect(items.findIndex((item) => item.label === "ORDERS_10K")).toBeLessThan(items.findIndex((item) => item.label === "TABLE"));
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlCompletion.snippet.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlCompletion.snippet.spec.ts
new file mode 100644
index 0000000..6381195
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlCompletion.snippet.spec.ts
@@ -0,0 +1,109 @@
+import { describe, it, expect } from "vitest";
+import { buildSnippetItemsForTest } from "@/lib/sql/sqlCompletion";
+import type { SqlSnippet } from "@/types/database";
+
+const TEST_SNIPPETS: SqlSnippet[] = [
+  { id: "1", label: "select all", prefix: "sel", body: "SELECT *\nFROM my_table;" },
+  { id: "2", label: "insert row", prefix: "ins", body: "INSERT INTO my_table VALUES (1);" },
+];
+
+const BUILTIN_SELECT: SqlSnippet = { id: "builtin-sel", label: "select *", prefix: "sel", body: "SELECT *\nFROM table\nLIMIT 100;" };
+const BUILTIN_CREATE_TABLE: SqlSnippet = { id: "builtin-ct", label: "create table", prefix: "ct", body: "CREATE TABLE table (\n  column type\n);" };
+const BUILTIN_UPDATE: SqlSnippet = { id: "builtin-upd", label: "update set", prefix: "upd", body: "UPDATE table\nSET column = value\nWHERE condition;" };
+const BUILTIN_CTE: SqlSnippet = { id: "builtin-cte", label: "common table expression", prefix: "cte", body: "WITH name AS (\n  SELECT columns\n  FROM table\n)\nSELECT *\nFROM name;" };
+const BUILTIN_INSERT: SqlSnippet = { id: "builtin-ins", label: "insert into", prefix: "ins", body: "INSERT INTO table (columns)\nVALUES (values);" };
+const BUILTIN_JOIN: SqlSnippet = { id: "builtin-join", label: "join", prefix: "join", body: "JOIN table ON left_column = right_column" };
+const BUILTIN_CASE: SqlSnippet = { id: "builtin-case", label: "case when", prefix: "case", body: "CASE\n  WHEN condition THEN value\n  ELSE default\nEND" };
+const BUILTIN_CREATE_INDEX: SqlSnippet = { id: "builtin-ci", label: "create index", prefix: "ci", body: "CREATE INDEX idx_name\nON table (column);" };
+
+describe("buildSnippetItems", () => {
+  it("returns matching snippet by prefix", () => {
+    const items = buildSnippetItemsForTest("sel", TEST_SNIPPETS);
+    expect(items).toHaveLength(1);
+    expect(items[0].label).toBe("select all");
+    expect(items[0].detail).toBe("SELECT *\nFROM my_table;");
+    expect(items[0].apply).toBe("SELECT *\nFROM my_table;");
+  });
+
+  it("uses CodeMirror placeholders for the built-in select snippet", () => {
+    const items = buildSnippetItemsForTest("sel", [BUILTIN_SELECT]);
+
+    expect(items[0].detail).toBe("SELECT *\nFROM table\nLIMIT 100;");
+    expect(items[0].apply).toBe("SELECT *\nFROM ${table}\nLIMIT 100;");
+  });
+
+  it("replaces placeholder words but preserves uppercase SQL keywords", () => {
+    const items = buildSnippetItemsForTest("ct", [BUILTIN_CREATE_TABLE]);
+
+    expect(items[0].apply).toBe("CREATE TABLE ${table} (\n  ${column} ${type}\n);");
+  });
+
+  it("adds placeholders across built-in update snippets", () => {
+    const items = buildSnippetItemsForTest("upd", [BUILTIN_UPDATE]);
+
+    expect(items[0].apply).toBe("UPDATE ${table}\nSET ${column} = ${value}\nWHERE ${condition};");
+  });
+
+  it("keeps keyword casing separate from editable placeholders", () => {
+    const items = buildSnippetItemsForTest("sel", [BUILTIN_SELECT], "lower");
+
+    expect(items[0].detail).toBe("select *\nfrom table\nlimit 100;");
+    expect(items[0].apply).toBe("select *\nfrom ${table}\nlimit 100;");
+  });
+
+  it("determines placeholders from original casing even when keywords are lowercased", () => {
+    const items = buildSnippetItemsForTest("ct", [BUILTIN_CREATE_TABLE], "lower");
+
+    expect(items[0].detail).toBe("create table table (\n  column type\n);");
+    expect(items[0].apply).toBe("create table ${table} (\n  ${column} ${type}\n);");
+  });
+
+  it("wraps repeated placeholder words in CTE snippets", () => {
+    const items = buildSnippetItemsForTest("cte", [BUILTIN_CTE]);
+
+    expect(items[0].apply).toBe("WITH ${name} AS (\n  SELECT ${columns}\n  FROM ${table}\n)\nSELECT *\nFROM ${name};");
+  });
+
+  it.each([
+    [BUILTIN_INSERT, "INSERT INTO ${table} (${columns})\nVALUES (${values});"],
+    [BUILTIN_JOIN, "JOIN ${table} ON ${left_column} = ${right_column}"],
+    [BUILTIN_CASE, "CASE\n  WHEN ${condition} THEN ${value}\n  ELSE ${default}\nEND"],
+    [BUILTIN_CREATE_INDEX, "CREATE INDEX ${idx_name}\nON ${table} (${column});"],
+  ])("adds placeholders for built-in %s snippet", (snippet, expectedApply) => {
+    const items = buildSnippetItemsForTest(snippet.prefix, [snippet]);
+
+    expect(items[0].apply).toBe(expectedApply);
+  });
+
+  it("returns matching snippet by label substring", () => {
+    const items = buildSnippetItemsForTest("select", TEST_SNIPPETS);
+    expect(items).toHaveLength(1);
+    expect(items[0].label).toBe("select all");
+  });
+
+  it("does not return disabled snippets", () => {
+    const items = buildSnippetItemsForTest("sel", [{ ...TEST_SNIPPETS[0], enabled: false }, TEST_SNIPPETS[1]]);
+    expect(items).toEqual([]);
+  });
+
+  it("does not keep matching a renamed snippet by its old short label prefix", () => {
+    const items = buildSnippetItemsForTest("sel", [{ id: "1", label: "select all", prefix: "fff", body: "SELECT *\nFROM my_table;" }]);
+    expect(items).toEqual([]);
+  });
+
+  it("still matches a renamed snippet by label when typing a longer descriptive query", () => {
+    const items = buildSnippetItemsForTest("select", [{ id: "1", label: "select all", prefix: "fff", body: "SELECT *\nFROM my_table;" }]);
+    expect(items).toHaveLength(1);
+    expect(items[0].label).toBe("select all");
+  });
+
+  it("returns empty for no match", () => {
+    const items = buildSnippetItemsForTest("zzz", TEST_SNIPPETS);
+    expect(items).toEqual([]);
+  });
+
+  it("returns empty for empty prefix", () => {
+    const items = buildSnippetItemsForTest("", TEST_SNIPPETS);
+    expect(items).toEqual([]);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlCompletionLookupTarget.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlCompletionLookupTarget.spec.ts
new file mode 100644
index 0000000..eac0929
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlCompletionLookupTarget.spec.ts
@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import { resolveSqlCompletionTableLookupTarget } from "@/lib/sql/sqlCompletionLookupTarget";
+
+describe("sqlCompletionLookupTarget", () => {
+  it("treats qualified table completion as a database lookup for MySQL-compatible engines", () => {
+    const target = resolveSqlCompletionTableLookupTarget({
+      currentDatabase: "default_db",
+      supportsDatabaseQualifier: true,
+      completionContext: {
+        qualifier: "game_data",
+        prefix: "",
+        suggestTables: true,
+      },
+    });
+
+    expect(target).toEqual({
+      database: "game_data",
+      filter: "",
+      qualifierDatabase: "game_data",
+    });
+  });
+
+  it("preserves the known database casing when the qualifier matches locally", () => {
+    const target = resolveSqlCompletionTableLookupTarget({
+      currentDatabase: "default_db",
+      supportsDatabaseQualifier: true,
+      knownDatabases: ["Game_Data"],
+      completionContext: {
+        qualifier: "game_data",
+        prefix: "ord",
+        suggestTables: true,
+      },
+    });
+
+    expect(target).toEqual({
+      database: "Game_Data",
+      filter: "ord",
+      qualifierDatabase: "Game_Data",
+    });
+  });
+
+  it("keeps schema-aware qualified table completion scoped to the schema", () => {
+    const target = resolveSqlCompletionTableLookupTarget({
+      currentDatabase: "app",
+      currentSchema: "public",
+      supportsDatabaseQualifier: false,
+      completionContext: {
+        qualifier: "sales",
+        prefix: "ord",
+        suggestTables: true,
+      },
+    });
+
+    expect(target).toEqual({
+      database: "app",
+      schema: "sales",
+      filter: "ord",
+    });
+  });
+
+  it("uses the current schema for unqualified table completion", () => {
+    const target = resolveSqlCompletionTableLookupTarget({
+      currentDatabase: "app",
+      currentSchema: "public",
+      supportsDatabaseQualifier: true,
+      completionContext: {
+        prefix: "ord",
+        suggestTables: true,
+      },
+    });
+
+    expect(target).toEqual({
+      database: "app",
+      schema: "public",
+      filter: "ord",
+    });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlExecutionTarget.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlExecutionTarget.spec.ts
new file mode 100644
index 0000000..5725a02
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlExecutionTarget.spec.ts
@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { resolveExecutableSql } from "@/lib/sql/sqlExecutionTarget";
+
+describe("resolveExecutableSql", () => {
+  it("uses selected SQL before cursor-mode resolution", () => {
+    const sql = "select 1;\n\nselect 2;";
+    const selectedSql = " select 2; ";
+    const cursorAfterFirstSemicolon = sql.indexOf(";") + 1;
+
+    expect(resolveExecutableSql(sql, selectedSql, { mode: "current", cursorPos: cursorAfterFirstSemicolon })).toBe("select 2;");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlFileOpen.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlFileOpen.spec.ts
new file mode 100644
index 0000000..80e8822
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlFileOpen.spec.ts
@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { externalSqlFileDisplayTitles, normalizeExternalSqlPath } from "@/lib/sql/sqlFileOpen";
+
+describe("external SQL file paths", () => {
+  it("normalizes Windows separators for identity checks", () => {
+    expect(normalizeExternalSqlPath(" C:\\work\\demo.sql ")).toBe("C:/work/demo.sql");
+  });
+
+  it("uses the shortest unique parent path for duplicate filenames", () => {
+    expect(externalSqlFileDisplayTitles(["/work/demo/create.sql", "/work/learn/create.sql", "/work/query.sql"])).toEqual(["demo/create.sql", "learn/create.sql", "query.sql"]);
+  });
+
+  it("adds more parent segments when immediate parents also collide", () => {
+    expect(externalSqlFileDisplayTitles(["/one/sql/create.sql", "/two/sql/create.sql"])).toEqual(["one/sql/create.sql", "two/sql/create.sql"]);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlFormatter.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlFormatter.spec.ts
new file mode 100644
index 0000000..b68414d
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlFormatter.spec.ts
@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { formatSqlForDisplay, formatSqlText, MAX_SQL_FORMAT_CHARS, sqlFormatDialectForDbType } from "@/lib/sql/sqlFormatter";
+
+describe("sqlFormatter", () => {
+  it("maps PostgreSQL-compatible database types to the postgres formatter dialect", () => {
+    for (const dbType of ["postgres", "kwdb", "gaussdb", "opengauss", "questdb", "kingbase", "highgo", "vastbase", "redshift"]) {
+      expect(sqlFormatDialectForDbType(dbType)).toBe("postgres");
+    }
+  });
+
+  it("maps SQLite-compatible database types to the sqlite formatter dialect", () => {
+    for (const dbType of ["sqlite", "rqlite", "turso", "cloudflare-d1"]) {
+      expect(sqlFormatDialectForDbType(dbType)).toBe("sqlite");
+    }
+  });
+
+  it("falls back to the postgres formatter when the generic dialect cannot parse SQL", async () => {
+    const formatted = await formatSqlText("SELECT 1::int AS id;", "generic");
+
+    expect(formatted).toContain("1::int");
+    expect(formatted).toContain("AS id");
+  });
+
+  it("returns the original SQL for display when formatting fails", async () => {
+    const oversizedSql = "x".repeat(MAX_SQL_FORMAT_CHARS + 1);
+
+    await expect(formatSqlText(oversizedSql, "postgres")).rejects.toThrow("SQL is too large to format safely.");
+    await expect(formatSqlForDisplay(oversizedSql, "postgres")).resolves.toBe(oversizedSql);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlFormatterConfig.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlFormatterConfig.spec.ts
new file mode 100644
index 0000000..92314fb
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlFormatterConfig.spec.ts
@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+import { DEFAULT_SQL_FORMATTER_SETTINGS, parseSqlFormatterConfig, serializeSqlFormatterConfig } from "@/lib/sql/sqlFormatterConfig";
+
+describe("sqlFormatterConfig shortcut storage", () => {
+  it("does not serialize JSON editor shortcut settings", () => {
+    const config = JSON.parse(serializeSqlFormatterConfig(DEFAULT_SQL_FORMATTER_SETTINGS));
+
+    expect(config.editor).toBeUndefined();
+  });
+
+  it("ignores legacy JSON editor shortcut settings on import", () => {
+    const result = parseSqlFormatterConfig(
+      JSON.stringify({
+        version: 1,
+        formatter: "sql-formatter",
+        options: {},
+        editor: {
+          scope: "legacyJsonEditorScope",
+          shortcuts: [{ id: "unknownLegacyShortcut", enabled: "yes" }],
+        },
+      }),
+    );
+
+    expect(result.ok).toBe(true);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlHighlighter.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlHighlighter.spec.ts
new file mode 100644
index 0000000..b9c4480
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlHighlighter.spec.ts
@@ -0,0 +1,27 @@
+import { describe, expect, it, vi } from "vitest";
+import { createSafeSqlHighlighter, escapeHtml } from "@/lib/sql/sqlHighlighter";
+
+describe("escapeHtml", () => {
+  it("escapes SQL text for v-html fallback rendering", () => {
+    expect(escapeHtml(`SELECT '<tag>' AS "name" & col`)).toBe("SELECT &#39;&lt;tag&gt;&#39; AS &quot;name&quot; &amp; col");
+  });
+});
+
+describe("createSafeSqlHighlighter", () => {
+  it("falls back to escaped SQL when Shiki highlighting fails", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const highlighter = createSafeSqlHighlighter(
+      {
+        codeToHtml: () => {
+          throw new SyntaxError("Invalid regular expression: invalid group specifier name");
+        },
+      },
+      { appearance: () => "light" },
+    );
+
+    expect(highlighter(`ALTER TABLE t ADD "<x>" INT;`)).toBe("ALTER TABLE t ADD &quot;&lt;x&gt;&quot; INT;");
+    expect(warn).toHaveBeenCalledOnce();
+
+    warn.mockRestore();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlInListPaste.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlInListPaste.spec.ts
new file mode 100644
index 0000000..cfb3d86
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlInListPaste.spec.ts
@@ -0,0 +1,110 @@
+import { describe, expect, it } from "vitest";
+import { buildSqlInConditionFromPasteSource, insertTextForSqlInCondition, SQL_IN_LIST_PASTE_MAX_SOURCE_LENGTH, SQL_IN_LIST_PASTE_MAX_VALUES } from "@/lib/sql/sqlInListPaste";
+
+describe("sqlInListPaste", () => {
+  it("builds an IN condition from newline values", () => {
+    expect(buildSqlInConditionFromPasteSource("A\nB\nC")).toEqual({
+      ok: true,
+      sql: "IN ('A', 'B', 'C')",
+      valueCount: 3,
+    });
+  });
+
+  it("splits comma, tab, and newline separated clipboard content", () => {
+    expect(buildSqlInConditionFromPasteSource("A\tB\nC,D")).toEqual({
+      ok: true,
+      sql: "IN ('A', 'B', 'C', 'D')",
+      valueCount: 4,
+    });
+  });
+
+  it("splits simple slash-separated value lists", () => {
+    expect(buildSqlInConditionFromPasteSource("1/2/3")).toEqual({
+      ok: true,
+      sql: "IN ('1', '2', '3')",
+      valueCount: 3,
+    });
+    expect(buildSqlInConditionFromPasteSource("A/B/C")).toEqual({
+      ok: true,
+      sql: "IN ('A', 'B', 'C')",
+      valueCount: 3,
+    });
+  });
+
+  it("does not treat common dates, URLs, or absolute paths as value lists", () => {
+    expect(buildSqlInConditionFromPasteSource("2026/07/07")).toEqual({ ok: false, reason: "not-list" });
+    expect(buildSqlInConditionFromPasteSource("http://example.com/a/b")).toEqual({ ok: false, reason: "not-list" });
+    expect(buildSqlInConditionFromPasteSource("/Users/staff/dbx")).toEqual({ ok: false, reason: "not-list" });
+  });
+
+  it("quotes all non-NULL values uniformly including numbers", () => {
+    expect(buildSqlInConditionFromPasteSource("1\n-2.5\n001\nnull\nA1")).toEqual({
+      ok: true,
+      sql: "IN ('1', '-2.5', '001', NULL, 'A1')",
+      valueCount: 5,
+    });
+  });
+
+  it("strips existing SQL list wrappers and escapes single quotes once", () => {
+    expect(buildSqlInConditionFromPasteSource("('O''Reilly', \"Bob\")")).toEqual({
+      ok: true,
+      sql: "IN ('O''Reilly', 'Bob')",
+      valueCount: 2,
+    });
+    expect(buildSqlInConditionFromPasteSource("IN ('A', 'B')")).toEqual({
+      ok: true,
+      sql: "IN ('A', 'B')",
+      valueCount: 2,
+    });
+    expect(buildSqlInConditionFromPasteSource("('A')")).toEqual({
+      ok: true,
+      sql: "IN ('A')",
+      valueCount: 1,
+    });
+  });
+
+  it("does not split delimiters inside quoted values", () => {
+    expect(buildSqlInConditionFromPasteSource("'A,B'\n'C\tD'")).toEqual({
+      ok: true,
+      sql: "IN ('A,B', 'C\tD')",
+      valueCount: 2,
+    });
+  });
+
+  it("treats apostrophes inside unquoted values as text", () => {
+    expect(buildSqlInConditionFromPasteSource("O'Reilly\nBob")).toEqual({
+      ok: true,
+      sql: "IN ('O''Reilly', 'Bob')",
+      valueCount: 2,
+    });
+  });
+
+  it("returns empty for blank or delimiter-only content", () => {
+    expect(buildSqlInConditionFromPasteSource(" \n,\t ")).toEqual({ ok: false, reason: "empty" });
+  });
+
+  it("does not process unrelated single text values", () => {
+    expect(buildSqlInConditionFromPasteSource("paste some random text here")).toEqual({ ok: false, reason: "not-list" });
+    expect(buildSqlInConditionFromPasteSource("O'Reilly")).toEqual({ ok: false, reason: "not-list" });
+  });
+
+  it("guards very large paste input and value count", () => {
+    expect(buildSqlInConditionFromPasteSource("x".repeat(SQL_IN_LIST_PASTE_MAX_SOURCE_LENGTH + 1))).toEqual({
+      ok: false,
+      reason: "too-large",
+      limit: SQL_IN_LIST_PASTE_MAX_SOURCE_LENGTH,
+    });
+    expect(buildSqlInConditionFromPasteSource(Array.from({ length: SQL_IN_LIST_PASTE_MAX_VALUES + 1 }, (_, index) => String(index)).join("\n"))).toEqual({
+      ok: false,
+      reason: "too-many-values",
+      limit: SQL_IN_LIST_PASTE_MAX_VALUES,
+    });
+  });
+
+  it("avoids duplicating IN when the cursor is already after IN or NOT IN", () => {
+    expect(insertTextForSqlInCondition("IN ('A')", "where id in ")).toBe("('A')");
+    expect(insertTextForSqlInCondition("IN ('A')", "where id not in")).toBe("('A')");
+    expect(insertTextForSqlInCondition("IN ('A')", "where id")).toBe(" IN ('A')");
+    expect(insertTextForSqlInCondition("IN ('A')", "where id = ")).toBe("IN ('A')");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlNavigation.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlNavigation.spec.ts
new file mode 100644
index 0000000..9898d62
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlNavigation.spec.ts
@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import { extractIdentifierAt, extractIdentifierDetailsAt, isSqlKeyword, matchTable, splitQualifiedIdentifier } from "@/lib/sql/sqlNavigation";
+
+describe("extractIdentifierAt", () => {
+  it("extracts unquoted qualified identifiers", () => {
+    const sql = "select * from MAAC00.Accounts";
+
+    expect(extractIdentifierAt(sql, sql.indexOf("Accounts"))).toBe("MAAC00.Accounts");
+  });
+
+  it("extracts backtick-quoted qualified identifiers", () => {
+    const sql = "select * from `MAAC00`.Accounts";
+
+    expect(extractIdentifierAt(sql, sql.indexOf("Accounts"))).toBe("MAAC00.Accounts");
+    expect(extractIdentifierAt(sql, sql.indexOf("MAAC00"))).toBe("MAAC00.Accounts");
+  });
+
+  it("preserves quote metadata for quoted keyword identifiers", () => {
+    const sql = "SELECT * FROM `group` LIMIT 100;";
+
+    expect(extractIdentifierDetailsAt(sql, sql.indexOf("group"))).toEqual({
+      identifier: "group",
+      quoted: true,
+    });
+    expect(matchTable(extractIdentifierAt(sql, sql.indexOf("group")) ?? "", [{ name: "group" }])).toEqual({ name: "group" });
+  });
+
+  it("marks unquoted keyword identifiers as unquoted", () => {
+    const sql = "SELECT dept, COUNT(*) FROM users GROUP BY dept;";
+    const extracted = extractIdentifierDetailsAt(sql, sql.indexOf("GROUP"));
+
+    expect(extracted).toEqual({
+      identifier: "GROUP",
+      quoted: false,
+    });
+    expect(extracted && isSqlKeyword(extracted.identifier)).toBe(true);
+  });
+
+  it("extracts double-quoted qualified identifiers", () => {
+    const sql = 'select * from "MAAC00"."Accounts"';
+
+    expect(extractIdentifierAt(sql, sql.indexOf("Accounts"))).toBe("MAAC00.Accounts");
+  });
+});
+
+describe("splitQualifiedIdentifier", () => {
+  it("splits quoted and multi-part identifiers", () => {
+    expect(splitQualifiedIdentifier('catalog."MAAC00".Accounts')).toEqual(["catalog", "MAAC00", "Accounts"]);
+    expect(splitQualifiedIdentifier("`MAAC00`.Accounts")).toEqual(["MAAC00", "Accounts"]);
+  });
+});
+
+describe("matchTable", () => {
+  it("matches schema-qualified table identifiers", () => {
+    const table = { schema: "MAAC00", name: "Accounts" };
+
+    expect(matchTable("maac00.accounts", [table])).toBe(table);
+  });
+
+  it("matches catalog.schema.table identifiers against schema-scoped tables", () => {
+    const table = { schema: "MAAC00", name: "Accounts" };
+
+    expect(matchTable("catalog.maac00.accounts", [table])).toBe(table);
+  });
+
+  it("matches quoted schema-qualified table identifiers", () => {
+    const table = { schema: "MAAC00", name: "Accounts" };
+
+    expect(matchTable("`MAAC00`.Accounts", [table])).toBe(table);
+  });
+
+  it("does not treat non-schema qualifiers as table matches", () => {
+    expect(matchTable("u.users", [{ schema: "public", name: "users" }])).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlParameterHistory.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlParameterHistory.spec.ts
new file mode 100644
index 0000000..cc2bc00
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlParameterHistory.spec.ts
@@ -0,0 +1,47 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { loadSqlParameterHistory, MAX_SQL_PARAMETER_HISTORY, rememberSqlParameterValue } from "@/lib/sql/sqlParameterHistory";
+
+const storage = new Map<string, string>();
+
+beforeEach(() => {
+  storage.clear();
+  vi.stubGlobal("localStorage", {
+    getItem: (key: string) => storage.get(key) ?? null,
+    setItem: (key: string, value: string) => storage.set(key, value),
+    removeItem: (key: string) => storage.delete(key),
+  });
+});
+
+describe("sqlParameterHistory", () => {
+  it("stores recent values by parameter name", () => {
+    rememberSqlParameterValue("start_date", { kind: "string", value: "2026-01-01" });
+    rememberSqlParameterValue("start_date", { kind: "string", value: "2026-01-02" });
+
+    expect(loadSqlParameterHistory("start_date")).toEqual([
+      { kind: "string", value: "2026-01-02" },
+      { kind: "string", value: "2026-01-01" },
+    ]);
+  });
+
+  it("deduplicates by type and value and moves the latest value to the front", () => {
+    rememberSqlParameterValue("min_id", { kind: "number", value: "1" });
+    rememberSqlParameterValue("min_id", { kind: "number", value: "2" });
+    rememberSqlParameterValue("min_id", { kind: "number", value: "1" });
+
+    expect(loadSqlParameterHistory("min_id")).toEqual([
+      { kind: "number", value: "1" },
+      { kind: "number", value: "2" },
+    ]);
+  });
+
+  it("matches parameter names case-insensitively and limits history size", () => {
+    for (let i = 0; i < MAX_SQL_PARAMETER_HISTORY + 2; i += 1) {
+      rememberSqlParameterValue("UserId", { kind: "number", value: String(i) });
+    }
+
+    const history = loadSqlParameterHistory("userId");
+    expect(history).toHaveLength(MAX_SQL_PARAMETER_HISTORY);
+    expect(history[0]).toEqual({ kind: "number", value: String(MAX_SQL_PARAMETER_HISTORY + 1) });
+    expect(history.at(-1)).toEqual({ kind: "number", value: "2" });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlParameters.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlParameters.spec.ts
new file mode 100644
index 0000000..7436655
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlParameters.spec.ts
@@ -0,0 +1,322 @@
+import { describe, expect, it } from "vitest";
+import { extractSqlParameterDescriptors, extractSqlParameters, sqlParameterLiteral, substituteSqlParameters } from "@/lib/sql/sqlParameters";
+
+describe("extractSqlParameters", () => {
+  it("extracts unique template parameters in order", () => {
+    const sql = "select * from t where pt_dt between ${start_date} and ${end_date} or pt_dt = ${start_date}";
+    expect(extractSqlParameters(sql)).toEqual(["start_date", "end_date"]);
+  });
+
+  it("ignores placeholders inside strings, quoted identifiers, and comments", () => {
+    const sql = `
+      select '\${quoted}' as a, "\${identifier}" as b, \`\${mysql_identifier}\`
+      -- \${line_comment}
+      # \${hash_comment}
+      #\${hash_comment_without_space}
+      select 1 #comment \${inline_hash_comment}
+      /* \${block_comment} */
+      from t
+      where id = \${id}
+    `;
+    expect(extractSqlParameters(sql)).toEqual(["id"]);
+  });
+
+  it("ignores placeholders inside Postgres dollar-quoted strings", () => {
+    const sql = "select $$ ${body_param} $$, $tag$ ${tag_param} $tag$, ${real_param}";
+    expect(extractSqlParameters(sql)).toEqual(["real_param"]);
+  });
+
+  it("extracts supported placeholder syntaxes in order", () => {
+    const sql = "select ? as a, :named as b, ${shell_name} as c, #{mybatis_name} as d, @sql_server_name as e";
+    expect(extractSqlParameters(sql)).toEqual(["?1", "named", "shell_name", "mybatis_name", "sql_server_name"]);
+  });
+
+  it("describes each placeholder syntax for the parameter dialog", () => {
+    const sql = "select ? as a, :named as b, ${shell_name} as c, #{mybatis_name} as d, @sql_server_name as e";
+    expect(extractSqlParameterDescriptors(sql)).toEqual([
+      { key: "?1", name: "?1", syntax: "positional", token: "?" },
+      { key: "named", name: "named", syntax: "named", token: ":named" },
+      { key: "shell_name", name: "shell_name", syntax: "shell", token: "${shell_name}" },
+      { key: "mybatis_name", name: "mybatis_name", syntax: "mybatis", token: "#{mybatis_name}" },
+      { key: "sql_server_name", name: "sql_server_name", syntax: "sqlserver", token: "@sql_server_name" },
+    ]);
+  });
+
+  it("ignores declared SQL Server variables and system variables", () => {
+    const sql = `
+      declare @id int = 1, @name nvarchar(50);
+      select @@version, @id, @name, @input_value
+    `;
+    expect(extractSqlParameters(sql)).toEqual(["input_value"]);
+  });
+
+  it("ignores variables assigned by SET statements", () => {
+    const sql = `
+      set @date_start = '2026-07-04 00:00:00';
+      select * from fin_pur_payment AS fp where fp.create_time < @date_start and fp.tenant_id = @tenant_id
+    `;
+    expect(extractSqlParameters(sql)).toEqual(["tenant_id"]);
+  });
+
+  it("ignores multiple variables assigned by SET statements", () => {
+    const sql = `
+      set @date_start := '2026-07-01', @date_end = '2026-07-31';
+      select * from orders where created_at between @date_start and @date_end and tenant_id = @tenant_id
+    `;
+    expect(extractSqlParameters(sql)).toEqual(["tenant_id"]);
+  });
+
+  it("ignores variables assigned by SELECT statements", () => {
+    const sql = `
+      select @date_start := min(created_at), @date_end = max(created_at) from orders;
+      select * from orders where created_at between @date_start and @date_end and tenant_id = @tenant_id
+    `;
+    expect(extractSqlParameters(sql)).toEqual(["tenant_id"]);
+  });
+
+  it("ignores SQL Server procedure parameters declared in routine definitions", () => {
+    const sql = `
+      create procedure dbo.search_orders
+        @date_start datetime,
+        @status nvarchar(20) = N'paid'
+      as
+      begin
+        select * from orders where created_at >= @date_start and status = @status and tenant_id = @tenant_id;
+      end
+    `;
+    expect(extractSqlParameters(sql)).toEqual(["tenant_id"]);
+  });
+
+  it("ignores SQL Server function parameters declared in routine definitions", () => {
+    const sql = `
+      create function dbo.order_count(@date_start datetime, @status nvarchar(20))
+      returns int
+      as
+      begin
+        return (select count(*) from orders where created_at >= @date_start and status = @status and tenant_id = @tenant_id);
+      end
+    `;
+    expect(extractSqlParameters(sql)).toEqual(["tenant_id"]);
+  });
+
+  it("keeps template parameters in non-routine CREATE statements", () => {
+    const sql = "create table #orders (tenant_id int default @tenant_id);";
+    expect(extractSqlParameters(sql)).toEqual(["tenant_id"]);
+  });
+
+  it("ignores named stored procedure arguments while preserving template values", () => {
+    const sql = "exec dbo.search_orders @date_start = '2026-07-04', @status = @status_value, @tenant_id = @tenant_id";
+    expect(extractSqlParameters(sql)).toEqual(["status_value", "tenant_id"]);
+  });
+
+  it("ignores declared SQL Server table variables", () => {
+    const sql = `
+      declare @ids table (id int);
+      insert into @ids values (1);
+      select * from @ids where id = @input_id;
+    `;
+    expect(extractSqlParameters(sql)).toEqual(["input_id"]);
+  });
+
+  it("ignores SQL Server and MySQL system variables", () => {
+    const sql = "select @@ROWCOUNT, @@IDENTITY, @@SERVERNAME, @@session.sql_mode, @@global.time_zone, @input_value";
+    expect(extractSqlParameters(sql)).toEqual(["input_value"]);
+  });
+
+  it("extracts template parameters from ordinary SELECT filters", () => {
+    const sql = `
+      select * from fin_pur_payment
+      where tenant_id = @tenant_id;
+    `;
+    expect(extractSqlParameters(sql)).toEqual(["tenant_id"]);
+  });
+
+  it("extracts remaining template parameters after SET-defined variables", () => {
+    const sql = `
+      set @date_start = '2026-07-04 00:00:00';
+
+      select * from fin_pur_payment
+      where create_time < @date_start
+        and tenant_id = @tenant_id;
+    `;
+    expect(extractSqlParameters(sql)).toEqual(["tenant_id"]);
+  });
+
+  it("does not treat native variable updates as template parameters", () => {
+    const sql = "set @n = 1; set @n = @n + 1; select @n;";
+    expect(extractSqlParameters(sql)).toEqual([]);
+  });
+
+  it("ignores MySQL dynamic SQL variables used by prepared statements", () => {
+    const sql = `
+      SET @sql = IF(
+        (SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS
+         WHERE TABLE_SCHEMA = DATABASE()
+           AND TABLE_NAME = 'oem_user_group'
+           AND COLUMN_NAME = 'group') = 0,
+        'ALTER TABLE \`oem_user_group\` ADD COLUMN \`group\` varchar(64) DEFAULT NULL COMMENT ''users.group'' AFTER \`oem_id\`',
+        'SELECT 1'
+      );
+      PREPARE stmt FROM @sql;
+      EXECUTE stmt;
+      DEALLOCATE PREPARE stmt;
+    `;
+    expect(extractSqlParameters(sql)).toEqual([]);
+  });
+
+  it("stops SQL Server declaration scanning when a new statement starts without a semicolon", () => {
+    const sql = `
+      declare @id int = 1
+      select @id, @tenant_id
+    `;
+    expect(extractSqlParameters(sql)).toEqual(["tenant_id"]);
+  });
+
+  it("does not treat PostgreSQL casts or assignment operators as named parameters", () => {
+    const sql = "select value::int, value := 1, :actual_value";
+    expect(extractSqlParameters(sql)).toEqual(["actual_value"]);
+  });
+
+  it("ignores HANA SQLScript variable references", () => {
+    const sql = "DO BEGIN Dummy1 = SELECT 1 FROM DUMMY; SELECT * FROM :Dummy1; END";
+    expect(extractSqlParameters(sql, { databaseType: "saphana" })).toEqual([]);
+  });
+});
+
+describe("substituteSqlParameters", () => {
+  it("replaces placeholders with SQL literals", () => {
+    const sql = "select * from t where dt >= ${start_date} and amount > ${amount} and enabled = ${enabled}";
+    expect(
+      substituteSqlParameters(sql, {
+        start_date: { kind: "string", value: "2026-06-26" },
+        amount: { kind: "number", value: "100.50" },
+        enabled: { kind: "boolean", value: "true" },
+      }),
+    ).toBe("select * from t where dt >= '2026-06-26' and amount > 100.50 and enabled = TRUE");
+  });
+
+  it("escapes string values and supports null and raw SQL", () => {
+    const sql = "select ${name}, ${empty_value}, ${expression}";
+    expect(
+      substituteSqlParameters(sql, {
+        name: { kind: "string", value: "O'Reilly" },
+        empty_value: { kind: "null", value: "" },
+        expression: { kind: "raw", value: "current_date" },
+      }),
+    ).toBe("select 'O''Reilly', NULL, current_date");
+  });
+
+  it("replaces all supported placeholder syntaxes with SQL literals", () => {
+    const sql = "select ? as a, :named as b, ${shell_name} as c, #{mybatis_name} as d, @sql_server_name as e";
+    expect(
+      substituteSqlParameters(sql, {
+        "?1": { kind: "number", value: "42" },
+        named: { kind: "string", value: "alpha" },
+        shell_name: { kind: "boolean", value: "yes" },
+        mybatis_name: { kind: "null", value: "" },
+        sql_server_name: { kind: "raw", value: "current_timestamp" },
+      }),
+    ).toBe("select 42 as a, 'alpha' as b, TRUE as c, NULL as d, current_timestamp as e");
+  });
+
+  it("replaces repeated named placeholders once and positional placeholders independently", () => {
+    const sql = "select :name, :name, ?, ?";
+    expect(
+      substituteSqlParameters(sql, {
+        name: { kind: "string", value: "same" },
+        "?1": { kind: "number", value: "1" },
+        "?2": { kind: "number", value: "2" },
+      }),
+    ).toBe("select 'same', 'same', 1, 2");
+  });
+
+  it("leaves declared SQL Server variables untouched while replacing undeclared variables", () => {
+    const sql = "DECLARE @id int = 1; SELECT * FROM users WHERE id = @id AND tenant_id = @tenant_id";
+    expect(substituteSqlParameters(sql, { tenant_id: { kind: "number", value: "7" } })).toBe("DECLARE @id int = 1; SELECT * FROM users WHERE id = @id AND tenant_id = 7");
+  });
+
+  it("leaves variables assigned by SET statements untouched while replacing undeclared variables", () => {
+    const sql = "set @date_start = '2026-07-04 00:00:00'; select * from fin_pur_payment where create_time < @date_start and tenant_id = @tenant_id";
+    expect(substituteSqlParameters(sql, { tenant_id: { kind: "number", value: "7" } })).toBe("set @date_start = '2026-07-04 00:00:00'; select * from fin_pur_payment where create_time < @date_start and tenant_id = 7");
+  });
+
+  it("preserves native variable updates instead of rewriting SQL text", () => {
+    const sql = "set @n = 1; set @n = @n + 1; select @n;";
+    expect(substituteSqlParameters(sql, {})).toBe(sql);
+  });
+
+  it("preserves MySQL dynamic SQL variables used by prepared statements", () => {
+    const sql = `SET @sql = IF(
+  (SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS
+   WHERE TABLE_SCHEMA = DATABASE()
+     AND TABLE_NAME = 'oem_user_group'
+     AND COLUMN_NAME = 'group') = 0,
+  'ALTER TABLE \`oem_user_group\` ADD COLUMN \`group\` varchar(64) DEFAULT NULL COMMENT ''users.group'' AFTER \`oem_id\`',
+  'SELECT 1'
+);
+PREPARE stmt FROM @sql;
+EXECUTE stmt;
+DEALLOCATE PREPARE stmt;`;
+    expect(substituteSqlParameters(sql, {})).toBe(sql);
+  });
+
+  it("leaves named stored procedure arguments untouched while replacing their template values", () => {
+    const sql = "exec dbo.search_orders @date_start = '2026-07-04', @status = @status_value, @tenant_id = @tenant_id";
+    expect(
+      substituteSqlParameters(sql, {
+        status_value: { kind: "string", value: "paid" },
+        tenant_id: { kind: "number", value: "7" },
+      }),
+    ).toBe("exec dbo.search_orders @date_start = '2026-07-04', @status = 'paid', @tenant_id = 7");
+  });
+
+  it("keeps HANA SQLScript variable references while replacing template parameters", () => {
+    const sql = "DO BEGIN Dummy1 = SELECT * FROM ORDERS WHERE TENANT_ID = ${tenant_id}; SELECT * FROM :Dummy1; END";
+    expect(substituteSqlParameters(sql, { tenant_id: { kind: "number", value: "42" } }, { databaseType: "saphana" })).toBe("DO BEGIN Dummy1 = SELECT * FROM ORDERS WHERE TENANT_ID = 42; SELECT * FROM :Dummy1; END");
+  });
+});
+
+describe("enabledSyntaxes option", () => {
+  const mixedSql = "select ? as a, :named as b, ${shell_name} as c, #{mybatis_name} as d, @sql_server_name as e";
+
+  it("extracts every syntax when the option is omitted (backward compatible)", () => {
+    expect(extractSqlParameters(mixedSql)).toEqual(["?1", "named", "shell_name", "mybatis_name", "sql_server_name"]);
+  });
+
+  it("only extracts the enabled syntaxes", () => {
+    expect(extractSqlParameters(mixedSql, { enabledSyntaxes: ["named"] })).toEqual(["named"]);
+    expect(extractSqlParameters(mixedSql, { enabledSyntaxes: ["shell", "mybatis"] })).toEqual(["shell_name", "mybatis_name"]);
+  });
+
+  it("extracts nothing when no syntax is enabled", () => {
+    expect(extractSqlParameters(mixedSql, { enabledSyntaxes: [] })).toEqual([]);
+  });
+
+  it("leaves disabled-syntax tokens untouched when substituting", () => {
+    // Only :named is enabled, so every other token survives verbatim.
+    expect(substituteSqlParameters(mixedSql, { named: { kind: "number", value: "2" } }, { enabledSyntaxes: ["named"] })).toBe("select ? as a, 2 as b, ${shell_name} as c, #{mybatis_name} as d, @sql_server_name as e");
+  });
+
+  it("does not consume the positional counter for disabled positional placeholders", () => {
+    expect(substituteSqlParameters("select ?, ?", {}, { enabledSyntaxes: ["named"] })).toBe("select ?, ?");
+  });
+
+  it("keeps #{name} out of hash-comment handling when mybatis is disabled", () => {
+    expect(extractSqlParameters("select #{mybatis_name} from t", { enabledSyntaxes: ["shell"] })).toEqual([]);
+    expect(substituteSqlParameters("select #{mybatis_name} from t", {}, { enabledSyntaxes: ["shell"] })).toBe("select #{mybatis_name} from t");
+  });
+
+  it("intersects the enabled set with the saphana named-parameter rule", () => {
+    const sql = "select :named as a, ${shell_name} as b";
+    // saphana already disables :name; enabling named cannot re-enable it.
+    expect(extractSqlParameters(sql, { databaseType: "saphana", enabledSyntaxes: ["named", "shell"] })).toEqual(["shell_name"]);
+    // A non-saphana database with named disabled also drops :name.
+    expect(extractSqlParameters(sql, { enabledSyntaxes: ["shell"] })).toEqual(["shell_name"]);
+  });
+});
+
+describe("sqlParameterLiteral", () => {
+  it("falls back to quoted strings for invalid boolean input", () => {
+    expect(sqlParameterLiteral({ kind: "boolean", value: "maybe" })).toBe("'maybe'");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlQuoteCaret.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlQuoteCaret.spec.ts
new file mode 100644
index 0000000..85a72dc
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlQuoteCaret.spec.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { resolveSqlSingleQuoteKeyAction } from "@/lib/sql/sqlQuoteCaret";
+
+describe("resolveSqlSingleQuoteKeyAction", () => {
+  it("skips over the auto-inserted closing single quote", () => {
+    expect(resolveSqlSingleQuoteKeyAction({ previousChar: "'", nextChar: "'" })).toBe("skipClosingQuote");
+  });
+
+  it("keeps escaped quote insertion when there is no closing quote to skip", () => {
+    expect(resolveSqlSingleQuoteKeyAction({ previousChar: "'", nextChar: "" })).toBe("insertEscapedQuote");
+  });
+
+  it("lets CodeMirror handle ordinary single quote input", () => {
+    expect(resolveSqlSingleQuoteKeyAction({ previousChar: "a", nextChar: "" })).toBe("pass");
+  });
+
+  it("does not skip an existing string opening quote after whitespace", () => {
+    expect(resolveSqlSingleQuoteKeyAction({ previousChar: " ", nextChar: "'" })).toBe("pass");
+  });
+
+  it("does not skip an existing string opening quote at the start of the document", () => {
+    expect(resolveSqlSingleQuoteKeyAction({ previousChar: "", nextChar: "'" })).toBe("pass");
+  });
+
+  it("does not intercept input when auto-close brackets is disabled", () => {
+    expect(resolveSqlSingleQuoteKeyAction({ previousChar: "'", nextChar: "'", autoCloseBrackets: false })).toBe("pass");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlStatementRanges.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlStatementRanges.spec.ts
new file mode 100644
index 0000000..09a48ec
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlStatementRanges.spec.ts
@@ -0,0 +1,769 @@
+import { describe, expect, it } from "vitest";
+import { buildExecutionCandidates, currentExecutableStatementRange, executableStatementRanges, fullSqlRange, hasMultipleExecutionTargets, splitSqlStatementRanges, statementRangeAtCursor, supportsExecutionTargetPicker } from "@/lib/sql/sqlStatementRanges";
+
+function indexOf(sql: string, needle: string, occurrence = 1): number {
+  let from = 0;
+  let idx = -1;
+  for (let i = 0; i < occurrence; i += 1) {
+    idx = sql.indexOf(needle, from);
+    if (idx === -1) return -1;
+    from = idx + needle.length;
+  }
+  return idx;
+}
+
+function rangeSqlTexts(ranges: Array<{ sql: string }>): string[] {
+  return ranges.map((range) => range.sql.trim());
+}
+
+function candidateKinds(candidates: Array<{ kind: string }>): string[] {
+  return candidates.map((candidate) => candidate.kind);
+}
+
+function candidateLabels(candidates: Array<{ label: string }>): string[] {
+  return candidates.map((candidate) => candidate.label);
+}
+
+function candidateSummaries(candidates: Array<{ kind: string; sql: string }>): string[] {
+  return candidates.map((candidate) => `${candidate.kind}:${candidate.sql.trim()}`);
+}
+
+const oraclePlSqlFixture = `DECLARE
+  v_order_count NUMBER;
+BEGIN
+  SELECT COUNT(*) INTO v_order_count
+  FROM "DBX_TEST"."ORDERS_10K";
+
+  IF v_order_count = 0 THEN
+    INSERT INTO "DBX_TEST"."STORES"
+      ("ID", "STORE_CODE", "STORE_NAME", "CITY", "OPENED_AT")
+    SELECT 10001, 'TEST_STORE_001', '测试门店', '上海', SYSDATE
+    FROM DUAL
+    WHERE NOT EXISTS (
+      SELECT 1 FROM "DBX_TEST"."STORES" WHERE "ID" = 10001
+    );
+
+    INSERT INTO "DBX_TEST"."PRODUCTS"
+      ("ID", "SKU", "PRODUCT_NAME", "CATEGORY", "PRICE")
+    SELECT 10001, 'TEST_SKU_001', '测试商品', '测试分类', 99.90
+    FROM DUAL
+    WHERE NOT EXISTS (
+      SELECT 1 FROM "DBX_TEST"."PRODUCTS" WHERE "ID" = 10001
+    );
+
+    INSERT INTO "DBX_TEST"."ORDERS_10K"
+      ("ID", "ORDER_NO", "STORE_ID", "PRODUCT_ID", "CUSTOMER_NAME", "QUANTITY", "AMOUNT", "ORDER_STATUS", "CREATED_AT")
+    SELECT 10001, 'TEST_ORDER_001', 10001, 10001, '测试客户', 2, 199.80, 'PAID', SYSDATE
+    FROM DUAL
+    WHERE NOT EXISTS (
+      SELECT 1 FROM "DBX_TEST"."ORDERS_10K" WHERE "ORDER_NO" = 'TEST_ORDER_001'
+    );
+
+    COMMIT;
+  END IF;
+END;
+/
+SELECT 1;`;
+
+const oracleIssue2405PlSql = `DECLARE
+   PRE_TRD_DATE   INTEGER ;
+BEGIN
+   SELECT 1 + 2 INTO PRE_TRD_DATE FROM DUAL;
+END;`;
+
+const mysqlRoutineFixture = `CREATE PROCEDURE p()
+BEGIN
+  SELECT 1;
+  IF 1 = 1 THEN
+    SELECT 'ok';
+  END IF;
+END;
+SELECT 2;`;
+
+const mysqlRoutineWithLoopsFixture = `CREATE PROCEDURE p_loop()
+BEGIN
+  WHILE 1 = 0 DO
+    SELECT 'while; still body';
+  END WHILE;
+  REPEAT
+    SELECT 'repeat; still body';
+  UNTIL 1 = 1 END REPEAT;
+END;
+SELECT 2;`;
+
+const mysqlDelimitedRoutineFixture = `DELIMITER //
+CREATE PROCEDURE sp_insert_random_users(IN p_count INT)
+BEGIN
+  DECLARE i INT DEFAULT 0;
+  DECLARE v_name VARCHAR(32);
+
+  WHILE i < p_count DO
+    SET v_name = CONCAT('user_', i);
+    INSERT INTO t_user (username) VALUES (v_name);
+    SET i = i + 1;
+  END WHILE;
+END //
+DELIMITER ;
+
+CALL sp_insert_random_users(100);`;
+
+const sapHanaDoBlockFixture = `DO
+BEGIN
+  SELECT 1 AS "Result" FROM DUMMY;
+END;
+SELECT 2 FROM DUMMY;`;
+
+describe("splitSqlStatementRanges", () => {
+  it("splits multiple top-level statements", () => {
+    const sql = "SELECT 1;\nSELECT 2;\nSELECT 3;";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT 1", "SELECT 2", "SELECT 3"]);
+  });
+
+  it("keeps a trailing statement without a semicolon", () => {
+    const sql = "SELECT 1;\nSELECT 2";
+    const ranges = splitSqlStatementRanges(sql);
+    expect(rangeSqlTexts(ranges)).toEqual(["SELECT 1", "SELECT 2"]);
+  });
+
+  it("ignores semicolons inside single-quoted strings", () => {
+    const sql = "INSERT INTO t VALUES ('a;b;c');\nSELECT 1";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["INSERT INTO t VALUES ('a;b;c')", "SELECT 1"]);
+  });
+
+  it("handles doubled single quotes as escaped quotes", () => {
+    const sql = "SELECT 'it''s; ok';\nSELECT 2";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT 'it''s; ok'", "SELECT 2"]);
+  });
+
+  it("ignores semicolons inside double-quoted identifiers", () => {
+    const sql = 'SELECT "a;b";\nSELECT 2';
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(['SELECT "a;b"', "SELECT 2"]);
+  });
+
+  it("ignores semicolons inside backtick identifiers (MySQL)", () => {
+    const sql = "SELECT `a;b`;\nSELECT 2";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT `a;b`", "SELECT 2"]);
+  });
+
+  it("ignores semicolons inside bracket identifiers (SQL Server)", () => {
+    const sql = "SELECT [a;b];\nSELECT 2";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT [a;b]", "SELECT 2"]);
+  });
+
+  it("ignores semicolons in line comments", () => {
+    const sql = "SELECT 1 -- a; b\n;\nSELECT 2";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT 1", "SELECT 2"]);
+  });
+
+  it("ignores semicolons in hash line comments", () => {
+    const sql = "SELECT 1 # a; b\n;\nSELECT 2";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT 1", "SELECT 2"]);
+  });
+
+  it("ignores semicolons in block comments", () => {
+    const sql = "SELECT /* a; b */ 1;\nSELECT 2";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT /* a; b */ 1", "SELECT 2"]);
+  });
+
+  it("handles Postgres dollar quoting", () => {
+    const sql = "SELECT $$ a; b $$;\nSELECT 2";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT $$ a; b $$", "SELECT 2"]);
+  });
+
+  it("skips MySQL delimiter commands and empty custom delimiter statements", () => {
+    const sql = "select COUNT(1) FROM your_table;\ndelimiter ;;\nselect COUNT(1) FROM your_table;\n\n;;\ndelimiter ;";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "mysql"))).toEqual(["select COUNT(1) FROM your_table", "select COUNT(1) FROM your_table;"]);
+  });
+
+  it("keeps MySQL routine blocks together without delimiter commands", () => {
+    const ranges = splitSqlStatementRanges(mysqlRoutineFixture, "mysql");
+    expect(rangeSqlTexts(ranges)).toEqual([mysqlRoutineFixture.slice(0, mysqlRoutineFixture.indexOf("\nSELECT 2;")).replace(/;$/, "").trim(), "SELECT 2"]);
+    expect(ranges[0].sql).toContain("SELECT 1;");
+    expect(ranges[0].sql).toContain("END IF;");
+    expect(ranges[0].sql).not.toMatch(/END;$/);
+  });
+
+  it("does not merge regular MySQL transaction statements as routine blocks", () => {
+    const sql = "BEGIN; INSERT INTO t VALUES (1); COMMIT;";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "mysql"))).toEqual(["BEGIN", "INSERT INTO t VALUES (1)", "COMMIT"]);
+  });
+
+  it("treats SQL Server GO lines as batch delimiters", () => {
+    const sql = "SELECT 1\nGO\nSELECT 2;\n  GO 2\nSELECT 3";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "sqlserver"))).toEqual(["SELECT 1", "SELECT 2", "SELECT 3"]);
+  });
+
+  it("does not treat GO inside strings or comments as a SQL Server batch delimiter", () => {
+    const sql = "SELECT 'GO'\n-- GO\nSELECT 2\nGO\nSELECT 3";
+    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "sqlserver"))).toEqual(["SELECT 'GO'\n-- GO\nSELECT 2", "SELECT 3"]);
+  });
+
+  it("keeps Oracle PL/SQL blocks together and treats slash lines as delimiters", () => {
+    const ranges = splitSqlStatementRanges(oraclePlSqlFixture, "oracle");
+    expect(rangeSqlTexts(ranges)).toEqual([oraclePlSqlFixture.slice(0, oraclePlSqlFixture.indexOf("\n/")), "SELECT 1"]);
+    expect(ranges[0].sql).toContain("v_order_count NUMBER;");
+    expect(ranges[0].sql).toContain("END;");
+    expect(ranges[0].sql).not.toContain("\n/");
+  });
+
+  it("keeps issue #2405 Oracle PL/SQL block together without a slash delimiter", () => {
+    expect(rangeSqlTexts(splitSqlStatementRanges(oracleIssue2405PlSql, "oracle"))).toEqual([oracleIssue2405PlSql]);
+  });
+
+  it("keeps SAP HANA DO blocks together", () => {
+    const ranges = splitSqlStatementRanges(sapHanaDoBlockFixture, "saphana");
+
+    expect(rangeSqlTexts(ranges)).toEqual([sapHanaDoBlockFixture.slice(0, sapHanaDoBlockFixture.indexOf("\nSELECT 2")), "SELECT 2 FROM DUMMY"]);
+    expect(ranges[0].sql).toContain('SELECT 1 AS "Result" FROM DUMMY;');
+    expect(ranges[0].sql).toContain("END;");
+  });
+});
+
+describe("statementRangeAtCursor", () => {
+  it("returns the first statement when the cursor is inside it", () => {
+    const sql = "SELECT 1;\nSELECT 2;";
+    const pos = indexOf(sql, "1");
+    const range = statementRangeAtCursor(sql, pos);
+    expect(range?.sql.trim()).toBe("SELECT 1");
+  });
+
+  it("returns the second statement when the cursor is inside it", () => {
+    const sql = "SELECT 1;\nSELECT 2;";
+    const pos = indexOf(sql, "2");
+    const range = statementRangeAtCursor(sql, pos);
+    expect(range?.sql.trim()).toBe("SELECT 2");
+  });
+
+  it("returns the statement when the cursor is in indentation before it", () => {
+    const sql = "SELECT 1;\n    SELECT 2;";
+    const indentationPos = sql.indexOf("    SELECT 2") + 2;
+    const range = statementRangeAtCursor(sql, indentationPos);
+    expect(range?.sql.trim()).toBe("SELECT 2");
+  });
+
+  it("returns the previous statement when the cursor is in same-line whitespace after its semicolon", () => {
+    const sql = "SELECT 1;   SELECT 2;";
+    const gapPos = sql.indexOf(";") + 2;
+    const range = statementRangeAtCursor(sql, gapPos);
+    expect(range?.sql.trim()).toBe("SELECT 1");
+  });
+
+  it("returns the previous statement when the cursor is just after its semicolon before a later statement", () => {
+    const sql = "SELECT *\nFROM system_dept;\n\nSELECT *\nFROM sys;";
+    const gapPos = sql.indexOf(";") + 1;
+    const range = statementRangeAtCursor(sql, gapPos);
+    expect(range?.sql.trim()).toBe("SELECT *\nFROM system_dept");
+  });
+
+  it("keeps a semicolon-line-end cursor on the current multi-line statement", () => {
+    const sql = "SELECT *\nFROM system_dept;";
+    const gapPos = sql.indexOf(";") + 1;
+    const range = statementRangeAtCursor(sql, gapPos);
+    expect(range?.sql.trim()).toBe("SELECT *\nFROM system_dept");
+  });
+
+  it("returns the next same-line statement when the cursor is inside it", () => {
+    const sql = "SELECT 1;   SELECT 2;";
+    const pos = indexOf(sql, "SELECT 2") + 1;
+    const range = statementRangeAtCursor(sql, pos);
+    expect(range?.sql.trim()).toBe("SELECT 2");
+  });
+
+  it("returns a statement even without a trailing semicolon", () => {
+    const sql = "SELECT 1";
+    const pos = indexOf(sql, "1");
+    const range = statementRangeAtCursor(sql, pos);
+    expect(range?.sql.trim()).toBe("SELECT 1");
+  });
+
+  it("stops at the next top-level statement start when the cursor statement has no semicolon", () => {
+    const sql = "SELECT 1\nSELECT 2;\nSELECT 3;";
+    const range = statementRangeAtCursor(sql, indexOf(sql, "1"));
+    expect(range?.sql.trim()).toBe("SELECT 1");
+  });
+
+  it("returns the later top-level statement when earlier statements are missing semicolons", () => {
+    const sql = "SELECT 1\nSELECT 2;\nSELECT 3;";
+    const range = statementRangeAtCursor(sql, indexOf(sql, "2"));
+    expect(range?.sql.trim()).toBe("SELECT 2");
+  });
+
+  it("keeps newline set-operation SELECT operands with the cursor statement", () => {
+    const sql = "select * from tbA\nunion\nselect * from tbB";
+    const expected = "select * from tbA\nunion\nselect * from tbB";
+
+    expect(statementRangeAtCursor(sql, indexOf(sql, "tbA"))?.sql.trim()).toBe(expected);
+    expect(statementRangeAtCursor(sql, indexOf(sql, "tbB"))?.sql.trim()).toBe(expected);
+  });
+
+  it("keeps newline set-operation operands with ALL modifiers together", () => {
+    const sql = "select * from tbA\nunion all\nselect * from tbB\nSELECT * FROM logs;";
+    const range = statementRangeAtCursor(sql, indexOf(sql, "tbA"));
+
+    expect(range?.sql.trim()).toBe("select * from tbA\nunion all\nselect * from tbB");
+  });
+
+  it("keeps a multi-line select together when continuation lines do not start statements", () => {
+    const sql = "SELECT id,\n  name\nFROM users\nWHERE active = 1\nSELECT * FROM logs;";
+    const range = statementRangeAtCursor(sql, indexOf(sql, "name"));
+    expect(range?.sql.trim()).toBe("SELECT id,\n  name\nFROM users\nWHERE active = 1");
+  });
+
+  it("keeps a CTE main query with its WITH statement", () => {
+    const sql = "WITH active_users AS (\n  SELECT * FROM users\n)\nSELECT * FROM active_users\nSELECT * FROM logs;";
+    const range = statementRangeAtCursor(sql, indexOf(sql, "active_users", 2));
+    expect(range?.sql.trim()).toBe("WITH active_users AS (\n  SELECT * FROM users\n)\nSELECT * FROM active_users");
+  });
+
+  it("keeps update assignments with the UPDATE statement", () => {
+    const sql = "UPDATE users\nSET name = 'a'\nWHERE id = 1\nSELECT * FROM users;";
+    const range = statementRangeAtCursor(sql, indexOf(sql, "name"));
+    expect(range?.sql.trim()).toBe("UPDATE users\nSET name = 'a'\nWHERE id = 1");
+  });
+
+  it("keeps MySQL ALTER TABLE column comments with the column definition", () => {
+    const sql =
+      "ALTER TABLE `yb_course_order`\n  ADD COLUMN `audit_status` tinyint(4) DEFAULT NULL\n    COMMENT '审核状态：0-待审核，1-已通过，2-已拒绝',\n  ADD COLUMN `close_reason` varchar(30) DEFAULT NULL\n    COMMENT '关闭原因：timeout-超时关闭，cancel-取消关闭，refund-退款关闭',\n  ADD COLUMN `paid_completion_time` datetime DEFAULT NULL\n    COMMENT '订单完成支付(付清)时间 首次全额支付完成时记录，全部退款后不重置';";
+
+    expect(statementRangeAtCursor(sql, indexOf(sql, "ALTER"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(statementRangeAtCursor(sql, indexOf(sql, "close_reason"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
+  });
+
+  it("keeps MySQL CREATE TABLE options with table comments", () => {
+    const sql = `CREATE TABLE test_1 (
+  id bigint NOT NULL AUTO_INCREMENT COMMENT '主键id',
+  deleted tinyint NOT NULL DEFAULT 0 COMMENT '删除标志(0:有效 1：无效)',
+  locked tinyint NOT NULL DEFAULT 0 COMMENT '是否锁定(0.否,1.是)',
+  version int NOT NULL DEFAULT 0 COMMENT '版本号',
+  creatorId bigint DEFAULT NULL COMMENT '创建人ID',
+  createBy varchar(100) DEFAULT NULL COMMENT '创建人名称',
+  createdTime timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  updaterId bigint DEFAULT NULL COMMENT '修改人ID',
+  updatedBy varchar(100) DEFAULT NULL COMMENT '修改人名称',
+  updatedTime timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '最后更新时间',
+  PRIMARY KEY (id)
+)
+ENGINE = INNODB,
+CHARACTER SET utf8mb4,
+COLLATE utf8mb4_general_ci,
+COMMENT = '测试';`;
+
+    expect(statementRangeAtCursor(sql, indexOf(sql, "CREATE"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(statementRangeAtCursor(sql, indexOf(sql, "COMMENT ="), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
+    expect(statementRangeAtCursor(sql, indexOf(sql, "COMMENT ="))?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual([sql.slice(0, -1)]);
+  });
+
+  it("keeps MySQL CREATE TABLE comments without equals as table options", () => {
+    const sql = "CREATE TABLE test_2 (\n  id bigint NOT NULL\n)\nCOMMENT '测试';";
+
+    expect(statementRangeAtCursor(sql, indexOf(sql, "COMMENT"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
+    expect(statementRangeAtCursor(sql, indexOf(sql, "COMMENT"))?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual([sql.slice(0, -1)]);
+  });
+
+  it("does not merge standard COMMENT ON statements into preceding CREATE TABLE statements", () => {
+    const sql = "CREATE TABLE users (id int)\nCOMMENT ON TABLE users IS 'Users';";
+
+    expect(rangeSqlTexts(executableStatementRanges(sql, "postgres"))).toEqual(["CREATE TABLE users (id int)", "COMMENT ON TABLE users IS 'Users'"]);
+    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual(["CREATE TABLE users (id int)", "COMMENT ON TABLE users IS 'Users'"]);
+  });
+
+  it("keeps MySQL ALTER TABLE drop column clauses with the statement", () => {
+    const sql = "ALTER TABLE t\n  DROP COLUMN a,\n  DROP COLUMN b;";
+
+    expect(statementRangeAtCursor(sql, indexOf(sql, "ALTER"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(statementRangeAtCursor(sql, indexOf(sql, "DROP COLUMN b"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
+  });
+
+  it("keeps MySQL ALTER TABLE alter column clauses with the statement", () => {
+    const sql = "ALTER TABLE t\n  ALTER COLUMN name SET NOT NULL;";
+
+    expect(statementRangeAtCursor(sql, indexOf(sql, "ALTER"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(statementRangeAtCursor(sql, indexOf(sql, "ALTER COLUMN"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
+  });
+
+  it("keeps insert-select with the INSERT statement", () => {
+    const sql = "INSERT INTO archived_users (id, name)\nSELECT id, name FROM users\nUPDATE users SET archived = 1;";
+    const range = statementRangeAtCursor(sql, indexOf(sql, "archived_users"));
+    expect(range?.sql.trim()).toBe("INSERT INTO archived_users (id, name)\nSELECT id, name FROM users");
+  });
+
+  it("keeps explain target SQL with the EXPLAIN statement", () => {
+    const sql = "EXPLAIN\nSELECT * FROM users\nSELECT * FROM logs;";
+    const range = statementRangeAtCursor(sql, indexOf(sql, "EXPLAIN"));
+    expect(range?.sql.trim()).toBe("EXPLAIN\nSELECT * FROM users");
+  });
+
+  it("keeps MySQL DESC UPDATE joins as one statement", () => {
+    const sql = "desc update  test_orders a\njoin test_users b\non a.id=b.id \nset a.name = '张三'\nwhere b.id > 10;";
+    expect(statementRangeAtCursor(sql, indexOf(sql, "desc"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(statementRangeAtCursor(sql, indexOf(sql, "set"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
+  });
+
+  it("keeps MySQL EXPLAIN UPDATE assignments as one statement", () => {
+    const sql = "EXPLAIN UPDATE test_orders a\nJOIN test_users b ON a.id=b.id\nSET a.name = '张三'\nWHERE b.id > 10;";
+    expect(statementRangeAtCursor(sql, indexOf(sql, "SET"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
+  });
+
+  it("keeps MySQL REPLACE function calls inside UPDATE assignments", () => {
+    const sql = `UPDATE ecm_archive_prepare_pool
+SET
+  request_json =
+    REPLACE(
+      request_json,
+      '"paperFlag":null',
+      '"paperFlag":false'
+    ),
+  process_flag = 0
+WHERE request_json LIKE '%"paperFlag":null%';`;
+
+    expect(statementRangeAtCursor(sql, indexOf(sql, "REPLACE"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
+    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
+  });
+
+  it("does not merge a plain MySQL DESC table statement with the next query", () => {
+    const sql = "DESC users\nSELECT * FROM users;";
+    expect(statementRangeAtCursor(sql, indexOf(sql, "DESC"), "mysql")?.sql.trim()).toBe("DESC users");
+    expect(statementRangeAtCursor(sql, indexOf(sql, "SELECT"), "mysql")?.sql.trim()).toBe("SELECT * FROM users");
+    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual(["DESC users", "SELECT * FROM users"]);
+  });
+
+  it("does not include comments between soft statement blocks", () => {
+    const sql = "SELECT 1\n-- explain the next query\n/* still next query notes */\nSELECT 2;";
+    const range = statementRangeAtCursor(sql, indexOf(sql, "1"));
+    expect(range?.sql.trim()).toBe("SELECT 1");
+  });
+
+  it("detects a soft statement start after a leading block comment on the same line", () => {
+    const sql = "SELECT 1\n/* next */ SELECT 2;";
+    const range = statementRangeAtCursor(sql, indexOf(sql, "2"));
+    expect(range?.sql.trim()).toBe("SELECT 2");
+  });
+
+  it("uses database-specific soft statement keywords", () => {
+    const sql = "SELECT 1\nDO $$ BEGIN RAISE NOTICE 'x'; END $$;";
+    expect(statementRangeAtCursor(sql, indexOf(sql, "1"))?.sql.trim()).toBe("SELECT 1\nDO $$ BEGIN RAISE NOTICE 'x'; END $$");
+    expect(statementRangeAtCursor(sql, indexOf(sql, "1"), "postgres")?.sql.trim()).toBe("SELECT 1");
+    expect(statementRangeAtCursor(sql, indexOf(sql, "DO"), "postgres")?.sql.trim()).toBe("DO $$ BEGIN RAISE NOTICE 'x'; END $$");
+  });
+
+  it("returns null when the cursor is on a blank line", () => {
+    const sql = "SELECT 1;\n\nSELECT 2;";
+    const blankLinePos = sql.indexOf("\n") + 1;
+    expect(statementRangeAtCursor(sql, blankLinePos)).toBeNull();
+  });
+
+  it("returns null for an empty document", () => {
+    expect(statementRangeAtCursor("", 0)).toBeNull();
+  });
+
+  it("does not treat comment semicolons as delimiters", () => {
+    const sql = "SELECT 1; -- drop; this\nSELECT 2;";
+    const pos = indexOf(sql, "2");
+    expect(statementRangeAtCursor(sql, pos)?.sql.trim()).toBe("SELECT 2");
+  });
+
+  it("exposes offsets aligned to the statement body", () => {
+    const sql = "  SELECT 1;\nSELECT 2;";
+    const range = statementRangeAtCursor(sql, indexOf(sql, "1"));
+    expect(range?.from).toBe(2);
+    expect(range?.sql).toBe("SELECT 1");
+  });
+
+  it("skips MySQL delimiter commands when resolving the cursor statement", () => {
+    const sql = "select COUNT(1) FROM your_table;\ndelimiter ;;\nselect COUNT(1) FROM your_table;\n\n;;\ndelimiter ;";
+    expect(statementRangeAtCursor(sql, indexOf(sql, "COUNT", 2), "mysql")?.sql.trim()).toBe("select COUNT(1) FROM your_table;");
+    expect(statementRangeAtCursor(sql, indexOf(sql, "delimiter"), "mysql")).toBeNull();
+  });
+
+  it("returns the full MySQL routine block for cursors inside nested statements", () => {
+    const range = statementRangeAtCursor(mysqlRoutineFixture, indexOf(mysqlRoutineFixture, "ok"), "mysql");
+    expect(range?.sql.trim()).toBe(mysqlRoutineFixture.slice(0, mysqlRoutineFixture.indexOf("\nSELECT 2;")).replace(/;$/, "").trim());
+  });
+
+  it("returns null on SQL Server GO batch delimiter lines", () => {
+    const sql = "SELECT 1\nGO\nSELECT 2";
+    expect(statementRangeAtCursor(sql, indexOf(sql, "GO"), "sqlserver")).toBeNull();
+  });
+
+  it("returns the current SQL Server batch around GO delimiters", () => {
+    const sql = "SELECT 1\nGO\nSELECT 2\nGO\nSELECT 3";
+    expect(statementRangeAtCursor(sql, indexOf(sql, "1"), "sqlserver")?.sql.trim()).toBe("SELECT 1");
+    expect(statementRangeAtCursor(sql, indexOf(sql, "2"), "sqlserver")?.sql.trim()).toBe("SELECT 2");
+    expect(statementRangeAtCursor(sql, indexOf(sql, "3"), "sqlserver")?.sql.trim()).toBe("SELECT 3");
+  });
+
+  it("returns the full Oracle PL/SQL block for cursors inside nested statements", () => {
+    const range = statementRangeAtCursor(oraclePlSqlFixture, indexOf(oraclePlSqlFixture, "ORDERS_10K", 2), "oracle");
+    expect(range?.sql.trim()).toBe(oraclePlSqlFixture.slice(0, oraclePlSqlFixture.indexOf("\n/")));
+  });
+
+  it("returns the full issue #2405 Oracle PL/SQL block for cursors inside the block", () => {
+    for (const cursor of [indexOf(oracleIssue2405PlSql, "PRE_TRD_DATE"), indexOf(oracleIssue2405PlSql, "SELECT 1 + 2"), indexOf(oracleIssue2405PlSql, "END;")]) {
+      expect(statementRangeAtCursor(oracleIssue2405PlSql, cursor, "oracle")?.sql.trim()).toBe(oracleIssue2405PlSql);
+    }
+  });
+
+  it("returns the full SAP HANA DO block for cursors inside nested statements", () => {
+    const range = statementRangeAtCursor(sapHanaDoBlockFixture, indexOf(sapHanaDoBlockFixture, "Result"), "saphana");
+
+    expect(range?.sql.trim()).toBe(sapHanaDoBlockFixture.slice(0, sapHanaDoBlockFixture.indexOf("\nSELECT 2")));
+  });
+});
+
+describe("executableStatementRanges", () => {
+  it("returns statement ranges starting only at statement starts", () => {
+    const sql = "SELECT *\nFROM users\nWHERE active = 1;\nSELECT 2;";
+    const ranges = executableStatementRanges(sql);
+    expect(rangeSqlTexts(ranges)).toEqual(["SELECT *\nFROM users\nWHERE active = 1", "SELECT 2"]);
+    expect(ranges.map((range) => range.from)).toEqual([0, sql.indexOf("SELECT 2")]);
+  });
+
+  it("returns Redis executable command lines", () => {
+    const sql = "GET user:1\n# comment\n  DEL user:2  ";
+    const ranges = executableStatementRanges(sql, "redis");
+    expect(rangeSqlTexts(ranges)).toEqual(["GET user:1", "DEL user:2"]);
+    expect(ranges.map((range) => range.from)).toEqual([0, sql.indexOf("DEL")]);
+  });
+
+  it("keeps MySQL REPLACE INTO as an executable statement start", () => {
+    const sql = "SELECT 1\nREPLACE INTO users (id, name) VALUES (1, 'a');";
+    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual(["SELECT 1", "REPLACE INTO users (id, name) VALUES (1, 'a')"]);
+  });
+
+  it("returns MongoDB command ranges for newline-separated shell commands", () => {
+    const sql = 'use archive\ndb.users.find({ status: "open" })\n  .limit(5)';
+    const ranges = executableStatementRanges(sql, "mongodb");
+
+    expect(rangeSqlTexts(ranges)).toEqual(["use archive", 'db.users.find({ status: "open" })\n  .limit(5)']);
+    expect(ranges.map((range) => range.from)).toEqual([0, sql.indexOf("db.users.find")]);
+  });
+
+  it("does not split executable Oracle PL/SQL ranges at inner statement starts", () => {
+    expect(rangeSqlTexts(executableStatementRanges(oraclePlSqlFixture, "oracle"))).toEqual([oraclePlSqlFixture.slice(0, oraclePlSqlFixture.indexOf("\n/")), "SELECT 1"]);
+  });
+
+  it("returns the issue #2405 Oracle PL/SQL block as one executable range", () => {
+    expect(rangeSqlTexts(executableStatementRanges(oracleIssue2405PlSql, "oracle"))).toEqual([oracleIssue2405PlSql]);
+  });
+
+  it("does not split executable MySQL routine ranges at inner statements", () => {
+    expect(rangeSqlTexts(executableStatementRanges(mysqlRoutineFixture, "mysql"))).toEqual([mysqlRoutineFixture.slice(0, mysqlRoutineFixture.indexOf("\nSELECT 2;")).replace(/;$/, "").trim(), "SELECT 2"]);
+  });
+
+  it("does not split executable MySQL routine ranges at WHILE and REPEAT endings", () => {
+    expect(rangeSqlTexts(executableStatementRanges(mysqlRoutineWithLoopsFixture, "mysql"))).toEqual([mysqlRoutineWithLoopsFixture.slice(0, mysqlRoutineWithLoopsFixture.indexOf("\nSELECT 2;")).replace(/;$/, "").trim(), "SELECT 2"]);
+  });
+
+  it("does not expose run targets for statements inside a delimited MySQL routine", () => {
+    expect(rangeSqlTexts(executableStatementRanges(mysqlDelimitedRoutineFixture, "mysql"))).toEqual([mysqlDelimitedRoutineFixture.slice(mysqlDelimitedRoutineFixture.indexOf("CREATE PROCEDURE"), mysqlDelimitedRoutineFixture.indexOf(" //\nDELIMITER")), "CALL sp_insert_random_users(100)"]);
+  });
+
+  it("does not split executable SAP HANA DO ranges at inner statements", () => {
+    expect(rangeSqlTexts(executableStatementRanges(sapHanaDoBlockFixture, "saphana"))).toEqual([sapHanaDoBlockFixture.slice(0, sapHanaDoBlockFixture.indexOf("\nSELECT 2")), "SELECT 2 FROM DUMMY"]);
+  });
+
+  it("returns executable SQL Server batches without GO delimiter lines", () => {
+    expect(rangeSqlTexts(executableStatementRanges("SELECT 1\nGO\nSELECT 2;", "sqlserver"))).toEqual(["SELECT 1", "SELECT 2"]);
+  });
+});
+
+describe("currentExecutableStatementRange", () => {
+  it("uses the current SQL statement range for multi-line DDL", () => {
+    const sql = "ALTER TABLE `yb_course_order`\n  ADD COLUMN `audit_status` tinyint(4) DEFAULT NULL\n    COMMENT '审核状态：0-待审核，1-已通过，2-已拒绝',\n  ADD COLUMN `close_reason` varchar(30) DEFAULT NULL\n    COMMENT '关闭原因：timeout-超时关闭，cancel-取消关闭，refund-退款关闭';\nSELECT 1;";
+
+    expect(currentExecutableStatementRange(sql, indexOf(sql, "close_reason"), "mysql")?.sql.trim()).toBe(sql.slice(0, sql.indexOf(";\nSELECT")));
+  });
+
+  it("returns null on blank and pure comment lines", () => {
+    const sql = "SELECT 1;\n-- comment\n\nSELECT 2;";
+
+    expect(currentExecutableStatementRange(sql, indexOf(sql, "comment"), "mysql")).toBeNull();
+    expect(currentExecutableStatementRange(sql, sql.indexOf("\n\n") + 1, "mysql")).toBeNull();
+  });
+
+  it("uses the current Redis command line", () => {
+    const sql = "GET user:1\n  DEL user:2\n# comment";
+
+    expect(currentExecutableStatementRange(sql, indexOf(sql, "DEL"), "redis")?.sql).toBe("DEL user:2");
+    expect(currentExecutableStatementRange(sql, indexOf(sql, "comment"), "redis")).toBeNull();
+  });
+
+  it("does not expose current statement framing for MongoDB", () => {
+    const sql = "db.users.find({})";
+
+    expect(currentExecutableStatementRange(sql, indexOf(sql, "users"), "mongodb")).toBeNull();
+  });
+});
+
+describe("fullSqlRange", () => {
+  it("returns the trimmed full document", () => {
+    const sql = "  SELECT 1;  \n";
+    const range = fullSqlRange(sql);
+    expect(range?.sql).toBe("SELECT 1;");
+  });
+
+  it("returns null for an empty/whitespace document", () => {
+    expect(fullSqlRange("   \n  ")).toBeNull();
+  });
+});
+
+describe("buildExecutionCandidates", () => {
+  it("returns a single candidate when only the cursor statement exists", () => {
+    const sql = "SELECT 1";
+    const candidates = buildExecutionCandidates(sql, indexOf(sql, "1"));
+    expect(candidates).toHaveLength(1);
+    expect(candidates[0].kind).toBe("all");
+  });
+
+  it("returns current + all in order for multiple statements", () => {
+    const sql = "SELECT 1;\nSELECT 2;";
+    const candidates = buildExecutionCandidates(sql, indexOf(sql, "2"));
+    expect(candidateKinds(candidates)).toEqual(["cursor", "all"]);
+  });
+
+  it("uses the cursor statement for the first candidate when there is no selection", () => {
+    const sql = "SELECT *\nFROM users\nWHERE active = 1";
+    const candidates = buildExecutionCandidates(sql, indexOf(sql, "users"));
+    expect(candidates).toHaveLength(1);
+    expect(candidates[0].kind).toBe("all");
+  });
+
+  it("uses the whole set-operation statement for cursor execution candidates", () => {
+    const sql = "select * from tbA\nunion\nselect * from tbB\nSELECT * FROM logs;";
+    const candidates = buildExecutionCandidates(sql, indexOf(sql, "tbA"));
+
+    expect(candidateSummaries(candidates)).toEqual(["cursor:select * from tbA\nunion\nselect * from tbB", "all:select * from tbA\nunion\nselect * from tbB\nSELECT * FROM logs;"]);
+  });
+
+  it("uses the current command line for Redis cursor candidates", () => {
+    const sql = "GET user:1\nDEL user:2\nHGETALL user:3";
+    const candidates = buildExecutionCandidates(sql, indexOf(sql, "user:2"), "redis");
+    expect(candidateSummaries(candidates)).toEqual(["cursor:DEL user:2", "all:GET user:1\nDEL user:2\nHGETALL user:3"]);
+    expect(candidateLabels(candidates)).toEqual(["currentCommand", "allCommands"]);
+  });
+
+  it("returns only all for Redis when the cursor is on a comment line", () => {
+    const sql = "GET user:1\n# comment\nDEL user:2";
+    const candidates = buildExecutionCandidates(sql, indexOf(sql, "comment"), "redis");
+    expect(candidateSummaries(candidates)).toEqual(["all:GET user:1\n# comment\nDEL user:2"]);
+  });
+
+  it("returns current + all when the cursor is in indentation before a statement", () => {
+    const sql = "SELECT 1;\n    SELECT 2;";
+    const indentationPos = sql.indexOf("    SELECT 2") + 2;
+    const candidates = buildExecutionCandidates(sql, indentationPos);
+    expect(candidateSummaries(candidates)).toEqual(["cursor:SELECT 2", "all:SELECT 1;\n    SELECT 2;"]);
+    expect(candidateLabels(candidates)).toEqual(["currentStatement", "allStatements"]);
+  });
+
+  it("uses the current statement when the cursor is immediately after its semicolon before a blank line", () => {
+    const sql = "select 1;\n\nselect 2;";
+    const cursorAfterFirstSemicolon = sql.indexOf(";") + 1;
+    const candidates = buildExecutionCandidates(sql, cursorAfterFirstSemicolon);
+    expect(candidateSummaries(candidates)).toEqual(["cursor:select 1", "all:select 1;\n\nselect 2;"]);
+  });
+
+  it("dedupes when the cursor statement equals the full document", () => {
+    const sql = "SELECT 1;";
+    const candidates = buildExecutionCandidates(sql, indexOf(sql, "1"));
+    expect(candidates).toHaveLength(1);
+    expect(candidates[0].kind).toBe("all");
+  });
+
+  it("returns only 'all' when the cursor is on a blank line", () => {
+    const sql = "SELECT 1;\n\nSELECT 2;";
+    const candidates = buildExecutionCandidates(sql, sql.indexOf("\n") + 1);
+    expect(candidateKinds(candidates)).toEqual(["all"]);
+  });
+
+  it("returns no candidates for an empty document", () => {
+    expect(buildExecutionCandidates("", 0)).toEqual([]);
+  });
+
+  it("returns only 'all' when the cursor has no statement but the document has SQL", () => {
+    // Cursor past the end on a trailing blank line.
+    const sql = "SELECT 1;\nSELECT 2;\n";
+    const candidates = buildExecutionCandidates(sql, sql.length);
+    expect(candidateKinds(candidates)).toEqual(["all"]);
+  });
+
+  it("uses the MySQL statement body for delimiter scripts", () => {
+    const sql = "select COUNT(1) FROM your_table;\ndelimiter ;;\nselect COUNT(1) FROM your_table;\n\n;;\ndelimiter ;";
+    const candidates = buildExecutionCandidates(sql, indexOf(sql, "COUNT", 2), "mysql");
+    expect(candidateSummaries(candidates)).toEqual(["cursor:select COUNT(1) FROM your_table;", "all:select COUNT(1) FROM your_table;\ndelimiter ;;\nselect COUNT(1) FROM your_table;\n\n;;\ndelimiter ;"]);
+  });
+
+  it("uses the current SQL Server batch for cursor candidates", () => {
+    const sql = "SELECT 1\nGO\nSELECT 2;";
+    const candidates = buildExecutionCandidates(sql, indexOf(sql, "2"), "sqlserver");
+    expect(candidateSummaries(candidates)).toEqual(["cursor:SELECT 2", "all:SELECT 1\nGO\nSELECT 2;"]);
+  });
+});
+
+describe("hasMultipleExecutionTargets", () => {
+  it("returns false for a single SQL statement", () => {
+    expect(hasMultipleExecutionTargets("SELECT 1;")).toBe(false);
+  });
+
+  it("returns true for multiple SQL statements", () => {
+    expect(hasMultipleExecutionTargets("SELECT 1;\nSELECT 2;")).toBe(true);
+  });
+
+  it("ignores comments when counting SQL statements", () => {
+    expect(hasMultipleExecutionTargets("-- check one thing\nSELECT 1;")).toBe(false);
+  });
+
+  it("counts executable Redis command lines", () => {
+    expect(hasMultipleExecutionTargets("GET user:1", "redis")).toBe(false);
+    expect(hasMultipleExecutionTargets("GET user:1\n# comment\nDEL user:2", "redis")).toBe(true);
+  });
+
+  it("counts MySQL delimiter scripts by executable statements", () => {
+    const sql = "select COUNT(1) FROM your_table;\ndelimiter ;;\nselect COUNT(1) FROM your_table;\n\n;;\ndelimiter ;";
+    expect(hasMultipleExecutionTargets(sql, "mysql")).toBe(true);
+  });
+
+  it("counts MySQL routine blocks without delimiter by executable statements", () => {
+    expect(hasMultipleExecutionTargets(mysqlRoutineFixture, "mysql")).toBe(true);
+  });
+
+  it("counts SQL Server GO batches as multiple execution targets", () => {
+    expect(hasMultipleExecutionTargets("SELECT 1\nGO\nSELECT 2", "sqlserver")).toBe(true);
+  });
+
+  it("does not show multiple targets for MySQL DESC UPDATE joins", () => {
+    const sql = "desc update  test_orders a\njoin test_users b\non a.id=b.id \nset a.name = '张三'\nwhere b.id > 10;";
+    expect(hasMultipleExecutionTargets(sql, "mysql")).toBe(false);
+  });
+});
+
+describe("supportsExecutionTargetPicker", () => {
+  it("enables the picker for SQL database connections and Redis", () => {
+    expect(supportsExecutionTargetPicker("mysql")).toBe(true);
+    expect(supportsExecutionTargetPicker("postgres")).toBe(true);
+    expect(supportsExecutionTargetPicker("sqlserver")).toBe(true);
+    expect(supportsExecutionTargetPicker("sqlite")).toBe(true);
+    expect(supportsExecutionTargetPicker("jdbc")).toBe(true);
+    expect(supportsExecutionTargetPicker("redis")).toBe(true);
+    expect(supportsExecutionTargetPicker("mongodb")).toBe(false);
+    expect(supportsExecutionTargetPicker("elasticsearch")).toBe(false);
+    expect(supportsExecutionTargetPicker("qdrant")).toBe(false);
+    expect(supportsExecutionTargetPicker("milvus")).toBe(false);
+    expect(supportsExecutionTargetPicker("weaviate")).toBe(false);
+    expect(supportsExecutionTargetPicker("chromadb")).toBe(false);
+    expect(supportsExecutionTargetPicker("etcd")).toBe(false);
+    expect(supportsExecutionTargetPicker("zookeeper")).toBe(false);
+    expect(supportsExecutionTargetPicker("mq")).toBe(false);
+    expect(supportsExecutionTargetPicker("neo4j")).toBe(false);
+    expect(supportsExecutionTargetPicker(undefined)).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlVariableSyntax.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlVariableSyntax.spec.ts
new file mode 100644
index 0000000..4e25f88
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlVariableSyntax.spec.ts
@@ -0,0 +1,83 @@
+import { describe, expect, it } from "vitest";
+import { reactive } from "vue";
+import { DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES, enabledSqlParameterSyntaxes, normalizeSqlVariableSyntaxOverrides, resolveSqlVariableSyntaxToggles } from "@/lib/sql/sqlVariableSyntax";
+
+describe("resolveSqlVariableSyntaxToggles", () => {
+  it("enables every syntax when there are no overrides", () => {
+    expect(resolveSqlVariableSyntaxToggles(undefined, "mysql")).toEqual(DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES);
+    expect(resolveSqlVariableSyntaxToggles({}, "mysql")).toEqual(DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES);
+  });
+
+  it("enables every syntax for a database type without an entry", () => {
+    expect(resolveSqlVariableSyntaxToggles({ mysql: { shell: false } }, "postgres")).toEqual(DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES);
+  });
+
+  it("enables every syntax when the database type is unknown", () => {
+    expect(resolveSqlVariableSyntaxToggles({ mysql: { shell: false } }, undefined)).toEqual(DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES);
+  });
+
+  it("applies only the disabled syntaxes for the matching database type", () => {
+    expect(resolveSqlVariableSyntaxToggles({ mysql: { sqlserver: false, atSet: false } }, "mysql")).toEqual({
+      positional: true,
+      named: true,
+      shell: true,
+      mybatis: true,
+      sqlserver: false,
+      atSet: false,
+    });
+  });
+});
+
+describe("enabledSqlParameterSyntaxes", () => {
+  it("returns the five placeholder syntaxes and never atSet", () => {
+    expect(enabledSqlParameterSyntaxes(DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES)).toEqual(["positional", "named", "shell", "mybatis", "sqlserver"]);
+  });
+
+  it("filters out disabled placeholder syntaxes", () => {
+    expect(enabledSqlParameterSyntaxes({ positional: false, named: true, shell: false, mybatis: true, sqlserver: false, atSet: true })).toEqual(["named", "mybatis"]);
+  });
+
+  it("ignores the atSet toggle entirely", () => {
+    expect(enabledSqlParameterSyntaxes({ positional: true, named: true, shell: true, mybatis: true, sqlserver: true, atSet: false })).toEqual(["positional", "named", "shell", "mybatis", "sqlserver"]);
+    expect(enabledSqlParameterSyntaxes({ positional: false, named: false, shell: false, mybatis: false, sqlserver: false, atSet: true })).toEqual([]);
+  });
+});
+
+describe("normalizeSqlVariableSyntaxOverrides", () => {
+  it("returns an empty object for non-object input", () => {
+    expect(normalizeSqlVariableSyntaxOverrides(undefined)).toEqual({});
+    expect(normalizeSqlVariableSyntaxOverrides(null)).toEqual({});
+    expect(normalizeSqlVariableSyntaxOverrides([])).toEqual({});
+    expect(normalizeSqlVariableSyntaxOverrides("mysql")).toEqual({});
+  });
+
+  it("keeps only syntaxes explicitly set to false", () => {
+    expect(normalizeSqlVariableSyntaxOverrides({ mysql: { positional: true, shell: false, atSet: false } })).toEqual({ mysql: { shell: false, atSet: false } });
+  });
+
+  it("drops entries with no disabled syntaxes", () => {
+    expect(normalizeSqlVariableSyntaxOverrides({ mysql: { positional: true }, postgres: {} })).toEqual({});
+  });
+
+  it("ignores non-boolean values and unknown keys", () => {
+    expect(normalizeSqlVariableSyntaxOverrides({ mysql: { shell: "false", named: 0, bogus: false, sqlserver: false } })).toEqual({ mysql: { sqlserver: false } });
+  });
+
+  it("skips non-object database entries", () => {
+    expect(normalizeSqlVariableSyntaxOverrides({ mysql: null, postgres: [], sqlserver: { shell: false } })).toEqual({ sqlserver: { shell: false } });
+  });
+
+  it("is stable across a round-trip", () => {
+    const normalized = normalizeSqlVariableSyntaxOverrides({ mysql: { shell: false }, oracle: { atSet: false, named: false } });
+    expect(normalizeSqlVariableSyntaxOverrides(normalized)).toEqual(normalized);
+  });
+
+  it("reads through a Vue reactive proxy without throwing (settings store is reactive; structuredClone would throw DataCloneError here)", () => {
+    const overrides = reactive({ mysql: { shell: false, atSet: false } });
+    const cloned = normalizeSqlVariableSyntaxOverrides(overrides);
+    expect(cloned).toEqual({ mysql: { shell: false, atSet: false } });
+    // Detached from the reactive source: mutating the clone must not touch the proxy.
+    cloned.mysql = {};
+    expect(overrides.mysql).toEqual({ shell: false, atSet: false });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlVariables.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlVariables.spec.ts
new file mode 100644
index 0000000..b97ca1b
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/sql/sqlVariables.spec.ts
@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { expandSqlVariables } from "@/lib/sql/sqlVariables";
+
+describe("expandSqlVariables", () => {
+  it("returns the SQL unchanged when there is no @set declaration", () => {
+    const sql = "select * from t where id = @id";
+    expect(expandSqlVariables(sql)).toEqual({ sql, expanded: false });
+  });
+
+  it("inlines a declared IN-list verbatim across the script", () => {
+    const sql = ["@set client_id = (606,322,634);", "select * from invoices where client_id in @client_id"].join("\n");
+    const { sql: result, expanded } = expandSqlVariables(sql);
+    expect(expanded).toBe(true);
+    expect(result).toBe("select * from invoices where client_id in (606,322,634)");
+  });
+
+  it("inlines a quoted string value verbatim", () => {
+    const sql = ["@set date_start = '2026-07-04 00:00:00';", "select * from t where created_at < @date_start"].join("\n");
+    expect(expandSqlVariables(sql).sql).toBe("select * from t where created_at < '2026-07-04 00:00:00'");
+  });
+
+  it("expands the same variable in multiple places", () => {
+    const sql = ["@set tenant = 42;", "select @tenant, count(*) from t where tenant_id = @tenant"].join("\n");
+    expect(expandSqlVariables(sql).sql).toBe("select 42, count(*) from t where tenant_id = 42");
+  });
+
+  it("supports several declarations", () => {
+    const sql = ["@set a = 1;", "@set b = 'x';", "select @a, @b"].join("\n");
+    expect(expandSqlVariables(sql).sql).toBe("select 1, 'x'");
+  });
+
+  it("leaves undeclared @name references untouched", () => {
+    const sql = ["@set a = 1;", "select @a, @b, @@version"].join("\n");
+    expect(expandSqlVariables(sql).sql).toBe("select 1, @b, @@version");
+  });
+
+  it("does not expand references inside strings, comments, or quoted identifiers", () => {
+    const sql = ["@set a = 1;", "select '@a' as s, \"@a\" as q, `@a` as b -- @a"].join("\n");
+    expect(expandSqlVariables(sql).sql).toBe("select '@a' as s, \"@a\" as q, `@a` as b -- @a");
+  });
+
+  it("does not treat @set inside a string as a declaration", () => {
+    const sql = "select '@set a = 1;' as note, @a";
+    expect(expandSqlVariables(sql)).toEqual({ sql, expanded: false });
+  });
+
+  it("keeps a value's own quotes and parentheses intact", () => {
+    const sql = ["@set filter = (status = 'drafted' and deleted_at is null);", "select * from t where @filter"].join("\n");
+    expect(expandSqlVariables(sql).sql).toBe("select * from t where (status = 'drafted' and deleted_at is null)");
+  });
+
+  it("matches @set case-insensitively", () => {
+    const sql = ["@SET a = 7;", "select @a"].join("\n");
+    expect(expandSqlVariables(sql).sql).toBe("select 7");
+  });
+
+  it("does not treat @settings as an @set declaration", () => {
+    const sql = "select @settings from t";
+    expect(expandSqlVariables(sql)).toEqual({ sql, expanded: false });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/batchTableTruncate.spec.ts b/apps/desktop/src/lib/__tests__/table/batchTableTruncate.spec.ts
new file mode 100644
index 0000000..49256d6
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/batchTableTruncate.spec.ts
@@ -0,0 +1,33 @@
+import { describe, expect, it, vi } from "vitest";
+import { runBatchTableTruncate } from "@/lib/table/batchTableTruncate";
+
+describe("batch table truncate", () => {
+  it("refreshes completed targets before propagating a later failure", async () => {
+    const execute = vi.fn(async (table: string) => {
+      if (table === "locked") throw new Error("permission denied");
+    });
+    const refreshSucceeded = vi.fn(async () => undefined);
+
+    await expect(runBatchTableTruncate(["orders", "locked", "customers"], execute, refreshSucceeded)).rejects.toThrow("permission denied");
+
+    expect(execute).toHaveBeenCalledTimes(2);
+    expect(refreshSucceeded).toHaveBeenCalledOnce();
+    expect(refreshSucceeded).toHaveBeenCalledWith(["orders"]);
+  });
+
+  it("does not refresh when the first target fails", async () => {
+    const refreshSucceeded = vi.fn(async () => undefined);
+
+    await expect(
+      runBatchTableTruncate(
+        ["locked"],
+        async () => {
+          throw new Error("permission denied");
+        },
+        refreshSucceeded,
+      ),
+    ).rejects.toThrow("permission denied");
+
+    expect(refreshSucceeded).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/dataTabExecutionDatabase.spec.ts b/apps/desktop/src/lib/__tests__/table/dataTabExecutionDatabase.spec.ts
new file mode 100644
index 0000000..ea78815
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/dataTabExecutionDatabase.spec.ts
@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { dataTabExecutionDatabase } from "@/lib/table/dataTabExecutionDatabase";
+import type { ConnectionConfig } from "@/types/database";
+
+function connection(overrides: Partial<ConnectionConfig>): ConnectionConfig {
+  return {
+    id: "connection-1",
+    name: "Test",
+    db_type: "mysql",
+    host: "localhost",
+    port: 3306,
+    username: "root",
+    password: "",
+    ...overrides,
+  };
+}
+
+describe("dataTabExecutionDatabase", () => {
+  it("uses the configured database for a Doris external catalog", () => {
+    expect(dataTabExecutionDatabase(connection({ db_type: "doris", database: "yunye" }), "default", "iceberg_catalog")).toBe("yunye");
+  });
+
+  it("allows no session database for a Doris external catalog", () => {
+    expect(dataTabExecutionDatabase(connection({ db_type: "doris" }), "default", "iceberg_catalog")).toBe("");
+  });
+
+  it("uses the configured database for a StarRocks external catalog", () => {
+    expect(dataTabExecutionDatabase(connection({ db_type: "starrocks", database: "analytics" }), "default", "iceberg_catalog")).toBe("analytics");
+  });
+
+  it("recognizes Doris JDBC connections", () => {
+    expect(dataTabExecutionDatabase(connection({ db_type: "jdbc", connection_string: "jdbc:mysql://localhost:9030/db?product=doris", database: "internal_db" }), "default", "iceberg_catalog")).toBe("internal_db");
+  });
+
+  it("keeps the tab database for internal and ordinary tables", () => {
+    expect(dataTabExecutionDatabase(connection({ db_type: "doris", database: "configured" }), "internal_db")).toBe("internal_db");
+    expect(dataTabExecutionDatabase(connection({ db_type: "mysql", database: "configured" }), "tenant_db", "catalog_like_value")).toBe("tenant_db");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/mysqlDataTypeHelp.spec.ts b/apps/desktop/src/lib/__tests__/table/mysqlDataTypeHelp.spec.ts
new file mode 100644
index 0000000..2c0e241
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/mysqlDataTypeHelp.spec.ts
@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { DATA_TYPE_OPTIONS } from "@/lib/table/tableStructureEditorState";
+import { getMysqlDataTypeHelp } from "@/lib/table/mysqlDataTypeHelp";
+import en from "@/i18n/locales/en";
+import zhCN from "@/i18n/locales/zh-CN";
+
+function mysqlHelpMessages(locale: unknown): Record<string, unknown> {
+  const messages = locale as { structureEditor?: { mysqlDataTypeHelp?: Record<string, unknown> } };
+  return messages.structureEditor?.mysqlDataTypeHelp ?? {};
+}
+
+describe("getMysqlDataTypeHelp", () => {
+  it("normalizes MySQL attributes, aliases, parameters, casing, and whitespace", () => {
+    expect(getMysqlDataTypeHelp(" INT(11) UNSIGNED ")).toEqual({ key: "int", warningKeys: ["integerDisplayWidth"] });
+    expect(getMysqlDataTypeHelp("integer zerofill")).toEqual({ key: "int", warningKeys: ["zerofill"] });
+    expect(getMysqlDataTypeHelp("NUMERIC(10, 2)")).toEqual({ key: "decimal" });
+    expect(getMysqlDataTypeHelp(" double   precision ")).toEqual({ key: "double" });
+    expect(getMysqlDataTypeHelp("BOOL")).toEqual({ key: "boolean" });
+    expect(getMysqlDataTypeHelp("DEC(20, 6)")).toEqual({ key: "decimal" });
+    expect(getMysqlDataTypeHelp("CHARACTER VARYING(120)")).toEqual({ key: "varchar" });
+    expect(getMysqlDataTypeHelp("CHARACTER(12)")).toEqual({ key: "char" });
+    expect(getMysqlDataTypeHelp("CHAR VARYING(120)")).toEqual({ key: "varchar" });
+    expect(getMysqlDataTypeHelp("CHAR BYTE")).toEqual({ key: "char" });
+  });
+
+  it("covers phpMyAdmin's additional MySQL type aliases for dynamic type lists", () => {
+    expect(getMysqlDataTypeHelp("FIXED")?.key).toBe("decimal");
+    expect(getMysqlDataTypeHelp("FLOAT4")?.key).toBe("float");
+    expect(getMysqlDataTypeHelp("FLOAT8")?.key).toBe("double");
+    expect(getMysqlDataTypeHelp("INT1")?.key).toBe("tinyint");
+    expect(getMysqlDataTypeHelp("INT2")?.key).toBe("smallint");
+    expect(getMysqlDataTypeHelp("INT3")?.key).toBe("mediumint");
+    expect(getMysqlDataTypeHelp("INT4")?.key).toBe("int");
+    expect(getMysqlDataTypeHelp("INT8")?.key).toBe("bigint");
+    expect(getMysqlDataTypeHelp("MIDDLEINT")?.key).toBe("mediumint");
+    expect(getMysqlDataTypeHelp("LONG")?.key).toBe("mediumtext");
+    expect(getMysqlDataTypeHelp("LONG VARCHAR")?.key).toBe("mediumtext");
+    expect(getMysqlDataTypeHelp("LONG VARBINARY")?.key).toBe("mediumblob");
+    expect(getMysqlDataTypeHelp("GEOMCOLLECTION")?.key).toBe("geometrycollection");
+    expect(getMysqlDataTypeHelp("NCHAR(30)")?.key).toBe("nationalCharacter");
+    expect(getMysqlDataTypeHelp("NVARCHAR(30)")?.key).toBe("nationalCharacter");
+    expect(getMysqlDataTypeHelp("NATIONAL CHARACTER VARYING(30)")?.key).toBe("nationalCharacter");
+  });
+
+  it("documents numeric, text, binary, enum, temporal, JSON, and spatial types", () => {
+    expect(getMysqlDataTypeHelp("bigint unsigned")?.key).toBe("bigint");
+    expect(getMysqlDataTypeHelp("varchar")?.key).toBe("varchar");
+    expect(getMysqlDataTypeHelp("mediumblob")?.key).toBe("mediumblob");
+    expect(getMysqlDataTypeHelp("enum")?.key).toBe("enum");
+    expect(getMysqlDataTypeHelp("timestamp")?.key).toBe("timestamp");
+    expect(getMysqlDataTypeHelp("json")?.key).toBe("json");
+    expect(getMysqlDataTypeHelp("geometrycollection")?.key).toBe("geometrycollection");
+  });
+
+  it("uses product-specific JSON help when the connection profile identifies the server", () => {
+    expect(getMysqlDataTypeHelp("json")).toEqual({ key: "json" });
+    expect(getMysqlDataTypeHelp("json", { product: "mysql" })).toEqual({ key: "jsonMysql" });
+    expect(getMysqlDataTypeHelp("json", { product: "mariadb" })).toEqual({ key: "jsonMariaDb" });
+  });
+
+  it("warns about MySQL 8 numeric syntax based on the exact raw type", () => {
+    expect(getMysqlDataTypeHelp("INT(11) ZEROFILL")).toEqual({ key: "int", warningKeys: ["integerDisplayWidth", "zerofill"] });
+    expect(getMysqlDataTypeHelp("DECIMAL(10,2) UNSIGNED")).toEqual({ key: "decimal", warningKeys: ["unsignedNumeric"] });
+    expect(getMysqlDataTypeHelp("FLOAT(30)")).toEqual({ key: "float", warningKeys: ["floatPrecision"] });
+    expect(getMysqlDataTypeHelp("DOUBLE(10,2) UNSIGNED")).toEqual({ key: "double", warningKeys: ["unsignedNumeric", "floatingPointDisplay"] });
+  });
+
+  it("also recognizes compatible-server extensions and leaves unknown custom types alone", () => {
+    expect(getMysqlDataTypeHelp("inet4")?.key).toBe("inet4");
+    expect(getMysqlDataTypeHelp("inet6")?.key).toBe("inet6");
+    expect(getMysqlDataTypeHelp("uuid")?.key).toBe("uuid");
+    expect(getMysqlDataTypeHelp("vector(1536)")?.key).toBe("vector");
+    expect(getMysqlDataTypeHelp("xmltype")?.key).toBe("xmltype");
+    expect(getMysqlDataTypeHelp("my_private_type")).toBeUndefined();
+  });
+
+  it("covers every built-in MySQL type option", () => {
+    const undocumented = DATA_TYPE_OPTIONS.mysql.filter((type) => !getMysqlDataTypeHelp(type));
+    expect(undocumented).toEqual([]);
+  });
+
+  it("has an English and Simplified Chinese message for every supported help key", () => {
+    const options = [...DATA_TYPE_OPTIONS.mysql, "inet4", "inet6", "uuid", "vector", "xmltype", "character", "char varying", "char byte", "geomcollection", "nchar", "nvarchar", "national character varying", "int(11) zerofill", "decimal(10,2) unsigned", "float(30)", "double(10,2)"];
+    const english = mysqlHelpMessages(en);
+    const chinese = mysqlHelpMessages(zhCN);
+
+    for (const option of options) {
+      const key = getMysqlDataTypeHelp(option)?.key;
+      expect(key, option).toBeTruthy();
+      for (const helpKey of [key!, ...(getMysqlDataTypeHelp(option)?.warningKeys ?? [])]) {
+        expect(english[helpKey], `English: ${option}`).toEqual(expect.any(String));
+        expect(chinese[helpKey], `Simplified Chinese: ${option}`).toEqual(expect.any(String));
+      }
+    }
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/objectBrowserRowAction.spec.ts b/apps/desktop/src/lib/__tests__/table/objectBrowserRowAction.spec.ts
new file mode 100644
index 0000000..5c34f0b
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/objectBrowserRowAction.spec.ts
@@ -0,0 +1,147 @@
+import { describe, expect, it } from "vitest";
+import { doubleClickRowAction, resolveRowClickAction, shouldDeferSingleClick, singleClickRowAction, type ObjectBrowserRowAction } from "@/lib/table/objectBrowserRowAction";
+import type { ObjectBrowserRow } from "@/lib/table/objectBrowserRows";
+
+function row(type: ObjectBrowserRow["type"], name = "test"): ObjectBrowserRow {
+  return { id: `${type}-${name}`, name, displayName: name, type };
+}
+
+describe("singleClickRowAction", () => {
+  it("returns table-info for TABLE", () => {
+    expect(singleClickRowAction(row("TABLE", "users"))).toBe("table-info");
+  });
+
+  it("returns open-source for VIEW", () => {
+    expect(singleClickRowAction(row("VIEW", "v_users"))).toBe("open-source");
+  });
+
+  it("returns open-source for PROCEDURE", () => {
+    expect(singleClickRowAction(row("PROCEDURE", "sp_test"))).toBe("open-source");
+  });
+
+  it("returns open-source for FUNCTION", () => {
+    expect(singleClickRowAction(row("FUNCTION", "fn_test"))).toBe("open-source");
+  });
+
+  it("returns open-source for SEQUENCE", () => {
+    expect(singleClickRowAction(row("SEQUENCE", "seq_test"))).toBe("open-source");
+  });
+
+  it("returns open-source for MATERIALIZED_VIEW", () => {
+    expect(singleClickRowAction(row("MATERIALIZED_VIEW", "mv_test"))).toBe("open-source");
+  });
+
+  it("returns open-source for PACKAGE", () => {
+    expect(singleClickRowAction(row("PACKAGE", "pkg_test"))).toBe("open-source");
+  });
+
+  it("returns open-source for PACKAGE_BODY", () => {
+    expect(singleClickRowAction(row("PACKAGE_BODY", "pkg_body_test"))).toBe("open-source");
+  });
+
+  it("returns none for null/undefined", () => {
+    expect(singleClickRowAction(null)).toBe("none");
+    expect(singleClickRowAction(undefined)).toBe("none");
+  });
+});
+
+describe("doubleClickRowAction", () => {
+  it("returns open-table for TABLE", () => {
+    expect(doubleClickRowAction(row("TABLE", "orders"))).toBe("open-table");
+  });
+
+  it("returns open-source for VIEW", () => {
+    expect(doubleClickRowAction(row("VIEW", "v_orders"))).toBe("open-source");
+  });
+
+  it("returns open-source for PROCEDURE", () => {
+    expect(doubleClickRowAction(row("PROCEDURE", "sp_run"))).toBe("open-source");
+  });
+
+  it("returns none for null/undefined", () => {
+    expect(doubleClickRowAction(null)).toBe("none");
+  });
+});
+
+describe("resolveRowClickAction", () => {
+  const tableRow = row("TABLE", "users");
+  const viewRow = row("VIEW", "v_users");
+
+  describe("single-click activation mode", () => {
+    it("single click on TABLE returns table-info", () => {
+      const result = resolveRowClickAction(tableRow, 1, "single");
+      expect(result.action).toBe("table-info");
+      expect(result.isDouble).toBe(false);
+    });
+
+    it("double click on TABLE returns open-table", () => {
+      const result = resolveRowClickAction(tableRow, 2, "single");
+      expect(result.action).toBe("open-table");
+      expect(result.isDouble).toBe(true);
+    });
+
+    it("single click on VIEW returns open-source", () => {
+      const result = resolveRowClickAction(viewRow, 1, "single");
+      expect(result.action).toBe("open-source");
+      expect(result.isDouble).toBe(false);
+    });
+
+    it("double click on VIEW returns open-source", () => {
+      const result = resolveRowClickAction(viewRow, 2, "single");
+      expect(result.action).toBe("open-source");
+      expect(result.isDouble).toBe(true);
+    });
+  });
+
+  describe("double-click activation mode", () => {
+    it("single click (detail=1) on TABLE returns table-info (side panel)", () => {
+      const result = resolveRowClickAction(tableRow, 1, "double");
+      expect(result.action).toBe("table-info");
+      expect(result.isDouble).toBe(false);
+    });
+
+    it("single click (detail=1) on VIEW returns open-source (side panel)", () => {
+      const result = resolveRowClickAction(viewRow, 1, "double");
+      expect(result.action).toBe("open-source");
+      expect(result.isDouble).toBe(false);
+    });
+
+    it("double click on TABLE returns open-table", () => {
+      const result = resolveRowClickAction(tableRow, 2, "double");
+      expect(result.action).toBe("open-table");
+      expect(result.isDouble).toBe(true);
+    });
+
+    it("double click on VIEW returns open-source", () => {
+      const result = resolveRowClickAction(viewRow, 2, "double");
+      expect(result.action).toBe("open-source");
+      expect(result.isDouble).toBe(true);
+    });
+  });
+});
+
+describe("shouldDeferSingleClick", () => {
+  const tableRow = row("TABLE", "users");
+  const viewRow = row("VIEW", "v_users");
+
+  it("defers TABLE table-info (distinct single/double actions)", () => {
+    expect(shouldDeferSingleClick(tableRow, "table-info")).toBe(true);
+  });
+
+  it("does not defer VIEW open-source (same single/double action)", () => {
+    expect(shouldDeferSingleClick(viewRow, "open-source")).toBe(false);
+  });
+
+  it("does not defer none action", () => {
+    expect(shouldDeferSingleClick(tableRow, "none")).toBe(false);
+  });
+
+  it("does not defer when action is not the single-click action", () => {
+    expect(shouldDeferSingleClick(tableRow, "open-table")).toBe(false);
+  });
+
+  it("handles null/undefined row", () => {
+    expect(shouldDeferSingleClick(null, "table-info")).toBe(false);
+    expect(shouldDeferSingleClick(undefined, "open-source")).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/objectSourceEditor.spec.ts b/apps/desktop/src/lib/__tests__/table/objectSourceEditor.spec.ts
new file mode 100644
index 0000000..78e692d
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/objectSourceEditor.spec.ts
@@ -0,0 +1,34 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import * as api from "@/lib/backend/api";
+import { executeObjectSourceSave } from "@/lib/table/objectSourceEditor";
+
+vi.mock("@/lib/backend/api", () => ({
+  executeInTransaction: vi.fn().mockResolvedValue({}),
+  executeQuery: vi.fn().mockResolvedValue({}),
+  executeScript: vi.fn().mockResolvedValue({}),
+}));
+
+beforeEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("executeObjectSourceSave", () => {
+  it("runs multi-statement Informix source saves in a transaction", async () => {
+    await executeObjectSourceSave("conn-1", "stores", "informix", ["CREATE TEMP VIEW v AS SELECT 1", "  ", "DROP VIEW v", "CREATE VIEW v AS SELECT 2"], "app");
+
+    expect(api.executeInTransaction).toHaveBeenCalledOnce();
+    expect(api.executeInTransaction).toHaveBeenCalledWith("conn-1", "stores", ["CREATE TEMP VIEW v AS SELECT 1", "DROP VIEW v", "CREATE VIEW v AS SELECT 2"], "app");
+    expect(api.executeQuery).not.toHaveBeenCalled();
+    expect(api.executeScript).not.toHaveBeenCalled();
+  });
+
+  it("keeps non-Informix source saves on the existing per-statement path", async () => {
+    await executeObjectSourceSave("conn-1", "app", "mysql", ["ALTER VIEW v AS SELECT 1", "", "ALTER VIEW v AS SELECT 2"], "public");
+
+    expect(api.executeInTransaction).not.toHaveBeenCalled();
+    expect(api.executeQuery).toHaveBeenCalledTimes(2);
+    expect(api.executeQuery).toHaveBeenNthCalledWith(1, "conn-1", "app", "ALTER VIEW v AS SELECT 1", "public");
+    expect(api.executeQuery).toHaveBeenNthCalledWith(2, "conn-1", "app", "ALTER VIEW v AS SELECT 2", "public");
+    expect(api.executeScript).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/postgresDataTypeHelp.spec.ts b/apps/desktop/src/lib/__tests__/table/postgresDataTypeHelp.spec.ts
new file mode 100644
index 0000000..29b91db
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/postgresDataTypeHelp.spec.ts
@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { DATA_TYPE_OPTIONS } from "@/lib/table/tableStructureEditorState";
+import { getPostgresDataTypeHelp } from "@/lib/table/postgresDataTypeHelp";
+import en from "@/i18n/locales/en";
+import zhCN from "@/i18n/locales/zh-CN";
+
+function postgresHelpMessages(locale: unknown): Record<string, unknown> {
+  const messages = locale as { structureEditor?: { postgresDataTypeHelp?: Record<string, unknown> } };
+  return messages.structureEditor?.postgresDataTypeHelp ?? {};
+}
+
+describe("getPostgresDataTypeHelp", () => {
+  it("covers every built-in PostgreSQL type option", () => {
+    expect(DATA_TYPE_OPTIONS.postgres.filter((type) => !getPostgresDataTypeHelp(type))).toEqual([]);
+  });
+
+  it("normalizes aliases and float precision parameters", () => {
+    expect(getPostgresDataTypeHelp("int2")).toEqual({ key: "smallint" });
+    expect(getPostgresDataTypeHelp("INT4")).toEqual({ key: "integer" });
+    expect(getPostgresDataTypeHelp("int8")).toEqual({ key: "bigint" });
+    expect(getPostgresDataTypeHelp("decimal(10, 2)")).toEqual({ key: "numeric" });
+    expect(getPostgresDataTypeHelp("float")).toEqual({ key: "double" });
+    expect(getPostgresDataTypeHelp("float(24)")).toEqual({ key: "real" });
+    expect(getPostgresDataTypeHelp("float(25)")).toEqual({ key: "double" });
+    expect(getPostgresDataTypeHelp("float(0)")).toBeUndefined();
+    expect(getPostgresDataTypeHelp("float(54)")).toBeUndefined();
+    expect(getPostgresDataTypeHelp("float(1.5)")).toBeUndefined();
+    expect(getPostgresDataTypeHelp("float(precision)")).toBeUndefined();
+    expect(getPostgresDataTypeHelp("character varying(255)")).toEqual({ key: "varchar" });
+  });
+
+  it("documents serial, temporal aliases, dynamic built-ins, and arrays", () => {
+    expect(getPostgresDataTypeHelp("bigserial")).toEqual({ key: "serial" });
+    expect(getPostgresDataTypeHelp("timestamp with time zone")).toEqual({ key: "timestamptz" });
+    expect(getPostgresDataTypeHelp("int4multirange")).toEqual({ key: "multirange" });
+    expect(getPostgresDataTypeHelp("jsonpath")).toEqual({ key: "jsonpath" });
+    expect(getPostgresDataTypeHelp("pg_lsn")).toEqual({ key: "pgLsn" });
+    expect(getPostgresDataTypeHelp("pg_snapshot")).toEqual({ key: "pgSnapshot" });
+    expect(getPostgresDataTypeHelp("uuid[][]")).toEqual({ key: "array" });
+    expect(getPostgresDataTypeHelp("my_schema.order_status[]")).toEqual({ key: "array" });
+  });
+
+  it("leaves extensions and named user types undocumented", () => {
+    expect(getPostgresDataTypeHelp("vector(1536)")).toBeUndefined();
+    expect(getPostgresDataTypeHelp("geometry(Point, 4326)")).toBeUndefined();
+    expect(getPostgresDataTypeHelp("citext")).toBeUndefined();
+    expect(getPostgresDataTypeHelp("hstore")).toBeUndefined();
+    expect(getPostgresDataTypeHelp("order_status")).toBeUndefined();
+    expect(getPostgresDataTypeHelp("order_status_multirange")).toBeUndefined();
+  });
+
+  it("has English and Simplified Chinese copy for every supported static key", () => {
+    const english = postgresHelpMessages(en);
+    const chinese = postgresHelpMessages(zhCN);
+    const dynamic = ["int4multirange", "jsonpath", "pg_lsn", "pg_snapshot", "any_type[]"];
+
+    for (const option of [...DATA_TYPE_OPTIONS.postgres, ...dynamic]) {
+      const key = getPostgresDataTypeHelp(option)?.key;
+      expect(key, option).toBeTruthy();
+      expect(english[key!], `English: ${option}`).toEqual(expect.any(String));
+      expect(chinese[key!], `Simplified Chinese: ${option}`).toEqual(expect.any(String));
+    }
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/sidePanelRequestGuard.spec.ts b/apps/desktop/src/lib/__tests__/table/sidePanelRequestGuard.spec.ts
new file mode 100644
index 0000000..a65586c
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/sidePanelRequestGuard.spec.ts
@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { createSidePanelRequestGuard } from "@/lib/table/sidePanelRequestGuard";
+
+describe("SidePanelRequestGuard", () => {
+  it("fresh capture is not stale", () => {
+    const guard = createSidePanelRequestGuard();
+    const epoch = guard.capture();
+    expect(guard.isStale(epoch)).toBe(false);
+    expect(guard.isFresh(epoch)).toBe(true);
+  });
+
+  it("bump invalidates previously captured epoch", () => {
+    const guard = createSidePanelRequestGuard();
+    const epoch = guard.capture();
+    guard.bump();
+    expect(guard.isStale(epoch)).toBe(true);
+    expect(guard.isFresh(epoch)).toBe(false);
+  });
+
+  it("multiple bumps invalidate all previous epochs", () => {
+    const guard = createSidePanelRequestGuard();
+    const e1 = guard.capture();
+    guard.bump();
+    const e2 = guard.capture();
+    guard.bump();
+    const e3 = guard.capture();
+    expect(guard.isStale(e1)).toBe(true);
+    expect(guard.isStale(e2)).toBe(true);
+    expect(guard.isStale(e3)).toBe(false);
+    expect(guard.isFresh(e3)).toBe(true);
+  });
+
+  it("starting B invalidates an in-flight request for A", () => {
+    const guard = createSidePanelRequestGuard();
+    const epochA = guard.start();
+    const epochB = guard.start();
+
+    expect(guard.isStale(epochA)).toBe(true);
+    expect(guard.isFresh(epochB)).toBe(true);
+  });
+
+  it("simulates database context change: old results are stale", () => {
+    const guard = createSidePanelRequestGuard();
+    const epochDb1 = guard.capture();
+    // Database switch → close panel + bump epoch
+    guard.bump();
+    // Old request from DB1 arrives — must be discarded
+    expect(guard.isStale(epochDb1)).toBe(true);
+  });
+
+  it("guards are independent", () => {
+    const guard1 = createSidePanelRequestGuard();
+    const guard2 = createSidePanelRequestGuard();
+    const e1 = guard1.capture();
+    guard2.bump();
+    expect(guard1.isStale(e1)).toBe(false);
+    expect(guard2.isStale(e1)).toBe(true);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/sqliteDataTypeHelp.spec.ts b/apps/desktop/src/lib/__tests__/table/sqliteDataTypeHelp.spec.ts
new file mode 100644
index 0000000..dc79e74
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/sqliteDataTypeHelp.spec.ts
@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { DATA_TYPE_OPTIONS } from "@/lib/table/tableStructureEditorState";
+import { getSqliteDataTypeHelp } from "@/lib/table/sqliteDataTypeHelp";
+import en from "@/i18n/locales/en";
+import zhCN from "@/i18n/locales/zh-CN";
+
+function sqliteHelpMessages(locale: unknown): Record<string, unknown> {
+  const messages = locale as { structureEditor?: { sqliteDataTypeHelp?: Record<string, unknown> } };
+  return messages.structureEditor?.sqliteDataTypeHelp ?? {};
+}
+
+describe("getSqliteDataTypeHelp", () => {
+  it("covers every built-in SQLite type option", () => {
+    expect(DATA_TYPE_OPTIONS.sqlite.filter((type) => !getSqliteDataTypeHelp(type))).toEqual([]);
+  });
+
+  it("normalizes whitespace, casing, and declared type parameters", () => {
+    expect(getSqliteDataTypeHelp(" INTEGER ")).toEqual({ key: "integer" });
+    expect(getSqliteDataTypeHelp("VARCHAR(255)")).toEqual({ key: "text" });
+    expect(getSqliteDataTypeHelp(" decimal(10, 2) ")).toEqual({ key: "numeric" });
+  });
+
+  it("applies SQLite's ordered declared-type affinity rules", () => {
+    expect(getSqliteDataTypeHelp("char(12)")).toEqual({ key: "text" });
+    expect(getSqliteDataTypeHelp("boolean")).toEqual({ key: "numeric" });
+    expect(getSqliteDataTypeHelp("unsigned big int")).toEqual({ key: "integer" });
+    expect(getSqliteDataTypeHelp("double precision")).toEqual({ key: "real" });
+    expect(getSqliteDataTypeHelp("date")).toEqual({ key: "numeric" });
+    expect(getSqliteDataTypeHelp("datetime")).toEqual({ key: "numeric" });
+    expect(getSqliteDataTypeHelp("time")).toEqual({ key: "numeric" });
+    expect(getSqliteDataTypeHelp("VARCHAR2")).toEqual({ key: "text" });
+    expect(getSqliteDataTypeHelp("CHARACTER")).toEqual({ key: "text" });
+    expect(getSqliteDataTypeHelp("INT64")).toEqual({ key: "integer" });
+    expect(getSqliteDataTypeHelp("FLOATING POINT")).toEqual({ key: "integer" });
+    expect(getSqliteDataTypeHelp("STRING")).toEqual({ key: "numeric" });
+    expect(getSqliteDataTypeHelp("application_status")).toEqual({ key: "numeric" });
+    expect(getSqliteDataTypeHelp("")).toEqual({ key: "blob" });
+  });
+
+  it("has English and Simplified Chinese copy for static and common help keys", () => {
+    const english = sqliteHelpMessages(en);
+    const chinese = sqliteHelpMessages(zhCN);
+    const types = [...DATA_TYPE_OPTIONS.sqlite, "varchar", "boolean", "datetime"];
+
+    for (const type of types) {
+      const key = getSqliteDataTypeHelp(type)?.key;
+      expect(key, type).toBeTruthy();
+      expect(english[key!], `English: ${type}`).toEqual(expect.any(String));
+      expect(chinese[key!], `Simplified Chinese: ${type}`).toEqual(expect.any(String));
+    }
+  });
+
+  it("calls out SQLite affinity and its important storage exceptions", () => {
+    const english = sqliteHelpMessages(en);
+
+    expect(english.integer).toContain("rowid");
+    expect(english.integer).toContain("does not enforce");
+    expect(english.real).toContain("IEEE 754");
+    expect(english.text).toContain("do not enforce n");
+    expect(english.blob).toContain("without type conversion");
+    expect(english.numeric).toContain("not a separate SQLite storage class");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/tableDependencySort.spec.ts b/apps/desktop/src/lib/__tests__/table/tableDependencySort.spec.ts
new file mode 100644
index 0000000..d5b76c1
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/tableDependencySort.spec.ts
@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { sortTablesByFkDependency, type TableWithFk } from "@/lib/table/tableDependencySort";
+
+function fk(refTable: string) {
+  return { name: `fk_to_${refTable}`, column: "id", ref_table: refTable, ref_column: "id" };
+}
+
+function table(name: string, foreignKeys: ReturnType<typeof fk>[] = []): TableWithFk {
+  return { name, foreignKeys };
+}
+
+describe("sortTablesByFkDependency", () => {
+  it("returns single table unchanged", () => {
+    const input = [table("t1")];
+    const result = sortTablesByFkDependency(input);
+    expect(result.map((t) => t.name)).toEqual(["t1"]);
+  });
+
+  it("returns empty array unchanged", () => {
+    expect(sortTablesByFkDependency([])).toEqual([]);
+  });
+
+  it("preserves original order when no FK dependencies exist", () => {
+    const input = [table("t2"), table("t1")];
+    const result = sortTablesByFkDependency(input);
+    expect(result.map((t) => t.name)).toEqual(["t2", "t1"]);
+  });
+
+  it("sorts referencing table before referenced table (simple dependency)", () => {
+    // t2 references t1 → t2 should be dropped before t1
+    const input = [table("t1"), table("t2", [fk("t1")])];
+    const result = sortTablesByFkDependency(input);
+    expect(result.map((t) => t.name)).toEqual(["t2", "t1"]);
+  });
+
+  it("sorts referencing table before referenced table regardless of input order", () => {
+    // Input order reversed from the above test
+    const input = [table("t2", [fk("t1")]), table("t1")];
+    const result = sortTablesByFkDependency(input);
+    expect(result.map((t) => t.name)).toEqual(["t2", "t1"]);
+  });
+
+  it("handles chain dependency (C→B→A)", () => {
+    // t3 references t2, t2 references t1 → t3, t2, t1
+    const input = [table("t1"), table("t2", [fk("t1")]), table("t3", [fk("t2")])];
+    const result = sortTablesByFkDependency(input);
+    expect(result.map((t) => t.name)).toEqual(["t3", "t2", "t1"]);
+  });
+
+  it("handles multiple tables referencing the same table", () => {
+    // t2 and t3 both reference t1 → t2,t3 before t1
+    const input = [table("t1"), table("t2", [fk("t1")]), table("t3", [fk("t1")])];
+    const result = sortTablesByFkDependency(input);
+    const names = result.map((t) => t.name);
+    // t1 must be last
+    expect(names[names.length - 1]).toBe("t1");
+    // t2 and t3 must come before t1
+    expect(names.slice(0, 2)).toEqual(expect.arrayContaining(["t2", "t3"]));
+  });
+
+  it("falls back to original order on cyclic dependency", () => {
+    // t1 references t2 and t2 references t1
+    const input = [table("t1", [fk("t2")]), table("t2", [fk("t1")])];
+    const result = sortTablesByFkDependency(input);
+    expect(result.map((t) => t.name)).toEqual(["t1", "t2"]);
+  });
+
+  it("ignores FK references to tables not in the selected set", () => {
+    // t2 references t3 (not selected), t1 has no FK → original order
+    const input = [table("t1"), table("t2", [fk("t3")])];
+    const result = sortTablesByFkDependency(input);
+    expect(result.map((t) => t.name)).toEqual(["t1", "t2"]);
+  });
+
+  it("handles table with multiple FKs where only some target selected tables", () => {
+    // t3 references both t1 (selected) and t4 (not selected)
+    const input = [table("t1"), table("t3", [fk("t1"), fk("t4")])];
+    const result = sortTablesByFkDependency(input);
+    expect(result.map((t) => t.name)).toEqual(["t3", "t1"]);
+  });
+
+  it("handles complex DAG with multiple branches", () => {
+    // t4 → t2 → t1
+    // t3 → t1
+    const input = [table("t1"), table("t2", [fk("t1")]), table("t3", [fk("t1")]), table("t4", [fk("t2")])];
+    const result = sortTablesByFkDependency(input);
+    const names = result.map((t) => t.name);
+    // t1 must be last (everything references it directly or indirectly)
+    expect(names[names.length - 1]).toBe("t1");
+    // t4 must come before t2
+    expect(names.indexOf("t4")).toBeLessThan(names.indexOf("t2"));
+    // t2 and t3 must come before t1
+    expect(names.indexOf("t2")).toBeLessThan(names.indexOf("t1"));
+    expect(names.indexOf("t3")).toBeLessThan(names.indexOf("t1"));
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/tableEditing.spec.ts b/apps/desktop/src/lib/__tests__/table/tableEditing.spec.ts
new file mode 100644
index 0000000..4ef9207
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/tableEditing.spec.ts
@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import {
+  DBX_ROWID_COLUMN,
+  DBX_TDENGINE_TBNAME_COLUMN,
+  canDeleteExistingTdengineRows,
+  canEditExistingTableRows,
+  canUseKeylessRowPredicate,
+  editablePrimaryKeys,
+  editableRowIdentifierColumns,
+  hasCompleteTdengineRowIdentity,
+  isClickHouseExistingRowReadonlyColumn,
+  isTdengineExistingRowReadonlyColumn,
+  isTableDataEditable,
+  supportsDataGridTransaction,
+  usesSyntheticRowIdKey,
+} from "@/lib/table/tableEditing";
+import type { ColumnInfo, IndexInfo } from "@/types/database";
+
+function column(name: string, isPrimaryKey = false): ColumnInfo {
+  return {
+    name,
+    data_type: "varchar",
+    is_nullable: true,
+    column_default: null,
+    is_primary_key: isPrimaryKey,
+    extra: null,
+  };
+}
+
+function index(columns: string[], isUnique = true, filter: string | null = null): IndexInfo {
+  return {
+    name: columns.join("_"),
+    columns,
+    is_unique: isUnique,
+    is_primary: false,
+    filter,
+  };
+}
+
+describe("tableEditing", () => {
+  it("does not synthesize Oracle ROWID for views", () => {
+    expect(editablePrimaryKeys("oracle", [column("ID"), column("NAME")], "VIEW")).toEqual([]);
+    expect(editablePrimaryKeys("oracle", [column("ID"), column("NAME")], "TABLE")).toEqual([DBX_ROWID_COLUMN]);
+  });
+
+  it("treats view data tabs as readonly", () => {
+    expect(isTableDataEditable("oracle", [DBX_ROWID_COLUMN], "VIEW")).toBe(false);
+  });
+
+  it("does not include Oracle ROWID for view data tabs", () => {
+    expect(usesSyntheticRowIdKey("oracle", [DBX_ROWID_COLUMN], "VIEW")).toBe(false);
+    expect(usesSyntheticRowIdKey("oracle", [DBX_ROWID_COLUMN], "MATERIALIZED_VIEW")).toBe(false);
+  });
+
+  it("allows keyless row predicates only for databases that support them", () => {
+    expect(canUseKeylessRowPredicate("postgres", [])).toBe(true);
+    expect(canUseKeylessRowPredicate("mysql", [])).toBe(true);
+    expect(canUseKeylessRowPredicate("jdbc", [])).toBe(false);
+    expect(canUseKeylessRowPredicate("postgres", ["id"])).toBe(false);
+  });
+
+  it("uses unique indexes as row identifiers when primary keys are absent", () => {
+    expect(editableRowIdentifierColumns("postgres", [column("email"), column("name")], [index(["email", "name"]), index(["email"])])).toEqual(["email"]);
+    expect(editableRowIdentifierColumns("postgres", [column("email"), column("name")], [index(["email"], true, "email IS NOT NULL")])).toEqual([]);
+    expect(editableRowIdentifierColumns("postgres", [column("id", true), column("email")], [index(["email"])])).toEqual(["id"]);
+  });
+
+  it("allows ClickHouse table editing when row identifiers are available", () => {
+    expect(isTableDataEditable("clickhouse", ["id"], "BASE TABLE")).toBe(true);
+    expect(canEditExistingTableRows("clickhouse", undefined, ["id"])).toBe(true);
+    expect(supportsDataGridTransaction("clickhouse")).toBe(false);
+    expect(isTableDataEditable("clickhouse", [], "BASE TABLE")).toBe(true);
+    expect(canEditExistingTableRows("clickhouse", undefined, [])).toBe(false);
+  });
+
+  it("uses tbname only when editing TDengine stable rows", () => {
+    const columns = [column("ts", true), column("seq", true), column("voltage")];
+    expect(editablePrimaryKeys("tdengine", columns, "STABLE")).toEqual([DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"]);
+    expect(editablePrimaryKeys("tdengine", columns, "TABLE")).toEqual(["ts", "seq"]);
+    expect(canEditExistingTableRows("tdengine", undefined, ["ts", "seq"])).toBe(true);
+    expect(canEditExistingTableRows("tdengine", undefined, [])).toBe(false);
+    expect(isTdengineExistingRowReadonlyColumn("tdengine", "seq", columns)).toBe(true);
+  });
+
+  it("requires every TDengine row identifier in editable results", () => {
+    const stableKeys = [DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"];
+    expect(hasCompleteTdengineRowIdentity("tdengine", stableKeys, ["tbname", "ts", "seq", "voltage"])).toBe(true);
+    expect(hasCompleteTdengineRowIdentity("tdengine", stableKeys, ["tbname", "ts", "voltage"])).toBe(false);
+    expect(hasCompleteTdengineRowIdentity("tdengine", ["ts", "seq"], ["ts", "seq", "voltage"])).toBe(true);
+    expect(hasCompleteTdengineRowIdentity("postgres", ["id"], [])).toBe(true);
+  });
+
+  it("disables existing-row deletion for TDengine composite keys", () => {
+    expect(canDeleteExistingTdengineRows("tdengine", ["ts"])).toBe(true);
+    expect(canDeleteExistingTdengineRows("tdengine", [DBX_TDENGINE_TBNAME_COLUMN, "ts"])).toBe(true);
+    expect(canDeleteExistingTdengineRows("tdengine", ["ts", "seq"])).toBe(false);
+    expect(canDeleteExistingTdengineRows("tdengine", [DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"])).toBe(false);
+    expect(canDeleteExistingTdengineRows("postgres", ["id", "tenant_id"])).toBe(true);
+  });
+
+  it("treats ClickHouse row identifier cells as readonly on existing rows", () => {
+    expect(isClickHouseExistingRowReadonlyColumn("clickhouse", "ID", ["id"])).toBe(true);
+    expect(isClickHouseExistingRowReadonlyColumn("clickhouse", "name", ["id"])).toBe(false);
+    expect(isClickHouseExistingRowReadonlyColumn("clickhouse", "event_date", ["id"], [{ ...column("event_date"), extra: "partition_key" }])).toBe(true);
+    expect(isClickHouseExistingRowReadonlyColumn("postgres", "id", ["id"])).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/tableImport.spec.ts b/apps/desktop/src/lib/__tests__/table/tableImport.spec.ts
new file mode 100644
index 0000000..6887130
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/tableImport.spec.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import { autoMapImportColumns, nextTableImportWizardStep, previousTableImportWizardStep, requiredImportTargetColumns, suggestImportTargetDataTypes, validateImportMappings } from "@/lib/table/tableImport";
+
+describe("tableImport", () => {
+  it("auto maps exact and normalized column names", () => {
+    expect(autoMapImportColumns(["id", "user name", "ignored"], ["id", "user_name"])).toEqual({
+      id: "id",
+      "user name": "user_name",
+      ignored: "",
+    });
+  });
+
+  it("rejects empty mappings and duplicate target columns", () => {
+    expect(validateImportMappings([])).toEqual({
+      valid: false,
+      errors: ["No columns mapped for import"],
+      duplicateTargets: [],
+    });
+
+    const result = validateImportMappings([
+      { sourceColumn: "a", targetColumn: "name" },
+      { sourceColumn: "b", targetColumn: "NAME" },
+    ]);
+
+    expect(result.valid).toBe(false);
+    expect(result.duplicateTargets).toEqual(["NAME"]);
+    expect(result.errors[0]).toContain("Target column mapped more than once");
+  });
+
+  it("rejects empty create-table data types", () => {
+    const result = validateImportMappings([{ sourceColumn: "code", targetColumn: "code", targetDataType: "" }]);
+
+    expect(result.valid).toBe(false);
+    expect(result.errors).toEqual(["Target data type cannot be empty: code"]);
+  });
+
+  it("detects unmapped required target columns", () => {
+    expect(
+      requiredImportTargetColumns(
+        [
+          { name: "id", is_nullable: false, column_default: null, extra: "auto_increment" },
+          { name: "name", is_nullable: false, column_default: null },
+          { name: "created_at", is_nullable: false, column_default: "CURRENT_TIMESTAMP" },
+        ],
+        ["id"],
+      ),
+    ).toEqual(["name"]);
+  });
+
+  it("moves through wizard steps with bounds", () => {
+    expect(nextTableImportWizardStep("source")).toBe("options");
+    expect(nextTableImportWizardStep("execution")).toBe("execution");
+    expect(previousTableImportWizardStep("review")).toBe("mapping");
+    expect(previousTableImportWizardStep("source")).toBe("source");
+  });
+
+  it("suggests create-table data types from preview rows", () => {
+    expect(
+      suggestImportTargetDataTypes(
+        ["id", "code", "amount", "created_at"],
+        [
+          ["1001", "00123", "12.5", "2026-07-07 08:15:00"],
+          ["1002", "00456", "13.75", "2026-07-07 09:15:00"],
+        ],
+        "mysql",
+      ),
+    ).toEqual({
+      id: "BIGINT",
+      code: "TEXT",
+      amount: "DOUBLE",
+      created_at: "DATETIME",
+    });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/tableSelectSql.spec.ts b/apps/desktop/src/lib/__tests__/table/tableSelectSql.spec.ts
new file mode 100644
index 0000000..e3b82f1
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/tableSelectSql.spec.ts
@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { qualifiedTableName, quoteTableIdentifier } from "@/lib/table/tableSelectSql";
+
+describe("qualifiedTableName — Doris/StarRocks multi-catalog", () => {
+  it("prefixes external catalog for Doris (no schema)", () => {
+    expect(qualifiedTableName({ databaseType: "doris", catalog: "iceberg_catalog", tableName: "orders" })).toBe("`iceberg_catalog`.`orders`");
+  });
+
+  it("prefixes external catalog for Doris (with schema)", () => {
+    expect(qualifiedTableName({ databaseType: "doris", catalog: "iceberg_catalog", schema: "sales", tableName: "orders" })).toBe("`iceberg_catalog`.`sales`.`orders`");
+  });
+
+  it("prefixes external catalog for StarRocks", () => {
+    expect(qualifiedTableName({ databaseType: "starrocks", catalog: "hive_catalog", tableName: "orders" })).toBe("`hive_catalog`.`orders`");
+  });
+
+  it("treats the internal catalog as no catalog", () => {
+    expect(qualifiedTableName({ databaseType: "doris", catalog: "internal", tableName: "orders" })).toBe("`orders`");
+  });
+
+  it("omits the catalog for non-Doris engines", () => {
+    // MySQL has no 3-part catalog naming; the catalog must be ignored.
+    expect(qualifiedTableName({ databaseType: "mysql", catalog: "iceberg_catalog", tableName: "orders" })).toBe("`orders`");
+  });
+
+  it("escapes embedded backticks in catalog and table identifiers", () => {
+    expect(qualifiedTableName({ databaseType: "doris", catalog: "a`b", schema: "c`d", tableName: "e`f" })).toBe("`a``b`.`c``d`.`e``f`");
+  });
+});
+
+describe("quoteTableIdentifier", () => {
+  it("backtick-quotes mysql identifiers", () => {
+    expect(quoteTableIdentifier("mysql", "orders")).toBe("`orders`");
+  });
+
+  it("bracket-quotes sqlserver identifiers", () => {
+    expect(quoteTableIdentifier("sqlserver", "orders")).toBe("[orders]");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/tableStructureCapabilities.spec.ts b/apps/desktop/src/lib/__tests__/table/tableStructureCapabilities.spec.ts
new file mode 100644
index 0000000..a0867c9
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/tableStructureCapabilities.spec.ts
@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { getTableStructureCapabilities, hasLocalTableColumnOrderChange, isPhysicalTableColumnOrderChange, supportsLocalTableColumnReorder } from "@/lib/table/tableStructureCapabilities";
+
+describe("tableStructureCapabilities", () => {
+  it("uses table rebuilds only for native SQLite connections", () => {
+    expect(getTableStructureCapabilities("sqlite", "sqlite")).toMatchObject({
+      alterStrategy: "sqlite-rebuild",
+      alterExistingColumn: true,
+      alterType: true,
+    });
+
+    for (const [databaseType, connectionType] of [
+      ["rqlite", "rqlite"],
+      ["turso", "turso"],
+      ["sqlite", "jdbc"],
+      ["sqlite", undefined],
+    ] as const) {
+      expect(getTableStructureCapabilities(databaseType, connectionType)).toMatchObject({
+        alterStrategy: "none",
+        alterExistingColumn: false,
+        alterType: false,
+      });
+    }
+  });
+
+  it("marks databases with native ALTER COLUMN support as direct", () => {
+    expect(getTableStructureCapabilities("mysql", "mysql").alterStrategy).toBe("direct");
+    expect(getTableStructureCapabilities("postgres", "postgres").alterStrategy).toBe("direct");
+  });
+
+  it("uses local-only column reordering for editable databases without physical reorder support", () => {
+    for (const databaseType of ["sqlserver", "postgres", "sqlite", "oracle", "dameng", "duckdb", "informix"] as const) {
+      expect(supportsLocalTableColumnReorder(databaseType, databaseType)).toBe(true);
+    }
+
+    for (const databaseType of ["mysql", "gbase", "clickhouse"] as const) {
+      expect(supportsLocalTableColumnReorder(databaseType, databaseType)).toBe(false);
+    }
+    expect(supportsLocalTableColumnReorder("influxdb", "influxdb")).toBe(false);
+  });
+
+  it("does not treat local-only reordering as a database structure change", () => {
+    expect(isPhysicalTableColumnOrderChange("sqlserver", "sqlserver", 0, 2)).toBe(false);
+    expect(isPhysicalTableColumnOrderChange("postgres", "postgres", 0, 2)).toBe(false);
+    expect(isPhysicalTableColumnOrderChange("mysql", "mysql", 0, 2)).toBe(true);
+  });
+
+  it("detects local order changes including newly added columns", () => {
+    const first = { original: {}, originalPosition: 0 };
+    const second = { original: {}, originalPosition: 1 };
+    const added = {};
+
+    expect(hasLocalTableColumnOrderChange([first, second, added])).toBe(false);
+    expect(hasLocalTableColumnOrderChange([first, added, second])).toBe(true);
+    expect(hasLocalTableColumnOrderChange([second, first, added])).toBe(true);
+  });
+
+  it("ignores dropped columns when comparing local order", () => {
+    const first = { original: {}, originalPosition: 0 };
+    const dropped = { original: {}, originalPosition: 1, markedForDrop: true };
+    const third = { original: {}, originalPosition: 2 };
+
+    expect(hasLocalTableColumnOrderChange([first, dropped, third])).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/tableStructureEditorState.spec.ts b/apps/desktop/src/lib/__tests__/table/tableStructureEditorState.spec.ts
new file mode 100644
index 0000000..87bd1e9
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/tableStructureEditorState.spec.ts
@@ -0,0 +1,247 @@
+import { describe, expect, it } from "vitest";
+import {
+  combineDataTypeForDatabase,
+  createColumnDrafts,
+  dataTypeLengthInputValue,
+  DATA_TYPE_OPTIONS,
+  defaultNewColumnDataType,
+  getDefaultLengthForType,
+  hasExistingColumnTypeChange,
+  isDataTypeLengthDisabled,
+  isDamengIdentityCompatibleDataType,
+  isMysqlCharacterDataType,
+  isMysqlEnumDataType,
+  isSqlServerIdentityCompatibleDataType,
+  mysqlEnumDataType,
+  rehydrateColumnDraftsFromMetadata,
+  splitDataType,
+} from "@/lib/table/tableStructureEditorState";
+
+describe("tableStructureEditorState", () => {
+  it("keeps mysql unsigned attributes in the editable base type", () => {
+    expect(splitDataType("int(11) unsigned")).toEqual({ baseType: "int unsigned", params: "11" });
+    expect(splitDataType("bigint(20) unsigned zerofill")).toEqual({
+      baseType: "bigint unsigned zerofill",
+      params: "20",
+    });
+  });
+
+  it("combines mysql unsigned type choices with the length field", () => {
+    expect(combineDataTypeForDatabase("mysql", "int unsigned", "11")).toBe("int(11) unsigned");
+    expect(combineDataTypeForDatabase("mysql", "bigint unsigned zerofill", "20")).toBe("bigint(20) unsigned zerofill");
+  });
+
+  it("does not expose mysql enum or set values as editable length", () => {
+    const dataType = "enum('purchase_in','sale_out','return_in','adjustment_out','transfer_in','transfer_out')";
+
+    expect(splitDataType(dataType)).toEqual({
+      baseType: "enum",
+      params: "'purchase_in','sale_out','return_in','adjustment_out','transfer_in','transfer_out'",
+    });
+    expect(isDataTypeLengthDisabled("mysql", "enum")).toBe(true);
+    expect(isDataTypeLengthDisabled("mysql", "set")).toBe(true);
+    expect(dataTypeLengthInputValue("mysql", dataType)).toBe("");
+    expect(dataTypeLengthInputValue("mysql", "set('manual','auto')")).toBe("");
+  });
+
+  it("hydrates mysql enum values into an editable canonical type", () => {
+    const [draft] = createColumnDrafts(
+      [
+        {
+          name: "status",
+          data_type: "enum",
+          enum_values: ["", "pending", "it's", "path\\name"],
+          is_nullable: false,
+          column_default: "'pending'",
+          is_primary_key: false,
+          extra: null,
+        },
+      ],
+      "mysql",
+    );
+
+    expect(draft?.enumValues).toEqual(["", "pending", "it's", "path\\name"]);
+    expect(draft?.dataType).toBe("enum('','pending','it''s','path\\\\name')");
+    expect(draft?.original?.data_type).toBe(draft?.dataType);
+  });
+
+  it("builds mysql enum types without confusing values with length", () => {
+    expect(isMysqlEnumDataType("mysql", "ENUM('a','b')")).toBe(true);
+    expect(isMysqlEnumDataType("postgres", "enum")).toBe(false);
+    expect(mysqlEnumDataType(["", "a'b", "a\\b"])).toBe("enum('','a''b','a\\\\b')");
+  });
+
+  it("rehydrates enum values into drafts saved before enum editing existed", () => {
+    const metadata = {
+      name: "status",
+      data_type: "enum",
+      enum_values: ["pending", "active"],
+      is_nullable: false,
+      column_default: "'pending'",
+      is_primary_key: false,
+      extra: null,
+    };
+    const [legacyDraft] = createColumnDrafts([metadata], "mysql");
+    legacyDraft!.dataType = "enum";
+    legacyDraft!.enumValues = undefined;
+    legacyDraft!.original = { ...metadata };
+
+    const [rehydrated] = rehydrateColumnDraftsFromMetadata([legacyDraft!], [metadata], "mysql");
+
+    expect(rehydrated?.enumValues).toEqual(["pending", "active"]);
+    expect(rehydrated?.dataType).toBe("enum('pending','active')");
+    expect(rehydrated?.original?.data_type).toBe("enum('pending','active')");
+  });
+
+  it("does not expose Oracle-like integer display widths as editable length", () => {
+    expect(isDataTypeLengthDisabled("dameng", "integer")).toBe(true);
+    expect(dataTypeLengthInputValue("dameng", "integer(11)")).toBe("");
+    expect(combineDataTypeForDatabase("dameng", "integer", "11")).toBe("integer");
+    expect(combineDataTypeForDatabase("oracle", "number", "10,0")).toBe("number(10,0)");
+    expect(combineDataTypeForDatabase("mysql", "integer", "11")).toBe("integer(11)");
+  });
+
+  it("does not add MySQL display lengths when choosing SQLite-family types", () => {
+    for (const databaseType of ["sqlite", "rqlite", "turso"] as const) {
+      expect(getDefaultLengthForType(databaseType, "integer")).toBe("");
+      expect(getDefaultLengthForType(databaseType, "real")).toBe("");
+      expect(combineDataTypeForDatabase(databaseType, "integer", getDefaultLengthForType(databaseType, "integer"))).toBe("integer");
+    }
+
+    expect(getDefaultLengthForType("mysql", "integer")).toBe("11");
+  });
+
+  it("uses MySQL 8-safe defaults only when the native MySQL profile is known", () => {
+    const mysql8Defaults = { omitMysqlDeprecatedDefaults: true };
+
+    expect(getDefaultLengthForType("mysql", "int", mysql8Defaults)).toBe("");
+    expect(getDefaultLengthForType("mysql", "bigint unsigned", mysql8Defaults)).toBe("");
+    expect(getDefaultLengthForType("mysql", "float", mysql8Defaults)).toBe("");
+    expect(getDefaultLengthForType("mysql", "double", mysql8Defaults)).toBe("");
+    expect(combineDataTypeForDatabase("mysql", "int", getDefaultLengthForType("mysql", "int", mysql8Defaults))).toBe("int");
+    expect(combineDataTypeForDatabase("mysql", "float", getDefaultLengthForType("mysql", "float", mysql8Defaults))).toBe("float");
+    expect(getDefaultLengthForType("mysql", "decimal", mysql8Defaults)).toBe("10,0");
+
+    // A compatibility profile cannot be version-identified, so its existing behavior is retained.
+    expect(getDefaultLengthForType("mysql", "int")).toBe("11");
+    expect(getDefaultLengthForType("mysql", "float")).toBe("10,2");
+  });
+
+  it("uses TEXT for a new native SQLite column without changing compatible defaults", () => {
+    expect(DATA_TYPE_OPTIONS.sqlite).toContain("text");
+    expect(defaultNewColumnDataType("sqlite")).toBe("text");
+    expect(defaultNewColumnDataType("rqlite")).toBe("varchar(255)");
+    expect(defaultNewColumnDataType("turso")).toBe("varchar(255)");
+    expect(defaultNewColumnDataType("mysql")).toBe("varchar(255)");
+  });
+
+  it("requires a SQLite rebuild only for a retained existing column type change", () => {
+    const [column] = createColumnDrafts(
+      [
+        {
+          name: "status",
+          data_type: "integer",
+          is_nullable: false,
+          column_default: null,
+          is_primary_key: false,
+          extra: null,
+        },
+      ],
+      "sqlite",
+    );
+
+    expect(hasExistingColumnTypeChange([column])).toBe(false);
+    column.name = "state";
+    expect(hasExistingColumnTypeChange([column])).toBe(false);
+    column.dataType = "text";
+    expect(hasExistingColumnTypeChange([column])).toBe(true);
+    column.markedForDrop = true;
+    expect(hasExistingColumnTypeChange([column])).toBe(false);
+  });
+
+  it("strips SQL Server metadata parentheses from editable defaults", () => {
+    const drafts = createColumnDrafts(
+      [
+        {
+          name: "name",
+          data_type: "nvarchar(100)",
+          is_nullable: true,
+          column_default: "('')",
+          is_primary_key: false,
+          extra: null,
+        },
+        {
+          name: "active",
+          data_type: "bit",
+          is_nullable: false,
+          column_default: "((1))",
+          is_primary_key: false,
+          extra: null,
+        },
+        {
+          name: "created_at",
+          data_type: "datetime2(7)",
+          is_nullable: false,
+          column_default: "((sysdatetime()))",
+          is_primary_key: false,
+          extra: null,
+        },
+        {
+          name: "label",
+          data_type: "nvarchar(100)",
+          is_nullable: true,
+          column_default: "('prefix (internal)')",
+          is_primary_key: false,
+          extra: null,
+        },
+      ],
+      "sqlserver",
+    );
+
+    expect(drafts.map((draft) => draft.defaultValue)).toEqual(["''", "1", "sysdatetime()", "'prefix (internal)'"]);
+    expect(drafts.map((draft) => draft.original?.column_default)).toEqual(["''", "1", "sysdatetime()", "'prefix (internal)'"]);
+  });
+
+  it("limits SQL Server identity columns to supported data types", () => {
+    expect(isSqlServerIdentityCompatibleDataType("int")).toBe(true);
+    expect(isSqlServerIdentityCompatibleDataType("bigint")).toBe(true);
+    expect(isSqlServerIdentityCompatibleDataType("numeric(18, 0)")).toBe(true);
+    expect(isSqlServerIdentityCompatibleDataType("decimal(10)")).toBe(true);
+    expect(isSqlServerIdentityCompatibleDataType("varchar(255)")).toBe(false);
+    expect(isSqlServerIdentityCompatibleDataType("numeric(18, 2)")).toBe(false);
+  });
+
+  it("limits Dameng identity columns to supported data types", () => {
+    expect(isDamengIdentityCompatibleDataType("int")).toBe(true);
+    expect(isDamengIdentityCompatibleDataType("integer")).toBe(true);
+    expect(isDamengIdentityCompatibleDataType("bigint")).toBe(true);
+    expect(isDamengIdentityCompatibleDataType("number(18, 0)")).toBe(true);
+    expect(isDamengIdentityCompatibleDataType("decimal(10)")).toBe(true);
+    expect(isDamengIdentityCompatibleDataType("varchar(255)")).toBe(false);
+    expect(isDamengIdentityCompatibleDataType("number(18, 2)")).toBe(false);
+  });
+
+  it("identifies MySQL character data types that accept charset/collation", () => {
+    expect(isMysqlCharacterDataType("char(1)")).toBe(true);
+    expect(isMysqlCharacterDataType("varchar(255)")).toBe(true);
+    expect(isMysqlCharacterDataType("tinytext")).toBe(true);
+    expect(isMysqlCharacterDataType("text")).toBe(true);
+    expect(isMysqlCharacterDataType("mediumtext")).toBe(true);
+    expect(isMysqlCharacterDataType("longtext")).toBe(true);
+    expect(isMysqlCharacterDataType("enum('a','b')")).toBe(true);
+    expect(isMysqlCharacterDataType("set('x','y')")).toBe(true);
+    expect(isMysqlCharacterDataType("int")).toBe(false);
+    expect(isMysqlCharacterDataType("bigint(20) unsigned")).toBe(false);
+    expect(isMysqlCharacterDataType("decimal(10,2)")).toBe(false);
+    expect(isMysqlCharacterDataType("float")).toBe(false);
+    expect(isMysqlCharacterDataType("double")).toBe(false);
+    expect(isMysqlCharacterDataType("date")).toBe(false);
+    expect(isMysqlCharacterDataType("datetime")).toBe(false);
+    expect(isMysqlCharacterDataType("timestamp")).toBe(false);
+    expect(isMysqlCharacterDataType("json")).toBe(false);
+    expect(isMysqlCharacterDataType("binary(16)")).toBe(false);
+    expect(isMysqlCharacterDataType("varbinary(255)")).toBe(false);
+    expect(isMysqlCharacterDataType("blob")).toBe(false);
+    expect(isMysqlCharacterDataType("geometry")).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/table/tableTree.spec.ts b/apps/desktop/src/lib/__tests__/table/tableTree.spec.ts
new file mode 100644
index 0000000..8fb947c
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/table/tableTree.spec.ts
@@ -0,0 +1,125 @@
+import { describe, expect, it } from "vitest";
+import { appendTableTreeLoadMoreNode, buildSimpleObjectTreeNodes, buildTableTreeNodes, mergeTableTreePageChildren, tablePartitionGroups, withoutTableTreeLoadMoreNodes } from "@/lib/table/tableTree";
+import type { ObjectInfo, TableInfo, TreeNode } from "@/types/database";
+
+const context = {
+  nodeId: "connection:db",
+  connectionId: "connection",
+  database: "db",
+};
+
+describe("PostgreSQL overloaded routines", () => {
+  it("keeps routines with the same name distinct by identity arguments", () => {
+    const objects: ObjectInfo[] = [
+      { name: "calc", object_type: "FUNCTION", schema: "public", signature: "integer" },
+      { name: "calc", object_type: "FUNCTION", schema: "public", signature: "integer, integer" },
+      { name: "calc", object_type: "FUNCTION", schema: "public", signature: "numeric" },
+    ];
+
+    const nodes = buildSimpleObjectTreeNodes({ ...context, schema: "public", objects });
+
+    expect(nodes.map((node) => ({ label: node.label, objectName: node.objectName, signature: node.signature }))).toEqual(
+      expect.arrayContaining([
+        { label: "calc(integer)", objectName: "calc", signature: "integer" },
+        { label: "calc(integer, integer)", objectName: "calc", signature: "integer, integer" },
+        { label: "calc(numeric)", objectName: "calc", signature: "numeric" },
+      ]),
+    );
+    expect(new Set(nodes.map((node) => node.id)).size).toBe(3);
+  });
+});
+
+describe("TDengine table hierarchy", () => {
+  it("groups child tables under their supertable and keeps ordinary tables flat", () => {
+    const tables: TableInfo[] = [
+      { name: "meters", table_type: "STABLE", comment: null },
+      { name: "device_b", table_type: "TABLE", comment: null, parent_name: "meters" },
+      { name: "standalone", table_type: "TABLE", comment: null },
+      { name: "device_a", table_type: "TABLE", comment: null, parent_name: "meters" },
+    ];
+
+    const nodes = buildTableTreeNodes({ ...context, tables });
+
+    expect(nodes.map((node) => node.label)).toEqual(["meters", "standalone"]);
+    expect(nodes[0].children).toHaveLength(1);
+    expect(nodes[0].children?.[0]).toMatchObject({
+      type: "group-partitions",
+      label: "tree.childTables",
+      objectCount: 2,
+      isExpanded: true,
+    });
+    expect(nodes[0].children?.[0].children?.map((node) => node.label)).toEqual(["device_a", "device_b"]);
+  });
+
+  it("attaches child tables loaded on later pages to the existing supertable", () => {
+    const firstPage = buildTableTreeNodes({
+      ...context,
+      tables: [{ name: "meters", table_type: "STABLE", comment: null }],
+    });
+    const secondPage = buildTableTreeNodes({
+      ...context,
+      tables: [{ name: "device_a", table_type: "TABLE", comment: null, parent_name: "meters" }],
+    });
+
+    const merged = mergeTableTreePageChildren(firstPage, secondPage, context.connectionId, context.database);
+
+    expect(merged).toHaveLength(1);
+    expect(merged[0].children?.[0]).toMatchObject({
+      type: "group-partitions",
+      label: "tree.childTables",
+      objectCount: 1,
+      isExpanded: true,
+    });
+    expect(merged[0].children?.[0].children?.[0].label).toBe("device_a");
+  });
+
+  it("keeps pagination inside the child table group across pages", () => {
+    const firstPage = buildTableTreeNodes({
+      ...context,
+      tables: [
+        { name: "meters", table_type: "STABLE", comment: null },
+        { name: "device_a", table_type: "TABLE", comment: null, parent_name: "meters" },
+      ],
+    });
+    const firstLoadMore: TreeNode = {
+      id: "load-more:1",
+      label: "tree.loadMore",
+      type: "load-more",
+      connectionId: context.connectionId,
+      database: context.database,
+      loadMore: { parentId: "connection:db:__tables", offset: 2, pageSize: 2 },
+    };
+
+    appendTableTreeLoadMoreNode(firstPage, firstLoadMore, { name: "meters" });
+
+    expect(firstPage.map((node) => node.type)).toEqual(["table"]);
+    expect(tablePartitionGroups(firstPage[0])[0].children?.map((node) => node.type)).toEqual(["table", "load-more"]);
+
+    const secondPage = buildTableTreeNodes({
+      ...context,
+      tables: [{ name: "device_b", table_type: "TABLE", comment: null, parent_name: "meters" }],
+    });
+    const withoutLoadMore = withoutTableTreeLoadMoreNodes(firstPage);
+    const merged = mergeTableTreePageChildren(withoutLoadMore, secondPage, context.connectionId, context.database);
+    const secondLoadMore = { ...firstLoadMore, id: "load-more:2", loadMore: { ...firstLoadMore.loadMore!, offset: 4 } };
+
+    appendTableTreeLoadMoreNode(merged, secondLoadMore, { name: "meters" });
+
+    expect(merged).toHaveLength(1);
+    expect(tablePartitionGroups(merged[0])[0]).toMatchObject({ objectCount: 2 });
+    expect(tablePartitionGroups(merged[0])[0].children?.map((node) => node.label)).toEqual(["device_a", "device_b", "tree.loadMore"]);
+  });
+
+  it("keeps the partition label for non-TDengine parent tables", () => {
+    const nodes = buildTableTreeNodes({
+      ...context,
+      schema: "public",
+      tables: [
+        { name: "orders", table_type: "PARTITIONED TABLE", comment: null },
+        { name: "orders_2026", table_type: "TABLE", comment: null, parent_schema: "public", parent_name: "orders" },
+      ],
+    });
+
+    expect(nodes[0].children?.[0]).toMatchObject({ label: "tree.partitions", isExpanded: false });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/tabs/tabPresentation.spec.ts b/apps/desktop/src/lib/__tests__/tabs/tabPresentation.spec.ts
new file mode 100644
index 0000000..dec05ad
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/tabs/tabPresentation.spec.ts
@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import { queryResultBaseSql, queryResultExecutionSql, tabularResultItems } from "@/lib/tabs/tabPresentation";
+import type { QueryTab } from "@/types/database";
+
+function queryTab(overrides: Partial<QueryTab>): QueryTab {
+  return {
+    id: "tab-1",
+    title: "SQL",
+    connectionId: "conn-1",
+    database: "db",
+    sql: "SELECT * FROM dbo.first;\nSELECT * FROM dbo.second;",
+    originalSql: "",
+    isExecuting: false,
+    isCancelling: false,
+    isExplaining: false,
+    mode: "query",
+    ...overrides,
+  } as QueryTab;
+}
+
+describe("query result SQL selection", () => {
+  it("uses the active result source statement for multi-result query actions", () => {
+    const tab = queryTab({
+      resultBaseSql: "SELECT * FROM dbo.first;\nSELECT * FROM dbo.second;",
+      result: {
+        columns: ["id"],
+        rows: [[1]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+        sourceStatement: "SELECT * FROM dbo.second",
+      },
+    });
+
+    expect(queryResultBaseSql(tab)).toBe("SELECT * FROM dbo.second");
+    expect(queryResultExecutionSql(tab)).toBe("SELECT * FROM dbo.second");
+  });
+
+  it("prefers the sorted SQL when the active result is sorted", () => {
+    const tab = queryTab({
+      resultSortedSql: "SELECT * FROM dbo.second ORDER BY id DESC",
+      result: {
+        columns: ["id"],
+        rows: [[2]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+        sourceStatement: "SELECT * FROM dbo.second",
+      },
+    });
+
+    expect(queryResultBaseSql(tab)).toBe("SELECT * FROM dbo.second");
+    expect(queryResultExecutionSql(tab)).toBe("SELECT * FROM dbo.second ORDER BY id DESC");
+  });
+});
+
+describe("query result labels", () => {
+  it("uses source labels while keeping the full statement as the title", () => {
+    const [item] = tabularResultItems([
+      {
+        columns: ["id"],
+        rows: [[1]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+        sourceLabel: "app.users",
+        sourceStatement: "SELECT * FROM users",
+      },
+    ]);
+
+    expect(item?.label).toBe("app.users");
+    expect(item?.title).toBe("SELECT * FROM users");
+  });
+
+  it("does not expose SQL text as a visible fallback label", () => {
+    const [item] = tabularResultItems([
+      {
+        columns: ["value"],
+        rows: [[1]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+        sourceStatement: "SELECT 1",
+      },
+    ]);
+
+    expect(item?.label).toBeUndefined();
+    expect(item?.title).toBe("SELECT 1");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/zookeeper/zookeeperApiContract.spec.ts b/apps/desktop/src/lib/__tests__/zookeeper/zookeeperApiContract.spec.ts
new file mode 100644
index 0000000..b0907c9
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/zookeeper/zookeeperApiContract.spec.ts
@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { zookeeperDelete, zookeeperGet, zookeeperListPrefix, zookeeperPut, type KvListPrefixOptions, type KvPutOptions, type KvPutResponse } from "@/lib/backend/api";
+import type { DatabaseType } from "@/types/database";
+
+describe("zookeeper frontend API contract", () => {
+  it("exposes the zookeeper database type and KV put options", () => {
+    const dbType: DatabaseType = "zookeeper";
+    const options: KvPutOptions = {
+      writeMode: "create",
+      createMode: "ephemeral_sequential",
+    };
+    const response: KvPutResponse = {
+      key: "/sessions/member-0000000001",
+      createdKey: "/sessions/member-0000000001",
+    };
+    const listOptions: KvListPrefixOptions = {
+      recursive: false,
+    };
+
+    expect(dbType).toBe("zookeeper");
+    expect(options.createMode).toBe("ephemeral_sequential");
+    expect(listOptions.recursive).toBe(false);
+    expect(response.createdKey).toBe(response.key);
+    expect(typeof zookeeperListPrefix).toBe("function");
+    expect(typeof zookeeperGet).toBe("function");
+    expect(typeof zookeeperPut).toBe("function");
+    expect(typeof zookeeperDelete).toBe("function");
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/zookeeper/zookeeperConnection.spec.ts b/apps/desktop/src/lib/__tests__/zookeeper/zookeeperConnection.spec.ts
new file mode 100644
index 0000000..3f0e24b
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/zookeeper/zookeeperConnection.spec.ts
@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { firstZooKeeperEndpoint, normalizeZooKeeperConnectString } from "@/lib/zookeeper/zookeeperConnection";
+
+describe("zookeeperConnection", () => {
+  it("normalizes comma, semicolon, and newline separated connect strings", () => {
+    expect(normalizeZooKeeperConnectString(" zk-1:2181, zk-2:2182\nzk-3 ; ")).toBe("zk-1:2181,zk-2:2182,zk-3");
+  });
+
+  it("extracts the first host and port from a connect string", () => {
+    expect(firstZooKeeperEndpoint("zk-1:2182,zk-2:2181")).toEqual({ host: "zk-1", port: 2182 });
+  });
+
+  it("strips a zookeeper URL scheme when normalizing connect strings", () => {
+    expect(normalizeZooKeeperConnectString("zookeeper://zk-main:2181")).toBe("zk-main:2181");
+  });
+
+  it("uses the ZooKeeper default port when the first endpoint omits a port", () => {
+    expect(firstZooKeeperEndpoint("zk-main")).toEqual({ host: "zk-main", port: 2181 });
+  });
+
+  it("parses bracketed IPv6 endpoints", () => {
+    expect(firstZooKeeperEndpoint("[::1]:2281,zk-2:2181")).toEqual({ host: "::1", port: 2281 });
+  });
+});
diff --git a/apps/desktop/src/lib/__tests__/zookeeper/zookeeperLazyKeyTree.spec.ts b/apps/desktop/src/lib/__tests__/zookeeper/zookeeperLazyKeyTree.spec.ts
new file mode 100644
index 0000000..f259b75
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/zookeeper/zookeeperLazyKeyTree.spec.ts
@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import { createLazyKvKeyTreeState, createZooKeeperChildPathDraft, flattenLazyKvKeyTree, replaceLazyKvChildren, resetLazyKvKeyTree } from "@/lib/zookeeper/zookeeperLazyKeyTree";
+
+describe("zookeeper lazy key tree", () => {
+  it("stores only the current path direct children on reset", () => {
+    const state = createLazyKvKeyTreeState();
+
+    resetLazyKvKeyTree(state, "/app");
+    replaceLazyKvChildren(
+      state,
+      null,
+      [
+        { key: "/app/a", numChildren: 0, valueSize: 1 },
+        { key: "/app/folder", numChildren: 2, valueSize: 0 },
+      ],
+      null,
+    );
+
+    expect(state.rootPath).toBe("/app");
+    expect(state.roots.map((node) => node.key)).toEqual(["/app/a", "/app/folder"]);
+    expect(flattenLazyKvKeyTree(state, new Set()).map((row) => `${row.depth}:${row.node.label}`)).toEqual(["0:a", "0:folder"]);
+  });
+
+  it("does not expose grandchildren until their parent is loaded", () => {
+    const state = createLazyKvKeyTreeState("/");
+    replaceLazyKvChildren(state, null, [{ key: "/app", numChildren: 1 }], null);
+
+    expect(flattenLazyKvKeyTree(state, new Set(["lazy:/app"])).map((row) => row.node.key)).toEqual(["/app"]);
+
+    replaceLazyKvChildren(state, "/app", [{ key: "/app/name", numChildren: 0 }], null);
+
+    expect(flattenLazyKvKeyTree(state, new Set(["lazy:/app"])).map((row) => row.node.key)).toEqual(["/app", "/app/name"]);
+  });
+
+  it("keeps child pagination continuation on the owning node", () => {
+    const state = createLazyKvKeyTreeState("/");
+    replaceLazyKvChildren(state, null, [{ key: "/app", numChildren: 3 }], "root-next");
+    replaceLazyKvChildren(state, "/app", [{ key: "/app/a", numChildren: 0 }], "child-next");
+
+    const app = state.nodeByKey.get("/app");
+
+    expect(state.rootContinuation).toBe("root-next");
+    expect(app?.continuation).toBe("child-next");
+  });
+
+  it("does not prefill root as a creatable znode path", () => {
+    expect(createZooKeeperChildPathDraft("")).toBe("");
+    expect(createZooKeeperChildPathDraft("/")).toBe("");
+    expect(createZooKeeperChildPathDraft("/app")).toBe("/app/");
+    expect(createZooKeeperChildPathDraft("app/")).toBe("/app/");
+  });
+});
diff --git a/apps/desktop/src/lib/ai/__tests__/aiActions.spec.ts b/apps/desktop/src/lib/ai/__tests__/aiActions.spec.ts
new file mode 100644
index 0000000..a776993
--- /dev/null
+++ b/apps/desktop/src/lib/ai/__tests__/aiActions.spec.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { ASK_ACTIONS, AGENT_ACTIONS, defaultActionForMode, isValidActionForMode } from "@/lib/ai/ai";
+
+describe("AI action mode mapping", () => {
+  describe("defaultActionForMode", () => {
+    it("defaults Ask to general", () => {
+      expect(defaultActionForMode("ask")).toBe("general");
+    });
+
+    it("defaults Agent to general", () => {
+      expect(defaultActionForMode("agent")).toBe("general");
+    });
+  });
+
+  describe("isValidActionForMode", () => {
+    it("accepts generate in both modes (shared SQL-only action)", () => {
+      expect(isValidActionForMode("generate", "ask")).toBe(true);
+      expect(isValidActionForMode("generate", "agent")).toBe(true);
+    });
+
+    it("accepts every Ask action in Ask mode", () => {
+      for (const action of ASK_ACTIONS) {
+        expect(isValidActionForMode(action, "ask")).toBe(true);
+      }
+    });
+
+    it("accepts every Agent action in Agent mode", () => {
+      for (const action of AGENT_ACTIONS) {
+        expect(isValidActionForMode(action, "agent")).toBe(true);
+      }
+    });
+
+    it("rejects Ask-only actions in Agent mode", () => {
+      // explain/optimize/fix/convert/sampleData are SQL-text operations and must not
+      // appear in the Agent (task-oriented) menu.
+      for (const action of ["explain", "optimize", "fix", "convert", "sampleData"] as const) {
+        expect(isValidActionForMode(action, "agent")).toBe(false);
+      }
+    });
+
+    it("rejects Agent-only actions in Ask mode", () => {
+      for (const action of ["query", "exploreSchema", "executeAndExplain"] as const) {
+        expect(isValidActionForMode(action, "ask")).toBe(false);
+      }
+    });
+  });
+
+  describe("action sets", () => {
+    it("Ask menu starts with general, then SQL-producing actions", () => {
+      expect(ASK_ACTIONS).toEqual(["general", "generate", "explain", "optimize", "fix", "convert", "sampleData"]);
+    });
+
+    it("Agent menu starts with general, then task-oriented actions", () => {
+      expect(AGENT_ACTIONS[0]).toBe("general");
+      // generate is shared so users can still request SQL-only output.
+      expect(AGENT_ACTIONS).toContain("generate");
+      expect(AGENT_ACTIONS).toEqual(["general", "query", "exploreSchema", "executeAndExplain", "generate"]);
+    });
+  });
+});
diff --git a/apps/desktop/src/lib/ai/__tests__/aiProductionSafety.spec.ts b/apps/desktop/src/lib/ai/__tests__/aiProductionSafety.spec.ts
new file mode 100644
index 0000000..6b4db62
--- /dev/null
+++ b/apps/desktop/src/lib/ai/__tests__/aiProductionSafety.spec.ts
@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { buildAiAgentPlan } from "../aiAgentPlan";
+import { classifyAiSqlExecution } from "../aiSqlExecutionPolicy";
+import type { ConnectionConfig } from "@/types/database";
+
+const productionConnection: ConnectionConfig = {
+  id: "conn-1",
+  name: "Operations",
+  db_type: "mysql",
+  host: "db.internal",
+  port: 3306,
+  username: "readonly",
+  password: "",
+  production_databases: ["prod_app"],
+};
+
+describe("AI production SQL policy", () => {
+  it("requires confirmation for a scoped production write", () => {
+    expect(classifyAiSqlExecution("UPDATE users SET active = 1 WHERE id = 7", productionConnection, "prod_app")).toMatchObject({
+      action: "confirm",
+      environment: "production",
+      reasons: ["production_write"],
+    });
+  });
+
+  it("hands production write SQL back to the operator instead of auto-executing", () => {
+    const plan = buildAiAgentPlan({
+      mode: "agent",
+      action: "generate",
+      instruction: "execute the update",
+      assistantContent: "```sql\nUPDATE users SET active = 1 WHERE id = 7\n```",
+      connection: productionConnection,
+      database: "prod_app",
+    });
+
+    expect(plan.executableSql).toBeUndefined();
+    expect(plan.handoffSql).toContain("UPDATE users");
+    expect(plan.steps).toContainEqual({ kind: "execute_sql", status: "skipped", reason: "requires_confirmation" });
+  });
+});
diff --git a/apps/desktop/src/lib/ai/ai.ts b/apps/desktop/src/lib/ai/ai.ts
new file mode 100644
index 0000000..a5b2f1c
--- /dev/null
+++ b/apps/desktop/src/lib/ai/ai.ts
@@ -0,0 +1,613 @@
+import type { AiConfig } from "@/stores/settingsStore";
+import { uuid } from "@/lib/common/utils";
+import type { ColumnInfo, ConnectionConfig, DatabaseType, ForeignKeyInfo, IndexInfo, QueryResult, QueryTab } from "@/types/database";
+import * as api from "@/lib/backend/api";
+import { currentLocale, type Locale } from "@/i18n";
+import { aiTableMentionKey, type AiTableMention } from "@/lib/ai/aiTableMentions";
+import { aiSkillForAction } from "@/lib/ai/aiSkills";
+import { isSchemaAware } from "@/lib/database/databaseCapabilities";
+import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+
+import type { AgentEvent } from "@/lib/backend/tauri";
+
+const VECTOR_DB_TYPES: ReadonlySet<DatabaseType> = new Set([
+  "qdrant",
+  "milvus",
+  "weaviate",
+  "chromadb",
+  // If modifying this, also update is_vector_db() in crates/dbx-core/src/agent_tools.rs.
+]);
+
+export function isVectorDbType(dbType: DatabaseType): boolean {
+  return VECTOR_DB_TYPES.has(dbType);
+}
+
+function dbLabel(dbType: DatabaseType): string {
+  const labels: Partial<Record<DatabaseType, string>> = {
+    qdrant: "Qdrant",
+    milvus: "Milvus",
+    weaviate: "Weaviate",
+    chromadb: "ChromaDB",
+  };
+  return labels[dbType] || dbType;
+}
+
+export type AiAction = "general" | "generate" | "explain" | "optimize" | "fix" | "convert" | "sampleData" | "query" | "exploreSchema" | "executeAndExplain";
+export type AiAssistantMode = "ask" | "agent";
+
+/** Actions shown in the Ask mode menu: SQL-producing, never auto-run. */
+export const ASK_ACTIONS: AiAction[] = ["general", "generate", "explain", "optimize", "fix", "convert", "sampleData"];
+
+/**
+ * Actions shown in the Agent mode menu: task-oriented, drive tool use.
+ * `generate` is shared with Ask so users can still request SQL-only output without execution.
+ */
+export const AGENT_ACTIONS: AiAction[] = ["general", "query", "exploreSchema", "executeAndExplain", "generate"];
+
+export function defaultActionForMode(_mode: AiAssistantMode): AiAction {
+  return "general";
+}
+
+export function isValidActionForMode(action: AiAction, mode: AiAssistantMode): boolean {
+  return (mode === "agent" ? AGENT_ACTIONS : ASK_ACTIONS).includes(action);
+}
+
+function isChineseLocale(locale: Locale): boolean {
+  return locale === "zh-CN" || locale === "zh-TW";
+}
+
+export interface AiSchemaTable {
+  schema?: string;
+  name: string;
+  tableType: string;
+  comment?: string | null;
+  columns: ColumnInfo[];
+  indexes?: IndexInfo[];
+  foreignKeys?: ForeignKeyInfo[];
+}
+
+export interface AiSqlFileContext {
+  id: string;
+  name: string;
+  sql: string;
+  truncated?: boolean;
+}
+
+export interface AiContext {
+  connectionId: string;
+  connectionName: string;
+  databaseType: DatabaseType;
+  database: string;
+  currentSql: string;
+  lastError?: string;
+  lastResultPreview?: string;
+  tables: AiSchemaTable[];
+  sqlFiles: AiSqlFileContext[];
+  schemaScope?: "focused_table" | "database";
+  truncated: boolean;
+}
+
+export interface AiRequestInput {
+  config: AiConfig;
+  action: AiAction;
+  mode?: AiAssistantMode;
+  instruction: string;
+  context: AiContext;
+  allowWriteSql?: boolean;
+}
+
+function buildAgentRequest(input: AiRequestInput, history?: api.AiMessage[]): { messages: api.AiMessage[]; systemPrompt: string; taskContract: api.AiTaskContract; maxTokens: number } {
+  const isZh = isChineseLocale(currentLocale());
+  const systemPrompt = buildSystemPrompt(input.action, input.context, input.mode);
+  const userPrompt = buildUserPrompt(input.action, input.context, input.instruction, isZh);
+  const taskContract: api.AiTaskContract = {
+    action: input.action,
+    mode: input.mode || "ask",
+    userRequest: input.instruction.trim(),
+  };
+
+  const messages: api.AiMessage[] = [...(history || []), { role: "user", content: userPrompt }];
+
+  const params = actionParams(input.action);
+  const maxTokens = input.config.enableThinking ? Math.max(params.maxTokens, 8192) : params.maxTokens;
+  return { messages, systemPrompt, taskContract, maxTokens };
+}
+
+export async function runAiAction(input: AiRequestInput, history?: api.AiMessage[]): Promise<string> {
+  const { messages, systemPrompt, taskContract, maxTokens } = buildAgentRequest(input, history);
+  return api.aiComplete({
+    config: input.config,
+    systemPrompt,
+    messages,
+    taskContract,
+    maxTokens,
+  });
+}
+
+export async function runAiStream(input: AiRequestInput, history: api.AiMessage[] | undefined, onDelta: (delta: string) => void, sessionId?: string, onReasoningDelta?: (delta: string) => void): Promise<void> {
+  const { messages, systemPrompt, taskContract, maxTokens } = buildAgentRequest(input, history);
+  const sid = sessionId || uuid();
+
+  await api.aiStream(
+    sid,
+    {
+      config: input.config,
+      systemPrompt,
+      messages,
+      taskContract,
+      maxTokens,
+    },
+    (chunk) => {
+      if (!chunk.done) {
+        if (chunk.reasoning_delta) onReasoningDelta?.(chunk.reasoning_delta);
+        if (chunk.delta) onDelta(chunk.delta);
+      }
+    },
+  );
+}
+
+export async function runAgentStream(input: AiRequestInput, history: api.AiMessage[] | undefined, onEvent: (event: AgentEvent) => void, sessionId?: string): Promise<string> {
+  const { messages, systemPrompt, taskContract, maxTokens } = buildAgentRequest(input, history);
+  const sid = sessionId || uuid();
+
+  return api.aiAgentStream(
+    sid,
+    {
+      config: input.config,
+      systemPrompt,
+      messages,
+      taskContract,
+      maxTokens,
+    },
+    input.context.connectionId,
+    input.context.database,
+    input.context.databaseType,
+    onEvent,
+    input.mode || "ask",
+    input.allowWriteSql || false,
+  );
+}
+
+export function buildUserPrompt(action: AiAction, context: AiContext, instruction: string, isZh: boolean): string {
+  const userRequest = instruction.trim() || (isZh ? "（无额外说明）" : "(No extra instruction provided.)");
+  if (isVectorDbType(context.databaseType)) {
+    // Vector databases: skip SQL action instructions, only send the user's request
+    return userRequest;
+  }
+  const skill = aiSkillForAction(action);
+  const skillInstruction = isZh ? skill.userInstruction.zh : skill.userInstruction.en;
+  return [`Action: ${action}`, skillInstruction, "", "User request:", userRequest].join("\n");
+}
+
+function actionParams(action: AiAction): { maxTokens: number } {
+  switch (action) {
+    case "explain":
+    case "query":
+    case "exploreSchema":
+    case "executeAndExplain":
+      return { maxTokens: 3200 };
+    case "sampleData":
+      return { maxTokens: 2400 };
+    default:
+      return { maxTokens: 2400 };
+  }
+}
+
+export function extractSql(text: string): string {
+  const fenced = text.match(/```(?:sql|mysql|postgresql|sqlite|tsql|clickhouse)?\s*([\s\S]*?)```/i);
+  if (fenced?.[1]) return fenced[1].trim();
+  return text.trim();
+}
+
+export function buildSystemPrompt(action: AiAction, context: AiContext, mode: AiAssistantMode = "ask"): string {
+  if (isVectorDbType(context.databaseType)) {
+    return buildVectorSystemPrompt(context, mode);
+  }
+  const schema = formatSchema(context);
+  const resultPreview = context.lastResultPreview ? `\nLast result preview:\n${context.lastResultPreview}\n` : "";
+  const lastError = context.lastError ? `\nLast error:\n${context.lastError}\n` : "";
+  const referencedSqlFiles = formatReferencedSqlFiles(context);
+  const schemaScope = context.schemaScope ?? "database";
+
+  const isZh = isChineseLocale(currentLocale());
+
+  const lines: string[] = [...buildBasePromptLines(isZh), ...buildModePromptLines(mode, isZh), ...buildActionPromptLines(action, isZh)];
+
+  if (schemaScope === "focused_table") {
+    lines.push(
+      isZh
+        ? "Schema 上下文只覆盖当前打开的表；数据库中可能还有其他表。用户询问当前有哪些表、某表是否存在，或提到上下文中不存在的表时，不要直接断言不存在，优先生成只读元数据查询来核实。"
+        : "Schema context covers only the currently opened table; the database may contain other tables. When the user asks what tables exist, whether a table exists, or mentions a table absent from context, do not conclude it is missing; prefer a read-only metadata query to verify.",
+    );
+  } else if (context.truncated) {
+    lines.push(
+      isZh
+        ? "Schema 已截断：如果请求可能涉及未出现的表或字段，不要猜测。请让用户用 @table 指定相关表，或先生成只读探索/元数据查询。"
+        : "Schema is truncated: if the request may involve tables or columns not shown, do not guess. Ask the user to mention the relevant @table, or generate a read-only exploration/metadata query first.",
+    );
+  }
+
+  lines.push(
+    isZh ? "返回 SQL 时放在 ```sql 代码块中。额外说明简短实用。" : "Put SQL in a fenced ```sql code block. Keep extra explanation short and practical.",
+    "",
+    `Database type: ${context.databaseType}`,
+    `Connection: ${context.connectionName}`,
+    `Database: ${context.database}`,
+    schemaCoverageLine(context, isZh),
+    "",
+    `Current SQL:\n${context.currentSql.trim() || "(empty)"}`,
+    referencedSqlFiles,
+    lastError,
+    resultPreview,
+    `Schema:\n${schema}`,
+  );
+
+  return lines.filter(Boolean).join("\n");
+}
+
+function buildBasePromptLines(isZh: boolean): string[] {
+  return [
+    isZh ? "你是 DBX 内置的数据库助手。用中文回复。" : "You are DBX's built-in database assistant. Reply in English.",
+    isZh ? "精确、保守，根据当前数据库方言生成 SQL。" : "Be precise, conservative, and adapt SQL to the active database dialect.",
+    isZh ? "严格使用当前数据库方言；标识符引用、分页、日期函数、字符串拼接、LIMIT/TOP/OFFSET 语法必须匹配数据库类型。" : "Strictly use the active database dialect; identifier quoting, pagination, date functions, string concatenation, and LIMIT/TOP/OFFSET syntax must match the database type.",
+    isZh
+      ? '标识符引用必须匹配当前连接类型：MySQL/MariaDB 用反引号 `name`，PostgreSQL/SQLite/Oracle 等用双引号 "name"，SQL Server 用方括号 [name]；不要因为用户口头提到其他数据库而切换方言。'
+      : 'Identifier quoting must match the active connection type: MySQL/MariaDB use backticks `name`, PostgreSQL/SQLite/Oracle and similar dialects use double quotes "name", and SQL Server uses brackets [name]. Do not switch dialects merely because the user mentions another database in prose.',
+    isZh
+      ? "对于普通数据查询，优先使用下面已加载的 Schema 上下文，不要为了重复确认已给出的结构而查询 information_schema 或系统表。但当用户询问某表的字段详情、列信息时，应使用 get_columns 工具获取最权威完整的定义。"
+      : "For ordinary data queries, prefer the loaded schema context below. Do not query information_schema or system tables merely to rediscover structure already provided. However, when the user asks for detailed column/field information of a specific table, use the get_columns tool for the authoritative and complete definition.",
+    isZh
+      ? "例外：当用户明确询问当前有哪些表/Schema、某张表是否存在、或需要盘点数据库对象时，应生成符合当前方言的只读元数据查询（例如 SHOW TABLES、information_schema、sqlite_master 等）。"
+      : "Exception: when the user explicitly asks what tables/schemas exist, whether a table exists, or asks for database object inventory, generate a read-only metadata query appropriate for the active dialect (for example SHOW TABLES, information_schema, sqlite_master).",
+    isZh ? "表注释和列注释是语义别名；当用户用中文业务名描述表或字段时，优先根据注释匹配真实表名和字段名。" : "Table and column comments are semantic aliases; when the user describes tables or fields by business names, prefer matching those comments to the real table and column names.",
+    isZh ? "当用户要求分析或查看某个表时，生成 SELECT 查询获取数据，而不是查询元数据。" : "When the user asks to 'analyze' or 'look at' a table, generate a SELECT query to retrieve data, not a metadata query.",
+    isZh ? "不要编造 Schema 中不存在的表或列。" : "Never invent tables or columns that are not in the schema context.",
+    isZh ? "用户输入中的 @schema.table 或 @table 表示用户明确提到的表；这些表已优先放入 Schema 上下文。" : "User input may contain @schema.table or @table mentions. Treat them as explicit table references; mentioned tables are prioritized in the schema context.",
+    isZh ? "用户引用的 SQL 库文件是额外上下文；可参考其中的查询意图、业务过滤条件和 SQL 写法，但不要把它当作当前编辑器内容。" : "Referenced SQL library files are additional context. Use them for query intent, business filters, and SQL style, but do not treat them as the current editor content.",
+    isZh ? "不要生成多语句 SQL，除非用户明确要求。不要在同一个回答里混合 SELECT 和写操作。" : "Do not generate multi-statement SQL unless the user explicitly asks for it. Do not mix SELECT statements and write operations in the same answer.",
+    isZh ? "对于 DROP、DELETE、TRUNCATE、ALTER 或没有 WHERE 的 UPDATE，简要警告并优先提供安全的 SELECT 预览。" : "For destructive statements (DROP, DELETE, TRUNCATE, ALTER, UPDATE without WHERE), warn briefly and prefer a safer SELECT preview.",
+    isZh ? "对于 UPDATE 或 DELETE，必须带 WHERE 并说明影响范围；生产库写操作只给建议，不主动建议执行。" : "For UPDATE or DELETE, require a WHERE clause and explain the affected scope; for production writes, provide guidance but do not proactively suggest execution.",
+    isZh ? "当用户回复简短肯定词时（例如：需要、好、可以、对），直接执行你之前提议的动作，不要再反问确认。" : "When the user replies with a short affirmative (e.g.: Yes, OK, Sure, Do it), directly execute the action you previously proposed — do not ask for confirmation again.",
+  ];
+}
+
+function buildVectorSystemPrompt(context: AiContext, mode: AiAssistantMode): string {
+  const isZh = isChineseLocale(currentLocale());
+  const schema = formatSchema(context);
+  const resultPreview = context.lastResultPreview ? `\nLast result preview:\n${context.lastResultPreview}\n` : "";
+  const lastError = context.lastError ? `\nLast error:\n${context.lastError}\n` : "";
+  const referencedSqlFiles = formatReferencedSqlFiles(context);
+  const lines: string[] = [
+    isZh ? `你是 DBX 内置的向量数据库助手。当前连接的是 ${dbLabel(context.databaseType)} 数据库。用中文回复。` : `You are DBX's vector database assistant. Connected to ${dbLabel(context.databaseType)}. Reply in English.`,
+    isZh ? "数据存储在集合（collections）中，每条记录包含唯一标识及可选的元数据负载（payload/metadata）。" : "Data is stored in collections. Each record has a unique identifier and optional metadata payload.",
+    ...buildVectorModePromptLines(context, mode, isZh),
+    "",
+    `Database type: ${context.databaseType}`,
+    `Connection: ${context.connectionName}`,
+    `Database: ${context.database}`,
+    schemaCoverageLine(context, isZh),
+    "",
+    `Current collection:\n${context.currentSql.trim() || "(none)"}`,
+    referencedSqlFiles,
+    lastError,
+    resultPreview,
+    "",
+    `Schema:\n${schema}`,
+  ];
+
+  if (context.schemaScope === "focused_table") {
+    lines.push(
+      isZh
+        ? "Schema 上下文只覆盖当前打开的集合；数据库中可能还有其他集合。用户询问当前有哪些集合或提到上下文中不存在的集合时，不要直接断言不存在，先用 list_collections 工具确认。"
+        : "Schema context covers only the currently opened collection; the database may contain other collections. When the user asks what collections exist or mentions a collection absent from context, do not conclude it is missing; use list_collections to verify first.",
+    );
+  }
+
+  return lines.filter(Boolean).join("\n");
+}
+
+function buildVectorModePromptLines(context: AiContext, mode: AiAssistantMode, isZh: boolean): string[] {
+  if (mode === "agent") {
+    return [isZh ? "你处于 Agent 模式。你有以下工具可用：list_collections、browse_collection。" : "You are in Agent mode. You have the following tools available: list_collections, browse_collection."];
+  }
+  return [
+    isZh
+      ? `你处于 Ask 模式。你只能使用 list_collections 确认集合清单；不要浏览集合数据。${dbLabel(context.databaseType)} 的查询格式为 REST API（METHOD /path + JSON body），具体格式因数据库类型而异。只生成查询请求文本和说明，不要暗示已经执行。`
+      : `You are in Ask mode. You may only use list_collections to inspect collection names; do not browse collection data. ${dbLabel(context.databaseType)} uses a REST API query format (METHOD /path + JSON body) that varies by database type. Generate query strings and explanations only; do not imply execution.`,
+  ];
+}
+
+function buildModePromptLines(mode: AiAssistantMode, isZh: boolean): string[] {
+  if (mode === "agent") {
+    return [
+      isZh ? "你处于 Agent 模式。你有以下工具可用：list_tables、get_columns、execute_query、get_sample_data。" : "You are in Agent mode. You have the following tools available: list_tables, get_columns, execute_query, get_sample_data.",
+      isZh
+        ? "用户提出数据查询意图时，必须调用 execute_query 工具执行 SQL，不要只输出 SQL 文本后停止。先用 list_tables/get_columns 了解 schema，再调用 execute_query 获取真实结果，最后基于结果回答用户。"
+        : "When the user expresses a data query intent, you MUST call the execute_query tool to run the SQL — do NOT just output SQL text and stop. Use list_tables/get_columns to understand the schema first, then call execute_query to get real results, then answer based on the actual data.",
+      isZh
+        ? "只有 SELECT、WITH、SHOW、DESCRIBE、EXPLAIN 可以通过 execute_query 执行。如果用户要求写入操作，先解释原因，不要执行。"
+        : "Only SELECT, WITH, SHOW, DESCRIBE, EXPLAIN can be executed via execute_query. If the user requests a write operation, explain why it is blocked instead of executing.",
+      isZh ? "如果安全执行条件不满足，先说明原因，再给只读预览或澄清问题。" : "If safe execution requirements are not met, explain why first, then provide a read-only preview or a clarifying question.",
+    ];
+  }
+
+  return [isZh ? "你处于 Ask 模式。只生成 SQL 和说明，不要暗示已经执行或即将自动执行。" : "You are in Ask mode. Generate SQL and explanations only; do not imply that anything has run or will auto-run."];
+}
+
+function schemaCoverageLine(context: AiContext, isZh: boolean): string {
+  if (context.schemaScope === "focused_table") {
+    if (isVectorDbType(context.databaseType)) {
+      return isZh ? "Schema 上下文只覆盖当前打开的集合，不是完整的集合列表。" : "Schema context scope: focused collection only; not a complete collection list.";
+    }
+    return "Schema context scope: focused table only; not a complete database table list.";
+  }
+  return context.truncated ? "Schema context is truncated." : "Schema context is complete for the loaded database scope.";
+}
+
+function buildActionPromptLines(action: AiAction, isZh: boolean): string[] {
+  const skill = aiSkillForAction(action);
+  return isZh ? [...skill.systemRules.zh, ...skill.outputContract.zh] : [...skill.systemRules.en, ...skill.outputContract.en];
+}
+
+function formatSchema(context: AiContext): string {
+  if (!context.tables.length) return "(No table schema loaded.)";
+
+  return context.tables
+    .map((table) => {
+      const name = table.schema ? `${table.schema}.${table.name}` : table.name;
+      const lines: string[] = [`${name} (${table.tableType})`];
+      const tableComment = table.comment?.trim();
+      if (tableComment) lines.push(`  Comment: ${tableComment}`);
+
+      for (const column of table.columns) {
+        const flags = [column.is_primary_key ? "PK" : "", column.is_nullable ? "nullable" : "NOT NULL", column.column_default ? `default ${column.column_default}` : "", column.extra || ""].filter(Boolean).join(", ");
+        const columnComment = column.comment?.trim();
+        lines.push(`  - ${column.name}: ${column.data_type}${flags ? ` (${flags})` : ""}${columnComment ? ` -- ${columnComment}` : ""}`);
+      }
+
+      if (table.indexes?.length) {
+        for (const idx of table.indexes) {
+          if (idx.is_primary) continue;
+          const unique = idx.is_unique ? "UNIQUE " : "";
+          lines.push(`  Index: ${unique}${idx.name}(${idx.columns.join(", ")})`);
+        }
+      }
+
+      if (table.foreignKeys?.length) {
+        for (const fk of table.foreignKeys) {
+          lines.push(`  FK: ${fk.column} → ${fk.ref_table}.${fk.ref_column}`);
+        }
+      }
+
+      return lines.join("\n");
+    })
+    .join("\n\n");
+}
+
+function formatReferencedSqlFiles(context: AiContext): string {
+  if (!context.sqlFiles.length) return "";
+
+  return [
+    "Referenced SQL library files:",
+    ...context.sqlFiles.map((file) => {
+      const sql = file.sql.trim() || "(empty)";
+      const suffix = file.truncated ? " (truncated)" : "";
+      return `File: ${file.name}${suffix}\nSQL:\n${sql}`;
+    }),
+  ].join("\n\n");
+}
+
+export async function buildAiContext(tab: QueryTab, connection: ConnectionConfig, options: { maxTables?: number; maxColumnsPerTable?: number; maxIndexesPerTable?: number; maxFksPerTable?: number; mentionedTables?: AiTableMention[]; sqlFiles?: AiSqlFileContext[] } = {}): Promise<AiContext> {
+  const maxTables = options.maxTables ?? 50;
+  const maxColumnsPerTable = options.maxColumnsPerTable ?? 40;
+  const maxIndexesPerTable = options.maxIndexesPerTable ?? 10;
+  const maxFksPerTable = options.maxFksPerTable ?? 10;
+  const databaseType = aiDatabaseTypeForConnection(connection);
+  const tables: AiSchemaTable[] = [];
+  const tableKeys = new Set<string>();
+  let truncated = false;
+  let schemaScope: AiContext["schemaScope"] = "database";
+  let currentCollectionName: string | undefined;
+
+  if (tab.tableMeta) {
+    schemaScope = "focused_table";
+    const s = tab.tableMeta.schema ?? "";
+    const tName = tab.tableMeta.tableName;
+    const [indexes, foreignKeys] = await Promise.all([api.listIndexes(tab.connectionId, tab.database, s, tName).catch(() => [] as IndexInfo[]), api.listForeignKeys(tab.connectionId, tab.database, s, tName).catch(() => [] as ForeignKeyInfo[])]);
+    const tableComment = await loadTableComment(tab.connectionId, tab.database, s, tName).catch(() => undefined);
+    tables.push({
+      schema: tab.tableMeta.schema,
+      name: tName,
+      tableType: "TABLE",
+      comment: tableComment,
+      columns: tab.tableMeta.columns.slice(0, maxColumnsPerTable),
+      indexes: indexes.slice(0, maxIndexesPerTable),
+      foreignKeys: foreignKeys.slice(0, maxFksPerTable),
+    });
+    tableKeys.add(aiTableMentionKey(tab.tableMeta.schema, tName));
+    truncated = tab.tableMeta.columns.length > maxColumnsPerTable;
+  }
+
+  for (const mention of options.mentionedTables ?? []) {
+    const key = aiTableMentionKey(mention.schema, mention.table);
+    if (tableKeys.has(key)) continue;
+    const entry = await loadMentionedTableContext(tab, connection, mention, maxColumnsPerTable, maxIndexesPerTable, maxFksPerTable).catch(() => undefined);
+    if (!entry) continue;
+    tableKeys.add(aiTableMentionKey(entry.schema, entry.name));
+    tables.push(entry);
+  }
+
+  // Vector databases: load collections instead of SQL tables
+  if (isVectorDbType(databaseType)) {
+    try {
+      const collections = await api.vectorListCollections(tab.connectionId, tab.database);
+
+      // Find the currently opened collection (tab.sql is UUID for ChromaDB, name for others)
+      const currentCollection = collections.find((c) => c.id === tab.sql || c.name === tab.sql);
+      if (currentCollection) {
+        schemaScope = "focused_table";
+        currentCollectionName = currentCollection.name;
+        tables.push({
+          name: currentCollection.name,
+          tableType: "COLLECTION",
+          comment: currentCollection.dimension ? `${currentCollection.dimension}d vector` : undefined,
+          columns: [],
+        });
+        tableKeys.add(aiTableMentionKey(undefined, currentCollection.name));
+      }
+
+      for (const col of collections.slice(0, maxTables)) {
+        const key = aiTableMentionKey(undefined, col.name);
+        if (tableKeys.has(key)) continue;
+        tables.push({
+          name: col.name,
+          tableType: "COLLECTION",
+          comment: col.dimension ? `${col.dimension}d vector` : undefined,
+          columns: [],
+        });
+        tableKeys.add(key);
+      }
+      if (collections.length > maxTables) truncated = true;
+    } catch {
+      truncated = true;
+    }
+  }
+
+  if (!tab.tableMeta && !["redis", "mongodb"].includes(connection.db_type) && !isVectorDbType(databaseType)) {
+    try {
+      const schemas = await loadCandidateSchemas(tab, connection);
+      for (const schema of schemas) {
+        const tableList = await api.listTables(tab.connectionId, tab.database, schema);
+        const candidates = tableList.slice(0, maxTables - tables.length);
+        if (candidates.length < tableList.length) truncated = true;
+
+        const metaResults = await Promise.all(
+          candidates.map((table) =>
+            Promise.all([
+              api.getColumns(tab.connectionId, tab.database, schema, table.name),
+              api.listIndexes(tab.connectionId, tab.database, schema, table.name).catch(() => [] as IndexInfo[]),
+              api.listForeignKeys(tab.connectionId, tab.database, schema, table.name).catch(() => [] as ForeignKeyInfo[]),
+            ]).then(([columns, indexes, foreignKeys]) => ({
+              schema: schema === tab.database && !isSchemaAware(databaseType) ? undefined : schema,
+              name: table.name,
+              tableType: table.table_type,
+              comment: table.comment,
+              columns: columns.slice(0, maxColumnsPerTable),
+              indexes: indexes.slice(0, maxIndexesPerTable),
+              foreignKeys: foreignKeys.slice(0, maxFksPerTable),
+              _truncatedCols: columns.length > maxColumnsPerTable,
+            })),
+          ),
+        );
+
+        for (const meta of metaResults) {
+          if (meta._truncatedCols) truncated = true;
+          const { _truncatedCols, ...entry } = meta;
+          const key = aiTableMentionKey(entry.schema, entry.name);
+          if (tableKeys.has(key)) continue;
+          tableKeys.add(key);
+          tables.push(entry);
+        }
+        if (tables.length >= maxTables) break;
+      }
+    } catch {
+      truncated = true;
+    }
+  }
+
+  return {
+    connectionId: tab.connectionId,
+    connectionName: connection.name,
+    databaseType,
+    database: tab.database,
+    currentSql: currentCollectionName ?? tab.sql,
+    lastError: extractLastError(tab.result),
+    lastResultPreview: formatResultPreview(tab.result),
+    tables,
+    sqlFiles: options.sqlFiles ?? [],
+    schemaScope,
+    truncated,
+  };
+}
+
+async function loadMentionedTableContext(tab: QueryTab, connection: ConnectionConfig, mention: AiTableMention, maxColumnsPerTable: number, maxIndexesPerTable: number, maxFksPerTable: number): Promise<AiSchemaTable | undefined> {
+  const databaseType = aiDatabaseTypeForConnection(connection);
+  const schema = await resolveMentionedTableSchema(tab, connection, mention);
+  const [columns, indexes, foreignKeys, tableComment] = await Promise.all([
+    api.getColumns(tab.connectionId, tab.database, schema, mention.table),
+    api.listIndexes(tab.connectionId, tab.database, schema, mention.table).catch(() => [] as IndexInfo[]),
+    api.listForeignKeys(tab.connectionId, tab.database, schema, mention.table).catch(() => [] as ForeignKeyInfo[]),
+    loadTableComment(tab.connectionId, tab.database, schema, mention.table).catch(() => undefined),
+  ]);
+  return {
+    schema: schema === tab.database && !isSchemaAware(databaseType) ? undefined : schema,
+    name: mention.table,
+    tableType: "TABLE",
+    comment: tableComment,
+    columns: columns.slice(0, maxColumnsPerTable),
+    indexes: indexes.slice(0, maxIndexesPerTable),
+    foreignKeys: foreignKeys.slice(0, maxFksPerTable),
+  };
+}
+
+async function loadTableComment(connectionId: string, database: string, schema: string, tableName: string): Promise<string | undefined> {
+  const tables = await api.listTables(connectionId, database, schema, tableName, 10);
+  return tables.find((table) => table.name.toLowerCase() === tableName.toLowerCase())?.comment?.trim() || undefined;
+}
+
+async function resolveMentionedTableSchema(tab: QueryTab, connection: ConnectionConfig, mention: AiTableMention): Promise<string> {
+  if (mention.schema) return mention.schema;
+  if (tab.tableMeta?.tableName.toLowerCase() === mention.table.toLowerCase() && tab.tableMeta.schema) {
+    return tab.tableMeta.schema;
+  }
+  if (isSchemaAware(aiDatabaseTypeForConnection(connection))) {
+    const schemas = await loadCandidateSchemas(tab, connection);
+    for (const schema of schemas) {
+      const tables = await api.listTables(tab.connectionId, tab.database, schema, mention.table, 10).catch(() => []);
+      if (tables.some((table) => table.name.toLowerCase() === mention.table.toLowerCase())) return schema;
+    }
+  }
+  return tab.database || connection.database || "main";
+}
+
+async function loadCandidateSchemas(tab: QueryTab, connection: ConnectionConfig): Promise<string[]> {
+  if (isSchemaAware(aiDatabaseTypeForConnection(connection))) {
+    const schemas = await api.listSchemas(tab.connectionId, tab.database);
+    return prioritizeSchemas(schemas);
+  }
+  return [tab.database || connection.database || "main"];
+}
+
+function aiDatabaseTypeForConnection(connection: ConnectionConfig): DatabaseType {
+  return effectiveDatabaseTypeForConnection(connection) ?? connection.db_type;
+}
+
+function prioritizeSchemas(schemas: string[]): string[] {
+  const preferred = ["public", "dbo", "main"];
+  return [...schemas].sort((a, b) => {
+    const ai = preferred.indexOf(a);
+    const bi = preferred.indexOf(b);
+    if (ai >= 0 || bi >= 0) return (ai >= 0 ? ai : 99) - (bi >= 0 ? bi : 99);
+    return a.localeCompare(b);
+  });
+}
+
+function extractLastError(result?: QueryResult): string | undefined {
+  if (!result?.columns.includes("Error")) return undefined;
+  return result.rows[0]?.[0] == null ? undefined : String(result.rows[0][0]);
+}
+
+function formatResultPreview(result?: QueryResult): string | undefined {
+  if (!result || result.columns.includes("Error") || !result.rows.length) return undefined;
+  const MAX_VALUE_CHARS = 200;
+  const rows = result.rows.slice(0, 5).map((row) => {
+    return result.columns
+      .map((column, index) => {
+        const raw = JSON.stringify(row[index] ?? null);
+        const val = raw.length > MAX_VALUE_CHARS ? raw.slice(0, MAX_VALUE_CHARS) + "…" : raw;
+        return `${column}=${val}`;
+      })
+      .join(", ");
+  });
+  return rows.join("\n");
+}
diff --git a/apps/desktop/src/lib/ai/aiAgentPlan.ts b/apps/desktop/src/lib/ai/aiAgentPlan.ts
new file mode 100644
index 0000000..5c627f9
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiAgentPlan.ts
@@ -0,0 +1,88 @@
+import type { AiAction, AiAssistantMode } from "@/lib/ai/ai";
+import { classifyAiSqlExecution, shouldAttemptAiAutoExecute, stripAiSqlComments, type AiSqlExecutionDecision } from "@/lib/ai/aiSqlExecutionPolicy";
+import type { ConnectionConfig } from "@/types/database";
+
+export type AiAgentStep =
+  | { kind: "generate_sql"; status: "done"; sql: string }
+  | { kind: "generate_sql"; status: "skipped"; reason: "no_sql" }
+  | ({
+      kind: "risk_check";
+      status: "done";
+    } & AiSqlExecutionDecision)
+  | { kind: "execute_sql"; status: "pending"; sql: string }
+  | {
+      kind: "execute_sql";
+      status: "skipped";
+      reason: "ask_mode" | "no_sql" | "no_execution_intent" | "blocked_by_policy" | "requires_confirmation";
+    };
+
+export interface AiAgentPlanInput {
+  mode: AiAssistantMode;
+  action: AiAction;
+  instruction: string;
+  assistantContent: string;
+  connection?: ConnectionConfig;
+  database?: string;
+}
+
+export interface AiAgentPlan {
+  steps: AiAgentStep[];
+  executableSql?: string;
+  handoffSql?: string;
+}
+
+export function buildAiAgentPlan(input: AiAgentPlanInput): AiAgentPlan {
+  const sql = extractFirstExecutableSqlCodeBlock(input.assistantContent);
+  if (!sql) {
+    return {
+      steps: [
+        { kind: "generate_sql", status: "skipped", reason: "no_sql" },
+        { kind: "execute_sql", status: "skipped", reason: "no_sql" },
+      ],
+    };
+  }
+
+  const steps: AiAgentStep[] = [{ kind: "generate_sql", status: "done", sql }];
+
+  if (input.mode !== "agent") {
+    steps.push({ kind: "execute_sql", status: "skipped", reason: "ask_mode" });
+    return { steps };
+  }
+
+  // Task-oriented Agent actions (query / exploreSchema / executeAndExplain) execute via the
+  // execute_query tool, surfaced through real-time tool-call events — not via this legacy
+  // client-side auto-execute path. Only render the generated SQL; do not drive client-side
+  // execution for these actions.
+  if (input.action !== "generate") {
+    return { steps };
+  }
+
+  if (!shouldAttemptAiAutoExecute(input.instruction, input.action)) {
+    steps.push({ kind: "execute_sql", status: "skipped", reason: "no_execution_intent" });
+    return { steps };
+  }
+
+  const decision = classifyAiSqlExecution(sql, input.connection, input.database);
+  steps.push({ kind: "risk_check", status: "done", ...decision });
+
+  if (decision.action === "auto_execute") {
+    steps.push({ kind: "execute_sql", status: "pending", sql });
+    return { steps, executableSql: sql, handoffSql: sql };
+  }
+
+  steps.push({
+    kind: "execute_sql",
+    status: "skipped",
+    reason: decision.action === "block" ? "blocked_by_policy" : "requires_confirmation",
+  });
+  return { steps, handoffSql: sql };
+}
+
+function extractFirstExecutableSqlCodeBlock(content: string): string | undefined {
+  const blocks = content.matchAll(/```(?:sql|mysql|postgresql|sqlite|tsql|clickhouse)?\s*\n([\s\S]*?)```/gi);
+  for (const block of blocks) {
+    const sql = block[1]?.trim();
+    if (sql && stripAiSqlComments(sql).trim()) return sql;
+  }
+  return undefined;
+}
diff --git a/apps/desktop/src/lib/ai/aiAgentStepPresentation.ts b/apps/desktop/src/lib/ai/aiAgentStepPresentation.ts
new file mode 100644
index 0000000..dc0c59b
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiAgentStepPresentation.ts
@@ -0,0 +1,117 @@
+import type { AiAgentPlan, AiAgentStep } from "@/lib/ai/aiAgentPlan";
+
+export type AiAgentStepTone = "success" | "active" | "warning" | "danger" | "muted";
+
+export interface AiAgentStepItem {
+  key: string;
+  labelKey: string;
+  tone: AiAgentStepTone;
+  titleKey?: string;
+  titleParams?: Record<string, string>;
+  /** Tool name for display */
+  toolName?: string;
+  /** Tool arguments (e.g., SQL query) for display */
+  toolArgs?: Record<string, unknown>;
+  /** Tool result content (e.g., query results) for display */
+  toolResult?: string;
+  /** Whether this is an error result */
+  isError?: boolean;
+  /** Structured explain plan data (for explain_query tool results) */
+  explainData?: unknown;
+}
+
+/** Backend fallback tool_call_id values that repeat across calls and must not be used as stable merge keys. */
+const REPEATING_TOOL_CALL_IDS = new Set(["cli-tool-call"]);
+
+/**
+ * Build a tool step key. Real tool_call_id values merge start/end into one card;
+ * missing or known repeating fallback IDs stay event-specific to avoid collapsing unrelated calls.
+ */
+export function toolCallStepKey(toolCallId: string, index: number, eventType: string): string {
+  if (toolCallId && !REPEATING_TOOL_CALL_IDS.has(toolCallId)) return `tool-${toolCallId}`;
+  return `tool-${eventType}-${index}`;
+}
+
+/** Upsert a step, preserving details gathered from the previous state of the same card. */
+export function upsertAgentStep(steps: AiAgentStepItem[], step: AiAgentStepItem) {
+  const idx = steps.findIndex((s) => s.key === step.key);
+  if (idx < 0) {
+    steps.push(step);
+    return;
+  }
+
+  const existing = steps[idx];
+  const merged: AiAgentStepItem = { ...step };
+  if (!merged.toolArgs && existing.toolArgs) merged.toolArgs = existing.toolArgs;
+  if (!merged.explainData && existing.explainData) merged.explainData = existing.explainData;
+  if (!merged.titleKey && existing.titleKey) merged.titleKey = existing.titleKey;
+  if (!merged.titleParams && existing.titleParams) merged.titleParams = existing.titleParams;
+  steps.splice(idx, 1, merged);
+}
+
+export function buildAiAgentStepItems(plan: AiAgentPlan): AiAgentStepItem[] {
+  return plan.steps.map(presentStep);
+}
+
+function presentStep(step: AiAgentStep): AiAgentStepItem {
+  if (step.kind === "generate_sql") {
+    if (step.status === "done") {
+      return { key: "generated", labelKey: "ai.agentSteps.generated", tone: "success" };
+    }
+    return { key: "noSql", labelKey: "ai.agentSteps.noSql", tone: "muted" };
+  }
+
+  if (step.kind === "risk_check") {
+    const title = {
+      titleKey: "ai.agentStepTitles.riskCheck",
+      titleParams: {
+        action: step.action,
+        category: step.category,
+        environment: step.environment,
+        reasons: step.reasons.length ? step.reasons.join(", ") : "-",
+      },
+    };
+    if (step.action === "auto_execute") {
+      return { key: "safe", labelKey: "ai.agentSteps.safe", tone: "success", ...title };
+    }
+    if (step.action === "confirm") {
+      return { key: "needsConfirm", labelKey: "ai.agentSteps.needsConfirm", tone: "warning", ...title };
+    }
+    return { key: "blocked", labelKey: "ai.agentSteps.blocked", tone: "danger", ...title };
+  }
+
+  if (step.status === "pending") {
+    return { key: "autoExecute", labelKey: "ai.agentSteps.autoExecute", tone: "active" };
+  }
+
+  if (step.reason === "no_execution_intent") {
+    return {
+      key: "notRequested",
+      labelKey: "ai.agentSteps.notRequested",
+      titleKey: "ai.agentStepTitles.notRequested",
+      tone: "muted",
+    };
+  }
+
+  return {
+    key: "skipped",
+    labelKey: "ai.agentSteps.skipped",
+    titleKey: skippedTitleKey(step.reason),
+    tone: "muted",
+  };
+}
+
+function skippedTitleKey(reason: string): string {
+  switch (reason) {
+    case "blocked_by_policy":
+      return "ai.agentStepTitles.blocked";
+    case "requires_confirmation":
+      return "ai.agentStepTitles.requiresConfirmation";
+    case "ask_mode":
+      return "ai.agentStepTitles.askMode";
+    case "no_sql":
+      return "ai.agentStepTitles.noSql";
+    default:
+      return "ai.agentStepTitles.skipped";
+  }
+}
diff --git a/apps/desktop/src/lib/ai/aiCodeHighlighter.ts b/apps/desktop/src/lib/ai/aiCodeHighlighter.ts
new file mode 100644
index 0000000..920f47d
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiCodeHighlighter.ts
@@ -0,0 +1,101 @@
+import type { AppThemeAppearance } from "@/lib/app/appTheme";
+
+export type AiCodeHighlighter = (content: string, lang: string, appearance?: AppThemeAppearance) => string;
+
+interface AiShikiCodeHighlighterOptions {
+  appearance: () => AppThemeAppearance;
+}
+
+const SHIKI_THEMES = {
+  dark: "github-dark",
+  light: "github-light",
+} as const;
+
+const SHIKI_LANGUAGES = ["bash", "css", "go", "html", "java", "javascript", "json", "markdown", "php", "python", "rust", "shellscript", "sql", "tsx", "typescript", "vue", "xml", "yaml"] as const;
+
+const SHIKI_LANG_BY_AI_LABEL: Record<string, (typeof SHIKI_LANGUAGES)[number] | "text"> = {
+  BASH: "bash",
+  CLICKHOUSE: "sql",
+  CSS: "css",
+  GO: "go",
+  HTML: "html",
+  JAVA: "java",
+  JAVASCRIPT: "javascript",
+  JS: "javascript",
+  JSON: "json",
+  MARKDOWN: "markdown",
+  MYSQL: "sql",
+  PHP: "php",
+  POSTGRESQL: "sql",
+  PYTHON: "python",
+  RUST: "rust",
+  SHELL: "shellscript",
+  SH: "shellscript",
+  SQL: "sql",
+  SQLITE: "sql",
+  TS: "typescript",
+  TSQL: "sql",
+  TSX: "tsx",
+  TYPESCRIPT: "typescript",
+  VUE: "vue",
+  XML: "xml",
+  YAML: "yaml",
+  YML: "yaml",
+  ZSH: "shellscript",
+};
+
+type ShikiHighlighter = Awaited<ReturnType<typeof import("shiki/core").createHighlighterCore>>;
+
+let highlighterPromise: Promise<ShikiHighlighter> | undefined;
+
+export async function createAiShikiCodeHighlighter(options: AiShikiCodeHighlighterOptions): Promise<AiCodeHighlighter> {
+  const highlighter = await getAiShikiHighlighter();
+  return (content, lang, appearance = options.appearance()) =>
+    highlighter.codeToHtml(content, {
+      lang: resolveShikiLanguage(lang),
+      structure: "inline",
+      theme: SHIKI_THEMES[appearance],
+    });
+}
+
+function getAiShikiHighlighter(): Promise<ShikiHighlighter> {
+  highlighterPromise ??= loadAiShikiHighlighter();
+  return highlighterPromise;
+}
+
+async function loadAiShikiHighlighter(): Promise<ShikiHighlighter> {
+  const [{ createHighlighterCore }, { createJavaScriptRegexEngine }, githubDark, githubLight, bash, css, go, html, java, javascript, json, markdown, php, python, rust, shellscript, sql, tsx, typescript, vue, xml, yaml] = await Promise.all([
+    import("shiki/core"),
+    import("shiki/engine/javascript"),
+    import("shiki/themes/github-dark.mjs"),
+    import("shiki/themes/github-light.mjs"),
+    import("shiki/langs/bash.mjs"),
+    import("shiki/langs/css.mjs"),
+    import("shiki/langs/go.mjs"),
+    import("shiki/langs/html.mjs"),
+    import("shiki/langs/java.mjs"),
+    import("shiki/langs/javascript.mjs"),
+    import("shiki/langs/json.mjs"),
+    import("shiki/langs/markdown.mjs"),
+    import("shiki/langs/php.mjs"),
+    import("shiki/langs/python.mjs"),
+    import("shiki/langs/rust.mjs"),
+    import("shiki/langs/shellscript.mjs"),
+    import("shiki/langs/sql.mjs"),
+    import("shiki/langs/tsx.mjs"),
+    import("shiki/langs/typescript.mjs"),
+    import("shiki/langs/vue.mjs"),
+    import("shiki/langs/xml.mjs"),
+    import("shiki/langs/yaml.mjs"),
+  ]);
+
+  return createHighlighterCore({
+    engine: createJavaScriptRegexEngine(),
+    langs: [bash.default, css.default, go.default, html.default, java.default, javascript.default, json.default, markdown.default, php.default, python.default, rust.default, shellscript.default, sql.default, tsx.default, typescript.default, vue.default, xml.default, yaml.default],
+    themes: [githubDark.default, githubLight.default],
+  });
+}
+
+function resolveShikiLanguage(lang: string): (typeof SHIKI_LANGUAGES)[number] | "text" {
+  return SHIKI_LANG_BY_AI_LABEL[lang.toUpperCase()] ?? "text";
+}
diff --git a/apps/desktop/src/lib/ai/aiMarkdown.ts b/apps/desktop/src/lib/ai/aiMarkdown.ts
new file mode 100644
index 0000000..aa5507a
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiMarkdown.ts
@@ -0,0 +1,119 @@
+import { Marked, type Tokens } from "marked";
+
+const EXTERNAL_LINK_PROTOCOLS = new Set(["http:", "https:"]);
+
+export interface AiMarkdownLinkClickEvent {
+  target: unknown;
+  currentTarget: unknown;
+  preventDefault: () => void;
+  stopPropagation: () => void;
+}
+
+export type AiMarkdownLinkOpener = (url: string) => void | Promise<void>;
+
+const markedInstance = new Marked({
+  breaks: true,
+  gfm: true,
+  renderer: {
+    codespan({ text }: Tokens.Codespan) {
+      return `<code class="rounded bg-muted px-1.5 py-0.5 text-[11px] font-mono">${escapeHtml(text)}</code>`;
+    },
+    html({ text }: Tokens.HTML | Tokens.Tag) {
+      return escapeHtml(text);
+    },
+    link({ href, title, tokens }: Tokens.Link) {
+      const label = this.parser.parseInline(tokens);
+      const safeHref = normalizeAiMarkdownLink(href);
+      if (!safeHref) return label;
+
+      const titleAttr = title ? ` title="${escapeHtml(title)}"` : "";
+      return `<a href="${escapeHtml(safeHref)}"${titleAttr} target="_blank" rel="noopener noreferrer">${label}</a>`;
+    },
+    table({ header, rows, align }: Tokens.Table) {
+      const renderCell = (cell: Tokens.TableCell, tag: "th" | "td", colIndex: number): string => {
+        const content = this.parser.parseInline(cell.tokens);
+        const alignAttr = align?.[colIndex] ? ` align="${escapeHtml(align[colIndex]!)}"` : "";
+        return `<${tag}${alignAttr}>${content}</${tag}>`;
+      };
+      const thead = header.length > 0 ? `<thead><tr>${header.map((cell, i) => renderCell(cell, "th", i)).join("")}</tr></thead>` : "";
+      const tbodyRows = rows
+        .map((row) => {
+          const cells = row.map((cell, i) => renderCell(cell, "td", i)).join("");
+          return `<tr>${cells}</tr>`;
+        })
+        .join("");
+      const tbody = `<tbody>${tbodyRows}</tbody>`;
+      return `<div class="ai-markdown-table-wrap"><table>${thead}${tbody}</table></div>`;
+    },
+  },
+});
+
+export function formatAiInlineMarkdown(text: string): string {
+  try {
+    return markedInstance.parse(text) as string;
+  } catch {
+    return escapeHtml(text);
+  }
+}
+
+export function normalizeAiMarkdownLink(href: string): string | null {
+  try {
+    const url = new URL(href);
+    return EXTERNAL_LINK_PROTOCOLS.has(url.protocol) ? url.toString() : null;
+  } catch {
+    return null;
+  }
+}
+
+export function aiMarkdownLinkUrlFromClick(target: unknown, currentTarget: unknown): string | null {
+  const anchor = closestAnchor(target);
+  if (!anchor) return null;
+  if (hasContains(currentTarget) && !currentTarget.contains(anchor)) return null;
+
+  const href = anchor.getAttribute("href");
+  return href ? normalizeAiMarkdownLink(href) : null;
+}
+
+export function handleAiMarkdownLinkClick(event: AiMarkdownLinkClickEvent, openUrl: AiMarkdownLinkOpener): boolean {
+  const url = aiMarkdownLinkUrlFromClick(event.target, event.currentTarget);
+  if (!url) return false;
+
+  event.preventDefault();
+  event.stopPropagation();
+  void openUrl(url);
+  return true;
+}
+
+function escapeHtml(value: string): string {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+interface AnchorLike {
+  getAttribute: (name: string) => string | null;
+}
+
+function closestAnchor(target: unknown): AnchorLike | null {
+  const closestSource = hasClosest(target) ? target : parentWithClosest(target);
+  if (!closestSource) return null;
+
+  const anchor = closestSource.closest("a[href]");
+  return hasGetAttribute(anchor) ? anchor : null;
+}
+
+function parentWithClosest(target: unknown): { closest: (selector: string) => unknown } | null {
+  if (!target || typeof target !== "object" || !("parentElement" in target)) return null;
+  const parentElement = target.parentElement;
+  return hasClosest(parentElement) ? parentElement : null;
+}
+
+function hasClosest(value: unknown): value is { closest: (selector: string) => unknown } {
+  return !!value && typeof value === "object" && "closest" in value && typeof value.closest === "function";
+}
+
+function hasGetAttribute(value: unknown): value is AnchorLike {
+  return !!value && typeof value === "object" && "getAttribute" in value && typeof value.getAttribute === "function";
+}
+
+function hasContains(value: unknown): value is { contains: (node: unknown) => boolean } {
+  return !!value && typeof value === "object" && "contains" in value && typeof value.contains === "function";
+}
diff --git a/apps/desktop/src/lib/ai/aiMessageEdit.ts b/apps/desktop/src/lib/ai/aiMessageEdit.ts
new file mode 100644
index 0000000..41247e1
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiMessageEdit.ts
@@ -0,0 +1,19 @@
+export interface MessageWithKind {
+  kind?: string;
+}
+
+/**
+ * Maps a visible message index (contextSummary messages excluded) to the
+ * actual index in the full messages array.
+ * Returns -1 if not found.
+ */
+export function visibleToActualIndex(messages: MessageWithKind[], visibleIndex: number): number {
+  let vi = 0;
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].kind !== "contextSummary") {
+      if (vi === visibleIndex) return i;
+      vi++;
+    }
+  }
+  return -1;
+}
diff --git a/apps/desktop/src/lib/ai/aiMessageRender.ts b/apps/desktop/src/lib/ai/aiMessageRender.ts
new file mode 100644
index 0000000..cb97b71
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiMessageRender.ts
@@ -0,0 +1,141 @@
+export interface AiMessageTextSegment {
+  type: "text";
+  content: string;
+  html: string;
+}
+
+export interface AiMessageCodeSegment {
+  type: "code";
+  content: string;
+  lang: string;
+  html: string;
+  isSql: boolean;
+}
+
+export type AiMessageRenderSegment = AiMessageTextSegment | AiMessageCodeSegment;
+
+interface MessageSegment {
+  type: "text" | "code";
+  content: string;
+  lang?: string;
+}
+
+export interface AiMessageRendererOptions {
+  maxEntries?: number;
+  maxCacheableChars?: number;
+  markdown: (text: string) => string;
+  highlightCode?: (content: string, lang: string) => string;
+}
+
+const DEFAULT_MAX_ENTRIES = 100;
+const DEFAULT_MAX_CACHEABLE_CHARS = 20_000;
+const SQL_LANGUAGES = new Map([
+  ["sql", "SQL"],
+  ["mysql", "MYSQL"],
+  ["postgres", "POSTGRESQL"],
+  ["postgresql", "POSTGRESQL"],
+  ["sqlite", "SQLITE"],
+  ["tsql", "TSQL"],
+  ["clickhouse", "CLICKHOUSE"],
+  ["mongodb", "MONGODB"],
+  ["mongo", "MONGODB"],
+]);
+const SHELL_LANGUAGES = new Map([
+  ["bash", "BASH"],
+  ["sh", "SHELL"],
+  ["shell", "SHELL"],
+  ["zsh", "ZSH"],
+]);
+const SQL_LANGUAGE_LABELS = new Set(SQL_LANGUAGES.values());
+
+export function createAiMessageRenderer(options: AiMessageRendererOptions) {
+  const maxEntries = Math.max(1, Math.floor(options.maxEntries ?? DEFAULT_MAX_ENTRIES));
+  const maxCacheableChars = Math.max(0, Math.floor(options.maxCacheableChars ?? DEFAULT_MAX_CACHEABLE_CHARS));
+  const cache = new Map<string, AiMessageRenderSegment[]>();
+
+  function render(content: string): AiMessageRenderSegment[] {
+    const cacheable = content.length <= maxCacheableChars;
+    const cached = cacheable ? cache.get(content) : undefined;
+    if (cached) {
+      cache.delete(content);
+      cache.set(content, cached);
+      return cached;
+    }
+
+    const rendered = parseAiMessage(content).map((segment): AiMessageRenderSegment => {
+      if (segment.type === "text") {
+        return { type: "text", content: segment.content, html: options.markdown(segment.content) };
+      }
+      const lang = normalizeAiCodeLanguage(segment.lang);
+      return {
+        type: "code",
+        content: segment.content,
+        html: options.highlightCode?.(segment.content, lang) ?? escapeHtml(segment.content),
+        lang,
+        isSql: isSqlAiCodeLanguage(lang),
+      };
+    });
+
+    if (cacheable) {
+      cache.set(content, rendered);
+      while (cache.size > maxEntries) {
+        const oldestKey = cache.keys().next().value;
+        if (oldestKey === undefined) break;
+        cache.delete(oldestKey);
+      }
+    }
+    return rendered;
+  }
+
+  function clear() {
+    cache.clear();
+  }
+
+  return { render, clear };
+}
+
+export function parseAiMessage(text: string): MessageSegment[] {
+  const segments: MessageSegment[] = [];
+  const lines = text.split("\n");
+  let i = 0;
+
+  while (i < lines.length) {
+    const fenceMatch = lines[i].match(/^```([a-zA-Z0-9_+.-]*)\s*$/);
+    if (fenceMatch) {
+      const lang = fenceMatch[1] || "sql";
+      const codeLines: string[] = [];
+      i++;
+      while (i < lines.length && !/^```\s*$/.test(lines[i])) {
+        codeLines.push(lines[i]);
+        i++;
+      }
+      if (i < lines.length) i++;
+      const content = codeLines.join("\n").trim();
+      if (content) segments.push({ type: "code", lang, content });
+    } else {
+      const textLines: string[] = [];
+      while (i < lines.length && !/^```([a-zA-Z0-9_+.-]*)\s*$/.test(lines[i])) {
+        textLines.push(lines[i]);
+        i++;
+      }
+      const content = textLines.join("\n");
+      if (content.trim()) segments.push({ type: "text", content });
+    }
+  }
+
+  return segments;
+}
+
+export function normalizeAiCodeLanguage(lang?: string): string {
+  const key = (lang || "sql").trim().toLowerCase();
+  if (!key) return "SQL";
+  return SQL_LANGUAGES.get(key) || SHELL_LANGUAGES.get(key) || (key === "json" ? "JSON" : key.toUpperCase());
+}
+
+export function isSqlAiCodeLanguage(lang: string): boolean {
+  return SQL_LANGUAGE_LABELS.has(lang);
+}
+
+function escapeHtml(value: string): string {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
diff --git a/apps/desktop/src/lib/ai/aiModelPresentation.ts b/apps/desktop/src/lib/ai/aiModelPresentation.ts
new file mode 100644
index 0000000..94c8c8c
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiModelPresentation.ts
@@ -0,0 +1,25 @@
+export interface AiModelPresentation {
+  primary: string;
+  secondary?: string;
+}
+
+function compactModelName(value: string): string {
+  return value
+    .trim()
+    .toLowerCase()
+    .replace(/[\s_-]+/g, "");
+}
+
+export function shouldShowAiModelSecondaryLabel(label: string, modelId: string): boolean {
+  const normalizedLabel = compactModelName(label);
+  const normalizedId = compactModelName(modelId);
+  if (!normalizedLabel || !normalizedId || normalizedLabel === normalizedId) return false;
+  return true;
+}
+
+export function formatAiModelOption(label: string, modelId: string): AiModelPresentation {
+  return {
+    primary: label || modelId,
+    secondary: shouldShowAiModelSecondaryLabel(label, modelId) ? modelId : undefined,
+  };
+}
diff --git a/apps/desktop/src/lib/ai/aiPromptKeyboard.ts b/apps/desktop/src/lib/ai/aiPromptKeyboard.ts
new file mode 100644
index 0000000..8c3bf2e
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiPromptKeyboard.ts
@@ -0,0 +1,17 @@
+export interface AiPromptKeydownLikeEvent {
+  key: string;
+  shiftKey?: boolean;
+  isComposing?: boolean;
+  keyCode?: number;
+}
+
+export function isAiPromptImeCompositionEvent(event: AiPromptKeydownLikeEvent, compositionActive = false): boolean {
+  return compositionActive || !!event.isComposing || event.keyCode === 229 || event.key === "Process";
+}
+
+export function shouldSubmitAiPromptOnKeydown(event: AiPromptKeydownLikeEvent, compositionActive = false): boolean {
+  if (event.key !== "Enter") return false;
+  if (event.shiftKey) return false;
+  if (isAiPromptImeCompositionEvent(event, compositionActive)) return false;
+  return true;
+}
diff --git a/apps/desktop/src/lib/ai/aiProposalDetect.ts b/apps/desktop/src/lib/ai/aiProposalDetect.ts
new file mode 100644
index 0000000..9873f87
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiProposalDetect.ts
@@ -0,0 +1,168 @@
+/**
+ * Pure detectors for recognizing AI assistant action proposals and user
+ * short replies (affirmative / negative). Used by the chat UI to render
+ * a quick action confirmation bar instead of requiring the user to type.
+ *
+ * Detectors are intentionally narrow:
+ * - A "proposal" requires both a first-person/asking phrase AND an
+ *   actionable intent verb (execute query, fetch data, investigate, etc.)
+ * - Affirmative / negative detectors only match short replies (the user
+ *   typing a couple of words). Long replies fall through.
+ *
+ * Side-effect free. Safe to import from anywhere.
+ */
+
+/** Trim whitespace, leading/trailing punctuation (CJK + ASCII) for short-reply matching. */
+function stripOuterPunctuation(input: string): string {
+  return input
+    .replace(/^[\s　]+/, "")
+    .replace(/[\s　]+$/, "")
+    .replace(/^[!?.,;:！？。，；：]+/, "")
+    .replace(/[!?.,;:！？。，；：]+$/, "");
+}
+
+/** Returns the last non-empty line/sentence-ish chunk of the assistant message. */
+function lastNonEmptyLine(content: string): string {
+  const lines = content.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const trimmed = lines[i].trim();
+    if (trimmed) return trimmed;
+  }
+  return "";
+}
+
+/** True when the string contains at least one CJK ideograph. */
+export function containsChinese(input: string): boolean {
+  return /[一-鿿]/.test(input);
+}
+
+// Phrases that indicate the assistant is asking permission to take an action.
+const ZH_ASK_PHRASES = [
+  /需要我/, // "do you need me to"
+  /要不要我/, // "shall I"
+  /是否需要/, // "is it needed"
+  /帮我?(?:你)?/, // "shall I help" (loose)
+  /我来/, // "let me"
+  /我帮你/, // "let me help you"
+  /我现在/, // "shall I now"
+  /我可以/, // "may I"
+  /我去/, // "shall I go"
+  /我能/, // "may I"
+];
+
+const EN_ASK_PHRASES = [/\bshould\s+i\b/i, /\bdo\s+you\s+want\s+me\s+to\b/i, /\bwould\s+you\s+like\s+me\s+to\b/i, /\bwant\s+me\s+to\b/i, /\bshall\s+i\b/i, /\bcan\s+i\b/i, /\blet\s+me\s+know\s+if\s+you\s+want\s+me\s+to\b/i];
+
+// Actionable intent verbs/phrases. Must co-occur with an ask phrase to count.
+const ZH_ACTION_PHRASES = [
+  /执行/, // execute
+  /运行/, // run
+  /查询/, // query
+  /查看/, // view
+  /看看/,
+  /查一下/, // check
+  /拉取/, // fetch
+  /获取/, // get/fetch
+  /读取/, // read
+  /取出?/, // take out / extract
+  /取数据/,
+  /看看数据/,
+  /看一下/,
+  /分析/, // analyze
+  /统计/, // count/aggregate
+  /排查/, // investigate
+  /调查/, // investigate
+  /生成/, // generate
+  /创建/, // create
+  /列出/, // list
+  /对比/, // compare
+];
+
+const EN_ACTION_PHRASES = [
+  /\bexecute\b/i,
+  /\brun\b/i,
+  /\bquery\b/i,
+  /\bfetch\b/i,
+  /\bpull\b/i,
+  /\bretrieve\b/i,
+  /\bread\b/i,
+  /\bget\s+(?:the\s+)?(?:data|rows|sample|columns|results)\b/i,
+  /\banalyze\b/i,
+  /\binvestigate\b/i,
+  /\bcheck\b/i,
+  /\binspect\b/i,
+  /\bgenerate\b/i,
+  /\bcreate\b/i,
+  /\blist\b/i,
+  /\bcompare\b/i,
+  /\bcount\b/i,
+  /\bsample\b/i,
+];
+
+/**
+ * Detect whether the assistant message ends with a proposal-style question
+ * such as "Should I execute this query?" / "需要我拉取这两个表的数据吗？".
+ *
+ * Heuristic:
+ * - Looks at the last non-empty line.
+ * - Must end with a question mark (Chinese ？ or English ?).
+ * - Must contain BOTH a first-person ask phrase AND an actionable intent.
+ *
+ * Returns false for generic clarifying questions (no actionable verb).
+ */
+export function looksLikeActionProposal(content: string): boolean {
+  if (!content) return false;
+  const lastLine = lastNonEmptyLine(content);
+  if (!lastLine) return false;
+
+  // Must be a question.
+  if (!/[?？]\s*$/.test(lastLine)) return false;
+
+  const isZh = containsChinese(lastLine);
+  const askPhrases = isZh ? ZH_ASK_PHRASES : EN_ASK_PHRASES;
+  const actionPhrases = isZh ? ZH_ACTION_PHRASES : EN_ACTION_PHRASES;
+
+  const hasAsk = askPhrases.some((re) => re.test(lastLine));
+  if (!hasAsk) return false;
+
+  const hasAction = actionPhrases.some((re) => re.test(lastLine));
+  return hasAction;
+}
+
+// Short affirmative words/phrases. Must match (after stripping punctuation /
+// whitespace) the entire reply for it to count — long replies fall through.
+const ZH_AFFIRMATIVE = [/^需要$/, /^需要的$/, /^要$/, /^要的$/, /^好$/, /^好的$/, /^可以$/, /^行$/, /^是$/, /^是的$/, /^对$/, /^对的$/, /^嗯$/, /^嗯嗯$/, /^OK$/i, /^OKK*$/i, /^没问题$/, /^请$/, /^麻烦了$/, /^来吧$/, /^继续$/];
+
+const EN_AFFIRMATIVE = [/^yes$/i, /^yeah$/i, /^yep$/i, /^y$/i, /^ok$/i, /^okay$/i, /^k$/i, /^sure$/i, /^go$/i, /^go\s+ahead$/i, /^do\s+it$/i, /^please\s+do$/i, /^please$/i, /^proceed$/i, /^continue$/i, /^confirm(?:ed)?$/i];
+
+const ZH_NEGATIVE = [/^不$/, /^不用$/, /^不用了$/, /^不需要$/, /^不要$/, /^别$/, /^先不$/, /^先不(?:用|要)$/, /^算了$/, /^不必$/, /^取消$/, /^停$/, /^先别$/];
+
+const EN_NEGATIVE = [/^no$/i, /^nope$/i, /^nah$/i, /^n$/i, /^don'?t$/i, /^do\s+not$/i, /^not\s+needed$/i, /^skip$/i, /^cancel$/i, /^stop$/i, /^never\s*mind$/i, /^nvm$/i, /^hold\s+off$/i, /^not\s+now$/i];
+
+/**
+ * Detect "short affirmative" user replies like 需要 / 好 / 可以 / 是 / 对 /
+ * 嗯 / yes / ok / sure / go ahead / do it.
+ *
+ * Long messages (multiple sentences, or words mixed with extra context)
+ * intentionally do NOT match — those should be sent to the LLM normally.
+ */
+export function isShortAffirmative(content: string): boolean {
+  const cleaned = stripOuterPunctuation(content);
+  if (!cleaned) return false;
+  // Reject when the reply has multiple words/lines unless still very short
+  // and matches a known phrase (e.g. "go ahead" / "do it" / "好的").
+  if (cleaned.length > 24) return false;
+  const all = [...ZH_AFFIRMATIVE, ...EN_AFFIRMATIVE];
+  return all.some((re) => re.test(cleaned));
+}
+
+/**
+ * Detect "short negative" user replies like 不用 / 不需要 / 不要 / no /
+ * nope / don't / not needed.
+ */
+export function isShortNegative(content: string): boolean {
+  const cleaned = stripOuterPunctuation(content);
+  if (!cleaned) return false;
+  if (cleaned.length > 24) return false;
+  const all = [...ZH_NEGATIVE, ...EN_NEGATIVE];
+  return all.some((re) => re.test(cleaned));
+}
diff --git a/apps/desktop/src/lib/ai/aiSkills.ts b/apps/desktop/src/lib/ai/aiSkills.ts
new file mode 100644
index 0000000..c623280
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiSkills.ts
@@ -0,0 +1,254 @@
+import type { AiAction } from "@/lib/ai/ai";
+
+export type AiSkillRiskPolicy = "readonly" | "readonly_preferred" | "confirmed_write" | "sample_write";
+export type AiSkillContextNeed = "currentSql" | "schema" | "indexes" | "foreignKeys" | "lastError" | "lastResultPreview" | "databaseDialect";
+
+export interface LocalizedAiSkillText {
+  en: string;
+  zh: string;
+}
+
+export interface LocalizedAiSkillLines {
+  en: string[];
+  zh: string[];
+}
+
+export interface AiSkillDefinition {
+  id: string;
+  action: AiAction;
+  title: LocalizedAiSkillText;
+  riskPolicy: AiSkillRiskPolicy;
+  contextNeeds: AiSkillContextNeed[];
+  userInstruction: LocalizedAiSkillText;
+  systemRules: LocalizedAiSkillLines;
+  outputContract: LocalizedAiSkillLines;
+}
+
+export const AI_SKILL_DEFINITIONS: AiSkillDefinition[] = [
+  {
+    id: "general",
+    action: "general",
+    title: {
+      en: "General",
+      zh: "通用问答",
+    },
+    riskPolicy: "readonly",
+    contextNeeds: [],
+    userInstruction: {
+      en: "Answer the user's question directly and naturally. Use your general knowledge and the database schema context when relevant.",
+      zh: "直接、自然地回答用户的问题。使用你的通用知识，涉及数据库时可参考 Schema 上下文。",
+    },
+    systemRules: {
+      en: ["Answer naturally and helpfully. Adapt to the user's intent — whether that's a greeting, a conceptual question, or a database-related inquiry."],
+      zh: ["自然、有帮助地回答。根据用户意图灵活应对——无论是问候、概念性问题还是数据库相关咨询。"],
+    },
+    outputContract: {
+      en: ["Provide a clear, helpful answer adapted to the user's question."],
+      zh: ["根据用户问题提供清晰、有帮助的回答。"],
+    },
+  },
+  {
+    id: "generate_sql",
+    action: "generate",
+    title: {
+      en: "Generate SQL",
+      zh: "生成 SQL",
+    },
+    riskPolicy: "readonly_preferred",
+    contextNeeds: ["schema", "indexes", "foreignKeys", "databaseDialect"],
+    userInstruction: {
+      en: "Generate a SQL query that satisfies the user's request. Return the SQL in a ```sql code block first, followed by a brief note if needed. Use foreign key relationships from the schema to infer correct JOIN conditions.",
+      zh: "根据用户请求生成 SQL。先在 ```sql 代码块中返回 SQL，必要时附简短说明。利用 Schema 中的外键关系推断正确的 JOIN 条件。",
+    },
+    systemRules: {
+      en: ["Use foreign key relationships to infer JOIN conditions. Return the SQL first and avoid long explanations."],
+      zh: ["利用外键关系推断 JOIN 条件。生成操作优先返回 SQL，避免长篇解释。"],
+    },
+    outputContract: {
+      en: ["Output format: put only the final recommended SQL in the first ```sql code block; add at most 3 practical notes after it. If required information is missing, ask one clarifying question first."],
+      zh: ["输出格式：第一个 ```sql 代码块只放最终推荐 SQL；SQL 后最多 3 条实用说明。信息不足时先提出一个澄清问题。"],
+    },
+  },
+  {
+    id: "explain_sql",
+    action: "explain",
+    title: {
+      en: "Explain SQL",
+      zh: "解释 SQL",
+    },
+    riskPolicy: "readonly",
+    contextNeeds: ["currentSql", "schema", "indexes", "foreignKeys", "lastResultPreview"],
+    userInstruction: {
+      en: "Explain the current SQL step by step. Point out risky operations, implicit assumptions, and potential performance issues. Reference index and foreign key info from the schema when relevant.",
+      zh: "逐步解释当前 SQL。指出危险操作、隐含假设和潜在性能问题。结合 Schema 中的索引和外键信息分析。",
+    },
+    systemRules: {
+      en: ["Explain what the SQL does without changing it. Reference schema, indexes, foreign keys, result preview, and risky assumptions when relevant."],
+      zh: ["解释当前 SQL 的作用，不要改写 SQL。必要时结合 Schema、索引、外键、结果预览和风险假设说明。"],
+    },
+    outputContract: {
+      en: ["Output format: summarize the SQL purpose first, then explain execution logic, risks, and performance notes step by step."],
+      zh: ["输出格式：先概括 SQL 目的，再按步骤解释执行逻辑、风险点和性能注意事项。"],
+    },
+  },
+  {
+    id: "optimize_sql",
+    action: "optimize",
+    title: {
+      en: "Optimize SQL",
+      zh: "优化 SQL",
+    },
+    riskPolicy: "readonly",
+    contextNeeds: ["currentSql", "schema", "indexes", "foreignKeys"],
+    userInstruction: {
+      en: "Rewrite or suggest improvements for the current SQL. Return the improved SQL in a ```sql code block first, followed by short notes explaining the changes. Use the index information in the schema to suggest index-aware optimizations (e.g., avoid full table scans, leverage existing indexes).",
+      zh: "重写或优化当前 SQL。先在 ```sql 代码块中返回优化后的 SQL，然后简要说明改动。利用 Schema 中的索引信息建议索引友好的优化（如避免全表扫描、利用现有索引）。",
+    },
+    systemRules: {
+      en: ["Use the index information in the schema to suggest optimizations. Point out which conditions hit indexes and which cause full table scans."],
+      zh: ["利用 Schema 中的索引信息建议优化。指出哪些查询条件可以命中索引、哪些会导致全表扫描。"],
+    },
+    outputContract: {
+      en: ["Output format: provide the optimized SQL first, then explain the key changes in at most 3 notes."],
+      zh: ["输出格式：先给优化后的 SQL，再用最多 3 条说明解释关键改动。"],
+    },
+  },
+  {
+    id: "fix_sql",
+    action: "fix",
+    title: {
+      en: "Fix SQL",
+      zh: "修复 SQL",
+    },
+    riskPolicy: "readonly_preferred",
+    contextNeeds: ["currentSql", "schema", "lastError", "lastResultPreview", "databaseDialect"],
+    userInstruction: {
+      en: "Fix the current SQL using the provided error message and result context. Return the corrected SQL in a ```sql code block first, followed by a brief explanation of the root cause.",
+      zh: "根据报错信息和结果上下文修复当前 SQL。先在 ```sql 代码块中返回修正后的 SQL，再简要说明根因。",
+    },
+    systemRules: {
+      en: ["Carefully analyze the error message to identify the root cause. Return the corrected SQL first, then briefly explain."],
+      zh: ["仔细分析错误信息，定位根因。先返回修正后的 SQL，再简要解释。"],
+    },
+    outputContract: {
+      en: ["Output format: corrected SQL, error cause, change notes."],
+      zh: ["输出格式：修复后的 SQL、错误原因、改动说明。"],
+    },
+  },
+  {
+    id: "convert_sql",
+    action: "convert",
+    title: {
+      en: "Convert SQL Dialect",
+      zh: "转换 SQL 方言",
+    },
+    riskPolicy: "readonly_preferred",
+    contextNeeds: ["currentSql", "schema", "databaseDialect"],
+    userInstruction: {
+      en: "Convert the current SQL to the target dialect requested by the user. Return the converted SQL in a ```sql code block first. Note any syntax differences or incompatibilities.",
+      zh: "将当前 SQL 转换为用户指定的目标方言。先在 ```sql 代码块中返回转换后的 SQL，再说明语法差异。",
+    },
+    systemRules: {
+      en: ["Convert only to the target dialect requested by the user. Preserve the query intent and call out syntax that cannot be converted safely."],
+      zh: ["只转换到用户指定的目标方言。保持查询意图，并指出无法安全转换的语法。"],
+    },
+    outputContract: {
+      en: ["Output format: provide the converted SQL first, then note important target-dialect syntax differences or incompatibilities."],
+      zh: ["输出格式：先给转换后的 SQL，再说明目标方言下的重要语法差异或不兼容点。"],
+    },
+  },
+  {
+    id: "sample_data",
+    action: "sampleData",
+    title: {
+      en: "Generate Sample Data",
+      zh: "生成样例数据",
+    },
+    riskPolicy: "sample_write",
+    contextNeeds: ["schema", "databaseDialect"],
+    userInstruction: {
+      en: "Generate safe sample INSERT statements or mock data for the current schema. Do not use real production data. Return SQL in a ```sql code block.",
+      zh: "为当前 Schema 生成安全的示例 INSERT 语句或模拟数据。不使用真实生产数据。在 ```sql 代码块中返回 SQL。",
+    },
+    systemRules: {
+      en: ["Generate mock data only. Do not use or imply real production data, credentials, personal data, or secrets."],
+      zh: ["只生成模拟数据。不要使用或暗示真实生产数据、凭据、个人数据或密钥。"],
+    },
+    outputContract: {
+      en: ["Output format: provide safe sample SQL first, then explain which values are mock data."],
+      zh: ["输出格式：先给安全的示例 SQL，再说明哪些值是模拟数据。"],
+    },
+  },
+  {
+    id: "query_data",
+    action: "query",
+    title: {
+      en: "Query Data",
+      zh: "查询数据",
+    },
+    riskPolicy: "readonly",
+    contextNeeds: ["schema", "indexes", "foreignKeys", "databaseDialect"],
+    userInstruction: {
+      en: "Query or aggregate data per the user's request. Confirm structure via the schema or list_tables/get_columns, then call execute_query to run a read-only query and obtain real results, then answer based on the actual data. Do not stop after merely outputting SQL text.",
+      zh: "根据用户请求查询或统计数据。先用 Schema 或 list_tables/get_columns 确认结构，然后调用 execute_query 执行只读查询获取真实结果，最后基于真实结果回答用户。不要只输出 SQL 文本就停止。",
+    },
+    systemRules: {
+      en: ["You MUST obtain real data via the execute_query tool before answering; do not stop at SQL text only.", "If safe execution requirements are not met, explain why first, then provide a read-only preview or a clarifying question."],
+      zh: ["必须通过 execute_query 工具获取真实数据后再回答，不要只生成 SQL 文本。", "如果安全执行条件不满足，先说明原因，再给只读预览或澄清问题。"],
+    },
+    outputContract: {
+      en: ["Output format: lead with a one-sentence conclusion based on real data, then include the SQL used in a ```sql code block. When safe execution is not possible, state the reason and ask one clarifying question."],
+      zh: ["输出格式：先给一句基于真实数据的结论，再附上所用的 SQL（放在 ```sql 代码块中）。无法安全执行时，说明原因并提出一个澄清问题。"],
+    },
+  },
+  {
+    id: "explore_schema",
+    action: "exploreSchema",
+    title: {
+      en: "Inspect Schema",
+      zh: "查看表结构",
+    },
+    riskPolicy: "readonly",
+    contextNeeds: ["schema", "databaseDialect"],
+    userInstruction: {
+      en: "Help the user understand the database or table structure. Prefer the loaded schema context; call list_tables / get_columns for more complete or authoritative definitions, then clearly summarize the structure.",
+      zh: "帮助用户了解数据库或表的结构。优先使用已加载的 Schema 上下文；需要更完整或权威的定义时调用 list_tables / get_columns，然后清晰总结结构。",
+    },
+    systemRules: {
+      en: ["Never invent tables or columns not present in the schema context.", "Use get_columns for authoritative column definitions; do not guess."],
+      zh: ["不要编造 Schema 中不存在的表或列。", "需要权威列定义时使用 get_columns，不要猜测。"],
+    },
+    outputContract: {
+      en: ["Output format: summarize the key structural points first, then list relevant tables/columns and their purpose. If further exploration helps, include a read-only metadata query."],
+      zh: ["输出格式：先概括结构要点，再列出相关表/列及其用途。如需进一步探索，附一个只读元数据查询。"],
+    },
+  },
+  {
+    id: "execute_and_explain",
+    action: "executeAndExplain",
+    title: {
+      en: "Run & Explain",
+      zh: "执行并解释",
+    },
+    riskPolicy: "readonly",
+    contextNeeds: ["currentSql", "schema", "indexes", "foreignKeys", "lastResultPreview", "databaseDialect"],
+    userInstruction: {
+      en: "Execute the current SQL and explain the results. First call execute_query to run the current SQL, then explain the query meaning, data characteristics, and notable points based on the real results.",
+      zh: "执行当前的 SQL 并解释结果。先调用 execute_query 运行当前 SQL，再基于真实结果解释查询含义、数据特征和值得注意的点。",
+    },
+    systemRules: {
+      en: ["Only SELECT/WITH/SHOW/DESCRIBE/EXPLAIN can be executed. If the current SQL is a write operation, do not execute; explain its impact instead.", "Base explanations on real execution results; do not speculate about data."],
+      zh: ["只有 SELECT/WITH/SHOW/DESCRIBE/EXPLAIN 可执行。如果当前 SQL 是写操作，不要执行，改为解释其影响。", "解释要基于真实执行结果，不要凭空推测数据。"],
+    },
+    outputContract: {
+      en: ["Output format: lead with an execution-result summary, then step through the key data and its meaning."],
+      zh: ["输出格式：先给执行结果概要，再逐步解释关键数据和含义。"],
+    },
+  },
+];
+
+export function aiSkillForAction(action: AiAction): AiSkillDefinition {
+  const skill = AI_SKILL_DEFINITIONS.find((item) => item.action === action);
+  if (!skill) throw new Error(`Missing AI skill definition for action: ${action}`);
+  return skill;
+}
diff --git a/apps/desktop/src/lib/ai/aiSqlAppend.ts b/apps/desktop/src/lib/ai/aiSqlAppend.ts
new file mode 100644
index 0000000..11e01ce
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiSqlAppend.ts
@@ -0,0 +1,19 @@
+/**
+ * Build the editor content after appending AI-generated SQL to existing editor SQL.
+ * Preserves the existing editor content exactly and adds only the newline separator
+ * needed to leave a blank line before the appended SQL.
+ */
+export function buildAppendedEditorSql(currentEditorSql: string, newSql: string): string {
+  if (!currentEditorSql) return newSql;
+
+  let separator = "\n\n";
+  if (currentEditorSql.endsWith("\r\n\r\n") || currentEditorSql.endsWith("\n\n")) {
+    separator = "";
+  } else if (currentEditorSql.endsWith("\r\n")) {
+    separator = "\r\n";
+  } else if (currentEditorSql.endsWith("\n")) {
+    separator = "\n";
+  }
+
+  return `${currentEditorSql}${separator}${newSql}`;
+}
diff --git a/apps/desktop/src/lib/ai/aiSqlExecutionPolicy.ts b/apps/desktop/src/lib/ai/aiSqlExecutionPolicy.ts
new file mode 100644
index 0000000..4517d99
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiSqlExecutionPolicy.ts
@@ -0,0 +1,125 @@
+import type { ConnectionConfig } from "@/types/database";
+import { assessProductionSql, productionContextForDatabase } from "@/lib/database/productionSafety";
+import { classifySqlStatementRisk, splitSqlStatementsForSafety, sqlSafetyText } from "@/lib/sql/sqlRisk";
+
+export type ConnectionEnvironment = "production" | "non_production" | "unknown";
+export type AiSqlExecutionAction = "auto_execute" | "confirm" | "block";
+export type AiSqlExecutionCategory = "read" | "low_risk_write" | "write" | "schema_change" | "dangerous" | "unknown";
+
+export interface AiSqlExecutionDecision {
+  action: AiSqlExecutionAction;
+  environment: ConnectionEnvironment;
+  category: AiSqlExecutionCategory;
+  reasons: string[];
+}
+
+const PRODUCTION_RE = /\b(prod|prd|production)\b|生产|正式/i;
+const NON_PRODUCTION_RE = /\b(local|localhost|dev|develop|development|test|testing|stage|staging|sandbox|demo)\b|本地|开发|测试|预发/i;
+const LOCAL_HOST_RE = /^(localhost|127(?:\.\d{1,3}){3}|0\.0\.0\.0|::1)$/i;
+const NEGATIVE_EXECUTION_RE = /(不要|别|不用|禁止|只生成|仅生成|只写|仅写).{0,12}(执行|运行|跑)|do\s+not\s+execute|don't\s+execute|dont\s+execute|without\s+executing|only\s+(generate|write|return)/i;
+
+export function stripAiSqlComments(sql: string): string {
+  return sqlSafetyText(sql);
+}
+
+function sqlStatements(sql: string): string[] {
+  return splitSqlStatementsForSafety(sql);
+}
+
+function classifyStatement(statement: string, connection?: ConnectionConfig): AiSqlExecutionCategory {
+  const risk = classifySqlStatementRisk(statement, { dialect: connection?.db_type });
+  if (risk.risk === "read") return "read";
+  if (risk.risk === "unknown") return "unknown";
+  if (risk.risk === "transaction" || risk.risk === "ddl") {
+    return risk.firstKeyword === "create" ? "schema_change" : "dangerous";
+  }
+  if (risk.firstKeyword === "insert") return "low_risk_write";
+  if (risk.firstKeyword === "update") return isScopedUpdate(statement) ? "low_risk_write" : "dangerous";
+  if (risk.firstKeyword === "delete" || risk.firstKeyword === "merge" || risk.firstKeyword === "replace") return "write";
+  return "unknown";
+}
+
+function isScopedUpdate(statement: string): boolean {
+  const whereMatch = statement.match(/\bWHERE\b([\s\S]*)$/i);
+  if (!whereMatch) return false;
+  const where = whereMatch[1];
+  if (/\b1\s*=\s*1\b|\btrue\b/i.test(where)) return false;
+  return /\b[\w"`.[\]]*(?:id|_id|uuid|key)[\w"`.[\]]*\s*=\s*(?:'[^']+'|"[^"]+"|`[^`]+`|[\w.-]+)/i.test(where);
+}
+
+export function classifyConnectionEnvironment(connection?: ConnectionConfig, database?: string): ConnectionEnvironment {
+  if (!connection) return "unknown";
+  if (productionContextForDatabase(connection, database).active) return "production";
+
+  const parts = [connection.name, connection.host, connection.database, connection.connection_string].filter(Boolean);
+  const signal = parts.join(" ");
+  if (PRODUCTION_RE.test(signal)) return "production";
+  if (LOCAL_HOST_RE.test(connection.host) || NON_PRODUCTION_RE.test(signal)) return "non_production";
+  return "unknown";
+}
+
+export function classifyAiSqlExecution(sql: string, connection?: ConnectionConfig, database?: string): AiSqlExecutionDecision {
+  const environment = classifyConnectionEnvironment(connection, database);
+  const statements = sqlStatements(sql);
+  const reasons: string[] = [];
+
+  if (!statements.length) {
+    return { action: "block", environment, category: "unknown", reasons: ["empty_sql"] };
+  }
+
+  const categories = statements.map((statement) => classifyStatement(statement, connection));
+  const hasMultipleStatements = statements.length > 1;
+  if (hasMultipleStatements) reasons.push("multi_statement");
+  const productionAssessment = assessProductionSql(sql, connection, database);
+
+  if (categories.includes("dangerous")) {
+    return { action: "block", environment, category: "dangerous", reasons };
+  }
+
+  if (categories.includes("unknown")) {
+    return { action: "confirm", environment, category: "unknown", reasons };
+  }
+
+  if (categories.every((category) => category === "read")) {
+    return { action: "auto_execute", environment, category: "read", reasons };
+  }
+
+  if (productionAssessment.active && productionAssessment.isMutation) {
+    reasons.push("production_write");
+    return { action: "confirm", environment: "production", category: categories[0] ?? "unknown", reasons };
+  }
+
+  if (hasMultipleStatements) {
+    return { action: "confirm", environment, category: "write", reasons };
+  }
+
+  const [category] = categories;
+  if (category === "low_risk_write") {
+    return {
+      action: environment === "non_production" ? "auto_execute" : "confirm",
+      environment,
+      category,
+      reasons,
+    };
+  }
+
+  return {
+    action: "confirm",
+    environment,
+    category,
+    reasons,
+  };
+}
+
+export function shouldAttemptAiAutoExecute(instruction: string, action: string): boolean {
+  if (action !== "generate") return false;
+  const normalized = instruction.trim();
+  if (!normalized || NEGATIVE_EXECUTION_RE.test(normalized)) return false;
+  return true;
+}
+
+export function extractFirstSqlCodeBlock(content: string): string | undefined {
+  const match = content.match(/```(?:sql|mysql|postgresql|sqlite|tsql|clickhouse)?\s*\n([\s\S]*?)```/i);
+  const sql = match?.[1]?.trim();
+  return sql || undefined;
+}
diff --git a/apps/desktop/src/lib/ai/aiTableMentions.ts b/apps/desktop/src/lib/ai/aiTableMentions.ts
new file mode 100644
index 0000000..a487be3
--- /dev/null
+++ b/apps/desktop/src/lib/ai/aiTableMentions.ts
@@ -0,0 +1,111 @@
+export interface AiTableMention {
+  raw: string;
+  schema?: string;
+  table: string;
+}
+
+export const AI_TABLE_MENTION_SCHEMA_LIMIT = 8;
+export const AI_TABLE_MENTION_CANDIDATE_LIMIT = 200;
+
+const SIMPLE_IDENTIFIER_RE = /^[\p{L}_][\p{L}\p{N}_$]*$/u;
+
+function isMentionBoundary(char: string | undefined): boolean {
+  return !char || /\s|[([{,;:]/.test(char);
+}
+
+function isUnquotedMentionChar(char: string): boolean {
+  return /[\p{L}\p{N}_$.-]/u.test(char);
+}
+
+function readQuotedSegment(source: string, start: number): { value: string; end: number } | null {
+  const quote = source[start];
+  if (quote !== '"' && quote !== "`") return null;
+  let value = "";
+  for (let i = start + 1; i < source.length; i++) {
+    const char = source[i];
+    if (char === quote) {
+      if (source[i + 1] === quote) {
+        value += quote;
+        i++;
+        continue;
+      }
+      return { value, end: i + 1 };
+    }
+    value += char;
+  }
+  return null;
+}
+
+function readMentionToken(source: string, start: number): { raw: string; parts: string[]; end: number } | null {
+  let i = start;
+  const parts: string[] = [];
+  let raw = "";
+
+  while (i < source.length) {
+    const quoted = readQuotedSegment(source, i);
+    if (quoted) {
+      parts.push(quoted.value);
+      raw += source.slice(i, quoted.end);
+      i = quoted.end;
+    } else {
+      let value = "";
+      const valueStart = i;
+      while (i < source.length && isUnquotedMentionChar(source[i]) && source[i] !== ".") {
+        value += source[i];
+        i++;
+      }
+      if (!value) break;
+      parts.push(value);
+      raw += source.slice(valueStart, i);
+    }
+
+    if (source[i] !== ".") break;
+    raw += ".";
+    i++;
+  }
+
+  const usableParts = parts.filter(Boolean);
+  if (!usableParts.length) return null;
+  return { raw, parts: usableParts, end: i };
+}
+
+export function parseAiTableMentions(text: string): AiTableMention[] {
+  const mentions: AiTableMention[] = [];
+  const seen = new Set<string>();
+
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] !== "@" || !isMentionBoundary(text[i - 1])) continue;
+    const token = readMentionToken(text, i + 1);
+    if (!token) continue;
+
+    const table = token.parts[token.parts.length - 1];
+    const schema = token.parts.length > 1 ? token.parts[token.parts.length - 2] : undefined;
+    const key = `${schema || ""}.${table}`.toLowerCase();
+    if (!seen.has(key)) {
+      seen.add(key);
+      mentions.push({ raw: `@${token.raw}`, schema, table });
+    }
+    i = token.end - 1;
+  }
+
+  return mentions;
+}
+
+export function formatAiTableMention(schema: string | undefined, table: string): string {
+  const parts = [schema, table].filter((part): part is string => !!part);
+  return `@${parts.map(formatMentionPart).join(".")}`;
+}
+
+function formatMentionPart(part: string): string {
+  if (SIMPLE_IDENTIFIER_RE.test(part)) return part;
+  return `"${part.replace(/"/g, '""')}"`;
+}
+
+export function aiTableMentionKey(schema: string | undefined, table: string): string {
+  return `${schema || ""}.${table}`.toLowerCase();
+}
+
+export function filterAiTableMentionCandidates<T extends { name: string }>(candidates: T[], tableFilter: string, limit = AI_TABLE_MENTION_CANDIDATE_LIMIT): T[] {
+  const normalizedFilter = tableFilter.toLowerCase();
+  return candidates.filter((candidate) => !normalizedFilter || candidate.name.toLowerCase().includes(normalizedFilter)).slice(0, limit);
+}
diff --git a/apps/desktop/src/lib/app/appFonts.ts b/apps/desktop/src/lib/app/appFonts.ts
new file mode 100644
index 0000000..47bd758
--- /dev/null
+++ b/apps/desktop/src/lib/app/appFonts.ts
@@ -0,0 +1,6 @@
+export const APP_FONT_SANS_CSS_VAR = "--font-sans";
+
+export const DEFAULT_UI_FONT_FAMILY = `"Geist Variable", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", "Segoe UI", system-ui, sans-serif`;
+
+// Native-feeling UI option without DBX's bundled/brand font at the front of the stack.
+export const SYSTEM_UI_FONT_FAMILY = `system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif`;
diff --git a/apps/desktop/src/lib/app/appTheme.ts b/apps/desktop/src/lib/app/appTheme.ts
new file mode 100644
index 0000000..0fb0ffb
--- /dev/null
+++ b/apps/desktop/src/lib/app/appTheme.ts
@@ -0,0 +1,64 @@
+import type { Theme } from "@tauri-apps/api/window";
+
+export const APP_THEME_STORAGE_KEY = "dbx-theme";
+export const APP_THEME_PALETTE_STORAGE_KEY = "dbx-theme-palette";
+
+export type AppThemeMode = "light" | "dark" | "system";
+export type AppThemeAppearance = "light" | "dark";
+export type AppThemePalette = "pearl" | "mist" | "graphite" | "cobalt" | "sage" | "amber" | "blush" | "vscode" | "idea" | "xcode" | "jetbrains" | "cursor" | "claude";
+
+export type AppThemePaletteOption = {
+  value: AppThemePalette;
+  labelKey: string;
+  className: string | null;
+  previewColor: string;
+};
+
+export const APP_THEME_PALETTES: AppThemePaletteOption[] = [
+  { value: "pearl", labelKey: "settings.themePalettePearl", className: null, previewColor: "#ffffff" },
+  { value: "mist", labelKey: "settings.themePaletteMist", className: "theme-soft", previewColor: "#e4eaf2" },
+  { value: "graphite", labelKey: "settings.themePaletteGraphite", className: "theme-graphite", previewColor: "#d8dce4" },
+  { value: "cobalt", labelKey: "settings.themePaletteCobalt", className: "theme-cobalt", previewColor: "#d8e6f7" },
+  { value: "sage", labelKey: "settings.themePaletteSage", className: "theme-sage", previewColor: "#dbe9e2" },
+  { value: "amber", labelKey: "settings.themePaletteAmber", className: "theme-amber", previewColor: "#f4e4b8" },
+  { value: "blush", labelKey: "settings.themePaletteBlush", className: "theme-blush", previewColor: "#f4d9e6" },
+  { value: "vscode", labelKey: "settings.themePaletteVscode", className: "theme-vscode", previewColor: "#007acc" },
+  { value: "idea", labelKey: "settings.themePaletteIdea", className: "theme-idea", previewColor: "#4b6eaf" },
+  { value: "xcode", labelKey: "settings.themePaletteXcode", className: "theme-xcode", previewColor: "#0a84ff" },
+  { value: "jetbrains", labelKey: "settings.themePaletteJetbrains", className: "theme-jetbrains", previewColor: "#7b61ff" },
+  { value: "cursor", labelKey: "settings.themePaletteCursor", className: "theme-cursor", previewColor: "#6ba4ff" },
+  { value: "claude", labelKey: "settings.themePaletteClaude", className: "theme-claude", previewColor: "#c47a50" },
+];
+
+export const APP_THEME_PALETTE_CLASS_NAMES = APP_THEME_PALETTES.map((palette) => palette.className).filter((className): className is string => Boolean(className));
+
+export function normalizeAppThemeMode(value: string | null): AppThemeMode {
+  if (value === "soft-light") return "light";
+  if (value === "soft-dark") return "dark";
+  if (value === "soft-system") return "system";
+  if (value === "dark" || value === "light" || value === "system") return value;
+  return "light";
+}
+
+export function normalizeAppThemePalette(value: string | null): AppThemePalette {
+  if (value === "mist" || value === "graphite" || value === "cobalt" || value === "sage" || value === "amber" || value === "blush" || value === "vscode" || value === "idea" || value === "xcode" || value === "jetbrains" || value === "cursor" || value === "claude" || value === "pearl") return value;
+  return "pearl";
+}
+
+export function getAppThemePaletteClass(palette: AppThemePalette): string | null {
+  return APP_THEME_PALETTES.find((option) => option.value === palette)?.className ?? null;
+}
+
+export function isSystemAppThemeMode(mode: AppThemeMode): boolean {
+  return mode === "system";
+}
+
+export function resolveAppThemeAppearance(mode: AppThemeMode, systemPrefersDark: boolean): AppThemeAppearance {
+  if (isSystemAppThemeMode(mode)) return systemPrefersDark ? "dark" : "light";
+  return mode === "dark" ? "dark" : "light";
+}
+
+export function getTauriThemeForMode(mode: AppThemeMode): Theme | null {
+  if (isSystemAppThemeMode(mode)) return null;
+  return resolveAppThemeAppearance(mode, false);
+}
diff --git a/apps/desktop/src/lib/app/documentStoreProvider.ts b/apps/desktop/src/lib/app/documentStoreProvider.ts
new file mode 100644
index 0000000..e9de31e
--- /dev/null
+++ b/apps/desktop/src/lib/app/documentStoreProvider.ts
@@ -0,0 +1,376 @@
+import type { ComposerTranslation } from "vue-i18n";
+import type { DatabaseType } from "@/types/database";
+import { quoteUnquotedObjectKeys } from "@/lib/mongo/mongoShellCommand";
+import { formatMongoShellLiteral } from "@/lib/mongo/mongoDocumentValues";
+
+export type DocumentStoreKind = "mongodb" | "elasticsearch";
+export type DocumentFilterMode = "equals" | "not-equals" | "like" | "not-like" | "greater-than" | "less-than" | "is-null" | "is-not-null";
+
+export type DocumentFilterRule = {
+  id: string;
+  fieldName: string;
+  mode: DocumentFilterMode;
+  rawValue: string;
+  conjunction: "AND" | "OR";
+};
+
+export type DocumentStoreQueryPreviewOptions = {
+  collection: string;
+  filterJson?: string;
+  sortJson?: string;
+  skip: number;
+  limit: number;
+};
+
+export type DocumentStoreProvider = {
+  kind: DocumentStoreKind;
+  filterInputLabel: string;
+  sortInputLabel: string;
+  documentsLabel(options: { total: number; t: ComposerTranslation }): string;
+  queryPreview(options: DocumentStoreQueryPreviewOptions): string;
+  sortInputForColumn(column: string, direction: "asc" | "desc" | null): string;
+};
+
+export const documentFilterModeOptions: Array<{ value: DocumentFilterMode; labelKey: string }> = [
+  { value: "equals", labelKey: "grid.filterBuilderEquals" },
+  { value: "not-equals", labelKey: "grid.filterBuilderNotEquals" },
+  { value: "like", labelKey: "grid.filterBuilderContains" },
+  { value: "not-like", labelKey: "grid.filterBuilderNotContains" },
+  { value: "greater-than", labelKey: "grid.filterBuilderGreaterThan" },
+  { value: "less-than", labelKey: "grid.filterBuilderLessThan" },
+  { value: "is-null", labelKey: "grid.filterBuilderIsNull" },
+  { value: "is-not-null", labelKey: "grid.filterBuilderIsNotNull" },
+];
+
+const mongoDocumentProvider: DocumentStoreProvider = {
+  kind: "mongodb",
+  filterInputLabel: "find",
+  sortInputLabel: "sort",
+  documentsLabel: ({ total, t }) => t("mongo.documents", { count: total }),
+  queryPreview: ({ collection, filterJson, sortJson, skip, limit }) => {
+    const collectionRef = `db.getCollection(${JSON.stringify(collection)})`;
+    const parts = [`${collectionRef}.find(${mongoShellPreviewLiteral(filterJson || "{}")})`];
+    if (sortJson?.trim()) parts.push(`.sort(${mongoShellPreviewLiteral(sortJson)})`);
+    parts.push(`.skip(${skip}).limit(${limit})`);
+    return parts.join("");
+  },
+  sortInputForColumn: (column, direction) => (direction ? JSON.stringify({ [column]: direction === "asc" ? 1 : -1 }) : ""),
+};
+
+function mongoShellPreviewLiteral(json: string): string {
+  const trimmed = json.trim();
+  if (!trimmed) return "{}";
+  try {
+    return formatMongoShellLiteral(JSON.parse(trimmed));
+  } catch {
+    return trimmed;
+  }
+}
+
+const elasticsearchDocumentProvider: DocumentStoreProvider = {
+  kind: "elasticsearch",
+  filterInputLabel: "filter",
+  sortInputLabel: "sort",
+  documentsLabel: () => "Documents",
+  queryPreview: ({ collection, filterJson, sortJson, skip, limit }) => {
+    const body = safeElasticsearchSearchBodyFromDocumentQuery({ filterJson, sortJson, skip, limit });
+    return `POST /${collection}/_search\n${JSON.stringify(body, null, 2)}`;
+  },
+  sortInputForColumn: mongoDocumentProvider.sortInputForColumn,
+};
+
+export function documentStoreProviderFor(databaseType?: DatabaseType): DocumentStoreProvider {
+  return databaseType === "elasticsearch" ? elasticsearchDocumentProvider : mongoDocumentProvider;
+}
+
+export function defaultDocumentFilterRule(id: string, fieldName = ""): DocumentFilterRule {
+  return {
+    id,
+    fieldName,
+    mode: "equals",
+    rawValue: "",
+    conjunction: "AND",
+  };
+}
+
+export function documentFilterModeNeedsValue(mode: DocumentFilterMode): boolean {
+  return mode !== "is-null" && mode !== "is-not-null";
+}
+
+type DocumentFilterParseOptions = {
+  kind?: DocumentStoreKind;
+};
+
+export function buildDocumentFilterCondition(rule: DocumentFilterRule, options: DocumentFilterParseOptions = {}): Record<string, unknown> | null {
+  if (!rule.fieldName) return null;
+  if (documentFilterModeNeedsValue(rule.mode) && !rule.rawValue.trim()) return null;
+  const value = documentFilterModeNeedsValue(rule.mode) ? parseDocumentFilterValue(rule.rawValue, options) : null;
+  const textValue = documentFilterModeNeedsValue(rule.mode) ? String(parseDocumentFilterValue(rule.rawValue)) : "";
+  switch (rule.mode) {
+    case "equals":
+      return { [rule.fieldName]: value };
+    case "not-equals":
+      return { [rule.fieldName]: { $ne: value } };
+    case "like":
+      return { [rule.fieldName]: { $regex: textValue, $options: "i" } };
+    case "not-like":
+      return { [rule.fieldName]: { $not: { $regex: textValue, $options: "i" } } };
+    case "greater-than":
+      return { [rule.fieldName]: { $gt: value } };
+    case "less-than":
+      return { [rule.fieldName]: { $lt: value } };
+    case "is-null":
+      return { [rule.fieldName]: null };
+    case "is-not-null":
+      return { [rule.fieldName]: { $ne: null } };
+  }
+}
+
+export function combineDocumentFilterConditions(conditions: Record<string, unknown>[], rules: Pick<DocumentFilterRule, "conjunction">[]): Record<string, unknown> | null {
+  if (conditions.length === 0) return null;
+  let result = conditions[0];
+  for (let i = 1; i < conditions.length; i++) {
+    const operator = rules[i]?.conjunction === "OR" ? "$or" : "$and";
+    result = { [operator]: [result, conditions[i]] };
+  }
+  return result;
+}
+
+const MAX_SAFE_BIGINT = 9007199254740991n;
+const MIN_BSON_INT64 = -9223372036854775808n;
+const MAX_BSON_INT64 = 9223372036854775807n;
+
+function parseJsonPreservingLargeIntegers(json: string, options: DocumentFilterParseOptions = {}): unknown {
+  return JSON.parse(rewriteUnsafeIntegerTokens(json, options));
+}
+
+function rewriteUnsafeIntegerTokens(json: string, options: DocumentFilterParseOptions): string {
+  let output = "";
+  let i = 0;
+  while (i < json.length) {
+    const ch = json[i];
+    if (ch === '"') {
+      const start = i;
+      i++;
+      while (i < json.length) {
+        const current = json[i++];
+        if (current === "\\") {
+          i++;
+        } else if (current === '"') {
+          break;
+        }
+      }
+      output += json.slice(start, i);
+      continue;
+    }
+
+    if (ch === "-" || isDigit(ch)) {
+      const start = i;
+      let end = i;
+      if (json[end] === "-") end++;
+      if (!isDigit(json[end])) {
+        output += ch;
+        i++;
+        continue;
+      }
+
+      if (json[end] === "0") {
+        end++;
+      } else {
+        while (isDigit(json[end])) end++;
+      }
+
+      let decimalOrExponent = false;
+      if (json[end] === ".") {
+        decimalOrExponent = true;
+        end++;
+        while (isDigit(json[end])) end++;
+      }
+      if (json[end] === "e" || json[end] === "E") {
+        decimalOrExponent = true;
+        end++;
+        if (json[end] === "+" || json[end] === "-") end++;
+        while (isDigit(json[end])) end++;
+      }
+
+      const token = json.slice(start, end);
+      if (!decimalOrExponent) {
+        try {
+          const n = BigInt(token);
+          if (n > MAX_SAFE_BIGINT || n < -MAX_SAFE_BIGINT) {
+            output += unsafeIntegerReplacement(token, n, options);
+            i = end;
+            continue;
+          }
+        } catch {
+          /* not a valid integer */
+        }
+      }
+
+      output += token;
+      i = end;
+      continue;
+    }
+
+    output += ch;
+    i++;
+  }
+  return output;
+}
+
+function unsafeIntegerReplacement(token: string, value: bigint, options: DocumentFilterParseOptions): string {
+  if (options.kind === "mongodb" && value >= MIN_BSON_INT64 && value <= MAX_BSON_INT64) {
+    // MongoDB int64 filters must use Extended JSON so JS Number never rounds snowflake-style IDs.
+    return `{"$numberLong":${JSON.stringify(token)}}`;
+  }
+  return JSON.stringify(token);
+}
+
+function isDigit(value: string | undefined): boolean {
+  return value !== undefined && value >= "0" && value <= "9";
+}
+
+export function parseDocumentFilterInput(input: string, options: DocumentFilterParseOptions = {}): Record<string, unknown> {
+  const trimmed = input.trim();
+  if (!trimmed) return {};
+  const safe = quoteUnquotedObjectKeys(trimmed);
+  const parsed = parseJsonPreservingLargeIntegers(safe, options);
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? (parsed as Record<string, unknown>) : {};
+}
+
+export function currentDocumentFilterJson(input: string, structured: Record<string, unknown> | null, kind?: DocumentStoreKind): string | undefined {
+  const manual = parseDocumentFilterInput(input, { kind });
+  const filter = structured ? (Object.keys(manual).length ? { $and: [manual, structured] } : structured) : manual;
+  return Object.keys(filter).length ? JSON.stringify(filter) : undefined;
+}
+
+export function currentDocumentSortJson(input: string): string | undefined {
+  const sort = parseDocumentFilterInput(input);
+  return Object.keys(sort).length ? JSON.stringify(sort) : undefined;
+}
+
+function parseDocumentFilterValue(raw: string, options: DocumentFilterParseOptions = {}): unknown {
+  const trimmed = raw.trim();
+  if (!trimmed) return "";
+  try {
+    return parseJsonPreservingLargeIntegers(trimmed, options);
+  } catch {
+    return trimmed;
+  }
+}
+
+export function elasticsearchSearchBodyFromDocumentQuery(options: Pick<DocumentStoreQueryPreviewOptions, "filterJson" | "sortJson" | "skip" | "limit">): Record<string, unknown> {
+  const body: Record<string, unknown> = {
+    from: options.skip,
+    size: options.limit,
+  };
+  const query = elasticsearchQueryFromDocumentFilter(options.filterJson);
+  if (query) body.query = query;
+  body.sort = elasticsearchSortFromDocumentSort(options.sortJson);
+  return body;
+}
+
+function safeElasticsearchSearchBodyFromDocumentQuery(options: Pick<DocumentStoreQueryPreviewOptions, "filterJson" | "sortJson" | "skip" | "limit">): Record<string, unknown> {
+  try {
+    return elasticsearchSearchBodyFromDocumentQuery(options);
+  } catch {
+    return {
+      from: options.skip,
+      size: options.limit,
+      sort: ["_doc"],
+    };
+  }
+}
+
+function elasticsearchQueryFromDocumentFilter(filterJson?: string): Record<string, unknown> | null {
+  const trimmed = filterJson?.trim();
+  if (!trimmed || trimmed === "{}") return null;
+  const parsed = JSON.parse(trimmed);
+  if (!isPlainRecord(parsed) || Object.keys(parsed).length === 0) return null;
+  return translateDocumentFilterToElasticsearchQuery(parsed);
+}
+
+function translateDocumentFilterToElasticsearchQuery(filter: Record<string, unknown>): Record<string, unknown> {
+  const filters: Record<string, unknown>[] = [];
+  for (const [key, value] of Object.entries(filter)) {
+    if (key === "$and") {
+      filters.push(...translateLogicalArrayToElasticsearch("$and", value));
+    } else if (key === "$or") {
+      const should = translateLogicalArrayToElasticsearch("$or", value);
+      if (should.length > 0) filters.push({ bool: { should, minimum_should_match: 1 } });
+    } else {
+      filters.push(translateFieldFilterToElasticsearchQuery(key, value));
+    }
+  }
+  if (filters.length === 1) return filters[0];
+  return { bool: { filter: filters } };
+}
+
+function translateLogicalArrayToElasticsearch(operator: "$and" | "$or", value: unknown): Record<string, unknown>[] {
+  if (!Array.isArray(value)) throw new Error(`${operator} must be an array`);
+  return value.filter(isPlainRecord).map(translateDocumentFilterToElasticsearchQuery);
+}
+
+function translateFieldFilterToElasticsearchQuery(field: string, value: unknown): Record<string, unknown> {
+  if (!isPlainRecord(value) || !Object.keys(value).some((key) => key.startsWith("$"))) {
+    return termOrNullQuery(field, value);
+  }
+
+  const filter: Record<string, unknown>[] = [];
+  const mustNot: Record<string, unknown>[] = [];
+  const range: Record<string, unknown> = {};
+  for (const [operator, operatorValue] of Object.entries(value)) {
+    if (operator === "$options") continue;
+    if (operator === "$ne") {
+      if (operatorValue === null) filter.push({ exists: { field } });
+      else mustNot.push({ term: { [field]: operatorValue } });
+    } else if (operator === "$gt" || operator === "$gte" || operator === "$lt" || operator === "$lte") {
+      range[operator.slice(1)] = operatorValue;
+    } else if (operator === "$regex") {
+      filter.push(wildcardQuery(field, operatorValue, value.$options));
+    } else if (operator === "$not") {
+      if (isPlainRecord(operatorValue) && "$regex" in operatorValue) {
+        mustNot.push(wildcardQuery(field, operatorValue.$regex, operatorValue.$options ?? value.$options));
+      }
+    }
+  }
+  if (Object.keys(range).length > 0) filter.push({ range: { [field]: range } });
+  if (filter.length === 1 && mustNot.length === 0) return filter[0];
+  if (filter.length === 0 && mustNot.length > 0) return { bool: { must_not: mustNot } };
+  const bool: Record<string, unknown> = {};
+  if (filter.length > 0) bool.filter = filter;
+  if (mustNot.length > 0) bool.must_not = mustNot;
+  return { bool };
+}
+
+function termOrNullQuery(field: string, value: unknown): Record<string, unknown> {
+  if (value === null) return { bool: { must_not: [{ exists: { field } }] } };
+  return { term: { [field]: value } };
+}
+
+function wildcardQuery(field: string, value: unknown, options: unknown): Record<string, unknown> {
+  const pattern = String(value ?? "");
+  const wildcard = pattern.startsWith("*") || pattern.endsWith("*") ? pattern : `*${pattern}*`;
+  return {
+    wildcard: {
+      [field]: {
+        value: wildcard,
+        case_insensitive: typeof options === "string" && options.toLowerCase().includes("i"),
+      },
+    },
+  };
+}
+
+function elasticsearchSortFromDocumentSort(sortJson?: string): unknown[] {
+  const trimmed = sortJson?.trim();
+  if (!trimmed || trimmed === "{}") return ["_doc"];
+  const parsed = JSON.parse(trimmed);
+  if (!isPlainRecord(parsed)) return ["_doc"];
+  return Object.entries(parsed).map(([field, direction]) => ({
+    [field]: { order: direction === -1 || (typeof direction === "string" && direction.toLowerCase() === "desc") ? "desc" : "asc" },
+  }));
+}
+
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
diff --git a/apps/desktop/src/lib/app/localeOptions.ts b/apps/desktop/src/lib/app/localeOptions.ts
new file mode 100644
index 0000000..50bce54
--- /dev/null
+++ b/apps/desktop/src/lib/app/localeOptions.ts
@@ -0,0 +1,11 @@
+import type { Locale } from "@/i18n";
+
+export const LOCALE_OPTIONS: { value: Locale; flag: string; label: string }[] = [
+  { value: "en", flag: "🇺🇸", label: "English" },
+  { value: "es", flag: "🇪🇸", label: "Español" },
+  { value: "it", flag: "🇮🇹", label: "Italiano" },
+  { value: "ja", flag: "🇯🇵", label: "日本語" },
+  { value: "pt-BR", flag: "🇧🇷", label: "Português" },
+  { value: "zh-CN", flag: "🇨🇳", label: "简体中文" },
+  { value: "zh-TW", flag: "繁", label: "繁體中文" },
+];
diff --git a/apps/desktop/src/lib/app/openTabsPersistence.ts b/apps/desktop/src/lib/app/openTabsPersistence.ts
new file mode 100644
index 0000000..ae089d4
--- /dev/null
+++ b/apps/desktop/src/lib/app/openTabsPersistence.ts
@@ -0,0 +1,199 @@
+import type { QueryTab } from "@/types/database";
+
+export const OPEN_TABS_STORAGE_KEY = "dbx-open-tabs";
+export const ACTIVE_TAB_STORAGE_KEY = "dbx-active-tab";
+
+export interface SavedQueryResultRun {
+  id: string;
+  title: string;
+  sequence: number;
+  sql: string;
+  createdAt: number;
+  activeResultIndex?: number;
+  resultCacheKey?: string;
+  resultEvicted?: boolean;
+}
+
+export interface SavedOpenTab {
+  id: string;
+  title: string;
+  customTitle?: boolean;
+  connectionId: string;
+  database: string;
+  schema?: string;
+  sql: string;
+  savedSqlId?: string;
+  externalSqlPath?: string;
+  lastExecutedSql?: string;
+  resultBaseSql?: string;
+  resultSortedSql?: string;
+  resultSortColumn?: string;
+  resultSortColumnIndex?: number;
+  resultSortDirection?: QueryTab["resultSortDirection"];
+  resultSortMode?: QueryTab["resultSortMode"];
+  orderByInput?: string;
+  resultPageLimit?: number;
+  resultPageOffset?: number;
+  whereInput?: string;
+  pinned?: boolean;
+  mode?: QueryTab["mode"];
+  mqTenant?: string;
+  mqInitialTab?: QueryTab["mqInitialTab"];
+  nacosNamespace?: string;
+  nacosNamespaceName?: string;
+  structureTableName?: string;
+  objectBrowser?: QueryTab["objectBrowser"];
+  objectSource?: QueryTab["objectSource"];
+  tableMeta?: QueryTab["tableMeta"];
+  mongoEditTarget?: QueryTab["mongoEditTarget"];
+  resultEvicted?: boolean;
+  resultCacheKey?: string;
+  resultRuns?: SavedQueryResultRun[];
+  activeResultRunId?: string;
+  resultAutoSave?: boolean;
+}
+
+export interface RestoredOpenTabs {
+  tabs: QueryTab[];
+  activeTabId: string | null;
+}
+
+export type OpenTabsRestoreFilter = "all" | "pinned";
+
+function shouldPersistTabSql(tab: QueryTab) {
+  if (!tab.savedSqlId) return true;
+  return tab.originalSql !== undefined && tab.sql !== tab.originalSql;
+}
+
+function restoredOriginalSql(tab: SavedOpenTab, mode: QueryTab["mode"], sql: string) {
+  if (mode !== "query") return undefined;
+  if (tab.externalSqlPath) return sql;
+  if (tab.savedSqlId) return sql ? "" : undefined;
+  return "";
+}
+
+export function serializeOpenTabs(tabs: QueryTab[]): SavedOpenTab[] {
+  return tabs.map((tab) => ({
+    id: tab.id,
+    title: tab.title,
+    ...(tab.customTitle ? { customTitle: true } : {}),
+    connectionId: tab.connectionId,
+    database: tab.database,
+    schema: tab.schema,
+    sql: shouldPersistTabSql(tab) ? tab.sql : "",
+    savedSqlId: tab.savedSqlId,
+    externalSqlPath: tab.externalSqlPath,
+    ...(tab.lastExecutedSql !== undefined ? { lastExecutedSql: tab.lastExecutedSql } : {}),
+    ...(tab.resultBaseSql !== undefined ? { resultBaseSql: tab.resultBaseSql } : {}),
+    ...(tab.resultSortedSql !== undefined ? { resultSortedSql: tab.resultSortedSql } : {}),
+    ...(tab.resultSortColumn !== undefined ? { resultSortColumn: tab.resultSortColumn } : {}),
+    ...(tab.resultSortColumnIndex !== undefined ? { resultSortColumnIndex: tab.resultSortColumnIndex } : {}),
+    ...(tab.resultSortDirection !== undefined ? { resultSortDirection: tab.resultSortDirection } : {}),
+    ...(tab.resultSortMode !== undefined ? { resultSortMode: tab.resultSortMode } : {}),
+    ...(tab.orderByInput !== undefined ? { orderByInput: tab.orderByInput } : {}),
+    ...(tab.resultPageLimit !== undefined ? { resultPageLimit: tab.resultPageLimit } : {}),
+    ...(tab.resultPageOffset !== undefined ? { resultPageOffset: tab.resultPageOffset } : {}),
+    ...(tab.whereInput !== undefined ? { whereInput: tab.whereInput } : {}),
+    pinned: tab.pinned,
+    mode: tab.mode,
+    ...(tab.mqTenant !== undefined ? { mqTenant: tab.mqTenant } : {}),
+    ...(tab.mqInitialTab !== undefined ? { mqInitialTab: tab.mqInitialTab } : {}),
+    ...(tab.nacosNamespace !== undefined ? { nacosNamespace: tab.nacosNamespace } : {}),
+    ...(tab.nacosNamespaceName !== undefined ? { nacosNamespaceName: tab.nacosNamespaceName } : {}),
+    ...(tab.structureTableName !== undefined ? { structureTableName: tab.structureTableName } : {}),
+    objectBrowser: tab.objectBrowser,
+    objectSource: tab.objectSource,
+    tableMeta: tab.tableMeta,
+    ...(tab.mongoEditTarget !== undefined ? { mongoEditTarget: tab.mongoEditTarget } : {}),
+    ...(tab.mode !== "data" && tab.resultEvicted ? { resultEvicted: true } : {}),
+    ...(tab.mode !== "data" && tab.resultEvicted && tab.resultCacheKey !== undefined ? { resultCacheKey: tab.resultCacheKey } : {}),
+    ...(tab.mode === "query" && tab.resultRuns?.length
+      ? {
+          resultRuns: tab.resultRuns.map((run) => ({
+            id: run.id,
+            title: run.title,
+            sequence: run.sequence,
+            sql: run.sql,
+            createdAt: run.createdAt,
+            activeResultIndex: run.activeResultIndex,
+            ...(run.resultCacheKey !== undefined ? { resultCacheKey: run.resultCacheKey } : {}),
+            ...(run.resultEvicted ? { resultEvicted: true } : {}),
+          })),
+        }
+      : {}),
+    ...(tab.mode === "query" && tab.activeResultRunId !== undefined ? { activeResultRunId: tab.activeResultRunId } : {}),
+    ...(tab.mode === "query" && tab.resultAutoSave ? { resultAutoSave: true } : {}),
+  }));
+}
+
+function isSavedOpenTab(value: unknown): value is SavedOpenTab {
+  if (!value || typeof value !== "object") return false;
+  const tab = value as Record<string, unknown>;
+  return typeof tab.id === "string" && typeof tab.title === "string" && typeof tab.connectionId === "string" && typeof tab.database === "string" && (typeof tab.sql === "string" || typeof tab.savedSqlId === "string");
+}
+
+function restoreOpenTabsArray(parsed: unknown, rawActiveTabId: string | null, options: { queryOnly?: boolean; filter?: OpenTabsRestoreFilter } = {}): RestoredOpenTabs {
+  if (!Array.isArray(parsed)) return { tabs: [], activeTabId: null };
+
+  try {
+    const saved = parsed.filter(isSavedOpenTab);
+    const filtered = saved.filter((tab) => {
+      if (options.queryOnly && (tab.mode ?? "query") !== "query") return false;
+      if (options.filter === "pinned" && !tab.pinned) return false;
+      return true;
+    });
+    const tabs: QueryTab[] = filtered.map((tab) => {
+      const mode = tab.mode ?? "query";
+      const resultRuns =
+        mode === "query"
+          ? tab.resultRuns?.map((run) => ({
+              ...run,
+              result: undefined,
+              results: undefined,
+              resultCacheState: run.resultCacheKey ? ("disk" as const) : undefined,
+            }))
+          : undefined;
+      return {
+        ...tab,
+        mode,
+        sql: typeof tab.sql === "string" ? tab.sql : "",
+        isExecuting: false,
+        isCancelling: false,
+        queryExecutionStartedAt: undefined,
+        editorViewport: undefined,
+        editorSelection: undefined,
+        isExplaining: false,
+        originalSql: restoredOriginalSql(tab, mode, typeof tab.sql === "string" ? tab.sql : ""),
+        resultEvicted: mode === "data" ? undefined : tab.resultEvicted,
+        resultCacheKey: mode === "data" ? undefined : tab.resultCacheKey,
+        resultCacheState: mode !== "data" && tab.resultCacheKey ? "disk" : undefined,
+        resultRuns,
+        activeResultRunId: resultRuns?.some((run) => run.id === tab.activeResultRunId) ? tab.activeResultRunId : resultRuns?.[0]?.id,
+        resultAutoSave: mode === "query" && tab.resultAutoSave ? true : undefined,
+      };
+    });
+    const activeTabId = rawActiveTabId || null;
+
+    return {
+      tabs,
+      activeTabId: tabs.some((tab) => tab.id === activeTabId) ? activeTabId : tabs[0]?.id || null,
+    };
+  } catch {
+    return { tabs: [], activeTabId: null };
+  }
+}
+
+export function restoreOpenTabsPayload(payload: { tabs?: unknown; activeTabId?: unknown } | null | undefined, options: { queryOnly?: boolean; filter?: OpenTabsRestoreFilter } = {}): RestoredOpenTabs {
+  if (!payload) return { tabs: [], activeTabId: null };
+  return restoreOpenTabsArray(payload.tabs, typeof payload.activeTabId === "string" ? payload.activeTabId : null, options);
+}
+
+export function restoreOpenTabsState(rawTabs: string | null, rawActiveTabId: string | null, options: { queryOnly?: boolean; filter?: OpenTabsRestoreFilter } = {}): RestoredOpenTabs {
+  if (!rawTabs) return { tabs: [], activeTabId: null };
+
+  try {
+    return restoreOpenTabsArray(JSON.parse(rawTabs), rawActiveTabId, options);
+  } catch {
+    return { tabs: [], activeTabId: null };
+  }
+}
diff --git a/apps/desktop/src/lib/app/pinnedItems.ts b/apps/desktop/src/lib/app/pinnedItems.ts
new file mode 100644
index 0000000..2e6dc6a
--- /dev/null
+++ b/apps/desktop/src/lib/app/pinnedItems.ts
@@ -0,0 +1,54 @@
+import type { TreeNode } from "@/types/database";
+
+export type PinnedTreeNodeUpdateScope = "missing" | "root" | "siblings";
+
+export function orderPinnedFirst<T>(items: T[], isPinned: (item: T) => boolean): T[] {
+  const pinned: T[] = [];
+  const unpinned: T[] = [];
+
+  for (const item of items) {
+    if (isPinned(item)) pinned.push(item);
+    else unpinned.push(item);
+  }
+
+  return [...pinned, ...unpinned];
+}
+
+function findTreeNodeLocation(nodes: TreeNode[], id: string, parent: TreeNode | null = null): { node: TreeNode; parent: TreeNode | null } | null {
+  for (const node of nodes) {
+    if (node.id === id) return { node, parent };
+    if (node.children) {
+      const found = findTreeNodeLocation(node.children, id, node);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+
+export function updatePinnedTreeNodeInPlace(nodes: TreeNode[], id: string, pinned: boolean): PinnedTreeNodeUpdateScope {
+  const location = findTreeNodeLocation(nodes, id);
+  if (!location) return "missing";
+
+  location.node.pinned = pinned;
+  const siblings = location.parent?.children ?? nodes;
+  const ordered = orderPinnedFirst(siblings, (node) => !!node.pinned);
+
+  if (location.parent) {
+    location.parent.children = ordered;
+    return "siblings";
+  }
+
+  nodes.splice(0, nodes.length, ...ordered);
+  return "root";
+}
+
+export function applyPinnedTreeNodeState(nodes: TreeNode[], pinnedIds: Set<string>): TreeNode[] {
+  return orderPinnedFirst(
+    nodes.map((node) => ({
+      ...node,
+      pinned: pinnedIds.has(node.id),
+      children: node.children ? applyPinnedTreeNodeState(node.children, pinnedIds) : node.children,
+    })),
+    (node) => !!node.pinned,
+  );
+}
diff --git a/apps/desktop/src/lib/app/pinnedTreeNodeIds.ts b/apps/desktop/src/lib/app/pinnedTreeNodeIds.ts
new file mode 100644
index 0000000..f2f267f
--- /dev/null
+++ b/apps/desktop/src/lib/app/pinnedTreeNodeIds.ts
@@ -0,0 +1,10 @@
+export function prunePinnedTreeNodeIdsForConnection(ids: Set<string>, connectionId: string): Set<string> {
+  const next = new Set<string>();
+  const prefix = `${connectionId}:`;
+  for (const id of ids) {
+    if (id === connectionId) continue;
+    if (id.startsWith(prefix)) continue;
+    next.add(id);
+  }
+  return next;
+}
diff --git a/apps/desktop/src/lib/app/savedSqlEditorPosition.ts b/apps/desktop/src/lib/app/savedSqlEditorPosition.ts
new file mode 100644
index 0000000..f69c002
--- /dev/null
+++ b/apps/desktop/src/lib/app/savedSqlEditorPosition.ts
@@ -0,0 +1,215 @@
+import * as api from "@/lib/backend/api";
+import { safeLocalStorageGet, safeLocalStorageRemove } from "@/lib/backend/safeStorage";
+
+export const SAVED_SQL_EDITOR_POSITIONS_STORAGE_KEY = "dbx-saved-sql-editor-positions";
+
+const MAX_SAVED_SQL_EDITOR_POSITIONS = 200;
+const ANCHOR_CONTEXT_CHARS = 80;
+
+export interface SavedSqlEditorSelection {
+  anchor: number;
+  head: number;
+}
+
+export interface SavedSqlEditorViewport {
+  scrollTop: number;
+  scrollLeft: number;
+}
+
+export interface SavedSqlEditorPosition {
+  savedSqlId: string;
+  selection: SavedSqlEditorSelection;
+  viewport?: SavedSqlEditorViewport;
+  anchor: {
+    before: string;
+    after: string;
+    head: number;
+    docLength: number;
+  };
+  updatedAt: number;
+}
+
+function clampOffset(value: number, docLength: number) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.min(Math.max(0, Math.trunc(value)), docLength);
+}
+
+function normalizeSelection(selection: SavedSqlEditorSelection | undefined, docLength: number): SavedSqlEditorSelection {
+  return {
+    anchor: clampOffset(selection?.anchor ?? selection?.head ?? 0, docLength),
+    head: clampOffset(selection?.head ?? selection?.anchor ?? 0, docLength),
+  };
+}
+
+function normalizeViewport(viewport: SavedSqlEditorViewport | undefined): SavedSqlEditorViewport | undefined {
+  if (!viewport) return undefined;
+  return {
+    scrollTop: Math.max(0, Number.isFinite(viewport.scrollTop) ? viewport.scrollTop : 0),
+    scrollLeft: Math.max(0, Number.isFinite(viewport.scrollLeft) ? viewport.scrollLeft : 0),
+  };
+}
+
+function findClosestOccurrence(text: string, query: string, target: number): number | null {
+  if (!query) return null;
+  let best: number | null = null;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  let from = 0;
+  while (from <= text.length) {
+    const index = text.indexOf(query, from);
+    if (index < 0) break;
+    const distance = Math.abs(index - target);
+    if (distance < bestDistance) {
+      best = index;
+      bestDistance = distance;
+    }
+    from = index + 1;
+  }
+  return best;
+}
+
+function restoredHeadFromAnchor(position: SavedSqlEditorPosition, sql: string): number {
+  const targetHead = clampOffset(position.anchor.head, sql.length);
+  const before = position.anchor.before;
+  const after = position.anchor.after;
+  const combined = `${before}${after}`;
+  if (combined) {
+    const combinedIndex = findClosestOccurrence(sql, combined, Math.max(0, targetHead - before.length));
+    if (combinedIndex !== null) return clampOffset(combinedIndex + before.length, sql.length);
+  }
+
+  const beforeIndex = findClosestOccurrence(sql, before, Math.max(0, targetHead - before.length));
+  if (beforeIndex !== null) return clampOffset(beforeIndex + before.length, sql.length);
+
+  const afterIndex = findClosestOccurrence(sql, after, targetHead);
+  if (afterIndex !== null) return clampOffset(afterIndex, sql.length);
+
+  return targetHead;
+}
+
+function normalizeSavedPositions(value: unknown): SavedSqlEditorPosition[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item): item is SavedSqlEditorPosition => {
+    return (
+      !!item &&
+      typeof item === "object" &&
+      typeof item.savedSqlId === "string" &&
+      !!item.selection &&
+      typeof item.selection.anchor === "number" &&
+      typeof item.selection.head === "number" &&
+      !!item.anchor &&
+      typeof item.anchor.before === "string" &&
+      typeof item.anchor.after === "string" &&
+      typeof item.anchor.head === "number" &&
+      typeof item.anchor.docLength === "number" &&
+      typeof item.updatedAt === "number"
+    );
+  });
+}
+
+function parseLegacySavedPositions(): SavedSqlEditorPosition[] {
+  const raw = safeLocalStorageGet(SAVED_SQL_EDITOR_POSITIONS_STORAGE_KEY);
+  if (!raw) return [];
+  try {
+    return normalizeSavedPositions(JSON.parse(raw));
+  } catch {
+    return [];
+  }
+}
+
+let savedPositions: SavedSqlEditorPosition[] = [];
+let savedPositionsLoaded = false;
+let savedPositionsInitPromise: Promise<void> | undefined;
+
+export async function initSavedSqlEditorPositions() {
+  if (savedPositionsLoaded) return;
+  if (savedPositionsInitPromise) return savedPositionsInitPromise;
+
+  savedPositionsInitPromise = (async () => {
+    const storedValue = await api.loadSavedSqlEditorPositions().catch(() => null);
+    if (Array.isArray(storedValue)) {
+      savedPositions = normalizeSavedPositions(storedValue);
+      return;
+    }
+
+    const legacy = parseLegacySavedPositions();
+    if (legacy.length > 0) {
+      savedPositions = legacy;
+      try {
+        await api.saveSavedSqlEditorPositions(trimSavedPositions(legacy));
+        // Remove the synchronous startup payload only after the async store
+        // accepts the migrated positions.
+        safeLocalStorageRemove(SAVED_SQL_EDITOR_POSITIONS_STORAGE_KEY);
+      } catch {
+        /* keep legacy values for a later migration attempt */
+      }
+    }
+  })().finally(() => {
+    savedPositionsLoaded = true;
+    savedPositionsInitPromise = undefined;
+  });
+
+  return savedPositionsInitPromise;
+}
+
+function readSavedPositions(): SavedSqlEditorPosition[] {
+  return savedPositions;
+}
+
+function trimSavedPositions(positions: SavedSqlEditorPosition[]) {
+  return [...positions].sort((a, b) => b.updatedAt - a.updatedAt).slice(0, MAX_SAVED_SQL_EDITOR_POSITIONS);
+}
+
+function writeSavedPositions(positions: SavedSqlEditorPosition[]) {
+  savedPositions = trimSavedPositions(positions);
+  void api.saveSavedSqlEditorPositions(savedPositions).catch(() => {});
+}
+
+export function createSavedSqlEditorPosition(input: { savedSqlId: string; sql: string; selection?: SavedSqlEditorSelection; viewport?: SavedSqlEditorViewport; now?: number }): SavedSqlEditorPosition {
+  const selection = normalizeSelection(input.selection, input.sql.length);
+  const head = selection.head;
+  return {
+    savedSqlId: input.savedSqlId,
+    selection,
+    viewport: normalizeViewport(input.viewport),
+    anchor: {
+      before: input.sql.slice(Math.max(0, head - ANCHOR_CONTEXT_CHARS), head),
+      after: input.sql.slice(head, Math.min(input.sql.length, head + ANCHOR_CONTEXT_CHARS)),
+      head,
+      docLength: input.sql.length,
+    },
+    updatedAt: input.now ?? Date.now(),
+  };
+}
+
+export function saveSavedSqlEditorPosition(position: SavedSqlEditorPosition) {
+  const next = readSavedPositions().filter((item) => item.savedSqlId !== position.savedSqlId);
+  next.unshift(position);
+  writeSavedPositions(next);
+}
+
+export function restoreSavedSqlEditorPosition(savedSqlId: string, sql: string): { selection?: SavedSqlEditorSelection; viewport?: SavedSqlEditorViewport } {
+  const position = readSavedPositions().find((item) => item.savedSqlId === savedSqlId);
+  if (!position) return {};
+
+  const restoredHead = restoredHeadFromAnchor(position, sql);
+  const originalSelection = normalizeSelection(position.selection, position.anchor.docLength);
+  const anchorOffsetFromHead = originalSelection.anchor - originalSelection.head;
+  const canReuseViewport = sql.length === position.anchor.docLength && restoredHead === originalSelection.head;
+  return {
+    selection: {
+      anchor: clampOffset(restoredHead + anchorOffsetFromHead, sql.length),
+      head: restoredHead,
+    },
+    viewport: canReuseViewport ? normalizeViewport(position.viewport) : undefined,
+  };
+}
+
+export function forgetSavedSqlEditorPosition(savedSqlId: string) {
+  writeSavedPositions(readSavedPositions().filter((item) => item.savedSqlId !== savedSqlId));
+}
+
+export function __resetSavedSqlEditorPositionsForTests(positions: SavedSqlEditorPosition[] = []) {
+  savedPositions = trimSavedPositions(positions);
+  savedPositionsLoaded = true;
+  savedPositionsInitPromise = undefined;
+}
diff --git a/apps/desktop/src/lib/app/supportInfo.ts b/apps/desktop/src/lib/app/supportInfo.ts
new file mode 100644
index 0000000..f187ebc
--- /dev/null
+++ b/apps/desktop/src/lib/app/supportInfo.ts
@@ -0,0 +1,67 @@
+import type { AppSupportInfo } from "@/lib/backend/tauri";
+
+export interface AppSupportInfoLabels {
+  appVersion: string;
+  runtime: string;
+  runtimeDesktop: string;
+  runtimeWeb: string;
+  operatingSystem: string;
+  architecture: string;
+  unknown: string;
+}
+
+export interface AppSupportInfoRow {
+  key: keyof Pick<AppSupportInfoLabels, "appVersion" | "runtime" | "operatingSystem" | "architecture">;
+  label: string;
+  value: string;
+}
+
+export function normalizeSupportInfoVersion(version: string | null | undefined, unknownLabel: string): string {
+  const trimmed = version?.trim();
+  if (!trimmed) return unknownLabel;
+  return trimmed.startsWith("v") || trimmed.startsWith("V") ? `v${trimmed.slice(1)}` : `v${trimmed}`;
+}
+
+export function formatSupportInfoRuntime(runtime: AppSupportInfo["runtime"], labels: AppSupportInfoLabels): string {
+  if (runtime === "desktop") return labels.runtimeDesktop;
+  if (runtime === "web") return labels.runtimeWeb;
+  return labels.unknown;
+}
+
+export function formatSupportInfoOperatingSystem(info: AppSupportInfo, unknownLabel: string): string {
+  const name = info.osName?.trim();
+  const version = info.osVersion?.trim();
+  if (!name && !version) return unknownLabel;
+  return [name, version].filter(Boolean).join(" ");
+}
+
+export function buildAppSupportInfoRows(info: AppSupportInfo, labels: AppSupportInfoLabels): AppSupportInfoRow[] {
+  return [
+    {
+      key: "appVersion",
+      label: labels.appVersion,
+      value: normalizeSupportInfoVersion(info.appVersion, labels.unknown),
+    },
+    {
+      key: "runtime",
+      label: labels.runtime,
+      value: formatSupportInfoRuntime(info.runtime, labels),
+    },
+    {
+      key: "operatingSystem",
+      label: labels.operatingSystem,
+      value: formatSupportInfoOperatingSystem(info, labels.unknown),
+    },
+    {
+      key: "architecture",
+      label: labels.architecture,
+      value: info.arch?.trim() || labels.unknown,
+    },
+  ];
+}
+
+export function formatAppSupportInfoForClipboard(info: AppSupportInfo, labels: AppSupportInfoLabels): string {
+  return buildAppSupportInfoRows(info, labels)
+    .map((row) => `${row.label}: ${row.value}`)
+    .join("\n");
+}
diff --git a/apps/desktop/src/lib/app/transferProgressState.ts b/apps/desktop/src/lib/app/transferProgressState.ts
new file mode 100644
index 0000000..6bcd6be
--- /dev/null
+++ b/apps/desktop/src/lib/app/transferProgressState.ts
@@ -0,0 +1,32 @@
+export interface TransferTerminalState {
+  done: boolean;
+  cancelled: boolean;
+  error: boolean;
+}
+
+export interface TransferStatusLike {
+  status: "running" | "tableDone" | "done" | "error" | "cancelled";
+}
+
+export interface TransferDialogRunState extends TransferTerminalState {
+  transferring: boolean;
+}
+
+export function nextTransferTerminalState(state: TransferTerminalState, progress: TransferStatusLike): TransferTerminalState {
+  if (progress.status === "error") return { ...state, error: true };
+  if (progress.status === "done") return { ...state, done: true, error: state.error };
+  if (progress.status === "cancelled") return { ...state, cancelled: true };
+  return state;
+}
+
+export function isTransferRunActive(state: TransferDialogRunState): boolean {
+  return state.transferring && !state.done && !state.cancelled && !state.error;
+}
+
+export function shouldResetTransferDialogOnOpen(state: TransferDialogRunState): boolean {
+  return state.transferring && !isTransferRunActive(state);
+}
+
+export function shouldKeepTransferDraftOnOpen(preserveDraft: boolean, state: TransferDialogRunState): boolean {
+  return preserveDraft || shouldResetTransferDialogOnOpen(state);
+}
diff --git a/apps/desktop/src/lib/backend/__tests__/debugLog.spec.ts b/apps/desktop/src/lib/backend/__tests__/debugLog.spec.ts
new file mode 100644
index 0000000..b68b10d
--- /dev/null
+++ b/apps/desktop/src/lib/backend/__tests__/debugLog.spec.ts
@@ -0,0 +1,102 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { appendDebugLog, formatLocalTimestamp, formatLocalTimestampForFilename, formatLocalTimezoneOffset, getDebugLogText, padNumber } from "@/lib/backend/debugLog";
+
+class MemoryStorage implements Storage {
+  private data = new Map<string, string>();
+
+  get length() {
+    return this.data.size;
+  }
+
+  clear() {
+    this.data.clear();
+  }
+
+  getItem(key: string) {
+    return this.data.get(key) ?? null;
+  }
+
+  key(index: number) {
+    return [...this.data.keys()][index] ?? null;
+  }
+
+  removeItem(key: string) {
+    this.data.delete(key);
+  }
+
+  setItem(key: string, value: string) {
+    this.data.set(key, value);
+  }
+}
+
+const DEBUG_LOG_ENABLED_KEY = "dbx-debug-logging-enabled";
+
+let originalLocalStorage: PropertyDescriptor | undefined;
+
+function expectedLocalOffset(date: Date): string {
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? "+" : "-";
+  const absoluteMinutes = Math.abs(offsetMinutes);
+  return `${sign}${String(Math.floor(absoluteMinutes / 60)).padStart(2, "0")}:${String(absoluteMinutes % 60).padStart(2, "0")}`;
+}
+
+beforeEach(() => {
+  originalLocalStorage = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: new MemoryStorage(),
+  });
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+  if (originalLocalStorage) Object.defineProperty(globalThis, "localStorage", originalLocalStorage);
+  else Reflect.deleteProperty(globalThis, "localStorage");
+});
+
+describe("debug log local timestamps", () => {
+  it("pads date and time parts", () => {
+    expect(padNumber(7)).toBe("07");
+    expect(padNumber(35)).toBe("35");
+    expect(padNumber(8, 3)).toBe("008");
+  });
+
+  it("formats timezone offsets in RFC 3339 style", () => {
+    const east = new Date(0);
+    const west = new Date(0);
+    vi.spyOn(east, "getTimezoneOffset").mockReturnValue(-480);
+    vi.spyOn(west, "getTimezoneOffset").mockReturnValue(420);
+
+    expect(formatLocalTimezoneOffset(east)).toBe("+08:00");
+    expect(formatLocalTimezoneOffset(west)).toBe("-07:00");
+  });
+
+  it("formats local timestamps with milliseconds and timezone", () => {
+    const date = new Date(2026, 6, 8, 9, 50, 35, 882);
+
+    expect(formatLocalTimestamp(date)).toBe(`2026-07-08T09:50:35.882${expectedLocalOffset(date)}`);
+  });
+
+  it("formats Windows-safe filename timestamp tokens", () => {
+    const date = new Date(2026, 6, 8, 9, 50, 35, 882);
+    const filenameToken = formatLocalTimestampForFilename(date);
+
+    expect(filenameToken).toBe(`2026-07-08T09-50-35-882${expectedLocalOffset(date).replace(":", "-")}`);
+    expect(filenameToken).not.toMatch(/[:.]/);
+  });
+
+  it("uses local timestamps in exported debug log text", () => {
+    const date = new Date(2026, 6, 8, 9, 50, 35, 882);
+    const timestamp = formatLocalTimestamp(date);
+    vi.useFakeTimers();
+    vi.setSystemTime(date);
+    localStorage.setItem(DEBUG_LOG_ENABLED_KEY, "1");
+
+    appendDebugLog("info", "hello");
+
+    const text = getDebugLogText();
+    expect(text).toContain(`Exported: ${timestamp}`);
+    expect(text).toContain(`[${timestamp}] [INFO] hello`);
+    expect(text).not.toContain(".882Z");
+  });
+});
diff --git a/apps/desktop/src/lib/backend/api.ts b/apps/desktop/src/lib/backend/api.ts
new file mode 100644
index 0000000..b5a2c03
--- /dev/null
+++ b/apps/desktop/src/lib/backend/api.ts
@@ -0,0 +1,571 @@
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import type * as TauriModule from "@/lib/backend/tauri";
+import { appendDebugLog } from "@/lib/backend/debugLog";
+import { useSettingsStore } from "@/stores/settingsStore";
+
+// ---------------------------------------------------------------------------
+// Lazy backend resolution (avoids top-level await)
+// ---------------------------------------------------------------------------
+
+type Backend = typeof TauriModule;
+
+let _backend: Backend | null = null;
+
+async function getBackend(): Promise<Backend> {
+  if (_backend) return _backend;
+  _backend = isTauriRuntime(globalThis) ? await import("@/lib/backend/tauri") : await import("@/lib/backend/http");
+  return _backend;
+}
+
+// ---------------------------------------------------------------------------
+// Helper: create a forwarding function that lazily resolves the backend
+// ---------------------------------------------------------------------------
+
+function forward<K extends keyof Backend>(name: K): Backend[K] {
+  return (async (...args: unknown[]) => {
+    const startedAt = performance.now();
+    const operation = String(name);
+    appendDebugLog("debug", "[DBX][api:start]", operation);
+    const b = await getBackend();
+    try {
+      const result = await (b[name] as (...a: unknown[]) => unknown)(...args);
+      appendDebugLog("debug", "[DBX][api:success]", {
+        operation,
+        elapsedMs: Math.round(performance.now() - startedAt),
+      });
+      return result;
+    } catch (error) {
+      appendDebugLog("error", "[DBX][api:error]", {
+        operation,
+        elapsedMs: Math.round(performance.now() - startedAt),
+        error,
+      });
+      throw error;
+    }
+  }) as unknown as Backend[K];
+}
+
+// ---------------------------------------------------------------------------
+// Re-export all functions via lazy forwarding
+// ---------------------------------------------------------------------------
+
+// Connection
+export const testConnection = forward("testConnection");
+export const connectDb = forward("connectDb");
+export const connectionFinalProxyPort = forward("connectionFinalProxyPort");
+export const disconnectDb = forward("disconnectDb");
+export const checkConnectionHealth = forward("checkConnectionHealth");
+export const closeDatabaseConnection = forward("closeDatabaseConnection");
+export const refreshConnections = forward("refreshConnections");
+export const saveConnections = forward("saveConnections");
+export const loadConnections = forward("loadConnections");
+export const loadTunnelProfiles = forward("loadTunnelProfiles");
+export const saveTunnelProfiles = forward("saveTunnelProfiles");
+export const readKeychainPassword = forward("readKeychainPassword");
+export const readKeychainPasswords = forward("readKeychainPasswords");
+export const decryptConfig = forward("decryptConfig");
+export const listPlugins = forward("listPlugins");
+export const listJdbcDrivers = forward("listJdbcDrivers");
+export const listJdbcMavenBundles = forward("listJdbcMavenBundles");
+export const listJdbcLocalBundles = forward("listJdbcLocalBundles");
+export const importJdbcDrivers = forward("importJdbcDrivers");
+export const installJdbcDriverFromMaven = forward("installJdbcDriverFromMaven");
+export const installPrestoSqlJdbcDriver = forward("installPrestoSqlJdbcDriver");
+export const deleteJdbcDriver = forward("deleteJdbcDriver");
+export const deleteJdbcMavenBundle = forward("deleteJdbcMavenBundle");
+export const deleteJdbcLocalBundle = forward("deleteJdbcLocalBundle");
+export const jdbcPluginStatus = forward("jdbcPluginStatus");
+export const installJdbcPlugin = forward("installJdbcPlugin");
+export const installJdbcPluginLocal = forward("installJdbcPluginLocal");
+export const uninstallJdbcPlugin = forward("uninstallJdbcPlugin");
+export const listInstalledAgentsLocal = forward("listInstalledAgentsLocal");
+export async function listInstalledAgents() {
+  const backend = await getBackend();
+  return backend.listInstalledAgents(useSettingsStore().editorSettings.updateDownloadSource);
+}
+export const isAgentInstalled = forward("isAgentInstalled");
+export const getDriverStoreUsage = forward("getDriverStoreUsage");
+export const clearDriverDownloadCache = forward("clearDriverDownloadCache");
+export const getDriverRuntimeSummary = forward("getDriverRuntimeSummary");
+export const stopDriverRuntime = forward("stopDriverRuntime");
+export const restartDriverRuntime = forward("restartDriverRuntime");
+export async function installAgent(dbType: string) {
+  const backend = await getBackend();
+  return backend.installAgent(dbType, useSettingsStore().editorSettings.updateDownloadSource);
+}
+export async function upgradeAllAgents() {
+  const backend = await getBackend();
+  return backend.upgradeAllAgents(useSettingsStore().editorSettings.updateDownloadSource);
+}
+export const checkAgentUpdateBlockers = forward("checkAgentUpdateBlockers");
+export const uninstallAgent = forward("uninstallAgent");
+export const getAgentJavaRuntimeConfig = forward("getAgentJavaRuntimeConfig");
+export const setAgentJavaRuntimeConfig = forward("setAgentJavaRuntimeConfig");
+export const invalidateAgentRegistryCache = forward("invalidateAgentRegistryCache");
+export const importAgentsFromZip = forward("importAgentsFromZip");
+export const importAgentJar = forward("importAgentJar");
+export async function reinstallJre(jreKey?: string) {
+  const backend = await getBackend();
+  return backend.reinstallJre(jreKey, useSettingsStore().editorSettings.updateDownloadSource);
+}
+export const uninstallJre = forward("uninstallJre");
+export const listenAgentInstallProgress = forward("listenAgentInstallProgress");
+export const loadSavedSqlLibrary = forward("loadSavedSqlLibrary");
+export const loadSavedSqlFile = forward("loadSavedSqlFile");
+export const saveSavedSqlFolder = forward("saveSavedSqlFolder");
+export const deleteSavedSqlFolder = forward("deleteSavedSqlFolder");
+export const saveSavedSqlFile = forward("saveSavedSqlFile");
+export const deleteSavedSqlFile = forward("deleteSavedSqlFile");
+export const savedSqlStorageDir = forward("savedSqlStorageDir");
+export const openSavedSqlStorageDir = forward("openSavedSqlStorageDir");
+export const revealPathInFileManager = forward("revealPathInFileManager");
+export const isSqliteDatabaseFile = forward("isSqliteDatabaseFile");
+export const backupSqliteDatabase = forward("backupSqliteDatabase");
+export const syncSavedSqlDirectory = forward("syncSavedSqlDirectory");
+
+// Schema
+export const listDatabases = forward("listDatabases");
+export const listDorisCatalogs = forward("listDorisCatalogs");
+export const listDorisCatalogDatabases = forward("listDorisCatalogDatabases");
+export const listSqlServerLinkedServers = forward("listSqlServerLinkedServers");
+export const listSqlServerLinkedServerCatalogs = forward("listSqlServerLinkedServerCatalogs");
+export const listSqlServerLinkedServerSchemas = forward("listSqlServerLinkedServerSchemas");
+export const listSqlServerLinkedServerTables = forward("listSqlServerLinkedServerTables");
+export const saveSchemaCache = forward("saveSchemaCache");
+export const loadSchemaCache = forward("loadSchemaCache");
+export const deleteSchemaCachePrefix = forward("deleteSchemaCachePrefix");
+export const listSchemas = forward("listSchemas");
+export const listSchemaInfos = forward("listSchemaInfos");
+export const listTables = forward("listTables");
+export const getTableComment = forward("getTableComment");
+export const listObjects = forward("listObjects");
+export const listObjectStatistics = forward("listObjectStatistics");
+export const listCompletionObjects = forward("listCompletionObjects");
+export const completionAssistantSearch = forward("completionAssistantSearch");
+export const getObjectSource = forward("getObjectSource");
+export const getColumns = forward("getColumns");
+export const listDataTypes = forward("listDataTypes");
+export const listIndexes = forward("listIndexes");
+export const listForeignKeys = forward("listForeignKeys");
+export const listTriggers = forward("listTriggers");
+export const getTableDdl = forward("getTableDdl");
+export const listFunctions = forward("listFunctions");
+export const listSequences = forward("listSequences");
+export const listRules = forward("listRules");
+export const listOwners = forward("listOwners");
+export const listExtensions = forward("listExtensions");
+export const listAvailableExtensions = forward("listAvailableExtensions");
+export const prepareSchemaDiff = forward("prepareSchemaDiff");
+export const generateSchemaSyncSql = forward("generateSchemaSyncSql");
+
+// Query
+export const executeQuery = forward("executeQuery");
+export const executeMulti = forward("executeMulti");
+export const executeBatch = forward("executeBatch");
+export const executeScript = forward("executeScript");
+export const executeInTransaction = forward("executeInTransaction");
+export const beginManualTransaction = forward("beginManualTransaction");
+export const executeInManualTransaction = forward("executeInManualTransaction");
+export const commitManualTransaction = forward("commitManualTransaction");
+export const rollbackManualTransaction = forward("rollbackManualTransaction");
+export const cancelQuery = forward("cancelQuery");
+export const closeQuerySession = forward("closeQuerySession");
+export const closeClientConnectionSession = forward("closeClientConnectionSession");
+export const analyzeSqlReferences = forward("analyzeSqlReferences");
+export const findStatementAtCursor = forward("findStatementAtCursor");
+export const prepareQueryPaginationExecutionPlan = forward("prepareQueryPaginationExecutionPlan");
+export const buildSortedQuerySql = forward("buildSortedQuerySql");
+export const buildExplainSql = forward("buildExplainSql");
+export const getExplainInfo = forward("getExplainInfo");
+export const buildCreateUserSql = forward("buildCreateUserSql");
+export const buildDroppedFilePreviewSql = forward("buildDroppedFilePreviewSql");
+export const buildTableSelectSql = forward("buildTableSelectSql");
+export const buildDatabaseSearchSql = forward("buildDatabaseSearchSql");
+export const buildSearchResultWhere = forward("buildSearchResultWhere");
+export const buildRenameObjectSql = forward("buildRenameObjectSql");
+export const buildCreateDatabaseSql = forward("buildCreateDatabaseSql");
+export const buildDuckDbAttachDatabaseSql = forward("buildDuckDbAttachDatabaseSql");
+export const buildDropObjectSql = forward("buildDropObjectSql");
+export const buildDropTableSql = forward("buildDropTableSql");
+export const buildDropTableChildObjectSql = forward("buildDropTableChildObjectSql");
+export const buildEmptyTableSql = forward("buildEmptyTableSql");
+export const buildTruncateTableSql = forward("buildTruncateTableSql");
+export const buildDropDatabaseSql = forward("buildDropDatabaseSql");
+export const buildCreateSchemaSql = forward("buildCreateSchemaSql");
+export const buildUpdateDatabasePropertiesSql = forward("buildUpdateDatabasePropertiesSql");
+export const buildDropSchemaSql = forward("buildDropSchemaSql");
+export const buildDuplicateTableStructureSql = forward("buildDuplicateTableStructureSql");
+export const buildCopyTableDataSql = forward("buildCopyTableDataSql");
+export const buildExecutableObjectSourceStatements = forward("buildExecutableObjectSourceStatements");
+export const buildExecutableObjectSourceSql = forward("buildExecutableObjectSourceSql");
+export const buildEditableObjectSource = forward("buildEditableObjectSource");
+export const buildRoutineRenameObjectSourceStatements = forward("buildRoutineRenameObjectSourceStatements");
+export const buildViewDdlSql = forward("buildViewDdlSql");
+export const buildTableStructureChangeSql = forward("buildTableStructureChangeSql");
+export const previewSqliteTableStructureChange = forward("previewSqliteTableStructureChange");
+export const applySqliteTableStructureChange = forward("applySqliteTableStructureChange");
+export const buildCreateTableSql = forward("buildCreateTableSql");
+export const buildSingleColumnAlterSql = forward("buildSingleColumnAlterSql");
+export const analyzeEditableQueryEditability = forward("analyzeEditableQueryEditability");
+export const prepareDataGridSave = forward("prepareDataGridSave");
+export const buildDataGridCopyUpdateStatements = forward("buildDataGridCopyUpdateStatements");
+export const buildDataGridCopyInsertStatement = forward("buildDataGridCopyInsertStatement");
+export const buildDataGridContextFilterCondition = forward("buildDataGridContextFilterCondition");
+export const buildDataGridColumnValueFilterCondition = forward("buildDataGridColumnValueFilterCondition");
+export const buildDataGridColumnValuesFilterCondition = forward("buildDataGridColumnValuesFilterCondition");
+export const buildDataGridColumnDistinctValuesSql = forward("buildDataGridColumnDistinctValuesSql");
+export const buildDataGridCountSql = forward("buildDataGridCountSql");
+export const buildHiveTablePropertiesSql = forward("buildHiveTablePropertiesSql");
+export const buildExportInsertStatements = forward("buildExportInsertStatements");
+export const buildExportSqlInsert = forward("buildExportSqlInsert");
+export const buildDatabaseSqlExport = forward("buildDatabaseSqlExport");
+export const prepareDataCompare = forward("prepareDataCompare");
+export const prepareDataCompareFromTables = forward("prepareDataCompareFromTables");
+export const prepareDataCompareMissingTarget = forward("prepareDataCompareMissingTarget");
+export const buildDataCompareSyncPlan = forward("buildDataCompareSyncPlan");
+
+// AI
+export const aiComplete = forward("aiComplete");
+export const aiStream = forward("aiStream");
+export const aiAgentStream = forward("aiAgentStream");
+export const aiCancelStream = forward("aiCancelStream");
+export const aiTestConnection = forward("aiTestConnection");
+export const aiListModels = forward("aiListModels");
+export const saveAiConfig = forward("saveAiConfig");
+export const loadAiConfig = forward("loadAiConfig");
+export const saveAiProviderConfig = forward("saveAiProviderConfig");
+export const loadAiProviderConfigs = forward("loadAiProviderConfigs");
+export const loadDesktopSettings = forward("loadDesktopSettings");
+export const saveDesktopSettings = forward("saveDesktopSettings");
+export const completeAppClose = forward("completeAppClose");
+export const requestAppClose = forward("requestAppClose");
+export const setDriverStoreDir = forward("setDriverStoreDir");
+export const setPluginStoreDir = forward("setPluginStoreDir");
+export const setAgentStoreDir = forward("setAgentStoreDir");
+export const getDriverStorePath = forward("getDriverStorePath");
+export const loadPinnedTreeNodeIds = forward("loadPinnedTreeNodeIds");
+export const savePinnedTreeNodeIds = forward("savePinnedTreeNodeIds");
+export const loadEditorSettings = forward("loadEditorSettings");
+export const saveEditorSettings = forward("saveEditorSettings");
+export const loadOpenTabsState = forward("loadOpenTabsState");
+export const saveOpenTabsState = forward("saveOpenTabsState");
+export const loadSavedSqlEditorPositions = forward("loadSavedSqlEditorPositions");
+export const saveSavedSqlEditorPositions = forward("saveSavedSqlEditorPositions");
+export const webdavSyncTest = forward("webdavSyncTest");
+export const webdavPasswordStatus = forward("webdavPasswordStatus");
+export const saveWebdavSavedPassword = forward("saveWebdavSavedPassword");
+export const forgetWebdavSavedPassword = forward("forgetWebdavSavedPassword");
+export const webdavSyncSecretsStatus = forward("webdavSyncSecretsStatus");
+export const saveWebdavSyncSecretsPreference = forward("saveWebdavSyncSecretsPreference");
+export const forgetWebdavSyncSecretsPassphrase = forward("forgetWebdavSyncSecretsPassphrase");
+export const webdavSyncUpload = forward("webdavSyncUpload");
+export const webdavSyncDownload = forward("webdavSyncDownload");
+export const snippetSyncTest = forward("snippetSyncTest");
+export const snippetTokenStatus = forward("snippetTokenStatus");
+export const saveSnippetSavedToken = forward("saveSnippetSavedToken");
+export const forgetSnippetSavedToken = forward("forgetSnippetSavedToken");
+export const snippetSyncUpload = forward("snippetSyncUpload");
+export const snippetSyncDownload = forward("snippetSyncDownload");
+export const saveAiConversation = forward("saveAiConversation");
+export const loadAiConversations = forward("loadAiConversations");
+export const deleteAiConversation = forward("deleteAiConversation");
+
+// System
+export const listSystemFonts = forward("listSystemFonts");
+export const listSshConfigHosts = forward("listSshConfigHosts");
+
+// SQL File Execution
+export const previewSqlFile = forward("previewSqlFile");
+export const executeSqlFile = forward("executeSqlFile");
+export const cancelSqlFileExecution = forward("cancelSqlFileExecution");
+export const listenSqlFileProgress = forward("listenSqlFileProgress");
+export const pendingOpenSqlFiles = forward("pendingOpenSqlFiles");
+export const pendingOpenDbFiles = forward("pendingOpenDbFiles");
+export const pendingOpenConnectionLinks = forward("pendingOpenConnectionLinks");
+export const readExternalSqlFile = forward("readExternalSqlFile");
+export const writeExternalSqlFile = forward("writeExternalSqlFile");
+export const listSqlFilesInFolder = forward("listSqlFilesInFolder");
+
+// Nacos
+export const nacosTestConnection = forward("nacosTestConnection");
+export const nacosListNamespaces = forward("nacosListNamespaces");
+export const nacosCreateNamespace = forward("nacosCreateNamespace");
+export const nacosUpdateNamespace = forward("nacosUpdateNamespace");
+export const nacosListConfigs = forward("nacosListConfigs");
+export const nacosGetConfig = forward("nacosGetConfig");
+export const nacosPublishConfig = forward("nacosPublishConfig");
+export const nacosDeleteConfig = forward("nacosDeleteConfig");
+export const nacosListConfigHistory = forward("nacosListConfigHistory");
+export const nacosGetConfigHistory = forward("nacosGetConfigHistory");
+export const nacosRollbackConfig = forward("nacosRollbackConfig");
+export const nacosListServices = forward("nacosListServices");
+export const nacosListInstances = forward("nacosListInstances");
+export const nacosUpdateInstance = forward("nacosUpdateInstance");
+export const nacosRawRequest = forward("nacosRawRequest");
+
+// Data Transfer
+export const startTransfer = forward("startTransfer");
+export const cancelTransfer = forward("cancelTransfer");
+export const previewTransferOwnership = forward("previewTransferOwnership");
+export const sortTablesByFkDependency = forward("sortTablesByFkDependency");
+
+// Table File Import
+export const previewTableImportFile = forward("previewTableImportFile");
+export const importTableFile = forward("importTableFile");
+export const cancelTableImport = forward("cancelTableImport");
+
+// Database Export
+export const exportDatabaseSql = forward("exportDatabaseSql");
+export const cancelDatabaseExport = forward("cancelDatabaseExport");
+export const exportQueryResultCsv = forward("exportQueryResultCsv");
+export const exportTableDataCsv = forward("exportTableDataCsv");
+export const exportQueryResultXlsx = forward("exportQueryResultXlsx");
+export const exportQueryResultsXlsx = forward("exportQueryResultsXlsx");
+export const exportQueryResultJson = forward("exportQueryResultJson");
+export const exportQueryResultMarkdown = forward("exportQueryResultMarkdown");
+export const startTableExport = forward("startTableExport");
+export const cancelTableExport = forward("cancelTableExport");
+export const startQueryResultExport = forward("startQueryResultExport");
+export const cancelQueryResultExport = forward("cancelQueryResultExport");
+
+// Redis
+export const redisListDatabases = forward("redisListDatabases");
+export const redisScanKeys = forward("redisScanKeys");
+export const redisScanKeysBatch = forward("redisScanKeysBatch");
+export const redisScanValues = forward("redisScanValues");
+export const redisGetValue = forward("redisGetValue");
+export const redisSetString = forward("redisSetString");
+export const redisDeleteKey = forward("redisDeleteKey");
+export const redisHashSet = forward("redisHashSet");
+export const redisHashDel = forward("redisHashDel");
+export const redisListPush = forward("redisListPush");
+export const redisListSet = forward("redisListSet");
+export const redisListRemove = forward("redisListRemove");
+export const redisSetAdd = forward("redisSetAdd");
+export const redisSetRemove = forward("redisSetRemove");
+export const redisZadd = forward("redisZadd");
+export const redisZrem = forward("redisZrem");
+export const redisStreamAdd = forward("redisStreamAdd");
+export const redisJsonSet = forward("redisJsonSet");
+export const redisCheckJsonModule = forward("redisCheckJsonModule");
+export const redisSetTtl = forward("redisSetTtl");
+export const redisDeleteKeys = forward("redisDeleteKeys");
+export const redisFlushDb = forward("redisFlushDb");
+export const redisExecuteCommand = forward("redisExecuteCommand");
+export const redisLoadMore = forward("redisLoadMore");
+export const redisPubSubPublish = forward("redisPubSubPublish");
+export const redisPubSubConnect = forward("redisPubSubConnect");
+export const redisSlowlogGet = forward("redisSlowlogGet");
+export const redisClusterMasterNodes = forward("redisClusterMasterNodes");
+
+// etcd
+export const etcdListPrefix = forward("etcdListPrefix");
+export const etcdGet = forward("etcdGet");
+export const etcdPut = forward("etcdPut");
+export const etcdDelete = forward("etcdDelete");
+
+// ZooKeeper
+export const zookeeperListPrefix = forward("zookeeperListPrefix");
+export const zookeeperGet = forward("zookeeperGet");
+export const zookeeperPut = forward("zookeeperPut");
+export const zookeeperDelete = forward("zookeeperDelete");
+
+// Message Queue
+export const mqTestConnection = forward("mqTestConnection");
+export const mqListTenants = forward("mqListTenants");
+export const mqGetTenant = forward("mqGetTenant");
+export const mqCreateTenant = forward("mqCreateTenant");
+export const mqUpdateTenant = forward("mqUpdateTenant");
+export const mqDeleteTenant = forward("mqDeleteTenant");
+export const mqListNamespaces = forward("mqListNamespaces");
+export const mqCreateNamespace = forward("mqCreateNamespace");
+export const mqDeleteNamespace = forward("mqDeleteNamespace");
+export const mqGetNamespacePolicies = forward("mqGetNamespacePolicies");
+export const mqListTopics = forward("mqListTopics");
+export const mqCreateTopic = forward("mqCreateTopic");
+export const mqDeleteTopic = forward("mqDeleteTopic");
+export const mqUpdatePartitions = forward("mqUpdatePartitions");
+export const mqGetTopicStats = forward("mqGetTopicStats");
+export const mqGetTopicInternalStats = forward("mqGetTopicInternalStats");
+export const mqListSubscriptions = forward("mqListSubscriptions");
+export const mqCreateSubscription = forward("mqCreateSubscription");
+export const mqDeleteSubscription = forward("mqDeleteSubscription");
+export const mqSkipMessages = forward("mqSkipMessages");
+export const mqResetCursor = forward("mqResetCursor");
+export const mqClearBacklog = forward("mqClearBacklog");
+export const mqPeekMessages = forward("mqPeekMessages");
+export const mqExpireMessages = forward("mqExpireMessages");
+export const mqListProducers = forward("mqListProducers");
+export const mqListConsumers = forward("mqListConsumers");
+export const mqUnloadTopic = forward("mqUnloadTopic");
+export const mqSetPublishRate = forward("mqSetPublishRate");
+export const mqSetDispatchRate = forward("mqSetDispatchRate");
+export const mqSetSubscribeRate = forward("mqSetSubscribeRate");
+export const mqSetBacklogQuota = forward("mqSetBacklogQuota");
+export const mqSetRetention = forward("mqSetRetention");
+export const mqGetEffectivePolicies = forward("mqGetEffectivePolicies");
+export const mqGrantPermission = forward("mqGrantPermission");
+export const mqRevokePermission = forward("mqRevokePermission");
+export const mqListPermissions = forward("mqListPermissions");
+export const mqIssueToken = forward("mqIssueToken");
+export const mqListTokenRecords = forward("mqListTokenRecords");
+export const mqGetBacklog = forward("mqGetBacklog");
+export const mqGetClusterInfo = forward("mqGetClusterInfo");
+export const mqRawRequest = forward("mqRawRequest");
+export const mqSendMessage = forward("mqSendMessage");
+
+// MongoDB
+export const documentListDatabases = forward("documentListDatabases");
+export const mongoListDatabases = forward("mongoListDatabases");
+export const documentListCollections = forward("documentListCollections");
+export const mongoListCollections = forward("mongoListCollections");
+export const documentListGridFsBuckets = forward("documentListGridFsBuckets");
+export const documentCreateGridFsBucket = forward("documentCreateGridFsBucket");
+export const documentDeleteGridFsBucket = forward("documentDeleteGridFsBucket");
+export const documentListGridFsFiles = forward("documentListGridFsFiles");
+export const documentDownloadGridFsFile = forward("documentDownloadGridFsFile");
+export const documentUploadGridFsFile = forward("documentUploadGridFsFile");
+export const documentDeleteGridFsFile = forward("documentDeleteGridFsFile");
+export const vectorGetCollectionDetail = forward("vectorGetCollectionDetail");
+export const mongoCreateDatabase = forward("mongoCreateDatabase");
+export const mongoDropDatabase = forward("mongoDropDatabase");
+export const mongoDropCollection = forward("mongoDropCollection");
+export const documentFindDocuments = forward("documentFindDocuments");
+export const mongoFindDocuments = forward("mongoFindDocuments");
+export const mongoServerVersion = forward("mongoServerVersion");
+export const mongoAggregateDocuments = forward("mongoAggregateDocuments");
+export const mongoCollectionStats = forward("mongoCollectionStats");
+export const mongoCreateIndex = forward("mongoCreateIndex");
+export const mongoDropIndexes = forward("mongoDropIndexes");
+export const documentInsertDocument = forward("documentInsertDocument");
+export const mongoInsertDocument = forward("mongoInsertDocument");
+export const mongoInsertDocuments = forward("mongoInsertDocuments");
+export const documentUpdateDocument = forward("documentUpdateDocument");
+export const mongoUpdateDocument = forward("mongoUpdateDocument");
+export const mongoUpdateDocuments = forward("mongoUpdateDocuments");
+export const documentDeleteDocument = forward("documentDeleteDocument");
+export const mongoDeleteDocument = forward("mongoDeleteDocument");
+export const mongoDeleteDocuments = forward("mongoDeleteDocuments");
+
+// Elasticsearch
+export const elasticsearchListIndices = forward("elasticsearchListIndices");
+export const vectorListCollections = forward("vectorListCollections");
+
+// History
+export const saveHistory = forward("saveHistory");
+export const loadHistory = forward("loadHistory");
+export const loadRedisHistory = forward("loadRedisHistory");
+export const clearHistory = forward("clearHistory");
+export const clearRedisHistory = forward("clearRedisHistory");
+export const deleteHistoryEntry = forward("deleteHistoryEntry");
+
+// Updates
+export const checkMcpServerStatus = forward("checkMcpServerStatus");
+export const installMcpServer = forward("installMcpServer");
+export const checkForUpdates = forward("checkForUpdates");
+export const getSystemProxyUrl = forward("getSystemProxyUrl");
+export const downloadAndInstallUpdate = forward("downloadAndInstallUpdate");
+export const getAppVersion = forward("getAppVersion");
+export const getAppSupportInfo = forward("getAppSupportInfo");
+
+// Layout
+export const saveSidebarLayout = forward("saveSidebarLayout");
+export const loadSidebarLayout = forward("loadSidebarLayout");
+
+// ---------------------------------------------------------------------------
+// Re-export all types from tauri.ts (shared between both backends)
+// ---------------------------------------------------------------------------
+
+export type {
+  AppSupportInfo,
+  AiMessage,
+  AiCompletionRequest,
+  AiTaskContract,
+  AiStreamChunk,
+  AiModelInfo,
+  AiChatMessage,
+  AiConversation,
+  AgentDriverInfo,
+  DriverStoreUsage,
+  DriverStoreUsageItem,
+  DriverRuntimeHealth,
+  DriverRuntimeStatus,
+  DriverRuntimeInfo,
+  DriverRuntimeSummary,
+  JavaRuntimeMode,
+  JavaRuntimeConfig,
+  DriverInstallProgress,
+  DriverStoreMigrationResult,
+  DriverStorePathInfo,
+  WebDavConfig,
+  WebDavPasswordStatus,
+  WebDavSyncSummary,
+  WebDavDownloadResult,
+  SnippetProvider,
+  SnippetSyncConfig,
+  SnippetSyncSummary,
+  SnippetDownloadResult,
+  SnippetTokenStatus,
+  McpServerStatus,
+  UpdateInfo,
+  RedisBlob,
+  RedisCollectionPage,
+  RedisDatabaseInfo,
+  RedisHashItem,
+  RedisKeyInfo,
+  RedisListItem,
+  RedisSetItem,
+  RedisStreamEntry,
+  RedisStreamField,
+  RedisValue,
+  RedisValueData,
+  RedisZsetItem,
+  RedisScanResult,
+  RedisCommandSafety,
+  RedisCommandResult,
+  RedisSlowlogEntry,
+  RedisNodeEndpoint,
+  KvValueEncoding,
+  KvValue,
+  KvKeyMetadata,
+  KvKeySummary,
+  KvListPrefixResponse,
+  KvListPrefixOptions,
+  KvGetResponse,
+  KvWriteMode,
+  KvCreateMode,
+  KvPutOptions,
+  KvPutResponse,
+  KvDeleteResponse,
+  MongoDocumentResult,
+  HistoryEntry,
+  SqlFileStatus,
+  SqlFileRequest,
+  SqlFilePreview,
+  SqlFileProgress,
+  TransferRequest,
+  TransferProgress,
+  TransferMode,
+  TransferTableNameCase,
+  TransferOwnershipPolicy,
+  TransferOwnershipPreview,
+  TableImportMode,
+  TableImportStatus,
+  TableImportSourceFormat,
+  TableImportJsonShape,
+  TableImportColumnMapping,
+  TableImportParseOptions,
+  TableImportPreviewRequest,
+  TableImportPreview,
+  TableImportRequest,
+  TableImportSummary,
+  TableImportProgress,
+  DatabaseExportRequest,
+  ExportProgress,
+  TableExportProgress,
+  TableExportStatus,
+  TableExportRequest,
+  QueryResultExportRequest,
+  AgentEvent,
+  SqlFileEntry,
+} from "@/lib/backend/tauri";
diff --git a/apps/desktop/src/lib/backend/browserAppStateStorage.ts b/apps/desktop/src/lib/backend/browserAppStateStorage.ts
new file mode 100644
index 0000000..91e66d3
--- /dev/null
+++ b/apps/desktop/src/lib/backend/browserAppStateStorage.ts
@@ -0,0 +1,70 @@
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+
+const DB_NAME = "dbx-app-state";
+const DB_VERSION = 1;
+const STORE_NAME = "state";
+const LOCAL_STORAGE_PREFIX = "dbx-app-state:";
+
+function indexedDb(): IDBFactory | undefined {
+  return typeof globalThis.indexedDB === "undefined" ? undefined : globalThis.indexedDB;
+}
+
+function requestToPromise<T>(request: IDBRequest<T>): Promise<T> {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+
+let dbPromise: Promise<IDBDatabase | null> | undefined;
+
+function openDb(): Promise<IDBDatabase | null> {
+  if (dbPromise) return dbPromise;
+  const idb = indexedDb();
+  if (!idb) return Promise.resolve(null);
+
+  dbPromise = new Promise((resolve) => {
+    const request = idb.open(DB_NAME, DB_VERSION);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) db.createObjectStore(STORE_NAME);
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => resolve(null);
+    request.onblocked = () => resolve(null);
+  });
+  return dbPromise;
+}
+
+function fallbackKey(key: string) {
+  return `${LOCAL_STORAGE_PREFIX}${key}`;
+}
+
+async function withStore<T>(mode: IDBTransactionMode, run: (store: IDBObjectStore) => IDBRequest<T>): Promise<T | null> {
+  const db = await openDb();
+  if (!db) return null;
+  try {
+    return await requestToPromise(run(db.transaction(STORE_NAME, mode).objectStore(STORE_NAME)));
+  } catch {
+    return null;
+  }
+}
+
+export async function loadBrowserAppState(key: string): Promise<unknown | null> {
+  const value = await withStore("readonly", (store) => store.get(key));
+  if (value !== null && value !== undefined) return value;
+
+  const fallback = safeLocalStorageGet(fallbackKey(key));
+  if (!fallback) return null;
+  try {
+    return JSON.parse(fallback);
+  } catch {
+    return null;
+  }
+}
+
+export async function saveBrowserAppState(key: string, value: unknown): Promise<void> {
+  const result = await withStore("readwrite", (store) => store.put(value, key));
+  if (result !== null) return;
+  safeLocalStorageSet(fallbackKey(key), JSON.stringify(value));
+}
diff --git a/apps/desktop/src/lib/backend/configCrypto.ts b/apps/desktop/src/lib/backend/configCrypto.ts
new file mode 100644
index 0000000..88711cd
--- /dev/null
+++ b/apps/desktop/src/lib/backend/configCrypto.ts
@@ -0,0 +1,102 @@
+export interface EncryptedPayload {
+  format: "dbx-encrypted";
+  version: 1;
+  salt: string;
+  iv: string;
+  data: string;
+}
+
+export interface PlainConfigPayload {
+  format: "dbx-config";
+  version: 1;
+  connections: unknown[];
+}
+
+const PBKDF2_ITERATIONS = 100_000;
+export const CONFIG_CRYPTO_UNAVAILABLE = "crypto_unavailable";
+
+function getCrypto(): Crypto {
+  const runtimeCrypto = globalThis.crypto;
+  if (!runtimeCrypto?.getRandomValues || !runtimeCrypto.subtle) {
+    throw new Error(CONFIG_CRYPTO_UNAVAILABLE);
+  }
+  return runtimeCrypto;
+}
+
+function getSubtleCrypto(): SubtleCrypto {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw new Error(CONFIG_CRYPTO_UNAVAILABLE);
+  return subtle;
+}
+
+async function deriveKey(passphrase: string, salt: Uint8Array<ArrayBuffer>): Promise<CryptoKey> {
+  const encoder = new TextEncoder();
+  const subtle = getSubtleCrypto();
+  const baseKey = await subtle.importKey("raw", encoder.encode(passphrase), "PBKDF2", false, ["deriveKey"]);
+  return subtle.deriveKey({ name: "PBKDF2", salt, iterations: PBKDF2_ITERATIONS, hash: "SHA-256" }, baseKey, { name: "AES-GCM", length: 256 }, false, ["encrypt", "decrypt"]);
+}
+
+function toBase64(data: ArrayBuffer | Uint8Array<ArrayBuffer>): string {
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+function fromBase64(base64: string): Uint8Array<ArrayBuffer> {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+export async function encryptConfig(json: string, passphrase: string): Promise<EncryptedPayload> {
+  const runtimeCrypto = getCrypto();
+  const salt = runtimeCrypto.getRandomValues(new Uint8Array(16));
+  const iv = runtimeCrypto.getRandomValues(new Uint8Array(12));
+  const key = await deriveKey(passphrase, salt);
+  const encoded = new TextEncoder().encode(json);
+  const ciphertext = await runtimeCrypto.subtle.encrypt({ name: "AES-GCM", iv }, key, encoded);
+  return {
+    format: "dbx-encrypted",
+    version: 1,
+    salt: toBase64(salt),
+    iv: toBase64(iv),
+    data: toBase64(ciphertext),
+  };
+}
+
+export async function decryptConfig(payload: EncryptedPayload, passphrase: string): Promise<string> {
+  const salt = fromBase64(payload.salt);
+  const iv = fromBase64(payload.iv);
+  const ciphertext = fromBase64(payload.data);
+  let key: CryptoKey;
+  try {
+    key = await deriveKey(passphrase, salt);
+  } catch (error) {
+    if (error instanceof Error && error.message === CONFIG_CRYPTO_UNAVAILABLE) {
+      const { isTauriRuntime } = await import("@/lib/backend/tauriRuntime");
+      if (!isTauriRuntime(globalThis)) {
+        const { decryptConfig: decryptConfigOnBackend } = await import("@/lib/backend/api");
+        return decryptConfigOnBackend(payload, passphrase);
+      }
+    }
+    throw error;
+  }
+  try {
+    const plaintext = await getSubtleCrypto().decrypt({ name: "AES-GCM", iv }, key, ciphertext);
+    return new TextDecoder().decode(plaintext);
+  } catch {
+    throw new Error("wrong_passphrase");
+  }
+}
+
+export function isEncryptedConfig(data: unknown): data is EncryptedPayload {
+  if (typeof data !== "object" || data === null) return false;
+  const obj = data as Record<string, unknown>;
+  return obj.format === "dbx-encrypted" && obj.version === 1 && typeof obj.salt === "string" && typeof obj.iv === "string" && typeof obj.data === "string";
+}
diff --git a/apps/desktop/src/lib/backend/connectionTransport.ts b/apps/desktop/src/lib/backend/connectionTransport.ts
new file mode 100644
index 0000000..5520d30
--- /dev/null
+++ b/apps/desktop/src/lib/backend/connectionTransport.ts
@@ -0,0 +1,5 @@
+import type { ConnectionConfig } from "@/types/database";
+
+export function hasEnabledTransportLayers(connection?: Pick<ConnectionConfig, "transport_layers"> | null): boolean {
+  return !!connection?.transport_layers?.some((layer) => layer.enabled !== false);
+}
diff --git a/apps/desktop/src/lib/backend/debugLog.ts b/apps/desktop/src/lib/backend/debugLog.ts
new file mode 100644
index 0000000..9c7bf8c
--- /dev/null
+++ b/apps/desktop/src/lib/backend/debugLog.ts
@@ -0,0 +1,282 @@
+const DEBUG_LOG_ENABLED_KEY = "dbx-debug-logging-enabled";
+const DEBUG_LOG_ENTRIES_KEY = "dbx-debug-log-entries";
+const MAX_DEBUG_LOG_ENTRIES = 1500;
+const MAX_TEXT_LENGTH = 4000;
+const MAX_LABEL_LENGTH = 120;
+
+type DebugLogLevel = "debug" | "info" | "log" | "warn" | "error";
+
+interface DebugLogEntry {
+  timestamp: string;
+  level: DebugLogLevel;
+  message: string;
+}
+
+let installed = false;
+let originalConsole: Partial<Record<DebugLogLevel, (...args: unknown[]) => void>> = {};
+
+function safeLocalStorageGet(key: string): string | null {
+  try {
+    return localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+
+function safeLocalStorageSet(key: string, value: string) {
+  try {
+    localStorage.setItem(key, value);
+  } catch {
+    // Ignore quota or unavailable storage errors. The app should keep running.
+  }
+}
+
+function safeLocalStorageRemove(key: string) {
+  try {
+    localStorage.removeItem(key);
+  } catch {}
+}
+
+export function isDebugLoggingEnabled(): boolean {
+  return safeLocalStorageGet(DEBUG_LOG_ENABLED_KEY) === "1";
+}
+
+function readEntries(): DebugLogEntry[] {
+  const raw = safeLocalStorageGet(DEBUG_LOG_ENTRIES_KEY);
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.slice(-MAX_DEBUG_LOG_ENTRIES) : [];
+  } catch {
+    return [];
+  }
+}
+
+function redactSensitiveText(value: string): string {
+  return value.replace(/("(?:password|passphrase|apiKey|api_key|token|secret|connectionString|connection_string)"\s*:\s*")([^"]*)(")/gi, "$1[redacted]$3").replace(/\b(password|passphrase|apiKey|api_key|token|secret)=([^&\s]+)/gi, "$1=[redacted]");
+}
+
+function formatValue(value: unknown, seen = new WeakSet<object>()): string {
+  if (value instanceof Error) {
+    return redactSensitiveText([value.name, value.message, value.stack].filter(Boolean).join(": "));
+  }
+  if (typeof value === "string") return redactSensitiveText(value);
+  if (typeof value !== "object" || value === null) return String(value);
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  try {
+    return redactSensitiveText(
+      JSON.stringify(value, (_key, item) => {
+        if (typeof item === "function") return `[Function ${item.name || "anonymous"}]`;
+        return item;
+      }),
+    );
+  } catch {
+    return redactSensitiveText(String(value));
+  }
+}
+
+function formatArgs(args: unknown[]): string {
+  const message = args.map((arg) => formatValue(arg)).join(" ");
+  return message.length > MAX_TEXT_LENGTH ? `${message.slice(0, MAX_TEXT_LENGTH)}...` : message;
+}
+
+// Pads date/time parts to keep timestamps width-stable.
+export function padNumber(value: number, length = 2): string {
+  return String(value).padStart(length, "0");
+}
+
+// Formats the local UTC offset in RFC 3339 style.
+export function formatLocalTimezoneOffset(date: Date): string {
+  const offsetMinutes = -date.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? "+" : "-";
+  const absoluteMinutes = Math.abs(offsetMinutes);
+  return `${sign}${padNumber(Math.floor(absoluteMinutes / 60))}:${padNumber(absoluteMinutes % 60)}`;
+}
+
+// Formats a local timestamp with milliseconds and timezone.
+export function formatLocalTimestamp(date = new Date()): string {
+  return `${date.getFullYear()}-${padNumber(date.getMonth() + 1)}-${padNumber(date.getDate())}T${padNumber(date.getHours())}:${padNumber(date.getMinutes())}:${padNumber(date.getSeconds())}.${padNumber(date.getMilliseconds(), 3)}${formatLocalTimezoneOffset(date)}`;
+}
+
+// Converts the local timestamp into a Windows-safe filename token.
+export function formatLocalTimestampForFilename(date = new Date()): string {
+  return formatLocalTimestamp(date).replace(/[:.]/g, "-");
+}
+
+export function appendDebugLog(level: DebugLogLevel, ...args: unknown[]) {
+  if (!isDebugLoggingEnabled()) return;
+  const entries = readEntries();
+  entries.push({
+    timestamp: formatLocalTimestamp(),
+    level,
+    message: formatArgs(args),
+  });
+  safeLocalStorageSet(DEBUG_LOG_ENTRIES_KEY, JSON.stringify(entries.slice(-MAX_DEBUG_LOG_ENTRIES)));
+}
+
+export function setDebugLoggingEnabled(enabled: boolean) {
+  safeLocalStorageSet(DEBUG_LOG_ENABLED_KEY, enabled ? "1" : "0");
+  if (enabled) {
+    appendDebugLog("info", "[DBX][debug-log] enabled", {
+      url: location.href,
+      viewport: `${window.innerWidth}x${window.innerHeight}`,
+      devicePixelRatio: window.devicePixelRatio,
+      language: navigator.language,
+      online: navigator.onLine,
+    });
+  }
+}
+
+export function clearDebugLogs() {
+  safeLocalStorageRemove(DEBUG_LOG_ENTRIES_KEY);
+}
+
+export function getDebugLogText(): string {
+  const entries = readEntries();
+  const header = [`DBX debug log`, `Exported: ${formatLocalTimestamp()}`, `User agent: ${navigator.userAgent}`, `Platform: ${navigator.platform}`, `Timezone: ${Intl.DateTimeFormat().resolvedOptions().timeZone || "unknown"}`, ""];
+  const body = entries.map((entry) => `[${entry.timestamp}] [${entry.level.toUpperCase()}] ${entry.message}`);
+  return [...header, ...body].join("\n");
+}
+
+export async function downloadDebugLogs() {
+  const text = await getDebugLogBundleText();
+  const filename = `dbx-debug-log-${formatLocalTimestampForFilename()}.txt`;
+  if (typeof window !== "undefined" && isTauriRuntimeLike()) {
+    const [{ save }, { writeTextFile }] = await Promise.all([import("@tauri-apps/plugin-dialog"), import("@tauri-apps/plugin-fs")]);
+    const path = await save({
+      defaultPath: filename,
+      filters: [{ name: "Text", extensions: ["txt", "log"] }],
+    });
+    if (!path) return false;
+    await writeTextFile(path, text);
+    return true;
+  }
+
+  const blob = new Blob([text], { type: "text/plain;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  link.click();
+  URL.revokeObjectURL(url);
+  return true;
+}
+
+export async function getDebugLogBundleText(): Promise<string> {
+  const sections = [getDebugLogText()];
+  const nativeLogs = await loadNativeDebugLogs().catch((error) => `Failed to load native logs: ${formatValue(error)}`);
+  if (nativeLogs) {
+    sections.push(["", "===== Native / Tauri logs =====", nativeLogs].join("\n"));
+  }
+  return sections.join("\n");
+}
+
+async function loadNativeDebugLogs(): Promise<string> {
+  if (!isTauriRuntimeLike()) return "";
+  const { invoke } = await import("@tauri-apps/api/core");
+  return invoke<string>("load_native_debug_logs");
+}
+
+function isTauriRuntimeLike(): boolean {
+  return "__TAURI_INTERNALS__" in globalThis || "__TAURI__" in globalThis;
+}
+
+export function installDebugLogCapture() {
+  if (installed) return;
+  installed = true;
+  originalConsole = {
+    debug: console.debug.bind(console),
+    info: console.info.bind(console),
+    log: console.log.bind(console),
+    warn: console.warn.bind(console),
+    error: console.error.bind(console),
+  };
+  (Object.keys(originalConsole) as DebugLogLevel[]).forEach((level) => {
+    console[level] = (...args: unknown[]) => {
+      appendDebugLog(level, ...args);
+      originalConsole[level]?.(...args);
+    };
+  });
+  window.addEventListener("error", (event) => {
+    const target = event.target;
+    if (target instanceof HTMLElement) {
+      appendDebugLog("error", "[window:resource-error]", describeElement(target));
+      return;
+    }
+    appendDebugLog("error", "[window:error]", event.error ?? event.message);
+  });
+  window.addEventListener("unhandledrejection", (event) => {
+    appendDebugLog("error", "[window:unhandledrejection]", event.reason);
+  });
+  window.addEventListener("online", () => appendDebugLog("info", "[window:online]"));
+  window.addEventListener("offline", () => appendDebugLog("warn", "[window:offline]"));
+  window.addEventListener("hashchange", () => appendDebugLog("info", "[window:hashchange]", location.hash));
+  document.addEventListener("visibilitychange", () => {
+    appendDebugLog("info", "[document:visibilitychange]", document.visibilityState);
+  });
+  document.addEventListener(
+    "click",
+    (event) => {
+      const target = event.target instanceof HTMLElement ? interactiveElement(event.target) : null;
+      if (!target) return;
+      appendDebugLog("debug", "[ui:click]", describeElement(target));
+    },
+    true,
+  );
+  document.addEventListener(
+    "change",
+    (event) => {
+      const target = event.target instanceof HTMLElement ? event.target : null;
+      if (!target || !isFormControl(target)) return;
+      appendDebugLog("debug", "[ui:change]", describeElement(target));
+    },
+    true,
+  );
+  installPerformanceCapture();
+}
+
+function installPerformanceCapture() {
+  if (typeof PerformanceObserver === "undefined") return;
+  try {
+    const observer = new PerformanceObserver((list) => {
+      for (const entry of list.getEntries()) {
+        if (entry.duration >= 250) {
+          appendDebugLog("warn", "[performance:long-task]", {
+            name: entry.name,
+            durationMs: Math.round(entry.duration),
+            startTimeMs: Math.round(entry.startTime),
+          });
+        }
+      }
+    });
+    observer.observe({ entryTypes: ["longtask"] });
+  } catch {
+    // Long task entries are not available in every WebView.
+  }
+}
+
+function interactiveElement(target: HTMLElement): HTMLElement | null {
+  return target.closest(["button", "a[href]", "input", "select", "textarea", "[role='button']", "[role='menuitem']", "[role='tab']", "[data-debug-id]"].join(","));
+}
+
+function isFormControl(target: HTMLElement): boolean {
+  return target instanceof HTMLInputElement || target instanceof HTMLSelectElement || target instanceof HTMLTextAreaElement || target.getAttribute("role") === "switch";
+}
+
+function describeElement(element: HTMLElement): Record<string, string> {
+  const label = element.getAttribute("data-debug-id") || element.getAttribute("aria-label") || element.getAttribute("title") || element.textContent || "";
+  const attrs: Record<string, string> = {
+    tag: element.tagName.toLowerCase(),
+  };
+  if (element.id) attrs.id = element.id;
+  const role = element.getAttribute("role");
+  if (role) attrs.role = role;
+  const type = element.getAttribute("type");
+  if (type) attrs.type = type;
+  const safeLabel = redactSensitiveText(label.trim().replace(/\s+/g, " "));
+  if (safeLabel) attrs.label = safeLabel.slice(0, MAX_LABEL_LENGTH);
+  const testId = element.getAttribute("data-testid");
+  if (testId) attrs.testId = testId;
+  return attrs;
+}
diff --git a/apps/desktop/src/lib/backend/errorUtils.ts b/apps/desktop/src/lib/backend/errorUtils.ts
new file mode 100644
index 0000000..bec50ff
--- /dev/null
+++ b/apps/desktop/src/lib/backend/errorUtils.ts
@@ -0,0 +1,63 @@
+/**
+ * Utility functions for consistent error handling across the application.
+ */
+
+/**
+ * Formats an unknown error value into a human-readable string.
+ * Handles Error objects, strings, null/undefined, and other types.
+ *
+ * @param e - The error value to format (from a catch block)
+ * @returns A human-readable error message string
+ *
+ * @example
+ * try {
+ *   await someOperation();
+ * } catch (e: unknown) {
+ *   errorMessage.value = formatError(e);
+ * }
+ */
+export function formatError(e: unknown): string {
+  if (e instanceof Error) {
+    return e.message;
+  }
+
+  if (typeof e === "string") {
+    return e;
+  }
+
+  if (e === null || e === undefined) {
+    return "Unknown error occurred";
+  }
+
+  // Try to extract message property from object-like values
+  if (typeof e === "object" && "message" in e) {
+    const message = (e as { message: unknown }).message;
+    if (typeof message === "string") {
+      return message;
+    }
+  }
+
+  // Fallback: attempt to stringify
+  try {
+    return String(e);
+  } catch {
+    return "Unknown error occurred";
+  }
+}
+
+/**
+ * Formats an error with a context prefix for better debugging.
+ *
+ * @param e - The error value to format
+ * @param context - The operation context (e.g., "loading topics", "creating tenant")
+ * @returns A formatted error message with context
+ *
+ * @example
+ * catch (e: unknown) {
+ *   errorMessage.value = formatErrorWithContext(e, 'loading topics');
+ * }
+ */
+export function formatErrorWithContext(e: unknown, context: string): string {
+  const message = formatError(e);
+  return `Failed to ${context}: ${message}`;
+}
diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.ts
new file mode 100644
index 0000000..cab4f0c
--- /dev/null
+++ b/apps/desktop/src/lib/backend/http.ts
@@ -0,0 +1,2216 @@
+import type {
+  ConnectionConfig,
+  DatabaseInfo,
+  SchemaInfo,
+  LinkedServerInfo,
+  CatalogInfo,
+  TableInfo,
+  ObjectInfo,
+  CompletionAssistantRequest,
+  CompletionAssistantResponse,
+  ObjectStatistics,
+  ObjectSource,
+  ObjectSourceKind,
+  ColumnInfo,
+  IndexInfo,
+  ForeignKeyInfo,
+  TriggerInfo,
+  ExtensionInfo,
+  FunctionInfo,
+  SequenceInfo,
+  RuleInfo,
+  OwnerInfo,
+  QueryResult,
+  SqlReferenceAnalysis,
+  DatabaseType,
+  InstalledPlugin,
+  JdbcDriverInfo,
+  JdbcLocalBundleInfo,
+  JdbcMavenBundleInfo,
+  JdbcPluginStatus,
+  SidebarLayout,
+  SavedSqlFile,
+  SavedSqlFolder,
+  SavedSqlLibrary,
+  SshConfigHostEntry,
+  TunnelProfile,
+} from "@/types/database";
+import type { CollectionInfo } from "@/types/database";
+import type { SchemaDiffPreparation, SchemaDiffPreparationOptions, TableDiff, FunctionDiff, SequenceDiff, RuleDiff, OwnerDiff } from "@/lib/schema/schemaDiff";
+import type { SidebarObjectKind } from "@/lib/database/databaseObjectCapabilities";
+import type { AiConfig, AiTestConnectionResult } from "@/stores/settingsStore";
+import type {
+  AgentDriverInfo,
+  AiCompletionRequest,
+  AiStreamChunk,
+  AiConversation,
+  AiModelInfo,
+  DriverStoreUsage,
+  DriverRuntimeSummary,
+  UpgradeAllAgentDriversResult,
+  AgentUpdateBlocker,
+  DesktopSettings,
+  SavedSqlSyncRequest,
+  DriverInstallProgress,
+  JavaRuntimeConfig,
+  UpdateInfo,
+  UpdateDownloadSource,
+  RedisCollectionPage,
+  RedisDatabaseInfo,
+  RedisValue,
+  RedisScanResult,
+  RedisCommandResult,
+  RedisSlowlogEntry,
+  RedisNodeEndpoint,
+  KvValue,
+  KvListPrefixResponse,
+  KvListPrefixOptions,
+  KvGetResponse,
+  KvPutOptions,
+  KvPutResponse,
+  KvDeleteResponse,
+  MongoDocumentResult,
+  MongoCollectionStatsResult,
+  MongoGridFsBucketInfo,
+  HistoryEntry,
+  SqlFileRequest,
+  SqlFilePreview,
+  SqlFileProgress,
+  TransferRequest,
+  TransferProgress,
+  TransferOwnershipPreview,
+  TableImportPreviewRequest,
+  TableImportPreview,
+  TableImportRequest,
+  TableImportSummary,
+  TableImportProgress,
+  DatabaseExportRequest,
+  ExportProgress,
+  TableExportRequest,
+  TableExportProgress,
+  QueryResultExportRequest,
+  TableCsvExportOptions,
+  XlsxCellValue,
+  QueryPaginationExecutionPlanOptions,
+  QueryPaginationExecutionPlan,
+  SortedQuerySqlOptions,
+  QuerySqlBuildResult,
+  BuildExplainSqlOptions,
+  ExplainSqlBuildResult,
+  DroppedFilePreviewSqlOptions,
+  MongoGridFsFileInfo,
+  AppSupportInfo,
+} from "@/lib/backend/tauri";
+import type { QueryEditability } from "@/lib/sql/sqlAnalysis";
+import { isTerminalTransferProgress } from "@/lib/backend/transferProgress";
+import type {
+  DataGridColumnDistinctValuesSqlOptions,
+  DataGridColumnValueFilterConditionOptions,
+  DataGridColumnValuesFilterConditionOptions,
+  DataGridContextFilterConditionOptions,
+  DataGridCountSqlOptions,
+  DataGridCopyInsertStatementOptions,
+  DataGridCopyUpdateStatementOptions,
+  DataGridSaveStatementOptions,
+  HiveTablePropertiesSqlOptions,
+} from "@/lib/dataGrid/dataGridSql";
+import type { BuildTableStructureChangeSqlOptions, BuildSingleColumnAlterSqlOptions, SqliteTableStructureChangePreview, TableStructureChangeSql } from "@/lib/table/tableStructureEditorSql";
+import type { BuildTableSelectSqlOptions } from "@/lib/table/tableSelectSql";
+import type { DatabaseSearchSql, DatabaseSearchSqlOptions, SearchResultWhereOptions } from "@/lib/database/databaseSearch";
+import type { BuildEditableObjectSourceSqlInput, BuildRoutineRenameObjectSourceInput } from "@/lib/table/objectSourceEditor";
+import type { BuildViewDdlInput } from "@/lib/table/viewDdl";
+import type { BuildRenameObjectSqlOptions } from "@/lib/table/objectRenameSql";
+import type { CreateDatabaseSqlOptions } from "@/lib/database/createDatabaseSql";
+import type { DatabaseNameSqlOptions, DatabasePropertyEditSqlOptions, DropTableChildObjectSqlOptions, DropObjectSqlOptions, DuplicateTableStructureSqlOptions, CopyTableDataSqlOptions, SchemaNameSqlOptions, TableAdminSqlOptions } from "@/lib/database/dbAdminSql";
+import type { BuildDatabaseSqlExportOptions, BuildExportInsertStatementsOptions } from "@/lib/export/databaseExport";
+import { loadBrowserAppState, saveBrowserAppState } from "@/lib/backend/browserAppStateStorage";
+import type { DataCompareFromTablesOptions, DataCompareFromTablesPreparation, DataCompareSyncPlan, DataCompareSyncPlanOptions, DataComparePreparation, DataComparePreparationOptions } from "@/lib/dataGrid/dataCompare";
+import { apiUrl, apiWebSocketUrl } from "@/lib/common/webPath";
+import type { DataGridSavePreparation } from "@/lib/backend/tauri";
+import type {
+  NacosConfigHistoryKey,
+  NacosConfigHistoryList,
+  NacosConfigHistoryQuery,
+  NacosConfigItem,
+  NacosConfigKey,
+  NacosConfigList,
+  NacosConfigQuery,
+  NacosConfigRollbackRequest,
+  NacosConfigUpsert,
+  NacosConnectionInfo,
+  NacosInstanceInfo,
+  NacosInstanceQuery,
+  NacosInstanceUpdate,
+  NacosNamespaceCreate,
+  NacosNamespaceInfo,
+  NacosNamespaceUpdate,
+  NacosRawRequest,
+  NacosRawResponse,
+  NacosServiceList,
+  NacosServiceQuery,
+} from "@/types/nacos";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const DESKTOP_SETTINGS_STORAGE_KEY = "dbx-desktop-settings";
+const DEFAULT_DESKTOP_SETTINGS: DesktopSettings = {
+  show_tray_icon: true,
+  icon_theme: "default",
+  quit_on_close: false,
+  close_action_prompted: false,
+  debug_logging_enabled: false,
+  duckdb_worker_process_isolation: false,
+  duckdb_worker_max_processes: 4,
+  saved_sql_sync_dir: null,
+  driver_store_dir: null,
+  plugin_store_dir: null,
+  agent_store_dir: null,
+  sidebar_table_page_size: 1000,
+};
+
+async function post<T>(url: string, body: unknown): Promise<T> {
+  const res = await fetch(apiUrl(url), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) throw new Error(await res.text());
+  return res.json();
+}
+
+async function get<T>(url: string): Promise<T> {
+  const res = await fetch(apiUrl(url));
+  if (!res.ok) throw new Error(await res.text());
+  return res.json();
+}
+
+async function del<T>(url: string): Promise<T> {
+  const res = await fetch(apiUrl(url), { method: "DELETE" });
+  if (!res.ok) throw new Error(await res.text());
+  return res.json();
+}
+
+function qs(params: Record<string, string | number | boolean | undefined>): string {
+  const sp = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== undefined && v !== null) sp.set(k, String(v));
+  }
+  return sp.toString();
+}
+
+// ---------------------------------------------------------------------------
+// Connection
+// ---------------------------------------------------------------------------
+
+export async function testConnection(config: ConnectionConfig): Promise<string> {
+  return post("/api/connection/test", { config });
+}
+
+export async function connectDb(config: ConnectionConfig, clientAttempt?: number): Promise<string> {
+  return post("/api/connection/connect", { config, clientAttempt });
+}
+
+export async function connectionFinalProxyPort(config: ConnectionConfig): Promise<number> {
+  return post("/api/connection/final-proxy-port", { config });
+}
+
+export async function disconnectDb(connectionId: string, clientAttempt?: number): Promise<void> {
+  return post("/api/connection/disconnect", { connectionId, clientAttempt });
+}
+
+export async function checkConnectionHealth(connectionId: string): Promise<void> {
+  return post("/api/connection/check-health", { connectionId });
+}
+
+export async function closeDatabaseConnection(connectionId: string, database: string): Promise<boolean> {
+  return post("/api/connection/close-database", { connectionId, database });
+}
+
+export async function saveConnections(configs: ConnectionConfig[]): Promise<void> {
+  return post("/api/connection/save", { configs });
+}
+
+export async function loadConnections(): Promise<ConnectionConfig[]> {
+  return get("/api/connection/list");
+}
+
+export async function loadTunnelProfiles(): Promise<TunnelProfile[]> {
+  return get("/api/tunnel-profiles/list");
+}
+
+export async function saveTunnelProfiles(profiles: TunnelProfile[]): Promise<void> {
+  return post("/api/tunnel-profiles/save", { profiles });
+}
+
+export async function readKeychainPassword(_service: string): Promise<string> {
+  return ""; // Not available in web backend
+}
+
+export async function readKeychainPasswords(services: string[]): Promise<[string, string][]> {
+  return services.map((s) => [s, ""]); // Not available in web backend
+}
+
+export async function decryptConfig(payload: unknown, passphrase: string): Promise<string> {
+  return post("/api/app-settings/config/decrypt", { payload, passphrase });
+}
+
+export async function listSystemFonts(): Promise<string[]> {
+  return get("/api/system/fonts");
+}
+
+export async function listSshConfigHosts(): Promise<SshConfigHostEntry[]> {
+  return get("/api/ssh/config-hosts");
+}
+
+export async function listPlugins(): Promise<InstalledPlugin[]> {
+  return get("/api/plugins");
+}
+
+export async function listJdbcDrivers(): Promise<JdbcDriverInfo[]> {
+  return get("/api/jdbc/drivers");
+}
+
+export async function listJdbcMavenBundles(): Promise<JdbcMavenBundleInfo[]> {
+  return get("/api/jdbc/drivers/maven");
+}
+
+export async function listJdbcLocalBundles(): Promise<JdbcLocalBundleInfo[]> {
+  return get("/api/jdbc/drivers/local");
+}
+
+export async function importJdbcDrivers(pathsOrFiles: (string | File)[]): Promise<JdbcDriverInfo[]> {
+  const formData = new FormData();
+  for (const item of pathsOrFiles) {
+    if (item instanceof File) {
+      formData.append("files", item, item.name);
+    } else {
+      const fileName = item.split("/").pop() || "driver.jar";
+      const blob = await (await fetch(item)).blob();
+      formData.append("files", blob, fileName);
+    }
+  }
+  const res = await fetch(apiUrl("/api/jdbc/drivers"), { method: "POST", body: formData });
+  if (!res.ok) throw new Error(await res.text());
+  return res.json();
+}
+
+export async function installJdbcDriverFromMaven(coordinate: string, repositories: string[] = []): Promise<JdbcDriverInfo[]> {
+  return post("/api/jdbc/drivers/maven", { coordinate, repositories });
+}
+
+export async function installPrestoSqlJdbcDriver(): Promise<JdbcDriverInfo[]> {
+  return post("/api/jdbc/drivers/prestosql", {});
+}
+
+export async function deleteJdbcDriver(path: string): Promise<JdbcDriverInfo[]> {
+  const fileName = path.split("/").pop() || path;
+  return del(`/api/jdbc/drivers/${encodeURIComponent(fileName)}`);
+}
+
+export async function deleteJdbcMavenBundle(bundleId: string): Promise<JdbcDriverInfo[]> {
+  return del(`/api/jdbc/drivers/maven/${encodeURIComponent(bundleId)}`);
+}
+
+export async function deleteJdbcLocalBundle(bundleId: string): Promise<JdbcDriverInfo[]> {
+  return del(`/api/jdbc/drivers/local/${encodeURIComponent(bundleId)}`);
+}
+
+export async function jdbcPluginStatus(): Promise<JdbcPluginStatus> {
+  return get("/api/jdbc/plugin/status");
+}
+
+export async function installJdbcPlugin(): Promise<JdbcPluginStatus> {
+  return post("/api/jdbc/plugin/install", {});
+}
+
+export async function installJdbcPluginLocal(pathOrFile: string | File): Promise<JdbcPluginStatus> {
+  let blob: Blob;
+  let fileName: string;
+  if (pathOrFile instanceof File) {
+    blob = pathOrFile;
+    fileName = pathOrFile.name;
+  } else {
+    fileName = pathOrFile.split("/").pop() || "plugin.zip";
+    blob = await (await fetch(pathOrFile)).blob();
+  }
+  const formData = new FormData();
+  formData.append("file", blob, fileName);
+  const uploadRes = await fetch(apiUrl("/api/jdbc/plugin/install-local"), { method: "POST", body: formData });
+  if (!uploadRes.ok) throw new Error(await uploadRes.text());
+  return uploadRes.json();
+}
+
+export async function uninstallJdbcPlugin(): Promise<JdbcPluginStatus> {
+  return post("/api/jdbc/plugin/uninstall", {});
+}
+
+export async function listInstalledAgentsLocal(): Promise<AgentDriverInfo[]> {
+  return get("/api/agents/installed-local");
+}
+
+export async function listInstalledAgents(_source?: UpdateDownloadSource): Promise<AgentDriverInfo[]> {
+  return get("/api/agents/installed");
+}
+
+export async function isAgentInstalled(dbType: string): Promise<boolean> {
+  return get(`/api/agents/installed/${encodeURIComponent(dbType)}`);
+}
+
+export async function getDriverStoreUsage(): Promise<DriverStoreUsage> {
+  return get("/api/agents/storage-usage");
+}
+
+export async function clearDriverDownloadCache(): Promise<void> {
+  await del("/api/agents/download-cache");
+}
+
+export async function getDriverRuntimeSummary(): Promise<DriverRuntimeSummary> {
+  return get("/api/agents/runtime");
+}
+
+export async function stopDriverRuntime(runtimeId: string): Promise<void> {
+  await post("/api/agents/runtime/stop", { runtimeId });
+}
+
+export async function restartDriverRuntime(runtimeId: string): Promise<void> {
+  await post("/api/agents/runtime/restart", { runtimeId });
+}
+
+export async function installAgent(dbType: string, _source?: UpdateDownloadSource): Promise<void> {
+  await post("/api/agents/install", { dbType });
+}
+
+export async function upgradeAllAgents(_source?: UpdateDownloadSource): Promise<UpgradeAllAgentDriversResult> {
+  return post("/api/agents/upgrade-all", {});
+}
+
+export async function checkAgentUpdateBlockers(_dbTypes: string[]): Promise<AgentUpdateBlocker[]> {
+  return [];
+}
+
+export async function uninstallAgent(dbType: string): Promise<void> {
+  await post("/api/agents/uninstall", { dbType });
+}
+
+export async function getAgentJavaRuntimeConfig(): Promise<JavaRuntimeConfig> {
+  return get("/api/agents/java-runtime");
+}
+
+export async function setAgentJavaRuntimeConfig(config: JavaRuntimeConfig): Promise<JavaRuntimeConfig> {
+  return post("/api/agents/java-runtime", { config });
+}
+
+export async function invalidateAgentRegistryCache(): Promise<void> {
+  await post("/api/agents/invalidate-registry-cache", {});
+}
+
+export async function importAgentsFromZip(fileOrPath: string | File): Promise<number> {
+  if (typeof fileOrPath === "string") {
+    throw new Error("Offline ZIP import in web mode requires a File object, not a file path");
+  }
+  const formData = new FormData();
+  formData.append("file", fileOrPath);
+  const res = await fetch(apiUrl("/api/agents/import-offline"), { method: "POST", body: formData });
+  if (!res.ok) throw new Error(await res.text());
+  const result: { count: number } = await res.json();
+  return result.count;
+}
+
+export async function importAgentJar(dbType: string, pathOrFile: string | File): Promise<void> {
+  let blob: Blob;
+  let fileName: string;
+  if (pathOrFile instanceof File) {
+    blob = pathOrFile;
+    fileName = pathOrFile.name;
+  } else {
+    fileName = pathOrFile.split("/").pop() || "driver.jar";
+    blob = await (await fetch(pathOrFile)).blob();
+  }
+  const formData = new FormData();
+  formData.append("dbType", dbType);
+  formData.append("file", blob, fileName);
+  const uploadRes = await fetch(apiUrl("/api/agents/import-jar"), { method: "POST", body: formData });
+  if (!uploadRes.ok) throw new Error(await uploadRes.text());
+}
+
+export async function reinstallJre(jreKey?: string, _source?: UpdateDownloadSource): Promise<void> {
+  await post("/api/agents/reinstall-jre", { jreKey });
+}
+
+export async function uninstallJre(jreKey: string): Promise<void> {
+  await post("/api/agents/uninstall-jre", { jreKey });
+}
+
+export async function listenAgentInstallProgress(handler: (progress: DriverInstallProgress) => void): Promise<() => void> {
+  const es = new EventSource(apiUrl("/api/agents/progress/global"));
+  es.onmessage = (event) => {
+    try {
+      handler(JSON.parse(event.data));
+    } catch {
+      /* ignore malformed progress events */
+    }
+  };
+  return () => es.close();
+}
+
+export async function loadSavedSqlLibrary(): Promise<SavedSqlLibrary> {
+  return get("/api/saved-sql");
+}
+
+export async function loadSavedSqlFile(id: string): Promise<SavedSqlFile | null> {
+  return get(`/api/saved-sql/${encodeURIComponent(id)}`);
+}
+
+export async function saveSavedSqlFolder(folder: SavedSqlFolder): Promise<SavedSqlFolder> {
+  return post("/api/saved-sql/folders", folder);
+}
+
+export async function deleteSavedSqlFolder(id: string): Promise<void> {
+  return del(`/api/saved-sql/folders/${encodeURIComponent(id)}`);
+}
+
+export async function saveSavedSqlFile(file: SavedSqlFile): Promise<SavedSqlFile> {
+  return post("/api/saved-sql", file);
+}
+
+export async function deleteSavedSqlFile(id: string): Promise<void> {
+  return del(`/api/saved-sql/${encodeURIComponent(id)}`);
+}
+
+export async function savedSqlStorageDir(): Promise<string> {
+  return "";
+}
+
+export async function openSavedSqlStorageDir(_dir?: string | null): Promise<void> {
+  throw new Error("SQL storage directory is only available in the desktop app.");
+}
+
+export async function revealPathInFileManager(_path: string): Promise<void> {
+  throw new Error("Reveal in file manager is only available in the desktop app.");
+}
+
+export async function isSqliteDatabaseFile(_path: string): Promise<boolean> {
+  return false;
+}
+
+export async function backupSqliteDatabase(_connectionId: string, _destinationPath: string): Promise<void> {
+  throw new Error("SQLite backup is only available in the desktop app.");
+}
+
+export async function syncSavedSqlDirectory(_request: SavedSqlSyncRequest): Promise<void> {
+  throw new Error("SQL directory sync is only available in the desktop app.");
+}
+
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+
+export async function listDatabases(connectionId: string): Promise<DatabaseInfo[]> {
+  return get(`/api/schema/databases?${qs({ connection_id: connectionId })}`);
+}
+
+export async function listDorisCatalogs(connectionId: string): Promise<CatalogInfo[]> {
+  return get(`/api/schema/doris/catalogs?${qs({ connection_id: connectionId })}`);
+}
+
+export async function listDorisCatalogDatabases(connectionId: string, catalog: string): Promise<DatabaseInfo[]> {
+  return get(`/api/schema/doris/catalog-databases?${qs({ connection_id: connectionId, catalog })}`);
+}
+
+export async function listSqlServerLinkedServers(connectionId: string): Promise<LinkedServerInfo[]> {
+  return get(`/api/schema/sqlserver/linked-servers?${qs({ connection_id: connectionId })}`);
+}
+
+export async function listSqlServerLinkedServerCatalogs(connectionId: string, server: string): Promise<DatabaseInfo[]> {
+  return get(`/api/schema/sqlserver/linked-server-catalogs?${qs({ connection_id: connectionId, server })}`);
+}
+
+export async function listSqlServerLinkedServerSchemas(connectionId: string, server: string, catalog: string): Promise<string[]> {
+  return get(`/api/schema/sqlserver/linked-server-schemas?${qs({ connection_id: connectionId, server, catalog })}`);
+}
+
+export async function listSqlServerLinkedServerTables(connectionId: string, server: string, catalog: string, schema: string, filter?: string, limit?: number, offset?: number): Promise<TableInfo[]> {
+  return get(`/api/schema/sqlserver/linked-server-tables?${qs({ connection_id: connectionId, server, catalog, schema, filter, limit, offset })}`);
+}
+
+export async function saveSchemaCache(cacheKey: string, payload: unknown): Promise<void> {
+  return post("/api/schema/cache", { cacheKey, payload });
+}
+
+export async function loadSchemaCache<T = unknown>(cacheKey: string): Promise<T | null> {
+  return get(`/api/schema/cache?${qs({ cache_key: cacheKey })}`);
+}
+
+export async function deleteSchemaCachePrefix(prefix: string): Promise<void> {
+  return del(`/api/schema/cache-prefix?${qs({ prefix })}`);
+}
+
+export async function listSchemas(connectionId: string, database: string, applyVisibleFilter = false): Promise<string[]> {
+  return get(`/api/schema/schemas?${qs({ connection_id: connectionId, database, apply_visible_filter: applyVisibleFilter || undefined })}`);
+}
+
+export async function listSchemaInfos(connectionId: string, database: string): Promise<SchemaInfo[]> {
+  const schemas = await listSchemas(connectionId, database);
+  return schemas.map((name) => ({ name, comment: null }));
+}
+
+export async function listTables(connectionId: string, database: string, schema: string, filter?: string, limit?: number, offset?: number, objectTypes?: SidebarObjectKind[], catalog?: string): Promise<TableInfo[]> {
+  return get(`/api/schema/tables?${qs({ connection_id: connectionId, database, schema, filter, limit, offset, object_types: objectTypes?.join(","), catalog })}`);
+}
+
+export async function getTableComment(_connectionId: string, _database: string, _schema: string, _table: string, _catalog?: string): Promise<string | null> {
+  throw new Error("Table comment lookup is not available in the web backend");
+}
+
+export async function listObjects(connectionId: string, database: string, schema: string, objectTypes?: SidebarObjectKind[], filter?: string, limit?: number, offset?: number, catalog?: string): Promise<ObjectInfo[]> {
+  return get(
+    `/api/schema/objects?${qs({
+      connection_id: connectionId,
+      database,
+      schema,
+      object_types: objectTypes?.join(","),
+      filter,
+      limit,
+      offset,
+      catalog,
+    })}`,
+  );
+}
+
+export async function listObjectStatistics(connectionId: string, database: string, schema: string): Promise<ObjectStatistics[]> {
+  return get(`/api/schema/object-statistics?${qs({ connection_id: connectionId, database, schema })}`);
+}
+
+export async function listCompletionObjects(connectionId: string, database: string, schema: string): Promise<ObjectInfo[]> {
+  return get(`/api/schema/completion-objects?${qs({ connection_id: connectionId, database, schema })}`);
+}
+
+export async function completionAssistantSearch(request: CompletionAssistantRequest): Promise<CompletionAssistantResponse> {
+  return post("/api/schema/completion-assistant", request);
+}
+
+export async function getObjectSource(connectionId: string, database: string, schema: string, name: string, objectType: ObjectSourceKind, signature?: string): Promise<ObjectSource> {
+  return get(`/api/schema/object-source?${qs({ connection_id: connectionId, database, schema, table: name, object_type: objectType, signature })}`);
+}
+
+export async function getColumns(connectionId: string, database: string, schema: string, table: string, catalog?: string): Promise<ColumnInfo[]> {
+  return get(`/api/schema/columns?${qs({ connection_id: connectionId, database, schema, table, catalog })}`);
+}
+
+export async function listDataTypes(connectionId: string, database: string): Promise<string[]> {
+  return get(`/api/schema/data-types?${qs({ connection_id: connectionId, database })}`);
+}
+
+export async function listIndexes(connectionId: string, database: string, schema: string, table: string, catalog?: string): Promise<IndexInfo[]> {
+  return get(`/api/schema/indexes?${qs({ connection_id: connectionId, database, schema, table, catalog })}`);
+}
+
+export async function listForeignKeys(connectionId: string, database: string, schema: string, table: string, catalog?: string): Promise<ForeignKeyInfo[]> {
+  return get(`/api/schema/foreign-keys?${qs({ connection_id: connectionId, database, schema, table, catalog })}`);
+}
+
+export async function listTriggers(connectionId: string, database: string, schema: string, table: string, catalog?: string): Promise<TriggerInfo[]> {
+  return get(`/api/schema/triggers?${qs({ connection_id: connectionId, database, schema, table, catalog })}`);
+}
+
+export async function getTableDdl(connectionId: string, database: string, schema: string, table: string, objectType?: ObjectSourceKind, catalog?: string): Promise<string> {
+  return get(`/api/schema/ddl?${qs({ connection_id: connectionId, database, schema, table, object_type: objectType, catalog })}`);
+}
+
+export async function prepareSchemaDiff(options: SchemaDiffPreparationOptions): Promise<SchemaDiffPreparation> {
+  return post("/api/schema-diff/prepare", options);
+}
+
+export async function generateSchemaSyncSql(diffs: TableDiff[], databaseType: DatabaseType, targetSchema?: string, functionDiffs?: FunctionDiff[], sequenceDiffs?: SequenceDiff[], ruleDiffs?: RuleDiff[], ownerDiffs?: OwnerDiff[], cascadeDelete?: boolean): Promise<string> {
+  return post("/api/schema-diff/generate-sync-sql", {
+    diffs,
+    databaseType,
+    targetSchema,
+    functionDiffs: functionDiffs ?? [],
+    sequenceDiffs: sequenceDiffs ?? [],
+    ruleDiffs: ruleDiffs ?? [],
+    ownerDiffs: ownerDiffs ?? [],
+    cascadeDelete: cascadeDelete ?? false,
+  });
+}
+
+export async function listFunctions(connectionId: string, database: string, schema: string): Promise<FunctionInfo[]> {
+  return get(`/api/schema/functions?${qs({ connection_id: connectionId, database, schema })}`);
+}
+
+export async function listSequences(connectionId: string, database: string, schema: string, withLastValues: boolean): Promise<SequenceInfo[]> {
+  return get(`/api/schema/sequences?${qs({ connection_id: connectionId, database, schema, with_last_values: withLastValues })}`);
+}
+
+export async function listRules(connectionId: string, database: string, schema: string): Promise<RuleInfo[]> {
+  return get(`/api/schema/rules?${qs({ connection_id: connectionId, database, schema })}`);
+}
+
+export async function listOwners(connectionId: string, database: string, schema: string): Promise<OwnerInfo[]> {
+  return get(`/api/schema/owners?${qs({ connection_id: connectionId, database, schema })}`);
+}
+
+export async function listExtensions(connectionId: string, database: string, schema: string): Promise<ExtensionInfo[]> {
+  return get(`/api/schema/extensions?${qs({ connection_id: connectionId, database, schema })}`);
+}
+
+export async function listAvailableExtensions(connectionId: string, database: string): Promise<ExtensionInfo[]> {
+  return get(`/api/schema/available-extensions?${qs({ connection_id: connectionId, database })}`);
+}
+
+// ---------------------------------------------------------------------------
+// Query
+// ---------------------------------------------------------------------------
+
+export async function executeQuery(
+  connectionId: string,
+  database: string,
+  sql: string,
+  schema?: string,
+  executionId?: string,
+  options?: {
+    maxRows?: number;
+    fetchSize?: number;
+    pageSize?: number;
+    resultSessionId?: string;
+    clientSessionId?: string;
+    timeoutSecs?: number;
+  },
+): Promise<QueryResult> {
+  return post("/api/query/execute", { connectionId, database, sql, schema, executionId, ...options });
+}
+
+export async function executeMulti(
+  connectionId: string,
+  database: string,
+  sql: string,
+  schema?: string,
+  executionId?: string,
+  options?: {
+    maxRows?: number;
+    fetchSize?: number;
+    pageSize?: number;
+    resultSessionId?: string;
+    clientSessionId?: string;
+    timeoutSecs?: number;
+    useTransaction?: boolean;
+  },
+): Promise<QueryResult[]> {
+  return post("/api/query/execute-multi", { connectionId, database, sql, schema, executionId, ...options });
+}
+
+export async function closeQuerySession(connectionId: string, database: string, sessionId: string, clientSessionId?: string): Promise<boolean> {
+  return post("/api/query/close-session", { connectionId, database, sessionId, clientSessionId });
+}
+
+export async function closeClientConnectionSession(connectionId: string, database: string, clientSessionId: string): Promise<boolean> {
+  return post("/api/query/close-client-session", { connectionId, database, clientSessionId });
+}
+
+export async function executeBatch(connectionId: string, database: string, statements: string[], schema?: string): Promise<QueryResult> {
+  return post("/api/query/execute-batch", { connectionId, database, statements, schema });
+}
+
+export async function executeScript(connectionId: string, database: string, sql: string, schema?: string): Promise<QueryResult> {
+  return post("/api/query/execute-script", { connectionId, database, sql, schema });
+}
+
+export async function executeInTransaction(connectionId: string, database: string, statements: string[], schema?: string): Promise<QueryResult> {
+  return post("/api/query/execute-in-transaction", { connectionId, database, statements, schema });
+}
+
+export async function beginManualTransaction(_connectionId: string, _database: string, _schema?: string): Promise<string> {
+  throw new Error("Manual transaction management is only available in the desktop app.");
+}
+
+export async function executeInManualTransaction(_txnSessionId: string, _sql: string, _database: string, _schema?: string, _maxRows?: number): Promise<QueryResult[]> {
+  throw new Error("Manual transaction management is only available in the desktop app.");
+}
+
+export async function commitManualTransaction(_txnSessionId: string): Promise<QueryResult> {
+  throw new Error("Manual transaction management is only available in the desktop app.");
+}
+
+export async function rollbackManualTransaction(_txnSessionId: string): Promise<QueryResult> {
+  throw new Error("Manual transaction management is only available in the desktop app.");
+}
+
+export async function cancelQuery(executionId: string): Promise<boolean> {
+  const result = await post<boolean | { cancelled?: boolean }>("/api/query/cancel", { executionId });
+  return typeof result === "boolean" ? result : result.cancelled === true;
+}
+
+export async function analyzeSqlReferences(sql: string, dialect?: string): Promise<SqlReferenceAnalysis> {
+  return post("/api/query/analyze-sql-references", { sql, dialect });
+}
+
+export async function findStatementAtCursor(sql: string, cursorPos: number, databaseType?: DatabaseType): Promise<string> {
+  return post("/api/query/find-statement-at-cursor", { sql, cursorPos, databaseType });
+}
+
+export async function prepareQueryPaginationExecutionPlan(options: QueryPaginationExecutionPlanOptions): Promise<QueryPaginationExecutionPlan> {
+  return post("/api/query/prepare-pagination-plan", { options });
+}
+
+export async function buildSortedQuerySql(options: SortedQuerySqlOptions): Promise<QuerySqlBuildResult> {
+  return post("/api/query/build-sorted-sql", { options });
+}
+
+export async function buildExplainSql(options: BuildExplainSqlOptions): Promise<ExplainSqlBuildResult> {
+  return post("/api/query/build-explain-sql", { options });
+}
+
+export async function buildCreateUserSql(username: string, password: string, tablespace: string): Promise<string> {
+  return post("/api/query/build-create-user-sql", { username, password, tablespace });
+}
+
+export async function getExplainInfo(connectionId: string, database: string | undefined, schema: string | undefined, sql: string, mode: string): Promise<string | undefined> {
+  try {
+    const result = await post<string>("/api/query/get-explain-info", { connectionId, database, schema, sql, mode });
+    return result;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function buildDroppedFilePreviewSql(options: DroppedFilePreviewSqlOptions): Promise<string | undefined> {
+  const result = await post<string | null>("/api/query/build-dropped-file-preview-sql", { options });
+  return result ?? undefined;
+}
+
+export async function buildTableSelectSql(options: BuildTableSelectSqlOptions): Promise<string> {
+  return post("/api/query/build-table-select-sql", { options });
+}
+
+export async function buildDatabaseSearchSql(options: DatabaseSearchSqlOptions): Promise<DatabaseSearchSql | null> {
+  return post("/api/query/build-database-search-sql", { options });
+}
+
+export async function buildSearchResultWhere(options: SearchResultWhereOptions): Promise<string> {
+  return post("/api/query/build-search-result-where", { options });
+}
+
+export async function buildRenameObjectSql(options: BuildRenameObjectSqlOptions): Promise<string> {
+  return post("/api/query/build-rename-object-sql", { options });
+}
+
+export async function buildCreateDatabaseSql(options: CreateDatabaseSqlOptions): Promise<string> {
+  return post("/api/query/build-create-database-sql", { options });
+}
+
+export async function buildDuckDbAttachDatabaseSql(path: string, name: string): Promise<string> {
+  return post("/api/query/build-duckdb-attach-database-sql", { options: { path, name } });
+}
+
+export async function buildDropObjectSql(options: DropObjectSqlOptions): Promise<string> {
+  return post("/api/query/build-drop-object-sql", { options });
+}
+
+export async function buildDropTableSql(options: TableAdminSqlOptions): Promise<string> {
+  return post("/api/query/build-drop-table-sql", { options });
+}
+
+export async function buildDropTableChildObjectSql(options: DropTableChildObjectSqlOptions): Promise<string> {
+  return post("/api/query/build-drop-table-child-object-sql", { options });
+}
+
+export async function buildEmptyTableSql(options: TableAdminSqlOptions): Promise<string> {
+  return post("/api/query/build-empty-table-sql", { options });
+}
+
+export async function buildTruncateTableSql(options: TableAdminSqlOptions): Promise<string> {
+  return post("/api/query/build-truncate-table-sql", { options });
+}
+
+export async function buildDropDatabaseSql(options: DatabaseNameSqlOptions): Promise<string> {
+  return post("/api/query/build-drop-database-sql", { options });
+}
+
+export async function buildCreateSchemaSql(options: SchemaNameSqlOptions): Promise<string> {
+  return post("/api/query/build-create-schema-sql", { options });
+}
+
+export async function buildUpdateDatabasePropertiesSql(options: DatabasePropertyEditSqlOptions): Promise<string> {
+  return post("/api/query/build-update-database-properties-sql", { options });
+}
+
+export async function buildDropSchemaSql(options: SchemaNameSqlOptions): Promise<string> {
+  return post("/api/query/build-drop-schema-sql", { options });
+}
+
+export async function buildDuplicateTableStructureSql(options: DuplicateTableStructureSqlOptions): Promise<string> {
+  return post("/api/query/build-duplicate-table-structure-sql", { options });
+}
+
+export async function buildCopyTableDataSql(options: CopyTableDataSqlOptions): Promise<string> {
+  return post("/api/query/build-copy-table-data-sql", { options });
+}
+
+export async function buildExecutableObjectSourceStatements(input: BuildEditableObjectSourceSqlInput): Promise<string[]> {
+  return post("/api/query/build-executable-object-source-statements", { input });
+}
+
+export async function buildExecutableObjectSourceSql(input: BuildEditableObjectSourceSqlInput): Promise<string> {
+  return post("/api/query/build-executable-object-source-sql", { input });
+}
+
+export async function buildEditableObjectSource(input: BuildEditableObjectSourceSqlInput): Promise<string> {
+  return post("/api/query/build-editable-object-source", { input });
+}
+
+export async function buildRoutineRenameObjectSourceStatements(input: BuildRoutineRenameObjectSourceInput): Promise<string[]> {
+  return post("/api/query/build-routine-rename-object-source-statements", { input });
+}
+
+export async function buildViewDdlSql(input: BuildViewDdlInput): Promise<string> {
+  return post("/api/query/build-view-ddl-sql", { input });
+}
+
+export async function buildTableStructureChangeSql(options: BuildTableStructureChangeSqlOptions): Promise<TableStructureChangeSql> {
+  return post("/api/query/build-table-structure-change-sql", { options });
+}
+
+export async function previewSqliteTableStructureChange(connectionId: string, database: string, options: BuildTableStructureChangeSqlOptions): Promise<SqliteTableStructureChangePreview> {
+  return post("/api/query/preview-sqlite-table-structure-change", { connectionId, database, options });
+}
+
+export async function applySqliteTableStructureChange(connectionId: string, database: string, options: BuildTableStructureChangeSqlOptions, schemaRevision: string): Promise<QueryResult> {
+  return post("/api/query/apply-sqlite-table-structure-change", { connectionId, database, options, schemaRevision });
+}
+
+export async function buildCreateTableSql(options: BuildTableStructureChangeSqlOptions): Promise<TableStructureChangeSql> {
+  return post("/api/query/build-create-table-sql", { options });
+}
+
+export async function buildSingleColumnAlterSql(options: BuildSingleColumnAlterSqlOptions): Promise<TableStructureChangeSql> {
+  return post("/api/query/build-single-column-alter-sql", { options });
+}
+
+export async function analyzeEditableQueryEditability(sql: string): Promise<QueryEditability> {
+  return post("/api/query/analyze-editability", { sql });
+}
+
+export async function prepareDataGridSave(options: DataGridSaveStatementOptions): Promise<DataGridSavePreparation> {
+  return post("/api/query/prepare-data-grid-save", { options });
+}
+
+export async function buildDataGridCopyUpdateStatements(options: DataGridCopyUpdateStatementOptions): Promise<string[]> {
+  return post("/api/query/build-data-grid-copy-update-statements", { options });
+}
+
+export async function buildDataGridCopyInsertStatement(options: DataGridCopyInsertStatementOptions): Promise<string | undefined> {
+  const result = await post<string | null>("/api/query/build-data-grid-copy-insert-statement", { options });
+  return result ?? undefined;
+}
+
+export async function buildDataGridContextFilterCondition(options: DataGridContextFilterConditionOptions): Promise<string | undefined> {
+  const result = await post<string | null>("/api/query/build-data-grid-context-filter-condition", { options });
+  return result ?? undefined;
+}
+
+export async function buildDataGridColumnValueFilterCondition(options: DataGridColumnValueFilterConditionOptions): Promise<string | undefined> {
+  const result = await post<string | null>("/api/query/build-data-grid-column-value-filter-condition", { options });
+  return result ?? undefined;
+}
+
+export async function buildDataGridColumnValuesFilterCondition(options: DataGridColumnValuesFilterConditionOptions): Promise<string | undefined> {
+  const result = await post<string | null>("/api/query/build-data-grid-column-values-filter-condition", { options });
+  return result ?? undefined;
+}
+
+export async function buildDataGridColumnDistinctValuesSql(options: DataGridColumnDistinctValuesSqlOptions): Promise<string> {
+  return post("/api/query/build-data-grid-column-distinct-values-sql", { options });
+}
+
+export async function buildDataGridCountSql(options: DataGridCountSqlOptions): Promise<string> {
+  return post("/api/query/build-data-grid-count-sql", { options });
+}
+
+export async function buildHiveTablePropertiesSql(options: HiveTablePropertiesSqlOptions): Promise<string> {
+  return post("/api/query/build-hive-table-properties-sql", { options });
+}
+
+export async function buildExportInsertStatements(options: BuildExportInsertStatementsOptions): Promise<string[]> {
+  return post("/api/query/build-export-insert-statements", { options });
+}
+
+export async function buildExportSqlInsert(options: BuildExportInsertStatementsOptions): Promise<string> {
+  return post("/api/query/build-export-sql-insert", { options });
+}
+
+export async function buildDatabaseSqlExport(options: BuildDatabaseSqlExportOptions): Promise<string> {
+  return post("/api/query/build-database-sql-export", { options });
+}
+
+export async function prepareDataCompare(options: DataComparePreparationOptions): Promise<DataComparePreparation> {
+  return post("/api/data-compare/prepare", options);
+}
+
+export async function prepareDataCompareFromTables(options: DataCompareFromTablesOptions): Promise<DataCompareFromTablesPreparation> {
+  return post("/api/data-compare/prepare-from-tables", options);
+}
+
+export async function prepareDataCompareMissingTarget(options: import("@/lib/dataGrid/dataCompare").DataCompareMissingTargetOptions): Promise<DataCompareFromTablesPreparation> {
+  return post("/api/data-compare/prepare-missing-target", options);
+}
+
+export async function buildDataCompareSyncPlan(options: DataCompareSyncPlanOptions): Promise<DataCompareSyncPlan> {
+  return post("/api/data-compare/build-sync-plan", options);
+}
+
+// ---------------------------------------------------------------------------
+// AI
+// ---------------------------------------------------------------------------
+
+export async function aiComplete(request: AiCompletionRequest): Promise<string> {
+  return post("/api/ai/complete", { request });
+}
+
+export async function aiStream(sessionId: string, request: AiCompletionRequest, onChunk: (chunk: AiStreamChunk) => void): Promise<void> {
+  const res = await fetch(apiUrl("/api/ai/stream"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ session_id: sessionId, request }),
+  });
+  if (!res.ok) throw new Error(await res.text());
+
+  const reader = res.body!.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (line.startsWith("data:")) {
+        const data = line.slice(5).trim();
+        if (data && data !== "[DONE]") {
+          try {
+            const chunk: AiStreamChunk = JSON.parse(data);
+            onChunk(chunk);
+            if (chunk.done) return;
+          } catch {
+            // skip malformed JSON
+          }
+        }
+      }
+    }
+  }
+}
+
+export async function aiCancelStream(sessionId: string): Promise<boolean> {
+  return post("/api/ai/cancel-stream", { sessionId });
+}
+
+export async function aiTestConnection(config: AiConfig): Promise<AiTestConnectionResult> {
+  return post("/api/ai/test-connection", { config });
+}
+
+export async function aiListModels(config: AiConfig): Promise<AiModelInfo[]> {
+  return post("/api/ai/models", { config });
+}
+
+export type { AgentEvent } from "@/lib/backend/tauri";
+
+function isAgentEvent(v: unknown): v is import("@/lib/backend/tauri").AgentEvent {
+  return typeof v === "object" && v !== null && "type" in v && typeof (v as Record<string, unknown>).type === "string";
+}
+
+export async function aiAgentStream(sessionId: string, request: AiCompletionRequest, connectionId: string, database: string, dbType: string, onEvent: (event: import("@/lib/backend/tauri").AgentEvent) => void, mode?: string, allowWriteSql = false, signal?: AbortSignal): Promise<string> {
+  const res = await fetch(apiUrl("/api/ai/agent-stream"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ sessionId, request, connectionId, database, dbType, mode: mode || "ask", allowWriteSql }),
+    signal,
+  });
+  if (!res.ok) throw new Error(await res.text());
+
+  const reader = res.body!.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let result = "";
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (line.startsWith("data:")) {
+        const data = line.slice(5).trim();
+        if (data && data !== "[DONE]") {
+          try {
+            const parsed = JSON.parse(data);
+            if (!isAgentEvent(parsed)) {
+              console.warn("[aiAgentStream] Skipping invalid agent event:", data);
+              continue;
+            }
+            onEvent(parsed);
+            if (parsed.type === "agent_end" || parsed.type === "error") {
+              result = data;
+            }
+          } catch {
+            // skip malformed JSON
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+
+export async function saveAiConfig(config: AiConfig): Promise<void> {
+  return post("/api/ai/config", { config });
+}
+
+export async function saveAiProviderConfig(provider: string, config: AiConfig): Promise<void> {
+  return post("/api/ai/provider-config", { provider, config });
+}
+
+export async function loadAiProviderConfigs(): Promise<Record<string, AiConfig>> {
+  return get("/api/ai/provider-configs");
+}
+
+export async function loadAiConfig(): Promise<AiConfig | null> {
+  return get("/api/ai/config");
+}
+
+export async function loadDesktopSettings(): Promise<DesktopSettings> {
+  try {
+    const raw = safeLocalStorageGet(DESKTOP_SETTINGS_STORAGE_KEY);
+    return raw ? { ...DEFAULT_DESKTOP_SETTINGS, ...(JSON.parse(raw) as Partial<DesktopSettings>) } : { ...DEFAULT_DESKTOP_SETTINGS };
+  } catch {
+    return { ...DEFAULT_DESKTOP_SETTINGS };
+  }
+}
+
+export async function saveDesktopSettings(settings: DesktopSettings): Promise<void> {
+  safeLocalStorageSet(DESKTOP_SETTINGS_STORAGE_KEY, JSON.stringify({ ...DEFAULT_DESKTOP_SETTINGS, ...settings }));
+}
+
+export interface OpenTabsStatePayload {
+  tabs: unknown[];
+  activeTabId: string | null;
+}
+
+export async function loadEditorSettings(): Promise<unknown | null> {
+  return loadBrowserAppState("editor_settings");
+}
+
+export async function saveEditorSettings(settings: unknown): Promise<void> {
+  await saveBrowserAppState("editor_settings", settings);
+}
+
+export async function loadOpenTabsState(): Promise<OpenTabsStatePayload | null> {
+  const value = await loadBrowserAppState("open_tabs");
+  if (!value || typeof value !== "object") return null;
+  const payload = value as Partial<OpenTabsStatePayload>;
+  return Array.isArray(payload.tabs) ? { tabs: payload.tabs, activeTabId: typeof payload.activeTabId === "string" ? payload.activeTabId : null } : null;
+}
+
+export async function saveOpenTabsState(payload: OpenTabsStatePayload): Promise<void> {
+  await saveBrowserAppState("open_tabs", payload);
+}
+
+export async function loadSavedSqlEditorPositions(): Promise<unknown[] | null> {
+  const value = await loadBrowserAppState("saved_sql_editor_positions");
+  return Array.isArray(value) ? value : null;
+}
+
+export async function saveSavedSqlEditorPositions(positions: unknown[]): Promise<void> {
+  await saveBrowserAppState("saved_sql_editor_positions", positions);
+}
+
+export async function completeAppClose(_action: "quit" | "hide"): Promise<void> {
+  return undefined;
+}
+
+export async function requestAppClose(): Promise<void> {
+  return undefined;
+}
+
+export interface DriverStoreMigrationResult {
+  driver_store_dir: string | null;
+  plugin_store_dir: string | null;
+  agent_store_dir: string | null;
+  plugins_dir: string;
+  agents_dir: string;
+  migrated_plugins: boolean;
+  migrated_agents: boolean;
+}
+
+export async function setDriverStoreDir(_newDir: string | null): Promise<DriverStoreMigrationResult> {
+  throw new Error("Not available in web mode");
+}
+
+export async function setPluginStoreDir(_newDir: string | null): Promise<DriverStoreMigrationResult> {
+  throw new Error("Not available in web mode");
+}
+
+export async function setAgentStoreDir(_newDir: string | null): Promise<DriverStoreMigrationResult> {
+  throw new Error("Not available in web mode");
+}
+
+export interface DriverStorePathInfo {
+  driver_store_dir: string | null;
+  plugin_store_dir: string | null;
+  agent_store_dir: string | null;
+  plugins_dir: string;
+  agents_dir: string;
+}
+
+export async function getDriverStorePath(): Promise<DriverStorePathInfo> {
+  throw new Error("Not available in web mode");
+}
+
+export interface WebDavConfig {
+  endpoint: string;
+  username?: string;
+  password?: string;
+  remotePath?: string;
+}
+
+export interface WebDavSyncSummary {
+  remotePath: string;
+  bytes: number;
+  exportedAt?: string;
+  appVersion?: string;
+}
+
+export interface WebDavDownloadResult {
+  summary: WebDavSyncSummary;
+  editorSettings?: unknown;
+  desktopSettings: DesktopSettings;
+  applySummary: {
+    encryptedSecretsPresent: boolean;
+    secretsApplied: boolean;
+  };
+}
+
+export interface WebDavPasswordStatus {
+  hasSavedPassword: boolean;
+}
+
+export interface WebDavSyncSecretsStatus {
+  enabled: boolean;
+  hasSavedPassphrase: boolean;
+}
+
+export type SnippetProvider = "github" | "gitee";
+
+export interface SnippetSyncConfig {
+  provider: SnippetProvider;
+  token?: string;
+  snippetId?: string;
+}
+
+export interface SnippetSyncSummary {
+  provider: SnippetProvider;
+  snippetId: string;
+  bytes: number;
+  exportedAt?: string;
+  appVersion?: string;
+}
+
+export interface SnippetDownloadResult {
+  summary: SnippetSyncSummary;
+  editorSettings?: unknown;
+  desktopSettings: DesktopSettings;
+  applySummary: WebDavDownloadResult["applySummary"];
+}
+
+export interface SnippetTokenStatus {
+  hasSavedToken: boolean;
+}
+
+export async function webdavSyncTest(config: WebDavConfig): Promise<void> {
+  return post("/api/cloud-sync/webdav/test", { config });
+}
+
+export async function webdavPasswordStatus(config: WebDavConfig): Promise<WebDavPasswordStatus> {
+  return post("/api/cloud-sync/webdav/password-status", { config });
+}
+
+export async function saveWebdavSavedPassword(config: WebDavConfig, password: string): Promise<void> {
+  return post("/api/cloud-sync/webdav/save-password", { config, password });
+}
+
+export async function forgetWebdavSavedPassword(config: WebDavConfig): Promise<void> {
+  return post("/api/cloud-sync/webdav/forget-password", { config });
+}
+
+export async function webdavSyncSecretsStatus(): Promise<WebDavSyncSecretsStatus> {
+  return post("/api/cloud-sync/webdav/sync-secrets-status", {});
+}
+
+export async function saveWebdavSyncSecretsPreference(enabled: boolean, passphrase?: string): Promise<void> {
+  return post("/api/cloud-sync/webdav/save-sync-secrets-preference", { enabled, passphrase });
+}
+
+export async function forgetWebdavSyncSecretsPassphrase(): Promise<void> {
+  return post("/api/cloud-sync/webdav/forget-sync-secrets-passphrase", {});
+}
+
+export async function webdavSyncUpload(config: WebDavConfig, editorSettings?: unknown, secretsPassphrase?: string): Promise<WebDavSyncSummary> {
+  return post("/api/cloud-sync/webdav/upload", { config, editorSettings, secretsPassphrase });
+}
+
+export async function webdavSyncDownload(config: WebDavConfig, secretsPassphrase?: string): Promise<WebDavDownloadResult> {
+  return post("/api/cloud-sync/webdav/download", { config, secretsPassphrase });
+}
+
+export async function snippetSyncTest(config: SnippetSyncConfig): Promise<void> {
+  await post("/api/cloud-sync/snippet/test", { config });
+}
+
+export async function snippetTokenStatus(config: SnippetSyncConfig): Promise<SnippetTokenStatus> {
+  return post("/api/cloud-sync/snippet/token-status", { config });
+}
+
+export async function saveSnippetSavedToken(config: SnippetSyncConfig, token: string): Promise<void> {
+  await post("/api/cloud-sync/snippet/save-token", { config, token });
+}
+
+export async function forgetSnippetSavedToken(config: SnippetSyncConfig): Promise<void> {
+  await post("/api/cloud-sync/snippet/forget-token", { config });
+}
+
+export async function snippetSyncUpload(config: SnippetSyncConfig, editorSettings?: unknown, secretsPassphrase?: string): Promise<SnippetSyncSummary> {
+  return post("/api/cloud-sync/snippet/upload", { config, editorSettings, secretsPassphrase });
+}
+
+export async function snippetSyncDownload(config: SnippetSyncConfig, secretsPassphrase?: string): Promise<SnippetDownloadResult> {
+  return post("/api/cloud-sync/snippet/download", { config, secretsPassphrase });
+}
+
+export async function loadPinnedTreeNodeIds(): Promise<string[]> {
+  return get("/api/app-settings/pinned-tree-node-ids");
+}
+
+export async function savePinnedTreeNodeIds(_ids: string[]): Promise<void> {
+  return post("/api/app-settings/pinned-tree-node-ids", { ids: _ids });
+}
+
+// --- AI Conversations ---
+
+export async function saveAiConversation(conversation: AiConversation): Promise<void> {
+  return post("/api/ai/conversation", { conversation });
+}
+
+export async function loadAiConversations(): Promise<AiConversation[]> {
+  return get("/api/ai/conversations");
+}
+
+export async function deleteAiConversation(id: string): Promise<void> {
+  return del(`/api/ai/conversation/${id}`);
+}
+
+// ---------------------------------------------------------------------------
+// SQL File Execution
+// ---------------------------------------------------------------------------
+
+export async function previewSqlFile(fileOrPath: string | File): Promise<SqlFilePreview> {
+  if (typeof fileOrPath === "string") {
+    // In web mode a raw path is not useful; throw a clear error
+    throw new Error("previewSqlFile in web mode requires a File object, not a file path");
+  }
+  const formData = new FormData();
+  formData.append("file", fileOrPath);
+  const res = await fetch(apiUrl("/api/sql-file/preview"), { method: "POST", body: formData });
+  if (!res.ok) throw new Error(await res.text());
+  return res.json();
+}
+
+export async function executeSqlFile(request: SqlFileRequest): Promise<void> {
+  return post("/api/sql-file/execute", { request });
+}
+
+export async function cancelSqlFileExecution(executionId: string): Promise<boolean> {
+  return post("/api/sql-file/cancel", { executionId });
+}
+
+export async function listenSqlFileProgress(_handler: (progress: SqlFileProgress) => void): Promise<() => void> {
+  // For HTTP mode we need an executionId, but the tauri API does not take one.
+  // The SSE endpoint requires a specific executionId. As a workaround we return
+  // a no-op unlisten; callers that need progress in web mode should use
+  // the web-specific SQL file progress listener instead.
+  return () => {};
+}
+
+export async function pendingOpenSqlFiles(): Promise<string[]> {
+  return [];
+}
+
+export async function pendingOpenDbFiles(): Promise<string[]> {
+  return [];
+}
+
+export async function pendingOpenConnectionLinks(): Promise<string[]> {
+  return [];
+}
+
+export async function readExternalSqlFile(_path: string): Promise<string> {
+  throw new Error("Opening external SQL file paths is only available in the desktop app");
+}
+
+export async function writeExternalSqlFile(_path: string, _content: string): Promise<void> {
+  throw new Error("Saving external SQL file paths is only available in the desktop app");
+}
+
+export interface SqlFileEntry {
+  name: string;
+  path: string;
+  is_dir: boolean;
+  children: SqlFileEntry[];
+}
+
+export async function listSqlFilesInFolder(_folderPath: string): Promise<SqlFileEntry[]> {
+  throw new Error("Listing SQL files in a folder is only available in the desktop app");
+}
+
+// ---------------------------------------------------------------------------
+// Data Transfer
+// ---------------------------------------------------------------------------
+
+export async function startTransfer(request: TransferRequest, onProgress: (progress: TransferProgress) => void): Promise<void> {
+  // 1. POST to start the transfer
+  const res = await fetch(apiUrl("/api/transfer/start"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ request }),
+  });
+  if (!res.ok) throw new Error(await res.text());
+
+  // 2. SSE to listen for progress
+  return new Promise((resolve, reject) => {
+    const es = new EventSource(apiUrl(`/api/transfer/progress/${request.transferId}`));
+    es.onmessage = (e) => {
+      const progress: TransferProgress = JSON.parse(e.data);
+      onProgress(progress);
+      if (isTerminalTransferProgress(progress)) {
+        es.close();
+        resolve();
+      }
+    };
+    es.onerror = () => {
+      es.close();
+      reject(new Error("Transfer SSE connection failed"));
+    };
+  });
+}
+
+export async function cancelTransfer(transferId: string): Promise<void> {
+  return post("/api/transfer/cancel", { transferId });
+}
+
+export async function previewTransferOwnership(request: TransferRequest): Promise<TransferOwnershipPreview> {
+  return post("/api/transfer/ownership-preview", { request });
+}
+
+export interface SortTablesByFkOptions {
+  connectionId: string;
+  database: string;
+  schema: string;
+  tables: string[];
+  parentsFirst: boolean;
+}
+
+export async function sortTablesByFkDependency(options: SortTablesByFkOptions): Promise<string[]> {
+  return post("/api/transfer/sort-tables-by-fk", options);
+}
+
+// ---------------------------------------------------------------------------
+// Table File Import
+// ---------------------------------------------------------------------------
+
+export async function previewTableImportFile(fileOrPath: string | File | TableImportPreviewRequest, options: Partial<TableImportPreviewRequest> = {}): Promise<TableImportPreview> {
+  if (typeof fileOrPath === "object" && !(fileOrPath instanceof File)) {
+    throw new Error("previewTableImportFile in web mode requires a File object for upload previews");
+  }
+  if (typeof fileOrPath === "string") {
+    if (!options.sourceRef) {
+      throw new Error("previewTableImportFile in web mode requires a File object for new uploads");
+    }
+    const res = await fetch(apiUrl("/api/import/preview"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ request: { ...options, filePath: fileOrPath } }),
+    });
+    if (!res.ok) throw new Error(await res.text());
+    return res.json();
+  }
+  const formData = new FormData();
+  formData.append("file", fileOrPath);
+  if (options.sourceFormat) formData.append("sourceFormat", options.sourceFormat);
+  if (options.parseOptions) formData.append("parseOptions", JSON.stringify(options.parseOptions));
+  if (options.previewLimit != null) formData.append("previewLimit", String(options.previewLimit));
+  const res = await fetch(apiUrl("/api/import/preview"), { method: "POST", body: formData });
+  if (!res.ok) throw new Error(await res.text());
+  return res.json();
+}
+
+export async function importTableFile(request: TableImportRequest, onProgress: (progress: TableImportProgress) => void): Promise<TableImportSummary> {
+  // 1. POST to start the import
+  const res = await fetch(apiUrl("/api/import/execute"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ request }),
+  });
+  if (!res.ok) throw new Error(await res.text());
+
+  // 2. SSE to listen for progress
+  return new Promise((resolve, reject) => {
+    const es = new EventSource(apiUrl(`/api/import/progress/${request.importId}`));
+    let summary: TableImportSummary | null = null;
+    es.onmessage = (e) => {
+      const progress: TableImportProgress = JSON.parse(e.data);
+      onProgress(progress);
+      if (progress.status === "done") {
+        summary = {
+          importId: progress.importId,
+          rowsImported: progress.rowsImported,
+          totalRows: progress.totalRows,
+        };
+        es.close();
+        resolve(summary);
+      } else if (progress.status === "error" || progress.status === "cancelled") {
+        es.close();
+        reject(new Error(progress.error || "Import failed"));
+      }
+    };
+    es.onerror = () => {
+      es.close();
+      reject(new Error("Import SSE connection failed"));
+    };
+  });
+}
+
+export async function cancelTableImport(importId: string): Promise<boolean> {
+  return post("/api/import/cancel", { importId });
+}
+
+// ---------------------------------------------------------------------------
+// Database Export
+// ---------------------------------------------------------------------------
+
+export async function exportDatabaseSql(request: DatabaseExportRequest, onProgress: (progress: ExportProgress) => void): Promise<void> {
+  // 1. POST to start the export
+  const res = await fetch(apiUrl("/api/export/database"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ request }),
+  });
+  if (!res.ok) throw new Error(await res.text());
+
+  // 2. SSE to listen for progress
+  return new Promise((resolve, reject) => {
+    const es = new EventSource(apiUrl(`/api/export/database/progress/${request.exportId}`));
+    es.onmessage = (e) => {
+      const progress: ExportProgress = JSON.parse(e.data);
+      onProgress(progress);
+      if (progress.status === "Done" || progress.status === "Error" || progress.status === "Cancelled") {
+        es.close();
+        if (progress.status === "Done") {
+          // Trigger browser download; filename is decided by the server's
+          // Content-Disposition header.
+          downloadDatabaseExportFile(request.exportId);
+        }
+        resolve();
+      }
+    };
+    es.onerror = () => {
+      es.close();
+      reject(new Error("Export SSE connection failed"));
+    };
+  });
+}
+
+function downloadDatabaseExportFile(exportId: string): void {
+  const a = document.createElement("a");
+  a.href = apiUrl(`/api/export/database/download/${exportId}`);
+  a.click();
+}
+
+export async function cancelDatabaseExport(exportId: string): Promise<void> {
+  await post("/api/export/database/cancel", { exportId });
+}
+
+// --- Table Export ---
+
+export async function startTableExport(request: TableExportRequest, onProgress: (progress: TableExportProgress) => void): Promise<TableExportProgress> {
+  const { exportId } = request;
+
+  return new Promise((resolve, reject) => {
+    let started = false;
+    let settled = false;
+    const eventSource = new EventSource(apiUrl(`/api/export/table/progress/${exportId}`));
+
+    const finish = (callback: () => void) => {
+      if (settled) return;
+      settled = true;
+      eventSource.close();
+      callback();
+    };
+
+    eventSource.onopen = () => {
+      if (started) return;
+      started = true;
+      post("/api/export/table", { request }).catch((error) => {
+        finish(() => reject(error));
+      });
+    };
+
+    eventSource.onmessage = (event) => {
+      const progress: TableExportProgress = JSON.parse(event.data);
+      onProgress(progress);
+      if (progress.status === "Done" || progress.status === "Error" || progress.status === "Cancelled") {
+        if (progress.status === "Error") {
+          finish(() => reject(new Error(progress.errorMessage || "Export failed")));
+        } else if (progress.status === "Done") {
+          // Trigger browser download
+          downloadTableExportFile(exportId, request.format);
+          finish(() => resolve(progress));
+        } else {
+          finish(() => resolve(progress));
+        }
+      }
+    };
+
+    eventSource.onerror = () => {
+      finish(() => reject(new Error("Export progress connection lost")));
+    };
+  });
+}
+
+function downloadTableExportFile(exportId: string, format: string): void {
+  const ext = format === "markdown" || format === "md" ? "md" : format;
+  const a = document.createElement("a");
+  a.href = apiUrl(`/api/export/table/download/${exportId}`);
+  a.download = `table_export_${exportId}.${ext}`;
+  a.click();
+}
+
+export async function cancelTableExport(exportId: string): Promise<void> {
+  return post("/api/export/table/cancel", { exportId });
+}
+
+export async function startQueryResultExport(request: QueryResultExportRequest, onProgress: (progress: TableExportProgress) => void): Promise<TableExportProgress> {
+  const { exportId } = request;
+
+  return new Promise((resolve, reject) => {
+    let started = false;
+    let settled = false;
+    const eventSource = new EventSource(apiUrl(`/api/export/query-result/progress/${exportId}`));
+
+    const finish = (callback: () => void) => {
+      if (settled) return;
+      settled = true;
+      eventSource.close();
+      callback();
+    };
+
+    eventSource.onopen = () => {
+      if (started) return;
+      started = true;
+      post("/api/export/query-result", { request }).catch((error) => {
+        finish(() => reject(error));
+      });
+    };
+
+    eventSource.onmessage = (event) => {
+      const progress: TableExportProgress = JSON.parse(event.data);
+      onProgress(progress);
+      if (progress.status === "Done" || progress.status === "Error" || progress.status === "Cancelled") {
+        if (progress.status === "Error") {
+          finish(() => reject(new Error(progress.errorMessage || "Export failed")));
+        } else if (progress.status === "Done") {
+          downloadQueryResultExportFile(exportId, request.format);
+          finish(() => resolve(progress));
+        } else {
+          finish(() => resolve(progress));
+        }
+      }
+    };
+
+    eventSource.onerror = () => {
+      finish(() => reject(new Error("Export progress connection lost")));
+    };
+  });
+}
+
+function downloadQueryResultExportFile(exportId: string, format: string): void {
+  const a = document.createElement("a");
+  a.href = apiUrl(`/api/export/query-result/download/${exportId}`);
+  a.download = `query_result_export_${exportId}.${format}`;
+  a.click();
+}
+
+export async function cancelQueryResultExport(exportId: string, executionId?: string): Promise<void> {
+  return post("/api/export/query-result/cancel", {
+    exportId,
+    ...(executionId ? { executionId } : {}),
+  });
+}
+
+export async function exportQueryResultCsv(filePath: string, columns: string[], rows: readonly (readonly XlsxCellValue[])[]): Promise<void> {
+  const { formatCsv } = await import("@/lib/export/exportFormats");
+  const content = formatCsv(columns, rows as (string | number | boolean | null)[][]);
+  const fileName = filePath.split(/[\\/]/).pop() || "export.csv";
+  const blob = new Blob(["\uFEFF", content], { type: "text/csv;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = fileName;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+export async function exportTableDataCsv(_options: TableCsvExportOptions): Promise<number> {
+  throw new Error("Streaming table CSV export is only available in the desktop runtime");
+}
+
+function downloadTextFile(filePath: string, fallbackFileName: string, content: string, mimeType: string): void {
+  const fileName = filePath.split(/[\\/]/).pop() || fallbackFileName;
+  const blob = new Blob(["\uFEFF", content], { type: mimeType });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = fileName;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+export async function exportQueryResultXlsx(filePath: string, sheetName: string | undefined, columns: string[], columnTypes: string[], rows: readonly (readonly XlsxCellValue[])[]): Promise<void> {
+  const { buildXlsxWorkbook } = await import("@/lib/export/xlsxExport");
+  const workbook = buildXlsxWorkbook({
+    sheetName: sheetName || "Export",
+    columns,
+    columnTypes,
+    rows,
+  });
+  const fileName = filePath.split(/[\\/]/).pop() || "export.xlsx";
+  const blob = new Blob([new Uint8Array(workbook)], {
+    type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = fileName;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+export async function exportQueryResultsXlsx(filePath: string, worksheets: readonly { sheetName?: string; columns: string[]; columnTypes?: string[]; rows: readonly (readonly XlsxCellValue[])[] }[]): Promise<void> {
+  const { buildXlsxWorkbookMulti } = await import("@/lib/export/xlsxExport");
+  const workbook = buildXlsxWorkbookMulti(worksheets);
+  const fileName = filePath.split(/[\\/]/).pop() || "export.xlsx";
+  const blob = new Blob([new Uint8Array(workbook)], {
+    type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = fileName;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+
+export async function exportQueryResultJson(filePath: string, columns: string[], rows: readonly (readonly XlsxCellValue[])[]): Promise<void> {
+  const result = await post<{ content: string }>("/api/export/query-result-json", { columns, rows });
+  downloadTextFile(filePath, "export.json", result.content, "application/json;charset=utf-8");
+}
+
+export async function exportQueryResultMarkdown(filePath: string, columns: string[], rows: readonly (readonly XlsxCellValue[])[]): Promise<void> {
+  const result = await post<{ content: string }>("/api/export/query-result-markdown", { columns, rows });
+  downloadTextFile(filePath, "export.md", result.content, "text/markdown;charset=utf-8");
+}
+
+// ---------------------------------------------------------------------------
+// Redis
+// ---------------------------------------------------------------------------
+
+export async function redisListDatabases(connectionId: string): Promise<RedisDatabaseInfo[]> {
+  return post("/api/redis/list-databases", { connectionId });
+}
+
+export async function redisScanKeys(connectionId: string, db: number, cursor: number, pattern: string, count: number): Promise<RedisScanResult> {
+  return post("/api/redis/scan-keys", { connectionId, db, cursor, pattern, count });
+}
+
+export async function redisScanKeysBatch(connectionId: string, db: number, cursor: number, pattern: string, count: number, maxIterations: number, includeTypes = true): Promise<RedisScanResult> {
+  return post("/api/redis/scan-keys-batch", { connectionId, db, cursor, pattern, count, maxIterations, includeTypes });
+}
+
+export async function redisScanValues(connectionId: string, db: number, cursor: number, pattern: string, query: string, count: number, includeKeyMatches = false): Promise<RedisScanResult> {
+  return post("/api/redis/scan-values", { connectionId, db, cursor, pattern, query, includeKeyMatches, count });
+}
+
+export async function redisGetValue(connectionId: string, db: number, keyRaw: string): Promise<RedisValue> {
+  return post("/api/redis/get-value", { connectionId, db, keyRaw });
+}
+
+export async function redisSetString(connectionId: string, db: number, keyRaw: string, value: string, ttl?: number): Promise<void> {
+  return post("/api/redis/set-string", { connectionId, db, keyRaw, value, ttl });
+}
+
+export async function redisDeleteKey(connectionId: string, db: number, keyRaw: string): Promise<void> {
+  return post("/api/redis/delete-key", { connectionId, db, keyRaw });
+}
+
+export async function redisHashSet(connectionId: string, db: number, keyRaw: string, field: string, value: string, ttl?: number): Promise<void> {
+  return post("/api/redis/hash-set", { connectionId, db, keyRaw, field, value, ttl });
+}
+
+export async function redisHashDel(connectionId: string, db: number, keyRaw: string, field: string): Promise<void> {
+  return post("/api/redis/hash-del", { connectionId, db, keyRaw, field });
+}
+
+export async function redisListPush(connectionId: string, db: number, keyRaw: string, value: string, ttl?: number): Promise<void> {
+  return post("/api/redis/list-push", { connectionId, db, keyRaw, value, ttl });
+}
+
+export async function redisListSet(connectionId: string, db: number, keyRaw: string, index: number, value: string): Promise<void> {
+  return post("/api/redis/list-set", { connectionId, db, keyRaw, index, value });
+}
+
+export async function redisListRemove(connectionId: string, db: number, keyRaw: string, index: number): Promise<void> {
+  return post("/api/redis/list-remove", { connectionId, db, keyRaw, index });
+}
+
+export async function redisSetAdd(connectionId: string, db: number, keyRaw: string, member: string, ttl?: number): Promise<void> {
+  return post("/api/redis/set-add", { connectionId, db, keyRaw, member, ttl });
+}
+
+export async function redisSetRemove(connectionId: string, db: number, keyRaw: string, member: string): Promise<void> {
+  return post("/api/redis/set-remove", { connectionId, db, keyRaw, member });
+}
+
+export async function redisZadd(connectionId: string, db: number, keyRaw: string, member: string, score: number, ttl?: number): Promise<void> {
+  return post("/api/redis/zadd", { connectionId, db, keyRaw, member, score, ttl });
+}
+
+export async function redisZrem(connectionId: string, db: number, keyRaw: string, member: string): Promise<void> {
+  return post("/api/redis/zrem", { connectionId, db, keyRaw, member });
+}
+
+export async function redisStreamAdd(connectionId: string, db: number, keyRaw: string, entryId: string, fields: [string, string][], ttl?: number): Promise<void> {
+  return post("/api/redis/stream-add", { connectionId, db, keyRaw, entryId, fields, ttl });
+}
+
+export async function redisJsonSet(connectionId: string, db: number, keyRaw: string, value: string, ttl?: number): Promise<void> {
+  return post("/api/redis/json-set", { connectionId, db, keyRaw, value, ttl });
+}
+
+export async function redisCheckJsonModule(connectionId: string, db: number): Promise<boolean> {
+  return post("/api/redis/check-json-module", { connectionId, db });
+}
+
+export async function redisSetTtl(connectionId: string, db: number, keyRaw: string, ttl: number): Promise<void> {
+  return post("/api/redis/set-ttl", { connectionId, db, keyRaw, ttl });
+}
+
+export async function redisDeleteKeys(connectionId: string, db: number, keyRaws: string[]): Promise<number> {
+  return post("/api/redis/delete-keys", { connectionId, db, keyRaws });
+}
+
+export async function redisFlushDb(connectionId: string, db: number): Promise<void> {
+  return post("/api/redis/flush-db", { connectionId, db });
+}
+
+export async function redisExecuteCommand(connectionId: string, db: number, command: string, skipSafetyCheck?: boolean): Promise<RedisCommandResult> {
+  return post("/api/redis/execute-command", { connectionId, db, command, skipSafetyCheck: skipSafetyCheck ?? false });
+}
+
+export async function redisLoadMore(connectionId: string, db: number, keyRaw: string, keyType: string, cursor: number, count: number, filter?: string): Promise<RedisCollectionPage> {
+  return post("/api/redis/load-more", { connectionId, db, keyRaw, keyType, cursor, count, filter });
+}
+
+export async function redisPubSubPublish(connectionId: string, db: number, channel: string, message: string): Promise<{ subscribers: number }> {
+  return post("/api/redis/pubsub/publish", { connectionId, db, channel, message });
+}
+
+export async function redisPubSubConnect(connectionId: string): Promise<WebSocket> {
+  return new WebSocket(apiWebSocketUrl(`/api/redis/pubsub/ws?connectionId=${encodeURIComponent(connectionId)}`));
+}
+
+export async function redisSlowlogGet(connectionId: string, count: number, nodeHost?: string, nodePort?: number): Promise<RedisSlowlogEntry[]> {
+  return post("/api/redis/slowlog-get", { connectionId, count, nodeHost, nodePort });
+}
+
+export async function redisClusterMasterNodes(connectionId: string): Promise<RedisNodeEndpoint[]> {
+  return post("/api/redis/cluster-master-nodes", { connectionId });
+}
+
+// ---------------------------------------------------------------------------
+// etcd
+// ---------------------------------------------------------------------------
+
+export async function etcdListPrefix(connectionId: string, prefix: string, limit: number, continuation?: string | null): Promise<KvListPrefixResponse> {
+  return post("/api/etcd/list-prefix", { connectionId, prefix, limit, continuation });
+}
+
+export async function etcdGet(connectionId: string, key: string): Promise<KvGetResponse> {
+  return post("/api/etcd/get", { connectionId, key });
+}
+
+export async function etcdPut(connectionId: string, key: string, value: KvValue, lease?: number | null): Promise<KvPutResponse> {
+  return post("/api/etcd/put", { connectionId, key, value, lease });
+}
+
+export async function etcdDelete(connectionId: string, key: string): Promise<KvDeleteResponse> {
+  return post("/api/etcd/delete", { connectionId, key });
+}
+
+// ---------------------------------------------------------------------------
+// ZooKeeper
+// ---------------------------------------------------------------------------
+
+export async function zookeeperListPrefix(connectionId: string, prefix: string, limit: number, continuation?: string | null, options?: KvListPrefixOptions | null): Promise<KvListPrefixResponse> {
+  return post("/api/zookeeper/list-prefix", { connectionId, prefix, limit, continuation, recursive: options?.recursive ?? null });
+}
+
+export async function zookeeperGet(connectionId: string, key: string): Promise<KvGetResponse> {
+  return post("/api/zookeeper/get", { connectionId, key });
+}
+
+export async function zookeeperPut(connectionId: string, key: string, value: KvValue, options?: KvPutOptions | null): Promise<KvPutResponse> {
+  return post("/api/zookeeper/put", { connectionId, key, value, options: options ?? null });
+}
+
+export async function zookeeperDelete(connectionId: string, key: string): Promise<KvDeleteResponse> {
+  return post("/api/zookeeper/delete", { connectionId, key });
+}
+
+// ---------------------------------------------------------------------------
+// Nacos
+// ---------------------------------------------------------------------------
+
+export async function nacosTestConnection(connectionId: string): Promise<NacosConnectionInfo> {
+  return post("/api/nacos/test-connection", { connectionId });
+}
+
+export async function nacosListNamespaces(connectionId: string): Promise<NacosNamespaceInfo[]> {
+  return post("/api/nacos/namespaces/list", { connectionId });
+}
+
+export async function nacosCreateNamespace(connectionId: string, req: NacosNamespaceCreate): Promise<void> {
+  return post("/api/nacos/namespaces/create", { connectionId, req });
+}
+
+export async function nacosUpdateNamespace(connectionId: string, req: NacosNamespaceUpdate): Promise<void> {
+  return post("/api/nacos/namespaces/update", { connectionId, req });
+}
+
+export async function nacosListConfigs(connectionId: string, query: NacosConfigQuery): Promise<NacosConfigList> {
+  return post("/api/nacos/configs/list", { connectionId, query });
+}
+
+export async function nacosGetConfig(connectionId: string, key: NacosConfigKey): Promise<NacosConfigItem> {
+  return post("/api/nacos/configs/get", { connectionId, key });
+}
+
+export async function nacosPublishConfig(connectionId: string, req: NacosConfigUpsert): Promise<void> {
+  return post("/api/nacos/configs/publish", { connectionId, req });
+}
+
+export async function nacosDeleteConfig(connectionId: string, key: NacosConfigKey): Promise<void> {
+  return post("/api/nacos/configs/delete", { connectionId, key });
+}
+
+export async function nacosListConfigHistory(connectionId: string, query: NacosConfigHistoryQuery): Promise<NacosConfigHistoryList> {
+  return post("/api/nacos/configs/history/list", { connectionId, query });
+}
+
+export async function nacosGetConfigHistory(connectionId: string, key: NacosConfigHistoryKey): Promise<NacosConfigItem> {
+  return post("/api/nacos/configs/history/get", { connectionId, key });
+}
+
+export async function nacosRollbackConfig(connectionId: string, req: NacosConfigRollbackRequest): Promise<void> {
+  return post("/api/nacos/configs/history/rollback", { connectionId, req });
+}
+
+export async function nacosListServices(connectionId: string, query: NacosServiceQuery): Promise<NacosServiceList> {
+  return post("/api/nacos/services/list", { connectionId, query });
+}
+
+export async function nacosListInstances(connectionId: string, query: NacosInstanceQuery): Promise<NacosInstanceInfo[]> {
+  return post("/api/nacos/instances/list", { connectionId, query });
+}
+
+export async function nacosUpdateInstance(connectionId: string, req: NacosInstanceUpdate): Promise<void> {
+  return post("/api/nacos/instances/update", { connectionId, req });
+}
+
+export async function nacosRawRequest(connectionId: string, req: NacosRawRequest): Promise<NacosRawResponse> {
+  return post("/api/nacos/raw", { connectionId, req });
+}
+
+// ---------------------------------------------------------------------------
+// MongoDB
+// ---------------------------------------------------------------------------
+
+export async function documentListDatabases(connectionId: string): Promise<string[]> {
+  return post("/api/document-store/list-databases", { connectionId });
+}
+
+export async function mongoListDatabases(connectionId: string): Promise<string[]> {
+  return documentListDatabases(connectionId);
+}
+
+export async function documentListCollections(connectionId: string, database: string): Promise<CollectionInfo[]> {
+  return post("/api/document-store/list-collections", { connectionId, database });
+}
+
+export async function mongoListCollections(connectionId: string, database: string): Promise<CollectionInfo[]> {
+  return documentListCollections(connectionId, database);
+}
+
+export async function mongoCreateDatabase(connectionId: string, database: string): Promise<void> {
+  await post("/api/mongo/create-database", { connectionId, database });
+}
+
+export async function mongoDropDatabase(connectionId: string, database: string): Promise<void> {
+  await post("/api/mongo/drop-database", { connectionId, database });
+}
+
+export async function mongoDropCollection(connectionId: string, database: string, collection: string): Promise<void> {
+  await post("/api/mongo/drop-collection", { connectionId, database, collection });
+}
+
+export async function elasticsearchListIndices(connectionId: string): Promise<string[]> {
+  const collections = await documentListCollections(connectionId, "default");
+  return collections.map((c) => c.name);
+}
+
+export async function vectorListCollections(connectionId: string, database?: string): Promise<CollectionInfo[]> {
+  return documentListCollections(connectionId, database || "default");
+}
+
+export async function vectorGetCollectionDetail(connectionId: string, database: string, collection: string): Promise<CollectionInfo> {
+  return post("/api/mongo/vector-collection-detail", { connectionId, database, collection });
+}
+
+export async function mongoFindDocuments(connectionId: string, database: string, collection: string, skip: number, limit: number, filter?: string, projection?: string, sort?: string, executionId?: string): Promise<MongoDocumentResult> {
+  return documentFindDocuments(connectionId, database, collection, skip, limit, filter, projection, sort, executionId);
+}
+
+export async function documentFindDocuments(connectionId: string, database: string, collection: string, skip: number, limit: number, filter?: string, projection?: string, sort?: string, executionId?: string): Promise<MongoDocumentResult> {
+  return post("/api/document-store/find-documents", { connectionId, database, collection, skip, limit, filter, projection, sort, executionId });
+}
+
+export async function documentListGridFsFiles(connectionId: string, database: string, bucket: string, filter?: string, sort?: string): Promise<MongoGridFsFileInfo[]> {
+  return post("/api/document-store/list-gridfs-files", { connectionId, database, bucket, filter, sort });
+}
+
+export async function documentListGridFsBuckets(connectionId: string, database: string, filter?: string, sort?: string): Promise<MongoGridFsBucketInfo[]> {
+  return post("/api/document-store/list-gridfs-buckets", { connectionId, database, filter, sort });
+}
+
+export async function documentCreateGridFsBucket(connectionId: string, database: string, bucket: string): Promise<void> {
+  return post("/api/document-store/create-gridfs-bucket", { connectionId, database, bucket });
+}
+
+export async function documentDeleteGridFsBucket(connectionId: string, database: string, bucket: string): Promise<void> {
+  return post("/api/document-store/delete-gridfs-bucket", { connectionId, database, bucket });
+}
+
+export async function documentDownloadGridFsFile(connectionId: string, database: string, bucket: string, fileId: string): Promise<Uint8Array> {
+  const res = await fetch(apiUrl("/api/document-store/download-gridfs-file"), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ connectionId, database, bucket, fileId }),
+  });
+  if (!res.ok) throw new Error(await res.text());
+  const data = (await res.json()) as number[];
+  return new Uint8Array(data);
+}
+
+export async function documentUploadGridFsFile(connectionId: string, database: string, bucket: string, fileName: string, data: Uint8Array, contentType?: string): Promise<string> {
+  const body = new FormData();
+  body.append("connectionId", connectionId);
+  body.append("database", database);
+  body.append("bucket", bucket);
+  body.append("fileName", fileName);
+  if (contentType) body.append("contentType", contentType);
+  const bytes = new Uint8Array(data.byteLength);
+  bytes.set(data);
+  body.append("file", new Blob([bytes], { type: contentType || "application/octet-stream" }), fileName);
+  const res = await fetch(apiUrl("/api/document-store/upload-gridfs-file"), {
+    method: "POST",
+    body,
+  });
+  if (!res.ok) throw new Error(await res.text());
+  return res.json();
+}
+
+export async function documentDeleteGridFsFile(connectionId: string, database: string, bucket: string, fileId: string): Promise<void> {
+  return post("/api/document-store/delete-gridfs-file", { connectionId, database, bucket, fileId });
+}
+
+export async function mongoServerVersion(connectionId: string, database: string, executionId?: string): Promise<string> {
+  return post("/api/mongo/server-version", { connectionId, database, executionId });
+}
+
+export async function mongoAggregateDocuments(connectionId: string, database: string, collection: string, pipelineJson: string, maxRows?: number, executionId?: string): Promise<MongoDocumentResult> {
+  return post("/api/mongo/aggregate-documents", { connectionId, database, collection, pipelineJson, maxRows, executionId });
+}
+
+export async function mongoCollectionStats(connectionId: string, database: string, collection: string, scale?: number, executionId?: string): Promise<MongoCollectionStatsResult> {
+  return post("/api/mongo/collection-stats", { connectionId, database, collection, scale, executionId });
+}
+
+export async function mongoCreateIndex(connectionId: string, database: string, collection: string, keysJson: string, optionsJson?: string): Promise<{ name: string }> {
+  return post("/api/mongo/create-index", { connectionId, database, collection, keysJson, optionsJson });
+}
+
+export async function mongoDropIndexes(connectionId: string, database: string, collection: string, indexesJson?: string, single = false): Promise<{ dropped_names: string[]; affected_rows: number }> {
+  return post("/api/mongo/drop-indexes", { connectionId, database, collection, indexesJson, single });
+}
+
+export async function mongoInsertDocument(connectionId: string, database: string, collection: string, docJson: string): Promise<string> {
+  return documentInsertDocument(connectionId, database, collection, docJson);
+}
+
+export async function documentInsertDocument(connectionId: string, database: string, collection: string, docJson: string): Promise<string> {
+  return post("/api/document-store/insert-document", { connectionId, database, collection, docJson });
+}
+
+export async function mongoInsertDocuments(connectionId: string, database: string, collection: string, docsJson: string): Promise<{ affected_rows: number }> {
+  return post("/api/mongo/insert-documents", { connectionId, database, collection, docsJson });
+}
+
+export async function mongoUpdateDocument(connectionId: string, database: string, collection: string, id: string, docJson: string, routing?: string): Promise<number> {
+  return documentUpdateDocument(connectionId, database, collection, id, docJson, routing);
+}
+
+export async function documentUpdateDocument(connectionId: string, database: string, collection: string, id: string, docJson: string, routing?: string): Promise<number> {
+  return post("/api/document-store/update-document", { connectionId, database, collection, id, docJson, routing });
+}
+
+export async function mongoUpdateDocuments(connectionId: string, database: string, collection: string, filterJson: string, updateJson: string, many: boolean, optionsJson?: string): Promise<{ affected_rows: number }> {
+  return post("/api/mongo/update-documents", { connectionId, database, collection, filterJson, updateJson, many, optionsJson });
+}
+
+export async function mongoDeleteDocument(connectionId: string, database: string, collection: string, id: string, routing?: string): Promise<number> {
+  return documentDeleteDocument(connectionId, database, collection, id, routing);
+}
+
+export async function documentDeleteDocument(connectionId: string, database: string, collection: string, id: string, routing?: string): Promise<number> {
+  return post("/api/document-store/delete-document", { connectionId, database, collection, id, routing });
+}
+
+export async function mongoDeleteDocuments(connectionId: string, database: string, collection: string, filterJson: string, many: boolean): Promise<{ affected_rows: number }> {
+  return post("/api/mongo/delete-documents", { connectionId, database, collection, filterJson, many });
+}
+
+// ---------------------------------------------------------------------------
+// History
+// ---------------------------------------------------------------------------
+
+export async function saveHistory(entry: HistoryEntry): Promise<void> {
+  return post("/api/history/save", { entry });
+}
+
+export async function loadHistory(limit: number, offset: number, activityKind?: string): Promise<HistoryEntry[]> {
+  return get(`/api/history?${qs({ limit, offset, activity_kind: activityKind })}`);
+}
+
+export async function loadRedisHistory(limit = 100, offset = 0): Promise<HistoryEntry[]> {
+  return loadHistory(limit, offset, "redis_command");
+}
+
+export async function clearHistory(): Promise<void> {
+  return del("/api/history");
+}
+
+export async function clearRedisHistory(): Promise<void> {
+  const entries = await loadRedisHistory(1000, 0);
+  await Promise.all(entries.map((e) => deleteHistoryEntry(e.id)));
+}
+
+export async function deleteHistoryEntry(id: string): Promise<void> {
+  return del(`/api/history/${id}`);
+}
+
+// ---------------------------------------------------------------------------
+// Updates
+// ---------------------------------------------------------------------------
+
+export async function checkForUpdates(locale?: string): Promise<UpdateInfo> {
+  const query = locale ? `?locale=${encodeURIComponent(locale)}` : "";
+  return get(`/api/update/check${query}`);
+}
+
+export async function checkMcpServerStatus(): Promise<import("@/lib/backend/tauri").McpServerStatus> {
+  return {
+    installed: false,
+    npm_available: false,
+    node_path: null,
+    node_version: null,
+    current_version: null,
+    latest_version: null,
+    update_available: false,
+    bin_path: null,
+    script_path: null,
+    install_command: "npm install -g @dbx-app/mcp-server@latest --registry=https://registry.npmjs.org",
+    update_command: "npm install -g @dbx-app/mcp-server@latest --registry=https://registry.npmjs.org",
+    error: "MCP Server status is only available in the desktop app.",
+  };
+}
+
+export async function installMcpServer(): Promise<string> {
+  throw new Error("MCP Server installation is only available in the desktop app.");
+}
+
+export async function getSystemProxyUrl(): Promise<string | null> {
+  return null;
+}
+
+export async function downloadAndInstallUpdate(_source: UpdateDownloadSource, _latestVersion?: string): Promise<void> {
+  throw new Error("In-app update installation is only available in the desktop app.");
+}
+
+export async function getAppVersion(): Promise<string> {
+  const res: { version: string } = await get("/api/version");
+  return res.version;
+}
+
+export async function getAppSupportInfo(): Promise<AppSupportInfo> {
+  const appVersion = await getAppVersion();
+  return {
+    appVersion,
+    runtime: "web",
+    osName: navigator.platform || "web",
+    osVersion: null,
+    arch: "",
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Layout
+// ---------------------------------------------------------------------------
+
+export async function saveSidebarLayout(layout: SidebarLayout): Promise<void> {
+  return post("/api/layout/sidebar", { layout });
+}
+
+export async function loadSidebarLayout(): Promise<SidebarLayout | null> {
+  return get("/api/layout/sidebar");
+}
+
+export async function refreshConnections(): Promise<void> {
+  // Web mode doesn't maintain persistent connection pools - no-op
+}
+
+export * from "@/lib/backend/mq-http";
diff --git a/apps/desktop/src/lib/backend/mq-http.ts b/apps/desktop/src/lib/backend/mq-http.ts
new file mode 100644
index 0000000..e09c5f3
--- /dev/null
+++ b/apps/desktop/src/lib/backend/mq-http.ts
@@ -0,0 +1,219 @@
+// HTTP fetch API for message queue admin (web mode)
+import { apiUrl } from "@/lib/common/webPath";
+import type {
+  MqClusterInfo,
+  ClusterInfo,
+  TenantInfo,
+  TenantConfig,
+  NamespaceRef,
+  NamespaceInfo,
+  NamespaceConfig,
+  TopicRef,
+  TopicInfo,
+  ListTopicsOpts,
+  TopicStats,
+  SubscriptionInfo,
+  ResetPosition,
+  SkipCount,
+  ConsumerInfo,
+  ProducerInfo,
+  PolicyScope,
+  PublishRate,
+  DispatchRate,
+  SubscribeRate,
+  BacklogQuota,
+  RetentionPolicy,
+  AuthAction,
+  PermissionMap,
+  MqTokenIssueRequest,
+  MqTokenRecord,
+  MqIssuedToken,
+  BacklogStats,
+  PeekedMessage,
+  PeekMessagesOptions,
+  MqRawRequest,
+  MqRawResponse,
+  SendMessageRequest,
+  SendMessageResponse,
+} from "@/types/mq";
+
+async function post<T>(path: string, body: unknown): Promise<T> {
+  const resp = await fetch(apiUrl(path), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!resp.ok) {
+    const detail = (await resp.text().catch(() => "")).trim();
+    throw new Error(detail ? `${path} returned ${resp.status}: ${detail}` : `${path} returned ${resp.status}`);
+  }
+  return resp.json();
+}
+
+export async function mqTestConnection(connectionId: string): Promise<MqClusterInfo> {
+  return post("/api/mq/test-connection", { connectionId });
+}
+
+export async function mqListTenants(connectionId: string): Promise<TenantInfo[]> {
+  return post("/api/mq/tenants/list", { connectionId });
+}
+
+export async function mqGetTenant(connectionId: string, name: string): Promise<TenantInfo> {
+  return post("/api/mq/tenants/get", { connectionId, name });
+}
+
+export async function mqCreateTenant(connectionId: string, name: string, config: TenantConfig): Promise<void> {
+  return post("/api/mq/tenants/create", { connectionId, name, config });
+}
+
+export async function mqUpdateTenant(connectionId: string, name: string, config: TenantConfig): Promise<void> {
+  return post("/api/mq/tenants/update", { connectionId, name, config });
+}
+
+export async function mqDeleteTenant(connectionId: string, name: string, force: boolean): Promise<void> {
+  return post("/api/mq/tenants/delete", { connectionId, name, force });
+}
+
+export async function mqListNamespaces(connectionId: string, tenant: string): Promise<NamespaceInfo[]> {
+  return post("/api/mq/namespaces/list", { connectionId, tenant });
+}
+
+export async function mqCreateNamespace(connectionId: string, ns: NamespaceRef, config: NamespaceConfig): Promise<void> {
+  return post("/api/mq/namespaces/create", { connectionId, ns, config });
+}
+
+export async function mqDeleteNamespace(connectionId: string, ns: NamespaceRef, force: boolean): Promise<void> {
+  return post("/api/mq/namespaces/delete", { connectionId, ns, force });
+}
+
+export async function mqGetNamespacePolicies(connectionId: string, ns: NamespaceRef): Promise<unknown> {
+  return post("/api/mq/namespaces/policies", { connectionId, ns });
+}
+
+export async function mqListTopics(connectionId: string, ns: NamespaceRef, opts: ListTopicsOpts): Promise<TopicInfo[]> {
+  return post("/api/mq/topics/list", { connectionId, ns, opts });
+}
+
+export async function mqCreateTopic(connectionId: string, topic: TopicRef, partitions?: number): Promise<void> {
+  return post("/api/mq/topics/create", { connectionId, topic, partitions });
+}
+
+export async function mqDeleteTopic(connectionId: string, topic: TopicRef, force: boolean): Promise<void> {
+  return post("/api/mq/topics/delete", { connectionId, topic, force });
+}
+
+export async function mqUpdatePartitions(connectionId: string, topic: TopicRef, partitions: number): Promise<void> {
+  return post("/api/mq/topics/update-partitions", { connectionId, topic, partitions });
+}
+
+export async function mqGetTopicStats(connectionId: string, topic: TopicRef): Promise<TopicStats> {
+  return post("/api/mq/topics/stats", { connectionId, topic });
+}
+
+export async function mqGetTopicInternalStats(connectionId: string, topic: TopicRef): Promise<unknown> {
+  return post("/api/mq/topics/internal-stats", { connectionId, topic });
+}
+
+export async function mqListSubscriptions(connectionId: string, topic: TopicRef): Promise<SubscriptionInfo[]> {
+  return post("/api/mq/subscriptions/list", { connectionId, topic });
+}
+
+export async function mqCreateSubscription(connectionId: string, topic: TopicRef, sub: string, pos: ResetPosition): Promise<void> {
+  return post("/api/mq/subscriptions/create", { connectionId, topic, sub, pos });
+}
+
+export async function mqDeleteSubscription(connectionId: string, topic: TopicRef, sub: string, force: boolean): Promise<void> {
+  return post("/api/mq/subscriptions/delete", { connectionId, topic, sub, force });
+}
+
+export async function mqSkipMessages(connectionId: string, topic: TopicRef, sub: string, count: SkipCount): Promise<void> {
+  return post("/api/mq/subscriptions/skip-messages", { connectionId, topic, sub, count });
+}
+
+export async function mqResetCursor(connectionId: string, topic: TopicRef, sub: string, pos: ResetPosition): Promise<void> {
+  return post("/api/mq/subscriptions/reset-cursor", { connectionId, topic, sub, pos });
+}
+
+export async function mqClearBacklog(connectionId: string, topic: TopicRef, sub: string): Promise<void> {
+  return post("/api/mq/subscriptions/clear-backlog", { connectionId, topic, sub });
+}
+
+export async function mqPeekMessages(connectionId: string, topic: TopicRef, sub: string, count: number, options?: PeekMessagesOptions): Promise<PeekedMessage[]> {
+  return post("/api/mq/subscriptions/peek-messages", { connectionId, topic, sub, count, options });
+}
+
+export async function mqExpireMessages(connectionId: string, topic: TopicRef, sub: string, expireSeconds: number): Promise<void> {
+  return post("/api/mq/subscriptions/expire-messages", { connectionId, topic, sub, expireSeconds });
+}
+
+export async function mqListProducers(connectionId: string, topic: TopicRef): Promise<ProducerInfo[]> {
+  return post("/api/mq/producers/list", { connectionId, topic });
+}
+
+export async function mqListConsumers(connectionId: string, topic: TopicRef, sub: string): Promise<ConsumerInfo[]> {
+  return post("/api/mq/consumers/list", { connectionId, topic, sub });
+}
+
+export async function mqUnloadTopic(connectionId: string, topic: TopicRef): Promise<void> {
+  return post("/api/mq/topics/unload", { connectionId, topic });
+}
+
+export async function mqSetPublishRate(connectionId: string, scope: PolicyScope, rate: PublishRate): Promise<void> {
+  return post("/api/mq/policies/publish-rate", { connectionId, scope, rate });
+}
+
+export async function mqSetDispatchRate(connectionId: string, scope: PolicyScope, rate: DispatchRate): Promise<void> {
+  return post("/api/mq/policies/dispatch-rate", { connectionId, scope, rate });
+}
+
+export async function mqSetSubscribeRate(connectionId: string, scope: PolicyScope, rate: SubscribeRate): Promise<void> {
+  return post("/api/mq/policies/subscribe-rate", { connectionId, scope, rate });
+}
+
+export async function mqSetBacklogQuota(connectionId: string, scope: PolicyScope, quota: BacklogQuota): Promise<void> {
+  return post("/api/mq/policies/backlog-quota", { connectionId, scope, quota });
+}
+
+export async function mqSetRetention(connectionId: string, scope: PolicyScope, retention: RetentionPolicy): Promise<void> {
+  return post("/api/mq/policies/retention", { connectionId, scope, retention });
+}
+
+export async function mqGetEffectivePolicies(connectionId: string, scope: PolicyScope): Promise<unknown> {
+  return post("/api/mq/policies/effective", { connectionId, scope });
+}
+
+export async function mqGrantPermission(connectionId: string, scope: PolicyScope, role: string, actions: AuthAction[]): Promise<void> {
+  return post("/api/mq/permissions/grant", { connectionId, scope, role, actions });
+}
+
+export async function mqRevokePermission(connectionId: string, scope: PolicyScope, role: string): Promise<void> {
+  return post("/api/mq/permissions/revoke", { connectionId, scope, role });
+}
+
+export async function mqListPermissions(connectionId: string, scope: PolicyScope): Promise<PermissionMap> {
+  return post("/api/mq/permissions/list", { connectionId, scope });
+}
+
+export async function mqIssueToken(connectionId: string, req: MqTokenIssueRequest): Promise<MqIssuedToken> {
+  return post("/api/mq/tokens/issue", { connectionId, req });
+}
+
+export async function mqListTokenRecords(connectionId: string, subject?: string): Promise<MqTokenRecord[]> {
+  return post("/api/mq/tokens/list", { connectionId, subject });
+}
+
+export async function mqGetBacklog(connectionId: string, topic: TopicRef, sub?: string): Promise<BacklogStats> {
+  return post("/api/mq/monitoring/backlog", { connectionId, topic, sub });
+}
+
+export async function mqGetClusterInfo(connectionId: string): Promise<ClusterInfo> {
+  return post("/api/mq/monitoring/cluster-info", { connectionId });
+}
+
+export async function mqRawRequest(connectionId: string, req: MqRawRequest): Promise<MqRawResponse> {
+  return post("/api/mq/raw", { connectionId, req });
+}
+
+export async function mqSendMessage(connectionId: string, req: SendMessageRequest): Promise<SendMessageResponse> {
+  return post("/api/mq/send-message", { connectionId, req });
+}
diff --git a/apps/desktop/src/lib/backend/mq-tauri.ts b/apps/desktop/src/lib/backend/mq-tauri.ts
new file mode 100644
index 0000000..2472810
--- /dev/null
+++ b/apps/desktop/src/lib/backend/mq-tauri.ts
@@ -0,0 +1,216 @@
+// Message queue admin API functions - Tauri invoke layer
+import { invoke } from "@tauri-apps/api/core";
+import type {
+  MqClusterInfo,
+  ClusterInfo,
+  TenantInfo,
+  TenantConfig,
+  NamespaceRef,
+  NamespaceInfo,
+  NamespaceConfig,
+  TopicRef,
+  TopicInfo,
+  ListTopicsOpts,
+  TopicStats,
+  SubscriptionInfo,
+  ResetPosition,
+  SkipCount,
+  ConsumerInfo,
+  ProducerInfo,
+  PolicyScope,
+  PublishRate,
+  DispatchRate,
+  SubscribeRate,
+  BacklogQuota,
+  RetentionPolicy,
+  AuthAction,
+  PermissionMap,
+  MqTokenIssueRequest,
+  MqTokenRecord,
+  MqIssuedToken,
+  BacklogStats,
+  PeekedMessage,
+  PeekMessagesOptions,
+  MqRawRequest,
+  MqRawResponse,
+  SendMessageRequest,
+  SendMessageResponse,
+} from "@/types/mq";
+
+// Connectivity
+export async function mqTestConnection(connectionId: string): Promise<MqClusterInfo> {
+  return invoke("mq_test_connection", { connectionId });
+}
+
+// Tenants
+export async function mqListTenants(connectionId: string): Promise<TenantInfo[]> {
+  return invoke("mq_list_tenants", { connectionId });
+}
+
+export async function mqGetTenant(connectionId: string, name: string): Promise<TenantInfo> {
+  return invoke("mq_get_tenant", { connectionId, name });
+}
+
+export async function mqCreateTenant(connectionId: string, name: string, config: TenantConfig): Promise<void> {
+  return invoke("mq_create_tenant", { connectionId, name, config });
+}
+
+export async function mqUpdateTenant(connectionId: string, name: string, config: TenantConfig): Promise<void> {
+  return invoke("mq_update_tenant", { connectionId, name, config });
+}
+
+export async function mqDeleteTenant(connectionId: string, name: string, force: boolean): Promise<void> {
+  return invoke("mq_delete_tenant", { connectionId, name, force });
+}
+
+// Namespaces
+export async function mqListNamespaces(connectionId: string, tenant: string): Promise<NamespaceInfo[]> {
+  return invoke("mq_list_namespaces", { connectionId, tenant });
+}
+
+export async function mqCreateNamespace(connectionId: string, ns: NamespaceRef, config: NamespaceConfig): Promise<void> {
+  return invoke("mq_create_namespace", { connectionId, ns, config });
+}
+
+export async function mqDeleteNamespace(connectionId: string, ns: NamespaceRef, force: boolean): Promise<void> {
+  return invoke("mq_delete_namespace", { connectionId, ns, force });
+}
+
+export async function mqGetNamespacePolicies(connectionId: string, ns: NamespaceRef): Promise<unknown> {
+  return invoke("mq_get_namespace_policies", { connectionId, ns });
+}
+
+// Topics
+export async function mqListTopics(connectionId: string, ns: NamespaceRef, opts: ListTopicsOpts): Promise<TopicInfo[]> {
+  return invoke("mq_list_topics", { connectionId, ns, opts });
+}
+
+export async function mqCreateTopic(connectionId: string, topic: TopicRef, partitions?: number): Promise<void> {
+  return invoke("mq_create_topic", { connectionId, topic, partitions });
+}
+
+export async function mqDeleteTopic(connectionId: string, topic: TopicRef, force: boolean): Promise<void> {
+  return invoke("mq_delete_topic", { connectionId, topic, force });
+}
+
+export async function mqUpdatePartitions(connectionId: string, topic: TopicRef, partitions: number): Promise<void> {
+  return invoke("mq_update_partitions", { connectionId, topic, partitions });
+}
+
+export async function mqGetTopicStats(connectionId: string, topic: TopicRef): Promise<TopicStats> {
+  return invoke("mq_get_topic_stats", { connectionId, topic });
+}
+
+export async function mqGetTopicInternalStats(connectionId: string, topic: TopicRef): Promise<unknown> {
+  return invoke("mq_get_topic_internal_stats", { connectionId, topic });
+}
+
+// Subscriptions
+export async function mqListSubscriptions(connectionId: string, topic: TopicRef): Promise<SubscriptionInfo[]> {
+  return invoke("mq_list_subscriptions", { connectionId, topic });
+}
+
+export async function mqCreateSubscription(connectionId: string, topic: TopicRef, sub: string, pos: ResetPosition): Promise<void> {
+  return invoke("mq_create_subscription", { connectionId, topic, sub, pos });
+}
+
+export async function mqDeleteSubscription(connectionId: string, topic: TopicRef, sub: string, force: boolean): Promise<void> {
+  return invoke("mq_delete_subscription", { connectionId, topic, sub, force });
+}
+
+export async function mqSkipMessages(connectionId: string, topic: TopicRef, sub: string, count: SkipCount): Promise<void> {
+  return invoke("mq_skip_messages", { connectionId, topic, sub, count });
+}
+
+export async function mqResetCursor(connectionId: string, topic: TopicRef, sub: string, pos: ResetPosition): Promise<void> {
+  return invoke("mq_reset_cursor", { connectionId, topic, sub, pos });
+}
+
+export async function mqClearBacklog(connectionId: string, topic: TopicRef, sub: string): Promise<void> {
+  return invoke("mq_clear_backlog", { connectionId, topic, sub });
+}
+
+export async function mqPeekMessages(connectionId: string, topic: TopicRef, sub: string, count: number, options?: PeekMessagesOptions): Promise<PeekedMessage[]> {
+  return invoke("mq_peek_messages", { connectionId, topic, sub, count, options });
+}
+
+export async function mqExpireMessages(connectionId: string, topic: TopicRef, sub: string, expireSeconds: number): Promise<void> {
+  return invoke("mq_expire_messages", { connectionId, topic, sub, expireSeconds });
+}
+
+// Producers / Consumers
+export async function mqListProducers(connectionId: string, topic: TopicRef): Promise<ProducerInfo[]> {
+  return invoke("mq_list_producers", { connectionId, topic });
+}
+
+export async function mqListConsumers(connectionId: string, topic: TopicRef, sub: string): Promise<ConsumerInfo[]> {
+  return invoke("mq_list_consumers", { connectionId, topic, sub });
+}
+
+export async function mqUnloadTopic(connectionId: string, topic: TopicRef): Promise<void> {
+  return invoke("mq_unload_topic", { connectionId, topic });
+}
+
+// Policies
+export async function mqSetPublishRate(connectionId: string, scope: PolicyScope, rate: PublishRate): Promise<void> {
+  return invoke("mq_set_publish_rate", { connectionId, scope, rate });
+}
+
+export async function mqSetDispatchRate(connectionId: string, scope: PolicyScope, rate: DispatchRate): Promise<void> {
+  return invoke("mq_set_dispatch_rate", { connectionId, scope, rate });
+}
+
+export async function mqSetSubscribeRate(connectionId: string, scope: PolicyScope, rate: SubscribeRate): Promise<void> {
+  return invoke("mq_set_subscribe_rate", { connectionId, scope, rate });
+}
+
+export async function mqSetBacklogQuota(connectionId: string, scope: PolicyScope, quota: BacklogQuota): Promise<void> {
+  return invoke("mq_set_backlog_quota", { connectionId, scope, quota });
+}
+
+export async function mqSetRetention(connectionId: string, scope: PolicyScope, retention: RetentionPolicy): Promise<void> {
+  return invoke("mq_set_retention", { connectionId, scope, retention });
+}
+
+export async function mqGetEffectivePolicies(connectionId: string, scope: PolicyScope): Promise<unknown> {
+  return invoke("mq_get_effective_policies", { connectionId, scope });
+}
+
+// Permissions
+export async function mqGrantPermission(connectionId: string, scope: PolicyScope, role: string, actions: AuthAction[]): Promise<void> {
+  return invoke("mq_grant_permission", { connectionId, scope, role, actions });
+}
+
+export async function mqRevokePermission(connectionId: string, scope: PolicyScope, role: string): Promise<void> {
+  return invoke("mq_revoke_permission", { connectionId, scope, role });
+}
+
+export async function mqListPermissions(connectionId: string, scope: PolicyScope): Promise<PermissionMap> {
+  return invoke("mq_list_permissions", { connectionId, scope });
+}
+
+export async function mqIssueToken(connectionId: string, req: MqTokenIssueRequest): Promise<MqIssuedToken> {
+  return invoke("mq_issue_token", { connectionId, req });
+}
+
+export async function mqListTokenRecords(connectionId: string, subject?: string): Promise<MqTokenRecord[]> {
+  return invoke("mq_list_token_records", { connectionId, subject });
+}
+
+// Monitoring
+export async function mqGetBacklog(connectionId: string, topic: TopicRef, sub?: string): Promise<BacklogStats> {
+  return invoke("mq_get_backlog", { connectionId, topic, sub });
+}
+
+export async function mqGetClusterInfo(connectionId: string): Promise<ClusterInfo> {
+  return invoke("mq_get_cluster_info", { connectionId });
+}
+
+// Raw request
+export async function mqRawRequest(connectionId: string, req: MqRawRequest): Promise<MqRawResponse> {
+  return invoke("mq_raw_request", { connectionId, req });
+}
+
+export async function mqSendMessage(connectionId: string, req: SendMessageRequest): Promise<SendMessageResponse> {
+  return invoke("mq_send_message", { connectionId, req });
+}
diff --git a/apps/desktop/src/lib/backend/nacos-tauri.ts b/apps/desktop/src/lib/backend/nacos-tauri.ts
new file mode 100644
index 0000000..6b390b3
--- /dev/null
+++ b/apps/desktop/src/lib/backend/nacos-tauri.ts
@@ -0,0 +1,83 @@
+import { invoke } from "@tauri-apps/api/core";
+import type {
+  NacosConfigHistoryKey,
+  NacosConfigHistoryList,
+  NacosConfigHistoryQuery,
+  NacosConfigItem,
+  NacosConfigKey,
+  NacosConfigList,
+  NacosConfigQuery,
+  NacosConfigRollbackRequest,
+  NacosConfigUpsert,
+  NacosConnectionInfo,
+  NacosInstanceInfo,
+  NacosInstanceQuery,
+  NacosInstanceUpdate,
+  NacosNamespaceCreate,
+  NacosNamespaceInfo,
+  NacosNamespaceUpdate,
+  NacosRawRequest,
+  NacosRawResponse,
+  NacosServiceList,
+  NacosServiceQuery,
+} from "@/types/nacos";
+
+export async function nacosTestConnection(connectionId: string): Promise<NacosConnectionInfo> {
+  return invoke("nacos_test_connection", { connectionId });
+}
+
+export async function nacosListNamespaces(connectionId: string): Promise<NacosNamespaceInfo[]> {
+  return invoke("nacos_list_namespaces", { connectionId });
+}
+
+export async function nacosCreateNamespace(connectionId: string, req: NacosNamespaceCreate): Promise<void> {
+  return invoke("nacos_create_namespace", { connectionId, req });
+}
+
+export async function nacosUpdateNamespace(connectionId: string, req: NacosNamespaceUpdate): Promise<void> {
+  return invoke("nacos_update_namespace", { connectionId, req });
+}
+
+export async function nacosListConfigs(connectionId: string, query: NacosConfigQuery): Promise<NacosConfigList> {
+  return invoke("nacos_list_configs", { connectionId, query });
+}
+
+export async function nacosGetConfig(connectionId: string, key: NacosConfigKey): Promise<NacosConfigItem> {
+  return invoke("nacos_get_config", { connectionId, key });
+}
+
+export async function nacosPublishConfig(connectionId: string, req: NacosConfigUpsert): Promise<void> {
+  return invoke("nacos_publish_config", { connectionId, req });
+}
+
+export async function nacosDeleteConfig(connectionId: string, key: NacosConfigKey): Promise<void> {
+  return invoke("nacos_delete_config", { connectionId, key });
+}
+
+export async function nacosListConfigHistory(connectionId: string, query: NacosConfigHistoryQuery): Promise<NacosConfigHistoryList> {
+  return invoke("nacos_list_config_history", { connectionId, query });
+}
+
+export async function nacosGetConfigHistory(connectionId: string, key: NacosConfigHistoryKey): Promise<NacosConfigItem> {
+  return invoke("nacos_get_config_history", { connectionId, key });
+}
+
+export async function nacosRollbackConfig(connectionId: string, req: NacosConfigRollbackRequest): Promise<void> {
+  return invoke("nacos_rollback_config", { connectionId, req });
+}
+
+export async function nacosListServices(connectionId: string, query: NacosServiceQuery): Promise<NacosServiceList> {
+  return invoke("nacos_list_services", { connectionId, query });
+}
+
+export async function nacosListInstances(connectionId: string, query: NacosInstanceQuery): Promise<NacosInstanceInfo[]> {
+  return invoke("nacos_list_instances", { connectionId, query });
+}
+
+export async function nacosUpdateInstance(connectionId: string, req: NacosInstanceUpdate): Promise<void> {
+  return invoke("nacos_update_instance", { connectionId, req });
+}
+
+export async function nacosRawRequest(connectionId: string, req: NacosRawRequest): Promise<NacosRawResponse> {
+  return invoke("nacos_raw_request", { connectionId, req });
+}
diff --git a/apps/desktop/src/lib/backend/platform.ts b/apps/desktop/src/lib/backend/platform.ts
new file mode 100644
index 0000000..4a50009
--- /dev/null
+++ b/apps/desktop/src/lib/backend/platform.ts
@@ -0,0 +1,17 @@
+export type Platform = "macos" | "windows" | "linux" | "unknown";
+
+export function getPlatform(): Platform {
+  const ua = navigator.userAgent.toLowerCase();
+  if (ua.includes("mac")) return "macos";
+  if (ua.includes("win")) return "windows";
+  if (ua.includes("linux")) return "linux";
+  return "unknown";
+}
+
+export function isMacOS(): boolean {
+  return getPlatform() === "macos";
+}
+
+export function isWindows(): boolean {
+  return getPlatform() === "windows";
+}
diff --git a/apps/desktop/src/lib/backend/safeStorage.ts b/apps/desktop/src/lib/backend/safeStorage.ts
new file mode 100644
index 0000000..3596b5a
--- /dev/null
+++ b/apps/desktop/src/lib/backend/safeStorage.ts
@@ -0,0 +1,28 @@
+function storageWarn(action: string, key: string, error: unknown) {
+  console.warn(`[DBX][storage:${action}] ${key}`, error);
+}
+
+export function safeLocalStorageGet(key: string): string | null {
+  try {
+    return globalThis.localStorage?.getItem(key) ?? null;
+  } catch (error) {
+    storageWarn("get", key, error);
+    return null;
+  }
+}
+
+export function safeLocalStorageSet(key: string, value: string) {
+  try {
+    globalThis.localStorage?.setItem(key, value);
+  } catch (error) {
+    storageWarn("set", key, error);
+  }
+}
+
+export function safeLocalStorageRemove(key: string) {
+  try {
+    globalThis.localStorage?.removeItem(key);
+  } catch (error) {
+    storageWarn("remove", key, error);
+  }
+}
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
new file mode 100644
index 0000000..f8356cf
--- /dev/null
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -0,0 +1,2440 @@
+import { invoke } from "@tauri-apps/api/core";
+import { listen, type UnlistenFn } from "@tauri-apps/api/event";
+import type {
+  ConnectionConfig,
+  DatabaseInfo,
+  SchemaInfo,
+  LinkedServerInfo,
+  CatalogInfo,
+  TableInfo,
+  ObjectInfo,
+  CompletionAssistantRequest,
+  CompletionAssistantResponse,
+  ObjectStatistics,
+  ObjectSource,
+  ObjectSourceKind,
+  ColumnInfo,
+  IndexInfo,
+  ForeignKeyInfo,
+  TriggerInfo,
+  FunctionInfo,
+  SequenceInfo,
+  RuleInfo,
+  OwnerInfo,
+  ExtensionInfo,
+  QueryResult,
+  SqlReferenceAnalysis,
+  DatabaseType,
+  InstalledPlugin,
+  JdbcDriverInfo,
+  JdbcLocalBundleInfo,
+  JdbcMavenBundleInfo,
+  JdbcPluginStatus,
+  SavedSqlFile,
+  SavedSqlFolder,
+  SavedSqlLibrary,
+  SshConfigHostEntry,
+  TunnelProfile,
+} from "@/types/database";
+import type { CollectionInfo } from "@/types/database";
+import type { SidebarObjectKind } from "@/lib/database/databaseObjectCapabilities";
+import type { AiConfig, AiTestConnectionResult } from "@/stores/settingsStore";
+import type { QueryEditability } from "@/lib/sql/sqlAnalysis";
+import { isTerminalTransferProgress } from "@/lib/backend/transferProgress";
+import type {
+  DataGridColumnDistinctValuesSqlOptions,
+  DataGridColumnValueFilterConditionOptions,
+  DataGridColumnValuesFilterConditionOptions,
+  DataGridContextFilterConditionOptions,
+  DataGridCountSqlOptions,
+  DataGridCopyInsertStatementOptions,
+  DataGridCopyUpdateStatementOptions,
+  DataGridSaveStatementOptions,
+  HiveTablePropertiesSqlOptions,
+} from "@/lib/dataGrid/dataGridSql";
+import type { DataCompareFromTablesOptions, DataCompareFromTablesPreparation, DataCompareSyncPlan, DataCompareSyncPlanOptions, DataComparePreparation, DataComparePreparationOptions } from "@/lib/dataGrid/dataCompare";
+import type { SchemaDiffPreparation, SchemaDiffPreparationOptions, TableDiff, FunctionDiff, SequenceDiff, RuleDiff, OwnerDiff } from "@/lib/schema/schemaDiff";
+import type { BuildTableStructureChangeSqlOptions, BuildSingleColumnAlterSqlOptions, SqliteTableStructureChangePreview, TableStructureChangeSql } from "@/lib/table/tableStructureEditorSql";
+import type { BuildTableSelectSqlOptions } from "@/lib/table/tableSelectSql";
+import type { DatabaseSearchSql, DatabaseSearchSqlOptions, SearchResultWhereOptions } from "@/lib/database/databaseSearch";
+import type { BuildEditableObjectSourceSqlInput, BuildRoutineRenameObjectSourceInput } from "@/lib/table/objectSourceEditor";
+import type { BuildViewDdlInput } from "@/lib/table/viewDdl";
+import type { BuildRenameObjectSqlOptions } from "@/lib/table/objectRenameSql";
+import type { CreateDatabaseSqlOptions } from "@/lib/database/createDatabaseSql";
+import type { DatabaseNameSqlOptions, DatabasePropertyEditSqlOptions, DropTableChildObjectSqlOptions, DropObjectSqlOptions, DuplicateTableStructureSqlOptions, CopyTableDataSqlOptions, SchemaNameSqlOptions, TableAdminSqlOptions } from "@/lib/database/dbAdminSql";
+import type { BuildDatabaseSqlExportOptions, BuildExportInsertStatementsOptions } from "@/lib/export/databaseExport";
+
+export interface AgentDriverInfo {
+  db_type: string;
+  label: string;
+  version: string;
+  size: number;
+  installed: boolean;
+  installed_version: string | null;
+  update_available: boolean;
+  requires_java_runtime?: boolean;
+  jre: string;
+  jre_installed: boolean;
+}
+
+export interface AgentDriverUpdateIssue {
+  db_type: string;
+  error: string;
+}
+
+export interface UpgradeAllAgentDriversResult {
+  upgraded: number;
+  failed: AgentDriverUpdateIssue[];
+}
+
+export interface AgentUpdateBlocker {
+  db_type: string;
+  label: string;
+}
+
+export type JavaRuntimeMode = "managed" | "system" | "custom";
+
+export interface JavaRuntimeConfig {
+  mode: JavaRuntimeMode;
+  custom_java_path: string | null;
+}
+
+export interface DriverStoreUsageItem {
+  id: string;
+  bytes: number;
+}
+
+export interface DriverStoreUsage {
+  total_bytes: number;
+  jre_bytes: number;
+  agent_driver_bytes: number;
+  download_cache_bytes?: number;
+  jdbc_plugin_bytes: number;
+  jdbc_driver_bytes: number;
+  jres: DriverStoreUsageItem[];
+  agent_drivers: DriverStoreUsageItem[];
+}
+
+export type DriverRuntimeHealth = "healthy" | "warning" | "error";
+export type DriverRuntimeStatus = "running" | "stopped" | "error" | "unknown";
+
+export interface DriverRuntimeInfo {
+  id: string;
+  driver_key: string;
+  label: string;
+  kind: string;
+  source: string;
+  status: DriverRuntimeStatus;
+  pid: number | null;
+  memory_bytes: number | null;
+  cpu_percent: number | null;
+  uptime_seconds: number | null;
+  version: string | null;
+  last_error: string | null;
+  can_stop: boolean;
+  can_restart: boolean;
+  control_unavailable_reason: string | null;
+}
+
+export interface DriverRuntimeSummary {
+  running_count: number;
+  total_memory_bytes: number;
+  last_error: string | null;
+  health: DriverRuntimeHealth;
+  runtimes: DriverRuntimeInfo[];
+}
+
+export interface DesktopSettings {
+  show_tray_icon: boolean;
+  icon_theme: "default" | "black";
+  quit_on_close: boolean;
+  close_action_prompted: boolean;
+  debug_logging_enabled: boolean;
+  duckdb_worker_process_isolation: boolean;
+  duckdb_worker_max_processes: number;
+  saved_sql_sync_dir?: string | null;
+  driver_store_dir?: string | null;
+  plugin_store_dir?: string | null;
+  agent_store_dir?: string | null;
+  sidebar_table_page_size?: number | null;
+}
+
+export interface SavedSqlSyncEntry {
+  folderName?: string;
+  fileName: string;
+  sql: string;
+}
+
+export interface SavedSqlSyncRequest {
+  targetDir: string;
+  entries: SavedSqlSyncEntry[];
+}
+
+export interface WebDavConfig {
+  endpoint: string;
+  username?: string;
+  password?: string;
+  remotePath?: string;
+}
+
+export interface WebDavSyncSummary {
+  remotePath: string;
+  bytes: number;
+  exportedAt?: string;
+  appVersion?: string;
+}
+
+export interface WebDavDownloadResult {
+  summary: WebDavSyncSummary;
+  editorSettings?: unknown;
+  desktopSettings: DesktopSettings;
+  applySummary: {
+    encryptedSecretsPresent: boolean;
+    secretsApplied: boolean;
+  };
+}
+
+export interface WebDavPasswordStatus {
+  hasSavedPassword: boolean;
+}
+
+export interface WebDavSyncSecretsStatus {
+  enabled: boolean;
+  hasSavedPassphrase: boolean;
+}
+
+export type SnippetProvider = "github" | "gitee";
+
+export interface SnippetSyncConfig {
+  provider: SnippetProvider;
+  token?: string;
+  snippetId?: string;
+}
+
+export interface SnippetSyncSummary {
+  provider: SnippetProvider;
+  snippetId: string;
+  bytes: number;
+  exportedAt?: string;
+  appVersion?: string;
+}
+
+export interface SnippetDownloadResult {
+  summary: SnippetSyncSummary;
+  editorSettings?: unknown;
+  desktopSettings: DesktopSettings;
+  applySummary: WebDavDownloadResult["applySummary"];
+}
+
+export interface SnippetTokenStatus {
+  hasSavedToken: boolean;
+}
+
+export interface AppSupportInfo {
+  appVersion: string;
+  runtime: "desktop" | "web";
+  osName: string;
+  osVersion?: string | null;
+  arch: string;
+}
+
+export interface QueryPagination {
+  limit: number;
+  offset: number;
+  sessionId?: string;
+}
+
+export interface QueryPaginationExecutionPlanOptions {
+  sql: string;
+  queryBaseSql: string;
+  databaseType?: DatabaseType;
+  pagination: QueryPagination;
+  useAgentCursor: boolean;
+  firstPageUsesActualSql?: boolean;
+}
+
+export interface QueryPaginationExecutionPlan {
+  sqlToExecute: string;
+  pageSql?: string;
+  pageLimit?: number;
+  pageOffset?: number;
+  countSql?: string;
+  useAgentResultSession: boolean;
+}
+
+export type QuerySortDirection = "asc" | "desc";
+
+export interface SortedQuerySqlOptions {
+  originalSql: string;
+  databaseType?: DatabaseType;
+  resultColumns: string[];
+  columnIndex: number;
+  column: string;
+  direction: QuerySortDirection;
+}
+
+export interface QuerySqlBuildResult {
+  ok: boolean;
+  sql?: string;
+  reason?: "empty" | "multi" | "not_select" | "unsupported" | "with";
+}
+
+export interface BuildExplainSqlOptions {
+  databaseType?: DatabaseType;
+  sql: string;
+  /** MySQL can return either the existing JSON plan or its native tabular plan. */
+  format?: "json" | "standard";
+}
+
+export interface ExplainSqlBuildResult {
+  ok: boolean;
+  sql?: string;
+  reason?: "unsupported" | "empty" | "unsafe";
+}
+
+export interface DroppedFilePreviewSqlOptions {
+  path: string;
+  limit?: number;
+}
+
+export type XlsxCellValue = string | number | boolean | null;
+
+export interface DriverInstallProgress {
+  step: string;
+  downloaded?: number;
+  total?: number;
+  db_type?: string;
+  current?: number;
+  total_drivers?: number;
+}
+
+export interface AiMessage {
+  role: "user" | "assistant" | "system";
+  content: string;
+}
+
+export interface AiTaskContract {
+  action?: string;
+  mode?: string;
+  userRequest?: string;
+}
+
+export interface AiCompletionRequest {
+  config: AiConfig;
+  systemPrompt: string;
+  messages: AiMessage[];
+  taskContract?: AiTaskContract;
+  maxTokens?: number;
+}
+
+export interface AiModelInfo {
+  id: string;
+  displayName?: string;
+}
+
+export async function aiComplete(request: AiCompletionRequest): Promise<string> {
+  return invoke("ai_complete", { request });
+}
+
+export interface AiStreamChunk {
+  session_id: string;
+  delta: string;
+  reasoning_delta?: string;
+  done: boolean;
+}
+
+export async function aiStream(sessionId: string, request: AiCompletionRequest, onChunk: (chunk: AiStreamChunk) => void): Promise<void> {
+  const unlisten: UnlistenFn = await listen<AiStreamChunk>("ai-stream-chunk", (event) => {
+    if (event.payload.session_id === sessionId) {
+      onChunk(event.payload);
+      if (event.payload.done) unlisten();
+    }
+  });
+  try {
+    await invoke("ai_stream", { sessionId, request });
+  } catch (e) {
+    unlisten();
+    throw e;
+  }
+}
+
+export type AgentEvent =
+  | { type: "turn_start"; turn: number }
+  | { type: "text_delta"; delta: string }
+  | { type: "reasoning_delta"; delta: string }
+  | { type: "tool_call_start"; tool_call_id: string; tool_name: string; args: Record<string, unknown> }
+  | { type: "tool_call_end"; tool_call_id: string; tool_name: string; result: unknown; is_error: boolean }
+  | { type: "turn_end"; turn: number }
+  | { type: "agent_end"; input_tokens?: number; output_tokens?: number }
+  | { type: "context_compacted"; summary: string; summary_tokens: number; compacted_messages: number; estimated_before: number; estimated_after: number }
+  | { type: "error"; message: string };
+
+export async function aiAgentStream(sessionId: string, request: AiCompletionRequest, connectionId: string, database: string, dbType: string, onEvent: (event: AgentEvent) => void, mode?: string, allowWriteSql = false, _signal?: AbortSignal): Promise<string> {
+  const unlisten: UnlistenFn = await listen<AgentEvent>("ai-agent-event", (event) => {
+    onEvent(event.payload);
+    if (event.payload.type === "agent_end" || event.payload.type === "error") {
+      unlisten();
+    }
+  });
+  try {
+    return await invoke("ai_agent_stream", { sessionId, request, connectionId, database, dbType, mode, allowWriteSql });
+  } catch (e) {
+    unlisten();
+    throw e;
+  }
+}
+
+export async function saveAiConfig(config: AiConfig): Promise<void> {
+  return invoke("save_ai_config", { config });
+}
+
+export async function saveAiProviderConfig(provider: string, config: AiConfig): Promise<void> {
+  return invoke("save_ai_provider_config", { provider, config });
+}
+
+export async function loadAiProviderConfigs(): Promise<Record<string, AiConfig>> {
+  return invoke("load_ai_provider_configs");
+}
+
+export async function aiTestConnection(config: AiConfig): Promise<AiTestConnectionResult> {
+  return invoke("ai_test_connection", { config });
+}
+
+export async function aiListModels(config: AiConfig): Promise<AiModelInfo[]> {
+  return invoke("ai_list_models", { config });
+}
+
+export async function aiCancelStream(sessionId: string): Promise<boolean> {
+  return invoke("ai_cancel_stream", { sessionId });
+}
+
+export async function loadAiConfig(): Promise<AiConfig | null> {
+  return invoke("load_ai_config");
+}
+
+export async function loadDesktopSettings(): Promise<DesktopSettings> {
+  return invoke("load_desktop_settings");
+}
+
+export async function saveDesktopSettings(settings: DesktopSettings): Promise<void> {
+  return invoke("save_desktop_settings", { settings });
+}
+
+export interface OpenTabsStatePayload {
+  tabs: unknown[];
+  activeTabId: string | null;
+}
+
+export async function loadEditorSettings(): Promise<unknown | null> {
+  return invoke("load_editor_settings");
+}
+
+export async function saveEditorSettings(settings: unknown): Promise<void> {
+  return invoke("save_editor_settings", { settings });
+}
+
+export async function loadOpenTabsState(): Promise<OpenTabsStatePayload | null> {
+  return invoke("load_open_tabs_state");
+}
+
+export async function saveOpenTabsState(payload: OpenTabsStatePayload): Promise<void> {
+  return invoke("save_open_tabs_state", { payload });
+}
+
+export async function loadSavedSqlEditorPositions(): Promise<unknown[] | null> {
+  return invoke("load_saved_sql_editor_positions");
+}
+
+export async function saveSavedSqlEditorPositions(positions: unknown[]): Promise<void> {
+  return invoke("save_saved_sql_editor_positions", { positions });
+}
+
+export async function completeAppClose(action: "quit" | "hide"): Promise<void> {
+  return invoke("complete_app_close", { action });
+}
+
+export async function requestAppClose(): Promise<void> {
+  return invoke("request_app_close_from_window_controls");
+}
+
+export interface DriverStoreMigrationResult {
+  driver_store_dir: string | null;
+  plugin_store_dir: string | null;
+  agent_store_dir: string | null;
+  plugins_dir: string;
+  agents_dir: string;
+  migrated_plugins: boolean;
+  migrated_agents: boolean;
+}
+
+export async function setDriverStoreDir(newDir: string | null): Promise<DriverStoreMigrationResult> {
+  return invoke("set_driver_store_dir", { newDir });
+}
+
+export async function setPluginStoreDir(newDir: string | null): Promise<DriverStoreMigrationResult> {
+  return invoke("set_plugin_store_dir", { newDir });
+}
+
+export async function setAgentStoreDir(newDir: string | null): Promise<DriverStoreMigrationResult> {
+  return invoke("set_agent_store_dir", { newDir });
+}
+
+export interface DriverStorePathInfo {
+  driver_store_dir: string | null;
+  plugin_store_dir: string | null;
+  agent_store_dir: string | null;
+  plugins_dir: string;
+  agents_dir: string;
+}
+
+export async function getDriverStorePath(): Promise<DriverStorePathInfo> {
+  return invoke("get_driver_store_path");
+}
+
+export async function webdavSyncTest(config: WebDavConfig): Promise<void> {
+  return invoke("webdav_sync_test", { config });
+}
+
+export async function webdavPasswordStatus(config: WebDavConfig): Promise<WebDavPasswordStatus> {
+  return invoke("webdav_password_status", { config });
+}
+
+export async function saveWebdavSavedPassword(config: WebDavConfig, password: string): Promise<void> {
+  return invoke("save_webdav_saved_password", { config, password });
+}
+
+export async function forgetWebdavSavedPassword(config: WebDavConfig): Promise<void> {
+  return invoke("forget_webdav_saved_password", { config });
+}
+
+export async function webdavSyncSecretsStatus(): Promise<WebDavSyncSecretsStatus> {
+  return invoke("webdav_sync_secrets_status");
+}
+
+export async function saveWebdavSyncSecretsPreference(enabled: boolean, passphrase?: string): Promise<void> {
+  return invoke("save_webdav_sync_secrets_preference", { enabled, passphrase });
+}
+
+export async function forgetWebdavSyncSecretsPassphrase(): Promise<void> {
+  return invoke("forget_webdav_sync_secrets_passphrase");
+}
+
+export async function webdavSyncUpload(config: WebDavConfig, editorSettings?: unknown, secretsPassphrase?: string): Promise<WebDavSyncSummary> {
+  return invoke("webdav_sync_upload", { config, editorSettings, secretsPassphrase });
+}
+
+export async function webdavSyncDownload(config: WebDavConfig, secretsPassphrase?: string): Promise<WebDavDownloadResult> {
+  return invoke("webdav_sync_download", { config, secretsPassphrase });
+}
+
+export async function snippetSyncTest(config: SnippetSyncConfig): Promise<void> {
+  return invoke("snippet_sync_test", { config });
+}
+
+export async function snippetTokenStatus(config: SnippetSyncConfig): Promise<SnippetTokenStatus> {
+  return invoke("snippet_token_status", { config });
+}
+
+export async function saveSnippetSavedToken(config: SnippetSyncConfig, token: string): Promise<void> {
+  return invoke("save_snippet_saved_token", { config, token });
+}
+
+export async function forgetSnippetSavedToken(config: SnippetSyncConfig): Promise<void> {
+  return invoke("forget_snippet_saved_token", { config });
+}
+
+export async function snippetSyncUpload(config: SnippetSyncConfig, editorSettings?: unknown, secretsPassphrase?: string): Promise<SnippetSyncSummary> {
+  return invoke("snippet_sync_upload", { config, editorSettings, secretsPassphrase });
+}
+
+export async function snippetSyncDownload(config: SnippetSyncConfig, secretsPassphrase?: string): Promise<SnippetDownloadResult> {
+  return invoke("snippet_sync_download", { config, secretsPassphrase });
+}
+
+export async function loadPinnedTreeNodeIds(): Promise<string[]> {
+  return invoke("load_pinned_tree_node_ids");
+}
+
+export async function savePinnedTreeNodeIds(ids: string[]): Promise<void> {
+  return invoke("save_pinned_tree_node_ids", { ids });
+}
+
+export async function listSystemFonts(): Promise<string[]> {
+  return invoke("list_system_fonts");
+}
+
+export async function listSshConfigHosts(): Promise<SshConfigHostEntry[]> {
+  return invoke("list_ssh_config_hosts");
+}
+
+export async function pendingOpenSqlFiles(): Promise<string[]> {
+  return invoke("pending_open_sql_files");
+}
+
+export async function pendingOpenDbFiles(): Promise<string[]> {
+  return invoke("pending_open_db_files");
+}
+
+export async function pendingOpenConnectionLinks(): Promise<string[]> {
+  return invoke("pending_open_connection_links");
+}
+
+export async function readExternalSqlFile(path: string): Promise<string> {
+  return invoke("read_external_sql_file", { path });
+}
+
+export async function writeExternalSqlFile(path: string, content: string): Promise<void> {
+  return invoke("write_external_sql_file", { path, content });
+}
+
+export interface SqlFileEntry {
+  name: string;
+  path: string;
+  is_dir: boolean;
+  children: SqlFileEntry[];
+}
+
+export async function listSqlFilesInFolder(folderPath: string): Promise<SqlFileEntry[]> {
+  return invoke("list_sql_files_in_folder", { folderPath });
+}
+
+// --- AI Conversations ---
+
+export interface AiChatMessage {
+  role: string;
+  content: string;
+  mentions?: unknown[];
+  reasoning?: string;
+  kind?: "contextSummary";
+}
+
+export interface AiConversation {
+  id: string;
+  title: string;
+  connectionName: string;
+  database: string;
+  messages: AiChatMessage[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export async function saveAiConversation(conversation: AiConversation): Promise<void> {
+  return invoke("save_ai_conversation", { conversation });
+}
+
+export async function loadAiConversations(): Promise<AiConversation[]> {
+  return invoke("load_ai_conversations");
+}
+
+export async function deleteAiConversation(id: string): Promise<void> {
+  return invoke("delete_ai_conversation", { id });
+}
+
+export async function testConnection(config: ConnectionConfig): Promise<string> {
+  return invoke("test_connection", { config });
+}
+
+export async function connectDb(config: ConnectionConfig, clientAttempt?: number): Promise<string> {
+  return invoke("connect_db", { config, clientAttempt });
+}
+
+export async function connectionFinalProxyPort(config: ConnectionConfig): Promise<number> {
+  return invoke("connection_final_proxy_port", { config });
+}
+
+export async function disconnectDb(connectionId: string, clientAttempt?: number): Promise<void> {
+  return invoke("disconnect_db", { connectionId, clientAttempt });
+}
+
+export async function checkConnectionHealth(connectionId: string): Promise<void> {
+  return invoke("check_connection_health", { connectionId });
+}
+
+export async function closeDatabaseConnection(connectionId: string, database: string): Promise<boolean> {
+  return invoke("close_database_connection", { connectionId, database });
+}
+
+export async function listDatabases(connectionId: string): Promise<DatabaseInfo[]> {
+  return invoke("list_databases", { connectionId });
+}
+
+export async function listDorisCatalogs(connectionId: string): Promise<CatalogInfo[]> {
+  return invoke("list_doris_catalogs", { connectionId });
+}
+
+export async function listDorisCatalogDatabases(connectionId: string, catalog: string): Promise<DatabaseInfo[]> {
+  return invoke("list_doris_catalog_databases", { connectionId, catalog });
+}
+
+export async function listSqlServerLinkedServers(connectionId: string): Promise<LinkedServerInfo[]> {
+  return invoke("list_sqlserver_linked_servers", { connectionId });
+}
+
+export async function listSqlServerLinkedServerCatalogs(connectionId: string, server: string): Promise<DatabaseInfo[]> {
+  return invoke("list_sqlserver_linked_server_catalogs", { connectionId, server });
+}
+
+export async function listSqlServerLinkedServerSchemas(connectionId: string, server: string, catalog: string): Promise<string[]> {
+  return invoke("list_sqlserver_linked_server_schemas", { connectionId, server, catalog });
+}
+
+export async function listSqlServerLinkedServerTables(connectionId: string, server: string, catalog: string, schema: string, filter?: string, limit?: number, offset?: number): Promise<TableInfo[]> {
+  return invoke("list_sqlserver_linked_server_tables", { connectionId, server, catalog, schema, filter, limit, offset });
+}
+
+export async function saveSchemaCache(cacheKey: string, payload: unknown): Promise<void> {
+  return invoke("save_schema_cache", { cacheKey, payload });
+}
+
+export async function loadSchemaCache<T = unknown>(cacheKey: string): Promise<T | null> {
+  return invoke("load_schema_cache", { cacheKey });
+}
+
+export async function deleteSchemaCachePrefix(prefix: string): Promise<void> {
+  return invoke("delete_schema_cache_prefix", { prefix });
+}
+
+export async function listTables(connectionId: string, database: string, schema: string, filter?: string, limit?: number, offset?: number, objectTypes?: SidebarObjectKind[], catalog?: string): Promise<TableInfo[]> {
+  return invoke("list_tables", { connectionId, database, schema, filter, limit, offset, objectTypes, catalog });
+}
+
+export async function getTableComment(connectionId: string, database: string, schema: string, table: string, catalog?: string): Promise<string | null> {
+  return invoke("get_table_comment", { connectionId, database, schema, table, catalog });
+}
+
+export async function listObjects(connectionId: string, database: string, schema: string, objectTypes?: SidebarObjectKind[], filter?: string, limit?: number, offset?: number, catalog?: string): Promise<ObjectInfo[]> {
+  return invoke("list_objects", { connectionId, database, schema, objectTypes, filter, limit, offset, catalog });
+}
+
+export async function listObjectStatistics(connectionId: string, database: string, schema: string): Promise<ObjectStatistics[]> {
+  return invoke("list_object_statistics", { connectionId, database, schema });
+}
+
+export async function listCompletionObjects(connectionId: string, database: string, schema: string): Promise<ObjectInfo[]> {
+  return invoke("list_completion_objects", { connectionId, database, schema });
+}
+
+export async function completionAssistantSearch(request: CompletionAssistantRequest): Promise<CompletionAssistantResponse> {
+  return invoke("completion_assistant_search", { request });
+}
+
+export async function getObjectSource(connectionId: string, database: string, schema: string, name: string, objectType: ObjectSourceKind, signature?: string): Promise<ObjectSource> {
+  return invoke("get_object_source", { connectionId, database, schema, name, objectType, signature });
+}
+
+export async function listSchemas(connectionId: string, database: string, applyVisibleFilter = false): Promise<string[]> {
+  return invoke("list_schemas", { connectionId, database, applyVisibleFilter });
+}
+
+export async function listSchemaInfos(connectionId: string, database: string): Promise<SchemaInfo[]> {
+  return invoke("list_schema_infos", { connectionId, database });
+}
+
+export async function getColumns(connectionId: string, database: string, schema: string, table: string, catalog?: string): Promise<ColumnInfo[]> {
+  return invoke("get_columns", { connectionId, database, schema, table, catalog });
+}
+
+export async function listDataTypes(connectionId: string, database: string): Promise<string[]> {
+  return invoke("list_data_types", { connectionId, database });
+}
+
+export async function executeQuery(
+  connectionId: string,
+  database: string,
+  sql: string,
+  schema?: string,
+  executionId?: string,
+  options?: {
+    maxRows?: number;
+    fetchSize?: number;
+    pageSize?: number;
+    resultSessionId?: string;
+    clientSessionId?: string;
+    timeoutSecs?: number;
+  },
+): Promise<QueryResult> {
+  return invoke("execute_query", { connectionId, database, sql, schema, executionId, ...options });
+}
+
+export async function executeMulti(
+  connectionId: string,
+  database: string,
+  sql: string,
+  schema?: string,
+  executionId?: string,
+  options?: {
+    maxRows?: number;
+    fetchSize?: number;
+    pageSize?: number;
+    resultSessionId?: string;
+    clientSessionId?: string;
+    timeoutSecs?: number;
+    useTransaction?: boolean;
+  },
+): Promise<QueryResult[]> {
+  return invoke("execute_multi", { connectionId, database, sql, schema, executionId, ...options });
+}
+
+export async function refreshConnections(): Promise<void> {
+  return invoke("refresh_connections");
+}
+
+export async function cancelQuery(executionId: string): Promise<boolean> {
+  return invoke("cancel_query", { executionId });
+}
+
+export async function closeQuerySession(connectionId: string, database: string, sessionId: string, clientSessionId?: string): Promise<boolean> {
+  return invoke("close_query_session", { connectionId, database, sessionId, clientSessionId });
+}
+
+export async function closeClientConnectionSession(connectionId: string, database: string, clientSessionId: string): Promise<boolean> {
+  return invoke("close_client_connection_session", { connectionId, database, clientSessionId });
+}
+
+export async function executeBatch(connectionId: string, database: string, statements: string[], schema?: string, timeoutSecs?: number): Promise<QueryResult> {
+  return invoke("execute_batch", { connectionId, database, statements, schema, timeoutSecs });
+}
+
+export async function executeScript(connectionId: string, database: string, sql: string, schema?: string): Promise<QueryResult> {
+  return invoke("execute_script", { connectionId, database, sql, schema });
+}
+
+export async function executeInTransaction(connectionId: string, database: string, statements: string[], schema?: string): Promise<QueryResult> {
+  return invoke("execute_in_transaction", { connectionId, database, statements, schema });
+}
+
+export async function beginManualTransaction(connectionId: string, database: string, schema?: string): Promise<string> {
+  return invoke("begin_manual_transaction", { connectionId, database, schema });
+}
+
+export async function executeInManualTransaction(txnSessionId: string, sql: string, database: string, schema?: string, maxRows?: number): Promise<QueryResult[]> {
+  return invoke("execute_in_manual_transaction", { txnSessionId, sql, database, schema, maxRows });
+}
+
+export async function commitManualTransaction(txnSessionId: string): Promise<QueryResult> {
+  return invoke("commit_manual_transaction", { txnSessionId });
+}
+
+export async function rollbackManualTransaction(txnSessionId: string): Promise<QueryResult> {
+  return invoke("rollback_manual_transaction", { txnSessionId });
+}
+
+export async function analyzeSqlReferences(sql: string, dialect?: string): Promise<SqlReferenceAnalysis> {
+  return invoke("analyze_sql_references", { sql, dialect });
+}
+
+export async function findStatementAtCursor(sql: string, cursorPos: number, databaseType?: DatabaseType): Promise<string> {
+  return invoke("find_statement_at_cursor", { sql, cursorPos, databaseType });
+}
+
+export async function prepareQueryPaginationExecutionPlan(options: QueryPaginationExecutionPlanOptions): Promise<QueryPaginationExecutionPlan> {
+  return invoke("prepare_query_pagination_execution_plan", { options });
+}
+
+export async function buildSortedQuerySql(options: SortedQuerySqlOptions): Promise<QuerySqlBuildResult> {
+  return invoke("build_sorted_query_sql", { options });
+}
+
+export async function buildExplainSql(options: BuildExplainSqlOptions): Promise<ExplainSqlBuildResult> {
+  return invoke("build_explain_sql", { options });
+}
+
+export async function buildCreateUserSql(username: string, password: string, tablespace: string): Promise<string> {
+  return invoke("build_create_user_sql", { username, password, tablespace });
+}
+
+export async function getExplainInfo(connectionId: string, database: string | undefined, schema: string | undefined, sql: string, mode: string): Promise<string | undefined> {
+  try {
+    const result = await invoke<string>("get_explain_info", { connectionId, database, schema, sql, mode });
+    return result;
+  } catch (e: any) {
+    console.error("[getExplainInfo] invoke failed:", e?.message || e);
+    return undefined;
+  }
+}
+
+export async function buildDroppedFilePreviewSql(options: DroppedFilePreviewSqlOptions): Promise<string | undefined> {
+  const result = await invoke<string | null>("build_dropped_file_preview_sql", { options });
+  return result ?? undefined;
+}
+
+export async function buildTableSelectSql(options: BuildTableSelectSqlOptions): Promise<string> {
+  return invoke("build_table_select_sql", { options });
+}
+
+export async function buildDatabaseSearchSql(options: DatabaseSearchSqlOptions): Promise<DatabaseSearchSql | null> {
+  return invoke("build_database_search_sql", { options });
+}
+
+export async function buildSearchResultWhere(options: SearchResultWhereOptions): Promise<string> {
+  return invoke("build_search_result_where", { options });
+}
+
+export async function buildRenameObjectSql(options: BuildRenameObjectSqlOptions): Promise<string> {
+  return invoke("build_rename_object_sql", { options });
+}
+
+export async function buildCreateDatabaseSql(options: CreateDatabaseSqlOptions): Promise<string> {
+  return invoke("build_create_database_sql", { options });
+}
+
+export async function buildDuckDbAttachDatabaseSql(path: string, name: string): Promise<string> {
+  return invoke("build_duckdb_attach_database_sql", { options: { path, name } });
+}
+
+export async function buildDropObjectSql(options: DropObjectSqlOptions): Promise<string> {
+  return invoke("build_drop_object_sql", { options });
+}
+
+export async function buildDropTableSql(options: TableAdminSqlOptions): Promise<string> {
+  return invoke("build_drop_table_sql", { options });
+}
+
+export async function buildDropTableChildObjectSql(options: DropTableChildObjectSqlOptions): Promise<string> {
+  return invoke("build_drop_table_child_object_sql", { options });
+}
+
+export async function buildEmptyTableSql(options: TableAdminSqlOptions): Promise<string> {
+  return invoke("build_empty_table_sql", { options });
+}
+
+export async function buildTruncateTableSql(options: TableAdminSqlOptions): Promise<string> {
+  return invoke("build_truncate_table_sql", { options });
+}
+
+export async function buildDropDatabaseSql(options: DatabaseNameSqlOptions): Promise<string> {
+  return invoke("build_drop_database_sql", { options });
+}
+
+export async function buildCreateSchemaSql(options: SchemaNameSqlOptions): Promise<string> {
+  return invoke("build_create_schema_sql", { options });
+}
+
+export async function buildUpdateDatabasePropertiesSql(options: DatabasePropertyEditSqlOptions): Promise<string> {
+  return invoke("build_update_database_properties_sql", { options });
+}
+
+export async function buildDropSchemaSql(options: SchemaNameSqlOptions): Promise<string> {
+  return invoke("build_drop_schema_sql", { options });
+}
+
+export async function buildDuplicateTableStructureSql(options: DuplicateTableStructureSqlOptions): Promise<string> {
+  return invoke("build_duplicate_table_structure_sql", { options });
+}
+
+export async function buildCopyTableDataSql(options: CopyTableDataSqlOptions): Promise<string> {
+  return invoke("build_copy_table_data_sql", { options });
+}
+
+export async function buildExecutableObjectSourceStatements(input: BuildEditableObjectSourceSqlInput): Promise<string[]> {
+  return invoke("build_executable_object_source_statements", { input });
+}
+
+export async function buildExecutableObjectSourceSql(input: BuildEditableObjectSourceSqlInput): Promise<string> {
+  return invoke("build_executable_object_source_sql", { input });
+}
+
+export async function buildEditableObjectSource(input: BuildEditableObjectSourceSqlInput): Promise<string> {
+  return invoke("build_editable_object_source", { input });
+}
+
+export async function buildRoutineRenameObjectSourceStatements(input: BuildRoutineRenameObjectSourceInput): Promise<string[]> {
+  return invoke("build_routine_rename_object_source_statements", { input });
+}
+
+export async function buildViewDdlSql(input: BuildViewDdlInput): Promise<string> {
+  return invoke("build_view_ddl_sql", { input });
+}
+
+export async function buildTableStructureChangeSql(options: BuildTableStructureChangeSqlOptions): Promise<TableStructureChangeSql> {
+  return invoke("build_table_structure_change_sql", { options });
+}
+
+export async function previewSqliteTableStructureChange(connectionId: string, database: string, options: BuildTableStructureChangeSqlOptions): Promise<SqliteTableStructureChangePreview> {
+  return invoke("preview_sqlite_table_structure_change", { connectionId, database, options });
+}
+
+export async function applySqliteTableStructureChange(connectionId: string, database: string, options: BuildTableStructureChangeSqlOptions, schemaRevision: string): Promise<QueryResult> {
+  return invoke("apply_sqlite_table_structure_change", { connectionId, database, options, schemaRevision });
+}
+
+export async function buildCreateTableSql(options: BuildTableStructureChangeSqlOptions): Promise<TableStructureChangeSql> {
+  return invoke("build_create_table_sql", { options });
+}
+
+export async function buildSingleColumnAlterSql(options: BuildSingleColumnAlterSqlOptions): Promise<TableStructureChangeSql> {
+  return invoke("build_single_column_alter_sql", { options });
+}
+
+export async function analyzeEditableQueryEditability(sql: string): Promise<QueryEditability> {
+  return invoke("analyze_editable_query_editability", { sql });
+}
+
+export interface DataGridSavePreparation {
+  validationError?: string;
+  statements: string[];
+  rollbackStatements: string[];
+  executionSchema?: string;
+}
+
+export async function prepareDataGridSave(options: DataGridSaveStatementOptions): Promise<DataGridSavePreparation> {
+  return invoke("prepare_data_grid_save", { options });
+}
+
+export async function buildDataGridCopyUpdateStatements(options: DataGridCopyUpdateStatementOptions): Promise<string[]> {
+  return invoke("build_data_grid_copy_update_statements", { options });
+}
+
+export async function buildDataGridCopyInsertStatement(options: DataGridCopyInsertStatementOptions): Promise<string | undefined> {
+  const result = await invoke<string | null>("build_data_grid_copy_insert_statement", { options });
+  return result ?? undefined;
+}
+
+export async function buildDataGridContextFilterCondition(options: DataGridContextFilterConditionOptions): Promise<string | undefined> {
+  const result = await invoke<string | null>("build_data_grid_context_filter_condition", { options });
+  return result ?? undefined;
+}
+
+export async function buildDataGridColumnValueFilterCondition(options: DataGridColumnValueFilterConditionOptions): Promise<string | undefined> {
+  const result = await invoke<string | null>("build_data_grid_column_value_filter_condition", { options });
+  return result ?? undefined;
+}
+
+export async function buildDataGridColumnValuesFilterCondition(options: DataGridColumnValuesFilterConditionOptions): Promise<string | undefined> {
+  const result = await invoke<string | null>("build_data_grid_column_values_filter_condition", { options });
+  return result ?? undefined;
+}
+
+export async function buildDataGridColumnDistinctValuesSql(options: DataGridColumnDistinctValuesSqlOptions): Promise<string> {
+  return invoke("build_data_grid_column_distinct_values_sql", { options });
+}
+
+export async function buildDataGridCountSql(options: DataGridCountSqlOptions): Promise<string> {
+  return invoke("build_data_grid_count_sql", { options });
+}
+
+export async function buildHiveTablePropertiesSql(options: HiveTablePropertiesSqlOptions): Promise<string> {
+  return invoke("build_hive_table_properties_sql", { options });
+}
+
+export async function buildExportInsertStatements(options: BuildExportInsertStatementsOptions): Promise<string[]> {
+  return invoke("build_export_insert_statements", { options });
+}
+
+export async function buildExportSqlInsert(options: BuildExportInsertStatementsOptions): Promise<string> {
+  return invoke("build_export_sql_insert", { options });
+}
+
+export async function buildDatabaseSqlExport(options: BuildDatabaseSqlExportOptions): Promise<string> {
+  return invoke("build_database_sql_export", { options });
+}
+
+export async function prepareDataCompare(options: DataComparePreparationOptions): Promise<DataComparePreparation> {
+  return invoke("prepare_data_compare", { options });
+}
+
+export async function prepareDataCompareFromTables(options: DataCompareFromTablesOptions): Promise<DataCompareFromTablesPreparation> {
+  return invoke("prepare_data_compare_from_tables", { options });
+}
+
+export async function prepareDataCompareMissingTarget(options: import("@/lib/dataGrid/dataCompare").DataCompareMissingTargetOptions): Promise<DataCompareFromTablesPreparation> {
+  return invoke("prepare_data_compare_missing_target", { options });
+}
+
+export async function buildDataCompareSyncPlan(options: DataCompareSyncPlanOptions): Promise<DataCompareSyncPlan> {
+  return invoke("build_data_compare_sync_plan", { options });
+}
+
+export async function listIndexes(connectionId: string, database: string, schema: string, table: string, catalog?: string): Promise<IndexInfo[]> {
+  return invoke("list_indexes", { connectionId, database, schema, table, catalog });
+}
+
+export async function listForeignKeys(connectionId: string, database: string, schema: string, table: string, catalog?: string): Promise<ForeignKeyInfo[]> {
+  return invoke("list_foreign_keys", { connectionId, database, schema, table, catalog });
+}
+
+export async function listTriggers(connectionId: string, database: string, schema: string, table: string, catalog?: string): Promise<TriggerInfo[]> {
+  return invoke("list_triggers", { connectionId, database, schema, table, catalog });
+}
+
+export async function getTableDdl(connectionId: string, database: string, schema: string, table: string, objectType?: ObjectSourceKind, catalog?: string): Promise<string> {
+  return invoke("get_table_ddl", { connectionId, database, schema, table, objectType, catalog });
+}
+
+export async function prepareSchemaDiff(options: SchemaDiffPreparationOptions): Promise<SchemaDiffPreparation> {
+  return invoke("prepare_schema_diff", { options });
+}
+
+export async function generateSchemaSyncSql(diffs: TableDiff[], databaseType: DatabaseType, targetSchema?: string, functionDiffs?: FunctionDiff[], sequenceDiffs?: SequenceDiff[], ruleDiffs?: RuleDiff[], ownerDiffs?: OwnerDiff[], cascadeDelete?: boolean): Promise<string> {
+  return invoke("generate_schema_sync_sql", {
+    diffs,
+    databaseType,
+    targetSchema,
+    functionDiffs: functionDiffs ?? [],
+    sequenceDiffs: sequenceDiffs ?? [],
+    ruleDiffs: ruleDiffs ?? [],
+    ownerDiffs: ownerDiffs ?? [],
+    cascadeDelete: cascadeDelete ?? false,
+  });
+}
+
+export async function listFunctions(connectionId: string, database: string, schema: string): Promise<FunctionInfo[]> {
+  return invoke("list_functions", { connectionId, database, schema });
+}
+
+export async function listSequences(connectionId: string, database: string, schema: string, withLastValues: boolean): Promise<SequenceInfo[]> {
+  return invoke("list_sequences", { connectionId, database, schema, withLastValues });
+}
+
+export async function listRules(connectionId: string, database: string, schema: string): Promise<RuleInfo[]> {
+  return invoke("list_rules", { connectionId, database, schema });
+}
+
+export async function listOwners(connectionId: string, database: string, schema: string): Promise<OwnerInfo[]> {
+  return invoke("list_owners", { connectionId, database, schema });
+}
+
+export async function listExtensions(connectionId: string, database: string, schema: string): Promise<ExtensionInfo[]> {
+  return invoke("list_extensions", { connectionId, database, schema });
+}
+
+export async function listAvailableExtensions(connectionId: string, database: string): Promise<ExtensionInfo[]> {
+  return invoke("list_available_extensions", { connectionId, database });
+}
+
+export async function saveConnections(configs: ConnectionConfig[]): Promise<void> {
+  return invoke("save_connections", { configs });
+}
+
+export async function loadConnections(): Promise<ConnectionConfig[]> {
+  return invoke("load_connections");
+}
+
+export async function loadTunnelProfiles(): Promise<TunnelProfile[]> {
+  return invoke("load_tunnel_profiles");
+}
+
+export async function saveTunnelProfiles(profiles: TunnelProfile[]): Promise<void> {
+  return invoke("save_tunnel_profiles", { profiles });
+}
+
+export async function readKeychainPassword(service: string): Promise<string> {
+  return invoke("read_keychain_password", { service, account: null });
+}
+
+export async function readKeychainPasswords(services: string[]): Promise<[string, string][]> {
+  return invoke("read_keychain_passwords", { services });
+}
+
+export async function decryptConfig(payload: unknown, passphrase: string): Promise<string> {
+  const { decryptConfig: decryptConfigPayload } = await import("@/lib/backend/configCrypto");
+  return decryptConfigPayload(payload as any, passphrase);
+}
+
+export async function listPlugins(): Promise<InstalledPlugin[]> {
+  return invoke("list_plugins");
+}
+
+export async function listJdbcDrivers(): Promise<JdbcDriverInfo[]> {
+  return invoke("list_jdbc_drivers");
+}
+
+export async function listJdbcMavenBundles(): Promise<JdbcMavenBundleInfo[]> {
+  return invoke("list_jdbc_maven_bundles");
+}
+
+export async function listJdbcLocalBundles(): Promise<JdbcLocalBundleInfo[]> {
+  return invoke("list_jdbc_local_bundles");
+}
+
+export async function importJdbcDrivers(paths: (string | File)[]): Promise<JdbcDriverInfo[]> {
+  if (paths.some((path) => typeof path !== "string")) {
+    throw new Error("Desktop JDBC driver import requires local file paths");
+  }
+  return invoke("import_jdbc_drivers", { paths });
+}
+
+export async function installJdbcDriverFromMaven(coordinate: string, repositories: string[] = []): Promise<JdbcDriverInfo[]> {
+  return invoke("install_jdbc_driver_from_maven", { request: { coordinate, repositories } });
+}
+
+export async function installPrestoSqlJdbcDriver(): Promise<JdbcDriverInfo[]> {
+  return invoke("install_prestosql_jdbc_driver");
+}
+
+export async function deleteJdbcDriver(path: string): Promise<JdbcDriverInfo[]> {
+  return invoke("delete_jdbc_driver", { path });
+}
+
+export async function deleteJdbcMavenBundle(bundleId: string): Promise<JdbcDriverInfo[]> {
+  return invoke("delete_jdbc_maven_bundle", { bundleId });
+}
+
+export async function deleteJdbcLocalBundle(bundleId: string): Promise<JdbcDriverInfo[]> {
+  return invoke("delete_jdbc_local_bundle", { bundleId });
+}
+
+export async function jdbcPluginStatus(): Promise<JdbcPluginStatus> {
+  return invoke("jdbc_plugin_status");
+}
+
+export async function installJdbcPlugin(): Promise<JdbcPluginStatus> {
+  return invoke("install_jdbc_plugin");
+}
+
+export async function installJdbcPluginLocal(path: string | File): Promise<JdbcPluginStatus> {
+  if (typeof path !== "string") {
+    throw new Error("Desktop JDBC plugin install requires a local file path");
+  }
+  return invoke("install_jdbc_plugin_local", { path });
+}
+
+export async function uninstallJdbcPlugin(): Promise<JdbcPluginStatus> {
+  return invoke("uninstall_jdbc_plugin");
+}
+
+export async function listInstalledAgentsLocal(): Promise<AgentDriverInfo[]> {
+  return invoke("list_installed_agents_local");
+}
+
+export async function listInstalledAgents(source?: UpdateDownloadSource): Promise<AgentDriverInfo[]> {
+  return invoke("list_installed_agents", { source });
+}
+
+export async function isAgentInstalled(dbType: string): Promise<boolean> {
+  return invoke("is_agent_installed", { dbType });
+}
+
+export async function getDriverStoreUsage(): Promise<DriverStoreUsage> {
+  return invoke("get_driver_store_usage");
+}
+
+export async function clearDriverDownloadCache(): Promise<void> {
+  return invoke("clear_driver_download_cache");
+}
+
+export async function getDriverRuntimeSummary(): Promise<DriverRuntimeSummary> {
+  return invoke("get_driver_runtime_summary");
+}
+
+export async function stopDriverRuntime(runtimeId: string): Promise<void> {
+  return invoke("stop_driver_runtime", { runtimeId });
+}
+
+export async function restartDriverRuntime(runtimeId: string): Promise<void> {
+  return invoke("restart_driver_runtime", { runtimeId });
+}
+
+export async function installAgent(dbType: string, source?: UpdateDownloadSource): Promise<void> {
+  return invoke("install_agent", { dbType, source });
+}
+
+export async function upgradeAllAgents(source?: UpdateDownloadSource): Promise<UpgradeAllAgentDriversResult> {
+  return invoke("upgrade_all_agents", { source });
+}
+
+export async function checkAgentUpdateBlockers(dbTypes: string[]): Promise<AgentUpdateBlocker[]> {
+  return invoke("check_agent_update_blockers", { dbTypes });
+}
+
+export async function uninstallAgent(dbType: string): Promise<void> {
+  return invoke("uninstall_agent", { dbType });
+}
+
+export async function getAgentJavaRuntimeConfig(): Promise<JavaRuntimeConfig> {
+  return invoke("get_agent_java_runtime_config");
+}
+
+export async function setAgentJavaRuntimeConfig(config: JavaRuntimeConfig): Promise<JavaRuntimeConfig> {
+  return invoke("set_agent_java_runtime_config", { config });
+}
+
+export async function invalidateAgentRegistryCache(): Promise<void> {
+  return invoke("invalidate_agent_registry_cache");
+}
+
+export async function importAgentsFromZip(path: string | File): Promise<number> {
+  if (typeof path !== "string") {
+    throw new Error("Desktop offline ZIP import requires a local file path");
+  }
+  return invoke("import_agents_from_zip", { path });
+}
+
+export async function importAgentJar(dbType: string, path: string | File): Promise<void> {
+  if (typeof path !== "string") {
+    throw new Error("Desktop driver JAR import requires a local file path");
+  }
+  return invoke("import_agent_jar_cmd", { dbType, path });
+}
+
+export async function reinstallJre(jreKey?: string, source?: UpdateDownloadSource): Promise<void> {
+  return invoke("reinstall_jre", { jreKey, source });
+}
+
+export async function uninstallJre(jreKey: string): Promise<void> {
+  return invoke("uninstall_jre", { jreKey });
+}
+
+export async function listenAgentInstallProgress(handler: (progress: DriverInstallProgress) => void): Promise<UnlistenFn> {
+  return listen<DriverInstallProgress>("agent-install-progress", (event) => handler(event.payload));
+}
+
+export async function loadSavedSqlLibrary(): Promise<SavedSqlLibrary> {
+  return invoke("load_saved_sql_library");
+}
+
+export async function loadSavedSqlFile(id: string): Promise<SavedSqlFile | null> {
+  return invoke("load_saved_sql_file", { id });
+}
+
+export async function saveSavedSqlFolder(folder: SavedSqlFolder): Promise<SavedSqlFolder> {
+  return invoke("save_saved_sql_folder", { folder });
+}
+
+export async function deleteSavedSqlFolder(id: string): Promise<void> {
+  return invoke("delete_saved_sql_folder", { id });
+}
+
+export async function saveSavedSqlFile(file: SavedSqlFile): Promise<SavedSqlFile> {
+  return invoke("save_saved_sql_file", { file });
+}
+
+export async function deleteSavedSqlFile(id: string): Promise<void> {
+  return invoke("delete_saved_sql_file", { id });
+}
+
+export async function savedSqlStorageDir(): Promise<string> {
+  return invoke("saved_sql_storage_dir");
+}
+
+export async function openSavedSqlStorageDir(dir?: string | null): Promise<void> {
+  return invoke("open_saved_sql_storage_dir", { dir });
+}
+
+export async function revealPathInFileManager(path: string): Promise<void> {
+  return invoke("reveal_path_in_file_manager", { path });
+}
+
+export async function isSqliteDatabaseFile(path: string): Promise<boolean> {
+  return invoke("is_sqlite_database_file", { path });
+}
+
+export async function backupSqliteDatabase(connectionId: string, destinationPath: string): Promise<void> {
+  return invoke("backup_sqlite_database", { connectionId, destinationPath });
+}
+
+export async function syncSavedSqlDirectory(request: SavedSqlSyncRequest): Promise<void> {
+  return invoke("sync_saved_sql_directory", { request });
+}
+
+export async function saveSidebarLayout(layout: import("@/types/database").SidebarLayout): Promise<void> {
+  return invoke("save_sidebar_layout", { layout });
+}
+
+export async function loadSidebarLayout(): Promise<import("@/types/database").SidebarLayout | null> {
+  return invoke("load_sidebar_layout");
+}
+
+// --- Updates ---
+export interface UpdateInfo {
+  current_version: string;
+  latest_version: string;
+  update_available: boolean;
+  portable_mode: boolean;
+  release_name: string;
+  release_url: string;
+  release_notes: string;
+}
+
+export type UpdateDownloadSource = "official" | "cnb" | "atomgit";
+
+export interface UpdateDownloadProgress {
+  downloaded: number;
+  total: number | null;
+}
+
+export interface McpServerStatus {
+  installed: boolean;
+  npm_available: boolean;
+  node_path: string | null;
+  node_version: string | null;
+  current_version: string | null;
+  latest_version: string | null;
+  update_available: boolean;
+  bin_path: string | null;
+  script_path: string | null;
+  install_command: string;
+  update_command: string;
+  error: string | null;
+}
+
+export async function checkMcpServerStatus(): Promise<McpServerStatus> {
+  return invoke("check_mcp_server_status");
+}
+
+export async function installMcpServer(): Promise<string> {
+  return invoke("install_mcp_server");
+}
+
+export async function checkForUpdates(locale?: string): Promise<UpdateInfo> {
+  return invoke("check_for_updates", { locale });
+}
+
+export async function getSystemProxyUrl(): Promise<string | null> {
+  return invoke("get_system_proxy_url");
+}
+
+export async function downloadAndInstallUpdate(source: UpdateDownloadSource, latestVersion?: string): Promise<void> {
+  return invoke("download_and_install_update", { source, latestVersion });
+}
+
+export async function getAppVersion(): Promise<string> {
+  const { getVersion } = await import("@tauri-apps/api/app");
+  return getVersion();
+}
+
+export async function getAppSupportInfo(): Promise<AppSupportInfo> {
+  return invoke<AppSupportInfo>("get_app_support_info");
+}
+
+// --- Redis ---
+export interface RedisKeyInfo {
+  key_display: string;
+  key_raw: string;
+  key_type?: string;
+  ttl?: number;
+  size?: number;
+  value_preview?: string;
+}
+
+export interface RedisDatabaseInfo {
+  db: number;
+  keys: number;
+}
+
+export type RedisBlobEncoding = "utf8" | "binary";
+
+export interface RedisBlob {
+  raw_base64: string;
+  encoding: RedisBlobEncoding;
+}
+
+export interface RedisListItem {
+  index: number;
+  value: RedisBlob;
+}
+
+export interface RedisSetItem {
+  member: RedisBlob;
+}
+
+export interface RedisHashItem {
+  field: RedisBlob;
+  value: RedisBlob;
+}
+
+export interface RedisZsetItem {
+  score: string;
+  member: RedisBlob;
+}
+
+export interface RedisStreamField {
+  field: string;
+  value: string;
+}
+
+export interface RedisStreamEntry {
+  id: string;
+  fields: RedisStreamField[];
+}
+
+export type RedisValueData =
+  | { kind: "string"; content: RedisBlob }
+  | { kind: "json"; value: unknown }
+  | { kind: "list"; items: RedisListItem[]; total: number; scan_cursor?: number }
+  | { kind: "set"; items: RedisSetItem[]; total: number; scan_cursor?: number }
+  | { kind: "hash"; items: RedisHashItem[]; total: number; scan_cursor?: number }
+  | { kind: "zset"; items: RedisZsetItem[]; total: number; scan_cursor?: number }
+  | { kind: "stream"; entries: RedisStreamEntry[] }
+  | { kind: "unknown" };
+
+export interface RedisValue {
+  key_display: string;
+  key_raw: string;
+  ttl: number;
+  redis_type: string;
+  data: RedisValueData;
+}
+
+export type RedisCollectionPage = { kind: "list"; items: RedisListItem[]; scan_cursor?: number } | { kind: "set"; items: RedisSetItem[]; scan_cursor?: number } | { kind: "hash"; items: RedisHashItem[]; scan_cursor?: number } | { kind: "zset"; items: RedisZsetItem[]; scan_cursor?: number };
+
+export interface RedisScanResult {
+  cursor: number;
+  keys: RedisKeyInfo[];
+  total_keys: number;
+}
+
+export type RedisCommandSafety = "allowed" | "write" | "confirm" | "blocked";
+
+export interface RedisCommandResult {
+  command: string;
+  safety: RedisCommandSafety;
+  value: any;
+}
+
+export interface RedisSlowlogEntry {
+  id: number;
+  timestamp: number;
+  duration_micros: number;
+  command: string;
+  client_addr: string | null;
+  client_name: string | null;
+}
+
+export interface RedisNodeEndpoint {
+  host: string;
+  port: number;
+}
+
+export async function redisListDatabases(connectionId: string): Promise<RedisDatabaseInfo[]> {
+  return invoke("redis_list_databases", { connectionId });
+}
+
+export async function redisScanKeys(connectionId: string, db: number, cursor: number, pattern: string, count: number): Promise<RedisScanResult> {
+  return invoke("redis_scan_keys", { connectionId, db, cursor, pattern, count });
+}
+
+export async function redisScanKeysBatch(connectionId: string, db: number, cursor: number, pattern: string, count: number, maxIterations: number, includeTypes = true): Promise<RedisScanResult> {
+  return invoke("redis_scan_keys_batch", { connectionId, db, cursor, pattern, count, maxIterations, includeTypes });
+}
+
+export async function redisScanValues(connectionId: string, db: number, cursor: number, pattern: string, query: string, count: number, includeKeyMatches = false): Promise<RedisScanResult> {
+  return invoke("redis_scan_values", { connectionId, db, cursor, pattern, query, includeKeyMatches, count });
+}
+
+export async function redisGetValue(connectionId: string, db: number, keyRaw: string): Promise<RedisValue> {
+  return invoke("redis_get_value", { connectionId, db, keyRaw });
+}
+
+export async function redisSetString(connectionId: string, db: number, keyRaw: string, value: string, ttl?: number): Promise<void> {
+  return invoke("redis_set_string", { connectionId, db, keyRaw, value, ttl });
+}
+
+export async function redisDeleteKey(connectionId: string, db: number, keyRaw: string): Promise<void> {
+  return invoke("redis_delete_key", { connectionId, db, keyRaw });
+}
+
+export async function redisHashSet(connectionId: string, db: number, keyRaw: string, field: string, value: string, ttl?: number): Promise<void> {
+  return invoke("redis_hash_set", { connectionId, db, keyRaw, field, value, ttl });
+}
+
+export async function redisHashDel(connectionId: string, db: number, keyRaw: string, field: string): Promise<void> {
+  return invoke("redis_hash_del", { connectionId, db, keyRaw, field });
+}
+
+export async function redisListPush(connectionId: string, db: number, keyRaw: string, value: string, ttl?: number): Promise<void> {
+  return invoke("redis_list_push", { connectionId, db, keyRaw, value, ttl });
+}
+
+export async function redisListSet(connectionId: string, db: number, keyRaw: string, index: number, value: string): Promise<void> {
+  return invoke("redis_list_set", { connectionId, db, keyRaw, index, value });
+}
+
+export async function redisListRemove(connectionId: string, db: number, keyRaw: string, index: number): Promise<void> {
+  return invoke("redis_list_remove", { connectionId, db, keyRaw, index });
+}
+
+export async function redisSetAdd(connectionId: string, db: number, keyRaw: string, member: string, ttl?: number): Promise<void> {
+  return invoke("redis_set_add", { connectionId, db, keyRaw, member, ttl });
+}
+
+export async function redisSetRemove(connectionId: string, db: number, keyRaw: string, member: string): Promise<void> {
+  return invoke("redis_set_remove", { connectionId, db, keyRaw, member });
+}
+
+export async function redisZadd(connectionId: string, db: number, keyRaw: string, member: string, score: number, ttl?: number): Promise<void> {
+  return invoke("redis_zadd", { connectionId, db, keyRaw, member, score, ttl });
+}
+
+export async function redisZrem(connectionId: string, db: number, keyRaw: string, member: string): Promise<void> {
+  return invoke("redis_zrem", { connectionId, db, keyRaw, member });
+}
+
+export async function redisStreamAdd(connectionId: string, db: number, keyRaw: string, entryId: string, fields: [string, string][], ttl?: number): Promise<void> {
+  return invoke("redis_stream_add", { connectionId, db, keyRaw, entryId, fields, ttl });
+}
+
+export async function redisJsonSet(connectionId: string, db: number, keyRaw: string, value: string, ttl?: number): Promise<void> {
+  return invoke("redis_json_set", { connectionId, db, keyRaw, value, ttl });
+}
+
+export async function redisCheckJsonModule(connectionId: string, db: number): Promise<boolean> {
+  return invoke("redis_check_json_module", { connectionId, db });
+}
+
+export async function redisSetTtl(connectionId: string, db: number, keyRaw: string, ttl: number): Promise<void> {
+  return invoke("redis_set_ttl", { connectionId, db, keyRaw, ttl });
+}
+
+export async function redisDeleteKeys(connectionId: string, db: number, keyRaws: string[]): Promise<number> {
+  return invoke("redis_delete_keys", { connectionId, db, keyRaws });
+}
+
+export async function redisFlushDb(connectionId: string, db: number): Promise<void> {
+  return invoke("redis_flush_db", { connectionId, db });
+}
+
+export async function redisExecuteCommand(connectionId: string, db: number, command: string, skipSafetyCheck?: boolean): Promise<RedisCommandResult> {
+  return invoke("redis_execute_command", { connectionId, db, command, skipSafetyCheck: skipSafetyCheck ?? false });
+}
+
+export async function redisLoadMore(connectionId: string, db: number, keyRaw: string, keyType: string, cursor: number, count: number, filter?: string): Promise<RedisCollectionPage> {
+  return invoke("redis_load_more", { connectionId, db, keyRaw, keyType, cursor, count, filter });
+}
+
+export async function redisPubSubPublish(connectionId: string, db: number, channel: string, message: string): Promise<{ subscribers: number }> {
+  return invoke("redis_pubsub_publish", { connectionId, db, channel, message });
+}
+
+export async function redisPubSubConnect(connectionId: string): Promise<WebSocket> {
+  const port = await invoke<number>("redis_pubsub_server_port");
+  return new WebSocket(`ws://127.0.0.1:${port}/api/redis/pubsub/ws?connectionId=${encodeURIComponent(connectionId)}`);
+}
+
+export async function redisSlowlogGet(connectionId: string, count: number, nodeHost?: string, nodePort?: number): Promise<RedisSlowlogEntry[]> {
+  return invoke("redis_slowlog_get", { connectionId, count, nodeHost, nodePort });
+}
+
+export async function redisClusterMasterNodes(connectionId: string): Promise<RedisNodeEndpoint[]> {
+  return invoke("redis_cluster_master_nodes", { connectionId });
+}
+
+// --- etcd ---
+export type KvValueEncoding = "utf8" | "base64";
+
+export interface KvValue {
+  encoding: KvValueEncoding;
+  data: string;
+}
+
+export interface KvKeyMetadata {
+  createRevision?: number | null;
+  modRevision?: number | null;
+  version?: number | null;
+  lease?: number | null;
+  valueSize?: number | null;
+  czxid?: number | null;
+  mzxid?: number | null;
+  pzxid?: number | null;
+  ctime?: number | null;
+  mtime?: number | null;
+  cversion?: number | null;
+  aversion?: number | null;
+  ephemeralOwner?: number | null;
+  dataLength?: number | null;
+  numChildren?: number | null;
+}
+
+export interface KvKeySummary extends KvKeyMetadata {
+  key: string;
+}
+
+export interface KvListPrefixResponse {
+  keys: KvKeySummary[];
+  continuation?: string | null;
+  revision?: number | null;
+}
+
+export interface KvListPrefixOptions {
+  recursive?: boolean | null;
+}
+
+export interface KvGetResponse {
+  found: boolean;
+  key?: string | null;
+  value?: KvValue | null;
+  metadata?: KvKeyMetadata | null;
+}
+
+export interface KvPutResponse {
+  revision?: number | null;
+  version?: number | null;
+  mtime?: number | null;
+  key?: string | null;
+  createdKey?: string | null;
+}
+
+export type KvWriteMode = "upsert" | "create" | "update";
+export type KvCreateMode = "persistent" | "ephemeral" | "persistent_sequential" | "ephemeral_sequential";
+
+export interface KvPutOptions {
+  writeMode?: KvWriteMode | null;
+  createMode?: KvCreateMode | null;
+}
+
+export interface KvDeleteResponse {
+  deleted: number;
+  revision?: number | null;
+}
+
+export async function etcdListPrefix(connectionId: string, prefix: string, limit: number, continuation?: string | null): Promise<KvListPrefixResponse> {
+  return invoke("etcd_list_prefix", { connectionId, prefix, limit, continuation });
+}
+
+export async function etcdGet(connectionId: string, key: string): Promise<KvGetResponse> {
+  return invoke("etcd_get", { connectionId, key });
+}
+
+export async function etcdPut(connectionId: string, key: string, value: KvValue, lease?: number | null): Promise<KvPutResponse> {
+  return invoke("etcd_put", { connectionId, key, value, lease });
+}
+
+export async function etcdDelete(connectionId: string, key: string): Promise<KvDeleteResponse> {
+  return invoke("etcd_delete", { connectionId, key });
+}
+
+// --- ZooKeeper ---
+export async function zookeeperListPrefix(connectionId: string, prefix: string, limit: number, continuation?: string | null, options?: KvListPrefixOptions | null): Promise<KvListPrefixResponse> {
+  return invoke("zookeeper_list_prefix", { connectionId, prefix, limit, continuation, recursive: options?.recursive ?? null });
+}
+
+export async function zookeeperGet(connectionId: string, key: string): Promise<KvGetResponse> {
+  return invoke("zookeeper_get", { connectionId, key });
+}
+
+export async function zookeeperPut(connectionId: string, key: string, value: KvValue, options?: KvPutOptions | null): Promise<KvPutResponse> {
+  return invoke("zookeeper_put", { connectionId, key, value, options: options ?? null });
+}
+
+export async function zookeeperDelete(connectionId: string, key: string): Promise<KvDeleteResponse> {
+  return invoke("zookeeper_delete", { connectionId, key });
+}
+
+// --- MongoDB ---
+export interface MongoDocumentResult {
+  documents: any[];
+  total: number;
+}
+
+export interface MongoCollectionStatsResult {
+  count: unknown;
+  size: unknown;
+  avgObjSize: unknown;
+  storageSize: unknown;
+  totalIndexSize: unknown;
+  nindexes: unknown;
+}
+
+export interface MongoGridFsFileInfo {
+  id: string;
+  filename?: string;
+  length: number;
+  chunkSize: number;
+  uploadDate?: string;
+  metadata?: any;
+  md5?: string;
+  contentType?: string;
+  aliases?: string[];
+}
+
+export interface MongoGridFsBucketInfo {
+  name: string;
+  fileCount: number;
+  totalBytes: number;
+}
+
+export async function documentListDatabases(connectionId: string): Promise<string[]> {
+  return invoke("document_list_databases", { connectionId });
+}
+
+export async function mongoListDatabases(connectionId: string): Promise<string[]> {
+  return documentListDatabases(connectionId);
+}
+
+export async function documentListCollections(connectionId: string, database: string): Promise<CollectionInfo[]> {
+  return invoke("document_list_collections", { connectionId, database });
+}
+
+export async function mongoListCollections(connectionId: string, database: string): Promise<CollectionInfo[]> {
+  return documentListCollections(connectionId, database);
+}
+
+export async function vectorGetCollectionDetail(connectionId: string, database: string, collection: string): Promise<CollectionInfo> {
+  return invoke("vector_collection_detail", { connectionId, database, collection });
+}
+
+export async function mongoCreateDatabase(connectionId: string, database: string): Promise<void> {
+  return invoke("mongo_create_database", { connectionId, database });
+}
+
+export async function mongoDropDatabase(connectionId: string, database: string): Promise<void> {
+  return invoke("mongo_drop_database", { connectionId, database });
+}
+
+export async function mongoDropCollection(connectionId: string, database: string, collection: string): Promise<void> {
+  return invoke("mongo_drop_collection", { connectionId, database, collection });
+}
+
+export async function elasticsearchListIndices(connectionId: string): Promise<string[]> {
+  const collections = await documentListCollections(connectionId, "default");
+  return collections.map((c) => c.name);
+}
+
+export async function vectorListCollections(connectionId: string, database?: string): Promise<CollectionInfo[]> {
+  return documentListCollections(connectionId, database || "default");
+}
+
+export async function mongoFindDocuments(connectionId: string, database: string, collection: string, skip: number, limit: number, filter?: string, projection?: string, sort?: string, executionId?: string): Promise<MongoDocumentResult> {
+  return documentFindDocuments(connectionId, database, collection, skip, limit, filter, projection, sort, executionId);
+}
+
+export async function documentFindDocuments(connectionId: string, database: string, collection: string, skip: number, limit: number, filter?: string, projection?: string, sort?: string, executionId?: string): Promise<MongoDocumentResult> {
+  return invoke("document_find_documents", { connectionId, database, collection, skip, limit, filter, projection, sort, executionId });
+}
+
+export async function documentListGridFsFiles(connectionId: string, database: string, bucket: string, filter?: string, sort?: string): Promise<MongoGridFsFileInfo[]> {
+  return invoke("document_list_gridfs_files", { connectionId, database, bucket, filter, sort });
+}
+
+export async function documentListGridFsBuckets(connectionId: string, database: string, filter?: string, sort?: string): Promise<MongoGridFsBucketInfo[]> {
+  return invoke("document_list_gridfs_buckets", { connectionId, database, filter, sort });
+}
+
+export async function documentCreateGridFsBucket(connectionId: string, database: string, bucket: string): Promise<void> {
+  return invoke("document_create_gridfs_bucket", { connectionId, database, bucket });
+}
+
+export async function documentDeleteGridFsBucket(connectionId: string, database: string, bucket: string): Promise<void> {
+  return invoke("document_delete_gridfs_bucket", { connectionId, database, bucket });
+}
+
+export async function documentDownloadGridFsFile(connectionId: string, database: string, bucket: string, fileId: string): Promise<Uint8Array> {
+  const data = await invoke<number[]>("document_download_gridfs_file", { connectionId, database, bucket, fileId });
+  return new Uint8Array(data);
+}
+
+export async function documentUploadGridFsFile(connectionId: string, database: string, bucket: string, fileName: string, data: Uint8Array, contentType?: string): Promise<string> {
+  return invoke("document_upload_gridfs_file", {
+    connectionId,
+    database,
+    bucket,
+    fileName,
+    data: Array.from(data),
+    contentType,
+  });
+}
+
+export async function documentDeleteGridFsFile(connectionId: string, database: string, bucket: string, fileId: string): Promise<void> {
+  return invoke("document_delete_gridfs_file", { connectionId, database, bucket, fileId });
+}
+
+export async function mongoServerVersion(connectionId: string, database: string, executionId?: string): Promise<string> {
+  return invoke("mongo_server_version", { connectionId, database, executionId });
+}
+
+export async function mongoAggregateDocuments(connectionId: string, database: string, collection: string, pipelineJson: string, maxRows?: number, executionId?: string): Promise<MongoDocumentResult> {
+  return invoke("mongo_aggregate_documents", { connectionId, database, collection, pipelineJson, maxRows, executionId });
+}
+
+export async function mongoCollectionStats(connectionId: string, database: string, collection: string, scale?: number, executionId?: string): Promise<MongoCollectionStatsResult> {
+  return invoke("mongo_collection_stats", { connectionId, database, collection, scale, executionId });
+}
+
+export async function mongoCreateIndex(connectionId: string, database: string, collection: string, keysJson: string, optionsJson?: string): Promise<{ name: string }> {
+  return invoke("mongo_create_index", { connectionId, database, collection, keysJson, optionsJson });
+}
+
+export async function mongoDropIndexes(connectionId: string, database: string, collection: string, indexesJson?: string, single = false): Promise<{ dropped_names: string[]; affected_rows: number }> {
+  return invoke("mongo_drop_indexes", { connectionId, database, collection, indexesJson, single });
+}
+
+export async function mongoInsertDocument(connectionId: string, database: string, collection: string, docJson: string): Promise<string> {
+  return documentInsertDocument(connectionId, database, collection, docJson);
+}
+
+export async function documentInsertDocument(connectionId: string, database: string, collection: string, docJson: string): Promise<string> {
+  return invoke("document_insert_document", { connectionId, database, collection, docJson });
+}
+
+export async function mongoInsertDocuments(connectionId: string, database: string, collection: string, docsJson: string): Promise<{ affected_rows: number }> {
+  const affectedRows = await invoke<number>("mongo_insert_documents", { connectionId, database, collection, docsJson });
+  return { affected_rows: affectedRows };
+}
+
+export async function mongoUpdateDocument(connectionId: string, database: string, collection: string, id: string, docJson: string, routing?: string): Promise<number> {
+  return documentUpdateDocument(connectionId, database, collection, id, docJson, routing);
+}
+
+export async function documentUpdateDocument(connectionId: string, database: string, collection: string, id: string, docJson: string, routing?: string): Promise<number> {
+  return invoke("document_update_document", { connectionId, database, collection, id, docJson, routing });
+}
+
+export async function mongoUpdateDocuments(connectionId: string, database: string, collection: string, filterJson: string, updateJson: string, many: boolean, optionsJson?: string): Promise<{ affected_rows: number }> {
+  const affectedRows = await invoke<number>("mongo_update_documents", {
+    connectionId,
+    database,
+    collection,
+    filterJson,
+    updateJson,
+    many,
+    optionsJson,
+  });
+  return { affected_rows: affectedRows };
+}
+
+export async function mongoDeleteDocument(connectionId: string, database: string, collection: string, id: string, routing?: string): Promise<number> {
+  return documentDeleteDocument(connectionId, database, collection, id, routing);
+}
+
+export async function documentDeleteDocument(connectionId: string, database: string, collection: string, id: string, routing?: string): Promise<number> {
+  return invoke("document_delete_document", { connectionId, database, collection, id, routing });
+}
+
+export async function mongoDeleteDocuments(connectionId: string, database: string, collection: string, filterJson: string, many: boolean): Promise<{ affected_rows: number }> {
+  const affectedRows = await invoke<number>("mongo_delete_documents", {
+    connectionId,
+    database,
+    collection,
+    filterJson,
+    many,
+  });
+  return { affected_rows: affectedRows };
+}
+
+// --- History ---
+export interface HistoryEntry {
+  id: string;
+  connection_id?: string;
+  connection_name: string;
+  database: string;
+  sql: string;
+  executed_at: string;
+  execution_time_ms: number;
+  success: boolean;
+  error?: string;
+  activity_kind?: "query" | "data_change" | "schema_change" | "import" | "transfer" | "redis_command";
+  operation?: string;
+  target?: string;
+  affected_rows?: number | null;
+  rollback_sql?: string | null;
+  details_json?: string | null;
+}
+
+export async function saveHistory(entry: HistoryEntry): Promise<void> {
+  return invoke("save_history", { entry });
+}
+
+export async function loadHistory(limit: number, offset: number, activityKind?: string): Promise<HistoryEntry[]> {
+  return invoke("load_history", { limit, offset, activityKind: activityKind ?? null });
+}
+
+export async function loadRedisHistory(limit = 100, offset = 0): Promise<HistoryEntry[]> {
+  return loadHistory(limit, offset, "redis_command");
+}
+
+export async function clearHistory(): Promise<void> {
+  return invoke("clear_history");
+}
+
+export async function clearRedisHistory(): Promise<void> {
+  const entries = await loadRedisHistory(1000, 0);
+  await Promise.all(entries.map((e) => deleteHistoryEntry(e.id)));
+}
+
+export async function deleteHistoryEntry(id: string): Promise<void> {
+  return invoke("delete_history_entry", { id });
+}
+
+// --- SQL File Execution ---
+export type SqlFileStatus = "started" | "running" | "statementDone" | "statementFailed" | "done" | "error" | "cancelled";
+
+export interface SqlFileRequest {
+  executionId: string;
+  connectionId: string;
+  database: string;
+  filePath: string;
+  continueOnError: boolean;
+}
+
+export interface SqlFilePreview {
+  fileName: string;
+  filePath: string;
+  sizeBytes: number;
+  preview: string;
+  canExecuteWithoutSelectedDatabase: boolean;
+}
+
+export interface SqlFileProgress {
+  executionId: string;
+  status: SqlFileStatus;
+  statementIndex: number;
+  successCount: number;
+  failureCount: number;
+  affectedRows: number;
+  elapsedMs: number;
+  statementSummary: string;
+  error?: string | null;
+}
+
+export async function previewSqlFile(filePath: string): Promise<SqlFilePreview> {
+  return invoke("preview_sql_file", { filePath });
+}
+
+export async function executeSqlFile(request: SqlFileRequest): Promise<void> {
+  return invoke("execute_sql_file", { request });
+}
+
+export async function cancelSqlFileExecution(executionId: string): Promise<boolean> {
+  return invoke("cancel_sql_file_execution", { executionId });
+}
+
+export async function listenSqlFileProgress(handler: (progress: SqlFileProgress) => void): Promise<UnlistenFn> {
+  return listen<SqlFileProgress>("sql-file-progress", (event) => handler(event.payload));
+}
+
+// --- Data Transfer ---
+export type TransferMode = "append" | "overwrite" | "upsert";
+export type TransferTableNameCase = "preserve" | "lower" | "upper";
+export type TransferOwnershipPolicy = "preserve" | "skip" | "reassignMissing";
+
+export interface TransferRequest {
+  transferId: string;
+  sourceConnectionId: string;
+  sourceDatabase: string;
+  sourceSchema: string;
+  targetConnectionId: string;
+  targetDatabase: string;
+  targetSchema: string;
+  tables: string[];
+  createTable: boolean;
+  mode: TransferMode;
+  targetTableNameCase: TransferTableNameCase;
+  ownershipPolicy?: TransferOwnershipPolicy;
+  batchSize: number;
+}
+
+export interface TransferOwnershipPreview {
+  missingOwners: string[];
+  targetOwner: string;
+}
+
+export interface TransferProgress {
+  transferId: string;
+  table: string;
+  tableIndex: number;
+  totalTables: number;
+  rowsTransferred: number;
+  totalRows: number | null;
+  status: "running" | "tableDone" | "done" | "error" | "cancelled";
+  error: string | null;
+  terminal: boolean;
+}
+
+export async function startTransfer(request: TransferRequest, onProgress: (progress: TransferProgress) => void): Promise<void> {
+  return new Promise((resolve, reject) => {
+    let unlisten: UnlistenFn | null = null;
+    void (async () => {
+      try {
+        unlisten = await listen<TransferProgress>("transfer-progress", (event) => {
+          if (event.payload.transferId !== request.transferId) return;
+          onProgress(event.payload);
+          if (isTerminalTransferProgress(event.payload)) {
+            unlisten?.();
+            resolve();
+          }
+        });
+
+        await invoke("start_transfer", { request });
+      } catch (e) {
+        unlisten?.();
+        reject(e);
+      }
+    })();
+  });
+}
+
+export async function cancelTransfer(transferId: string): Promise<void> {
+  return invoke("cancel_transfer", { transferId });
+}
+
+export async function previewTransferOwnership(request: TransferRequest): Promise<TransferOwnershipPreview> {
+  return invoke("preview_transfer_ownership", { request });
+}
+
+export interface SortTablesByFkOptions {
+  connectionId: string;
+  database: string;
+  schema: string;
+  tables: string[];
+  parentsFirst: boolean;
+}
+
+export async function sortTablesByFkDependency(options: SortTablesByFkOptions): Promise<string[]> {
+  return invoke("sort_tables_by_fk_dependency", {
+    connectionId: options.connectionId,
+    database: options.database,
+    schema: options.schema,
+    tables: options.tables,
+    parentsFirst: options.parentsFirst,
+  });
+}
+
+// --- Table File Import ---
+export type TableImportMode = "append" | "truncate";
+export type TableImportStatus = "running" | "done" | "error" | "cancelled";
+export type TableImportSourceFormat = "csv" | "tsv" | "delimited" | "json" | "excel";
+export type TableImportJsonShape = "auto" | "objects" | "arrays";
+
+export interface TableImportColumnMapping {
+  sourceColumn: string;
+  targetColumn: string;
+  targetDataType?: string | null;
+}
+
+export interface TableImportParseOptions {
+  delimiter?: string | null;
+  hasHeader?: boolean | null;
+  titleRow?: number | null;
+  dataStartRow?: number | null;
+  lastDataRow?: number | null;
+  trimValues?: boolean | null;
+  emptyStringAsNull?: boolean | null;
+  sheetName?: string | null;
+  sheetIndex?: number | null;
+  jsonShape?: TableImportJsonShape | null;
+}
+
+export interface TableImportPreviewRequest {
+  filePath: string;
+  sourceRef?: string | null;
+  sourceFormat?: TableImportSourceFormat | null;
+  parseOptions?: TableImportParseOptions | null;
+  previewLimit?: number | null;
+}
+
+export interface TableImportPreview {
+  fileName: string;
+  filePath: string;
+  sourceRef?: string | null;
+  fileType: string;
+  sizeBytes: number;
+  columns: string[];
+  rows: unknown[][];
+  totalRows: number;
+  sheets?: string[];
+}
+
+export interface TableImportRequest {
+  importId: string;
+  connectionId: string;
+  database: string;
+  schema: string;
+  table: string;
+  filePath: string;
+  sourceRef?: string | null;
+  sourceFormat?: TableImportSourceFormat | null;
+  parseOptions?: TableImportParseOptions | null;
+  mappings: TableImportColumnMapping[];
+  mode: TableImportMode;
+  createTable?: boolean;
+  batchSize: number;
+}
+
+export interface TableImportSummary {
+  importId: string;
+  rowsImported: number;
+  totalRows: number;
+}
+
+export interface TableImportProgress {
+  importId: string;
+  status: TableImportStatus;
+  rowsImported: number;
+  totalRows: number;
+  error?: string | null;
+}
+
+export async function previewTableImportFile(filePathOrRequest: string | File | TableImportPreviewRequest, options: Partial<TableImportPreviewRequest> = {}): Promise<TableImportPreview> {
+  if (typeof filePathOrRequest !== "string" && !("filePath" in filePathOrRequest)) {
+    throw new Error("previewTableImportFile in desktop mode requires a file path, not a File object");
+  }
+  const request: TableImportPreviewRequest = typeof filePathOrRequest === "string" ? { ...options, filePath: filePathOrRequest } : filePathOrRequest;
+  return invoke("preview_table_import_file", { request });
+}
+
+export async function importTableFile(request: TableImportRequest, onProgress: (progress: TableImportProgress) => void): Promise<TableImportSummary> {
+  const unlisten: UnlistenFn = await listen<TableImportProgress>("table-import-progress", (event) => {
+    if (event.payload.importId === request.importId) {
+      onProgress(event.payload);
+      if (event.payload.status === "done" || event.payload.status === "error" || event.payload.status === "cancelled") {
+        unlisten();
+      }
+    }
+  });
+  try {
+    return await invoke("import_table_file", { request });
+  } catch (e) {
+    unlisten();
+    throw e;
+  }
+}
+
+export async function cancelTableImport(importId: string): Promise<boolean> {
+  return invoke("cancel_table_import", { importId });
+}
+
+// --- Database Export ---
+export interface DatabaseExportRequest {
+  exportId: string;
+  connectionId: string;
+  database: string;
+  schema: string;
+  filePath: string;
+  selectedTables?: string[];
+  includeStructure: boolean;
+  includeData: boolean;
+  includeObjects: boolean;
+  dropTableIfExists?: boolean;
+  batchSize: number;
+}
+
+export interface ExportProgress {
+  exportId: string;
+  currentObject: string;
+  objectIndex: number;
+  totalObjects: number;
+  rowsExported: number;
+  totalRows: number | null;
+  status: "Running" | "Done" | "Error" | "Cancelled";
+  error: string | null;
+}
+
+// --- Table Export ---
+export type TableExportStatus = "Running" | "Writing" | "Done" | "Error" | "Cancelled";
+
+export interface TableExportRequest {
+  exportId: string;
+  connectionId: string;
+  database: string;
+  schema?: string;
+  tableName: string;
+  filePath: string;
+  format: "csv" | "xlsx" | "json" | "markdown" | "sql";
+  columns?: string[];
+  columnTypes?: Array<string | null | undefined>;
+  primaryKeys?: string[];
+  whereInput?: string;
+  orderBy?: string;
+  skipCount?: boolean;
+  batchSize?: number;
+  rowLimit?: number | null;
+}
+
+export interface TableCsvExportOptions {
+  filePath: string;
+  connectionId: string;
+  database: string;
+  schema?: string;
+  tableName: string;
+  columns?: string[];
+  pageSize?: number;
+  timeoutSecs?: number;
+}
+
+export interface TableExportProgress {
+  exportId: string;
+  tableName: string;
+  rowsExported: number;
+  totalRows: number | null;
+  status: TableExportStatus;
+  errorMessage?: string;
+}
+
+export interface QueryResultExportRequest {
+  exportId: string;
+  connectionId: string;
+  database: string;
+  schema?: string;
+  sql: string;
+  queryBaseSql: string;
+  databaseType: DatabaseType;
+  useAgentCursor: boolean;
+  filePath: string;
+  format: "csv" | "xlsx";
+  pageSize: number;
+  rowLimit?: number | null;
+  totalRows?: number | null;
+  timeoutSecs?: number;
+  keysetOptimizationEnabled: boolean;
+  clientSessionId?: string;
+  executionId?: string;
+}
+
+export async function startTableExport(request: TableExportRequest, onProgress: (progress: TableExportProgress) => void): Promise<TableExportProgress> {
+  let unlisten: UnlistenFn | undefined;
+  let settled = false;
+  let resolveTerminal: (progress: TableExportProgress) => void = () => {};
+  let rejectTerminal: (error: unknown) => void = () => {};
+
+  const terminalProgress = new Promise<TableExportProgress>((resolve, reject) => {
+    resolveTerminal = resolve;
+    rejectTerminal = reject;
+  });
+
+  const finish = (callback: () => void) => {
+    if (settled) return;
+    settled = true;
+    unlisten?.();
+    callback();
+  };
+
+  try {
+    unlisten = await listen<TableExportProgress>("table-export-progress", (event) => {
+      if (event.payload.exportId !== request.exportId) return;
+      onProgress(event.payload);
+      if (event.payload.status === "Done" || event.payload.status === "Error" || event.payload.status === "Cancelled") {
+        if (event.payload.status === "Error") {
+          finish(() => rejectTerminal(new Error(event.payload.errorMessage || "Export failed")));
+        } else {
+          finish(() => resolveTerminal(event.payload));
+        }
+      }
+    });
+    await invoke("start_table_export", { request });
+    return await terminalProgress;
+  } catch (error) {
+    if (!settled) {
+      settled = true;
+      unlisten?.();
+    }
+    throw error;
+  }
+}
+
+export async function cancelTableExport(exportId: string): Promise<void> {
+  return invoke("cancel_table_export", { exportId });
+}
+
+export async function startQueryResultExport(request: QueryResultExportRequest, onProgress: (progress: TableExportProgress) => void): Promise<TableExportProgress> {
+  let unlisten: UnlistenFn | undefined;
+  let settled = false;
+  let resolveTerminal: (progress: TableExportProgress) => void = () => {};
+  let rejectTerminal: (error: unknown) => void = () => {};
+
+  const terminalProgress = new Promise<TableExportProgress>((resolve, reject) => {
+    resolveTerminal = resolve;
+    rejectTerminal = reject;
+  });
+
+  const finish = (callback: () => void) => {
+    if (settled) return;
+    settled = true;
+    unlisten?.();
+    callback();
+  };
+
+  try {
+    unlisten = await listen<TableExportProgress>("query-result-export-progress", (event) => {
+      if (event.payload.exportId !== request.exportId) return;
+      onProgress(event.payload);
+      if (event.payload.status === "Done" || event.payload.status === "Error" || event.payload.status === "Cancelled") {
+        if (event.payload.status === "Error") {
+          finish(() => rejectTerminal(new Error(event.payload.errorMessage || "Export failed")));
+        } else {
+          finish(() => resolveTerminal(event.payload));
+        }
+      }
+    });
+    await invoke("start_query_result_export", { request });
+    return await terminalProgress;
+  } catch (error) {
+    if (!settled) {
+      settled = true;
+      unlisten?.();
+    }
+    throw error;
+  }
+}
+
+export async function cancelQueryResultExport(exportId: string, executionId?: string): Promise<void> {
+  return invoke("cancel_query_result_export", { exportId, executionId: executionId || null });
+}
+
+export async function exportDatabaseSql(request: DatabaseExportRequest, onProgress: (progress: ExportProgress) => void): Promise<void> {
+  const unlisten: UnlistenFn = await listen<ExportProgress>("database-export-progress", (event) => {
+    if (event.payload.exportId === request.exportId) {
+      onProgress(event.payload);
+      if (event.payload.status === "Done" || event.payload.status === "Error" || event.payload.status === "Cancelled") {
+        unlisten();
+      }
+    }
+  });
+  try {
+    await invoke("export_database_sql", { request });
+  } catch (e) {
+    unlisten();
+    throw e;
+  }
+}
+
+export async function cancelDatabaseExport(exportId: string): Promise<void> {
+  await invoke("cancel_database_export", { exportId });
+}
+
+export async function exportQueryResultCsv(filePath: string, columns: string[], rows: readonly (readonly XlsxCellValue[])[]): Promise<void> {
+  return invoke("export_query_result_csv", {
+    request: {
+      filePath,
+      columns,
+      rows,
+    },
+  });
+}
+
+export async function exportTableDataCsv(options: TableCsvExportOptions): Promise<number> {
+  return invoke("export_table_data_csv", { request: options });
+}
+
+export async function exportQueryResultXlsx(filePath: string, sheetName: string | undefined, columns: string[], columnTypes: string[], rows: readonly (readonly XlsxCellValue[])[]): Promise<void> {
+  return invoke("export_query_result_xlsx", {
+    request: {
+      filePath,
+      sheetName,
+      columns,
+      columnTypes,
+      rows,
+    },
+  });
+}
+
+export async function exportQueryResultsXlsx(filePath: string, worksheets: readonly { sheetName?: string; columns: string[]; columnTypes?: string[]; rows: readonly (readonly XlsxCellValue[])[] }[]): Promise<void> {
+  return invoke("export_query_results_xlsx", {
+    request: {
+      filePath,
+      worksheets,
+    },
+  });
+}
+
+export async function exportQueryResultJson(filePath: string, columns: string[], rows: readonly (readonly XlsxCellValue[])[]): Promise<void> {
+  return invoke("export_query_result_json", {
+    request: {
+      filePath,
+      columns,
+      rows,
+    },
+  });
+}
+
+export async function exportQueryResultMarkdown(filePath: string, columns: string[], rows: readonly (readonly XlsxCellValue[])[]): Promise<void> {
+  return invoke("export_query_result_markdown", {
+    request: {
+      filePath,
+      columns,
+      rows,
+    },
+  });
+}
+
+export * from "@/lib/backend/mq-tauri";
+export * from "@/lib/backend/nacos-tauri";
diff --git a/apps/desktop/src/lib/backend/tauriRuntime.ts b/apps/desktop/src/lib/backend/tauriRuntime.ts
new file mode 100644
index 0000000..21bccc0
--- /dev/null
+++ b/apps/desktop/src/lib/backend/tauriRuntime.ts
@@ -0,0 +1,3 @@
+export function isTauriRuntime(globalObject: Record<string, unknown> = globalThis as Record<string, unknown>): boolean {
+  return Boolean(globalObject.__TAURI_INTERNALS__ || globalObject.__TAURI__);
+}
diff --git a/apps/desktop/src/lib/backend/transferProgress.ts b/apps/desktop/src/lib/backend/transferProgress.ts
new file mode 100644
index 0000000..a190fcf
--- /dev/null
+++ b/apps/desktop/src/lib/backend/transferProgress.ts
@@ -0,0 +1,8 @@
+type TransferProgressTerminalState = {
+  terminal?: boolean;
+  status: "running" | "tableDone" | "done" | "error" | "cancelled";
+};
+
+export function isTerminalTransferProgress(progress: TransferProgressTerminalState): boolean {
+  return progress.terminal === true || progress.status === "done" || progress.status === "cancelled";
+}
diff --git a/apps/desktop/src/lib/common/__tests__/jsonTree.spec.ts b/apps/desktop/src/lib/common/__tests__/jsonTree.spec.ts
new file mode 100644
index 0000000..18d898c
--- /dev/null
+++ b/apps/desktop/src/lib/common/__tests__/jsonTree.spec.ts
@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { appendJsonPointer, createJsonTreeRoot, getJsonTreeChildren, getVisibleJsonTreeNodes, isJsonTreeContainer, isJsonTreeInitiallyExpanded } from "../jsonTree";
+import { parseJsonPreservingLargeNumbers } from "../safeJsonFormat";
+
+describe("jsonTree", () => {
+  it("uses RFC 6901 paths for object keys and array positions", () => {
+    const root = createJsonTreeRoot({ "a/b~c": ["value"] });
+    const objectChild = getJsonTreeChildren(root)[0];
+    const arrayChild = getJsonTreeChildren(objectChild)[0];
+
+    expect(root.path).toBe("");
+    expect(objectChild.path).toBe("/a~1b~0c");
+    expect(arrayChild.path).toBe("/a~1b~0c/0");
+    expect(appendJsonPointer("/parent", "a/b~c")).toBe("/parent/a~1b~0c");
+  });
+
+  it("keeps lossless JSON numbers as scalar nodes", () => {
+    const value = parseJsonPreservingLargeNumbers('{"id":518400931654815740}') as Record<string, unknown>;
+    const child = getJsonTreeChildren(createJsonTreeRoot(value))[0];
+
+    expect(isJsonTreeContainer(child.value)).toBe(false);
+  });
+
+  it("treats initial depth as expanded container levels from the root", () => {
+    expect(isJsonTreeInitiallyExpanded(0, 2)).toBe(true);
+    expect(isJsonTreeInitiallyExpanded(1, 2)).toBe(true);
+    expect(isJsonTreeInitiallyExpanded(2, 2)).toBe(false);
+    expect(isJsonTreeInitiallyExpanded(99, Number.POSITIVE_INFINITY)).toBe(true);
+  });
+
+  it("flattens expanded branches iteratively for virtual rendering", () => {
+    const root = createJsonTreeRoot({ first: { nested: true }, second: ["kept"] });
+    const nodes = getVisibleJsonTreeNodes(root, (node) => node.path !== "/first");
+
+    expect(nodes.map((node) => node.path)).toEqual(["", "/first", "/second", "/second/0"]);
+  });
+
+  it("handles deeply nested expanded JSON without recursive traversal", () => {
+    let value: unknown = true;
+    for (let depth = 0; depth < 2_000; depth += 1) value = { child: value };
+
+    const nodes = getVisibleJsonTreeNodes(createJsonTreeRoot(value), () => true);
+
+    expect(nodes).toHaveLength(2_001);
+  });
+});
diff --git a/apps/desktop/src/lib/common/__tests__/safeJsonFormat.spec.ts b/apps/desktop/src/lib/common/__tests__/safeJsonFormat.spec.ts
new file mode 100644
index 0000000..bbe77f5
--- /dev/null
+++ b/apps/desktop/src/lib/common/__tests__/safeJsonFormat.spec.ts
@@ -0,0 +1,88 @@
+import { describe, it, expect } from "vitest";
+import { isLosslessJsonNumber, parseJsonPreservingLargeNumbers, safeJsonFormat } from "../safeJsonFormat";
+
+describe("safeJsonFormat", () => {
+  it("preserves large integers exceeding MAX_SAFE_INTEGER", () => {
+    const input = '{"id":87712409002717401}';
+    const result = safeJsonFormat(input, 2);
+    expect(result).toBe('{\n  "id": 87712409002717401\n}');
+  });
+
+  it("preserves negative large integers exceeding MIN_SAFE_INTEGER", () => {
+    const input = '{"value":-87712409002717401}';
+    const result = safeJsonFormat(input, 2);
+    expect(result).toBe('{\n  "value": -87712409002717401\n}');
+  });
+
+  it("preserves multiple large integers in the same JSON", () => {
+    const input = '{"a":87712409002717401,"b":9007199254740992}';
+    const result = safeJsonFormat(input, 2);
+    expect(result).toBe('{\n  "a": 87712409002717401,\n  "b": 9007199254740992\n}');
+  });
+
+  it("does not modify integers within MAX_SAFE_INTEGER", () => {
+    const input = '{"id":12345}';
+    const result = safeJsonFormat(input, 2);
+    expect(result).toBe('{\n  "id": 12345\n}');
+  });
+
+  it("does not modify integers exactly at MAX_SAFE_INTEGER", () => {
+    const input = `{"id":${Number.MAX_SAFE_INTEGER}}`;
+    const result = safeJsonFormat(input, 2);
+    expect(result).toBe(`{\n  "id": ${Number.MAX_SAFE_INTEGER}\n}`);
+  });
+
+  it("preserves floating point numbers with large integer parts", () => {
+    const input = '{"value":87712409002717401.5}';
+    const result = safeJsonFormat(input, 2);
+    expect(result).toBe('{\n  "value": 87712409002717401.5\n}');
+  });
+
+  it("compacts JSON without indent", () => {
+    const input = '{\n  "id":  87712409002717401\n}';
+    const result = safeJsonFormat(input);
+    expect(result).toBe('{"id":87712409002717401}');
+  });
+
+  it("preserves large integers in nested JSON", () => {
+    const input = '{"data":{"id":87712409002717401}}';
+    const result = safeJsonFormat(input, 2);
+    expect(result).toBe('{\n  "data": {\n    "id": 87712409002717401\n  }\n}');
+  });
+
+  it("preserves large integers in arrays", () => {
+    const input = '{"ids":[87712409002717401,87712409002717402]}';
+    const result = safeJsonFormat(input, 2);
+    expect(result).toBe('{\n  "ids": [\n    87712409002717401,\n    87712409002717402\n  ]\n}');
+  });
+
+  it("handles string values that look like numbers", () => {
+    const input = '{"id":"87712409002717401"}';
+    const result = safeJsonFormat(input, 2);
+    expect(result).toBe('{\n  "id": "87712409002717401"\n}');
+  });
+
+  it("does not replace large digit sequences inside strings", () => {
+    const input = '{"text":"value 87712409002717401, unchanged"}';
+    expect(safeJsonFormat(input, 2)).toBe('{\n  "text": "value 87712409002717401, unchanged"\n}');
+  });
+
+  it("parses large integers as lossless numeric values", () => {
+    const parsed = parseJsonPreservingLargeNumbers('{"companyId":518400931654815740,"safe":42}') as Record<string, unknown>;
+    expect(isLosslessJsonNumber(parsed.companyId)).toBe(true);
+    expect(isLosslessJsonNumber(parsed.companyId) ? parsed.companyId.raw : null).toBe("518400931654815740");
+    expect(parsed.safe).toBe(42);
+  });
+
+  it("preserves fractional and exponent literals that Number would round or overflow", () => {
+    const input = '{"fraction":0.123456789012345678901234,"scientific":1.234567890123456789e20,"overflow":1e999}';
+    const parsed = parseJsonPreservingLargeNumbers(input) as Record<string, unknown>;
+
+    expect(isLosslessJsonNumber(parsed.fraction) ? parsed.fraction.raw : null).toBe("0.123456789012345678901234");
+    expect(isLosslessJsonNumber(parsed.scientific) ? parsed.scientific.raw : null).toBe("1.234567890123456789e20");
+    expect(isLosslessJsonNumber(parsed.overflow) ? parsed.overflow.raw : null).toBe("1e999");
+    expect(safeJsonFormat(input, 2)).toContain("0.123456789012345678901234");
+    expect(safeJsonFormat(input, 2)).toContain("1.234567890123456789e20");
+    expect(safeJsonFormat(input, 2)).toContain("1e999");
+  });
+});
diff --git a/apps/desktop/src/lib/common/clipboard.ts b/apps/desktop/src/lib/common/clipboard.ts
new file mode 100644
index 0000000..f4ba38b
--- /dev/null
+++ b/apps/desktop/src/lib/common/clipboard.ts
@@ -0,0 +1,155 @@
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+
+interface ClipboardApi {
+  readText?: () => Promise<string> | string;
+  writeText?: (text: string) => Promise<void> | void;
+}
+
+interface ClipboardNavigator {
+  clipboard?: ClipboardApi;
+}
+
+interface ClipboardTextarea {
+  value: string;
+  style: {
+    position?: string;
+    top?: string;
+    left?: string;
+    opacity?: string;
+  };
+  setAttribute(name: string, value: string): void;
+  focus?(): void;
+  select(): void;
+  setSelectionRange?(start: number, end: number): void;
+}
+
+interface ClipboardDocument {
+  body?: {
+    appendChild(node: unknown): unknown;
+    removeChild(node: unknown): unknown;
+  };
+  createElement(tagName: "textarea"): ClipboardTextarea;
+  execCommand?(command: string): boolean;
+}
+
+export interface ClipboardEnvironment {
+  navigator?: ClipboardNavigator;
+  document?: ClipboardDocument;
+}
+
+export interface ClipboardShortcutEvent {
+  key: string;
+  metaKey?: boolean;
+  ctrlKey?: boolean;
+  altKey?: boolean;
+  shiftKey?: boolean;
+  target?: EventTarget | null;
+}
+
+interface SelectionLike {
+  anchorNode: Node | null;
+  focusNode: Node | null;
+  isCollapsed: boolean;
+}
+
+interface NativeClipboardSelectionEnvironment {
+  getSelection?: () => SelectionLike | null;
+}
+
+const EDITABLE_CLIPBOARD_TARGET_SELECTOR = "input, textarea, [contenteditable='true'], [role='textbox']";
+const NATIVE_CLIPBOARD_REGION_SELECTOR = "[data-native-clipboard]";
+
+function closestElement(target: unknown, selector: string): unknown {
+  return (target as { closest?: (selector: string) => unknown } | null)?.closest?.(selector) ?? null;
+}
+
+function selectionNodeElement(node: Node | null): Element | null {
+  if (!node) return null;
+  if (typeof Element !== "undefined" && node instanceof Element) return node;
+  return (node as { parentElement?: Element | null }).parentElement ?? null;
+}
+
+export function isPlainClipboardShortcut(event: ClipboardShortcutEvent, key: string): boolean {
+  return !!(event.metaKey || event.ctrlKey) && !event.altKey && !event.shiftKey && event.key.toLowerCase() === key;
+}
+
+export function hasNativeClipboardSelection(env: NativeClipboardSelectionEnvironment = globalThis as unknown as NativeClipboardSelectionEnvironment): boolean {
+  const selection = env.getSelection?.();
+  if (!selection || selection.isCollapsed) return false;
+  const anchorRegion = selectionNodeElement(selection.anchorNode)?.closest(NATIVE_CLIPBOARD_REGION_SELECTOR);
+  const focusRegion = selectionNodeElement(selection.focusNode)?.closest(NATIVE_CLIPBOARD_REGION_SELECTOR);
+  return !!anchorRegion && anchorRegion === focusRegion;
+}
+
+export function eventTargetAllowsNativeClipboard(event: ClipboardShortcutEvent, env: NativeClipboardSelectionEnvironment = globalThis as unknown as NativeClipboardSelectionEnvironment): boolean {
+  if (closestElement(event.target, EDITABLE_CLIPBOARD_TARGET_SELECTOR)) return true;
+  return isPlainClipboardShortcut(event, "c") && hasNativeClipboardSelection(env);
+}
+
+export function eventTargetAllowsAppClipboardShortcut(event: ClipboardShortcutEvent, key = "v"): boolean {
+  if (!isPlainClipboardShortcut(event, key)) return false;
+  return !closestElement(event.target, EDITABLE_CLIPBOARD_TARGET_SELECTOR);
+}
+
+export async function readTextFromClipboard(env: ClipboardEnvironment = globalThis as unknown as ClipboardEnvironment): Promise<string> {
+  if (isTauriRuntime(env as unknown as Record<string, unknown>)) {
+    try {
+      const { readText } = await import("@tauri-apps/plugin-clipboard-manager");
+      return await readText();
+    } catch {
+      // Fall through to Web Clipboard when the native plugin is unavailable.
+    }
+  }
+
+  if (env.navigator?.clipboard?.readText) {
+    return await env.navigator.clipboard.readText();
+  }
+
+  throw new Error("Clipboard API is not available");
+}
+
+export async function copyToClipboard(text: string, env: ClipboardEnvironment = globalThis as unknown as ClipboardEnvironment): Promise<void> {
+  if (isTauriRuntime(env as unknown as Record<string, unknown>)) {
+    try {
+      const { writeText } = await import("@tauri-apps/plugin-clipboard-manager");
+      await writeText(text);
+      return;
+    } catch {
+      // Fall through to Web Clipboard / legacy copy when the native plugin is unavailable.
+    }
+  }
+
+  try {
+    if (env.navigator?.clipboard?.writeText) {
+      await env.navigator.clipboard.writeText(text);
+      return;
+    }
+  } catch {
+    // Fall through to the legacy copy path for non-secure web contexts.
+  }
+
+  const document = env.document;
+  if (!document?.body || !document.execCommand) {
+    throw new Error("Clipboard API is not available");
+  }
+
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.setAttribute("readonly", "");
+  textarea.style.position = "fixed";
+  textarea.style.top = "0";
+  textarea.style.left = "-9999px";
+  textarea.style.opacity = "0";
+
+  document.body.appendChild(textarea);
+  try {
+    textarea.focus?.();
+    textarea.select();
+    textarea.setSelectionRange?.(0, text.length);
+    if (!document.execCommand("copy")) {
+      throw new Error("Clipboard copy failed");
+    }
+  } finally {
+    document.body.removeChild(textarea);
+  }
+}
diff --git a/apps/desktop/src/lib/common/color.ts b/apps/desktop/src/lib/common/color.ts
new file mode 100644
index 0000000..498d1ba
--- /dev/null
+++ b/apps/desktop/src/lib/common/color.ts
@@ -0,0 +1,30 @@
+export function hexToRgba(color: string | undefined, alpha: number): string | undefined {
+  if (!color) return undefined;
+  const trimmed = color.trim();
+
+  // Already rgba/rgb: replace or add alpha, then return
+  const rgbaMatch = trimmed.match(/^rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([\d.]+)\s*\)$/i);
+  if (rgbaMatch) {
+    return `rgba(${rgbaMatch[1]}, ${rgbaMatch[2]}, ${rgbaMatch[3]}, ${alpha})`;
+  }
+  const rgbMatch = trimmed.match(/^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i);
+  if (rgbMatch) {
+    return `rgba(${rgbMatch[1]}, ${rgbMatch[2]}, ${rgbMatch[3]}, ${alpha})`;
+  }
+
+  const hex = trimmed.replace(/^#/, "");
+  const normalized =
+    hex.length === 3
+      ? hex
+          .split("")
+          .map((c) => c + c)
+          .join("")
+      : hex;
+  if (!/^[0-9a-fA-F]{6}$/.test(normalized)) return undefined;
+
+  const value = Number.parseInt(normalized, 16);
+  const r = (value >> 16) & 255;
+  const g = (value >> 8) & 255;
+  const b = value & 255;
+  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
diff --git a/apps/desktop/src/lib/common/elapsedTime.ts b/apps/desktop/src/lib/common/elapsedTime.ts
new file mode 100644
index 0000000..e814a7b
--- /dev/null
+++ b/apps/desktop/src/lib/common/elapsedTime.ts
@@ -0,0 +1,3 @@
+export function formatElapsedSeconds(ms: number): string {
+  return (Math.max(0, Number.isFinite(ms) ? ms : 0) / 1000).toFixed(2);
+}
diff --git a/apps/desktop/src/lib/common/jsonCopyValue.ts b/apps/desktop/src/lib/common/jsonCopyValue.ts
new file mode 100644
index 0000000..328a729
--- /dev/null
+++ b/apps/desktop/src/lib/common/jsonCopyValue.ts
@@ -0,0 +1,30 @@
+export function expandNestedJsonStringsForCopy(value: unknown): unknown {
+  if (typeof value === "string") {
+    return parseNestedJsonString(value) ?? value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(expandNestedJsonStringsForCopy);
+  }
+
+  if (isPlainObject(value)) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, expandNestedJsonStringsForCopy(item)]));
+  }
+
+  return value;
+}
+
+function parseNestedJsonString(value: string): unknown | undefined {
+  const trimmed = value.trim();
+  if (!trimmed || (trimmed[0] !== "{" && trimmed[0] !== "[")) return undefined;
+
+  try {
+    return expandNestedJsonStringsForCopy(JSON.parse(trimmed));
+  } catch {
+    return undefined;
+  }
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
diff --git a/apps/desktop/src/lib/common/jsonTree.ts b/apps/desktop/src/lib/common/jsonTree.ts
new file mode 100644
index 0000000..62792d3
--- /dev/null
+++ b/apps/desktop/src/lib/common/jsonTree.ts
@@ -0,0 +1,111 @@
+import { isLosslessJsonNumber } from "./safeJsonFormat";
+
+export type JsonTreeContainerKind = "array" | "object";
+export type JsonTreeParentKind = JsonTreeContainerKind | "root";
+
+export interface JsonTreeNode {
+  key: string;
+  label: string;
+  value: unknown;
+  /** RFC 6901 JSON Pointer. The root value is represented by an empty string. */
+  path: string;
+  /** Zero-based structural depth; the root value is at depth zero. */
+  depth: number;
+  parentKind: JsonTreeParentKind;
+}
+
+export type JsonTreeContainer = Record<string, unknown> | unknown[];
+
+export function createJsonTreeRoot(value: unknown): JsonTreeNode {
+  return {
+    key: "$",
+    label: "$",
+    value,
+    path: "",
+    depth: 0,
+    parentKind: "root",
+  };
+}
+
+export function isJsonTreeContainer(value: unknown): value is JsonTreeContainer {
+  // LosslessJsonNumber is an object wrapper, but represents a scalar JSON number.
+  return value !== null && typeof value === "object" && !isLosslessJsonNumber(value);
+}
+
+export function jsonTreeContainerKind(value: JsonTreeContainer): JsonTreeContainerKind {
+  return Array.isArray(value) ? "array" : "object";
+}
+
+export function jsonTreeContainerSummary(value: JsonTreeContainer, includeObjectLength = true): string {
+  if (Array.isArray(value)) return `Array(${value.length})`;
+  return includeObjectLength ? `Object(${Object.keys(value).length})` : "Object";
+}
+
+/** Escape a reference token according to RFC 6901. */
+export function escapeJsonPointerSegment(segment: string): string {
+  return segment.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+
+export function appendJsonPointer(path: string, segment: string | number): string {
+  return `${path}/${escapeJsonPointerSegment(String(segment))}`;
+}
+
+/**
+ * Create child nodes only for an already-expanded parent. Callers should not
+ * invoke this while a container is collapsed so large JSON payloads stay lazy.
+ */
+export function getJsonTreeChildren(node: JsonTreeNode): JsonTreeNode[] {
+  if (!isJsonTreeContainer(node.value)) return [];
+
+  if (Array.isArray(node.value)) {
+    return node.value.map((value, index) => ({
+      key: String(index),
+      label: String(index),
+      value,
+      path: appendJsonPointer(node.path, index),
+      depth: node.depth + 1,
+      parentKind: "array",
+    }));
+  }
+
+  return Object.entries(node.value).map(([key, value]) => ({
+    key,
+    label: key,
+    value,
+    path: appendJsonPointer(node.path, key),
+    depth: node.depth + 1,
+    parentKind: "object",
+  }));
+}
+
+/**
+ * Flatten the currently expanded tree with an iterative traversal. This lets
+ * virtual renderers keep every node logically expanded without recursive DOM
+ * creation or deep-call-stack failures.
+ */
+export function getVisibleJsonTreeNodes(root: JsonTreeNode, isExpanded: (node: JsonTreeNode) => boolean): JsonTreeNode[] {
+  const nodes: JsonTreeNode[] = [];
+  const pending = [root];
+
+  while (pending.length > 0) {
+    const node = pending.pop();
+    if (!node) continue;
+    nodes.push(node);
+
+    if (!isJsonTreeContainer(node.value) || !isExpanded(node)) continue;
+    const children = getJsonTreeChildren(node);
+    for (let index = children.length - 1; index >= 0; index -= 1) pending.push(children[index]);
+  }
+
+  return nodes;
+}
+
+/**
+ * `initialExpandedDepth` counts container levels from the root. For example,
+ * a value of 2 expands the root and its direct container children.
+ */
+export function isJsonTreeInitiallyExpanded(depth: number, initialExpandedDepth: number): boolean {
+  if (initialExpandedDepth === Number.POSITIVE_INFINITY) return true;
+  if (!Number.isFinite(initialExpandedDepth)) return false;
+  return depth < Math.max(0, Math.floor(initialExpandedDepth));
+}
diff --git a/apps/desktop/src/lib/common/optionHelpPanelOffset.ts b/apps/desktop/src/lib/common/optionHelpPanelOffset.ts
new file mode 100644
index 0000000..cfa1c6b
--- /dev/null
+++ b/apps/desktop/src/lib/common/optionHelpPanelOffset.ts
@@ -0,0 +1,13 @@
+export interface OptionHelpPanelOffsetInput {
+  activeItemTop: number;
+  listCardHeight: number;
+  panelHeight: number;
+}
+
+/** Aligns a help card to its active row without allowing it past the list card. */
+export function optionHelpPanelOffsetTop({ activeItemTop, listCardHeight, panelHeight }: OptionHelpPanelOffsetInput): number {
+  if (![activeItemTop, listCardHeight, panelHeight].every(Number.isFinite)) return 0;
+  const desiredTop = Math.max(0, activeItemTop);
+  const maxTop = Math.max(0, listCardHeight - Math.max(0, panelHeight));
+  return Math.min(desiredTop, maxTop);
+}
diff --git a/apps/desktop/src/lib/common/safeJsonFormat.ts b/apps/desktop/src/lib/common/safeJsonFormat.ts
new file mode 100644
index 0000000..7721d79
--- /dev/null
+++ b/apps/desktop/src/lib/common/safeJsonFormat.ts
@@ -0,0 +1,122 @@
+const LOSSLESS_JSON_NUMBER = Symbol("DBX lossless JSON number");
+
+export interface LosslessJsonNumber {
+  readonly [LOSSLESS_JSON_NUMBER]: true;
+  readonly raw: string;
+}
+
+interface ProtectedJsonNumbers {
+  text: string;
+  numbers: Map<string, string>;
+}
+
+const MAX_SAFE_INTEGER_TEXT = String(Number.MAX_SAFE_INTEGER);
+
+export function isLosslessJsonNumber(value: unknown): value is LosslessJsonNumber {
+  return typeof value === "object" && value !== null && (value as Partial<LosslessJsonNumber>)[LOSSLESS_JSON_NUMBER] === true && typeof (value as Partial<LosslessJsonNumber>).raw === "string";
+}
+
+/**
+ * Parses JSON while retaining numeric literals that JavaScript cannot safely
+ * represent exactly. Callers can render these values without adding quotes.
+ */
+export function parseJsonPreservingLargeNumbers(text: string): unknown {
+  const protectedJson = protectLargeJsonNumbers(text);
+  const parsed = JSON.parse(protectedJson.text);
+  return restoreLosslessNumbers(parsed, protectedJson.numbers);
+}
+
+/**
+ * Parse and re-stringify JSON while preserving numeric literals whose integer
+ * parts exceed Number.MAX_SAFE_INTEGER (2^53 - 1), plus decimal and exponent
+ * forms that JavaScript may round or turn into Infinity.
+ */
+export function safeJsonFormat(text: string, indent?: number): string {
+  const protectedJson = protectLargeJsonNumbers(text);
+  const parsed = JSON.parse(protectedJson.text);
+  let result = JSON.stringify(parsed, null, indent ?? undefined);
+
+  for (const [placeholder, raw] of protectedJson.numbers) {
+    result = result.replaceAll(JSON.stringify(placeholder), raw);
+  }
+
+  return result;
+}
+
+function protectLargeJsonNumbers(text: string): ProtectedJsonNumbers {
+  let placeholderPrefix = "__DBX_LOSSLESS_NUMBER_";
+  while (text.includes(placeholderPrefix)) placeholderPrefix += "_";
+
+  const numbers = new Map<string, string>();
+  let output = "";
+  let index = 0;
+
+  while (index < text.length) {
+    const character = text[index];
+    if (character === '"') {
+      const stringEnd = findJsonStringEnd(text, index);
+      output += text.slice(index, stringEnd);
+      index = stringEnd;
+      continue;
+    }
+
+    const numberMatch = text.slice(index).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/);
+    if (numberMatch) {
+      const raw = numberMatch[0];
+      if (shouldPreserveJsonNumber(raw)) {
+        // A quoted placeholder lets the native parser validate the rest of the JSON.
+        const placeholder = `${placeholderPrefix}${numbers.size}__`;
+        numbers.set(placeholder, raw);
+        output += JSON.stringify(placeholder);
+      } else {
+        output += raw;
+      }
+      index += raw.length;
+      continue;
+    }
+
+    output += character;
+    index += 1;
+  }
+
+  return { text: output, numbers };
+}
+
+function findJsonStringEnd(text: string, start: number): number {
+  let escaped = false;
+  for (let index = start + 1; index < text.length; index += 1) {
+    const character = text[index];
+    if (escaped) {
+      escaped = false;
+    } else if (character === "\\") {
+      escaped = true;
+    } else if (character === '"') {
+      return index + 1;
+    }
+  }
+  return text.length;
+}
+
+function shouldPreserveJsonNumber(raw: string): boolean {
+  // Keep fractional/exponent forms verbatim. Even when a particular value is
+  // representable today, parsing it through Number can change its precision or
+  // spelling before the JSON viewer renders it.
+  if (raw.includes(".") || raw.includes("e") || raw.includes("E") || raw === "-0") return true;
+
+  const unsigned = raw.startsWith("-") ? raw.slice(1) : raw;
+  const integerPart = unsigned.split(/[.eE]/, 1)[0];
+  const normalized = integerPart.replace(/^0+(?=\d)/, "");
+  return normalized.length > MAX_SAFE_INTEGER_TEXT.length || (normalized.length === MAX_SAFE_INTEGER_TEXT.length && normalized > MAX_SAFE_INTEGER_TEXT);
+}
+
+function restoreLosslessNumbers(value: unknown, numbers: Map<string, string>): unknown {
+  if (typeof value === "string") {
+    const raw = numbers.get(value);
+    return raw === undefined ? value : ({ [LOSSLESS_JSON_NUMBER]: true, raw } satisfies LosslessJsonNumber);
+  }
+  if (Array.isArray(value)) return value.map((item) => restoreLosslessNumbers(item, numbers));
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, restoreLosslessNumbers(item, numbers)]));
+  }
+  return value;
+}
diff --git a/apps/desktop/src/lib/common/searchPattern.ts b/apps/desktop/src/lib/common/searchPattern.ts
new file mode 100644
index 0000000..63f0e44
--- /dev/null
+++ b/apps/desktop/src/lib/common/searchPattern.ts
@@ -0,0 +1,15 @@
+export function parseSlashDelimitedRegexQuery(query: string): RegExp | null {
+  if (!query.startsWith("/") || query.length < 2) return null;
+  const lastSlash = query.lastIndexOf("/");
+  if (lastSlash <= 0) return null;
+
+  const source = query.slice(1, lastSlash);
+  const flags = query.slice(lastSlash + 1);
+  if (!/^[dgimsuvy]*$/.test(flags)) return null;
+
+  try {
+    return new RegExp(source, flags.includes("i") ? flags : `${flags}i`);
+  } catch {
+    return null;
+  }
+}
diff --git a/apps/desktop/src/lib/common/searchableSelectTooltip.ts b/apps/desktop/src/lib/common/searchableSelectTooltip.ts
new file mode 100644
index 0000000..cd6a232
--- /dev/null
+++ b/apps/desktop/src/lib/common/searchableSelectTooltip.ts
@@ -0,0 +1,19 @@
+export type SearchableSelectOptionTooltip = (option: string) => string | undefined;
+
+/** Keep the option list aligned with its trigger while help expands rightward. */
+export const SEARCHABLE_SELECT_HELP_PANEL_ALIGN = "start";
+
+/**
+ * Returns the option whose help panel is activated by keyboard navigation
+ * while focus remains in the searchable input. Empty-string options are valid.
+ */
+export function searchableSelectKeyboardTooltipOption(options: readonly string[], highlightIndex: number, optionTooltip?: SearchableSelectOptionTooltip): string | undefined {
+  const option = options[highlightIndex];
+  return option === undefined || !optionTooltip?.(option) ? undefined : option;
+}
+
+/** Returns the selected option's help, or the first available option's help. */
+export function searchableSelectSelectedOrFirstHelpOption(options: readonly string[], selectedOption: string, optionTooltip?: SearchableSelectOptionTooltip): string | undefined {
+  if (options.includes(selectedOption) && optionTooltip?.(selectedOption)) return selectedOption;
+  return options.find((option) => !!optionTooltip?.(option));
+}
diff --git a/apps/desktop/src/lib/common/shikiJsonHighlighter.ts b/apps/desktop/src/lib/common/shikiJsonHighlighter.ts
new file mode 100644
index 0000000..11420b2
--- /dev/null
+++ b/apps/desktop/src/lib/common/shikiJsonHighlighter.ts
@@ -0,0 +1,41 @@
+import type { AppThemeAppearance } from "@/lib/app/appTheme";
+
+export type JsonHighlighter = (content: string, appearance?: AppThemeAppearance) => string;
+
+interface ShikiJsonHighlighterOptions {
+  appearance: () => AppThemeAppearance;
+}
+
+const SHIKI_THEMES = {
+  dark: "github-dark",
+  light: "github-light",
+} as const;
+
+type ShikiHighlighter = Awaited<ReturnType<typeof import("shiki/core").createHighlighterCore>>;
+
+let highlighterPromise: Promise<ShikiHighlighter> | undefined;
+
+export async function createShikiJsonHighlighter(options: ShikiJsonHighlighterOptions): Promise<JsonHighlighter> {
+  const highlighter = await getShikiJsonHighlighter();
+  return (content, appearance = options.appearance()) =>
+    highlighter.codeToHtml(content, {
+      lang: "json",
+      structure: "inline",
+      theme: SHIKI_THEMES[appearance],
+    });
+}
+
+function getShikiJsonHighlighter(): Promise<ShikiHighlighter> {
+  highlighterPromise ??= loadShikiJsonHighlighter();
+  return highlighterPromise;
+}
+
+async function loadShikiJsonHighlighter(): Promise<ShikiHighlighter> {
+  const [{ createHighlighterCore }, { createJavaScriptRegexEngine }, githubDark, githubLight, json] = await Promise.all([import("shiki/core"), import("shiki/engine/javascript"), import("shiki/themes/github-dark.mjs"), import("shiki/themes/github-light.mjs"), import("shiki/langs/json.mjs")]);
+
+  return createHighlighterCore({
+    engine: createJavaScriptRegexEngine(),
+    langs: [json.default],
+    themes: [githubDark.default, githubLight.default],
+  });
+}
diff --git a/apps/desktop/src/lib/common/ttlFormat.ts b/apps/desktop/src/lib/common/ttlFormat.ts
new file mode 100644
index 0000000..1ddab93
--- /dev/null
+++ b/apps/desktop/src/lib/common/ttlFormat.ts
@@ -0,0 +1,26 @@
+/**
+ * Formats Redis TTL (seconds) as a compact string:
+ *   < 1 day  →  HH:mm:ss
+ *   >= 1 day →  {n}d HH:mm:ss  (day unit localized)
+ *
+ * Returns null for ttl === -1 (no expiry) or ttl <= 0.
+ */
+
+type TranslateFn = (key: string, options?: Record<string, unknown>) => string;
+
+export function formatTtl(ttl: number, t: TranslateFn): string | null {
+  if (ttl === -1) return null;
+  if (ttl <= 0) return null;
+
+  const days = Math.floor(ttl / 86_400);
+  const hours = Math.floor((ttl % 86_400) / 3_600);
+  const minutes = Math.floor((ttl % 3_600) / 60);
+  const seconds = ttl % 60;
+
+  const time = [String(hours).padStart(2, "0"), String(minutes).padStart(2, "0"), String(seconds).padStart(2, "0")].join(":");
+
+  if (days > 0) {
+    return `${t("redis.ttlDay", { count: days })} ${time}`;
+  }
+  return time;
+}
diff --git a/apps/desktop/src/lib/common/utils.ts b/apps/desktop/src/lib/common/utils.ts
new file mode 100644
index 0000000..80ca1a8
--- /dev/null
+++ b/apps/desktop/src/lib/common/utils.ts
@@ -0,0 +1,17 @@
+import type { ClassValue } from "clsx";
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+export function uuid(): string {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
+  });
+}
diff --git a/apps/desktop/src/lib/common/webPath.ts b/apps/desktop/src/lib/common/webPath.ts
new file mode 100644
index 0000000..24bf6b5
--- /dev/null
+++ b/apps/desktop/src/lib/common/webPath.ts
@@ -0,0 +1,39 @@
+function normalizeBasePath(value: string | undefined): string {
+  const trimmed = (value ?? "").trim();
+  if (!trimmed || trimmed === "." || trimmed === "./" || trimmed === "/") return "";
+  const withoutQuery = trimmed.split(/[?#]/, 1)[0] ?? "";
+  const withLeadingSlash = withoutQuery.startsWith("/") ? withoutQuery : `/${withoutQuery}`;
+  return withLeadingSlash.replace(/\/+$/, "");
+}
+
+function inferredRuntimeBasePath(pathname: string): string {
+  const normalized = pathname.replace(/\/+$/, "");
+  if (!normalized || normalized === "/login") return "";
+  if (normalized.endsWith("/login")) return normalized.slice(0, -"/login".length);
+  return normalized;
+}
+
+export function dbxWebBasePath(pathname = globalThis.location?.pathname ?? "", buildBase = import.meta.env.BASE_URL): string {
+  const configured = normalizeBasePath(buildBase);
+  if (configured) return configured;
+  return normalizeBasePath(inferredRuntimeBasePath(pathname));
+}
+
+export function webPath(path: string, basePath = dbxWebBasePath()): string {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const base = normalizeBasePath(basePath);
+  return `${base}${normalizedPath}` || "/";
+}
+
+export function apiUrl(path: string, basePath = dbxWebBasePath()): string {
+  const pathWithLeadingSlash = path.startsWith("/") ? path : `/${path}`;
+  const normalizedPath = pathWithLeadingSlash === "/api" || pathWithLeadingSlash.startsWith("/api/") || pathWithLeadingSlash.startsWith("/api?") ? pathWithLeadingSlash : `/api${pathWithLeadingSlash}`;
+  return webPath(normalizedPath, basePath);
+}
+
+type WebSocketLocation = Pick<Location, "protocol" | "host"> | undefined;
+
+export function apiWebSocketUrl(path: string, basePath = dbxWebBasePath(), currentLocation: WebSocketLocation = globalThis.location): string {
+  const protocol = currentLocation?.protocol === "https:" ? "wss:" : "ws:";
+  return `${protocol}//${currentLocation?.host ?? ""}${apiUrl(path, basePath)}`;
+}
diff --git a/apps/desktop/src/lib/connection/__tests__/connectionErrorHints.spec.ts b/apps/desktop/src/lib/connection/__tests__/connectionErrorHints.spec.ts
new file mode 100644
index 0000000..419ab77
--- /dev/null
+++ b/apps/desktop/src/lib/connection/__tests__/connectionErrorHints.spec.ts
@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import { appendConnectionErrorHints } from "@/lib/connection/connectionErrorHints";
+import type { ConnectionConfig } from "@/types/database";
+
+function mysqlConfig(urlParams: string | undefined): ConnectionConfig {
+  return {
+    id: "mysql-test",
+    name: "MySQL",
+    db_type: "mysql",
+    host: "127.0.0.1",
+    port: 3306,
+    username: "root",
+    password: "",
+    database: undefined,
+    url_params: urlParams,
+    ssl: false,
+  };
+}
+
+const t = (key: string) => (key === "connection.mysqlTlsConnectionFailureHint" ? "Set TLS Mode to Disabled." : key);
+
+describe("appendConnectionErrorHints", () => {
+  it("adds a MySQL TLS hint for non-disabled TLS failures", () => {
+    const message = appendConnectionErrorHints(mysqlConfig("ssl-mode=preferred"), "MySQL connection failed: TLS handshake failed", t);
+
+    expect(message).toContain("TLS handshake failed");
+    expect(message).toContain("Set TLS Mode to Disabled.");
+  });
+
+  it("adds the TLS hint for camel-case MySQL sslMode params", () => {
+    const message = appendConnectionErrorHints(mysqlConfig("sslMode=REQUIRED"), "MySQL connection failed: Driver error: `Client asked for SSL but server does not have this capability'", t);
+
+    expect(message).toContain("server does not have this capability");
+    expect(message).toContain("Set TLS Mode to Disabled.");
+  });
+
+  it("does not add the TLS hint when MySQL TLS is disabled", () => {
+    const message = appendConnectionErrorHints(mysqlConfig("ssl-mode=disabled"), "MySQL connection failed: TLS handshake failed", t);
+
+    expect(message).toBe("MySQL connection failed: TLS handshake failed");
+  });
+
+  it("does not add the TLS hint for non-TLS errors", () => {
+    const message = appendConnectionErrorHints(mysqlConfig("ssl-mode=preferred"), "Access denied for user root", t);
+
+    expect(message).toBe("Access denied for user root");
+  });
+});
diff --git a/apps/desktop/src/lib/connection/__tests__/connectionHealth.spec.ts b/apps/desktop/src/lib/connection/__tests__/connectionHealth.spec.ts
new file mode 100644
index 0000000..0395bb7
--- /dev/null
+++ b/apps/desktop/src/lib/connection/__tests__/connectionHealth.spec.ts
@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { shouldMarkDisconnected } from "@/lib/connection/connectionHealth";
+
+describe("connectionHealth", () => {
+  it("marks localized and JDBC communication errors as disconnected", () => {
+    expect(shouldMarkDisconnected("Agent RPC error (-1): dm.jdbc.driver.DMException: 网络通信异常")).toBe(true);
+    expect(shouldMarkDisconnected("Agent RPC error (-1): com.mysql.cj.jdbc.exceptions.CommunicationsException: Communications link failure")).toBe(true);
+    expect(shouldMarkDisconnected("Agent RPC error (-1): java.sql.SQLRecoverableException: IO 错误: Got minus one from a read call")).toBe(true);
+  });
+
+  it("does not mark ordinary SQL or authentication errors as disconnected", () => {
+    expect(shouldMarkDisconnected("syntax error at or near SELECT")).toBe(false);
+    expect(shouldMarkDisconnected("Access denied for user root")).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/connection/actionActivation.ts b/apps/desktop/src/lib/connection/actionActivation.ts
new file mode 100644
index 0000000..1664dd8
--- /dev/null
+++ b/apps/desktop/src/lib/connection/actionActivation.ts
@@ -0,0 +1,38 @@
+export const DEFAULT_REPEATED_ACTIVATION_WINDOW_MS = 500;
+
+export interface ActionActivationGuard {
+  lastActivatedAt?: number;
+  running?: boolean;
+}
+
+function nowMs(): number {
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return performance.now();
+  }
+  return Date.now();
+}
+
+export function shouldSuppressRepeatedActivation(guard: ActionActivationGuard, now = nowMs(), windowMs = DEFAULT_REPEATED_ACTIVATION_WINDOW_MS): boolean {
+  if (guard.lastActivatedAt !== undefined && now - guard.lastActivatedAt < windowMs) {
+    return true;
+  }
+  guard.lastActivatedAt = now;
+  return false;
+}
+
+export function suppressEvent(event: Event) {
+  event.preventDefault();
+  event.stopPropagation();
+  event.stopImmediatePropagation?.();
+}
+
+export function tryStartExclusiveActivation(guard: ActionActivationGuard): (() => void) | null {
+  if (guard.running) return null;
+  guard.running = true;
+  let finished = false;
+  return () => {
+    if (finished) return;
+    finished = true;
+    guard.running = false;
+  };
+}
diff --git a/apps/desktop/src/lib/connection/agentDriverInstallHint.ts b/apps/desktop/src/lib/connection/agentDriverInstallHint.ts
new file mode 100644
index 0000000..7318dfe
--- /dev/null
+++ b/apps/desktop/src/lib/connection/agentDriverInstallHint.ts
@@ -0,0 +1,35 @@
+import type { DatabaseType } from "@/types/database";
+import { supportsDriverManagement } from "@/lib/database/databaseCapabilities";
+
+export interface AgentDriverInstallState {
+  db_type: string;
+  installed: boolean;
+  update_available?: boolean;
+}
+
+export function agentDriverInstallKey(dbType: DatabaseType | undefined, driverProfile?: string): string | undefined {
+  if (dbType === "oracle") return "oracle";
+  if (dbType === "mongodb") return "mongodb";
+  if (dbType === "dameng") return "dameng";
+  if (dbType === "mq") return driverProfile === "kafka" ? "kafka" : undefined;
+  return driverProfile && driverProfile !== dbType ? driverProfile : dbType;
+}
+
+export function showAgentDriverInstallHint(dbType: DatabaseType | undefined, drivers: readonly AgentDriverInstallState[], driverProfile?: string): boolean {
+  if (!supportsDriverManagement(dbType)) return false;
+  const driverKey = agentDriverInstallKey(dbType, driverProfile);
+  if (!driverKey) return false;
+  return drivers.find((driver) => driver.db_type === driverKey)?.installed !== true;
+}
+
+export function hasAgentDriverUpdate(dbType: DatabaseType | undefined, drivers: readonly AgentDriverInstallState[], driverProfile?: string): boolean {
+  if (!supportsDriverManagement(dbType)) return false;
+  const driverKey = agentDriverInstallKey(dbType, driverProfile);
+  return drivers.find((driver) => driver.db_type === driverKey)?.update_available === true;
+}
+
+export function appendAgentDriverUpdateHint(message: string, hint: string): string {
+  if (!message.trim()) return hint;
+  if (message.includes(hint)) return message;
+  return `${message}\n\n${hint}`;
+}
diff --git a/apps/desktop/src/lib/connection/agentDriverUpdateBadge.ts b/apps/desktop/src/lib/connection/agentDriverUpdateBadge.ts
new file mode 100644
index 0000000..c04fc96
--- /dev/null
+++ b/apps/desktop/src/lib/connection/agentDriverUpdateBadge.ts
@@ -0,0 +1,15 @@
+export interface AgentDriverUpdateBadgeState {
+  update_available: boolean;
+}
+
+export function countAvailableAgentDriverUpdates(drivers: readonly AgentDriverUpdateBadgeState[]): number {
+  return drivers.filter((driver) => driver.update_available).length;
+}
+
+export interface JdbcPluginUpdateBadgeState {
+  update_available?: boolean | null;
+}
+
+export function countAvailableDriverUpdates(drivers: readonly AgentDriverUpdateBadgeState[], jdbcPlugin?: JdbcPluginUpdateBadgeState | null): number {
+  return countAvailableAgentDriverUpdates(drivers) + (jdbcPlugin?.update_available ? 1 : 0);
+}
diff --git a/apps/desktop/src/lib/connection/cloudflareD1.ts b/apps/desktop/src/lib/connection/cloudflareD1.ts
new file mode 100644
index 0000000..d8a1b57
--- /dev/null
+++ b/apps/desktop/src/lib/connection/cloudflareD1.ts
@@ -0,0 +1,23 @@
+import type { ConnectionConfig } from "@/types/database";
+
+type CloudflareD1Config = Pick<ConnectionConfig, "db_type" | "host" | "database" | "password">;
+type MutableCloudflareD1Config = CloudflareD1Config & Pick<ConnectionConfig, "port" | "username" | "ssl" | "url_params" | "transport_layers">;
+
+export function isCloudflareD1Connection(config: Pick<ConnectionConfig, "db_type">): boolean {
+  return config.db_type === "cloudflare-d1";
+}
+
+export function hasCloudflareD1Credentials(config: CloudflareD1Config): boolean {
+  return !!config.host.trim() && !!config.database?.trim() && !!config.password.trim();
+}
+
+export function normalizeCloudflareD1Connection(config: MutableCloudflareD1Config): void {
+  config.host = config.host.trim();
+  config.database = config.database?.trim() || undefined;
+  config.password = config.password.trim();
+  config.port = 443;
+  config.username = "";
+  config.ssl = true;
+  config.url_params = "";
+  config.transport_layers = [];
+}
diff --git a/apps/desktop/src/lib/connection/connectionAttemptTimeout.ts b/apps/desktop/src/lib/connection/connectionAttemptTimeout.ts
new file mode 100644
index 0000000..0b6f670
--- /dev/null
+++ b/apps/desktop/src/lib/connection/connectionAttemptTimeout.ts
@@ -0,0 +1,75 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+
+export const CONNECTION_ATTEMPT_TIMEOUT_BUFFER_MS = 2_000;
+export const MONGO_LEGACY_FALLBACK_TIMEOUT_BUFFER_MS = 30_000;
+export const AGENT_DRIVER_MIN_CONNECT_TIMEOUT_SECS = 30;
+export const ACCESS_AGENT_MIN_CONNECT_TIMEOUT_SECS = 30;
+const DEFAULT_CONNECT_TIMEOUT_SECS = 10;
+
+const DRIVER_STARTUP_FLOOR_TYPES = new Set<DatabaseType>([
+  "dameng",
+  "kingbase",
+  "highgo",
+  "vastbase",
+  "goldendb",
+  "yashandb",
+  "databricks",
+  "saphana",
+  "teradata",
+  "vertica",
+  "firebird",
+  "exasol",
+  "oceanbase-oracle",
+  "gbase",
+  "access",
+  "oracle",
+  "h2",
+  "snowflake",
+  "trino",
+  "prestosql",
+  "jdbc",
+  "hive",
+  "spark",
+  "db2",
+  "informix",
+  "neo4j",
+  "cassandra",
+  "bigquery",
+  "kylin",
+  "sundb",
+  "oscar",
+  "tdengine",
+  "xugu",
+  "iotdb",
+  "etcd",
+  "zookeeper",
+  "iris",
+]);
+
+function positiveSeconds(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+
+export function connectionAttemptTimeoutMs(config: Pick<ConnectionConfig, "connect_timeout_secs" | "transport_layers"> & Partial<Pick<ConnectionConfig, "db_type">>): number {
+  const baseTimeoutSecs = positiveSeconds(config.connect_timeout_secs, DEFAULT_CONNECT_TIMEOUT_SECS);
+  const agentMinTimeoutSecs = config.db_type === "access" ? ACCESS_AGENT_MIN_CONNECT_TIMEOUT_SECS : AGENT_DRIVER_MIN_CONNECT_TIMEOUT_SECS;
+  const timeouts = [DRIVER_STARTUP_FLOOR_TYPES.has(config.db_type as DatabaseType) ? Math.max(baseTimeoutSecs, agentMinTimeoutSecs) : baseTimeoutSecs];
+  for (const layer of config.transport_layers ?? []) {
+    if (layer.enabled === false) continue;
+    if (layer.type === "ssh" || layer.type === "http_tunnel") {
+      timeouts.push(positiveSeconds(layer.connect_timeout_secs, DEFAULT_CONNECT_TIMEOUT_SECS));
+    }
+  }
+  const fallbackBuffer = config.db_type === "mongodb" ? MONGO_LEGACY_FALLBACK_TIMEOUT_BUFFER_MS : 0;
+  return Math.ceil(Math.max(...timeouts) * 1000 + CONNECTION_ATTEMPT_TIMEOUT_BUFFER_MS + fallbackBuffer);
+}
+
+export function connectionAttemptTimeoutMessage(timeoutMs: number): string {
+  return `Connection attempt timed out after ${Math.ceil(timeoutMs / 1000)}s. Please check the network or VPN and try again.`;
+}
+
+export function connectionAttemptOriginalErrorMessage(timeoutMessage: string, originalMessage: string): string {
+  const message = originalMessage.trim();
+  if (!message || message === timeoutMessage) return timeoutMessage;
+  return `${timeoutMessage}\n\nOriginal database error returned after the UI timeout:\n${message}`;
+}
diff --git a/apps/desktop/src/lib/connection/connectionDeepLink.ts b/apps/desktop/src/lib/connection/connectionDeepLink.ts
new file mode 100644
index 0000000..4c28c61
--- /dev/null
+++ b/apps/desktop/src/lib/connection/connectionDeepLink.ts
@@ -0,0 +1,110 @@
+import type { DatabaseType } from "@/types/database";
+import { connectionProfileForScheme, parseConnectionUrl } from "@/lib/connection/connectionUrl";
+
+export interface ConnectionDeepLinkDraft {
+  name?: string;
+  dbType: DatabaseType;
+  driverProfile: string;
+  driverLabel: string;
+  host?: string;
+  port?: number;
+  username?: string;
+  password?: string;
+  database?: string;
+  urlParams?: string;
+  ssl?: boolean;
+  connectionString?: string;
+  oracleConnectionType?: "service_name" | "sid";
+  useMongoUrl?: boolean;
+  oneTime?: boolean;
+}
+
+const CONNECTION_DEEP_LINK_TARGET = "connection/new";
+
+function normalizePath(url: URL): string {
+  return [url.hostname, url.pathname.replace(/^\/+/, "")].filter(Boolean).join("/").replace(/\/+$/, "");
+}
+
+function optionalParam(params: URLSearchParams, ...keys: string[]): string | undefined {
+  for (const key of keys) {
+    const value = params.get(key)?.trim();
+    if (value) return value;
+  }
+  return undefined;
+}
+
+function optionalNumberParam(params: URLSearchParams, ...keys: string[]): number | undefined {
+  const value = optionalParam(params, ...keys);
+  if (!value) return undefined;
+  const numberValue = Number(value);
+  return Number.isFinite(numberValue) && numberValue > 0 ? numberValue : undefined;
+}
+
+function optionalBooleanParam(params: URLSearchParams, ...keys: string[]): boolean {
+  const value = optionalParam(params, ...keys)?.toLowerCase();
+  return value === "true" || value === "1" || value === "yes" || value === "on";
+}
+
+function draftFromConnectionUrl(value: string, preferredProfile?: string): ConnectionDeepLinkDraft {
+  const parsed = parseConnectionUrl(value, preferredProfile);
+  return {
+    name: parsed.name,
+    dbType: parsed.dbType,
+    driverProfile: parsed.driverProfile,
+    driverLabel: parsed.driverLabel,
+    host: parsed.host,
+    port: parsed.port,
+    username: parsed.username,
+    password: parsed.password,
+    database: parsed.database,
+    urlParams: parsed.urlParams,
+    ssl: parsed.ssl,
+    connectionString: parsed.connectionString,
+    oracleConnectionType: parsed.oracleConnectionType,
+    useMongoUrl: parsed.useMongoUrl,
+  };
+}
+
+export function parseConnectionDeepLink(value: string): ConnectionDeepLinkDraft | null {
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    return null;
+  }
+
+  if (url.protocol !== "dbx:") return null;
+  if (normalizePath(url) !== CONNECTION_DEEP_LINK_TARGET) return null;
+
+  const params = url.searchParams;
+  const preferredProfile = optionalParam(params, "type");
+  const rawConnectionUrl = optionalParam(params, "url");
+  const draft: ConnectionDeepLinkDraft = rawConnectionUrl
+    ? draftFromConnectionUrl(rawConnectionUrl, preferredProfile)
+    : (() => {
+        const profile = connectionProfileForScheme(preferredProfile || "mysql");
+        if (!profile) throw new Error(`Unsupported connection type: ${preferredProfile}`);
+        return {
+          dbType: profile.type,
+          driverProfile: profile.profile,
+          driverLabel: profile.label,
+          port: profile.defaultPort,
+          ssl: false,
+        };
+      })();
+
+  const oneTime = optionalBooleanParam(params, "one_time");
+
+  return {
+    ...draft,
+    name: optionalParam(params, "name") ?? draft.name,
+    host: optionalParam(params, "host") ?? draft.host,
+    port: optionalNumberParam(params, "port") ?? draft.port,
+    username: optionalParam(params, "user") ?? draft.username,
+    password: optionalParam(params, "password") ?? draft.password,
+    database: optionalParam(params, "database") ?? draft.database,
+    urlParams: optionalParam(params, "url_params") ?? draft.urlParams,
+    ssl: optionalBooleanParam(params, "ssl") ? true : draft.ssl,
+    ...(oneTime ? { oneTime: true } : {}),
+  };
+}
diff --git a/apps/desktop/src/lib/connection/connectionErrorHints.ts b/apps/desktop/src/lib/connection/connectionErrorHints.ts
new file mode 100644
index 0000000..0fa71b4
--- /dev/null
+++ b/apps/desktop/src/lib/connection/connectionErrorHints.ts
@@ -0,0 +1,46 @@
+import type { ConnectionConfig } from "@/types/database";
+
+type Translate = (key: string) => string;
+
+function normalizeUrlParams(params: string | undefined): URLSearchParams {
+  return new URLSearchParams((params || "").trim().replace(/^\?/, ""));
+}
+
+function normalizeUrlParamKey(key: string): string {
+  return key.trim().toLowerCase().replace(/[-_]/g, "");
+}
+
+function urlParamValue(params: URLSearchParams, key: string): string {
+  const normalizedKey = normalizeUrlParamKey(key);
+  for (const [paramKey, value] of params.entries()) {
+    if (normalizeUrlParamKey(paramKey) === normalizedKey) return value;
+  }
+  return "";
+}
+
+function mysqlTlsMode(config: ConnectionConfig): string {
+  const parsed = normalizeUrlParams(config.url_params);
+  // MySQL clients use ssl-mode, sslmode and sslMode spellings; keep hint behavior aligned with backend parsing.
+  const mode = urlParamValue(parsed, "ssl-mode").trim().toLowerCase().replace("-", "_");
+  if (["disabled", "disable"].includes(mode)) return "disabled";
+  if (["preferred", "prefer"].includes(mode)) return "preferred";
+  if (["required", "require", "verify_ca", "verify_identity"].includes(mode)) return mode;
+  if (config.ssl || ["true", "1", "yes", "on"].includes(urlParamValue(parsed, "require_ssl").trim().toLowerCase())) return "required";
+  return "disabled";
+}
+
+function isMysqlTlsLikeFailure(message: string): boolean {
+  const text = message.toLowerCase();
+  return (
+    (text.includes("mysql") || text.includes("mariadb") || text.includes("tidb") || text.includes("tls") || text.includes("ssl")) &&
+    (text.includes("tls") || text.includes("ssl") || text.includes("handshake") || text.includes("certificate") || text.includes("cert") || text.includes("unknown ca") || text.includes("self signed"))
+  );
+}
+
+export function appendConnectionErrorHints(config: ConnectionConfig | undefined, message: string, t: Translate): string {
+  if (!config || config.db_type !== "mysql") return message;
+  if (mysqlTlsMode(config) === "disabled") return message;
+  if (!isMysqlTlsLikeFailure(message)) return message;
+  const hint = t("connection.mysqlTlsConnectionFailureHint");
+  return message.includes(hint) ? message : `${message}\n\n${hint}`;
+}
diff --git a/apps/desktop/src/lib/connection/connectionFile.ts b/apps/desktop/src/lib/connection/connectionFile.ts
new file mode 100644
index 0000000..843668c
--- /dev/null
+++ b/apps/desktop/src/lib/connection/connectionFile.ts
@@ -0,0 +1,76 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { h2FilePathFromJdbcUrl } from "@/lib/database/h2Connection";
+
+/**
+ * Whether the database type is one that (potentially) backs onto a local file.
+ * This is a type-level check only — it does not verify that a valid path is
+ * configured. Use this to decide whether to show file-path UI; use
+ * `isLocalFileDb` / `connectionFilePath` to decide whether a reveal action is
+ * available.
+ */
+export function isLocalFileTypeDb(dbType: DatabaseType | string): boolean {
+  return dbType === "sqlite" || dbType === "duckdb" || dbType === "access" || dbType === "h2";
+}
+
+/**
+ * Extract the on-disk file path of a connection if (and only if) the
+ * connection backs onto a single local file.
+ *
+ * - SQLite / DuckDB / Access: `host` holds the file path.
+ * - H2 file mode: path is parsed out of the JDBC URL via `h2FilePathFromJdbcUrl`.
+ *   H2 stores its data in `<base>.mv.db` (default) or `<base>.h2.db`; we hand
+ *   back the base path the user actually configured so the Tauri side can try
+ *   reasonable variants when the literal path isn't a file.
+ *
+ * Returns `null` for in-memory (`:memory:`), empty paths, H2 server/mem mode,
+ * and any DB type that isn't local-file.
+ */
+export function connectionFilePath(config: Pick<ConnectionConfig, "db_type" | "host" | "connection_string">): string | null {
+  const dbType = config.db_type;
+  if (dbType === "sqlite" || dbType === "duckdb" || dbType === "access") {
+    const host = (config.host ?? "").trim();
+    if (!host || host === ":memory:") return null;
+    return host;
+  }
+  if (dbType === "h2") {
+    const fromUrl = h2FilePathFromJdbcUrl(config.connection_string);
+    const trimmed = (fromUrl ?? "").trim();
+    if (!trimmed) return null;
+    return trimmed;
+  }
+  return null;
+}
+
+/**
+ * Whether the connection has a meaningful local file path that can be revealed
+ * in the OS file manager. True iff `connectionFilePath` returns non-null.
+ */
+export function isLocalFileDb(config: Pick<ConnectionConfig, "db_type" | "host" | "connection_string">): boolean {
+  return connectionFilePath(config) !== null;
+}
+
+export function isMemorySqlitePath(path: string | undefined | null): boolean {
+  return (path ?? "").trim().toLowerCase() === ":memory:";
+}
+
+export function sqliteBackupSourcePath(config: Pick<ConnectionConfig, "db_type" | "host">): string | null {
+  if (config.db_type !== "sqlite") return null;
+  const host = (config.host ?? "").trim();
+  return host || null;
+}
+
+export function defaultSqliteBackupFileName(config: Pick<ConnectionConfig, "host" | "name">): string {
+  const source = (config.host || config.name || "database").trim();
+  const rawFileName = isMemorySqlitePath(source) ? "memory.db" : source.split(/[\\/]/).filter(Boolean).pop() || "database.db";
+  const fileName = sanitizeFileName(rawFileName) || "database.db";
+  const dotIndex = fileName.lastIndexOf(".");
+  if (dotIndex <= 0) return `${fileName}.backup.db`;
+  return `${fileName.slice(0, dotIndex)}.backup${fileName.slice(dotIndex)}`;
+}
+
+function sanitizeFileName(fileName: string): string {
+  return fileName
+    .replace(/[<>:"/\\|?*\u0000-\u001f]/g, "_")
+    .trim()
+    .replace(/[. ]+$/g, "");
+}
diff --git a/apps/desktop/src/lib/connection/connectionHealth.ts b/apps/desktop/src/lib/connection/connectionHealth.ts
new file mode 100644
index 0000000..2504df7
--- /dev/null
+++ b/apps/desktop/src/lib/connection/connectionHealth.ts
@@ -0,0 +1,51 @@
+const CONNECTION_ERROR_PATTERNS = [
+  "connection reset",
+  "connection refused",
+  "connection timed out",
+  "connection closed",
+  "connection lost",
+  "connection not found",
+  "connection config not found",
+  "not connected",
+  "closed the connection",
+  "broken pipe",
+  "reset by peer",
+  "socket closed",
+  "unexpected eof",
+  "end-of-file",
+  "end-of-file on communication channel",
+  "server closed session",
+  "communicating with the server",
+  "exceeded maximum idle time",
+  "agent stdin not available",
+  "agent stdout not available",
+  "failed to write to agent stdin",
+  "failed to flush agent stdin",
+  "input/output error",
+  "关闭的连接",
+  "连接已关闭",
+  "网络通信异常",
+  "通信异常",
+  "communications link failure",
+  "sqlrecoverableexception",
+  "sqlnontransientconnectionexception",
+  "sqltransientconnectionexception",
+  "i/o error",
+  "no route to host",
+];
+
+export function staleConnectionMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+export function shouldMarkDisconnected(error: unknown): boolean {
+  const message = staleConnectionMessage(error).toLowerCase();
+  return CONNECTION_ERROR_PATTERNS.some((pattern) => message.includes(pattern)) || hasConnectionOsError(message);
+}
+
+function hasConnectionOsError(message: string): boolean {
+  const osErrorCodes = new Set(["65", "10053", "10054", "10057", "10058", "10060", "10061"]);
+  const match = message.match(/os error\s+(\d+)/);
+  return !!match && osErrorCodes.has(match[1]);
+}
diff --git a/apps/desktop/src/lib/connection/connectionLevelDatabaseBootstrap.ts b/apps/desktop/src/lib/connection/connectionLevelDatabaseBootstrap.ts
new file mode 100644
index 0000000..f8a7065
--- /dev/null
+++ b/apps/desktop/src/lib/connection/connectionLevelDatabaseBootstrap.ts
@@ -0,0 +1,217 @@
+import { splitSqlStatementRanges } from "@/lib/sql/sqlStatementRanges";
+import { supportsCreateDatabaseCharset } from "@/lib/database/createDatabaseSql";
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+
+const MYSQL_BOOTSTRAP_EXTRA_PROFILES = new Set(["selectdb", "goldendb"]);
+
+type BootstrapConnection = Pick<ConnectionConfig, "db_type" | "driver_profile">;
+type ParsedIdentifier = { identifier: string; rest: string };
+
+function splitBootstrapStatements(sql: string, dbType?: DatabaseType): string[] {
+  return splitSqlStatementRanges(sql, dbType)
+    .map((statement) => statement.sql.trim())
+    .filter(Boolean);
+}
+
+function parseMysqlIdentifier(input: string): ParsedIdentifier | null {
+  const first = input[0];
+  if (!first) return null;
+
+  if (first === "`" || first === '"') {
+    return parseDoubledDelimitedIdentifier(input, first);
+  }
+  if (first === "[") {
+    return parseBracketIdentifier(input);
+  }
+
+  const end = input.search(/[\s;]/);
+  const identifier = (end === -1 ? input : input.slice(0, end)).trim();
+  if (!identifier) return null;
+  return { identifier, rest: end === -1 ? "" : input.slice(end) };
+}
+
+function parseDoubledDelimitedIdentifier(input: string, quote: "`" | '"'): ParsedIdentifier | null {
+  let index = 1;
+  let segmentStart = 1;
+  let identifier = "";
+
+  while (index < input.length) {
+    if (input[index] === quote) {
+      identifier += input.slice(segmentStart, index);
+      if (input[index + 1] === quote) {
+        identifier += quote;
+        index += 2;
+        segmentStart = index;
+        continue;
+      }
+      return { identifier, rest: input.slice(index + 1) };
+    }
+    index += 1;
+  }
+
+  return null;
+}
+
+function parseBracketIdentifier(input: string): ParsedIdentifier | null {
+  let index = 1;
+  let segmentStart = 1;
+  let identifier = "";
+
+  while (index < input.length) {
+    if (input[index] === "]") {
+      identifier += input.slice(segmentStart, index);
+      if (input[index + 1] === "]") {
+        identifier += "]";
+        index += 2;
+        segmentStart = index;
+        continue;
+      }
+      return { identifier, rest: input.slice(index + 1) };
+    }
+    index += 1;
+  }
+
+  return null;
+}
+
+function stripLeadingSqlComments(sql: string): string {
+  let rest = sql;
+
+  for (;;) {
+    rest = rest.trimStart();
+    if (!rest) return rest;
+
+    if (rest.startsWith("--")) {
+      const index = rest.indexOf("\n");
+      if (index === -1) return "";
+      rest = rest.slice(index + 1);
+      continue;
+    }
+
+    if (rest.startsWith("#")) {
+      const index = rest.indexOf("\n");
+      if (index === -1) return "";
+      rest = rest.slice(index + 1);
+      continue;
+    }
+
+    if (rest.startsWith("/*")) {
+      const index = rest.indexOf("*/");
+      if (index === -1) return "";
+      rest = rest.slice(index + 2);
+      continue;
+    }
+
+    return rest;
+  }
+}
+
+function leadingSqlKeyword(statement: string): [keyword: string, rest: string] | null {
+  const trimmed = statement.trimStart();
+  const match = trimmed.match(/^[A-Za-z_][A-Za-z0-9_]*/);
+  if (!match) return null;
+  return [match[0], trimmed.slice(match[0].length)];
+}
+
+function sqlRemainderIsCommentOnly(remainder: string): boolean {
+  let rest = remainder;
+
+  for (;;) {
+    rest = rest.trimStart();
+    if (!rest) return true;
+
+    if (rest.startsWith(";")) {
+      rest = rest.slice(1);
+      continue;
+    }
+
+    if (rest.startsWith("--") || rest.startsWith("#")) {
+      return true;
+    }
+
+    if (rest.startsWith("/*")) {
+      const index = rest.indexOf("*/");
+      if (index === -1) return false;
+      rest = rest.slice(index + 2);
+      continue;
+    }
+
+    return false;
+  }
+}
+
+function parseMysqlUseDatabaseTarget(statement: string): string | null {
+  const stripped = stripLeadingSqlComments(statement);
+  const match = stripped.match(/^USE\b/i);
+  if (!match) return null;
+
+  const parsed = parseMysqlIdentifier(stripped.slice(match[0].length).trimStart());
+  if (!parsed) return null;
+
+  return sqlRemainderIsCommentOnly(parsed.rest) ? parsed.identifier : null;
+}
+
+function isDatabaseKeyword(keyword: string): boolean {
+  const normalized = keyword.toUpperCase();
+  return normalized === "DATABASE" || normalized === "SCHEMA";
+}
+
+function isAllowedBootstrapPrelude(statement: string): boolean {
+  const stripped = stripLeadingSqlComments(statement);
+  const leading = leadingSqlKeyword(stripped);
+  if (!leading) return false;
+
+  const [keyword, rest] = leading;
+  const normalized = keyword.toUpperCase();
+  if (normalized === "SET") {
+    return true;
+  }
+
+  if (normalized !== "CREATE" && normalized !== "DROP") {
+    return false;
+  }
+
+  const next = leadingSqlKeyword(rest);
+  return !!next && isDatabaseKeyword(next[0]);
+}
+
+export function supportsConnectionLevelDatabaseBootstrap(connection: BootstrapConnection | undefined): boolean {
+  if (!connection) return false;
+  if (supportsCreateDatabaseCharset(connection.db_type, connection.driver_profile)) return true;
+  return !!connection.driver_profile && MYSQL_BOOTSTRAP_EXTRA_PROFILES.has(connection.driver_profile.toLowerCase());
+}
+
+export function canExecuteWithoutSelectedDatabase(connection: BootstrapConnection | undefined, sql: string): boolean {
+  if (!supportsConnectionLevelDatabaseBootstrap(connection)) return false;
+
+  const statements = splitBootstrapStatements(sql, connection?.db_type);
+  if (statements.length === 0) return false;
+
+  let sawStatement = false;
+  let hasDatabaseContext = false;
+
+  for (const statement of statements) {
+    const stripped = stripLeadingSqlComments(statement);
+    if (!stripped) continue;
+
+    sawStatement = true;
+
+    if (isAllowedBootstrapPrelude(stripped)) {
+      continue;
+    }
+    if (parseMysqlUseDatabaseTarget(stripped)) {
+      hasDatabaseContext = true;
+      continue;
+    }
+    if (!hasDatabaseContext) {
+      return false;
+    }
+  }
+
+  return sawStatement;
+}
+
+export function requiresSqlFileTargetDatabaseSelection(connection: BootstrapConnection | undefined, sqlCanExecuteWithoutSelectedDatabase = false): boolean {
+  if (!supportsConnectionLevelDatabaseBootstrap(connection)) return true;
+  return !sqlCanExecuteWithoutSelectedDatabase;
+}
diff --git a/apps/desktop/src/lib/connection/connectionOpenTarget.ts b/apps/desktop/src/lib/connection/connectionOpenTarget.ts
new file mode 100644
index 0000000..77270bc
--- /dev/null
+++ b/apps/desktop/src/lib/connection/connectionOpenTarget.ts
@@ -0,0 +1,14 @@
+import type { ConnectionConfig } from "@/types/database";
+import { resolveDefaultDatabase } from "@/lib/database/defaultDatabase";
+
+export type QuickConnectionOpenTarget = { kind: "mq-admin" } | { kind: "nacos-admin" } | { kind: "query"; database: string };
+
+export function quickConnectionOpenTarget(connection: Pick<ConnectionConfig, "db_type" | "database">, databaseOptions: string[] = []): QuickConnectionOpenTarget {
+  if (connection.db_type === "mq") {
+    return { kind: "mq-admin" };
+  }
+  if (connection.db_type === "nacos") {
+    return { kind: "nacos-admin" };
+  }
+  return { kind: "query", database: resolveDefaultDatabase(connection, databaseOptions) };
+}
diff --git a/apps/desktop/src/lib/connection/connectionPresentation.ts b/apps/desktop/src/lib/connection/connectionPresentation.ts
new file mode 100644
index 0000000..31a5a72
--- /dev/null
+++ b/apps/desktop/src/lib/connection/connectionPresentation.ts
@@ -0,0 +1,182 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+
+type ConnectionPresentationConfig = Pick<ConnectionConfig, "db_type" | "driver_profile" | "driver_label" | "host" | "port" | "database">;
+type ConnectionNamePresentationConfig = ConnectionPresentationConfig & Pick<ConnectionConfig, "name">;
+
+const LOCAL_DATABASE_TYPES = new Set(["sqlite", "duckdb", "access"]);
+const REDACTED_HOST_SEGMENT = "***";
+const REDACTED_PORT = "****";
+
+export function connectionIconType(connection?: Pick<ConnectionConfig, "db_type" | "driver_profile">): string {
+  return connection?.driver_profile || connection?.db_type || "postgres";
+}
+
+export function connectionDriverLabel(connection?: Pick<ConnectionConfig, "db_type" | "driver_label">): string {
+  return connection?.driver_label || connection?.db_type.toUpperCase() || "";
+}
+
+export function connectionEndpointLabel(connection?: ConnectionPresentationConfig): string {
+  if (!connection) return "";
+  if (connection.db_type === "cloudflare-d1") return [connection.host, connection.database].filter(Boolean).join("/");
+  if (LOCAL_DATABASE_TYPES.has(connection.db_type) || (connection.db_type === "h2" && connection.port === 0)) {
+    return connection.host || connection.database || "local";
+  }
+  if (connection.host && connection.port) return `${connection.host}:${connection.port}`;
+  return connection.host || connection.database || "";
+}
+
+function redactConnectionHost(host: string): string {
+  const normalizedHost = host.trim();
+  if (!normalizedHost) return "";
+
+  const unwrappedHost = normalizedHost.startsWith("[") && normalizedHost.endsWith("]") ? normalizedHost.slice(1, -1) : normalizedHost;
+  const separator = unwrappedHost.includes(":") ? ":" : ".";
+  const segments = unwrappedHost.split(separator).filter(Boolean);
+
+  if (segments.length >= 3) {
+    return [segments[0], ...segments.slice(1, -1).map(() => REDACTED_HOST_SEGMENT), segments[segments.length - 1]].join(separator);
+  }
+
+  if (segments.length === 2) {
+    return [segments[0], REDACTED_HOST_SEGMENT].join(separator);
+  }
+
+  return REDACTED_HOST_SEGMENT;
+}
+
+export function connectionRedactedEndpointLabel(connection?: ConnectionPresentationConfig): string {
+  if (!connection) return "";
+  if (connection.db_type === "cloudflare-d1") return `${REDACTED_HOST_SEGMENT}/${REDACTED_HOST_SEGMENT}`;
+  if (LOCAL_DATABASE_TYPES.has(connection.db_type) || (connection.db_type === "h2" && connection.port === 0)) {
+    return connectionEndpointLabel(connection);
+  }
+
+  const redactedHost = connection.host ? redactConnectionHost(connection.host) : "";
+  if (redactedHost && connection.port) {
+    const endpointHost = redactedHost.includes(":") ? `[${redactedHost}]` : redactedHost;
+    return `${endpointHost}:${REDACTED_PORT}`;
+  }
+
+  return redactedHost || connection.database || "";
+}
+
+export function connectionRedactedNameLabel(connection?: ConnectionNamePresentationConfig): string {
+  const name = connection?.name.trim() || "";
+  if (!connection || !name || LOCAL_DATABASE_TYPES.has(connection.db_type) || (connection.db_type === "h2" && connection.port === 0)) return name;
+
+  const host = connection.host.trim();
+  if (!host) return name;
+
+  const unwrappedHost = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  const hostNames = new Set([host, unwrappedHost]);
+  if (connection.port) {
+    hostNames.add(`${host}:${connection.port}`);
+    if (unwrappedHost.includes(":")) {
+      hostNames.add(`[${unwrappedHost}]:${connection.port}`);
+    }
+  }
+
+  return hostNames.has(name) ? connectionRedactedEndpointLabel(connection) : name;
+}
+
+export function connectionUrlPlaceholder(dbType: DatabaseType): string {
+  switch (dbType) {
+    case "mysql":
+    case "doris":
+    case "starrocks":
+    case "manticoresearch":
+      return "mysql://user:password@host:port/database";
+
+    case "postgres":
+    case "gaussdb":
+    case "kwdb":
+    case "yashandb":
+    case "redshift":
+    case "questdb":
+      return "postgresql://user:password@host:port/database";
+
+    case "redis":
+      return "redis://:password@host:port/0";
+
+    case "etcd":
+      return "etcd://host:2379";
+
+    case "zookeeper":
+      return "zookeeper://host:2181";
+
+    case "sqlite":
+      return "sqlite:///absolute/path/to/database.db";
+
+    case "rqlite":
+      return "http://user:password@host:4001";
+
+    case "turso":
+      return "https://[your-db]-[org].turso.io";
+
+    case "cloudflare-d1":
+      return "https://api.cloudflare.com/client/v4/accounts/{account_id}/d1/database/{database_id}";
+
+    case "duckdb":
+      return "duckdb:///absolute/path/to/database.duckdb";
+
+    case "access":
+      return "jdbc:ucanaccess:///absolute/path/to/database.accdb";
+
+    case "mongodb":
+      return "mongodb://user:password@host:port/database";
+
+    case "clickhouse":
+      return "clickhouse://user:password@host:port/database";
+
+    case "sqlserver":
+      return "mssql://user:password@host:port/database";
+
+    case "oracle":
+      return "oracle://user:password@host:port/service_name";
+
+    case "elasticsearch":
+    case "qdrant":
+    case "milvus":
+    case "weaviate":
+    case "chromadb":
+      return "http://user:password@host:port";
+
+    case "dameng":
+      return "dm://user:password@host:port";
+
+    case "tdengine":
+      return "tdengine://user:password@host:6041/database";
+
+    case "oscar":
+      return "oscar://user:password@host:2003/database";
+
+    case "xugu":
+      return "xugu://user:password@host:5138/database";
+
+    case "iotdb":
+      return "iotdb://user:password@host:6667/root.test";
+
+    case "bigquery":
+      return "bigquery://https://www.googleapis.com/bigquery/v2:443/project-id";
+
+    case "iris":
+      return "iris://user:password@host:port/namespace";
+
+    case "influxdb":
+      return "influxdb://user:password@host:port/database";
+
+    case "jdbc":
+      return "jdbc:mysql://host:3306/database";
+
+    default:
+      return "postgresql://user:password@host:port/database";
+  }
+}
+
+export function connectionOptionSubtitle(connection?: ConnectionPresentationConfig): string {
+  return [connectionDriverLabel(connection), connectionEndpointLabel(connection)].filter(Boolean).join(" · ");
+}
+
+export function connectionRedactedOptionSubtitle(connection?: ConnectionPresentationConfig): string {
+  return [connectionDriverLabel(connection), connectionRedactedEndpointLabel(connection)].filter(Boolean).join(" · ");
+}
diff --git a/apps/desktop/src/lib/connection/connectionUrl.ts b/apps/desktop/src/lib/connection/connectionUrl.ts
new file mode 100644
index 0000000..f8d0a56
--- /dev/null
+++ b/apps/desktop/src/lib/connection/connectionUrl.ts
@@ -0,0 +1,618 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { h2JdbcUrlHasPasswordParam, h2JdbcUrlHasUserParam, parseH2JdbcUrl } from "@/lib/database/h2Connection";
+
+export interface ParsedConnectionUrl {
+  name?: string;
+  dbType: DatabaseType;
+  driverProfile: string;
+  driverLabel: string;
+  host: string;
+  port: number;
+  username: string;
+  password: string;
+  database?: string;
+  urlParams: string;
+  ssl: boolean;
+  connectionString?: string;
+  oracleConnectionType?: "service_name" | "sid";
+  useMongoUrl?: boolean;
+}
+
+export type ConnectionProfile = {
+  type: DatabaseType;
+  profile: string;
+  label: string;
+  defaultPort: number;
+};
+
+const SCHEME_PROFILES: Record<string, ConnectionProfile> = {
+  mysql: { type: "mysql", profile: "mysql", label: "MySQL", defaultPort: 3306 },
+  mariadb: { type: "mysql", profile: "mariadb", label: "MariaDB", defaultPort: 3306 },
+  postgres: { type: "postgres", profile: "postgres", label: "PostgreSQL", defaultPort: 5432 },
+  postgresql: { type: "postgres", profile: "postgres", label: "PostgreSQL", defaultPort: 5432 },
+  redshift: { type: "redshift", profile: "redshift", label: "Redshift", defaultPort: 5439 },
+  redis: { type: "redis", profile: "redis", label: "Redis", defaultPort: 6379 },
+  rediss: { type: "redis", profile: "redis", label: "Redis", defaultPort: 6379 },
+  etcd: { type: "etcd", profile: "etcd", label: "etcd", defaultPort: 2379 },
+  zookeeper: { type: "zookeeper", profile: "zookeeper", label: "Apache ZooKeeper", defaultPort: 2181 },
+  mongodb: { type: "mongodb", profile: "mongodb", label: "MongoDB", defaultPort: 27017 },
+  "mongodb+srv": { type: "mongodb", profile: "mongodb", label: "MongoDB", defaultPort: 27017 },
+  clickhouse: { type: "clickhouse", profile: "clickhouse", label: "ClickHouse", defaultPort: 8123 },
+  sqlserver: { type: "sqlserver", profile: "sqlserver", label: "SQL Server", defaultPort: 1433 },
+  mssql: { type: "sqlserver", profile: "sqlserver", label: "SQL Server", defaultPort: 1433 },
+  oracle: { type: "oracle", profile: "oracle", label: "Oracle", defaultPort: 1521 },
+  elasticsearch: { type: "elasticsearch", profile: "elasticsearch", label: "Elasticsearch", defaultPort: 9200 },
+  qdrant: { type: "qdrant", profile: "qdrant", label: "Qdrant", defaultPort: 6333 },
+  milvus: { type: "milvus", profile: "milvus", label: "Milvus", defaultPort: 19530 },
+  weaviate: { type: "weaviate", profile: "weaviate", label: "Weaviate", defaultPort: 8080 },
+  chromadb: { type: "chromadb", profile: "chromadb", label: "ChromaDB", defaultPort: 8000 },
+  dm: { type: "dameng", profile: "dm", label: "DM (Dameng)", defaultPort: 5236 },
+  dameng: { type: "dameng", profile: "dm", label: "DM (Dameng)", defaultPort: 5236 },
+  gaussdb: { type: "gaussdb", profile: "gaussdb", label: "GaussDB", defaultPort: 5432 },
+  kwdb: { type: "kwdb", profile: "kwdb", label: "KWDB", defaultPort: 26257 },
+  gbase: { type: "gbase", profile: "gbase", label: "GBase", defaultPort: 5258 },
+  "gbasedbt-sqli": { type: "gbase", profile: "gbase8s", label: "GBase 8s", defaultPort: 9088 },
+  "informix-sqli": { type: "informix", profile: "informix", label: "Informix", defaultPort: 9088 },
+  yashandb: { type: "yashandb", profile: "yashandb", label: "YashanDB", defaultPort: 1688 },
+  opengauss: { type: "gaussdb", profile: "opengauss", label: "openGauss", defaultPort: 5432 },
+  questdb: { type: "questdb", profile: "questdb", label: "QuestDB", defaultPort: 8812 },
+  tdengine: { type: "tdengine", profile: "tdengine", label: "TDengine", defaultPort: 6041 },
+  "taos-ws": { type: "tdengine", profile: "tdengine", label: "TDengine", defaultPort: 6041 },
+  oscar: { type: "oscar", profile: "oscar", label: "神通 OSCAR", defaultPort: 2003 },
+  xugu: { type: "xugu", profile: "xugu", label: "XuguDB", defaultPort: 5138 },
+  iotdb: { type: "iotdb", profile: "iotdb", label: "Apache IoTDB", defaultPort: 6667 },
+  iris: { type: "iris", profile: "iris", label: "IRIS", defaultPort: 1972 },
+};
+
+const HTTP_SELECTED_PROFILES: Record<string, ConnectionProfile> = {
+  clickhouse: SCHEME_PROFILES.clickhouse,
+  elasticsearch: SCHEME_PROFILES.elasticsearch,
+  qdrant: SCHEME_PROFILES.qdrant,
+  milvus: SCHEME_PROFILES.milvus,
+  weaviate: SCHEME_PROFILES.weaviate,
+  chromadb: SCHEME_PROFILES.chromadb,
+};
+
+function decodeUrlPart(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function decodePercentEscapes(value: string): string {
+  return value.replace(/%([0-9a-fA-F]{2})/g, (_, hex: string) => String.fromCharCode(Number.parseInt(hex, 16)));
+}
+
+function encodeMongoUserInfoPart(value: string): string {
+  return encodeURIComponent(decodePercentEscapes(value));
+}
+
+export function normalizeMongoConnectionString(value: string): string {
+  const input = value.trim();
+  if (!input) return input;
+
+  const mongoMatch = input.match(/^(mongodb(?:\+srv)?):\/\/(?:(.+)@)?/i);
+  if (!mongoMatch) return input;
+
+  const userinfo = mongoMatch[2];
+  if (!userinfo) return input;
+
+  const [username, ...passwordParts] = userinfo.split(":");
+  const password = passwordParts.join(":");
+  const encodedUsername = encodeMongoUserInfoPart(username);
+  const encodedPassword = password ? `:${encodeMongoUserInfoPart(password)}` : "";
+
+  return input.replace(/^(mongodb(?:\+srv)?:\/\/)(?:(.+)@)?/i, `$1${encodedUsername}${encodedPassword}@`);
+}
+
+function parseMongoUrl(source: string): ParsedConnectionUrl | null {
+  const match = source.match(/^(mongodb(?:\+srv)?):\/\/(?:(.+)@)?([^/]+)(\/[^?]*)?(\?.*)?$/);
+  if (!match) return null;
+
+  const scheme = match[1].toLowerCase();
+  const userinfo = match[2] || "";
+  const hosts = match[3] || "";
+  const pathname = match[4] || "";
+  const search = match[5] || "";
+
+  const profile = SCHEME_PROFILES[scheme];
+  if (!profile) return null;
+
+  const [username, ...passwordParts] = decodeUrlPart(userinfo).split(":");
+  const password = passwordParts.join(":");
+
+  const firstHost = hosts.split(",")[0];
+  let host: string;
+  let port: number;
+  if (firstHost.startsWith("[")) {
+    const bracketEnd = firstHost.indexOf("]");
+    host = firstHost.substring(1, bracketEnd);
+    port = firstHost.substring(bracketEnd + 1).startsWith(":") ? Number(firstHost.substring(bracketEnd + 2)) || profile.defaultPort : profile.defaultPort;
+  } else if (firstHost.includes(":")) {
+    const colonIdx = firstHost.lastIndexOf(":");
+    host = firstHost.substring(0, colonIdx);
+    port = Number(firstHost.substring(colonIdx + 1)) || profile.defaultPort;
+  } else {
+    host = firstHost;
+    port = profile.defaultPort;
+  }
+
+  const database = databaseFromPath(pathname);
+  const urlParams = search.replace(/^\?/, "");
+
+  return {
+    dbType: profile.type,
+    driverProfile: profile.profile,
+    driverLabel: profile.label,
+    host,
+    port,
+    username,
+    password,
+    database,
+    urlParams,
+    ssl: scheme === "mongodb+srv",
+    connectionString: normalizeMongoConnectionString(source),
+    useMongoUrl: true,
+  };
+}
+
+function databaseFromPath(pathname: string): string | undefined {
+  const value = pathname.replace(/^\/+/, "");
+  if (!value) return undefined;
+  return decodeUrlPart(value.split("/")[0]);
+}
+
+function queryParamValue(params: string, key: string): string | undefined {
+  for (const part of params.split(/[&;]/)) {
+    if (!part) continue;
+    const [rawKey, ...rest] = part.split("=");
+    if (decodeUrlPart(rawKey).toLowerCase() === key.toLowerCase()) {
+      return decodeUrlPart(rest.join("=")).trim();
+    }
+  }
+  return undefined;
+}
+
+function connectionNameParam(parsed: URL): string | undefined {
+  for (const [key, value] of parsed.searchParams) {
+    if (key.toLowerCase() === "name") {
+      const name = value.trim();
+      if (name) return name;
+    }
+  }
+  return undefined;
+}
+
+function stripConnectionNameParam(params: string): string {
+  if (!params) return params;
+  return params
+    .split("&")
+    .filter((part) => {
+      if (!part) return true;
+      const [rawKey] = part.split("=");
+      return decodeUrlPart(rawKey).trim().toLowerCase() !== "name";
+    })
+    .join("&");
+}
+
+function extractMysqlCredentialParams(params: string): { username?: string; password?: string; urlParams: string } {
+  let username: string | undefined;
+  let password: string | undefined;
+  let foundCredentialParam = false;
+  const urlParams: string[] = [];
+
+  for (const part of params.split(/[&;]/)) {
+    if (!part) continue;
+    const [rawKey, ...rest] = part.split("=");
+    const key = decodeUrlPart(rawKey).trim().toLowerCase();
+    if (key === "user") {
+      username = decodeUrlPart(rest.join("=")).trim();
+      foundCredentialParam = true;
+    } else if (key === "password") {
+      password = decodeUrlPart(rest.join("=")).trim();
+      foundCredentialParam = true;
+    } else {
+      urlParams.push(part);
+    }
+  }
+
+  return { username, password, urlParams: foundCredentialParam ? urlParams.join("&") : params };
+}
+
+function urlParamsRequireTls(dbType: DatabaseType, params: string): boolean {
+  if (dbType === "mysql") {
+    const requireSsl = queryParamValue(params, "require_ssl")?.toLowerCase();
+    if (requireSsl === "true" || requireSsl === "1" || requireSsl === "yes") return true;
+    const sslMode = (queryParamValue(params, "ssl-mode") || queryParamValue(params, "sslmode") || "").toLowerCase().replace("-", "_");
+    return sslMode === "required" || sslMode === "require" || sslMode === "verify_ca" || sslMode === "verify_identity";
+  }
+
+  if (dbType === "postgres" || dbType === "redshift" || dbType === "kwdb") {
+    const sslMode = (queryParamValue(params, "sslmode") || "").toLowerCase();
+    return sslMode === "require" || sslMode === "verify-ca" || sslMode === "verify-full";
+  }
+
+  return false;
+}
+
+function isTidbCloudHost(host: string): boolean {
+  return host.toLowerCase().endsWith(".tidbcloud.com");
+}
+
+export function connectionProfileForScheme(scheme: string, preferredProfile?: string): ConnectionProfile | undefined {
+  if ((scheme === "http" || scheme === "https") && preferredProfile) {
+    return HTTP_SELECTED_PROFILES[preferredProfile];
+  }
+  return SCHEME_PROFILES[scheme];
+}
+
+function parseJdbcSqlServerUrl(source: string): ParsedConnectionUrl | null {
+  const match = source.match(/^jdbc:sqlserver:\/\/([^;:/]+)(?::(\d+))?(?:;(.*))?$/i);
+  if (!match) return null;
+
+  const profile = SCHEME_PROFILES.sqlserver;
+  const props = new Map<string, string>();
+  const urlParams: string[] = [];
+  for (const part of (match[3] || "").split(";")) {
+    if (!part) continue;
+    const [rawKey, ...rest] = part.split("=");
+    const key = rawKey.trim();
+    const value = rest.join("=");
+    const normalizedKey = key.toLowerCase();
+    if (normalizedKey === "databasename" || normalizedKey === "database" || normalizedKey === "user") {
+      props.set(normalizedKey, value);
+    } else if (normalizedKey === "password") {
+      props.set(normalizedKey, value);
+    } else {
+      urlParams.push(part);
+    }
+  }
+
+  return {
+    dbType: profile.type,
+    driverProfile: profile.profile,
+    driverLabel: profile.label,
+    host: match[1],
+    port: match[2] ? Number(match[2]) : profile.defaultPort,
+    username: decodeUrlPart(props.get("user") || ""),
+    password: decodeUrlPart(props.get("password") || ""),
+    database: decodeUrlPart(props.get("databasename") || props.get("database") || "") || undefined,
+    urlParams: urlParams.join(";"),
+    ssl: false,
+  };
+}
+
+function parseJdbcOracleUrl(source: string): ParsedConnectionUrl | null {
+  const descriptorMatch = source.match(/^jdbc:oracle:thin:@\s*\((.+)\)\s*$/i);
+  if (descriptorMatch) {
+    const profile = SCHEME_PROFILES.oracle;
+    const host = oracleDescriptorValue(source, "HOST");
+    const port = oracleDescriptorValue(source, "PORT");
+    const serviceName = oracleDescriptorValue(source, "SERVICE_NAME");
+    const sid = oracleDescriptorValue(source, "SID");
+    if (!host) return null;
+    return {
+      dbType: profile.type,
+      driverProfile: profile.profile,
+      driverLabel: profile.label,
+      host,
+      port: port ? Number(port) : profile.defaultPort,
+      username: "",
+      password: "",
+      database: serviceName || sid || undefined,
+      urlParams: "",
+      ssl: false,
+      connectionString: source,
+      oracleConnectionType: sid && !serviceName ? "sid" : "service_name",
+    };
+  }
+
+  const serviceMatch = source.match(/^jdbc:oracle:thin:@\/\/([^:/?#]+)(?::(\d+))?\/([^?]+)(?:\?(.*))?$/i);
+  if (serviceMatch) {
+    const profile = SCHEME_PROFILES.oracle;
+    return {
+      dbType: profile.type,
+      driverProfile: profile.profile,
+      driverLabel: profile.label,
+      host: serviceMatch[1],
+      port: serviceMatch[2] ? Number(serviceMatch[2]) : profile.defaultPort,
+      username: "",
+      password: "",
+      database: decodeUrlPart(serviceMatch[3]),
+      urlParams: serviceMatch[4] || "",
+      ssl: false,
+      oracleConnectionType: "service_name",
+    };
+  }
+
+  const sidMatch = source.match(/^jdbc:oracle:thin:@([^:/?#]+)(?::(\d+))?:([^?]+)(?:\?(.*))?$/i);
+  if (sidMatch) {
+    const profile = SCHEME_PROFILES.oracle;
+    return {
+      dbType: profile.type,
+      driverProfile: profile.profile,
+      driverLabel: profile.label,
+      host: sidMatch[1],
+      port: sidMatch[2] ? Number(sidMatch[2]) : profile.defaultPort,
+      username: "",
+      password: "",
+      database: decodeUrlPart(sidMatch[3]),
+      urlParams: sidMatch[4] || "",
+      ssl: false,
+      oracleConnectionType: "sid",
+    };
+  }
+
+  return null;
+}
+
+function oracleDescriptorValue(source: string, key: string): string | undefined {
+  const match = new RegExp(`\\(${key}\\s*=\\s*([^\\)]+)\\)`, "i").exec(source);
+  return match?.[1]?.trim();
+}
+
+function parseJdbcUCanAccessUrl(source: string): ParsedConnectionUrl | null {
+  const match = source.match(/^jdbc:ucanaccess:\/\/(.+?)(?:;.*)?$/i);
+  if (!match) return null;
+
+  const filePath = decodeUrlPart(match[1]);
+  const normalizedPath = filePath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(filePath) ? filePath : `/${filePath}`;
+  const database = normalizedPath.split(/[\\/]/).filter(Boolean).pop();
+
+  return {
+    dbType: "access",
+    driverProfile: "access",
+    driverLabel: "Microsoft Access",
+    host: normalizedPath,
+    port: 0,
+    username: "",
+    password: "",
+    database,
+    urlParams: "",
+    ssl: false,
+    connectionString: source,
+  };
+}
+
+function parseJdbcGbase8sUrl(source: string): ParsedConnectionUrl | null {
+  const match = /^jdbc:gbasedbt-sqli:\/\/(?:(?<userinfo>[^@/?#]*)@)?(?<host>\[[^\]]+\]|[^:/?#]+)(?::(?<port>\d+))?\/(?<database>[^:?#]*)(?::(?<params>[^?#]*))?/i.exec(source);
+  if (!match?.groups) return null;
+
+  const rawUserInfo = match.groups.userinfo || "";
+  const [rawUser = "", ...passwordParts] = rawUserInfo.split(":");
+  const host = match.groups.host.replace(/^\[/, "").replace(/\]$/, "");
+
+  return {
+    dbType: "gbase",
+    driverProfile: "gbase8s",
+    driverLabel: "GBase 8s",
+    host,
+    port: match.groups.port ? Number(match.groups.port) : 9088,
+    username: decodeUrlPart(rawUser),
+    password: decodeUrlPart(passwordParts.join(":")),
+    database: decodeUrlPart(match.groups.database || ""),
+    urlParams: match.groups.params || "",
+    ssl: false,
+  };
+}
+
+function parseJdbcInformixUrl(source: string): ParsedConnectionUrl | null {
+  const match = /^jdbc:informix-sqli:\/\/(?:(?<userinfo>[^@/?#]*)@)?(?<host>\[[^\]]+\]|[^:/?#]+)(?::(?<port>\d+))?\/(?<database>[^:?#]*)(?::(?<params>[^?#]*))?/i.exec(source);
+  if (!match?.groups) return null;
+
+  const rawUserInfo = match.groups.userinfo || "";
+  const [rawUser = "", ...passwordParts] = rawUserInfo.split(":");
+  const host = match.groups.host.replace(/^\[/, "").replace(/\]$/, "");
+
+  return {
+    dbType: "informix",
+    driverProfile: "informix",
+    driverLabel: "Informix",
+    host,
+    port: match.groups.port ? Number(match.groups.port) : 9088,
+    username: decodeUrlPart(rawUser),
+    password: decodeUrlPart(passwordParts.join(":")),
+    database: decodeUrlPart(match.groups.database || ""),
+    urlParams: match.groups.params || "",
+    ssl: false,
+  };
+}
+
+function parseJdbcDremioUrl(source: string): ParsedConnectionUrl | null {
+  const match = /^jdbc:dremio:(?<mode>direct|zk)=(?<host>\[[^\]]+\]|[^:;]+)(?::(?<port>\d+))?(?:;(?<params>.*))?$/i.exec(source);
+  if (!match?.groups) return null;
+
+  const props = new Map<string, string>();
+  const urlParams: string[] = [];
+  for (const part of (match.groups.params || "").split(";")) {
+    if (!part) continue;
+    const [rawKey, ...rest] = part.split("=");
+    const key = rawKey.trim();
+    const value = rest.join("=");
+    const normalizedKey = key.toLowerCase();
+    if (normalizedKey === "schema" || normalizedKey === "user" || normalizedKey === "password") {
+      props.set(normalizedKey, value);
+    } else {
+      urlParams.push(part);
+    }
+  }
+
+  return {
+    dbType: "jdbc",
+    driverProfile: "dremio",
+    driverLabel: "Dremio",
+    host: match.groups.host.replace(/^\[/, "").replace(/\]$/, ""),
+    port: match.groups.port ? Number(match.groups.port) : match.groups.mode.toLowerCase() === "zk" ? 2181 : 31010,
+    username: decodeUrlPart(props.get("user") || ""),
+    password: decodeUrlPart(props.get("password") || ""),
+    database: decodeUrlPart(props.get("schema") || "") || undefined,
+    urlParams: urlParams.join(";"),
+    ssl: false,
+    connectionString: source,
+  };
+}
+
+function parseJdbcDremioArrowFlightSqlUrl(source: string): ParsedConnectionUrl | null {
+  if (!/^jdbc:arrow-flight-sql:\/\//i.test(source)) return null;
+
+  let parsed: URL;
+  try {
+    parsed = new URL(source.replace(/^jdbc:/i, ""));
+  } catch {
+    return null;
+  }
+
+  const urlParams = parsed.search.replace(/^\?/, "");
+
+  return {
+    dbType: "jdbc",
+    driverProfile: "dremio",
+    driverLabel: "Dremio",
+    host: parsed.hostname.replace(/^\[(.*)]$/, "$1"),
+    port: parsed.port ? Number(parsed.port) : 32010,
+    username: decodeUrlPart(parsed.username),
+    password: decodeUrlPart(parsed.password),
+    database: queryParamValue(urlParams, "schema") || undefined,
+    urlParams,
+    ssl: queryParamValue(urlParams, "useEncryption")?.toLowerCase() !== "false",
+    connectionString: source,
+  };
+}
+
+export function parseConnectionUrl(value: string, preferredProfile?: string): ParsedConnectionUrl {
+  const input = value.trim();
+  if (!input) {
+    throw new Error("Connection URL is empty");
+  }
+  const jdbcH2 = parseH2JdbcUrl(input);
+  if (jdbcH2) return jdbcH2;
+  const jdbcUCanAccess = parseJdbcUCanAccessUrl(input);
+  if (jdbcUCanAccess) return jdbcUCanAccess;
+  const jdbcGbase8s = parseJdbcGbase8sUrl(input);
+  if (jdbcGbase8s) return jdbcGbase8s;
+  const jdbcInformix = parseJdbcInformixUrl(input);
+  if (jdbcInformix) return jdbcInformix;
+  const jdbcDremioArrowFlightSql = parseJdbcDremioArrowFlightSqlUrl(input);
+  if (jdbcDremioArrowFlightSql) return jdbcDremioArrowFlightSql;
+  const jdbcDremio = parseJdbcDremioUrl(input);
+  if (jdbcDremio) return jdbcDremio;
+  const jdbcOracle = parseJdbcOracleUrl(input);
+  if (jdbcOracle) return jdbcOracle;
+  const jdbcSqlServer = parseJdbcSqlServerUrl(input);
+  if (jdbcSqlServer) return jdbcSqlServer;
+  const isJdbcUrl = /^jdbc:/i.test(input);
+  const source = isJdbcUrl ? input.replace(/^jdbc:/i, "") : input;
+
+  const mongoResult = parseMongoUrl(source);
+  if (mongoResult) return mongoResult;
+
+  let parsed: URL;
+  try {
+    parsed = new URL(source);
+  } catch {
+    throw new Error("Invalid connection URL");
+  }
+
+  const scheme = parsed.protocol.replace(/:$/, "").toLowerCase();
+  const profile = connectionProfileForScheme(scheme, preferredProfile);
+  if (!profile) {
+    throw new Error(`Unsupported connection URL scheme: ${scheme}`);
+  }
+
+  const urlParams = parsed.search.replace(/^\?/, "");
+  const name = connectionNameParam(parsed);
+  const urlParamsWithoutName = stripConnectionNameParam(urlParams);
+  const normalizedFragment = decodeUrlPart(parsed.hash.replace(/^#/, "")).trim().toLowerCase();
+  const parsedUrlParams = profile.type === "redis" && normalizedFragment === "insecure" ? [urlParamsWithoutName, "insecure=true"].filter(Boolean).join("&") : urlParamsWithoutName;
+  const mysqlCredentials = isJdbcUrl && profile.type === "mysql" ? extractMysqlCredentialParams(parsedUrlParams) : undefined;
+  const effectiveUrlParams = mysqlCredentials?.urlParams ?? parsedUrlParams;
+  if (profile.type === "mongodb") {
+    return {
+      dbType: profile.type,
+      driverProfile: profile.profile,
+      driverLabel: profile.label,
+      host: parsed.hostname,
+      port: parsed.port ? Number(parsed.port) : profile.defaultPort,
+      username: decodeUrlPart(parsed.username),
+      password: decodeUrlPart(parsed.password),
+      database: databaseFromPath(parsed.pathname),
+      urlParams: parsedUrlParams,
+      ssl: scheme === "mongodb+srv",
+      connectionString: normalizeMongoConnectionString(source),
+      useMongoUrl: true,
+    };
+  }
+  if (profile.type === "zookeeper") {
+    return {
+      ...(name ? { name } : {}),
+      dbType: profile.type,
+      driverProfile: profile.profile,
+      driverLabel: profile.label,
+      host: parsed.hostname.replace(/^\[(.*)]$/, "$1"),
+      port: parsed.port ? Number(parsed.port) : profile.defaultPort,
+      username: decodeUrlPart(parsed.username),
+      password: decodeUrlPart(parsed.password),
+      database: undefined,
+      urlParams: urlParamsWithoutName,
+      ssl: false,
+      connectionString: zookeeperConnectStringFromUrl(parsed, profile.defaultPort),
+    };
+  }
+
+  return {
+    ...(name ? { name } : {}),
+    dbType: profile.type,
+    driverProfile: profile.profile,
+    driverLabel: profile.label,
+    host: parsed.hostname,
+    port: parsed.port ? Number(parsed.port) : profile.defaultPort,
+    username: mysqlCredentials?.username ?? decodeUrlPart(parsed.username),
+    password: mysqlCredentials?.password ?? decodeUrlPart(parsed.password),
+    database: databaseFromPath(parsed.pathname),
+    urlParams: effectiveUrlParams,
+    ssl: scheme === "rediss" || scheme === "https" || urlParamsRequireTls(profile.type, effectiveUrlParams) || (profile.type === "mysql" && isTidbCloudHost(parsed.hostname)),
+  };
+}
+
+function zookeeperConnectStringFromUrl(parsed: URL, defaultPort: number): string {
+  const rawHost = parsed.hostname.replace(/^\[(.*)]$/, "$1");
+  const host = rawHost.includes(":") ? `[${rawHost}]` : rawHost;
+  const port = parsed.port ? Number(parsed.port) : defaultPort;
+  const chroot = parsed.pathname && parsed.pathname !== "/" ? parsed.pathname : "";
+  return `${host}:${port}${chroot}`;
+}
+
+function applyParsedUsername(config: Omit<ConnectionConfig, "id">, parsed: ParsedConnectionUrl): string {
+  if (parsed.dbType === "h2" && config.db_type === "h2" && !h2JdbcUrlHasUserParam(parsed.connectionString)) {
+    return config.username || parsed.username;
+  }
+  return parsed.username;
+}
+
+function applyParsedPassword(config: Omit<ConnectionConfig, "id">, parsed: ParsedConnectionUrl): string {
+  if (parsed.dbType === "h2" && config.db_type === "h2" && !h2JdbcUrlHasPasswordParam(parsed.connectionString)) {
+    return config.password || parsed.password;
+  }
+  return parsed.password;
+}
+
+export function applyParsedConnectionUrl(config: Omit<ConnectionConfig, "id">, parsed: ParsedConnectionUrl): Omit<ConnectionConfig, "id"> {
+  return {
+    ...config,
+    db_type: parsed.dbType,
+    driver_profile: parsed.driverProfile,
+    driver_label: parsed.driverLabel,
+    host: parsed.host,
+    port: parsed.port,
+    name: parsed.name?.trim() || config.name,
+    username: applyParsedUsername(config, parsed),
+    password: applyParsedPassword(config, parsed),
+    database: parsed.database,
+    url_params: parsed.urlParams,
+    ssl: parsed.ssl,
+    connection_string: parsed.connectionString,
+    oracle_connection_type: parsed.oracleConnectionType,
+  };
+}
diff --git a/apps/desktop/src/lib/connection/connectionVisibleDatabases.ts b/apps/desktop/src/lib/connection/connectionVisibleDatabases.ts
new file mode 100644
index 0000000..16cd73c
--- /dev/null
+++ b/apps/desktop/src/lib/connection/connectionVisibleDatabases.ts
@@ -0,0 +1,56 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { filterDatabaseNamesForVisiblePicker, normalizeVisibleDatabaseSelection } from "@/lib/database/visibleDatabases";
+
+const DRAFT_VISIBLE_DATABASES_PREFIX = "__visible_draft_";
+
+const UNSUPPORTED_VISIBLE_DATABASE_TYPES = new Set<DatabaseType>(["cloudflare-d1", "elasticsearch", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper"]);
+
+type VisibleDatabaseConnectionFields = Pick<
+  ConnectionConfig,
+  "db_type" | "driver_profile" | "host" | "port" | "username" | "database" | "connection_string" | "url_params" | "redis_connection_mode" | "redis_sentinel_master" | "redis_sentinel_nodes" | "redis_cluster_nodes" | "etcd_endpoints" | "jdbc_driver_class"
+>;
+
+export function buildDraftVisibleDatabasesConnectionId(seed: string): string {
+  return `${DRAFT_VISIBLE_DATABASES_PREFIX}${seed}`;
+}
+
+export function connectionCanChooseVisibleDatabases(connection: Pick<ConnectionConfig, "db_type"> | undefined): boolean {
+  return !!connection?.db_type && !UNSUPPORTED_VISIBLE_DATABASE_TYPES.has(connection.db_type);
+}
+
+export function initialVisibleDatabaseSelection(databaseNames: string[], visibleDatabases: string[] | undefined, connection?: Pick<ConnectionConfig, "db_type" | "driver_profile" | "visible_databases">): string[] {
+  if (Array.isArray(visibleDatabases)) {
+    return normalizeVisibleDatabaseSelection(visibleDatabases, databaseNames);
+  }
+  return filterDatabaseNamesForVisiblePicker(databaseNames, connection);
+}
+
+export function appendVisibleDatabaseSelection(visibleDatabases: string[] | undefined, databaseName: string): string[] | undefined {
+  if (!Array.isArray(visibleDatabases)) return undefined;
+  const name = databaseName.trim();
+  if (!name || visibleDatabases.includes(name)) return visibleDatabases;
+  return [...visibleDatabases, name];
+}
+
+export function visibleDatabaseSelectionIsStale(previous: VisibleDatabaseConnectionFields, current: VisibleDatabaseConnectionFields): boolean {
+  return visibleDatabaseFingerprint(previous) !== visibleDatabaseFingerprint(current);
+}
+
+function visibleDatabaseFingerprint(connection: VisibleDatabaseConnectionFields): string {
+  return JSON.stringify({
+    db_type: connection.db_type,
+    driver_profile: connection.driver_profile || "",
+    host: connection.host || "",
+    port: Number(connection.port) || 0,
+    username: connection.username || "",
+    database: connection.database || "",
+    connection_string: connection.connection_string || "",
+    url_params: connection.url_params || "",
+    redis_connection_mode: connection.redis_connection_mode || "",
+    redis_sentinel_master: connection.redis_sentinel_master || "",
+    redis_sentinel_nodes: connection.redis_sentinel_nodes || "",
+    redis_cluster_nodes: connection.redis_cluster_nodes || "",
+    etcd_endpoints: connection.etcd_endpoints || "",
+    jdbc_driver_class: connection.jdbc_driver_class || "",
+  });
+}
diff --git a/apps/desktop/src/lib/connection/driverInstallProgressUi.ts b/apps/desktop/src/lib/connection/driverInstallProgressUi.ts
new file mode 100644
index 0000000..827730d
--- /dev/null
+++ b/apps/desktop/src/lib/connection/driverInstallProgressUi.ts
@@ -0,0 +1,43 @@
+export interface DriverInstallProgress {
+  step: string;
+  downloaded?: number;
+  total?: number;
+  db_type?: string;
+}
+
+export interface DriverInstallProgressTargetState {
+  installing: string | null;
+  upgradingAll: boolean;
+  progress: DriverInstallProgress | null;
+}
+
+export function driverInstallProgressPercent(progress: DriverInstallProgress | null): number | null {
+  if (!progress?.total || progress.total <= 0) return null;
+  const percent = Math.round(((progress.downloaded ?? 0) / progress.total) * 100);
+  return Math.min(100, Math.max(0, percent));
+}
+
+export function isDriverInstallProgressTarget(dbType: string, state: DriverInstallProgressTargetState): boolean {
+  if (state.installing === dbType) return true;
+  return state.upgradingAll && state.progress?.db_type === dbType;
+}
+
+export function addDriverInstallQueue(queue: string[], dbType: string, activeDbType: string | null): string[] {
+  if (activeDbType === dbType || queue.includes(dbType)) return queue;
+  return [...queue, dbType];
+}
+
+export function removeDriverInstallQueue(queue: string[], dbType: string): string[] {
+  return queue.filter((queuedDbType) => queuedDbType !== dbType);
+}
+
+export function takeNextDriverInstallQueue(queue: string[], isInstallable: (dbType: string) => boolean): { next: string | null; queue: string[] } {
+  const remaining = [...queue];
+  while (remaining.length > 0) {
+    const next = remaining.shift() ?? null;
+    if (next && isInstallable(next)) {
+      return { next, queue: remaining };
+    }
+  }
+  return { next: null, queue: [] };
+}
diff --git a/apps/desktop/src/lib/connection/driverRuntimePresentation.ts b/apps/desktop/src/lib/connection/driverRuntimePresentation.ts
new file mode 100644
index 0000000..aff5a50
--- /dev/null
+++ b/apps/desktop/src/lib/connection/driverRuntimePresentation.ts
@@ -0,0 +1,59 @@
+import type { DriverRuntimeHealth, DriverRuntimeStatus } from "@/lib/backend/api";
+
+export function formatRuntimeBytes(bytes: number | null | undefined): string {
+  if (!bytes) return "-";
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+export function formatRuntimeCpu(value: number | null | undefined): string {
+  if (value === null || value === undefined || Number.isNaN(value)) return "-";
+  return `${Math.max(0, value).toFixed(1)}%`;
+}
+
+export function formatRuntimeUptime(seconds: number | null | undefined): string {
+  if (!seconds) return "-";
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remMinutes = minutes % 60;
+  return remMinutes > 0 ? `${hours}h ${remMinutes}m` : `${hours}h`;
+}
+
+export function runtimeStatusClass(status: DriverRuntimeStatus): string {
+  switch (status) {
+    case "running":
+      return "bg-emerald-500/10 text-emerald-700 dark:text-emerald-400";
+    case "error":
+      return "bg-destructive/10 text-destructive";
+    case "unknown":
+      return "bg-amber-500/10 text-amber-700 dark:text-amber-400";
+    default:
+      return "bg-muted text-muted-foreground";
+  }
+}
+
+export function runtimeStatusDotClass(status: DriverRuntimeStatus): string {
+  switch (status) {
+    case "running":
+      return "bg-emerald-500";
+    case "error":
+      return "bg-destructive";
+    case "unknown":
+      return "bg-amber-500";
+    default:
+      return "bg-muted-foreground/40";
+  }
+}
+
+export function runtimeHealthClass(health: DriverRuntimeHealth): string {
+  switch (health) {
+    case "error":
+      return "text-destructive";
+    case "warning":
+      return "text-amber-700 dark:text-amber-400";
+    default:
+      return "text-green-700 dark:text-green-400";
+  }
+}
diff --git a/apps/desktop/src/lib/connection/kafkaBootstrapServers.ts b/apps/desktop/src/lib/connection/kafkaBootstrapServers.ts
new file mode 100644
index 0000000..1b836af
--- /dev/null
+++ b/apps/desktop/src/lib/connection/kafkaBootstrapServers.ts
@@ -0,0 +1,33 @@
+const KAFKA_BOOTSTRAP_SERVER_SEPARATOR = /[\s,;，；]+/u;
+
+function requireKafkaBootstrapServers(value: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) throw new Error("Kafka bootstrap servers are required");
+  return trimmed;
+}
+
+function normalizeKafkaBootstrapServer(server: string): string {
+  if (server.includes("://")) {
+    throw new Error("Kafka bootstrap servers must be host:port values without a URL scheme");
+  }
+  let parsed: URL;
+  try {
+    parsed = new URL(`kafka://${server}`);
+  } catch {
+    throw new Error("Kafka bootstrap servers are invalid");
+  }
+  if (!parsed.hostname || parsed.username || parsed.password || parsed.search || parsed.hash || (parsed.pathname && parsed.pathname !== "/")) {
+    throw new Error("Kafka bootstrap servers are invalid");
+  }
+  return server;
+}
+
+export function normalizeKafkaBootstrapServers(value: string): string {
+  const servers = requireKafkaBootstrapServers(value)
+    .split(KAFKA_BOOTSTRAP_SERVER_SEPARATOR)
+    .map((server) => server.trim())
+    .filter(Boolean)
+    .map(normalizeKafkaBootstrapServer);
+  if (!servers.length) throw new Error("Kafka bootstrap servers are required");
+  return servers.join(",");
+}
diff --git a/apps/desktop/src/lib/connection/mqAuth.ts b/apps/desktop/src/lib/connection/mqAuth.ts
new file mode 100644
index 0000000..a6611be
--- /dev/null
+++ b/apps/desktop/src/lib/connection/mqAuth.ts
@@ -0,0 +1,22 @@
+import type { MqAuth, MqSystemKind } from "@/types/mq";
+
+export type MqAuthKind = MqAuth["kind"];
+export type MqUiAuthKind = MqAuthKind | "kerberos";
+
+const KAFKA_AUTH_KINDS = new Set<MqUiAuthKind>(["none", "basic", "kerberos"]);
+
+export function isMqAuthKindAllowedForSystem(systemKind: MqSystemKind, authKind: MqUiAuthKind): boolean {
+  if (systemKind === "kafka") return KAFKA_AUTH_KINDS.has(authKind);
+  return authKind !== "kerberos";
+}
+
+export function detectMqUiAuthKind({ systemKind, authKind, saslMechanism, jaasConfig }: { systemKind: MqSystemKind; authKind?: MqAuthKind; saslMechanism: string; jaasConfig: string }): MqUiAuthKind {
+  if (systemKind === "kafka") {
+    if (saslMechanism.toUpperCase() === "GSSAPI" && jaasConfig.includes("Krb5LoginModule")) {
+      return "kerberos";
+    }
+    return authKind === "basic" ? "basic" : "none";
+  }
+
+  return authKind || "none";
+}
diff --git a/apps/desktop/src/lib/connection/sqlServerLegacyCompatibility.ts b/apps/desktop/src/lib/connection/sqlServerLegacyCompatibility.ts
new file mode 100644
index 0000000..3629451
--- /dev/null
+++ b/apps/desktop/src/lib/connection/sqlServerLegacyCompatibility.ts
@@ -0,0 +1,34 @@
+import type { ConnectionConfig } from "@/types/database";
+
+export const SQLSERVER_LEGACY_COMPATIBILITY_DRIVER_KEY = "sqlserver-legacy";
+
+const SQLSERVER_LEGACY_DISABLED_VALUES = new Set(["disabled", "disable", "false", "0", "off", "no"]);
+
+export function isSqlServerLegacyCompatibilityMode(params: string | undefined): boolean {
+  const normalized = (params || "").trim().replace(/^\?/, "").replace(/;/g, "&");
+  if (!normalized) return false;
+  const parsed = new URLSearchParams(normalized);
+  for (const [key, value] of parsed.entries()) {
+    const normalizedKey = key.trim().toLowerCase();
+    if (normalizedKey === "sqlserverencryption" || normalizedKey === "encrypt") {
+      // Accept JDBC-style `encrypt=false` from imported SQL Server URLs as the same opt-in.
+      if (SQLSERVER_LEGACY_DISABLED_VALUES.has(value.trim().toLowerCase())) return true;
+    }
+  }
+  return false;
+}
+
+export function setSqlServerLegacyCompatibilityMode(params: string | undefined, enabled: boolean): string {
+  const normalized = (params || "").trim().replace(/^\?/, "").replace(/;/g, "&");
+  const parsed = new URLSearchParams(normalized);
+  for (const key of Array.from(parsed.keys())) {
+    const normalizedKey = key.trim().toLowerCase();
+    if (normalizedKey === "sqlserverencryption" || normalizedKey === "encrypt") parsed.delete(key);
+  }
+  if (enabled) parsed.set("sqlserverEncryption", "disabled");
+  return parsed.toString();
+}
+
+export function requiresSqlServerLegacyCompatibilityComponent(config: ConnectionConfig): boolean {
+  return config.db_type === "sqlserver" && isSqlServerLegacyCompatibilityMode(config.url_params);
+}
diff --git a/apps/desktop/src/lib/connection/tunnelProfiles.ts b/apps/desktop/src/lib/connection/tunnelProfiles.ts
new file mode 100644
index 0000000..4891f70
--- /dev/null
+++ b/apps/desktop/src/lib/connection/tunnelProfiles.ts
@@ -0,0 +1,95 @@
+import { uuid } from "@/lib/common/utils";
+import type { TransportLayerConfig, TunnelProfile } from "@/types/database";
+
+export type TunnelProfileType = TunnelProfile["type"];
+
+export function createTunnelProfile(type: TunnelProfileType): TunnelProfile {
+  if (type === "proxy") {
+    return {
+      type: "proxy",
+      id: uuid(),
+      name: "",
+      enabled: true,
+      proxy_type: "socks5",
+      host: "",
+      port: 1080,
+      username: "",
+      password: "",
+    };
+  }
+  if (type === "http_tunnel") {
+    return {
+      type: "http_tunnel",
+      id: uuid(),
+      name: "",
+      enabled: true,
+      url: "",
+      token: "",
+      connect_timeout_secs: 10,
+    };
+  }
+  return {
+    type: "ssh",
+    id: uuid(),
+    name: "",
+    enabled: true,
+    host: "",
+    port: 22,
+    user: "root",
+    password: "",
+    key_path: "",
+    key_passphrase: "",
+    connect_timeout_secs: 5,
+    expose_lan: false,
+    use_ssh_agent: false,
+    ssh_agent_sock_path: "",
+    auth_method: "password",
+  };
+}
+
+export function tunnelProfileSummary(profile: TunnelProfile): string {
+  if (profile.type === "ssh") {
+    if (!profile.host) return "";
+    const user = profile.user ? `${profile.user}@` : "";
+    return `${user}${profile.host}:${profile.port || 22}`;
+  }
+  if (profile.type === "proxy") {
+    if (!profile.host) return "";
+    return `${profile.proxy_type || "socks5"}://${profile.host}:${profile.port || 1080}`;
+  }
+  return profile.url || "";
+}
+
+export function layerReferencesProfile(layer: TransportLayerConfig): boolean {
+  return !!layer.profile_id;
+}
+
+/**
+ * Builds the reference stub stored on a connection for a layer that uses a
+ * shared profile: only identity, enabled state, and the reference survive —
+ * the backend swaps in the profile's full configuration at connect time, and
+ * keeping credentials out of the stub avoids stale copies.
+ */
+export function tunnelProfileReferenceLayer(profile: TunnelProfile, previous?: Pick<TransportLayerConfig, "id" | "enabled">): TransportLayerConfig {
+  const stub = createTunnelProfile(profile.type);
+  stub.id = previous?.id || stub.id;
+  stub.enabled = previous?.enabled !== false;
+  stub.name = profile.name || "";
+  stub.profile_id = profile.id;
+  return stub;
+}
+
+/**
+ * Detaches a profile-referencing layer back into a self-contained custom
+ * layer by copying the profile's full configuration onto it.
+ */
+export function detachTunnelProfileLayer(layer: TransportLayerConfig, profile: TunnelProfile | undefined): TransportLayerConfig {
+  if (!profile) {
+    const detached = { ...layer };
+    delete detached.profile_id;
+    return detached;
+  }
+  const detached = { ...profile, id: layer.id, enabled: layer.enabled !== false };
+  delete detached.profile_id;
+  return detached;
+}
diff --git a/apps/desktop/src/lib/dataGrid/binaryCellDownload.ts b/apps/desktop/src/lib/dataGrid/binaryCellDownload.ts
new file mode 100644
index 0000000..92d48c5
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/binaryCellDownload.ts
@@ -0,0 +1,177 @@
+import type { CellValue } from "@/lib/dataGrid/cellValue";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+
+export type BinaryCellDownloadMode = "binary" | "utf8" | "gbk";
+
+export interface BinaryCellDownloadPayload {
+  data: Uint8Array | string;
+  mimeType: string;
+  extension: string;
+}
+
+export interface BinaryCellDownloadResult {
+  kind: "saved" | "browser-download" | "cancelled";
+  path?: string;
+  fileName?: string;
+}
+
+export const BINARY_CELL_DOWNLOAD_MODES: BinaryCellDownloadMode[] = ["binary", "utf8", "gbk"];
+
+const HEX_VALUE_RE = /^(?:0[xX]|\\x)([0-9a-fA-F\s]+)$/;
+const BARE_HEX_RE = /^[0-9a-fA-F\s]+$/;
+const HEX_ESCAPE_RE = /^(?:\\x[0-9a-fA-F]{2}|\s)+$/;
+const BINARY_TYPE_RE = /^(?:blob|tinyblob|mediumblob|longblob|bytea|bytes|binary|varbinary|image|raw|long\s+raw)(?:\b|\()/i;
+
+function copyBytesForBlob(bytes: Uint8Array): Uint8Array<ArrayBuffer> {
+  return new Uint8Array(bytes);
+}
+
+export function parseBinaryCellHexValue(value: CellValue): Uint8Array | null {
+  if (typeof value !== "string") return null;
+  const match = value.trim().match(HEX_VALUE_RE);
+  if (!match) return null;
+
+  return bytesFromHex(match[1]);
+}
+
+function bytesFromHex(value: string): Uint8Array | null {
+  const hex = value.replace(/\s+/g, "");
+  if (!hex || hex.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(hex)) return null;
+
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    const parsed = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    if (Number.isNaN(parsed)) return null;
+    bytes[i] = parsed;
+  }
+  return bytes;
+}
+
+function bytesFromByteArray(value: unknown): Uint8Array | null {
+  if (!Array.isArray(value)) return null;
+  const bytes = new Uint8Array(value.length);
+  for (let i = 0; i < value.length; i++) {
+    const item = value[i];
+    if (!Number.isInteger(item) || item < 0 || item > 255) return null;
+    bytes[i] = item;
+  }
+  return bytes;
+}
+
+function bytesFromBufferLikeObject(value: unknown): Uint8Array | null {
+  if (!value || typeof value !== "object") return null;
+  const data = (value as { data?: unknown }).data;
+  return bytesFromByteArray(data);
+}
+
+export function parseBinaryCellBytes(value: unknown, columnType?: string): Uint8Array | null {
+  if (typeof value === "string") {
+    const prefixed = parseBinaryCellHexValue(value);
+    if (prefixed) return prefixed;
+
+    const trimmed = value.trim();
+    if (HEX_ESCAPE_RE.test(trimmed)) {
+      return bytesFromHex(trimmed.replace(/\\x/gi, ""));
+    }
+
+    if (isBinaryCellColumnType(columnType) && BARE_HEX_RE.test(trimmed)) {
+      return bytesFromHex(trimmed);
+    }
+  }
+
+  return bytesFromByteArray(value) ?? bytesFromBufferLikeObject(value);
+}
+
+export function isBinaryCellColumnType(columnType?: string): boolean {
+  const type = (columnType ?? "").trim();
+  return !!type && BINARY_TYPE_RE.test(type);
+}
+
+export function canDownloadBinaryCellValue(value: unknown, columnType?: string): boolean {
+  return !!parseBinaryCellBytes(value, columnType);
+}
+
+export function binaryCellDisplayText(value: unknown, columnType?: string): string | null {
+  const bytes = parseBinaryCellBytes(value, columnType);
+  if (!bytes || !isBinaryCellColumnType(columnType)) return null;
+  return `${binaryCellDisplayLabel(columnType)} [${formatBinaryCellByteSize(bytes.length)}]`;
+}
+
+function binaryCellDisplayLabel(columnType?: string): string {
+  const base = (columnType ?? "")
+    .trim()
+    .split(/[(:\s]/)[0]
+    .toUpperCase();
+  if (!base) return "BLOB";
+  if (base.includes("BLOB")) return "BLOB";
+  return base;
+}
+
+function formatBinaryCellByteSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} bytes`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(bytes < 10 * 1024 ? 1 : 0)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(bytes < 10 * 1024 * 1024 ? 1 : 0)} MB`;
+}
+
+export function binaryCellDownloadPayload(value: unknown, mode: BinaryCellDownloadMode, columnType?: string): BinaryCellDownloadPayload {
+  const bytes = parseBinaryCellBytes(value, columnType);
+  if (!bytes) {
+    throw new Error("Cell value is not a downloadable binary value.");
+  }
+
+  if (mode === "binary") {
+    return {
+      data: bytes,
+      mimeType: "application/octet-stream",
+      extension: "bin",
+    };
+  }
+
+  const decoder = new TextDecoder(mode === "gbk" ? "gbk" : "utf-8", { fatal: false });
+  return {
+    data: decoder.decode(bytes),
+    mimeType: "text/plain;charset=utf-8",
+    extension: "txt",
+  };
+}
+
+export function binaryCellDownloadFileName(options: { column: string; rowNumber: number; mode: BinaryCellDownloadMode; extension: string }): string {
+  const column = options.column
+    .trim()
+    .replace(/[\\/:*?"<>|]+/g, "-")
+    .replace(/\s+/g, "_")
+    .slice(0, 48);
+  const safeColumn = column || "cell";
+  const suffix = options.mode === "binary" ? "" : `-${options.mode}`;
+  return `${safeColumn}-row-${options.rowNumber}${suffix}.${options.extension}`;
+}
+
+export async function downloadBinaryCellPayload(payload: BinaryCellDownloadPayload, fileName: string): Promise<BinaryCellDownloadResult> {
+  if (isTauriRuntime()) {
+    const [{ save }, fs] = await Promise.all([import("@tauri-apps/plugin-dialog"), import("@tauri-apps/plugin-fs")]);
+    const path = await save({
+      defaultPath: fileName,
+      filters: [{ name: payload.extension.toUpperCase(), extensions: [payload.extension] }],
+    });
+    if (!path) return { kind: "cancelled" };
+    if (typeof payload.data === "string") {
+      await fs.writeTextFile(path, payload.data);
+    } else {
+      await fs.writeFile(path, payload.data);
+    }
+    return { kind: "saved", path };
+  }
+
+  const blob = new Blob([typeof payload.data === "string" ? payload.data : copyBytesForBlob(payload.data)], {
+    type: payload.mimeType,
+  });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = fileName;
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+  URL.revokeObjectURL(url);
+  return { kind: "browser-download", fileName };
+}
diff --git a/apps/desktop/src/lib/dataGrid/binaryHexViewer.ts b/apps/desktop/src/lib/dataGrid/binaryHexViewer.ts
new file mode 100644
index 0000000..8081f4d
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/binaryHexViewer.ts
@@ -0,0 +1,28 @@
+export interface BinaryHexViewRow {
+  offset: string;
+  hex: string;
+  ascii: string;
+}
+
+const BYTES_PER_ROW = 16;
+
+function formatHexByte(value: number): string {
+  return value.toString(16).toUpperCase().padStart(2, "0");
+}
+
+function formatAsciiByte(value: number): string {
+  return value >= 0x20 && value <= 0x7e ? String.fromCharCode(value) : ".";
+}
+
+export function buildBinaryHexViewRows(bytes: Uint8Array): BinaryHexViewRow[] {
+  const rows: BinaryHexViewRow[] = [];
+  for (let offset = 0; offset < bytes.length; offset += BYTES_PER_ROW) {
+    const slice = bytes.slice(offset, offset + BYTES_PER_ROW);
+    rows.push({
+      offset: offset.toString(16).toUpperCase().padStart(8, "0"),
+      hex: Array.from(slice, formatHexByte).join(" "),
+      ascii: Array.from(slice, formatAsciiByte).join(""),
+    });
+  }
+  return rows;
+}
diff --git a/apps/desktop/src/lib/dataGrid/canvasDataGridRenderer.ts b/apps/desktop/src/lib/dataGrid/canvasDataGridRenderer.ts
new file mode 100644
index 0000000..f145dd0
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/canvasDataGridRenderer.ts
@@ -0,0 +1,450 @@
+import { firstLineCellDisplayValue, type CellValue } from "@/lib/dataGrid/cellValue";
+import type { RowStatus } from "@/lib/dataGrid/gridRowStatus";
+import { DATA_GRID_DARK_SEARCH_COLORS, resolveDataGridPaintTheme, type DataGridPaintTheme } from "@/lib/dataGrid/dataGridPaintTheme";
+
+export const CANVAS_DATA_GRID_ROW_HEIGHT = 26;
+
+export interface CanvasDataGridRow {
+  id: number;
+  displayIndex: number;
+  data: CellValue[];
+  isNew: boolean;
+  isDraft?: boolean;
+  isDeleted: boolean;
+  isDirtyCol: boolean[];
+  status: RowStatus;
+}
+
+export interface CanvasHoverCell {
+  rowIndex: number;
+  visibleColIdx: number;
+}
+
+export interface CanvasEditingCell {
+  rowId: number;
+  col: number;
+}
+
+export interface CanvasSearchMatch {
+  kind: "cell" | "column";
+  displayRow: number;
+  col: number;
+}
+
+export interface DrawCanvasDataGridOptions {
+  canvas: HTMLCanvasElement;
+  scroller: HTMLElement;
+  width: number;
+  height: number;
+  pixelRatio?: number;
+  isDark: boolean;
+  styleKey?: string;
+  rowCount: number;
+  rowAt: (rowIndex: number) => CanvasDataGridRow | undefined;
+  renderedColumnWidths: number[];
+  renderedColumnOffsets?: number[];
+  columnPreviewOffsets?: readonly number[];
+  columnPreviewSourceVisibleIndex?: number | null;
+  visibleColumnIndexes: number[];
+  rowNumberWidth: number;
+  hoverCell: CanvasHoverCell | null;
+  isScrolling: boolean;
+  editingCell: CanvasEditingCell | null;
+  searchMatchKeys: ReadonlySet<string>;
+  currentSearchMatch: CanvasSearchMatch | null;
+  formatCell: (value: CellValue, columnIndex: number) => string;
+  draftCellPlaceholder?: string;
+  isRowActive: (rowIndex: number) => boolean;
+  rowCellsUseSelectionVisual: (rowId: number) => boolean;
+  cellIsSelected: (rowIndex: number, visibleColIdx: number) => boolean;
+  cellCanHover: (row: CanvasDataGridRow, actualColIdx: number) => boolean;
+  infiniteScrollEnabled: boolean;
+  pageSize: number;
+  currentPage: number;
+}
+
+type NumericCanvasContext = CanvasRenderingContext2D & {
+  fontVariantNumeric?: string;
+};
+
+interface CanvasRenderState {
+  cacheKey: string;
+  normalFont: string;
+  tabularFont: string;
+  semiboldFont: string;
+  italicFont: string;
+  theme: DataGridPaintTheme;
+  searchFill: string;
+  currentSearchFill: string;
+  currentSearchBorder: string;
+}
+
+const canvasRenderStateCache = new WeakMap<HTMLCanvasElement, CanvasRenderState>();
+
+function setCanvasNumericVariant(ctx: CanvasRenderingContext2D, value: "normal" | "tabular-nums") {
+  const numericCtx = ctx as NumericCanvasContext;
+  if ("fontVariantNumeric" in numericCtx) numericCtx.fontVariantNumeric = value;
+}
+
+function canvasTabularFontFamily(fontFamily: string): string {
+  return fontFamily.replace(/"Geist Variable"/g, '"Geist Variable Tabular"');
+}
+
+const FIT_CANVAS_TEXT_CACHE_MAX = 10000;
+const fitCanvasTextCache = new Map<string, string>();
+
+export function clearFitCanvasTextCache(): void {
+  fitCanvasTextCache.clear();
+}
+
+export function fitCanvasText(ctx: CanvasRenderingContext2D, text: string, maxWidth: number): string {
+  if (maxWidth <= 0) return "";
+  const font = ctx.font;
+  const cacheKey = `${font}|${text}|${maxWidth}`;
+  const cached = fitCanvasTextCache.get(cacheKey);
+  if (cached !== undefined) return cached;
+  if (ctx.measureText(text).width <= maxWidth) {
+    if (fitCanvasTextCache.size >= FIT_CANVAS_TEXT_CACHE_MAX) fitCanvasTextCache.clear();
+    fitCanvasTextCache.set(cacheKey, text);
+    return text;
+  }
+  const ellipsis = "...";
+  const ellipsisWidth = ctx.measureText(ellipsis).width;
+  let low = 0;
+  let high = text.length;
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (ctx.measureText(text.slice(0, mid)).width + ellipsisWidth <= maxWidth) low = mid;
+    else high = mid - 1;
+  }
+  const result = text.slice(0, low) + ellipsis;
+  if (fitCanvasTextCache.size >= FIT_CANVAS_TEXT_CACHE_MAX) fitCanvasTextCache.clear();
+  fitCanvasTextCache.set(cacheKey, result);
+  return result;
+}
+
+function canvasFont(style: { family: string; sizePx: number; style?: string; weight?: string | number; lineHeight?: string }): string {
+  const fontStyle = style.style && style.style !== "normal" ? `${style.style} ` : "";
+  const fontWeight = style.weight && style.weight !== "400" && style.weight !== "normal" ? `${style.weight} ` : "";
+  const lineHeight = style.lineHeight && style.lineHeight !== "normal" ? `/${style.lineHeight}` : "";
+  return `${fontStyle}${fontWeight}${style.sizePx}px${lineHeight} ${style.family}`;
+}
+
+function columnOffsets(widths: number[]): number[] {
+  const offsets = Array.from({ length: widths.length + 1 }, () => 0);
+  offsets[0] = 0;
+  for (let index = 0; index < widths.length; index++) {
+    offsets[index + 1] = offsets[index] + (widths[index] ?? 0);
+  }
+  return offsets;
+}
+
+function firstVisibleColumn(offsets: number[], contentStart: number): number {
+  let low = 0;
+  let high = Math.max(0, offsets.length - 2);
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if ((offsets[mid + 1] ?? 0) < contentStart) low = mid + 1;
+    else high = mid;
+  }
+  return low;
+}
+
+function alignCanvasPixel(value: number, dpr: number): number {
+  return Math.round(value * dpr) / dpr;
+}
+
+function crispCanvasLine(value: number, dpr: number): number {
+  return alignCanvasPixel(value, dpr) + 0.5 / dpr;
+}
+
+function resolveCanvasRenderState(canvas: HTMLCanvasElement, isDark: boolean, styleKey?: string): CanvasRenderState {
+  const canvasStyle = getComputedStyle(canvas);
+  const cacheKey = `${styleKey ?? "default"}:${isDark ? "dark" : "light"}:${canvasStyle.fontFamily}:${canvasStyle.fontSize}`;
+  const cached = canvasRenderStateCache.get(canvas);
+  if (cached?.cacheKey === cacheKey) return cached;
+
+  const fontFamily = canvasStyle.fontFamily || `"Geist Variable Tabular", "Geist Variable", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif`;
+  const fontSize = Number.parseFloat(canvasStyle.fontSize) || 13;
+  const lineHeight = canvasStyle.lineHeight;
+  const normalFont = canvasFont({
+    family: fontFamily,
+    sizePx: fontSize,
+    weight: canvasStyle.fontWeight,
+    lineHeight,
+  });
+  const tabularFont = canvasFont({
+    family: canvasTabularFontFamily(fontFamily),
+    sizePx: fontSize,
+    weight: canvasStyle.fontWeight,
+    lineHeight,
+  });
+  const semiboldFont = canvasFont({ family: fontFamily, sizePx: fontSize, weight: 600, lineHeight });
+  const italicFont = canvasFont({
+    family: fontFamily,
+    sizePx: fontSize,
+    style: "italic",
+    weight: canvasStyle.fontWeight,
+    lineHeight,
+  });
+  const theme = resolveDataGridPaintTheme({
+    getVar: (name) => canvasStyle.getPropertyValue(name),
+    isDark,
+  });
+  const state = {
+    cacheKey,
+    normalFont,
+    tabularFont,
+    semiboldFont,
+    italicFont,
+    theme,
+    searchFill: isDark ? DATA_GRID_DARK_SEARCH_COLORS.match : theme.cellSearch,
+    currentSearchFill: isDark ? DATA_GRID_DARK_SEARCH_COLORS.current : theme.cellCurrentSearch,
+    currentSearchBorder: isDark ? DATA_GRID_DARK_SEARCH_COLORS.currentBorder : theme.cellCurrentSearchBorder,
+  };
+  canvasRenderStateCache.set(canvas, state);
+  return state;
+}
+
+export function drawCanvasDataGrid(options: DrawCanvasDataGridOptions) {
+  const {
+    canvas,
+    scroller,
+    width,
+    height,
+    isDark,
+    styleKey,
+    rowCount,
+    rowAt,
+    renderedColumnWidths,
+    renderedColumnOffsets,
+    columnPreviewOffsets = [],
+    columnPreviewSourceVisibleIndex,
+    visibleColumnIndexes,
+    rowNumberWidth,
+    hoverCell,
+    isScrolling,
+    editingCell,
+    searchMatchKeys,
+    currentSearchMatch,
+    formatCell,
+    draftCellPlaceholder,
+    isRowActive,
+    rowCellsUseSelectionVisual,
+    cellIsSelected,
+    cellCanHover,
+    infiniteScrollEnabled,
+    pageSize,
+    currentPage,
+  } = options;
+  const dpr = Math.max(1, options.pixelRatio ?? window.devicePixelRatio ?? 1);
+  const pixelWidth = Math.max(1, Math.ceil(width * dpr));
+  const pixelHeight = Math.max(1, Math.ceil(height * dpr));
+  if (canvas.width !== pixelWidth || canvas.height !== pixelHeight) {
+    canvas.width = pixelWidth;
+    canvas.height = pixelHeight;
+  }
+  const canvasWidth = `${width}px`;
+  const canvasHeight = `${height}px`;
+  if (canvas.style.width !== canvasWidth) canvas.style.width = canvasWidth;
+  if (canvas.style.height !== canvasHeight) canvas.style.height = canvasHeight;
+
+  const ctx = canvas.getContext("2d");
+  if (!ctx) return;
+  ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
+  ctx.imageSmoothingEnabled = false;
+  ctx.clearRect(0, 0, width, height);
+
+  const { normalFont, tabularFont, semiboldFont, italicFont, theme, searchFill, currentSearchFill, currentSearchBorder } = resolveCanvasRenderState(canvas, isDark, styleKey);
+
+  const scrollTop = scroller.scrollTop;
+  const scrollLeft = scroller.scrollLeft;
+  const firstRow = Math.max(0, Math.floor(scrollTop / CANVAS_DATA_GRID_ROW_HEIGHT));
+  const lastRow = Math.min(rowCount - 1, Math.ceil((scrollTop + height) / CANVAS_DATA_GRID_ROW_HEIGHT));
+
+  ctx.fillStyle = theme.background;
+  ctx.fillRect(0, 0, width, height);
+  ctx.font = normalFont;
+  ctx.textBaseline = "middle";
+
+  const offsets = renderedColumnOffsets ?? columnOffsets(renderedColumnWidths);
+  let maxPreviewRightShift = 0;
+  let maxPreviewLeftShift = 0;
+  for (const offset of columnPreviewOffsets) {
+    if (offset > maxPreviewRightShift) maxPreviewRightShift = offset;
+    else if (-offset > maxPreviewLeftShift) maxPreviewLeftShift = -offset;
+  }
+  const contentStart = Math.max(0, scrollLeft - rowNumberWidth);
+  const firstCol = firstVisibleColumn(offsets, Math.max(0, contentStart - maxPreviewRightShift));
+  const columnOffset = offsets[firstCol] ?? 0;
+  const paintSearchMatches = !isScrolling && searchMatchKeys.size > 0;
+  const rowNumberBorderX = crispCanvasLine(rowNumberWidth - 1, dpr);
+  const rowNumberTextX = alignCanvasPixel(Math.max(0, rowNumberWidth - 1) / 2, dpr);
+  const rowTextOffsetY = alignCanvasPixel(CANVAS_DATA_GRID_ROW_HEIGHT / 2, dpr);
+
+  for (let rowIndex = firstRow; rowIndex <= lastRow; rowIndex++) {
+    const item = rowAt(rowIndex);
+    if (!item) continue;
+    const y = rowIndex * CANVAS_DATA_GRID_ROW_HEIGHT - scrollTop;
+    const rowIsActive = isRowActive(item.displayIndex);
+
+    const rowBase = item.isDeleted ? theme.rowDeleted : item.isNew && !rowIsActive ? theme.rowNew : item.isDraft && !rowIsActive ? theme.rowMuted : item.displayIndex % 2 === 1 && !rowIsActive ? theme.rowMuted : theme.background;
+    const rowBorderY = crispCanvasLine(y + CANVAS_DATA_GRID_ROW_HEIGHT - 1, dpr);
+    ctx.globalAlpha = item.isDeleted ? 0.7 : 1;
+    ctx.fillStyle = rowIsActive && !item.isDeleted ? theme.cellSelectedSingle : rowBase;
+    ctx.fillRect(0, y, width, CANVAS_DATA_GRID_ROW_HEIGHT);
+
+    const rowNumberFill = item.status === "draft" ? theme.rowNumberDefault : item.status === "new" ? theme.rowNumberNew : item.status === "edited" ? theme.rowNumberEdited : item.status === "deleted" ? theme.rowNumberDeleted : theme.rowNumberDefault;
+    ctx.fillStyle = rowNumberFill;
+    ctx.fillRect(0, y, rowNumberWidth, CANVAS_DATA_GRID_ROW_HEIGHT);
+    ctx.strokeStyle = theme.border;
+    ctx.beginPath();
+    ctx.moveTo(rowNumberBorderX, y);
+    ctx.lineTo(rowNumberBorderX, y + CANVAS_DATA_GRID_ROW_HEIGHT);
+    ctx.stroke();
+
+    const rowNumberText = item.status === "new" ? theme.rowNumberTextNew : item.status === "edited" ? theme.rowNumberTextEdited : item.status === "deleted" ? theme.rowNumberTextDeleted : theme.rowNumberTextClean;
+    ctx.fillStyle = rowNumberText;
+    ctx.font = item.status === "new" || item.status === "edited" || item.status === "draft" ? semiboldFont : normalFont;
+    ctx.textAlign = "center";
+    const textY = alignCanvasPixel(y + rowTextOffsetY, dpr);
+    if (item.isDraft) {
+      ctx.fillText("*", rowNumberTextX, textY);
+    } else if (infiniteScrollEnabled) {
+      ctx.fillText(String(item.displayIndex + 1), rowNumberTextX, textY);
+    } else {
+      ctx.fillText(String(item.displayIndex + 1 + pageSize * (currentPage - 1)), rowNumberTextX, textY);
+    }
+    ctx.font = normalFont;
+
+    ctx.strokeStyle = theme.border;
+    ctx.beginPath();
+    ctx.moveTo(0, rowBorderY);
+    ctx.lineTo(width, rowBorderY);
+    ctx.stroke();
+    const drawCell = (visibleColIdx: number, baseX: number) => {
+      const colWidth = renderedColumnWidths[visibleColIdx] ?? 0;
+      const actualColIdx = visibleColumnIndexes[visibleColIdx];
+      if (actualColIdx === undefined) return;
+      const drawX = baseX + (columnPreviewOffsets[visibleColIdx] ?? 0);
+      if (drawX + colWidth < rowNumberWidth || drawX >= width) return;
+
+      const selectedCell = cellIsSelected(item.displayIndex, visibleColIdx);
+      const rowSelectionVisual = rowCellsUseSelectionVisual(item.id);
+      const isDirtyCell = item.isDirtyCol[actualColIdx];
+      const selectedFillVisual = rowSelectionVisual || selectedCell;
+      const selectedBorderVisual = rowSelectionVisual || selectedCell;
+      const isSearchMatch = paintSearchMatches && searchMatchKeys.has(`cell:${item.displayIndex}:${actualColIdx}`);
+      const isCurrentSearchMatch = paintSearchMatches && currentSearchMatch?.displayRow === item.displayIndex && currentSearchMatch.col === actualColIdx;
+      const clippedX = Math.max(drawX, rowNumberWidth);
+      const cellPaintWidth = Math.min(width, drawX + colWidth) - clippedX;
+      if (cellPaintWidth <= 0) return;
+
+      if (isDirtyCell && !selectedFillVisual) {
+        ctx.fillStyle = theme.cellDirty;
+        ctx.fillRect(clippedX, y, cellPaintWidth, CANVAS_DATA_GRID_ROW_HEIGHT);
+      }
+      if (hoverCell?.rowIndex === item.displayIndex && hoverCell.visibleColIdx === visibleColIdx && !isScrolling && !isSearchMatch && !isCurrentSearchMatch && !isDirtyCell && cellCanHover(item, actualColIdx)) {
+        ctx.fillStyle = theme.cellHover;
+        ctx.fillRect(clippedX, y, cellPaintWidth, CANVAS_DATA_GRID_ROW_HEIGHT);
+      }
+      if ((rowIsActive || selectedCell) && !item.isDeleted && !isDirtyCell) {
+        ctx.fillStyle = theme.cellSelectedSingle;
+        ctx.fillRect(clippedX, y, cellPaintWidth, CANVAS_DATA_GRID_ROW_HEIGHT);
+      }
+      if (selectedFillVisual && isDirtyCell) {
+        ctx.fillStyle = theme.cellSelectedDirty;
+        ctx.fillRect(clippedX, y, cellPaintWidth, CANVAS_DATA_GRID_ROW_HEIGHT);
+      }
+      if (isSearchMatch) {
+        ctx.fillStyle = searchFill;
+        ctx.fillRect(clippedX, y, cellPaintWidth, CANVAS_DATA_GRID_ROW_HEIGHT);
+      }
+      if (isCurrentSearchMatch) {
+        ctx.fillStyle = currentSearchFill;
+        ctx.fillRect(clippedX, y, cellPaintWidth, CANVAS_DATA_GRID_ROW_HEIGHT);
+      }
+
+      ctx.strokeStyle = theme.border;
+      ctx.beginPath();
+      ctx.moveTo(clippedX, rowBorderY);
+      ctx.lineTo(Math.min(width, clippedX + cellPaintWidth), rowBorderY);
+      ctx.stroke();
+
+      ctx.save();
+      ctx.beginPath();
+      ctx.rect(clippedX, y, Math.min(cellPaintWidth, width - clippedX), CANVAS_DATA_GRID_ROW_HEIGHT);
+      ctx.clip();
+      const value = item.data[actualColIdx];
+      ctx.textAlign = "left";
+      ctx.fillStyle = value === null ? theme.mutedForeground : theme.foreground;
+      ctx.font = value === null ? italicFont : tabularFont;
+      setCanvasNumericVariant(ctx, value === null ? "normal" : "tabular-nums");
+      const textLeft = alignCanvasPixel(drawX + 12, dpr);
+      const paddedMaxWidth = Math.max(0, drawX + colWidth - textLeft - 12);
+      const isEditingThisCell = editingCell?.rowId === item.id && editingCell.col === actualColIdx;
+      const rawDisplayText = item.isDraft && value === null ? (draftCellPlaceholder ?? "") : formatCell(value, actualColIdx);
+      const displayText = isEditingThisCell ? "" : firstLineCellDisplayValue(rawDisplayText);
+      const needsTruncation = ctx.measureText(displayText).width > paddedMaxWidth;
+      const textMaxWidth = needsTruncation ? Math.max(0, drawX + colWidth - textLeft) : paddedMaxWidth;
+      const text = isEditingThisCell ? displayText : fitCanvasText(ctx, displayText, textMaxWidth - 12);
+      ctx.fillText(text, textLeft, textY);
+      if (item.isDeleted && text) {
+        const textWidth = Math.min(ctx.measureText(text).width, textMaxWidth);
+        ctx.strokeStyle = theme.foreground;
+        ctx.beginPath();
+        ctx.moveTo(textLeft, textY);
+        ctx.lineTo(alignCanvasPixel(textLeft + textWidth, dpr), textY);
+        ctx.stroke();
+      }
+      ctx.restore();
+      setCanvasNumericVariant(ctx, "normal");
+      ctx.font = normalFont;
+
+      ctx.strokeStyle = theme.border;
+      ctx.beginPath();
+      const columnBorderX = crispCanvasLine(drawX + colWidth - 1, dpr);
+      ctx.moveTo(columnBorderX, y);
+      ctx.lineTo(columnBorderX, y + CANVAS_DATA_GRID_ROW_HEIGHT);
+      ctx.stroke();
+
+      if (selectedBorderVisual && cellPaintWidth >= 2) {
+        const selectedLeftX = clippedX + 0.5;
+        const selectedRightX = clippedX + cellPaintWidth - 1.5;
+        const selectedTopY = Math.max(y + 0.5, 1);
+        const drawSelectedLeftBorder = selectedLeftX >= rowNumberWidth + 0.5;
+        ctx.strokeStyle = selectedCell && !isDirtyCell ? theme.cellSelectedSingleBorder : theme.cellSelectedBorder;
+        ctx.beginPath();
+        ctx.moveTo(selectedLeftX, selectedTopY);
+        ctx.lineTo(selectedRightX, selectedTopY);
+        ctx.moveTo(selectedLeftX, rowBorderY);
+        ctx.lineTo(selectedRightX, rowBorderY);
+        if (drawSelectedLeftBorder) {
+          ctx.moveTo(selectedLeftX, selectedTopY);
+          ctx.lineTo(selectedLeftX, rowBorderY);
+        }
+        ctx.moveTo(selectedRightX, selectedTopY);
+        ctx.lineTo(selectedRightX, rowBorderY);
+        ctx.stroke();
+      }
+
+      if (isCurrentSearchMatch) {
+        ctx.strokeStyle = currentSearchBorder;
+        ctx.lineWidth = 2;
+        ctx.strokeRect(clippedX + 1, y + 1, Math.max(0, cellPaintWidth - 2), CANVAS_DATA_GRID_ROW_HEIGHT - 2);
+        ctx.lineWidth = 1;
+      }
+    };
+
+    let x = rowNumberWidth + columnOffset - scrollLeft;
+    for (let visibleColIdx = firstCol; visibleColIdx < renderedColumnWidths.length && x - maxPreviewLeftShift < width; visibleColIdx++) {
+      const colWidth = renderedColumnWidths[visibleColIdx] ?? 0;
+      drawCell(visibleColIdx, x);
+      x += colWidth;
+    }
+    if (columnPreviewSourceVisibleIndex !== null && columnPreviewSourceVisibleIndex !== undefined && (columnPreviewOffsets[columnPreviewSourceVisibleIndex] ?? 0) !== 0) {
+      drawCell(columnPreviewSourceVisibleIndex, rowNumberWidth + (offsets[columnPreviewSourceVisibleIndex] ?? 0) - scrollLeft);
+    }
+    ctx.globalAlpha = 1;
+  }
+}
diff --git a/apps/desktop/src/lib/dataGrid/cellDetailPresentation.ts b/apps/desktop/src/lib/dataGrid/cellDetailPresentation.ts
new file mode 100644
index 0000000..f05617c
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/cellDetailPresentation.ts
@@ -0,0 +1,115 @@
+import { safeJsonFormat } from "@/lib/common/safeJsonFormat";
+
+export type CellDetailTab = "details" | "hexViewer" | "valueEditor";
+export type ValueEditorAction = "formatJson" | "setNull" | "restoreOriginal";
+
+export const CELL_DETAIL_JSON_FORMAT_MAX_LENGTH = 50_000;
+
+export interface CellDetailPresentationOptions {
+  isEditable: boolean;
+  hasBinaryHexViewer?: boolean;
+}
+
+export interface LinkedCellDetailOptions {
+  isOpen: boolean;
+  isEditing: boolean;
+  selectedCell: { rowIndex: number; visibleColIndex: number } | null;
+  actualColumnIndex: (visibleColIndex: number) => number;
+}
+
+export interface CellDetailTarget {
+  rowIndex: number;
+  col: number;
+}
+
+export function defaultCellDetailTab(): CellDetailTab {
+  return "details";
+}
+
+export function visibleCellDetailTabs(options: CellDetailPresentationOptions): CellDetailTab[] {
+  const tabs: CellDetailTab[] = ["details"];
+  if (options.hasBinaryHexViewer) {
+    tabs.push("hexViewer");
+  }
+  if (options.isEditable) {
+    tabs.push("valueEditor");
+  }
+  return tabs;
+}
+
+export function cellDetailEditorText(value: unknown, _columnType?: string): string {
+  if (value === null) return "";
+  return cellDetailRawEditorText(value);
+}
+
+function cellDetailRawEditorText(value: unknown): string {
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+
+export function valueEditorActions(options: { canSetNull: boolean; canFormatJson?: boolean }): ValueEditorAction[] {
+  const actions: ValueEditorAction[] = [];
+  if (options.canFormatJson) actions.push("formatJson");
+  if (options.canSetNull) actions.push("setNull");
+  actions.push("restoreOriginal");
+  return actions;
+}
+
+export function linkedCellDetailTarget(options: LinkedCellDetailOptions): CellDetailTarget | null {
+  if (!options.isOpen || options.isEditing || !options.selectedCell) return null;
+  return {
+    rowIndex: options.selectedCell.rowIndex,
+    col: options.actualColumnIndex(options.selectedCell.visibleColIndex),
+  };
+}
+
+export function isJsonColumnType(columnType: string | undefined): boolean {
+  const base = (columnType ?? "")
+    .trim()
+    .toLowerCase()
+    .split(/[(:\s]/)[0];
+  return base === "json" || base === "jsonb";
+}
+
+export function isGeometryColumnType(columnType: string | undefined): boolean {
+  const base = (columnType ?? "")
+    .trim()
+    .toLowerCase()
+    .split(/[(:\s]/)[0];
+  return base === "geometry" || base === "geography";
+}
+
+export function canFormatCellDetailJson(value: unknown, columnType?: string): boolean {
+  if (value === null || value === undefined) return false;
+  const text = cellDetailRawEditorText(value);
+  if (text.length > CELL_DETAIL_JSON_FORMAT_MAX_LENGTH) return false;
+  if (isJsonColumnType(columnType)) return !!formatJsonText(text);
+  return typeof value === "string" && looksLikeJsonContainerText(text) && !!formatJsonText(text);
+}
+
+export function formatJsonText(text: string): string | undefined {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  if (trimmed.length > CELL_DETAIL_JSON_FORMAT_MAX_LENGTH) return undefined;
+  try {
+    return safeJsonFormat(trimmed, 2);
+  } catch {
+    return undefined;
+  }
+}
+
+export function compactJsonText(text: string): string | undefined {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  if (trimmed.length > CELL_DETAIL_JSON_FORMAT_MAX_LENGTH) return undefined;
+  try {
+    return safeJsonFormat(trimmed);
+  } catch {
+    return undefined;
+  }
+}
+
+export function looksLikeJsonContainerText(text: string): boolean {
+  const trimmed = text.trim();
+  return trimmed.startsWith("{") || trimmed.startsWith("[");
+}
diff --git a/apps/desktop/src/lib/dataGrid/cellDetailSelection.ts b/apps/desktop/src/lib/dataGrid/cellDetailSelection.ts
new file mode 100644
index 0000000..cb40b2c
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/cellDetailSelection.ts
@@ -0,0 +1,9 @@
+interface CellDetailSelectionEditor {
+  state: { doc: { length: number } };
+  dispatch(spec: { selection: { anchor: number; head: number } }): void;
+}
+
+export function selectAllCellDetailText(editor: CellDetailSelectionEditor): boolean {
+  editor.dispatch({ selection: { anchor: 0, head: editor.state.doc.length } });
+  return true;
+}
diff --git a/apps/desktop/src/lib/dataGrid/cellImageUrl.ts b/apps/desktop/src/lib/dataGrid/cellImageUrl.ts
new file mode 100644
index 0000000..ebdc508
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/cellImageUrl.ts
@@ -0,0 +1,107 @@
+import type { CellValue } from "@/lib/dataGrid/cellValue";
+import { isBinaryCellColumnType, parseBinaryCellBytes } from "@/lib/dataGrid/binaryCellDownload";
+
+const IMAGE_PATH_RE = /\.(?:png|jpe?g|webp|gif|avif|bmp|svg)$/i;
+const SAFE_DATA_IMAGE_RE = /^data:image\/(?:png|jpe?g|webp|gif|avif|bmp);base64,[a-z0-9+/=\s]+$/i;
+const MAX_BINARY_IMAGE_PREVIEW_BYTES = 8 * 1024 * 1024;
+const HEX_PREFIX_RE = /^(?:0[xX]|\\x)([0-9a-fA-F\s]+)$/;
+const HEX_ESCAPE_RE = /^(?:\\x[0-9a-fA-F]{2}|\s)+$/;
+const BARE_HEX_RE = /^[0-9a-fA-F\s]+$/;
+
+function isLocalHttpHost(hostname: string): boolean {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+}
+
+export interface CellImagePreviewOptions {
+  binary?: boolean;
+}
+
+export function cellImagePreviewUrl(value: CellValue | unknown, columnType?: string, options: CellImagePreviewOptions = {}): string | null {
+  const binaryPreviewUrl = options.binary === false ? null : binaryImagePreviewUrl(value, columnType);
+  if (binaryPreviewUrl) return binaryPreviewUrl;
+
+  if (typeof value !== "string") return null;
+  const text = value.trim();
+  if (!text) return null;
+  if (SAFE_DATA_IMAGE_RE.test(text)) return text;
+
+  let url: URL;
+  try {
+    url = new URL(text);
+  } catch {
+    return null;
+  }
+
+  if (url.protocol === "http:" && !isLocalHttpHost(url.hostname)) return null;
+  if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+  if (!IMAGE_PATH_RE.test(url.pathname)) return null;
+  return text;
+}
+
+function binaryImagePreviewUrl(value: unknown, columnType?: string): string | null {
+  if (estimatedBinaryByteLength(value, columnType) > MAX_BINARY_IMAGE_PREVIEW_BYTES) return null;
+  const bytes = parseBinaryCellBytes(value, columnType);
+  if (!bytes || bytes.length > MAX_BINARY_IMAGE_PREVIEW_BYTES) return null;
+  const mimeType = detectImageMimeType(bytes);
+  if (!mimeType) return null;
+  return `data:${mimeType};base64,${bytesToBase64(bytes)}`;
+}
+
+function estimatedBinaryByteLength(value: unknown, columnType?: string): number {
+  if (Array.isArray(value)) return value.length;
+  if (value && typeof value === "object" && Array.isArray((value as { data?: unknown }).data)) {
+    return (value as { data: unknown[] }).data.length;
+  }
+  if (typeof value !== "string") return 0;
+
+  const trimmed = value.trim();
+  const prefixed = trimmed.match(HEX_PREFIX_RE);
+  if (prefixed) return prefixed[1].replace(/\s+/g, "").length / 2;
+  if (HEX_ESCAPE_RE.test(trimmed)) return trimmed.replace(/\s+/g, "").replace(/\\x/gi, "").length / 2;
+  if (isBinaryCellColumnType(columnType) && BARE_HEX_RE.test(trimmed)) return trimmed.replace(/\s+/g, "").length / 2;
+  return 0;
+}
+
+function detectImageMimeType(bytes: Uint8Array): string | null {
+  if (startsWith(bytes, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])) return "image/png";
+  if (startsWith(bytes, [0xff, 0xd8, 0xff])) return "image/jpeg";
+  if (asciiAt(bytes, 0, "GIF87a") || asciiAt(bytes, 0, "GIF89a")) return "image/gif";
+  if (asciiAt(bytes, 0, "RIFF") && asciiAt(bytes, 8, "WEBP")) return "image/webp";
+  if (startsWith(bytes, [0x42, 0x4d])) return "image/bmp";
+  if (asciiAt(bytes, 4, "ftyp") && (asciiAt(bytes, 8, "avif") || asciiAt(bytes, 8, "avis"))) return "image/avif";
+  return safeSvgMimeType(bytes);
+}
+
+function startsWith(bytes: Uint8Array, signature: number[]): boolean {
+  if (bytes.length < signature.length) return false;
+  return signature.every((byte, index) => bytes[index] === byte);
+}
+
+function asciiAt(bytes: Uint8Array, offset: number, value: string): boolean {
+  if (bytes.length < offset + value.length) return false;
+  for (let i = 0; i < value.length; i++) {
+    if (bytes[offset + i] !== value.charCodeAt(i)) return false;
+  }
+  return true;
+}
+
+function safeSvgMimeType(bytes: Uint8Array): string | null {
+  const text = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+  const trimmed = text.replace(/^\uFEFF/, "").trimStart();
+  if (!/^(?:<\?xml[\s\S]*?\?>\s*)?(?:<!--[\s\S]*?-->\s*)*<svg(?:\s|>)/i.test(trimmed.slice(0, 2048))) {
+    return null;
+  }
+  if (/<\s*script\b/i.test(text) || /<\s*foreignObject\b/i.test(text) || /\son[a-z]+\s*=/i.test(text) || /\b(?:href|xlink:href|src)\s*=\s*["']?\s*javascript:/i.test(text)) {
+    return null;
+  }
+  return "image/svg+xml";
+}
+
+function bytesToBase64(bytes: Uint8Array): string {
+  let binary = "";
+  const chunkSize = 0x8000;
+  for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + chunkSize));
+  }
+  return btoa(binary);
+}
diff --git a/apps/desktop/src/lib/dataGrid/cellValue.ts b/apps/desktop/src/lib/dataGrid/cellValue.ts
new file mode 100644
index 0000000..ef6b474
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/cellValue.ts
@@ -0,0 +1,13 @@
+export type CellValue = string | number | boolean | null;
+
+export function displayCellValue(value: CellValue): string {
+  if (value === null) return "NULL";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+
+export function firstLineCellDisplayValue(value: string): string {
+  const lineBreakIndex = value.search(/\r\n|\r|\n/);
+  return lineBreakIndex === -1 ? value : value.slice(0, lineBreakIndex);
+}
diff --git a/apps/desktop/src/lib/dataGrid/chartData.ts b/apps/desktop/src/lib/dataGrid/chartData.ts
new file mode 100644
index 0000000..c70bb37
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/chartData.ts
@@ -0,0 +1,26 @@
+import type { QueryResult } from "@/types/database";
+
+export function toChartNumber(value: QueryResult["rows"][number][number]): number | null {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string") return null;
+
+  const trimmed = value.trim();
+  if (trimmed === "") return null;
+
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+export function isChartableValue(value: QueryResult["rows"][number][number]): boolean {
+  return toChartNumber(value) !== null;
+}
+
+export function chartableColumnIndexes(result: QueryResult): number[] {
+  return result.columns.map((_, index) => index).filter((index) => result.rows.some((row) => isChartableValue(row[index])));
+}
+
+export function axisColumnLabel(columns: string[], index: number): string {
+  const name = columns[index] ?? `#${index + 1}`;
+  if (columns.filter((column) => column === name).length <= 1) return name;
+  return `${name} #${index + 1}`;
+}
diff --git a/apps/desktop/src/lib/dataGrid/columnFormatter.ts b/apps/desktop/src/lib/dataGrid/columnFormatter.ts
new file mode 100644
index 0000000..2683465
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/columnFormatter.ts
@@ -0,0 +1,303 @@
+import { displayCellValue, type CellValue } from "@/lib/dataGrid/cellValue";
+import dayjs, { Dayjs } from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat";
+import utc from "dayjs/plugin/utc";
+import timezone from "dayjs/plugin/timezone";
+
+dayjs.extend(customParseFormat);
+dayjs.extend(utc);
+dayjs.extend(timezone);
+
+export type DateTimeFormatterUnit = "seconds" | "milliseconds" | "auto";
+const DEFAULT_DATETIME_PATTERN = "YYYY-MM-DD HH:mm:ss";
+export const DateTimePatterns = ["HH:mm:ss", "HH:mm:ss.SSS", "YYYY-MM-DD HH:mm:ss", "YYYY-MM-DD HH:mm:ss.SSS", "YYYY/MM/DD HH:mm:ss", "YYYY/MM/DD HH:mm:ss.SSS", "YYYY-MM-DDTHH:mm:ssZ", "YYYY-MM-DDTHH:mm:ss.SSSZ", "YYYY/MM/DDTHH:mm:ssZ", "YYYY/MM/DDTHH:mm:ss.SSSZ"];
+const STRICT_LOCAL_DATETIME_INPUT_PATTERNS = ["YYYY-MM-DD", "YYYY/MM/DD", "YYYY-MM-DD HH:mm:ss", "YYYY-MM-DD HH:mm:ss.SSS", "YYYY/MM/DD HH:mm:ss", "YYYY/MM/DD HH:mm:ss.SSS", "YYYY-MM-DDTHH:mm:ss", "YYYY-MM-DDTHH:mm:ss.SSS", "YYYY/MM/DDTHH:mm:ss", "YYYY/MM/DDTHH:mm:ss.SSS"];
+const ISO_OFFSET_DATETIME_PATTERN = /^(\d{4})([-/])(\d{2})\2(\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d{1,3})?(Z|[+-]\d{2}:\d{2})$/;
+
+export interface CustomColumnFormatterConfig {
+  id: string;
+  name: string;
+  template: string;
+}
+
+export type ColumnFormatterConfig = { kind: "datetime"; unit: DateTimeFormatterUnit; pattern: string } | { kind: "json-path"; path: string } | { kind: "mask"; prefix: number; suffix: number } | { kind: "custom-template"; template: string } | { kind: "custom-ref"; formatterId: string };
+
+export interface ColumnFormatterKeyParts {
+  connectionId: string;
+  database?: string;
+  schema?: string;
+  tableName: string;
+  column: string;
+}
+
+export function buildColumnFormatterKey(parts: ColumnFormatterKeyParts): string {
+  return [parts.connectionId, parts.database ?? "", parts.schema ?? "", parts.tableName, parts.column].join("::");
+}
+
+export function normalizeColumnFormatter(value: unknown): ColumnFormatterConfig | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const config = value as Record<string, unknown>;
+
+  if (config.kind === "datetime") {
+    return config.unit === "seconds" || config.unit === "milliseconds" || config.unit === "auto"
+      ? {
+          kind: "datetime",
+          unit: config.unit,
+          pattern: normalizeDateTimePattern(config.pattern),
+        }
+      : undefined;
+  }
+
+  if (config.kind === "json-path") {
+    return typeof config.path === "string" && isSupportedJsonPath(config.path) ? { kind: "json-path", path: config.path } : undefined;
+  }
+
+  if (config.kind === "mask") {
+    if (!Number.isInteger(config.prefix) || !Number.isInteger(config.suffix)) return undefined;
+    if ((config.prefix as number) < 0 || (config.suffix as number) < 0) return undefined;
+    return { kind: "mask", prefix: config.prefix as number, suffix: config.suffix as number };
+  }
+
+  if (config.kind === "custom-template") {
+    return typeof config.template === "string" && config.template.trim() ? { kind: "custom-template", template: config.template.slice(0, 500) } : undefined;
+  }
+
+  if (config.kind === "custom-ref") {
+    return typeof config.formatterId === "string" && config.formatterId.trim() ? { kind: "custom-ref", formatterId: config.formatterId } : undefined;
+  }
+
+  return undefined;
+}
+
+export function normalizeCustomColumnFormatter(value: unknown): CustomColumnFormatterConfig | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const config = value as Record<string, unknown>;
+  if (typeof config.id !== "string" || !config.id.trim()) return undefined;
+  if (typeof config.name !== "string" || !config.name.trim()) return undefined;
+  if (typeof config.template !== "string" || !config.template.trim()) return undefined;
+  return {
+    id: config.id.trim(),
+    name: config.name.trim().slice(0, 80),
+    template: config.template.slice(0, 500),
+  };
+}
+
+export function resolveColumnFormatter(formatter: ColumnFormatterConfig | undefined, customFormatters: Record<string, CustomColumnFormatterConfig>): ColumnFormatterConfig | undefined {
+  if (!formatter) return undefined;
+  if (formatter.kind !== "custom-ref") return formatter;
+  const customFormatter = customFormatters[formatter.formatterId];
+  return customFormatter ? { kind: "custom-template", template: customFormatter.template } : undefined;
+}
+
+export function applyColumnFormatter(value: CellValue, formatter: ColumnFormatterConfig | undefined): string {
+  if (!formatter) return displayCellValue(value);
+
+  try {
+    if (formatter.kind === "datetime") return formatDateTime(value, formatter.unit, formatter.pattern);
+    if (formatter.kind === "json-path") return formatJsonPath(value, formatter.path);
+    if (formatter.kind === "mask") return formatMask(value, formatter);
+    if (formatter.kind === "custom-template") return formatCustomTemplate(value, formatter.template);
+    return displayCellValue(value);
+  } catch {
+    return displayCellValue(value);
+  }
+}
+
+function formatDateTime(value: CellValue, unit: DateTimeFormatterUnit, pattern: string): string {
+  if (value === null) return displayCellValue(value);
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "object") return JSON.stringify(value);
+  const parsed: Dayjs | undefined = resolveDateTimeValue(value, unit);
+  return parsed ? parsed.format(pattern || DEFAULT_DATETIME_PATTERN) : displayCellValue(value);
+}
+
+function resolveDateTimeValue(value: string | number, unit: DateTimeFormatterUnit) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return undefined;
+    }
+    const timestamp = parseTimestampMilliseconds(trimmed, unit);
+    if (timestamp !== undefined) {
+      const parsedTimestamp = dayjs(timestamp);
+      return parsedTimestamp.isValid() ? parsedTimestamp : undefined;
+    }
+    if (isIntegerString(trimmed)) return undefined;
+
+    return parseStrictDateTimeString(trimmed);
+  }
+
+  const timestamp = parseTimestampMilliseconds(value, unit);
+  if (timestamp === undefined) return undefined;
+
+  const parsedTimestamp = dayjs(timestamp);
+  return parsedTimestamp.isValid() ? parsedTimestamp : undefined;
+}
+
+function normalizeDateTimePattern(pattern: unknown): string {
+  return typeof pattern === "string" && pattern.trim() ? pattern : DEFAULT_DATETIME_PATTERN;
+}
+
+function parseStrictDateTimeString(value: string): Dayjs | undefined {
+  const parsedIsoOffset = parseIsoOffsetDateTimeString(value);
+  if (parsedIsoOffset) return parsedIsoOffset;
+
+  for (const pattern of STRICT_LOCAL_DATETIME_INPUT_PATTERNS) {
+    // Day.js non-strict parsing normalizes overflow dates such as 2022-01-33.
+    // Keep cell text strict so invalid values fall back unchanged.
+    const parsed = dayjs(value, pattern, true);
+    if (parsed.isValid()) return parsed;
+  }
+  return undefined;
+}
+
+function parseIsoOffsetDateTimeString(value: string): Dayjs | undefined {
+  const match = value.match(ISO_OFFSET_DATETIME_PATTERN);
+  if (!match) return undefined;
+
+  const [, yearText, , monthText, dayText, hourText, minuteText, secondText, fractionText = "", zoneText] = match;
+  if (!isValidDateTimeParts(yearText, monthText, dayText, hourText, minuteText, secondText)) return undefined;
+  if (!isValidOffset(zoneText)) return undefined;
+
+  const normalized = `${yearText}-${monthText}-${dayText}T${hourText}:${minuteText}:${secondText}${fractionText}${zoneText}`;
+  const parsed = dayjs(normalized);
+  return parsed.isValid() ? parsed : undefined;
+}
+
+function isValidDateTimeParts(yearText: string, monthText: string, dayText: string, hourText: string, minuteText: string, secondText: string): boolean {
+  const year = Number(yearText);
+  const month = Number(monthText);
+  const day = Number(dayText);
+  const hour = Number(hourText);
+  const minute = Number(minuteText);
+  const second = Number(secondText);
+  if (!Number.isInteger(year) || year < 1) return false;
+  if (!Number.isInteger(month) || month < 1 || month > 12) return false;
+  const daysInMonth = new Date(Date.UTC(year, month, 0)).getUTCDate();
+  if (!Number.isInteger(day) || day < 1 || day > daysInMonth) return false;
+  return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
+}
+
+function isValidOffset(offset: string): boolean {
+  if (offset === "Z") return true;
+  const match = offset.match(/^([+-])(\d{2}):(\d{2})$/);
+  if (!match) return false;
+  const hour = Number(match[2]);
+  const minute = Number(match[3]);
+  return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59;
+}
+
+function parseTimestampMilliseconds(value: string | number, unit: DateTimeFormatterUnit): number | undefined {
+  const numeric = typeof value === "string" ? Number(value) : value;
+  if (!Number.isInteger(numeric)) {
+    return undefined;
+  }
+  if (unit === "seconds" || unit === "milliseconds") {
+    return convertToMilliseconds(numeric, unit);
+  }
+  return isAutoTimestampValue(value, numeric) ? convertToMilliseconds(numeric, unit) : undefined;
+}
+
+function convertToMilliseconds(value: number, unit: DateTimeFormatterUnit): number {
+  return unit === "seconds" || (unit === "auto" && Math.abs(value) < 100_000_000_000) ? value * 1000 : value;
+}
+
+function isAutoTimestampValue(originalValue: string | number, numericValue: number): boolean {
+  if (!Number.isInteger(numericValue)) {
+    return false;
+  }
+  const digits = getTimestampDigits(originalValue);
+  if (digits !== 10 && digits !== 13) {
+    return false;
+  }
+  const yearFromTimestamp = dayjs(digits === 10 ? numericValue * 1000 : numericValue).year();
+  return yearFromTimestamp >= 1970 && yearFromTimestamp <= 2100;
+}
+
+function getTimestampDigits(value: string | number): number | undefined {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!isIntegerString(trimmed)) return undefined;
+    return trimmed.startsWith("-") ? trimmed.length - 1 : trimmed.length;
+  } else if (!Number.isInteger(value)) {
+    return undefined;
+  } else {
+    return Math.abs(value).toString().length;
+  }
+}
+
+function isIntegerString(value: string): boolean {
+  return /^-?\d+$/.test(value);
+}
+
+function formatJsonPath(value: CellValue, path: string): string {
+  if (value === null) return displayCellValue(value);
+  if (typeof value !== "string") return displayCellValue(value);
+  const parsed = JSON.parse(value);
+  const tokens = parseJsonPath(path);
+  let current: unknown = parsed;
+
+  for (const token of tokens) {
+    if (current == null) return "";
+    if (typeof token === "number") {
+      if (!Array.isArray(current)) return "";
+      current = current[token];
+    } else {
+      if (typeof current !== "object" || Array.isArray(current)) return "";
+      current = (current as Record<string, unknown>)[token];
+    }
+  }
+
+  if (current === undefined) return "";
+  if (current === null) return "NULL";
+  if (typeof current === "object") return JSON.stringify(current);
+  return String(current);
+}
+
+function formatMask(value: CellValue, formatter: Extract<ColumnFormatterConfig, { kind: "mask" }>): string {
+  if (value === null) return displayCellValue(value);
+  const text = displayCellValue(value);
+  const visibleCount = formatter.prefix + formatter.suffix;
+  if (text.length <= visibleCount) return "*".repeat(text.length);
+  return `${text.slice(0, formatter.prefix)}${"*".repeat(text.length - visibleCount)}${text.slice(text.length - formatter.suffix)}`;
+}
+
+function formatCustomTemplate(value: CellValue, template: string): string {
+  const text = displayCellValue(value);
+  return template.replaceAll("${value}", text).replaceAll("${upper}", text.toUpperCase()).replaceAll("${lower}", text.toLowerCase()).replaceAll("${length}", String(text.length));
+}
+
+function isSupportedJsonPath(path: string): boolean {
+  if (!path.startsWith("$")) return false;
+  try {
+    parseJsonPath(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function parseJsonPath(path: string): Array<string | number> {
+  const tokens: Array<string | number> = [];
+  let index = 1;
+
+  while (index < path.length) {
+    if (path[index] === ".") {
+      const match = path.slice(index + 1).match(/^[A-Za-z_$][\w$]*/);
+      if (!match) throw new Error("Invalid JSON path");
+      tokens.push(match[0]);
+      index += match[0].length + 1;
+      continue;
+    }
+    if (path[index] === "[") {
+      const match = path.slice(index).match(/^\[(\d+)\]/);
+      if (!match) throw new Error("Invalid JSON path");
+      tokens.push(Number(match[1]));
+      index += match[0].length;
+      continue;
+    }
+    throw new Error("Invalid JSON path");
+  }
+
+  return tokens;
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataCompare.ts b/apps/desktop/src/lib/dataGrid/dataCompare.ts
new file mode 100644
index 0000000..4cfdb6a
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataCompare.ts
@@ -0,0 +1,105 @@
+import type { ColumnInfo, DatabaseType, QueryResult } from "@/types/database";
+
+export type DataCompareCellValue = QueryResult["rows"][number][number];
+
+export interface DataCompareChangedCell {
+  column: string;
+  source: DataCompareCellValue;
+  target: DataCompareCellValue;
+}
+
+export interface DataCompareRow {
+  key: string;
+  keyValues: Record<string, DataCompareCellValue>;
+  values: Record<string, DataCompareCellValue>;
+}
+
+export interface DataCompareModifiedRow {
+  key: string;
+  keyValues: Record<string, DataCompareCellValue>;
+  sourceValues: Record<string, DataCompareCellValue>;
+  targetValues: Record<string, DataCompareCellValue>;
+  changes: DataCompareChangedCell[];
+}
+
+export interface DataCompareResult {
+  added: DataCompareRow[];
+  removed: DataCompareRow[];
+  modified: DataCompareModifiedRow[];
+}
+
+export interface DataComparePreparationOptions {
+  tableName: string;
+  schema?: string;
+  columns: string[];
+  keyColumns: string[];
+  columnInfo?: ColumnInfo[];
+  sourceRows: DataCompareCellValue[][];
+  targetRows: DataCompareCellValue[][];
+  databaseType?: DatabaseType;
+}
+
+export interface DataComparePreparation {
+  result: DataCompareResult;
+  syncStatements: string[];
+  syncSql: string;
+}
+
+export interface DataCompareFromTablesOptions {
+  sourceConnectionId: string;
+  sourceDatabase: string;
+  sourceSchema: string;
+  sourceTable: string;
+  targetConnectionId: string;
+  targetDatabase: string;
+  targetSchema: string;
+  targetTable: string;
+  columns: string[];
+  keyColumns: string[];
+  fetchBatchSize?: number;
+}
+
+export interface DataCompareMissingTargetOptions {
+  sourceConnectionId: string;
+  sourceDatabase: string;
+  sourceSchema: string;
+  sourceTable: string;
+  targetConnectionId: string;
+  targetDatabase: string;
+  targetSchema: string;
+  targetTable: string;
+  keyColumns: string[];
+  fetchBatchSize?: number;
+}
+
+export interface DataCompareFromTablesPreparation extends DataComparePreparation {
+  preSyncStatements: string[];
+  sourceRowCount: number;
+  targetRowCount: number;
+  sourceTruncated: boolean;
+  targetTruncated: boolean;
+}
+
+export interface DataCompareSyncPlanTableOptions {
+  tableName: string;
+  schema?: string;
+  columns: string[];
+  keyColumns: string[];
+  columnInfo?: ColumnInfo[];
+  diff: DataCompareResult;
+  databaseType?: DatabaseType;
+  preSyncStatements?: string[];
+}
+
+export interface DataCompareSyncPlanOptions {
+  tables: DataCompareSyncPlanTableOptions[];
+}
+
+export interface DataCompareSyncPlan {
+  insertCount: number;
+  updateCount: number;
+  deleteCount: number;
+  statementCount: number;
+  syncStatements: string[];
+  syncSql: string;
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGenerate.ts b/apps/desktop/src/lib/dataGrid/dataGenerate.ts
new file mode 100644
index 0000000..eda2693
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGenerate.ts
@@ -0,0 +1,1760 @@
+import type { DatabaseType } from "@/types/database";
+import { quoteTableIdentifier } from "@/lib/table/tableSelectSql";
+
+export interface GeneratorNode {
+  key: string;
+  label: string;
+  children?: GeneratorNode[];
+}
+
+export const GeneratorHierarchy: GeneratorNode[] = [
+  {
+    key: "general",
+    label: "通用",
+    children: [
+      { key: "number", label: "数字" },
+      { key: "datetime", label: "日期时间" },
+      { key: "date", label: "日期" },
+      { key: "time", label: "时间" },
+      { key: "sequence", label: "序列" },
+      { key: "enum", label: "枚举" },
+      { key: "text", label: "文本" },
+      { key: "image", label: "图像或二进制" },
+      { key: "foreign_key", label: "外键" },
+      { key: "uuid", label: "UUID" },
+      { key: "regex", label: "正则表达式" },
+    ],
+  },
+  {
+    key: "personal",
+    label: "个人",
+    children: [
+      { key: "full_name", label: "姓名" },
+      { key: "gender", label: "性别" },
+      { key: "title", label: "称谓" },
+      { key: "marital_status", label: "婚姻状况" },
+      { key: "phone", label: "电话号码" },
+      { key: "email", label: "电子邮箱" },
+      { key: "id_number", label: "证件号" },
+      { key: "job_title", label: "职位名称" },
+      { key: "social_id", label: "社交网络ID" },
+    ],
+  },
+  {
+    key: "payment",
+    label: "支付",
+    children: [
+      { key: "payment_method", label: "支付方式" },
+      { key: "credit_card_type", label: "信用卡类型" },
+      { key: "credit_card_number", label: "信用卡卡号" },
+      { key: "credit_card_date", label: "信用卡日期" },
+    ],
+  },
+  {
+    key: "business",
+    label: "商业",
+    children: [
+      { key: "company_name", label: "公司名称" },
+      { key: "department", label: "部门" },
+      { key: "industry", label: "行业" },
+    ],
+  },
+  {
+    key: "location",
+    label: "位置",
+    children: [
+      { key: "address", label: "地址" },
+      { key: "city", label: "城市" },
+      { key: "region", label: "地区" },
+    ],
+  },
+  {
+    key: "product",
+    label: "产品",
+    children: [
+      { key: "product_name", label: "产品名称" },
+      { key: "product_category", label: "产品类别" },
+      { key: "color", label: "颜色" },
+      { key: "size", label: "尺寸" },
+      { key: "weight_unit", label: "重量单位" },
+      { key: "barcode", label: "条码" },
+      { key: "sku", label: "SKU" },
+    ],
+  },
+  {
+    key: "computer",
+    label: "电脑",
+    children: [
+      { key: "ip_address", label: "IP地址" },
+      { key: "mac_address", label: "MAC地址" },
+      { key: "file_path", label: "文件路径" },
+      { key: "file_name", label: "文件名称" },
+      { key: "file_extension", label: "文件扩展名" },
+      { key: "url", label: "网址" },
+      { key: "hostname", label: "主机名" },
+    ],
+  },
+];
+
+export interface GeneratorParams {
+  // number / decimal
+  numberType?: "integer" | "decimal";
+  decimalPlaces?: number;
+  // range
+  start?: string;
+  end?: string;
+  min?: number;
+  max?: number;
+  // text
+  minLength?: number;
+  maxLength?: number;
+  textFormat?: "lorem" | "alphanumeric" | "hex" | "bcrypt" | "version" | "language" | "currency" | "slug" | "tag_list" | "level" | "channel";
+  // date/time
+  allDay?: boolean;
+  startTime?: string;
+  endTime?: string;
+  weekdayMode?: "all" | "weekday" | "custom";
+  weekdays?: number[];
+  // sequence
+  startValue?: number;
+  increment?: number;
+  sequenceMin?: number;
+  sequenceMax?: number;
+  sequenceCycle?: boolean;
+  // enum
+  values?: string;
+  // regex
+  pattern?: string;
+  rawPattern?: boolean;
+  // uuid
+  uuidHyphens?: boolean;
+  // name
+  nameFormat?: "full" | "last" | "first";
+  languages?: string[];
+  // phone
+  phoneFormat?: "domestic" | "international";
+  phoneSeparator?: boolean;
+  phoneRegions?: string[];
+  // email
+  emailDomains?: string;
+  // image
+  imageMode?: "generate" | "folder";
+  imageWidth?: number;
+  imageHeight?: number;
+  imageFormat?: "JPEG" | "PNG";
+  folderPath?: string;
+  fileExtensions?: string;
+  // foreign key
+  fkSchema?: string;
+  fkTable?: string;
+  fkField?: string;
+  fkMode?: "random" | "unique" | "repeat";
+  fkRepeatMin?: number;
+  fkRepeatMax?: number;
+  // credit card / payment
+  cardTypes?: string[];
+  ccDateFormat?: string;
+  ccYearOffsetMin?: number;
+  ccYearOffsetMax?: number;
+  // address / location
+  addressType?: string;
+  regions?: string[];
+  // region / country
+  regionFormat?: string;
+  regionLang?: string;
+  // id numbers
+  idTypes?: string[];
+  idCustomPattern?: string;
+  textTransform?: string;
+  // product
+  productKeywords?: string;
+  // barcode / sku
+  barcodeTypes?: string[];
+  // ip
+  ipType?: string;
+  // mac / file / url
+  pathTypes?: string[];
+  includeFileName?: boolean;
+  includeExtension?: boolean;
+  extensionCategory?: string;
+  urlSubdomains?: string;
+  urlTlds?: string;
+  // common options
+  includeDefault?: boolean;
+  defaultPercent?: number;
+  includeNull?: boolean;
+  nullPercent?: number;
+  unique?: boolean;
+  disableLinks?: boolean;
+}
+
+export interface GeneratedSqlExpression {
+  __dbxGeneratedSqlExpression: true;
+  sql: string;
+  display: string;
+}
+
+export interface ColumnGenerateConfig {
+  columnName: string;
+  dataType: string;
+  rowCount: number;
+  generatorKey?: string;
+  generatorLabel?: string;
+  generatorCategory?: string;
+  generatorCategoryLabel?: string;
+  generatorParams?: GeneratorParams;
+  isAutoIncrement?: boolean;
+  columnDefault?: string | null;
+}
+
+export interface TableGenerateConfig {
+  tableName: string;
+  schema: string;
+  database: string;
+  rowCount: number;
+  columns: ColumnGenerateConfig[];
+}
+
+const firstNames = ["James", "Mary", "John", "Patricia", "Robert", "Jennifer", "Michael", "Linda", "David", "Elizabeth", "William", "Barbara", "Richard", "Susan", "Joseph", "Jessica", "Thomas", "Sarah", "Christopher", "Karen"];
+const lastNames = ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis", "Rodriguez", "Martinez", "Hernandez", "Lopez", "Gonzalez", "Wilson", "Anderson", "Thomas", "Taylor", "Moore", "Jackson", "Martin"];
+const domains = ["gmail.com", "yahoo.com", "outlook.com", "example.com", "test.org"];
+
+function pick<T>(arr: T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+export function randInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randDigit(): number {
+  return Math.floor(Math.random() * 10);
+}
+export function randDecimal(min: number, max: number, decimals: number): number {
+  return parseFloat((Math.random() * (max - min) + min).toFixed(decimals));
+}
+
+export function isGeneratedSqlExpression(value: unknown): value is GeneratedSqlExpression {
+  return !!value && typeof value === "object" && (value as GeneratedSqlExpression).__dbxGeneratedSqlExpression === true;
+}
+
+function generatedSqlExpression(sql: string, display = sql): GeneratedSqlExpression {
+  return { __dbxGeneratedSqlExpression: true, sql, display };
+}
+
+function trimColumnDefault(defaultValue: string | null | undefined): string | null {
+  const value = defaultValue?.trim();
+  if (!value || value.toLowerCase() === "null") return null;
+  return value;
+}
+
+function isWrappedByOuterParens(value: string): boolean {
+  if (!value.startsWith("(") || !value.endsWith(")")) return false;
+  let depth = 0;
+  let quote: "'" | '"' | null = null;
+  for (let i = 0; i < value.length; i++) {
+    const ch = value[i];
+    if (quote) {
+      if (ch === quote) {
+        if (quote === "'" && value[i + 1] === "'") {
+          i++;
+        } else {
+          quote = null;
+        }
+      }
+      continue;
+    }
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      continue;
+    }
+    if (ch === "(") depth++;
+    if (ch === ")") depth--;
+    if (depth === 0 && i < value.length - 1) return false;
+  }
+  return depth === 0;
+}
+
+function stripOuterParens(value: string): string {
+  let current = value.trim();
+  while (isWrappedByOuterParens(current)) {
+    current = current.slice(1, -1).trim();
+  }
+  return current;
+}
+
+function parseSqlStringLiteral(value: string): string | null {
+  const text = stripOuterParens(value);
+  let start = 0;
+  if ((text[0] === "N" || text[0] === "n" || text[0] === "E" || text[0] === "e") && text[1] === "'") {
+    start = 1;
+  }
+  if (text[start] !== "'") return null;
+
+  let result = "";
+  for (let i = start + 1; i < text.length; i++) {
+    const ch = text[i];
+    if (ch !== "'") {
+      result += ch;
+      continue;
+    }
+    if (text[i + 1] === "'") {
+      result += "'";
+      i++;
+      continue;
+    }
+    const tail = text.slice(i + 1).trim();
+    if (!tail || /^::[\w."[\]\s]+$/.test(tail)) return result;
+    return null;
+  }
+  return null;
+}
+
+function isStringLikeType(dataType: string): boolean {
+  const type = dataType.toLowerCase();
+  return type.includes("char") || type.includes("text") || type.includes("clob") || type.includes("enum") || type.includes("set") || type.includes("uuid") || type.includes("guid") || type.includes("json") || type.includes("xml");
+}
+
+function isTemporalType(dataType: string): boolean {
+  const type = dataType.toLowerCase();
+  return type.includes("date") || type.includes("time") || type.includes("timestamp");
+}
+
+function looksLikeSqlDefaultExpression(value: string): boolean {
+  const text = stripOuterParens(value);
+  const lower = text.toLowerCase();
+  if (/^(current_timestamp|current_date|current_time|localtimestamp|localtime|sysdate|systimestamp)(\(\))?$/i.test(text)) {
+    return true;
+  }
+  if (/\b(nextval|now|uuid|random|rand|gen_random_uuid|uuid_generate_v4)\s*\(/i.test(text)) {
+    return true;
+  }
+  if (/^[a-z_][\w$]*(?:\.[a-z_][\w$]*)?\s*\(/i.test(text)) {
+    return true;
+  }
+  return lower.includes("::") || /\b(case|select)\b/i.test(text);
+}
+
+function generatedDefaultValue(defaultValue: string | null | undefined, dataType: string): unknown | undefined {
+  const trimmed = trimColumnDefault(defaultValue);
+  if (!trimmed) return undefined;
+
+  const value = stripOuterParens(trimmed);
+  const quoted = parseSqlStringLiteral(value);
+  if (quoted !== null) return quoted;
+
+  if (/^(true|false)$/i.test(value)) return value.toLowerCase() === "true";
+
+  if (/^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?$/i.test(value)) {
+    return Number(value);
+  }
+
+  if (isTemporalType(dataType) && /^\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?)?$/.test(value)) {
+    return value;
+  }
+
+  if (isStringLikeType(dataType) && !looksLikeSqlDefaultExpression(value)) {
+    return value;
+  }
+
+  // Keep expression defaults as raw SQL so functions like CURRENT_TIMESTAMP run in the database.
+  return generatedSqlExpression(value);
+}
+function parseLocalDate(str: string): Date {
+  const [y, m, d] = str.split("-").map(Number);
+  return new Date(y, m - 1, d);
+}
+
+function formatLocalDate(d: Date): string {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+function ensureRange(start: Date, end: Date): [Date, Date] {
+  if (start.getTime() > end.getTime()) {
+    console.warn("[dbx] date range reversed, swapping start/end", start, end);
+    return [end, start];
+  }
+  return [start, end];
+}
+
+function randDate(start: Date, end: Date): string {
+  [start, end] = ensureRange(start, end);
+  return formatLocalDate(new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime())));
+}
+
+function randTimestamp(start: Date, end: Date): string {
+  [start, end] = ensureRange(start, end);
+  const d = new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
+  const date = formatLocalDate(d);
+  const h = String(d.getHours()).padStart(2, "0");
+  const min = String(d.getMinutes()).padStart(2, "0");
+  const s = String(d.getSeconds()).padStart(2, "0");
+  return `${date} ${h}:${min}:${s}`;
+}
+function pad2(n: number): string {
+  return String(n).padStart(2, "0");
+}
+
+// Credit card data
+const ccPrefixMap: Record<string, string[]> = {
+  american_express: ["34", "37"],
+  jcb: ["3528", "3529", "3530", "3531", "3532", "3533", "3534", "3535", "3536", "3537", "3538", "3539"],
+  mastercard: ["51", "52", "53", "54", "55", "2221", "2222", "2223", "2224", "2225", "2226", "2227", "2228", "2229", "23", "24", "25", "26", "270", "271", "2720"],
+  unionpay: ["62", "623", "624", "625", "626", "627", "628"],
+  visa: ["4"],
+};
+const ccLengthMap: Record<string, number> = {
+  american_express: 15,
+  jcb: 16,
+  mastercard: 16,
+  unionpay: 16,
+  visa: 16,
+};
+const ccLabelMap: Record<string, string> = {
+  american_express: "American Express",
+  jcb: "JCB",
+  mastercard: "MasterCard",
+  unionpay: "UnionPay",
+  visa: "Visa",
+};
+
+function luhnCheck(numStr: string): boolean {
+  let sum = 0;
+  let shouldDouble = false;
+  for (let i = numStr.length - 1; i >= 0; i--) {
+    let d = parseInt(numStr.charAt(i), 10);
+    if (shouldDouble) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+    shouldDouble = !shouldDouble;
+  }
+  return sum % 10 === 0;
+}
+
+function generateLuhnCard(prefix: string, length: number): string {
+  const body: number[] = prefix.split("").map((c) => parseInt(c, 10));
+  while (body.length < length - 1) body.push(randDigit());
+  for (let check = 0; check < 10; check++) {
+    const candidate = body.join("") + String(check);
+    if (luhnCheck(candidate)) return candidate;
+  }
+  return body.join("") + "0";
+}
+
+// Company name word banks
+const companyPrefixes: Record<string, string[]> = {
+  en: ["Alpha", "Beta", "Global", "Prime", "Apex", "Nexus", "Atlas", "Vertex", "Zenith", "Acme"],
+  zh_pinyin: ["Hua", "Zhong", "Da", "Xin", "Guo", "Tai", "Sheng", "Long", "Dong", "Nan"],
+  zh_eng: ["Hua", "Zhong", "Da", "Xin", "Great", "New", "China", "Oriental", "Pacific", "Golden"],
+  zh_hans: ["华", "中", "大", "新", "国", "泰", "盛", "龙", "东方", "金"],
+  ja_romaji: ["Abe", "Sato", "Suzuki", "Takahashi", "Tanaka", "Watanabe", "Ito", "Yamamoto"],
+  ja: ["アベ", "サトウ", "スズキ", "タカハシ", "タナカ", "ワタナベ"],
+};
+const companyMiddles: Record<string, string[]> = {
+  en: ["Consulting", "Technologies", "Solutions", "Enterprises", "Industries", "Systems", "Holdings", "Services", "Digital", "Media"],
+  zh_pinyin: ["Keji", "Shangmao", "Gongcheng", "Fuwu", "Zixun", "Chuangxin", "Touzi", "Wenhua", "Dianzi"],
+  zh_eng: ["Tech", "Trading", "Industry", "Services", "Consulting", "Investment", "Digital", "Media", "Enterprise"],
+  zh_hans: ["科技", "商贸", "工程", "服务", "咨询", "创新", "投资", "文化", "电子"],
+  ja_romaji: ["Kigyo", "Sangyo", "Service", "Tech", "Consulting", "Media", "Digital", "System"],
+  ja: ["企業", "産業", "サービス", "テック", "コンサルティング", "メディア"],
+};
+const companySuffixes: Record<string, string[]> = {
+  en: ["Inc.", "Ltd.", "Corporation", "Company", "LLC", "Group"],
+  zh_pinyin: ["Gongsi", "Jituan", "Youxian gongsi"],
+  zh_eng: ["Co., Ltd.", "Inc.", "Ltd.", "Corporation", "Group"],
+  zh_hans: ["有限公司", "股份有限公司", "集团", "公司"],
+  ja_romaji: ["K.K.", "Co., Ltd.", "Kabushiki-gaisha"],
+  ja: ["株式会社", "合同会社", "有限会社"],
+};
+
+function generateCompanyName(lang: string): string {
+  const pf = companyPrefixes[lang] ?? companyPrefixes["en"];
+  const md = companyMiddles[lang] ?? companyMiddles["en"];
+  const sf = companySuffixes[lang] ?? companySuffixes["en"];
+  return `${pick(pf)} ${pick(md)} ${pick(sf)}`.trim();
+}
+
+// Department / industry data
+const departmentByLang: Record<string, string[]> = {
+  en: ["Engineering", "Marketing", "Sales", "Human Resources", "Finance", "Operations", "Research and Development", "Customer Support", "Legal", "IT", "Design", "Purchasing"],
+  zh: ["研发部", "市场部", "销售部", "人力资源部", "财务部", "运营部", "研发中心", "客户支持部", "法务部", "信息技术部", "设计部", "采购部"],
+  zh_hant: ["研發部", "市場部", "銷售部", "人力資源部", "財務部", "營運部", "研發中心", "客戶支援部", "法務部", "資訊技術部", "設計部", "採購部"],
+  ja: ["エンジニアリング", "マーケティング", "営業", "人事", "経理", "オペレーション", "研究開発", "カスタマーサポート", "法務", "IT", "デザイン", "購買"],
+};
+
+const industryByLang: Record<string, string[]> = {
+  en: ["Technology", "Healthcare", "Finance", "Education", "Manufacturing", "Retail", "Media", "Energy", "Real Estate", "Transportation", "Telecommunications", "Agriculture", "Hospitality", "Pharmaceutical", "Automotive", "Logistics", "Construction", "Entertainment"],
+  zh: ["科技", "医疗保健", "金融", "教育", "制造业", "零售", "媒体", "能源", "房地产", "交通运输", "电信", "农业", "酒店业", "制药", "汽车", "物流", "建筑", "娱乐"],
+  zh_hant: ["科技", "醫療保健", "金融", "教育", "製造業", "零售", "媒體", "能源", "房地產", "交通運輸", "電信", "農業", "酒店業", "製藥", "汽車", "物流", "建築", "娛樂"],
+  ja: ["テクノロジー", "医療", "金融", "教育", "製造業", "小売", "メディア", "エネルギー", "不動産", "運輸", "通信", "農業", "ホスピタリティ", "製薬", "自動車", "物流", "建設", "エンターテイメント"],
+};
+
+// Address data
+const addressStreets: Record<string, string[]> = {
+  us: ["Main St", "Oak Ave", "Elm Rd", "Park Blvd", "Lake Dr", "Hill St", "Washington Blvd", "2nd Ave"],
+  uk: ["Oxford Street", "Abbey Road", "Baker Street", "Piccadilly", "Downing Street", "Regent Street"],
+  cn: ["No. 88, YuShuang Road", "No. 128, Nanjing West Road", "No. 56, RenMin Avenue", "No. 201, ZhongShan Road"],
+  jp: ["1-1-1, Marunouchi", "2-3-1, Shibuya", "3-2-1, Ginza", "1-5-2, Shinjuku"],
+};
+const addressApts: Record<string, string[]> = {
+  us: ["Apt #203", "Unit 5", "Suite 300", "#4B", "Floor 7"],
+  uk: ["Flat 3", "Apartment 5B", "Studio 2", "Suite 12"],
+  cn: ["Building A, Unit 301", "Room 202, Block B", "Unit 1105"],
+  jp: ["Building #2, 3F", "Room 402", "Tower A, 15F"],
+};
+
+function generateAddress(type: string, region: string): string {
+  const streets = addressStreets[region] ?? addressStreets["us"];
+  const apts = addressApts[region] ?? addressApts["us"];
+  if (type === "line1") {
+    if (region === "cn" || region === "jp") return pick(streets);
+    return `${randInt(1, 9999)} ${pick(streets)}`;
+  }
+  if (type === "line2") return pick(apts);
+  if (region === "cn" || region === "jp") return `${randInt(1, 999)} ${pick(streets)}, ${pick(apts)}`;
+  return `${randInt(1, 9999)} ${pick(streets)}, ${pick(apts)}`;
+}
+
+// City data
+const cityData: Record<string, { en: string; native: string }[]> = {
+  us: [
+    { en: "New York", native: "New York" },
+    { en: "Los Angeles", native: "Los Angeles" },
+    { en: "Chicago", native: "Chicago" },
+    { en: "San Francisco", native: "San Francisco" },
+    { en: "Boston", native: "Boston" },
+    { en: "Seattle", native: "Seattle" },
+    { en: "Washington, D.C.", native: "Washington, D.C." },
+    { en: "Miami", native: "Miami" },
+  ],
+  uk: [
+    { en: "London", native: "London" },
+    { en: "Manchester", native: "Manchester" },
+    { en: "Birmingham", native: "Birmingham" },
+    { en: "Liverpool", native: "Liverpool" },
+    { en: "Edinburgh", native: "Edinburgh" },
+    { en: "Glasgow", native: "Glasgow" },
+  ],
+  cn: [
+    { en: "Beijing", native: "北京" },
+    { en: "Shanghai", native: "上海" },
+    { en: "Guangzhou", native: "广州" },
+    { en: "Shenzhen", native: "深圳" },
+    { en: "Chengdu", native: "成都" },
+    { en: "Hangzhou", native: "杭州" },
+    { en: "Nanjing", native: "南京" },
+    { en: "Xi'an", native: "西安" },
+  ],
+  jp: [
+    { en: "Tokyo", native: "東京" },
+    { en: "Osaka", native: "大阪" },
+    { en: "Kyoto", native: "京都" },
+    { en: "Yokohama", native: "横浜" },
+    { en: "Nagoya", native: "名古屋" },
+    { en: "Sapporo", native: "札幌" },
+    { en: "Fukuoka", native: "福岡" },
+  ],
+};
+
+// Country / region data
+const countryData: Array<{ code: string; en: string; zh: string; zh_hant: string; ja: string }> = [
+  { code: "US", en: "United States", zh: "美国", zh_hant: "美國", ja: "アメリカ合衆国" },
+  { code: "CN", en: "China", zh: "中国", zh_hant: "中國", ja: "中国" },
+  { code: "JP", en: "Japan", zh: "日本", zh_hant: "日本", ja: "日本" },
+  { code: "GB", en: "United Kingdom", zh: "英国", zh_hant: "英國", ja: "イギリス" },
+  { code: "DE", en: "Germany", zh: "德国", zh_hant: "德國", ja: "ドイツ" },
+  { code: "FR", en: "France", zh: "法国", zh_hant: "法國", ja: "フランス" },
+  { code: "CA", en: "Canada", zh: "加拿大", zh_hant: "加拿大", ja: "カナダ" },
+  { code: "AU", en: "Australia", zh: "澳大利亚", zh_hant: "澳洲", ja: "オーストラリア" },
+  { code: "IN", en: "India", zh: "印度", zh_hant: "印度", ja: "インド" },
+  { code: "BR", en: "Brazil", zh: "巴西", zh_hant: "巴西", ja: "ブラジル" },
+  { code: "RU", en: "Russia", zh: "俄罗斯", zh_hant: "俄羅斯", ja: "ロシア" },
+  { code: "KR", en: "South Korea", zh: "韩国", zh_hant: "韓國", ja: "韓国" },
+  { code: "IT", en: "Italy", zh: "意大利", zh_hant: "意大利", ja: "イタリア" },
+  { code: "ES", en: "Spain", zh: "西班牙", zh_hant: "西班牙", ja: "スペイン" },
+  { code: "MX", en: "Mexico", zh: "墨西哥", zh_hant: "墨西哥", ja: "メキシコ" },
+];
+
+// Product data
+const productCategoryByLang: Record<string, string[]> = {
+  en: ["Electronics", "Clothing", "Food", "Books", "Home Goods", "Sports", "Toys", "Beauty", "Furniture", "Automotive", "Garden", "Pet Supplies", "Video Games", "Music Instruments", "Office Supplies"],
+  zh: ["电子", "服装", "食品", "图书", "家居", "运动", "玩具", "美妆", "家具", "汽车用品", "园艺", "宠物用品", "视频游戏", "乐器", "办公用品"],
+  zh_hant: ["電子", "服裝", "食品", "圖書", "家居", "運動", "玩具", "美妝", "家具", "汽車用品", "園藝", "寵物用品", "視頻遊戲", "樂器", "辦公用品"],
+  ja: ["電子機器", "衣料品", "食品", "書籍", "家財", "スポーツ", "玩具", "美容", "家具", "自動車用品", "ガーデニング", "ペット用品", "ビデオゲーム", "楽器", "オフィス用品"],
+};
+
+const colorByLang: Record<string, string[]> = {
+  en: ["Red", "Blue", "Green", "Black", "White", "Yellow", "Purple", "Orange", "Pink", "Brown", "Gray", "Cyan", "Jasmine", "Teal", "Maroon", "Navy", "Olive", "Coral"],
+  zh: ["红色", "蓝色", "绿色", "黑色", "白色", "黄色", "紫色", "橙色", "粉色", "棕色", "灰色", "青色", "茉莉色", "蓝绿色", "褐红色", "藏青", "橄榄", "珊瑚色"],
+  zh_hant: ["紅色", "藍色", "綠色", "黑色", "白色", "黃色", "紫色", "橙色", "粉色", "棕色", "灰色", "青色", "茉莉色", "藍綠色", "褐紅色", "藏青", "橄欖", "珊瑚色"],
+  ja: ["赤", "青", "緑", "黒", "白", "黄色", "紫", "オレンジ", "ピンク", "茶色", "灰色", "シアン", "ジャスミン", "ティール", "えんじ色", "ネイビー", "オリーブ", "コーラル"],
+};
+
+const sizeByLang: Record<string, string[]> = {
+  en: ["XS", "S", "M", "L", "XL", "XXL", "XXXL", "One Size"],
+  zh: ["特小", "小", "中", "大", "加大", "特大", "超特大", "均码"],
+  zh_hant: ["特小", "小", "中", "大", "加大", "特大", "超特大", "均碼"],
+  ja: ["XS", "S", "M", "L", "XL", "XXL", "XXXL", "フリーサイズ"],
+};
+
+function jumbleWord(word: string): string {
+  const letters = word.split("");
+  for (let i = letters.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [letters[i], letters[j]] = [letters[j], letters[i]];
+  }
+  return letters.join("");
+}
+
+function randFromCharSet(charSet: string, n: number): string {
+  return Array.from({ length: n }, () => charSet.charAt(Math.floor(Math.random() * charSet.length))).join("");
+}
+
+function generateBarcode(type: string): string {
+  const digits = (n: number) => Array.from({ length: n }, () => Math.floor(Math.random() * 10).toString()).join("");
+  switch (type) {
+    case "ean8":
+      return digits(8);
+    case "ean13":
+      return digits(13);
+    case "upca":
+      return digits(12);
+    case "upce":
+      return digits(6);
+    case "isbn":
+      return `978${digits(10)}`;
+    case "code39": {
+      const letters = Array.from({ length: 3 }, () => String.fromCharCode(65 + Math.floor(Math.random() * 26))).join("");
+      return `${letters}-${digits(4)}`;
+    }
+    default:
+      return digits(13);
+  }
+}
+
+function generateSkuFromPattern(pattern: string): string {
+  const letterCharSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const digitCharSet = "0123456789";
+  let result = "";
+  const tokens = pattern.split(/([{}[\]-])/).filter(Boolean);
+  let i = 0;
+  while (i < tokens.length) {
+    const t = tokens[i];
+    if (t === "(" || t === ")") {
+      i++;
+      continue;
+    }
+    if (t === "[") {
+      const charSetToken = tokens[i + 1];
+      i += 2;
+      let charSet = "";
+      if (charSetToken?.includes("A-F") || charSetToken?.includes("A-Z")) {
+        charSet = letterCharSet;
+      } else if (charSetToken?.includes("0-9")) {
+        charSet = digitCharSet;
+      } else {
+        charSet = letterCharSet + digitCharSet;
+      }
+      i++;
+      let count = 1;
+      if (tokens[i] === "{") {
+        i++;
+        count = parseInt(tokens[i], 10) || 1;
+        i += 2;
+      }
+      result += randFromCharSet(charSet, count);
+      continue;
+    }
+    if (t === "-") {
+      result += "-";
+      i++;
+      continue;
+    }
+    i++;
+  }
+  if (!result) {
+    return `${randFromCharSet("ABCDEF", 2)}-${randFromCharSet("ABCDEF", 2)}-${randFromCharSet("0123456789", 4)}-${randFromCharSet("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 1)}`;
+  }
+  return result;
+}
+
+function generateIPv6(): string {
+  const groups: string[] = [];
+  for (let i = 0; i < 8; i++) {
+    groups.push(
+      Math.floor(Math.random() * 65536)
+        .toString(16)
+        .padStart(4, "0"),
+    );
+  }
+  return groups.join(":");
+}
+
+// ============================================================
+// ID Numbers (证件号)
+// ============================================================
+
+const areaCodes = [
+  "110101",
+  "110105",
+  "110108",
+  "120101",
+  "120103",
+  "130102",
+  "130105",
+  "210102",
+  "210105",
+  "210203",
+  "310101",
+  "310104",
+  "310115",
+  "320102",
+  "320105",
+  "330102",
+  "330106",
+  "340102",
+  "340104",
+  "350102",
+  "360102",
+  "370102",
+  "370202",
+  "410102",
+  "410105",
+  "420102",
+  "420106",
+  "430102",
+  "440103",
+  "440106",
+  "440303",
+  "440305",
+  "450102",
+  "460105",
+  "500103",
+  "510104",
+  "510107",
+  "520102",
+  "530102",
+  "540102",
+  "610103",
+  "620102",
+  "630102",
+  "640104",
+  "650102",
+];
+
+function generateIdCard(): string {
+  const area = pick(areaCodes);
+  const year = randInt(1960, 2005).toString();
+  const month = randInt(1, 12).toString().padStart(2, "0");
+  const day = randInt(1, 28).toString().padStart(2, "0");
+  const seq = randInt(1, 999).toString().padStart(3, "0");
+  const first17 = `${area}${year}${month}${day}${seq}`;
+  const weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
+  const checks = ["1", "0", "X", "9", "8", "7", "6", "5", "4", "3", "2"];
+  let sum = 0;
+  for (let i = 0; i < 17; i++) sum += parseInt(first17[i]) * weights[i];
+  const check = checks[sum % 11];
+  return `${first17}${check}`;
+}
+
+function generatePassport(): string {
+  const prefixes = ["E", "G", "E", "E", "E", "H", "P"];
+  const prefix = pick(prefixes);
+  const digits = Array.from({ length: 7 }, () => Math.floor(Math.random() * 10).toString()).join("");
+  return `${prefix}${digits}`;
+}
+
+function generateHKMacauPass(): string {
+  const prefixes = ["C", "W", "H"];
+  const prefix = pick(prefixes);
+  const digits = Array.from({ length: 8 }, () => Math.floor(Math.random() * 10).toString()).join("");
+  return `${prefix}${digits}`;
+}
+
+function generateTaiwanPass(): string {
+  const digits = Array.from({ length: 8 }, () => Math.floor(Math.random() * 10).toString()).join("");
+  return `T${digits}`;
+}
+
+function generateUSCC(): string {
+  const firstPart = "91310115MA";
+  const randChars = randFromCharSet("ABCDEFGHJKLMNPQRSTUVWXY23456789", 6);
+  const randDigits = Array.from({ length: 4 }, () => Math.floor(Math.random() * 10).toString()).join("");
+  return `${firstPart}${randChars}${randDigits}`;
+}
+
+const bankBins = ["622202", "622700", "621700", "622848", "621559", "621798", "622208", "622280", "621661", "621785", "622838", "622510", "622698", "622690", "622556", "622588", "621286", "622218", "622506", "622622", "622696", "621483", "621299", "622155", "622156"];
+
+function luhnCalculateCheckDigit(numStr: string): string {
+  let sum = 0;
+  const digits = numStr.split("").map(Number);
+  for (let i = 0; i < digits.length; i++) {
+    let d = digits[digits.length - 1 - i];
+    if (i % 2 === 0) {
+      d *= 2;
+      if (d > 9) d -= 9;
+    }
+    sum += d;
+  }
+  const check = (10 - (sum % 10)) % 10;
+  return check.toString();
+}
+
+function generateBankCard(): string {
+  const bin = pick(bankBins);
+  const middle = Array.from({ length: 10 }, () => Math.floor(Math.random() * 10).toString()).join("");
+  const first15 = `${bin}${middle}`;
+  const check = luhnCalculateCheckDigit(first15);
+  return `${first15}${check}`;
+}
+
+function generateDriversLicense(): string {
+  return generateIdCard();
+}
+
+function generateIdNumber(params?: GeneratorParams): string {
+  const types = params?.idTypes?.length ? params.idTypes : ["id_card"];
+  const type = pick(types);
+  switch (type) {
+    case "id_card":
+      return generateIdCard();
+    case "passport":
+      return generatePassport();
+    case "hk_macau_pass":
+      return generateHKMacauPass();
+    case "taiwan_pass":
+      return generateTaiwanPass();
+    case "uscc":
+      return generateUSCC();
+    case "bank_card":
+      return generateBankCard();
+    case "drivers_license":
+      return generateDriversLicense();
+    case "custom":
+      if (params?.idCustomPattern) return generateSkuFromPattern(params.idCustomPattern);
+      return Array.from({ length: 10 }, () => Math.floor(Math.random() * 10).toString()).join("");
+    default:
+      return generateIdCard();
+  }
+}
+
+// Extension categories
+const extensionCategoryMap: Record<string, string[]> = {
+  image: [".jpg", ".jpeg", ".png", ".gif", ".bmp", ".svg", ".webp", ".tiff"],
+  document: [".txt", ".pdf", ".doc", ".docx", ".rtf", ".odt"],
+  spreadsheet: [".xls", ".xlsx", ".csv", ".ods", ".tsv"],
+  presentation: [".ppt", ".pptx", ".odp", ".key"],
+  audio: [".mp3", ".wav", ".flac", ".aac", ".ogg", ".m4a"],
+  video: [".mp4", ".avi", ".mov", ".mkv", ".wmv", ".flv"],
+  code: [".js", ".ts", ".py", ".java", ".cpp", ".c", ".h", ".rs", ".go", ".rb", ".php"],
+  archive: [".zip", ".rar", ".7z", ".tar", ".gz", ".bz2"],
+  web: [".html", ".htm", ".css", ".json", ".xml", ".yml", ".yaml"],
+  database: [".db", ".sqlite", ".sql", ".mdb", ".accdb"],
+};
+
+function splitLines(text: string): string[] {
+  return text
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function generateFilePath(params?: GeneratorParams): string {
+  const cat = params?.extensionCategory ?? "image";
+  const exts = extensionCategoryMap[cat] ?? extensionCategoryMap.image;
+  const ext = pick(exts);
+  const types = params?.pathTypes?.length ? params.pathTypes : ["linux"];
+  const t = pick(types);
+  const includeName = params?.includeFileName ?? true;
+  const nameBases = ["report", "doc", "img", "photo", "backup", "config", "data", "file"];
+  const randNum = randInt(1, 999999);
+  const fileName = `${pick(nameBases)}_${randNum}${ext}`;
+  if (t === "windows") {
+    const baseDirs = ["Users", "Program Files", "ProgramData", "Windows", "Temp"];
+    const userDirs = ["Administrator", "User", "Admin", "Guest"];
+    const folders = ["Documents", "Downloads", "Pictures", "Music", "Videos", "Desktop"];
+    const base = `C:\\${pick(baseDirs)}\\${pick(userDirs)}\\${pick(folders)}`;
+    return includeName ? `${base}\\${fileName}` : base;
+  }
+  if (t === "macos") {
+    const users = ["administrator", "user", "admin", "guest"];
+    const folders = ["Documents", "Downloads", "Pictures", "Music", "Movies", "Desktop", "Library", "Applications"];
+    const base = `/Users/${pick(users)}/${pick(folders)}`;
+    return includeName ? `${base}/${fileName}` : base;
+  }
+  const baseDirs = ["home", "opt", "var", "usr", "tmp", "root"];
+  const users = ["user", "admin", "root", "ubuntu", "deploy"];
+  const folders = ["documents", "downloads", "pictures", "music", "videos", "projects", "data", "logs"];
+  const bd = pick(baseDirs);
+  const base = bd === "home" ? `/home/${pick(users)}/${pick(folders)}` : `/${bd}/${pick(folders)}`;
+  return includeName ? `${base}/${fileName}` : base;
+}
+
+function generateFileName(params?: GeneratorParams): string {
+  const nameBases = ["report", "photo", "backup", "config", "data", "file", "doc", "img", "project", "output", "result"];
+  const base = pick(nameBases);
+  const num = randInt(1, 999999);
+  if (!params?.includeExtension) return `${base}_${num}`;
+  const cat = params?.extensionCategory ?? "image";
+  const exts = extensionCategoryMap[cat] ?? extensionCategoryMap.image;
+  return `${base}_${num}${pick(exts)}`;
+}
+
+function generateFileExtension(params?: GeneratorParams): string {
+  const cat = params?.extensionCategory ?? "image";
+  const exts = extensionCategoryMap[cat] ?? extensionCategoryMap.image;
+  return pick(exts);
+}
+
+function generateUrl(params?: GeneratorParams): string {
+  const defaultSubs = ["auth.", "drive.", "image.", "www.", "api.", "mail.", "shop.", "blog."];
+  const defaultTlds = [".biz", ".co.jp", ".com", ".cn", ".org", ".net", ".io", ".dev", ".xyz"];
+  const baseDomains = ["example", "test", "demo", "sample", "meyer80", "acme", "contoso", "fabrikam"];
+  const paths = ["ToysGames", "home", "about", "products", "login", "dashboard", "items", "search", "profile", "settings"];
+  const subs = params?.urlSubdomains ? splitLines(params.urlSubdomains) : defaultSubs;
+  const tlds = params?.urlTlds ? splitLines(params.urlTlds) : defaultTlds;
+  const sub = subs.length ? pick(subs) : "www.";
+  const tld = tlds.length ? pick(tlds) : ".com";
+  return `https://${sub}${pick(baseDomains)}${tld}/${pick(paths)}`;
+}
+
+function generateHostname(params?: GeneratorParams): string {
+  const defaultSubs = ["auth.", "drive.", "image.", "www.", "api.", "mail.", "shop.", "blog."];
+  const defaultTlds = [".biz", ".co.jp", ".com", ".cn", ".org", ".net", ".io", ".dev", ".xyz"];
+  const baseDomains = ["example", "test", "demo", "sample", "meyer80", "acme", "contoso", "fabrikam"];
+  const subs = params?.urlSubdomains ? splitLines(params.urlSubdomains) : defaultSubs;
+  const tlds = params?.urlTlds ? splitLines(params.urlTlds) : defaultTlds;
+  const sub = subs.length ? pick(subs) : "www.";
+  const tld = tlds.length ? pick(tlds) : ".com";
+  return `${sub}${pick(baseDomains)}${tld}`;
+}
+
+function transformText(text: string, mode: string): string {
+  if (mode === "upper") return text.toUpperCase();
+  if (mode === "lower") return text.toLowerCase();
+  if (mode === "title") return text.replace(/\w\S*/g, (w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase());
+  return text;
+}
+
+function generateEmail(): string {
+  return `${pick(firstNames).toLowerCase()}.${pick(lastNames).toLowerCase()}@${pick(domains)}`;
+}
+function generatePhone(): string {
+  return `+1${randInt(200, 999)}${randInt(100, 999)}${randInt(1000, 9999)}`;
+}
+function generateIP(): string {
+  return `${randInt(1, 255)}.${randInt(0, 255)}.${randInt(0, 255)}.${randInt(1, 255)}`;
+}
+function generateMAC(): string {
+  return Array.from({ length: 6 }, () => randInt(0, 255).toString(16).padStart(2, "0").toUpperCase()).join(":");
+}
+
+function pickLang(languages: string[] | undefined, fallback: string): string {
+  if (languages && languages.length) return pick(languages);
+  return fallback;
+}
+
+function formatFullName(first: string, last: string, lang: string): string {
+  const cjkNative = new Set(["zh_hans", "zh_hant", "ja"]);
+  const cjkRomanized = new Set(["zh_pinyin", "ja_romaji"]);
+  if (cjkNative.has(lang)) return `${last}${first}`;
+  if (cjkRomanized.has(lang)) return `${last} ${first}`;
+  return `${first} ${last}`;
+}
+
+const GeneratorFunctions: Record<string, (params?: GeneratorParams) => string> = {
+  full_name: (params) => {
+    const lang = params?.languages?.[0] ?? "en";
+    const fnMap: Record<string, string[]> = {
+      en: firstNames,
+      zh_hans: ["伟", "芳", "娜", "秀英", "敏", "静", "丽", "强", "磊", "洋"],
+      zh_hant: ["偉", "芳", "娜", "秀英", "敏", "靜", "麗", "強", "磊", "洋"],
+      ja: ["翼", "桜", "翔太", "美咲", "蓮", "結菜", "大輔", "陽子"],
+    };
+    const lnMap: Record<string, string[]> = {
+      en: lastNames,
+      zh_hans: ["王", "李", "张", "刘", "陈", "杨", "赵", "黄"],
+      zh_hant: ["王", "李", "張", "劉", "陳", "楊", "趙", "黃"],
+      ja: ["佐藤", "鈴木", "高橋", "田中", "渡辺"],
+    };
+    const fn = pick(fnMap[lang] ?? firstNames);
+    const ln = pick(lnMap[lang] ?? lastNames);
+    const fmt = params?.nameFormat ?? "full";
+    if (fmt === "first") return fn;
+    if (fmt === "last") return ln;
+    return formatFullName(fn, ln, lang);
+  },
+  email: generateEmail,
+  phone: generatePhone,
+  gender: (params) => {
+    const lang = params?.languages?.[0] ?? "en";
+    const map: Record<string, string[]> = {
+      en: ["Male", "Female"],
+      zh: ["男", "女"],
+      zh_hant: ["男", "女"],
+      ja: ["男性", "女性"],
+    };
+    return pick(map[lang] ?? map["en"]);
+  },
+  title: () => pick(["Mr.", "Ms.", "Dr.", "Prof."]),
+  marital_status: (params) => {
+    const lang = params?.languages?.[0] ?? "en";
+    const map: Record<string, string[]> = {
+      en: ["Single", "Married", "Divorced", "Widowed"],
+      zh: ["未婚", "已婚", "离异", "丧偶"],
+      zh_hant: ["未婚", "已婚", "離異", "喪偶"],
+      ja: ["未婚", "既婚", "離婚", "死別"],
+    };
+    return pick(map[lang] ?? map["en"]);
+  },
+  job_title: (params) => {
+    const lang = params?.languages?.[0] ?? "en";
+    const map: Record<string, string[]> = {
+      en: ["Software Engineer", "Senior Manager", "Product Designer", "Data Analyst", "DevOps Engineer", "HR Director", "Marketing Lead"],
+      zh: ["软件工程师", "高级经理", "产品设计师", "数据分析师", "运维工程师"],
+      zh_hant: ["軟體工程師", "高級經理", "產品設計師"],
+      ja: ["ソフトウェアエンジニア", "シニアマネージャー", "プロダクトデザイナー"],
+    };
+    return pick(map[lang] ?? map["en"]);
+  },
+  social_id: () => `SN${randInt(100000, 999999)}`,
+  payment_method: (params) => {
+    const vals = (params?.values ?? "Credit Card\nPayPal\nApple Pay\nGoogle Pay\nBank Transfer\nCash\nCryptocurrency")
+      .split("\n")
+      .map((s) => s.trim())
+      .filter(Boolean);
+    return vals.length ? pick(vals) : "Credit Card";
+  },
+  credit_card_type: (params) => {
+    const selected = params?.cardTypes?.length ? params.cardTypes : Object.keys(ccLabelMap);
+    const key = pick(selected);
+    return ccLabelMap[key] ?? "Visa";
+  },
+  credit_card_number: (params) => {
+    const selected = params?.cardTypes?.length ? params.cardTypes : ["visa"];
+    const key = pick(selected);
+    const prefix = pick(ccPrefixMap[key] ?? ccPrefixMap["visa"]);
+    const length = ccLengthMap[key] ?? 16;
+    return generateLuhnCard(prefix, length);
+  },
+  credit_card_date: (params) => {
+    const fmt = params?.ccDateFormat ?? "MM/YY";
+    const now = new Date();
+    const yearBase = now.getFullYear() + randInt(params?.ccYearOffsetMin ?? 0, params?.ccYearOffsetMax ?? 5);
+    const month = randInt(1, 12);
+    switch (fmt) {
+      case "MM/YYYY":
+        return `${pad2(month)}/${yearBase}`;
+      case "YYYY-MM":
+        return `${yearBase}-${pad2(month)}`;
+      case "MM/YY":
+      default:
+        return `${pad2(month)}/${pad2(yearBase % 100)}`;
+    }
+  },
+  company_name: (params) => generateCompanyName(pickLang(params?.languages, "en")),
+  department: (params) => pick(departmentByLang[pickLang(params?.languages, "en")] ?? departmentByLang["en"]),
+  industry: (params) => pick(industryByLang[pickLang(params?.languages, "en")] ?? industryByLang["en"]),
+  address: (params) => {
+    const regions = params?.regions?.length ? params.regions : ["us"];
+    const region = pick(regions);
+    return generateAddress(params?.addressType ?? "line1", region);
+  },
+  city: (params) => {
+    const regions = params?.regions?.length ? params.regions : ["us"];
+    const region = pick(regions);
+    const city = pick(cityData[region] ?? cityData["us"]);
+    const lang = params?.languages?.[0] ?? "en";
+    return lang === "native" ? city.native : city.en;
+  },
+  region: (params) => {
+    const country = pick(countryData);
+    const lang = params?.regionLang ?? "en";
+    const fmt = params?.regionFormat ?? "name";
+    const tf = params?.textTransform ?? "none";
+    let text = "";
+    if (fmt === "code") text = country.code;
+    else if (fmt === "code_name") text = `${country.code} - ${(country as any)[lang] ?? country.en}`;
+    else text = (country as any)[lang] ?? country.en;
+    return transformText(text, tf);
+  },
+  product_name: (params) => {
+    const keywords = (params?.productKeywords ?? "")
+      .split("\n")
+      .map((s) => s.trim())
+      .filter(Boolean);
+    if (keywords.length === 0) return `${pick(["Premium", "Basic", "Ultra", "Standard"])} ${pick(["Widget", "Gadget", "Tool", "Device"])}`;
+    const mode = Math.random();
+    if (mode < 0.4) return pick(keywords);
+    if (mode < 0.7) return `${pick(keywords)} ${pick(keywords)}`;
+    return jumbleWord(pick(keywords).toLowerCase());
+  },
+  product_category: (params) => pick(productCategoryByLang[pickLang(params?.languages, "en")] ?? productCategoryByLang["en"]),
+  color: (params) => pick(colorByLang[pickLang(params?.languages, "en")] ?? colorByLang["en"]),
+  size: (params) => pick(sizeByLang[pickLang(params?.languages, "en")] ?? sizeByLang["en"]),
+  weight_unit: (params) => {
+    const vals = (params?.values ?? "")
+      .split("\n")
+      .map((s) => s.trim())
+      .filter(Boolean);
+    return vals.length ? pick(vals) : pick(["kg", "g", "lb", "oz"]);
+  },
+  barcode: (params) => {
+    const selected = params?.barcodeTypes?.length ? params.barcodeTypes : ["ean13"];
+    return generateBarcode(pick(selected));
+  },
+  sku: (params) => generateSkuFromPattern(params?.pattern ?? "([A-F]{2}[-]){2}([0-9]{4}[-])([A-Z])"),
+  id_number: generateIdNumber,
+  ip_address: (params) => (params?.ipType === "ipv6" ? generateIPv6() : generateIP()),
+  mac_address: generateMAC,
+  file_path: (params) => generateFilePath(params),
+  file_name: (params) => generateFileName(params),
+  file_extension: (params) => generateFileExtension(params),
+  url: (params) => generateUrl(params),
+  hostname: (params) => generateHostname(params),
+};
+
+const KnownColumnPatterns: Array<{ pattern: RegExp; generatorKey: string }> = [
+  { pattern: /email|e-?mail|mail/i, generatorKey: "email" },
+  { pattern: /phone|tel|mobile|cell|fax|telephone/i, generatorKey: "phone" },
+  { pattern: /id.?card|idcard|身份证|id.?number|证件号|证件|passport|护照|social.?credit|统一社会|信用代码/i, generatorKey: "id_number" },
+  { pattern: /bank.?card|银行卡|bank.?account/i, generatorKey: "id_number" },
+  { pattern: /driver.?license|drivers?|驾驶证|驾照/i, generatorKey: "id_number" },
+  { pattern: /first.?name|fname|given.?name/i, generatorKey: "full_name" },
+  { pattern: /last.?name|lname|surname|family.?name/i, generatorKey: "full_name" },
+  { pattern: /full.?name|name|user.?name|username|nickname|nick.?name/i, generatorKey: "full_name" },
+  { pattern: /gender|sex/i, generatorKey: "gender" },
+  { pattern: /city|town|municipality/i, generatorKey: "city" },
+  { pattern: /country|province|state|region/i, generatorKey: "city" },
+  { pattern: /zip|postal.?code|postcode/i, generatorKey: "number" },
+  { pattern: /address|street|district|county/i, generatorKey: "address" },
+  { pattern: /url|website|link|homepage|href|weburl/i, generatorKey: "url" },
+  { pattern: /ip$/i, generatorKey: "ip_address" },
+  { pattern: /ip.?address|ipv4|ipv6/i, generatorKey: "ip_address" },
+  { pattern: /mac.?address|mac$/i, generatorKey: "mac_address" },
+  { pattern: /uuid|guid/i, generatorKey: "uuid" },
+  { pattern: /company|corp|organization|org|brand/i, generatorKey: "company_name" },
+  { pattern: /department|dept|division/i, generatorKey: "department" },
+  { pattern: /color|colour/i, generatorKey: "color" },
+  { pattern: /title|position|job.?title|role/i, generatorKey: "job_title" },
+  { pattern: /description|comment|note|summary|bio|content|body|detail|remark|memo|intro|introduction|overview/i, generatorKey: "text" },
+  { pattern: /status|state/i, generatorKey: "enum" },
+  { pattern: /barcode|upc|ean|qr.?code/i, generatorKey: "barcode" },
+  { pattern: /sku/i, generatorKey: "sku" },
+  { pattern: /product.?name|product$/i, generatorKey: "product_name" },
+  { pattern: /category|type|kind|classification/i, generatorKey: "product_category" },
+  { pattern: /size$/i, generatorKey: "size" },
+  { pattern: /weight|weight.?unit|unit.?weight|weight.?unit|weight.?type/i, generatorKey: "weight_unit" },
+  { pattern: /file.?path|filePath|directory|dir$/i, generatorKey: "file_path" },
+  { pattern: /file.?name|filename|original.?name|file.?original.?name/i, generatorKey: "file_name" },
+  { pattern: /file.?extension|ext$|filetype|file.?type/i, generatorKey: "file_extension" },
+  { pattern: /hostname|host$/i, generatorKey: "hostname" },
+  { pattern: /version|ver$/i, generatorKey: "text" },
+  { pattern: /language|locale$/i, generatorKey: "text" },
+  { pattern: /currency|currency.?code|currency.?name/i, generatorKey: "text" },
+  { pattern: /slug|permalink|alias|url.?slug|key$/i, generatorKey: "text" },
+  { pattern: /tag|keyword|labels|tags$/i, generatorKey: "text" },
+  { pattern: /level|tier|stage|phase|channel|source|platform/i, generatorKey: "text" },
+  { pattern: /owner|creator|author|created_by|updated_by|modified_by|operator|user$/i, generatorKey: "full_name" },
+];
+
+export function findGeneratorKey(columnName: string, dataType: string, isAutoIncrement?: boolean): string {
+  if (isAutoIncrement) return "sequence";
+  const type = dataType.toLowerCase();
+  const isNumeric = type.includes("int") || type === "smallint" || type === "bigint" || type.includes("bool") || type.includes("decimal") || type.includes("numeric") || type.includes("float") || type.includes("double") || type === "real";
+  const isDateTime = type.includes("date") || type.includes("timestamp") || type === "time";
+  const isBinary = type.includes("binary") || type.includes("blob") || type.includes("bytea");
+  const isBoolType = type === "bool" || type === "boolean" || type === "bit" || type === "tinyint(1)";
+  const isBoolName = /^(is|has|had|can|did|enable|disable|allow|use|visible|deleted|active|flag)[_\-]?/i.test(columnName);
+  if (isNumeric || isDateTime || isBinary) {
+    if (type.includes("serial")) return "sequence";
+    if (isBoolType || (isNumeric && isBoolName)) return "enum";
+    if (/status|state/i.test(columnName)) return "enum";
+    if (isNumeric) return "number";
+    if (type === "time") return "time";
+    if (isDateTime) return "datetime";
+    if (isBinary) return "text";
+  }
+  for (const { pattern, generatorKey } of KnownColumnPatterns) {
+    if (pattern.test(columnName)) return generatorKey;
+  }
+  if (type.includes("char") || type.includes("text") || type.includes("varchar") || type === "clob") return "text";
+  if (type.includes("uuid") || type.includes("guid")) return "uuid";
+  return "text";
+}
+
+export interface ColumnAttrs {
+  dataType: string;
+  isAutoIncrement?: boolean;
+  columnDefault?: string | null;
+  numericPrecision?: number | null;
+  numericScale?: number | null;
+  characterMaximumLength?: number | null;
+}
+
+export function defaultGeneratorParams(_columnName: string, attrs: ColumnAttrs, generatorKey: string): GeneratorParams {
+  const params: GeneratorParams = {};
+  const type = attrs.dataType.toLowerCase();
+  const precision = attrs.numericPrecision ?? null;
+  const scale = attrs.numericScale ?? null;
+  const charLen = attrs.characterMaximumLength ?? null;
+  if (!attrs.isAutoIncrement && generatedDefaultValue(attrs.columnDefault, attrs.dataType) !== undefined) {
+    params.includeDefault = true;
+    params.defaultPercent = 100;
+  }
+
+  if (generatorKey === "sequence") {
+    params.startValue = 1;
+    params.increment = 1;
+    return params;
+  }
+
+  if (generatorKey === "number") {
+    const isDecimal = type.includes("decimal") || type.includes("numeric") || type.includes("float") || type.includes("double") || type === "real";
+    const col = _columnName.toLowerCase();
+    const isAmount = /price|amount|total|cost|fee|balance|salary|income|revenue|tax|discount|money|payment|price/i.test(col);
+    const isBigAmount = /salary|income|revenue|balance|total/i.test(col);
+    const isPrice = /price|fee|cost|payment|amount|discount/i.test(col);
+    const isPercent = /percent|percentage|pct|rate|score|rating|progress/i.test(col);
+
+    if (isDecimal) {
+      params.numberType = "decimal";
+      params.decimalPlaces = scale ?? 2;
+      if (isPercent) {
+        params.min = 0;
+        params.max = 100;
+      } else if (isBigAmount) {
+        params.min = 100;
+        params.max = 999999;
+      } else if (isPrice) {
+        params.min = 1;
+        params.max = 9999.99;
+      } else {
+        const effectivePrecision = precision ?? 10;
+        const intDigits = Math.max(1, effectivePrecision - (scale ?? 0));
+        const maxVal = Math.pow(10, intDigits) - 1;
+        params.min = 0;
+        params.max = Math.max(1, Math.min(maxVal, 999999));
+      }
+    } else {
+      params.numberType = "integer";
+      if (type.includes("tinyint") || (precision !== null && precision <= 3)) {
+        params.min = 0;
+        params.max = 127;
+      } else if (type === "smallint" || (precision !== null && precision <= 5)) {
+        params.min = 0;
+        params.max = 32767;
+      } else if (type === "bigint" || (precision !== null && precision >= 19)) {
+        params.min = 1;
+        params.max = 999999;
+      } else if (isPercent) {
+        params.min = 0;
+        params.max = 100;
+      } else if (isAmount) {
+        params.min = 1;
+        params.max = 999999;
+      } else {
+        params.min = 1;
+        params.max = precision ? Math.min(Math.pow(10, Math.min(precision, 6)) - 1, 999999) : 1000;
+      }
+    }
+    return params;
+  }
+
+  if (generatorKey === "text") {
+    const col = _columnName.toLowerCase();
+    if (/^password|^pwd|password$|pwd$/.test(col)) {
+      params.textFormat = "bcrypt";
+      params.minLength = 60;
+      params.maxLength = 60;
+      return params;
+    }
+    if (/token/.test(col)) {
+      params.textFormat = "hex";
+      params.minLength = 32;
+      params.maxLength = 32;
+      return params;
+    }
+    if (/^hash|hash$/.test(col)) {
+      params.textFormat = "hex";
+      params.minLength = 64;
+      params.maxLength = 64;
+      return params;
+    }
+    if (/secret|api[_-]?key/.test(col)) {
+      params.textFormat = "alphanumeric";
+      params.minLength = 32;
+      params.maxLength = 32;
+      return params;
+    }
+    if (/^version|version$|^ver$/i.test(_columnName)) {
+      params.textFormat = "version";
+      params.minLength = 3;
+      params.maxLength = 10;
+      return params;
+    }
+    if (/language|^locale$/i.test(_columnName)) {
+      params.textFormat = "language";
+      params.minLength = 5;
+      params.maxLength = 5;
+      return params;
+    }
+    if (/currency/i.test(_columnName)) {
+      params.textFormat = "currency";
+      params.minLength = 3;
+      params.maxLength = 3;
+      return params;
+    }
+    if (/slug|permalink|alias/i.test(_columnName)) {
+      params.textFormat = "slug";
+      params.minLength = 8;
+      params.maxLength = 40;
+      return params;
+    }
+    if (/tag|keyword|labels/i.test(_columnName)) {
+      params.textFormat = "tag_list";
+      params.minLength = 3;
+      params.maxLength = 30;
+      return params;
+    }
+    if (/level|tier|stage|phase/i.test(_columnName)) {
+      params.textFormat = "level";
+      params.minLength = 4;
+      params.maxLength = 15;
+      return params;
+    }
+    if (/channel|source|platform/i.test(_columnName)) {
+      params.textFormat = "channel";
+      params.minLength = 3;
+      params.maxLength = 20;
+      return params;
+    }
+    if (charLen !== null && charLen > 0) {
+      const effectiveLen = Math.min(charLen, 2000);
+      if (effectiveLen <= 20) {
+        params.minLength = Math.max(1, Math.floor(effectiveLen * 0.6));
+        params.maxLength = effectiveLen;
+      } else {
+        params.minLength = Math.max(10, Math.floor(effectiveLen * 0.3));
+        params.maxLength = effectiveLen;
+      }
+    } else {
+      params.minLength = 50;
+      params.maxLength = 500;
+    }
+    return params;
+  }
+
+  if (generatorKey === "id_number") {
+    if (/passport|护照/.test(_columnName)) {
+      params.idTypes = ["passport"];
+    } else if (/bank.?card|银行卡|credit.?card/.test(_columnName)) {
+      params.idTypes = ["bank_card"];
+    } else if (/driver|驾照|驾驶证/.test(_columnName)) {
+      params.idTypes = ["drivers_license"];
+    } else if (/social.?credit|统一社会|信用.?代码|uscc/.test(_columnName)) {
+      params.idTypes = ["uscc"];
+    } else if (/hk|macau|港澳|港澳通行/.test(_columnName)) {
+      params.idTypes = ["hk_macau_pass"];
+    } else if (/taiwan|台湾|台胞/.test(_columnName)) {
+      params.idTypes = ["taiwan_pass"];
+    } else {
+      params.idTypes = ["id_card"];
+    }
+    return params;
+  }
+
+  if (generatorKey === "datetime" || generatorKey === "date") {
+    params.start = "2020-01-01";
+    params.end = "2030-12-31";
+    return params;
+  }
+
+  if (generatorKey === "time") {
+    params.startTime = "00";
+    params.endTime = "23";
+    return params;
+  }
+
+  if (generatorKey === "uuid") {
+    params.uuidHyphens = true;
+    return params;
+  }
+
+  if (generatorKey === "enum") {
+    const t = attrs.dataType.toLowerCase();
+    const isNum = t.includes("int") || t.includes("bool") || t.includes("decimal") || t.includes("numeric") || t.includes("float") || t.includes("double") || t === "real";
+    const isBoolType = t === "bool" || t === "boolean" || t === "bit" || t === "tinyint(1)";
+    const isBoolName = /^(is|has|had|can|did|enable|disable|allow|use|visible|deleted|active|flag)[_\-]?/i.test(_columnName);
+    if (isBoolType || (isNum && isBoolName)) {
+      params.values = "0\n1";
+    } else if (isNum) {
+      params.values = "0\n1\n2";
+    } else {
+      params.values = "A\nB\nC\nD\nE";
+    }
+    return params;
+  }
+
+  // --- 其他生成器的默认参数（确保保存/加载配置时所有参数都被覆盖） ---
+  if (generatorKey === "full_name") {
+    params.nameFormat = "full";
+    params.languages = ["en"];
+    return params;
+  }
+  if (
+    generatorKey === "gender" ||
+    generatorKey === "title" ||
+    generatorKey === "marital_status" ||
+    generatorKey === "job_title" ||
+    generatorKey === "company_name" ||
+    generatorKey === "department" ||
+    generatorKey === "industry" ||
+    generatorKey === "product_category" ||
+    generatorKey === "color" ||
+    generatorKey === "size"
+  ) {
+    params.languages = ["en"];
+    return params;
+  }
+  if (generatorKey === "social_id") {
+    return params;
+  }
+  if (generatorKey === "phone") {
+    params.phoneFormat = "domestic";
+    params.phoneSeparator = true;
+    params.phoneRegions = ["us"];
+    return params;
+  }
+  if (generatorKey === "email") {
+    params.emailDomains = "gmail.com\nyahoo.com\noutlook.com\nexample.com\ntest.org";
+    return params;
+  }
+  if (generatorKey === "payment_method") {
+    params.values = "Credit Card\nPayPal\nApple Pay\nGoogle Pay\nBank Transfer\nCash\nCryptocurrency";
+    return params;
+  }
+  if (generatorKey === "credit_card_type" || generatorKey === "credit_card_number") {
+    params.cardTypes = ["visa", "mastercard"];
+    return params;
+  }
+  if (generatorKey === "credit_card_date") {
+    params.ccDateFormat = "MM/YY";
+    params.ccYearOffsetMin = 0;
+    params.ccYearOffsetMax = 5;
+    return params;
+  }
+  if (generatorKey === "address") {
+    params.addressType = "line1";
+    params.regions = ["us"];
+    return params;
+  }
+  if (generatorKey === "city") {
+    params.regions = ["us"];
+    params.languages = ["en"];
+    return params;
+  }
+  if (generatorKey === "region") {
+    params.regionFormat = "name";
+    params.regionLang = "en";
+    params.textTransform = "none";
+    return params;
+  }
+  if (generatorKey === "product_name") {
+    params.productKeywords = "Premium\nBasic\nUltra\nStandard\nPro\nWidget\nGadget\nTool\nDevice\nKit\nPack\nBundle\nEdition\nPlus\nMax\nMini\nLite\nCore\nSelect\nAdvanced\nSmart";
+    return params;
+  }
+  if (generatorKey === "weight_unit") {
+    params.values = "g\nkg\nlb\noz\nt\nmg\nct";
+    return params;
+  }
+  if (generatorKey === "barcode") {
+    params.barcodeTypes = ["ean13"];
+    return params;
+  }
+  if (generatorKey === "sku") {
+    params.pattern = "([A-F]{2}[-]){2}([0-9]{4}[-])([A-Z])";
+    return params;
+  }
+  if (generatorKey === "ip_address") {
+    params.ipType = "ipv4";
+    return params;
+  }
+  if (generatorKey === "mac_address") {
+    return params;
+  }
+  if (generatorKey === "file_path") {
+    params.pathTypes = ["linux"];
+    params.includeFileName = true;
+    params.extensionCategory = "image";
+    return params;
+  }
+  if (generatorKey === "file_name") {
+    params.includeExtension = true;
+    params.extensionCategory = "image";
+    return params;
+  }
+  if (generatorKey === "file_extension") {
+    params.extensionCategory = "image";
+    return params;
+  }
+  if (generatorKey === "url") {
+    params.urlSubdomains = "auth.\ndrive.\nimage.\nwww.\napi.\nmail.\nshop.\nblog.";
+    params.urlTlds = ".biz\n.co.jp\n.com\n.cn\n.org\n.net\n.io\n.dev\n.xyz";
+    return params;
+  }
+  if (generatorKey === "hostname") {
+    return params;
+  }
+  if (generatorKey === "foreign_key") {
+    params.fkSchema = "";
+    params.fkTable = "";
+    params.fkField = "";
+    params.fkMode = "random";
+    params.min = 1;
+    params.max = 500;
+    return params;
+  }
+  if (generatorKey === "image") {
+    params.imageMode = "generate";
+    params.imageWidth = 200;
+    params.imageHeight = 200;
+    params.imageFormat = "JPEG";
+    params.folderPath = "";
+    params.fileExtensions = "";
+    return params;
+  }
+  if (generatorKey === "regex") {
+    params.pattern = "";
+    params.rawPattern = false;
+    return params;
+  }
+
+  return params;
+}
+
+export function getGeneratorCategoryAndLabel(key: string): { category: string; categoryLabel: string; label: string } {
+  const genKey = key.startsWith("general/") ? key.slice(8) : key;
+  for (const cat of GeneratorHierarchy) {
+    const child = cat.children?.find((c) => c.key === genKey);
+    if (child) return { category: cat.key, categoryLabel: cat.label, label: child.label };
+  }
+  return { category: "general", categoryLabel: "通用", label: key };
+}
+
+export function generateValue(columnName: string, dataType: string, generatorKey: string | undefined, rowIndex: number, params?: GeneratorParams, columnDefault?: string | null): unknown {
+  // null / default overrides
+  if (params?.includeNull && params.nullPercent && Math.random() * 100 < params.nullPercent) return null;
+  const defaultValue = generatedDefaultValue(columnDefault, dataType);
+  if (defaultValue !== undefined) {
+    const includeDefault = params?.includeDefault ?? true;
+    const defaultPercent = params?.defaultPercent ?? 100;
+    if (includeDefault && defaultPercent > 0 && Math.random() * 100 < defaultPercent) return defaultValue;
+  }
+
+  const key = generatorKey ?? findGeneratorKey(columnName, dataType);
+  if ((key === "date" || key === "datetime") && rowIndex === 0) {
+    console.log("[dbx:gen] col=%s key=%s start=%j end=%j allDay=%j", columnName, key, params?.start, params?.end, params?.allDay);
+  }
+
+  if (key === "number") {
+    const min = params?.min ?? 1;
+    const max = params?.max ?? 1000;
+    if (params?.numberType === "decimal") {
+      return randDecimal(min, max, params.decimalPlaces ?? 2);
+    }
+    return randInt(min, max);
+  }
+  if (key === "sequence") {
+    const start = params?.startValue ?? 1;
+    const inc = params?.increment ?? 1;
+    let val = start + rowIndex * inc;
+    if (params?.sequenceMin !== undefined && params?.sequenceMax !== undefined && params?.sequenceCycle) {
+      const range = params.sequenceMax - params.sequenceMin + 1;
+      val = params.sequenceMin + ((((val - params.sequenceMin) % range) + range) % range);
+    } else if (params?.sequenceMin !== undefined && val < params.sequenceMin) {
+      val = params.sequenceMin;
+    } else if (params?.sequenceMax !== undefined && val > params.sequenceMax) {
+      val = params.sequenceMax;
+    }
+    return val;
+  }
+  if (key === "datetime") {
+    const start = params?.start ? parseLocalDate(params.start) : new Date("2020-01-01");
+    const end = params?.end ? parseLocalDate(params.end) : new Date();
+    if (params?.allDay) {
+      const [rangeStart, rangeEnd] = ensureRange(start, end);
+      const d = new Date(rangeStart.getTime() + Math.random() * (rangeEnd.getTime() - rangeStart.getTime()));
+      const sh = parseInt(params.startTime ?? "00") || 0;
+      const sm = parseInt(params.endTime ?? "23") || 23;
+      const h = Math.floor(Math.random() * (sm - sh + 1)) + sh;
+      const m = Math.floor(Math.random() * 60);
+      const s = Math.floor(Math.random() * 60);
+      const pad = (n: number) => String(n).padStart(2, "0");
+      return `${formatLocalDate(d)} ${pad(h)}:${pad(m)}:${pad(s)}`;
+    }
+    return randTimestamp(start, end);
+  }
+  if (key === "date") {
+    const start = params?.start ? parseLocalDate(params.start) : new Date("2020-01-01");
+    const end = params?.end ? parseLocalDate(params.end) : new Date();
+    return randDate(start, end);
+  }
+  if (key === "time") {
+    let sh = 0,
+      sm = 23;
+    if (!params?.allDay) {
+      sh = parseInt(params?.startTime ?? "00") || 0;
+      sm = parseInt(params?.endTime ?? "23") || 23;
+    }
+    const h = Math.floor(Math.random() * (sm - sh + 1)) + sh;
+    const m = Math.floor(Math.random() * 60);
+    const s = Math.floor(Math.random() * 60);
+    const pad = (n: number) => String(n).padStart(2, "0");
+    return `${pad(h)}:${pad(m)}:${pad(s)}`;
+  }
+  if (key === "enum") {
+    const vals = (params?.values ?? "")
+      .split("\n")
+      .map((s) => s.trim())
+      .filter(Boolean);
+    if (vals.length === 0) return pick(["A", "B", "C", "D", "E"]);
+    return vals[Math.floor(Math.random() * vals.length)];
+  }
+  if (key === "text") {
+    const fmt = params?.textFormat ?? "lorem";
+    if (fmt === "bcrypt") {
+      const b64chars = "./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+      const b64 = (n: number) => Array.from({ length: n }, () => b64chars[Math.floor(Math.random() * b64chars.length)]).join("");
+      return `$2a$10$${b64(22)}${b64(31)}`;
+    }
+    if (fmt === "hex") {
+      const hex = "0123456789abcdef";
+      const minLen = params?.minLength ?? 32;
+      const maxLen = params?.maxLength ?? 32;
+      const len = Math.floor(Math.random() * (maxLen - minLen + 1)) + minLen;
+      return Array.from({ length: len }, () => hex[Math.floor(Math.random() * 16)]).join("");
+    }
+    if (fmt === "alphanumeric") {
+      const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+      const minLen = params?.minLength ?? 32;
+      const maxLen = params?.maxLength ?? 32;
+      const len = Math.floor(Math.random() * (maxLen - minLen + 1)) + minLen;
+      return Array.from({ length: len }, () => chars[Math.floor(Math.random() * chars.length)]).join("");
+    }
+    if (fmt === "version") {
+      const v = `${randInt(0, 3)}.${randInt(0, 20)}.${randInt(0, 99)}`;
+      return Math.random() < 0.3 ? `v${v}` : v;
+    }
+    if (fmt === "language") {
+      const langs = ["en-US", "en-GB", "zh-CN", "zh-TW", "ja-JP", "ko-KR", "fr-FR", "de-DE", "es-ES", "pt-BR", "it-IT", "ru-RU", "ar-SA", "hi-IN", "nl-NL", "pl-PL"];
+      return pick(langs);
+    }
+    if (fmt === "currency") {
+      const codes = ["USD", "CNY", "EUR", "JPY", "GBP", "HKD", "SGD", "AUD", "CAD", "CHF", "THB", "TWD", "KRW", "INR", "RUB", "BRL"];
+      return pick(codes);
+    }
+    if (fmt === "slug") {
+      const words = ["product", "item", "category", "page", "service", "plan", "feature", "edition", "version", "type", "mode", "option", "setting", "config"];
+      const count = randInt(2, 4);
+      const parts: string[] = [];
+      for (let i = 0; i < count; i++) parts.push(pick(words).toLowerCase());
+      return parts.join("-");
+    }
+    if (fmt === "tag_list") {
+      const pool = ["new", "featured", "hot", "sale", "discount", "promo", "vip", "limited", "bestseller", "recommended", "popular", "trending", "special", "exclusive", "premium", "basic"];
+      const count = randInt(1, 3);
+      const selected = new Set<string>();
+      while (selected.size < count) selected.add(pick(pool));
+      return Array.from(selected).join(",");
+    }
+    if (fmt === "level") {
+      const tiers = ["basic", "standard", "premium", "enterprise", "professional", "ultimate", "starter", "advanced", "lite", "pro"];
+      return pick(tiers);
+    }
+    if (fmt === "channel") {
+      const channels = ["web", "mobile", "api", "desktop", "ios", "android", "mini-program", "wechat", "official", "direct", "partner", "affiliate", "referral", "organic", "email"];
+      return pick(channels);
+    }
+    const texts = [
+      "Lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua Ut enim ad minim veniam quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat",
+      "The quick brown fox jumps over the lazy dog near the bank of the river A gentle breeze carried the scent of wildflowers across the meadow as birds sang melodies from the treetops",
+      "In the world of technology change is the only constant Innovations emerge daily reshaping how we live work and communicate with one another across vast distances",
+      "科学研究需要坚持不懈的努力和严谨的态度每一个实验每一次观察都是通向真理的重要一步不断积累的知识终将改变世界",
+      "数据库管理系统是现代应用的核心支柱从简单的数据存储到复杂的高并发查询它支撑着数以亿计的用户请求",
+    ];
+    const minLen = params?.minLength ?? 50;
+    const maxLen = params?.maxLength ?? 500;
+    const len = Math.floor(Math.random() * (maxLen - minLen + 1)) + minLen;
+    const base = texts[Math.floor(Math.random() * texts.length)];
+    if (base.length >= len) return base.slice(0, len);
+    const repeats = Math.ceil(len / base.length) + 1;
+    const txt = Array.from({ length: repeats }, () => base).join(" ");
+    return txt.slice(0, len);
+  }
+  if (key === "uuid") {
+    const hex = "0123456789abcdef";
+    const parts = [8, 4, 4, 4, 12];
+    const uuid = parts.map((length) => Array.from({ length }, () => hex[Math.floor(Math.random() * 16)]).join(""));
+    return params?.uuidHyphens !== false ? uuid.join("-") : uuid.join("");
+  }
+  if (key === "foreign_key") {
+    return randInt(params?.min ?? 1, params?.max ?? 500);
+  }
+  if (key === "image") return `0x${Array.from({ length: 16 }, () => randInt(0, 255).toString(16).padStart(2, "0")).join("")}`;
+
+  const fn = GeneratorFunctions[key];
+  if (fn) return fn(params);
+
+  return generateByType(dataType, rowIndex);
+}
+
+function generateByType(type: string, rowIndex: number): unknown {
+  const t = type.toLowerCase();
+  if (t.includes("int") || t.includes("serial") || t === "bigint" || t === "smallint" || t === "tinyint") return randInt(1, 1000);
+  if (t.includes("decimal") || t.includes("numeric") || t.includes("float") || t.includes("double") || t === "real") return randDecimal(0, 10000, 2);
+  if (t.includes("bool")) return Math.random() > 0.5 ? 1 : 0;
+  if (t.includes("date")) return randDate(new Date("2020-01-01"), new Date("2025-12-31"));
+  if (t.includes("time")) return randTimestamp(new Date("2020-01-01"), new Date("2025-12-31"));
+  return `value_${rowIndex + 1}`;
+}
+
+export function formatGeneratedValue(value: unknown): string {
+  if (isGeneratedSqlExpression(value)) return value.sql;
+  if (value === null || value === undefined) return "NULL";
+  if (typeof value === "number") return String(value);
+  if (typeof value === "boolean") return value ? "1" : "0";
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+export function displayGeneratedValue(value: unknown): string {
+  if (isGeneratedSqlExpression(value)) return value.display;
+  if (value === null || value === undefined) return "NULL";
+  return String(value);
+}
+
+export interface GenerateResult {
+  columns: string[];
+  rows: unknown[][];
+  sql: string;
+}
+
+export function generateTableData(config: TableGenerateConfig, databaseType?: DatabaseType): GenerateResult {
+  const colNames = config.columns.map((c) => c.columnName);
+  const rows: unknown[][] = [];
+
+  for (let i = 0; i < config.rowCount; i++) {
+    const row = config.columns.map((col) => generateValue(col.columnName, col.dataType, col.generatorKey, i, col.generatorParams, col.isAutoIncrement ? null : col.columnDefault));
+    rows.push(row);
+  }
+
+  const valuesSql = rows.map((row) => `(${row.map(formatGeneratedValue).join(", ")})`).join(",\n");
+
+  const quotedCols = config.columns.map((c) => quoteTableIdentifier(databaseType, c.columnName));
+  const sql = `INSERT INTO ${quoteTableIdentifier(databaseType, config.tableName)} (${quotedCols.join(", ")}) VALUES\n${valuesSql};`;
+
+  return { columns: colNames, rows, sql };
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridCellCoercion.ts b/apps/desktop/src/lib/dataGrid/dataGridCellCoercion.ts
new file mode 100644
index 0000000..84b2e21
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridCellCoercion.ts
@@ -0,0 +1,319 @@
+import type { GridCellValue } from "@/lib/dataGrid/dataGridSql";
+import type { DatabaseType, ColumnInfo } from "@/types/database";
+
+export interface CoerceDataGridCellValueOptions {
+  value: string;
+  oldValue: GridCellValue | undefined;
+  databaseType: DatabaseType | undefined;
+  columnInfo: Pick<ColumnInfo, "data_type"> | undefined;
+}
+
+export function coerceDataGridCellValue(options: CoerceDataGridCellValueOptions): GridCellValue {
+  const { value, oldValue } = options;
+  if (value.toUpperCase() === "NULL") return null;
+  if (value === "" && oldValue === null) return null;
+  const postgresArrayValue = coercePostgresArrayValue(options);
+  if (postgresArrayValue !== undefined) return postgresArrayValue;
+  if (typeof oldValue === "number") {
+    const num = Number(value);
+    if (!Number.isNaN(num)) {
+      if (shouldPreserveNumericText(options, num)) {
+        // Keep precision-sensitive numeric edits as text; JS Number rounds 64-bit integers.
+        const text = value.trim();
+        if (text === String(oldValue)) return oldValue;
+        return text;
+      }
+      return num;
+    }
+  }
+  if (typeof oldValue === "boolean") {
+    return value === "true" || value === "1";
+  }
+  return normalizeSmartQuotedJsonInput(value);
+}
+
+export function dataGridCellEditorText(options: { value: GridCellValue | undefined; databaseType: DatabaseType | undefined; columnInfo: Pick<ColumnInfo, "data_type"> | undefined }): string {
+  const value = options.value ?? null;
+  if (value === null) return "";
+  if (Array.isArray(value) && options.databaseType === "postgres" && isPostgresArrayColumn(options.columnInfo, value)) {
+    return formatPostgresArrayText(value);
+  }
+  return typeof value === "object" ? JSON.stringify(value) : String(value);
+}
+
+export function dataGridCellDisplayText(options: { value: GridCellValue; databaseType: DatabaseType | undefined; columnInfo: Pick<ColumnInfo, "data_type"> | undefined }): string | undefined {
+  if (Array.isArray(options.value) && options.databaseType === "postgres" && isPostgresArrayColumn(options.columnInfo, options.value)) {
+    return formatPostgresArrayText(options.value);
+  }
+  if (typeof options.value === "string" && isOracleDateColumn(options.databaseType, options.columnInfo)) {
+    return formatOracleDateDisplayText(options.value);
+  }
+  return undefined;
+}
+
+function coercePostgresArrayValue(options: CoerceDataGridCellValueOptions): unknown[] | undefined {
+  if (options.databaseType !== "postgres") return undefined;
+  if (!isPostgresArrayColumn(options.columnInfo, options.oldValue)) return undefined;
+  const trimmed = options.value.trim();
+
+  if (trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(normalizeSmartQuotes(trimmed));
+      return Array.isArray(parsed) ? parsed : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = parsePostgresArrayText(trimmed, {
+        numericDataType: postgresArrayElementDataType(options.columnInfo?.data_type),
+      });
+      if (Array.isArray(options.oldValue) && deepEqual(parsed, options.oldValue)) {
+        return options.oldValue;
+      }
+      return parsed;
+    } catch {
+      return undefined;
+    }
+  }
+
+  return undefined;
+}
+
+function deepEqual(a: unknown, b: unknown): boolean {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+function isPostgresArrayColumn(columnInfo: Pick<ColumnInfo, "data_type"> | undefined, oldValue: GridCellValue | undefined): boolean {
+  if (Array.isArray(oldValue)) return true;
+  const dataType = columnInfo?.data_type.trim().toLowerCase() ?? "";
+  return dataType === "array" || dataType.endsWith("[]") || dataType.startsWith("_");
+}
+
+function shouldPreserveNumericText(options: CoerceDataGridCellValueOptions, parsedNumber: number): boolean {
+  const text = options.value.trim();
+  if (!isNumericLiteralText(text)) return false;
+  return shouldPreserveNumericTextForType(options.columnInfo?.data_type, text, parsedNumber);
+}
+
+function postgresArrayElementDataType(dataType: string | undefined): string {
+  const normalized = normalizeDataType(dataType);
+  if (normalized.startsWith("_")) return normalized.slice(1);
+  if (normalized.endsWith("[]")) return normalized.slice(0, -2).trim();
+  return normalized;
+}
+
+function shouldPreserveNumericTextForType(dataType: string | undefined, text: string, parsedNumber: number): boolean {
+  const normalized = normalizeDataType(dataType);
+  if (isExactDecimalDataType(normalized)) return true;
+  if (isLargeIntegerDataType(normalized)) return !Number.isSafeInteger(parsedNumber);
+  return numericTextWouldLosePrecision(text, parsedNumber);
+}
+
+function normalizeDataType(dataType: string | undefined): string {
+  return (dataType ?? "").trim().toLowerCase();
+}
+
+function isOracleDateColumn(databaseType: DatabaseType | undefined, columnInfo: Pick<ColumnInfo, "data_type"> | undefined): boolean {
+  if (databaseType !== "oracle" && databaseType !== "oceanbase-oracle") return false;
+  const base = normalizeDataType(columnInfo?.data_type).split(/[()\s\t\n]/)[0] ?? "";
+  return base === "date";
+}
+
+function formatOracleDateDisplayText(value: string): string | undefined {
+  const parts = parseOracleDateLikeText(value);
+  if (!parts) return undefined;
+  if (parts.time === "00:00:00" && !parts.fraction) return parts.date;
+  return `${parts.date} ${parts.time}${parts.fraction ?? ""}`;
+}
+
+function parseOracleDateLikeText(value: string): { date: string; time: string; fraction?: string } | undefined {
+  if (!/^\d{4}-\d{2}-\d{2}/.test(value)) return undefined;
+  const date = value.slice(0, 10);
+  if (value.length === 10) return { date, time: "00:00:00" };
+  const separator = value[10];
+  if (separator !== "T" && separator !== " ") return undefined;
+  if (!/^\d{2}:\d{2}:\d{2}/.test(value.slice(11))) return undefined;
+  const time = value.slice(11, 19);
+  let rest = value.slice(19);
+  let fraction: string | undefined;
+  if (rest.startsWith(".")) {
+    const match = rest.match(/^(\.\d{1,9})(.*)$/);
+    if (!match) return undefined;
+    fraction = match[1];
+    rest = match[2];
+  }
+  if (rest && !/^z$/i.test(rest) && !/^[+-]\d{2}:\d{2}$/.test(rest)) return undefined;
+  return { date, time, fraction };
+}
+
+function isExactDecimalDataType(dataType: string): boolean {
+  return /\b(?:decimal|numeric|number|dec|money|smallmoney|bigdecimal|bignumeric|big_numeric|fixed)\b/.test(dataType);
+}
+
+function isLargeIntegerDataType(dataType: string): boolean {
+  return /\b(?:bigint|int8|int64|uint64|u64|bigserial|serial8|int128|uint128|int256|uint256)\b/.test(dataType);
+}
+
+function numericTextWouldLosePrecision(text: string, parsedNumber: number): boolean {
+  if (isIntegerLiteralText(text)) return !Number.isSafeInteger(parsedNumber);
+  return significantDigitCount(text) > 15;
+}
+
+function isNumericLiteralText(text: string): boolean {
+  return /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(text);
+}
+
+function isIntegerLiteralText(text: string): boolean {
+  return /^[+-]?\d+$/.test(text);
+}
+
+function significantDigitCount(text: string): number {
+  const mantissa = text.replace(/^[+-]/, "").split(/[eE]/)[0].replace(".", "");
+  const withoutLeadingZeros = mantissa.replace(/^0+/, "");
+  return withoutLeadingZeros.length;
+}
+
+function normalizeSmartQuotedJsonInput(value: string): string {
+  // Check for smart double quotes that input methods might insert.
+  // U+201C, U+201D, U+201E, U+201F, U+FF02
+  if (!hasSmartDoubleQuotes(value)) return value;
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return value;
+
+  try {
+    JSON.parse(value);
+    return value;
+  } catch {
+    // Input methods can turn JSON delimiters into smart quotes.
+  }
+
+  // Input methods (especially on macOS and with Chinese IME) can turn JSON delimiters
+  // into smart quotes. Normalize them to standard ASCII quotes.
+  const normalized = normalizeSmartQuotes(value);
+  try {
+    JSON.parse(normalized);
+    return normalized;
+  } catch {
+    return value;
+  }
+}
+
+function hasSmartDoubleQuotes(value: string): boolean {
+  // Check for smart double quotes: U+201C, U+201D, U+201E, U+201F, U+FF02
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code === 0x201c || code === 0x201d || code === 0x201e || code === 0x201f || code === 0xff02) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function normalizeSmartQuotes(value: string): string {
+  let result = "";
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code === 0x201c || code === 0x201d || code === 0x201e || code === 0x201f || code === 0xff02) {
+      // Convert to standard double quote
+      result += '"';
+    } else {
+      result += value[i];
+    }
+  }
+  return result;
+}
+
+function formatPostgresArrayText(value: unknown[]): string {
+  return `{${value.map(formatPostgresArrayElement).join(",")}}`;
+}
+
+function formatPostgresArrayElement(value: unknown): string {
+  if (Array.isArray(value)) return formatPostgresArrayText(value);
+  if (value === null) return "NULL";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return String(value);
+  const text = typeof value === "string" ? value : JSON.stringify(value);
+  if (text === undefined) return "";
+  if (!needsQuotedPostgresArrayElement(text)) return text;
+  return `"${text.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+function needsQuotedPostgresArrayElement(value: string): boolean {
+  return value === "" || /[\s,"{}\\]/.test(value) || value.toUpperCase() === "NULL";
+}
+
+function parsePostgresArrayText(value: string, options: { numericDataType?: string } = {}): unknown[] {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+    throw new Error("Invalid PG array literal");
+  }
+  const inner = trimmed.slice(1, -1);
+  if (inner.length === 0) return [];
+
+  const elements: unknown[] = [];
+  let i = 0;
+  while (i < inner.length) {
+    while (i < inner.length && inner[i] === " ") i++;
+    if (i >= inner.length) break;
+
+    let element: unknown;
+    if (inner[i] === '"') {
+      i++;
+      let str = "";
+      while (i < inner.length) {
+        if (inner[i] === "\\" && i + 1 < inner.length) {
+          i++;
+          str += inner[i];
+          i++;
+        } else if (inner[i] === '"') {
+          i++;
+          break;
+        } else {
+          str += inner[i];
+          i++;
+        }
+      }
+      element = str;
+    } else if (inner[i] === "{") {
+      let depth = 0;
+      const start = i;
+      while (i < inner.length) {
+        if (inner[i] === "{") depth++;
+        else if (inner[i] === "}") {
+          depth--;
+          if (depth === 0) {
+            i++;
+            break;
+          }
+        }
+        i++;
+      }
+      element = parsePostgresArrayText(inner.slice(start, i), options);
+    } else {
+      let start = i;
+      while (i < inner.length && inner[i] !== "," && inner[i] !== "}") i++;
+      const token = inner.slice(start, i).trim();
+      if (token.toUpperCase() === "NULL") {
+        element = null;
+      } else if (/^(true|false)$/i.test(token)) {
+        element = token.toLowerCase() === "true";
+      } else if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(token)) {
+        const num = Number(token);
+        // JS numbers cannot carry 64-bit integer or high-precision decimal array elements exactly.
+        element = shouldPreserveNumericTextForType(options.numericDataType, token, num) ? token : num;
+      } else {
+        element = token;
+      }
+    }
+
+    elements.push(element);
+
+    while (i < inner.length && inner[i] === " ") i++;
+    if (i < inner.length && inner[i] === ",") i++;
+  }
+
+  return elements;
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnFilter.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnFilter.ts
new file mode 100644
index 0000000..a8557b1
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridColumnFilter.ts
@@ -0,0 +1,97 @@
+import type { ColumnInfo, DatabaseType } from "@/types/database";
+import type { DataGridColumnInfo, DataGridContextFilterMode, GridCellValue } from "@/lib/dataGrid/dataGridSql";
+import { buildDataGridColumnValueFilterCondition, buildDataGridColumnValuesFilterCondition } from "@/lib/dataGrid/dataGridSql";
+import { normalizeWhereInput } from "@/lib/table/tableSelectSql";
+
+export function buildColumnValueFilterCondition(options: { databaseType?: DatabaseType; columnName: string; columnInfo?: Pick<ColumnInfo, "data_type">; rawValue: string }): Promise<string | undefined> {
+  return buildDataGridColumnValueFilterCondition({
+    databaseType: options.databaseType,
+    columnName: options.columnName,
+    columnInfo: options.columnInfo
+      ? {
+          name: options.columnName,
+          data_type: options.columnInfo.data_type,
+          is_nullable: true,
+        }
+      : undefined,
+    rawValue: options.rawValue,
+  });
+}
+
+export function buildColumnValuesFilterCondition(options: { databaseType?: DatabaseType; columnName: string; columnInfo?: Pick<ColumnInfo, "data_type">; values: GridCellValue[] }): Promise<string | undefined> {
+  return buildDataGridColumnValuesFilterCondition({
+    databaseType: options.databaseType,
+    columnName: options.columnName,
+    columnInfo: options.columnInfo
+      ? {
+          name: options.columnName,
+          data_type: options.columnInfo.data_type,
+          is_nullable: true,
+        }
+      : undefined,
+    values: options.values,
+  });
+}
+
+export function appendColumnValueFilterCondition(whereInput: string | undefined, condition: string | undefined): string {
+  if (!condition) return normalizeWhereInput(whereInput);
+  const existing = normalizeWhereInput(whereInput);
+  return existing ? `(${existing}) AND (${condition})` : condition;
+}
+
+export function combineWhereInputs(manualWhereInput?: string, structuredWhereInput?: string): string | undefined {
+  const manual = normalizeWhereInput(manualWhereInput);
+  const structured = normalizeWhereInput(structuredWhereInput);
+  if (manual && structured) return `(${manual}) AND (${structured})`;
+  return manual || structured || undefined;
+}
+
+export function filterModeNeedsValue(mode: DataGridContextFilterMode): boolean {
+  return mode !== "is-null" && mode !== "is-not-null";
+}
+
+export function parseFilterValue(rawValue: string, columnInfo?: Pick<DataGridColumnInfo, "data_type">): GridCellValue {
+  const unquoted = unwrapMatchingQuotes(rawValue.trim());
+  const dataType = (columnInfo?.data_type ?? "").toLowerCase();
+
+  if (isBooleanType(dataType) && unquoted.toLowerCase() === "true") return true;
+  if (isBooleanType(dataType) && unquoted.toLowerCase() === "false") return false;
+
+  if ((isNumericType(dataType) || !dataType) && isNumericLiteral(unquoted)) {
+    const numeric = Number(unquoted);
+    if (Number.isFinite(numeric)) {
+      // Keep large integers as strings to avoid JS precision loss (> Number.MAX_SAFE_INTEGER).
+      // The Rust backend parses strings exactly via serde_json::Number, so this is safe.
+      if (Number.isInteger(numeric) && Math.abs(numeric) > Number.MAX_SAFE_INTEGER) {
+        return unquoted;
+      }
+      return numeric;
+    }
+  }
+
+  return unquoted;
+}
+
+function unwrapMatchingQuotes(text: string): string {
+  if (text.length >= 2) {
+    const first = text[0];
+    const last = text[text.length - 1];
+    if ((first === "'" && last === "'") || (first === '"' && last === '"')) {
+      return text.slice(1, -1);
+    }
+  }
+  return text;
+}
+
+function isNumericType(dataType: string): boolean {
+  return ["int", "integer", "bigint", "smallint", "tinyint", "mediumint", "serial", "number", "numeric", "decimal", "float", "double", "real", "money"].some((part) => dataType.split(/[^a-z0-9]+/).includes(part));
+}
+
+function isBooleanType(dataType: string): boolean {
+  return dataType.split(/[^a-z0-9]+/).some((part) => part === "bool" || part === "boolean" || part === "bit");
+}
+
+function isNumericLiteral(text: string): boolean {
+  if (!text || text.trim() !== text) return false;
+  return Number.isFinite(Number(text)) && /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(text);
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnHeaderInteraction.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnHeaderInteraction.ts
new file mode 100644
index 0000000..ae05234
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridColumnHeaderInteraction.ts
@@ -0,0 +1,57 @@
+export interface ColumnHeaderTooltipState {
+  columnDragActive: boolean;
+  columnResizeActive: boolean;
+}
+
+export function columnHeaderTooltipDisabled(state: ColumnHeaderTooltipState): boolean {
+  return state.columnDragActive || state.columnResizeActive;
+}
+
+export interface ColumnHeaderCanvasPointerState {
+  columnDragActive: boolean;
+  columnResizeActive: boolean;
+}
+
+export function columnHeaderCanvasPointerDisabled(state: ColumnHeaderCanvasPointerState): boolean {
+  return state.columnDragActive || state.columnResizeActive;
+}
+
+export interface ColumnHeaderClickGuardState {
+  now: number;
+  guardUntil: number;
+  suppressNextClick: boolean;
+}
+
+export function columnHeaderClickShouldBeSuppressed(state: ColumnHeaderClickGuardState): boolean {
+  return state.suppressNextClick || state.now < state.guardUntil;
+}
+
+export interface ColumnHeaderPreviewState {
+  columnDragActive: boolean;
+}
+
+export function columnHeaderPreviewEnabled(state: ColumnHeaderPreviewState): boolean {
+  return state.columnDragActive;
+}
+
+export interface ColumnHeaderPreviewOffsetState {
+  columnDragActive: boolean;
+  visibleColIdx: number;
+  sourceVisibleIndex: number;
+  targetVisibleIndex: number;
+  startX: number;
+  currentX: number;
+  sourceWidth: number;
+}
+
+export function columnHeaderPreviewOffsetForColumn(state: ColumnHeaderPreviewOffsetState): number {
+  if (!columnHeaderPreviewEnabled(state)) return 0;
+  if (state.visibleColIdx === state.sourceVisibleIndex) return state.currentX - state.startX;
+  if (state.targetVisibleIndex < state.sourceVisibleIndex && state.visibleColIdx >= state.targetVisibleIndex && state.visibleColIdx < state.sourceVisibleIndex) {
+    return state.sourceWidth;
+  }
+  if (state.targetVisibleIndex > state.sourceVisibleIndex && state.visibleColIdx > state.sourceVisibleIndex && state.visibleColIdx <= state.targetVisibleIndex) {
+    return -state.sourceWidth;
+  }
+  return 0;
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnLayoutStorage.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnLayoutStorage.ts
new file mode 100644
index 0000000..438522e
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridColumnLayoutStorage.ts
@@ -0,0 +1,111 @@
+import { safeLocalStorageGet, safeLocalStorageRemove, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+
+const STORAGE_PREFIX = "dbx-data-grid-column-layout:";
+const TABLE_STORAGE_PREFIX = "dbx-data-grid-table-column-order:";
+const STORAGE_VERSION = 1;
+
+export const TABLE_DATA_GRID_COLUMN_ORDER_CHANGED_EVENT = "dbx:table-data-grid-column-order-changed";
+
+export interface TableDataGridColumnOrderChangedDetail {
+  scopeKey: string;
+}
+
+export interface DataGridColumnLayoutScope {
+  connectionId?: string;
+  database?: string;
+  schema?: string;
+  context?: string;
+  tableSchema?: string;
+  tableName?: string;
+  sql?: string;
+  columns: readonly string[];
+  sourceColumns?: readonly (string | undefined)[];
+}
+
+interface StoredDataGridColumnLayout {
+  version: number;
+  columnSignature: string;
+  order: string[];
+}
+
+export interface TableDataGridColumnOrderScope {
+  connectionId: string;
+  database: string;
+  schema?: string;
+  tableName: string;
+}
+
+interface StoredTableDataGridColumnOrder {
+  version: number;
+  order: string[];
+}
+
+function normalizeSql(sql?: string): string {
+  return (sql ?? "").replace(/\s+/g, " ").trim();
+}
+
+export function dataGridColumnLayoutScopeKey(scope: DataGridColumnLayoutScope): string {
+  const columnSignature = scope.columns.join("\0");
+  const sourceSignature = (scope.sourceColumns ?? []).map((column) => column ?? "").join("\0");
+  return [scope.connectionId ?? "", scope.database ?? "", scope.schema ?? "", scope.context ?? "", scope.tableSchema ?? "", scope.tableName ?? "", scope.tableName ? "" : normalizeSql(scope.sql), columnSignature, sourceSignature].join("\u0001");
+}
+
+export function loadDataGridColumnOrder(scopeKey: string, columnKeys: readonly string[]): string[] {
+  const raw = safeLocalStorageGet(`${STORAGE_PREFIX}${scopeKey}`);
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw) as Partial<StoredDataGridColumnLayout>;
+    if (parsed.version !== STORAGE_VERSION || !Array.isArray(parsed.order)) return [];
+    if (parsed.columnSignature && parsed.columnSignature !== columnKeys.join("\0")) return [];
+    return parsed.order.filter((key): key is string => typeof key === "string");
+  } catch {
+    return [];
+  }
+}
+
+export function saveDataGridColumnOrder(scopeKey: string, columnKeys: readonly string[], order: readonly string[]) {
+  const payload: StoredDataGridColumnLayout = {
+    version: STORAGE_VERSION,
+    columnSignature: columnKeys.join("\0"),
+    order: [...order],
+  };
+  safeLocalStorageSet(`${STORAGE_PREFIX}${scopeKey}`, JSON.stringify(payload));
+}
+
+export function removeDataGridColumnOrder(scopeKey: string) {
+  safeLocalStorageRemove(`${STORAGE_PREFIX}${scopeKey}`);
+}
+
+export function tableDataGridColumnOrderScopeKey(scope: TableDataGridColumnOrderScope): string {
+  const namespace = scope.schema?.trim() || scope.database;
+  return [scope.connectionId, scope.database, namespace, scope.tableName].join("\u0001");
+}
+
+export function loadTableDataGridColumnOrder(scopeKey: string): string[] {
+  const raw = safeLocalStorageGet(`${TABLE_STORAGE_PREFIX}${scopeKey}`);
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw) as Partial<StoredTableDataGridColumnOrder>;
+    if (parsed.version !== STORAGE_VERSION || !Array.isArray(parsed.order)) return [];
+    return parsed.order.filter((key): key is string => typeof key === "string");
+  } catch {
+    return [];
+  }
+}
+
+export function saveTableDataGridColumnOrder(scopeKey: string, order: readonly string[]) {
+  const payload: StoredTableDataGridColumnOrder = {
+    version: STORAGE_VERSION,
+    order: [...order],
+  };
+  safeLocalStorageSet(`${TABLE_STORAGE_PREFIX}${scopeKey}`, JSON.stringify(payload));
+}
+
+export function removeTableDataGridColumnOrder(scopeKey: string) {
+  safeLocalStorageRemove(`${TABLE_STORAGE_PREFIX}${scopeKey}`);
+}
+
+export function notifyTableDataGridColumnOrderChanged(scopeKey: string) {
+  if (typeof window === "undefined") return;
+  window.dispatchEvent(new CustomEvent<TableDataGridColumnOrderChangedDetail>(TABLE_DATA_GRID_COLUMN_ORDER_CHANGED_EVENT, { detail: { scopeKey } }));
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnLookup.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnLookup.ts
new file mode 100644
index 0000000..90b91b7
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridColumnLookup.ts
@@ -0,0 +1,53 @@
+export interface DataGridColumnLookupItem {
+  index: number;
+  name: string;
+  sourceName?: string;
+  comment?: string;
+}
+
+export interface DataGridColumnLookupOptions {
+  columns: readonly string[];
+  sourceColumns?: readonly (string | undefined)[];
+  displayableIndexes?: readonly number[];
+  commentByColumn?: ReadonlyMap<string, string>;
+}
+
+function normalizedSearchText(value: string): string {
+  return value.trim().toLocaleLowerCase();
+}
+
+function nonEmptyComment(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+export function dataGridColumnCommentFor(commentByColumn: ReadonlyMap<string, string> | undefined, columnName: string, sourceName?: string): string | undefined {
+  if (!commentByColumn) return undefined;
+  const keys = [sourceName, sourceName?.toLocaleLowerCase(), columnName, columnName.toLocaleLowerCase()].filter((value): value is string => !!value);
+  for (const key of keys) {
+    const comment = nonEmptyComment(commentByColumn.get(key));
+    if (comment) return comment;
+  }
+  return undefined;
+}
+
+export function buildDataGridColumnLookupItems(options: DataGridColumnLookupOptions): DataGridColumnLookupItem[] {
+  const indexes = options.displayableIndexes ?? options.columns.map((_, index) => index);
+  return indexes.map((index) => {
+    const name = options.columns[index] ?? `#${index + 1}`;
+    const sourceName = options.sourceColumns?.[index];
+    const comment = dataGridColumnCommentFor(options.commentByColumn, name, sourceName);
+    return {
+      index,
+      name,
+      ...(sourceName ? { sourceName } : {}),
+      ...(comment ? { comment } : {}),
+    };
+  });
+}
+
+export function filterDataGridColumnLookupItems(items: readonly DataGridColumnLookupItem[], query: string): DataGridColumnLookupItem[] {
+  const normalizedQuery = normalizedSearchText(query);
+  if (!normalizedQuery) return [...items];
+  return items.filter((item) => [item.name, item.sourceName, item.comment].filter((value): value is string => !!value).some((value) => value.toLocaleLowerCase().includes(normalizedQuery)));
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnOrder.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnOrder.ts
new file mode 100644
index 0000000..62c363c
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridColumnOrder.ts
@@ -0,0 +1,67 @@
+export function uniqueDataGridColumnOrderKeys(columns: readonly string[], sourceColumns?: readonly (string | undefined)[]): string[] {
+  const counts = new Map<string, number>();
+  return columns.map((column, index) => {
+    const base = sourceColumns?.[index] || column || `#${index + 1}`;
+    const count = counts.get(base) ?? 0;
+    counts.set(base, count + 1);
+    return `${base}\u0000${count}`;
+  });
+}
+
+export function orderedColumnIndexes(options: { availableIndexes: readonly number[]; columnKeys: readonly string[]; orderedKeys: readonly string[] }): number[] {
+  const available = new Set(options.availableIndexes);
+  const indexByKey = new Map<string, number>();
+  for (const index of options.availableIndexes) {
+    const key = options.columnKeys[index];
+    if (key) indexByKey.set(key, index);
+  }
+
+  const used = new Set<number>();
+  const ordered: number[] = [];
+  for (const key of options.orderedKeys) {
+    const index = indexByKey.get(key);
+    if (index === undefined || !available.has(index) || used.has(index)) continue;
+    ordered.push(index);
+    used.add(index);
+  }
+
+  for (const index of options.availableIndexes) {
+    if (!used.has(index)) ordered.push(index);
+  }
+
+  return ordered;
+}
+
+export function moveVisibleColumnIndex(options: { orderedIndexes: readonly number[]; hiddenIndexes: ReadonlySet<number>; fromVisibleIndex: number; toVisibleIndex: number }): number[] {
+  const visibleIndexes = options.orderedIndexes.filter((index) => !options.hiddenIndexes.has(index));
+  const fromActualIndex = visibleIndexes[options.fromVisibleIndex];
+  if (fromActualIndex === undefined) return [...options.orderedIndexes];
+
+  const withoutSource = options.orderedIndexes.filter((index) => index !== fromActualIndex);
+  const visibleWithoutSource = visibleIndexes.filter((index) => index !== fromActualIndex);
+  const targetVisibleIndex = Math.max(0, Math.min(options.toVisibleIndex, visibleWithoutSource.length));
+  if (options.fromVisibleIndex === targetVisibleIndex) return [...options.orderedIndexes];
+
+  const next = [...withoutSource];
+  if (targetVisibleIndex >= visibleWithoutSource.length) {
+    const lastVisibleIndex = visibleWithoutSource[visibleWithoutSource.length - 1];
+    const insertAfterIndex = lastVisibleIndex === undefined ? next.length - 1 : next.indexOf(lastVisibleIndex);
+    next.splice(insertAfterIndex + 1, 0, fromActualIndex);
+    return next;
+  }
+
+  const targetActualIndex = visibleWithoutSource[targetVisibleIndex];
+  const insertIndex = targetActualIndex === undefined ? next.length : next.indexOf(targetActualIndex);
+  if (insertIndex < 0) return [...options.orderedIndexes];
+  next.splice(insertIndex, 0, fromActualIndex);
+  return next;
+}
+
+export function columnOrderKeysForIndexes(indexes: readonly number[], columnKeys: readonly string[]): string[] {
+  return indexes.map((index) => columnKeys[index]).filter((key): key is string => !!key);
+}
+
+export function isDefaultColumnOrder(availableIndexes: readonly number[], orderedIndexes: readonly number[]): boolean {
+  if (availableIndexes.length !== orderedIndexes.length) return false;
+  return availableIndexes.every((index, position) => orderedIndexes[position] === index);
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnType.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnType.ts
new file mode 100644
index 0000000..43da9b4
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridColumnType.ts
@@ -0,0 +1,33 @@
+/**
+ * Resolve the data type to display in a data-grid column header.
+ *
+ * Two sources can supply a column's type:
+ *  - Table metadata (only when a table is open): matched **by column name**,
+ *    richer because it carries precision/scale. Preferred.
+ *  - `QueryResult.column_types` (any query): parallel to `result.columns`, so
+ *    it must be read **by index**. Used as a fallback for arbitrary queries
+ *    that have no table metadata (e.g. `select * from pg_depend`).
+ *
+ * Returns `undefined` when neither source has a non-empty type, so callers can
+ * simply hide the type row.
+ */
+export interface HeaderColumnTypeSources {
+  /** Type from table metadata for this column (looked up by name), if any. */
+  tableColumnType?: string;
+  /** `QueryResult.column_types`, parallel to `result.columns` (by index). */
+  resultColumnTypes?: readonly string[];
+  /** Index of the column within `result.columns`. */
+  actualColIdx: number;
+}
+
+export function resolveHeaderColumnType({ tableColumnType, resultColumnTypes, actualColIdx }: HeaderColumnTypeSources): string | undefined {
+  const fromMeta = tableColumnType?.trim();
+  if (fromMeta) return fromMeta;
+
+  const fromResult = resultColumnTypes?.[actualColIdx]?.trim();
+  return fromResult ? fromResult : undefined;
+}
+
+export function compactHeaderColumnType(dataType: string): string {
+  return /^enum\s*\(/i.test(dataType.trim()) ? "enum" : dataType;
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnVisibility.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnVisibility.ts
new file mode 100644
index 0000000..3c855bd
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridColumnVisibility.ts
@@ -0,0 +1,86 @@
+import { buildDataGridColumnLookupItems, filterDataGridColumnLookupItems } from "./dataGridColumnLookup";
+
+export interface ColumnVisibilityOption {
+  column: string;
+  comment?: string;
+  index: number;
+}
+
+export interface ColumnVisibilityFilterOptions {
+  sourceColumns?: readonly (string | undefined)[];
+  commentByColumn?: ReadonlyMap<string, string>;
+}
+
+export function filterColumnVisibilityOptions(columns: readonly string[], query: string, options: ColumnVisibilityFilterOptions = {}): ColumnVisibilityOption[] {
+  return filterDataGridColumnLookupItems(
+    buildDataGridColumnLookupItems({
+      columns,
+      sourceColumns: options.sourceColumns,
+      commentByColumn: options.commentByColumn,
+    }),
+    query,
+  ).map((item) => ({
+    column: item.name,
+    ...(item.comment ? { comment: item.comment } : {}),
+    index: item.index,
+  }));
+}
+
+export function visibleColumnIndexesForFilter(availableIndexes: number[], hiddenIndexes: ReadonlySet<number>): number[] {
+  const visibleIndexes = availableIndexes.filter((index) => !hiddenIndexes.has(index));
+  return visibleIndexes.length > 0 ? visibleIndexes : availableIndexes;
+}
+
+export function nextHiddenColumnIndexes(options: { columnIndex: number; hiddenIndexes: ReadonlySet<number>; totalColumns: number }): Set<number> {
+  const next = new Set(options.hiddenIndexes);
+  if (next.has(options.columnIndex)) {
+    next.delete(options.columnIndex);
+    return next;
+  }
+
+  if (options.totalColumns - next.size <= 1) return next;
+  next.add(options.columnIndex);
+  return next;
+}
+
+export function invertedHiddenColumnIndexes(availableIndexes: number[], hiddenIndexes: ReadonlySet<number>): Set<number> {
+  const next = new Set(availableIndexes.filter((index) => !hiddenIndexes.has(index)));
+  if (next.size === availableIndexes.length && availableIndexes.length > 0) {
+    next.delete(availableIndexes[0]);
+  }
+  return next;
+}
+
+export function allNullColumnIndexes(rows: ReadonlyArray<ReadonlyArray<unknown>>, availableIndexes: number[]): number[] {
+  if (rows.length === 0) return [];
+  return availableIndexes.filter((index) => rows.every((row) => row[index] === null));
+}
+
+export function hiddenColumnIndexesWithAllNullColumns(options: { availableIndexes: number[]; hiddenIndexes: ReadonlySet<number>; allNullIndexes: ReadonlySet<number> }): { hiddenIndexes: Set<number>; autoHiddenIndexes: Set<number> } {
+  const next = new Set(options.hiddenIndexes);
+  const autoHidden = new Set<number>();
+  const available = new Set(options.availableIndexes);
+
+  for (const index of options.allNullIndexes) {
+    if (!available.has(index) || next.has(index)) continue;
+    next.add(index);
+    autoHidden.add(index);
+  }
+
+  const hasVisibleColumn = options.availableIndexes.some((index) => !next.has(index));
+  if (!hasVisibleColumn && options.availableIndexes.length > 0) {
+    const restoredIndex = options.availableIndexes.find((index) => autoHidden.has(index)) ?? options.availableIndexes[0];
+    next.delete(restoredIndex);
+    autoHidden.delete(restoredIndex);
+  }
+
+  return { hiddenIndexes: next, autoHiddenIndexes: autoHidden };
+}
+
+export function removeAutoHiddenColumnIndexes(hiddenIndexes: ReadonlySet<number>, autoHiddenIndexes: ReadonlySet<number>): Set<number> {
+  const next = new Set(hiddenIndexes);
+  for (const index of autoHiddenIndexes) {
+    next.delete(index);
+  }
+  return next;
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridColumnWidth.ts b/apps/desktop/src/lib/dataGrid/dataGridColumnWidth.ts
new file mode 100644
index 0000000..1fad05a
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridColumnWidth.ts
@@ -0,0 +1,81 @@
+import type { ColumnWidthDensity } from "@/stores/settingsStore";
+
+type CellValue = string | number | boolean | null;
+
+export const DATA_GRID_COL_MIN_WIDTH = 60;
+export const DATA_GRID_COL_MAX_WIDTH = 400;
+export const DATA_GRID_COL_AUTO_FIT_MAX_WIDTH = 1200;
+export const DATA_GRID_CHAR_WIDTH = 8;
+export const DATA_GRID_HEADER_CONTROL_WIDTH = 80;
+export const DATA_GRID_CELL_PADDING = 28;
+export const DATA_GRID_SAMPLE_ROWS = 50;
+export const DATA_GRID_VALUE_TEXT_LIMIT = 60;
+export const DATA_GRID_AUTO_FIT_VALUE_TEXT_LIMIT = 160;
+
+export interface ColumnWidthDensityPreset {
+  charWidth: number;
+  headerControlWidth: number;
+  cellPadding: number;
+  valueTextLimit: number;
+  maxWidth: number;
+  sampleRows: number;
+  headerControlWidthCompact: number;
+}
+
+export const COLUMN_WIDTH_DENSITY_PRESETS: Record<ColumnWidthDensity, ColumnWidthDensityPreset> = {
+  compact: {
+    charWidth: 7,
+    headerControlWidth: 36,
+    headerControlWidthCompact: 20,
+    cellPadding: 18,
+    valueTextLimit: 30,
+    maxWidth: 250,
+    sampleRows: 30,
+  },
+  standard: {
+    charWidth: 8,
+    headerControlWidth: 80,
+    headerControlWidthCompact: 80,
+    cellPadding: 28,
+    valueTextLimit: 60,
+    maxWidth: 400,
+    sampleRows: 50,
+  },
+  comfortable: {
+    charWidth: 9,
+    headerControlWidth: 96,
+    headerControlWidthCompact: 96,
+    cellPadding: 36,
+    valueTextLimit: 80,
+    maxWidth: 600,
+    sampleRows: 50,
+  },
+};
+
+function estimateTextWidth(text: string, padding: number, charWidth: number): number {
+  return text.length * charWidth + padding;
+}
+
+function displaySampleValue(value: CellValue): string | null {
+  if (value == null) return null;
+  return typeof value === "object" ? JSON.stringify(value) : String(value);
+}
+
+export function calculateDataGridColumnWidth(options: { columnName: string; sampleValues: readonly CellValue[]; maxWidth?: number; valueTextLimit?: number; density?: ColumnWidthDensity; compactColumnHeaderActions?: boolean }): number {
+  const density = options.density ?? "standard";
+  const preset = COLUMN_WIDTH_DENSITY_PRESETS[density];
+  const maxAllowedWidth = options.maxWidth ?? preset.maxWidth;
+  const valueTextLimit = options.valueTextLimit ?? preset.valueTextLimit;
+  const headerControl = options.compactColumnHeaderActions ? preset.headerControlWidthCompact : preset.headerControlWidth;
+  let maxContentWidth = estimateTextWidth(options.columnName, headerControl, preset.charWidth);
+
+  for (const value of options.sampleValues.slice(0, preset.sampleRows)) {
+    const text = displaySampleValue(value);
+    if (text == null) continue;
+    const displayLen = Math.min(text.length, valueTextLimit);
+    const width = displayLen * preset.charWidth + preset.cellPadding;
+    if (width > maxContentWidth) maxContentWidth = width;
+  }
+
+  return Math.max(DATA_GRID_COL_MIN_WIDTH, Math.min(maxAllowedWidth, Math.round(maxContentWidth)));
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridConditionHistory.ts b/apps/desktop/src/lib/dataGrid/dataGridConditionHistory.ts
new file mode 100644
index 0000000..e7f3f7e
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridConditionHistory.ts
@@ -0,0 +1,78 @@
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+
+const STORAGE_KEY = "dbx-data-grid-condition-history";
+const MAX_HISTORY_PER_SCOPE = 12;
+
+export type DataGridConditionHistoryKind = "where" | "orderBy";
+
+export interface DataGridConditionHistoryScope {
+  connectionId?: string;
+  database?: string;
+  schema?: string;
+  tableName?: string;
+}
+
+interface StoredConditionHistory {
+  version: 1;
+  scopes: Record<string, string[]>;
+}
+
+function normalizeConditionInput(value: string | undefined): string {
+  return (value ?? "").trim().replace(/;+$/, "").trim();
+}
+
+export function dataGridConditionHistoryScopeKey(kind: DataGridConditionHistoryKind, scope: DataGridConditionHistoryScope): string {
+  return [kind, scope.connectionId ?? "", scope.database ?? "", scope.schema ?? "", scope.tableName ?? ""].join("\u0001");
+}
+
+function emptyHistory(): StoredConditionHistory {
+  return { version: 1, scopes: {} };
+}
+
+function readHistory(): StoredConditionHistory {
+  const raw = safeLocalStorageGet(STORAGE_KEY);
+  if (!raw) return emptyHistory();
+  try {
+    const parsed = JSON.parse(raw) as Partial<StoredConditionHistory>;
+    if (parsed.version !== 1 || !parsed.scopes || typeof parsed.scopes !== "object") return emptyHistory();
+    return { version: 1, scopes: parsed.scopes };
+  } catch {
+    return emptyHistory();
+  }
+}
+
+function writeHistory(history: StoredConditionHistory) {
+  safeLocalStorageSet(STORAGE_KEY, JSON.stringify(history));
+}
+
+export function loadDataGridConditionHistory(kind: DataGridConditionHistoryKind, scope: DataGridConditionHistoryScope, query = ""): string[] {
+  const key = dataGridConditionHistoryScopeKey(kind, scope);
+  const normalizedQuery = normalizeConditionInput(query).toLowerCase();
+  const entries = readHistory().scopes[key] ?? [];
+  if (!normalizedQuery) return entries.slice(0, MAX_HISTORY_PER_SCOPE);
+  return entries.filter((entry) => entry.toLowerCase().includes(normalizedQuery)).slice(0, MAX_HISTORY_PER_SCOPE);
+}
+
+export function rememberDataGridConditionHistory(kind: DataGridConditionHistoryKind, scope: DataGridConditionHistoryScope, value: string | undefined): string[] {
+  const normalized = normalizeConditionInput(value);
+  if (!normalized) return loadDataGridConditionHistory(kind, scope);
+
+  const history = readHistory();
+  const key = dataGridConditionHistoryScopeKey(kind, scope);
+  const previous = history.scopes[key] ?? [];
+  history.scopes[key] = [normalized, ...previous.filter((entry) => entry.toLowerCase() !== normalized.toLowerCase())].slice(0, MAX_HISTORY_PER_SCOPE);
+  writeHistory(history);
+  return history.scopes[key];
+}
+
+export function forgetDataGridConditionHistory(kind: DataGridConditionHistoryKind, scope: DataGridConditionHistoryScope, value: string | undefined): string[] {
+  const normalized = normalizeConditionInput(value);
+  if (!normalized) return loadDataGridConditionHistory(kind, scope);
+
+  const history = readHistory();
+  const key = dataGridConditionHistoryScopeKey(kind, scope);
+  history.scopes[key] = (history.scopes[key] ?? []).filter((entry) => entry.toLowerCase() !== normalized.toLowerCase());
+  if (history.scopes[key].length === 0) delete history.scopes[key];
+  writeHistory(history);
+  return loadDataGridConditionHistory(kind, scope);
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridConditionSuggestionPosition.ts b/apps/desktop/src/lib/dataGrid/dataGridConditionSuggestionPosition.ts
new file mode 100644
index 0000000..d7d4411
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridConditionSuggestionPosition.ts
@@ -0,0 +1,34 @@
+export interface DataGridConditionSuggestionRect {
+  left: number;
+  bottom: number;
+  width: number;
+}
+
+export interface DataGridConditionSuggestionPositionOptions {
+  viewportWidth: number;
+  minWidth?: number;
+  viewportMargin?: number;
+  topOffset?: number;
+}
+
+export interface DataGridConditionSuggestionPosition {
+  left: number;
+  top: number;
+  width: number;
+}
+
+export function getDataGridConditionSuggestionPosition(inputRect: DataGridConditionSuggestionRect, options: DataGridConditionSuggestionPositionOptions): DataGridConditionSuggestionPosition {
+  const minWidth = options.minWidth ?? 180;
+  const viewportMargin = options.viewportMargin ?? 8;
+  const topOffset = options.topOffset ?? 2;
+  const availableWidth = Math.max(minWidth, options.viewportWidth - viewportMargin * 2);
+  const width = Math.min(Math.max(inputRect.width, minWidth), availableWidth);
+  const maxLeft = Math.max(viewportMargin, options.viewportWidth - viewportMargin - width);
+  const left = Math.min(Math.max(inputRect.left, viewportMargin), maxLeft);
+
+  return {
+    left,
+    top: inputRect.bottom + topOffset,
+    width,
+  };
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridDetail.ts b/apps/desktop/src/lib/dataGrid/dataGridDetail.ts
new file mode 100644
index 0000000..81148d5
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridDetail.ts
@@ -0,0 +1,220 @@
+import { cellImagePreviewUrl } from "@/lib/dataGrid/cellImageUrl";
+import { displayCellValue, type CellValue } from "@/lib/dataGrid/cellValue";
+import { formatJsonText } from "@/lib/dataGrid/cellDetailPresentation";
+
+export const CELL_DETAIL_VALUE_PREVIEW_MAX_LENGTH = 12_000;
+
+export interface DataGridCellDetail {
+  rowNumber: number;
+  rowId: number;
+  colIndex: number;
+  column: string;
+  type: string;
+  comment: string;
+  value: CellValue;
+  rawValue: string;
+  rawValuePreview: string;
+  displayValue: string;
+  displayValuePreview: string;
+  isValuePreviewTruncated: boolean;
+  imagePreviewUrl: string | null;
+  length: number;
+  formattedJson: string;
+  isEditable: boolean;
+}
+
+export interface DataGridRowDetail {
+  rowNumber: number;
+  rowId: number;
+  fields: DataGridCellDetail[];
+}
+
+export interface DataGridColumnDetail {
+  colIndex: number;
+  column: string;
+  type: string;
+  comment: string;
+  fields: DataGridCellDetail[];
+}
+
+export interface BuildDataGridCellDetailOptions {
+  rowIndex: number;
+  rowId: number;
+  row: readonly CellValue[];
+  columns: readonly string[];
+  columnIndex: number;
+  typeByColumn?: ReadonlyMap<string, string>;
+  resultColumnTypes?: readonly string[];
+  commentByColumn?: ReadonlyMap<string, string>;
+  displayValue: (value: CellValue, columnIndex: number) => string;
+  isEditable: boolean;
+  includeBinaryImagePreview?: boolean;
+}
+
+export interface BuildDataGridRowDetailOptions {
+  rowIndex: number;
+  rowId: number;
+  row: readonly CellValue[];
+  columns: readonly string[];
+  columnIndexes: readonly number[];
+  typeByColumn?: ReadonlyMap<string, string>;
+  resultColumnTypes?: readonly string[];
+  commentByColumn?: ReadonlyMap<string, string>;
+  displayValue: (value: CellValue, columnIndex: number) => string;
+  isEditableColumn?: (columnIndex: number) => boolean;
+}
+
+export interface BuildDataGridColumnDetailRow {
+  rowIndex: number;
+  rowId: number;
+  row: readonly CellValue[];
+  isEditable?: boolean;
+}
+
+export interface BuildDataGridColumnDetailOptions {
+  rows: readonly BuildDataGridColumnDetailRow[];
+  columns: readonly string[];
+  columnIndex: number;
+  typeByColumn?: ReadonlyMap<string, string>;
+  resultColumnTypes?: readonly string[];
+  commentByColumn?: ReadonlyMap<string, string>;
+  displayValue: (value: CellValue, columnIndex: number) => string;
+}
+
+export function buildDataGridCellDetail(options: BuildDataGridCellDetailOptions): DataGridCellDetail | null {
+  const column = options.columns[options.columnIndex];
+  if (column === undefined) return null;
+
+  const value = options.row[options.columnIndex] ?? null;
+  const rawValue = displayCellValue(value);
+  const displayValue = options.displayValue(value, options.columnIndex);
+  const formattedJson = typeof value === "string" && looksLikeJsonContainer(value) ? (formatJsonText(value) ?? "") : "";
+  const rawValuePreview = previewText(rawValue);
+  const displayValuePreview = previewText(displayValue);
+  const type = detailColumnType(options.typeByColumn, options.resultColumnTypes, column, options.columnIndex);
+
+  return {
+    rowNumber: options.rowIndex + 1,
+    rowId: options.rowId,
+    colIndex: options.columnIndex,
+    column,
+    type,
+    comment: options.commentByColumn?.get(column) ?? "",
+    value,
+    rawValue,
+    rawValuePreview,
+    displayValue,
+    displayValuePreview,
+    isValuePreviewTruncated: rawValuePreview.length < rawValue.length || displayValuePreview.length < displayValue.length,
+    imagePreviewUrl: cellImagePreviewUrl(value, type, { binary: options.includeBinaryImagePreview !== false }),
+    length: value === null ? 0 : String(value).length,
+    formattedJson,
+    isEditable: options.isEditable,
+  };
+}
+
+export function buildDataGridColumnDetail(options: BuildDataGridColumnDetailOptions): DataGridColumnDetail | null {
+  const column = options.columns[options.columnIndex];
+  if (column === undefined) return null;
+
+  const fields = options.rows
+    .map((row) =>
+      buildDataGridCellDetail({
+        rowIndex: row.rowIndex,
+        rowId: row.rowId,
+        row: row.row,
+        columns: options.columns,
+        columnIndex: options.columnIndex,
+        typeByColumn: options.typeByColumn,
+        resultColumnTypes: options.resultColumnTypes,
+        commentByColumn: options.commentByColumn,
+        displayValue: options.displayValue,
+        isEditable: row.isEditable ?? false,
+        includeBinaryImagePreview: false,
+      }),
+    )
+    .filter((field): field is DataGridCellDetail => field !== null);
+
+  return {
+    colIndex: options.columnIndex,
+    column,
+    type: detailColumnType(options.typeByColumn, options.resultColumnTypes, column, options.columnIndex),
+    comment: options.commentByColumn?.get(column) ?? "",
+    fields,
+  };
+}
+
+export function buildDataGridRowDetail(options: BuildDataGridRowDetailOptions): DataGridRowDetail {
+  const fields = options.columnIndexes
+    .map((columnIndex) =>
+      buildDataGridCellDetail({
+        rowIndex: options.rowIndex,
+        rowId: options.rowId,
+        row: options.row,
+        columns: options.columns,
+        columnIndex,
+        typeByColumn: options.typeByColumn,
+        resultColumnTypes: options.resultColumnTypes,
+        commentByColumn: options.commentByColumn,
+        displayValue: options.displayValue,
+        isEditable: options.isEditableColumn?.(columnIndex) ?? false,
+        includeBinaryImagePreview: false,
+      }),
+    )
+    .filter((field): field is DataGridCellDetail => field !== null);
+
+  return {
+    rowNumber: options.rowIndex + 1,
+    rowId: options.rowId,
+    fields,
+  };
+}
+
+function detailColumnType(typeByColumn: ReadonlyMap<string, string> | undefined, resultColumnTypes: readonly string[] | undefined, column: string, columnIndex: number): string {
+  const fromMeta = typeByColumn?.get(column)?.trim();
+  if (fromMeta) return fromMeta;
+  return resultColumnTypes?.[columnIndex]?.trim() ?? "";
+}
+
+export function dataGridRowDetailJson(detail: DataGridRowDetail): string {
+  const row: Record<string, CellValue> = {};
+  detail.fields.forEach((field) => {
+    row[field.column] = field.value;
+  });
+  return JSON.stringify(row, null, 2);
+}
+
+export function dataGridRowDetailTsv(detail: DataGridRowDetail): string {
+  return detail.fields.map((field) => displayCellValue(field.value)).join("\t");
+}
+
+export function dataGridColumnDetailJson(detail: DataGridColumnDetail): string {
+  return JSON.stringify(
+    detail.fields.map((field) => ({
+      row: field.rowNumber,
+      value: field.value,
+    })),
+    null,
+    2,
+  );
+}
+
+export function dataGridColumnDetailTsv(detail: DataGridColumnDetail): string {
+  return detail.fields.map((field) => displayCellValue(field.value)).join("\n");
+}
+
+export function filterDataGridDetailFields<T extends DataGridCellDetail>(fields: readonly T[], keyword: string): T[] {
+  if (keyword.trim() === "") return [...fields];
+  const kw = keyword.trim().toLowerCase();
+  return fields.filter((field) => field.column.toLowerCase().includes(kw) || field.rawValuePreview.toLowerCase().includes(kw) || field.displayValuePreview.toLowerCase().includes(kw) || String(field.rowNumber).includes(kw));
+}
+
+function looksLikeJsonContainer(text: string): boolean {
+  const trimmed = text.trim();
+  return trimmed.startsWith("{") || trimmed.startsWith("[");
+}
+
+function previewText(text: string): string {
+  if (text.length <= CELL_DETAIL_VALUE_PREVIEW_MAX_LENGTH) return text;
+  return text.slice(0, CELL_DETAIL_VALUE_PREVIEW_MAX_LENGTH);
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridInfiniteScroll.ts b/apps/desktop/src/lib/dataGrid/dataGridInfiniteScroll.ts
new file mode 100644
index 0000000..9b9bcce
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridInfiniteScroll.ts
@@ -0,0 +1,36 @@
+export interface DataGridScrollPosition {
+  top: number;
+  left: number;
+}
+
+export interface DataGridScrollMetrics {
+  scrollTop: number;
+  scrollHeight: number;
+  clientHeight: number;
+}
+
+export function dataGridScrollPosition(top: number, left: number): DataGridScrollPosition {
+  return {
+    top: Math.max(0, top),
+    left: Math.max(0, left),
+  };
+}
+
+export function shouldCheckInfiniteScrollAfterScroll(previous: DataGridScrollPosition | undefined, current: DataGridScrollPosition): boolean {
+  if (!previous) return false;
+  // Shift+wheel horizontal scrolling changes scrollLeft only and must not paginate.
+  return previous.top !== current.top;
+}
+
+export function isDataGridNearScrollBottom(metrics: DataGridScrollMetrics, threshold = 100): boolean {
+  return metrics.scrollHeight - metrics.scrollTop - metrics.clientHeight < threshold;
+}
+
+export function isDataGridAtScrollBottom(metrics: DataGridScrollMetrics, tolerance = 1): boolean {
+  const maxScrollTop = Math.max(0, metrics.scrollHeight - metrics.clientHeight);
+  return maxScrollTop - metrics.scrollTop <= tolerance;
+}
+
+export function dataGridBottomScrollTop(metrics: Pick<DataGridScrollMetrics, "scrollHeight" | "clientHeight">): number {
+  return Math.max(0, metrics.scrollHeight - metrics.clientHeight);
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridPagination.ts b/apps/desktop/src/lib/dataGrid/dataGridPagination.ts
new file mode 100644
index 0000000..8fac6c1
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridPagination.ts
@@ -0,0 +1,30 @@
+export interface CanGoNextDataGridPageOptions {
+  hasMore?: boolean;
+  rowCount: number;
+  pageSize: number;
+  pageOffset?: number;
+  currentPage?: number;
+  totalRowCount?: number;
+  // True when every result row is already in memory (SQL editor result with no
+  // server-side pagination). rowCount IS the authoritative total in that case,
+  // so a full final page must not appear as "more available".
+  allRowsLoaded?: boolean;
+}
+
+export function canGoNextDataGridPage(options: CanGoNextDataGridPageOptions): boolean {
+  if (options.hasMore === true) return true;
+
+  const pageSize = Math.max(1, options.pageSize);
+  const currentOffset = typeof options.pageOffset === "number" && options.pageOffset >= 0 ? options.pageOffset : Math.max(0, (options.currentPage ?? 1) - 1) * pageSize;
+
+  const totalRowCount = options.totalRowCount;
+  if (typeof totalRowCount === "number" && Number.isFinite(totalRowCount) && totalRowCount >= 0) {
+    return currentOffset + pageSize < totalRowCount;
+  }
+
+  if (options.allRowsLoaded === true) {
+    return currentOffset + pageSize < options.rowCount;
+  }
+
+  return options.rowCount >= pageSize;
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridPaintTheme.ts b/apps/desktop/src/lib/dataGrid/dataGridPaintTheme.ts
new file mode 100644
index 0000000..264b3ae
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridPaintTheme.ts
@@ -0,0 +1,293 @@
+export interface DataGridPaintTheme {
+  background: string;
+  border: string;
+  foreground: string;
+  mutedForeground: string;
+  primary: string;
+  rowMuted: string;
+  rowNew: string;
+  rowDeleted: string;
+  cellActive: string;
+  cellDirty: string;
+  cellSelected: string;
+  cellSelectedDirty: string;
+  cellSelectedBorder: string;
+  cellSelectedSingle: string;
+  cellSelectedSingleBorder: string;
+  cellHover: string;
+  cellSearch: string;
+  cellCurrentSearch: string;
+  cellCurrentSearchBorder: string;
+  rowNumberDefault: string;
+  rowNumberNew: string;
+  rowNumberEdited: string;
+  rowNumberDeleted: string;
+  rowNumberActive: string;
+  rowNumberSelected: string;
+  rowNumberTextClean: string;
+  rowNumberTextNew: string;
+  rowNumberTextEdited: string;
+  rowNumberTextDeleted: string;
+}
+
+export const DATA_GRID_DARK_SEARCH_COLORS = {
+  match: "rgb(72, 57, 8)",
+  current: "rgb(116, 87, 0)",
+  currentBorder: "rgb(239, 177, 0)",
+} as const;
+export const DATA_GRID_DARK_ROW_NUMBER_BG = "rgb(35, 37, 42)";
+const DATA_GRID_DARK_ROW_NUMBER_NEW_BG = "rgb(33, 45, 40)";
+const DATA_GRID_DARK_ROW_NUMBER_EDITED_BG = "rgb(48, 41, 28)";
+const DATA_GRID_DARK_ROW_NUMBER_DELETED_BG = "rgb(55, 31, 32)";
+const DATA_GRID_LIGHT_ROW_NUMBER_NEW_BG = "rgb(219, 244, 233)";
+const DATA_GRID_LIGHT_ROW_NUMBER_EDITED_BG = "rgb(253, 241, 219)";
+const DATA_GRID_LIGHT_ROW_NUMBER_DELETED_BG = "rgb(255, 244, 244)";
+const CANVAS_SAFE_COLOR_RE = /^(#|rgb\(|rgba\(|hsl\(|hsla\()/i;
+const ADVANCED_COLOR_RE = /^(oklch\(|oklab\(|lab\(|lch\(|color\(|color-mix\()/i;
+let browserColorProbe: HTMLElement | null = null;
+let canvasColorProbe: CanvasRenderingContext2D | null | undefined;
+
+interface RgbaColor {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+}
+
+function parseAlpha(value: string | undefined): number {
+  if (!value) return 1;
+  const trimmed = value.trim();
+  if (trimmed.endsWith("%")) return clamp(Number.parseFloat(trimmed) / 100, 0, 1);
+  return clamp(Number.parseFloat(trimmed), 0, 1);
+}
+
+function clamp(value: number, min: number, max: number): number {
+  if (Number.isNaN(value)) return min;
+  return Math.min(max, Math.max(min, value));
+}
+
+function formatAlpha(value: number): string {
+  return Number(clamp(value, 0, 1).toFixed(3)).toString();
+}
+
+function formatRgb(color: RgbaColor): string {
+  const r = Math.round(clamp(color.r, 0, 255));
+  const g = Math.round(clamp(color.g, 0, 255));
+  const b = Math.round(clamp(color.b, 0, 255));
+  if (color.a < 1) return `rgba(${r}, ${g}, ${b}, ${formatAlpha(color.a)})`;
+  return `rgb(${r}, ${g}, ${b})`;
+}
+
+function parseRgbColor(value: string): RgbaColor | null {
+  const hex = value.match(/^#([0-9a-f]{3}|[0-9a-f]{6})$/i)?.[1];
+  if (hex) {
+    const fullHex = hex.length === 3 ? [...hex].map((char) => `${char}${char}`).join("") : hex;
+    return {
+      r: Number.parseInt(fullHex.slice(0, 2), 16),
+      g: Number.parseInt(fullHex.slice(2, 4), 16),
+      b: Number.parseInt(fullHex.slice(4, 6), 16),
+      a: 1,
+    };
+  }
+
+  const rgb = value.match(/^rgba?\((.+)\)$/i)?.[1]?.trim();
+  if (!rgb) return null;
+  const parts = rgb.includes(",") ? rgb.split(",").map((part) => part.trim()) : rgb.replace(/\s+\/\s+/, " / ").split(/\s+/);
+  const slashIndex = parts.indexOf("/");
+  const channels = slashIndex >= 0 ? parts.slice(0, slashIndex) : parts.slice(0, 3);
+  const alpha = slashIndex >= 0 ? parts[slashIndex + 1] : parts[3];
+  if (channels.length < 3) return null;
+  const [r, g, b] = channels.map((part) => Number.parseFloat(part));
+  if ([r, g, b].some((channel) => Number.isNaN(channel))) return null;
+  return { r, g, b, a: parseAlpha(alpha) };
+}
+
+function splitTopLevelCommas(value: string): string[] {
+  const parts: string[] = [];
+  let depth = 0;
+  let start = 0;
+  for (let index = 0; index < value.length; index++) {
+    const char = value[index];
+    if (char === "(") depth += 1;
+    if (char === ")") depth = Math.max(0, depth - 1);
+    if (char === "," && depth === 0) {
+      parts.push(value.slice(start, index).trim());
+      start = index + 1;
+    }
+  }
+  parts.push(value.slice(start).trim());
+  return parts;
+}
+
+function parseColorStop(value: string): { color: string; percent?: number } | null {
+  const match = value.match(/^(.*)\s+([0-9.]+)%$/);
+  if (!match) return { color: value.trim() };
+  return {
+    color: match[1]?.trim() ?? "",
+    percent: Number.parseFloat(match[2] ?? ""),
+  };
+}
+
+function mixRgb(first: RgbaColor, firstPercent: number, second: RgbaColor, secondPercent: number): RgbaColor {
+  const total = firstPercent + secondPercent || 100;
+  const firstWeight = firstPercent / total;
+  const secondWeight = secondPercent / total;
+  return {
+    r: first.r * firstWeight + second.r * secondWeight,
+    g: first.g * firstWeight + second.g * secondWeight,
+    b: first.b * firstWeight + second.b * secondWeight,
+    a: first.a * firstWeight + second.a * secondWeight,
+  };
+}
+
+function parseColorMix(value: string): string | null {
+  const body = value.match(/^color-mix\(\s*in\s+oklab\s*,\s*(.*)\)$/i)?.[1];
+  if (!body) return null;
+  const [firstRaw, secondRaw] = splitTopLevelCommas(body);
+  if (!firstRaw || !secondRaw) return null;
+  const first = parseColorStop(firstRaw);
+  const second = parseColorStop(secondRaw);
+  if (!first?.color || !second?.color || first.percent === undefined) return null;
+  const firstColor = parseRgbColor(toCanvasSafeColor(first.color, ""));
+  if (!firstColor) return null;
+  const secondPercent = second.percent ?? 100 - first.percent;
+  if (second.color.toLowerCase() === "transparent") {
+    return formatRgb({ ...firstColor, a: firstColor.a * (first.percent / 100) });
+  }
+  const secondColor = parseRgbColor(toCanvasSafeColor(second.color, ""));
+  if (!secondColor) return null;
+  return formatRgb(mixRgb(firstColor, first.percent, secondColor, secondPercent));
+}
+
+function normalizeCssColorWithBrowser(value: string): string | null {
+  if (typeof document === "undefined") return null;
+  try {
+    browserColorProbe ??= document.createElement("span");
+    const probe = browserColorProbe;
+    probe.style.color = "";
+    probe.style.color = value;
+    if (!probe.style.color) return null;
+    if (!probe.isConnected) {
+      probe.style.position = "absolute";
+      probe.style.left = "-9999px";
+      probe.style.top = "-9999px";
+      probe.style.visibility = "hidden";
+      document.body?.appendChild(probe);
+    }
+    const computed = getComputedStyle(probe).color.trim();
+    return computed || null;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeColorWithCanvas(value: string): string | null {
+  if (!value || typeof document === "undefined") return value || null;
+  try {
+    if (canvasColorProbe === undefined) {
+      canvasColorProbe = document.createElement("canvas").getContext("2d");
+    }
+    const ctx = canvasColorProbe;
+    if (!ctx) return value;
+
+    ctx.fillStyle = "#010203";
+    ctx.fillStyle = value;
+    const first = String(ctx.fillStyle);
+    if (first !== "#010203") return first;
+
+    ctx.fillStyle = "#040506";
+    ctx.fillStyle = value;
+    const second = String(ctx.fillStyle);
+    return second !== "#040506" ? second : null;
+  } catch {
+    return null;
+  }
+}
+
+function toCanvasSafeColor(value: string, fallback: string): string {
+  const trimmed = value.trim();
+  if (!trimmed) return fallback;
+  const rgb = parseRgbColor(trimmed);
+  const candidate = rgb ? formatRgb(rgb) : CANVAS_SAFE_COLOR_RE.test(trimmed) ? trimmed : ADVANCED_COLOR_RE.test(trimmed) ? (normalizeCssColorWithBrowser(trimmed) ?? parseColorMix(trimmed) ?? fallback) : `hsl(${trimmed})`;
+  return normalizeColorWithCanvas(candidate) ?? normalizeColorWithCanvas(fallback) ?? fallback;
+}
+
+export function cssVarColor(getVar: (name: string) => string, name: string, fallback: string): string {
+  return toCanvasSafeColor(getVar(name), fallback);
+}
+
+function resolveCssVarReferences(value: string, getVar: (name: string) => string, depth = 0): string {
+  if (depth > 6 || !value.includes("var(")) return value;
+  return value.replace(/var\(\s*(--[\w-]+)(?:\s*,\s*([^)]+))?\s*\)/g, (_match, name: string, fallback?: string) => {
+    const resolved = getVar(name).trim() || fallback?.trim() || "";
+    if (!resolved) return "";
+    return resolveCssVarReferences(resolved, getVar, depth + 1);
+  });
+}
+
+function paintToken(getVar: (name: string) => string, name: string, fallback: string): string {
+  const value = resolveCssVarReferences(getVar(name).trim(), getVar);
+  return toCanvasSafeColor(value, fallback);
+}
+
+export function resolveDataGridPaintTheme(options: { getVar: (name: string) => string; isDark: boolean }): DataGridPaintTheme {
+  const { getVar, isDark } = options;
+  const background = cssVarColor(getVar, "--background", isDark ? "rgb(19, 20, 22)" : "rgb(255, 255, 255)");
+  const foreground = cssVarColor(getVar, "--foreground", isDark ? "rgb(215, 215, 219)" : "rgb(10, 10, 10)");
+  const mutedForeground = cssVarColor(getVar, "--muted-foreground", isDark ? "rgb(151, 152, 157)" : "rgb(115, 115, 115)");
+  const primary = cssVarColor(getVar, "--primary", isDark ? "rgb(208, 208, 214)" : "rgb(23, 23, 23)");
+  const destructive = cssVarColor(getVar, "--destructive", isDark ? "rgb(243, 98, 95)" : "rgb(231, 0, 11)");
+  const accent = cssVarColor(getVar, "--accent", isDark ? "rgb(46, 47, 51)" : "rgb(245, 245, 245)");
+  const activeSurface = isDark ? "rgb(64, 64, 64)" : "rgb(232, 232, 232)";
+  const rowMuted = isDark ? "rgb(32, 32, 34)" : "rgb(248, 248, 248)";
+  const rowNew = isDark ? "rgb(51, 51, 55)" : "rgb(243, 243, 243)";
+  const rowDeleted = isDark ? "rgb(55, 31, 32)" : "rgb(255, 244, 244)";
+  const cellActive = activeSurface;
+  const cellDirty = isDark ? "rgb(94, 75, 26)" : "rgb(255, 248, 230)";
+  const cellSelected = isDark ? "rgb(66, 67, 70)" : "rgb(226, 226, 226)";
+  const cellSelectedDirty = isDark ? "rgb(94, 75, 26)" : "rgb(244, 229, 186)";
+  const cellSelectedBorder = isDark ? "rgb(170, 170, 175)" : "rgb(90, 90, 90)";
+  const cellSelectedSingle = isDark ? "rgb(17, 24, 39)" : "rgb(209, 213, 219)";
+  const cellHover = accent;
+  const cellSearch = isDark ? DATA_GRID_DARK_SEARCH_COLORS.match : "rgb(253, 245, 184)";
+  const cellCurrentSearch = isDark ? DATA_GRID_DARK_SEARCH_COLORS.current : "rgba(253, 224, 71, 0.52)";
+  const cellCurrentSearchBorder = isDark ? DATA_GRID_DARK_SEARCH_COLORS.currentBorder : "rgba(234, 179, 8, 0.82)";
+  const rowNumberDefault = isDark ? DATA_GRID_DARK_ROW_NUMBER_BG : paintToken(getVar, "--data-grid-row-number-default-bg", "rgb(255, 255, 255)");
+  const rowNumberNew = isDark ? DATA_GRID_DARK_ROW_NUMBER_NEW_BG : DATA_GRID_LIGHT_ROW_NUMBER_NEW_BG;
+  const rowNumberEdited = isDark ? DATA_GRID_DARK_ROW_NUMBER_EDITED_BG : DATA_GRID_LIGHT_ROW_NUMBER_EDITED_BG;
+  const rowNumberDeleted = isDark ? DATA_GRID_DARK_ROW_NUMBER_DELETED_BG : DATA_GRID_LIGHT_ROW_NUMBER_DELETED_BG;
+  const rowNumberActive = activeSurface;
+  const rowNumberSelected = isDark ? "rgb(31, 41, 55)" : "rgb(209, 213, 219)";
+
+  return {
+    background,
+    border: cssVarColor(getVar, "--border", isDark ? "rgb(63, 63, 70)" : "rgb(229, 231, 235)"),
+    foreground,
+    mutedForeground,
+    primary,
+    rowMuted: isDark ? rowMuted : paintToken(getVar, "--data-grid-row-muted-bg", rowMuted),
+    rowNew: isDark ? rowNew : paintToken(getVar, "--data-grid-row-new-bg", rowNew),
+    rowDeleted: isDark ? rowDeleted : paintToken(getVar, "--data-grid-row-deleted-bg", rowDeleted),
+    cellActive: isDark ? cellActive : paintToken(getVar, "--data-grid-cell-active-bg", cellActive),
+    cellDirty: isDark ? cellDirty : paintToken(getVar, "--data-grid-cell-dirty-bg", cellDirty),
+    cellSelected: isDark ? cellSelected : paintToken(getVar, "--data-grid-cell-selected-bg", cellSelected),
+    cellSelectedDirty: isDark ? cellSelectedDirty : paintToken(getVar, "--data-grid-cell-selected-dirty-bg", cellSelectedDirty),
+    cellSelectedBorder: isDark ? cellSelectedBorder : paintToken(getVar, "--data-grid-cell-selected-border", cellSelectedBorder),
+    cellSelectedSingle: isDark ? cellSelectedSingle : paintToken(getVar, "--data-grid-cell-selected-single-bg", cellSelectedSingle),
+    cellSelectedSingleBorder: isDark ? primary : paintToken(getVar, "--data-grid-cell-selected-single-border", primary),
+    cellHover: isDark ? cellHover : paintToken(getVar, "--data-grid-cell-hover-bg", cellHover),
+    cellSearch: isDark ? cellSearch : paintToken(getVar, "--data-grid-cell-search-bg", cellSearch),
+    cellCurrentSearch: isDark ? cellCurrentSearch : paintToken(getVar, "--data-grid-cell-current-search-bg", cellCurrentSearch),
+    cellCurrentSearchBorder: isDark ? cellCurrentSearchBorder : paintToken(getVar, "--data-grid-cell-current-search-border", cellCurrentSearchBorder),
+    rowNumberDefault,
+    rowNumberNew: isDark ? rowNumberNew : paintToken(getVar, "--data-grid-row-number-new-bg", rowNumberNew),
+    rowNumberEdited: isDark ? rowNumberEdited : paintToken(getVar, "--data-grid-row-number-edited-bg", rowNumberEdited),
+    rowNumberDeleted: isDark ? rowNumberDeleted : paintToken(getVar, "--data-grid-row-number-deleted-bg", rowNumberDeleted),
+    rowNumberActive: isDark ? rowNumberActive : paintToken(getVar, "--data-grid-row-number-active-bg", rowNumberActive),
+    rowNumberSelected: isDark ? rowNumberSelected : paintToken(getVar, "--data-grid-row-number-selected-bg", rowNumberSelected),
+    rowNumberTextClean: mutedForeground,
+    rowNumberTextNew: isDark ? "rgb(94, 233, 181)" : "rgb(0, 122, 85)",
+    rowNumberTextEdited: isDark ? "rgb(255, 210, 48)" : "rgb(187, 77, 0)",
+    rowNumberTextDeleted: destructive,
+  };
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridSaveUi.ts b/apps/desktop/src/lib/dataGrid/dataGridSaveUi.ts
new file mode 100644
index 0000000..e67ecf9
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridSaveUi.ts
@@ -0,0 +1,26 @@
+export interface DataGridSaveActionMode {
+  labelKey: "grid.commit" | "grid.save";
+  tooltipKey: "grid.transactionSaveHint" | "grid.nonTransactionalSaveHint";
+  secondaryActionKey: "grid.rollback" | "grid.discard";
+}
+
+export function dataGridSaveActionMode(options: { pendingChangeCount: number; useTransaction: boolean }): DataGridSaveActionMode {
+  return {
+    labelKey: options.useTransaction ? "grid.commit" : "grid.save",
+    tooltipKey: options.useTransaction ? "grid.transactionSaveHint" : "grid.nonTransactionalSaveHint",
+    secondaryActionKey: options.useTransaction ? "grid.rollback" : "grid.discard",
+  };
+}
+
+export interface DataGridSaveToolbarState {
+  showActions: boolean;
+  actionsDisabled: boolean;
+}
+
+export function dataGridSaveToolbarState(options: { editable: boolean; hasSaveTarget: boolean; hasPendingChanges: boolean; isSaving: boolean }): DataGridSaveToolbarState {
+  const showActions = options.editable && options.hasSaveTarget;
+  return {
+    showActions,
+    actionsDisabled: !showActions || !options.hasPendingChanges || options.isSaving,
+  };
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridScrollGutter.ts b/apps/desktop/src/lib/dataGrid/dataGridScrollGutter.ts
new file mode 100644
index 0000000..623c057
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridScrollGutter.ts
@@ -0,0 +1,7 @@
+export function scrollbarGutterWidth(element: Pick<HTMLElement, "offsetWidth" | "clientWidth">): number {
+  return Math.max(0, element.offsetWidth - element.clientWidth);
+}
+
+export function dataGridHeaderContentWidth(baseWidth: string, gutterWidth: number): string {
+  return gutterWidth > 0 ? `calc(${baseWidth} + ${gutterWidth}px)` : baseWidth;
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridSearchSplit.ts b/apps/desktop/src/lib/dataGrid/dataGridSearchSplit.ts
new file mode 100644
index 0000000..c5ccf42
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridSearchSplit.ts
@@ -0,0 +1,11 @@
+export const DEFAULT_SEARCH_SPLIT_RATIO = 0.5;
+export const MIN_SEARCH_SPLIT_PANE_WIDTH = 180;
+
+export function clampSearchSplitWidth({ containerWidth, desiredWidth }: { containerWidth: number; desiredWidth?: number }): number {
+  const fallback = containerWidth * DEFAULT_SEARCH_SPLIT_RATIO;
+  if (containerWidth <= MIN_SEARCH_SPLIT_PANE_WIDTH * 2) return fallback;
+
+  const min = MIN_SEARCH_SPLIT_PANE_WIDTH;
+  const max = containerWidth - MIN_SEARCH_SPLIT_PANE_WIDTH;
+  return Math.min(Math.max(desiredWidth ?? fallback, min), max);
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridSort.ts b/apps/desktop/src/lib/dataGrid/dataGridSort.ts
new file mode 100644
index 0000000..7909840
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridSort.ts
@@ -0,0 +1,87 @@
+export type DataGridSortDirection = "asc" | "desc";
+export type DataGridSortMode = "database" | "local";
+
+export interface DataGridSortState {
+  column: string | null;
+  columnIndex: number | null;
+  direction: DataGridSortDirection;
+}
+
+export function nextDataGridSortState(current: DataGridSortState, column: string, columnIndex: number): DataGridSortState {
+  if (current.column === column && current.columnIndex === columnIndex) {
+    if (current.direction === "asc") {
+      return { column, columnIndex, direction: "desc" };
+    }
+    return { column: null, columnIndex: null, direction: "asc" };
+  }
+  return { column, columnIndex, direction: "asc" };
+}
+
+type DataGridCellValue = string | number | boolean | null | undefined;
+type DataGridRow = DataGridCellValue[];
+
+const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
+
+export function sortDataGridRows<T extends DataGridRow>(rows: readonly T[], columnIndex: number, direction: DataGridSortDirection): T[] {
+  return sortDataGridRowIndexes(rows, columnIndex, direction).map((index) => rows[index]!);
+}
+
+export function sortDataGridRowIndexes(rows: readonly DataGridRow[], columnIndex: number, direction: DataGridSortDirection): number[] {
+  const directionMultiplier = direction === "asc" ? 1 : -1;
+  return rows
+    .map((row, index) => ({ row, index }))
+    .sort((left, right) => {
+      const emptyCompared = compareEmptyValues(left.row[columnIndex], right.row[columnIndex]);
+      if (emptyCompared !== null) return emptyCompared;
+      const compared = compareDataGridValues(left.row[columnIndex], right.row[columnIndex]);
+      if (compared !== 0) return compared * directionMultiplier;
+      return left.index - right.index;
+    })
+    .map((item) => item.index);
+}
+
+export function compareDataGridValues(left: DataGridCellValue, right: DataGridCellValue): number {
+  const leftEmpty = left == null;
+  const rightEmpty = right == null;
+  if (leftEmpty || rightEmpty) {
+    if (leftEmpty && rightEmpty) return 0;
+    return leftEmpty ? 1 : -1;
+  }
+
+  if (typeof left === "number" && typeof right === "number") {
+    return compareNumbers(left, right);
+  }
+  if (typeof left === "boolean" && typeof right === "boolean") {
+    return Number(left) - Number(right);
+  }
+  if (typeof left === "string" && typeof right === "string") {
+    const leftDate = dateSortValue(left);
+    const rightDate = dateSortValue(right);
+    if (leftDate !== null && rightDate !== null) return compareNumbers(leftDate, rightDate);
+    return collator.compare(left, right);
+  }
+
+  return collator.compare(String(left), String(right));
+}
+
+function compareEmptyValues(left: DataGridCellValue, right: DataGridCellValue): number | null {
+  const leftEmpty = left == null;
+  const rightEmpty = right == null;
+  if (!leftEmpty && !rightEmpty) return null;
+  if (leftEmpty && rightEmpty) return 0;
+  return leftEmpty ? 1 : -1;
+}
+
+function compareNumbers(left: number, right: number): number {
+  if (Number.isNaN(left) || Number.isNaN(right)) {
+    if (Number.isNaN(left) && Number.isNaN(right)) return 0;
+    return Number.isNaN(left) ? 1 : -1;
+  }
+  return left - right;
+}
+
+function dateSortValue(value: string): number | null {
+  if (!/^\d{4}-\d{2}-\d{2}/.test(value)) return null;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridSql.ts b/apps/desktop/src/lib/dataGrid/dataGridSql.ts
new file mode 100644
index 0000000..1cc9a50
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridSql.ts
@@ -0,0 +1,144 @@
+import type { DatabaseType } from "@/types/database";
+import * as api from "@/lib/backend/api";
+
+export type GridCellValue = string | number | boolean | null | unknown[] | { [key: string]: unknown };
+
+export interface DataGridTableMeta {
+  catalog?: string;
+  schema?: string;
+  tableName: string;
+  primaryKeys: string[];
+  columns?: DataGridColumnInfo[];
+}
+
+export interface DataGridColumnInfo {
+  name: string;
+  data_type: string;
+  is_nullable: boolean;
+  is_primary_key?: boolean;
+  column_default?: string | null;
+  extra?: string | null;
+}
+
+export interface DataGridSaveStatementOptions {
+  databaseType?: DatabaseType;
+  tableMeta: DataGridTableMeta;
+  columns: string[];
+  sourceColumns?: Array<string | undefined>;
+  rows: GridCellValue[][];
+  dirtyRows: Array<[number, Array<[number, GridCellValue]>]>;
+  deletedRows: number[];
+  newRows: GridCellValue[][];
+}
+
+export interface DataGridCopyUpdateStatementOptions {
+  databaseType?: DatabaseType;
+  tableMeta: DataGridTableMeta;
+  columns: string[];
+  sourceColumns?: Array<string | undefined>;
+  rows: GridCellValue[][];
+}
+
+export type DataGridCopyInsertMode = "merged" | "row-by-row";
+
+export interface DataGridCopyInsertStatementOptions {
+  databaseType?: DatabaseType;
+  tableMeta?: DataGridTableMeta;
+  columns: string[];
+  columnTypes?: Array<string | null | undefined>;
+  sourceColumns?: Array<string | undefined>;
+  rows: GridCellValue[][];
+  excludePrimaryKeys?: boolean;
+  insertMode?: DataGridCopyInsertMode;
+}
+
+export type DataGridContextFilterMode = "equals" | "not-equals" | "is-null" | "is-not-null" | "like" | "not-like" | "less-than" | "greater-than";
+
+export interface DataGridContextFilterConditionOptions {
+  databaseType?: DatabaseType;
+  columnName: string;
+  mode: DataGridContextFilterMode;
+  value: GridCellValue;
+  columnInfo?: DataGridColumnInfo;
+}
+
+export interface DataGridColumnValueFilterConditionOptions {
+  databaseType?: DatabaseType;
+  columnName: string;
+  columnInfo?: DataGridColumnInfo;
+  rawValue: string;
+}
+
+export interface DataGridColumnValuesFilterConditionOptions {
+  databaseType?: DatabaseType;
+  columnName: string;
+  columnInfo?: DataGridColumnInfo;
+  values: GridCellValue[];
+}
+
+export interface DataGridColumnDistinctValuesSqlOptions {
+  databaseType?: DatabaseType;
+  catalog?: string;
+  schema?: string;
+  tableName: string;
+  columnName: string;
+  columnInfo?: DataGridColumnInfo;
+  whereInput?: string;
+  searchValue?: string;
+  limit?: number;
+  includeCounts?: boolean;
+}
+
+export interface DataGridCountSqlOptions {
+  databaseType?: DatabaseType;
+  catalog?: string;
+  schema?: string;
+  tableName: string;
+  whereInput?: string;
+}
+
+export interface HiveTablePropertiesSqlOptions {
+  schema?: string;
+  tableName: string;
+  propertyName: string;
+}
+
+export function buildDataGridCopyUpdateStatements(options: DataGridCopyUpdateStatementOptions): Promise<string[]> {
+  return api.buildDataGridCopyUpdateStatements(options);
+}
+
+export function buildDataGridCopyInsertStatement(options: DataGridCopyInsertStatementOptions): Promise<string | undefined> {
+  return api.buildDataGridCopyInsertStatement(options);
+}
+
+export function buildDataGridContextFilterCondition(options: DataGridContextFilterConditionOptions): Promise<string | undefined> {
+  return api.buildDataGridContextFilterCondition(options);
+}
+
+export function buildDataGridColumnValueFilterCondition(options: DataGridColumnValueFilterConditionOptions): Promise<string | undefined> {
+  return api.buildDataGridColumnValueFilterCondition(options);
+}
+
+export function buildDataGridColumnValuesFilterCondition(options: DataGridColumnValuesFilterConditionOptions): Promise<string | undefined> {
+  return api.buildDataGridColumnValuesFilterCondition(options);
+}
+
+export function buildDataGridColumnDistinctValuesSql(options: DataGridColumnDistinctValuesSqlOptions): Promise<string> {
+  return api.buildDataGridColumnDistinctValuesSql(options);
+}
+
+export function buildDataGridCountSql(options: DataGridCountSqlOptions): Promise<string> {
+  return api.buildDataGridCountSql(options);
+}
+
+export function buildHiveTablePropertiesSql(options: HiveTablePropertiesSqlOptions): Promise<string> {
+  return api.buildHiveTablePropertiesSql(options);
+}
+
+export function normalizeDataGridSaveError(databaseType: DatabaseType | undefined, error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  if (databaseType === "hive" && /Attempt to do update or delete|Error 10294/i.test(message)) {
+    return "Hive UPDATE/DELETE are not enabled for this table or server. Add rows with INSERT, or enable ACID transactional tables in Hive before editing/deleting existing rows.";
+  }
+  return message;
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridTemporalEditor.ts b/apps/desktop/src/lib/dataGrid/dataGridTemporalEditor.ts
new file mode 100644
index 0000000..e03d92e
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridTemporalEditor.ts
@@ -0,0 +1,138 @@
+import type { ColumnInfo, DatabaseType } from "@/types/database";
+
+export type TemporalCellEditorKind = "date" | "time" | "datetime";
+export type TemporalCellEditorColumn = Pick<ColumnInfo, "data_type" | "numeric_scale">;
+
+export interface TemporalCellEditorConfig {
+  kind: TemporalCellEditorKind;
+  fractionPrecision: number;
+}
+
+export function temporalCellEditorConfig(columnOrDataType: string | TemporalCellEditorColumn | undefined, _databaseType?: DatabaseType): TemporalCellEditorConfig | undefined {
+  const dataType = temporalColumnDataType(columnOrDataType);
+  const numericScale = temporalColumnNumericScale(columnOrDataType);
+  const normalized = normalizeTemporalType(dataType);
+  if (!normalized) return undefined;
+  if (/\b(?:datetime|datetime2|datetime64|smalldatetime|datetimeoffset|timestamp|timestamptz)\b/.test(normalized)) {
+    return {
+      kind: "datetime",
+      fractionPrecision: normalized.includes("smalldatetime") ? 0 : temporalFractionPrecision(dataType, numericScale),
+    };
+  }
+  if (/\bdate(?:32)?\b/.test(normalized)) return { kind: "date", fractionPrecision: 0 };
+  if (/\b(?:time|timetz|time64)\b/.test(normalized)) {
+    return {
+      kind: "time",
+      fractionPrecision: temporalFractionPrecision(dataType, numericScale),
+    };
+  }
+  return undefined;
+}
+
+export function temporalCellEditorKind(dataType: string | undefined, databaseType?: DatabaseType): TemporalCellEditorKind | undefined {
+  return temporalCellEditorConfig(dataType, databaseType)?.kind;
+}
+
+export function formatTemporalInputValue(value: string | number | boolean | null, kind: TemporalCellEditorKind): string {
+  if (value === null || value === undefined) return "";
+  const text = String(value).trim();
+  if (!text) return "";
+
+  if (kind === "date") {
+    const date = text.match(/^(\d{4}-\d{2}-\d{2})/);
+    return date?.[1] ?? "";
+  }
+
+  if (kind === "time") {
+    return normalizeTimeInput(text);
+  }
+
+  const datetime = text.match(/^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2})(?::(\d{2})(\.\d{1,9})?)?/);
+  if (!datetime) return "";
+  return `${datetime[1]}T${datetime[2]}:${datetime[3] ?? "00"}${datetime[4] ?? ""}`;
+}
+
+export function parseTemporalInputValue(value: string, kind: TemporalCellEditorKind): string | null {
+  const text = value.trim();
+  if (!text) return null;
+  if (kind === "date") return text;
+  if (kind === "time") return normalizeTimeInput(text) || text;
+
+  const datetime = text.match(/^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2})(?::(\d{2})(\.\d{1,9})?)?$/);
+  if (!datetime) return text;
+  return `${datetime[1]} ${datetime[2]}:${datetime[3] ?? "00"}${datetime[4] ?? ""}`;
+}
+
+export type TemporalCellEditorPart = "year" | "month" | "day" | "hour" | "minute" | "second";
+
+export function stepTemporalInputValue(value: string, kind: TemporalCellEditorKind, part: TemporalCellEditorPart, delta: number): string {
+  const dateParts = temporalDateParts(value);
+  const timeParts = temporalTimeParts(value, kind);
+
+  if (part === "year") dateParts.year = Math.max(1, Math.min(9999, dateParts.year + delta));
+  else if (part === "month") dateParts.month = Math.max(1, Math.min(12, dateParts.month + delta));
+  else if (part === "day") dateParts.day = Math.max(1, Math.min(31, dateParts.day + delta));
+  else {
+    const max = part === "hour" ? 23 : 59;
+    timeParts[part] = (timeParts[part] + delta + max + 1) % (max + 1);
+  }
+
+  dateParts.day = Math.max(1, Math.min(daysInMonth(dateParts.year, dateParts.month), dateParts.day));
+  const dateText = [String(dateParts.year).padStart(4, "0"), String(dateParts.month).padStart(2, "0"), String(dateParts.day).padStart(2, "0")].join("-");
+  const timeText = [timeParts.hour, timeParts.minute, timeParts.second].map((item) => String(item).padStart(2, "0")).join(":") + timeParts.fraction;
+
+  if (kind === "date") return dateText;
+  if (kind === "time") return timeText;
+  return `${dateText} ${timeText}`;
+}
+
+function normalizeTemporalType(dataType: string | undefined): string {
+  return (dataType ?? "").toLowerCase().replace(/_/g, "").replace(/[(),]/g, " ").replace(/\s+/g, " ").trim();
+}
+
+function temporalColumnDataType(columnOrDataType: string | TemporalCellEditorColumn | undefined): string | undefined {
+  return typeof columnOrDataType === "string" ? columnOrDataType : columnOrDataType?.data_type;
+}
+
+function temporalColumnNumericScale(columnOrDataType: string | TemporalCellEditorColumn | undefined): number | null | undefined {
+  return typeof columnOrDataType === "string" ? undefined : columnOrDataType?.numeric_scale;
+}
+
+function temporalFractionPrecision(dataType: string | undefined, numericScale?: number | null): number {
+  if (numericScale !== null && numericScale !== undefined) return clampFractionPrecision(numericScale);
+  const precision = dataType?.match(/\((\d{1,2})/)?.[1];
+  if (!precision) return 0;
+  return clampFractionPrecision(Number(precision));
+}
+
+function clampFractionPrecision(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(9, Math.trunc(value)));
+}
+
+function normalizeTimeInput(text: string): string {
+  const match = text.match(/^(\d{2}:\d{2})(?::(\d{2})(\.\d{1,9})?)?/);
+  if (!match) return "";
+  return `${match[1]}:${match[2] ?? "00"}${match[3] ?? ""}`;
+}
+
+function temporalDateParts(value: string): { year: number; month: number; day: number } {
+  const text = formatTemporalInputValue(value, "date");
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
+  if (!match) {
+    const now = new Date();
+    return { year: now.getFullYear(), month: now.getMonth() + 1, day: now.getDate() };
+  }
+  return { year: Number(match[1]), month: Number(match[2]), day: Number(match[3]) };
+}
+
+function temporalTimeParts(value: string, kind: TemporalCellEditorKind): { hour: number; minute: number; second: number; fraction: string } {
+  const time = kind === "time" ? formatTemporalInputValue(value, "time") || "00:00:00" : formatTemporalInputValue(value, "datetime").split("T")[1] || "00:00:00";
+  const match = /^(\d{2}):(\d{2}):(\d{2})(\.\d{1,9})?$/.exec(time);
+  if (!match) return { hour: 0, minute: 0, second: 0, fraction: "" };
+  return { hour: Number(match[1]) || 0, minute: Number(match[2]) || 0, second: Number(match[3]) || 0, fraction: match[4] ?? "" };
+}
+
+function daysInMonth(year: number, month: number): number {
+  return new Date(year, month, 0).getDate();
+}
diff --git a/apps/desktop/src/lib/dataGrid/dataGridToolbar.ts b/apps/desktop/src/lib/dataGrid/dataGridToolbar.ts
new file mode 100644
index 0000000..3dd1173
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridToolbar.ts
@@ -0,0 +1,3 @@
+export const DATA_GRID_COMPACT_TOPBAR_WIDTH = 900;
+
+export type DataGridReloadIntent = "refresh";
diff --git a/apps/desktop/src/lib/dataGrid/dataGridTranspose.ts b/apps/desktop/src/lib/dataGrid/dataGridTranspose.ts
new file mode 100644
index 0000000..463cb24
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/dataGridTranspose.ts
@@ -0,0 +1,297 @@
+import { COLUMN_WIDTH_DENSITY_PRESETS } from "@/lib/dataGrid/dataGridColumnWidth";
+import type { ColumnWidthDensity } from "@/stores/settingsStore";
+
+export interface DataGridTransposeState {
+  showTranspose: boolean;
+  transposeRowIndex: number | null;
+}
+
+export interface BuildTransposeRowsOptions<T> {
+  columns: string[];
+  records: T[][];
+  typeByColumn?: Map<string, string>;
+  displayValue: (value: T, column: string, columnIndex: number, recordIndex: number) => string;
+}
+
+export interface DataGridTransposeCell<T> {
+  value: T;
+  display: string;
+  isNull: boolean;
+}
+
+export interface DataGridVisibleTransposeCell<T> extends DataGridTransposeCell<T> {
+  recordIndex: number;
+  valueIndex: number;
+}
+
+export interface DataGridTransposeRow<T> {
+  id: string;
+  column: string;
+  type: string;
+  values: Array<DataGridTransposeCell<T>>;
+}
+
+export interface DataGridVisibleTransposeRow<T> {
+  id: string;
+  column: string;
+  type: string;
+  values: Array<DataGridVisibleTransposeCell<T>>;
+}
+
+export interface BuildVisibleTransposeRowsOptions<T> extends BuildTransposeRowsOptions<T> {
+  recordIndexes: number[];
+  valueIndexes?: number[];
+}
+
+export interface TransposeRecordWindowOptions {
+  totalRecords: number;
+  scrollLeft: number;
+  viewportWidth: number;
+  pinnedWidth: number;
+  recordWidth: number;
+  overscan?: number;
+}
+
+export interface TransposeRecordWindow {
+  start: number;
+  end: number;
+  beforeWidth: number;
+  afterWidth: number;
+}
+
+export interface TransposeSelectionRange {
+  startRow: number;
+  endRow: number;
+  startCol: number;
+  endCol: number;
+}
+
+export interface TransposeAnchorOptions {
+  requestedRowIndex: number;
+  rowIds: number[];
+  selectedRowIds: Set<number>;
+  selectedRange: TransposeSelectionRange | null;
+}
+
+export interface ContextTransposeStateOptions extends TransposeAnchorOptions {
+  showTranspose: boolean;
+  transposeRowIndex: number | null;
+}
+
+export type KeyboardTransposeStateOptions = ContextTransposeStateOptions;
+
+export interface TransposeFieldWidthOptions {
+  minWidth?: number;
+  maxWidth?: number;
+  charWidth?: number;
+  padding?: number;
+  density?: ColumnWidthDensity;
+}
+
+export interface TransposeRecordWidthsOptions {
+  records: readonly (readonly unknown[])[];
+  density: ColumnWidthDensity;
+  previousWidths?: readonly number[];
+  manualWidthIndexes?: ReadonlySet<number>;
+}
+
+const TRANSPOSE_RECORD_MIN_WIDTH = 96;
+const TRANSPOSE_RECORD_DEFAULT_WIDTH = 168;
+const TRANSPOSE_FIELD_MIN_WIDTH = 104;
+const TRANSPOSE_FIELD_MAX_WIDTH = 220;
+const STANDARD_CHAR_WIDTH = COLUMN_WIDTH_DENSITY_PRESETS.standard.charWidth;
+
+function densityScaledWidth(width: number, density: ColumnWidthDensity): number {
+  return Math.round((width * COLUMN_WIDTH_DENSITY_PRESETS[density].charWidth) / STANDARD_CHAR_WIDTH);
+}
+
+function transposeDisplayText(value: unknown): string {
+  if (value === null || value === undefined) return "";
+  return typeof value === "object" ? (JSON.stringify(value) ?? String(value)) : String(value);
+}
+
+export function defaultTransposeRecordWidth(density: ColumnWidthDensity): number {
+  return densityScaledWidth(TRANSPOSE_RECORD_DEFAULT_WIDTH, density);
+}
+
+export function minTransposeRecordWidth(density: ColumnWidthDensity): number {
+  return densityScaledWidth(TRANSPOSE_RECORD_MIN_WIDTH, density);
+}
+
+export function minTransposeFieldWidth(density: ColumnWidthDensity): number {
+  return densityScaledWidth(TRANSPOSE_FIELD_MIN_WIDTH, density);
+}
+
+export function calculateTransposeRecordWidth(values: readonly unknown[], density: ColumnWidthDensity): number {
+  const preset = COLUMN_WIDTH_DENSITY_PRESETS[density];
+  const minWidth = minTransposeRecordWidth(density);
+  let maxWidth = minWidth;
+  for (const value of values) {
+    const displayLen = Math.min(transposeDisplayText(value).length, preset.valueTextLimit);
+    maxWidth = Math.max(maxWidth, displayLen * preset.charWidth + preset.cellPadding);
+  }
+  return Math.max(minWidth, Math.min(preset.maxWidth, Math.round(maxWidth)));
+}
+
+export function transposeRecordWidthsForDensity(options: TransposeRecordWidthsOptions): number[] {
+  const previousWidths = options.previousWidths ?? [];
+  const manualWidthIndexes = options.manualWidthIndexes ?? new Set<number>();
+  return options.records.map((record, index) => (manualWidthIndexes.has(index) && previousWidths[index] !== undefined ? previousWidths[index] : calculateTransposeRecordWidth(record, options.density)));
+}
+
+export function averageTransposeRecordWidth(widths: readonly number[], density: ColumnWidthDensity): number {
+  if (widths.length === 0) return defaultTransposeRecordWidth(density);
+  return widths.reduce((sum, width) => sum + width, 0) / widths.length;
+}
+
+export interface TransposeScrollLeftOptions {
+  recordIndex: number;
+  totalRecords: number;
+  viewportWidth: number;
+  pinnedWidth: number;
+  recordWidth: number;
+}
+
+export interface TransposeRecordIndexesForModeOptions {
+  multiRow: boolean;
+  activeRecordIndex: number | null;
+  totalRecords: number;
+  visibleRecordIndexes: number[];
+}
+
+export function nextTransposeState(showTranspose: boolean, transposeRowIndex: number | null, requestedRowIndex: number): DataGridTransposeState {
+  if (showTranspose && transposeRowIndex === requestedRowIndex) {
+    return { showTranspose: false, transposeRowIndex: null };
+  }
+  return { showTranspose: true, transposeRowIndex: requestedRowIndex };
+}
+
+export function nextContextTransposeState(options: ContextTransposeStateOptions): DataGridTransposeState {
+  const anchorRowIndex = transposeAnchorRowIndex(options);
+  return nextTransposeState(options.showTranspose, options.transposeRowIndex, anchorRowIndex);
+}
+
+export function nextKeyboardTransposeState(options: KeyboardTransposeStateOptions): DataGridTransposeState {
+  if (options.showTranspose) return { showTranspose: false, transposeRowIndex: null };
+  if (options.rowIds.length === 0) return { showTranspose: false, transposeRowIndex: null };
+  const requestedRowIndex = Math.max(0, Math.min(options.rowIds.length - 1, options.requestedRowIndex));
+  const anchorRowIndex = transposeAnchorRowIndex({ ...options, requestedRowIndex });
+  return { showTranspose: true, transposeRowIndex: anchorRowIndex };
+}
+
+export function nextAppendedTransposeState(showTranspose: boolean, totalRecords: number): DataGridTransposeState {
+  if (!showTranspose || totalRecords <= 0) return { showTranspose: false, transposeRowIndex: null };
+  return { showTranspose: true, transposeRowIndex: totalRecords - 1 };
+}
+
+export function nextTransposeStateForRecordCount(showTranspose: boolean, transposeRowIndex: number | null, totalRecords: number): DataGridTransposeState {
+  if (!showTranspose || totalRecords <= 0) return { showTranspose: false, transposeRowIndex: null };
+  const requestedRowIndex = transposeRowIndex ?? 0;
+  return {
+    showTranspose: true,
+    transposeRowIndex: Math.max(0, Math.min(totalRecords - 1, requestedRowIndex)),
+  };
+}
+
+export function buildTransposeRows<T>(options: BuildTransposeRowsOptions<T>): Array<DataGridTransposeRow<T>> {
+  return options.columns.map((column, columnIndex) => {
+    return {
+      id: `${columnIndex}:${column}`,
+      column,
+      type: options.typeByColumn?.get(column) || "",
+      values: options.records.map((record, recordIndex) => {
+        const value = record[columnIndex] as T;
+        return {
+          value,
+          display: options.displayValue(value, column, columnIndex, recordIndex),
+          isNull: value === null,
+        };
+      }),
+    };
+  });
+}
+
+export function buildVisibleTransposeRows<T>(options: BuildVisibleTransposeRowsOptions<T>): Array<DataGridVisibleTransposeRow<T>> {
+  return options.columns.map((column, columnIndex) => {
+    return {
+      id: `${columnIndex}:${column}`,
+      column,
+      type: options.typeByColumn?.get(column) || "",
+      values: options.recordIndexes.flatMap((recordIndex) => {
+        const record = options.records[recordIndex];
+        if (!record) return [];
+        const valueIndex = options.valueIndexes?.[columnIndex] ?? columnIndex;
+        const value = record[valueIndex] as T;
+        return [
+          {
+            recordIndex,
+            valueIndex,
+            value,
+            display: options.displayValue(value, column, columnIndex, recordIndex),
+            isNull: value === null,
+          },
+        ];
+      }),
+    };
+  });
+}
+
+export function visibleTransposeRecordWindow(options: TransposeRecordWindowOptions): TransposeRecordWindow {
+  if (options.totalRecords <= 0 || options.recordWidth <= 0) {
+    return { start: 0, end: 0, beforeWidth: 0, afterWidth: 0 };
+  }
+
+  const overscan = options.overscan ?? 2;
+  const recordScrollLeft = Math.max(0, options.scrollLeft - options.pinnedWidth);
+  const recordViewportWidth = Math.max(0, options.viewportWidth - options.pinnedWidth);
+  const start = Math.max(0, Math.floor(recordScrollLeft / options.recordWidth) - overscan);
+  const end = Math.min(options.totalRecords, Math.ceil((recordScrollLeft + recordViewportWidth) / options.recordWidth) + overscan + 1);
+
+  return {
+    start,
+    end,
+    beforeWidth: start * options.recordWidth,
+    afterWidth: Math.max(0, (options.totalRecords - end) * options.recordWidth),
+  };
+}
+
+export function transposeRecordIndexesForMode(options: TransposeRecordIndexesForModeOptions): number[] {
+  if (options.totalRecords <= 0) return [];
+  if (options.multiRow) return options.visibleRecordIndexes;
+  const requested = options.activeRecordIndex ?? 0;
+  return [Math.max(0, Math.min(options.totalRecords - 1, requested))];
+}
+
+export function transposeAnchorRowIndex(options: TransposeAnchorOptions): number {
+  const requestedRowId = options.rowIds[options.requestedRowIndex];
+  if (requestedRowId !== undefined && options.selectedRowIds.size > 1 && options.selectedRowIds.has(requestedRowId)) {
+    const firstSelectedIndex = options.rowIds.findIndex((rowId) => options.selectedRowIds.has(rowId));
+    if (firstSelectedIndex >= 0) return firstSelectedIndex;
+  }
+
+  const range = options.selectedRange;
+  if (range && range.startRow !== range.endRow && options.requestedRowIndex >= range.startRow && options.requestedRowIndex <= range.endRow) {
+    return range.startRow;
+  }
+
+  return options.requestedRowIndex;
+}
+
+export function transposeFieldWidth(columns: string[], options: TransposeFieldWidthOptions = {}): number {
+  const density = options.density ?? "standard";
+  const preset = COLUMN_WIDTH_DENSITY_PRESETS[density];
+  const minWidth = options.minWidth ?? minTransposeFieldWidth(density);
+  const maxWidth = options.maxWidth ?? densityScaledWidth(TRANSPOSE_FIELD_MAX_WIDTH, density);
+  const charWidth = options.charWidth ?? preset.charWidth;
+  const padding = options.padding ?? preset.cellPadding + 4;
+  const longest = columns.reduce((max, column) => Math.max(max, column.length), 0);
+  return Math.min(maxWidth, Math.max(minWidth, Math.ceil(longest * charWidth + padding)));
+}
+
+export function transposeScrollLeftForRecord(options: TransposeScrollLeftOptions): number {
+  if (options.recordWidth <= 0 || options.totalRecords <= 0) return 0;
+  const desired = Math.max(0, options.recordIndex) * options.recordWidth;
+  const totalWidth = options.pinnedWidth + options.totalRecords * options.recordWidth;
+  const maxScrollLeft = Math.max(0, totalWidth - options.viewportWidth);
+  return Math.min(desired, maxScrollLeft);
+}
diff --git a/apps/desktop/src/lib/dataGrid/geometryMapPreview.ts b/apps/desktop/src/lib/dataGrid/geometryMapPreview.ts
new file mode 100644
index 0000000..8991b11
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/geometryMapPreview.ts
@@ -0,0 +1,84 @@
+import { Map as MapIcon } from "@lucide/vue";
+import { registerPreviewAction } from "@/lib/dataGrid/resultPreviewRegistry";
+import { wktToGeoJson } from "@/lib/dataGrid/geometryPreview";
+import LayerPreviewDialog from "@/components/grid/LayerPreviewDialog.vue";
+
+registerPreviewAction({
+  id: "geometry-map-preview",
+  label: "grid.layerPreview",
+  icon: MapIcon,
+  isAvailable(result) {
+    return (result.column_types ?? []).some((t) => {
+      const base = (t ?? "")
+        .trim()
+        .toLowerCase()
+        .split(/[(:\s]/)[0];
+      return base === "geometry" || base === "geography";
+    });
+  },
+  execute(ctx) {
+    const geomIndices = geometryColumnIndices(ctx.result.column_types);
+    if (geomIndices.length === 0) return null;
+
+    const features: Record<string, any>[] = [];
+    const seen = new Set<string>();
+
+    for (const ref of ctx.displayRowRefs) {
+      if (ref.isNew) continue;
+      // Only include selected rows if there's an active selection
+      if (ctx.selectedRowIds.length > 0 && !ctx.selectedRowIds.includes(ref.id)) continue;
+      const row = ctx.result.rows[ref.sourceIndex];
+      if (!row) continue;
+      for (const colIdx of geomIndices) {
+        const raw = row[colIdx];
+        if (raw === null || raw === undefined) continue;
+        const wkt = String(raw);
+        if (wkt.startsWith("0x") || seen.has(wkt)) continue;
+        seen.add(wkt);
+        const geom = wktToGeoJson(wkt);
+        if (geom) {
+          // Include all non-geometry column values as properties for labelling.
+          const props: Record<string, any> = {
+            _column: ctx.result.columns[colIdx],
+            _row: ref.sourceIndex,
+          };
+          for (let c = 0; c < ctx.result.columns.length; c++) {
+            if (geomIndices.includes(c)) continue; // skip geometry columns
+            const colName = ctx.result.columns[c] ?? `col_${c}`;
+            const val = row[c];
+            props[colName] = val ?? null;
+          }
+          features.push({
+            type: "Feature",
+            geometry: geom,
+            properties: props,
+          });
+        }
+      }
+    }
+
+    if (features.length === 0) return null;
+
+    const fc = { type: "FeatureCollection", features };
+
+    return {
+      component: LayerPreviewDialog,
+      props: {
+        geojson: JSON.stringify(fc),
+      },
+    };
+  },
+});
+
+function geometryColumnIndices(columnTypes: readonly string[] | undefined): number[] {
+  if (!columnTypes) return [];
+  const indices: number[] = [];
+  for (let i = 0; i < columnTypes.length; i++) {
+    const base = (columnTypes[i] ?? "")
+      .trim()
+      .toLowerCase()
+      .split(/[(:\s]/)[0];
+    if (base === "geometry" || base === "geography") indices.push(i);
+  }
+  return indices;
+}
diff --git a/apps/desktop/src/lib/dataGrid/geometryPreview.ts b/apps/desktop/src/lib/dataGrid/geometryPreview.ts
new file mode 100644
index 0000000..b5daad1
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/geometryPreview.ts
@@ -0,0 +1,396 @@
+type Coord = [number, number];
+
+interface GeometryGroup {
+  coords: Coord[];
+  children: GeometryGroup[];
+}
+
+function tokenize(wkt: string): (string | number)[] {
+  const tokens: (string | number)[] = [];
+  let i = 0;
+  while (i < wkt.length) {
+    const ch = wkt[i];
+    if (ch === "(" || ch === ")" || ch === ",") {
+      tokens.push(ch);
+      i++;
+    } else if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r") {
+      i++;
+    } else if ((ch >= "0" && ch <= "9") || ch === "-" || ch === "+" || ch === ".") {
+      const m = wkt.slice(i).match(/^[+-]?\d*\.?\d+(?:[eE][+-]?\d+)?/);
+      if (m) {
+        tokens.push(parseFloat(m[0]));
+        i += m[0].length;
+      } else {
+        i++;
+      }
+    } else {
+      // skip alphabetic keywords (type names, EMPTY, Z, M, etc.)
+      const word = wkt.slice(i).match(/^[A-Za-z]+/);
+      if (word) {
+        i += word[0].length;
+      } else {
+        i++;
+      }
+    }
+  }
+  return tokens;
+}
+
+function parseCoordSequence(tokens: (string | number)[], start: number): { coords: Coord[]; end: number } {
+  const coords: Coord[] = [];
+  let i = start;
+  while (i < tokens.length) {
+    if (typeof tokens[i] === "number") {
+      const x = tokens[i] as number;
+      i++;
+      const y = i < tokens.length && typeof tokens[i] === "number" ? (tokens[i] as number) : 0;
+      i++;
+      coords.push([x, y]);
+      // skip Z/M values
+      while (i < tokens.length && typeof tokens[i] === "number") i++;
+    } else if (tokens[i] === ",") {
+      i++;
+    } else {
+      break;
+    }
+  }
+  return { coords, end: i };
+}
+
+function parseGroups(tokens: (string | number)[], start: number): { groups: GeometryGroup[]; end: number } {
+  const groups: GeometryGroup[] = [];
+  let i = start;
+  while (i < tokens.length) {
+    if (tokens[i] === "(") {
+      const inner = parseGroups(tokens, i + 1);
+      if (inner.groups.length === 0) {
+        // leaf group: parse as coordinate sequence
+        const seq = parseCoordSequence(tokens, i + 1);
+        groups.push({ coords: seq.coords, children: [] });
+        i = seq.end;
+      } else {
+        groups.push({ coords: [], children: inner.groups });
+        i = inner.end;
+      }
+      if (i < tokens.length && tokens[i] === ")") i++;
+    } else if (tokens[i] === ")") {
+      break;
+    } else if (tokens[i] === ",") {
+      i++;
+    } else if (typeof tokens[i] === "number") {
+      const seq = parseCoordSequence(tokens, i);
+      groups.push({ coords: seq.coords, children: [] });
+      i = seq.end;
+    } else {
+      i++;
+    }
+  }
+  return { groups, end: i };
+}
+
+function flattenCoords(groups: GeometryGroup[]): Coord[] {
+  const result: Coord[] = [];
+  for (const g of groups) {
+    for (const c of g.coords) result.push(c);
+    const childCoords = flattenCoords(g.children);
+    for (const c of childCoords) result.push(c);
+  }
+  return result;
+}
+
+// Walk a group recursively and return the first non-empty coordinate sequence found
+function extractCoords(g: GeometryGroup): Coord[] {
+  if (g.coords.length > 0) return g.coords;
+  for (const child of g.children) {
+    const found = extractCoords(child);
+    if (found.length > 0) return found;
+  }
+  return [];
+}
+
+// Draw polygon exterior + holes from a group structure
+function drawPolygonRings(ctx: CanvasRenderingContext2D, group: GeometryGroup, mapX: (v: number) => number, mapY: (v: number) => number) {
+  // group.children contains ring groups
+  const rings = group.children.length > 0 ? group.children : [group];
+  let ringIndex = 0;
+  for (const ringGroup of rings) {
+    const coords = extractCoords(ringGroup);
+    if (coords.length < 2) continue;
+    ctx.beginPath();
+    ctx.moveTo(mapX(coords[0][0]), mapY(coords[0][1]));
+    for (let j = 1; j < coords.length; j++) {
+      ctx.lineTo(mapX(coords[j][0]), mapY(coords[j][1]));
+    }
+    ctx.closePath();
+    if (ringIndex === 0) ctx.fill();
+    ctx.stroke();
+    ringIndex++;
+  }
+}
+
+function drawGroups(ctx: CanvasRenderingContext2D, groups: GeometryGroup[], type: string, mapX: (v: number) => number, mapY: (v: number) => number) {
+  if (type === "POINT" || type === "MULTIPOINT") {
+    const allCoords = flattenCoords(groups);
+    for (const [x, y] of allCoords) {
+      ctx.beginPath();
+      ctx.arc(mapX(x), mapY(y), 3, 0, Math.PI * 2);
+      ctx.fill();
+    }
+    return;
+  }
+
+  if (type === "LINESTRING" || type === "MULTILINESTRING") {
+    for (const g of groups) {
+      const coords = extractCoords(g);
+      if (coords.length >= 2) {
+        ctx.beginPath();
+        ctx.moveTo(mapX(coords[0][0]), mapY(coords[0][1]));
+        for (let i = 1; i < coords.length; i++) {
+          ctx.lineTo(mapX(coords[i][0]), mapY(coords[i][1]));
+        }
+        ctx.stroke();
+      }
+    }
+    return;
+  }
+
+  if (type === "POLYGON") {
+    for (const g of groups) {
+      drawPolygonRings(ctx, g, mapX, mapY);
+    }
+    return;
+  }
+
+  if (type === "MULTIPOLYGON") {
+    for (const g of groups) {
+      if (g.children.length > 0) {
+        for (const polyChild of g.children) {
+          drawPolygonRings(ctx, polyChild, mapX, mapY);
+        }
+      }
+    }
+    return;
+  }
+
+  // GEOMETRYCOLLECTION or unknown: draw all coordinate sequences
+  for (const g of groups) {
+    const coords = extractCoords(g);
+    if (coords.length >= 2) {
+      ctx.beginPath();
+      ctx.moveTo(mapX(coords[0][0]), mapY(coords[0][1]));
+      for (let i = 1; i < coords.length; i++) {
+        ctx.lineTo(mapX(coords[i][0]), mapY(coords[i][1]));
+      }
+      ctx.stroke();
+    } else if (coords.length === 1) {
+      const [x, y] = coords[0];
+      ctx.beginPath();
+      ctx.arc(mapX(x), mapY(y), 3, 0, Math.PI * 2);
+      ctx.fill();
+    }
+
+    // recurse for type-less children
+    if (coords.length === 0) {
+      drawGroups(ctx, g.children, "", mapX, mapY);
+    }
+  }
+}
+
+function detectWktType(wkt: string): string {
+  const m = wkt.trim().match(/^([A-Za-z]+)/);
+  return m ? m[1].toUpperCase() : "GEOMETRYCOLLECTION";
+}
+
+// EWKB parsing on the backend can fall back to hex for unsupported geometry types
+// (e.g. TIN, Triangle, CircularString). Don't attempt to render hex as WKT.
+export function isHexGeometry(value: string): boolean {
+  return value.startsWith("0x");
+}
+
+export function renderWktOnCanvas(canvas: HTMLCanvasElement, wkt: string): void {
+  if (isHexGeometry(wkt)) {
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return;
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    ctx.fillStyle = "#888";
+    ctx.font = "12px sans-serif";
+    ctx.textAlign = "center";
+    ctx.fillText("Preview not available for binary format", canvas.width / 2, canvas.height / 2);
+    return;
+  }
+
+  const type = detectWktType(wkt);
+  const tokens = tokenize(wkt);
+  const { groups } = parseGroups(tokens, 0);
+  const allCoords = flattenCoords(groups);
+
+  const ctx = canvas.getContext("2d");
+  if (!ctx) return;
+
+  const W = canvas.width;
+  const H = canvas.height;
+  const pad = 20;
+
+  ctx.clearRect(0, 0, W, H);
+
+  if (allCoords.length === 0) {
+    ctx.fillStyle = "#888";
+    ctx.font = "12px sans-serif";
+    ctx.textAlign = "center";
+    ctx.fillText("Empty geometry", W / 2, H / 2);
+    return;
+  }
+
+  let minX = Infinity,
+    maxX = -Infinity,
+    minY = Infinity,
+    maxY = -Infinity;
+  for (const [x, y] of allCoords) {
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+  }
+
+  if (minX === maxX && minY === maxY) {
+    minX -= 1;
+    maxX += 1;
+    minY -= 1;
+    maxY += 1;
+  }
+
+  const rangeX = maxX - minX || 1;
+  const rangeY = maxY - minY || 1;
+  const scale = Math.min((W - pad * 2) / rangeX, (H - pad * 2) / rangeY);
+
+  const midX = (minX + maxX) / 2;
+  const midY = (minY + maxY) / 2;
+
+  const mapX = (x: number) => (x - midX) * scale + W / 2;
+  const mapY = (y: number) => -(y - midY) * scale + H / 2;
+
+  ctx.strokeStyle = "#3b82f6";
+  ctx.fillStyle = "rgba(59, 130, 246, 0.15)";
+  ctx.lineWidth = 1.5;
+  ctx.lineJoin = "round";
+  ctx.lineCap = "round";
+
+  drawGroups(ctx, groups, type, mapX, mapY);
+}
+
+/** GeoJSON geometry type. */
+export interface GeoJsonGeometry {
+  type: string;
+  coordinates?: any;
+  geometries?: (GeoJsonGeometry | null)[];
+}
+
+/**
+ * Convert a WKT geometry string to a GeoJSON geometry object.
+ * Returns `null` for binary (hex) geometries or parse failures.
+ */
+export function wktToGeoJson(wkt: string): GeoJsonGeometry | null {
+  if (isHexGeometry(wkt)) return null;
+  const type = detectWktType(wkt);
+  if (type === "GEOMETRYCOLLECTION") return geometryCollectionToGeoJson(wkt);
+  const tokens = tokenize(wkt);
+  const { groups } = parseGroups(tokens, 0);
+  if (groups.length === 0) return null;
+  try {
+    switch (type) {
+      case "POINT":
+        return pointToGeoJson(groups);
+      case "MULTIPOINT":
+        return multiPointToGeoJson(groups);
+      case "LINESTRING":
+        return lineStringToGeoJson(groups);
+      case "MULTILINESTRING":
+        return multiLineStringToGeoJson(groups);
+      case "POLYGON":
+        return polygonToGeoJson(groups);
+      case "MULTIPOLYGON":
+        return multiPolygonToGeoJson(groups);
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+
+// ── GeoJSON conversion helpers ─────────────────────────────────────────────
+
+function getLeafCoords(g: GeometryGroup): number[][] {
+  if (g.coords.length > 0) return g.coords;
+  for (const child of g.children) {
+    const found = getLeafCoords(child);
+    if (found.length > 0) return found;
+  }
+  return [];
+}
+
+function pointToGeoJson(groups: GeometryGroup[]): GeoJsonGeometry {
+  const leaf = getLeafCoords(groups[0]);
+  return { type: "Point", coordinates: leaf[0] ?? [0, 0] };
+}
+
+function multiPointToGeoJson(groups: GeometryGroup[]): GeoJsonGeometry {
+  if (groups[0].coords.length > 0) {
+    return { type: "MultiPoint", coordinates: groups[0].coords };
+  }
+  const coords = groups[0].children.map((c) => getLeafCoords(c)[0] ?? [0, 0]);
+  return { type: "MultiPoint", coordinates: coords };
+}
+
+function lineStringToGeoJson(groups: GeometryGroup[]): GeoJsonGeometry {
+  return { type: "LineString", coordinates: getLeafCoords(groups[0]) };
+}
+
+function multiLineStringToGeoJson(groups: GeometryGroup[]): GeoJsonGeometry {
+  const lines = groups[0].children;
+  const coords = lines.map((l) => getLeafCoords(l));
+  return { type: "MultiLineString", coordinates: coords };
+}
+
+function polygonToGeoJson(groups: GeometryGroup[]): GeoJsonGeometry {
+  const rings = groups[0].children.map((c) => getLeafCoords(c));
+  return { type: "Polygon", coordinates: rings };
+}
+
+function multiPolygonToGeoJson(groups: GeometryGroup[]): GeoJsonGeometry {
+  const polygons = groups[0].children;
+  const coords = polygons.map((p) => p.children.map((c) => getLeafCoords(c)));
+  return { type: "MultiPolygon", coordinates: coords };
+}
+
+function geometryCollectionToGeoJson(wkt: string): GeoJsonGeometry | null {
+  const inner = wkt.trim().replace(/^GEOMETRYCOLLECTION\s*/i, "");
+  if (!inner.startsWith("(") || !inner.endsWith(")")) return null;
+  const content = inner.slice(1, -1).trim();
+  if (!content) return null;
+  const parts = splitGeomCollectionMembers(content);
+  return {
+    type: "GeometryCollection",
+    geometries: parts.map((p) => wktToGeoJson(p)),
+  };
+}
+
+/** Split GEOMETRYCOLLECTION content into individual WKT geometry strings. */
+function splitGeomCollectionMembers(content: string): string[] {
+  const parts: string[] = [];
+  let depth = 0;
+  let start = 0;
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] === "(") depth++;
+    else if (content[i] === ")") depth--;
+    else if (content[i] === "," && depth === 0) {
+      parts.push(content.slice(start, i).trim());
+      start = i + 1;
+    }
+    i++;
+  }
+  const last = content.slice(start).trim();
+  if (last) parts.push(last);
+  return parts;
+}
diff --git a/apps/desktop/src/lib/dataGrid/gridRowStatus.ts b/apps/desktop/src/lib/dataGrid/gridRowStatus.ts
new file mode 100644
index 0000000..5a7b045
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/gridRowStatus.ts
@@ -0,0 +1,29 @@
+export type RowStatus = "clean" | "edited" | "new" | "deleted" | "draft";
+export type RowStatusFilter = "all" | "changed" | "edited" | "new" | "deleted";
+
+export function matchesRowStatusFilter(status: RowStatus, filter: RowStatusFilter): boolean {
+  if (status === "draft") return filter === "all";
+  if (filter === "all") return true;
+  if (filter === "changed") return status !== "clean";
+  return status === filter;
+}
+
+export function rowStatusFilterAfterAddingRow(filter: RowStatusFilter): RowStatusFilter {
+  return matchesRowStatusFilter("new", filter) ? filter : "all";
+}
+
+export function shouldShowQuickEntryDraftRow(options: { editable: boolean; hasInsertTarget: boolean; quickEntryEnabled: boolean; rowStatusFilter: RowStatusFilter; hasPendingChanges: boolean }): boolean {
+  return options.editable && options.hasInsertTarget && options.quickEntryEnabled && !options.hasPendingChanges && matchesRowStatusFilter("draft", options.rowStatusFilter);
+}
+
+export function canDeleteGridRowItem(options: { editable: boolean; isDraft: boolean; isDeleted: boolean; isNew: boolean; canEditExistingRows: boolean; isSavingNewRow: boolean }): boolean {
+  return options.editable && !options.isDraft && !options.isDeleted && !options.isSavingNewRow && (options.isNew || options.canEditExistingRows);
+}
+
+export function canEditGridCellDetail(options: { canEditCell: boolean; isDraft: boolean }): boolean {
+  return options.canEditCell && !options.isDraft;
+}
+
+export function canApplyGridSelectionValue(options: { isDraft: boolean; allowDraft?: boolean }): boolean {
+  return !options.isDraft || options.allowDraft === true;
+}
diff --git a/apps/desktop/src/lib/dataGrid/gridSelection.ts b/apps/desktop/src/lib/dataGrid/gridSelection.ts
new file mode 100644
index 0000000..df368c1
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/gridSelection.ts
@@ -0,0 +1,162 @@
+export type GridCellValue = string | number | boolean | null;
+
+export interface CellPosition {
+  rowIndex: number;
+  colIndex: number;
+}
+
+export interface CellSelectionRange {
+  startRow: number;
+  endRow: number;
+  startCol: number;
+  endCol: number;
+}
+
+export interface SelectionData {
+  columns: string[];
+  rows: GridCellValue[][];
+}
+
+export interface SelectionSummary {
+  cellCount: number;
+  rowCount: number;
+  numericCount: number;
+  sum: number;
+}
+
+export function parseClipboardTable(text: string): string[][] {
+  const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n$/, "");
+  if (!normalized) return [[""]];
+  return normalized.split("\n").map((row) => row.split("\t"));
+}
+
+export function normalizeSelectedColumnIndexes(columnIndexes: Iterable<number>): number[] {
+  return [...new Set(columnIndexes)].filter((index) => index >= 0).sort((a, b) => a - b);
+}
+
+export function normalizeSelectionRange(anchor: CellPosition, focus: CellPosition): CellSelectionRange {
+  return {
+    startRow: Math.min(anchor.rowIndex, focus.rowIndex),
+    endRow: Math.max(anchor.rowIndex, focus.rowIndex),
+    startCol: Math.min(anchor.colIndex, focus.colIndex),
+    endCol: Math.max(anchor.colIndex, focus.colIndex),
+  };
+}
+
+export function rowSelectionRange(rowIndex: number, columnCount: number, endRowIndex = rowIndex): CellSelectionRange | null {
+  if (rowIndex < 0 || endRowIndex < 0 || columnCount <= 0) return null;
+  return {
+    startRow: Math.min(rowIndex, endRowIndex),
+    endRow: Math.max(rowIndex, endRowIndex),
+    startCol: 0,
+    endCol: columnCount - 1,
+  };
+}
+
+export function columnSelectionRange(rowCount: number, colIndex: number, endColIndex = colIndex): CellSelectionRange | null {
+  if (rowCount <= 0 || colIndex < 0 || endColIndex < 0) return null;
+  return {
+    startRow: 0,
+    endRow: rowCount - 1,
+    startCol: Math.min(colIndex, endColIndex),
+    endCol: Math.max(colIndex, endColIndex),
+  };
+}
+
+export function allCellsSelectionRange(rowCount: number, columnCount: number): CellSelectionRange | null {
+  if (rowCount <= 0 || columnCount <= 0) return null;
+  return { startRow: 0, endRow: rowCount - 1, startCol: 0, endCol: columnCount - 1 };
+}
+
+export function isCellInSelection(rowIndex: number, colIndex: number, range: CellSelectionRange | null): boolean {
+  if (!range) return false;
+  return rowIndex >= range.startRow && rowIndex <= range.endRow && colIndex >= range.startCol && colIndex <= range.endCol;
+}
+
+export function extractSelection(columns: readonly string[], rows: readonly GridCellValue[][], range: CellSelectionRange | null): SelectionData {
+  if (!range) return { columns: [], rows: [] };
+
+  const selectedColumns = columns.slice(range.startCol, range.endCol + 1);
+  const selectedRows = rows.slice(range.startRow, range.endRow + 1).map((row) => row.slice(range.startCol, range.endCol + 1));
+
+  return { columns: selectedColumns, rows: selectedRows };
+}
+
+export function extractColumnsSelection(columns: readonly string[], rows: readonly GridCellValue[][], selectedColumnIndexes: Iterable<number>): SelectionData {
+  const normalizedIndexes = normalizeSelectedColumnIndexes(selectedColumnIndexes).filter((index) => index < columns.length);
+  if (normalizedIndexes.length === 0) return { columns: [], rows: [] };
+
+  return {
+    columns: normalizedIndexes.map((index) => columns[index]),
+    rows: rows.map((row) => normalizedIndexes.map((index) => row[index] ?? null)),
+  };
+}
+
+export function summarizeSelection(selection: SelectionData): SelectionSummary {
+  let numericCount = 0;
+  let sum = 0;
+
+  for (const row of selection.rows) {
+    for (const value of row) {
+      const numericValue = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
+      if (Number.isFinite(numericValue)) {
+        numericCount += 1;
+        sum += numericValue;
+      }
+    }
+  }
+
+  return {
+    cellCount: selection.rows.reduce((count, row) => count + row.length, 0),
+    rowCount: selection.rows.length,
+    numericCount,
+    sum,
+  };
+}
+
+function displayValue(value: GridCellValue): string {
+  if (value === null) return "NULL";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+
+function csvValue(value: GridCellValue | string): string {
+  const text = typeof value === "string" ? value : displayValue(value);
+  return `"${text.replace(/"/g, '""')}"`;
+}
+
+function sqlValue(value: GridCellValue): string {
+  if (value === null) return "NULL";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+export function formatSelectionAsTsv(selection: SelectionData, includeHeader = false): string {
+  const body = selection.rows.map((row) => row.map(displayValue).join("\t")).join("\n");
+  if (!includeHeader) return body;
+  return [selection.columns.join("\t"), body].filter(Boolean).join("\n");
+}
+
+export function formatSelectionAsCsv(selection: SelectionData): string {
+  const header = selection.columns.map(csvValue).join(",");
+  const body = selection.rows.map((row) => row.map(csvValue).join(",")).join("\n");
+  return [header, body].filter(Boolean).join("\n");
+}
+
+export function formatSelectionAsJson(selection: SelectionData): string {
+  const objects = selection.rows.map((row) => {
+    const item: Record<string, GridCellValue> = {};
+    selection.columns.forEach((column, index) => {
+      item[column] = row[index] ?? null;
+    });
+    return item;
+  });
+  return JSON.stringify(objects, null, 2);
+}
+
+export function formatSelectionAsSqlInList(selection: SelectionData): string {
+  const values = selection.rows.flat().map(sqlValue);
+  return `(${values.join(", ")})`;
+}
diff --git a/apps/desktop/src/lib/dataGrid/imagePreviewViewer.ts b/apps/desktop/src/lib/dataGrid/imagePreviewViewer.ts
new file mode 100644
index 0000000..aa50f93
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/imagePreviewViewer.ts
@@ -0,0 +1,70 @@
+export const IMAGE_PREVIEW_MIN_SCALE = 0.2;
+export const IMAGE_PREVIEW_MAX_SCALE = 8;
+export const IMAGE_PREVIEW_ZOOM_STEP = 0.2;
+
+export type ImagePreviewZoomDirection = "in" | "out";
+
+export function clampImagePreviewScale(scale: number): number {
+  if (!Number.isFinite(scale)) return 1;
+  return Math.min(Math.max(Number(scale.toFixed(2)), IMAGE_PREVIEW_MIN_SCALE), IMAGE_PREVIEW_MAX_SCALE);
+}
+
+export function nextImagePreviewScale(scale: number, direction: ImagePreviewZoomDirection): number {
+  const delta = direction === "in" ? IMAGE_PREVIEW_ZOOM_STEP : -IMAGE_PREVIEW_ZOOM_STEP;
+  return clampImagePreviewScale(scale + delta);
+}
+
+export function imagePreviewFitScale(options: { imageWidth: number; imageHeight: number; viewportWidth: number; viewportHeight: number; paddingRatio?: number }): number {
+  if (options.imageWidth <= 0 || options.imageHeight <= 0 || options.viewportWidth <= 0 || options.viewportHeight <= 0) {
+    return 1;
+  }
+  const paddingRatio = options.paddingRatio ?? 0.9;
+  const widthScale = (options.viewportWidth * paddingRatio) / options.imageWidth;
+  const heightScale = (options.viewportHeight * paddingRatio) / options.imageHeight;
+  return clampImagePreviewScale(Math.min(widthScale, heightScale, 1));
+}
+
+export function imagePreviewTransform(options: { scale: number; offsetX: number; offsetY: number }): string {
+  return `translate(${options.offsetX}px, ${options.offsetY}px) scale(${options.scale})`;
+}
+
+export function imagePreviewDialogSize(options: {
+  imageWidth: number;
+  imageHeight: number;
+  viewportWidth: number;
+  viewportHeight: number;
+  toolbarHeight?: number;
+  maxWidthRatio?: number;
+  maxHeightRatio?: number;
+  maxWidth?: number;
+  maxHeight?: number;
+  minWidth?: number;
+  minStageHeight?: number;
+}): { width: number; height: number } | null {
+  if (options.imageWidth <= 0 || options.imageHeight <= 0 || options.viewportWidth <= 0 || options.viewportHeight <= 0) {
+    return null;
+  }
+
+  const toolbarHeight = options.toolbarHeight ?? 48;
+  const maxWidth = Math.min(options.viewportWidth * (options.maxWidthRatio ?? 0.92), options.maxWidth ?? 1280);
+  const maxHeight = Math.min(options.viewportHeight * (options.maxHeightRatio ?? 0.86), options.maxHeight ?? 920);
+  const maxStageHeight = Math.max(1, maxHeight - toolbarHeight);
+  const minWidth = Math.min(maxWidth, options.minWidth ?? 360);
+  const minStageHeight = Math.min(maxStageHeight, options.minStageHeight ?? 180);
+  const imageRatio = options.imageWidth / options.imageHeight;
+  let stageWidth = maxWidth;
+  let stageHeight = stageWidth / imageRatio;
+
+  if (stageHeight > maxStageHeight) {
+    stageHeight = maxStageHeight;
+    stageWidth = stageHeight * imageRatio;
+  }
+
+  stageWidth = Math.min(maxWidth, Math.max(stageWidth, minWidth));
+  stageHeight = Math.min(maxStageHeight, Math.max(stageHeight, minStageHeight));
+
+  return {
+    width: Math.max(1, Math.floor(stageWidth)),
+    height: Math.max(1, Math.floor(stageHeight + toolbarHeight)),
+  };
+}
diff --git a/apps/desktop/src/lib/dataGrid/paginationPageSize.ts b/apps/desktop/src/lib/dataGrid/paginationPageSize.ts
new file mode 100644
index 0000000..4228c48
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/paginationPageSize.ts
@@ -0,0 +1,17 @@
+export const RESULT_PAGE_SIZE_OPTIONS = [50, 100, 500, 1000];
+export const DEFAULT_RESULT_PAGE_SIZE = 100;
+export const MIN_RESULT_PAGE_SIZE = 1;
+export const MAX_RESULT_PAGE_SIZE = 100000;
+
+export function normalizeResultPageSize(value: unknown, fallback = DEFAULT_RESULT_PAGE_SIZE): number {
+  const fallbackValue = Number.isFinite(fallback) && fallback >= MIN_RESULT_PAGE_SIZE ? Math.min(Math.floor(fallback), MAX_RESULT_PAGE_SIZE) : DEFAULT_RESULT_PAGE_SIZE;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return fallbackValue;
+  const rounded = Math.floor(parsed);
+  if (rounded < MIN_RESULT_PAGE_SIZE) return fallbackValue;
+  return Math.min(rounded, MAX_RESULT_PAGE_SIZE);
+}
+
+export function resultPageSizeMenuOptions(current: number): number[] {
+  return [...new Set([...RESULT_PAGE_SIZE_OPTIONS, normalizeResultPageSize(current)])].sort((a, b) => a - b);
+}
diff --git a/apps/desktop/src/lib/dataGrid/resultPreviewRegistry.ts b/apps/desktop/src/lib/dataGrid/resultPreviewRegistry.ts
new file mode 100644
index 0000000..065f378
--- /dev/null
+++ b/apps/desktop/src/lib/dataGrid/resultPreviewRegistry.ts
@@ -0,0 +1,63 @@
+import type { Component } from "vue";
+import type { QueryResult } from "@/types/database";
+
+/**
+ * Configuration returned by a preview action when the user activates it.
+ * DataGrid renders the component with the given props in a dialog.
+ */
+export interface PreviewDialogConfig {
+  component: Component;
+  props: Record<string, any>;
+}
+
+/**
+ * Context passed to a preview action's `execute` method.
+ */
+export interface PreviewActionContext {
+  result: QueryResult;
+  selectedRowIds: readonly number[];
+  displayRowRefs: readonly { id: number; sourceIndex: number; isNew: boolean }[];
+}
+
+/**
+ * A preview action that can appear in the result grid's context menu.
+ * Handlers register themselves and are discovered by DataGrid via the registry.
+ */
+export interface PreviewAction {
+  /** Unique identifier for this action. */
+  id: string;
+  /** Display label in the context menu. */
+  label: string;
+  /** Optional icon component for the menu item. */
+  icon?: Component;
+  /** Check whether this action should be shown for the given query result. */
+  isAvailable(result: Pick<QueryResult, "columns" | "column_types">): boolean;
+  /**
+   * Execute the action. Returns a dialog configuration to render, or null
+   * if nothing to show (e.g. no applicable data in selected rows).
+   */
+  execute(ctx: PreviewActionContext): PreviewDialogConfig | null;
+}
+
+const actions = new Map<string, PreviewAction>();
+
+/**
+ * Register a preview action that will be offered in the result grid
+ * context menu when its `isAvailable` check passes.
+ */
+export function registerPreviewAction(action: PreviewAction): void {
+  actions.set(action.id, action);
+}
+
+/**
+ * Get all registered actions that are applicable for the given result.
+ */
+export function getApplicablePreviewActions(result: Pick<QueryResult, "columns" | "column_types">): PreviewAction[] {
+  const applicable: PreviewAction[] = [];
+  for (const action of actions.values()) {
+    if (action.isAvailable(result)) {
+      applicable.push(action);
+    }
+  }
+  return applicable;
+}
diff --git a/apps/desktop/src/lib/database/__tests__/productionExecutionGuard.spec.ts b/apps/desktop/src/lib/database/__tests__/productionExecutionGuard.spec.ts
new file mode 100644
index 0000000..ba95ffd
--- /dev/null
+++ b/apps/desktop/src/lib/database/__tests__/productionExecutionGuard.spec.ts
@@ -0,0 +1,119 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createPinia, setActivePinia } from "pinia";
+import { executeWithProductionSqlGuard } from "../productionExecutionGuard";
+import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
+import type { ConnectionConfig } from "@/types/database";
+
+function connection(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
+  return {
+    id: "conn-1",
+    name: "Operations",
+    db_type: "mysql",
+    host: "db.internal",
+    port: 3306,
+    username: "operator",
+    password: "",
+    production_databases: ["prod_app"],
+    ...overrides,
+  };
+}
+
+describe("production SQL execution guard", () => {
+  beforeEach(() => {
+    setActivePinia(createPinia());
+  });
+
+  it("waits for confirmation before executing production SQL", async () => {
+    const execute = vi.fn().mockResolvedValue("done");
+    const pendingExecution = executeWithProductionSqlGuard({
+      connection: connection(),
+      database: "prod_app",
+      sql: "DELETE FROM users WHERE id = 1",
+      source: "Schema diff",
+      execute,
+    });
+
+    await Promise.resolve();
+    const store = useProductionSafetyStore();
+    expect(store.pending).toMatchObject({
+      sql: "DELETE FROM users WHERE id = 1",
+      database: "prod_app",
+      productionDatabases: ["prod_app"],
+      source: "Schema diff",
+    });
+    expect(execute).not.toHaveBeenCalled();
+
+    store.confirm();
+    await expect(pendingExecution).resolves.toBe("done");
+    expect(execute).toHaveBeenCalledTimes(1);
+  });
+
+  it("cancels production SQL without executing the callback", async () => {
+    const execute = vi.fn().mockResolvedValue("done");
+    const pendingExecution = executeWithProductionSqlGuard({
+      connection: connection(),
+      database: "prod_app",
+      sql: "TRUNCATE TABLE users",
+      source: "Object tree",
+      execute,
+    });
+
+    await Promise.resolve();
+    useProductionSafetyStore().cancel();
+
+    await expect(pendingExecution).resolves.toBeUndefined();
+    expect(execute).not.toHaveBeenCalled();
+  });
+
+  it("queues concurrent production confirmations", async () => {
+    const firstExecute = vi.fn().mockResolvedValue("first");
+    const secondExecute = vi.fn().mockResolvedValue("second");
+    const firstSql = "DELETE FROM prod_app.users WHERE id = 1";
+    const secondSql = "DELETE FROM prod_app.audit_log WHERE id = 2";
+    const firstExecution = executeWithProductionSqlGuard({
+      connection: connection(),
+      database: "staging",
+      sql: firstSql,
+      source: "Schema diff",
+      execute: firstExecute,
+    });
+    const secondExecution = executeWithProductionSqlGuard({
+      connection: connection(),
+      database: "staging",
+      sql: secondSql,
+      source: "Data compare",
+      execute: secondExecute,
+    });
+
+    await Promise.resolve();
+    const store = useProductionSafetyStore();
+    expect(store.pending?.sql).toBe(firstSql);
+    expect(firstExecute).not.toHaveBeenCalled();
+    expect(secondExecute).not.toHaveBeenCalled();
+
+    store.confirm();
+    await expect(firstExecution).resolves.toBe("first");
+    expect(firstExecute).toHaveBeenCalledTimes(1);
+    expect(store.pending?.sql).toBe(secondSql);
+
+    store.cancel();
+    await expect(secondExecution).resolves.toBeUndefined();
+    expect(secondExecute).not.toHaveBeenCalled();
+  });
+
+  it("executes non-production SQL immediately", async () => {
+    const execute = vi.fn().mockResolvedValue("done");
+    await expect(
+      executeWithProductionSqlGuard({
+        connection: connection(),
+        database: "staging",
+        sql: "UPDATE staging.users SET active = 1 WHERE id = 1",
+        source: "Data compare",
+        execute,
+      }),
+    ).resolves.toBe("done");
+
+    expect(useProductionSafetyStore().pending).toBeUndefined();
+    expect(execute).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/apps/desktop/src/lib/database/__tests__/productionSafety.spec.ts b/apps/desktop/src/lib/database/__tests__/productionSafety.spec.ts
new file mode 100644
index 0000000..c23fd36
--- /dev/null
+++ b/apps/desktop/src/lib/database/__tests__/productionSafety.spec.ts
@@ -0,0 +1,117 @@
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "node:fs";
+import { assessProductionSql, isProductionMutation, productionContextForDatabase } from "../productionSafety";
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+
+interface ProductionSafetyCorpusCase {
+  name: string;
+  dialect: DatabaseType;
+  productionDatabases: string[];
+  activeDatabase: string;
+  sql: string;
+  active: boolean;
+  isMutation: boolean;
+  databases: string[];
+}
+
+const productionSafetyCorpus = JSON.parse(readFileSync(new URL("../../../../../../tests/fixtures/production-safety-corpus.json", import.meta.url), "utf8")) as ProductionSafetyCorpusCase[];
+
+function connection(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
+  return {
+    id: "conn-1",
+    name: "Operations",
+    db_type: "mysql",
+    host: "db.internal",
+    port: 3306,
+    username: "readonly",
+    password: "",
+    production_databases: ["prod_app"],
+    ...overrides,
+  };
+}
+
+describe("production SQL safety", () => {
+  it("marks an explicitly production connection regardless of database", () => {
+    expect(productionContextForDatabase(connection({ is_production: true }), "scratch").active).toBe(true);
+  });
+
+  it("marks only configured production databases for multi-database connections", () => {
+    expect(productionContextForDatabase(connection(), "PROD_APP").active).toBe(true);
+    expect(productionContextForDatabase(connection(), "staging").active).toBe(false);
+  });
+
+  it("detects a write after a USE production switch despite comments", () => {
+    const assessment = assessProductionSql("-- install\nUSE `prod_app`; /* migration */ DELETE FROM users", connection(), "staging");
+    expect(assessment).toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+  });
+
+  it("detects qualified production targets in multi-statement SQL", () => {
+    const assessment = assessProductionSql("SELECT ';' AS literal; DELETE FROM `prod_app`.`orders`; UPDATE staging.users SET active = 1", connection(), "staging");
+    expect(assessment).toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+  });
+
+  it("detects production database DDL without a selected production database", () => {
+    expect(assessProductionSql("DROP DATABASE IF EXISTS prod_app", connection(), "staging")).toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+  });
+
+  it("detects production writes hidden behind parser-sensitive SQL forms", () => {
+    for (const sql of ["EXPLAIN ANALYZE DELETE FROM prod_app.users WHERE id = 1", "/*! DELETE FROM prod_app.users WHERE id = 1 */", "COPY prod_app.users FROM '/tmp/users.csv'", "SELECT * INTO prod_app.backup_users FROM users", "SELECT * FROM prod_app.users INTO OUTFILE '/tmp/users.csv'"]) {
+      expect(assessProductionSql(sql, connection(), "staging")).toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+    }
+  });
+
+  it("matches the shared SQL target safety corpus", () => {
+    for (const corpusCase of productionSafetyCorpus) {
+      const assessment = assessProductionSql(
+        corpusCase.sql,
+        connection({
+          db_type: corpusCase.dialect,
+          production_databases: corpusCase.productionDatabases,
+        }),
+        corpusCase.activeDatabase,
+      );
+      expect(
+        {
+          active: assessment.active,
+          isMutation: assessment.isMutation,
+          databases: assessment.databases,
+        },
+        corpusCase.name,
+      ).toEqual({
+        active: corpusCase.active,
+        isMutation: corpusCase.isMutation,
+        databases: corpusCase.databases,
+      });
+    }
+  });
+
+  it("detects qualified procedure calls and privilege targets", () => {
+    for (const sql of ["CALL prod_app.purge_users()", "CALL `prod_app`.`purge_users`()", "GRANT ALL ON prod_app.* TO 'u'@'%'", "GRANT EXECUTE ON PROCEDURE prod_app.purge_users TO 'u'@'%'"]) {
+      expect(assessProductionSql(sql, connection(), "staging")).toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+    }
+  });
+
+  it("allows resolved non-production procedure and privilege targets", () => {
+    expect(assessProductionSql("CALL staging.purge_users()", connection(), "staging")).toMatchObject({ active: false, isMutation: true });
+    expect(assessProductionSql("GRANT ALL ON staging.* TO 'u'@'%'", connection(), "staging")).toMatchObject({ active: false, isMutation: true });
+  });
+
+  it("conservatively confirms ambiguous production targets", () => {
+    for (const sql of ["CALL purge_users()", "GRANT PROCESS ON *.* TO 'u'@'%'", "GRANT ALL ON users TO 'u'@'%'", "CREATE USER 'u'@'%'"]) {
+      expect(assessProductionSql(sql, connection(), "staging")).toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+    }
+  });
+
+  it("does not treat read-only qualified references as write targets", () => {
+    expect(assessProductionSql("SELECT * FROM prod_app.orders; DELETE FROM staging.users WHERE id = 1", connection(), "staging")).toMatchObject({ active: false, isMutation: true });
+  });
+
+  it("treats unrecognized SQL as a production mutation until proven read-only", () => {
+    expect(isProductionMutation("MAINTAIN UNKNOWN THING")).toBe(true);
+    expect(assessProductionSql("MAINTAIN UNKNOWN THING", connection(), "prod_app")).toMatchObject({ active: true, isMutation: true });
+  });
+
+  it("does not require a production confirmation for reads", () => {
+    expect(assessProductionSql("SELECT * FROM prod_app.orders", connection(), "staging")).toMatchObject({ active: false, isMutation: false });
+  });
+});
diff --git a/apps/desktop/src/lib/database/createDatabaseCharsetOptions.ts b/apps/desktop/src/lib/database/createDatabaseCharsetOptions.ts
new file mode 100644
index 0000000..d84e662
--- /dev/null
+++ b/apps/desktop/src/lib/database/createDatabaseCharsetOptions.ts
@@ -0,0 +1,112 @@
+type QueryLikeResult = {
+  columns: string[];
+  rows: (string | number | boolean | null)[][];
+};
+
+export interface CreateDatabaseCharsetMetadata {
+  charsets: string[];
+  collationsByCharset: Record<string, string[]>;
+}
+
+export const CREATE_DATABASE_CHARSET_OPTIONS = ["utf8mb4", "utf8", "gbk", "latin1", "ascii", "big5", "gb2312", "utf16", "utf32"] as const;
+
+const FALLBACK_COLLATION_OPTIONS: Record<string, string[]> = {
+  ascii: ["ascii_general_ci", "ascii_bin"],
+  big5: ["big5_chinese_ci", "big5_bin"],
+  gb2312: ["gb2312_chinese_ci", "gb2312_bin"],
+  gbk: ["gbk_chinese_ci", "gbk_bin"],
+  latin1: ["latin1_swedish_ci", "latin1_general_ci", "latin1_bin"],
+  utf16: ["utf16_general_ci", "utf16_unicode_ci", "utf16_bin"],
+  utf32: ["utf32_general_ci", "utf32_unicode_ci", "utf32_bin"],
+  utf8: ["utf8mb3_general_ci", "utf8mb3_unicode_ci", "utf8mb3_bin"],
+  utf8mb3: ["utf8mb3_general_ci", "utf8mb3_unicode_ci", "utf8mb3_bin"],
+  utf8mb4: ["utf8mb4_unicode_ci", "utf8mb4_general_ci", "utf8mb4_bin"],
+};
+
+export function normalizeCreateDatabaseCharset(value: string): string {
+  return value.trim();
+}
+
+export function normalizeCreateDatabaseCharsetKey(value: string): string {
+  const normalized = normalizeCreateDatabaseCharset(value).toLowerCase();
+  return normalized === "utf8" ? "utf8mb3" : normalized;
+}
+
+export function createDatabaseCollationOptionsForCharset(charset: string, collationsByCharset: Record<string, string[]> = FALLBACK_COLLATION_OPTIONS): string[] {
+  return collationsByCharset[normalizeCreateDatabaseCharsetKey(charset)] ?? [];
+}
+
+export function defaultCreateDatabaseCollationForCharset(charset: string, collationsByCharset: Record<string, string[]> = FALLBACK_COLLATION_OPTIONS): string {
+  return createDatabaseCollationOptionsForCharset(charset, collationsByCharset)[0] ?? "";
+}
+
+export function nextCreateDatabaseCollation(nextCharset: string, previousCharset: string, currentCollation: string, collationsByCharset: Record<string, string[]> = FALLBACK_COLLATION_OPTIONS): string {
+  const previousDefault = defaultCreateDatabaseCollationForCharset(previousCharset, collationsByCharset);
+  if (currentCollation && currentCollation !== previousDefault) return currentCollation;
+  return defaultCreateDatabaseCollationForCharset(nextCharset, collationsByCharset) || currentCollation;
+}
+
+export function fallbackCreateDatabaseCharsetMetadata(): CreateDatabaseCharsetMetadata {
+  return {
+    charsets: [...CREATE_DATABASE_CHARSET_OPTIONS],
+    collationsByCharset: { ...FALLBACK_COLLATION_OPTIONS },
+  };
+}
+
+export function parseCreateDatabaseCharsetMetadata(charsetResult: QueryLikeResult, collationResult: QueryLikeResult): CreateDatabaseCharsetMetadata {
+  const charsetNameIndex = columnIndex(charsetResult.columns, ["charset", "character set", "character_set_name"]);
+  const charsetDefaultCollationIndex = columnIndex(charsetResult.columns, ["default collation", "default_collate_name", "default_collation_name"]);
+  const collationNameIndex = columnIndex(collationResult.columns, ["collation", "collation_name"]);
+  const collationCharsetIndex = columnIndex(collationResult.columns, ["charset", "character_set_name"]);
+  const collationDefaultIndex = columnIndex(collationResult.columns, ["default", "is_default"]);
+
+  const charsets = uniqueStrings(charsetResult.rows.map((row) => cellString(row[charsetNameIndex])));
+  const collationsByCharset: Record<string, string[]> = {};
+
+  for (const row of collationResult.rows) {
+    const collation = cellString(row[collationNameIndex]);
+    const charset = normalizeCreateDatabaseCharsetKey(cellString(row[collationCharsetIndex]));
+    if (!collation || !charset) continue;
+    collationsByCharset[charset] ??= [];
+    if (isDefaultFlag(row[collationDefaultIndex])) {
+      collationsByCharset[charset].unshift(collation);
+    } else if (!collationsByCharset[charset].includes(collation)) {
+      collationsByCharset[charset].push(collation);
+    }
+  }
+
+  for (const row of charsetResult.rows) {
+    const charset = normalizeCreateDatabaseCharsetKey(cellString(row[charsetNameIndex]));
+    const defaultCollation = cellString(row[charsetDefaultCollationIndex]);
+    if (!charset || !defaultCollation) continue;
+    collationsByCharset[charset] ??= [];
+    const existingIndex = collationsByCharset[charset].indexOf(defaultCollation);
+    if (existingIndex > 0) collationsByCharset[charset].splice(existingIndex, 1);
+    if (existingIndex !== 0) collationsByCharset[charset].unshift(defaultCollation);
+  }
+
+  return {
+    charsets: charsets.length ? charsets : [...CREATE_DATABASE_CHARSET_OPTIONS],
+    collationsByCharset: Object.keys(collationsByCharset).length ? collationsByCharset : { ...FALLBACK_COLLATION_OPTIONS },
+  };
+}
+
+function columnIndex(columns: string[], names: string[]): number {
+  const lowerNames = names.map((name) => name.toLowerCase());
+  const index = columns.findIndex((column) => lowerNames.includes(column.trim().toLowerCase()));
+  return index >= 0 ? index : 0;
+}
+
+function cellString(value: unknown): string {
+  return typeof value === "string" ? value.trim() : value == null ? "" : String(value).trim();
+}
+
+function uniqueStrings(values: string[]): string[] {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function isDefaultFlag(value: unknown): boolean {
+  if (value === true) return true;
+  if (typeof value !== "string") return false;
+  return ["yes", "y", "1", "true"].includes(value.trim().toLowerCase());
+}
diff --git a/apps/desktop/src/lib/database/createDatabaseSql.ts b/apps/desktop/src/lib/database/createDatabaseSql.ts
new file mode 100644
index 0000000..6051ce5
--- /dev/null
+++ b/apps/desktop/src/lib/database/createDatabaseSql.ts
@@ -0,0 +1,47 @@
+import type { DatabaseType } from "@/types/database";
+import * as api from "@/lib/backend/api";
+
+const MYSQL_COMPATIBLE_PROFILES = new Set(["mysql", "mariadb", "tidb", "oceanbase", "doris", "starrocks", "custom_mysql"]);
+const MYSQL_COMPATIBLE_TYPES = new Set<DatabaseType>(["mysql", "doris", "starrocks", "goldendb"]);
+
+export interface CreateDatabaseSqlOptions {
+  databaseType?: DatabaseType;
+  driverProfile?: string | null;
+  target?: "database" | "schema" | "catalog" | "namespace";
+  parent?: string | null;
+  name: string;
+  charset?: string;
+  collation?: string;
+}
+
+export function supportsCreateDatabaseCharset(databaseType?: DatabaseType, driverProfile?: string | null): boolean {
+  return MYSQL_COMPATIBLE_TYPES.has(databaseType as DatabaseType) || (!!driverProfile && MYSQL_COMPATIBLE_PROFILES.has(driverProfile.toLowerCase()));
+}
+
+export function buildCreateDatabaseSql(options: CreateDatabaseSqlOptions): Promise<string> {
+  return api.buildCreateDatabaseSql(options);
+}
+
+export function buildDuckDbAttachDatabaseSql(path: string, name: string): Promise<string> {
+  return api.buildDuckDbAttachDatabaseSql(path, name);
+}
+
+export function duckDbAttachedDatabaseNameFromPath(path: string): string {
+  const fileName = path.split(/[\\/]/).pop() ?? "";
+  const withoutExtension = fileName.replace(/\.[^.\\/]+$/, "");
+  const normalized = withoutExtension
+    .trim()
+    .replace(/[^\p{L}\p{N}_]+/gu, "_")
+    .replace(/^_+|_+$/g, "");
+  return normalized || "duckdb_database";
+}
+
+export function uniqueDuckDbAttachedDatabaseName(baseName: string, existingNames: string[]): string {
+  const existing = new Set(existingNames.map((name) => name.toLowerCase()));
+  if (!existing.has(baseName.toLowerCase())) return baseName;
+  for (let index = 2; index < Number.MAX_SAFE_INTEGER; index++) {
+    const candidate = `${baseName}_${index}`;
+    if (!existing.has(candidate.toLowerCase())) return candidate;
+  }
+  return `${baseName}_${Date.now()}`;
+}
diff --git a/apps/desktop/src/lib/database/damengJobAdmin.ts b/apps/desktop/src/lib/database/damengJobAdmin.ts
new file mode 100644
index 0000000..3bddcc2
--- /dev/null
+++ b/apps/desktop/src/lib/database/damengJobAdmin.ts
@@ -0,0 +1,176 @@
+import type { QueryResult } from "@/types/database";
+
+export interface DamengJob {
+  id: string;
+  name: string;
+  enabled: boolean;
+  running: boolean;
+  runningSid?: string;
+  valid?: string;
+  owner?: string;
+  createdAt?: string;
+  modifiedAt?: string;
+  description?: string;
+  raw: Record<string, unknown>;
+}
+
+export interface DamengJobCreateInput {
+  name: string;
+  enabled: boolean;
+  description?: string;
+  stepName: string;
+  command: string;
+  scheduleName: string;
+  scheduleMode: "once" | "daily";
+  startDate: string;
+  startTime: string;
+  endTime?: string;
+  minuteInterval?: number;
+}
+
+export function damengJobListSql(useSystemTables = false): string {
+  if (!useSystemTables) {
+    return `SELECT J.ID, J.NAME, J.ENABLE, J.USERNAME, J.CREATETIME, J.MODIFYTIME, J.VALID, J.DESCRIBE,
+       0 AS RUNNING,
+       NULL AS RUNNING_SID
+FROM SYSJOB.USER_JOBS_VIEW J
+ORDER BY J.NAME`;
+  }
+
+  return `SELECT J.ID, J.NAME, J.ENABLE, J.USERNAME, J.CREATETIME, J.MODIFYTIME, J.VALID, J.DESCRIBE,
+       CASE WHEN R.JOB IS NULL THEN 0 ELSE 1 END AS RUNNING,
+       R.SID AS RUNNING_SID
+FROM SYSJOB.SYSJOBS J
+LEFT JOIN SYSJOB.DBA_JOBS_RUNNING R ON R.JOB = J.ID
+ORDER BY J.NAME`;
+}
+
+export const DAMENG_JOB_ENVIRONMENT_SQL = `SELECT COUNT(*) AS CNT
+FROM ALL_OBJECTS
+WHERE OWNER = 'SYSJOB'
+  AND OBJECT_NAME = 'USER_JOBS_VIEW'`;
+
+export function damengJobStepsSql(jobId: string | number, useSystemTables = false): string {
+  return `SELECT * FROM ${useSystemTables ? "SYSJOB.SYSJOBSTEPS" : "SYSJOB.USER_JOBSTEPS_VIEW"} WHERE JOBID = ${quoteDamengNumber(jobId)}`;
+}
+
+export function damengJobSchedulesSql(jobId: string | number, useSystemTables = false): string {
+  return `SELECT * FROM ${useSystemTables ? "SYSJOB.SYSJOBSCHEDULES" : "SYSJOB.USER_JOBSCHEDULES_VIEW"} WHERE JOBID = ${quoteDamengNumber(jobId)}`;
+}
+
+export function damengJobHistoriesSql(job: { id: string | number; name: string }, useSystemTables = false): string {
+  if (useSystemTables) {
+    return `SELECT * FROM SYSJOB.SYSJOBHISTORIES2 WHERE JOBID = ${quoteDamengNumber(job.id)}`;
+  }
+  return `SELECT * FROM SYSJOB.USER_JOBHISTORIES_VIEW WHERE JOBID = ${quoteDamengNumber(job.id)}`;
+}
+
+export function damengInitJobSystemSql(): string {
+  return "SP_INIT_JOB_SYS(1);";
+}
+
+export function damengEnableJobSql(jobName: string, enabled: boolean): string {
+  return `SP_ENABLE_JOB(${quoteDamengString(jobName)}, ${enabled ? 1 : 0});`;
+}
+
+export function damengDropJobSql(jobName: string): string {
+  return `SP_DROP_JOB(${quoteDamengString(jobName)});`;
+}
+
+export function damengRunJobSql(jobId: string | number): string {
+  const id = Number(jobId);
+  if (!Number.isFinite(id)) return "";
+  return `SP_DBMS_JOB_RUN_ASYNC(${Math.trunc(id)});`;
+}
+
+export function damengStopJobSql(jobId: string | number): string {
+  const id = Number(jobId);
+  if (!Number.isFinite(id)) return "";
+  return `SP_STOP_RUNNING_JOB(${Math.trunc(id)});`;
+}
+
+export function damengClearJobHistoriesSql(jobName: string): string {
+  return `SP_JOB_CLEAR_HISTORIES(${quoteDamengString(jobName)});`;
+}
+
+export function damengCreateJobSql(input: DamengJobCreateInput): string {
+  const name = input.name.trim();
+  const stepName = input.stepName.trim() || "STEP1";
+  const scheduleName = input.scheduleName.trim() || "SCHEDULE1";
+  const startDate = input.startDate.trim() || "CURDATE";
+  const startTime = input.startTime.trim() || "CURTIME";
+  const endTime = input.endTime?.trim();
+  const interval = Math.max(0, Math.min(1439, Math.trunc(input.minuteInterval ?? 0)));
+  const scheduleType = input.scheduleMode === "once" ? 0 : 1;
+  const freqInterval = input.scheduleMode === "once" ? 0 : 1;
+  const freqMinuteInterval = input.scheduleMode === "once" ? 0 : interval;
+  const startTimeSql = input.scheduleMode === "once" ? "NULL" : quoteDamengString(startTime);
+  const endTimeSql = endTime ? quoteDamengString(endTime) : "NULL";
+  const startDateSql = startDate.toUpperCase() === "CURDATE" ? "CURDATE" : quoteDamengString(startDate);
+
+  return [
+    `SP_CREATE_JOB(${quoteDamengString(name)}, ${input.enabled ? 1 : 0}, 0, '', 0, 0, '', 0, ${quoteDamengString(input.description ?? "")});`,
+    `SP_JOB_CONFIG_START(${quoteDamengString(name)});`,
+    `SP_ADD_JOB_STEP(${quoteDamengString(name)}, ${quoteDamengString(stepName)}, 0, ${quoteDamengString(input.command)}, 1, 1, 0, 0, NULL, 0);`,
+    `SP_ADD_JOB_SCHEDULE(${quoteDamengString(name)}, ${quoteDamengString(scheduleName)}, 1, ${scheduleType}, ${freqInterval}, 0, ${freqMinuteInterval}, ${startTimeSql}, ${endTimeSql}, ${startDateSql}, NULL, '');`,
+    `SP_JOB_CONFIG_COMMIT(${quoteDamengString(name)});`,
+  ].join("\n");
+}
+
+export function parseDamengJobs(result: QueryResult): DamengJob[] {
+  return result.rows.map((row) => {
+    const raw = rowToObject(result.columns, row);
+    const name = valueAt(raw, "NAME");
+    const id = valueAt(raw, "ID");
+    return {
+      id: id || name,
+      name,
+      enabled: valueAt(raw, "ENABLE") === "1",
+      running: valueAt(raw, "RUNNING") === "1",
+      runningSid: valueAt(raw, "RUNNING_SID"),
+      valid: valueAt(raw, "VALID"),
+      owner: valueAt(raw, "USERNAME"),
+      createdAt: valueAt(raw, "CREATETIME"),
+      modifiedAt: valueAt(raw, "MODIFYTIME"),
+      description: valueAt(raw, "DESCRIBE"),
+      raw,
+    };
+  });
+}
+
+export function parseDamengJobEnvironmentReady(result: QueryResult): boolean {
+  const value = result.rows[0]?.[0];
+  return Number(value) > 0;
+}
+
+export function isDamengJobEnvironmentMissingError(message: string): boolean {
+  return /SYSJOB/i.test(message) && (/无效的模式名/.test(message) || /invalid schema/i.test(message));
+}
+
+export function queryResultToObjects(result: QueryResult): Record<string, unknown>[] {
+  return result.rows.map((row) => rowToObject(result.columns, row));
+}
+
+export function quoteDamengString(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+function quoteDamengNumber(value: string | number): string {
+  const id = Number(value);
+  if (!Number.isFinite(id)) return "NULL";
+  return String(Math.trunc(id));
+}
+
+function rowToObject(columns: string[], row: QueryResult["rows"][number]): Record<string, unknown> {
+  const object: Record<string, unknown> = {};
+  columns.forEach((column, index) => {
+    object[column] = row[index] ?? null;
+  });
+  return object;
+}
+
+function valueAt(row: Record<string, unknown>, column: string): string {
+  const key = Object.keys(row).find((candidate) => candidate.toLowerCase() === column.toLowerCase());
+  const value = key ? row[key] : undefined;
+  return value == null ? "" : String(value);
+}
diff --git a/apps/desktop/src/lib/database/databaseCapabilities.ts b/apps/desktop/src/lib/database/databaseCapabilities.ts
new file mode 100644
index 0000000..ce99af9
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseCapabilities.ts
@@ -0,0 +1,7 @@
+export * from "@/lib/database/databaseCapabilitySets";
+export * from "@/lib/database/databaseDriverManifest";
+export * from "@/lib/database/databaseFeatureSupport";
+export * from "@/lib/database/databaseNamespaceCreation";
+export * from "@/lib/database/databasePropertyEditing";
+export * from "@/lib/database/databaseObjectCapabilities";
+export * from "@/lib/database/databaseTableDataCapabilities";
diff --git a/apps/desktop/src/lib/database/databaseCapabilitySets.ts b/apps/desktop/src/lib/database/databaseCapabilitySets.ts
new file mode 100644
index 0000000..3d4511f
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseCapabilitySets.ts
@@ -0,0 +1,78 @@
+import type { DatabaseType } from "@/types/database";
+
+export const SCHEMA_AWARE_TYPES = new Set<DatabaseType>([
+  "postgres",
+  "sqlserver",
+  "oracle",
+  "redshift",
+  "dameng",
+  "gaussdb",
+  "kwdb",
+  "kingbase",
+  "highgo",
+  "vastbase",
+  "yashandb",
+  "databricks",
+  "saphana",
+  "teradata",
+  "vertica",
+  "exasol",
+  "opengauss",
+  "oceanbase-oracle",
+  "gbase",
+  "jdbc",
+  "h2",
+  "snowflake",
+  "trino",
+  "prestosql",
+  "hive",
+  "spark",
+  "databend",
+  "db2",
+  "informix",
+  "xugu",
+  "oscar",
+  "iotdb",
+  "iris",
+  "duckdb",
+]);
+
+export const SINGLE_DATABASE_TYPES = new Set<DatabaseType>(["oracle", "dameng", "firebird", "oceanbase-oracle", "access", "questdb"]);
+
+export const FETCH_FIRST_TYPES = new Set<DatabaseType>(["oracle", "dameng"]);
+
+export const TREE_SCHEMA_TYPES = new Set<DatabaseType>([
+  "postgres",
+  "redshift",
+  "sqlserver",
+  "db2",
+  "gaussdb",
+  "kwdb",
+  "kingbase",
+  "highgo",
+  "vastbase",
+  "yashandb",
+  "databricks",
+  "saphana",
+  "teradata",
+  "vertica",
+  "exasol",
+  "opengauss",
+  "oceanbase-oracle",
+  "gbase",
+  "jdbc",
+  "trino",
+  "prestosql",
+  "h2",
+  "informix",
+  "xugu",
+  "oscar",
+  "iris",
+  "duckdb",
+]);
+
+export const DATABASE_OBJECT_TREE_TYPES = new Set<DatabaseType>(["jdbc"]);
+
+export const PG_LIKE_STRUCTURE_TYPES = new Set<DatabaseType>(["postgres", "redshift", "gaussdb", "kwdb", "opengauss", "questdb"]);
+
+export const DIAGRAM_SQL_TYPES = new Set<DatabaseType>(["mysql", "postgres", "sqlite", "rqlite", "turso", "cloudflare-d1", "sqlserver", "oracle", "redshift", "dameng", "gaussdb", "kwdb", "opengauss", "questdb", "oceanbase-oracle"]);
diff --git a/apps/desktop/src/lib/database/databaseDriverManifest.ts b/apps/desktop/src/lib/database/databaseDriverManifest.ts
new file mode 100644
index 0000000..37b2f85
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseDriverManifest.ts
@@ -0,0 +1,102 @@
+import type { DatabaseType } from "@/types/database";
+import driverManifest from "../../../../../crates/dbx-core/assets/database-drivers.manifest.json";
+
+export type DatabaseSupportLevel = "connect" | "browse" | "understand" | "operate";
+export type DatabaseRuntimeMode = "native" | "file" | "agent" | "external";
+
+export const DATABASE_PRODUCT_CAPABILITY_KEYS = [
+  "queryExecution",
+  "metadataBrowse",
+  "objectBrowser",
+  "objectSource",
+  "schemaSearch",
+  "diagram",
+  "tableDataEdit",
+  "tableStructureEdit",
+  "tableImport",
+  "dataTransfer",
+  "sqlFileExecution",
+  "databaseCreate",
+  "fieldLineage",
+  "sqlExplain",
+  "userAdmin",
+  "driverManagement",
+] as const;
+
+export type DatabaseProductCapability = (typeof DATABASE_PRODUCT_CAPABILITY_KEYS)[number];
+export type DatabaseProductCapabilities = Record<DatabaseProductCapability, boolean>;
+
+interface DatabaseDriverManifestEntry {
+  dbType: DatabaseType;
+  runtimeMode: DatabaseRuntimeMode;
+  supportLevel: DatabaseSupportLevel;
+  capabilities: Partial<DatabaseProductCapabilities>;
+}
+
+const SUPPORT_LEVEL_DEFAULTS: Record<DatabaseSupportLevel, DatabaseProductCapabilities> = {
+  connect: productCapabilities({
+    queryExecution: true,
+    sqlFileExecution: true,
+  }),
+  browse: productCapabilities({
+    metadataBrowse: true,
+    objectBrowser: true,
+    sqlFileExecution: true,
+  }),
+  understand: productCapabilities({
+    metadataBrowse: true,
+    objectBrowser: true,
+    schemaSearch: true,
+    sqlFileExecution: true,
+  }),
+  operate: productCapabilities({
+    metadataBrowse: true,
+    objectBrowser: true,
+    schemaSearch: true,
+    tableDataEdit: true,
+    sqlFileExecution: true,
+  }),
+};
+
+const DEFAULT_CAPABILITIES = productCapabilities({});
+
+const DATABASE_DRIVER_ENTRIES = (driverManifest.drivers as DatabaseDriverManifestEntry[]).map((entry) => ({
+  ...entry,
+  capabilities: {
+    ...SUPPORT_LEVEL_DEFAULTS[entry.supportLevel],
+    ...entry.capabilities,
+  },
+}));
+
+const DATABASE_DRIVER_BY_TYPE = new Map<DatabaseType, DatabaseDriverManifestEntry>(DATABASE_DRIVER_ENTRIES.map((entry) => [entry.dbType, entry]));
+
+export function databaseSupportLevel(dbType?: DatabaseType): DatabaseSupportLevel | undefined {
+  return dbType ? DATABASE_DRIVER_BY_TYPE.get(dbType)?.supportLevel : undefined;
+}
+
+export function databaseRuntimeMode(dbType?: DatabaseType): DatabaseRuntimeMode | undefined {
+  return dbType ? DATABASE_DRIVER_BY_TYPE.get(dbType)?.runtimeMode : undefined;
+}
+
+export function databaseProductCapabilities(dbType?: DatabaseType): DatabaseProductCapabilities {
+  if (!dbType) return DEFAULT_CAPABILITIES;
+  return (DATABASE_DRIVER_BY_TYPE.get(dbType)?.capabilities ?? DEFAULT_CAPABILITIES) as DatabaseProductCapabilities;
+}
+
+export function supportsDatabaseFeature(dbType: DatabaseType | undefined, capability: DatabaseProductCapability): boolean {
+  return databaseProductCapabilities(dbType)[capability];
+}
+
+export function manifestDatabaseTypes(): DatabaseType[] {
+  return DATABASE_DRIVER_ENTRIES.map((entry) => entry.dbType);
+}
+
+export function usesAgentCursorForQuery(dbType?: DatabaseType): boolean {
+  const runtimeMode = databaseRuntimeMode(dbType);
+  return runtimeMode === "agent" || runtimeMode === "external";
+}
+
+function productCapabilities(overrides: Partial<DatabaseProductCapabilities>): DatabaseProductCapabilities {
+  const capabilities = Object.fromEntries(DATABASE_PRODUCT_CAPABILITY_KEYS.map((key) => [key, false])) as DatabaseProductCapabilities;
+  return { ...capabilities, ...overrides };
+}
diff --git a/apps/desktop/src/lib/database/databaseFeatureSupport.ts b/apps/desktop/src/lib/database/databaseFeatureSupport.ts
new file mode 100644
index 0000000..06b5034
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseFeatureSupport.ts
@@ -0,0 +1,136 @@
+import type { ConnectionConfig, DatabaseType, TreeNodeType } from "@/types/database";
+import { supportsDatabaseFeature } from "@/lib/database/databaseDriverManifest";
+import { canEditTableStructure } from "@/lib/table/tableStructureCapabilities";
+import { DATABASE_OBJECT_TREE_TYPES, FETCH_FIRST_TYPES, PG_LIKE_STRUCTURE_TYPES, SCHEMA_AWARE_TYPES, SINGLE_DATABASE_TYPES, TREE_SCHEMA_TYPES } from "@/lib/database/databaseCapabilitySets";
+
+export function isSchemaAware(dbType?: DatabaseType): boolean {
+  return !!dbType && SCHEMA_AWARE_TYPES.has(dbType);
+}
+
+/**
+ * Doris-family engines that support multi-catalog federation (`SHOW CATALOGS`):
+ * Doris (incl. SelectDB) and StarRocks. Manticore Search shares the MySQL code
+ * path but has no catalog concept, so it is excluded.
+ */
+export function isDorisFamilyCatalogCapable(dbType?: DatabaseType, driverProfile?: string | null): boolean {
+  if (dbType === "doris" || dbType === "starrocks") return true;
+  return driverProfile === "doris" || driverProfile === "selectdb" || driverProfile === "starrocks";
+}
+
+export function connectionIsDorisFamilyCatalogCapable(connection: Pick<ConnectionConfig, "db_type" | "driver_profile"> | undefined): boolean {
+  if (!connection) return false;
+  return isDorisFamilyCatalogCapable(connection.db_type, connection.driver_profile);
+}
+
+/**
+ * Whether a Doris/StarRocks catalog is the engine's built-in (non-federated)
+ * catalog. Doris names it `internal` (Type=`internal`); StarRocks names it
+ * `default_catalog` (Type=`Internal`). The `catalogType` column is the
+ * cross-engine signal, so it is matched case-insensitively, falling back to the
+ * canonical Doris name `internal` when the type is absent (very old / proxied
+ * deployments). Mirrors `CatalogInfo::is_internal` on the backend.
+ */
+export function isInternalDorisCatalog(catalogType?: string | null, catalogName?: string | null): boolean {
+  const type = (catalogType ?? "").trim().toLowerCase();
+  if (type) return type === "internal";
+  return (catalogName ?? "").trim() === "internal";
+}
+
+export function usesTreeSchemaMode(dbType?: DatabaseType): boolean {
+  return !!dbType && TREE_SCHEMA_TYPES.has(dbType);
+}
+
+export function usesDatabaseObjectTreeMode(dbType?: DatabaseType): boolean {
+  return !!dbType && DATABASE_OBJECT_TREE_TYPES.has(dbType);
+}
+
+export function databaseObjectTreeQuerySchema(dbType: DatabaseType | undefined, database: string, schema?: string): string {
+  if (usesDatabaseObjectTreeMode(dbType)) return "";
+  return schema || database;
+}
+
+export function databaseObjectTreeNodeSchema(dbType: DatabaseType | undefined, database: string, schema?: string): string | undefined {
+  if (usesDatabaseObjectTreeMode(dbType)) return undefined;
+  if (schema) return schema;
+  return isSchemaAware(dbType) ? database : undefined;
+}
+
+export function isSingleDatabase(dbType?: DatabaseType): boolean {
+  return !!dbType && SINGLE_DATABASE_TYPES.has(dbType);
+}
+
+export function usesFetchFirst(dbType?: DatabaseType): boolean {
+  return !!dbType && FETCH_FIRST_TYPES.has(dbType);
+}
+
+export function supportsSqlFileExecution(dbType?: DatabaseType): boolean {
+  return supportsDatabaseFeature(dbType, "sqlFileExecution");
+}
+
+const NON_SQL_IN_LIST_PASTE_TYPES = new Set<DatabaseType>(["neo4j"]);
+
+export function supportsSqlInListPaste(dbType?: DatabaseType): boolean {
+  if (!dbType) return true;
+  return supportsSqlFileExecution(dbType) && !NON_SQL_IN_LIST_PASTE_TYPES.has(dbType);
+}
+
+export function supportsSchemaDiagram(dbType?: DatabaseType): boolean {
+  return supportsDatabaseFeature(dbType, "diagram");
+}
+
+export function supportsDatabaseSearch(dbType?: DatabaseType): boolean {
+  return supportsDatabaseFeature(dbType, "schemaSearch");
+}
+
+export function supportsTableImport(dbType?: DatabaseType): boolean {
+  return supportsDatabaseFeature(dbType, "tableImport");
+}
+
+export function supportsTableStructureEditing(dbType?: DatabaseType): boolean {
+  return supportsDatabaseFeature(dbType, "tableStructureEdit") && canEditTableStructure(dbType);
+}
+
+export function supportsDatabaseCreation(dbType?: DatabaseType): boolean {
+  return supportsDatabaseFeature(dbType, "databaseCreate");
+}
+
+export function supportsFieldLineage(dbType?: DatabaseType): boolean {
+  return supportsDatabaseFeature(dbType, "fieldLineage");
+}
+
+export function supportsTransfer(dbType?: DatabaseType): boolean {
+  return supportsDatabaseFeature(dbType, "dataTransfer");
+}
+
+export function supportsDriverManagement(dbType?: DatabaseType): boolean {
+  return supportsDatabaseFeature(dbType, "driverManagement");
+}
+
+export function supportsObjectBrowser(dbType?: DatabaseType): boolean {
+  return supportsDatabaseFeature(dbType, "objectBrowser");
+}
+
+export function supportsObjectBrowserTreeNode(dbType: DatabaseType | undefined, nodeType: TreeNodeType): boolean {
+  if (!supportsObjectBrowser(dbType)) return false;
+  if (nodeType === "database" && usesDatabaseObjectTreeMode(dbType)) return true;
+  if (nodeType === "database" && isSchemaAware(dbType) && dbType !== "sqlserver") return false;
+  return nodeType === "database" || nodeType === "schema" || nodeType === "object-browser";
+}
+
+export function supportsTableTruncate(dbType?: DatabaseType): boolean {
+  return !!dbType && dbType !== "sqlite" && dbType !== "rqlite" && dbType !== "turso" && dbType !== "cloudflare-d1" && dbType !== "duckdb" && dbType !== "influxdb" && dbType !== "manticoresearch";
+}
+
+export function usesPostgresLikeStructureCopy(dbType?: DatabaseType): boolean {
+  return !!dbType && PG_LIKE_STRUCTURE_TYPES.has(dbType);
+}
+
+const TRANSACTION_SUPPORTED_TYPES: readonly string[] = ["postgres", "mysql"];
+
+/**
+ * Returns true if the given database type supports explicit transaction control
+ * (i.e. toggling between auto-commit and manual transaction mode via BEGIN/COMMIT).
+ */
+export function supportsTransaction(dbType?: string): boolean {
+  return !!dbType && TRANSACTION_SUPPORTED_TYPES.includes(dbType);
+}
diff --git a/apps/desktop/src/lib/database/databaseFileDetection.ts b/apps/desktop/src/lib/database/databaseFileDetection.ts
new file mode 100644
index 0000000..1281254
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseFileDetection.ts
@@ -0,0 +1,18 @@
+import * as api from "@/lib/backend/api";
+
+export const SQLITE_DATABASE_FILE_EXTENSIONS = ["db", "db3", "sqlite", "sqlite3", "sqlitedb"];
+
+const SQLITE_DATABASE_EXTENSION_SET = new Set(SQLITE_DATABASE_FILE_EXTENSIONS.map((extension) => `.${extension}`));
+
+export function databaseTypeFromKnownExtension(path: string): "sqlite" | "duckdb" | null {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".duckdb")) return "duckdb";
+  if ([...SQLITE_DATABASE_EXTENSION_SET].some((extension) => lower.endsWith(extension))) return "sqlite";
+  return null;
+}
+
+export async function detectDatabaseFileType(path: string): Promise<"sqlite" | "duckdb" | null> {
+  const knownType = databaseTypeFromKnownExtension(path);
+  if (knownType) return knownType;
+  return (await api.isSqliteDatabaseFile(path).catch(() => false)) ? "sqlite" : null;
+}
diff --git a/apps/desktop/src/lib/database/databaseNamespaceCreation.ts b/apps/desktop/src/lib/database/databaseNamespaceCreation.ts
new file mode 100644
index 0000000..253afc6
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseNamespaceCreation.ts
@@ -0,0 +1,104 @@
+import type { ConnectionConfig, DatabaseType, TreeNodeType } from "@/types/database";
+
+export type DatabaseNamespaceCreationTarget = "database" | "schema" | "attach" | "special";
+
+type ConnectionCreationTarget = Extract<DatabaseNamespaceCreationTarget, "database" | "schema" | "attach" | "special">;
+type DatabaseNodeCreationTarget = Extract<DatabaseNamespaceCreationTarget, "schema">;
+
+export interface DatabaseNamespaceCreationMatrixEntry {
+  connection?: ConnectionCreationTarget;
+  database?: DatabaseNodeCreationTarget;
+  deferred?: string;
+}
+
+type CreationConnection = Pick<ConnectionConfig, "db_type" | "driver_profile" | "read_only"> | undefined;
+
+// Keep creation target-specific: many products expose schemas, files, or provider-managed namespaces instead of a top-level database.
+export const DATABASE_NAMESPACE_CREATION_MATRIX = {
+  mysql: { connection: "database" },
+  postgres: { connection: "database", database: "schema" },
+  sqlite: { deferred: "file-backed; create a new connection/file instead" },
+  rqlite: { deferred: "single SQLite-compatible database per node" },
+  turso: { deferred: "remote libSQL database lifecycle is provider-managed" },
+  "cloudflare-d1": { deferred: "Cloudflare D1 database lifecycle is provider-managed" },
+  redis: { deferred: "numbered logical databases are server-configured" },
+  duckdb: { connection: "attach" },
+  clickhouse: { connection: "database" },
+  sqlserver: { connection: "database", database: "schema" },
+  mongodb: { connection: "special" },
+  oracle: { deferred: "Oracle schemas are users; database creation is not a normal connected DDL action" },
+  elasticsearch: { deferred: "index creation is not modeled as database creation" },
+  qdrant: { deferred: "collection creation is separate from database creation" },
+  milvus: { deferred: "collection/database lifecycle needs a dedicated vector workflow" },
+  weaviate: { deferred: "collection creation is separate from database creation" },
+  chromadb: { deferred: "collection creation is separate from database creation" },
+  doris: { connection: "database" },
+  starrocks: { connection: "database" },
+  manticoresearch: { deferred: "index/table creation is not database creation" },
+  databend: { connection: "database" },
+  redshift: { connection: "database", database: "schema" },
+  dameng: { connection: "schema" },
+  gaussdb: { connection: "database", database: "schema" },
+  kingbase: { connection: "database", database: "schema" },
+  highgo: { connection: "database", database: "schema" },
+  vastbase: { connection: "database", database: "schema" },
+  goldendb: { connection: "database" },
+  kwdb: { connection: "database", database: "schema" },
+  yashandb: { connection: "database", database: "schema" },
+  databricks: { database: "schema" },
+  saphana: { database: "schema" },
+  teradata: { database: "schema" },
+  vertica: { database: "schema" },
+  firebird: { deferred: "database files are created through connection provisioning" },
+  exasol: { database: "schema" },
+  opengauss: { connection: "database", database: "schema" },
+  "oceanbase-oracle": { deferred: "Oracle-mode schemas are users; use a dedicated user workflow" },
+  questdb: { deferred: "single database model in DBX" },
+  gbase: { database: "schema" },
+  access: { deferred: "file-backed; create a new connection/file instead" },
+  h2: { database: "schema" },
+  snowflake: { connection: "database", database: "schema" },
+  trino: { database: "schema" },
+  prestosql: { database: "schema" },
+  hive: { deferred: "Hive database creation needs agent metadata validation first" },
+  spark: { deferred: "Spark database creation needs agent metadata validation first" },
+  db2: { database: "schema" },
+  informix: { database: "schema" },
+  neo4j: { deferred: "database creation depends on edition/admin privileges" },
+  cassandra: { deferred: "keyspace creation requires replication options" },
+  bigquery: { deferred: "dataset creation needs project/location options" },
+  kylin: { deferred: "project/model lifecycle is not SQL database creation" },
+  sundb: { deferred: "creation semantics not verified for first pass" },
+  oscar: { database: "schema" },
+  tdengine: { connection: "database" },
+  xugu: { database: "schema" },
+  iotdb: { deferred: "storage group/database semantics need dedicated IoTDB handling" },
+  etcd: { deferred: "key-value namespaces are not databases" },
+  zookeeper: { deferred: "key-value namespaces are not databases" },
+  iris: { database: "schema" },
+  influxdb: { connection: "database" },
+  jdbc: { deferred: "generic JDBC does not expose a reliable dialect-specific create target" },
+  mq: { deferred: "message queue namespaces are handled by MQ admin panels" },
+  nacos: { deferred: "Nacos namespace creation already uses the Nacos admin flow" },
+} satisfies Record<DatabaseType, DatabaseNamespaceCreationMatrixEntry>;
+
+export function connectionNamespaceCreationTarget(connection: CreationConnection): ConnectionCreationTarget | null {
+  if (!connection || connection.read_only) return null;
+  if (connection.db_type === "mongodb" && connection.driver_profile === "mongodb-legacy") return null;
+  const entry: DatabaseNamespaceCreationMatrixEntry = DATABASE_NAMESPACE_CREATION_MATRIX[connection.db_type];
+  return entry.connection ?? null;
+}
+
+export function databaseNodeNamespaceCreationTarget(connection: CreationConnection, node: Pick<{ type: TreeNodeType; database?: string | null }, "type" | "database">): DatabaseNodeCreationTarget | null {
+  if (!connection || connection.read_only || node.type !== "database" || !node.database) return null;
+  const entry: DatabaseNamespaceCreationMatrixEntry = DATABASE_NAMESPACE_CREATION_MATRIX[connection.db_type];
+  return entry.database ?? null;
+}
+
+export function canCreateConnectionNamespace(connection: CreationConnection): boolean {
+  return connectionNamespaceCreationTarget(connection) !== null;
+}
+
+export function canCreateDatabaseNodeNamespace(connection: CreationConnection, node: Pick<{ type: TreeNodeType; database?: string | null }, "type" | "database">): boolean {
+  return databaseNodeNamespaceCreationTarget(connection, node) !== null;
+}
diff --git a/apps/desktop/src/lib/database/databaseObjectCapabilities.ts b/apps/desktop/src/lib/database/databaseObjectCapabilities.ts
new file mode 100644
index 0000000..dc4e134
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseObjectCapabilities.ts
@@ -0,0 +1,84 @@
+import type { DatabaseType } from "@/types/database";
+
+export type SidebarObjectKind = "TABLE" | "VIEW" | "MATERIALIZED_VIEW" | "PROCEDURE" | "FUNCTION" | "SEQUENCE" | "PACKAGE" | "PACKAGE_BODY";
+
+export interface DatabaseObjectCapabilities {
+  sidebarObjects: SidebarObjectKind[];
+  sourceReadable: SidebarObjectKind[];
+  executable: SidebarObjectKind[];
+}
+
+const TABLE_VIEW_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW"];
+
+const ROUTINE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "PROCEDURE", "FUNCTION"];
+
+const POSTGRES_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE"];
+const POSTGRES_LIKE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION"];
+const ORACLE_OBJECTS: SidebarObjectKind[] = ["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "PACKAGE", "PACKAGE_BODY"];
+
+const DATABASE_TYPE_OBJECTS = new Map<DatabaseType, SidebarObjectKind[]>([
+  // postgres
+  ["postgres", POSTGRES_OBJECTS],
+  ["gaussdb", POSTGRES_OBJECTS],
+  ["kwdb", POSTGRES_OBJECTS],
+  ["opengauss", POSTGRES_OBJECTS],
+  // postgres like
+  ["kingbase", POSTGRES_LIKE_OBJECTS],
+  ["highgo", POSTGRES_LIKE_OBJECTS],
+  ["vastbase", POSTGRES_LIKE_OBJECTS],
+  ["redshift", POSTGRES_LIKE_OBJECTS],
+  // oracle
+  ["oracle", ORACLE_OBJECTS],
+  ["dameng", ORACLE_OBJECTS],
+  ["oceanbase-oracle", ORACLE_OBJECTS],
+  // table and view
+  ["sqlite", TABLE_VIEW_OBJECTS],
+  ["rqlite", TABLE_VIEW_OBJECTS],
+  ["turso", TABLE_VIEW_OBJECTS],
+  ["cloudflare-d1", TABLE_VIEW_OBJECTS],
+  ["duckdb", TABLE_VIEW_OBJECTS],
+  ["clickhouse", TABLE_VIEW_OBJECTS],
+  ["doris", TABLE_VIEW_OBJECTS],
+  ["starrocks", TABLE_VIEW_OBJECTS],
+  ["hive", TABLE_VIEW_OBJECTS],
+  ["spark", TABLE_VIEW_OBJECTS],
+  ["trino", TABLE_VIEW_OBJECTS],
+  ["prestosql", TABLE_VIEW_OBJECTS],
+  ["cassandra", TABLE_VIEW_OBJECTS],
+  ["bigquery", TABLE_VIEW_OBJECTS],
+  ["kylin", TABLE_VIEW_OBJECTS],
+  ["tdengine", TABLE_VIEW_OBJECTS],
+  ["iotdb", TABLE_VIEW_OBJECTS],
+  ["neo4j", TABLE_VIEW_OBJECTS],
+  // others
+  ["influxdb", ["TABLE"]],
+  ["questdb", ["TABLE", "VIEW", "MATERIALIZED_VIEW"]],
+  ["manticoresearch", ["TABLE", "FUNCTION"]],
+  ["databend", ["TABLE", "VIEW", "PROCEDURE"]],
+]);
+export function databaseObjectCapabilities(dbType?: DatabaseType): DatabaseObjectCapabilities {
+  const sidebarObjects = sidebarObjectKindsForDatabase(dbType);
+  return {
+    sidebarObjects,
+    sourceReadable: sidebarObjects.filter((kind) => kind !== "TABLE"),
+    executable: sidebarObjects.filter((kind) => kind === "PROCEDURE"),
+  };
+}
+
+export function sidebarObjectKindsForDatabase(dbType?: DatabaseType): SidebarObjectKind[] {
+  if (!dbType) return [...TABLE_VIEW_OBJECTS];
+  return DATABASE_TYPE_OBJECTS.get(dbType) ?? [...ROUTINE_OBJECTS];
+}
+
+export function normalizeSidebarObjectKind(type: string): SidebarObjectKind {
+  const value = type.toUpperCase();
+  const normalized = value.replace(/[\s-]+/g, "_");
+  if (normalized.includes("PACKAGE_BODY")) return "PACKAGE_BODY";
+  if (normalized.includes("PACKAGE")) return "PACKAGE";
+  if (normalized.includes("MATERIALIZED_VIEW")) return "MATERIALIZED_VIEW";
+  if (value.includes("VIEW")) return "VIEW";
+  if (value.includes("SEQ")) return "SEQUENCE";
+  if (value.includes("PROC")) return "PROCEDURE";
+  if (value.includes("FUNC")) return "FUNCTION";
+  return "TABLE";
+}
diff --git a/apps/desktop/src/lib/database/databaseOptionSearch.ts b/apps/desktop/src/lib/database/databaseOptionSearch.ts
new file mode 100644
index 0000000..93ac176
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseOptionSearch.ts
@@ -0,0 +1,10 @@
+export function filterDatabaseOptions(options: string[], query: string, displayName: (option: string) => string = (option) => option): string[] {
+  const normalizedQuery = query.trim().toLowerCase();
+  if (!normalizedQuery) return options;
+
+  return options.filter((option) => {
+    const raw = option.toLowerCase();
+    const label = displayName(option).toLowerCase();
+    return raw.includes(normalizedQuery) || label.includes(normalizedQuery);
+  });
+}
diff --git a/apps/desktop/src/lib/database/databasePropertyEditing.ts b/apps/desktop/src/lib/database/databasePropertyEditing.ts
new file mode 100644
index 0000000..f5e71b3
--- /dev/null
+++ b/apps/desktop/src/lib/database/databasePropertyEditing.ts
@@ -0,0 +1,112 @@
+import type { ConnectionConfig, DatabaseType, TreeNodeType } from "@/types/database";
+import { supportsCreateDatabaseCharset } from "@/lib/database/createDatabaseSql";
+
+export type DatabasePropertyEditGroup = "charsetCollation" | "databaseComment" | "schemaComment";
+
+export interface DatabasePropertyEditingEntry {
+  database?: DatabasePropertyEditGroup[];
+  schema?: DatabasePropertyEditGroup[];
+  deferred?: string;
+}
+
+type PropertyEditConnection = Pick<ConnectionConfig, "db_type" | "driver_profile" | "read_only"> | undefined;
+type DatabaseNode = Pick<{ type: TreeNodeType; database?: string | null }, "type" | "database">;
+type SchemaNode = Pick<{ type: TreeNodeType; database?: string | null; schema?: string | null }, "type" | "database" | "schema">;
+
+const POSTGRES_COMMENT_TYPES = new Set<DatabaseType>(["postgres", "gaussdb", "kwdb", "kingbase", "highgo", "vastbase", "opengauss", "yashandb"]);
+
+export const DATABASE_PROPERTY_EDITING_MATRIX = {
+  mysql: { database: ["charsetCollation"] },
+  postgres: { database: ["databaseComment"], schema: ["schemaComment"] },
+  sqlite: { deferred: "file-backed database properties are not edited in-place" },
+  rqlite: { deferred: "single SQLite-compatible database per node" },
+  turso: { deferred: "remote libSQL database lifecycle is provider-managed" },
+  "cloudflare-d1": { deferred: "Cloudflare D1 database lifecycle is provider-managed" },
+  redis: { deferred: "numbered logical databases are server-configured" },
+  duckdb: { deferred: "attached database file properties need a dedicated DuckDB workflow" },
+  clickhouse: { deferred: "database property editing not verified for first pass" },
+  sqlserver: { deferred: "database options are broad administrative settings and need a dedicated editor" },
+  mongodb: { deferred: "database options are not modeled as SQL database properties" },
+  oracle: { deferred: "Oracle database properties are instance/user/tablespace administration" },
+  elasticsearch: { deferred: "index settings are not database properties" },
+  qdrant: { deferred: "collection settings are not database properties" },
+  milvus: { deferred: "collection/database settings need a dedicated vector workflow" },
+  weaviate: { deferred: "collection settings are not database properties" },
+  chromadb: { deferred: "collection settings are not database properties" },
+  doris: { deferred: "database collation metadata is MySQL-compatible only and not an editable database default" },
+  starrocks: { deferred: "ALTER DATABASE edits quota/rename/storage volume, not charset/collation defaults" },
+  manticoresearch: { deferred: "index/table settings are not database properties" },
+  databend: { deferred: "database property editing not verified for first pass" },
+  redshift: { deferred: "comment catalog compatibility not verified for first pass" },
+  dameng: { deferred: "schema/user settings need a dedicated workflow" },
+  gaussdb: { database: ["databaseComment"], schema: ["schemaComment"] },
+  kingbase: { database: ["databaseComment"], schema: ["schemaComment"] },
+  highgo: { database: ["databaseComment"], schema: ["schemaComment"] },
+  vastbase: { database: ["databaseComment"], schema: ["schemaComment"] },
+  goldendb: { database: ["charsetCollation"] },
+  kwdb: { database: ["databaseComment"], schema: ["schemaComment"] },
+  yashandb: { database: ["databaseComment"], schema: ["schemaComment"] },
+  databricks: { deferred: "catalog/schema properties need warehouse-specific handling" },
+  saphana: { deferred: "schema properties need product-specific handling" },
+  teradata: { deferred: "database properties need product-specific handling" },
+  vertica: { deferred: "schema properties need product-specific handling" },
+  firebird: { deferred: "database files are managed through connection provisioning" },
+  exasol: { deferred: "schema properties need product-specific handling" },
+  opengauss: { database: ["databaseComment"], schema: ["schemaComment"] },
+  "oceanbase-oracle": { deferred: "Oracle-mode schemas are users; use a dedicated user workflow" },
+  questdb: { deferred: "single database model in DBX" },
+  gbase: { deferred: "schema properties need product-specific handling" },
+  access: { deferred: "file-backed database properties are not edited in-place" },
+  h2: { deferred: "schema properties need product-specific handling" },
+  snowflake: { deferred: "database/schema properties need Snowflake-specific options" },
+  trino: { deferred: "catalog properties are connector-managed" },
+  prestosql: { deferred: "catalog properties are connector-managed" },
+  hive: { deferred: "database properties need agent metadata validation first" },
+  spark: { deferred: "database properties need agent metadata validation first" },
+  db2: { deferred: "schema properties need product-specific handling" },
+  informix: { deferred: "schema properties need product-specific handling" },
+  neo4j: { deferred: "database properties depend on edition/admin privileges" },
+  cassandra: { deferred: "keyspace properties require replication option handling" },
+  bigquery: { deferred: "dataset properties need project/location-specific handling" },
+  kylin: { deferred: "project/model lifecycle is not SQL database property editing" },
+  sundb: { deferred: "property semantics not verified for first pass" },
+  oscar: { deferred: "schema properties need product-specific handling" },
+  tdengine: { deferred: "database property editing not verified for first pass" },
+  xugu: { deferred: "schema properties need product-specific handling" },
+  iotdb: { deferred: "storage group/database semantics need dedicated IoTDB handling" },
+  etcd: { deferred: "key-value namespaces are not databases" },
+  zookeeper: { deferred: "key-value namespaces are not databases" },
+  iris: { deferred: "schema properties need product-specific handling" },
+  influxdb: { deferred: "database retention policies need a dedicated workflow" },
+  jdbc: { deferred: "generic JDBC does not expose reliable dialect-specific properties" },
+  mq: { deferred: "message queue namespaces are handled by MQ admin panels" },
+  nacos: { deferred: "Nacos namespace editing already uses the Nacos admin flow" },
+} satisfies Record<DatabaseType, DatabasePropertyEditingEntry>;
+
+function entryFor(connection: PropertyEditConnection): DatabasePropertyEditingEntry | null {
+  if (!connection || connection.read_only) return null;
+  return DATABASE_PROPERTY_EDITING_MATRIX[connection.db_type] ?? null;
+}
+
+export function editableDatabasePropertyGroups(connection: PropertyEditConnection, node: DatabaseNode): DatabasePropertyEditGroup[] {
+  if (node.type !== "database" || !node.database) return [];
+  const groups = entryFor(connection)?.database ?? [];
+  return groups.filter((group) => group !== "charsetCollation" || supportsCreateDatabaseCharset(connection?.db_type, connection?.driver_profile));
+}
+
+export function editableSchemaPropertyGroups(connection: PropertyEditConnection, node: SchemaNode): DatabasePropertyEditGroup[] {
+  if (node.type !== "schema" || !node.database) return [];
+  return entryFor(connection)?.schema ?? [];
+}
+
+export function canEditDatabaseProperties(connection: PropertyEditConnection, node: DatabaseNode): boolean {
+  return editableDatabasePropertyGroups(connection, node).length > 0;
+}
+
+export function canEditSchemaProperties(connection: PropertyEditConnection, node: SchemaNode): boolean {
+  return editableSchemaPropertyGroups(connection, node).length > 0;
+}
+
+export function supportsPostgresStyleComments(databaseType?: DatabaseType): boolean {
+  return !!databaseType && POSTGRES_COMMENT_TYPES.has(databaseType);
+}
diff --git a/apps/desktop/src/lib/database/databaseSearch.ts b/apps/desktop/src/lib/database/databaseSearch.ts
new file mode 100644
index 0000000..49e862a
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseSearch.ts
@@ -0,0 +1,92 @@
+import type { ColumnInfo, DatabaseType } from "@/types/database.ts";
+import * as api from "@/lib/backend/api.ts";
+
+export interface DatabaseSearchSqlOptions {
+  databaseType?: DatabaseType;
+  schema?: string;
+  tableName: string;
+  columns: ColumnInfo[];
+  term: string;
+  limit?: number;
+}
+
+export interface DatabaseSearchSql {
+  sql: string;
+  searchableColumns: string[];
+}
+
+export interface SearchResultWhereOptions {
+  databaseType?: DatabaseType;
+  columns: ColumnInfo[];
+  resultColumns: string[];
+  row: unknown[];
+  matchedColumns?: string[];
+}
+
+const TEXT_TYPES = ["char", "text", "clob", "varchar", "nvarchar", "nchar", "uuid", "uniqueidentifier", "enum"];
+
+const NUMBER_TYPES = ["int", "serial", "number", "numeric", "decimal", "float", "double", "real", "money"];
+
+const SKIPPED_TYPES = ["blob", "binary", "bytea", "image", "geometry", "geography"];
+
+function normalizedType(column: ColumnInfo): string {
+  return column.data_type.toLowerCase();
+}
+
+export function isTextSearchColumn(column: ColumnInfo): boolean {
+  const type = normalizedType(column);
+  if (SKIPPED_TYPES.some((skipped) => type.includes(skipped))) return false;
+  return TEXT_TYPES.some((textType) => type.includes(textType));
+}
+
+export function isNumericSearchColumn(column: ColumnInfo): boolean {
+  const type = normalizedType(column);
+  if (SKIPPED_TYPES.some((skipped) => type.includes(skipped))) return false;
+  return NUMBER_TYPES.some((numberType) => type.includes(numberType));
+}
+
+function cleanTerm(term: string): string {
+  return term.trim();
+}
+
+function parseNumericTerm(term: string): string | null {
+  const trimmed = cleanTerm(term);
+  if (!/^[+-]?(?:\d+|\d+\.\d+|\.\d+)$/.test(trimmed)) return null;
+  return trimmed;
+}
+
+export async function buildDatabaseSearchSql(options: DatabaseSearchSqlOptions): Promise<DatabaseSearchSql | null> {
+  return api.buildDatabaseSearchSql(options);
+}
+
+function columnByName(columns: ColumnInfo[], name: string): ColumnInfo | undefined {
+  return columns.find((column) => column.name.toLowerCase() === name.toLowerCase());
+}
+
+export function findMatchedSearchColumns(resultColumns: string[], row: unknown[], columns: ColumnInfo[], term: string): string[] {
+  const query = cleanTerm(term).toLowerCase();
+  const numericTerm = parseNumericTerm(term);
+  if (!query) return [];
+
+  const matches: string[] = [];
+  resultColumns.forEach((columnName, index) => {
+    const value = row[index];
+    if (value === null || value === undefined) return;
+    const column = columnByName(columns, columnName);
+    if (!column || (!isTextSearchColumn(column) && !isNumericSearchColumn(column))) return;
+
+    if (isNumericSearchColumn(column) && numericTerm && String(value).trim() === numericTerm) {
+      matches.push(columnName);
+      return;
+    }
+
+    if (isTextSearchColumn(column) && String(value).toLowerCase().includes(query)) {
+      matches.push(columnName);
+    }
+  });
+  return matches;
+}
+
+export async function buildSearchResultWhere(options: SearchResultWhereOptions): Promise<string> {
+  return api.buildSearchResultWhere(options);
+}
diff --git a/apps/desktop/src/lib/database/databaseTableDataCapabilities.ts b/apps/desktop/src/lib/database/databaseTableDataCapabilities.ts
new file mode 100644
index 0000000..1dc6c1e
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseTableDataCapabilities.ts
@@ -0,0 +1,195 @@
+import type { DatabaseType } from "@/types/database";
+import { isSchemaAware, usesTreeSchemaMode } from "@/lib/database/databaseFeatureSupport";
+
+export type SyntheticEditKey = "oracle-rowid" | "neo4j-element-id";
+
+export interface TableDataCapability {
+  insert: boolean;
+  updateRequiresPrimaryKey: boolean;
+  deleteRequiresPrimaryKey: boolean;
+  keylessRowPredicate?: boolean;
+  requiresTransactionalTableForExistingRows: boolean;
+  existingRowsReadonly?: boolean;
+  transaction: boolean;
+  readonly?: boolean;
+}
+
+export interface DatabaseCapability {
+  schemaAware: boolean;
+  treeSchemaMode: boolean;
+  tableData: TableDataCapability;
+  syntheticKey?: SyntheticEditKey;
+}
+
+const DEFAULT_TABLE_DATA_CAPABILITY: TableDataCapability = {
+  insert: false,
+  updateRequiresPrimaryKey: true,
+  deleteRequiresPrimaryKey: true,
+  keylessRowPredicate: false,
+  requiresTransactionalTableForExistingRows: false,
+  transaction: true,
+};
+
+const NAVICAT_STYLE_TABLE_DATA_CAPABILITY: TableDataCapability = {
+  insert: true,
+  updateRequiresPrimaryKey: false,
+  deleteRequiresPrimaryKey: false,
+  keylessRowPredicate: true,
+  requiresTransactionalTableForExistingRows: false,
+  transaction: true,
+};
+
+const DEFAULT_CAPABILITY: DatabaseCapability = {
+  schemaAware: false,
+  treeSchemaMode: false,
+  tableData: DEFAULT_TABLE_DATA_CAPABILITY,
+};
+
+const NAVICAT_STYLE_TABLE_DATA_TYPES = new Set<DatabaseType>([
+  "mysql",
+  "manticoresearch",
+  "postgres",
+  "sqlite",
+  "rqlite",
+  "turso",
+  "cloudflare-d1",
+  "duckdb",
+  "sqlserver",
+  "oracle",
+  "doris",
+  "starrocks",
+  "redshift",
+  "dameng",
+  "gaussdb",
+  "kwdb",
+  "kingbase",
+  "highgo",
+  "vastbase",
+  "goldendb",
+  "yashandb",
+  "databricks",
+  "saphana",
+  "teradata",
+  "vertica",
+  "firebird",
+  "exasol",
+  "opengauss",
+  "questdb",
+  "oceanbase-oracle",
+  "gbase",
+  "access",
+  "h2",
+  "snowflake",
+  "db2",
+  "informix",
+  "bigquery",
+  "sundb",
+  "oscar",
+  "databend",
+]);
+
+const DATABASE_CAPABILITY_OVERRIDES: Partial<Record<DatabaseType, Partial<DatabaseCapability>>> = {
+  hive: {
+    tableData: {
+      insert: true,
+      updateRequiresPrimaryKey: false,
+      deleteRequiresPrimaryKey: false,
+      keylessRowPredicate: true,
+      requiresTransactionalTableForExistingRows: true,
+      transaction: false,
+    },
+  },
+  jdbc: {
+    tableData: {
+      insert: false,
+      updateRequiresPrimaryKey: true,
+      deleteRequiresPrimaryKey: true,
+      requiresTransactionalTableForExistingRows: false,
+      transaction: false,
+    },
+  },
+  manticoresearch: {
+    tableData: {
+      insert: true,
+      updateRequiresPrimaryKey: false,
+      deleteRequiresPrimaryKey: false,
+      keylessRowPredicate: true,
+      requiresTransactionalTableForExistingRows: false,
+      transaction: false,
+    },
+  },
+  neo4j: {
+    syntheticKey: "neo4j-element-id",
+  },
+  oracle: {
+    syntheticKey: "oracle-rowid",
+  },
+  trino: {
+    tableData: {
+      insert: true,
+      updateRequiresPrimaryKey: true,
+      deleteRequiresPrimaryKey: true,
+      requiresTransactionalTableForExistingRows: false,
+      transaction: false,
+    },
+  },
+  prestosql: {
+    tableData: {
+      insert: true,
+      updateRequiresPrimaryKey: true,
+      deleteRequiresPrimaryKey: true,
+      requiresTransactionalTableForExistingRows: false,
+      transaction: false,
+    },
+  },
+  clickhouse: {
+    tableData: {
+      insert: true,
+      updateRequiresPrimaryKey: true,
+      deleteRequiresPrimaryKey: true,
+      requiresTransactionalTableForExistingRows: false,
+      transaction: false,
+    },
+  },
+  tdengine: {
+    tableData: {
+      insert: true,
+      updateRequiresPrimaryKey: true,
+      deleteRequiresPrimaryKey: true,
+      requiresTransactionalTableForExistingRows: false,
+      transaction: false,
+    },
+  },
+  influxdb: {
+    tableData: {
+      insert: false,
+      updateRequiresPrimaryKey: false,
+      deleteRequiresPrimaryKey: true,
+      keylessRowPredicate: false,
+      requiresTransactionalTableForExistingRows: false,
+      existingRowsReadonly: true,
+      transaction: false,
+      readonly: true,
+    },
+  },
+};
+
+function defaultTableDataCapability(dbType?: DatabaseType): TableDataCapability {
+  if (dbType && NAVICAT_STYLE_TABLE_DATA_TYPES.has(dbType)) return NAVICAT_STYLE_TABLE_DATA_CAPABILITY;
+  return DEFAULT_TABLE_DATA_CAPABILITY;
+}
+
+export function getDatabaseCapability(dbType?: DatabaseType): DatabaseCapability {
+  const override = dbType ? DATABASE_CAPABILITY_OVERRIDES[dbType] : undefined;
+  const tableData = defaultTableDataCapability(dbType);
+  return {
+    ...DEFAULT_CAPABILITY,
+    ...override,
+    schemaAware: isSchemaAware(dbType),
+    treeSchemaMode: usesTreeSchemaMode(dbType),
+    tableData: {
+      ...tableData,
+      ...override?.tableData,
+    },
+  };
+}
diff --git a/apps/desktop/src/lib/database/databaseTree.ts b/apps/desktop/src/lib/database/databaseTree.ts
new file mode 100644
index 0000000..937e0de
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseTree.ts
@@ -0,0 +1,85 @@
+import type { ConnectionConfig, DatabaseInfo, TreeNode } from "@/types/database";
+import { DEFAULT_DATABASE_TREE_LABEL } from "@/lib/sidebar/treeNodeContext";
+
+const sidebarNameCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
+
+export function shouldIncludeDefaultDatabaseNode(connection: Pick<ConnectionConfig, "db_type"> | undefined, databases: DatabaseInfo[]): boolean {
+  return connection?.db_type === "mysql" && databases.some((database) => !database.name.trim());
+}
+
+export function sortSidebarNames(names: readonly string[]): string[] {
+  return [...names].sort((left, right) => sidebarNameCollator.compare(left, right));
+}
+
+export function sortSidebarDatabases(databases: readonly DatabaseInfo[]): DatabaseInfo[] {
+  return [...databases].sort((left, right) => sidebarNameCollator.compare(left.name, right.name));
+}
+
+export function buildDatabaseTreeNodes(connectionId: string, databases: DatabaseInfo[], options: { includeDefaultWhenEmpty?: boolean } = {}): TreeNode[] {
+  const nodes = sortSidebarDatabases(databases).flatMap((db) => {
+    const name = db.name.trim();
+    if (!name) return [];
+    return [
+      {
+        id: `${connectionId}:${name}`,
+        label: name,
+        type: "database" as const,
+        connectionId,
+        database: name,
+        isExpanded: false,
+        children: [],
+      },
+    ];
+  });
+
+  if (nodes.length > 0 || !options.includeDefaultWhenEmpty) return nodes;
+
+  return [
+    {
+      id: `${connectionId}:`,
+      label: DEFAULT_DATABASE_TREE_LABEL,
+      type: "database" as const,
+      connectionId,
+      database: "",
+      isExpanded: false,
+      children: [],
+    },
+  ];
+}
+
+export function buildDuckDbConnectionTreeNodes(connectionId: string, databases: DatabaseInfo[], primarySchemas: string[]): TreeNode[] {
+  const schemaNodes = sortSidebarNames(primarySchemas).flatMap((schema) => {
+    const name = schema.trim();
+    if (!name) return [];
+    return [
+      {
+        id: `${connectionId}:main:${name}`,
+        label: name,
+        type: "schema" as const,
+        connectionId,
+        database: "main",
+        schema: name,
+        isExpanded: false,
+        children: [],
+      },
+    ];
+  });
+
+  const attachedCatalogNodes = sortSidebarDatabases(databases).flatMap((db) => {
+    const name = db.name.trim();
+    if (!name || name === "main") return [];
+    return [
+      {
+        id: `${connectionId}:${name}`,
+        label: name,
+        type: "database" as const,
+        connectionId,
+        database: name,
+        isExpanded: false,
+        children: [],
+      },
+    ];
+  });
+
+  return [...schemaNodes, ...attachedCatalogNodes];
+}
diff --git a/apps/desktop/src/lib/database/databaseUserAdmin.ts b/apps/desktop/src/lib/database/databaseUserAdmin.ts
new file mode 100644
index 0000000..a831627
--- /dev/null
+++ b/apps/desktop/src/lib/database/databaseUserAdmin.ts
@@ -0,0 +1,468 @@
+import type { DatabaseType, QueryResult } from "@/types/database";
+import { supportsDatabaseFeature } from "@/lib/database/databaseDriverManifest";
+
+export type UserAdminDialect = "mysql" | "postgres";
+export type PrivilegeScope = "mysql" | "database" | "schema" | "table" | "role";
+
+export interface DatabaseUserIdentity {
+  user: string;
+  host: string;
+  plugin?: string;
+}
+
+export interface CreatePrincipalInput extends DatabaseUserIdentity {
+  password: string;
+  canLogin?: boolean;
+}
+
+export interface PrivilegeChangeInput {
+  user: DatabaseUserIdentity;
+  privileges: string[];
+  database: string;
+  table?: string;
+  grantOption?: boolean;
+  scope?: PrivilegeScope;
+  role?: string;
+}
+
+export interface DatabaseUserAdminProvider {
+  dialect: UserAdminDialect;
+  defaultScope: PrivilegeScope;
+  listUsersSql(): string;
+  fallbackListUsersSql?: () => string;
+  parseUsers(result: QueryResult): DatabaseUserIdentity[];
+  parseFallbackUsers?: (result: QueryResult) => DatabaseUserIdentity[];
+  showGrantsSql(user: DatabaseUserIdentity): string;
+  createUserSql(input: CreatePrincipalInput): string;
+  alterPasswordSql(user: DatabaseUserIdentity, password: string): string;
+  alterLoginSql(user: DatabaseUserIdentity, enabled: boolean): string;
+  dropUserSql(user: DatabaseUserIdentity): string;
+  grantPrivilegesSql(input: PrivilegeChangeInput): string;
+  revokePrivilegesSql(input: PrivilegeChangeInput): string;
+  label(user: DatabaseUserIdentity): string;
+  detail(user: DatabaseUserIdentity): string | undefined;
+  privilegesForScope(scope: PrivilegeScope): readonly string[];
+  defaultPrivilegesForScope(scope: PrivilegeScope): string[];
+}
+
+export const MYSQL_USER_ADMIN_TYPES = new Set<DatabaseType>(["mysql", "goldendb"]);
+export const KINGBASE_USER_ADMIN_TYPES = new Set<DatabaseType>(["kingbase"]);
+export const POSTGRES_USER_ADMIN_TYPES = new Set<DatabaseType>(["postgres", "gaussdb", "highgo", "kwdb", "opengauss", "questdb", "vastbase"]);
+
+export const MYSQL_COMMON_PRIVILEGES = ["SELECT", "INSERT", "UPDATE", "DELETE", "CREATE", "DROP", "ALTER", "INDEX", "REFERENCES", "EXECUTE", "SHOW VIEW", "TRIGGER", "EVENT", "CREATE TEMPORARY TABLES"] as const;
+
+export const POSTGRES_DATABASE_PRIVILEGES = ["CONNECT", "CREATE", "TEMPORARY"] as const;
+export const POSTGRES_SCHEMA_PRIVILEGES = ["USAGE", "CREATE"] as const;
+export const POSTGRES_TABLE_PRIVILEGES = ["SELECT", "INSERT", "UPDATE", "DELETE", "TRUNCATE", "REFERENCES", "TRIGGER"] as const;
+
+export function supportsDatabaseUserAdmin(dbType: DatabaseType | undefined): boolean {
+  return !!dbType && supportsDatabaseFeature(dbType, "userAdmin") && !!getDatabaseUserAdminProvider(dbType);
+}
+
+export function getDatabaseUserAdminProvider(dbType: DatabaseType | undefined): DatabaseUserAdminProvider | null {
+  if (!dbType) return null;
+  if (MYSQL_USER_ADMIN_TYPES.has(dbType)) return mysqlUserAdminProvider;
+  if (KINGBASE_USER_ADMIN_TYPES.has(dbType)) return kingbaseUserAdminProvider;
+  if (POSTGRES_USER_ADMIN_TYPES.has(dbType)) return postgresUserAdminProvider;
+  return null;
+}
+
+export function quoteSqlString(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+export function quoteMySqlString(value: string): string {
+  return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "''")}'`;
+}
+
+export function quoteMySqlIdentifier(value: string): string {
+  return `\`${value.replace(/`/g, "``")}\``;
+}
+
+export function quotePostgresIdentifier(value: string): string {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+
+export function mysqlUserAccount(user: DatabaseUserIdentity): string {
+  return `${quoteMySqlString(user.user)}@${quoteMySqlString(user.host)}`;
+}
+
+export function mysqlUserLabel(user: DatabaseUserIdentity): string {
+  return `${user.user}@${user.host}`;
+}
+
+export function postgresRoleLabel(user: DatabaseUserIdentity): string {
+  return user.user;
+}
+
+export function mysqlListUsersSql(): string {
+  return "SELECT User AS user, Host AS host, plugin AS plugin FROM mysql.user ORDER BY User, Host;";
+}
+
+export function mysqlListUsersFallbackSql(): string {
+  return "SELECT DISTINCT GRANTEE AS grantee FROM information_schema.USER_PRIVILEGES ORDER BY GRANTEE;";
+}
+
+export function mysqlShowGrantsSql(user: DatabaseUserIdentity): string {
+  return `SHOW GRANTS FOR ${mysqlUserAccount(user)};`;
+}
+
+export function mysqlCreateUserSql(input: CreatePrincipalInput): string {
+  return `CREATE USER ${mysqlUserAccount(input)} IDENTIFIED BY ${quoteMySqlString(input.password)};`;
+}
+
+export function mysqlAlterUserPasswordSql(user: DatabaseUserIdentity, password: string): string {
+  return `ALTER USER ${mysqlUserAccount(user)} IDENTIFIED BY ${quoteMySqlString(password)};`;
+}
+
+export function mysqlAlterUserAccountLockSql(user: DatabaseUserIdentity, locked: boolean): string {
+  return `ALTER USER ${mysqlUserAccount(user)} ACCOUNT ${locked ? "LOCK" : "UNLOCK"};`;
+}
+
+export function mysqlDropUserSql(user: DatabaseUserIdentity): string {
+  return `DROP USER ${mysqlUserAccount(user)};`;
+}
+
+export function mysqlPrivilegeTargetSql(database: string, table = "*"): string {
+  const db = database.trim() || "*";
+  const tbl = table.trim() || "*";
+  const dbSql = db === "*" ? "*" : quoteMySqlIdentifier(db);
+  const tableSql = tbl === "*" ? "*" : quoteMySqlIdentifier(tbl);
+  return `${dbSql}.${tableSql}`;
+}
+
+export function mysqlGrantPrivilegesSql(input: PrivilegeChangeInput): string {
+  const privileges = normalizePrivileges(input.privileges).join(", ");
+  const grantOption = input.grantOption ? " WITH GRANT OPTION" : "";
+  return `GRANT ${privileges} ON ${mysqlPrivilegeTargetSql(input.database, input.table)} TO ${mysqlUserAccount(input.user)}${grantOption};`;
+}
+
+export function mysqlRevokePrivilegesSql(input: PrivilegeChangeInput): string {
+  const privileges = normalizePrivileges(input.privileges).join(", ");
+  return `REVOKE ${privileges} ON ${mysqlPrivilegeTargetSql(input.database, input.table)} FROM ${mysqlUserAccount(input.user)};`;
+}
+
+export function normalizePrivileges(privileges: string[], fallback = "SELECT"): string[] {
+  const normalized = privileges.map((privilege) => privilege.trim().toUpperCase()).filter(Boolean);
+  return Array.from(new Set(normalized.length > 0 ? normalized : [fallback]));
+}
+
+export const normalizeMySqlPrivileges = normalizePrivileges;
+
+export function usersFromMySqlUserResult(result: QueryResult): DatabaseUserIdentity[] {
+  const userIndex = columnIndex(result, "user", "User");
+  const hostIndex = columnIndex(result, "host", "Host");
+  const pluginIndex = columnIndex(result, "plugin", "Plugin");
+  if (userIndex < 0 || hostIndex < 0) return [];
+  return result.rows
+    .map((row) => ({
+      user: String(row[userIndex] ?? ""),
+      host: String(row[hostIndex] ?? ""),
+      plugin: pluginIndex >= 0 && row[pluginIndex] != null ? String(row[pluginIndex]) : undefined,
+    }))
+    .filter((user) => user.user || user.host);
+}
+
+export function usersFromMySqlGranteeResult(result: QueryResult): DatabaseUserIdentity[] {
+  const granteeIndex = columnIndex(result, "grantee", "GRANTEE");
+  if (granteeIndex < 0) return [];
+  return result.rows.flatMap((row) => {
+    const parsed = parseMySqlGrantee(String(row[granteeIndex] ?? ""));
+    return parsed ? [parsed] : [];
+  });
+}
+
+export function postgresListRolesSql(): string {
+  const bypassRls = postgresRoleBypassRlsSql("r");
+  return `
+SELECT
+  r.rolname AS user,
+  CASE WHEN r.rolcanlogin THEN 'LOGIN' ELSE 'ROLE' END AS host,
+  concat_ws(', ',
+    CASE WHEN r.rolsuper THEN 'SUPERUSER' END,
+    CASE WHEN r.rolcreatedb THEN 'CREATEDB' END,
+    CASE WHEN r.rolcreaterole THEN 'CREATEROLE' END,
+    CASE WHEN r.rolreplication THEN 'REPLICATION' END,
+    CASE WHEN ${bypassRls} THEN 'BYPASSRLS' END
+  ) AS plugin
+FROM pg_catalog.pg_roles r
+ORDER BY r.rolname;`.trim();
+}
+
+export function usersFromPostgresRolesResult(result: QueryResult): DatabaseUserIdentity[] {
+  return usersFromMySqlUserResult(result);
+}
+
+export function postgresShowGrantsSql(user: DatabaseUserIdentity): string {
+  const role = quoteSqlString(user.user);
+  const bypassRls = postgresRoleBypassRlsSql("r");
+  return `
+WITH target AS (
+  SELECT oid, rolname, rolsuper, rolcreatedb, rolcreaterole, rolcanlogin, rolreplication, ${bypassRls} AS rolbypassrls
+  FROM pg_catalog.pg_roles r
+  WHERE r.rolname = ${role}
+)
+SELECT line
+FROM (
+  SELECT 1 AS sort, 'Role: ' || quote_ident(rolname) AS line
+  FROM target
+  UNION ALL
+  SELECT 2, 'Attributes: ' || COALESCE(NULLIF(concat_ws(', ',
+    CASE WHEN rolsuper THEN 'SUPERUSER' END,
+    CASE WHEN rolcreatedb THEN 'CREATEDB' END,
+    CASE WHEN rolcreaterole THEN 'CREATEROLE' END,
+    CASE WHEN rolcanlogin THEN 'LOGIN' ELSE 'NOLOGIN' END,
+    CASE WHEN rolreplication THEN 'REPLICATION' END,
+    CASE WHEN rolbypassrls THEN 'BYPASSRLS' END
+  ), ''), 'none')
+  FROM target
+  UNION ALL
+  SELECT 10, 'Member of: ' || quote_ident(parent.rolname) || CASE WHEN m.admin_option THEN ' WITH ADMIN OPTION' ELSE '' END
+  FROM pg_catalog.pg_auth_members m
+  JOIN target t ON t.oid = m.member
+  JOIN pg_catalog.pg_roles parent ON parent.oid = m.roleid
+  UNION ALL
+  SELECT 20, 'Has member: ' || quote_ident(member.rolname) || CASE WHEN m.admin_option THEN ' WITH ADMIN OPTION' ELSE '' END
+  FROM pg_catalog.pg_auth_members m
+  JOIN target t ON t.oid = m.roleid
+  JOIN pg_catalog.pg_roles member ON member.oid = m.member
+  UNION ALL
+  SELECT 30, 'Database: ' || quote_ident(d.datname) || ' = ' ||
+    concat_ws(', ',
+      CASE WHEN has_database_privilege(t.rolname, d.oid, 'CONNECT') THEN 'CONNECT' END,
+      CASE WHEN has_database_privilege(t.rolname, d.oid, 'CREATE') THEN 'CREATE' END,
+      CASE WHEN has_database_privilege(t.rolname, d.oid, 'TEMPORARY') THEN 'TEMPORARY' END
+    )
+  FROM target t
+  CROSS JOIN pg_catalog.pg_database d
+  WHERE has_database_privilege(t.rolname, d.oid, 'CONNECT')
+     OR has_database_privilege(t.rolname, d.oid, 'CREATE')
+     OR has_database_privilege(t.rolname, d.oid, 'TEMPORARY')
+  UNION ALL
+  SELECT 40, 'Schema: ' || quote_ident(n.nspname) || ' = ' ||
+    concat_ws(', ',
+      CASE WHEN has_schema_privilege(t.rolname, n.oid, 'USAGE') THEN 'USAGE' END,
+      CASE WHEN has_schema_privilege(t.rolname, n.oid, 'CREATE') THEN 'CREATE' END
+    )
+  FROM target t
+  CROSS JOIN pg_catalog.pg_namespace n
+  WHERE n.nspname NOT LIKE 'pg~_%' ESCAPE '~'
+    AND n.nspname <> 'information_schema'
+    AND (has_schema_privilege(t.rolname, n.oid, 'USAGE') OR has_schema_privilege(t.rolname, n.oid, 'CREATE'))
+  UNION ALL
+  SELECT 50, 'Table: ' || quote_ident(table_schema) || '.' || quote_ident(table_name) || ' = ' ||
+    string_agg(privilege_type || CASE WHEN is_grantable = 'YES' THEN ' WITH GRANT OPTION' ELSE '' END, ', ' ORDER BY privilege_type)
+  FROM information_schema.role_table_grants
+  WHERE grantee = ${role}
+  GROUP BY table_schema, table_name
+) grants
+ORDER BY sort, line;`.trim();
+}
+
+export function kingbaseListRolesSql(): string {
+  return `
+SELECT
+  r.rolname AS user,
+  CASE WHEN r.rolcanlogin THEN 'LOGIN' ELSE 'ROLE' END AS host,
+  concat_ws(', ',
+    CASE WHEN r.rolsuper THEN 'SUPERUSER' END,
+    CASE WHEN r.rolcreatedb THEN 'CREATEDB' END,
+    CASE WHEN r.rolcreaterole THEN 'CREATEROLE' END,
+    CASE WHEN r.rolreplication THEN 'REPLICATION' END,
+    CASE WHEN r.rolbypassrls THEN 'BYPASSRLS' END
+  ) AS plugin
+FROM sys_catalog.sys_roles r
+ORDER BY r.rolname;`.trim();
+}
+
+export function kingbaseShowGrantsSql(user: DatabaseUserIdentity): string {
+  const role = quoteSqlString(user.user);
+  return `
+WITH target AS (
+  SELECT oid, rolname, rolsuper, rolcreatedb, rolcreaterole, rolcanlogin, rolreplication, rolbypassrls
+  FROM sys_catalog.sys_roles r
+  WHERE r.rolname = ${role}
+)
+SELECT line
+FROM (
+  SELECT 1 AS sort, 'Role: ' || quote_ident(rolname) AS line
+  FROM target
+  UNION ALL
+  SELECT 2, 'Attributes: ' || COALESCE(NULLIF(concat_ws(', ',
+    CASE WHEN rolsuper THEN 'SUPERUSER' END,
+    CASE WHEN rolcreatedb THEN 'CREATEDB' END,
+    CASE WHEN rolcreaterole THEN 'CREATEROLE' END,
+    CASE WHEN rolcanlogin THEN 'LOGIN' ELSE 'NOLOGIN' END,
+    CASE WHEN rolreplication THEN 'REPLICATION' END,
+    CASE WHEN rolbypassrls THEN 'BYPASSRLS' END
+  ), ''), 'none')
+  FROM target
+  UNION ALL
+  SELECT 10, 'Member of: ' || quote_ident(parent.rolname) || CASE WHEN m.admin_option THEN ' WITH ADMIN OPTION' ELSE '' END
+  FROM sys_catalog.sys_auth_members m
+  JOIN target t ON t.oid = m.member
+  JOIN sys_catalog.sys_roles parent ON parent.oid = m.roleid
+  UNION ALL
+  SELECT 20, 'Has member: ' || quote_ident(member.rolname) || CASE WHEN m.admin_option THEN ' WITH ADMIN OPTION' ELSE '' END
+  FROM sys_catalog.sys_auth_members m
+  JOIN target t ON t.oid = m.roleid
+  JOIN sys_catalog.sys_roles member ON member.oid = m.member
+  UNION ALL
+  SELECT 30, 'Database: ' || quote_ident(d.datname) || ' = ' ||
+    concat_ws(', ',
+      CASE WHEN has_database_privilege(t.rolname, d.oid, 'CONNECT') THEN 'CONNECT' END,
+      CASE WHEN has_database_privilege(t.rolname, d.oid, 'CREATE') THEN 'CREATE' END,
+      CASE WHEN has_database_privilege(t.rolname, d.oid, 'TEMPORARY') THEN 'TEMPORARY' END
+    )
+  FROM target t
+  CROSS JOIN sys_catalog.sys_database d
+  WHERE has_database_privilege(t.rolname, d.oid, 'CONNECT')
+     OR has_database_privilege(t.rolname, d.oid, 'CREATE')
+     OR has_database_privilege(t.rolname, d.oid, 'TEMPORARY')
+  UNION ALL
+  SELECT 40, 'Schema: ' || quote_ident(n.nspname) || ' = ' ||
+    concat_ws(', ',
+      CASE WHEN has_schema_privilege(t.rolname, n.oid, 'USAGE') THEN 'USAGE' END,
+      CASE WHEN has_schema_privilege(t.rolname, n.oid, 'CREATE') THEN 'CREATE' END
+    )
+  FROM target t
+  CROSS JOIN sys_catalog.sys_namespace n
+  WHERE UPPER(n.nspname) <> 'INFORMATION_SCHEMA'
+    AND UPPER(n.nspname) NOT LIKE 'SYS%'
+    AND UPPER(n.nspname) NOT LIKE 'XLOG%'
+    AND (has_schema_privilege(t.rolname, n.oid, 'USAGE') OR has_schema_privilege(t.rolname, n.oid, 'CREATE'))
+  UNION ALL
+  SELECT 50, 'Table: ' || quote_ident(table_schema) || '.' || quote_ident(table_name) || ' = ' ||
+    string_agg(privilege_type || CASE WHEN is_grantable = 'YES' THEN ' WITH GRANT OPTION' ELSE '' END, ', ' ORDER BY privilege_type)
+  FROM information_schema.role_table_grants
+  WHERE grantee = ${role}
+    AND UPPER(table_schema) <> 'INFORMATION_SCHEMA'
+    AND UPPER(table_schema) NOT LIKE 'SYS%'
+    AND UPPER(table_schema) NOT LIKE 'XLOG%'
+  GROUP BY table_schema, table_name
+) grants
+ORDER BY sort, line;`.trim();
+}
+
+export function postgresCreateRoleSql(input: CreatePrincipalInput): string {
+  const login = input.canLogin === false ? "NOLOGIN" : "LOGIN";
+  return `CREATE ROLE ${quotePostgresIdentifier(input.user)} ${login} PASSWORD ${quoteSqlString(input.password)};`;
+}
+
+export function postgresAlterRolePasswordSql(user: DatabaseUserIdentity, password: string): string {
+  return `ALTER ROLE ${quotePostgresIdentifier(user.user)} PASSWORD ${quoteSqlString(password)};`;
+}
+
+export function postgresAlterRoleLoginSql(user: DatabaseUserIdentity, enabled: boolean): string {
+  return `ALTER ROLE ${quotePostgresIdentifier(user.user)} ${enabled ? "LOGIN" : "NOLOGIN"};`;
+}
+
+export function postgresDropRoleSql(user: DatabaseUserIdentity): string {
+  return `DROP ROLE ${quotePostgresIdentifier(user.user)};`;
+}
+
+export function postgresPrivilegeTargetSql(input: Pick<PrivilegeChangeInput, "scope" | "database" | "table">): string {
+  const scope = input.scope || "database";
+  const name = input.database.trim();
+  if (scope === "database") return `DATABASE ${quotePostgresIdentifier(name || "postgres")}`;
+  if (scope === "schema") return `SCHEMA ${quotePostgresIdentifier(name || "public")}`;
+  const schema = name || "public";
+  const table = input.table?.trim() || "*";
+  if (table === "*") return `ALL TABLES IN SCHEMA ${quotePostgresIdentifier(schema)}`;
+  return `TABLE ${quotePostgresIdentifier(schema)}.${quotePostgresIdentifier(table)}`;
+}
+
+export function postgresGrantPrivilegesSql(input: PrivilegeChangeInput): string {
+  if (input.scope === "role") {
+    return `GRANT ${quotePostgresIdentifier(input.role?.trim() || "")} TO ${quotePostgresIdentifier(input.user.user)}${input.grantOption ? " WITH ADMIN OPTION" : ""};`;
+  }
+  const privileges = normalizePrivileges(input.privileges, postgresDefaultPrivilege(input.scope)).join(", ");
+  return `GRANT ${privileges} ON ${postgresPrivilegeTargetSql(input)} TO ${quotePostgresIdentifier(input.user.user)}${input.grantOption ? " WITH GRANT OPTION" : ""};`;
+}
+
+export function postgresRevokePrivilegesSql(input: PrivilegeChangeInput): string {
+  if (input.scope === "role") {
+    return `REVOKE ${quotePostgresIdentifier(input.role?.trim() || "")} FROM ${quotePostgresIdentifier(input.user.user)};`;
+  }
+  const privileges = normalizePrivileges(input.privileges, postgresDefaultPrivilege(input.scope)).join(", ");
+  return `REVOKE ${privileges} ON ${postgresPrivilegeTargetSql(input)} FROM ${quotePostgresIdentifier(input.user.user)};`;
+}
+
+export function grantsFromQueryResult(result: QueryResult): string[] {
+  return result.rows.map((row) => String(row[0] ?? "")).filter(Boolean);
+}
+
+function columnIndex(result: QueryResult, ...names: string[]): number {
+  const wanted = new Set(names.map((name) => name.toLowerCase()));
+  return result.columns.findIndex((column) => wanted.has(column.toLowerCase()));
+}
+
+function parseMySqlGrantee(value: string): DatabaseUserIdentity | null {
+  const match = /^'((?:''|[^'])*)'@'((?:''|[^'])*)'$/.exec(value.trim());
+  if (!match) return null;
+  return {
+    user: match[1].replace(/''/g, "'"),
+    host: match[2].replace(/''/g, "'"),
+  };
+}
+
+function postgresDefaultPrivilege(scope: PrivilegeScope | undefined): string {
+  if (scope === "schema") return "USAGE";
+  if (scope === "database") return "CONNECT";
+  return "SELECT";
+}
+
+function postgresPrivilegesForScope(scope: PrivilegeScope): readonly string[] {
+  if (scope === "database") return POSTGRES_DATABASE_PRIVILEGES;
+  if (scope === "schema") return POSTGRES_SCHEMA_PRIVILEGES;
+  if (scope === "table") return POSTGRES_TABLE_PRIVILEGES;
+  return [];
+}
+
+function postgresRoleBypassRlsSql(alias: string): string {
+  return `row_to_json(${alias})::text LIKE '%"rolbypassrls":true%'`;
+}
+
+export const mysqlUserAdminProvider: DatabaseUserAdminProvider = {
+  dialect: "mysql",
+  defaultScope: "mysql",
+  listUsersSql: mysqlListUsersSql,
+  fallbackListUsersSql: mysqlListUsersFallbackSql,
+  parseUsers: usersFromMySqlUserResult,
+  parseFallbackUsers: usersFromMySqlGranteeResult,
+  showGrantsSql: mysqlShowGrantsSql,
+  createUserSql: mysqlCreateUserSql,
+  alterPasswordSql: mysqlAlterUserPasswordSql,
+  alterLoginSql: (user, enabled) => mysqlAlterUserAccountLockSql(user, !enabled),
+  dropUserSql: mysqlDropUserSql,
+  grantPrivilegesSql: mysqlGrantPrivilegesSql,
+  revokePrivilegesSql: mysqlRevokePrivilegesSql,
+  label: mysqlUserLabel,
+  detail: (user) => user.plugin,
+  privilegesForScope: () => MYSQL_COMMON_PRIVILEGES,
+  defaultPrivilegesForScope: () => ["SELECT"],
+};
+
+export const postgresUserAdminProvider: DatabaseUserAdminProvider = {
+  dialect: "postgres",
+  defaultScope: "database",
+  listUsersSql: postgresListRolesSql,
+  parseUsers: usersFromPostgresRolesResult,
+  showGrantsSql: postgresShowGrantsSql,
+  createUserSql: postgresCreateRoleSql,
+  alterPasswordSql: postgresAlterRolePasswordSql,
+  alterLoginSql: postgresAlterRoleLoginSql,
+  dropUserSql: postgresDropRoleSql,
+  grantPrivilegesSql: postgresGrantPrivilegesSql,
+  revokePrivilegesSql: postgresRevokePrivilegesSql,
+  label: postgresRoleLabel,
+  detail: (user) => [user.host, user.plugin].filter(Boolean).join(" · ") || undefined,
+  privilegesForScope: postgresPrivilegesForScope,
+  defaultPrivilegesForScope: (scope) => (scope === "role" ? [] : [postgresDefaultPrivilege(scope)]),
+};
+
+export const kingbaseUserAdminProvider: DatabaseUserAdminProvider = {
+  ...postgresUserAdminProvider,
+  listUsersSql: kingbaseListRolesSql,
+  showGrantsSql: kingbaseShowGrantsSql,
+};
diff --git a/apps/desktop/src/lib/database/dbAdminSql.ts b/apps/desktop/src/lib/database/dbAdminSql.ts
new file mode 100644
index 0000000..f1e1043
--- /dev/null
+++ b/apps/desktop/src/lib/database/dbAdminSql.ts
@@ -0,0 +1,179 @@
+import type { DatabaseObjectType, DatabaseType } from "@/types/database";
+import * as api from "@/lib/backend/api";
+
+export interface DropObjectSqlOptions {
+  databaseType?: DatabaseType;
+  objectType: DatabaseObjectType;
+  schema?: string | null;
+  name: string;
+  signature?: string | null;
+}
+
+export interface TableAdminSqlOptions {
+  databaseType?: DatabaseType;
+  schema?: string | null;
+  tableName: string;
+  cascade?: boolean;
+}
+
+export type TableChildObjectType = "COLUMN" | "INDEX" | "FOREIGN_KEY" | "TRIGGER";
+
+export interface DropTableChildObjectSqlOptions {
+  databaseType?: DatabaseType;
+  objectType: TableChildObjectType;
+  schema?: string | null;
+  tableName: string;
+  name: string;
+}
+
+export interface DatabaseNameSqlOptions {
+  databaseType?: DatabaseType;
+  name: string;
+}
+
+export interface SchemaNameSqlOptions {
+  databaseType?: DatabaseType;
+  name: string;
+}
+
+export interface SchemaCommentSqlOptions extends SchemaNameSqlOptions {
+  comment: string;
+}
+
+export interface DatabasePropertyEditSqlOptions {
+  databaseType?: DatabaseType;
+  driverProfile?: string | null;
+  target: "database" | "schema";
+  name: string;
+  charset?: string;
+  collation?: string;
+  comment?: string;
+}
+
+export interface DuplicateTableStructureSqlOptions {
+  databaseType?: DatabaseType;
+  schema?: string | null;
+  sourceName: string;
+  targetName: string;
+}
+
+export interface CopyTableDataSqlOptions {
+  databaseType?: DatabaseType;
+  schema?: string | null;
+  sourceName: string;
+  targetName: string;
+  columns?: string[];
+  postgresOverridingSystemValue?: boolean;
+  sqlserverIdentityInsert?: boolean;
+}
+
+export function buildDropObjectSql(options: DropObjectSqlOptions): Promise<string> {
+  return api.buildDropObjectSql(options);
+}
+
+export function buildDropTableSql(options: TableAdminSqlOptions): Promise<string> {
+  return api.buildDropTableSql(options);
+}
+
+export function buildDropTableChildObjectSql(options: DropTableChildObjectSqlOptions): Promise<string> {
+  return api.buildDropTableChildObjectSql(options);
+}
+
+export function buildEmptyTableSql(options: TableAdminSqlOptions): Promise<string> {
+  return api.buildEmptyTableSql(options);
+}
+
+export function buildTruncateTableSql(options: TableAdminSqlOptions): Promise<string> {
+  return api.buildTruncateTableSql(options);
+}
+
+const DROP_TABLE_CASCADE_DATABASE_TYPES: readonly DatabaseType[] = ["postgres", "redshift", "gaussdb", "kwdb", "kingbase", "highgo", "vastbase", "opengauss"];
+const TRUNCATE_TABLE_CASCADE_DATABASE_TYPES: readonly DatabaseType[] = ["postgres", "gaussdb", "kwdb", "kingbase", "highgo", "vastbase", "opengauss"];
+
+export function supportsDropTableCascade(databaseType?: DatabaseType): boolean {
+  return !!databaseType && DROP_TABLE_CASCADE_DATABASE_TYPES.includes(databaseType);
+}
+
+export function supportsTruncateTableCascade(databaseType?: DatabaseType): boolean {
+  return !!databaseType && TRUNCATE_TABLE_CASCADE_DATABASE_TYPES.includes(databaseType);
+}
+
+export function buildDropDatabaseSql(options: DatabaseNameSqlOptions): Promise<string> {
+  return api.buildDropDatabaseSql(options);
+}
+
+export function buildCreateSchemaSql(options: SchemaNameSqlOptions): Promise<string> {
+  return api.buildCreateSchemaSql(options);
+}
+
+export function buildDropSchemaSql(options: SchemaNameSqlOptions): Promise<string> {
+  return api.buildDropSchemaSql(options);
+}
+
+export function supportsSchemaComment(databaseType?: DatabaseType): boolean {
+  return ["postgres", "gaussdb", "kwdb", "kingbase", "highgo", "vastbase", "opengauss", "yashandb"].includes(databaseType || "");
+}
+
+export function buildUpdateDatabasePropertiesSql(options: DatabasePropertyEditSqlOptions): Promise<string> {
+  return api.buildUpdateDatabasePropertiesSql(options);
+}
+
+export function buildGetDatabaseCommentSql(options: DatabaseNameSqlOptions): string {
+  if (!supportsSchemaComment(options.databaseType)) {
+    throw new Error("Database comments are not supported by this database");
+  }
+  return ["SELECT pg_catalog.shobj_description(db.oid, 'pg_database') AS comment", "FROM pg_catalog.pg_database db", `WHERE db.datname = ${quoteSqlLiteral(options.name)};`].join("\n");
+}
+
+export function buildGetSchemaCommentSql(options: SchemaNameSqlOptions): string {
+  if (!supportsSchemaComment(options.databaseType)) {
+    throw new Error("Schema comments are not supported by this database");
+  }
+  return ["SELECT d.description AS comment", "FROM pg_catalog.pg_namespace n", "LEFT JOIN pg_catalog.pg_description d ON d.objoid = n.oid AND d.objsubid = 0 AND d.classoid = 'pg_namespace'::regclass", `WHERE n.nspname = ${quoteSqlLiteral(options.name)};`].join("\n");
+}
+
+export function buildSetSchemaCommentSql(options: SchemaCommentSqlOptions): string {
+  if (!supportsSchemaComment(options.databaseType)) {
+    throw new Error("Schema comments are not supported by this database");
+  }
+  const comment = options.comment.trim();
+  const literal = comment ? quoteSqlLiteral(comment) : "NULL";
+  return `COMMENT ON SCHEMA ${quotePostgresIdentifier(options.name)} IS ${literal};`;
+}
+
+export function buildDuplicateTableStructureSql(options: DuplicateTableStructureSqlOptions): Promise<string> {
+  return api.buildDuplicateTableStructureSql(options);
+}
+
+export function buildCopyTableDataSql(options: CopyTableDataSqlOptions): Promise<string> {
+  return api.buildCopyTableDataSql(options);
+}
+
+function quotePostgresIdentifier(value: string): string {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+
+function quoteSqlLiteral(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+export function buildCreateExtensionSql(name: string, schema?: string | null): string {
+  const extName = quotePostgresIdentifier(name);
+  if (schema) {
+    return `CREATE EXTENSION ${extName} WITH SCHEMA ${quotePostgresIdentifier(schema)};`;
+  }
+  return `CREATE EXTENSION ${extName};`;
+}
+
+export function buildDropExtensionSql(name: string, cascade = false): string {
+  const extName = quotePostgresIdentifier(name);
+  return cascade ? `DROP EXTENSION ${extName} CASCADE;` : `DROP EXTENSION ${extName};`;
+}
+
+export function buildListAvailableExtensionsSql(schema?: string | null): string {
+  // pg_available_extensions shows extensions available for installation
+  if (schema) {
+    return `SELECT name, default_version, comment FROM pg_catalog.pg_available_extensions WHERE installed_version IS NULL ORDER BY name`;
+  }
+  return `SELECT name, default_version, comment FROM pg_catalog.pg_available_extensions WHERE installed_version IS NULL ORDER BY name`;
+}
diff --git a/apps/desktop/src/lib/database/defaultDatabase.ts b/apps/desktop/src/lib/database/defaultDatabase.ts
new file mode 100644
index 0000000..1a923ee
--- /dev/null
+++ b/apps/desktop/src/lib/database/defaultDatabase.ts
@@ -0,0 +1,36 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { usesTreeSchemaMode } from "@/lib/database/databaseCapabilities";
+
+export const TREE_SCHEMA_DEFAULT_DATABASE_SELECT_VALUE = "__dbx_tree_schema_default_database__";
+export const EMPTY_DATABASE_SELECT_VALUE = "__dbx_empty_database__";
+
+export function resolveDefaultDatabase(connection: Pick<ConnectionConfig, "database"> & Partial<Pick<ConnectionConfig, "db_type">>, options: string[]): string {
+  if (connection.db_type === "cloudflare-d1") return "main";
+  return connection.database || options[0] || "";
+}
+
+export function isTreeSchemaDefaultDatabase(dbType: DatabaseType | undefined, database: string): boolean {
+  return database === "" && usesTreeSchemaMode(dbType);
+}
+
+export function encodeSelectableDatabaseValue(dbType: DatabaseType | undefined, database: string): string {
+  if (isTreeSchemaDefaultDatabase(dbType, database)) return TREE_SCHEMA_DEFAULT_DATABASE_SELECT_VALUE;
+  return database === "" ? EMPTY_DATABASE_SELECT_VALUE : database;
+}
+
+export function decodeSelectableDatabaseValue(dbType: DatabaseType | undefined, value: string): string {
+  if (value === TREE_SCHEMA_DEFAULT_DATABASE_SELECT_VALUE && usesTreeSchemaMode(dbType)) return "";
+  if (value === EMPTY_DATABASE_SELECT_VALUE) return "";
+  return value;
+}
+
+export function formatDatabaseLabel(connection: Pick<ConnectionConfig, "db_type"> | undefined, database: string, labels: { defaultDatabase: string; noDatabase: string }): string {
+  if (connection?.db_type === "redis" && database !== "") return `db${database}`;
+  if (isTreeSchemaDefaultDatabase(connection?.db_type, database)) return labels.defaultDatabase;
+  return database || labels.noDatabase;
+}
+
+export function isDefaultDatabase(connection: (Pick<ConnectionConfig, "database"> & Partial<Pick<ConnectionConfig, "db_type">>) | undefined, database: string): boolean {
+  if (connection?.db_type === "cloudflare-d1") return database === "main";
+  return !!connection?.database && !!database && connection.database === database;
+}
diff --git a/apps/desktop/src/lib/database/h2Connection.ts b/apps/desktop/src/lib/database/h2Connection.ts
new file mode 100644
index 0000000..299ecdb
--- /dev/null
+++ b/apps/desktop/src/lib/database/h2Connection.ts
@@ -0,0 +1,165 @@
+import type { ConnectionConfig } from "@/types/database";
+
+export type H2ConnectionMode = "file" | "tcp";
+
+const H2_FILE_PREFIX = "jdbc:h2:file:";
+const H2_SPLIT_PREFIX = "jdbc:h2:split:";
+const H2_FILE_PREFIXES = [H2_FILE_PREFIX, H2_SPLIT_PREFIX];
+const H2_DEFAULT_PORT = 9092;
+const H2_PARSED_PROFILE = {
+  dbType: "h2" as const,
+  driverProfile: "h2" as const,
+  driverLabel: "H2" as const,
+};
+
+function decodeH2UrlPart(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function extractH2JdbcSemicolonParams(source: string): { username?: string; password?: string; urlParams: string } {
+  let username: string | undefined;
+  let password: string | undefined;
+  const urlParams: string[] = [];
+
+  for (const part of source.split(";").slice(1)) {
+    if (!part) continue;
+    const [rawKey, ...rest] = part.split("=");
+    const key = decodeH2UrlPart(rawKey).trim().toLowerCase();
+    const value = decodeH2UrlPart(rest.join("=")).trim();
+    if (key === "user") {
+      username = value;
+    } else if (key === "password") {
+      password = value;
+    } else {
+      urlParams.push(part);
+    }
+  }
+
+  return { username, password, urlParams: urlParams.join(";") };
+}
+
+function hasH2JdbcSemicolonParam(source: string | undefined, name: string): boolean {
+  for (const part of (source || "").split(";").slice(1)) {
+    if (!part) continue;
+    const [rawKey] = part.split("=");
+    if (decodeH2UrlPart(rawKey).trim().toLowerCase() === name) return true;
+  }
+  return false;
+}
+
+export function h2JdbcUrlHasUserParam(source: string | undefined): boolean {
+  return hasH2JdbcSemicolonParam(source, "user");
+}
+
+export function h2JdbcUrlHasPasswordParam(source: string | undefined): boolean {
+  return hasH2JdbcSemicolonParam(source, "password");
+}
+
+function databaseNameFromPath(path: string): string | undefined {
+  const name = path.split(/[\\/]/).filter(Boolean).pop()?.trim();
+  return name || undefined;
+}
+
+function h2FileJdbcUrlPrefix(value: string): string | undefined {
+  const lower = value.toLowerCase();
+  return H2_FILE_PREFIXES.find((prefix) => lower.startsWith(prefix));
+}
+
+export function isH2FileJdbcUrl(value: string | undefined | null): boolean {
+  return h2FileJdbcUrlPrefix((value || "").trim()) !== undefined;
+}
+
+export function h2FilePathFromJdbcUrl(value: string | undefined | null): string {
+  const trimmed = (value || "").trim();
+  const prefix = h2FileJdbcUrlPrefix(trimmed);
+  if (!prefix) return "";
+  const rawPath = trimmed.slice(prefix.length).split(";")[0] || "";
+  if (prefix === H2_SPLIT_PREFIX) {
+    return rawPath.replace(/^\d+:/, "");
+  }
+  return rawPath;
+}
+
+export function isH2SplitJdbcUrl(value: string | undefined | null): value is string {
+  return (value || "").trim().toLowerCase().startsWith(H2_SPLIT_PREFIX);
+}
+
+export function h2FileJdbcUrlWithPath(source: string | undefined | null, path: string): string {
+  const trimmed = (source || "").trim();
+  if (!isH2SplitJdbcUrl(trimmed)) return h2FileJdbcUrl(path);
+
+  const rest = trimmed.slice(H2_SPLIT_PREFIX.length);
+  const [rawPath, ...optionParts] = rest.split(";");
+  const blockPrefix = rawPath.match(/^\d+:/)?.[0] || "";
+  const options = optionParts.length > 0 ? `;${optionParts.join(";")}` : "";
+  return `${H2_SPLIT_PREFIX}${blockPrefix}${h2JdbcFileBasePath(path)}${options}`;
+}
+
+export function parseH2JdbcUrl(source: string) {
+  const trimmed = source.trim();
+  if (!/^jdbc:h2:/i.test(trimmed)) return null;
+
+  const credentials = extractH2JdbcSemicolonParams(trimmed);
+  const filePath = h2FilePathFromJdbcUrl(trimmed);
+  if (filePath) {
+    return {
+      ...H2_PARSED_PROFILE,
+      host: filePath,
+      port: 0,
+      username: credentials.username || "sa",
+      password: credentials.password || "",
+      database: databaseNameFromPath(filePath),
+      urlParams: credentials.urlParams,
+      ssl: false,
+      connectionString: trimmed,
+    };
+  }
+
+  const serverMatch = /^jdbc:h2:(?<protocol>tcp|ssl):\/\/(?<host>\[[^\]]+\]|[^:/;]+)(?::(?<port>\d+))?\/(?<database>[^;]*)/i.exec(trimmed);
+  if (serverMatch?.groups) {
+    return {
+      ...H2_PARSED_PROFILE,
+      host: serverMatch.groups.host.replace(/^\[/, "").replace(/\]$/, ""),
+      port: serverMatch.groups.port ? Number(serverMatch.groups.port) : H2_DEFAULT_PORT,
+      username: credentials.username || "sa",
+      password: credentials.password || "",
+      database: decodeH2UrlPart(serverMatch.groups.database || "") || undefined,
+      urlParams: credentials.urlParams,
+      ssl: serverMatch.groups.protocol.toLowerCase() === "ssl",
+      connectionString: trimmed,
+    };
+  }
+
+  const database = trimmed.replace(/^jdbc:h2:/i, "").split(";")[0] || undefined;
+  return {
+    ...H2_PARSED_PROFILE,
+    host: "",
+    port: H2_DEFAULT_PORT,
+    username: credentials.username || "sa",
+    password: credentials.password || "",
+    database: database ? decodeH2UrlPart(database) : undefined,
+    urlParams: credentials.urlParams,
+    ssl: false,
+    connectionString: trimmed,
+  };
+}
+
+export function h2JdbcFileBasePath(path: string): string {
+  const trimmed = path.trim();
+  if (/\.mv\.db$/i.test(trimmed)) return trimmed.slice(0, -".mv.db".length);
+  if (/\.h2\.db$/i.test(trimmed)) return trimmed.slice(0, -".h2.db".length);
+  return trimmed;
+}
+
+export function h2FileJdbcUrl(path: string): string {
+  return `${H2_FILE_PREFIX}${h2JdbcFileBasePath(path)};AUTO_SERVER=TRUE`;
+}
+
+export function h2ConnectionModeForConfig(config: Pick<ConnectionConfig, "db_type" | "connection_string" | "port">) {
+  if (config.db_type !== "h2") return "tcp";
+  return isH2FileJdbcUrl(config.connection_string) || config.port === 0 ? "file" : "tcp";
+}
diff --git a/apps/desktop/src/lib/database/hiveKerberosOptions.ts b/apps/desktop/src/lib/database/hiveKerberosOptions.ts
new file mode 100644
index 0000000..7648339
--- /dev/null
+++ b/apps/desktop/src/lib/database/hiveKerberosOptions.ts
@@ -0,0 +1,149 @@
+export type HiveKerberosAuthMode = "none" | "kerberos";
+
+export interface HiveKerberosFormConfig {
+  authMode: HiveKerberosAuthMode;
+  principal: string;
+  krb5ConfPath: string;
+  jaasConfigPath: string;
+  useSubjectCredsOnlyFalse: boolean;
+  extraJavaOptions: string;
+}
+
+export interface HiveKerberosSubmitConfig extends HiveKerberosFormConfig {
+  urlParams?: string;
+}
+
+const KRB5_CONF_PREFIX = "-Djava.security.krb5.conf=";
+const JAAS_CONFIG_PREFIX = "-Djava.security.auth.login.config=";
+const SUBJECT_CREDS_PREFIX = "-Djavax.security.auth.useSubjectCredsOnly=";
+
+export function hiveKerberosFormConfig(urlParams?: string, agentJavaOptions?: string[]): HiveKerberosFormConfig {
+  const params = parseHiveUrlParams(urlParams);
+  const auth = getHiveUrlParam(params, "auth").toLowerCase();
+  const principal = getHiveUrlParam(params, "principal");
+  const java = parseHiveKerberosJavaOptions(agentJavaOptions || []);
+
+  return {
+    authMode: auth === "kerberos" || principal ? "kerberos" : "none",
+    principal,
+    ...java,
+  };
+}
+
+export function applyHiveKerberosSubmitConfig(config: HiveKerberosSubmitConfig): {
+  urlParams: string;
+  agentJavaOptions: string[];
+} {
+  const enabled = config.authMode === "kerberos";
+  return {
+    urlParams: applyHiveKerberosUrlParams(config.urlParams, enabled, config.principal),
+    agentJavaOptions: buildHiveKerberosJavaOptions(enabled, config),
+  };
+}
+
+export function applyHiveKerberosUrlParams(urlParams: string | undefined, enabled: boolean, principal: string): string {
+  const params = parseHiveUrlParams(urlParams).filter((param) => shouldKeepHiveUrlParam(param, enabled));
+  if (enabled) {
+    const normalizedPrincipal = principal.trim();
+    if (normalizedPrincipal) {
+      params.push({ key: "principal", value: normalizedPrincipal });
+    }
+  }
+  return serializeHiveUrlParams(params);
+}
+
+export function buildHiveKerberosJavaOptions(enabled: boolean, config: HiveKerberosFormConfig): string[] {
+  const options: string[] = [];
+  if (enabled) {
+    const krb5ConfPath = config.krb5ConfPath.trim();
+    const jaasConfigPath = config.jaasConfigPath.trim();
+    if (krb5ConfPath) options.push(`${KRB5_CONF_PREFIX}${krb5ConfPath}`);
+    if (jaasConfigPath) options.push(`${JAAS_CONFIG_PREFIX}${jaasConfigPath}`);
+    if (config.useSubjectCredsOnlyFalse) options.push(`${SUBJECT_CREDS_PREFIX}false`);
+  }
+  options.push(...splitExtraJavaOptions(config.extraJavaOptions));
+  return options;
+}
+
+interface HiveUrlParam {
+  key: string;
+  value: string;
+}
+
+function parseHiveUrlParams(urlParams?: string): HiveUrlParam[] {
+  return trimHiveUrlParams(urlParams)
+    .split(/[;&]/)
+    .map((part) => part.trim())
+    .filter(Boolean)
+    .map((part) => {
+      const equals = part.indexOf("=");
+      if (equals < 0) return { key: part, value: "" };
+      return { key: part.slice(0, equals).trim(), value: part.slice(equals + 1).trim() };
+    })
+    .filter((param) => !!param.key);
+}
+
+function serializeHiveUrlParams(params: HiveUrlParam[]): string {
+  return params.map((param) => (param.value ? `${param.key}=${param.value}` : param.key)).join(";");
+}
+
+function trimHiveUrlParams(urlParams?: string): string {
+  return (urlParams || "")
+    .trim()
+    .replace(/^[?&;]+/, "")
+    .replace(/[?&;]+$/, "");
+}
+
+function getHiveUrlParam(params: HiveUrlParam[], key: string): string {
+  const lowerKey = key.toLowerCase();
+  return params.find((param) => param.key.toLowerCase() === lowerKey)?.value || "";
+}
+
+function shouldKeepHiveUrlParam(param: HiveUrlParam, kerberosEnabled: boolean): boolean {
+  const key = param.key.toLowerCase();
+  if (key === "principal") return false;
+  if (key !== "auth") return true;
+
+  const auth = param.value.toLowerCase();
+  if (kerberosEnabled) {
+    // `auth=noSasl` and token auth conflict with Kerberos. Hive's JDBC driver selects
+    // regular Kerberos from `principal`; `auth=kerberos` is only needed for explicit advanced cases.
+    return auth === "kerberos";
+  }
+  return auth !== "kerberos";
+}
+
+function parseHiveKerberosJavaOptions(options: string[]): Omit<HiveKerberosFormConfig, "authMode" | "principal"> {
+  let krb5ConfPath = "";
+  let jaasConfigPath = "";
+  let useSubjectCredsOnlyFalse = false;
+  const extra: string[] = [];
+
+  for (const option of options) {
+    const trimmed = option.trim();
+    if (!trimmed) continue;
+    if (trimmed.startsWith(KRB5_CONF_PREFIX)) {
+      krb5ConfPath = trimmed.slice(KRB5_CONF_PREFIX.length);
+    } else if (trimmed.startsWith(JAAS_CONFIG_PREFIX)) {
+      jaasConfigPath = trimmed.slice(JAAS_CONFIG_PREFIX.length);
+    } else if (trimmed.startsWith(SUBJECT_CREDS_PREFIX)) {
+      useSubjectCredsOnlyFalse = trimmed.slice(SUBJECT_CREDS_PREFIX.length).toLowerCase() === "false";
+    } else {
+      extra.push(trimmed);
+    }
+  }
+
+  return {
+    krb5ConfPath,
+    jaasConfigPath,
+    useSubjectCredsOnlyFalse,
+    extraJavaOptions: extra.join("\n"),
+  };
+}
+
+function splitExtraJavaOptions(value: string): string[] {
+  return value
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
diff --git a/apps/desktop/src/lib/database/jdbcDialect.ts b/apps/desktop/src/lib/database/jdbcDialect.ts
new file mode 100644
index 0000000..486c479
--- /dev/null
+++ b/apps/desktop/src/lib/database/jdbcDialect.ts
@@ -0,0 +1,101 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { isSchemaAware, usesDatabaseObjectTreeMode, usesTreeSchemaMode } from "@/lib/database/databaseFeatureSupport";
+
+type JdbcDialectConnection = Pick<ConnectionConfig, "db_type"> & Partial<Pick<ConnectionConfig, "driver_profile" | "connection_string" | "jdbc_driver_class" | "jdbc_driver_paths">>;
+
+const DATABASE_AS_EXECUTION_SCHEMA_TYPES = new Set<DatabaseType>(["hive", "spark"]);
+
+const JDBC_DIALECT_MATCHERS: Array<{ type: DatabaseType; patterns: RegExp[] }> = [
+  { type: "databend", patterns: [/jdbc:databend:/i, /com\.databend\.jdbc\.DatabendDriver/i, /databend-jdbc/i] },
+  { type: "starrocks", patterns: [/starrocks/i] },
+  { type: "doris", patterns: [/doris/i] },
+  { type: "goldendb", patterns: [/jdbc:goldendb:/i, /goldendb/i] },
+  { type: "hive", patterns: [/org\.apache\.hive\.jdbc\.HiveDriver/i, /hive-jdbc/i] },
+  { type: "mysql", patterns: [/jdbc:mysql:/i, /mysql/i, /mariadb/i, /kyuubi/i, /hive2/i] },
+  { type: "postgres", patterns: [/jdbc:postgresql:/i, /postgres/i] },
+  { type: "sqlserver", patterns: [/jdbc:sqlserver:/i, /sqlserver/i, /mssql/i] },
+  { type: "oracle", patterns: [/jdbc:oracle:/i, /oracle/i] },
+  { type: "clickhouse", patterns: [/jdbc:clickhouse:/i, /clickhouse/i] },
+  { type: "h2", patterns: [/jdbc:h2:/i, /\bh2\b/i] },
+  { type: "sqlite", patterns: [/jdbc:sqlite:/i, /sqlite/i] },
+  { type: "db2", patterns: [/jdbc:db2:/i, /\bdb2\b/i] },
+  { type: "informix", patterns: [/jdbc:informix/i, /informix/i] },
+  { type: "iris", patterns: [/jdbc:(?:iris|cache):/i, /com\.intersystems\.jdbc\.(?:IRIS|Cache)Driver/i, /intersystems-jdbc/i] },
+];
+
+export function inferJdbcDialect(connection?: JdbcDialectConnection): DatabaseType | undefined {
+  if (!connection || connection.db_type !== "jdbc") return undefined;
+  const haystack = [connection.driver_profile, connection.connection_string, connection.jdbc_driver_class, ...(connection.jdbc_driver_paths ?? [])].filter(Boolean).join("\n");
+  if (!haystack) return undefined;
+  return JDBC_DIALECT_MATCHERS.find((matcher) => matcher.patterns.some((pattern) => pattern.test(haystack)))?.type;
+}
+
+export function effectiveDatabaseTypeForConnection(connection?: JdbcDialectConnection): DatabaseType | undefined {
+  if (!connection) return undefined;
+  if (connection.db_type === "gbase" && isGbase8sProfile(connection.driver_profile)) return "informix";
+  if (connection.db_type === "gbase") return "mysql";
+  if (connection.db_type !== "jdbc") return connection.db_type;
+  return inferJdbcDialect(connection) ?? "jdbc";
+}
+
+export function tableStructureDatabaseTypeForConnection(connection?: JdbcDialectConnection): DatabaseType | undefined {
+  if (!connection) return undefined;
+  if (connection.db_type === "gbase" && !isGbase8sProfile(connection.driver_profile)) return "gbase";
+  return effectiveDatabaseTypeForConnection(connection);
+}
+
+export function connectionUsesDatabaseObjectTreeMode(connection?: JdbcDialectConnection): boolean {
+  if (!connection) return false;
+  if (connection.db_type !== "jdbc") return usesDatabaseObjectTreeMode(effectiveDatabaseTypeForConnection(connection));
+  const dialect = inferJdbcDialect(connection);
+  if (!dialect) return true;
+  if (dialect === "hive" || dialect === "trino") return false;
+  if (dialect === "databend") return true;
+  return !usesTreeSchemaMode(dialect);
+}
+
+export function connectionUsesSchemaExecutionContext(connection?: Pick<ConnectionConfig, "db_type" | "connection_string" | "jdbc_driver_class" | "jdbc_driver_paths">): boolean {
+  return connection?.db_type === "jdbc" && inferJdbcDialect(connection) === "databend";
+}
+
+export function connectionQueryExecutionSchema(connection: JdbcDialectConnection | undefined, database: string | undefined, schema: string | undefined, dataMode: boolean): string | undefined {
+  if (connectionUsesSchemaExecutionContext(connection)) return schema || database || undefined;
+  if (dataMode || connectionUsesDatabaseObjectTreeMode(connection)) return undefined;
+  if (schema) return schema;
+  const type = effectiveDatabaseTypeForConnection(connection);
+  // Hive and Spark display their SQL namespace in the database selector, but
+  // their agents switch it with USE through the schema execution parameter.
+  return type && DATABASE_AS_EXECUTION_SCHEMA_TYPES.has(type) ? database || undefined : undefined;
+}
+
+export function connectionObjectTreeQuerySchema(connection: JdbcDialectConnection | undefined, database: string, schema?: string): string {
+  if (connection?.db_type === "jdbc" && inferJdbcDialect(connection) === "databend") return schema || database;
+  if (connectionUsesDatabaseObjectTreeMode(connection)) return "";
+  return schema || database;
+}
+
+export function metadataSchemaForConnection(connection: JdbcDialectConnection | undefined, database: string, schema?: string): string {
+  const type = effectiveDatabaseTypeForConnection(connection);
+  if (type === "sqlserver") return schema || "dbo";
+  return connectionObjectTreeQuerySchema(connection, database, schema);
+}
+
+export function connectionObjectTreeNodeSchema(connection: JdbcDialectConnection | undefined, database: string, schema?: string): string | undefined {
+  if (connection?.db_type === "jdbc" && inferJdbcDialect(connection) === "databend") return schema || database;
+  if (connection?.db_type === "jdbc" && inferJdbcDialect(connection) === "databend") return schema || database;
+  if (connectionUsesDatabaseObjectTreeMode(connection)) return undefined;
+  if (schema) return schema;
+  const type = effectiveDatabaseTypeForConnection(connection);
+  return isSchemaAware(type) ? database : undefined;
+}
+
+/** Maps a database type to the corresponding CodeMirror SQL dialect name used by QueryEditor and DdlViewDialog. */
+export function codeMirrorSqlDialect(dbType: DatabaseType | undefined): "mysql" | "postgres" | "sqlserver" {
+  if (dbType === "postgres" || dbType === "gaussdb" || dbType === "kwdb" || dbType === "opengauss") return "postgres";
+  if (dbType === "sqlserver") return "sqlserver";
+  return "mysql";
+}
+
+function isGbase8sProfile(driverProfile?: string): boolean {
+  return driverProfile === "gbase8s";
+}
diff --git a/apps/desktop/src/lib/database/mysqlConnectionOptions.ts b/apps/desktop/src/lib/database/mysqlConnectionOptions.ts
new file mode 100644
index 0000000..e9fae9b
--- /dev/null
+++ b/apps/desktop/src/lib/database/mysqlConnectionOptions.ts
@@ -0,0 +1,31 @@
+const MYSQL_CLEAR_TEXT_PARAM_ALIASES = new Set(["allowcleartextpasswords", "enable_cleartext_plugin"]);
+const MYSQL_CLEAR_TEXT_PARAM = "enable_cleartext_plugin";
+
+function normalizeKey(key: string): string {
+  return key.trim().toLowerCase();
+}
+
+function isTruthyUrlParam(value: string): boolean {
+  return ["true", "1", "yes", "on"].includes(value.trim().toLowerCase());
+}
+
+function isMysqlCleartextPasswordParam(key: string): boolean {
+  return MYSQL_CLEAR_TEXT_PARAM_ALIASES.has(normalizeKey(key));
+}
+
+export function mysqlCleartextPasswordAuthEnabled(params: string | undefined): boolean {
+  const parsed = new URLSearchParams((params || "").trim().replace(/^\?/, ""));
+  for (const [key, value] of parsed.entries()) {
+    if (isMysqlCleartextPasswordParam(key) && isTruthyUrlParam(value)) return true;
+  }
+  return false;
+}
+
+export function setMysqlCleartextPasswordAuthEnabled(params: string | undefined, enabled: boolean): string {
+  const parsed = new URLSearchParams((params || "").trim().replace(/^\?/, ""));
+  for (const key of [...parsed.keys()]) {
+    if (isMysqlCleartextPasswordParam(key)) parsed.delete(key);
+  }
+  if (enabled) parsed.set(MYSQL_CLEAR_TEXT_PARAM, "true");
+  return parsed.toString();
+}
diff --git a/apps/desktop/src/lib/database/oceanbaseConnectionMode.ts b/apps/desktop/src/lib/database/oceanbaseConnectionMode.ts
new file mode 100644
index 0000000..4b59665
--- /dev/null
+++ b/apps/desktop/src/lib/database/oceanbaseConnectionMode.ts
@@ -0,0 +1,26 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+
+export type OceanbaseSubMode = "mysql" | "oracle";
+
+export function oceanbaseSubModeFromConfig(config: Pick<ConnectionConfig, "db_type" | "driver_profile">): OceanbaseSubMode {
+  return config.db_type === "oceanbase-oracle" || config.driver_profile === "oceanbase-oracle" ? "oracle" : "mysql";
+}
+
+export function oceanbaseModeConnectionPatch(mode: OceanbaseSubMode): {
+  db_type: DatabaseType;
+  driver_profile: string;
+  driver_label: string;
+} {
+  if (mode === "oracle") {
+    return {
+      db_type: "oceanbase-oracle",
+      driver_profile: "oceanbase-oracle",
+      driver_label: "OceanBase Oracle Mode",
+    };
+  }
+  return {
+    db_type: "mysql",
+    driver_profile: "oceanbase",
+    driver_label: "OceanBase",
+  };
+}
diff --git a/apps/desktop/src/lib/database/prestoSqlBuiltinDriver.ts b/apps/desktop/src/lib/database/prestoSqlBuiltinDriver.ts
new file mode 100644
index 0000000..cbaa168
--- /dev/null
+++ b/apps/desktop/src/lib/database/prestoSqlBuiltinDriver.ts
@@ -0,0 +1,31 @@
+import type { AgentDriverInfo } from "@/lib/backend/api";
+import type { JdbcMavenBundleInfo } from "@/types/database";
+
+export const PRESTOSQL_DRIVER_DB_TYPE = "prestosql";
+export const PRESTOSQL_JDBC_DRIVER_VERSION = "350";
+export const PRESTOSQL_JDBC_DRIVER_COORDINATE = `io.prestosql:presto-jdbc:${PRESTOSQL_JDBC_DRIVER_VERSION}`;
+export const PRESTOSQL_JDBC_DRIVER_REPOSITORY = "https://repo.maven.apache.org/maven2/";
+
+export function prestoSqlMavenBundle(bundles: JdbcMavenBundleInfo[]): JdbcMavenBundleInfo | undefined {
+  return bundles.find((bundle) => bundle.coordinate === PRESTOSQL_JDBC_DRIVER_COORDINATE);
+}
+
+export function prestoSqlBuiltinDriverPaths(bundles: JdbcMavenBundleInfo[]): string[] {
+  return (prestoSqlMavenBundle(bundles)?.artifacts ?? []).map((artifact) => artifact.path).filter(Boolean);
+}
+
+export function prestoSqlBuiltinDriverRow(bundles: JdbcMavenBundleInfo[]): AgentDriverInfo {
+  const installedBundle = prestoSqlMavenBundle(bundles);
+  return {
+    db_type: PRESTOSQL_DRIVER_DB_TYPE,
+    label: "PrestoSQL",
+    version: PRESTOSQL_JDBC_DRIVER_VERSION,
+    size: installedBundle ? installedBundle.artifacts.reduce((total, artifact) => total + Number(artifact.size || 0), 0) : 0,
+    installed: Boolean(installedBundle),
+    installed_version: installedBundle ? PRESTOSQL_JDBC_DRIVER_VERSION : null,
+    update_available: false,
+    requires_java_runtime: true,
+    jre: "21",
+    jre_installed: true,
+  };
+}
diff --git a/apps/desktop/src/lib/database/productionExecutionGuard.ts b/apps/desktop/src/lib/database/productionExecutionGuard.ts
new file mode 100644
index 0000000..06fa905
--- /dev/null
+++ b/apps/desktop/src/lib/database/productionExecutionGuard.ts
@@ -0,0 +1,28 @@
+import { useProductionSafetyStore } from "@/stores/productionSafetyStore";
+import { assessProductionSql } from "@/lib/database/productionSafety";
+import type { ConnectionConfig } from "@/types/database";
+
+export interface ProductionSqlExecutionGuardOptions<T> {
+  connection?: ConnectionConfig;
+  database?: string | null;
+  sql: string;
+  source?: string;
+  execute: () => Promise<T>;
+}
+
+export async function executeWithProductionSqlGuard<T>(options: ProductionSqlExecutionGuardOptions<T>): Promise<T | undefined> {
+  const assessment = assessProductionSql(options.sql, options.connection, options.database);
+  if (assessment.active && assessment.isMutation) {
+    // Centralize production write confirmation so secondary tool surfaces cannot
+    // bypass the same explicit review step used by the SQL editor.
+    const confirmed = await useProductionSafetyStore().requestConfirmation({
+      sql: options.sql,
+      connectionName: options.connection?.name,
+      database: options.database ?? undefined,
+      productionDatabases: assessment.databases,
+      source: options.source,
+    });
+    if (!confirmed) return undefined;
+  }
+  return options.execute();
+}
diff --git a/apps/desktop/src/lib/database/productionSafety.ts b/apps/desktop/src/lib/database/productionSafety.ts
new file mode 100644
index 0000000..603a6b5
--- /dev/null
+++ b/apps/desktop/src/lib/database/productionSafety.ts
@@ -0,0 +1,347 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { classifySqlRisk, isSqlRiskMutation } from "@/lib/sql/sqlRisk";
+
+export type ProductionContextReason = "connection" | "database" | "sql_target";
+
+export interface ProductionContext {
+  active: boolean;
+  reason?: ProductionContextReason;
+  databases: string[];
+}
+
+export interface ProductionSqlAssessment extends ProductionContext {
+  isMutation: boolean;
+}
+
+const IDENTIFIER_PATTERN = String.raw`[A-Za-z0-9_@$#-]*[A-Za-z_@$#][A-Za-z0-9_@$#-]*`;
+const TARGET_NAME_PATTERN = String.raw`${IDENTIFIER_PATTERN}(?:\s*\.\s*(?:\*|${IDENTIFIER_PATTERN})){0,2}`;
+const QUALIFIED_NAME_PATTERN = String.raw`${IDENTIFIER_PATTERN}\s*\.\s*(?:\*|${IDENTIFIER_PATTERN})(?:\s*\.\s*(?:\*|${IDENTIFIER_PATTERN}))?`;
+const USE_RE = new RegExp(String.raw`^\s*USE\s+(${IDENTIFIER_PATTERN})`, "i");
+const DML_TARGET_RE = new RegExp(String.raw`\b(?:FROM|JOIN|UPDATE|INTO|REFERENCES)\s+(${TARGET_NAME_PATTERN})`, "gi");
+const DDL_OBJECT_TARGET_RE = new RegExp(String.raw`\b(?:CREATE|ALTER|DROP)\s+(?:OR\s+REPLACE\s+)?(?:TABLE|VIEW|MATERIALIZED\s+VIEW|INDEX|SEQUENCE|FUNCTION|PROCEDURE|ROUTINE|TRIGGER|EVENT|TYPE|SYNONYM)\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?(?:ONLY\s+)?(${TARGET_NAME_PATTERN})`, "gi");
+const INDEX_ON_TARGET_RE = new RegExp(String.raw`\b(?:CREATE|ALTER|DROP)\s+(?:UNIQUE\s+)?INDEX\b[\s\S]*?\bON\s+(${TARGET_NAME_PATTERN})`, "gi");
+const DATABASE_TARGET_RE = new RegExp(String.raw`\b(?:CREATE|ALTER|DROP)\s+(DATABASE|SCHEMA|CATALOG)\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?(${IDENTIFIER_PATTERN})`, "gi");
+const COPY_TARGET_RE = new RegExp(String.raw`^\s*COPY\s+(${TARGET_NAME_PATTERN})\s+FROM\b`, "i");
+const TRUNCATE_TARGET_RE = new RegExp(String.raw`\bTRUNCATE\s+(?:TABLE\s+)?(${TARGET_NAME_PATTERN})`, "gi");
+const RENAME_TABLE_TARGET_RE = new RegExp(String.raw`\bRENAME\s+TABLE\s+(${TARGET_NAME_PATTERN})\s+TO\s+(${TARGET_NAME_PATTERN})`, "gi");
+const MAINTENANCE_TABLE_TARGET_RE = new RegExp(String.raw`\b(?:ANALYZE|OPTIMIZE|REPAIR|CHECK)\s+(?:NO_WRITE_TO_BINLOG\s+|LOCAL\s+)?TABLE\s+(${TARGET_NAME_PATTERN})`, "gi");
+const COMMENT_TARGET_RE = new RegExp(String.raw`\bCOMMENT\s+ON\s+(?:TABLE|VIEW|COLUMN|INDEX|SEQUENCE|FUNCTION|PROCEDURE|TYPE)\s+(${TARGET_NAME_PATTERN})`, "gi");
+const ROUTINE_CALL_TARGET_RE = new RegExp(String.raw`\b(?:CALL|EXEC|EXECUTE)\s+(${QUALIFIED_NAME_PATTERN})`, "gi");
+const PRIVILEGE_TARGET_RE = new RegExp(String.raw`\b(?:GRANT|REVOKE|DENY)\b[\s\S]*?\bON\s+(?:(?:TABLE|SEQUENCE|FUNCTION|PROCEDURE|ROUTINE|OBJECT)\s+|OBJECT\s*::\s*)?(${QUALIFIED_NAME_PATTERN})`, "gi");
+const PRIVILEGE_DATABASE_TARGET_RE = new RegExp(String.raw`\b(?:GRANT|REVOKE|DENY)\b[\s\S]*?\bON\s+(?:DATABASE|CATALOG)(?:::|\s+)\s*(${IDENTIFIER_PATTERN})`, "gi");
+const GLOBAL_PRIVILEGE_TARGET_RE = /\b(?:GRANT|REVOKE|DENY)\b[\s\S]*?\bON\s+\*\s*\.\s*\*/i;
+const GLOBAL_DDL_TARGET_RE = /^\s*(?:CREATE|ALTER|DROP)\s+(?:USER|ROLE|LOGIN|SERVER|TABLESPACE|RESOURCE|PROFILE|ACCOUNT)\b/i;
+const MULTI_TARGET_MUTATION_RE = /^\s*(?:DROP\s+(?:TEMPORARY\s+)?TABLE\b[\s\S]*,|RENAME\s+TABLE\b[\s\S]*,)/i;
+const THREE_PART_DATABASE_QUALIFIER_TYPES = new Set<DatabaseType>(["sqlserver", "snowflake", "trino", "prestosql", "databricks", "bigquery"]);
+const TRANSACTION_KEYWORDS = new Set(["begin", "start", "commit", "rollback", "abort", "savepoint", "release"]);
+const SCHEMA_FIRST_QUALIFIER_TYPES = new Set<DatabaseType>([
+  "postgres",
+  "redshift",
+  "gaussdb",
+  "kwdb",
+  "opengauss",
+  "kingbase",
+  "highgo",
+  "vastbase",
+  "yashandb",
+  "oracle",
+  "oceanbase-oracle",
+  "dameng",
+  "firebird",
+  "exasol",
+  "teradata",
+  "vertica",
+  "db2",
+  "informix",
+  "h2",
+  "iris",
+  "xugu",
+  "oscar",
+  "gbase",
+  "saphana",
+  "sqlserver",
+  "snowflake",
+  "trino",
+  "prestosql",
+  "databricks",
+  "bigquery",
+]);
+
+interface ReferencedDatabaseAssessment {
+  databases: string[];
+  uncertain: boolean;
+}
+
+interface SqlTargetSafetyText {
+  text: string;
+  quotedIdentifiers: Map<string, string>;
+}
+
+/**
+ * Normalize database identifiers for safety matching while retaining the
+ * original display value separately. Safety comparisons intentionally ignore
+ * identifier quoting and case so a quoted MySQL production database cannot
+ * bypass its marker.
+ */
+export function normalizeProductionDatabase(value: string | undefined | null): string {
+  return String(value ?? "")
+    .trim()
+    .replace(/^[`"[]|[`"\]]$/g, "")
+    .toLowerCase();
+}
+
+export function productionDatabases(connection: ConnectionConfig | undefined): string[] {
+  if (!connection?.production_databases?.length) return [];
+  return [...new Set(connection.production_databases.map(normalizeProductionDatabase).filter(Boolean))];
+}
+
+export function productionContextForDatabase(connection: ConnectionConfig | undefined, database: string | undefined | null): ProductionContext {
+  if (!connection) return { active: false, databases: [] };
+  if (connection.is_production) return { active: true, reason: "connection", databases: [] };
+
+  const normalizedDatabase = normalizeProductionDatabase(database);
+  const marked = productionDatabases(connection);
+  if (normalizedDatabase && marked.includes(normalizedDatabase)) {
+    return { active: true, reason: "database", databases: [String(database)] };
+  }
+  return { active: false, databases: [] };
+}
+
+export function isProductionMutation(sql: string): boolean {
+  return isSqlRiskMutation(classifySqlRisk(sql).risk);
+}
+
+/**
+ * Resolves production scope for the SQL about to run. The active database is
+ * authoritative for ordinary statements; MySQL-style USE and qualified names
+ * additionally protect production databases referenced from another context.
+ */
+export function assessProductionSql(sql: string, connection: ConnectionConfig | undefined, activeDatabase: string | undefined | null): ProductionSqlAssessment {
+  const activeContext = productionContextForDatabase(connection, activeDatabase);
+  const targetText = sqlTargetSafetyText(sql);
+  const statements = splitTargetStatements(targetText.text);
+  const risk = classifySqlRisk(sql, { dialect: connection?.db_type });
+  const isMutation = isSqlRiskMutation(risk.risk);
+  if (!isMutation || !connection) return { ...activeContext, isMutation };
+  if (connection.is_production) return { active: true, reason: "connection", databases: [], isMutation };
+  if (activeContext.active) return { ...activeContext, isMutation };
+
+  const marked = productionDatabases(connection);
+  if (!marked.length) return { active: false, databases: [], isMutation };
+
+  const targets = referencedDatabases(statements, connection.db_type, activeDatabase, targetText.quotedIdentifiers);
+  const matched = targets.databases.filter((database) => marked.includes(normalizeProductionDatabase(database)));
+  if (matched.length) return { active: true, reason: "sql_target", databases: matched, isMutation };
+  if (targets.uncertain) return { active: true, reason: "sql_target", databases: marked, isMutation };
+  return { active: false, databases: [], isMutation };
+}
+
+function referencedDatabases(statements: string[], dbType: DatabaseType, activeDatabase: string | undefined | null, quotedIdentifiers: Map<string, string>): ReferencedDatabaseAssessment {
+  const databases = new Set<string>();
+  let uncertain = false;
+  let useDatabase = "";
+  const normalizedActiveDatabase = normalizeProductionDatabase(activeDatabase);
+
+  for (const statement of statements) {
+    const statementDatabases = new Set<string>();
+    const statementAssessment = classifySqlRisk(statement, { dialect: dbType });
+    const statementIsMutation = isSqlRiskMutation(statementAssessment.risk);
+    const useMatch = statement.match(USE_RE);
+    if (useMatch?.[1]) {
+      useDatabase = normalizeTargetDatabase(useMatch[1], quotedIdentifiers);
+      continue;
+    }
+    if (!statementIsMutation) continue;
+    const currentDatabase = useDatabase || normalizedActiveDatabase;
+
+    collectQualifiedTargetDatabases(statement, dbType, quotedIdentifiers, currentDatabase, statementDatabases, DML_TARGET_RE, DDL_OBJECT_TARGET_RE, INDEX_ON_TARGET_RE, TRUNCATE_TARGET_RE, MAINTENANCE_TABLE_TARGET_RE, COMMENT_TARGET_RE, ROUTINE_CALL_TARGET_RE, PRIVILEGE_TARGET_RE);
+    collectQualifiedTargetDatabaseGroups(statement, dbType, quotedIdentifiers, currentDatabase, statementDatabases, RENAME_TABLE_TARGET_RE, [1, 2]);
+    for (const match of statement.matchAll(DATABASE_TARGET_RE)) {
+      const database = databaseTargetKindMeansDatabase(match[1], dbType) ? normalizeTargetDatabase(match[2], quotedIdentifiers) : "";
+      if (database) statementDatabases.add(database);
+    }
+    for (const match of statement.matchAll(PRIVILEGE_DATABASE_TARGET_RE)) {
+      const database = normalizeTargetDatabase(match[1], quotedIdentifiers);
+      if (database) statementDatabases.add(database);
+    }
+    const copyTarget = statement.match(COPY_TARGET_RE);
+    if (copyTarget?.[1]) {
+      const database = databaseFromQualifiedName(copyTarget[1], dbType, quotedIdentifiers, currentDatabase);
+      if (database) statementDatabases.add(database);
+    }
+    for (const database of statementDatabases) databases.add(database);
+    // The target regexes intentionally extract one object at a time. Until all
+    // list forms are parsed, never let a resolved first target disable fallback.
+    uncertain = uncertain || GLOBAL_PRIVILEGE_TARGET_RE.test(statement) || MULTI_TARGET_MUTATION_RE.test(statement) || isAmbiguousProductionTargetStatement(statement, statementAssessment, statementDatabases.size > 0);
+  }
+  return { databases: [...databases], uncertain };
+}
+
+function collectQualifiedTargetDatabases(statement: string, dbType: DatabaseType, quotedIdentifiers: Map<string, string>, currentDatabase: string, databases: Set<string>, ...patterns: RegExp[]): void {
+  for (const pattern of patterns) {
+    collectQualifiedTargetDatabaseGroups(statement, dbType, quotedIdentifiers, currentDatabase, databases, pattern, [1]);
+  }
+}
+
+function collectQualifiedTargetDatabaseGroups(statement: string, dbType: DatabaseType, quotedIdentifiers: Map<string, string>, currentDatabase: string, databases: Set<string>, pattern: RegExp, captureIndexes: number[]): void {
+  pattern.lastIndex = 0;
+  for (const match of statement.matchAll(pattern)) {
+    for (const captureIndex of captureIndexes) {
+      const database = databaseFromQualifiedName(match[captureIndex], dbType, quotedIdentifiers, currentDatabase);
+      if (database) databases.add(database);
+    }
+  }
+}
+
+function databaseFromQualifiedName(qualifiedName: string | undefined, dbType: DatabaseType, quotedIdentifiers: Map<string, string>, currentDatabase: string): string {
+  const parts = String(qualifiedName ?? "")
+    .split(".")
+    .map((part) => normalizeTargetDatabase(part, quotedIdentifiers))
+    .filter(Boolean);
+  if (parts.length < 2) return currentDatabase;
+  if (qualifiedFirstPartIsDatabase(dbType, parts.length)) return parts[0] ?? "";
+  return currentDatabase;
+}
+
+function normalizeTargetDatabase(value: string | undefined, quotedIdentifiers: Map<string, string>): string {
+  const normalized = normalizeProductionDatabase(value);
+  const quoted = quotedIdentifiers.get(normalized);
+  return quoted === undefined ? normalized : normalizeProductionDatabase(quoted);
+}
+
+function qualifiedFirstPartIsDatabase(dbType: DatabaseType, partCount: number): boolean {
+  if (partCount >= 3 && THREE_PART_DATABASE_QUALIFIER_TYPES.has(dbType)) return true;
+  if (SCHEMA_FIRST_QUALIFIER_TYPES.has(dbType)) return false;
+  return partCount >= 2;
+}
+
+function databaseTargetKindMeansDatabase(kind: string | undefined, dbType: DatabaseType): boolean {
+  const normalizedKind = String(kind ?? "").toLowerCase();
+  if (normalizedKind === "database" || normalizedKind === "catalog") return true;
+  if (normalizedKind !== "schema") return false;
+  return !SCHEMA_FIRST_QUALIFIER_TYPES.has(dbType);
+}
+
+function isAmbiguousProductionTargetStatement(statement: string, assessment: ReturnType<typeof classifySqlRisk>, hasResolvedTarget: boolean): boolean {
+  if (!isSqlRiskMutation(assessment.risk)) return false;
+  if (assessment.risk === "transaction") return false;
+  const firstKeyword = assessment.firstKeyword;
+  if (firstKeyword && TRANSACTION_KEYWORDS.has(firstKeyword)) return false;
+  return GLOBAL_DDL_TARGET_RE.test(statement) || !hasResolvedTarget;
+}
+
+function splitTargetStatements(sql: string): string[] {
+  return sql
+    .split(";")
+    .map((statement) => statement.trim())
+    .filter(Boolean);
+}
+
+function sqlTargetSafetyText(sql: string, quotedIdentifiers = new Map<string, string>()): SqlTargetSafetyText {
+  let output = "";
+  let index = 0;
+
+  while (index < sql.length) {
+    const char = sql[index] ?? "";
+    const next = sql[index + 1] ?? "";
+
+    if (char === "-" && next === "-") {
+      index += 2;
+      while (index < sql.length && sql[index] !== "\n" && sql[index] !== "\r") index += 1;
+      output += " ";
+      continue;
+    }
+
+    if (char === "#") {
+      index += 1;
+      while (index < sql.length && sql[index] !== "\n" && sql[index] !== "\r") index += 1;
+      output += " ";
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      const close = sql.indexOf("*/", index + 2);
+      if (close < 0) return { text: output, quotedIdentifiers };
+      const executablePrefixLength = mysqlExecutableCommentPrefixLength(sql, index);
+      if (executablePrefixLength > 0) {
+        const bodyStart = skipExecutableCommentVersion(sql, index + executablePrefixLength);
+        output += ` ${sqlTargetSafetyText(sql.slice(bodyStart, close), quotedIdentifiers).text} `;
+      } else {
+        output += " ";
+      }
+      index = close + 2;
+      continue;
+    }
+
+    const dollarQuote = dollarQuoteTagAt(sql, index);
+    if (dollarQuote) {
+      const close = sql.indexOf(dollarQuote, index + dollarQuote.length);
+      index = close < 0 ? sql.length : close + dollarQuote.length;
+      output += " ";
+      continue;
+    }
+
+    if (char === "'") {
+      index = readQuotedEnd(sql, index, "'", "'");
+      output += " ";
+      continue;
+    }
+
+    if (char === '"' || char === "`" || char === "[") {
+      const close = char === "[" ? "]" : char;
+      const end = readQuotedEnd(sql, index, char, close);
+      const identifier = unquoteIdentifier(sql.slice(index, end), char, close).replace(/[;]/g, " ");
+      const token = `__dbxq${quotedIdentifiers.size}__`;
+      quotedIdentifiers.set(token.toLowerCase(), identifier);
+      output += ` ${token} `;
+      index = end;
+      continue;
+    }
+
+    output += char;
+    index += 1;
+  }
+
+  return { text: output, quotedIdentifiers };
+}
+
+function mysqlExecutableCommentPrefixLength(sql: string, index: number): number {
+  if (sql[index] !== "/" || sql[index + 1] !== "*") return 0;
+  if (sql[index + 2] === "!") return 3;
+  if (sql[index + 2] === "M" && sql[index + 3] === "!") return 4;
+  return 0;
+}
+
+function skipExecutableCommentVersion(sql: string, index: number): number {
+  let cursor = index;
+  while (cursor < sql.length && /[0-9\s]/.test(sql[cursor] ?? "")) cursor += 1;
+  return cursor;
+}
+
+function dollarQuoteTagAt(sql: string, index: number): string | undefined {
+  return sql.slice(index).match(/^\$[A-Za-z_][A-Za-z0-9_]*\$|^\$\$/)?.[0];
+}
+
+function readQuotedEnd(sql: string, start: number, open: string, close: string): number {
+  let index = start + open.length;
+  while (index < sql.length) {
+    if (sql[index] === "\\" && (open === "'" || open === '"')) {
+      index += 2;
+      continue;
+    }
+    if (sql.startsWith(close, index)) {
+      if (sql.startsWith(close + close, index)) {
+        index += close.length * 2;
+        continue;
+      }
+      return index + close.length;
+    }
+    index += 1;
+  }
+  return sql.length;
+}
+
+function unquoteIdentifier(value: string, open: string, close: string): string {
+  if (!value.startsWith(open) || !value.endsWith(close)) return value;
+  return value.slice(open.length, value.length - close.length).replaceAll(close + close, close);
+}
diff --git a/apps/desktop/src/lib/database/sqlServerLinkedServers.ts b/apps/desktop/src/lib/database/sqlServerLinkedServers.ts
new file mode 100644
index 0000000..8e97a61
--- /dev/null
+++ b/apps/desktop/src/lib/database/sqlServerLinkedServers.ts
@@ -0,0 +1,41 @@
+import type { TreeNode } from "@/types/database";
+
+const SQLSERVER_LINKED_SCHEMA_PREFIX = "__dbx_sqlserver_linked__:";
+
+export interface SqlServerLinkedSchemaRef {
+  server: string;
+  catalog: string;
+  schema: string;
+}
+
+export function encodeSqlServerLinkedSchema(ref: SqlServerLinkedSchemaRef): string {
+  return `${SQLSERVER_LINKED_SCHEMA_PREFIX}${[ref.server, ref.catalog, ref.schema].map(encodeURIComponent).join("|")}`;
+}
+
+export function parseSqlServerLinkedSchema(schema: string | undefined): SqlServerLinkedSchemaRef | null {
+  if (!schema?.startsWith(SQLSERVER_LINKED_SCHEMA_PREFIX)) return null;
+  const parts = schema.slice(SQLSERVER_LINKED_SCHEMA_PREFIX.length).split("|").map(decodeURIComponent);
+  if (parts.length !== 3 || parts.some((part) => !part.trim())) return null;
+  return { server: parts[0], catalog: parts[1], schema: parts[2] };
+}
+
+export function isSqlServerLinkedNode(node: Pick<TreeNode, "linkedServer" | "linkedCatalog" | "linkedSchema" | "schema">): boolean {
+  return !!node.linkedServer || !!node.linkedCatalog || !!node.linkedSchema || !!parseSqlServerLinkedSchema(node.schema);
+}
+
+export function sqlServerLinkedTableSchema(node: Pick<TreeNode, "linkedServer" | "linkedCatalog" | "linkedSchema">): string | undefined {
+  if (!node.linkedServer || !node.linkedCatalog || !node.linkedSchema) return undefined;
+  return encodeSqlServerLinkedSchema({
+    server: node.linkedServer,
+    catalog: node.linkedCatalog,
+    schema: node.linkedSchema,
+  });
+}
+
+export function quoteSqlServerIdentifier(name: string): string {
+  return `[${name.replace(/\]/g, "]]")}]`;
+}
+
+export function sqlServerLinkedTableName(ref: SqlServerLinkedSchemaRef, tableName: string): string {
+  return [ref.server, ref.catalog, ref.schema, tableName].map(quoteSqlServerIdentifier).join(".");
+}
diff --git a/apps/desktop/src/lib/database/sqlServerTree.ts b/apps/desktop/src/lib/database/sqlServerTree.ts
new file mode 100644
index 0000000..69f7b2b
--- /dev/null
+++ b/apps/desktop/src/lib/database/sqlServerTree.ts
@@ -0,0 +1,18 @@
+import type { TreeNode } from "@/types/database";
+import { sortSidebarNames } from "@/lib/database/databaseTree";
+
+export const SQLSERVER_DEFAULT_SCHEMA = "dbo";
+
+export function buildSqlServerDatabaseTreeNodes(connectionId: string, database: string, schemas: string[]): TreeNode[] {
+  const databaseNodeId = `${connectionId}:${database}`;
+  return sortSidebarNames(schemas).map((schema) => ({
+    id: `${databaseNodeId}:${schema}`,
+    label: schema,
+    type: "schema" as const,
+    connectionId,
+    database,
+    schema,
+    isExpanded: false,
+    children: [],
+  }));
+}
diff --git a/apps/desktop/src/lib/database/visibleDatabases.ts b/apps/desktop/src/lib/database/visibleDatabases.ts
new file mode 100644
index 0000000..26e48cd
--- /dev/null
+++ b/apps/desktop/src/lib/database/visibleDatabases.ts
@@ -0,0 +1,140 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+
+const SYSTEM_DATABASE_RULES: Partial<Record<DatabaseType, ReadonlySet<string>>> = {
+  mysql: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
+  doris: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
+  starrocks: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
+  manticoresearch: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
+  goldendb: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
+  gbase: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
+  postgres: new Set(["template0", "template1"]),
+  gaussdb: new Set(["template0", "template1"]),
+  kwdb: new Set(["template0", "template1"]),
+  opengauss: new Set(["template0", "template1"]),
+  questdb: new Set(["template0", "template1"]),
+  kingbase: new Set(["template0", "template1"]),
+  highgo: new Set(["template0", "template1"]),
+  vastbase: new Set(["template0", "template1"]),
+  redshift: new Set(["template0", "template1"]),
+  clickhouse: new Set(["information_schema", "system"]),
+  tdengine: new Set(["information_schema", "performance_schema"]),
+  sqlserver: new Set(["master", "model", "msdb", "tempdb"]),
+  mongodb: new Set(["admin", "config", "local"]),
+  oracle: new Set([
+    "anonymous",
+    "appqossys",
+    "audsys",
+    "ctxsys",
+    "dbsnmp",
+    "dip",
+    "dvf",
+    "dvsys",
+    "exfsys",
+    "flows_files",
+    "gsmadmin_internal",
+    "mddata",
+    "mdsys",
+    "mgmt_view",
+    "olapsys",
+    "orddata",
+    "ordplugins",
+    "ordsys",
+    "outln",
+    "owbsys",
+    "remote_scheduler_agent",
+    "si_informtn_schema",
+    "sys",
+    "sysback",
+    "sysdg",
+    "syskm",
+    "system",
+    "wmsys",
+    "xdb",
+    "xs$null",
+  ]),
+  dameng: new Set(["ctisys", "dba", "sys", "sysauditor", "syssso", "system"]),
+  saphana: new Set(["_sys_afl", "_sys_bi", "_sys_bic", "_sys_repo", "_sys_statistics", "sys"]),
+  cassandra: new Set(["system", "system_auth", "system_distributed", "system_schema", "system_traces", "system_views", "system_virtual_schema"]),
+  neo4j: new Set(["system"]),
+  snowflake: new Set(["snowflake", "snowflake_sample_data"]),
+};
+
+export function visibleDatabaseFilterIsEnabled(visibleDatabases: string[] | undefined): boolean {
+  return Array.isArray(visibleDatabases);
+}
+
+export function canSaveVisibleDatabaseSelection(selectedNames: string[]): boolean {
+  return selectedNames.length > 0;
+}
+
+export function filterVisibleDatabaseNames(databaseNames: string[], visibleDatabases: string[] | undefined): string[] {
+  if (!visibleDatabaseFilterIsEnabled(visibleDatabases)) return databaseNames;
+  const visible = new Set(visibleDatabases);
+  return databaseNames.filter((name) => visible.has(name));
+}
+
+export function normalizeVisibleDatabaseSelection(selectedNames: string[], databaseNames: string[]): string[] {
+  const available = new Set(databaseNames);
+  const seen = new Set<string>();
+  return selectedNames.filter((name) => {
+    if (!available.has(name) || seen.has(name)) return false;
+    seen.add(name);
+    return true;
+  });
+}
+
+export function isSystemDatabaseName(databaseType: DatabaseType | undefined, databaseName: string): boolean {
+  if (!databaseType) return false;
+  return SYSTEM_DATABASE_RULES[databaseType]?.has(databaseName.toLowerCase()) ?? false;
+}
+
+export function filterDatabaseNamesForConnection(databaseNames: string[], connection: Pick<ConnectionConfig, "db_type" | "driver_profile" | "visible_databases"> | undefined): string[] {
+  const visibleDatabases = connection?.visible_databases;
+  if (visibleDatabaseFilterIsEnabled(visibleDatabases)) {
+    return filterVisibleDatabaseNames(databaseNames, visibleDatabases);
+  }
+  return filterDatabaseNamesForVisiblePicker(databaseNames, connection);
+}
+
+export function filterDatabaseNamesForVisiblePicker(databaseNames: string[], connection: Pick<ConnectionConfig, "db_type" | "driver_profile"> | undefined): string[] {
+  if (connection?.db_type === "gbase" && connection.driver_profile === "gbase8s") {
+    return databaseNames;
+  }
+  return databaseNames.filter((name) => !isSystemDatabaseName(connection?.db_type, name));
+}
+
+export function connectionUsesVisibleSchemaFilter(connection: Pick<ConnectionConfig, "db_type"> | undefined): boolean {
+  return connection?.db_type === "oracle" || connection?.db_type === "dameng" || connection?.db_type === "oceanbase-oracle";
+}
+
+export function visibleSchemaFilterIsEnabled(visibleSchemas: Record<string, string[]> | undefined, database: string): boolean {
+  return Array.isArray(visibleSchemas?.[database]);
+}
+
+export function filterSchemaNamesForConnection(schemaNames: string[], connection: Pick<ConnectionConfig, "db_type" | "visible_schemas" | "visible_databases"> | undefined, database: string): string[] {
+  const visibleSchemas = connection?.visible_schemas;
+  if (!visibleSchemaFilterIsEnabled(visibleSchemas, database)) {
+    if (connectionUsesVisibleSchemaFilter(connection) && visibleDatabaseFilterIsEnabled(connection?.visible_databases)) {
+      return filterVisibleDatabaseNames(schemaNames, connection?.visible_databases);
+    }
+    return schemaNames.filter((name) => !isSystemDatabaseName(connection?.db_type, name));
+  }
+  const visible = new Set(visibleSchemas![database]);
+  return schemaNames.filter((name) => visible.has(name));
+}
+
+export function normalizeVisibleSchemaSelection(selectedNames: string[], schemaNames: string[]): string[] {
+  const available = new Set(schemaNames);
+  const seen = new Set<string>();
+  return selectedNames.filter((name) => {
+    if (!available.has(name) || seen.has(name)) return false;
+    seen.add(name);
+    return true;
+  });
+}
+
+const DRAFT_VISIBLE_SCHEMAS_PREFIX = "__visible_schema_draft_";
+
+export function buildDraftVisibleSchemasConnectionId(seed: string): string {
+  return `${DRAFT_VISIBLE_SCHEMAS_PREFIX}${seed}`;
+}
diff --git a/apps/desktop/src/lib/diagram/diagramZoom.ts b/apps/desktop/src/lib/diagram/diagramZoom.ts
new file mode 100644
index 0000000..dd76d3c
--- /dev/null
+++ b/apps/desktop/src/lib/diagram/diagramZoom.ts
@@ -0,0 +1,16 @@
+export const DIAGRAM_MIN_ZOOM = 0.6;
+export const DIAGRAM_MAX_ZOOM = 1.5;
+const WHEEL_ZOOM_SENSITIVITY = 0.003;
+
+export function clampDiagramZoom(value: number): number {
+  const clamped = Math.min(DIAGRAM_MAX_ZOOM, Math.max(DIAGRAM_MIN_ZOOM, value));
+  return Number(clamped.toFixed(2));
+}
+
+export function zoomFromWheelDelta(currentZoom: number, deltaY: number): number {
+  return clampDiagramZoom(currentZoom * Math.exp(-deltaY * WHEEL_ZOOM_SENSITIVITY));
+}
+
+export function zoomFromGestureScale(startZoom: number, scale: number): number {
+  return clampDiagramZoom(startZoom * scale);
+}
diff --git a/apps/desktop/src/lib/diagram/engineeringDiagram.ts b/apps/desktop/src/lib/diagram/engineeringDiagram.ts
new file mode 100644
index 0000000..3c31e1a
--- /dev/null
+++ b/apps/desktop/src/lib/diagram/engineeringDiagram.ts
@@ -0,0 +1,354 @@
+import type { DiagramPosition, DiagramRelationship, DiagramTable } from "@/lib/diagram/erDiagram";
+
+export const ENGINEERING_ENTITY_WIDTH = 184;
+export const ENGINEERING_ENTITY_HEIGHT = 58;
+export const ENGINEERING_ATTRIBUTE_HEIGHT = 34;
+export const ENGINEERING_RELATIONSHIP_WIDTH = 104;
+export const ENGINEERING_RELATIONSHIP_HEIGHT = 58;
+
+const ATTRIBUTE_MIN_WIDTH = 96;
+const ATTRIBUTE_MAX_WIDTH = 156;
+const ATTRIBUTE_GAP_X = 18;
+const ATTRIBUTE_GAP_Y = 12;
+const ATTRIBUTE_ENTITY_GAP = 38;
+const HORIZONTAL_ATTRIBUTE_COLUMNS = 4;
+const ENGINEERING_CLUSTER_GAP_X = 120;
+const ENGINEERING_CLUSTER_GAP_Y = 100;
+const CANVAS_PADDING = 80;
+
+type AttributeSide = "top" | "right" | "bottom" | "left";
+type EngineeringColumn = DiagramTable["columns"][number];
+
+interface AttributeDraft {
+  column: EngineeringColumn;
+  width: number;
+}
+
+interface BlockSize {
+  width: number;
+  height: number;
+}
+
+interface EngineeringCluster {
+  tableName: string;
+  width: number;
+  height: number;
+  entityX: number;
+  entityY: number;
+  attributes: EngineeringAttributeNode[];
+}
+
+export interface EngineeringEntityNode {
+  id: string;
+  name: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface EngineeringAttributeNode {
+  id: string;
+  tableName: string;
+  columnName: string;
+  label: string;
+  dataType: string;
+  primaryKey: boolean;
+  foreignKey: boolean;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface EngineeringRelationshipNode {
+  id: string;
+  label: string;
+  sourceTable: string;
+  targetTable: string;
+  sourceCardinality: "1" | "N";
+  targetCardinality: "1" | "N";
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export interface EngineeringDiagram {
+  entities: EngineeringEntityNode[];
+  attributes: EngineeringAttributeNode[];
+  relationships: EngineeringRelationshipNode[];
+  canvas: {
+    width: number;
+    height: number;
+  };
+}
+
+function attributeWidth(label: string): number {
+  return Math.min(ATTRIBUTE_MAX_WIDTH, Math.max(ATTRIBUTE_MIN_WIDTH, label.length * 10 + 30));
+}
+
+function relationshipLabel(relationship: DiagramRelationship): string {
+  if (relationship.name && relationship.name.length <= 16) return relationship.name;
+  return relationship.sourceColumn || "rel";
+}
+
+function entityCenter(entity: EngineeringEntityNode): DiagramPosition {
+  return {
+    x: entity.x + entity.width / 2,
+    y: entity.y + entity.height / 2,
+  };
+}
+
+function chunkAttributes(items: AttributeDraft[], size: number): AttributeDraft[][] {
+  const rows: AttributeDraft[][] = [];
+  for (let index = 0; index < items.length; index += size) {
+    rows.push(items.slice(index, index + size));
+  }
+  return rows;
+}
+
+function rowWidth(items: AttributeDraft[]): number {
+  if (items.length === 0) return 0;
+  return items.reduce((width, item) => width + item.width, 0) + (items.length - 1) * ATTRIBUTE_GAP_X;
+}
+
+function horizontalBlockSize(items: AttributeDraft[]): BlockSize {
+  if (items.length === 0) return { width: 0, height: 0 };
+  const rows = chunkAttributes(items, HORIZONTAL_ATTRIBUTE_COLUMNS);
+  return {
+    width: Math.max(...rows.map(rowWidth)),
+    height: rows.length * ENGINEERING_ATTRIBUTE_HEIGHT + (rows.length - 1) * ATTRIBUTE_GAP_Y,
+  };
+}
+
+function verticalBlockSize(items: AttributeDraft[]): BlockSize {
+  if (items.length === 0) return { width: 0, height: 0 };
+  return {
+    width: Math.max(...items.map((item) => item.width)),
+    height: items.length * ENGINEERING_ATTRIBUTE_HEIGHT + (items.length - 1) * ATTRIBUTE_GAP_Y,
+  };
+}
+
+function sideGap(block: BlockSize): number {
+  return block.width > 0 && block.height > 0 ? ATTRIBUTE_ENTITY_GAP : 0;
+}
+
+function distributeAttributes(table: DiagramTable): Record<AttributeSide, AttributeDraft[]> {
+  const sides: AttributeSide[] = ["top", "right", "bottom", "left"];
+  const groups: Record<AttributeSide, AttributeDraft[]> = {
+    top: [],
+    right: [],
+    bottom: [],
+    left: [],
+  };
+
+  table.columns.forEach((column, index) => {
+    groups[sides[index % sides.length]].push({
+      column,
+      width: attributeWidth(column.name),
+    });
+  });
+
+  return groups;
+}
+
+function localAttributeNode(table: DiagramTable, item: AttributeDraft, x: number, y: number): EngineeringAttributeNode {
+  return {
+    id: `${table.name}:${item.column.name}`,
+    tableName: table.name,
+    columnName: item.column.name,
+    label: item.column.name,
+    dataType: item.column.data_type,
+    primaryKey: item.column.is_primary_key,
+    foreignKey: table.foreignKeys.some((fk) => fk.column === item.column.name),
+    x,
+    y,
+    width: item.width,
+    height: ENGINEERING_ATTRIBUTE_HEIGHT,
+  };
+}
+
+function buildEngineeringCluster(table: DiagramTable): EngineeringCluster {
+  const groups = distributeAttributes(table);
+  const topSize = horizontalBlockSize(groups.top);
+  const rightSize = verticalBlockSize(groups.right);
+  const bottomSize = horizontalBlockSize(groups.bottom);
+  const leftSize = verticalBlockSize(groups.left);
+
+  const leftGap = sideGap(leftSize);
+  const rightGap = sideGap(rightSize);
+  const topGap = sideGap(topSize);
+  const bottomGap = sideGap(bottomSize);
+  const centerWidth = Math.max(ENGINEERING_ENTITY_WIDTH, topSize.width, bottomSize.width);
+  const centerHeight = Math.max(ENGINEERING_ENTITY_HEIGHT, leftSize.height, rightSize.height);
+  const centerX = leftSize.width + leftGap;
+  const centerY = topSize.height + topGap;
+  const entityX = centerX + centerWidth / 2 - ENGINEERING_ENTITY_WIDTH / 2;
+  const entityY = centerY + centerHeight / 2 - ENGINEERING_ENTITY_HEIGHT / 2;
+  const attributes: EngineeringAttributeNode[] = [];
+
+  chunkAttributes(groups.top, HORIZONTAL_ATTRIBUTE_COLUMNS).forEach((row, rowIndex) => {
+    let x = centerX + (centerWidth - rowWidth(row)) / 2;
+    const y = rowIndex * (ENGINEERING_ATTRIBUTE_HEIGHT + ATTRIBUTE_GAP_Y);
+    row.forEach((item) => {
+      attributes.push(localAttributeNode(table, item, x, y));
+      x += item.width + ATTRIBUTE_GAP_X;
+    });
+  });
+
+  groups.right.forEach((item, index) => {
+    attributes.push(localAttributeNode(table, item, centerX + centerWidth + rightGap + (rightSize.width - item.width) / 2, centerY + (centerHeight - rightSize.height) / 2 + index * (ENGINEERING_ATTRIBUTE_HEIGHT + ATTRIBUTE_GAP_Y)));
+  });
+
+  chunkAttributes(groups.bottom, HORIZONTAL_ATTRIBUTE_COLUMNS).forEach((row, rowIndex) => {
+    let x = centerX + (centerWidth - rowWidth(row)) / 2;
+    const y = centerY + centerHeight + bottomGap + rowIndex * (ENGINEERING_ATTRIBUTE_HEIGHT + ATTRIBUTE_GAP_Y);
+    row.forEach((item) => {
+      attributes.push(localAttributeNode(table, item, x, y));
+      x += item.width + ATTRIBUTE_GAP_X;
+    });
+  });
+
+  groups.left.forEach((item, index) => {
+    attributes.push(localAttributeNode(table, item, (leftSize.width - item.width) / 2, centerY + (centerHeight - leftSize.height) / 2 + index * (ENGINEERING_ATTRIBUTE_HEIGHT + ATTRIBUTE_GAP_Y)));
+  });
+
+  return {
+    tableName: table.name,
+    width: leftSize.width + leftGap + centerWidth + rightGap + rightSize.width,
+    height: topSize.height + topGap + centerHeight + bottomGap + bottomSize.height,
+    entityX,
+    entityY,
+    attributes,
+  };
+}
+
+function positionKey(value: number): string {
+  return value.toFixed(3);
+}
+
+function orderedTableRows(tables: DiagramTable[], positions: Record<string, DiagramPosition>): DiagramTable[][] {
+  const columnsPerRow = Math.max(1, Math.min(4, Math.ceil(Math.sqrt(Math.max(tables.length, 1)))));
+  const ordered = tables.map((table, fallbackIndex) => ({
+    table,
+    position: positions[table.name] ?? {
+      x: fallbackIndex % columnsPerRow,
+      y: Math.floor(fallbackIndex / columnsPerRow),
+    },
+  }));
+  const ys = [...new Set(ordered.map((item) => positionKey(item.position.y)))].sort((left, right) => Number(left) - Number(right));
+
+  return ys.map((y) =>
+    ordered
+      .filter((item) => positionKey(item.position.y) === y)
+      .sort((left, right) => left.position.x - right.position.x)
+      .map((item) => item.table),
+  );
+}
+
+function normalizeDiagram(diagram: Omit<EngineeringDiagram, "canvas">): EngineeringDiagram {
+  const rects = [...diagram.entities, ...diagram.attributes, ...diagram.relationships];
+  if (rects.length === 0) {
+    return {
+      ...diagram,
+      canvas: {
+        width: CANVAS_PADDING * 2,
+        height: CANVAS_PADDING * 2,
+      },
+    };
+  }
+
+  const minX = Math.min(...rects.map((rect) => rect.x));
+  const minY = Math.min(...rects.map((rect) => rect.y));
+  const maxX = Math.max(...rects.map((rect) => rect.x + rect.width));
+  const maxY = Math.max(...rects.map((rect) => rect.y + rect.height));
+  const dx = CANVAS_PADDING - minX;
+  const dy = CANVAS_PADDING - minY;
+
+  const shift = <T extends { x: number; y: number }>(node: T): T => ({
+    ...node,
+    x: node.x + dx,
+    y: node.y + dy,
+  });
+
+  return {
+    entities: diagram.entities.map(shift),
+    attributes: diagram.attributes.map(shift),
+    relationships: diagram.relationships.map(shift),
+    canvas: {
+      width: maxX + dx + CANVAS_PADDING,
+      height: maxY + dy + CANVAS_PADDING,
+    },
+  };
+}
+
+export function buildEngineeringDiagram(tables: DiagramTable[], relationships: DiagramRelationship[], positions: Record<string, DiagramPosition>): EngineeringDiagram {
+  const clusters = new Map(tables.map((table) => [table.name, buildEngineeringCluster(table)]));
+  const rows = orderedTableRows(tables, positions);
+  const entities: EngineeringEntityNode[] = [];
+  const attributes: EngineeringAttributeNode[] = [];
+  let nextRowY = 0;
+
+  rows.forEach((row) => {
+    const rowClusters = row.map((table) => clusters.get(table.name)).filter((cluster): cluster is EngineeringCluster => cluster !== undefined);
+    const rowHeight = Math.max(...rowClusters.map((cluster) => cluster.height), ENGINEERING_ENTITY_HEIGHT);
+    let nextX = 0;
+
+    rowClusters.forEach((cluster) => {
+      const originX = nextX;
+      const originY = nextRowY + (rowHeight - cluster.height) / 2;
+
+      entities.push({
+        id: cluster.tableName,
+        name: cluster.tableName,
+        x: originX + cluster.entityX,
+        y: originY + cluster.entityY,
+        width: ENGINEERING_ENTITY_WIDTH,
+        height: ENGINEERING_ENTITY_HEIGHT,
+      });
+      attributes.push(
+        ...cluster.attributes.map((attribute) => ({
+          ...attribute,
+          x: originX + attribute.x,
+          y: originY + attribute.y,
+        })),
+      );
+
+      nextX += cluster.width + ENGINEERING_CLUSTER_GAP_X;
+    });
+
+    nextRowY += rowHeight + ENGINEERING_CLUSTER_GAP_Y;
+  });
+  const entityMap = new Map(entities.map((entity) => [entity.name, entity]));
+  const orderedEntities = tables.map((table) => entityMap.get(table.name)).filter((entity): entity is EngineeringEntityNode => entity !== undefined);
+
+  const relationshipNodes: EngineeringRelationshipNode[] = relationships.flatMap((relationship) => {
+    const source = entityMap.get(relationship.sourceTable);
+    const target = entityMap.get(relationship.targetTable);
+    if (!source || !target) return [];
+
+    const sourceCenter = entityCenter(source);
+    const targetCenter = entityCenter(target);
+    return [
+      {
+        id: relationship.id,
+        label: relationshipLabel(relationship),
+        sourceTable: relationship.sourceTable,
+        targetTable: relationship.targetTable,
+        sourceCardinality: relationship.sourceCardinality ?? "N",
+        targetCardinality: relationship.targetCardinality ?? "1",
+        x: (sourceCenter.x + targetCenter.x) / 2 - ENGINEERING_RELATIONSHIP_WIDTH / 2,
+        y: (sourceCenter.y + targetCenter.y) / 2 - ENGINEERING_RELATIONSHIP_HEIGHT / 2,
+        width: ENGINEERING_RELATIONSHIP_WIDTH,
+        height: ENGINEERING_RELATIONSHIP_HEIGHT,
+      },
+    ];
+  });
+
+  return normalizeDiagram({
+    entities: orderedEntities,
+    attributes,
+    relationships: relationshipNodes,
+  });
+}
diff --git a/apps/desktop/src/lib/diagram/erDiagram.ts b/apps/desktop/src/lib/diagram/erDiagram.ts
new file mode 100644
index 0000000..c0ccceb
--- /dev/null
+++ b/apps/desktop/src/lib/diagram/erDiagram.ts
@@ -0,0 +1,192 @@
+import type { ColumnInfo, ForeignKeyInfo } from "@/types/database";
+
+export interface DiagramTable {
+  name: string;
+  columns: ColumnInfo[];
+  foreignKeys: ForeignKeyInfo[];
+}
+
+export interface DiagramRelationship {
+  id: string;
+  name: string;
+  kind: "foreign-key" | "custom";
+  sourceTable: string;
+  sourceColumn: string;
+  targetTable: string;
+  targetColumn: string;
+  sourceCardinality: "1" | "N";
+  targetCardinality: "1" | "N";
+}
+
+export interface CustomDiagramRelationship {
+  id: string;
+  name: string;
+  sourceTable: string;
+  sourceColumn: string;
+  targetTable: string;
+  targetColumn: string;
+  sourceCardinality: "1" | "N";
+  targetCardinality: "1" | "N";
+}
+
+export interface DiagramJoinSqlOptions {
+  joinType?: "INNER JOIN" | "LEFT JOIN";
+  rootTable?: string;
+}
+
+export interface DiagramPosition {
+  x: number;
+  y: number;
+}
+
+export interface DiagramLayoutOptions {
+  columnsPerRow?: number;
+  cardWidth?: number;
+  rowHeight?: number;
+  gapX?: number;
+  gapY?: number;
+  margin?: number;
+}
+
+function relationshipId(sourceTable: string, fk: ForeignKeyInfo): string {
+  return [sourceTable, fk.name || "foreign_key", fk.column, fk.ref_table, fk.ref_column].join(":");
+}
+
+function columnExists(table: DiagramTable | undefined, columnName: string): boolean {
+  return !!table?.columns.some((column) => column.name === columnName);
+}
+
+function customRelationshipId(relationship: Omit<CustomDiagramRelationship, "id">): string {
+  return ["custom", relationship.sourceTable, relationship.sourceColumn, relationship.targetTable, relationship.targetColumn, relationship.sourceCardinality, relationship.targetCardinality].join(":");
+}
+
+export function normalizeCustomDiagramRelationship(input: Omit<CustomDiagramRelationship, "id"> & { id?: string }): CustomDiagramRelationship {
+  return {
+    ...input,
+    id: input.id || customRelationshipId(input),
+  };
+}
+
+export function buildDiagramRelationships(tables: DiagramTable[], customRelationships: CustomDiagramRelationship[] = []): DiagramRelationship[] {
+  const visibleTableNames = new Set(tables.map((table) => table.name));
+  const tableMap = new Map(tables.map((table) => [table.name, table]));
+
+  const foreignKeyRelationships = tables.flatMap((table) =>
+    table.foreignKeys
+      .filter((fk) => visibleTableNames.has(fk.ref_table))
+      .map((fk) => ({
+        id: relationshipId(table.name, fk),
+        name: fk.name,
+        kind: "foreign-key" as const,
+        sourceTable: table.name,
+        sourceColumn: fk.column,
+        targetTable: fk.ref_table,
+        targetColumn: fk.ref_column,
+        sourceCardinality: "N" as const,
+        targetCardinality: "1" as const,
+      })),
+  );
+
+  const custom = customRelationships
+    .filter((relationship) => visibleTableNames.has(relationship.sourceTable) && visibleTableNames.has(relationship.targetTable))
+    .filter((relationship) => columnExists(tableMap.get(relationship.sourceTable), relationship.sourceColumn) && columnExists(tableMap.get(relationship.targetTable), relationship.targetColumn))
+    .map((relationship) => ({
+      ...relationship,
+      kind: "custom" as const,
+    }));
+
+  return [...foreignKeyRelationships, ...custom];
+}
+
+export function filterDiagramTables(tables: DiagramTable[], query: string): DiagramTable[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return tables;
+
+  return tables.filter((table) => {
+    if (table.name.toLowerCase().includes(q)) return true;
+    if (table.columns.some((column) => column.name.toLowerCase().includes(q) || column.data_type.toLowerCase().includes(q))) return true;
+    return table.foreignKeys.some((fk) => fk.name.toLowerCase().includes(q) || fk.column.toLowerCase().includes(q) || fk.ref_table.toLowerCase().includes(q) || fk.ref_column.toLowerCase().includes(q));
+  });
+}
+
+export function layoutDiagramTables(tables: Pick<DiagramTable, "name" | "columns">[], options: DiagramLayoutOptions = {}): Record<string, DiagramPosition> {
+  const columnsPerRow = Math.max(1, options.columnsPerRow ?? Math.ceil(Math.sqrt(Math.max(tables.length, 1))));
+  const cardWidth = options.cardWidth ?? 260;
+  const rowHeight = options.rowHeight ?? 220;
+  const gapX = options.gapX ?? 56;
+  const gapY = options.gapY ?? 40;
+  const margin = options.margin ?? 40;
+
+  return Object.fromEntries(
+    tables.map((table, index) => {
+      const col = index % columnsPerRow;
+      const row = Math.floor(index / columnsPerRow);
+      return [
+        table.name,
+        {
+          x: margin + col * (cardWidth + gapX),
+          y: margin + row * (rowHeight + gapY),
+        },
+      ];
+    }),
+  );
+}
+
+function quoteIdentifier(value: string): string {
+  if (/^[A-Za-z_][A-Za-z0-9_$]*$/.test(value)) return value;
+  return `"${value.replace(/"/g, '""')}"`;
+}
+
+function relationshipCondition(relationship: DiagramRelationship, aliases: Map<string, string>): string {
+  const sourceAlias = aliases.get(relationship.sourceTable) ?? quoteIdentifier(relationship.sourceTable);
+  const targetAlias = aliases.get(relationship.targetTable) ?? quoteIdentifier(relationship.targetTable);
+  return `${sourceAlias}.${quoteIdentifier(relationship.sourceColumn)} = ${targetAlias}.${quoteIdentifier(relationship.targetColumn)}`;
+}
+
+function nextJoinableRelationship(relationships: DiagramRelationship[], joinedTables: Set<string>, consumedRelationships: Set<string>): DiagramRelationship | undefined {
+  return relationships.find((relationship) => {
+    if (consumedRelationships.has(relationship.id)) return false;
+    const sourceJoined = joinedTables.has(relationship.sourceTable);
+    const targetJoined = joinedTables.has(relationship.targetTable);
+    return sourceJoined !== targetJoined || (!sourceJoined && !targetJoined && joinedTables.size === 0);
+  });
+}
+
+export function buildDiagramJoinSql(relationships: DiagramRelationship[], options: DiagramJoinSqlOptions = {}): string {
+  const joinableRelationships = relationships.filter((relationship) => relationship.sourceTable && relationship.sourceColumn && relationship.targetTable && relationship.targetColumn);
+  if (joinableRelationships.length === 0) return "";
+
+  const joinType = options.joinType ?? "LEFT JOIN";
+  const rootTable = options.rootTable && joinableRelationships.some((relationship) => relationship.sourceTable === options.rootTable || relationship.targetTable === options.rootTable) ? options.rootTable : joinableRelationships[0].sourceTable;
+  const joinedTables = new Set<string>([rootTable]);
+  const aliases = new Map<string, string>([[rootTable, "t1"]]);
+  const consumedRelationships = new Set<string>();
+  const joinLines: string[] = [];
+
+  while (consumedRelationships.size < joinableRelationships.length) {
+    const relationship = nextJoinableRelationship(joinableRelationships, joinedTables, consumedRelationships);
+    if (!relationship) break;
+
+    const sourceJoined = joinedTables.has(relationship.sourceTable);
+    const targetJoined = joinedTables.has(relationship.targetTable);
+    const tableToJoin = sourceJoined && !targetJoined ? relationship.targetTable : relationship.sourceTable;
+    if (!joinedTables.has(tableToJoin)) {
+      const previousJoinedTables = new Set(joinedTables);
+      aliases.set(tableToJoin, `t${aliases.size + 1}`);
+      joinedTables.add(tableToJoin);
+      const joinConditions = joinableRelationships.filter((item) => !consumedRelationships.has(item.id) && ((item.sourceTable === tableToJoin && previousJoinedTables.has(item.targetTable)) || (item.targetTable === tableToJoin && previousJoinedTables.has(item.sourceTable))));
+      joinConditions.forEach((item) => consumedRelationships.add(item.id));
+      joinLines.push(`${joinType} ${quoteIdentifier(tableToJoin)} ${aliases.get(tableToJoin)} ON ${joinConditions.map((item) => relationshipCondition(item, aliases)).join(" AND ")}`);
+    }
+    consumedRelationships.add(relationship.id);
+  }
+
+  const whereRelationships = joinableRelationships.filter((relationship) => !consumedRelationships.has(relationship.id) && joinedTables.has(relationship.sourceTable) && joinedTables.has(relationship.targetTable));
+  whereRelationships.forEach((relationship) => consumedRelationships.add(relationship.id));
+  const whereLine = whereRelationships.length > 0 ? `WHERE ${whereRelationships.map((relationship) => relationshipCondition(relationship, aliases)).join(" AND ")}` : "";
+  const selectList = [...joinedTables].map((table) => `  ${aliases.get(table)}.*`).join(",\n");
+  const disconnectedRelationships = joinableRelationships.filter((relationship) => !consumedRelationships.has(relationship.id));
+  const disconnectedNotes = disconnectedRelationships.map((relationship) => `-- Disconnected relationship skipped: ${relationship.sourceTable}.${relationship.sourceColumn} = ${relationship.targetTable}.${relationship.targetColumn}`);
+
+  return [`SELECT`, selectList, `FROM ${quoteIdentifier(rootTable)} ${aliases.get(rootTable)}`, ...joinLines, whereLine, ...disconnectedNotes].filter(Boolean).join("\n");
+}
diff --git a/apps/desktop/src/lib/diagram/explainPlan.ts b/apps/desktop/src/lib/diagram/explainPlan.ts
new file mode 100644
index 0000000..136c48f
--- /dev/null
+++ b/apps/desktop/src/lib/diagram/explainPlan.ts
@@ -0,0 +1,678 @@
+import type { DatabaseType, QueryResult } from "@/types/database";
+import * as api from "@/lib/backend/api";
+import { supportsDatabaseFeature } from "@/lib/database/databaseDriverManifest";
+
+export interface ExplainPlanNode {
+  id: string;
+  title: string;
+  nodeType: string;
+  relation?: string;
+  index?: string;
+  cost?: string;
+  rows?: string;
+  width?: string;
+  details: string[];
+  children: ExplainPlanNode[];
+}
+
+export interface ParsedExplainPlan {
+  databaseType: "mysql" | "postgres" | "dameng" | "questdb" | "oracle";
+  raw: unknown;
+  nodes: ExplainPlanNode[];
+}
+
+export type BuildExplainSqlResult = { ok: true; sql: string } | { ok: false; reason: "unsupported" | "empty" | "unsafe" };
+
+const SUPPORTED_EXPLAIN_TYPES = new Set<DatabaseType>(["mysql", "postgres", "dameng", "questdb", "oracle"]);
+export function supportsExplainPlan(databaseType?: DatabaseType): databaseType is "mysql" | "postgres" | "dameng" | "questdb" | "oracle" {
+  return !!databaseType && supportsDatabaseFeature(databaseType, "sqlExplain") && SUPPORTED_EXPLAIN_TYPES.has(databaseType);
+}
+
+export function buildExplainSql(databaseType: DatabaseType | undefined, sql: string, format: "json" | "standard" = "json"): Promise<BuildExplainSqlResult> {
+  return api.buildExplainSql({ databaseType, sql, format }) as Promise<BuildExplainSqlResult>;
+}
+
+export function parseExplainResult(databaseType: "mysql" | "postgres" | "dameng" | "questdb", result: QueryResult): ParsedExplainPlan {
+  if (databaseType === "dameng") {
+    return parseDamengExplain(result);
+  } else if (databaseType === "questdb") {
+    return parseQuestdbExplain(result);
+  }
+  const raw = parseExplainCell(result.rows[0]?.[0]);
+  const nodes = databaseType === "postgres" ? parsePostgresExplain(raw) : parseMysqlExplain(raw);
+  return { databaseType, raw, nodes };
+}
+
+/**
+ * Parse DM's getExplainInfo() text output.
+ * Format (flat list with indentation):
+ *   1   #NSET2: [cost, rows, width]
+ *   2     #PIPE2: [cost, rows, width]
+ *   3       #PRJT2: [cost, rows, width]; props...
+ *   ...
+ *   Statistics
+ *       logical reads
+ *       exec time(ms)
+ *
+ * For autotrace, rows include ->actual: [cost, estRows->actualRows, width]
+ */
+export function parseDamengExplainText(planText: string): ParsedExplainPlan {
+  const lines = planText.split("\n");
+  const operatorLines: { indent: number; line: string; raw: string }[] = [];
+  const stats: Record<string, string> = {};
+  let inStats = false;
+
+  for (const rawLine of lines) {
+    const trimmed = rawLine.trim();
+    if (!trimmed) continue;
+
+    // Check for Statistics section
+    if (trimmed.toLowerCase() === "statistics") {
+      inStats = true;
+      continue;
+    }
+    if (inStats) {
+      const m = trimmed.match(/^(\d+)\s+(.+)$/);
+      if (m) {
+        stats[m[2].trim()] = m[1];
+      }
+      continue;
+    }
+
+    // Try to parse operator line: <line_number><spaces>#OPERATOR...
+    const opMatch = trimmed.match(/^\d+(\s+)#/);
+    if (opMatch) {
+      // indent = number of spaces between line number and #
+      const indent = opMatch[1].length;
+      operatorLines.push({ indent, line: trimmed.substring(trimmed.indexOf("#")), raw: rawLine });
+    }
+  }
+
+  // Build tree from flat operator lines using indent spacing
+  // First line's indent = baseline (depth 0), each +2 spaces = +1 depth
+  const baseIndent = operatorLines.length > 0 ? operatorLines[0].indent : 0;
+  const rootNodes: ExplainPlanNode[] = [];
+  const parentStack: ExplainPlanNode[] = [];
+
+  for (const { indent, line } of operatorLines) {
+    const nodeInfo = parseDamengPlanLine(line);
+    if (!nodeInfo) continue;
+
+    const depth = Math.max(0, Math.round((indent - baseIndent) / 2));
+    while (parentStack.length > depth) parentStack.pop();
+
+    const childIndex = parentStack.length === 0 ? rootNodes.length + 1 : parentStack[parentStack.length - 1].children.length + 1;
+    const id = parentStack.length === 0 ? String(childIndex) : `${parentStack[parentStack.length - 1].id}.${childIndex}`;
+
+    const details: string[] = [];
+    if (nodeInfo.props) details.push(nodeInfo.props);
+    if (nodeInfo.actualRows) details.push(`Actual Rows: ${nodeInfo.actualRows}`);
+    if (nodeInfo.memUsed) details.push(`Memory: ${nodeInfo.memUsed}`);
+    if (nodeInfo.diskUsed) details.push(`Disk: ${nodeInfo.diskUsed}`);
+
+    const node: ExplainPlanNode = {
+      id,
+      title: nodeInfo.relation ? `${nodeInfo.nodeType} on ${nodeInfo.relation}` : nodeInfo.nodeType,
+      nodeType: nodeInfo.operation,
+      cost: nodeInfo.cost || undefined,
+      rows: nodeInfo.rows || undefined,
+      relation: nodeInfo.relation || undefined,
+      details,
+      children: [],
+    };
+
+    if (parentStack.length === 0) {
+      rootNodes.push(node);
+    } else {
+      parentStack[parentStack.length - 1].children.push(node);
+    }
+    parentStack.push(node);
+  }
+
+  // Add stats summary to root node
+  if (Object.keys(stats).length > 0) {
+    const statsDetail = Object.entries(stats)
+      .map(([k, v]) => `${k}: ${v}`)
+      .join(", ");
+    if (rootNodes.length > 0 && !rootNodes[0].details.some((d) => d.startsWith("Statistics:"))) {
+      rootNodes[0].details.push(`Statistics: ${statsDetail}`);
+    }
+  }
+
+  return { databaseType: "dameng", raw: planText, nodes: rootNodes };
+}
+
+export function parseOracleExplainText(planText: string): ParsedExplainPlan {
+  const lines = planText.split("\n");
+  const headerIndex = lines.findIndex((line) => /^\|\s*Id\s*\|/i.test(line) && line.includes("Operation"));
+  if (headerIndex < 0) return { databaseType: "oracle", raw: planText, nodes: [] };
+
+  const headers = splitOraclePlanColumns(lines[headerIndex]).map((header) => header.trim().toLowerCase().replace(/\s+/g, " "));
+  const columnIndex = (name: string) => headers.findIndex((header) => header === name || header.startsWith(`${name} `));
+  const idIndex = columnIndex("id");
+  const operationIndex = columnIndex("operation");
+  const nameIndex = columnIndex("name");
+  const rowsIndex = columnIndex("rows");
+  const bytesIndex = columnIndex("bytes");
+  const costIndex = columnIndex("cost");
+  const timeIndex = columnIndex("time");
+  const predicates = oraclePredicateDetails(lines);
+
+  const parsedRows: Array<{
+    id: string;
+    depth: number;
+    operation: string;
+    name?: string;
+    rows?: string;
+    cost?: string;
+    bytes?: string;
+    time?: string;
+  }> = [];
+  let baseIndent: number | undefined;
+
+  for (const line of lines.slice(headerIndex + 1)) {
+    if (!line.startsWith("|")) continue;
+    const cells = splitOraclePlanColumns(line);
+    const idMatch = cells[idIndex]?.match(/\d+/);
+    const operationCell = cells[operationIndex];
+    if (!idMatch || operationCell == null) continue;
+
+    const indent = operationCell.search(/\S/);
+    if (indent < 0) continue;
+    baseIndent ??= indent;
+    parsedRows.push({
+      id: idMatch[0],
+      depth: Math.max(0, indent - baseIndent),
+      operation: operationCell.trim(),
+      name: cellValue(cells, nameIndex),
+      rows: cellValue(cells, rowsIndex),
+      cost: cellValue(cells, costIndex),
+      bytes: cellValue(cells, bytesIndex),
+      time: cellValue(cells, timeIndex),
+    });
+  }
+
+  const roots: ExplainPlanNode[] = [];
+  const parents: ExplainPlanNode[] = [];
+  for (const row of parsedRows) {
+    const isIndex = /\bINDEX\b/i.test(row.operation) && !/\bTABLE ACCESS\b/i.test(row.operation);
+    const relation = row.name && !isIndex ? row.name : undefined;
+    const index = row.name && isIndex ? row.name : undefined;
+    const details = [row.bytes ? `Bytes: ${row.bytes}` : "", row.time ? `Time: ${row.time}` : "", ...(predicates.get(row.id) ?? []).map((predicate) => `Predicate: ${predicate}`)].filter(Boolean);
+    const node: ExplainPlanNode = {
+      id: row.id,
+      title: row.name ? `${row.operation} on ${row.name}` : row.operation,
+      nodeType: row.operation,
+      relation,
+      index,
+      cost: row.cost,
+      rows: row.rows,
+      details,
+      children: [],
+    };
+
+    while (parents.length > row.depth) parents.pop();
+    const parent = row.depth > 0 ? parents[row.depth - 1] : undefined;
+    if (parent) parent.children.push(node);
+    else roots.push(node);
+    parents[row.depth] = node;
+    parents.length = row.depth + 1;
+  }
+
+  return { databaseType: "oracle", raw: planText, nodes: roots };
+}
+
+function splitOraclePlanColumns(line: string): string[] {
+  const columns = line.split("|");
+  return columns.length >= 3 ? columns.slice(1, -1) : [];
+}
+
+function cellValue(cells: string[], index: number): string | undefined {
+  if (index < 0) return undefined;
+  const value = cells[index]?.trim();
+  return value || undefined;
+}
+
+function oraclePredicateDetails(lines: string[]): Map<string, string[]> {
+  const predicates = new Map<string, string[]>();
+  const start = lines.findIndex((line) => line.trim().toLowerCase().startsWith("predicate information"));
+  if (start < 0) return predicates;
+
+  let currentId = "";
+  for (const rawLine of lines.slice(start + 1)) {
+    const line = rawLine.trim();
+    if (!line || /^-+$/.test(line)) continue;
+    if (/^note\b/i.test(line)) break;
+    const entry = line.match(/^(\d+)\s*-\s*(.+)$/);
+    if (entry) {
+      currentId = entry[1];
+      predicates.set(currentId, [entry[2]]);
+    } else if (currentId) {
+      const details = predicates.get(currentId);
+      if (!details?.length) continue;
+      if (/^(?:access|filter|storage)\s*\(/i.test(line)) {
+        details.push(line);
+      } else {
+        details[details.length - 1] = `${details[details.length - 1]} ${line}`;
+      }
+    }
+  }
+  return predicates;
+}
+
+interface DamengOpInfo {
+  operation: string;
+  nodeType: string;
+  cost?: string;
+  rows?: string;
+  actualRows?: string;
+  width?: string;
+  relation?: string;
+  props?: string;
+  memUsed?: string;
+  diskUsed?: string;
+}
+
+/**
+ * Parse a single DM operator line:
+ *   #NSET2: [cost, rows, width]; props
+ *   #HASH2 INNER JOIN: [cost, rows->actual, width]; KEY_NUM(1), MEM_USED(20352KB)
+ *   #CSCN2: [cost, rows, width]; INDEX_NAME; btr_scan(1)
+ */
+function parseDamengPlanLine(line: string): DamengOpInfo | null {
+  // Remove leading #
+  const content = line.replace(/^#+/, "").trim();
+
+  // Split at first colon
+  const colonIdx = content.indexOf(":");
+  if (colonIdx < 0) return null;
+
+  const operator = content.substring(0, colonIdx).trim();
+  const rest = content.substring(colonIdx + 1).trim();
+
+  // Extract [cost, rows, width] or [cost, estRows->actualRows, width]
+  let costPart = "";
+  let afterBracket = rest;
+  const bracketMatch = rest.match(/^\[([^\]]+)\]/);
+  if (bracketMatch) {
+    costPart = bracketMatch[1];
+    afterBracket = rest.substring(bracketMatch[0].length).trim();
+  }
+
+  // Parse cost part
+  let cost: string | undefined;
+  let rows: string | undefined;
+  let actualRows: string | undefined;
+  let width: string | undefined;
+
+  if (costPart) {
+    const parts = costPart.split(",").map((s) => s.trim());
+    if (parts.length >= 1) cost = parts[0];
+    if (parts.length >= 2) {
+      const rowPart = parts[1];
+      const arrowIdx = rowPart.indexOf("->");
+      if (arrowIdx >= 0) {
+        rows = rowPart.substring(0, arrowIdx).trim();
+        actualRows = rowPart.substring(arrowIdx + 2).trim();
+      } else {
+        rows = rowPart;
+      }
+    }
+    if (parts.length >= 3) width = parts[2];
+  }
+
+  // Extract props after semicolons
+  const semiParts = afterBracket
+    .split(";")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  let relation: string | undefined;
+  let memUsed: string | undefined;
+  let diskUsed: string | undefined;
+  const otherProps: string[] = [];
+
+  for (const part of semiParts) {
+    if (/^[A-Za-z_]\w*\(/.test(part) || part.includes("(")) {
+      otherProps.push(part);
+    } else if (part.toUpperCase().includes("MEM_USED")) {
+      const m = part.match(/MEM_USED\((\d+)(KB|MB)\)/i);
+      if (m) memUsed = `${m[1]}${m[2]}`;
+      otherProps.push(part);
+    } else if (part.toUpperCase().includes("DISK_USED")) {
+      const m = part.match(/DISK_USED\((\d+)(KB|MB)\)/i);
+      if (m) diskUsed = `${m[1]}${m[2]}`;
+      otherProps.push(part);
+    } else if (!relation && part.length > 0 && part.length < 100 && !part.includes(" ")) {
+      relation = part; // likely an index or table name
+    } else if (part.length > 0) {
+      otherProps.push(part);
+    }
+  }
+
+  return {
+    operation: operator,
+    nodeType: operator,
+    cost,
+    rows,
+    actualRows,
+    width,
+    relation,
+    props: otherProps.length > 0 ? otherProps.join("; ") : undefined,
+    memUsed,
+    diskUsed,
+  };
+}
+
+export function flattenExplainPlanNodes(nodes: ExplainPlanNode[]): ExplainPlanNode[] {
+  const rows: ExplainPlanNode[] = [];
+  function visit(node: ExplainPlanNode) {
+    rows.push(node);
+    node.children.forEach((child) => visit(child));
+  }
+  nodes.forEach((node) => visit(node));
+  return rows;
+}
+
+function parseExplainCell(value: unknown): unknown {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+// ── DM (达梦) tabular explain parser ──────────────────────────────────
+
+interface DamengExplainRow {
+  id: string;
+  operation: string;
+  options: string;
+  objectName: string;
+  objectType: string;
+  cost: string;
+  cardinality: string;
+  [key: string]: unknown;
+}
+
+/**
+ * DM's EXPLAIN returns a tabular result set.
+ * Columns: EXPLAIN_ID, ID, OPERATION, OPTIONS, OBJECT_NAME, OBJECT_TYPE,
+ *          COST, CARDINALITY, CPU_COST, IO_COST, etc.
+ * ID is hierarchical dot-notation (1, 2, 2.1, 2.2, 3).
+ */
+function parseDamengExplain(result: QueryResult): ParsedExplainPlan {
+  const colIndex = buildColumnIndex(result.columns);
+  const rows: DamengExplainRow[] = result.rows.map((row: unknown[]) => ({
+    id: String(row[colIndex.id] ?? ""),
+    operation: String(row[colIndex.operation] ?? ""),
+    options: String(row[colIndex.options] ?? ""),
+    objectName: String(row[colIndex.objectName] ?? ""),
+    objectType: String(row[colIndex.objectType] ?? ""),
+    cost: String(row[colIndex.cost] ?? ""),
+    cardinality: String(row[colIndex.cardinality] ?? ""),
+  }));
+
+  const nodes = buildDamengTree(rows);
+  return { databaseType: "dameng", raw: rows, nodes };
+}
+
+function buildColumnIndex(columns: string[]): Record<string, number> {
+  const lower = columns.map((c) => c.toLowerCase());
+  const idx = (name: string) => {
+    const i = lower.indexOf(name);
+    // fallback search for similar names
+    if (i >= 0) return i;
+    if (name === "id") return lower.findIndex((c) => c === "id" || c === "step" || c === "step_id");
+    if (name === "operation") return lower.findIndex((c) => c.includes("operation"));
+    if (name === "options") return lower.findIndex((c) => c === "options" || c === "option");
+    if (name === "objectName") return lower.findIndex((c) => c.includes("object_name"));
+    if (name === "objectType") return lower.findIndex((c) => c.includes("object_type"));
+    if (name === "cost") return lower.findIndex((c) => c === "cost" || c === "total_cost");
+    if (name === "cardinality") return lower.findIndex((c) => c === "cardinality" || c.includes("cardinality") || c === "rows");
+    return -1;
+  };
+  return {
+    id: idx("id"),
+    operation: idx("operation"),
+    options: idx("options"),
+    objectName: idx("objectName"),
+    objectType: idx("objectType"),
+    cost: idx("cost"),
+    cardinality: idx("cardinality"),
+  };
+}
+
+/**
+ * Build a tree from flat DM explain rows using dot-notation ID hierarchy.
+ * Root nodes have IDs like "1", "2", "3".
+ * Children have IDs like "1.1", "1.2", "2.1.1".
+ */
+function buildDamengTree(rows: DamengExplainRow[]): ExplainPlanNode[] {
+  const nodes: ExplainPlanNode[] = [];
+
+  // First pass: create all nodes
+  const nodeMap = new Map<string, ExplainPlanNode>();
+  for (const row of rows) {
+    const nodeType = [row.operation, row.options].filter(Boolean).join(" ");
+    const relation = row.objectName || undefined;
+    const index = row.objectType === "INDEX" ? row.objectName : undefined;
+
+    const details: string[] = [];
+    if (row.objectType && row.objectType !== "TABLE" && row.objectType !== "INDEX") {
+      details.push(`Object Type: ${row.objectType}`);
+    }
+    if (row.cardinality && row.cardinality !== "0") {
+      details.push(`Cardinality: ${row.cardinality}`);
+    }
+
+    const node: ExplainPlanNode = {
+      id: row.id,
+      title: relation ? `${nodeType} on ${relation}` : nodeType || "Plan",
+      nodeType: row.operation || "Plan",
+      relation,
+      index,
+      cost: row.cost || undefined,
+      rows: row.cardinality || undefined,
+      details,
+      children: [],
+    };
+    nodeMap.set(row.id, node);
+  }
+
+  // Second pass: build parent-child relationships based on dot notation
+  for (const row of rows) {
+    const node = nodeMap.get(row.id);
+    if (!node) continue;
+
+    const parts = row.id.split(".");
+    if (parts.length === 1) {
+      // Root-level node
+      nodes.push(node);
+    } else {
+      // Child node: find parent
+      const parentId = parts.slice(0, -1).join(".");
+      const parent = nodeMap.get(parentId);
+      if (parent) {
+        parent.children.push(node);
+      } else {
+        // Orphan — treat as root
+        nodes.push(node);
+      }
+    }
+  }
+
+  // Sort children by their last ID segment (numerically)
+  function sortChildren(nodes: ExplainPlanNode[]) {
+    for (const n of nodes) {
+      sortChildren(n.children);
+    }
+    nodes.sort((a, b) => {
+      const aLast = parseInt(a.id.split(".").pop() || "0", 10);
+      const bLast = parseInt(b.id.split(".").pop() || "0", 10);
+      return aLast - bLast;
+    });
+  }
+  sortChildren(nodes);
+
+  return nodes;
+}
+
+// ── PostgreSQL JSON explain parser ────────────────────────────────────
+
+function parsePostgresExplain(raw: unknown): ExplainPlanNode[] {
+  const plans = Array.isArray(raw) ? raw : [raw];
+  return plans
+    .map((item, index) => {
+      const root = objectValue(item);
+      if (!root) return null;
+      const plan = objectValue(root.Plan) || root;
+      return parsePostgresNode(plan, String(index));
+    })
+    .filter((node): node is ExplainPlanNode => !!node);
+}
+
+function parsePostgresNode(plan: Record<string, unknown> | null, id: string): ExplainPlanNode | null {
+  if (!plan) return null;
+  const nodeType = stringValue(plan["Node Type"]) || "Plan";
+  const relation = stringValue(plan["Relation Name"]);
+  const index = stringValue(plan["Index Name"]);
+  const startupCost = numberLike(plan["Startup Cost"]);
+  const totalCost = numberLike(plan["Total Cost"]);
+  const rows = numberLike(plan["Plan Rows"]);
+  const width = numberLike(plan["Plan Width"]);
+  const filter = stringValue(plan.Filter);
+  const joinType = stringValue(plan["Join Type"]);
+  const sortKey = arrayValue(plan["Sort Key"])?.map(String).join(", ");
+
+  const children =
+    arrayValue(plan.Plans)
+      ?.map((child, childIndex) => parsePostgresNode(objectValue(child), `${id}.${childIndex}`))
+      .filter((node): node is ExplainPlanNode => !!node) ?? [];
+
+  return {
+    id,
+    title: relation ? `${nodeType} on ${relation}` : nodeType,
+    nodeType,
+    relation,
+    index,
+    cost: [startupCost, totalCost].every(Boolean) ? `${startupCost}..${totalCost}` : totalCost,
+    rows,
+    width,
+    details: [joinType ? `Join: ${joinType}` : "", filter ? `Filter: ${filter}` : "", sortKey ? `Sort: ${sortKey}` : ""].filter(Boolean),
+    children,
+  };
+}
+
+// ── MySQL JSON explain parser ─────────────────────────────────────────
+
+function parseMysqlExplain(raw: unknown): ExplainPlanNode[] {
+  const root = objectValue(raw);
+  if (!root) return [];
+  const block = objectValue(root.query_block) || root;
+  return [parseMysqlBlock(block, "0", "query_block")];
+}
+
+function parseMysqlBlock(block: Record<string, unknown>, id: string, nodeType: string): ExplainPlanNode {
+  const costInfo = objectValue(block.cost_info);
+  const children: ExplainPlanNode[] = [];
+
+  const table = objectValue(block.table);
+  if (table) children.push(parseMysqlTable(table, `${id}.0`));
+
+  const nestedLoop = arrayValue(block.nested_loop);
+  if (nestedLoop) {
+    nestedLoop.forEach((item) => {
+      const itemObject = objectValue(item);
+      if (!itemObject) return;
+      const nestedTable = objectValue(itemObject.table);
+      if (nestedTable) {
+        children.push(parseMysqlTable(nestedTable, `${id}.${children.length}`));
+        return;
+      }
+      children.push(parseMysqlBlock(itemObject, `${id}.${children.length}`, "operation"));
+    });
+  }
+
+  ["ordering_operation", "grouping_operation", "duplicates_removal", "union_result", "materialized_from_subquery"].forEach((key) => {
+    const child = objectValue(block[key]);
+    if (child) children.push(parseMysqlBlock(child, `${id}.${children.length}`, key));
+  });
+
+  return {
+    id,
+    title: nodeType,
+    nodeType,
+    cost: stringValue(costInfo?.query_cost),
+    rows: numberLike(block.select_id),
+    details: [stringValue(block.message)].filter(nonEmptyString),
+    children,
+  };
+}
+
+function parseMysqlTable(table: Record<string, unknown>, id: string): ExplainPlanNode {
+  const relation = stringValue(table.table_name);
+  const accessType = stringValue(table.access_type) || "table";
+  const costInfo = objectValue(table.cost_info);
+  const rows = numberLike(table.rows_examined_per_scan) || numberLike(table.rows_produced_per_join);
+  const cost = stringValue(costInfo?.query_cost) || stringValue(costInfo?.read_cost) || stringValue(costInfo?.eval_cost);
+  const details = [stringValue(table.attached_condition) ? `Condition: ${stringValue(table.attached_condition)}` : "", arrayValue(table.used_columns)?.length ? `Columns: ${arrayValue(table.used_columns)!.map(String).join(", ")}` : "", table.using_index === true ? "Using index" : ""].filter(Boolean);
+
+  return {
+    id,
+    title: relation ? `${accessType} on ${relation}` : accessType,
+    nodeType: accessType,
+    relation,
+    index: stringValue(table.key),
+    cost,
+    rows,
+    details,
+    children: [],
+  };
+}
+
+// ── QuestDB explain parser ─────────────────────────────────────────
+function parseQuestdbExplain(result: QueryResult): ParsedExplainPlan {
+  let nodes: ExplainPlanNode[] = result.rows.map((row: unknown[], index: number) => {
+    const text = String(row[0] ?? "");
+    const node: ExplainPlanNode = {
+      id: `plan_${index}`,
+      title: text,
+      nodeType: "Plan",
+      relation: "",
+      index: String(index),
+      cost: undefined,
+      rows: undefined,
+      details: [text],
+      children: [],
+    };
+    return node;
+  });
+  return { databaseType: "questdb", raw: result, nodes };
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────
+
+function objectValue(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : null;
+}
+
+function arrayValue(value: unknown): unknown[] | null {
+  return Array.isArray(value) ? value : null;
+}
+
+function stringValue(value: unknown): string | undefined {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return undefined;
+}
+
+function nonEmptyString(value: string | undefined): value is string {
+  return !!value;
+}
+
+function numberLike(value: unknown): string | undefined {
+  if (typeof value === "number") return Number.isInteger(value) ? String(value) : String(value);
+  if (typeof value === "string" && value.trim()) return value;
+  return undefined;
+}
diff --git a/apps/desktop/src/lib/diagram/fieldLineage.ts b/apps/desktop/src/lib/diagram/fieldLineage.ts
new file mode 100644
index 0000000..9dde674
--- /dev/null
+++ b/apps/desktop/src/lib/diagram/fieldLineage.ts
@@ -0,0 +1,200 @@
+import type { ForeignKeyInfo } from "@/types/database";
+
+export type FieldLineageConfidence = "certain" | "likely" | "possible";
+export type FieldLineageKind = "foreignKey" | "viewReference" | "historyReference" | "sameName";
+export type FieldLineageDirection = "incoming" | "outgoing" | "reference";
+
+export interface FieldLineageTarget {
+  schema?: string;
+  table: string;
+  column: string;
+}
+
+export interface FieldLineageTable {
+  schema?: string;
+  name: string;
+  columns: string[];
+  foreignKeys?: ForeignKeyInfo[];
+}
+
+export interface FieldLineageView {
+  schema?: string;
+  name: string;
+  ddl: string;
+}
+
+export interface FieldLineageHistory {
+  id: string;
+  sql: string;
+  executed_at?: string;
+}
+
+export interface FieldLineageItem {
+  id: string;
+  kind: FieldLineageKind;
+  confidence: FieldLineageConfidence;
+  direction: FieldLineageDirection;
+  title: string;
+  description: string;
+  schema?: string;
+  table?: string;
+  column?: string;
+  sqlSnippet?: string;
+}
+
+export interface FieldLineageResult {
+  target: FieldLineageTarget;
+  items: FieldLineageItem[];
+}
+
+export function analyzeFieldLineage(options: { target: FieldLineageTarget; tables?: FieldLineageTable[]; views?: FieldLineageView[]; histories?: FieldLineageHistory[] }): FieldLineageResult {
+  const target = normalizeTarget(options.target);
+  const items: FieldLineageItem[] = [...foreignKeyLineage(target, options.tables ?? []), ...viewLineage(target, options.views ?? []), ...historyLineage(target, options.histories ?? []), ...sameNameLineage(target, options.tables ?? [])];
+
+  return { target: options.target, items };
+}
+
+export function summarizeLineageCounts(items: FieldLineageItem[]) {
+  return {
+    certain: items.filter((item) => item.confidence === "certain").length,
+    likely: items.filter((item) => item.confidence === "likely").length,
+    possible: items.filter((item) => item.confidence === "possible").length,
+  };
+}
+
+export function identifierInSql(sql: string, identifier: string): boolean {
+  const escaped = escapeRegExp(identifier);
+  const quoted = [`"${escapeRegExp(identifier)}"`, `\`${escapeRegExp(identifier)}\``, `\\[${escapeRegExp(identifier)}\\]`];
+  const pattern = `(?:${quoted.join("|")}|(?<![\\w$])${escaped}(?![\\w$]))`;
+  return new RegExp(pattern, "i").test(sql);
+}
+
+function foreignKeyLineage(target: Required<FieldLineageTarget>, tables: FieldLineageTable[]): FieldLineageItem[] {
+  const items: FieldLineageItem[] = [];
+  for (const table of tables) {
+    for (const fk of table.foreignKeys ?? []) {
+      const tableMatches = sameIdentifier(table.name, target.table) && schemaMatches(table.schema, target.schema);
+      if (tableMatches && sameIdentifier(fk.column, target.column)) {
+        items.push({
+          id: `fk-out:${table.schema ?? ""}:${table.name}:${fk.name}:${fk.column}`,
+          kind: "foreignKey",
+          confidence: "certain",
+          direction: "outgoing",
+          title: `${table.name}.${fk.column} -> ${fk.ref_table}.${fk.ref_column}`,
+          description: `Foreign key ${fk.name} references ${fk.ref_table}.${fk.ref_column}.`,
+          schema: table.schema,
+          table: fk.ref_table,
+          column: fk.ref_column,
+        });
+      }
+
+      if (sameIdentifier(fk.ref_table, target.table) && sameIdentifier(fk.ref_column, target.column)) {
+        items.push({
+          id: `fk-in:${table.schema ?? ""}:${table.name}:${fk.name}:${fk.column}`,
+          kind: "foreignKey",
+          confidence: "certain",
+          direction: "incoming",
+          title: `${table.name}.${fk.column} -> ${target.table}.${target.column}`,
+          description: `Foreign key ${fk.name} points to this field.`,
+          schema: table.schema,
+          table: table.name,
+          column: fk.column,
+        });
+      }
+    }
+  }
+  return items;
+}
+
+function viewLineage(target: Required<FieldLineageTarget>, views: FieldLineageView[]): FieldLineageItem[] {
+  return views
+    .filter((view) => identifierInSql(view.ddl, target.column))
+    .map((view) => {
+      const confidence: FieldLineageConfidence = identifierInSql(view.ddl, target.table) ? "likely" : "possible";
+      return {
+        id: `view:${view.schema ?? ""}:${view.name}`,
+        kind: "viewReference" as const,
+        confidence,
+        direction: "reference" as const,
+        title: `${view.name} references ${target.column}`,
+        description: confidence === "likely" ? `View definition mentions both ${target.table} and ${target.column}.` : `View definition mentions ${target.column}.`,
+        schema: view.schema,
+        table: view.name,
+        sqlSnippet: snippetAround(view.ddl, target.column),
+      };
+    });
+}
+
+function historyLineage(target: Required<FieldLineageTarget>, histories: FieldLineageHistory[]): FieldLineageItem[] {
+  return histories
+    .filter((entry) => identifierInSql(entry.sql, target.column))
+    .slice(0, 20)
+    .map((entry) => {
+      const confidence: FieldLineageConfidence = identifierInSql(entry.sql, target.table) ? "likely" : "possible";
+      return {
+        id: `history:${entry.id}`,
+        kind: "historyReference" as const,
+        confidence,
+        direction: "reference" as const,
+        title: confidence === "likely" ? "Query history references table and field" : "Query history references field",
+        description: entry.executed_at ? `Executed at ${entry.executed_at}.` : "Found in query history.",
+        sqlSnippet: snippetAround(entry.sql, target.column),
+      };
+    });
+}
+
+function sameNameLineage(target: Required<FieldLineageTarget>, tables: FieldLineageTable[]): FieldLineageItem[] {
+  const items: FieldLineageItem[] = [];
+  for (const table of tables) {
+    if (sameIdentifier(table.name, target.table) && schemaMatches(table.schema, target.schema)) continue;
+    for (const column of table.columns) {
+      if (!sameIdentifier(column, target.column)) continue;
+      items.push({
+        id: `same:${table.schema ?? ""}:${table.name}:${column}`,
+        kind: "sameName",
+        confidence: "possible",
+        direction: "reference",
+        title: `${table.name}.${column}`,
+        description: "Another field has the same name. This is a possible semantic relationship, not a verified dependency.",
+        schema: table.schema,
+        table: table.name,
+        column,
+      });
+    }
+  }
+  return items.slice(0, 40);
+}
+
+function normalizeTarget(target: FieldLineageTarget): Required<FieldLineageTarget> {
+  return {
+    schema: target.schema ?? "",
+    table: target.table,
+    column: target.column,
+  };
+}
+
+function sameIdentifier(left: string | undefined, right: string | undefined): boolean {
+  return normalizeIdentifier(left) === normalizeIdentifier(right);
+}
+
+function schemaMatches(left: string | undefined, right: string | undefined): boolean {
+  return normalizeIdentifier(left) === normalizeIdentifier(right);
+}
+
+function normalizeIdentifier(value: string | undefined): string {
+  return (value ?? "").replace(/^[`"[]|[`"\]]$/g, "").toLowerCase();
+}
+
+function snippetAround(sql: string, needle: string): string {
+  const index = sql.toLowerCase().indexOf(needle.toLowerCase());
+  if (index < 0) return sql.slice(0, 180);
+  const start = Math.max(0, index - 80);
+  const end = Math.min(sql.length, index + needle.length + 80);
+  const prefix = start > 0 ? "..." : "";
+  const suffix = end < sql.length ? "..." : "";
+  return `${prefix}${sql.slice(start, end)}${suffix}`;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
diff --git a/apps/desktop/src/lib/document/documentViewerFontStyle.ts b/apps/desktop/src/lib/document/documentViewerFontStyle.ts
new file mode 100644
index 0000000..6f2d6d7
--- /dev/null
+++ b/apps/desktop/src/lib/document/documentViewerFontStyle.ts
@@ -0,0 +1,11 @@
+import { EDITOR_FONT_FAMILY_CSS_VAR, EDITOR_FONT_SIZE_CSS_VAR } from "@/lib/editor/editorThemes";
+import type { EditorSettings } from "@/stores/settingsStore";
+
+export type DocumentViewerFontSettings = Pick<EditorSettings, "fontFamily" | "fontSize">;
+
+export function documentViewerFontStyle(settings: DocumentViewerFontSettings): Record<string, string> {
+  return {
+    [EDITOR_FONT_FAMILY_CSS_VAR]: settings.fontFamily,
+    [EDITOR_FONT_SIZE_CSS_VAR]: `${settings.fontSize}px`,
+  };
+}
diff --git a/apps/desktop/src/lib/document/gridFsBrowser.ts b/apps/desktop/src/lib/document/gridFsBrowser.ts
new file mode 100644
index 0000000..08a5583
--- /dev/null
+++ b/apps/desktop/src/lib/document/gridFsBrowser.ts
@@ -0,0 +1,139 @@
+import { buildDocumentFilterCondition, combineDocumentFilterConditions, defaultDocumentFilterRule, type DocumentFilterRule } from "@/lib/app/documentStoreProvider";
+import { formatMongoShellLiteral } from "@/lib/mongo/mongoDocumentValues";
+import { quoteUnquotedObjectKeys } from "@/lib/mongo/mongoShellCommand";
+
+export type GridFsBucketSortField = "name" | "fileCount" | "totalBytes";
+export type GridFsBucketSortDirection = "asc" | "desc";
+export type GridFsSortDirectionState = "none" | "asc" | "desc";
+export type GridFsFileField = "_id" | "filename" | "contentType" | "length" | "chunkSize" | "uploadDate" | "md5";
+export type GridFsFileFieldDisplayOption = { fieldName: GridFsFileField; label: string; labelKey?: never } | { fieldName: GridFsFileField; labelKey: string; label?: never };
+export type GridFsBucketSort = {
+  field: GridFsBucketSortField;
+  direction: GridFsBucketSortDirection;
+};
+
+export const gridFsFileFilterFieldOptions = ["_id", "filename", "contentType", "length", "chunkSize", "uploadDate", "md5"] as const satisfies readonly GridFsFileField[];
+export const gridFsFileFieldDisplayOptions = [
+  { fieldName: "_id", label: "ID" },
+  { fieldName: "filename", labelKey: "gridfsBrowser.name" },
+  { fieldName: "contentType", labelKey: "gridfsBrowser.contentType" },
+  { fieldName: "length", labelKey: "gridfsBrowser.totalSize" },
+  { fieldName: "chunkSize", labelKey: "gridfsBrowser.chunkSize" },
+  { fieldName: "uploadDate", labelKey: "gridfsBrowser.uploadDate" },
+  { fieldName: "md5", label: "MD5" },
+] as const satisfies readonly GridFsFileFieldDisplayOption[];
+
+export function gridFsFilesQueryPreview(options: { bucket: string; filterJson?: string; sortJson?: string }): string {
+  const parts = [`db.getCollection(${JSON.stringify(`${options.bucket}.files`)}).find(${mongoShellPreviewLiteral(options.filterJson || "{}")})`];
+  if (options.sortJson?.trim()) parts.push(`.sort(${mongoShellPreviewLiteral(options.sortJson)})`);
+  return parts.join("");
+}
+
+export function currentGridFsBucketFilter(input: string): string | undefined {
+  const trimmed = input.trim();
+  return trimmed || undefined;
+}
+
+export function createGridFsFileFilterRule(id: string): DocumentFilterRule {
+  return defaultDocumentFilterRule(id, gridFsFileFilterFieldOptions[0] ?? "");
+}
+
+export function gridFsFileFieldDisplayOption(fieldName: string): GridFsFileFieldDisplayOption | null {
+  return gridFsFileFieldDisplayOptions.find((option) => option.fieldName === fieldName) ?? null;
+}
+
+export function buildGridFsFilesStructuredFilter(rules: DocumentFilterRule[]): Record<string, unknown> | null {
+  const items = rules
+    .map((rule) => ({
+      rule,
+      condition: buildDocumentFilterCondition(rule, { kind: "mongodb" }),
+    }))
+    .filter((item): item is { rule: DocumentFilterRule; condition: Record<string, unknown> } => !!item.condition);
+  return combineDocumentFilterConditions(
+    items.map((item) => item.condition),
+    items.map((item) => item.rule),
+  );
+}
+
+export function parseGridFsBucketSort(input?: string): GridFsBucketSort | null {
+  const trimmed = input?.trim();
+  if (!trimmed) return null;
+  const parsed = JSON.parse(quoteUnquotedObjectKeys(trimmed)) as unknown;
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("GridFS bucket sort must be a JSON object");
+  }
+  const entries = Object.entries(parsed);
+  if (entries.length !== 1) {
+    throw new Error("GridFS bucket sort must contain exactly one field");
+  }
+  const [field, rawDirection] = entries[0]!;
+  if (field !== "name" && field !== "fileCount" && field !== "totalBytes") {
+    throw new Error("Unsupported GridFS bucket sort field");
+  }
+  const direction = normalizeGridFsBucketSortDirection(rawDirection);
+  if (!direction) {
+    throw new Error("GridFS bucket sort direction must be 1, -1, 'asc', or 'desc'");
+  }
+  return { field, direction };
+}
+
+export function currentGridFsBucketSort(input: string): string | undefined {
+  const sort = parseGridFsBucketSort(input);
+  if (!sort) return undefined;
+  return JSON.stringify({ [sort.field]: sort.direction === "desc" ? -1 : 1 });
+}
+
+export function currentGridFsFileSortDirection(input: string, column: string): GridFsSortDirectionState {
+  const sort = parseSingleFieldSort(input);
+  if (!sort || sort.field !== column) return "none";
+  return sort.direction;
+}
+
+export function currentGridFsBucketSortDirection(input: string, column: GridFsBucketSortField): GridFsSortDirectionState {
+  try {
+    const sort = parseGridFsBucketSort(input);
+    if (!sort || sort.field !== column) return "none";
+    return sort.direction;
+  } catch {
+    return "none";
+  }
+}
+
+export function gridFsBucketSortInputForColumn(column: string, direction: GridFsBucketSortDirection | null): string {
+  if (!direction) return "";
+  if (column !== "name" && column !== "fileCount" && column !== "totalBytes") return "";
+  return JSON.stringify({ [column]: direction === "desc" ? -1 : 1 });
+}
+
+function normalizeGridFsBucketSortDirection(value: unknown): GridFsBucketSortDirection | null {
+  if (value === -1 || value === "-1" || value === "desc") return "desc";
+  if (value === 1 || value === "1" || value === "asc") return "asc";
+  return null;
+}
+
+function parseSingleFieldSort(input?: string): { field: string; direction: GridFsBucketSortDirection } | null {
+  const trimmed = input?.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(quoteUnquotedObjectKeys(trimmed)) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    const entries = Object.entries(parsed);
+    if (entries.length !== 1) return null;
+    const [field, rawDirection] = entries[0]!;
+    const direction = normalizeGridFsBucketSortDirection(rawDirection);
+    if (!direction) return null;
+    return { field, direction };
+  } catch {
+    return null;
+  }
+}
+
+function mongoShellPreviewLiteral(json: string): string {
+  const trimmed = json.trim();
+  if (!trimmed) return "{}";
+  try {
+    return formatMongoShellLiteral(JSON.parse(quoteUnquotedObjectKeys(trimmed)));
+  } catch {
+    return trimmed;
+  }
+}
diff --git a/apps/desktop/src/lib/document/gridfsFiles.ts b/apps/desktop/src/lib/document/gridfsFiles.ts
new file mode 100644
index 0000000..fbdae0a
--- /dev/null
+++ b/apps/desktop/src/lib/document/gridfsFiles.ts
@@ -0,0 +1,183 @@
+import dayjs from "dayjs";
+
+export interface GridFsDownloadArchiveEntry {
+  id: string;
+  filename?: string;
+  data: Uint8Array;
+}
+
+type ZipEntry = {
+  path: string;
+  data: Uint8Array;
+  crc: number;
+  localHeaderOffset: number;
+};
+
+const encoder = new TextEncoder();
+const CRC_TABLE = buildCrcTable();
+const GRIDFS_DATETIME_PATTERN = "YYYY-MM-DD HH:mm:ss";
+
+export function formatGridFsUploadDate(value?: string | null): string {
+  const trimmed = value?.trim();
+  if (!trimmed) return "-";
+  const parsed = dayjs(trimmed);
+  return parsed.isValid() ? parsed.format(GRIDFS_DATETIME_PATTERN) : trimmed;
+}
+
+export function defaultGridFsArchiveFileName(bucket: string, now = new Date()): string {
+  const safeBucket = sanitizePathStem(bucket) || "gridfs-files";
+  return `${safeBucket}-gridfs-${dayjs(now).format("YYYYMMDD-HHmmss")}.zip`;
+}
+
+export function buildGridFsDownloadArchive(entries: readonly GridFsDownloadArchiveEntry[]): Uint8Array {
+  if (entries.length === 0) {
+    throw new Error("At least one GridFS file must be selected.");
+  }
+  const seen = new Set<string>();
+  const files = entries.map((entry) => ({
+    path: uniqueArchiveEntryName(entry, seen),
+    data: entry.data,
+  }));
+  return buildZipArchive(files);
+}
+
+function uniqueArchiveEntryName(entry: GridFsDownloadArchiveEntry, seen: Set<string>): string {
+  const baseName = normalizeArchiveEntryName(entry.filename, entry.id);
+  let candidate = baseName;
+  let suffix = 2;
+  while (seen.has(candidate.toLowerCase())) {
+    candidate = withDuplicateSuffix(baseName, suffix);
+    suffix += 1;
+  }
+  seen.add(candidate.toLowerCase());
+  return candidate;
+}
+
+function normalizeArchiveEntryName(filename: string | undefined, id: string): string {
+  const fallback = `${sanitizePathStem(id) || "gridfs-file"}.bin`;
+  const raw = filename?.trim();
+  if (!raw) return fallback;
+
+  const normalized = raw.replace(/[\\/]+/g, "-");
+  const dotIndex = normalized.lastIndexOf(".");
+  const hasExtension = dotIndex > 0 && dotIndex < normalized.length - 1;
+  const rawStem = hasExtension ? normalized.slice(0, dotIndex) : normalized;
+  const rawExtension = hasExtension ? normalized.slice(dotIndex + 1) : "";
+
+  const stem = sanitizePathStem(rawStem) || sanitizePathStem(id) || "gridfs-file";
+  const extension = sanitizeExtension(rawExtension);
+  const fileName = extension ? `${stem}.${extension}` : stem;
+  return fileName.slice(0, 180) || fallback;
+}
+
+function withDuplicateSuffix(fileName: string, index: number): string {
+  const dotIndex = fileName.lastIndexOf(".");
+  if (dotIndex > 0 && dotIndex < fileName.length - 1) {
+    const extension = fileName.slice(dotIndex);
+    const stem = fileName.slice(0, dotIndex).slice(0, Math.max(1, 180 - extension.length - `${index}`.length - 1));
+    return `${stem}-${index}${extension}`;
+  }
+  const stem = fileName.slice(0, Math.max(1, 180 - `${index}`.length - 1));
+  return `${stem}-${index}`;
+}
+
+function sanitizePathStem(value: string): string {
+  return value
+    .trim()
+    .replace(/[<>:"/\\|?*\u0000-\u001f]+/g, "-")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^[-.\s]+|[-.\s]+$/g, "")
+    .slice(0, 160);
+}
+
+function sanitizeExtension(value: string): string {
+  return value.replace(/[^A-Za-z0-9_-]+/g, "").slice(0, 16);
+}
+
+function buildCrcTable(): number[] {
+  const table: number[] = [];
+  for (let i = 0; i < 256; i++) {
+    let crc = i;
+    for (let j = 0; j < 8; j++) {
+      crc = crc & 1 ? 0xedb88320 ^ (crc >>> 1) : crc >>> 1;
+    }
+    table.push(crc >>> 0);
+  }
+  return table;
+}
+
+function crc32(data: Uint8Array): number {
+  let crc = 0xffffffff;
+  for (const byte of data) {
+    crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function uint16(value: number): Uint8Array {
+  const bytes = new Uint8Array(2);
+  new DataView(bytes.buffer).setUint16(0, value, true);
+  return bytes;
+}
+
+function uint32(value: number): Uint8Array {
+  const bytes = new Uint8Array(4);
+  new DataView(bytes.buffer).setUint32(0, value >>> 0, true);
+  return bytes;
+}
+
+function concatBytes(parts: readonly Uint8Array[]): Uint8Array {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+
+function buildZipArchive(files: ReadonlyArray<{ path: string; data: Uint8Array }>): Uint8Array {
+  const entries: ZipEntry[] = [];
+  const localParts: Uint8Array[] = [];
+  let offset = 0;
+
+  for (const file of files) {
+    const path = encoder.encode(file.path);
+    const crc = crc32(file.data);
+    const localHeader = concatBytes([uint32(0x04034b50), uint16(20), uint16(0), uint16(0), uint16(0), uint16(0), uint32(crc), uint32(file.data.length), uint32(file.data.length), uint16(path.length), uint16(0), path]);
+    entries.push({ path: file.path, data: file.data, crc, localHeaderOffset: offset });
+    localParts.push(localHeader, file.data);
+    offset += localHeader.length + file.data.length;
+  }
+
+  const centralParts = entries.map((entry) => {
+    const path = encoder.encode(entry.path);
+    return concatBytes([
+      uint32(0x02014b50),
+      uint16(20),
+      uint16(20),
+      uint16(0),
+      uint16(0),
+      uint16(0),
+      uint16(0),
+      uint32(entry.crc),
+      uint32(entry.data.length),
+      uint32(entry.data.length),
+      uint16(path.length),
+      uint16(0),
+      uint16(0),
+      uint16(0),
+      uint16(0),
+      uint32(0),
+      uint32(entry.localHeaderOffset),
+      path,
+    ]);
+  });
+
+  const centralDirectory = concatBytes(centralParts);
+  const endOfCentralDirectory = concatBytes([uint32(0x06054b50), uint16(0), uint16(0), uint16(entries.length), uint16(entries.length), uint32(centralDirectory.length), uint32(offset), uint16(0)]);
+
+  return concatBytes([...localParts, centralDirectory, endOfCentralDirectory]);
+}
diff --git a/apps/desktop/src/lib/document/gridfsPagination.ts b/apps/desktop/src/lib/document/gridfsPagination.ts
new file mode 100644
index 0000000..f005005
--- /dev/null
+++ b/apps/desktop/src/lib/document/gridfsPagination.ts
@@ -0,0 +1,20 @@
+import { normalizeResultPageSize } from "@/lib/dataGrid/paginationPageSize";
+
+export function gridFsTotalPages(totalCount: number, pageSize: number): number {
+  const normalizedPageSize = Math.max(1, normalizeResultPageSize(pageSize));
+  const normalizedTotal = Number.isFinite(totalCount) ? Math.max(0, Math.floor(totalCount)) : 0;
+  return Math.max(1, Math.ceil(normalizedTotal / normalizedPageSize));
+}
+
+export function clampGridFsPage(page: number, totalCount: number, pageSize: number): number {
+  const lastPage = gridFsTotalPages(totalCount, pageSize) - 1;
+  if (!Number.isFinite(page)) return 0;
+  return Math.max(0, Math.min(Math.floor(page), lastPage));
+}
+
+export function paginateGridFsItems<T>(items: readonly T[], page: number, pageSize: number): T[] {
+  const normalizedPageSize = Math.max(1, normalizeResultPageSize(pageSize));
+  const safePage = clampGridFsPage(page, items.length, normalizedPageSize);
+  const start = safePage * normalizedPageSize;
+  return items.slice(start, start + normalizedPageSize);
+}
diff --git a/apps/desktop/src/lib/editor/codemirrorInsertValueHints.ts b/apps/desktop/src/lib/editor/codemirrorInsertValueHints.ts
new file mode 100644
index 0000000..d955d8e
--- /dev/null
+++ b/apps/desktop/src/lib/editor/codemirrorInsertValueHints.ts
@@ -0,0 +1,212 @@
+import { StateEffect, type Extension } from "@codemirror/state";
+import { Decoration, EditorView, ViewPlugin, WidgetType, type DecorationSet, type ViewUpdate } from "@codemirror/view";
+import { buildInsertValueHints, expandToSqlStatementWindow, insertValueHintsNeedTableColumns, parseInsertValuesClauses, type InsertValueHint, type InsertValuesClause, type TextRange } from "@/lib/sql/insertValueHints";
+
+export const refreshInsertValueHintsEffect = StateEffect.define<null>();
+
+/** Debounce hint reparse while the user is typing / holding a key. */
+const INSERT_HINT_REPARSE_DELAY_MS = 80;
+
+export interface InsertValueHintsExtensionOptions {
+  isEnabled?: () => boolean;
+  /** Sync cache lookup for table columns when INSERT has no explicit column list. */
+  getTableColumns?: (table: string, schema?: string, database?: string) => string[] | undefined;
+  /** Async loader invoked when sync cache misses; should call refresh after load. */
+  requestTableColumns?: (table: string, schema?: string, database?: string) => void;
+}
+
+class InsertValueHintWidget extends WidgetType {
+  constructor(readonly column: string) {
+    super();
+  }
+
+  eq(other: InsertValueHintWidget) {
+    return other.column === this.column;
+  }
+
+  toDOM() {
+    const span = document.createElement("span");
+    span.className = "cm-insert-value-hint";
+    span.textContent = this.column;
+    span.setAttribute("aria-hidden", "true");
+    return span;
+  }
+
+  ignoreEvent() {
+    return true;
+  }
+}
+
+function decorationsForHints(hints: readonly InsertValueHint[]): DecorationSet {
+  if (hints.length === 0) return Decoration.none;
+  const deduped: InsertValueHint[] = [];
+  const seenFrom = new Set<number>();
+  for (const hint of [...hints].sort((a, b) => a.from - b.from || a.column.localeCompare(b.column))) {
+    if (seenFrom.has(hint.from)) continue;
+    seenFrom.add(hint.from);
+    deduped.push(hint);
+  }
+  const ranges = deduped.map((hint) =>
+    Decoration.widget({
+      widget: new InsertValueHintWidget(hint.column),
+      side: -1,
+    }).range(hint.from),
+  );
+  return Decoration.set(ranges);
+}
+
+function interestRanges(view: EditorView): TextRange[] {
+  const ranges: TextRange[] = view.visibleRanges.map((range) => ({ from: range.from, to: range.to }));
+  const cursor = view.state.selection.main.head;
+  ranges.push({ from: cursor, to: cursor });
+  return ranges;
+}
+
+function shiftClause(clause: InsertValuesClause, offset: number): InsertValuesClause {
+  if (offset === 0) return clause;
+  return {
+    ...clause,
+    span: { start: clause.span.start + offset, end: clause.span.end + offset },
+    rows: clause.rows.map((row) => row.map((from) => from + offset)),
+  };
+}
+
+/** Parse INSERT hints using only local slices around interest ranges — no full-document tokenize. */
+function parseClausesNearView(view: EditorView): InsertValuesClause[] {
+  const doc = view.state.doc;
+  const clauses: InsertValuesClause[] = [];
+  const seenStmtStarts = new Set<number>();
+
+  for (const range of interestRanges(view)) {
+    // Pull a bounded neighborhood from the doc instead of materializing the whole script.
+    const pad = 32 * 1024;
+    const sliceFrom = Math.max(0, range.from - pad);
+    const sliceTo = Math.min(doc.length, range.to + pad);
+    if (sliceTo <= sliceFrom) continue;
+    const slice = doc.sliceString(sliceFrom, sliceTo);
+    const window = expandToSqlStatementWindow(slice, range.from - sliceFrom, range.to - sliceFrom);
+    if (window.to <= window.from) continue;
+    const absStart = sliceFrom + window.from;
+    if (seenStmtStarts.has(absStart)) continue;
+    seenStmtStarts.add(absStart);
+    const stmt = slice.slice(window.from, window.to);
+    // Cheap reject: skip tokenize when the window clearly has no INSERT.
+    if (!/\binsert\b/i.test(stmt)) continue;
+    for (const clause of parseInsertValuesClauses(stmt)) {
+      clauses.push(shiftClause(clause, absStart));
+    }
+  }
+  return clauses;
+}
+
+function buildHints(view: EditorView, options: InsertValueHintsExtensionOptions): InsertValueHint[] {
+  const clauses = parseClausesNearView(view);
+  for (const clause of clauses) {
+    if (clause.columns !== null) continue;
+    const cached = options.getTableColumns?.(clause.table, clause.schema, clause.database);
+    if (!cached) options.requestTableColumns?.(clause.table, clause.schema, clause.database);
+  }
+  return buildInsertValueHints(clauses, {
+    resolveTableColumns: (table, schema, database) => options.getTableColumns?.(table, schema, database),
+  });
+}
+
+const insertValueHintsTheme = EditorView.baseTheme({
+  ".cm-insert-value-hint": {
+    display: "inline-block",
+    marginRight: "0.35em",
+    padding: "0 0.3em",
+    borderRadius: "3px",
+    fontSize: "0.85em",
+    lineHeight: "1.2",
+    verticalAlign: "baseline",
+    color: "var(--cm-insert-value-hint-color, rgba(120, 120, 120, 0.95))",
+    backgroundColor: "var(--cm-insert-value-hint-bg, rgba(120, 120, 120, 0.18))",
+    pointerEvents: "none",
+    userSelect: "none",
+    fontStyle: "normal",
+    fontWeight: "500",
+  },
+  "&dark .cm-insert-value-hint": {
+    color: "var(--cm-insert-value-hint-color, rgba(180, 180, 180, 0.9))",
+    backgroundColor: "var(--cm-insert-value-hint-bg, rgba(180, 180, 180, 0.16))",
+  },
+});
+
+export function createInsertValueHintsExtension(options: InsertValueHintsExtensionOptions = {}): Extension {
+  const plugin = ViewPlugin.fromClass(
+    class {
+      decorations: DecorationSet;
+      private lastEnabled = true;
+      private reparseTimer: ReturnType<typeof setTimeout> | null = null;
+
+      constructor(view: EditorView) {
+        this.decorations = this.compute(view);
+      }
+
+      update(update: ViewUpdate) {
+        const refreshed = update.transactions.some((tr) => tr.effects.some((effect) => effect.is(refreshInsertValueHintsEffect)));
+        const enabled = options.isEnabled?.() ?? true;
+
+        if (!enabled) {
+          this.clearTimer();
+          this.lastEnabled = false;
+          this.decorations = Decoration.none;
+          return;
+        }
+
+        // Keep widget positions valid while a debounced reparse is pending.
+        if (update.docChanged) {
+          this.decorations = this.decorations.map(update.changes);
+        }
+
+        if (refreshed || enabled !== this.lastEnabled) {
+          this.clearTimer();
+          this.lastEnabled = enabled;
+          this.decorations = this.compute(update.view);
+          return;
+        }
+
+        this.lastEnabled = enabled;
+        if (update.docChanged || update.viewportChanged) {
+          // Do not reparse on the hot path — key-repeat would block the UI.
+          this.scheduleReparse(update.view);
+        }
+      }
+
+      destroy() {
+        this.clearTimer();
+      }
+
+      private scheduleReparse(view: EditorView) {
+        this.clearTimer();
+        this.reparseTimer = setTimeout(() => {
+          this.reparseTimer = null;
+          // Trigger a lightweight transaction so update() runs compute once typing pauses.
+          view.dispatch({ effects: refreshInsertValueHintsEffect.of(null) });
+        }, INSERT_HINT_REPARSE_DELAY_MS);
+      }
+
+      private clearTimer() {
+        if (this.reparseTimer !== null) {
+          clearTimeout(this.reparseTimer);
+          this.reparseTimer = null;
+        }
+      }
+
+      private compute(view: EditorView): DecorationSet {
+        if (!(options.isEnabled?.() ?? true)) return Decoration.none;
+        return decorationsForHints(buildHints(view, options));
+      }
+    },
+    { decorations: (value) => value.decorations },
+  );
+
+  return [insertValueHintsTheme, plugin];
+}
+
+export function requestInsertValueHintsRefresh(view: EditorView) {
+  view.dispatch({ effects: refreshInsertValueHintsEffect.of(null) });
+}
+
+export { insertValueHintsNeedTableColumns };
diff --git a/apps/desktop/src/lib/editor/codemirrorSelectionMatches.ts b/apps/desktop/src/lib/editor/codemirrorSelectionMatches.ts
new file mode 100644
index 0000000..3db6406
--- /dev/null
+++ b/apps/desktop/src/lib/editor/codemirrorSelectionMatches.ts
@@ -0,0 +1,148 @@
+import type { EditorState, Extension } from "@codemirror/state";
+import { highlightSelectionMatches, SearchCursor } from "@codemirror/search";
+import { EditorView, ViewPlugin, type ViewUpdate } from "@codemirror/view";
+
+const MIN_SELECTION_MATCH_LENGTH = 2;
+const MAX_SELECTION_MATCH_LENGTH = 200;
+const MAX_SCROLLBAR_MARKS = 1200;
+
+interface SelectionMatchMarker {
+  from: number;
+  to: number;
+  lineNumber: number;
+  selected: boolean;
+}
+
+function selectedMatchQuery(state: EditorState): string | null {
+  const selection = state.selection.main;
+  if (selection.empty) return null;
+  if (selection.to - selection.from > MAX_SELECTION_MATCH_LENGTH) return null;
+
+  const text = state.sliceDoc(selection.from, selection.to);
+  if (text.length < MIN_SELECTION_MATCH_LENGTH || !text.trim() || /[\r\n]/.test(text)) return null;
+  return text;
+}
+
+function buildSelectionMatchMarkers(state: EditorState): SelectionMatchMarker[] {
+  const query = selectedMatchQuery(state);
+  if (!query) return [];
+
+  const selection = state.selection.main;
+  const markers: SelectionMatchMarker[] = [];
+  const seenLines = new Set<number>();
+  const cursor = new SearchCursor(state.doc, query);
+
+  for (let match = cursor.next(); !match.done; match = cursor.next()) {
+    const { from, to } = match.value;
+    if (from === to) continue;
+
+    const line = state.doc.lineAt(from);
+    const selected = from === selection.from && to === selection.to;
+    const lineKey = selected ? -line.number : line.number;
+    if (seenLines.has(lineKey)) continue;
+    seenLines.add(lineKey);
+
+    markers.push({ from, to, lineNumber: line.number, selected });
+    if (markers.length >= MAX_SCROLLBAR_MARKS) break;
+  }
+
+  return markers;
+}
+
+class SelectionMatchScrollbar {
+  private readonly layer: HTMLElement;
+  private signature = "";
+
+  constructor(view: EditorView) {
+    this.layer = document.createElement("div");
+    this.layer.className = "cm-selectionMatchScrollbarLayer";
+    view.dom.appendChild(this.layer);
+    this.render(view);
+  }
+
+  update(update: ViewUpdate) {
+    if (update.docChanged || update.selectionSet || update.geometryChanged) {
+      this.render(update.view);
+    }
+  }
+
+  destroy() {
+    this.layer.remove();
+  }
+
+  private render(view: EditorView) {
+    const markers = buildSelectionMatchMarkers(view.state);
+    const lineCount = view.state.doc.lines;
+    const signature = markers.map((marker) => `${marker.lineNumber}:${marker.from}:${marker.to}:${marker.selected}`).join("|");
+    if (signature === this.signature) return;
+    this.signature = signature;
+    this.layer.replaceChildren(
+      ...markers.map((marker) => {
+        const el = document.createElement("div");
+        el.className = marker.selected ? "cm-selectionMatchScrollbarMark cm-selectionMatchScrollbarMark-selected" : "cm-selectionMatchScrollbarMark";
+        const ratio = lineCount <= 1 ? 0 : (marker.lineNumber - 1) / (lineCount - 1);
+        el.style.top = `${Math.max(0, Math.min(1, ratio)) * 100}%`;
+        return el;
+      }),
+    );
+  }
+}
+
+const selectionMatchScrollbar = ViewPlugin.fromClass(SelectionMatchScrollbar);
+
+export function selectionMatchOccurrences(): Extension {
+  return [
+    highlightSelectionMatches({
+      minSelectionLength: MIN_SELECTION_MATCH_LENGTH,
+      maxMatches: 500,
+    }),
+    selectionMatchScrollbar,
+    EditorView.theme({
+      "&": {
+        "--dbx-selection-match-background": "rgb(59 130 246 / 0.07)",
+        "--dbx-selection-match-border": "rgb(59 130 246 / 0.24)",
+        "--dbx-selection-match-main-background": "rgb(59 130 246 / 0.11)",
+        "--dbx-selection-match-main-border": "rgb(59 130 246 / 0.36)",
+        position: "relative",
+      },
+      ".dark &": {
+        "--dbx-selection-match-background": "rgb(147 197 253 / 0.12)",
+        "--dbx-selection-match-border": "rgb(147 197 253 / 0.3)",
+        "--dbx-selection-match-main-background": "rgb(147 197 253 / 0.18)",
+        "--dbx-selection-match-main-border": "rgb(147 197 253 / 0.42)",
+      },
+      ".cm-selectionMatch": {
+        backgroundColor: "var(--dbx-selection-match-background)",
+        borderRadius: "2px",
+        boxShadow: "inset 0 0 0 1px var(--dbx-selection-match-border)",
+      },
+      ".cm-selectionMatch-main": {
+        backgroundColor: "var(--dbx-selection-match-main-background)",
+        boxShadow: "inset 0 0 0 1px var(--dbx-selection-match-main-border)",
+      },
+      ".cm-selectionMatchScrollbarLayer": {
+        bottom: "2px",
+        pointerEvents: "none",
+        position: "absolute",
+        right: "2px",
+        top: "2px",
+        width: "5px",
+        zIndex: "40",
+      },
+      ".cm-selectionMatchScrollbarMark": {
+        backgroundColor: "color-mix(in oklab, var(--primary) 48%, transparent)",
+        borderRadius: "999px",
+        height: "2px",
+        position: "absolute",
+        right: "0",
+        transform: "translateY(-50%)",
+        width: "3px",
+      },
+      ".cm-selectionMatchScrollbarMark-selected": {
+        backgroundColor: "color-mix(in oklab, var(--primary) 72%, transparent)",
+        height: "3px",
+        width: "4px",
+      },
+    }),
+  ];
+}
diff --git a/apps/desktop/src/lib/editor/codemirrorSqlDialect.ts b/apps/desktop/src/lib/editor/codemirrorSqlDialect.ts
new file mode 100644
index 0000000..265db57
--- /dev/null
+++ b/apps/desktop/src/lib/editor/codemirrorSqlDialect.ts
@@ -0,0 +1,68 @@
+import type { SQLDialect } from "@codemirror/lang-sql";
+
+export type CodeMirrorSqlDialectName = "mysql" | "postgres" | "sqlserver";
+
+type CodeMirrorSqlLanguageModule = Pick<typeof import("@codemirror/lang-sql"), "MSSQL" | "MySQL" | "PostgreSQL" | "SQLDialect">;
+
+const DBX_COMMON_SQL_KEYWORDS = [
+  "PIVOT",
+  "UNPIVOT",
+  "EXCLUDE",
+  "REPLACE",
+  "QUALIFY",
+  "ASOF",
+  "POSITIONAL",
+  "ANTI",
+  "SEMI",
+  "SAMPLE",
+  "TABLESAMPLE",
+  "STRUCT",
+  "MAP",
+  "LIST",
+  "ARRAY",
+  "LAMBDA",
+  "UNNEST",
+  "LATERAL",
+  "FILTER",
+  "RECURSIVE",
+  "SUMMARIZE",
+  "PRAGMA",
+  "READ_CSV",
+  "READ_PARQUET",
+  "READ_JSON",
+  "DESCRIBE",
+  "SHOW",
+  "COPY",
+  "EXPORT",
+  "IMPORT",
+].join(" ");
+
+const POSTGRES_PLPGSQL_KEYWORDS = "PERFORM";
+const POSTGRES_PLPGSQL_TYPES = "RECORD JSON JSONB";
+const POSTGRES_PLPGSQL_BUILTIN = "SQLERRM TG_NAME TG_WHEN TG_LEVEL TG_OP TG_RELID TG_RELNAME TG_TABLE_NAME TG_TABLE_SCHEMA TG_NARGS TG_ARGV";
+const POSTGRES_IDENTIFIER_LIKE_KEYWORDS = new Set("COMMENT COUNT DATA DAY HOUR ID KEY LEVEL MINUTE MONTH NAME OWNER PASSWORD POSITION ROLE SECOND TYPE USER VALUE YEAR".split(" "));
+
+// SQL Server table-valued parameters require READONLY in procedure/function declarations.
+const SQLSERVER_KEYWORDS = "readonly";
+
+export function postgresKeywordSyntaxTerms(keywords: string): string {
+  return keywords
+    .split(/\s+/)
+    .filter((keyword) => keyword && !POSTGRES_IDENTIFIER_LIKE_KEYWORDS.has(keyword.toUpperCase()))
+    .join(" ");
+}
+
+export function createDbxCodeMirrorSqlDialect(langSql: CodeMirrorSqlLanguageModule, dialectName: CodeMirrorSqlDialectName = "mysql"): SQLDialect {
+  const baseDialect = dialectName === "postgres" ? langSql.PostgreSQL : dialectName === "sqlserver" ? langSql.MSSQL : langSql.MySQL;
+  const isPostgres = dialectName === "postgres";
+  const isSqlServer = dialectName === "sqlserver";
+  const baseKeywords = isPostgres ? postgresKeywordSyntaxTerms(baseDialect.spec.keywords || "") : baseDialect.spec.keywords || "";
+
+  return langSql.SQLDialect.define({
+    ...baseDialect.spec,
+    keywords: [baseKeywords, DBX_COMMON_SQL_KEYWORDS, isPostgres ? POSTGRES_PLPGSQL_KEYWORDS : "", isSqlServer ? SQLSERVER_KEYWORDS : ""].filter(Boolean).join(" "),
+    types: [baseDialect.spec.types || "", isPostgres ? POSTGRES_PLPGSQL_TYPES : ""].filter(Boolean).join(" ") || undefined,
+    builtin: [baseDialect.spec.builtin || "", isPostgres ? POSTGRES_PLPGSQL_BUILTIN : ""].filter(Boolean).join(" ") || undefined,
+    doubleDollarQuotedStrings: false,
+  });
+}
diff --git a/apps/desktop/src/lib/editor/codemirrorTrimmedSelectionLayer.ts b/apps/desktop/src/lib/editor/codemirrorTrimmedSelectionLayer.ts
new file mode 100644
index 0000000..77e16fe
--- /dev/null
+++ b/apps/desktop/src/lib/editor/codemirrorTrimmedSelectionLayer.ts
@@ -0,0 +1,207 @@
+import { layer, RectangleMarker, type EditorView } from "@codemirror/view";
+
+const FALLBACK_EMPTY_SELECTION_WIDTH = 8;
+const END_OF_LINE_PADDING = 3;
+const CONTIGUOUS_LINE_GAP = 1.5;
+const CORNER_COVERAGE_GAP = 1;
+
+type TrimmedSelectionRect = {
+  left: number;
+  top: number;
+  width: number;
+  height: number;
+};
+
+type PositionRect = ReturnType<EditorView["coordsAtPos"]>;
+
+export function trimmedSelectionHorizontalBounds(options: {
+  from: number;
+  to: number;
+  lineFrom: number;
+  lineTo: number;
+  includesLineBreak: boolean;
+  startLeft: number;
+  startRight: number;
+  endLeft: number;
+  endRight: number;
+  lineStartLeft: number;
+  lineEndRight: number;
+  emptySelectionWidth?: number;
+}): {
+  left: number;
+  right: number;
+} {
+  const lineBreakOnlyAtContentEnd = options.from >= options.to && options.includesLineBreak && options.from >= options.lineTo && options.lineTo > options.lineFrom;
+  const left = options.from < options.to ? Math.min(options.startLeft, options.endLeft) : lineBreakOnlyAtContentEnd ? options.lineEndRight : options.lineStartLeft;
+  const emptySelectionWidth = Math.max(1, options.emptySelectionWidth ?? FALLBACK_EMPTY_SELECTION_WIDTH);
+  let right = options.from < options.to ? Math.max(options.startRight, options.endRight) : left + emptySelectionWidth;
+  if (options.includesLineBreak && options.to >= options.lineTo) {
+    right = Math.max(right, options.lineEndRight + END_OF_LINE_PADDING);
+  }
+  return { left, right };
+}
+
+function visualLineVerticalBounds(view: EditorView, start: NonNullable<PositionRect>, end: NonNullable<PositionRect>): { top: number; bottom: number } {
+  const top = Math.min(start.top, end.top);
+  const bottom = Math.max(start.bottom, end.bottom);
+  const height = Math.max(bottom - top, view.defaultLineHeight);
+  const center = (top + bottom) / 2;
+  return {
+    top: center - height / 2,
+    bottom: center + height / 2,
+  };
+}
+
+function layerBase(view: EditorView) {
+  const rect = view.scrollDOM.getBoundingClientRect();
+  return {
+    left: rect.left - view.scrollDOM.scrollLeft * view.scaleX,
+    top: rect.top - view.scrollDOM.scrollTop * view.scaleY,
+  };
+}
+
+function markerForLineRange(view: EditorView, from: number, to: number, lineFrom: number, lineTo: number, includesLineBreak: boolean, base: { left: number; top: number }): TrimmedSelectionRect | null {
+  const start = view.coordsAtPos(from, 1);
+  const end = from < to ? view.coordsAtPos(to, -1) : start;
+  const lineStart = view.coordsAtPos(lineFrom, 1) ?? start;
+  const lineEnd = view.coordsAtPos(lineTo, -1) ?? end;
+  if (!start || !end || !lineStart || !lineEnd) return null;
+
+  const { left, right } = trimmedSelectionHorizontalBounds({
+    from,
+    to,
+    lineFrom,
+    lineTo,
+    includesLineBreak,
+    startLeft: start.left,
+    startRight: start.right,
+    endLeft: end.left,
+    endRight: end.right,
+    lineStartLeft: lineStart.left,
+    lineEndRight: lineEnd.right,
+    emptySelectionWidth: view.defaultCharacterWidth,
+  });
+
+  const { top, bottom } = visualLineVerticalBounds(view, start, end);
+
+  return {
+    left: left - base.left,
+    top: top - base.top,
+    width: Math.max(1, right - left),
+    height: Math.max(1, bottom - top),
+  };
+}
+
+function sameVisualLine(a: NonNullable<PositionRect>, b: NonNullable<PositionRect>): boolean {
+  const aMid = (a.top + a.bottom) / 2;
+  const bMid = (b.top + b.bottom) / 2;
+  return Math.abs(aMid - bMid) <= Math.max(2, Math.min(a.bottom - a.top, b.bottom - b.top) / 2);
+}
+
+function lastPositionOnVisualLine(view: EditorView, from: number, to: number, start: NonNullable<PositionRect>): number {
+  let low = from + 1;
+  let high = to;
+  let best = from;
+
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const coords = view.coordsAtPos(mid, -1) ?? view.coordsAtPos(mid, 1);
+    if (coords && sameVisualLine(start, coords)) {
+      best = mid;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+
+  return best > from ? best : Math.min(to, from + 1);
+}
+
+function markerRectsForLineRange(view: EditorView, from: number, to: number, lineFrom: number, lineTo: number, includesLineBreak: boolean, base: { left: number; top: number }): TrimmedSelectionRect[] {
+  const start = view.coordsAtPos(from, 1);
+  const end = from < to ? view.coordsAtPos(to, -1) : start;
+  if (!start || !end) return [];
+  if (from >= to || sameVisualLine(start, end)) {
+    const rect = markerForLineRange(view, from, to, lineFrom, lineTo, includesLineBreak, base);
+    return rect ? [rect] : [];
+  }
+
+  const rects: TrimmedSelectionRect[] = [];
+  let segmentFrom = from;
+  while (segmentFrom < to) {
+    const segmentStart = view.coordsAtPos(segmentFrom, 1);
+    if (!segmentStart) break;
+    const segmentTo = lastPositionOnVisualLine(view, segmentFrom, to, segmentStart);
+    const rect = markerForLineRange(view, segmentFrom, segmentTo, lineFrom, lineTo, includesLineBreak && segmentTo >= to, base);
+    if (rect) rects.push(rect);
+    if (segmentTo <= segmentFrom) break;
+    segmentFrom = segmentTo;
+  }
+  return rects;
+}
+
+function coversX(rect: TrimmedSelectionRect | undefined, x: number): boolean {
+  if (!rect) return false;
+  return rect.left <= x + CORNER_COVERAGE_GAP && rect.left + rect.width >= x - CORNER_COVERAGE_GAP;
+}
+
+function markerClass(rects: TrimmedSelectionRect[], index: number): string {
+  const prev = rects[index - 1];
+  const current = rects[index];
+  const next = rects[index + 1];
+  const touchesPrev = !!prev && Math.abs(prev.top + prev.height - current.top) <= CONTIGUOUS_LINE_GAP;
+  const touchesNext = !!next && Math.abs(current.top + current.height - next.top) <= CONTIGUOUS_LINE_GAP;
+  const left = current.left;
+  const right = current.left + current.width;
+
+  const classes = ["cm-trimmedSelection"];
+  if (!touchesPrev || !coversX(prev, left)) classes.push("cm-trimmedSelection-topLeft");
+  if (!touchesPrev || !coversX(prev, right)) classes.push("cm-trimmedSelection-topRight");
+  if (!touchesNext || !coversX(next, left)) classes.push("cm-trimmedSelection-bottomLeft");
+  if (!touchesNext || !coversX(next, right)) classes.push("cm-trimmedSelection-bottomRight");
+
+  return classes.join(" ");
+}
+
+export function trimmedSelectionLayer() {
+  return layer({
+    above: false,
+    class: "cm-trimmedSelectionLayer",
+    markers(view) {
+      const markers: InstanceType<typeof RectangleMarker>[] = [];
+      const base = layerBase(view);
+
+      for (const range of view.state.selection.ranges) {
+        if (range.empty) continue;
+        const rects: TrimmedSelectionRect[] = [];
+
+        for (const visible of view.visibleRanges) {
+          let pos = Math.max(range.from, visible.from, view.viewport.from);
+          const endPos = Math.min(range.to, visible.to, view.viewport.to);
+
+          while (pos < endPos) {
+            const line = view.state.doc.lineAt(pos);
+            const from = Math.max(pos, line.from);
+            const to = Math.min(endPos, line.to);
+            const includesLineBreak = endPos > line.to && range.to > line.to;
+            rects.push(...markerRectsForLineRange(view, from, to, line.from, line.to, includesLineBreak, base));
+
+            const next = line.to + 1;
+            if (next <= pos) break;
+            pos = next;
+          }
+        }
+
+        rects.sort((a, b) => a.top - b.top || a.left - b.left);
+        rects.forEach((rect, index) => {
+          markers.push(new RectangleMarker(markerClass(rects, index), rect.left, rect.top, rect.width, rect.height));
+        });
+      }
+
+      return markers;
+    },
+    update(update) {
+      return update.docChanged || update.selectionSet || update.viewportChanged || update.geometryChanged;
+    },
+  });
+}
diff --git a/apps/desktop/src/lib/editor/editorSearchQuery.ts b/apps/desktop/src/lib/editor/editorSearchQuery.ts
new file mode 100644
index 0000000..2a8ca66
--- /dev/null
+++ b/apps/desktop/src/lib/editor/editorSearchQuery.ts
@@ -0,0 +1,18 @@
+import { SearchQuery } from "@codemirror/search";
+
+export interface EditorSearchQueryOptions {
+  search: string;
+  replace?: string;
+  caseSensitive: boolean;
+  useRegex: boolean;
+}
+
+export function createEditorSearchQuery(options: EditorSearchQueryOptions): SearchQuery {
+  return new SearchQuery({
+    search: options.search,
+    replace: options.replace ?? "",
+    caseSensitive: options.caseSensitive,
+    regexp: options.useRegex,
+    literal: !options.useRegex,
+  });
+}
diff --git a/apps/desktop/src/lib/editor/editorThemes.ts b/apps/desktop/src/lib/editor/editorThemes.ts
new file mode 100644
index 0000000..9f99bca
--- /dev/null
+++ b/apps/desktop/src/lib/editor/editorThemes.ts
@@ -0,0 +1,973 @@
+import type { Extension } from "@codemirror/state";
+import type { EditorTheme, CustomThemeColors } from "@/stores/settingsStore";
+import type { AppThemeAppearance, AppThemePalette } from "@/lib/app/appTheme";
+import { HighlightStyle, syntaxHighlighting } from "@codemirror/language";
+import { tags } from "@lezer/highlight";
+
+type CodeMirrorStyleSpec = Parameters<typeof import("@codemirror/view").EditorView.theme>[0];
+type LucideIconNode = Array<[string, Record<string, string>]>;
+
+export const EDITOR_FONT_SIZE_CSS_VAR = "--dbx-editor-font-size";
+export const EDITOR_FONT_FAMILY_CSS_VAR = "--dbx-editor-font-family";
+const EDITOR_SELECTION_BACKGROUND_CSS_VAR = "--dbx-editor-selection-background";
+
+export function createRunStatementButtonDom(ariaLabel = "Execute statement"): HTMLButtonElement {
+  const marker = document.createElement("button");
+  marker.className = "cm-run-statement-marker cm-run-statement-marker--active";
+  marker.setAttribute("type", "button");
+  marker.setAttribute("aria-label", ariaLabel);
+  marker.innerHTML =
+    '<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 5a2 2 0 0 1 3.008-1.728l11.997 6.998a2 2 0 0 1 .003 3.458l-12 7A2 2 0 0 1 5 19z"></path></svg>';
+  return marker;
+}
+
+const SUPPORTS_COLOR_MIX = typeof CSS !== "undefined" && typeof CSS.supports === "function" && CSS.supports("color", "color-mix(in oklch, black 50%, white)");
+const SUPPORTS_OKLCH = typeof CSS !== "undefined" && typeof CSS.supports === "function" && CSS.supports("color", "oklch(0.62 0.19 255)");
+
+// ==================== 自定义主题配置 ====================
+// 在这里修改你喜欢的颜色！
+
+const customThemeColors = {
+  lineNumber: "#6c7086", // 行号颜色
+  lineNumberActive: "#cdd6f4", // 当前行号颜色
+  selection: "#313244", // 选中文本背景
+  cursor: "#f5e0dc", // 光标颜色
+
+  // 语法高亮颜色
+  keyword: "#cba6f7", // 关键字 (SELECT, FROM, WHERE 等)
+  string: "#a6e3a1", // 字符串
+  number: "#fab387", // 数字
+  comment: "#6c7086", // 注释
+  type: "#89b4fa", // 类型 (INTEGER, TEXT 等)
+  variable: "#f38ba8", // 变量
+  function: "#89dceb", // 函数
+  operator: "#89b4fa", // 运算符
+  punctuation: "#9399b2", // 标点符号
+  property: "#f9e2af", // 属性/字段名
+  tag: "#cba6f7", // XML/HTML 标签
+  attribute: "#fab387", // 属性名
+  className: "#f9e2af", // 类名
+
+  // UI 元素
+  gutterBackground: "#181825", // 侧边栏背景
+  activeLine: "#313244", // 当前行高亮
+  matchingBracket: "#45475a", // 匹配括号背景
+
+  // 特殊
+  builtin: "#89dceb", // 内置函数
+  meta: "#cdd6f4", // 元信息
+  invalid: "#f38ba8", // 无效字符
+};
+
+/** 创建自定义 CodeMirror 主题 */
+function createCustomTheme(EditorView: typeof import("@codemirror/view").EditorView, colors?: CustomThemeColors, isDark: boolean = true): Extension {
+  // 根据系统主题设置默认背景色和前景色
+  const defaultColors = isDark ? { background: "#1e1e2e", foreground: "#cdd6f4" } : { background: "#fafafa", foreground: "#242424" };
+
+  const c = { ...defaultColors, ...customThemeColors, ...colors };
+
+  // 映射用户自定义属性名到 CodeMirror 内部属性名
+  if (colors) {
+    if (colors.field) {
+      c.variable = colors.field;
+      c.property = colors.field;
+    }
+    if (colors.table) {
+      // 表名通常被识别为 propertyName，如果单独设置了表名颜色则覆盖
+      c.property = colors.table;
+    }
+  }
+
+  const theme = EditorView.theme(
+    {
+      "&": {
+        backgroundColor: c.background,
+        color: c.foreground,
+        [EDITOR_SELECTION_BACKGROUND_CSS_VAR]: c.selection,
+      },
+      ".cm-content": {
+        caretColor: c.cursor,
+      },
+      ".cm-cursor": {
+        borderLeftColor: c.cursor,
+      },
+      "&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection": {
+        backgroundColor: c.selection,
+      },
+      ".cm-activeLine": {
+        backgroundColor: c.activeLine,
+      },
+      ".cm-gutters": {
+        backgroundColor: c.gutterBackground,
+        color: c.lineNumber,
+        borderRight: "1px solid #313244",
+      },
+      ".cm-activeLineGutter": {
+        backgroundColor: c.activeLine,
+        color: c.lineNumberActive,
+      },
+      ".cm-matchingBracket": {
+        backgroundColor: c.matchingBracket,
+        outline: "none",
+      },
+    },
+    { dark: isDark },
+  );
+
+  const highlightStyle = HighlightStyle.define([
+    { tag: tags.keyword, color: c.keyword },
+    { tag: tags.controlKeyword, color: c.keyword },
+    { tag: tags.definitionKeyword, color: c.keyword },
+    { tag: tags.moduleKeyword, color: c.keyword },
+    { tag: tags.operatorKeyword, color: c.keyword },
+    { tag: tags.string, color: c.string },
+    { tag: tags.special(tags.string), color: c.string },
+    { tag: tags.number, color: c.number },
+    { tag: tags.integer, color: c.number },
+    { tag: tags.float, color: c.number },
+    { tag: tags.comment, color: c.comment, fontStyle: "italic" },
+    { tag: tags.lineComment, color: c.comment, fontStyle: "italic" },
+    { tag: tags.blockComment, color: c.comment, fontStyle: "italic" },
+    { tag: tags.typeName, color: c.type },
+    { tag: tags.typeOperator, color: c.type },
+    { tag: tags.name, color: c.variable }, // ← 添加：普通标识符（字段名、表名等）
+    { tag: tags.variableName, color: c.variable },
+    { tag: tags.definition(tags.variableName), color: c.variable },
+    { tag: tags.function(tags.variableName), color: c.function },
+    { tag: tags.function(tags.propertyName), color: c.function },
+    { tag: tags.standard(tags.variableName), color: c.builtin },
+    { tag: tags.propertyName, color: c.property },
+    { tag: tags.operator, color: c.operator },
+    { tag: tags.compareOperator, color: c.operator },
+    { tag: tags.logicOperator, color: c.operator },
+    { tag: tags.arithmeticOperator, color: c.operator },
+    { tag: tags.punctuation, color: c.punctuation },
+    { tag: tags.paren, color: c.punctuation },
+    { tag: tags.brace, color: c.punctuation },
+    { tag: tags.bracket, color: c.punctuation },
+    { tag: tags.tagName, color: c.tag },
+    { tag: tags.attributeName, color: c.attribute },
+    { tag: tags.attributeValue, color: c.string },
+    { tag: tags.className, color: c.className },
+    { tag: tags.bool, color: c.keyword },
+    { tag: tags.null, color: c.keyword },
+    { tag: tags.meta, color: c.meta },
+    { tag: tags.invalid, color: c.invalid },
+    { tag: tags.heading, color: c.keyword, fontWeight: "bold" },
+    { tag: tags.heading1, color: c.keyword, fontWeight: "bold" },
+    { tag: tags.heading2, color: c.keyword, fontWeight: "bold" },
+    { tag: tags.heading3, color: c.keyword, fontWeight: "bold" },
+    { tag: tags.strong, color: c.foreground, fontWeight: "bold" },
+    { tag: tags.emphasis, color: c.foreground, fontStyle: "italic" },
+    { tag: tags.link, color: c.type, textDecoration: "underline" },
+    { tag: tags.url, color: c.type, textDecoration: "underline" },
+    { tag: tags.labelName, color: c.property },
+    { tag: tags.namespace, color: c.className },
+    { tag: tags.macroName, color: c.function },
+    { tag: tags.literal, color: c.string },
+    { tag: tags.special(tags.string), color: c.string },
+    { tag: tags.regexp, color: c.string },
+    { tag: tags.escape, color: c.string },
+    { tag: tags.processingInstruction, color: c.keyword },
+    { tag: tags.inserted, color: c.string },
+    { tag: tags.deleted, color: c.invalid },
+    { tag: tags.changed, color: c.property },
+    { tag: tags.self, color: c.keyword },
+    { tag: tags.derefOperator, color: c.operator },
+    { tag: tags.unit, color: c.type },
+    { tag: tags.angleBracket, color: c.punctuation },
+    { tag: tags.annotation, color: c.property },
+    { tag: tags.modifier, color: c.keyword },
+    { tag: tags.list, color: c.foreground },
+    { tag: tags.quote, color: c.string, fontStyle: "italic" },
+    { tag: tags.monospace, color: c.foreground },
+    { tag: tags.strikethrough, color: c.invalid, textDecoration: "line-through" },
+    { tag: tags.contentSeparator, color: c.operator },
+    { tag: tags.special(tags.name), color: c.builtin },
+  ]);
+
+  return [theme, syntaxHighlighting(highlightStyle)];
+}
+
+type IdeEditorThemeColors = {
+  dark: boolean;
+  background: string;
+  foreground: string;
+  selection: string;
+  selectionMatch: string;
+  cursor: string;
+  gutterBackground: string;
+  gutterForeground: string;
+  gutterActiveForeground: string;
+  activeLine: string;
+  matchingBracket: string;
+  gutterBorder: string;
+  keyword: string;
+  string: string;
+  number: string;
+  comment: string;
+  type: string;
+  variable: string;
+  function: string;
+  operator: string;
+  punctuation: string;
+  property: string;
+  builtin: string;
+  meta: string;
+  invalid: string;
+  tag: string;
+  attribute: string;
+  className: string;
+  keywordBold?: boolean;
+  stringBold?: boolean;
+  numberBold?: boolean;
+};
+
+const IDE_EDITOR_THEMES = {
+  ideaLight: {
+    dark: false,
+    background: "#ffffff",
+    foreground: "#080808",
+    selection: "#a6d2ff",
+    selectionMatch: "#93d9d9",
+    cursor: "#000000",
+    gutterBackground: "#f2f2f2",
+    gutterForeground: "#adadad",
+    gutterActiveForeground: "#767a8a",
+    activeLine: "#fcfaed",
+    matchingBracket: "#93d9d9",
+    gutterBorder: "#d4d4d4",
+    keyword: "#0033b3",
+    string: "#067d17",
+    number: "#1750eb",
+    comment: "#8c8c8c",
+    type: "#0033b3",
+    variable: "#174ad4",
+    function: "#00627a",
+    operator: "#080808",
+    punctuation: "#080808",
+    property: "#871094",
+    builtin: "#0033b3",
+    meta: "#9e880d",
+    invalid: "#f50000",
+    tag: "#0033b3",
+    attribute: "#871094",
+    className: "#174be6",
+    keywordBold: true,
+    stringBold: true,
+    numberBold: true,
+  },
+  ideaDark: {
+    dark: true,
+    background: "#2b2b2b",
+    foreground: "#a9b7c6",
+    selection: "#214283",
+    selectionMatch: "#3b514d",
+    cursor: "#bbbbbb",
+    gutterBackground: "#313335",
+    gutterForeground: "#606366",
+    gutterActiveForeground: "#a4a3a3",
+    activeLine: "#323232",
+    matchingBracket: "#3b514d",
+    gutterBorder: "#4d4d4d",
+    keyword: "#cc7832",
+    string: "#6a8759",
+    number: "#6897bb",
+    comment: "#808080",
+    type: "#a9b7c6",
+    variable: "#a9b7c6",
+    function: "#ffc66d",
+    operator: "#cc7832",
+    punctuation: "#a9b7c6",
+    property: "#9876aa",
+    builtin: "#cc7832",
+    meta: "#bbb529",
+    invalid: "#ff0000",
+    tag: "#e8bf6a",
+    attribute: "#bababa",
+    className: "#a9b7c6",
+  },
+  jetbrainsLight: {
+    dark: false,
+    background: "#ffffff",
+    foreground: "#080808",
+    selection: "#a6d2ff",
+    selectionMatch: "#c9ecec",
+    cursor: "#000000",
+    gutterBackground: "#ffffff",
+    gutterForeground: "#aeb3c2",
+    gutterActiveForeground: "#767a8a",
+    activeLine: "#f5f8fe",
+    matchingBracket: "#93d9d9",
+    gutterBorder: "#ebecf0",
+    keyword: "#0033b3",
+    string: "#067d17",
+    number: "#1750eb",
+    comment: "#8c8c8c",
+    type: "#0033b3",
+    variable: "#174ad4",
+    function: "#00627a",
+    operator: "#080808",
+    punctuation: "#080808",
+    property: "#871094",
+    builtin: "#0033b3",
+    meta: "#9e880d",
+    invalid: "#f50000",
+    tag: "#0033b3",
+    attribute: "#871094",
+    className: "#174be6",
+    keywordBold: true,
+    stringBold: true,
+    numberBold: true,
+  },
+  jetbrainsDark: {
+    dark: true,
+    background: "#1e1f22",
+    foreground: "#bcbec4",
+    selection: "#2e436e",
+    selectionMatch: "#114957",
+    cursor: "#ced0d6",
+    gutterBackground: "#1e1f22",
+    gutterForeground: "#4b5059",
+    gutterActiveForeground: "#a1a3ab",
+    activeLine: "#26282e",
+    matchingBracket: "#43454a",
+    gutterBorder: "#313438",
+    keyword: "#cf8e6d",
+    string: "#6aab73",
+    number: "#2aacb8",
+    comment: "#7a7e85",
+    type: "#cf8e6d",
+    variable: "#bcbec4",
+    function: "#56a8f5",
+    operator: "#bcbec4",
+    punctuation: "#bcbec4",
+    property: "#c77dbb",
+    builtin: "#cf8e6d",
+    meta: "#b3ae60",
+    invalid: "#f75464",
+    tag: "#2fbaa3",
+    attribute: "#b3ae60",
+    className: "#56a8f5",
+  },
+  cursorLight: {
+    dark: false,
+    background: "#fcfcfc",
+    foreground: "#141414eb",
+    selection: "#1414141e",
+    selectionMatch: "#14141411",
+    cursor: "#141414eb",
+    gutterBackground: "#fcfcfc",
+    gutterForeground: "#1414147a",
+    gutterActiveForeground: "#141414ad",
+    activeLine: "#ededed",
+    matchingBracket: "#1414141e",
+    gutterBorder: "#14141413",
+    keyword: "#b3003f",
+    string: "#9e94d5",
+    number: "#b8448b",
+    comment: "#141414ad",
+    type: "#206595",
+    variable: "#206595",
+    function: "#db704b",
+    operator: "#b3003f",
+    punctuation: "#141414eb",
+    property: "#1f8a65",
+    builtin: "#206595",
+    meta: "#1f8a65",
+    invalid: "#cf2d56",
+    tag: "#206595",
+    attribute: "#6049b3",
+    className: "#206595",
+  },
+  cursorDark: {
+    dark: true,
+    background: "#181818",
+    foreground: "#e4e4e4eb",
+    selection: "#40404099",
+    selectionMatch: "#404040cc",
+    cursor: "#e4e4e4eb",
+    gutterBackground: "#181818",
+    gutterForeground: "#e4e4e442",
+    gutterActiveForeground: "#e4e4e4eb",
+    activeLine: "#262626",
+    matchingBracket: "#e4e4e41e",
+    gutterBorder: "#e4e4e413",
+    keyword: "#82d2ce",
+    string: "#e394dc",
+    number: "#ebc88d",
+    comment: "#e4e4e45e",
+    type: "#efb080",
+    variable: "#87c3ff",
+    function: "#efb080",
+    operator: "#d6d6dd",
+    punctuation: "#d6d6dd",
+    property: "#82d2ce",
+    builtin: "#a8cc7c",
+    meta: "#a8cc7c",
+    invalid: "#e34671",
+    tag: "#82d2ce",
+    attribute: "#aaa0fa",
+    className: "#efb080",
+  },
+  claudeLight: {
+    dark: false,
+    background: "#fffdf8",
+    foreground: "#302820",
+    selection: "#ead8c6",
+    selectionMatch: "#e7d8c8",
+    cursor: "#b86b3c",
+    gutterBackground: "#f8f1e9",
+    gutterForeground: "#9a7f66",
+    gutterActiveForeground: "#5f4b3a",
+    activeLine: "#f4e9de",
+    matchingBracket: "#e2c9b1",
+    gutterBorder: "#ddcdbb",
+    keyword: "#9a4f2e",
+    string: "#4f7d5d",
+    number: "#2d6f91",
+    comment: "#8c745f",
+    type: "#7a5aa8",
+    variable: "#3e5f75",
+    function: "#b86b3c",
+    operator: "#6b5544",
+    punctuation: "#6b5544",
+    property: "#9a4f2e",
+    builtin: "#4f7d5d",
+    meta: "#8f6b2e",
+    invalid: "#c3493d",
+    tag: "#7a5aa8",
+    attribute: "#b86b3c",
+    className: "#7a5aa8",
+  },
+  claudeDark: {
+    dark: true,
+    background: "#211f1c",
+    foreground: "#d8d0c4",
+    selection: "#44382f",
+    selectionMatch: "#564539",
+    cursor: "#d28a5f",
+    gutterBackground: "#1b1917",
+    gutterForeground: "#8f7f70",
+    gutterActiveForeground: "#d8d0c4",
+    activeLine: "#2a2723",
+    matchingBracket: "#564539",
+    gutterBorder: "#7f6c5b59",
+    keyword: "#d28a5f",
+    string: "#74b195",
+    number: "#65a1c6",
+    comment: "#a39686",
+    type: "#a08fcd",
+    variable: "#d8d0c4",
+    function: "#d69a6b",
+    operator: "#e0d0c0",
+    punctuation: "#c9b9a7",
+    property: "#d28a5f",
+    builtin: "#74b195",
+    meta: "#d4ae63",
+    invalid: "#e2675f",
+    tag: "#a08fcd",
+    attribute: "#d69a6b",
+    className: "#a08fcd",
+  },
+} satisfies Record<string, IdeEditorThemeColors>;
+
+function createIdeEditorTheme(EditorView: typeof import("@codemirror/view").EditorView, c: IdeEditorThemeColors): Extension {
+  const theme = EditorView.theme(
+    {
+      "&": {
+        backgroundColor: c.background,
+        color: c.foreground,
+        [EDITOR_SELECTION_BACKGROUND_CSS_VAR]: c.selection,
+      },
+      ".cm-scroller": {
+        backgroundColor: c.background,
+      },
+      ".cm-content": {
+        caretColor: c.cursor,
+      },
+      ".cm-cursor": {
+        borderLeftColor: c.cursor,
+      },
+      "&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection": {
+        backgroundColor: c.selection,
+      },
+      ".cm-selectionMatch": {
+        backgroundColor: c.selectionMatch,
+      },
+      ".cm-activeLine": {
+        backgroundColor: c.activeLine,
+      },
+      ".cm-gutters": {
+        backgroundColor: c.gutterBackground,
+        borderRight: `1px solid ${c.gutterBorder}`,
+        color: c.gutterForeground,
+      },
+      ".cm-activeLineGutter": {
+        backgroundColor: c.activeLine,
+        color: c.gutterActiveForeground,
+      },
+      ".cm-matchingBracket": {
+        backgroundColor: c.matchingBracket,
+        outline: "none",
+      },
+    },
+    { dark: c.dark },
+  );
+
+  const highlightStyle = HighlightStyle.define([
+    { tag: [tags.keyword, tags.controlKeyword, tags.definitionKeyword, tags.moduleKeyword, tags.operatorKeyword, tags.modifier, tags.bool, tags.null], color: c.keyword, ...(c.keywordBold ? { fontWeight: "bold" } : {}) },
+    { tag: [tags.string, tags.special(tags.string), tags.regexp, tags.escape, tags.inserted], color: c.string, ...(c.stringBold ? { fontWeight: "bold" } : {}) },
+    { tag: [tags.number, tags.integer, tags.float], color: c.number, ...(c.numberBold ? { fontWeight: "bold" } : {}) },
+    { tag: [tags.comment, tags.lineComment, tags.blockComment, tags.quote], color: c.comment, fontStyle: "italic" },
+    { tag: [tags.typeName, tags.typeOperator, tags.unit], color: c.type },
+    { tag: [tags.name, tags.variableName, tags.definition(tags.variableName)], color: c.variable },
+    { tag: [tags.function(tags.variableName), tags.function(tags.propertyName), tags.function(tags.name), tags.macroName], color: c.function },
+    { tag: [tags.standard(tags.variableName), tags.special(tags.name)], color: c.builtin },
+    { tag: [tags.propertyName, tags.labelName, tags.annotation], color: c.property },
+    { tag: [tags.operator, tags.compareOperator, tags.logicOperator, tags.arithmeticOperator, tags.derefOperator], color: c.operator },
+    { tag: [tags.punctuation, tags.separator, tags.paren, tags.brace, tags.bracket, tags.angleBracket], color: c.punctuation },
+    { tag: tags.tagName, color: c.tag },
+    { tag: tags.attributeName, color: c.attribute },
+    { tag: tags.attributeValue, color: c.string },
+    { tag: [tags.className, tags.namespace], color: c.className },
+    { tag: [tags.meta, tags.processingInstruction], color: c.meta },
+    { tag: tags.invalid, color: c.invalid },
+    { tag: [tags.heading, tags.heading1, tags.heading2, tags.heading3], color: c.keyword, fontWeight: "bold" },
+    { tag: tags.strong, color: c.foreground, fontWeight: "bold" },
+    { tag: tags.emphasis, color: c.foreground, fontStyle: "italic" },
+    { tag: [tags.link, tags.url], color: c.type, textDecoration: "underline" },
+    { tag: tags.literal, color: c.string },
+    { tag: tags.deleted, color: c.invalid },
+    { tag: tags.changed, color: c.property },
+    { tag: tags.self, color: c.keyword },
+    { tag: tags.list, color: c.foreground },
+    { tag: tags.monospace, color: c.foreground },
+    { tag: tags.strikethrough, color: c.invalid, textDecoration: "line-through" },
+    { tag: tags.contentSeparator, color: c.operator },
+  ]);
+
+  return [theme, syntaxHighlighting(highlightStyle)];
+}
+
+async function loadIdeEditorTheme(colors: IdeEditorThemeColors): Promise<Extension> {
+  return createIdeEditorTheme((await import("@codemirror/view")).EditorView, colors);
+}
+
+// ======================================================
+
+const TABLE_ICON: LucideIconNode = [
+  ["path", { d: "M12 3v18" }],
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2" }],
+  ["path", { d: "M3 9h18" }],
+  ["path", { d: "M3 15h18" }],
+];
+
+const COLUMNS_ICON: LucideIconNode = [
+  ["rect", { width: "18", height: "18", x: "3", y: "3", rx: "2" }],
+  ["path", { d: "M12 3v18" }],
+];
+
+const KEYWORD_ICON: LucideIconNode = [
+  ["path", { d: "m16 18 6-6-6-6" }],
+  ["path", { d: "m8 6-6 6 6 6" }],
+];
+
+const SNIPPET_ICON: LucideIconNode = [
+  ["path", { d: "M8 3H7a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h1" }],
+  ["path", { d: "M16 3h1a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-1" }],
+];
+
+const FUNCTION_ICON: LucideIconNode = [
+  ["path", { d: "m15 10 5 5-5 5" }],
+  ["path", { d: "M4 4v7a4 4 0 0 0 4 4h12" }],
+];
+
+const SCHEMA_ICON: LucideIconNode = [["path", { d: "M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2v11z" }]];
+
+function encodeSvgIcon(iconNode: LucideIconNode): string {
+  const body = iconNode
+    .map(
+      ([tag, attrs]) =>
+        `<${tag} ${Object.entries(attrs)
+          .map(([key, value]) => `${key}="${value}"`)
+          .join(" ")} />`,
+    )
+    .join("");
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="black" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">${body}</svg>`;
+  return `url("data:image/svg+xml,${encodeURIComponent(svg)}")`;
+}
+
+function lucideCompletionIconMask(iconNode: LucideIconNode) {
+  const mask = encodeSvgIcon(iconNode);
+  return {
+    "--dbx-completion-icon-mask": mask,
+  };
+}
+
+function colorMixValue(fallback: string, preferred: string): string {
+  return SUPPORTS_COLOR_MIX ? preferred : fallback;
+}
+
+function oklchValue(fallback: string, preferred: string): string {
+  return SUPPORTS_OKLCH ? preferred : fallback;
+}
+
+export function cellDetailActiveLineColor(): string {
+  return colorMixValue("var(--accent)", "color-mix(in oklch, var(--foreground) 4%, transparent)");
+}
+
+/** Resolve the concrete CodeMirror theme used by the "Follow app theme" setting. */
+export function resolveEditorTheme(theme: EditorTheme, appAppearance: AppThemeAppearance, appPalette: AppThemePalette = "pearl"): Exclude<EditorTheme, "app"> {
+  if (theme === "app") {
+    switch (appPalette) {
+      case "vscode":
+        return appAppearance === "dark" ? "vscode-dark" : "vscode-light";
+      case "idea":
+        return appAppearance === "dark" ? "idea-dark" : "idea-light";
+      case "xcode":
+        return appAppearance === "dark" ? "xcode-dark" : "xcode";
+      case "jetbrains":
+        return appAppearance === "dark" ? "jetbrains-dark" : "jetbrains-light";
+      case "cursor":
+        return appAppearance === "dark" ? "cursor-dark" : "cursor-light";
+      case "claude":
+        return appAppearance === "dark" ? "claude-dark" : "claude-light";
+      default:
+        return appAppearance === "dark" ? "one-dark" : "vscode-light";
+    }
+  }
+  return theme;
+}
+
+/** Load a CodeMirror theme extension by theme name. */
+export async function loadEditorTheme(theme: EditorTheme, appAppearance: AppThemeAppearance = "dark", customColors?: CustomThemeColors, appPalette: AppThemePalette = "pearl"): Promise<Extension> {
+  const resolvedTheme = resolveEditorTheme(theme, appAppearance, appPalette);
+  switch (resolvedTheme) {
+    case "one-dark":
+      return (await import("@codemirror/theme-one-dark")).oneDark;
+    case "vscode-dark":
+      return (await import("@uiw/codemirror-theme-vscode")).vscodeDark;
+    case "vscode-light":
+      return (await import("@uiw/codemirror-theme-vscode")).vscodeLight;
+    case "nord":
+      return (await import("@uiw/codemirror-theme-nord")).nord;
+    case "okaidia":
+      return (await import("@uiw/codemirror-theme-okaidia")).okaidia;
+    case "material":
+      return (await import("@uiw/codemirror-theme-material")).materialDark;
+    case "duotone-light":
+      return (await import("@uiw/codemirror-theme-duotone")).duotoneLight;
+    case "duotone-dark":
+      return (await import("@uiw/codemirror-theme-duotone")).duotoneDark;
+    case "xcode":
+      return (await import("@uiw/codemirror-theme-xcode")).xcodeLight;
+    case "xcode-dark":
+      return (await import("@uiw/codemirror-theme-xcode")).xcodeDark;
+    case "idea-light":
+      return loadIdeEditorTheme(IDE_EDITOR_THEMES.ideaLight);
+    case "idea-dark":
+      return loadIdeEditorTheme(IDE_EDITOR_THEMES.ideaDark);
+    case "jetbrains-light":
+      return loadIdeEditorTheme(IDE_EDITOR_THEMES.jetbrainsLight);
+    case "jetbrains-dark":
+      return loadIdeEditorTheme(IDE_EDITOR_THEMES.jetbrainsDark);
+    case "cursor-light":
+      return loadIdeEditorTheme(IDE_EDITOR_THEMES.cursorLight);
+    case "cursor-dark":
+      return loadIdeEditorTheme(IDE_EDITOR_THEMES.cursorDark);
+    case "claude-light":
+      return loadIdeEditorTheme(IDE_EDITOR_THEMES.claudeLight);
+    case "claude-dark":
+      return loadIdeEditorTheme(IDE_EDITOR_THEMES.claudeDark);
+    case "custom":
+      return createCustomTheme((await import("@codemirror/view")).EditorView, customColors, appAppearance === "dark");
+    default:
+      return (await import("@codemirror/theme-one-dark")).oneDark;
+  }
+}
+
+export function buildEditorFontThemeRules(opts?: { fixedHeight?: boolean; scrollable?: boolean }, defaults?: { size?: number; family?: string }): CodeMirrorStyleSpec {
+  return {
+    "&": {
+      ...(opts?.fixedHeight ? { height: "100%" } : {}),
+      fontSize: `var(${EDITOR_FONT_SIZE_CSS_VAR}, ${defaults?.size ?? 13}px)`,
+    },
+    ...(opts?.scrollable ? { ".cm-scroller": { overflowX: "auto", overflowY: "auto" } } : {}),
+    ".cm-content": {
+      fontFamily: `var(${EDITOR_FONT_FAMILY_CSS_VAR}, ${defaults?.family ?? "monospace"})`,
+      lineHeight: "1.6",
+      padding: "0",
+    },
+    ".cm-line": {
+      padding: "0 2px !important",
+    },
+    ".cm-selectionLayer .cm-selectionBackground": {
+      display: "none",
+    },
+    ".cm-cursor": {
+      height: "1.6em !important",
+      transform: "translateY(-0.3em)",
+    },
+    ".cm-trimmedSelection": {
+      backgroundColor: `var(${EDITOR_SELECTION_BACKGROUND_CSS_VAR}, rgb(148 163 184 / 38%))`,
+      borderRadius: "0",
+    },
+    ".cm-trimmedSelection-topLeft": {
+      borderTopLeftRadius: "3px",
+    },
+    ".cm-trimmedSelection-topRight": {
+      borderTopRightRadius: "3px",
+    },
+    ".cm-trimmedSelection-bottomLeft": {
+      borderBottomLeftRadius: "3px",
+    },
+    ".cm-trimmedSelection-bottomRight": {
+      borderBottomRightRadius: "3px",
+    },
+    ".cm-gutters": {
+      borderRight: "0 !important",
+      fontSize: `var(${EDITOR_FONT_SIZE_CSS_VAR}, ${defaults?.size ?? 13}px)`,
+      fontFamily: `var(${EDITOR_FONT_FAMILY_CSS_VAR}, ${defaults?.family ?? "monospace"})`,
+      position: "relative",
+      userSelect: "none",
+    },
+    ".cm-gutters:after": {
+      background: "rgba(148, 163, 184, 0.38)",
+      bottom: "0",
+      content: "''",
+      pointerEvents: "none",
+      position: "absolute",
+      right: "0",
+      top: "0",
+      width: "1px",
+      zIndex: "10",
+    },
+    ".cm-lineNumbers .cm-gutterElement": {
+      cursor: "pointer",
+      paddingRight: "16px",
+      userSelect: "none",
+    },
+    ".cm-run-statement-gutter": {
+      minWidth: "34px",
+    },
+    ".cm-run-statement-gutter .cm-gutterElement": {
+      alignItems: "center",
+      boxSizing: "border-box",
+      display: "flex",
+      justifyContent: "center",
+      minWidth: "34px",
+      padding: "0 5px",
+    },
+    ".cm-run-statement-marker": {
+      alignItems: "center",
+      background: "transparent",
+      border: "1px solid transparent",
+      borderRadius: "6px",
+      boxSizing: "border-box",
+      color: "transparent",
+      display: "inline-flex",
+      flexShrink: "0",
+      height: `min(24px, calc(var(${EDITOR_FONT_SIZE_CSS_VAR}, ${defaults?.size ?? 13}px) * 1.6))`,
+      justifyContent: "center",
+      margin: "0",
+      outline: "none",
+      padding: "0",
+      transition: "color 0.15s, background-color 0.15s",
+      userSelect: "none",
+      verticalAlign: "middle",
+      whiteSpace: "nowrap",
+      width: `min(24px, calc(var(${EDITOR_FONT_SIZE_CSS_VAR}, ${defaults?.size ?? 13}px) * 1.6))`,
+    },
+    ".cm-run-statement-marker--active": {
+      background: "rgb(16 185 129 / 0.1)",
+      color: "rgb(4 120 87)",
+      cursor: "pointer",
+    },
+    ".cm-run-statement-marker--active:hover": {
+      background: "rgb(16 185 129 / 0.2)",
+      color: "rgb(6 95 70)",
+    },
+    "&.cm-editor .cm-run-statement-marker svg": {
+      display: "block",
+      flexShrink: "0",
+      height: "min(14px, 70%)",
+      pointerEvents: "none",
+      width: "min(14px, 70%)",
+    },
+    "&.cm-editor.cm-focused .cm-run-statement-marker:focus-visible": {
+      outline: "1px solid var(--ring)",
+      outlineOffset: "1px",
+    },
+    "&.cm-editor .cm-run-statement-marker--executed": {
+      background: "rgb(16 185 129 / 0.18)",
+      color: "rgb(6 95 70)",
+    },
+    "&.cm-editor .cm-settings-preview-run-highlight": {
+      background: "rgb(16 185 129 / 0.12)",
+    },
+    ".dark &.cm-editor .cm-run-statement-marker--active": {
+      color: "rgb(110 231 183)",
+    },
+    ".dark &.cm-editor .cm-run-statement-marker--active:hover, .dark &.cm-editor .cm-run-statement-marker--executed": {
+      color: "rgb(167 243 208)",
+    },
+  };
+}
+
+/** Build a CodeMirror theme extension for font size + font family. */
+export function editorFontTheme(EditorView: typeof import("@codemirror/view").EditorView, size: number, family: string, opts?: { fixedHeight?: boolean; scrollable?: boolean }): Extension {
+  return EditorView.theme(buildEditorFontThemeRules(opts, { size, family }));
+}
+
+export function buildSqlCompletionThemeRules(): CodeMirrorStyleSpec {
+  return {
+    ".cm-tooltip.cm-tooltip-autocomplete": {
+      background: "var(--popover)",
+      backgroundClip: "padding-box",
+      border: colorMixValue("1px solid var(--border)", "1px solid color-mix(in oklch, var(--border) 82%, var(--foreground) 18%)"),
+      borderRadius: "8px",
+      boxShadow: "0 8px 18px rgb(0 0 0 / 0.14)",
+      color: "var(--popover-foreground)",
+      fontFamily: `var(${EDITOR_FONT_FAMILY_CSS_VAR}, var(--font-mono, monospace))`,
+      maxWidth: "min(760px, calc(100vw - 24px))",
+      minWidth: "min(280px, calc(100vw - 24px))",
+      overflowX: "hidden",
+      overflowY: "hidden",
+      padding: "4px 0",
+      scrollbarColor: colorMixValue("var(--muted-foreground) transparent", "color-mix(in oklch, var(--muted-foreground) 44%, transparent) transparent"),
+      scrollbarWidth: "thin",
+      zIndex: "9999",
+    },
+    ".cm-tooltip.cm-tooltip-autocomplete *": {
+      boxSizing: "border-box",
+    },
+    ".cm-tooltip.cm-tooltip-autocomplete > ul": {
+      maxHeight: "min(280px, calc(100vh - 32px))",
+      minWidth: "min(280px, calc(100vw - 24px))",
+      maxWidth: "inherit",
+      overflowX: "hidden",
+      overflowY: "auto",
+      padding: "0 4px 0 !important",
+      scrollbarColor: colorMixValue("var(--muted-foreground) transparent", "color-mix(in oklch, var(--muted-foreground) 44%, transparent) transparent"),
+      scrollbarWidth: "thin",
+      width: "max-content",
+    },
+    ".cm-tooltip.cm-tooltip-autocomplete > ul > li": {
+      alignItems: "center",
+      borderRadius: "6px",
+      color: "var(--popover-foreground)",
+      display: "flex",
+      fontSize: `clamp(12px, var(${EDITOR_FONT_SIZE_CSS_VAR}, 13px), 14px)`,
+      fontWeight: "520",
+      height: "28px",
+      letterSpacing: "0",
+      lineHeight: "28px",
+      overflow: "hidden",
+      padding: "0 10px !important",
+      textOverflow: "clip",
+      transition: "background-color 90ms ease, color 90ms ease",
+      whiteSpace: "nowrap",
+    },
+    ".cm-tooltip.cm-tooltip-autocomplete > ul > li[aria-selected]": {
+      background: `${colorMixValue("var(--accent)", "color-mix(in oklch, var(--primary) 14%, var(--popover))")} !important`,
+      color: "var(--popover-foreground) !important",
+      outline: colorMixValue("1px solid var(--border)", "1px solid color-mix(in oklch, var(--primary) 22%, transparent)"),
+    },
+    ".cm-completionIcon": {
+      alignItems: "center",
+      display: "inline-flex",
+      flex: "0 0 15px",
+      height: "15px",
+      justifyContent: "center",
+      marginRight: "0.65em",
+      opacity: "1",
+      position: "relative",
+      overflow: "hidden",
+      width: "15px",
+    },
+    ".cm-completionIcon:before": {
+      backgroundColor: "currentColor",
+      content: "''",
+      display: "block",
+      height: "14px",
+      position: "absolute",
+      WebkitMaskImage: "var(--dbx-completion-icon-mask)",
+      WebkitMaskPosition: "center",
+      WebkitMaskRepeat: "no-repeat",
+      WebkitMaskSize: "14px 14px",
+      maskImage: "var(--dbx-completion-icon-mask)",
+      maskPosition: "center",
+      maskRepeat: "no-repeat",
+      maskSize: "14px 14px",
+      width: "14px",
+    },
+    ".cm-completionIcon:after": {
+      content: "'none'",
+      display: "none",
+    },
+    ".cm-completionIcon-table": {
+      color: colorMixValue("var(--primary)", "color-mix(in oklch, var(--primary) 92%, var(--popover-foreground))"),
+      ...lucideCompletionIconMask(TABLE_ICON),
+    },
+    ".cm-completionIcon-column": {
+      color: colorMixValue("var(--blue-500, #3b82f6)", "color-mix(in oklch, var(--blue-500, #3b82f6) 92%, var(--popover-foreground))"),
+      ...lucideCompletionIconMask(COLUMNS_ICON),
+    },
+    ".cm-completionIcon-keyword": {
+      color: colorMixValue("var(--orange-500, #f97316)", "color-mix(in oklch, var(--orange-500, #f97316) 92%, var(--popover-foreground))"),
+      ...lucideCompletionIconMask(KEYWORD_ICON),
+    },
+    ".cm-completionIcon-snippet": {
+      color: colorMixValue("var(--violet-500, #8b5cf6)", "color-mix(in oklch, var(--violet-500, #8b5cf6) 92%, var(--popover-foreground))"),
+      ...lucideCompletionIconMask(SNIPPET_ICON),
+    },
+    ".cm-completionIcon-function": {
+      color: colorMixValue("var(--emerald-500, #10b981)", "color-mix(in oklch, var(--emerald-500, #10b981) 92%, var(--popover-foreground))"),
+      ...lucideCompletionIconMask(FUNCTION_ICON),
+    },
+    ".cm-completionIcon-schema": {
+      color: colorMixValue("var(--amber-500, #f59e0b)", "color-mix(in oklch, var(--amber-500, #f59e0b) 92%, var(--popover-foreground))"),
+      ...lucideCompletionIconMask(SCHEMA_ICON),
+    },
+    ".cm-completionLabel": {
+      color: "inherit",
+      flex: "0 1 auto",
+      fontFamily: `var(${EDITOR_FONT_FAMILY_CSS_VAR}, var(--font-mono, monospace))`,
+      fontSize: `clamp(12px, var(${EDITOR_FONT_SIZE_CSS_VAR}, 13px), 14px)`,
+      fontWeight: "520",
+      letterSpacing: "0",
+      minWidth: "8ch",
+      overflow: "hidden",
+      textOverflow: "ellipsis",
+      whiteSpace: "nowrap",
+    },
+    ".cm-completionMatchedText": {
+      color: oklchValue("rgb(29 132 245)", "oklch(0.62 0.19 255)"),
+      fontWeight: "700",
+      textDecoration: "none",
+    },
+    ".cm-completionDetail": {
+      color: colorMixValue("var(--muted-foreground)", "color-mix(in oklch, var(--popover-foreground) 68%, var(--popover))"),
+      fontSize: `clamp(11px, calc(var(${EDITOR_FONT_SIZE_CSS_VAR}, 13px) - 1px), 13px)`,
+      fontWeight: "500",
+      fontStyle: "normal",
+      flex: "1 1 auto",
+      marginLeft: "10px",
+      minWidth: "0",
+      opacity: "1",
+      overflow: "hidden",
+      textOverflow: "ellipsis",
+      whiteSpace: "nowrap",
+    },
+    ".cm-tooltip.cm-completionInfo": {
+      maxWidth: "min(420px, calc(100vw - 24px))",
+      overflowWrap: "anywhere",
+      zIndex: "10000",
+    },
+  };
+}
+
+export function sqlCompletionTheme(EditorView: typeof import("@codemirror/view").EditorView): Extension {
+  return EditorView.theme(buildSqlCompletionThemeRules());
+}
diff --git a/apps/desktop/src/lib/editor/editorZoom.ts b/apps/desktop/src/lib/editor/editorZoom.ts
new file mode 100644
index 0000000..e609d33
--- /dev/null
+++ b/apps/desktop/src/lib/editor/editorZoom.ts
@@ -0,0 +1,52 @@
+export const EDITOR_MIN_FONT_SIZE = 10;
+export const EDITOR_MAX_FONT_SIZE = 24;
+const WHEEL_FONT_ZOOM_SENSITIVITY = 0.0015;
+
+export function clampEditorFontSize(value: number): number {
+  const clamped = Math.min(EDITOR_MAX_FONT_SIZE, Math.max(EDITOR_MIN_FONT_SIZE, value));
+  return Number(clamped.toFixed(2));
+}
+
+export function fontSizeFromWheelDelta(currentFontSize: number, deltaY: number): number {
+  return clampEditorFontSize(currentFontSize * Math.exp(-deltaY * WHEEL_FONT_ZOOM_SENSITIVITY));
+}
+
+export function fontSizeFromGestureScale(startFontSize: number, scale: number): number {
+  return clampEditorFontSize(startFontSize * scale);
+}
+
+export function createEditorZoomCommitScheduler(commit: (fontSize: number) => void, delayMs = 160) {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  let pendingFontSize: number | null = null;
+
+  const clearPending = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+  };
+
+  return {
+    schedule(fontSize: number) {
+      pendingFontSize = clampEditorFontSize(fontSize);
+      clearPending();
+      timer = setTimeout(() => {
+        timer = null;
+        const next = pendingFontSize;
+        pendingFontSize = null;
+        if (next !== null) commit(next);
+      }, delayMs);
+    },
+    flush(fontSize?: number) {
+      const next = clampEditorFontSize(fontSize ?? pendingFontSize ?? NaN);
+      clearPending();
+      pendingFontSize = null;
+      if (!Number.isNaN(next)) commit(next);
+    },
+    hasPendingCommit() {
+      return timer !== null;
+    },
+    dispose() {
+      clearPending();
+      pendingFontSize = null;
+    },
+  };
+}
diff --git a/apps/desktop/src/lib/editor/keyboardShortcuts.ts b/apps/desktop/src/lib/editor/keyboardShortcuts.ts
new file mode 100644
index 0000000..3bc3945
--- /dev/null
+++ b/apps/desktop/src/lib/editor/keyboardShortcuts.ts
@@ -0,0 +1,191 @@
+import { parseShortcutParts } from "@/lib/editor/shortcutDisplay";
+import { normalizeShortcutSettings, type ShortcutActionId, type ShortcutSettings } from "@/lib/editor/shortcutRegistry";
+
+export interface ShortcutLikeEvent {
+  key: string;
+  metaKey?: boolean;
+  ctrlKey?: boolean;
+  altKey?: boolean;
+  shiftKey?: boolean;
+  isComposing?: boolean;
+}
+
+function normalizeKey(key: string): string {
+  if (key === " ") return "Space";
+  if (key === "+" || key === "Plus") return "Plus";
+  return key.length === 1 ? key.toLowerCase() : key;
+}
+
+function shortcutKeyName(key: string): string | null {
+  if (key === " ") return "Space";
+  if (key === "+") return "Plus";
+  if (["Control", "Meta", "Shift", "Alt"].includes(key)) return null;
+  if (key.length === 1) return key.toUpperCase();
+  return key;
+}
+
+export function eventToShortcut(event: ShortcutLikeEvent): string | null {
+  if (event.isComposing) return null;
+
+  const key = shortcutKeyName(event.key);
+  if (!key) return null;
+
+  const hasModifier = !!event.metaKey || !!event.ctrlKey || !!event.altKey || !!event.shiftKey;
+  if (!hasModifier && event.key.length === 1 && event.key !== " ") return null;
+
+  const parts: string[] = [];
+  if (event.shiftKey) parts.push("Shift");
+  if (event.metaKey || event.ctrlKey) parts.push("Mod");
+  if (event.altKey) parts.push("Alt");
+  parts.push(key);
+  return parts.join("+");
+}
+
+export function matchesShortcut(event: ShortcutLikeEvent, shortcut: string): boolean {
+  if (event.isComposing || !shortcut) return false;
+  const parts = parseShortcutParts(shortcut);
+  const key = parts[parts.length - 1] ?? "";
+  const modifiers = new Set(parts.slice(0, -1));
+  const usesMod = modifiers.has("Mod");
+  const usesMeta = modifiers.has("Meta");
+  const usesCtrl = modifiers.has("Ctrl");
+
+  if (usesMod) {
+    if (!event.metaKey && !event.ctrlKey) return false;
+  } else {
+    if (!!event.metaKey !== usesMeta) return false;
+    if (!!event.ctrlKey !== usesCtrl) return false;
+  }
+
+  if (!!event.altKey !== modifiers.has("Alt")) return false;
+  if (!!event.shiftKey !== modifiers.has("Shift")) return false;
+  return normalizeKey(event.key) === normalizeKey(key);
+}
+
+function actionShortcut(actionId: ShortcutActionId, shortcuts?: Partial<ShortcutSettings>): string {
+  return normalizeShortcutSettings(shortcuts)[actionId];
+}
+
+const SWITCH_TO_TAB_ACTIONS: ShortcutActionId[] = ["switchToTab1", "switchToTab2", "switchToTab3", "switchToTab4", "switchToTab5", "switchToTab6", "switchToTab7", "switchToTab8", "switchToTab9"];
+
+export function isExecuteSqlShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("executeSql", shortcuts));
+}
+
+export function isCloseTabShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("closeTab", shortcuts));
+}
+
+export function isSendSelectionToAiShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("sendSelectionToAi", shortcuts));
+}
+
+export function isNewQueryShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("newQuery", shortcuts));
+}
+
+export function isOpenSettingsShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("openSettings", shortcuts));
+}
+
+export function isFocusSearchShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("focusSearch", shortcuts));
+}
+
+export function isRefreshDataShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("refreshData", shortcuts));
+}
+
+export function isModRShortcut(event: ShortcutLikeEvent): boolean {
+  return matchesShortcut(event, "Mod+R");
+}
+
+export function isZoomInShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  if (matchesShortcut(event, actionShortcut("zoomInUi", shortcuts))) return true;
+  if (event.isComposing || event.altKey) return false;
+  if (!event.metaKey && !event.ctrlKey) return false;
+  return normalizeKey(event.key) === "NumpadAdd" && !event.shiftKey;
+}
+
+export function isZoomOutShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  if (matchesShortcut(event, actionShortcut("zoomOutUi", shortcuts))) return true;
+  if (event.isComposing || event.altKey) return false;
+  if (!event.metaKey && !event.ctrlKey) return false;
+  return normalizeKey(event.key) === "NumpadSubtract" && !event.shiftKey;
+}
+
+export function isResetZoomShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  if (matchesShortcut(event, actionShortcut("resetUiZoom", shortcuts))) return true;
+  if (event.isComposing || event.altKey || event.shiftKey) return false;
+  if (!event.metaKey && !event.ctrlKey) return false;
+  return normalizeKey(event.key) === "Numpad0";
+}
+
+export function isToggleTransposeShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("toggleTranspose", shortcuts));
+}
+
+export function isSaveShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("saveSql", shortcuts));
+}
+
+export function isAcceptCompletionShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("acceptCompletion", shortcuts));
+}
+
+export function isObjectSourceSaveShortcutTarget(target: { closest(selector: string): unknown } | null | undefined): boolean {
+  return !!target?.closest("[data-object-source-editor], [data-object-source-preview]");
+}
+
+export function isCopyCurrentRowShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("copyCurrentRow", shortcuts));
+}
+
+export function isDeleteCurrentRowShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("deleteCurrentRow", shortcuts));
+}
+
+export function isCancelSearchShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("cancelSearch", shortcuts));
+}
+
+export function isToggleSidebarShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("toggleSidebar", shortcuts));
+}
+
+export function isCopySidebarSelectionShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("copySidebarSelection", shortcuts));
+}
+
+export function isPasteSidebarSelectionShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("pasteSidebarSelection", shortcuts));
+}
+
+export function isEditSidebarConnectionShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("editSidebarConnection", shortcuts));
+}
+
+export function isQuickOpenShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("quickOpen", shortcuts));
+}
+
+export function isSwitchToPreviousTabShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("switchToPreviousTab", shortcuts));
+}
+
+export function isSwitchToNextTabShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): boolean {
+  return matchesShortcut(event, actionShortcut("switchToNextTab", shortcuts));
+}
+
+export function switchToTabIndexFromShortcut(event: ShortcutLikeEvent, shortcuts?: Partial<ShortcutSettings>): number | null {
+  const normalized = normalizeShortcutSettings(shortcuts);
+  const index = SWITCH_TO_TAB_ACTIONS.findIndex((actionId) => matchesShortcut(event, normalized[actionId]));
+  return index >= 0 ? index : null;
+}
+
+export function isBrowserReloadShortcut(event: ShortcutLikeEvent): boolean {
+  if (event.isComposing || event.altKey) return false;
+  const key = normalizeKey(event.key);
+  if (key === "F5") return true;
+  return key === "r" && (!!event.metaKey || !!event.ctrlKey);
+}
diff --git a/apps/desktop/src/lib/editor/queryEditorPointerSelection.ts b/apps/desktop/src/lib/editor/queryEditorPointerSelection.ts
new file mode 100644
index 0000000..bcc545f
--- /dev/null
+++ b/apps/desktop/src/lib/editor/queryEditorPointerSelection.ts
@@ -0,0 +1,8 @@
+export interface QueryEditorPointerEvent {
+  altKey: boolean;
+  button: number;
+}
+
+export function startsQueryEditorRectangularSelection(event: QueryEditorPointerEvent): boolean {
+  return event.altKey || event.button === 1;
+}
diff --git a/apps/desktop/src/lib/editor/queryEditorTableDrop.ts b/apps/desktop/src/lib/editor/queryEditorTableDrop.ts
new file mode 100644
index 0000000..71171ee
--- /dev/null
+++ b/apps/desktop/src/lib/editor/queryEditorTableDrop.ts
@@ -0,0 +1,132 @@
+import type { DatabaseType } from "@/types/database";
+import { qualifiedTableName, quoteTableIdentifier } from "@/lib/table/tableSelectSql";
+
+export const DBX_TABLE_REFERENCE_MIME = "application/x-dbx-table-reference";
+export const DBX_TABLE_REFERENCE_DROP_EVENT = "dbx-table-reference-drop";
+
+export interface QueryEditorTableReferencePayload {
+  kind: "dbx-table-reference";
+  connectionId: string;
+  database: string;
+  schema?: string;
+  tableName?: string;
+  columnName?: string;
+  referenceType?: "database" | "table" | "column";
+  databaseType?: DatabaseType;
+}
+
+export interface QueryEditorTableReferenceDropDetail {
+  payload: QueryEditorTableReferencePayload;
+  clientX: number;
+  clientY: number;
+}
+
+let activeTableReferencePayload: QueryEditorTableReferencePayload | null = null;
+
+export function createTableReferencePayload(options: { connectionId?: string; database?: string; schema?: string; tableName?: string; columnName?: string; referenceType?: "database" | "table" | "column"; databaseType?: DatabaseType }): QueryEditorTableReferencePayload | null {
+  if (!options.connectionId || options.database == null) return null;
+  const referenceType = options.referenceType ?? (options.columnName ? "column" : "table");
+  if (referenceType !== "database" && !options.tableName) return null;
+  const payload: QueryEditorTableReferencePayload = {
+    kind: "dbx-table-reference",
+    connectionId: options.connectionId,
+    database: options.database,
+  };
+  if (referenceType === "database") {
+    payload.referenceType = "database";
+  } else {
+    payload.tableName = options.tableName;
+  }
+  if (referenceType === "column" && options.columnName) {
+    payload.columnName = options.columnName;
+    payload.referenceType = "column";
+  }
+  if (options.schema) payload.schema = options.schema;
+  if (options.databaseType) payload.databaseType = options.databaseType;
+  return payload;
+}
+
+export function serializeTableReferencePayload(payload: QueryEditorTableReferencePayload): string {
+  return JSON.stringify(payload);
+}
+
+export function parseTableReferencePayload(value: string | undefined | null): QueryEditorTableReferencePayload | null {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value) as Partial<QueryEditorTableReferencePayload>;
+    if (parsed.kind !== "dbx-table-reference" || typeof parsed.connectionId !== "string" || typeof parsed.database !== "string" || !parsed.connectionId) {
+      return null;
+    }
+    if (parsed.referenceType === "database") {
+      const payload: QueryEditorTableReferencePayload = {
+        kind: "dbx-table-reference",
+        connectionId: parsed.connectionId,
+        database: parsed.database,
+        referenceType: "database",
+      };
+      if (parsed.databaseType) payload.databaseType = parsed.databaseType;
+      return payload;
+    }
+    if (typeof parsed.tableName !== "string" || !parsed.tableName) return null;
+    const columnName = typeof parsed.columnName === "string" && parsed.columnName ? parsed.columnName : undefined;
+    const referenceType = parsed.referenceType === "column" || columnName ? "column" : "table";
+    if (referenceType === "column" && !columnName) return null;
+    const payload: QueryEditorTableReferencePayload = {
+      kind: "dbx-table-reference",
+      connectionId: parsed.connectionId,
+      database: parsed.database,
+      tableName: parsed.tableName,
+    };
+    if (referenceType === "column" && columnName) {
+      payload.columnName = columnName;
+      payload.referenceType = "column";
+    }
+    if (typeof parsed.schema === "string" && parsed.schema) payload.schema = parsed.schema;
+    if (parsed.databaseType) payload.databaseType = parsed.databaseType;
+    return payload;
+  } catch {
+    return null;
+  }
+}
+
+export function hasTableReferencePayloadType(types: Iterable<string> | undefined | null): boolean {
+  if (!types) return false;
+  for (const type of types) {
+    if (type === DBX_TABLE_REFERENCE_MIME) return true;
+  }
+  return false;
+}
+
+export function setActiveTableReferencePayload(payload: QueryEditorTableReferencePayload | null) {
+  activeTableReferencePayload = payload;
+}
+
+export function activeTableReferencePayloadValue(): QueryEditorTableReferencePayload | null {
+  return activeTableReferencePayload;
+}
+
+export function clearActiveTableReferencePayload(payload?: QueryEditorTableReferencePayload | null) {
+  if (!payload || activeTableReferencePayload === payload) {
+    activeTableReferencePayload = null;
+  }
+}
+
+export function createTableReferenceDropEvent(detail: QueryEditorTableReferenceDropDetail) {
+  return new CustomEvent<QueryEditorTableReferenceDropDetail>(DBX_TABLE_REFERENCE_DROP_EVENT, { detail });
+}
+
+export function tableReferenceInsertText(payload: QueryEditorTableReferencePayload, fallbackDatabaseType?: DatabaseType): string {
+  const databaseType = payload.databaseType ?? fallbackDatabaseType;
+  if (payload.referenceType === "database") {
+    return quoteTableIdentifier(databaseType, payload.database);
+  }
+  if (payload.referenceType === "column" && payload.columnName) {
+    return quoteTableIdentifier(databaseType, payload.columnName);
+  }
+  const tableName = payload.tableName || payload.database;
+  return qualifiedTableName({
+    databaseType,
+    schema: payload.schema,
+    tableName,
+  });
+}
diff --git a/apps/desktop/src/lib/editor/shortcutDisplay.ts b/apps/desktop/src/lib/editor/shortcutDisplay.ts
new file mode 100644
index 0000000..b82c63b
--- /dev/null
+++ b/apps/desktop/src/lib/editor/shortcutDisplay.ts
@@ -0,0 +1,88 @@
+export function isMacShortcutPlatform(platform = globalThis.navigator?.platform || ""): boolean {
+  return platform.toLowerCase().includes("mac");
+}
+
+export function parseShortcutParts(shortcut?: string): string[] {
+  if (!shortcut) return [];
+
+  if (shortcut.endsWith("++")) {
+    const prefix = shortcut.slice(0, -2);
+    return [...prefix.split("+").filter(Boolean), "Plus"];
+  }
+
+  return shortcut.split("+").filter(Boolean);
+}
+
+export function parseShortcutStrokes(shortcut?: string): string[][] {
+  if (!shortcut) return [];
+  return shortcut.trim().split(/\s+/).filter(Boolean).map(parseShortcutParts);
+}
+
+function shortcutDisplayOrder(parts: string[], platform = globalThis.navigator?.platform || ""): string[] {
+  if (parts.length <= 2 || isMacShortcutPlatform(platform)) return parts;
+
+  const key = parts[parts.length - 1];
+  const modifierOrder = new Map([
+    ["Mod", 0],
+    ["Ctrl", 0],
+    ["Control", 0],
+    ["Meta", 0],
+    ["Cmd", 0],
+    ["Shift", 1],
+    ["Alt", 2],
+  ]);
+  const modifiers = parts.slice(0, -1);
+  if (!modifiers.some((part) => modifierOrder.get(part) === 0)) return parts;
+
+  return [
+    ...[...modifiers].sort((a, b) => {
+      const rankA = modifierOrder.get(a) ?? 99;
+      const rankB = modifierOrder.get(b) ?? 99;
+      return rankA - rankB;
+    }),
+    key,
+  ];
+}
+
+export function shortcutDisplayParts(shortcut?: string, platform = globalThis.navigator?.platform || ""): string[] {
+  return shortcutDisplayOrder(parseShortcutParts(shortcut), platform);
+}
+
+export function shortcutDisplayStrokes(shortcut?: string, platform = globalThis.navigator?.platform || ""): string[][] {
+  return parseShortcutStrokes(shortcut).map((parts) => shortcutDisplayOrder(parts, platform));
+}
+
+export function shortcutKeyLabel(part: string, platform = globalThis.navigator?.platform || ""): string {
+  const isMac = isMacShortcutPlatform(platform);
+  if (part === "Mod") return isMac ? "⌘" : "Ctrl";
+  if (part === "Cmd") return isMac ? "⌘" : "Cmd";
+  if (part === "Meta") return isMac ? "⌘" : "Meta";
+  if (part === "Alt") return isMac ? "⌥" : "Alt";
+  if (part === "Shift") return isMac ? "⇧" : "Shift";
+  if (part === "Control" || part === "Ctrl") return isMac ? "⌃" : "Ctrl";
+  if (part === "Delete") return isMac ? "⌦" : "Del";
+  if (part === "Backspace") return "⌫";
+  if (part === "Enter") return "↵";
+  if (part === "Escape") return "Esc";
+  if (part === "ArrowUp") return "↑";
+  if (part === "ArrowDown") return "↓";
+  if (part === "ArrowLeft") return "←";
+  if (part === "ArrowRight") return "→";
+  if (part === " ") return "Space";
+  if (part === "Plus") return "+";
+  return part.length === 1 ? part.toUpperCase() : part;
+}
+
+export function shortcutDisplayKeys(shortcut?: string, platform = globalThis.navigator?.platform || ""): string[] {
+  return shortcutDisplayStrokes(shortcut, platform)
+    .flat()
+    .map((part) => shortcutKeyLabel(part, platform));
+}
+
+export function formatShortcutDisplay(shortcut: string, platform = globalThis.navigator?.platform || ""): string {
+  if (!shortcut) return "—";
+  const keySeparator = isMacShortcutPlatform(platform) ? " " : " + ";
+  return shortcutDisplayStrokes(shortcut, platform)
+    .map((parts) => parts.map((part) => shortcutKeyLabel(part, platform)).join(keySeparator))
+    .join(", ");
+}
diff --git a/apps/desktop/src/lib/editor/shortcutRegistry.ts b/apps/desktop/src/lib/editor/shortcutRegistry.ts
new file mode 100644
index 0000000..71b8486
--- /dev/null
+++ b/apps/desktop/src/lib/editor/shortcutRegistry.ts
@@ -0,0 +1,405 @@
+import { parseShortcutStrokes, shortcutDisplayParts } from "@/lib/editor/shortcutDisplay";
+
+export type ShortcutActionId =
+  | "executeSql"
+  | "formatSql"
+  | "toggleLineComment"
+  | "saveSql"
+  | "acceptCompletion"
+  | "indentMore"
+  | "indentLess"
+  | "duplicateLine"
+  | "deleteLine"
+  | "moveLineUp"
+  | "moveLineDown"
+  | "copyLineUp"
+  | "copyLineDown"
+  | "undo"
+  | "redo"
+  | "selectAll"
+  | "uppercaseSelection"
+  | "lowercaseSelection"
+  | "exPasteSqlInCondition"
+  | "copyCurrentRow"
+  | "deleteCurrentRow"
+  | "newQuery"
+  | "openSettings"
+  | "closeTab"
+  | "focusSearch"
+  | "quickOpen"
+  | "switchToPreviousTab"
+  | "switchToNextTab"
+  | "switchToTab1"
+  | "switchToTab2"
+  | "switchToTab3"
+  | "switchToTab4"
+  | "switchToTab5"
+  | "switchToTab6"
+  | "switchToTab7"
+  | "switchToTab8"
+  | "switchToTab9"
+  | "zoomInUi"
+  | "zoomOutUi"
+  | "resetUiZoom"
+  | "find"
+  | "replace"
+  | "refreshData"
+  | "toggleTranspose"
+  | "cancelSearch"
+  | "toggleSidebar"
+  | "copySidebarSelection"
+  | "pasteSidebarSelection"
+  | "editSidebarConnection"
+  | "sendSelectionToAi";
+
+export type ShortcutScope = "global" | "editor" | "grid" | "search" | "sidebar";
+
+export interface ShortcutDefinition {
+  id: ShortcutActionId;
+  labelKey: string;
+  scope: ShortcutScope;
+  defaultShortcut: string;
+}
+
+export type ShortcutSettings = Record<ShortcutActionId, string>;
+
+export const SHORTCUT_DEFINITIONS: ShortcutDefinition[] = [
+  {
+    id: "executeSql",
+    labelKey: "settings.shortcutExecuteSql",
+    scope: "editor",
+    defaultShortcut: "Mod+Enter",
+  },
+  {
+    id: "formatSql",
+    labelKey: "settings.shortcutFormatSql",
+    scope: "editor",
+    defaultShortcut: "Shift+Mod+F",
+  },
+  {
+    id: "toggleLineComment",
+    labelKey: "settings.shortcutToggleLineComment",
+    scope: "editor",
+    defaultShortcut: "Mod+/",
+  },
+  {
+    id: "saveSql",
+    labelKey: "settings.shortcutSaveSql",
+    scope: "editor",
+    defaultShortcut: "Mod+S",
+  },
+  {
+    id: "acceptCompletion",
+    labelKey: "settings.shortcutAcceptCompletion",
+    scope: "editor",
+    defaultShortcut: "Tab",
+  },
+  {
+    id: "indentMore",
+    labelKey: "settings.shortcutIndentMore",
+    scope: "editor",
+    defaultShortcut: "",
+  },
+  {
+    id: "indentLess",
+    labelKey: "settings.shortcutIndentLess",
+    scope: "editor",
+    defaultShortcut: "Shift+Tab",
+  },
+  {
+    id: "duplicateLine",
+    labelKey: "settings.shortcutDuplicateLine",
+    scope: "editor",
+    defaultShortcut: "Mod+D",
+  },
+  {
+    id: "deleteLine",
+    labelKey: "settings.shortcutDeleteLine",
+    scope: "editor",
+    defaultShortcut: "Shift+Mod+K",
+  },
+  {
+    id: "moveLineUp",
+    labelKey: "settings.shortcutMoveLineUp",
+    scope: "editor",
+    defaultShortcut: "Alt+ArrowUp",
+  },
+  {
+    id: "moveLineDown",
+    labelKey: "settings.shortcutMoveLineDown",
+    scope: "editor",
+    defaultShortcut: "Alt+ArrowDown",
+  },
+  {
+    id: "copyLineUp",
+    labelKey: "settings.shortcutCopyLineUp",
+    scope: "editor",
+    defaultShortcut: "Shift+Alt+ArrowUp",
+  },
+  {
+    id: "copyLineDown",
+    labelKey: "settings.shortcutCopyLineDown",
+    scope: "editor",
+    defaultShortcut: "Shift+Alt+ArrowDown",
+  },
+  {
+    id: "undo",
+    labelKey: "settings.shortcutUndo",
+    scope: "editor",
+    defaultShortcut: "Mod+Z",
+  },
+  {
+    id: "redo",
+    labelKey: "settings.shortcutRedo",
+    scope: "editor",
+    defaultShortcut: "Shift+Mod+Z",
+  },
+  {
+    id: "selectAll",
+    labelKey: "settings.shortcutSelectAll",
+    scope: "editor",
+    defaultShortcut: "Mod+A",
+  },
+  {
+    id: "uppercaseSelection",
+    labelKey: "settings.shortcutUppercaseSelection",
+    scope: "editor",
+    defaultShortcut: "Shift+Alt+U",
+  },
+  {
+    id: "lowercaseSelection",
+    labelKey: "settings.shortcutLowercaseSelection",
+    scope: "editor",
+    defaultShortcut: "Shift+Alt+L",
+  },
+  {
+    id: "exPasteSqlInCondition",
+    labelKey: "settings.shortcutExPasteSqlInCondition",
+    scope: "editor",
+    defaultShortcut: "",
+  },
+  {
+    id: "copyCurrentRow",
+    labelKey: "settings.shortcutCopyCurrentRow",
+    scope: "grid",
+    defaultShortcut: "Mod+D",
+  },
+  {
+    id: "deleteCurrentRow",
+    labelKey: "settings.shortcutDeleteCurrentRow",
+    scope: "grid",
+    defaultShortcut: "Delete",
+  },
+  {
+    id: "newQuery",
+    labelKey: "settings.shortcutNewQuery",
+    scope: "global",
+    defaultShortcut: "Mod+T",
+  },
+  {
+    id: "openSettings",
+    labelKey: "settings.shortcutOpenSettings",
+    scope: "global",
+    defaultShortcut: "Mod+,",
+  },
+  {
+    id: "closeTab",
+    labelKey: "settings.shortcutCloseTab",
+    scope: "global",
+    defaultShortcut: "Meta+W",
+  },
+  {
+    id: "focusSearch",
+    labelKey: "settings.shortcutFocusSearch",
+    scope: "global",
+    defaultShortcut: "Mod+F",
+  },
+  {
+    id: "quickOpen",
+    labelKey: "settings.shortcutQuickOpen",
+    scope: "global",
+    defaultShortcut: "Mod+P",
+  },
+  {
+    id: "switchToPreviousTab",
+    labelKey: "settings.shortcutSwitchToPreviousTab",
+    scope: "global",
+    defaultShortcut: "Shift+Mod+[",
+  },
+  {
+    id: "switchToNextTab",
+    labelKey: "settings.shortcutSwitchToNextTab",
+    scope: "global",
+    defaultShortcut: "Shift+Mod+]",
+  },
+  {
+    id: "switchToTab1",
+    labelKey: "settings.shortcutSwitchToTab1",
+    scope: "global",
+    defaultShortcut: "Mod+1",
+  },
+  {
+    id: "switchToTab2",
+    labelKey: "settings.shortcutSwitchToTab2",
+    scope: "global",
+    defaultShortcut: "Mod+2",
+  },
+  {
+    id: "switchToTab3",
+    labelKey: "settings.shortcutSwitchToTab3",
+    scope: "global",
+    defaultShortcut: "Mod+3",
+  },
+  {
+    id: "switchToTab4",
+    labelKey: "settings.shortcutSwitchToTab4",
+    scope: "global",
+    defaultShortcut: "Mod+4",
+  },
+  {
+    id: "switchToTab5",
+    labelKey: "settings.shortcutSwitchToTab5",
+    scope: "global",
+    defaultShortcut: "Mod+5",
+  },
+  {
+    id: "switchToTab6",
+    labelKey: "settings.shortcutSwitchToTab6",
+    scope: "global",
+    defaultShortcut: "Mod+6",
+  },
+  {
+    id: "switchToTab7",
+    labelKey: "settings.shortcutSwitchToTab7",
+    scope: "global",
+    defaultShortcut: "Mod+7",
+  },
+  {
+    id: "switchToTab8",
+    labelKey: "settings.shortcutSwitchToTab8",
+    scope: "global",
+    defaultShortcut: "Mod+8",
+  },
+  {
+    id: "switchToTab9",
+    labelKey: "settings.shortcutSwitchToTab9",
+    scope: "global",
+    defaultShortcut: "Mod+9",
+  },
+  {
+    id: "zoomInUi",
+    labelKey: "settings.shortcutZoomInUi",
+    scope: "global",
+    defaultShortcut: "Mod+=",
+  },
+  {
+    id: "zoomOutUi",
+    labelKey: "settings.shortcutZoomOutUi",
+    scope: "global",
+    defaultShortcut: "Mod+-",
+  },
+  {
+    id: "resetUiZoom",
+    labelKey: "settings.shortcutResetUiZoom",
+    scope: "global",
+    defaultShortcut: "Mod+0",
+  },
+  {
+    id: "find",
+    labelKey: "settings.shortcutFind",
+    scope: "editor",
+    defaultShortcut: "Mod+F",
+  },
+  {
+    id: "replace",
+    labelKey: "settings.shortcutReplace",
+    scope: "editor",
+    defaultShortcut: "Mod+R",
+  },
+  {
+    id: "refreshData",
+    labelKey: "settings.shortcutRefreshData",
+    scope: "global",
+    defaultShortcut: "F5",
+  },
+  {
+    id: "toggleTranspose",
+    labelKey: "settings.shortcutToggleTranspose",
+    scope: "grid",
+    defaultShortcut: "Tab",
+  },
+  {
+    id: "cancelSearch",
+    labelKey: "settings.shortcutCancelSearch",
+    scope: "search",
+    defaultShortcut: "Escape",
+  },
+  {
+    id: "toggleSidebar",
+    labelKey: "settings.shortcutToggleSidebar",
+    scope: "global",
+    defaultShortcut: "Mod+B",
+  },
+  {
+    id: "copySidebarSelection",
+    labelKey: "settings.shortcutCopySidebarSelection",
+    scope: "sidebar",
+    defaultShortcut: "Mod+C",
+  },
+  {
+    id: "pasteSidebarSelection",
+    labelKey: "settings.shortcutPasteSidebarSelection",
+    scope: "sidebar",
+    defaultShortcut: "Mod+V",
+  },
+  {
+    id: "editSidebarConnection",
+    labelKey: "settings.shortcutEditSidebarConnection",
+    scope: "sidebar",
+    defaultShortcut: "Mod+E",
+  },
+  {
+    id: "sendSelectionToAi",
+    labelKey: "settings.shortcutSendSelectionToAi",
+    scope: "editor",
+    defaultShortcut: "Mod+Shift+A",
+  },
+];
+
+export const DEFAULT_SHORTCUT_SETTINGS: ShortcutSettings = Object.fromEntries(SHORTCUT_DEFINITIONS.map((definition) => [definition.id, definition.defaultShortcut])) as ShortcutSettings;
+
+export function normalizeShortcutSettings(settings?: Partial<ShortcutSettings>): ShortcutSettings {
+  return Object.fromEntries(SHORTCUT_DEFINITIONS.map((definition) => [definition.id, typeof settings?.[definition.id] === "string" ? settings[definition.id] : definition.defaultShortcut])) as ShortcutSettings;
+}
+
+export function shortcutToCodeMirrorKey(shortcut: string): string {
+  return parseShortcutStrokes(shortcut)
+    .map((parts) =>
+      parts
+        .map((part) => (part.length === 1 ? part.toLowerCase() : part))
+        .map((part) => (part === "Plus" ? "+" : part))
+        .join("-"),
+    )
+    .join(" ");
+}
+
+export function formatShortcut(shortcut: string, platform = globalThis.navigator?.platform || ""): string {
+  const isMac = platform.toLowerCase().includes("mac");
+  return shortcutDisplayParts(shortcut, platform)
+    .map((part) => {
+      if (part === "Mod") return isMac ? "Cmd" : "Ctrl";
+      if (part === "Meta") return isMac ? "Cmd" : "Meta";
+      if (part === "Plus") return "+";
+      return part;
+    })
+    .join("+");
+}
+
+export function findShortcutConflict(actionId: ShortcutActionId, shortcut: string, shortcuts: ShortcutSettings): ShortcutActionId | null {
+  if (!shortcut) return null;
+  const definition = SHORTCUT_DEFINITIONS.find((item) => item.id === actionId);
+  if (!definition) return null;
+
+  const conflict = SHORTCUT_DEFINITIONS.find((item) => item.id !== actionId && item.scope === definition.scope && shortcuts[item.id] === shortcut);
+  return conflict?.id ?? null;
+}
diff --git a/apps/desktop/src/lib/elasticsearch/elasticsearchCompletion.ts b/apps/desktop/src/lib/elasticsearch/elasticsearchCompletion.ts
new file mode 100644
index 0000000..161b0a7
--- /dev/null
+++ b/apps/desktop/src/lib/elasticsearch/elasticsearchCompletion.ts
@@ -0,0 +1,274 @@
+export type ElasticsearchCompletionMode = "method" | "path" | "json";
+
+export interface ElasticsearchCompletionItem {
+  label: string;
+  type: "keyword" | "property" | "text" | "snippet";
+  detail?: string;
+  info?: string;
+  apply?: string;
+  boost: number;
+}
+
+export interface ElasticsearchCompletionContext {
+  mode: ElasticsearchCompletionMode;
+  prefix: string;
+  from: number;
+  method?: string;
+  path?: string;
+  segmentIndex?: number;
+}
+
+export interface ElasticsearchCompletionInput {
+  indices?: string[];
+}
+
+const HTTP_METHODS = ["GET", "POST", "PUT", "DELETE"] as const;
+
+const ROOT_ENDPOINTS = [
+  { label: "/_search", apply: "_search", method: "GET", detail: "Search all indices" },
+  { label: "/_cat/indices", apply: "_cat/indices?v", method: "GET", detail: "List indices" },
+  { label: "/_cluster/health", apply: "_cluster/health", method: "GET", detail: "Cluster health" },
+  { label: "/_aliases", apply: "_aliases", method: "GET", detail: "List aliases" },
+  { label: "/_bulk", apply: "_bulk\n", method: "POST", detail: "Bulk operations" },
+  { label: "/_count", apply: "_count", method: "GET", detail: "Count documents" },
+];
+
+const INDEX_ENDPOINTS = [
+  {
+    label: "_search",
+    apply: '_search\n{\n  "query": {\n    "match_all": {}\n  }\n}',
+    method: "GET",
+    detail: "Search this index",
+  },
+  { label: "_mapping", apply: "_mapping", method: "GET", detail: "Show mapping" },
+  { label: "_settings", apply: "_settings", method: "GET", detail: "Show settings" },
+  { label: "_count", apply: "_count", method: "GET", detail: "Count documents" },
+  {
+    label: "_doc",
+    apply: '_doc/${}\n{\n  "${}": "${}"\n}',
+    method: "POST",
+    detail: "Create document",
+  },
+  { label: "_refresh", apply: "_refresh", method: "POST", detail: "Refresh index" },
+];
+
+const JSON_KEYWORDS = ["query", "bool", "must", "should", "must_not", "filter", "match", "match_all", "term", "terms", "range", "exists", "sort", "aggs", "aggregations", "size", "from", "_source", "fields", "track_total_hits"];
+
+const JSON_SNIPPETS = [
+  {
+    label: "match_all",
+    apply: '"match_all": {}',
+    detail: "Match all documents",
+  },
+  {
+    label: "bool",
+    apply: '"bool": {\n  "must": [\n    {}\n  ],\n  "filter": []\n}',
+    detail: "Bool query",
+  },
+  {
+    label: "range",
+    apply: '"range": {\n  "${field}": {\n    "gte": "${value}"\n  }\n}',
+    detail: "Range query",
+  },
+  {
+    label: "terms",
+    apply: '"terms": {\n  "${field}": []\n}',
+    detail: "Terms query",
+  },
+];
+
+export function getElasticsearchCompletionContext(text: string, cursor: number): ElasticsearchCompletionContext {
+  const safeCursor = Math.max(0, Math.min(cursor, text.length));
+  const lineStart = text.lastIndexOf("\n", safeCursor - 1) + 1;
+  const lineEnd = text.indexOf("\n", lineStart);
+  const currentLineEnd = lineEnd >= 0 ? lineEnd : text.length;
+  const beforeCursorOnLine = text.slice(lineStart, safeCursor);
+  const firstLineEnd = text.indexOf("\n");
+  const firstLineLimit = firstLineEnd >= 0 ? firstLineEnd : text.length;
+
+  if (lineStart > 0 || safeCursor > firstLineLimit || looksLikeJsonBody(text, safeCursor)) {
+    const jsonPrefix = readJsonPrefix(text, safeCursor);
+    return { mode: "json", prefix: jsonPrefix.prefix, from: jsonPrefix.from };
+  }
+
+  const methodMatch = /^([A-Za-z]*)$/.exec(beforeCursorOnLine);
+  if (methodMatch) {
+    return {
+      mode: "method",
+      prefix: methodMatch[1] ?? "",
+      from: lineStart,
+    };
+  }
+
+  const commandMatch = /^([A-Za-z]+)\s+(\S*)/.exec(text.slice(lineStart, currentLineEnd));
+  if (!commandMatch) {
+    const prefix = readWordPrefix(text, safeCursor);
+    return { mode: "method", prefix: prefix.prefix, from: prefix.from };
+  }
+
+  const method = commandMatch[1]?.toUpperCase();
+  const path = commandMatch[2] ?? "";
+  const pathStart = lineStart + (commandMatch[0].indexOf(path) >= 0 ? commandMatch[0].indexOf(path) : 0);
+  const pathCursor = Math.max(0, safeCursor - pathStart);
+  const boundedPathCursor = Math.min(pathCursor, path.length);
+  const beforePathCursor = path.slice(0, boundedPathCursor);
+  const segmentStartInPath = beforePathCursor.lastIndexOf("/") + 1;
+  const prefix = beforePathCursor.slice(segmentStartInPath);
+  const segmentIndex = beforePathCursor.slice(0, segmentStartInPath).split("/").filter(Boolean).length;
+
+  return {
+    mode: "path",
+    prefix,
+    from: pathStart + segmentStartInPath,
+    method,
+    path,
+    segmentIndex,
+  };
+}
+
+export function buildElasticsearchCompletionItems(text: string, cursor: number, input: ElasticsearchCompletionInput = {}): ElasticsearchCompletionItem[] {
+  const context = getElasticsearchCompletionContext(text, cursor);
+  return buildElasticsearchCompletionItemsFromContext(context, input);
+}
+
+export function buildElasticsearchCompletionItemsFromContext(context: ElasticsearchCompletionContext, input: ElasticsearchCompletionInput = {}): ElasticsearchCompletionItem[] {
+  if (context.mode === "method") return methodItems(context.prefix);
+  if (context.mode === "json") return jsonItems(context.prefix);
+  return pathItems(context, input.indices ?? []);
+}
+
+export function shouldAutoOpenElasticsearchCompletion(text: string, cursor: number): boolean {
+  const previousChar = text[cursor - 1];
+  if (!previousChar) return false;
+  if (/[{,}\]\n\r]/.test(previousChar)) return false;
+  if (/[\w/_."]/.test(previousChar)) return true;
+  return false;
+}
+
+export function getElasticsearchCompletionResultValidFor(): RegExp {
+  return /[\w/_."]*$/;
+}
+
+function methodItems(prefix: string): ElasticsearchCompletionItem[] {
+  return HTTP_METHODS.filter((method) => matchesPrefix(method, prefix)).map((method) => ({
+    label: method,
+    type: "keyword",
+    detail: "HTTP method",
+    apply: `${method} /`,
+    boost: 120,
+  }));
+}
+
+function pathItems(context: ElasticsearchCompletionContext, indices: string[]): ElasticsearchCompletionItem[] {
+  const items: ElasticsearchCompletionItem[] = [];
+  const path = context.path ?? "";
+  const segments = path.split("/").filter(Boolean);
+  const isFirstSegment = context.segmentIndex === 0;
+  const isRootApiSegment = isFirstSegment && context.prefix.startsWith("_");
+
+  if (isFirstSegment && !isRootApiSegment) {
+    items.push(...indexItems(context.prefix, indices));
+  }
+
+  if (isFirstSegment || isRootApiSegment) {
+    items.push(...rootEndpointItems(context.prefix));
+  }
+
+  if (segments.length >= 1 && !segments[0]?.startsWith("_")) {
+    items.push(...indexEndpointItems(context.prefix));
+  }
+
+  return dedupeAndSort(items);
+}
+
+function indexItems(prefix: string, indices: string[]): ElasticsearchCompletionItem[] {
+  return indices
+    .filter((index) => matchesFuzzyPrefix(index, prefix))
+    .slice(0, 100)
+    .map((index) => ({
+      label: index,
+      type: "text" as const,
+      detail: "index",
+      apply: index,
+      boost: index.toLowerCase().startsWith(prefix.toLowerCase()) ? 110 : 80,
+    }));
+}
+
+function rootEndpointItems(prefix: string): ElasticsearchCompletionItem[] {
+  const normalizedPrefix = prefix.startsWith("/") ? prefix.slice(1) : prefix;
+  return ROOT_ENDPOINTS.filter((endpoint) => matchesFuzzyPrefix(endpoint.label.slice(1), normalizedPrefix)).map((endpoint) => ({
+    label: endpoint.label,
+    type: endpoint.apply.includes("\n") ? ("snippet" as const) : ("property" as const),
+    detail: `${endpoint.method} ${endpoint.detail}`,
+    apply: endpoint.apply,
+    boost: 95,
+  }));
+}
+
+function indexEndpointItems(prefix: string): ElasticsearchCompletionItem[] {
+  return INDEX_ENDPOINTS.filter((endpoint) => matchesFuzzyPrefix(endpoint.label, prefix)).map((endpoint) => ({
+    label: endpoint.label,
+    type: endpoint.apply.includes("\n") ? ("snippet" as const) : ("property" as const),
+    detail: `${endpoint.method} ${endpoint.detail}`,
+    apply: endpoint.apply,
+    boost: 100,
+  }));
+}
+
+function jsonItems(prefix: string): ElasticsearchCompletionItem[] {
+  const normalizedPrefix = prefix.replace(/^"/, "");
+  const keyItems = JSON_KEYWORDS.filter((key) => matchesFuzzyPrefix(key, normalizedPrefix)).map((key) => ({
+    label: `"${key}"`,
+    type: "property" as const,
+    detail: "Query DSL field",
+    apply: `"${key}"`,
+    boost: key.startsWith(normalizedPrefix) ? 95 : 70,
+  }));
+  const snippetItems = JSON_SNIPPETS.filter((snippet) => matchesFuzzyPrefix(snippet.label, normalizedPrefix)).map((snippet) => ({
+    label: snippet.label,
+    type: "snippet" as const,
+    detail: snippet.detail,
+    apply: snippet.apply,
+    boost: 105,
+  }));
+  return dedupeAndSort([...snippetItems, ...keyItems]);
+}
+
+function looksLikeJsonBody(text: string, cursor: number): boolean {
+  const before = text.slice(0, cursor);
+  return before.includes("\n") || before.lastIndexOf("{") > before.lastIndexOf("\n");
+}
+
+function readJsonPrefix(text: string, cursor: number): { prefix: string; from: number } {
+  let from = cursor;
+  while (from > 0 && /[\w_"]/.test(text[from - 1] ?? "")) from--;
+  return { prefix: text.slice(from, cursor), from };
+}
+
+function readWordPrefix(text: string, cursor: number): { prefix: string; from: number } {
+  let from = cursor;
+  while (from > 0 && /[A-Za-z]/.test(text[from - 1] ?? "")) from--;
+  return { prefix: text.slice(from, cursor), from };
+}
+
+function matchesPrefix(value: string, prefix: string): boolean {
+  return value.toLowerCase().startsWith(prefix.toLowerCase());
+}
+
+function matchesFuzzyPrefix(value: string, prefix: string): boolean {
+  const normalizedValue = value.toLowerCase();
+  const normalizedPrefix = prefix.toLowerCase();
+  return !normalizedPrefix || normalizedValue.includes(normalizedPrefix);
+}
+
+function dedupeAndSort(items: ElasticsearchCompletionItem[]): ElasticsearchCompletionItem[] {
+  const seen = new Set<string>();
+  const deduped: ElasticsearchCompletionItem[] = [];
+  for (const item of items) {
+    const key = `${item.type}:${item.label}:${item.apply ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(item);
+  }
+  return deduped.sort((a, b) => b.boost - a.boost);
+}
diff --git a/apps/desktop/src/lib/elasticsearch/elasticsearchJsonResponse.ts b/apps/desktop/src/lib/elasticsearch/elasticsearchJsonResponse.ts
new file mode 100644
index 0000000..2fd731a
--- /dev/null
+++ b/apps/desktop/src/lib/elasticsearch/elasticsearchJsonResponse.ts
@@ -0,0 +1,26 @@
+import type { DatabaseType, QueryResult } from "@/types/database";
+
+export interface ElasticsearchJsonResponse {
+  status: number;
+  body: string;
+}
+
+const ELASTICSEARCH_REST_STATEMENT = /^(?:GET|POST|PUT|DELETE)\s+\S+/i;
+
+/**
+ * Detect the result shape emitted for a JSON response to an explicit
+ * Elasticsearch REST request. SQL and text (such as CAT) results keep using
+ * the normal data-grid path.
+ */
+export function elasticsearchJsonResponseForResult(databaseType: DatabaseType | undefined, sourceStatement: string | undefined, result: QueryResult | undefined): ElasticsearchJsonResponse | undefined {
+  if (databaseType !== "elasticsearch" || !result || typeof sourceStatement !== "string") return undefined;
+  if (!ELASTICSEARCH_REST_STATEMENT.test(sourceStatement.trim())) return undefined;
+  if (result.columns.length !== 2 || result.columns[0] !== "status" || result.columns[1] !== "response" || result.rows.length !== 1) return undefined;
+
+  const row = result.rows[0];
+  if (!row || row.length !== 2) return undefined;
+
+  const [status, body] = row;
+  if (typeof status !== "number" || !Number.isInteger(status) || status < 100 || status > 599 || typeof body !== "string") return undefined;
+  return { status, body };
+}
diff --git a/apps/desktop/src/lib/etcd/etcdKeyTree.ts b/apps/desktop/src/lib/etcd/etcdKeyTree.ts
new file mode 100644
index 0000000..7578977
--- /dev/null
+++ b/apps/desktop/src/lib/etcd/etcdKeyTree.ts
@@ -0,0 +1,3 @@
+export { buildKvKeyTree as buildEtcdKeyTree, collectKvGroupIds as collectEtcdGroupIds, flattenVisibleKvKeyTree as flattenVisibleEtcdKeyTree, preserveKvExpandedGroupIds as preserveEtcdExpandedGroupIds } from "@/lib/kv/kvKeyTree";
+
+export type { KvKeyTreeGroupNode as EtcdKeyTreeGroupNode, KvKeyTreeLeafNode as EtcdKeyTreeLeafNode, KvKeyTreeNode as EtcdKeyTreeNode, KvKeyTreeRow as EtcdKeyTreeRow } from "@/lib/kv/kvKeyTree";
diff --git a/apps/desktop/src/lib/export/databaseExport.ts b/apps/desktop/src/lib/export/databaseExport.ts
new file mode 100644
index 0000000..5ab8183
--- /dev/null
+++ b/apps/desktop/src/lib/export/databaseExport.ts
@@ -0,0 +1,106 @@
+import type { DatabaseType, QueryResult } from "@/types/database.ts";
+import * as api from "@/lib/backend/api.ts";
+import { buildTableSelectSql } from "@/lib/table/tableSelectSql.ts";
+import { uuid } from "@/lib/common/utils.ts";
+
+export const DATABASE_EXPORT_ROW_LIMIT = 10_000;
+export const DATABASE_EXPORT_PAGE_SIZE = 500;
+export const DATABASE_EXPORT_INSERT_BATCH_SIZE = 100;
+
+export interface ExportedTableSql {
+  displayName: string;
+  databaseType?: DatabaseType;
+  schema?: string;
+  tableName?: string;
+  qualifiedTableName?: string;
+  ddl?: string;
+  columns: string[];
+  columnTypes?: Array<string | null | undefined>;
+  columnExtras?: Array<string | null | undefined>;
+  rows: QueryResult["rows"];
+  truncated?: boolean;
+}
+
+export interface BuildDatabaseSqlExportOptions {
+  databaseName: string;
+  exportedAt?: Date | string;
+  tables: ExportedTableSql[];
+  rowLimitPerTable?: number;
+  insertBatchSize?: number;
+  connectionId?: string;
+  database?: string;
+  schema?: string;
+}
+
+export interface BuildExportInsertStatementsOptions {
+  databaseType?: DatabaseType;
+  schema?: string;
+  tableName?: string;
+  qualifiedTableName?: string;
+  columns: string[];
+  columnTypes?: Array<string | null | undefined>;
+  columnExtras?: Array<string | null | undefined>;
+  rows: QueryResult["rows"];
+  batchSize?: number;
+}
+
+export interface BuildExportPageSqlOptions {
+  databaseType?: DatabaseType;
+  schema?: string;
+  tableName: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface AllDatabaseExportPlanInput {
+  databases: string[];
+  schemaAware: boolean;
+  schemasByDatabase?: Record<string, string[]>;
+}
+
+export interface AllDatabaseExportPlanItem {
+  database: string;
+  schema: string;
+  fileStem: string;
+  displayName: string;
+}
+
+export function buildInsertStatements(options: BuildExportInsertStatementsOptions): Promise<string[]> {
+  return api.buildExportInsertStatements(options);
+}
+
+export async function buildExportPageSql(options: BuildExportPageSqlOptions): Promise<string> {
+  return buildTableSelectSql({
+    databaseType: options.databaseType,
+    schema: options.schema,
+    tableName: options.tableName,
+    limit: options.limit ?? DATABASE_EXPORT_PAGE_SIZE,
+    offset: options.offset,
+  });
+}
+
+export function generateDatabaseExportId(): string {
+  return uuid();
+}
+
+export function buildAllDatabaseExportPlan(options: AllDatabaseExportPlanInput): AllDatabaseExportPlanItem[] {
+  return options.databases.flatMap((database) => {
+    const schemas = options.schemaAware ? (options.schemasByDatabase?.[database] ?? []).filter((schema) => schema.trim()) : [database];
+    const exportSchemas = schemas.length > 0 ? schemas : [database];
+    const includeSchemaInFileName = options.schemaAware && exportSchemas.length > 1;
+
+    return exportSchemas.map((schema) => ({
+      database,
+      schema,
+      fileStem: includeSchemaInFileName ? `${database}.${schema}` : database,
+      displayName: includeSchemaInFileName ? `${database}.${schema}` : database,
+    }));
+  });
+}
+
+export function buildDatabaseSqlExport(options: BuildDatabaseSqlExportOptions): Promise<string> {
+  return api.buildDatabaseSqlExport({
+    ...options,
+    exportedAt: options.exportedAt instanceof Date ? options.exportedAt.toISOString() : options.exportedAt,
+  });
+}
diff --git a/apps/desktop/src/lib/export/databaseExportSelection.ts b/apps/desktop/src/lib/export/databaseExportSelection.ts
new file mode 100644
index 0000000..5e7b9e1
--- /dev/null
+++ b/apps/desktop/src/lib/export/databaseExportSelection.ts
@@ -0,0 +1,8 @@
+export function buildSelectedTablesPayload(allTables: string[], selectedTables: string[]): string[] | undefined {
+  if (allTables.length > 0 && selectedTables.length === allTables.length) {
+    return undefined;
+  }
+
+  const selected = new Set(selectedTables);
+  return allTables.filter((table) => selected.has(table));
+}
diff --git a/apps/desktop/src/lib/export/ddlExport.ts b/apps/desktop/src/lib/export/ddlExport.ts
new file mode 100644
index 0000000..f672cc9
--- /dev/null
+++ b/apps/desktop/src/lib/export/ddlExport.ts
@@ -0,0 +1,15 @@
+export function ensureSqlStatementTerminator(sql: string): string {
+  const trimmed = sql.trim();
+  if (!trimmed) return "";
+  return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
+}
+
+export function buildSingleDdlExportFileContent(sql: string): string {
+  const statement = ensureSqlStatementTerminator(sql);
+  return statement ? `${statement}\n` : "";
+}
+
+export function joinExportedDdls(ddls: readonly string[]): string {
+  const statements = ddls.map(ensureSqlStatementTerminator).filter(Boolean);
+  return statements.length ? `${statements.join("\n\n")}\n` : "";
+}
diff --git a/apps/desktop/src/lib/export/diagramSvgExport.ts b/apps/desktop/src/lib/export/diagramSvgExport.ts
new file mode 100644
index 0000000..127ca89
--- /dev/null
+++ b/apps/desktop/src/lib/export/diagramSvgExport.ts
@@ -0,0 +1,252 @@
+import type { EngineeringDiagram, EngineeringEntityNode } from "@/lib/diagram/engineeringDiagram";
+import type { DiagramPosition, DiagramRelationship, DiagramTable } from "@/lib/diagram/erDiagram";
+
+type DiagramSvgMode = "table" | "engineering";
+
+interface DiagramCanvas {
+  width: number;
+  height: number;
+}
+
+export interface TableDiagramSvgOptions {
+  tables: DiagramTable[];
+  relationships: DiagramRelationship[];
+  positions: Record<string, DiagramPosition>;
+  relationshipPaths: Record<string, string>;
+  canvas: DiagramCanvas;
+  cardWidth: number;
+  cardHeaderHeight: number;
+  columnRowHeight: number;
+  maxVisibleColumns: number;
+  cardBottomPadding?: number;
+  moreColumnsLabel?: (count: number) => string;
+}
+
+function escapeXml(value: string | number): string {
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+function svgNumber(value: number): string {
+  return Number.isInteger(value) ? String(value) : value.toFixed(2).replace(/\.?0+$/, "");
+}
+
+function svgHeader(canvas: DiagramCanvas): string {
+  return [`<svg xmlns="http://www.w3.org/2000/svg" width="${svgNumber(canvas.width)}" height="${svgNumber(canvas.height)}" viewBox="0 0 ${svgNumber(canvas.width)} ${svgNumber(canvas.height)}">`, '<rect width="100%" height="100%" fill="#fafafa"/>'].join("");
+}
+
+function svgText(
+  label: string,
+  x: number,
+  y: number,
+  options: {
+    size?: number;
+    fill?: string;
+    weight?: string;
+    anchor?: "start" | "middle" | "end";
+    family?: string;
+    decoration?: string;
+  } = {},
+): string {
+  const attrs = [`x="${svgNumber(x)}"`, `y="${svgNumber(y)}"`, `fill="${options.fill ?? "#18181b"}"`, `font-size="${options.size ?? 12}"`, `font-family="${options.family ?? "Arial, Helvetica, sans-serif"}"`, 'dominant-baseline="middle"'];
+  if (options.weight) attrs.push(`font-weight="${options.weight}"`);
+  if (options.anchor) attrs.push(`text-anchor="${options.anchor}"`);
+  if (options.decoration) attrs.push(`text-decoration="${options.decoration}"`);
+  return `<text ${attrs.join(" ")}>${escapeXml(label)}</text>`;
+}
+
+function tableHeight(table: DiagramTable, options: TableDiagramSvgOptions): number {
+  const visibleCount = Math.min(table.columns.length, options.maxVisibleColumns);
+  const overflowHeight = table.columns.length > options.maxVisibleColumns ? options.columnRowHeight : 0;
+  return options.cardHeaderHeight + visibleCount * options.columnRowHeight + overflowHeight + (options.cardBottomPadding ?? 12);
+}
+
+function tableDiagramDefs(): string {
+  return ["<defs>", '<marker id="dbx-diagram-arrow" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto" markerUnits="strokeWidth">', '<path d="M 0 0 L 8 4 L 0 8 z" fill="#2563eb"/>', "</marker>", "</defs>"].join("");
+}
+
+function isForeignKeyColumn(table: DiagramTable, columnName: string): boolean {
+  return table.foreignKeys.some((fk) => fk.column === columnName);
+}
+
+export function buildTableDiagramSvg(options: TableDiagramSvgOptions): string {
+  const parts = [svgHeader(options.canvas), tableDiagramDefs(), '<g fill="none" stroke="#2563eb" stroke-opacity="0.58" stroke-width="1.6">'];
+
+  for (const relationship of options.relationships) {
+    const path = options.relationshipPaths[relationship.id];
+    if (!path) continue;
+    parts.push(`<path d="${escapeXml(path)}" marker-end="url(#dbx-diagram-arrow)">` + `<title>${escapeXml(`${relationship.sourceTable}.${relationship.sourceColumn} -> ${relationship.targetTable}.${relationship.targetColumn}`)}</title>` + "</path>");
+  }
+  parts.push("</g>");
+
+  for (const table of options.tables) {
+    const position = options.positions[table.name] ?? { x: 0, y: 0 };
+    const height = tableHeight(table, options);
+    const visibleColumns = table.columns.slice(0, options.maxVisibleColumns);
+    const hiddenCount = Math.max(0, table.columns.length - options.maxVisibleColumns);
+    parts.push(`<g transform="translate(${svgNumber(position.x)} ${svgNumber(position.y)})">`);
+    parts.push(`<rect width="${options.cardWidth}" height="${svgNumber(height)}" rx="6" fill="#ffffff" stroke="#d4d4d8"/>`);
+    parts.push(`<rect width="${options.cardWidth}" height="${options.cardHeaderHeight}" rx="6" fill="#f4f4f5"/>`);
+    parts.push(`<path d="M 0 ${options.cardHeaderHeight} H ${options.cardWidth}" stroke="#e4e4e7"/>`);
+    parts.push(svgText(table.name, 36, options.cardHeaderHeight / 2, { size: 13, weight: "600" }));
+    parts.push(
+      svgText(String(table.columns.length), options.cardWidth - 18, options.cardHeaderHeight / 2, {
+        size: 10,
+        anchor: "end",
+        fill: "#52525b",
+      }),
+    );
+
+    visibleColumns.forEach((column, index) => {
+      const rowTop = options.cardHeaderHeight + index * options.columnRowHeight;
+      const rowCenter = rowTop + options.columnRowHeight / 2;
+      parts.push(`<path d="M 0 ${svgNumber(rowTop)} H ${options.cardWidth}" stroke="#f0f0f1"/>`);
+      if (column.is_primary_key) {
+        parts.push(svgText("PK", 14, rowCenter, { size: 9, fill: "#d97706", weight: "700" }));
+      } else if (isForeignKeyColumn(table, column.name)) {
+        parts.push(svgText("FK", 14, rowCenter, { size: 9, fill: "#2563eb", weight: "700" }));
+      }
+      parts.push(svgText(column.name, 38, rowCenter, { size: 11, family: "Menlo, Consolas, monospace" }));
+      parts.push(
+        svgText(column.data_type, options.cardWidth - 12, rowCenter, {
+          size: 10,
+          fill: "#71717a",
+          anchor: "end",
+        }),
+      );
+    });
+
+    if (hiddenCount > 0) {
+      const y = options.cardHeaderHeight + visibleColumns.length * options.columnRowHeight + options.columnRowHeight / 2;
+      parts.push(
+        svgText(options.moreColumnsLabel?.(hiddenCount) ?? `+ ${hiddenCount} columns`, 12, y, {
+          size: 11,
+          fill: "#71717a",
+        }),
+      );
+    }
+    parts.push("</g>");
+  }
+
+  parts.push("</svg>");
+  return parts.join("");
+}
+
+function nodeCenter(node: { x: number; y: number; width: number; height: number }): DiagramPosition {
+  return {
+    x: node.x + node.width / 2,
+    y: node.y + node.height / 2,
+  };
+}
+
+function cardinalityPoint(from: DiagramPosition, to: DiagramPosition): DiagramPosition {
+  return {
+    x: from.x + (to.x - from.x) * 0.72,
+    y: from.y + (to.y - from.y) * 0.72,
+  };
+}
+
+function entityCenterMap(entities: EngineeringEntityNode[]): Map<string, DiagramPosition> {
+  return new Map(entities.map((entity) => [entity.name, nodeCenter(entity)]));
+}
+
+export function buildEngineeringDiagramSvg(diagram: EngineeringDiagram): string {
+  const parts = [svgHeader(diagram.canvas)];
+  const centers = entityCenterMap(diagram.entities);
+
+  parts.push('<g stroke="#52525b" stroke-width="1.2">');
+  for (const attribute of diagram.attributes) {
+    const from = centers.get(attribute.tableName);
+    if (!from) continue;
+    const to = nodeCenter(attribute);
+    parts.push(`<line x1="${svgNumber(from.x)}" y1="${svgNumber(from.y)}" x2="${svgNumber(to.x)}" y2="${svgNumber(to.y)}"/>`);
+  }
+  for (const relationship of diagram.relationships) {
+    const source = centers.get(relationship.sourceTable);
+    const target = centers.get(relationship.targetTable);
+    if (!source || !target) continue;
+    const middle = nodeCenter(relationship);
+    parts.push(`<line x1="${svgNumber(source.x)}" y1="${svgNumber(source.y)}" x2="${svgNumber(middle.x)}" y2="${svgNumber(middle.y)}"/>`);
+    parts.push(`<line x1="${svgNumber(middle.x)}" y1="${svgNumber(middle.y)}" x2="${svgNumber(target.x)}" y2="${svgNumber(target.y)}"/>`);
+    const sourceLabel = cardinalityPoint(middle, source);
+    const targetLabel = cardinalityPoint(middle, target);
+    parts.push(
+      svgText(relationship.sourceCardinality, sourceLabel.x, sourceLabel.y - 8, {
+        size: 13,
+        weight: "700",
+        anchor: "middle",
+      }),
+    );
+    parts.push(
+      svgText(relationship.targetCardinality, targetLabel.x, targetLabel.y - 8, {
+        size: 13,
+        weight: "700",
+        anchor: "middle",
+      }),
+    );
+  }
+  parts.push("</g>");
+
+  for (const attribute of diagram.attributes) {
+    parts.push(`<ellipse cx="${svgNumber(attribute.x + attribute.width / 2)}" cy="${svgNumber(attribute.y + attribute.height / 2)}" ` + `rx="${svgNumber(attribute.width / 2)}" ry="${svgNumber(attribute.height / 2)}" fill="#dcfce7" stroke="#16a34a" stroke-opacity="0.65"/>`);
+    parts.push(
+      svgText(attribute.label, attribute.x + attribute.width / 2, attribute.y + attribute.height / 2, {
+        size: 11,
+        fill: "#052e16",
+        weight: attribute.primaryKey ? "700" : undefined,
+        anchor: "middle",
+        decoration: attribute.primaryKey ? "underline" : undefined,
+      }),
+    );
+  }
+
+  for (const relationship of diagram.relationships) {
+    const cx = relationship.x + relationship.width / 2;
+    const cy = relationship.y + relationship.height / 2;
+    const points = [
+      [cx, relationship.y],
+      [relationship.x + relationship.width, cy],
+      [cx, relationship.y + relationship.height],
+      [relationship.x, cy],
+    ]
+      .map(([x, y]) => `${svgNumber(x)},${svgNumber(y)}`)
+      .join(" ");
+    parts.push(`<polygon points="${points}" fill="#fee2e2" stroke="#ef4444" stroke-opacity="0.7"/>`);
+    parts.push(
+      svgText(relationship.label, cx, cy, {
+        size: 11,
+        fill: "#450a0a",
+        weight: "600",
+        anchor: "middle",
+      }),
+    );
+  }
+
+  for (const entity of diagram.entities) {
+    parts.push(`<rect x="${svgNumber(entity.x)}" y="${svgNumber(entity.y)}" width="${entity.width}" height="${entity.height}" fill="#dbeafe" stroke="#3b82f6" stroke-opacity="0.7"/>`);
+    parts.push(
+      svgText(entity.name, entity.x + entity.width / 2, entity.y + entity.height / 2, {
+        size: 13,
+        fill: "#172554",
+        weight: "700",
+        anchor: "middle",
+      }),
+    );
+  }
+
+  parts.push("</svg>");
+  return parts.join("");
+}
+
+function fileToken(value: string): string {
+  return value
+    .trim()
+    .replace(/[^\p{L}\p{N}._-]+/gu, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+}
+
+export function diagramSvgFileName(connectionName: string, databaseName: string, mode: DiagramSvgMode): string {
+  const context = [connectionName, databaseName].map(fileToken).filter(Boolean);
+  const suffix = mode === "engineering" ? "engineering-er" : "table-structure";
+  return ["dbx", ...(context.length > 0 ? context : ["diagram"]), suffix].join("-") + ".svg";
+}
diff --git a/apps/desktop/src/lib/export/exportFormats.ts b/apps/desktop/src/lib/export/exportFormats.ts
new file mode 100644
index 0000000..bb3270f
--- /dev/null
+++ b/apps/desktop/src/lib/export/exportFormats.ts
@@ -0,0 +1,28 @@
+import type { DatabaseType } from "@/types/database";
+import * as api from "@/lib/backend/api";
+
+export type ExportCellValue = string | number | boolean | null;
+
+export function formatCsv(columns: string[], rows: ExportCellValue[][]): string {
+  const esc = (v: string) => `"${v.replace(/"/g, '""')}"`;
+  const header = columns.map(esc).join(",");
+  const body = rows.map((row) => row.map((c) => esc(c === null ? "NULL" : String(c))).join(",")).join("\n");
+  return `${header}\n${body}`;
+}
+
+export interface FormatSqlInsertOptions {
+  databaseType?: DatabaseType;
+  schema?: string;
+  tableName?: string;
+  qualifiedTableName?: string;
+  columns: string[];
+  columnTypes?: Array<string | null | undefined>;
+  rows: ExportCellValue[][];
+}
+
+export function formatSqlInsert(options: FormatSqlInsertOptions): Promise<string> {
+  return api.buildExportSqlInsert({
+    ...options,
+    batchSize: 1,
+  });
+}
diff --git a/apps/desktop/src/lib/export/xlsxExport.ts b/apps/desktop/src/lib/export/xlsxExport.ts
new file mode 100644
index 0000000..52f92b0
--- /dev/null
+++ b/apps/desktop/src/lib/export/xlsxExport.ts
@@ -0,0 +1,314 @@
+export type XlsxCellValue = string | number | boolean | null | undefined;
+
+export interface XlsxWorksheetData {
+  sheetName?: string;
+  columns: readonly string[];
+  columnTypes?: readonly string[];
+  rows: readonly (readonly XlsxCellValue[])[];
+}
+
+type ZipEntry = {
+  path: string;
+  data: Uint8Array;
+  crc: number;
+  localHeaderOffset: number;
+};
+
+const encoder = new TextEncoder();
+const CRC_TABLE = buildCrcTable();
+
+function buildCrcTable(): number[] {
+  const table: number[] = [];
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let j = 0; j < 8; j++) {
+      c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    }
+    table.push(c >>> 0);
+  }
+  return table;
+}
+
+function crc32(data: Uint8Array): number {
+  let crc = 0xffffffff;
+  for (const byte of data) {
+    crc = CRC_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function escapeXml(value: string): string {
+  return [...value]
+    .filter((char) => {
+      const code = char.charCodeAt(0);
+      return code === 9 || code === 10 || code === 13 || code >= 32;
+    })
+    .join("")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function columnName(index: number): string {
+  let value = "";
+  let n = index + 1;
+  while (n > 0) {
+    const rem = (n - 1) % 26;
+    value = String.fromCharCode(65 + rem) + value;
+    n = Math.floor((n - 1) / 26);
+  }
+  return value;
+}
+
+function cellRef(rowIndex: number, colIndex: number): string {
+  return `${columnName(colIndex)}${rowIndex + 1}`;
+}
+
+function sheetRange(columnCount: number, rowCount: number): string {
+  if (columnCount === 0 || rowCount === 0) return "A1";
+  return `A1:${columnName(columnCount - 1)}${rowCount}`;
+}
+
+function normalizeSheetName(value?: string): string {
+  const invalidChars = new Set(["[", "]", ":", "*", "?", "/", "\\"]);
+  const name =
+    [...(value || "Sheet1")]
+      .map((char) => (invalidChars.has(char) ? " " : char))
+      .join("")
+      .trim() || "Sheet1";
+  return name.slice(0, 31);
+}
+
+function normalizeUniqueSheetNames(sheets: readonly XlsxWorksheetData[]): string[] {
+  const names: string[] = [];
+  sheets.forEach((sheet, index) => {
+    const base = normalizeSheetName(sheet.sheetName || `Sheet${index + 1}`);
+    let candidate = base;
+    let suffix = 2;
+    while (names.includes(candidate)) {
+      const suffixText = ` (${suffix})`;
+      candidate = `${base.slice(0, 31 - suffixText.length)}${suffixText}`;
+      suffix += 1;
+    }
+    names.push(candidate);
+  });
+  return names;
+}
+
+function estimateColumnWidths(columns: readonly string[], rows: readonly (readonly XlsxCellValue[])[]): number[] {
+  return columns.map((column, colIndex) => {
+    const values = rows.slice(0, 100).map((row) => row[colIndex]);
+    const maxLen = [column, ...values.map((value) => (value == null ? "" : String(value)))].map((value) => Math.min(value.length, 60)).reduce((max, length) => Math.max(max, length), 8);
+    return Math.max(10, Math.min(60, maxLen + 2));
+  });
+}
+
+function isNumericColumnType(columnType?: string): boolean {
+  const base = (columnType || "")
+    .trim()
+    .toLowerCase()
+    .split(/[\s([]/, 1)[0];
+  return new Set([
+    "bit",
+    "tinyint",
+    "smallint",
+    "mediumint",
+    "int",
+    "integer",
+    "bigint",
+    "int2",
+    "int4",
+    "int8",
+    "uint8",
+    "uint16",
+    "uint32",
+    "uint64",
+    "uint128",
+    "uint256",
+    "float",
+    "float4",
+    "float8",
+    "float32",
+    "float64",
+    "real",
+    "double",
+    "decimal",
+    "numeric",
+    "number",
+    "money",
+    "smallmoney",
+  ]).has(base);
+}
+
+function safeExcelNumber(value: string): string | undefined {
+  const trimmed = value.trim();
+  if (!trimmed || !Number.isFinite(Number(trimmed))) return undefined;
+  const significantDigits = (trimmed.split(/[eE]/, 1)[0].match(/\d/g) || []).join("").replace(/^0+/, "").length;
+  return significantDigits <= 15 ? trimmed : undefined;
+}
+
+function cellXml(value: XlsxCellValue, rowIndex: number, colIndex: number, style?: number, columnType?: string): string {
+  const ref = cellRef(rowIndex, colIndex);
+  const styleAttr = style == null ? "" : ` s="${style}"`;
+  if (value == null) return `<c r="${ref}"${styleAttr}/>`;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return `<c r="${ref}"${styleAttr}><v>${value}</v></c>`;
+  }
+  if (typeof value === "boolean") {
+    return `<c r="${ref}" t="b"${styleAttr}><v>${value ? 1 : 0}</v></c>`;
+  }
+  if (typeof value === "string" && isNumericColumnType(columnType)) {
+    // Excel keeps only 15 significant digits, so preserve higher-precision
+    // database values as text rather than silently rounding them.
+    const number = safeExcelNumber(value);
+    if (number !== undefined) return `<c r="${ref}"${styleAttr}><v>${number}</v></c>`;
+  }
+  return `<c r="${ref}" t="inlineStr"${styleAttr}><is><t>${escapeXml(String(value))}</t></is></c>`;
+}
+
+function worksheetXml(data: XlsxWorksheetData): string {
+  const columns = data.columns;
+  const rows = data.rows;
+  const totalRows = rows.length + 1;
+  const range = sheetRange(columns.length, totalRows);
+  const widths = estimateColumnWidths(columns, rows);
+  const colsXml = widths.map((width, index) => `<col min="${index + 1}" max="${index + 1}" width="${width}" customWidth="1"/>`).join("");
+  const headerXml = `<row r="1">${columns.map((column, index) => cellXml(column, 0, index, 1)).join("")}</row>`;
+  const bodyXml = rows
+    .map((row, rowIndex) => {
+      const excelRowIndex = rowIndex + 2;
+      const cells = columns.map((_, colIndex) => cellXml(row[colIndex], excelRowIndex - 1, colIndex, undefined, data.columnTypes?.[colIndex])).join("");
+      return `<row r="${excelRowIndex}">${cells}</row>`;
+    })
+    .join("");
+
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="${range}"/>
+  <sheetViews><sheetView workbookViewId="0"><pane ySplit="1" topLeftCell="A2" activePane="bottomLeft" state="frozen"/></sheetView></sheetViews>
+  <sheetFormatPr defaultRowHeight="15"/>
+  <cols>${colsXml}</cols>
+  <sheetData>${headerXml}${bodyXml}</sheetData>
+  <autoFilter ref="${range}"/>
+</worksheet>`;
+}
+
+function contentTypesXml(sheetCount = 1): string {
+  const worksheetOverrides = Array.from({ length: sheetCount }, (_, index) => `  <Override PartName="/xl/worksheets/sheet${index + 1}.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
+${worksheetOverrides}
+  <Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>
+</Types>`;
+}
+
+function rootRelsXml(): string {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
+</Relationships>`;
+}
+
+function workbookXml(sheetNames: readonly string[]): string {
+  const sheets = sheetNames.map((sheetName, index) => `<sheet name="${escapeXml(sheetName)}" sheetId="${index + 1}" r:id="rId${index + 1}"/>`).join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <sheets>${sheets}</sheets>
+</workbook>`;
+}
+
+function workbookRelsXml(sheetCount = 1): string {
+  const worksheetRels = Array.from({ length: sheetCount }, (_, index) => `  <Relationship Id="rId${index + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet${index + 1}.xml"/>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+${worksheetRels}
+  <Relationship Id="rId${sheetCount + 1}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>
+</Relationships>`;
+}
+
+function stylesXml(): string {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <fonts count="2"><font><sz val="11"/><name val="Calibri"/></font><font><b/><sz val="11"/><name val="Calibri"/></font></fonts>
+  <fills count="2"><fill><patternFill patternType="none"/></fill><fill><patternFill patternType="gray125"/></fill></fills>
+  <borders count="1"><border><left/><right/><top/><bottom/><diagonal/></border></borders>
+  <cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs>
+  <cellXfs count="2"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/><xf numFmtId="0" fontId="1" fillId="0" borderId="0" xfId="0" applyFont="1"/></cellXfs>
+  <cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles>
+</styleSheet>`;
+}
+
+function uint16(value: number): Uint8Array {
+  const bytes = new Uint8Array(2);
+  const view = new DataView(bytes.buffer);
+  view.setUint16(0, value, true);
+  return bytes;
+}
+
+function uint32(value: number): Uint8Array {
+  const bytes = new Uint8Array(4);
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, value >>> 0, true);
+  return bytes;
+}
+
+function concatBytes(parts: Uint8Array[]): Uint8Array {
+  const total = parts.reduce((sum, part) => sum + part.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+
+function createZip(files: Array<{ path: string; content: string }>): Uint8Array {
+  const entries: ZipEntry[] = [];
+  const localParts: Uint8Array[] = [];
+  let offset = 0;
+
+  for (const file of files) {
+    const path = encoder.encode(file.path);
+    const data = encoder.encode(file.content);
+    const crc = crc32(data);
+    const localHeader = concatBytes([uint32(0x04034b50), uint16(20), uint16(0), uint16(0), uint16(0), uint16(0), uint32(crc), uint32(data.length), uint32(data.length), uint16(path.length), uint16(0), path]);
+    entries.push({ path: file.path, data, crc, localHeaderOffset: offset });
+    localParts.push(localHeader, data);
+    offset += localHeader.length + data.length;
+  }
+
+  const centralParts: Uint8Array[] = [];
+  for (const entry of entries) {
+    const path = encoder.encode(entry.path);
+    centralParts.push(
+      concatBytes([uint32(0x02014b50), uint16(20), uint16(20), uint16(0), uint16(0), uint16(0), uint16(0), uint32(entry.crc), uint32(entry.data.length), uint32(entry.data.length), uint16(path.length), uint16(0), uint16(0), uint16(0), uint16(0), uint32(0), uint32(entry.localHeaderOffset), path]),
+    );
+  }
+
+  const central = concatBytes(centralParts);
+  const end = concatBytes([uint32(0x06054b50), uint16(0), uint16(0), uint16(entries.length), uint16(entries.length), uint32(central.length), uint32(offset), uint16(0)]);
+
+  return concatBytes([...localParts, central, end]);
+}
+
+export function buildXlsxWorkbook(data: XlsxWorksheetData): Uint8Array {
+  return buildXlsxWorkbookMulti([data]);
+}
+
+export function buildXlsxWorkbookMulti(sheets: readonly XlsxWorksheetData[]): Uint8Array {
+  if (sheets.length === 0) throw new Error("At least one worksheet is required");
+  const sheetNames = normalizeUniqueSheetNames(sheets);
+  return createZip([
+    { path: "[Content_Types].xml", content: contentTypesXml(sheets.length) },
+    { path: "_rels/.rels", content: rootRelsXml() },
+    { path: "xl/workbook.xml", content: workbookXml(sheetNames) },
+    { path: "xl/_rels/workbook.xml.rels", content: workbookRelsXml(sheets.length) },
+    { path: "xl/styles.xml", content: stylesXml() },
+    ...sheets.map((sheet, index) => ({ path: `xl/worksheets/sheet${index + 1}.xml`, content: worksheetXml(sheet) })),
+  ]);
+}
diff --git a/apps/desktop/src/lib/history/historyActions.ts b/apps/desktop/src/lib/history/historyActions.ts
new file mode 100644
index 0000000..abbc54a
--- /dev/null
+++ b/apps/desktop/src/lib/history/historyActions.ts
@@ -0,0 +1,7 @@
+export function shouldDeleteHistoryEntry(confirmDelete: () => boolean): boolean {
+  return confirmDelete();
+}
+
+export function shouldClearHistory(entryCount: number, confirmClear: () => boolean): boolean {
+  return entryCount > 0 && confirmClear();
+}
diff --git a/apps/desktop/src/lib/history/historyActivityKind.ts b/apps/desktop/src/lib/history/historyActivityKind.ts
new file mode 100644
index 0000000..c906b20
--- /dev/null
+++ b/apps/desktop/src/lib/history/historyActivityKind.ts
@@ -0,0 +1,43 @@
+export type HistoryActivityKind = "query" | "data_change" | "schema_change" | "import" | "transfer" | "redis_command";
+
+export type HistoryActivitySource = {
+  activity_kind?: HistoryActivityKind;
+  operation?: string;
+  sql?: string;
+};
+
+const READ_RE = /^\s*(SELECT|WITH|SHOW|DESCRIBE|DESC|EXPLAIN)\b/i;
+const WRITE_RE = /^\s*(INSERT|UPDATE|DELETE|MERGE|REPLACE|TRUNCATE)\b/i;
+const SCHEMA_RE = /^\s*(CREATE|ALTER|DROP|RENAME)\b/i;
+
+function stripSqlComments(sql: string): string {
+  return sql
+    .replace(/\/\*[\s\S]*?\*\//g, " ")
+    .replace(/--.*$/gm, " ")
+    .replace(/#.*$/gm, " ");
+}
+
+function statementsFor(sql: string): string[] {
+  return stripSqlComments(sql)
+    .split(";")
+    .map((stmt) => stmt.trim())
+    .filter(Boolean);
+}
+
+export function classifySqlActivityKind(sql: string): "query" | "data_change" | "schema_change" {
+  const statements = statementsFor(sql);
+  if (statements.some((stmt) => SCHEMA_RE.test(stmt))) return "schema_change";
+  if (statements.some((stmt) => WRITE_RE.test(stmt))) return "data_change";
+  if (statements.every((stmt) => READ_RE.test(stmt))) return "query";
+  return "query";
+}
+
+export function resolveHistoryActivityKind(entry: HistoryActivitySource): HistoryActivityKind {
+  if (entry.activity_kind && entry.activity_kind !== "query") return entry.activity_kind;
+
+  const operation = entry.operation?.trim();
+  if (operation && SCHEMA_RE.test(operation)) return "schema_change";
+  if (operation && WRITE_RE.test(operation)) return "data_change";
+
+  return entry.sql ? classifySqlActivityKind(entry.sql) : "query";
+}
diff --git a/apps/desktop/src/lib/history/historyAiAnalysis.ts b/apps/desktop/src/lib/history/historyAiAnalysis.ts
new file mode 100644
index 0000000..bdab77c
--- /dev/null
+++ b/apps/desktop/src/lib/history/historyAiAnalysis.ts
@@ -0,0 +1,56 @@
+export type HistoryAiAnalysisEntry = {
+  id: string;
+  connection_id?: string;
+  connection_name: string;
+  database: string;
+  sql: string;
+  executed_at: string;
+  execution_time_ms: number;
+  success: boolean;
+  error?: string | null;
+  activity_kind?: "query" | "data_change" | "schema_change" | "import" | "transfer" | "redis_command";
+  operation?: string;
+  target?: string;
+  affected_rows?: number | null;
+  rollback_sql?: string | null;
+  details_json?: string | null;
+};
+
+export function canRollbackHistoryEntry(entry: Pick<HistoryAiAnalysisEntry, "connection_id" | "database" | "rollback_sql">) {
+  return !!entry.connection_id?.trim() && !!entry.database?.trim() && !!entry.rollback_sql?.trim();
+}
+
+export function buildHistoryAiAnalysisPrompt(entry: HistoryAiAnalysisEntry): string {
+  const details = [
+    "请分析这条 DBX 历史记录，重点说明：",
+    "1. 这次操作做了什么，以及可能影响哪些数据或结构。",
+    "2. 是否有风险，例如无 WHERE 更新、删除、DDL、锁表、性能或权限问题。",
+    "3. 如果有 Rollback SQL，请评估它是否足够安全，执行前还应该确认什么。",
+    "4. 如果没有 Rollback SQL，请明确说明无法直接回滚，并给出可行的人工恢复建议。",
+    "",
+    "History metadata:",
+    `Connection: ${entry.connection_name || "(unknown)"}`,
+    `Database: ${entry.database || "(unknown)"}`,
+    `Activity kind: ${entry.activity_kind || "query"}`,
+    `Operation: ${entry.operation || "(unknown)"}`,
+    `Target: ${entry.target || "(unknown)"}`,
+    `Status: ${entry.success ? "success" : "failed"}`,
+    `Executed at: ${entry.executed_at || "(unknown)"}`,
+    `Duration: ${entry.execution_time_ms}ms`,
+    `Affected rows: ${entry.affected_rows ?? "(unknown)"}`,
+    entry.error ? `Error: ${entry.error}` : "",
+    entry.details_json ? `Details JSON: ${entry.details_json}` : "",
+    "",
+    "SQL:",
+    "```sql",
+    entry.sql.trim() || "-- empty",
+    "```",
+    "",
+    "Rollback SQL:",
+    entry.rollback_sql?.trim() ? "```sql" : "(not available)",
+    entry.rollback_sql?.trim() ? entry.rollback_sql.trim() : "",
+    entry.rollback_sql?.trim() ? "```" : "",
+  ];
+
+  return details.filter((line) => line !== "").join("\n");
+}
diff --git a/apps/desktop/src/lib/history/historyTimeRange.ts b/apps/desktop/src/lib/history/historyTimeRange.ts
new file mode 100644
index 0000000..99a4cfa
--- /dev/null
+++ b/apps/desktop/src/lib/history/historyTimeRange.ts
@@ -0,0 +1,51 @@
+export interface HistoryDateRange {
+  startDate: string;
+  endDate: string;
+}
+
+export function hasHistoryDateRange(range: HistoryDateRange): boolean {
+  return !!range.startDate || !!range.endDate;
+}
+
+export function historyEntryMatchesDateRange(executedAt: string, range: HistoryDateRange): boolean {
+  if (!hasHistoryDateRange(range)) return true;
+
+  const executedTime = new Date(executedAt).getTime();
+  if (Number.isNaN(executedTime)) return false;
+
+  const startTime = startOfLocalDate(range.startDate);
+  const endTime = endOfLocalDate(range.endDate);
+  if (startTime !== null && executedTime < startTime) return false;
+  if (endTime !== null && executedTime > endTime) return false;
+  return true;
+}
+
+export function historyDateRangeIsValid(range: HistoryDateRange): boolean {
+  const startTime = startOfLocalDate(range.startDate);
+  const endTime = endOfLocalDate(range.endDate);
+  return startTime === null || endTime === null || startTime <= endTime;
+}
+
+function startOfLocalDate(value: string): number | null {
+  const parts = parseDateInput(value);
+  if (!parts) return null;
+  return new Date(parts.year, parts.month - 1, parts.day, 0, 0, 0, 0).getTime();
+}
+
+function endOfLocalDate(value: string): number | null {
+  const parts = parseDateInput(value);
+  if (!parts) return null;
+  return new Date(parts.year, parts.month - 1, parts.day, 23, 59, 59, 999).getTime();
+}
+
+function parseDateInput(value: string): { year: number; month: number; day: number } | null {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value.trim());
+  if (!match) return null;
+
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const date = new Date(year, month - 1, day);
+  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) return null;
+  return { year, month, day };
+}
diff --git a/apps/desktop/src/lib/history/historyVirtualList.ts b/apps/desktop/src/lib/history/historyVirtualList.ts
new file mode 100644
index 0000000..4aeb8e2
--- /dev/null
+++ b/apps/desktop/src/lib/history/historyVirtualList.ts
@@ -0,0 +1,6 @@
+export const HISTORY_ROW_HEIGHT = 72;
+export const HISTORY_SCROLL_BUFFER = 600;
+
+export function shouldVirtualizeHistory(count: number): boolean {
+  return count > 0;
+}
diff --git a/apps/desktop/src/lib/imports/datagripImport.ts b/apps/desktop/src/lib/imports/datagripImport.ts
new file mode 100644
index 0000000..9562d4a
--- /dev/null
+++ b/apps/desktop/src/lib/imports/datagripImport.ts
@@ -0,0 +1,462 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { uuid } from "@/lib/common/utils";
+
+declare var process: { env: Record<string, string | undefined> } | undefined;
+
+type PartialConnection = Omit<ConnectionConfig, "id">;
+
+export type DataGripImportPayload = {
+  format: "datagrip-import";
+  dataSources: string;
+  dataSourcesLocal?: string;
+};
+
+type DataSourceFragment = {
+  uuid: string;
+  name: string;
+  driverRef: string;
+  jdbcUrl: string;
+  driverClass: string;
+  username: string;
+  product: string;
+  groupName?: string;
+};
+
+type DriverProfile = {
+  dbType: DatabaseType;
+  profile: string;
+  label: string;
+  port: number;
+  user: string;
+};
+
+// driver-ref prefix → dbx profile
+const driverRefMap: Record<string, DriverProfile> = {
+  mysql: { dbType: "mysql", profile: "mysql", label: "MySQL", port: 3306, user: "root" },
+  mariadb: { dbType: "mysql", profile: "mariadb", label: "MariaDB", port: 3306, user: "root" },
+  postgresql: { dbType: "postgres", profile: "postgres", label: "PostgreSQL", port: 5432, user: "postgres" },
+  postgres: { dbType: "postgres", profile: "postgres", label: "PostgreSQL", port: 5432, user: "postgres" },
+  sqlite: { dbType: "sqlite", profile: "sqlite", label: "SQLite", port: 0, user: "" },
+  sqlserver: { dbType: "sqlserver", profile: "sqlserver", label: "SQL Server", port: 1433, user: "sa" },
+  mssql: { dbType: "sqlserver", profile: "sqlserver", label: "SQL Server", port: 1433, user: "sa" },
+  jtds: { dbType: "sqlserver", profile: "sqlserver", label: "SQL Server", port: 1433, user: "sa" },
+  oracle: { dbType: "oracle", profile: "oracle", label: "Oracle", port: 1521, user: "system" },
+  mongo: { dbType: "mongodb", profile: "mongodb", label: "MongoDB", port: 27017, user: "" },
+  mongodb: { dbType: "mongodb", profile: "mongodb", label: "MongoDB", port: 27017, user: "" },
+  redis: { dbType: "redis", profile: "redis", label: "Redis", port: 6379, user: "" },
+  clickhouse: { dbType: "clickhouse", profile: "clickhouse", label: "ClickHouse", port: 8123, user: "default" },
+  cassandra: { dbType: "cassandra", profile: "cassandra", label: "Cassandra", port: 9042, user: "" },
+  duckdb: { dbType: "duckdb", profile: "duckdb", label: "DuckDB", port: 0, user: "" },
+  bigquery: { dbType: "bigquery", profile: "bigquery", label: "BigQuery", port: 443, user: "" },
+  cockroach: { dbType: "postgres", profile: "cockroachdb", label: "CockroachDB", port: 26257, user: "root" },
+  cockroachdb: { dbType: "postgres", profile: "cockroachdb", label: "CockroachDB", port: 26257, user: "root" },
+  redshift: { dbType: "redshift", profile: "redshift", label: "Redshift", port: 5439, user: "awsuser" },
+  elasticsearch: { dbType: "elasticsearch", profile: "elasticsearch", label: "Elasticsearch", port: 9200, user: "" },
+  h2: { dbType: "h2", profile: "h2", label: "H2", port: 9092, user: "sa" },
+  snowflake: { dbType: "snowflake", profile: "snowflake", label: "Snowflake", port: 443, user: "" },
+};
+
+// product name from <database-info product="..."> → dbx profile
+const productMap: Record<string, DriverProfile> = {
+  mysql: { dbType: "mysql", profile: "mysql", label: "MySQL", port: 3306, user: "root" },
+  mariadb: { dbType: "mysql", profile: "mariadb", label: "MariaDB", port: 3306, user: "root" },
+  postgresql: { dbType: "postgres", profile: "postgres", label: "PostgreSQL", port: 5432, user: "postgres" },
+  postgres: { dbType: "postgres", profile: "postgres", label: "PostgreSQL", port: 5432, user: "postgres" },
+  sqlite: { dbType: "sqlite", profile: "sqlite", label: "SQLite", port: 0, user: "" },
+  oracle: { dbType: "oracle", profile: "oracle", label: "Oracle", port: 1521, user: "system" },
+  "sql server": { dbType: "sqlserver", profile: "sqlserver", label: "SQL Server", port: 1433, user: "sa" },
+  mongodb: { dbType: "mongodb", profile: "mongodb", label: "MongoDB", port: 27017, user: "" },
+  redis: { dbType: "redis", profile: "redis", label: "Redis", port: 6379, user: "" },
+  clickhouse: { dbType: "clickhouse", profile: "clickhouse", label: "ClickHouse", port: 8123, user: "default" },
+  cassandra: { dbType: "cassandra", profile: "cassandra", label: "Cassandra", port: 9042, user: "" },
+  duckdb: { dbType: "duckdb", profile: "duckdb", label: "DuckDB", port: 0, user: "" },
+  bigquery: { dbType: "bigquery", profile: "bigquery", label: "BigQuery", port: 443, user: "" },
+  redshift: { dbType: "redshift", profile: "redshift", label: "Redshift", port: 5439, user: "awsuser" },
+  elasticsearch: { dbType: "elasticsearch", profile: "elasticsearch", label: "Elasticsearch", port: 9200, user: "" },
+  snowflake: { dbType: "snowflake", profile: "snowflake", label: "Snowflake", port: 443, user: "" },
+};
+
+// JDBC subprotocol → dbx profile (fallback when driver-ref and product are unknown)
+const subprotocolMap: Record<string, DriverProfile> = {
+  mysql: { dbType: "mysql", profile: "mysql", label: "MySQL", port: 3306, user: "root" },
+  mariadb: { dbType: "mysql", profile: "mariadb", label: "MariaDB", port: 3306, user: "root" },
+  postgresql: { dbType: "postgres", profile: "postgres", label: "PostgreSQL", port: 5432, user: "postgres" },
+  sqlite: { dbType: "sqlite", profile: "sqlite", label: "SQLite", port: 0, user: "" },
+  sqlserver: { dbType: "sqlserver", profile: "sqlserver", label: "SQL Server", port: 1433, user: "sa" },
+  jtds: { dbType: "sqlserver", profile: "sqlserver", label: "SQL Server", port: 1433, user: "sa" },
+  oracle: { dbType: "oracle", profile: "oracle", label: "Oracle", port: 1521, user: "system" },
+  mongodb: { dbType: "mongodb", profile: "mongodb", label: "MongoDB", port: 27017, user: "" },
+  redis: { dbType: "redis", profile: "redis", label: "Redis", port: 6379, user: "" },
+  clickhouse: { dbType: "clickhouse", profile: "clickhouse", label: "ClickHouse", port: 8123, user: "default" },
+  cassandra: { dbType: "cassandra", profile: "cassandra", label: "Cassandra", port: 9042, user: "" },
+  duckdb: { dbType: "duckdb", profile: "duckdb", label: "DuckDB", port: 0, user: "" },
+  bigquery: { dbType: "bigquery", profile: "bigquery", label: "BigQuery", port: 443, user: "" },
+  redshift: { dbType: "redshift", profile: "redshift", label: "Redshift", port: 5439, user: "awsuser" },
+};
+
+function getNumber(value: string | undefined): number {
+  if (!value) return 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+function getText(element: Element, tagName: string): string {
+  const child = element.getElementsByTagName(tagName)[0];
+  return child?.textContent?.trim() ?? "";
+}
+
+function expandPathMacros(value: string): string {
+  if (typeof window !== "undefined") {
+    const home = (typeof process !== "undefined" && process.env?.HOME) || (typeof process !== "undefined" && process.env?.USERPROFILE) || "";
+    if (home) return value.replace(/\$USER_HOME\$/g, home);
+  }
+  return value.replace(/\$USER_HOME\$/g, "~");
+}
+
+// --- JDBC URL parser ---
+
+function parseJdbcUrl(jdbcUrl: string): {
+  host: string;
+  port: number;
+  database: string;
+  oracleConnectionType?: "service_name" | "sid";
+} {
+  const url = jdbcUrl.replace(/^jdbc:/i, "").trim();
+  const result = {
+    host: "",
+    port: 0,
+    database: "",
+    oracleConnectionType: undefined as "service_name" | "sid" | undefined,
+  };
+
+  // SQL Server: jdbc:sqlserver://host[:port][;key=value]
+  const sqlServerMatch = url.match(/^sqlserver:\/\/([^;:/]+)(?::(\d+))?(?:;(.*))?/i);
+  if (sqlServerMatch) {
+    result.host = sqlServerMatch[1];
+    result.port = getNumber(sqlServerMatch[2]);
+    for (const part of (sqlServerMatch[3] || "").split(";")) {
+      const [key, ...rest] = part.split("=");
+      if (/^(databasename|database)$/i.test(key)) result.database = rest.join("=");
+    }
+    return result;
+  }
+
+  // Oracle thin with service_name: jdbc:oracle:thin:@//host:port/service
+  const oracleService = url.match(/^oracle:thin:@\/\/([^:/]+)(?::(\d+))?\/([^?]+)/i);
+  if (oracleService) {
+    result.host = oracleService[1];
+    result.port = getNumber(oracleService[2]);
+    result.database = oracleService[3];
+    result.oracleConnectionType = "service_name";
+    return result;
+  }
+
+  // Oracle thin with SID: jdbc:oracle:thin:@host:port:sid
+  const oracleSid = url.match(/^oracle:thin:@([^:/]+)(?::(\d+))?:([^?]+)/i);
+  if (oracleSid) {
+    result.host = oracleSid[1];
+    result.port = getNumber(oracleSid[2]);
+    result.database = oracleSid[3];
+    result.oracleConnectionType = "sid";
+    return result;
+  }
+
+  // SQLite / DuckDB file path: jdbc:sqlite:path/to/file.db
+  const fileMatch = url.match(/^(sqlite|duckdb):(.+)$/i);
+  if (fileMatch) {
+    result.host = expandPathMacros(fileMatch[2].split("?")[0]);
+    result.database = result.host;
+    return result;
+  }
+
+  // BigQuery: jdbc:bigquery://host;ProjectId=xxx
+  const bigqueryMatch = url.match(/^bigquery:\/\/([^;]+)(?:;(.+))?/i);
+  if (bigqueryMatch) {
+    result.host = bigqueryMatch[1];
+    for (const part of (bigqueryMatch[2] || "").split(";")) {
+      const [key, ...rest] = part.split("=");
+      if (/^(projectid|project)$/i.test(key)) result.database = rest.join("=");
+    }
+    return result;
+  }
+
+  // Generic authority form: jdbc:<sub>://[user[:pass]@]host[:port][/database][?params]
+  const schemeEnd = url.indexOf("://");
+  if (schemeEnd === -1) return result;
+
+  let remainder = url.slice(schemeEnd + 3);
+  remainder = remainder.split("?")[0];
+
+  const slashIndex = remainder.indexOf("/");
+  const authority = (slashIndex >= 0 ? remainder.slice(0, slashIndex) : remainder).split("@").pop() || "";
+  const database = slashIndex >= 0 ? remainder.slice(slashIndex + 1) : "";
+
+  const firstHost = authority.split(",")[0] || authority;
+  if (firstHost.startsWith("[")) {
+    const closing = firstHost.indexOf("]");
+    if (closing > 0) {
+      result.host = firstHost.slice(1, closing);
+      if (firstHost[closing + 1] === ":") result.port = getNumber(firstHost.slice(closing + 2));
+    }
+  } else {
+    const lastColon = firstHost.lastIndexOf(":");
+    if (lastColon > 0) {
+      result.host = firstHost.slice(0, lastColon);
+      result.port = getNumber(firstHost.slice(lastColon + 1));
+    } else {
+      result.host = firstHost;
+    }
+  }
+
+  result.database = database;
+  return result;
+}
+
+function extractSubprotocol(jdbcUrl: string): string {
+  const url = jdbcUrl.trim();
+  if (!url.toLowerCase().startsWith("jdbc:")) return "";
+  let subprotocol = "";
+  for (const char of url.slice(5)) {
+    if (char === ":" || char === "/") break;
+    subprotocol += char;
+  }
+  return subprotocol;
+}
+
+function inferProfile(driverRef: string, subprotocol: string, driverClass: string, product: string): DriverProfile {
+  // 1. Try driver-ref prefix (most specific)
+  const refKey = driverRef.split(".")[0].toLowerCase();
+  if (driverRefMap[refKey]) return driverRefMap[refKey];
+
+  // 2. Try product name from <database-info>
+  const productKey = product.toLowerCase();
+  for (const [needle, profile] of Object.entries(productMap)) {
+    if (productKey.includes(needle)) return profile;
+  }
+
+  // 3. Try JDBC subprotocol
+  const subKey = subprotocol.toLowerCase();
+  if (subprotocolMap[subKey]) return subprotocolMap[subKey];
+
+  // 4. Try driver class name
+  const classLower = driverClass.toLowerCase();
+  if (classLower.includes("mysql")) return driverRefMap.mysql;
+  if (classLower.includes("postgres")) return driverRefMap.postgresql;
+  if (classLower.includes("sqlite")) return driverRefMap.sqlite;
+  if (classLower.includes("oracle")) return driverRefMap.oracle;
+  if (classLower.includes("sqlserver") || classLower.includes("mssql")) return driverRefMap.sqlserver;
+  if (classLower.includes("mongo")) return driverRefMap.mongodb;
+  if (classLower.includes("redis")) return driverRefMap.redis;
+  if (classLower.includes("clickhouse")) return driverRefMap.clickhouse;
+
+  // 5. Fallback to JDBC
+  return { dbType: "jdbc", profile: "jdbc", label: driverClass || "JDBC", port: 0, user: "" };
+}
+
+// --- XML parsing ---
+
+function parseDataSourcesXml(xml: string): Map<string, Partial<DataSourceFragment>> {
+  const doc = new DOMParser().parseFromString(xml, "application/xml");
+  if (doc.querySelector("parsererror")) return new Map();
+
+  const result = new Map<string, Partial<DataSourceFragment>>();
+  const elements = doc.getElementsByTagName("data-source");
+
+  for (const element of Array.from(elements)) {
+    const uuidVal = element.getAttribute("uuid");
+    if (!uuidVal) continue;
+
+    const fragment: Partial<DataSourceFragment> = {
+      uuid: uuidVal,
+      name: element.getAttribute("name") || undefined,
+    };
+
+    const driverRef = getText(element, "driver-ref");
+    if (driverRef) fragment.driverRef = driverRef;
+
+    const jdbcUrl = getText(element, "jdbc-url");
+    if (jdbcUrl) fragment.jdbcUrl = jdbcUrl;
+
+    const driverClass = getText(element, "jdbc-driver");
+    if (driverClass) fragment.driverClass = driverClass;
+
+    const userName = getText(element, "user-name");
+    if (userName) fragment.username = userName;
+
+    const groupName = element.getAttribute("group-name") || undefined;
+    if (groupName) fragment.groupName = groupName;
+
+    result.set(uuidVal, fragment);
+  }
+
+  return result;
+}
+
+function parseDataSourcesLocalXml(xml: string): Map<string, Partial<DataSourceFragment>> {
+  const doc = new DOMParser().parseFromString(xml, "application/xml");
+  if (doc.querySelector("parsererror")) return new Map();
+
+  const result = new Map<string, Partial<DataSourceFragment>>();
+  const elements = doc.getElementsByTagName("data-source");
+
+  for (const element of Array.from(elements)) {
+    const uuidVal = element.getAttribute("uuid");
+    if (!uuidVal) continue;
+
+    const fragment: Partial<DataSourceFragment> = {
+      uuid: uuidVal,
+      name: element.getAttribute("name") || undefined,
+    };
+
+    const userName = getText(element, "user-name");
+    if (userName) fragment.username = userName;
+
+    // Extract product from <database-info product="...">
+    const dbInfo = element.getElementsByTagName("database-info")[0];
+    const product = dbInfo?.getAttribute("product") || "";
+    if (product) fragment.product = product;
+
+    result.set(uuidVal, fragment);
+  }
+
+  return result;
+}
+
+function mergeFragments(shared: Map<string, Partial<DataSourceFragment>>, local: Map<string, Partial<DataSourceFragment>>): DataSourceFragment[] {
+  const merged = new Map<string, Partial<DataSourceFragment>>();
+
+  // Shared first (has driver-ref, jdbc-url, group-name)
+  for (const [uuidVal, frag] of shared) {
+    merged.set(uuidVal, { ...frag });
+  }
+
+  // Merge local (has user-name, product — overrides name if present)
+  for (const [uuidVal, localFrag] of local) {
+    const existing = merged.get(uuidVal) || { uuid: uuidVal };
+    merged.set(uuidVal, {
+      ...existing,
+      ...localFrag,
+      // Keep shared name if local has it too (they're usually the same)
+      name: existing.name || localFrag.name,
+      // Keep shared driver-ref and jdbc-url (local doesn't have these)
+      driverRef: existing.driverRef || localFrag.driverRef,
+      jdbcUrl: existing.jdbcUrl || localFrag.jdbcUrl,
+      driverClass: existing.driverClass || localFrag.driverClass,
+      groupName: existing.groupName || localFrag.groupName,
+    });
+  }
+
+  // Resolve and filter
+  const resolved: DataSourceFragment[] = [];
+  for (const frag of merged.values()) {
+    if (!frag.uuid || !frag.driverRef || !frag.jdbcUrl) continue;
+    resolved.push({
+      uuid: frag.uuid,
+      name: frag.name || frag.uuid,
+      driverRef: frag.driverRef,
+      jdbcUrl: frag.jdbcUrl,
+      driverClass: frag.driverClass || "",
+      username: frag.username || "",
+      product: frag.product || "",
+      groupName: frag.groupName,
+    });
+  }
+
+  return resolved;
+}
+
+function buildConnection(fragment: DataSourceFragment): ConnectionConfig {
+  const subprotocol = extractSubprotocol(fragment.jdbcUrl);
+  const profile = inferProfile(fragment.driverRef, subprotocol, fragment.driverClass, fragment.product);
+  const parsed = parseJdbcUrl(fragment.jdbcUrl);
+
+  const host = parsed.host || (profile.dbType === "sqlite" ? "" : "127.0.0.1");
+  const port = parsed.port || profile.port;
+  const database = parsed.database || undefined;
+  const username = fragment.username || profile.user;
+  const name = fragment.name || database || host || profile.label;
+
+  const partial: PartialConnection = {
+    name,
+    db_type: profile.dbType,
+    driver_profile: profile.profile,
+    driver_label: profile.label,
+    url_params: "",
+    host,
+    port,
+    username,
+    password: "",
+    database,
+    color: "",
+    transport_layers: [],
+    connect_timeout_secs: 10,
+    query_timeout_secs: 30,
+    ssl: false,
+    oracle_connection_type: profile.dbType === "oracle" ? parsed.oracleConnectionType || "service_name" : undefined,
+    connection_string: profile.dbType === "jdbc" || profile.dbType === "mongodb" ? fragment.jdbcUrl.replace(/^jdbc:/i, "") : undefined,
+    jdbc_driver_class: profile.dbType === "jdbc" ? fragment.driverClass || undefined : undefined,
+    jdbc_driver_paths: [],
+  };
+
+  return { ...partial, id: uuid() };
+}
+
+// --- Public API ---
+
+export function isDataGripImportPayload(content: string): boolean {
+  try {
+    const parsed = JSON.parse(content);
+    return parsed?.format === "datagrip-import";
+  } catch {
+    return false;
+  }
+}
+
+export function parseDataGripConnections(payload: DataGripImportPayload): ConnectionConfig[] {
+  const shared = parseDataSourcesXml(payload.dataSources);
+  const local = payload.dataSourcesLocal ? parseDataSourcesLocalXml(payload.dataSourcesLocal) : new Map();
+  const fragments = mergeFragments(shared, local);
+
+  const configs: ConnectionConfig[] = [];
+  const seen = new Set<string>();
+
+  for (const fragment of fragments) {
+    const config = buildConnection(fragment);
+    const key = [config.name, config.db_type, config.host, config.port, config.database || ""].join("\u0000");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    configs.push(config);
+  }
+
+  return configs;
+}
+
+/** Returns a map of dedup key (name\0host\0port\0db) → DataGrip UUID for Keychain lookup. */
+export function getDataGripUuidMap(payload: DataGripImportPayload): Map<string, string> {
+  const shared = parseDataSourcesXml(payload.dataSources);
+  const local = payload.dataSourcesLocal ? parseDataSourcesLocalXml(payload.dataSourcesLocal) : new Map();
+  const fragments = mergeFragments(shared, local);
+
+  const uuidMap = new Map<string, string>();
+  const seen = new Set<string>();
+
+  for (const fragment of fragments) {
+    const profile = inferProfile(fragment.driverRef, extractSubprotocol(fragment.jdbcUrl), fragment.driverClass, fragment.product);
+    const parsed = parseJdbcUrl(fragment.jdbcUrl);
+    const host = parsed.host || (profile.dbType === "sqlite" ? "" : "127.0.0.1");
+    const port = parsed.port || profile.port;
+    const database = parsed.database || "";
+    const name = fragment.name || database || host || profile.label;
+    const dedupKey = [name, host, port, database].join("\u0000");
+    if (seen.has(dedupKey)) continue;
+    seen.add(dedupKey);
+    uuidMap.set(dedupKey, fragment.uuid);
+  }
+
+  return uuidMap;
+}
+
+/** Build the macOS Keychain service name for a DataGrip data source UUID. */
+export function datagripKeychainService(uuid: string): string {
+  return `IntelliJ Platform DB — ${uuid}`;
+}
diff --git a/apps/desktop/src/lib/imports/dbeaverImport.ts b/apps/desktop/src/lib/imports/dbeaverImport.ts
new file mode 100644
index 0000000..c8ac100
--- /dev/null
+++ b/apps/desktop/src/lib/imports/dbeaverImport.ts
@@ -0,0 +1,258 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { uuid } from "@/lib/common/utils";
+
+type PartialConnection = Omit<ConnectionConfig, "id">;
+
+type DbeaverImportPayload = {
+  format: "dbeaver-import";
+  dataSources: string;
+  credentialsBase64?: string;
+};
+
+type DbeaverConnectionEntry = {
+  id: string;
+  name?: string;
+  provider?: string;
+  driver?: string;
+  configuration?: Record<string, any>;
+  [key: string]: any;
+};
+
+type ConnectionProfile = {
+  dbType: DatabaseType;
+  profile: string;
+  label: string;
+  port: number;
+  user: string;
+};
+
+const dbeaverKey = new Uint8Array([186, 187, 74, 159, 119, 74, 184, 83, 201, 108, 45, 101, 61, 254, 84, 74]);
+
+const profileMap: Record<string, ConnectionProfile> = {
+  mysql: { dbType: "mysql", profile: "mysql", label: "MySQL", port: 3306, user: "root" },
+  mariadb: { dbType: "mysql", profile: "mariadb", label: "MariaDB", port: 3306, user: "root" },
+  postgresql: { dbType: "postgres", profile: "postgres", label: "PostgreSQL", port: 5432, user: "postgres" },
+  postgres: { dbType: "postgres", profile: "postgres", label: "PostgreSQL", port: 5432, user: "postgres" },
+  sqlite: { dbType: "sqlite", profile: "sqlite", label: "SQLite", port: 0, user: "" },
+  sqlserver: { dbType: "sqlserver", profile: "sqlserver", label: "SQL Server", port: 1433, user: "sa" },
+  mssql: { dbType: "sqlserver", profile: "sqlserver", label: "SQL Server", port: 1433, user: "sa" },
+  oracle: { dbType: "oracle", profile: "oracle", label: "Oracle", port: 1521, user: "system" },
+  clickhouse: { dbType: "clickhouse", profile: "clickhouse", label: "ClickHouse", port: 8123, user: "default" },
+  duckdb: { dbType: "duckdb", profile: "duckdb", label: "DuckDB", port: 0, user: "" },
+  mongodb: { dbType: "mongodb", profile: "mongodb", label: "MongoDB", port: 27017, user: "" },
+  mongo: { dbType: "mongodb", profile: "mongodb", label: "MongoDB", port: 27017, user: "" },
+  redshift: { dbType: "redshift", profile: "redshift", label: "Redshift", port: 5439, user: "awsuser" },
+  elasticsearch: { dbType: "elasticsearch", profile: "elasticsearch", label: "Elasticsearch", port: 9200, user: "" },
+  doris: { dbType: "doris", profile: "doris", label: "Doris", port: 9030, user: "root" },
+  starrocks: { dbType: "starrocks", profile: "starrocks", label: "StarRocks", port: 9030, user: "root" },
+  dameng: { dbType: "dameng", profile: "dm", label: "DM (Dameng)", port: 5236, user: "SYSDBA" },
+  dm: { dbType: "dameng", profile: "dm", label: "DM (Dameng)", port: 5236, user: "SYSDBA" },
+  gaussdb: { dbType: "gaussdb", profile: "gaussdb", label: "GaussDB", port: 5432, user: "gaussdb" },
+  kwdb: { dbType: "kwdb", profile: "kwdb", label: "KWDB", port: 26257, user: "root" },
+  opengauss: { dbType: "gaussdb", profile: "opengauss", label: "openGauss", port: 5432, user: "gaussdb" },
+  questdb: { dbType: "questdb", profile: "questdb", label: "QuestDB", port: 8812, user: "questdb" },
+  influxdb: { dbType: "influxdb", profile: "influxdb", label: "InfluxDB", port: 8086, user: "" },
+};
+
+function normalizeKey(value: unknown) {
+  return String(value || "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]/g, "");
+}
+
+function getString(value: unknown) {
+  return typeof value === "string" ? value.trim() : value == null ? "" : String(value).trim();
+}
+
+function getNumber(value: unknown) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
+}
+
+function inferProfile(entry: DbeaverConnectionEntry): ConnectionProfile {
+  const candidates = [entry.provider, entry.driver, entry.configuration?.url, entry.name].map(normalizeKey).join(" ");
+  for (const [needle, profile] of Object.entries(profileMap)) {
+    if (candidates.includes(needle)) return profile;
+  }
+  return { dbType: "jdbc", profile: "jdbc", label: getString(entry.driver) || "JDBC", port: 0, user: "" };
+}
+
+function base64ToBytes(value: string) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+async function decryptCredentialsFile(base64?: string): Promise<Record<string, Record<string, Record<string, string>>>> {
+  if (!base64) return {};
+  const bytes = base64ToBytes(base64);
+  if (bytes.length <= 16) return {};
+
+  try {
+    const iv = bytes.slice(0, 16);
+    const encrypted = bytes.slice(16);
+    const cryptoKey = await crypto.subtle.importKey("raw", dbeaverKey, { name: "AES-CBC" }, false, ["decrypt"]);
+    const decrypted = await crypto.subtle.decrypt({ name: "AES-CBC", iv }, cryptoKey, encrypted);
+    return JSON.parse(new TextDecoder().decode(decrypted));
+  } catch {
+    return {};
+  }
+}
+
+function readCredentials(entry: DbeaverConnectionEntry, credentials: Record<string, Record<string, Record<string, string>>>) {
+  const secure = credentials[entry.id]?.["#connection"] || {};
+  const inline = entry.configuration?.credentials || {};
+  return {
+    username: getString(secure.user || secure.username || inline.user || inline.username || entry.configuration?.user),
+    password: getString(secure.password || inline.password || entry.configuration?.password),
+  };
+}
+
+function parseJdbcUrl(url: string, profile: ConnectionProfile) {
+  const result: {
+    host?: string;
+    port?: number;
+    database?: string;
+    params?: string;
+    username?: string;
+    password?: string;
+    oracleConnectionType?: "service_name" | "sid";
+  } = {};
+  const source = url.trim();
+  if (!source) return result;
+
+  const withoutJdbc = source.replace(/^jdbc:/i, "");
+  const sqlServerMatch = withoutJdbc.match(/^sqlserver:\/\/([^;:/]+)(?::(\d+))?(?:;(.*))?/i);
+  if (sqlServerMatch) {
+    result.host = sqlServerMatch[1];
+    result.port = getNumber(sqlServerMatch[2]);
+    for (const part of (sqlServerMatch[3] || "").split(";")) {
+      const [key, ...rest] = part.split("=");
+      const value = rest.join("=");
+      if (/^(databasename|database)$/i.test(key)) result.database = value;
+      else if (/^user$/i.test(key)) result.username = value;
+      else if (/^password$/i.test(key)) result.password = value;
+    }
+    return result;
+  }
+
+  const oracleServiceMatch = withoutJdbc.match(/^oracle:thin:@\/\/([^:/]+)(?::(\d+))?\/([^?]+)/i);
+  if (oracleServiceMatch) {
+    result.host = oracleServiceMatch[1];
+    result.port = getNumber(oracleServiceMatch[2]);
+    result.database = oracleServiceMatch[3];
+    result.oracleConnectionType = "service_name";
+    return result;
+  }
+
+  const oracleSidMatch = withoutJdbc.match(/^oracle:thin:@([^:/]+)(?::(\d+))?:([^?]+)/i);
+  if (oracleSidMatch) {
+    result.host = oracleSidMatch[1];
+    result.port = getNumber(oracleSidMatch[2]);
+    result.database = oracleSidMatch[3];
+    result.oracleConnectionType = "sid";
+    return result;
+  }
+
+  const sqliteMatch = withoutJdbc.match(/^sqlite:(.+)$/i);
+  if (sqliteMatch) {
+    result.host = sqliteMatch[1];
+    result.database = sqliteMatch[1];
+    return result;
+  }
+
+  try {
+    const parsed = new URL(withoutJdbc);
+    result.host = parsed.hostname;
+    result.port = parsed.port ? Number(parsed.port) : profile.port;
+    result.database = parsed.pathname.replace(/^\/+/, "").split("/")[0] || undefined;
+    result.params = parsed.search.replace(/^\?/, "");
+    result.username = decodeURIComponent(parsed.username || "");
+    result.password = decodeURIComponent(parsed.password || "");
+  } catch {
+    return result;
+  }
+
+  return result;
+}
+
+function extractConnections(parsed: any): DbeaverConnectionEntry[] {
+  const source = parsed?.connections || parsed?.dataSources || parsed?.datasources || parsed;
+  if (!source || typeof source !== "object") return [];
+
+  if (Array.isArray(source)) {
+    return source.filter((entry) => entry && typeof entry === "object").map((entry) => ({ ...entry, id: getString(entry.id || entry.uuid || entry.name) }));
+  }
+
+  return Object.entries(source)
+    .filter(([, entry]) => entry && typeof entry === "object")
+    .map(([id, entry]) => ({ ...(entry as Record<string, any>), id: getString((entry as any).id || id) }));
+}
+
+function buildConnection(entry: DbeaverConnectionEntry, credentials: ReturnType<typeof readCredentials>): ConnectionConfig | null {
+  const profile = inferProfile(entry);
+  const config = entry.configuration || {};
+  const url = getString(config.url);
+  const parsedUrl = parseJdbcUrl(url, profile);
+  const host = getString(config.host || config["host-name"] || parsedUrl.host || (profile.dbType === "sqlite" ? "" : "127.0.0.1"));
+  const database = getString(config.database || config["database-name"] || config.schema || parsedUrl.database);
+  const name = getString(entry.name || database || host || profile.label);
+  if (!entry.id || !name) return null;
+
+  const partial: PartialConnection = {
+    name,
+    db_type: profile.dbType,
+    driver_profile: profile.profile,
+    driver_label: profile.label,
+    url_params: getString(parsedUrl.params),
+    host,
+    port: getNumber(config.port || config["host-port"] || parsedUrl.port) || profile.port,
+    username: credentials.username || getString(parsedUrl.username) || profile.user,
+    password: credentials.password || getString(parsedUrl.password),
+    database: database || undefined,
+    color: getString(config.color || config["connection-color"]),
+    transport_layers: [],
+    connect_timeout_secs: 10,
+    query_timeout_secs: 30,
+    ssl: false,
+    oracle_connection_type: profile.dbType === "oracle" ? parsedUrl.oracleConnectionType || "service_name" : undefined,
+    connection_string: profile.dbType === "jdbc" || profile.dbType === "mongodb" ? url || undefined : undefined,
+    jdbc_driver_class: profile.dbType === "jdbc" ? getString(config["driver-class"] || entry.driver) || undefined : undefined,
+    jdbc_driver_paths: [],
+  };
+
+  return { ...partial, id: uuid() };
+}
+
+export function isDbeaverImportPayload(content: string) {
+  try {
+    const parsed = JSON.parse(content);
+    return parsed?.format === "dbeaver-import";
+  } catch {
+    return false;
+  }
+}
+
+export async function parseDbeaverConnections(content: string): Promise<ConnectionConfig[]> {
+  const payload = JSON.parse(content) as DbeaverImportPayload;
+  if (payload.format !== "dbeaver-import" || !payload.dataSources) {
+    throw new Error("Invalid DBeaver import payload");
+  }
+
+  const dataSources = JSON.parse(payload.dataSources);
+  const encryptedCredentials = await decryptCredentialsFile(payload.credentialsBase64);
+  const configs: ConnectionConfig[] = [];
+  const seen = new Set<string>();
+
+  for (const entry of extractConnections(dataSources)) {
+    const config = buildConnection(entry, readCredentials(entry, encryptedCredentials));
+    if (!config) continue;
+    const key = [config.name, config.db_type, config.host, config.port, config.database || ""].join("\u0000");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    configs.push(config);
+  }
+
+  return configs;
+}
diff --git a/apps/desktop/src/lib/imports/navicatImport.ts b/apps/desktop/src/lib/imports/navicatImport.ts
new file mode 100644
index 0000000..540b830
--- /dev/null
+++ b/apps/desktop/src/lib/imports/navicatImport.ts
@@ -0,0 +1,242 @@
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+import { uuid } from "@/lib/common/utils";
+
+type PartialConnection = Omit<ConnectionConfig, "id">;
+
+type ParsedNode = {
+  tag: string;
+  values: Record<string, string>;
+};
+
+const typeMap: Record<string, { dbType: DatabaseType; profile: string; label: string; port: number; user: string }> = {
+  // String type identifiers (from Navicat ConnType / DatabaseType attributes)
+  mysql: { dbType: "mysql", profile: "mysql", label: "MySQL", port: 3306, user: "root" },
+  mariadb: { dbType: "mysql", profile: "mariadb", label: "MariaDB", port: 3306, user: "root" },
+  postgresql: { dbType: "postgres", profile: "postgres", label: "PostgreSQL", port: 5432, user: "postgres" },
+  postgres: { dbType: "postgres", profile: "postgres", label: "PostgreSQL", port: 5432, user: "postgres" },
+  sqlite: { dbType: "sqlite", profile: "sqlite", label: "SQLite", port: 0, user: "" },
+  sqlserver: { dbType: "sqlserver", profile: "sqlserver", label: "SQL Server", port: 1433, user: "sa" },
+  mssql: { dbType: "sqlserver", profile: "sqlserver", label: "SQL Server", port: 1433, user: "sa" },
+  oracle: { dbType: "oracle", profile: "oracle", label: "Oracle", port: 1521, user: "system" },
+  redis: { dbType: "redis", profile: "redis", label: "Redis", port: 6379, user: "" },
+  mongodb: { dbType: "mongodb", profile: "mongodb", label: "MongoDB", port: 27017, user: "" },
+  mongo: { dbType: "mongodb", profile: "mongodb", label: "MongoDB", port: 27017, user: "" },
+  dameng: { dbType: "dameng", profile: "dm", label: "DM (Dameng)", port: 5236, user: "SYSDBA" },
+  dm: { dbType: "dameng", profile: "dm", label: "DM (Dameng)", port: 5236, user: "SYSDBA" },
+  clickhouse: { dbType: "clickhouse", profile: "clickhouse", label: "ClickHouse", port: 8123, user: "default" },
+  snowflake: { dbType: "snowflake", profile: "snowflake", label: "Snowflake", port: 443, user: "" },
+  kingbase: { dbType: "kingbase", profile: "kingbase", label: "KingbaseES", port: 54321, user: "SYSTEM" },
+  kingbasees: { dbType: "kingbase", profile: "kingbase", label: "KingbaseES", port: 54321, user: "SYSTEM" },
+  gaussdb: { dbType: "gaussdb", profile: "gaussdb", label: "GaussDB", port: 8000, user: "root" },
+  oceanbase: { dbType: "oceanbase-oracle", profile: "oceanbase", label: "OceanBase", port: 2883, user: "root" },
+  // Numeric type codes (Navicat uses numeric ConnType for some exports)
+  "1": { dbType: "mysql", profile: "mysql", label: "MySQL", port: 3306, user: "root" },
+  "2": { dbType: "postgres", profile: "postgres", label: "PostgreSQL", port: 5432, user: "postgres" },
+  "3": { dbType: "sqlite", profile: "sqlite", label: "SQLite", port: 0, user: "" },
+  "4": { dbType: "oracle", profile: "oracle", label: "Oracle", port: 1521, user: "system" },
+  "5": { dbType: "mysql", profile: "mariadb", label: "MariaDB", port: 3306, user: "root" },
+  "7": { dbType: "sqlserver", profile: "sqlserver", label: "SQL Server", port: 1433, user: "sa" },
+  "8": { dbType: "mongodb", profile: "mongodb", label: "MongoDB", port: 27017, user: "" },
+  "9": { dbType: "redis", profile: "redis", label: "Redis", port: 6379, user: "" },
+};
+
+const unsupportedTypes = new Set(["http", "https", "ftp", "sftp", "ssh"]);
+
+function normalizeKey(value: string) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+function getAny(values: Record<string, string>, keys: string[]) {
+  for (const key of keys) {
+    const value = values[normalizeKey(key)];
+    if (value?.trim()) return value.trim();
+  }
+  return "";
+}
+
+function getSqlitePath(values: Record<string, string>) {
+  return getAny(values, ["databaseFile", "databaseFileName", "databaseFilename", "filename", "fileName", "path", "databasePath", "dbPath", "dbFile", "sqliteFile", "sqlitePath", "database", "databaseName"]);
+}
+
+function truthyNavicatFlag(value: string) {
+  const normalized = value.trim().toLowerCase();
+  return ["1", "true", "yes", "y", "on", "checked"].includes(normalized);
+}
+
+function hexToBytes(hex: string) {
+  const clean = hex.trim();
+  if (!clean || clean.length % 2 !== 0 || /[^0-9a-f]/i.test(clean)) return null;
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < clean.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(clean.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+
+function stripPkcs7(bytes: Uint8Array) {
+  const pad = bytes[bytes.length - 1];
+  if (!pad || pad > 16 || pad > bytes.length) return bytes;
+  for (let i = bytes.length - pad; i < bytes.length; i++) {
+    if (bytes[i] !== pad) return bytes;
+  }
+  return bytes.slice(0, bytes.length - pad);
+}
+
+async function decryptNavicatPassword(value: string) {
+  const encrypted = hexToBytes(value);
+  if (!encrypted?.length) return "";
+
+  const key = new TextEncoder().encode("libcckeylibcckey");
+  const iv = new TextEncoder().encode("libcciv libcciv ");
+  try {
+    const cryptoKey = await crypto.subtle.importKey("raw", key, { name: "AES-CBC" }, false, ["decrypt"]);
+    const decrypted = new Uint8Array(await crypto.subtle.decrypt({ name: "AES-CBC", iv }, cryptoKey, encrypted));
+    return new TextDecoder().decode(stripPkcs7(decrypted));
+  } catch {
+    return "";
+  }
+}
+
+function inferProfile(rawType: string, tag: string, port?: number) {
+  const key = normalizeKey(rawType || tag);
+  for (const [needle, profile] of Object.entries(typeMap)) {
+    if (key.includes(needle)) return profile;
+  }
+  if (unsupportedTypes.has(key)) return null;
+  // Port-based fallback for common default ports
+  if (port) {
+    if (port === 6379) return typeMap.redis;
+    if (port === 27017) return typeMap.mongodb;
+    if (port === 5432) return typeMap.postgresql;
+    if (port === 3306) return typeMap.mysql;
+    if (port === 1433) return typeMap.sqlserver;
+    if (port === 1521) return typeMap.oracle;
+  }
+  return null;
+}
+
+function readNode(element: Element): ParsedNode {
+  const values: Record<string, string> = {};
+  for (const attr of Array.from(element.attributes)) {
+    values[normalizeKey(attr.name)] = attr.value;
+  }
+
+  for (const child of Array.from(element.children)) {
+    const key = getAny(valuesFromElement(child), ["name", "key", "property", "field"]);
+    const value = getAny(valuesFromElement(child), ["value", "val", "text", "data"]) || child.textContent?.trim() || "";
+    if (key && value) values[normalizeKey(key)] = value;
+
+    const tag = normalizeKey(child.tagName);
+    const text = child.children.length === 0 ? child.textContent?.trim() || "" : "";
+    if (text && !values[tag]) values[tag] = text;
+    for (const attr of Array.from(child.attributes)) {
+      values[`${tag}${normalizeKey(attr.name)}`] = attr.value;
+    }
+  }
+
+  return { tag: element.tagName, values };
+}
+
+function valuesFromElement(element: Element) {
+  const values: Record<string, string> = {};
+  for (const attr of Array.from(element.attributes)) {
+    values[normalizeKey(attr.name)] = attr.value;
+  }
+  return values;
+}
+
+function isConnectionCandidate(node: ParsedNode) {
+  const type = getAny(node.values, ["connType", "databaseType", "driver", "connectionType", "type"]);
+  const name = getAny(node.values, ["name", "connectionName", "connName", "caption", "title"]);
+  const host = getAny(node.values, ["host", "server", "hostname", "serverHost", "address"]);
+  const file = getSqlitePath(node.values);
+  return !!(name || host || file) && !!(type || host || file);
+}
+
+async function parseConnection(node: ParsedNode): Promise<ConnectionConfig | null> {
+  const rawType = getAny(node.values, ["connType", "databaseType", "driver", "dbType", "connectionType", "type"]);
+  const portValue = Number(getAny(node.values, ["port", "serverPort"]));
+  const port = Number.isFinite(portValue) && portValue > 0 ? portValue : undefined;
+  const profile = inferProfile(rawType, node.tag, port);
+  if (!profile) {
+    const name = getAny(node.values, ["name", "connectionName", "connName", "caption", "title"]) || "(unnamed)";
+    console.warn(`[Navicat Import] 跳过无法识别类型的连接: "${name}" (type="${rawType}", tag="${node.tag}", port=${port ?? "N/A"})`);
+    return null;
+  }
+
+  // Navicat NCX uses ServiceProvider to distinguish vendor-specific database providers.
+  // e.g. OceanBase MySQL reports ConnType="MYSQL" ServiceProvider="AliyunOceanBase"
+  //      OceanBase Oracle reports ConnType="ORACLE" ServiceProvider="AliyunOceanBase"
+  //      GaussDB reports ConnType="POSTGRESQL" ServiceProvider="HuaweiCloudGaussDB"
+  // For OceanBase, ConnType remains the source of truth for the compatibility mode.
+  const serviceProvider = getAny(node.values, ["serviceprovider"]);
+  let effectiveProfile = profile;
+  if (serviceProvider) {
+    const sp = serviceProvider.toLowerCase();
+    if (sp.includes("oceanbase")) {
+      const oceanbaseOracleMode = normalizeKey(rawType).includes("oracle") || profile.dbType === "oracle";
+      effectiveProfile = oceanbaseOracleMode ? { ...profile, dbType: "oceanbase-oracle", profile: "oceanbase-oracle", label: "OceanBase Oracle Mode", port: 2883 } : { ...profile, dbType: "mysql", profile: "oceanbase", label: "OceanBase", port: 2883 };
+    } else if (sp.includes("gaussdb") || sp.includes("huaweicloudgauss")) {
+      effectiveProfile = { ...profile, dbType: "gaussdb", profile: "gaussdb", label: "GaussDB", port: 8000 };
+    }
+  }
+
+  const sqlitePath = effectiveProfile.dbType === "sqlite" ? getSqlitePath(node.values) : "";
+  const name = getAny(node.values, ["name", "connectionName", "connName", "caption", "title"]) || getAny(node.values, ["host", "server", "hostname"]) || sqlitePath || effectiveProfile.label;
+  const host = sqlitePath || getAny(node.values, ["host", "server", "hostname", "serverHost", "address"]) || (effectiveProfile.dbType === "sqlite" ? "" : "127.0.0.1");
+  // Navicat exports OceanBase Oracle connections with Database="ORCL", but OceanBase resolves the target from the username.
+  const database = effectiveProfile.dbType === "sqlite" ? sqlitePath : effectiveProfile.dbType === "oceanbase-oracle" ? "" : getAny(node.values, ["database", "databaseName", "initialDatabase", "serviceName", "sid", "schema"]);
+  const isOracleLike = effectiveProfile.dbType === "oracle" || effectiveProfile.dbType === "oceanbase-oracle";
+  const oracleConnectionType = isOracleLike && getAny(node.values, ["sid"]) ? "sid" : isOracleLike ? "service_name" : undefined;
+  const username = getAny(node.values, ["user", "username", "userName", "uid"]) || profile.user;
+  const password = await decryptNavicatPassword(getAny(node.values, ["password"]));
+  const keepaliveValue = Number(getAny(node.values, ["keepAliveInterval", "keepaliveInterval", "keepAliveTime", "keepaliveTime"]));
+  const keepaliveFlag = getAny(node.values, ["keepAlive", "keepalive", "useKeepAlive", "enableKeepAlive"]);
+  const keepaliveEnabled = !keepaliveFlag || truthyNavicatFlag(keepaliveFlag);
+  const keepaliveInterval = Number.isFinite(keepaliveValue) && keepaliveValue > 0 && keepaliveEnabled ? keepaliveValue : 0;
+
+  const config: PartialConnection = {
+    name,
+    db_type: effectiveProfile.dbType,
+    driver_profile: effectiveProfile.profile,
+    driver_label: effectiveProfile.label,
+    url_params: "",
+    host,
+    port: port || effectiveProfile.port,
+    username,
+    password,
+    database: database || undefined,
+    color: "",
+    transport_layers: [],
+    connect_timeout_secs: 10,
+    query_timeout_secs: 30,
+    keepalive_interval_secs: keepaliveInterval,
+    ssl: false,
+    oracle_connection_type: oracleConnectionType,
+    connection_string: undefined,
+    jdbc_driver_class: undefined,
+    jdbc_driver_paths: [],
+  };
+
+  return { ...config, id: uuid() };
+}
+
+export async function parseNavicatConnections(content: string): Promise<ConnectionConfig[]> {
+  const doc = new DOMParser().parseFromString(content, "application/xml");
+  const parserError = doc.querySelector("parsererror");
+  if (parserError) throw new Error("Invalid Navicat connection file");
+
+  const seen = new Set<string>();
+  const configs: ConnectionConfig[] = [];
+  for (const element of Array.from(doc.querySelectorAll("*"))) {
+    const node = readNode(element);
+    if (!isConnectionCandidate(node)) continue;
+    const config = await parseConnection(node);
+    if (!config) continue;
+    const key = [config.name, config.db_type, config.host, config.port, config.database || ""].join("\u0000");
+    if (seen.has(key)) continue;
+    seen.add(key);
+    configs.push(config);
+  }
+  return configs;
+}
diff --git a/apps/desktop/src/lib/kv/kvKeyTree.ts b/apps/desktop/src/lib/kv/kvKeyTree.ts
new file mode 100644
index 0000000..63a3087
--- /dev/null
+++ b/apps/desktop/src/lib/kv/kvKeyTree.ts
@@ -0,0 +1,136 @@
+import type { KvKeySummary } from "@/lib/backend/api";
+
+export interface KvKeyTreeLeafNode {
+  kind: "leaf";
+  id: string;
+  label: string;
+  key: string;
+  pathSegments: string[];
+  createRevision?: number | null;
+  modRevision?: number | null;
+  version?: number | null;
+  lease?: number | null;
+  valueSize?: number | null;
+}
+
+export interface KvKeyTreeGroupNode {
+  kind: "group";
+  id: string;
+  label: string;
+  pathSegments: string[];
+  children: KvKeyTreeNode[];
+}
+
+export type KvKeyTreeNode = KvKeyTreeLeafNode | KvKeyTreeGroupNode;
+
+export interface KvKeyTreeRow {
+  node: KvKeyTreeNode;
+  depth: number;
+}
+
+function keySegments(key: string): string[] {
+  return key.split("/").filter(Boolean);
+}
+
+function groupId(pathSegments: string[]): string {
+  return `group:${pathSegments.join("\u0000")}`;
+}
+
+function leafId(key: string): string {
+  return `leaf:${key}`;
+}
+
+function sortNodes(nodes: KvKeyTreeNode[]): KvKeyTreeNode[] {
+  return [...nodes]
+    .sort((a, b) => {
+      if (a.kind !== b.kind) return a.kind === "group" ? -1 : 1;
+      return a.label.localeCompare(b.label);
+    })
+    .map((node) => (node.kind === "group" ? { ...node, children: sortNodes(node.children) } : node));
+}
+
+export function buildKvKeyTree(keys: KvKeySummary[]): KvKeyTreeNode[] {
+  const root: KvKeyTreeNode[] = [];
+  const groups = new Map<string, KvKeyTreeGroupNode>();
+
+  for (const key of keys) {
+    const segments = keySegments(key.key);
+    if (segments.length <= 1) {
+      root.push({
+        kind: "leaf",
+        id: leafId(key.key),
+        label: segments[0] || key.key || "/",
+        key: key.key,
+        pathSegments: segments,
+        createRevision: key.createRevision,
+        modRevision: key.modRevision,
+        version: key.version,
+        lease: key.lease,
+        valueSize: key.valueSize,
+      });
+      continue;
+    }
+
+    let current = root;
+    const groupSegments: string[] = [];
+    for (const segment of segments.slice(0, -1)) {
+      groupSegments.push(segment);
+      const id = groupId(groupSegments);
+      let group = groups.get(id);
+      if (!group) {
+        group = { kind: "group", id, label: segment, pathSegments: [...groupSegments], children: [] };
+        groups.set(id, group);
+        current.push(group);
+      }
+      current = group.children;
+    }
+
+    current.push({
+      kind: "leaf",
+      id: leafId(key.key),
+      label: segments[segments.length - 1],
+      key: key.key,
+      pathSegments: segments,
+      createRevision: key.createRevision,
+      modRevision: key.modRevision,
+      version: key.version,
+      lease: key.lease,
+      valueSize: key.valueSize,
+    });
+  }
+
+  return sortNodes(root);
+}
+
+export function collectKvGroupIds(nodes: KvKeyTreeNode[]): Set<string> {
+  const ids = new Set<string>();
+  const walk = (entries: KvKeyTreeNode[]) => {
+    for (const node of entries) {
+      if (node.kind !== "group") continue;
+      ids.add(node.id);
+      walk(node.children);
+    }
+  };
+  walk(nodes);
+  return ids;
+}
+
+export function preserveKvExpandedGroupIds(nodes: KvKeyTreeNode[], previous: ReadonlySet<string>, expandAll = false): Set<string> {
+  const available = collectKvGroupIds(nodes);
+  const next = new Set<string>();
+  for (const id of expandAll ? available : previous) {
+    if (available.has(id)) next.add(id);
+  }
+  return next;
+}
+
+export function flattenVisibleKvKeyTree(nodes: KvKeyTreeNode[], expandedGroupIds: ReadonlySet<string>, depth = 0): KvKeyTreeRow[] {
+  const rows: KvKeyTreeRow[] = [];
+  for (const node of nodes) {
+    rows.push({ node, depth });
+    if (node.kind === "group" && expandedGroupIds.has(node.id)) {
+      rows.push(...flattenVisibleKvKeyTree(node.children, expandedGroupIds, depth + 1));
+    }
+  }
+  return rows;
+}
diff --git a/apps/desktop/src/lib/kv/kvRefreshSelection.ts b/apps/desktop/src/lib/kv/kvRefreshSelection.ts
new file mode 100644
index 0000000..8a41aef
--- /dev/null
+++ b/apps/desktop/src/lib/kv/kvRefreshSelection.ts
@@ -0,0 +1,6 @@
+import type { KvKeySummary } from "@/lib/backend/api";
+
+export function refreshedKvSelectionKey(previousKey: string | null | undefined, refreshedKeys: readonly KvKeySummary[]): string | null {
+  if (!previousKey) return null;
+  return refreshedKeys.some((item) => item.key === previousKey) ? previousKey : null;
+}
diff --git a/apps/desktop/src/lib/kv/kvRootPresentation.ts b/apps/desktop/src/lib/kv/kvRootPresentation.ts
new file mode 100644
index 0000000..a3e9276
--- /dev/null
+++ b/apps/desktop/src/lib/kv/kvRootPresentation.ts
@@ -0,0 +1,5 @@
+export type KvRootKind = "etcd" | "zookeeper";
+
+export function kvRootNodeLabel(kind: KvRootKind): string {
+  return kind === "zookeeper" ? "/" : "Keys";
+}
diff --git a/apps/desktop/src/lib/kv/kvValueDisplay.ts b/apps/desktop/src/lib/kv/kvValueDisplay.ts
new file mode 100644
index 0000000..a3e37e0
--- /dev/null
+++ b/apps/desktop/src/lib/kv/kvValueDisplay.ts
@@ -0,0 +1,79 @@
+import type { KvKeyMetadata } from "@/lib/backend/api";
+
+import { safeJsonFormat } from "@/lib/common/safeJsonFormat";
+
+export interface PrettyPrintJsonResult {
+  ok: boolean;
+  value?: string;
+  error?: "invalid_json";
+}
+
+export interface DisplayItem {
+  label: string;
+  value: string;
+}
+
+export interface ZooKeeperSummaryLabels {
+  revision?: string;
+  version?: string;
+  lease?: string;
+  size?: string;
+}
+
+export function prettyPrintJsonText(text: string): PrettyPrintJsonResult {
+  try {
+    return { ok: true, value: safeJsonFormat(text, 2) };
+  } catch {
+    return { ok: false, error: "invalid_json" };
+  }
+}
+
+function valueLabel(value: number | null | undefined): string {
+  return value == null ? "-" : String(value);
+}
+
+function byteLabel(value: number | null | undefined): string {
+  return value == null ? "- B" : `${value} B`;
+}
+
+function hexLabel(value: number | null | undefined): string {
+  if (value == null) return "-";
+  return `0x${Math.trunc(value).toString(16)}`;
+}
+
+function dateTimeLabel(value: number | null | undefined): string {
+  if (value == null) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return "-";
+  const pad = (part: number) => String(part).padStart(2, "0");
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+
+function metadataNumber(metadata: KvKeyMetadata | null | undefined, key: keyof KvKeyMetadata): number | null | undefined {
+  return metadata?.[key] as number | null | undefined;
+}
+
+export function formatZooKeeperSummaryBadges(metadata: KvKeyMetadata | null | undefined, labels: ZooKeeperSummaryLabels = {}): DisplayItem[] {
+  return [
+    { label: labels.revision ?? "rev", value: valueLabel(metadata?.modRevision ?? metadata?.mzxid) },
+    { label: labels.version ?? "ver", value: valueLabel(metadata?.version) },
+    { label: labels.lease ?? "lease", value: valueLabel(metadata?.lease) },
+    { label: labels.size ?? "size", value: byteLabel(metadata?.valueSize ?? metadata?.dataLength) },
+  ];
+}
+
+export function formatZooKeeperMetadataRows(metadata: KvKeyMetadata | null | undefined): DisplayItem[] {
+  return [
+    { label: "ephemeralOwner", value: hexLabel(metadata?.ephemeralOwner) },
+    { label: "mtime", value: dateTimeLabel(metadata?.mtime) },
+    { label: "ctime", value: dateTimeLabel(metadata?.ctime) },
+    { label: "mZxid", value: hexLabel(metadata?.mzxid) },
+    { label: "pZxid", value: hexLabel(metadataNumber(metadata, "pzxid")) },
+    { label: "cZxid", value: hexLabel(metadata?.czxid) },
+    { label: "dataLength", value: valueLabel(metadata?.dataLength) },
+    { label: "numChildren", value: valueLabel(metadata?.numChildren) },
+    { label: "dataVersion", value: valueLabel(metadata?.version) },
+    { label: "aclVersion", value: valueLabel(metadata?.aversion) },
+    { label: "cVersion", value: valueLabel(metadata?.cversion) },
+  ];
+}
diff --git a/apps/desktop/src/lib/mcp/mcpConfigTemplates.ts b/apps/desktop/src/lib/mcp/mcpConfigTemplates.ts
new file mode 100644
index 0000000..595773f
--- /dev/null
+++ b/apps/desktop/src/lib/mcp/mcpConfigTemplates.ts
@@ -0,0 +1,89 @@
+export type McpEnvEntry = readonly [key: string, value: string];
+
+export interface McpLaunchConfig {
+  command: string;
+  args?: readonly string[];
+}
+
+const DEFAULT_MCP_LAUNCH_CONFIG: McpLaunchConfig = {
+  command: "dbx-mcp-server",
+};
+
+function envObject(envEntries: readonly McpEnvEntry[]): Record<string, string> {
+  return Object.fromEntries(envEntries);
+}
+
+function launchConfig(config?: McpLaunchConfig): McpLaunchConfig {
+  return config ?? DEFAULT_MCP_LAUNCH_CONFIG;
+}
+
+function withLaunchConfig(dbx: Record<string, unknown>, config?: McpLaunchConfig): Record<string, unknown> {
+  const launch = launchConfig(config);
+  dbx.command = launch.command;
+  if (launch.args && launch.args.length > 0) {
+    dbx.args = [...launch.args];
+  }
+  return dbx;
+}
+
+function tomlStringArray(values: readonly string[]): string {
+  return `[${values.map((value) => JSON.stringify(value)).join(", ")}]`;
+}
+
+export function buildMcpJsonConfig(envEntries: readonly McpEnvEntry[] = [], config?: McpLaunchConfig): string {
+  const dbx: Record<string, unknown> = {
+    ...withLaunchConfig({}, config),
+  };
+
+  if (envEntries.length > 0) {
+    dbx.env = envObject(envEntries);
+  }
+
+  return JSON.stringify({ mcpServers: { dbx } }, null, 2);
+}
+
+export function buildMcpVsCodeConfig(envEntries: readonly McpEnvEntry[] = [], config?: McpLaunchConfig): string {
+  const dbx: Record<string, unknown> = {
+    type: "stdio",
+    ...withLaunchConfig({}, config),
+  };
+
+  if (envEntries.length > 0) {
+    dbx.env = envObject(envEntries);
+  }
+
+  return JSON.stringify({ servers: { dbx } }, null, 2);
+}
+
+export function buildMcpCodexConfig(envEntries: readonly McpEnvEntry[] = [], config?: McpLaunchConfig): string {
+  const launch = launchConfig(config);
+  const lines = ["[mcp_servers.dbx]", `command = ${JSON.stringify(launch.command)}`];
+
+  if (launch.args && launch.args.length > 0) {
+    lines.push(`args = ${tomlStringArray(launch.args)}`);
+  }
+
+  if (envEntries.length > 0) {
+    lines.push("");
+    lines.push("[mcp_servers.dbx.env]");
+    for (const [key, value] of envEntries) {
+      lines.push(`${key} = ${JSON.stringify(value)}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+export function buildMcpOpenCodeConfig(envEntries: readonly McpEnvEntry[] = [], config?: McpLaunchConfig): string {
+  const launch = launchConfig(config);
+  const dbx: Record<string, unknown> = {
+    type: "local",
+    command: [launch.command, ...(launch.args ?? [])],
+  };
+
+  if (envEntries.length > 0) {
+    dbx.environment = envObject(envEntries);
+  }
+
+  return JSON.stringify({ mcp: { dbx } }, null, 2);
+}
diff --git a/apps/desktop/src/lib/metadata/completionMetadataPolicy.ts b/apps/desktop/src/lib/metadata/completionMetadataPolicy.ts
new file mode 100644
index 0000000..54fe0a2
--- /dev/null
+++ b/apps/desktop/src/lib/metadata/completionMetadataPolicy.ts
@@ -0,0 +1,11 @@
+import type { DatabaseType } from "@/types/database";
+
+const LOCAL_ONLY_EDITOR_COMPLETION_METADATA_TYPES = new Set<DatabaseType>(["prestosql", "trino"]);
+
+export function usesLocalOnlyEditorCompletionMetadata(databaseType?: DatabaseType): boolean {
+  return !!databaseType && LOCAL_ONLY_EDITOR_COMPLETION_METADATA_TYPES.has(databaseType);
+}
+
+export function usesOnDemandOnlyEditorColumnMetadata(databaseType?: DatabaseType): boolean {
+  return !!databaseType && LOCAL_ONLY_EDITOR_COMPLETION_METADATA_TYPES.has(databaseType);
+}
diff --git a/apps/desktop/src/lib/metadata/completionTreeIndex.ts b/apps/desktop/src/lib/metadata/completionTreeIndex.ts
new file mode 100644
index 0000000..0754b36
--- /dev/null
+++ b/apps/desktop/src/lib/metadata/completionTreeIndex.ts
@@ -0,0 +1,52 @@
+import type { TreeNode } from "@/types/database";
+import type { SqlCompletionTable } from "@/lib/sql/sqlCompletion";
+
+const TABLE_NODE_TYPES = new Set(["table", "view", "materialized_view"]);
+
+export function completionSchemasFromTree(nodes: readonly TreeNode[], connectionId: string, database: string): string[] {
+  const seen = new Set<string>();
+  const schemas: string[] = [];
+  visitTree(nodes, (node) => {
+    if (node.connectionId !== connectionId || node.database !== database || node.type !== "schema" || !node.schema) return;
+    const key = node.schema.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    schemas.push(node.schema);
+  });
+  return schemas;
+}
+
+export function completionTablesFromTree(nodes: readonly TreeNode[], connectionId: string, database: string, schema?: string): SqlCompletionTable[] {
+  const preferredSchema = schema?.toLowerCase();
+  const tables: SqlCompletionTable[] = [];
+  visitTree(nodes, (node) => {
+    if (node.connectionId !== connectionId || node.database !== database || !TABLE_NODE_TYPES.has(node.type)) return;
+    if (preferredSchema && node.schema?.toLowerCase() !== preferredSchema) return;
+    tables.push({
+      name: node.tableName || node.label,
+      schema: node.schema,
+      type: node.type === "view" || node.type === "materialized_view" ? "view" : "table",
+    });
+  });
+  return dedupeCompletionTables(tables);
+}
+
+function visitTree(nodes: readonly TreeNode[], visit: (node: TreeNode) => void) {
+  for (const node of nodes) {
+    visit(node);
+    if (node.children?.length) visitTree(node.children, visit);
+    if (node.hiddenChildren?.length) visitTree(node.hiddenChildren, visit);
+  }
+}
+
+function dedupeCompletionTables(tables: SqlCompletionTable[]): SqlCompletionTable[] {
+  const seen = new Set<string>();
+  const result: SqlCompletionTable[] = [];
+  for (const table of tables) {
+    const key = `${table.schema ?? ""}.${table.name}`.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(table);
+  }
+  return result;
+}
diff --git a/apps/desktop/src/lib/metadata/metadataLoadCoordinator.ts b/apps/desktop/src/lib/metadata/metadataLoadCoordinator.ts
new file mode 100644
index 0000000..892ad40
--- /dev/null
+++ b/apps/desktop/src/lib/metadata/metadataLoadCoordinator.ts
@@ -0,0 +1,145 @@
+import { metadataScopeKey, type MetadataScopeInput } from "./metadataLoadScope";
+
+export type MetadataLoadCacheStatus = "none" | "hit" | "miss" | "stale" | "refresh";
+
+export interface MetadataLoadTraceDetails {
+  cacheStatus?: MetadataLoadCacheStatus;
+  resultCount?: number;
+  deduped?: boolean;
+  force?: boolean;
+  stale?: boolean;
+  superseded?: boolean;
+  error?: unknown;
+}
+
+export interface MetadataLoadTraceEvent extends MetadataLoadTraceDetails {
+  event: string;
+  traceId: string;
+  scopeKey: string;
+  elapsedMs: number;
+}
+
+export type MetadataLoadTraceLogger = (event: MetadataLoadTraceEvent) => void;
+
+export interface MetadataLoadTrace {
+  traceId: string;
+  scopeKey: string;
+  startedAt: number;
+  elapsedMs: () => number;
+  event: (event: string, details?: MetadataLoadTraceDetails) => MetadataLoadTraceEvent;
+}
+
+export interface MetadataLoadCoordinatorEvent {
+  event: "start" | "dedupe" | "done" | "error";
+  key: string;
+  kind: string;
+  active: number;
+  force: boolean;
+}
+
+export type MetadataLoadCoordinatorLogger = (event: MetadataLoadCoordinatorEvent) => void;
+
+export interface MetadataLoadCoordinatorOptions {
+  force?: boolean;
+  kind?: string;
+}
+
+interface InFlightLoad<T> {
+  kind: string;
+  promise: Promise<T>;
+}
+
+function defaultTraceId() {
+  return Math.random().toString(16).slice(2, 10);
+}
+
+function defaultNow() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+
+export function createMetadataLoadTrace(
+  scope: MetadataScopeInput | string,
+  options?: {
+    traceId?: string;
+    now?: () => number;
+  },
+): MetadataLoadTrace {
+  const now = options?.now ?? defaultNow;
+  const startedAt = now();
+  const scopeKey = typeof scope === "string" ? scope : metadataScopeKey(scope);
+  const traceId = options?.traceId ?? defaultTraceId();
+  const elapsedMs = () => Math.max(0, Math.round(now() - startedAt));
+  return {
+    traceId,
+    scopeKey,
+    startedAt,
+    elapsedMs,
+    event: (event, details = {}) => ({
+      event,
+      traceId,
+      scopeKey,
+      elapsedMs: elapsedMs(),
+      ...details,
+    }),
+  };
+}
+
+export function logMetadataLoadTrace(logger: MetadataLoadTraceLogger | undefined, trace: MetadataLoadTrace, event: string, details?: MetadataLoadTraceDetails) {
+  logger?.(trace.event(event, details));
+}
+
+export class MetadataLoadCoordinator {
+  private readonly inFlight = new Map<string, InFlightLoad<unknown>>();
+
+  constructor(private readonly logger?: MetadataLoadCoordinatorLogger) {}
+
+  run<T>(scope: MetadataScopeInput | string, load: () => Promise<T>, options?: MetadataLoadCoordinatorOptions): Promise<T> {
+    const key = typeof scope === "string" ? scope : metadataScopeKey(scope);
+    const kind = options?.kind ?? (typeof scope === "string" ? "metadata" : scope.kind);
+    const force = options?.force === true;
+    const existing = force ? undefined : this.inFlight.get(key);
+    if (existing) {
+      this.logger?.({ event: "dedupe", key, kind: existing.kind, active: this.inFlight.size, force: false });
+      return existing.promise as Promise<T>;
+    }
+
+    this.logger?.({ event: "start", key, kind, active: this.inFlight.size + 1, force });
+    const promise = Promise.resolve()
+      .then(load)
+      .then(
+        (value) => {
+          this.logger?.({ event: "done", key, kind, active: this.inFlight.size, force });
+          return value;
+        },
+        (error) => {
+          this.logger?.({ event: "error", key, kind, active: this.inFlight.size, force });
+          throw error;
+        },
+      )
+      .finally(() => {
+        const current = this.inFlight.get(key);
+        if (current?.promise === promise) {
+          this.inFlight.delete(key);
+        }
+      });
+
+    if (!force) {
+      this.inFlight.set(key, { kind, promise });
+    }
+    return promise;
+  }
+
+  has(scope: MetadataScopeInput | string): boolean {
+    const key = typeof scope === "string" ? scope : metadataScopeKey(scope);
+    return this.inFlight.has(key);
+  }
+
+  clear(scope?: MetadataScopeInput | string) {
+    if (scope === undefined) {
+      this.inFlight.clear();
+      return;
+    }
+    const key = typeof scope === "string" ? scope : metadataScopeKey(scope);
+    this.inFlight.delete(key);
+  }
+}
diff --git a/apps/desktop/src/lib/metadata/metadataLoadScope.ts b/apps/desktop/src/lib/metadata/metadataLoadScope.ts
new file mode 100644
index 0000000..c807fc0
--- /dev/null
+++ b/apps/desktop/src/lib/metadata/metadataLoadScope.ts
@@ -0,0 +1,86 @@
+export type MetadataScopeValue = string | number | boolean | null | undefined;
+
+export interface MetadataScopeInput {
+  kind: string;
+  connectionId?: string | null;
+  database?: string | null;
+  schema?: string | null;
+  nodeKind?: string | null;
+  tableName?: string | null;
+  tableType?: string | null;
+  objectTypes?: readonly (string | null | undefined)[] | null;
+  searchFilter?: string | null;
+  limit?: number | null;
+  offset?: number | null;
+  sidebarDisplayMode?: string | null;
+  driverProfile?: string | null;
+  extra?: Record<string, MetadataScopeValue | readonly MetadataScopeValue[]> | null;
+}
+
+function normalizeString(value: string | null | undefined): string | undefined {
+  if (value == null) return undefined;
+  return value;
+}
+
+function normalizeSearchFilter(value: string | null | undefined): string | undefined {
+  const normalized = value?.trim();
+  return normalized ? normalized : undefined;
+}
+
+function normalizeNumber(value: number | null | undefined): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function normalizeObjectTypes(values: readonly (string | null | undefined)[] | null | undefined): string[] | undefined {
+  if (!values?.length) return undefined;
+  const normalized = values
+    .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+    .map((value) => value.trim().toUpperCase().replace(/\s+/g, "_"))
+    .sort();
+  return normalized.length > 0 ? [...new Set(normalized)] : undefined;
+}
+
+function stableEntries(record: Record<string, unknown>): [string, unknown][] {
+  return Object.entries(record)
+    .filter(([, value]) => value !== undefined)
+    .sort(([left], [right]) => left.localeCompare(right));
+}
+
+function normalizeExtra(extra: MetadataScopeInput["extra"]): Record<string, unknown> | undefined {
+  if (!extra) return undefined;
+  const entries = stableEntries(extra)
+    .map(([key, value]) => {
+      if (Array.isArray(value)) {
+        return [key, value.filter((item) => item !== undefined)] as const;
+      }
+      return [key, value] as const;
+    })
+    .filter(([, value]) => {
+      if (Array.isArray(value)) return value.length > 0;
+      return value !== undefined;
+    });
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+export function metadataScopeParts(input: MetadataScopeInput): Record<string, unknown> {
+  return {
+    kind: input.kind,
+    connectionId: normalizeString(input.connectionId),
+    database: normalizeString(input.database),
+    schema: normalizeString(input.schema),
+    nodeKind: normalizeString(input.nodeKind),
+    tableName: normalizeString(input.tableName),
+    tableType: normalizeString(input.tableType),
+    objectTypes: normalizeObjectTypes(input.objectTypes),
+    searchFilter: normalizeSearchFilter(input.searchFilter),
+    limit: normalizeNumber(input.limit),
+    offset: normalizeNumber(input.offset),
+    sidebarDisplayMode: normalizeString(input.sidebarDisplayMode),
+    driverProfile: normalizeString(input.driverProfile),
+    extra: normalizeExtra(input.extra),
+  };
+}
+
+export function metadataScopeKey(input: MetadataScopeInput): string {
+  return JSON.stringify(stableEntries(metadataScopeParts(input)));
+}
diff --git a/apps/desktop/src/lib/metadata/metadataResultCache.ts b/apps/desktop/src/lib/metadata/metadataResultCache.ts
new file mode 100644
index 0000000..25fb3f3
--- /dev/null
+++ b/apps/desktop/src/lib/metadata/metadataResultCache.ts
@@ -0,0 +1,99 @@
+import { metadataScopeKey, metadataScopeParts, type MetadataScopeInput } from "./metadataLoadScope";
+
+export interface MetadataCacheHit<T> {
+  value: T;
+  cachedAt: number;
+  ageMs: number;
+  stale: boolean;
+}
+
+export type MetadataCacheInvalidation = Partial<Omit<MetadataScopeInput, "extra">>;
+
+interface MetadataCacheEntry<T> {
+  scope: ReturnType<typeof metadataScopeParts>;
+  value: T;
+  cachedAt: number;
+}
+
+export interface MetadataResultCacheOptions {
+  ttlMs: number;
+  maxEntries: number;
+  now?: () => number;
+}
+
+function normalizeInvalidation(match: MetadataCacheInvalidation): Partial<ReturnType<typeof metadataScopeParts>> {
+  const normalized = metadataScopeParts({ ...match, kind: match.kind ?? "__metadata_cache_match__" });
+  const result: Partial<ReturnType<typeof metadataScopeParts>> = {};
+  for (const key of Object.keys(match) as (keyof MetadataCacheInvalidation)[]) {
+    const value = normalized[key as keyof typeof normalized];
+    if (value !== undefined) {
+      (result as Record<string, unknown>)[key] = value;
+    }
+  }
+  return result;
+}
+
+function valuesEqual(left: unknown, right: unknown): boolean {
+  if (Array.isArray(left) || Array.isArray(right) || (left && typeof left === "object") || (right && typeof right === "object")) {
+    return JSON.stringify(left) === JSON.stringify(right);
+  }
+  return left === right;
+}
+
+export class MetadataResultCache<T> {
+  private readonly entries = new Map<string, MetadataCacheEntry<T>>();
+  private readonly now: () => number;
+
+  constructor(private readonly options: MetadataResultCacheOptions) {
+    this.now = options.now ?? Date.now;
+  }
+
+  get(scope: MetadataScopeInput, options?: { allowStale?: boolean }): MetadataCacheHit<T> | undefined {
+    const key = metadataScopeKey(scope);
+    const entry = this.entries.get(key);
+    if (!entry) return undefined;
+    const ageMs = Math.max(0, this.now() - entry.cachedAt);
+    const stale = ageMs > this.options.ttlMs;
+    if (stale && !options?.allowStale) return undefined;
+
+    this.entries.delete(key);
+    this.entries.set(key, entry);
+    return { value: entry.value, cachedAt: entry.cachedAt, ageMs, stale };
+  }
+
+  set(scope: MetadataScopeInput, value: T): void {
+    const key = metadataScopeKey(scope);
+    this.entries.delete(key);
+    this.entries.set(key, { scope: metadataScopeParts(scope), value, cachedAt: this.now() });
+    this.evictOldest();
+  }
+
+  invalidate(match: MetadataCacheInvalidation): number {
+    const normalized = normalizeInvalidation(match);
+    let removed = 0;
+    for (const [key, entry] of this.entries) {
+      const matches = Object.entries(normalized).every(([field, value]) => valuesEqual(entry.scope[field as keyof typeof entry.scope], value));
+      if (matches) {
+        this.entries.delete(key);
+        removed++;
+      }
+    }
+    return removed;
+  }
+
+  clear(): void {
+    this.entries.clear();
+  }
+
+  get size(): number {
+    return this.entries.size;
+  }
+
+  private evictOldest(): void {
+    while (this.entries.size > this.options.maxEntries) {
+      const oldest = this.entries.keys().next().value;
+      if (oldest === undefined) return;
+      this.entries.delete(oldest);
+    }
+  }
+}
diff --git a/apps/desktop/src/lib/metadata/metadataTaskLimiter.ts b/apps/desktop/src/lib/metadata/metadataTaskLimiter.ts
new file mode 100644
index 0000000..570fe3a
--- /dev/null
+++ b/apps/desktop/src/lib/metadata/metadataTaskLimiter.ts
@@ -0,0 +1,70 @@
+export interface MetadataTaskLimiterEvent {
+  scope: string;
+  kind: string;
+  active: number;
+  queued: number;
+}
+
+type MetadataTaskLimiterLogger = (event: MetadataTaskLimiterEvent & { event: "start" | "queued" | "done" }) => void;
+
+interface QueuedTask<T> {
+  kind: string;
+  run: () => Promise<T>;
+  resolve: (value: T) => void;
+  reject: (reason?: unknown) => void;
+}
+
+interface ScopeState {
+  active: number;
+  queue: QueuedTask<unknown>[];
+}
+
+export class MetadataTaskLimiter {
+  private readonly scopes = new Map<string, ScopeState>();
+
+  constructor(
+    private readonly maxActive = 2,
+    private readonly logger?: MetadataTaskLimiterLogger,
+  ) {}
+
+  run<T>(scope: string, kind: string, task: () => Promise<T>): Promise<T> {
+    const normalizedScope = scope || "global";
+    const state = this.stateForScope(normalizedScope);
+    return new Promise<T>((resolve, reject) => {
+      const queued: QueuedTask<T> = { kind, run: task, resolve, reject };
+      if (state.active < this.maxActive) {
+        this.start(normalizedScope, state, queued);
+        return;
+      }
+      state.queue.push(queued as QueuedTask<unknown>);
+      this.logger?.({ event: "queued", scope: normalizedScope, kind, active: state.active, queued: state.queue.length });
+    });
+  }
+
+  private stateForScope(scope: string): ScopeState {
+    let state = this.scopes.get(scope);
+    if (!state) {
+      state = { active: 0, queue: [] };
+      this.scopes.set(scope, state);
+    }
+    return state;
+  }
+
+  private start<T>(scope: string, state: ScopeState, task: QueuedTask<T>) {
+    state.active++;
+    this.logger?.({ event: "start", scope, kind: task.kind, active: state.active, queued: state.queue.length });
+    task
+      .run()
+      .then(task.resolve, task.reject)
+      .finally(() => {
+        state.active--;
+        this.logger?.({ event: "done", scope, kind: task.kind, active: state.active, queued: state.queue.length });
+        const next = state.queue.shift();
+        if (next) {
+          this.start(scope, state, next);
+        } else if (state.active === 0) {
+          this.scopes.delete(scope);
+        }
+      });
+  }
+}
diff --git a/apps/desktop/src/lib/metadata/schemaTreeCache.ts b/apps/desktop/src/lib/metadata/schemaTreeCache.ts
new file mode 100644
index 0000000..f13329a
--- /dev/null
+++ b/apps/desktop/src/lib/metadata/schemaTreeCache.ts
@@ -0,0 +1,41 @@
+export const SCHEMA_TREE_CACHE_TTL_MS = 15 * 60 * 1000;
+
+export interface SchemaTreeCacheEnvelope<T> {
+  version: 2;
+  cachedAt: string;
+  children: T;
+}
+
+export interface DecodedSchemaTreeCache<T> {
+  children: T;
+  isStale: boolean;
+}
+
+export function encodeSchemaTreeCache<T>(children: T, nowMs = Date.now()): SchemaTreeCacheEnvelope<T> {
+  return {
+    version: 2,
+    cachedAt: new Date(nowMs).toISOString(),
+    children,
+  };
+}
+
+export function decodeSchemaTreeCache<T>(payload: unknown, nowMs = Date.now(), ttlMs = SCHEMA_TREE_CACHE_TTL_MS): DecodedSchemaTreeCache<T> | null {
+  if (Array.isArray(payload)) {
+    return { children: payload as T, isStale: true };
+  }
+
+  if (!payload || typeof payload !== "object") return null;
+
+  const envelope = payload as Partial<SchemaTreeCacheEnvelope<unknown>>;
+  if (envelope.version !== 2 || !Array.isArray(envelope.children) || typeof envelope.cachedAt !== "string") {
+    return null;
+  }
+
+  const cachedAtMs = Date.parse(envelope.cachedAt);
+  if (!Number.isFinite(cachedAtMs)) return null;
+
+  return {
+    children: envelope.children as T,
+    isStale: nowMs - cachedAtMs >= ttlMs,
+  };
+}
diff --git a/apps/desktop/src/lib/metadata/tableMetadataCache.ts b/apps/desktop/src/lib/metadata/tableMetadataCache.ts
new file mode 100644
index 0000000..f7c7654
--- /dev/null
+++ b/apps/desktop/src/lib/metadata/tableMetadataCache.ts
@@ -0,0 +1,131 @@
+import type { ColumnInfo, DatabaseType, IndexInfo, QueryTab } from "@/types/database";
+import * as api from "@/lib/backend/api";
+import { editableRowIdentifierColumns } from "@/lib/table/tableEditing";
+import { createMetadataLoadTrace, logMetadataLoadTrace, MetadataLoadCoordinator, type MetadataLoadCacheStatus, type MetadataLoadTraceLogger } from "./metadataLoadCoordinator";
+import type { MetadataScopeInput } from "./metadataLoadScope";
+import { MetadataResultCache, type MetadataCacheInvalidation } from "./metadataResultCache";
+
+export const TABLE_METADATA_CACHE_TTL_MS = 30_000;
+const TABLE_METADATA_CACHE_MAX_ENTRIES = 120;
+
+export interface TableMetadata {
+  schema?: string;
+  tableName: string;
+  tableType?: string;
+  catalog?: string;
+  columns: ColumnInfo[];
+  indexes: IndexInfo[];
+  primaryKeys: string[];
+  cachedAt: number;
+}
+
+export interface TableMetadataRequest {
+  connectionId: string;
+  database: string;
+  schema?: string;
+  tableName: string;
+  tableType?: string;
+  databaseType: DatabaseType | string;
+  driverProfile?: string;
+  catalog?: string;
+  force?: boolean;
+  traceLogger?: MetadataLoadTraceLogger;
+}
+
+export interface TableMetadataLoadResult {
+  metadata: TableMetadata;
+  cacheStatus: MetadataLoadCacheStatus;
+  ageMs: number;
+}
+
+const tableMetadataCache = new MetadataResultCache<TableMetadata>({
+  ttlMs: TABLE_METADATA_CACHE_TTL_MS,
+  maxEntries: TABLE_METADATA_CACHE_MAX_ENTRIES,
+});
+
+const tableMetadataCoordinator = new MetadataLoadCoordinator((event) => {
+  console.debug("[DBX][metadata-load:table-coordinator]", event);
+});
+
+export function tableMetadataScope(request: Pick<TableMetadataRequest, "connectionId" | "database" | "schema" | "tableName" | "tableType" | "driverProfile" | "databaseType" | "catalog">): MetadataScopeInput {
+  return {
+    kind: "table-metadata",
+    connectionId: request.connectionId,
+    database: request.database,
+    schema: request.schema ?? "",
+    tableName: request.tableName,
+    tableType: request.tableType,
+    driverProfile: request.driverProfile || request.databaseType,
+    extra: request.catalog ? { catalog: request.catalog } : undefined,
+  };
+}
+
+export function getCachedTableMetadata(request: Pick<TableMetadataRequest, "connectionId" | "database" | "schema" | "tableName" | "tableType" | "driverProfile" | "databaseType" | "catalog">): TableMetadataLoadResult | undefined {
+  const hit = tableMetadataCache.get(tableMetadataScope(request));
+  if (!hit) return undefined;
+  return { metadata: hit.value, cacheStatus: hit.stale ? "stale" : "hit", ageMs: hit.ageMs };
+}
+
+export function tableMetadataToDataTabMeta(metadata: TableMetadata, schema = metadata.schema): NonNullable<QueryTab["tableMeta"]> {
+  return {
+    schema,
+    tableName: metadata.tableName,
+    tableType: metadata.tableType,
+    catalog: metadata.catalog,
+    columns: metadata.columns,
+    primaryKeys: metadata.primaryKeys,
+  };
+}
+
+export async function loadTableMetadata(request: TableMetadataRequest): Promise<TableMetadataLoadResult> {
+  const scope = tableMetadataScope(request);
+  const trace = createMetadataLoadTrace(scope);
+  if (!request.force) {
+    const cached = tableMetadataCache.get(scope);
+    if (cached) {
+      logMetadataLoadTrace(request.traceLogger, trace, "cache-hit", {
+        cacheStatus: cached.stale ? "stale" : "hit",
+        resultCount: cached.value.columns.length,
+        stale: cached.stale,
+      });
+      return { metadata: cached.value, cacheStatus: cached.stale ? "stale" : "hit", ageMs: cached.ageMs };
+    }
+  }
+
+  logMetadataLoadTrace(request.traceLogger, trace, "cache-miss", { cacheStatus: request.force ? "refresh" : "miss", force: request.force === true });
+  const metadata = await tableMetadataCoordinator.run(
+    scope,
+    async () => {
+      const columns = await api.getColumns(request.connectionId, request.database, request.schema ?? "", request.tableName, request.catalog);
+      const indexes = await api.listIndexes(request.connectionId, request.database, request.schema ?? "", request.tableName, request.catalog).catch((): IndexInfo[] => []);
+      const primaryKeys = editableRowIdentifierColumns(request.databaseType as DatabaseType, columns, indexes, request.tableType);
+      return {
+        schema: request.schema || undefined,
+        tableName: request.tableName,
+        tableType: request.tableType,
+        catalog: request.catalog,
+        columns,
+        indexes,
+        primaryKeys,
+        cachedAt: Date.now(),
+      };
+    },
+    { force: request.force, kind: scope.kind },
+  );
+
+  tableMetadataCache.set(scope, metadata);
+  logMetadataLoadTrace(request.traceLogger, trace, "done", {
+    cacheStatus: request.force ? "refresh" : "miss",
+    resultCount: metadata.columns.length,
+    force: request.force === true,
+  });
+  return { metadata, cacheStatus: request.force ? "refresh" : "miss", ageMs: 0 };
+}
+
+export function invalidateTableMetadataCache(match: MetadataCacheInvalidation): number {
+  return tableMetadataCache.invalidate(match);
+}
+
+export function clearTableMetadataCache(): void {
+  tableMetadataCache.clear();
+}
diff --git a/apps/desktop/src/lib/mongo/mongoCompletion.ts b/apps/desktop/src/lib/mongo/mongoCompletion.ts
new file mode 100644
index 0000000..211bbd2
--- /dev/null
+++ b/apps/desktop/src/lib/mongo/mongoCompletion.ts
@@ -0,0 +1,415 @@
+export type MongoCompletionMode = "root" | "collection" | "method" | "cursorMethod" | "field" | "operator" | "stage";
+
+export interface MongoCompletionField {
+  name: string;
+  type?: string;
+}
+
+export interface MongoCompletionItem {
+  label: string;
+  type: "column" | "function" | "keyword" | "snippet" | "table";
+  detail?: string;
+  info?: string;
+  apply?: string;
+  boost: number;
+}
+
+export interface MongoCompletionContext {
+  mode: MongoCompletionMode;
+  prefix: string;
+  from: number;
+  collection?: string;
+}
+
+export interface MongoCompletionInput {
+  collections?: string[];
+  fields?: MongoCompletionField[];
+}
+
+const COLLECTION_METHODS = [
+  { label: "find", detail: "Query matching documents", apply: "find({})" },
+  { label: "findOne", detail: "Query one matching document", apply: "findOne({})" },
+  { label: "aggregate", detail: "Run an aggregation pipeline", apply: "aggregate([])" },
+  { label: "countDocuments", detail: "Count matching documents", apply: "countDocuments({})" },
+  { label: "distinct", detail: "Return distinct field values", apply: 'distinct("${field}", {})' },
+  { label: "insertOne", detail: "Insert one document", apply: "insertOne({})" },
+  { label: "insertMany", detail: "Insert multiple documents", apply: "insertMany([{}])" },
+  { label: "updateOne", detail: "Update one matching document", apply: "updateOne({}, { $set: {} })" },
+  { label: "updateMany", detail: "Update all matching documents", apply: "updateMany({}, { $set: {} })" },
+  { label: "deleteOne", detail: "Delete one matching document", apply: "deleteOne({})" },
+  { label: "deleteMany", detail: "Delete all matching documents", apply: "deleteMany({})" },
+  { label: "getIndexes", detail: "List collection indexes", apply: "getIndexes()" },
+  { label: "stats", detail: "Show collection statistics", apply: "stats()" },
+  { label: "dataSize", detail: "Total size of documents in bytes", apply: "dataSize()" },
+  { label: "storageSize", detail: "Allocated storage size in bytes", apply: "storageSize()" },
+  { label: "totalIndexSize", detail: "Total size of all indexes in bytes", apply: "totalIndexSize()" },
+  { label: "createIndex", detail: "Create an index", apply: "createIndex({ ${field}: 1 })" },
+  { label: "dropIndex", detail: "Drop one index", apply: 'dropIndex("${indexName}")' },
+  { label: "dropIndexes", detail: "Drop collection indexes", apply: "dropIndexes()" },
+] as const;
+
+const CURSOR_METHODS = [
+  { label: "sort", detail: "Sort cursor results", apply: "sort({ ${field}: 1 })" },
+  { label: "limit", detail: "Limit cursor results", apply: "limit(100)" },
+  { label: "skip", detail: "Skip cursor results", apply: "skip(0)" },
+] as const;
+
+const ROOT_SNIPPETS = [
+  { label: "db.collection.find", detail: "Find documents", apply: "db.${collection}.find({})" },
+  { label: "db.collection.aggregate", detail: "Aggregation pipeline", apply: "db.${collection}.aggregate([\n  { $match: {} }\n])" },
+  { label: "db.getCollection", detail: "Reference a collection by name", apply: 'db.getCollection("${collection}")' },
+] as const;
+
+const FIELD_SNIPPETS = [
+  { label: "ObjectId", detail: "MongoDB ObjectId value", apply: 'ObjectId("${id}")' },
+  { label: "ISODate", detail: "MongoDB ISODate value", apply: 'ISODate("${date}")' },
+  { label: "$regex", detail: "Regular expression match", apply: '$regex: "${pattern}"' },
+  { label: "$in", detail: "Match any value in array", apply: "$in: []" },
+  { label: "$gte", detail: "Greater than or equal", apply: "$gte: ${value}" },
+  { label: "$lte", detail: "Less than or equal", apply: "$lte: ${value}" },
+] as const;
+
+const QUERY_OPERATORS = ["$eq", "$ne", "$gt", "$gte", "$lt", "$lte", "$in", "$nin", "$exists", "$regex", "$and", "$or", "$nor", "$not", "$elemMatch"];
+const UPDATE_OPERATORS = ["$set", "$unset", "$inc", "$push", "$pull", "$addToSet", "$rename", "$currentDate", "$setOnInsert"];
+const PIPELINE_STAGES = ["$match", "$project", "$group", "$sort", "$limit", "$skip", "$unwind", "$lookup", "$addFields", "$count", "$facet"];
+const QUERY_METHODS = ["find", "findOne", "countDocuments", "updateOne", "updateMany", "deleteOne", "deleteMany", "dropIndex", "dropIndexes", "sort"];
+
+export function getMongoCompletionContext(text: string, cursor: number): MongoCompletionContext {
+  const safeCursor = Math.max(0, Math.min(cursor, text.length));
+  const operatorPrefix = readOperatorPrefix(text, safeCursor);
+  const collection = extractActiveCollection(text, safeCursor);
+
+  if (operatorPrefix) {
+    return {
+      mode: isLikelyAggregationPipeline(text, safeCursor) ? "stage" : "operator",
+      prefix: operatorPrefix.prefix,
+      from: operatorPrefix.from,
+      collection,
+    };
+  }
+
+  const propertyPrefix = readPropertyPrefix(text, safeCursor);
+  const beforeCursor = text.slice(0, safeCursor);
+
+  if (isInsideOperatorValueObject(beforeCursor)) {
+    return { mode: "operator", prefix: propertyPrefix.prefix, from: propertyPrefix.from, collection };
+  }
+
+  if (/db\.$/.test(beforeCursor)) {
+    return { mode: "collection", prefix: "", from: safeCursor, collection };
+  }
+
+  const collectionPrefix = matchDbCollectionPrefix(beforeCursor);
+  if (collectionPrefix) {
+    return { mode: "collection", prefix: collectionPrefix.prefix, from: collectionPrefix.from, collection };
+  }
+
+  if (isAfterCollectionDot(beforeCursor)) {
+    const methodPrefix = readMethodPrefix(beforeCursor);
+    return { mode: "method", prefix: methodPrefix.prefix, from: methodPrefix.from, collection };
+  }
+
+  if (isAfterCursorMethodDot(beforeCursor)) {
+    const methodPrefix = readMethodPrefix(beforeCursor);
+    return { mode: "cursorMethod", prefix: methodPrefix.prefix, from: methodPrefix.from, collection };
+  }
+
+  if (isLikelyFieldPosition(text, safeCursor)) {
+    return { mode: "field", prefix: propertyPrefix.prefix, from: propertyPrefix.from, collection };
+  }
+
+  return { mode: "root", prefix: propertyPrefix.prefix, from: propertyPrefix.from, collection };
+}
+
+export function buildMongoCompletionItems(text: string, cursor: number, input: MongoCompletionInput = {}): MongoCompletionItem[] {
+  return buildMongoCompletionItemsFromContext(getMongoCompletionContext(text, cursor), input);
+}
+
+export function buildMongoCompletionItemsFromContext(context: MongoCompletionContext, input: MongoCompletionInput = {}): MongoCompletionItem[] {
+  if (context.mode === "collection") return collectionItems(context.prefix, input.collections ?? []);
+  if (context.mode === "method") return methodItems(context.prefix);
+  if (context.mode === "cursorMethod") return cursorMethodItems(context.prefix);
+  if (context.mode === "field") return fieldItems(context.prefix, input.fields ?? []);
+  if (context.mode === "operator") return operatorItems(context.prefix);
+  if (context.mode === "stage") return stageItems(context.prefix);
+  return rootItems(context.prefix);
+}
+
+export function shouldAutoOpenMongoCompletion(text: string, cursor: number): boolean {
+  const previousChar = text[cursor - 1];
+  if (!previousChar) return false;
+  if (/db\.$/.test(text.slice(0, cursor))) return true;
+  if (previousChar === "$" || previousChar === "." || previousChar === '"') return true;
+  if (/[{,[]/.test(previousChar)) return isLikelyFieldPosition(text, cursor) || isLikelyAggregationPipeline(text, cursor);
+  if (/[\w_$.-]/.test(previousChar)) return true;
+  return false;
+}
+
+export function getMongoCompletionResultValidFor(): RegExp {
+  return /[\w_$.-]*$/;
+}
+
+export function inferMongoCompletionFields(documents: unknown[]): MongoCompletionField[] {
+  const typeByPath = new Map<string, Set<string>>();
+  for (const doc of documents) collectFieldTypes(doc, "", typeByPath, 0);
+  return [...typeByPath.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, types]) => ({ name, type: [...types].sort().join(" | ") }));
+}
+
+function rootItems(prefix: string): MongoCompletionItem[] {
+  const snippets = ROOT_SNIPPETS.filter((snippet) => matchesFuzzyPrefix(snippet.label, prefix)).map((snippet) => ({
+    label: snippet.label,
+    type: "snippet" as const,
+    detail: snippet.detail,
+    apply: snippet.apply,
+    boost: 120,
+  }));
+  const methods = [...COLLECTION_METHODS, ...CURSOR_METHODS]
+    .filter((method) => matchesFuzzyPrefix(method.label, prefix))
+    .map((method) => ({
+      label: method.label,
+      type: "function" as const,
+      detail: method.detail,
+      apply: method.apply,
+      boost: 100,
+    }));
+  return dedupeAndSort([...snippets, ...methods]);
+}
+
+function collectionItems(prefix: string, collections: string[]): MongoCompletionItem[] {
+  return collections
+    .filter((collection) => matchesFuzzyPrefix(collection, prefix))
+    .slice(0, 100)
+    .map((collection) => ({
+      label: collection,
+      type: "table" as const,
+      detail: "collection",
+      apply: needsGetCollectionSyntax(collection) ? `getCollection("${escapeDoubleQuoted(collection)}")` : collection,
+      boost: collection.toLowerCase().startsWith(prefix.toLowerCase()) ? 120 : 90,
+    }));
+}
+
+function methodItems(prefix: string): MongoCompletionItem[] {
+  return dedupeAndSort(
+    [...COLLECTION_METHODS, ...CURSOR_METHODS]
+      .filter((method) => matchesFuzzyPrefix(method.label, prefix))
+      .map((method) => ({
+        label: method.label,
+        type: "function" as const,
+        detail: method.detail,
+        apply: method.apply,
+        boost: method.label === "find" || method.label === "aggregate" ? 130 : 100,
+      })),
+  );
+}
+
+function cursorMethodItems(prefix: string): MongoCompletionItem[] {
+  return dedupeAndSort(
+    CURSOR_METHODS.filter((method) => matchesFuzzyPrefix(method.label, prefix)).map((method) => ({
+      label: method.label,
+      type: "function" as const,
+      detail: method.detail,
+      apply: method.apply,
+      boost: method.label === "limit" ? 130 : 110,
+    })),
+  );
+}
+
+function fieldItems(prefix: string, fields: MongoCompletionField[]): MongoCompletionItem[] {
+  const normalizedPrefix = normalizeMongoKeyPrefix(prefix);
+  const observedFields = fields
+    .filter((field) => matchesFuzzyPrefix(field.name, normalizedPrefix))
+    .slice(0, 100)
+    .map((field) => ({
+      label: field.name,
+      type: "column" as const,
+      detail: field.type ? `observed field · ${field.type}` : "observed field",
+      apply: mongoFieldApplyText(field.name, prefix),
+      boost: field.name.toLowerCase().startsWith(normalizedPrefix.toLowerCase()) ? 120 : 85,
+    }));
+  const snippets = FIELD_SNIPPETS.filter((snippet) => matchesFuzzyPrefix(snippet.label, normalizedPrefix)).map((snippet) => ({
+    label: snippet.label,
+    type: "snippet" as const,
+    detail: snippet.detail,
+    apply: snippet.apply,
+    boost: 95,
+  }));
+  return dedupeAndSort([...observedFields, ...snippets]);
+}
+
+function operatorItems(prefix: string): MongoCompletionItem[] {
+  return [...QUERY_OPERATORS, ...UPDATE_OPERATORS]
+    .filter((operator) => matchesFuzzyPrefix(operator, prefix))
+    .map((operator) => ({
+      label: operator,
+      type: "keyword" as const,
+      detail: operator.startsWith("$set") || UPDATE_OPERATORS.includes(operator) ? "update operator" : "query operator",
+      apply: operator,
+      boost: operator === "$set" || operator === "$match" ? 115 : 90,
+    }));
+}
+
+function stageItems(prefix: string): MongoCompletionItem[] {
+  const stages = PIPELINE_STAGES.filter((stage) => matchesFuzzyPrefix(stage, prefix)).map((stage) => ({
+    label: stage,
+    type: "keyword" as const,
+    detail: "aggregation stage",
+    apply: stage,
+    boost: stage === "$match" || stage === "$project" ? 120 : 95,
+  }));
+  const snippets = [
+    { label: "$match stage", apply: "$match: {}", detail: "Filter documents in a pipeline" },
+    { label: "$group stage", apply: '$group: { _id: "$${field}", count: { $sum: 1 } }', detail: "Group documents" },
+    { label: "$lookup stage", apply: '$lookup: { from: "${collection}", localField: "${field}", foreignField: "_id", as: "${as}" }', detail: "Join another collection" },
+  ]
+    .filter((snippet) => matchesFuzzyPrefix(snippet.label, prefix))
+    .map((snippet) => ({ ...snippet, type: "snippet" as const, boost: 110 }));
+  return dedupeAndSort([...snippets, ...stages]);
+}
+
+function readPropertyPrefix(text: string, cursor: number): { prefix: string; from: number } {
+  let from = cursor;
+  while (from > 0 && /[\w_$.-]/.test(text[from - 1] ?? "")) from--;
+  if (text[from - 1] === '"' || text[from - 1] === "'") from--;
+  return { prefix: text.slice(from, cursor), from };
+}
+
+function readOperatorPrefix(text: string, cursor: number): { prefix: string; from: number } | null {
+  let from = cursor;
+  while (from > 0 && /[\w$]/.test(text[from - 1] ?? "")) from--;
+  const prefix = text.slice(from, cursor);
+  return prefix.startsWith("$") ? { prefix, from } : null;
+}
+
+function readMethodPrefix(beforeCursor: string): { prefix: string; from: number } {
+  const dot = beforeCursor.lastIndexOf(".");
+  const from = dot >= 0 ? dot + 1 : beforeCursor.length;
+  return { prefix: beforeCursor.slice(from), from };
+}
+
+function matchDbCollectionPrefix(beforeCursor: string): { prefix: string; from: number } | null {
+  const match = /(?:^|[\s;(])db\.([A-Za-z_][\w$-]*)$/.exec(beforeCursor);
+  if (!match) return null;
+  const prefix = match[1] ?? "";
+  return { prefix, from: beforeCursor.length - prefix.length };
+}
+
+function isAfterCollectionDot(beforeCursor: string): boolean {
+  return /(?:^|[\s;(])db\.(?:[A-Za-z_][\w$-]*|getCollection\(["'][^"']+["']\))\.[\w$-]*$/.test(beforeCursor);
+}
+
+function isAfterCursorMethodDot(beforeCursor: string): boolean {
+  return /(?:^|[\s;(])db\.(?:[A-Za-z_][\w$-]*|getCollection\(["'][^"']+["']\))\.(?:find|aggregate)\s*\([\s\S]*\)(?:\s*\.\s*(?:sort|skip|limit)\s*\([\s\S]*\))*\s*\.\s*[\w$-]*$/.test(beforeCursor);
+}
+
+function isLikelyFieldPosition(text: string, cursor: number): boolean {
+  const before = text.slice(0, cursor);
+  if (!/[{,]\s*["']?[\w$.-]*$/.test(before)) return false;
+  const call = findInnermostMongoCall(before);
+  if (!call) return false;
+  if (call.method === "aggregate") return isLikelyAggregationPipeline(text, cursor);
+  if (!QUERY_METHODS.includes(call.method)) return false;
+  if (isInsideOperatorValueObject(before)) return false;
+  return true;
+}
+
+function isLikelyAggregationPipeline(text: string, cursor: number): boolean {
+  const before = text.slice(0, cursor);
+  const aggregatePos = before.lastIndexOf(".aggregate");
+  if (aggregatePos < 0) return false;
+  const afterAggregate = before.slice(aggregatePos);
+  return afterAggregate.lastIndexOf("[") > afterAggregate.lastIndexOf("]");
+}
+
+function extractActiveCollection(text: string, cursor: number): string | undefined {
+  const before = text.slice(0, cursor);
+  const getCollectionMatches = [...before.matchAll(/db\.getCollection\(["']([^"']+)["']\)/g)];
+  const directMatches = [...before.matchAll(/db\.([A-Za-z_][\w$-]*)\s*\./g)].filter((match) => match[1] !== "getCollection");
+  const lastGetCollection = getCollectionMatches[getCollectionMatches.length - 1];
+  const lastDirect = directMatches[directMatches.length - 1];
+  const getCollectionIndex = lastGetCollection?.index ?? -1;
+  const directIndex = lastDirect?.index ?? -1;
+  if (getCollectionIndex > directIndex) return lastGetCollection?.[1];
+  return lastDirect?.[1];
+}
+
+function collectFieldTypes(value: unknown, prefix: string, out: Map<string, Set<string>>, depth: number) {
+  if (depth > 4 || value == null || typeof value !== "object") return;
+  if (Array.isArray(value)) {
+    for (const item of value.slice(0, 3)) collectFieldTypes(item, prefix, out, depth + 1);
+    return;
+  }
+  for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (!out.has(path)) out.set(path, new Set());
+    out.get(path)?.add(describeMongoValueType(child));
+    collectFieldTypes(child, path, out, depth + 1);
+  }
+}
+
+function describeMongoValueType(value: unknown): string {
+  if (value == null) return "null";
+  if (Array.isArray(value)) return "array";
+  if (value instanceof Date) return "date";
+  return typeof value === "object" ? "object" : typeof value;
+}
+
+function quoteMongoFieldName(field: string, prefix: string): string {
+  if (prefix.startsWith('"')) return `"${escapeDoubleQuoted(field)}"`;
+  if (prefix.startsWith("'")) return `'${field.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+  return field;
+}
+
+function mongoFieldApplyText(field: string, prefix: string): string {
+  const quoted = quoteMongoFieldName(field, prefix);
+  return `${quoted}: `;
+}
+
+function findInnermostMongoCall(beforeCursor: string): { method: string; openParenIndex: number } | null {
+  const callPattern = /\.(find|findOne|countDocuments|updateOne|updateMany|deleteOne|deleteMany|aggregate|sort)\s*\(/g;
+  let match: RegExpExecArray | null;
+  let result: { method: string; openParenIndex: number } | null = null;
+  while ((match = callPattern.exec(beforeCursor))) {
+    const method = match[1];
+    const openParenIndex = match.index + match[0].lastIndexOf("(");
+    if (method) result = { method, openParenIndex };
+  }
+  return result;
+}
+
+function isInsideOperatorValueObject(beforeCursor: string): boolean {
+  const call = findInnermostMongoCall(beforeCursor);
+  if (!call) return false;
+  const callArgumentsBeforeCursor = beforeCursor.slice(call.openParenIndex + 1);
+  return /(?:^|[{,])\s*["']?[\w$.-]+["']?\s*:\s*\{\s*["']?[\w$.-]*$/.test(callArgumentsBeforeCursor);
+}
+
+function normalizeMongoKeyPrefix(prefix: string): string {
+  return prefix.replace(/^["']/, "");
+}
+
+function needsGetCollectionSyntax(collection: string): boolean {
+  return !/^[A-Za-z_][\w$]*$/.test(collection);
+}
+
+function escapeDoubleQuoted(value: string): string {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+function matchesFuzzyPrefix(value: string, prefix: string): boolean {
+  const normalizedValue = value.toLowerCase();
+  const normalizedPrefix = prefix.toLowerCase().replace(/^["']/, "");
+  if (!normalizedPrefix) return true;
+  return normalizedValue.startsWith(normalizedPrefix) || normalizedValue.includes(normalizedPrefix);
+}
+
+function dedupeAndSort(items: MongoCompletionItem[]): MongoCompletionItem[] {
+  const seen = new Set<string>();
+  const deduped: MongoCompletionItem[] = [];
+  for (const item of items) {
+    const key = `${item.type}:${item.label}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(item);
+  }
+  return deduped.sort((a, b) => b.boost - a.boost || a.label.localeCompare(b.label));
+}
diff --git a/apps/desktop/src/lib/mongo/mongoConnectionOptions.ts b/apps/desktop/src/lib/mongo/mongoConnectionOptions.ts
new file mode 100644
index 0000000..7fb36fc
--- /dev/null
+++ b/apps/desktop/src/lib/mongo/mongoConnectionOptions.ts
@@ -0,0 +1,83 @@
+export function mongoUrlParam(urlParams: string | undefined, key: string): string {
+  const params = parseMongoUrlParams(urlParams);
+  return params.get(key) || "";
+}
+
+export function setMongoUrlParam(urlParams: string | undefined, key: string, value: string): string {
+  const params = parseMongoUrlParams(urlParams);
+  const normalized = value.trim();
+  if (normalized) {
+    params.set(key, normalized);
+  } else {
+    params.delete(key);
+  }
+  return params.toString();
+}
+
+export function mongoUrlParamIsTrue(urlParams: string | undefined, key: string, defaultValue = false): boolean {
+  const value = mongoUrlParam(urlParams, key);
+  if (!value) return defaultValue;
+  return ["true", "1", "yes"].includes(value.toLowerCase());
+}
+
+export function setMongoUrlParamBoolean(urlParams: string | undefined, key: string, value: boolean, defaultWhenEnabled = false): string {
+  if (value === defaultWhenEnabled) {
+    return setMongoUrlParam(urlParams, key, "");
+  }
+  return setMongoUrlParam(urlParams, key, value ? "true" : "false");
+}
+
+export function normalizeMongoTlsFormState(ssl: boolean, urlParams: string | undefined, caCertPath: string | undefined): { urlParams: string; caCertPath: string } {
+  if (ssl) {
+    const nextCaCertPath = caCertPath?.trim() || "";
+    let nextUrlParams = urlParams || "";
+    if (nextCaCertPath) {
+      nextUrlParams = setMongoUrlParam(nextUrlParams, "tlsCAFile", "");
+    }
+    return { urlParams: nextUrlParams, caCertPath: nextCaCertPath };
+  }
+  const next = setMongoUrlParam(setMongoUrlParam(setMongoUrlParam(urlParams, "tlsAllowInvalidCertificates", ""), "tlsAllowInvalidHostnames", ""), "tlsCAFile", "");
+  return { urlParams: next, caCertPath: "" };
+}
+
+export function mongodbAuthFailureHint(message: string): string {
+  const normalizedMessage = message.toLowerCase();
+  if (normalizedMessage.includes("tlsallowinvalidhostnames is an invalid option")) {
+    return `${message}\n\nDBX uses the Rust MongoDB driver (rustls), which does not accept tlsAllowInvalidHostnames in the connection string. Use tlsAllowInvalidCertificates=true instead. This is commonly required for AWS DocumentDB over an SSH tunnel because the local endpoint is 127.0.0.1 while the server certificate is issued for the DocumentDB hostname.`;
+  }
+
+  if (message.includes('certificate not valid for name "127.0.0.1"') || (message.includes("invalid peer certificate") && message.includes("127.0.0.1") && message.includes("docdb"))) {
+    return `${message}\n\nTLS hostname verification failed because the SSH tunnel connects to 127.0.0.1, but the DocumentDB certificate is issued for the cluster hostname. Add tlsAllowInvalidCertificates=true to URL params. Keep tlsCAFile configured so the certificate chain is still trusted when possible.`;
+  }
+
+  if (message.includes("cannot specify multiple seeds with directConnection=true")) {
+    return `${message}\n\nMongoDB directConnection=true can only be used with a single host. Remove directConnection=true when using a multi-host replica set URL, or keep only one reachable host if you need a direct connection.`;
+  }
+
+  if (message.includes("no records found") && message.includes("_mongodb._tcp.")) {
+    return `${message}\n\nMongoDB SRV URLs require a DNS hostname with SRV records. For an IP address or normal host:port endpoint, use mongodb://host:port instead of mongodb+srv://host.`;
+  }
+
+  if (message.includes("ReplicaSetNoPrimary") && message.includes("127.0.0.1:27017")) {
+    return `${message}\n\nThe replica set is advertising 127.0.0.1:27017, which points back to this app machine instead of the MongoDB server. Add directConnection=true for a single reachable endpoint, or reconfigure the replica set members to advertise addresses reachable from this app.`;
+  }
+
+  if (message.includes("must be URL encoded") || message.includes("cannot contain unescaped %")) {
+    return `${message}\n\nMongoDB URL mode requires reserved characters in usernames and passwords to be percent-encoded. For example, @ becomes %40, # becomes %23, / becomes %2F, : becomes %3A, and % becomes %25.`;
+  }
+
+  if (message.includes("not authorized") && message.includes("listDatabases")) {
+    return `${message}\n\nThis MongoDB user can authenticate but does not have permission to run listDatabases on admin. Grant listDatabases/cluster monitor privileges, or set a specific default database that the user can access.`;
+  }
+
+  if (message.includes("Current authentication database:")) return message;
+
+  const source = message.match(/source='([^']+)'/)?.[1];
+  if (!source || !message.includes("Exception authenticating MongoCredential")) return message;
+
+  return `${message}\n\nCurrent authentication database: ${source}. If this user was created in admin, set Authentication database to admin or add authSource=admin to URL params.`;
+}
+
+function parseMongoUrlParams(urlParams: string | undefined): URLSearchParams {
+  return new URLSearchParams((urlParams || "").trim().replace(/^\?/, ""));
+}
diff --git a/apps/desktop/src/lib/mongo/mongoDocumentValues.ts b/apps/desktop/src/lib/mongo/mongoDocumentValues.ts
new file mode 100644
index 0000000..7320b6e
--- /dev/null
+++ b/apps/desktop/src/lib/mongo/mongoDocumentValues.ts
@@ -0,0 +1,123 @@
+export type MongoInputValue = string | number | boolean | null;
+
+const MONGO_SHELL_DATE_PATTERN = /^(?:ISODate|new Date)\(\s*(["'])(.+)\1\s*\)$/;
+const LEGACY_MONGO_DATE_DISPLAY_PATTERN = /^(\d{4}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})(?:\.(\d{1,3}))?$/;
+const MONGO_OBJECT_ID_PATTERN = /^[a-fA-F0-9]{24}$/;
+
+export function mongoShellDateToExtendedJson(value: unknown): unknown {
+  if (typeof value !== "string") return value;
+  const match = value.trim().match(MONGO_SHELL_DATE_PATTERN);
+  if (!match) return value;
+  return { $date: match[2] };
+}
+
+export function parseMongoDocumentInputValue(raw: MongoInputValue): unknown {
+  if (raw === null || typeof raw === "number" || typeof raw === "boolean") return raw;
+
+  const trimmed = raw.trim();
+  if (trimmed === "NULL") return null;
+  if (/^(true|false|null)$/i.test(trimmed)) return JSON.parse(trimmed.toLowerCase());
+
+  const shellDate = mongoShellDateToExtendedJson(trimmed);
+  if (shellDate !== trimmed) return shellDate;
+
+  const legacyDate = legacyMongoDateDisplayToExtendedJson(trimmed);
+  if (legacyDate) return legacyDate;
+
+  if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) return Number(trimmed);
+  if (trimmed.startsWith("{") || trimmed.startsWith("[") || trimmed.startsWith('"')) {
+    return mongoShellDateToExtendedJson(JSON.parse(trimmed));
+  }
+  return raw;
+}
+
+function legacyMongoDateDisplayToExtendedJson(value: string): { $date: string } | null {
+  const match = value.match(LEGACY_MONGO_DATE_DISPLAY_PATTERN);
+  if (!match) return null;
+  const [, date, time, millis = "000"] = match;
+  return { $date: `${date}T${time}.${millis.padEnd(3, "0")}Z` };
+}
+
+export function buildMongoUpdateDocument(changes: Map<number, MongoInputValue>, columns: string[]): Record<string, unknown> {
+  const setFields: Record<string, unknown> = {};
+  const unsetFields: Record<string, unknown> = {};
+  for (const [colIdx, newVal] of changes) {
+    const col = columns[colIdx];
+    if (!col || col === "_id") continue;
+    if (newVal === null) {
+      unsetFields[col] = "";
+    } else {
+      setFields[col] = parseMongoDocumentInputValue(newVal);
+    }
+  }
+  const doc: Record<string, unknown> = {};
+  if (Object.keys(setFields).length > 0) doc.$set = setFields;
+  if (Object.keys(unsetFields).length > 0) doc.$unset = unsetFields;
+  return doc;
+}
+
+export function applyMongoGridChangesToDocument(document: unknown, changes: Map<number, MongoInputValue>, columns: string[]): unknown {
+  if (!document || typeof document !== "object" || Array.isArray(document)) return document;
+
+  const updated = { ...(document as Record<string, unknown>) };
+  for (const [colIdx, newVal] of changes) {
+    const column = columns[colIdx];
+    if (!column || column === "_id") continue;
+    if (newVal === null) {
+      delete updated[column];
+    } else {
+      updated[column] = parseMongoDocumentInputValue(newVal);
+    }
+  }
+  return updated;
+}
+
+export function buildMongoInsertDocument(row: MongoInputValue[], columns: string[]): Record<string, unknown> {
+  const doc: Record<string, unknown> = {};
+  for (let ci = 0; ci < columns.length; ci++) {
+    const col = columns[ci];
+    if (!col || col === "_id") continue;
+    const val = row[ci];
+    if (val === null) continue;
+    doc[col] = parseMongoDocumentInputValue(val);
+  }
+  return doc;
+}
+
+export function buildMongoCopyInsertDocument(row: MongoInputValue[], columns: string[], options: { excludePrimaryKeys?: boolean } = {}): Record<string, unknown> {
+  const doc: Record<string, unknown> = {};
+  for (let ci = 0; ci < columns.length; ci++) {
+    const col = columns[ci];
+    if (!col || (options.excludePrimaryKeys && col === "_id")) continue;
+    const val = row[ci];
+    if (val === null) continue;
+    if (col === "_id" && typeof val === "string" && MONGO_OBJECT_ID_PATTERN.test(val)) {
+      doc[col] = { $oid: val };
+      continue;
+    }
+    doc[col] = parseMongoDocumentInputValue(val);
+  }
+  return doc;
+}
+
+export function formatMongoShellLiteral(value: unknown): string {
+  if (value === null || value === undefined) return "null";
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  if (typeof value === "string") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(formatMongoShellLiteral).join(",")}]`;
+  if (typeof value === "object") {
+    const object = value as Record<string, unknown>;
+    const keys = Object.keys(object);
+    if (keys.length === 1 && typeof object.$date === "string") {
+      return `ISODate(${JSON.stringify(object.$date)})`;
+    }
+    if (keys.length === 1 && typeof object.$oid === "string" && MONGO_OBJECT_ID_PATTERN.test(object.$oid)) {
+      return `ObjectId(${JSON.stringify(object.$oid)})`;
+    }
+    if (keys.length === 1 && typeof object.$numberLong === "string") {
+      return `NumberLong(${JSON.stringify(object.$numberLong)})`;
+    }
+    return `{${keys.map((key) => `${JSON.stringify(key)}:${formatMongoShellLiteral(object[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(String(value));
+}
diff --git a/apps/desktop/src/lib/mongo/mongoFormatter.ts b/apps/desktop/src/lib/mongo/mongoFormatter.ts
new file mode 100644
index 0000000..31a5605
--- /dev/null
+++ b/apps/desktop/src/lib/mongo/mongoFormatter.ts
@@ -0,0 +1,277 @@
+import { DEFAULT_SQL_FORMATTER_SETTINGS, type SqlFormatterSettings } from "@/lib/sql/sqlFormatterConfig";
+
+export const MAX_MONGO_FORMAT_CHARS = 1_000_000;
+
+interface FormatState {
+  out: string;
+  indentLevel: number;
+  atLineStart: boolean;
+  pendingSpace: boolean;
+  chainIndent: boolean;
+  pendingChainCall: boolean;
+  stack: Array<{ char: string; expanded: boolean; chainCall?: boolean }>;
+}
+
+const CHAIN_METHODS = new Set(["find", "findOne", "aggregate", "countDocuments", "distinct", "insertOne", "insertMany", "updateOne", "updateMany", "deleteOne", "deleteMany", "getIndexes", "createIndex", "dropIndex", "dropIndexes", "sort", "limit", "skip"]);
+
+export function formatMongoShellText(text: string, settings: Partial<SqlFormatterSettings> = DEFAULT_SQL_FORMATTER_SETTINGS): string {
+  if (!text.trim()) return text;
+  if (text.length > MAX_MONGO_FORMAT_CHARS) {
+    throw new Error("MongoDB query is too large to format safely.");
+  }
+
+  const indentUnit = settings.useTabs ? "\t" : " ".repeat(settings.tabWidth ?? DEFAULT_SQL_FORMATTER_SETTINGS.tabWidth);
+  const state: FormatState = { out: "", indentLevel: 0, atLineStart: true, pendingSpace: false, chainIndent: false, pendingChainCall: false, stack: [] };
+
+  for (let index = 0; index < text.length; index++) {
+    const char = text[index] ?? "";
+    const next = text[index + 1] ?? "";
+
+    if (char === '"' || char === "'" || char === "`") {
+      const literal = readQuotedLiteral(text, index, char);
+      appendToken(state, literal.value, indentUnit);
+      index = literal.end;
+      continue;
+    }
+
+    if (char === "/" && next === "/") {
+      const comment = readLineComment(text, index);
+      appendToken(state, comment.value, indentUnit);
+      index = comment.end;
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      const comment = readBlockComment(text, index);
+      appendToken(state, comment.value, indentUnit);
+      index = comment.end;
+      continue;
+    }
+
+    if (char === "/" && looksLikeRegexLiteral(text, index)) {
+      const regex = readRegexLiteral(text, index);
+      appendToken(state, regex.value, indentUnit);
+      index = regex.end;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      state.pendingSpace = !state.atLineStart;
+      continue;
+    }
+
+    if (char === "." && shouldBreakBeforeDot(text, index)) {
+      newline(state, indentUnit);
+      state.chainIndent = true;
+      state.pendingChainCall = true;
+      appendToken(state, ".", indentUnit);
+      continue;
+    }
+
+    if (char === "{" || char === "[" || char === "(") {
+      appendToken(state, char, indentUnit);
+      const expanded = char !== "(" && shouldExpandOpening(text, index);
+      const isChainCall = char === "(" && state.pendingChainCall;
+      state.stack.push({ char, expanded, chainCall: isChainCall });
+      if (isChainCall) state.indentLevel++;
+      state.pendingChainCall = false;
+      if (expanded) {
+        state.indentLevel++;
+        newline(state, indentUnit);
+      }
+      continue;
+    }
+
+    if (char === "}" || char === "]" || char === ")") {
+      const frame = popMatchingFrame(state, char);
+      if (frame?.expanded) {
+        if (!state.atLineStart) newline(state, indentUnit, -1);
+        else state.indentLevel = Math.max(0, state.indentLevel - 1);
+      }
+      if (frame?.chainCall) {
+        state.indentLevel = Math.max(0, state.indentLevel - 1);
+      }
+      appendRaw(state, char, indentUnit);
+      continue;
+    }
+
+    if (char === ",") {
+      appendToken(state, ",", indentUnit);
+      newline(state, indentUnit);
+      continue;
+    }
+
+    if (char === ":") {
+      trimTrailingSpaces(state);
+      appendRaw(state, ": ", indentUnit);
+      state.pendingSpace = false;
+      continue;
+    }
+
+    appendToken(state, char, indentUnit);
+  }
+
+  return cleanupFormattedMongoText(state.out);
+}
+
+function appendToken(state: FormatState, token: string, indentUnit: string) {
+  if (state.atLineStart) {
+    state.out += indentUnit.repeat(Math.max(0, state.indentLevel + (state.chainIndent ? 1 : 0)));
+    state.atLineStart = false;
+  } else if (state.pendingSpace && shouldInsertPendingSpace(state.out, token)) {
+    state.out += " ";
+  }
+  state.out += token;
+  state.pendingSpace = false;
+  state.chainIndent = false;
+}
+
+function appendRaw(state: FormatState, token: string, indentUnit: string) {
+  if (state.atLineStart) {
+    state.out += indentUnit.repeat(Math.max(0, state.indentLevel + (state.chainIndent ? 1 : 0)));
+    state.atLineStart = false;
+  }
+  state.out += token;
+  state.pendingSpace = false;
+  state.chainIndent = false;
+}
+
+function newline(state: FormatState, indentUnit: string, indentDelta = 0) {
+  trimTrailingSpaces(state);
+  if (!state.out.endsWith("\n")) state.out += "\n";
+  state.indentLevel = Math.max(0, state.indentLevel + indentDelta);
+  state.atLineStart = true;
+  state.pendingSpace = false;
+  state.chainIndent = false;
+  void indentUnit;
+}
+
+function shouldInsertPendingSpace(output: string, token: string): boolean {
+  const previous = lastNonWhitespace(output);
+  if (!previous) return false;
+  if ([".", "(", "[", "{"].includes(previous)) return false;
+  if ([".", ")", "]", "}", ",", ":"].includes(token)) return false;
+  return true;
+}
+
+function shouldExpandOpening(text: string, index: number): boolean {
+  const close = matchingClose(text[index] ?? "");
+  const nextNonSpace = findNextNonWhitespace(text, index + 1);
+  if (nextNonSpace == null || text[nextNonSpace] === close) return false;
+  return true;
+}
+
+function popMatchingFrame(state: FormatState, close: string): { char: string; expanded: boolean; chainCall?: boolean } | undefined {
+  const expectedOpen = close === "}" ? "{" : close === "]" ? "[" : "(";
+  for (let index = state.stack.length - 1; index >= 0; index--) {
+    const frame = state.stack[index];
+    state.stack.splice(index, state.stack.length - index);
+    if (frame?.char === expectedOpen) return frame;
+  }
+  return undefined;
+}
+
+function shouldBreakBeforeDot(text: string, index: number): boolean {
+  const method = readIdentifier(text, findNextNonWhitespace(text, index + 1) ?? index + 1);
+  if (!method || !CHAIN_METHODS.has(method)) return false;
+  const previousNonSpace = findPreviousNonWhitespace(text, index - 1);
+  if (previousNonSpace == null) return false;
+  return text[previousNonSpace] === ")";
+}
+
+function readQuotedLiteral(text: string, start: number, quote: string): { value: string; end: number } {
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index] ?? "";
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === quote) return { value: text.slice(start, index + 1), end: index };
+    index++;
+  }
+  return { value: text.slice(start), end: text.length - 1 };
+}
+
+function readLineComment(text: string, start: number): { value: string; end: number } {
+  const end = text.indexOf("\n", start);
+  if (end < 0) return { value: text.slice(start), end: text.length - 1 };
+  return { value: text.slice(start, end), end: end - 1 };
+}
+
+function readBlockComment(text: string, start: number): { value: string; end: number } {
+  const end = text.indexOf("*/", start + 2);
+  if (end < 0) return { value: text.slice(start), end: text.length - 1 };
+  return { value: text.slice(start, end + 2), end: end + 1 };
+}
+
+function readRegexLiteral(text: string, start: number): { value: string; end: number } {
+  let index = start + 1;
+  let inCharClass = false;
+  while (index < text.length) {
+    const char = text[index] ?? "";
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === "[") inCharClass = true;
+    else if (char === "]") inCharClass = false;
+    else if (char === "/" && !inCharClass) {
+      let end = index;
+      while (/[a-z]/i.test(text[end + 1] ?? "")) end++;
+      return { value: text.slice(start, end + 1), end };
+    }
+    index++;
+  }
+  return { value: text.slice(start), end: text.length - 1 };
+}
+
+function looksLikeRegexLiteral(text: string, index: number): boolean {
+  const previous = findPreviousNonWhitespace(text, index - 1);
+  if (previous == null) return true;
+  return "({[,=:!&|?".includes(text[previous] ?? "");
+}
+
+function readIdentifier(text: string, start: number): string {
+  let index = start;
+  while (index < text.length && /[A-Za-z0-9_$]/.test(text[index] ?? "")) index++;
+  return text.slice(start, index);
+}
+
+function matchingClose(open: string): string {
+  if (open === "{") return "}";
+  if (open === "[") return "]";
+  return ")";
+}
+
+function findNextNonWhitespace(text: string, start: number): number | null {
+  for (let index = start; index < text.length; index++) {
+    if (!/\s/.test(text[index] ?? "")) return index;
+  }
+  return null;
+}
+
+function findPreviousNonWhitespace(text: string, start: number): number | null {
+  for (let index = start; index >= 0; index--) {
+    if (!/\s/.test(text[index] ?? "")) return index;
+  }
+  return null;
+}
+
+function lastNonWhitespace(text: string): string | null {
+  const index = findPreviousNonWhitespace(text, text.length - 1);
+  return index == null ? null : (text[index] ?? null);
+}
+
+function trimTrailingSpaces(state: FormatState) {
+  state.out = state.out.replace(/[ \t]+$/g, "");
+}
+
+function cleanupFormattedMongoText(text: string): string {
+  return text
+    .split("\n")
+    .map((line) => line.replace(/[ \t]+$/g, ""))
+    .join("\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
diff --git a/apps/desktop/src/lib/mongo/mongoShellCommand.ts b/apps/desktop/src/lib/mongo/mongoShellCommand.ts
new file mode 100644
index 0000000..4494113
--- /dev/null
+++ b/apps/desktop/src/lib/mongo/mongoShellCommand.ts
@@ -0,0 +1,1174 @@
+import type { QueryResult } from "@/types/database";
+
+export interface MongoFindCommand {
+  collection: string;
+  filter: string;
+  projection?: string;
+  skip: number;
+  limit: number;
+  sort?: string;
+}
+
+export interface MongoCountDocumentsCommand {
+  collection: string;
+  filter: string;
+}
+
+export interface MongoAggregateCommand {
+  collection: string;
+  pipeline: string;
+}
+
+export interface MongoGetIndexesCommand {
+  collection: string;
+}
+
+export interface MongoUseCommand {
+  database: string;
+}
+
+export interface MongoVersionCommand {
+  kind: "version";
+}
+
+export type MongoCollectionStatsMetric = "stats" | "dataSize" | "storageSize" | "totalIndexSize";
+
+export interface MongoCollectionStatsCommand {
+  collection: string;
+  metric: MongoCollectionStatsMetric;
+  scale?: number;
+}
+
+type MongoWriteKind = "insert" | "update" | "delete" | "createIndex" | "dropIndex" | "dropIndexes" | "dropCollection";
+
+export type MongoCommand =
+  | ({ kind: "find" } & MongoFindCommand)
+  | MongoVersionCommand
+  | ({ kind: "countDocuments" } & MongoCountDocumentsCommand)
+  | ({ kind: "aggregate" } & MongoAggregateCommand)
+  | ({ kind: "getIndexes" } & MongoGetIndexesCommand)
+  | ({ kind: "collectionStats" } & MongoCollectionStatsCommand)
+  | ({ kind: "use" } & MongoUseCommand)
+  | { kind: "insert"; collection: string; docsJson: string }
+  | { kind: "update"; collection: string; filter: string; update: string; options?: string; many: boolean }
+  | { kind: "delete"; collection: string; filter: string; many: boolean }
+  | { kind: "createIndex"; collection: string; keys: string; options?: string }
+  | { kind: "dropIndex"; collection: string; index: string }
+  | { kind: "dropIndexes"; collection: string; indexes?: string }
+  | { kind: "dropCollection"; collection: string };
+
+export type MongoWriteCommand = Extract<MongoCommand, { kind: MongoWriteKind }>;
+
+export interface ParsedMongoCommand {
+  text: string;
+  command: MongoCommand;
+}
+
+export interface ParsedMongoCommandRange extends ParsedMongoCommand {
+  from: number;
+  to: number;
+}
+
+export interface MongoAggregateSafetyOptions {
+  allowWrites?: boolean;
+  allowDangerous?: boolean;
+}
+
+const DEFAULT_LIMIT = 100;
+
+export function parseMongoFindCommand(input: string): MongoFindCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  const target = parseFindTarget(source);
+  if (!target) return null;
+
+  const findOpenIndex = source.indexOf("(", target.findCallIndex);
+  const findCloseIndex = findMatchingParen(source, findOpenIndex);
+  if (findCloseIndex < 0) return null;
+
+  const findArgs = splitTopLevel(source.slice(findOpenIndex + 1, findCloseIndex));
+  if (findArgs.length > 2 && findArgs.slice(2).some((arg) => arg.trim())) return null;
+  const filter = normalizeJsonArgument(findArgs[0] || "{}");
+  if (!filter) return null;
+  let projection: string | undefined;
+  if (findArgs[1]?.trim()) {
+    const parsedProjection = normalizeJsonArgument(findArgs[1]);
+    if (!parsedProjection) return null;
+    projection = parsedProjection;
+  }
+
+  const chain = source.slice(findCloseIndex + 1).trim();
+  if (chain && !chain.startsWith(".")) return null;
+  if (findChainedMethodCallIndex(chain, "count") >= 0) return null;
+
+  const sortArg = readChainedCallArgument(chain, "sort");
+  let sort: string | undefined;
+  if (sortArg !== undefined) {
+    const parsedSort = normalizeJsonArgument(sortArg);
+    if (!parsedSort) return null;
+    sort = parsedSort;
+  }
+
+  const skip = readChainedIntegerArgument(chain, "skip", 0);
+  const limit = readChainedIntegerArgument(chain, "limit", DEFAULT_LIMIT);
+  if (skip === null || limit === null) return null;
+
+  return {
+    collection: target.collection,
+    filter,
+    ...(projection ? { projection } : {}),
+    skip,
+    limit,
+    sort,
+  };
+}
+
+export function applyMongoFindSort(input: string, column: string, direction: "asc" | "desc"): string | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  const parsed = parseMongoFindCommand(source);
+  if (!parsed) return null;
+
+  const target = parseFindTarget(source);
+  if (!target) return null;
+
+  const findOpenIndex = source.indexOf("(", target.findCallIndex);
+  const findCloseIndex = findMatchingParen(source, findOpenIndex);
+  if (findCloseIndex < 0) return null;
+
+  const prefix = source.slice(0, findCloseIndex + 1);
+  const chainSource = source.slice(findCloseIndex + 1).trim();
+  if (chainSource && !chainSource.startsWith(".")) return null;
+
+  const chain = removeChainedMethodCall(chainSource, "sort");
+  const sortCall = `.sort(${JSON.stringify({ [column]: direction === "asc" ? 1 : -1 })})`;
+  return `${prefix}${sortCall}${chain}`;
+}
+
+export function parseMongoCountDocumentsCommand(input: string): MongoCountDocumentsCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  // Accept deprecated Mongo shell count helpers for old server workflows, but
+  // keep DBX's internal execution mapped to the countDocuments result shape.
+  return parseCollectionCountCommand(source, "countDocuments") ?? parseCollectionCountCommand(source, "count") ?? parseFindCountCommand(source);
+}
+
+function parseCollectionCountCommand(source: string, method: "countDocuments" | "count"): MongoCountDocumentsCommand | null {
+  const target = parseCollectionMethodTarget(source, method);
+  if (!target) return null;
+
+  const openIndex = source.indexOf("(", target.methodCallIndex);
+  const closeIndex = findMatchingParen(source, openIndex);
+  if (closeIndex < 0 || source.slice(closeIndex + 1).trim()) return null;
+
+  const args = splitTopLevel(source.slice(openIndex + 1, closeIndex));
+  if (args.length > 1 && args.slice(1).some((arg) => arg.trim())) return null;
+  const filter = normalizeJsonArgument(args[0] || "{}");
+  if (!filter) return null;
+
+  return {
+    collection: target.collection,
+    filter,
+  };
+}
+
+function parseFindCountCommand(source: string): MongoCountDocumentsCommand | null {
+  const target = parseFindTarget(source);
+  if (!target) return null;
+
+  const findOpenIndex = source.indexOf("(", target.findCallIndex);
+  const findCloseIndex = findMatchingParen(source, findOpenIndex);
+  if (findCloseIndex < 0) return null;
+
+  const chain = source.slice(findCloseIndex + 1).trim();
+  if (!hasSingleEmptyChainedCall(chain, "count")) return null;
+
+  const findArgs = splitTopLevel(source.slice(findOpenIndex + 1, findCloseIndex));
+  if (findArgs.length > 2 && findArgs.slice(2).some((arg) => arg.trim())) return null;
+  const filter = normalizeJsonArgument(findArgs[0] || "{}");
+  if (!filter) return null;
+
+  return {
+    collection: target.collection,
+    filter,
+  };
+}
+
+export function parseMongoAggregateCommand(input: string): MongoAggregateCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  const target = parseCollectionMethodTarget(source, "aggregate");
+  if (!target) return null;
+
+  const openIndex = source.indexOf("(", target.methodCallIndex);
+  const closeIndex = findMatchingParen(source, openIndex);
+  if (closeIndex < 0 || source.slice(closeIndex + 1).trim()) return null;
+
+  const args = splitTopLevel(source.slice(openIndex + 1, closeIndex));
+  if (args.length !== 1) return null;
+  const pipeline = normalizeJsonArgument(args[0]);
+  if (!pipeline) return null;
+  try {
+    if (!Array.isArray(JSON.parse(pipeline))) return null;
+  } catch {
+    return null;
+  }
+
+  return {
+    collection: target.collection,
+    pipeline,
+  };
+}
+
+export function parseMongoGetIndexesCommand(input: string): MongoGetIndexesCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  const target = parseCollectionMethodTarget(source, "getIndexes");
+  if (!target) return null;
+
+  const openIndex = source.indexOf("(", target.methodCallIndex);
+  const closeIndex = findMatchingParen(source, openIndex);
+  if (closeIndex < 0 || source.slice(closeIndex + 1).trim()) return null;
+
+  const args = splitTopLevel(source.slice(openIndex + 1, closeIndex));
+  if (args.some((arg) => arg.trim())) return null;
+
+  return {
+    collection: target.collection,
+  };
+}
+
+export function parseMongoCollectionStatsCommand(input: string): MongoCollectionStatsCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  for (const metric of ["stats", "dataSize", "storageSize", "totalIndexSize"] as const) {
+    const target = parseCollectionMethodTarget(source, metric);
+    if (!target) continue;
+    const args = parseMethodArgs(source, target.methodCallIndex);
+    if (!args) return null;
+    const scale = parseMongoCollectionStatsScale(args);
+    return scale === null ? null : { collection: target.collection, metric, ...(scale === undefined ? {} : { scale }) };
+  }
+  return null;
+}
+
+function parseMongoCollectionStatsScale(args: string[]): number | undefined | null {
+  if (args.length === 1 && !args[0]?.trim()) return undefined;
+  if (args.length !== 1) return null;
+  const raw = args[0].trim();
+  if (!/^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(raw)) return null;
+  const scale = Number(raw);
+  if (!Number.isFinite(scale)) return null;
+  return scale;
+}
+
+export function parseMongoUseCommand(input: string): MongoUseCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  const match = /^use\s+([a-zA-Z0-9_-]+)$/i.exec(source);
+  if (!match) return null;
+  return {
+    database: match[1],
+  };
+}
+
+export function parseMongoVersionCommand(input: string): MongoVersionCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  return /^db\s*\.\s*version\s*\(\s*\)$/i.test(source) ? { kind: "version" } : null;
+}
+
+export function parseMongoWriteCommand(input: string): MongoWriteCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  const insertOne = parseCollectionMethodTarget(source, "insertOne");
+  if (insertOne) {
+    const args = parseMethodArgs(source, insertOne.methodCallIndex);
+    if (!args || args.length !== 1) return null;
+    const doc = normalizeJsonArgument(args[0]);
+    return doc ? { kind: "insert", collection: insertOne.collection, docsJson: doc } : null;
+  }
+
+  const insertMany = parseCollectionMethodTarget(source, "insertMany");
+  if (insertMany) {
+    const args = parseMethodArgs(source, insertMany.methodCallIndex);
+    if (!args || args.length !== 1) return null;
+    const docs = normalizeJsonArgument(args[0]);
+    if (!docs) return null;
+    return Array.isArray(JSON.parse(docs)) ? { kind: "insert", collection: insertMany.collection, docsJson: docs } : null;
+  }
+
+  for (const method of ["updateOne", "updateMany"] as const) {
+    const target = parseCollectionMethodTarget(source, method);
+    if (!target) continue;
+    const args = parseMethodArgs(source, target.methodCallIndex);
+    if (!args || args.length < 2 || args.length > 3) return null;
+    const filter = normalizeJsonArgument(args[0]);
+    const update = normalizeJsonArgument(args[1]);
+    if (!filter || !update) return null;
+    const options = args[2]?.trim() ? normalizeJsonArgument(args[2]) : undefined;
+    if (args[2]?.trim() && !options) return null;
+    return { kind: "update", collection: target.collection, filter, update, ...(options ? { options } : {}), many: method === "updateMany" };
+  }
+
+  for (const method of ["deleteOne", "deleteMany"] as const) {
+    const target = parseCollectionMethodTarget(source, method);
+    if (!target) continue;
+    const args = parseMethodArgs(source, target.methodCallIndex);
+    if (!args || args.length !== 1) return null;
+    const filter = normalizeJsonArgument(args[0]);
+    if (!filter) return null;
+    return { kind: "delete", collection: target.collection, filter, many: method === "deleteMany" };
+  }
+
+  const createIndex = parseCollectionMethodTarget(source, "createIndex");
+  if (createIndex) {
+    const args = parseMethodArgs(source, createIndex.methodCallIndex);
+    if (!args || args.length < 1 || args.length > 2) return null;
+    const keys = normalizeJsonArgument(args[0]);
+    if (!keys) return null;
+    let options: string | undefined;
+    if (args[1]?.trim()) {
+      const parsedOptions = normalizeJsonArgument(args[1]);
+      if (!parsedOptions) return null;
+      options = parsedOptions;
+    }
+    return { kind: "createIndex", collection: createIndex.collection, keys, ...(options ? { options } : {}) };
+  }
+
+  const dropIndex = parseCollectionMethodTarget(source, "dropIndex");
+  if (dropIndex) {
+    const args = parseMethodArgs(source, dropIndex.methodCallIndex);
+    if (!args) return null;
+    const index = parseMongoDropIndexArgument(args);
+    return index ? { kind: "dropIndex", collection: dropIndex.collection, index } : null;
+  }
+
+  const dropIndexes = parseCollectionMethodTarget(source, "dropIndexes");
+  if (dropIndexes) {
+    const args = parseMethodArgs(source, dropIndexes.methodCallIndex);
+    if (!args) return null;
+    const indexes = parseMongoDropIndexesArgument(args);
+    return indexes !== null ? { kind: "dropIndexes", collection: dropIndexes.collection, ...(indexes ? { indexes } : {}) } : null;
+  }
+
+  const dropCollection = parseCollectionMethodTarget(source, "drop");
+  if (dropCollection) {
+    const args = parseMethodArgs(source, dropCollection.methodCallIndex);
+    if (!args || args.some((arg) => arg.trim())) return null;
+    return { kind: "dropCollection", collection: dropCollection.collection };
+  }
+
+  return null;
+}
+
+export function parseMongoCommand(input: string): ParsedMongoCommand | null {
+  const text = trimMongoOuterComments(input);
+  if (!text) return null;
+
+  // Keep the more specific readers ahead of generic write parsing so the
+  // returned kind matches the result renderer we want to use downstream.
+  const parsers: Array<(source: string) => MongoCommand | null> = [
+    (source) => {
+      const version = parseMongoVersionCommand(source);
+      return version ?? null;
+    },
+    (source) => {
+      // Legacy Mongo shell uses count()/find().count(); keep accepting it
+      // while mapping to DBX's countDocuments-compatible result path.
+      const count = parseMongoCountDocumentsCommand(source);
+      return count ? { kind: "countDocuments", ...count } : null;
+    },
+    (source) => {
+      const find = parseMongoFindCommand(source);
+      return find ? { kind: "find", ...find } : null;
+    },
+    (source) => {
+      const aggregate = parseMongoAggregateCommand(source);
+      return aggregate ? { kind: "aggregate", ...aggregate } : null;
+    },
+    (source) => {
+      const getIndexes = parseMongoGetIndexesCommand(source);
+      return getIndexes ? { kind: "getIndexes", ...getIndexes } : null;
+    },
+    (source) => {
+      const stats = parseMongoCollectionStatsCommand(source);
+      return stats ? { kind: "collectionStats", ...stats } : null;
+    },
+    (source) => {
+      const write = parseMongoWriteCommand(source);
+      return write ?? null;
+    },
+    (source) => {
+      const use = parseMongoUseCommand(source);
+      return use ? { kind: "use", ...use } : null;
+    },
+  ];
+
+  for (const parse of parsers) {
+    const command = parse(text);
+    if (command) return { text, command };
+  }
+
+  return null;
+}
+
+export function splitMongoCommands(input: string): ParsedMongoCommand[] {
+  return splitMongoCommandRanges(input).map(({ from: _from, to: _to, ...command }) => command);
+}
+
+export function splitMongoCommandRanges(input: string): ParsedMongoCommandRange[] {
+  const commands: ParsedMongoCommandRange[] = [];
+  for (const segment of splitMongoCommandTextRanges(input)) {
+    const parsed = parseMongoCommand(segment.text);
+    if (!parsed) return [];
+    commands.push({ from: segment.from, to: segment.to, ...parsed });
+  }
+  return commands;
+}
+
+export function evaluateMongoWriteSafety(command: MongoWriteCommand, options: MongoAggregateSafetyOptions): { allowed: boolean; reason?: string } {
+  if (!options.allowWrites) {
+    return {
+      allowed: false,
+      reason: "MCP MongoDB execution is read-only by default. Set DBX_MCP_ALLOW_WRITES=1 to allow write commands.",
+    };
+  }
+  if (!options.allowDangerous && (command.kind === "update" || command.kind === "delete") && isEmptyJsonObject(command.filter)) {
+    return {
+      allowed: false,
+      reason: "MongoDB update/delete commands must include a non-empty filter unless DBX_MCP_ALLOW_DANGEROUS_SQL=1 is set.",
+    };
+  }
+  if (!options.allowDangerous && mongoDropIndexesRequiresDangerous(command)) {
+    return {
+      allowed: false,
+      reason: "MongoDB dropIndexes() without a specific single index requires DBX_MCP_ALLOW_DANGEROUS_SQL=1.",
+    };
+  }
+  if (!options.allowDangerous && command.kind === "dropCollection") {
+    return {
+      allowed: false,
+      reason: "MongoDB drop() requires DBX_MCP_ALLOW_DANGEROUS_SQL=1.",
+    };
+  }
+  return { allowed: true };
+}
+
+export function mongoAggregateWriteStage(pipelineJson: string): "$out" | "$merge" | null {
+  try {
+    const pipeline = JSON.parse(pipelineJson);
+    if (!Array.isArray(pipeline)) return null;
+    for (const stage of pipeline) {
+      if (!isRecord(stage)) continue;
+      if (Object.prototype.hasOwnProperty.call(stage, "$out")) return "$out";
+      if (Object.prototype.hasOwnProperty.call(stage, "$merge")) return "$merge";
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+export function evaluateMongoAggregateSafety(command: MongoAggregateCommand, options: MongoAggregateSafetyOptions): { allowed: boolean; reason?: string } {
+  const writeStage = mongoAggregateWriteStage(command.pipeline);
+  if (!writeStage) return { allowed: true };
+  if (!options.allowWrites) {
+    return {
+      allowed: false,
+      reason: `MongoDB aggregate stage "${writeStage}" writes data. Set DBX_MCP_ALLOW_WRITES=1 to allow write commands.`,
+    };
+  }
+  if (!options.allowDangerous) {
+    return {
+      allowed: false,
+      reason: `MongoDB aggregate stage "${writeStage}" is dangerous. Set DBX_MCP_ALLOW_DANGEROUS_SQL=1 to allow it.`,
+    };
+  }
+  return { allowed: true };
+}
+
+export function mongoDocumentsToQueryResult(documents: unknown[], executionTimeMs: number, total: number): QueryResult {
+  const columns: string[] = [];
+
+  for (const doc of documents) {
+    if (isRecord(doc)) {
+      for (const key of Object.keys(doc)) {
+        if (!columns.includes(key)) columns.push(key);
+      }
+    } else if (!columns.includes("value")) {
+      columns.push("value");
+    }
+  }
+
+  const rows = documents.map((doc) => {
+    if (isRecord(doc)) return columns.map((column) => toCellValue(doc[column]));
+    return columns.map((column) => (column === "value" ? toCellValue(doc) : null));
+  });
+
+  return {
+    columns,
+    rows,
+    mongo_documents: documents,
+    affected_rows: total,
+    execution_time_ms: Math.max(0, Math.round(executionTimeMs)),
+    truncated: total > documents.length,
+  };
+}
+
+export function mongoCountToQueryResult(total: number, executionTimeMs: number): QueryResult {
+  return {
+    columns: ["count"],
+    rows: [[total]],
+    affected_rows: total,
+    execution_time_ms: Math.max(0, Math.round(executionTimeMs)),
+  };
+}
+
+export function mongoWriteToQueryResult(affectedRows: number, executionTimeMs: number): QueryResult {
+  return {
+    columns: [],
+    rows: [],
+    affected_rows: affectedRows,
+    execution_time_ms: Math.max(0, Math.round(executionTimeMs)),
+  };
+}
+
+export function mongoCreateIndexToQueryResult(name: string, executionTimeMs: number): QueryResult {
+  return {
+    columns: ["name"],
+    rows: [[name]],
+    affected_rows: 1,
+    execution_time_ms: Math.max(0, Math.round(executionTimeMs)),
+  };
+}
+
+export function mongoDroppedIndexesToQueryResult(names: string[], executionTimeMs: number): QueryResult {
+  return {
+    columns: ["name"],
+    rows: names.map((name) => [name]),
+    affected_rows: names.length,
+    execution_time_ms: Math.max(0, Math.round(executionTimeMs)),
+  };
+}
+
+export function mongoUseToQueryResult(database: string, executionTimeMs: number): QueryResult {
+  return {
+    columns: ["message"],
+    rows: [[`switched to db ${database}`]],
+    affected_rows: 0,
+    execution_time_ms: Math.max(0, Math.round(executionTimeMs)),
+  };
+}
+
+export function mongoVersionToQueryResult(version: string, executionTimeMs: number): QueryResult {
+  return {
+    columns: ["version"],
+    rows: [[version]],
+    affected_rows: 1,
+    execution_time_ms: Math.max(0, Math.round(executionTimeMs)),
+  };
+}
+
+export function mongoIndexesToQueryResult(
+  indexes: {
+    name: string;
+    columns: string[];
+    is_unique: boolean;
+    is_primary: boolean;
+    filter?: string | null;
+    index_type?: string | null;
+    included_columns?: string[] | null;
+    comment?: string | null;
+  }[],
+  executionTimeMs: number,
+): QueryResult {
+  return {
+    columns: ["name", "columns", "unique", "primary", "type", "filter"],
+    rows: indexes.map((index) => [index.name, index.columns.join(", "), index.is_unique, index.is_primary, index.index_type ?? null, index.filter ?? null]),
+    affected_rows: indexes.length,
+    execution_time_ms: Math.max(0, Math.round(executionTimeMs)),
+  };
+}
+
+export function mongoCollectionStatsToQueryResult(metric: MongoCollectionStatsMetric, stats: Record<string, unknown>, executionTimeMs: number): QueryResult {
+  const execution_time_ms = Math.max(0, Math.round(executionTimeMs));
+  if (metric === "stats") {
+    const columns = ["count", "size", "avgObjSize", "storageSize", "totalIndexSize", "nindexes"];
+    return {
+      columns,
+      rows: [columns.map((column) => (column in stats ? toCellValue(stats[column]) : null))],
+      affected_rows: 1,
+      execution_time_ms,
+    };
+  }
+  const sourceField = metric === "dataSize" ? "size" : metric;
+  return {
+    columns: [metric],
+    rows: [[sourceField in stats ? toCellValue(stats[sourceField]) : null]],
+    affected_rows: 1,
+    execution_time_ms,
+  };
+}
+
+function parseFindTarget(source: string): { collection: string; findCallIndex: number } | null {
+  const direct = parseCollectionMethodTarget(source, "find");
+  if (direct) {
+    return { collection: direct.collection, findCallIndex: direct.methodCallIndex };
+  }
+
+  return null;
+}
+
+function parseCollectionMethodTarget(source: string, method: string): { collection: string; methodCallIndex: number } | null {
+  const escapedMethod = escapeRegExp(method);
+  const direct = new RegExp(`^db\\s*\\.\\s*([A-Za-z_$][\\w$]*)\\s*\\.\\s*${escapedMethod}\\s*\\(`).exec(source);
+  if (direct) {
+    return {
+      collection: direct[1],
+      methodCallIndex: findChainedMethodCallIndex(source, method),
+    };
+  }
+
+  const getCollection = new RegExp(`^db\\s*\\.\\s*getCollection\\s*\\(\\s*(["'])(.*?)\\1\\s*\\)\\s*\\.\\s*${escapedMethod}\\s*\\(`).exec(source);
+  if (getCollection) {
+    return {
+      collection: getCollection[2],
+      methodCallIndex: findChainedMethodCallIndex(source, method),
+    };
+  }
+
+  return null;
+}
+
+function normalizeJsonArgument(value: string): string | null {
+  const trimmed = value.trim();
+  if (!trimmed) return "{}";
+  // Rewrite mongo shell constructors that are not valid JSON into the extended
+  // JSON the backend understands (mongo_driver::json_value_to_bson): ObjectId(x)
+  // -> {"$oid":x} and ISODate(x)/new Date(x) -> {"$date":x}. Without this a
+  // filter such as { createdAt: { $gte: ISODate("...") } } fails JSON.parse,
+  // the command is left unrecognized and falls through to the SQL executor,
+  // which rejects it with "Use MongoDB-specific commands".
+  const withExtendedJson = trimmed.replace(/ObjectId\s*\(\s*["']([^"']+)["']\s*\)/g, '{"$oid":"$1"}').replace(/(?:ISODate|new\s+Date)\s*\(\s*["']([^"']+)["']\s*\)/g, '{"$date":"$1"}');
+  const preprocessed = quoteUnquotedObjectKeys(convertSingleQuotedStrings(withExtendedJson));
+  try {
+    JSON.parse(preprocessed);
+    return preprocessed;
+  } catch {
+    return null;
+  }
+}
+
+function parseMethodArgs(source: string, methodCallIndex: number): string[] | null {
+  const openIndex = source.indexOf("(", methodCallIndex);
+  const closeIndex = findMatchingParen(source, openIndex);
+  if (closeIndex < 0 || source.slice(closeIndex + 1).trim()) return null;
+  return splitTopLevel(source.slice(openIndex + 1, closeIndex));
+}
+
+interface MongoTextRange {
+  from: number;
+  to: number;
+  text: string;
+}
+
+function splitMongoCommandTextRanges(input: string): MongoTextRange[] {
+  const commands: MongoTextRange[] = [];
+  for (const segment of splitMongoSemicolonSeparatedSegments(input)) {
+    const parsed = parseMongoCommand(segment.text);
+    if (parsed) {
+      commands.push({ ...segment, text: parsed.text });
+      continue;
+    }
+
+    // Mongo shell users often omit semicolons and rely on one top-level
+    // command per line, so fall back to a conservative newline split.
+    const softSplit = splitMongoSegmentAtSoftStarts(segment);
+    if (softSplit.length > 1) {
+      commands.push(...softSplit);
+      continue;
+    }
+
+    commands.push(segment);
+  }
+  return commands;
+}
+
+function splitMongoSemicolonSeparatedSegments(input: string): MongoTextRange[] {
+  const segments: MongoTextRange[] = [];
+  let start = 0;
+  let depth = 0;
+  let quote: string | null = null;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+
+  // Respect semicolons only when they appear at the top level; JSON literals,
+  // strings and comments are allowed to contain semicolons verbatim.
+  for (let i = 0; i < input.length; i += 1) {
+    const char = input[i] ?? "";
+    const next = input[i + 1] ?? "";
+
+    if (lineComment) {
+      if (char === "\n") lineComment = false;
+      continue;
+    }
+
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === quote) quote = null;
+      continue;
+    }
+
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      i += 1;
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      i += 1;
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+
+    if (char === "{" || char === "[" || char === "(") depth += 1;
+    else if ((char === "}" || char === "]" || char === ")") && depth > 0) depth -= 1;
+    else if (char === ";" && depth === 0) {
+      pushMongoSegment(segments, input, start, i);
+      start = i + 1;
+    }
+  }
+
+  pushMongoSegment(segments, input, start, input.length);
+  return segments;
+}
+
+function splitMongoSegmentAtSoftStarts(segment: MongoTextRange): MongoTextRange[] {
+  const boundaries = mongoTopLevelCommandLineStarts(segment.text);
+  if (boundaries.length <= 1) return [segment];
+
+  const segments: MongoTextRange[] = [];
+  let start = boundaries[0] ?? 0;
+  for (let index = 1; index < boundaries.length; index += 1) {
+    const boundary = boundaries[index] ?? 0;
+    const candidate = trimMongoOuterCommentRange(segment.text, start, boundary);
+    // Only accept newline-based splitting when every slice is a valid command;
+    // otherwise keep the original text intact and let normal parsing reject it.
+    if (!candidate || !parseMongoCommand(candidate.text)) return [segment];
+    segments.push({
+      from: segment.from + candidate.from,
+      to: segment.from + candidate.to,
+      text: candidate.text,
+    });
+    start = boundary;
+  }
+
+  const last = trimMongoOuterCommentRange(segment.text, start, segment.text.length);
+  if (!last || !parseMongoCommand(last.text)) return [segment];
+  segments.push({
+    from: segment.from + last.from,
+    to: segment.from + last.to,
+    text: last.text,
+  });
+  return segments;
+}
+
+function mongoTopLevelCommandLineStarts(segment: string): number[] {
+  const starts: number[] = [];
+  let depth = 0;
+  let quote: string | null = null;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  let lineStart = 0;
+  let firstNonWhitespaceOnLine = -1;
+
+  for (let i = 0; i < segment.length; i += 1) {
+    const char = segment[i] ?? "";
+    const next = segment[i + 1] ?? "";
+
+    if (char === "\n") {
+      if (lineComment) lineComment = false;
+      lineStart = i + 1;
+      firstNonWhitespaceOnLine = -1;
+      continue;
+    }
+
+    if (lineComment) continue;
+
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === quote) quote = null;
+      continue;
+    }
+
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      i += 1;
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      i += 1;
+      continue;
+    }
+
+    if (char === '"' || char === "'" || char === "`") {
+      if (firstNonWhitespaceOnLine === -1 && !/\s/.test(char)) firstNonWhitespaceOnLine = i;
+      quote = char;
+      continue;
+    }
+
+    if (char === "{" || char === "[" || char === "(") depth += 1;
+    else if ((char === "}" || char === "]" || char === ")") && depth > 0) depth -= 1;
+
+    if (firstNonWhitespaceOnLine === -1 && !/\s/.test(char)) {
+      firstNonWhitespaceOnLine = i;
+      if (depth === 0 && char !== "." && isMongoCommandLineStart(segment, i)) starts.push(i);
+    }
+  }
+
+  return starts.length > 0 ? starts : [lineStart];
+}
+
+function isMongoCommandLineStart(segment: string, index: number): boolean {
+  const rest = segment.slice(index);
+  return /^use\b/i.test(rest) || /^db(?:\s*\.|\b)/i.test(rest);
+}
+
+function pushMongoSegment(segments: MongoTextRange[], source: string, from: number, to: number) {
+  const trimmed = trimMongoOuterCommentRange(source, from, to);
+  if (trimmed) segments.push(trimmed);
+}
+
+function trimMongoOuterComments(source: string): string {
+  let value = source.trim();
+  while (value) {
+    const next = value.replace(/^(?:\/\/[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)\s*/u, "");
+    if (next === value) break;
+    value = next.trimStart();
+  }
+  while (value) {
+    const next = value.replace(/\s*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)\s*$/u, "");
+    if (next === value) break;
+    value = next.trimEnd();
+  }
+  return value.trim();
+}
+
+function trimMongoOuterCommentRange(source: string, from: number, to: number): MongoTextRange | null {
+  let start = from;
+  let end = to;
+
+  while (start < end) {
+    const value = source.slice(start, end);
+    const trimmed = value.trimStart();
+    if (trimmed !== value) {
+      start += value.length - trimmed.length;
+      continue;
+    }
+    const next = value.replace(/^(?:\/\/[^\n]*(?:\n|$)|\/\*[\s\S]*?\*\/)\s*/u, "");
+    if (next !== value) {
+      start += value.length - next.length;
+      continue;
+    }
+    break;
+  }
+
+  while (start < end) {
+    const value = source.slice(start, end);
+    const trimmed = value.trimEnd();
+    if (trimmed !== value) {
+      end -= value.length - trimmed.length;
+      continue;
+    }
+    const next = value.replace(/\s*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/)\s*$/u, "");
+    if (next !== value) {
+      end -= value.length - next.length;
+      continue;
+    }
+    break;
+  }
+
+  if (start >= end) return null;
+  return {
+    from: start,
+    to: end,
+    text: source.slice(start, end),
+  };
+}
+
+function convertSingleQuotedStrings(source: string): string {
+  let result = "";
+  let copiedUntil = 0;
+  let quote: string | null = null;
+  let start = 0;
+  let value = "";
+  let escaped = false;
+
+  for (let i = 0; i < source.length; i += 1) {
+    const char = source[i];
+    if (!quote) {
+      if (char === "'") {
+        quote = char;
+        start = i;
+        value = "";
+        escaped = false;
+      } else if (char === '"') {
+        quote = char;
+      }
+      continue;
+    }
+
+    if (quote === '"') {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') quote = null;
+      continue;
+    }
+
+    if (escaped) {
+      value += char;
+      escaped = false;
+    } else if (char === "\\") {
+      escaped = true;
+    } else if (char === "'") {
+      result += source.slice(copiedUntil, start) + JSON.stringify(value);
+      copiedUntil = i + 1;
+      quote = null;
+    } else {
+      value += char;
+    }
+  }
+
+  return quote === "'" ? source : result + source.slice(copiedUntil);
+}
+
+function parseMongoDropIndexArgument(args: string[]): string | null {
+  if (args.length !== 1 || !args[0]?.trim()) return null;
+  const normalized = normalizeJsonArgument(args[0]);
+  if (!normalized) return null;
+  const parsed = parseNormalizedJson(normalized);
+  if (typeof parsed === "string") return parsed === "*" ? null : normalized;
+  return isNonEmptyRecord(parsed) ? normalized : null;
+}
+
+function parseMongoDropIndexesArgument(args: string[]): string | undefined | null {
+  if (args.length !== 1) return null;
+  if (!args[0]?.trim()) return undefined;
+  const normalized = normalizeJsonArgument(args[0]);
+  if (!normalized) return null;
+  const parsed = parseNormalizedJson(normalized);
+  if (typeof parsed === "string") return normalized;
+  if (isNonEmptyRecord(parsed)) return normalized;
+  return Array.isArray(parsed) && parsed.length > 0 && parsed.every((item) => typeof item === "string") ? normalized : null;
+}
+
+export function quoteUnquotedObjectKeys(source: string): string {
+  let result = "";
+  let quote: string | null = null;
+  let escaped = false;
+
+  for (let i = 0; i < source.length; i += 1) {
+    const char = source[i];
+    if (quote) {
+      result += char;
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === quote) quote = null;
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      quote = char;
+      result += char;
+      continue;
+    }
+
+    if (/[A-Za-z_$]/.test(char) && shouldQuoteObjectKey(source, i)) {
+      let end = i + 1;
+      while (/[\w$]/.test(source[end] || "")) end += 1;
+      result += `"${source.slice(i, end)}"`;
+      i = end - 1;
+      continue;
+    }
+
+    result += char;
+  }
+
+  return result;
+}
+
+function shouldQuoteObjectKey(source: string, index: number): boolean {
+  let before = index - 1;
+  while (/\s/.test(source[before] || "")) before -= 1;
+  if (source[before] !== "{" && source[before] !== ",") return false;
+
+  let after = index + 1;
+  while (/[\w$]/.test(source[after] || "")) after += 1;
+  while (/\s/.test(source[after] || "")) after += 1;
+  return source[after] === ":";
+}
+
+function readChainedIntegerArgument(source: string, name: string, fallback: number): number | null {
+  const raw = readChainedCallArgument(source, name);
+  if (raw === undefined) return fallback;
+  const value = Number(raw.trim());
+  if (!Number.isSafeInteger(value) || value < 0) return null;
+  return value;
+}
+
+function removeChainedMethodCall(chain: string, name: string): string {
+  if (!chain.trim()) return "";
+  let result = chain.trim();
+  const pattern = chainedMethodCallPattern(name);
+  let match: RegExpExecArray | null;
+  while ((match = pattern.exec(result)) !== null) {
+    const openIndex = result.indexOf("(", match.index);
+    const closeIndex = findMatchingParen(result, openIndex);
+    if (closeIndex < 0) break;
+    result = `${result.slice(0, match.index)}${result.slice(closeIndex + 1)}`.trim();
+    pattern.lastIndex = 0;
+  }
+  return result;
+}
+
+function readChainedCallArgument(source: string, name: string): string | undefined {
+  const pattern = chainedMethodCallPattern(name);
+  let match = pattern.exec(source);
+  while (match) {
+    const openIndex = source.indexOf("(", match.index);
+    const closeIndex = findMatchingParen(source, openIndex);
+    if (closeIndex >= 0) return source.slice(openIndex + 1, closeIndex);
+    match = pattern.exec(source);
+  }
+  return undefined;
+}
+
+function hasSingleEmptyChainedCall(source: string, name: string): boolean {
+  const trimmed = source.trim();
+  const match = chainedMethodCallPattern(name).exec(trimmed);
+  if (!match || match.index !== 0) return false;
+  const openIndex = trimmed.indexOf("(", match.index);
+  const closeIndex = findMatchingParen(trimmed, openIndex);
+  return closeIndex >= 0 && !trimmed.slice(openIndex + 1, closeIndex).trim() && !trimmed.slice(closeIndex + 1).trim();
+}
+
+function findChainedMethodCallIndex(source: string, name: string): number {
+  return chainedMethodCallPattern(name).exec(source)?.index ?? -1;
+}
+
+function chainedMethodCallPattern(name: string): RegExp {
+  return new RegExp(`\\.\\s*${escapeRegExp(name)}\\s*\\(`, "g");
+}
+
+function splitTopLevel(source: string): string[] {
+  const parts: string[] = [];
+  let start = 0;
+  let depth = 0;
+  let quote: string | null = null;
+  let escaped = false;
+
+  for (let i = 0; i < source.length; i += 1) {
+    const char = source[i];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === quote) quote = null;
+      continue;
+    }
+
+    if (char === '"' || char === "'") quote = char;
+    else if (char === "{" || char === "[" || char === "(") depth += 1;
+    else if (char === "}" || char === "]" || char === ")") depth -= 1;
+    else if (char === "," && depth === 0) {
+      parts.push(source.slice(start, i).trim());
+      start = i + 1;
+    }
+  }
+
+  parts.push(source.slice(start).trim());
+  return parts;
+}
+
+function findMatchingParen(source: string, openIndex: number): number {
+  if (source[openIndex] !== "(") return -1;
+  let depth = 0;
+  let quote: string | null = null;
+  let escaped = false;
+
+  for (let i = openIndex; i < source.length; i += 1) {
+    const char = source[i];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === quote) quote = null;
+      continue;
+    }
+
+    if (char === '"' || char === "'") quote = char;
+    else if (char === "(") depth += 1;
+    else if (char === ")") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+
+  return -1;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function parseNormalizedJson(json: string): unknown {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return undefined;
+  }
+}
+
+function isNonEmptyRecord(value: unknown): value is Record<string, unknown> {
+  return isRecord(value) && Object.keys(value).length > 0;
+}
+
+function isEmptyJsonObject(json: string): boolean {
+  const parsed = parseNormalizedJson(json);
+  return isRecord(parsed) && Object.keys(parsed).length === 0;
+}
+
+function mongoDropIndexesRequiresDangerous(command: MongoWriteCommand): boolean {
+  if (command.kind !== "dropIndexes") return false;
+  if (!command.indexes) return true;
+  const parsed = parseNormalizedJson(command.indexes);
+  if (parsed === "*") return true;
+  return Array.isArray(parsed) && parsed.length > 1;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function toCellValue(value: unknown): string | number | boolean | null {
+  if (value === undefined || value === null) return null;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+  return JSON.stringify(value);
+}
diff --git a/apps/desktop/src/lib/mq/mqPinnedVersionOptions.ts b/apps/desktop/src/lib/mq/mqPinnedVersionOptions.ts
new file mode 100644
index 0000000..d8bbcf9
--- /dev/null
+++ b/apps/desktop/src/lib/mq/mqPinnedVersionOptions.ts
@@ -0,0 +1,31 @@
+export const MQ_PINNED_VERSION_AUTO = "auto";
+
+export interface MqPinnedVersionOption {
+  value: string;
+  label: string;
+  description: string;
+}
+
+export const MQ_PINNED_VERSION_OPTIONS: MqPinnedVersionOption[] = [
+  {
+    value: MQ_PINNED_VERSION_AUTO,
+    label: "Auto detect",
+    description: "Probe /admin/v2/brokers/version and use the default 3.1.x profile if probing fails.",
+  },
+  {
+    value: "3.1.x",
+    label: "Apache Pulsar 3.1.x",
+    description: "Supported Pulsar 3.x admin API profile, compatible with the 3.0/3.1 LTS line.",
+  },
+];
+
+export function pinnedVersionToSelection(pinnedVersion: string | null | undefined): string {
+  const value = pinnedVersion?.trim();
+  if (!value) return MQ_PINNED_VERSION_AUTO;
+  if (/^3(?:\.|$)/.test(value)) return "3.1.x";
+  return MQ_PINNED_VERSION_AUTO;
+}
+
+export function selectionToPinnedVersion(selection: string): string | undefined {
+  return MQ_PINNED_VERSION_OPTIONS.some((option) => option.value === selection) && selection !== MQ_PINNED_VERSION_AUTO ? selection : undefined;
+}
diff --git a/apps/desktop/src/lib/mq/mqPolicyForms.ts b/apps/desktop/src/lib/mq/mqPolicyForms.ts
new file mode 100644
index 0000000..8260f3e
--- /dev/null
+++ b/apps/desktop/src/lib/mq/mqPolicyForms.ts
@@ -0,0 +1,137 @@
+import type { BacklogQuota, DispatchRate, PublishRate, RetentionPolicy, SubscribeRate } from "@/types/mq";
+
+export interface MqPolicyForms {
+  publishForm: PublishRate;
+  dispatchForm: DispatchRate;
+  subscribeForm: SubscribeRate;
+  backlogForm: BacklogQuota;
+  retentionForm: RetentionPolicy;
+}
+
+export function defaultMqPolicyForms(): MqPolicyForms {
+  return {
+    publishForm: {
+      publishThrottlingRateInMsg: 0,
+      publishThrottlingRateInByte: 0,
+    },
+    dispatchForm: {
+      dispatchThrottlingRateInMsg: 0,
+      dispatchThrottlingRateInByte: 0,
+      ratePeriodInSecond: 1,
+    },
+    subscribeForm: {
+      subscribeThrottlingRatePerConsumer: 0,
+      ratePeriodInSecond: 1,
+    },
+    backlogForm: {
+      limitSize: -1,
+      limitTime: -1,
+      policy: "producer_request_hold",
+      quotaType: "destination_storage",
+    },
+    retentionForm: {
+      retentionTimeInMinutes: -1,
+      retentionSizeInMb: -1,
+    },
+  };
+}
+
+export function policyFormsFromEffectivePolicies(raw: unknown, fallback: MqPolicyForms): MqPolicyForms {
+  const root = objectRecord(raw);
+  const topicPolicies = objectRecord(root.topicPolicies);
+  const namespacePolicies = objectRecord(root.namespacePolicies);
+  const namespaceSource = Object.keys(namespacePolicies).length ? namespacePolicies : root;
+
+  const publish = firstRecord(topicPolicies.publishRate, root.publishRate, namespaceSource.publishRate, namespaceSource.publishMaxMessageRate);
+  const dispatch = firstRecord(topicPolicies.dispatchRate, root.dispatchRate, namespaceSource.dispatchRate);
+  const subscribe = firstRecord(topicPolicies.subscribeRate, root.subscribeRate, namespaceSource.subscribeRate);
+  const backlog = normalizeBacklogQuota(firstDefined(topicPolicies.backlogQuota, root.backlogQuota, namespaceSource.backlogQuota, namespaceSource.backlogQuotaMap, namespaceSource.backlog_quota_map));
+  const retention = firstRecord(topicPolicies.retention, root.retention, namespaceSource.retention, namespaceSource.retentionPolicies, namespaceSource.retention_policies);
+
+  return {
+    publishForm: publish
+      ? {
+          publishThrottlingRateInMsg: numberField(publish.publishThrottlingRateInMsg) ?? fallback.publishForm.publishThrottlingRateInMsg,
+          publishThrottlingRateInByte: numberField(publish.publishThrottlingRateInByte) ?? fallback.publishForm.publishThrottlingRateInByte,
+        }
+      : { ...fallback.publishForm },
+    dispatchForm: dispatch
+      ? {
+          dispatchThrottlingRateInMsg: numberField(dispatch.dispatchThrottlingRateInMsg) ?? fallback.dispatchForm.dispatchThrottlingRateInMsg,
+          dispatchThrottlingRateInByte: numberField(dispatch.dispatchThrottlingRateInByte) ?? fallback.dispatchForm.dispatchThrottlingRateInByte,
+          ratePeriodInSecond: numberField(dispatch.ratePeriodInSecond) ?? fallback.dispatchForm.ratePeriodInSecond,
+        }
+      : { ...fallback.dispatchForm },
+    subscribeForm: subscribe
+      ? {
+          subscribeThrottlingRatePerConsumer: numberField(subscribe.subscribeThrottlingRatePerConsumer) ?? fallback.subscribeForm.subscribeThrottlingRatePerConsumer,
+          ratePeriodInSecond: numberField(subscribe.ratePeriodInSecond) ?? fallback.subscribeForm.ratePeriodInSecond,
+        }
+      : { ...fallback.subscribeForm },
+    backlogForm: backlog
+      ? {
+          limitSize: numberField(backlog.limitSize) ?? numberField(backlog.limit) ?? fallback.backlogForm.limitSize,
+          limitTime: numberField(backlog.limitTime) ?? fallback.backlogForm.limitTime,
+          policy: stringField(backlog.policy) || fallback.backlogForm.policy,
+          quotaType: stringField(backlog.quotaType) || fallback.backlogForm.quotaType,
+        }
+      : { ...fallback.backlogForm },
+    retentionForm: retention
+      ? {
+          retentionTimeInMinutes: numberField(retention.retentionTimeInMinutes) ?? fallback.retentionForm.retentionTimeInMinutes,
+          retentionSizeInMb: numberField(retention.retentionSizeInMb) ?? numberField(retention.retentionSizeInMB) ?? fallback.retentionForm.retentionSizeInMb,
+        }
+      : { ...fallback.retentionForm },
+  };
+}
+
+function normalizeBacklogQuota(value: unknown): Record<string, unknown> | undefined {
+  const quota = objectRecord(value);
+  if (!Object.keys(quota).length) return undefined;
+  if (hasQuotaFields(quota)) return quota;
+
+  const entries = Object.entries(quota);
+  for (const [quotaType, body] of entries) {
+    const normalized = objectRecord(body);
+    if (hasQuotaFields(normalized)) {
+      return {
+        ...normalized,
+        quotaType: normalized.quotaType ?? quotaType,
+      };
+    }
+  }
+  return undefined;
+}
+
+function hasQuotaFields(value: Record<string, unknown>): boolean {
+  return "limit" in value || "limitSize" in value || "limitTime" in value || "policy" in value;
+}
+
+function firstRecord(...values: unknown[]): Record<string, unknown> | undefined {
+  for (const value of values) {
+    const record = objectRecord(value);
+    if (Object.keys(record).length) return record;
+  }
+  return undefined;
+}
+
+function firstDefined(...values: unknown[]) {
+  return values.find((value) => value !== undefined && value !== null);
+}
+
+function objectRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : {};
+}
+
+function numberField(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return undefined;
+}
+
+function stringField(value: unknown): string | undefined {
+  return typeof value === "string" ? value : undefined;
+}
diff --git a/apps/desktop/src/lib/mq/mqTenantForm.ts b/apps/desktop/src/lib/mq/mqTenantForm.ts
new file mode 100644
index 0000000..f7a6ede
--- /dev/null
+++ b/apps/desktop/src/lib/mq/mqTenantForm.ts
@@ -0,0 +1,42 @@
+import type { TenantConfig } from "@/types/mq";
+
+export function normalizeClusterOptions(clusters: readonly unknown[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+
+  for (const cluster of clusters) {
+    if (typeof cluster !== "string") continue;
+    const name = cluster.trim();
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    result.push(name);
+  }
+
+  return result;
+}
+
+export function mqClusterOptionsFromExtra(extra: unknown): string[] {
+  if (!extra || typeof extra !== "object") return [];
+
+  const clusters = (extra as { clusters?: unknown }).clusters;
+  if (!Array.isArray(clusters)) return [];
+
+  return normalizeClusterOptions(clusters);
+}
+
+export function defaultTenantConfig(clusterOptions: readonly string[]): TenantConfig {
+  return {
+    adminRoles: [],
+    allowedClusters: normalizeClusterOptions(clusterOptions),
+  };
+}
+
+export function validateTenantForm(name: string | undefined, config: TenantConfig): string | undefined {
+  if (!name?.trim()) {
+    return "Tenant name is required";
+  }
+  if (!normalizeClusterOptions(config.allowedClusters).length) {
+    return "Allowed clusters are required";
+  }
+  return undefined;
+}
diff --git a/apps/desktop/src/lib/mq/mqTokenErrors.ts b/apps/desktop/src/lib/mq/mqTokenErrors.ts
new file mode 100644
index 0000000..bdc79fa
--- /dev/null
+++ b/apps/desktop/src/lib/mq/mqTokenErrors.ts
@@ -0,0 +1,31 @@
+export type MqTokenIssueErrorView =
+  | {
+      kind: "missingSigningKey";
+      title: string;
+      message: string;
+      detail: string;
+    }
+  | {
+      kind: "generic";
+      title?: undefined;
+      message: string;
+      detail?: undefined;
+    };
+
+export function formatMqTokenIssueError(error: unknown): MqTokenIssueErrorView {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  if (isMissingTokenSigningConfig(message)) {
+    return {
+      kind: "missingSigningKey",
+      title: "未配置 Token 签发密钥",
+      message: "当前 MQ 连接还没有配置 Broker Token 签发密钥，无法生成客户端 Token。",
+      detail: "请编辑该连接，在 MQ 配置中设置“Broker Token 签发”为 HS256 SECRET 或 RS256 PRIVATE，并填写签发密钥后再生成。",
+    };
+  }
+  return { kind: "generic", message };
+}
+
+function isMissingTokenSigningConfig(message: string) {
+  const normalized = message.toLowerCase();
+  return normalized.includes("token signing is not configured") || normalized.includes("token signing key is required") || normalized.includes("broker token signing key is required");
+}
diff --git a/apps/desktop/src/lib/nacos/nacosAdmin.ts b/apps/desktop/src/lib/nacos/nacosAdmin.ts
new file mode 100644
index 0000000..6e2a5b0
--- /dev/null
+++ b/apps/desktop/src/lib/nacos/nacosAdmin.ts
@@ -0,0 +1,354 @@
+import type { NacosConfigHistoryItem, NacosConfigItem, NacosInstanceInfo, NacosRawRequest, NacosServiceInfo } from "@/types/nacos";
+import { diffChars, diffLines } from "diff";
+
+export type NacosRawTemplateKey = "serverState" | "namespaceList" | "configDetail" | "serviceList" | "instanceList";
+
+export interface NacosRawTemplate {
+  key: NacosRawTemplateKey;
+  method: string;
+  path: string;
+  query: string;
+  body: string;
+}
+
+export const NACOS_RAW_TEMPLATES: NacosRawTemplate[] = [
+  { key: "serverState", method: "GET", path: "/v3/console/server/state", query: "", body: "" },
+  { key: "namespaceList", method: "GET", path: "/v3/console/core/namespace/list", query: "", body: "" },
+  {
+    key: "configDetail",
+    method: "GET",
+    path: "/v3/console/cs/config",
+    query: "dataId=application.yaml&groupName=DEFAULT_GROUP&namespaceId=",
+    body: "",
+  },
+  {
+    key: "serviceList",
+    method: "GET",
+    path: "/v3/console/ns/service/list",
+    query: "pageNo=1&pageSize=20&namespaceId=",
+    body: "",
+  },
+  {
+    key: "instanceList",
+    method: "GET",
+    path: "/v3/console/ns/instance/list",
+    query: "serviceName=DEFAULT_GROUP@@example&namespaceId=",
+    body: "",
+  },
+];
+
+export function parseNacosRawQuery(text: string): Record<string, string> | undefined {
+  const trimmed = text.trim().replace(/^\?/, "");
+  if (!trimmed) return undefined;
+  return Object.fromEntries(new URLSearchParams(trimmed).entries());
+}
+
+export function parseNacosRawBody(text: string): unknown {
+  const trimmed = text.trim();
+  if (!trimmed) return undefined;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return text;
+  }
+}
+
+export function buildNacosRawRequest(method: string, path: string, queryText: string, bodyText: string): NacosRawRequest {
+  return {
+    method,
+    path: path.trim(),
+    query: parseNacosRawQuery(queryText),
+    body: parseNacosRawBody(bodyText),
+  };
+}
+
+export function isNacosRawMutation(method: string): boolean {
+  return method.trim().toUpperCase() !== "GET";
+}
+
+export function formatNacosConfigIdentity(item: Pick<NacosConfigItem, "namespace" | "dataId" | "group">, fallbackNamespace = ""): string {
+  return [`namespace=${item.namespace || fallbackNamespace || "public"}`, `dataId=${item.dataId}`, `group=${item.group || "DEFAULT_GROUP"}`].join("\n");
+}
+
+export function buildNacosConfigExport(item: NacosConfigItem, content: string): string {
+  return [`# namespace: ${item.namespace || "public"}`, `# dataId: ${item.dataId}`, `# group: ${item.group || "DEFAULT_GROUP"}`, item.configType ? `# type: ${item.configType}` : "", "", content].filter((line, index) => index >= 4 || line).join("\n");
+}
+
+export function buildNacosConfigCopy(item: NacosConfigItem, content: string): string {
+  return `${formatNacosConfigIdentity(item)}\n\n${content}`;
+}
+
+export function resolveNacosConfigCopyText(selectionText: string, editorText: string | undefined, stateText: string): string {
+  return selectionText || editorText || stateText;
+}
+
+export function sanitizeNacosConfigFileNameSegment(value: string): string {
+  const sanitized = value
+    .trim()
+    .replace(/[<>:"/\\|?*\x00-\x1f]/g, "_")
+    .replace(/\s+/g, " ")
+    .replace(/^[._\s-]+/, "")
+    .replace(/\.+$/, "");
+  return sanitized || "nacos-config";
+}
+
+export function nacosConfigFileExtension(configType?: string): string {
+  const normalized = configType?.trim().toLowerCase();
+  if (normalized === "yaml" || normalized === "yml") return "yaml";
+  if (normalized === "json") return "json";
+  if (normalized === "xml") return "xml";
+  if (normalized === "html") return "html";
+  if (normalized === "properties" || normalized === "props") return "properties";
+  if (normalized === "toml") return "toml";
+  return "txt";
+}
+
+export function buildNacosConfigExportFileName(item: Pick<NacosConfigItem, "dataId" | "configType">): string {
+  const baseName = sanitizeNacosConfigFileNameSegment(item.dataId || "nacos-config");
+  if (/\.[A-Za-z0-9][A-Za-z0-9_-]{0,15}$/.test(baseName)) return baseName;
+  return `${baseName}.${nacosConfigFileExtension(item.configType)}`;
+}
+
+export function createNacosSaveAsCopy(item: NacosConfigItem): NacosConfigItem {
+  return {
+    ...item,
+    dataId: item.dataId ? `${item.dataId}.copy` : "",
+    content: item.content ?? "",
+  };
+}
+
+export interface NacosDiffSummary {
+  changed: boolean;
+  addedLines: number;
+  removedLines: number;
+  preview: string;
+}
+
+export type NacosDiffLineType = "equal" | "delete" | "insert" | "modify" | "padding";
+
+export interface NacosInlineSegment {
+  value: string;
+  changed: boolean;
+}
+
+export interface NacosSideBySideDiffRow {
+  id: string;
+  leftLineNumber: number | null;
+  rightLineNumber: number | null;
+  leftContent: string;
+  rightContent: string;
+  leftType: NacosDiffLineType;
+  rightType: NacosDiffLineType;
+  leftInline: NacosInlineSegment[];
+  rightInline: NacosInlineSegment[];
+}
+
+export interface NacosInlineDiffRow {
+  id: string;
+  lineNumber: number | null;
+  content: string;
+  type: Exclude<NacosDiffLineType, "modify" | "padding">;
+  segments: NacosInlineSegment[];
+}
+
+export function summarizeNacosConfigDiff(before: string, after: string, maxPreviewLines = 40): NacosDiffSummary {
+  if (before === after) {
+    return { changed: false, addedLines: 0, removedLines: 0, preview: "No content changes." };
+  }
+  const beforeLines = before.split(/\r?\n/);
+  const afterLines = after.split(/\r?\n/);
+  const max = Math.max(beforeLines.length, afterLines.length);
+  const lines: string[] = [];
+  let addedLines = 0;
+  let removedLines = 0;
+  for (let index = 0; index < max; index += 1) {
+    const left = beforeLines[index];
+    const right = afterLines[index];
+    if (left === right) continue;
+    if (left !== undefined) {
+      removedLines += 1;
+      lines.push(`- ${left}`);
+    }
+    if (right !== undefined) {
+      addedLines += 1;
+      lines.push(`+ ${right}`);
+    }
+    if (lines.length >= maxPreviewLines) {
+      lines.push("...");
+      break;
+    }
+  }
+  return { changed: true, addedLines, removedLines, preview: lines.join("\n") };
+}
+
+function normalizeNacosDiffText(value: string): string {
+  return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+function splitDiffLines(value: string): string[] {
+  const lines = normalizeNacosDiffText(value).split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+
+function inlineSegments(left: string, right: string): { left: NacosInlineSegment[]; right: NacosInlineSegment[] } {
+  const changes = diffChars(left, right);
+  const leftSegments: NacosInlineSegment[] = [];
+  const rightSegments: NacosInlineSegment[] = [];
+  for (const change of changes) {
+    if (change.removed) {
+      leftSegments.push({ value: change.value, changed: true });
+    } else if (change.added) {
+      rightSegments.push({ value: change.value, changed: true });
+    } else {
+      leftSegments.push({ value: change.value, changed: false });
+      rightSegments.push({ value: change.value, changed: false });
+    }
+  }
+  return { left: leftSegments, right: rightSegments };
+}
+
+function pairChangedLines(leftLines: string[], rightLines: string[], leftStart: number, rightStart: number, rows: NacosSideBySideDiffRow[], nextId: () => string) {
+  const max = Math.max(leftLines.length, rightLines.length);
+  for (let index = 0; index < max; index += 1) {
+    const left = leftLines[index];
+    const right = rightLines[index];
+    const hasLeft = left !== undefined;
+    const hasRight = right !== undefined;
+    const inline = hasLeft && hasRight ? inlineSegments(left, right) : { left: [], right: [] };
+    rows.push({
+      id: nextId(),
+      leftLineNumber: hasLeft ? leftStart + index : null,
+      rightLineNumber: hasRight ? rightStart + index : null,
+      leftContent: left ?? "",
+      rightContent: right ?? "",
+      leftType: hasLeft ? (hasRight ? "modify" : "delete") : "padding",
+      rightType: hasRight ? (hasLeft ? "modify" : "insert") : "padding",
+      leftInline: inline.left,
+      rightInline: inline.right,
+    });
+  }
+}
+
+export function buildNacosSideBySideDiff(before: string, after: string): NacosSideBySideDiffRow[] {
+  const changes = diffLines(normalizeNacosDiffText(before), normalizeNacosDiffText(after), { newlineIsToken: false });
+  const rows: NacosSideBySideDiffRow[] = [];
+  let leftLineNumber = 1;
+  let rightLineNumber = 1;
+  let id = 0;
+  const nextId = () => `nacos-diff-${id++}`;
+
+  for (let index = 0; index < changes.length; index += 1) {
+    const change = changes[index];
+    if (!change.added && !change.removed) {
+      for (const line of splitDiffLines(change.value)) {
+        rows.push({
+          id: nextId(),
+          leftLineNumber,
+          rightLineNumber,
+          leftContent: line,
+          rightContent: line,
+          leftType: "equal",
+          rightType: "equal",
+          leftInline: [{ value: line, changed: false }],
+          rightInline: [{ value: line, changed: false }],
+        });
+        leftLineNumber += 1;
+        rightLineNumber += 1;
+      }
+      continue;
+    }
+
+    if (change.removed) {
+      const leftLines = splitDiffLines(change.value);
+      const next = changes[index + 1];
+      if (next?.added) {
+        const rightLines = splitDiffLines(next.value);
+        pairChangedLines(leftLines, rightLines, leftLineNumber, rightLineNumber, rows, nextId);
+        leftLineNumber += leftLines.length;
+        rightLineNumber += rightLines.length;
+        index += 1;
+      } else {
+        pairChangedLines(leftLines, [], leftLineNumber, rightLineNumber, rows, nextId);
+        leftLineNumber += leftLines.length;
+      }
+      continue;
+    }
+
+    if (change.added) {
+      const rightLines = splitDiffLines(change.value);
+      pairChangedLines([], rightLines, leftLineNumber, rightLineNumber, rows, nextId);
+      rightLineNumber += rightLines.length;
+    }
+  }
+
+  return rows;
+}
+
+function visibleInlineSegments(content: string, segments: NacosInlineSegment[]): NacosInlineSegment[] {
+  return segments.length ? segments : [{ value: content, changed: false }];
+}
+
+export function buildNacosInlineDiff(before: string, after: string): NacosInlineDiffRow[] {
+  return buildNacosSideBySideDiff(before, after).flatMap((row) => {
+    if (row.leftType === "equal" && row.rightType === "equal") {
+      return [
+        {
+          id: `${row.id}-equal`,
+          lineNumber: row.leftLineNumber,
+          content: row.leftContent,
+          type: "equal" as const,
+          segments: visibleInlineSegments(row.leftContent, row.leftInline),
+        },
+      ];
+    }
+
+    const rows: NacosInlineDiffRow[] = [];
+    if (row.leftType === "delete" || row.leftType === "modify") {
+      rows.push({
+        id: `${row.id}-delete`,
+        lineNumber: row.leftLineNumber,
+        content: row.leftContent,
+        type: "delete",
+        segments: visibleInlineSegments(row.leftContent, row.leftInline),
+      });
+    }
+    if (row.rightType === "insert" || row.rightType === "modify") {
+      rows.push({
+        id: `${row.id}-insert`,
+        lineNumber: row.rightLineNumber,
+        content: row.rightContent,
+        type: "insert",
+        segments: visibleInlineSegments(row.rightContent, row.rightInline),
+      });
+    }
+    return rows;
+  });
+}
+
+export function buildNacosConfigDeleteConfirm(item: NacosConfigItem, fallbackNamespace = ""): string {
+  return formatNacosConfigIdentity(item, fallbackNamespace);
+}
+
+export function buildNacosConfigHistoryRollbackConfirm(item: NacosConfigHistoryItem, fallbackNamespace = ""): string {
+  return [`namespace=${item.namespace || fallbackNamespace || "public"}`, `dataId=${item.dataId}`, `group=${item.group || "DEFAULT_GROUP"}`, item.lastModifiedTime ? `historyTime=${item.lastModifiedTime}` : "", item.operator ? `operator=${item.operator}` : ""].filter(Boolean).join("\n");
+}
+
+export function buildNacosInstanceConfirm(service: NacosServiceInfo, instance: NacosInstanceInfo, patch: Partial<NacosInstanceInfo>, fallbackGroup = "", namespace = ""): string {
+  const targetEnabled = patch.enabled ?? instance.enabled;
+  const targetHealthy = patch.healthy ?? instance.healthy;
+  return [
+    `namespace=${namespace || "public"}`,
+    `serviceName=${service.serviceName}`,
+    `group=${instance.groupName || service.groupName || fallbackGroup || "DEFAULT_GROUP"}`,
+    `instance=${instance.ip}:${instance.port}`,
+    patch.enabled == null ? "" : `targetEnabled=${targetEnabled === false ? "false" : "true"}`,
+    patch.healthy == null ? "" : `targetHealthy=${targetHealthy === false ? "false" : "true"}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+export function buildNacosRawMutationConfirm(req: NacosRawRequest): string {
+  return [`method=${req.method.toUpperCase()}`, `path=${req.path}`, req.query ? `query=${JSON.stringify(req.query)}` : ""].filter(Boolean).join("\n");
+}
diff --git a/apps/desktop/src/lib/query/queryResultArchive.ts b/apps/desktop/src/lib/query/queryResultArchive.ts
new file mode 100644
index 0000000..1d86c33
--- /dev/null
+++ b/apps/desktop/src/lib/query/queryResultArchive.ts
@@ -0,0 +1,140 @@
+import { decode, encode } from "@msgpack/msgpack";
+import type { QueryTab } from "@/types/database";
+import { decodeTabResultSnapshot, encodeTabResultSnapshot, type TabResultSnapshot } from "@/lib/tabs/tabResultCache";
+
+const ARCHIVE_MAGIC = "DBX_QUERY_RESULT_ARCHIVE";
+const ARCHIVE_VERSION = 1;
+const ARCHIVE_CODEC = "msgpack-tab-result-snapshot";
+
+export interface QueryResultArchiveTab {
+  title: string;
+  connectionId: string;
+  database: string;
+  schema?: string;
+  sql: string;
+  lastExecutedSql?: string;
+  resultBaseSql?: string;
+  resultSortedSql?: string;
+}
+
+export interface DecodedQueryResultArchive {
+  createdAt: number;
+  tab: QueryResultArchiveTab;
+  snapshot: TabResultSnapshot;
+}
+
+interface QueryResultArchiveEnvelope {
+  magic: typeof ARCHIVE_MAGIC;
+  version: typeof ARCHIVE_VERSION;
+  codec: typeof ARCHIVE_CODEC;
+  createdAt: number;
+  tab: QueryResultArchiveTab;
+  snapshot: Uint8Array;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isBinaryLike(value: unknown): boolean {
+  return value instanceof ArrayBuffer || ArrayBuffer.isView(value);
+}
+
+function removeUndefinedFields<T>(value: T): T {
+  if (Array.isArray(value)) return value.map((item) => removeUndefinedFields(item)) as T;
+  if (isBinaryLike(value)) return value;
+  if (!isRecord(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(([, entryValue]) => entryValue !== undefined)
+      .map(([key, entryValue]) => [key, removeUndefinedFields(entryValue)]),
+  ) as T;
+}
+
+function archiveTabMetadata(tab: QueryTab): QueryResultArchiveTab {
+  return removeUndefinedFields({
+    title: tab.title,
+    connectionId: tab.connectionId,
+    database: tab.database,
+    schema: tab.schema,
+    sql: tab.sql,
+    lastExecutedSql: tab.lastExecutedSql,
+    resultBaseSql: tab.resultBaseSql,
+    resultSortedSql: tab.resultSortedSql,
+  });
+}
+
+function isArchiveTab(value: unknown): value is QueryResultArchiveTab {
+  if (!isRecord(value)) return false;
+  return typeof value.title === "string" && typeof value.connectionId === "string" && typeof value.database === "string" && typeof value.sql === "string";
+}
+
+function binaryPayload(value: unknown): Uint8Array | undefined {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  return undefined;
+}
+
+async function transformBytes(bytes: Uint8Array, stream: CompressionStream | DecompressionStream): Promise<Uint8Array> {
+  const output = new Response(stream.readable).arrayBuffer();
+  const writer = stream.writable.getWriter();
+  await writer.write(bytes.slice());
+  await writer.close();
+  return new Uint8Array(await output);
+}
+
+async function gzipBytes(bytes: Uint8Array): Promise<Uint8Array> {
+  if (typeof CompressionStream === "undefined") return bytes;
+  try {
+    return await transformBytes(bytes, new CompressionStream("gzip"));
+  } catch {
+    return bytes;
+  }
+}
+
+async function gunzipBytes(bytes: Uint8Array): Promise<Uint8Array> {
+  if (bytes[0] !== 0x1f || bytes[1] !== 0x8b || typeof DecompressionStream === "undefined") return bytes;
+  return transformBytes(bytes, new DecompressionStream("gzip"));
+}
+
+export function defaultQueryResultArchiveFileName(title: string | undefined): string {
+  const base = (title ?? "")
+    .trim()
+    .replace(/[^A-Za-z0-9._-]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .slice(0, 80);
+  return `${base || "query-results"}.dbxresults`;
+}
+
+export async function encodeQueryResultArchive(tab: QueryTab, snapshot: TabResultSnapshot): Promise<Uint8Array> {
+  const envelope: QueryResultArchiveEnvelope = {
+    magic: ARCHIVE_MAGIC,
+    version: ARCHIVE_VERSION,
+    codec: ARCHIVE_CODEC,
+    createdAt: Date.now(),
+    tab: archiveTabMetadata(tab),
+    snapshot: encodeTabResultSnapshot(snapshot),
+  };
+  return gzipBytes(encode(removeUndefinedFields(envelope)));
+}
+
+export async function decodeQueryResultArchive(bytes: Uint8Array | ArrayBuffer): Promise<DecodedQueryResultArchive | undefined> {
+  try {
+    const rawBytes = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+    const decoded = decode(await gunzipBytes(rawBytes));
+    if (!isRecord(decoded)) return undefined;
+    if (decoded.magic !== ARCHIVE_MAGIC || decoded.version !== ARCHIVE_VERSION || decoded.codec !== ARCHIVE_CODEC) return undefined;
+    if (!isArchiveTab(decoded.tab)) return undefined;
+    const snapshotBytes = binaryPayload(decoded.snapshot);
+    if (!snapshotBytes) return undefined;
+    const snapshot = decodeTabResultSnapshot(snapshotBytes);
+    if (!snapshot) return undefined;
+    return {
+      createdAt: typeof decoded.createdAt === "number" ? decoded.createdAt : Date.now(),
+      tab: decoded.tab,
+      snapshot,
+    };
+  } catch {
+    return undefined;
+  }
+}
diff --git a/apps/desktop/src/lib/query/queryResultArchiveFile.ts b/apps/desktop/src/lib/query/queryResultArchiveFile.ts
new file mode 100644
index 0000000..443ed6a
--- /dev/null
+++ b/apps/desktop/src/lib/query/queryResultArchiveFile.ts
@@ -0,0 +1,62 @@
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+
+const ARCHIVE_MIME_TYPE = "application/vnd.dbx.results";
+const ARCHIVE_EXTENSIONS = ["dbxresults"];
+
+function downloadArchiveFile(fileName: string, bytes: Uint8Array): string {
+  const blob = new Blob([bytes.slice().buffer], { type: ARCHIVE_MIME_TYPE });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = fileName;
+  a.click();
+  URL.revokeObjectURL(url);
+  return fileName;
+}
+
+function openArchiveFileInBrowser(): Promise<Uint8Array | undefined> {
+  return new Promise((resolve, reject) => {
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = ".dbxresults,application/octet-stream,application/vnd.dbx.results";
+    input.onchange = async () => {
+      try {
+        const file = input.files?.[0];
+        if (!file) {
+          resolve(undefined);
+          return;
+        }
+        resolve(new Uint8Array(await file.arrayBuffer()));
+      } catch (error) {
+        reject(error);
+      }
+    };
+    input.click();
+  });
+}
+
+export async function saveQueryResultArchiveFile(fileName: string, bytes: Uint8Array): Promise<string | undefined> {
+  if (!isTauriRuntime()) return downloadArchiveFile(fileName, bytes);
+
+  const [{ save }, { writeFile }] = await Promise.all([import("@tauri-apps/plugin-dialog"), import("@tauri-apps/plugin-fs")]);
+  const path = await save({
+    defaultPath: fileName,
+    filters: [{ name: "DBX Result Archive", extensions: ARCHIVE_EXTENSIONS }],
+  });
+  if (!path) return undefined;
+  await writeFile(path, bytes);
+  return path;
+}
+
+export async function openQueryResultArchiveFile(): Promise<Uint8Array | undefined> {
+  if (!isTauriRuntime()) return openArchiveFileInBrowser();
+
+  const [{ open }, { readFile }] = await Promise.all([import("@tauri-apps/plugin-dialog"), import("@tauri-apps/plugin-fs")]);
+  const selected = await open({
+    multiple: false,
+    filters: [{ name: "DBX Result Archive", extensions: ARCHIVE_EXTENSIONS }],
+  });
+  const path = Array.isArray(selected) ? selected[0] : selected;
+  if (!path) return undefined;
+  return readFile(path);
+}
diff --git a/apps/desktop/src/lib/query/queryResultError.ts b/apps/desktop/src/lib/query/queryResultError.ts
new file mode 100644
index 0000000..43d6a4a
--- /dev/null
+++ b/apps/desktop/src/lib/query/queryResultError.ts
@@ -0,0 +1,24 @@
+import type { DatabaseType, QueryResult } from "@/types/database";
+
+// Lake/external tables (e.g. Paimon in StarRocks) return this error on a data
+// read when no snapshot exists yet, while metadata reads (DESC/SHOW CREATE)
+// still succeed. executeTabSql surfaces query failures as an "Error" result, so
+// callers can detect this case and fall back to a structure-only (LIMIT 0)
+// preview instead of showing a cryptic server error.
+const NO_SNAPSHOT_ERROR_PATTERN = /there is currently no snapshot/i;
+const MYSQL_PROTOCOL_DATABASE_TYPES = new Set<DatabaseType>(["mysql", "doris", "starrocks", "manticoresearch"]);
+
+export function usesMysqlProtocolDatabaseType(databaseType: DatabaseType | undefined): boolean {
+  return databaseType !== undefined && MYSQL_PROTOCOL_DATABASE_TYPES.has(databaseType);
+}
+
+// The batch executor marks synthesized MySQL-protocol errors explicitly so a
+// successful result column named Error is never mistaken for a failure.
+export function isMysqlExecutionErrorResult(result: QueryResult, databaseType: DatabaseType | undefined): boolean {
+  return usesMysqlProtocolDatabaseType(databaseType) && result.execution_error === true;
+}
+
+export function isNoSnapshotErrorResult(result: QueryResult | undefined | null): boolean {
+  if (!result || !result.columns.includes("Error") || result.rows.length === 0) return false;
+  return NO_SNAPSHOT_ERROR_PATTERN.test(String(result.rows[0]?.[0] ?? ""));
+}
diff --git a/apps/desktop/src/lib/redis/javaSerialized.ts b/apps/desktop/src/lib/redis/javaSerialized.ts
new file mode 100644
index 0000000..8cec4ec
--- /dev/null
+++ b/apps/desktop/src/lib/redis/javaSerialized.ts
@@ -0,0 +1,559 @@
+export interface RedisJavaSerializedDetail {
+  formattedText: string;
+  value: unknown;
+}
+
+type JavaFieldDescriptor = {
+  type: string;
+  name: string;
+  className?: string;
+};
+
+type JavaClassDescriptor = {
+  name: string;
+  serialVersionUID: string;
+  flags: number;
+  isEnum: boolean;
+  fields: JavaFieldDescriptor[];
+  superClass: JavaClassDescriptor | null;
+};
+
+type JavaObjectValue = Record<string, unknown> & {
+  [JAVA_CLASS_META]?: JavaClassDescriptor;
+  [JAVA_EXTENDS_META]?: Record<string, Record<string, unknown>>;
+};
+
+type JavaPostProcessor = (fields: Record<string, unknown>, annotations: unknown[]) => Record<string, unknown>;
+
+const JAVA_CLASS_META = Symbol("javaClassMeta");
+const JAVA_EXTENDS_META = Symbol("javaExtendsMeta");
+const STREAM_MAGIC = 0xaced;
+const STREAM_VERSION = 5;
+const BASE_WIRE_HANDLE = 0x7e0000;
+const END_BLOCK = Symbol("endBlock");
+
+const TAG_NAMES: Record<number, string> = {
+  0x70: "Null",
+  0x71: "Reference",
+  0x72: "ClassDesc",
+  0x73: "Object",
+  0x74: "String",
+  0x75: "Array",
+  0x76: "Class",
+  0x77: "BlockData",
+  0x78: "EndBlockData",
+  0x79: "Reset",
+  0x7a: "BlockDataLong",
+  0x7b: "Exception",
+  0x7c: "LongString",
+  0x7d: "ProxyClassDesc",
+  0x7e: "Enum",
+};
+
+const JAVA_POST_PROCESSORS = new Map<string, JavaPostProcessor>([
+  ["java.util.ArrayList@7881d21d99c7619d", (fields, annotations) => ({ ...fields, list: annotations.slice(1) })],
+  ["java.util.ArrayDeque@207cda2e240da08b", (fields, annotations) => ({ ...fields, list: annotations.slice(1) })],
+  ["java.util.Hashtable@13bb0f25214ae4b8", mapPostProcessor],
+  ["java.util.HashMap@0507dac1c31660d1", mapPostProcessor],
+  ["java.util.HashMap@0507b0c1331660d1", mapPostProcessor],
+  ["java.util.EnumMap@065d7df7be907ca1", enumMapPostProcessor],
+  ["java.util.HashSet@ba44859596b8b734", hashSetPostProcessor],
+]);
+
+export function parseJavaSerializedDetail(bytes: Uint8Array): RedisJavaSerializedDetail | null {
+  if (!isJavaSerialized(bytes)) return null;
+
+  try {
+    const parser = new JavaSerializationParser(bytes);
+    const contents = parser.parseContents();
+    if (contents.length === 0) return null;
+    const root = contents.length === 1 ? contents[0] : contents;
+    const normalized = normalizeJavaSerializedValue(root, new WeakMap<object, string>(), { nextId: 1 });
+    return {
+      value: normalized,
+      formattedText: JSON.stringify(normalized, null, 2),
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function isJavaSerialized(bytes: Uint8Array): boolean {
+  return bytes.length >= 4 && bytes[0] === 0xac && bytes[1] === 0xed && bytes[2] === 0x00 && bytes[3] === 0x05;
+}
+
+class JavaSerializationParser {
+  private readonly view: DataView;
+  private position = 0;
+  private nextHandle = BASE_WIRE_HANDLE;
+  private readonly handles = new Map<number, unknown>();
+
+  constructor(private readonly bytes: Uint8Array) {
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  }
+
+  parseContents(): unknown[] {
+    if (this.readUint16() !== STREAM_MAGIC) throw new Error("STREAM_MAGIC not found");
+    if (this.readUint16() !== STREAM_VERSION) throw new Error("Only understand protocol version 5");
+
+    const contents: unknown[] = [];
+    while (this.position < this.bytes.length) {
+      contents.push(this.readContent());
+    }
+    return contents;
+  }
+
+  private readContent(allowed?: string[]): unknown {
+    const tag = this.readUint8();
+    const name = TAG_NAMES[tag];
+    if (!name) throw new Error(`Don't know about type 0x${tag.toString(16)}`);
+    if (allowed && !allowed.includes(name)) throw new Error(`${name} not allowed here`);
+
+    switch (tag) {
+      case 0x70:
+        return null;
+      case 0x71:
+        return this.readReference();
+      case 0x72:
+        return this.readClassDescriptor();
+      case 0x73:
+        return this.readObject();
+      case 0x74:
+        return this.addHandle(this.readUtf());
+      case 0x75:
+        return this.readArray();
+      case 0x76:
+        return this.addHandle(this.readClassDesc());
+      case 0x77:
+        return this.readBytes(this.readUint8());
+      case 0x78:
+        return END_BLOCK;
+      case 0x79:
+      case 0x7b:
+      case 0x7d:
+        throw new Error(`Don't know how to handle ${name}`);
+      case 0x7a:
+        return this.readBytes(this.readUint32());
+      case 0x7c:
+        return this.addHandle(this.readUtfLong());
+      case 0x7e:
+        return this.readEnum();
+      default:
+        throw new Error(`Don't know how to handle ${name}`);
+    }
+  }
+
+  private readClassDesc(): JavaClassDescriptor | null {
+    return this.readContent(["ClassDesc", "ProxyClassDesc", "Null", "Reference"]) as JavaClassDescriptor | null;
+  }
+
+  private readClassDescriptor(): JavaClassDescriptor {
+    const descriptor: JavaClassDescriptor = {
+      name: this.readUtf(),
+      serialVersionUID: bytesToHex(this.readBytes(8)),
+      flags: 0,
+      isEnum: false,
+      fields: [],
+      superClass: null,
+    };
+    this.addHandle(descriptor);
+
+    descriptor.flags = this.readUint8();
+    descriptor.isEnum = Boolean(descriptor.flags & 0x10);
+    const count = this.readUint16();
+    for (let index = 0; index < count; index += 1) {
+      descriptor.fields.push(this.readFieldDescriptor());
+    }
+    this.readAnnotations();
+    descriptor.superClass = this.readClassDesc();
+    return descriptor;
+  }
+
+  private readFieldDescriptor(): JavaFieldDescriptor {
+    const type = String.fromCharCode(this.readUint8());
+    const field: JavaFieldDescriptor = { type, name: this.readUtf() };
+    if (type === "[" || type === "L") {
+      const className = this.readContent();
+      field.className = typeof className === "string" ? className : String(className ?? "");
+    }
+    return field;
+  }
+
+  private readObject(): JavaObjectValue {
+    const classDescriptor = this.readClassDesc();
+    if (!classDescriptor) throw new Error("Object must have a class descriptor");
+
+    const value: JavaObjectValue = {};
+    Object.defineProperty(value, JAVA_CLASS_META, { value: classDescriptor, configurable: true });
+    Object.defineProperty(value, JAVA_EXTENDS_META, { value: {}, configurable: true });
+    this.addHandle(value);
+    this.readClassDataRecursive(classDescriptor, value);
+    return value;
+  }
+
+  private readClassDataRecursive(classDescriptor: JavaClassDescriptor, value: JavaObjectValue) {
+    if (classDescriptor.superClass) {
+      this.readClassDataRecursive(classDescriptor.superClass, value);
+    }
+
+    const fields = this.readClassData(classDescriptor);
+    value[JAVA_EXTENDS_META]![classDescriptor.name] = fields;
+    for (const [name, fieldValue] of Object.entries(fields)) {
+      value[name] = fieldValue;
+    }
+  }
+
+  private readClassData(classDescriptor: JavaClassDescriptor): Record<string, unknown> {
+    const flags = classDescriptor.flags & 0x0f;
+    const postProcessor = JAVA_POST_PROCESSORS.get(`${classDescriptor.name}@${classDescriptor.serialVersionUID}`);
+
+    if (flags === 0x02) return this.readFieldValues(classDescriptor);
+    if (flags === 0x03) {
+      const fields = this.readFieldValues(classDescriptor);
+      const annotations = this.readAnnotations();
+      fields["@"] = annotations;
+      return postProcessor ? postProcessor(fields, annotations) : fields;
+    }
+    if (flags === 0x04) throw new Error("Can't parse version 1 external content");
+    if (flags === 0x0c) {
+      const annotations = this.readAnnotations();
+      return { "@": annotations };
+    }
+    throw new Error(`Don't know how to deserialize class with flags 0x${classDescriptor.flags.toString(16)}`);
+  }
+
+  private readArray(): unknown[] {
+    const classDescriptor = this.readClassDesc();
+    if (!classDescriptor) throw new Error("Array must have a class descriptor");
+
+    const value: unknown[] = [];
+    Object.defineProperty(value, JAVA_CLASS_META, { value: classDescriptor, configurable: true });
+    this.addHandle(value);
+
+    const length = this.readInt32();
+    const reader = this.primitiveReader(classDescriptor.name.charAt(1));
+    for (let index = 0; index < length; index += 1) {
+      value.push(reader());
+    }
+    return value;
+  }
+
+  private readEnum(): unknown {
+    const classDescriptor = this.readClassDesc();
+    if (!classDescriptor) throw new Error("Enum must have a class descriptor");
+
+    const assignHandle = this.reserveHandle();
+    const constant = this.readContent();
+    const value = new String(typeof constant === "string" ? constant : String(constant ?? ""));
+    Object.defineProperty(value, JAVA_CLASS_META, { value: classDescriptor, configurable: true });
+    assignHandle(value);
+    return value;
+  }
+
+  private readAnnotations(): unknown[] {
+    const annotations: unknown[] = [];
+    while (true) {
+      const value = this.readContent();
+      if (value === END_BLOCK) return annotations;
+      annotations.push(value);
+    }
+  }
+
+  private readFieldValues(classDescriptor: JavaClassDescriptor): Record<string, unknown> {
+    const values: Record<string, unknown> = {};
+    for (const field of classDescriptor.fields) {
+      values[field.name] = this.primitiveReader(field.type)();
+    }
+    return values;
+  }
+
+  private primitiveReader(type: string): () => unknown {
+    switch (type) {
+      case "B":
+        return () => this.readInt8();
+      case "C":
+        return () => String.fromCharCode(this.readUint16());
+      case "D":
+        return () => this.readFloat64();
+      case "F":
+        return () => this.readFloat32();
+      case "I":
+        return () => this.readInt32();
+      case "J":
+        return () => this.readInt64();
+      case "S":
+        return () => this.readInt16();
+      case "Z":
+        return () => this.readInt8() !== 0;
+      case "L":
+      case "[":
+        return () => this.readContent();
+      default:
+        throw new Error(`Don't know how to read field of type '${type}'`);
+    }
+  }
+
+  private addHandle<T>(value: T): T {
+    this.handles.set(this.nextHandle, value);
+    this.nextHandle += 1;
+    return value;
+  }
+
+  private reserveHandle(): (value: unknown) => void {
+    const handle = this.nextHandle;
+    this.nextHandle += 1;
+    this.handles.set(handle, null);
+    return (value: unknown) => {
+      this.handles.set(handle, value);
+    };
+  }
+
+  private readReference(): unknown {
+    const handle = this.readInt32();
+    if (!this.handles.has(handle)) throw new Error(`Unknown reference handle 0x${handle.toString(16)}`);
+    return this.handles.get(handle);
+  }
+
+  private readUint8(): number {
+    const position = this.step(1);
+    return this.view.getUint8(position);
+  }
+
+  private readInt8(): number {
+    const position = this.step(1);
+    return this.view.getInt8(position);
+  }
+
+  private readUint16(): number {
+    const position = this.step(2);
+    return this.view.getUint16(position, false);
+  }
+
+  private readInt16(): number {
+    const position = this.step(2);
+    return this.view.getInt16(position, false);
+  }
+
+  private readUint32(): number {
+    const position = this.step(4);
+    return this.view.getUint32(position, false);
+  }
+
+  private readInt32(): number {
+    const position = this.step(4);
+    return this.view.getInt32(position, false);
+  }
+
+  private readInt64(): bigint {
+    const high = this.readUint32();
+    const low = this.readUint32();
+    let value = (BigInt(high) << 32n) | BigInt(low);
+    if (high & 0x80000000) {
+      value -= 1n << 64n;
+    }
+    return value;
+  }
+
+  private readFloat32(): number {
+    const position = this.step(4);
+    return this.view.getFloat32(position, false);
+  }
+
+  private readFloat64(): number {
+    const position = this.step(8);
+    return this.view.getFloat64(position, false);
+  }
+
+  private readUtf(): string {
+    return decodeModifiedUtf8(this.readBytes(this.readUint16()));
+  }
+
+  private readUtfLong(): string {
+    const high = this.readUint32();
+    if (high !== 0) throw new Error("Can't handle more than 2^32 bytes in a string");
+    return decodeModifiedUtf8(this.readBytes(this.readUint32()));
+  }
+
+  private readBytes(length: number): Uint8Array {
+    const position = this.step(length);
+    return this.bytes.slice(position, position + length);
+  }
+
+  private step(length: number): number {
+    const position = this.position;
+    this.position += length;
+    if (this.position > this.bytes.length) {
+      throw new Error("Premature end of input");
+    }
+    return position;
+  }
+}
+
+function normalizeJavaSerializedValue(value: unknown, seen: WeakMap<object, string>, state: { nextId: number }): unknown {
+  if (value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (value instanceof Uint8Array) {
+    return { $blockDataHex: bytesToHex(value) };
+  }
+  if (value instanceof String) {
+    const classDescriptor = getJavaClassDescriptor(value);
+    if (!classDescriptor) return value.toString();
+    return {
+      $class: classDescriptor.name,
+      $enum: value.toString(),
+    };
+  }
+  if (typeof value !== "object") {
+    return String(value);
+  }
+  if (seen.has(value)) {
+    return { $ref: seen.get(value) };
+  }
+
+  const objectId = `#${state.nextId}`;
+  state.nextId += 1;
+  seen.set(value, objectId);
+
+  const classDescriptor = getJavaClassDescriptor(value);
+  const extendsValues = getJavaExtendsValues(value);
+
+  if (value instanceof Map) {
+    return {
+      $id: objectId,
+      ...(classDescriptor ? { $class: classDescriptor.name } : {}),
+      $entries: Array.from(value.entries(), ([key, entryValue]) => ({
+        key: normalizeJavaSerializedValue(key, seen, state),
+        value: normalizeJavaSerializedValue(entryValue, seen, state),
+      })),
+    };
+  }
+
+  if (value instanceof Set) {
+    return {
+      $id: objectId,
+      ...(classDescriptor ? { $class: classDescriptor.name } : {}),
+      $values: Array.from(value.values(), (entryValue) => normalizeJavaSerializedValue(entryValue, seen, state)),
+    };
+  }
+
+  if (Array.isArray(value)) {
+    const normalized = {
+      $id: objectId,
+      ...(classDescriptor ? { $class: classDescriptor.name } : {}),
+      $values: value.map((entryValue) => normalizeJavaSerializedValue(entryValue, seen, state)),
+    };
+    return normalized;
+  }
+
+  const normalized: Record<string, unknown> = {
+    $id: objectId,
+    ...(classDescriptor ? { $class: classDescriptor.name } : {}),
+  };
+
+  for (const [name, entryValue] of Object.entries(value as Record<string, unknown>)) {
+    normalized[name] = normalizeJavaSerializedValue(entryValue, seen, state);
+  }
+
+  if (extendsValues) {
+    const classNames = Object.keys(extendsValues);
+    if (classNames.length > 1) {
+      normalized.$extends = Object.fromEntries(classNames.map((className) => [className, Object.fromEntries(Object.entries(extendsValues[className]).map(([name, entryValue]) => [name, normalizeJavaSerializedValue(entryValue, seen, state)]))]));
+    }
+  }
+
+  return normalized;
+}
+
+function getJavaClassDescriptor(value: object): JavaClassDescriptor | undefined {
+  return (value as { [JAVA_CLASS_META]?: JavaClassDescriptor })[JAVA_CLASS_META];
+}
+
+function getJavaExtendsValues(value: object): Record<string, Record<string, unknown>> | undefined {
+  return (value as { [JAVA_EXTENDS_META]?: Record<string, Record<string, unknown>> })[JAVA_EXTENDS_META];
+}
+
+function mapPostProcessor(fields: Record<string, unknown>, annotations: unknown[]): Record<string, unknown> {
+  const header = annotations[0];
+  if (!(header instanceof Uint8Array)) return fields;
+
+  const size = readInt32FromBytes(header, 4);
+  const map = new Map<unknown, unknown>();
+  const obj: Record<string, unknown> = {};
+  for (let index = 0; index < size; index += 1) {
+    const key = annotations[2 * index + 1];
+    const value = annotations[2 * index + 2];
+    map.set(key, value);
+    if (typeof key === "string") {
+      obj[key] = value;
+    }
+  }
+  return { ...fields, map, obj };
+}
+
+function enumMapPostProcessor(fields: Record<string, unknown>, annotations: unknown[]): Record<string, unknown> {
+  const header = annotations[0];
+  if (!(header instanceof Uint8Array)) return fields;
+
+  const size = readInt32FromBytes(header, 0);
+  const map = new Map<unknown, unknown>();
+  const obj: Record<string, unknown> = {};
+  for (let index = 0; index < size; index += 1) {
+    const key = annotations[2 * index + 1];
+    const value = annotations[2 * index + 2];
+    map.set(key, value);
+    obj[String(key)] = value;
+  }
+  return { ...fields, map, obj };
+}
+
+function hashSetPostProcessor(fields: Record<string, unknown>, annotations: unknown[]): Record<string, unknown> {
+  const header = annotations[0];
+  if (!(header instanceof Uint8Array)) return fields;
+
+  const size = readInt32FromBytes(header, 8);
+  const values = annotations.slice(1);
+  if (values.length !== size) return fields;
+  return { ...fields, set: new Set(values) };
+}
+
+function readInt32FromBytes(bytes: Uint8Array, offset: number): number {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return view.getInt32(offset, false);
+}
+
+function decodeModifiedUtf8(bytes: Uint8Array): string {
+  let output = "";
+  for (let index = 0; index < bytes.length; ) {
+    const byte = bytes[index];
+    if ((byte & 0x80) === 0) {
+      output += String.fromCharCode(byte);
+      index += 1;
+      continue;
+    }
+    if ((byte & 0xe0) === 0xc0) {
+      const next = bytes[index + 1];
+      if (next == null) throw new Error("Invalid modified UTF-8 sequence");
+      output += String.fromCharCode(((byte & 0x1f) << 6) | (next & 0x3f));
+      index += 2;
+      continue;
+    }
+    if ((byte & 0xf0) === 0xe0) {
+      const next = bytes[index + 1];
+      const third = bytes[index + 2];
+      if (next == null || third == null) throw new Error("Invalid modified UTF-8 sequence");
+      output += String.fromCharCode(((byte & 0x0f) << 12) | ((next & 0x3f) << 6) | (third & 0x3f));
+      index += 3;
+      continue;
+    }
+    throw new Error("Invalid modified UTF-8 sequence");
+  }
+  return output;
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
diff --git a/apps/desktop/src/lib/redis/redisAutoRefresh.ts b/apps/desktop/src/lib/redis/redisAutoRefresh.ts
new file mode 100644
index 0000000..ae8eff9
--- /dev/null
+++ b/apps/desktop/src/lib/redis/redisAutoRefresh.ts
@@ -0,0 +1,43 @@
+/**
+ * Pure decision functions for Redis key auto-refresh countdown.
+ *
+ * Extracted from RedisValueViewer.vue to enable unit testing of the
+ * state-machine logic without mounting a Vue component.
+ */
+
+/** Action computed after evaluating one auto-refresh tick. */
+export type AutoRefreshTickAction = { type: "idle" } | { type: "decrement" } | { type: "refresh" };
+
+/**
+ * Evaluate one tick of the auto-refresh interval.
+ *
+ * @param enabled  Whether auto-refresh is currently toggled on.
+ * @param countdownTtl  Current countdown value in seconds.
+ * @param isLoading  Whether a data load is already in flight.
+ * @returns The action the caller should take this tick.
+ */
+export function computeAutoRefreshTick(enabled: boolean, countdownTtl: number, isLoading: boolean): AutoRefreshTickAction {
+  if (!enabled) return { type: "idle" };
+  if (isLoading) return countdownTtl > 0 ? { type: "decrement" } : { type: "idle" };
+  return countdownTtl <= 1 ? { type: "refresh" } : { type: "decrement" };
+}
+
+/**
+ * Determine whether auto-refresh should be automatically disabled
+ * after a server load completes (e.g. key expired or deleted).
+ *
+ * @param ttl  The TTL value returned by the server (seconds, -1 = no expiry).
+ */
+export function shouldStopAutoRefresh(ttl: number): boolean {
+  return ttl <= 0;
+}
+
+/**
+ * Compute the TTL value that should be displayed in the badge.
+ *
+ * When auto-refresh is active, the live countdown value is shown. The
+ * last known server TTL must not reappear after the countdown reaches zero.
+ */
+export function computeDisplayTtl(autoRefreshEnabled: boolean, countdownTtl: number, serverTtl: number): number {
+  return autoRefreshEnabled ? Math.max(countdownTtl, 0) : serverTtl;
+}
diff --git a/apps/desktop/src/lib/redis/redisCommandSafety.ts b/apps/desktop/src/lib/redis/redisCommandSafety.ts
new file mode 100644
index 0000000..88222e3
--- /dev/null
+++ b/apps/desktop/src/lib/redis/redisCommandSafety.ts
@@ -0,0 +1,123 @@
+export type RedisCommandSafety = "allowed" | "write" | "confirm" | "blocked";
+
+const BLOCKED_COMMANDS = new Set(["KEYS", "FLUSHALL", "SHUTDOWN", "CONFIG", "SAVE", "BGSAVE", "SLAVEOF", "REPLICAOF", "MIGRATE", "MODULE", "SCRIPT", "EVAL", "EVALSHA"]);
+
+const CONFIRM_COMMANDS = new Set([
+  "DEL",
+  "UNLINK",
+  "EXPIRE",
+  "EXPIREAT",
+  "PEXPIRE",
+  "PEXPIREAT",
+  "RENAME",
+  "RENAMENX",
+  "GETDEL",
+  "HDEL",
+  "LPOP",
+  "RPOP",
+  "LREM",
+  "LTRIM",
+  "SPOP",
+  "SREM",
+  "ZREM",
+  "ZPOPMAX",
+  "ZPOPMIN",
+  "ZMPOP",
+  "ZREMRANGEBYLEX",
+  "ZREMRANGEBYRANK",
+  "ZREMRANGEBYSCORE",
+  "XDEL",
+  "XTRIM",
+  "MOVE",
+  "SORT",
+  "SDIFFSTORE",
+  "SINTERSTORE",
+  "SUNIONSTORE",
+  "ZDIFFSTORE",
+  "ZINTERSTORE",
+  "ZRANGESTORE",
+  "ZUNIONSTORE",
+  "PFMERGE",
+  "GEOSEARCHSTORE",
+  "FLUSHDB",
+]);
+
+const WRITE_COMMANDS = new Set([
+  "APPEND",
+  "BITFIELD",
+  "BITOP",
+  "COPY",
+  "DECR",
+  "DECRBY",
+  "GEOADD",
+  "GEORADIUS",
+  "GEORADIUSBYMEMBER",
+  "GETSET",
+  "INCR",
+  "INCRBY",
+  "INCRBYFLOAT",
+  "SET",
+  "SETEX",
+  "PSETEX",
+  "SETNX",
+  "SETRANGE",
+  "MSET",
+  "MSETNX",
+  "PERSIST",
+  "HSET",
+  "HMSET",
+  "HINCRBY",
+  "HINCRBYFLOAT",
+  "HSETNX",
+  "LINSERT",
+  "LSET",
+  "LMOVE",
+  "LPUSH",
+  "LPUSHX",
+  "PFADD",
+  "RPUSH",
+  "RPUSHX",
+  "RESTORE",
+  "SADD",
+  "ZADD",
+  "ZINCRBY",
+  "SETBIT",
+  "XADD",
+  "XACK",
+  "XAUTOCLAIM",
+  "XCLAIM",
+  "XSETID",
+]);
+
+export function firstRedisCommandToken(command: string): string {
+  const trimmed = command.trimStart();
+  if (!trimmed) return "";
+
+  const quote = trimmed[0] === '"' || trimmed[0] === "'" ? trimmed[0] : "";
+  let token = "";
+  let escaping = false;
+  for (let i = quote ? 1 : 0; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (escaping) {
+      token += ch;
+      escaping = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaping = true;
+      continue;
+    }
+    if (quote && ch === quote) break;
+    if (!quote && /\s/.test(ch)) break;
+    token += ch;
+  }
+  return token.toUpperCase();
+}
+
+export function classifyRedisCommandSafety(command: string): RedisCommandSafety {
+  const token = firstRedisCommandToken(command);
+  if (BLOCKED_COMMANDS.has(token)) return "blocked";
+  if (CONFIRM_COMMANDS.has(token)) return "confirm";
+  if (WRITE_COMMANDS.has(token)) return "write";
+  return "allowed";
+}
diff --git a/apps/desktop/src/lib/redis/redisCommandSession.ts b/apps/desktop/src/lib/redis/redisCommandSession.ts
new file mode 100644
index 0000000..5d15f38
--- /dev/null
+++ b/apps/desktop/src/lib/redis/redisCommandSession.ts
@@ -0,0 +1,22 @@
+export function nextRedisCommandDb(currentDb: number, command: string, result: unknown): number {
+  if (result !== "OK") return currentDb;
+
+  const match = command.trim().match(/^SELECT\s+(\d+)\s*;?$/i);
+  if (!match) return currentDb;
+
+  const nextDb = Number.parseInt(match[1], 10);
+  return Number.isFinite(nextDb) ? nextDb : currentDb;
+}
+
+export function isRedisClearScreenCommand(command: string): boolean {
+  return /^(clear|cls)\s*;?$/i.test(command.trim());
+}
+
+export function redisKeyTextToRaw(key: string): string {
+  const bytes = new TextEncoder().encode(key);
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
diff --git a/apps/desktop/src/lib/redis/redisCommandTable.ts b/apps/desktop/src/lib/redis/redisCommandTable.ts
new file mode 100644
index 0000000..4fb2f18
--- /dev/null
+++ b/apps/desktop/src/lib/redis/redisCommandTable.ts
@@ -0,0 +1,522 @@
+/**
+ * Static Redis command metadata, distilled from the official Redis command table
+ * (redis-doc `commands.json` / the `COMMAND` output). Kept offline and lightweight:
+ * we only retain what the editor syntax diagnostics need — `arity` and `group` —
+ * plus a `safety` hint for command gating and write-command highlighting.
+ *
+ * Arity semantics (matches the Redis `COMMAND` reply, command name INCLUDED in the count):
+ *   arity > 0  → the command takes exactly `arity` tokens (e.g. GET key → arity 2).
+ *   arity < 0  → the command takes AT LEAST `-arity` tokens (e.g. MSET k v [k v ...] → arity -3).
+ *
+ * `safety` is aligned with the token-level sets in `redisCommandSafety.ts` (used to gate
+ * execution). `write` commands mutate data without a confirmation prompt; `confirm`
+ * commands are destructive/structural enough to ask first. Here it is recorded
+ * per-command (including subcommands) so diagnostics can be more precise than the
+ * first-token classification.
+ *
+ * Subcommands are keyed as `"MAIN SUB"` in UPPER CASE (e.g. `"CONFIG GET"`, `"XGROUP CREATE"`).
+ */
+import type { RedisCommandSafety } from "@/lib/redis/redisCommandSafety";
+
+export interface RedisCommandSpec {
+  /** Token count including the command name. Positive = exact, negative = minimum (-N). */
+  arity: number;
+  /** Redis command group: string/list/hash/.../server. */
+  group: string;
+  /** Danger level for diagnostic highlighting. */
+  safety: RedisCommandSafety;
+}
+
+type Spec = [arity: number, group: string, safety?: RedisCommandSafety];
+
+const WRITE_WITHOUT_CONFIRM = new Set([
+  "APPEND",
+  "BITFIELD",
+  "BITOP",
+  "CLIENT SETINFO",
+  "CLIENT SETNAME",
+  "COPY",
+  "DECR",
+  "DECRBY",
+  "GEOADD",
+  "GEORADIUS",
+  "GEORADIUSBYMEMBER",
+  "GETSET",
+  "HINCRBY",
+  "HINCRBYFLOAT",
+  "HMSET",
+  "HSET",
+  "HSETNX",
+  "INCR",
+  "INCRBY",
+  "INCRBYFLOAT",
+  "LINSERT",
+  "LMOVE",
+  "LPUSH",
+  "LPUSHX",
+  "MSET",
+  "MSETNX",
+  "PERSIST",
+  "PFADD",
+  "PSETEX",
+  "RESTORE",
+  "RPUSH",
+  "RPUSHX",
+  "SADD",
+  "SET",
+  "SETBIT",
+  "SETEX",
+  "SETNX",
+  "SETRANGE",
+  "XACK",
+  "XADD",
+  "XAUTOCLAIM",
+  "XCLAIM",
+  "XGROUP CREATE",
+  "XGROUP CREATECONSUMER",
+  "XGROUP SETID",
+  "XSETID",
+  "ZADD",
+  "ZINCRBY",
+]);
+
+// Compact tuple form → expanded into the record below.
+const RAW_COMMANDS: Record<string, Spec> = {
+  // ---- String ----
+  APPEND: [3, "string", "confirm"],
+  DECR: [2, "string", "confirm"],
+  DECRBY: [3, "string", "confirm"],
+  GET: [2, "string"],
+  GETDEL: [2, "string", "confirm"],
+  GETEX: [-2, "string"],
+  GETRANGE: [4, "string"],
+  GETSET: [3, "string", "confirm"],
+  INCR: [2, "string", "confirm"],
+  INCRBY: [3, "string", "confirm"],
+  INCRBYFLOAT: [3, "string", "confirm"],
+  LCS: [-3, "string"],
+  MGET: [-2, "string"],
+  MSET: [-3, "string", "confirm"],
+  MSETNX: [-3, "string", "confirm"],
+  PSETEX: [4, "string", "confirm"],
+  SET: [-3, "string", "confirm"],
+  SETEX: [4, "string", "confirm"],
+  SETNX: [3, "string", "confirm"],
+  SETRANGE: [4, "string", "confirm"],
+  STRLEN: [2, "string"],
+
+  // ---- Generic key ----
+  COPY: [-3, "generic", "confirm"],
+  DEL: [-2, "generic", "confirm"],
+  DUMP: [2, "generic"],
+  EXISTS: [-2, "generic"],
+  EXPIRE: [-3, "generic", "confirm"],
+  EXPIREAT: [-3, "generic", "confirm"],
+  KEYS: [2, "generic", "blocked"],
+  MIGRATE: [-6, "generic", "blocked"],
+  MOVE: [3, "generic", "confirm"],
+  OBJECT_ENCODING: [3, "generic"],
+  OBJECT_FREQ: [3, "generic"],
+  OBJECT_IDLETIME: [3, "generic"],
+  OBJECT_REFCOUNT: [3, "generic"],
+  OBJECT_HELP: [2, "generic"],
+  PERSIST: [2, "generic", "confirm"],
+  PEXPIRE: [-3, "generic", "confirm"],
+  PEXPIREAT: [-3, "generic", "confirm"],
+  PTTL: [2, "generic"],
+  RANDOMKEY: [1, "generic"],
+  RENAME: [3, "generic", "confirm"],
+  RENAMENX: [3, "generic", "confirm"],
+  RESTORE: [-4, "generic", "confirm"],
+  SCAN: [-2, "generic"],
+  SORT: [-2, "generic", "confirm"],
+  SORT_RO: [-2, "generic"],
+  TOUCH: [-2, "generic"],
+  TTL: [2, "generic"],
+  TYPE: [2, "generic"],
+  UNLINK: [-2, "generic", "confirm"],
+  WAIT: [3, "generic"],
+  WAITAOF: [4, "generic"],
+
+  // ---- List ----
+  BLMOVE: [6, "list"],
+  BLMPOP: [-4, "list"],
+  BLPOP: [-3, "list"],
+  BRPOP: [-3, "list"],
+  BRPOPLPUSH: [4, "list"],
+  LINDEX: [3, "list"],
+  LINSERT: [5, "list", "confirm"],
+  LLEN: [2, "list"],
+  LMOVE: [5, "list", "confirm"],
+  LMPOP: [-4, "list", "confirm"],
+  LPOP: [-2, "list", "confirm"],
+  LPOS: [-2, "list"],
+  LPUSH: [-3, "list", "confirm"],
+  LPUSHX: [-3, "list", "confirm"],
+  LRANGE: [4, "list"],
+  LREM: [4, "list", "confirm"],
+  LSET: [4, "list", "confirm"],
+  LTRIM: [4, "list", "confirm"],
+  RPOP: [-2, "list", "confirm"],
+  RPOPLPUSH: [4, "list", "confirm"],
+  RPUSH: [-3, "list", "confirm"],
+  RPUSHX: [-3, "list", "confirm"],
+
+  // ---- Hash ----
+  HDEL: [-3, "hash", "confirm"],
+  HEXISTS: [3, "hash"],
+  HGET: [3, "hash"],
+  HGETALL: [2, "hash"],
+  HINCRBY: [4, "hash", "confirm"],
+  HINCRBYFLOAT: [4, "hash", "confirm"],
+  HKEYS: [2, "hash"],
+  HLEN: [2, "hash"],
+  HMGET: [-3, "hash"],
+  HMSET: [-4, "hash", "confirm"],
+  HRANDFIELD: [-2, "hash"],
+  HSCAN: [-3, "hash"],
+  HSET: [-4, "hash", "confirm"],
+  HSETNX: [4, "hash", "confirm"],
+  HSTRLEN: [3, "hash"],
+  HVALS: [2, "hash"],
+
+  // ---- Set ----
+  SADD: [-3, "set", "confirm"],
+  SCARD: [2, "set"],
+  SDIFF: [-2, "set"],
+  SDIFFSTORE: [-3, "set", "confirm"],
+  SINTER: [-2, "set"],
+  SINTERCARD: [-3, "set"],
+  SINTERSTORE: [-3, "set", "confirm"],
+  SISMEMBER: [3, "set"],
+  SMEMBERS: [2, "set"],
+  SMISMEMBER: [-3, "set"],
+  SMOVE: [4, "set", "confirm"],
+  SPOP: [-2, "set", "confirm"],
+  SRANDMEMBER: [-2, "set"],
+  SREM: [-3, "set", "confirm"],
+  SSCAN: [-3, "set"],
+  SUNION: [-2, "set"],
+  SUNIONSTORE: [-3, "set", "confirm"],
+
+  // ---- Sorted set ----
+  BZMPOP: [-3, "zset"],
+  BZPOPMAX: [-3, "zset"],
+  BZPOPMIN: [-3, "zset"],
+  ZADD: [-4, "zset", "confirm"],
+  ZCARD: [2, "zset"],
+  ZCOUNT: [4, "zset"],
+  ZDIFF: [-3, "zset"],
+  ZDIFFSTORE: [-4, "zset", "confirm"],
+  ZINCRBY: [4, "zset", "confirm"],
+  ZINTER: [-3, "zset"],
+  ZINTERCARD: [-3, "zset"],
+  ZINTERSTORE: [-4, "zset", "confirm"],
+  ZLEXCOUNT: [4, "zset"],
+  ZMPOP: [-3, "zset", "confirm"],
+  ZMSCORE: [-3, "zset"],
+  ZPOPMAX: [-2, "zset", "confirm"],
+  ZPOPMIN: [-2, "zset", "confirm"],
+  ZRANDMEMBER: [-2, "zset"],
+  ZRANGE: [-4, "zset"],
+  ZRANGEBYLEX: [-4, "zset"],
+  ZRANGEBYSCORE: [-4, "zset"],
+  ZRANGESTORE: [-5, "zset", "confirm"],
+  ZRANK: [-3, "zset"],
+  ZREM: [-3, "zset", "confirm"],
+  ZREMRANGEBYLEX: [4, "zset", "confirm"],
+  ZREMRANGEBYRANK: [4, "zset", "confirm"],
+  ZREMRANGEBYSCORE: [4, "zset", "confirm"],
+  ZREVRANGE: [-4, "zset"],
+  ZREVRANGEBYLEX: [-4, "zset"],
+  ZREVRANGEBYSCORE: [-4, "zset"],
+  ZREVRANK: [-3, "zset"],
+  ZSCAN: [-3, "zset"],
+  ZSCORE: [3, "zset"],
+  ZUNION: [-3, "zset"],
+  ZUNIONSTORE: [-4, "zset", "confirm"],
+
+  // ---- Bitmap ----
+  BITCOUNT: [-2, "bitmap"],
+  BITFIELD: [-2, "bitmap", "confirm"],
+  BITFIELD_RO: [-2, "bitmap"],
+  BITOP: [-4, "bitmap", "confirm"],
+  BITPOS: [-3, "bitmap"],
+  GETBIT: [3, "bitmap"],
+  SETBIT: [4, "bitmap", "confirm"],
+
+  // ---- Hyperloglog ----
+  PFADD: [-2, "hyperloglog", "confirm"],
+  PFCOUNT: [-2, "hyperloglog"],
+  PFMERGE: [-2, "hyperloglog", "confirm"],
+
+  // ---- Geo ----
+  GEOADD: [-5, "geo", "confirm"],
+  GEODIST: [-4, "geo"],
+  GEOHASH: [-3, "geo"],
+  GEOPOS: [-3, "geo"],
+  GEORADIUS: [-6, "geo", "confirm"],
+  GEORADIUS_RO: [-6, "geo"],
+  GEORADIUSBYMEMBER: [-5, "geo", "confirm"],
+  GEORADIUSBYMEMBER_RO: [-5, "geo"],
+  GEOSEARCH: [-7, "geo"],
+  GEOSEARCHSTORE: [-8, "geo", "confirm"],
+
+  // ---- Stream ----
+  XACK: [-4, "stream", "confirm"],
+  XADD: [-5, "stream", "confirm"],
+  XAUTOCLAIM: [-7, "stream", "confirm"],
+  XCLAIM: [-6, "stream", "confirm"],
+  XDEL: [-3, "stream", "confirm"],
+  "XGROUP CREATE": [-6, "stream", "confirm"],
+  "XGROUP CREATECONSUMER": [5, "stream", "confirm"],
+  "XGROUP DELCONSUMER": [4, "stream", "confirm"],
+  "XGROUP DESTROY": [4, "stream", "confirm"],
+  "XGROUP HELP": [2, "stream"],
+  "XGROUP SETID": [-5, "stream", "confirm"],
+  "XINFO CONSUMERS": [4, "stream"],
+  "XINFO GROUPS": [3, "stream"],
+  "XINFO HELP": [2, "stream"],
+  "XINFO STREAM": [-3, "stream"],
+  XLEN: [2, "stream"],
+  XPENDING: [-3, "stream"],
+  XRANGE: [-4, "stream"],
+  XREAD: [-4, "stream"],
+  XREADGROUP: [-7, "stream"],
+  XREVRANGE: [-4, "stream"],
+  XSETID: [-3, "stream", "confirm"],
+  XTRIM: [-4, "stream", "confirm"],
+
+  // ---- Pub/Sub ----
+  PSUBSCRIBE: [-2, "pubsub"],
+  PUBLISH: [3, "pubsub"],
+  "PUBSUB CHANNELS": [-2, "pubsub"],
+  "PUBSUB NUMPAT": [1, "pubsub"],
+  "PUBSUB NUMSUB": [-2, "pubsub"],
+  "PUBSUB SHARDCHANNELS": [-2, "pubsub"],
+  "PUBSUB SHARDNUMSUB": [-2, "pubsub"],
+  PUNSUBSCRIBE: [-1, "pubsub"],
+  SPUBLISH: [3, "pubsub"],
+  SSUBSCRIBE: [2, "pubsub"],
+  SUBSCRIBE: [-2, "pubsub"],
+  SUNSUBSCRIBE: [-1, "pubsub"],
+  UNSUBSCRIBE: [-1, "pubsub"],
+
+  // ---- Transactions ----
+  DISCARD: [1, "transactions"],
+  EXEC: [1, "transactions"],
+  MULTI: [1, "transactions"],
+  UNWATCH: [1, "transactions"],
+  WATCH: [-2, "transactions"],
+
+  // ---- Scripting ----
+  EVAL: [-3, "scripting", "blocked"],
+  EVALSHA: [-3, "scripting", "blocked"],
+  EVAL_RO: [-3, "scripting", "blocked"],
+  EVALSHA_RO: [-3, "scripting", "blocked"],
+  FCALL: [-3, "scripting"],
+  FCALL_RO: [-3, "scripting"],
+  "FUNCTION DELETE": [3, "scripting", "confirm"],
+  "FUNCTION DUMP": [2, "scripting"],
+  "FUNCTION FLUSH": [-2, "scripting", "confirm"],
+  "FUNCTION LIST": [-2, "scripting"],
+  "FUNCTION LOAD": [-3, "scripting", "confirm"],
+  "FUNCTION RESTORE": [-4, "scripting", "confirm"],
+  "FUNCTION STATS": [1, "scripting"],
+  "SCRIPT EXISTS": [-2, "scripting", "blocked"],
+  "SCRIPT FLUSH": [-2, "scripting", "blocked"],
+  "SCRIPT KILL": [1, "scripting", "blocked"],
+  "SCRIPT LOAD": [2, "scripting", "blocked"],
+
+  // ---- Connection ----
+  AUTH: [-2, "connection"],
+  ECHO: [2, "connection"],
+  HELLO: [-1, "connection"],
+  PING: [-1, "connection"],
+  QUIT: [1, "connection"],
+  RESET: [1, "connection"],
+  SELECT: [2, "connection"],
+  "CLIENT CACHING": [3, "connection"],
+  "CLIENT GETNAME": [1, "connection"],
+  "CLIENT GETREDIR": [1, "connection"],
+  "CLIENT ID": [1, "connection"],
+  "CLIENT INFO": [1, "connection"],
+  "CLIENT KILL": [-3, "connection", "confirm"],
+  "CLIENT LIST": [-2, "connection"],
+  "CLIENT NO-EVICT": [2, "connection"],
+  "CLIENT NO-TOUCH": [2, "connection"],
+  "CLIENT PAUSE": [-2, "connection"],
+  "CLIENT REPLY": [2, "connection"],
+  "CLIENT SETINFO": [-3, "connection"],
+  "CLIENT SETNAME": [3, "connection"],
+  "CLIENT TRACKING": [-3, "connection"],
+  "CLIENT TRACKINGINFO": [1, "connection"],
+  "CLIENT UNPAUSE": [1, "connection"],
+
+  // ---- Server ----
+  BGREWRITEAOF: [1, "server"],
+  BGSAVE: [-1, "server", "blocked"],
+  "COMMAND COUNT": [1, "server"],
+  "COMMAND DOCS": [-2, "server"],
+  "COMMAND GETKEYS": [-3, "server"],
+  "COMMAND INFO": [-2, "server"],
+  "COMMAND LIST": [-2, "server"],
+  "CONFIG GET": [-2, "server", "blocked"],
+  "CONFIG RESETSTAT": [1, "server", "blocked"],
+  "CONFIG REWRITE": [1, "server", "blocked"],
+  "CONFIG SET": [-3, "server", "blocked"],
+  DBSIZE: [1, "server"],
+  FAILOVER: [-1, "server", "confirm"],
+  FLUSHALL: [-1, "server", "blocked"],
+  FLUSHDB: [-1, "server", "confirm"],
+  INFO: [-1, "server"],
+  LASTSAVE: [1, "server"],
+  "MEMORY USAGE": [-3, "server"],
+  "MEMORY STATS": [1, "server"],
+  "MEMORY PURGE": [1, "server"],
+  "MEMORY DOCS": [1, "server"],
+  "MODULE LIST": [1, "server", "blocked"],
+  "MODULE LOAD": [-3, "server", "blocked"],
+  "MODULE LOADEX": [-3, "server", "blocked"],
+  "MODULE UNLOAD": [3, "server", "blocked"],
+  MONITOR: [1, "server"],
+  REPLICAOF: [3, "server", "blocked"],
+  ROLE: [1, "server"],
+  SAVE: [1, "server", "blocked"],
+  SHUTDOWN: [-1, "server", "blocked"],
+  SLAVEOF: [3, "server", "blocked"],
+  "SLOWLOG GET": [-2, "server"],
+  "SLOWLOG LEN": [1, "server"],
+  "SLOWLOG RESET": [1, "server"],
+  "SLOWLOG HELP": [1, "server"],
+  SWAPDB: [3, "server", "confirm"],
+  SYNC: [1, "server"],
+  TIME: [1, "server"],
+
+  // ---- Cluster ----
+  "CLUSTER ADDSLOTS": [-3, "cluster", "confirm"],
+  "CLUSTER COUNT-FAILURE-REPORTS": [2, "cluster"],
+  "CLUSTER COUNTKEYSINSLOT": [3, "cluster"],
+  "CLUSTER DELSLOTS": [-3, "cluster", "confirm"],
+  "CLUSTER FAILOVER": [-2, "cluster", "confirm"],
+  "CLUSTER FLUSHSLOTS": [1, "cluster", "confirm"],
+  "CLUSTER FORGET": [2, "cluster", "confirm"],
+  "CLUSTER GETKEYSINSLOT": [4, "cluster"],
+  "CLUSTER INFO": [1, "cluster"],
+  "CLUSTER KEYSLOT": [2, "cluster"],
+  "CLUSTER LINKS": [1, "cluster"],
+  "CLUSTER MEET": [-4, "cluster", "confirm"],
+  "CLUSTER MYID": [1, "cluster"],
+  "CLUSTER NODES": [1, "cluster"],
+  "CLUSTER REPLICAS": [2, "cluster"],
+  "CLUSTER REPLICATE": [2, "cluster", "confirm"],
+  "CLUSTER RESET": [-2, "cluster", "confirm"],
+  "CLUSTER SAVECONFIG": [1, "cluster", "confirm"],
+  "CLUSTER SET-CONFIG-EPOCH": [2, "cluster", "confirm"],
+  "CLUSTER SETSLOT": [-4, "cluster", "confirm"],
+  "CLUSTER SHARDS": [1, "cluster"],
+  "CLUSTER SLAVES": [2, "cluster"],
+  "CLUSTER SLOTS": [1, "cluster"],
+  READONLY: [1, "cluster"],
+  READWRITE: [1, "cluster"],
+};
+
+function commandTableSafety(name: string, safety?: RedisCommandSafety): RedisCommandSafety {
+  if (safety === "confirm" && WRITE_WITHOUT_CONFIRM.has(name.toUpperCase())) return "write";
+  return safety ?? "allowed";
+}
+
+export const REDIS_COMMAND_TABLE: Record<string, RedisCommandSpec> = Object.fromEntries(Object.entries(RAW_COMMANDS).map(([name, [arity, group, safety]]) => [name.toUpperCase(), { arity, group, safety: commandTableSafety(name, safety) }]));
+
+/**
+ * Resolve a command spec. Handles two-token subcommands (e.g. `XGROUP CREATE`,
+ * `CONFIG GET`) by trying `MAIN SUB` first, then falling back to the main token.
+ */
+export function resolveRedisCommandSpec(argvUpper: readonly string[]): RedisCommandSpec | undefined {
+  if (argvUpper.length === 0) return undefined;
+  const main = argvUpper[0];
+  if (argvUpper.length >= 2) {
+    const sub = `${main} ${argvUpper[1]}`;
+    const subSpec = REDIS_COMMAND_TABLE[sub];
+    if (subSpec) return subSpec;
+  }
+  return REDIS_COMMAND_TABLE[main];
+}
+
+/**
+ * Minimal argv tokenizer for the first two tokens of a Redis command line —
+ * enough to resolve a spec (which only needs the command head, optionally a
+ * subcommand). Single-quoted, double-quoted and unquoted tokens are supported
+ * with backslash escapes; quoting errors are tolerated (the token still resolves).
+ * Kept local so this module stays self-contained (no dependency on the syntax
+ * diagnostics tokenizer).
+ */
+function firstRedisArgvUpper(line: string): string[] {
+  const tokens: string[] = [];
+  let i = 0;
+  const n = line.length;
+  while (i < n && tokens.length < 2) {
+    while (i < n && /\s/.test(line[i])) i++;
+    if (i >= n) break;
+    const quote = line[i] === '"' || line[i] === "'" ? line[i] : "";
+    let token = "";
+    let escaping = false;
+    if (quote) i++;
+    while (i < n) {
+      const ch = line[i];
+      if (escaping) {
+        token += ch;
+        escaping = false;
+        i++;
+        continue;
+      }
+      if (ch === "\\") {
+        escaping = true;
+        i++;
+        continue;
+      }
+      if (quote && ch === quote) {
+        i++;
+        break;
+      }
+      if (!quote && /\s/.test(ch)) break;
+      token += ch;
+      i++;
+    }
+    tokens.push(token.toUpperCase());
+  }
+  return tokens;
+}
+
+// Commands marked `safety: "blocked"` because they are dangerous/administrative,
+// but which do NOT actually change the key set of the current db — so they should
+// NOT trigger key-name completion cache invalidation. (e.g. KEYS is read-only;
+// SAVE/BGSAVE/SHUTDOWN/REPLICAOF/SLAVEOF are server admin.) Everything else in the
+// `blocked` set (FLUSHALL, MIGRATE, EVAL[ESHA]) may mutate keys and is left in.
+const NON_MUTATING_BLOCKED = new Set(["KEYS", "BGSAVE", "SAVE", "SHUTDOWN", "REPLICAOF", "SLAVEOF"]);
+
+/**
+ * True when a command may change the key set of the db it ran on (adds/edits/
+ * removes/renames keys, or wipes the db), and therefore the cached key-name
+ * completion for that db is potentially stale and should be dropped.
+ *
+ * Mapping from the diagnostic `safety` field:
+ *   - `write`/`confirm` → every write command mutates keys (SET/DEL/INCR/HSET/...).
+ *   - `blocked`  → mostly destructive/admin; we keep the ones that may touch keys
+ *                  (FLUSHALL, MIGRATE, EVAL[ESHA]) and exclude the read-only/admin
+ *                  ones in `NON_MUTATING_BLOCKED`.
+ *   - `allowed`  → read-only (GET/LRANGE/SCAN/...), never invalidates.
+ *
+ * Commands absent from the table (unknown or read-only extensions) are treated as
+ * non-mutating so we never thrash the cache on lookups.
+ */
+export function isRedisMutatingCommand(command: string): boolean {
+  const argv = firstRedisArgvUpper(command);
+  const spec = resolveRedisCommandSpec(argv);
+  if (!spec) return false;
+  if (spec.safety === "write" || spec.safety === "confirm") return true;
+  if (spec.safety === "blocked") {
+    return !NON_MUTATING_BLOCKED.has(argv[0]);
+  }
+  return false;
+}
diff --git a/apps/desktop/src/lib/redis/redisCompletion.ts b/apps/desktop/src/lib/redis/redisCompletion.ts
new file mode 100644
index 0000000..d7622be
--- /dev/null
+++ b/apps/desktop/src/lib/redis/redisCompletion.ts
@@ -0,0 +1,243 @@
+/**
+ * Redis command autocompletion for the query editor. Mirrors the shape of
+ * `elasticsearchCompletion.ts` so the editor's completion pipeline (the single
+ * `autocompletion({ override })` in QueryEditor.vue) can dispatch to it.
+ *
+ * Data source: the static `REDIS_COMMAND_TABLE` (built for diagnostics). Keys
+ * are UPPER CASE command names; two-token subcommands are keyed as `"MAIN SUB"`
+ * (e.g. `"XGROUP CREATE"`). We split those into a main-name index + subcommand
+ * index here.
+ */
+import { REDIS_COMMAND_TABLE } from "@/lib/redis/redisCommandTable";
+import type { RedisCommandSpec } from "@/lib/redis/redisCommandTable";
+
+export interface RedisCompletionItem {
+  label: string;
+  type: "keyword" | "text"; // command/subcommand=keyword, key name=text
+  detail?: string; // single-line, e.g. "string · confirm"
+  info?: string; // multi-line: Group / Arity / Safety
+  apply?: string;
+  boost: number;
+}
+
+export interface RedisCompletionContext {
+  mode: "command" | "subcommand" | "argument";
+  prefix: string;
+  /** Absolute document offset where the completion starts. */
+  from: number;
+  /** Upper-cased main command already typed, when known. */
+  mainCommand?: string;
+  /** In argument mode: 0-based index of the argument position (after the command head). */
+  argumentIndex?: number;
+}
+
+export interface RedisCompletionInput {
+  keys?: string[];
+}
+
+// ---- Static indexes derived from the command table ----
+
+interface MainCommandEntry {
+  name: string;
+  spec: RedisCommandSpec;
+}
+
+interface SubcommandEntry {
+  main: string;
+  sub: string;
+  spec: RedisCommandSpec;
+}
+
+const MAIN_COMMANDS: MainCommandEntry[] = [];
+const SUBCOMMANDS: SubcommandEntry[] = [];
+const SUBCOMMAND_MAINS = new Set<string>();
+
+for (const [key, spec] of Object.entries(REDIS_COMMAND_TABLE)) {
+  const space = key.indexOf(" ");
+  if (space < 0) {
+    MAIN_COMMANDS.push({ name: key, spec });
+  } else {
+    const main = key.slice(0, space);
+    const sub = key.slice(space + 1);
+    SUBCOMMANDS.push({ main, sub, spec });
+    SUBCOMMAND_MAINS.add(main);
+    // A main command that only has subcommand forms still needs a main-name
+    // entry so the user can complete the main token first.
+    if (!REDIS_COMMAND_TABLE[main]) MAIN_COMMANDS.push({ name: main, spec });
+  }
+}
+
+// Groups whose first argument is a key name (enable key completion there).
+const KEY_ARGUMENT_GROUPS = new Set(["string", "generic", "list", "hash", "set", "zset", "bitmap", "hyperloglog", "geo", "stream"]);
+
+// Commands that accept a variadic list of keys (keep suggesting keys beyond the
+// first argument slot). Most key commands take exactly one key; these keep going.
+const MULTI_KEY_COMMANDS = new Set(["DEL", "UNLINK", "EXISTS", "TOUCH", "MGET"]);
+
+// Boost tuning: common groups surface higher.
+const GROUP_BOOST: Record<string, number> = {
+  string: 110,
+  generic: 108,
+  connection: 100,
+  server: 96,
+};
+
+function describeArity(arity: number): string {
+  if (arity > 0) {
+    const n = arity - 1;
+    return `exactly ${n} argument${n === 1 ? "" : "s"}`;
+  }
+  if (arity < 0) {
+    const n = -arity - 1;
+    return `at least ${n} argument${n === 1 ? "" : "s"}`;
+  }
+  return "variable arguments";
+}
+
+function matchesPrefix(value: string, prefix: string): boolean {
+  return value.toLowerCase().startsWith(prefix.toLowerCase());
+}
+
+function buildSpecDetail(spec: RedisCommandSpec): string {
+  return spec.safety === "allowed" ? spec.group : `${spec.group} · ${spec.safety}`;
+}
+
+function buildSpecInfo(spec: RedisCommandSpec, label: string): string {
+  return [`Command: ${label}`, `Group: ${spec.group}`, `Arity: ${describeArity(spec.arity)}`, `Safety: ${spec.safety}`].join("\n");
+}
+
+function boostFor(spec: RedisCommandSpec): number {
+  return GROUP_BOOST[spec.group] ?? 90;
+}
+
+// ---- Context parsing ----
+
+export function getRedisCompletionContext(text: string, cursor: number): RedisCompletionContext {
+  const safeCursor = Math.max(0, Math.min(cursor, text.length));
+  const lineStart = text.lastIndexOf("\n", safeCursor - 1) + 1;
+  const beforeCursor = text.slice(lineStart, safeCursor);
+
+  // Tokenize the part before the cursor by whitespace.
+  const tokens = beforeCursor.trimStart().length === 0 ? [] : beforeCursor.trim().split(/\s+/);
+  const endsWithSpace = beforeCursor.length > 0 && /\s$/.test(beforeCursor);
+
+  // Current word being typed (no trailing space yet).
+  const currentWord = endsWithSpace ? "" : (tokens[tokens.length - 1] ?? "");
+  const wordStartFromEnd = currentWord.length;
+  const from = safeCursor - wordStartFromEnd;
+
+  const typedTokens = endsWithSpace ? tokens : tokens.slice(0, -1);
+
+  // No command yet (or typing the very first token).
+  if (typedTokens.length === 0) {
+    return { mode: "command", prefix: currentWord, from };
+  }
+
+  const main = typedTokens[0]!.toUpperCase();
+
+  // First token done + space → maybe a subcommand of a command that has them.
+  if (typedTokens.length === 1 && SUBCOMMAND_MAINS.has(main)) {
+    return { mode: "subcommand", prefix: currentWord, from, mainCommand: main };
+  }
+
+  // Past the command (and any subcommand slot) → an argument. Track which
+  // argument position the cursor is at so we only suggest key names for the
+  // first key argument (e.g. GET <key>, not after the key is filled in).
+  const commandHeadTokens = typedTokens.length >= 2 && REDIS_COMMAND_TABLE[`${main} ${typedTokens[1]!.toUpperCase()}`] ? 2 : 1;
+  const argumentIndex = Math.max(typedTokens.length - commandHeadTokens, 0);
+  return { mode: "argument", prefix: currentWord, from, mainCommand: main, argumentIndex };
+}
+
+// ---- Item builders ----
+
+function commandItems(prefix: string): RedisCompletionItem[] {
+  const items = MAIN_COMMANDS.filter((entry) => matchesPrefix(entry.name, prefix)).map((entry) => ({
+    label: entry.name,
+    type: "keyword" as const,
+    detail: buildSpecDetail(entry.spec),
+    info: buildSpecInfo(entry.spec, entry.name),
+    boost: boostFor(entry.spec),
+  }));
+  return items.sort((a, b) => b.boost - a.boost);
+}
+
+function subcommandItems(main: string, prefix: string): RedisCompletionItem[] {
+  const items = SUBCOMMANDS.filter((entry) => entry.main === main && matchesPrefix(entry.sub, prefix)).map((entry) => ({
+    label: entry.sub,
+    type: "keyword" as const,
+    detail: buildSpecDetail(entry.spec),
+    info: buildSpecInfo(entry.spec, `${main} ${entry.sub}`),
+    boost: boostFor(entry.spec),
+  }));
+  return items.sort((a, b) => b.boost - a.boost);
+}
+
+function keyItems(prefix: string, keys: string[]): RedisCompletionItem[] {
+  if (!prefix) {
+    // No partial key typed yet: offer a bounded sample (sorted) so the menu isn't empty.
+    return keys.slice(0, 100).map((key) => ({
+      label: key,
+      type: "text" as const,
+      detail: "key",
+      boost: 60,
+    }));
+  }
+  return keys
+    .filter((key) => key.toLowerCase().includes(prefix.toLowerCase()))
+    .slice(0, 100)
+    .map((key) => ({
+      label: key,
+      type: "text" as const,
+      detail: "key",
+      boost: key.toLowerCase().startsWith(prefix.toLowerCase()) ? 70 : 55,
+    }));
+}
+
+export function buildRedisCompletionItemsFromContext(context: RedisCompletionContext, input: RedisCompletionInput = {}): RedisCompletionItem[] {
+  if (context.mode === "command") return commandItems(context.prefix);
+  if (context.mode === "subcommand" && context.mainCommand) {
+    return subcommandItems(context.mainCommand, context.prefix);
+  }
+  // argument mode: offer key names at the key-argument slot only. Most key
+  // commands take a single key (first slot); variadic key-list commands
+  // (DEL/UNLINK/EXISTS/...) keep suggesting at every slot.
+  if (context.mode === "argument" && takesKeyArgument(context.mainCommand) && shouldSuggestKeyAt(context.mainCommand, context.argumentIndex)) {
+    return keyItems(context.prefix, input.keys ?? []);
+  }
+  return [];
+}
+
+function shouldSuggestKeyAt(mainCommand: string | undefined, argumentIndex: number | undefined): boolean {
+  if (argumentIndex == null) return false;
+  if (mainCommand && MULTI_KEY_COMMANDS.has(mainCommand)) return true;
+  return argumentIndex === 0;
+}
+
+export function buildRedisCompletionItems(text: string, cursor: number, input: RedisCompletionInput = {}): RedisCompletionItem[] {
+  return buildRedisCompletionItemsFromContext(getRedisCompletionContext(text, cursor), input);
+}
+
+/** True when the main command's first argument is a key (by group heuristic). */
+export function takesKeyArgument(mainCommand?: string): boolean {
+  if (!mainCommand) return false;
+  const spec = REDIS_COMMAND_TABLE[mainCommand];
+  if (spec) return KEY_ARGUMENT_GROUPS.has(spec.group);
+  // A main that only exists via subcommands (e.g. XGROUP, CONFIG): treat stream/cluster
+  // subcommand roots as key-taking only for the stream group, conservatively.
+  return false;
+}
+
+export function shouldAutoOpenRedisCompletion(text: string, cursor: number): boolean {
+  const previousChar = text[cursor - 1];
+  if (!previousChar) return false;
+  if (/[\n\r]/.test(previousChar)) return false;
+  // Open while typing command names or key names (letters/digits/_/:/./-).
+  if (/[\w:*.-]/.test(previousChar)) return true;
+  // Just typed a space after a command → open to suggest subcommands / keys.
+  if (/\s/.test(previousChar)) return true;
+  return false;
+}
+
+export function getRedisCompletionResultValidFor(): RegExp {
+  return /[\w:*.-]*$/;
+}
diff --git a/apps/desktop/src/lib/redis/redisCreateKeyTypeHelp.ts b/apps/desktop/src/lib/redis/redisCreateKeyTypeHelp.ts
new file mode 100644
index 0000000..1663cc3
--- /dev/null
+++ b/apps/desktop/src/lib/redis/redisCreateKeyTypeHelp.ts
@@ -0,0 +1,41 @@
+export const REDIS_CREATE_KEY_TYPE_VALUES = ["string", "hash", "list", "set", "zset", "stream", "json"] as const;
+
+export type RedisCreateKeyTypeValue = (typeof REDIS_CREATE_KEY_TYPE_VALUES)[number];
+export type RedisCreateKeyTypeHelpKey = RedisCreateKeyTypeValue;
+
+export interface RedisCreateKeyTypeHelp {
+  key: RedisCreateKeyTypeHelpKey;
+}
+
+export interface RedisCreateKeyTypeHelpFocusState {
+  openedByArrow: boolean;
+  keyboardNavigating: boolean;
+}
+
+const REDIS_CREATE_KEY_TYPE_HELP: Readonly<Record<RedisCreateKeyTypeValue, RedisCreateKeyTypeHelpKey>> = {
+  string: "string",
+  hash: "hash",
+  list: "list",
+  set: "set",
+  zset: "zset",
+  stream: "stream",
+  json: "json",
+};
+
+/** Returns help for a Redis data type offered by the Create key dialog. */
+export function getRedisCreateKeyTypeHelp(rawType: string): RedisCreateKeyTypeHelp | undefined {
+  const type = rawType.trim().toLowerCase() as RedisCreateKeyTypeValue;
+  const key = REDIS_CREATE_KEY_TYPE_HELP[type];
+  return key ? { key } : undefined;
+}
+
+/** Returns the selected offered type whose help is shown when the Select opens. */
+export function redisCreateKeyTypeHelpOptionOnOpen(rawType: string): RedisCreateKeyTypeValue | undefined {
+  const type = rawType.trim().toLowerCase() as RedisCreateKeyTypeValue;
+  return REDIS_CREATE_KEY_TYPE_HELP[type] ? type : undefined;
+}
+
+/** Determines whether a SelectItem focus event was caused by Arrow navigation. */
+export function shouldActivateRedisCreateKeyTypeHelpOnFocus(state: RedisCreateKeyTypeHelpFocusState): boolean {
+  return state.openedByArrow || state.keyboardNavigating;
+}
diff --git a/apps/desktop/src/lib/redis/redisKeyPattern.ts b/apps/desktop/src/lib/redis/redisKeyPattern.ts
new file mode 100644
index 0000000..32060f7
--- /dev/null
+++ b/apps/desktop/src/lib/redis/redisKeyPattern.ts
@@ -0,0 +1,19 @@
+const REDIS_GLOB_SPECIAL_CHARS = /[\\*?[\]]/g;
+const REDIS_GLOB_SPECIAL_CHARS_FUZZY = /[\\*?[\]]/g;
+
+export function escapeRedisGlobText(value: string, fuzzy = false): string {
+  return value.replace(fuzzy ? REDIS_GLOB_SPECIAL_CHARS_FUZZY : REDIS_GLOB_SPECIAL_CHARS, "\\$&");
+}
+
+export function redisKeySearchPattern(value: string, fuzzy: boolean): string {
+  const pattern = value.trim();
+  if (!pattern) return "*";
+  return fuzzy ? `*${escapeRedisGlobText(pattern, fuzzy)}*` : pattern;
+}
+
+// Redis scan page size (COUNT parameter per SCAN round-trip) — shared defaults
+// and validation bounds used by the connection form and key browser.
+export const REDIS_SCAN_PAGE_SIZE_DEFAULT = 1000;
+export const REDIS_SCAN_PAGE_SIZE_MIN = 200;
+export const REDIS_SCAN_PAGE_SIZE_MAX = 10_000;
+export const REDIS_SCAN_PAGE_SIZE_OPTIONS = [200, 1000, 5000, 10_000] as const;
diff --git a/apps/desktop/src/lib/redis/redisKeyTree.ts b/apps/desktop/src/lib/redis/redisKeyTree.ts
new file mode 100644
index 0000000..8419792
--- /dev/null
+++ b/apps/desktop/src/lib/redis/redisKeyTree.ts
@@ -0,0 +1,239 @@
+import type { RedisKeyInfo } from "@/lib/backend/api";
+
+export interface RedisKeyTreeLeafNode {
+  kind: "leaf";
+  id: string;
+  label: string;
+  fullKeyDisplay: string;
+  keyRaw: string;
+  db: number;
+  keyType: string;
+  ttl: number;
+  size: number;
+  valuePreview: string;
+  pathSegments: string[];
+}
+
+export interface RedisKeyTreeGroupNode {
+  kind: "group";
+  id: string;
+  label: string;
+  pathSegments: string[];
+  children: RedisKeyTreeNode[];
+}
+
+export type RedisKeyTreeNode = RedisKeyTreeLeafNode | RedisKeyTreeGroupNode;
+
+export interface RedisKeyTreeRow {
+  node: RedisKeyTreeNode;
+  depth: number;
+}
+
+export function redisKeyNameCopyText(node: RedisKeyTreeNode): string | null {
+  // keyRaw is base64-encoded for backend roundtrips; copy the user-visible
+  // Redis key name instead of the internal transport value.
+  return node.kind === "leaf" ? node.fullKeyDisplay : null;
+}
+
+function buildGroupId(db: number, pathSegments: string[]): string {
+  return `group:${db}:${pathSegments.join("\u0000")}`;
+}
+
+function buildLeafId(db: number, keyRaw: string): string {
+  return `leaf:${db}:${keyRaw}`;
+}
+
+export function redisKeyToFlatTreeRow(key: RedisKeyInfo, db: number): RedisKeyTreeRow {
+  return {
+    node: {
+      kind: "leaf",
+      id: buildLeafId(db, key.key_raw),
+      label: key.key_display,
+      fullKeyDisplay: key.key_display,
+      keyRaw: key.key_raw,
+      db,
+      keyType: key.key_type ?? "",
+      ttl: key.ttl ?? -2,
+      size: key.size ?? 0,
+      valuePreview: key.value_preview ?? "",
+      pathSegments: [key.key_display],
+    },
+    depth: 0,
+  };
+}
+
+function compareRedisTreeNodes(a: RedisKeyTreeNode, b: RedisKeyTreeNode): number {
+  if (a.kind !== b.kind) return a.kind === "group" ? -1 : 1;
+  return a.label.localeCompare(b.label);
+}
+
+function sortRedisTreeNodes(nodes: RedisKeyTreeNode[]): RedisKeyTreeNode[] {
+  return [...nodes].sort(compareRedisTreeNodes).map((node) =>
+    node.kind === "group"
+      ? {
+          ...node,
+          children: sortRedisTreeNodes(node.children),
+        }
+      : node,
+  );
+}
+
+export function buildRedisKeyTree(keys: RedisKeyInfo[], db: number, separator = ":"): RedisKeyTreeNode[] {
+  const root: RedisKeyTreeNode[] = [];
+  const groupMap = new Map<string, RedisKeyTreeGroupNode>();
+
+  for (const key of keys) {
+    insertKeyIntoTree(root, groupMap, key, db, separator);
+  }
+
+  return sortRedisTreeNodes(root);
+}
+
+function insertKeyIntoTree(root: RedisKeyTreeNode[], groupMap: Map<string, RedisKeyTreeGroupNode>, key: RedisKeyInfo, db: number, separator: string): void {
+  const pathSegments = separator ? key.key_display.split(separator) : [key.key_display];
+  if (pathSegments.length === 1) {
+    root.push({
+      kind: "leaf",
+      id: buildLeafId(db, key.key_raw),
+      label: pathSegments[0],
+      fullKeyDisplay: key.key_display,
+      keyRaw: key.key_raw,
+      db,
+      keyType: key.key_type ?? "",
+      ttl: key.ttl ?? -2,
+      size: key.size ?? 0,
+      valuePreview: key.value_preview ?? "",
+      pathSegments,
+    });
+    return;
+  }
+
+  let currentLevel = root;
+  const groupSegments: string[] = [];
+  for (const segment of pathSegments.slice(0, -1)) {
+    groupSegments.push(segment);
+    const groupId = buildGroupId(db, groupSegments);
+    let group = groupMap.get(groupId);
+    if (!group) {
+      group = {
+        kind: "group",
+        id: groupId,
+        label: segment,
+        pathSegments: [...groupSegments],
+        children: [],
+      };
+      groupMap.set(groupId, group);
+      currentLevel.push(group);
+    }
+    currentLevel = group.children;
+  }
+
+  currentLevel.push({
+    kind: "leaf",
+    id: buildLeafId(db, key.key_raw),
+    label: pathSegments[pathSegments.length - 1],
+    fullKeyDisplay: key.key_display,
+    keyRaw: key.key_raw,
+    db,
+    keyType: key.key_type ?? "",
+    ttl: key.ttl ?? -2,
+    size: key.size ?? 0,
+    valuePreview: key.value_preview ?? "",
+    pathSegments,
+  });
+}
+
+function rebuildGroupMap(tree: RedisKeyTreeNode[]): Map<string, RedisKeyTreeGroupNode> {
+  const groupMap = new Map<string, RedisKeyTreeGroupNode>();
+
+  const walk = (nodes: RedisKeyTreeNode[]) => {
+    for (const node of nodes) {
+      if (node.kind === "group") {
+        groupMap.set(node.id, node);
+        walk(node.children);
+      }
+    }
+  };
+
+  walk(tree);
+  return groupMap;
+}
+
+export function mergeKeysIntoRedisKeyTree(existingTree: RedisKeyTreeNode[], newKeys: RedisKeyInfo[], db: number, separator = ":"): RedisKeyTreeNode[] {
+  if (existingTree.length === 0) return buildRedisKeyTree(newKeys, db, separator);
+
+  const groupMap = rebuildGroupMap(existingTree);
+  const existingKeyIds = new Set<string>();
+  const collectKeys = (nodes: RedisKeyTreeNode[]) => {
+    for (const node of nodes) {
+      if (node.kind === "leaf") {
+        existingKeyIds.add(node.keyRaw);
+      } else {
+        collectKeys(node.children);
+      }
+    }
+  };
+  collectKeys(existingTree);
+
+  for (const key of newKeys) {
+    if (existingKeyIds.has(key.key_raw)) continue;
+    insertKeyIntoTree(existingTree, groupMap, key, db, separator);
+  }
+
+  return sortRedisTreeNodes(existingTree);
+}
+
+export function collectExpandedGroupIds(nodes: RedisKeyTreeNode[]): Set<string> {
+  const ids = new Set<string>();
+
+  const visit = (entries: RedisKeyTreeNode[]) => {
+    for (const node of entries) {
+      if (node.kind !== "group") continue;
+      ids.add(node.id);
+      visit(node.children);
+    }
+  };
+
+  visit(nodes);
+  return ids;
+}
+
+export function collectRedisGroupKeyRaws(group: RedisKeyTreeGroupNode): string[] {
+  const keyRaws: string[] = [];
+
+  const visit = (nodes: RedisKeyTreeNode[]) => {
+    for (const node of nodes) {
+      if (node.kind === "leaf") {
+        keyRaws.push(node.keyRaw);
+      } else {
+        visit(node.children);
+      }
+    }
+  };
+
+  visit(group.children);
+  return keyRaws;
+}
+
+export function flattenVisibleRedisKeyTree(nodes: RedisKeyTreeNode[], expandedGroupIds: ReadonlySet<string>, depth = 0): RedisKeyTreeRow[] {
+  const rows: RedisKeyTreeRow[] = [];
+  const stack: RedisKeyTreeRow[] = [];
+
+  for (let index = nodes.length - 1; index >= 0; index--) {
+    stack.push({ node: nodes[index], depth });
+  }
+
+  while (stack.length > 0) {
+    const row = stack.pop()!;
+    rows.push(row);
+
+    if (row.node.kind !== "group" || !expandedGroupIds.has(row.node.id)) continue;
+
+    const childDepth = row.depth + 1;
+    for (let index = row.node.children.length - 1; index >= 0; index--) {
+      stack.push({ node: row.node.children[index], depth: childDepth });
+    }
+  }
+
+  return rows;
+}
diff --git a/apps/desktop/src/lib/redis/redisQueryResult.ts b/apps/desktop/src/lib/redis/redisQueryResult.ts
new file mode 100644
index 0000000..50bff26
--- /dev/null
+++ b/apps/desktop/src/lib/redis/redisQueryResult.ts
@@ -0,0 +1,49 @@
+import type { QueryResult } from "@/types/database";
+import { formatRedisCommandResult } from "@/lib/redis/redisValuePresentation";
+
+const KEY_VALUE_COMMANDS = new Set(["HGETALL"]);
+
+function isKeyValueCommand(command: string): boolean {
+  return KEY_VALUE_COMMANDS.has(command.toUpperCase().trim());
+}
+
+export function redisCommandResultToQueryResult(value: unknown, elapsedMs: number, command?: string): QueryResult {
+  if (Array.isArray(value) && command && isKeyValueCommand(command)) {
+    const rows: (string | number | boolean | null)[][] = [];
+    for (let i = 0; i + 1 < value.length; i += 2) {
+      rows.push([formatRedisCommandResult(value[i]), formatRedisCommandResult(value[i + 1])]);
+    }
+    return {
+      columns: ["field", "value"],
+      rows,
+      affected_rows: value.length / 2,
+      execution_time_ms: Math.max(0, Math.round(elapsedMs)),
+    };
+  }
+  // INFO commands in cluster mode → [[node_addr, info_text], ...] pairs.
+  // Render as a two-column table with the addr as the index and info text as the value.
+  if (Array.isArray(value) && value.length > 0 && value.every((item) => Array.isArray(item) && item.length === 2 && typeof item[0] === "string" && typeof item[1] === "string")) {
+    const rows: (string | number | boolean | null)[][] = value.map((item: [string, string]) => [item[0], item[1]]);
+    return {
+      columns: ["(index)", "value"],
+      rows,
+      affected_rows: value.length,
+      execution_time_ms: Math.max(0, Math.round(elapsedMs)),
+    };
+  }
+  if (Array.isArray(value)) {
+    const rows: (string | number | boolean | null)[][] = value.map((item, i) => [i + 1, formatRedisCommandResult(item)]);
+    return {
+      columns: ["(index)", "value"],
+      rows,
+      affected_rows: value.length,
+      execution_time_ms: Math.max(0, Math.round(elapsedMs)),
+    };
+  }
+  return {
+    columns: ["result"],
+    rows: [[formatRedisCommandResult(value)]],
+    affected_rows: 0,
+    execution_time_ms: Math.max(0, Math.round(elapsedMs)),
+  };
+}
diff --git a/apps/desktop/src/lib/redis/redisSyntaxDiagnostics.ts b/apps/desktop/src/lib/redis/redisSyntaxDiagnostics.ts
new file mode 100644
index 0000000..688e5cb
--- /dev/null
+++ b/apps/desktop/src/lib/redis/redisSyntaxDiagnostics.ts
@@ -0,0 +1,224 @@
+/**
+ * Redis command syntax diagnostics for the query editor.
+ *
+ * Mirrors the shape of `sqlSemantic/diagnostics.ts` so the editor's diagnostic
+ * pipeline (StateField + Decoration.mark) can render them with no extra wiring.
+ * Diagnostics are produced per-line (one Redis command per line — matching the
+ * execution contract in `queryStore.executeTabSql`).
+ */
+import type { SqlTextSpan } from "@/types/database";
+import type { SqlSemanticDiagnostic } from "@/lib/sql/semantic/diagnostics";
+import { resolveRedisCommandSpec } from "@/lib/redis/redisCommandTable";
+
+export interface RedisArgvToken {
+  /** Token text (raw, case preserved). */
+  value: string;
+  /** 1-based start/end character columns within the source line. */
+  startColumn: number;
+  endColumn: number;
+}
+
+export interface RedisArgvResult {
+  argv: RedisArgvToken[];
+  /** True when a quoted string was not closed before end-of-line. */
+  unclosedQuote: boolean;
+  /** Column where an unclosed quote started (1-based), if any. */
+  unclosedQuoteStart?: number;
+}
+
+/**
+ * Tokenize a single Redis command line into argv, mirroring the server-side
+ * `parse_command_argv` rules (whitespace separation, single/double quotes,
+ * backslash escapes). Trailing `;` is stripped. Each token records its column
+ * span so diagnostics can underline the offending token.
+ */
+export function tokenizeRedisLine(line: string): RedisArgvResult {
+  const argv: RedisArgvToken[] = [];
+  let i = 0;
+  const n = line.length;
+  let unclosedQuote = false;
+  let unclosedQuoteStart: number | undefined;
+
+  while (i < n) {
+    // Skip whitespace.
+    while (i < n && (line[i] === " " || line[i] === "\t")) i++;
+    if (i >= n) break;
+
+    const startColumn = i + 1; // 1-based
+    let value = "";
+    let closed = false;
+    const ch = line[i];
+
+    if (ch === '"' || ch === "'") {
+      if (unclosedQuoteStart === undefined) unclosedQuoteStart = startColumn;
+      const quote = ch;
+      i++; // consume opening quote
+      let escaping = false;
+      while (i < n) {
+        const c = line[i];
+        if (escaping) {
+          value += c;
+          escaping = false;
+          i++;
+          continue;
+        }
+        if (c === "\\") {
+          escaping = true;
+          i++;
+          continue;
+        }
+        if (c === quote) {
+          i++; // consume closing quote
+          closed = true;
+          break;
+        }
+        value += c;
+        i++;
+      }
+      if (!closed && i >= n) {
+        unclosedQuote = true;
+      } else {
+        // If the quote was closed, allow trailing chars until whitespace as part
+        // of the same token (e.g. `"a"b` → `ab`) to match common tokenizers.
+        while (i < n && line[i] !== " " && line[i] !== "\t") {
+          value += line[i];
+          i++;
+        }
+      }
+    } else {
+      closed = true; // unquoted tokens are always complete
+      while (i < n && line[i] !== " " && line[i] !== "\t") {
+        if (line[i] === "\\") {
+          i++;
+          if (i < n) {
+            value += line[i];
+            i++;
+          }
+          continue;
+        }
+        value += line[i];
+        i++;
+      }
+    }
+
+    // Strip a single trailing semicolon (line-level `;` terminator).
+    if (value.endsWith(";")) value = value.slice(0, -1);
+
+    if (value.length > 0 || !closed) {
+      argv.push({ value, startColumn, endColumn: i + 1 });
+    }
+  }
+
+  return { argv, unclosedQuote, unclosedQuoteStart };
+}
+
+function aritySatisfied(arity: number, tokenCount: number): boolean {
+  if (arity > 0) return tokenCount === arity;
+  if (arity < 0) return tokenCount >= -arity;
+  return true; // arity 0 — unspecified, accept anything
+}
+
+function describeArity(arity: number): string {
+  if (arity > 0) return `exactly ${arity - 1} argument${arity - 1 === 1 ? "" : "s"}`;
+  if (arity < 0) return `at least ${-arity - 1} argument${-arity - 1 === 1 ? "" : "s"}`;
+  return "any number of arguments";
+}
+
+function lineSpan(lineIndex: number, startColumn: number, endColumn: number): SqlTextSpan {
+  // SqlTextSpan columns are 1-based and inclusive; map onto the physical line.
+  return {
+    start_line: lineIndex,
+    start_column: startColumn,
+    end_line: lineIndex,
+    end_column: endColumn,
+  };
+}
+
+/**
+ * Build diagnostics for the whole editor source (multi-line). Each non-empty,
+ * non-comment line is parsed as one Redis command.
+ */
+export function buildRedisSyntaxDiagnostics(source: string): SqlSemanticDiagnostic[] {
+  const diagnostics: SqlSemanticDiagnostic[] = [];
+  const lines = source.split(/\r?\n/);
+
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const rawLine = lines[lineIndex];
+    const lineNo = lineIndex + 1; // 1-based line number for SqlTextSpan
+    if (!rawLine || !rawLine.trim()) continue;
+    // Skip comment-ish lines (Redis has no official comments, but `#`/`--` are
+    // commonly used by users as notes).
+    if (/^\s*(#|--)/.test(rawLine)) continue;
+
+    const { argv, unclosedQuote, unclosedQuoteStart } = tokenizeRedisLine(rawLine);
+
+    if (unclosedQuote) {
+      const startCol = unclosedQuoteStart ?? 1;
+      diagnostics.push({
+        span: lineSpan(lineNo, startCol, Math.max(rawLine.length, startCol)),
+        message: "Unclosed quote",
+        severity: "error",
+      });
+      continue; // further checks are unreliable without a clean parse
+    }
+
+    if (argv.length === 0) continue;
+
+    const upper = argv.map((token) => token.value.toUpperCase());
+    const spec = resolveRedisCommandSpec(upper);
+    const commandToken = argv[0];
+
+    if (!spec) {
+      diagnostics.push({
+        span: lineSpan(lineNo, commandToken.startColumn, commandToken.endColumn),
+        message: `Unknown command '${argv[0].value}'`,
+        severity: "error",
+      });
+      continue;
+    }
+
+    if (!aritySatisfied(spec.arity, argv.length)) {
+      diagnostics.push({
+        span: lineSpan(lineNo, commandToken.startColumn, commandToken.endColumn),
+        message: `Wrong number of arguments for '${argv[0].value}': expected ${describeArity(spec.arity)}, got ${argv.length - 1}`,
+        severity: "error",
+      });
+      // Don't also emit a safety marker on the same token — arity error is clearer.
+      continue;
+    }
+
+    if (spec.safety === "blocked") {
+      diagnostics.push({
+        span: lineSpan(lineNo, commandToken.startColumn, commandToken.endColumn),
+        message: `Blocked command '${argv[0].value}'`,
+        severity: "error",
+      });
+    } else if (spec.safety === "confirm") {
+      diagnostics.push({
+        span: lineSpan(lineNo, commandToken.startColumn, commandToken.endColumn),
+        message: `Dangerous command '${argv[0].value}' — confirmation recommended`,
+        severity: "warning",
+      });
+    }
+  }
+
+  return diagnostics;
+}
+
+/**
+ * Gate diagnostics while the user is actively typing the command name on the
+ * current line, to avoid transient "Unknown command" noise. Mirrors the intent
+ * of `shouldRunSqlSemanticDiagnostics`.
+ */
+export function shouldRunRedisDiagnostics(source: string, cursor: number): boolean {
+  if (!source.trim()) return false;
+  // Find the line the cursor is on.
+  const upto = source.slice(0, cursor);
+  const lineStart = upto.lastIndexOf("\n") + 1;
+  const lineText = source.slice(lineStart, cursor);
+  const trimmed = lineText.trimStart();
+  // If the cursor line only has whitespace and a partial first token with no
+  // separating whitespace yet, we're still typing the command name → wait.
+  if (trimmed.length > 0 && !/\s/.test(trimmed)) return false;
+  return true;
+}
diff --git a/apps/desktop/src/lib/redis/redisValuePresentation.ts b/apps/desktop/src/lib/redis/redisValuePresentation.ts
new file mode 100644
index 0000000..1d5bfd7
--- /dev/null
+++ b/apps/desktop/src/lib/redis/redisValuePresentation.ts
@@ -0,0 +1,532 @@
+import type { BinaryHexViewRow } from "@/lib/dataGrid/binaryHexViewer";
+import { buildBinaryHexViewRows } from "@/lib/dataGrid/binaryHexViewer";
+import { parseJsonPreservingLargeNumbers, safeJsonFormat } from "@/lib/common/safeJsonFormat";
+import type { RedisBlob, RedisCollectionPage, RedisHashItem, RedisListItem, RedisSetItem, RedisValue, RedisZsetItem } from "@/lib/backend/api";
+import { parseJavaSerializedDetail, type RedisJavaSerializedDetail } from "@/lib/redis/javaSerialized";
+
+export type RedisValueFormat = "utf8" | "ascii" | "binary" | "json" | "javaserialize" | "hex" | "base64";
+export type RedisMemberDetailFormat = "json" | "text";
+
+export const REDIS_VALUE_FORMAT_DISPLAY_ORDER: RedisValueFormat[] = ["utf8", "ascii", "binary", "json", "javaserialize", "hex", "base64"];
+
+export interface RedisMemberDetail {
+  text: string;
+  rawText: string;
+  rawLabel: string;
+  utf8Text: string;
+  asciiText: string;
+  binaryText: string;
+  format: RedisMemberDetailFormat;
+  json?: RedisJsonDetail;
+  javaSerialized?: RedisJavaSerializedDetail;
+  availableFormats: RedisValueFormat[];
+  defaultFormat: RedisValueFormat;
+  byteCount: number;
+  base64Text: string;
+  hexRows: BinaryHexViewRow[];
+  editable: boolean;
+  binary: boolean;
+}
+
+export interface RedisJsonDetail {
+  rawText: string;
+  formattedText: string;
+  value: unknown;
+}
+
+export interface RedisMemberDetailOptions {
+  allowJsonText?: boolean;
+}
+
+export type RedisMemberDetailKind = "list" | "set" | "hash" | "zset" | "stream";
+export type RedisCollectionItem = RedisListItem | RedisSetItem | RedisHashItem | RedisZsetItem;
+
+export const REDIS_MEMBER_DETAIL_SHEET_MIN_WIDTH = 360;
+export const REDIS_MEMBER_DETAIL_SHEET_MAX_WIDTH = 900;
+
+export function canEditRedisMemberDetail(kind: RedisMemberDetailKind, value?: unknown): boolean {
+  if (kind === "stream") return false;
+  if (value == null) return true;
+  return !isRedisBlob(value) || value.encoding !== "binary";
+}
+
+export function clampRedisMemberDetailSheetWidth(width: number, viewportWidth: number): number {
+  const viewportMax = Math.max(REDIS_MEMBER_DETAIL_SHEET_MIN_WIDTH, viewportWidth - 32);
+  return Math.min(Math.min(REDIS_MEMBER_DETAIL_SHEET_MAX_WIDTH, viewportMax), Math.max(REDIS_MEMBER_DETAIL_SHEET_MIN_WIDTH, width));
+}
+
+export function isRedisBlob(value: unknown): value is RedisBlob {
+  return typeof value === "object" && value !== null && "raw_base64" in value && "encoding" in value;
+}
+
+export function decodeRedisBlob(blob: RedisBlob): Uint8Array {
+  return base64ToBytes(blob.raw_base64);
+}
+
+export function redisBlobText(blob: RedisBlob): string | null {
+  if (blob.encoding === "binary") return null;
+  return decodeUtf8Bytes(decodeRedisBlob(blob));
+}
+
+export function redisBlobRawText(blob: RedisBlob): string {
+  return redisBlobText(blob) ?? escapeRedisBytes(decodeRedisBlob(blob));
+}
+
+export function redisBlobDisplayText(blob: RedisBlob): string {
+  return sanitizeRedisDisplayText(redisBlobRawText(blob));
+}
+
+export function formatRedisMemberDetail(value: unknown, options: RedisMemberDetailOptions = {}): RedisMemberDetail {
+  if (isRedisBlob(value)) return formatRedisBlobDetail(value, options);
+
+  if (typeof value === "string") {
+    const bytes = new TextEncoder().encode(value);
+    const json = options.allowJsonText ? (parseRedisJsonDetail(value) ?? undefined) : undefined;
+    const textFormats: RedisValueFormat[] = ["utf8", "ascii", "binary"];
+    return {
+      text: sanitizeRedisDisplayText(value),
+      rawText: value,
+      rawLabel: isAsciiBytes(bytes) ? "ASCII" : "UTF-8",
+      utf8Text: value,
+      asciiText: asciiBytesToText(bytes),
+      binaryText: binaryBytesToText(bytes),
+      format: "text",
+      json,
+      availableFormats: formatOrderForValue("utf8", textFormats, json ? ["json"] : []),
+      defaultFormat: "utf8",
+      byteCount: bytes.byteLength,
+      base64Text: bytesToBase64(bytes),
+      hexRows: buildBinaryHexViewRows(bytes),
+      editable: true,
+      binary: false,
+    };
+  }
+
+  try {
+    const formattedText = JSON.stringify(value, null, 2);
+    const bytes = new TextEncoder().encode(formattedText);
+    return {
+      text: formattedText,
+      rawText: formattedText,
+      rawLabel: "Raw",
+      utf8Text: formattedText,
+      asciiText: asciiBytesToText(bytes),
+      binaryText: binaryBytesToText(bytes),
+      format: "json",
+      json: { rawText: formattedText, formattedText, value },
+      availableFormats: formatOrderForValue("json", ["utf8"], ["json"]),
+      defaultFormat: "json",
+      byteCount: bytes.byteLength,
+      base64Text: bytesToBase64(bytes),
+      hexRows: buildBinaryHexViewRows(bytes),
+      editable: false,
+      binary: false,
+    };
+  } catch {
+    const text = String(value);
+    const bytes = new TextEncoder().encode(text);
+    return {
+      text,
+      rawText: text,
+      rawLabel: "Raw",
+      utf8Text: text,
+      asciiText: asciiBytesToText(bytes),
+      binaryText: binaryBytesToText(bytes),
+      format: "text",
+      availableFormats: formatOrderForValue("utf8", ["utf8"], []),
+      defaultFormat: "utf8",
+      byteCount: bytes.byteLength,
+      base64Text: bytesToBase64(bytes),
+      hexRows: buildBinaryHexViewRows(bytes),
+      editable: false,
+      binary: false,
+    };
+  }
+}
+
+export function formatRedisStringValue(value: unknown): string {
+  if (isRedisBlob(value)) return formatRedisMemberDetail(value).text;
+  if (typeof value !== "string") return String(value ?? "");
+  return formatRedisJsonString(value) ?? sanitizeRedisDisplayText(value);
+}
+
+export function formatRedisCommandResult(value: unknown): string {
+  if (typeof value === "string") return formatRedisStringValue(value);
+  return JSON.stringify(value, null, 2);
+}
+
+/**
+ * Detect if a value is a cluster-aggregated INFO response:
+ * `[[addr, infoText], ...]` where each `infoText` starts with `"# "`
+ * (the INFO section marker). This is the format produced by the backend
+ * in `redis_driver.rs::execute_command` for cluster-mode INFO.
+ */
+function isRedisClusterInfoValue(value: unknown): value is [string, string][] {
+  return Array.isArray(value) && value.length > 0 && (value as unknown[]).every((item) => Array.isArray(item) && item.length === 2 && typeof item[0] === "string" && typeof item[1] === "string" && item[1].startsWith("# "));
+}
+
+/**
+ * Format a Redis command result for the **command console terminal** (RedisKeyBrowser.vue).
+ * Unlike `formatRedisCommandResult` (used by the query result table UI), this function
+ * renders cluster-aggregated INFO output as plain text (not JSON), matching the native
+ * redis-cli display style.
+ *
+ * - Cluster INFO `[[addr, infoText], ...]` → `"{addr}\n{infoText}"` per node, joined by newlines.
+ * - Plain string → passthrough (handles single-node INFO text correctly).
+ * - Everything else → JSON.stringify (arrays, objects, etc.).
+ */
+export function formatRedisConsoleValue(value: unknown): string {
+  if (isRedisClusterInfoValue(value)) {
+    return value.map(([addr, info]) => `${addr}\n${info}`).join("\n");
+  }
+  if (typeof value === "string") return formatRedisStringValue(value);
+  return JSON.stringify(value, null, 2);
+}
+
+export function parseRedisJsonDetail(value: unknown): RedisJsonDetail | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+
+  try {
+    const parsed = parseJsonPreservingLargeNumbers(trimmed);
+    return {
+      rawText: value,
+      formattedText: safeJsonFormat(trimmed, 2),
+      value: parsed,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function preferredRedisValueFormat(value: unknown, preferred?: RedisValueFormat | null, options: RedisMemberDetailOptions = {}): RedisValueFormat {
+  const detail = formatRedisMemberDetail(value, options);
+  if (preferred && detail.availableFormats.includes(preferred) && shouldReuseRedisValueFormatPreference(detail, preferred)) return preferred;
+  return detail.defaultFormat;
+}
+
+export function canRenderRedisValueFormat(detail: RedisMemberDetail, format: RedisValueFormat): boolean {
+  switch (format) {
+    case "json":
+      return Boolean(detail.json);
+    case "javaserialize":
+      return Boolean(detail.javaSerialized);
+    default:
+      return true;
+  }
+}
+
+export function redisMemberCopyText(value: unknown): string {
+  return isRedisBlob(value) ? redisBlobRawText(value) : formatRedisMemberDetail(value).rawText;
+}
+
+export function getRedisMemberSelectionKey(title: string, value: unknown, identity = title): string {
+  if (isRedisBlob(value)) return `${identity}\n${value.raw_base64}`;
+  const detail = formatRedisMemberDetail(value);
+  return `${identity}\n${detail.rawText}`;
+}
+
+export function redisValueCollectionItems(value: RedisValue): RedisCollectionItem[] {
+  switch (value.data.kind) {
+    case "list":
+    case "set":
+    case "hash":
+    case "zset":
+      return value.data.items;
+    default:
+      return [];
+  }
+}
+
+export function redisCollectionPageItems(page: RedisCollectionPage): RedisCollectionItem[] {
+  return page.items;
+}
+
+export function redisValueCollectionTotal(value: RedisValue): number | null {
+  switch (value.data.kind) {
+    case "list":
+    case "set":
+    case "hash":
+    case "zset":
+      return value.data.total;
+    default:
+      return null;
+  }
+}
+
+export function redisValueCollectionScanCursor(value: RedisValue): number | undefined {
+  switch (value.data.kind) {
+    case "list":
+    case "set":
+    case "hash":
+    case "zset":
+      return value.data.scan_cursor;
+    default:
+      return undefined;
+  }
+}
+
+export function redisValueSize(value: RedisValue): number {
+  switch (value.data.kind) {
+    case "string":
+      return decodeRedisBlob(value.data.content).byteLength;
+    case "json":
+      return new TextEncoder().encode(JSON.stringify(value.data.value)).byteLength;
+    case "list":
+    case "set":
+    case "hash":
+    case "zset":
+      return value.data.total;
+    case "stream":
+      return value.data.entries.length;
+    default:
+      return 0;
+  }
+}
+
+export function redisValuePreview(value: RedisValue): string {
+  switch (value.data.kind) {
+    case "string":
+      return previewText(redisBlobRawText(value.data.content));
+    case "json":
+      return previewText(JSON.stringify(value.data.value));
+    case "list": {
+      const first = value.data.items[0];
+      return first ? previewText(redisBlobRawText(first.value)) : "";
+    }
+    case "set": {
+      const first = value.data.items[0];
+      return first ? previewText(redisBlobRawText(first.member)) : "";
+    }
+    case "hash": {
+      const first = value.data.items[0];
+      return first ? previewText(`${redisBlobRawText(first.field)} ${redisBlobRawText(first.value)}`) : "";
+    }
+    case "zset": {
+      const first = value.data.items[0];
+      return first ? previewText(`${first.score} ${redisBlobRawText(first.member)}`) : "";
+    }
+    case "stream": {
+      const first = value.data.entries[0];
+      if (!first) return "";
+      const joined = first.fields.map(({ field, value: entryValue }) => `${field} ${entryValue}`).join(" ");
+      return previewText(joined);
+    }
+    default:
+      return "";
+  }
+}
+
+export function redisValueCopyText(value: RedisValue, collectionItems: RedisCollectionItem[] = redisValueCollectionItems(value)): string {
+  switch (value.data.kind) {
+    case "string":
+      return redisBlobRawText(value.data.content);
+    case "json":
+      return JSON.stringify(value.data.value, null, 2);
+    case "list":
+      return JSON.stringify(
+        (collectionItems as RedisListItem[]).map((item) => redisBlobRawText(item.value)),
+        null,
+        2,
+      );
+    case "set":
+      return JSON.stringify(
+        (collectionItems as RedisSetItem[]).map((item) => redisBlobRawText(item.member)),
+        null,
+        2,
+      );
+    case "hash":
+      return JSON.stringify(
+        (collectionItems as RedisHashItem[]).map((item) => ({
+          field: redisBlobRawText(item.field),
+          value: redisBlobRawText(item.value),
+        })),
+        null,
+        2,
+      );
+    case "zset":
+      return JSON.stringify(
+        (collectionItems as RedisZsetItem[]).map((item) => ({
+          score: item.score,
+          member: redisBlobRawText(item.member),
+        })),
+        null,
+        2,
+      );
+    case "stream":
+      return JSON.stringify(
+        value.data.entries.map((entry) => ({
+          id: entry.id,
+          fields: entry.fields.map((field) => ({
+            field: field.field,
+            value: field.value,
+          })),
+        })),
+        null,
+        2,
+      );
+    default:
+      return JSON.stringify(value.data, null, 2);
+  }
+}
+
+export function sanitizeRedisDisplayText(value: string): string {
+  let output = "";
+  for (const ch of value) {
+    if (ch === "\n" || ch === "\r" || ch === "\t") {
+      output += ch;
+      continue;
+    }
+    if (ch >= " " && ch !== "\u007f" && !isUtf8ControlCharacter(ch)) {
+      output += ch;
+    }
+  }
+  return output;
+}
+
+export function highlightRedisJsonDetail(json: string): string {
+  const escaped = json.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+  return escaped.replace(/("(?:\\u[a-fA-F0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(?:true|false|null)\b|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)/g, (match) => {
+    let cls = "json-number";
+    if (match.startsWith('"')) cls = match.endsWith(":") ? "json-key" : "json-string";
+    else if (match === "true" || match === "false") cls = "json-boolean";
+    else if (match === "null") cls = "json-null";
+    return `<span class="${cls}">${match}</span>`;
+  });
+}
+
+function formatRedisBlobDetail(blob: RedisBlob, options: RedisMemberDetailOptions): RedisMemberDetail {
+  const bytes = decodeRedisBlob(blob);
+  const strictUtf8Text = blob.encoding === "binary" ? null : decodeUtf8Bytes(bytes);
+  const utf8Text = strictUtf8Text ?? decodeUtf8BytesLossy(bytes);
+  const asciiText = asciiBytesToText(bytes);
+  const binaryText = binaryBytesToText(bytes);
+  const rawText = strictUtf8Text ?? binaryText;
+  const javaSerialized = parseJavaSerializedDetail(bytes);
+  const defaultFormat: RedisValueFormat = javaSerialized ? "javaserialize" : strictUtf8Text != null ? "utf8" : "hex";
+  const json = options.allowJsonText && strictUtf8Text != null ? (parseRedisJsonDetail(strictUtf8Text) ?? undefined) : undefined;
+  const textFormats: RedisValueFormat[] = strictUtf8Text != null ? ["utf8", "ascii", "binary"] : ["binary"];
+  const extraFormats: RedisValueFormat[] = [];
+  if (json) extraFormats.push("json");
+  if (javaSerialized) extraFormats.push("javaserialize");
+  return {
+    text: redisBlobDisplayText(blob),
+    rawText,
+    rawLabel: blob.encoding === "binary" ? "Binary" : isAsciiBytes(bytes) ? "ASCII" : "UTF-8",
+    utf8Text,
+    asciiText,
+    binaryText,
+    format: "text",
+    json,
+    javaSerialized: javaSerialized ?? undefined,
+    availableFormats: formatOrderForValue(defaultFormat, textFormats, extraFormats),
+    defaultFormat,
+    byteCount: bytes.byteLength,
+    base64Text: blob.raw_base64,
+    hexRows: buildBinaryHexViewRows(bytes),
+    editable: strictUtf8Text != null,
+    binary: strictUtf8Text == null,
+  };
+}
+
+function formatRedisJsonString(value: string): string | null {
+  return parseRedisJsonDetail(value)?.formattedText ?? null;
+}
+
+function formatOrderForValue(defaultFormat: RedisValueFormat, textFormats: RedisValueFormat[], extraFormats: RedisValueFormat[]): RedisValueFormat[] {
+  const availableFormats: RedisValueFormat[] = [...textFormats];
+  availableFormats.push(...extraFormats);
+  availableFormats.push("hex", "base64");
+  return [defaultFormat, ...availableFormats.filter((format) => format !== defaultFormat)];
+}
+
+function shouldReuseRedisValueFormatPreference(detail: RedisMemberDetail, format: RedisValueFormat): boolean {
+  if (!detail.editable) return true;
+  return format === "utf8" || format === "json";
+}
+
+function previewText(value: string): string {
+  const singleLine = value.replace(/\s+/g, " ").trim();
+  return singleLine.length > 160 ? `${singleLine.slice(0, 160)}…` : singleLine;
+}
+
+function isUtf8ControlCharacter(ch: string): boolean {
+  return /\p{Cc}/u.test(ch);
+}
+
+function escapeRedisBytes(bytes: Uint8Array): string {
+  let output = "";
+  for (const byte of bytes) {
+    if (byte === 0x5c) {
+      output += "\\\\";
+      continue;
+    }
+    if (byte >= 0x20 && byte <= 0x7e) {
+      output += String.fromCharCode(byte);
+      continue;
+    }
+    output += `\\x${byte.toString(16).padStart(2, "0")}`;
+  }
+  return output;
+}
+
+function decodeUtf8Bytes(bytes: Uint8Array): string | null {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return null;
+  }
+}
+
+function decodeUtf8BytesLossy(bytes: Uint8Array): string {
+  return new TextDecoder("utf-8").decode(bytes);
+}
+
+function asciiBytesToText(bytes: Uint8Array): string {
+  let output = "";
+  for (const byte of bytes) {
+    if (byte === 0x0a) {
+      output += "\n";
+      continue;
+    }
+    if (byte === 0x0d) {
+      output += "\r";
+      continue;
+    }
+    if (byte === 0x09) {
+      output += "\t";
+      continue;
+    }
+    if (byte >= 0x20 && byte <= 0x7e) {
+      output += String.fromCharCode(byte);
+      continue;
+    }
+    output += `\\x${byte.toString(16).padStart(2, "0")}`;
+  }
+  return output;
+}
+
+function binaryBytesToText(bytes: Uint8Array): string {
+  return Array.from(bytes, (byte) => byte.toString(2).padStart(8, "0")).join("");
+}
+
+function base64ToBytes(value: string): Uint8Array {
+  if (typeof atob !== "function") throw new Error("Base64 decoding is unavailable in this runtime");
+  const binary = atob(value);
+  return Uint8Array.from(binary, (char) => char.charCodeAt(0));
+}
+
+function bytesToBase64(bytes: Uint8Array): string {
+  if (typeof btoa !== "function") throw new Error("Base64 encoding is unavailable in this runtime");
+  let binary = "";
+  bytes.forEach((byte) => {
+    binary += String.fromCharCode(byte);
+  });
+  return btoa(binary);
+}
+
+function isAsciiBytes(bytes: Uint8Array): boolean {
+  return bytes.every((byte) => byte <= 0x7f);
+}
diff --git a/apps/desktop/src/lib/savedSql/savedSqlFileName.ts b/apps/desktop/src/lib/savedSql/savedSqlFileName.ts
new file mode 100644
index 0000000..9cca7f9
--- /dev/null
+++ b/apps/desktop/src/lib/savedSql/savedSqlFileName.ts
@@ -0,0 +1,9 @@
+export function ensureSqlExtension(name: string): string {
+  const trimmed = name.trim();
+  if (!trimmed) return trimmed;
+  return /\.sql$/i.test(trimmed) ? trimmed : `${trimmed}.sql`;
+}
+
+export function stripSqlExtension(name: string): string {
+  return name.replace(/\.sql$/i, "");
+}
diff --git a/apps/desktop/src/lib/savedSql/savedSqlFolderCounts.ts b/apps/desktop/src/lib/savedSql/savedSqlFolderCounts.ts
new file mode 100644
index 0000000..5d98ced
--- /dev/null
+++ b/apps/desktop/src/lib/savedSql/savedSqlFolderCounts.ts
@@ -0,0 +1,23 @@
+export interface SavedSqlFolderCountNode {
+  id: string;
+  parentFolderId?: string;
+}
+
+export function savedSqlFolderBranchFileCount(folderId: string, folders: readonly SavedSqlFolderCountNode[], filesInFolder: (folderId: string) => readonly unknown[]): number {
+  const visited = new Set<string>();
+
+  const count = (currentFolderId: string): number => {
+    if (visited.has(currentFolderId)) return 0;
+    visited.add(currentFolderId);
+
+    let total = filesInFolder(currentFolderId).length;
+    for (const child of folders) {
+      if ((child.parentFolderId || "") === currentFolderId) {
+        total += count(child.id);
+      }
+    }
+    return total;
+  };
+
+  return count(folderId);
+}
diff --git a/apps/desktop/src/lib/savedSql/savedSqlHistory.ts b/apps/desktop/src/lib/savedSql/savedSqlHistory.ts
new file mode 100644
index 0000000..66339bf
--- /dev/null
+++ b/apps/desktop/src/lib/savedSql/savedSqlHistory.ts
@@ -0,0 +1,81 @@
+import type { SavedSqlFile } from "@/types/database";
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const RECENCY_WINDOW_MS = 30 * DAY_MS;
+
+export interface SavedSqlHistoryScope {
+  connectionId?: string;
+  database?: string;
+  schema?: string;
+  tableName?: string;
+  limit?: number;
+  now?: number;
+}
+
+function timestamp(value?: string) {
+  if (!value) return 0;
+  const time = Date.parse(value);
+  return Number.isFinite(time) ? time : 0;
+}
+
+function normalize(value?: string) {
+  return (value || "").trim().toLowerCase();
+}
+
+function containsToken(text: string | undefined, token: string) {
+  const normalizedText = normalize(text);
+  const normalizedToken = normalize(token);
+  if (!normalizedText || !normalizedToken) return false;
+  return normalizedText.includes(normalizedToken);
+}
+
+function scopeRelevance(file: SavedSqlFile, scope: SavedSqlHistoryScope) {
+  let score = 0;
+  if (scope.database != null && file.database === scope.database) score += 100;
+  if (scope.schema && file.schema === scope.schema) score += 30;
+  if (scope.tableName) {
+    const schemaTable = scope.schema ? `${scope.schema}.${scope.tableName}` : "";
+    if (containsToken(file.name, scope.tableName) || containsToken(file.sql, scope.tableName)) score += 80;
+    if (schemaTable && (containsToken(file.name, schemaTable) || containsToken(file.sql, schemaTable))) score += 40;
+  }
+  return score;
+}
+
+export function savedSqlHistoryScore(file: SavedSqlFile, now = Date.now()) {
+  const openCount = Math.max(0, file.openCount ?? 0);
+  const openedAt = timestamp(file.openedAt);
+  const age = openedAt > 0 ? Math.max(0, now - openedAt) : RECENCY_WINDOW_MS;
+  const recency = openedAt > 0 ? Math.max(0, 1 - age / RECENCY_WINDOW_MS) : 0;
+  return openCount * 1000 + recency * 999;
+}
+
+export function savedSqlMatchesHistoryScope(file: SavedSqlFile, scope: SavedSqlHistoryScope) {
+  if (scope.connectionId && file.connectionId !== scope.connectionId) return false;
+  if (scope.database != null && file.database !== scope.database) return false;
+  if (scope.schema && file.schema && file.schema !== scope.schema) return false;
+  return true;
+}
+
+export function rankSavedSqlHistory(files: SavedSqlFile[], scope: SavedSqlHistoryScope = {}) {
+  const now = scope.now ?? Date.now();
+  const ranked = files
+    .filter((file) => savedSqlMatchesHistoryScope(file, scope))
+    .map((file) => ({
+      file,
+      score: scopeRelevance(file, scope) + savedSqlHistoryScore(file, now),
+      openedAt: timestamp(file.openedAt),
+      updatedAt: timestamp(file.updatedAt),
+    }))
+    .sort((a, b) => {
+      const scoreDiff = b.score - a.score;
+      if (scoreDiff !== 0) return scoreDiff;
+      const openedDiff = b.openedAt - a.openedAt;
+      if (openedDiff !== 0) return openedDiff;
+      const updatedDiff = b.updatedAt - a.updatedAt;
+      if (updatedDiff !== 0) return updatedDiff;
+      return a.file.name.localeCompare(b.file.name, undefined, { numeric: true, sensitivity: "base" });
+    })
+    .map((item) => item.file);
+
+  return typeof scope.limit === "number" ? ranked.slice(0, Math.max(0, scope.limit)) : ranked;
+}
diff --git a/apps/desktop/src/lib/schema/schemaDiff.ts b/apps/desktop/src/lib/schema/schemaDiff.ts
new file mode 100644
index 0000000..2bd7f7b
--- /dev/null
+++ b/apps/desktop/src/lib/schema/schemaDiff.ts
@@ -0,0 +1,507 @@
+import type { ColumnInfo, IndexInfo, ForeignKeyInfo, TriggerInfo, FunctionInfo, SequenceInfo, RuleInfo, OwnerInfo, DatabaseType, TableInfo } from "@/types/database";
+
+export interface ColumnDiff {
+  type: "added" | "removed" | "modified";
+  name: string;
+  source?: ColumnInfo;
+  target?: ColumnInfo;
+  changes?: string[];
+}
+
+export interface IndexDiff {
+  type: "added" | "removed" | "modified";
+  name: string;
+  source?: IndexInfo;
+  target?: IndexInfo;
+  changes?: string[];
+}
+
+export interface ForeignKeyDiff {
+  type: "added" | "removed" | "modified";
+  name: string;
+  source?: ForeignKeyInfo;
+  target?: ForeignKeyInfo;
+  changes?: string[];
+}
+
+export interface TriggerDiff {
+  type: "added" | "removed" | "modified";
+  name: string;
+  source?: TriggerInfo;
+  target?: TriggerInfo;
+  changes?: string[];
+}
+
+export interface FunctionDiff {
+  type: "added" | "removed" | "modified";
+  name: string;
+  source?: FunctionInfo;
+  target?: FunctionInfo;
+  changes?: string[];
+}
+
+export interface SequenceDiff {
+  type: "added" | "removed" | "modified";
+  name: string;
+  source?: SequenceInfo;
+  target?: SequenceInfo;
+  changes?: string[];
+}
+
+export interface RuleDiff {
+  type: "added" | "removed" | "modified";
+  name: string;
+  source?: RuleInfo;
+  target?: RuleInfo;
+  changes?: string[];
+}
+
+export interface OwnerDiff {
+  type: "added" | "removed" | "modified";
+  objectName: string;
+  source?: OwnerInfo;
+  target?: OwnerInfo;
+  changes?: string[];
+}
+
+export interface TableDiff {
+  type: "added" | "removed" | "modified";
+  objectType?: "table" | "view";
+  name: string;
+  columns?: ColumnDiff[];
+  indexes?: IndexDiff[];
+  foreignKeys?: ForeignKeyDiff[];
+  triggers?: TriggerDiff[];
+  ddl?: string;
+  targetDdl?: string;
+  sourceTableComment?: string | null;
+  targetTableComment?: string | null;
+  syncSql?: string;
+}
+
+export interface TableSchemaDetail {
+  name: string;
+  columns?: ColumnInfo[];
+  indexes?: IndexInfo[];
+  foreignKeys?: ForeignKeyInfo[];
+  triggers?: TriggerInfo[];
+  ddl?: string;
+}
+
+export interface SchemaDiffPreparationOptions {
+  sourceTables: TableInfo[];
+  targetTables: TableInfo[];
+  sourceDetails: TableSchemaDetail[];
+  targetDetails: TableSchemaDetail[];
+  sourceFunctions?: FunctionInfo[];
+  targetFunctions?: FunctionInfo[];
+  sourceSequences?: SequenceInfo[];
+  targetSequences?: SequenceInfo[];
+  sourceRules?: RuleInfo[];
+  targetRules?: RuleInfo[];
+  sourceOwners?: OwnerInfo[];
+  targetOwners?: OwnerInfo[];
+  databaseType: DatabaseType;
+  targetSchema?: string;
+  ignoreComments?: boolean;
+  cascadeDelete?: boolean;
+  compareColumnOrder?: boolean;
+}
+
+export interface SchemaDiffPreparation {
+  diffs: TableDiff[];
+  functionDiffs?: FunctionDiff[];
+  sequenceDiffs?: SequenceDiff[];
+  ruleDiffs?: RuleDiff[];
+  ownerDiffs?: OwnerDiff[];
+  syncSql: string;
+}
+
+const MYSQL_LIKE_SCHEMA_DIFF_TARGET_TYPES = new Set<DatabaseType>(["mysql", "doris", "starrocks", "goldendb", "sundb", "databend", "gbase"]);
+
+export function schemaDiffDeployTargetSchema(databaseType: DatabaseType | undefined, targetDatabase: string, targetSchema?: string): string | undefined {
+  const schema = targetSchema?.trim();
+  if (schema) return schema;
+
+  const database = targetDatabase.trim();
+  if (databaseType && MYSQL_LIKE_SCHEMA_DIFF_TARGET_TYPES.has(databaseType) && database) {
+    return database;
+  }
+
+  return undefined;
+}
+
+// Unified object type for UI display
+export type DiffOperationType = "modify" | "create" | "delete" | "none";
+export type DiffObjectKind = "table" | "view" | "function" | "sequence" | "rule" | "owner" | "index" | "trigger" | "foreignKey";
+
+export interface SchemaDiffObject {
+  id: string;
+  operationType: DiffOperationType;
+  objectKind: DiffObjectKind;
+  name: string;
+  sourceName?: string;
+  targetName?: string;
+  selected: boolean;
+  sourceDdl?: string;
+  targetDdl?: string;
+  deploySql?: string;
+  changes?: string[];
+  children?: SchemaDiffObject[];
+  /** Function arguments signature (for PostgreSQL overloaded functions) */
+  arguments?: string;
+}
+
+export interface SchemaDiffGroup {
+  operationType: DiffOperationType;
+  label: string;
+  count: number;
+  selectedCount: number;
+  expanded: boolean;
+  objects: SchemaDiffObject[];
+}
+
+export function getOperationType(diffType: string): DiffOperationType {
+  switch (diffType) {
+    case "modified":
+      return "modify";
+    case "added":
+      return "create";
+    case "removed":
+      return "delete";
+    default:
+      return "none";
+  }
+}
+
+export function getOperationLabel(operationType: DiffOperationType): string {
+  switch (operationType) {
+    case "modify":
+      return "diff.operationLabel.modify";
+    case "create":
+      return "diff.operationLabel.create";
+    case "delete":
+      return "diff.operationLabel.delete";
+    case "none":
+      return "diff.operationLabel.none";
+  }
+}
+
+function buildSequenceDdl(seq: SequenceInfo): string {
+  const parts = [`CREATE SEQUENCE ${seq.name}`];
+  if (seq.data_type) parts.push(`    AS ${seq.data_type}`);
+  if (seq.start_value != null) parts.push(`    START WITH ${seq.start_value}`);
+  if (seq.increment != null) parts.push(`    INCREMENT BY ${seq.increment}`);
+  if (seq.min_value != null) parts.push(`    MINVALUE ${seq.min_value}`);
+  if (seq.max_value != null) parts.push(`    MAXVALUE ${seq.max_value}`);
+  else parts.push(`    NO MAXVALUE`);
+  parts.push(`    ${seq.cycle ? "" : "NO "}CYCLE`);
+  parts.push(`;`);
+  if (seq.last_value != null) {
+    parts.push(`SELECT setval('${seq.name}', ${seq.last_value});`);
+  }
+  return parts.join("\n");
+}
+
+export function convertToSchemaDiffObjects(tableDiffs: TableDiff[], functionDiffs: FunctionDiff[] = [], sequenceDiffs: SequenceDiff[] = [], ruleDiffs: RuleDiff[] = [], ownerDiffs: OwnerDiff[] = []): SchemaDiffObject[] {
+  const objects: SchemaDiffObject[] = [];
+
+  for (const diff of tableDiffs) {
+    const opType = getOperationType(diff.type);
+    const obj: SchemaDiffObject = {
+      id: `table-${diff.name}`,
+      operationType: opType,
+      objectKind: diff.objectType === "view" ? "view" : "table",
+      name: diff.name,
+      sourceName: diff.type === "added" ? undefined : diff.name,
+      targetName: diff.type === "removed" ? undefined : diff.name,
+      selected: opType !== "none",
+      sourceDdl: diff.ddl,
+      targetDdl: diff.targetDdl,
+      deploySql: diff.syncSql,
+      changes: diff.columns?.flatMap((c) => c.changes || []),
+      children: [
+        ...(diff.columns?.map((c) => ({
+          id: `col-${diff.name}-${c.name}`,
+          operationType: getOperationType(c.type),
+          objectKind: "table" as DiffObjectKind,
+          name: c.name,
+          sourceName: c.type === "added" ? undefined : c.name,
+          targetName: c.type === "removed" ? undefined : c.name,
+          selected: opType !== "none",
+          changes: c.changes,
+        })) || []),
+        ...(diff.indexes?.map((i) => ({
+          id: `idx-${diff.name}-${i.name}`,
+          operationType: getOperationType(i.type),
+          objectKind: "index" as DiffObjectKind,
+          name: i.name,
+          sourceName: i.type === "added" ? undefined : i.name,
+          targetName: i.type === "removed" ? undefined : i.name,
+          selected: opType !== "none",
+          changes: i.changes,
+        })) || []),
+        ...(diff.foreignKeys?.map((f) => ({
+          id: `fk-${diff.name}-${f.name}`,
+          operationType: getOperationType(f.type),
+          objectKind: "foreignKey" as DiffObjectKind,
+          name: f.name,
+          sourceName: f.type === "added" ? undefined : f.name,
+          targetName: f.type === "removed" ? undefined : f.name,
+          selected: opType !== "none",
+          changes: f.changes,
+        })) || []),
+        ...(diff.triggers?.map((t) => ({
+          id: `trg-${diff.name}-${t.name}`,
+          operationType: getOperationType(t.type),
+          objectKind: "trigger" as DiffObjectKind,
+          name: t.name,
+          sourceName: t.type === "added" ? undefined : t.name,
+          targetName: t.type === "removed" ? undefined : t.name,
+          selected: opType !== "none",
+          changes: t.changes,
+        })) || []),
+      ],
+    };
+    objects.push(obj);
+  }
+
+  for (const diff of functionDiffs) {
+    const args = diff.source?.arguments || diff.target?.arguments || "";
+    objects.push({
+      id: `func-${diff.name}-${args}`,
+      operationType: getOperationType(diff.type),
+      objectKind: "function",
+      name: diff.name,
+      arguments: args,
+      sourceName: diff.type === "added" ? undefined : diff.name,
+      targetName: diff.type === "removed" ? undefined : diff.name,
+      selected: true,
+      sourceDdl: diff.source?.definition,
+      targetDdl: diff.target?.definition,
+      changes: diff.changes,
+    });
+  }
+
+  for (const diff of sequenceDiffs) {
+    objects.push({
+      id: `seq-${diff.name}`,
+      operationType: getOperationType(diff.type),
+      objectKind: "sequence",
+      name: diff.name,
+      sourceName: diff.type === "added" ? undefined : diff.name,
+      targetName: diff.type === "removed" ? undefined : diff.name,
+      selected: true,
+      sourceDdl: diff.source ? buildSequenceDdl(diff.source) : undefined,
+      targetDdl: diff.target ? buildSequenceDdl(diff.target) : undefined,
+      changes: diff.changes,
+    });
+  }
+
+  for (const diff of ruleDiffs) {
+    objects.push({
+      id: `rule-${diff.name}`,
+      operationType: getOperationType(diff.type),
+      objectKind: "rule",
+      name: diff.name,
+      sourceName: diff.type === "added" ? undefined : diff.name,
+      targetName: diff.type === "removed" ? undefined : diff.name,
+      selected: true,
+      changes: diff.changes,
+    });
+  }
+
+  for (const diff of ownerDiffs) {
+    objects.push({
+      id: `owner-${diff.objectName}`,
+      operationType: getOperationType(diff.type),
+      objectKind: "owner",
+      name: diff.objectName,
+      sourceName: diff.type === "added" ? undefined : diff.objectName,
+      targetName: diff.type === "removed" ? undefined : diff.objectName,
+      selected: true,
+      changes: diff.changes,
+    });
+  }
+
+  return objects;
+}
+
+export function buildDeploySqlForObjects(objects: SchemaDiffObject[]): string {
+  const selected = objects.filter((o) => {
+    const isTopLevel = !o.id.startsWith("col-") && !o.id.startsWith("idx-") && !o.id.startsWith("fk-") && !o.id.startsWith("trg-");
+    return o.selected && o.operationType !== "none" && isTopLevel;
+  });
+
+  if (selected.length === 0) {
+    return "-- No objects selected";
+  }
+
+  const lines: string[] = [];
+
+  for (const obj of selected) {
+    if (obj.deploySql?.trim()) {
+      lines.push(obj.deploySql.trim());
+      lines.push("");
+      continue;
+    }
+
+    if (obj.operationType === "create") {
+      if (obj.sourceDdl) {
+        lines.push(`-- Create ${obj.objectKind}: ${obj.name}`);
+        lines.push(obj.sourceDdl);
+        lines.push("");
+      }
+    } else if (obj.operationType === "delete") {
+      lines.push(`-- Drop ${obj.objectKind}: ${obj.name}`);
+      const dropSql = generateDropSql(obj);
+      lines.push(dropSql);
+      lines.push("");
+    } else if (obj.operationType === "modify") {
+      if (obj.sourceDdl) {
+        lines.push(`-- Modify ${obj.objectKind}: ${obj.name}`);
+        lines.push(obj.sourceDdl);
+        lines.push("");
+      }
+    }
+  }
+
+  return lines.join("\n") || "-- No DDL available for selected objects";
+}
+
+function generateDropSql(obj: SchemaDiffObject): string {
+  const typeMap: Record<string, string> = {
+    table: "TABLE",
+    view: "VIEW",
+    function: "FUNCTION",
+    sequence: "SEQUENCE",
+    rule: "RULE",
+    owner: "OWNED BY",
+  };
+  const sqlType = typeMap[obj.objectKind] || obj.objectKind.toUpperCase();
+  return `DROP ${sqlType} IF EXISTS ${obj.name};`;
+}
+
+export interface ObjectTypeGroup {
+  kind: DiffObjectKind;
+  label: string;
+  objects: SchemaDiffObject[];
+  expanded: boolean;
+  selectedCount: number;
+}
+
+export interface OperationGroup {
+  operationType: DiffOperationType;
+  label: string;
+  count: number;
+  selectedCount: number;
+  expanded: boolean;
+  typeGroups: ObjectTypeGroup[];
+}
+
+export function groupDiffObjects(objects: SchemaDiffObject[]): OperationGroup[] {
+  const groups: Record<DiffOperationType, Record<DiffObjectKind, SchemaDiffObject[]>> = {
+    modify: {
+      table: [],
+      view: [],
+      function: [],
+      sequence: [],
+      rule: [],
+      owner: [],
+      index: [],
+      foreignKey: [],
+      trigger: [],
+    },
+    create: {
+      table: [],
+      view: [],
+      function: [],
+      sequence: [],
+      rule: [],
+      owner: [],
+      index: [],
+      foreignKey: [],
+      trigger: [],
+    },
+    delete: {
+      table: [],
+      view: [],
+      function: [],
+      sequence: [],
+      rule: [],
+      owner: [],
+      index: [],
+      foreignKey: [],
+      trigger: [],
+    },
+    none: {
+      table: [],
+      view: [],
+      function: [],
+      sequence: [],
+      rule: [],
+      owner: [],
+      index: [],
+      foreignKey: [],
+      trigger: [],
+    },
+  };
+
+  for (const obj of objects) {
+    groups[obj.operationType][obj.objectKind].push(obj);
+  }
+
+  const order: DiffOperationType[] = ["modify", "create", "delete", "none"];
+  return order.map((opType) => {
+    const typeGroups: ObjectTypeGroup[] = [];
+    const kinds: DiffObjectKind[] = ["table", "view", "function", "sequence", "rule", "owner", "index", "foreignKey", "trigger"];
+
+    for (const kind of kinds) {
+      const objs = groups[opType][kind];
+      if (objs.length > 0) {
+        typeGroups.push({
+          kind,
+          label: getObjectTypeLabel(kind),
+          objects: objs,
+          expanded: true,
+          selectedCount: objs.filter((o) => o.selected).length,
+        });
+      }
+    }
+
+    const allObjects = Object.values(groups[opType]).flat();
+    return {
+      operationType: opType,
+      label: getOperationLabel(opType),
+      count: allObjects.length,
+      selectedCount: allObjects.filter((o) => o.selected).length,
+      expanded: opType !== "none",
+      typeGroups,
+    };
+  });
+}
+
+function getObjectTypeLabel(kind: DiffObjectKind): string {
+  switch (kind) {
+    case "table":
+      return "diff.objectKindLabel.table";
+    case "view":
+      return "diff.objectKindLabel.view";
+    case "function":
+      return "diff.objectKindLabel.function";
+    case "sequence":
+      return "diff.objectKindLabel.sequence";
+    case "rule":
+      return "diff.objectKindLabel.rule";
+    case "owner":
+      return "diff.objectKindLabel.owner";
+    case "index":
+      return "diff.objectKindLabel.index";
+    case "foreignKey":
+      return "diff.objectKindLabel.foreignKey";
+    case "trigger":
+      return "diff.objectKindLabel.trigger";
+    default:
+      return kind;
+  }
+}
diff --git a/apps/desktop/src/lib/schema/schemaDiffMetadataLoad.ts b/apps/desktop/src/lib/schema/schemaDiffMetadataLoad.ts
new file mode 100644
index 0000000..8973ffc
--- /dev/null
+++ b/apps/desktop/src/lib/schema/schemaDiffMetadataLoad.ts
@@ -0,0 +1,83 @@
+const MYSQL_LARGE_SCHEMA_DIFF_METADATA_CONCURRENCY = 2;
+const MYSQL_SMALL_SCHEMA_DIFF_METADATA_CONCURRENCY = 4;
+const MYSQL_SMALL_SCHEMA_TABLE_LIMIT = 30;
+const DEFAULT_SCHEMA_DIFF_METADATA_CONCURRENCY = 6;
+
+function normalizeConcurrencyLimit(limit: number): number {
+  return Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 1;
+}
+
+export function schemaDiffMetadataConcurrency(dbType: string | null | undefined, tableCount?: number): number {
+  const normalizedDbType = (dbType || "").toLowerCase();
+  if (normalizedDbType === "mysql" || normalizedDbType === "mariadb") {
+    if (typeof tableCount === "number" && tableCount <= MYSQL_SMALL_SCHEMA_TABLE_LIMIT) {
+      return MYSQL_SMALL_SCHEMA_DIFF_METADATA_CONCURRENCY;
+    }
+    return MYSQL_LARGE_SCHEMA_DIFF_METADATA_CONCURRENCY;
+  }
+  return DEFAULT_SCHEMA_DIFF_METADATA_CONCURRENCY;
+}
+
+export async function mapWithConcurrency<T, R>(items: readonly T[], limit: number, worker: (item: T, index: number) => Promise<R>): Promise<R[]> {
+  const workerCount = Math.min(normalizeConcurrencyLimit(limit), items.length);
+  if (workerCount === 0) return [];
+
+  const results: R[] = [];
+  let nextIndex = 0;
+  let hasError = false;
+  let firstError: unknown;
+
+  async function runWorker() {
+    while (!hasError) {
+      const index = nextIndex++;
+      if (index >= items.length) return;
+
+      try {
+        results[index] = await worker(items[index], index);
+      } catch (error) {
+        hasError = true;
+        firstError = error;
+        return;
+      }
+    }
+  }
+
+  await Promise.all(Array.from({ length: workerCount }, runWorker));
+  if (hasError) throw firstError;
+  return results;
+}
+
+export function createConcurrencyLimiter(limit: number) {
+  const maxActive = normalizeConcurrencyLimit(limit);
+  let active = 0;
+  const queue: Array<() => void> = [];
+
+  async function acquire() {
+    if (active < maxActive) {
+      active += 1;
+      return;
+    }
+
+    await new Promise<void>((resolve) => {
+      queue.push(() => {
+        active += 1;
+        resolve();
+      });
+    });
+  }
+
+  function release() {
+    active = Math.max(0, active - 1);
+    const next = queue.shift();
+    if (next) next();
+  }
+
+  return async function runLimited<T>(task: () => Promise<T>): Promise<T> {
+    await acquire();
+    try {
+      return await task();
+    } finally {
+      release();
+    }
+  };
+}
diff --git a/apps/desktop/src/lib/schema/schemaDiffOptions.ts b/apps/desktop/src/lib/schema/schemaDiffOptions.ts
new file mode 100644
index 0000000..45cd115
--- /dev/null
+++ b/apps/desktop/src/lib/schema/schemaDiffOptions.ts
@@ -0,0 +1,60 @@
+import type { BooleanSchemaDiffCompareOptionKey, SchemaDiffCompareOptions, SchemaDiffOptionItem } from "@/types/schemaDiff";
+
+export const POSTGRES_SCHEMA_DIFF_OPTIONS: SchemaDiffOptionItem[] = [
+  {
+    id: "tables",
+    labelKey: "schemaDiff.options.tables",
+    defaultChecked: true,
+    children: [
+      { id: "primaryKeys", labelKey: "schemaDiff.options.primaryKeys", defaultChecked: true },
+      { id: "foreignKeys", labelKey: "schemaDiff.options.foreignKeys", defaultChecked: true },
+      { id: "uniqueKeys", labelKey: "schemaDiff.options.uniqueKeys", defaultChecked: true },
+      { id: "checks", labelKey: "schemaDiff.options.checks", defaultChecked: true },
+      { id: "exclusions", labelKey: "schemaDiff.options.exclusions", defaultChecked: true },
+    ],
+  },
+  { id: "views", labelKey: "schemaDiff.options.views", defaultChecked: true },
+  { id: "functions", labelKey: "schemaDiff.options.functions", defaultChecked: true },
+  { id: "indexes", labelKey: "schemaDiff.options.indexes", defaultChecked: true },
+  { id: "sequences", labelKey: "schemaDiff.options.sequences", defaultChecked: true },
+  { id: "triggers", labelKey: "schemaDiff.options.triggers", defaultChecked: true },
+  { id: "rules", labelKey: "schemaDiff.options.rules", defaultChecked: true },
+  { id: "owners", labelKey: "schemaDiff.options.owners", defaultChecked: true },
+  { id: "cascadeDelete", labelKey: "schemaDiff.options.cascadeDelete", defaultChecked: false },
+  { id: "sequenceLastValues", labelKey: "schemaDiff.options.sequenceLastValues", defaultChecked: true },
+  { id: "compareColumnOrder", labelKey: "schemaDiff.options.compareColumnOrder", defaultChecked: false },
+];
+
+export const SCHEMA_DIFF_OPTIONS_BY_DB_TYPE: Record<string, SchemaDiffOptionItem[]> = {
+  postgres: POSTGRES_SCHEMA_DIFF_OPTIONS,
+  opengauss: POSTGRES_SCHEMA_DIFF_OPTIONS,
+  // mysql: [...] 后续扩展
+  // sqlserver: [...] 后续扩展
+};
+
+export function getSchemaDiffOptionsForDbType(dbType: string): SchemaDiffOptionItem[] {
+  return SCHEMA_DIFF_OPTIONS_BY_DB_TYPE[dbType] ?? POSTGRES_SCHEMA_DIFF_OPTIONS;
+}
+
+export function getOptionIdsFromTree(items: SchemaDiffOptionItem[]): BooleanSchemaDiffCompareOptionKey[] {
+  const ids: BooleanSchemaDiffCompareOptionKey[] = [];
+  for (const item of items) {
+    ids.push(item.id);
+    if (item.children) {
+      ids.push(...getOptionIdsFromTree(item.children));
+    }
+  }
+  return ids;
+}
+
+export function buildDefaultOptionsFromTree(items: SchemaDiffOptionItem[]): SchemaDiffCompareOptions {
+  const options = {} as SchemaDiffCompareOptions;
+  for (const item of items) {
+    options[item.id] = item.defaultChecked as never;
+    if (item.children) {
+      const childDefaults = buildDefaultOptionsFromTree(item.children);
+      Object.assign(options, childDefaults);
+    }
+  }
+  return options;
+}
diff --git a/apps/desktop/src/lib/schema/schemaDiffTableFilter.ts b/apps/desktop/src/lib/schema/schemaDiffTableFilter.ts
new file mode 100644
index 0000000..07f38cb
--- /dev/null
+++ b/apps/desktop/src/lib/schema/schemaDiffTableFilter.ts
@@ -0,0 +1,49 @@
+import type { TableInfo } from "@/types/database";
+import type { SchemaDiffCompareOptions } from "@/types/schemaDiff";
+
+export interface CompiledSchemaDiffTableFilter {
+  include?: RegExp;
+  exclude?: RegExp;
+  priority: SchemaDiffCompareOptions["tableFilterPriority"];
+}
+
+export interface FilteredSchemaDiffTables {
+  sourceTables: TableInfo[];
+  targetTables: TableInfo[];
+}
+
+function compilePattern(pattern: string, label: "include" | "exclude"): RegExp | undefined {
+  const trimmed = pattern.trim();
+  if (!trimmed) return undefined;
+  try {
+    return new RegExp(trimmed);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid ${label} table name regex: ${message}`);
+  }
+}
+
+export function compileSchemaDiffTableFilter(options: SchemaDiffCompareOptions): CompiledSchemaDiffTableFilter {
+  return {
+    include: compilePattern(options.tableIncludePattern, "include"),
+    exclude: compilePattern(options.tableExcludePattern, "exclude"),
+    priority: options.tableFilterPriority,
+  };
+}
+
+export function matchesSchemaDiffTableFilter(tableName: string, filter: CompiledSchemaDiffTableFilter): boolean {
+  const includeMatches = filter.include ? filter.include.test(tableName) : true;
+  const excludeMatches = filter.exclude ? filter.exclude.test(tableName) : false;
+
+  if (filter.include && filter.exclude && includeMatches && excludeMatches) {
+    return filter.priority === "include";
+  }
+  return includeMatches && !excludeMatches;
+}
+
+export function filterSchemaDiffTables(sourceTables: TableInfo[], targetTables: TableInfo[], filter: CompiledSchemaDiffTableFilter): FilteredSchemaDiffTables {
+  return {
+    sourceTables: sourceTables.filter((table) => matchesSchemaDiffTableFilter(table.name, filter)),
+    targetTables: targetTables.filter((table) => matchesSchemaDiffTableFilter(table.name, filter)),
+  };
+}
diff --git a/apps/desktop/src/lib/settings/editorSettingsDraft.ts b/apps/desktop/src/lib/settings/editorSettingsDraft.ts
new file mode 100644
index 0000000..3799094
--- /dev/null
+++ b/apps/desktop/src/lib/settings/editorSettingsDraft.ts
@@ -0,0 +1,87 @@
+import type { EditorSettings } from "@/stores/settingsStore";
+
+export const EDITOR_SETTINGS_DRAFT_KEYS = [
+  "fontFamily",
+  "fontSize",
+  "uiFontFamily",
+  "uiScale",
+  "theme",
+  "customThemes",
+  "activeCustomThemeId",
+  "executeMode",
+  "showExecutionTargetPicker",
+  "showStatementRunButtons",
+  "showCurrentStatementFrame",
+  "showInsertValueHints",
+  "autoAliasTables",
+  "wordWrap",
+  "vimModeEnabled",
+  "autoCloseBrackets",
+  "sqlSemanticDiagnosticsMode",
+  "confirmDangerousSqlExecution",
+  "confirmUnsavedSqlClose",
+  "appLayout",
+  "showColumnCommentsInHeader",
+  "showColumnTypesInHeader",
+  "compactColumnHeaderActions",
+  "dataGridQuickEntry",
+  "infiniteScroll",
+  "infiniteScrollMaxRows",
+  "autoCalculateTotalRows",
+  "tableColumnTemplateFields",
+  "shortcuts",
+  "sqlFormatter",
+  "sidebarActivation",
+  "sidebarObjectDisplay",
+  "sidebarTableSearchEnabled",
+  "autoSelectActiveSidebarNode",
+  "openTabsRestoreMode",
+  "disconnectTabHandlingMode",
+  "reuseDataTab",
+  "updateNotificationsEnabled",
+  "sidebarHideTableComments",
+  "sidebarAllowHorizontalScroll",
+  "sidebarHiddenTablePrefixes",
+  "exportBatchSize",
+  "exportRowLimitEnabled",
+  "exportRowLimit",
+  "queryExportKeysetOptimizationEnabled",
+  "updateDownloadSource",
+  "toolbarItems",
+  "snippets",
+  "sqlVariableSyntaxOverrides",
+] as const satisfies readonly (keyof EditorSettings)[];
+
+export type EditorSettingsDraftKey = (typeof EDITOR_SETTINGS_DRAFT_KEYS)[number];
+export type EditorSettingsDraft = Pick<EditorSettings, EditorSettingsDraftKey>;
+
+function cloneDraftValue<T>(value: T): T {
+  if (value === null || typeof value !== "object") return value;
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+function draftValueChanged(a: unknown, b: unknown): boolean {
+  return JSON.stringify(a) !== JSON.stringify(b);
+}
+
+export function editorSettingsDraftFromSettings(settings: EditorSettings): EditorSettingsDraft {
+  const draft = {} as EditorSettingsDraft;
+  for (const key of EDITOR_SETTINGS_DRAFT_KEYS) {
+    draft[key] = cloneDraftValue(settings[key]) as never;
+  }
+  return draft;
+}
+
+export function editorSettingsPatchFromDraft(draft: EditorSettingsDraft, base: EditorSettingsDraft): Partial<EditorSettings> {
+  const patch: Partial<EditorSettings> = {};
+  for (const key of EDITOR_SETTINGS_DRAFT_KEYS) {
+    if (draftValueChanged(draft[key], base[key])) {
+      patch[key] = cloneDraftValue(draft[key]) as never;
+    }
+  }
+  return patch;
+}
+
+export function editorSettingsDraftChanged(draft: EditorSettingsDraft, base: EditorSettingsDraft): boolean {
+  return EDITOR_SETTINGS_DRAFT_KEYS.some((key) => draftValueChanged(draft[key], base[key]));
+}
diff --git a/apps/desktop/src/lib/sidebar/batchTableEmpty.ts b/apps/desktop/src/lib/sidebar/batchTableEmpty.ts
new file mode 100644
index 0000000..8409721
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/batchTableEmpty.ts
@@ -0,0 +1,39 @@
+export interface BatchTableEmptyResult<T> {
+  succeeded: T[];
+  failed: Array<{ target: T; error: unknown }>;
+}
+
+export interface BatchTableEmptyPlanItem<T> {
+  target: T;
+  sql: string;
+}
+
+export type BatchTableEmptyFeedback = "success" | "partial" | "submitted" | "submitted-partial";
+
+export async function buildBatchTableEmptyPlan<T>(targets: readonly T[], buildSql: (target: T) => Promise<string>): Promise<BatchTableEmptyPlanItem<T>[]> {
+  const plan: BatchTableEmptyPlanItem<T>[] = [];
+  for (const target of targets) {
+    const sql = await buildSql(target);
+    if (!sql.trim()) throw new Error("Empty table SQL preview is unavailable");
+    plan.push({ target, sql });
+  }
+  return plan;
+}
+
+export async function runBatchTableEmpty<T>(targets: readonly T[], execute: (target: T) => Promise<void>): Promise<BatchTableEmptyResult<T>> {
+  const result: BatchTableEmptyResult<T> = { succeeded: [], failed: [] };
+  for (const target of targets) {
+    try {
+      await execute(target);
+      result.succeeded.push(target);
+    } catch (error) {
+      result.failed.push({ target, error });
+    }
+  }
+  return result;
+}
+
+export function batchTableEmptyFeedback(result: BatchTableEmptyResult<unknown>, asynchronousMutation: boolean): BatchTableEmptyFeedback {
+  if (asynchronousMutation) return result.failed.length > 0 ? "submitted-partial" : "submitted";
+  return result.failed.length > 0 ? "partial" : "success";
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarActiveTabTarget.ts b/apps/desktop/src/lib/sidebar/sidebarActiveTabTarget.ts
new file mode 100644
index 0000000..9ae7c70
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarActiveTabTarget.ts
@@ -0,0 +1,262 @@
+import { SIDEBAR_TREE_ROW_HEIGHT, type FlatTreeNode } from "@/composables/useFlatTree";
+import type { QueryTab, TreeNode } from "@/types/database";
+
+export type ActiveTabSidebarTarget =
+  | {
+      type: "table";
+      connectionId: string;
+      database: string;
+      schema?: string;
+      tableName: string;
+    }
+  | {
+      type: "mongo-collection";
+      connectionId: string;
+      database: string;
+      collectionName: string;
+    }
+  | {
+      type: "mongo-gridfs";
+      connectionId: string;
+      database: string;
+    }
+  | {
+      type: "vector-collection";
+      connectionId: string;
+      database: string;
+      collectionName: string;
+    }
+  | {
+      type: "etcd-root";
+      connectionId: string;
+    }
+  | {
+      type: "zookeeper-root";
+      connectionId: string;
+    }
+  | {
+      type: "mq-tenant";
+      connectionId: string;
+      tenant: string;
+    }
+  | {
+      type: "nacos-namespace";
+      connectionId: string;
+      namespace: string;
+    }
+  | {
+      type: "query-context";
+      connectionId: string;
+      database: string;
+      schema?: string;
+    }
+  | {
+      type: "saved-sql-file";
+      savedSqlId: string;
+    };
+
+export function activeTabSidebarTarget(tab: QueryTab | undefined | null): ActiveTabSidebarTarget | null {
+  if (!tab) return null;
+
+  if (tab.mode === "data") {
+    const tableName = tab.tableMeta?.tableName || tab.title;
+    if (!tableName) return null;
+    return {
+      type: "table",
+      connectionId: tab.connectionId,
+      database: tab.database,
+      schema: tab.tableMeta?.schema ?? tab.schema,
+      tableName,
+    };
+  }
+
+  if (tab.mode === "mongo") {
+    const collectionName = tab.sql || tab.title.split(".").pop() || tab.title;
+    if (!collectionName) return null;
+    return {
+      type: "mongo-collection",
+      connectionId: tab.connectionId,
+      database: tab.database,
+      collectionName,
+    };
+  }
+
+  if (tab.mode === "mongo-bucket") {
+    return {
+      type: "mongo-gridfs",
+      connectionId: tab.connectionId,
+      database: tab.database,
+    };
+  }
+
+  if (tab.mode === "mongo-gridfs") {
+    return {
+      type: "mongo-gridfs",
+      connectionId: tab.connectionId,
+      database: tab.database,
+    };
+  }
+
+  if (tab.mode === "vector") {
+    const collectionName = tab.sql || tab.title;
+    if (!collectionName) return null;
+    return {
+      type: "vector-collection",
+      connectionId: tab.connectionId,
+      database: tab.database,
+      collectionName,
+    };
+  }
+
+  if (tab.mode === "etcd") {
+    return { type: "etcd-root", connectionId: tab.connectionId };
+  }
+
+  if (tab.mode === "zookeeper") {
+    return { type: "zookeeper-root", connectionId: tab.connectionId };
+  }
+
+  if (tab.mode === "mq" && tab.mqTenant) {
+    return { type: "mq-tenant", connectionId: tab.connectionId, tenant: tab.mqTenant };
+  }
+
+  if (tab.mode === "nacos") {
+    return { type: "nacos-namespace", connectionId: tab.connectionId, namespace: tab.nacosNamespace || "" };
+  }
+
+  if (tab.savedSqlId) {
+    return { type: "saved-sql-file", savedSqlId: tab.savedSqlId };
+  }
+
+  if (tab.mode === "query") {
+    if (!tab.connectionId || !tab.database) return null;
+    return {
+      type: "query-context",
+      connectionId: tab.connectionId,
+      database: tab.database,
+      schema: tab.schema,
+    };
+  }
+
+  return null;
+}
+
+function schemaMatches(node: TreeNode, schema: string | undefined): boolean {
+  if (!schema) return true;
+
+  if ((node.schema || "") === schema) return true;
+  // Some database engines (for example MySQL in database-object tree mode) do
+  // not store a separate schema on table nodes. In that case the database name
+  // is the effective schema, so a target schema equal to the node database
+  // should still resolve to the loaded table node.
+  return !node.schema && (node.database || "") === schema;
+}
+
+export function matchesTarget(node: TreeNode, target: ActiveTabSidebarTarget): boolean {
+  if (target.type === "mongo-collection") {
+    if (node.type === "elasticsearch-index") {
+      return node.connectionId === target.connectionId && node.label === target.collectionName;
+    }
+    return node.type === "mongo-collection" && node.connectionId === target.connectionId && node.database === target.database && node.label === target.collectionName;
+  }
+
+  if (target.type === "mongo-gridfs") {
+    return node.type === "mongo-gridfs" && node.connectionId === target.connectionId && node.database === target.database;
+  }
+
+  if (target.type === "vector-collection") {
+    return node.type === "vector-collection" && node.connectionId === target.connectionId && node.database === target.database && node.label === target.collectionName;
+  }
+
+  if (target.type === "query-context") {
+    if (target.schema) {
+      return node.type === "schema" && node.connectionId === target.connectionId && node.database === target.database && node.label === target.schema;
+    }
+    return node.type === "database" && node.connectionId === target.connectionId && node.label === target.database;
+  }
+
+  if (target.type === "etcd-root") {
+    return node.type === "etcd-root" && node.connectionId === target.connectionId;
+  }
+
+  if (target.type === "zookeeper-root") {
+    return node.type === "zookeeper-root" && node.connectionId === target.connectionId;
+  }
+
+  if (target.type === "mq-tenant") {
+    return node.type === "mq-tenant" && node.connectionId === target.connectionId && (node.mqTenant || node.label) === target.tenant;
+  }
+
+  if (target.type === "nacos-namespace") {
+    return node.type === "nacos-namespace" && node.connectionId === target.connectionId && (node.nacosNamespace || "") === target.namespace;
+  }
+
+  if (target.type === "saved-sql-file") {
+    return node.type === "saved-sql-file" && node.savedSqlId === target.savedSqlId;
+  }
+
+  return (node.type === "table" || node.type === "view" || node.type === "materialized_view") && node.connectionId === target.connectionId && node.database === target.database && schemaMatches(node, target.schema) && node.label === target.tableName;
+}
+
+export function findSidebarNodeForActiveTab(tab: QueryTab | undefined | null, flatNodes: readonly FlatTreeNode[]): FlatTreeNode | null {
+  const target = activeTabSidebarTarget(tab);
+  if (!target) return null;
+  return findSidebarNodeForTarget(target, flatNodes);
+}
+
+export function findSidebarNodeForTarget(target: ActiveTabSidebarTarget, flatNodes: readonly FlatTreeNode[]): FlatTreeNode | null {
+  return flatNodes.find((item) => matchesTarget(item.node, target)) ?? null;
+}
+
+export function shouldScrollActiveSidebarSelection(options: { activeTabId: string | null | undefined; previousActiveTabId: string | null | undefined; autoSelectEnabled: boolean; previousAutoSelectEnabled: boolean | undefined }): boolean {
+  if (!options.autoSelectEnabled) return false;
+  return options.activeTabId !== options.previousActiveTabId || (options.autoSelectEnabled && options.previousAutoSelectEnabled === false);
+}
+
+// nearest is used for passive auto-selection; smart keeps context for explicit locate actions.
+export type SidebarNodeScrollAlign = "nearest" | "top" | "smart";
+
+export function scrollTopForSidebarNode(options: { index: number; currentScrollTop: number; viewportHeight: number; rowHeight?: number; topOcclusionHeight?: number; align?: SidebarNodeScrollAlign }): number {
+  const rowHeight = options.rowHeight ?? SIDEBAR_TREE_ROW_HEIGHT;
+  if (options.index < 0 || options.viewportHeight <= 0) return options.currentScrollTop;
+
+  const rowTop = options.index * rowHeight;
+  const rowBottom = rowTop + rowHeight;
+  const topOcclusionHeight = options.topOcclusionHeight ?? 0;
+  if (options.align === "top") return Math.max(0, rowTop - topOcclusionHeight);
+  if (options.align === "smart") {
+    // Similar to IDE Locate: place the target around the upper third of the viewport.
+    const availableViewportHeight = Math.max(rowHeight, options.viewportHeight - topOcclusionHeight);
+    const smartOffset = Math.max(0, (availableViewportHeight - rowHeight) / 3);
+    return Math.max(0, Math.round(rowTop - topOcclusionHeight - smartOffset));
+  }
+
+  const viewportTop = options.currentScrollTop + topOcclusionHeight;
+  const viewportBottom = options.currentScrollTop + options.viewportHeight;
+
+  if (rowTop < viewportTop) return Math.max(0, rowTop - topOcclusionHeight);
+  if (rowBottom > viewportBottom) return Math.max(0, rowBottom - options.viewportHeight);
+  return options.currentScrollTop;
+}
+
+export function findNodePathForActiveTab(tab: QueryTab | undefined | null, treeNodes: readonly TreeNode[]): TreeNode[] | null {
+  const target = activeTabSidebarTarget(tab);
+  if (!target) return null;
+  return findNodePathForTarget(target, treeNodes);
+}
+
+export function findNodePathForTarget(target: ActiveTabSidebarTarget, treeNodes: readonly TreeNode[]): TreeNode[] | null {
+  return findPath(treeNodes, (node) => matchesTarget(node, target));
+}
+
+function findPath(nodes: readonly TreeNode[], predicate: (node: TreeNode) => boolean, path: TreeNode[] = []): TreeNode[] | null {
+  for (const node of nodes) {
+    const currentPath = [...path, node];
+    if (predicate(node)) return currentPath;
+    if (node.children) {
+      const result = findPath(node.children, predicate, currentPath);
+      if (result) return result;
+    }
+  }
+  return null;
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarConnectionSelection.ts b/apps/desktop/src/lib/sidebar/sidebarConnectionSelection.ts
new file mode 100644
index 0000000..871476c
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarConnectionSelection.ts
@@ -0,0 +1,47 @@
+import type { TreeNode } from "@/types/database";
+
+type ConnectionTreeNode = TreeNode & { connectionId: string };
+
+export function isConnectionNode(node: TreeNode): node is ConnectionTreeNode {
+  return node.type === "connection" && !!node.connectionId;
+}
+
+function selectedConnectionActionTargets(currentNode: TreeNode, selectedNodes: TreeNode[]): ConnectionTreeNode[] {
+  if (!isConnectionNode(currentNode)) return [];
+  const selectedContainsCurrent = selectedNodes.some((node) => node.id === currentNode.id);
+  if (selectedNodes.length > 1 && selectedContainsCurrent && selectedNodes.every(isConnectionNode)) {
+    return selectedNodes;
+  }
+  return [currentNode];
+}
+
+export function selectedConnectionDeleteTargets(currentNode: TreeNode, selectedNodes: TreeNode[]): ConnectionTreeNode[] {
+  return selectedConnectionActionTargets(currentNode, selectedNodes);
+}
+
+export function selectedConnectionDuplicateTargets(currentNode: TreeNode, selectedNodes: TreeNode[]): ConnectionTreeNode[] {
+  return selectedConnectionActionTargets(currentNode, selectedNodes);
+}
+
+export function selectedConnectionClipboardTargets(currentNode: TreeNode, selectedNodes: TreeNode[]): ConnectionTreeNode[] {
+  return selectedConnectionActionTargets(currentNode, selectedNodes);
+}
+
+export function selectedConnectionEditTarget(currentNode: TreeNode, selectedNodes: TreeNode[]): ConnectionTreeNode | null {
+  if (!isConnectionNode(currentNode)) return null;
+  const selectedContainsCurrent = selectedNodes.some((node) => node.id === currentNode.id);
+  if (selectedNodes.length > 1 && selectedContainsCurrent) return null;
+  return currentNode;
+}
+
+export function selectedConnectionClipboardNodes(selectedNodes: TreeNode[]): ConnectionTreeNode[] {
+  if (selectedNodes.length === 0 || !selectedNodes.every(isConnectionNode)) return [];
+  return selectedNodes;
+}
+
+export function connectionPasteTargetGroupId(node: TreeNode | null | undefined, groupIdForConnection: (connectionId: string) => string | null): string | null {
+  if (!node) return null;
+  if (node.type === "connection-group") return node.id;
+  if (isConnectionNode(node)) return groupIdForConnection(node.connectionId);
+  return null;
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarDatabaseOpenState.ts b/apps/desktop/src/lib/sidebar/sidebarDatabaseOpenState.ts
new file mode 100644
index 0000000..740d88d
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarDatabaseOpenState.ts
@@ -0,0 +1,9 @@
+import type { TreeNode } from "@/types/database";
+
+export function isSidebarDatabaseOpened(node: TreeNode, isTreeNodeChildrenLoaded: (nodeId: string) => boolean): boolean {
+  return (node.type === "database" || node.type === "mongo-db" || node.type === "vector-database") && !!node.connectionId && node.database != null && isTreeNodeChildrenLoaded(node.id);
+}
+
+export function canCloseSidebarDatabaseConnection(node: TreeNode, isTreeNodeChildrenLoaded: (nodeId: string) => boolean): boolean {
+  return node.type === "database" && !!node.connectionId && node.database != null && isTreeNodeChildrenLoaded(node.id);
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarLabelTooltip.ts b/apps/desktop/src/lib/sidebar/sidebarLabelTooltip.ts
new file mode 100644
index 0000000..64af04d
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarLabelTooltip.ts
@@ -0,0 +1,3 @@
+export function shouldMeasureSidebarLabelOverflow(options: { hasDetailTooltip: boolean; isRenaming: boolean; usesFullWidthLabel: boolean }): boolean {
+  return !options.isRenaming && !options.hasDetailTooltip && !options.usesFullWidthLabel;
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarLayout.ts b/apps/desktop/src/lib/sidebar/sidebarLayout.ts
new file mode 100644
index 0000000..ecb1575
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarLayout.ts
@@ -0,0 +1,325 @@
+import type { ConnectionConfig, ConnectionGroup, SidebarLayout, SidebarOrderEntry, TreeNode } from "@/types/database";
+import { uuid } from "@/lib/common/utils";
+
+export function emptyLayout(): SidebarLayout {
+  return { groups: [], order: [] };
+}
+
+function entryChildren(entry: Extract<SidebarOrderEntry, { type: "group" }>): SidebarOrderEntry[] {
+  return entry.children ?? entry.connectionIds?.map((id) => ({ type: "connection" as const, id })) ?? [];
+}
+
+function normalizeEntry(entry: SidebarOrderEntry, validIds: Set<string>, validGroups: Set<string>, seenConnections: Set<string>, seenGroups: Set<string>): SidebarOrderEntry | null {
+  if (entry.type === "connection") {
+    if (!validIds.has(entry.id) || seenConnections.has(entry.id)) return null;
+    seenConnections.add(entry.id);
+    return { type: "connection", id: entry.id };
+  }
+
+  if (!validGroups.has(entry.id) || seenGroups.has(entry.id)) return null;
+  seenGroups.add(entry.id);
+
+  const children = entryChildren(entry)
+    .map((child) => normalizeEntry(child, validIds, validGroups, seenConnections, seenGroups))
+    .filter(Boolean) as SidebarOrderEntry[];
+  return { type: "group", id: entry.id, children };
+}
+
+export function reconcileLayout(connectionIds: string[], layout: SidebarLayout | null): SidebarLayout {
+  if (!layout) {
+    return {
+      groups: [],
+      order: connectionIds.map((id) => ({ type: "connection" as const, id })),
+    };
+  }
+
+  const validIds = new Set(connectionIds);
+  const validGroups = new Set(layout.groups.map((group) => group.id));
+  const seenConnections = new Set<string>();
+  const seenGroups = new Set<string>();
+  const order = layout.order.map((entry) => normalizeEntry(entry, validIds, validGroups, seenConnections, seenGroups)).filter(Boolean) as SidebarOrderEntry[];
+
+  for (const id of connectionIds) {
+    if (!seenConnections.has(id)) {
+      order.push({ type: "connection", id });
+    }
+  }
+
+  const usedGroupIds = new Set<string>();
+  const collectGroups = (entries: SidebarOrderEntry[]) => {
+    for (const entry of entries) {
+      if (entry.type !== "group") continue;
+      usedGroupIds.add(entry.id);
+      collectGroups(entryChildren(entry));
+    }
+  };
+  collectGroups(order);
+
+  const groups = layout.groups.filter((group) => usedGroupIds.has(group.id));
+  return { groups, order };
+}
+
+export function remapSidebarLayoutConnectionIds(layout: SidebarLayout, connectionIdMap: Map<string, string>): SidebarLayout {
+  const remapEntries = (entries: SidebarOrderEntry[]): SidebarOrderEntry[] =>
+    entries.flatMap((entry): SidebarOrderEntry[] => {
+      if (entry.type === "connection") {
+        const id = connectionIdMap.get(entry.id);
+        return id ? [{ type: "connection", id }] : [];
+      }
+
+      const children = entryChildren(entry).flatMap((child): SidebarOrderEntry[] => remapEntries([child]));
+      return [{ type: "group", id: entry.id, children }];
+    });
+
+  return {
+    groups: layout.groups.map((group) => ({ ...group })),
+    order: remapEntries(layout.order),
+  };
+}
+
+function makeConnectionNode(config: ConnectionConfig, pinned: boolean): TreeNode {
+  return {
+    id: config.id,
+    label: config.name,
+    type: "connection",
+    connectionId: config.id,
+    isExpanded: false,
+    children: [],
+    pinned,
+  };
+}
+
+function orderPinnedFirst(nodes: TreeNode[]): TreeNode[] {
+  const pinned: TreeNode[] = [];
+  const unpinned: TreeNode[] = [];
+  for (const node of nodes) {
+    if (node.pinned) pinned.push(node);
+    else unpinned.push(node);
+  }
+  return [...pinned, ...unpinned];
+}
+
+export function buildTreeNodesFromLayout(layout: SidebarLayout, connections: ConnectionConfig[], pinnedIds: Set<string>): TreeNode[] {
+  const configMap = new Map(connections.map((connection) => [connection.id, connection]));
+  const groupMap = new Map(layout.groups.map((group) => [group.id, group]));
+
+  const build = (entries: SidebarOrderEntry[]): TreeNode[] => {
+    const nodes: TreeNode[] = [];
+    for (const entry of entries) {
+      if (entry.type === "connection") {
+        const config = configMap.get(entry.id);
+        if (config) nodes.push(makeConnectionNode(config, pinnedIds.has(entry.id)));
+        continue;
+      }
+
+      const group = groupMap.get(entry.id);
+      if (!group) continue;
+      nodes.push({
+        id: group.id,
+        label: group.name,
+        type: "connection-group",
+        pinned: pinnedIds.has(group.id),
+        isExpanded: !group.collapsed,
+        children: orderPinnedFirst(build(entryChildren(entry))),
+      });
+    }
+    return nodes;
+  };
+
+  return orderPinnedFirst(build(layout.order));
+}
+
+export function findConnectionLocation(layout: SidebarLayout, connectionId: string): { entries: SidebarOrderEntry[]; entryIndex: number; groupId?: string } | null {
+  const visit = (entries: SidebarOrderEntry[], groupId?: string): { entries: SidebarOrderEntry[]; entryIndex: number; groupId?: string } | null => {
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry.type === "connection" && entry.id === connectionId) return { entries, entryIndex: i, groupId };
+      if (entry.type === "group") {
+        const found = visit(entryChildren(entry), entry.id);
+        if (found) return found;
+      }
+    }
+    return null;
+  };
+  return visit(layout.order);
+}
+
+function findGroupEntry(entries: SidebarOrderEntry[], groupId: string): Extract<SidebarOrderEntry, { type: "group" }> | null {
+  for (const entry of entries) {
+    if (entry.type !== "group") continue;
+    if (entry.id === groupId) return entry;
+    const found = findGroupEntry(entryChildren(entry), groupId);
+    if (found) return found;
+  }
+  return null;
+}
+
+function cloneEntries(entries: SidebarOrderEntry[]): SidebarOrderEntry[] {
+  return entries.map((entry) => (entry.type === "group" ? { type: "group", id: entry.id, children: cloneEntries(entryChildren(entry)) } : { ...entry }));
+}
+
+function removeEntry(entries: SidebarOrderEntry[], id: string): SidebarOrderEntry | null {
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if ((entry.type === "connection" && entry.id === id) || (entry.type === "group" && entry.id === id)) {
+      entries.splice(i, 1);
+      return entry;
+    }
+    if (entry.type === "group") {
+      const removed = removeEntry(entry.children ?? [], id);
+      if (removed) return removed;
+    }
+  }
+  return null;
+}
+
+function removeConnectionFromEntries(entries: SidebarOrderEntry[], connectionId: string): SidebarOrderEntry[] {
+  const next = cloneEntries(entries);
+  removeEntry(next, connectionId);
+  return next;
+}
+
+function containsGroup(entry: SidebarOrderEntry, groupId: string): boolean {
+  if (entry.type !== "group") return false;
+  if (entry.id === groupId) return true;
+  return entryChildren(entry).some((child) => containsGroup(child, groupId));
+}
+
+function expandGroup(layout: SidebarLayout, groupId: string): SidebarLayout {
+  return {
+    ...layout,
+    groups: layout.groups.map((group) => (group.id === groupId ? { ...group, collapsed: false } : group)),
+  };
+}
+
+export function moveConnectionToGroup(layout: SidebarLayout, connectionId: string, targetGroupId: string | null): SidebarLayout {
+  const order = removeConnectionFromEntries(layout.order, connectionId);
+  const entry: SidebarOrderEntry = { type: "connection", id: connectionId };
+
+  if (targetGroupId) {
+    const group = findGroupEntry(order, targetGroupId);
+    if (group) {
+      group.children = [...(group.children ?? []), entry];
+      return { ...expandGroup(layout, targetGroupId), order };
+    }
+  }
+
+  order.push(entry);
+  return { ...layout, order };
+}
+
+export type DropPosition = "before" | "after" | "inside";
+
+export function reorderEntry(layout: SidebarLayout, draggedId: string, targetId: string, position: DropPosition): SidebarLayout {
+  if (draggedId === targetId) return layout;
+
+  const order = cloneEntries(layout.order);
+  const dragged = removeEntry(order, draggedId);
+  if (!dragged) return layout;
+
+  if (dragged.type === "group" && containsGroup(dragged, targetId)) return layout;
+
+  if (position === "inside") {
+    const targetGroup = findGroupEntry(order, targetId);
+    if (targetGroup) {
+      targetGroup.children = [...(targetGroup.children ?? []), dragged];
+      return { ...layout, order };
+    }
+  }
+
+  const insertNear = (entries: SidebarOrderEntry[]): boolean => {
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if ((entry.type === "connection" && entry.id === targetId) || (entry.type === "group" && entry.id === targetId)) {
+        entries.splice(position === "after" ? i + 1 : i, 0, dragged);
+        return true;
+      }
+      if (entry.type === "group" && insertNear(entry.children ?? [])) return true;
+    }
+    return false;
+  };
+
+  if (!insertNear(order)) order.push(dragged);
+  return { ...layout, order };
+}
+
+export function createGroup(layout: SidebarLayout, name: string, parentGroupId?: string | null): { layout: SidebarLayout; groupId: string } {
+  const groupId = uuid();
+  const group: ConnectionGroup = { id: groupId, name, collapsed: false };
+  const order = cloneEntries(layout.order);
+  const entry: SidebarOrderEntry = { type: "group", id: groupId, children: [] };
+  let parentFound = false;
+
+  if (parentGroupId) {
+    const parent = findGroupEntry(order, parentGroupId);
+    if (parent) {
+      parent.children = [...(parent.children ?? []), entry];
+      parentFound = true;
+    } else {
+      order.push(entry);
+    }
+  } else {
+    order.push(entry);
+  }
+
+  return {
+    groupId,
+    layout: {
+      groups: [...layout.groups, group].map((current) => (parentFound && current.id === parentGroupId ? { ...current, collapsed: false } : current)),
+      order,
+    },
+  };
+}
+
+export function renameGroup(layout: SidebarLayout, groupId: string, name: string): SidebarLayout {
+  return {
+    ...layout,
+    groups: layout.groups.map((group) => (group.id === groupId ? { ...group, name } : group)),
+  };
+}
+
+export function deleteGroup(layout: SidebarLayout, groupId: string): SidebarLayout {
+  const order = cloneEntries(layout.order);
+  const removeGroup = (entries: SidebarOrderEntry[]): boolean => {
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry.type === "group" && entry.id === groupId) {
+        entries.splice(i, 1, ...entryChildren(entry));
+        return true;
+      }
+      if (entry.type === "group") {
+        const removed = removeGroup(entry.children ?? []);
+        if (removed) return true;
+      }
+    }
+    return false;
+  };
+
+  const removed = removeGroup(order);
+  return {
+    groups: removed ? layout.groups.filter((group) => group.id !== groupId) : layout.groups,
+    order,
+  };
+}
+
+export function toggleGroupCollapsed(layout: SidebarLayout, groupId: string): SidebarLayout {
+  return {
+    ...layout,
+    groups: layout.groups.map((group) => (group.id === groupId ? { ...group, collapsed: !group.collapsed } : group)),
+  };
+}
+
+export function collapseAllGroups(layout: SidebarLayout): SidebarLayout {
+  return {
+    ...layout,
+    groups: layout.groups.map((group) => (group.collapsed ? group : { ...group, collapsed: true })),
+  };
+}
+
+export function removeConnectionFromSidebarLayout(layout: SidebarLayout, connectionId: string): SidebarLayout {
+  return { ...layout, order: removeConnectionFromEntries(layout.order, connectionId) };
+}
+
+export function appendConnectionToLayout(layout: SidebarLayout, connectionId: string, groupId?: string | null): SidebarLayout {
+  return moveConnectionToGroup(layout, connectionId, groupId ?? null);
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarNodeOrdering.ts b/apps/desktop/src/lib/sidebar/sidebarNodeOrdering.ts
new file mode 100644
index 0000000..c08e20a
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarNodeOrdering.ts
@@ -0,0 +1,79 @@
+import type { DatabaseType, TreeNode } from "@/types/database";
+
+const sidebarTreeCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
+
+function sortByLabel(nodes: readonly TreeNode[]): TreeNode[] {
+  return [...nodes].sort((left, right) => sidebarTreeCollator.compare(left.label, right.label));
+}
+
+function sortRecursive(node: TreeNode, databaseType?: DatabaseType): TreeNode {
+  const children = node.children ? sortSidebarTreeChildrenForParent(node, node.children, databaseType) : node.children;
+  const hiddenChildren = node.hiddenChildren ? sortSidebarTreeChildrenForParent(node, node.hiddenChildren, databaseType) : node.hiddenChildren;
+  if (children === node.children && hiddenChildren === node.hiddenChildren) return node;
+  return {
+    ...node,
+    children,
+    hiddenChildren,
+  };
+}
+
+export function sortSidebarTreeChildrenForParent(parent: Pick<TreeNode, "type">, children: readonly TreeNode[], databaseType?: DatabaseType): TreeNode[] {
+  const normalized = children.map((child) => sortRecursive(child, databaseType));
+
+  if (parent.type === "mongo-db") {
+    const gridFsNodes = normalized.filter((child) => child.type === "mongo-gridfs");
+    const collections = normalized.filter((child) => child.type !== "mongo-gridfs");
+    return [...gridFsNodes, ...sortByLabel(collections)];
+  }
+
+  if (parent.type === "vector-database") {
+    return sortByLabel(normalized);
+  }
+
+  if (parent.type === "mongo-buckets") {
+    return sortByLabel(normalized);
+  }
+
+  if (parent.type === "connection") {
+    const savedSqlNodes = normalized.filter((child) => child.type === "saved-sql-root");
+    const userAdminNodes = normalized.filter((child) => child.type === "user-admin");
+    const regularChildren = normalized.filter((child) => child.type !== "user-admin" && child.type !== "saved-sql-root");
+    const withConnectionUtilityOrder = (children: TreeNode[]) => [...savedSqlNodes, ...children, ...userAdminNodes];
+
+    if (databaseType === "mongodb" || databaseType === "elasticsearch" || databaseType === "qdrant" || databaseType === "milvus" || databaseType === "weaviate" || databaseType === "chromadb") {
+      return withConnectionUtilityOrder(sortByLabel(regularChildren));
+    }
+
+    if (databaseType === "duckdb") {
+      const schemas = sortByLabel(regularChildren.filter((child) => child.type === "schema"));
+      const databases = sortByLabel(regularChildren.filter((child) => child.type === "database"));
+      const rest = regularChildren.filter((child) => child.type !== "schema" && child.type !== "database");
+      return withConnectionUtilityOrder([...schemas, ...databases, ...rest]);
+    }
+
+    if (regularChildren.every((child) => child.type === "database")) {
+      return withConnectionUtilityOrder(sortByLabel(regularChildren));
+    }
+
+    if (regularChildren.every((child) => child.type === "schema")) {
+      return withConnectionUtilityOrder(sortByLabel(regularChildren));
+    }
+
+    return withConnectionUtilityOrder(regularChildren);
+  }
+
+  if (parent.type === "database") {
+    if (databaseType === "sqlserver") {
+      const objectGroups = normalized.filter((child) => child.type.startsWith("group-"));
+      const schemas = sortByLabel(normalized.filter((child) => child.type === "schema"));
+      const rest = normalized.filter((child) => !child.type.startsWith("group-") && child.type !== "schema");
+      return [...objectGroups, ...schemas, ...rest];
+    }
+
+    if (normalized.every((child) => child.type === "schema")) {
+      return sortByLabel(normalized);
+    }
+  }
+
+  return normalized;
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarRenameFocus.ts b/apps/desktop/src/lib/sidebar/sidebarRenameFocus.ts
new file mode 100644
index 0000000..8e1b9df
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarRenameFocus.ts
@@ -0,0 +1,24 @@
+type RenameInput = Pick<HTMLInputElement, "focus" | "select">;
+type FrameScheduler = (callback: () => void) => number;
+type PendingRenameFocusRestore = { value: boolean };
+
+const scheduleAnimationFrame: FrameScheduler = (callback) => {
+  if (typeof requestAnimationFrame === "function") {
+    return requestAnimationFrame(callback);
+  }
+  return setTimeout(callback, 0) as unknown as number;
+};
+
+export function focusSidebarRenameInput(getInput: () => RenameInput | undefined, schedule: FrameScheduler = scheduleAnimationFrame) {
+  schedule(() => {
+    const input = getInput();
+    input?.focus();
+    input?.select();
+  });
+}
+
+export function shouldPreventRenameCloseAutoFocus(pending: PendingRenameFocusRestore): boolean {
+  if (!pending.value) return false;
+  pending.value = false;
+  return true;
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarSearch.ts b/apps/desktop/src/lib/sidebar/sidebarSearch.ts
new file mode 100644
index 0000000..3aa1b6b
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarSearch.ts
@@ -0,0 +1,68 @@
+import { parseSlashDelimitedRegexQuery } from "@/lib/common/searchPattern";
+
+export type SidebarSearchMatchKind = "exact" | "prefix" | "word-prefix" | "substring" | "abbreviation" | "fuzzy" | "regex";
+
+export interface SidebarSearchMatch {
+  kind: SidebarSearchMatchKind;
+  score: number;
+}
+
+export type SidebarLabelMatcher = (label: string) => SidebarSearchMatch | null;
+
+function isWordBoundary(text: string, index: number): boolean {
+  if (index === 0) return true;
+  const prev = text[index - 1];
+  return prev === "_" || prev === "-" || prev === "." || prev === " " || prev === "/" || prev === "\\";
+}
+
+function matchesWordPrefix(text: string, query: string): boolean {
+  for (let i = 0; i < text.length; i++) {
+    if (isWordBoundary(text, i) && text.startsWith(query, i)) return true;
+  }
+  return false;
+}
+
+function matchesAbbreviation(text: string, query: string): boolean {
+  let j = 0;
+  for (let i = 0; i < text.length && j < query.length; i++) {
+    if (isWordBoundary(text, i) && text[i] === query[j]) j++;
+  }
+  return j === query.length;
+}
+
+function matchesSubsequence(text: string, query: string): boolean {
+  if (query.length < 2 || query.length > text.length) return false;
+
+  let j = 0;
+  for (let i = 0; i < text.length && j < query.length; i++) {
+    if (isWordBoundary(text, i) && i > 0) {
+      j = 0;
+    }
+    if (text[i] === query[j]) j++;
+  }
+  return j === query.length;
+}
+
+function matchSidebarLabelWithRegex(label: string, query: string, regex: RegExp | null): SidebarSearchMatch | null {
+  if (!query) return null;
+
+  if (regex) return regex.test(label) ? { kind: "regex", score: 95 } : null;
+
+  if (label === query) return { kind: "exact", score: 100 };
+  if (label.startsWith(query)) return { kind: "prefix", score: 90 };
+  if (matchesWordPrefix(label, query)) return { kind: "word-prefix", score: 80 };
+  if (label.includes(query)) return { kind: "substring", score: 70 };
+  if (query.length >= 2 && matchesAbbreviation(label, query)) return { kind: "abbreviation", score: 60 };
+  if (matchesSubsequence(label, query)) return { kind: "fuzzy", score: 40 };
+
+  return null;
+}
+
+export function createSidebarLabelMatcher(query: string): SidebarLabelMatcher {
+  const regex = parseSlashDelimitedRegexQuery(query);
+  return (label) => matchSidebarLabelWithRegex(label, query, regex);
+}
+
+export function matchSidebarLabel(label: string, query: string): SidebarSearchMatch | null {
+  return matchSidebarLabelWithRegex(label, query, parseSlashDelimitedRegexQuery(query));
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarSearchTree.ts b/apps/desktop/src/lib/sidebar/sidebarSearchTree.ts
new file mode 100644
index 0000000..73f8d6b
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarSearchTree.ts
@@ -0,0 +1,72 @@
+import type { TreeNode, TreeNodeType } from "@/types/database";
+import { createSidebarLabelMatcher, type SidebarLabelMatcher } from "@/lib/sidebar/sidebarSearch";
+
+const preserveMatchedSubtreeTypes = new Set(["connection", "database", "schema", "table", "view", "mongo-db", "mongo-collection"]);
+
+const normalizedLabelCache = new WeakMap<TreeNode, { label: string; normalized: string }>();
+
+function bestMatch(matchLabel: SidebarLabelMatcher, label: string, comment?: string | null) {
+  const lm = matchLabel(label);
+  if (!comment) return lm;
+  const cm = matchLabel(comment.toLowerCase());
+  if (lm && cm) return lm.score >= cm.score ? lm : cm;
+  return lm ?? cm;
+}
+
+function normalizedLabel(node: TreeNode): string {
+  const cached = normalizedLabelCache.get(node);
+  if (cached?.label === node.label) return cached.normalized;
+
+  const normalized = node.label.toLowerCase();
+  normalizedLabelCache.set(node, { label: node.label, normalized });
+  return normalized;
+}
+
+export function filterSidebarTree(nodes: TreeNode[], query: string, collapsedIds: ReadonlySet<string>, searchableNodeTypes?: ReadonlySet<TreeNodeType>): TreeNode[] {
+  return filterSidebarTreeWithMatcher(nodes, createSidebarLabelMatcher(query), collapsedIds, searchableNodeTypes);
+}
+
+function filterSidebarTreeWithMatcher(nodes: TreeNode[], matchLabel: SidebarLabelMatcher, collapsedIds: ReadonlySet<string>, searchableNodeTypes?: ReadonlySet<TreeNodeType>): TreeNode[] {
+  const filteredNodes: { node: TreeNode; score: number }[] = [];
+
+  for (const node of nodes) {
+    if (node.type === "object-browser" && node.hiddenChildren) {
+      const matches = node.hiddenChildren.map((child) => ({ node: child, score: matchLabel(normalizedLabel(child))?.score ?? 0 })).filter((match) => match.score > 0);
+      filteredNodes.push(...matches);
+      continue;
+    }
+
+    const label = normalizedLabel(node);
+    const canSelfMatch = !searchableNodeTypes || searchableNodeTypes.has(node.type);
+    const selfMatch = canSelfMatch ? bestMatch(matchLabel, label, node.comment) : null;
+    const preservesSubtree = !!selfMatch && preserveMatchedSubtreeTypes.has(node.type);
+    const filteredChildren = preservesSubtree ? node.children : node.children ? filterSidebarTreeWithMatcher(node.children, matchLabel, collapsedIds, searchableNodeTypes) : undefined;
+
+    if (selfMatch || (filteredChildren && filteredChildren.length > 0)) {
+      if (!node.children) {
+        filteredNodes.push({ node, score: selfMatch?.score ?? 0 });
+      } else {
+        const children = filteredChildren ?? [];
+        filteredNodes.push({
+          node: {
+            ...node,
+            children,
+            isLoading: node.isLoading,
+            isExpanded: children.length > 0 && !collapsedIds.has(node.id),
+          },
+          score: selfMatch?.score ?? 0,
+        });
+      }
+    }
+  }
+
+  filteredNodes.sort((a, b) => b.score - a.score);
+  return filteredNodes.map((match) => match.node);
+}
+
+export function filterSidebarSearchRootsByConnectionState(nodes: TreeNode[], connectedIds: ReadonlySet<string>): TreeNode[] {
+  return nodes.filter((node) => {
+    if (node.type === "connection-group" || node.type === "connection") return true;
+    return node.connectionId ? connectedIds.has(node.connectionId) : true;
+  });
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarTableNameDisplay.ts b/apps/desktop/src/lib/sidebar/sidebarTableNameDisplay.ts
new file mode 100644
index 0000000..ce2746a
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarTableNameDisplay.ts
@@ -0,0 +1,19 @@
+export function normalizeSidebarHiddenTablePrefixes(value: unknown): string[] {
+  const rawPrefixes = typeof value === "string" ? value.split(/\r?\n/) : Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+  const seen = new Set<string>();
+  const prefixes: string[] = [];
+
+  for (const rawPrefix of rawPrefixes) {
+    const prefix = rawPrefix.trim();
+    if (!prefix || seen.has(prefix)) continue;
+    seen.add(prefix);
+    prefixes.push(prefix);
+  }
+
+  return prefixes.sort((a, b) => b.length - a.length);
+}
+
+export function sidebarDisplayTableName(name: string, prefixes: readonly string[]): string {
+  const prefix = [...prefixes].sort((a, b) => b.length - a.length).find((item) => name.startsWith(item) && name.length > item.length);
+  return prefix ? `...${name.slice(prefix.length)}` : name;
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarTableSearchControl.ts b/apps/desktop/src/lib/sidebar/sidebarTableSearchControl.ts
new file mode 100644
index 0000000..445eb44
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarTableSearchControl.ts
@@ -0,0 +1,67 @@
+import type { FlatTreeNode } from "@/composables/useFlatTree";
+import type { TreeNode, TreeNodeType } from "@/types/database";
+
+const simpleObjectParentTypes = new Set<TreeNodeType>(["database", "schema", "linked-server-schema"]);
+const tableSearchableChildTypes = new Set<TreeNodeType>(["table", "view", "materialized_view", "load-more"]);
+
+export function isSidebarTableSearchControlNode(node: TreeNode): boolean {
+  return node.type === "table-search-control";
+}
+
+function tableSearchControlId(parentId: string): string {
+  return `${parentId}:__table_search`;
+}
+
+function parentHasSearchableTableList(node: TreeNode): boolean {
+  // Routine-only schemas should not show a table-specific search box.
+  return !!node.children?.some((child) => tableSearchableChildTypes.has(child.type));
+}
+
+function shouldInsertTableSearchControl(item: FlatTreeNode, sidebarObjectDisplay: "simple" | "grouped", activeQueries: Readonly<Record<string, string | undefined>>): boolean {
+  const node = item.node;
+  if (!node.isExpanded) return false;
+  if (sidebarObjectDisplay === "grouped") {
+    return node.type === "group-tables" && (parentHasSearchableTableList(node) || !!activeQueries[node.id]?.trim());
+  }
+  if (!simpleObjectParentTypes.has(node.type)) return false;
+  return parentHasSearchableTableList(node) || !!activeQueries[node.id]?.trim();
+}
+
+function buildTableSearchControlNode(parent: TreeNode): TreeNode {
+  return {
+    id: tableSearchControlId(parent.id),
+    label: "sidebar.searchTablesInCurrentScope",
+    type: "table-search-control",
+    connectionId: parent.connectionId,
+    database: parent.database,
+    schema: parent.schema,
+    tableSearchParentId: parent.id,
+  };
+}
+
+export function insertSidebarTableSearchControls(
+  flatNodes: readonly FlatTreeNode[],
+  options: {
+    enabled: boolean;
+    sidebarObjectDisplay: "simple" | "grouped";
+    activeQueries: Readonly<Record<string, string | undefined>>;
+  },
+): FlatTreeNode[] {
+  if (!options.enabled) return [...flatNodes];
+
+  const result: FlatTreeNode[] = [];
+  for (const item of flatNodes) {
+    result.push(item);
+    if (!shouldInsertTableSearchControl(item, options.sidebarObjectDisplay, options.activeQueries)) continue;
+
+    const node = buildTableSearchControlNode(item.node);
+    result.push({
+      node,
+      depth: item.depth + 1,
+      id: node.id,
+      type: node.type,
+      poolType: `${node.type}:${node.id}`,
+    });
+  }
+  return result;
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarTreeCollapse.ts b/apps/desktop/src/lib/sidebar/sidebarTreeCollapse.ts
new file mode 100644
index 0000000..74a775e
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarTreeCollapse.ts
@@ -0,0 +1,17 @@
+import type { TreeNode } from "@/types/database";
+
+export function collapseExpandedTreeNodes(nodes: TreeNode[]): number {
+  let collapsedCount = 0;
+
+  for (const node of nodes) {
+    if (node.isExpanded) {
+      node.isExpanded = false;
+      collapsedCount += 1;
+    }
+    if (node.children?.length) {
+      collapsedCount += collapseExpandedTreeNodes(node.children);
+    }
+  }
+
+  return collapsedCount;
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarTreeContext.ts b/apps/desktop/src/lib/sidebar/sidebarTreeContext.ts
new file mode 100644
index 0000000..db13eb3
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarTreeContext.ts
@@ -0,0 +1,10 @@
+import type { InjectionKey } from "vue";
+import type { TreeNode } from "@/types/database";
+
+export interface SidebarTreeContext {
+  getVisibleNodes: () => TreeNode[];
+  getVisibleNodeIndex: (id: string) => number;
+  setTableSearchQuery?: (parentNodeId: string, query: string) => void;
+}
+
+export const sidebarTreeContextKey: InjectionKey<SidebarTreeContext> = Symbol("sidebar-tree-context");
diff --git a/apps/desktop/src/lib/sidebar/sidebarTreeItemLayout.ts b/apps/desktop/src/lib/sidebar/sidebarTreeItemLayout.ts
new file mode 100644
index 0000000..cbdbe56
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarTreeItemLayout.ts
@@ -0,0 +1,71 @@
+import type { TreeNodeType } from "@/types/database";
+
+const leafTypes: Set<TreeNodeType> = new Set([
+  "column",
+  "index",
+  "fkey",
+  "trigger",
+  "procedure",
+  "function",
+  "package",
+  "package-body",
+  "object-browser",
+  "redis-db",
+  "mq-tenant",
+  "zookeeper-root",
+  "mongo-gridfs",
+  "mongo-bucket",
+  "vector-collection",
+  "elasticsearch-index",
+  "user-admin",
+  "saved-sql-file",
+  "table-search-control",
+  "load-more",
+]);
+
+const fullWidthLabelTypes: Set<TreeNodeType> = new Set(["table", "view", "materialized_view", "mongo-collection", "mongo-bucket", "vector-collection", "elasticsearch-index"]);
+
+const emptyContainerTypes: Set<TreeNodeType> = new Set(["saved-sql-root", "saved-sql-folder"]);
+
+const pinnableTypes: Set<TreeNodeType> = new Set([
+  "connection-group",
+  "database",
+  "linked-server",
+  "linked-server-catalog",
+  "linked-server-schema",
+  "doris-catalog",
+  "schema",
+  "table",
+  "view",
+  "materialized_view",
+  "redis-db",
+  "mongo-db",
+  "mongo-gridfs",
+  "mongo-bucket",
+  "mongo-collection",
+  "vector-collection",
+  "elasticsearch-index",
+  "nacos-namespace",
+]);
+
+export function treeItemPaddingLeft(depth: number): string {
+  return `${depth * 16 + 8}px`;
+}
+
+export function usesFullWidthTreeLabel(type: TreeNodeType, allowHorizontalScroll: boolean): boolean {
+  return allowHorizontalScroll && fullWidthLabelTypes.has(type);
+}
+
+export function canTreeNodeExpand(type: TreeNodeType): boolean {
+  return !leafTypes.has(type);
+}
+
+export function canTreeNodeShowExpander({ type, childCount }: { type: TreeNodeType; childCount?: number }): boolean {
+  if (!canTreeNodeExpand(type)) return false;
+  if (childCount === 0 && emptyContainerTypes.has(type)) return false;
+  return true;
+}
+
+export function canTreeNodePin(type: TreeNodeType): boolean {
+  return pinnableTypes.has(type);
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarTreeSelection.ts b/apps/desktop/src/lib/sidebar/sidebarTreeSelection.ts
new file mode 100644
index 0000000..164cb93
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarTreeSelection.ts
@@ -0,0 +1,21 @@
+import type { TreeNode } from "@/types/database";
+
+export function selectedTreeNodesInVisibleOrder(visibleNodes: TreeNode[], selectedIds: Iterable<string>): TreeNode[] {
+  const ids = new Set(selectedIds);
+  if (!ids.size) return [];
+  return visibleNodes.filter((node) => ids.has(node.id));
+}
+
+export function treeSelectionRangeIdsByIndex(visibleNodes: TreeNode[], currentIndex: number, anchorIndex: number, currentId?: string): string[] {
+  if (anchorIndex < 0 || currentIndex < 0) return currentId ? [currentId] : [];
+  const start = Math.min(anchorIndex, currentIndex);
+  const end = Math.max(anchorIndex, currentIndex);
+  return visibleNodes.slice(start, end + 1).map((node) => node.id);
+}
+
+export function treeSelectionRangeIds(visibleNodes: TreeNode[], currentId: string, anchorId?: string | null, selectedId?: string | null): string[] {
+  const anchor = anchorId || selectedId || currentId;
+  const anchorIndex = visibleNodes.findIndex((node) => node.id === anchor);
+  const currentIndex = visibleNodes.findIndex((node) => node.id === currentId);
+  return treeSelectionRangeIdsByIndex(visibleNodes, currentIndex, anchorIndex, currentId);
+}
diff --git a/apps/desktop/src/lib/sidebar/sidebarTypeSearch.ts b/apps/desktop/src/lib/sidebar/sidebarTypeSearch.ts
new file mode 100644
index 0000000..2b14e39
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/sidebarTypeSearch.ts
@@ -0,0 +1,25 @@
+export interface SidebarTypeSearchKeyEvent {
+  key: string;
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  altKey?: boolean;
+  isComposing?: boolean;
+}
+
+export function isEditableSidebarTypeSearchTarget(target: EventTarget | null): boolean {
+  if (!(target instanceof HTMLElement)) return false;
+  return !!target.closest("input, textarea, select, [contenteditable='true'], .cm-editor");
+}
+
+export function sidebarTypeSearchNextQuery(currentQuery: string, event: SidebarTypeSearchKeyEvent): string | null {
+  if (event.ctrlKey || event.metaKey || event.altKey || event.isComposing) return null;
+
+  if (event.key === "Backspace") {
+    if (!currentQuery) return null;
+    return currentQuery.slice(0, -1);
+  }
+
+  if (event.key.length !== 1) return null;
+  if (event.key === " " && !currentQuery.trim()) return null;
+  return `${currentQuery}${event.key}`;
+}
diff --git a/apps/desktop/src/lib/sidebar/treeNodeClick.ts b/apps/desktop/src/lib/sidebar/treeNodeClick.ts
new file mode 100644
index 0000000..69ad01e
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/treeNodeClick.ts
@@ -0,0 +1,73 @@
+import type { ObjectSourceKind, TreeNode, TreeNodeType } from "@/types/database";
+import { matchesShortcut, type ShortcutLikeEvent } from "@/lib/editor/keyboardShortcuts";
+
+export type TreeNodeRowAction = "open-data" | "toggle" | "none";
+export type TreeNodeRowDoubleClickAction = "open-data" | "open-object-browser" | "open-object-browser-and-expand" | "open-source" | "open-saved-sql" | "toggle" | "none";
+export type SidebarSelectionCopyAction = "copy-name" | "none";
+export type SidebarActivation = "single" | "double";
+
+const dataNodeTypes = new Set<TreeNodeType>(["table", "view", "materialized_view"]);
+const documentBrowserNodeTypes = new Set<TreeNodeType>(["mongo-collection", "mongo-bucket"]);
+const toggleLeafNodeTypes = new Set<TreeNodeType>(["redis-db", "mq-tenant", "etcd-root", "zookeeper-root", "mongo-gridfs", "mongo-collection", "mongo-bucket", "vector-collection", "elasticsearch-index", "user-admin"]);
+const objectBrowserNodeTypes = new Set<TreeNodeType>(["database", "schema", "object-browser"]);
+const sourceNodeTypes = new Set<TreeNodeType>(["materialized_view", "procedure", "function", "sequence", "package", "package-body"]);
+const savedSqlNodeTypes = new Set<TreeNodeType>(["saved-sql-file"]);
+const tableChildGroupNodeTypes = new Set<TreeNodeType>(["group-columns", "group-indexes", "group-fkeys", "group-triggers", "group-partitions"]);
+const databaseChildGroupNodeTypes = new Set<TreeNodeType>(["group-tables", "group-views", "group-materialized-views", "group-procedures", "group-functions", "group-sequences", "group-packages"]);
+
+export function objectSourceKindForTreeNode(type: TreeNodeType): ObjectSourceKind | null {
+  if (type === "view") return "VIEW";
+  if (type === "materialized_view") return "MATERIALIZED_VIEW";
+  if (type === "procedure") return "PROCEDURE";
+  if (type === "function") return "FUNCTION";
+  if (type === "sequence") return "SEQUENCE";
+  if (type === "package") return "PACKAGE";
+  if (type === "package-body") return "PACKAGE_BODY";
+  return null;
+}
+
+export function isDocumentBrowserTreeNode(type: TreeNodeType): boolean {
+  return documentBrowserNodeTypes.has(type);
+}
+
+export function treeNodeRowAction(type: TreeNodeType, canExpand: boolean, activation: SidebarActivation = "single"): TreeNodeRowAction {
+  if (activation === "double") return "none";
+  if (dataNodeTypes.has(type)) return "open-data";
+  if (toggleLeafNodeTypes.has(type)) return "toggle";
+  if (canExpand) return "toggle";
+  return "none";
+}
+
+export function shouldRunTreeNodeRowAction(action: TreeNodeRowAction, clickDetail: number): boolean {
+  // Double-clicks emit a second click before dblclick; leave that event to the
+  // double-click handler so expandable database rows do not toggle first.
+  return action !== "none" && clickDetail <= 1;
+}
+
+export function treeNodeRowDoubleClickAction(type: TreeNodeType, canOpenObjectBrowser: boolean, activation: SidebarActivation = "single", canExpand = false): TreeNodeRowDoubleClickAction {
+  if (activation === "double") {
+    if (dataNodeTypes.has(type)) return "open-data";
+    if (sourceNodeTypes.has(type)) return "open-source";
+    if (savedSqlNodeTypes.has(type)) return "open-saved-sql";
+    if (toggleLeafNodeTypes.has(type)) return "toggle";
+    if (canOpenObjectBrowser && objectBrowserNodeTypes.has(type) && canExpand) return "open-object-browser-and-expand";
+    if (canOpenObjectBrowser && objectBrowserNodeTypes.has(type)) return "open-object-browser";
+    if (canExpand) return "toggle";
+  }
+  if (canOpenObjectBrowser && objectBrowserNodeTypes.has(type)) return "open-object-browser";
+  return "none";
+}
+
+export function sidebarSelectionCopyAction(event: ShortcutLikeEvent): SidebarSelectionCopyAction {
+  return matchesShortcut(event, "Mod+C") ? "copy-name" : "none";
+}
+
+export function copyNameForTreeNode(node: TreeNode): string {
+  if (tableChildGroupNodeTypes.has(node.type) && node.tableName) return node.tableName;
+  if (databaseChildGroupNodeTypes.has(node.type)) return node.schema || node.database || node.label;
+  if (node.type === "column") {
+    if (node.meta && "name" in node.meta) return node.meta.name;
+    return node.label.replace(/\s+\(.+\)$/, "");
+  }
+  return node.label;
+}
diff --git a/apps/desktop/src/lib/sidebar/treeNodeContext.ts b/apps/desktop/src/lib/sidebar/treeNodeContext.ts
new file mode 100644
index 0000000..3536716
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/treeNodeContext.ts
@@ -0,0 +1,39 @@
+import type { TreeNode } from "@/types/database";
+
+export const DEFAULT_DATABASE_TREE_LABEL = "tree.defaultDatabase";
+
+export function hasTreeNodeDatabaseContext(node: Pick<TreeNode, "database">): node is Pick<TreeNode, "database"> & {
+  database: string;
+} {
+  return node.database != null;
+}
+
+function schemaCacheKey(...parts: string[]): string {
+  return parts.map((part) => encodeURIComponent(part)).join(":");
+}
+
+export function treeNodeSchemaCachePrefix(node: TreeNode): string | null {
+  if (node.type === "connection" && node.connectionId) {
+    return `${schemaCacheKey(node.connectionId)}:`;
+  }
+  if (node.type === "database" && node.connectionId && hasTreeNodeDatabaseContext(node)) {
+    return `${schemaCacheKey(node.connectionId, node.database)}:`;
+  }
+  if (node.type === "schema" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.schema) {
+    return `${schemaCacheKey(node.connectionId, node.database, node.schema)}:`;
+  }
+  return null;
+}
+
+export function normalizeCataloglessDatabaseNodes(nodes: TreeNode[]): TreeNode[] {
+  return nodes.map((node) => {
+    const normalized = node.type === "database" && node.database === "" && !node.label.trim() ? { ...node, label: DEFAULT_DATABASE_TREE_LABEL } : node;
+
+    return normalized.children
+      ? {
+          ...normalized,
+          children: normalizeCataloglessDatabaseNodes(normalized.children),
+        }
+      : normalized;
+  });
+}
diff --git a/apps/desktop/src/lib/sidebar/treeNodeIcon.ts b/apps/desktop/src/lib/sidebar/treeNodeIcon.ts
new file mode 100644
index 0000000..4fcb375
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/treeNodeIcon.ts
@@ -0,0 +1,108 @@
+import type { Component } from "vue";
+import { Archive, Braces, Columns3, Database, Eye, FileCode, FolderClosed, FolderOpen, Key, Link, ListTree, Network, Package, Plus, ScrollText, Server, Table, TableProperties, UsersRound, Zap } from "@lucide/vue";
+import type { ColumnInfo, TreeNode } from "@/types/database";
+
+export type TreeNodeIconInfo = {
+  icon: Component;
+  colorClass: string;
+};
+
+export function getTreeNodeIconInfo(node: TreeNode): TreeNodeIconInfo | null {
+  switch (node.type) {
+    case "schema":
+      return { icon: node.isExpanded ? FolderOpen : FolderClosed, colorClass: "text-amber-500" };
+    case "connection":
+    case "database":
+    case "mongo-db":
+      return { icon: Database, colorClass: "text-yellow-500" };
+    case "vector-database":
+      return { icon: Database, colorClass: "text-cyan-500" };
+    case "linked-server-root":
+      return { icon: Network, colorClass: "text-blue-500" };
+    case "linked-server":
+      return { icon: Server, colorClass: "text-blue-400" };
+    case "linked-server-catalog":
+    case "linked-server-schema":
+    case "mq-tenant":
+      return { icon: FolderOpen, colorClass: "text-sky-400" };
+    case "doris-catalog":
+      return { icon: FolderOpen, colorClass: "text-emerald-500" };
+    case "nacos-namespace":
+    case "etcd-root":
+      return { icon: FolderOpen, colorClass: "text-sky-500" };
+    case "zookeeper-root":
+      return { icon: Database, colorClass: "text-blue-500" };
+    case "table":
+      return { icon: Table, colorClass: "text-green-500" };
+    case "view":
+      return { icon: Eye, colorClass: "text-purple-500" };
+    case "materialized_view":
+      return { icon: Eye, colorClass: "text-indigo-500" };
+    case "column":
+      return { icon: Columns3, colorClass: (node.meta as ColumnInfo | undefined)?.is_primary_key ? "text-orange-400" : "text-muted-foreground" };
+    case "group-columns":
+      return { icon: ListTree, colorClass: "text-green-400" };
+    case "group-indexes":
+    case "index":
+      return { icon: Key, colorClass: "text-amber-500" };
+    case "group-fkeys":
+      return { icon: Link, colorClass: "text-blue-400" };
+    case "fkey":
+      return { icon: Link, colorClass: "text-blue-300" };
+    case "group-triggers":
+      return { icon: Zap, colorClass: "text-orange-400" };
+    case "trigger":
+      return { icon: Zap, colorClass: "text-orange-300" };
+    case "object-browser":
+      return { icon: TableProperties, colorClass: "text-primary" };
+    case "user-admin":
+      return { icon: UsersRound, colorClass: "text-primary" };
+    case "redis-db":
+      return { icon: Database, colorClass: "text-red-400" };
+    case "mongo-gridfs":
+    case "mongo-buckets":
+      return { icon: Archive, colorClass: "text-cyan-500" };
+    case "mongo-bucket":
+      return { icon: Archive, colorClass: "text-cyan-400" };
+    case "mongo-collection":
+      return { icon: Table, colorClass: "text-green-400" };
+    case "vector-collection":
+      return { icon: TableProperties, colorClass: "text-cyan-400" };
+    case "elasticsearch-index":
+      return { icon: Table, colorClass: "text-emerald-400" };
+    case "procedure":
+      return { icon: ScrollText, colorClass: "text-blue-500" };
+    case "function":
+      return { icon: Braces, colorClass: "text-amber-500" };
+    case "sequence":
+      return { icon: ListTree, colorClass: "text-emerald-500" };
+    case "package":
+      return { icon: Package, colorClass: "text-cyan-500" };
+    case "package-body":
+      return { icon: FileCode, colorClass: "text-cyan-400" };
+    case "group-tables":
+      return { icon: Table, colorClass: "text-green-500" };
+    case "group-views":
+      return { icon: Eye, colorClass: "text-purple-500" };
+    case "group-materialized-views":
+      return { icon: Eye, colorClass: "text-indigo-500" };
+    case "group-procedures":
+      return { icon: ScrollText, colorClass: "text-blue-500" };
+    case "group-functions":
+      return { icon: Braces, colorClass: "text-amber-500" };
+    case "group-sequences":
+      return { icon: ListTree, colorClass: "text-emerald-500" };
+    case "group-packages":
+      return { icon: Package, colorClass: "text-cyan-500" };
+    case "group-partitions":
+      return { icon: node.isExpanded ? FolderOpen : FolderClosed, colorClass: "text-green-400" };
+    case "group-extensions":
+      return { icon: Package, colorClass: "text-violet-500" };
+    case "extension":
+      return { icon: Package, colorClass: "text-violet-400" };
+    case "load-more":
+      return { icon: Plus, colorClass: "text-primary" };
+    default:
+      return { icon: Database, colorClass: "text-muted-foreground" };
+  }
+}
diff --git a/apps/desktop/src/lib/sidebar/treeRefreshTarget.ts b/apps/desktop/src/lib/sidebar/treeRefreshTarget.ts
new file mode 100644
index 0000000..62ebb56
--- /dev/null
+++ b/apps/desktop/src/lib/sidebar/treeRefreshTarget.ts
@@ -0,0 +1,14 @@
+import type { TreeNode } from "@/types/database";
+
+export function findDatabaseTreeNode(nodes: TreeNode[], connectionId: string, database: string): TreeNode | null {
+  for (const node of nodes) {
+    if (node.type === "database" && node.connectionId === connectionId && node.database === database) {
+      return node;
+    }
+    if (node.children) {
+      const found = findDatabaseTreeNode(node.children, connectionId, database);
+      if (found) return found;
+    }
+  }
+  return null;
+}
diff --git a/apps/desktop/src/lib/sql/cloudflareD1.ts b/apps/desktop/src/lib/sql/cloudflareD1.ts
new file mode 100644
index 0000000..f52c6ac
--- /dev/null
+++ b/apps/desktop/src/lib/sql/cloudflareD1.ts
@@ -0,0 +1 @@
+export const CLOUDFLARE_D1_COMMON_FUNCTION_NAMES = new Set(["ABS", "AVG", "CAST", "CEIL", "COALESCE", "CONCAT", "COUNT", "FLOOR", "LENGTH", "LOWER", "LTRIM", "MAX", "MIN", "MOD", "NULLIF", "REPLACE", "ROUND", "RTRIM", "SIGN", "SQRT", "SUBSTR", "SUBSTRING", "SUM", "TRIM", "UPPER"]);
diff --git a/apps/desktop/src/lib/sql/currentStatementFrame.ts b/apps/desktop/src/lib/sql/currentStatementFrame.ts
new file mode 100644
index 0000000..ae23e3b
--- /dev/null
+++ b/apps/desktop/src/lib/sql/currentStatementFrame.ts
@@ -0,0 +1,59 @@
+import type { SqlTextRange } from "@/lib/sql/sqlStatementRanges";
+
+export function currentStatementFrameRangeTo(nextChar: string, range: SqlTextRange): number {
+  return nextChar === ";" ? range.to + 1 : range.to;
+}
+
+export function visualSqlColumns(text: string): number {
+  let columns = 0;
+  for (const ch of text) {
+    if (ch === "\t") {
+      columns += 4;
+    } else if (isWideSqlChar(ch)) {
+      columns += 2;
+    } else {
+      columns += 1;
+    }
+  }
+  return columns;
+}
+
+export function isWideSqlChar(ch: string): boolean {
+  return /[\u1100-\u115f\u2329\u232a\u2e80-\u303e\u3040-\ua4cf\uac00-\ud7a3\uf900-\ufaff\ufe10-\ufe19\ufe30-\ufe6f\uff00-\uff60\uffe0-\uffe6]/u.test(ch);
+}
+
+/** Approximate visual columns for a `.cm-insert-value-hint` widget (0.85em text + padding/margin). */
+export function estimateInlineHintVisualColumns(label: string): number {
+  // Slightly generous vs CSS (0.85em font + 0.3em*2 padding + 0.35em margin) so the
+  // statement frame does not clip past inlay hints.
+  return Math.max(2, Math.ceil(label.length * 0.9 + 2.2));
+}
+
+export interface InlineHintForFrameWidth {
+  from: number;
+  column: string;
+}
+
+/** Document text columns plus inline widget hints that sit on `[lineFrom, lineTo)`. */
+export function visualSqlColumnsWithInlineHints(text: string, lineFrom: number, lineTo: number, hints: readonly InlineHintForFrameWidth[] = []): number {
+  let columns = visualSqlColumns(text);
+  const seen = new Set<number>();
+  for (const hint of hints) {
+    if (hint.from < lineFrom || hint.from >= lineTo) continue;
+    if (seen.has(hint.from)) continue;
+    seen.add(hint.from);
+    columns += estimateInlineHintVisualColumns(hint.column);
+  }
+  return columns;
+}
+
+/** Measure rendered line width in CSS pixels, including inline widgets already in the DOM. */
+export function measureSqlLineWidthPx(view: { coordsAtPos: (pos: number, side?: -1 | 1) => { left: number; right: number; top: number; bottom: number } | null }, from: number, to: number): number | null {
+  if (to < from) return null;
+  const start = view.coordsAtPos(from, 1);
+  const end = view.coordsAtPos(to, -1);
+  if (!start || !end) return null;
+  // Ignore cross-line measurements (wrapping / mismatched sides).
+  if (Math.abs(start.top - end.top) > 2) return null;
+  return Math.max(0, end.right - start.left);
+}
diff --git a/apps/desktop/src/lib/sql/editableQueryHiddenKeys.ts b/apps/desktop/src/lib/sql/editableQueryHiddenKeys.ts
new file mode 100644
index 0000000..fb6e0d4
--- /dev/null
+++ b/apps/desktop/src/lib/sql/editableQueryHiddenKeys.ts
@@ -0,0 +1,61 @@
+import { sqlSemanticDialectFor } from "@/lib/sql/semantic/dialect";
+import { tokenizeSqlSemantic } from "@/lib/sql/semantic/tokens";
+import type { DatabaseType } from "@/types/database";
+
+const HIDDEN_PRIMARY_KEY_ALIAS_PREFIX = "__DBX_PK_";
+
+export interface HiddenPrimaryKeyProjection {
+  sourceName: string;
+  alias: string;
+}
+
+export interface HiddenPrimaryKeyQuery {
+  sql: string;
+  projections: HiddenPrimaryKeyProjection[];
+}
+
+export function buildQueryWithHiddenPrimaryKeys(options: { sql: string; databaseType: DatabaseType; primaryKeys: string[]; existingResultNames: string[] }): HiddenPrimaryKeyQuery | undefined {
+  if (options.primaryKeys.length === 0) return undefined;
+
+  const dialect = sqlSemanticDialectFor({ databaseType: options.databaseType });
+  const usedNames = new Set(options.existingResultNames.map((name) => name.toLowerCase()));
+  const projections = options.primaryKeys.map((sourceName, index) => {
+    let suffix = index;
+    let alias = `${HIDDEN_PRIMARY_KEY_ALIAS_PREFIX}${suffix}`;
+    while (usedNames.has(alias.toLowerCase())) {
+      suffix += 1;
+      alias = `${HIDDEN_PRIMARY_KEY_ALIAS_PREFIX}${suffix}`;
+    }
+    usedNames.add(alias.toLowerCase());
+    return { sourceName, alias };
+  });
+  const expressions = projections.map(({ sourceName, alias }) => `${dialect.quoteIdentifier(sourceName)} AS ${dialect.quoteIdentifier(alias)}`);
+  const sql = appendSelectProjections(options.sql, expressions);
+  return sql ? { sql, projections } : undefined;
+}
+
+export function hiddenResultColumnIndexes(columns: string[], projections: HiddenPrimaryKeyProjection[]): number[] {
+  return projections.flatMap((projection) => {
+    const index = columns.findIndex((column) => column.toLowerCase() === projection.alias.toLowerCase());
+    return index < 0 ? [] : [index];
+  });
+}
+
+function appendSelectProjections(sql: string, expressions: string[]): string | undefined {
+  if (expressions.length === 0) return sql;
+  const tokens = tokenizeSqlSemantic(sql);
+  const selectIndex = tokens.findIndex((token) => token.kind === "word" && token.depth === 0 && token.normalized === "select");
+  if (selectIndex < 0) return undefined;
+  const fromIndex = tokens.findIndex((token, index) => index > selectIndex && token.kind === "word" && token.depth === 0 && token.normalized === "from");
+  if (fromIndex < 0) return undefined;
+
+  let projectionEnd: number | undefined;
+  for (let index = fromIndex - 1; index > selectIndex; index -= 1) {
+    const token = tokens[index];
+    if (token?.kind === "comment") continue;
+    projectionEnd = token?.span.end;
+    break;
+  }
+  if (projectionEnd === undefined) return undefined;
+  return `${sql.slice(0, projectionEnd)}, ${expressions.join(", ")}${sql.slice(projectionEnd)}`;
+}
diff --git a/apps/desktop/src/lib/sql/executableStatementRangeCache.ts b/apps/desktop/src/lib/sql/executableStatementRangeCache.ts
new file mode 100644
index 0000000..4011879
--- /dev/null
+++ b/apps/desktop/src/lib/sql/executableStatementRangeCache.ts
@@ -0,0 +1,79 @@
+import type { Text } from "@codemirror/state";
+import type { DatabaseType } from "@/types/database";
+import { executableStatementRanges, type SqlTextRange } from "@/lib/sql/sqlStatementRanges";
+
+export interface ExecutableStatementRangeCache {
+  doc: Text;
+  databaseType?: DatabaseType;
+  byStart: Map<number, SqlTextRange>;
+  byExecutableLineStart: Map<number, SqlTextRange>;
+  ranges: SqlTextRange[];
+}
+
+export type ExecutableStatementRangeParser = (sql: string, databaseType?: DatabaseType) => SqlTextRange[];
+
+export function executableStatementRangeCacheForDoc(cache: ExecutableStatementRangeCache | null, doc: Text, databaseType?: DatabaseType, parse: ExecutableStatementRangeParser = executableStatementRanges): ExecutableStatementRangeCache {
+  if (cache?.doc === doc && cache.databaseType === databaseType) return cache;
+
+  const byStart = new Map<number, SqlTextRange>();
+  const byExecutableLineStart = new Map<number, SqlTextRange>();
+  const ranges = parse(doc.toString(), databaseType);
+  for (const range of ranges) {
+    byStart.set(range.from, range);
+    const line = doc.lineAt(range.from);
+    if (doc.sliceString(line.from, range.from).trim() === "") {
+      byExecutableLineStart.set(line.from, range);
+    }
+  }
+  return { doc, databaseType, byStart, byExecutableLineStart, ranges };
+}
+
+export function executableStatementRangeStartingAt(cache: ExecutableStatementRangeCache, lineFrom: number): SqlTextRange | null {
+  return cache.byStart.get(lineFrom) ?? cache.byExecutableLineStart.get(lineFrom) ?? null;
+}
+
+export function executableStatementRangeAtCursor(cache: ExecutableStatementRangeCache, cursorPos: number): SqlTextRange | null {
+  const pos = Math.max(0, Math.min(cursorPos, cache.doc.length));
+  const line = cache.doc.lineAt(pos);
+  const lineText = line.text.trim();
+  if (!lineText || lineText.startsWith("--") || lineText.startsWith("#") || isCursorOnLeadingBlockComment(line.text, pos - line.from)) return null;
+
+  for (let index = 0; index < cache.ranges.length; index += 1) {
+    const range = cache.ranges[index];
+    if (pos >= range.from && pos <= range.to) return range;
+
+    if (pos < range.from && range.from <= line.to && cache.doc.sliceString(pos, range.from).trim() === "") {
+      return range;
+    }
+
+    const next = cache.ranges[index + 1];
+    if (pos > range.to && (!next || pos < next.from) && range.to >= line.from && range.to <= line.to && cursorRemainsOnRangeLine(cache.doc, range.to, pos)) {
+      return range;
+    }
+  }
+
+  return null;
+}
+
+function isCursorOnLeadingBlockComment(lineText: string, lineOffset: number): boolean {
+  const commentStart = lineText.search(/\S/);
+  if (commentStart < 0 || !lineText.startsWith("/*", commentStart)) return false;
+
+  const commentEnd = lineText.indexOf("*/", commentStart + 2);
+  if (commentEnd < 0) return true;
+  const afterComment = lineText.slice(commentEnd + 2);
+  if (!afterComment.trim()) return true;
+
+  return lineOffset <= commentEnd + 2;
+}
+
+function cursorRemainsOnRangeLine(doc: Text, rangeTo: number, cursorPos: number): boolean {
+  const between = doc.sliceString(rangeTo, cursorPos);
+  if (between.includes("\n")) return false;
+  const delimiterIndex = between.lastIndexOf(";");
+  if (delimiterIndex === -1) return between.trim() === "";
+
+  const beforeDelimiter = between.slice(0, delimiterIndex);
+  const afterDelimiter = between.slice(delimiterIndex + 1);
+  return beforeDelimiter.trim() === "" && afterDelimiter.trim() === "";
+}
diff --git a/apps/desktop/src/lib/sql/httpSqlFileProgress.ts b/apps/desktop/src/lib/sql/httpSqlFileProgress.ts
new file mode 100644
index 0000000..04b67ae
--- /dev/null
+++ b/apps/desktop/src/lib/sql/httpSqlFileProgress.ts
@@ -0,0 +1,17 @@
+import type { SqlFileProgress } from "@/lib/backend/tauri";
+import { apiUrl } from "@/lib/common/webPath";
+
+export function listenSqlFileProgressById(executionId: string, handler: (progress: SqlFileProgress) => void): () => void {
+  const es = new EventSource(apiUrl(`/api/sql-file/progress/${executionId}`));
+  es.onmessage = (e) => {
+    const progress: SqlFileProgress = JSON.parse(e.data);
+    handler(progress);
+    if (progress.status === "done" || progress.status === "error" || progress.status === "cancelled") {
+      es.close();
+    }
+  };
+  es.onerror = () => {
+    es.close();
+  };
+  return () => es.close();
+}
diff --git a/apps/desktop/src/lib/sql/insertValueHints.ts b/apps/desktop/src/lib/sql/insertValueHints.ts
new file mode 100644
index 0000000..39e75af
--- /dev/null
+++ b/apps/desktop/src/lib/sql/insertValueHints.ts
@@ -0,0 +1,499 @@
+import { findActiveSqlStatementSpan, tokenizeSqlSemantic, tokenIsIdentifier, unquoteSqlSemanticIdentifier } from "@/lib/sql/semantic/tokens";
+import type { SqlSemanticSpan, SqlSemanticToken } from "@/lib/sql/semantic/types";
+
+export interface InsertValueHint {
+  /** Document offset where the inlay widget is inserted (before the value expression). */
+  from: number;
+  column: string;
+}
+
+export interface InsertValuesClause {
+  table: string;
+  schema?: string;
+  /** Catalog/database qualifier for three-part names like OtherDb.dbo.Users. */
+  database?: string;
+  /** Explicit column list, or null when `INSERT INTO t VALUES` has no column list. */
+  columns: string[] | null;
+  /** For each VALUES row, start offsets of top-level value expressions. */
+  rows: number[][];
+  span: SqlSemanticSpan;
+}
+
+export interface ParseInsertValueHintsOptions {
+  /** Resolve table columns when the INSERT has no explicit column list. */
+  resolveTableColumns?: (table: string, schema?: string, database?: string) => string[] | undefined;
+}
+
+export interface TextRange {
+  from: number;
+  to: number;
+}
+
+function significantTokens(tokens: readonly SqlSemanticToken[]): SqlSemanticToken[] {
+  return tokens.filter((item) => item.kind !== "comment");
+}
+
+function statementSpans(sql: string, tokens: readonly SqlSemanticToken[]): SqlSemanticSpan[] {
+  const spans: SqlSemanticSpan[] = [];
+  let start = 0;
+  for (const item of tokens) {
+    if (item.kind !== "punctuation" || item.text !== ";" || item.depth !== 0) continue;
+    const span = trimSpan(sql, start, item.span.start);
+    if (span.end > span.start) spans.push(span);
+    start = item.span.end;
+  }
+  const last = trimSpan(sql, start, sql.length);
+  if (last.end > last.start) spans.push(last);
+  return spans;
+}
+
+function trimSpan(sql: string, start: number, end: number): SqlSemanticSpan {
+  let from = start;
+  let to = end;
+  while (from < to && /\s/.test(sql[from] ?? "")) from += 1;
+  while (to > from && /\s/.test(sql[to - 1] ?? "")) to -= 1;
+  return { start: from, end: to };
+}
+
+function tokensInSpan(tokens: readonly SqlSemanticToken[], span: SqlSemanticSpan): SqlSemanticToken[] {
+  return tokens.filter((item) => item.span.end > span.start && item.span.start < span.end);
+}
+
+function findWordIndex(tokens: readonly SqlSemanticToken[], word: string, from = 0): number {
+  const needle = word.toLowerCase();
+  for (let index = from; index < tokens.length; index += 1) {
+    const item = tokens[index];
+    if (item?.kind === "word" && item.normalized === needle) return index;
+  }
+  return -1;
+}
+
+export function readQualifiedName(tokens: readonly SqlSemanticToken[], startIndex: number): { name: string; schema?: string; database?: string; nextIndex: number } | null {
+  const first = tokens[startIndex];
+  if (!tokenIsIdentifier(first)) return null;
+  const parts = [unquoteSqlSemanticIdentifier(first)];
+  let index = startIndex + 1;
+  while (tokens[index]?.text === "." && tokenIsIdentifier(tokens[index + 1])) {
+    parts.push(unquoteSqlSemanticIdentifier(tokens[index + 1]!));
+    index += 2;
+  }
+  if (parts.length >= 3) {
+    return {
+      database: parts[parts.length - 3],
+      schema: parts[parts.length - 2],
+      name: parts[parts.length - 1]!,
+      nextIndex: index,
+    };
+  }
+  if (parts.length === 2) {
+    return { schema: parts[0], name: parts[1]!, nextIndex: index };
+  }
+  return { name: parts[0]!, nextIndex: index };
+}
+
+function parseColumnList(tokens: readonly SqlSemanticToken[], openIndex: number): { columns: string[]; nextIndex: number } | null {
+  const open = tokens[openIndex];
+  if (!open || open.text !== "(") return null;
+  const columns: string[] = [];
+  let index = openIndex + 1;
+  while (index < tokens.length) {
+    const item = tokens[index];
+    if (!item) break;
+    if (item.text === ")" && item.depth === open.depth) {
+      return { columns, nextIndex: index + 1 };
+    }
+    if (tokenIsIdentifier(item) && item.depth === open.depth + 1) {
+      columns.push(unquoteSqlSemanticIdentifier(item));
+      index += 1;
+      continue;
+    }
+    index += 1;
+  }
+  return { columns, nextIndex: index };
+}
+
+function valueStartsInRow(tokens: readonly SqlSemanticToken[], openIndex: number): { starts: number[]; nextIndex: number } | null {
+  const open = tokens[openIndex];
+  if (!open || open.text !== "(") return null;
+  const contentDepth = open.depth + 1;
+  const starts: number[] = [];
+  let expectValue = true;
+  let index = openIndex + 1;
+
+  while (index < tokens.length) {
+    const item = tokens[index];
+    if (!item) break;
+    if (item.text === ")" && item.depth === open.depth) {
+      return { starts, nextIndex: index + 1 };
+    }
+    if (expectValue && item.depth === contentDepth) {
+      starts.push(item.span.start);
+      expectValue = false;
+    }
+    if (item.text === "," && item.depth === contentDepth) {
+      expectValue = true;
+    }
+    index += 1;
+  }
+  return { starts, nextIndex: index };
+}
+
+function parseValuesRows(tokens: readonly SqlSemanticToken[], valuesIndex: number): number[][] {
+  const rows: number[][] = [];
+  let index = valuesIndex + 1;
+  while (index < tokens.length) {
+    const item = tokens[index];
+    if (!item) break;
+    if (item.kind === "word" && (item.normalized === "returning" || item.normalized === "on" || item.normalized === "select")) break;
+    if (item.text === "(") {
+      const row = valueStartsInRow(tokens, index);
+      if (!row) break;
+      if (row.starts.length > 0) rows.push(row.starts);
+      index = row.nextIndex;
+      continue;
+    }
+    if (item.text === ",") {
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  return rows;
+}
+
+function parseInsertClause(tokens: readonly SqlSemanticToken[], span: SqlSemanticSpan): InsertValuesClause | null {
+  const insertIndex = findWordIndex(tokens, "insert");
+  if (insertIndex < 0) return null;
+  const intoIndex = findWordIndex(tokens, "into", insertIndex + 1);
+  if (intoIndex < 0) return null;
+
+  const tableInfo = readQualifiedName(tokens, intoIndex + 1);
+  if (!tableInfo) return null;
+
+  let index = tableInfo.nextIndex;
+  let columns: string[] | null = null;
+
+  // SQL Server table hints appear between the target table and INSERT column list.
+  if (tokens[index]?.normalized === "with" && tokens[index + 1]?.text === "(") {
+    const hintList = parseColumnList(tokens, index + 1);
+    if (!hintList) return null;
+    index = hintList.nextIndex;
+  }
+
+  // Optional alias between table and column list / VALUES / SELECT
+  if (tokenIsIdentifier(tokens[index]) && tokens[index]?.normalized !== "values" && tokens[index]?.normalized !== "select" && tokens[index]?.normalized !== "default") {
+    const maybeAs = tokens[index];
+    if (maybeAs?.normalized === "as" && tokenIsIdentifier(tokens[index + 1])) {
+      index += 2;
+    } else if (tokens[index]?.text !== "(") {
+      index += 1;
+    }
+  }
+
+  if (tokens[index]?.text === "(") {
+    const columnList = parseColumnList(tokens, index);
+    if (!columnList) return null;
+    columns = columnList.columns;
+    index = columnList.nextIndex;
+  }
+
+  const valuesIndex = findWordIndex(tokens, "values", index);
+  const selectIndex = findWordIndex(tokens, "select", index);
+  if (valuesIndex < 0) return null;
+  if (selectIndex >= 0 && selectIndex < valuesIndex) return null;
+
+  const rows = parseValuesRows(tokens, valuesIndex);
+  if (rows.length === 0) return null;
+
+  return {
+    table: tableInfo.name,
+    schema: tableInfo.schema,
+    database: tableInfo.database,
+    columns,
+    rows,
+    span,
+  };
+}
+
+function shiftClause(clause: InsertValuesClause, offset: number): InsertValuesClause {
+  if (offset === 0) return clause;
+  return {
+    ...clause,
+    span: { start: clause.span.start + offset, end: clause.span.end + offset },
+    rows: clause.rows.map((row) => row.map((from) => from + offset)),
+  };
+}
+
+/**
+ * Expand [from, to) to the nearest top-level statement window (quote/comment aware).
+ * Scans at most LOOKBACK bytes before `from` and LOOKAHEAD after `to` so large scripts
+ * do not pay O(document) on every keystroke.
+ */
+const STATEMENT_LOOKBACK = 32 * 1024;
+const STATEMENT_LOOKAHEAD = 32 * 1024;
+
+export function expandToSqlStatementWindow(sql: string, from: number, to: number): TextRange {
+  const safeFrom = Math.max(0, Math.min(from, sql.length));
+  const safeTo = Math.max(safeFrom, Math.min(to, sql.length));
+  const scanFrom = Math.max(0, safeFrom - STATEMENT_LOOKBACK);
+  const scanTo = Math.min(sql.length, safeTo + STATEMENT_LOOKAHEAD);
+  const slice = scanFrom === 0 && scanTo === sql.length ? sql : sql.slice(scanFrom, scanTo);
+  const localFrom = safeFrom - scanFrom;
+  const localTo = safeTo - scanFrom;
+  const start = findStatementStart(slice, localFrom) + scanFrom;
+  const end = findStatementEnd(slice, Math.max(localFrom, localTo)) + scanFrom;
+  const trimmed = trimSpan(sql, start, Math.min(end, scanTo));
+  return { from: trimmed.start, to: trimmed.end };
+}
+
+function findStatementStart(sql: string, pos: number): number {
+  let index = 0;
+  let start = 0;
+  let depth = 0;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let quote: string | null = null;
+
+  while (index < pos) {
+    const ch = sql[index] ?? "";
+    const next = sql[index + 1] ?? "";
+
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      index += 1;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        index += 2;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    if (quote) {
+      if (ch === quote) {
+        if (next === quote) {
+          index += 2;
+          continue;
+        }
+        quote = null;
+      }
+      index += 1;
+      continue;
+    }
+
+    if (ch === "-" && next === "-") {
+      inLineComment = true;
+      index += 2;
+      continue;
+    }
+    if (ch === "#") {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      index += 2;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      quote = ch;
+      index += 1;
+      continue;
+    }
+    if (ch === "[") {
+      quote = "]";
+      index += 1;
+      continue;
+    }
+    if (ch === "(") {
+      depth += 1;
+      index += 1;
+      continue;
+    }
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1);
+      index += 1;
+      continue;
+    }
+    if (ch === ";" && depth === 0) {
+      start = index + 1;
+      index += 1;
+      continue;
+    }
+    index += 1;
+  }
+  return start;
+}
+
+function findStatementEnd(sql: string, pos: number): number {
+  let index = pos;
+  let depth = 0;
+  let inLineComment = false;
+  let inBlockComment = false;
+  let quote: string | null = null;
+
+  while (index < sql.length) {
+    const ch = sql[index] ?? "";
+    const next = sql[index + 1] ?? "";
+
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      index += 1;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        index += 2;
+        continue;
+      }
+      index += 1;
+      continue;
+    }
+    if (quote) {
+      if ((quote === "]" && ch === "]") || (quote !== "]" && ch === quote)) {
+        if (next === (quote === "]" ? "]" : quote)) {
+          index += 2;
+          continue;
+        }
+        quote = null;
+      }
+      index += 1;
+      continue;
+    }
+
+    if (ch === "-" && next === "-") {
+      inLineComment = true;
+      index += 2;
+      continue;
+    }
+    if (ch === "#") {
+      inLineComment = true;
+      index += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      index += 2;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      quote = ch;
+      index += 1;
+      continue;
+    }
+    if (ch === "[") {
+      quote = "]";
+      index += 1;
+      continue;
+    }
+    if (ch === "(") {
+      depth += 1;
+      index += 1;
+      continue;
+    }
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1);
+      index += 1;
+      continue;
+    }
+    if (ch === ";" && depth === 0) {
+      return index;
+    }
+    index += 1;
+  }
+  return sql.length;
+}
+
+function mergeTextRanges(ranges: readonly TextRange[]): TextRange[] {
+  if (ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b) => a.from - b.from || a.to - b.to);
+  const merged: TextRange[] = [{ ...sorted[0]! }];
+  for (let index = 1; index < sorted.length; index += 1) {
+    const current = sorted[index]!;
+    const last = merged[merged.length - 1]!;
+    if (current.from <= last.to) {
+      last.to = Math.max(last.to, current.to);
+    } else {
+      merged.push({ ...current });
+    }
+  }
+  return merged;
+}
+
+/** Parse INSERT ... VALUES clauses only inside the given document ranges (expanded to statement windows). */
+export function parseInsertValuesClausesInRanges(sql: string, ranges: readonly TextRange[]): InsertValuesClause[] {
+  if (!sql.trim() || ranges.length === 0) return [];
+  const windows = mergeTextRanges(ranges.map((range) => expandToSqlStatementWindow(sql, range.from, range.to)));
+  const clauses: InsertValuesClause[] = [];
+  for (const window of windows) {
+    if (window.to <= window.from) continue;
+    const slice = sql.slice(window.from, window.to);
+    for (const clause of parseInsertValuesClauses(slice)) {
+      clauses.push(shiftClause(clause, window.from));
+    }
+  }
+  return clauses;
+}
+
+/** Parse all INSERT ... VALUES clauses in `sql` (multi-statement aware). Prefer ranged parsing for editors. */
+export function parseInsertValuesClauses(sql: string): InsertValuesClause[] {
+  if (!sql.trim()) return [];
+  const allTokens = tokenizeSqlSemantic(sql);
+  const spans = statementSpans(sql, allTokens);
+  const clauses: InsertValuesClause[] = [];
+  for (const span of spans) {
+    const tokens = significantTokens(tokensInSpan(allTokens, span));
+    const clause = parseInsertClause(tokens, span);
+    if (clause) clauses.push(clause);
+  }
+  return clauses;
+}
+
+/** Build inlay hint positions from parsed clauses and optional table-column resolver. */
+export function buildInsertValueHints(clauses: readonly InsertValuesClause[], options: ParseInsertValueHintsOptions = {}): InsertValueHint[] {
+  const hints: InsertValueHint[] = [];
+  for (const clause of clauses) {
+    const columns = clause.columns ?? options.resolveTableColumns?.(clause.table, clause.schema, clause.database);
+    if (!columns || columns.length === 0) continue;
+    for (const row of clause.rows) {
+      const count = Math.min(row.length, columns.length);
+      for (let index = 0; index < count; index += 1) {
+        const from = row[index];
+        const column = columns[index];
+        if (from === undefined || !column) continue;
+        hints.push({ from, column });
+      }
+    }
+  }
+  return hints;
+}
+
+/** Parse SQL and return insert-value inlay hints. */
+export function parseInsertValueHints(sql: string, options: ParseInsertValueHintsOptions = {}): InsertValueHint[] {
+  return buildInsertValueHints(parseInsertValuesClauses(sql), options);
+}
+
+/** Parse only the statements covering `ranges` and return insert-value inlay hints. */
+export function parseInsertValueHintsInRanges(sql: string, ranges: readonly TextRange[], options: ParseInsertValueHintsOptions = {}): InsertValueHint[] {
+  return buildInsertValueHints(parseInsertValuesClausesInRanges(sql, ranges), options);
+}
+
+/** True when the document still needs table metadata for at least one INSERT without a column list. */
+export function insertValueHintsNeedTableColumns(sql: string): InsertValuesClause[] {
+  return parseInsertValuesClauses(sql).filter((clause) => clause.columns === null);
+}
+
+/** Convenience: hints for the statement containing `cursor` only. */
+export function parseInsertValueHintsAtCursor(sql: string, cursor: number, options: ParseInsertValueHintsOptions = {}): InsertValueHint[] {
+  const tokens = tokenizeSqlSemantic(sql);
+  const span = findActiveSqlStatementSpan(sql, tokens, cursor);
+  const statementTokens = significantTokens(tokensInSpan(tokens, span));
+  const clause = parseInsertClause(statementTokens, span);
+  if (!clause) return [];
+  return buildInsertValueHints([clause], options);
+}
diff --git a/apps/desktop/src/lib/sql/newQueryContext.ts b/apps/desktop/src/lib/sql/newQueryContext.ts
new file mode 100644
index 0000000..b521821
--- /dev/null
+++ b/apps/desktop/src/lib/sql/newQueryContext.ts
@@ -0,0 +1,61 @@
+import { resolveDefaultDatabase } from "@/lib/database/defaultDatabase";
+import type { ConnectionConfig, QueryTab, TreeNode } from "@/types/database";
+
+export interface NewQueryTarget {
+  connectionId: string;
+  database: string;
+  schema?: string;
+  shouldRefreshDefaultDatabase: boolean;
+}
+
+export type NewQueryContextSource = "tab" | "sidebar";
+
+interface ResolveNewQueryTargetInput {
+  activeTab?: Pick<QueryTab, "connectionId" | "database" | "schema">;
+  selectedTreeNode?: Pick<TreeNode, "connectionId" | "database" | "schema"> | null;
+  activeConnectionId?: string | null;
+  connections: Pick<ConnectionConfig, "id" | "database">[];
+  preferredSource?: NewQueryContextSource;
+}
+
+export function findTreeNodeById(nodes: TreeNode[], id: string | null | undefined): TreeNode | null {
+  if (!id) return null;
+  for (const node of nodes) {
+    if (node.id === id) return node;
+    const found = findTreeNodeById(node.children || [], id);
+    if (found) return found;
+  }
+  return null;
+}
+
+export function resolveNewQueryTarget(input: ResolveNewQueryTargetInput): NewQueryTarget | null {
+  const primaryContext = input.preferredSource === "sidebar" ? input.selectedTreeNode || undefined : input.activeTab;
+  const secondaryContext = input.preferredSource === "sidebar" ? input.activeTab : input.selectedTreeNode || undefined;
+  const primaryTarget = targetFromContext(primaryContext, input.connections);
+  if (primaryTarget) return primaryTarget;
+  const secondaryTarget = targetFromContext(secondaryContext, input.connections);
+  if (secondaryTarget) return secondaryTarget;
+
+  const activeConnection = input.activeConnectionId ? input.connections.find((connection) => connection.id === input.activeConnectionId) : undefined;
+  const fallbackConnection = activeConnection || input.connections[0];
+  return fallbackConnection
+    ? {
+        connectionId: fallbackConnection.id,
+        database: resolveDefaultDatabase(fallbackConnection, []),
+        shouldRefreshDefaultDatabase: true,
+      }
+    : null;
+}
+
+function targetFromContext(context: Pick<QueryTab | TreeNode, "connectionId" | "database" | "schema"> | undefined, connections: Pick<ConnectionConfig, "id" | "database">[]): NewQueryTarget | null {
+  if (!context?.connectionId) return null;
+  const connection = connections.find((item) => item.id === context.connectionId);
+  if (!connection) return null;
+  const database = context.database || resolveDefaultDatabase(connection, []);
+  return {
+    connectionId: context.connectionId,
+    database,
+    schema: "schema" in context ? (context as { schema?: string }).schema : undefined,
+    shouldRefreshDefaultDatabase: !context.database,
+  };
+}
diff --git a/apps/desktop/src/lib/sql/queryCursorTableTarget.ts b/apps/desktop/src/lib/sql/queryCursorTableTarget.ts
new file mode 100644
index 0000000..65a800d
--- /dev/null
+++ b/apps/desktop/src/lib/sql/queryCursorTableTarget.ts
@@ -0,0 +1,184 @@
+import { isSchemaAware, isSingleDatabase } from "@/lib/database/databaseFeatureSupport";
+import { isSqlKeyword } from "@/lib/sql/sqlNavigation";
+import type { ActiveTabSidebarTarget } from "@/lib/sidebar/sidebarActiveTabTarget";
+import type { DatabaseType, QueryTab, TreeNode } from "@/types/database";
+
+export interface QueryCursorTableCandidate {
+  connectionId: string;
+  database: string;
+  schema?: string;
+  tableName: string;
+}
+
+export interface IdentifierPart {
+  value: string;
+  quoted: boolean;
+}
+
+function identifierChar(ch: string | undefined): boolean {
+  return !!ch && (/[A-Za-z0-9_$."`-]/.test(ch) || ch === "[" || ch === "]");
+}
+
+function readIdentifierWindow(sql: string, pos: number): string {
+  const clamped = Math.max(0, Math.min(pos, sql.length));
+  let from = clamped;
+  let to = clamped;
+
+  if (!identifierChar(sql[from]) && identifierChar(sql[from - 1])) {
+    from -= 1;
+    to = from + 1;
+  }
+
+  if (!identifierChar(sql[from])) return "";
+
+  while (from > 0 && identifierChar(sql[from - 1])) from -= 1;
+  while (to < sql.length && identifierChar(sql[to])) to += 1;
+  return sql.slice(from, to).replace(/^\.+|\.+$/g, "");
+}
+
+function splitQualifiedIdentifier(text: string): IdentifierPart[] {
+  const parts: IdentifierPart[] = [];
+  let current = "";
+  let quoted = false;
+  let quote: "`" | '"' | "]" | null = null;
+
+  function pushPart() {
+    const value = current.trim();
+    if (value) parts.push({ value, quoted });
+    current = "";
+    quoted = false;
+  }
+
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+
+    if (quote) {
+      if (quote === "]" && ch === "]") {
+        if (text[i + 1] === "]") {
+          current += "]";
+          i += 1;
+        } else {
+          quote = null;
+        }
+        continue;
+      }
+      if ((quote === "`" || quote === '"') && ch === quote) {
+        if (text[i + 1] === quote) {
+          current += ch;
+          i += 1;
+        } else {
+          quote = null;
+        }
+        continue;
+      }
+      current += ch;
+      continue;
+    }
+
+    if (ch === ".") {
+      pushPart();
+      continue;
+    }
+
+    if (ch === "`" || ch === '"') {
+      quoted = true;
+      quote = ch;
+      continue;
+    }
+
+    if (ch === "[") {
+      quoted = true;
+      quote = "]";
+      continue;
+    }
+
+    current += ch;
+  }
+
+  pushPart();
+  return parts;
+}
+
+export function extractQualifiedIdentifierPartsAt(sql: string, pos: number): IdentifierPart[] {
+  const text = readIdentifierWindow(sql, pos);
+  if (!text) return [];
+  const parts = splitQualifiedIdentifier(text);
+  const last = parts[parts.length - 1];
+  if (!last || (!last.quoted && isSqlKeyword(last.value))) return [];
+  return parts;
+}
+
+export function queryCursorTableCandidate(tab: QueryTab | undefined | null, databaseType?: DatabaseType): QueryCursorTableCandidate | null {
+  if (!tab || tab.mode !== "query" || !tab.connectionId || !tab.database) return null;
+
+  const cursor = tab.editorSelection?.head ?? tab.editorSelection?.anchor ?? tab.sql.length;
+  const parts = extractQualifiedIdentifierPartsAt(tab.sql, cursor).map((part) => part.value);
+  if (parts.length === 0) return null;
+
+  const tableName = parts[parts.length - 1];
+  let database = tab.database;
+  let schema = tab.schema;
+
+  if (parts.length >= 3) {
+    database = parts[parts.length - 3];
+    schema = parts[parts.length - 2];
+  } else if (parts.length === 2) {
+    if (databaseType && !isSchemaAware(databaseType) && !isSingleDatabase(databaseType)) {
+      database = parts[0];
+      schema = undefined;
+    } else {
+      schema = parts[0];
+    }
+  }
+
+  return { connectionId: tab.connectionId, database, schema, tableName };
+}
+
+export function qualifiedTableNameAtSqlPosition(sql: string, pos: number): string | null {
+  const parts = extractQualifiedIdentifierPartsAt(sql, pos).map((part) => part.value);
+  if (parts.length === 0) return null;
+  return parts.join(".");
+}
+
+export function queryContextTargetFromCandidate(tab: QueryTab | undefined | null, candidate?: QueryCursorTableCandidate | null): ActiveTabSidebarTarget | null {
+  if (!tab || tab.mode !== "query" || !tab.connectionId || !tab.database) return null;
+  return {
+    type: "query-context",
+    connectionId: tab.connectionId,
+    database: candidate?.database || tab.database,
+    schema: candidate?.schema ?? tab.schema,
+  };
+}
+
+function sameIdentifier(left: string | undefined, right: string | undefined): boolean {
+  return (left || "").toLowerCase() === (right || "").toLowerCase();
+}
+
+function nodeMatchesCandidate(node: TreeNode, candidate: QueryCursorTableCandidate): boolean {
+  if (node.type !== "table" && node.type !== "view" && node.type !== "materialized_view") return false;
+  if (node.connectionId !== candidate.connectionId) return false;
+  if (!sameIdentifier(node.database, candidate.database)) return false;
+  if (candidate.schema && !sameIdentifier(node.schema, candidate.schema)) return false;
+  return sameIdentifier(node.label, candidate.tableName);
+}
+
+export function findLoadedTableTargetForCandidate(nodes: readonly TreeNode[], candidate: QueryCursorTableCandidate): ActiveTabSidebarTarget | null {
+  for (const node of nodes) {
+    if (nodeMatchesCandidate(node, candidate)) {
+      return {
+        type: "table",
+        connectionId: candidate.connectionId,
+        database: node.database || candidate.database,
+        schema: node.schema || candidate.schema,
+        tableName: node.label,
+      };
+    }
+
+    if (node.children) {
+      const found = findLoadedTableTargetForCandidate(node.children, candidate);
+      if (found) return found;
+    }
+  }
+
+  return null;
+}
diff --git a/apps/desktop/src/lib/sql/queryError.ts b/apps/desktop/src/lib/sql/queryError.ts
new file mode 100644
index 0000000..d8d8fcd
--- /dev/null
+++ b/apps/desktop/src/lib/sql/queryError.ts
@@ -0,0 +1,16 @@
+export function isQueryTimeoutErrorMessage(message: string): boolean {
+  const lower = message.toLowerCase();
+  if (lower.includes("query timed out") || lower.includes("查询超时") || lower.includes("查詢逾時")) return true;
+  // Agent RPC client-side timeout (tokio::time::timeout in agent_driver.rs). This is the
+  // fallback when JDBC setQueryTimeout never fires (unsupported/unresponsive driver), so the
+  // backend already treats it as a query timeout (is_agent_rpc_timeout_error in query.rs) —
+  // surface the same action here to stay consistent with the backend.
+  if (/\bagent rpc call timed out\b/.test(lower)) return true;
+  if (/\b(?:canceling|cancelling|canceled|cancelled)\b[\s\S]{0,80}\bstatement\b[\s\S]{0,80}\btimeout\b/.test(lower)) return true;
+  if (/\b(?:connection|connect|pool|checkout|metadata|loading|health check|cancel request|ssh|tunnel)\b/.test(lower)) return false;
+  return (
+    /\b(?:query|statement|sql|execution|execute|executing)\b[\s\S]{0,80}\b(?:timed out|timeout expired|timeout exceeded|time-out)\b/.test(lower) ||
+    /\b(?:timed out|timeout expired|timeout exceeded|time-out)\b[\s\S]{0,80}\b(?:query|statement|sql|execution|execute|executing)\b/.test(lower) ||
+    /\bquery\b[\s\S]{0,80}\bexceeded\b[\s\S]{0,80}\b(?:execution\s+)?time\b/.test(lower)
+  );
+}
diff --git a/apps/desktop/src/lib/sql/queryExecutionState.ts b/apps/desktop/src/lib/sql/queryExecutionState.ts
new file mode 100644
index 0000000..c87a7fa
--- /dev/null
+++ b/apps/desktop/src/lib/sql/queryExecutionState.ts
@@ -0,0 +1,13 @@
+export interface QueryExecutionStateLike {
+  isExecuting: boolean;
+  isCancelling?: boolean;
+  executionId?: string;
+}
+
+export function canCancelQueryExecution(state: QueryExecutionStateLike): boolean {
+  return state.isExecuting && !!state.executionId && !state.isCancelling;
+}
+
+export function queryExecutionLabelKey(state: Pick<QueryExecutionStateLike, "isCancelling">): "common.loading" | "common.stopping" {
+  return state.isCancelling ? "common.stopping" : "common.loading";
+}
diff --git a/apps/desktop/src/lib/sql/queryResultSource.ts b/apps/desktop/src/lib/sql/queryResultSource.ts
new file mode 100644
index 0000000..6cf8f03
--- /dev/null
+++ b/apps/desktop/src/lib/sql/queryResultSource.ts
@@ -0,0 +1,24 @@
+import { buildSqlSemanticModel } from "@/lib/sql/semantic/model";
+import type { SqlSemanticRowSource } from "@/lib/sql/semantic/types";
+import type { DatabaseType } from "@/types/database";
+
+export interface QueryResultSourceLabelOptions {
+  database?: string;
+  databaseType?: DatabaseType;
+}
+
+function firstSourceOfKind(sources: SqlSemanticRowSource[], kind: SqlSemanticRowSource["kind"]): SqlSemanticRowSource | undefined {
+  return sources.filter((source) => source.kind === kind).sort((left, right) => left.sourceSpan.start - right.sourceSpan.start)[0];
+}
+
+export function queryResultSourceLabel(sql: string, options: QueryResultSourceLabelOptions = {}): string | undefined {
+  const statement = sql.trim();
+  if (!statement) return undefined;
+
+  const model = buildSqlSemanticModel(statement, statement.length, { databaseType: options.databaseType });
+  const source = firstSourceOfKind(model.rowSources, "mutation_target") ?? firstSourceOfKind(model.rowSources, "table");
+  if (!source?.name) return undefined;
+
+  const qualifier = source.qualifierParts[source.qualifierParts.length - 1]?.trim() || options.database?.trim();
+  return qualifier ? `${qualifier}.${source.name}` : source.name;
+}
diff --git a/apps/desktop/src/lib/sql/queryTimeout.ts b/apps/desktop/src/lib/sql/queryTimeout.ts
new file mode 100644
index 0000000..d3b4409
--- /dev/null
+++ b/apps/desktop/src/lib/sql/queryTimeout.ts
@@ -0,0 +1,17 @@
+import { splitSqlStatementRanges } from "@/lib/sql/sqlStatementRanges";
+import type { ConnectionConfig, DatabaseType } from "@/types/database";
+
+export const DEFAULT_QUERY_TIMEOUT_SECS = 60;
+
+export function queryTimeoutSecsForConnection(connection?: Pick<ConnectionConfig, "query_timeout_secs"> | null): number {
+  const value = Number(connection?.query_timeout_secs);
+  return Number.isFinite(value) && value >= 0 ? value : DEFAULT_QUERY_TIMEOUT_SECS;
+}
+
+export function frontendQueryTimeoutSecsForSql(sql: string, databaseType: DatabaseType | undefined, queryTimeoutSecs: number): number {
+  if (queryTimeoutSecs === 0) return 0;
+
+  const baseTimeoutSecs = Math.max(queryTimeoutSecs * 2, 60);
+  const statementCount = Math.max(splitSqlStatementRanges(sql, databaseType).length, 1);
+  return baseTimeoutSecs * statementCount;
+}
diff --git a/apps/desktop/src/lib/sql/semantic/README.md b/apps/desktop/src/lib/sql/semantic/README.md
new file mode 100644
index 0000000..638ab29
--- /dev/null
+++ b/apps/desktop/src/lib/sql/semantic/README.md
@@ -0,0 +1,13 @@
+# SQL Semantic
+
+This directory owns the pure frontend SQL semantic layer used by editor completion, diagnostics, and navigation.
+
+- `tokens.ts`: span-preserving SQL tokenization and active statement detection.
+- `dialect.ts`: dialect adapters for identifier normalization, quoting, qualifier roles, and projection alias visibility.
+- `model.ts`: active-statement semantic model, row-source parsing, cursor intent, and confidence/fallback output.
+- `completion.ts`: compatibility adapter from semantic intent to the existing SQL completion item builder.
+- `references.ts`: shared row-source references for completion, diagnostics, and navigation.
+- `diagnostics.ts`: SQL semantic diagnostic helpers and viewport range selection.
+- `fixtures.ts` and `types.ts`: test fixtures and shared semantic types.
+
+The older `sqlCompletion.ts` and `sqlNavigation.ts` files remain at `lib/` for now because they are broad public editor utilities. Move them only with a separate behavior-preserving migration.
diff --git a/apps/desktop/src/lib/sql/semantic/completion.ts b/apps/desktop/src/lib/sql/semantic/completion.ts
new file mode 100644
index 0000000..793a6d8
--- /dev/null
+++ b/apps/desktop/src/lib/sql/semantic/completion.ts
@@ -0,0 +1,211 @@
+import type { SqlCompletionColumn, SqlCompletionContext, SqlCompletionReferencedTable } from "@/lib/sql/sqlCompletion";
+import { SQL_SEMANTIC_DIALECTS } from "@/lib/sql/semantic/dialect";
+import type { SqlSemanticModel, SqlSemanticRowSource } from "@/lib/sql/semantic/types";
+
+export type SqlSemanticCompletionScopeKind = "keyword" | "table" | "schema" | "catalog" | "routine" | "columns" | "local";
+
+export interface SqlSemanticCompletionScope {
+  kind: SqlSemanticCompletionScopeKind;
+  prefix: string;
+  qualifierParts: string[];
+  targetSource?: SqlSemanticRowSource;
+  useRemoteMetadata: boolean;
+  fallbackReason?: string;
+}
+
+export function sqlSemanticReferencedTables(model: SqlSemanticModel): SqlCompletionReferencedTable[] {
+  return model.rowSources
+    .filter((source) => source.kind !== "unknown")
+    .map((source) => ({
+      name: source.name,
+      schema: source.qualifierParts[source.qualifierParts.length - 1],
+      alias: source.alias,
+      columns: source.columns,
+    }));
+}
+
+export function sqlSemanticLocalColumnsByTable(model: SqlSemanticModel): Map<string, SqlCompletionColumn[]> {
+  const columnsByTable = new Map<string, SqlCompletionColumn[]>();
+  for (const source of model.rowSources) {
+    if (!source.columns?.length) continue;
+    columnsByTable.set(
+      source.name,
+      source.columns.map((name) => ({
+        name,
+        table: source.name,
+        schema: source.qualifierParts[source.qualifierParts.length - 1],
+      })),
+    );
+  }
+  return columnsByTable;
+}
+
+function activeProjectionAliasClause(model: SqlSemanticModel): "where" | "groupBy" | "having" | "orderBy" | null {
+  const words = model.tokens.filter((token) => token.span.end <= model.cursor && token.kind === "word").map((token) => token.normalized);
+  for (let index = words.length - 1; index >= 0; index -= 1) {
+    const word = words[index];
+    const previous = words[index - 1];
+    if (word === "by" && previous === "order") return "orderBy";
+    if (word === "by" && previous === "group") return "groupBy";
+    if (word === "having") return "having";
+    if (word === "where") return "where";
+    if (word === "from" || word === "join" || word === "select") return null;
+  }
+  return null;
+}
+
+export function sqlSemanticProjectionAliasColumns(model: SqlSemanticModel): SqlCompletionColumn[] {
+  const clause = activeProjectionAliasClause(model);
+  if (!clause) return [];
+  const adapter = SQL_SEMANTIC_DIALECTS[model.dialectId] ?? SQL_SEMANTIC_DIALECTS.generic;
+  if (!adapter.projectionAliasVisibility[clause]) return [];
+  return model.projections
+    .filter((projection) => projection.name)
+    .map((projection) => ({
+      name: projection.name,
+      table: "__projection__",
+      comment: "Projection alias",
+    }));
+}
+
+export function sqlSemanticCompletionScope(model: SqlSemanticModel): SqlSemanticCompletionScope {
+  const intent = model.cursorIntent;
+  const targetSource = intent.targetSourceId ? model.rowSources.find((source) => source.id === intent.targetSourceId) : undefined;
+  switch (intent.kind) {
+    case "table":
+    case "delete_target":
+      return {
+        kind: "table",
+        prefix: intent.prefix,
+        qualifierParts: intent.qualifierParts,
+        useRemoteMetadata: intent.confidence !== "low",
+        fallbackReason: intent.fallbackReason,
+      };
+    case "schema":
+      return {
+        kind: "schema",
+        prefix: intent.prefix,
+        qualifierParts: intent.qualifierParts,
+        useRemoteMetadata: intent.confidence !== "low",
+        fallbackReason: intent.fallbackReason,
+      };
+    case "catalog":
+      return {
+        kind: "catalog",
+        prefix: intent.prefix,
+        qualifierParts: intent.qualifierParts,
+        useRemoteMetadata: intent.confidence !== "low",
+        fallbackReason: intent.fallbackReason,
+      };
+    case "routine":
+      return {
+        kind: "routine",
+        prefix: intent.prefix,
+        qualifierParts: intent.qualifierParts,
+        useRemoteMetadata: intent.confidence !== "low",
+        fallbackReason: intent.fallbackReason,
+      };
+    case "column":
+    case "alias_column":
+    case "insert_column":
+    case "update_column":
+    case "join_condition":
+    case "star":
+      return {
+        kind: "columns",
+        prefix: intent.prefix,
+        qualifierParts: intent.qualifierParts,
+        targetSource,
+        useRemoteMetadata: intent.confidence !== "low" && (!!targetSource || model.rowSources.length > 0),
+        fallbackReason: intent.fallbackReason,
+      };
+    case "suppressed":
+      return {
+        kind: "local",
+        prefix: intent.prefix,
+        qualifierParts: [],
+        useRemoteMetadata: false,
+        fallbackReason: intent.fallbackReason ?? "suppressed",
+      };
+    case "keyword":
+      return {
+        kind: "keyword",
+        prefix: intent.prefix,
+        qualifierParts: intent.qualifierParts,
+        useRemoteMetadata: false,
+        fallbackReason: intent.fallbackReason,
+      };
+  }
+}
+
+function semanticContextKind(model: SqlSemanticModel): SqlCompletionContext["contextKind"] {
+  switch (model.cursorIntent.kind) {
+    case "table":
+    case "schema":
+    case "catalog":
+    case "delete_target":
+      return "table";
+    case "routine":
+      return "routine";
+    case "alias_column":
+      return "alias_column";
+    case "insert_column":
+    case "update_column":
+    case "column":
+    case "star":
+      return "column";
+    case "join_condition":
+      return "join";
+    case "keyword":
+    case "suppressed":
+      return "keyword";
+  }
+}
+
+function semanticMutationTarget(model: SqlSemanticModel): SqlSemanticRowSource | undefined {
+  const targetId = model.cursorIntent.targetSourceId;
+  return targetId ? model.rowSources.find((source) => source.id === targetId) : model.rowSources.find((source) => source.kind === "mutation_target");
+}
+
+export function sqlCompletionContextFromSemantic(model: SqlSemanticModel, base: SqlCompletionContext): SqlCompletionContext {
+  if (model.cursorIntent.confidence === "low" || model.cursorIntent.kind === "suppressed") {
+    return base;
+  }
+  if ((base.suggestTables || base.exclusiveTableSuggestions) && model.cursorIntent.kind !== "table" && model.cursorIntent.kind !== "schema" && model.cursorIntent.kind !== "catalog" && model.cursorIntent.kind !== "delete_target") {
+    return base;
+  }
+
+  const scope = sqlSemanticCompletionScope(model);
+  const qualifier = model.cursorIntent.qualifierParts.length > 0 ? model.cursorIntent.qualifierParts.join(".") : undefined;
+  const referencedTables = sqlSemanticReferencedTables(model);
+  const mutationTarget = semanticMutationTarget(model);
+  const mutationSchema = mutationTarget?.qualifierParts[mutationTarget.qualifierParts.length - 1];
+  const suggestTables = scope.kind === "table" || scope.kind === "schema" || scope.kind === "catalog";
+  const suggestColumns = scope.kind === "columns";
+  const suggestRoutines = scope.kind === "routine";
+  const projectionAliases = sqlSemanticProjectionAliasColumns(model).map((column) => column.name);
+
+  return {
+    ...base,
+    prefix: model.cursorIntent.prefix,
+    qualifier,
+    qualifierParts: model.cursorIntent.qualifierParts.length > 0 ? [...model.cursorIntent.qualifierParts] : undefined,
+    suggestTables,
+    suggestColumns,
+    suggestKeywords: scope.kind === "keyword" || (!suggestTables && !suggestColumns && !suggestRoutines),
+    suggestRoutines,
+    suggestJoinConditions: model.cursorIntent.kind === "join_condition",
+    exclusiveTableSuggestions: suggestTables,
+    exclusiveColumnSuggestions: model.cursorIntent.kind === "alias_column" || model.cursorIntent.kind === "insert_column" || model.cursorIntent.kind === "update_column",
+    exclusiveRoutineSuggestions: suggestRoutines,
+    prioritizeSelectAliases: base.prioritizeSelectAliases || projectionAliases.length > 0,
+    selectAliases: projectionAliases.length > 0 ? projectionAliases : base.selectAliases,
+    referencedTables: referencedTables.length > 0 ? referencedTables : base.referencedTables,
+    insertTable: model.cursorIntent.kind === "insert_column" ? mutationTarget?.name : base.insertTable,
+    insertSchema: model.cursorIntent.kind === "insert_column" ? mutationSchema : base.insertSchema,
+    updateTarget: model.cursorIntent.kind === "update_column" && mutationTarget ? { table: mutationTarget.name, schema: mutationSchema } : base.updateTarget,
+    deleteTarget: model.cursorIntent.kind === "delete_target" && mutationTarget ? { table: mutationTarget.name, schema: mutationSchema } : base.deleteTarget,
+    onStar: model.cursorIntent.kind === "star" || base.onStar,
+    contextKind: semanticContextKind(model),
+  };
+}
diff --git a/apps/desktop/src/lib/sql/semantic/diagnostics.ts b/apps/desktop/src/lib/sql/semantic/diagnostics.ts
new file mode 100644
index 0000000..df06388
--- /dev/null
+++ b/apps/desktop/src/lib/sql/semantic/diagnostics.ts
@@ -0,0 +1,330 @@
+import type { SqlCompletionColumn, SqlCompletionTable } from "@/lib/sql/sqlCompletion";
+import { getSqlCompletionContext } from "@/lib/sql/sqlCompletion";
+import { executableStatementRanges, isOraclePlSqlStatement, type SqlTextRange } from "@/lib/sql/sqlStatementRanges";
+import type { DatabaseType, SqlColumnReference, SqlReferenceAnalysis, SqlReferenceScope, SqlTableReference, SqlTextSpan } from "@/types/database";
+
+export interface SqlSemanticDiagnostic {
+  span: SqlTextSpan;
+  message: string;
+  severity: "error" | "warning";
+}
+
+export interface SqlSemanticDiagnosticSchema {
+  tables: SqlCompletionTable[];
+  columnsByTable: Map<string, SqlCompletionColumn[]>;
+  missingTables?: Set<string>;
+  loadedColumnTables?: Set<string>;
+  sql?: string;
+}
+
+export interface SqlSemanticDiagnosticVisibleRange {
+  from: number;
+  to: number;
+}
+
+export function sqlSemanticDiagnosticRangesForViewport(sql: string, visibleRanges: readonly SqlSemanticDiagnosticVisibleRange[], databaseType?: DatabaseType): SqlTextRange[] {
+  const statements = executableStatementRanges(sql, databaseType);
+  if (statements.length === 0 || visibleRanges.length === 0) return [];
+
+  const selected: SqlTextRange[] = [];
+  const seen = new Set<string>();
+  for (const statement of statements) {
+    if (isOraclePlSqlStatement(statement.sql, databaseType)) continue;
+    if (!visibleRanges.some((visibleRange) => rangesIntersect(statement, visibleRange))) continue;
+    const key = `${statement.from}:${statement.to}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    selected.push({ from: statement.from, to: statement.to, sql: sql.slice(statement.from, statement.to) });
+  }
+  return selected;
+}
+
+export function buildSqlSemanticDiagnostics(analysis: SqlReferenceAnalysis, schema: SqlSemanticDiagnosticSchema): SqlSemanticDiagnostic[] {
+  const diagnostics: SqlSemanticDiagnostic[] = [];
+  const tables = analysis.tables.filter((table) => table.name.trim());
+  const knownTables = new Map<string, SqlTableReference>();
+  const scopesById = scopesByIdMap(analysis.scopes);
+
+  for (const table of tables) {
+    knownTables.set(normalizeName(table.name), table);
+    if (table.alias) knownTables.set(normalizeName(table.alias), table);
+    if (table.schema) knownTables.set(normalizeName(`${table.schema}.${table.name}`), table);
+  }
+
+  for (const table of tables) {
+    if (!schema.missingTables?.has(tableReferenceKey(table))) continue;
+    diagnostics.push({
+      span: trimSqlTextSpanWhitespace(schema.sql, table.span),
+      message: `Unknown table ${displayTableName(table)}`,
+      severity: "error",
+    });
+  }
+
+  for (const column of analysis.columns) {
+    const table = resolveColumnTable(column, tables, knownTables, schema.sql, scopesById);
+    if (!table) continue;
+    if (schema.missingTables?.has(tableReferenceKey(table))) continue;
+
+    const columns = columnsForTable(table, schema.columnsByTable, schema.loadedColumnTables);
+    if (!columns) continue;
+
+    const columnNames = new Set(columns.map((item) => normalizeName(item.name)));
+    if (columnNames.has(normalizeName(column.name))) continue;
+
+    const displayName = column.qualifier ? `${column.qualifier}.${column.name}` : column.name;
+    diagnostics.push({
+      span: trimSqlTextSpanWhitespace(schema.sql, column.span),
+      message: `Unknown column ${displayName}`,
+      severity: "error",
+    });
+  }
+
+  return diagnostics;
+}
+
+function trimSqlTextSpanWhitespace(sql: string | undefined, span: SqlTextSpan): SqlTextSpan {
+  if (!sql) return span;
+  const range = sqlTextSpanToOffsetRange(sql, span);
+  if (!range) return span;
+
+  let from = range.from;
+  let to = range.to;
+  while (from < to && /\s/.test(sql[from] ?? "")) from += 1;
+  while (to > from && /\s/.test(sql[to - 1] ?? "")) to -= 1;
+  if (from === range.from && to === range.to) return span;
+
+  const start = offsetToSqlTextStartPosition(sql, from);
+  const end = offsetToSqlTextEndPosition(sql, to);
+  if (!start || !end) return span;
+  return {
+    start_line: start.line,
+    start_column: start.column,
+    end_line: end.line,
+    end_column: Math.max(end.column, start.column),
+  };
+}
+
+function sqlTextSpanToOffsetRange(sql: string, span: SqlTextSpan): { from: number; to: number } | null {
+  if (!span.start_line || !span.start_column) return null;
+  const from = sqlTextPositionToOffset(sql, span.start_line, span.start_column - 1);
+  const to = sqlTextPositionToOffset(sql, Math.max(span.end_line, span.start_line), Math.max(span.end_column, span.start_column));
+  if (from == null || to == null || to <= from) return null;
+  return { from, to };
+}
+
+function sqlTextPositionToOffset(sql: string, line: number, column: number): number | null {
+  const lines = sql.split(/\r?\n/);
+  if (line < 1 || line > lines.length) return null;
+  let offset = 0;
+  for (let index = 0; index < line - 1; index += 1) {
+    offset += lines[index].length + 1;
+  }
+  return Math.min(offset + Math.max(column, 0), offset + lines[line - 1].length);
+}
+
+function offsetToSqlTextStartPosition(sql: string, offset: number): { line: number; column: number } | null {
+  const position = offsetToLineColumn(sql, offset);
+  return position ? { line: position.line, column: position.column + 1 } : null;
+}
+
+function offsetToSqlTextEndPosition(sql: string, offset: number): { line: number; column: number } | null {
+  return offsetToLineColumn(sql, offset);
+}
+
+function offsetToLineColumn(sql: string, offset: number): { line: number; column: number } | null {
+  if (offset < 0 || offset > sql.length) return null;
+  const lines = sql.split(/\r?\n/);
+  let remaining = offset;
+  for (let index = 0; index < lines.length; index += 1) {
+    const lineLength = lines[index].length;
+    if (remaining <= lineLength) {
+      return { line: index + 1, column: remaining };
+    }
+    remaining -= lineLength + 1;
+  }
+  const lastLine = lines[lines.length - 1] ?? "";
+  return { line: lines.length, column: lastLine.length };
+}
+
+export function buildSqlParserErrorDiagnostic(error: unknown, sql: string): SqlSemanticDiagnostic | null {
+  const message = errorMessage(error);
+  const location = /\bat Line:\s*(\d+),\s*Column:\s*(\d+)\b/i.exec(message);
+  if (!location) return null;
+
+  const startLine = Number.parseInt(location[1], 10);
+  const startColumn = Number.parseInt(location[2], 10);
+  if (!Number.isFinite(startLine) || !Number.isFinite(startColumn) || startLine < 1 || startColumn < 1) return null;
+
+  const lineText = sql.split(/\r?\n/)[startLine - 1] ?? "";
+  const startIndex = Math.max(startColumn - 1, 0);
+  const token = /^[\w$]+/.exec(lineText.slice(startIndex))?.[0];
+  const tokenLength = Math.max(token?.length ?? 1, 1);
+
+  return {
+    span: {
+      start_line: startLine,
+      start_column: startColumn,
+      end_line: startLine,
+      end_column: startColumn + tokenLength - 1,
+    },
+    message,
+    severity: "error",
+  };
+}
+
+export function areSqlSemanticDiagnosticsEqual(left: readonly SqlSemanticDiagnostic[], right: readonly SqlSemanticDiagnostic[]): boolean {
+  if (left.length !== right.length) return false;
+  return left.every((item, index) => {
+    const other = right[index];
+    return !!other && item.message === other.message && item.severity === other.severity && item.span.start_line === other.span.start_line && item.span.start_column === other.span.start_column && item.span.end_line === other.span.end_line && item.span.end_column === other.span.end_column;
+  });
+}
+
+export function shouldRunSqlSemanticDiagnostics(sql: string, cursor: number, options: { databaseType?: DatabaseType } = {}): boolean {
+  if (options.databaseType === "mongodb" || options.databaseType === "elasticsearch" || options.databaseType === "qdrant" || options.databaseType === "milvus" || options.databaseType === "weaviate" || options.databaseType === "chromadb" || options.databaseType === "redis") return false;
+  const context = getSqlCompletionContext(sql, cursor);
+  if (context.exclusiveColumnSuggestions) return false;
+  if (context.qualifier) return false;
+  if ((context.suggestTables || context.exclusiveTableSuggestions) && isCursorAfterTableTrigger(sql, cursor)) return false;
+  return true;
+}
+
+export function isSqlSemanticDiagnosticInputContext(sql: string, cursor: number, options: { databaseType?: DatabaseType } = {}): boolean {
+  if (options.databaseType === "mongodb" || options.databaseType === "elasticsearch" || options.databaseType === "qdrant" || options.databaseType === "milvus" || options.databaseType === "weaviate" || options.databaseType === "chromadb" || options.databaseType === "redis") return false;
+  const context = getSqlCompletionContext(sql, cursor);
+  return context.exclusiveColumnSuggestions || !!context.qualifier || ((context.suggestTables || context.exclusiveTableSuggestions) && isCursorAfterTableTrigger(sql, cursor));
+}
+
+function resolveColumnTable(column: SqlColumnReference, tables: SqlTableReference[], knownTables: Map<string, SqlTableReference>, sql?: string, scopesById?: Map<number, SqlReferenceScope>): SqlTableReference | null {
+  const candidateTables = candidateTablesForColumn(tables, column, sql, scopesById);
+  if (column.qualifier) {
+    return tableLookupFor(candidateTables).get(normalizeName(column.qualifier)) ?? (sql ? null : (knownTables.get(normalizeName(column.qualifier)) ?? null));
+  }
+  if (candidateTables.length !== 1) return null;
+  return candidateTables[0];
+}
+
+function candidateTablesForColumn(tables: SqlTableReference[], column: SqlColumnReference, sql?: string, scopesById?: Map<number, SqlReferenceScope>): SqlTableReference[] {
+  const scoped = tablesInVisibleScopes(tables, column, scopesById);
+  if (scoped) return scoped;
+  return sql ? tablesInSameStatement(tables, column, sql) : tables;
+}
+
+function tablesInVisibleScopes(tables: SqlTableReference[], column: SqlColumnReference, scopesById?: Map<number, SqlReferenceScope>): SqlTableReference[] | null {
+  if (column.scope_id == null || !scopesById || scopesById.size === 0) return null;
+  if (!column.qualifier) {
+    const currentScopeTables = tables.filter((table) => table.scope_id === column.scope_id);
+    if (currentScopeTables.length > 0) return currentScopeTables;
+  }
+  const visibleScopeIds = scopeAndParents(column.scope_id, scopesById);
+  if (visibleScopeIds.size === 0) return null;
+  return tables.filter((table) => table.scope_id != null && visibleScopeIds.has(table.scope_id));
+}
+
+function scopeAndParents(scopeId: number, scopesById: Map<number, SqlReferenceScope>): Set<number> {
+  const ids = new Set<number>();
+  let current: number | undefined = scopeId;
+  while (current != null && !ids.has(current)) {
+    ids.add(current);
+    const scope = scopesById.get(current);
+    current = scope?.parent_id ?? undefined;
+  }
+  return ids;
+}
+
+function tableLookupFor(tables: SqlTableReference[]): Map<string, SqlTableReference> {
+  const lookup = new Map<string, SqlTableReference>();
+  for (const table of tables) {
+    lookup.set(normalizeName(table.name), table);
+    if (table.alias) lookup.set(normalizeName(table.alias), table);
+    if (table.schema) lookup.set(normalizeName(`${table.schema}.${table.name}`), table);
+  }
+  return lookup;
+}
+
+function tablesInSameStatement(tables: SqlTableReference[], column: SqlColumnReference, sql: string): SqlTableReference[] {
+  const columnOffset = spanStartOffset(sql, column.span);
+  if (columnOffset == null) return tables;
+  return tables.filter((table) => {
+    const tableOffset = spanStartOffset(sql, table.span);
+    return tableOffset != null && statementIndexAt(sql, tableOffset) === statementIndexAt(sql, columnOffset);
+  });
+}
+
+function scopesByIdMap(scopes: readonly SqlReferenceScope[] | undefined): Map<number, SqlReferenceScope> {
+  const map = new Map<number, SqlReferenceScope>();
+  for (const scope of scopes ?? []) map.set(scope.id, scope);
+  return map;
+}
+
+function spanStartOffset(sql: string, span: SqlTextSpan): number | null {
+  if (!span.start_line || !span.start_column) return null;
+  const lines = sql.split(/\r?\n/);
+  const lineIndex = span.start_line - 1;
+  if (lineIndex < 0 || lineIndex >= lines.length) return null;
+  let offset = 0;
+  for (let index = 0; index < lineIndex; index++) offset += lines[index].length + 1;
+  return Math.min(offset + span.start_column - 1, offset + lines[lineIndex].length);
+}
+
+function statementIndexAt(sql: string, offset: number): number {
+  let statementIndex = 0;
+  for (let index = 0; index < Math.min(offset, sql.length); index++) {
+    if (sql[index] === ";") statementIndex++;
+  }
+  return statementIndex;
+}
+
+function columnsForTable(table: SqlTableReference, columnsByTable: Map<string, SqlCompletionColumn[]>, loadedColumnTables?: Set<string>): SqlCompletionColumn[] | null {
+  const inlineColumns = (table as SqlTableReference & { columns?: string[] }).columns;
+  if (inlineColumns && inlineColumns.length > 0) {
+    return inlineColumns.map((name) => ({
+      name,
+      table: table.name,
+      schema: table.schema ?? undefined,
+    }));
+  }
+  const keys = table.schema ? [`${table.schema}.${table.name}`, table.name] : [table.name, ...keysWithTableName(columnsByTable, table.name)];
+  for (const key of keys) {
+    const normalizedKey = normalizeName(key);
+    const columns = columnsByTable.get(key) ?? columnsByTable.get(normalizedKey);
+    if (!columns) continue;
+    if (columns.length > 0 || loadedColumnTables?.has(normalizedKey)) return columns;
+  }
+  if (loadedColumnTables?.has(tableReferenceKey(table))) return [];
+  return null;
+}
+
+function keysWithTableName(columnsByTable: Map<string, SqlCompletionColumn[]>, tableName: string): string[] {
+  const suffix = `.${normalizeName(tableName)}`;
+  return [...columnsByTable.keys()].filter((key) => normalizeName(key).endsWith(suffix));
+}
+
+function rangesIntersect(left: SqlSemanticDiagnosticVisibleRange, right: SqlSemanticDiagnosticVisibleRange): boolean {
+  return left.from < right.to && right.from < left.to;
+}
+
+export function tableReferenceKey(table: Pick<SqlTableReference, "name" | "schema">): string {
+  return normalizeName(table.schema ? `${table.schema}.${table.name}` : table.name);
+}
+
+function displayTableName(table: SqlTableReference): string {
+  return table.schema ? `${table.schema}.${table.name}` : table.name;
+}
+
+function isCursorAfterTableTrigger(sql: string, cursor: number): boolean {
+  const beforeCursor = sql.slice(0, cursor).trimEnd();
+  return /\b(from|join|update|into|table)(?:\s+[\w$`"'[\].]*)?$/i.test(beforeCursor);
+}
+
+function normalizeName(value: string): string {
+  let normalized = value;
+  while (normalized && `"'\`[]`.includes(normalized[0])) normalized = normalized.slice(1);
+  while (normalized && `"'\`[]`.includes(normalized[normalized.length - 1])) normalized = normalized.slice(0, -1);
+  return normalized.toLowerCase();
+}
+
+function errorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
diff --git a/apps/desktop/src/lib/sql/semantic/dialect.ts b/apps/desktop/src/lib/sql/semantic/dialect.ts
new file mode 100644
index 0000000..5419967
--- /dev/null
+++ b/apps/desktop/src/lib/sql/semantic/dialect.ts
@@ -0,0 +1,173 @@
+import type { DatabaseType } from "@/types/database";
+
+export interface SqlSemanticProjectionAliasVisibility {
+  where: boolean;
+  groupBy: boolean;
+  having: boolean;
+  orderBy: boolean;
+}
+
+export interface SqlSemanticDialectAdapter {
+  id: string;
+  identifierQuotes: Array<{ open: string; close: string }>;
+  supportsAsForTableAlias: boolean;
+  projectionAliasVisibility: SqlSemanticProjectionAliasVisibility;
+  normalizeIdentifier(identifier: string, quoted?: boolean): string;
+  quoteIdentifier(identifier: string): string;
+  qualifierRole(parts: string[], context: "table" | "column" | "routine"): "catalog" | "schema" | "table" | "package" | "unknown";
+}
+
+function quoteWith(identifier: string, quote: string): string {
+  return `${quote}${identifier.replaceAll(quote, quote + quote)}${quote}`;
+}
+
+function defaultNormalize(identifier: string): string {
+  return identifier;
+}
+
+function lowerUnquoted(identifier: string, quoted?: boolean): string {
+  return quoted ? identifier : identifier.toLowerCase();
+}
+
+function upperUnquoted(identifier: string, quoted?: boolean): string {
+  return quoted ? identifier : identifier.toUpperCase();
+}
+
+const defaultProjectionAliasVisibility: SqlSemanticProjectionAliasVisibility = {
+  where: false,
+  groupBy: false,
+  having: false,
+  orderBy: true,
+};
+
+function roleForGenericQualifier(parts: string[], context: "table" | "column" | "routine"): "catalog" | "schema" | "table" | "package" | "unknown" {
+  if (parts.length <= 0) return "unknown";
+  if (context === "column") return parts.length >= 2 ? "table" : "table";
+  if (context === "routine") return parts.length >= 2 ? "package" : "schema";
+  if (parts.length >= 2) return "schema";
+  return "schema";
+}
+
+export const SQL_SEMANTIC_DIALECTS: Record<string, SqlSemanticDialectAdapter> = {
+  generic: {
+    id: "generic",
+    identifierQuotes: [{ open: '"', close: '"' }],
+    supportsAsForTableAlias: true,
+    projectionAliasVisibility: defaultProjectionAliasVisibility,
+    normalizeIdentifier: defaultNormalize,
+    quoteIdentifier: (identifier) => quoteWith(identifier, '"'),
+    qualifierRole: roleForGenericQualifier,
+  },
+  postgres: {
+    id: "postgres",
+    identifierQuotes: [{ open: '"', close: '"' }],
+    supportsAsForTableAlias: true,
+    projectionAliasVisibility: defaultProjectionAliasVisibility,
+    normalizeIdentifier: lowerUnquoted,
+    quoteIdentifier: (identifier) => quoteWith(identifier, '"'),
+    qualifierRole: roleForGenericQualifier,
+  },
+  mysql: {
+    id: "mysql",
+    identifierQuotes: [
+      { open: "`", close: "`" },
+      { open: '"', close: '"' },
+    ],
+    supportsAsForTableAlias: true,
+    projectionAliasVisibility: { where: false, groupBy: true, having: true, orderBy: true },
+    normalizeIdentifier: defaultNormalize,
+    quoteIdentifier: (identifier) => quoteWith(identifier, "`"),
+    qualifierRole(parts, context) {
+      if (context === "column") return parts.length >= 2 ? "table" : "table";
+      if (context === "routine") return parts.length >= 2 ? "package" : "schema";
+      return parts.length >= 1 ? "schema" : "unknown";
+    },
+  },
+  sqlserver: {
+    id: "sqlserver",
+    identifierQuotes: [
+      { open: "[", close: "]" },
+      { open: '"', close: '"' },
+    ],
+    supportsAsForTableAlias: true,
+    projectionAliasVisibility: defaultProjectionAliasVisibility,
+    normalizeIdentifier: defaultNormalize,
+    quoteIdentifier: (identifier) => `[${identifier.replaceAll("]", "]]")}]`,
+    qualifierRole(parts, context) {
+      if (context === "column") return parts.length >= 2 ? "table" : "table";
+      if (context === "routine") return parts.length >= 2 ? "package" : "schema";
+      if (parts.length >= 2) return "schema";
+      return "schema";
+    },
+  },
+  sqlite: {
+    id: "sqlite",
+    identifierQuotes: [
+      { open: '"', close: '"' },
+      { open: "`", close: "`" },
+      { open: "[", close: "]" },
+    ],
+    supportsAsForTableAlias: true,
+    projectionAliasVisibility: { where: false, groupBy: true, having: true, orderBy: true },
+    normalizeIdentifier: defaultNormalize,
+    quoteIdentifier: (identifier) => quoteWith(identifier, '"'),
+    qualifierRole: roleForGenericQualifier,
+  },
+  duckdb: {
+    id: "duckdb",
+    identifierQuotes: [{ open: '"', close: '"' }],
+    supportsAsForTableAlias: true,
+    projectionAliasVisibility: defaultProjectionAliasVisibility,
+    normalizeIdentifier: defaultNormalize,
+    quoteIdentifier: (identifier) => quoteWith(identifier, '"'),
+    qualifierRole: roleForGenericQualifier,
+  },
+  oracle: {
+    id: "oracle",
+    identifierQuotes: [{ open: '"', close: '"' }],
+    supportsAsForTableAlias: false,
+    projectionAliasVisibility: defaultProjectionAliasVisibility,
+    normalizeIdentifier: upperUnquoted,
+    quoteIdentifier: (identifier) => quoteWith(identifier, '"'),
+    qualifierRole(parts, context) {
+      if (context === "column") return parts.length >= 2 ? "table" : "table";
+      if (context === "routine") return parts.length >= 2 ? "package" : "schema";
+      return parts.length >= 1 ? "schema" : "unknown";
+    },
+  },
+};
+
+export function sqlSemanticDialectFor(options: { databaseType?: DatabaseType; dialect?: "mysql" | "postgres" | "sqlserver" }): SqlSemanticDialectAdapter {
+  if (options.dialect && SQL_SEMANTIC_DIALECTS[options.dialect]) return SQL_SEMANTIC_DIALECTS[options.dialect];
+  switch (options.databaseType) {
+    case "postgres":
+    case "redshift":
+    case "opengauss":
+    case "gaussdb":
+    case "highgo":
+      return SQL_SEMANTIC_DIALECTS.postgres;
+    case "mysql":
+    case "doris":
+    case "starrocks":
+      return SQL_SEMANTIC_DIALECTS.mysql;
+    case "sqlserver":
+      return SQL_SEMANTIC_DIALECTS.sqlserver;
+    case "sqlite":
+    case "rqlite":
+    case "turso":
+    case "cloudflare-d1":
+      return SQL_SEMANTIC_DIALECTS.sqlite;
+    case "duckdb":
+      return SQL_SEMANTIC_DIALECTS.duckdb;
+    case "oracle":
+    case "oceanbase-oracle":
+    case "dameng":
+    case "kingbase":
+    case "vastbase":
+    case "goldendb":
+    case "yashandb":
+      return SQL_SEMANTIC_DIALECTS.oracle;
+    default:
+      return SQL_SEMANTIC_DIALECTS.generic;
+  }
+}
diff --git a/apps/desktop/src/lib/sql/semantic/fixtures.ts b/apps/desktop/src/lib/sql/semantic/fixtures.ts
new file mode 100644
index 0000000..dd14575
--- /dev/null
+++ b/apps/desktop/src/lib/sql/semantic/fixtures.ts
@@ -0,0 +1,168 @@
+import type { SqlSemanticCompletionScopeKind } from "@/lib/sql/semantic/completion";
+import type { SqlSemanticConfidence, SqlSemanticCursorKind, SqlSemanticStatementKind } from "@/lib/sql/semantic/types";
+
+export interface SqlSemanticFixture {
+  name: string;
+  sql: string;
+  databaseType?: "postgres" | "mysql" | "sqlserver" | "sqlite" | "duckdb" | "oracle";
+  expected: {
+    statementKind: SqlSemanticStatementKind;
+    cursorKind: SqlSemanticCursorKind;
+    completionScope: SqlSemanticCompletionScopeKind;
+    prefix: string;
+    qualifierParts?: string[];
+    confidence: SqlSemanticConfidence;
+    rowSources?: Array<{ name: string; alias?: string; kind?: string; columns?: string[] }>;
+    completionLabels?: string[];
+  };
+}
+
+export function sqlFixtureCursor(input: string): { sql: string; cursor: number } {
+  const cursor = input.indexOf("|");
+  if (cursor < 0) {
+    throw new Error("SQL semantic fixture is missing a | cursor marker");
+  }
+  return {
+    sql: input.slice(0, cursor) + input.slice(cursor + 1),
+    cursor,
+  };
+}
+
+export const SQL_SEMANTIC_BASELINE_FIXTURES: SqlSemanticFixture[] = [
+  {
+    name: "select alias column",
+    sql: "SELECT * FROM users u JOIN orders o ON o.user_id = u.id WHERE u.|",
+    expected: {
+      statementKind: "select",
+      cursorKind: "alias_column",
+      completionScope: "columns",
+      prefix: "",
+      qualifierParts: ["u"],
+      confidence: "high",
+      rowSources: [
+        { name: "users", alias: "u", kind: "table" },
+        { name: "orders", alias: "o", kind: "table" },
+      ],
+    },
+  },
+  {
+    name: "with cte table source",
+    sql: "WITH recent_orders(id, total) AS (SELECT id, total FROM orders) SELECT * FROM recent_orders ro WHERE ro.|",
+    expected: {
+      statementKind: "select",
+      cursorKind: "alias_column",
+      completionScope: "columns",
+      prefix: "",
+      qualifierParts: ["ro"],
+      confidence: "high",
+      rowSources: [{ name: "recent_orders", alias: "ro", kind: "cte", columns: ["id", "total"] }],
+      completionLabels: ["id", "total"],
+    },
+  },
+  {
+    name: "subquery projection columns",
+    sql: "SELECT * FROM (SELECT id, name AS user_name FROM users) sq WHERE sq.|",
+    expected: {
+      statementKind: "select",
+      cursorKind: "alias_column",
+      completionScope: "columns",
+      prefix: "",
+      qualifierParts: ["sq"],
+      confidence: "high",
+      rowSources: [{ name: "sq", alias: "sq", kind: "subquery", columns: ["id", "user_name"] }],
+      completionLabels: ["id", "user_name"],
+    },
+  },
+  {
+    name: "insert target columns",
+    sql: "INSERT INTO dbo.Users (|",
+    databaseType: "sqlserver",
+    expected: {
+      statementKind: "insert",
+      cursorKind: "insert_column",
+      completionScope: "columns",
+      prefix: "",
+      qualifierParts: [],
+      confidence: "medium",
+      rowSources: [{ name: "Users", kind: "mutation_target" }],
+    },
+  },
+  {
+    name: "update set columns",
+    sql: "UPDATE dbo.Users SET |",
+    databaseType: "sqlserver",
+    expected: {
+      statementKind: "update",
+      cursorKind: "update_column",
+      completionScope: "columns",
+      prefix: "",
+      qualifierParts: [],
+      confidence: "medium",
+      rowSources: [{ name: "Users", kind: "mutation_target" }],
+    },
+  },
+  {
+    name: "call routine",
+    sql: "CALL app.refresh_|",
+    databaseType: "postgres",
+    expected: {
+      statementKind: "call",
+      cursorKind: "routine",
+      completionScope: "routine",
+      prefix: "refresh_",
+      qualifierParts: ["app"],
+      confidence: "high",
+    },
+  },
+  {
+    name: "delete target",
+    sql: "DELETE FROM audit_events ae WHERE ae.|",
+    expected: {
+      statementKind: "delete",
+      cursorKind: "alias_column",
+      completionScope: "columns",
+      prefix: "",
+      qualifierParts: ["ae"],
+      confidence: "high",
+      rowSources: [{ name: "audit_events", alias: "ae", kind: "mutation_target" }],
+    },
+  },
+  {
+    name: "table function alias",
+    sql: "SELECT * FROM JSON_TABLE(payload, '$' COLUMNS(id INT PATH '$.id')) jt WHERE jt.|",
+    databaseType: "oracle",
+    expected: {
+      statementKind: "select",
+      cursorKind: "alias_column",
+      completionScope: "columns",
+      prefix: "",
+      qualifierParts: ["JT"],
+      confidence: "high",
+      rowSources: [{ name: "JT", alias: "JT", kind: "table_function" }],
+    },
+  },
+  {
+    name: "schema qualified table",
+    sql: "SELECT * FROM reporting.|",
+    databaseType: "postgres",
+    expected: {
+      statementKind: "select",
+      cursorKind: "table",
+      completionScope: "table",
+      prefix: "",
+      qualifierParts: ["reporting"],
+      confidence: "medium",
+    },
+  },
+  {
+    name: "comment suppressed",
+    sql: "SELECT * FROM users -- u.|",
+    expected: {
+      statementKind: "select",
+      cursorKind: "suppressed",
+      completionScope: "local",
+      prefix: "",
+      confidence: "high",
+    },
+  },
+];
diff --git a/apps/desktop/src/lib/sql/semantic/model.ts b/apps/desktop/src/lib/sql/semantic/model.ts
new file mode 100644
index 0000000..7b1e13d
--- /dev/null
+++ b/apps/desktop/src/lib/sql/semantic/model.ts
@@ -0,0 +1,587 @@
+import { sqlSemanticDialectFor, type SqlSemanticDialectAdapter } from "@/lib/sql/semantic/dialect";
+import { findActiveSqlStatementSpan, isSuppressedSqlSemanticContext, tokenIsIdentifier, tokenizeSqlSemantic, unquoteSqlSemanticIdentifier } from "@/lib/sql/semantic/tokens";
+import type {
+  SqlSemanticBuildOptions,
+  SqlSemanticClauseSpans,
+  SqlSemanticCursorIntent,
+  SqlSemanticIdentifierPart,
+  SqlSemanticModel,
+  SqlSemanticProjection,
+  SqlSemanticQualifiedName,
+  SqlSemanticRowSource,
+  SqlSemanticScope,
+  SqlSemanticSpan,
+  SqlSemanticStatement,
+  SqlSemanticStatementKind,
+  SqlSemanticToken,
+} from "@/lib/sql/semantic/types";
+
+const TABLE_INTRODUCERS = new Set(["from", "join", "straight_join", "update", "into", "using", "apply"]);
+const JOIN_MODIFIERS = new Set(["left", "right", "inner", "outer", "cross", "full", "natural"]);
+const CLAUSE_BOUNDARIES = new Set(["where", "group", "having", "order", "limit", "offset", "union", "intersect", "except", "on", "set", "values", "returning"]);
+const ALIAS_BLACKLIST = new Set([...CLAUSE_BOUNDARIES, "join", "straight_join", "left", "right", "inner", "outer", "cross", "full", "natural", "as", "select", "from"]);
+
+interface ParseState {
+  dialect: SqlSemanticDialectAdapter;
+  tokens: SqlSemanticToken[];
+  statement: SqlSemanticStatement;
+  cteSources: SqlSemanticRowSource[];
+}
+
+interface TrailingIdentifier {
+  prefix: string;
+  replacementRange: SqlSemanticSpan;
+  qualifierParts: string[];
+}
+
+function significantTokens(tokens: readonly SqlSemanticToken[]): SqlSemanticToken[] {
+  return tokens.filter((item) => item.kind !== "comment");
+}
+
+function tokenTextAt(sql: string, span: SqlSemanticSpan): string {
+  return sql.slice(span.start, span.end);
+}
+
+function firstWord(tokens: readonly SqlSemanticToken[]): string {
+  return tokens.find((item) => item.kind === "word")?.normalized ?? "";
+}
+
+function statementKind(tokens: readonly SqlSemanticToken[]): SqlSemanticStatementKind {
+  const word = firstWord(tokens);
+  if (word === "with" || word === "select") return "select";
+  if (word === "insert") return "insert";
+  if (word === "update") return "update";
+  if (word === "delete") return "delete";
+  if (word === "call" || word === "exec" || word === "execute") return "call";
+  return "unknown";
+}
+
+function identifierPart(tokenValue: SqlSemanticToken, dialect: SqlSemanticDialectAdapter): SqlSemanticIdentifierPart {
+  const quoted = tokenValue.kind === "quoted_identifier";
+  const raw = unquoteSqlSemanticIdentifier(tokenValue);
+  return {
+    raw: tokenValue.text,
+    name: dialect.normalizeIdentifier(raw, quoted),
+    span: tokenValue.span,
+    quote: tokenValue.quote,
+  };
+}
+
+function readQualifiedName(tokens: readonly SqlSemanticToken[], startIndex: number, dialect: SqlSemanticDialectAdapter): { name: SqlSemanticQualifiedName; nextIndex: number } | null {
+  const parts: SqlSemanticIdentifierPart[] = [];
+  let index = startIndex;
+  while (index < tokens.length) {
+    const current = tokens[index];
+    if (!tokenIsIdentifier(current)) break;
+    parts.push(identifierPart(current, dialect));
+    if (tokens[index + 1]?.text !== ".") {
+      index += 1;
+      break;
+    }
+    index += 2;
+  }
+  if (parts.length === 0) return null;
+  return {
+    name: {
+      parts,
+      span: { start: parts[0]?.span.start ?? tokens[startIndex]?.span.start ?? 0, end: parts[parts.length - 1]?.span.end ?? tokens[startIndex]?.span.end ?? 0 },
+    },
+    nextIndex: index,
+  };
+}
+
+function sourceNameFromQualifiedName(name: SqlSemanticQualifiedName): { name: string; qualifierParts: string[] } {
+  const parts = name.parts.map((part) => part.name);
+  return {
+    name: parts[parts.length - 1] ?? "",
+    qualifierParts: parts.slice(0, -1),
+  };
+}
+
+function findMatchingParenToken(tokens: readonly SqlSemanticToken[], openIndex: number): number {
+  if (tokens[openIndex]?.text !== "(") return -1;
+  const startDepth = tokens[openIndex]?.depth ?? 0;
+  for (let index = openIndex + 1; index < tokens.length; index += 1) {
+    const item = tokens[index];
+    if (item?.text === ")" && item.depth === startDepth) return index;
+  }
+  return -1;
+}
+
+function splitTopLevelByComma(tokens: readonly SqlSemanticToken[]): SqlSemanticToken[][] {
+  const groups: SqlSemanticToken[][] = [];
+  let current: SqlSemanticToken[] = [];
+  const baseDepth = tokens.reduce((min, item) => Math.min(min, item.depth), Number.POSITIVE_INFINITY);
+  for (const item of tokens) {
+    if (item.text === "," && item.depth === baseDepth) {
+      groups.push(current);
+      current = [];
+    } else {
+      current.push(item);
+    }
+  }
+  if (current.length > 0) groups.push(current);
+  return groups;
+}
+
+function projectionNameFromTokens(tokens: readonly SqlSemanticToken[], dialect: SqlSemanticDialectAdapter): SqlSemanticProjection | null {
+  const useful = tokens.filter((item) => item.kind !== "comment");
+  if (useful.length === 0) return null;
+  let asIndex = -1;
+  for (let index = useful.length - 1; index >= 0; index -= 1) {
+    if (useful[index]?.kind === "word" && useful[index]?.normalized === "as") {
+      asIndex = index;
+      break;
+    }
+  }
+  const aliasToken = asIndex >= 0 ? useful[asIndex + 1] : undefined;
+  if (tokenIsIdentifier(aliasToken)) {
+    const name = identifierPart(aliasToken, dialect).name;
+    return {
+      name,
+      alias: name,
+      aliasSpan: aliasToken.span,
+      sourceExpression: useful.map((item) => item.text).join(" "),
+      span: { start: useful[0]?.span.start ?? 0, end: useful[useful.length - 1]?.span.end ?? 0 },
+    };
+  }
+  const lastIdentifier = [...useful].reverse().find(tokenIsIdentifier);
+  if (!lastIdentifier) return null;
+  const name = identifierPart(lastIdentifier, dialect).name;
+  return {
+    name,
+    sourceExpression: useful.map((item) => item.text).join(" "),
+    span: { start: useful[0]?.span.start ?? 0, end: useful[useful.length - 1]?.span.end ?? 0 },
+  };
+}
+
+function parseSelectProjections(tokens: readonly SqlSemanticToken[], dialect: SqlSemanticDialectAdapter): SqlSemanticProjection[] {
+  const baseDepth = tokens.reduce((min, item) => Math.min(min, item.depth), Number.POSITIVE_INFINITY);
+  const selectDepth = Number.isFinite(baseDepth) ? baseDepth : 0;
+  const selectIndex = tokens.findIndex((item) => item.depth === selectDepth && item.kind === "word" && item.normalized === "select");
+  if (selectIndex < 0) return [];
+  let fromIndex = tokens.findIndex((item, index) => index > selectIndex && item.depth === selectDepth && item.kind === "word" && item.normalized === "from");
+  if (fromIndex < 0) fromIndex = tokens.length;
+  const projectionTokens = tokens.slice(selectIndex + 1, fromIndex);
+  return splitTopLevelByComma(projectionTokens)
+    .map((group) => projectionNameFromTokens(group, dialect))
+    .filter((projection): projection is SqlSemanticProjection => projection != null && projection.name !== "*");
+}
+
+function parseCteSources(state: ParseState): SqlSemanticRowSource[] {
+  const tokens = state.tokens;
+  const first = tokens.findIndex((item) => item.kind === "word" && item.normalized === "with");
+  if (first < 0) return [];
+  const sources: SqlSemanticRowSource[] = [];
+  let index = first + 1;
+  if (tokens[index]?.normalized === "recursive") index += 1;
+
+  while (index < tokens.length) {
+    while (tokens[index]?.text === ",") index += 1;
+    const nameToken = tokens[index];
+    if (!tokenIsIdentifier(nameToken)) break;
+    const namePart = identifierPart(nameToken, state.dialect);
+    index += 1;
+
+    const explicitColumns: string[] = [];
+    if (tokens[index]?.text === "(") {
+      const close = findMatchingParenToken(tokens, index);
+      if (close > index) {
+        for (const part of splitTopLevelByComma(tokens.slice(index + 1, close))) {
+          const identifier = part.find(tokenIsIdentifier);
+          if (identifier) explicitColumns.push(identifierPart(identifier, state.dialect).name);
+        }
+        index = close + 1;
+      }
+    }
+
+    if (tokens[index]?.normalized === "as") index += 1;
+    if (tokens[index]?.text !== "(") break;
+    const bodyOpen = index;
+    const bodyClose = findMatchingParenToken(tokens, bodyOpen);
+    const safeBodyClose = bodyClose < 0 ? tokens.length - 1 : bodyClose;
+    const bodyTokens = tokens.slice(bodyOpen + 1, safeBodyClose);
+    const bodyColumns = explicitColumns.length > 0 ? explicitColumns : parseSelectProjections(bodyTokens, state.dialect).map((projection) => projection.name);
+    sources.push({
+      id: `cte:${namePart.name}:${sources.length}`,
+      kind: "cte",
+      name: namePart.name,
+      qualifierParts: [],
+      sourceSpan: { start: nameToken.span.start, end: tokens[safeBodyClose]?.span.end ?? nameToken.span.end },
+      columns: bodyColumns,
+    });
+    index = safeBodyClose + 1;
+
+    if (tokens[index]?.text !== ",") break;
+    index += 1;
+  }
+  return sources;
+}
+
+function aliasAfter(tokens: readonly SqlSemanticToken[], index: number, dialect: SqlSemanticDialectAdapter): { alias?: string; aliasSpan?: SqlSemanticSpan; nextIndex: number } {
+  let cursor = index;
+  if (tokens[cursor]?.kind === "word" && tokens[cursor]?.normalized === "as") cursor += 1;
+  const aliasToken = tokens[cursor];
+  if (tokenIsIdentifier(aliasToken)) {
+    const alias = identifierPart(aliasToken, dialect).name;
+    if (!ALIAS_BLACKLIST.has(alias.toLowerCase())) {
+      return { alias, aliasSpan: aliasToken.span, nextIndex: cursor + 1 };
+    }
+  }
+  return { nextIndex: index };
+}
+
+function parseSubquerySource(state: ParseState, openIndex: number, introducer: string, sourceIndex: number): { source: SqlSemanticRowSource; nextIndex: number } | null {
+  const close = findMatchingParenToken(state.tokens, openIndex);
+  if (close < 0) return null;
+  const alias = aliasAfter(state.tokens, close + 1, state.dialect);
+  if (!alias.alias) return null;
+  const bodyTokens = state.tokens.slice(openIndex + 1, close);
+  const columns = parseSelectProjections(bodyTokens, state.dialect).map((projection) => projection.name);
+  return {
+    source: {
+      id: `${introducer}:subquery:${sourceIndex}`,
+      kind: "subquery",
+      name: alias.alias,
+      qualifierParts: [],
+      alias: alias.alias,
+      aliasSpan: alias.aliasSpan,
+      sourceSpan: { start: state.tokens[openIndex]?.span.start ?? 0, end: alias.aliasSpan?.end ?? state.tokens[close]?.span.end ?? 0 },
+      columns,
+    },
+    nextIndex: alias.nextIndex,
+  };
+}
+
+function parseTableFunctionSource(state: ParseState, nameIndex: number, introducer: string, sourceIndex: number): { source: SqlSemanticRowSource; nextIndex: number } | null {
+  const nameToken = state.tokens[nameIndex];
+  if (!nameToken || nameToken.kind !== "word" || !["table", "xmltable", "json_table", "the", "read_csv", "read_parquet", "read_json", "unnest"].includes(nameToken.normalized)) return null;
+  if (state.tokens[nameIndex + 1]?.text !== "(") return null;
+  const close = findMatchingParenToken(state.tokens, nameIndex + 1);
+  const safeClose = close < 0 ? nameIndex + 1 : close;
+  const alias = aliasAfter(state.tokens, safeClose + 1, state.dialect);
+  const sourceName = alias.alias ?? nameToken.normalized;
+  return {
+    source: {
+      id: `${introducer}:table_function:${sourceIndex}`,
+      kind: "table_function",
+      name: sourceName,
+      qualifierParts: [],
+      alias: alias.alias,
+      aliasSpan: alias.aliasSpan,
+      sourceSpan: { start: nameToken.span.start, end: alias.aliasSpan?.end ?? state.tokens[safeClose]?.span.end ?? nameToken.span.end },
+      unresolved: close < 0,
+    },
+    nextIndex: alias.nextIndex,
+  };
+}
+
+function parseTableSource(state: ParseState, nameIndex: number, introducer: string, sourceIndex: number): { source: SqlSemanticRowSource; nextIndex: number } | null {
+  const qualified = readQualifiedName(state.tokens, nameIndex, state.dialect);
+  if (!qualified) return null;
+  const { name, qualifierParts } = sourceNameFromQualifiedName(qualified.name);
+  const alias = aliasAfter(state.tokens, qualified.nextIndex, state.dialect);
+  const cte = state.cteSources.find((source) => source.name.toLowerCase() === name.toLowerCase());
+  const kind = cte ? "cte" : introducer === "update" || introducer === "into" || (state.statement.kind === "delete" && introducer === "from") ? "mutation_target" : "table";
+  const source: SqlSemanticRowSource = {
+    id: `${introducer}:${name}:${sourceIndex}`,
+    kind,
+    name,
+    qualifiedName: qualified.name,
+    qualifierParts,
+    alias: alias.alias,
+    aliasSpan: alias.aliasSpan,
+    sourceSpan: { start: qualified.name.span.start, end: alias.aliasSpan?.end ?? qualified.name.span.end },
+    columns: cte?.columns,
+    metadataTarget: {
+      schema: qualifierParts[qualifierParts.length - 1],
+      table: name,
+    },
+  };
+  return { source, nextIndex: alias.nextIndex };
+}
+
+function parseRowSources(state: ParseState): SqlSemanticRowSource[] {
+  const sources: SqlSemanticRowSource[] = [...state.cteSources];
+  const rootDepth = state.tokens.reduce((min, item) => Math.min(min, item.depth), Number.POSITIVE_INFINITY);
+  const sourceDepth = Number.isFinite(rootDepth) ? rootDepth : 0;
+  for (let index = 0; index < state.tokens.length; index += 1) {
+    const item = state.tokens[index];
+    if (!item || item.kind !== "word") continue;
+    if (item.depth !== sourceDepth) continue;
+    const normalized = item.normalized;
+    if (!TABLE_INTRODUCERS.has(normalized)) continue;
+    if (JOIN_MODIFIERS.has(normalized)) continue;
+    let target = index + 1;
+    while (JOIN_MODIFIERS.has(state.tokens[target]?.normalized ?? "")) target += 1;
+    if (state.tokens[target]?.text === "(") {
+      const subquery = parseSubquerySource(state, target, normalized, sources.length);
+      if (subquery) {
+        sources.push(subquery.source);
+        index = subquery.nextIndex - 1;
+      }
+      continue;
+    }
+    const tableFunction = parseTableFunctionSource(state, target, normalized, sources.length);
+    if (tableFunction) {
+      sources.push(tableFunction.source);
+      index = tableFunction.nextIndex - 1;
+      continue;
+    }
+    const table = parseTableSource(state, target, normalized, sources.length);
+    if (table) {
+      sources.push(table.source);
+      index = table.nextIndex - 1;
+    }
+  }
+  return dedupeSources(sources);
+}
+
+function dedupeSources(sources: SqlSemanticRowSource[]): SqlSemanticRowSource[] {
+  const seen = new Set<string>();
+  const result: SqlSemanticRowSource[] = [];
+  for (const source of sources) {
+    const key = `${source.kind}:${source.name}:${source.alias ?? ""}:${source.sourceSpan.start}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(source);
+  }
+  return result;
+}
+
+function clauseSpans(tokens: readonly SqlSemanticToken[]): SqlSemanticClauseSpans {
+  const spans: SqlSemanticClauseSpans = {};
+  const depth = tokens[0]?.depth ?? 0;
+  for (let index = 0; index < tokens.length; index += 1) {
+    const item = tokens[index];
+    if (!item || item.depth !== depth || item.kind !== "word") continue;
+    const next = tokens[index + 1];
+    const start = item.span.start;
+    const end = next?.span.start ?? tokens[tokens.length - 1]?.span.end ?? item.span.end;
+    if (item.normalized === "select") spans.select = { start, end };
+    if (item.normalized === "from") spans.from = { start, end };
+    if (item.normalized === "where") spans.where = { start, end };
+    if (item.normalized === "having") spans.having = { start, end };
+    if (item.normalized === "limit") spans.limit = { start, end };
+    if (item.normalized === "group" && next?.normalized === "by") spans.groupBy = { start, end: next.span.end };
+    if (item.normalized === "order" && next?.normalized === "by") spans.orderBy = { start, end: next.span.end };
+    if (item.normalized === "set") spans.updateSet = { start, end };
+  }
+  return spans;
+}
+
+function trailingIdentifier(tokens: readonly SqlSemanticToken[], cursor: number, dialect: SqlSemanticDialectAdapter): TrailingIdentifier {
+  const before = tokens.filter((item) => item.span.start < cursor && item.kind !== "comment" && item.kind !== "string");
+  const last = before[before.length - 1];
+  if (!last) return { prefix: "", replacementRange: { start: cursor, end: cursor }, qualifierParts: [] };
+  if (last.span.end < cursor && last.text !== ".") {
+    return { prefix: "", replacementRange: { start: cursor, end: cursor }, qualifierParts: [] };
+  }
+
+  let prefix = "";
+  let replacementRange: SqlSemanticSpan = { start: cursor, end: cursor };
+  let index = before.length - 1;
+  let hasQualifier = false;
+  if (tokenIsIdentifier(last) && cursor <= last.span.end) {
+    const rawPrefix = tokenTextAt(last.text, { start: 0, end: Math.max(0, cursor - last.span.start) });
+    prefix = last.kind === "quoted_identifier" ? unquoteSqlSemanticIdentifier({ ...last, text: rawPrefix.endsWith(last.quote ?? "") ? rawPrefix : rawPrefix + (last.quote === "[" ? "]" : (last.quote ?? "")) }) : rawPrefix;
+    replacementRange = { start: last.span.start, end: cursor };
+    index -= 1;
+    if (before[index]?.text === ".") {
+      hasQualifier = true;
+      index -= 1;
+    }
+  } else if (last.text === ".") {
+    hasQualifier = true;
+    index -= 1;
+  }
+
+  const qualifierParts: string[] = [];
+  if (hasQualifier) {
+    while (index >= 0) {
+      const identifier = before[index];
+      if (!tokenIsIdentifier(identifier)) break;
+      qualifierParts.unshift(identifierPart(identifier, dialect).name);
+      if (before[index - 1]?.text !== ".") break;
+      index -= 2;
+    }
+  }
+
+  return { prefix, replacementRange, qualifierParts };
+}
+
+function previousWord(tokens: readonly SqlSemanticToken[], cursor: number): string {
+  const before = tokens.filter((item) => item.span.end <= cursor && item.kind === "word");
+  return before[before.length - 1]?.normalized ?? "";
+}
+
+function wordBeforePosition(tokens: readonly SqlSemanticToken[], position: number): string {
+  const before = tokens.filter((item) => item.span.end <= position && item.kind === "word");
+  return before[before.length - 1]?.normalized ?? "";
+}
+
+function isTableListContinuation(tokens: readonly SqlSemanticToken[], position: number): boolean {
+  const before = tokens.filter((item) => item.span.end <= position && item.kind !== "comment");
+  const commaIndex = before.length - 1;
+  const comma = before[commaIndex];
+  if (comma?.text !== ",") return false;
+  const depth = comma.depth;
+  for (let index = commaIndex - 1; index >= 0; index -= 1) {
+    const token = before[index];
+    if (!token || token.depth !== depth || token.kind !== "word") continue;
+    if (TABLE_INTRODUCERS.has(token.normalized) || token.normalized === "from" || token.normalized === "join") return true;
+    if (CLAUSE_BOUNDARIES.has(token.normalized) || token.normalized === "select") return false;
+  }
+  return false;
+}
+
+function hasWordBefore(tokens: readonly SqlSemanticToken[], cursor: number, word: string): boolean {
+  return tokens.some((item) => item.span.end <= cursor && item.kind === "word" && item.normalized === word);
+}
+
+function isBeforeWord(tokens: readonly SqlSemanticToken[], cursor: number, word: string): boolean {
+  const target = tokens.find((item) => item.span.start >= cursor && item.kind === "word" && item.normalized === word);
+  return !!target;
+}
+
+function sourceForQualifier(sources: readonly SqlSemanticRowSource[], qualifierParts: readonly string[]): SqlSemanticRowSource | undefined {
+  const qualifier = qualifierParts[qualifierParts.length - 1]?.toLowerCase();
+  if (!qualifier) return undefined;
+  return sources.find((source) => source.alias?.toLowerCase() === qualifier || source.name.toLowerCase() === qualifier);
+}
+
+function starQualifierParts(before: readonly SqlSemanticToken[], starIndex: number, dialect: SqlSemanticDialectAdapter): string[] {
+  let index = starIndex - 1;
+  if (before[index]?.text === ".") index -= 1;
+  const qualifierParts: string[] = [];
+  while (index >= 0) {
+    const identifier = before[index];
+    if (!tokenIsIdentifier(identifier)) break;
+    qualifierParts.unshift(identifierPart(identifier, dialect).name);
+    if (before[index - 1]?.text !== ".") break;
+    index -= 2;
+  }
+  return qualifierParts;
+}
+
+function buildCursorIntent(tokens: readonly SqlSemanticToken[], cursor: number, sources: readonly SqlSemanticRowSource[], dialect: SqlSemanticDialectAdapter, suppressed: boolean, kind: SqlSemanticStatementKind): SqlSemanticCursorIntent {
+  if (suppressed) {
+    return { kind: "suppressed", prefix: "", replacementRange: { start: cursor, end: cursor }, qualifierParts: [], expectedObjectKinds: [], confidence: "high", fallbackReason: "comment_or_string" };
+  }
+  const trailing = trailingIdentifier(tokens, cursor, dialect);
+  const previous = previousWord(tokens, cursor);
+  const targetSource = sourceForQualifier(sources, trailing.qualifierParts);
+  const before = tokens.filter((item) => item.span.end <= cursor);
+  const last = before[before.length - 1];
+  const wordBeforeReplacement = wordBeforePosition(tokens, trailing.replacementRange.start);
+  const tableListContinuation = isTableListContinuation(tokens, trailing.replacementRange.start);
+
+  if (last?.text === "*" || trailing.prefix === "*") {
+    const starIndex = last?.text === "*" ? before.length - 1 : -1;
+    const qualifierParts = starIndex >= 0 ? starQualifierParts(before, starIndex, dialect) : trailing.qualifierParts;
+    const starTarget = sourceForQualifier(sources, qualifierParts);
+    const replacementRange = last?.text === "*" ? { start: last.span.start, end: Math.min(cursor, last.span.end) } : trailing.replacementRange;
+    return { kind: "star", prefix: "*", replacementRange, qualifierParts, targetSourceId: starTarget?.id, expectedObjectKinds: ["column"], confidence: "high" };
+  }
+
+  if (kind === "call") {
+    return { kind: "routine", prefix: trailing.prefix, replacementRange: trailing.replacementRange, qualifierParts: trailing.qualifierParts, expectedObjectKinds: ["routine", "procedure", "function"], confidence: "high" };
+  }
+
+  if (kind === "insert" && hasWordBefore(tokens, cursor, "into") && !hasWordBefore(tokens, cursor, "values")) {
+    const mutationTarget = sources.find((source) => source.kind === "mutation_target");
+    return {
+      kind: "insert_column",
+      prefix: trailing.prefix,
+      replacementRange: trailing.replacementRange,
+      qualifierParts: trailing.qualifierParts,
+      targetSourceId: mutationTarget?.id,
+      expectedObjectKinds: ["column"],
+      confidence: mutationTarget ? "medium" : "low",
+      fallbackReason: mutationTarget ? undefined : "unresolved_insert_target",
+    };
+  }
+
+  if (
+    trailing.qualifierParts.length > 0 &&
+    (previous === "from" || previous === "join" || TABLE_INTRODUCERS.has(previous) || TABLE_INTRODUCERS.has(wordBeforeReplacement) || (!!targetSource && !targetSource.alias && TABLE_INTRODUCERS.has(wordBeforePosition(tokens, targetSource.sourceSpan.start))))
+  ) {
+    const role = dialect.qualifierRole(trailing.qualifierParts, "table");
+    return { kind: role === "catalog" ? "catalog" : "table", prefix: trailing.prefix, replacementRange: trailing.replacementRange, qualifierParts: trailing.qualifierParts, expectedObjectKinds: ["table", "view"], confidence: "medium" };
+  }
+
+  if (trailing.qualifierParts.length > 0 && targetSource) {
+    return { kind: "alias_column", prefix: trailing.prefix, replacementRange: trailing.replacementRange, qualifierParts: trailing.qualifierParts, targetSourceId: targetSource.id, expectedObjectKinds: ["column"], confidence: "high" };
+  }
+
+  if (TABLE_INTRODUCERS.has(previous) || TABLE_INTRODUCERS.has(wordBeforeReplacement) || previous === "from" || previous === "join" || wordBeforeReplacement === "from" || wordBeforeReplacement === "join" || tableListContinuation) {
+    return { kind: previous === "join" ? "table" : "table", prefix: trailing.prefix, replacementRange: trailing.replacementRange, qualifierParts: trailing.qualifierParts, expectedObjectKinds: ["table", "view"], confidence: "high" };
+  }
+
+  if (previous === "call" || previous === "exec" || previous === "execute") {
+    return { kind: "routine", prefix: trailing.prefix, replacementRange: trailing.replacementRange, qualifierParts: trailing.qualifierParts, expectedObjectKinds: ["routine", "procedure", "function"], confidence: "high" };
+  }
+
+  if (previous === "set") {
+    return {
+      kind: "update_column",
+      prefix: trailing.prefix,
+      replacementRange: trailing.replacementRange,
+      qualifierParts: trailing.qualifierParts,
+      expectedObjectKinds: ["column"],
+      confidence: sources.length > 0 ? "medium" : "low",
+      fallbackReason: sources.length > 0 ? undefined : "unresolved_update_target",
+    };
+  }
+
+  if (["where", "on", "and", "or", "having", "by", "select"].includes(previous) && sources.length > 0 && !isBeforeWord(tokens, cursor, "from")) {
+    return { kind: previous === "on" ? "join_condition" : "column", prefix: trailing.prefix, replacementRange: trailing.replacementRange, qualifierParts: trailing.qualifierParts, expectedObjectKinds: ["column"], confidence: "medium" };
+  }
+
+  return { kind: "keyword", prefix: trailing.prefix, replacementRange: trailing.replacementRange, qualifierParts: trailing.qualifierParts, expectedObjectKinds: [], confidence: "low", fallbackReason: "keyword_context" };
+}
+
+function buildScope(statement: SqlSemanticStatement, rowSources: SqlSemanticRowSource[], projections: SqlSemanticProjection[], tokens: SqlSemanticToken[]): SqlSemanticScope {
+  return {
+    id: "root",
+    kind: statement.kind,
+    span: statement.span,
+    rowSources,
+    projections,
+    clauseSpans: clauseSpans(tokens),
+  };
+}
+
+export function buildSqlSemanticModel(sql: string, cursor: number, options: SqlSemanticBuildOptions = {}): SqlSemanticModel {
+  const safeCursor = Math.max(0, Math.min(cursor, sql.length));
+  const dialect = sqlSemanticDialectFor(options);
+  const allTokens = tokenizeSqlSemantic(sql);
+  const statementSpan = findActiveSqlStatementSpan(sql, allTokens, safeCursor);
+  const tokens = significantTokens(allTokens.filter((item) => item.span.end > statementSpan.start && item.span.start < statementSpan.end));
+  const kind = statementKind(tokens);
+  const statement: SqlSemanticStatement = {
+    kind,
+    span: statementSpan,
+    text: sql.slice(statementSpan.start, statementSpan.end),
+  };
+  const suppressed = isSuppressedSqlSemanticContext(allTokens, safeCursor);
+  const parseState: ParseState = { dialect, tokens, statement, cteSources: [] };
+  parseState.cteSources = parseCteSources(parseState);
+  const rowSources = parseRowSources(parseState);
+  const projections = parseSelectProjections(tokens, dialect);
+  const cursorIntent = buildCursorIntent(tokens, safeCursor, rowSources, dialect, suppressed, kind);
+  const scopes = [buildScope(statement, rowSources, projections, tokens)];
+  return {
+    databaseType: options.databaseType,
+    dialectId: dialect.id,
+    sql,
+    cursor: safeCursor,
+    statement,
+    tokens: allTokens,
+    scopes,
+    rowSources,
+    projections,
+    cursorIntent,
+    diagnostics: [],
+  };
+}
diff --git a/apps/desktop/src/lib/sql/semantic/references.ts b/apps/desktop/src/lib/sql/semantic/references.ts
new file mode 100644
index 0000000..3918407
--- /dev/null
+++ b/apps/desktop/src/lib/sql/semantic/references.ts
@@ -0,0 +1,154 @@
+import type { SqlCompletionReferencedTable } from "@/lib/sql/sqlCompletion";
+import type { SqlSemanticModel, SqlSemanticRowSource, SqlSemanticSpan } from "@/lib/sql/semantic/types";
+import type { SqlReferenceAnalysis, SqlTableReference, SqlTextSpan } from "@/types/database";
+
+export type SqlSemanticTableReference = SqlTableReference & {
+  columns?: string[];
+  semanticSourceId?: string;
+  semanticSourceKind?: SqlSemanticRowSource["kind"];
+};
+
+export interface SqlSemanticNavigationTarget {
+  name: string;
+  schema?: string;
+  alias?: string;
+  columns?: string[];
+  source: SqlSemanticRowSource;
+}
+
+function offsetToLineColumn(sql: string, offset: number): { line: number; column: number } {
+  const safeOffset = Math.max(0, Math.min(offset, sql.length));
+  let line = 1;
+  let lineStart = 0;
+  for (let index = 0; index < safeOffset; index += 1) {
+    if (sql[index] === "\n") {
+      line += 1;
+      lineStart = index + 1;
+    }
+  }
+  return { line, column: safeOffset - lineStart };
+}
+
+function semanticSpanToSqlTextSpan(sql: string, span: SqlSemanticSpan): SqlTextSpan {
+  const start = offsetToLineColumn(sql, span.start);
+  const end = offsetToLineColumn(sql, Math.max(span.end, span.start));
+  return {
+    start_line: start.line,
+    start_column: start.column + 1,
+    end_line: end.line,
+    end_column: Math.max(end.column, start.column + 1),
+  };
+}
+
+function normalized(value: string | null | undefined): string {
+  let result = value ?? "";
+  while (result && '`"['.includes(result[0])) result = result.slice(1);
+  while (result && '`"]'.includes(result[result.length - 1])) result = result.slice(0, -1);
+  return result.toLowerCase();
+}
+
+function sourceSchema(source: SqlSemanticRowSource): string | undefined {
+  return source.metadataTarget?.schema ?? source.qualifierParts[source.qualifierParts.length - 1];
+}
+
+function sourceTableName(source: SqlSemanticRowSource): string {
+  return source.metadataTarget?.table ?? source.name;
+}
+
+function sourceReferenceKey(source: SqlSemanticTableReference): string {
+  return [normalized(source.schema), normalized(source.name), normalized(source.alias), source.span.start_line, source.span.start_column].join(":");
+}
+
+function existingScopeId(analysis: SqlReferenceAnalysis): number {
+  return analysis.tables[0]?.scope_id ?? analysis.columns[0]?.scope_id ?? 0;
+}
+
+export function sqlSemanticTableReferences(model: SqlSemanticModel, scopeId = 0): SqlSemanticTableReference[] {
+  if (model.cursorIntent.kind === "suppressed" || model.cursorIntent.confidence === "low") return [];
+  return model.rowSources
+    .filter((source) => source.kind !== "unknown")
+    .map((source) => {
+      const span = source.qualifiedName?.span ?? source.aliasSpan ?? source.sourceSpan;
+      const schema = sourceSchema(source);
+      return {
+        name: sourceTableName(source),
+        schema,
+        alias: source.alias,
+        span: semanticSpanToSqlTextSpan(model.sql, span),
+        scope_id: scopeId,
+        columns: source.columns?.length ? [...source.columns] : undefined,
+        semanticSourceId: source.id,
+        semanticSourceKind: source.kind,
+      };
+    });
+}
+
+export function mergeSqlSemanticReferenceAnalysis(analysis: SqlReferenceAnalysis, model: SqlSemanticModel): SqlReferenceAnalysis {
+  const semanticTables = sqlSemanticTableReferences(model, existingScopeId(analysis));
+  if (semanticTables.length === 0) return analysis;
+
+  const merged = new Map<string, SqlSemanticTableReference>();
+  for (const table of analysis.tables as SqlSemanticTableReference[]) {
+    merged.set(sourceReferenceKey(table), table);
+  }
+
+  for (const table of semanticTables) {
+    const existing = [...merged.values()].find((candidate) => {
+      if (normalized(candidate.name) !== normalized(table.name)) return false;
+      if (candidate.alias && table.alias && normalized(candidate.alias) !== normalized(table.alias)) return false;
+      if (candidate.schema && table.schema && normalized(candidate.schema) !== normalized(table.schema)) return false;
+      return true;
+    });
+    if (existing) {
+      existing.schema = existing.schema ?? table.schema;
+      existing.alias = existing.alias ?? table.alias;
+      existing.columns = existing.columns ?? table.columns;
+      existing.semanticSourceId = existing.semanticSourceId ?? table.semanticSourceId;
+    } else {
+      merged.set(sourceReferenceKey(table), table);
+    }
+  }
+
+  return {
+    ...analysis,
+    tables: [...merged.values()],
+  };
+}
+
+export function sqlSemanticCompletionReferenceTables(model: SqlSemanticModel): SqlCompletionReferencedTable[] {
+  return sqlSemanticTableReferences(model).map((table) => ({
+    name: table.name,
+    schema: table.schema ?? undefined,
+    alias: table.alias ?? undefined,
+    columns: table.columns,
+  }));
+}
+
+export function resolveSqlSemanticNavigationTarget(model: SqlSemanticModel, identifierParts: readonly string[]): SqlSemanticNavigationTarget | null {
+  if (model.cursorIntent.kind === "suppressed" || model.cursorIntent.confidence === "low" || identifierParts.length === 0) return null;
+  const normalizedParts = identifierParts.map(normalized).filter(Boolean);
+  const name = normalizedParts[normalizedParts.length - 1];
+  const qualifier = normalizedParts.length > 1 ? normalizedParts[normalizedParts.length - 2] : undefined;
+
+  const source =
+    model.rowSources.find((candidate) => {
+      const candidateName = normalized(sourceTableName(candidate));
+      const candidateAlias = normalized(candidate.alias);
+      const candidateSchema = normalized(sourceSchema(candidate));
+      if (qualifier) {
+        if (candidateAlias && candidateAlias === qualifier) return true;
+        return candidateName === name && (!candidateSchema || candidateSchema === qualifier);
+      }
+      return candidateName === name || candidateAlias === name;
+    }) ?? null;
+
+  if (!source) return null;
+  const schema = sourceSchema(source);
+  return {
+    name: sourceTableName(source),
+    schema,
+    alias: source.alias,
+    columns: source.columns,
+    source,
+  };
+}
diff --git a/apps/desktop/src/lib/sql/semantic/tokens.ts b/apps/desktop/src/lib/sql/semantic/tokens.ts
new file mode 100644
index 0000000..adecd87
--- /dev/null
+++ b/apps/desktop/src/lib/sql/semantic/tokens.ts
@@ -0,0 +1,173 @@
+import type { SqlSemanticSpan, SqlSemanticToken } from "@/lib/sql/semantic/types";
+
+const WORD_START = /[A-Za-z_@$#]/;
+const WORD_PART = /[A-Za-z0-9_@$#]/;
+
+function token(kind: SqlSemanticToken["kind"], text: string, start: number, end: number, depth: number, quote?: string): SqlSemanticToken {
+  return {
+    kind,
+    text,
+    normalized: kind === "word" ? text.toLowerCase() : text,
+    span: { start, end },
+    depth,
+    quote,
+  };
+}
+
+function readQuoted(input: string, start: number, open: string, close: string): number {
+  let index = start + open.length;
+  while (index < input.length) {
+    if (input.startsWith(close, index)) {
+      if (input.startsWith(close + close, index)) {
+        index += close.length * 2;
+        continue;
+      }
+      return index + close.length;
+    }
+    index += 1;
+  }
+  return input.length;
+}
+
+export function tokenizeSqlSemantic(input: string): SqlSemanticToken[] {
+  const tokens: SqlSemanticToken[] = [];
+  let index = 0;
+  let depth = 0;
+
+  while (index < input.length) {
+    const start = index;
+    const ch = input[index] ?? "";
+    const next = input[index + 1] ?? "";
+
+    if (/\s/.test(ch)) {
+      index += 1;
+      continue;
+    }
+
+    if (ch === "-" && next === "-") {
+      index += 2;
+      while (index < input.length && input[index] !== "\n" && input[index] !== "\r") index += 1;
+      tokens.push(token("comment", input.slice(start, index), start, index, depth));
+      continue;
+    }
+
+    if (ch === "#") {
+      index += 1;
+      while (index < input.length && input[index] !== "\n" && input[index] !== "\r") index += 1;
+      tokens.push(token("comment", input.slice(start, index), start, index, depth));
+      continue;
+    }
+
+    if (ch === "/" && next === "*") {
+      index += 2;
+      while (index < input.length && !(input[index] === "*" && input[index + 1] === "/")) index += 1;
+      index = Math.min(input.length, index + (index < input.length ? 2 : 0));
+      tokens.push(token("comment", input.slice(start, index), start, index, depth));
+      continue;
+    }
+
+    if (ch === "'") {
+      index = readQuoted(input, start, "'", "'");
+      tokens.push(token("string", input.slice(start, index), start, index, depth, "'"));
+      continue;
+    }
+
+    if (ch === "$") {
+      const marker = /^\$[A-Za-z_0-9]*\$/.exec(input.slice(start))?.[0];
+      if (marker) {
+        const closing = input.indexOf(marker, start + marker.length);
+        index = closing < 0 ? input.length : closing + marker.length;
+        tokens.push(token("string", input.slice(start, index), start, index, depth, marker));
+        continue;
+      }
+    }
+
+    if (ch === '"') {
+      index = readQuoted(input, start, '"', '"');
+      tokens.push(token("quoted_identifier", input.slice(start, index), start, index, depth, '"'));
+      continue;
+    }
+
+    if (ch === "`") {
+      index = readQuoted(input, start, "`", "`");
+      tokens.push(token("quoted_identifier", input.slice(start, index), start, index, depth, "`"));
+      continue;
+    }
+
+    if (ch === "[") {
+      index = readQuoted(input, start, "[", "]");
+      tokens.push(token("quoted_identifier", input.slice(start, index), start, index, depth, "["));
+      continue;
+    }
+
+    if (ch === ":" || ch === "?") {
+      index += 1;
+      while (index < input.length && WORD_PART.test(input[index] ?? "")) index += 1;
+      tokens.push(token("parameter", input.slice(start, index), start, index, depth));
+      continue;
+    }
+
+    if (/[0-9]/.test(ch)) {
+      index += 1;
+      while (index < input.length && /[0-9.]/.test(input[index] ?? "")) index += 1;
+      tokens.push(token("number", input.slice(start, index), start, index, depth));
+      continue;
+    }
+
+    if (WORD_START.test(ch)) {
+      index += 1;
+      while (index < input.length && WORD_PART.test(input[index] ?? "")) index += 1;
+      tokens.push(token("word", input.slice(start, index), start, index, depth));
+      continue;
+    }
+
+    if ("(),.;*".includes(ch)) {
+      if (ch === ")") depth = Math.max(0, depth - 1);
+      tokens.push(token("punctuation", ch, start, start + 1, depth));
+      if (ch === "(") depth += 1;
+      index += 1;
+      continue;
+    }
+
+    index += 1;
+    tokens.push(token("operator", ch, start, index, depth));
+  }
+
+  return tokens;
+}
+
+export function tokenContainsPosition(tokenValue: SqlSemanticToken, position: number): boolean {
+  return tokenValue.span.start <= position && position <= tokenValue.span.end;
+}
+
+export function isSuppressedSqlSemanticContext(tokens: readonly SqlSemanticToken[], cursor: number): boolean {
+  return tokens.some((item) => (item.kind === "comment" || item.kind === "string") && item.span.start < cursor && cursor <= item.span.end);
+}
+
+export function findActiveSqlStatementSpan(sql: string, tokens: readonly SqlSemanticToken[], cursor: number): SqlSemanticSpan {
+  let start = 0;
+  let end = sql.length;
+  for (const item of tokens) {
+    if (item.kind !== "punctuation" || item.text !== ";" || item.depth !== 0) continue;
+    if (item.span.end <= cursor) start = item.span.end;
+    if (item.span.start >= cursor) {
+      end = item.span.start;
+      break;
+    }
+  }
+
+  while (start < end && /\s/.test(sql[start] ?? "")) start += 1;
+  while (end > start && /\s/.test(sql[end - 1] ?? "")) end -= 1;
+  return { start, end };
+}
+
+export function unquoteSqlSemanticIdentifier(tokenValue: SqlSemanticToken): string {
+  if (tokenValue.kind !== "quoted_identifier") return tokenValue.text;
+  if (tokenValue.quote === "[") return tokenValue.text.slice(1, -1).replaceAll("]]", "]");
+  const quote = tokenValue.quote ?? tokenValue.text[0] ?? "";
+  return tokenValue.text.slice(1, -1).replaceAll(quote + quote, quote);
+}
+
+export function tokenIsIdentifier(tokenValue: SqlSemanticToken | undefined): tokenValue is SqlSemanticToken {
+  return !!tokenValue && (tokenValue.kind === "word" || tokenValue.kind === "quoted_identifier");
+}
diff --git a/apps/desktop/src/lib/sql/semantic/types.ts b/apps/desktop/src/lib/sql/semantic/types.ts
new file mode 100644
index 0000000..9c6d46c
--- /dev/null
+++ b/apps/desktop/src/lib/sql/semantic/types.ts
@@ -0,0 +1,130 @@
+import type { DatabaseType } from "@/types/database";
+
+export interface SqlSemanticSpan {
+  start: number;
+  end: number;
+}
+
+export type SqlSemanticConfidence = "high" | "medium" | "low";
+
+export type SqlSemanticStatementKind = "select" | "insert" | "update" | "delete" | "call" | "unknown";
+
+export type SqlSemanticTokenKind = "word" | "quoted_identifier" | "string" | "number" | "comment" | "parameter" | "punctuation" | "operator";
+
+export interface SqlSemanticToken {
+  kind: SqlSemanticTokenKind;
+  text: string;
+  normalized: string;
+  span: SqlSemanticSpan;
+  depth: number;
+  quote?: string;
+}
+
+export interface SqlSemanticIdentifierPart {
+  raw: string;
+  name: string;
+  span: SqlSemanticSpan;
+  quote?: string;
+}
+
+export interface SqlSemanticQualifiedName {
+  parts: SqlSemanticIdentifierPart[];
+  span: SqlSemanticSpan;
+}
+
+export type SqlSemanticRowSourceKind = "table" | "cte" | "subquery" | "table_function" | "mutation_target" | "unknown";
+
+export interface SqlSemanticMetadataTarget {
+  database?: string;
+  schema?: string;
+  table?: string;
+  packageName?: string;
+}
+
+export interface SqlSemanticProjection {
+  name: string;
+  sourceExpression: string;
+  span: SqlSemanticSpan;
+  alias?: string;
+  aliasSpan?: SqlSemanticSpan;
+}
+
+export interface SqlSemanticRowSource {
+  id: string;
+  kind: SqlSemanticRowSourceKind;
+  name: string;
+  qualifiedName?: SqlSemanticQualifiedName;
+  qualifierParts: string[];
+  alias?: string;
+  aliasSpan?: SqlSemanticSpan;
+  sourceSpan: SqlSemanticSpan;
+  columns?: string[];
+  metadataTarget?: SqlSemanticMetadataTarget;
+  unresolved?: boolean;
+}
+
+export interface SqlSemanticClauseSpans {
+  select?: SqlSemanticSpan;
+  from?: SqlSemanticSpan;
+  where?: SqlSemanticSpan;
+  groupBy?: SqlSemanticSpan;
+  having?: SqlSemanticSpan;
+  orderBy?: SqlSemanticSpan;
+  limit?: SqlSemanticSpan;
+  insertColumns?: SqlSemanticSpan;
+  updateSet?: SqlSemanticSpan;
+}
+
+export interface SqlSemanticScope {
+  id: string;
+  kind: SqlSemanticStatementKind | "subquery" | "cte";
+  span: SqlSemanticSpan;
+  parentId?: string;
+  rowSources: SqlSemanticRowSource[];
+  projections: SqlSemanticProjection[];
+  clauseSpans: SqlSemanticClauseSpans;
+}
+
+export type SqlSemanticCursorKind = "table" | "schema" | "catalog" | "routine" | "column" | "alias_column" | "insert_column" | "update_column" | "delete_target" | "join_condition" | "star" | "keyword" | "suppressed";
+
+export interface SqlSemanticCursorIntent {
+  kind: SqlSemanticCursorKind;
+  prefix: string;
+  replacementRange: SqlSemanticSpan;
+  qualifierParts: string[];
+  targetSourceId?: string;
+  expectedObjectKinds: Array<"database" | "schema" | "table" | "view" | "routine" | "procedure" | "function" | "column">;
+  confidence: SqlSemanticConfidence;
+  fallbackReason?: string;
+}
+
+export interface SqlSemanticStatement {
+  kind: SqlSemanticStatementKind;
+  span: SqlSemanticSpan;
+  text: string;
+}
+
+export interface SqlSemanticDiagnostic {
+  message: string;
+  span: SqlSemanticSpan;
+  severity: "info" | "warning" | "error";
+}
+
+export interface SqlSemanticModel {
+  databaseType?: DatabaseType;
+  dialectId: string;
+  sql: string;
+  cursor: number;
+  statement: SqlSemanticStatement;
+  tokens: SqlSemanticToken[];
+  scopes: SqlSemanticScope[];
+  rowSources: SqlSemanticRowSource[];
+  projections: SqlSemanticProjection[];
+  cursorIntent: SqlSemanticCursorIntent;
+  diagnostics: SqlSemanticDiagnostic[];
+}
+
+export interface SqlSemanticBuildOptions {
+  databaseType?: DatabaseType;
+  dialect?: "mysql" | "postgres" | "sqlserver";
+}
diff --git a/apps/desktop/src/lib/sql/sqlAnalysis.ts b/apps/desktop/src/lib/sql/sqlAnalysis.ts
new file mode 100644
index 0000000..f7d19e2
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlAnalysis.ts
@@ -0,0 +1,504 @@
+// Binary column types that should not be edited inline
+export const BINARY_TYPES = new Set(["blob", "clob", "bytea", "varbinary", "binary", "image", "longblob", "mediumblob", "tinyblob", "blob sub_type 2004", "blob sub_type 2005"]);
+
+export function isBinaryType(dataType: string): boolean {
+  const lower = dataType
+    .toLowerCase()
+    .replace(/\s*\([^)]*\)\s*$/, "")
+    .trim();
+  return BINARY_TYPES.has(lower);
+}
+
+export interface EditableQueryInfo {
+  catalog?: string;
+  catalogQuoted?: boolean;
+  schema: string | undefined;
+  schemaQuoted?: boolean;
+  tableName: string;
+  tableNameQuoted?: boolean;
+  tableAlias?: string;
+  selectStar: boolean;
+  columns: EditableQueryColumn[]; // empty array if SELECT *
+  sources?: EditableQuerySource[];
+  editableSourceKey?: string;
+  multiSource?: boolean;
+  allowInsert?: boolean;
+  allowInsertDelete?: boolean;
+  distinct?: boolean;
+}
+
+export interface EditableQueryColumn {
+  sourceName?: string;
+  sourceNameQuoted?: boolean;
+  sourceQualifier?: string;
+  sourceKey?: string;
+  star?: boolean;
+  resultName: string;
+  expression: string;
+}
+
+export interface EditableQuerySource {
+  key: string;
+  catalog?: string;
+  catalogQuoted?: boolean;
+  schema?: string;
+  schemaQuoted?: boolean;
+  tableName: string;
+  tableNameQuoted?: boolean;
+  alias?: string;
+}
+
+export type QueryEditabilityReason = "not-select" | "cte" | "set-operation" | "aggregation" | "external-source" | "complex-source" | "computed-columns" | "no-table" | "no-primary-key" | "primary-key-not-returned" | "aliased-columns" | "metadata-unavailable";
+
+export type QueryEditability = { editable: true; analysis: EditableQueryInfo } | { editable: false; reason: QueryEditabilityReason };
+
+/**
+ * Parse a SELECT statement to determine if it's editable.
+ * Parse a SELECT statement to determine whether DBX can bind result columns to
+ * base-table columns. DBeaver uses result metadata for the same idea; DBX has to
+ * recover enough source mapping from SQL text before table metadata is loaded.
+ *
+ * Aggregated/set/query-derived results remain read-only. Multi-source queries
+ * may still be editable later if metadata proves that exactly one source table
+ * has a complete row identifier in the returned columns.
+ */
+export function analyzeEditableQuery(sql: string): EditableQueryInfo | null {
+  const result = analyzeEditableQueryEditability(sql);
+  return result.editable ? result.analysis : null;
+}
+
+export function analyzeEditableQueryEditability(sql: string): QueryEditability {
+  const normalized = stripSqlComments(sql)
+    .replace(/;+\s*$/, "")
+    .trim();
+  if (!normalized) return { editable: false, reason: "not-select" };
+  if (/^\s*WITH\b/i.test(normalized)) return { editable: false, reason: "cte" };
+  if (!/^SELECT\b/i.test(normalized)) return { editable: false, reason: "not-select" };
+  if (hasTopLevelKeyword(normalized, ["UNION", "INTERSECT", "EXCEPT"])) {
+    return { editable: false, reason: "set-operation" };
+  }
+  if (normalized.includes(";")) return { editable: false, reason: "complex-source" };
+
+  const fromIndex = findTopLevelKeyword(normalized, "FROM", 0);
+  if (fromIndex < 0) return { editable: false, reason: "no-table" };
+
+  const rawSelectBody = normalized.slice("SELECT".length, fromIndex).trim();
+  const distinct = /^DISTINCT\b/i.test(rawSelectBody);
+  const selectBodyWithoutDistinct = distinct ? rawSelectBody.replace(/^DISTINCT\b/i, "").trimStart() : rawSelectBody;
+  // DISTINCT ON selects a representative row using database-specific ordering,
+  // so it cannot be mapped to base rows like an ordinary DISTINCT projection.
+  if (distinct && /^ON\b/i.test(selectBodyWithoutDistinct)) return { editable: false, reason: "aggregation" };
+  const selectBody = stripSqlServerTopClause(selectBodyWithoutDistinct);
+
+  const groupIndex = findTopLevelKeyword(normalized, "GROUP", fromIndex + 4);
+  const havingIndex = findTopLevelKeyword(normalized, "HAVING", fromIndex + 4);
+  if (groupIndex >= 0 || havingIndex >= 0) return { editable: false, reason: "aggregation" };
+
+  const fromEnd = firstTopLevelKeywordIndex(normalized, ["WHERE", "ORDER", "LIMIT", "OFFSET", "FETCH"], fromIndex + 4);
+  const fromBody = normalized.slice(fromIndex + 4, fromEnd < 0 ? normalized.length : fromEnd).trim();
+  if (isExternalFromSource(fromBody)) return { editable: false, reason: "external-source" };
+  const sources = parseFromSources(fromBody);
+  if (!sources.length) return { editable: false, reason: "complex-source" };
+  const source = sources[0]!;
+
+  const selectStar = sources.length === 1 && isSelectStar(selectBody, source.alias);
+  const columns = selectStar ? [] : parseSelectColumns(selectBody, sources);
+  if (!selectStar && columns.length === 0) return { editable: false, reason: "computed-columns" };
+  if (sources.length > 1 && columns.some((column) => column.star && !column.sourceKey)) {
+    return { editable: false, reason: "complex-source" };
+  }
+
+  const analysis: EditableQueryInfo = {
+    catalog: source.catalog,
+    catalogQuoted: source.catalogQuoted,
+    schema: source.schema,
+    schemaQuoted: source.schemaQuoted,
+    tableName: source.tableName,
+    tableNameQuoted: source.tableNameQuoted,
+    tableAlias: source.alias,
+    selectStar,
+    columns,
+    ...(distinct ? { distinct: true, allowInsertDelete: false } : {}),
+  };
+  if (sources.length > 1) {
+    analysis.sources = sources;
+    analysis.multiSource = true;
+    analysis.allowInsertDelete = false;
+  }
+  return {
+    editable: true,
+    analysis,
+  };
+}
+
+export function queryEditabilityMessageKey(reason: QueryEditabilityReason): string {
+  return `grid.queryEditUnsupported.${reason}`;
+}
+
+function stripSqlServerTopClause(body: string): string {
+  const topMatch = body.match(/^TOP(?:\s+|(?=\())(?:\((?:[^()'"`[\]]|"[^"]*"|'(?:''|[^'])*'|`[^`]*`|\[[^\]]*\])+\)|\d+)\s*/i);
+  if (!topMatch) return body;
+  let remaining = body.slice(topMatch[0].length).trimStart();
+  remaining = remaining.replace(/^PERCENT\b\s*/i, "").replace(/^WITH\s+TIES\b\s*/i, "");
+  return remaining || body;
+}
+
+function parseSelectColumns(body: string, sources?: EditableQuerySource[]): EditableQueryColumn[] {
+  const cols: EditableQueryColumn[] = [];
+  let depth = 0;
+  let current = "";
+  let quote: string | null = null;
+  for (let i = 0; i < body.length; i++) {
+    const ch = body[i];
+    if (quote) {
+      current += ch;
+      if (ch === quote || (quote === "]" && ch === "]")) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") quote = ch;
+    else if (ch === "[") quote = "]";
+    else if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "," && depth === 0) {
+      const col = parseSelectColumn(current.trim(), sources);
+      if (!col) return [];
+      cols.push(col);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current.trim()) {
+    const col = parseSelectColumn(current.trim(), sources);
+    if (!col) return [];
+    cols.push(col);
+  }
+  return cols;
+}
+
+function parseSelectColumn(col: string, sources?: EditableQuerySource[]): EditableQueryColumn | null {
+  const star = parseStarSelectColumn(col, sources);
+  if (star) return star;
+  const source = parseQualifiedIdentifier(col);
+  if (!source) return parseComputedSelectColumn(col);
+  const alias = parseColumnAlias(source.rest);
+  if (alias === null) return parseComputedSelectColumn(col);
+  const sourceName = source.parts[source.parts.length - 1];
+  const qualifier = source.parts.length >= 2 ? source.parts[source.parts.length - 2] : undefined;
+  const sourceKey = qualifier ? sourceKeyForQualifier(sources, qualifier) : undefined;
+  return {
+    sourceName,
+    sourceNameQuoted: source.quoted[source.quoted.length - 1],
+    ...(qualifier ? { sourceQualifier: qualifier } : {}),
+    ...(sourceKey ? { sourceKey } : {}),
+    resultName: alias ?? sourceName,
+    expression: col.slice(0, source.end).trim(),
+  };
+}
+
+function parseStarSelectColumn(col: string, sources?: EditableQuerySource[]): EditableQueryColumn | null {
+  if (col === "*") {
+    return {
+      star: true,
+      resultName: "*",
+      expression: col,
+    };
+  }
+  const starMatch = col.match(/^((?:[A-Za-z_][\w$]*|"[^"]+"|`[^`]+`|\[[^\]]+\]))\s*\.\s*\*$/);
+  if (!starMatch) return null;
+  const qualifier = readIdentifier(starMatch[1]!, 0);
+  if (!qualifier) return null;
+  const sourceKey = sourceKeyForQualifier(sources, qualifier.value);
+  return {
+    star: true,
+    sourceQualifier: qualifier.value,
+    ...(sourceKey ? { sourceKey } : {}),
+    resultName: "*",
+    expression: col,
+  };
+}
+
+function parseComputedSelectColumn(col: string): EditableQueryColumn | null {
+  const alias = parseExpressionAlias(col);
+  if (!alias) return null;
+  return {
+    sourceName: undefined,
+    sourceNameQuoted: false,
+    resultName: alias.resultName,
+    expression: alias.expression,
+  };
+}
+
+function parseExpressionAlias(col: string): { expression: string; resultName: string } | null {
+  const asMatch = col.match(/\bAS\s+((?:"[^"]+")|(?:`[^`]+`)|(?:\[[^\]]+\])|(?:[A-Za-z_][\w$]*))\s*$/i);
+  if (asMatch?.index === undefined) return null;
+  const alias = readIdentifier(asMatch[1], 0);
+  if (!alias || alias.end !== asMatch[1].length) return null;
+  const expression = col.slice(0, asMatch.index).trim();
+  return expression ? { expression, resultName: alias.value } : null;
+}
+
+function parseColumnAlias(rest: string): string | undefined | null {
+  const trimmed = rest.trim();
+  if (!trimmed) return undefined;
+  const asMatch = trimmed.match(/^AS\s+/i);
+  const aliasText = asMatch ? trimmed.slice(asMatch[0].length).trim() : trimmed;
+  const alias = readIdentifier(aliasText, 0);
+  if (!alias || alias.end !== aliasText.length) return null;
+  return alias.value;
+}
+
+function isSelectStar(body: string, alias: string | undefined): boolean {
+  const trimmed = body.trim();
+  if (trimmed === "*") return true;
+  if (!alias) return false;
+  return new RegExp(`^${escapeRegExp(alias)}\\s*\\.\\s*\\*$`, "i").test(trimmed);
+}
+
+function parseFromSources(body: string): EditableQuerySource[] {
+  if (!body || /[()]/.test(body)) return [];
+  const sources: EditableQuerySource[] = [];
+  let pos = 0;
+  const first = parseTableSourceAt(body, pos, sources.length);
+  if (!first) return [];
+  sources.push(first.source);
+  pos = first.end;
+
+  while (pos < body.length) {
+    pos = skipWhitespace(body, pos);
+    if (pos >= body.length) break;
+    if (body[pos] === ",") {
+      const next = parseTableSourceAt(body, pos + 1, sources.length);
+      if (!next) return [];
+      sources.push(next.source);
+      pos = next.end;
+      continue;
+    }
+    const joinIndex = findTopLevelKeyword(body, "JOIN", pos);
+    if (joinIndex < 0) break;
+    const next = parseTableSourceAt(body, joinIndex + "JOIN".length, sources.length);
+    if (!next) return [];
+    sources.push(next.source);
+    pos = next.end;
+  }
+
+  return sources;
+}
+
+function parseTableSourceAt(text: string, start: number, index: number): { source: EditableQuerySource; end: number } | null {
+  const pos = skipWhitespace(text, start);
+  if (text[pos] === "'" || text[pos] === "(") return null;
+  const ident = parseQualifiedIdentifier(text.slice(pos));
+  if (!ident || ident.parts.length < 1 || ident.parts.length > 3) return null;
+  if (ident.rest.trimStart().startsWith("(")) return null;
+
+  let end = pos + ident.end;
+  let alias: string | undefined;
+  let tailPos = skipWhitespace(text, end);
+  if (startsWithKeyword(text, tailPos, "AS")) {
+    const aliasIdent = readIdentifier(text, tailPos + 2);
+    if (!aliasIdent) return null;
+    alias = aliasIdent.value;
+    end = aliasIdent.end;
+    tailPos = skipWhitespace(text, end);
+  } else if (!tableSourceTerminatorAt(text, tailPos)) {
+    const aliasIdent = readIdentifier(text, tailPos);
+    if (!aliasIdent) return null;
+    alias = aliasIdent.value;
+    end = aliasIdent.end;
+  }
+
+  const tableName = ident.parts[ident.parts.length - 1]!;
+  const tableNameQuoted = ident.quoted[ident.quoted.length - 1];
+  const schema = ident.parts.length >= 2 ? ident.parts[ident.parts.length - 2] : undefined;
+  const schemaQuoted = ident.parts.length >= 2 ? ident.quoted[ident.quoted.length - 2] : false;
+  const catalog = ident.parts.length === 3 ? ident.parts[0] : undefined;
+  const catalogQuoted = ident.parts.length === 3 ? ident.quoted[0] : false;
+  return {
+    source: {
+      key: `${alias ?? tableName}:${index}`,
+      ...(catalog ? { catalog, catalogQuoted } : {}),
+      schema,
+      schemaQuoted,
+      tableName,
+      tableNameQuoted,
+      alias,
+    },
+    end,
+  };
+}
+
+function isExternalFromSource(body: string): boolean {
+  const trimmed = body.trim();
+  return /^'(?:''|[^'])*'(?:\s+(?:AS\s+)?[A-Za-z_][\w$]*)?$/i.test(trimmed) || /^[A-Za-z_][\w$]*\s*\(/.test(trimmed);
+}
+
+function tableSourceTerminatorAt(text: string, pos: number): boolean {
+  if (pos >= text.length) return true;
+  if (text[pos] === ",") return true;
+  return ["ON", "USING", "JOIN", "LEFT", "RIGHT", "INNER", "FULL", "CROSS", "OUTER", "NATURAL"].some((keyword) => startsWithKeyword(text, pos, keyword));
+}
+
+function startsWithKeyword(text: string, pos: number, keyword: string): boolean {
+  const start = skipWhitespace(text, pos);
+  if (text.slice(start, start + keyword.length).toUpperCase() !== keyword) return false;
+  const before = start === 0 ? "" : text[start - 1];
+  const after = text[start + keyword.length] ?? "";
+  return !isIdentifierChar(before) && !isIdentifierChar(after);
+}
+
+function sourceKeyForQualifier(sources: EditableQuerySource[] | undefined, qualifier: string): string | undefined {
+  if (!sources?.length) return undefined;
+  const normalizedQualifier = qualifier.toLowerCase();
+  const matches = sources.filter((source) => (source.alias ?? source.tableName).toLowerCase() === normalizedQualifier || source.tableName.toLowerCase() === normalizedQualifier);
+  return matches.length === 1 ? matches[0]!.key : undefined;
+}
+
+function parseQualifiedIdentifier(text: string): { parts: string[]; quoted: boolean[]; end: number; rest: string; done: boolean } | null {
+  const parts: string[] = [];
+  const quoted: boolean[] = [];
+  let pos = 0;
+  while (pos < text.length) {
+    pos = skipWhitespace(text, pos);
+    const ident = readIdentifier(text, pos);
+    if (!ident) break;
+    parts.push(ident.value);
+    quoted.push(ident.quoted);
+    pos = skipWhitespace(text, ident.end);
+    if (text[pos] !== ".") break;
+    pos++;
+  }
+  if (parts.length === 0) return null;
+  return { parts, quoted, end: pos, rest: text.slice(pos), done: text.slice(pos).trim() === "" };
+}
+
+function readIdentifier(text: string, start: number): { value: string; quoted: boolean; end: number } | null {
+  const pos = skipWhitespace(text, start);
+  const quote = text[pos];
+  if (quote === '"' || quote === "`" || quote === "[") {
+    const close = quote === "[" ? "]" : quote;
+    let value = "";
+    for (let i = pos + 1; i < text.length; i++) {
+      if (text[i] === close) return { value, quoted: true, end: i + 1 };
+      value += text[i];
+    }
+    return null;
+  }
+  const match = text.slice(pos).match(/^[A-Za-z_][\w$]*/);
+  return match ? { value: match[0], quoted: false, end: pos + match[0].length } : null;
+}
+
+function skipWhitespace(text: string, pos: number): number {
+  while (pos < text.length && /\s/.test(text[pos])) pos++;
+  return pos;
+}
+
+function stripSqlComments(sql: string): string {
+  return sql.replace(/--.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+
+function hasTopLevelKeyword(sql: string, keywords: string[]): boolean {
+  return keywords.some((keyword) => findTopLevelKeyword(sql, keyword, 0) >= 0);
+}
+
+function firstTopLevelKeywordIndex(sql: string, keywords: string[], start: number): number {
+  const indexes = keywords.map((keyword) => findTopLevelKeyword(sql, keyword, start)).filter((index) => index >= 0);
+  return indexes.length ? Math.min(...indexes) : -1;
+}
+
+function findTopLevelKeyword(sql: string, keyword: string, start: number): number {
+  let depth = 0;
+  let quote: string | null = null;
+  const upperKeyword = keyword.toUpperCase();
+  for (let i = start; i < sql.length; i++) {
+    const ch = sql[i];
+    if (quote) {
+      if (ch === quote || (quote === "]" && ch === "]")) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "[") {
+      quote = "]";
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      continue;
+    }
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (depth !== 0) continue;
+    if (sql.slice(i, i + keyword.length).toUpperCase() !== upperKeyword) continue;
+    const before = i === 0 ? "" : sql[i - 1];
+    const after = sql[i + keyword.length] ?? "";
+    if (!isIdentifierChar(before) && !isIdentifierChar(after)) return i;
+  }
+  return -1;
+}
+
+function isIdentifierChar(ch: string): boolean {
+  return /[\w$]/.test(ch);
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Check if all primary key columns are present in the result set columns.
+ * Comparison is case-insensitive.
+ */
+export function allPrimaryKeysPresent(primaryKeys: string[], resultColumns: string[], analysis?: EditableQueryInfo, sourceKey?: string): boolean {
+  if (analysis && !analysis.selectStar) {
+    const sourceColumns = new Set(
+      analysis.columns.flatMap((column) => {
+        if (!column.sourceName) return [];
+        if (sourceKey && column.sourceKey !== sourceKey) return [];
+        return [column.sourceName.toLowerCase()];
+      }),
+    );
+    return primaryKeys.every((pk) => sourceColumns.has(pk.toLowerCase()));
+  }
+  const colSet = new Set(resultColumns.map((c) => c.toLowerCase()));
+  return primaryKeys.every((pk) => colSet.has(pk.toLowerCase()));
+}
+
+function matchColumnsForResult(analysis: EditableQueryInfo, resultColumns: string[]): EditableQueryColumn[] | undefined {
+  const matches: EditableQueryColumn[] = [];
+  let searchFrom = 0;
+  for (const resultColumn of resultColumns) {
+    const normalized = resultColumn.toLowerCase();
+    let matchIndex = -1;
+    for (let index = searchFrom; index < analysis.columns.length; index++) {
+      if (analysis.columns[index]!.resultName.toLowerCase() === normalized) {
+        matchIndex = index;
+        break;
+      }
+    }
+    if (matchIndex < 0) return undefined;
+    matches.push(analysis.columns[matchIndex]!);
+    searchFrom = matchIndex + 1;
+  }
+  return matches;
+}
+
+export function allEditableColumnsWriteable(analysis: EditableQueryInfo, resultColumns: string[], sourceKey?: string): boolean {
+  if (analysis.selectStar) return true;
+  const matchedColumns = matchColumnsForResult(analysis, resultColumns);
+  return !!matchedColumns && matchedColumns.every((source) => !sourceKey || !source.sourceName || source.sourceKey === sourceKey);
+}
+
+export function sourceColumnsForResult(analysis: EditableQueryInfo, resultColumns: string[], sourceKey?: string): Array<string | undefined> | undefined {
+  if (analysis.selectStar) return undefined;
+  const matchedColumns = matchColumnsForResult(analysis, resultColumns);
+  if (!matchedColumns) return undefined;
+  return matchedColumns.map((column) => {
+    if (sourceKey && column.sourceKey !== sourceKey) return undefined;
+    return column.sourceName;
+  });
+}
diff --git a/apps/desktop/src/lib/sql/sqlCompletion.ts b/apps/desktop/src/lib/sql/sqlCompletion.ts
new file mode 100644
index 0000000..ddaf87e
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlCompletion.ts
@@ -0,0 +1,4067 @@
+import { Cassandra, MariaSQL, MSSQL, MySQL, PLSQL, PostgreSQL, SQLite, StandardSQL } from "@codemirror/lang-sql";
+import type { DatabaseType, SqlSnippet } from "@/types/database";
+import { buildMongoCompletionItemsFromContext, type MongoCompletionItem } from "@/lib/mongo/mongoCompletion";
+import { CLOUDFLARE_D1_COMMON_FUNCTION_NAMES } from "@/lib/sql/cloudflareD1";
+
+const SQL_KEYWORDS = [
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "JOIN",
+  "LEFT",
+  "RIGHT",
+  "INNER",
+  "OUTER",
+  "ON",
+  "GROUP BY",
+  "ORDER BY",
+  "ASC",
+  "DESC",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "INSERT",
+  "INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "DELETE",
+  "CREATE",
+  "TABLE",
+  "VIEW",
+  "AS",
+  "AND",
+  "OR",
+  "NOT",
+  "IN",
+  "IS",
+  "NULL",
+  "LIKE",
+  "DISTINCT",
+  "UNION",
+  "ALL",
+  "EXISTS",
+  "BETWEEN",
+  "CASE",
+  "WHEN",
+  "THEN",
+  "ELSE",
+  "END",
+  "IF",
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MIN",
+  "MAX",
+  "IIF",
+  "CHOOSE",
+  "COALESCE",
+  "CAST",
+  "ALTER",
+  "DROP",
+  "ADD",
+  "COLUMN",
+  "INDEX",
+  "PRIMARY",
+  "KEY",
+  "FOREIGN",
+  "REFERENCES",
+  "CONSTRAINT",
+  "DEFAULT",
+  "CHECK",
+  "UNIQUE",
+  "BEGIN",
+  "COMMIT",
+  "ROLLBACK",
+  "TRUNCATE",
+  "EXPLAIN",
+  "ANALYZE",
+  "WITH",
+  "RECURSIVE",
+  "OVER",
+  "PARTITION BY",
+  "ROW_NUMBER",
+  "RANK",
+  "DENSE_RANK",
+  "LAG",
+  "LEAD",
+  "FIRST_VALUE",
+  "LAST_VALUE",
+  "NTILE",
+  "CROSS",
+  "APPLY",
+  "CROSS APPLY",
+  "OUTER APPLY",
+  "ISJSON",
+  "JSON_ARRAY",
+  "JSON_ARRAYAGG",
+  "JSON_ARRAY_APPEND",
+  "JSON_ARRAY_INSERT",
+  "JSON_CONTAINS",
+  "JSON_CONTAINS_PATH",
+  "JSON_DEPTH",
+  "JSON_EXTRACT",
+  "JSON_INSERT",
+  "JSON_KEYS",
+  "JSON_LENGTH",
+  "JSON_MERGE_PATCH",
+  "JSON_MERGE_PRESERVE",
+  "JSON_MODIFY",
+  "JSON_OBJECT",
+  "JSON_OBJECTAGG",
+  "JSON_OVERLAPS",
+  "JSON_PATH_EXISTS",
+  "JSON_PRETTY",
+  "JSON_QUERY",
+  "JSON_QUOTE",
+  "JSON_REMOVE",
+  "JSON_REPLACE",
+  "JSON_SCHEMA_VALID",
+  "JSON_SEARCH",
+  "JSON_SET",
+  "JSON_STORAGE_FREE",
+  "JSON_STORAGE_SIZE",
+  "JSON_TABLE",
+  "JSON_TYPE",
+  "JSON_UNQUOTE",
+  "JSON_VALID",
+  "JSON_VALUE",
+  "OPENJSON",
+  "OPENXML",
+  "OPENROWSET",
+  "FULL",
+  "NATURAL",
+  "USING",
+  "LATERAL",
+  "UNNEST",
+  "FILTER",
+  "EXCLUDE",
+  "REPLACE",
+  "QUALIFY",
+  "PIVOT",
+  "UNPIVOT",
+  "ASOF",
+  "POSITIONAL",
+  "ANTI",
+  "SEMI",
+  "SAMPLE",
+  "TABLESAMPLE",
+  "STRUCT",
+  "MAP",
+  "LIST",
+  "ARRAY",
+  "LAMBDA",
+  "LIST_TRANSFORM",
+  "READ_CSV",
+  "READ_PARQUET",
+  "READ_JSON",
+  "COPY",
+  "EXPORT",
+  "IMPORT",
+  "DESCRIBE",
+  "SHOW",
+  "SUMMARIZE",
+  "PRAGMA",
+  "BIGINT",
+  "BINARY",
+  "BIT",
+  "CHAR",
+  "DATE",
+  "DATETIME",
+  "DATETIME2",
+  "DATETIMEOFFSET",
+  "DECIMAL",
+  "FLOAT",
+  "IMAGE",
+  "INT",
+  "MONEY",
+  "NCHAR",
+  "NTEXT",
+  "NUMERIC",
+  "NVARCHAR",
+  "REAL",
+  "SMALLDATETIME",
+  "SMALLINT",
+  "SMALLMONEY",
+  "TEXT",
+  "TIME",
+  "TIMESTAMP",
+  "TINYINT",
+  "UNIQUEIDENTIFIER",
+  "VARBINARY",
+  "VARCHAR",
+  "XML",
+  // Common built-in functions
+  "ABS",
+  "CEIL",
+  "CEILING",
+  "FLOOR",
+  "ROUND",
+  "MOD",
+  "POWER",
+  "SQRT",
+  "SIGN",
+  "TRUNCATE",
+  "CONCAT",
+  "CONCAT_WS",
+  "LENGTH",
+  "CHAR_LENGTH",
+  "UPPER",
+  "LOWER",
+  "TRIM",
+  "LTRIM",
+  "RTRIM",
+  "SUBSTRING",
+  "SUBSTR",
+  "INSTR",
+  "LOCATE",
+  "LPAD",
+  "RPAD",
+  "REVERSE",
+  "REPEAT",
+  "SPACE",
+  "FORMAT",
+  "HEX",
+  "UNHEX",
+  "NOW",
+  "CURDATE",
+  "CURTIME",
+  "DATE_ADD",
+  "DATE_SUB",
+  "DATE_FORMAT",
+  "DATEDIFF",
+  "TIMESTAMPDIFF",
+  "EXTRACT",
+  "YEAR",
+  "MONTH",
+  "DAY",
+  "HOUR",
+  "MINUTE",
+  "SECOND",
+  "DAYOFWEEK",
+  "DAYOFYEAR",
+  "LAST_DAY",
+  "STR_TO_DATE",
+  "CONVERT",
+  "IFNULL",
+  "NULLIF",
+  "GREATEST",
+  "LEAST",
+  "GROUP_CONCAT",
+  "FIND_IN_SET",
+  "FIELD",
+  "ELT",
+  "REGEXP",
+  "REGEXP_LIKE",
+  "REGEXP_REPLACE",
+  "REGEXP_SUBSTR",
+  "UUID",
+  "MD5",
+  "SHA1",
+  "SHA2",
+  "CRC32",
+];
+
+const COMMON_SQL_KEYWORDS = [
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "JOIN",
+  "LEFT",
+  "RIGHT",
+  "INNER",
+  "OUTER",
+  "ON",
+  "GROUP BY",
+  "ORDER BY",
+  "ASC",
+  "DESC",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "INSERT",
+  "INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "DELETE",
+  "CREATE",
+  "TABLE",
+  "VIEW",
+  "AS",
+  "AND",
+  "OR",
+  "NOT",
+  "IN",
+  "IS",
+  "NULL",
+  "LIKE",
+  "DISTINCT",
+  "UNION",
+  "ALL",
+  "EXISTS",
+  "BETWEEN",
+  "CASE",
+  "WHEN",
+  "THEN",
+  "ELSE",
+  "END",
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MIN",
+  "MAX",
+  "COALESCE",
+  "CAST",
+  "ALTER",
+  "DROP",
+  "ADD",
+  "COLUMN",
+  "INDEX",
+  "PRIMARY",
+  "KEY",
+  "FOREIGN",
+  "REFERENCES",
+  "CONSTRAINT",
+  "DEFAULT",
+  "CHECK",
+  "UNIQUE",
+  "BEGIN",
+  "COMMIT",
+  "ROLLBACK",
+  "TRUNCATE",
+  "EXPLAIN",
+  "ANALYZE",
+  "WITH",
+  "RECURSIVE",
+  "OVER",
+  "PARTITION BY",
+  "ROW_NUMBER",
+  "RANK",
+  "DENSE_RANK",
+  "LAG",
+  "LEAD",
+  "FIRST_VALUE",
+  "LAST_VALUE",
+  "NTILE",
+  "BIGINT",
+  "BINARY",
+  "BIT",
+  "CHAR",
+  "DATE",
+  "DECIMAL",
+  "FLOAT",
+  "INT",
+  "NUMERIC",
+  "REAL",
+  "SMALLINT",
+  "TEXT",
+  "TIME",
+  "TIMESTAMP",
+  "VARCHAR",
+];
+
+const POSTGRES_SQL_KEYWORDS = [
+  "BIGSERIAL",
+  "JSON",
+  "JSONB",
+  "SMALLSERIAL",
+  "SERIAL",
+  "UUID",
+  "INET",
+  "CIDR",
+  "MACADDR",
+  "MACADDR8",
+  "TSVECTOR",
+  "TSQUERY",
+  "BYTEA",
+  "BOOLEAN",
+  "RETURNING",
+  "ILIKE",
+  "SIMILAR TO",
+  "ON CONFLICT",
+  "DO NOTHING",
+  "DO UPDATE",
+  "GENERATED",
+  "IDENTITY",
+  "MATERIALIZED",
+  "VACUUM",
+  "ARRAY_AGG",
+  "JSONB_BUILD_OBJECT",
+  "JSONB_AGG",
+  "TO_JSONB",
+  "CURRENT_TIMESTAMP",
+];
+
+const MYSQL_SQL_KEYWORDS = [
+  "AUTO_INCREMENT",
+  "UNSIGNED",
+  "ZEROFILL",
+  "ENGINE",
+  "CHARSET",
+  "COLLATE",
+  "ENUM",
+  "JSON",
+  "BOOL",
+  "BOOLEAN",
+  "TINYTEXT",
+  "MEDIUMTEXT",
+  "LONGTEXT",
+  "TINYBLOB",
+  "MEDIUMBLOB",
+  "LONGBLOB",
+  "SHOW",
+  "DESCRIBE",
+  "REPLACE",
+  "DUPLICATE KEY",
+  "JSON_EXTRACT",
+  "JSON_UNQUOTE",
+  "DATE_FORMAT",
+];
+
+const MANTICORESEARCH_SQL_KEYWORDS = ["FACET", "MATCH", "SHOW", "SHOW META", "SHOW TABLES", "CALL", "CALL PQ", "PQ", "META", "TABLES", "OPTION", "WITHIN GROUP ORDER BY"];
+
+const SQLITE_SQL_KEYWORDS = ["AUTOINCREMENT", "INTEGER", "BLOB", "BOOLEAN", "WITHOUT ROWID", "VACUUM", "PRAGMA", "JSON_EXTRACT", "JSON_SET", "STRFTIME"];
+
+const SQLSERVER_SQL_KEYWORDS = [
+  "TOP",
+  "IDENTITY",
+  "IDENTITY_INSERT",
+  "UNIQUEIDENTIFIER",
+  "NVARCHAR",
+  "DATETIME2",
+  "DATETIMEOFFSET",
+  "BIT",
+  "GO",
+  "MERGE",
+  "OUTPUT",
+  "TRY_CAST",
+  "TRY_CONVERT",
+  "OPENJSON",
+  "JSON_VALUE",
+  "JSON_QUERY",
+  "NOCOUNT",
+  "XACT_ABORT",
+  "ANSI_NULLS",
+  "ANSI_PADDING",
+  "ANSI_WARNINGS",
+  "ANSI_DEFAULTS",
+  "ARITHABORT",
+  "ARITHIGNORE",
+  "QUOTED_IDENTIFIER",
+  "IMPLICIT_TRANSACTIONS",
+  "TRANSACTION ISOLATION LEVEL",
+  "DATEFIRST",
+  "DATEFORMAT",
+  "DEADLOCK_PRIORITY",
+  "LOCK_TIMEOUT",
+  "ROWCOUNT",
+  "TEXTSIZE",
+  "STATISTICS IO",
+  "STATISTICS TIME",
+  "STATISTICS XML",
+  "SHOWPLAN_ALL",
+  "SHOWPLAN_TEXT",
+  "SHOWPLAN_XML",
+];
+
+const DATABASE_SQL_KEYWORDS: Partial<Record<DatabaseType, string[]>> = {
+  mysql: MYSQL_SQL_KEYWORDS,
+  postgres: POSTGRES_SQL_KEYWORDS,
+  sqlite: SQLITE_SQL_KEYWORDS,
+  rqlite: SQLITE_SQL_KEYWORDS,
+  turso: SQLITE_SQL_KEYWORDS,
+  "cloudflare-d1": SQLITE_SQL_KEYWORDS,
+  sqlserver: SQLSERVER_SQL_KEYWORDS,
+  manticoresearch: MANTICORESEARCH_SQL_KEYWORDS,
+};
+
+// Keywords that appear in nearly every SQL query — boosted so frequency beats length tie-breaking.
+// E.g. typing "WH" should rank WHERE (high frequency) above WHEN (CASE-only).
+const HIGH_FREQUENCY_KEYWORDS = new Set([
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "AND",
+  "OR",
+  "JOIN",
+  "ON",
+  "IN",
+  "AS",
+  "GROUP BY",
+  "ORDER BY",
+  "LEFT",
+  "RIGHT",
+  "INNER",
+  "OUTER",
+  "INSERT",
+  "INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "DELETE",
+  "NOT",
+  "NULL",
+  "IS",
+  "LIKE",
+  "DISTINCT",
+  "HAVING",
+  "LIMIT",
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MAX",
+  "MIN",
+  "CASE",
+  "UNION",
+  "ALL",
+  "ASC",
+  "DESC",
+  "BETWEEN",
+  "EXISTS",
+]);
+
+const TABLE_TRIGGER_KEYWORDS = new Set(["from", "join", "update", "into", "table", "describe", "explain", "apply"]);
+const EXCLUSIVE_TABLE_TRIGGER_KEYWORDS = new Set(["from", "join", "update", "into", "apply"]);
+const JOIN_MODIFIERS = new Set(["left", "right", "inner", "outer", "cross", "full", "natural"]);
+const JOIN_MODIFIER_KEYWORD_PHRASES = ["LEFT JOIN", "RIGHT JOIN", "INNER JOIN", "FULL JOIN", "CROSS JOIN", "NATURAL JOIN", "LEFT OUTER JOIN", "RIGHT OUTER JOIN", "FULL OUTER JOIN"];
+const MAX_TABLE_COMPLETION_ITEMS = 200;
+const EXACT_LABEL_MATCH_BOOST = 10000;
+
+// Keywords that only make sense in DDL / statement-start contexts (not inside SELECT/INSERT/UPDATE/DELETE)
+const DDL_ONLY_KEYWORDS = new Set([
+  "CREATE",
+  "ALTER",
+  "DROP",
+  "TABLE",
+  "VIEW",
+  "INDEX",
+  "COLUMN",
+  "ADD",
+  "CONSTRAINT",
+  "PRIMARY",
+  "KEY",
+  "FOREIGN",
+  "REFERENCES",
+  "DEFAULT",
+  "CHECK",
+  "UNIQUE",
+  "BEGIN",
+  "COMMIT",
+  "ROLLBACK",
+  "TRUNCATE",
+  "EXPLAIN",
+  "DESCRIBE",
+  "SHOW",
+  "SUMMARIZE",
+  "PRAGMA",
+  "COPY",
+  "EXPORT",
+  "IMPORT",
+  "IF",
+]);
+
+// Data type keywords — only relevant in DDL (CREATE/ALTER TABLE)
+const DATA_TYPE_KEYWORDS = new Set([
+  "BIGINT",
+  "BINARY",
+  "BIT",
+  "CHAR",
+  "DATE",
+  "DATETIME",
+  "DATETIME2",
+  "DATETIMEOFFSET",
+  "DECIMAL",
+  "FLOAT",
+  "IMAGE",
+  "INT",
+  "MONEY",
+  "NCHAR",
+  "NTEXT",
+  "NUMERIC",
+  "NVARCHAR",
+  "REAL",
+  "SMALLDATETIME",
+  "SMALLINT",
+  "SMALLMONEY",
+  "TEXT",
+  "TIME",
+  "TIMESTAMP",
+  "TINYINT",
+  "UNIQUEIDENTIFIER",
+  "VARBINARY",
+  "VARCHAR",
+  "XML",
+  "JSON",
+  "JSONB",
+  "UUID",
+  "SERIAL",
+  "BIGSERIAL",
+  "SMALLSERIAL",
+  "BYTEA",
+  "BOOLEAN",
+  "BOOL",
+  "INET",
+  "CIDR",
+  "MACADDR",
+  "MACADDR8",
+  "TSVECTOR",
+  "TSQUERY",
+  "ENUM",
+  "TINYTEXT",
+  "MEDIUMTEXT",
+  "LONGTEXT",
+  "TINYBLOB",
+  "MEDIUMBLOB",
+  "LONGBLOB",
+]);
+
+// Window functions that should use OVER() completion
+const WINDOW_FUNCTIONS = new Set(["ROW_NUMBER", "RANK", "DENSE_RANK", "LAG", "LEAD", "FIRST_VALUE", "LAST_VALUE", "NTILE"]);
+
+function getFunctionDescriptions(t?: SqlCompletionTranslations): Map<string, string> {
+  const d = t?.functionDescriptions ?? {};
+  return new Map<string, string>([
+    ["COUNT", d.COUNT || "Returns the number of rows"],
+    ["SUM", d.SUM || "Returns the sum of a numeric column"],
+    ["AVG", d.AVG || "Returns the average of a numeric column"],
+    ["MIN", d.MIN || "Returns the minimum value"],
+    ["MAX", d.MAX || "Returns the maximum value"],
+    ["GROUP_CONCAT", d.GROUP_CONCAT || "Concatenates group values into a string"],
+    ["STRING_AGG", d.STRING_AGG || "Concatenates strings in a group"],
+    ["CONCAT", d.CONCAT || "Concatenates multiple strings"],
+    ["CONCAT_WS", d.CONCAT_WS || "Concatenates strings with a separator"],
+    ["SUBSTRING", d.SUBSTRING || "Extracts a substring"],
+    ["REPLACE", d.REPLACE || "Replaces content in a string"],
+    ["TRIM", d.TRIM || "Removes leading and trailing spaces"],
+    ["UPPER", d.UPPER || "Converts to uppercase"],
+    ["LOWER", d.LOWER || "Converts to lowercase"],
+    ["LENGTH", d.LENGTH || "Returns string length"],
+    ["REGEXP_REPLACE", d.REGEXP_REPLACE || "Replaces using a regular expression"],
+    ["DATE_FORMAT", d.DATE_FORMAT || "Formats a date with a pattern"],
+    ["DATEDIFF", d.DATEDIFF || "Calculates the difference between two dates"],
+    ["DATE_ADD", d.DATE_ADD || "Adds to a date"],
+    ["DATE_SUB", d.DATE_SUB || "Subtracts from a date"],
+    ["EXTRACT", d.EXTRACT || "Extracts a part from a date"],
+    ["NOW", d.NOW || "Returns the current date and time"],
+    ["ROUND", d.ROUND || "Rounds to the specified precision"],
+    ["FLOOR", d.FLOOR || "Rounds down"],
+    ["CEIL", d.CEIL || "Rounds up"],
+    ["ABS", d.ABS || "Returns the absolute value"],
+    ["MOD", d.MOD || "Returns the remainder"],
+    ["COALESCE", d.COALESCE || "Returns the first non-NULL argument"],
+    ["IFNULL", d.IFNULL || "Returns an alternate value when NULL"],
+    ["NULLIF", d.NULLIF || "Returns NULL when values are equal"],
+    ["CAST", d.CAST || "Converts an expression to a specified type"],
+    ["JSON_EXTRACT", d.JSON_EXTRACT || "Extracts a value from JSON"],
+    ["JSON_VALUE", d.JSON_VALUE || "Extracts a scalar value from JSON"],
+    ["JSON_OBJECT", d.JSON_OBJECT || "Creates a JSON object"],
+    ["JSON_ARRAY", d.JSON_ARRAY || "Creates a JSON array"],
+  ]);
+}
+
+export const DEFAULT_SQL_SNIPPETS: SqlSnippet[] = [
+  {
+    id: "builtin-sel",
+    label: "select *",
+    prefix: "sel",
+    body: "SELECT *\nFROM table\nLIMIT 100;",
+    enabled: true,
+  },
+  {
+    id: "builtin-ins",
+    label: "insert into",
+    prefix: "ins",
+    body: "INSERT INTO table (columns)\nVALUES (values);",
+    enabled: true,
+  },
+  {
+    id: "builtin-upd",
+    label: "update set",
+    prefix: "upd",
+    body: "UPDATE table\nSET column = value\nWHERE condition;",
+    enabled: true,
+  },
+  {
+    id: "builtin-cte",
+    label: "common table expression",
+    prefix: "cte",
+    body: "WITH name AS (\n  SELECT columns\n  FROM table\n)\nSELECT *\nFROM name;",
+    enabled: true,
+  },
+  {
+    id: "builtin-join",
+    label: "join",
+    prefix: "join",
+    body: "JOIN table ON left_column = right_column",
+    enabled: true,
+  },
+  {
+    id: "builtin-case",
+    label: "case when",
+    prefix: "case",
+    body: "CASE\n  WHEN condition THEN value\n  ELSE default\nEND",
+    enabled: true,
+  },
+  {
+    id: "builtin-ct",
+    label: "create table",
+    prefix: "ct",
+    body: "CREATE TABLE table (\n  column type\n);",
+    enabled: true,
+  },
+  {
+    id: "builtin-ex",
+    label: "exists",
+    prefix: "ex",
+    body: "EXISTS (\n  SELECT 1\n  FROM table\n  WHERE condition\n)",
+    enabled: true,
+  },
+  {
+    id: "builtin-nex",
+    label: "not exists",
+    prefix: "nex",
+    body: "NOT EXISTS (\n  SELECT 1\n  FROM table\n  WHERE condition\n)",
+    enabled: true,
+  },
+  {
+    id: "builtin-at",
+    label: "alter table add column",
+    prefix: "at",
+    body: "ALTER TABLE table\nADD COLUMN column type;",
+    enabled: true,
+  },
+  {
+    id: "builtin-ci",
+    label: "create index",
+    prefix: "ci",
+    body: "CREATE INDEX idx_name\nON table (column);",
+    enabled: true,
+  },
+];
+
+const MANTICORESEARCH_SQL_SNIPPETS: SqlSnippet[] = [
+  {
+    id: "builtin-manticore-match",
+    label: "match query",
+    prefix: "match",
+    body: "MATCH('query')",
+  },
+  {
+    id: "builtin-manticore-facet",
+    label: "facet",
+    prefix: "facet",
+    body: "FACET column",
+  },
+  {
+    id: "builtin-manticore-show-meta",
+    label: "show meta",
+    prefix: "m",
+    body: "SHOW META;",
+  },
+  {
+    id: "builtin-manticore-show-tables",
+    label: "show tables",
+    prefix: "tab",
+    body: "SHOW TABLES;",
+  },
+  {
+    id: "builtin-manticore-call-pq",
+    label: "call pq",
+    prefix: "p",
+    body: "CALL PQ ('pq', ('{\"title\":\"query\"}'));",
+  },
+];
+
+const SQL_FUNCTION_SIGNATURES = new Map<string, string[]>([
+  // Aggregate
+  ["COUNT", ["expression"]],
+  ["SUM", ["expression"]],
+  ["AVG", ["expression"]],
+  ["MIN", ["expression"]],
+  ["MAX", ["expression"]],
+  ["GROUP_CONCAT", ["expression", "separator"]],
+  ["STRING_AGG", ["expression", "separator"]],
+  ["ARRAY_AGG", ["expression"]],
+  // String
+  ["CONCAT", ["value", "...values"]],
+  ["CONCAT_WS", ["separator", "...values"]],
+  ["SUBSTRING", ["string", "start", "length"]],
+  ["SUBSTR", ["string", "start", "length"]],
+  ["REPLACE", ["string", "old", "new"]],
+  ["TRIM", ["string"]],
+  ["LTRIM", ["string"]],
+  ["RTRIM", ["string"]],
+  ["UPPER", ["string"]],
+  ["LOWER", ["string"]],
+  ["LENGTH", ["string"]],
+  ["LPAD", ["string", "length", "pad"]],
+  ["RPAD", ["string", "length", "pad"]],
+  ["INSTR", ["string", "substring"]],
+  ["LOCATE", ["substring", "string"]],
+  ["REVERSE", ["string"]],
+  ["REPEAT", ["string", "count"]],
+  ["SPACE", ["count"]],
+  ["FORMAT", ["number", "decimals"]],
+  ["REGEXP_REPLACE", ["string", "pattern", "replacement"]],
+  ["REGEXP_SUBSTR", ["string", "pattern"]],
+  ["SPLIT_PART", ["string", "delimiter", "part"]],
+  // Date / Time
+  ["DATE_FORMAT", ["date", "format"]],
+  ["DATEDIFF", ["date1", "date2"]],
+  ["TIMESTAMPDIFF", ["unit", "datetime_expr1", "datetime_expr2"]],
+  ["DATE_ADD", ["date", "interval"]],
+  ["DATE_SUB", ["date", "interval"]],
+  ["EXTRACT", ["unit", "date"]],
+  ["YEAR", ["date"]],
+  ["MONTH", ["date"]],
+  ["DAY", ["date"]],
+  ["HOUR", ["datetime"]],
+  ["MINUTE", ["datetime"]],
+  ["SECOND", ["datetime"]],
+  ["DAYOFWEEK", ["date"]],
+  ["DAYOFYEAR", ["date"]],
+  ["LAST_DAY", ["date"]],
+  ["STR_TO_DATE", ["string", "format"]],
+  ["NOW", []],
+  ["CURDATE", []],
+  ["CURTIME", []],
+  // Numeric
+  ["ROUND", ["number", "decimals"]],
+  ["FLOOR", ["number"]],
+  ["CEIL", ["number"]],
+  ["CEILING", ["number"]],
+  ["ABS", ["number"]],
+  ["MOD", ["dividend", "divisor"]],
+  ["POWER", ["base", "exponent"]],
+  ["SQRT", ["number"]],
+  ["SIGN", ["number"]],
+  ["TRUNCATE", ["number", "decimals"]],
+  ["RAND", []],
+  // Conditional
+  ["COALESCE", ["value", "...values"]],
+  ["IFNULL", ["expression", "fallback"]],
+  ["NULLIF", ["expression1", "expression2"]],
+  ["CAST", ["expression AS type"]],
+  ["CONVERT", ["expression", "type"]],
+  ["GREATEST", ["...values"]],
+  ["LEAST", ["...values"]],
+  ["IIF", ["condition", "true_value", "false_value"]],
+  // Hash / Crypto
+  ["MD5", ["string"]],
+  ["SHA1", ["string"]],
+  ["SHA2", ["string", "bit_length"]],
+  ["UUID", []],
+  // JSON
+  ["JSON_EXTRACT", ["json", "path"]],
+  ["JSON_VALUE", ["json", "path"]],
+  ["JSON_QUERY", ["json", "path"]],
+  ["JSON_OBJECT", ["key", "value", "...pairs"]],
+  ["JSON_ARRAY", ["...values"]],
+  ["JSON_SET", ["json", "path", "value"]],
+  ["JSON_REMOVE", ["json", "path"]],
+  ["JSON_CONTAINS", ["json", "value"]],
+  ["JSON_LENGTH", ["json"]],
+  ["JSON_KEYS", ["json"]],
+  ["JSON_TYPE", ["json"]],
+  ["JSON_PRETTY", ["json"]],
+  ["JSON_VALID", ["json"]],
+  ["JSON_ARRAYAGG", ["expression"]],
+  ["JSON_OBJECTAGG", ["key", "value"]],
+]);
+
+const POSTGRES_FUNCTION_SIGNATURES = new Map<string, string[]>([
+  ["JSONB_BUILD_OBJECT", ["key", "value", "...pairs"]],
+  ["JSONB_AGG", ["expression"]],
+  ["TO_JSONB", ["value"]],
+  ["JSONB_SET", ["target", "path", "new_value"]],
+  ["ARRAY_AGG", ["expression"]],
+  ["STRING_AGG", ["expression", "delimiter"]],
+  ["GEN_RANDOM_UUID", []],
+  ["NOW", []],
+]);
+
+const MYSQL_FUNCTION_SIGNATURES = new Map<string, string[]>([
+  ["DATE_FORMAT", ["date", "format"]],
+  ["JSON_EXTRACT", ["json", "path"]],
+  ["JSON_UNQUOTE", ["json"]],
+  ["GROUP_CONCAT", ["expression"]],
+  ["UUID", []],
+  ["NOW", []],
+]);
+
+const SQLITE_FUNCTION_SIGNATURES = new Map<string, string[]>([
+  ["JSON_EXTRACT", ["json", "path"]],
+  ["JSON_SET", ["json", "path", "value"]],
+  ["STRFTIME", ["format", "time"]],
+  ["IFNULL", ["expression", "fallback"]],
+  ["NOW", []],
+]);
+
+const CLOUDFLARE_D1_FUNCTION_SIGNATURES = new Map(Array.from(SQLITE_FUNCTION_SIGNATURES.entries()).filter(([name]) => name !== "NOW"));
+
+const SQLSERVER_FUNCTION_SIGNATURES = new Map<string, string[]>([
+  ["TRY_CAST", ["expression AS type"]],
+  ["TRY_CONVERT", ["type", "expression"]],
+  ["JSON_VALUE", ["expression", "path"]],
+  ["JSON_QUERY", ["expression", "path"]],
+  ["NEWID", []],
+  ["GETDATE", []],
+  ["GETUTCDATE", []],
+  ["SYSDATETIME", []],
+  ["SYSUTCDATETIME", []],
+  ["DATEADD", ["datepart", "number", "date"]],
+  ["DATEDIFF", ["datepart", "startdate", "enddate"]],
+  ["DATEPART", ["datepart", "date"]],
+  ["DATENAME", ["datepart", "date"]],
+  ["EOMONTH", ["start_date"]],
+  ["CHARINDEX", ["substring", "string"]],
+  ["PATINDEX", ["pattern", "string"]],
+  ["LEN", ["string"]],
+  ["STUFF", ["string", "start", "length", "replace"]],
+  ["ISNULL", ["expression", "replacement"]],
+]);
+
+const MANTICORESEARCH_FUNCTION_SIGNATURES = new Map<string, string[]>([
+  ["MATCH", ["query"]],
+  ["BM25F", ["field=weight", "...fields"]],
+  ["EXIST", ["attribute", "default"]],
+  ["IDF", ["keyword"]],
+  ["PACKEDFACTORS", []],
+  ["QUERY", []],
+  ["REMAP", ["expression", "from_values", "to_values"]],
+  ["SNIPPET", ["field", "query"]],
+  ["WEIGHT", []],
+  ["ZONESPANLIST", []],
+  ["BIGINT", ["expression"]],
+  ["DOUBLE", ["expression"]],
+  ["INTEGER", ["expression"]],
+  ["SINT", ["expression"]],
+  ["TO_STRING", ["expression"]],
+  ["UINT", ["expression"]],
+  ["UINT64", ["expression"]],
+  ["GEODIST", ["lat1", "lon1", "lat2", "lon2"]],
+  ["CONTAINS", ["polygon", "point"]],
+  ["POLY2D", ["...points"]],
+  ["CRC32", ["expression"]],
+  ["FIBONACCI", ["number"]],
+  ["KNN_DIST", []],
+  ["NOW", []],
+  ["DATE_FORMAT", ["timestamp", "format"]],
+  ["DAY", ["timestamp"]],
+  ["MONTH", ["timestamp"]],
+  ["YEAR", ["timestamp"]],
+  ["HOUR", ["timestamp"]],
+  ["MINUTE", ["timestamp"]],
+  ["SECOND", ["timestamp"]],
+]);
+
+const DATABASE_FUNCTION_SIGNATURES: Partial<Record<DatabaseType, Map<string, string[]>>> = {
+  mysql: MYSQL_FUNCTION_SIGNATURES,
+  postgres: POSTGRES_FUNCTION_SIGNATURES,
+  sqlite: SQLITE_FUNCTION_SIGNATURES,
+  rqlite: SQLITE_FUNCTION_SIGNATURES,
+  turso: SQLITE_FUNCTION_SIGNATURES,
+  "cloudflare-d1": CLOUDFLARE_D1_FUNCTION_SIGNATURES,
+  sqlserver: SQLSERVER_FUNCTION_SIGNATURES,
+  manticoresearch: MANTICORESEARCH_FUNCTION_SIGNATURES,
+};
+
+const COMMON_SQL_FUNCTION_NAMES = new Set([
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MIN",
+  "MAX",
+  "CONCAT",
+  "SUBSTRING",
+  "SUBSTR",
+  "REPLACE",
+  "TRIM",
+  "LTRIM",
+  "RTRIM",
+  "UPPER",
+  "LOWER",
+  "LENGTH",
+  "EXTRACT",
+  "ROUND",
+  "FLOOR",
+  "CEIL",
+  "CEILING",
+  "ABS",
+  "MOD",
+  "POWER",
+  "SQRT",
+  "SIGN",
+  "COALESCE",
+  "NULLIF",
+  "CAST",
+  "GREATEST",
+  "LEAST",
+]);
+
+const SQL_ALIAS_RESERVED_WORDS = new Set([
+  "all",
+  "alter",
+  "and",
+  "any",
+  "as",
+  "asc",
+  "begin",
+  "between",
+  "by",
+  "case",
+  "check",
+  "commit",
+  "constraint",
+  "create",
+  "cross",
+  "default",
+  "delete",
+  "desc",
+  "distinct",
+  "drop",
+  "else",
+  "end",
+  "except",
+  "exists",
+  "for",
+  "foreign",
+  "from",
+  "full",
+  "grant",
+  "group",
+  "having",
+  "in",
+  "index",
+  "inner",
+  "insert",
+  "intersect",
+  "into",
+  "is",
+  "join",
+  "left",
+  "like",
+  "limit",
+  "natural",
+  "not",
+  "null",
+  "offset",
+  "on",
+  "or",
+  "order",
+  "outer",
+  "primary",
+  "references",
+  "right",
+  "rollback",
+  "select",
+  "set",
+  "table",
+  "then",
+  "to",
+  "truncate",
+  "union",
+  "unique",
+  "update",
+  "values",
+  "view",
+  "when",
+  "where",
+  "with",
+]);
+
+const SQL_ALIAS_KEYWORD_WORDS = new Set(sqlAliasKeywordWords(SQL_KEYWORDS.join(" "), StandardSQL.spec.keywords, MySQL.spec.keywords, MariaSQL.spec.keywords, PostgreSQL.spec.keywords, MSSQL.spec.keywords, SQLite.spec.keywords, PLSQL.spec.keywords, Cassandra.spec.keywords));
+
+function sqlAliasKeywordWords(...sources: Array<string | undefined>): string[] {
+  return sources
+    .flatMap((source) => (source ?? "").split(/\s+/))
+    .filter((keyword) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(keyword))
+    .map((keyword) => keyword.toLowerCase());
+}
+
+export interface SqlCompletionTable {
+  name: string;
+  schema?: string;
+  type?: "table" | "view";
+}
+
+export interface SqlCompletionObject {
+  name: string;
+  schema?: string;
+  type: "procedure" | "function" | "trigger" | "package";
+  parentSchema?: string;
+  parentName?: string;
+}
+
+export interface SqlCompletionColumn {
+  name: string;
+  table: string;
+  schema?: string;
+  dataType?: string;
+  isNullable?: boolean;
+  comment?: string | null;
+}
+
+export interface SqlCompletionForeignKey {
+  name: string;
+  column: string;
+  ref_schema?: string | null;
+  ref_table: string;
+  ref_column: string;
+}
+
+export interface SqlCompletionItem {
+  label: string;
+  type: "keyword" | "table" | "column" | "snippet" | "function" | "schema";
+  detail?: string;
+  info?: string;
+  apply?: string;
+  boost: number;
+  exactMatch?: boolean;
+}
+
+export type SqlKeywordCase = "preserve" | "upper" | "lower";
+
+export interface SqlCompletionReferencedTable {
+  name: string;
+  schema?: string;
+  alias?: string;
+  columns?: string[];
+}
+
+export type SqlStatementKind = "select" | "insert" | "update" | "delete" | "create" | "alter" | "drop" | "unknown";
+
+export type SqlCompletionContextKind = "table" | "schema" | "catalog" | "routine" | "column" | "alias_column" | "insert_target" | "update_target" | "exec" | "join" | "keyword";
+
+export interface SqlCompletionContext {
+  prefix: string;
+  qualifier?: string;
+  qualifierParts?: string[];
+  suggestTables: boolean;
+  suggestColumns: boolean;
+  suggestKeywords: boolean;
+  suggestRoutines: boolean;
+  suggestJoinConditions: boolean;
+  exclusiveTableSuggestions: boolean;
+  exclusiveColumnSuggestions: boolean;
+  exclusiveRoutineSuggestions: boolean;
+  prioritizeSelectAliases: boolean;
+  selectAliases: string[];
+  referencedTables: SqlCompletionReferencedTable[];
+  insertTable?: string;
+  insertSchema?: string;
+  statementKind: SqlStatementKind;
+  tableTriggerWord?: string;
+  isGroupBy: boolean;
+  nonAggregatedSelectColumns: string[];
+  comparisonLeftColumn?: string;
+  onStar: boolean;
+  selectListColumnContext: boolean;
+  preferredKeywords: string[];
+  updateTarget?: { table: string; schema?: string };
+  deleteTarget?: { table: string; schema?: string };
+  oracleTableFunctionContext?: boolean;
+  autoAliasTableCompletions: boolean;
+  tableAliasAfterCursor?: boolean;
+  contextKind: SqlCompletionContextKind;
+}
+
+export interface SqlFunctionSignatureHelp {
+  name: string;
+  signature: string;
+  activeParameter: number;
+  parameters: string[];
+}
+
+export interface SqlCompletionTranslations {
+  nullValue: string;
+  isNull: string;
+  isNotNull: string;
+  stringLiteral: string;
+  numericLiteral: string;
+  booleanValue: string;
+  starExpansionColumns: string;
+  functionDescriptions: Record<string, string>;
+}
+
+export interface SqlCompletionProviderInput {
+  tables: SqlCompletionTable[];
+  objects?: SqlCompletionObject[];
+  columnsByTable: Map<string, SqlCompletionColumn[]>;
+  foreignKeysByTable?: Map<string, SqlCompletionForeignKey[]>;
+  schemas?: string[];
+  translations?: SqlCompletionTranslations;
+  snippets?: SqlSnippet[];
+  dialect?: "mysql" | "postgres" | "sqlserver";
+  databaseType?: DatabaseType;
+  keywordCase?: SqlKeywordCase;
+  autoAliasTables?: boolean;
+}
+
+export function buildSqlCompletionItems(
+  sql: string,
+  cursor: number,
+  input: {
+    tables: SqlCompletionTable[];
+    objects?: SqlCompletionObject[];
+    columnsByTable: Map<string, SqlCompletionColumn[]>;
+    foreignKeysByTable?: Map<string, SqlCompletionForeignKey[]>;
+    schemas?: string[];
+    translations?: SqlCompletionTranslations;
+    dialect?: "mysql" | "postgres" | "sqlserver";
+    databaseType?: DatabaseType;
+    keywordCase?: SqlKeywordCase;
+    autoAliasTables?: boolean;
+  },
+): SqlCompletionItem[] {
+  if (isSqlCompletionSuppressedContext(sql, cursor)) return [];
+  const context = getSqlCompletionContext(sql, cursor);
+  return buildSqlCompletionItemsFromContext(context, input);
+}
+
+export function buildSqlCompletionItemsFromContext(context: SqlCompletionContext, input: SqlCompletionProviderInput): SqlCompletionItem[] {
+  return new SqlCompletionProvider(context, input).build();
+}
+
+class SqlCompletionProvider {
+  private readonly items: SqlCompletionItem[] = [];
+  private readonly t?: SqlCompletionTranslations;
+  private readonly dialect?: "mysql" | "postgres" | "sqlserver";
+  private readonly databaseType?: DatabaseType;
+
+  constructor(
+    private readonly context: SqlCompletionContext,
+    private readonly input: SqlCompletionProviderInput,
+  ) {
+    this.t = input.translations;
+    this.dialect = input.dialect;
+    this.databaseType = input.databaseType;
+  }
+
+  build(): SqlCompletionItem[] {
+    const { context } = this;
+    const pendingJoinKeyword = isPendingJoinKeywordContext(context);
+
+    if (this.databaseType === "mongodb") {
+      return dedupeAndSort(buildMongoCompletionItemsFromContext({ mode: "root", prefix: context.prefix, from: 0 }).map(mongoCompletionItemToSqlCompletionItem));
+    }
+
+    const preferReferencedColumns = hasMatchingReferencedColumnPrefix(context, this.input.columnsByTable);
+    if (!pendingJoinKeyword && !preferReferencedColumns && !context.exclusiveTableSuggestions && !context.exclusiveColumnSuggestions && !context.exclusiveRoutineSuggestions) {
+      const snippets = this.databaseType === "manticoresearch" ? [...(this.input.snippets ?? DEFAULT_SQL_SNIPPETS), ...MANTICORESEARCH_SQL_SNIPPETS] : (this.input.snippets ?? DEFAULT_SQL_SNIPPETS);
+      this.items.push(...buildSnippetItems(context.prefix, snippets, this.input.keywordCase));
+      this.items.push(...buildFunctionSnippetItems(context.prefix, getFunctionDescriptions(this.t), this.databaseType));
+    }
+
+    if (this.databaseType === "manticoresearch" && context.exclusiveRoutineSuggestions) {
+      this.items.push(
+        ...buildSnippetItems(
+          context.prefix,
+          MANTICORESEARCH_SQL_SNIPPETS.filter((snippet) => snippet.id === "builtin-manticore-call-pq"),
+          this.input.keywordCase,
+        ),
+      );
+    }
+
+    if (context.preferredKeywords.length > 0) {
+      this.items.push(...buildPreferredKeywordItems(context.prefix, context.preferredKeywords, this.input.keywordCase));
+    }
+
+    if (!context.exclusiveTableSuggestions && !context.exclusiveColumnSuggestions && !context.exclusiveRoutineSuggestions && context.prioritizeSelectAliases) {
+      this.items.push(...buildSelectAliasItems(context));
+    }
+
+    if (!context.exclusiveTableSuggestions && !context.exclusiveColumnSuggestions && !context.exclusiveRoutineSuggestions && context.isGroupBy && context.nonAggregatedSelectColumns.length > 0) {
+      this.items.push(...buildNonAggregatedColumnItems(context, this.input.columnsByTable, this.dialect));
+    }
+
+    if (!context.exclusiveTableSuggestions && !context.exclusiveColumnSuggestions && !context.exclusiveRoutineSuggestions && context.suggestJoinConditions) {
+      this.items.push(...buildJoinConditionItems(context, this.input.columnsByTable, this.input.foreignKeysByTable, this.dialect, this.input.keywordCase));
+    }
+
+    if (context.suggestKeywords && !context.exclusiveRoutineSuggestions && !pendingJoinKeyword) {
+      this.items.push(...buildJoinModifierKeywordItems(context.prefix, this.input.keywordCase));
+      this.items.push(...buildKeywordItems(context.prefix, context, this.databaseType, this.input.keywordCase));
+    }
+
+    if (!context.exclusiveTableSuggestions && context.suggestColumns) {
+      this.items.push(...buildColumnItems(context, this.input.columnsByTable, this.dialect));
+      this.items.push(...buildSelectAllColumnItems(context, this.input.columnsByTable, this.t, this.dialect));
+      this.items.push(...buildInsertAllColumnItems(context, this.input.columnsByTable, this.t, this.dialect));
+    }
+
+    const emptyTableNameCompletion = !context.prefix && (context.suggestTables || context.exclusiveTableSuggestions);
+    if (!pendingJoinKeyword && !emptyTableNameCompletion && !context.tableAliasAfterCursor && context.referencedTables.length > 0 && !context.suggestColumns && !context.insertTable) {
+      this.items.push(...buildAliasItems(context, this.databaseType));
+    }
+
+    if (!context.exclusiveColumnSuggestions && context.suggestTables) {
+      this.items.push(...buildForeignKeyRelatedTableItems(context, this.input.tables, this.input.foreignKeysByTable, this.dialect));
+      this.items.push(...buildTableItems(context.prefix, this.input.tables, this.dialect, !!this.input.autoAliasTables && context.autoAliasTableCompletions, context.referencedTables, this.databaseType));
+      if (isOracleLikeDatabase(this.databaseType)) {
+        this.items.push(...buildOracleTableFunctionItems(context.prefix));
+      }
+      if (this.input.schemas && this.input.schemas.length > 0) {
+        this.items.push(...buildSchemaItems(context.prefix, this.input.schemas, this.dialect));
+      }
+    }
+
+    if (context.suggestRoutines || context.exclusiveRoutineSuggestions || context.oracleTableFunctionContext) {
+      this.items.push(...buildObjectItems(context, this.input.objects ?? [], this.dialect));
+    }
+
+    if (context.comparisonLeftColumn && context.suggestKeywords) {
+      this.items.push(...buildComparisonValueItems(context, this.input.columnsByTable, this.t, this.input.keywordCase));
+    }
+
+    if (context.onStar) {
+      const starItem = buildStarExpansionItem(context, this.input.columnsByTable, this.t, this.dialect);
+      if (starItem) this.items.push(starItem);
+    }
+
+    if (context.prefix) {
+      for (const item of this.items) {
+        // Alias snippets reuse the prefix as a label while applying alias SQL, so they are not exact name matches.
+        const isAliasSnippet = item.type === "snippet" && item.apply === formatAliasCompletionApply(item.label, this.databaseType);
+        if (!isAliasSnippet && item.label.toLowerCase() === context.prefix.toLowerCase()) {
+          item.exactMatch = true;
+          item.boost += EXACT_LABEL_MATCH_BOOST;
+        }
+      }
+    }
+
+    return dedupeAndSort(this.items);
+  }
+}
+
+export function shouldAutoOpenSqlCompletion(sql: string, cursor: number): boolean {
+  if (isSqlCompletionSuppressedContext(sql, cursor)) return false;
+  const previousChar = sql[cursor - 1];
+  if (!previousChar) return false;
+  if (/\bon\s+$/i.test(sql.slice(0, cursor))) return true;
+  if (isAfterJoinModifierContext(sql.slice(0, cursor))) return true;
+  if (/\bcall\s+(?:[A-Za-z_][\w$]*\.)?$/i.test(sql.slice(0, cursor))) return true;
+  const context = getSqlCompletionContext(sql, cursor);
+  if (previousChar === "(" && context.insertTable) return true;
+  if (/[,;()[\]]/.test(previousChar)) return false;
+  if (context.exclusiveTableSuggestions || context.exclusiveRoutineSuggestions || context.suggestTables) {
+    return true;
+  }
+  if (context.exclusiveColumnSuggestions || shouldAutoOpenColumnCompletion(context, sql, cursor)) return true;
+  return /[A-Za-z_$@.]/.test(previousChar);
+}
+
+function shouldAutoOpenColumnCompletion(context: SqlCompletionContext, sql: string, cursor: number): boolean {
+  if (!context.suggestColumns || context.referencedTables.length === 0) return false;
+  if (context.prefix.length > 0) return true;
+  return isColumnCompletionExpressionStart(sql.slice(0, cursor));
+}
+
+function isColumnCompletionExpressionStart(beforeCursor: string): boolean {
+  const cleaned = stripSqlLiterals(beforeCursor).trimEnd();
+  if (!cleaned) return false;
+  return /(?:\b(?:where|on|having|and|or|not|is|like|in|between|by)\b|[,(])$/i.test(cleaned);
+}
+
+export function isSqlCompletionSuppressedContext(sql: string, cursor: number): boolean {
+  const context = getSqlLexicalContext(sql, cursor);
+  return context.inLineComment || context.inBlockComment || context.inStringLiteral;
+}
+
+export function isSqlStringLiteralContext(sql: string, cursor: number): boolean {
+  return getSqlLexicalContext(sql, cursor).inStringLiteral;
+}
+
+export function isSqlCommentContext(sql: string, cursor: number): boolean {
+  const context = getSqlLexicalContext(sql, cursor);
+  return context.inLineComment || context.inBlockComment;
+}
+
+function getSqlLexicalContext(sql: string, cursor: number): { inLineComment: boolean; inBlockComment: boolean; inStringLiteral: boolean } {
+  const end = Math.max(0, Math.min(cursor, sql.length));
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inBacktick = false;
+  let inBracket = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let index = 0; index < end; index += 1) {
+    const ch = sql[index] ?? "";
+    const next = sql[index + 1] ?? "";
+
+    if (inLineComment) {
+      if (ch === "\n" || ch === "\r") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+
+    if (inSingleQuote) {
+      if (ch === "\\" && next) {
+        index += 1;
+      } else if (ch === "'" && next === "'") {
+        index += 1;
+      } else if (ch === "'") {
+        inSingleQuote = false;
+      }
+      continue;
+    }
+    if (inDoubleQuote) {
+      if (ch === "\\" && next) {
+        index += 1;
+      } else if (ch === '"' && next === '"') {
+        index += 1;
+      } else if (ch === '"') {
+        inDoubleQuote = false;
+      }
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "`") inBacktick = false;
+      continue;
+    }
+    if (inBracket) {
+      if (ch === "]") inBracket = false;
+      continue;
+    }
+
+    if (ch === "-" && next === "-") {
+      inLineComment = true;
+      index += 1;
+    } else if (ch === "#") {
+      inLineComment = true;
+    } else if (ch === "/" && next === "*") {
+      inBlockComment = true;
+      index += 1;
+    } else if (ch === "'") {
+      inSingleQuote = true;
+    } else if (ch === '"') {
+      inDoubleQuote = true;
+    } else if (ch === "`") {
+      inBacktick = true;
+    } else if (ch === "[") {
+      inBracket = true;
+    }
+  }
+
+  // Only single-quoted text is a value literal here. Double quotes, backticks,
+  // and brackets delimit identifiers in common SQL dialects, so they must not
+  // suppress identifier completion.
+  return {
+    inLineComment,
+    inBlockComment,
+    inStringLiteral: inSingleQuote,
+  };
+}
+
+export function isSqlLikeCompletionStatement(sql: string, cursor: number): boolean {
+  const statement = extractStatementAt(sql, cursor).trimStart();
+  if (/^(select|with)\b/i.test(statement)) return true;
+  return currentLineBlockStartsSql(sql, cursor);
+}
+
+function currentLineBlockStartsSql(sql: string, cursor: number): boolean {
+  return currentSqlLikeLineBlockSpan(sql, cursor) != null;
+}
+
+function currentSqlLikeLineBlockSpan(sql: string, cursor: number): { start: number; end: number } | null {
+  const safeCursor = Math.max(0, Math.min(cursor, sql.length));
+  const beforeCursor = sql.slice(0, safeCursor);
+  const lines = beforeCursor.split(/\r?\n/);
+  let start: number | null = null;
+  let offset = 0;
+
+  for (const line of lines) {
+    const trimmed = line.trimStart();
+    if (trimmed) {
+      const indentation = line.length - trimmed.length;
+      if (/^(select|with)\b/i.test(trimmed)) start = offset + indentation;
+      if (/^(get|post|put|delete|patch|head)\s+\//i.test(trimmed)) start = null;
+    }
+    offset += line.length + 1;
+  }
+
+  if (start == null) return null;
+
+  let end = sql.length;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let index = start; index < sql.length; index += 1) {
+    const ch = sql[index];
+    if (ch === "'" && !inDoubleQuote) inSingleQuote = !inSingleQuote;
+    else if (ch === '"' && !inSingleQuote) inDoubleQuote = !inDoubleQuote;
+    else if (ch === ";" && !inSingleQuote && !inDoubleQuote && index >= safeCursor) {
+      end = index;
+      break;
+    }
+  }
+
+  const blockEnd = currentLineBlockEnd(sql, safeCursor, start);
+  if (blockEnd != null) end = Math.min(end, blockEnd);
+
+  return { start, end };
+}
+
+function currentLineBlockEnd(sql: string, cursor: number, start: number): number | null {
+  let lineStart = sql.lastIndexOf("\n", cursor - 1) + 1;
+  while (lineStart < sql.length) {
+    const lineEnd = sql.indexOf("\n", lineStart);
+    const boundedLineEnd = lineEnd >= 0 ? lineEnd : sql.length;
+    const line = sql.slice(lineStart, boundedLineEnd);
+    const trimmed = line.trimStart();
+    if (lineStart > start && (!trimmed || /^(get|post|put|delete|patch|head)\s+\//i.test(trimmed))) {
+      return lineStart;
+    }
+    if (lineEnd < 0) break;
+    lineStart = lineEnd + 1;
+  }
+  return null;
+}
+
+export function getSqlCompletionResultValidFor(sql: string, cursor: number): RegExp | undefined {
+  void sql;
+  void cursor;
+  return undefined;
+}
+
+export function getSqlFunctionSignatureHelp(sql: string, cursor: number): SqlFunctionSignatureHelp | null {
+  const beforeCursor = sql.slice(0, cursor);
+  const openParenIndex = findActiveFunctionOpenParen(beforeCursor);
+  if (openParenIndex == null) return null;
+
+  const beforeParen = beforeCursor.slice(0, openParenIndex).trimEnd();
+  const name = /([A-Za-z_][\w$]*)$/.exec(beforeParen)?.[1]?.toUpperCase();
+  if (!name) return null;
+
+  const parameters = SQL_FUNCTION_SIGNATURES.get(name);
+  if (!parameters) return null;
+
+  const activeParameter = countTopLevelCommas(beforeCursor.slice(openParenIndex + 1));
+  return {
+    name,
+    signature: `${name}(${parameters.join(", ")})`,
+    activeParameter: Math.min(activeParameter, Math.max(0, parameters.length - 1)),
+    parameters,
+  };
+}
+
+/**
+ * Find the start position of the SQL statement containing the cursor.
+ * Respects semicolons and string literals.
+ */
+function extractStatementStart(sql: string, cursor: number): number {
+  const lineBlock = currentSqlLikeLineBlockSpan(sql, cursor);
+  if (lineBlock) return lineBlock.start;
+
+  let start = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    if (ch === "'" && !inDoubleQuote) inSingleQuote = !inSingleQuote;
+    else if (ch === '"' && !inSingleQuote) inDoubleQuote = !inDoubleQuote;
+    else if (ch === ";" && !inSingleQuote && !inDoubleQuote) {
+      if (i < cursor) {
+        start = i + 1;
+        while (start < sql.length && /\s/.test(sql[start])) start++;
+      }
+    }
+  }
+  return start;
+}
+
+/**
+ * Extract the full SQL statement that contains the cursor position.
+ * Respects semicolons and string literals.
+ */
+function extractStatementAt(sql: string, cursor: number): string {
+  const lineBlock = currentSqlLikeLineBlockSpan(sql, cursor);
+  if (lineBlock) return sql.slice(lineBlock.start, lineBlock.end).trim();
+
+  const start = extractStatementStart(sql, cursor);
+  let end = sql.length;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let i = start; i < sql.length; i++) {
+    const ch = sql[i];
+    if (ch === "'" && !inDoubleQuote) inSingleQuote = !inSingleQuote;
+    else if (ch === '"' && !inSingleQuote) inDoubleQuote = !inDoubleQuote;
+    else if (ch === ";" && !inSingleQuote && !inDoubleQuote && i >= cursor) {
+      end = i;
+      break;
+    }
+  }
+  return sql.slice(start, end).trim();
+}
+
+function detectStatementKind(previousStatements: string): SqlStatementKind {
+  const trimmed = previousStatements.trim();
+  if (!trimmed) return "unknown";
+  const firstWord = /^([A-Za-z_][\w$]*)/.exec(trimmed)?.[1]?.toLowerCase();
+  if (!firstWord) return "unknown";
+  const kindMap: Record<string, SqlStatementKind> = {
+    select: "select",
+    with: "select",
+    insert: "insert",
+    update: "update",
+    delete: "delete",
+    create: "create",
+    alter: "alter",
+    drop: "drop",
+  };
+  return kindMap[firstWord] ?? "unknown";
+}
+
+function isCallRoutineContext(beforeToken: string): boolean {
+  return /\bcall\s+(?:[A-Za-z_][\w$]*\.)?$/i.test(beforeToken) || /\bcall\s+(?:[A-Za-z_][\w$]*\.)?[A-Za-z_][\w$]*$/i.test(beforeToken);
+}
+
+const SQL_IDENTIFIER_CONTINUE_CHAR = /[$_\u200c\u200d\p{ID_Continue}]/u;
+
+function hasTableAliasAfterCursor(sql: string, cursor: number): boolean {
+  if (hasAliasMarkerAt(sql, cursor, false)) return true;
+  let pos = cursor;
+  while (pos < sql.length) {
+    const codePoint = sql.codePointAt(pos);
+    if (codePoint === undefined) break;
+    const char = String.fromCodePoint(codePoint);
+    if (char !== "." && !SQL_IDENTIFIER_CONTINUE_CHAR.test(char)) break;
+    // Advance by the full code point so supplementary Unicode identifiers
+    // do not leave the scan between UTF-16 surrogate halves.
+    pos += char.length;
+  }
+  if (sql[pos] === '"' || sql[pos] === "`" || sql[pos] === "]") pos++;
+  return hasAliasMarkerAt(sql, pos, true);
+}
+
+function hasAliasMarkerAt(sql: string, pos: number, allowImplicitAlias: boolean): boolean {
+  const following = sql.slice(skipSqlWhitespaceAndComments(sql, pos));
+  if (/^as\b/i.test(following)) return true;
+  if (/^(?:"[^"]+"|`[^`]+`|\[[^\]]+\])/.test(following)) return true;
+  if (!allowImplicitAlias) return false;
+  const implicitAlias = /^([A-Za-z_][\w$]*)/.exec(following)?.[1]?.toLowerCase();
+  return !!implicitAlias && !isUnsafeSqlAlias(implicitAlias);
+}
+
+function skipSqlWhitespaceAndComments(sql: string, pos: number): number {
+  for (;;) {
+    while (pos < sql.length && /\s/.test(sql[pos])) pos++;
+    if (sql.startsWith("--", pos)) {
+      const newline = sql.indexOf("\n", pos + 2);
+      if (newline === -1) return sql.length;
+      pos = newline + 1;
+    } else if (sql.startsWith("/*", pos)) {
+      const end = sql.indexOf("*/", pos + 2);
+      if (end === -1) return sql.length;
+      pos = end + 2;
+    } else {
+      return pos;
+    }
+  }
+}
+
+export function getSqlCompletionContext(sql: string, cursor: number): SqlCompletionContext {
+  // Extract the full statement at cursor position for referenced tables
+  const fullStatement = extractStatementAt(sql, cursor);
+
+  // Content before cursor within the current statement
+  const stmtStart = extractStatementStart(sql, cursor);
+  const beforeCursor = sql.slice(stmtStart, cursor);
+
+  const trailingIdentifier = parseTrailingIdentifierContext(beforeCursor);
+  const prefix = trailingIdentifier?.prefix ?? "";
+  const qualifier = trailingIdentifier?.qualifier;
+  const qualifierParts = trailingIdentifier?.qualifierParts;
+  const bareStart = trailingIdentifier?.start ?? beforeCursor.length;
+  const beforeToken = beforeCursor.slice(0, Math.max(0, bareStart)).trimEnd();
+  const lastWord = /([A-Za-z_][\w$]*)$/.exec(beforeToken)?.[1]?.toLowerCase() ?? "";
+
+  let referencedTables = extractReferencedTables(fullStatement);
+
+  // Merge CTE definitions into referenced tables
+  const cteDefs = extractCteDefinitions(fullStatement);
+  for (const cte of cteDefs) {
+    if (!referencedTables.some((rt) => rt.name.toLowerCase() === cte.name.toLowerCase())) {
+      referencedTables.push({ name: cte.name, columns: cte.columns });
+    } else {
+      const existing = referencedTables.find((rt) => rt.name.toLowerCase() === cte.name.toLowerCase());
+      if (existing && !existing.columns) {
+        existing.columns = cte.columns;
+      }
+    }
+  }
+
+  // Merge subquery alias references
+  const subqueryRefs = extractSubqueryReferences(fullStatement);
+  for (const sq of subqueryRefs) {
+    if (!referencedTables.some((rt) => rt.name.toLowerCase() === sq.name.toLowerCase() && rt.alias === sq.alias)) {
+      referencedTables.push(sq);
+    }
+  }
+
+  // Detect INSERT INTO table (column list) context
+  const insertInfo = detectInsertColumnListContext(beforeCursor);
+  const updateInfo = detectUpdateCompletionContext(beforeCursor);
+  const deleteInfo = detectDeleteCompletionContext(beforeCursor);
+  const oracleTableFunctionContext = detectOracleTableFunctionContext(beforeCursor);
+
+  const afterTableTrigger = TABLE_TRIGGER_KEYWORDS.has(lastWord) || (JOIN_MODIFIERS.has(lastWord) && isFollowedByJoin(beforeToken)) || isInTableListContext(beforeToken);
+  const exclusiveTableSuggestions = EXCLUSIVE_TABLE_TRIGGER_KEYWORDS.has(lastWord) || (JOIN_MODIFIERS.has(lastWord) && isFollowedByJoin(beforeToken)) || isInTableListContext(beforeToken);
+  const tableAliasAfterCursor = hasTableAliasAfterCursor(sql, cursor);
+  const autoAliasTableCompletions = (lastWord === "from" || lastWord === "join" || (JOIN_MODIFIERS.has(lastWord) && isFollowedByJoin(beforeToken)) || isInTableListContext(beforeToken)) && !tableAliasAfterCursor;
+  const exclusiveColumnSuggestions = !!qualifier && !exclusiveTableSuggestions && !insertInfo;
+  const activePrefixIsCte = cteDefs.some((cte) => normalizeIdentifierPart(cte.name) === normalizeIdentifierPart(prefix));
+  if (exclusiveTableSuggestions && prefix && !activePrefixIsCte && referencedTables.length > 1) {
+    referencedTables = removeActiveTableCompletionReference(referencedTables, prefix, qualifier);
+  }
+
+  // Check if we're in a context where columns are expected
+  const selectListColumnContext = isInSelectListContext(beforeCursor);
+  const inColumnContext = selectListColumnContext || isInColumnContext(beforeCursor) || !!insertInfo;
+  const inJoinConditionContext = isInJoinConditionContext(beforeCursor);
+  const prioritizeSelectAliases = isInOrderOrGroupByContext(beforeCursor);
+  const inCallRoutineContext = isCallRoutineContext(beforeCursor);
+  const inPotentialPackageMemberContext = !!qualifier && !exclusiveTableSuggestions && !insertInfo && !oracleTableFunctionContext;
+  const suggestColumns = !!qualifier || !!updateInfo?.inSetClause || !!insertInfo || (inColumnContext && referencedTables.length > 0);
+  const preferColumnsOverGlobalRoutines = suggestColumns && referencedTables.length > 0 && !qualifier;
+  const suggestRoutines = inCallRoutineContext || oracleTableFunctionContext || inPotentialPackageMemberContext || (!preferColumnsOverGlobalRoutines && !exclusiveTableSuggestions && !exclusiveColumnSuggestions && !insertInfo && prefix.length >= 2);
+
+  const statementKind = detectStatementKind(beforeCursor || fullStatement);
+  const preferredKeywords = qualifier ? [] : preferredKeywordsForCompletion(beforeCursor, beforeToken, selectListColumnContext, exclusiveTableSuggestions, updateInfo, deleteInfo);
+  const contextKind = detectCompletionContextKind({
+    qualifier,
+    exclusiveTableSuggestions,
+    exclusiveColumnSuggestions,
+    insertInfo,
+    updateInfo,
+    inCallRoutineContext,
+    oracleTableFunctionContext,
+    afterTableTrigger,
+    lastWord,
+    statementKind,
+    suggestColumns,
+    suggestRoutines,
+  });
+
+  return {
+    prefix,
+    qualifier: insertInfo ? undefined : qualifier,
+    qualifierParts: insertInfo ? undefined : qualifierParts,
+    suggestTables: insertInfo ? false : afterTableTrigger,
+    suggestColumns,
+    suggestKeywords: !exclusiveTableSuggestions && !exclusiveColumnSuggestions && !insertInfo && !inCallRoutineContext,
+    suggestRoutines,
+    suggestJoinConditions: insertInfo ? false : inJoinConditionContext && referencedTables.length >= 2,
+    exclusiveTableSuggestions: insertInfo ? false : exclusiveTableSuggestions,
+    exclusiveColumnSuggestions: exclusiveColumnSuggestions || !!insertInfo || !!updateInfo?.inSetClause,
+    exclusiveRoutineSuggestions: inCallRoutineContext,
+    prioritizeSelectAliases: insertInfo ? false : prioritizeSelectAliases,
+    selectAliases: prioritizeSelectAliases ? extractSelectAliases(fullStatement) : [],
+    referencedTables,
+    insertTable: insertInfo?.table,
+    insertSchema: insertInfo?.schema,
+    statementKind,
+    tableTriggerWord: lastWord || undefined,
+    isGroupBy: isInGroupByContext(beforeCursor),
+    nonAggregatedSelectColumns: extractNonAggregatedSelectColumns(fullStatement),
+    comparisonLeftColumn: detectComparisonLeftColumn(beforeCursor),
+    onStar: detectOnStar(beforeCursor),
+    selectListColumnContext,
+    preferredKeywords,
+    updateTarget: updateInfo?.target,
+    deleteTarget: deleteInfo?.target,
+    oracleTableFunctionContext,
+    autoAliasTableCompletions,
+    tableAliasAfterCursor,
+    contextKind,
+  };
+}
+
+function removeActiveTableCompletionReference(referencedTables: SqlCompletionReferencedTable[], prefix: string, qualifier?: string): SqlCompletionReferencedTable[] {
+  const activeName = normalizeIdentifierPart(prefix);
+  const activeQualifier = qualifier ? normalizeIdentifierPart(qualifier) : undefined;
+  return referencedTables.filter((table) => {
+    if (table.alias) return true;
+    if (normalizeIdentifierPart(table.name) !== activeName) return true;
+    if (activeQualifier && table.schema && normalizeIdentifierPart(table.schema) !== activeQualifier) return true;
+    return false;
+  });
+}
+
+function detectCompletionContextKind(options: {
+  qualifier?: string;
+  exclusiveTableSuggestions: boolean;
+  exclusiveColumnSuggestions: boolean;
+  insertInfo: ReturnType<typeof detectInsertColumnListContext>;
+  updateInfo: ReturnType<typeof detectUpdateCompletionContext>;
+  inCallRoutineContext: boolean;
+  oracleTableFunctionContext: boolean;
+  afterTableTrigger: boolean;
+  lastWord: string;
+  statementKind: SqlStatementKind;
+  suggestColumns: boolean;
+  suggestRoutines: boolean;
+}): SqlCompletionContextKind {
+  if (options.insertInfo) return "column";
+  if (options.updateInfo?.inSetClause) return "column";
+  if (options.inCallRoutineContext) return "exec";
+  if (options.qualifier && options.exclusiveColumnSuggestions) return "alias_column";
+  if (options.oracleTableFunctionContext || options.suggestRoutines) return "routine";
+  if (options.exclusiveTableSuggestions || options.afterTableTrigger) {
+    if (options.statementKind === "insert" && options.lastWord === "into") return "insert_target";
+    return options.lastWord === "join" ? "join" : "table";
+  }
+  if (options.suggestColumns) return options.qualifier ? "alias_column" : "column";
+  return "keyword";
+}
+
+function parseTrailingIdentifierContext(input: string): { start: number; prefix: string; qualifier?: string; qualifierParts?: string[] } | null {
+  if (/\s$/.test(input)) return null;
+  let i = input.length - 1;
+  while (i >= 0 && /\s/.test(input[i] ?? "")) i--;
+  if (i < 0) return null;
+
+  const endsWithDot = input[i] === ".";
+  const tail = input.slice(0, endsWithDot ? i : i + 1);
+  if (!tail) {
+    return endsWithDot ? { start: i, prefix: "" } : null;
+  }
+  const parts: string[] = [];
+  let index = tail.length;
+
+  while (index > 0) {
+    const parsed = parseTrailingIdentifierPart(tail, index);
+    if (!parsed) break;
+    parts.unshift(unquoteIdentifier(parsed.raw));
+    index = parsed.start;
+    if (index <= 0 || tail[index - 1] !== ".") break;
+    index -= 1;
+  }
+
+  if (parts.length === 0) return null;
+  const start = index;
+
+  if (parts.length >= 2 || endsWithDot) {
+    const qualifierParts = endsWithDot ? parts : parts.slice(0, -1);
+    const prefixPart = endsWithDot ? "" : (parts[parts.length - 1] ?? "");
+    const qualifierValue = qualifierParts.join(".");
+    return {
+      start,
+      prefix: prefixPart,
+      qualifier: qualifierValue || undefined,
+      qualifierParts: qualifierParts.length > 0 ? qualifierParts : undefined,
+    };
+  }
+
+  return {
+    start,
+    prefix: parts[0] ?? "",
+  };
+}
+
+function parseTrailingIdentifierPart(input: string, endExclusive: number): { start: number; raw: string } | null {
+  if (endExclusive <= 0) return null;
+  const end = endExclusive - 1;
+  const tailChar = input[end];
+  if (!tailChar) return null;
+
+  if (tailChar === '"') {
+    let start = end - 1;
+    while (start >= 0) {
+      if (input[start] === '"') {
+        if (start > 0 && input[start - 1] === '"') {
+          start -= 2;
+          continue;
+        }
+        return { start, raw: input.slice(start, endExclusive) };
+      }
+      start -= 1;
+    }
+    return null;
+  }
+
+  if (tailChar === "`") {
+    const start = input.lastIndexOf("`", end - 1);
+    if (start < 0) return null;
+    return { start, raw: input.slice(start, endExclusive) };
+  }
+
+  let start = end;
+  while (start >= 0 && /[A-Za-z0-9_$@]/.test(input[start] ?? "")) start -= 1;
+  start += 1;
+  if (start >= endExclusive) return null;
+  const raw = input.slice(start, endExclusive);
+  if (!/^[@A-Za-z_][\w$@]*$/.test(raw)) return null;
+  return { start, raw };
+}
+
+/**
+ * Check if the content before cursor is in a column-expected context.
+ */
+function isInColumnContext(beforeCursor: string): boolean {
+  if (!beforeCursor) return false;
+
+  if (isInSelectListContext(beforeCursor)) return true;
+  if (isInOrderOrGroupByContext(beforeCursor)) return true;
+
+  // Strip string literals
+  const cleaned = beforeCursor.replace(/'[^']*'/g, "''").replace(/"[^"]*"/g, "''");
+
+  // Get all words/tokens
+  const lastWords = cleaned.trimEnd().split(/\s+/);
+
+  // Check the last 3 words for column-context keywords
+  for (let i = lastWords.length - 1; i >= Math.max(0, lastWords.length - 3); i--) {
+    const rawWord = lastWords[i]?.toLowerCase() ?? "";
+    if (/^[=<>!+\-/(,]$/.test(rawWord)) return true;
+    const word = rawWord.replace(/[^a-z0-9.]/g, "");
+    // Operators that indicate column context
+    // Keywords that directly precede column expressions
+    if (["where", "on", "having", "set", "and", "or", "not", "is", "like", "in", "between", "select"].includes(word)) {
+      return true;
+    }
+    // "ORDER BY" / "GROUP BY" — when we see "by", check the word before it
+    if (word === "by" && i > 0) {
+      const prevWord = lastWords[i - 1]?.toLowerCase() ?? "";
+      if (["order", "group"].includes(prevWord)) return true;
+    }
+  }
+
+  return false;
+}
+
+function isInSelectListContext(beforeCursor: string): boolean {
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let inBacktick = false;
+  const selectOpenByDepth = new Map<number, boolean>();
+
+  for (let i = 0; i < beforeCursor.length; i++) {
+    const ch = beforeCursor[i] ?? "";
+    const next = beforeCursor[i + 1] ?? "";
+
+    if (inSingleQuote) {
+      if (ch === "\\" && next) {
+        i++;
+      } else if (ch === "'" && next === "'") {
+        i++;
+      } else if (ch === "'") {
+        inSingleQuote = false;
+      }
+      continue;
+    }
+    if (inDoubleQuote) {
+      if (ch === '"' && next === '"') {
+        i++;
+      } else if (ch === '"') {
+        inDoubleQuote = false;
+      }
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "`") inBacktick = false;
+      continue;
+    }
+
+    if (ch === "'") {
+      inSingleQuote = true;
+      continue;
+    }
+    if (ch === '"') {
+      inDoubleQuote = true;
+      continue;
+    }
+    if (ch === "`") {
+      inBacktick = true;
+      continue;
+    }
+    if (ch === "(") {
+      depth++;
+      continue;
+    }
+    if (ch === ")") {
+      selectOpenByDepth.delete(depth);
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (!/[A-Za-z_]/.test(ch)) continue;
+
+    let end = i + 1;
+    while (end < beforeCursor.length && /[A-Za-z0-9_$]/.test(beforeCursor[end] ?? "")) end++;
+    const word = beforeCursor.slice(i, end).toLowerCase();
+    if (word === "select") {
+      selectOpenByDepth.set(depth, true);
+    } else if (word === "from") {
+      selectOpenByDepth.set(depth, false);
+    }
+    i = end - 1;
+  }
+
+  return selectOpenByDepth.get(depth) === true;
+}
+
+function isInJoinConditionContext(beforeCursor: string): boolean {
+  const cleaned = beforeCursor
+    .replace(/'[^']*'/g, "''")
+    .replace(/"[^"]*"/g, "''")
+    .toLowerCase();
+  const lastJoinIndex = cleaned.lastIndexOf(" join ");
+  const currentJoinSegment = lastJoinIndex >= 0 ? cleaned.slice(lastJoinIndex) : cleaned;
+  if (!/\bon\b/.test(currentJoinSegment)) return false;
+  return /\b(?:on|and)\s+[a-z0-9_$]*$/i.test(currentJoinSegment);
+}
+
+function isInOrderOrGroupByContext(beforeCursor: string): boolean {
+  const cleaned = beforeCursor
+    .replace(/'[^']*'/g, "''")
+    .replace(/"[^"]*"/g, '""')
+    .toLowerCase();
+  const lastOrderBy = cleaned.lastIndexOf("order by");
+  const lastGroupBy = cleaned.lastIndexOf("group by");
+  const lastContext = Math.max(lastOrderBy, lastGroupBy);
+  if (lastContext < 0) return false;
+
+  const segment = cleaned.slice(lastContext);
+  return !/\b(?:where|having|limit|offset|union|intersect|except|join|from)\b/.test(segment);
+}
+
+function isInGroupByContext(beforeCursor: string): boolean {
+  const cleaned = beforeCursor
+    .replace(/'[^']*'/g, "''")
+    .replace(/"[^"]*"/g, '""')
+    .toLowerCase();
+  const lastGroupBy = cleaned.lastIndexOf("group by");
+  if (lastGroupBy < 0) return false;
+  // Make sure GROUP BY is after ORDER BY (if both exist) — we want the closest
+  const lastOrderBy = cleaned.lastIndexOf("order by");
+  if (lastOrderBy > lastGroupBy) return false;
+  const segment = cleaned.slice(lastGroupBy);
+  return !/\b(?:where|having|limit|offset|union|intersect|except|join|from)\b/.test(segment);
+}
+
+const AGGREGATE_FUNCTION_PATTERN = /^(COUNT|SUM|AVG|MIN|MAX|GROUP_CONCAT|STRING_AGG|ARRAY_AGG|JSON_ARRAYAGG|JSON_OBJECTAGG)\s*\(/i;
+
+function extractNonAggregatedSelectColumns(sql: string): string[] {
+  const selectList = extractSelectList(sql);
+  if (!selectList) return [];
+
+  const columns: string[] = [];
+  for (const expression of splitTopLevel(selectList, ",")) {
+    const trimmed = expression.trim();
+    if (trimmed === "*") continue;
+    if (AGGREGATE_FUNCTION_PATTERN.test(trimmed)) continue;
+
+    const alias = /\bas\s+([A-Za-z_][\w$]*)$/i.exec(trimmed)?.[1];
+    if (alias) {
+      columns.push(alias);
+      continue;
+    }
+
+    const lastId = /([A-Za-z_][\w$]*)$/.exec(trimmed)?.[1];
+    if (lastId) columns.push(lastId);
+  }
+
+  return columns;
+}
+
+function detectOnStar(beforeCursor: string): boolean {
+  // Cursor is right after * in SELECT clause
+  return /\bselect\b[^;]*\*$/i.test(beforeCursor);
+}
+
+function detectComparisonLeftColumn(beforeCursor: string): string | undefined {
+  // Match: column_name = | column.column = | alias.column =
+  const match = /\b([A-Za-z_][\w$]*(?:\.[A-Za-z_][\w$]*)?)\s*(?:=|!=|<>|>=|<=|>|<)\s*$/i.exec(beforeCursor);
+  return match?.[1];
+}
+
+function detectInsertColumnListContext(beforeCursor: string): { table: string; schema?: string } | null {
+  // Keep quoted identifiers intact so schema/table targets resolve to their
+  // real names instead of placeholder string contents.
+  const cleaned = beforeCursor.replace(/'[^']*'/g, "''");
+  const identifier = '(?:"[^"]+"|`[^`]+`|[A-Za-z_][\\w$]*)';
+  const qualifiedIdentifier = `${identifier}(?:\\.${identifier}){0,2}`;
+  const match = new RegExp(`\\binsert\\s+into\\s+(${qualifiedIdentifier})\\s*\\([^)]*$`, "i").exec(cleaned);
+  if (!match) return null;
+  const fullTable = match[1];
+  if (!fullTable) return null;
+  const [first, second] = splitQualifiedName(fullTable);
+  if (second) return { table: second, schema: first! };
+  return { table: first! };
+}
+
+function detectUpdateCompletionContext(beforeCursor: string): { target: { table: string; schema?: string }; afterTarget: boolean; inSetClause: boolean; afterSetAssignments: boolean } | null {
+  const cleaned = beforeCursor.replace(/'[^']*'/g, "''").replace(/"[^"]*"/g, '""');
+  const match = /^\s*update\s+((?:"[^"]+"|`[^`]+`|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|`[^`]+`|[A-Za-z_][\w$]*))?)(?:\s+(?:as\s+)?([A-Za-z_][\w$]*))?/i.exec(cleaned);
+  if (!match) return null;
+  const [first, second] = splitQualifiedName(match[1] ?? "");
+  if (!first) return null;
+  const target = second ? { schema: first, table: second } : { table: first };
+  const afterTargetText = cleaned.slice(match[0].length).trimStart();
+  const afterTarget = !afterTargetText || /^[A-Za-z_][\w$]*$/i.test(afterTargetText);
+  const setIndex = afterTargetText.search(/\bset\b/i);
+  if (setIndex < 0) return { target, afterTarget, inSetClause: false, afterSetAssignments: false };
+  const setSegment = afterTargetText.slice(setIndex + 3);
+  const inSetClause = !/\bwhere\b/i.test(setSegment);
+  const afterSetAssignments = inSetClause && /(?:=|,)\s*(?:''|""|[A-Za-z0-9_.$]+)?\s+[A-Za-z_][\w$]*$/i.test(setSegment);
+  return { target, afterTarget: false, inSetClause, afterSetAssignments };
+}
+
+function detectDeleteCompletionContext(beforeCursor: string): { target?: { table: string; schema?: string }; afterTarget: boolean } | null {
+  const cleaned = beforeCursor.replace(/'[^']*'/g, "''").replace(/"[^"]*"/g, '""');
+  const match = /^\s*delete(?:\s+[A-Za-z_][\w$]*)?\s+from\s+((?:"[^"]+"|`[^`]+`|[A-Za-z_][\w$]*)(?:\.(?:"[^"]+"|`[^`]+`|[A-Za-z_][\w$]*))?)(?:\s+(?:as\s+)?([A-Za-z_][\w$]*))?/i.exec(cleaned);
+  if (!match) return /^\s*delete\s+(?:from\s+)?[A-Za-z_][\w$]*$/i.test(cleaned) ? { afterTarget: false } : null;
+  const [first, second] = splitQualifiedName(match[1] ?? "");
+  const target = first ? (second ? { schema: first, table: second } : { table: first }) : undefined;
+  const afterTargetText = cleaned.slice(match[0].length).trimStart();
+  return { target, afterTarget: !afterTargetText || /^[A-Za-z_][\w$]*$/i.test(afterTargetText) };
+}
+
+function detectOracleTableFunctionContext(beforeCursor: string): boolean {
+  const cleaned = beforeCursor.replace(/'[^']*'/g, "''").replace(/"[^"]*"/g, '""');
+  return /\b(?:from|join)\s+table\s*\(\s*(?:(?:"[^"]+"|`[^`]+`|[A-Za-z_][\w$]*)\.){0,2}[A-Za-z_][\w$]*$/i.test(cleaned);
+}
+
+function preferredKeywordsForCompletion(beforeCursor: string, beforeToken: string, selectListColumnContext: boolean, exclusiveTableSuggestions: boolean, updateInfo: ReturnType<typeof detectUpdateCompletionContext>, deleteInfo: ReturnType<typeof detectDeleteCompletionContext>): string[] {
+  const keywords: string[] = [];
+  if (selectListColumnContext && hasSelectListExpression(beforeCursor)) keywords.push("FROM");
+  if (isAfterJoinModifierContext(beforeCursor)) keywords.push("JOIN");
+  if (!exclusiveTableSuggestions && isAfterSelectBodyExpression(beforeToken)) keywords.push("LIMIT");
+  if (isAfterConditionExpression(beforeToken)) keywords.push("AND", "OR");
+  if (updateInfo?.afterTarget) keywords.push("SET");
+  if (updateInfo?.afterSetAssignments) keywords.push("WHERE");
+  if (deleteInfo?.afterTarget) keywords.push("WHERE");
+  return keywords;
+}
+
+function hasSelectListExpression(beforeCursor: string): boolean {
+  const cleaned = stripSqlLiterals(beforeCursor).trimEnd();
+  const selectIndex = lastTopLevelKeywordIndex(cleaned, "select");
+  if (selectIndex < 0) return false;
+  const afterSelect = cleaned.slice(selectIndex + "select".length).trim();
+  return !!afterSelect && !/^distinct\s*$/i.test(afterSelect);
+}
+
+function isAfterSelectBodyExpression(beforeToken: string): boolean {
+  const cleaned = stripSqlLiterals(beforeToken).trimEnd();
+  if (!/^\s*(?:with\b[\s\S]*\bselect\b|select\b)/i.test(cleaned)) return false;
+  if (!/\bfrom\b/i.test(cleaned)) return false;
+  if (/\b(?:limit|offset|union|intersect|except)\b/i.test(cleaned)) return false;
+  if (/[,.(+\-*/%<>=!&|]$/.test(cleaned)) return false;
+  const lastKeyword = /\b([A-Za-z_][\w$]*)\s*$/.exec(cleaned)?.[1]?.toLowerCase();
+  if (lastKeyword && SELECT_BODY_INCOMPLETE_TAIL_KEYWORDS.has(lastKeyword)) return false;
+  return true;
+}
+
+const SELECT_BODY_INCOMPLETE_TAIL_KEYWORDS = new Set(["where", "and", "or", "not", "having", "group", "order", "by", "on", "is", "in", "like", "between", ...JOIN_MODIFIERS]);
+const CONDITION_INCOMPLETE_TAIL_KEYWORDS = new Set(["where", "and", "or", "not", "having", "on", "is", "in", "like", "between", "exists"]);
+
+function isAfterConditionExpression(beforeToken: string): boolean {
+  const cleaned = stripSqlLiterals(beforeToken).trimEnd();
+  if (!hasActiveConditionClause(cleaned)) return false;
+  const lastKeyword = /\b([A-Za-z_][\w$]*)\s*$/.exec(cleaned)?.[1]?.toLowerCase();
+  if (lastKeyword && CONDITION_INCOMPLETE_TAIL_KEYWORDS.has(lastKeyword)) return false;
+  return isExpressionTailComplete(cleaned);
+}
+
+function isAfterJoinModifierContext(beforeCursor: string): boolean {
+  const cleaned = stripSqlLiterals(beforeCursor).trimEnd();
+  const modifier = /\b([A-Za-z_][\w$]*)\s*$/.exec(cleaned)?.[1]?.toLowerCase();
+  if (!modifier || !JOIN_MODIFIERS.has(modifier)) return false;
+
+  const beforeModifier = cleaned.slice(0, cleaned.length - modifier.length).trimEnd();
+  const lastTableIntro = Math.max(lastTopLevelKeywordIndex(beforeModifier, "from"), lastTopLevelKeywordIndex(beforeModifier, "join"));
+  if (lastTableIntro < 0) return false;
+
+  const lastClauseBoundary = Math.max(
+    lastTopLevelKeywordIndex(beforeModifier, "where"),
+    lastTopLevelKeywordIndex(beforeModifier, "group"),
+    lastTopLevelKeywordIndex(beforeModifier, "order"),
+    lastTopLevelKeywordIndex(beforeModifier, "having"),
+    lastTopLevelKeywordIndex(beforeModifier, "limit"),
+    lastTopLevelKeywordIndex(beforeModifier, "offset"),
+    lastTopLevelKeywordIndex(beforeModifier, "union"),
+    lastTopLevelKeywordIndex(beforeModifier, "intersect"),
+    lastTopLevelKeywordIndex(beforeModifier, "except"),
+  );
+  if (lastClauseBoundary > lastTableIntro) return false;
+
+  const tableSegment = beforeModifier
+    .slice(lastTableIntro)
+    .replace(/^\s*(?:from|join)\b/i, "")
+    .trim();
+  return tableSegment.length > 0;
+}
+
+function hasActiveConditionClause(sql: string): boolean {
+  const lower = sql.toLowerCase();
+  const whereIndex = lastTopLevelKeywordIndex(lower, "where");
+  const havingIndex = lastTopLevelKeywordIndex(lower, "having");
+  const onIndex = lastTopLevelKeywordIndex(lower, "on");
+  const conditionIndex = Math.max(whereIndex, havingIndex, onIndex);
+  if (conditionIndex < 0) return false;
+  const afterCondition = lower.slice(conditionIndex);
+  return !/\b(?:group\s+by|order\s+by|limit|offset|union|intersect|except)\b/.test(afterCondition);
+}
+
+function isExpressionTailComplete(sql: string): boolean {
+  const trimmed = sql.trimEnd();
+  if (!trimmed) return false;
+  const lastChar = trimmed[trimmed.length - 1] ?? "";
+  if (/[,.(+\-*/%<>=!&|]$/.test(lastChar)) return false;
+  return /(?:\)|\]|\b(?:true|false|null)\b|`[^`]+`|"[^"]*"|''|\b\d+(?:\.\d+)?\b|\b[A-Za-z_][\w$]*\b)$/i.test(trimmed);
+}
+
+function stripSqlLiterals(sql: string): string {
+  return sql.replace(/'[^']*'/g, "''").replace(/"[^"]*"/g, '""');
+}
+
+function lastTopLevelKeywordIndex(sql: string, keyword: string): number {
+  const lower = sql.toLowerCase();
+  const target = keyword.toLowerCase();
+  let depth = 0;
+  let lastIndex = -1;
+  for (let index = 0; index < lower.length; index++) {
+    const ch = lower[index] ?? "";
+    if (ch === "(") {
+      depth++;
+      continue;
+    }
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1);
+      continue;
+    }
+    if (depth === 0 && lower.startsWith(target, index) && !isIdentifierPart(lower[index - 1]) && !isIdentifierPart(lower[index + target.length])) {
+      lastIndex = index;
+      index += target.length - 1;
+    }
+  }
+  return lastIndex;
+}
+
+function extractReferencedTables(sql: string): SqlCompletionReferencedTable[] {
+  // Keywords that should NOT be treated as table aliases
+  const ALIAS_BLACKLIST = new Set([
+    "where",
+    "group",
+    "order",
+    "having",
+    "limit",
+    "offset",
+    "union",
+    "intersect",
+    "except",
+    "and",
+    "or",
+    "not",
+    "is",
+    "like",
+    "in",
+    "between",
+    "exists",
+    "select",
+    "from",
+    "join",
+    "straight_join",
+    "left",
+    "right",
+    "inner",
+    "outer",
+    "cross",
+    "apply",
+    "full",
+    "natural",
+    "on",
+    "as",
+    "set",
+    "insert",
+    "update",
+    "delete",
+    "create",
+    "drop",
+    "alter",
+    "into",
+    "values",
+    "returning",
+    "for",
+    "window",
+    "partition",
+    "over",
+    "with",
+    "recursive",
+    "lateral",
+    "when",
+    "then",
+    "else",
+    "end",
+    "case",
+    "cast",
+    "coalesce",
+    "null",
+    "true",
+    "false",
+    "distinct",
+    "all",
+    "primary",
+    "key",
+    "foreign",
+    "references",
+    "constraint",
+    "default",
+    "check",
+    "unique",
+    "index",
+    "table",
+    "view",
+    "database",
+    "schema",
+    "describe",
+    "explain",
+    "analyze",
+    "pivot",
+    "unpivot",
+    "asof",
+    "positional",
+    "anti",
+    "semi",
+    "sample",
+    "filter",
+    "qualify",
+    "offset",
+    "fetch",
+    "next",
+    "rows",
+    "only",
+    "preceding",
+    "following",
+    "current",
+    "unbounded",
+    "asc",
+    "desc",
+    "nulls",
+    "first",
+    "last",
+    "ignore",
+    "respect",
+  ]);
+
+  // STRAIGHT_JOIN is a standalone MySQL table introducer, not a modifier followed by JOIN.
+  const pattern = /\b(?:from|join|straight_join|update|apply)\s+((?:"[^"]+"|`[^`]+`|[^\s,;()]+)(?:\.(?:"[^"]+"|`[^`]+`|[^\s,;()]+))?)(?:\s+(?:as\s+)?([A-Za-z_][\w$]*))?/gi;
+  const referenced: SqlCompletionReferencedTable[] = [];
+  let match: RegExpExecArray | null;
+  while ((match = pattern.exec(sql)) !== null) {
+    const rawName = match[1];
+    const alias = match[2];
+    if (alias && ALIAS_BLACKLIST.has(alias.toLowerCase())) {
+      pattern.lastIndex = match.index + match[0].length - alias.length;
+    }
+    const quotedName = !!rawName && (rawName.startsWith('"') || rawName.startsWith("`"));
+    if (!quotedName && rawName && ALIAS_BLACKLIST.has(rawName.toLowerCase())) continue;
+    // Filter out SQL keywords that accidentally matched as aliases
+    const cleanAlias = alias && !ALIAS_BLACKLIST.has(alias.toLowerCase()) ? alias : undefined;
+    if (isElasticsearchStyleIndexName(rawName)) {
+      referenced.push({ name: unquoteIdentifier(rawName), alias: cleanAlias });
+      continue;
+    }
+    const [first, second] = splitQualifiedName(rawName);
+    if (!first) continue;
+    const table = second ? { schema: first, name: second, alias: cleanAlias } : { name: first, alias: cleanAlias };
+    referenced.push(table);
+  }
+  return referenced;
+}
+
+function isElasticsearchStyleIndexName(name: string | undefined): name is string {
+  if (!name) return false;
+  if ((name.startsWith('"') && name.endsWith('"')) || (name.startsWith("`") && name.endsWith("`"))) return false;
+  return /[-*]/.test(name);
+}
+
+function extractSelectAliases(sql: string): string[] {
+  const selectList = extractSelectList(sql);
+  if (!selectList) return [];
+
+  const aliases: string[] = [];
+  const seen = new Set<string>();
+  for (const expression of splitTopLevel(selectList, ",")) {
+    const alias = extractSelectAlias(expression);
+    if (!alias) continue;
+    const key = alias.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    aliases.push(alias);
+  }
+
+  return aliases;
+}
+
+function extractSelectList(sql: string): string | null {
+  const lower = sql.toLowerCase();
+  const selectIndex = lower.search(/\bselect\b/);
+  if (selectIndex < 0) return null;
+
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let i = selectIndex + "select".length; i < sql.length; i++) {
+    const ch = sql[i];
+    if (ch === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (ch === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (inSingleQuote || inDoubleQuote) continue;
+    if (ch === "(") depth++;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    else if (depth === 0 && lower.slice(i, i + "from".length) === "from" && !isIdentifierPart(sql[i - 1]) && !isIdentifierPart(sql[i + "from".length])) {
+      return sql.slice(selectIndex + "select".length, i).trim();
+    }
+  }
+
+  return null;
+}
+
+function extractSelectAlias(expression: string): string | null {
+  const trimmed = expression.trim();
+  const explicitAlias = /\bas\s+([A-Za-z_][\w$]*)$/i.exec(trimmed)?.[1];
+  if (explicitAlias) return explicitAlias;
+
+  const implicitAlias = /(?:^|[\s)])([A-Za-z_][\w$]*)$/.exec(trimmed)?.[1];
+  if (!implicitAlias) return null;
+  const expressionWithoutAlias = trimmed.slice(0, trimmed.length - implicitAlias.length).trimEnd();
+  if (!expressionWithoutAlias || /^[A-Za-z_][\w$]*(?:\.[A-Za-z_][\w$]*)?$/.test(trimmed)) return null;
+  return implicitAlias;
+}
+
+function isIdentifierPart(ch: string | undefined): boolean {
+  return !!ch && /[A-Za-z0-9_$]/.test(ch);
+}
+
+function findMatchingParen(sql: string, openPos: number): number {
+  if (sql[openPos] !== "(") return -1;
+  let depth = 1;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let i = openPos + 1; i < sql.length; i++) {
+    const ch = sql[i];
+    if (ch === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (ch === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (inSingleQuote || inDoubleQuote) continue;
+    if (ch === "(") depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+function extractSelectColumnNames(sql: string): string[] {
+  const selectList = extractSelectList(sql);
+  if (!selectList) return [];
+  const names: string[] = [];
+  for (const expression of splitTopLevel(selectList, ",")) {
+    const trimmed = expression.trim();
+    if (trimmed === "*") continue;
+    if (/^[A-Za-z_][\w$]*$/.test(trimmed)) {
+      names.push(trimmed);
+      continue;
+    }
+    const alias = /\bas\s+([A-Za-z_][\w$]*)$/i.exec(trimmed)?.[1];
+    if (alias) {
+      names.push(alias);
+      continue;
+    }
+    const lastId = /([A-Za-z_][\w$]*)$/.exec(trimmed)?.[1];
+    if (lastId) names.push(lastId);
+  }
+  return names;
+}
+
+export function extractCteDefinitions(sql: string): Array<{ name: string; columns: string[] }> {
+  const ctes: Array<{ name: string; columns: string[] }> = [];
+  let lower = sql.toLowerCase();
+  const withMatch = /\bwith\b/.exec(lower);
+  if (!withMatch) return ctes;
+
+  let pos = withMatch.index + "with".length;
+  lower = lower.slice(pos);
+  const recursiveMatch = /^\s+recursive\b/.exec(lower);
+  if (recursiveMatch) {
+    pos += recursiveMatch[0].length;
+  }
+
+  while (pos < sql.length) {
+    while (pos < sql.length && /\s/.test(sql[pos])) pos++;
+    if (pos >= sql.length) break;
+    if (sql[pos] === "," || sql[pos] === ";") {
+      pos++;
+      continue;
+    }
+
+    const remaining = sql.slice(pos);
+    const nameMatch = /^([A-Za-z_][\w$]*)/.exec(remaining);
+    if (!nameMatch) break;
+    const cteName = nameMatch[1];
+    pos += nameMatch[0].length;
+
+    while (pos < sql.length && /\s/.test(sql[pos])) pos++;
+
+    let columns: string[] = [];
+    if (pos < sql.length && sql[pos] === "(") {
+      const colListEnd = findMatchingParen(sql, pos);
+      if (colListEnd !== -1) {
+        const colList = sql.slice(pos + 1, colListEnd).trim();
+        if (!/\bselect\b/i.test(colList)) {
+          columns = colList
+            .split(",")
+            .map((c) => c.trim())
+            .filter(Boolean);
+          pos = colListEnd + 1;
+          while (pos < sql.length && /\s/.test(sql[pos])) pos++;
+        }
+      }
+    }
+
+    while (pos < sql.length && /\s/.test(sql[pos])) pos++;
+    if (/\bas\b/i.test(sql.slice(pos, pos + 5))) {
+      pos += 2;
+      while (pos < sql.length && /\s/.test(sql[pos])) pos++;
+    }
+
+    if (pos >= sql.length || sql[pos] !== "(") break;
+    const bodyEnd = findMatchingParen(sql, pos);
+    if (bodyEnd === -1) break;
+
+    if (columns.length === 0) {
+      const body = sql.slice(pos + 1, bodyEnd);
+      columns = extractSelectColumnNames(body);
+    }
+
+    ctes.push({ name: cteName, columns });
+    pos = bodyEnd + 1;
+  }
+
+  return ctes;
+}
+
+function extractSubqueryReferences(sql: string): SqlCompletionReferencedTable[] {
+  const refs: SqlCompletionReferencedTable[] = [];
+  const pattern = /\b(?:from|join)\s*\(/gi;
+
+  for (const match of sql.matchAll(pattern)) {
+    const openParen = match.index! + match[0].length - 1;
+    const closeParen = findMatchingParen(sql, openParen);
+    if (closeParen === -1) continue;
+
+    // Extract alias after closing paren
+    let pos = closeParen + 1;
+    while (pos < sql.length && /\s/.test(sql[pos])) pos++;
+    if (/\bas\b/i.test(sql.slice(pos, pos + 4))) {
+      pos += 2;
+      while (pos < sql.length && /\s/.test(sql[pos])) pos++;
+    }
+    const aliasMatch = /^([A-Za-z_][\w$]*)/.exec(sql.slice(pos));
+    if (!aliasMatch) continue;
+    const alias = aliasMatch[1];
+    if (ALIAS_BLACKLIST_FOR_REF.has(alias.toLowerCase())) continue;
+
+    // Extract SELECT columns from subquery body
+    const body = sql.slice(openParen + 1, closeParen);
+    const columns = extractSelectColumnNames(body);
+
+    refs.push({ name: alias, alias, columns });
+  }
+
+  return refs;
+}
+
+const ALIAS_BLACKLIST_FOR_REF = new Set(["where", "group", "order", "having", "limit", "offset", "union", "intersect", "except", "and", "or", "not", "is", "like", "in", "between", "exists", "select", "on", "set", "left", "right", "inner", "outer", "cross", "full", "natural", "join"]);
+
+function splitTopLevel(text: string, separator: string): string[] {
+  const parts: string[] = [];
+  let start = 0;
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (ch === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (inSingleQuote || inDoubleQuote) continue;
+    if (ch === "(") depth++;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    else if (ch === separator && depth === 0) {
+      parts.push(text.slice(start, i));
+      start = i + 1;
+    }
+  }
+
+  parts.push(text.slice(start));
+  return parts;
+}
+
+function splitQualifiedName(input: string): [string | undefined, string | undefined] {
+  const parts: string[] = [];
+  let current = "";
+  let inDoubleQuote = false;
+  let inBacktick = false;
+
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === '"' && !inBacktick) {
+      inDoubleQuote = !inDoubleQuote;
+      current += ch;
+      continue;
+    }
+    if (ch === "`" && !inDoubleQuote) {
+      inBacktick = !inBacktick;
+      current += ch;
+      continue;
+    }
+    if (ch === "." && !inDoubleQuote && !inBacktick) {
+      parts.push(current.trim());
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) parts.push(current.trim());
+
+  const unquoted = parts.map((p) => unquoteIdentifier(p)).filter(Boolean);
+  // For three-part names, the completion model can carry schema.table today;
+  // keep the table as the final segment instead of accidentally using catalog.schema.
+  if (unquoted.length >= 2) return [unquoted[unquoted.length - 2], unquoted[unquoted.length - 1]];
+  return [unquoted[0], undefined];
+}
+
+function unquoteIdentifier(value: string): string {
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("`") && value.endsWith("`"))) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+
+function quoteSqlIdentifier(identifier: string, dialect?: "mysql" | "postgres" | "sqlserver"): string {
+  if (dialect !== "postgres" || !requiresPostgresIdentifierQuote(identifier)) return identifier;
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+
+function requiresPostgresIdentifierQuote(identifier: string): boolean {
+  if (!/^[a-z_][a-z0-9_$]*$/.test(identifier)) return true;
+  return POSTGRES_IDENTIFIER_KEYWORDS.has(identifier);
+}
+
+const POSTGRES_IDENTIFIER_KEYWORDS = new Set(SQL_KEYWORDS.map((keyword) => keyword.toLowerCase()).concat(["current_user", "session_user", "user"]));
+
+function buildTableItems(prefix: string, tables: SqlCompletionTable[], dialect?: "mysql" | "postgres" | "sqlserver", autoAliasTables = false, referencedTables: SqlCompletionReferencedTable[] = [], databaseType?: DatabaseType): SqlCompletionItem[] {
+  const existingAliases = new Set(referencedTables.map((ref) => ref.alias?.toLowerCase()).filter((alias): alias is string => !!alias));
+  return tables
+    .filter((table) => matchesPrefix(table.name, prefix))
+    .map((table) => {
+      const applyName = quoteSqlIdentifier(table.name, dialect);
+      const alias = autoAliasTables ? generateTableCompletionAlias(table.name, existingAliases) : "";
+      return {
+        label: table.name,
+        type: "table" as const,
+        detail: table.schema ? `${table.schema}.${table.name}` : table.type,
+        apply: formatTableAliasApply(applyName, alias, databaseType),
+        boost: computeBoost(table.name, prefix) + 1000,
+      };
+    })
+    .sort(compareCompletionItems)
+    .slice(0, MAX_TABLE_COMPLETION_ITEMS);
+}
+
+function buildForeignKeyRelatedTableItems(context: SqlCompletionContext, tables: SqlCompletionTable[], foreignKeysByTable?: Map<string, SqlCompletionForeignKey[]>, dialect?: "mysql" | "postgres" | "sqlserver"): SqlCompletionItem[] {
+  if (!foreignKeysByTable || context.referencedTables.length === 0) return [];
+  const candidates = new Map<string, { table: SqlCompletionTable; detail: string }>();
+  for (const ref of context.referencedTables) {
+    for (const [ownerKey, foreignKeys] of foreignKeysByTable.entries()) {
+      const owner = foreignKeyOwnerFromKey(ownerKey);
+      for (const foreignKey of foreignKeys) {
+        if (referencedTableMatchesName(ref, owner.name, owner.schema)) {
+          const target = findCompletionTable(tables, foreignKey.ref_table, foreignKey.ref_schema);
+          if (target && matchesPrefix(target.name, context.prefix)) {
+            candidates.set(`${target.schema ?? ""}.${target.name}`.toLowerCase(), { table: target, detail: `related by ${foreignKey.column} → ${qualifiedCompletionName(foreignKey.ref_table, foreignKey.ref_schema)}.${foreignKey.ref_column}` });
+          }
+        } else if (referencedTableMatchesName(ref, foreignKey.ref_table, foreignKey.ref_schema)) {
+          const target = findCompletionTable(tables, owner.name, owner.schema);
+          if (target && matchesPrefix(target.name, context.prefix)) {
+            candidates.set(`${target.schema ?? ""}.${target.name}`.toLowerCase(), { table: target, detail: `related by ${qualifiedCompletionName(owner.name, owner.schema)}.${foreignKey.column} → ${foreignKey.ref_column}` });
+          }
+        }
+      }
+    }
+  }
+
+  return [...candidates.values()]
+    .map(({ table, detail }) => ({
+      label: table.name,
+      type: "table" as const,
+      detail,
+      apply: quoteSqlIdentifier(table.name, dialect),
+      boost: computeBoost(table.name, context.prefix) + 3600,
+    }))
+    .sort(compareCompletionItems);
+}
+
+function foreignKeyOwnerFromKey(ownerKey: string): { name: string; schema?: string } {
+  const parts = ownerKey.split(".").filter(Boolean);
+  const name = parts.pop() ?? ownerKey;
+  const schema = parts.pop();
+  return { name, schema };
+}
+
+function qualifiedCompletionName(name: string, schema?: string | null): string {
+  return schema ? `${schema}.${name}` : name;
+}
+
+function findCompletionTable(tables: SqlCompletionTable[], name: string, schema?: string | null): SqlCompletionTable | undefined {
+  const normalizedName = normalizeIdentifierPart(name);
+  const normalizedSchema = schema ? normalizeIdentifierPart(schema) : undefined;
+  return tables.find((table) => normalizeIdentifierPart(table.name) === normalizedName && (!normalizedSchema || !table.schema || normalizeIdentifierPart(table.schema) === normalizedSchema));
+}
+
+function buildSchemaItems(prefix: string, schemas: string[], dialect?: "mysql" | "postgres" | "sqlserver"): SqlCompletionItem[] {
+  return schemas
+    .filter((schema) => matchesPrefix(schema, prefix))
+    .slice(0, 50)
+    .map((schema) => ({
+      label: schema,
+      type: "schema" as const,
+      detail: "schema",
+      apply: `${quoteSqlIdentifier(schema, dialect)}.`,
+      boost: computeBoost(schema, prefix) + 700,
+    }));
+}
+
+function buildObjectItems(context: SqlCompletionContext, objects: SqlCompletionObject[], dialect?: "mysql" | "postgres" | "sqlserver"): SqlCompletionItem[] {
+  const onlyProcedures = context.exclusiveRoutineSuggestions;
+  return objects
+    .filter((object) => (!onlyProcedures || object.type === "procedure") && objectMatchesCompletionContext(object, context))
+    .map((object) => {
+      const qualifiedByContext = objectIsQualifiedByContext(object, context);
+      const applyName =
+        qualifiedByContext || (context.qualifier && object.schema?.toLowerCase() === context.qualifier.toLowerCase())
+          ? quoteSqlIdentifier(object.name, dialect)
+          : object.schema
+            ? `${quoteSqlIdentifier(object.schema, dialect)}.${quoteSqlIdentifier(object.name, dialect)}`
+            : quoteSqlIdentifier(object.name, dialect);
+      const detail = object.type === "trigger" && object.parentName ? `trigger on ${object.parentName}` : object.parentName ? `${object.type} in ${object.parentName}` : object.schema ? `${object.type} in ${object.schema}` : object.type;
+      return {
+        label: object.name,
+        type: "function" as const,
+        detail,
+        apply: object.type === "trigger" || object.type === "package" ? applyName : `${applyName}()`,
+        boost: computeBoost(object.name, context.prefix) + (object.type === "procedure" ? 1800 : object.type === "package" ? 1600 : 900),
+        // Preserve exact routine matches before the capped candidate list is truncated.
+        exactMatch: !!context.prefix && object.name.toLowerCase() === context.prefix.toLowerCase(),
+      };
+    })
+    .sort(compareCompletionItems)
+    .slice(0, MAX_TABLE_COMPLETION_ITEMS);
+}
+
+function objectIsQualifiedByContext(object: SqlCompletionObject, context: SqlCompletionContext): boolean {
+  if (!context.qualifier || !object.parentName) return false;
+  const qualifier = context.qualifier.toLowerCase();
+  const qualifierParts = qualifier.split(".").filter(Boolean);
+  const qualifierSchema = qualifierParts.length > 1 ? qualifierParts[qualifierParts.length - 2] : undefined;
+  const qualifierPackage = qualifierParts[qualifierParts.length - 1];
+  return object.parentName.toLowerCase() === qualifier || (!!qualifierPackage && object.parentName.toLowerCase() === qualifierPackage && (!qualifierSchema || !object.parentSchema || object.parentSchema.toLowerCase() === qualifierSchema));
+}
+
+function objectMatchesCompletionContext(object: SqlCompletionObject, context: SqlCompletionContext): boolean {
+  if (context.oracleTableFunctionContext && object.type !== "function") return false;
+  if (context.qualifier) {
+    const qualifier = context.qualifier.toLowerCase();
+    const qualifierParts = qualifier.split(".").filter(Boolean);
+    const qualifierSchema = qualifierParts.length > 1 ? qualifierParts[qualifierParts.length - 2] : undefined;
+    const qualifierPackage = qualifierParts[qualifierParts.length - 1];
+    if (object.parentName && object.parentName.toLowerCase() === qualifier) return matchesPrefix(object.name, context.prefix);
+    if (object.parentName && qualifierPackage && object.parentName.toLowerCase() === qualifierPackage && (!qualifierSchema || !object.parentSchema || object.parentSchema.toLowerCase() === qualifierSchema)) return matchesPrefix(object.name, context.prefix);
+    if (object.schema && object.schema.toLowerCase() === qualifier) return matchesPrefix(object.name, context.prefix);
+    if (object.parentSchema && `${object.parentSchema}.${object.parentName ?? ""}`.toLowerCase() === qualifier) return matchesPrefix(object.name, context.prefix);
+  }
+  return matchesPrefix(object.name, context.prefix);
+}
+
+function buildOracleTableFunctionItems(prefix: string): SqlCompletionItem[] {
+  const items = [
+    { label: "TABLE", detail: "Oracle table function", apply: "TABLE(${function_call})" },
+    { label: "THE", detail: "Oracle nested-table expression", apply: "THE(${subquery})" },
+    { label: "XMLTABLE", detail: "XML to relational rows", apply: "XMLTABLE(${xpath})" },
+    { label: "JSON_TABLE", detail: "JSON to relational rows", apply: "JSON_TABLE(${expr}, ${path})" },
+  ];
+  return items
+    .filter((item) => matchesPrefix(item.label, prefix))
+    .map((item) => ({
+      ...item,
+      type: "function" as const,
+      boost: computeBoost(item.label, prefix) + 600,
+    }));
+}
+
+function applySqlKeywordCase(value: string, keywordCase?: SqlKeywordCase): string {
+  if (keywordCase === "lower") return value.toLowerCase();
+  return value.toUpperCase();
+}
+
+function keywordJoiner(keywordCase?: SqlKeywordCase): string {
+  return keywordCase === "lower" ? " and " : " AND ";
+}
+
+function shouldFormatBuiltinSnippet(snippet: SqlSnippet): boolean {
+  return snippet.id.startsWith("builtin-");
+}
+
+function applyBuiltinSnippetKeywordCase(snippet: SqlSnippet, text: string, keywordCase?: SqlKeywordCase): string {
+  if (!shouldFormatBuiltinSnippet(snippet)) return text;
+  if (keywordCase === "lower") return text.toLowerCase();
+  return text;
+}
+
+const BUILTIN_SNIPPET_PLACEHOLDER_RE = /\b(idx_name|left_column|right_column|columns|values|condition|column|default|value|name|type|table)\b/g;
+
+function applyBuiltinSnippetPlaceholders(snippet: SqlSnippet): string {
+  if (!shouldFormatBuiltinSnippet(snippet)) return snippet.body;
+  return snippet.body.replace(BUILTIN_SNIPPET_PLACEHOLDER_RE, (match) => `\${${match}}`);
+}
+
+function buildPreferredKeywordItems(prefix: string, keywords: string[], keywordCase?: SqlKeywordCase): SqlCompletionItem[] {
+  return keywords
+    .filter((keyword) => matchesPrefix(keyword, prefix))
+    .map((keyword, index) => ({
+      label: applySqlKeywordCase(keyword, keywordCase),
+      type: "keyword" as const,
+      boost: computeBoost(keyword, prefix) + 6200 - index,
+    }));
+}
+
+function buildStarExpansionItem(context: SqlCompletionContext, columnsByTable: Map<string, SqlCompletionColumn[]>, t?: SqlCompletionTranslations, dialect?: "mysql" | "postgres" | "sqlserver"): SqlCompletionItem | null {
+  const columns = context.qualifier ? referencedTablesForSelectAllColumns(context).flatMap((ref) => columnsForSelectAllReferencedTable(ref, columnsByTable)) : [...columnsByTable.values()].flat();
+  const uniqueColumns = uniqueColumnsByName(columns);
+  if (uniqueColumns.length === 0) return null;
+  // `alias.*` replaces only the `*`, so the first column must continue the already typed `alias.`.
+  const expansion = context.qualifier ? buildSelectAllColumnExpansion(uniqueColumns, context.qualifier, true, dialect) : uniqueColumns.map((column) => quoteSqlIdentifier(column.name, dialect)).join(", ");
+  return {
+    label: "* → columns",
+    type: "snippet" as const,
+    detail: `${(t?.starExpansionColumns ?? "{count} columns").replace("{count}", String(uniqueColumns.length))}: ${expansion.length > 60 ? expansion.slice(0, 57) + "..." : expansion}`,
+    apply: expansion,
+    boost: 1900,
+  };
+}
+
+function buildSelectAllColumnItems(context: SqlCompletionContext, columnsByTable: Map<string, SqlCompletionColumn[]>, t?: SqlCompletionTranslations, dialect?: "mysql" | "postgres" | "sqlserver"): SqlCompletionItem[] {
+  if (!context.selectListColumnContext || context.statementKind !== "select" || context.onStar || context.referencedTables.length === 0) {
+    return [];
+  }
+
+  const items: SqlCompletionItem[] = [];
+  const emittedRefs = new Set<string>();
+  const targetRefs = referencedTablesForSelectAllColumns(context);
+  const shouldQualify = !!context.qualifier || context.referencedTables.length > 1;
+
+  for (const ref of targetRefs) {
+    const displayRef = context.qualifier || ref.alias || ref.name;
+    const refKey = `${displayRef}.${ref.schema ?? ""}.${ref.name}`.toLowerCase();
+    if (emittedRefs.has(refKey)) continue;
+    emittedRefs.add(refKey);
+
+    const columns = uniqueColumnsByName(columnsForSelectAllReferencedTable(ref, columnsByTable));
+    if (columns.length === 0) continue;
+
+    const label = `${displayRef}.*`;
+    if (!selectAllColumnItemMatchesPrefix(label, ref, columns, context.prefix)) continue;
+
+    const qualifier = context.qualifier || ref.alias || (shouldQualify ? quoteSqlIdentifier(ref.name, dialect) : undefined);
+    const expansion = buildSelectAllColumnExpansion(columns, qualifier, !!context.qualifier, dialect);
+    const countText = (t?.starExpansionColumns ?? "{count} columns").replace("{count}", String(columns.length));
+    items.push({
+      label,
+      type: "snippet" as const,
+      detail: `${countText}: ${expansion.length > 60 ? expansion.slice(0, 57) + "..." : expansion}`,
+      apply: expansion,
+      boost: 2400 + selectAllColumnItemPrefixBoost(label, ref, columns, context.prefix) - items.length,
+    });
+  }
+
+  return items;
+}
+
+function buildInsertAllColumnItems(context: SqlCompletionContext, columnsByTable: Map<string, SqlCompletionColumn[]>, t?: SqlCompletionTranslations, dialect?: "mysql" | "postgres" | "sqlserver"): SqlCompletionItem[] {
+  if (!context.insertTable) return [];
+  const columns = uniqueColumnsByName(columnsForInsertTarget(context, columnsByTable));
+  if (columns.length === 0) return [];
+
+  const label = `${context.insertTable}.*`;
+  if (!selectAllColumnItemMatchesPrefix(label, { name: context.insertTable, schema: context.insertSchema }, columns, context.prefix)) return [];
+
+  const expansion = columns.map((column) => quoteSqlIdentifier(column.name, dialect)).join(", ");
+  const countText = (t?.starExpansionColumns ?? "{count} columns").replace("{count}", String(columns.length));
+  return [
+    {
+      label,
+      type: "snippet" as const,
+      detail: `${countText}: ${expansion.length > 60 ? expansion.slice(0, 57) + "..." : expansion}`,
+      apply: expansion,
+      boost: 2450 + selectAllColumnItemPrefixBoost(label, { name: context.insertTable, schema: context.insertSchema }, columns, context.prefix),
+    },
+  ];
+}
+
+function referencedTablesForSelectAllColumns(context: SqlCompletionContext): SqlCompletionReferencedTable[] {
+  if (!context.qualifier) return context.referencedTables;
+  const qualifier = context.qualifier;
+  const qualifierLower = qualifier.toLowerCase();
+  const qualifiedTarget = qualifiedTableTargetFromContext(context);
+  return context.referencedTables.filter((table) => referencedTableMatchesColumnQualifier(table, qualifier, qualifierLower, qualifiedTarget));
+}
+
+function buildSelectAllColumnExpansion(columns: SqlCompletionColumn[], qualifier: string | undefined, qualifierAlreadyTyped: boolean, dialect?: "mysql" | "postgres" | "sqlserver"): string {
+  return columns
+    .map((column, index) => {
+      const columnName = quoteSqlIdentifier(column.name, dialect);
+      if (!qualifier || (qualifierAlreadyTyped && index === 0)) return columnName;
+      return `${qualifier}.${columnName}`;
+    })
+    .join(", ");
+}
+
+function columnsForSelectAllReferencedTable(table: SqlCompletionReferencedTable, columnsByTable: Map<string, SqlCompletionColumn[]>): SqlCompletionColumn[] {
+  const columns = columnsForReferencedTable(table, columnsByTable);
+  if (columns.length > 0) return columns;
+  if (!table.columns || table.columns.length === 0) return [];
+  return table.columns.map((name) => ({ name, table: table.name, schema: table.schema }));
+}
+
+function uniqueColumnsByName(columns: SqlCompletionColumn[]): SqlCompletionColumn[] {
+  const seen = new Set<string>();
+  const unique: SqlCompletionColumn[] = [];
+  for (const column of columns) {
+    const key = normalizeIdentifierPart(column.name);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(column);
+  }
+  return unique;
+}
+
+function selectAllColumnItemMatchesPrefix(label: string, ref: SqlCompletionReferencedTable, columns: SqlCompletionColumn[], prefix: string): boolean {
+  if (!prefix) return true;
+  if (matchesPrefix(label, prefix) || matchesPrefix(ref.name, prefix) || (!!ref.alias && matchesPrefix(ref.alias, prefix))) return true;
+  return columns.some((column) => matchesPrefix(column.name, prefix));
+}
+
+function selectAllColumnItemPrefixBoost(label: string, ref: SqlCompletionReferencedTable, columns: SqlCompletionColumn[], prefix: string): number {
+  if (!prefix) return 0;
+  const scores = [computeBoost(label, prefix), computeBoost(ref.name, prefix), ref.alias ? computeBoost(ref.alias, prefix) : -1, ...columns.map((column) => computeBoost(column.name, prefix))];
+  return Math.min(Math.max(...scores, 0), 1000);
+}
+
+function buildComparisonValueItems(context: SqlCompletionContext, columnsByTable: Map<string, SqlCompletionColumn[]>, t?: SqlCompletionTranslations, keywordCase?: SqlKeywordCase): SqlCompletionItem[] {
+  const colName = context.comparisonLeftColumn!;
+  const parts = colName.split(".");
+  const unqualified = parts.length > 1 ? parts[parts.length - 1]! : colName;
+  const qualifier = parts.length > 1 ? parts[0] : undefined;
+
+  // Resolve alias to actual table name
+  let resolvedTable: string | undefined;
+  if (qualifier) {
+    const ref = context.referencedTables.find((r) => r.alias?.toLowerCase() === qualifier.toLowerCase());
+    resolvedTable = ref?.name?.toLowerCase();
+  }
+
+  // Find the column's data type
+  let dataType: string | undefined;
+  for (const [, cols] of columnsByTable) {
+    for (const col of cols) {
+      if (col.name.toLowerCase() === unqualified.toLowerCase()) {
+        if (qualifier) {
+          const qualLower = qualifier.toLowerCase();
+          if (col.table.toLowerCase() === qualLower || col.schema?.toLowerCase() === qualLower || col.table.toLowerCase() === resolvedTable) {
+            dataType = col.dataType;
+            break;
+          }
+        } else {
+          dataType = col.dataType;
+          break;
+        }
+      }
+    }
+    if (dataType) break;
+  }
+
+  const items: SqlCompletionItem[] = [];
+
+  // NULL check — always useful
+  items.push({
+    label: applySqlKeywordCase("NULL", keywordCase),
+    type: "keyword" as const,
+    detail: t?.nullValue ?? "NULL value",
+    boost: 1300,
+  });
+  items.push({
+    label: applySqlKeywordCase("IS NULL", keywordCase),
+    type: "keyword" as const,
+    detail: t?.isNull ?? "Checks whether the value is NULL",
+    boost: 1250,
+  });
+  items.push({
+    label: applySqlKeywordCase("IS NOT NULL", keywordCase),
+    type: "keyword" as const,
+    detail: t?.isNotNull ?? "Checks whether the value is not NULL",
+    boost: 1200,
+  });
+
+  if (!dataType) return items;
+
+  const prefix = context.prefix;
+  const dt = dataType.toLowerCase();
+
+  // String-like types: suggest quoted string snippet
+  if (dt.includes("char") || dt.includes("text") || dt === "varchar" || dt === "nvarchar" || dt === "ntext") {
+    if (matchesPrefix("''", prefix) || !prefix) {
+      items.push({
+        label: "''",
+        type: "snippet" as const,
+        detail: t?.stringLiteral ?? "String literal",
+        apply: "'${value}'",
+        boost: 1800,
+      });
+    }
+  }
+
+  // Numeric types: suggest number placeholder
+  if (dt.includes("int") || dt.includes("decimal") || dt.includes("numeric") || dt.includes("float") || dt.includes("real") || dt.includes("money") || dt === "bigint" || dt === "smallint" || dt === "tinyint") {
+    if (matchesPrefix("0", prefix) || !prefix) {
+      items.push({
+        label: "0",
+        type: "snippet" as const,
+        detail: t?.numericLiteral ?? "Numeric literal",
+        apply: "${1:value}",
+        boost: 1750,
+      });
+    }
+  }
+
+  // Boolean-ish: tinyint or bit
+  if (dt === "bit" || dt === "boolean" || dt === "bool") {
+    items.push({ label: "TRUE", type: "keyword" as const, detail: t?.booleanValue ?? "Boolean value", boost: 1700 }, { label: "FALSE", type: "keyword" as const, detail: t?.booleanValue ?? "Boolean value", boost: 1650 });
+  }
+
+  return items;
+}
+
+function buildAliasItems(context: SqlCompletionContext, databaseType?: DatabaseType): SqlCompletionItem[] {
+  const items: SqlCompletionItem[] = [];
+  const existingAliases = new Set(context.referencedTables.map((ref) => ref.alias?.toLowerCase()).filter((alias): alias is string => !!alias));
+  const seen = new Set<string>(existingAliases);
+  for (const ref of context.referencedTables) {
+    if (ref.alias) continue;
+    if (context.prefix && !matchesPrefix(ref.name, context.prefix)) continue;
+    const candidate = generateAlias(ref.name, seen);
+    if (!candidate || seen.has(candidate.toLowerCase())) continue;
+    seen.add(candidate.toLowerCase());
+    items.push({
+      label: candidate,
+      type: "snippet" as const,
+      detail: `alias for ${ref.name}`,
+      apply: formatAliasCompletionApply(candidate, databaseType),
+      boost: 1600 - items.length,
+    });
+  }
+  return items;
+}
+
+function formatTableAliasApply(tableName: string, alias: string, databaseType?: DatabaseType): string {
+  if (!alias) return tableName;
+  return isOracleLikeDatabase(databaseType) ? `${tableName} ${alias}` : `${tableName} AS ${alias}`;
+}
+
+function formatAliasCompletionApply(alias: string, databaseType?: DatabaseType): string {
+  return isOracleLikeDatabase(databaseType) ? `${alias} ` : `AS ${alias} `;
+}
+
+function generateAlias(tableName: string, existing = new Set<string>()): string {
+  const candidates = buildAliasCandidates(tableName);
+
+  for (const candidate of candidates.filter(Boolean)) {
+    if (!aliasConflicts(candidate, existing)) return candidate;
+  }
+
+  const fallback = candidates.find(Boolean) ?? "tb";
+  for (let index = 2; index < 100; index++) {
+    const candidate = `${fallback}${index}`;
+    if (!aliasConflicts(candidate, existing)) return candidate;
+  }
+  return fallback;
+}
+
+function generateTableCompletionAlias(tableName: string, existing = new Set<string>()): string {
+  const candidates = buildAliasCandidates(tableName);
+
+  for (const candidate of candidates.filter(Boolean)) {
+    if (isUnsafeSqlAlias(candidate.toLowerCase())) continue;
+    if (!existing.has(candidate.toLowerCase())) return candidate;
+    for (let index = 2; index < 100; index++) {
+      const numbered = `${candidate}${index}`;
+      if (!aliasConflicts(numbered, existing)) return numbered;
+    }
+  }
+
+  return generateAlias(tableName, existing);
+}
+
+function buildAliasCandidates(tableName: string): string[] {
+  const parts = identifierWords(tableName);
+  const candidates: string[] = [];
+
+  if (parts.length > 1) {
+    const initials = parts.map((part) => part[0]).join("");
+    if (initials.length >= 2) candidates.push(initials.slice(0, 2));
+    if (initials.length >= 3) candidates.push(initials.slice(0, 3));
+    candidates.push(parts[0].slice(0, 2), parts[0].slice(0, 3));
+  } else {
+    const name = parts[0] ?? tableName.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const chars = [...name];
+    const consonants = chars.slice(1).filter((ch) => /[a-z]/.test(ch) && !"aeiou".includes(ch));
+    if (chars.length <= 3) candidates.push(name);
+    if (chars.length >= 2 && consonants[0]) candidates.push(`${chars[0]}${consonants[0]}`);
+    if (chars.length >= 2) candidates.push(chars.slice(0, 2).join(""));
+    if (chars.length >= 3 && consonants.length >= 2) candidates.push(`${chars[0]}${consonants[0]}${consonants[1]}`);
+    if (chars.length >= 3) candidates.push(chars.slice(0, 3).join(""));
+  }
+
+  return candidates;
+}
+
+function aliasConflicts(candidate: string, existing: Set<string>): boolean {
+  const lower = candidate.toLowerCase();
+  return existing.has(lower) || isUnsafeSqlAlias(lower);
+}
+
+function isUnsafeSqlAlias(candidate: string): boolean {
+  return SQL_ALIAS_RESERVED_WORDS.has(candidate) || SQL_ALIAS_KEYWORD_WORDS.has(candidate);
+}
+
+function isFollowedByJoin(beforeToken: string): boolean {
+  const words = beforeToken.trimEnd().split(/\s+/);
+  const second = words[words.length - 2]?.toLowerCase();
+  return second === "join" || JOIN_MODIFIERS.has(second ?? "");
+}
+
+function isInTableListContext(beforeToken: string): boolean {
+  if (isInOrderOrGroupByContext(beforeToken)) return false;
+  const cleaned = stripSqlLiterals(beforeToken).trimEnd();
+  if (!/,\s*$/.test(cleaned)) return false;
+
+  // Only commas in the active top-level table segment should continue table completion.
+  const lastTableIntro = Math.max(lastTopLevelKeywordIndex(cleaned, "from"), lastTopLevelKeywordIndex(cleaned, "join"), lastTopLevelKeywordIndex(cleaned, "update"), lastTopLevelKeywordIndex(cleaned, "into"));
+  if (lastTableIntro < 0) return false;
+
+  const lastBoundary = Math.max(
+    lastTopLevelKeywordIndex(cleaned, "where"),
+    lastTopLevelKeywordIndex(cleaned, "set"),
+    lastTopLevelKeywordIndex(cleaned, "group"),
+    lastTopLevelKeywordIndex(cleaned, "order"),
+    lastTopLevelKeywordIndex(cleaned, "having"),
+    lastTopLevelKeywordIndex(cleaned, "limit"),
+    lastTopLevelKeywordIndex(cleaned, "offset"),
+    lastTopLevelKeywordIndex(cleaned, "union"),
+    lastTopLevelKeywordIndex(cleaned, "intersect"),
+    lastTopLevelKeywordIndex(cleaned, "except"),
+  );
+  return lastBoundary < lastTableIntro;
+}
+
+function collectCompletionColumns(columnsByTable: Map<string, SqlCompletionColumn[]>): Array<SqlCompletionColumn & { key: string }> {
+  const allColumns: Array<SqlCompletionColumn & { key: string }> = [];
+  for (const [key, cols] of columnsByTable.entries()) {
+    for (const col of cols) {
+      allColumns.push({ ...col, key });
+    }
+  }
+  return allColumns;
+}
+
+function columnsForInsertTarget(context: SqlCompletionContext, columnsByTable: Map<string, SqlCompletionColumn[]>): Array<SqlCompletionColumn & { key: string }> {
+  if (!context.insertTable) return [];
+  const tableKey = normalizeIdentifierPart(context.insertTable);
+  const schemaKey = context.insertSchema ? normalizeIdentifierPart(context.insertSchema) : undefined;
+  const qualifiedKey = schemaKey ? normalizeCompletionKey(`${context.insertSchema}.${context.insertTable}`) : undefined;
+  return collectCompletionColumns(columnsByTable).filter((column) => {
+    if (normalizeIdentifierPart(column.table) !== tableKey) return false;
+    if (!schemaKey) return true;
+    if (column.schema && normalizeIdentifierPart(column.schema) === schemaKey) return true;
+    return !!qualifiedKey && normalizeCompletionKey(column.key) === qualifiedKey;
+  });
+}
+
+function buildColumnItems(context: SqlCompletionContext, columnsByTable: Map<string, SqlCompletionColumn[]>, dialect?: "mysql" | "postgres" | "sqlserver"): SqlCompletionItem[] {
+  // Collect all columns from the map (all tables have been fetched)
+  const allColumns = collectCompletionColumns(columnsByTable);
+
+  // Handle INSERT column list: filter to only the target table
+  let relevantCols = allColumns;
+  if (context.insertTable) {
+    relevantCols = columnsForInsertTarget(context, columnsByTable);
+  } else if (context.qualifier) {
+    const q = context.qualifier;
+    const qLower = q.toLowerCase();
+    const qualifiedTarget = qualifiedTableTargetFromContext(context);
+    const relatedTables = context.referencedTables.filter((table) => referencedTableMatchesColumnQualifier(table, q, qLower, qualifiedTarget));
+    relevantCols = allColumns.filter((column) => relatedTables.some((table) => columnMatchesReferencedTable(column, table)) || (!!qualifiedTarget && columnMatchesQualifiedTable(column, qualifiedTarget)));
+  } else if (context.referencedTables.length > 0) {
+    relevantCols = allColumns.filter((column) => context.referencedTables.some((table) => columnMatchesReferencedTable(column, table)));
+  }
+
+  // Count name frequencies to detect duplicates across tables
+  const nameCount = new Map<string, number>();
+  for (const c of relevantCols) {
+    nameCount.set(c.name, (nameCount.get(c.name) || 0) + 1);
+  }
+
+  // Deduplicate — for dupes, qualify with table name
+  const seen = new Set<string>();
+  const uniqueColumns: Array<SqlCompletionColumn & { key: string; displayLabel: string }> = [];
+  for (const c of relevantCols) {
+    const count = nameCount.get(c.name) || 0;
+    if (count > 1) {
+      const qualifiedKey = `${c.table}.${c.name}`;
+      if (seen.has(qualifiedKey)) continue;
+      seen.add(qualifiedKey);
+      uniqueColumns.push({ ...c, key: c.key, displayLabel: `${c.table}.${c.name}` });
+    } else {
+      if (seen.has(c.name)) continue;
+      seen.add(c.name);
+      uniqueColumns.push({ ...c, key: c.key, displayLabel: c.name });
+    }
+  }
+
+  // When the query already references concrete tables (or we are after a
+  // "table." qualifier / in an INSERT column list), the columns of those
+  // tables are what the user is most likely picking — boost them above plain
+  // keywords so they rank at the top instead of being interleaved.
+  const relevanceBoost = context.referencedTables.length > 0 || !!context.qualifier || !!context.insertTable ? 2000 : 0;
+
+  return uniqueColumns
+    .filter((column) => matchesPrefix(column.displayLabel, context.prefix))
+    .map((column) => {
+      const keyBoost = isKeyColumn(column.name) ? 500 : 0;
+      return {
+        label: column.displayLabel,
+        type: "column" as const,
+        detail: buildColumnDetail(column),
+        info: buildColumnInfo(column),
+        apply: buildColumnApply(column, context, dialect),
+        boost: computeBoost(column.displayLabel, context.prefix) + keyBoost + relevanceBoost,
+      };
+    })
+    .sort(compareCompletionItems);
+}
+
+function hasMatchingReferencedColumnPrefix(context: SqlCompletionContext, columnsByTable: Map<string, SqlCompletionColumn[]>): boolean {
+  if (!context.suggestColumns || !context.prefix || context.referencedTables.length === 0) return false;
+
+  for (const [key, cols] of columnsByTable.entries()) {
+    for (const column of cols) {
+      if (!matchesPrefix(column.name, context.prefix)) continue;
+      if (context.referencedTables.some((table) => columnMatchesReferencedTable({ ...column, key }, table))) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+function qualifiedTableTargetFromContext(context: SqlCompletionContext): { schema: string; table: string } | null {
+  const parts = context.qualifierParts ?? context.qualifier?.split(".").filter(Boolean) ?? [];
+  if (parts.length < 2) return null;
+  const table = parts[parts.length - 1];
+  const schema = parts[parts.length - 2];
+  if (!schema || !table) return null;
+  return { schema, table };
+}
+
+function referencedTableMatchesColumnQualifier(table: SqlCompletionReferencedTable, qualifier: string, qualifierLower: string, qualifiedTarget: { schema: string; table: string } | null): boolean {
+  if (table.alias === qualifier || table.alias?.toLowerCase() === qualifierLower) return true;
+  if (table.name === qualifier || table.name.toLowerCase() === qualifierLower) return true;
+  if (!qualifiedTarget) return false;
+  if (normalizeIdentifierPart(table.name) !== normalizeIdentifierPart(qualifiedTarget.table)) return false;
+  return !table.schema || normalizeIdentifierPart(table.schema) === normalizeIdentifierPart(qualifiedTarget.schema);
+}
+
+function columnMatchesReferencedTable(column: SqlCompletionColumn & { key: string }, table: SqlCompletionReferencedTable): boolean {
+  if (normalizeIdentifierPart(column.table) !== normalizeIdentifierPart(table.name)) return false;
+  if (!table.schema) return true;
+  return columnMatchesQualifiedTable(column, { schema: table.schema, table: table.name });
+}
+
+function columnMatchesQualifiedTable(column: SqlCompletionColumn & { key: string }, target: { schema: string; table: string }): boolean {
+  if (normalizeIdentifierPart(column.table) !== normalizeIdentifierPart(target.table)) return false;
+  if (column.schema && normalizeIdentifierPart(column.schema) === normalizeIdentifierPart(target.schema)) return true;
+  return normalizeCompletionKey(column.key) === normalizeCompletionKey(`${target.schema}.${target.table}`);
+}
+
+function normalizeCompletionKey(key: string): string {
+  return key
+    .split(".")
+    .filter(Boolean)
+    .map((part) => normalizeIdentifierPart(part))
+    .join(".");
+}
+
+function buildColumnApply(column: SqlCompletionColumn & { displayLabel: string }, context: SqlCompletionContext, dialect?: "mysql" | "postgres" | "sqlserver"): string {
+  if (context.qualifier || column.displayLabel === column.name || !column.displayLabel.includes(".")) {
+    return quoteSqlIdentifier(column.name, dialect);
+  }
+  return `${quoteSqlIdentifier(column.table, dialect)}.${quoteSqlIdentifier(column.name, dialect)}`;
+}
+
+function isKeyColumn(name: string): boolean {
+  const lower = name.toLowerCase();
+  return lower === "id" || lower.endsWith("_id");
+}
+
+function buildColumnDetail(column: SqlCompletionColumn): string {
+  const tableInfo = column.schema ? `${column.schema}.${column.table}` : column.table;
+  let detail = column.dataType ? `${tableInfo}  [${column.dataType}]` : tableInfo;
+  if (column.isNullable === false) {
+    detail += "  NOT NULL";
+  }
+  const comment = column.comment?.trim();
+  if (comment) {
+    detail += `  -- ${comment}`;
+  }
+  return detail;
+}
+
+function buildColumnInfo(column: SqlCompletionColumn): string | undefined {
+  const parts = [
+    column.schema ? `${column.schema}.${column.table}.${column.name}` : `${column.table}.${column.name}`,
+    column.dataType ? `Type: ${column.dataType}` : undefined,
+    column.isNullable === false ? "Nullable: no" : column.isNullable === true ? "Nullable: yes" : undefined,
+    column.comment?.trim() ? `Comment: ${column.comment.trim()}` : undefined,
+  ].filter((part): part is string => !!part);
+  return parts.length > 1 ? parts.join("\n") : undefined;
+}
+
+function buildJoinConditionItems(context: SqlCompletionContext, columnsByTable: Map<string, SqlCompletionColumn[]>, foreignKeysByTable?: Map<string, SqlCompletionForeignKey[]>, dialect?: "mysql" | "postgres" | "sqlserver", keywordCase?: SqlKeywordCase): SqlCompletionItem[] {
+  const refs = context.referencedTables;
+  if (refs.length < 2) return [];
+
+  const latest = refs[refs.length - 1];
+  const previousRefs = refs.slice(0, -1);
+  const items: SqlCompletionItem[] = [];
+
+  for (const previous of previousRefs) {
+    const previousColumns = columnsForReferencedTable(previous, columnsByTable);
+    const latestColumns = columnsForReferencedTable(latest, columnsByTable);
+    items.push(...buildForeignKeyJoinConditionItemsForPair(previous, latest, foreignKeysByTable, context.prefix, dialect, keywordCase), ...buildJoinConditionItemsForPair(previous, previousColumns, latest, latestColumns, context.prefix, dialect, keywordCase));
+  }
+
+  return items;
+}
+
+function columnsForReferencedTable(table: SqlCompletionReferencedTable, columnsByTable: Map<string, SqlCompletionColumn[]>): SqlCompletionColumn[] {
+  const keys = table.schema ? [`${table.schema}.${table.name}`, table.name] : [table.name];
+  for (const key of keys) {
+    const columns = columnsByTable.get(key);
+    if (columns) return columns;
+  }
+  return [];
+}
+
+function foreignKeysForReferencedTable(table: SqlCompletionReferencedTable, foreignKeysByTable?: Map<string, SqlCompletionForeignKey[]>): SqlCompletionForeignKey[] {
+  if (!foreignKeysByTable) return [];
+  const keys = table.schema ? [`${table.schema}.${table.name}`, table.name] : [table.name];
+  for (const key of keys) {
+    const foreignKeys = foreignKeysByTable.get(key);
+    if (foreignKeys) return foreignKeys;
+  }
+  return [];
+}
+
+function buildForeignKeyJoinConditionItemsForPair(left: SqlCompletionReferencedTable, right: SqlCompletionReferencedTable, foreignKeysByTable?: Map<string, SqlCompletionForeignKey[]>, prefix = "", dialect?: "mysql" | "postgres" | "sqlserver", keywordCase?: SqlKeywordCase): SqlCompletionItem[] {
+  if (!foreignKeysByTable) return [];
+  return [
+    ...buildDirectionalForeignKeyJoinConditionItems(left, right, foreignKeysForReferencedTable(left, foreignKeysByTable), prefix, dialect, keywordCase),
+    ...buildDirectionalForeignKeyJoinConditionItems(right, left, foreignKeysForReferencedTable(right, foreignKeysByTable), prefix, dialect, keywordCase),
+  ];
+}
+
+function buildDirectionalForeignKeyJoinConditionItems(owner: SqlCompletionReferencedTable, referenced: SqlCompletionReferencedTable, foreignKeys: SqlCompletionForeignKey[], prefix: string, dialect?: "mysql" | "postgres" | "sqlserver", keywordCase?: SqlKeywordCase): SqlCompletionItem[] {
+  const matchingForeignKeys = foreignKeys.filter((foreignKey) => referencedTableMatchesName(referenced, foreignKey.ref_table, foreignKey.ref_schema));
+  const groups = groupForeignKeysByConstraint(matchingForeignKeys);
+  const items: SqlCompletionItem[] = [];
+
+  for (const group of groups) {
+    const parts = group.map((foreignKey) => buildJoinConditionPart(owner, foreignKey.column, referenced, foreignKey.ref_column, dialect));
+    const joiner = keywordJoiner(keywordCase);
+    const label = parts.map((part) => part.label).join(joiner);
+    if (!label || (prefix && !matchesPrefix(label, prefix))) continue;
+    const apply = parts.map((part) => part.apply).join(joiner);
+    items.push({
+      label,
+      type: "snippet",
+      detail: group.length > 1 ? "JOIN condition from composite foreign key" : "JOIN condition from foreign key",
+      apply,
+      boost: 3200 + group.length,
+    });
+  }
+
+  return items;
+}
+
+function buildJoinConditionPart(owner: SqlCompletionReferencedTable, ownerColumn: string, referenced: SqlCompletionReferencedTable, referencedColumn: string, dialect?: "mysql" | "postgres" | "sqlserver"): { label: string; apply: string } {
+  const ownerRef = owner.alias || owner.name;
+  const referencedRef = referenced.alias || referenced.name;
+  const ownerApplyRef = owner.alias ? owner.alias : quoteSqlIdentifier(owner.name, dialect);
+  const referencedApplyRef = referenced.alias ? referenced.alias : quoteSqlIdentifier(referenced.name, dialect);
+  return {
+    label: `${ownerRef}.${ownerColumn} = ${referencedRef}.${referencedColumn}`,
+    apply: `${ownerApplyRef}.${quoteSqlIdentifier(ownerColumn, dialect)} = ${referencedApplyRef}.${quoteSqlIdentifier(referencedColumn, dialect)}`,
+  };
+}
+
+function groupForeignKeysByConstraint(foreignKeys: SqlCompletionForeignKey[]): SqlCompletionForeignKey[][] {
+  const groups = new Map<string, SqlCompletionForeignKey[]>();
+  for (const foreignKey of foreignKeys) {
+    const key = `${foreignKey.name || `${foreignKey.column}->${foreignKey.ref_table}.${foreignKey.ref_column}`}:${foreignKey.ref_table}`;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key)!.push(foreignKey);
+  }
+  return [...groups.values()];
+}
+
+function referencedTableMatchesName(table: SqlCompletionReferencedTable, candidate: string, candidateSchema?: string | null): boolean {
+  const normalizedCandidate = normalizeTableName(candidate);
+  if (normalizeTableName(table.name) !== normalizedCandidate) return false;
+  if (!candidateSchema || !table.schema) return true;
+  return normalizeIdentifierPart(table.schema) === normalizeIdentifierPart(candidateSchema);
+}
+
+function normalizeTableName(name: string): string {
+  return name
+    .split(".")
+    .filter(Boolean)
+    .pop()!
+    .replace(/^["`[]|["`\]]$/g, "")
+    .toLowerCase();
+}
+
+function normalizeIdentifierPart(name: string): string {
+  return name.replace(/^["`[]|["`\]]$/g, "").toLowerCase();
+}
+
+function buildJoinConditionItemsForPair(left: SqlCompletionReferencedTable, leftColumns: SqlCompletionColumn[], right: SqlCompletionReferencedTable, rightColumns: SqlCompletionColumn[], prefix: string, dialect?: "mysql" | "postgres" | "sqlserver", keywordCase?: SqlKeywordCase): SqlCompletionItem[] {
+  const items: SqlCompletionItem[] = [];
+  const leftRef = left.alias || left.name;
+  const rightRef = right.alias || right.name;
+  const leftApplyRef = left.alias ? left.alias : quoteSqlIdentifier(left.name, dialect);
+  const rightApplyRef = right.alias ? right.alias : quoteSqlIdentifier(right.name, dialect);
+  const leftTableKey = singularTableName(left.name);
+  const rightTableKey = singularTableName(right.name);
+
+  const leftByName = indexColumnsByLowerName(leftColumns);
+  const rightByName = indexColumnsByLowerName(rightColumns);
+  const emittedPairs = new Set<string>();
+
+  const addPair = (leftColumn: SqlCompletionColumn | undefined, rightColumn: SqlCompletionColumn | undefined, boost: number) => {
+    if (!leftColumn || !rightColumn || !areJoinColumnTypesCompatible(leftColumn, rightColumn)) return;
+    const key = `${leftColumn.name.toLowerCase()}:${rightColumn.name.toLowerCase()}`;
+    if (emittedPairs.has(key)) return;
+    emittedPairs.add(key);
+    const label = `${leftRef}.${leftColumn.name} = ${rightRef}.${rightColumn.name}`;
+    if (prefix && !matchesPrefix(label, prefix)) return;
+    const apply = `${leftApplyRef}.${quoteSqlIdentifier(leftColumn.name, dialect)} = ${rightApplyRef}.${quoteSqlIdentifier(rightColumn.name, dialect)}`;
+    items.push({
+      label,
+      type: "snippet",
+      detail: "JOIN condition",
+      apply,
+      boost,
+    });
+  };
+
+  const leftId = leftByName.get("id")?.[0];
+  const rightId = rightByName.get("id")?.[0];
+
+  // Pattern 1: a.id = b.{singular_a}_id  (e.g., users.id = orders.user_id)
+  addPair(leftId, rightByName.get(`${leftTableKey}_id`)?.[0], 2300);
+  // Pattern 2: a.{singular_b}_id = b.id  (e.g., orders.user_id = users.id)
+  addPair(leftByName.get(`${rightTableKey}_id`)?.[0], rightId, 2300);
+
+  // Pattern 3/4: same-name columns, with FK-looking names above generic shared columns.
+  for (const [name, leftMatches] of leftByName.entries()) {
+    if (name === "id") continue;
+    const rightMatches = rightByName.get(name);
+    if (!rightMatches?.length) continue;
+    addPair(leftMatches[0], rightMatches[0], name.endsWith("_id") ? 2000 : 1700);
+  }
+
+  // Pattern 5: parent_id -> id (self-referencing / hierarchical)
+  if (leftTableKey === rightTableKey) {
+    addPair(leftByName.get("parent_id")?.[0], rightId, 2100);
+    addPair(leftId, rightByName.get("parent_id")?.[0], 2100);
+  }
+
+  // Pattern 6: created_by / modified_by / owned_by -> users.id
+  for (const auditColumnName of ["created_by", "modified_by", "owned_by"]) {
+    addPair(leftId, rightByName.get(auditColumnName)?.[0], 1800);
+    addPair(leftByName.get(auditColumnName)?.[0], rightId, 1800);
+  }
+
+  // Pattern 7: Generic FK column -> id when table names do not reveal the relationship.
+  for (const leftColumn of leftColumns) {
+    const leftName = leftColumn.name.toLowerCase();
+    if (leftName !== "id" && leftName.endsWith("_id")) addPair(leftColumn, rightId, 1650);
+  }
+  for (const rightColumn of rightColumns) {
+    const rightName = rightColumn.name.toLowerCase();
+    if (rightName !== "id" && rightName.endsWith("_id")) addPair(leftId, rightColumn, 1650);
+  }
+
+  items.push(...buildCompositeHeuristicJoinConditionItems(left, leftColumns, right, leftByName, rightByName, prefix, dialect, keywordCase));
+
+  return items;
+}
+
+function indexColumnsByLowerName(columns: SqlCompletionColumn[]): Map<string, SqlCompletionColumn[]> {
+  const index = new Map<string, SqlCompletionColumn[]>();
+  for (const column of columns) {
+    const key = column.name.toLowerCase();
+    const existing = index.get(key);
+    if (existing) existing.push(column);
+    else index.set(key, [column]);
+  }
+  return index;
+}
+
+function buildCompositeHeuristicJoinConditionItems(
+  left: SqlCompletionReferencedTable,
+  leftColumns: SqlCompletionColumn[],
+  right: SqlCompletionReferencedTable,
+  leftByName: Map<string, SqlCompletionColumn[]>,
+  rightByName: Map<string, SqlCompletionColumn[]>,
+  prefix: string,
+  dialect?: "mysql" | "postgres" | "sqlserver",
+  keywordCase?: SqlKeywordCase,
+): SqlCompletionItem[] {
+  const leftId = leftByName.get("id")?.[0];
+  const rightId = rightByName.get("id")?.[0];
+  const leftTableKey = singularTableName(left.name);
+  const rightTableKey = singularTableName(right.name);
+  const candidates: Array<{ parent: "left" | "right"; parentId: SqlCompletionColumn; childFk: SqlCompletionColumn }> = [];
+  const rightNamedFk = rightByName.get(`${leftTableKey}_id`)?.[0];
+  const leftNamedFk = leftByName.get(`${rightTableKey}_id`)?.[0];
+  if (leftId && rightNamedFk && areJoinColumnTypesCompatible(leftId, rightNamedFk)) {
+    candidates.push({ parent: "left", parentId: leftId, childFk: rightNamedFk });
+  }
+  if (rightId && leftNamedFk && areJoinColumnTypesCompatible(leftNamedFk, rightId)) {
+    candidates.push({ parent: "right", parentId: rightId, childFk: leftNamedFk });
+  }
+  if (candidates.length === 0) return [];
+
+  const sharedScopeColumns = leftColumns
+    .map((leftColumn) => {
+      const name = leftColumn.name.toLowerCase();
+      const rightColumn = rightByName.get(name)?.[0];
+      if (!rightColumn || !isLikelyScopeColumnName(name) || !areJoinColumnTypesCompatible(leftColumn, rightColumn)) {
+        return null;
+      }
+      return { leftColumn, rightColumn };
+    })
+    .filter((value): value is { leftColumn: SqlCompletionColumn; rightColumn: SqlCompletionColumn } => !!value)
+    .slice(0, 2);
+  if (sharedScopeColumns.length === 0) return [];
+
+  const leftRef = left.alias || left.name;
+  const rightRef = right.alias || right.name;
+  const leftApplyRef = left.alias ? left.alias : quoteSqlIdentifier(left.name, dialect);
+  const rightApplyRef = right.alias ? right.alias : quoteSqlIdentifier(right.name, dialect);
+  const items: SqlCompletionItem[] = [];
+
+  for (const candidate of candidates.slice(0, 2)) {
+    const parts = sharedScopeColumns.map(({ leftColumn, rightColumn }) => buildHeuristicJoinConditionPart(leftRef, leftApplyRef, leftColumn, rightRef, rightApplyRef, rightColumn, dialect));
+    if (candidate.parent === "left") {
+      parts.push(buildHeuristicJoinConditionPart(leftRef, leftApplyRef, candidate.parentId, rightRef, rightApplyRef, candidate.childFk, dialect));
+    } else {
+      parts.push(buildHeuristicJoinConditionPart(leftRef, leftApplyRef, candidate.childFk, rightRef, rightApplyRef, candidate.parentId, dialect));
+    }
+    const joiner = keywordJoiner(keywordCase);
+    const label = parts.map((part) => part.label).join(joiner);
+    if (prefix && !matchesPrefix(label, prefix)) continue;
+    items.push({
+      label,
+      type: "snippet",
+      detail: "Likely composite JOIN condition",
+      apply: parts.map((part) => part.apply).join(joiner),
+      boost: 2400 + parts.length,
+    });
+  }
+
+  return items;
+}
+
+function buildHeuristicJoinConditionPart(leftRef: string, leftApplyRef: string, leftColumn: SqlCompletionColumn, rightRef: string, rightApplyRef: string, rightColumn: SqlCompletionColumn, dialect?: "mysql" | "postgres" | "sqlserver"): { label: string; apply: string } {
+  return {
+    label: `${leftRef}.${leftColumn.name} = ${rightRef}.${rightColumn.name}`,
+    apply: `${leftApplyRef}.${quoteSqlIdentifier(leftColumn.name, dialect)} = ${rightApplyRef}.${quoteSqlIdentifier(rightColumn.name, dialect)}`,
+  };
+}
+
+function isLikelyScopeColumnName(name: string): boolean {
+  return name !== "id" && (name.endsWith("_id") || name === "tenant" || name === "tenant_id" || name === "account_id" || name === "workspace_id" || name === "organization_id" || name === "org_id");
+}
+
+function areJoinColumnTypesCompatible(left: SqlCompletionColumn, right: SqlCompletionColumn): boolean {
+  const leftType = normalizeJoinType(left.dataType);
+  const rightType = normalizeJoinType(right.dataType);
+  if (!leftType || !rightType) return true;
+  return leftType === rightType;
+}
+
+function normalizeJoinType(dataType?: string): string | null {
+  if (!dataType) return null;
+  const type = dataType.toLowerCase();
+  if (/\b(uuid|uniqueidentifier)\b/.test(type)) return "uuid";
+  if (/\b(bigint|int8|integer|int|int4|smallint|int2|tinyint|serial|bigserial|number|numeric|decimal)\b/.test(type)) {
+    return "number";
+  }
+  if (/\b(char|text|clob|string|varchar|nvarchar|nchar|uuid)\b/.test(type)) return "text";
+  if (/\b(bool|boolean|bit)\b/.test(type)) return "boolean";
+  if (/\b(date|time|timestamp|datetime)\b/.test(type)) return "temporal";
+  return type.replace(/\(.+\)/, "").trim() || null;
+}
+
+function singularTableName(name: string): string {
+  const lower = name.toLowerCase();
+  // Irregular plurals
+  if (lower.endsWith("ies") && lower.length > 3) return `${lower.slice(0, -3)}y`;
+  if (lower.endsWith("ives") && lower.length > 4) return `${lower.slice(0, -4)}f`; // lives → life
+  if (lower.endsWith("ves") && lower.length > 3) {
+    const stem = lower.slice(0, -3);
+    if (stem.endsWith("el") || stem.endsWith("lf")) return `${stem}fe`; // shelves → shelf, halves → half
+    return `${stem}f`; // calves → calf
+  }
+  if (lower.endsWith("ses") && lower.length > 3) {
+    const stem = lower.slice(0, -2); // statuses → status, buses → bus
+    if (stem.endsWith("s") || stem.endsWith("x") || stem.endsWith("z") || stem.endsWith("ch") || stem.endsWith("sh")) {
+      return stem;
+    }
+  }
+  if (lower.endsWith("xes") && lower.length > 3) return lower.slice(0, -2); // boxes → box
+  if (lower.endsWith("ches") && lower.length > 4) return lower.slice(0, -2); // matches → match
+  if (lower.endsWith("shes") && lower.length > 4) return lower.slice(0, -2); // dishes → dish
+  if (lower.endsWith("ices") && lower.length > 4) {
+    const stem = lower.slice(0, -4);
+    if (stem === "ind") return "index";
+    if (stem === "append") return "appendix";
+    return `${stem}ex`; // matrices → matrix
+  }
+  if (lower.endsWith("men") && lower.length > 3) return `${lower}um`; // children → child... no, that's wrong
+  if (lower === "children") return "child";
+  if (lower === "people") return "person";
+  if (lower === "data") return lower; // data is already singular-ish
+  if (lower.endsWith("s") && !lower.endsWith("ss") && lower.length > 1) return lower.slice(0, -1);
+  return lower;
+}
+
+export function buildSnippetItemsForTest(prefix: string, snippets: SqlSnippet[], keywordCase?: SqlKeywordCase): SqlCompletionItem[] {
+  return buildSnippetItems(prefix, snippets, keywordCase);
+}
+
+function buildSnippetItems(prefix: string, snippets: SqlSnippet[], keywordCase?: SqlKeywordCase): SqlCompletionItem[] {
+  if (!prefix) return [];
+  return snippets
+    .filter((snippet) => {
+      if (snippet.enabled === false) return false;
+      const matchesSnippetPrefix = matchesPrefix(snippet.prefix, prefix);
+      const matchesSnippetLabel = prefix.length > snippet.prefix.length && matchesPrefix(snippet.label, prefix);
+      return matchesSnippetPrefix || matchesSnippetLabel;
+    })
+    .map((snippet) => {
+      const boostByPrefix = computeBoost(snippet.prefix, prefix);
+      const boostByLabel = computeBoost(snippet.label, prefix);
+      const matchesByPrefix = matchesPrefix(snippet.prefix, prefix);
+      // When the user types past the snippet prefix (e.g. "sele" vs prefix "sel"),
+      // they are likely typing the actual keyword — reduce the base boost so
+      // the real keyword can rank higher.
+      const baseBoost = matchesByPrefix ? 4000 : 0;
+      // Placeholder replacement runs on the original (UPPER-case) body first,
+      // then keyword casing is applied to both variants uniformly.
+      const body = applyBuiltinSnippetKeywordCase(snippet, snippet.body, keywordCase);
+      const apply = applyBuiltinSnippetKeywordCase(snippet, applyBuiltinSnippetPlaceholders(snippet), keywordCase);
+      return {
+        label: snippet.label,
+        type: "snippet" as const,
+        detail: body,
+        apply,
+        boost: Math.max(boostByPrefix, boostByLabel) + baseBoost,
+      };
+    });
+}
+
+function activeFunctionSignatures(databaseType?: DatabaseType): Map<string, string[]> {
+  const commonFunctionNames = databaseType === "cloudflare-d1" ? CLOUDFLARE_D1_COMMON_FUNCTION_NAMES : COMMON_SQL_FUNCTION_NAMES;
+  const signatures = databaseType ? new Map(Array.from(SQL_FUNCTION_SIGNATURES.entries()).filter(([name]) => commonFunctionNames.has(name))) : new Map(SQL_FUNCTION_SIGNATURES);
+  const databaseSignatures = databaseType ? DATABASE_FUNCTION_SIGNATURES[databaseType] : undefined;
+  if (databaseSignatures) {
+    for (const [name, parameters] of databaseSignatures) signatures.set(name, parameters);
+  }
+  return signatures;
+}
+
+function buildFunctionSnippetItems(prefix: string, functionDescriptions: Map<string, string>, databaseType?: DatabaseType): SqlCompletionItem[] {
+  const items: SqlCompletionItem[] = [];
+
+  for (const [name, parameters] of activeFunctionSignatures(databaseType).entries()) {
+    if (!matchesPrefix(name, prefix)) continue;
+    const paramStr = parameters.length > 0 ? parameters.map((p) => `\${${p}}`).join(", ") : "";
+    items.push({
+      label: name,
+      type: "function" as const,
+      detail: functionDescriptions.get(name) ?? "function",
+      apply: `${name}(${paramStr})`,
+      boost: computeBoost(name, prefix) + 300,
+    });
+  }
+
+  // Window functions — complete with OVER() clause
+  for (const name of WINDOW_FUNCTIONS) {
+    if (!matchesPrefix(name, prefix)) continue;
+    items.push({
+      label: name,
+      type: "function" as const,
+      detail: "window function",
+      apply: `${name}() OVER (PARTITION BY \${col} ORDER BY \${col})`,
+      boost: computeBoost(name, prefix) + 250,
+    });
+  }
+
+  return items;
+}
+
+function mongoCompletionItemToSqlCompletionItem(item: MongoCompletionItem): SqlCompletionItem {
+  return {
+    label: item.label,
+    type: item.type,
+    detail: item.detail,
+    info: item.info,
+    apply: item.apply,
+    boost: item.boost,
+  };
+}
+
+function buildSelectAliasItems(context: SqlCompletionContext): SqlCompletionItem[] {
+  return context.selectAliases
+    .filter((alias) => matchesPrefix(alias, context.prefix))
+    .map((alias, index) => ({
+      label: alias,
+      type: "column" as const,
+      detail: "SELECT alias",
+      boost: computeBoost(alias, context.prefix) + 3500 - index,
+    }));
+}
+
+function buildNonAggregatedColumnItems(context: SqlCompletionContext, columnsByTable: Map<string, SqlCompletionColumn[]>, dialect?: "mysql" | "postgres" | "sqlserver"): SqlCompletionItem[] {
+  const nonAggSet = new Set(context.nonAggregatedSelectColumns.map((c) => c.toLowerCase()));
+  const seen = new Set<string>();
+
+  const items: SqlCompletionItem[] = [];
+  for (const [, cols] of columnsByTable) {
+    for (const col of cols) {
+      const key = col.name.toLowerCase();
+      if (!nonAggSet.has(key) || seen.has(key)) continue;
+      if (context.prefix && !matchesPrefix(col.name, context.prefix)) continue;
+      seen.add(key);
+      items.push({
+        label: col.name,
+        type: "column" as const,
+        detail: "non-aggregated column — required in GROUP BY",
+        apply: quoteSqlIdentifier(col.name, dialect),
+        boost: 2800 - items.length,
+      });
+    }
+  }
+
+  return items;
+}
+
+function activeSqlKeywords(databaseType?: DatabaseType): string[] {
+  if (databaseType === "mongodb") return [];
+  const databaseKeywords = databaseType ? DATABASE_SQL_KEYWORDS[databaseType] : undefined;
+  return databaseType ? Array.from(new Set([...COMMON_SQL_KEYWORDS, ...(databaseKeywords ?? [])])) : Array.from(new Set(SQL_KEYWORDS));
+}
+
+function isOracleLikeDatabase(databaseType?: DatabaseType): boolean {
+  return databaseType === "oracle" || databaseType === "oceanbase-oracle";
+}
+
+function buildJoinModifierKeywordItems(prefix: string, keywordCase?: SqlKeywordCase): SqlCompletionItem[] {
+  if (!prefix) return [];
+  return JOIN_MODIFIER_KEYWORD_PHRASES.filter((keyword) => matchesPrefix(keyword, prefix)).map((keyword) => {
+    const label = applySqlKeywordCase(keyword, keywordCase);
+    return {
+      label,
+      type: "keyword" as const,
+      apply: `${label} `,
+      detail: "join keyword",
+      boost: computeBoost(keyword, prefix) + 1300,
+    };
+  });
+}
+
+function isPendingJoinKeywordContext(context: SqlCompletionContext): boolean {
+  return !context.prefix && context.preferredKeywords.includes("JOIN") && !!context.tableTriggerWord && JOIN_MODIFIERS.has(context.tableTriggerWord);
+}
+
+function buildKeywordItems(prefix: string, context: SqlCompletionContext, databaseType?: DatabaseType, keywordCase?: SqlKeywordCase): SqlCompletionItem[] {
+  const isDml = context.statementKind === "select" || context.statementKind === "insert" || context.statementKind === "update" || context.statementKind === "delete";
+  const showDdl = !isDml || context.suggestTables;
+
+  return activeSqlKeywords(databaseType)
+    .filter((keyword) => {
+      if (SQL_FUNCTION_SIGNATURES.has(keyword)) return false;
+      if (databaseType && DATABASE_FUNCTION_SIGNATURES[databaseType]?.has(keyword)) return false;
+      if (WINDOW_FUNCTIONS.has(keyword)) return false;
+      if (!matchesPrefix(keyword, prefix)) return false;
+      if (!showDdl && isDml && (DDL_ONLY_KEYWORDS.has(keyword) || DATA_TYPE_KEYWORDS.has(keyword))) return false;
+      return true;
+    })
+    .map((keyword) => {
+      const base = computeBoost(keyword, prefix);
+      const freqBoost = HIGH_FREQUENCY_KEYWORDS.has(keyword) ? 100 : 0;
+      return {
+        label: applySqlKeywordCase(keyword, keywordCase),
+        type: "keyword" as const,
+        boost: base + freqBoost,
+      };
+    });
+}
+
+function matchesPrefix(candidate: string, prefix: string): boolean {
+  if (!prefix) return true;
+  return computeMatchScore(candidate, prefix) >= 0;
+}
+
+/**
+ * Score how well `prefix` matches `candidate`.
+ * Returns -1 for no match, or a positive score where higher = better match.
+ *
+ * Scoring tiers:
+ *   Exact match:    3000 - len
+ *   Initials match: 2400 + exactInitialsBonus - len
+ *   Prefix match:   2000 - len
+ *   Substring:      900 + boundaryBonus - len
+ *   Tight fuzzy:    1500 - gapPenalty + earlyMatchBonus - len  (gaps < prefix length)
+ *   Loose fuzzy:     500 + partialEarlyBonus - gapPenalty - len (gaps >= prefix length)
+ */
+function computeMatchScore(candidate: string, prefix: string): number {
+  if (!prefix) return 1;
+  const c = candidate.toLowerCase();
+  const p = prefix.toLowerCase();
+
+  // Exact match
+  if (c === p) return 3000 - c.length;
+
+  // Prefix match
+  if (c.startsWith(p)) return 2000 - c.length;
+
+  const initials = identifierInitials(candidate);
+  if (initials && initials.startsWith(p)) {
+    const exactInitialsBonus = initials === p ? 400 : 0;
+    return 2400 + exactInitialsBonus - c.length;
+  }
+
+  const substringIndex = c.indexOf(p);
+  if (substringIndex >= 0) {
+    const boundaryBonus = isIdentifierBoundary(candidate, substringIndex) ? 400 : Math.max(0, 180 - substringIndex * 12);
+    return 900 + boundaryBonus - c.length;
+  }
+
+  // Fuzzy match: chars must appear in order (allows gaps for typos/abbrevs)
+  let ci = 0;
+  let totalGap = 0;
+  let firstMatchPos = -1;
+  let boundaryBonus = 0;
+  for (let pi = 0; pi < p.length; pi++) {
+    const ch = p[pi];
+    const nextPos = c.indexOf(ch, ci);
+    if (nextPos === -1) {
+      return -1;
+    }
+    if (firstMatchPos === -1) firstMatchPos = nextPos;
+    if (isIdentifierBoundary(candidate, nextPos)) boundaryBonus += 40;
+    totalGap += nextPos - ci;
+    ci = nextPos + 1;
+  }
+
+  const earlyMatchBonus = Math.max(0, 700 - firstMatchPos * 35) + boundaryBonus;
+
+  if (totalGap >= p.length) {
+    // Too many gaps — low-confidence fuzzy match
+    return 400 + earlyMatchBonus * 0.3 - totalGap * 20 - c.length;
+  }
+
+  const gapPenalty = totalGap * 10;
+  return 1200 + earlyMatchBonus - gapPenalty - c.length;
+}
+
+function identifierWords(candidate: string): string[] {
+  return candidate
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean);
+}
+
+function identifierInitials(candidate: string): string {
+  return identifierWords(candidate)
+    .map((part) => part[0])
+    .join("");
+}
+
+function isIdentifierBoundary(candidate: string, index: number): boolean {
+  if (index <= 0) return true;
+  const previous = candidate[index - 1] ?? "";
+  const current = candidate[index] ?? "";
+  return /[^A-Za-z0-9]/.test(previous) || (/[a-z0-9]/.test(previous) && /[A-Z]/.test(current));
+}
+
+function computeBoost(candidate: string, prefix: string): number {
+  return computeMatchScore(candidate, prefix);
+}
+
+// --- History-based ranking ---
+const completionStats = new Map<string, number>();
+
+/** Record a user selection to boost future rankings. */
+export function recordCompletionSelection(label: string, type: string): void {
+  const key = `${type}:${label}`;
+  completionStats.set(key, (completionStats.get(key) || 0) + 1);
+}
+
+function getHistoryBoost(label: string, type: string): number {
+  const count = completionStats.get(`${type}:${label}`);
+  if (!count) return 0;
+  // Diminishing returns: first selection gives biggest boost
+  return Math.min(count * 80, 500);
+}
+
+function dedupeAndSort(items: SqlCompletionItem[]): SqlCompletionItem[] {
+  const seen = new Set<string>();
+  return items.sort(compareCompletionItems).filter((item) => {
+    const key = `${item.type}:${item.label}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function compareCompletionItems(left: SqlCompletionItem, right: SqlCompletionItem): number {
+  if (!left.exactMatch !== !right.exactMatch) return left.exactMatch ? -1 : 1;
+  const leftBonus = getHistoryBoost(left.label, left.type);
+  const rightBonus = getHistoryBoost(right.label, right.type);
+  return right.boost + rightBonus + getTypePriorityBoost(right.type) - (left.boost + leftBonus + getTypePriorityBoost(left.type));
+}
+
+function getTypePriorityBoost(type: SqlCompletionItem["type"]): number {
+  switch (type) {
+    case "column":
+      return 180;
+    case "table":
+      return 160;
+    case "schema":
+      return 120;
+    case "function":
+      return 90;
+    case "snippet":
+      return 40;
+    case "keyword":
+      return 0;
+  }
+}
+
+function findActiveFunctionOpenParen(sqlBeforeCursor: string): number | null {
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+
+  for (let i = sqlBeforeCursor.length - 1; i >= 0; i--) {
+    const ch = sqlBeforeCursor[i];
+    if (ch === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (ch === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (inSingleQuote || inDoubleQuote) continue;
+
+    if (ch === ")") {
+      depth++;
+    } else if (ch === "(") {
+      if (depth === 0) return i;
+      depth--;
+    }
+  }
+
+  return null;
+}
+
+function countTopLevelCommas(text: string): number {
+  let count = 0;
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (ch === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+    if (ch === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+    if (inSingleQuote || inDoubleQuote) continue;
+
+    if (ch === "(") depth++;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    else if (ch === "," && depth === 0) count++;
+  }
+
+  return count;
+}
diff --git a/apps/desktop/src/lib/sql/sqlCompletionLookupTarget.ts b/apps/desktop/src/lib/sql/sqlCompletionLookupTarget.ts
new file mode 100644
index 0000000..6d7cd4d
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlCompletionLookupTarget.ts
@@ -0,0 +1,42 @@
+import type { SqlCompletionContext } from "@/lib/sql/sqlCompletion";
+
+export interface SqlCompletionTableLookupTarget {
+  database: string;
+  schema?: string;
+  filter: string;
+  qualifierDatabase?: string;
+}
+
+function findExactName(names: readonly string[] | undefined, value: string): string | undefined {
+  return names?.find((name) => name.toLowerCase() === value.toLowerCase());
+}
+
+export function resolveSqlCompletionTableLookupTarget(options: {
+  currentDatabase: string;
+  currentSchema?: string;
+  supportsDatabaseQualifier: boolean;
+  completionContext: Pick<SqlCompletionContext, "qualifier" | "prefix" | "suggestTables" | "insertTable">;
+  knownDatabases?: readonly string[];
+}): SqlCompletionTableLookupTarget {
+  const { completionContext } = options;
+  const qualifier = completionContext.qualifier?.trim();
+  const qualifierIsDatabase = options.supportsDatabaseQualifier && !!qualifier && completionContext.suggestTables && !completionContext.insertTable;
+
+  if (qualifierIsDatabase) {
+    // MySQL-compatible engines, including OceanBase MySQL mode, use
+    // database.table. Do not block table completion on a separate database-list
+    // request when the user already typed the database qualifier.
+    const database = findExactName(options.knownDatabases, qualifier) ?? qualifier;
+    return {
+      database,
+      filter: completionContext.prefix,
+      qualifierDatabase: database,
+    };
+  }
+
+  return {
+    database: options.currentDatabase,
+    schema: qualifier && completionContext.suggestTables ? qualifier : options.currentSchema,
+    filter: qualifier && completionContext.suggestTables ? completionContext.prefix : qualifier || completionContext.prefix,
+  };
+}
diff --git a/apps/desktop/src/lib/sql/sqlDiagnostics.ts b/apps/desktop/src/lib/sql/sqlDiagnostics.ts
new file mode 100644
index 0000000..ab56e98
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlDiagnostics.ts
@@ -0,0 +1,44 @@
+export interface SqlErrorLocation {
+  line: number;
+  column: number;
+}
+
+function toZeroBased(value: string | undefined): number | null {
+  if (!value) return null;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) return null;
+  return parsed - 1;
+}
+
+export function parseSqlErrorLocation(message: string): SqlErrorLocation | null {
+  const lineColumn = /\bline\s+(\d+)\s*[,:\s]\s*column\s+(\d+)\b/i.exec(message) ?? /\bline\s+(\d+)\b[\s\S]{0,80}?\bcol(?:umn)?\s+(\d+)\b/i.exec(message);
+  if (lineColumn) {
+    const line = toZeroBased(lineColumn[1]);
+    const column = toZeroBased(lineColumn[2]);
+    if (line != null && column != null) return { line, column };
+  }
+
+  const lines = message.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    const lineMatch = /^LINE\s+(\d+):/i.exec(lines[index] ?? "");
+    if (!lineMatch) continue;
+    const caretLine = lines.slice(index + 1).find((line) => line.includes("^"));
+    const line = toZeroBased(lineMatch[1]);
+    const caretIndex = caretLine?.indexOf("^") ?? -1;
+    if (line != null && caretIndex >= 0) return { line, column: caretIndex };
+  }
+
+  return null;
+}
+
+export function lineColumnToOffset(sql: string, location: SqlErrorLocation): number | null {
+  const lines = sql.split(/\r?\n/);
+  if (location.line < 0 || location.line >= lines.length) return null;
+
+  let offset = 0;
+  for (let index = 0; index < location.line; index++) {
+    offset += lines[index].length + 1;
+  }
+
+  return Math.min(offset + location.column, offset + lines[location.line].length);
+}
diff --git a/apps/desktop/src/lib/sql/sqlExecutionTarget.ts b/apps/desktop/src/lib/sql/sqlExecutionTarget.ts
new file mode 100644
index 0000000..dc105b3
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlExecutionTarget.ts
@@ -0,0 +1,68 @@
+import * as api from "@/lib/backend/api";
+import { mongoCommandRangeAtCursor } from "@/lib/sql/sqlStatementRanges";
+import type { DatabaseType } from "@/types/database";
+
+export type ExecuteMode = "all" | "current";
+
+export interface SqlExecutionSnapshot {
+  fullSql: string;
+  selectedSql: string;
+  cursorPos: number;
+}
+
+export type SqlExecutionOverride = string | SqlExecutionSnapshot;
+
+export type SqlExecutionTargetKind = "cursor" | "all";
+
+/**
+ * A candidate execution target surfaced by the execution target picker.
+ * `from`/`to` are offsets into the full document so the editor can highlight
+ * the corresponding range as a preview while the picker is open.
+ */
+export interface SqlExecutionCandidate {
+  kind: SqlExecutionTargetKind;
+  label: string;
+  sql: string;
+  from: number;
+  to: number;
+}
+
+export interface SqlExecutionChoiceRequest {
+  fullSql: string;
+  selectedSql: string;
+  cursorPos: number;
+  candidates: SqlExecutionCandidate[];
+}
+
+export function isSqlExecutionSnapshot(value: SqlExecutionOverride | undefined): value is SqlExecutionSnapshot {
+  return typeof value === "object" && value !== null && typeof value.fullSql === "string" && typeof value.selectedSql === "string" && typeof value.cursorPos === "number";
+}
+
+export function resolveExecutableSql(fullSql: string, selectedSql: string, options?: { mode?: ExecuteMode; cursorPos?: number }): string {
+  const trimmedSelection = selectedSql.trim();
+  if (trimmedSelection) return trimmedSelection;
+
+  if (options?.mode === "current" && options.cursorPos !== undefined) {
+    return fullSql;
+  }
+
+  return fullSql;
+}
+
+export async function resolveExecutableSqlWithBackend(fullSql: string, selectedSql: string, options?: { mode?: ExecuteMode; cursorPos?: number; databaseType?: DatabaseType }): Promise<string> {
+  const trimmedSelection = selectedSql.trim();
+  if (trimmedSelection) return trimmedSelection;
+
+  if (options?.databaseType === "mongodb") {
+    if (options.mode === "current" && options.cursorPos !== undefined) {
+      return mongoCommandRangeAtCursor(fullSql, options.cursorPos)?.sql ?? fullSql;
+    }
+    return fullSql;
+  }
+
+  if (options?.mode === "current" && options.cursorPos !== undefined) {
+    return await api.findStatementAtCursor(fullSql, options.cursorPos, options.databaseType);
+  }
+
+  return fullSql;
+}
diff --git a/apps/desktop/src/lib/sql/sqlFileOpen.ts b/apps/desktop/src/lib/sql/sqlFileOpen.ts
new file mode 100644
index 0000000..8926e30
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlFileOpen.ts
@@ -0,0 +1,48 @@
+export function isSqlFilePath(path: string): boolean {
+  return /\.sql$/i.test(path.trim());
+}
+
+export function sqlFileTitleFromPath(path: string): string {
+  const normalized = normalizeExternalSqlPath(path);
+  const name = normalized.split("/").filter(Boolean).pop();
+  return name || "script.sql";
+}
+
+export function normalizeExternalSqlPath(path: string): string {
+  const normalized = path
+    .trim()
+    .replace(/\\/g, "/")
+    .replace(/\/{2,}/g, "/");
+  return normalized.length > 1 ? normalized.replace(/\/$/, "") : normalized;
+}
+
+export function externalSqlFileDisplayTitles(paths: string[]): string[] {
+  const segments = paths.map((path) => normalizeExternalSqlPath(path).split("/").filter(Boolean));
+  const titles = segments.map((parts) => parts[parts.length - 1] || "script.sql");
+  const collisions = new Map<string, number[]>();
+
+  titles.forEach((title, index) => {
+    const indexes = collisions.get(title) ?? [];
+    indexes.push(index);
+    collisions.set(title, indexes);
+  });
+
+  for (const indexes of collisions.values()) {
+    if (indexes.length < 2) continue;
+    const maxDepth = Math.max(...indexes.map((index) => segments[index].length));
+    for (let depth = 2; depth <= maxDepth; depth++) {
+      const candidates = indexes.map((index) => segments[index].slice(-depth).join("/"));
+      if (new Set(candidates).size !== candidates.length) continue;
+      indexes.forEach((index, candidateIndex) => {
+        titles[index] = candidates[candidateIndex];
+      });
+      break;
+    }
+  }
+
+  return titles;
+}
+
+export function externalSqlFilePaths(paths: string[]): string[] {
+  return paths.filter(isSqlFilePath);
+}
diff --git a/apps/desktop/src/lib/sql/sqlFormatter.ts b/apps/desktop/src/lib/sql/sqlFormatter.ts
new file mode 100644
index 0000000..1980de3
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlFormatter.ts
@@ -0,0 +1,100 @@
+import { DEFAULT_SQL_FORMATTER_SETTINGS, sqlFormatterOptions, type SqlFormatterSettings } from "@/lib/sql/sqlFormatterConfig";
+
+export type SqlFormatDialect = "mysql" | "postgres" | "sqlite" | "sqlserver" | "generic";
+
+export const MAX_SQL_FORMAT_CHARS = 1_000_000;
+
+/**
+ * Maps a connection's database type to the SQL-formatter dialect to use.
+ *
+ * Postgres-compatible engines (GaussDB/openGauss/Kingbase/...) reuse the
+ * "postgres" grammar, SQLite-compatible ones reuse "sqlite", and anything
+ * unrecognized falls back to the permissive "generic" dialect. Centralized
+ * here so every surface that formats SQL (editor, object source, DDL viewers)
+ * stays in sync.
+ */
+export function sqlFormatDialectForDbType(dbType: string | null | undefined): SqlFormatDialect {
+  switch (dbType) {
+    case "mysql":
+      return "mysql";
+    case "postgres":
+    case "kwdb":
+    case "gaussdb":
+    case "opengauss":
+    case "questdb":
+    case "kingbase":
+    case "highgo":
+    case "vastbase":
+    case "redshift":
+      return "postgres";
+    case "sqlite":
+    case "rqlite":
+    case "turso":
+    case "cloudflare-d1":
+      return "sqlite";
+    case "sqlserver":
+      return "sqlserver";
+    default:
+      return "generic";
+  }
+}
+
+function formatterLanguage(dialect: SqlFormatDialect) {
+  switch (dialect) {
+    case "mysql":
+      return "mysql";
+    case "postgres":
+      return "postgresql";
+    case "sqlite":
+      return "sqlite";
+    case "sqlserver":
+      return "transactsql";
+    default:
+      return "sql";
+  }
+}
+
+export async function formatSqlText(sql: string, dialect: SqlFormatDialect = "generic", settings: Partial<SqlFormatterSettings> = DEFAULT_SQL_FORMATTER_SETTINGS): Promise<string> {
+  if (!sql.trim()) return sql;
+  if (sql.length > MAX_SQL_FORMAT_CHARS) {
+    throw new Error("SQL is too large to format safely.");
+  }
+
+  const { format } = await import("sql-formatter");
+  const options = sqlFormatterOptions(settings);
+  const language = formatterLanguage(dialect);
+  try {
+    return format(sql, { language, ...options });
+  } catch (err) {
+    // The generic "sql" dialect can't parse many real-world constructs (PostgreSQL
+    // `::` casts, GaussDB/openGauss materialized-view DDL, T-SQL specifics, ...).
+    // Retry once with the more permissive PostgreSQL grammar, which is a superset
+    // that tolerates most of these, before surfacing the failure.
+    if (language !== "postgresql") {
+      try {
+        return format(sql, { language: "postgresql", ...options });
+      } catch {
+        // fall through to the original error below
+      }
+    }
+    throw err;
+  }
+}
+
+/**
+ * Format SQL for *display* (object source, view/table DDL viewers).
+ *
+ * Unlike `formatSqlText`, this never throws: if the SQL can't be parsed by the
+ * formatter (vendor-specific DDL, oversized input, ...) the original text is
+ * returned unchanged so the viewer still shows the source. Use this for
+ * read-only/auto-format surfaces; use `formatSqlText` where a thrown error
+ * should surface to the user (e.g. the explicit "Format SQL" command).
+ */
+export async function formatSqlForDisplay(sql: string, dialect: SqlFormatDialect = "generic", settings: Partial<SqlFormatterSettings> = DEFAULT_SQL_FORMATTER_SETTINGS): Promise<string> {
+  if (!sql.trim()) return sql;
+  try {
+    return await formatSqlText(sql, dialect, settings);
+  } catch {
+    return sql;
+  }
+}
diff --git a/apps/desktop/src/lib/sql/sqlFormatterConfig.ts b/apps/desktop/src/lib/sql/sqlFormatterConfig.ts
new file mode 100644
index 0000000..a6ac64e
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlFormatterConfig.ts
@@ -0,0 +1,257 @@
+export const SQL_FORMATTER_CONFIG_VERSION = 1;
+export const SQL_FORMATTER_CONFIG_FORMATTER = "sql-formatter";
+
+const CASE_VALUES = ["preserve", "upper", "lower"] as const;
+const INDENT_STYLE_VALUES = ["standard", "tabularLeft", "tabularRight"] as const;
+const LOGICAL_OPERATOR_NEWLINE_VALUES = ["before", "after"] as const;
+const TAB_WIDTH_VALUES = [2, 4] as const;
+const EXPRESSION_WIDTH_VALUES = [50, 80, 120] as const;
+const LINES_BETWEEN_QUERIES_VALUES = [0, 1, 2] as const;
+const SQL_FORMATTER_PARAM_TYPE_MARKERS = ["?", ":", "$"] as const;
+const SQL_FORMATTER_NAMED_PARAM_TYPE_MARKERS = [":", "@", "$"] as const;
+const SQL_FORMATTER_LEGACY_OPTION_KEYS = new Set(["params"]);
+
+export type SqlFormatterCase = (typeof CASE_VALUES)[number];
+export type SqlFormatterIndentStyle = (typeof INDENT_STYLE_VALUES)[number];
+export type SqlFormatterLogicalOperatorNewline = (typeof LOGICAL_OPERATOR_NEWLINE_VALUES)[number];
+export type SqlFormatterTabWidth = (typeof TAB_WIDTH_VALUES)[number];
+export type SqlFormatterExpressionWidth = (typeof EXPRESSION_WIDTH_VALUES)[number];
+export type SqlFormatterLinesBetweenQueries = (typeof LINES_BETWEEN_QUERIES_VALUES)[number];
+
+export interface SqlFormatterCustomParameter {
+  regex: string;
+}
+
+export interface SqlFormatterParamTypes {
+  positional?: boolean;
+  numbered?: ("?" | ":" | "$")[];
+  named?: (":" | "@" | "$")[];
+  quoted?: (":" | "@" | "$")[];
+  custom?: SqlFormatterCustomParameter[];
+}
+
+export interface SqlFormatterOptionSettings {
+  keywordCase: SqlFormatterCase;
+  dataTypeCase: SqlFormatterCase;
+  functionCase: SqlFormatterCase;
+  identifierCase: SqlFormatterCase;
+  indentStyle: SqlFormatterIndentStyle;
+  useTabs: boolean;
+  tabWidth: SqlFormatterTabWidth;
+  logicalOperatorNewline: SqlFormatterLogicalOperatorNewline;
+  expressionWidth: SqlFormatterExpressionWidth;
+  linesBetweenQueries: SqlFormatterLinesBetweenQueries;
+  denseOperators: boolean;
+  newlineBeforeSemicolon: boolean;
+  paramTypes: SqlFormatterParamTypes | null;
+}
+
+export type SqlFormatterSettings = SqlFormatterOptionSettings;
+
+export interface SqlFormatterConfigFile {
+  version: typeof SQL_FORMATTER_CONFIG_VERSION;
+  formatter: typeof SQL_FORMATTER_CONFIG_FORMATTER;
+  options: SqlFormatterOptionSettings;
+}
+
+export type SqlFormatterConfigParseResult = { ok: true; settings: SqlFormatterSettings } | { ok: false; message: string };
+
+export const DEFAULT_SQL_FORMATTER_SETTINGS: SqlFormatterSettings = {
+  keywordCase: "upper",
+  dataTypeCase: "preserve",
+  functionCase: "preserve",
+  identifierCase: "preserve",
+  indentStyle: "standard",
+  useTabs: false,
+  tabWidth: 2,
+  logicalOperatorNewline: "before",
+  expressionWidth: 50,
+  linesBetweenQueries: 1,
+  denseOperators: false,
+  newlineBeforeSemicolon: false,
+  paramTypes: null,
+};
+
+const SQL_FORMATTER_OPTION_KEYS = new Set<keyof SqlFormatterOptionSettings>([
+  "keywordCase",
+  "dataTypeCase",
+  "functionCase",
+  "identifierCase",
+  "indentStyle",
+  "useTabs",
+  "tabWidth",
+  "logicalOperatorNewline",
+  "expressionWidth",
+  "linesBetweenQueries",
+  "denseOperators",
+  "newlineBeforeSemicolon",
+  "paramTypes",
+]);
+
+const SQL_FORMATTER_OPTION_VALIDATORS: Record<keyof SqlFormatterOptionSettings, (value: unknown) => boolean> = {
+  keywordCase: (value) => isStringChoice(value, CASE_VALUES),
+  dataTypeCase: (value) => isStringChoice(value, CASE_VALUES),
+  functionCase: (value) => isStringChoice(value, CASE_VALUES),
+  identifierCase: (value) => isStringChoice(value, CASE_VALUES),
+  indentStyle: (value) => isStringChoice(value, INDENT_STYLE_VALUES),
+  useTabs: (value) => typeof value === "boolean",
+  tabWidth: (value) => isNumberChoice(value, TAB_WIDTH_VALUES),
+  logicalOperatorNewline: (value) => isStringChoice(value, LOGICAL_OPERATOR_NEWLINE_VALUES),
+  expressionWidth: (value) => isNumberChoice(value, EXPRESSION_WIDTH_VALUES),
+  linesBetweenQueries: (value) => isNumberChoice(value, LINES_BETWEEN_QUERIES_VALUES),
+  denseOperators: (value) => typeof value === "boolean",
+  newlineBeforeSemicolon: (value) => typeof value === "boolean",
+  paramTypes: isSqlFormatterParamTypes,
+};
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isStringChoice(value: unknown, values: readonly string[]): boolean {
+  return typeof value === "string" && values.includes(value);
+}
+
+function isNumberChoice(value: unknown, values: readonly number[]): boolean {
+  return typeof value === "number" && values.includes(value);
+}
+
+function isMarkerArray<T extends readonly string[]>(value: unknown, markers: T): value is T[number][] {
+  return Array.isArray(value) && value.every((item) => typeof item === "string" && markers.includes(item));
+}
+
+function isCustomParameter(value: unknown): value is SqlFormatterCustomParameter {
+  if (!isObject(value) || typeof value.regex !== "string" || value.regex.length === 0 || !Object.keys(value).every((key) => key === "regex")) return false;
+  try {
+    new RegExp(`(?:${value.regex})`, "uy");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isSqlFormatterParamTypes(value: unknown): value is SqlFormatterParamTypes | null {
+  if (value === null) return true;
+  if (!isObject(value)) return false;
+  if (!Object.keys(value).every((key) => ["positional", "numbered", "named", "quoted", "custom"].includes(key))) return false;
+  if (value.positional !== undefined && typeof value.positional !== "boolean") return false;
+  if (value.numbered !== undefined && !isMarkerArray(value.numbered, SQL_FORMATTER_PARAM_TYPE_MARKERS)) return false;
+  if (value.named !== undefined && !isMarkerArray(value.named, SQL_FORMATTER_NAMED_PARAM_TYPE_MARKERS)) return false;
+  if (value.quoted !== undefined && !isMarkerArray(value.quoted, SQL_FORMATTER_NAMED_PARAM_TYPE_MARKERS)) return false;
+  if (value.custom !== undefined && (!Array.isArray(value.custom) || !value.custom.every(isCustomParameter))) return false;
+  return true;
+}
+
+function normalizeChoice<T extends readonly string[]>(value: unknown, values: T, fallback: T[number]): T[number] {
+  return typeof value === "string" && values.includes(value) ? value : fallback;
+}
+
+function normalizeNumberChoice<T extends readonly number[]>(value: unknown, values: T, fallback: T[number]): T[number] {
+  return typeof value === "number" && values.includes(value) ? value : fallback;
+}
+
+function normalizeBoolean(value: unknown, fallback: boolean): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function normalizeParamTypes(value: unknown, fallback: SqlFormatterParamTypes | null): SqlFormatterParamTypes | null {
+  if (value === null) return null;
+  if (!isSqlFormatterParamTypes(value)) return fallback;
+  return {
+    ...(value.positional !== undefined ? { positional: value.positional } : {}),
+    ...(value.numbered ? { numbered: [...value.numbered] } : {}),
+    ...(value.named ? { named: [...value.named] } : {}),
+    ...(value.quoted ? { quoted: [...value.quoted] } : {}),
+    ...(value.custom ? { custom: value.custom.map((item) => ({ regex: item.regex })) } : {}),
+  };
+}
+
+export function sqlFormatterOptionSettings(settings: unknown): SqlFormatterOptionSettings {
+  const input = isObject(settings) ? settings : {};
+  return {
+    keywordCase: normalizeChoice(input.keywordCase, CASE_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.keywordCase),
+    dataTypeCase: normalizeChoice(input.dataTypeCase, CASE_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.dataTypeCase),
+    functionCase: normalizeChoice(input.functionCase, CASE_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.functionCase),
+    identifierCase: normalizeChoice(input.identifierCase, CASE_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.identifierCase),
+    indentStyle: normalizeChoice(input.indentStyle, INDENT_STYLE_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.indentStyle),
+    useTabs: normalizeBoolean(input.useTabs, DEFAULT_SQL_FORMATTER_SETTINGS.useTabs),
+    tabWidth: normalizeNumberChoice(input.tabWidth, TAB_WIDTH_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.tabWidth),
+    logicalOperatorNewline: normalizeChoice(input.logicalOperatorNewline, LOGICAL_OPERATOR_NEWLINE_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.logicalOperatorNewline),
+    expressionWidth: normalizeNumberChoice(input.expressionWidth, EXPRESSION_WIDTH_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.expressionWidth),
+    linesBetweenQueries: normalizeNumberChoice(input.linesBetweenQueries, LINES_BETWEEN_QUERIES_VALUES, DEFAULT_SQL_FORMATTER_SETTINGS.linesBetweenQueries),
+    denseOperators: normalizeBoolean(input.denseOperators, DEFAULT_SQL_FORMATTER_SETTINGS.denseOperators),
+    newlineBeforeSemicolon: normalizeBoolean(input.newlineBeforeSemicolon, DEFAULT_SQL_FORMATTER_SETTINGS.newlineBeforeSemicolon),
+    paramTypes: normalizeParamTypes(input.paramTypes, DEFAULT_SQL_FORMATTER_SETTINGS.paramTypes),
+  };
+}
+
+export function normalizeSqlFormatterSettings(value: unknown): SqlFormatterSettings {
+  const input = isObject(value) ? value : {};
+  const optionSource = isObject(input.options) ? input.options : input;
+  return sqlFormatterOptionSettings(optionSource);
+}
+
+export function sqlFormatterConfigFile(settings: unknown): SqlFormatterConfigFile {
+  const normalized = normalizeSqlFormatterSettings(settings);
+  return {
+    version: SQL_FORMATTER_CONFIG_VERSION,
+    formatter: SQL_FORMATTER_CONFIG_FORMATTER,
+    options: sqlFormatterOptionSettings(normalized),
+  };
+}
+
+export function serializeSqlFormatterConfig(settings: unknown): string {
+  return JSON.stringify(sqlFormatterConfigFile(settings), null, 2);
+}
+
+export function parseSqlFormatterConfig(text: string): SqlFormatterConfigParseResult {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return { ok: false, message: "Invalid JSON." };
+  }
+
+  if (!isObject(parsed)) return { ok: false, message: "Config must be a JSON object." };
+  if (parsed.version !== SQL_FORMATTER_CONFIG_VERSION) return { ok: false, message: "Unsupported config version." };
+  if (parsed.formatter !== SQL_FORMATTER_CONFIG_FORMATTER) return { ok: false, message: "Unsupported formatter." };
+  if (!isObject(parsed.options)) return { ok: false, message: "Config options must be a JSON object." };
+
+  const unknownOption = Object.keys(parsed.options).find((key) => !SQL_FORMATTER_OPTION_KEYS.has(key as keyof SqlFormatterOptionSettings) && !SQL_FORMATTER_LEGACY_OPTION_KEYS.has(key));
+  if (unknownOption) return { ok: false, message: `Unknown formatter option: ${unknownOption}.` };
+  if ("params" in parsed.options && parsed.options.params !== null) return { ok: false, message: "Unsupported formatter option: params." };
+
+  const invalidOption = Object.entries(parsed.options).find(([key, value]) => {
+    if (SQL_FORMATTER_LEGACY_OPTION_KEYS.has(key)) return false;
+    const optionKey = key as keyof SqlFormatterOptionSettings;
+    return !SQL_FORMATTER_OPTION_VALIDATORS[optionKey](value);
+  });
+  if (invalidOption) return { ok: false, message: `Invalid formatter option value: ${invalidOption[0]}.` };
+
+  return { ok: true, settings: normalizeSqlFormatterSettings(parsed.options) };
+}
+
+export function syncSqlFormatterConfigDraft(text: string, syncSettings: (settings: SqlFormatterSettings) => void): SqlFormatterConfigParseResult {
+  const result = parseSqlFormatterConfig(text);
+  if (result.ok) syncSettings(result.settings);
+  return result;
+}
+
+export function sqlFormatterOptions(settings: unknown) {
+  const normalized = sqlFormatterOptionSettings(settings);
+  return {
+    keywordCase: normalized.keywordCase,
+    dataTypeCase: normalized.dataTypeCase,
+    functionCase: normalized.functionCase,
+    identifierCase: normalized.identifierCase,
+    indentStyle: normalized.indentStyle,
+    useTabs: normalized.useTabs,
+    tabWidth: normalized.tabWidth,
+    logicalOperatorNewline: normalized.logicalOperatorNewline,
+    expressionWidth: normalized.expressionWidth,
+    linesBetweenQueries: normalized.linesBetweenQueries,
+    denseOperators: normalized.denseOperators,
+    newlineBeforeSemicolon: normalized.newlineBeforeSemicolon,
+    ...(normalized.paramTypes !== null ? { paramTypes: normalized.paramTypes } : {}),
+  };
+}
diff --git a/apps/desktop/src/lib/sql/sqlHighlighter.ts b/apps/desktop/src/lib/sql/sqlHighlighter.ts
new file mode 100644
index 0000000..edd8a4a
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlHighlighter.ts
@@ -0,0 +1,74 @@
+import type { AppThemeAppearance } from "@/lib/app/appTheme";
+
+export type SqlHighlighter = (content: string, appearance?: AppThemeAppearance) => string;
+
+interface ShikiSqlHighlighterOptions {
+  appearance: () => AppThemeAppearance;
+}
+
+const SHIKI_THEMES = {
+  dark: "github-dark",
+  light: "github-light",
+} as const;
+
+type ShikiHighlighter = Awaited<ReturnType<typeof import("shiki/core").createHighlighterCore>>;
+type ShikiCodeHighlighter = Pick<ShikiHighlighter, "codeToHtml">;
+
+let highlighterPromise: Promise<ShikiHighlighter> | undefined;
+
+export async function createShikiSqlHighlighter(options: ShikiSqlHighlighterOptions): Promise<SqlHighlighter> {
+  try {
+    const highlighter = await getShikiSqlHighlighter();
+    return createSafeSqlHighlighter(highlighter, options);
+  } catch (error) {
+    console.warn("[DBX][sqlHighlighter] Failed to initialize SQL highlighter:", error);
+    return escapeHtml;
+  }
+}
+
+export function createSafeSqlHighlighter(highlighter: ShikiCodeHighlighter, options: ShikiSqlHighlighterOptions): SqlHighlighter {
+  return (content, appearance = options.appearance()) => {
+    try {
+      return highlighter.codeToHtml(content, {
+        lang: "sql",
+        structure: "inline",
+        theme: SHIKI_THEMES[appearance],
+      });
+    } catch (error) {
+      console.warn("[DBX][sqlHighlighter] Failed to highlight SQL:", error);
+      return escapeHtml(content);
+    }
+  };
+}
+
+export function escapeHtml(content: string): string {
+  return content.replace(/[&<>"']/g, (char) => {
+    switch (char) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      default:
+        return "&#39;";
+    }
+  });
+}
+
+function getShikiSqlHighlighter(): Promise<ShikiHighlighter> {
+  highlighterPromise ??= loadShikiSqlHighlighter();
+  return highlighterPromise;
+}
+
+async function loadShikiSqlHighlighter(): Promise<ShikiHighlighter> {
+  const [{ createHighlighterCore }, { createJavaScriptRegexEngine }, githubDark, githubLight, sql] = await Promise.all([import("shiki/core"), import("shiki/engine/javascript"), import("shiki/themes/github-dark.mjs"), import("shiki/themes/github-light.mjs"), import("shiki/langs/sql.mjs")]);
+
+  return createHighlighterCore({
+    engine: createJavaScriptRegexEngine(),
+    langs: [sql.default],
+    themes: [githubDark.default, githubLight.default],
+  });
+}
diff --git a/apps/desktop/src/lib/sql/sqlInListPaste.ts b/apps/desktop/src/lib/sql/sqlInListPaste.ts
new file mode 100644
index 0000000..c3ae861
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlInListPaste.ts
@@ -0,0 +1,198 @@
+export const SQL_IN_LIST_PASTE_MAX_SOURCE_LENGTH = 1024 * 1024;
+export const SQL_IN_LIST_PASTE_MAX_VALUES = 10_000;
+
+export type SqlInListPasteError = "empty" | "not-list" | "too-large" | "too-many-values";
+
+export type SqlInListPasteResult =
+  | {
+      ok: true;
+      sql: string;
+      valueCount: number;
+    }
+  | {
+      ok: false;
+      reason: SqlInListPasteError;
+      limit?: number;
+    };
+
+interface ParsedPasteValue {
+  value: string;
+  quoted: boolean;
+}
+
+interface ParsedPasteValues {
+  values: ParsedPasteValue[];
+  explicitList: boolean;
+}
+
+const SIMPLE_SLASH_LIST_VALUE_RE = /^[A-Za-z0-9_.:-]+$/;
+
+export function buildSqlInConditionFromPasteSource(source: string): SqlInListPasteResult {
+  if (source.length > SQL_IN_LIST_PASTE_MAX_SOURCE_LENGTH) {
+    return { ok: false, reason: "too-large", limit: SQL_IN_LIST_PASTE_MAX_SOURCE_LENGTH };
+  }
+
+  const parsed = parsePastedValues(source);
+  const values = parsed.values;
+  if (values.length === 0) return { ok: false, reason: "empty" };
+  if (values.length === 1 && !parsed.explicitList) return { ok: false, reason: "not-list" };
+  if (values.length > SQL_IN_LIST_PASTE_MAX_VALUES) {
+    return { ok: false, reason: "too-many-values", limit: SQL_IN_LIST_PASTE_MAX_VALUES };
+  }
+
+  const literals = values.map(formatSqlLiteral);
+  return {
+    ok: true,
+    sql: `IN (${literals.join(", ")})`,
+    valueCount: values.length,
+  };
+}
+
+export function sqlInConditionNeedsListOnly(prefix: string): boolean {
+  return /\b(?:not\s+)?in\s*$/i.test(prefix);
+}
+
+export function insertTextForSqlInCondition(condition: string, prefix: string): string {
+  if (sqlInConditionNeedsListOnly(prefix)) return condition.replace(/^IN\s+/i, "");
+  if (!prefix || /\s$|\($/.test(prefix)) return condition;
+  return ` ${condition}`;
+}
+
+function parsePastedValues(source: string): ParsedPasteValues {
+  const sourceText = source.replace(/\r\n?/g, "\n").trim();
+  const withoutInKeyword = stripLeadingInKeyword(sourceText);
+  const explicitSource = withoutInKeyword.trim();
+  const explicitList = explicitSource.startsWith("(") && explicitSource.endsWith(")") && hasSingleWrappingParentheses(explicitSource);
+  const trimmed = stripOuterParentheses(withoutInKeyword);
+  if (!trimmed) return { values: [], explicitList };
+
+  return {
+    values: splitPasteTokens(trimmed)
+      .map(normalizePastedToken)
+      .filter((value): value is ParsedPasteValue => !!value),
+    explicitList,
+  };
+}
+
+function stripLeadingInKeyword(value: string): string {
+  const match = /^(?:not\s+)?in\b\s*([\s\S]*)$/i.exec(value.trim());
+  return match ? match[1].trim() : value;
+}
+
+function splitPasteTokens(source: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: "'" | '"' | null = null;
+  const slashIsDelimiter = shouldSplitSlashSeparatedValues(source);
+
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index];
+    const next = source[index + 1];
+
+    if (quote) {
+      current += char;
+      if (char === quote) {
+        if (next === quote) {
+          current += next;
+          index += 1;
+        } else {
+          quote = null;
+        }
+      }
+      continue;
+    }
+
+    if ((char === "'" || char === '"') && current.trim().length === 0) {
+      quote = char;
+      current += char;
+      continue;
+    }
+
+    if (char === "," || char === "\n" || char === "\t" || (slashIsDelimiter && char === "/")) {
+      tokens.push(current);
+      current = "";
+      continue;
+    }
+
+    current += char;
+  }
+
+  tokens.push(current);
+  return tokens;
+}
+
+function shouldSplitSlashSeparatedValues(source: string): boolean {
+  const trimmed = source.trim();
+  if (!trimmed.includes("/") || /[,\n\t]/.test(trimmed)) return false;
+  if (trimmed.includes("'") || trimmed.includes('"')) return false;
+  if (trimmed.startsWith("/") || /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) return false;
+  if (/^\d{4}\/\d{1,2}\/\d{1,2}(?:\D|$)/.test(trimmed) || /^\d{1,2}\/\d{1,2}\/\d{4}(?:\D|$)/.test(trimmed)) return false;
+
+  const parts = trimmed.split("/").map((part) => part.trim());
+  if (parts.length < 2 || parts.some((part) => !part)) return false;
+  return parts.every((part) => SIMPLE_SLASH_LIST_VALUE_RE.test(part));
+}
+
+function normalizePastedToken(token: string): ParsedPasteValue | null {
+  let value = stripOuterParentheses(
+    token
+      .trim()
+      .replace(/[;,]+$/g, "")
+      .trim(),
+  );
+  if (!value) return null;
+
+  const first = value[0];
+  const last = value[value.length - 1];
+  const quoted = value.length >= 2 && ((first === "'" && last === "'") || (first === '"' && last === '"'));
+  if (quoted) {
+    value = value.slice(1, -1);
+    value = first === "'" ? value.replace(/''/g, "'") : value.replace(/""/g, '"');
+  }
+
+  value = value.trim();
+  if (!value) return null;
+  return { value, quoted };
+}
+
+function stripOuterParentheses(value: string): string {
+  let next = value.trim();
+  while (next.startsWith("(") && next.endsWith(")") && hasSingleWrappingParentheses(next)) {
+    next = next.slice(1, -1).trim();
+  }
+  return next;
+}
+
+function hasSingleWrappingParentheses(value: string): boolean {
+  let depth = 0;
+  let quote: "'" | '"' | null = null;
+
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    const next = value[index + 1];
+
+    if (quote) {
+      if (char === quote) {
+        if (next === quote) index += 1;
+        else quote = null;
+      }
+      continue;
+    }
+
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+
+    if (char === "(") depth += 1;
+    if (char === ")") depth -= 1;
+    if (depth === 0 && index < value.length - 1) return false;
+  }
+
+  return depth === 0;
+}
+
+function formatSqlLiteral(token: ParsedPasteValue): string {
+  if (!token.quoted && /^null$/i.test(token.value)) return "NULL";
+  return `'${token.value.replace(/'/g, "''")}'`;
+}
diff --git a/apps/desktop/src/lib/sql/sqlMetadataRefresh.ts b/apps/desktop/src/lib/sql/sqlMetadataRefresh.ts
new file mode 100644
index 0000000..81b43e0
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlMetadataRefresh.ts
@@ -0,0 +1,68 @@
+export type SqlMetadataRefreshScope = "none" | "connection" | "database";
+export type SqlMetadataRefreshTarget = { scope: "none" } | { scope: "connection" } | { scope: "database"; schema?: string };
+
+const DATABASE_DDL_RE = /\b(CREATE|DROP)\s+DATABASE\b/i;
+const SCHEMA_DDL_RE = /\b(CREATE|DROP)\s+SCHEMA\b/i;
+const OBJECT_DDL_RE = /\b(CREATE|ALTER|DROP|RENAME)\s+(OR\s+REPLACE\s+)?(((GLOBAL|LOCAL)\s+)?TEMP(ORARY)?\s+)?(MATERIALIZED\s+)?(TABLE|VIEW|INDEX|SEQUENCE|PROCEDURE|FUNCTION|TRIGGER|TYPE)\b/i;
+const OBJECT_NAME_DDL_RE =
+  /\b(?:CREATE|ALTER|DROP|RENAME)\s+(?:OR\s+REPLACE\s+)?(?:(?:(?:GLOBAL|LOCAL)\s+)?TEMP(?:ORARY)?\s+)?(?:MATERIALIZED\s+)?(?:TABLE|VIEW|SEQUENCE|PROCEDURE|FUNCTION|TRIGGER|TYPE)\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?((?:"[^"]+"|`[^`]+`|\[[^\]]+\]|[A-Za-z_][\w$]*)\s*\.\s*(?:"[^"]+"|`[^`]+`|\[[^\]]+\]|[A-Za-z_][\w$]*))/i;
+const INDEX_TABLE_DDL_RE = /\bCREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:"[^"]+"|`[^`]+`|\[[^\]]+\]|[A-Za-z_][\w$]*)\s+ON\s+((?:"[^"]+"|`[^`]+`|\[[^\]]+\]|[A-Za-z_][\w$]*)\s*\.\s*(?:"[^"]+"|`[^`]+`|\[[^\]]+\]|[A-Za-z_][\w$]*))/i;
+
+function stripSqlMetadataComments(sql: string): string {
+  return sql
+    .replace(/\/\*[\s\S]*?\*\//g, " ")
+    .replace(/--.*$/gm, " ")
+    .replace(/#.*$/gm, " ");
+}
+
+export function sqlMetadataRefreshScope(sql: string): SqlMetadataRefreshScope {
+  return sqlMetadataRefreshTarget(sql).scope;
+}
+
+function splitSqlMetadataStatements(sql: string): string[] {
+  return stripSqlMetadataComments(sql)
+    .split(";")
+    .map((stmt) => stmt.trim())
+    .filter(Boolean);
+}
+
+function unquoteIdentifier(identifier: string): string {
+  const trimmed = identifier.trim();
+  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("`") && trimmed.endsWith("`")) || (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+
+function schemaFromQualifiedName(qualifiedName: string): string | undefined {
+  const schema = qualifiedName.split(".")[0]?.trim();
+  return schema ? unquoteIdentifier(schema) : undefined;
+}
+
+function schemaFromObjectDdl(statement: string): string | undefined {
+  const match = statement.match(INDEX_TABLE_DDL_RE) || statement.match(OBJECT_NAME_DDL_RE);
+  return match?.[1] ? schemaFromQualifiedName(match[1]) : undefined;
+}
+
+export function sqlMetadataRefreshTarget(sql: string, activeSchema?: string): SqlMetadataRefreshTarget {
+  const statements = splitSqlMetadataStatements(sql);
+  if (statements.some((stmt) => DATABASE_DDL_RE.test(stmt))) return { scope: "connection" };
+
+  const schemaTargets = new Set<string>();
+  let hasDatabaseRefresh = false;
+
+  for (const statement of statements) {
+    if (SCHEMA_DDL_RE.test(statement)) {
+      hasDatabaseRefresh = true;
+      continue;
+    }
+    if (!OBJECT_DDL_RE.test(statement)) continue;
+    hasDatabaseRefresh = true;
+    const schema = schemaFromObjectDdl(statement) || activeSchema;
+    if (schema) schemaTargets.add(schema);
+  }
+
+  if (!hasDatabaseRefresh) return { scope: "none" };
+  if (schemaTargets.size === 1) return { scope: "database", schema: [...schemaTargets][0] };
+  return { scope: "database" };
+}
diff --git a/apps/desktop/src/lib/sql/sqlNavigation.ts b/apps/desktop/src/lib/sql/sqlNavigation.ts
new file mode 100644
index 0000000..a9653f0
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlNavigation.ts
@@ -0,0 +1,256 @@
+/**
+ * Utilities for SQL identifier navigation (Ctrl/Cmd + click on table/column names).
+ */
+
+const SQL_KEYWORDS_SET = new Set([
+  "select",
+  "from",
+  "where",
+  "join",
+  "left",
+  "right",
+  "inner",
+  "outer",
+  "on",
+  "group",
+  "by",
+  "order",
+  "asc",
+  "desc",
+  "having",
+  "limit",
+  "offset",
+  "insert",
+  "into",
+  "values",
+  "update",
+  "set",
+  "delete",
+  "create",
+  "table",
+  "view",
+  "as",
+  "and",
+  "or",
+  "not",
+  "in",
+  "is",
+  "null",
+  "like",
+  "distinct",
+  "union",
+  "all",
+  "exists",
+  "between",
+  "case",
+  "when",
+  "then",
+  "else",
+  "end",
+  "count",
+  "sum",
+  "avg",
+  "min",
+  "max",
+  "coalesce",
+  "cast",
+  "alter",
+  "drop",
+  "add",
+  "column",
+  "index",
+  "primary",
+  "key",
+  "foreign",
+  "references",
+  "constraint",
+  "default",
+  "check",
+  "unique",
+  "begin",
+  "commit",
+  "rollback",
+  "truncate",
+  "explain",
+  "analyze",
+  "with",
+  "recursive",
+  "over",
+  "partition",
+  "row_number",
+  "rank",
+  "dense_rank",
+  "lag",
+  "lead",
+  "first_value",
+  "last_value",
+  "ntile",
+  "cross",
+  "full",
+  "natural",
+  "using",
+  "lateral",
+  "unnest",
+  "filter",
+  "exclude",
+  "replace",
+  "qualify",
+  "pivot",
+  "unpivot",
+  "asof",
+  "positional",
+  "anti",
+  "semi",
+  "sample",
+  "struct",
+  "map",
+  "list",
+  "array",
+  "lambda",
+  "copy",
+  "export",
+  "import",
+  "describe",
+  "show",
+  "summarize",
+  "pragma",
+  "tablesample",
+  "read_csv",
+  "read_parquet",
+  "read_json",
+  "list_transform",
+]);
+
+type IdentifierPart = { value: string; start: number; end: number; quoted: boolean };
+
+export interface ExtractedSqlIdentifier {
+  identifier: string;
+  quoted: boolean;
+}
+
+function isIdentifierChar(char: string | undefined): boolean {
+  return !!char && /^[A-Za-z0-9_$]$/.test(char);
+}
+
+function readQuotedPart(text: string, start: number): IdentifierPart | null {
+  const open = text[start];
+  const close = open === "[" ? "]" : open;
+  if (open !== "`" && open !== '"' && open !== "[") return null;
+
+  let value = "";
+  for (let i = start + 1; i < text.length; i += 1) {
+    const char = text[i];
+    if (char === close) {
+      if (text[i + 1] === close) {
+        value += close;
+        i += 1;
+        continue;
+      }
+      return { value, start, end: i + 1, quoted: true };
+    }
+    value += char;
+  }
+  return null;
+}
+
+function readUnquotedPart(text: string, start: number): IdentifierPart | null {
+  if (!isIdentifierChar(text[start])) return null;
+  let end = start + 1;
+  while (end < text.length && isIdentifierChar(text[end])) end += 1;
+  return { value: text.slice(start, end), start, end, quoted: false };
+}
+
+function readIdentifierPart(text: string, start: number): IdentifierPart | null {
+  return readQuotedPart(text, start) ?? readUnquotedPart(text, start);
+}
+
+function parseQualifiedIdentifier(text: string, start: number): { parts: IdentifierPart[]; start: number; end: number } | null {
+  const first = readIdentifierPart(text, start);
+  if (!first) return null;
+
+  const parts = [first];
+  let end = first.end;
+  while (text[end] === ".") {
+    const next = readIdentifierPart(text, end + 1);
+    if (!next) break;
+    parts.push(next);
+    end = next.end;
+  }
+
+  return { parts, start, end };
+}
+
+function identifierSearchBounds(doc: string, pos: number): { start: number; end: number } {
+  let start = pos;
+  while (start > 0 && doc[start - 1] !== "\n" && doc[start - 1] !== "\r") start -= 1;
+
+  let end = pos;
+  while (end < doc.length && doc[end] !== "\n" && doc[end] !== "\r") end += 1;
+
+  return { start, end };
+}
+
+/** Extract identifier and quote metadata at position `pos` in the document. */
+export function extractIdentifierDetailsAt(doc: string, pos: number): ExtractedSqlIdentifier | null {
+  if (pos < 0 || pos > doc.length) return null;
+
+  const clickPos = pos === doc.length ? pos - 1 : pos;
+  if (clickPos < 0) return null;
+
+  const bounds = identifierSearchBounds(doc, clickPos);
+  let index = bounds.start;
+  while (index < bounds.end) {
+    const parsed = parseQualifiedIdentifier(doc, index);
+    if (parsed) {
+      if (clickPos >= parsed.start && clickPos < parsed.end) {
+        return {
+          identifier: parsed.parts.map((part) => part.value).join("."),
+          quoted: parsed.parts.some((part) => part.quoted),
+        };
+      }
+      index = Math.max(parsed.end, index + 1);
+      continue;
+    }
+    index += 1;
+  }
+
+  return null;
+}
+
+/** Extract identifier at position `pos` in the document. */
+export function extractIdentifierAt(doc: string, pos: number): string | null {
+  return extractIdentifierDetailsAt(doc, pos)?.identifier ?? null;
+}
+
+/** Check whether the identifier is a SQL keyword (not a table/column name). */
+export function isSqlKeyword(identifier: string): boolean {
+  return SQL_KEYWORDS_SET.has(identifier.toLowerCase());
+}
+
+export function splitQualifiedIdentifier(identifier: string): string[] {
+  const trimmed = identifier.trim();
+  if (!trimmed) return [];
+
+  const parsed = parseQualifiedIdentifier(trimmed, 0);
+  if (!parsed || parsed.end !== trimmed.length) return [trimmed];
+  return parsed.parts.map((part) => part.value);
+}
+
+/** Match identifier against known table names (case-insensitive). Supports qualified identifiers like schema.table. */
+export function matchTable(identifier: string, tables: Array<{ name: string; schema?: string }>): { name: string; schema?: string } | null {
+  const parts = splitQualifiedIdentifier(identifier);
+  const normalizedIdentifier = parts.length > 0 ? parts.join(".").toLowerCase() : identifier.toLowerCase();
+
+  const direct = tables.find((t) => t.name.toLowerCase() === normalizedIdentifier);
+  if (direct) return direct;
+
+  if (parts.length >= 2) {
+    // Use the final two parts so catalog.schema.table still resolves against schema-scoped metadata.
+    const qualifier = parts[parts.length - 2].toLowerCase();
+    const name = parts[parts.length - 1].toLowerCase();
+    const qualified = tables.find((t) => t.name.toLowerCase() === name && t.schema?.toLowerCase() === qualifier);
+    if (qualified) return qualified;
+  }
+
+  return null;
+}
diff --git a/apps/desktop/src/lib/sql/sqlParameterHistory.ts b/apps/desktop/src/lib/sql/sqlParameterHistory.ts
new file mode 100644
index 0000000..c5b339b
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlParameterHistory.ts
@@ -0,0 +1,65 @@
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+import type { SqlParameterInput } from "@/lib/sql/sqlParameters";
+
+const STORAGE_KEY = "dbx-sql-parameter-history";
+export const MAX_SQL_PARAMETER_HISTORY = 8;
+
+interface StoredSqlParameterHistory {
+  version: 1;
+  parameters: Record<string, SqlParameterInput[]>;
+}
+
+function emptyHistory(): StoredSqlParameterHistory {
+  return { version: 1, parameters: {} };
+}
+
+function readHistory(): StoredSqlParameterHistory {
+  const raw = safeLocalStorageGet(STORAGE_KEY);
+  if (!raw) return emptyHistory();
+  try {
+    const parsed = JSON.parse(raw) as Partial<StoredSqlParameterHistory>;
+    if (parsed.version !== 1 || !parsed.parameters || typeof parsed.parameters !== "object") return emptyHistory();
+    return { version: 1, parameters: parsed.parameters };
+  } catch {
+    return emptyHistory();
+  }
+}
+
+function writeHistory(history: StoredSqlParameterHistory) {
+  safeLocalStorageSet(STORAGE_KEY, JSON.stringify(history));
+}
+
+function normalizeParameterName(name: string): string {
+  return name.trim().toLowerCase();
+}
+
+function normalizeInput(input: SqlParameterInput): SqlParameterInput | null {
+  if (input.kind === "null") return { kind: "null", value: "NULL" };
+  const value = input.value.trim();
+  if (!value) return null;
+  return { kind: input.kind, value };
+}
+
+export function loadSqlParameterHistory(name: string): SqlParameterInput[] {
+  return (readHistory().parameters[normalizeParameterName(name)] ?? []).slice(0, MAX_SQL_PARAMETER_HISTORY);
+}
+
+export function rememberSqlParameterValue(name: string, input: SqlParameterInput): SqlParameterInput[] {
+  const normalized = normalizeInput(input);
+  if (!normalized) return loadSqlParameterHistory(name);
+
+  const history = readHistory();
+  const key = normalizeParameterName(name);
+  const previous = history.parameters[key] ?? [];
+  history.parameters[key] = [normalized, ...previous.filter((entry) => entry.value !== normalized.value || entry.kind !== normalized.kind)].slice(0, MAX_SQL_PARAMETER_HISTORY);
+  writeHistory(history);
+  return history.parameters[key];
+}
+
+export function rememberSqlParameterValues(values: Record<string, SqlParameterInput>): Record<string, SqlParameterInput[]> {
+  const result: Record<string, SqlParameterInput[]> = {};
+  for (const [name, input] of Object.entries(values)) {
+    result[name] = rememberSqlParameterValue(name, input);
+  }
+  return result;
+}
diff --git a/apps/desktop/src/lib/sql/sqlParameters.ts b/apps/desktop/src/lib/sql/sqlParameters.ts
new file mode 100644
index 0000000..c180e62
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlParameters.ts
@@ -0,0 +1,613 @@
+import type { DatabaseType } from "@/types/database";
+
+export type SqlParameterValueKind = "string" | "number" | "boolean" | "null" | "raw";
+
+export interface SqlParameterInput {
+  kind: SqlParameterValueKind;
+  value: string;
+}
+
+export type SqlParameterSyntax = "positional" | "named" | "shell" | "mybatis" | "sqlserver";
+
+export interface SqlParameterDescriptor {
+  key: string;
+  name: string;
+  syntax: SqlParameterSyntax;
+  token: string;
+}
+
+interface ParameterOccurrence extends SqlParameterDescriptor {
+  start: number;
+  end: number;
+}
+
+export interface SqlParameterOptions {
+  databaseType?: DatabaseType;
+  // Which placeholder syntaxes are recognized. Undefined enables all of them.
+  enabledSyntaxes?: readonly SqlParameterSyntax[];
+}
+
+const PARAMETER_NAME_RE = /^[\p{L}_][\p{L}\p{N}_]*$/u;
+const PARAMETER_NAME_START_RE = /[\p{L}_]/u;
+const PARAMETER_NAME_CHAR_RE = /[\p{L}\p{N}_]/u;
+const SQL_SERVER_TEMP_TABLE_CONTEXT_KEYWORDS = new Set(["table", "from", "join", "into", "update", "truncate"]);
+
+export function extractSqlParameters(sql: string, options?: SqlParameterOptions): string[] {
+  return extractSqlParameterDescriptors(sql, options).map((descriptor) => descriptor.key);
+}
+
+export function extractSqlParameterDescriptors(sql: string, options?: SqlParameterOptions): SqlParameterDescriptor[] {
+  const names = new Set<string>();
+  const descriptors: SqlParameterDescriptor[] = [];
+  for (const occurrence of findSqlParameterOccurrences(sql, options)) {
+    if (names.has(occurrence.key)) continue;
+    names.add(occurrence.key);
+    descriptors.push({
+      key: occurrence.key,
+      name: occurrence.name,
+      syntax: occurrence.syntax,
+      token: occurrence.token,
+    });
+  }
+  return descriptors;
+}
+
+export function substituteSqlParameters(sql: string, values: Record<string, SqlParameterInput>, options?: SqlParameterOptions): string {
+  const occurrences = findSqlParameterOccurrences(sql, options);
+  if (!occurrences.length) return sql;
+
+  let result = "";
+  let cursor = 0;
+  for (const occurrence of occurrences) {
+    result += sql.slice(cursor, occurrence.start);
+    result += sqlParameterLiteral(values[occurrence.key] ?? { kind: "string", value: "" });
+    cursor = occurrence.end;
+  }
+  result += sql.slice(cursor);
+  return result;
+}
+
+export function sqlParameterLiteral(input: SqlParameterInput): string {
+  if (input.kind === "null") return "NULL";
+  const raw = input.value;
+  if (input.kind === "raw") return raw.trim() || "NULL";
+  if (input.kind === "number") return raw.trim() || "NULL";
+  if (input.kind === "boolean") return normalizeBooleanLiteral(raw);
+  return quoteSqlString(raw);
+}
+
+function findSqlParameterOccurrences(sql: string, options?: SqlParameterOptions): ParameterOccurrence[] {
+  const occurrences: ParameterOccurrence[] = [];
+  const nativeSqlServerParameters = collectNativeSqlServerParameters(sql);
+  const supportsNamedParameters = options?.databaseType !== "saphana";
+  const enabledSyntaxes = options?.enabledSyntaxes ? new Set(options.enabledSyntaxes) : null;
+  const isSyntaxEnabled = (syntax: SqlParameterSyntax) => !enabledSyntaxes || enabledSyntaxes.has(syntax);
+  let i = 0;
+  let dollarQuoteEnd = "";
+  let positionalIndex = 0;
+
+  while (i < sql.length) {
+    if (dollarQuoteEnd) {
+      const end = sql.indexOf(dollarQuoteEnd, i);
+      if (end === -1) break;
+      i = end + dollarQuoteEnd.length;
+      dollarQuoteEnd = "";
+      continue;
+    }
+
+    const ch = sql[i];
+    const next = sql[i + 1];
+
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(sql, i, ch);
+      continue;
+    }
+    if (ch === "[") {
+      i = skipBracketIdentifier(sql, i);
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      i = skipLine(sql, i + 2);
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i = skipBlockComment(sql, i + 2);
+      continue;
+    }
+    if (ch === "?" && isSyntaxEnabled("positional")) {
+      positionalIndex += 1;
+      const key = `?${positionalIndex}`;
+      occurrences.push({ key, name: key, syntax: "positional", token: "?", start: i, end: i + 1 });
+      i += 1;
+      continue;
+    }
+    if (ch === ":" && supportsNamedParameters && isSyntaxEnabled("named")) {
+      const name = readParameterName(sql, i + 1);
+      if (name && sql[i - 1] !== ":" && sql[i + 1] !== "=") {
+        occurrences.push({
+          key: name,
+          name,
+          syntax: "named",
+          token: sql.slice(i, i + 1 + name.length),
+          start: i,
+          end: i + 1 + name.length,
+        });
+        i += 1 + name.length;
+        continue;
+      }
+    }
+    if (ch === "$" && next === "{" && isSyntaxEnabled("shell")) {
+      const end = sql.indexOf("}", i + 2);
+      if (end !== -1) {
+        const name = sql.slice(i + 2, end).trim();
+        if (PARAMETER_NAME_RE.test(name)) {
+          occurrences.push({ key: name, name, syntax: "shell", token: sql.slice(i, end + 1), start: i, end: end + 1 });
+          i = end + 1;
+          continue;
+        }
+      }
+    }
+    if (ch === "#" && next === "{" && isSyntaxEnabled("mybatis")) {
+      const end = sql.indexOf("}", i + 2);
+      if (end !== -1) {
+        const name = sql.slice(i + 2, end).trim();
+        if (PARAMETER_NAME_RE.test(name)) {
+          occurrences.push({ key: name, name, syntax: "mybatis", token: sql.slice(i, end + 1), start: i, end: end + 1 });
+          i = end + 1;
+          continue;
+        }
+      }
+    }
+    if (isHashLineComment(sql, i)) {
+      i = skipLine(sql, i + 1);
+      continue;
+    }
+    if (ch === "@" && isSyntaxEnabled("sqlserver")) {
+      const name = readParameterName(sql, i + 1);
+      if (name && next !== "@" && sql[i - 1] !== "@" && !nativeSqlServerParameters.declared.has(name.toLowerCase()) && !nativeSqlServerParameters.ignoredStarts.has(i)) {
+        occurrences.push({
+          key: name,
+          name,
+          syntax: "sqlserver",
+          token: sql.slice(i, i + 1 + name.length),
+          start: i,
+          end: i + 1 + name.length,
+        });
+        i += 1 + name.length;
+        continue;
+      }
+    }
+    if (ch === "$") {
+      const marker = readDollarQuoteMarker(sql, i);
+      if (marker) {
+        dollarQuoteEnd = marker;
+        i += marker.length;
+        continue;
+      }
+    }
+    i += 1;
+  }
+
+  return occurrences;
+}
+
+function collectNativeSqlServerParameters(sql: string): { declared: Set<string>; ignoredStarts: Set<number> } {
+  const declared = new Set<string>();
+  const ignoredStarts = new Set<number>();
+  let i = 0;
+  let dollarQuoteEnd = "";
+
+  while (i < sql.length) {
+    if (dollarQuoteEnd) {
+      const end = sql.indexOf(dollarQuoteEnd, i);
+      if (end === -1) break;
+      i = end + dollarQuoteEnd.length;
+      dollarQuoteEnd = "";
+      continue;
+    }
+
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(sql, i, ch);
+      continue;
+    }
+    if (ch === "[") {
+      i = skipBracketIdentifier(sql, i);
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      i = skipLine(sql, i + 2);
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i = skipBlockComment(sql, i + 2);
+      continue;
+    }
+    if (ch === "$") {
+      const marker = readDollarQuoteMarker(sql, i);
+      if (marker) {
+        dollarQuoteEnd = marker;
+        i += marker.length;
+        continue;
+      }
+    }
+    if (isHashLineComment(sql, i)) {
+      i = skipLine(sql, i + 1);
+      continue;
+    }
+    if (matchesWord(sql, i, "declare")) {
+      i = collectDeclareStatementVariables(sql, i + "declare".length, declared);
+      continue;
+    }
+    if (matchesWord(sql, i, "set")) {
+      i = collectSetStatementVariables(sql, i + "set".length, declared);
+      continue;
+    }
+    if (matchesWord(sql, i, "select")) {
+      i = collectSelectAssignmentVariables(sql, i + "select".length, declared);
+      continue;
+    }
+    if ((matchesWord(sql, i, "create") || matchesWord(sql, i, "alter")) && isRoutineDefinitionStart(sql, i)) {
+      i = collectRoutineDefinitionVariables(sql, i, declared);
+      continue;
+    }
+    if (matchesWord(sql, i, "exec") || matchesWord(sql, i, "execute")) {
+      i = collectExecNamedArgumentStarts(sql, i + (matchesWord(sql, i, "exec") ? "exec".length : "execute".length), ignoredStarts);
+      continue;
+    }
+    i += 1;
+  }
+
+  return { declared, ignoredStarts };
+}
+
+function collectDeclareStatementVariables(sql: string, start: number, declared: Set<string>): number {
+  let i = start;
+  while (i < sql.length) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (ch === ";") return i + 1;
+    if (isLineStatementStart(sql, i) && isSqlStatementKeyword(sql, i)) return i;
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(sql, i, ch);
+      continue;
+    }
+    if (ch === "[") {
+      i = skipBracketIdentifier(sql, i);
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      i = skipLine(sql, i + 2);
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i = skipBlockComment(sql, i + 2);
+      continue;
+    }
+    if (isHashLineComment(sql, i)) {
+      i = skipLine(sql, i + 1);
+      continue;
+    }
+    if (ch === "@") {
+      const name = readParameterName(sql, i + 1);
+      if (name && next !== "@" && sql[i - 1] !== "@") {
+        declared.add(name.toLowerCase());
+        i += 1 + name.length;
+        continue;
+      }
+    }
+    i += 1;
+  }
+  return i;
+}
+
+function collectSetStatementVariables(sql: string, start: number, declared: Set<string>): number {
+  let i = start;
+  while (i < sql.length) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (ch === ";") return i + 1;
+    if (isLineStatementStart(sql, i) && isSqlStatementKeyword(sql, i)) return i;
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(sql, i, ch);
+      continue;
+    }
+    if (ch === "[") {
+      i = skipBracketIdentifier(sql, i);
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      i = skipLine(sql, i + 2);
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i = skipBlockComment(sql, i + 2);
+      continue;
+    }
+    if (isHashLineComment(sql, i)) {
+      i = skipLine(sql, i + 1);
+      continue;
+    }
+    if (ch === "@") {
+      const name = readParameterName(sql, i + 1);
+      if (name && next !== "@" && sql[i - 1] !== "@" && isSetAssignmentTarget(sql, i + 1 + name.length)) {
+        declared.add(name.toLowerCase());
+        i += 1 + name.length;
+        continue;
+      }
+    }
+    i += 1;
+  }
+  return i;
+}
+
+function collectSelectAssignmentVariables(sql: string, start: number, declared: Set<string>): number {
+  let i = start;
+  while (i < sql.length) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (ch === ";") return i + 1;
+    if (isLineStatementStart(sql, i) && isSqlStatementKeyword(sql, i)) return i;
+    if (matchesWord(sql, i, "from")) return i;
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(sql, i, ch);
+      continue;
+    }
+    if (ch === "[") {
+      i = skipBracketIdentifier(sql, i);
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      i = skipLine(sql, i + 2);
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i = skipBlockComment(sql, i + 2);
+      continue;
+    }
+    if (isHashLineComment(sql, i)) {
+      i = skipLine(sql, i + 1);
+      continue;
+    }
+    if (ch === "@") {
+      const name = readParameterName(sql, i + 1);
+      if (name && next !== "@" && sql[i - 1] !== "@" && isSetAssignmentTarget(sql, i + 1 + name.length)) {
+        declared.add(name.toLowerCase());
+        i += 1 + name.length;
+        continue;
+      }
+    }
+    i += 1;
+  }
+  return i;
+}
+
+function collectRoutineDefinitionVariables(sql: string, start: number, declared: Set<string>): number {
+  let i = start;
+  while (i < sql.length) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (ch === ";") return i + 1;
+    if (matchesWord(sql, i, "as") || matchesWord(sql, i, "returns")) return i;
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(sql, i, ch);
+      continue;
+    }
+    if (ch === "[") {
+      i = skipBracketIdentifier(sql, i);
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      i = skipLine(sql, i + 2);
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i = skipBlockComment(sql, i + 2);
+      continue;
+    }
+    if (isHashLineComment(sql, i)) {
+      i = skipLine(sql, i + 1);
+      continue;
+    }
+    if (ch === "@") {
+      const name = readParameterName(sql, i + 1);
+      if (name && next !== "@" && sql[i - 1] !== "@") {
+        declared.add(name.toLowerCase());
+        i += 1 + name.length;
+        continue;
+      }
+    }
+    i += 1;
+  }
+  return i;
+}
+
+function collectExecNamedArgumentStarts(sql: string, start: number, ignoredStarts: Set<number>): number {
+  let i = start;
+  while (i < sql.length) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (ch === ";") return i + 1;
+    if (isLineStatementStart(sql, i) && isSqlStatementKeyword(sql, i)) return i;
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(sql, i, ch);
+      continue;
+    }
+    if (ch === "[") {
+      i = skipBracketIdentifier(sql, i);
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      i = skipLine(sql, i + 2);
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i = skipBlockComment(sql, i + 2);
+      continue;
+    }
+    if (isHashLineComment(sql, i)) {
+      i = skipLine(sql, i + 1);
+      continue;
+    }
+    if (ch === "@") {
+      const name = readParameterName(sql, i + 1);
+      if (name && next !== "@" && sql[i - 1] !== "@" && isSetAssignmentTarget(sql, i + 1 + name.length)) {
+        ignoredStarts.add(i);
+        i += 1 + name.length;
+        continue;
+      }
+    }
+    i += 1;
+  }
+  return i;
+}
+
+function isRoutineDefinitionStart(sql: string, start: number): boolean {
+  const keyword = matchesWord(sql, start, "create") ? "create" : matchesWord(sql, start, "alter") ? "alter" : "";
+  if (!keyword) return false;
+
+  let next = readNextKeyword(sql, start + keyword.length);
+  if (!next) return false;
+  if (keyword === "create" && next.word === "or") {
+    const afterOr = readNextKeyword(sql, next.end);
+    if (!afterOr || (afterOr.word !== "alter" && afterOr.word !== "replace")) return false;
+    next = readNextKeyword(sql, afterOr.end);
+    if (!next) return false;
+  }
+  return next.word === "procedure" || next.word === "proc" || next.word === "function";
+}
+
+function readNextKeyword(sql: string, start: number): { word: string; end: number } | null {
+  let i = start;
+  while (i < sql.length) {
+    while (i < sql.length && /\s/.test(sql[i])) i += 1;
+    if (sql[i] === "-" && sql[i + 1] === "-") {
+      i = skipLine(sql, i + 2);
+      continue;
+    }
+    if (sql[i] === "/" && sql[i + 1] === "*") {
+      i = skipBlockComment(sql, i + 2);
+      continue;
+    }
+    break;
+  }
+  if (!PARAMETER_NAME_START_RE.test(sql[i] ?? "")) return null;
+  let end = i + 1;
+  while (end < sql.length && PARAMETER_NAME_CHAR_RE.test(sql[end])) end += 1;
+  return { word: sql.slice(i, end).toLowerCase(), end };
+}
+
+function isSetAssignmentTarget(sql: string, start: number): boolean {
+  let i = start;
+  while (i < sql.length && /\s/.test(sql[i])) i += 1;
+  return sql[i] === "=" || (sql[i] === ":" && sql[i + 1] === "=");
+}
+
+function isLineStatementStart(sql: string, start: number): boolean {
+  let i = start - 1;
+  while (i >= 0 && (sql[i] === " " || sql[i] === "\t" || sql[i] === "\r")) i -= 1;
+  return i >= 0 && sql[i] === "\n";
+}
+
+function isSqlStatementKeyword(sql: string, start: number): boolean {
+  return ["select", "with", "insert", "update", "delete", "merge", "exec", "execute", "set", "if", "while", "begin", "create", "alter", "drop", "truncate"].some((keyword) => matchesWord(sql, start, keyword));
+}
+
+function matchesWord(sql: string, start: number, word: string): boolean {
+  const value = sql.slice(start, start + word.length);
+  if (value.toLowerCase() !== word) return false;
+  return !PARAMETER_NAME_CHAR_RE.test(sql[start - 1] ?? "") && !PARAMETER_NAME_CHAR_RE.test(sql[start + word.length] ?? "");
+}
+
+function readParameterName(sql: string, start: number): string {
+  if (!PARAMETER_NAME_START_RE.test(sql[start] ?? "")) return "";
+  let i = start + 1;
+  while (i < sql.length && PARAMETER_NAME_CHAR_RE.test(sql[i])) i += 1;
+  return sql.slice(start, i);
+}
+
+function skipQuoted(sql: string, start: number, quote: string): number {
+  let i = start + 1;
+  while (i < sql.length) {
+    if (sql[i] === "\\" && quote === "'" && i + 1 < sql.length) {
+      i += 2;
+      continue;
+    }
+    if (sql[i] === quote) {
+      if (sql[i + 1] === quote) {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i += 1;
+  }
+  return sql.length;
+}
+
+function skipBracketIdentifier(sql: string, start: number): number {
+  let i = start + 1;
+  while (i < sql.length) {
+    if (sql[i] === "]") {
+      if (sql[i + 1] === "]") {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i += 1;
+  }
+  return sql.length;
+}
+
+function skipLine(sql: string, start: number): number {
+  const nextNewline = sql.indexOf("\n", start);
+  return nextNewline === -1 ? sql.length : nextNewline + 1;
+}
+
+function skipBlockComment(sql: string, start: number): number {
+  const end = sql.indexOf("*/", start);
+  return end === -1 ? sql.length : end + 2;
+}
+
+function isHashLineComment(sql: string, start: number): boolean {
+  if (sql[start] !== "#" || sql[start + 1] === "{") return false;
+  // Keep SQL Server #temp table names parseable while treating other # tokens as MySQL-style comments.
+  return !isSqlServerTempTableReference(sql, start);
+}
+
+function isSqlServerTempTableReference(sql: string, start: number): boolean {
+  let nameStart = start + 1;
+  if (sql[nameStart] === "#") nameStart += 1;
+  if (!PARAMETER_NAME_START_RE.test(sql[nameStart] ?? "")) return false;
+
+  const previous = previousKeyword(sql, start);
+  return !!previous && SQL_SERVER_TEMP_TABLE_CONTEXT_KEYWORDS.has(previous);
+}
+
+function previousKeyword(sql: string, start: number): string {
+  let end = start - 1;
+  while (end >= 0 && /\s/.test(sql[end])) end -= 1;
+  let begin = end;
+  while (begin >= 0 && PARAMETER_NAME_CHAR_RE.test(sql[begin])) begin -= 1;
+  begin += 1;
+  if (begin > end || !PARAMETER_NAME_START_RE.test(sql[begin] ?? "")) return "";
+  return sql.slice(begin, end + 1).toLowerCase();
+}
+
+function readDollarQuoteMarker(sql: string, start: number): string {
+  const match = sql.slice(start).match(/^\$[A-Za-z_][A-Za-z0-9_]*\$|^\$\$/);
+  return match?.[0] ?? "";
+}
+
+function quoteSqlString(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+function normalizeBooleanLiteral(value: string): string {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "t" || normalized === "yes" || normalized === "y" || normalized === "1") return "TRUE";
+  if (normalized === "false" || normalized === "f" || normalized === "no" || normalized === "n" || normalized === "0") return "FALSE";
+  return quoteSqlString(value);
+}
diff --git a/apps/desktop/src/lib/sql/sqlQuoteCaret.ts b/apps/desktop/src/lib/sql/sqlQuoteCaret.ts
new file mode 100644
index 0000000..60809ea
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlQuoteCaret.ts
@@ -0,0 +1,36 @@
+export interface SqlSingleQuoteCaretOptions {
+  previousValue: string;
+  nextValue: string;
+  selectionStart: number | null | undefined;
+}
+
+export type SqlSingleQuoteKeyAction = "pass" | "skipClosingQuote" | "insertEscapedQuote";
+
+export function resolveSqlSingleQuoteKeyAction(options: { previousChar?: string; nextChar?: string; autoCloseBrackets?: boolean }): SqlSingleQuoteKeyAction {
+  const { previousChar = "", nextChar = "", autoCloseBrackets = true } = options;
+  if (!autoCloseBrackets) return "pass";
+  if (previousChar === "'" && nextChar === "'") return "skipClosingQuote";
+  if (previousChar === "'") return "insertEscapedQuote";
+  return "pass";
+}
+
+export function insertedSqlSingleQuoteAtCaret(options: SqlSingleQuoteCaretOptions): boolean {
+  const { previousValue, nextValue, selectionStart } = options;
+  if (typeof selectionStart !== "number" || selectionStart < 1) return false;
+  if (nextValue.charAt(selectionStart - 1) !== "'") return false;
+  return nextValue.slice(0, selectionStart - 1) + nextValue.slice(selectionStart) === previousValue;
+}
+
+export function caretPositionInsideInsertedSqlSingleQuotes(options: SqlSingleQuoteCaretOptions): number | null {
+  const { previousValue, nextValue, selectionStart } = options;
+  if (typeof selectionStart !== "number" || selectionStart < 2) return null;
+  if (nextValue.slice(selectionStart - 2, selectionStart) !== "''") return null;
+
+  const singleQuoteInsertPrevious = nextValue.slice(0, selectionStart - 1) + nextValue.slice(selectionStart);
+  if (singleQuoteInsertPrevious === previousValue) return selectionStart - 1;
+
+  const pairInsertPrevious = nextValue.slice(0, selectionStart - 2) + nextValue.slice(selectionStart);
+  if (pairInsertPrevious === previousValue) return selectionStart - 1;
+
+  return null;
+}
diff --git a/apps/desktop/src/lib/sql/sqlRisk.ts b/apps/desktop/src/lib/sql/sqlRisk.ts
new file mode 100644
index 0000000..f3e9b56
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlRisk.ts
@@ -0,0 +1,276 @@
+import type { DatabaseType } from "@/types/database";
+
+export type SqlRiskLevel = "read" | "write" | "ddl" | "transaction" | "unknown";
+
+export interface SqlRiskStatementAssessment {
+  risk: SqlRiskLevel;
+  firstKeyword?: string;
+}
+
+export interface SqlRiskAssessment extends SqlRiskStatementAssessment {
+  statements: SqlRiskStatementAssessment[];
+}
+
+interface SqlRiskOptions {
+  dialect?: DatabaseType | string;
+}
+
+interface SqlRiskToken {
+  text: string;
+  normalized: string;
+}
+
+const READ_KEYWORDS = new Set(["select", "show", "describe", "desc", "values", "table"]);
+const WRITE_KEYWORDS = new Set(["insert", "update", "delete", "merge", "replace", "upsert", "load", "call", "exec", "execute", "flush"]);
+const DDL_KEYWORDS = new Set(["create", "alter", "drop", "truncate", "rename", "grant", "revoke", "deny", "comment", "reindex", "vacuum", "optimize"]);
+const TRANSACTION_KEYWORDS = new Set(["begin", "start", "commit", "rollback", "abort", "savepoint", "release"]);
+const EXPLAIN_OPTION_KEYWORDS = new Set(["explain", "analyze", "analyse", "verbose", "query", "plan", "format", "type", "costs", "buffers", "timing", "summary", "settings", "wal", "generic_plan"]);
+const PRIMARY_STATEMENT_KEYWORDS = new Set([...READ_KEYWORDS, ...WRITE_KEYWORDS, ...DDL_KEYWORDS, ...TRANSACTION_KEYWORDS, "with", "copy", "pragma", "use", "set"]);
+const SAFE_READ_PRAGMA_NAMES = new Set(["table_info", "table_xinfo", "index_list", "index_info", "foreign_key_list", "database_list", "compile_options", "data_version"]);
+
+const RISK_ORDER: Record<SqlRiskLevel, number> = {
+  read: 0,
+  write: 1,
+  ddl: 2,
+  transaction: 3,
+  unknown: 4,
+};
+
+export function splitSqlStatementsForSafety(sql: string): string[] {
+  return sqlSafetyText(sql)
+    .split(";")
+    .map((statement) => statement.trim())
+    .filter(Boolean);
+}
+
+export function classifySqlRisk(sql: string, options: SqlRiskOptions = {}): SqlRiskAssessment {
+  const statements = splitSqlStatementsForSafety(sql).map((statement) => classifySqlStatementRisk(statement, options));
+  if (!statements.length) return { risk: "unknown", statements: [] };
+  const highest = statements.reduce<SqlRiskStatementAssessment>((current, statement) => (RISK_ORDER[statement.risk] > RISK_ORDER[current.risk] ? statement : current), { risk: "read" });
+  return { ...highest, statements };
+}
+
+export function classifySqlStatementRisk(sql: string, _options: SqlRiskOptions = {}): SqlRiskStatementAssessment {
+  return classifyTokens(tokenizeSqlForRisk(sql));
+}
+
+export function isSqlRiskMutation(risk: SqlRiskLevel): boolean {
+  return risk !== "read";
+}
+
+export function sqlSafetyText(sql: string): string {
+  let output = "";
+  let index = 0;
+
+  while (index < sql.length) {
+    const char = sql[index] ?? "";
+    const next = sql[index + 1] ?? "";
+
+    if (char === "-" && next === "-") {
+      index += 2;
+      while (index < sql.length && sql[index] !== "\n" && sql[index] !== "\r") index += 1;
+      output += " ";
+      continue;
+    }
+
+    if (char === "#") {
+      index += 1;
+      while (index < sql.length && sql[index] !== "\n" && sql[index] !== "\r") index += 1;
+      output += " ";
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      const close = sql.indexOf("*/", index + 2);
+      if (close < 0) return output;
+      const executablePrefixLength = mysqlExecutableCommentPrefixLength(sql, index);
+      if (executablePrefixLength > 0) {
+        const bodyStart = skipExecutableCommentVersion(sql, index + executablePrefixLength);
+        output += ` ${sqlSafetyText(sql.slice(bodyStart, close))} `;
+      } else {
+        output += " ";
+      }
+      index = close + 2;
+      continue;
+    }
+
+    const dollarQuote = dollarQuoteTagAt(sql, index);
+    if (dollarQuote) {
+      const close = sql.indexOf(dollarQuote, index + dollarQuote.length);
+      index = close < 0 ? sql.length : close + dollarQuote.length;
+      output += " ";
+      continue;
+    }
+
+    if (char === "'") {
+      index = readQuotedEnd(sql, index, "'", "'");
+      output += " ";
+      continue;
+    }
+
+    if (char === '"' || char === "`" || char === "[") {
+      const close = char === "[" ? "]" : char;
+      const end = readQuotedEnd(sql, index, char, close);
+      output += ` ${unquoteIdentifier(sql.slice(index, end), char, close).replace(/[;]/g, " ")} `;
+      index = end;
+      continue;
+    }
+
+    output += char;
+    index += 1;
+  }
+
+  return output;
+}
+
+function tokenizeSqlForRisk(sql: string): SqlRiskToken[] {
+  const tokens: SqlRiskToken[] = [];
+  const re = /[A-Za-z_@$#][A-Za-z0-9_@$#-]*|[0-9]+|[(),.;*]|\S/g;
+  for (const match of sql.matchAll(re)) {
+    const text = match[0];
+    tokens.push({ text, normalized: /^[A-Za-z_@$#]/.test(text) ? text.toLowerCase() : text });
+  }
+  return tokens;
+}
+
+function classifyTokens(tokens: SqlRiskToken[]): SqlRiskStatementAssessment {
+  const useful = trimWrappingParentheses(tokens);
+  const firstKeyword = useful.find((token) => /^[a-z_]/i.test(token.text))?.normalized;
+  if (!firstKeyword) return { risk: "unknown" };
+
+  if (READ_KEYWORDS.has(firstKeyword)) {
+    return { risk: firstKeyword === "select" && hasTopLevelSelectInto(useful) ? "write" : "read", firstKeyword };
+  }
+
+  if (firstKeyword === "with") {
+    return { risk: highestRiskInTokens(useful) ?? "read", firstKeyword };
+  }
+
+  if (firstKeyword === "explain") {
+    return classifyExplainTokens(useful);
+  }
+
+  if (firstKeyword === "copy") {
+    return { risk: classifyCopyTokens(useful), firstKeyword };
+  }
+
+  if (firstKeyword === "pragma") {
+    return { risk: classifyPragmaTokens(useful), firstKeyword };
+  }
+
+  if (firstKeyword === "use") return { risk: "read", firstKeyword };
+  if (WRITE_KEYWORDS.has(firstKeyword)) return { risk: "write", firstKeyword };
+  if (DDL_KEYWORDS.has(firstKeyword)) return { risk: "ddl", firstKeyword };
+  if (TRANSACTION_KEYWORDS.has(firstKeyword)) return { risk: "transaction", firstKeyword };
+
+  // Unknown statements are treated as unsafe until a dialect-aware parser can
+  // prove they are read-only.
+  return { risk: "unknown", firstKeyword };
+}
+
+function classifyExplainTokens(tokens: SqlRiskToken[]): SqlRiskStatementAssessment {
+  const analyze = tokens.some((token) => token.normalized === "analyze" || token.normalized === "analyse");
+  const innerIndex = tokens.findIndex((token, index) => index > 0 && PRIMARY_STATEMENT_KEYWORDS.has(token.normalized) && !EXPLAIN_OPTION_KEYWORDS.has(token.normalized));
+  if (innerIndex < 0) return { risk: "read", firstKeyword: "explain" };
+  const inner = classifyTokens(tokens.slice(innerIndex));
+  if (!analyze) return { risk: inner.risk === "unknown" ? "unknown" : "read", firstKeyword: "explain" };
+  return { risk: inner.risk, firstKeyword: inner.firstKeyword ?? "explain" };
+}
+
+function classifyCopyTokens(tokens: SqlRiskToken[]): SqlRiskLevel {
+  if (tokens.some((token) => token.normalized === "from")) return "write";
+  if (tokens.some((token) => token.normalized === "to")) return "read";
+  return "unknown";
+}
+
+function classifyPragmaTokens(tokens: SqlRiskToken[]): SqlRiskLevel {
+  const name = tokens.find((token, index) => index > 0 && /^[a-z_]/i.test(token.text))?.normalized;
+  if (name && SAFE_READ_PRAGMA_NAMES.has(name) && !tokens.some((token) => token.text === "=")) return "read";
+  return "write";
+}
+
+function highestRiskInTokens(tokens: SqlRiskToken[]): SqlRiskLevel | undefined {
+  let result: SqlRiskLevel | undefined;
+  for (const token of tokens) {
+    const risk = WRITE_KEYWORDS.has(token.normalized) ? "write" : DDL_KEYWORDS.has(token.normalized) ? "ddl" : TRANSACTION_KEYWORDS.has(token.normalized) ? "transaction" : undefined;
+    if (risk && (!result || RISK_ORDER[risk] > RISK_ORDER[result])) result = risk;
+  }
+  return result;
+}
+
+function hasTopLevelSelectInto(tokens: SqlRiskToken[]): boolean {
+  let depth = 0;
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token.text === "(") depth += 1;
+    if (token.text === ")") depth = Math.max(0, depth - 1);
+    if (depth !== 0) continue;
+    if (token.normalized === "into") return true;
+  }
+  return false;
+}
+
+function trimWrappingParentheses(tokens: SqlRiskToken[]): SqlRiskToken[] {
+  let start = 0;
+  let end = tokens.length;
+  while (tokens[start]?.text === "(" && matchingParenIndex(tokens, start) === end - 1) {
+    start += 1;
+    end -= 1;
+  }
+  return tokens.slice(start, end);
+}
+
+function matchingParenIndex(tokens: readonly SqlRiskToken[], openIndex: number): number {
+  let depth = 0;
+  for (let index = openIndex; index < tokens.length; index += 1) {
+    if (tokens[index]?.text === "(") depth += 1;
+    if (tokens[index]?.text === ")") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function mysqlExecutableCommentPrefixLength(sql: string, index: number): number {
+  if (sql[index] !== "/" || sql[index + 1] !== "*") return 0;
+  if (sql[index + 2] === "!") return 3;
+  if (sql[index + 2] === "M" && sql[index + 3] === "!") return 4;
+  return 0;
+}
+
+function skipExecutableCommentVersion(sql: string, index: number): number {
+  let cursor = index;
+  while (cursor < sql.length && /[0-9\s]/.test(sql[cursor] ?? "")) cursor += 1;
+  return cursor;
+}
+
+function dollarQuoteTagAt(sql: string, index: number): string | undefined {
+  const match = sql.slice(index).match(/^\$[A-Za-z_][A-Za-z0-9_]*\$|^\$\$/);
+  return match?.[0];
+}
+
+function readQuotedEnd(sql: string, start: number, open: string, close: string): number {
+  let index = start + open.length;
+  while (index < sql.length) {
+    if (sql[index] === "\\" && (open === "'" || open === '"')) {
+      index += 2;
+      continue;
+    }
+    if (sql.startsWith(close, index)) {
+      if (sql.startsWith(close + close, index)) {
+        index += close.length * 2;
+        continue;
+      }
+      return index + close.length;
+    }
+    index += 1;
+  }
+  return sql.length;
+}
+
+function unquoteIdentifier(value: string, open: string, close: string): string {
+  if (!value.startsWith(open) || !value.endsWith(close)) return value;
+  return value.slice(open.length, value.length - close.length).replaceAll(close + close, close);
+}
diff --git a/apps/desktop/src/lib/sql/sqlServerQueryWrapping.ts b/apps/desktop/src/lib/sql/sqlServerQueryWrapping.ts
new file mode 100644
index 0000000..71c2830
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlServerQueryWrapping.ts
@@ -0,0 +1,130 @@
+export function sqlServerStatementForDerivedTable(statement: string): string {
+  const orderBy = findTopLevelTrailingOrderBy(statement);
+  if (orderBy === undefined) return statement;
+  if (hasTopLevelSelectTop(statement) || hasTopLevelForXml(statement)) return statement;
+  return statement.slice(0, orderBy).trimEnd();
+}
+
+function findTopLevelTrailingOrderBy(sql: string): number | undefined {
+  const tokens = topLevelSqlTokens(sql);
+  for (let i = tokens.length - 2; i >= 0; i--) {
+    if (tokens[i].text === "ORDER" && tokens[i + 1]?.text === "BY") {
+      return tokens[i].start;
+    }
+  }
+  return undefined;
+}
+
+function hasTopLevelSelectTop(sql: string): boolean {
+  const tokens = topLevelSqlTokens(sql);
+  const selectIndex = tokens.findIndex((token) => token.text === "SELECT");
+  if (selectIndex < 0) return false;
+  const fromIndex = tokens.findIndex((token, index) => index > selectIndex && token.text === "FROM");
+  const end = fromIndex < 0 ? tokens.length : fromIndex;
+  return tokens.slice(selectIndex + 1, end).some((token) => token.text === "TOP");
+}
+
+function hasTopLevelForXml(sql: string): boolean {
+  const tokens = topLevelSqlTokens(sql);
+  return tokens.some((token, index) => token.text === "FOR" && tokens[index + 1]?.text === "XML");
+}
+
+function topLevelSqlTokens(sql: string): Array<{ text: string; start: number }> {
+  const tokens: Array<{ text: string; start: number }> = [];
+  let i = 0;
+  let depth = 0;
+
+  while (i < sql.length) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+
+    if (ch === "-" && next === "-") {
+      i += 2;
+      while (i < sql.length && sql[i] !== "\n") i++;
+      continue;
+    }
+
+    if (ch === "/" && next === "*") {
+      i += 2;
+      while (i < sql.length - 1 && !(sql[i] === "*" && sql[i + 1] === "/")) i++;
+      i = Math.min(i + 2, sql.length);
+      continue;
+    }
+
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipSqlQuoted(sql, i, ch);
+      continue;
+    }
+
+    if (ch === "[") {
+      i = skipSqlBracketIdentifier(sql, i);
+      continue;
+    }
+
+    if (ch === "(") {
+      depth++;
+      i++;
+      continue;
+    }
+
+    if (ch === ")") {
+      depth = Math.max(0, depth - 1);
+      i++;
+      continue;
+    }
+
+    if (depth === 0 && isSqlTokenStart(ch)) {
+      const start = i;
+      i++;
+      while (i < sql.length && isSqlTokenPart(sql[i])) i++;
+      tokens.push({ text: sql.slice(start, i).toUpperCase(), start });
+      continue;
+    }
+
+    i++;
+  }
+
+  return tokens;
+}
+
+function skipSqlQuoted(sql: string, pos: number, quote: string): number {
+  let i = pos + 1;
+  while (i < sql.length) {
+    if (sql[i] === quote) {
+      if (sql[i + 1] === quote) {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    if (quote === "'" && sql[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    i++;
+  }
+  return sql.length;
+}
+
+function skipSqlBracketIdentifier(sql: string, pos: number): number {
+  let i = pos + 1;
+  while (i < sql.length) {
+    if (sql[i] === "]") {
+      if (sql[i + 1] === "]") {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i++;
+  }
+  return sql.length;
+}
+
+function isSqlTokenStart(ch: string | undefined): boolean {
+  return !!ch && /[A-Za-z_]/.test(ch);
+}
+
+function isSqlTokenPart(ch: string | undefined): boolean {
+  return !!ch && /[A-Za-z0-9_$#]/.test(ch);
+}
diff --git a/apps/desktop/src/lib/sql/sqlStatementRanges.ts b/apps/desktop/src/lib/sql/sqlStatementRanges.ts
new file mode 100644
index 0000000..3caa137
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlStatementRanges.ts
@@ -0,0 +1,1670 @@
+import type { SqlExecutionCandidate } from "@/lib/sql/sqlExecutionTarget";
+import { splitMongoCommandRanges } from "@/lib/mongo/mongoShellCommand";
+import type { DatabaseType } from "@/types/database";
+
+/**
+ * A contiguous range of SQL text expressed as document offsets plus the
+ * extracted (original) substring.
+ */
+export interface SqlTextRange {
+  from: number;
+  to: number;
+  sql: string;
+}
+
+const NON_SQL_EXECUTION_TARGET_TYPES: ReadonlySet<DatabaseType> = new Set(["mongodb", "elasticsearch", "qdrant", "milvus", "weaviate", "chromadb", "etcd", "zookeeper", "mq", "neo4j"]);
+
+export function supportsExecutionTargetPicker(databaseType?: DatabaseType): boolean {
+  return !!databaseType && (databaseType === "redis" || !NON_SQL_EXECUTION_TARGET_TYPES.has(databaseType));
+}
+
+export function hasMultipleExecutionTargets(sql: string, databaseType?: DatabaseType): boolean {
+  if (databaseType === "redis") {
+    return redisExecutableCommandCount(sql) > 1;
+  }
+  return splitSqlStatementRanges(sql, databaseType).length > 1;
+}
+
+interface RawStatement {
+  /** Start offset (inclusive) of whitespace that can still target this statement. */
+  hitFrom: number;
+  /** Start offset (inclusive) of the statement's first non-whitespace char. */
+  from: number;
+  /** End offset (exclusive) — up to and excluding the terminating semicolon. */
+  to: number;
+  /** The statement text, sliced from the source document. */
+  sql: string;
+}
+
+type QuoteState = "none" | "single" | "double" | "backtick" | "bracket" | "dollar";
+
+const COMMON_SOFT_STATEMENT_START_KEYWORDS = [
+  "SELECT",
+  "WITH",
+  "CREATE",
+  "ALTER",
+  "DROP",
+  "INSERT",
+  "UPDATE",
+  "DELETE",
+  "MERGE",
+  "REPLACE",
+  "TRUNCATE",
+  "GRANT",
+  "REVOKE",
+  "COMMENT",
+  "EXPLAIN",
+  "SHOW",
+  "DESCRIBE",
+  "DESC",
+  "USE",
+  "SET",
+  "CALL",
+  "EXEC",
+  "EXECUTE",
+  "BEGIN",
+  "COMMIT",
+  "ROLLBACK",
+  "DECLARE",
+  "ANALYZE",
+  "VACUUM",
+  "PRAGMA",
+  "REFRESH",
+  "COPY",
+] as const;
+
+const DATABASE_SOFT_STATEMENT_KEYWORDS: Partial<Record<DatabaseType, readonly string[]>> = {
+  mysql: ["HANDLER", "LOAD", "OPTIMIZE", "REPAIR"],
+  postgres: ["DO", "LISTEN", "NOTIFY", "UNLISTEN"],
+  sqlite: ["ATTACH", "DETACH", "REINDEX"],
+  duckdb: ["ATTACH", "DETACH", "EXPORT", "IMPORT", "INSTALL", "LOAD"],
+  clickhouse: ["ATTACH", "CHECK", "DETACH", "EXCHANGE", "KILL", "OPTIMIZE", "SYSTEM"],
+  sqlserver: ["BACKUP", "DBCC", "DENY", "RESTORE"],
+  saphana: ["DO"],
+  oracle: ["FLASHBACK", "LOCK", "PURGE"],
+  dameng: ["FLASHBACK", "LOCK", "PURGE"],
+  gaussdb: ["DO", "LOCK"],
+  "oceanbase-oracle": ["FLASHBACK", "LOCK", "PURGE"],
+  redis: [],
+  mongodb: [],
+  elasticsearch: [],
+  qdrant: [],
+  milvus: [],
+  weaviate: [],
+  chromadb: [],
+  mq: [],
+  etcd: [],
+  zookeeper: [],
+};
+
+const WITH_MAIN_STATEMENT_KEYWORDS = new Set(["SELECT", "INSERT", "UPDATE", "DELETE", "MERGE"]);
+const EXPLAIN_STATEMENT_KEYWORDS = new Set(["SELECT", "WITH", "INSERT", "UPDATE", "DELETE", "MERGE", "CREATE", "ALTER", "DROP"]);
+const CREATE_BODY_KEYWORDS = new Set(["SELECT", "WITH", "BEGIN", "DECLARE"]);
+const INSERT_BODY_KEYWORDS = new Set(["SELECT", "WITH"]);
+const ALTER_BODY_KEYWORDS = new Set(["ADD", "ALTER", "COMMENT", "DROP", "MODIFY", "RENAME", "SET"]);
+const SET_OPERATION_KEYWORDS = new Set(["UNION", "INTERSECT", "EXCEPT", "MINUS"]);
+const SET_OPERATION_MODIFIER_KEYWORDS = new Set(["ALL", "DISTINCT"]);
+const ORACLE_LIKE_PL_SQL_DATABASES: ReadonlySet<DatabaseType> = new Set(["oracle", "dameng", "gaussdb", "yashandb", "oscar", "oceanbase-oracle"]);
+const MYSQL_ROUTINE_BLOCK_DATABASES: ReadonlySet<DatabaseType> = new Set(["mysql", "doris", "starrocks", "manticoresearch", "goldendb"]);
+const MYSQL_CREATE_TABLE_OPTION_DATABASES: ReadonlySet<DatabaseType> = new Set(["mysql", "doris", "starrocks", "manticoresearch", "goldendb", "gbase"]);
+const MYSQL_ROUTINE_OBJECT_TYPES = new Set(["PROCEDURE", "FUNCTION", "TRIGGER", "EVENT"]);
+const MYSQL_NON_ROUTINE_CREATE_TYPES = new Set(["DATABASE", "INDEX", "LOGFILE", "ROLE", "SCHEMA", "SERVER", "SPATIAL", "TABLE", "TEMPORARY", "UNIQUE", "USER", "VIEW"]);
+const MYSQL_CONTROL_BLOCK_SUFFIXES = new Set(["IF", "LOOP", "CASE", "REPEAT", "WHILE"]);
+const ORACLE_PL_SQL_BLOCK_STARTERS = new Set(["DECLARE", "BEGIN"]);
+const ORACLE_PL_SQL_CREATE_OBJECT_TYPES = new Set(["FUNCTION", "PROCEDURE", "TRIGGER", "PACKAGE", "PACKAGE BODY", "TYPE", "TYPE BODY"]);
+const ORACLE_PL_SQL_TERMINATORS = new Set(["IF", "LOOP", "CASE"]);
+const SAP_HANA_SCRIPT_BLOCK_TERMINATORS = new Set(["IF", "FOR", "WHILE"]);
+
+/**
+ * Parse the SQL document into top-level statement ranges delimited by `;`.
+ *
+ * Delimiters inside string literals, double/backtick/bracket quoted
+ * identifiers, dollar-quoted bodies (Postgres), line comments (`--`, `#`) and
+ * block comments (`/* *​/`) are ignored, mirroring the backend splitter in
+ * `dbx-core/src/sql.rs`. Ranges are returned as `[from, to)` offsets covering
+ * only the statement text (the trailing semicolon and inter-statement
+ * whitespace are excluded so editor highlights stay tight).
+ */
+export function splitSqlStatementRanges(sql: string, databaseType?: DatabaseType): RawStatement[] {
+  const statements: RawStatement[] = [];
+  const len = sql.length;
+  const supportsDelimiterCommands = databaseType === "mysql";
+
+  let statementStart = -1;
+  let statementEnd = -1;
+  let statementHitStart = 0;
+  let customDelimiter: string | null = null;
+  let state: QuoteState = "none";
+  let dollarTag = "";
+  let i = 0;
+
+  const isWhitespace = (ch: string) => ch === " " || ch === "\t" || ch === "\r" || ch === "\n";
+
+  const markContent = (pos: number) => {
+    if (statementStart === -1) statementStart = pos;
+    statementEnd = pos + 1;
+  };
+
+  const flush = (to = statementEnd) => {
+    if (statementStart === -1) {
+      statementEnd = -1;
+      return;
+    }
+    const trimmedTo = trimRangeEnd(sql, statementStart, to);
+    if (trimmedTo > statementStart) {
+      statements.push({ hitFrom: statementHitStart, from: statementStart, to: trimmedTo, sql: sql.slice(statementStart, trimmedTo) });
+    }
+    statementStart = -1;
+    statementEnd = -1;
+  };
+
+  while (i < len) {
+    const ch = sql[i];
+    const next = sql[i + 1] ?? "";
+
+    if (state === "dollar") {
+      // Inside a Postgres dollar-quoted body; look for the closing $tag$.
+      if (ch === "$") {
+        const closingTag = `$${dollarTag}$`;
+        if (sql.startsWith(closingTag, i)) {
+          markContent(i);
+          for (let k = 0; k < closingTag.length; k += 1) {
+            markContent(i + k);
+          }
+          i += closingTag.length;
+          state = "none";
+          dollarTag = "";
+          continue;
+        }
+      }
+      markContent(i);
+      i += 1;
+      continue;
+    }
+
+    if (state === "single") {
+      markContent(i);
+      // Backslash escapes the next char (e.g. PostgreSQL standard_conforming_strings=off style).
+      if (ch === "\\" && next) {
+        i += 2;
+        continue;
+      }
+      if (ch === "'") {
+        // Doubled single quote '' is an escaped quote, not a terminator.
+        if (next === "'") {
+          i += 2;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "double") {
+      markContent(i);
+      if (ch === '"') {
+        if (next === '"') {
+          i += 2;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "backtick") {
+      markContent(i);
+      if (ch === "`") {
+        if (next === "`") {
+          i += 2;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "bracket") {
+      markContent(i);
+      if (ch === "]") {
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    // state === "none"
+    if (supportsDelimiterCommands && isAtLineStart(sql, i) && startsDelimiterCommand(sql, i)) {
+      const lineEnd = findLineEnd(sql, i);
+      const delimiter = parseDelimiterCommand(sql.slice(i, lineEnd));
+      if (delimiter !== null) {
+        flush();
+        customDelimiter = delimiter === ";" ? null : delimiter;
+        i = nextLineStart(sql, lineEnd);
+        statementHitStart = i;
+        continue;
+      }
+    }
+    if (isOracleLikeDatabase(databaseType) && isAtLineStart(sql, i) && isSlashLine(sql, i)) {
+      const lineEnd = findLineEnd(sql, i);
+      flush(i);
+      i = nextLineStart(sql, lineEnd);
+      statementHitStart = i;
+      continue;
+    }
+
+    // Line comments consume up to (and including) the newline.
+    if (ch === "-" && next === "-") {
+      const newline = sql.indexOf("\n", i);
+      i = newline === -1 ? len : newline + 1;
+      continue;
+    }
+    if (ch === "#") {
+      const newline = sql.indexOf("\n", i);
+      i = newline === -1 ? len : newline + 1;
+      continue;
+    }
+    // Block comments consume until the closing */.
+    if (ch === "/" && next === "*") {
+      const close = sql.indexOf("*/", i + 2);
+      i = close === -1 ? len : close + 2;
+      continue;
+    }
+
+    if (supportsSqlServerGoCommands(databaseType) && isAtLineStart(sql, i) && isSqlServerGoLine(sql, i)) {
+      const lineEnd = findLineEnd(sql, i);
+      flush(i);
+      i = nextLineStart(sql, lineEnd);
+      statementHitStart = i;
+      continue;
+    }
+
+    if (ch === "'") {
+      markContent(i);
+      state = "single";
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      markContent(i);
+      state = "double";
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      markContent(i);
+      state = "backtick";
+      i += 1;
+      continue;
+    }
+    if (ch === "[") {
+      markContent(i);
+      state = "bracket";
+      i += 1;
+      continue;
+    }
+    // Postgres dollar quoting: $tag$ ... $tag$ (tag may be empty, i.e. $$)
+    if (!customDelimiter && ch === "$") {
+      const tagMatch = /^\$[A-Za-z_0-9]*\$/.exec(sql.slice(i));
+      if (tagMatch) {
+        markContent(i);
+        dollarTag = tagMatch[0].slice(1, -1);
+        i += tagMatch[0].length;
+        state = "dollar";
+        continue;
+      }
+    }
+
+    if (customDelimiter) {
+      if (sql.startsWith(customDelimiter, i)) {
+        flush(i);
+        i += customDelimiter.length;
+        statementHitStart = i;
+        continue;
+      }
+    } else if (ch === ";") {
+      const isMysqlRoutineBlock = isMysqlRoutineBlockDatabase(databaseType) && statementStart !== -1 && startsWithMysqlRoutineBlock(sql.slice(statementStart, i));
+      if (isMysqlRoutineBlock) {
+        if (!mysqlRoutineBlockIsComplete(sql.slice(statementStart, i + 1))) {
+          markContent(i);
+          i += 1;
+          continue;
+        }
+        // The final semicolon is the client-side statement delimiter.
+        // Internal semicolons remain part of the routine body.
+        flush();
+      } else {
+        const statementSoFar = statementStart === -1 ? "" : sql.slice(statementStart, i);
+        const isOraclePlSql = isOracleLikeDatabase(databaseType) && statementStart !== -1 && startsWithOraclePlSqlBlock(statementSoFar);
+        const isSapHanaScriptBlock = isSapHanaScriptBlockDatabase(databaseType) && statementStart !== -1 && startsWithSapHanaScriptBlock(statementSoFar);
+        if (isOraclePlSql || isSapHanaScriptBlock) {
+          markContent(i);
+          if (isOraclePlSql && !oraclePlSqlBlockIsComplete(sql.slice(statementStart, i + 1))) {
+            i += 1;
+            continue;
+          }
+          if (isSapHanaScriptBlock && !sapHanaScriptBlockIsComplete(sql.slice(statementStart, i + 1))) {
+            i += 1;
+            continue;
+          }
+          flush(i + 1);
+        } else {
+          flush();
+        }
+      }
+      statementHitStart = i + 1;
+      i += 1;
+      continue;
+    }
+
+    if (!isWhitespace(ch)) {
+      markContent(i);
+    }
+    i += 1;
+  }
+
+  // Flush any trailing statement that lacks a terminating semicolon.
+  flush();
+
+  return statements;
+}
+
+/**
+ * Returns the statement that contains `cursorPos`, or `null` when the cursor
+ * sits on a blank line or no statement can be resolved.
+ *
+ * The returned range covers only the statement's own text (no trailing `;`),
+ * which lets the editor highlight a tight preview range.
+ */
+export function statementRangeAtCursor(sql: string, cursorPos: number, databaseType?: DatabaseType): SqlTextRange | null {
+  const pos = clampCursor(sql, cursorPos);
+  if (isCursorOnBlankLine(sql, pos)) return null;
+
+  const statements = splitSqlStatementRanges(sql, databaseType);
+  for (let index = 0; index < statements.length; index += 1) {
+    const statement = statements[index];
+    const softRanges = splitStatementRangeAtSoftStarts(sql, statement, databaseType);
+    // Cursor inside the statement body, including the exact start/end.
+    if (pos >= statement.from && pos <= statement.to) {
+      return rangeForCursorInSoftRanges(sql, softRanges, pos) ?? rangeFor(statement, sql);
+    }
+    const next = statements[index + 1];
+    // A caret after a statement's semicolon still belongs to that statement
+    // until the next statement's text begins.
+    if (pos > statement.to && (!next || pos < next.from) && isCursorInSameLineDelimiterGap(sql, statement.to, pos)) {
+      return rangeForCursorInSoftRanges(sql, softRanges, pos) ?? rangeFor(statement, sql);
+    }
+
+    // Cursor in indentation or inter-statement whitespace immediately before
+    // the statement should still target that statement, while the returned
+    // execution range remains tight around the SQL text itself.
+    if (pos >= statement.hitFrom && pos < statement.from && sql.slice(pos, statement.from).trim() === "") {
+      const previous = statements[index - 1];
+      if (previous && isCursorInSameLineDelimiterGap(sql, previous.to, pos)) {
+        const previousSoftRanges = splitStatementRangeAtSoftStarts(sql, previous, databaseType);
+        return rangeForCursorInSoftRanges(sql, previousSoftRanges, pos) ?? rangeFor(previous, sql);
+      }
+      return rangeForCursorInSoftRanges(sql, softRanges, pos) ?? rangeFor(statement, sql);
+    }
+
+    if (pos > statement.to && (!next || pos < next.hitFrom) && isCursorOnStatementLine(sql, pos, statement)) {
+      return rangeForCursorInSoftRanges(sql, softRanges, pos) ?? rangeFor(statement, sql);
+    }
+  }
+
+  return null;
+}
+
+export function mongoCommandRangeAtCursor(sql: string, cursorPos: number): SqlTextRange | null {
+  const pos = clampCursor(sql, cursorPos);
+  if (isCursorOnBlankLine(sql, pos)) return null;
+
+  const commands = splitMongoCommandRanges(sql);
+  for (let index = 0; index < commands.length; index += 1) {
+    const command = commands[index];
+    const range = { from: command.from, to: command.to, sql: command.text };
+
+    if (pos >= command.from && pos <= command.to) return range;
+
+    const next = commands[index + 1];
+    if (pos > command.to && (!next || pos < next.from) && isCursorInSameLineDelimiterGap(sql, command.to, pos)) return range;
+
+    if (pos < command.from && sql.slice(pos, command.from).trim() === "" && isCursorOnStatementLine(sql, pos, command)) return range;
+  }
+
+  return null;
+}
+
+function isCursorInSameLineDelimiterGap(sql: string, previousStatementEnd: number, cursorPos: number): boolean {
+  if (cursorPos <= previousStatementEnd) return false;
+  const between = sql.slice(previousStatementEnd, cursorPos);
+  const delimiterIndex = between.lastIndexOf(";");
+  if (delimiterIndex === -1) return false;
+  const afterDelimiter = between.slice(delimiterIndex + 1);
+  return !afterDelimiter.includes("\n") && between.slice(0, delimiterIndex).trim() === "" && afterDelimiter.trim() === "";
+}
+
+function rangeForCursorInSoftRanges(sql: string, ranges: RawStatement[], pos: number): SqlTextRange | null {
+  for (let index = 0; index < ranges.length; index += 1) {
+    const range = ranges[index];
+    if (pos >= range.from && pos <= range.to) {
+      return rangeFor(range, sql);
+    }
+    if (pos >= range.hitFrom && pos < range.from && sql.slice(pos, range.from).trim() === "") {
+      return rangeFor(range, sql);
+    }
+
+    const next = ranges[index + 1];
+    if (pos > range.to && (!next || pos < next.hitFrom) && isCursorOnStatementLine(sql, pos, range)) {
+      return rangeFor(range, sql);
+    }
+  }
+
+  return null;
+}
+
+function splitStatementRangeAtSoftStarts(sql: string, statement: RawStatement, databaseType?: DatabaseType): RawStatement[] {
+  if (isOraclePlSqlStatement(statement.sql, databaseType)) return [statement];
+  if (isSapHanaScriptBlockStatement(statement.sql, databaseType)) return [statement];
+  // Routine bodies contain top-level-looking SET/INSERT/SELECT lines that are not independent statements.
+  if (isMysqlRoutineBlockDatabase(databaseType) && startsWithMysqlRoutineBlock(statement.sql)) return [statement];
+
+  const lineStarts = topLevelSoftStatementLineStarts(sql, statement, databaseType);
+  if (lineStarts.length <= 1) return [statement];
+
+  const boundaries: Array<{ hitFrom: number; from: number; keyword: string }> = [];
+  let currentKeyword = softStatementKeywordAt(sql, statement.from, databaseType);
+  let currentExplainTargetKeyword = explainLikeTargetKeywordAt(sql, statement.from);
+  let currentBodyKeyword = currentExplainTargetKeyword ?? currentKeyword;
+  let consumedWithMainStatement = false;
+  let consumedExplainStatement = false;
+
+  boundaries.push({ hitFrom: statement.hitFrom, from: statement.from, keyword: currentKeyword ?? "" });
+
+  for (const lineStart of lineStarts) {
+    if (lineStart.from <= statement.from) continue;
+
+    if (currentKeyword === "WITH" && !consumedWithMainStatement && WITH_MAIN_STATEMENT_KEYWORDS.has(lineStart.keyword)) {
+      consumedWithMainStatement = true;
+      continue;
+    }
+
+    if (isSetOperationQueryContinuation(sql, statement.from, lineStart.from, lineStart.keyword)) {
+      continue;
+    }
+
+    if (!consumedExplainStatement && EXPLAIN_STATEMENT_KEYWORDS.has(lineStart.keyword) && (currentKeyword === "EXPLAIN" || currentExplainTargetKeyword !== null)) {
+      consumedExplainStatement = true;
+      currentBodyKeyword = lineStart.keyword;
+      continue;
+    }
+
+    if (currentBodyKeyword === "CREATE" && CREATE_BODY_KEYWORDS.has(lineStart.keyword)) {
+      continue;
+    }
+
+    if (currentBodyKeyword === "CREATE" && isMysqlCreateTableOptionContinuation(sql, statement.from, lineStart.from, lineStart.keyword, databaseType)) {
+      continue;
+    }
+
+    if (currentBodyKeyword === "INSERT" && INSERT_BODY_KEYWORDS.has(lineStart.keyword)) {
+      continue;
+    }
+
+    if (currentBodyKeyword === "UPDATE" && lineStart.keyword === "SET") {
+      continue;
+    }
+
+    if (currentBodyKeyword === "ALTER" && ALTER_BODY_KEYWORDS.has(lineStart.keyword)) {
+      continue;
+    }
+
+    boundaries.push(lineStart);
+    currentKeyword = lineStart.keyword;
+    currentExplainTargetKeyword = explainLikeTargetKeywordAt(sql, lineStart.from);
+    currentBodyKeyword = currentExplainTargetKeyword ?? currentKeyword;
+    consumedWithMainStatement = false;
+    consumedExplainStatement = false;
+  }
+
+  if (boundaries.length <= 1) return [statement];
+
+  const ranges: RawStatement[] = [];
+  for (let index = 0; index < boundaries.length; index += 1) {
+    const boundary = boundaries[index];
+    const next = boundaries[index + 1];
+    const to = next ? trimRangeEndBeforeNextBoundary(sql, boundary.from, next.from) : trimRangeEnd(sql, boundary.from, statement.to);
+    if (to > boundary.from) {
+      ranges.push({
+        hitFrom: boundary.hitFrom,
+        from: boundary.from,
+        to,
+        sql: sql.slice(boundary.from, to),
+      });
+    }
+  }
+
+  return ranges.length > 0 ? ranges : [statement];
+}
+
+function topLevelSoftStatementLineStarts(sql: string, statement: RawStatement, databaseType?: DatabaseType): Array<{ hitFrom: number; from: number; keyword: string }> {
+  const starts: Array<{ hitFrom: number; from: number; keyword: string }> = [];
+  const len = statement.to;
+  let state: QuoteState | "lineComment" | "blockComment" = "none";
+  let dollarTag = "";
+  let parenDepth = 0;
+  let lineStart = statement.from;
+  let firstNonWhitespaceOnLine = -1;
+  let i = statement.from;
+
+  while (i < len) {
+    const ch = sql[i];
+    const next = sql[i + 1] ?? "";
+
+    if (state === "none" && firstNonWhitespaceOnLine === -1 && ch !== "\n" && ch !== "\r" && !isSqlWhitespace(ch) && !startsLineComment(sql, i) && !startsBlockComment(sql, i)) {
+      firstNonWhitespaceOnLine = i;
+      if (parenDepth === 0) {
+        const keyword = softStatementKeywordAt(sql, i, databaseType);
+        if (keyword) {
+          starts.push({ hitFrom: lineStart, from: i, keyword });
+        }
+      }
+    }
+
+    if (ch === "\n") {
+      if (state === "lineComment") state = "none";
+      lineStart = i + 1;
+      firstNonWhitespaceOnLine = -1;
+      i += 1;
+      continue;
+    }
+
+    if (state === "lineComment") {
+      i += 1;
+      continue;
+    }
+
+    if (state === "blockComment") {
+      if (ch === "*" && next === "/") {
+        state = "none";
+        i += 2;
+        continue;
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "dollar") {
+      if (ch === "$") {
+        const closingTag = `$${dollarTag}$`;
+        if (sql.startsWith(closingTag, i)) {
+          i += closingTag.length;
+          state = "none";
+          dollarTag = "";
+          continue;
+        }
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "single") {
+      if (ch === "\\" && next) {
+        i += 2;
+        continue;
+      }
+      if (ch === "'") {
+        if (next === "'") {
+          i += 2;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "double") {
+      if (ch === '"') {
+        if (next === '"') {
+          i += 2;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "backtick") {
+      if (ch === "`") {
+        if (next === "`") {
+          i += 2;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "bracket") {
+      if (ch === "]") state = "none";
+      i += 1;
+      continue;
+    }
+
+    // state === "none"
+    if (ch === "-" && next === "-") {
+      state = "lineComment";
+      i += 2;
+      continue;
+    }
+    if (ch === "#") {
+      state = "lineComment";
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      state = "blockComment";
+      i += 2;
+      continue;
+    }
+    if (ch === "'") {
+      state = "single";
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      state = "double";
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      state = "backtick";
+      i += 1;
+      continue;
+    }
+    if (ch === "[") {
+      state = "bracket";
+      i += 1;
+      continue;
+    }
+    if (ch === "$") {
+      const tagMatch = /^\$[A-Za-z_0-9]*\$/.exec(sql.slice(i));
+      if (tagMatch) {
+        dollarTag = tagMatch[0].slice(1, -1);
+        i += tagMatch[0].length;
+        state = "dollar";
+        continue;
+      }
+    }
+    if (ch === "(") {
+      parenDepth += 1;
+    } else if (ch === ")" && parenDepth > 0) {
+      parenDepth -= 1;
+    }
+    i += 1;
+  }
+
+  return starts;
+}
+
+function softStatementKeywordAt(sql: string, pos: number, databaseType?: DatabaseType): string | null {
+  const match = /^[A-Za-z_][\w$]*/.exec(sql.slice(pos));
+  if (!match) return null;
+  const keyword = match[0].toUpperCase();
+  if (keyword === "REPLACE" && nextNonWhitespaceChar(sql, pos + match[0].length) === "(") return null;
+  return softStatementStartKeywords(databaseType).has(keyword) ? keyword : null;
+}
+
+function softStatementStartKeywords(databaseType?: DatabaseType): Set<string> {
+  return new Set([...COMMON_SOFT_STATEMENT_START_KEYWORDS, ...(databaseType ? (DATABASE_SOFT_STATEMENT_KEYWORDS[databaseType] ?? []) : [])]);
+}
+
+function isSetOperationQueryContinuation(sql: string, from: number, to: number, keyword: string): boolean {
+  if (keyword !== "SELECT" && keyword !== "WITH") return false;
+  const words = topLevelWordsBefore(sql, from, to, 3);
+  const last = words[words.length - 1];
+  if (last && SET_OPERATION_KEYWORDS.has(last)) return true;
+  if (last && SET_OPERATION_MODIFIER_KEYWORDS.has(last)) {
+    const previous = words[words.length - 2];
+    return !!previous && SET_OPERATION_KEYWORDS.has(previous);
+  }
+  return false;
+}
+
+function isMysqlCreateTableOptionContinuation(sql: string, statementFrom: number, lineStartFrom: number, keyword: string, databaseType?: DatabaseType): boolean {
+  if (databaseType && !MYSQL_CREATE_TABLE_OPTION_DATABASES.has(databaseType)) return false;
+  if (keyword !== "COMMENT") return false;
+  if (!startsWithMysqlCreateTable(sql, statementFrom)) return false;
+
+  const next = nextNonWhitespaceChar(sql, lineStartFrom + keyword.length);
+  return next === "=" || next === "'" || next === '"';
+}
+
+function startsWithMysqlCreateTable(sql: string, statementFrom: number): boolean {
+  const text = sql.slice(statementFrom, statementFrom + 256);
+  return /^CREATE\s+(?:TEMPORARY\s+)?TABLE\b/i.test(text);
+}
+
+function topLevelWordsBefore(sql: string, from: number, to: number, limit: number): string[] {
+  const words: string[] = [];
+  let state: QuoteState | "lineComment" | "blockComment" = "none";
+  let dollarTag = "";
+  let parenDepth = 0;
+  let i = from;
+
+  while (i < to) {
+    const ch = sql[i];
+    const next = sql[i + 1] ?? "";
+
+    if (state === "lineComment") {
+      if (ch === "\n") state = "none";
+      i += 1;
+      continue;
+    }
+
+    if (state === "blockComment") {
+      if (ch === "*" && next === "/") {
+        state = "none";
+        i += 2;
+        continue;
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "dollar") {
+      if (ch === "$") {
+        const closingTag = `$${dollarTag}$`;
+        if (sql.startsWith(closingTag, i)) {
+          i += closingTag.length;
+          state = "none";
+          dollarTag = "";
+          continue;
+        }
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "single") {
+      if (ch === "\\" && next) {
+        i += 2;
+        continue;
+      }
+      if (ch === "'") {
+        if (next === "'") {
+          i += 2;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "double") {
+      if (ch === '"') {
+        if (next === '"') {
+          i += 2;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "backtick") {
+      if (ch === "`") {
+        if (next === "`") {
+          i += 2;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "bracket") {
+      if (ch === "]") state = "none";
+      i += 1;
+      continue;
+    }
+
+    if (ch === "-" && next === "-") {
+      state = "lineComment";
+      i += 2;
+      continue;
+    }
+    if (ch === "#") {
+      state = "lineComment";
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      state = "blockComment";
+      i += 2;
+      continue;
+    }
+    if (ch === "'") {
+      state = "single";
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      state = "double";
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      state = "backtick";
+      i += 1;
+      continue;
+    }
+    if (ch === "[") {
+      state = "bracket";
+      i += 1;
+      continue;
+    }
+    if (ch === "$") {
+      const tagMatch = /^\$[A-Za-z_0-9]*\$/.exec(sql.slice(i));
+      if (tagMatch) {
+        dollarTag = tagMatch[0].slice(1, -1);
+        i += tagMatch[0].length;
+        state = "dollar";
+        continue;
+      }
+    }
+    if (ch === "(") {
+      parenDepth += 1;
+      i += 1;
+      continue;
+    }
+    if (ch === ")") {
+      if (parenDepth > 0) parenDepth -= 1;
+      i += 1;
+      continue;
+    }
+    if (parenDepth === 0) {
+      const match = /^[A-Za-z_][\w$]*/.exec(sql.slice(i));
+      if (match) {
+        words.push(match[0].toUpperCase());
+        if (words.length > limit) words.shift();
+        i += match[0].length;
+        continue;
+      }
+    }
+    i += 1;
+  }
+
+  return words;
+}
+
+function nextNonWhitespaceChar(sql: string, pos: number): string | null {
+  let i = pos;
+  while (i < sql.length && isSqlWhitespace(sql[i])) i += 1;
+  return i < sql.length ? sql[i] : null;
+}
+
+function isExplainLikeKeyword(keyword: string | null): boolean {
+  return keyword === "EXPLAIN" || keyword === "DESCRIBE" || keyword === "DESC";
+}
+
+function explainLikeTargetKeywordAt(sql: string, pos: number): string | null {
+  const prefixMatch = /^[A-Za-z_][\w$]*/.exec(sql.slice(pos));
+  const prefix = prefixMatch?.[0]?.toUpperCase();
+  if (!isExplainLikeKeyword(prefix ?? null)) return null;
+
+  let i = pos + (prefixMatch?.[0].length ?? 0);
+  while (i < sql.length && isSqlWhitespace(sql[i])) i += 1;
+  const targetMatch = /^[A-Za-z_][\w$]*/.exec(sql.slice(i));
+  const targetKeyword = targetMatch?.[0]?.toUpperCase();
+  return targetKeyword && EXPLAIN_STATEMENT_KEYWORDS.has(targetKeyword) ? targetKeyword : null;
+}
+
+function startsLineComment(sql: string, pos: number): boolean {
+  return (sql[pos] === "-" && sql[pos + 1] === "-") || sql[pos] === "#";
+}
+
+function startsBlockComment(sql: string, pos: number): boolean {
+  return sql[pos] === "/" && sql[pos + 1] === "*";
+}
+
+function trimRangeEnd(sql: string, from: number, to: number): number {
+  let end = to;
+  while (end > from && isSqlWhitespace(sql[end - 1])) {
+    end -= 1;
+  }
+  return end;
+}
+
+function trimRangeEndBeforeNextBoundary(sql: string, from: number, nextBoundaryFrom: number): number {
+  let state: QuoteState | "lineComment" | "blockComment" = "none";
+  let dollarTag = "";
+  let lastContentEnd = from;
+  let i = from;
+
+  while (i < nextBoundaryFrom) {
+    const ch = sql[i];
+    const next = sql[i + 1] ?? "";
+
+    if (state === "lineComment") {
+      if (ch === "\n") state = "none";
+      i += 1;
+      continue;
+    }
+
+    if (state === "blockComment") {
+      if (ch === "*" && next === "/") {
+        state = "none";
+        i += 2;
+        continue;
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "dollar") {
+      lastContentEnd = i + 1;
+      if (ch === "$") {
+        const closingTag = `$${dollarTag}$`;
+        if (sql.startsWith(closingTag, i)) {
+          i += closingTag.length;
+          lastContentEnd = i;
+          state = "none";
+          dollarTag = "";
+          continue;
+        }
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "single") {
+      lastContentEnd = i + 1;
+      if (ch === "\\" && next) {
+        i += 2;
+        lastContentEnd = i;
+        continue;
+      }
+      if (ch === "'") {
+        if (next === "'") {
+          i += 2;
+          lastContentEnd = i;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "double") {
+      lastContentEnd = i + 1;
+      if (ch === '"') {
+        if (next === '"') {
+          i += 2;
+          lastContentEnd = i;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "backtick") {
+      lastContentEnd = i + 1;
+      if (ch === "`") {
+        if (next === "`") {
+          i += 2;
+          lastContentEnd = i;
+          continue;
+        }
+        state = "none";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "bracket") {
+      lastContentEnd = i + 1;
+      if (ch === "]") state = "none";
+      i += 1;
+      continue;
+    }
+
+    if (ch === "-" && next === "-") {
+      state = "lineComment";
+      i += 2;
+      continue;
+    }
+    if (ch === "#") {
+      state = "lineComment";
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      state = "blockComment";
+      i += 2;
+      continue;
+    }
+    if (ch === "'") {
+      state = "single";
+      lastContentEnd = i + 1;
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      state = "double";
+      lastContentEnd = i + 1;
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      state = "backtick";
+      lastContentEnd = i + 1;
+      i += 1;
+      continue;
+    }
+    if (ch === "[") {
+      state = "bracket";
+      lastContentEnd = i + 1;
+      i += 1;
+      continue;
+    }
+    if (ch === "$") {
+      const tagMatch = /^\$[A-Za-z_0-9]*\$/.exec(sql.slice(i));
+      if (tagMatch) {
+        state = "dollar";
+        dollarTag = tagMatch[0].slice(1, -1);
+        i += tagMatch[0].length;
+        lastContentEnd = i;
+        continue;
+      }
+    }
+
+    if (!isSqlWhitespace(ch)) {
+      lastContentEnd = i + 1;
+    }
+    i += 1;
+  }
+
+  return trimRangeEnd(sql, from, lastContentEnd);
+}
+
+function isSqlWhitespace(ch: string): boolean {
+  return ch === " " || ch === "\t" || ch === "\r" || ch === "\n";
+}
+
+export function isOracleLikeDatabase(databaseType?: DatabaseType): boolean {
+  return !!databaseType && ORACLE_LIKE_PL_SQL_DATABASES.has(databaseType);
+}
+
+export function isOraclePlSqlStatement(sql: string, databaseType?: DatabaseType): boolean {
+  return isOracleLikeDatabase(databaseType) && startsWithOraclePlSqlBlock(sql);
+}
+
+function isSapHanaScriptBlockDatabase(databaseType?: DatabaseType): boolean {
+  return databaseType === "saphana";
+}
+
+function isSapHanaScriptBlockStatement(sql: string, databaseType?: DatabaseType): boolean {
+  return isSapHanaScriptBlockDatabase(databaseType) && startsWithSapHanaScriptBlock(sql);
+}
+
+function isMysqlRoutineBlockDatabase(databaseType?: DatabaseType): boolean {
+  return !!databaseType && MYSQL_ROUTINE_BLOCK_DATABASES.has(databaseType);
+}
+
+function startsWithMysqlRoutineBlock(sql: string): boolean {
+  return isMysqlRoutineDdlStart(sql) && mysqlRoutineTokens(sql).some((token) => token.kind === "word" && token.value === "BEGIN");
+}
+
+function isMysqlRoutineDdlStart(sql: string): boolean {
+  const words = mysqlRoutineWords(sql).slice(0, 16);
+  if (words[0] !== "CREATE") return false;
+
+  for (const word of words.slice(1)) {
+    if (MYSQL_ROUTINE_OBJECT_TYPES.has(word)) return true;
+    if (MYSQL_NON_ROUTINE_CREATE_TYPES.has(word)) return false;
+  }
+  return false;
+}
+
+function mysqlRoutineBlockIsComplete(sql: string): boolean {
+  if (!startsWithMysqlRoutineBlock(sql)) return false;
+
+  const tokens = mysqlRoutineTokens(sql);
+  let beginDepth = 0;
+  let sawBegin = false;
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token.kind !== "word") continue;
+    if (token.value === "BEGIN") {
+      if (previousWordToken(tokens, index) === "END") continue;
+      sawBegin = true;
+      beginDepth += 1;
+      continue;
+    }
+    if (token.value === "END" && sawBegin) {
+      if (MYSQL_CONTROL_BLOCK_SUFFIXES.has(nextWordToken(tokens, index) ?? "")) continue;
+      beginDepth = Math.max(0, beginDepth - 1);
+    }
+  }
+
+  return sawBegin && beginDepth === 0 && tokens[tokens.length - 1]?.kind === "semicolon";
+}
+
+function mysqlRoutineWords(sql: string): string[] {
+  return mysqlRoutineTokens(sql)
+    .filter((token): token is { kind: "word"; value: string } => token.kind === "word")
+    .map((token) => token.value);
+}
+
+function mysqlRoutineTokens(sql: string): Array<{ kind: "word" | "semicolon"; value: string }> {
+  const tokens: Array<{ kind: "word" | "semicolon"; value: string }> = [];
+  let state: QuoteState | "lineComment" | "blockComment" = "none";
+  let i = 0;
+
+  while (i < sql.length) {
+    const ch = sql[i];
+    const next = sql[i + 1] ?? "";
+
+    if (state === "lineComment") {
+      if (ch === "\n") state = "none";
+      i += 1;
+      continue;
+    }
+    if (state === "blockComment") {
+      if (ch === "*" && next === "/") {
+        state = "none";
+        i += 2;
+        continue;
+      }
+      i += 1;
+      continue;
+    }
+    if (state === "single") {
+      if (ch === "\\" && next) {
+        i += 2;
+        continue;
+      }
+      if (ch === "'" && next === "'") {
+        i += 2;
+        continue;
+      }
+      if (ch === "'") state = "none";
+      i += 1;
+      continue;
+    }
+    if (state === "double") {
+      if (ch === "\\" && next) {
+        i += 2;
+        continue;
+      }
+      if (ch === '"' && next === '"') {
+        i += 2;
+        continue;
+      }
+      if (ch === '"') state = "none";
+      i += 1;
+      continue;
+    }
+    if (state === "backtick") {
+      if (ch === "`" && next === "`") {
+        i += 2;
+        continue;
+      }
+      if (ch === "`") state = "none";
+      i += 1;
+      continue;
+    }
+
+    if (ch === "-" && next === "-") {
+      state = "lineComment";
+      i += 2;
+      continue;
+    }
+    if (ch === "#") {
+      state = "lineComment";
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      state = "blockComment";
+      i += 2;
+      continue;
+    }
+    if (ch === "'") {
+      state = "single";
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      state = "double";
+      i += 1;
+      continue;
+    }
+    if (ch === "`") {
+      state = "backtick";
+      i += 1;
+      continue;
+    }
+    if (ch === ";") {
+      tokens.push({ kind: "semicolon", value: ";" });
+      i += 1;
+      continue;
+    }
+
+    const word = /^[A-Za-z_][\w$]*/.exec(sql.slice(i))?.[0];
+    if (word) {
+      tokens.push({ kind: "word", value: word.toUpperCase() });
+      i += word.length;
+      continue;
+    }
+    i += 1;
+  }
+
+  return tokens;
+}
+
+function startsWithOraclePlSqlBlock(sql: string): boolean {
+  const words = oraclePlSqlWords(sql);
+  const first = words[0];
+  if (!first) return false;
+  if (ORACLE_PL_SQL_BLOCK_STARTERS.has(first)) return first !== "BEGIN" || words[1] !== "TRANSACTION";
+  if (first !== "CREATE") return false;
+
+  let index = 1;
+  while (["OR", "REPLACE", "EDITIONABLE", "NONEDITIONABLE"].includes(words[index] ?? "")) {
+    index += 1;
+  }
+  if (words[index] === "PACKAGE" && words[index + 1] === "BODY") return true;
+  if (words[index] === "TYPE" && words[index + 1] === "BODY") return true;
+  return ORACLE_PL_SQL_CREATE_OBJECT_TYPES.has(words[index] ?? "");
+}
+
+function startsWithSapHanaScriptBlock(sql: string): boolean {
+  return oraclePlSqlWords(sql)[0] === "DO";
+}
+
+function sapHanaScriptBlockIsComplete(sql: string): boolean {
+  if (!startsWithSapHanaScriptBlock(sql)) return false;
+
+  const tokens = oraclePlSqlTokens(sql);
+  const stack: string[] = [];
+  let sawBegin = false;
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token.kind !== "word") continue;
+
+    if (token.value === "BEGIN") {
+      if (previousWordToken(tokens, index) === "END") continue;
+      stack.push("BLOCK");
+      sawBegin = true;
+      continue;
+    }
+    if (token.value === "IF" || token.value === "FOR" || token.value === "WHILE" || token.value === "CASE") {
+      if (previousWordToken(tokens, index) !== "END") stack.push(token.value);
+      continue;
+    }
+    if (token.value === "END") {
+      const next = nextWordToken(tokens, index);
+      const top = stack[stack.length - 1];
+      const target = SAP_HANA_SCRIPT_BLOCK_TERMINATORS.has(next ?? "") ? next : top === "CASE" ? "CASE" : "BLOCK";
+      if (top === target) stack.pop();
+    }
+  }
+
+  return sawBegin && stack.length === 0 && tokens[tokens.length - 1]?.kind === "semicolon";
+}
+
+function oraclePlSqlBlockIsComplete(sql: string): boolean {
+  const tokens = oraclePlSqlTokens(sql);
+  if (!startsWithOraclePlSqlBlock(sql)) return false;
+
+  const stack: string[] = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (token.kind !== "word") continue;
+
+    if (token.value === "DECLARE") {
+      stack.push("BLOCK");
+      continue;
+    }
+    if (token.value === "BEGIN") {
+      if (tokens[index - 1]?.kind === "word" && tokens[index - 1]?.value === "TRANSACTION") continue;
+      const previous = previousWordToken(tokens, index);
+      if (previous === "END") continue;
+      if (stack[stack.length - 1] !== "BLOCK") stack.push("BLOCK");
+      continue;
+    }
+    if (token.value === "IF") {
+      const previous = previousWordToken(tokens, index);
+      if (previous !== "END" && previous !== "ELSIF") stack.push("IF");
+      continue;
+    }
+    if (token.value === "LOOP") {
+      if (previousWordToken(tokens, index) !== "END") stack.push("LOOP");
+      continue;
+    }
+    if (token.value === "CASE") {
+      if (previousWordToken(tokens, index) !== "END") stack.push("CASE");
+      continue;
+    }
+    if (token.value === "END") {
+      const next = nextWordToken(tokens, index);
+      const target = ORACLE_PL_SQL_TERMINATORS.has(next ?? "") ? next : "BLOCK";
+      const top = stack[stack.length - 1];
+      if (top === target || (target === "BLOCK" && top === "BLOCK")) stack.pop();
+      continue;
+    }
+  }
+
+  return stack.length === 0 && tokens[tokens.length - 1]?.kind === "semicolon";
+}
+
+function oraclePlSqlWords(sql: string): string[] {
+  return oraclePlSqlTokens(sql)
+    .filter((token): token is { kind: "word"; value: string } => token.kind === "word")
+    .map((token) => token.value);
+}
+
+function oraclePlSqlTokens(sql: string): Array<{ kind: "word" | "semicolon"; value: string }> {
+  const tokens: Array<{ kind: "word" | "semicolon"; value: string }> = [];
+  let state: QuoteState | "lineComment" | "blockComment" = "none";
+  let i = 0;
+
+  while (i < sql.length) {
+    const ch = sql[i];
+    const next = sql[i + 1] ?? "";
+
+    if (state === "lineComment") {
+      if (ch === "\n") state = "none";
+      i += 1;
+      continue;
+    }
+    if (state === "blockComment") {
+      if (ch === "*" && next === "/") {
+        state = "none";
+        i += 2;
+        continue;
+      }
+      i += 1;
+      continue;
+    }
+    if (state === "single") {
+      if (ch === "'" && next === "'") {
+        i += 2;
+        continue;
+      }
+      if (ch === "'") state = "none";
+      i += 1;
+      continue;
+    }
+    if (state === "double") {
+      if (ch === '"' && next === '"') {
+        i += 2;
+        continue;
+      }
+      if (ch === '"') state = "none";
+      i += 1;
+      continue;
+    }
+
+    if (ch === "-" && next === "-") {
+      state = "lineComment";
+      i += 2;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      state = "blockComment";
+      i += 2;
+      continue;
+    }
+    if (ch === "'") {
+      state = "single";
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      state = "double";
+      i += 1;
+      continue;
+    }
+    if (ch === ";") {
+      tokens.push({ kind: "semicolon", value: ";" });
+      i += 1;
+      continue;
+    }
+
+    const word = /^[A-Za-z_][\w$]*/.exec(sql.slice(i))?.[0];
+    if (word) {
+      tokens.push({ kind: "word", value: word.toUpperCase() });
+      i += word.length;
+      continue;
+    }
+    i += 1;
+  }
+
+  return tokens;
+}
+
+function previousWordToken(tokens: Array<{ kind: "word" | "semicolon"; value: string }>, index: number): string | null {
+  for (let i = index - 1; i >= 0; i -= 1) {
+    if (tokens[i].kind === "word") return tokens[i].value;
+  }
+  return null;
+}
+
+function nextWordToken(tokens: Array<{ kind: "word" | "semicolon"; value: string }>, index: number): string | null {
+  for (let i = index + 1; i < tokens.length; i += 1) {
+    if (tokens[i].kind === "word") return tokens[i].value;
+  }
+  return null;
+}
+
+function isAtLineStart(sql: string, pos: number): boolean {
+  for (let i = pos - 1; i >= 0; i -= 1) {
+    const ch = sql[i];
+    if (ch === "\n" || ch === "\r") return true;
+    if (ch !== " " && ch !== "\t") return false;
+  }
+  return true;
+}
+
+function isSlashLine(sql: string, pos: number): boolean {
+  const lineEnd = findLineEnd(sql, pos);
+  return sql.slice(pos, lineEnd).trim() === "/";
+}
+
+function supportsSqlServerGoCommands(databaseType?: DatabaseType): boolean {
+  return databaseType === "sqlserver";
+}
+
+function isSqlServerGoLine(sql: string, pos: number): boolean {
+  const lineEnd = findLineEnd(sql, pos);
+  return /^go(?:\s+\d+)?$/i.test(sql.slice(pos, lineEnd).trim());
+}
+
+function startsDelimiterCommand(sql: string, pos: number): boolean {
+  const prefix = sql.slice(pos, pos + 9);
+  return prefix.toLowerCase() === "delimiter" && (sql[pos + 9] === " " || sql[pos + 9] === "\t");
+}
+
+function parseDelimiterCommand(line: string): string | null {
+  const match = /^delimiter[ \t]+(.+)$/i.exec(line.trim());
+  const delimiter = match?.[1]?.trim();
+  return delimiter ? delimiter : null;
+}
+
+function findLineEnd(sql: string, pos: number): number {
+  const newline = sql.indexOf("\n", pos);
+  const carriageReturn = sql.indexOf("\r", pos);
+  if (newline === -1) return carriageReturn === -1 ? sql.length : carriageReturn;
+  if (carriageReturn === -1) return newline;
+  return Math.min(newline, carriageReturn);
+}
+
+function nextLineStart(sql: string, lineEnd: number): number {
+  if (sql[lineEnd] === "\r" && sql[lineEnd + 1] === "\n") return lineEnd + 2;
+  if (sql[lineEnd] === "\n" || sql[lineEnd] === "\r") return lineEnd + 1;
+  return lineEnd;
+}
+
+function rangeFor(statement: RawStatement, sql: string): SqlTextRange {
+  return {
+    from: statement.from,
+    to: statement.to,
+    sql: sql.slice(statement.from, statement.to),
+  };
+}
+
+function clampCursor(sql: string, cursorPos: number): number {
+  if (!Number.isFinite(cursorPos)) return 0;
+  if (cursorPos < 0) return 0;
+  if (cursorPos > sql.length) return sql.length;
+  return cursorPos;
+}
+
+function isCursorOnBlankLine(sql: string, pos: number): boolean {
+  const lineStart = sql.lastIndexOf("\n", pos - 1) + 1;
+  let lineEnd = sql.indexOf("\n", pos);
+  if (lineEnd === -1) lineEnd = sql.length;
+  return sql.slice(lineStart, lineEnd).trim() === "";
+}
+
+function isCursorOnStatementLine(sql: string, pos: number, statement: Pick<RawStatement, "from">): boolean {
+  const lineStart = sql.lastIndexOf("\n", pos - 1) + 1;
+  let lineEnd = sql.indexOf("\n", pos);
+  if (lineEnd === -1) lineEnd = sql.length;
+  return statement.from >= lineStart && statement.from <= lineEnd;
+}
+
+/**
+ * Returns the full document as a range, or `null` when it is empty/whitespace.
+ */
+export function fullSqlRange(sql: string): SqlTextRange | null {
+  const trimmed = sql.trim();
+  if (!trimmed) return null;
+  const from = sql.length - sql.trimStart().length;
+  const to = from + trimmed.length;
+  return { from, to, sql: sql.slice(from, to) };
+}
+
+function normalizeSql(sql: string): string {
+  return sql.replace(/\s+/g, " ").replace(/;\s*$/, "").trim();
+}
+
+/**
+ * Build the ordered list of execution candidates to show in the picker.
+ *
+ * Order is always `[cursor, all]` when both are available, except when the
+ * cursor statement and the full document are effectively the same SQL — in
+ * that case only a single candidate is returned to avoid duplicates.
+ */
+export function executableStatementRanges(sql: string, databaseType?: DatabaseType): SqlTextRange[] {
+  if (databaseType === "redis") return redisExecutableCommandRanges(sql);
+  if (databaseType === "mongodb") return splitMongoCommandRanges(sql).map(({ from, to, text }) => ({ from, to, sql: text }));
+  return splitSqlStatementRanges(sql, databaseType).flatMap((statement) => splitStatementRangeAtSoftStarts(sql, statement, databaseType).map((range) => rangeFor(range, sql)));
+}
+
+export function currentExecutableStatementRange(sql: string, cursorPos: number, databaseType?: DatabaseType): SqlTextRange | null {
+  if (databaseType === "redis") return redisCommandRangeAtCursor(sql, cursorPos);
+  if (databaseType === "mongodb") return null;
+  return statementRangeAtCursor(sql, cursorPos, databaseType);
+}
+
+export function buildExecutionCandidates(sql: string, cursorPos: number, databaseType?: DatabaseType): SqlExecutionCandidate[] {
+  const full = fullSqlRange(sql);
+  const cursorStatement = currentExecutableStatementRange(sql, cursorPos, databaseType);
+
+  if (!full && !cursorStatement) return [];
+  if (!full) {
+    return cursorStatement ? [candidateFromRange(cursorStatement, "cursor", databaseType)] : [];
+  }
+  if (!cursorStatement) {
+    return [candidateFromRange(full, "all", databaseType)];
+  }
+
+  const sameContent = normalizeSql(cursorStatement.sql) === normalizeSql(full.sql);
+  if (sameContent) {
+    return [candidateFromRange(full, "all", databaseType)];
+  }
+
+  return [candidateFromRange(cursorStatement, "cursor", databaseType), candidateFromRange(full, "all", databaseType)];
+}
+
+function candidateFromRange(range: SqlTextRange, kind: SqlExecutionCandidate["kind"], databaseType?: DatabaseType): SqlExecutionCandidate {
+  const isRedis = databaseType === "redis";
+  return {
+    kind,
+    label: kind === "cursor" ? (isRedis ? "currentCommand" : "currentStatement") : isRedis ? "allCommands" : "allStatements",
+    sql: range.sql,
+    from: range.from,
+    to: range.to,
+  };
+}
+
+function redisExecutableCommandCount(sql: string): number {
+  let count = 0;
+  for (const range of redisExecutableCommandRanges(sql)) {
+    if (!range.sql.trim()) continue;
+    count += 1;
+    if (count > 1) return count;
+  }
+  return count;
+}
+
+function redisExecutableCommandRanges(sql: string): SqlTextRange[] {
+  const ranges: SqlTextRange[] = [];
+  let lineStart = 0;
+  while (lineStart <= sql.length) {
+    let lineEnd = sql.indexOf("\n", lineStart);
+    if (lineEnd === -1) lineEnd = sql.length;
+    const rawLine = sql.slice(lineStart, lineEnd);
+    const leadingWhitespace = rawLine.length - rawLine.trimStart().length;
+    const trailingWhitespace = rawLine.length - rawLine.trimEnd().length;
+    const trimmedLine = rawLine.trim();
+    if (trimmedLine && !trimmedLine.startsWith("#")) {
+      const from = lineStart + leadingWhitespace;
+      const to = lineStart + rawLine.length - trailingWhitespace;
+      ranges.push({ from, to, sql: sql.slice(from, to) });
+    }
+    if (lineEnd >= sql.length) break;
+    lineStart = lineEnd + 1;
+  }
+  return ranges;
+}
+
+function redisCommandRangeAtCursor(sql: string, cursorPos: number): SqlTextRange | null {
+  const pos = clampCursor(sql, cursorPos);
+  if (isCursorOnBlankLine(sql, pos)) return null;
+
+  const lineStart = sql.lastIndexOf("\n", pos - 1) + 1;
+  let lineEnd = sql.indexOf("\n", pos);
+  if (lineEnd === -1) lineEnd = sql.length;
+
+  const rawLine = sql.slice(lineStart, lineEnd);
+  const leadingWhitespace = rawLine.length - rawLine.trimStart().length;
+  const trimmedLine = rawLine.trim();
+  if (!trimmedLine || trimmedLine.startsWith("#")) return null;
+
+  const from = lineStart + leadingWhitespace;
+  const to = lineStart + rawLine.length - (rawLine.length - rawLine.trimEnd().length);
+  return {
+    from,
+    to,
+    sql: sql.slice(from, to),
+  };
+}
diff --git a/apps/desktop/src/lib/sql/sqlVariableSyntax.ts b/apps/desktop/src/lib/sql/sqlVariableSyntax.ts
new file mode 100644
index 0000000..4e83d3d
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlVariableSyntax.ts
@@ -0,0 +1,93 @@
+// Per-database-type configuration for SQL variable/placeholder substitution.
+//
+// DBX runs two client-side substitution systems before sending SQL to a backend:
+// the placeholder parameter dialog (`sqlParameters.ts`, five syntaxes) and the
+// `@set name = value;` expansion (`sqlVariables.ts`). This module lets users opt
+// out of individual syntaxes per database type. Every toggle defaults to `true`,
+// so an empty/absent config reproduces the historical "always substitute" behaviour.
+//
+// Storage is sparse: only syntaxes explicitly turned off (`false`) are persisted,
+// keyed by database type. Anything not stored resolves to enabled.
+
+import type { DatabaseType } from "@/types/database";
+import type { SqlParameterSyntax } from "@/lib/sql/sqlParameters";
+import { manifestDatabaseTypes } from "@/lib/database/databaseDriverManifest";
+
+export interface SqlVariableSyntaxToggles {
+  positional: boolean; // ?
+  named: boolean; // :name
+  shell: boolean; // ${name}
+  mybatis: boolean; // #{name}
+  sqlserver: boolean; // @name
+  atSet: boolean; // @set name = value;  (expandSqlVariables)
+}
+
+export const DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES: SqlVariableSyntaxToggles = {
+  positional: true,
+  named: true,
+  shell: true,
+  mybatis: true,
+  sqlserver: true,
+  atSet: true,
+};
+
+// Fixed order for iterating the toggles in the settings UI.
+export const SQL_VARIABLE_SYNTAX_KEYS = ["positional", "named", "shell", "mybatis", "sqlserver", "atSet"] as const satisfies readonly (keyof SqlVariableSyntaxToggles)[];
+
+// Display tokens (code symbols, not translated) shown next to each toggle.
+export const SQL_VARIABLE_SYNTAX_TOKENS: Record<keyof SqlVariableSyntaxToggles, string> = {
+  positional: "?",
+  named: ":name",
+  shell: "${name}",
+  mybatis: "#{name}",
+  sqlserver: "@name",
+  atSet: "@set …;",
+};
+
+// The first five toggles map one-to-one onto placeholder parameter syntaxes.
+const PARAMETER_SYNTAX_KEYS = ["positional", "named", "shell", "mybatis", "sqlserver"] as const satisfies readonly SqlParameterSyntax[];
+
+export type SqlVariableSyntaxOverrides = Partial<Record<DatabaseType, Partial<SqlVariableSyntaxToggles>>>;
+
+// Database types offered in the settings selector — every connectable type.
+export const SQL_VARIABLE_SYNTAX_DATABASE_TYPES: DatabaseType[] = manifestDatabaseTypes();
+
+/**
+ * Resolve the effective toggles for a database type. Any syntax not explicitly
+ * disabled in `overrides` is enabled. A pure function safe to call on every
+ * execution.
+ */
+export function resolveSqlVariableSyntaxToggles(overrides: SqlVariableSyntaxOverrides | undefined, dbType: DatabaseType | undefined): SqlVariableSyntaxToggles {
+  const partial = dbType ? overrides?.[dbType] : undefined;
+  return {
+    positional: partial?.positional ?? true,
+    named: partial?.named ?? true,
+    shell: partial?.shell ?? true,
+    mybatis: partial?.mybatis ?? true,
+    sqlserver: partial?.sqlserver ?? true,
+    atSet: partial?.atSet ?? true,
+  };
+}
+
+/** Derive the enabled placeholder parameter syntaxes (excludes `atSet`). */
+export function enabledSqlParameterSyntaxes(toggles: SqlVariableSyntaxToggles): SqlParameterSyntax[] {
+  return PARAMETER_SYNTAX_KEYS.filter((key) => toggles[key]);
+}
+
+/**
+ * Normalize persisted overrides into a sparse structure: drop non-object entries
+ * and only keep syntaxes explicitly set to `false`. Absence resolves to enabled.
+ */
+export function normalizeSqlVariableSyntaxOverrides(value: unknown): SqlVariableSyntaxOverrides {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const result: SqlVariableSyntaxOverrides = {};
+  for (const [dbType, raw] of Object.entries(value as Record<string, unknown>)) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+    const partial: Partial<SqlVariableSyntaxToggles> = {};
+    for (const key of SQL_VARIABLE_SYNTAX_KEYS) {
+      if ((raw as Record<string, unknown>)[key] === false) partial[key] = false;
+    }
+    if (Object.keys(partial).length > 0) result[dbType as DatabaseType] = partial;
+  }
+  return result;
+}
diff --git a/apps/desktop/src/lib/sql/sqlVariables.ts b/apps/desktop/src/lib/sql/sqlVariables.ts
new file mode 100644
index 0000000..b193158
--- /dev/null
+++ b/apps/desktop/src/lib/sql/sqlVariables.ts
@@ -0,0 +1,331 @@
+// Client-side SQL variable expansion.
+//
+// Lets users declare reusable values inside a SQL script with `@set name = value;`
+// and reference them elsewhere as `@name`. Expansion happens entirely on the client:
+// declarations are stripped and every reference is replaced with the declared value
+// verbatim (raw). Because the SQL sent to the server contains only plain literals,
+// this works uniformly across PostgreSQL, MySQL, SQL Server and every other backend
+// regardless of whether they have native variable support.
+//
+// This is intentionally separate from the placeholder parameter system
+// (`sqlParameters.ts`). A `@name` reference is only expanded when a matching
+// `@set` declaration exists in the same script; any other `@name` (SQL Server
+// native variables, `@@version`, dialog parameters) is left untouched.
+
+const VARIABLE_NAME_START_RE = /[\p{L}_]/u;
+const VARIABLE_NAME_CHAR_RE = /[\p{L}\p{N}_]/u;
+
+export interface SqlVariableExpansion {
+  sql: string;
+  expanded: boolean;
+}
+
+interface DeclarationSpan {
+  name: string;
+  value: string;
+  start: number;
+  end: number;
+}
+
+/**
+ * Expand `@set name = value;` declarations within a SQL script.
+ *
+ * Returns the SQL with declarations removed and `@name` references replaced by
+ * their declared values. When no declaration is found the input is returned
+ * unchanged with `expanded: false`.
+ */
+export function expandSqlVariables(sql: string): SqlVariableExpansion {
+  const declarations = collectDeclarations(sql);
+  if (!declarations.length) return { sql, expanded: false };
+
+  const values = new Map<string, string>();
+  for (const declaration of declarations) {
+    values.set(declaration.name.toLowerCase(), declaration.value);
+  }
+
+  // Remove declaration spans first (right-to-left keeps earlier offsets valid),
+  // then replace references in the remaining text.
+  let result = sql;
+  for (let i = declarations.length - 1; i >= 0; i -= 1) {
+    const declaration = declarations[i];
+    result = stripDeclaration(result, declaration.start, declaration.end);
+  }
+
+  result = replaceReferences(result, values);
+  return { sql: result, expanded: true };
+}
+
+function collectDeclarations(sql: string): DeclarationSpan[] {
+  const declarations: DeclarationSpan[] = [];
+  let i = 0;
+  let dollarQuoteEnd = "";
+
+  while (i < sql.length) {
+    if (dollarQuoteEnd) {
+      const end = sql.indexOf(dollarQuoteEnd, i);
+      if (end === -1) break;
+      i = end + dollarQuoteEnd.length;
+      dollarQuoteEnd = "";
+      continue;
+    }
+
+    const ch = sql[i];
+    const next = sql[i + 1];
+
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(sql, i, ch);
+      continue;
+    }
+    if (ch === "[") {
+      i = skipBracketIdentifier(sql, i);
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      i = skipLine(sql, i + 2);
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      i = skipBlockComment(sql, i + 2);
+      continue;
+    }
+    if (ch === "$") {
+      const marker = readDollarQuoteMarker(sql, i);
+      if (marker) {
+        dollarQuoteEnd = marker;
+        i += marker.length;
+        continue;
+      }
+    }
+    if (ch === "@" && matchesWord(sql, i + 1, "set") && isStatementStart(sql, i)) {
+      const declaration = readDeclaration(sql, i);
+      if (declaration) {
+        declarations.push(declaration);
+        i = declaration.end;
+        continue;
+      }
+    }
+    i += 1;
+  }
+
+  return declarations;
+}
+
+// Parse `@set name = value` starting at `start` (the `@`). The value runs until
+// the terminating `;` or end of input, honouring nested quotes, comments and
+// parentheses so that `IN (...)` lists and quoted strings survive intact.
+function readDeclaration(sql: string, start: number): DeclarationSpan | null {
+  let i = start + 1 + "set".length;
+  i = skipInlineWhitespace(sql, i);
+
+  const name = readVariableName(sql, i);
+  if (!name) return null;
+  i += name.length;
+
+  i = skipInlineWhitespace(sql, i);
+  if (sql[i] !== "=") return null;
+  i += 1;
+  i = skipInlineWhitespace(sql, i);
+
+  const valueStart = i;
+  const valueEnd = readValueEnd(sql, i);
+  const value = sql.slice(valueStart, valueEnd).trim();
+  if (!value) return null;
+
+  // Consume the terminating semicolon so the declaration disappears cleanly.
+  let end = valueEnd;
+  if (sql[end] === ";") end += 1;
+
+  return { name, value, start, end };
+}
+
+function readValueEnd(sql: string, start: number): number {
+  let i = start;
+  let depth = 0;
+  while (i < sql.length) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (ch === "'" || ch === '"' || ch === "`") {
+      i = skipQuoted(sql, i, ch);
+      continue;
+    }
+    if (ch === "[") {
+      i = skipBracketIdentifier(sql, i);
+      continue;
+    }
+    if (ch === "-" && next === "-") return i;
+    if (ch === "/" && next === "*") return i;
+    if (ch === "$") {
+      const marker = readDollarQuoteMarker(sql, i);
+      if (marker) {
+        const end = sql.indexOf(marker, i + marker.length);
+        i = end === -1 ? sql.length : end + marker.length;
+        continue;
+      }
+    }
+    if (ch === "(") depth += 1;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    else if ((ch === ";" || ch === "\n") && depth === 0) return i;
+    i += 1;
+  }
+  return sql.length;
+}
+
+function replaceReferences(sql: string, values: Map<string, string>): string {
+  let result = "";
+  let i = 0;
+  let dollarQuoteEnd = "";
+
+  while (i < sql.length) {
+    if (dollarQuoteEnd) {
+      const end = sql.indexOf(dollarQuoteEnd, i);
+      const stop = end === -1 ? sql.length : end + dollarQuoteEnd.length;
+      result += sql.slice(i, stop);
+      i = stop;
+      dollarQuoteEnd = "";
+      continue;
+    }
+
+    const ch = sql[i];
+    const next = sql[i + 1];
+
+    if (ch === "'" || ch === '"' || ch === "`") {
+      const end = skipQuoted(sql, i, ch);
+      result += sql.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (ch === "[") {
+      const end = skipBracketIdentifier(sql, i);
+      result += sql.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (ch === "-" && next === "-") {
+      const end = skipLine(sql, i + 2);
+      result += sql.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (ch === "/" && next === "*") {
+      const end = skipBlockComment(sql, i + 2);
+      result += sql.slice(i, end);
+      i = end;
+      continue;
+    }
+    if (ch === "$") {
+      const marker = readDollarQuoteMarker(sql, i);
+      if (marker) {
+        result += marker;
+        i += marker.length;
+        dollarQuoteEnd = marker;
+        continue;
+      }
+    }
+    if (ch === "@" && next !== "@" && sql[i - 1] !== "@") {
+      const name = readVariableName(sql, i + 1);
+      if (name) {
+        const value = values.get(name.toLowerCase());
+        if (value !== undefined) {
+          result += value;
+          i += 1 + name.length;
+          continue;
+        }
+      }
+    }
+    result += ch;
+    i += 1;
+  }
+
+  return result;
+}
+
+// Remove a declaration span, collapsing the leftover blank line it leaves behind
+// so the expanded SQL stays tidy.
+function stripDeclaration(sql: string, start: number, end: number): string {
+  let lineStart = start;
+  while (lineStart > 0 && sql[lineStart - 1] !== "\n") {
+    if (sql[lineStart - 1] !== " " && sql[lineStart - 1] !== "\t" && sql[lineStart - 1] !== "\r") break;
+    lineStart -= 1;
+  }
+  const trimmableStart = lineStart === 0 || sql[lineStart - 1] === "\n" ? lineStart : start;
+
+  let lineEnd = end;
+  while (lineEnd < sql.length && (sql[lineEnd] === " " || sql[lineEnd] === "\t" || sql[lineEnd] === "\r")) lineEnd += 1;
+  if (trimmableStart === lineStart && sql[lineEnd] === "\n") lineEnd += 1;
+
+  return sql.slice(0, trimmableStart) + sql.slice(lineEnd);
+}
+
+function isStatementStart(sql: string, start: number): boolean {
+  let i = start - 1;
+  while (i >= 0 && /\s/.test(sql[i])) i -= 1;
+  return i < 0 || sql[i] === ";";
+}
+
+function matchesWord(sql: string, start: number, word: string): boolean {
+  const value = sql.slice(start, start + word.length);
+  if (value.toLowerCase() !== word) return false;
+  return !VARIABLE_NAME_CHAR_RE.test(sql[start + word.length] ?? "");
+}
+
+function readVariableName(sql: string, start: number): string {
+  if (!VARIABLE_NAME_START_RE.test(sql[start] ?? "")) return "";
+  let i = start + 1;
+  while (i < sql.length && VARIABLE_NAME_CHAR_RE.test(sql[i])) i += 1;
+  return sql.slice(start, i);
+}
+
+function skipInlineWhitespace(sql: string, start: number): number {
+  let i = start;
+  while (i < sql.length && (sql[i] === " " || sql[i] === "\t" || sql[i] === "\r")) i += 1;
+  return i;
+}
+
+function skipQuoted(sql: string, start: number, quote: string): number {
+  let i = start + 1;
+  while (i < sql.length) {
+    if (sql[i] === "\\" && quote === "'" && i + 1 < sql.length) {
+      i += 2;
+      continue;
+    }
+    if (sql[i] === quote) {
+      if (sql[i + 1] === quote) {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i += 1;
+  }
+  return sql.length;
+}
+
+function skipBracketIdentifier(sql: string, start: number): number {
+  let i = start + 1;
+  while (i < sql.length) {
+    if (sql[i] === "]") {
+      if (sql[i + 1] === "]") {
+        i += 2;
+        continue;
+      }
+      return i + 1;
+    }
+    i += 1;
+  }
+  return sql.length;
+}
+
+function skipLine(sql: string, start: number): number {
+  const nextNewline = sql.indexOf("\n", start);
+  return nextNewline === -1 ? sql.length : nextNewline + 1;
+}
+
+function skipBlockComment(sql: string, start: number): number {
+  const end = sql.indexOf("*/", start);
+  return end === -1 ? sql.length : end + 2;
+}
+
+function readDollarQuoteMarker(sql: string, start: number): string {
+  const match = sql.slice(start).match(/^\$[A-Za-z_][A-Za-z0-9_]*\$|^\$\$/);
+  return match?.[0] ?? "";
+}
diff --git a/apps/desktop/src/lib/table/__tests__/tableDataRefresh.spec.ts b/apps/desktop/src/lib/table/__tests__/tableDataRefresh.spec.ts
new file mode 100644
index 0000000..76c3c96
--- /dev/null
+++ b/apps/desktop/src/lib/table/__tests__/tableDataRefresh.spec.ts
@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { canReloadUnavailableDataTab } from "@/lib/table/tableDataRefresh";
+
+describe("canReloadUnavailableDataTab", () => {
+  it("allows restored data tabs to reload before the grid mounts", () => {
+    expect(canReloadUnavailableDataTab({ mode: "data", result: undefined, isExecuting: false })).toBe(true);
+  });
+
+  it("does not start duplicate or unrelated reloads", () => {
+    expect(canReloadUnavailableDataTab({ mode: "data", result: undefined, isExecuting: true })).toBe(false);
+    expect(canReloadUnavailableDataTab({ mode: "query", result: undefined, isExecuting: false })).toBe(false);
+  });
+
+  it("keeps populated data tabs on the DataGrid refresh path", () => {
+    expect(
+      canReloadUnavailableDataTab({
+        mode: "data",
+        isExecuting: false,
+        result: { columns: ["id"], rows: [[1]], row_count: 1, execution_time_ms: 1 },
+      }),
+    ).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/lib/table/batchTableTruncate.ts b/apps/desktop/src/lib/table/batchTableTruncate.ts
new file mode 100644
index 0000000..fae2866
--- /dev/null
+++ b/apps/desktop/src/lib/table/batchTableTruncate.ts
@@ -0,0 +1,11 @@
+export async function runBatchTableTruncate<T>(targets: readonly T[], execute: (target: T) => Promise<boolean | void>, refreshSucceeded: (targets: readonly T[]) => Promise<void>): Promise<void> {
+  const succeeded: T[] = [];
+  try {
+    for (const target of targets) {
+      if ((await execute(target)) !== false) succeeded.push(target);
+    }
+  } finally {
+    // A later failure must not leave tabs for already truncated tables showing stale rows.
+    if (succeeded.length > 0) await refreshSucceeded(succeeded);
+  }
+}
diff --git a/apps/desktop/src/lib/table/dataTabExecutionDatabase.ts b/apps/desktop/src/lib/table/dataTabExecutionDatabase.ts
new file mode 100644
index 0000000..f47d01c
--- /dev/null
+++ b/apps/desktop/src/lib/table/dataTabExecutionDatabase.ts
@@ -0,0 +1,15 @@
+import type { ConnectionConfig } from "@/types/database";
+import { connectionIsDorisFamilyCatalogCapable } from "@/lib/database/databaseFeatureSupport";
+import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+
+export function dataTabExecutionDatabase(connection: ConnectionConfig | undefined, tabDatabase: string, catalog?: string): string {
+  if (!catalog?.trim()) return tabDatabase;
+
+  const databaseType = effectiveDatabaseTypeForConnection(connection);
+  const usesExternalCatalog = connectionIsDorisFamilyCatalogCapable(connection) || databaseType === "doris" || databaseType === "starrocks";
+  if (!usesExternalCatalog) return tabDatabase;
+
+  // External catalog namespaces qualify the SQL object name, but they are not
+  // valid MySQL-protocol session databases. Keep the configured internal DB.
+  return connection?.database ?? "";
+}
diff --git a/apps/desktop/src/lib/table/mysqlDataTypeHelp.ts b/apps/desktop/src/lib/table/mysqlDataTypeHelp.ts
new file mode 100644
index 0000000..e26c729
--- /dev/null
+++ b/apps/desktop/src/lib/table/mysqlDataTypeHelp.ts
@@ -0,0 +1,199 @@
+export type MysqlDataTypeHelpKey =
+  | "tinyint"
+  | "smallint"
+  | "mediumint"
+  | "int"
+  | "bigint"
+  | "decimal"
+  | "float"
+  | "double"
+  | "real"
+  | "bit"
+  | "boolean"
+  | "serial"
+  | "date"
+  | "datetime"
+  | "timestamp"
+  | "time"
+  | "year"
+  | "char"
+  | "varchar"
+  | "tinytext"
+  | "text"
+  | "mediumtext"
+  | "longtext"
+  | "binary"
+  | "varbinary"
+  | "tinyblob"
+  | "blob"
+  | "mediumblob"
+  | "longblob"
+  | "enum"
+  | "set"
+  | "json"
+  | "jsonMysql"
+  | "jsonMariaDb"
+  | "nationalCharacter"
+  | "geometry"
+  | "point"
+  | "linestring"
+  | "polygon"
+  | "multipoint"
+  | "multilinestring"
+  | "multipolygon"
+  | "geometrycollection"
+  | "inet4"
+  | "inet6"
+  | "uuid"
+  | "vector"
+  | "xmltype"
+  | "integerDisplayWidth"
+  | "zerofill"
+  | "unsignedNumeric"
+  | "floatPrecision"
+  | "floatingPointDisplay";
+
+export interface MysqlDataTypeHelp {
+  key: MysqlDataTypeHelpKey;
+  warningKeys?: MysqlDataTypeHelpKey[];
+}
+
+export interface MysqlDataTypeHelpOptions {
+  /** Set only when the selected connection profile identifies the server product. */
+  product?: "mysql" | "mariadb";
+}
+
+const MYSQL_TYPE_HELP_KEYS: Readonly<Record<string, MysqlDataTypeHelpKey>> = {
+  tinyint: "tinyint",
+  smallint: "smallint",
+  mediumint: "mediumint",
+  int: "int",
+  bigint: "bigint",
+  decimal: "decimal",
+  float: "float",
+  double: "double",
+  real: "real",
+  bit: "bit",
+  boolean: "boolean",
+  nationalCharacter: "nationalCharacter",
+  serial: "serial",
+  date: "date",
+  datetime: "datetime",
+  timestamp: "timestamp",
+  time: "time",
+  year: "year",
+  char: "char",
+  varchar: "varchar",
+  tinytext: "tinytext",
+  text: "text",
+  mediumtext: "mediumtext",
+  longtext: "longtext",
+  binary: "binary",
+  varbinary: "varbinary",
+  tinyblob: "tinyblob",
+  blob: "blob",
+  mediumblob: "mediumblob",
+  longblob: "longblob",
+  enum: "enum",
+  set: "set",
+  json: "json",
+  geometry: "geometry",
+  point: "point",
+  linestring: "linestring",
+  polygon: "polygon",
+  multipoint: "multipoint",
+  multilinestring: "multilinestring",
+  multipolygon: "multipolygon",
+  geometrycollection: "geometrycollection",
+  inet4: "inet4",
+  inet6: "inet6",
+  uuid: "uuid",
+  vector: "vector",
+  xmltype: "xmltype",
+};
+
+const MYSQL_TYPE_ALIASES: Readonly<Record<string, string>> = {
+  integer: "int",
+  numeric: "decimal",
+  dec: "decimal",
+  fixed: "decimal",
+  bool: "boolean",
+  "character varying": "varchar",
+  character: "char",
+  "char varying": "varchar",
+  "char byte": "char",
+  nchar: "nationalCharacter",
+  nvarchar: "nationalCharacter",
+  "nchar varying": "nationalCharacter",
+  "national char": "nationalCharacter",
+  "national character": "nationalCharacter",
+  "national varchar": "nationalCharacter",
+  "national char varying": "nationalCharacter",
+  "national character varying": "nationalCharacter",
+  "double precision": "double",
+  float4: "float",
+  float8: "double",
+  int1: "tinyint",
+  int2: "smallint",
+  int3: "mediumint",
+  int4: "int",
+  int8: "bigint",
+  middleint: "mediumint",
+  long: "mediumtext",
+  "long varchar": "mediumtext",
+  "long varbinary": "mediumblob",
+  geomcollection: "geometrycollection",
+};
+
+/**
+ * Returns help for a MySQL-family type name without making a database request.
+ * The caller is responsible for limiting this to connections that use MySQL
+ * semantics, since several compatible databases accept similarly named types
+ * with different limits.
+ */
+export function getMysqlDataTypeHelp(rawType: string, options: MysqlDataTypeHelpOptions = {}): MysqlDataTypeHelp | undefined {
+  const normalized = normalizeMysqlType(rawType);
+  const resolvedType = MYSQL_TYPE_ALIASES[normalized] ?? normalized;
+  const baseKey = MYSQL_TYPE_HELP_KEYS[resolvedType];
+  if (!baseKey) return undefined;
+
+  const key = resolvedType === "json" ? jsonHelpKey(options.product) : baseKey;
+  const warningKeys = mysqlDataTypeWarningKeys(rawType, resolvedType);
+  return warningKeys.length > 0 ? { key, warningKeys } : { key };
+}
+
+function jsonHelpKey(product: MysqlDataTypeHelpOptions["product"]): MysqlDataTypeHelpKey {
+  if (product === "mysql") return "jsonMysql";
+  if (product === "mariadb") return "jsonMariaDb";
+  return "json";
+}
+
+function mysqlDataTypeWarningKeys(rawType: string, resolvedType: string): MysqlDataTypeHelpKey[] {
+  const lowered = rawType.trim().toLowerCase().replace(/\s+/g, " ");
+  const warnings: MysqlDataTypeHelpKey[] = [];
+  const isInteger = ["tinyint", "smallint", "mediumint", "int", "bigint"].includes(resolvedType);
+  const isNumeric = isInteger || ["decimal", "float", "double", "real"].includes(resolvedType);
+
+  if (isInteger && /\(\s*\d+\s*\)/.test(lowered)) warnings.push("integerDisplayWidth");
+  if (isNumeric && /\bzerofill\b/.test(lowered)) warnings.push("zerofill");
+  if (["decimal", "float", "double", "real"].includes(resolvedType) && /\bunsigned\b/.test(lowered)) warnings.push("unsignedNumeric");
+
+  const parameters = lowered.match(/\(([^)]*)\)/)?.[1]?.trim() ?? "";
+  if (resolvedType === "float" && /^\d+$/.test(parameters)) {
+    const precision = Number(parameters);
+    if (precision >= 25 && precision <= 53) warnings.push("floatPrecision");
+  }
+  if (["float", "double"].includes(resolvedType) && /^\d+\s*,\s*\d+$/.test(parameters)) warnings.push("floatingPointDisplay");
+
+  return warnings;
+}
+
+function normalizeMysqlType(rawType: string): string {
+  return rawType
+    .trim()
+    .toLowerCase()
+    .replace(/\([^)]*\)/g, " ")
+    .replace(/\b(?:unsigned|signed|zerofill)\b/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
diff --git a/apps/desktop/src/lib/table/objectBrowserRowAction.ts b/apps/desktop/src/lib/table/objectBrowserRowAction.ts
new file mode 100644
index 0000000..59e4638
--- /dev/null
+++ b/apps/desktop/src/lib/table/objectBrowserRowAction.ts
@@ -0,0 +1,67 @@
+import type { ObjectBrowserRow } from "@/lib/table/objectBrowserRows";
+
+export type ObjectBrowserRowAction = "table-info" | "open-table" | "open-source" | "none";
+
+/**
+ * Determine the action for a single click on an object browser row.
+ * - TABLE → table-info (show table properties panel)
+ * - VIEW/MATERIALIZED_VIEW/PROCEDURE/FUNCTION/SEQUENCE/PACKAGE/PACKAGE_BODY → open-source
+ * - otherwise → none
+ */
+export function singleClickRowAction(row: ObjectBrowserRow | null | undefined): ObjectBrowserRowAction {
+  if (!row) return "none";
+  if (row.type === "TABLE") return "table-info";
+  if (canOpenSource(row)) return "open-source";
+  return "none";
+}
+
+/**
+ * Determine the action for a double click on an object browser row.
+ * - TABLE → open-table (open table data tab)
+ * - VIEW/MATERIALIZED_VIEW/PROCEDURE/FUNCTION/SEQUENCE/PACKAGE/PACKAGE_BODY → open-source
+ * - otherwise → none
+ */
+export function doubleClickRowAction(row: ObjectBrowserRow | null | undefined): ObjectBrowserRowAction {
+  if (!row) return "none";
+  if (row.type === "TABLE") return "open-table";
+  if (canOpenSource(row)) return "open-source";
+  return "none";
+}
+
+/**
+ * Resolve a row click event into a single or double action based on click detail
+ * and the sidebar activation setting.
+ *
+ * In both single-click and double-click activation modes, a single click
+ * triggers the side-panel action (table-info / open-source). When a distinct
+ * double-click action exists (e.g. TABLE single→table-info, double→open-table),
+ * the caller defers the single-click via shouldDeferSingleClick so the second
+ * click can cancel it.
+ */
+export function resolveRowClickAction(row: ObjectBrowserRow | null | undefined, detail: number, activation: "single" | "double"): { action: ObjectBrowserRowAction; isDouble: boolean } {
+  if (activation === "double") {
+    if (detail === 2) return { action: doubleClickRowAction(row), isDouble: true };
+    return { action: singleClickRowAction(row), isDouble: false };
+  }
+  // single-click activation
+  if (detail > 1) return { action: doubleClickRowAction(row), isDouble: true };
+  return { action: singleClickRowAction(row), isDouble: false };
+}
+
+/**
+ * Whether a single-click action should be deferred to distinguish it from a
+ * possible upcoming double-click. Applies when the row's single-click and
+ * double-click actions differ (e.g. TABLE: single → table-info, double →
+ * open-table). For rows whose single and double actions are identical
+ * (e.g. VIEW → open-source both), no deferral is needed.
+ */
+export function shouldDeferSingleClick(row: ObjectBrowserRow | null | undefined, action: ObjectBrowserRowAction): boolean {
+  if (action === "none") return false;
+  const single = singleClickRowAction(row);
+  const double = doubleClickRowAction(row);
+  return single !== double && action === single;
+}
+
+function canOpenSource(row: ObjectBrowserRow): boolean {
+  return row.type === "VIEW" || row.type === "MATERIALIZED_VIEW" || row.type === "PROCEDURE" || row.type === "FUNCTION" || row.type === "SEQUENCE" || row.type === "PACKAGE" || row.type === "PACKAGE_BODY";
+}
diff --git a/apps/desktop/src/lib/table/objectBrowserRows.ts b/apps/desktop/src/lib/table/objectBrowserRows.ts
new file mode 100644
index 0000000..8b17d2c
--- /dev/null
+++ b/apps/desktop/src/lib/table/objectBrowserRows.ts
@@ -0,0 +1,196 @@
+import type { ObjectInfo } from "@/types/database";
+import { createDatabaseObjectNameComparator, normalizeDatabaseObjectName } from "@/lib/table/tableTree";
+import { parseSlashDelimitedRegexQuery } from "@/lib/common/searchPattern";
+
+export type ObjectBrowserRow = {
+  id: string;
+  name: string;
+  displayName: string;
+  schema?: string;
+  type: "TABLE" | "VIEW" | "MATERIALIZED_VIEW" | "PROCEDURE" | "FUNCTION" | "SEQUENCE" | "PACKAGE" | "PACKAGE_BODY";
+  signature?: string | null;
+  comment?: string | null;
+  created_at?: string | null;
+  updated_at?: string | null;
+  partitionParentId?: string;
+  partitionCount?: number;
+  partitionParentSchema?: string;
+  partitionParentName?: string;
+  estimatedRows?: number | null;
+  totalBytes?: number | null;
+};
+
+export type ObjectBrowserSortKey = "name" | "type" | "estimatedRows" | "totalBytes" | "created_at" | "updated_at" | "comment";
+export type ObjectBrowserSortDirection = "asc" | "desc";
+
+export function normalizeObjectBrowserType(type: string): ObjectBrowserRow["type"] {
+  const value = type.toUpperCase();
+  const normalized = value.replace(/[\s-]+/g, "_");
+  if (normalized.includes("PACKAGE_BODY")) return "PACKAGE_BODY";
+  if (normalized.includes("PACKAGE")) return "PACKAGE";
+  if (normalized.includes("MATERIALIZED_VIEW")) return "MATERIALIZED_VIEW";
+  if (value.includes("VIEW")) return "VIEW";
+  if (value.includes("SEQ")) return "SEQUENCE";
+  if (value.includes("PROC")) return "PROCEDURE";
+  if (value.includes("FUNC")) return "FUNCTION";
+  return "TABLE";
+}
+
+export function buildObjectBrowserRows(options: { objects: ObjectInfo[]; database: string; fallbackSchema: string; needsSchema: boolean }): ObjectBrowserRow[] {
+  const seen = new Map<string, number>();
+  const rows = options.objects.flatMap((object) => {
+    const name = normalizeDatabaseObjectName(object.name);
+    if (!name) return [];
+    const objectSchema = object.schema ? normalizeDatabaseObjectName(object.schema) : undefined;
+    const schema = objectSchema || (options.needsSchema ? options.fallbackSchema : undefined);
+    const type = normalizeObjectBrowserType(object.object_type);
+    const signature = routineSignatureForDisplay(type, object.signature);
+    const displayName = signature === undefined ? name : `${name}(${signature})`;
+    const signatureIdPart = signature === undefined ? "" : `:${signature}`;
+    const baseId = `${schema || options.fallbackSchema || options.database}:${name}:${type}${signatureIdPart}`;
+    const index = seen.get(baseId) ?? 0;
+    seen.set(baseId, index + 1);
+    return [
+      {
+        id: `${baseId}:${index}`,
+        name,
+        displayName,
+        schema,
+        type,
+        signature,
+        comment: object.comment,
+        created_at: object.created_at,
+        updated_at: object.updated_at,
+        partitionParentSchema: object.parent_schema ? normalizeDatabaseObjectName(object.parent_schema) : undefined,
+        partitionParentName: object.parent_name ? normalizeDatabaseObjectName(object.parent_name) : undefined,
+      },
+    ];
+  });
+
+  markPartitionRows(rows, options.fallbackSchema || options.database);
+  return rows;
+}
+
+function routineSignatureForDisplay(type: ObjectBrowserRow["type"], signature: string | null | undefined): string | undefined {
+  if (type !== "PROCEDURE" && type !== "FUNCTION") return undefined;
+  if (signature == null) return undefined;
+  return signature.trim();
+}
+
+function markPartitionRows(rows: ObjectBrowserRow[], fallbackSchema: string) {
+  const tableByKey = new Map<string, ObjectBrowserRow>();
+  for (const row of rows) {
+    if (row.type !== "TABLE") continue;
+    tableByKey.set(objectKey(row, fallbackSchema), row);
+  }
+
+  const partitionCountByParent = new Map<string, number>();
+  for (const row of rows) {
+    if (row.type !== "TABLE") continue;
+    const parentName = row.partitionParentName || partitionParentName(row.name);
+    if (!parentName) continue;
+    const parentKey = objectKey({ ...row, schema: row.partitionParentSchema || row.schema, name: parentName }, fallbackSchema);
+    const parent = tableByKey.get(parentKey);
+    if (!parent || parent.id === row.id) continue;
+    row.partitionParentId = parent.id;
+    partitionCountByParent.set(parent.id, (partitionCountByParent.get(parent.id) ?? 0) + 1);
+  }
+
+  for (const row of rows) {
+    row.partitionCount = partitionCountByParent.get(row.id);
+  }
+}
+
+function objectKey(row: Pick<ObjectBrowserRow, "schema" | "name" | "type">, fallbackSchema: string) {
+  return `${row.type}\0${(row.schema || fallbackSchema).toLowerCase()}\0${row.name.toLowerCase()}`;
+}
+
+function partitionParentName(name: string): string | null {
+  const match = /^(.*)_p\d{4,}$/.exec(name);
+  return match?.[1] || null;
+}
+
+export function filterObjectBrowserRows(rows: ObjectBrowserRow[], query: string): ObjectBrowserRow[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return rows;
+  const regex = parseSlashDelimitedRegexQuery(query.trim());
+  if (regex) {
+    return rows.filter((row) => [row.displayName, row.name, row.type, row.comment].filter(Boolean).some((value) => regex.test(String(value))));
+  }
+  return rows.filter((row) => [row.displayName, row.name, row.type, row.comment].filter(Boolean).some((value) => String(value).toLowerCase().includes(q)));
+}
+
+export function sortObjectBrowserRows(rows: ObjectBrowserRow[], key: ObjectBrowserSortKey, direction: ObjectBrowserSortDirection): ObjectBrowserRow[] {
+  const multiplier = direction === "asc" ? 1 : -1;
+  const compareNames = createDatabaseObjectNameComparator(rows.map((row) => row.displayName));
+  return [...rows].sort((left, right) => {
+    const compared = key === "name" ? compareNames(left.displayName, right.displayName) : compareObjectBrowserValue(left[key], right[key], key, direction);
+    if (compared !== 0) return compared * multiplier;
+    return compareNames(left.displayName, right.displayName);
+  });
+}
+
+export function initialObjectBrowserSortDirection(key: ObjectBrowserSortKey): ObjectBrowserSortDirection {
+  return key === "created_at" || key === "updated_at" || key === "estimatedRows" || key === "totalBytes" ? "desc" : "asc";
+}
+
+export function formatObjectBrowserTimestamp(value: string | null | undefined): string {
+  const text = value?.trim();
+  if (!text) return "";
+  return text
+    .replace("T", " ")
+    .replace(/\.\d+(?=$|[+-]\d{2}(?::?\d{2})?$)/, "")
+    .replace(/(?:Z|[+-]\d{2}(?::?\d{2})?)$/, "");
+}
+
+export function formatObjectBrowserCount(value: number | null | undefined): string {
+  if (typeof value !== "number" || !Number.isFinite(value)) return "";
+  return new Intl.NumberFormat().format(value);
+}
+
+export function formatObjectBrowserBytes(value: number | null | undefined): string {
+  if (typeof value !== "number" || !Number.isFinite(value)) return "";
+  const units = ["B", "KB", "MB", "GB", "TB", "PB"];
+  let size = Math.max(0, value);
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  const fractionDigits = unitIndex === 0 || size >= 100 ? 0 : size >= 10 ? 1 : 2;
+  return `${size.toFixed(fractionDigits)} ${units[unitIndex]}`;
+}
+
+function compareObjectBrowserValue(left: string | number | null | undefined, right: string | number | null | undefined, key: ObjectBrowserSortKey, direction: ObjectBrowserSortDirection): number {
+  if (key === "estimatedRows" || key === "totalBytes") {
+    return compareObjectBrowserNumber(left, right, direction);
+  }
+  const leftText = normalizeSortValue(left);
+  const rightText = normalizeSortValue(right);
+  if (!leftText && !rightText) return 0;
+  if (!leftText) return direction === "asc" ? 1 : -1;
+  if (!rightText) return direction === "asc" ? -1 : 1;
+  if (key === "created_at" || key === "updated_at") return leftText.localeCompare(rightText);
+  return leftText.localeCompare(rightText, undefined, { numeric: true, sensitivity: "base" });
+}
+
+function compareObjectBrowserNumber(left: string | number | null | undefined, right: string | number | null | undefined, direction: ObjectBrowserSortDirection): number {
+  const leftNumber = normalizeSortNumber(left);
+  const rightNumber = normalizeSortNumber(right);
+  if (leftNumber === null && rightNumber === null) return 0;
+  if (leftNumber === null) return direction === "asc" ? 1 : -1;
+  if (rightNumber === null) return direction === "asc" ? -1 : 1;
+  return leftNumber - rightNumber;
+}
+
+function normalizeSortValue(value: string | number | null | undefined): string {
+  if (typeof value === "number") return String(value);
+  return value?.trim() ?? "";
+}
+
+function normalizeSortNumber(value: string | number | null | undefined): number | null {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string" || !value.trim()) return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
diff --git a/apps/desktop/src/lib/table/objectRenameSql.ts b/apps/desktop/src/lib/table/objectRenameSql.ts
new file mode 100644
index 0000000..be82797
--- /dev/null
+++ b/apps/desktop/src/lib/table/objectRenameSql.ts
@@ -0,0 +1,33 @@
+import type { DatabaseObjectType, DatabaseType } from "@/types/database";
+import * as api from "@/lib/backend/api";
+
+export type RenameableObjectType = DatabaseObjectType;
+
+export interface BuildRenameObjectSqlOptions {
+  databaseType?: DatabaseType;
+  objectType: RenameableObjectType;
+  schema?: string | null;
+  oldName: string;
+  newName: string;
+}
+
+const postgresLikeRenameTypes = new Set<DatabaseType>(["postgres", "redshift", "gaussdb", "kwdb", "kingbase", "highgo", "vastbase"]);
+
+const oracleLikeRenameTypes = new Set<DatabaseType>(["oracle", "dameng"]);
+
+export function supportsObjectRename(databaseType: DatabaseType | undefined, objectType: RenameableObjectType): boolean {
+  if (!databaseType) return false;
+  if (databaseType === "sqlserver") return true;
+  if (objectType === "PROCEDURE" || objectType === "FUNCTION") {
+    return false;
+  }
+  if (databaseType === "sqlite" || databaseType === "rqlite" || databaseType === "turso" || databaseType === "cloudflare-d1") return objectType === "TABLE";
+  if (databaseType === "mysql" || databaseType === "goldendb") return objectType === "TABLE" || objectType === "VIEW";
+  if (postgresLikeRenameTypes.has(databaseType)) return objectType === "TABLE" || objectType === "VIEW" || objectType === "MATERIALIZED_VIEW";
+  if (oracleLikeRenameTypes.has(databaseType)) return objectType === "TABLE" || objectType === "VIEW" || objectType === "MATERIALIZED_VIEW";
+  return false;
+}
+
+export function buildRenameObjectSql(options: BuildRenameObjectSqlOptions): Promise<string> {
+  return api.buildRenameObjectSql(options);
+}
diff --git a/apps/desktop/src/lib/table/objectSourceEditor.ts b/apps/desktop/src/lib/table/objectSourceEditor.ts
new file mode 100644
index 0000000..23397ca
--- /dev/null
+++ b/apps/desktop/src/lib/table/objectSourceEditor.ts
@@ -0,0 +1,66 @@
+import type { DatabaseType, ObjectSourceKind } from "@/types/database";
+import * as api from "@/lib/backend/api";
+
+export type BuildEditableObjectSourceSqlInput = {
+  databaseType: DatabaseType;
+  objectType: ObjectSourceKind;
+  schema?: string | null;
+  name: string;
+  source: string;
+};
+
+export type BuildRoutineRenameObjectSourceInput = BuildEditableObjectSourceSqlInput & {
+  newName: string;
+};
+
+export type ObjectSourceSaveExecutionMode = "single" | "script";
+
+const postgresLikeRoutineRenameTypes = new Set<DatabaseType>(["postgres", "redshift", "gaussdb", "kwdb", "kingbase", "highgo", "vastbase"]);
+const mysqlLikeRoutineRenameTypes = new Set<DatabaseType>(["mysql", "goldendb"]);
+const oracleLikeRoutineRenameTypes = new Set<DatabaseType>(["oracle", "dameng"]);
+
+export function supportsSourceBackedRoutineRename(databaseType: DatabaseType | undefined, objectType: ObjectSourceKind): boolean {
+  if (objectType !== "FUNCTION" && objectType !== "PROCEDURE") return false;
+  if (!databaseType || databaseType === "sqlserver") return false;
+  return mysqlLikeRoutineRenameTypes.has(databaseType) || postgresLikeRoutineRenameTypes.has(databaseType) || oracleLikeRoutineRenameTypes.has(databaseType);
+}
+
+export function buildRoutineRenameObjectSourceStatements(input: BuildRoutineRenameObjectSourceInput): Promise<string[]> {
+  return api.buildRoutineRenameObjectSourceStatements(input);
+}
+
+export function buildExecutableObjectSourceStatements(input: BuildEditableObjectSourceSqlInput): Promise<string[]> {
+  return api.buildExecutableObjectSourceStatements(input);
+}
+
+export async function buildExecutableObjectSourceSql(input: BuildEditableObjectSourceSqlInput): Promise<string> {
+  return api.buildExecutableObjectSourceSql(input);
+}
+
+export function buildEditableObjectSource(input: BuildEditableObjectSourceSqlInput): Promise<string> {
+  return api.buildEditableObjectSource(input);
+}
+
+export function objectSourceSaveExecutionMode(_databaseType: DatabaseType): ObjectSourceSaveExecutionMode {
+  return "single";
+}
+
+export async function executeObjectSourceSave(connectionId: string, database: string, databaseType: DatabaseType, statements: string[], schema?: string): Promise<void> {
+  const nonEmptyStatements = statements.filter((sql) => sql.trim().length > 0);
+  if (nonEmptyStatements.length === 0) return;
+
+  if (databaseType === "informix" && nonEmptyStatements.length > 1) {
+    // Informix/GBase 8s view replacement is validate + drop/create; run it atomically
+    // so a failing final CREATE rolls back the original view instead of deleting it.
+    await api.executeInTransaction(connectionId, database, nonEmptyStatements, schema);
+    return;
+  }
+
+  for (const sql of nonEmptyStatements) {
+    if (objectSourceSaveExecutionMode(databaseType) === "single") {
+      await api.executeQuery(connectionId, database, sql, schema);
+    } else {
+      await api.executeScript(connectionId, database, sql, schema);
+    }
+  }
+}
diff --git a/apps/desktop/src/lib/table/postgresDataTypeHelp.ts b/apps/desktop/src/lib/table/postgresDataTypeHelp.ts
new file mode 100644
index 0000000..d4218c5
--- /dev/null
+++ b/apps/desktop/src/lib/table/postgresDataTypeHelp.ts
@@ -0,0 +1,155 @@
+export type PostgresDataTypeHelpKey =
+  | "smallint"
+  | "integer"
+  | "bigint"
+  | "serial"
+  | "numeric"
+  | "real"
+  | "double"
+  | "money"
+  | "boolean"
+  | "char"
+  | "varchar"
+  | "text"
+  | "bytea"
+  | "date"
+  | "time"
+  | "timetz"
+  | "timestamp"
+  | "timestamptz"
+  | "interval"
+  | "uuid"
+  | "json"
+  | "jsonb"
+  | "xml"
+  | "bit"
+  | "tsvector"
+  | "tsquery"
+  | "cidr"
+  | "inet"
+  | "macaddr"
+  | "geometry"
+  | "range"
+  | "oid"
+  | "array"
+  | "multirange"
+  | "jsonpath"
+  | "pgLsn"
+  | "pgSnapshot";
+
+export interface PostgresDataTypeHelp {
+  key: PostgresDataTypeHelpKey;
+}
+
+const POSTGRES_TYPE_HELP_KEYS: Readonly<Record<string, PostgresDataTypeHelpKey>> = {
+  smallint: "smallint",
+  integer: "integer",
+  bigint: "bigint",
+  smallserial: "serial",
+  serial: "serial",
+  bigserial: "serial",
+  numeric: "numeric",
+  real: "real",
+  "double precision": "double",
+  money: "money",
+  boolean: "boolean",
+  char: "char",
+  varchar: "varchar",
+  text: "text",
+  bytea: "bytea",
+  date: "date",
+  time: "time",
+  timetz: "timetz",
+  timestamp: "timestamp",
+  timestamptz: "timestamptz",
+  interval: "interval",
+  uuid: "uuid",
+  json: "json",
+  jsonb: "jsonb",
+  xml: "xml",
+  bit: "bit",
+  "bit varying": "bit",
+  tsvector: "tsvector",
+  tsquery: "tsquery",
+  cidr: "cidr",
+  inet: "inet",
+  macaddr: "macaddr",
+  macaddr8: "macaddr",
+  point: "geometry",
+  line: "geometry",
+  lseg: "geometry",
+  box: "geometry",
+  path: "geometry",
+  polygon: "geometry",
+  circle: "geometry",
+  int4range: "range",
+  int8range: "range",
+  numrange: "range",
+  tsrange: "range",
+  tstzrange: "range",
+  daterange: "range",
+  oid: "oid",
+  jsonpath: "jsonpath",
+  pg_lsn: "pgLsn",
+  pg_snapshot: "pgSnapshot",
+};
+
+const POSTGRES_TYPE_ALIASES: Readonly<Record<string, string>> = {
+  int2: "smallint",
+  int: "integer",
+  int4: "integer",
+  int8: "bigint",
+  decimal: "numeric",
+  float4: "real",
+  float8: "double precision",
+  bool: "boolean",
+  character: "char",
+  "character varying": "varchar",
+  "time without time zone": "time",
+  "time with time zone": "timetz",
+  "timestamp without time zone": "timestamp",
+  "timestamp with time zone": "timestamptz",
+  varbit: "bit varying",
+};
+
+const POSTGRES_MULTIRANGE_TYPES = new Set(["int4multirange", "int8multirange", "nummultirange", "tsmultirange", "tstzmultirange", "datemultirange"]);
+
+/**
+ * Returns static PostgreSQL type help without querying the server. Extension
+ * types and user-defined types intentionally remain undocumented.
+ */
+export function getPostgresDataTypeHelp(rawType: string): PostgresDataTypeHelp | undefined {
+  const normalized = normalizePostgresType(rawType);
+  if (isPostgresArrayType(normalized)) return { key: "array" };
+
+  const baseType = normalized
+    .replace(/\([^)]*\)/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (baseType === "float") {
+    const key = floatHelpKey(normalized);
+    return key ? { key } : undefined;
+  }
+  if (POSTGRES_MULTIRANGE_TYPES.has(baseType)) return { key: "multirange" };
+
+  const canonicalType = POSTGRES_TYPE_ALIASES[baseType] ?? baseType;
+  const key = POSTGRES_TYPE_HELP_KEYS[canonicalType];
+  return key ? { key } : undefined;
+}
+
+function normalizePostgresType(rawType: string): string {
+  return rawType.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+function isPostgresArrayType(normalizedType: string): boolean {
+  return /(?:\[\s*\]\s*)+$/.test(normalizedType);
+}
+
+function floatHelpKey(normalizedType: string): "real" | "double" | undefined {
+  if (normalizedType === "float") return "double";
+  const precision = normalizedType.match(/^float\(\s*(\d+)\s*\)$/)?.[1];
+  if (!precision) return undefined;
+  const value = Number(precision);
+  if (value >= 1 && value <= 24) return "real";
+  return value >= 25 && value <= 53 ? "double" : undefined;
+}
diff --git a/apps/desktop/src/lib/table/routineExecutionSql.ts b/apps/desktop/src/lib/table/routineExecutionSql.ts
new file mode 100644
index 0000000..a2b2d34
--- /dev/null
+++ b/apps/desktop/src/lib/table/routineExecutionSql.ts
@@ -0,0 +1,121 @@
+import type { DatabaseType } from "@/types/database";
+import { isSchemaAware } from "@/lib/database/databaseCapabilities";
+import { quoteTableIdentifier } from "@/lib/table/tableSelectSql";
+
+export interface BuildRoutineExecutionSqlOptions {
+  databaseType?: DatabaseType;
+  schema?: string;
+  routineName: string;
+}
+
+export type RoutineParameterMode = "IN" | "OUT" | "INOUT" | "RETURN" | "UNKNOWN";
+
+export interface RoutineParameter {
+  name: string;
+  dataType: string;
+  mode: RoutineParameterMode;
+  ordinal: number;
+  hasDefault?: boolean;
+  defaultValue?: string | null;
+}
+
+export interface RoutineParameterValue extends RoutineParameter {
+  value: string;
+  useNull?: boolean;
+  useDefault?: boolean;
+}
+
+export function qualifiedRoutineName(options: BuildRoutineExecutionSqlOptions): string {
+  const { databaseType, schema, routineName } = options;
+  if (databaseType === "databend") return routineName;
+  if (isSchemaAware(databaseType) && schema) {
+    return `${quoteTableIdentifier(databaseType, schema)}.${quoteTableIdentifier(databaseType, routineName)}`;
+  }
+  return quoteTableIdentifier(databaseType, routineName);
+}
+
+export function buildProcedureExecutionSql(options: BuildRoutineExecutionSqlOptions): string {
+  return buildProcedureExecutionSqlFromValues({ ...options, parameters: [] });
+}
+
+export function buildProcedureExecutionSqlFromValues(options: BuildRoutineExecutionSqlOptions & { parameters: RoutineParameterValue[] }): string {
+  const routine = qualifiedRoutineName(options);
+  const sortedParameters = [...options.parameters].sort((a, b) => a.ordinal - b.ordinal);
+  const values = sortedParameters.filter((parameter) => shouldIncludeParameter(parameter));
+  const useNamedArguments = shouldUseNamedArguments(options.databaseType, sortedParameters);
+  if (options.databaseType === "sqlserver") {
+    const args = values.map((parameter) => `${sqlServerParameterName(parameter.name)} = ${routineParameterSqlValue(options.databaseType, parameter)}`).join(", ");
+    return args ? `EXEC ${routine} ${args};` : `EXEC ${routine};`;
+  }
+  if (options.databaseType === "oracle" || options.databaseType === "dameng" || options.databaseType === "oceanbase-oracle") {
+    return `BEGIN\n  ${routine}(${values.map((parameter) => routineArgumentSql(options.databaseType, parameter, useNamedArguments)).join(", ")});\nEND;`;
+  }
+  if (options.databaseType === "databend") {
+    return `CALL PROCEDURE ${routine}(${values.map((parameter) => routineArgumentSql(options.databaseType, parameter, useNamedArguments)).join(", ")});`;
+  }
+  return `CALL ${routine}(${values.map((parameter) => routineArgumentSql(options.databaseType, parameter, useNamedArguments)).join(", ")});`;
+}
+
+export function shouldIncludeParameter(parameter: RoutineParameterValue): boolean {
+  if (parameter.useDefault && parameter.hasDefault) return false;
+  return acceptsRoutineInput(parameter);
+}
+
+export function acceptsRoutineInput(parameter: Pick<RoutineParameterValue, "mode">): boolean {
+  return parameter.mode === "IN" || parameter.mode === "INOUT" || parameter.mode === "UNKNOWN";
+}
+
+export function routineParameterSqlValue(databaseType: DatabaseType | undefined, parameter: RoutineParameterValue): string {
+  if (parameter.useNull) return "NULL";
+  const raw = parameter.value;
+  if (raw.trim() === "") return "NULL";
+  if (looksLikeNumericType(parameter.dataType)) return raw.trim();
+  if (looksLikeBooleanType(parameter.dataType)) return normalizeBooleanLiteral(raw, databaseType);
+  return quoteSqlString(raw);
+}
+
+function sqlServerParameterName(name: string): string {
+  return name.startsWith("@") ? name : `@${name}`;
+}
+
+function routineArgumentSql(databaseType: DatabaseType | undefined, parameter: RoutineParameterValue, useNamedArguments: boolean): string {
+  const value = routineParameterSqlValue(databaseType, parameter);
+  if (!useNamedArguments) return value;
+  return `${quoteTableIdentifier(databaseType, parameter.name)} => ${value}`;
+}
+
+function shouldUseNamedArguments(databaseType: DatabaseType | undefined, sortedParameters: RoutineParameterValue[]): boolean {
+  if (databaseType !== "postgres" && databaseType !== "oracle" && databaseType !== "dameng" && databaseType !== "oceanbase-oracle") {
+    return false;
+  }
+  let omittedDefault = false;
+  for (const parameter of sortedParameters) {
+    if (parameter.useDefault && parameter.hasDefault && acceptsRoutineInput(parameter)) {
+      omittedDefault = true;
+      continue;
+    }
+    if (omittedDefault && shouldIncludeParameter(parameter)) return sortedParameters.every((item) => !!item.name);
+  }
+  return false;
+}
+
+function quoteSqlString(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+
+function looksLikeNumericType(dataType: string): boolean {
+  return /\b(bigint|int|integer|smallint|tinyint|serial|number|numeric|decimal|dec|float|double|real|money)\b/i.test(dataType);
+}
+
+function looksLikeBooleanType(dataType: string): boolean {
+  return /\b(bool|boolean|bit)\b/i.test(dataType);
+}
+
+function normalizeBooleanLiteral(value: string, databaseType: DatabaseType | undefined): string {
+  const normalized = value.trim().toLowerCase();
+  const truthy = normalized === "true" || normalized === "t" || normalized === "yes" || normalized === "y" || normalized === "1";
+  const falsy = normalized === "false" || normalized === "f" || normalized === "no" || normalized === "n" || normalized === "0";
+  if (!truthy && !falsy) return quoteSqlString(value);
+  if (databaseType === "sqlserver") return truthy ? "1" : "0";
+  return truthy ? "TRUE" : "FALSE";
+}
diff --git a/apps/desktop/src/lib/table/routineParameters.ts b/apps/desktop/src/lib/table/routineParameters.ts
new file mode 100644
index 0000000..4776f10
--- /dev/null
+++ b/apps/desktop/src/lib/table/routineParameters.ts
@@ -0,0 +1,205 @@
+import * as api from "@/lib/backend/api";
+import type { DatabaseType, QueryResult } from "@/types/database";
+import type { RoutineParameter, RoutineParameterMode } from "@/lib/table/routineExecutionSql";
+
+export interface LoadRoutineParametersOptions {
+  connectionId: string;
+  database: string;
+  databaseType?: DatabaseType;
+  schema?: string;
+  routineName: string;
+}
+
+export async function loadRoutineParameters(options: LoadRoutineParametersOptions): Promise<RoutineParameter[]> {
+  const sql = routineParametersQuery(options);
+  if (!sql) return [];
+  const result = await api.executeQuery(options.connectionId, options.database, sql, options.schema, undefined, {
+    maxRows: 200,
+    pageSize: 200,
+  });
+  return routineParametersFromResult(result, options.databaseType);
+}
+
+export function supportsRoutineParameterMetadata(databaseType?: DatabaseType): boolean {
+  return databaseType === "postgres" || databaseType === "mysql" || databaseType === "doris" || databaseType === "starrocks" || databaseType === "sqlserver" || databaseType === "oracle" || databaseType === "dameng" || databaseType === "oceanbase-oracle" || databaseType === "databend";
+}
+
+export function routineParametersQuery(options: Pick<LoadRoutineParametersOptions, "database" | "databaseType" | "schema" | "routineName">): string | null {
+  if (!supportsRoutineParameterMetadata(options.databaseType)) return null;
+  const effectiveSchema = options.schema || (options.databaseType === "postgres" ? "public" : "") || (options.databaseType === "mysql" || options.databaseType === "doris" || options.databaseType === "starrocks" ? options.database : "");
+  const schema = quoteSqlLiteral(effectiveSchema);
+  const name = quoteSqlLiteral(options.routineName);
+  if (options.databaseType === "postgres") {
+    return `
+SELECT
+  NULLIF(arg.name, '') AS name,
+  arg.data_type,
+  CASE arg.mode
+    WHEN 'i' THEN 'IN'
+    WHEN 'o' THEN 'OUT'
+    WHEN 'b' THEN 'INOUT'
+    WHEN 'v' THEN 'IN'
+    WHEN 't' THEN 'OUT'
+    ELSE 'IN'
+  END AS mode,
+  arg.ordinal,
+  CASE
+    WHEN COALESCE(arg.mode, 'i') IN ('i', 'b', 'v') AND p.pronargdefaults > 0 AND arg.input_ordinal > p.pronargs - p.pronargdefaults THEN TRUE
+    ELSE FALSE
+  END AS has_default
+FROM pg_proc p
+JOIN pg_namespace n ON n.oid = p.pronamespace
+CROSS JOIN LATERAL (
+  SELECT
+    gs.ordinal AS ordinal,
+    p.proargnames[gs.ordinal] AS name,
+    CASE
+      WHEN p.proallargtypes IS NULL THEN p.proargtypes[gs.ordinal - 1]
+      ELSE p.proallargtypes[gs.ordinal]
+    END::regtype::text AS data_type,
+    COALESCE(p.proargmodes[gs.ordinal], 'i') AS mode,
+    COUNT(*) FILTER (WHERE COALESCE(p.proargmodes[gs.ordinal], 'i') IN ('i', 'b', 'v')) OVER (ORDER BY gs.ordinal) AS input_ordinal
+  FROM generate_series(1, COALESCE(array_length(p.proallargtypes, 1), p.pronargs)) AS gs(ordinal)
+) arg
+WHERE p.prokind = 'p'
+  AND n.nspname = ${schema}
+  AND p.proname = ${name}
+ORDER BY arg.ordinal;`.trim();
+  }
+  if (options.databaseType === "mysql" || options.databaseType === "doris" || options.databaseType === "starrocks") {
+    return `
+SELECT
+  PARAMETER_NAME AS name,
+  DTD_IDENTIFIER AS data_type,
+  COALESCE(PARAMETER_MODE, 'IN') AS mode,
+  ORDINAL_POSITION AS ordinal,
+  FALSE AS has_default
+FROM information_schema.PARAMETERS
+WHERE SPECIFIC_SCHEMA = ${schema}
+  AND SPECIFIC_NAME = ${name}
+  AND ORDINAL_POSITION > 0
+ORDER BY ORDINAL_POSITION;`.trim();
+  }
+  if (options.databaseType === "databend") {
+    return `
+SELECT arguments
+FROM system.procedures
+WHERE name = ${name}
+ORDER BY procedure_id
+LIMIT 1;`.trim();
+  }
+  if (options.databaseType === "sqlserver") {
+    return `
+SELECT
+  p.name AS name,
+  TYPE_NAME(p.user_type_id) AS data_type,
+  CASE WHEN p.is_output = 1 THEN 'OUT' ELSE 'IN' END AS mode,
+  p.parameter_id AS ordinal,
+  p.has_default_value AS has_default
+FROM sys.parameters p
+JOIN sys.objects o ON o.object_id = p.object_id
+JOIN sys.schemas s ON s.schema_id = o.schema_id
+WHERE o.type IN ('P', 'PC')
+  AND s.name = ${schema}
+  AND o.name = ${name}
+ORDER BY p.parameter_id;`.trim();
+  }
+  if (options.databaseType === "oracle" || options.databaseType === "dameng" || options.databaseType === "oceanbase-oracle") {
+    return `
+SELECT
+  ARGUMENT_NAME AS name,
+  DATA_TYPE AS data_type,
+  IN_OUT AS mode,
+  POSITION AS ordinal,
+  DEFAULTED AS has_default
+FROM ALL_ARGUMENTS
+WHERE OWNER = UPPER(${schema})
+  AND OBJECT_NAME = UPPER(${name})
+  AND POSITION > 0
+ORDER BY SEQUENCE;`.trim();
+  }
+  return null;
+}
+
+export function routineParametersFromResult(result: QueryResult, databaseType?: DatabaseType): RoutineParameter[] {
+  if (databaseType === "databend") return databendRoutineParametersFromResult(result);
+  return result.rows
+    .map((row, index) => ({
+      name: String(row[0] || `arg${index + 1}`),
+      dataType: String(row[1] || ""),
+      mode: normalizeParameterMode(row[2]),
+      ordinal: Number(row[3] || index + 1),
+      hasDefault: normalizeBoolean(row[4]),
+    }))
+    .filter((parameter) => parameter.mode !== "RETURN");
+}
+
+function databendRoutineParametersFromResult(result: QueryResult): RoutineParameter[] {
+  const argumentsIndex = result.columns.findIndex((column) => column.toLowerCase() === "arguments");
+  const signature = String(result.rows[0]?.[argumentsIndex >= 0 ? argumentsIndex : 0] || "");
+  const inputTypes = databendInputTypesFromArguments(signature);
+  return inputTypes.map((dataType, index) => ({
+    name: `arg${index + 1}`,
+    dataType,
+    mode: "IN",
+    ordinal: index + 1,
+    hasDefault: false,
+  }));
+}
+
+function databendInputTypesFromArguments(signature: string): string[] {
+  const openIndex = signature.indexOf("(");
+  if (openIndex < 0) return [];
+  let depth = 0;
+  for (let index = openIndex; index < signature.length; index += 1) {
+    const char = signature[index];
+    if (char === "(") depth += 1;
+    if (char === ")") {
+      depth -= 1;
+      if (depth === 0) {
+        return splitTopLevelComma(signature.slice(openIndex + 1, index)).filter(Boolean);
+      }
+    }
+  }
+  return [];
+}
+
+function splitTopLevelComma(value: string): string[] {
+  const parts: string[] = [];
+  let current = "";
+  let depth = 0;
+  for (const char of value) {
+    if (char === "(") depth += 1;
+    if (char === ")") depth = Math.max(0, depth - 1);
+    if (char === "," && depth === 0) {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts;
+}
+
+function normalizeParameterMode(value: unknown): RoutineParameterMode {
+  const mode = String(value || "IN")
+    .toUpperCase()
+    .replace(/\s+/g, "");
+  if (mode === "IN") return "IN";
+  if (mode === "OUT") return "OUT";
+  if (mode === "INOUT" || mode === "IN/OUT") return "INOUT";
+  if (mode === "RETURN") return "RETURN";
+  return "UNKNOWN";
+}
+
+function normalizeBoolean(value: unknown): boolean {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  const text = String(value || "").toLowerCase();
+  return text === "true" || text === "yes" || text === "y" || text === "1";
+}
+
+function quoteSqlLiteral(value: string): string {
+  return `'${value.replace(/'/g, "''")}'`;
+}
diff --git a/apps/desktop/src/lib/table/sidePanelRequestGuard.ts b/apps/desktop/src/lib/table/sidePanelRequestGuard.ts
new file mode 100644
index 0000000..eaba340
--- /dev/null
+++ b/apps/desktop/src/lib/table/sidePanelRequestGuard.ts
@@ -0,0 +1,33 @@
+/**
+ * Side panel async request guard.
+ *
+ * Prevents stale async results (from a previous object or database context)
+ * from overwriting the current panel state. Each context change bumps the
+ * epoch; in-flight requests capture the epoch at start and compare before
+ * writing results.
+ */
+export interface SidePanelRequestGuard {
+  /** Bump the epoch, invalidating all previously captured epochs. */
+  bump: () => void;
+  /** Start a new request context and return its epoch. */
+  start: () => number;
+  /** Capture the current epoch for later staleness comparison. */
+  capture: () => number;
+  /** Returns true if the captured epoch is no longer current (request is stale). */
+  isStale: (capturedEpoch: number) => boolean;
+  /** Returns true if the captured epoch is still current (request is fresh). */
+  isFresh: (capturedEpoch: number) => boolean;
+}
+
+export function createSidePanelRequestGuard(): SidePanelRequestGuard {
+  let epoch = 0;
+  return {
+    bump: () => {
+      epoch++;
+    },
+    start: () => ++epoch,
+    capture: () => epoch,
+    isStale: (capturedEpoch: number) => capturedEpoch !== epoch,
+    isFresh: (capturedEpoch: number) => capturedEpoch === epoch,
+  };
+}
diff --git a/apps/desktop/src/lib/table/sqliteDataTypeHelp.ts b/apps/desktop/src/lib/table/sqliteDataTypeHelp.ts
new file mode 100644
index 0000000..63d74fb
--- /dev/null
+++ b/apps/desktop/src/lib/table/sqliteDataTypeHelp.ts
@@ -0,0 +1,24 @@
+export type SqliteDataTypeHelpKey = "integer" | "real" | "text" | "blob" | "numeric";
+
+export interface SqliteDataTypeHelp {
+  key: SqliteDataTypeHelpKey;
+}
+
+/**
+ * Maps declared types using SQLite's ordered affinity rules. The order matters:
+ * for example, FLOATING POINT has INTEGER affinity because it contains "INT".
+ */
+export function getSqliteDataTypeHelp(rawType: string): SqliteDataTypeHelp | undefined {
+  const normalized = rawType
+    .trim()
+    .toLowerCase()
+    .replace(/\([^)]*\)/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (!normalized) return { key: "blob" };
+  if (normalized.includes("int")) return { key: "integer" };
+  if (normalized.includes("char") || normalized.includes("clob") || normalized.includes("text")) return { key: "text" };
+  if (normalized.includes("blob")) return { key: "blob" };
+  if (normalized.includes("real") || normalized.includes("floa") || normalized.includes("doub")) return { key: "real" };
+  return { key: "numeric" };
+}
diff --git a/apps/desktop/src/lib/table/tableClipboard.ts b/apps/desktop/src/lib/table/tableClipboard.ts
new file mode 100644
index 0000000..d86eb32
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableClipboard.ts
@@ -0,0 +1,66 @@
+import type { ColumnInfo, DatabaseType } from "@/types/database";
+
+export type PasteTableMode = "structure-and-data" | "structure-only" | "data-only";
+
+export interface TableClipboardContext {
+  connectionId: string;
+  database: string;
+  schema?: string | null;
+}
+
+export interface TableDataCopyColumnOptions {
+  columns: string[];
+  postgresOverridingSystemValue: boolean;
+  sqlserverIdentityInsert: boolean;
+}
+
+function normalizeSchema(schema: string | null | undefined): string {
+  return schema?.trim() ?? "";
+}
+
+export function tableClipboardEntryMatchesTarget(entry: TableClipboardContext, target: TableClipboardContext): boolean {
+  return entry.connectionId === target.connectionId && entry.database === target.database && normalizeSchema(entry.schema) === normalizeSchema(target.schema);
+}
+
+export function tableClipboardMatchesTarget(entries: TableClipboardContext[], target: TableClipboardContext | null): boolean {
+  return !!target && entries.length > 0 && entries.every((entry) => tableClipboardEntryMatchesTarget(entry, target));
+}
+
+export function supportsWholeRowTableDataCopy(databaseType: DatabaseType | undefined): boolean {
+  return !!databaseType;
+}
+
+export function defaultPasteTableMode(databaseType: DatabaseType | undefined): PasteTableMode {
+  return supportsWholeRowTableDataCopy(databaseType) ? "structure-and-data" : "structure-only";
+}
+
+export function pasteTableModeCopiesData(mode: PasteTableMode): boolean {
+  return mode === "structure-and-data" || mode === "data-only";
+}
+
+export function tableDataCopyColumnOptions(databaseType: DatabaseType | undefined, columns: ColumnInfo[]): TableDataCopyColumnOptions {
+  const writableColumns = columns.filter((column) => isWritableTableDataCopyColumn(databaseType, column));
+  return {
+    columns: writableColumns.map((column) => column.name),
+    postgresOverridingSystemValue: databaseType === "postgres" && writableColumns.some(isIdentityColumn),
+    sqlserverIdentityInsert: databaseType === "sqlserver" && writableColumns.some(isIdentityColumn),
+  };
+}
+
+function isWritableTableDataCopyColumn(databaseType: DatabaseType | undefined, column: ColumnInfo): boolean {
+  const extra = (column.extra ?? "").toLowerCase();
+  if (databaseType === "mysql") {
+    return !extra.includes("generated");
+  }
+  if (databaseType === "postgres") {
+    return !extra.includes("generated always as (");
+  }
+  if (databaseType === "sqlserver") {
+    return !extra.includes("computed");
+  }
+  return !extra.includes("computed") && !(extra.includes("generated") && !extra.includes("identity"));
+}
+
+function isIdentityColumn(column: ColumnInfo): boolean {
+  return (column.extra ?? "").toLowerCase().includes("identity");
+}
diff --git a/apps/desktop/src/lib/table/tableColumnTemplates.ts b/apps/desktop/src/lib/table/tableColumnTemplates.ts
new file mode 100644
index 0000000..3ab4ea2
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableColumnTemplates.ts
@@ -0,0 +1,133 @@
+import type { DatabaseType } from "@/types/database";
+import type { EditableStructureColumn } from "@/lib/table/tableStructureEditorSql";
+import { manifestDatabaseTypes } from "@/lib/database/databaseDriverManifest";
+import { getTableStructureCapabilities } from "@/lib/table/tableStructureCapabilities";
+
+export interface TableColumnTemplate {
+  id: string;
+  labelKey: string;
+  columnNames: string[];
+}
+
+export interface TableColumnTemplateField {
+  name: string;
+  dataTypesByDatabase: Partial<Record<DatabaseType, string>>;
+  defaultValue?: string;
+  isNullable?: boolean;
+  comment?: string;
+}
+
+export const PRESET_FIELDS_TEMPLATE_ID = "preset-fields";
+export const EMPTY_TABLE_COLUMN_TEMPLATE_DATA_TYPE = "<empty>";
+export const TABLE_COLUMN_TEMPLATE_DATABASE_TYPES: DatabaseType[] = manifestDatabaseTypes().filter(isTableColumnTemplateDatabaseType);
+export const DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS: string[] = [];
+
+export function normalizeTableColumnTemplateFields(value: unknown): string[] {
+  if (!Array.isArray(value)) return [...DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS];
+  const fields: string[] = [];
+  const seen = new Set<string>();
+  for (const item of value) {
+    if (typeof item !== "string") continue;
+    const field = item.trim();
+    const name = field.split("|")[0]?.trim();
+    if (!field || !name || seen.has(name.toLowerCase())) continue;
+    seen.add(name.toLowerCase());
+    fields.push(field);
+  }
+  return fields;
+}
+
+export function parseTableColumnTemplateFields(value: unknown): TableColumnTemplateField[] {
+  return normalizeTableColumnTemplateFields(value).map(parseTableColumnTemplateField);
+}
+
+export function tableColumnTemplates(columnNames: readonly string[] = DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS): TableColumnTemplate[] {
+  const fields = parseTableColumnTemplateFields([...columnNames]);
+  return [
+    {
+      id: PRESET_FIELDS_TEMPLATE_ID,
+      labelKey: "structureEditor.presetFieldsTemplate",
+      columnNames: fields.map((field) => field.name),
+    },
+  ];
+}
+
+export function createTableColumnTemplateDrafts(options: { templateId: string; databaseType?: DatabaseType; columnNames?: readonly string[]; existingColumnNames?: Iterable<string>; createId: () => string }): EditableStructureColumn[] {
+  if (options.templateId !== PRESET_FIELDS_TEMPLATE_ID) return [];
+  const existingNames = new Set([...(options.existingColumnNames ?? [])].map((name) => name.toLowerCase()));
+  return presetFieldColumns(options.databaseType, parseTableColumnTemplateFields([...(options.columnNames ?? DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS)]), options.createId).filter((column) => !existingNames.has(column.name.toLowerCase()));
+}
+
+function presetFieldColumns(databaseType: DatabaseType | undefined, fields: readonly TableColumnTemplateField[], createId: () => string): EditableStructureColumn[] {
+  return fields
+    .filter((field) => isTableColumnTemplateFieldApplicable(field, databaseType))
+    .map((field) => {
+      return templateColumn(createId, field.name, configuredFieldDataType(field, databaseType) ?? "", field.isNullable ?? false, field.defaultValue ?? "", field.comment ?? "");
+    });
+}
+
+function templateColumn(createId: () => string, name: string, dataType: string, isNullable: boolean, defaultValue = "", comment = ""): EditableStructureColumn {
+  return {
+    id: `new:${createId()}`,
+    name,
+    dataType,
+    enumValues: [],
+    isNullable,
+    defaultValue,
+    comment,
+    isPrimaryKey: false,
+    characterSet: "",
+    collation: "",
+    extra: {},
+    markedForDrop: false,
+  };
+}
+
+function parseTableColumnTemplateField(value: string): TableColumnTemplateField {
+  const [rawName = "", ...rawParts] = value.split("|").map((part) => part.trim());
+  const field: TableColumnTemplateField = { name: rawName, dataTypesByDatabase: {} };
+  for (const part of rawParts) {
+    const separator = part.indexOf(":");
+    if (separator <= 0) continue;
+    const key = part.slice(0, separator).trim().toLowerCase();
+    const dataType = part.slice(separator + 1).trim();
+    if (!dataType) continue;
+    if (key === "nullable") {
+      field.isNullable = parseBooleanConfigValue(dataType);
+    } else if (key === "required") {
+      const required = parseBooleanConfigValue(dataType);
+      field.isNullable = required === undefined ? undefined : !required;
+    } else if (key === "default" || key === "defaultvalue" || key === "default_value") {
+      field.defaultValue = dataType;
+    } else if (key === "comment" || key === "description") {
+      field.comment = dataType;
+    } else if (isDatabaseTypeKey(key)) {
+      field.dataTypesByDatabase[key] = dataType;
+    }
+  }
+  return field;
+}
+
+function parseBooleanConfigValue(value: string): boolean | undefined {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "yes" || normalized === "1") return true;
+  if (normalized === "false" || normalized === "no" || normalized === "0") return false;
+  return undefined;
+}
+
+function configuredFieldDataType(field: TableColumnTemplateField, databaseType: DatabaseType | undefined): string | undefined {
+  const configuredDataType = databaseType ? field.dataTypesByDatabase[databaseType] : undefined;
+  return configuredDataType && configuredDataType !== EMPTY_TABLE_COLUMN_TEMPLATE_DATA_TYPE ? configuredDataType : undefined;
+}
+
+function isTableColumnTemplateFieldApplicable(field: TableColumnTemplateField, databaseType: DatabaseType | undefined): boolean {
+  return !!databaseType && Object.prototype.hasOwnProperty.call(field.dataTypesByDatabase, databaseType);
+}
+
+function isTableColumnTemplateDatabaseType(databaseType: DatabaseType): boolean {
+  return databaseType !== "manticoresearch" && getTableStructureCapabilities(databaseType).createTable;
+}
+
+function isDatabaseTypeKey(value: string): value is DatabaseType {
+  return TABLE_COLUMN_TEMPLATE_DATABASE_TYPES.includes(value as DatabaseType);
+}
diff --git a/apps/desktop/src/lib/table/tableDataExport.ts b/apps/desktop/src/lib/table/tableDataExport.ts
new file mode 100644
index 0000000..0661906
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableDataExport.ts
@@ -0,0 +1,53 @@
+import type { DatabaseType, QueryResult } from "@/types/database.ts";
+import { buildTableSelectSql } from "@/lib/table/tableSelectSql.ts";
+
+export const TABLE_DATA_EXPORT_PAGE_SIZE = 10_000;
+
+export interface FetchTableDataForExportOptions {
+  databaseType?: DatabaseType;
+  schema?: string;
+  tableName: string;
+  tableType?: string;
+  columns?: string[];
+  pageSize?: number;
+  buildPageSql?: (options: { databaseType?: DatabaseType; schema?: string; tableName: string; tableType?: string; columns?: string[]; limit: number; offset: number }) => Promise<string> | string;
+  executePage: (sql: string) => Promise<QueryResult>;
+}
+
+export async function fetchTableDataForExport(options: FetchTableDataForExportOptions): Promise<QueryResult> {
+  const pageSize = Math.max(1, options.pageSize ?? TABLE_DATA_EXPORT_PAGE_SIZE);
+  let offset = 0;
+  const rows: QueryResult["rows"] = [];
+  let columns: string[] = [];
+  let executionTimeMs = 0;
+
+  while (true) {
+    const sql = await (options.buildPageSql ?? buildTableSelectSql)({
+      databaseType: options.databaseType,
+      schema: options.schema,
+      tableName: options.tableName,
+      tableType: options.tableType,
+      columns: options.columns,
+      limit: pageSize,
+      offset,
+    });
+    const result = await options.executePage(sql);
+    if (columns.length === 0) columns = result.columns;
+    rows.push(...result.rows);
+    executionTimeMs += result.execution_time_ms ?? 0;
+
+    if (result.rows.length < pageSize) {
+      return {
+        columns,
+        rows,
+        affected_rows: 0,
+        execution_time_ms: executionTimeMs,
+        truncated: false,
+        session_id: undefined,
+        has_more: false,
+      };
+    }
+
+    offset += result.rows.length;
+  }
+}
diff --git a/apps/desktop/src/lib/table/tableDataRefresh.ts b/apps/desktop/src/lib/table/tableDataRefresh.ts
new file mode 100644
index 0000000..67ee7d7
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableDataRefresh.ts
@@ -0,0 +1,7 @@
+import type { QueryTab } from "@/types/database";
+
+type RefreshableDataTab = Pick<QueryTab, "mode" | "result" | "isExecuting">;
+
+export function canReloadUnavailableDataTab(tab: RefreshableDataTab): boolean {
+  return tab.mode === "data" && !tab.result && !tab.isExecuting;
+}
diff --git a/apps/desktop/src/lib/table/tableDataTabMeta.ts b/apps/desktop/src/lib/table/tableDataTabMeta.ts
new file mode 100644
index 0000000..b9e44cc
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableDataTabMeta.ts
@@ -0,0 +1,28 @@
+import type { QueryTab, ColumnInfo } from "@/types/database";
+
+export type DataTabTableMeta = NonNullable<QueryTab["tableMeta"]>;
+
+function fallbackColumnInfo(name: string): ColumnInfo {
+  return {
+    name,
+    data_type: "",
+    is_nullable: true,
+    column_default: null,
+    is_primary_key: false,
+    extra: null,
+  };
+}
+
+export function tableMetaForDataTab(tab: QueryTab | undefined): DataTabTableMeta | undefined {
+  if (!tab || tab.mode !== "data") return undefined;
+  if (tab.tableMeta) return tab.tableMeta;
+  const tableName = tab.title.trim();
+  if (!tableName) return undefined;
+
+  return {
+    schema: tab.schema,
+    tableName,
+    columns: (tab.result?.columns ?? []).map(fallbackColumnInfo),
+    primaryKeys: [],
+  };
+}
diff --git a/apps/desktop/src/lib/table/tableDependencySort.ts b/apps/desktop/src/lib/table/tableDependencySort.ts
new file mode 100644
index 0000000..39333e4
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableDependencySort.ts
@@ -0,0 +1,73 @@
+import type { ForeignKeyInfo } from "@/types/database";
+
+export interface TableWithFk {
+  name: string;
+  schema?: string | null;
+  foreignKeys: ForeignKeyInfo[];
+}
+
+/**
+ * Sort tables by foreign key dependency so that referencing tables
+ * (those with an FK pointing to another table in the list) come before
+ * the tables they reference.
+ *
+ * Uses Kahn's algorithm for topological sort. Falls back to original
+ * order when a cycle is detected.
+ */
+export function sortTablesByFkDependency(tables: TableWithFk[]): TableWithFk[] {
+  if (tables.length <= 1) return tables;
+
+  const nameSet = new Set(tables.map((t) => t.name));
+  const adjacency = new Map<string, string[]>();
+  const inDegree = new Map<string, number>();
+
+  for (const table of tables) {
+    if (!adjacency.has(table.name)) adjacency.set(table.name, []);
+    if (!inDegree.has(table.name)) inDegree.set(table.name, 0);
+  }
+
+  // Build dependency graph: an edge A → B means A references B,
+  // so A should be dropped before B.
+  for (const table of tables) {
+    for (const fk of table.foreignKeys) {
+      if (nameSet.has(fk.ref_table)) {
+        // A → B: A depends on B, drop A first
+        adjacency.get(table.name)!.push(fk.ref_table);
+        inDegree.set(fk.ref_table, (inDegree.get(fk.ref_table) ?? 0) + 1);
+      }
+    }
+  }
+
+  // Kahn topological sort
+  const queue: string[] = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0) queue.push(name);
+  }
+
+  const sortedNames: string[] = [];
+  while (queue.length > 0) {
+    // Sort queue for deterministic output; preserves original order
+    // among nodes with equal in-degree.
+    queue.sort((a, b) => {
+      const ia = tables.findIndex((t) => t.name === a);
+      const ib = tables.findIndex((t) => t.name === b);
+      return ia - ib;
+    });
+    const current = queue.shift()!;
+    sortedNames.push(current);
+
+    for (const neighbor of adjacency.get(current) ?? []) {
+      const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+      inDegree.set(neighbor, newDegree);
+      if (newDegree === 0) queue.push(neighbor);
+    }
+  }
+
+  // If not all nodes sorted, cycle detected — fall back to original order
+  if (sortedNames.length !== tables.length) {
+    return tables;
+  }
+
+  const nameToTable = new Map(tables.map((t) => [t.name, t]));
+  return sortedNames.map((name) => nameToTable.get(name)!);
+}
diff --git a/apps/desktop/src/lib/table/tableEditing.ts b/apps/desktop/src/lib/table/tableEditing.ts
new file mode 100644
index 0000000..46529b7
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableEditing.ts
@@ -0,0 +1,114 @@
+import type { ColumnInfo, DatabaseType, IndexInfo } from "@/types/database";
+import { getDatabaseCapability } from "@/lib/database/databaseCapabilities";
+
+export const DBX_ROWID_COLUMN = "__DBX_ROWID";
+export const DBX_NEO4J_ELEMENT_ID_COLUMN = "__DBX_ELEMENT_ID";
+export const DBX_TDENGINE_TBNAME_COLUMN = "tbname";
+
+function isViewTableType(tableType?: string): boolean {
+  return tableType?.toUpperCase().includes("VIEW") === true;
+}
+
+function isTdengineStableTableType(tableType?: string): boolean {
+  const normalized = tableType?.trim().toUpperCase();
+  return normalized === "STABLE" || normalized === "SUPER TABLE" || normalized === "SUPERTABLE";
+}
+
+export function editablePrimaryKeys(databaseType: DatabaseType | undefined, columns: ColumnInfo[], tableType?: string): string[] {
+  const primaryKeys = columns.filter((column) => column.is_primary_key).map((column) => column.name);
+  if (isViewTableType(tableType)) return primaryKeys;
+  if (databaseType === "tdengine" && primaryKeys.length > 0 && isTdengineStableTableType(tableType)) return [DBX_TDENGINE_TBNAME_COLUMN, ...primaryKeys];
+  const syntheticKey = getDatabaseCapability(databaseType).syntheticKey;
+  if (syntheticKey === "oracle-rowid" && primaryKeys.length === 0) return [DBX_ROWID_COLUMN];
+  if (syntheticKey === "neo4j-element-id" && primaryKeys.length === 0) return [DBX_NEO4J_ELEMENT_ID_COLUMN];
+  return primaryKeys;
+}
+
+export function editableRowIdentifierColumns(databaseType: DatabaseType | undefined, columns: ColumnInfo[], indexes?: IndexInfo[], tableType?: string): string[] {
+  const primaryKeys = editablePrimaryKeys(databaseType, columns, tableType);
+  if (primaryKeys.length > 0) return primaryKeys;
+  const uniqueIndex = indexes?.filter((index) => !index.filter && index.columns.length > 0 && (index.is_primary || index.is_unique)).sort((left, right) => Number(right.is_primary) - Number(left.is_primary) || left.columns.length - right.columns.length)[0];
+  return uniqueIndex?.columns ?? [];
+}
+
+export function isTableDataEditable(databaseType: DatabaseType | undefined, primaryKeys: string[], tableType?: string): boolean {
+  if (isViewTableType(tableType)) return false;
+  const cap = getDatabaseCapability(databaseType).tableData;
+  if (cap.readonly) return false;
+  if (cap.insert) return true;
+  return primaryKeys.length > 0;
+}
+
+export function canInsertTableRows(databaseType: DatabaseType | undefined): boolean {
+  return getDatabaseCapability(databaseType).tableData.insert;
+}
+
+export function supportsDataGridTransaction(databaseType: DatabaseType | undefined): boolean {
+  return getDatabaseCapability(databaseType).tableData.transaction;
+}
+
+export function usesKeylessRowPredicate(databaseType: DatabaseType | undefined): boolean {
+  return !!getDatabaseCapability(databaseType).tableData.keylessRowPredicate;
+}
+
+export function canUseKeylessRowPredicate(databaseType: DatabaseType | undefined, primaryKeys: readonly string[]): boolean {
+  return primaryKeys.length === 0 && usesKeylessRowPredicate(databaseType);
+}
+
+export function canEditExistingTableRows(databaseType: DatabaseType | undefined, hiveTableTransactional?: boolean, primaryKeys?: string[]): boolean {
+  const tableData = getDatabaseCapability(databaseType).tableData;
+  if (tableData.readonly) return false;
+  if (tableData.existingRowsReadonly) return false;
+  if (tableData.requiresTransactionalTableForExistingRows && hiveTableTransactional !== true) return false;
+  if (tableData.updateRequiresPrimaryKey && primaryKeys && primaryKeys.length === 0) return false;
+  return true;
+}
+
+export function hasCompleteTdengineRowIdentity(databaseType: DatabaseType | undefined, primaryKeys: readonly string[], resultColumns: readonly (string | undefined)[]): boolean {
+  if (databaseType !== "tdengine") return true;
+  if (primaryKeys.length === 0) return false;
+  const availableColumns = new Set(resultColumns.filter((column): column is string => !!column).map((column) => column.toLowerCase()));
+  return primaryKeys.every((primaryKey) => availableColumns.has(primaryKey.toLowerCase()));
+}
+
+export function canDeleteExistingTdengineRows(databaseType: DatabaseType | undefined, primaryKeys: readonly string[]): boolean {
+  if (databaseType !== "tdengine") return true;
+  const rowPrimaryKeys = primaryKeys.filter((primaryKey) => primaryKey.toLowerCase() !== DBX_TDENGINE_TBNAME_COLUMN);
+  return rowPrimaryKeys.length <= 1;
+}
+
+export function hiveTablePropertiesIndicateTransactional(result: { rows: readonly (readonly unknown[])[] }): boolean {
+  return result.rows.some((row) => {
+    const name = String(row[0] ?? "")
+      .trim()
+      .toLowerCase();
+    const value = String(row[1] ?? "")
+      .trim()
+      .toLowerCase();
+    return name === "transactional" && value === "true";
+  });
+}
+
+export function usesSyntheticRowIdKey(databaseType: DatabaseType | undefined, primaryKeys: string[], tableType?: string): boolean {
+  if (isViewTableType(tableType)) return false;
+  return primaryKeys.length === 1 && ((databaseType === "oracle" && primaryKeys[0].toUpperCase() === DBX_ROWID_COLUMN) || (databaseType === "neo4j" && primaryKeys[0] === DBX_NEO4J_ELEMENT_ID_COLUMN));
+}
+
+export function isHiddenGridColumn(databaseType: DatabaseType | undefined, column: string, primaryKeys: string[], tableType?: string): boolean {
+  if (databaseType === "neo4j" && column === DBX_NEO4J_ELEMENT_ID_COLUMN) return true;
+  return usesSyntheticRowIdKey(databaseType, primaryKeys, tableType) && column.toUpperCase() === DBX_ROWID_COLUMN;
+}
+
+export function isTdengineExistingRowReadonlyColumn(databaseType: DatabaseType | undefined, column: string, columns: ColumnInfo[]): boolean {
+  if (databaseType !== "tdengine") return false;
+  if (column.toLowerCase() === DBX_TDENGINE_TBNAME_COLUMN) return true;
+  const columnInfo = columns.find((info) => info.name.toLowerCase() === column.toLowerCase());
+  return !!columnInfo?.is_primary_key || /\btag\b/i.test(columnInfo?.extra ?? "");
+}
+
+export function isClickHouseExistingRowReadonlyColumn(databaseType: DatabaseType | undefined, column: string, primaryKeys: readonly string[], columns: ColumnInfo[] = []): boolean {
+  if (databaseType !== "clickhouse") return false;
+  if (primaryKeys.some((key) => key.toLowerCase() === column.toLowerCase())) return true;
+  const columnInfo = columns.find((info) => info.name.toLowerCase() === column.toLowerCase());
+  return /\bpartition_key\b/i.test(columnInfo?.extra ?? "");
+}
diff --git a/apps/desktop/src/lib/table/tableImport.ts b/apps/desktop/src/lib/table/tableImport.ts
new file mode 100644
index 0000000..96586bd
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableImport.ts
@@ -0,0 +1,195 @@
+import type { DatabaseType } from "@/types/database";
+
+export const IMPORT_SKIP_TARGET = "";
+
+export interface ImportColumnMappingLike {
+  sourceColumn: string;
+  targetColumn: string;
+  targetDataType?: string | null;
+}
+
+export interface ImportMappingValidationResult {
+  valid: boolean;
+  errors: string[];
+  duplicateTargets: string[];
+}
+
+export interface ImportTargetColumnLike {
+  name: string;
+  is_nullable?: boolean;
+  column_default?: string | null;
+  extra?: string | null;
+  is_primary_key?: boolean;
+}
+
+export type TableImportWizardStep = "source" | "options" | "mapping" | "review" | "execution";
+
+export const TABLE_IMPORT_WIZARD_STEPS: TableImportWizardStep[] = ["source", "options", "mapping", "review", "execution"];
+
+export function normalizeImportColumnName(name: string): string {
+  return name.trim().toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ");
+}
+
+export function autoMapImportColumns(sourceColumns: string[], targetColumns: string[]): Record<string, string> {
+  const exactTargets = new Map(targetColumns.map((column) => [column, column]));
+  const normalizedTargets = new Map(targetColumns.map((column) => [normalizeImportColumnName(column), column]));
+
+  return Object.fromEntries(sourceColumns.map((source) => [source, exactTargets.get(source) ?? normalizedTargets.get(normalizeImportColumnName(source)) ?? IMPORT_SKIP_TARGET]));
+}
+
+export function validateImportMappings(mappings: ImportColumnMappingLike[]): ImportMappingValidationResult {
+  const activeMappings = mappings.filter((mapping) => mapping.targetColumn.trim());
+  const errors: string[] = [];
+  const duplicateTargets: string[] = [];
+  if (activeMappings.length === 0) {
+    errors.push("No columns mapped for import");
+  }
+
+  const seen = new Set<string>();
+  for (const mapping of activeMappings) {
+    const key = mapping.targetColumn.trim().toLowerCase();
+    if (seen.has(key) && !duplicateTargets.includes(mapping.targetColumn)) {
+      duplicateTargets.push(mapping.targetColumn);
+    }
+    seen.add(key);
+    if (Object.prototype.hasOwnProperty.call(mapping, "targetDataType") && !String(mapping.targetDataType || "").trim()) {
+      errors.push(`Target data type cannot be empty: ${mapping.targetColumn}`);
+    }
+  }
+  if (duplicateTargets.length) {
+    errors.push(`Target column mapped more than once: ${duplicateTargets.join(", ")}`);
+  }
+
+  return { valid: errors.length === 0, errors, duplicateTargets };
+}
+
+export function requiredImportTargetColumns(columns: ImportTargetColumnLike[], mappedTargetColumns: string[]): string[] {
+  const mapped = new Set(mappedTargetColumns.map((column) => column.toLowerCase()));
+  return columns
+    .filter((column) => !mapped.has(column.name.toLowerCase()))
+    .filter(
+      (column) =>
+        column.is_nullable === false &&
+        !column.column_default &&
+        !String(column.extra || "")
+          .toLowerCase()
+          .includes("auto"),
+    )
+    .map((column) => column.name);
+}
+
+export function nextTableImportWizardStep(step: TableImportWizardStep): TableImportWizardStep {
+  const index = TABLE_IMPORT_WIZARD_STEPS.indexOf(step);
+  return TABLE_IMPORT_WIZARD_STEPS[Math.min(TABLE_IMPORT_WIZARD_STEPS.length - 1, Math.max(0, index) + 1)];
+}
+
+export function previousTableImportWizardStep(step: TableImportWizardStep): TableImportWizardStep {
+  const index = TABLE_IMPORT_WIZARD_STEPS.indexOf(step);
+  return TABLE_IMPORT_WIZARD_STEPS[Math.max(0, index - 1)];
+}
+
+type ImportInferredType = "boolean" | "integer" | "decimal" | "date" | "timestamp" | "json" | "text";
+
+function hasNumericLeadingZero(value: string): boolean {
+  const unsigned = value.trim().replace(/^[+-]/, "");
+  return unsigned.length > 1 && unsigned[0] === "0" && /\d/.test(unsigned[1] || "");
+}
+
+function isLikelyDate(value: string): boolean {
+  return /^\d{4}[-/]\d{2}[-/]\d{2}$/.test(value.trim());
+}
+
+function isLikelyTimestamp(value: string): boolean {
+  const trimmed = value.trim();
+  return /^\d{4}[-/]\d{2}[-/]\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(trimmed) || /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(trimmed);
+}
+
+function inferStringType(value: string): ImportInferredType {
+  const trimmed = value.trim();
+  if (!trimmed) return "text";
+  if (isLikelyTimestamp(trimmed)) return "timestamp";
+  if (isLikelyDate(trimmed)) return "date";
+  if (!hasNumericLeadingZero(trimmed)) {
+    if (/^[+-]?\d+$/.test(trimmed)) return "integer";
+    if (/^[+-]?(?:\d+\.\d*|\d*\.\d+|\d+e[+-]?\d+|\d+\.\d*e[+-]?\d+|\d*\.\d+e[+-]?\d+)$/i.test(trimmed) && Number.isFinite(Number(trimmed))) {
+      return "decimal";
+    }
+  }
+  return "text";
+}
+
+function inferValueType(value: unknown): ImportInferredType | null {
+  if (value == null) return null;
+  if (typeof value === "boolean") return "boolean";
+  if (typeof value === "number") return Number.isInteger(value) ? "integer" : "decimal";
+  if (typeof value === "string") return inferStringType(value);
+  if (typeof value === "object") return "json";
+  return "text";
+}
+
+function mergeInferredType(current: ImportInferredType | null, next: ImportInferredType): ImportInferredType {
+  if (!current || current === next) return next;
+  if (current === "text" || next === "text") return "text";
+  if ((current === "integer" && next === "decimal") || (current === "decimal" && next === "integer")) return "decimal";
+  if ((current === "date" && next === "timestamp") || (current === "timestamp" && next === "date")) return "timestamp";
+  return "text";
+}
+
+function inferColumnType(rows: unknown[][], sourceIndex: number): ImportInferredType {
+  let inferred: ImportInferredType | null = null;
+  for (const row of rows) {
+    const valueType = inferValueType(row[sourceIndex]);
+    if (!valueType) continue;
+    inferred = mergeInferredType(inferred, valueType);
+    if (inferred === "text") break;
+  }
+  return inferred || "text";
+}
+
+export function importDataTypeForDatabase(inferredType: ImportInferredType, databaseType?: DatabaseType): string {
+  switch (inferredType) {
+    case "boolean":
+      if (["mysql", "doris", "starrocks", "goldendb", "sundb", "databend"].includes(databaseType || "")) return "TINYINT(1)";
+      if (databaseType === "sqlserver") return "BIT";
+      if (databaseType === "sqlite" || databaseType === "rqlite" || databaseType === "turso" || databaseType === "cloudflare-d1") return "INTEGER";
+      if (databaseType === "oracle" || databaseType === "oceanbase-oracle" || databaseType === "dameng") return "NUMBER(1)";
+      if (databaseType === "clickhouse") return "UInt8";
+      return "BOOLEAN";
+    case "integer":
+      if (databaseType === "sqlite" || databaseType === "rqlite" || databaseType === "turso" || databaseType === "cloudflare-d1") return "INTEGER";
+      if (databaseType === "oracle" || databaseType === "oceanbase-oracle" || databaseType === "dameng") return "NUMBER(19)";
+      if (databaseType === "clickhouse") return "Int64";
+      return "BIGINT";
+    case "decimal":
+      if (["postgres", "gaussdb", "opengauss", "redshift", "kingbase", "highgo", "kwdb", "vastbase"].includes(databaseType || "")) return "DOUBLE PRECISION";
+      if (databaseType === "sqlite" || databaseType === "rqlite" || databaseType === "turso" || databaseType === "cloudflare-d1") return "REAL";
+      if (databaseType === "oracle" || databaseType === "oceanbase-oracle" || databaseType === "dameng") return "BINARY_DOUBLE";
+      if (databaseType === "clickhouse") return "Float64";
+      return "DOUBLE";
+    case "date":
+      if (databaseType === "sqlite" || databaseType === "rqlite" || databaseType === "turso" || databaseType === "cloudflare-d1") return "TEXT";
+      if (databaseType === "clickhouse") return "Date";
+      return "DATE";
+    case "timestamp":
+      if (["mysql", "doris", "starrocks", "goldendb", "sundb", "databend"].includes(databaseType || "")) return "DATETIME";
+      if (databaseType === "sqlserver") return "DATETIME2";
+      if (databaseType === "sqlite" || databaseType === "rqlite" || databaseType === "turso" || databaseType === "cloudflare-d1") return "TEXT";
+      if (databaseType === "clickhouse") return "DateTime64";
+      return "TIMESTAMP";
+    case "json":
+      if (["postgres", "gaussdb", "opengauss", "kingbase", "highgo", "kwdb", "vastbase"].includes(databaseType || "")) return "JSONB";
+      if (databaseType === "mysql" || databaseType === "databend") return "JSON";
+      return importDataTypeForDatabase("text", databaseType);
+    case "text":
+    default:
+      if (databaseType === "sqlserver") return "NVARCHAR(MAX)";
+      if (databaseType === "oracle" || databaseType === "oceanbase-oracle" || databaseType === "dameng") return "CLOB";
+      if (databaseType === "clickhouse") return "String";
+      if (["hive", "trino", "prestosql", "databricks"].includes(databaseType || "")) return "STRING";
+      return "TEXT";
+  }
+}
+
+export function suggestImportTargetDataTypes(columns: string[], rows: unknown[][], databaseType?: DatabaseType): Record<string, string> {
+  return Object.fromEntries(columns.map((column, index) => [column, importDataTypeForDatabase(inferColumnType(rows, index), databaseType)]));
+}
diff --git a/apps/desktop/src/lib/table/tableMetadataCapabilities.ts b/apps/desktop/src/lib/table/tableMetadataCapabilities.ts
new file mode 100644
index 0000000..109e86b
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableMetadataCapabilities.ts
@@ -0,0 +1,88 @@
+import type { DatabaseType, TableInfoTab } from "@/types/database";
+
+export interface TableMetadataCapabilities {
+  columns: boolean;
+  indexes: boolean;
+  foreignKeys: boolean;
+  triggers: boolean;
+  ddl: boolean;
+}
+
+const defaultCapabilities: TableMetadataCapabilities = {
+  columns: true,
+  indexes: true,
+  foreignKeys: true,
+  triggers: true,
+  ddl: true,
+};
+
+const capabilityByType: Partial<Record<DatabaseType, Partial<TableMetadataCapabilities>>> = {
+  clickhouse: {
+    foreignKeys: false,
+    triggers: false,
+  },
+  manticoresearch: {
+    foreignKeys: false,
+    triggers: false,
+  },
+  elasticsearch: {
+    indexes: false,
+    foreignKeys: false,
+    triggers: false,
+    ddl: false,
+  },
+  qdrant: {
+    indexes: false,
+    foreignKeys: false,
+    triggers: false,
+    ddl: false,
+  },
+  milvus: {
+    indexes: false,
+    foreignKeys: false,
+    triggers: false,
+    ddl: false,
+  },
+  weaviate: {
+    indexes: false,
+    foreignKeys: false,
+    triggers: false,
+    ddl: false,
+  },
+  chromadb: {
+    indexes: false,
+    foreignKeys: false,
+    triggers: false,
+    ddl: false,
+  },
+  influxdb: {
+    indexes: false,
+    foreignKeys: false,
+    triggers: false,
+    ddl: false,
+  },
+  questdb: {
+    indexes: true,
+    foreignKeys: false,
+    triggers: false,
+  },
+};
+
+export function getTableMetadataCapabilities(dbType?: DatabaseType): TableMetadataCapabilities {
+  return { ...defaultCapabilities, ...(dbType ? capabilityByType[dbType] : undefined) };
+}
+
+export function firstStructureMetadataTab(capabilities: TableMetadataCapabilities, isCreateMode: boolean): TableInfoTab {
+  // Structure editing should open on an editable metadata page; DDL remains a
+  // read-only fallback for databases that do not expose editable metadata.
+  if (capabilities.columns) return "columns";
+  if (capabilities.indexes) return "indexes";
+  if (capabilities.foreignKeys) return "foreignKeys";
+  if (capabilities.triggers) return "triggers";
+  if (!isCreateMode && capabilities.ddl) return "ddl";
+  return "columns";
+}
+
+export function isStructureMetadataTabSupported(tab: TableInfoTab, capabilities: TableMetadataCapabilities, isCreateMode: boolean): boolean {
+  return (tab === "columns" && capabilities.columns) || (tab === "indexes" && capabilities.indexes) || (tab === "foreignKeys" && capabilities.foreignKeys) || (tab === "triggers" && capabilities.triggers) || (tab === "ddl" && capabilities.ddl && !isCreateMode);
+}
diff --git a/apps/desktop/src/lib/table/tableOpenPageLimit.ts b/apps/desktop/src/lib/table/tableOpenPageLimit.ts
new file mode 100644
index 0000000..4340427
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableOpenPageLimit.ts
@@ -0,0 +1,8 @@
+import { DEFAULT_RESULT_PAGE_SIZE, normalizeResultPageSize } from "@/lib/dataGrid/paginationPageSize";
+
+export const DEFAULT_TABLE_OPEN_PAGE_LIMIT = DEFAULT_RESULT_PAGE_SIZE;
+
+export function tableOpenPageLimit(): number {
+  // Opening a table should not inherit the mutable SQL result-grid rows-per-page setting.
+  return normalizeResultPageSize(DEFAULT_TABLE_OPEN_PAGE_LIMIT);
+}
diff --git a/apps/desktop/src/lib/table/tableSelectSql.ts b/apps/desktop/src/lib/table/tableSelectSql.ts
new file mode 100644
index 0000000..e56238b
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableSelectSql.ts
@@ -0,0 +1,76 @@
+import type { DatabaseType } from "@/types/database.ts";
+import { isSchemaAware, usesDatabaseObjectTreeMode } from "@/lib/database/databaseCapabilities.ts";
+import * as api from "@/lib/backend/api.ts";
+import { parseSqlServerLinkedSchema, sqlServerLinkedTableName } from "@/lib/database/sqlServerLinkedServers.ts";
+
+export interface BuildTableSelectSqlOptions {
+  databaseType?: DatabaseType;
+  schema?: string;
+  tableName: string;
+  tableType?: string;
+  primaryKeys?: string[];
+  columns?: string[];
+  fallbackOrderColumns?: string[];
+  orderBy?: string;
+  limit?: number;
+  offset?: number;
+  whereInput?: string;
+  includeRowId?: boolean;
+  catalog?: string;
+}
+
+export function quoteTableIdentifier(databaseType: DatabaseType | undefined, name: string): string {
+  if (databaseType === "iotdb") return name;
+  // JDBC connections use the driver-reported identifier quote string
+  // (DatabaseMetaData.getIdentifierQuoteString()) — pass through unquoted.
+  if (databaseType === "jdbc") return name;
+  if (databaseType === "mysql" || databaseType === "clickhouse" || databaseType === "hive" || databaseType === "spark" || databaseType === "databend" || databaseType === "tdengine" || databaseType === "access" || databaseType === "doris" || databaseType === "starrocks")
+    return `\`${name.replace(/`/g, "``")}\``;
+  if (databaseType === "informix" && /^[A-Za-z_][A-Za-z0-9_$]*$/.test(name)) return name;
+  if (databaseType === "neo4j") return quoteCypherIdentifier(name);
+  if (databaseType === "sqlserver") return `[${name.replace(/\]/g, "]]")}]`;
+  return `"${name.replace(/"/g, '""')}"`;
+}
+
+function quoteCypherIdentifier(name: string): string {
+  return `\`${name.replace(/`/g, "``")}\``;
+}
+
+export function qualifiedTableName(options: Pick<BuildTableSelectSqlOptions, "databaseType" | "schema" | "tableName" | "catalog">): string {
+  const { databaseType, schema, tableName, catalog } = options;
+  // Doris / StarRocks multi-catalog: address external-catalog tables with the
+  // 3-part `catalog.database.table` form, which the engines accept directly.
+  if (catalog && catalog !== "internal" && (databaseType === "doris" || databaseType === "starrocks")) {
+    const quotedCatalog = quoteTableIdentifier(databaseType, catalog);
+    const quotedTable = quoteTableIdentifier(databaseType, tableName);
+    const trimmedSchema = schema?.trim();
+    if (trimmedSchema) {
+      return `${quotedCatalog}.${quoteTableIdentifier(databaseType, trimmedSchema)}.${quotedTable}`;
+    }
+    return `${quotedCatalog}.${quotedTable}`;
+  }
+  if (databaseType === "iotdb") {
+    const trimmedSchema = schema?.trim();
+    if (trimmedSchema && tableName !== trimmedSchema && !tableName.startsWith(`${trimmedSchema}.`)) {
+      return `${quoteTableIdentifier(databaseType, trimmedSchema)}.${quoteTableIdentifier(databaseType, tableName)}`;
+    }
+    return quoteTableIdentifier(databaseType, tableName);
+  }
+  if (isSchemaAware(databaseType) && !usesDatabaseObjectTreeMode(databaseType) && schema) {
+    if (databaseType === "sqlserver") {
+      const linked = parseSqlServerLinkedSchema(schema);
+      if (linked) return sqlServerLinkedTableName(linked, tableName);
+    }
+    return `${quoteTableIdentifier(databaseType, schema)}.${quoteTableIdentifier(databaseType, tableName)}`;
+  }
+  return quoteTableIdentifier(databaseType, tableName);
+}
+
+export function normalizeWhereInput(whereInput?: string): string {
+  const withoutSemicolon = whereInput?.trim().replace(/;+$/, "").trim() ?? "";
+  return withoutSemicolon.replace(/^where\b/i, "").trim();
+}
+
+export async function buildTableSelectSql(options: BuildTableSelectSqlOptions): Promise<string> {
+  return api.buildTableSelectSql(options);
+}
diff --git a/apps/desktop/src/lib/table/tableSqlTemplates.ts b/apps/desktop/src/lib/table/tableSqlTemplates.ts
new file mode 100644
index 0000000..10244a9
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableSqlTemplates.ts
@@ -0,0 +1,196 @@
+import type { ColumnInfo, DatabaseType } from "@/types/database";
+import { qualifiedTableName, quoteTableIdentifier } from "@/lib/table/tableSelectSql";
+
+export interface TableSqlTemplateOptions {
+  databaseType?: DatabaseType;
+  schema?: string;
+  tableName: string;
+  columns?: ColumnInfo[];
+  tableType?: string;
+}
+
+export function buildTableSelectTemplate(options: TableSqlTemplateOptions): string {
+  const tableName = templateTableName(options);
+  const columns = options.columns ?? [];
+  if (!columns.length) {
+    return `SELECT *\nFROM ${tableName};`;
+  }
+  const selectColumns = columns.map((column) => quoteTableIdentifier(options.databaseType, column.name));
+  return `SELECT ${selectColumns.join(", ")}\nFROM ${tableName};`;
+}
+
+export function buildTableInsertTemplate(options: TableSqlTemplateOptions): string {
+  const strategy = options.databaseType ? insertTemplateStrategies[options.databaseType] : undefined;
+  return (strategy ?? buildDefaultInsertTemplate)(options);
+}
+
+type InsertTemplateStrategy = (options: TableSqlTemplateOptions) => string;
+
+function buildDefaultInsertTemplate(options: TableSqlTemplateOptions): string {
+  const tableName = templateTableName(options);
+  const columns = (options.columns ?? []).filter((column) => !isAutoGeneratedColumn(column));
+
+  // TDengine does not support INSERT INTO t(col1, col2) VALUES(...) syntax
+  if (options.databaseType === "tdengine") {
+    const values = columns.map((column) => columnPlaceholderValue(column, options.databaseType));
+    if (!values.length) {
+      return `INSERT INTO ${tableName}\nVALUES (/* TODO: add values */);`;
+    }
+    return `INSERT INTO ${tableName}\nVALUES (${values.join(", ")});`;
+  }
+
+  if (!columns.length) {
+    return `INSERT INTO ${tableName}\n/* TODO: add column values */\nVALUES ();`;
+  }
+
+  const columnNames = columns.map((column) => quoteTableIdentifier(options.databaseType, column.name));
+  const values = columns.map((column) => columnPlaceholderValue(column, options.databaseType));
+  return `INSERT INTO ${tableName} (${columnNames.join(", ")})\nVALUES (${values.join(", ")});`;
+}
+
+function buildTdengineInsertTemplate(options: TableSqlTemplateOptions): string {
+  const columns = options.columns ?? [];
+  const isTagColumn = (column: ColumnInfo) => (column.comment ?? "").toUpperCase() === "TAG" || (column.extra ?? "").toUpperCase().includes("TAG");
+  const tagColumns = columns.filter((column) => isTagColumn(column));
+  const normalizedTableType = (options.tableType ?? "").toUpperCase();
+  const shouldUseStableTemplate = normalizedTableType === "STABLE" || (!normalizedTableType && tagColumns.length > 0);
+
+  if (!shouldUseStableTemplate) {
+    return buildDefaultInsertTemplate(options);
+  }
+
+  const valueColumns = columns.filter((column) => !isTagColumn(column)).filter((column) => !isAutoGeneratedColumn(column));
+  const tagPlaceholders = tagColumns.map((column) => columnPlaceholderValue(column, options.databaseType));
+  const tagsSql = tagPlaceholders.length > 0 ? `TAGS (${tagPlaceholders.join(", ")})` : "TAGS (/* TODO: add tag values */)";
+  const stableNameForUsing = templateTableName(options).replace(/^`|`$/g, "");
+  const valuePlaceholders = valueColumns.map((column) => columnPlaceholderValue(column, options.databaseType));
+
+  if (!valueColumns.length) {
+    return `INSERT INTO /* child_table_name */ USING ${stableNameForUsing}\n${tagsSql}\nVALUES (/* TODO: add values */);`;
+  }
+
+  return `INSERT INTO /* child_table_name */ USING ${stableNameForUsing}\n${tagsSql}\nVALUES (${valuePlaceholders.join(", ")});`;
+}
+
+const insertTemplateStrategies: Partial<Record<DatabaseType, InsertTemplateStrategy>> = {
+  tdengine: buildTdengineInsertTemplate,
+};
+
+export function buildTableUpdateTemplate(options: TableSqlTemplateOptions): string {
+  const tableName = templateTableName(options);
+  const columns = options.columns ?? [];
+  const primaryKeys = columns.filter((column) => column.is_primary_key);
+  const primaryKeyNames = new Set(primaryKeys.map((column) => column.name));
+  const updateColumns = columns.filter((column) => !primaryKeyNames.has(column.name));
+  const setClause = updateColumns.length ? updateColumns.map((column) => `${quoteTableIdentifier(options.databaseType, column.name)} = ${columnPlaceholderValue(column, options.databaseType)}`).join(",\n    ") : "/* TODO: set column = value */";
+
+  return `UPDATE ${tableName}\nSET ${setClause}\n${buildWhereClause(options.databaseType, primaryKeys)};`;
+}
+
+export function buildTableDeleteTemplate(options: TableSqlTemplateOptions): string {
+  const tableName = templateTableName(options);
+  const primaryKeys = (options.columns ?? []).filter((column) => column.is_primary_key);
+  return `DELETE FROM ${tableName}\n${buildWhereClause(options.databaseType, primaryKeys)};`;
+}
+
+function templateTableName(options: TableSqlTemplateOptions): string {
+  return qualifiedTableName({
+    databaseType: options.databaseType,
+    schema: options.schema,
+    tableName: options.tableName,
+  });
+}
+
+function buildWhereClause(databaseType: DatabaseType | undefined, primaryKeys: ColumnInfo[]): string {
+  if (!primaryKeys.length) return "WHERE /* TODO: add WHERE clause */";
+  const conditions = primaryKeys.map((column) => `${quoteTableIdentifier(databaseType, column.name)} = ${columnPlaceholderValue(column, databaseType)}`);
+  return `WHERE ${conditions.join(" AND ")}`;
+}
+
+function isAutoGeneratedColumn(column: ColumnInfo): boolean {
+  const extra = (column.extra ?? "").toLowerCase().trim();
+  const colDefault = (column.column_default ?? "").toLowerCase().trim();
+  const dataType = (column.data_type ?? "").trim();
+
+  if (typeLooksPostgresTextSearchVector(dataType)) return true;
+  if (extra.includes("auto_increment")) return true;
+  if (extra.includes("autoincrement")) return true;
+  if (extra.includes("identity")) return true;
+  if (extra.includes("generated") && (extra.includes("as identity") || extra.includes("always as"))) return true;
+  if (colDefault.includes("nextval(")) return true;
+  if (colDefault.includes(".nextval")) return true;
+  if ((extra.includes("virtual") || extra.includes("computed")) && extra.includes("generated")) return true;
+
+  return false;
+}
+
+function columnPlaceholderValue(column: ColumnInfo, databaseType?: DatabaseType): string {
+  const dataType = (column.data_type ?? "").trim();
+  const colName = column.name;
+
+  if (typeLooksNumeric(dataType)) return "0";
+  if (typeLooksBoolean(dataType)) return databaseType === "mysql" || databaseType === "sqlite" || databaseType === "rqlite" || databaseType === "cloudflare-d1" ? "1" : "TRUE";
+  if (typeLooksDateOnly(dataType)) return "'2024-01-01'";
+  if (typeLooksTimeOnly(dataType)) return "'12:00:00'";
+  if (typeLooksTimestamp(dataType)) return databaseType === "tdengine" ? "NOW" : "CURRENT_TIMESTAMP";
+  if (typeLooksJson(dataType)) return databaseType === "postgres" || databaseType === "redshift" ? "'{}'::jsonb" : "'{}'";
+  if (typeLooksBinary(dataType)) return "''";
+  if (typeLooksUuid(dataType)) return databaseType === "postgres" || databaseType === "redshift" ? "'00000000-0000-0000-0000-000000000000'::uuid" : "'00000000-0000-0000-0000-000000000000'";
+  if (typeLooksXml(dataType)) return "'<root/>'";
+  if (typeLooksSpatial(dataType)) return "NULL";
+  if (typeLooksArray(dataType)) return "'{}'";
+
+  return `'${colName}_value'`;
+}
+
+function typeLooksNumeric(dataType: string): boolean {
+  return /^(tinyint|smallint|mediumint|int\d*|integer\d*|bigint|smallserial|serial\d*|bigserial|number|numeric|decimal|dec|float\d*|double|real|double\s+precision|money|smallmoney|fixed)/i.test(dataType.trim());
+}
+
+function typeLooksBoolean(dataType: string): boolean {
+  return /^(bool|boolean|bit\s*\(\s*1\s*\))$/i.test(dataType.trim());
+}
+
+function typeLooksDateOnly(dataType: string): boolean {
+  return /^date$/i.test(dataType.trim());
+}
+
+function typeLooksTimeOnly(dataType: string): boolean {
+  return /^time\b(?!stamp|stamptz|with|without)/i.test(dataType.trim());
+}
+
+function typeLooksTimestamp(dataType: string): boolean {
+  return /^(datetime|timestamp|timestamptz|timestamp\s+with\s+time\s+zone|timestamp\s+without\s+time\s+zone|smalldatetime|datetime2|datetimeoffset)/i.test(dataType.trim());
+}
+
+function typeLooksJson(dataType: string): boolean {
+  return /^(json|jsonb)$/i.test(dataType.trim());
+}
+
+function typeLooksBinary(dataType: string): boolean {
+  return /^(bytea|blob|binary|varbinary|image|raw|longblob|mediumblob|tinyblob|long\s+raw|bfile)$/i.test(dataType.trim());
+}
+
+function typeLooksUuid(dataType: string): boolean {
+  return /^uuid$/i.test(dataType.trim());
+}
+
+function typeLooksXml(dataType: string): boolean {
+  return /^xml$/i.test(dataType.trim());
+}
+
+function typeLooksSpatial(dataType: string): boolean {
+  return /^(geometry|geography|point|polygon|linestring|box|circle|path|line|lseg)/i.test(dataType.trim());
+}
+
+function typeLooksArray(dataType: string): boolean {
+  return /^(array|vector|_float\d*|_int\d*|_text|_varchar|_bool|_uuid)/i.test(dataType.trim());
+}
+
+function typeLooksPostgresTextSearchVector(dataType: string): boolean {
+  const normalized = dataType
+    .trim()
+    .replace(/^"+|"+$/g, "")
+    .toLowerCase();
+  return normalized === "tsvector" || normalized.endsWith(".tsvector");
+}
diff --git a/apps/desktop/src/lib/table/tableStructureCapabilities.ts b/apps/desktop/src/lib/table/tableStructureCapabilities.ts
new file mode 100644
index 0000000..656142e
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableStructureCapabilities.ts
@@ -0,0 +1,362 @@
+import type { DatabaseType } from "@/types/database";
+
+export type TableStructureDialect = "mysql" | "postgres" | "sqlite" | "duckdb" | "sqlserver" | "oracle" | "h2" | "clickhouse" | "informix" | "influxdb" | "unsupported";
+export type TableStructureAlterStrategy = "none" | "direct" | "sqlite-rebuild";
+
+export interface TableStructureCapabilities {
+  dialect: TableStructureDialect;
+  alterStrategy: TableStructureAlterStrategy;
+  createTable: boolean;
+  addColumn: boolean;
+  dropColumn: boolean;
+  renameColumn: boolean;
+  alterExistingColumn: boolean;
+  alterType: boolean;
+  alterNullability: boolean;
+  alterDefault: boolean;
+  alterPrimaryKey: boolean;
+  reorderColumn: boolean;
+  comment: boolean;
+  createIndex: boolean;
+  dropIndex: boolean;
+  rebuildIndex: boolean;
+  indexType: boolean;
+  indexInclude: boolean;
+  indexFilter: boolean;
+  indexComment: boolean;
+  foreignKey: boolean;
+}
+
+const unsupportedCapabilities: TableStructureCapabilities = {
+  dialect: "unsupported",
+  alterStrategy: "none",
+  createTable: false,
+  addColumn: false,
+  dropColumn: false,
+  renameColumn: false,
+  alterExistingColumn: false,
+  alterType: false,
+  alterNullability: false,
+  alterDefault: false,
+  alterPrimaryKey: false,
+  reorderColumn: false,
+  comment: false,
+  createIndex: false,
+  dropIndex: false,
+  rebuildIndex: false,
+  indexType: false,
+  indexInclude: false,
+  indexFilter: false,
+  indexComment: false,
+  foreignKey: false,
+};
+
+function capabilities(overrides: Partial<TableStructureCapabilities>): TableStructureCapabilities {
+  const resolved = { ...unsupportedCapabilities, ...overrides };
+  if (overrides.alterStrategy === undefined && resolved.alterExistingColumn) {
+    resolved.alterStrategy = "direct";
+  }
+  return resolved;
+}
+
+const mysqlCapabilities = capabilities({
+  dialect: "mysql",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+  renameColumn: true,
+  alterExistingColumn: true,
+  alterType: true,
+  alterNullability: true,
+  alterDefault: true,
+  reorderColumn: true,
+  comment: true,
+  createIndex: true,
+  dropIndex: true,
+  rebuildIndex: true,
+  indexType: true,
+  indexComment: true,
+  alterPrimaryKey: true,
+  foreignKey: true,
+});
+
+const gbaseCapabilities = capabilities({
+  dialect: "mysql",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+  renameColumn: true,
+  reorderColumn: true,
+});
+
+const postgresCapabilities = capabilities({
+  dialect: "postgres",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+  renameColumn: true,
+  alterExistingColumn: true,
+  alterType: true,
+  alterNullability: true,
+  alterDefault: true,
+  comment: true,
+  createIndex: true,
+  dropIndex: true,
+  rebuildIndex: true,
+  indexType: true,
+  indexInclude: true,
+  indexFilter: true,
+  indexComment: true,
+  alterPrimaryKey: true,
+  foreignKey: true,
+});
+
+const redshiftCapabilities = capabilities({
+  ...postgresCapabilities,
+  createIndex: false,
+  dropIndex: false,
+  rebuildIndex: false,
+  indexType: false,
+  indexInclude: false,
+  indexFilter: false,
+  indexComment: false,
+  alterPrimaryKey: false,
+});
+
+const sqliteCapabilities = capabilities({
+  dialect: "sqlite",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+  renameColumn: true,
+  createIndex: true,
+  dropIndex: true,
+  rebuildIndex: true,
+  indexFilter: true,
+});
+
+const nativeSqliteCapabilities = capabilities({
+  ...sqliteCapabilities,
+  alterStrategy: "sqlite-rebuild",
+  alterExistingColumn: true,
+  alterType: true,
+});
+
+const duckdbCapabilities = capabilities({
+  dialect: "duckdb",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+  renameColumn: true,
+  createIndex: true,
+  dropIndex: true,
+  rebuildIndex: true,
+});
+
+const sqlserverCapabilities = capabilities({
+  dialect: "sqlserver",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+  renameColumn: true,
+  alterExistingColumn: true,
+  alterType: true,
+  alterNullability: true,
+  alterDefault: true,
+  comment: true,
+  createIndex: true,
+  dropIndex: true,
+  rebuildIndex: true,
+  indexType: true,
+  indexInclude: true,
+  indexFilter: true,
+  indexComment: true,
+});
+
+const oracleCapabilities = capabilities({
+  dialect: "oracle",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+  renameColumn: true,
+  alterExistingColumn: true,
+  alterType: true,
+  alterNullability: true,
+  alterDefault: true,
+  comment: true,
+  createIndex: true,
+  dropIndex: true,
+  rebuildIndex: true,
+  indexType: true,
+});
+
+const h2Capabilities = capabilities({
+  dialect: "h2",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+  renameColumn: true,
+  alterExistingColumn: true,
+  alterType: true,
+  alterNullability: true,
+  alterDefault: true,
+  comment: true,
+  createIndex: true,
+  dropIndex: true,
+  rebuildIndex: true,
+});
+
+const clickhouseCapabilities = capabilities({
+  dialect: "clickhouse",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+  renameColumn: true,
+  alterExistingColumn: true,
+  alterType: true,
+  alterNullability: true,
+  alterDefault: true,
+  reorderColumn: true,
+  comment: true,
+});
+
+const informixCapabilities = capabilities({
+  dialect: "informix",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+  renameColumn: true,
+  alterExistingColumn: true,
+  alterType: true,
+  alterNullability: true,
+  alterDefault: true,
+  createIndex: true,
+  dropIndex: true,
+  rebuildIndex: true,
+});
+
+const accessCapabilities = capabilities({
+  dialect: "h2",
+  createTable: true,
+  addColumn: true,
+  createIndex: true,
+});
+
+const influxdbCapabilities = capabilities({
+  dialect: "influxdb",
+  createTable: false,
+  addColumn: false,
+  dropColumn: false,
+  renameColumn: false,
+  alterExistingColumn: false,
+  alterType: false,
+  alterNullability: false,
+  alterDefault: false,
+  reorderColumn: false,
+  comment: false,
+});
+
+const manticoreSearchCapabilities = capabilities({
+  dialect: "mysql",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+});
+
+const questdbCapabilities = capabilities({
+  dialect: "postgres",
+  createTable: true,
+  addColumn: true,
+  dropColumn: true,
+  renameColumn: true,
+  alterExistingColumn: true,
+  alterType: true,
+  alterNullability: false,
+  alterDefault: false,
+  comment: false,
+  createIndex: false,
+  dropIndex: false,
+  rebuildIndex: false,
+  indexType: false,
+  indexInclude: false,
+  indexFilter: false,
+  indexComment: false,
+  alterPrimaryKey: false,
+  foreignKey: false,
+});
+
+const firebirdCapabilities = capabilities({
+  ...postgresCapabilities,
+  foreignKey: false,
+});
+
+const capabilityByType: Partial<Record<DatabaseType, TableStructureCapabilities>> = {
+  mysql: mysqlCapabilities,
+  doris: mysqlCapabilities,
+  starrocks: mysqlCapabilities,
+  goldendb: mysqlCapabilities,
+  sundb: mysqlCapabilities,
+  oscar: unsupportedCapabilities,
+  databend: mysqlCapabilities,
+  gbase: gbaseCapabilities,
+  postgres: postgresCapabilities,
+  gaussdb: postgresCapabilities,
+  kwdb: postgresCapabilities,
+  opengauss: postgresCapabilities,
+  questdb: questdbCapabilities,
+  redshift: redshiftCapabilities,
+  vertica: redshiftCapabilities,
+  highgo: postgresCapabilities,
+  vastbase: postgresCapabilities,
+  kingbase: postgresCapabilities,
+  firebird: firebirdCapabilities,
+  sqlite: sqliteCapabilities,
+  rqlite: sqliteCapabilities,
+  turso: sqliteCapabilities,
+  duckdb: duckdbCapabilities,
+  sqlserver: sqlserverCapabilities,
+  oracle: oracleCapabilities,
+  dameng: oracleCapabilities,
+  "oceanbase-oracle": oracleCapabilities,
+  iris: oracleCapabilities,
+  yashandb: oracleCapabilities,
+  xugu: oracleCapabilities,
+  h2: h2Capabilities,
+  access: accessCapabilities,
+  clickhouse: clickhouseCapabilities,
+  informix: informixCapabilities,
+  influxdb: influxdbCapabilities,
+  manticoresearch: manticoreSearchCapabilities,
+};
+
+export function getTableStructureCapabilities(dbType?: DatabaseType, connectionDbType?: DatabaseType): TableStructureCapabilities {
+  if (dbType === "sqlite" && connectionDbType === "sqlite") return nativeSqliteCapabilities;
+  return dbType ? (capabilityByType[dbType] ?? unsupportedCapabilities) : unsupportedCapabilities;
+}
+
+export function canEditTableStructure(dbType?: DatabaseType): boolean {
+  const caps = getTableStructureCapabilities(dbType);
+  return caps.createTable || caps.addColumn || caps.alterExistingColumn || caps.createIndex || caps.dropIndex;
+}
+
+export function supportsLocalTableColumnReorder(dbType?: DatabaseType, connectionDbType?: DatabaseType): boolean {
+  const caps = getTableStructureCapabilities(dbType, connectionDbType);
+  return canEditTableStructure(dbType) && !caps.reorderColumn;
+}
+
+export function isPhysicalTableColumnOrderChange(dbType: DatabaseType | undefined, connectionDbType: DatabaseType | undefined, originalPosition: number | undefined, currentPosition: number): boolean {
+  return getTableStructureCapabilities(dbType, connectionDbType).reorderColumn && originalPosition !== currentPosition;
+}
+
+export function hasLocalTableColumnOrderChange(columns: readonly { originalPosition?: number; original?: unknown; markedForDrop?: boolean }[]): boolean {
+  const activeColumns = columns.filter((column) => !column.markedForDrop);
+  // Databases without physical reorder support keep existing columns in ordinal order
+  // and append newly added columns, so compare against that post-save layout.
+  const databaseOrder = [...activeColumns.filter((column) => column.original).sort((left, right) => (left.originalPosition ?? Number.MAX_SAFE_INTEGER) - (right.originalPosition ?? Number.MAX_SAFE_INTEGER)), ...activeColumns.filter((column) => !column.original)];
+  return activeColumns.some((column, index) => column !== databaseOrder[index]);
+}
+
+export function canAddTableStructureColumn(dbType: DatabaseType | undefined, isCreateMode: boolean): boolean {
+  const caps = getTableStructureCapabilities(dbType);
+  return isCreateMode ? caps.createTable : caps.addColumn;
+}
diff --git a/apps/desktop/src/lib/table/tableStructureEditorSql.ts b/apps/desktop/src/lib/table/tableStructureEditorSql.ts
new file mode 100644
index 0000000..177e040
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableStructureEditorSql.ts
@@ -0,0 +1,100 @@
+import type { ColumnInfo, DatabaseType, ForeignKeyInfo, IndexInfo, TriggerInfo } from "@/types/database.ts";
+
+export interface ColumnIdentity {
+  generation?: "BY DEFAULT" | "ALWAYS";
+  seed?: number;
+  increment?: number;
+}
+
+export interface ColumnExtra {
+  autoIncrement?: boolean;
+  onUpdateCurrentTimestamp?: boolean;
+  identity?: ColumnIdentity;
+  manticoreIndexed?: boolean;
+  manticoreStored?: boolean;
+  manticoreAttribute?: boolean;
+  manticoreSecondaryIndex?: boolean;
+}
+
+export interface EditableStructureColumn {
+  id: string;
+  name: string;
+  dataType: string;
+  enumValues?: string[];
+  isNullable: boolean;
+  defaultValue: string;
+  comment: string;
+  isPrimaryKey: boolean;
+  extra: ColumnExtra;
+  characterSet?: string;
+  collation?: string;
+  original?: ColumnInfo;
+  originalPosition?: number;
+  markedForDrop: boolean;
+}
+
+export interface EditableStructureIndex {
+  id: string;
+  name: string;
+  columns: string[];
+  nameEdited?: boolean;
+  isUnique: boolean;
+  isPrimary: boolean;
+  filter: string;
+  indexType: string;
+  includedColumns: string[];
+  comment: string;
+  original?: IndexInfo;
+  markedForDrop: boolean;
+}
+
+export interface EditableStructureForeignKey {
+  id: string;
+  name: string;
+  column: string;
+  refSchema: string;
+  refTable: string;
+  refColumn: string;
+  onUpdate: string;
+  onDelete: string;
+  original?: ForeignKeyInfo;
+  markedForDrop: boolean;
+}
+
+export interface EditableStructureTrigger {
+  id: string;
+  name: string;
+  timing: string;
+  event: string;
+  statement: string;
+  original?: TriggerInfo;
+  markedForDrop: boolean;
+}
+
+export interface BuildTableStructureChangeSqlOptions {
+  databaseType?: DatabaseType;
+  schema?: string;
+  tableName: string;
+  columns: EditableStructureColumn[];
+  indexes: EditableStructureIndex[];
+  foreignKeys?: EditableStructureForeignKey[];
+  triggers?: EditableStructureTrigger[];
+  tableComment?: string;
+  originalTableComment?: string;
+}
+
+export interface TableStructureChangeSql {
+  statements: string[];
+  warnings: string[];
+}
+
+export interface SqliteTableStructureChangePreview extends TableStructureChangeSql {
+  schemaRevision: string;
+}
+
+export interface BuildSingleColumnAlterSqlOptions {
+  databaseType?: DatabaseType;
+  schema?: string;
+  tableName: string;
+  column: EditableStructureColumn;
+}
diff --git a/apps/desktop/src/lib/table/tableStructureEditorState.ts b/apps/desktop/src/lib/table/tableStructureEditorState.ts
new file mode 100644
index 0000000..aa56632
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableStructureEditorState.ts
@@ -0,0 +1,1030 @@
+import type { ColumnInfo, DatabaseType, ForeignKeyInfo, IndexInfo, TriggerInfo } from "@/types/database.ts";
+import type { ColumnExtra, EditableStructureColumn, EditableStructureForeignKey, EditableStructureIndex, EditableStructureTrigger } from "@/lib/table/tableStructureEditorSql.ts";
+
+export function hasExistingColumnTypeChange(columns: readonly EditableStructureColumn[]): boolean {
+  return columns.some((column) => !!column.original && !column.markedForDrop && column.dataType !== column.original.data_type);
+}
+
+export const DATA_TYPE_OPTIONS: Record<string, string[]> = {
+  mysql: [
+    "tinyint",
+    "tinyint unsigned",
+    "smallint",
+    "smallint unsigned",
+    "mediumint",
+    "mediumint unsigned",
+    "int",
+    "int unsigned",
+    "integer",
+    "integer unsigned",
+    "bigint",
+    "bigint unsigned",
+    "float",
+    "double",
+    "double precision",
+    "real",
+    "decimal",
+    "numeric",
+    "bit",
+    "boolean",
+    "bool",
+    "serial",
+    "char",
+    "varchar",
+    "tinytext",
+    "text",
+    "mediumtext",
+    "longtext",
+    "binary",
+    "varbinary",
+    "tinyblob",
+    "blob",
+    "mediumblob",
+    "longblob",
+    "enum",
+    "set",
+    "date",
+    "datetime",
+    "timestamp",
+    "time",
+    "year",
+    "json",
+    "geometry",
+    "point",
+    "linestring",
+    "polygon",
+    "multipoint",
+    "multilinestring",
+    "multipolygon",
+    "geometrycollection",
+  ],
+  postgres: [
+    "smallint",
+    "int2",
+    "integer",
+    "int",
+    "int4",
+    "bigint",
+    "int8",
+    "smallserial",
+    "serial",
+    "bigserial",
+    "decimal",
+    "numeric",
+    "real",
+    "float",
+    "float4",
+    "double precision",
+    "float8",
+    "money",
+    "boolean",
+    "bool",
+    "char",
+    "character",
+    "varchar",
+    "character varying",
+    "text",
+    "bytea",
+    "date",
+    "time",
+    "time without time zone",
+    "time with time zone",
+    "timetz",
+    "timestamp",
+    "timestamp without time zone",
+    "timestamp with time zone",
+    "timestamptz",
+    "interval",
+    "uuid",
+    "json",
+    "jsonb",
+    "xml",
+    "bit",
+    "bit varying",
+    "varbit",
+    "tsvector",
+    "tsquery",
+    "cidr",
+    "inet",
+    "macaddr",
+    "macaddr8",
+    "point",
+    "line",
+    "lseg",
+    "box",
+    "path",
+    "polygon",
+    "circle",
+    "int4range",
+    "int8range",
+    "numrange",
+    "tsrange",
+    "tstzrange",
+    "daterange",
+    "oid",
+  ],
+  sqlite: ["integer", "real", "text", "blob", "numeric"],
+  rqlite: ["integer", "real", "text", "blob", "numeric"],
+  turso: ["integer", "real", "text", "blob", "numeric"],
+  sqlserver: [
+    "bit",
+    "tinyint",
+    "smallint",
+    "int",
+    "integer",
+    "bigint",
+    "decimal",
+    "numeric",
+    "float",
+    "real",
+    "money",
+    "smallmoney",
+    "char",
+    "nchar",
+    "varchar",
+    "nvarchar",
+    "text",
+    "ntext",
+    "date",
+    "time",
+    "datetime",
+    "datetime2",
+    "smalldatetime",
+    "datetimeoffset",
+    "timestamp",
+    "binary",
+    "varbinary",
+    "image",
+    "uniqueidentifier",
+    "xml",
+    "sql_variant",
+    "hierarchyid",
+    "geography",
+    "geometry",
+  ],
+  oracle: [
+    "number",
+    "integer",
+    "float",
+    "binary_float",
+    "binary_double",
+    "char",
+    "nchar",
+    "varchar2",
+    "nvarchar2",
+    "clob",
+    "nclob",
+    "long",
+    "date",
+    "timestamp",
+    "timestamp with time zone",
+    "timestamp with local time zone",
+    "interval year to month",
+    "interval day to second",
+    "raw",
+    "long raw",
+    "blob",
+    "bfile",
+    "boolean",
+    "json",
+    "vector",
+    "rowid",
+    "urowid",
+    "xmltype",
+    "sdo_geometry",
+  ],
+  clickhouse: [
+    "Int8",
+    "Int16",
+    "Int32",
+    "Int64",
+    "Int128",
+    "Int256",
+    "UInt8",
+    "UInt16",
+    "UInt32",
+    "UInt64",
+    "UInt128",
+    "UInt256",
+    "Float16",
+    "Float32",
+    "Float64",
+    "Decimal",
+    "Decimal32",
+    "Decimal64",
+    "Decimal128",
+    "Decimal256",
+    "Bool",
+    "String",
+    "FixedString",
+    "Date",
+    "Date32",
+    "DateTime",
+    "DateTime64",
+    "UUID",
+    "IPv4",
+    "IPv6",
+    "Enum8",
+    "Enum16",
+    "Array",
+    "Map",
+    "Tuple",
+    "Nested",
+    "Nullable",
+    "LowCardinality",
+    "SimpleAggregateFunction",
+    "AggregateFunction",
+    "Point",
+    "Ring",
+    "Polygon",
+    "MultiPolygon",
+    "JSON",
+  ],
+  manticoresearch: ["text", "string", "int", "bit", "bigint", "bool", "timestamp", "float", "json", "float_vector", "multi", "mva"],
+  informix: [
+    "smallint",
+    "integer",
+    "int",
+    "bigint",
+    "int8",
+    "serial",
+    "serial8",
+    "bigserial",
+    "decimal",
+    "numeric",
+    "money",
+    "smallfloat",
+    "float",
+    "real",
+    "char",
+    "varchar",
+    "lvarchar",
+    "nchar",
+    "nvarchar",
+    "text",
+    "clob",
+    "byte",
+    "blob",
+    "boolean",
+    "date",
+    "datetime year to second",
+    "datetime year to fraction",
+    "interval day to second",
+  ],
+  questdb: ["boolean", "ipv4", "byte", "short", "char", "int", "float", "symbol", "varchar", "string", "long", "date", "timestamp", "timestamp_ns", "double", "uuid", "binary", "long256", "geohash", "array", "interval", "decimal"],
+  xugu: ["BOOLEAN", "INTEGER", "SMALLINT", "BIGINT", "FLOAT", "NUMERIC", "CHAR", "VARCHAR", "CLOB", "DATE", "TIME", "TIMESTAMP", "BINARY", "VARBINARY", "BLOB", "XML", "BOOL", "INT", "SHORT", "LONGINT", "LONG", "REAL", "DECIMAL", "TEXT", "NCHAR", "NVARCHAR", "NVARCHAR2"],
+};
+
+const DATA_TYPE_OPTION_ALIASES: Partial<Record<DatabaseType, string>> = {
+  doris: "mysql",
+  starrocks: "mysql",
+  goldendb: "mysql",
+  sundb: "mysql",
+  oscar: "oracle",
+  gbase: "mysql",
+  gaussdb: "postgres",
+  kwdb: "postgres",
+  opengauss: "postgres",
+  questdb: "questdb",
+  redshift: "postgres",
+  highgo: "postgres",
+  vastbase: "postgres",
+  kingbase: "postgres",
+  dameng: "oracle",
+  "oceanbase-oracle": "oracle",
+  iris: "oracle",
+};
+
+export function getDataTypeOptions(dbType: DatabaseType | undefined): string[] {
+  const key = dbType ? (DATA_TYPE_OPTION_ALIASES[dbType] ?? dbType) : "";
+  return DATA_TYPE_OPTIONS[key] ?? [];
+}
+
+export function isMysqlEnumDataType(dbType: DatabaseType | undefined, dataType: string): boolean {
+  return dbType === "mysql" && splitDataType(dataType).baseType.trim().toLowerCase() === "enum";
+}
+
+export function mysqlEnumDataType(values: readonly string[]): string {
+  // Match MySQL's canonical ENUM literal escaping, including values returned by SHOW CREATE TABLE.
+  const literals = values.map((value) => `'${value.replace(/\\/g, "\\\\").replace(/'/g, "''")}'`);
+  return `enum(${literals.join(",")})`;
+}
+
+export interface ColumnEditorControls {
+  length: boolean;
+  nullable: boolean;
+  primaryKey: boolean;
+  defaultValue: boolean;
+  comment: boolean;
+}
+
+const DEFAULT_COLUMN_EDITOR_CONTROLS: ColumnEditorControls = {
+  length: true,
+  nullable: true,
+  primaryKey: true,
+  defaultValue: true,
+  comment: true,
+};
+
+export function getColumnEditorControls(dbType: DatabaseType | undefined): ColumnEditorControls {
+  if (dbType === "manticoresearch") {
+    return {
+      length: true,
+      nullable: false,
+      primaryKey: false,
+      defaultValue: false,
+      comment: false,
+    };
+  }
+  return DEFAULT_COLUMN_EDITOR_CONTROLS;
+}
+
+export function isProtectedManticoreIdColumn(dbType: DatabaseType | undefined, columnName: string): boolean {
+  return dbType === "manticoresearch" && columnName.trim().toLowerCase() === "id";
+}
+
+export function canEditManticoreColumnProperties(dbType: DatabaseType | undefined, hasOriginalColumn: boolean): boolean {
+  return dbType === "manticoresearch" && !hasOriginalColumn;
+}
+
+export const DEFAULT_TYPE_LENGTHS: Record<string, string> = {
+  tinyint: "4",
+  "tinyint unsigned": "4",
+  smallint: "6",
+  "smallint unsigned": "6",
+  mediumint: "9",
+  "mediumint unsigned": "9",
+  int: "11",
+  "int unsigned": "11",
+  integer: "11",
+  "integer unsigned": "11",
+  int4: "11",
+  bigint: "20",
+  "bigint unsigned": "20",
+  int8: "20",
+  float: "10,2",
+  real: "10,2",
+  "double precision": "10,2",
+  double: "10,2",
+  decimal: "10,0",
+  numeric: "10,0",
+  number: "10,0",
+  char: "1",
+  character: "1",
+  varchar: "255",
+  "character varying": "255",
+  varchar2: "255",
+  nvarchar2: "255",
+  nvarchar: "255",
+  nchar: "1",
+  varbinary: "255",
+  binary: "1",
+  bit: "1",
+  year: "4",
+};
+
+export const QUESTDB_TYPE_LENGTHS: Record<string, string> = {
+  geohash: "8c",
+  decimal: "10,2",
+};
+
+export const SQLSERVER_TYPE_LENGTHS: Record<string, string> = {
+  decimal: "10,0",
+  numeric: "10,0",
+  float: "53",
+  char: "1",
+  nchar: "1",
+  varchar: "255",
+  nvarchar: "255",
+  binary: "1",
+  varbinary: "255",
+};
+
+export const DEFAULT_TYPE_LENGTH_DISABLES: string[] = [];
+
+export const POSTGRES_TYPE_LENGTH_DISABLES: string[] = [
+  "bigint",
+  "int8",
+  "bigserial",
+  "serial8",
+  "boolean",
+  "bool",
+  "box",
+  "bytea",
+  "cidr",
+  "circle",
+  "date",
+  "double precision",
+  "float",
+  "float8",
+  "inet",
+  "integer",
+  "int",
+  "int4",
+  "json",
+  "jsonb",
+  "line",
+  "lseg",
+  "macaddr",
+  "macaddr8",
+  "money",
+  "path",
+  "pg_lsn",
+  "pg_snapshot",
+  "point",
+  "polygon",
+  "real",
+  "float4",
+  "smallint",
+  "int2",
+  "smallserial",
+  "serial2",
+  "serial",
+  "serial4",
+  "text",
+  "tsquery",
+  "tsvector",
+  "txid_snapshot",
+  "uuid",
+  "xml",
+];
+
+export const ORACLE_LIKE_TYPE_LENGTH_DISABLES: string[] = ["binary_double", "binary_float", "bigint", "boolean", "bool", "byte", "date", "double", "double precision", "float", "integer", "int", "long", "long raw", "nclob", "real", "smallint", "text", "tinyint"];
+
+export const SQLSERVER_TYPE_LENGTH_DISABLES: string[] = ["bigint", "bit", "date", "datetime", "image", "int", "integer", "money", "ntext", "real", "smalldatetime", "smallint", "smallmoney", "sql_variant", "text", "timestamp", "tinyint", "uniqueidentifier", "xml"];
+
+export function parseExtraToColumnExtra(extra: string | null | undefined, databaseType?: DatabaseType): ColumnExtra {
+  const result: ColumnExtra = {};
+  if (!extra) return result;
+  const lower = extra.toLowerCase().trim();
+  if (!lower) return result;
+
+  if (databaseType === "mysql") {
+    if (lower.includes("auto_increment")) {
+      result.autoIncrement = true;
+    }
+    if (lower.includes("on update current_timestamp")) {
+      result.onUpdateCurrentTimestamp = true;
+    }
+  } else if (databaseType === "postgres" || databaseType === "gaussdb" || databaseType === "kwdb" || databaseType === "opengauss" || databaseType === "questdb" || databaseType === "highgo" || databaseType === "vastbase" || databaseType === "kingbase") {
+    const identityMatch = lower.match(/generated\s+(by\s+default|always)\s+as\s+identity/i);
+    if (identityMatch) {
+      const sequenceMatch = lower.match(/start\s+with\s*(-?\d+)\s+increment\s+by\s*(-?\d+)/i);
+      result.identity = {
+        generation: identityMatch[1].toUpperCase() === "BY DEFAULT" ? "BY DEFAULT" : "ALWAYS",
+      };
+      if (sequenceMatch) {
+        result.identity.seed = Number(sequenceMatch[1]);
+        result.identity.increment = Number(sequenceMatch[2]);
+      }
+    }
+  } else if (databaseType === "sqlserver") {
+    if (lower.includes("identity")) {
+      result.autoIncrement = true;
+      const identityMatch = lower.match(/identity\s*\(\s*(-?\d+)\s*,\s*(-?\d+)\s*\)/i);
+      if (identityMatch) {
+        result.identity = {
+          seed: Number(identityMatch[1]),
+          increment: Number(identityMatch[2]),
+        };
+      }
+    }
+  } else if (databaseType === "dameng") {
+    if (lower.includes("identity")) {
+      result.autoIncrement = true;
+      const identityMatch = lower.match(/identity\s*\(\s*(-?\d+)\s*,\s*(-?\d+)\s*\)/i);
+      if (identityMatch) {
+        result.identity = {
+          seed: Number(identityMatch[1]),
+          increment: Number(identityMatch[2]),
+        };
+      }
+    }
+  } else if (databaseType === "manticoresearch") {
+    const tokens = new Set(lower.split(/\s+/).filter(Boolean));
+    if (tokens.has("indexed")) result.manticoreIndexed = true;
+    if (tokens.has("stored")) result.manticoreStored = true;
+    if (tokens.has("attribute")) result.manticoreAttribute = true;
+    if (/secondary_index\s*=\s*['"]?1['"]?/.test(lower)) result.manticoreSecondaryIndex = true;
+  }
+
+  return result;
+}
+
+const MANTICORE_COLUMN_PROPERTY_TOKENS = new Set(["indexed", "stored", "attribute"]);
+
+function splitManticoreDdlColumnLine(line: string): { name: string; dataType: string; extra: string } | null {
+  const trimmed = line.trim().replace(/,$/, "").trim();
+  if (!trimmed || trimmed.startsWith(")") || trimmed.startsWith("(")) return null;
+
+  let name = "";
+  let rest = "";
+  const quoted = trimmed.match(/^`((?:``|[^`])+)`\s+(.+)$/);
+  if (quoted) {
+    name = quoted[1]!.replace(/``/g, "`");
+    rest = quoted[2]!.trim();
+  } else {
+    const plain = trimmed.match(/^([A-Za-z_][\w$]*)\s+(.+)$/);
+    if (!plain) return null;
+    name = plain[1]!;
+    rest = plain[2]!.trim();
+  }
+
+  const parts = rest.split(/\s+/).filter(Boolean);
+  const dataType = parts.shift() ?? "";
+  const properties = parts.filter((part) => {
+    const normalized = part.toLowerCase();
+    return MANTICORE_COLUMN_PROPERTY_TOKENS.has(normalized) || /^secondary_index\s*=/.test(normalized);
+  });
+  if (!name || !dataType || properties.length === 0) return null;
+
+  return { name, dataType, extra: properties.join(" ") };
+}
+
+export function applyManticoreDdlColumnExtras(columns: ColumnInfo[], ddl: string): ColumnInfo[] {
+  if (!ddl.trim()) return columns;
+  const extrasByColumn = new Map<string, { dataType: string; extra: string }>();
+  for (const line of ddl.split(/\r?\n/)) {
+    const parsed = splitManticoreDdlColumnLine(line);
+    if (parsed) extrasByColumn.set(parsed.name.toLowerCase(), { dataType: parsed.dataType, extra: parsed.extra });
+  }
+  if (extrasByColumn.size === 0) return columns;
+
+  return columns.map((column) => {
+    const ddlColumn = extrasByColumn.get(column.name.toLowerCase());
+    if (!ddlColumn) return column;
+    const existingExtra = column.extra?.trim();
+    return {
+      ...column,
+      data_type: ddlColumn.dataType || column.data_type,
+      extra: existingExtra ? `${existingExtra} ${ddlColumn.extra}` : ddlColumn.extra,
+    };
+  });
+}
+
+function isPostgresTextualType(dataType: string): boolean {
+  const baseType = dataType.split("(")[0]?.trim().replace(/\s+/g, " ").toLowerCase() ?? "";
+  return ["char", "character", "varchar", "character varying", "text", "bpchar", "name", "json", "jsonb", "xml", "bytea", "uuid"].includes(baseType);
+}
+
+function stripPostgresStringDefaultCast(defaultValue: string, dataType: string): string {
+  if (!isPostgresTextualType(dataType)) return defaultValue;
+  const trimmed = defaultValue.trim();
+  const match = trimmed.match(/^('(?:''|[^'])*')::\s*((?:character\s+varying)|character|varchar|char|text|bpchar|name|jsonb?|xml|bytea|uuid)(?:\s*\(\s*\d+\s*\))?$/i);
+  return match?.[1] ?? defaultValue;
+}
+
+function isWrappedByOuterParens(value: string): boolean {
+  if (value.length < 2 || value[0] !== "(" || value[value.length - 1] !== ")") return false;
+
+  let depth = 0;
+  let inString = false;
+  let inBracketIdentifier = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (inString) {
+      if (char === "'" && value[index + 1] === "'") {
+        index += 1;
+      } else if (char === "'") {
+        inString = false;
+      }
+      continue;
+    }
+    if (inBracketIdentifier) {
+      if (char === "]") inBracketIdentifier = false;
+      continue;
+    }
+    if (char === "'") {
+      inString = true;
+      continue;
+    }
+    if (char === "[") {
+      inBracketIdentifier = true;
+      continue;
+    }
+    if (char === "(") {
+      depth += 1;
+    } else if (char === ")") {
+      depth -= 1;
+      if (depth < 0) return false;
+      if (depth === 0 && index < value.length - 1) return false;
+    }
+  }
+  return depth === 0;
+}
+
+function stripSqlServerDefaultOuterParens(defaultValue: string): string {
+  let value = defaultValue.trim();
+  while (isWrappedByOuterParens(value)) {
+    value = value.slice(1, -1).trim();
+  }
+  return value;
+}
+
+function columnDefaultForEditor(column: ColumnInfo, databaseType?: DatabaseType): string {
+  const defaultValue = column.column_default ?? "";
+  if (databaseType === "postgres") return stripPostgresStringDefaultCast(defaultValue, column.data_type);
+  if (databaseType === "sqlserver") return stripSqlServerDefaultOuterParens(defaultValue);
+  return defaultValue;
+}
+
+export function createColumnDrafts(columns: ColumnInfo[], databaseType?: DatabaseType): EditableStructureColumn[] {
+  return columns.map((column, index) => {
+    const defaultValue = columnDefaultForEditor(column, databaseType);
+    const enumValues = isMysqlEnumDataType(databaseType, column.data_type) ? [...(column.enum_values ?? [])] : undefined;
+    const dataType = enumValues?.length ? mysqlEnumDataType(enumValues) : column.data_type;
+    return {
+      id: `existing:${column.name}`,
+      name: column.name,
+      dataType,
+      enumValues,
+      isNullable: column.is_nullable,
+      defaultValue,
+      comment: column.comment ?? "",
+      isPrimaryKey: column.is_primary_key,
+      characterSet: column.character_set ?? "",
+      collation: column.collation ?? "",
+      extra: parseExtraToColumnExtra(column.extra, databaseType),
+      original: { ...column, data_type: dataType, column_default: column.column_default === null ? null : defaultValue },
+      originalPosition: index,
+      markedForDrop: false,
+    };
+  });
+}
+
+function existingColumnIdName(id: string): string | undefined {
+  const prefix = "existing:";
+  return id.startsWith(prefix) ? id.slice(prefix.length) : undefined;
+}
+
+function isNewColumnDraftId(id: string): boolean {
+  return id.startsWith("new:");
+}
+
+function uniqueNames(names: Array<string | undefined>): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const name of names) {
+    if (!name) continue;
+    if (seen.has(name)) continue;
+    seen.add(name);
+    result.push(name);
+  }
+  return result;
+}
+
+function findColumnDraftByName(columns: EditableStructureColumn[], names: string[], usedIndexes: Set<number>): number | undefined {
+  for (const name of names) {
+    const exactIndex = columns.findIndex((column, index) => !usedIndexes.has(index) && column.name === name);
+    if (exactIndex >= 0) return exactIndex;
+  }
+
+  for (const name of names) {
+    const lowerName = name.toLowerCase();
+    const matches = columns.map((column, index) => ({ column, index })).filter(({ column, index }) => !usedIndexes.has(index) && column.name.toLowerCase() === lowerName);
+    if (matches.length === 1) return matches[0]!.index;
+  }
+
+  return undefined;
+}
+
+export function rehydrateColumnDraftsFromMetadata(draftColumns: EditableStructureColumn[], columns: ColumnInfo[], databaseType?: DatabaseType): EditableStructureColumn[] {
+  const metadataDrafts = createColumnDrafts(columns, databaseType);
+  if (!metadataDrafts.length) return draftColumns;
+  if (!draftColumns.length) return metadataDrafts;
+
+  const usedMetadataIndexes = new Set<number>();
+  const nextColumns = draftColumns.map((column) => {
+    if (!column.original && isNewColumnDraftId(column.id)) return column;
+
+    const needsHydration = !column.original || column.originalPosition === undefined;
+    const candidates = uniqueNames([column.original?.name, existingColumnIdName(column.id), column.name]);
+    const metadataIndex = findColumnDraftByName(metadataDrafts, candidates, usedMetadataIndexes);
+    if (metadataIndex === undefined) return column;
+    usedMetadataIndexes.add(metadataIndex);
+    const metadataDraft = metadataDrafts[metadataIndex]!;
+    const shouldHydrateEnum = isMysqlEnumDataType(databaseType, column.dataType) && column.enumValues === undefined && metadataDraft.enumValues !== undefined;
+    if (!needsHydration && !shouldHydrateEnum) return column;
+
+    return {
+      ...column,
+      dataType: shouldHydrateEnum ? metadataDraft.dataType : column.dataType,
+      enumValues: column.enumValues ?? metadataDraft.enumValues,
+      original: shouldHydrateEnum ? metadataDraft.original : (column.original ?? metadataDraft.original),
+      originalPosition: column.originalPosition ?? metadataDraft.originalPosition,
+    };
+  });
+
+  if (usedMetadataIndexes.size === 0) {
+    return [...metadataDrafts, ...draftColumns];
+  }
+
+  const missingMetadataDrafts = metadataDrafts.filter((_, index) => !usedMetadataIndexes.has(index));
+  return [...nextColumns, ...missingMetadataDrafts];
+}
+
+export function createIndexDrafts(indexes: IndexInfo[]): EditableStructureIndex[] {
+  return indexes.map((index) => ({
+    id: `existing:${index.name}`,
+    name: index.name,
+    columns: [...index.columns],
+    nameEdited: true,
+    isUnique: index.is_unique,
+    isPrimary: index.is_primary,
+    filter: index.filter ?? "",
+    indexType: index.index_type ?? "",
+    includedColumns: index.included_columns ? [...index.included_columns] : [],
+    comment: index.comment ?? "",
+    original: index,
+    markedForDrop: false,
+  }));
+}
+
+export function createForeignKeyDrafts(foreignKeys: ForeignKeyInfo[]): EditableStructureForeignKey[] {
+  const groups = new Map<string, ForeignKeyInfo[]>();
+  for (const foreignKey of foreignKeys) {
+    const key = [foreignKey.name, foreignKey.ref_schema ?? "", foreignKey.ref_table, foreignKey.on_update ?? "", foreignKey.on_delete ?? ""].join("\u0000");
+    groups.set(key, [...(groups.get(key) ?? []), foreignKey]);
+  }
+
+  return [...groups.values()].map((group, index) => {
+    const first = group[0]!;
+    const original = {
+      ...first,
+      column: group.map((foreignKey) => foreignKey.column).join(", "),
+      ref_column: group.map((foreignKey) => foreignKey.ref_column).join(", "),
+    };
+    return {
+      id: `existing:${first.name}:${index}`,
+      name: first.name,
+      column: original.column,
+      refSchema: first.ref_schema ?? "",
+      refTable: first.ref_table,
+      refColumn: original.ref_column,
+      onUpdate: first.on_update ?? "",
+      onDelete: first.on_delete ?? "",
+      original,
+      markedForDrop: false,
+    };
+  });
+}
+
+export function createTriggerDrafts(triggers: TriggerInfo[]): EditableStructureTrigger[] {
+  return triggers.map((trigger) => ({
+    id: `existing:${trigger.name}`,
+    name: trigger.name,
+    timing: trigger.timing,
+    event: trigger.event,
+    statement: trigger.statement ?? "",
+    original: trigger,
+    markedForDrop: false,
+  }));
+}
+
+export function toColumnNames(columns: string[]): string {
+  return columns.join(", ");
+}
+
+const AUTO_INDEX_NAME_MAX_LENGTH = 63;
+
+function normalizeIndexNamePart(value: string): string {
+  const trimmed = value.trim();
+  const unquoted = (trimmed.startsWith("[") && trimmed.endsWith("]")) || (trimmed.startsWith("`") && trimmed.endsWith("`")) || (trimmed.startsWith('"') && trimmed.endsWith('"')) ? trimmed.slice(1, -1) : trimmed;
+  return unquoted
+    .trim()
+    .replace(/[^a-zA-Z0-9]+/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .toUpperCase();
+}
+
+function truncateIndexName(value: string, maxLength = AUTO_INDEX_NAME_MAX_LENGTH): string {
+  if (value.length <= maxLength) return value;
+  const suffix = "_IDX";
+  if (!value.endsWith(suffix)) return value.slice(0, maxLength).replace(/_+$/g, "");
+  return `${value.slice(0, maxLength - suffix.length).replace(/_+$/g, "")}${suffix}`;
+}
+
+export function generateIndexName(tableName: string, columns: string[], maxLength = AUTO_INDEX_NAME_MAX_LENGTH): string {
+  const parts = [tableName, ...columns].map(normalizeIndexNamePart).filter(Boolean);
+  if (parts.length === 0) return "";
+  return truncateIndexName(`${parts.join("_")}_IDX`, maxLength);
+}
+
+export function generateUniqueIndexName(tableName: string, columns: string[], existingNames: Iterable<string>, maxLength = AUTO_INDEX_NAME_MAX_LENGTH): string {
+  const base = generateIndexName(tableName, columns, maxLength);
+  if (!base) return "";
+
+  const taken = new Set([...existingNames].map((name) => name.trim().toLowerCase()).filter(Boolean));
+  if (!taken.has(base.toLowerCase())) return base;
+
+  for (let counter = 2; counter < 10_000; counter++) {
+    const suffix = `_${counter}`;
+    const stem = base.length + suffix.length <= maxLength ? base : base.slice(0, maxLength - suffix.length).replace(/_+$/g, "");
+    const candidate = `${stem}${suffix}`;
+    if (!taken.has(candidate.toLowerCase())) return candidate;
+  }
+  return base;
+}
+
+export function splitDataType(raw: string): { baseType: string; params: string } {
+  const trimmed = raw.trim();
+  const parenIdx = trimmed.indexOf("(");
+  if (parenIdx === -1) return { baseType: trimmed, params: "" };
+  const closeIdx = trimmed.lastIndexOf(")");
+  const baseTypePrefix = trimmed.slice(0, parenIdx).trim();
+  const params = trimmed.slice(parenIdx + 1, closeIdx).trim();
+  const suffix = trimmed
+    .slice(closeIdx + 1)
+    .trim()
+    .replace(/\s+/g, " ");
+  const baseType = /^(?:signed|unsigned|zerofill)(?:\s+(?:signed|unsigned|zerofill))*$/i.test(suffix) ? `${baseTypePrefix} ${suffix}`.trim() : baseTypePrefix;
+  return { baseType, params };
+}
+
+/** MySQL character/text types that accept `CHARACTER SET` and `COLLATE`. */
+const MYSQL_CHARACTER_DATA_TYPES = new Set(["char", "varchar", "tinytext", "text", "mediumtext", "longtext", "enum", "set"]);
+
+export function isMysqlCharacterDataType(dataType: string): boolean {
+  const { baseType } = splitDataType(dataType);
+  return MYSQL_CHARACTER_DATA_TYPES.has(baseType.trim().replace(/\s+/g, " ").toLowerCase());
+}
+
+export function isSqlServerIdentityCompatibleDataType(rawDataType: string): boolean {
+  const { baseType, params } = splitDataType(rawDataType);
+  const normalized = baseType.trim().replace(/\s+/g, " ").toLowerCase();
+  if (["tinyint", "smallint", "int", "integer", "bigint"].includes(normalized)) return true;
+  if (normalized !== "decimal" && normalized !== "numeric") return false;
+  const normalizedParams = params.replace(/\s+/g, "");
+  if (!normalizedParams) return true;
+  const parts = normalizedParams.split(",");
+  if (parts.length === 1) return /^\d+$/.test(parts[0] ?? "");
+  if (parts.length !== 2) return false;
+  const [precision, scale] = parts;
+  return /^\d+$/.test(precision ?? "") && scale === "0";
+}
+
+export function isDamengIdentityCompatibleDataType(rawDataType: string): boolean {
+  const { baseType, params } = splitDataType(rawDataType);
+  const normalized = baseType.trim().replace(/\s+/g, " ").toLowerCase();
+  if (["tinyint", "smallint", "int", "integer", "bigint"].includes(normalized)) return true;
+  if (!["number", "numeric", "decimal", "dec"].includes(normalized)) return false;
+  const normalizedParams = params.replace(/\s+/g, "");
+  if (!normalizedParams) return true;
+  const parts = normalizedParams.split(",");
+  if (parts.length === 1) return /^\d+$/.test(parts[0] ?? "");
+  if (parts.length !== 2) return false;
+  const [precision, scale] = parts;
+  return /^\d+$/.test(precision ?? "") && scale === "0";
+}
+
+export function combineDataType(baseType: string, params: string): string {
+  const type = baseType.trim();
+  const p = params.trim();
+  if (!type) return "";
+  if (!p) return type;
+  return `${type}(${p})`;
+}
+
+export function combineDataTypeForDatabase(dbType: DatabaseType | undefined, baseType: string, params: string): string {
+  if (isDataTypeLengthDisabled(dbType, baseType)) {
+    return baseType;
+  }
+  const normalizedParams = normalizeDataTypeParams(dbType, baseType, params);
+  const mysqlType = combineMysqlNumericAttributeType(dbType, baseType, normalizedParams);
+  if (mysqlType) return mysqlType;
+  return combineDataType(baseType, normalizedParams);
+}
+
+export function dataTypeLengthInputValue(dbType: DatabaseType | undefined, rawDataType: string): string {
+  const parsed = splitDataType(rawDataType);
+  return isDataTypeLengthDisabled(dbType, parsed.baseType) ? "" : parsed.params;
+}
+
+export function normalizeDataTypeParams(dbType: DatabaseType | undefined, baseType: string, params: string): string {
+  const p = params.trim();
+  if (!p) return "";
+  if (!isTemporalPrecisionType(dbType, baseType)) return p;
+  return isValidTemporalPrecision(dbType, p) ? p : "";
+}
+
+function isTemporalPrecisionType(dbType: DatabaseType | undefined, baseType: string): boolean {
+  const normalized = baseType.trim().replace(/\s+/g, " ").toLowerCase();
+  switch (dbType) {
+    case "mysql":
+    case "doris":
+    case "starrocks":
+    case "goldendb":
+    case "sundb":
+      return ["time", "datetime", "timestamp"].includes(normalized);
+    case "postgres":
+    case "gaussdb":
+    case "kwdb":
+    case "opengauss":
+    case "highgo":
+    case "vastbase":
+    case "kingbase":
+    case "redshift":
+      return ["time", "time without time zone", "time with time zone", "timestamp", "timestamp without time zone", "timestamp with time zone"].includes(normalized);
+    case "sqlserver":
+      return ["time", "datetime2", "datetimeoffset"].includes(normalized);
+    case "oracle":
+    case "dameng":
+    case "oceanbase-oracle":
+      return ["timestamp", "timestamp with time zone", "timestamp with local time zone"].includes(normalized);
+    case "questdb":
+      return ["timestamp"].includes(normalized);
+    default:
+      return false;
+  }
+}
+
+function combineMysqlNumericAttributeType(dbType: DatabaseType | undefined, baseType: string, params: string): string | null {
+  if (!params || !isMysqlLikeStructureType(dbType)) return null;
+  const parts = baseType.trim().replace(/\s+/g, " ").split(" ").filter(Boolean);
+  const typeName = parts[0]?.toLowerCase();
+  if (!typeName || !["tinyint", "smallint", "mediumint", "int", "integer", "bigint", "real", "double", "float", "decimal", "numeric"].includes(typeName)) return null;
+  const attrIndex = parts.findIndex((part) => ["signed", "unsigned", "zerofill"].includes(part.toLowerCase()));
+  if (attrIndex === -1) return null;
+  if (!parts.slice(attrIndex).every((part) => ["signed", "unsigned", "zerofill"].includes(part.toLowerCase()))) return null;
+  return `${parts.slice(0, attrIndex).join(" ")}(${params}) ${parts.slice(attrIndex).join(" ")}`;
+}
+
+function isMysqlLikeStructureType(dbType: DatabaseType | undefined): boolean {
+  return dbType === "mysql" || dbType === "doris" || dbType === "starrocks" || dbType === "goldendb" || dbType === "sundb" || dbType === "databend";
+}
+
+function isOracleLikeStructureType(dbType: DatabaseType | undefined): boolean {
+  return dbType === "oracle" || dbType === "dameng" || dbType === "oceanbase-oracle" || dbType === "iris" || dbType === "yashandb" || dbType === "xugu";
+}
+
+function isValidTemporalPrecision(dbType: DatabaseType | undefined, params: string): boolean {
+  if (!/^\d+$/.test(params)) return false;
+  const value = Number(params);
+  const max = dbType === "oracle" || dbType === "dameng" || dbType === "oceanbase-oracle" ? 9 : 6;
+  return Number.isInteger(value) && value >= 0 && value <= max && String(value) === params;
+}
+
+export interface DataTypeDefaultOptions {
+  /**
+   * Native MySQL profiles use MySQL 8-safe defaults. Compatibility profiles
+   * retain their existing DDL defaults because their server/version is unknown.
+   */
+  omitMysqlDeprecatedDefaults?: boolean;
+}
+
+export function getDefaultLengthForType(_dbType: DatabaseType | undefined, baseType: string, options: DataTypeDefaultOptions = {}): string {
+  const key = baseType.trim().toLowerCase();
+  if (_dbType === "mysql" && options.omitMysqlDeprecatedDefaults && isMysqlDeprecatedDefaultParameterType(key)) return "";
+  if (_dbType === "sqlite" || _dbType === "rqlite" || _dbType === "turso") {
+    return "";
+  } else if (_dbType === "questdb") {
+    return QUESTDB_TYPE_LENGTHS[key] ?? "";
+  } else if (_dbType === "sqlserver") {
+    return SQLSERVER_TYPE_LENGTHS[key] ?? "";
+  } else {
+    return DEFAULT_TYPE_LENGTHS[key] ?? "";
+  }
+}
+
+/** Default data type for a newly added structure-editor column. */
+export function defaultNewColumnDataType(dbType: DatabaseType | undefined, dataTypeOptions: readonly string[] = []): string {
+  if (dbType === "manticoresearch") {
+    const baseType = dataTypeOptions[0] ?? "text";
+    return combineDataTypeForDatabase(dbType, baseType, getDefaultLengthForType(dbType, baseType));
+  }
+  return dbType === "sqlite" ? "text" : "varchar(255)";
+}
+
+function isMysqlDeprecatedDefaultParameterType(baseType: string): boolean {
+  const typeName = baseType.split(/\s+/)[0];
+  return ["tinyint", "smallint", "mediumint", "int", "integer", "bigint", "float", "double", "real"].includes(typeName ?? "");
+}
+
+export function isDataTypeLengthDisabled(_dbType: DatabaseType | undefined, baseType: string): boolean {
+  const key = baseType.trim().toLowerCase();
+  if (_dbType === "questdb") {
+    return key !== "geohash" && key !== "decimal";
+  } else if (_dbType === "manticoresearch") {
+    return key !== "bit" && key !== "float_vector";
+  } else if (_dbType === "postgres" || _dbType === "gaussdb" || _dbType === "kwdb" || _dbType === "opengauss" || _dbType === "highgo" || _dbType === "vastbase" || _dbType === "kingbase") {
+    return POSTGRES_TYPE_LENGTH_DISABLES.includes(key);
+  } else if (isOracleLikeStructureType(_dbType)) {
+    // Dameng/Oracle integer aliases have fixed precision; MySQL-style display widths generate invalid DDL.
+    return ORACLE_LIKE_TYPE_LENGTH_DISABLES.includes(key);
+  } else if (_dbType === "sqlserver") {
+    // SQL Server exact integer and legacy LOB types do not accept MySQL-style display widths.
+    return SQLSERVER_TYPE_LENGTH_DISABLES.includes(key);
+  } else if (isMysqlLikeStructureType(_dbType)) {
+    return key === "enum" || key === "set";
+  } else {
+    return DEFAULT_TYPE_LENGTH_DISABLES.includes(key);
+  }
+}
+
+export function buildStructureTargetLabel(connectionName: string | undefined, database: string | undefined, schema: string | undefined, tableName: string | undefined): string {
+  const parts = [connectionName, database];
+  if (schema && schema !== database) parts.push(schema);
+  if (tableName) parts.push(tableName);
+  return parts.filter(Boolean).join(" / ");
+}
diff --git a/apps/desktop/src/lib/table/tableTree.ts b/apps/desktop/src/lib/table/tableTree.ts
new file mode 100644
index 0000000..38abbe0
--- /dev/null
+++ b/apps/desktop/src/lib/table/tableTree.ts
@@ -0,0 +1,711 @@
+import type { ObjectInfo, TableInfo, TreeNode, TreeNodeType } from "@/types/database";
+import { normalizeSidebarObjectKind, type SidebarObjectKind } from "@/lib/database/databaseObjectCapabilities";
+
+const databaseObjectNameCollator = new Intl.Collator(undefined, { numeric: true, sensitivity: "base" });
+
+export function normalizeDatabaseObjectName(name: string): string {
+  return name.trim();
+}
+
+export function buildTableTreeNodes({ nodeId, connectionId, database, schema, tables, catalog }: { nodeId: string; connectionId: string; database: string; schema?: string; tables: TableInfo[]; catalog?: string }): TreeNode[] {
+  const entries = tables.flatMap((table) => {
+    const name = normalizeDatabaseObjectName(table.name);
+    if (!name) return [];
+    const objectType = normalizeObjectType(table.table_type);
+    const childSchema = schema;
+    return [
+      makeTableTreeEntry({
+        nodeId,
+        connectionId,
+        database,
+        schema: childSchema,
+        includeSchemaInId: false,
+        name,
+        objectType,
+        tableType: table.table_type,
+        comment: table.comment,
+        parentSchema: table.parent_schema,
+        parentName: table.parent_name,
+        catalog,
+      }),
+    ];
+  });
+
+  return buildPartitionTree(entries, connectionId, database);
+}
+
+type TableTreeEntry = {
+  key: string;
+  objectType: DatabaseObjectTreeKind;
+  schema?: string;
+  parentSchema?: string;
+  parentName?: string;
+  node: TreeNode;
+};
+
+function makeTableTreeEntry({
+  nodeId,
+  connectionId,
+  database,
+  schema,
+  includeSchemaInId,
+  name,
+  objectType,
+  tableType,
+  comment,
+  parentSchema,
+  parentName,
+  catalog,
+}: {
+  nodeId: string;
+  connectionId: string;
+  database: string;
+  schema?: string;
+  includeSchemaInId?: boolean;
+  name: string;
+  objectType: DatabaseObjectTreeKind;
+  tableType?: string;
+  comment?: string | null;
+  parentSchema?: string | null;
+  parentName?: string | null;
+  catalog?: string;
+}): TableTreeEntry {
+  const normalizedParentSchema = parentSchema ? normalizeDatabaseObjectName(parentSchema) : undefined;
+  const normalizedParentName = parentName ? normalizeDatabaseObjectName(parentName) : undefined;
+  const nodeIdSchemaSuffix = includeSchemaInId !== false && schema ? `${schema}:` : "";
+  const node: TreeNode = {
+    id: `${nodeId}:${nodeIdSchemaSuffix}${name}`,
+    label: name,
+    type: objectType === "VIEW" ? ("view" as const) : objectType === "MATERIALIZED_VIEW" ? ("materialized_view" as const) : ("table" as const),
+    tableType,
+    comment,
+    connectionId,
+    database,
+    schema,
+    catalog,
+    isExpanded: false,
+    children: [],
+  };
+  if (normalizedParentSchema) node.partitionParentSchema = normalizedParentSchema;
+  if (normalizedParentName) node.partitionParentName = normalizedParentName;
+
+  return {
+    key: objectIdentityKey(objectType, schema, name),
+    objectType,
+    schema,
+    parentSchema: normalizedParentSchema,
+    parentName: normalizedParentName,
+    node,
+  };
+}
+
+function objectIdentityKey(objectType: string, schema: string | undefined, name: string) {
+  return `${objectType}\0${(schema || "").toLowerCase()}\0${name.toLowerCase()}`;
+}
+
+type PrefixSortInfo = {
+  rootName: string;
+  leadingSegments: number;
+};
+
+function nameSegments(name: string): string[] {
+  return name.toLowerCase().split("_").filter(Boolean);
+}
+
+function findSubsequence(haystack: readonly string[], needle: readonly string[]): number {
+  if (!needle.length || needle.length > haystack.length) return -1;
+
+  for (let start = 0; start <= haystack.length - needle.length; start += 1) {
+    let matched = true;
+    for (let offset = 0; offset < needle.length; offset += 1) {
+      if (haystack[start + offset] !== needle[offset]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) return start;
+  }
+
+  return -1;
+}
+
+function buildPrefixSortIndex(names: readonly string[]): Map<string, PrefixSortInfo> {
+  const segmentsByName = new Map<string, string[]>();
+  const nameBySegmentKey = new Map<string, string>();
+  for (const name of names) {
+    const normalized = name.toLowerCase();
+    if (segmentsByName.has(normalized)) continue;
+
+    const segments = nameSegments(name);
+    segmentsByName.set(normalized, segments);
+    const segmentKey = segments.join("_");
+    if (!nameBySegmentKey.has(segmentKey)) nameBySegmentKey.set(segmentKey, normalized);
+  }
+
+  const resolved = new Map<string, PrefixSortInfo>();
+
+  const resolve = (name: string): PrefixSortInfo => {
+    const cached = resolved.get(name);
+    if (cached) return cached;
+
+    const segments = segmentsByName.get(name) ?? [];
+    let bestAnchor: { name: string; segmentCount: number; start: number } | undefined;
+
+    for (let segmentCount = segments.length - 1; segmentCount > 0 && !bestAnchor; segmentCount -= 1) {
+      for (let start = 0; start <= segments.length - segmentCount; start += 1) {
+        const candidateName = nameBySegmentKey.get(segments.slice(start, start + segmentCount).join("_"));
+        if (!candidateName || candidateName === name) continue;
+        bestAnchor = { name: candidateName, segmentCount, start };
+        break;
+      }
+    }
+
+    if (!bestAnchor) {
+      const info = { rootName: name, leadingSegments: 0 };
+      resolved.set(name, info);
+      return info;
+    }
+
+    const anchor = resolve(bestAnchor.name);
+    const rootSegments = segmentsByName.get(anchor.rootName) ?? [];
+    const rootStart = findSubsequence(segments, rootSegments);
+    const info = {
+      rootName: anchor.rootName,
+      leadingSegments: rootStart >= 0 ? rootStart : bestAnchor.start + anchor.leadingSegments,
+    };
+    resolved.set(name, info);
+    return info;
+  };
+
+  for (const name of segmentsByName.keys()) resolve(name);
+  return resolved;
+}
+
+function comparePrefixPriorityNames(left: string, right: string, index: ReadonlyMap<string, PrefixSortInfo>): number {
+  const leftName = left.toLowerCase();
+  const rightName = right.toLowerCase();
+  const leftInfo = index.get(leftName) ?? { rootName: leftName, leadingSegments: 0 };
+  const rightInfo = index.get(rightName) ?? { rootName: rightName, leadingSegments: 0 };
+
+  const rootCompared = databaseObjectNameCollator.compare(leftInfo.rootName, rightInfo.rootName);
+  if (rootCompared !== 0) return rootCompared;
+
+  if (leftInfo.leadingSegments !== rightInfo.leadingSegments) {
+    return leftInfo.leadingSegments - rightInfo.leadingSegments;
+  }
+
+  return databaseObjectNameCollator.compare(left, right);
+}
+
+export function createDatabaseObjectNameComparator(names: readonly string[]): (left: string, right: string) => number {
+  const index = buildPrefixSortIndex(names);
+  return (left, right) => comparePrefixPriorityNames(left, right, index);
+}
+
+export function sortDatabaseObjectsByPrefixPriority<T>(items: readonly T[], getName: (item: T) => string): T[] {
+  const compareNames = createDatabaseObjectNameComparator(items.map(getName));
+  return [...items].sort((left, right) => compareNames(getName(left), getName(right)));
+}
+
+export function sortDatabaseObjectsByName<T>(items: readonly T[], getName: (item: T) => string): T[] {
+  return [...items].sort((left, right) => databaseObjectNameCollator.compare(getName(left), getName(right)));
+}
+
+export function mergeTableInfosIntoObjects(objects: readonly ObjectInfo[], tables: readonly TableInfo[], schema?: string): ObjectInfo[] {
+  const merged = [...objects];
+  const seen = new Set(
+    merged.map((obj) => {
+      const name = normalizeDatabaseObjectName(obj.name);
+      const objectSchema = obj.schema ? normalizeDatabaseObjectName(obj.schema) : schema || "";
+      return `${normalizeObjectType(obj.object_type)}\0${objectSchema.toLowerCase()}\0${name.toLowerCase()}`;
+    }),
+  );
+
+  for (const table of tables) {
+    const objectType = normalizeObjectType(table.table_type);
+    if (objectType !== "TABLE" && objectType !== "VIEW" && objectType !== "MATERIALIZED_VIEW") continue;
+    const name = normalizeDatabaseObjectName(table.name);
+    if (!name) continue;
+    const matchingObject = objects.find((obj) => {
+      const objName = normalizeDatabaseObjectName(obj.name);
+      if (objName.toLowerCase() !== name.toLowerCase()) return false;
+      return normalizeObjectType(obj.object_type) === objectType;
+    });
+    const tableSchema = schema ?? (matchingObject?.schema ? normalizeDatabaseObjectName(matchingObject.schema) : undefined);
+    const key = `${objectType}\0${(tableSchema || "").toLowerCase()}\0${name.toLowerCase()}`;
+    if (seen.has(key)) {
+      // Table already in objects — merge comment if missing
+      if (matchingObject && table.comment && !matchingObject.comment) {
+        matchingObject.comment = table.comment;
+      }
+      continue;
+    }
+    seen.add(key);
+    merged.push({
+      name,
+      // Keep original driver-reported type (e.g. TDengine STABLE) so
+      // downstream template strategies can distinguish special table kinds.
+      object_type: table.table_type,
+      schema: tableSchema,
+      comment: table.comment,
+      created_at: undefined,
+      updated_at: undefined,
+      parent_schema: table.parent_schema,
+      parent_name: table.parent_name,
+    });
+  }
+
+  return merged;
+}
+
+export function filterSimpleSidebarSupplementalObjects(objects: readonly ObjectInfo[]): ObjectInfo[] {
+  return objects.filter((object) => {
+    const objectType = normalizeObjectType(object.object_type);
+    return objectType !== "TABLE" && objectType !== "VIEW" && objectType !== "MATERIALIZED_VIEW";
+  });
+}
+
+function buildPartitionTree(entries: TableTreeEntry[], connectionId: string, database: string): TreeNode[] {
+  const orderedEntries = sortDatabaseObjectsByName(entries, (entry) => entry.node.label);
+  const byKey = new Map<string, TableTreeEntry>();
+  for (const entry of orderedEntries) {
+    byKey.set(entry.key, entry);
+  }
+
+  const childrenByParent = new Map<string, TableTreeEntry[]>();
+  const childKeys = new Set<string>();
+  for (const entry of orderedEntries) {
+    if (entry.objectType !== "TABLE" || !entry.parentName) continue;
+    const parentSchema = entry.parentSchema || entry.schema;
+    const parentKey = objectIdentityKey("TABLE", parentSchema, entry.parentName);
+    const parent = byKey.get(parentKey);
+    if (!parent || parent.key === entry.key) continue;
+    const children = childrenByParent.get(parent.key) ?? [];
+    children.push(entry);
+    childrenByParent.set(parent.key, children);
+    childKeys.add(entry.key);
+  }
+
+  const materialize = (entry: TableTreeEntry): TreeNode => {
+    const partitionChildren = childrenByParent.get(entry.key);
+    if (!partitionChildren?.length) return entry.node;
+
+    const partitionGroup: TreeNode = {
+      id: `${entry.node.id}:__partitions`,
+      label: childTableGroupLabel(entry.node),
+      type: "group-partitions",
+      connectionId,
+      database,
+      schema: entry.schema,
+      catalog: entry.node.catalog,
+      tableName: entry.node.label,
+      objectCount: partitionChildren.length,
+      isExpanded: isSuperTable(entry.node),
+      children: partitionChildren.map(materialize),
+    };
+    entry.node.children = [partitionGroup];
+    entry.node.hiddenChildren = [partitionGroup];
+    return entry.node;
+  };
+
+  return orderedEntries.filter((entry) => !childKeys.has(entry.key)).map(materialize);
+}
+
+function isSuperTable(parent: TreeNode): boolean {
+  return parent.tableType?.trim().toUpperCase() === "STABLE";
+}
+
+function childTableGroupLabel(parent: TreeNode): string {
+  return isSuperTable(parent) ? "tree.childTables" : "tree.partitions";
+}
+
+function partitionGroupChildren(node: TreeNode): TreeNode[] {
+  const children = node.children?.filter((child) => child.type === "group-partitions") ?? [];
+  if (children.length) return children;
+  return node.hiddenChildren?.filter((child) => child.type === "group-partitions") ?? [];
+}
+
+export function tablePartitionGroups(node: TreeNode): TreeNode[] {
+  return partitionGroupChildren(node);
+}
+
+export function hasTablePartitionGroups(node: TreeNode): boolean {
+  return partitionGroupChildren(node).length > 0;
+}
+
+export type TableTreeLoadMoreParent = {
+  schema?: string | null;
+  name: string;
+};
+
+function findTableTreeNode(nodes: readonly TreeNode[], parent: TableTreeLoadMoreParent): TreeNode | undefined {
+  for (const node of nodes) {
+    const sameSchema = !parent.schema || (node.schema || "").toLowerCase() === parent.schema.toLowerCase();
+    if (node.type === "table" && sameSchema && node.label.toLowerCase() === parent.name.toLowerCase()) return node;
+
+    const child = findTableTreeNode(node.children ?? [], parent);
+    if (child) return child;
+    const hiddenChild = findTableTreeNode(node.hiddenChildren?.filter((item) => !(node.children ?? []).includes(item)) ?? [], parent);
+    if (hiddenChild) return hiddenChild;
+  }
+  return undefined;
+}
+
+export function appendTableTreeLoadMoreNode(children: TreeNode[], loadMoreNode: TreeNode, parent?: TableTreeLoadMoreParent): TreeNode[] {
+  const parentNode = parent ? findTableTreeNode(children, parent) : undefined;
+  const childGroup = parentNode ? tablePartitionGroups(parentNode)[0] : undefined;
+  if (!childGroup) return [...children, loadMoreNode];
+
+  childGroup.children = [...(childGroup.children ?? []), loadMoreNode];
+  return children;
+}
+
+export function withoutTableTreeLoadMoreNodes(nodes: TreeNode[] | undefined): TreeNode[] {
+  return (nodes ?? [])
+    .filter((node) => node.type !== "load-more")
+    .map((node) => {
+      if (node.children) node.children = withoutTableTreeLoadMoreNodes(node.children);
+      if (node.hiddenChildren) node.hiddenChildren = withoutTableTreeLoadMoreNodes(node.hiddenChildren);
+      return node;
+    });
+}
+
+export function mergeTableTreePageChildren(currentChildren: TreeNode[], pageChildren: TreeNode[], connectionId: string, database: string): TreeNode[] {
+  const roots = [...currentChildren];
+  const nodesByKey = new Map<string, TreeNode>();
+  const rootKeys = new Set<string>();
+
+  const nodeKey = (node: TreeNode) => objectIdentityKey("TABLE", node.schema, node.label);
+  const collect = (nodes: readonly TreeNode[]) => {
+    for (const node of nodes) {
+      if (node.type === "table") {
+        nodesByKey.set(nodeKey(node), node);
+      }
+      collect(node.children ?? []);
+      collect(node.hiddenChildren?.filter((child) => !(node.children ?? []).includes(child)) ?? []);
+    }
+  };
+
+  collect(roots);
+  for (const node of roots) {
+    if (node.type === "table") rootKeys.add(nodeKey(node));
+  }
+
+  const ensurePartitionGroup = (parent: TreeNode): TreeNode => {
+    const existing = partitionGroupChildren(parent)[0];
+    if (existing) return existing;
+    const group: TreeNode = {
+      id: `${parent.id}:__partitions`,
+      label: childTableGroupLabel(parent),
+      type: "group-partitions",
+      connectionId,
+      database,
+      schema: parent.schema,
+      tableName: parent.label,
+      objectCount: 0,
+      isExpanded: isSuperTable(parent),
+      children: [],
+    };
+    parent.children = [...(parent.children ?? []), group];
+    parent.hiddenChildren = [...(parent.hiddenChildren ?? []), group];
+    return group;
+  };
+
+  const addToParent = (parent: TreeNode, child: TreeNode) => {
+    const group = ensurePartitionGroup(parent);
+    const children = group.children ?? [];
+    if (!children.some((node) => nodeKey(node) === nodeKey(child))) {
+      group.children = sortDatabaseObjectsByName([...children, child], (node) => node.label);
+      group.objectCount = group.children.length;
+    }
+  };
+
+  const addNode = (node: TreeNode) => {
+    if (node.type !== "table") {
+      roots.push(node);
+      return;
+    }
+
+    const key = nodeKey(node);
+    if (nodesByKey.has(key)) return;
+
+    const parentName = node.partitionParentName;
+    const parentSchema = node.partitionParentSchema || node.schema;
+    const parentKey = parentName ? objectIdentityKey("TABLE", parentSchema, parentName) : "";
+    const parent = parentKey ? nodesByKey.get(parentKey) : undefined;
+    nodesByKey.set(key, node);
+    if (parent && parent !== node) {
+      addToParent(parent, node);
+      return;
+    }
+
+    if (!rootKeys.has(key)) {
+      roots.push(node);
+      rootKeys.add(key);
+    }
+  };
+
+  const flattenIncomingTables = (node: TreeNode): TreeNode[] => {
+    if (node.type !== "table") return [node];
+    const descendants = partitionGroupChildren(node)
+      .flatMap((group) => group.children ?? [])
+      .flatMap(flattenIncomingTables);
+    node.children = (node.children ?? []).filter((child) => child.type !== "group-partitions");
+    node.hiddenChildren = (node.hiddenChildren ?? []).filter((child) => child.type !== "group-partitions");
+    return [node, ...descendants];
+  };
+
+  for (const node of pageChildren.flatMap(flattenIncomingTables)) {
+    addNode(node);
+  }
+
+  return sortDatabaseObjectsByName(roots, (node) => node.label);
+}
+
+export type DatabaseObjectTreeKind = SidebarObjectKind;
+
+function buildObjectTreeEntries({ nodeId, connectionId, database, schema, objects, objectType }: { nodeId: string; connectionId: string; database: string; schema?: string; objects: ObjectInfo[]; objectType: "TABLE" | "VIEW" | "MATERIALIZED_VIEW" }): TreeNode[] {
+  const entries = objects.flatMap((obj) => {
+    const name = normalizeDatabaseObjectName(obj.name);
+    if (!name) return [];
+    const childSchema = obj.schema ? normalizeDatabaseObjectName(obj.schema) : schema;
+    return [
+      makeTableTreeEntry({
+        nodeId,
+        connectionId,
+        database,
+        schema: childSchema,
+        name,
+        objectType,
+        tableType: obj.object_type,
+        comment: obj.comment,
+        parentSchema: obj.parent_schema,
+        parentName: obj.parent_name,
+      }),
+    ];
+  });
+
+  return buildPartitionTree(entries, connectionId, database);
+}
+
+export function buildSimpleObjectTreeNodes({ nodeId, connectionId, database, schema, objects }: { nodeId: string; connectionId: string; database: string; schema?: string; objects: ObjectInfo[] }): TreeNode[] {
+  const seen = new Set<string>();
+  const tableEntries: TableTreeEntry[] = [];
+  const objectNodes: TreeNode[] = [];
+
+  for (const obj of objects) {
+    const objectType = normalizeObjectType(obj.object_type);
+    if (!["TABLE", "VIEW", "MATERIALIZED_VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE", "PACKAGE", "PACKAGE_BODY"].includes(objectType)) {
+      continue;
+    }
+
+    const name = normalizeDatabaseObjectName(obj.name);
+    if (!name) continue;
+
+    const childSchema = obj.schema ? normalizeDatabaseObjectName(obj.schema) : schema;
+    const signature = obj.signature?.trim() || "";
+    const dedupeKey = `${objectType}\0${(childSchema || "").toLowerCase()}\0${name.toLowerCase()}\0${signature.toLowerCase()}`;
+    if (seen.has(dedupeKey)) continue;
+    seen.add(dedupeKey);
+
+    const entry = makeTableTreeEntry({
+      nodeId,
+      connectionId,
+      database,
+      schema: childSchema,
+      name,
+      objectType,
+      tableType: obj.object_type,
+      comment: obj.comment,
+      parentSchema: obj.parent_schema,
+      parentName: obj.parent_name,
+    });
+    if (objectType === "TABLE") {
+      tableEntries.push(entry);
+    } else {
+      const simpleNodeType = simpleObjectNodeType(objectType);
+      objectNodes.push({
+        id: objectType === "VIEW" || objectType === "MATERIALIZED_VIEW" ? entry.node.id : `${nodeId}:${childSchema ? `${childSchema}:` : ""}${name}:${signature}:${objectType}`,
+        label: signature && (objectType === "FUNCTION" || objectType === "PROCEDURE") ? `${name}(${signature})` : name,
+        type: simpleNodeType,
+        objectName: name,
+        signature: signature || undefined,
+        comment: obj.comment,
+        connectionId,
+        database,
+        schema: childSchema,
+        isExpanded: false,
+        children: undefined,
+      });
+    }
+  }
+
+  return [...buildPartitionTree(tableEntries, connectionId, database), ...sortDatabaseObjectsByName(objectNodes, (node) => node.label)];
+}
+
+function simpleObjectNodeType(objectType: DatabaseObjectTreeKind): TreeNodeType {
+  if (objectType === "VIEW") return "view";
+  if (objectType === "MATERIALIZED_VIEW") return "materialized_view";
+  if (objectType === "PROCEDURE") return "procedure";
+  if (objectType === "FUNCTION") return "function";
+  if (objectType === "SEQUENCE") return "sequence";
+  if (objectType === "PACKAGE_BODY") return "package-body";
+  if (objectType === "PACKAGE") return "package";
+  return "table";
+}
+
+function normalizeObjectType(type: string): DatabaseObjectTreeKind {
+  return normalizeSidebarObjectKind(type);
+}
+
+const groupDefs: Array<{
+  key: string;
+  label: string;
+  objectTypes: DatabaseObjectTreeKind[];
+  nodeType: TreeNodeType;
+  childType: TreeNodeType | ((objectType: DatabaseObjectTreeKind) => TreeNodeType);
+}> = [
+  { key: "__tables", label: "tree.tables", objectTypes: ["TABLE"], nodeType: "group-tables", childType: "table" },
+  { key: "__views", label: "tree.views", objectTypes: ["VIEW"], nodeType: "group-views", childType: "view" },
+  {
+    key: "__materialized_views",
+    label: "tree.materializedViews",
+    objectTypes: ["MATERIALIZED_VIEW"],
+    nodeType: "group-materialized-views",
+    childType: "materialized_view",
+  },
+  {
+    key: "__procedures",
+    label: "tree.procedures",
+    objectTypes: ["PROCEDURE"],
+    nodeType: "group-procedures",
+    childType: "procedure",
+  },
+  {
+    key: "__functions",
+    label: "tree.functions",
+    objectTypes: ["FUNCTION"],
+    nodeType: "group-functions",
+    childType: "function",
+  },
+  {
+    key: "__sequences",
+    label: "tree.sequences",
+    objectTypes: ["SEQUENCE"],
+    nodeType: "group-sequences",
+    childType: "sequence",
+  },
+  {
+    key: "__packages",
+    label: "tree.packages",
+    objectTypes: ["PACKAGE", "PACKAGE_BODY"],
+    nodeType: "group-packages",
+    childType: (objectType) => (objectType === "PACKAGE_BODY" ? "package-body" : "package"),
+  },
+];
+
+const objectGroupNodeTypes = new Set<TreeNodeType>(["group-tables", "group-views", "group-materialized-views", "group-procedures", "group-functions", "group-sequences", "group-packages"]);
+
+export function buildObjectGroupPlaceholderNodes({ nodeId, connectionId, database, schema, objectTypes }: { nodeId: string; connectionId: string; database: string; schema?: string; objectTypes: DatabaseObjectTreeKind[] }): TreeNode[] {
+  const supported = new Set(objectTypes);
+  return groupDefs
+    .filter((def) => def.objectTypes.some((objectType) => supported.has(objectType)))
+    .map((def) => ({
+      id: `${nodeId}:${def.key}`,
+      label: def.label,
+      type: def.nodeType,
+      connectionId,
+      database,
+      schema,
+      isExpanded: false,
+      children: [],
+    }));
+}
+
+export function objectGroupRefreshParentId(node: TreeNode): string | null {
+  if (!objectGroupNodeTypes.has(node.type)) return null;
+  const suffixStart = node.id.lastIndexOf(":__");
+  if (suffixStart < 0) return null;
+  return node.id.slice(0, suffixStart);
+}
+
+export function objectTypesForGroupNode(type: TreeNodeType): DatabaseObjectTreeKind[] | null {
+  return groupDefs.find((def) => def.nodeType === type)?.objectTypes ?? null;
+}
+
+export function buildGroupedObjectTreeNodes({ nodeId, connectionId, database, schema, objects }: { nodeId: string; connectionId: string; database: string; schema?: string; objects: ObjectInfo[] }): TreeNode[] {
+  const buckets = new Map<string, ObjectInfo[]>();
+  const seen = new Set<string>();
+  for (const obj of objects) {
+    const name = normalizeDatabaseObjectName(obj.name);
+    if (!name) continue;
+    const t = normalizeObjectType(obj.object_type);
+    const objectSchema = obj.schema ? normalizeDatabaseObjectName(obj.schema) : schema || "";
+    const key = `${t}\0${objectSchema.toLowerCase()}\0${name.toLowerCase()}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const arr = buckets.get(t) ?? [];
+    arr.push({ ...obj, name, schema: obj.schema ? normalizeDatabaseObjectName(obj.schema) : obj.schema });
+    buckets.set(t, arr);
+  }
+
+  const groups: TreeNode[] = [];
+  for (const def of groupDefs) {
+    const items = def.objectTypes.flatMap((objectType) => buckets.get(objectType) ?? []);
+    if (!items?.length) continue;
+    const isExpandable = def.nodeType === "group-tables" || def.nodeType === "group-views" || def.nodeType === "group-materialized-views";
+    const children = isExpandable
+      ? buildObjectTreeEntries({
+          nodeId: `${nodeId}:${def.key}`,
+          connectionId,
+          database,
+          schema,
+          objects: items,
+          objectType: def.objectTypes[0] as "TABLE" | "VIEW" | "MATERIALIZED_VIEW",
+        })
+      : sortDatabaseObjectsByName(items, (obj) => obj.name).map((obj) => {
+          const childSchema = obj.schema ? normalizeDatabaseObjectName(obj.schema) : schema;
+          const objectType = normalizeObjectType(obj.object_type);
+          const childType = typeof def.childType === "function" ? def.childType(objectType) : def.childType;
+          const objectTypeSuffix = objectType === "PACKAGE" || objectType === "PACKAGE_BODY" ? `:${objectType}` : "";
+          return {
+            id: `${nodeId}:${def.key}:${childSchema ? `${childSchema}:` : ""}${obj.name}${objectTypeSuffix}`,
+            label: obj.name,
+            type: childType,
+            comment: obj.comment,
+            connectionId,
+            database,
+            schema: childSchema,
+            isExpanded: false,
+            children: undefined,
+          };
+        });
+    groups.push({
+      id: `${nodeId}:${def.key}`,
+      label: def.label,
+      type: def.nodeType,
+      connectionId,
+      database,
+      schema,
+      objectCount: items.length,
+      isExpanded: false,
+      children,
+    });
+  }
+  return groups;
+}
+
+export function expandCachedObjectBrowserNodes(nodes: TreeNode[]): TreeNode[] {
+  return nodes.flatMap((node) => {
+    if (node.type === "object-browser") return node.hiddenChildren ?? [];
+
+    if (!node.children) return [node];
+
+    return [
+      {
+        ...node,
+        children: expandCachedObjectBrowserNodes(node.children),
+      },
+    ];
+  });
+}
diff --git a/apps/desktop/src/lib/table/viewDdl.ts b/apps/desktop/src/lib/table/viewDdl.ts
new file mode 100644
index 0000000..7eed0c8
--- /dev/null
+++ b/apps/desktop/src/lib/table/viewDdl.ts
@@ -0,0 +1,13 @@
+import type { DatabaseType } from "@/types/database";
+import * as api from "@/lib/backend/api";
+
+export type BuildViewDdlInput = {
+  databaseType?: DatabaseType;
+  schema?: string | null;
+  name: string;
+  source: string;
+};
+
+export function buildViewDdl(input: BuildViewDdlInput): Promise<string> {
+  return api.buildViewDdlSql(input);
+}
diff --git a/apps/desktop/src/lib/tabs/dataTabActivation.ts b/apps/desktop/src/lib/tabs/dataTabActivation.ts
new file mode 100644
index 0000000..7ab657e
--- /dev/null
+++ b/apps/desktop/src/lib/tabs/dataTabActivation.ts
@@ -0,0 +1,11 @@
+import type { QueryResult, QueryTab } from "@/types/database";
+
+function isErrorResult(result: QueryResult | undefined): boolean {
+  return result?.columns.length === 1 && result.columns[0] === "Error";
+}
+
+export function canActivateExistingDataTableTab(tab: QueryTab): boolean {
+  if (tab.isExecuting) return true;
+  if (isErrorResult(tab.result)) return false;
+  return !!tab.result || !!tab.results?.length;
+}
diff --git a/apps/desktop/src/lib/tabs/tabCloseActions.ts b/apps/desktop/src/lib/tabs/tabCloseActions.ts
new file mode 100644
index 0000000..3c7bc52
--- /dev/null
+++ b/apps/desktop/src/lib/tabs/tabCloseActions.ts
@@ -0,0 +1,19 @@
+export interface TabLike {
+  id: string;
+}
+
+export interface TabCloseState<T extends TabLike> {
+  tabs: T[];
+  activeTabId: string | null;
+}
+
+export function closeOtherTabsState<T extends TabLike>(tabs: readonly T[], activeTabId: string | null, targetTabId: string): TabCloseState<T> {
+  const target = tabs.find((tab) => tab.id === targetTabId);
+  if (!target) return { tabs: [...tabs], activeTabId };
+
+  return { tabs: [target], activeTabId: target.id };
+}
+
+export function closeAllTabsState<T extends TabLike>(_tabs: readonly T[], _activeTabId: string | null): TabCloseState<T> {
+  return { tabs: [], activeTabId: null };
+}
diff --git a/apps/desktop/src/lib/tabs/tabPresentation.ts b/apps/desktop/src/lib/tabs/tabPresentation.ts
new file mode 100644
index 0000000..9802f01
--- /dev/null
+++ b/apps/desktop/src/lib/tabs/tabPresentation.ts
@@ -0,0 +1,228 @@
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import type { ConnectionConfig, QueryResult, QueryTab } from "@/types/database";
+
+type Translate = (key: string, params?: Record<string, unknown>) => string;
+export type OutputView = "result" | "summary" | "explain" | "chart";
+
+export function connectionDisplayName(connectionId: string): string {
+  const connectionStore = useConnectionStore();
+  return connectionStore.getConfig(connectionId)?.name || connectionId;
+}
+
+export function connectionColor(connectionId: string): string {
+  const connectionStore = useConnectionStore();
+  return connectionStore.getConfig(connectionId)?.color || "";
+}
+
+export function isConnectionReadonly(connectionId: string): boolean {
+  const connectionStore = useConnectionStore();
+  return connectionStore.getConfig(connectionId)?.read_only ?? false;
+}
+
+function jdbcTargetLabel(connection: ConnectionConfig): string {
+  const url = connection.connection_string?.trim() || "";
+  const serviceMatch = url.match(/@\/\/[^/?;]+\/([^?;]+)/);
+  if (serviceMatch?.[1]) return serviceMatch[1];
+  const sidMatch = url.match(/@[^:]+:\d+:([^?;]+)/);
+  if (sidMatch?.[1]) return sidMatch[1];
+  const pathMatch = url.match(/^jdbc:[^:]+:\/\/[^/?;]+\/([^?;]+)/);
+  if (pathMatch?.[1]) return pathMatch[1];
+  return connection.driver_label || "JDBC";
+}
+
+export function databaseDisplayNameForTab(connectionId: string, database: string, t: Translate): string {
+  const connectionStore = useConnectionStore();
+  const connection = connectionStore.getConfig(connectionId);
+  if (connection?.db_type === "redis" && database !== "") return `db${database}`;
+  if (connection?.db_type === "jdbc" && !database) return jdbcTargetLabel(connection);
+  return database || t("editor.noDatabase");
+}
+
+export function isPreviewTab(tab: QueryTab): boolean {
+  const connectionStore = useConnectionStore();
+  const config = connectionStore.getConfig(tab.connectionId);
+  return !!config?.name.startsWith("[Preview]");
+}
+
+function queryTitle(tab: QueryTab): string | undefined {
+  if (tab.customTitle || tab.savedSqlId || tab.objectSource) return tab.title.trim() || undefined;
+  return undefined;
+}
+
+export function tabDisplayTitle(tab: QueryTab, t: Translate): string {
+  const database = databaseDisplayNameForTab(tab.connectionId, tab.database, t);
+  const settingsStore = useSettingsStore();
+  const compact = settingsStore.editorSettings.compactTabTitle;
+  if (isPreviewTab(tab)) return tab.title;
+  if (tab.mode === "data" && tab.tableMeta?.tableName) {
+    if (compact) return tab.tableMeta.tableName;
+    const suffix = tab.tableMeta.schema && tab.tableMeta.schema !== tab.database ? `@${database}.${tab.tableMeta.schema}` : `@${database}`;
+    return `${tab.tableMeta.tableName}${suffix}`;
+  }
+  if (tab.mode === "query") {
+    const title = queryTitle(tab);
+    if (title) return title;
+    if (compact) return connectionDisplayName(tab.connectionId);
+    return `${connectionDisplayName(tab.connectionId)}@${database}`;
+  }
+  if (tab.mode === "mongo" && tab.sql) {
+    if (compact) return tab.sql;
+    return `${tab.sql}@${database}`;
+  }
+  if (tab.mode === "mongo-gridfs") {
+    if (compact) return t("tabs.gridfs");
+    return `${t("tabs.gridfs")}@${database}`;
+  }
+  if (tab.mode === "mongo-bucket") {
+    const bucketName = tab.mongoBucket?.bucketName || tab.sql || tab.title.split(".").pop() || tab.title;
+    if (compact) return bucketName;
+    return `${bucketName}@${database}`;
+  }
+  if (tab.mode === "vector" && tab.sql) {
+    if (compact) return tab.sql;
+    return `${tab.sql}@${database}`;
+  }
+  if (tab.mode === "redis") {
+    if (compact) return connectionDisplayName(tab.connectionId);
+    return `${connectionDisplayName(tab.connectionId)}@${database}`;
+  }
+  if (tab.mode === "etcd") {
+    if (compact) return connectionDisplayName(tab.connectionId);
+    return `${connectionDisplayName(tab.connectionId)}@keys`;
+  }
+  if (tab.mode === "zookeeper") {
+    if (compact) return connectionDisplayName(tab.connectionId);
+    return `${connectionDisplayName(tab.connectionId)}@keys`;
+  }
+  if (tab.mode === "objects") {
+    const schema = tab.objectBrowser?.schema;
+    if (compact) return schema || tab.title;
+    return schema ? `${schema}@${database}` : `${tab.title}@${database}`;
+  }
+  if (tab.mode === "users") {
+    if (compact) return t("tabs.users");
+    return `${t("tabs.users")}@${connectionDisplayName(tab.connectionId)}`;
+  }
+  return tab.title;
+}
+
+export function tabTooltipLines(tab: QueryTab, t: Translate): { label: string; value: string }[] {
+  const connName = connectionDisplayName(tab.connectionId);
+  const database = databaseDisplayNameForTab(tab.connectionId, tab.database, t);
+  const lines: { label: string; value: string }[] = [
+    { label: t("tabs.tooltipConnection"), value: connName },
+    { label: t("tabs.tooltipDatabase"), value: database },
+  ];
+  if (tab.mode === "query" && queryTitle(tab)) {
+    lines.unshift({ label: t("tabs.tooltipTitle"), value: tab.title });
+  }
+  if (tab.mode === "query" && tab.externalSqlPath) {
+    lines.push({ label: t("tabs.tooltipFilePath"), value: tab.externalSqlPath });
+  }
+  if (tab.mode === "data" && tab.tableMeta?.tableName) {
+    lines.push({ label: t("tabs.tooltipTable"), value: tab.tableMeta.tableName });
+  }
+  if (tab.mode === "mongo" && tab.sql) {
+    lines.push({ label: t("tabs.tooltipCollection"), value: tab.sql });
+  }
+  if (tab.mode === "mongo-gridfs") {
+    lines.push({ label: t("tabs.gridfs"), value: t("tabs.gridfs") });
+  }
+  if (tab.mode === "mongo-bucket") {
+    lines.push({ label: t("tabs.gridfs"), value: tab.mongoBucket?.bucketName || tab.sql || tab.title });
+  }
+  if (tab.mode === "vector" && tab.sql) {
+    lines.push({ label: t("tabs.tooltipCollection"), value: tab.sql });
+  }
+  if (tab.mode === "objects" && tab.objectBrowser?.schema) {
+    lines.push({ label: t("tabs.tooltipSchema"), value: tab.objectBrowser.schema });
+  }
+  return lines;
+}
+
+export function queryResultStatementLabel(result: Pick<QueryResult, "sourceLabel">): string | undefined {
+  return result.sourceLabel;
+}
+
+export function resultSqlForGrid(tab: Pick<QueryTab, "result" | "resultBaseSql" | "lastExecutedSql" | "sql">): string {
+  return tab.result?.sourceStatement || tab.resultBaseSql || tab.lastExecutedSql || tab.sql;
+}
+
+export function queryResultBaseSql(tab: Pick<QueryTab, "result" | "resultBaseSql" | "lastExecutedSql" | "sql">): string {
+  return resultSqlForGrid(tab);
+}
+
+export function queryResultExecutionSql(tab: Pick<QueryTab, "result" | "resultBaseSql" | "resultSortedSql" | "lastExecutedSql" | "sql">): string {
+  return tab.resultSortedSql || resultSqlForGrid(tab);
+}
+
+export function tabularResultItems(results: QueryResult[] | undefined): { result: QueryResult; index: number; n: number; label?: string; title?: string }[] {
+  if (!results) return [];
+  return results
+    .map((result, index) => ({ result, index }))
+    .filter((item) => item.result.columns.length > 0)
+    .map((item, ordinal) => ({ ...item, n: ordinal + 1, label: queryResultStatementLabel(item.result), title: item.result.sourceStatement }));
+}
+
+export function activeResultRun(tab: Pick<QueryTab, "resultRuns" | "activeResultRunId">) {
+  return tab.resultRuns?.find((run) => run.id === tab.activeResultRunId);
+}
+
+export function resultRunItems(tab: Pick<QueryTab, "resultRuns" | "activeResultRunId">): { id: string; title: string; sequence: number; active: boolean }[] {
+  return (tab.resultRuns ?? []).map((run) => ({
+    id: run.id,
+    title: run.title,
+    sequence: run.sequence,
+    active: run.id === tab.activeResultRunId,
+  }));
+}
+
+export function resultGridCacheKey(tab: Pick<QueryTab, "id" | "activeResultRunId" | "activeResultIndex">): string {
+  return `${tab.id}-${tab.activeResultRunId ?? "current"}-${tab.activeResultIndex ?? 0}`;
+}
+
+export function nextExecutionSummaryView(currentView: OutputView, canShowResult: boolean): OutputView {
+  if (currentView === "summary" && canShowResult) return "result";
+  return "summary";
+}
+
+export interface ExecutionSummaryItem {
+  result: QueryResult;
+  index: number;
+  returnedColumns: number;
+  returnedRows: number;
+  affectedRows: number;
+  executionTimeMs: number;
+  hasTabularResult: boolean;
+  isError: boolean;
+}
+
+export function executionSummaryItems(tab: Pick<QueryTab, "result" | "results">): ExecutionSummaryItem[] {
+  const results = tab.results?.length ? tab.results : tab.result ? [tab.result] : [];
+  return results.map((result, index) => ({
+    result,
+    index,
+    returnedColumns: result.columns.length,
+    returnedRows: result.rows.length,
+    affectedRows: result.affected_rows,
+    executionTimeMs: result.execution_time_ms,
+    hasTabularResult: result.columns.length > 0,
+    isError: result.columns.includes("Error"),
+  }));
+}
+
+export function tabModeLabel(tab: QueryTab, t: Translate): string {
+  if (tab.mode === "data") return t("tabs.table");
+  if (tab.mode === "query") return t("tabs.sql");
+  if (tab.mode === "mongo") return t("tabs.mongo");
+  if (tab.mode === "mongo-gridfs" || tab.mode === "mongo-bucket") return t("tabs.gridfs");
+  if (tab.mode === "vector") return t("tabs.vector");
+  if (tab.mode === "redis") return t("tabs.redis");
+  if (tab.mode === "etcd") return t("tabs.etcd");
+  if (tab.mode === "zookeeper") return t("tabs.zookeeper");
+  if (tab.mode === "nacos") return "Nacos";
+  if (tab.mode === "objects") return t("tabs.objects");
+  if (tab.mode === "users") return t("tabs.users");
+  return tab.mode;
+}
diff --git a/apps/desktop/src/lib/tabs/tabResultCache.ts b/apps/desktop/src/lib/tabs/tabResultCache.ts
new file mode 100644
index 0000000..6c62e2d
--- /dev/null
+++ b/apps/desktop/src/lib/tabs/tabResultCache.ts
@@ -0,0 +1,472 @@
+import type { QueryResult, QueryTab } from "@/types/database";
+import { decode, encode } from "@msgpack/msgpack";
+import { toRaw } from "vue";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { apiUrl } from "@/lib/common/webPath";
+
+const DB_NAME = "dbx-tab-runtime-cache";
+const DB_VERSION = 1;
+const RESULT_STORE = "resultSnapshots";
+const PAYLOAD_MAGIC = "DBX_TAB_RESULT_CACHE";
+const PAYLOAD_VERSION = 1;
+const PAYLOAD_CODEC = "msgpack-columnar";
+type CellValue = QueryResult["rows"][number][number];
+
+export interface TabResultSnapshot {
+  result?: QueryResult;
+  results?: QueryResult[];
+  activeResultIndex?: number;
+  /**
+   * Source ordering retained while a local grid sort is active. It must travel
+   * with the snapshot so clearing the sort after a cache/archive restore can
+   * still return to the original result order.
+   */
+  resultLocalSortOriginalRows?: QueryResult["rows"];
+  resultLocalSortOriginalMongoDocuments?: QueryResult["mongo_documents"];
+  resultRuns?: QueryTab["resultRuns"];
+  activeResultRunId?: string;
+  queryAnalysis?: QueryTab["queryAnalysis"];
+  querySourceColumns?: QueryTab["querySourceColumns"];
+  queryEditabilityReason?: QueryTab["queryEditabilityReason"];
+  mongoEditTarget?: QueryTab["mongoEditTarget"];
+  tableMeta?: QueryTab["tableMeta"];
+  resultPageSql?: string;
+  resultPageLimit?: number;
+  resultPageOffset?: number;
+  resultCountSql?: string;
+  resultTotalRowCount?: number;
+  cachedAt: number;
+}
+
+interface ColumnarQueryResult {
+  columns: string[];
+  execution_error?: true;
+  column_types?: string[];
+  columnValues: CellValue[][];
+  rowCount: number;
+  mongo_documents?: unknown[];
+  affected_rows: number;
+  execution_time_ms: number;
+  truncated?: boolean;
+  has_more?: boolean;
+  sourceLabel?: string;
+  sourceStatement?: string;
+}
+
+type QueryResultRunSnapshot = NonNullable<QueryTab["resultRuns"]>[number];
+
+interface ColumnarQueryResultRun extends Omit<QueryResultRunSnapshot, "result" | "results"> {
+  result?: ColumnarQueryResult;
+  results?: ColumnarQueryResult[];
+}
+
+interface TabResultSnapshotPayload extends Omit<TabResultSnapshot, "result" | "results" | "resultRuns"> {
+  result?: ColumnarQueryResult;
+  results?: ColumnarQueryResult[];
+  resultRuns?: ColumnarQueryResultRun[];
+}
+
+interface TabResultCacheEnvelope {
+  magic: typeof PAYLOAD_MAGIC;
+  version: typeof PAYLOAD_VERSION;
+  codec: typeof PAYLOAD_CODEC;
+  cachedAt: number;
+  rowCount: number;
+  columnCount: number;
+  payload: TabResultSnapshotPayload;
+}
+
+function indexedDb(): IDBFactory | undefined {
+  return typeof globalThis.indexedDB === "undefined" ? undefined : globalThis.indexedDB;
+}
+
+function requestToPromise<T>(request: IDBRequest<T>): Promise<T> {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+  });
+}
+
+let dbPromise: Promise<IDBDatabase | null> | undefined;
+const cacheKeyVersions = new Map<string, number>();
+
+function bumpCacheKeyVersion(key: string): number {
+  const version = (cacheKeyVersions.get(key) ?? 0) + 1;
+  cacheKeyVersions.set(key, version);
+  return version;
+}
+
+function isCurrentCacheKeyVersion(key: string, version: number): boolean {
+  return cacheKeyVersions.get(key) === version;
+}
+
+function clearCacheKeyVersionIfCurrent(key: string, version: number) {
+  if (isCurrentCacheKeyVersion(key, version)) cacheKeyVersions.delete(key);
+}
+
+function openCacheDb(): Promise<IDBDatabase | null> {
+  if (dbPromise) return dbPromise;
+  const idb = indexedDb();
+  if (!idb) return Promise.resolve(null);
+
+  dbPromise = new Promise((resolve) => {
+    const request = idb.open(DB_NAME, DB_VERSION);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(RESULT_STORE)) db.createObjectStore(RESULT_STORE);
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => {
+      console.warn("[DBX][tab-result-cache:open:error]", request.error);
+      resolve(null);
+    };
+    request.onblocked = () => resolve(null);
+  });
+  return dbPromise;
+}
+
+function clonePlain<T>(value: T): T {
+  const raw = toRaw(value);
+  if (typeof structuredClone === "function") return structuredClone(raw);
+  return JSON.parse(JSON.stringify(raw)) as T;
+}
+
+function stripSessionIds(result: QueryResult | undefined): QueryResult | undefined {
+  if (!result) return undefined;
+  return {
+    columns: [...result.columns],
+    execution_error: result.execution_error,
+    column_types: result.column_types ? [...result.column_types] : undefined,
+    rows: result.rows.map((row) => [...row]),
+    mongo_documents: result.mongo_documents ? clonePlain(result.mongo_documents) : undefined,
+    affected_rows: result.affected_rows,
+    execution_time_ms: result.execution_time_ms,
+    truncated: result.truncated,
+    session_id: undefined,
+    has_more: result.has_more,
+    sourceLabel: result.sourceLabel,
+    sourceStatement: result.sourceStatement,
+  };
+}
+
+function stripResultSessionIds(results: QueryResult[] | undefined): QueryResult[] | undefined {
+  return results?.map((result) => stripSessionIds(result)!);
+}
+
+function stripResultRunSessionIds(resultRuns: QueryTab["resultRuns"]): QueryTab["resultRuns"] {
+  return resultRuns?.map((run) => ({
+    ...run,
+    result: stripSessionIds(run.result),
+    results: stripResultSessionIds(run.results),
+    resultLocalSortOriginalRows: run.resultLocalSortOriginalRows?.map((row) => [...row]),
+    resultLocalSortOriginalMongoDocuments: run.resultLocalSortOriginalMongoDocuments ? clonePlain(run.resultLocalSortOriginalMongoDocuments) : undefined,
+    resultSessionId: undefined,
+  }));
+}
+
+function toColumnarResult(result: QueryResult | undefined): ColumnarQueryResult | undefined {
+  if (!result) return undefined;
+  const columnValues = result.columns.map((_, colIndex) => result.rows.map((row) => row[colIndex] ?? null));
+  return removeUndefinedFields({
+    columns: [...result.columns],
+    execution_error: result.execution_error,
+    column_types: result.column_types ? [...result.column_types] : undefined,
+    columnValues,
+    rowCount: result.rows.length,
+    mongo_documents: result.mongo_documents ? clonePlain(result.mongo_documents) : undefined,
+    affected_rows: result.affected_rows,
+    execution_time_ms: result.execution_time_ms,
+    truncated: result.truncated,
+    has_more: result.has_more,
+    sourceLabel: result.sourceLabel,
+    sourceStatement: result.sourceStatement,
+  });
+}
+
+function fromColumnarResult(result: ColumnarQueryResult | undefined): QueryResult | undefined {
+  if (!result) return undefined;
+  const rows = Array.from({ length: result.rowCount }, (_, rowIndex) => result.columnValues.map((values) => values[rowIndex] ?? null));
+  return {
+    columns: [...result.columns],
+    execution_error: result.execution_error,
+    column_types: result.column_types ? [...result.column_types] : undefined,
+    rows,
+    mongo_documents: result.mongo_documents ? clonePlain(result.mongo_documents) : undefined,
+    affected_rows: result.affected_rows,
+    execution_time_ms: result.execution_time_ms,
+    truncated: result.truncated,
+    session_id: undefined,
+    has_more: result.has_more,
+    sourceLabel: result.sourceLabel,
+    sourceStatement: result.sourceStatement,
+  };
+}
+
+function snapshotToPayload(snapshot: TabResultSnapshot): TabResultSnapshotPayload {
+  return removeUndefinedFields({
+    ...snapshot,
+    result: toColumnarResult(snapshot.result),
+    results: snapshot.results?.map((result) => toColumnarResult(result)!),
+    resultRuns: snapshot.resultRuns?.map((run) =>
+      removeUndefinedFields({
+        ...run,
+        result: toColumnarResult(run.result),
+        results: run.results?.map((result) => toColumnarResult(result)!),
+      }),
+    ),
+  });
+}
+
+function payloadToSnapshot(payload: TabResultSnapshotPayload): TabResultSnapshot {
+  return {
+    ...payload,
+    result: fromColumnarResult(payload.result),
+    results: payload.results?.map((result) => fromColumnarResult(result)!),
+    resultRuns: payload.resultRuns?.map((run) => ({
+      ...run,
+      result: fromColumnarResult(run.result),
+      results: run.results?.map((result) => fromColumnarResult(result)!),
+    })),
+  };
+}
+
+function resultStats(snapshot: TabResultSnapshot): { rowCount: number; columnCount: number } {
+  const activeRun = snapshot.resultRuns?.find((run) => run.id === snapshot.activeResultRunId) ?? snapshot.resultRuns?.[0];
+  const result = snapshot.result ?? snapshot.results?.[snapshot.activeResultIndex ?? 0] ?? snapshot.results?.[0] ?? activeRun?.result ?? activeRun?.results?.[activeRun.activeResultIndex ?? 0] ?? activeRun?.results?.[0];
+  return {
+    rowCount: result?.rows.length ?? 0,
+    columnCount: result?.columns.length ?? 0,
+  };
+}
+
+function bytesToBase64(bytes: Uint8Array): string {
+  let binary = "";
+  const chunkSize = 0x8000;
+  for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + chunkSize));
+  }
+  return btoa(binary);
+}
+
+function base64ToBytes(value: string): Uint8Array {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+
+function canUseRemoteRuntimeCache(): boolean {
+  return typeof btoa !== "undefined" && typeof atob !== "undefined" && (isTauriRuntime() || typeof fetch !== "undefined");
+}
+
+async function writeRemoteRuntimeCache(key: string, bytes: Uint8Array, stats: { rowCount: number; columnCount: number }): Promise<boolean> {
+  if (!canUseRemoteRuntimeCache()) return false;
+  try {
+    if (isTauriRuntime()) {
+      const { invoke } = await import("@tauri-apps/api/core");
+      await invoke("save_tab_runtime_cache", {
+        key,
+        payloadBase64: bytesToBase64(bytes),
+        rowCount: stats.rowCount,
+        columnCount: stats.columnCount,
+      });
+      return true;
+    }
+    const response = await fetch(apiUrl("/api/tab-runtime-cache"), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        key,
+        payloadBase64: bytesToBase64(bytes),
+        rowCount: stats.rowCount,
+        columnCount: stats.columnCount,
+      }),
+    });
+    return response.ok;
+  } catch (error) {
+    console.warn("[DBX][tab-result-cache:remote-write:error]", { key, error });
+    return false;
+  }
+}
+
+async function readRemoteRuntimeCache(key: string): Promise<Uint8Array | undefined> {
+  if (!canUseRemoteRuntimeCache()) return undefined;
+  try {
+    if (isTauriRuntime()) {
+      const { invoke } = await import("@tauri-apps/api/core");
+      const entry = await invoke<{ payloadBase64?: string } | null>("load_tab_runtime_cache", { key });
+      return entry?.payloadBase64 ? base64ToBytes(entry.payloadBase64) : undefined;
+    }
+    const response = await fetch(apiUrl(`/api/tab-runtime-cache?key=${encodeURIComponent(key)}`));
+    if (!response.ok) return undefined;
+    const entry = (await response.json()) as { payloadBase64?: string } | null;
+    return entry?.payloadBase64 ? base64ToBytes(entry.payloadBase64) : undefined;
+  } catch (error) {
+    console.warn("[DBX][tab-result-cache:remote-read:error]", { key, error });
+    return undefined;
+  }
+}
+
+async function deleteRemoteRuntimeCache(key: string): Promise<void> {
+  if (!canUseRemoteRuntimeCache()) return;
+  try {
+    if (isTauriRuntime()) {
+      const { invoke } = await import("@tauri-apps/api/core");
+      await invoke("delete_tab_runtime_cache", { key });
+      return;
+    }
+    await fetch(apiUrl(`/api/tab-runtime-cache?key=${encodeURIComponent(key)}`), { method: "DELETE" });
+  } catch (error) {
+    console.warn("[DBX][tab-result-cache:remote-delete:error]", { key, error });
+  }
+}
+
+function scheduleRemoteRuntimeCacheWrite(key: string, bytes: Uint8Array, stats: { rowCount: number; columnCount: number }, version: number) {
+  window.setTimeout(async () => {
+    if (!isCurrentCacheKeyVersion(key, version)) return;
+    await writeRemoteRuntimeCache(key, bytes, stats);
+    clearCacheKeyVersionIfCurrent(key, version);
+  }, 0);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function removeUndefinedFields<T>(value: T): T {
+  if (Array.isArray(value)) return value.map((item) => removeUndefinedFields(item)) as T;
+  if (!isRecord(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(([, entryValue]) => entryValue !== undefined)
+      .map(([key, entryValue]) => [key, removeUndefinedFields(entryValue)]),
+  ) as T;
+}
+
+function isBinaryPayload(value: unknown): value is Uint8Array {
+  return value instanceof Uint8Array || value instanceof ArrayBuffer;
+}
+
+export function encodeTabResultSnapshot(snapshot: TabResultSnapshot): Uint8Array {
+  const stats = resultStats(snapshot);
+  const envelope: TabResultCacheEnvelope = {
+    magic: PAYLOAD_MAGIC,
+    version: PAYLOAD_VERSION,
+    codec: PAYLOAD_CODEC,
+    cachedAt: snapshot.cachedAt,
+    rowCount: stats.rowCount,
+    columnCount: stats.columnCount,
+    payload: snapshotToPayload(snapshot),
+  };
+  return encode(removeUndefinedFields(envelope));
+}
+
+export function decodeTabResultSnapshot(bytes: Uint8Array | ArrayBuffer): TabResultSnapshot | undefined {
+  const decoded = decode(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes));
+  if (!isRecord(decoded)) return undefined;
+  if (decoded.magic !== PAYLOAD_MAGIC || decoded.version !== PAYLOAD_VERSION || decoded.codec !== PAYLOAD_CODEC) {
+    return undefined;
+  }
+  if (!isRecord(decoded.payload)) return undefined;
+  return payloadToSnapshot(decoded.payload as unknown as TabResultSnapshotPayload);
+}
+
+export function tabResultCacheKey(tabId: string): string {
+  return `tab:${tabId}:result`;
+}
+
+export function buildTabResultSnapshot(tab: QueryTab): TabResultSnapshot | undefined {
+  if (!tab.result && !tab.results && !tab.resultRuns?.length) return undefined;
+  return {
+    result: stripSessionIds(tab.result),
+    results: stripResultSessionIds(tab.results),
+    activeResultIndex: tab.activeResultIndex,
+    resultLocalSortOriginalRows: tab.resultLocalSortOriginalRows?.map((row) => [...row]),
+    resultLocalSortOriginalMongoDocuments: tab.resultLocalSortOriginalMongoDocuments ? clonePlain(tab.resultLocalSortOriginalMongoDocuments) : undefined,
+    resultRuns: stripResultRunSessionIds(tab.resultRuns),
+    activeResultRunId: tab.activeResultRunId,
+    queryAnalysis: tab.queryAnalysis ? clonePlain(tab.queryAnalysis) : undefined,
+    querySourceColumns: tab.querySourceColumns ? [...tab.querySourceColumns] : undefined,
+    queryEditabilityReason: tab.queryEditabilityReason,
+    mongoEditTarget: tab.mongoEditTarget ? clonePlain(tab.mongoEditTarget) : undefined,
+    tableMeta: tab.tableMeta ? clonePlain(tab.tableMeta) : undefined,
+    resultPageSql: tab.resultPageSql,
+    resultPageLimit: tab.resultPageLimit,
+    resultPageOffset: tab.resultPageOffset,
+    resultCountSql: tab.resultCountSql,
+    resultTotalRowCount: tab.resultTotalRowCount,
+    cachedAt: Date.now(),
+  };
+}
+
+export async function writeTabResultSnapshot(key: string, snapshot: TabResultSnapshot | undefined): Promise<boolean> {
+  if (!snapshot) return false;
+  const version = bumpCacheKeyVersion(key);
+  const encoded = encodeTabResultSnapshot(snapshot);
+  const stats = resultStats(snapshot);
+  let wroteLocal = false;
+  try {
+    const db = await openCacheDb();
+    if (db) {
+      const tx = db.transaction(RESULT_STORE, "readwrite");
+      await requestToPromise(tx.objectStore(RESULT_STORE).put(encoded, key));
+      wroteLocal = true;
+    }
+  } catch (error) {
+    console.warn("[DBX][tab-result-cache:write:error]", { key, error });
+  }
+  if (wroteLocal) {
+    if (typeof window === "undefined") {
+      void writeRemoteRuntimeCache(key, encoded, stats).finally(() => clearCacheKeyVersionIfCurrent(key, version));
+    } else {
+      scheduleRemoteRuntimeCacheWrite(key, encoded, stats, version);
+    }
+    return true;
+  }
+  if (!isCurrentCacheKeyVersion(key, version)) return false;
+  try {
+    return await writeRemoteRuntimeCache(key, encoded, stats);
+  } finally {
+    clearCacheKeyVersionIfCurrent(key, version);
+  }
+}
+
+export async function readTabResultSnapshot(key: string): Promise<TabResultSnapshot | undefined> {
+  try {
+    const db = await openCacheDb();
+    if (db) {
+      const value = await requestToPromise(db.transaction(RESULT_STORE, "readonly").objectStore(RESULT_STORE).get(key));
+      if (isBinaryPayload(value)) return decodeTabResultSnapshot(value);
+      if (value) return value as TabResultSnapshot;
+    }
+    const remoteBytes = await readRemoteRuntimeCache(key);
+    const remoteSnapshot = remoteBytes ? decodeTabResultSnapshot(remoteBytes) : undefined;
+    if (remoteBytes && remoteSnapshot && db) {
+      void requestToPromise(db.transaction(RESULT_STORE, "readwrite").objectStore(RESULT_STORE).put(remoteBytes, key));
+    }
+    return remoteSnapshot;
+  } catch (error) {
+    console.warn("[DBX][tab-result-cache:read:error]", { key, error });
+    const remoteBytes = await readRemoteRuntimeCache(key);
+    return remoteBytes ? decodeTabResultSnapshot(remoteBytes) : undefined;
+  }
+}
+
+export async function deleteTabResultSnapshot(key: string): Promise<void> {
+  const version = bumpCacheKeyVersion(key);
+  const clearVersionLater = () => {
+    const cleanup = () => clearCacheKeyVersionIfCurrent(key, version);
+    if (typeof window !== "undefined") window.setTimeout(cleanup, 5000);
+    else setTimeout(cleanup, 5000);
+  };
+  try {
+    const db = await openCacheDb();
+    if (db) await requestToPromise(db.transaction(RESULT_STORE, "readwrite").objectStore(RESULT_STORE).delete(key));
+    await deleteRemoteRuntimeCache(key);
+    clearVersionLater();
+  } catch (error) {
+    console.warn("[DBX][tab-result-cache:delete:error]", { key, error });
+    await deleteRemoteRuntimeCache(key);
+    clearVersionLater();
+  }
+}
diff --git a/apps/desktop/src/lib/webdav/webdavAutoUploadConfig.ts b/apps/desktop/src/lib/webdav/webdavAutoUploadConfig.ts
new file mode 100644
index 0000000..81ab200
--- /dev/null
+++ b/apps/desktop/src/lib/webdav/webdavAutoUploadConfig.ts
@@ -0,0 +1,45 @@
+import type { WebDavConfig } from "@/lib/backend/api";
+import { safeLocalStorageGet, safeLocalStorageSet } from "@/lib/backend/safeStorage";
+
+export const WEB_DAV_AUTO_UPLOAD_STORAGE_KEYS = ["dbx-webdav-endpoint", "dbx-webdav-username", "dbx-webdav-remote-path", "dbx-webdav-auto-upload-enabled", "dbx-webdav-auto-upload-interval-minutes"] as const;
+
+export const DEFAULT_WEB_DAV_REMOTE_PATH = "DBX/sync/snapshot.json";
+export const DEFAULT_WEB_DAV_AUTO_UPLOAD_INTERVAL_MINUTES = 30;
+
+export interface WebDavAutoUploadConfig {
+  enabled: boolean;
+  intervalMinutes: number;
+  webDavConfig: WebDavConfig | null;
+}
+
+export function normalizedWebDavAutoUploadInterval(value: unknown): number {
+  const numberValue = Number(value);
+  if (!Number.isFinite(numberValue)) return DEFAULT_WEB_DAV_AUTO_UPLOAD_INTERVAL_MINUTES;
+  return Math.max(1, Math.min(1440, Math.round(numberValue)));
+}
+
+export function readWebDavAutoUploadConfig(): WebDavAutoUploadConfig {
+  const endpoint = safeLocalStorageGet("dbx-webdav-endpoint")?.trim() || "";
+  const username = safeLocalStorageGet("dbx-webdav-username")?.trim() || "";
+  const remotePath = safeLocalStorageGet("dbx-webdav-remote-path")?.trim() || DEFAULT_WEB_DAV_REMOTE_PATH;
+
+  return {
+    enabled: safeLocalStorageGet("dbx-webdav-auto-upload-enabled") === "true",
+    intervalMinutes: normalizedWebDavAutoUploadInterval(safeLocalStorageGet("dbx-webdav-auto-upload-interval-minutes")),
+    webDavConfig: endpoint
+      ? {
+          endpoint,
+          username: username || undefined,
+          remotePath,
+        }
+      : null,
+  };
+}
+
+export function writeWebDavAutoUploadFields(config: WebDavConfig, autoUpload: { enabled: boolean; intervalMinutes: unknown }) {
+  safeLocalStorageSet("dbx-webdav-endpoint", config.endpoint.trim());
+  safeLocalStorageSet("dbx-webdav-username", config.username?.trim() || "");
+  safeLocalStorageSet("dbx-webdav-remote-path", config.remotePath?.trim() || DEFAULT_WEB_DAV_REMOTE_PATH);
+  safeLocalStorageSet("dbx-webdav-auto-upload-enabled", String(autoUpload.enabled));
+  safeLocalStorageSet("dbx-webdav-auto-upload-interval-minutes", String(normalizedWebDavAutoUploadInterval(autoUpload.intervalMinutes)));
+}
diff --git a/apps/desktop/src/lib/zookeeper/zookeeperConnection.ts b/apps/desktop/src/lib/zookeeper/zookeeperConnection.ts
new file mode 100644
index 0000000..5fdf919
--- /dev/null
+++ b/apps/desktop/src/lib/zookeeper/zookeeperConnection.ts
@@ -0,0 +1,48 @@
+export interface ZooKeeperEndpoint {
+  host: string;
+  port: number;
+}
+
+const DEFAULT_ZOOKEEPER_PORT = 2181;
+
+export function normalizeZooKeeperConnectString(value: string): string {
+  return value
+    .split(/[\n,;]+/)
+    .map((endpoint) => endpoint.trim())
+    .map((endpoint) => endpoint.replace(/^zookeeper:\/\//i, ""))
+    .filter(Boolean)
+    .join(",");
+}
+
+export function firstZooKeeperEndpoint(value?: string): ZooKeeperEndpoint | null {
+  const first = normalizeZooKeeperConnectString(value || "")
+    .split(",")
+    .find(Boolean);
+  if (!first) return null;
+  return parseZooKeeperEndpoint(first);
+}
+
+function parseZooKeeperEndpoint(value: string): ZooKeeperEndpoint {
+  const endpoint = value
+    .trim()
+    .replace(/^zookeeper:\/\//i, "")
+    .replace(/^.*@/, "")
+    .replace(/[/?#].*$/, "");
+
+  if (endpoint.startsWith("[")) {
+    const end = endpoint.indexOf("]");
+    if (end > 0) {
+      const host = endpoint.slice(1, end);
+      const portText = endpoint.slice(end + 1).replace(/^:/, "");
+      const port = Number(portText);
+      return { host, port: Number.isFinite(port) && port > 0 ? port : DEFAULT_ZOOKEEPER_PORT };
+    }
+  }
+
+  const parts = endpoint.split(":");
+  if (parts.length === 2) {
+    const port = Number(parts[1]);
+    return { host: parts[0], port: Number.isFinite(port) && port > 0 ? port : DEFAULT_ZOOKEEPER_PORT };
+  }
+  return { host: endpoint, port: DEFAULT_ZOOKEEPER_PORT };
+}
diff --git a/apps/desktop/src/lib/zookeeper/zookeeperLazyKeyTree.ts b/apps/desktop/src/lib/zookeeper/zookeeperLazyKeyTree.ts
new file mode 100644
index 0000000..41fc58d
--- /dev/null
+++ b/apps/desktop/src/lib/zookeeper/zookeeperLazyKeyTree.ts
@@ -0,0 +1,193 @@
+import type { KvKeyMetadata, KvKeySummary } from "@/lib/backend/api";
+
+export interface LazyKvKeyTreeNode extends KvKeyMetadata {
+  kind: "lazy";
+  id: string;
+  label: string;
+  key: string;
+  pathSegments: string[];
+  hasChildren: boolean;
+  children: LazyKvKeyTreeNode[];
+  loaded: boolean;
+  loading: boolean;
+  continuation: string | null;
+}
+
+export interface LazyKvKeyTreeState {
+  rootPath: string;
+  roots: LazyKvKeyTreeNode[];
+  rootContinuation: string | null;
+  nodeByKey: Map<string, LazyKvKeyTreeNode>;
+}
+
+export type LazyKvKeyTreeRow =
+  | {
+      type: "node";
+      node: LazyKvKeyTreeNode;
+      depth: number;
+    }
+  | {
+      type: "loadMore";
+      id: string;
+      parentKey: string | null;
+      depth: number;
+      loading: boolean;
+    };
+
+export function normalizeZooKeeperPath(path: string): string {
+  const trimmed = path.trim();
+  if (!trimmed || trimmed === "/") return "/";
+  const withSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  return withSlash.replace(/\/+$/, "") || "/";
+}
+
+export function parentZooKeeperPath(path: string): string {
+  const normalized = normalizeZooKeeperPath(path);
+  if (normalized === "/") return "/";
+  const parent = normalized.slice(0, normalized.lastIndexOf("/"));
+  return parent || "/";
+}
+
+export function createZooKeeperChildPathDraft(parentPath: string): string {
+  const normalized = normalizeZooKeeperPath(parentPath);
+  if (normalized === "/") return "";
+  return `${normalized}/`;
+}
+
+export function createLazyKvKeyTreeState(rootPath = "/"): LazyKvKeyTreeState {
+  return {
+    rootPath: normalizeZooKeeperPath(rootPath),
+    roots: [],
+    rootContinuation: null,
+    nodeByKey: new Map(),
+  };
+}
+
+export function resetLazyKvKeyTree(state: LazyKvKeyTreeState, rootPath = "/") {
+  state.rootPath = normalizeZooKeeperPath(rootPath);
+  state.roots = [];
+  state.rootContinuation = null;
+  state.nodeByKey.clear();
+}
+
+export function replaceLazyKvChildren(state: LazyKvKeyTreeState, parentKey: string | null, keys: KvKeySummary[], continuation: string | null | undefined, options: { append?: boolean } = {}) {
+  const previous = new Map(state.nodeByKey);
+  const nextChildren = keys.map((key) => lazyNodeFromSummary(key, previous.get(key.key)));
+  const children = options.append ? mergeLazyChildren(parentKey ? state.nodeByKey.get(parentKey)?.children || [] : state.roots, nextChildren) : nextChildren;
+
+  if (parentKey) {
+    const parent = state.nodeByKey.get(parentKey);
+    if (!parent) return;
+    parent.children = children;
+    parent.loaded = true;
+    parent.continuation = continuation || null;
+  } else {
+    state.roots = children;
+    state.rootContinuation = continuation || null;
+  }
+
+  rebuildLazyNodeIndex(state);
+}
+
+export function replaceLazyKvFocusedRoot(state: LazyKvKeyTreeState, root: KvKeySummary, keys: KvKeySummary[], continuation: string | null | undefined) {
+  const previous = new Map(state.nodeByKey);
+  const focusedPath = normalizeZooKeeperPath(root.key);
+  const childNodes = keys.map((key) => lazyNodeFromSummary(key, previous.get(key.key)));
+  const chain = focusedPathChain(focusedPath);
+  let rootNode: LazyKvKeyTreeNode | null = null;
+  let parentNode: LazyKvKeyTreeNode | null = null;
+
+  for (const path of chain) {
+    const node = lazyNodeFromSummary(path === focusedPath ? { ...root, key: focusedPath } : { key: path, numChildren: 1 }, previous.get(path));
+    node.hasChildren = true;
+    node.loaded = true;
+    node.continuation = null;
+    node.children = [];
+
+    if (parentNode) parentNode.children = [node];
+    else rootNode = node;
+    parentNode = node;
+  }
+
+  if (parentNode) {
+    parentNode.children = childNodes;
+    parentNode.hasChildren = parentNode.hasChildren || childNodes.length > 0 || !!continuation;
+    parentNode.continuation = continuation || null;
+  }
+
+  state.roots = rootNode ? [rootNode] : [];
+  state.rootContinuation = null;
+  rebuildLazyNodeIndex(state);
+}
+
+export function flattenLazyKvKeyTree(state: LazyKvKeyTreeState, expandedIds: ReadonlySet<string>): LazyKvKeyTreeRow[] {
+  const rows = flattenLazyNodes(state.roots, expandedIds, 0);
+  if (state.rootContinuation) {
+    rows.push({ type: "loadMore", id: "lazy-load-more:root", parentKey: null, depth: 0, loading: false });
+  }
+  return rows;
+}
+
+export function lazyExpandedKeyFromId(id: string): string | null {
+  return id.startsWith("lazy:") ? id.slice("lazy:".length) : null;
+}
+
+function flattenLazyNodes(nodes: LazyKvKeyTreeNode[], expandedIds: ReadonlySet<string>, depth: number): LazyKvKeyTreeRow[] {
+  const rows: LazyKvKeyTreeRow[] = [];
+  for (const node of nodes) {
+    rows.push({ type: "node", node, depth });
+    if (node.hasChildren && expandedIds.has(node.id)) {
+      rows.push(...flattenLazyNodes(node.children, expandedIds, depth + 1));
+      if (node.continuation) {
+        rows.push({ type: "loadMore", id: `lazy-load-more:${node.key}`, parentKey: node.key, depth: depth + 1, loading: node.loading });
+      }
+    }
+  }
+  return rows;
+}
+
+function lazyNodeFromSummary(summary: KvKeySummary, previous?: LazyKvKeyTreeNode): LazyKvKeyTreeNode {
+  const pathSegments = keySegments(summary.key);
+  return {
+    ...summary,
+    kind: "lazy",
+    id: `lazy:${summary.key}`,
+    label: pathSegments[pathSegments.length - 1] || summary.key || "/",
+    key: summary.key,
+    pathSegments,
+    hasChildren: (summary.numChildren ?? 0) > 0,
+    children: previous?.children || [],
+    loaded: previous?.loaded || false,
+    loading: previous?.loading || false,
+    continuation: previous?.continuation || null,
+  };
+}
+
+function mergeLazyChildren(existing: LazyKvKeyTreeNode[], incoming: LazyKvKeyTreeNode[]): LazyKvKeyTreeNode[] {
+  const seen = new Set(existing.map((node) => node.key));
+  return [...existing, ...incoming.filter((node) => !seen.has(node.key))];
+}
+
+function rebuildLazyNodeIndex(state: LazyKvKeyTreeState) {
+  state.nodeByKey.clear();
+  const visit = (nodes: LazyKvKeyTreeNode[]) => {
+    for (const node of nodes) {
+      state.nodeByKey.set(node.key, node);
+      visit(node.children);
+    }
+  };
+  visit(state.roots);
+}
+
+function keySegments(key: string): string[] {
+  return key.split("/").filter(Boolean);
+}
+
+function focusedPathChain(path: string): string[] {
+  const segments = keySegments(path);
+  const chain: string[] = [];
+  for (let index = 0; index < segments.length; index++) {
+    chain.push(`/${segments.slice(0, index + 1).join("/")}`);
+  }
+  return chain;
+}
diff --git a/apps/desktop/src/main.ts b/apps/desktop/src/main.ts
new file mode 100644
index 0000000..fd75a47
--- /dev/null
+++ b/apps/desktop/src/main.ts
@@ -0,0 +1,94 @@
+import { createApp } from "vue";
+import { createPinia } from "pinia";
+import VueVirtualScroller from "vue-virtual-scroller";
+import "vue-virtual-scroller/dist/vue-virtual-scroller.css";
+import "./styles/globals.css";
+import { installDebugLogCapture } from "@/lib/backend/debugLog";
+
+function startupErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return [error.message, error.stack].filter(Boolean).join("\n");
+  }
+  return String(error);
+}
+
+function renderStartupError(error: unknown) {
+  const message = startupErrorMessage(error);
+  console.error("[STARTUP] bootstrap failed", error);
+  const root = document.querySelector<HTMLDivElement>("#root");
+  if (!root) return;
+  root.innerHTML = "";
+  const panel = document.createElement("div");
+  panel.style.cssText = ["display:flex", "min-height:100vh", "align-items:center", "justify-content:center", "background:#ffffff", "color:#111827", "padding:24px", "font-family:ui-sans-serif,system-ui,sans-serif"].join(";");
+  const card = document.createElement("div");
+  card.style.cssText = ["max-width:760px", "width:100%", "border:1px solid #e5e7eb", "border-radius:12px", "padding:20px", "box-shadow:0 10px 30px rgba(0,0,0,0.08)", "background:#fff"].join(";");
+  const title = document.createElement("h1");
+  title.textContent = "DBX startup failed";
+  title.style.cssText = "margin:0 0 12px;font-size:18px;font-weight:700;";
+  const text = document.createElement("p");
+  text.textContent = "The desktop UI crashed during startup. Please copy the error below and send it to the DBX team.";
+  text.style.cssText = "margin:0 0 12px;font-size:13px;line-height:1.5;color:#4b5563;";
+  const pre = document.createElement("pre");
+  pre.textContent = message;
+  pre.style.cssText = ["margin:0", "white-space:pre-wrap", "word-break:break-word", "font-size:12px", "line-height:1.5", "background:#f9fafb", "border-radius:8px", "padding:12px", "overflow:auto"].join(";");
+  card.append(title, text, pre);
+  panel.append(card);
+  root.append(panel);
+}
+
+function installStartupErrorHandlers() {
+  window.addEventListener("error", (event) => {
+    console.error("[STARTUP] window error", event.error ?? event.message);
+  });
+  window.addEventListener("unhandledrejection", (event) => {
+    console.error("[STARTUP] unhandled rejection", event.reason);
+  });
+}
+
+function installGlobalInputAttrs() {
+  const ATTRS: [string, string][] = [
+    ["autocomplete", "off"],
+    ["autocapitalize", "off"],
+    ["autocorrect", "off"],
+    ["spellcheck", "false"],
+  ];
+  const MARKER = "data-input-attrs-set";
+  const apply = (el: Element) => {
+    if ((el.tagName === "INPUT" || el.tagName === "TEXTAREA") && !el.hasAttribute(MARKER)) {
+      for (const [k, v] of ATTRS) el.setAttribute(k, v);
+      el.setAttribute(MARKER, "");
+    }
+  };
+  document.querySelectorAll("input, textarea").forEach(apply);
+  new MutationObserver((mutations) => {
+    for (const m of mutations) {
+      for (const node of m.addedNodes) {
+        if (node instanceof Element) {
+          apply(node);
+          node.querySelectorAll("input, textarea").forEach(apply);
+        }
+      }
+    }
+  }).observe(document.body, { childList: true, subtree: true });
+}
+
+async function bootstrap() {
+  console.log("[STARTUP] frontend bootstrap begin");
+  const [{ default: i18n, loadSavedLocale }, { default: App }] = await Promise.all([import("./i18n"), import("./App.vue")]);
+  console.log("[STARTUP] frontend modules loaded");
+  await loadSavedLocale();
+  console.log("[STARTUP] locale ready");
+
+  const app = createApp(App);
+  app.use(createPinia());
+  app.use(i18n);
+  app.use(VueVirtualScroller);
+  app.mount("#root");
+  console.log("[STARTUP] vue mounted");
+
+  installGlobalInputAttrs();
+}
+
+installDebugLogCapture();
+installStartupErrorHandlers();
+void bootstrap().catch(renderStartupError);
diff --git a/apps/desktop/src/stores/__tests__/connectionStore.completion.spec.ts b/apps/desktop/src/stores/__tests__/connectionStore.completion.spec.ts
new file mode 100644
index 0000000..14855a3
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/connectionStore.completion.spec.ts
@@ -0,0 +1,233 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ConnectionConfig } from "@/types/database";
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+}
+
+function postgresConnection(): ConnectionConfig {
+  return {
+    id: "pg-1",
+    name: "Postgres",
+    db_type: "postgres",
+    host: "127.0.0.1",
+    port: 5432,
+    username: "postgres",
+    password: "",
+    database: "app",
+    read_only: false,
+  } as ConnectionConfig;
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+}
+
+describe("connectionStore completion assistant", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    installLocalStorage();
+    setActivePinia(createPinia());
+  });
+
+  it("deduplicates in-flight assistant table requests", async () => {
+    const completionAssistantSearch = vi.fn().mockResolvedValue({
+      candidates: [{ name: "accounts", kind: "table", schema: "public" }],
+      incomplete: false,
+      fallback_used: false,
+    });
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      completionAssistantSearch,
+      listSchemas: vi.fn().mockResolvedValue(["public"]),
+      listTables: vi.fn().mockResolvedValue([]),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    store.connections = [postgresConnection()];
+    store.connectedIds.add("pg-1");
+
+    const [first, second] = await Promise.all([store.listCompletionTables("pg-1", "app", "acc", 20, "public"), store.listCompletionTables("pg-1", "app", "acc", 20, "public")]);
+
+    expect(completionAssistantSearch).toHaveBeenCalledTimes(1);
+    expect(first).toEqual(second);
+    expect(first[0]).toMatchObject({ name: "accounts", schema: "public", type: "table" });
+  });
+
+  it("returns fallback metadata when assistant table search fails", async () => {
+    const completionAssistantSearch = vi.fn().mockRejectedValue(new Error("assistant unavailable"));
+    const listTables = vi.fn().mockResolvedValue([{ name: "accounts", table_type: "BASE TABLE", comment: null }]);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      completionAssistantSearch,
+      listSchemas: vi.fn().mockResolvedValue(["public"]),
+      listTables,
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    store.connections = [postgresConnection()];
+    store.connectedIds.add("pg-1");
+
+    const tables = await store.listCompletionTables("pg-1", "app", "acc", 20, "public");
+
+    expect(completionAssistantSearch).toHaveBeenCalledTimes(1);
+    expect(listTables).toHaveBeenCalledWith("pg-1", "app", "public", "acc", 20);
+    expect(tables).toEqual([{ name: "accounts", schema: "public", type: "table" }]);
+  });
+
+  it("keeps schema-qualified local table completion scoped to the selected schema", async () => {
+    const completionAssistantSearch = vi.fn().mockRejectedValue(new Error("assistant unavailable"));
+    const listTables = vi.fn(async (_connectionId: string, _database: string, schema: string, filter: string) => {
+      if (schema === "dim_game_base" && filter === "dim") {
+        return [{ name: "dim_game", table_type: "BASE TABLE", comment: null }];
+      }
+      return [];
+    });
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      completionAssistantSearch,
+      listSchemas: vi.fn().mockResolvedValue(["dim_game_base", "dws_game_sdk_base"]),
+      listTables,
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    store.connections = [postgresConnection()];
+    store.connectedIds.add("pg-1");
+
+    const dimTables = await store.listCompletionTables("pg-1", "app", "dim", 20, "dim_game_base");
+    const dwsTables = store.lookupLocalCompletionTables("pg-1", "app", "d", 20, "dws_game_sdk_base");
+
+    expect(dimTables).toEqual([{ name: "dim_game", schema: "dim_game_base", type: "table" }]);
+    expect(dwsTables).toEqual([]);
+  });
+
+  it("preserves table filter casing for assistant searches", async () => {
+    const completionAssistantSearch = vi.fn().mockResolvedValue({
+      candidates: [{ name: "TEST_USERS", kind: "table", schema: "SYSDBA" }],
+      incomplete: false,
+      fallback_used: false,
+    });
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      completionAssistantSearch,
+      listSchemas: vi.fn().mockResolvedValue(["SYSDBA"]),
+      listTables: vi.fn().mockResolvedValue([]),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    store.connections = [postgresConnection()];
+    store.connectedIds.add("pg-1");
+
+    const tables = await store.listCompletionTables("pg-1", "app", "TEST_", 20, "SYSDBA");
+
+    expect(completionAssistantSearch).toHaveBeenCalledWith(expect.objectContaining({ mask: "TEST_", schema: "SYSDBA", parent_schema: "SYSDBA" }));
+    expect(tables).toEqual([{ name: "TEST_USERS", schema: "SYSDBA", type: "table" }]);
+  });
+
+  it("limits concurrent completion column metadata requests per connection database", async () => {
+    const gates = [deferred<any[]>(), deferred<any[]>(), deferred<any[]>(), deferred<any[]>()];
+    let activeColumns = 0;
+    let maxActiveColumns = 0;
+    const getColumns = vi.fn((_connectionId: string, _database: string, _schema: string, table: string) => {
+      const index = Number(table.replace("table_", ""));
+      activeColumns++;
+      maxActiveColumns = Math.max(maxActiveColumns, activeColumns);
+      return gates[index].promise.finally(() => {
+        activeColumns--;
+      });
+    });
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      completionAssistantSearch: vi.fn().mockResolvedValue({ candidates: [], incomplete: false, fallback_used: false }),
+      getColumns,
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    store.connections = [postgresConnection()];
+    store.connectedIds.add("pg-1");
+
+    const requests = [0, 1, 2, 3].map((index) => store.listCompletionColumns("pg-1", "app", `table_${index}`, "public"));
+
+    await vi.waitFor(() => expect(getColumns).toHaveBeenCalledTimes(2));
+    expect(maxActiveColumns).toBe(2);
+    gates[0].resolve([{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null }]);
+    await vi.waitFor(() => expect(getColumns).toHaveBeenCalledTimes(3));
+    gates[1].resolve([{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null }]);
+    gates[2].resolve([{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null }]);
+    gates[3].resolve([{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null }]);
+
+    await Promise.all(requests);
+    expect(maxActiveColumns).toBe(2);
+  });
+
+  it("evicts old completion database entries", async () => {
+    const listDatabases = vi.fn(async (connectionId: string) => [{ name: `db_${connectionId}` }]);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      listDatabases,
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+
+    for (let index = 0; index < 51; index++) {
+      const id = `pg-${index}`;
+      store.addEphemeralConnection({ ...postgresConnection(), id, name: `Postgres ${index}` });
+      await store.listCompletionDatabases(id);
+    }
+
+    await store.listCompletionDatabases("pg-0");
+
+    expect(listDatabases).toHaveBeenCalledTimes(52);
+  });
+
+  it("evicts old completion schema entries", async () => {
+    const listSchemas = vi.fn(async (_connectionId: string, database: string) => [`schema_${database}`]);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      listSchemas,
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    store.addEphemeralConnection(postgresConnection());
+
+    for (let index = 0; index < 51; index++) {
+      await store.listCompletionSchemas("pg-1", `db_${index}`);
+    }
+
+    await store.listCompletionSchemas("pg-1", "db_0");
+
+    expect(listSchemas).toHaveBeenCalledTimes(52);
+  });
+});
diff --git a/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts b/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts
new file mode 100644
index 0000000..edb777a
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/connectionStore.metadataLoading.spec.ts
@@ -0,0 +1,209 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ConnectionConfig, ObjectInfo, TableInfo, TreeNode } from "@/types/database";
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+}
+
+function postgresConnection(): ConnectionConfig {
+  return {
+    id: "pg-1",
+    name: "Postgres",
+    db_type: "postgres",
+    host: "127.0.0.1",
+    port: 5432,
+    username: "postgres",
+    password: "",
+    database: "app",
+  } as ConnectionConfig;
+}
+
+function mysqlConnection(): ConnectionConfig {
+  return {
+    id: "mysql-1",
+    name: "MySQL",
+    db_type: "mysql",
+    host: "127.0.0.1",
+    port: 3306,
+    username: "root",
+    password: "",
+    database: "app",
+  } as ConnectionConfig;
+}
+
+function procedure(name: string): ObjectInfo {
+  return {
+    name,
+    object_type: "PROCEDURE",
+    schema: "app",
+    comment: null,
+    created_at: null,
+    updated_at: null,
+    parent_schema: null,
+    parent_name: null,
+  };
+}
+
+describe("connectionStore metadata loading", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    installLocalStorage();
+    setActivePinia(createPinia());
+  });
+
+  it("renders simple-mode table children without waiting for supplemental objects", async () => {
+    const tables: TableInfo[] = [{ name: "users", table_type: "TABLE", comment: null }];
+    const listTables = vi.fn().mockResolvedValue(tables);
+    const listObjects = vi.fn(() => new Promise(() => undefined));
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      listObjects,
+      listTables,
+      loadSchemaCache: vi.fn().mockResolvedValue(null),
+      saveSchemaCache: vi.fn().mockResolvedValue(undefined),
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const { useSettingsStore } = await import("@/stores/settingsStore");
+    const store = useConnectionStore();
+    const settingsStore = useSettingsStore();
+    settingsStore.editorSettings.sidebarObjectDisplay = "simple";
+
+    const connection = postgresConnection();
+    const schemaNode: TreeNode = {
+      id: "pg-1:app:public",
+      label: "public",
+      type: "schema",
+      connectionId: connection.id,
+      database: "app",
+      schema: "public",
+      isExpanded: false,
+      children: [],
+    };
+    store.connections = [connection];
+    store.connectedIds.add(connection.id);
+    store.treeNodes = [
+      {
+        id: connection.id,
+        label: connection.name,
+        type: "connection",
+        connectionId: connection.id,
+        isExpanded: true,
+        children: [
+          {
+            id: "pg-1:app",
+            label: "app",
+            type: "database",
+            connectionId: connection.id,
+            database: "app",
+            isExpanded: true,
+            children: [schemaNode],
+          },
+        ],
+      },
+    ];
+
+    const result = await Promise.race([store.loadTables(connection.id, "app", "public").then(() => "done"), new Promise((resolve) => setTimeout(() => resolve("timeout"), 50))]);
+
+    expect(result).toBe("done");
+    expect(listTables).toHaveBeenCalledWith(connection.id, "app", "public", undefined, 1001, 0);
+    expect(listObjects).toHaveBeenCalled();
+    expect(schemaNode.children?.map((node) => node.label)).toEqual(["users"]);
+  });
+
+  it("paginates procedure groups and appends the next page", async () => {
+    const firstPage = Array.from({ length: 201 }, (_, index) => procedure(`p_${String(index + 1).padStart(4, "0")}`));
+    const listObjects = vi
+      .fn()
+      .mockResolvedValueOnce(firstPage)
+      .mockResolvedValueOnce([procedure("p_0201"), procedure("p_0202")])
+      .mockResolvedValueOnce([procedure("p_0999")]);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      listObjects,
+      loadSchemaCache: vi.fn().mockResolvedValue(null),
+      saveSchemaCache: vi.fn().mockResolvedValue(undefined),
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const { useSettingsStore } = await import("@/stores/settingsStore");
+    const store = useConnectionStore();
+    const settingsStore = useSettingsStore();
+    settingsStore.editorSettings.sidebarObjectDisplay = "grouped";
+    settingsStore.desktopSettings.sidebar_table_page_size = 200;
+
+    const connection = mysqlConnection();
+    const procedureGroup: TreeNode = {
+      id: "mysql-1:app:__procedures",
+      label: "tree.procedures",
+      type: "group-procedures",
+      connectionId: connection.id,
+      database: "app",
+      isExpanded: false,
+      children: [],
+    };
+    store.connections = [connection];
+    store.connectedIds.add(connection.id);
+    store.treeNodes = [
+      {
+        id: connection.id,
+        label: connection.name,
+        type: "connection",
+        connectionId: connection.id,
+        isExpanded: true,
+        children: [
+          {
+            id: "mysql-1:app",
+            label: "app",
+            type: "database",
+            connectionId: connection.id,
+            database: "app",
+            isExpanded: true,
+            children: [procedureGroup],
+          },
+        ],
+      },
+    ];
+
+    const storedProcedureGroup = store.treeNodes[0].children?.[0].children?.[0];
+    expect(storedProcedureGroup?.type).toBe("group-procedures");
+    await store.loadObjectGroupChildren(storedProcedureGroup!);
+
+    expect(listObjects).toHaveBeenNthCalledWith(1, connection.id, "app", "app", ["PROCEDURE"], undefined, 201, 0);
+    expect(storedProcedureGroup?.children).toHaveLength(201);
+    expect(storedProcedureGroup?.children?.[0].label).toBe("p_0001");
+    expect(storedProcedureGroup?.children?.[199].label).toBe("p_0200");
+    expect(storedProcedureGroup?.children?.[200].label).toBe("tree.loadMore");
+
+    const loadMoreNode = storedProcedureGroup?.children?.at(-1);
+    expect(loadMoreNode?.type).toBe("load-more");
+    await store.loadMoreObjectGroupChildren(loadMoreNode!);
+
+    expect(listObjects).toHaveBeenNthCalledWith(2, connection.id, "app", "app", ["PROCEDURE"], undefined, 201, 200);
+    expect(storedProcedureGroup?.children).toHaveLength(202);
+    expect(storedProcedureGroup?.children?.at(-1)?.label).toBe("p_0202");
+
+    store.sidebarSearchQuery = "p_0999";
+    await store.loadObjectGroupChildren(storedProcedureGroup!, { force: true, searchFilter: "p_0999" });
+
+    expect(listObjects).toHaveBeenNthCalledWith(3, connection.id, "app", "app", ["PROCEDURE"], "p_0999", undefined, undefined);
+    expect(storedProcedureGroup?.children?.map((node) => node.label)).toEqual(["p_0999"]);
+  });
+});
diff --git a/apps/desktop/src/stores/__tests__/connectionStore.mq.spec.ts b/apps/desktop/src/stores/__tests__/connectionStore.mq.spec.ts
new file mode 100644
index 0000000..49a5077
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/connectionStore.mq.spec.ts
@@ -0,0 +1,236 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ConnectionConfig, TreeNode } from "@/types/database";
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+}
+
+function mqConnection(): ConnectionConfig {
+  return {
+    id: "mq-1",
+    name: "Apache Pulsar",
+    db_type: "mq",
+    host: "127.0.0.1",
+    port: 8080,
+    user: "",
+    password: "",
+    database: "",
+    readonly: false,
+    read_only: false,
+    ssl_mode: "disabled",
+    color: "#888",
+    external_config: {
+      systemKind: "pulsar",
+      adminUrl: "http://127.0.0.1:8080",
+      auth: { kind: "none" },
+    },
+  } as ConnectionConfig;
+}
+
+function kafkaConnection(): ConnectionConfig {
+  return {
+    ...mqConnection(),
+    name: "Apache Kafka",
+    driver_profile: "kafka",
+    driver_label: "Apache Kafka",
+    external_config: {
+      systemKind: "kafka",
+      adminUrl: "",
+      auth: { kind: "none" },
+      extra: { bootstrapServers: "127.0.0.1:9092" },
+    },
+  } as ConnectionConfig;
+}
+
+function kafkaExternalConfigOnlyConnection(): ConnectionConfig {
+  const connection = kafkaConnection();
+  delete connection.driver_profile;
+  delete connection.driver_label;
+  return connection;
+}
+
+describe("connectionStore MQ sidebar tree", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    installLocalStorage();
+    setActivePinia(createPinia());
+  });
+
+  it("loads Pulsar tenants under a message queue connection", async () => {
+    const mqListTenants = vi.fn().mockResolvedValue([
+      { name: "public", adminRoles: [], allowedClusters: [] },
+      { name: "tenant-a", adminRoles: [], allowedClusters: [] },
+    ]);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      listDatabases: vi.fn().mockResolvedValue([]),
+      loadSchemaCache: vi.fn().mockResolvedValue(null),
+      mqListTenants,
+      saveSchemaCache: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = mqConnection();
+    const node: TreeNode = {
+      id: connection.id,
+      label: connection.name,
+      type: "connection",
+      connectionId: connection.id,
+      isExpanded: false,
+      children: [],
+    };
+
+    store.connections = [connection];
+    store.connectedIds.add(connection.id);
+    store.treeNodes = [node];
+
+    await store.refreshTreeNode(node);
+
+    expect(mqListTenants).toHaveBeenCalledWith(connection.id);
+    expect(node.children?.map((child) => ({ id: child.id, label: child.label, type: child.type, tenant: (child as TreeNode & { mqTenant?: string }).mqTenant }))).toEqual([
+      { id: "mq-1:mq-tenant:public", label: "public", type: "mq-tenant", tenant: "public" },
+      { id: "mq-1:mq-tenant:tenant-a", label: "tenant-a", type: "mq-tenant", tenant: "tenant-a" },
+    ]);
+    expect(node.isExpanded).toBe(true);
+  });
+
+  it("adds a Kafka topics child with a topics initial tab", async () => {
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      listDatabases: vi.fn().mockResolvedValue([]),
+      loadSchemaCache: vi.fn().mockResolvedValue(null),
+      mqListTenants: vi.fn(),
+      saveSchemaCache: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = kafkaConnection();
+    const node: TreeNode = {
+      id: connection.id,
+      label: connection.name,
+      type: "connection",
+      connectionId: connection.id,
+      isExpanded: false,
+      children: [],
+    };
+
+    store.connections = [connection];
+    store.connectedIds.add(connection.id);
+    store.treeNodes = [node];
+
+    await store.refreshTreeNode(node);
+
+    expect(node.children?.map((child) => ({ label: child.label, tenant: child.mqTenant, initialTab: child.mqInitialTab }))).toEqual([{ label: "Topics", tenant: "_kafka", initialTab: "topics" }]);
+  });
+
+  it("detects Kafka from external config when driver profile is missing", async () => {
+    const mqListTenants = vi.fn();
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      listDatabases: vi.fn().mockResolvedValue([]),
+      loadSchemaCache: vi.fn().mockResolvedValue(null),
+      mqListTenants,
+      saveSchemaCache: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = kafkaExternalConfigOnlyConnection();
+    const node: TreeNode = {
+      id: connection.id,
+      label: connection.name,
+      type: "connection",
+      connectionId: connection.id,
+      isExpanded: false,
+      children: [],
+    };
+
+    store.connections = [connection];
+    store.connectedIds.add(connection.id);
+    store.treeNodes = [node];
+
+    await store.refreshTreeNode(node);
+
+    expect(mqListTenants).not.toHaveBeenCalled();
+    expect(node.children?.map((child) => ({ label: child.label, tenant: child.mqTenant, initialTab: child.mqInitialTab }))).toEqual([{ label: "Topics", tenant: "_kafka", initialTab: "topics" }]);
+  });
+
+  it("reuses an in-flight connection attempt instead of recording stale superseded errors", async () => {
+    let resolveConnect: ((value: string) => void) | undefined;
+    const connectDb = vi.fn(
+      () =>
+        new Promise<string>((resolve) => {
+          resolveConnect = resolve;
+        }),
+    );
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
+      connectDb,
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = mqConnection();
+    store.connections = [connection];
+
+    const first = store.ensureConnected(connection.id);
+    const second = store.ensureConnected(connection.id);
+    await Promise.resolve();
+
+    expect(connectDb).toHaveBeenCalledTimes(1);
+    resolveConnect?.(connection.id);
+    await Promise.all([first, second]);
+
+    expect(store.connectedIds.has(connection.id)).toBe(true);
+    expect(store.connectionErrors[connection.id]).toBeUndefined();
+  });
+
+  it("stores the selected tenant when opening an MQ admin tab", async () => {
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const connectionStore = useConnectionStore();
+    const queryStore = useQueryStore();
+    connectionStore.connections = [mqConnection()];
+
+    const firstTabId = queryStore.openMqAdmin("mq-1", { tenant: "public" });
+    expect(queryStore.tabs.find((tab) => tab.id === firstTabId)?.mqTenant).toBe("public");
+    expect(queryStore.tabs.find((tab) => tab.id === firstTabId)?.mqInitialTab).toBeUndefined();
+
+    const secondTabId = queryStore.openMqAdmin("mq-1", { tenant: "tenant-a", initialTab: "topics" });
+    expect(secondTabId).toBe(firstTabId);
+    expect(queryStore.tabs.find((tab) => tab.id === firstTabId)?.mqTenant).toBe("tenant-a");
+    expect(queryStore.tabs.find((tab) => tab.id === firstTabId)?.mqInitialTab).toBe("topics");
+  });
+
+  it("preserves the selected tenant when duplicating an MQ admin tab", async () => {
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const connectionStore = useConnectionStore();
+    const queryStore = useQueryStore();
+    connectionStore.connections = [mqConnection()];
+
+    const tabId = queryStore.openMqAdmin("mq-1", { tenant: "public" });
+    queryStore.duplicateTab(tabId);
+
+    expect(queryStore.tabs).toHaveLength(2);
+    expect(queryStore.tabs[1]?.mqTenant).toBe("public");
+  });
+});
diff --git a/apps/desktop/src/stores/__tests__/connectionStore.sqlserverLegacy.spec.ts b/apps/desktop/src/stores/__tests__/connectionStore.sqlserverLegacy.spec.ts
new file mode 100644
index 0000000..13f2f34
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/connectionStore.sqlserverLegacy.spec.ts
@@ -0,0 +1,63 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { ConnectionConfig } from "@/types/database";
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+}
+
+function sqlServerLegacyConnection(): ConnectionConfig {
+  return {
+    id: "sqlserver-1",
+    name: "SQL Server",
+    db_type: "sqlserver",
+    driver_profile: "sqlserver",
+    driver_label: "SQL Server",
+    host: "127.0.0.1",
+    port: 1433,
+    username: "sa",
+    password: "secret",
+    database: "master",
+    url_params: "sqlserverEncryption=disabled",
+    ssl: false,
+    ssh_enabled: false,
+    read_only: false,
+    one_time: false,
+    transport_layers: [],
+    agent_java_options: [],
+  };
+}
+
+describe("connectionStore SQL Server legacy compatibility", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    installLocalStorage();
+    setActivePinia(createPinia());
+  });
+
+  it("installs the legacy compatibility component before connecting saved legacy configs", async () => {
+    const connectDb = vi.fn().mockResolvedValue("sqlserver-1");
+    const installAgent = vi.fn().mockResolvedValue(undefined);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      connectDb,
+      installAgent,
+      isAgentInstalled: vi.fn().mockResolvedValue(false),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    await store.connect(sqlServerLegacyConnection());
+
+    expect(installAgent).toHaveBeenCalledWith("sqlserver-legacy");
+    expect(connectDb).toHaveBeenCalledTimes(1);
+    expect(installAgent.mock.invocationCallOrder[0]).toBeLessThan(connectDb.mock.invocationCallOrder[0]);
+  });
+});
diff --git a/apps/desktop/src/stores/__tests__/connectionStore.timeout.spec.ts b/apps/desktop/src/stores/__tests__/connectionStore.timeout.spec.ts
new file mode 100644
index 0000000..fb9d7e9
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/connectionStore.timeout.spec.ts
@@ -0,0 +1,533 @@
+import { createPinia, setActivePinia } from "pinia";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ConnectionConfig, TreeNode } from "@/types/database";
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+}
+
+function postgresConnection(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
+  return {
+    id: "pg-1",
+    name: "Postgres",
+    db_type: "postgres",
+    host: "127.0.0.1",
+    port: 5432,
+    username: "postgres",
+    password: "",
+    database: "app",
+    read_only: false,
+    ...overrides,
+  } as ConnectionConfig;
+}
+
+describe("connectionStore timeout recovery", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    installLocalStorage();
+    setActivePinia(createPinia());
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("times out connected health checks and falls back to reconnect", async () => {
+    const checkConnectionHealth = vi.fn(() => new Promise(() => undefined));
+    const connectDb = vi.fn().mockResolvedValue(undefined);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth,
+      connectDb,
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = postgresConnection({ connect_timeout_secs: 10 });
+    store.connections = [connection];
+    store.connectedIds.add(connection.id);
+
+    const ensure = store.ensureConnected(connection.id);
+    await vi.advanceTimersByTimeAsync(5001);
+    await ensure;
+
+    expect(checkConnectionHealth).toHaveBeenCalledWith(connection.id);
+    expect(connectDb).toHaveBeenCalledWith(connection, expect.any(Number));
+    expect(store.connectedIds.has(connection.id)).toBe(true);
+  }, 10_000);
+
+  it("normalizes missing keepalive interval to 30 seconds", async () => {
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    await store.addConnection(postgresConnection({ keepalive_interval_secs: undefined }));
+
+    expect(store.connections[0]?.keepalive_interval_secs).toBe(30);
+  });
+
+  it("clears connection node loading when health check timeout forces reconnect failure", async () => {
+    const checkConnectionHealth = vi.fn(() => new Promise(() => undefined));
+    const connectDb = vi.fn().mockRejectedValue(new Error("reconnect failed"));
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      checkConnectionHealth,
+      connectDb,
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = postgresConnection({ connect_timeout_secs: 10 });
+    const node: TreeNode = {
+      id: connection.id,
+      label: connection.name,
+      type: "connection",
+      connectionId: connection.id,
+      isLoading: true,
+      children: [],
+    };
+    store.connections = [connection];
+    store.connectedIds.add(connection.id);
+    store.treeNodes = [node];
+
+    const ensure = store.ensureConnected(connection.id).catch((error) => error);
+    await vi.advanceTimersByTimeAsync(5001);
+    const error = await ensure;
+
+    expect(error).toBeInstanceOf(Error);
+    expect(node.isLoading).toBe(false);
+  }, 10_000);
+
+  it("cancels an in-flight connection without leaving connected or loading state", async () => {
+    const connectDb = vi.fn(() => new Promise(() => undefined));
+    const disconnectDb = vi.fn().mockResolvedValue(undefined);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      connectDb,
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      disconnectDb,
+      listInstalledAgents: vi.fn().mockResolvedValue([]),
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { CONNECTION_ATTEMPT_CANCELLED_MESSAGE, useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = postgresConnection({ connect_timeout_secs: 1 });
+    const node: TreeNode = {
+      id: connection.id,
+      label: connection.name,
+      type: "connection",
+      connectionId: connection.id,
+      isLoading: false,
+      children: [],
+    };
+    store.connections = [connection];
+    store.treeNodes = [node];
+
+    const ensure = store.ensureConnected(connection.id).catch((error) => error);
+    await vi.advanceTimersByTimeAsync(1);
+
+    expect(store.connectingIds.has(connection.id)).toBe(true);
+    expect(node.isLoading).toBe(true);
+
+    await expect(store.cancelConnecting(connection.id)).resolves.toBe(true);
+    expect(disconnectDb).toHaveBeenCalledWith(connection.id, expect.any(Number));
+    expect(store.connectingIds.has(connection.id)).toBe(false);
+    expect(store.connectedIds.has(connection.id)).toBe(false);
+    expect(store.connectionErrors[connection.id]).toBeUndefined();
+    expect(node.isLoading).toBe(false);
+
+    await vi.advanceTimersByTimeAsync(3001);
+    const error = await ensure;
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error.message).toContain(CONNECTION_ATTEMPT_CANCELLED_MESSAGE);
+    expect(store.connectingIds.has(connection.id)).toBe(false);
+    expect(store.connectedIds.has(connection.id)).toBe(false);
+    expect(store.connectionErrors[connection.id]).toBeUndefined();
+    expect(node.isLoading).toBe(false);
+  }, 10_000);
+
+  it("allows reconnecting the same connection while a scoped cancel is pending", async () => {
+    let resolveDisconnect!: () => void;
+    const pendingConnect = new Promise<string>(() => undefined);
+    let connectCallCount = 0;
+    const connectDb = vi.fn(() => {
+      connectCallCount += 1;
+      return connectCallCount === 1 ? pendingConnect : Promise.resolve("pg-1");
+    });
+    const disconnectDb = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveDisconnect = resolve;
+        }),
+    );
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      connectDb,
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      disconnectDb,
+      listInstalledAgents: vi.fn().mockResolvedValue([]),
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = postgresConnection({ connect_timeout_secs: 1 });
+    store.connections = [connection];
+    store.treeNodes = [
+      {
+        id: connection.id,
+        label: connection.name,
+        type: "connection",
+        connectionId: connection.id,
+        isLoading: false,
+        children: [],
+      },
+    ];
+
+    const firstEnsure = store.ensureConnected(connection.id).catch((error) => error);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(connectDb).toHaveBeenCalledTimes(1);
+    const firstAttempt = connectDb.mock.calls[0]?.[1];
+
+    const cancel = store.cancelConnecting(connection.id);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(disconnectDb).toHaveBeenCalledWith(connection.id, firstAttempt);
+
+    const reconnect = store.ensureConnected(connection.id);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(connectDb).toHaveBeenCalledTimes(2);
+    expect(connectDb.mock.calls[1]?.[1]).not.toBe(firstAttempt);
+
+    resolveDisconnect();
+    await cancel;
+    await reconnect;
+
+    expect(connectDb).toHaveBeenCalledTimes(2);
+    expect(store.connectedIds.has(connection.id)).toBe(true);
+    expect(store.connectionErrors[connection.id]).toBeUndefined();
+
+    await vi.advanceTimersByTimeAsync(3001);
+    await firstEnsure;
+  }, 10_000);
+
+  it("starts a fresh root metadata load after canceling a pending connection", async () => {
+    let connectCallCount = 0;
+    const connectDb = vi.fn(() => {
+      connectCallCount += 1;
+      return connectCallCount === 1 ? new Promise<string>(() => undefined) : Promise.resolve("pg-1");
+    });
+    const disconnectDb = vi.fn().mockResolvedValue(undefined);
+    const listDatabases = vi.fn().mockResolvedValue([{ name: "app" }]);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      connectDb,
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      disconnectDb,
+      listDatabases,
+      loadSchemaCache: vi.fn().mockResolvedValue(null),
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSchemaCache: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = postgresConnection({ connect_timeout_secs: 10 });
+    store.connections = [connection];
+    store.treeNodes = [
+      {
+        id: connection.id,
+        label: connection.name,
+        type: "connection",
+        connectionId: connection.id,
+        isLoading: false,
+        children: [],
+      },
+    ];
+
+    void store.loadDatabases(connection.id).catch(() => undefined);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(connectDb).toHaveBeenCalledTimes(1);
+    const firstAttempt = connectDb.mock.calls[0]?.[1];
+
+    await expect(store.cancelConnecting(connection.id)).resolves.toBe(true);
+    expect(disconnectDb).toHaveBeenCalledWith(connection.id, firstAttempt);
+    expect(store.treeNodes[0]?.isLoading).toBe(false);
+
+    await store.loadDatabases(connection.id);
+
+    expect(connectDb).toHaveBeenCalledTimes(2);
+    expect(connectDb.mock.calls[1]?.[1]).not.toBe(firstAttempt);
+    expect(listDatabases).toHaveBeenCalledTimes(1);
+    expect(store.connectedIds.has(connection.id)).toBe(true);
+    expect(store.treeNodes[0]?.isExpanded).toBe(true);
+  }, 10_000);
+
+  it("allows reconnecting the same connection while a scoped disconnect is pending", async () => {
+    let resolveDisconnect!: () => void;
+    const connectDb = vi.fn().mockResolvedValue("pg-1");
+    const disconnectDb = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveDisconnect = resolve;
+        }),
+    );
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      connectDb,
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      disconnectDb,
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = postgresConnection({ connect_timeout_secs: 10 });
+    store.connections = [connection];
+    store.treeNodes = [
+      {
+        id: connection.id,
+        label: connection.name,
+        type: "connection",
+        connectionId: connection.id,
+        isLoading: true,
+        isExpanded: true,
+        children: [],
+      },
+    ];
+
+    await store.connect(connection);
+    expect(store.connectedIds.has(connection.id)).toBe(true);
+    const firstAttempt = connectDb.mock.calls[0]?.[1];
+
+    const disconnect = store.disconnect(connection.id);
+    expect(disconnectDb).toHaveBeenCalledWith(connection.id, firstAttempt);
+    expect(store.connectedIds.has(connection.id)).toBe(false);
+    expect(store.treeNodes[0]?.isLoading).toBe(false);
+    expect(store.treeNodes[0]?.isExpanded).toBe(false);
+
+    await store.connect(connection);
+    expect(connectDb).toHaveBeenCalledTimes(2);
+    expect(connectDb.mock.calls[1]?.[1]).not.toBe(firstAttempt);
+    expect(store.connectedIds.has(connection.id)).toBe(true);
+
+    resolveDisconnect();
+    await disconnect;
+
+    expect(store.connectedIds.has(connection.id)).toBe(true);
+    expect(store.connectionErrors[connection.id]).toBeUndefined();
+  }, 10_000);
+
+  it("keeps a newer reconnect error when an older scoped disconnect finishes later", async () => {
+    let resolveDisconnect!: () => void;
+    let connectCallCount = 0;
+    const connectDb = vi.fn(() => {
+      connectCallCount += 1;
+      return connectCallCount === 1 ? Promise.resolve("pg-1") : Promise.reject(new Error("reconnect failed"));
+    });
+    const disconnectDb = vi.fn(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveDisconnect = resolve;
+        }),
+    );
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      connectDb,
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      disconnectDb,
+      listInstalledAgents: vi.fn().mockResolvedValue([]),
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = postgresConnection({ connect_timeout_secs: 10 });
+    store.connections = [connection];
+
+    await store.connect(connection);
+    const firstAttempt = connectDb.mock.calls[0]?.[1];
+
+    const disconnect = store.disconnect(connection.id);
+    expect(disconnectDb).toHaveBeenCalledWith(connection.id, firstAttempt);
+
+    await expect(store.connect(connection)).rejects.toThrow("reconnect failed");
+    expect(store.connectionErrors[connection.id]).toBe("reconnect failed");
+
+    resolveDisconnect();
+    await disconnect;
+
+    expect(store.connectedIds.has(connection.id)).toBe(false);
+    expect(store.connectionErrors[connection.id]).toBe("reconnect failed");
+  }, 10_000);
+
+  it("scopes a normal disconnect to the active connection attempt when one is running", async () => {
+    let resolveConnect!: (connectionId: string) => void;
+    const connectDb = vi.fn(
+      () =>
+        new Promise<string>((resolve) => {
+          resolveConnect = resolve;
+        }),
+    );
+    const disconnectDb = vi.fn().mockResolvedValue(undefined);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      connectDb,
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      disconnectDb,
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { CONNECTION_ATTEMPT_CANCELLED_MESSAGE, useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = postgresConnection({ connect_timeout_secs: 10 });
+    store.connections = [connection];
+
+    const connect = store.connect(connection).catch((error) => error);
+    await vi.advanceTimersByTimeAsync(1);
+    const activeAttempt = connectDb.mock.calls[0]?.[1];
+
+    await store.disconnect(connection.id);
+    expect(disconnectDb).toHaveBeenCalledWith(connection.id, activeAttempt);
+    expect(store.connectedIds.has(connection.id)).toBe(false);
+
+    resolveConnect(connection.id);
+    await vi.advanceTimersByTimeAsync(1);
+    const error = await connect;
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error.message).toContain(CONNECTION_ATTEMPT_CANCELLED_MESSAGE);
+    expect(disconnectDb).toHaveBeenLastCalledWith(connection.id, activeAttempt);
+    expect(store.connectedIds.has(connection.id)).toBe(false);
+  }, 10_000);
+
+  it("cleans up backend state when a cancelled connection later succeeds", async () => {
+    let resolveConnect!: (connectionId: string) => void;
+    const connectDb = vi.fn(
+      () =>
+        new Promise<string>((resolve) => {
+          resolveConnect = resolve;
+        }),
+    );
+    const disconnectDb = vi.fn().mockResolvedValue(undefined);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      connectDb,
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      disconnectDb,
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { CONNECTION_ATTEMPT_CANCELLED_MESSAGE, useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = postgresConnection({ connect_timeout_secs: 10 });
+    store.connections = [connection];
+
+    const ensure = store.ensureConnected(connection.id).catch((error) => error);
+    await vi.advanceTimersByTimeAsync(1);
+    const attempt = connectDb.mock.calls[0]?.[1];
+
+    await expect(store.cancelConnecting(connection.id)).resolves.toBe(true);
+    expect(disconnectDb).toHaveBeenCalledTimes(1);
+    expect(disconnectDb).toHaveBeenCalledWith(connection.id, attempt);
+
+    resolveConnect(connection.id);
+    await vi.advanceTimersByTimeAsync(1);
+    const error = await ensure;
+
+    expect(error).toBeInstanceOf(Error);
+    expect(error.message).toContain(CONNECTION_ATTEMPT_CANCELLED_MESSAGE);
+    expect(disconnectDb).toHaveBeenCalledTimes(2);
+    expect(disconnectDb).toHaveBeenLastCalledWith(connection.id, attempt);
+    expect(store.connectedIds.has(connection.id)).toBe(false);
+    expect(store.connectionErrors[connection.id]).toBeUndefined();
+  }, 10_000);
+
+  it("keeps errors from earlier cancelled attempts hidden after a second cancel", async () => {
+    let rejectFirstConnect!: (error: Error) => void;
+    let rejectSecondConnect!: (error: Error) => void;
+    let connectCallCount = 0;
+    const connectDb = vi.fn(() => {
+      connectCallCount += 1;
+      return new Promise<string>((_, reject) => {
+        if (connectCallCount === 1) {
+          rejectFirstConnect = reject;
+        } else {
+          rejectSecondConnect = reject;
+        }
+      });
+    });
+    const disconnectDb = vi.fn().mockResolvedValue(undefined);
+
+    vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+    vi.doMock("@/lib/backend/api", () => ({
+      connectDb,
+      deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
+      disconnectDb,
+      saveConnections: vi.fn().mockResolvedValue(undefined),
+      saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
+    }));
+
+    const { CONNECTION_ATTEMPT_CANCELLED_MESSAGE, useConnectionStore } = await import("@/stores/connectionStore");
+    const store = useConnectionStore();
+    const connection = postgresConnection({ connect_timeout_secs: 10 });
+    store.connections = [connection];
+
+    const firstEnsure = store.ensureConnected(connection.id).catch((error) => error);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(connectDb).toHaveBeenCalledTimes(1);
+    await expect(store.cancelConnecting(connection.id)).resolves.toBe(true);
+
+    const secondEnsure = store.ensureConnected(connection.id).catch((error) => error);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(connectDb).toHaveBeenCalledTimes(2);
+    await expect(store.cancelConnecting(connection.id)).resolves.toBe(true);
+
+    rejectFirstConnect(new Error("first connection failed after cancel"));
+    const firstError = await firstEnsure;
+    expect(firstError).toBeInstanceOf(Error);
+    expect(firstError.message).toContain(CONNECTION_ATTEMPT_CANCELLED_MESSAGE);
+    expect(store.connectionErrors[connection.id]).toBeUndefined();
+
+    rejectSecondConnect(new Error("second connection failed after cancel"));
+    const secondError = await secondEnsure;
+    expect(secondError).toBeInstanceOf(Error);
+    expect(secondError.message).toContain(CONNECTION_ATTEMPT_CANCELLED_MESSAGE);
+    expect(store.connectionErrors[connection.id]).toBeUndefined();
+  }, 10_000);
+});
diff --git a/apps/desktop/src/stores/__tests__/queryStore.cancel.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.cancel.spec.ts
new file mode 100644
index 0000000..0abd6ca
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/queryStore.cancel.spec.ts
@@ -0,0 +1,77 @@
+import { createPinia, setActivePinia } from "pinia";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+}
+
+describe("queryStore cancel timeout recovery", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    installLocalStorage();
+    setActivePinia(createPinia());
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("clears cancelling state when cancelQuery does not return", async () => {
+    const cancelQuery = vi.fn(() => new Promise(() => undefined));
+
+    vi.doMock("@/lib/backend/api", () => ({ cancelQuery }));
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("pg-1", "app", "query_1");
+    store.setExecutingWithId(tabId, "exec-1");
+
+    const cancel = store.cancelTabExecution(tabId);
+    expect(store.tabs[0]?.isCancelling).toBe(true);
+
+    await vi.advanceTimersByTimeAsync(10_001);
+    const result = await cancel;
+
+    expect(result).toBe(false);
+    expect(cancelQuery).toHaveBeenCalledWith("exec-1");
+    expect(store.tabs[0]).toMatchObject({
+      isExecuting: false,
+      isCancelling: false,
+      executionId: undefined,
+    });
+    expect(store.tabs[0]?.result?.rows[0]?.[0]).toContain("Cancel request timed out");
+  }, 15_000);
+
+  it("clears cancelling state when cancel is acknowledged but execution does not settle", async () => {
+    const cancelQuery = vi.fn(() => Promise.resolve(true));
+
+    vi.doMock("@/lib/backend/api", () => ({ cancelQuery }));
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("duckdb-1", "main", "query_1");
+    store.setExecutingWithId(tabId, "exec-1");
+
+    const cancel = store.cancelTabExecution(tabId);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(await cancel).toBe(true);
+    expect(store.tabs[0]?.isCancelling).toBe(true);
+
+    await vi.advanceTimersByTimeAsync(2_001);
+
+    expect(cancelQuery).toHaveBeenCalledWith("exec-1");
+    expect(store.tabs[0]).toMatchObject({
+      isExecuting: false,
+      isCancelling: false,
+      executionId: undefined,
+    });
+    expect(store.tabs[0]?.result?.rows[0]?.[0]).toContain("Query canceled");
+  }, 15_000);
+});
diff --git a/apps/desktop/src/stores/__tests__/queryStore.database-open.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.database-open.spec.ts
new file mode 100644
index 0000000..8350367
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/queryStore.database-open.spec.ts
@@ -0,0 +1,242 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ACTIVE_TAB_STORAGE_KEY, OPEN_TABS_STORAGE_KEY } from "@/lib/app/openTabsPersistence";
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+  return data;
+}
+
+describe("queryStore database open state", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    installLocalStorage();
+    setActivePinia(createPinia());
+  });
+
+  it("tracks whether a connection database has open tabs", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+
+    const tabId = store.createTab("pg-1", "app", "query_1");
+
+    expect(store.isDatabaseOpen("pg-1", "app")).toBe(true);
+    expect(store.isDatabaseOpen("pg-1", "analytics")).toBe(false);
+    expect(store.isDatabaseOpen("pg-2", "app")).toBe(false);
+
+    store.updateDatabase(tabId, "analytics");
+
+    expect(store.isDatabaseOpen("pg-1", "app")).toBe(false);
+    expect(store.isDatabaseOpen("pg-1", "analytics")).toBe(true);
+
+    store.closeTab(tabId);
+
+    expect(store.isDatabaseOpen("pg-1", "analytics")).toBe(false);
+  });
+
+  it("keeps object browser viewport per tab and clears it on schema change", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+
+    const tabId = store.openObjectBrowser("pg-1", "app", "public");
+    store.updateObjectBrowserViewport(tabId, { scrollTop: 340, viewMode: "list" });
+
+    const tab = store.tabs.find((item) => item.id === tabId);
+    expect(tab?.objectBrowser?.viewport).toEqual({ scrollTop: 340, viewMode: "list" });
+
+    store.updateSchema(tabId, "archive");
+
+    expect(tab?.objectBrowser?.schema).toBe("archive");
+    expect(tab?.objectBrowser?.viewport).toBeUndefined();
+  });
+
+  it("keeps external catalog object browsers isolated", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+
+    const icebergTabId = store.openObjectBrowser("doris-1", "default", undefined, "iceberg_catalog");
+    const hiveTabId = store.openObjectBrowser("doris-1", "default", undefined, "hive_catalog");
+
+    expect(hiveTabId).not.toBe(icebergTabId);
+    expect(store.tabs.find((tab) => tab.id === icebergTabId)?.objectBrowser?.catalog).toBe("iceberg_catalog");
+    expect(store.tabs.find((tab) => tab.id === hiveTabId)?.objectBrowser?.catalog).toBe("hive_catalog");
+    expect(store.openObjectBrowser("doris-1", "default", undefined, "iceberg_catalog")).toBe(icebergTabId);
+  });
+
+  it("closes data and structure tabs for a dropped table object", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+
+    const queryId = store.createTab("pg-1", "app", "Query", "query", "public");
+    const dataId = store.createTab("pg-1", "app", "users", "data", "public");
+    store.setTableMeta(dataId, {
+      schema: "public",
+      tableName: "users",
+      tableType: "TABLE",
+      columns: [],
+      primaryKeys: [],
+    });
+    const otherSchemaDataId = store.createTab("pg-1", "app", "users", "data", "archive");
+    store.setTableMeta(otherSchemaDataId, {
+      schema: "archive",
+      tableName: "users",
+      tableType: "TABLE",
+      columns: [],
+      primaryKeys: [],
+    });
+    const otherConnectionDataId = store.createTab("pg-2", "app", "users", "data", "public");
+    store.setTableMeta(otherConnectionDataId, {
+      schema: "public",
+      tableName: "users",
+      tableType: "TABLE",
+      columns: [],
+      primaryKeys: [],
+    });
+    const structureId = store.openTableStructure("pg-1", "app", "public", "users");
+
+    store.activeTabId = dataId;
+    store.closeDroppedTableObjectTabs({
+      connectionId: "pg-1",
+      database: "app",
+      schema: "public",
+      name: "users",
+      objectType: "TABLE",
+    });
+
+    expect(store.tabs.some((tab) => tab.id === dataId)).toBe(false);
+    expect(store.tabs.some((tab) => tab.id === structureId)).toBe(false);
+    expect(store.tabs.some((tab) => tab.id === otherSchemaDataId)).toBe(true);
+    expect(store.tabs.some((tab) => tab.id === otherConnectionDataId)).toBe(true);
+    expect(store.tabs.some((tab) => tab.id === queryId)).toBe(true);
+    expect(store.activeTabId).not.toBe(dataId);
+  });
+
+  it("closes data tabs but keeps structure tabs for dropped views", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+
+    const dataId = store.createTab("pg-1", "app", "report_view", "data", "public");
+    store.setTableMeta(dataId, {
+      schema: "public",
+      tableName: "report_view",
+      tableType: "VIEW",
+      columns: [],
+      primaryKeys: [],
+    });
+    const structureId = store.openTableStructure("pg-1", "app", "public", "report_view");
+
+    store.closeDroppedTableObjectTabs({
+      connectionId: "pg-1",
+      database: "app",
+      schema: "public",
+      name: "report_view",
+      objectType: "VIEW",
+    });
+
+    expect(store.tabs.some((tab) => tab.id === dataId)).toBe(false);
+    expect(store.tabs.some((tab) => tab.id === structureId)).toBe(true);
+  });
+
+  it("matches dropped table schema candidates", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+
+    const dataId = store.createTab("pg-1", "app", "orders", "data", "app");
+    store.setTableMeta(dataId, {
+      schema: "app",
+      tableName: "orders",
+      tableType: "TABLE",
+      columns: [],
+      primaryKeys: [],
+    });
+    const structureId = store.openTableStructure("pg-1", "app", undefined, "orders");
+
+    store.closeDroppedTableObjectTabs({
+      connectionId: "pg-1",
+      database: "app",
+      schema: "app",
+      schemaCandidates: [undefined, "app"],
+      name: "orders",
+      objectType: "TABLE",
+    });
+
+    expect(store.tabs.some((tab) => tab.id === dataId)).toBe(false);
+    expect(store.tabs.some((tab) => tab.id === structureId)).toBe(false);
+  });
+
+  it("does not restore open tabs when launch restore mode is none", async () => {
+    const persistedTabs = JSON.stringify([
+      {
+        id: "tab-1",
+        title: "Query 1",
+        connectionId: "pg-1",
+        database: "app",
+        sql: "select 1",
+      },
+    ]);
+
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    const storage = installLocalStorage();
+    storage.set("dbx-editor-settings", JSON.stringify({ openTabsRestoreMode: "none" }));
+    storage.set("dbx-app-state:open_tabs", JSON.stringify({ tabs: JSON.parse(persistedTabs), activeTabId: "tab-1" }));
+    storage.set(OPEN_TABS_STORAGE_KEY, persistedTabs);
+    storage.set(ACTIVE_TAB_STORAGE_KEY, "tab-1");
+    setActivePinia(createPinia());
+
+    const { useSettingsStore } = await import("@/stores/settingsStore");
+    const { useQueryStore } = await import("@/stores/queryStore");
+    await useSettingsStore().initEditorSettings();
+    const store = useQueryStore();
+    await store.initOpenTabs();
+
+    expect(store.tabs).toEqual([]);
+    expect(store.activeTabId).toBeNull();
+    expect(storage.get(OPEN_TABS_STORAGE_KEY)).toBeUndefined();
+    expect(storage.get(ACTIVE_TAB_STORAGE_KEY)).toBeUndefined();
+    expect(JSON.parse(storage.get("dbx-app-state:open_tabs") ?? "{}")).toEqual({ tabs: [], activeTabId: null });
+  });
+
+  it("restores only pinned tabs when launch restore mode is pinned", async () => {
+    const persistedTabs = JSON.stringify([
+      {
+        id: "tab-1",
+        title: "Pinned",
+        connectionId: "pg-1",
+        database: "app",
+        sql: "select 1",
+        pinned: true,
+      },
+      {
+        id: "tab-2",
+        title: "Regular",
+        connectionId: "pg-1",
+        database: "app",
+        sql: "select 2",
+      },
+    ]);
+
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    const storage = installLocalStorage();
+    storage.set("dbx-editor-settings", JSON.stringify({ openTabsRestoreMode: "pinned" }));
+    storage.set(OPEN_TABS_STORAGE_KEY, persistedTabs);
+    storage.set(ACTIVE_TAB_STORAGE_KEY, "tab-2");
+    setActivePinia(createPinia());
+
+    const { useSettingsStore } = await import("@/stores/settingsStore");
+    const { useQueryStore } = await import("@/stores/queryStore");
+    await useSettingsStore().initEditorSettings();
+    const store = useQueryStore();
+    await store.initOpenTabs();
+
+    expect(store.tabs.map((tab) => tab.id)).toEqual(["tab-1"]);
+    expect(store.activeTabId).toBe("tab-1");
+  });
+});
diff --git a/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts
new file mode 100644
index 0000000..ec2b40e
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/queryStore.hiddenPrimaryKey.spec.ts
@@ -0,0 +1,475 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const executeMulti = vi.fn();
+const executeQuery = vi.fn();
+const analyzeEditableQueryEditability = vi.fn();
+const getColumns = vi.fn();
+const listIndexes = vi.fn();
+const getConnectionConfig = vi.fn();
+const buildSortedQuerySql = vi.fn();
+const buildDataGridCountSql = vi.fn();
+const prepareQueryPaginationExecutionPlan = vi.fn(async (options) => ({
+  sqlToExecute: options.sql,
+  pageSql: undefined,
+  pageLimit: undefined,
+  pageOffset: undefined,
+  countSql: undefined,
+  useAgentResultSession: false,
+}));
+const editorSettings = {
+  pageSize: 100,
+  autoCalculateTotalRows: false,
+};
+
+vi.mock("@/lib/backend/api", () => ({
+  analyzeEditableQueryEditability,
+  buildDataGridCountSql,
+  buildSortedQuerySql,
+  closeClientConnectionSession: vi.fn().mockResolvedValue(undefined),
+  closeQuerySession: vi.fn().mockResolvedValue(undefined),
+  executeMulti,
+  executeQuery,
+  getColumns,
+  listIndexes,
+  prepareQueryPaginationExecutionPlan,
+  saveOpenTabsState: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock("@/stores/connectionStore", () => ({
+  useConnectionStore: () => ({
+    ensureConnected: vi.fn().mockResolvedValue(undefined),
+    getConfig: getConnectionConfig,
+    recordConnectionLostError: vi.fn(),
+  }),
+}));
+
+vi.mock("@/stores/settingsStore", () => ({
+  useSettingsStore: () => ({
+    editorSettings,
+  }),
+}));
+
+function queryAnalysis(sql: string) {
+  const hidden = sql.includes("__DBX_PK_0");
+  return {
+    editable: true,
+    analysis: {
+      schema: undefined,
+      tableName: "users",
+      selectStar: false,
+      columns: [{ sourceName: "name", resultName: "name", expression: "name" }, ...(hidden ? [{ sourceName: "id", resultName: "__DBX_PK_0", expression: "`id`" }] : [])],
+    },
+  };
+}
+
+describe("queryStore hidden primary key editing", () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    const { clearTableMetadataCache } = await import("@/lib/metadata/tableMetadataCache");
+    clearTableMetadataCache();
+    setActivePinia(createPinia());
+    getConnectionConfig.mockReturnValue({ id: "mysql-1", name: "MySQL", db_type: "mysql", database: "app", query_timeout_secs: 30 });
+    getColumns.mockResolvedValue([
+      { name: "id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+      { name: "name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
+    ]);
+    listIndexes.mockResolvedValue([]);
+    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => queryAnalysis(sql));
+    buildSortedQuerySql.mockImplementation(async (options) => ({ ok: true, sql: `${options.originalSql} ORDER BY ${options.column} ${options.direction.toUpperCase()}` }));
+    buildDataGridCountSql.mockResolvedValue("SELECT COUNT(*) FROM `users`");
+    prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
+      sqlToExecute: options.sql,
+      pageSql: undefined,
+      pageLimit: undefined,
+      pageOffset: undefined,
+      countSql: undefined,
+      useAgentResultSession: false,
+    }));
+    editorSettings.pageSize = 100;
+    editorSettings.autoCalculateTotalRows = false;
+    executeQuery.mockResolvedValue({
+      columns: ["row_count"],
+      rows: [[0]],
+      affected_rows: 0,
+      execution_time_ms: 1,
+    });
+    executeMulti.mockResolvedValue([
+      {
+        columns: ["name", "__DBX_PK_0"],
+        rows: [["Alice", 7]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    ]);
+  });
+
+  it("executes and hides an omitted primary key while retaining its source mapping", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT name FROM users");
+
+    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT name, `id` AS `__DBX_PK_0` FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.result?.hidden_column_indexes).toEqual([1]);
+    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "id"]));
+    expect(tab.queryAnalysis).toBeDefined();
+    expect(tab.queryAnalysis?.allowInsert).toBe(false);
+    expect(tab.queryEditabilityReason).toBeUndefined();
+  });
+
+  it("keeps hidden primary keys and editability after database sorting", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT name FROM users", {
+      resultBaseSql: "SELECT name FROM users",
+      querySort: {
+        resultColumns: ["name"],
+        columnIndex: 0,
+        column: "name",
+        direction: "asc",
+      },
+    });
+
+    expect(buildSortedQuerySql).toHaveBeenCalledWith({
+      originalSql: "SELECT name, `id` AS `__DBX_PK_0` FROM users",
+      databaseType: "mysql",
+      resultColumns: ["name", "__DBX_PK_0"],
+      columnIndex: 0,
+      column: "name",
+      direction: "asc",
+    });
+    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT name, `id` AS `__DBX_PK_0` FROM users ORDER BY name ASC", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.result?.hidden_column_indexes).toEqual([1]);
+    expect(tab.resultSortedSql).toBe("SELECT name, `id` AS `__DBX_PK_0` FROM users ORDER BY name ASC");
+    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "id"]));
+    expect(tab.queryAnalysis).toBeDefined();
+  });
+
+  it("preserves the original query behavior when the primary key is already returned", async () => {
+    analyzeEditableQueryEditability.mockResolvedValue({
+      editable: true,
+      analysis: {
+        schema: undefined,
+        tableName: "users",
+        selectStar: false,
+        columns: [
+          { sourceName: "id", resultName: "id", expression: "id" },
+          { sourceName: "name", resultName: "name", expression: "name" },
+        ],
+      },
+    });
+    executeMulti.mockResolvedValue([
+      {
+        columns: ["id", "name"],
+        rows: [[7, "Alice"]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    ]);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT id, name FROM users");
+
+    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT id, name FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.result?.hidden_column_indexes).toBeUndefined();
+    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["id", "name"]));
+    expect(tab.queryAnalysis?.allowInsert).toBeUndefined();
+    expect(tab.queryEditabilityReason).toBeUndefined();
+  });
+
+  it("loads unqualified Oracle metadata from the login schema instead of the service name", async () => {
+    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "XEPDB1", query_timeout_secs: 30 });
+    getColumns.mockResolvedValue([
+      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+      { name: "NAME", data_type: "VARCHAR2", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
+    ]);
+    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => {
+      const hidden = sql.includes("__DBX_PK_0");
+      return {
+        editable: true,
+        analysis: {
+          schema: undefined,
+          tableName: "DBX_HIDDEN_PK_EDIT_TEST",
+          selectStar: false,
+          columns: [{ sourceName: "NAME", resultName: "NAME", expression: "NAME" }, ...(hidden ? [{ sourceName: "ID", resultName: "__DBX_PK_0", expression: '"ID"' }] : [])],
+        },
+      };
+    });
+    executeMulti.mockResolvedValue([
+      {
+        columns: ["NAME", "__DBX_PK_0"],
+        rows: [["Alice", 7]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    ]);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("oracle-1", "XEPDB1", "Query");
+
+    await store.executeTabSql(tabId, "SELECT NAME FROM DBX_HIDDEN_PK_EDIT_TEST");
+
+    expect(getColumns).toHaveBeenCalledWith("oracle-1", "XEPDB1", "", "DBX_HIDDEN_PK_EDIT_TEST", undefined);
+    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "XEPDB1", 'SELECT NAME, "ID" AS "__DBX_PK_0" FROM DBX_HIDDEN_PK_EDIT_TEST', undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.result?.hidden_column_indexes).toEqual([1]);
+    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["NAME", "ID"]));
+    expect(tab.queryAnalysis).toBeDefined();
+    expect(tab.queryAnalysis?.allowInsert).toBe(false);
+    expect(tab.queryEditabilityReason).toBeUndefined();
+  });
+
+  it("appends only the missing part of a composite primary key", async () => {
+    getColumns.mockResolvedValue([
+      { name: "tenant_id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+      { name: "item_id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+      { name: "name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
+    ]);
+    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => {
+      const hidden = sql.includes("__DBX_PK_0");
+      return {
+        editable: true,
+        analysis: {
+          schema: undefined,
+          tableName: "items",
+          selectStar: false,
+          columns: [{ sourceName: "tenant_id", resultName: "tenant_id", expression: "tenant_id" }, { sourceName: "name", resultName: "name", expression: "name" }, ...(hidden ? [{ sourceName: "item_id", resultName: "__DBX_PK_0", expression: "`item_id`" }] : [])],
+        },
+      };
+    });
+    executeMulti.mockResolvedValue([
+      {
+        columns: ["tenant_id", "name", "__DBX_PK_0"],
+        rows: [[3, "Alice", 7]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    ]);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT tenant_id, name FROM items");
+
+    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT tenant_id, name, `item_id` AS `__DBX_PK_0` FROM items", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.result?.hidden_column_indexes).toEqual([2]);
+    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["tenant_id", "name", "item_id"]));
+  });
+
+  it("executes the original SQL when metadata loading fails", async () => {
+    getColumns.mockRejectedValue(new Error("metadata unavailable"));
+    executeMulti.mockResolvedValue([
+      {
+        columns: ["name"],
+        rows: [["Alice"]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    ]);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT name FROM users");
+
+    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT name FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    await vi.waitFor(() => expect(tab.queryEditabilityReason).toBe("metadata-unavailable"));
+    expect(tab.result?.hidden_column_indexes).toBeUndefined();
+  });
+
+  it("does not hide a unique index when the table has no declared primary key", async () => {
+    getColumns.mockResolvedValue([
+      { name: "email", data_type: "varchar", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
+      { name: "name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
+    ]);
+    listIndexes.mockResolvedValue([{ name: "uq_users_email", columns: ["email"], is_unique: true, is_primary: false }]);
+    executeMulti.mockResolvedValue([
+      {
+        columns: ["name"],
+        rows: [["Alice"]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    ]);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT name FROM users");
+
+    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT name FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    await vi.waitFor(() => expect(tab.queryEditabilityReason).toBe("primary-key-not-returned"));
+    expect(tab.result?.hidden_column_indexes).toBeUndefined();
+  });
+
+  it("hides returned internal keys but remains read-only when another hidden key is missing", async () => {
+    getColumns.mockResolvedValue([
+      { name: "tenant_id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+      { name: "item_id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+      { name: "name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
+    ]);
+    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => {
+      const hidden = sql.includes("__DBX_PK_0");
+      return {
+        editable: true,
+        analysis: {
+          schema: undefined,
+          tableName: "items",
+          selectStar: false,
+          columns: [
+            { sourceName: "name", resultName: "name", expression: "name" },
+            ...(hidden
+              ? [
+                  { sourceName: "tenant_id", resultName: "__DBX_PK_0", expression: "`tenant_id`" },
+                  { sourceName: "item_id", resultName: "__DBX_PK_1", expression: "`item_id`" },
+                ]
+              : []),
+          ],
+        },
+      };
+    });
+    executeMulti.mockResolvedValue([
+      {
+        columns: ["name", "__DBX_PK_1"],
+        rows: [["Alice", 7]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    ]);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT name FROM items");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.result?.hidden_column_indexes).toEqual([1]);
+    await vi.waitFor(() => expect(tab.queryEditabilityReason).toBe("primary-key-not-returned"));
+    expect(tab.queryAnalysis).toBeUndefined();
+  });
+
+  it("records the returned row count when a page is known to be incomplete without count sql", async () => {
+    prepareQueryPaginationExecutionPlan.mockResolvedValue({
+      sqlToExecute: "SELECT name FROM users LIMIT 100 OFFSET 0",
+      pageSql: "SELECT name FROM users LIMIT 100 OFFSET 0",
+      pageLimit: 100,
+      pageOffset: 0,
+      countSql: undefined,
+      useAgentResultSession: false,
+    });
+    executeMulti.mockResolvedValue([
+      {
+        columns: ["name"],
+        rows: Array.from({ length: 42 }, (_, index) => [`user-${index}`]),
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    ]);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT name FROM users");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.resultTotalRowCount).toBe(42);
+    expect(tab.resultTotalRowCountLoading).toBe(false);
+    expect(executeQuery).not.toHaveBeenCalled();
+  });
+
+  it("does not treat an empty later page as the total row count", async () => {
+    prepareQueryPaginationExecutionPlan.mockResolvedValue({
+      sqlToExecute: "SELECT name FROM users LIMIT 100 OFFSET 200",
+      pageSql: "SELECT name FROM users LIMIT 100 OFFSET 200",
+      pageLimit: 100,
+      pageOffset: 200,
+      countSql: undefined,
+      useAgentResultSession: false,
+    });
+    executeMulti.mockResolvedValue([
+      {
+        columns: ["name"],
+        rows: [],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    ]);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT name FROM users");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.resultTotalRowCount).toBeUndefined();
+    expect(tab.resultTotalRowCountLoading).toBe(false);
+    expect(executeQuery).not.toHaveBeenCalled();
+  });
+
+  it("automatically counts table data totals when the setting is enabled", async () => {
+    editorSettings.autoCalculateTotalRows = true;
+    executeMulti.mockResolvedValue([
+      {
+        columns: ["id", "name"],
+        rows: Array.from({ length: 100 }, (_, index) => [index + 1, `user-${index + 1}`]),
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    ]);
+    executeQuery.mockResolvedValue({
+      columns: ["row_count"],
+      rows: [[123]],
+      affected_rows: 0,
+      execution_time_ms: 1,
+    });
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "users", "data", "public");
+    store.setTableMeta(tabId, {
+      schema: "public",
+      tableName: "users",
+      columns: [
+        { name: "id", data_type: "int", is_nullable: false, is_primary_key: true, column_default: null, extra: null },
+        { name: "name", data_type: "varchar", is_nullable: true, is_primary_key: false, column_default: null, extra: null },
+      ],
+      primaryKeys: ["id"],
+    });
+
+    await store.executeTabSql(tabId, "SELECT id, name FROM users LIMIT 100", {
+      pagination: { limit: 100, offset: 0 },
+    });
+
+    expect(buildDataGridCountSql).toHaveBeenCalledWith({
+      databaseType: "mysql",
+      catalog: undefined,
+      schema: "public",
+      tableName: "users",
+      whereInput: undefined,
+    });
+    await vi.waitFor(() => expect(executeQuery).toHaveBeenCalledWith("mysql-1", "app", "SELECT COUNT(*) FROM `users`", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 })));
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    await vi.waitFor(() => expect(tab.resultTotalRowCount).toBe(123));
+    expect(tab.resultTotalRowCountLoading).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/stores/__tests__/queryStore.multiStatementError.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.multiStatementError.spec.ts
new file mode 100644
index 0000000..bb758e7
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/queryStore.multiStatementError.spec.ts
@@ -0,0 +1,125 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  analyzeEditableQueryEditability: vi.fn(),
+  closeClientConnectionSession: vi.fn(),
+  closeQuerySession: vi.fn(),
+  executeMulti: vi.fn(),
+  getConnectionConfig: vi.fn(),
+  prepareQueryPaginationExecutionPlan: vi.fn(),
+  saveOpenTabsState: vi.fn(),
+}));
+
+vi.mock("@/lib/backend/api", () => ({
+  analyzeEditableQueryEditability: mocks.analyzeEditableQueryEditability,
+  closeClientConnectionSession: mocks.closeClientConnectionSession,
+  closeQuerySession: mocks.closeQuerySession,
+  executeMulti: mocks.executeMulti,
+  prepareQueryPaginationExecutionPlan: mocks.prepareQueryPaginationExecutionPlan,
+  saveOpenTabsState: mocks.saveOpenTabsState,
+}));
+
+vi.mock("@/stores/connectionStore", () => ({
+  useConnectionStore: () => ({
+    ensureConnected: vi.fn().mockResolvedValue(undefined),
+    getConfig: mocks.getConnectionConfig,
+    recordConnectionLostError: vi.fn(),
+  }),
+}));
+
+vi.mock("@/stores/settingsStore", () => ({
+  useSettingsStore: () => ({
+    editorSettings: { autoCalculateTotalRows: false, pageSize: 100 },
+  }),
+}));
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+}
+
+describe("queryStore multi-statement errors", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.unstubAllGlobals();
+    installLocalStorage();
+    setActivePinia(createPinia());
+    mocks.getConnectionConfig.mockReturnValue({
+      id: "mysql-1",
+      name: "MySQL",
+      db_type: "mysql",
+      database: "app",
+      query_timeout_secs: 30,
+    });
+    mocks.prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
+      sqlToExecute: options.sql,
+      pageSql: undefined,
+      pageLimit: undefined,
+      pageOffset: undefined,
+      countSql: undefined,
+      useAgentResultSession: false,
+    }));
+    mocks.analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "multiple-statements" });
+  });
+
+  it("opens the first error result from a mixed result batch", async () => {
+    mocks.executeMulti.mockResolvedValue([
+      { columns: ["value"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+      { columns: ["Error"], execution_error: true, rows: [["no such table: missing"]], affected_rows: 0, execution_time_ms: 1 },
+    ]);
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT 1 AS value; SELECT * FROM missing");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.activeResultIndex).toBe(1);
+    expect(tab.result?.columns).toEqual(["Error"]);
+  });
+
+  it("does not promote an unmarked Error alias without type metadata as a batch failure", async () => {
+    mocks.executeMulti.mockResolvedValue([
+      { columns: ["value"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+      { columns: ["Error"], rows: [[2]], affected_rows: 0, execution_time_ms: 1 },
+    ]);
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT 1 AS value; SELECT 2 AS Error");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.activeResultIndex).toBe(0);
+    expect(tab.result?.columns).toEqual(["value"]);
+  });
+
+  it("does not apply the MySQL result heuristic to a JDBC MySQL dialect", async () => {
+    mocks.getConnectionConfig.mockReturnValue({
+      id: "mysql-1",
+      name: "JDBC MySQL",
+      db_type: "jdbc",
+      connection_string: "jdbc:mysql://localhost:3306/app",
+      database: "app",
+      query_timeout_secs: 30,
+    });
+    mocks.executeMulti.mockResolvedValue([
+      { columns: ["value"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+      { columns: ["Error"], rows: [[2]], affected_rows: 0, execution_time_ms: 1 },
+    ]);
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.executeTabSql(tabId, "SELECT 1 AS value; SELECT 2 AS Error");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(tab.activeResultIndex).toBe(0);
+    expect(tab.result?.columns).toEqual(["value"]);
+  });
+});
diff --git a/apps/desktop/src/stores/__tests__/queryStore.mysqlExplain.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.mysqlExplain.spec.ts
new file mode 100644
index 0000000..a95069d
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/queryStore.mysqlExplain.spec.ts
@@ -0,0 +1,254 @@
+import { createPinia, setActivePinia } from "pinia";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ParsedExplainPlan } from "@/lib/diagram/explainPlan";
+import type { QueryResult } from "@/types/database";
+
+const mocks = vi.hoisted(() => ({
+  buildExplainSql: vi.fn(),
+  parseExplainResult: vi.fn(),
+  parseDamengExplainText: vi.fn(),
+  parseOracleExplainText: vi.fn(),
+  executeQuery: vi.fn(),
+  cancelQuery: vi.fn(),
+  closeClientConnectionSession: vi.fn(),
+  saveOpenTabsState: vi.fn(),
+  getConfig: vi.fn(),
+}));
+
+vi.mock("@/lib/diagram/explainPlan", () => ({
+  buildExplainSql: mocks.buildExplainSql,
+  parseExplainResult: mocks.parseExplainResult,
+  parseDamengExplainText: mocks.parseDamengExplainText,
+  parseOracleExplainText: mocks.parseOracleExplainText,
+}));
+
+vi.mock("@/lib/backend/api", () => ({
+  executeQuery: mocks.executeQuery,
+  cancelQuery: mocks.cancelQuery,
+  closeClientConnectionSession: mocks.closeClientConnectionSession,
+  saveOpenTabsState: mocks.saveOpenTabsState,
+}));
+
+vi.mock("@/stores/connectionStore", () => ({
+  useConnectionStore: () => ({
+    getConfig: mocks.getConfig,
+    recordConnectionLostError: vi.fn(),
+  }),
+}));
+
+vi.mock("@/stores/settingsStore", () => ({
+  useSettingsStore: () => ({
+    editorSettings: { pageSize: 100, openTabsRestoreMode: "all", confirmUnsavedSqlClose: false },
+  }),
+}));
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((promiseResolve, promiseReject) => {
+    resolve = promiseResolve;
+    reject = promiseReject;
+  });
+  return { promise, resolve, reject };
+}
+
+const standardSql = "EXPLAIN SELECT * FROM users WHERE status = 'active'";
+const jsonSql = "EXPLAIN FORMAT=JSON SELECT * FROM users WHERE status = 'active'";
+const sourceSql = "SELECT * FROM users WHERE status = 'active'";
+
+const tableResult: QueryResult = {
+  columns: ["id", "select_type", "table", "type", "rows", "Extra"],
+  rows: [[1, "SIMPLE", "users", "ref", 12, "Using where"]],
+  affected_rows: 0,
+  execution_time_ms: 4,
+};
+
+const jsonResult: QueryResult = {
+  columns: ["EXPLAIN"],
+  rows: [['{"query_block":{"select_id":1}}']],
+  affected_rows: 0,
+  execution_time_ms: 5,
+};
+
+const visualPlan: ParsedExplainPlan = {
+  databaseType: "mysql",
+  raw: { query_block: { select_id: 1 } },
+  nodes: [],
+};
+
+function configureSuccessfulBuilds() {
+  mocks.buildExplainSql.mockImplementation(async (_databaseType: string, _sql: string, format: "standard" | "json") => ({
+    ok: true,
+    sql: format === "standard" ? standardSql : jsonSql,
+  }));
+}
+
+describe("queryStore MySQL dual explain", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.unstubAllGlobals();
+    installLocalStorage();
+    setActivePinia(createPinia());
+
+    mocks.getConfig.mockReturnValue({
+      id: "mysql-1",
+      name: "MySQL",
+      db_type: "mysql",
+      query_timeout_secs: 45,
+    });
+    mocks.cancelQuery.mockResolvedValue(true);
+    mocks.closeClientConnectionSession.mockResolvedValue(undefined);
+    mocks.saveOpenTabsState.mockResolvedValue(undefined);
+    mocks.parseExplainResult.mockReturnValue(visualPlan);
+    configureSuccessfulBuilds();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("executes standard EXPLAIN before JSON EXPLAIN using one execution and client session", async () => {
+    const standardExecution = deferred<QueryResult>();
+    mocks.executeQuery.mockImplementationOnce(() => standardExecution.promise).mockResolvedValueOnce(jsonResult);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query", "query", "analytics");
+    const explain = store.explainTabSql(tabId, sourceSql, "mysql");
+
+    await vi.waitFor(() => expect(mocks.executeQuery).toHaveBeenCalledTimes(1));
+    expect(mocks.buildExplainSql).toHaveBeenNthCalledWith(1, "mysql", sourceSql, "standard");
+    expect(mocks.buildExplainSql).toHaveBeenNthCalledWith(2, "mysql", sourceSql, "json");
+    expect(mocks.executeQuery).toHaveBeenNthCalledWith(1, "mysql-1", "app", standardSql, "analytics", expect.any(String), expect.objectContaining({ timeoutSecs: 45 }));
+
+    standardExecution.resolve(tableResult);
+    await vi.waitFor(() => expect(mocks.executeQuery).toHaveBeenCalledTimes(2));
+    await explain;
+
+    const standardCall = mocks.executeQuery.mock.calls[0]!;
+    const jsonCall = mocks.executeQuery.mock.calls[1]!;
+    const executionId = standardCall[4] as string;
+    const standardOptions = standardCall[5] as { clientSessionId: string; timeoutSecs: number };
+    const jsonOptions = jsonCall[5] as { clientSessionId: string; timeoutSecs: number };
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+
+    expect(jsonCall[0]).toBe("mysql-1");
+    expect(jsonCall[1]).toBe("app");
+    expect(jsonCall[2]).toBe(jsonSql);
+    expect(jsonCall[3]).toBe("analytics");
+    expect(jsonCall[4]).toBe(executionId);
+    expect(jsonOptions.clientSessionId).toBe(standardOptions.clientSessionId);
+    expect(standardOptions.clientSessionId).toBe(`${tabId}:explain:${executionId}`);
+    expect(jsonOptions.timeoutSecs).toBe(45);
+    expect(mocks.parseExplainResult).toHaveBeenCalledWith("mysql", jsonResult);
+    expect(tab.explainTableResult).toEqual(tableResult);
+    expect(tab.explainPlan).toEqual(visualPlan);
+    expect(tab.explainTableSql).toBe(standardSql);
+    expect(tab.explainSql).toBe(jsonSql);
+    expect(tab.isExplaining).toBe(false);
+    expect(tab.explainExecutionId).toBeUndefined();
+    await vi.waitFor(() => expect(mocks.closeClientConnectionSession).toHaveBeenCalledWith("mysql-1", "app", standardOptions.clientSessionId));
+  });
+
+  it("keeps the JSON visual plan when the standard table EXPLAIN fails", async () => {
+    mocks.executeQuery.mockRejectedValueOnce(new Error("standard EXPLAIN failed")).mockResolvedValueOnce(jsonResult);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await store.explainTabSql(tabId, sourceSql, "mysql");
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(mocks.executeQuery).toHaveBeenNthCalledWith(1, "mysql-1", "app", standardSql, undefined, expect.any(String), expect.any(Object));
+    expect(mocks.executeQuery).toHaveBeenNthCalledWith(2, "mysql-1", "app", jsonSql, undefined, expect.any(String), expect.any(Object));
+    expect(tab.explainTableResult).toBeUndefined();
+    expect(tab.explainTableError).toBe("standard EXPLAIN failed");
+    expect(tab.explainPlan).toEqual(visualPlan);
+    expect(tab.explainError).toBeUndefined();
+    expect(tab.isExplaining).toBe(false);
+  });
+
+  it.each([
+    ["is acknowledged", () => mocks.cancelQuery.mockResolvedValue(true), true],
+    ["returns false", () => mocks.cancelQuery.mockResolvedValue(false), false],
+    ["rejects", () => mocks.cancelQuery.mockRejectedValue(new Error("cancel request failed")), false],
+  ])("does not start JSON EXPLAIN when cancellation %s during standard EXPLAIN", async (_label, configureCancel, expectedResult) => {
+    const standardExecution = deferred<QueryResult>();
+    mocks.executeQuery.mockImplementationOnce(() => standardExecution.promise);
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+    const explain = store.explainTabSql(tabId, sourceSql, "mysql");
+
+    await vi.waitFor(() => expect(mocks.executeQuery).toHaveBeenCalledTimes(1));
+    const executionId = store.tabs.find((item) => item.id === tabId)?.explainExecutionId;
+    expect(executionId).toEqual(expect.any(String));
+
+    configureCancel();
+    await expect(store.cancelTabExplain(tabId)).resolves.toBe(expectedResult);
+    expect(mocks.cancelQuery).toHaveBeenCalledWith(executionId);
+
+    standardExecution.resolve(tableResult);
+    await explain;
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(mocks.executeQuery).toHaveBeenCalledTimes(1);
+    expect(tab.explainTableResult).toBeUndefined();
+    expect(tab.explainPlan).toBeUndefined();
+    expect(tab.isExplaining).toBe(false);
+    expect(tab.explainExecutionId).toBeUndefined();
+  });
+
+  it.each([
+    ["returns false", () => mocks.cancelQuery.mockResolvedValue(false)],
+    ["rejects", () => mocks.cancelQuery.mockRejectedValue(new Error("cancel request failed"))],
+  ])("does not start either EXPLAIN when cancellation %s while SQL formats are building", async (_label, configureCancel) => {
+    const standardBuild = deferred<{ ok: true; sql: string }>();
+    const jsonBuild = deferred<{ ok: true; sql: string }>();
+    mocks.buildExplainSql.mockImplementation((_databaseType: string, _sql: string, format: "standard" | "json") => (format === "standard" ? standardBuild.promise : jsonBuild.promise));
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+    const explain = store.explainTabSql(tabId, sourceSql, "mysql");
+
+    await vi.waitFor(() => expect(mocks.buildExplainSql).toHaveBeenCalledTimes(2));
+    configureCancel();
+    await expect(store.cancelTabExplain(tabId)).resolves.toBe(false);
+
+    standardBuild.resolve({ ok: true, sql: standardSql });
+    jsonBuild.resolve({ ok: true, sql: jsonSql });
+    await explain;
+
+    expect(mocks.executeQuery).not.toHaveBeenCalled();
+  });
+
+  it("clears loading state when one of the format builders rejects", async () => {
+    mocks.buildExplainSql.mockRejectedValueOnce(new Error("format builder unavailable"));
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+    const tabId = store.createTab("mysql-1", "app", "Query");
+
+    await expect(store.explainTabSql(tabId, sourceSql, "mysql")).resolves.toEqual({ ok: true, sql: "" });
+
+    const tab = store.tabs.find((item) => item.id === tabId)!;
+    expect(mocks.executeQuery).not.toHaveBeenCalled();
+    expect(tab).toMatchObject({
+      isExplaining: false,
+      explainExecutionId: undefined,
+      explainError: "format builder unavailable",
+    });
+  });
+});
diff --git a/apps/desktop/src/stores/__tests__/queryStore.switchTab.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.switchTab.spec.ts
new file mode 100644
index 0000000..7728b89
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/queryStore.switchTab.spec.ts
@@ -0,0 +1,71 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+describe("queryStore switchTab", () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllGlobals();
+    setActivePinia(createPinia());
+  });
+
+  it("deactivates settings page when switching to the same tab", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const { useSettingsStore } = await import("@/stores/settingsStore");
+    const queryStore = useQueryStore();
+    const settingsStore = useSettingsStore();
+
+    // Create a data tab
+    const tabId = queryStore.createTab("pg-1", "app", "users", "data", "public");
+    queryStore.activeTabId = tabId;
+
+    // Simulate settings page being active
+    settingsStore.settingsPageActive = true;
+
+    // Switch to the same tab (simulating reuseDataTab scenario)
+    queryStore.switchTab(tabId);
+
+    // Settings page should be deactivated
+    expect(settingsStore.settingsPageActive).toBe(false);
+    // Active tab should still be the same
+    expect(queryStore.activeTabId).toBe(tabId);
+  });
+
+  it("deactivates settings page when switching to a different tab", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const { useSettingsStore } = await import("@/stores/settingsStore");
+    const queryStore = useQueryStore();
+    const settingsStore = useSettingsStore();
+
+    // Create two data tabs
+    const tab1Id = queryStore.createTab("pg-1", "app", "users", "data", "public");
+    const tab2Id = queryStore.createTab("pg-1", "app", "orders", "data", "public");
+    queryStore.activeTabId = tab1Id;
+
+    // Simulate settings page being active
+    settingsStore.settingsPageActive = true;
+
+    // Switch to a different tab
+    queryStore.switchTab(tab2Id);
+
+    // Settings page should be deactivated
+    expect(settingsStore.settingsPageActive).toBe(false);
+    // Active tab should be the new tab
+    expect(queryStore.activeTabId).toBe(tab2Id);
+  });
+
+  it("deactivates settings page when reopening an existing special tab", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const { useSettingsStore } = await import("@/stores/settingsStore");
+    const queryStore = useQueryStore();
+    const settingsStore = useSettingsStore();
+
+    const tabId = queryStore.openObjectBrowser("pg-1", "app", "public");
+    settingsStore.settingsPageActive = true;
+
+    const reopenedTabId = queryStore.openObjectBrowser("pg-1", "app", "public");
+
+    expect(reopenedTabId).toBe(tabId);
+    expect(queryStore.activeTabId).toBe(tabId);
+    expect(settingsStore.settingsPageActive).toBe(false);
+  });
+});
diff --git a/apps/desktop/src/stores/__tests__/queryStore.tableDataRefresh.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.tableDataRefresh.spec.ts
new file mode 100644
index 0000000..4e7c07d
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/queryStore.tableDataRefresh.spec.ts
@@ -0,0 +1,124 @@
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  buildTableSelectSql: vi.fn(),
+  closeClientConnectionSession: vi.fn(),
+  closeQuerySession: vi.fn(),
+  executeMulti: vi.fn(),
+  getConnectionConfig: vi.fn(),
+  saveOpenTabsState: vi.fn(),
+}));
+
+vi.mock("@/lib/backend/api", () => ({
+  buildTableSelectSql: mocks.buildTableSelectSql,
+  closeClientConnectionSession: mocks.closeClientConnectionSession,
+  closeQuerySession: mocks.closeQuerySession,
+  executeMulti: mocks.executeMulti,
+  saveOpenTabsState: mocks.saveOpenTabsState,
+}));
+
+vi.mock("@/stores/connectionStore", () => ({
+  useConnectionStore: () => ({
+    ensureConnected: vi.fn().mockResolvedValue(undefined),
+    getConfig: mocks.getConnectionConfig,
+    recordConnectionLostError: vi.fn(),
+  }),
+}));
+
+vi.mock("@/stores/settingsStore", () => ({
+  useSettingsStore: () => ({
+    editorSettings: { pageSize: 100 },
+  }),
+}));
+
+function installLocalStorage() {
+  const data = new Map<string, string>();
+  vi.stubGlobal("localStorage", {
+    getItem: vi.fn((key: string) => data.get(key) ?? null),
+    setItem: vi.fn((key: string, value: string) => data.set(key, value)),
+    removeItem: vi.fn((key: string) => data.delete(key)),
+  });
+}
+
+describe("queryStore table data refresh", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.unstubAllGlobals();
+    installLocalStorage();
+    setActivePinia(createPinia());
+    mocks.getConnectionConfig.mockReturnValue({
+      id: "pg-1",
+      name: "Postgres",
+      db_type: "postgres",
+      database: "app",
+      query_timeout_secs: 30,
+    });
+    mocks.buildTableSelectSql.mockResolvedValue("SELECT id, status FROM public.users WHERE status = 'ACTIVE' ORDER BY created_at DESC LIMIT 25 OFFSET 50");
+    mocks.executeMulti.mockResolvedValue([
+      {
+        columns: ["id", "status"],
+        rows: [],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    ]);
+  });
+
+  it("refreshes only matching data tabs after a table mutation", async () => {
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const store = useQueryStore();
+
+    const publicTabId = store.createTab("pg-1", "app", "users", "data", "public");
+    store.setTableMeta(publicTabId, {
+      schema: "public",
+      tableName: "users",
+      tableType: "TABLE",
+      columns: [
+        { name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+        { name: "status", data_type: "text", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
+      ],
+      primaryKeys: ["id"],
+    });
+    const publicTab = store.tabs.find((tab) => tab.id === publicTabId)!;
+    publicTab.whereInput = "status = 'ACTIVE'";
+    publicTab.orderByInput = "created_at DESC";
+    publicTab.resultPageLimit = 25;
+    publicTab.resultPageOffset = 50;
+
+    const archiveTabId = store.createTab("pg-1", "app", "users", "data", "archive");
+    store.setTableMeta(archiveTabId, {
+      schema: "archive",
+      tableName: "users",
+      tableType: "TABLE",
+      columns: [{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null }],
+      primaryKeys: ["id"],
+    });
+
+    const refreshed = await store.refreshDataTabsForTable({
+      connectionId: "pg-1",
+      database: "app",
+      schema: "public",
+      name: "users",
+    });
+
+    expect(refreshed).toBe(1);
+    expect(mocks.buildTableSelectSql).toHaveBeenCalledWith({
+      databaseType: "postgres",
+      schema: "public",
+      tableName: "users",
+      tableType: "TABLE",
+      catalog: undefined,
+      columns: ["id", "status"],
+      primaryKeys: ["id"],
+      includeRowId: false,
+      whereInput: "status = 'ACTIVE'",
+      orderBy: "created_at DESC",
+      limit: 25,
+      offset: 50,
+    });
+    expect(mocks.executeMulti).toHaveBeenCalledTimes(1);
+    expect(store.tabs.find((tab) => tab.id === publicTabId)?.result?.rows).toEqual([]);
+    expect(store.tabs.find((tab) => tab.id === archiveTabId)?.result).toBeUndefined();
+  });
+});
diff --git a/apps/desktop/src/stores/__tests__/settingsStore.spec.ts b/apps/desktop/src/stores/__tests__/settingsStore.spec.ts
new file mode 100644
index 0000000..30e761a
--- /dev/null
+++ b/apps/desktop/src/stores/__tests__/settingsStore.spec.ts
@@ -0,0 +1,109 @@
+import { describe, expect, it } from "vitest";
+import { normalizeDesktopSettings, normalizeEditorSettings } from "@/stores/settingsStore";
+
+describe("normalizeEditorSettings", () => {
+  it("enables automatic table aliases by default", () => {
+    expect(normalizeEditorSettings({}).autoAliasTables).toBe(true);
+  });
+
+  it("preserves disabled automatic table aliases", () => {
+    expect(normalizeEditorSettings({ autoAliasTables: false }).autoAliasTables).toBe(false);
+  });
+
+  it("shows the current statement frame by default", () => {
+    expect(normalizeEditorSettings({}).showCurrentStatementFrame).toBe(true);
+  });
+
+  it("preserves disabled current statement frames", () => {
+    expect(normalizeEditorSettings({ showCurrentStatementFrame: false }).showCurrentStatementFrame).toBe(false);
+  });
+
+  it("shows INSERT value column hints by default", () => {
+    expect(normalizeEditorSettings({}).showInsertValueHints).toBe(true);
+  });
+
+  it("preserves disabled INSERT value column hints", () => {
+    expect(normalizeEditorSettings({ showInsertValueHints: false }).showInsertValueHints).toBe(false);
+  });
+
+  it("keeps SQL semantic diagnostics in auto mode and disabled by default", () => {
+    const settings = normalizeEditorSettings({});
+    expect(settings.sqlSemanticDiagnosticsMode).toBe("auto");
+    expect(settings.sqlSemanticDiagnosticsEnabled).toBe(false);
+  });
+
+  it("preserves explicit SQL semantic diagnostics modes", () => {
+    expect(normalizeEditorSettings({ sqlSemanticDiagnosticsMode: "enabled" }).sqlSemanticDiagnosticsEnabled).toBe(true);
+    expect(normalizeEditorSettings({ sqlSemanticDiagnosticsMode: "disabled" }).sqlSemanticDiagnosticsEnabled).toBe(false);
+  });
+
+  it("migrates legacy SQL semantic diagnostics booleans to explicit modes", () => {
+    expect(normalizeEditorSettings({ sqlSemanticDiagnosticsEnabled: true } as any).sqlSemanticDiagnosticsMode).toBe("enabled");
+    expect(normalizeEditorSettings({ sqlSemanticDiagnosticsEnabled: false } as any).sqlSemanticDiagnosticsMode).toBe("disabled");
+  });
+
+  it("defaults update downloads to the official source", () => {
+    expect(normalizeEditorSettings({}).updateDownloadSource).toBe("official");
+  });
+
+  it("preserves explicit editor themes from saved settings", () => {
+    expect(normalizeEditorSettings({ theme: "xcode" }).theme).toBe("xcode");
+    expect(normalizeEditorSettings({ theme: "one-dark" }).theme).toBe("one-dark");
+    expect(normalizeEditorSettings({ theme: "custom" }).theme).toBe("custom");
+  });
+
+  it("restores all open tabs on launch by default", () => {
+    expect(normalizeEditorSettings({}).openTabsRestoreMode).toBe("all");
+  });
+
+  it("preserves explicit open tab restore modes", () => {
+    expect(normalizeEditorSettings({ openTabsRestoreMode: "pinned" }).openTabsRestoreMode).toBe("pinned");
+    expect(normalizeEditorSettings({ openTabsRestoreMode: "none" }).openTabsRestoreMode).toBe("none");
+    expect(normalizeEditorSettings({ openTabsRestoreMode: "invalid" as any }).openTabsRestoreMode).toBe("all");
+  });
+
+  it("migrates legacy open tab restore booleans", () => {
+    expect(normalizeEditorSettings({ restoreOpenTabsOnLaunch: false } as any).openTabsRestoreMode).toBe("none");
+    expect(normalizeEditorSettings({ restoreOpenTabsOnLaunch: true } as any).openTabsRestoreMode).toBe("all");
+  });
+
+  it("preserves mirror update download sources and rejects invalid values", () => {
+    expect(normalizeEditorSettings({ updateDownloadSource: "cnb" }).updateDownloadSource).toBe("cnb");
+    expect(normalizeEditorSettings({ updateDownloadSource: "atomgit" }).updateDownloadSource).toBe("atomgit");
+    expect(normalizeEditorSettings({ updateDownloadSource: "mirror" as any }).updateDownloadSource).toBe("official");
+  });
+
+  it("defaults data grid search to row filtering and preserves highlight mode", () => {
+    expect(normalizeEditorSettings({}).dataGridSearchMode).toBe("filter");
+    expect(normalizeEditorSettings({ dataGridSearchMode: "highlight" }).dataGridSearchMode).toBe("highlight");
+    expect(normalizeEditorSettings({ dataGridSearchMode: "invalid" as any }).dataGridSearchMode).toBe("filter");
+  });
+
+  it("normalizes toolbar item settings from older saved settings", () => {
+    const settings = normalizeEditorSettings({
+      toolbarItems: {
+        sqlFileTree: false,
+        history: false,
+      } as any,
+    });
+
+    expect(settings.toolbarItems.sqlFileTree).toBe(false);
+    expect(settings.toolbarItems.history).toBe(false);
+    expect(settings.toolbarItems.sqlLibrary).toBe(true);
+  });
+});
+
+describe("normalizeDesktopSettings", () => {
+  it("defaults DuckDB worker process isolation to disabled for old settings", () => {
+    expect(normalizeDesktopSettings({}).duckdb_worker_process_isolation).toBe(false);
+  });
+
+  it("defaults DuckDB worker max processes to 4 and clamps saved values", () => {
+    expect(normalizeDesktopSettings({}).duckdb_worker_max_processes).toBe(4);
+    expect(normalizeDesktopSettings({ duckdb_worker_max_processes: 1 }).duckdb_worker_max_processes).toBe(1);
+    expect(normalizeDesktopSettings({ duckdb_worker_max_processes: 16 }).duckdb_worker_max_processes).toBe(16);
+    expect(normalizeDesktopSettings({ duckdb_worker_max_processes: 0 }).duckdb_worker_max_processes).toBe(1);
+    expect(normalizeDesktopSettings({ duckdb_worker_max_processes: 32 }).duckdb_worker_max_processes).toBe(16);
+    expect(normalizeDesktopSettings({ duckdb_worker_max_processes: 3.6 }).duckdb_worker_max_processes).toBe(4);
+  });
+});
diff --git a/apps/desktop/src/stores/connectionStore.ts b/apps/desktop/src/stores/connectionStore.ts
new file mode 100644
index 0000000..1a12c05
--- /dev/null
+++ b/apps/desktop/src/stores/connectionStore.ts
@@ -0,0 +1,5226 @@
+import { defineStore } from "pinia";
+import { uuid } from "@/lib/common/utils";
+import { ref, computed, watch } from "vue";
+import type { ColumnInfo, CompletionAssistantCandidate, CompletionAssistantObjectKind, CompletionAssistantRequest, ConnectionConfig, CatalogInfo, ForeignKeyInfo, ObjectInfo, SchemaInfo, SidebarLayout, TableInfo, TreeNode, TunnelProfile, VectorCollectionMeta } from "@/types/database";
+import { applyPinnedTreeNodeState, updatePinnedTreeNodeInPlace } from "@/lib/app/pinnedItems";
+import {
+  reconcileLayout,
+  buildTreeNodesFromLayout,
+  emptyLayout,
+  appendConnectionToLayout,
+  removeConnectionFromSidebarLayout,
+  findConnectionLocation,
+  createGroup as createGroupOp,
+  renameGroup as renameGroupOp,
+  deleteGroup as deleteGroupOp,
+  toggleGroupCollapsed as toggleGroupCollapsedOp,
+  collapseAllGroups as collapseAllGroupsOp,
+  moveConnectionToGroup as moveConnectionToGroupOp,
+  remapSidebarLayoutConnectionIds,
+  reorderEntry as reorderEntryOp,
+  type DropPosition,
+} from "@/lib/sidebar/sidebarLayout";
+import type { SqlCompletionColumn, SqlCompletionForeignKey, SqlCompletionObject, SqlCompletionTable } from "@/lib/sql/sqlCompletion";
+import * as api from "@/lib/backend/api";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { useTunnelProfileStore } from "@/stores/tunnelProfileStore";
+import { connectionIsDorisFamilyCatalogCapable, isInternalDorisCatalog, isSchemaAware, normalizeSidebarObjectKind, sidebarObjectKindsForDatabase, usesTreeSchemaMode } from "@/lib/database/databaseCapabilities";
+import { connectionObjectTreeNodeSchema, connectionObjectTreeQuerySchema, connectionUsesDatabaseObjectTreeMode, effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
+import { buildDatabaseTreeNodes, buildDuckDbConnectionTreeNodes, sortSidebarDatabases, sortSidebarNames, shouldIncludeDefaultDatabaseNode } from "@/lib/database/databaseTree";
+import { buildSqlServerDatabaseTreeNodes } from "@/lib/database/sqlServerTree";
+import { collapseExpandedTreeNodes } from "@/lib/sidebar/sidebarTreeCollapse";
+import { findDatabaseTreeNode } from "@/lib/sidebar/treeRefreshTarget";
+import { shouldMarkDisconnected } from "@/lib/connection/connectionHealth";
+import { connectionAttemptOriginalErrorMessage, connectionAttemptTimeoutMessage, connectionAttemptTimeoutMs } from "@/lib/connection/connectionAttemptTimeout";
+import { requiresSqlServerLegacyCompatibilityComponent, SQLSERVER_LEGACY_COMPATIBILITY_DRIVER_KEY } from "@/lib/connection/sqlServerLegacyCompatibility";
+import { connectionUsesVisibleSchemaFilter, filterDatabaseNamesForConnection, filterSchemaNamesForConnection, filterVisibleDatabaseNames, normalizeVisibleDatabaseSelection } from "@/lib/database/visibleDatabases";
+import {
+  buildObjectGroupPlaceholderNodes,
+  buildGroupedObjectTreeNodes,
+  buildSimpleObjectTreeNodes,
+  buildTableTreeNodes,
+  appendTableTreeLoadMoreNode,
+  expandCachedObjectBrowserNodes,
+  filterSimpleSidebarSupplementalObjects,
+  mergeTableInfosIntoObjects,
+  mergeTableTreePageChildren,
+  objectGroupRefreshParentId,
+  objectTypesForGroupNode,
+  sortDatabaseObjectsByName,
+  tablePartitionGroups,
+  withoutTableTreeLoadMoreNodes,
+  type TableTreeLoadMoreParent,
+  type DatabaseObjectTreeKind,
+} from "@/lib/table/tableTree";
+import { hasTreeNodeDatabaseContext, normalizeCataloglessDatabaseNodes, treeNodeSchemaCachePrefix } from "@/lib/sidebar/treeNodeContext";
+import { decodeSchemaTreeCache, encodeSchemaTreeCache } from "@/lib/metadata/schemaTreeCache";
+import { sortSidebarTreeChildrenForParent } from "@/lib/sidebar/sidebarNodeOrdering";
+import { prunePinnedTreeNodeIdsForConnection } from "@/lib/app/pinnedTreeNodeIds";
+import { supportsDatabaseUserAdmin } from "@/lib/database/databaseUserAdmin";
+import { getTableMetadataCapabilities } from "@/lib/table/tableMetadataCapabilities";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { encodeSqlServerLinkedSchema, parseSqlServerLinkedSchema } from "@/lib/database/sqlServerLinkedServers";
+import { inferMongoCompletionFields, type MongoCompletionField } from "@/lib/mongo/mongoCompletion";
+import { completionSchemasFromTree, completionTablesFromTree } from "@/lib/metadata/completionTreeIndex";
+import { kvRootNodeLabel } from "@/lib/kv/kvRootPresentation";
+import { REDIS_SCAN_PAGE_SIZE_DEFAULT } from "@/lib/redis/redisKeyPattern";
+import { appendAgentDriverUpdateHint, hasAgentDriverUpdate, type AgentDriverInstallState } from "@/lib/connection/agentDriverInstallHint";
+import { appendConnectionErrorHints } from "@/lib/connection/connectionErrorHints";
+import { appendVisibleDatabaseSelection } from "@/lib/connection/connectionVisibleDatabases";
+import { createMetadataLoadTrace, logMetadataLoadTrace, MetadataLoadCoordinator, type MetadataLoadTraceLogger } from "@/lib/metadata/metadataLoadCoordinator";
+import type { MetadataScopeInput } from "@/lib/metadata/metadataLoadScope";
+import { MetadataResultCache, type MetadataCacheInvalidation } from "@/lib/metadata/metadataResultCache";
+import { invalidateTableMetadataCache } from "@/lib/metadata/tableMetadataCache";
+import { MetadataTaskLimiter } from "@/lib/metadata/metadataTaskLimiter";
+import i18n from "@/i18n";
+import type { MqAdminConfig } from "@/types/mq";
+
+const PINNED_TREE_NODES_STORAGE_KEY = "dbx-pinned-tree-nodes";
+const ACTIVE_CONNECTION_STORAGE_KEY = "dbx-active-connection";
+const CONNECTION_HEALTH_CHECK_TTL_MS = 2000;
+const CONNECTION_HEALTH_CHECK_TIMEOUT_MS = 5000;
+const METADATA_LOAD_MIN_TIMEOUT_MS = 15_000;
+const METADATA_LOAD_DISABLED_QUERY_TIMEOUT_MS = 60_000;
+const DISCONNECT_REQUEST_TIMEOUT_MS = 5_000;
+const DEFAULT_KEEPALIVE_INTERVAL_SECS = 30;
+const METADATA_LIST_PAGE_CACHE_TTL_MS = 30_000;
+const METADATA_LIST_PAGE_CACHE_MAX_ENTRIES = 160;
+export const COMPLETION_METADATA_CONCURRENCY = 2;
+const MONGO_LEGACY_DRIVER_PROFILE = "mongodb-legacy";
+const MONGO_LEGACY_DRIVER_LABEL = "MongoDB (Legacy)";
+const SUPERSEDED_CONNECTION_ATTEMPT_MESSAGE = "Connection attempt was superseded by a newer attempt";
+function sidebarObjectGroupPageSize(): number {
+  const settingsStore = useSettingsStore();
+  const size = settingsStore.desktopSettings.sidebar_table_page_size;
+  return typeof size === "number" && size > 0 ? size : 500;
+}
+
+function isKafkaMqConnection(config: ConnectionConfig | undefined): boolean {
+  if (!config || config.db_type !== "mq") return false;
+  if (config.driver_profile === "kafka") return true;
+  return (config.external_config as Partial<MqAdminConfig> | undefined)?.systemKind === "kafka";
+}
+
+type ImportSource = "dbx" | "navicat" | "dbeaver" | "datagrip";
+
+interface LocateTableTarget {
+  connectionId: string;
+  database: string;
+  schema?: string;
+  tableName: string;
+}
+
+function nodeIdPart(value: string): string {
+  return encodeURIComponent(value);
+}
+
+function sqlServerLinkedRootId(connectionId: string): string {
+  return `${connectionId}:__linked_servers`;
+}
+
+function sqlServerLinkedServerId(connectionId: string, server: string): string {
+  return `${sqlServerLinkedRootId(connectionId)}:${nodeIdPart(server)}`;
+}
+
+function sqlServerLinkedCatalogId(connectionId: string, server: string, catalog: string): string {
+  return `${sqlServerLinkedServerId(connectionId, server)}:${nodeIdPart(catalog)}`;
+}
+
+function dorisCatalogId(connectionId: string, catalog: string): string {
+  return `${connectionId}:doris-catalog:${nodeIdPart(catalog)}`;
+}
+
+function dorisCatalogDatabaseId(connectionId: string, catalog: string, database: string): string {
+  return `${dorisCatalogId(connectionId, catalog)}:${nodeIdPart(database)}`;
+}
+
+function sqlServerLinkedRuntimeDatabase(config?: ConnectionConfig): string {
+  return config?.database?.trim() || "master";
+}
+
+function sqlServerLinkedRootNode(connectionId: string, database: string): TreeNode {
+  return {
+    id: sqlServerLinkedRootId(connectionId),
+    label: "tree.linkedServers",
+    type: "linked-server-root",
+    connectionId,
+    database,
+    isExpanded: false,
+    children: [],
+  };
+}
+
+function ensureSqlServerLinkedRootNode(connectionId: string, children: TreeNode[], config?: ConnectionConfig): TreeNode[] {
+  if (config?.db_type !== "sqlserver") return children;
+  if (children.some((child) => child.type === "linked-server-root" || child.id === sqlServerLinkedRootId(connectionId))) {
+    return children;
+  }
+  return [...children, sqlServerLinkedRootNode(connectionId, sqlServerLinkedRuntimeDatabase(config))];
+}
+
+// Temporary storage for DataGrip import payload (used to read Keychain passwords after import)
+let pendingDataGripPayload: { format: "datagrip-import"; dataSources: string; dataSourcesLocal?: string } | null = null;
+
+interface TreeClipboardTableEntry {
+  connectionId: string;
+  database: string;
+  schema?: string;
+  tableName: string;
+}
+
+interface TreeClipboardConnectionEntry {
+  config: ConnectionConfig;
+  sourceGroupId: string | null;
+}
+
+export type TreeClipboard =
+  | {
+      kind: "table-copy";
+      tables: TreeClipboardTableEntry[];
+    }
+  | {
+      kind: "connection-copy";
+      connections: TreeClipboardConnectionEntry[];
+    };
+
+interface LoadTreeOptions {
+  force?: boolean;
+  expectedSidebarSearchQuery?: string;
+  searchFilter?: string;
+  sidebarTableSearchParentId?: string;
+  expectedSidebarTableSearchQuery?: string;
+}
+
+interface PersistedTreeChildrenLoadResult {
+  hit: boolean;
+  isStale: boolean;
+}
+
+type MetadataListPageResult = TableInfo[] | ObjectInfo[];
+
+type BeforeConnectHandler = (config: ConnectionConfig) => Promise<void>;
+
+export const CONNECTION_ATTEMPT_CANCELLED_MESSAGE = "Connection attempt was cancelled";
+
+function redisDbLabel(db: number, _loadedKeyCount?: number, totalKeyCount?: number): string {
+  if (totalKeyCount == null) return `db${db}`;
+  return `db${db} (${totalKeyCount})`;
+}
+
+function metadataDriverProfile(config?: ConnectionConfig): string | undefined {
+  return config?.driver_profile || config?.db_type;
+}
+
+export const useConnectionStore = defineStore("connection", () => {
+  const settingsStore = useSettingsStore();
+  const connections = ref<ConnectionConfig[]>([]);
+  const isDesktop = isTauriRuntime();
+  const activeConnectionId = ref<string | null>(localStorage.getItem(ACTIVE_CONNECTION_STORAGE_KEY));
+  const selectedTreeNodeId = ref<string | null>(null);
+  const selectedTreeNodeIds = ref<string[]>([]);
+  const treeSelectionAnchorId = ref<string | null>(null);
+  const connectionMultiSelectActive = ref(false);
+  const treeClipboard = ref<TreeClipboard | null>(null);
+
+  watch(activeConnectionId, (id) => {
+    if (id) localStorage.setItem(ACTIVE_CONNECTION_STORAGE_KEY, id);
+    else localStorage.removeItem(ACTIVE_CONNECTION_STORAGE_KEY);
+  });
+  const treeNodes = ref<TreeNode[]>([]);
+  const pinnedTreeNodeIds = ref<Set<string>>(new Set());
+  const connectedIds = ref<Set<string>>(new Set());
+  const lastConnectionHealthCheckAt = ref<Record<string, number>>({});
+  const agentDrivers = ref<AgentDriverInstallState[]>([]);
+  let agentDriversRefreshPromise: Promise<void> | null = null;
+  const loadedTreeNodeChildrenIds = ref<Set<string>>(new Set());
+  const connectionErrors = ref<Record<string, string>>({});
+  const connectingIds = ref<Set<string>>(new Set());
+  const editingConnectionId = ref<string | null>(null);
+  const newConnectionGroupId = ref<string | null>(null);
+  const completionTablesCache = ref<Record<string, SqlCompletionTable[]>>({});
+  const completionObjectsCache = ref<Record<string, SqlCompletionObject[]>>({});
+  const completionColumnsCache = ref<Record<string, ColumnInfo[]>>({});
+  const completionForeignKeysCache = ref<Record<string, ForeignKeyInfo[]>>({});
+  const completionDatabasesCache = ref<Record<string, string[]>>({});
+  const elasticsearchCompletionIndicesCache = ref<Record<string, string[]>>({});
+  const redisCompletionKeysCache = ref<Record<string, string[]>>({});
+  const mongoCompletionCollectionsCache = ref<Record<string, string[]>>({});
+  const mongoCompletionFieldsCache = ref<Record<string, MongoCompletionField[]>>({});
+  const schemaListCache = ref<Record<string, string[]>>({});
+  const sidebarSearchQuery = ref("");
+  const sidebarTableSearchQueries = ref<Record<string, string>>({});
+  const completionTableIndex = new Map<string, { touched: number; tables: SqlCompletionTable[] }>();
+  const completionObjectIndex = new Map<string, { touched: number; objects: SqlCompletionObject[] }>();
+  const completionColumnIndex = new Map<string, { touched: number; columns: SqlCompletionColumn[] }>();
+  const completionForeignKeyIndex = new Map<string, { touched: number; foreignKeys: SqlCompletionForeignKey[] }>();
+  const completionInFlight = new Map<string, Promise<unknown>>();
+  const completionMetadataLimiter = new MetadataTaskLimiter(COMPLETION_METADATA_CONCURRENCY, (event) => {
+    console.debug("[DBX][completion-metadata:limit]", event);
+  });
+  const transferSource = ref<{ connectionId: string; database: string } | null>(null);
+  const schemaDiffSource = ref<{ connectionId: string; database: string; schema?: string } | null>(null);
+  const dataCompareSource = ref<{
+    connectionId: string;
+    database: string;
+    schema?: string;
+    tableName?: string;
+  } | null>(null);
+  const sqlFileSource = ref<{ connectionId: string; database: string; filePath?: string } | null>(null);
+  const diagramSource = ref<{
+    connectionId: string;
+    database: string;
+    schema?: string;
+    tableName?: string;
+  } | null>(null);
+  const tableImportSource = ref<{
+    connectionId: string;
+    database: string;
+    schema?: string;
+    tableName?: string;
+  } | null>(null);
+  const tableDataGenerateSource = ref<{
+    connectionId: string;
+    database: string;
+    schema?: string;
+    tableName: string;
+  } | null>(null);
+  const fieldLineageSource = ref<{
+    connectionId: string;
+    database: string;
+    schema?: string;
+    tableName: string;
+    columnName: string;
+  } | null>(null);
+  const databaseSearchSource = ref<{
+    connectionId: string;
+    database: string;
+    schema?: string;
+  } | null>(null);
+  const databaseExportSource = ref<{
+    connectionId: string;
+    database: string;
+    schema?: string;
+    tableName?: string;
+    tableNames?: string[];
+    allDatabases?: boolean;
+  } | null>(null);
+  const sidebarLayout = ref<SidebarLayout>(emptyLayout());
+  let layoutPersistTimer: ReturnType<typeof setTimeout> | null = null;
+  const staleTreeRefreshIds = new Set<string>();
+  const metadataLoadCoordinator = new MetadataLoadCoordinator((event) => {
+    console.debug("[DBX][metadata-load:coordinator]", event);
+  });
+  const metadataListPageCache = new MetadataResultCache<MetadataListPageResult>({
+    ttlMs: METADATA_LIST_PAGE_CACHE_TTL_MS,
+    maxEntries: METADATA_LIST_PAGE_CACHE_MAX_ENTRIES,
+  });
+  const metadataTraceLogger: MetadataLoadTraceLogger = (event) => {
+    console.debug("[DBX][metadata-load:trace]", event);
+  };
+  const connectInFlight = new Map<string, Promise<void>>();
+  const disconnectInFlight = new Map<string, Promise<void>>();
+  const disconnectInFlightScoped = new Map<string, boolean>();
+  const cancelDisconnectInFlight = new Map<string, Promise<void>>();
+  const activeLocalConnectionAttempts = new Map<string, number>();
+  const cancelledLocalConnectionAttempts = new Map<string, Set<number>>();
+  const successfulLocalConnectionAttempts = new Map<string, number>();
+  const connectionStateRevisions = new Map<string, number>();
+  let nextLocalConnectionAttempt = 0;
+  let beforeConnectHandler: BeforeConnectHandler | null = null;
+  let initFromDiskPromise: Promise<void> | null = null;
+
+  function runTreeMetadataLoad<T>(scope: MetadataScopeInput, task: () => Promise<T>, options?: LoadTreeOptions): Promise<T> {
+    return metadataLoadCoordinator.run(scope, task, { force: options?.force, kind: scope.kind });
+  }
+
+  async function loadCachedMetadataListPage<T extends MetadataListPageResult>(scope: MetadataScopeInput, load: () => Promise<T>, options?: { force?: boolean }): Promise<T> {
+    const trace = createMetadataLoadTrace(scope);
+    if (!options?.force) {
+      const cached = metadataListPageCache.get(scope);
+      if (cached) {
+        logMetadataLoadTrace(metadataTraceLogger, trace, "cache-hit", {
+          cacheStatus: cached.stale ? "stale" : "hit",
+          resultCount: cached.value.length,
+          stale: cached.stale,
+        });
+        return cached.value as T;
+      }
+    }
+
+    logMetadataLoadTrace(metadataTraceLogger, trace, "cache-miss", { cacheStatus: options?.force ? "refresh" : "miss", force: options?.force === true });
+    const result = await load();
+    metadataListPageCache.set(scope, result);
+    logMetadataLoadTrace(metadataTraceLogger, trace, "done", {
+      cacheStatus: options?.force ? "refresh" : "miss",
+      resultCount: result.length,
+      force: options?.force === true,
+    });
+    return result;
+  }
+
+  function startEditing(id: string) {
+    editingConnectionId.value = id;
+  }
+
+  function stopEditing() {
+    editingConnectionId.value = null;
+  }
+
+  function startCreatingConnectionInGroup(groupId: string) {
+    stopEditing();
+    newConnectionGroupId.value = groupId;
+  }
+
+  function stopCreatingConnectionInGroup() {
+    newConnectionGroupId.value = null;
+  }
+
+  const configById = computed(() => new Map(connections.value.map((c) => [c.id, c])));
+
+  function getConfig(connectionId: string) {
+    return configById.value.get(connectionId);
+  }
+
+  function connectionErrorMessage(error: unknown): string {
+    if (error instanceof Error) return error.message;
+    return String(error);
+  }
+
+  function isSupersededConnectionAttempt(error: unknown): boolean {
+    return connectionErrorMessage(error).includes(SUPERSEDED_CONNECTION_ATTEMPT_MESSAGE);
+  }
+
+  function isCancelledConnectionAttempt(error: unknown): boolean {
+    return connectionErrorMessage(error).includes(CONNECTION_ATTEMPT_CANCELLED_MESSAGE);
+  }
+
+  function beginLocalConnectionAttempt(connectionId: string): number {
+    const attempt = ++nextLocalConnectionAttempt;
+    bumpConnectionStateRevision(connectionId);
+    activeLocalConnectionAttempts.set(connectionId, attempt);
+    connectingIds.value.add(connectionId);
+    const node = findNode(treeNodes.value, connectionId);
+    if (node) node.isLoading = true;
+    return attempt;
+  }
+
+  function markSuccessfulLocalConnectionAttempt(connectionId: string, attempt: number) {
+    successfulLocalConnectionAttempts.set(connectionId, attempt);
+  }
+
+  function forgetSuccessfulLocalConnectionAttempt(connectionId: string) {
+    successfulLocalConnectionAttempts.delete(connectionId);
+  }
+
+  function bumpConnectionStateRevision(connectionId: string): number {
+    const revision = (connectionStateRevisions.get(connectionId) ?? 0) + 1;
+    connectionStateRevisions.set(connectionId, revision);
+    return revision;
+  }
+
+  function isCurrentConnectionStateRevision(connectionId: string, revision: number): boolean {
+    return connectionStateRevisions.get(connectionId) === revision;
+  }
+
+  function isCurrentLocalConnectionAttempt(connectionId: string, attempt: number): boolean {
+    return activeLocalConnectionAttempts.get(connectionId) === attempt;
+  }
+
+  function isCancelledLocalConnectionAttempt(connectionId: string, attempt: number): boolean {
+    return cancelledLocalConnectionAttempts.get(connectionId)?.has(attempt) === true;
+  }
+
+  function getLocalConnectionAttempt(connectionId: string): number | undefined {
+    return activeLocalConnectionAttempts.get(connectionId);
+  }
+
+  function finishLocalConnectionAttempt(connectionId: string, attempt: number) {
+    if (isCancelledLocalConnectionAttempt(connectionId, attempt)) {
+      const attempts = cancelledLocalConnectionAttempts.get(connectionId);
+      attempts?.delete(attempt);
+      if (attempts?.size === 0) {
+        cancelledLocalConnectionAttempts.delete(connectionId);
+      }
+    }
+    if (!isCurrentLocalConnectionAttempt(connectionId, attempt)) return;
+    activeLocalConnectionAttempts.delete(connectionId);
+    connectingIds.value.delete(connectionId);
+    clearConnectionNodeLoading(connectionId);
+  }
+
+  function cancelLocalConnectionAttempt(connectionId: string): boolean {
+    const attempt = activeLocalConnectionAttempts.get(connectionId);
+    if (attempt == null) return false;
+    const attempts = cancelledLocalConnectionAttempts.get(connectionId) ?? new Set<number>();
+    attempts.add(attempt);
+    cancelledLocalConnectionAttempts.set(connectionId, attempts);
+    activeLocalConnectionAttempts.delete(connectionId);
+    connectingIds.value.delete(connectionId);
+    clearConnectionNodeLoading(connectionId);
+    clearConnectionRootMetadataLoad(connectionId);
+    connectInFlight.delete(connectionId);
+    return true;
+  }
+
+  function clearConnectionRootMetadataLoad(connectionId: string) {
+    metadataLoadCoordinator.clear({
+      kind: "connection-databases",
+      connectionId,
+      driverProfile: metadataDriverProfile(getConfig(connectionId)),
+    });
+  }
+
+  function getBlockingDisconnectInFlight(connectionId: string): Promise<void> | undefined {
+    return disconnectInFlightScoped.get(connectionId) ? undefined : disconnectInFlight.get(connectionId);
+  }
+
+  async function waitForBlockingDisconnectInFlight(connectionId: string): Promise<void> {
+    const pending = getBlockingDisconnectInFlight(connectionId);
+    if (pending) await pending;
+  }
+
+  function trackDisconnectRequest(connectionId: string, request: Promise<void>, scoped: boolean): Promise<void> {
+    const bounded = withDisconnectRequestTimeout(connectionId, request);
+    const tracked = bounded
+      .catch((error) => {
+        console.warn("[DBX][connection:disconnect-error]", { connectionId, error });
+      })
+      .finally(() => {
+        if (disconnectInFlight.get(connectionId) === tracked) {
+          disconnectInFlight.delete(connectionId);
+          disconnectInFlightScoped.delete(connectionId);
+        }
+      });
+    disconnectInFlight.set(connectionId, tracked);
+    disconnectInFlightScoped.set(connectionId, scoped);
+    return bounded;
+  }
+
+  function startDisconnectRequest(connectionId: string): Promise<void> {
+    const clientAttempt = activeLocalConnectionAttempts.get(connectionId) ?? successfulLocalConnectionAttempts.get(connectionId);
+    let request: Promise<void>;
+    try {
+      request = api.disconnectDb(connectionId, clientAttempt);
+    } catch (error) {
+      request = Promise.reject(error);
+    }
+    return trackDisconnectRequest(connectionId, request, clientAttempt != null);
+  }
+
+  function cancelDisconnectKey(connectionId: string, attempt: number): string {
+    return `${connectionId}:${attempt}`;
+  }
+
+  function startCancelDisconnectRequest(connectionId: string, attempt: number): Promise<void> {
+    const key = cancelDisconnectKey(connectionId, attempt);
+    const existing = cancelDisconnectInFlight.get(key);
+    if (existing) return existing;
+    let request: Promise<void>;
+    try {
+      request = api.disconnectDb(connectionId, attempt);
+    } catch (error) {
+      request = Promise.reject(error);
+    }
+    const tracked = withDisconnectRequestTimeout(connectionId, request)
+      .catch((error) => {
+        console.warn("[DBX][connection:cancel-disconnect-error]", { connectionId, attempt, error });
+        throw error;
+      })
+      .finally(() => {
+        if (cancelDisconnectInFlight.get(key) === tracked) {
+          cancelDisconnectInFlight.delete(key);
+        }
+      });
+    cancelDisconnectInFlight.set(key, tracked);
+    return tracked;
+  }
+
+  async function cleanupResolvedCancelledConnectionAttempt(connectionId: string, attempt: number) {
+    try {
+      // A cancel request can reach the backend before connect_db registers the
+      // attempt, so clean again if that cancelled connect later returns a pool.
+      await withDisconnectRequestTimeout(connectionId, api.disconnectDb(connectionId, attempt));
+    } catch (error) {
+      console.warn("[DBX][connection:cancel-result-cleanup-error]", { connectionId, attempt, error });
+    }
+  }
+
+  async function ensureLocalConnectionAttemptActiveAfterConnectResult(connectionId: string, attempt: number, cleanupConnectionId: string) {
+    if (isCancelledLocalConnectionAttempt(connectionId, attempt)) {
+      await cleanupResolvedCancelledConnectionAttempt(cleanupConnectionId, attempt);
+      throw new Error(CONNECTION_ATTEMPT_CANCELLED_MESSAGE);
+    }
+    ensureLocalConnectionAttemptActive(connectionId, attempt);
+  }
+
+  function ensureLocalConnectionAttemptActive(connectionId: string, attempt: number) {
+    if (isCancelledLocalConnectionAttempt(connectionId, attempt)) {
+      throw new Error(CONNECTION_ATTEMPT_CANCELLED_MESSAGE);
+    }
+    if (!isCurrentLocalConnectionAttempt(connectionId, attempt)) {
+      throw new Error(SUPERSEDED_CONNECTION_ATTEMPT_MESSAGE);
+    }
+  }
+
+  function setConnectionError(connectionId: string, message: string) {
+    connectionErrors.value[connectionId] = message;
+  }
+
+  function agentDriverUpdateHint(): string {
+    return i18n.global.t("connection.agentDriverUpdateConnectionHint");
+  }
+
+  function connectionErrorWithDriverUpdateHint(config: ConnectionConfig | undefined, message: string): string {
+    if (!config) return message;
+    message = appendConnectionErrorHints(config, message, i18n.global.t);
+    if (!hasAgentDriverUpdate(config.db_type, agentDrivers.value, config.driver_profile)) return message;
+    return appendAgentDriverUpdateHint(message, agentDriverUpdateHint());
+  }
+
+  function refreshAgentDriversForErrorHint(): Promise<void> {
+    if (agentDriversRefreshPromise) return agentDriversRefreshPromise;
+    agentDriversRefreshPromise = api
+      .listInstalledAgents()
+      .then((drivers) => {
+        agentDrivers.value = drivers;
+      })
+      .catch(() => undefined)
+      .finally(() => {
+        agentDriversRefreshPromise = null;
+      });
+    return agentDriversRefreshPromise;
+  }
+
+  function maybeAppendAgentDriverUpdateHint(connectionId: string, baseMessage: string) {
+    const config = getConfig(connectionId);
+    const message = connectionErrorWithDriverUpdateHint(config, baseMessage);
+    if (message !== baseMessage) {
+      setConnectionError(connectionId, message);
+      return;
+    }
+    void refreshAgentDriversForErrorHint().then(() => {
+      if (connectionErrors.value[connectionId] !== baseMessage) return;
+      const refreshedMessage = connectionErrorWithDriverUpdateHint(config, baseMessage);
+      if (refreshedMessage !== baseMessage) setConnectionError(connectionId, refreshedMessage);
+    });
+  }
+
+  function clearConnectionError(connectionId: string) {
+    if (!connectionErrors.value[connectionId]) return;
+    delete connectionErrors.value[connectionId];
+  }
+
+  function markConnectionHealthChecked(connectionId: string) {
+    lastConnectionHealthCheckAt.value[connectionId] = Date.now();
+  }
+
+  function clearConnectionHealthCheck(connectionId: string) {
+    if (!lastConnectionHealthCheckAt.value[connectionId]) return;
+    delete lastConnectionHealthCheckAt.value[connectionId];
+  }
+
+  function hasRecentConnectionHealthCheck(connectionId: string) {
+    const checkedAt = lastConnectionHealthCheckAt.value[connectionId];
+    return typeof checkedAt === "number" && Date.now() - checkedAt < CONNECTION_HEALTH_CHECK_TTL_MS;
+  }
+
+  function clearConnectionNodeLoading(connectionId: string) {
+    const node = findNode(treeNodes.value, connectionId);
+    if (node) node.isLoading = false;
+  }
+
+  function metadataLoadTimeoutMs(config?: ConnectionConfig): number {
+    const queryTimeoutSecs = Number(config?.query_timeout_secs);
+    if (queryTimeoutSecs === 0) return METADATA_LOAD_DISABLED_QUERY_TIMEOUT_MS;
+    const boundedTimeoutSecs = Number.isFinite(queryTimeoutSecs) && queryTimeoutSecs > 0 ? queryTimeoutSecs + 5 : 35;
+    return Math.max(METADATA_LOAD_MIN_TIMEOUT_MS, boundedTimeoutSecs * 1000);
+  }
+
+  async function withConnectionHealthTimeout(connectionId: string, promise: Promise<void>): Promise<void> {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      return await Promise.race([
+        promise,
+        new Promise<never>((_, reject) => {
+          timer = setTimeout(() => {
+            reject(new Error(`Connection health check timed out after ${Math.ceil(CONNECTION_HEALTH_CHECK_TIMEOUT_MS / 1000)}s.`));
+          }, CONNECTION_HEALTH_CHECK_TIMEOUT_MS);
+        }),
+      ]);
+    } catch (error) {
+      clearConnectionNodeLoading(connectionId);
+      throw error;
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+
+  async function withMetadataLoadTimeout<T>(connectionId: string, promise: Promise<T>, label: string): Promise<T> {
+    const timeoutMs = metadataLoadTimeoutMs(getConfig(connectionId));
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      return await Promise.race([
+        promise,
+        new Promise<never>((_, reject) => {
+          timer = setTimeout(() => {
+            reject(new Error(`Connection timed out while loading ${label} after ${Math.ceil(timeoutMs / 1000)}s. Please check the network or VPN and try again.`));
+          }, timeoutMs);
+        }),
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+
+  async function withDisconnectRequestTimeout(connectionId: string, promise: Promise<void>): Promise<void> {
+    let timedOut = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    void promise.catch((error) => {
+      if (timedOut) console.warn("[DBX][connection:disconnect-late-error]", { connectionId, error });
+    });
+    try {
+      await Promise.race([
+        promise,
+        new Promise<void>((resolve) => {
+          timer = setTimeout(() => {
+            timedOut = true;
+            console.warn("[DBX][connection:disconnect-timeout]", { connectionId, timeoutMs: DISCONNECT_REQUEST_TIMEOUT_MS });
+            resolve();
+          }, DISCONNECT_REQUEST_TIMEOUT_MS);
+        }),
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+
+  function recordConnectionError(connectionId: string, error: unknown): string {
+    const message = connectionErrorMessage(error);
+    if (isCancelledConnectionAttempt(message)) {
+      clearConnectionError(connectionId);
+      return "";
+    }
+    setConnectionError(connectionId, message);
+    maybeAppendAgentDriverUpdateHint(connectionId, message);
+    return message;
+  }
+
+  function markConnectionLost(connectionId: string, error: unknown) {
+    connectedIds.value.delete(connectionId);
+    clearConnectionNodeLoading(connectionId);
+    clearConnectionHealthCheck(connectionId);
+    if (activeConnectionId.value === connectionId) activeConnectionId.value = null;
+    recordConnectionError(connectionId, error);
+  }
+
+  function recordConnectionLostError(connectionId: string, error: unknown): boolean {
+    if (shouldMarkDisconnected(error)) {
+      markConnectionLost(connectionId, error);
+      return true;
+    }
+    return false;
+  }
+
+  // Metadata loaders keep this internal: match connection-loss errors before recording generic errors.
+  function recordMetadataLoadError(connectionId: string, error: unknown) {
+    if (recordConnectionLostError(connectionId, error)) return;
+    recordConnectionError(connectionId, error);
+  }
+
+  async function withConnectionAttemptTimeout<T>(promise: Promise<T>, config: ConnectionConfig): Promise<T> {
+    const timeoutMs = connectionAttemptTimeoutMs(config);
+    const timeoutMessage = connectionAttemptTimeoutMessage(timeoutMs);
+    let timedOut = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    void promise.then(
+      (connectionId) => {
+        if (!timedOut) return;
+        const cleanupConnectionId = typeof connectionId === "string" && connectionId ? connectionId : config.id;
+        if (connectedIds.value.has(cleanupConnectionId)) return;
+        void api.disconnectDb(cleanupConnectionId).catch((error) => {
+          console.warn("[DBX][connection:timeout-cleanup-failed]", { connectionId: cleanupConnectionId, error });
+        });
+      },
+      (error) => {
+        if (!timedOut) return;
+        const current = connectionErrors.value[config.id];
+        if (current !== timeoutMessage) return;
+        setConnectionError(config.id, connectionAttemptOriginalErrorMessage(timeoutMessage, connectionErrorMessage(error)));
+      },
+    );
+    try {
+      return await Promise.race([
+        promise,
+        new Promise<never>((_, reject) => {
+          timer = setTimeout(() => {
+            timedOut = true;
+            reject(new Error(timeoutMessage));
+          }, timeoutMs);
+        }),
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+
+  function normalizeConnection(config: ConnectionConfig): ConnectionConfig {
+    const labelMap: Record<string, string> = {
+      mysql: "MySQL",
+      postgres: "PostgreSQL",
+      sqlite: "SQLite",
+      redis: "Redis",
+      etcd: "etcd",
+      zookeeper: "Apache ZooKeeper",
+      duckdb: "DuckDB",
+      clickhouse: "ClickHouse",
+      sqlserver: "SQL Server",
+      mongodb: "MongoDB",
+      oracle: "Oracle",
+      "mongodb-legacy": MONGO_LEGACY_DRIVER_LABEL,
+      elasticsearch: "Elasticsearch",
+      qdrant: "Qdrant",
+      milvus: "Milvus",
+      weaviate: "Weaviate",
+      chromadb: "ChromaDB",
+      doris: "Doris",
+      starrocks: "StarRocks",
+      manticoresearch: "Manticore Search",
+      redshift: "Redshift",
+      dameng: "DM (Dameng)",
+      gaussdb: "GaussDB",
+      questdb: "QuestDB",
+      kwdb: "KWDB",
+      kingbase: "KingBase",
+      highgo: "瀚高 HighGo",
+      yashandb: "崖山 YashanDB",
+      vastbase: "Vastbase",
+      goldendb: "GoldenDB",
+      access: "Microsoft Access",
+      h2: "H2",
+      snowflake: "Snowflake",
+      trino: "Trino",
+      prestosql: "PrestoSQL",
+      hive: "Hive",
+      spark: "Apache Spark",
+      db2: "DB2",
+      informix: "Informix",
+      neo4j: "Neo4j",
+      cassandra: "Cassandra",
+      bigquery: "BigQuery",
+      kylin: "Kylin",
+      sundb: "SunDB",
+      oscar: "神通 OSCAR",
+      influxdb: "InfluxDB",
+    };
+
+    const profile = config.driver_profile || config.db_type;
+    let dbType = config.db_type;
+    if ((profile === "gaussdb" || profile === "opengauss") && dbType === "postgres") {
+      dbType = "gaussdb" as ConnectionConfig["db_type"];
+    } else if (profile === "kwdb" && dbType === "postgres") {
+      dbType = "kwdb" as ConnectionConfig["db_type"];
+    } else if (profile === "questdb" && dbType === "postgres") {
+      dbType = "questdb" as ConnectionConfig["db_type"];
+    } else if (profile === "redshift" && dbType === "postgres") {
+      dbType = "redshift" as ConnectionConfig["db_type"];
+    } else if (profile === "kingbase" && dbType === "postgres") {
+      dbType = "kingbase" as ConnectionConfig["db_type"];
+    } else if (profile === "highgo" && dbType === "postgres") {
+      dbType = "highgo" as ConnectionConfig["db_type"];
+    } else if (profile === "vastbase" && dbType === "postgres") {
+      dbType = "vastbase" as ConnectionConfig["db_type"];
+    } else if (profile === "goldendb" && dbType === "mysql") {
+      dbType = "goldendb" as ConnectionConfig["db_type"];
+    }
+
+    return {
+      ...config,
+      db_type: dbType,
+      driver_profile: profile,
+      driver_label: config.driver_label || labelMap[profile] || config.db_type,
+      url_params: config.url_params || "",
+      agent_java_options: Array.isArray(config.agent_java_options) ? config.agent_java_options : [],
+      attached_databases: Array.isArray(config.attached_databases) ? config.attached_databases.filter((database) => database.name?.trim() && database.path?.trim()) : [],
+      transport_layers: Array.isArray(config.transport_layers) ? config.transport_layers : [],
+      connect_timeout_secs: config.connect_timeout_secs || 10,
+      query_timeout_secs: config.query_timeout_secs ?? 30,
+      idle_timeout_secs: config.idle_timeout_secs ?? 60,
+      keepalive_interval_secs: config.keepalive_interval_secs ?? DEFAULT_KEEPALIVE_INTERVAL_SECS,
+    };
+  }
+
+  function loadPinnedTreeNodeIdsFromLocalStorage(): Set<string> {
+    try {
+      if (typeof localStorage === "undefined") return new Set();
+      const saved = localStorage.getItem(PINNED_TREE_NODES_STORAGE_KEY);
+      const ids = saved ? JSON.parse(saved) : [];
+      return new Set(Array.isArray(ids) ? ids.filter((id) => typeof id === "string") : []);
+    } catch {
+      return new Set();
+    }
+  }
+
+  async function loadPinnedTreeNodeIds(): Promise<Set<string>> {
+    if (!isDesktop) return loadPinnedTreeNodeIdsFromLocalStorage();
+    const ids = await api.loadPinnedTreeNodeIds().catch(() => []);
+    const valid = ids.filter((id) => typeof id === "string");
+    if (valid.length > 0) return new Set(valid);
+
+    // Migrate legacy localStorage values for existing desktop users.
+    const legacy = loadPinnedTreeNodeIdsFromLocalStorage();
+    if (legacy.size > 0) {
+      await api.savePinnedTreeNodeIds([...legacy]).catch(() => undefined);
+      if (typeof localStorage !== "undefined") {
+        localStorage.removeItem(PINNED_TREE_NODES_STORAGE_KEY);
+      }
+    }
+    return legacy;
+  }
+
+  function persistPinnedTreeNodeIds() {
+    if (isDesktop) {
+      void api.savePinnedTreeNodeIds([...pinnedTreeNodeIds.value]).catch(() => undefined);
+      return;
+    }
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(PINNED_TREE_NODES_STORAGE_KEY, JSON.stringify([...pinnedTreeNodeIds.value]));
+  }
+
+  function isTreeNodePinned(id: string): boolean {
+    return pinnedTreeNodeIds.value.has(id);
+  }
+
+  function isConnectionUtilityNode(node: TreeNode): boolean {
+    return node.type === "user-admin" || node.type === "dameng-job-admin";
+  }
+
+  function connectionMetadataChildren(children: TreeNode[] | undefined): TreeNode[] {
+    return (children || []).filter((child) => !isConnectionUtilityNode(child));
+  }
+
+  function hasConnectionMetadataChildren(children: TreeNode[] | undefined): boolean {
+    return connectionMetadataChildren(children).length > 0;
+  }
+
+  function preserveExistingConnectionMetadataChildren(parent: TreeNode, children: TreeNode[]): TreeNode[] {
+    if (parent.type !== "connection" || hasConnectionMetadataChildren(children)) return children;
+
+    const existingMetadataChildren = connectionMetadataChildren(parent.children);
+    const nextUtilityChildren = children.filter(isConnectionUtilityNode);
+    if (existingMetadataChildren.length === 0 || nextUtilityChildren.length === 0) return children;
+
+    return [...existingMetadataChildren, ...nextUtilityChildren];
+  }
+
+  function setChildren(parent: TreeNode, children: TreeNode[]) {
+    children = preserveExistingConnectionMetadataChildren(parent, children);
+    if (parent.children && parent.children.length > 0) {
+      const oldMap = new Map(parent.children.map((c) => [c.id, c] as const));
+      children = children.map((child) => {
+        const old = oldMap.get(child.id);
+        if (old && old.isExpanded && old.children && old.children.length > 0) {
+          return { ...child, isExpanded: true, children: old.children };
+        }
+        return child;
+      });
+    }
+    parent.children = applyPinnedTreeNodeState(children, pinnedTreeNodeIds.value);
+    loadedTreeNodeChildrenIds.value.add(parent.id);
+  }
+
+  function removeTreeNode(nodeId: string) {
+    const parent = findParentNode(treeNodes.value, nodeId);
+    if (parent?.children) {
+      parent.children = parent.children.filter((c) => c.id !== nodeId);
+    }
+    if (selectedTreeNodeId.value === nodeId) selectedTreeNodeId.value = null;
+    selectedTreeNodeIds.value = selectedTreeNodeIds.value.filter((id) => id !== nodeId);
+    if (treeSelectionAnchorId.value === nodeId) treeSelectionAnchorId.value = null;
+  }
+
+  function buildUserAdminNode(connectionId: string, existingConnectionNode?: TreeNode): TreeNode | undefined {
+    const config = getConfig(connectionId);
+    if (!supportsDatabaseUserAdmin(effectiveDatabaseTypeForConnection(config))) return undefined;
+    const existing = existingConnectionNode?.children?.find((child) => child.type === "user-admin");
+    return {
+      id: `${connectionId}:__user_admin`,
+      label: "tree.userAdmin",
+      type: "user-admin",
+      connectionId,
+      database: "",
+      isExpanded: existing?.isExpanded ?? false,
+    };
+  }
+
+  function buildDamengJobAdminNode(connectionId: string, existingConnectionNode?: TreeNode): TreeNode | undefined {
+    const config = getConfig(connectionId);
+    if (effectiveDatabaseTypeForConnection(config) !== "dameng") return undefined;
+    const existing = existingConnectionNode?.children?.find((child) => child.type === "dameng-job-admin");
+    return {
+      id: `${connectionId}:__dameng_jobs`,
+      label: "tree.damengJobAdmin",
+      type: "dameng-job-admin",
+      connectionId,
+      database: "",
+      isExpanded: existing?.isExpanded ?? false,
+    };
+  }
+
+  function withConnectionUtilityNodes(connectionId: string, children: TreeNode[], existingConnectionNode?: TreeNode): TreeNode[] {
+    const nonUtilityChildren = connectionMetadataChildren(children);
+    const userAdminNode = buildUserAdminNode(connectionId, existingConnectionNode);
+    const damengJobAdminNode = buildDamengJobAdminNode(connectionId, existingConnectionNode);
+    return [...nonUtilityChildren, userAdminNode, damengJobAdminNode].filter(Boolean) as TreeNode[];
+  }
+
+  function withSavedSqlRoot(connectionId: string, children: TreeNode[], existingConnectionNode?: TreeNode): TreeNode[] {
+    return withConnectionUtilityNodes(connectionId, children, existingConnectionNode);
+  }
+
+  function schemaCacheKey(...parts: string[]): string {
+    return parts.map((part) => encodeURIComponent(part)).join(":");
+  }
+
+  function supportedSidebarObjectTypes(config?: ConnectionConfig): DatabaseObjectTreeKind[] {
+    const dbType = effectiveDatabaseTypeForConnection(config);
+    return sidebarObjectKindsForDatabase(dbType);
+  }
+
+  function sortSidebarSchemaInfos(schemas: readonly SchemaInfo[]): SchemaInfo[] {
+    const byName = new Map<string, SchemaInfo>();
+    for (const schema of schemas) {
+      const name = schema.name.trim();
+      if (!name) continue;
+      byName.set(name, { name, comment: schema.comment ?? null });
+    }
+    return sortSidebarNames([...byName.keys()]).map((name) => byName.get(name)!);
+  }
+
+  function objectGroupCacheKey(node: TreeNode): string {
+    return schemaCacheKey(node.connectionId || "", node.database || "", node.schema || "", node.type, "objects-v3");
+  }
+
+  function metadataListDriverProfile(connectionId?: string): string | undefined {
+    return connectionId ? metadataDriverProfile(getConfig(connectionId)) : undefined;
+  }
+
+  function metadataListCacheScope(options: {
+    kind: string;
+    connectionId?: string | null;
+    database?: string | null;
+    schema?: string | null;
+    nodeKind?: string | null;
+    objectTypes?: readonly string[] | null;
+    searchFilter?: string | null;
+    limit?: number | null;
+    offset?: number | null;
+    sidebarDisplayMode?: string | null;
+    extra?: MetadataScopeInput["extra"];
+  }): MetadataScopeInput {
+    return {
+      kind: options.kind,
+      connectionId: options.connectionId,
+      database: options.database,
+      schema: options.schema,
+      nodeKind: options.nodeKind,
+      objectTypes: options.objectTypes,
+      searchFilter: options.searchFilter,
+      limit: options.limit,
+      offset: options.offset,
+      sidebarDisplayMode: options.sidebarDisplayMode,
+      driverProfile: metadataListDriverProfile(options.connectionId || undefined),
+      extra: options.extra,
+    };
+  }
+
+  function invalidateMetadataCaches(match: MetadataCacheInvalidation): number {
+    return metadataListPageCache.invalidate(match) + invalidateTableMetadataCache(match);
+  }
+
+  function invalidateMetadataCachesByTreePrefix(prefix: string) {
+    const [connectionId, database, schema, tableName] = prefix.split(":").map((part) => {
+      try {
+        return decodeURIComponent(part);
+      } catch {
+        return part;
+      }
+    });
+    if (!connectionId) return;
+    invalidateMetadataCaches({
+      connectionId,
+      database: database || undefined,
+      schema: schema || undefined,
+      tableName: tableName && !tableName.startsWith("__") ? tableName : undefined,
+    });
+  }
+
+  function invalidateMetadataCachesForNode(node: TreeNode) {
+    if (!node.connectionId) return;
+    const tableName = node.tableName || (node.type === "table" || node.type === "view" || node.type === "materialized_view" || node.type === "mongo-collection" ? node.label : undefined);
+    invalidateMetadataCaches({
+      connectionId: node.connectionId,
+      database: node.database || undefined,
+      schema: node.schema || undefined,
+      tableName,
+    });
+  }
+
+  function invalidateMetadataCache(connectionId: string, database?: string, schema?: string, tableName?: string) {
+    invalidateMetadataCaches({ connectionId, database, schema, tableName });
+  }
+
+  function buildLoadMoreNode(parent: TreeNode, offset: number, pageSize: number): TreeNode {
+    return {
+      id: `${parent.id}:__load_more:${offset}`,
+      label: "tree.loadMore",
+      type: "load-more",
+      connectionId: parent.connectionId,
+      database: parent.database,
+      schema: parent.schema,
+      isLoading: false,
+      loadMore: {
+        parentId: parent.id,
+        offset,
+        pageSize,
+      },
+    };
+  }
+
+  function withoutLoadMoreNodes(children: TreeNode[] | undefined): TreeNode[] {
+    return (children || []).filter((child) => child.type !== "load-more");
+  }
+
+  function objectGroupChildrenFromObjects(options: { node: TreeNode; parentNodeId: string; effectiveSchema?: string; objectTypes: DatabaseObjectTreeKind[]; objects: ObjectInfo[] }): TreeNode[] {
+    const grouped = buildGroupedObjectTreeNodes({
+      nodeId: options.parentNodeId,
+      connectionId: options.node.connectionId || "",
+      database: options.node.database || "",
+      schema: options.effectiveSchema,
+      objects: options.objects.filter((object) => options.objectTypes.includes(normalizedObjectTreeKind(object.object_type))),
+    });
+    const refreshedGroup = grouped.find((group) => group.type === options.node.type);
+    return refreshedGroup?.children ?? [];
+  }
+
+  function tableInfosToCompletionTables(tables: readonly TableInfo[], schema?: string): SqlCompletionTable[] {
+    return tables.map((table) => ({
+      name: table.name,
+      schema,
+      type: isViewLikeTableType(table.table_type) ? "view" : "table",
+    }));
+  }
+
+  function isViewLikeTableType(tableType: string): boolean {
+    const normalized = tableType.toUpperCase().replace(/[\s-]+/g, "_");
+    return normalized === "VIEW" || normalized === "MATERIALIZED_VIEW";
+  }
+
+  function sameSidebarObjectName(left: string | undefined, right: string | undefined): boolean {
+    return (left || "").toLowerCase() === (right || "").toLowerCase();
+  }
+
+  function treeNodeObjectIdentity(node: TreeNode): string {
+    return `${node.type}\0${(node.schema || "").toLowerCase()}\0${node.label.toLowerCase()}`;
+  }
+
+  function mergeLocatedTreeChildren(parent: TreeNode, currentChildren: TreeNode[], pageChildren: TreeNode[], connectionId: string, database: string): TreeNode[] {
+    const tableChildren = pageChildren.filter((child) => child.type === "table");
+    const nonTableChildren = pageChildren.filter((child) => child.type !== "table");
+    let merged = tableChildren.length ? mergeTableTreePageChildren(currentChildren, tableChildren, connectionId, database) : [...currentChildren];
+    const existing = new Set(merged.map(treeNodeObjectIdentity));
+    for (const child of nonTableChildren) {
+      const key = treeNodeObjectIdentity(child);
+      if (existing.has(key)) continue;
+      merged.push(child);
+      existing.add(key);
+    }
+    const config = parent.connectionId ? getConfig(parent.connectionId) : undefined;
+    return sortSidebarTreeChildrenForParent(
+      parent,
+      sortDatabaseObjectsByName(merged, (node) => node.label),
+      config?.db_type,
+    );
+  }
+
+  function findTreeNodes(nodes: TreeNode[], predicate: (node: TreeNode) => boolean): TreeNode[] {
+    const matches: TreeNode[] = [];
+    for (const node of nodes) {
+      if (predicate(node)) matches.push(node);
+      if (node.children) matches.push(...findTreeNodes(node.children, predicate));
+      const hiddenOnlyChildren = node.hiddenChildren?.filter((child) => !(node.children || []).includes(child));
+      if (hiddenOnlyChildren?.length) matches.push(...findTreeNodes(hiddenOnlyChildren, predicate));
+    }
+    return matches;
+  }
+
+  async function loadPagedTableGroupChildren(options: {
+    node: TreeNode;
+    parentNodeId: string;
+    querySchema: string;
+    effectiveSchema?: string;
+    objectTypes: DatabaseObjectTreeKind[];
+    offset: number;
+    pageSize: number;
+    searchFilter?: string;
+    force?: boolean;
+  }): Promise<{ children: TreeNode[]; objectCount: number; hasMore: boolean; nextOffset: number; loadMoreParent?: TableTreeLoadMoreParent }> {
+    if (!options.node.connectionId || !options.node.database) {
+      return { children: [], objectCount: 0, hasMore: false, nextOffset: options.offset };
+    }
+    const searchFilter = (options.searchFilter ?? sidebarSearchQuery.value) || undefined;
+    const fetchLimit = searchFilter ? options.pageSize : options.pageSize + 1;
+    const fetchOffset = searchFilter ? undefined : options.offset;
+    const tables = await loadCachedMetadataListPage<TableInfo[]>(
+      metadataListCacheScope({
+        kind: "table-list-page",
+        connectionId: options.node.connectionId,
+        database: options.node.database,
+        schema: options.querySchema,
+        nodeKind: options.node.type,
+        objectTypes: options.objectTypes,
+        searchFilter,
+        limit: fetchLimit,
+        offset: fetchOffset,
+        sidebarDisplayMode: "grouped",
+      }),
+      () => api.listTables(options.node.connectionId!, options.node.database!, options.querySchema, searchFilter, fetchLimit, fetchOffset, options.objectTypes),
+      { force: options.force },
+    );
+    const hasMore = searchFilter ? false : tables.length > options.pageSize;
+    const pageTables = hasMore ? tables.slice(0, options.pageSize) : tables;
+    indexCompletionTables(options.node.connectionId, options.node.database, options.effectiveSchema, tableInfosToCompletionTables(pageTables, options.effectiveSchema));
+    const objects = mergeTableInfosIntoObjects([], pageTables, options.effectiveSchema);
+    const children = objectGroupChildrenFromObjects({
+      node: options.node,
+      parentNodeId: options.parentNodeId,
+      effectiveSchema: options.effectiveSchema,
+      objectTypes: options.objectTypes,
+      objects,
+    });
+    const lastTable = pageTables[pageTables.length - 1];
+    return {
+      children,
+      objectCount: children.length,
+      hasMore,
+      nextOffset: options.offset + pageTables.length,
+      loadMoreParent: lastTable?.parent_name ? { schema: lastTable.parent_schema, name: lastTable.parent_name } : undefined,
+    };
+  }
+
+  async function loadPagedObjectGroupChildren(options: {
+    node: TreeNode;
+    parentNodeId: string;
+    querySchema: string;
+    effectiveSchema?: string;
+    objectTypes: DatabaseObjectTreeKind[];
+    offset: number;
+    pageSize: number;
+    searchFilter?: string;
+    force?: boolean;
+  }): Promise<{ children: TreeNode[]; objectCount: number; hasMore: boolean; nextOffset: number }> {
+    if (!options.node.connectionId || !options.node.database) {
+      return { children: [], objectCount: 0, hasMore: false, nextOffset: options.offset };
+    }
+    const searchFilter = options.searchFilter || undefined;
+    const fetchLimit = searchFilter ? undefined : options.pageSize + 1;
+    const fetchOffset = searchFilter ? undefined : options.offset;
+    const objects = await loadCachedMetadataListPage<ObjectInfo[]>(
+      metadataListCacheScope({
+        kind: "object-list-page",
+        connectionId: options.node.connectionId,
+        database: options.node.database,
+        schema: options.querySchema,
+        nodeKind: options.node.type,
+        objectTypes: options.objectTypes,
+        searchFilter,
+        limit: fetchLimit,
+        offset: fetchOffset,
+        sidebarDisplayMode: useSettingsStore().editorSettings.sidebarObjectDisplay,
+      }),
+      () => api.listObjects(options.node.connectionId!, options.node.database!, options.querySchema, options.objectTypes, searchFilter, fetchLimit, fetchOffset),
+      { force: options.force },
+    );
+    const hasMore = searchFilter ? false : objects.length > options.pageSize;
+    const pageObjects = hasMore ? objects.slice(0, options.pageSize) : objects;
+    const children = objectGroupChildrenFromObjects({
+      node: options.node,
+      parentNodeId: options.parentNodeId,
+      effectiveSchema: options.effectiveSchema,
+      objectTypes: options.objectTypes,
+      objects: pageObjects,
+    });
+    return {
+      children,
+      objectCount: children.length,
+      hasMore,
+      nextOffset: options.offset + pageObjects.length,
+    };
+  }
+
+  async function loadPagedSimpleTableChildren(options: {
+    nodeId: string;
+    connectionId: string;
+    database: string;
+    querySchema: string;
+    effectiveSchema?: string;
+    nonTableObjectTypes: DatabaseObjectTreeKind[];
+    offset: number;
+    pageSize: number;
+    searchFilter?: string;
+    force?: boolean;
+  }): Promise<{ children: TreeNode[]; objectCount: number; hasMore: boolean; nextOffset: number; loadMoreParent?: TableTreeLoadMoreParent }> {
+    const searchFilter = (options.searchFilter ?? sidebarSearchQuery.value) || undefined;
+    const fetchLimit = searchFilter ? options.pageSize : options.pageSize + 1;
+    const fetchOffset = searchFilter ? undefined : options.offset;
+    const tables = await loadCachedMetadataListPage<TableInfo[]>(
+      metadataListCacheScope({
+        kind: "table-list-page",
+        connectionId: options.connectionId,
+        database: options.database,
+        schema: options.querySchema,
+        nodeKind: "simple-tables",
+        searchFilter,
+        limit: fetchLimit,
+        offset: fetchOffset,
+        sidebarDisplayMode: "simple",
+      }),
+      () => api.listTables(options.connectionId, options.database, options.querySchema, searchFilter, fetchLimit, fetchOffset),
+      { force: options.force },
+    );
+    const hasMore = searchFilter ? false : tables.length > options.pageSize;
+    const pageTables = hasMore ? tables.slice(0, options.pageSize) : tables;
+    indexCompletionTables(options.connectionId, options.database, options.effectiveSchema, tableInfosToCompletionTables(pageTables, options.effectiveSchema));
+
+    const children = buildTableTreeNodes({
+      nodeId: options.nodeId,
+      connectionId: options.connectionId,
+      database: options.database,
+      schema: options.effectiveSchema,
+      tables: pageTables,
+    });
+    const lastTable = pageTables[pageTables.length - 1];
+    return {
+      children,
+      objectCount: children.length,
+      hasMore,
+      nextOffset: options.offset + pageTables.length,
+      loadMoreParent: lastTable?.parent_name ? { schema: lastTable.parent_schema, name: lastTable.parent_name } : undefined,
+    };
+  }
+
+  async function loadSimpleSupplementalObjectChildren(options: { node: TreeNode; nodeId: string; connectionId: string; database: string; querySchema: string; effectiveSchema?: string; objectTypes: DatabaseObjectTreeKind[]; cacheKey: string; loadOptions?: LoadTreeOptions }) {
+    if (options.objectTypes.length === 0) return;
+    const searchFilter = activeTreeLoadSearchFilter(options.loadOptions);
+    if (searchFilter) return;
+
+    try {
+      const objects = await loadCachedMetadataListPage<ObjectInfo[]>(
+        metadataListCacheScope({
+          kind: "object-list-page",
+          connectionId: options.connectionId,
+          database: options.database,
+          schema: options.querySchema,
+          nodeKind: "simple-supplemental",
+          objectTypes: options.objectTypes,
+          sidebarDisplayMode: "simple",
+        }),
+        () => api.listObjects(options.connectionId, options.database, options.querySchema, options.objectTypes),
+        { force: options.loadOptions?.force },
+      );
+      const supplementalObjects = filterSimpleSidebarSupplementalObjects(objects);
+      if (supplementalObjects.length === 0) return;
+      const supplementalChildren = buildSimpleObjectTreeNodes({
+        nodeId: options.nodeId,
+        connectionId: options.connectionId,
+        database: options.database,
+        schema: options.effectiveSchema,
+        objects: supplementalObjects,
+      });
+      if (supplementalChildren.length === 0) return;
+      if (isTreeLoadSearchChanged(searchFilter, options.loadOptions)) return;
+      if (!canApplyTreeMetadataResult(options.node)) return;
+
+      const loadMoreNodes = (options.node.children || []).filter((child) => child.type === "load-more");
+      const currentChildren = withoutLoadMoreNodes(options.node.children);
+      const mergedChildren = mergeLocatedTreeChildren(options.node, currentChildren, supplementalChildren, options.connectionId, options.database);
+      const nextChildren = [...mergedChildren, ...loadMoreNodes];
+      setChildren(options.node, nextChildren);
+      await savePersistedTreeChildren(options.cacheKey, nextChildren);
+    } catch (error) {
+      // Some drivers only expose table metadata; keep the already-rendered table tree usable.
+      console.debug("[DBX][metadata:simple-supplemental:error]", {
+        connectionId: options.connectionId,
+        database: options.database,
+        schema: options.effectiveSchema,
+        error,
+      });
+    }
+  }
+
+  function refreshStaleTreeNode(node: TreeNode) {
+    const searchFilter = sidebarSearchQuery.value || "";
+    if (searchFilter) return;
+    if (staleTreeRefreshIds.has(node.id)) return;
+    staleTreeRefreshIds.add(node.id);
+    const expandedIds = collectExpandedNodeIds([node]);
+    clearLoadedChildrenCache(node.id);
+    const refreshOptions = { force: true, expectedSidebarSearchQuery: searchFilter };
+    void loadTreeNodeChildren(node, refreshOptions)
+      .then(() => {
+        if ((sidebarSearchQuery.value || "") !== searchFilter) return;
+        return restoreExpandedChildren(node, expandedIds, refreshOptions);
+      })
+      .finally(() => staleTreeRefreshIds.delete(node.id));
+  }
+
+  async function loadPersistedTreeChildren(node: TreeNode, cacheKey: string): Promise<PersistedTreeChildrenLoadResult> {
+    const trace = createMetadataLoadTrace({
+      kind: "persisted-tree-cache",
+      connectionId: node.connectionId,
+      database: node.database,
+      schema: node.schema,
+      nodeKind: node.type,
+      extra: { cacheKey },
+    });
+    const payload = await api.loadSchemaCache<unknown>(cacheKey).catch(() => null);
+    const decoded = decodeSchemaTreeCache<TreeNode[]>(payload);
+    if (!decoded) {
+      logMetadataLoadTrace(metadataTraceLogger, trace, "cache-miss", { cacheStatus: "miss" });
+      return { hit: false, isStale: false };
+    }
+    const config = node.connectionId ? getConfig(node.connectionId) : undefined;
+    const cachedChildren = normalizeCataloglessDatabaseNodes(expandCachedObjectBrowserNodes(decoded.children));
+    const childrenWithLinkedServers = node.type === "connection" && node.connectionId ? ensureSqlServerLinkedRootNode(node.connectionId, cachedChildren, config) : cachedChildren;
+    if (node.type === "connection" && !hasConnectionMetadataChildren(childrenWithLinkedServers)) {
+      logMetadataLoadTrace(metadataTraceLogger, trace, "cache-miss", { cacheStatus: "miss", resultCount: 0 });
+      return { hit: false, isStale: false };
+    }
+    const normalizedChildren = sortSidebarTreeChildrenForParent(node, childrenWithLinkedServers, config?.db_type);
+    setChildren(node, node.type === "connection" && node.connectionId ? withSavedSqlRoot(node.connectionId, normalizedChildren, node) : normalizedChildren);
+    node.isExpanded = true;
+    logMetadataLoadTrace(metadataTraceLogger, trace, "cache-hit", {
+      cacheStatus: decoded.isStale ? "stale" : "hit",
+      resultCount: normalizedChildren.length,
+      stale: decoded.isStale,
+    });
+    return { hit: true, isStale: decoded.isStale };
+  }
+
+  async function savePersistedTreeChildren(cacheKey: string, children: TreeNode[]) {
+    await api.saveSchemaCache(cacheKey, encodeSchemaTreeCache(children)).catch(() => undefined);
+  }
+
+  async function savePersistedConnectionTreeChildren(cacheKey: string, children: TreeNode[]) {
+    const metadataChildren = connectionMetadataChildren(children);
+    if (metadataChildren.length === 0) return;
+    await savePersistedTreeChildren(cacheKey, metadataChildren);
+  }
+
+  function useCachedChildren(node: TreeNode, options?: LoadTreeOptions): boolean {
+    if (options?.force || !loadedTreeNodeChildrenIds.value.has(node.id)) return false;
+    if (node.type === "connection" && node.connectionId) {
+      if (!hasConnectionMetadataChildren(node.children)) {
+        clearLoadedChildrenCache(node.id);
+        return false;
+      }
+      const normalizedChildren = sortSidebarTreeChildrenForParent(node, withSavedSqlRoot(node.connectionId, node.children || [], node), getConfig(node.connectionId)?.db_type);
+      setChildren(node, normalizedChildren);
+    }
+    node.isExpanded = true;
+    return true;
+  }
+
+  function isSidebarSearchQueryChanged(options?: LoadTreeOptions) {
+    return options?.expectedSidebarSearchQuery !== undefined && (sidebarSearchQuery.value || "") !== options.expectedSidebarSearchQuery;
+  }
+
+  function isSidebarTableSearchQueryChanged(options?: LoadTreeOptions) {
+    if (!options?.sidebarTableSearchParentId || options.expectedSidebarTableSearchQuery === undefined) return false;
+    return (sidebarTableSearchQueries.value[options.sidebarTableSearchParentId]?.trim() || "") !== options.expectedSidebarTableSearchQuery;
+  }
+
+  function activeTreeLoadSearchFilter(options?: LoadTreeOptions): string {
+    return (options?.searchFilter ?? sidebarSearchQuery.value) || "";
+  }
+
+  function isTreeLoadSearchChanged(searchFilter: string, options?: LoadTreeOptions): boolean {
+    if (options?.sidebarTableSearchParentId) return isSidebarTableSearchQueryChanged(options);
+    return (sidebarSearchQuery.value || "") !== searchFilter || isSidebarSearchQueryChanged(options);
+  }
+
+  function isTreeNodeChildrenLoaded(nodeId: string): boolean {
+    return loadedTreeNodeChildrenIds.value.has(nodeId);
+  }
+
+  function canApplyTreeMetadataResult(node: TreeNode): boolean {
+    if (findNode(treeNodes.value, node.id) !== node) return false;
+    if (node.connectionId && !connectedIds.value.has(node.connectionId)) return false;
+    return true;
+  }
+
+  function clearLoadedChildrenCache(prefix: string) {
+    for (const id of loadedTreeNodeChildrenIds.value) {
+      if (id === prefix || id.startsWith(`${prefix}:`)) {
+        loadedTreeNodeChildrenIds.value.delete(id);
+      }
+    }
+    invalidateMetadataCachesByTreePrefix(prefix);
+    const rawPrefix = `${prefix}:`;
+    const encodedPrefix = `${schemaCacheKey(prefix)}:`;
+    if (rawPrefix === encodedPrefix) {
+      api.deleteSchemaCachePrefix(rawPrefix).catch(() => undefined);
+    } else {
+      Promise.all([api.deleteSchemaCachePrefix(rawPrefix), api.deleteSchemaCachePrefix(encodedPrefix)]).catch(() => undefined);
+    }
+  }
+
+  function schemaCachePrefixForNode(node: TreeNode): string | null {
+    return treeNodeSchemaCachePrefix(node);
+  }
+
+  async function clearPersistedTreeCacheForNode(node: TreeNode) {
+    const prefix = schemaCachePrefixForNode(node);
+    if (!prefix) return;
+    await api.deleteSchemaCachePrefix(prefix).catch(() => undefined);
+  }
+
+  function findParentNode(nodes: TreeNode[], id: string, parent: TreeNode | null = null): TreeNode | null {
+    for (const node of nodes) {
+      if (node.id === id) return parent;
+      if (node.children) {
+        const found = findParentNode(node.children, id, node);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+
+  function toggleTreeNodePin(id: string) {
+    const next = new Set(pinnedTreeNodeIds.value);
+    if (next.has(id)) next.delete(id);
+    else next.add(id);
+    pinnedTreeNodeIds.value = next;
+    persistPinnedTreeNodeIds();
+
+    const scope = updatePinnedTreeNodeInPlace(treeNodes.value, id, next.has(id));
+    if (scope === "root") rebuildTreeNodes();
+  }
+
+  async function addConnection(config: ConnectionConfig, targetGroupId?: string | null) {
+    const normalized = normalizeConnection(config);
+    const existing = connections.value.findIndex((c) => c.id === normalized.id);
+    const nextConnections = [...connections.value];
+    if (existing >= 0) {
+      nextConnections[existing] = normalized;
+    } else {
+      nextConnections.push(normalized);
+      const groupId = targetGroupId !== undefined ? targetGroupId : newConnectionGroupId.value;
+      sidebarLayout.value = appendConnectionToLayout(sidebarLayout.value, normalized.id, groupId);
+    }
+    await persistConnections(nextConnections);
+    connections.value = nextConnections;
+    rebuildTreeNodes();
+    persistSidebarLayoutDebounced();
+    stopCreatingConnectionInGroup();
+  }
+
+  function copyConnectionsToTreeClipboard(connectionIds: Iterable<string>): number {
+    const seen = new Set<string>();
+    const entries: TreeClipboardConnectionEntry[] = [];
+    for (const connectionId of connectionIds) {
+      if (seen.has(connectionId)) continue;
+      seen.add(connectionId);
+      const config = getConfig(connectionId);
+      if (!config) continue;
+      entries.push({
+        config: { ...config },
+        sourceGroupId: findConnectionLocation(sidebarLayout.value, connectionId)?.groupId ?? null,
+      });
+    }
+    if (!entries.length) return 0;
+    treeClipboard.value = { kind: "connection-copy", connections: entries };
+    return entries.length;
+  }
+
+  async function pasteConnectionClipboard(targetGroupId?: string | null): Promise<number> {
+    const clipboard = treeClipboard.value;
+    if (clipboard?.kind !== "connection-copy" || clipboard.connections.length === 0) return 0;
+
+    let pastedCount = 0;
+    for (const entry of clipboard.connections) {
+      await addConnection(
+        {
+          ...entry.config,
+          id: uuid(),
+          name: `${entry.config.name} (Copy)`,
+        },
+        targetGroupId === undefined ? entry.sourceGroupId : targetGroupId,
+      );
+      pastedCount += 1;
+    }
+    return pastedCount;
+  }
+
+  function invalidateCompletionCache(connectionId: string, database?: string) {
+    invalidateMetadataCaches({ connectionId, database });
+    const cachePrefix = database == null ? `${connectionId}:` : `${connectionId}:${database}:`;
+    const exactCacheKey = database == null ? null : `${connectionId}:${database}`;
+    for (const key of Object.keys(completionTablesCache.value)) {
+      if (key === exactCacheKey || key.startsWith(cachePrefix)) delete completionTablesCache.value[key];
+    }
+    for (const key of Object.keys(completionObjectsCache.value)) {
+      if (key === exactCacheKey || key.startsWith(cachePrefix)) delete completionObjectsCache.value[key];
+    }
+    for (const key of Object.keys(completionColumnsCache.value)) {
+      if (key === exactCacheKey || key.startsWith(cachePrefix)) delete completionColumnsCache.value[key];
+    }
+    for (const key of Object.keys(completionForeignKeysCache.value)) {
+      if (key === exactCacheKey || key.startsWith(cachePrefix)) delete completionForeignKeysCache.value[key];
+    }
+    for (const key of Object.keys(schemaListCache.value)) {
+      if (key === exactCacheKey || key.startsWith(cachePrefix)) delete schemaListCache.value[key];
+    }
+    for (const key of Object.keys(elasticsearchCompletionIndicesCache.value)) {
+      if (key === exactCacheKey || key.startsWith(cachePrefix)) delete elasticsearchCompletionIndicesCache.value[key];
+    }
+    for (const key of Object.keys(redisCompletionKeysCache.value)) {
+      if (key === exactCacheKey || key.startsWith(cachePrefix)) delete redisCompletionKeysCache.value[key];
+    }
+    for (const key of Object.keys(mongoCompletionCollectionsCache.value)) {
+      if (key === exactCacheKey || key.startsWith(cachePrefix)) delete mongoCompletionCollectionsCache.value[key];
+    }
+    for (const key of Object.keys(mongoCompletionFieldsCache.value)) {
+      if (key === exactCacheKey || key.startsWith(cachePrefix)) delete mongoCompletionFieldsCache.value[key];
+    }
+    for (const key of completionTableIndex.keys()) {
+      if (key.startsWith(cachePrefix)) completionTableIndex.delete(key);
+    }
+    for (const key of completionObjectIndex.keys()) {
+      if (key.startsWith(cachePrefix)) completionObjectIndex.delete(key);
+    }
+    for (const key of completionColumnIndex.keys()) {
+      if (key.startsWith(cachePrefix)) completionColumnIndex.delete(key);
+    }
+    for (const key of completionForeignKeyIndex.keys()) {
+      if (key.startsWith(cachePrefix)) completionForeignKeyIndex.delete(key);
+    }
+    for (const key of completionInFlight.keys()) {
+      if (key.startsWith(cachePrefix)) completionInFlight.delete(key);
+    }
+  }
+
+  async function removeConnections(ids: Iterable<string>) {
+    const connectionIds = [...new Set(ids)].filter((id) => connections.value.some((c) => c.id === id));
+    if (!connectionIds.length) return;
+
+    const removedIds = new Set(connectionIds);
+    const nextConnections = connections.value.filter((c) => !removedIds.has(c.id));
+    await persistConnections(nextConnections);
+    connections.value = nextConnections;
+    for (const id of removedIds) {
+      pinnedTreeNodeIds.value = prunePinnedTreeNodeIdsForConnection(pinnedTreeNodeIds.value, id);
+    }
+    persistPinnedTreeNodeIds();
+    for (const id of removedIds) {
+      clearConnectionError(id);
+      connectedIds.value.delete(id);
+      clearConnectionHealthCheck(id);
+      sidebarLayout.value = removeConnectionFromSidebarLayout(sidebarLayout.value, id);
+    }
+    rebuildTreeNodes();
+    persistSidebarLayoutDebounced();
+    if (activeConnectionId.value && removedIds.has(activeConnectionId.value)) {
+      activeConnectionId.value = null;
+    }
+    selectedTreeNodeIds.value = selectedTreeNodeIds.value.filter((id) => !removedIds.has(id));
+    if (selectedTreeNodeId.value && removedIds.has(selectedTreeNodeId.value)) selectedTreeNodeId.value = null;
+    if (treeSelectionAnchorId.value && removedIds.has(treeSelectionAnchorId.value)) treeSelectionAnchorId.value = null;
+    for (const id of removedIds) {
+      invalidateCompletionCache(id);
+      clearLoadedChildrenCache(id);
+    }
+  }
+
+  async function removeConnection(id: string) {
+    await removeConnections([id]);
+  }
+
+  async function updateConnection(config: ConnectionConfig) {
+    config = normalizeConnection(config);
+    const idx = connections.value.findIndex((c) => c.id === config.id);
+    if (idx < 0) return;
+    const nextConnections = [...connections.value];
+    nextConnections[idx] = config;
+    await persistConnections(nextConnections);
+    connections.value = nextConnections;
+    rebuildTreeNodes();
+    connectedIds.value.delete(config.id);
+    clearConnectionHealthCheck(config.id);
+    invalidateCompletionCache(config.id);
+    clearLoadedChildrenCache(config.id);
+    const node = findNode(treeNodes.value, config.id);
+    if (node?.isExpanded) {
+      await reloadConnectionDatabaseChildren(config.id);
+    }
+  }
+
+  async function syncMongoLegacyDriverFallback(connectionId: string, previousConfig: ConnectionConfig) {
+    if (!isDesktop || previousConfig.db_type !== "mongodb" || previousConfig.driver_profile === MONGO_LEGACY_DRIVER_PROFILE) {
+      return;
+    }
+
+    const savedConnections = await api.loadConnections().catch(() => null);
+    const savedConfig = savedConnections?.map((connection) => normalizeConnection(connection)).find((connection) => connection.id === connectionId && connection.driver_profile === MONGO_LEGACY_DRIVER_PROFILE);
+    if (!savedConfig) return;
+
+    const idx = connections.value.findIndex((connection) => connection.id === connectionId);
+    if (idx < 0) return;
+    const nextConnections = [...connections.value];
+    nextConnections[idx] = {
+      ...savedConfig,
+      driver_label: savedConfig.driver_label || MONGO_LEGACY_DRIVER_LABEL,
+    };
+    connections.value = nextConnections;
+    rebuildTreeNodes();
+  }
+
+  async function ensureSqlServerLegacyCompatibilityComponentInstalled(config: ConnectionConfig) {
+    if (!requiresSqlServerLegacyCompatibilityComponent(config)) return;
+    if (await api.isAgentInstalled(SQLSERVER_LEGACY_COMPATIBILITY_DRIVER_KEY)) return;
+    await api.installAgent(SQLSERVER_LEGACY_COMPATIBILITY_DRIVER_KEY);
+  }
+
+  async function setDefaultDatabase(connectionId: string, database: string) {
+    const config = getConfig(connectionId);
+    if (config?.db_type === "cloudflare-d1") return;
+    if (!config || config.database === database) return;
+    await updateConnection({
+      ...config,
+      database,
+    });
+  }
+
+  async function clearDefaultDatabase(connectionId: string) {
+    const config = getConfig(connectionId);
+    if (config?.db_type === "cloudflare-d1") return;
+    if (!config || !config.database) return;
+    await updateConnection({
+      ...config,
+      database: undefined,
+    });
+  }
+
+  function isDefaultDatabase(connectionId: string, database: string): boolean {
+    const config = getConfig(connectionId);
+    if (config?.db_type === "cloudflare-d1") return database === "main";
+    return config?.database === database && database !== "";
+  }
+
+  async function setVisibleDatabases(connectionId: string, databaseNames: string[]) {
+    const config = getConfig(connectionId);
+    if (!config) return;
+    await updateVisibleDatabasesConfig(connectionId, normalizeVisibleDatabaseSelection(databaseNames, databaseNames));
+    await reloadConnectionDatabaseChildren(connectionId);
+  }
+
+  async function clearVisibleDatabases(connectionId: string) {
+    const config = getConfig(connectionId);
+    if (!config || !Array.isArray(config.visible_databases)) return;
+    await updateVisibleDatabasesConfig(connectionId, undefined);
+    await reloadConnectionDatabaseChildren(connectionId);
+  }
+
+  async function ensureVisibleDatabase(connectionId: string, databaseName: string) {
+    const config = getConfig(connectionId);
+    if (!config) return;
+    const visibleDatabases = appendVisibleDatabaseSelection(config.visible_databases, databaseName);
+    if (visibleDatabases === config.visible_databases) return;
+    await updateVisibleDatabasesConfig(connectionId, visibleDatabases);
+  }
+
+  async function updateVisibleDatabasesConfig(connectionId: string, visibleDatabases: string[] | undefined) {
+    const idx = connections.value.findIndex((connection) => connection.id === connectionId);
+    if (idx < 0) return;
+    const nextConnections = [...connections.value];
+    nextConnections[idx] = {
+      ...nextConnections[idx],
+      visible_databases: visibleDatabases,
+    };
+    await persistConnections(nextConnections);
+    connections.value = nextConnections;
+    invalidateCompletionCache(connectionId);
+    rebuildTreeNodes();
+  }
+
+  async function setVisibleSchemas(connectionId: string, database: string, schemaNames: string[]) {
+    const config = getConfig(connectionId);
+    if (!config) return;
+    const key = database || "";
+    await updateVisibleSchemasConfig(connectionId, key, schemaNames);
+    await reloadSchemaChildren(connectionId, database);
+  }
+
+  async function clearVisibleSchemas(connectionId: string, database: string) {
+    const config = getConfig(connectionId);
+    if (!config || !config.visible_schemas) return;
+    const key = database || "";
+    await updateVisibleSchemasConfig(connectionId, key, undefined);
+    await reloadSchemaChildren(connectionId, database);
+  }
+
+  async function updateVisibleSchemasConfig(connectionId: string, database: string, schemaNames: string[] | undefined) {
+    const idx = connections.value.findIndex((connection) => connection.id === connectionId);
+    if (idx < 0) return;
+    const existing = connections.value[idx].visible_schemas;
+    let nextSchemas: Record<string, string[]> | undefined;
+    if (schemaNames) {
+      nextSchemas = { ...(existing || {}), [database]: schemaNames };
+    } else if (existing) {
+      nextSchemas = { ...existing };
+      delete nextSchemas[database];
+      if (Object.keys(nextSchemas).length === 0) nextSchemas = undefined;
+    }
+    const nextConnections = [...connections.value];
+    nextConnections[idx] = {
+      ...nextConnections[idx],
+      visible_schemas: nextSchemas,
+    };
+    await persistConnections(nextConnections);
+    connections.value = nextConnections;
+    rebuildTreeNodes();
+  }
+
+  async function reloadSchemaChildren(connectionId: string, database?: string) {
+    const config = getConfig(connectionId);
+    if (!config) return;
+    const db = database || config.database || "";
+    clearLoadedChildrenCache(connectionId);
+    clearLoadedChildrenCache(`${connectionId}:${db}`);
+    await loadDatabases(connectionId, { force: true });
+    // After saving schema filter, force-refresh database node's schema children
+    // to avoid stale children from previously expanded nodes
+    if (db) {
+      const dbNode = findNode(treeNodes.value, `${connectionId}:${db}`);
+      if (dbNode) {
+        await loadTreeNodeChildren(dbNode, { force: true });
+      }
+    }
+  }
+
+  async function reloadConnectionDatabaseChildren(connectionId: string) {
+    const config = getConfig(connectionId);
+    if (!config) return;
+    clearLoadedChildrenCache(connectionId);
+    if (config.db_type === "redis") {
+      await loadRedisDatabases(connectionId);
+    } else if (config.db_type === "etcd") {
+      await loadEtcdRoot(connectionId);
+    } else if (config.db_type === "zookeeper") {
+      await loadZooKeeperRoot(connectionId);
+    } else if (config.db_type === "mongodb") {
+      await loadMongoDatabases(connectionId);
+    } else if (config.db_type === "elasticsearch") {
+      await loadElasticsearchIndices(connectionId);
+    } else if (config.db_type === "milvus") {
+      await loadMilvusDatabases(connectionId);
+    } else if (config.db_type === "qdrant" || config.db_type === "weaviate" || config.db_type === "chromadb") {
+      await loadVectorCollections(connectionId);
+    } else if (config.db_type === "mq") {
+      await loadMqTenants(connectionId, { force: true });
+    } else if (config.db_type === "nacos") {
+      await loadNacosNamespaces(connectionId, { force: true });
+    } else {
+      await loadDatabases(connectionId, { force: true });
+    }
+  }
+
+  async function connect(config: ConnectionConfig) {
+    config = normalizeConnection(config);
+    if (getBlockingDisconnectInFlight(config.id)) await waitForBlockingDisconnectInFlight(config.id);
+    const localAttempt = beginLocalConnectionAttempt(config.id);
+    try {
+      await beforeConnectHandler?.(config);
+      await ensureSqlServerLegacyCompatibilityComponentInstalled(config);
+      ensureLocalConnectionAttemptActive(config.id, localAttempt);
+      const id = await withConnectionAttemptTimeout(api.connectDb(config, localAttempt), config);
+      await ensureLocalConnectionAttemptActiveAfterConnectResult(config.id, localAttempt, id);
+      await syncMongoLegacyDriverFallback(id, config);
+      await ensureLocalConnectionAttemptActiveAfterConnectResult(config.id, localAttempt, id);
+      activeConnectionId.value = id;
+      connectedIds.value.add(id);
+      if (id !== config.id) markSuccessfulLocalConnectionAttempt(config.id, localAttempt);
+      markSuccessfulLocalConnectionAttempt(id, localAttempt);
+      markConnectionHealthChecked(id);
+      clearConnectionError(config.id);
+      if (id !== config.id) clearConnectionError(id);
+
+      const existing = findNode(treeNodes.value, id);
+      if (existing) {
+        existing.label = config.name;
+        existing.type = "connection";
+        existing.connectionId = id;
+        existing.children = existing.children || [];
+      } else {
+        treeNodes.value.push({
+          id,
+          label: config.name,
+          type: "connection",
+          connectionId: id,
+          isExpanded: false,
+          children: [],
+        });
+      }
+      return id;
+    } catch (e) {
+      if (isCancelledLocalConnectionAttempt(config.id, localAttempt)) {
+        clearConnectionError(config.id);
+        throw new Error(CONNECTION_ATTEMPT_CANCELLED_MESSAGE);
+      }
+      if (isCancelledConnectionAttempt(e) || isSupersededConnectionAttempt(e)) {
+        clearConnectionError(config.id);
+      } else {
+        recordConnectionError(config.id, e);
+      }
+      throw e;
+    } finally {
+      finishLocalConnectionAttempt(config.id, localAttempt);
+    }
+  }
+
+  async function cancelConnecting(connectionId: string): Promise<boolean> {
+    const localAttempt = getLocalConnectionAttempt(connectionId);
+    if (localAttempt == null) return false;
+    const disconnectRequest = startCancelDisconnectRequest(connectionId, localAttempt);
+    const cancelled = cancelLocalConnectionAttempt(connectionId);
+    if (!cancelled) return false;
+    clearConnectionError(connectionId);
+    connectedIds.value.delete(connectionId);
+    clearConnectionHealthCheck(connectionId);
+    if (activeConnectionId.value === connectionId) activeConnectionId.value = null;
+    invalidateCompletionCache(connectionId);
+    await disconnectRequest;
+    return true;
+  }
+
+  async function disconnect(connectionId: string) {
+    const stateRevision = bumpConnectionStateRevision(connectionId);
+    const disconnectRequest = startDisconnectRequest(connectionId);
+    cancelLocalConnectionAttempt(connectionId);
+    const shouldRemoveOneTimeConnection = getConfig(connectionId)?.one_time === true;
+
+    connectedIds.value.delete(connectionId);
+    forgetSuccessfulLocalConnectionAttempt(connectionId);
+    clearConnectionHealthCheck(connectionId);
+    const node = findNode(treeNodes.value, connectionId);
+    if (node) {
+      node.isLoading = false;
+      node.isExpanded = false;
+      node.children = [];
+    }
+    clearConnectionRootMetadataLoad(connectionId);
+    clearLoadedChildrenCache(connectionId);
+    if (activeConnectionId.value === connectionId) {
+      activeConnectionId.value = null;
+    }
+    invalidateCompletionCache(connectionId);
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const queryStore = useQueryStore();
+    switch (settingsStore.editorSettings.disconnectTabHandlingMode) {
+      case "close-tabs":
+        queryStore.closeConnectionTabs(connectionId);
+        break;
+      case "keep-tabs-clear-results":
+        queryStore.releaseConnectionTabs(connectionId);
+        break;
+      case "keep-tabs-keep-results":
+        queryStore.rollbackConnectionTransactions(connectionId);
+        break;
+    }
+    await disconnectRequest;
+    if (isCurrentConnectionStateRevision(connectionId, stateRevision)) {
+      clearConnectionError(connectionId);
+    }
+    if (shouldRemoveOneTimeConnection && isCurrentConnectionStateRevision(connectionId, stateRevision)) {
+      await removeConnection(connectionId);
+    }
+  }
+
+  async function closeDatabaseConnection(connectionId: string, database: string) {
+    await api.closeDatabaseConnection(connectionId, database);
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const queryStore = useQueryStore();
+    switch (settingsStore.editorSettings.disconnectTabHandlingMode) {
+      case "close-tabs":
+        queryStore.closeDatabaseTabs(connectionId, database);
+        break;
+      case "keep-tabs-clear-results":
+        queryStore.releaseDatabaseTabs(connectionId, database);
+        break;
+      case "keep-tabs-keep-results":
+        queryStore.rollbackDatabaseTransactions(connectionId, database);
+        break;
+    }
+    const node = findDatabaseTreeNode(treeNodes.value, connectionId, database);
+    if (node) {
+      node.isExpanded = false;
+      node.children = [];
+      clearLoadedChildrenCache(node.id);
+    }
+    invalidateCompletionCache(connectionId, database);
+  }
+
+  async function ensureConnected(connectionId: string) {
+    if (connectedIds.value.has(connectionId)) {
+      if (hasRecentConnectionHealthCheck(connectionId)) return;
+      // Optimistic: verify backend pool is actually healthy
+      try {
+        await withConnectionHealthTimeout(connectionId, api.checkConnectionHealth(connectionId));
+        markConnectionHealthChecked(connectionId);
+        return;
+      } catch {
+        // Backend pool is dead — remove from connectedIds and reconnect
+        connectedIds.value.delete(connectionId);
+        clearConnectionHealthCheck(connectionId);
+        if (activeConnectionId.value === connectionId) activeConnectionId.value = null;
+      }
+    }
+    let config = getConfig(connectionId);
+    if (!config) {
+      await initFromDisk();
+      config = getConfig(connectionId);
+    }
+    if (!config) {
+      const error = new Error("Connection config not found");
+      recordConnectionError(connectionId, error);
+      throw error;
+    }
+    if (getBlockingDisconnectInFlight(connectionId)) await waitForBlockingDisconnectInFlight(connectionId);
+    const existingConnect = connectInFlight.get(connectionId);
+    if (existingConnect) {
+      await existingConnect;
+      return;
+    }
+    const localAttempt = beginLocalConnectionAttempt(connectionId);
+    const connectPromise = (async () => {
+      await beforeConnectHandler?.(config);
+      ensureLocalConnectionAttemptActive(connectionId, localAttempt);
+      const id = await withConnectionAttemptTimeout(api.connectDb(config, localAttempt), config);
+      await ensureLocalConnectionAttemptActiveAfterConnectResult(connectionId, localAttempt, id);
+      await syncMongoLegacyDriverFallback(connectionId, config);
+      await ensureLocalConnectionAttemptActiveAfterConnectResult(connectionId, localAttempt, id);
+      connectedIds.value.add(connectionId);
+      markSuccessfulLocalConnectionAttempt(connectionId, localAttempt);
+      markConnectionHealthChecked(connectionId);
+      activeConnectionId.value = connectionId;
+      clearConnectionError(connectionId);
+    })();
+    connectInFlight.set(connectionId, connectPromise);
+    try {
+      await connectPromise;
+    } catch (e) {
+      if (isCancelledLocalConnectionAttempt(connectionId, localAttempt)) {
+        clearConnectionError(connectionId);
+        throw new Error(CONNECTION_ATTEMPT_CANCELLED_MESSAGE);
+      }
+      if (isCancelledConnectionAttempt(e)) {
+        clearConnectionError(connectionId);
+        throw e;
+      }
+      if (isSupersededConnectionAttempt(e) && connectedIds.value.has(connectionId)) {
+        clearConnectionError(connectionId);
+        return;
+      }
+      recordConnectionError(connectionId, e);
+      clearConnectionNodeLoading(connectionId);
+      throw e;
+    } finally {
+      if (connectInFlight.get(connectionId) === connectPromise) {
+        connectInFlight.delete(connectionId);
+      }
+      finishLocalConnectionAttempt(connectionId, localAttempt);
+    }
+  }
+
+  function setBeforeConnectHandler(handler: BeforeConnectHandler | null) {
+    beforeConnectHandler = handler;
+  }
+
+  async function loadDatabases(connectionId: string, options?: LoadTreeOptions) {
+    const configForScope = getConfig(connectionId);
+    return runTreeMetadataLoad(
+      {
+        kind: "connection-databases",
+        connectionId,
+        driverProfile: metadataDriverProfile(configForScope),
+      },
+      async () => {
+        const node = findNode(treeNodes.value, connectionId);
+        if (!node) return;
+        node.isLoading = true;
+        try {
+          await ensureConnected(connectionId);
+          if (useCachedChildren(node, options)) return;
+
+          const config = getConfig(connectionId);
+          if (config?.db_type === "duckdb") {
+            const cacheKey = schemaCacheKey(connectionId, "duckdb-root");
+            if (!options?.force) {
+              const cached = await loadPersistedTreeChildren(node, cacheKey);
+              if (cached.hit) {
+                if (cached.isStale) refreshStaleTreeNode(node);
+                return;
+              }
+            }
+            const [databases, schemas] = await Promise.all([withMetadataLoadTimeout(connectionId, api.listDatabases(connectionId), "databases"), withMetadataLoadTimeout(connectionId, api.listSchemas(connectionId, "main"), "schemas")]);
+            const children = withSavedSqlRoot(connectionId, buildDuckDbConnectionTreeNodes(connectionId, databases, schemas), node);
+            if (isSidebarSearchQueryChanged(options)) return;
+            if (!canApplyTreeMetadataResult(node)) return;
+            setChildren(node, children);
+            await savePersistedConnectionTreeChildren(cacheKey, node.children || children);
+          } else if (config && connectionUsesVisibleSchemaFilter(config)) {
+            const schemaFilterConfig = config;
+            const effectiveDb = schemaFilterConfig.database || "";
+            const cacheKey = schemaCacheKey(connectionId, effectiveDb, "schemas");
+            if (!options?.force) {
+              const cached = await loadPersistedTreeChildren(node, cacheKey);
+              if (cached.hit) {
+                if (cached.isStale) refreshStaleTreeNode(node);
+                return;
+              }
+            }
+            const schemas = await withMetadataLoadTimeout(connectionId, api.listSchemas(connectionId, effectiveDb, true), "schemas");
+            const visibleSchemas = filterSchemaNamesForConnection(schemas, schemaFilterConfig, effectiveDb || "");
+            const schemaNodes: TreeNode[] = sortSidebarNames(visibleSchemas).map((s) => ({
+              id: `${connectionId}:${s}:${s}`,
+              label: s,
+              type: "schema" as const,
+              connectionId,
+              database: s,
+              schema: s,
+              isExpanded: false,
+              children: [],
+            }));
+            if (isSidebarSearchQueryChanged(options)) return;
+            if (!canApplyTreeMetadataResult(node)) return;
+            setChildren(node, withSavedSqlRoot(connectionId, schemaNodes, node));
+            await savePersistedConnectionTreeChildren(cacheKey, node.children || schemaNodes);
+          } else {
+            // Doris / StarRocks multi-catalog: when external catalogs exist,
+            // render a catalog grouping layer (catalog → database → tables).
+            // When only `internal` is present, fall through to the flat database
+            // list (no regression for single-catalog deployments).
+            let dorisCatalogs: CatalogInfo[] | null = null;
+            if (connectionIsDorisFamilyCatalogCapable(config)) {
+              dorisCatalogs = await withMetadataLoadTimeout(connectionId, api.listDorisCatalogs(connectionId), "catalogs").catch((error: unknown) => {
+                recordMetadataLoadError(connectionId, error);
+                return null;
+              });
+            }
+            if (dorisCatalogs && dorisCatalogs.length > 1) {
+              const cacheKey = schemaCacheKey(connectionId, "doris-catalogs");
+              if (!options?.force) {
+                const cached = await loadPersistedTreeChildren(node, cacheKey);
+                if (cached.hit) {
+                  if (cached.isStale) refreshStaleTreeNode(node);
+                  return;
+                }
+              }
+              const catalogNodes: TreeNode[] = dorisCatalogs.map((catalog) => ({
+                id: dorisCatalogId(connectionId, catalog.name),
+                label: catalog.name,
+                type: "doris-catalog" as const,
+                connectionId,
+                catalog: catalog.name,
+                catalogType: catalog.catalog_type,
+                comment: catalog.comment ?? null,
+                isExpanded: false,
+                children: [],
+              }));
+              const children = withSavedSqlRoot(connectionId, catalogNodes, node);
+              if (isSidebarSearchQueryChanged(options)) return;
+              if (!canApplyTreeMetadataResult(node)) return;
+              setChildren(node, children);
+              await savePersistedConnectionTreeChildren(cacheKey, node.children || children);
+            } else {
+              const cacheKey = schemaCacheKey(connectionId, "databases");
+              if (!options?.force) {
+                const cached = await loadPersistedTreeChildren(node, cacheKey);
+                if (cached.hit) {
+                  if (cached.isStale) refreshStaleTreeNode(node);
+                  return;
+                }
+              }
+              const databases = await withMetadataLoadTimeout(connectionId, api.listDatabases(connectionId), "databases");
+              const visibleNames = filterDatabaseNamesForConnection(
+                databases.map((database) => database.name),
+                config,
+              );
+              const visibleNameSet = new Set(visibleNames);
+              const visibleDatabases = databases.filter((database) => visibleNameSet.has(database.name));
+              const effectiveDbType = effectiveDatabaseTypeForConnection(config);
+              const databaseNodes = buildDatabaseTreeNodes(connectionId, visibleDatabases, {
+                includeDefaultWhenEmpty: usesTreeSchemaMode(effectiveDbType) || shouldIncludeDefaultDatabaseNode(config, visibleDatabases),
+              });
+              if (config?.db_type === "sqlserver") {
+                const linkedServers = await withMetadataLoadTimeout(connectionId, api.listSqlServerLinkedServers(connectionId), "linked servers").catch(() => []);
+                const linkedDatabase = sqlServerLinkedRuntimeDatabase(config);
+                databaseNodes.push({
+                  ...sqlServerLinkedRootNode(connectionId, linkedDatabase),
+                  children: linkedServers.map((server) => ({
+                    id: sqlServerLinkedServerId(connectionId, server.name),
+                    label: server.name,
+                    type: "linked-server",
+                    connectionId,
+                    database: linkedDatabase,
+                    linkedServer: server.name,
+                    comment: [server.product, server.provider, server.data_source].filter(Boolean).join(" / ") || null,
+                    isExpanded: false,
+                    children: [],
+                  })),
+                });
+                if (linkedServers.length > 0) loadedTreeNodeChildrenIds.value.add(sqlServerLinkedRootId(connectionId));
+              }
+              const children = withSavedSqlRoot(connectionId, databaseNodes, node);
+              if (isSidebarSearchQueryChanged(options)) return;
+              if (!canApplyTreeMetadataResult(node)) return;
+              setChildren(node, children);
+              await savePersistedConnectionTreeChildren(cacheKey, node.children || children);
+            }
+          }
+          node.isExpanded = true;
+        } catch (e) {
+          recordMetadataLoadError(connectionId, e);
+          throw e;
+        } finally {
+          node.isLoading = false;
+        }
+      },
+      options,
+    );
+  }
+
+  async function loadRedisDatabases(connectionId: string) {
+    const node = findNode(treeNodes.value, connectionId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      const dbs = await withMetadataLoadTimeout(connectionId, api.redisListDatabases(connectionId), "Redis databases");
+      const config = getConfig(connectionId);
+      const visibleNames = filterVisibleDatabaseNames(
+        dbs.map((db) => String(db.db)),
+        config?.visible_databases,
+      );
+      const visibleNameSet = new Set(visibleNames);
+      setChildren(
+        node,
+        withSavedSqlRoot(
+          connectionId,
+          dbs
+            .filter((db) => visibleNameSet.has(String(db.db)))
+            .map((db) => ({
+              id: `${connectionId}:db${db.db}`,
+              label: redisDbLabel(db.db, 0, db.keys),
+              type: "redis-db" as const,
+              connectionId,
+              database: String(db.db),
+              loadedKeyCount: 0,
+              totalKeyCount: db.keys,
+              isExpanded: false,
+              children: [],
+            })),
+          node,
+        ),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadEtcdRoot(connectionId: string) {
+    const node = findNode(treeNodes.value, connectionId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      setChildren(
+        node,
+        withSavedSqlRoot(
+          connectionId,
+          [
+            {
+              id: `${connectionId}:etcd`,
+              label: kvRootNodeLabel("etcd"),
+              type: "etcd-root" as const,
+              connectionId,
+              database: "",
+              isExpanded: false,
+              children: [],
+            },
+          ],
+          node,
+        ),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadZooKeeperRoot(connectionId: string) {
+    const node = findNode(treeNodes.value, connectionId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      setChildren(
+        node,
+        withSavedSqlRoot(
+          connectionId,
+          [
+            {
+              id: `${connectionId}:zookeeper`,
+              label: kvRootNodeLabel("zookeeper"),
+              type: "zookeeper-root" as const,
+              connectionId,
+              database: "",
+              isExpanded: false,
+              children: [],
+            },
+          ],
+          node,
+        ),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadMqTenants(connectionId: string, options?: LoadTreeOptions) {
+    const node = findNode(treeNodes.value, connectionId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      if (useCachedChildren(node, options)) return;
+
+      const config = getConfig(connectionId);
+      if (isKafkaMqConnection(config)) {
+        // Kafka has no tenant/namespace concept. Create a synthetic child
+        // that opens the MQ admin console directly when clicked.
+        setChildren(node, [
+          {
+            id: schemaCacheKey(connectionId, "mq-tenant", "_kafka"),
+            label: "Topics",
+            type: "mq-tenant" as const,
+            connectionId,
+            mqTenant: "_kafka",
+            mqInitialTab: "topics",
+          },
+        ]);
+      } else {
+        const tenants = await withMetadataLoadTimeout(connectionId, api.mqListTenants(connectionId), "message queue tenants");
+        const tenantNames = sortSidebarNames(tenants.map((tenant) => tenant.name).filter((name) => !!name.trim()));
+        setChildren(
+          node,
+          tenantNames.map((tenant) => ({
+            id: schemaCacheKey(connectionId, "mq-tenant", tenant),
+            label: tenant,
+            type: "mq-tenant" as const,
+            connectionId,
+            mqTenant: tenant,
+          })),
+        );
+      }
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadNacosNamespaces(connectionId: string, options?: LoadTreeOptions) {
+    const node = findNode(treeNodes.value, connectionId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      if (useCachedChildren(node, options)) return;
+
+      const namespaces = await api.nacosListNamespaces(connectionId);
+      const sorted = [...namespaces].sort((left, right) => {
+        const leftLabel = left.namespaceShowName || left.namespace || "public";
+        const rightLabel = right.namespaceShowName || right.namespace || "public";
+        return leftLabel.localeCompare(rightLabel);
+      });
+      setChildren(
+        node,
+        sorted.map((namespace) => {
+          const value = namespace.namespace || "";
+          const label = namespace.namespaceShowName || value || "public";
+          return {
+            id: schemaCacheKey(connectionId, "nacos-namespace", value || "public"),
+            label,
+            type: "nacos-namespace" as const,
+            connectionId,
+            nacosNamespace: value,
+            nacosNamespaceName: label,
+            comment: namespace.namespaceDesc || null,
+            objectCount: namespace.configCount,
+          };
+        }),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  function updateRedisDbKeyStats(connectionId: string, db: number, stats: { loaded?: number; total?: number; totalDelta?: number }) {
+    const node = findNode(treeNodes.value, `${connectionId}:db${db}`);
+    if (!node || node.type !== "redis-db") return;
+    if (stats.loaded != null) node.loadedKeyCount = stats.loaded;
+    if (stats.total != null) node.totalKeyCount = stats.total;
+    if (stats.totalDelta != null && node.totalKeyCount != null) {
+      node.totalKeyCount = Math.max(0, node.totalKeyCount + stats.totalDelta);
+    }
+    node.label = redisDbLabel(db, node.loadedKeyCount, node.totalKeyCount);
+  }
+
+  // Re-fetch the authoritative per-db key counts (INFO keyspace, lightweight) and update
+  // the sidebar db nodes' counts in place — WITHOUT rebuilding the tree, so already-loaded
+  // key trees under expanded db nodes are preserved. Used after a Redis write command so the
+  // `dbN (count)` labels reflect the new reality without a manual refresh.
+  async function refreshRedisDbKeyCounts(connectionId: string) {
+    const connNode = findNode(treeNodes.value, connectionId);
+    if (!connNode) return;
+    try {
+      await ensureConnected(connectionId);
+      const dbs = await api.redisListDatabases(connectionId);
+      for (const db of dbs) {
+        updateRedisDbKeyStats(connectionId, db.db, { total: db.keys });
+      }
+    } catch {
+      // Best-effort: a failed count refresh must not disrupt the result view.
+    }
+  }
+
+  async function loadMongoDatabases(connectionId: string) {
+    const node = findNode(treeNodes.value, connectionId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      const dbs = await withMetadataLoadTimeout(connectionId, api.mongoListDatabases(connectionId), "MongoDB databases");
+      const config = getConfig(connectionId);
+      const visibleDbs = filterDatabaseNamesForConnection(dbs, config);
+      setChildren(
+        node,
+        withSavedSqlRoot(
+          connectionId,
+          sortSidebarNames(visibleDbs).map((db) => ({
+            id: `${connectionId}:${db}`,
+            label: db,
+            type: "mongo-db" as const,
+            connectionId,
+            database: db,
+            isExpanded: false,
+            children: [],
+          })),
+          node,
+        ),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadElasticsearchIndices(connectionId: string) {
+    const node = findNode(treeNodes.value, connectionId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      const indices = await withMetadataLoadTimeout(connectionId, api.elasticsearchListIndices(connectionId), "Elasticsearch indices");
+      setChildren(
+        node,
+        withSavedSqlRoot(
+          connectionId,
+          sortSidebarNames(indices).map((index) => ({
+            id: `${connectionId}:__collection:${index}`,
+            label: index,
+            type: "elasticsearch-index" as const,
+            connectionId,
+            database: "default",
+            isExpanded: false,
+          })),
+          node,
+        ),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadMilvusDatabases(connectionId: string) {
+    const node = findNode(treeNodes.value, connectionId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      const dbs = await withMetadataLoadTimeout(connectionId, api.documentListDatabases(connectionId), "Milvus databases");
+      setChildren(
+        node,
+        withSavedSqlRoot(
+          connectionId,
+          sortSidebarNames(dbs).map((db) => ({
+            id: `${connectionId}:${db}`,
+            label: db,
+            type: "vector-database" as const,
+            connectionId,
+            database: db,
+            isExpanded: false,
+            children: [],
+          })),
+          node,
+        ),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadVectorCollections(connectionId: string, database?: string) {
+    const config = getConfig(connectionId);
+    const isMilvus = config?.db_type === "milvus";
+    const effectiveDb = database || config?.database || "default";
+    // Milvus groups collections under a per-database node; other vector stores stay flat under the connection.
+    const node = isMilvus && database ? findNode(treeNodes.value, `${connectionId}:${database}`) : findNode(treeNodes.value, connectionId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      const collections = await withMetadataLoadTimeout(connectionId, api.vectorListCollections(connectionId, effectiveDb), "vector collections");
+      const sorted = [...collections].sort((a, b) => a.name.localeCompare(b.name));
+      const collectionChildren = sorted.map((info) => ({
+        // Include the database for Milvus so same-named collections across databases don't collide.
+        id: `${connectionId}:__vector_collection:${isMilvus ? `${effectiveDb}:${info.id}` : info.id}`,
+        label: info.name,
+        type: "vector-collection" as const,
+        connectionId,
+        database: effectiveDb,
+        isExpanded: false,
+        meta: { dimension: info.dimension, collectionId: info.id } as VectorCollectionMeta,
+      }));
+      setChildren(node, isMilvus && database ? collectionChildren : withSavedSqlRoot(connectionId, collectionChildren, node));
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadMongoCollections(connectionId: string, database: string) {
+    const nodeId = `${connectionId}:${database}`;
+    const node = findNode(treeNodes.value, nodeId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      const collections = await api.mongoListCollections(connectionId, database);
+      const bucketNames = new Set(collections.filter((c) => c.kind === "bucket" && c.bucketName).map((c) => c.bucketName as string));
+      const hiddenCollectionNames = new Set([...bucketNames].flatMap((bucketName) => [`${bucketName}.files`, `${bucketName}.chunks`]));
+      const collectionNames = collections
+        .filter((c) => c.kind !== "bucket")
+        .map((c) => c.name)
+        .filter((name) => !hiddenCollectionNames.has(name));
+      const collectionChildren = sortSidebarNames(collectionNames).map((col) => ({
+        id: `${nodeId}:${col}`,
+        label: col,
+        type: "mongo-collection" as const,
+        connectionId,
+        database,
+        isExpanded: false,
+      }));
+      const children = [
+        {
+          id: `${nodeId}:__gridfs`,
+          label: i18n.global.t("tree.gridfs"),
+          type: "mongo-gridfs" as const,
+          connectionId,
+          database,
+          isExpanded: false,
+        },
+        ...collectionChildren,
+      ];
+      setChildren(node, children);
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadSchemas(connectionId: string, database: string, options?: LoadTreeOptions) {
+    const configForScope = getConfig(connectionId);
+    return runTreeMetadataLoad(
+      {
+        kind: "database-schemas",
+        connectionId,
+        database,
+        driverProfile: metadataDriverProfile(configForScope),
+      },
+      async () => {
+        const nodeId = `${connectionId}:${database}`;
+        const node = findNode(treeNodes.value, nodeId);
+        if (!node) return;
+        node.isLoading = true;
+        try {
+          await ensureConnected(connectionId);
+          if (useCachedChildren(node, options)) return;
+          const cacheKey = schemaCacheKey(connectionId, database, "schemas-v2");
+          if (!options?.force) {
+            const cached = await loadPersistedTreeChildren(node, cacheKey);
+            if (cached.hit) {
+              if (cached.isStale) refreshStaleTreeNode(node);
+              return;
+            }
+          }
+
+          const schemas = sortSidebarSchemaInfos(await api.listSchemaInfos(connectionId, database));
+          const visibleSchemaNames = new Set(
+            filterSchemaNamesForConnection(
+              schemas.map((schema) => schema.name),
+              getConfig(connectionId),
+              database,
+            ),
+          );
+          const children = schemas
+            .filter((schema) => visibleSchemaNames.has(schema.name))
+            .map((schema) => {
+              const s = schema.name;
+              return {
+                id: `${connectionId}:${database}:${s}`,
+                label: s,
+                type: "schema" as const,
+                connectionId,
+                database,
+                schema: s,
+                comment: schema.comment,
+                isExpanded: false,
+                children: [],
+              };
+            });
+          if (isSidebarSearchQueryChanged(options)) return;
+          if (!canApplyTreeMetadataResult(node)) return;
+          setChildren(node, children);
+          await savePersistedTreeChildren(cacheKey, children);
+          node.isExpanded = true;
+        } catch (e) {
+          recordMetadataLoadError(connectionId, e);
+          throw e;
+        } finally {
+          node.isLoading = false;
+        }
+      },
+      options,
+    );
+  }
+
+  async function loadSqlServerDatabaseObjects(connectionId: string, database: string, options?: LoadTreeOptions) {
+    const nodeId = `${connectionId}:${database}`;
+    const node = findNode(treeNodes.value, nodeId);
+    if (!node) return;
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      if (useCachedChildren(node, options)) return;
+      const simpleObjectDisplay = useSettingsStore().editorSettings.sidebarObjectDisplay === "simple";
+      const cacheKey = schemaCacheKey(connectionId, database, simpleObjectDisplay ? "sqlserver-schemas-simple-v4" : "sqlserver-schemas-grouped-v4");
+      if (!options?.force) {
+        const cached = await loadPersistedTreeChildren(node, cacheKey);
+        if (cached.hit) {
+          if (cached.isStale) refreshStaleTreeNode(node);
+          return;
+        }
+      }
+
+      const config = getConfig(connectionId);
+      const schemas = filterSchemaNamesForConnection(await api.listSchemas(connectionId, database), config, database);
+      const children = buildSqlServerDatabaseTreeNodes(connectionId, database, schemas);
+      if (isSidebarSearchQueryChanged(options)) return;
+      setChildren(node, children);
+      await savePersistedTreeChildren(cacheKey, children);
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadSqlServerLinkedServers(connectionId: string, options?: LoadTreeOptions) {
+    const node = findNode(treeNodes.value, sqlServerLinkedRootId(connectionId));
+    if (!node) return;
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      if (useCachedChildren(node, options)) return;
+      const config = getConfig(connectionId);
+      const database = sqlServerLinkedRuntimeDatabase(config);
+      const linkedServers = await api.listSqlServerLinkedServers(connectionId);
+      setChildren(
+        node,
+        linkedServers.map((server) => ({
+          id: sqlServerLinkedServerId(connectionId, server.name),
+          label: server.name,
+          type: "linked-server" as const,
+          connectionId,
+          database,
+          linkedServer: server.name,
+          comment: [server.product, server.provider, server.data_source].filter(Boolean).join(" / ") || null,
+          isExpanded: false,
+          children: [],
+        })),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadSqlServerLinkedServerCatalogs(node: TreeNode, options?: LoadTreeOptions) {
+    if (!node.connectionId || !node.linkedServer) return;
+    const connectionId = node.connectionId;
+    const server = node.linkedServer;
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      if (useCachedChildren(node, options)) return;
+      const catalogs = await api.listSqlServerLinkedServerCatalogs(connectionId, server);
+      const database = node.database || sqlServerLinkedRuntimeDatabase(getConfig(connectionId));
+      setChildren(
+        node,
+        catalogs
+          .filter((catalog) => catalog.name.trim())
+          .map((catalog) => ({
+            id: sqlServerLinkedCatalogId(connectionId, server, catalog.name),
+            label: catalog.name,
+            type: "linked-server-catalog" as const,
+            connectionId,
+            database,
+            linkedServer: server,
+            linkedCatalog: catalog.name,
+            isExpanded: false,
+            children: [],
+          })),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadSqlServerLinkedServerSchemas(node: TreeNode, options?: LoadTreeOptions) {
+    if (!node.connectionId || !node.linkedServer || !node.linkedCatalog) return;
+    node.isLoading = true;
+    try {
+      await ensureConnected(node.connectionId);
+      if (useCachedChildren(node, options)) return;
+      const schemas = await api.listSqlServerLinkedServerSchemas(node.connectionId, node.linkedServer, node.linkedCatalog);
+      const database = node.database || sqlServerLinkedRuntimeDatabase(getConfig(node.connectionId));
+      setChildren(
+        node,
+        sortSidebarNames(schemas)
+          .filter((schema) => schema.trim())
+          .map((schema) => {
+            const encodedSchema = encodeSqlServerLinkedSchema({
+              server: node.linkedServer!,
+              catalog: node.linkedCatalog!,
+              schema,
+            });
+            return {
+              id: `${node.connectionId}:${database}:${encodedSchema}`,
+              label: schema,
+              type: "linked-server-schema" as const,
+              connectionId: node.connectionId,
+              database,
+              schema: encodedSchema,
+              linkedServer: node.linkedServer,
+              linkedCatalog: node.linkedCatalog,
+              linkedSchema: schema,
+              isExpanded: false,
+              children: [],
+            };
+          }),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(node.connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  // Doris / StarRocks multi-catalog: load the databases under a catalog node.
+  async function loadDorisCatalogDatabases(node: TreeNode, options?: LoadTreeOptions) {
+    if (!node.connectionId || !node.catalog) return;
+    const connectionId = node.connectionId;
+    const catalog = node.catalog;
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      if (useCachedChildren(node, options)) return;
+      const config = getConfig(connectionId);
+      const databases = await withMetadataLoadTimeout(connectionId, api.listDorisCatalogDatabases(connectionId, catalog), "databases");
+      let databaseNodes: TreeNode[];
+      if (isInternalDorisCatalog(node.catalogType, catalog)) {
+        // The internal catalog's databases are rendered as standard database
+        // nodes so they reuse the existing table-loading / table-open paths.
+        // Detection is type-based (catalogType=`internal`), so StarRocks
+        // `default_catalog` routes here too — its tables carry no catalog.
+        const visibleNames = filterDatabaseNamesForConnection(
+          databases.map((database) => database.name),
+          config,
+        );
+        const visibleNameSet = new Set(visibleNames);
+        const visibleDatabases = databases.filter((database) => visibleNameSet.has(database.name));
+        databaseNodes = buildDatabaseTreeNodes(connectionId, visibleDatabases, { includeDefaultWhenEmpty: false });
+      } else {
+        databaseNodes = sortSidebarDatabases(databases).flatMap((database) => {
+          const name = database.name.trim();
+          if (!name) return [];
+          return [
+            {
+              id: dorisCatalogDatabaseId(connectionId, catalog, name),
+              label: name,
+              type: "database" as const,
+              connectionId,
+              database: name,
+              catalog,
+              isExpanded: false,
+              children: [],
+            },
+          ];
+        });
+      }
+      if (isSidebarSearchQueryChanged(options)) return;
+      if (!canApplyTreeMetadataResult(node)) return;
+      setChildren(node, databaseNodes);
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  // Doris / StarRocks multi-catalog: load tables under an external-catalog
+  // database node. External catalogs only expose tables/views, so a flat list
+  // (no routines/sequences/triggers) is rendered.
+  async function loadDorisCatalogTables(node: TreeNode, options?: LoadTreeOptions) {
+    if (!node.connectionId || !node.database || !node.catalog) return;
+    const connectionId = node.connectionId;
+    const { database, catalog } = node;
+    const configForScope = getConfig(connectionId);
+    const simpleObjectDisplayForScope = useSettingsStore().editorSettings.sidebarObjectDisplay === "simple";
+    const objectTypesForScope = simpleObjectDisplayForScope ? supportedSidebarObjectTypes(configForScope) : undefined;
+    return runTreeMetadataLoad(
+      {
+        kind: "schema-tables",
+        connectionId,
+        database,
+        schema: undefined,
+        nodeKind: "database",
+        objectTypes: objectTypesForScope,
+        searchFilter: activeTreeLoadSearchFilter(options),
+        limit: simpleObjectDisplayForScope ? sidebarObjectGroupPageSize() + 1 : undefined,
+        offset: 0,
+        sidebarDisplayMode: simpleObjectDisplayForScope ? "simple" : "grouped",
+        driverProfile: metadataDriverProfile(configForScope),
+        extra: options?.sidebarTableSearchParentId ? { sidebarTableSearchParentId: options.sidebarTableSearchParentId } : undefined,
+      },
+      async () => {
+        node.isLoading = true;
+        try {
+          await ensureConnected(connectionId);
+          if (useCachedChildren(node, options)) return;
+          const searchFilter = activeTreeLoadSearchFilter(options);
+          const cacheKey = schemaCacheKey(connectionId, `doris-catalog:${catalog}`, database, "objects-simple-v3");
+          if (!options?.force && !searchFilter) {
+            const cached = await loadPersistedTreeChildren(node, cacheKey);
+            if (cached.hit) {
+              if (cached.isStale) refreshStaleTreeNode(node);
+              return;
+            }
+          }
+          const pageSize = sidebarObjectGroupPageSize();
+          const fetchLimit = searchFilter ? pageSize : pageSize + 1;
+          const fetchOffset = searchFilter ? undefined : 0;
+          const tables = await withMetadataLoadTimeout(connectionId, api.listTables(connectionId, database, "", searchFilter, fetchLimit, fetchOffset, objectTypesForScope, catalog), "tables");
+          const hasMore = searchFilter ? false : tables.length > pageSize;
+          const pageTables = hasMore ? tables.slice(0, pageSize) : tables;
+          indexCompletionTables(connectionId, database, undefined, tableInfosToCompletionTables(pageTables, undefined));
+          let children = buildTableTreeNodes({
+            nodeId: node.id,
+            connectionId,
+            database,
+            schema: undefined,
+            tables: pageTables,
+            catalog,
+          });
+          if (hasMore && !searchFilter) {
+            children = [...children, buildLoadMoreNode(node, pageSize, pageSize)];
+          }
+          if (isTreeLoadSearchChanged(searchFilter, options)) return;
+          if (!canApplyTreeMetadataResult(node)) return;
+          node.objectCount = children.filter((child) => child.type !== "load-more").length;
+          setChildren(node, children);
+          if (!searchFilter && !options?.sidebarTableSearchParentId) {
+            await savePersistedTreeChildren(cacheKey, children);
+          }
+          node.isExpanded = true;
+        } catch (e) {
+          recordMetadataLoadError(connectionId, e);
+          throw e;
+        } finally {
+          node.isLoading = false;
+        }
+      },
+      options,
+    );
+  }
+
+  async function loadTables(connectionId: string, database: string, schema?: string, options?: LoadTreeOptions) {
+    const configForScope = getConfig(connectionId);
+    const simpleObjectDisplayForScope = useSettingsStore().editorSettings.sidebarObjectDisplay === "simple";
+    const objectTypesForScope = simpleObjectDisplayForScope ? supportedSidebarObjectTypes(configForScope) : undefined;
+    return runTreeMetadataLoad(
+      {
+        kind: "schema-tables",
+        connectionId,
+        database,
+        schema,
+        nodeKind: schema ? "schema" : "database",
+        objectTypes: objectTypesForScope,
+        searchFilter: activeTreeLoadSearchFilter(options),
+        limit: simpleObjectDisplayForScope ? sidebarObjectGroupPageSize() + 1 : undefined,
+        offset: 0,
+        sidebarDisplayMode: simpleObjectDisplayForScope ? "simple" : "grouped",
+        driverProfile: metadataDriverProfile(configForScope),
+        extra: options?.sidebarTableSearchParentId ? { sidebarTableSearchParentId: options.sidebarTableSearchParentId } : undefined,
+      },
+      async () => {
+        const nodeId = schema ? `${connectionId}:${database}:${schema}` : `${connectionId}:${database}`;
+        const node = findNode(treeNodes.value, nodeId);
+        if (!node) return;
+        node.isLoading = true;
+        try {
+          await ensureConnected(connectionId);
+          if (useCachedChildren(node, options)) return;
+          const simpleObjectDisplay = useSettingsStore().editorSettings.sidebarObjectDisplay === "simple";
+          const cacheKey = schemaCacheKey(connectionId, database, schema || "", simpleObjectDisplay ? "objects-simple-v3" : "objects-grouped-v3");
+          const searchFilter = activeTreeLoadSearchFilter(options);
+          const isSidebarTableSearch = !!options?.sidebarTableSearchParentId;
+          if (!options?.force && !searchFilter) {
+            const cached = await loadPersistedTreeChildren(node, cacheKey);
+            if (cached.hit) {
+              if (cached.isStale) refreshStaleTreeNode(node);
+              return;
+            }
+          }
+
+          const config = getConfig(connectionId);
+          const querySchema = connectionObjectTreeQuerySchema(config, database, schema);
+          const effectiveSchema = connectionObjectTreeNodeSchema(config, database, schema);
+          const nonTableObjectTypes = simpleObjectDisplay ? supportedSidebarObjectTypes(config).filter((objectType) => objectType !== "TABLE") : [];
+          let children: TreeNode[];
+          let nextObjectCount: number | undefined;
+          if (simpleObjectDisplay) {
+            const pageSize = sidebarObjectGroupPageSize();
+            const page = await loadPagedSimpleTableChildren({
+              nodeId,
+              connectionId,
+              database,
+              querySchema,
+              effectiveSchema,
+              nonTableObjectTypes,
+              offset: 0,
+              pageSize,
+              searchFilter: searchFilter || undefined,
+              force: options?.force,
+            });
+            children = page.hasMore && !searchFilter ? appendTableTreeLoadMoreNode(page.children, buildLoadMoreNode(node, page.nextOffset, pageSize), page.loadMoreParent) : page.children;
+            nextObjectCount = page.objectCount;
+          } else {
+            children = buildObjectGroupPlaceholderNodes({
+              nodeId,
+              connectionId,
+              database,
+              schema: effectiveSchema,
+              objectTypes: supportedSidebarObjectTypes(config),
+            });
+            if (isPostgresLikeForExtensions(config?.db_type)) {
+              children.push({
+                id: `${nodeId}:__extensions`,
+                label: "tree.extensions",
+                type: "group-extensions",
+                connectionId,
+                database,
+                schema: effectiveSchema,
+                isExpanded: false,
+                children: [],
+              });
+            }
+          }
+          if (isTreeLoadSearchChanged(searchFilter, options)) return;
+          if (!canApplyTreeMetadataResult(node)) return;
+          if (nextObjectCount !== undefined) node.objectCount = nextObjectCount;
+          setChildren(node, children);
+          if (!searchFilter && !isSidebarTableSearch) {
+            await savePersistedTreeChildren(cacheKey, children);
+          }
+          node.isExpanded = true;
+          if (simpleObjectDisplay && !searchFilter && !isSidebarTableSearch && nonTableObjectTypes.length > 0) {
+            void loadSimpleSupplementalObjectChildren({
+              node,
+              nodeId,
+              connectionId,
+              database,
+              querySchema,
+              effectiveSchema,
+              objectTypes: nonTableObjectTypes,
+              cacheKey,
+              loadOptions: options,
+            });
+          }
+        } catch (e) {
+          recordMetadataLoadError(connectionId, e);
+          throw e;
+        } finally {
+          node.isLoading = false;
+        }
+      },
+      options,
+    );
+  }
+
+  async function loadObjectGroupChildren(node: TreeNode, options?: LoadTreeOptions) {
+    const configForScope = node.connectionId ? getConfig(node.connectionId) : undefined;
+    const objectTypesForScope = objectTypesForGroupNode(node.type);
+    const pageSizeForScope = sidebarObjectGroupPageSize();
+    return runTreeMetadataLoad(
+      {
+        kind: "object-group",
+        connectionId: node.connectionId,
+        database: node.database,
+        schema: node.schema,
+        nodeKind: node.type,
+        objectTypes: objectTypesForScope,
+        searchFilter: activeTreeLoadSearchFilter(options),
+        limit: pageSizeForScope + 1,
+        offset: 0,
+        sidebarDisplayMode: useSettingsStore().editorSettings.sidebarObjectDisplay,
+        driverProfile: metadataDriverProfile(configForScope),
+        extra: options?.sidebarTableSearchParentId ? { sidebarTableSearchParentId: options.sidebarTableSearchParentId } : undefined,
+      },
+      async () => {
+        if (!node.connectionId || !hasTreeNodeDatabaseContext(node)) return;
+        node.isLoading = true;
+        try {
+          await ensureConnected(node.connectionId);
+          if (useCachedChildren(node, options)) return;
+          const objectTypes = objectTypesForGroupNode(node.type);
+          const parentNodeId = objectGroupRefreshParentId(node);
+          if (!objectTypes || !parentNodeId) return;
+
+          const config = getConfig(node.connectionId);
+          const querySchema = connectionObjectTreeQuerySchema(config, node.database, node.schema);
+          const effectiveSchema = connectionObjectTreeNodeSchema(config, node.database, node.schema);
+          const cacheKey = objectGroupCacheKey(node);
+          const searchFilter = activeTreeLoadSearchFilter(options);
+          const isSidebarTableSearch = !!options?.sidebarTableSearchParentId;
+          if (!options?.force && !searchFilter) {
+            const cached = await loadPersistedTreeChildren(node, cacheKey);
+            if (cached.hit) {
+              if (cached.isStale) refreshStaleTreeNode(node);
+              return;
+            }
+          }
+
+          const wantsOnlyTablesOrViews = objectTypes.every((objectType) => objectType === "TABLE" || objectType === "VIEW" || objectType === "MATERIALIZED_VIEW");
+          let children: TreeNode[];
+          let nextObjectCount: number;
+          if (wantsOnlyTablesOrViews) {
+            const page = await loadPagedTableGroupChildren({
+              node,
+              parentNodeId,
+              querySchema,
+              effectiveSchema,
+              objectTypes,
+              offset: 0,
+              pageSize: sidebarObjectGroupPageSize(),
+              searchFilter: searchFilter || undefined,
+              force: options?.force,
+            });
+            children = page.hasMore && !searchFilter ? appendTableTreeLoadMoreNode(page.children, buildLoadMoreNode(node, page.nextOffset, sidebarObjectGroupPageSize()), page.loadMoreParent) : page.children;
+            nextObjectCount = page.objectCount;
+          } else {
+            const pageSize = sidebarObjectGroupPageSize();
+            const page = await loadPagedObjectGroupChildren({
+              node,
+              parentNodeId,
+              querySchema,
+              effectiveSchema,
+              objectTypes,
+              offset: 0,
+              pageSize,
+              searchFilter: searchFilter || undefined,
+              force: options?.force,
+            });
+            children = page.hasMore && !searchFilter ? [...page.children, buildLoadMoreNode(node, page.nextOffset, pageSize)] : page.children;
+            nextObjectCount = page.objectCount;
+          }
+          if (isTreeLoadSearchChanged(searchFilter, options)) return;
+          if (!canApplyTreeMetadataResult(node)) return;
+          node.objectCount = nextObjectCount;
+          setChildren(node, children);
+          if (!searchFilter && !isSidebarTableSearch) {
+            await savePersistedTreeChildren(cacheKey, children);
+          }
+          node.isExpanded = true;
+        } catch (e) {
+          recordMetadataLoadError(node.connectionId, e);
+          throw e;
+        } finally {
+          node.isLoading = false;
+        }
+      },
+      options,
+    );
+  }
+
+  async function loadExtensions(connectionId: string, database: string, schema: string) {
+    const node = findNode(treeNodes.value, `${connectionId}:${database}:${schema}:__extensions`);
+    if (!node) return;
+    node.isLoading = true;
+    try {
+      await ensureConnected(connectionId);
+      if (useCachedChildren(node)) return;
+      const extensions = await withMetadataLoadTimeout(connectionId, api.listExtensions(connectionId, database, schema), "extensions");
+      const children: TreeNode[] = extensions.map((ext) => ({
+        id: `${node.id}:${ext.name}`,
+        label: ext.name,
+        type: "extension" as const,
+        connectionId,
+        database,
+        schema,
+        comment: ext.comment ?? null,
+        meta: ext,
+        isExpanded: false,
+      }));
+      setChildren(node, children);
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadMoreObjectGroupChildren(node: TreeNode) {
+    if (node.type !== "load-more" || !node.loadMore) return;
+    const loadMore = node.loadMore;
+    const parent = findNode(treeNodes.value, node.loadMore.parentId);
+    if (!parent?.connectionId || !hasTreeNodeDatabaseContext(parent)) return;
+    const parentConnectionId = parent.connectionId;
+    const configForScope = getConfig(parentConnectionId);
+    const objectTypesForScope = objectTypesForGroupNode(parent.type);
+    return runTreeMetadataLoad(
+      {
+        kind: "object-group-page",
+        connectionId: parentConnectionId,
+        database: parent.database,
+        schema: parent.schema,
+        nodeKind: parent.type,
+        objectTypes: objectTypesForScope,
+        limit: loadMore.pageSize + 1,
+        offset: loadMore.offset,
+        sidebarDisplayMode: useSettingsStore().editorSettings.sidebarObjectDisplay,
+        driverProfile: metadataDriverProfile(configForScope),
+      },
+      async () => {
+        node.isLoading = true;
+        try {
+          await ensureConnected(parentConnectionId);
+          if (parent.type === "database" || parent.type === "schema" || parent.type === "linked-server-schema") {
+            const parentDatabase = parent.database;
+            if (!parentDatabase) return;
+            const config = getConfig(parentConnectionId);
+            const querySchema = connectionObjectTreeQuerySchema(config, parentDatabase, parent.schema);
+            const effectiveSchema = connectionObjectTreeNodeSchema(config, parentDatabase, parent.schema);
+            const page = await loadPagedSimpleTableChildren({
+              nodeId: parent.schema ? `${parentConnectionId}:${parentDatabase}:${parent.schema}` : `${parentConnectionId}:${parentDatabase}`,
+              connectionId: parentConnectionId,
+              database: parentDatabase,
+              querySchema,
+              effectiveSchema,
+              nonTableObjectTypes: [],
+              offset: loadMore.offset,
+              pageSize: loadMore.pageSize,
+              force: false,
+            });
+            const currentChildren = withoutTableTreeLoadMoreNodes(parent.children);
+            const mergedChildren = mergeTableTreePageChildren(currentChildren, page.children, parentConnectionId, parentDatabase);
+            const nextChildren = page.hasMore ? appendTableTreeLoadMoreNode(mergedChildren, buildLoadMoreNode(parent, page.nextOffset, loadMore.pageSize), page.loadMoreParent) : mergedChildren;
+            if (!canApplyTreeMetadataResult(parent)) return;
+            parent.objectCount = mergedChildren.length;
+            setChildren(parent, nextChildren);
+            await savePersistedTreeChildren(schemaCacheKey(parentConnectionId, parentDatabase, parent.schema || "", "objects-simple-v3"), nextChildren);
+            parent.isExpanded = true;
+            return;
+          }
+          const objectTypes = objectTypesForGroupNode(parent.type);
+          const parentNodeId = objectGroupRefreshParentId(parent);
+          if (!objectTypes || !parentNodeId) return;
+
+          const config = getConfig(parentConnectionId);
+          const parentDatabase = parent.database;
+          if (!parentDatabase) return;
+          const querySchema = connectionObjectTreeQuerySchema(config, parentDatabase, parent.schema);
+          const effectiveSchema = connectionObjectTreeNodeSchema(config, parentDatabase, parent.schema);
+          const wantsOnlyTablesOrViews = objectTypes.every((objectType) => objectType === "TABLE" || objectType === "VIEW" || objectType === "MATERIALIZED_VIEW");
+          let mergedChildren: TreeNode[];
+          let nextChildren: TreeNode[];
+          if (wantsOnlyTablesOrViews) {
+            const page = await loadPagedTableGroupChildren({
+              node: parent,
+              parentNodeId,
+              querySchema,
+              effectiveSchema,
+              objectTypes,
+              offset: loadMore.offset,
+              pageSize: loadMore.pageSize,
+              force: false,
+            });
+            const currentChildren = withoutTableTreeLoadMoreNodes(parent.children);
+            mergedChildren = mergeTableTreePageChildren(currentChildren, page.children, parentConnectionId, parentDatabase);
+            nextChildren = page.hasMore ? appendTableTreeLoadMoreNode(mergedChildren, buildLoadMoreNode(parent, page.nextOffset, loadMore.pageSize), page.loadMoreParent) : mergedChildren;
+          } else {
+            const page = await loadPagedObjectGroupChildren({
+              node: parent,
+              parentNodeId,
+              querySchema,
+              effectiveSchema,
+              objectTypes,
+              offset: loadMore.offset,
+              pageSize: loadMore.pageSize,
+              force: false,
+            });
+            const currentChildren = withoutLoadMoreNodes(parent.children);
+            mergedChildren = mergeLocatedTreeChildren(parent, currentChildren, page.children, parentConnectionId, parentDatabase);
+            nextChildren = page.hasMore ? [...mergedChildren, buildLoadMoreNode(parent, page.nextOffset, loadMore.pageSize)] : mergedChildren;
+          }
+          if (!canApplyTreeMetadataResult(parent)) return;
+          parent.objectCount = mergedChildren.length;
+          setChildren(parent, nextChildren);
+          await savePersistedTreeChildren(objectGroupCacheKey(parent), nextChildren);
+          parent.isExpanded = true;
+        } catch (e) {
+          recordMetadataLoadError(parentConnectionId, e);
+          throw e;
+        } finally {
+          node.isLoading = false;
+        }
+      },
+    );
+  }
+
+  async function loadTableForLocate(target: LocateTableTarget): Promise<boolean> {
+    const config = getConfig(target.connectionId);
+    if (!config) return false;
+    return runTreeMetadataLoad(
+      {
+        kind: "locate-target",
+        connectionId: target.connectionId,
+        database: target.database,
+        schema: target.schema,
+        tableName: target.tableName,
+        searchFilter: target.tableName,
+        limit: sidebarObjectGroupPageSize() + 1,
+        offset: 0,
+        sidebarDisplayMode: useSettingsStore().editorSettings.sidebarObjectDisplay,
+        driverProfile: metadataDriverProfile(config),
+      },
+      async () => {
+        await ensureConnected(target.connectionId);
+
+        const querySchema = connectionObjectTreeQuerySchema(config, target.database, target.schema);
+        const effectiveSchema = connectionObjectTreeNodeSchema(config, target.database, target.schema);
+        const pageSize = sidebarObjectGroupPageSize();
+        const simpleObjectDisplay = useSettingsStore().editorSettings.sidebarObjectDisplay === "simple";
+        let loaded = false;
+
+        if (simpleObjectDisplay) {
+          const parentId = target.schema ? `${target.connectionId}:${target.database}:${target.schema}` : `${target.connectionId}:${target.database}`;
+          const parent = findNode(treeNodes.value, parentId);
+          if (!parent) return false;
+          const page = await loadPagedSimpleTableChildren({
+            nodeId: parentId,
+            connectionId: target.connectionId,
+            database: target.database,
+            querySchema,
+            effectiveSchema,
+            nonTableObjectTypes: [],
+            offset: 0,
+            pageSize,
+            searchFilter: target.tableName,
+            force: false,
+          });
+          if (!page.children.length) return false;
+          const currentChildren = withoutLoadMoreNodes(parent.children);
+          const loadMoreNodes = (parent.children || []).filter((child) => child.type === "load-more");
+          const mergedChildren = mergeLocatedTreeChildren(parent, currentChildren, page.children, target.connectionId, target.database);
+          if (!canApplyTreeMetadataResult(parent)) return false;
+          setChildren(parent, [...mergedChildren, ...loadMoreNodes]);
+          parent.objectCount = Math.max(parent.objectCount ?? currentChildren.length, mergedChildren.length);
+          parent.isExpanded = true;
+          return true;
+        }
+
+        const matchingGroups = findTreeNodes(treeNodes.value, (node) => {
+          return (node.type === "group-tables" || node.type === "group-views" || node.type === "group-materialized-views") && node.connectionId === target.connectionId && sameSidebarObjectName(node.database, target.database) && (!target.schema || sameSidebarObjectName(node.schema, target.schema));
+        });
+
+        for (const group of matchingGroups) {
+          const objectTypes = objectTypesForGroupNode(group.type);
+          const parentNodeId = objectGroupRefreshParentId(group);
+          if (!objectTypes || !parentNodeId) continue;
+
+          const page = await loadPagedTableGroupChildren({
+            node: group,
+            parentNodeId,
+            querySchema,
+            effectiveSchema,
+            objectTypes,
+            offset: 0,
+            pageSize,
+            searchFilter: target.tableName,
+            force: false,
+          });
+          if (!page.children.length) continue;
+
+          const currentChildren = withoutLoadMoreNodes(group.children);
+          const loadMoreNodes = (group.children || []).filter((child) => child.type === "load-more");
+          const mergedChildren = mergeLocatedTreeChildren(group, currentChildren, page.children, target.connectionId, target.database);
+          if (!canApplyTreeMetadataResult(group)) continue;
+          setChildren(group, [...mergedChildren, ...loadMoreNodes]);
+          group.objectCount = Math.max(group.objectCount ?? currentChildren.length, mergedChildren.length);
+          group.isExpanded = true;
+          loaded = true;
+        }
+
+        return loaded;
+      },
+    );
+  }
+
+  async function loadAllObjectGroupChildren(parent: TreeNode) {
+    if (!parent.connectionId || !hasTreeNodeDatabaseContext(parent)) return;
+    if (!objectTypesForGroupNode(parent.type)) return;
+    parent.isLoading = true;
+    try {
+      await ensureConnected(parent.connectionId);
+      if (!isTreeNodeChildrenLoaded(parent.id)) {
+        await loadObjectGroupChildren(parent);
+      }
+
+      let loadMoreNode = findTreeNodes(parent.children ?? [], (child) => child.type === "load-more")[0];
+      while (loadMoreNode?.loadMore) {
+        loadMoreNode.isLoading = true;
+        await loadMoreObjectGroupChildren(loadMoreNode);
+        loadMoreNode = findTreeNodes(parent.children ?? [], (child) => child.type === "load-more")[0];
+      }
+      parent.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(parent.connectionId, e);
+      throw e;
+    } finally {
+      parent.isLoading = false;
+    }
+  }
+
+  function setSidebarTableSearchQuery(parentNodeId: string, query: string) {
+    const normalized = query.trim();
+    const next = { ...sidebarTableSearchQueries.value };
+    if (normalized) {
+      next[parentNodeId] = query;
+    } else {
+      delete next[parentNodeId];
+    }
+    sidebarTableSearchQueries.value = next;
+  }
+
+  async function refreshSidebarTableSearch(parentNodeId: string) {
+    const parent = findNode(treeNodes.value, parentNodeId);
+    if (!parent?.connectionId || !hasTreeNodeDatabaseContext(parent)) return;
+
+    const searchFilter = sidebarTableSearchQueries.value[parentNodeId]?.trim() || "";
+    const options: LoadTreeOptions = {
+      force: true,
+      searchFilter: searchFilter || undefined,
+      sidebarTableSearchParentId: parentNodeId,
+      expectedSidebarTableSearchQuery: searchFilter,
+    };
+
+    if (parent.type === "group-tables") {
+      await loadObjectGroupChildren(parent, options);
+      return;
+    }
+
+    if (parent.type === "database" || parent.type === "schema" || parent.type === "linked-server-schema") {
+      await loadTables(parent.connectionId, parent.database, parent.schema, options);
+    }
+  }
+
+  function normalizedObjectTreeKind(type: string): DatabaseObjectTreeKind {
+    return normalizeSidebarObjectKind(type);
+  }
+
+  async function loadTableGroups(connectionId: string, database: string, table: string, schema?: string, nodeId?: string, catalog?: string) {
+    const parentId = nodeId ?? (schema ? `${connectionId}:${database}:${schema}:${table}` : `${connectionId}:${database}:${table}`);
+    const node = findNode(treeNodes.value, parentId);
+    if (!node) return;
+
+    const children: TreeNode[] = [
+      ...tablePartitionGroups(node),
+      {
+        id: `${parentId}:__columns`,
+        label: "tree.columns",
+        type: "group-columns",
+        connectionId,
+        database,
+        schema,
+        catalog,
+        tableName: table,
+        isExpanded: false,
+        children: [],
+      },
+    ];
+
+    const config = getConfig(connectionId);
+    const metadataCapabilities = getTableMetadataCapabilities(effectiveDatabaseTypeForConnection(config));
+    if ((node.type === "table" || node.type === "mongo-collection") && !parseSqlServerLinkedSchema(schema)) {
+      if (metadataCapabilities.indexes) {
+        children.push({
+          id: `${parentId}:__indexes`,
+          label: "tree.indexes",
+          type: "group-indexes",
+          connectionId,
+          database,
+          schema,
+          catalog,
+          tableName: table,
+          isExpanded: false,
+          children: [],
+        });
+      }
+    }
+    if (node.type === "table" && !parseSqlServerLinkedSchema(schema)) {
+      if (metadataCapabilities.foreignKeys) {
+        children.push({
+          id: `${parentId}:__fkeys`,
+          label: "tree.foreignKeys",
+          type: "group-fkeys",
+          connectionId,
+          database,
+          schema,
+          catalog,
+          tableName: table,
+          isExpanded: false,
+          children: [],
+        });
+      }
+      if (metadataCapabilities.triggers) {
+        children.push({
+          id: `${parentId}:__triggers`,
+          label: "tree.triggers",
+          type: "group-triggers",
+          connectionId,
+          database,
+          schema,
+          catalog,
+          tableName: table,
+          isExpanded: false,
+          children: [],
+        });
+      }
+    }
+
+    setChildren(node, children);
+    node.isExpanded = true;
+  }
+
+  async function loadColumns(connectionId: string, database: string, table: string, schema?: string, nodeId?: string, catalog?: string) {
+    const parentId = nodeId ?? (schema ? `${connectionId}:${database}:${schema}:${table}:__columns` : `${connectionId}:${database}:${table}:__columns`);
+    const node = findNode(treeNodes.value, parentId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      if (effectiveDatabaseTypeForConnection(getConfig(connectionId)) === "mongodb") {
+        const fields = await listMongoCompletionFields(connectionId, database, table);
+        setChildren(
+          node,
+          fields.map((field) => {
+            const column = {
+              name: field.name,
+              data_type: field.type || "unknown",
+              is_nullable: true,
+              column_default: null,
+              is_primary_key: field.name === "_id",
+              extra: "sampled",
+            };
+            return {
+              id: `${parentId}:${field.name}`,
+              label: `${field.name} (${column.data_type})`,
+              type: "column" as const,
+              connectionId,
+              database,
+              tableName: table,
+              meta: column,
+            };
+          }),
+        );
+        node.isExpanded = true;
+        return;
+      }
+      const querySchema = metadataQuerySchema(connectionId, database, schema);
+      const columns = await api.getColumns(connectionId, database, querySchema, table, catalog);
+      setChildren(
+        node,
+        columns.map((col) => ({
+          id: `${parentId}:${col.name}`,
+          label: `${col.name} (${col.data_type})`,
+          type: "column" as const,
+          connectionId,
+          database,
+          schema,
+          tableName: table,
+          meta: col,
+        })),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadIndexes(connectionId: string, database: string, table: string, schema?: string, nodeId?: string, catalog?: string) {
+    const parentId = nodeId ?? (schema ? `${connectionId}:${database}:${schema}:${table}:__indexes` : `${connectionId}:${database}:${table}:__indexes`);
+    const node = findNode(treeNodes.value, parentId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      const metadataCapabilities = getTableMetadataCapabilities(effectiveDatabaseTypeForConnection(getConfig(connectionId)));
+      if (!metadataCapabilities.indexes) {
+        setChildren(node, []);
+        node.isExpanded = true;
+        return;
+      }
+      const querySchema = metadataQuerySchema(connectionId, database, schema);
+      const indexes = await api.listIndexes(connectionId, database, querySchema, table, catalog);
+      setChildren(
+        node,
+        indexes.map((idx) => ({
+          id: `${parentId}:${idx.name}`,
+          label: `${idx.name} (${idx.columns.join(", ")})`,
+          type: "index" as const,
+          connectionId,
+          database,
+          schema,
+          tableName: table,
+          meta: idx,
+        })),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadForeignKeys(connectionId: string, database: string, table: string, schema?: string, nodeId?: string, catalog?: string) {
+    const parentId = nodeId ?? (schema ? `${connectionId}:${database}:${schema}:${table}:__fkeys` : `${connectionId}:${database}:${table}:__fkeys`);
+    const node = findNode(treeNodes.value, parentId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      const metadataCapabilities = getTableMetadataCapabilities(effectiveDatabaseTypeForConnection(getConfig(connectionId)));
+      if (!metadataCapabilities.foreignKeys) {
+        setChildren(node, []);
+        node.isExpanded = true;
+        return;
+      }
+      const querySchema = metadataQuerySchema(connectionId, database, schema);
+      const fkeys = await api.listForeignKeys(connectionId, database, querySchema, table, catalog);
+      const cacheKey = `${connectionId}:${database}:${schema || ""}:${table}`;
+      completionForeignKeysCache.value[cacheKey] = fkeys;
+      evictOldestCacheEntries(completionForeignKeysCache.value, COMPLETION_CACHE_MAX);
+      indexCompletionForeignKeys(connectionId, database, table, schema, sqlCompletionForeignKeys(fkeys));
+      setChildren(
+        node,
+        fkeys.map((fk) => ({
+          id: `${parentId}:${fk.name}`,
+          label: `${fk.column} → ${fk.ref_table}.${fk.ref_column}`,
+          type: "fkey" as const,
+          connectionId,
+          database,
+          schema,
+          tableName: table,
+          meta: fk,
+        })),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  async function loadTriggers(connectionId: string, database: string, table: string, schema?: string, nodeId?: string, catalog?: string) {
+    const parentId = nodeId ?? (schema ? `${connectionId}:${database}:${schema}:${table}:__triggers` : `${connectionId}:${database}:${table}:__triggers`);
+    const node = findNode(treeNodes.value, parentId);
+    if (!node) return;
+
+    node.isLoading = true;
+    try {
+      const metadataCapabilities = getTableMetadataCapabilities(effectiveDatabaseTypeForConnection(getConfig(connectionId)));
+      if (!metadataCapabilities.triggers) {
+        setChildren(node, []);
+        node.isExpanded = true;
+        return;
+      }
+      const querySchema = metadataQuerySchema(connectionId, database, schema);
+      const triggers = await api.listTriggers(connectionId, database, querySchema, table, catalog);
+      setChildren(
+        node,
+        triggers.map((tr) => ({
+          id: `${parentId}:${tr.name}`,
+          label: `${tr.name} (${tr.timing} ${tr.event})`,
+          type: "trigger" as const,
+          connectionId,
+          database,
+          schema,
+          tableName: table,
+          meta: tr,
+        })),
+      );
+      node.isExpanded = true;
+    } catch (e) {
+      recordMetadataLoadError(connectionId, e);
+      throw e;
+    } finally {
+      node.isLoading = false;
+    }
+  }
+
+  function collectExpandedNodeIds(nodes: TreeNode[], ids = new Set<string>()): Set<string> {
+    for (const node of nodes) {
+      if (node.isExpanded) ids.add(node.id);
+      if (node.children) collectExpandedNodeIds(node.children, ids);
+    }
+    return ids;
+  }
+
+  async function loadTreeNodeChildren(node: TreeNode, options?: LoadTreeOptions) {
+    if (node.type === "connection" && node.connectionId) {
+      const config = getConfig(node.connectionId);
+      if (config?.db_type === "redis") {
+        await loadRedisDatabases(node.connectionId);
+      } else if (config?.db_type === "etcd") {
+        await loadEtcdRoot(node.connectionId);
+      } else if (config?.db_type === "zookeeper") {
+        await loadZooKeeperRoot(node.connectionId);
+      } else if (config?.db_type === "mongodb") {
+        await loadMongoDatabases(node.connectionId);
+      } else if (config?.db_type === "elasticsearch") {
+        await loadElasticsearchIndices(node.connectionId);
+      } else if (config?.db_type === "milvus") {
+        await loadMilvusDatabases(node.connectionId);
+      } else if (config?.db_type === "qdrant" || config?.db_type === "weaviate" || config?.db_type === "chromadb") {
+        await loadVectorCollections(node.connectionId);
+      } else if (config?.db_type === "mq") {
+        await loadMqTenants(node.connectionId, options);
+      } else if (config?.db_type === "nacos") {
+        await loadNacosNamespaces(node.connectionId, options);
+      } else {
+        await loadDatabases(node.connectionId, options);
+      }
+    } else if (node.type === "mongo-db" && node.connectionId && node.database) {
+      await loadMongoCollections(node.connectionId, node.database);
+    } else if (node.type === "vector-database" && node.connectionId && node.database) {
+      await loadVectorCollections(node.connectionId, node.database);
+    } else if (node.type === "mongo-collection" && node.connectionId && node.database) {
+      await loadTableGroups(node.connectionId, node.database, node.label, node.schema, node.id);
+    } else if (node.type === "mongo-gridfs") {
+      node.isExpanded = true;
+    } else if (node.type === "doris-catalog" && node.connectionId) {
+      await loadDorisCatalogDatabases(node, options);
+    } else if (node.type === "database" && node.connectionId && hasTreeNodeDatabaseContext(node)) {
+      if (node.catalog && node.catalog !== "internal") {
+        await loadDorisCatalogTables(node, options);
+      } else {
+        const config = getConfig(node.connectionId);
+        const effectiveDbType = effectiveDatabaseTypeForConnection(config);
+        if (config?.db_type === "sqlserver") {
+          await loadSqlServerDatabaseObjects(node.connectionId, node.database, options);
+        } else if (usesTreeSchemaMode(effectiveDbType) && !connectionUsesDatabaseObjectTreeMode(config)) {
+          await loadSchemas(node.connectionId, node.database, options);
+        } else {
+          await loadTables(node.connectionId, node.database, undefined, options);
+        }
+      }
+    } else if (node.type === "schema" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.schema) {
+      await loadTables(node.connectionId, node.database, node.schema, options);
+    } else if (node.type === "linked-server-root" && node.connectionId) {
+      await loadSqlServerLinkedServers(node.connectionId, options);
+    } else if (node.type === "linked-server" && node.connectionId) {
+      await loadSqlServerLinkedServerCatalogs(node, options);
+    } else if (node.type === "linked-server-catalog" && node.connectionId) {
+      await loadSqlServerLinkedServerSchemas(node, options);
+    } else if (node.type === "linked-server-schema" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.schema) {
+      await loadTables(node.connectionId, node.database, node.schema, options);
+    } else if ((node.type === "table" || node.type === "view" || node.type === "materialized_view") && node.connectionId && hasTreeNodeDatabaseContext(node)) {
+      await loadTableGroups(node.connectionId, node.database, node.label, node.schema, node.id, node.catalog);
+    } else if (node.type === "group-columns" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.tableName) {
+      await loadColumns(node.connectionId, node.database, node.tableName, node.schema, node.id, node.catalog);
+    } else if (node.type === "group-indexes" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.tableName) {
+      await loadIndexes(node.connectionId, node.database, node.tableName, node.schema, node.id, node.catalog);
+    } else if (node.type === "group-fkeys" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.tableName) {
+      await loadForeignKeys(node.connectionId, node.database, node.tableName, node.schema, node.id, node.catalog);
+    } else if (node.type === "group-triggers" && node.connectionId && hasTreeNodeDatabaseContext(node) && node.tableName) {
+      await loadTriggers(node.connectionId, node.database, node.tableName, node.schema, node.id, node.catalog);
+    } else if (node.type === "group-tables" || node.type === "group-views" || node.type === "group-materialized-views" || node.type === "group-procedures" || node.type === "group-functions" || node.type === "group-sequences" || node.type === "group-packages") {
+      await loadObjectGroupChildren(node, options);
+    } else if (node.type === "group-partitions") {
+      node.isExpanded = true;
+    } else if (node.type === "group-extensions" && node.connectionId && hasTreeNodeDatabaseContext(node)) {
+      await loadExtensions(node.connectionId, node.database || "", node.schema || "");
+    }
+  }
+
+  async function restoreExpandedChildren(node: TreeNode, expandedIds: Set<string>, options?: LoadTreeOptions) {
+    if (!node.children) return;
+    for (const child of node.children) {
+      if (!expandedIds.has(child.id)) continue;
+      await loadTreeNodeChildren(child, options);
+      await restoreExpandedChildren(child, expandedIds, options);
+    }
+  }
+
+  async function refreshTreeNode(node: TreeNode) {
+    invalidateMetadataCachesForNode(node);
+    if (objectTypesForGroupNode(node.type)) {
+      clearLoadedChildrenCache(node.id);
+      await loadObjectGroupChildren(node, { force: true });
+      return;
+    }
+
+    const parentId = objectGroupRefreshParentId(node);
+    const parentNode = parentId ? findNode(treeNodes.value, parentId) : null;
+    if (parentNode) {
+      await refreshTreeNode(parentNode);
+      return;
+    }
+
+    if (node.connectionId && !connectedIds.value.has(node.connectionId)) return;
+    const expandedIds = collectExpandedNodeIds([node]);
+    expandedIds.add(node.id);
+    await clearPersistedTreeCacheForNode(node);
+    clearLoadedChildrenCache(node.id);
+    if (node.type !== "connection-group") {
+      node.children = [];
+    }
+    await loadTreeNodeChildren(node, { force: true });
+    await restoreExpandedChildren(node, expandedIds, { force: true });
+  }
+
+  async function refreshDatabaseTreeNode(connectionId: string, database: string) {
+    const node = findDatabaseTreeNode(treeNodes.value, connectionId, database);
+    if (node) {
+      await refreshTreeNode(node);
+      return;
+    }
+    await loadDatabases(connectionId, { force: true });
+  }
+
+  async function refreshObjectListTreeNode(connectionId: string, database: string, schema?: string) {
+    invalidateMetadataCaches({ connectionId, database, schema });
+    const shouldRefreshSchemaNode = !!schema;
+    const node = shouldRefreshSchemaNode ? findNode(treeNodes.value, `${connectionId}:${database}:${schema}`) : null;
+    if (node) {
+      await refreshTreeNode(node);
+      return;
+    }
+    await refreshDatabaseTreeNode(connectionId, database);
+  }
+
+  function isSchemaAwareDatabase(connectionId: string): boolean {
+    return isSchemaAware(getConfig(connectionId)?.db_type);
+  }
+
+  function isPostgresLikeForExtensions(dbType?: string): boolean {
+    return dbType === "postgres" || dbType === "gaussdb" || dbType === "kwdb" || dbType === "opengauss" || dbType === "highgo" || dbType === "vastbase" || dbType === "kingbase";
+  }
+
+  function metadataQuerySchema(connectionId: string, database: string, schema?: string): string {
+    return connectionObjectTreeQuerySchema(getConfig(connectionId), database, schema);
+  }
+
+  const COMPLETION_CACHE_MAX = 50;
+
+  function evictOldestCacheEntries(cache: Record<string, unknown>, max: number) {
+    const keys = Object.keys(cache);
+    if (keys.length <= max) return;
+    const toRemove = keys.slice(0, keys.length - max);
+    for (const key of toRemove) {
+      delete cache[key];
+    }
+  }
+
+  function completionScopeKey(connectionId: string, database: string, schema?: string): string {
+    return `${connectionId}:${database}:${schema ?? ""}`;
+  }
+
+  function completionColumnsKey(connectionId: string, database: string, table: string, schema?: string): string {
+    return `${completionScopeKey(connectionId, database, schema)}:${table.toLowerCase()}`;
+  }
+
+  function completionForeignKeysKey(connectionId: string, database: string, table: string, schema?: string): string {
+    return `${completionScopeKey(connectionId, database, schema)}:${table.toLowerCase()}:fkeys`;
+  }
+
+  function touchCompletionIndex<T>(index: Map<string, { touched: number } & T>, key: string, value: T, max = COMPLETION_CACHE_MAX) {
+    index.set(key, { ...value, touched: Date.now() });
+    if (index.size <= max) return;
+    const oldest = [...index.entries()].sort(([, a], [, b]) => a.touched - b.touched).slice(0, index.size - max);
+    for (const [oldKey] of oldest) index.delete(oldKey);
+  }
+
+  function completionLimiterScope(connectionId: string, database = ""): string {
+    return `${connectionId}:${database}`;
+  }
+
+  function withCompletionInFlight<T>(key: string, load: () => Promise<T>, limit?: { scope: string; kind: string }): Promise<T> {
+    const existing = completionInFlight.get(key) as Promise<T> | undefined;
+    if (existing) return existing;
+    const promise = (limit ? completionMetadataLimiter.run(limit.scope, limit.kind, load) : load()).finally(() => {
+      if (completionInFlight.get(key) === promise) completionInFlight.delete(key);
+    });
+    completionInFlight.set(key, promise);
+    return promise;
+  }
+
+  function completionAssistantRequestKey(request: CompletionAssistantRequest): string {
+    return JSON.stringify({
+      connection_id: request.connection_id,
+      database: request.database,
+      schema: request.schema ?? "",
+      object_kinds: [...(request.object_kinds ?? [])].sort(),
+      mask: request.mask ?? "",
+      case_sensitive: !!request.case_sensitive,
+      global_search: !!request.global_search,
+      max_results: request.max_results ?? null,
+      search_in_comments: !!request.search_in_comments,
+      search_in_definitions: !!request.search_in_definitions,
+      parent_schema: request.parent_schema ?? "",
+      parent_name: request.parent_name ?? "",
+      match_mode: request.match_mode ?? "prefix",
+    });
+  }
+
+  async function completionAssistantSearch(request: CompletionAssistantRequest) {
+    return withCompletionInFlight(`assistant:${completionAssistantRequestKey(request)}`, async () => {
+      await ensureConnected(request.connection_id);
+      return api.completionAssistantSearch(request);
+    });
+  }
+
+  function completionAssistantTables(candidates: CompletionAssistantCandidate[]): SqlCompletionTable[] {
+    return candidates
+      .filter((candidate) => candidate.kind === "table" || candidate.kind === "view")
+      .map((candidate) => ({
+        name: candidate.name,
+        schema: candidate.schema ?? undefined,
+        type: candidate.kind === "view" ? ("view" as const) : ("table" as const),
+      }));
+  }
+
+  function completionAssistantColumns(candidates: CompletionAssistantCandidate[], table: string, schema?: string): SqlCompletionColumn[] {
+    return candidates
+      .filter((candidate) => candidate.kind === "column")
+      .map((candidate) => ({
+        name: candidate.name,
+        table: candidate.parent_name ?? table,
+        schema: candidate.parent_schema ?? candidate.schema ?? schema,
+        dataType: candidate.data_type ?? undefined,
+        comment: candidate.comment ?? null,
+      }));
+  }
+
+  async function listCompletionAssistantTables(connectionId: string, database: string, filter: string, limit?: number, schema?: string): Promise<SqlCompletionTable[]> {
+    const objectKinds: CompletionAssistantObjectKind[] = ["table", "view"];
+    const response = await completionAssistantSearch({
+      connection_id: connectionId,
+      database,
+      schema: schema ?? null,
+      object_kinds: objectKinds,
+      mask: filter.trim(),
+      max_results: limit ?? 200,
+      parent_schema: schema ?? null,
+      match_mode: "prefix",
+    });
+    const tables = completionAssistantTables(response.candidates);
+    indexCompletionTables(connectionId, database, schema, tables);
+    return tables;
+  }
+
+  async function listCompletionAssistantColumns(connectionId: string, database: string, table: string, schema?: string): Promise<SqlCompletionColumn[]> {
+    const response = await completionAssistantSearch({
+      connection_id: connectionId,
+      database,
+      schema: schema ?? null,
+      object_kinds: ["column"],
+      mask: "",
+      max_results: 500,
+      parent_schema: schema ?? null,
+      parent_name: table,
+      match_mode: "prefix",
+    });
+    const columns = completionAssistantColumns(response.candidates, table, schema);
+    if (columns.length > 0) indexCompletionColumns(connectionId, database, table, schema, columns);
+    return columns;
+  }
+
+  function completionNameSegments(name: string): string[] {
+    return name
+      .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+      .split(/[\s_.:-]+/)
+      .map((segment) => segment.trim().toLowerCase())
+      .filter(Boolean);
+  }
+
+  function completionNameAcronym(name: string): string {
+    return completionNameSegments(name)
+      .map((segment) => segment[0])
+      .join("");
+  }
+
+  function orderedSubsequenceScore(text: string, filter: string): number {
+    let index = 0;
+    let gaps = 0;
+    for (const ch of filter) {
+      const found = text.indexOf(ch, index);
+      if (found < 0) return -1;
+      gaps += found - index;
+      index = found + 1;
+    }
+    return 1_000 - gaps - text.length;
+  }
+
+  function tableMatchScore(table: SqlCompletionTable, filter: string, preferredSchema?: string): number {
+    const text = table.name.toLowerCase();
+    const schema = table.schema?.toLowerCase();
+    const normalized = filter.trim().toLowerCase();
+    let score = schema && preferredSchema && schema === preferredSchema.toLowerCase() ? 10_000 : 0;
+    if (!normalized) return score;
+    if (text === normalized) return score + 9_000 - text.length;
+    if (text.startsWith(normalized)) return score + 7_500 - text.length;
+    const segments = completionNameSegments(table.name);
+    if (segments.some((segment) => segment.startsWith(normalized))) return score + 7_200 - text.length;
+    const acronym = completionNameAcronym(table.name);
+    if (acronym === normalized) return score + 7_100 - text.length;
+    if (acronym.startsWith(normalized)) return score + 6_900 - text.length;
+    if (normalized.length <= segments.length && segments.every((segment, index) => segment.startsWith(normalized[index] ?? ""))) return score + 6_700 - text.length;
+    if (text.includes(normalized)) return score + 4_000 - text.length;
+    const subsequenceScore = orderedSubsequenceScore(text, normalized);
+    return subsequenceScore < 0 ? -1 : score + subsequenceScore;
+  }
+
+  function objectMatchScore(object: SqlCompletionObject, filter: string, preferredSchema?: string): number {
+    const tableLike: SqlCompletionTable = { name: object.name, schema: object.schema };
+    return tableMatchScore(tableLike, filter, preferredSchema);
+  }
+
+  function indexCompletionTables(connectionId: string, database: string, schema: string | undefined, tables: SqlCompletionTable[]) {
+    const groups = new Map<string, SqlCompletionTable[]>();
+    for (const table of tables) {
+      const tableSchema = table.schema ?? schema;
+      const key = completionScopeKey(connectionId, database, tableSchema);
+      const list = groups.get(key) ?? [];
+      list.push({ ...table, schema: tableSchema });
+      groups.set(key, list);
+    }
+    for (const [key, group] of groups) {
+      const previous = completionTableIndex.get(key)?.tables ?? [];
+      touchCompletionIndex(completionTableIndex, key, {
+        tables: dedupeCompletionTables([...previous, ...group]),
+      });
+    }
+  }
+
+  function indexCompletionObjects(connectionId: string, database: string, schema: string | undefined, objects: SqlCompletionObject[]) {
+    const groups = new Map<string, SqlCompletionObject[]>();
+    for (const object of objects) {
+      const objectSchema = object.schema ?? schema;
+      const key = completionScopeKey(connectionId, database, objectSchema);
+      const list = groups.get(key) ?? [];
+      list.push({ ...object, schema: objectSchema });
+      groups.set(key, list);
+    }
+    for (const [key, group] of groups) {
+      const previous = completionObjectIndex.get(key)?.objects ?? [];
+      touchCompletionIndex(completionObjectIndex, key, {
+        objects: dedupeCompletionObjects([...previous, ...group]),
+      });
+    }
+  }
+
+  function indexCompletionColumns(connectionId: string, database: string, table: string, schema: string | undefined, columns: SqlCompletionColumn[]) {
+    touchCompletionIndex(completionColumnIndex, completionColumnsKey(connectionId, database, table, schema), {
+      columns,
+    });
+  }
+
+  function sqlCompletionForeignKeys(foreignKeys: ForeignKeyInfo[]): SqlCompletionForeignKey[] {
+    return foreignKeys.map((foreignKey) => ({
+      name: foreignKey.name,
+      column: foreignKey.column,
+      ref_schema: foreignKey.ref_schema,
+      ref_table: foreignKey.ref_table,
+      ref_column: foreignKey.ref_column,
+    }));
+  }
+
+  function indexCompletionForeignKeys(connectionId: string, database: string, table: string, schema: string | undefined, foreignKeys: SqlCompletionForeignKey[]) {
+    touchCompletionIndex(completionForeignKeyIndex, completionForeignKeysKey(connectionId, database, table, schema), {
+      foreignKeys,
+    });
+  }
+
+  function lookupLocalCompletionTables(connectionId: string, database: string, filter = "", limit?: number, schema?: string): SqlCompletionTable[] {
+    const allScopes = [...completionTableIndex.entries()].filter(([key]) => key.startsWith(`${connectionId}:${database}:`)).map(([, entry]) => entry);
+    const preferred = schema ? completionTableIndex.get(completionScopeKey(connectionId, database, schema)) : undefined;
+    const scopes = schema ? (preferred ? [preferred] : []) : allScopes;
+    const treeTables = completionTablesFromTree(treeNodes.value, connectionId, database, schema);
+    const ranked = scopes
+      .flatMap((entry) => entry?.tables ?? [])
+      .concat(treeTables)
+      .map((table) => ({ table, score: tableMatchScore(table, filter, schema) }))
+      .filter((entry) => entry.score >= 0)
+      .sort((a, b) => b.score - a.score || a.table.name.localeCompare(b.table.name));
+    return dedupeCompletionTables(ranked.map((entry) => entry.table)).slice(0, limit ?? 200);
+  }
+
+  function lookupLocalCompletionObjects(connectionId: string, database: string, filter = "", limit?: number, schema?: string): SqlCompletionObject[] {
+    const allScopes = [...completionObjectIndex.entries()].filter(([key]) => key.startsWith(`${connectionId}:${database}:`)).map(([, entry]) => entry);
+    const preferred = schema ? completionObjectIndex.get(completionScopeKey(connectionId, database, schema)) : undefined;
+    const scopes = schema ? (preferred ? [preferred] : []) : allScopes;
+    const ranked = scopes
+      .flatMap((entry) => entry?.objects ?? [])
+      .map((object) => ({ object, score: objectMatchScore(object, filter, schema) }))
+      .filter((entry) => entry.score >= 0)
+      .sort((a, b) => b.score - a.score || a.object.name.localeCompare(b.object.name));
+    return dedupeCompletionObjects(ranked.map((entry) => entry.object)).slice(0, limit ?? 200);
+  }
+
+  function lookupLocalCompletionSchemas(connectionId: string, database: string, filter = "", limit = 50): string[] {
+    const schemas = dedupeCompletionQualifierNames([...(schemaListCache.value[`${connectionId}:${database}`] ?? []), ...completionSchemasFromTree(treeNodes.value, connectionId, database)]);
+    const normalized = filter.trim().toLowerCase();
+    return schemas
+      .filter((schema) => fuzzyTextMatch(schema, normalized))
+      .sort((a, b) => tableMatchScore({ name: b }, normalized) - tableMatchScore({ name: a }, normalized))
+      .slice(0, limit);
+  }
+
+  function lookupLocalCompletionDatabases(connectionId: string, filter = "", limit = 50): string[] {
+    const databases = completionDatabasesCache.value[connectionId] ?? databaseNamesFromTree(connectionId);
+    const normalized = filter.trim().toLowerCase();
+    return databases
+      .filter((database) => fuzzyTextMatch(database, normalized))
+      .sort((a, b) => tableMatchScore({ name: b }, normalized) - tableMatchScore({ name: a }, normalized))
+      .slice(0, limit);
+  }
+
+  function dedupeCompletionQualifierNames(names: string[]): string[] {
+    const seen = new Set<string>();
+    const result: string[] = [];
+    for (const name of names) {
+      const normalized = name.trim();
+      if (!normalized) continue;
+      const key = normalized.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      result.push(normalized);
+    }
+    return result;
+  }
+
+  function lookupLocalCompletionColumns(connectionId: string, database: string, table: string, schema?: string): SqlCompletionColumn[] {
+    return completionColumnIndex.get(completionColumnsKey(connectionId, database, table, schema))?.columns ?? [];
+  }
+
+  function lookupLocalCompletionForeignKeys(connectionId: string, database: string, table: string, schema?: string): SqlCompletionForeignKey[] {
+    return completionForeignKeyIndex.get(completionForeignKeysKey(connectionId, database, table, schema))?.foreignKeys ?? [];
+  }
+
+  function databaseNamesFromTree(connectionId: string): string[] {
+    const node = findNode(treeNodes.value, connectionId);
+    if (!node?.children) return [];
+    const seen = new Set<string>();
+    const names: string[] = [];
+    for (const child of node.children) {
+      if (child.type !== "database" || !child.database) continue;
+      const key = child.database.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      names.push(child.database);
+    }
+    return names;
+  }
+
+  async function listCompletionDatabases(connectionId: string): Promise<string[]> {
+    if (completionDatabasesCache.value[connectionId]) {
+      return completionDatabasesCache.value[connectionId];
+    }
+    return withCompletionInFlight(
+      `${connectionId}:completion-databases`,
+      async () => {
+        await ensureConnected(connectionId);
+        const config = getConfig(connectionId);
+        const databases = await api.listDatabases(connectionId);
+        completionDatabasesCache.value[connectionId] = filterDatabaseNamesForConnection(
+          databases.map((database) => database.name),
+          config,
+        );
+        evictOldestCacheEntries(completionDatabasesCache.value, COMPLETION_CACHE_MAX);
+        return completionDatabasesCache.value[connectionId];
+      },
+      { scope: completionLimiterScope(connectionId), kind: "databases" },
+    );
+  }
+
+  async function listCompletionSchemas(connectionId: string, database: string): Promise<string[]> {
+    const cacheKey = `${connectionId}:${database}`;
+    if (schemaListCache.value[cacheKey]) {
+      return schemaListCache.value[cacheKey];
+    }
+    return withCompletionInFlight(`${cacheKey}:schemas`, async () => {
+      const schemas = await api.listSchemas(connectionId, database);
+      schemaListCache.value[cacheKey] = schemas;
+      evictOldestCacheEntries(schemaListCache.value, COMPLETION_CACHE_MAX);
+      return schemas;
+    });
+  }
+
+  async function listElasticsearchCompletionIndices(connectionId: string, database: string): Promise<string[]> {
+    const cacheKey = `${connectionId}:${database}`;
+    if (elasticsearchCompletionIndicesCache.value[cacheKey]) {
+      return elasticsearchCompletionIndicesCache.value[cacheKey];
+    }
+    await ensureConnected(connectionId);
+    const indices = await api.elasticsearchListIndices(connectionId);
+    elasticsearchCompletionIndicesCache.value[cacheKey] = indices;
+    evictOldestCacheEntries(elasticsearchCompletionIndicesCache.value, COMPLETION_CACHE_MAX);
+    return elasticsearchCompletionIndicesCache.value[cacheKey];
+  }
+
+  // Upper bound on cached key names per db, to keep completion memory bounded
+  // (Redis can hold far more keys than we ever want resident for autocomplete).
+  const REDIS_COMPLETION_KEYS_MAX = 1000;
+
+  async function listRedisCompletionKeys(connectionId: string, database: string): Promise<string[]> {
+    if (!database) return [];
+    const cacheKey = `${connectionId}:${database}`;
+    const cached = redisCompletionKeysCache.value[cacheKey];
+    if (cached) return cached;
+    return withCompletionInFlight(`${cacheKey}:redis-keys`, async () => {
+      await ensureConnected(connectionId);
+      const pageSize = getConfig(connectionId)?.redis_scan_page_size ?? REDIS_SCAN_PAGE_SIZE_DEFAULT;
+      // Bounded multi-round SCAN: trade coverage for latency/memory safety.
+      const result = await api.redisScanKeysBatch(connectionId, Number(database), 0, "*", pageSize, 6, false);
+      const keys = result.keys.map((key) => key.key_display).slice(0, REDIS_COMPLETION_KEYS_MAX);
+      redisCompletionKeysCache.value[cacheKey] = keys;
+      evictOldestCacheEntries(redisCompletionKeysCache.value, COMPLETION_CACHE_MAX);
+      return keys;
+    });
+  }
+
+  async function listMongoCompletionCollections(connectionId: string, database: string): Promise<string[]> {
+    if (!database) return [];
+    const cacheKey = `${connectionId}:${database}`;
+    const cached = mongoCompletionCollectionsCache.value[cacheKey];
+    if (cached) return cached;
+    return withCompletionInFlight(`${cacheKey}:mongo-collections`, async () => {
+      await ensureConnected(connectionId);
+      const collections = sortSidebarNames((await api.mongoListCollections(connectionId, database)).map((c) => c.name));
+      mongoCompletionCollectionsCache.value[cacheKey] = collections;
+      evictOldestCacheEntries(mongoCompletionCollectionsCache.value, COMPLETION_CACHE_MAX);
+      return collections;
+    });
+  }
+
+  async function listMongoCompletionFields(connectionId: string, database: string, collection: string): Promise<MongoCompletionField[]> {
+    if (!database || !collection) return [];
+    const cacheKey = `${connectionId}:${database}:${collection}`;
+    const cached = mongoCompletionFieldsCache.value[cacheKey];
+    if (cached) return cached;
+    return withCompletionInFlight(`${cacheKey}:mongo-fields`, async () => {
+      await ensureConnected(connectionId);
+      const result = await api.mongoFindDocuments(connectionId, database, collection, 0, 20, "{}");
+      const fields = inferMongoCompletionFields(result.documents ?? []);
+      mongoCompletionFieldsCache.value[cacheKey] = fields;
+      evictOldestCacheEntries(mongoCompletionFieldsCache.value, COMPLETION_CACHE_MAX);
+      return fields;
+    });
+  }
+
+  async function listCompletionTables(connectionId: string, database: string, filter = "", limit?: number, schema?: string): Promise<SqlCompletionTable[]> {
+    const trimmedFilter = filter.trim();
+    const normalizedFilter = trimmedFilter.toLowerCase();
+    // Remote queries (Dameng/Oracle) are case-sensitive, so the cache key must
+    // preserve original casing — otherwise "TEST" and "test" collide and the
+    // second lookup returns the first's stale results. Local lookups below stay
+    // case-insensitive because tableMatchScore normalizes internally.
+    const relaxedFilter = relaxedCompletionTableFilter(trimmedFilter);
+    const cacheKey = `${connectionId}:${database}:${trimmedFilter}:${limit ?? ""}:${schema ?? ""}`;
+    if (completionTablesCache.value[cacheKey]) {
+      return completionTablesCache.value[cacheKey];
+    }
+
+    return withCompletionInFlight(
+      `${cacheKey}:tables`,
+      async () => {
+        await ensureConnected(connectionId);
+
+        if (isSchemaAwareDatabase(connectionId)) {
+          if (normalizedFilter || limit) {
+            let results: SqlCompletionTable[] = [];
+            try {
+              results = await listCompletionAssistantTables(connectionId, database, trimmedFilter, limit, schema);
+            } catch {
+              if (schema) {
+                const tables = await api.listTables(connectionId, database, schema, trimmedFilter, limit);
+                results = tables.map((table) => ({
+                  name: table.name,
+                  schema,
+                  type: isViewLikeTableType(table.table_type) ? ("view" as const) : ("table" as const),
+                }));
+              } else {
+                results = lookupLocalCompletionTables(connectionId, database, normalizedFilter, limit);
+              }
+            }
+            if (results.length === 0 && relaxedFilter) {
+              if (schema) {
+                try {
+                  const tables = await api.listTables(connectionId, database, schema, relaxedFilter, expandedCompletionLimit(limit));
+                  results = tables.map((table) => ({
+                    name: table.name,
+                    schema,
+                    type: isViewLikeTableType(table.table_type) ? ("view" as const) : ("table" as const),
+                  }));
+                } catch {
+                  results = [];
+                }
+              } else {
+                results = lookupLocalCompletionTables(connectionId, database, relaxedFilter, expandedCompletionLimit(limit));
+              }
+            }
+            const limitedTables = limit ? dedupeCompletionTables(results).slice(0, limit) : results;
+            completionTablesCache.value[cacheKey] = limitedTables;
+            indexCompletionTables(connectionId, database, undefined, limitedTables);
+            evictOldestCacheEntries(completionTablesCache.value, COMPLETION_CACHE_MAX);
+            return completionTablesCache.value[cacheKey];
+          }
+
+          if (schema) {
+            const tables = await api.listTables(connectionId, database, schema);
+            completionTablesCache.value[cacheKey] = tables.map((table) => ({
+              name: table.name,
+              schema,
+              type: isViewLikeTableType(table.table_type) ? ("view" as const) : ("table" as const),
+            }));
+          } else {
+            completionTablesCache.value[cacheKey] = lookupLocalCompletionTables(connectionId, database, normalizedFilter, limit);
+          }
+          indexCompletionTables(connectionId, database, undefined, completionTablesCache.value[cacheKey]);
+          evictOldestCacheEntries(completionTablesCache.value, COMPLETION_CACHE_MAX);
+          return completionTablesCache.value[cacheKey];
+        }
+
+        let tables = await api.listTables(connectionId, database, database, trimmedFilter, limit);
+        if (tables.length === 0 && relaxedFilter) {
+          tables = await api.listTables(connectionId, database, database, relaxedFilter, expandedCompletionLimit(limit));
+        }
+        completionTablesCache.value[cacheKey] = tables.map((table) => ({
+          name: table.name,
+          type: isViewLikeTableType(table.table_type) ? ("view" as const) : ("table" as const),
+        }));
+        completionTablesCache.value[cacheKey] = limit ? completionTablesCache.value[cacheKey].slice(0, limit) : completionTablesCache.value[cacheKey];
+        indexCompletionTables(connectionId, database, schema, completionTablesCache.value[cacheKey]);
+        evictOldestCacheEntries(completionTablesCache.value, COMPLETION_CACHE_MAX);
+        return completionTablesCache.value[cacheKey];
+      },
+      { scope: completionLimiterScope(connectionId, database), kind: "tables" },
+    );
+  }
+
+  function relaxedCompletionTableFilter(filter: string): string | undefined {
+    if (filter.length < 3) return undefined;
+    return filter.slice(0, 2);
+  }
+
+  function expandedCompletionLimit(limit?: number): number | undefined {
+    if (!limit) return limit;
+    return Math.min(Math.max(limit * 3, limit), 1000);
+  }
+
+  function dedupeCompletionTables(tables: SqlCompletionTable[]): SqlCompletionTable[] {
+    const seen = new Set<string>();
+    const deduped: SqlCompletionTable[] = [];
+    for (const table of tables) {
+      const key = `${table.schema ?? ""}.${table.name}`.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      deduped.push(table);
+    }
+    return deduped;
+  }
+
+  async function listCompletionObjects(connectionId: string, database: string, filter = "", limit?: number, schema?: string): Promise<SqlCompletionObject[]> {
+    const normalizedFilter = filter.trim().toLowerCase();
+    const cacheKey = `${connectionId}:${database}:${schema ?? ""}`;
+    if (!completionObjectsCache.value[cacheKey]) {
+      await withCompletionInFlight(
+        `${cacheKey}:objects`,
+        async () => {
+          await ensureConnected(connectionId);
+          const objects = isSchemaAwareDatabase(connectionId) ? await listSchemaAwareCompletionObjects(connectionId, database, schema) : await api.listCompletionObjects(connectionId, database, schema || database);
+          completionObjectsCache.value[cacheKey] = dedupeCompletionObjects(objects.map(toSqlCompletionObject).filter((object): object is SqlCompletionObject => object != null));
+          indexCompletionObjects(connectionId, database, schema, completionObjectsCache.value[cacheKey]);
+          evictOldestCacheEntries(completionObjectsCache.value, COMPLETION_CACHE_MAX);
+        },
+        { scope: completionLimiterScope(connectionId, database), kind: "objects" },
+      );
+    }
+
+    const objects = completionObjectsCache.value[cacheKey];
+    const filtered = normalizedFilter ? objects.filter((object) => fuzzyCompletionObjectMatch(object, normalizedFilter)) : objects;
+    return typeof limit === "number" ? filtered.slice(0, limit) : filtered;
+  }
+
+  async function listSchemaAwareCompletionObjects(connectionId: string, database: string, schema?: string): Promise<ObjectInfo[]> {
+    const schemas = schema ? [schema] : await listCompletionSchemas(connectionId, database);
+    const batchSize = COMPLETION_METADATA_CONCURRENCY;
+    const results: ObjectInfo[] = [];
+    for (let i = 0; i < schemas.length; i += batchSize) {
+      const batch = schemas.slice(i, i + batchSize);
+      const groups = await Promise.all(
+        batch.map(async (s) => {
+          try {
+            return await api.listCompletionObjects(connectionId, database, s);
+          } catch {
+            return [] as ObjectInfo[];
+          }
+        }),
+      );
+      for (const group of groups) results.push(...group);
+    }
+    return results;
+  }
+
+  function toSqlCompletionObject(object: ObjectInfo): SqlCompletionObject | null {
+    const objectType = object.object_type.toUpperCase();
+    const type = objectType.includes("PROCEDURE") ? "procedure" : objectType.includes("FUNCTION") ? "function" : objectType.includes("TRIGGER") ? "trigger" : objectType.includes("PACKAGE") ? "package" : null;
+    if (!type) return null;
+    return {
+      name: object.name,
+      schema: object.schema ?? undefined,
+      type,
+      parentSchema: object.parent_schema ?? undefined,
+      parentName: object.parent_name ?? undefined,
+    };
+  }
+
+  function fuzzyCompletionObjectMatch(object: SqlCompletionObject, filter: string): boolean {
+    return fuzzyTextMatch(object.name, filter) || (!!object.schema && fuzzyTextMatch(object.schema, filter)) || (!!object.parentName && fuzzyTextMatch(object.parentName, filter)) || (!!object.parentSchema && fuzzyTextMatch(`${object.parentSchema}.${object.parentName ?? ""}`, filter));
+  }
+
+  function fuzzyTextMatch(value: string, filter: string): boolean {
+    if (!filter) return true;
+    const text = value.toLowerCase();
+    if (text.includes(filter)) return true;
+    let index = 0;
+    for (const ch of filter) {
+      index = text.indexOf(ch, index);
+      if (index < 0) return false;
+      index++;
+    }
+    return true;
+  }
+
+  function dedupeCompletionObjects(objects: SqlCompletionObject[]): SqlCompletionObject[] {
+    const seen = new Set<string>();
+    const deduped: SqlCompletionObject[] = [];
+    for (const object of objects) {
+      const key = `${object.type}:${object.schema ?? ""}:${object.name}:${object.parentName ?? ""}`.toLowerCase();
+      if (seen.has(key)) continue;
+      seen.add(key);
+      deduped.push(object);
+    }
+    return deduped;
+  }
+
+  async function listCompletionColumns(connectionId: string, database: string, table: string, schema?: string): Promise<SqlCompletionColumn[]> {
+    if (isSchemaAwareDatabase(connectionId) && !connectionUsesDatabaseObjectTreeMode(getConfig(connectionId)) && !schema) {
+      return [];
+    }
+    const cacheKey = `${connectionId}:${database}:${schema || ""}:${table}`;
+    if (!completionColumnsCache.value[cacheKey]) {
+      await withCompletionInFlight(
+        `${cacheKey}:columns`,
+        async () => {
+          await ensureConnected(connectionId);
+          try {
+            const assistantColumns = await listCompletionAssistantColumns(connectionId, database, table, schema);
+            if (assistantColumns.length > 0) {
+              completionColumnsCache.value[cacheKey] = assistantColumns.map((column) => ({
+                name: column.name,
+                data_type: column.dataType ?? "",
+                is_nullable: column.isNullable ?? true,
+                column_default: null,
+                is_primary_key: false,
+                extra: null,
+                comment: column.comment ?? null,
+                numeric_precision: null,
+                numeric_scale: null,
+                character_maximum_length: null,
+              }));
+              evictOldestCacheEntries(completionColumnsCache.value, COMPLETION_CACHE_MAX);
+              return;
+            }
+          } catch {
+            // Fall back to the existing metadata path below.
+          }
+          const querySchema = metadataQuerySchema(connectionId, database, schema);
+          completionColumnsCache.value[cacheKey] = await api.getColumns(connectionId, database, querySchema, table);
+          evictOldestCacheEntries(completionColumnsCache.value, COMPLETION_CACHE_MAX);
+        },
+        { scope: completionLimiterScope(connectionId, database), kind: "columns" },
+      );
+    }
+
+    const columns = completionColumnsCache.value[cacheKey].map((column) => ({
+      name: column.name,
+      table,
+      schema,
+      dataType: column.data_type,
+      isNullable: column.is_nullable,
+      comment: column.comment,
+    }));
+    indexCompletionColumns(connectionId, database, table, schema, columns);
+    return columns;
+  }
+
+  async function listCompletionForeignKeys(connectionId: string, database: string, table: string, schema?: string): Promise<SqlCompletionForeignKey[]> {
+    if (isSchemaAwareDatabase(connectionId) && !connectionUsesDatabaseObjectTreeMode(getConfig(connectionId)) && !schema) {
+      return [];
+    }
+    const metadataCapabilities = getTableMetadataCapabilities(effectiveDatabaseTypeForConnection(getConfig(connectionId)));
+    if (!metadataCapabilities.foreignKeys) return [];
+
+    const cacheKey = `${connectionId}:${database}:${schema || ""}:${table}`;
+    if (!completionForeignKeysCache.value[cacheKey]) {
+      await withCompletionInFlight(
+        `${cacheKey}:fkeys`,
+        async () => {
+          await ensureConnected(connectionId);
+          const querySchema = metadataQuerySchema(connectionId, database, schema);
+          completionForeignKeysCache.value[cacheKey] = await api.listForeignKeys(connectionId, database, querySchema, table);
+          evictOldestCacheEntries(completionForeignKeysCache.value, COMPLETION_CACHE_MAX);
+        },
+        { scope: completionLimiterScope(connectionId, database), kind: "foreignKeys" },
+      );
+    }
+
+    const foreignKeys = sqlCompletionForeignKeys(completionForeignKeysCache.value[cacheKey]);
+    indexCompletionForeignKeys(connectionId, database, table, schema, foreignKeys);
+    return foreignKeys;
+  }
+
+  function refreshCompletionTables(connectionId: string, database: string, filter = "", limit?: number, schema?: string): Promise<SqlCompletionTable[]> {
+    return listCompletionTables(connectionId, database, filter, limit, schema);
+  }
+
+  function refreshCompletionObjects(connectionId: string, database: string, filter = "", limit?: number, schema?: string): Promise<SqlCompletionObject[]> {
+    return listCompletionObjects(connectionId, database, filter, limit, schema);
+  }
+
+  function refreshCompletionSchemas(connectionId: string, database: string): Promise<string[]> {
+    return listCompletionSchemas(connectionId, database);
+  }
+
+  function refreshCompletionDatabases(connectionId: string): Promise<string[]> {
+    return listCompletionDatabases(connectionId);
+  }
+
+  function refreshCompletionColumns(connectionId: string, database: string, table: string, schema?: string): Promise<SqlCompletionColumn[]> {
+    return listCompletionColumns(connectionId, database, table, schema);
+  }
+
+  function refreshCompletionForeignKeys(connectionId: string, database: string, table: string, schema?: string): Promise<SqlCompletionForeignKey[]> {
+    return listCompletionForeignKeys(connectionId, database, table, schema);
+  }
+
+  function findNode(nodes: TreeNode[], id: string): TreeNode | null {
+    for (const node of nodes) {
+      if (node.id === id) return node;
+      if (node.children) {
+        const found = findNode(node.children, id);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+
+  async function persistConnections(nextConnections: ConnectionConfig[] = connections.value) {
+    await api.saveConnections(nextConnections);
+  }
+
+  function persistSidebarLayoutDebounced() {
+    if (layoutPersistTimer) clearTimeout(layoutPersistTimer);
+    layoutPersistTimer = setTimeout(() => {
+      api.saveSidebarLayout(sidebarLayout.value).catch(() => {});
+      layoutPersistTimer = null;
+    }, 300);
+  }
+
+  function rebuildTreeNodes() {
+    const existingNodesMap = new Map<string, TreeNode>();
+    const collectExisting = (nodes: TreeNode[]) => {
+      for (const node of nodes) {
+        existingNodesMap.set(node.id, node);
+        if (node.children) collectExisting(node.children);
+      }
+    };
+    collectExisting(treeNodes.value);
+
+    const freshNodes = buildTreeNodesFromLayout(sidebarLayout.value, connections.value, pinnedTreeNodeIds.value);
+    const mergeState = (nodes: TreeNode[]): TreeNode[] =>
+      nodes.map((node) => {
+        const existing = existingNodesMap.get(node.id);
+        if (node.type === "connection-group") {
+          return { ...node, children: mergeState(node.children || []) };
+        }
+        if (existing && node.type === "connection") {
+          return {
+            ...existing,
+            label: node.label,
+            pinned: node.pinned,
+            children: withSavedSqlRoot(node.connectionId!, existing.children || [], existing),
+          };
+        }
+        if (node.type === "connection" && node.connectionId) {
+          return { ...node, children: withSavedSqlRoot(node.connectionId, node.children || []) };
+        }
+        return node;
+      });
+    treeNodes.value = mergeState(freshNodes);
+  }
+
+  function updateLayoutAndRebuild(nextLayout: SidebarLayout) {
+    sidebarLayout.value = nextLayout;
+    rebuildTreeNodes();
+    persistSidebarLayoutDebounced();
+  }
+
+  function collapseAllTreeNodes() {
+    updateLayoutAndRebuild(collapseAllGroupsOp(sidebarLayout.value));
+    collapseExpandedTreeNodes(treeNodes.value);
+  }
+
+  async function refreshAllTree() {
+    const expandedIds = collectExpandedNodeIds(treeNodes.value);
+    const refreshExpandedNodes = async (nodes: TreeNode[]) => {
+      for (const node of nodes) {
+        if (node.type === "connection-group") {
+          if (node.children) await refreshExpandedNodes(node.children);
+          continue;
+        }
+        if (!expandedIds.has(node.id)) continue;
+        if (node.connectionId && !connectedIds.value.has(node.connectionId)) continue;
+        clearLoadedChildrenCache(node.id);
+        node.children = [];
+        await loadTreeNodeChildren(node, { force: true });
+        await restoreExpandedChildren(node, expandedIds, { force: true });
+      }
+    };
+    await refreshExpandedNodes(treeNodes.value);
+  }
+
+  async function refreshSidebarObjectPagination() {
+    const simpleObjectDisplay = useSettingsStore().editorSettings.sidebarObjectDisplay === "simple";
+    const isDirectObjectParent = (node: TreeNode) => {
+      if (!node.children || node.children.length === 0) return false;
+      return node.children.some(
+        (child) => child.type === "table" || child.type === "view" || child.type === "materialized_view" || child.type === "procedure" || child.type === "function" || child.type === "sequence" || child.type === "package" || child.type === "package-body" || child.type === "load-more",
+      );
+    };
+    const refreshNodes = async (nodes: TreeNode[]) => {
+      for (const node of nodes) {
+        if (node.type === "connection-group") {
+          if (node.children) await refreshNodes(node.children);
+          continue;
+        }
+        if (objectTypesForGroupNode(node.type)) {
+          if (node.connectionId && connectedIds.value.has(node.connectionId)) {
+            clearLoadedChildrenCache(node.id);
+            if (node.isExpanded) {
+              await loadObjectGroupChildren(node, { force: true });
+            } else if (node.children) {
+              node.children = [];
+            }
+          }
+          continue;
+        }
+        if (simpleObjectDisplay && (node.type === "database" || node.type === "schema" || node.type === "linked-server-schema")) {
+          if (isDirectObjectParent(node)) {
+            if (node.connectionId && connectedIds.value.has(node.connectionId)) {
+              clearLoadedChildrenCache(node.id);
+              if (node.isExpanded) {
+                await refreshTreeNode(node);
+              } else {
+                node.children = [];
+              }
+            }
+            continue;
+          }
+          if (node.children) await refreshNodes(node.children);
+          continue;
+        }
+        if (node.children) await refreshNodes(node.children);
+      }
+    };
+    await refreshNodes(treeNodes.value);
+  }
+
+  async function exportConnectionsToFile(passphrase: string) {
+    const { encryptConfig } = await import("@/lib/backend/configCrypto");
+    const tunnelProfileStore = useTunnelProfileStore();
+    await tunnelProfileStore.init();
+    const exportData = { connections: connections.value, layout: sidebarLayout.value, tunnelProfiles: tunnelProfileStore.profiles };
+    const json = JSON.stringify(exportData);
+    const payload = await encryptConfig(json, passphrase);
+    const content = JSON.stringify(payload, null, 2);
+
+    if (isTauriRuntime()) {
+      const { save } = await import("@tauri-apps/plugin-dialog");
+      const { writeTextFile } = await import("@tauri-apps/plugin-fs");
+      const path = await save({
+        filters: [{ name: "JSON", extensions: ["json"] }],
+        defaultPath: "dbx-connections.json",
+      });
+      if (!path) return;
+      await writeTextFile(path, content);
+    } else {
+      const blob = new Blob([content], { type: "application/json" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = "dbx-connections.json";
+      a.click();
+      URL.revokeObjectURL(url);
+    }
+  }
+
+  function bytesToBase64(bytes: Uint8Array) {
+    let binary = "";
+    const chunkSize = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunkSize) {
+      binary += String.fromCharCode(...bytes.slice(i, i + chunkSize));
+    }
+    return btoa(binary);
+  }
+
+  function siblingCredentialsPath(path: string) {
+    const fileName = path.split(/[\\/]/).pop() || "";
+    const credentialsFile = fileName.startsWith("data-sources-") ? fileName.replace(/^data-sources/, "credentials-config") : "credentials-config.json";
+    return path.replace(/[^\\/]+$/, credentialsFile);
+  }
+
+  async function readDbeaverImportFile(): Promise<{ content: string; encrypted: boolean } | null> {
+    let dataSources: string;
+    let credentialsBase64 = "";
+
+    if (isTauriRuntime()) {
+      const { open } = await import("@tauri-apps/plugin-dialog");
+      const { readTextFile, readFile } = await import("@tauri-apps/plugin-fs");
+      const path = await open({
+        filters: [{ name: "DBeaver Data Sources", extensions: ["json"] }],
+        multiple: false,
+      });
+      if (!path) return null;
+      const dataSourcesPath = path as string;
+      dataSources = await readTextFile(dataSourcesPath);
+      try {
+        credentialsBase64 = bytesToBase64(await readFile(siblingCredentialsPath(dataSourcesPath)));
+      } catch {
+        credentialsBase64 = "";
+      }
+    } else {
+      const files = await new Promise<FileList>((resolve, reject) => {
+        const input = document.createElement("input");
+        input.type = "file";
+        input.accept = ".json";
+        input.multiple = true;
+        input.onchange = () => {
+          if (!input.files?.length) {
+            reject(new Error("No file selected"));
+            return;
+          }
+          resolve(input.files);
+        };
+        input.click();
+      });
+      const fileList = Array.from(files);
+      const dataSourcesFile = fileList.find((file) => /^data-sources.*\.json$/i.test(file.name)) || fileList.find((file) => !/^credentials-config.*\.json$/i.test(file.name));
+      const credentialsFile = fileList.find((file) => /^credentials-config.*\.json$/i.test(file.name));
+      if (!dataSourcesFile) throw new Error("Select DBeaver data-sources.json");
+      dataSources = await dataSourcesFile.text();
+      if (credentialsFile) {
+        credentialsBase64 = bytesToBase64(new Uint8Array(await credentialsFile.arrayBuffer()));
+      }
+    }
+
+    return {
+      content: JSON.stringify({ format: "dbeaver-import", dataSources, credentialsBase64 }),
+      encrypted: false,
+    };
+  }
+
+  async function readDataGripImportFile(): Promise<{ content: string; encrypted: boolean } | null> {
+    let dataSources: string;
+    let dataSourcesLocal = "";
+
+    if (isTauriRuntime()) {
+      const { open } = await import("@tauri-apps/plugin-dialog");
+      const { readTextFile } = await import("@tauri-apps/plugin-fs");
+      const path = await open({
+        filters: [{ name: "DataGrip dataSources.xml", extensions: ["xml"] }],
+        multiple: false,
+      });
+      if (!path) return null;
+      dataSources = await readTextFile(path as string);
+      // Auto-load dataSources.local.xml from the same directory
+      const dir = (path as string).replace(/[^/\\]*$/, "");
+      try {
+        dataSourcesLocal = await readTextFile(dir + "dataSources.local.xml");
+      } catch {
+        dataSourcesLocal = "";
+      }
+    } else {
+      const files = await new Promise<FileList>((resolve, reject) => {
+        const input = document.createElement("input");
+        input.type = "file";
+        input.accept = ".xml";
+        input.multiple = true;
+        input.onchange = () => {
+          if (!input.files?.length) {
+            reject(new Error("No file selected"));
+            return;
+          }
+          resolve(input.files);
+        };
+        input.click();
+      });
+      const fileList = Array.from(files);
+      const dsFile = fileList.find((f) => /^dataSources\.xml$/i.test(f.name)) || fileList[0];
+      const localFile = fileList.find((f) => /^dataSources\.local\.xml$/i.test(f.name));
+      if (!dsFile) throw new Error("Select dataSources.xml");
+      dataSources = await dsFile.text();
+      if (localFile) {
+        dataSourcesLocal = await localFile.text();
+      }
+    }
+
+    return {
+      content: JSON.stringify({ format: "datagrip-import", dataSources, dataSourcesLocal }),
+      encrypted: false,
+    };
+  }
+
+  async function readImportFile(source: ImportSource = "dbx"): Promise<{ content: string; encrypted: boolean } | null> {
+    if (source === "dbeaver") return readDbeaverImportFile();
+    if (source === "datagrip") return readDataGripImportFile();
+
+    let content: string;
+
+    if (isTauriRuntime()) {
+      const { open } = await import("@tauri-apps/plugin-dialog");
+      const { readTextFile } = await import("@tauri-apps/plugin-fs");
+      const path = await open({
+        filters: source === "navicat" ? [{ name: "Navicat Connection Export", extensions: ["ncx", "xml"] }] : [{ name: "DBX JSON", extensions: ["json"] }],
+        multiple: false,
+      });
+      if (!path) return null;
+      content = await readTextFile(path as string);
+    } else {
+      content = await new Promise<string>((resolve, reject) => {
+        const input = document.createElement("input");
+        input.type = "file";
+        input.accept = source === "navicat" ? ".ncx,.xml" : ".json";
+        input.onchange = () => {
+          const file = input.files?.[0];
+          if (!file) {
+            reject(new Error("No file selected"));
+            return;
+          }
+          const reader = new FileReader();
+          reader.onload = () => resolve(reader.result as string);
+          reader.onerror = () => reject(reader.error);
+          reader.readAsText(file);
+        };
+        input.click();
+      });
+    }
+
+    if (content.trimStart().startsWith("<")) {
+      return { content, encrypted: false };
+    }
+
+    const { isEncryptedConfig } = await import("@/lib/backend/configCrypto");
+    const parsed = JSON.parse(content);
+    return { content, encrypted: isEncryptedConfig(parsed) };
+  }
+
+  async function importConnectionsFromFile(content: string, passphrase: string | null): Promise<{ count: number; layout?: SidebarLayout }> {
+    let imported: ConnectionConfig[] = [];
+    let importedLayout: SidebarLayout | undefined;
+    let importedTunnelProfiles: TunnelProfile[] = [];
+
+    if (!passphrase && content.trimStart().startsWith("<")) {
+      const { parseNavicatConnections } = await import("@/lib/imports/navicatImport");
+      imported = await parseNavicatConnections(content);
+    } else if (!passphrase) {
+      const { isDbeaverImportPayload, parseDbeaverConnections } = await import("@/lib/imports/dbeaverImport");
+      const { isDataGripImportPayload, parseDataGripConnections } = await import("@/lib/imports/datagripImport");
+      if (isDataGripImportPayload(content)) {
+        const payload = JSON.parse(content) as {
+          format: "datagrip-import";
+          dataSources: string;
+          dataSourcesLocal?: string;
+        };
+        pendingDataGripPayload = payload;
+        imported = parseDataGripConnections(payload);
+      } else if (isDbeaverImportPayload(content)) {
+        imported = await parseDbeaverConnections(content);
+      } else {
+        const parsed = JSON.parse(content);
+
+        if (Array.isArray(parsed)) {
+          imported = parsed;
+        } else if (parsed.format === "dbx-config" && Array.isArray(parsed.connections)) {
+          imported = parsed.connections;
+        } else if (parsed.connections && Array.isArray(parsed.connections)) {
+          imported = parsed.connections;
+          if (parsed.layout?.groups && parsed.layout?.order) {
+            importedLayout = parsed.layout;
+          }
+          if (Array.isArray(parsed.tunnelProfiles)) {
+            importedTunnelProfiles = parsed.tunnelProfiles;
+          }
+        } else {
+          imported = [];
+        }
+      }
+    } else {
+      const parsed = JSON.parse(content);
+
+      if (passphrase) {
+        const { decryptConfig } = await import("@/lib/backend/configCrypto");
+        const json = await decryptConfig(parsed, passphrase);
+        const decrypted = JSON.parse(json);
+        if (Array.isArray(decrypted)) {
+          imported = decrypted;
+        } else if (decrypted.connections) {
+          imported = decrypted.connections;
+          if (decrypted.layout?.groups && decrypted.layout?.order) {
+            importedLayout = decrypted.layout;
+          }
+          if (Array.isArray(decrypted.tunnelProfiles)) {
+            importedTunnelProfiles = decrypted.tunnelProfiles;
+          }
+        } else {
+          imported = [];
+        }
+      }
+    }
+
+    // Profiles keep their original ids: imported connections reference them
+    // via transport_layers[].profile_id, so regenerating ids would break the
+    // links. Same-id profiles are overwritten with the imported copy.
+    if (importedTunnelProfiles.length) {
+      const tunnelProfileStore = useTunnelProfileStore();
+      await tunnelProfileStore.init();
+      const merged = [...tunnelProfileStore.profiles];
+      for (const profile of importedTunnelProfiles) {
+        if (!profile || typeof profile.id !== "string" || !profile.id) continue;
+        const index = merged.findIndex((existing) => existing.id === profile.id);
+        if (index >= 0) merged[index] = profile;
+        else merged.push(profile);
+      }
+      await tunnelProfileStore.saveProfiles(merged);
+    }
+
+    let count = 0;
+    const importedConnectionIdMap = new Map<string, string>();
+    for (const config of imported) {
+      const duplicate = connections.value.find((c) => c.name === config.name && c.host === config.host && c.port === config.port);
+      if (!duplicate) {
+        const importedId = config.id;
+        config.id = uuid();
+        if (typeof importedId === "string") importedConnectionIdMap.set(importedId, config.id);
+        const normalized = normalizeConnection(config);
+        await addConnection(normalized);
+        count++;
+      } else if (typeof config.id === "string") {
+        importedConnectionIdMap.set(config.id, duplicate.id);
+      }
+    }
+    if (importedLayout) {
+      importedLayout = remapSidebarLayoutConnectionIds(importedLayout, importedConnectionIdMap);
+    }
+    return { count, layout: importedLayout };
+  }
+
+  /** Read macOS Keychain passwords for DataGrip connections and update them. */
+  async function applyDataGripKeychainPasswords(): Promise<number> {
+    const payload = pendingDataGripPayload;
+    pendingDataGripPayload = null;
+    if (!payload) return 0;
+
+    try {
+      const { getDataGripUuidMap, datagripKeychainService } = await import("@/lib/imports/datagripImport");
+      // dedupKey → DataGrip UUID
+      const uuidMap = getDataGripUuidMap(payload);
+      if (uuidMap.size === 0) return 0;
+
+      // Build service names for batch Keychain read
+      const dedupKeyToService = new Map<string, string>();
+      const services: string[] = [];
+      for (const [dedupKey, dgUuid] of uuidMap) {
+        const service = datagripKeychainService(dgUuid);
+        dedupKeyToService.set(dedupKey, service);
+        services.push(service);
+      }
+
+      // Call Tauri command to read Keychain
+      const results: [string, string][] = await api.readKeychainPasswords(services);
+
+      // Build service → password map
+      const passwordByService = new Map<string, string>();
+      for (const [service, password] of results) {
+        if (password) passwordByService.set(service, password);
+      }
+
+      // Update connections that have passwords (match by name/host/port)
+      let filled = 0;
+      const updated = connections.value.map((conn) => {
+        const dedupKey = [conn.name, conn.host, conn.port, conn.database || ""].join("\u0000");
+        const service = dedupKeyToService.get(dedupKey);
+        if (!service) return conn;
+        const password = passwordByService.get(service);
+        if (password) {
+          filled++;
+          return { ...conn, password };
+        }
+        return conn;
+      });
+
+      if (filled > 0) {
+        connections.value = updated;
+        await persistConnections();
+      }
+      return filled;
+    } catch (e) {
+      console.warn("[DataGrip Import] Keychain read failed:", e);
+      return 0;
+    }
+  }
+
+  function applySidebarLayout(layout: SidebarLayout) {
+    const reconciledLayout = reconcileLayout(
+      connections.value.map((c) => c.id),
+      layout,
+    );
+    updateLayoutAndRebuild(reconciledLayout);
+  }
+
+  async function initFromDisk() {
+    if (!initFromDiskPromise) {
+      initFromDiskPromise = (async () => {
+        pinnedTreeNodeIds.value = await loadPinnedTreeNodeIds();
+        const saved = await api.loadConnections();
+        connections.value = saved.map(normalizeConnection);
+        const savedLayout = await api.loadSidebarLayout();
+        const currentLayout = sidebarLayout.value.groups.length || sidebarLayout.value.order.length ? sidebarLayout.value : null;
+        sidebarLayout.value = reconcileLayout(
+          connections.value.map((c) => c.id),
+          savedLayout ?? currentLayout,
+        );
+        rebuildTreeNodes();
+      })().finally(() => {
+        initFromDiskPromise = null;
+      });
+    }
+    await initFromDiskPromise;
+  }
+
+  function addEphemeralConnection(config: ConnectionConfig) {
+    const normalized = normalizeConnection(config);
+    if (!connections.value.find((c) => c.id === normalized.id)) {
+      connections.value.push(normalized);
+    }
+    connectedIds.value.add(normalized.id);
+    markConnectionHealthChecked(normalized.id);
+    clearConnectionError(normalized.id);
+  }
+
+  return {
+    connections,
+    activeConnectionId,
+    selectedTreeNodeId,
+    selectedTreeNodeIds,
+    treeSelectionAnchorId,
+    connectionMultiSelectActive,
+    treeClipboard,
+    treeNodes,
+    removeTreeNode,
+    refreshAllTree,
+    collapseAllTreeNodes,
+    refreshSidebarObjectPagination,
+    refreshTreeNode,
+    refreshDatabaseTreeNode,
+    refreshObjectListTreeNode,
+    connectedIds,
+    connectingIds,
+    connectionErrors,
+    setConnectionError,
+    clearConnectionError,
+    recordConnectionError,
+    markConnectionLost,
+    recordConnectionLostError,
+    sidebarLayout,
+    getConfig,
+    isTreeNodePinned,
+    toggleTreeNodePin,
+    addConnection,
+    copyConnectionsToTreeClipboard,
+    pasteConnectionClipboard,
+    addEphemeralConnection,
+    updateConnection,
+    setDefaultDatabase,
+    clearDefaultDatabase,
+    isDefaultDatabase,
+    setVisibleDatabases,
+    clearVisibleDatabases,
+    ensureVisibleDatabase,
+    setVisibleSchemas,
+    clearVisibleSchemas,
+    removeConnection,
+    removeConnections,
+    editingConnectionId,
+    newConnectionGroupId,
+    startEditing,
+    stopEditing,
+    startCreatingConnectionInGroup,
+    stopCreatingConnectionInGroup,
+    connect,
+    cancelConnecting,
+    disconnect,
+    closeDatabaseConnection,
+    ensureConnected,
+    isTreeNodeChildrenLoaded,
+    setBeforeConnectHandler,
+    initFromDisk,
+    loadDatabases,
+    loadRedisDatabases,
+    refreshRedisDbKeyCounts,
+    loadEtcdRoot,
+    loadZooKeeperRoot,
+    loadMqTenants,
+    loadNacosNamespaces,
+    updateRedisDbKeyStats,
+    loadMongoDatabases,
+    loadMilvusDatabases,
+    loadElasticsearchIndices,
+    loadVectorCollections,
+    loadMongoCollections,
+    loadSchemas,
+    loadSqlServerDatabaseObjects,
+    loadSqlServerLinkedServers,
+    loadSqlServerLinkedServerCatalogs,
+    loadSqlServerLinkedServerSchemas,
+    loadDorisCatalogDatabases,
+    loadDorisCatalogTables,
+    loadTables,
+    loadTableForLocate,
+    loadObjectGroupChildren,
+    loadMoreObjectGroupChildren,
+    loadAllObjectGroupChildren,
+    loadTableGroups,
+    loadColumns,
+    loadIndexes,
+    loadForeignKeys,
+    loadTriggers,
+    listCompletionTables,
+    listCompletionObjects,
+    listCompletionColumns,
+    listCompletionForeignKeys,
+    listCompletionSchemas,
+    listCompletionDatabases,
+    lookupLocalCompletionTables,
+    lookupLocalCompletionObjects,
+    lookupLocalCompletionColumns,
+    lookupLocalCompletionForeignKeys,
+    lookupLocalCompletionSchemas,
+    lookupLocalCompletionDatabases,
+    refreshCompletionTables,
+    refreshCompletionObjects,
+    refreshCompletionColumns,
+    refreshCompletionForeignKeys,
+    refreshCompletionSchemas,
+    refreshCompletionDatabases,
+    listElasticsearchCompletionIndices,
+    listRedisCompletionKeys,
+    listMongoCompletionCollections,
+    listMongoCompletionFields,
+    invalidateCompletionCache,
+    invalidateMetadataCache,
+    exportConnectionsToFile,
+    readImportFile,
+    importConnectionsFromFile,
+    applyDataGripKeychainPasswords,
+    applySidebarLayout,
+    transferSource,
+    schemaDiffSource,
+    dataCompareSource,
+    sqlFileSource,
+    diagramSource,
+    tableImportSource,
+    tableDataGenerateSource,
+    fieldLineageSource,
+    databaseSearchSource,
+    databaseExportSource,
+    sidebarSearchQuery,
+    sidebarTableSearchQueries,
+    setSidebarTableSearchQuery,
+    refreshSidebarTableSearch,
+    createConnectionGroup(name: string, parentGroupId?: string | null) {
+      const result = createGroupOp(sidebarLayout.value, name, parentGroupId);
+      updateLayoutAndRebuild(result.layout);
+      return result.groupId;
+    },
+    renameConnectionGroup(groupId: string, name: string) {
+      updateLayoutAndRebuild(renameGroupOp(sidebarLayout.value, groupId, name));
+    },
+    deleteConnectionGroup(groupId: string) {
+      updateLayoutAndRebuild(deleteGroupOp(sidebarLayout.value, groupId));
+    },
+    toggleConnectionGroupCollapsed(groupId: string) {
+      updateLayoutAndRebuild(toggleGroupCollapsedOp(sidebarLayout.value, groupId));
+    },
+    moveConnectionToGroup(connectionId: string, groupId: string | null) {
+      updateLayoutAndRebuild(moveConnectionToGroupOp(sidebarLayout.value, connectionId, groupId));
+    },
+    groupIdForConnection(connectionId: string): string | null {
+      return findConnectionLocation(sidebarLayout.value, connectionId)?.groupId ?? null;
+    },
+    reorderSidebarEntry(draggedId: string, targetId: string, position: DropPosition) {
+      updateLayoutAndRebuild(reorderEntryOp(sidebarLayout.value, draggedId, targetId, position));
+    },
+    reorderSidebarEntries(draggedIds: string[], targetId: string, position: DropPosition) {
+      // Apply each dragged entry in turn so a multi-selection moves together,
+      // not just the single grabbed row (issue #681).
+      let layout = sidebarLayout.value;
+      let changed = false;
+      for (const id of draggedIds) {
+        if (id === targetId) continue;
+        layout = reorderEntryOp(layout, id, targetId, position);
+        changed = true;
+      }
+      if (changed) updateLayoutAndRebuild(layout);
+    },
+  };
+});
diff --git a/apps/desktop/src/stores/historyStore.ts b/apps/desktop/src/stores/historyStore.ts
new file mode 100644
index 0000000..7c49a38
--- /dev/null
+++ b/apps/desktop/src/stores/historyStore.ts
@@ -0,0 +1,42 @@
+import { defineStore } from "pinia";
+import { uuid } from "@/lib/common/utils";
+import { ref } from "vue";
+import * as api from "@/lib/backend/api";
+import type { HistoryEntry } from "@/lib/backend/api";
+
+export const useHistoryStore = defineStore("history", () => {
+  const entries = ref<HistoryEntry[]>([]);
+  const loading = ref(false);
+
+  async function load() {
+    loading.value = true;
+    try {
+      entries.value = await api.loadHistory(200, 0);
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function add(entry: Omit<HistoryEntry, "id" | "executed_at">) {
+    const full: HistoryEntry = {
+      ...entry,
+      id: uuid(),
+      executed_at: new Date().toISOString(),
+    };
+    await api.saveHistory(full);
+    entries.value.unshift(full);
+    if (entries.value.length > 200) entries.value.pop();
+  }
+
+  async function remove(id: string) {
+    await api.deleteHistoryEntry(id);
+    entries.value = entries.value.filter((e) => e.id !== id);
+  }
+
+  async function clear() {
+    await api.clearHistory();
+    entries.value = [];
+  }
+
+  return { entries, loading, load, add, remove, clear };
+});
diff --git a/apps/desktop/src/stores/productionSafetyStore.ts b/apps/desktop/src/stores/productionSafetyStore.ts
new file mode 100644
index 0000000..004c22b
--- /dev/null
+++ b/apps/desktop/src/stores/productionSafetyStore.ts
@@ -0,0 +1,63 @@
+import { ref } from "vue";
+import { defineStore } from "pinia";
+
+export interface ProductionConfirmationRequest {
+  sql: string;
+  connectionName?: string;
+  database?: string;
+  productionDatabases?: string[];
+  source?: string;
+}
+
+interface QueuedConfirmationRequest {
+  request: ProductionConfirmationRequest;
+  resolve: (confirmed: boolean) => void;
+}
+
+/**
+ * Coordinates the single production-write confirmation dialog shared by all
+ * workbench surfaces. The request is intentionally transient and is never
+ * persisted, so every production write requires a fresh user decision.
+ */
+export const useProductionSafetyStore = defineStore("productionSafety", () => {
+  const pending = ref<ProductionConfirmationRequest>();
+  const queue: QueuedConfirmationRequest[] = [];
+  let resolvePending: ((confirmed: boolean) => void) | undefined;
+
+  function requestConfirmation(request: ProductionConfirmationRequest): Promise<boolean> {
+    return new Promise<boolean>((resolve) => {
+      if (pending.value) {
+        // Keep concurrent production writes visible instead of silently denying
+        // the later operation while the user is reviewing the current SQL.
+        queue.push({ request, resolve });
+        return;
+      }
+      beginRequest(request, resolve);
+    });
+  }
+
+  function beginRequest(request: ProductionConfirmationRequest, resolve: (confirmed: boolean) => void) {
+    pending.value = request;
+    resolvePending = resolve;
+  }
+
+  function settle(confirmed: boolean) {
+    const resolve = resolvePending;
+    resolvePending = undefined;
+    pending.value = undefined;
+    resolve?.(confirmed);
+
+    const next = queue.shift();
+    if (next) beginRequest(next.request, next.resolve);
+  }
+
+  function confirm() {
+    settle(true);
+  }
+
+  function cancel() {
+    settle(false);
+  }
+
+  return { pending, requestConfirmation, confirm, cancel };
+});
diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.ts
new file mode 100644
index 0000000..a32896f
--- /dev/null
+++ b/apps/desktop/src/stores/queryStore.ts
@@ -0,0 +1,3832 @@
+import { defineStore } from "pinia";
+import { uuid } from "@/lib/common/utils";
+import { markRaw, ref, watch, computed } from "vue";
+import { useI18n } from "vue-i18n";
+import type { ConnectionConfig, DatabaseType, ObjectBrowserViewport, QueryResult, QueryTab, TableInfoTab, TableStructureEditorTarget } from "@/types/database";
+import { orderPinnedFirst } from "@/lib/app/pinnedItems";
+import { canCancelQueryExecution } from "@/lib/sql/queryExecutionState";
+import { buildExplainSql, parseExplainResult, parseDamengExplainText, parseOracleExplainText, type BuildExplainSqlResult } from "@/lib/diagram/explainPlan";
+import { allEditableColumnsWriteable, allPrimaryKeysPresent, analyzeEditableQueryEditability, sourceColumnsForResult, type EditableQueryInfo, type EditableQuerySource } from "@/lib/sql/sqlAnalysis";
+import { buildQueryWithHiddenPrimaryKeys, hiddenResultColumnIndexes, type HiddenPrimaryKeyProjection } from "@/lib/sql/editableQueryHiddenKeys";
+import { ACTIVE_TAB_STORAGE_KEY, OPEN_TABS_STORAGE_KEY, restoreOpenTabsPayload, restoreOpenTabsState, serializeOpenTabs } from "@/lib/app/openTabsPersistence";
+import {
+  evaluateMongoAggregateSafety,
+  evaluateMongoWriteSafety,
+  mongoCollectionStatsToQueryResult,
+  mongoCountToQueryResult,
+  mongoCreateIndexToQueryResult,
+  mongoDocumentsToQueryResult,
+  mongoDroppedIndexesToQueryResult,
+  mongoIndexesToQueryResult,
+  mongoUseToQueryResult,
+  mongoVersionToQueryResult,
+  mongoWriteToQueryResult,
+  splitMongoCommandRanges,
+  type MongoAggregateSafetyOptions,
+} from "@/lib/mongo/mongoShellCommand";
+import { redisCommandResultToQueryResult } from "@/lib/redis/redisQueryResult";
+import { nextRedisCommandDb } from "@/lib/redis/redisCommandSession";
+import { isRedisMutatingCommand } from "@/lib/redis/redisCommandTable";
+import { usesAgentCursorForQuery } from "@/lib/database/databaseDriverManifest";
+import { canUseKeylessRowPredicate, usesSyntheticRowIdKey } from "@/lib/table/tableEditing";
+import { TABLE_DATA_EXPORT_PAGE_SIZE } from "@/lib/table/tableDataExport";
+import { tableMetaForDataTab } from "@/lib/table/tableDataTabMeta";
+import { dataTabExecutionDatabase } from "@/lib/table/dataTabExecutionDatabase";
+import { tableOpenPageLimit } from "@/lib/table/tableOpenPageLimit";
+import { loadTableMetadata } from "@/lib/metadata/tableMetadataCache";
+import { buildTableSelectSql, quoteTableIdentifier } from "@/lib/table/tableSelectSql";
+import { connectionQueryExecutionSchema, effectiveDatabaseTypeForConnection, metadataSchemaForConnection } from "@/lib/database/jdbcDialect";
+import { frontendQueryTimeoutSecsForSql, queryTimeoutSecsForConnection } from "@/lib/sql/queryTimeout";
+import { queryResultSourceLabel } from "@/lib/sql/queryResultSource";
+import { sortDataGridRowIndexes, type DataGridSortDirection } from "@/lib/dataGrid/dataGridSort";
+import { normalizeResultPageSize } from "@/lib/dataGrid/paginationPageSize";
+import { splitSqlStatementRanges } from "@/lib/sql/sqlStatementRanges";
+import { externalSqlFileDisplayTitles, normalizeExternalSqlPath } from "@/lib/sql/sqlFileOpen";
+import { clearDataGridPendingSnapshotsForTab } from "@/composables/useDataGridEditor";
+import { buildTabResultSnapshot, deleteTabResultSnapshot, readTabResultSnapshot, tabResultCacheKey, writeTabResultSnapshot } from "@/lib/tabs/tabResultCache";
+import { queryResultBaseSql, queryResultExecutionSql } from "@/lib/tabs/tabPresentation";
+import { isMysqlExecutionErrorResult } from "@/lib/query/queryResultError";
+import { decodeQueryResultArchive, encodeQueryResultArchive, type DecodedQueryResultArchive } from "@/lib/query/queryResultArchive";
+import * as api from "@/lib/backend/api";
+import { useConnectionStore } from "@/stores/connectionStore";
+import { useSettingsStore } from "@/stores/settingsStore";
+import { useSavedSqlStore } from "@/stores/savedSqlStore";
+import { createSavedSqlEditorPosition, initSavedSqlEditorPositions, restoreSavedSqlEditorPosition, saveSavedSqlEditorPosition } from "@/lib/app/savedSqlEditorPosition";
+import { ensureSqlExtension } from "@/lib/savedSql/savedSqlFileName";
+import { safeLocalStorageGet, safeLocalStorageRemove } from "@/lib/backend/safeStorage";
+import type { SavedSqlFile } from "@/types/database";
+
+const ORACLE_LIKE_METADATA_TYPES = new Set<string>(["oracle", "dameng", "oceanbase-oracle"]);
+const HIDDEN_QUERY_KEY_DATABASE_TYPES = new Set<DatabaseType>(["mysql", "postgres", "sqlserver", "oracle"]);
+const BACKGROUND_CLIENT_SESSION_SUFFIXES = ["count", "explain", "export"] as const;
+const CANCEL_QUERY_TIMEOUT_MS = 10_000;
+const CANCEL_ACK_SETTLE_TIMEOUT_MS = 2_000;
+const SAVED_SQL_EDITOR_POSITION_PERSIST_DELAY_MS = 500;
+type CloseConfirmContext = "tab" | "batch" | "app";
+
+function cloneTabDraft<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+interface BuildQueryResultExportRequestOptions {
+  exportId: string;
+  filePath: string;
+  format: "csv" | "xlsx";
+}
+
+type DroppedTableObjectType = "TABLE" | "VIEW" | "MATERIALIZED_VIEW";
+
+interface DroppedTableObjectTarget {
+  connectionId: string;
+  database: string;
+  schema?: string;
+  schemaCandidates?: Array<string | undefined>;
+  name: string;
+  objectType?: DroppedTableObjectType;
+}
+
+interface TableDataRefreshTarget {
+  connectionId: string;
+  database: string;
+  schema?: string;
+  schemaCandidates?: Array<string | undefined>;
+  catalog?: string;
+  name: string;
+}
+
+function tabClientSessionId(tab: Pick<QueryTab, "id">, suffix?: (typeof BACKGROUND_CLIENT_SESSION_SUFFIXES)[number]): string {
+  return suffix ? `${tab.id}:${suffix}` : tab.id;
+}
+
+function resultRunCacheKey(tabId: string, runId: string): string {
+  return `tab:${tabId}:run:${runId}`;
+}
+
+function normalizeOptionalSchema(schema: string | null | undefined): string {
+  return schema?.trim() ?? "";
+}
+
+function droppedTableObjectSchemaCandidates(target: DroppedTableObjectTarget): Set<string> {
+  const schemas = target.schemaCandidates?.length ? target.schemaCandidates : [target.schema];
+  return new Set(schemas.map(normalizeOptionalSchema));
+}
+
+function markQueryResultRowsRaw(result: QueryResult): QueryResult {
+  markRaw(result.rows);
+  if (result.mongo_documents) markRaw(result.mongo_documents);
+  return result;
+}
+
+function markQueryResultsRowsRaw(results: QueryResult[]): QueryResult[] {
+  for (const result of results) markQueryResultRowsRaw(result);
+  return results;
+}
+
+function markQueryResultRunsRowsRaw(resultRuns: NonNullable<QueryTab["resultRuns"]>): NonNullable<QueryTab["resultRuns"]> {
+  for (const run of resultRuns) {
+    if (run.result) markQueryResultRowsRaw(run.result);
+    if (run.results) markQueryResultsRowsRaw(run.results);
+    if (run.resultLocalSortOriginalRows) markRaw(run.resultLocalSortOriginalRows);
+    if (run.resultLocalSortOriginalMongoDocuments) markRaw(run.resultLocalSortOriginalMongoDocuments);
+  }
+  return resultRuns;
+}
+
+function preservedResultIndex(results: QueryResult[], currentIndex: number | undefined, preserve: boolean | undefined): number | undefined {
+  if (preserve !== true || typeof currentIndex !== "number" || currentIndex < 0 || currentIndex >= results.length) return undefined;
+  return currentIndex;
+}
+
+function annotateQueryResultSources(results: QueryResult[], sql: string, database: string | undefined, databaseType?: DatabaseType): QueryResult[] {
+  const statements = splitSqlStatementRanges(sql, databaseType);
+  let statementIndex = 0;
+  for (const result of results) {
+    const statement = statements[statementIndex++];
+    if (!statement) continue;
+    annotateQueryResultSource(result, statement.sql, database, databaseType);
+  }
+  return results;
+}
+
+function annotateQueryResultSource(result: QueryResult, sourceStatement: string, database?: string, databaseType?: DatabaseType): QueryResult {
+  result.sourceStatement = sourceStatement;
+  const label = databaseType ? queryResultSourceLabel(sourceStatement, { database, databaseType }) : undefined;
+  if (label) result.sourceLabel = label;
+  return result;
+}
+
+async function withFrontendQueryTimeout<T>(promise: Promise<T>, timeoutSecs: number, message: string): Promise<T> {
+  if (timeoutSecs === 0) return promise;
+
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), timeoutSecs * 1000);
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+async function withCancelQueryTimeout<T>(promise: Promise<T>): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_, reject) => {
+        timer = setTimeout(() => reject(new Error("Cancel request timed out after 10s.")), CANCEL_QUERY_TIMEOUT_MS);
+      }),
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+function normalizeOracleLikeMetadataIdentifier(dbType: string, identifier: string | undefined, quoted?: boolean) {
+  if (!identifier || quoted || !ORACLE_LIKE_METADATA_TYPES.has(dbType)) return identifier;
+  return identifier.toUpperCase();
+}
+
+function normalizeOracleLikeQueryAnalysis(dbType: string, analysis: EditableQueryInfo, schema: string | undefined, tableName: string): EditableQueryInfo {
+  if (!ORACLE_LIKE_METADATA_TYPES.has(dbType)) return analysis;
+  return {
+    ...analysis,
+    schema,
+    tableName,
+    sources: analysis.sources?.map((source) => ({
+      ...source,
+      schema: normalizeOracleLikeMetadataIdentifier(dbType, source.schema, source.schemaQuoted),
+      tableName: normalizeOracleLikeMetadataIdentifier(dbType, source.tableName, source.tableNameQuoted)!,
+    })),
+    columns: analysis.columns.map((column) => ({
+      ...column,
+      sourceName: normalizeOracleLikeMetadataIdentifier(dbType, column.sourceName, column.sourceNameQuoted),
+    })),
+  };
+}
+
+function editableQuerySources(analysis: EditableQueryInfo): EditableQuerySource[] {
+  return analysis.sources?.length
+    ? analysis.sources
+    : [
+        {
+          key: `${analysis.tableAlias ?? analysis.tableName}:0`,
+          catalog: analysis.catalog,
+          catalogQuoted: analysis.catalogQuoted,
+          schema: analysis.schema,
+          schemaQuoted: analysis.schemaQuoted,
+          tableName: analysis.tableName,
+          tableNameQuoted: analysis.tableNameQuoted,
+          alias: analysis.tableAlias,
+        },
+      ];
+}
+
+function cloneAnalysisForSource(analysis: EditableQueryInfo, source: EditableQuerySource): EditableQueryInfo {
+  return {
+    ...analysis,
+    catalog: source.catalog,
+    catalogQuoted: source.catalogQuoted,
+    schema: source.schema,
+    schemaQuoted: source.schemaQuoted,
+    tableName: source.tableName,
+    tableNameQuoted: source.tableNameQuoted,
+    tableAlias: source.alias,
+    editableSourceKey: source.key,
+    allowInsertDelete: analysis.sources?.length || analysis.distinct ? false : analysis.allowInsertDelete,
+  };
+}
+
+function sourceMatchesColumn(columnName: string, tableColumns: readonly { name: string }[]): boolean {
+  const normalizedColumn = columnName.toLowerCase();
+  return tableColumns.some((column) => column.name.toLowerCase() === normalizedColumn);
+}
+
+function bindUnqualifiedColumnsForSource(analysis: EditableQueryInfo, source: EditableQuerySource, tableColumns: readonly { name: string }[], allSourceColumns: Array<{ source: EditableQuerySource; columns: readonly { name: string }[] }> = [{ source, columns: tableColumns }]): EditableQueryInfo {
+  return {
+    ...analysis,
+    columns: analysis.columns.map((column) => {
+      if (!column.sourceName || column.sourceKey || column.sourceQualifier) return column;
+      if (!sourceMatchesColumn(column.sourceName, tableColumns)) return column;
+      const matchingSources = allSourceColumns.filter((entry) => sourceMatchesColumn(column.sourceName!, entry.columns));
+      if (matchingSources.length !== 1 || matchingSources[0]?.source.key !== source.key) return column;
+      return { ...column, sourceKey: source.key };
+    }),
+  };
+}
+
+function expandStarProjectionColumnsForSource(analysis: EditableQueryInfo, source: EditableQuerySource, tableColumns: readonly { name: string }[]): EditableQueryInfo {
+  if (analysis.selectStar || !analysis.columns.some((column) => column.star)) return analysis;
+  return {
+    ...analysis,
+    columns: analysis.columns.flatMap((column) => {
+      if (!column.star) return [column];
+      if (column.sourceKey && column.sourceKey !== source.key) return [column];
+      return tableColumns.map((tableColumn) => ({
+        sourceName: tableColumn.name,
+        sourceNameQuoted: false,
+        ...(column.sourceQualifier ? { sourceQualifier: column.sourceQualifier } : {}),
+        sourceKey: source.key,
+        resultName: tableColumn.name,
+        expression: column.sourceQualifier ? `${column.sourceQualifier}.${tableColumn.name}` : tableColumn.name,
+      }));
+    }),
+  };
+}
+
+let saveTabsQueue = Promise.resolve();
+
+function saveTabs(tabs: QueryTab[], activeTabId: string | null): Promise<void> {
+  const payload = { tabs: serializeOpenTabs(tabs), activeTabId };
+  saveTabsQueue = saveTabsQueue.catch(() => undefined).then(() => api.saveOpenTabsState(payload));
+  return saveTabsQueue;
+}
+
+function loadLegacySavedTabs(): { rawTabs: string | null; rawActiveTabId: string | null } {
+  return {
+    rawTabs: safeLocalStorageGet(OPEN_TABS_STORAGE_KEY),
+    rawActiveTabId: safeLocalStorageGet(ACTIVE_TAB_STORAGE_KEY),
+  };
+}
+
+function clearLegacySavedTabs() {
+  safeLocalStorageRemove(OPEN_TABS_STORAGE_KEY);
+  safeLocalStorageRemove(ACTIVE_TAB_STORAGE_KEY);
+}
+
+function restoreSavedTabsFromPayload(payload: { tabs?: unknown; activeTabId?: unknown } | null | undefined): { tabs: QueryTab[]; activeTabId: string | null } {
+  const restoreMode = useSettingsStore().editorSettings.openTabsRestoreMode;
+  if (restoreMode === "none") return { tabs: [], activeTabId: null };
+  return restoreOpenTabsPayload(payload, {
+    filter: restoreMode === "pinned" ? "pinned" : "all",
+  });
+}
+
+function restoreLegacySavedTabs(): { tabs: QueryTab[]; activeTabId: string | null } {
+  const restoreMode = useSettingsStore().editorSettings.openTabsRestoreMode;
+  if (restoreMode === "none") return { tabs: [], activeTabId: null };
+  const legacy = loadLegacySavedTabs();
+  return restoreOpenTabsState(legacy.rawTabs, legacy.rawActiveTabId, {
+    filter: restoreMode === "pinned" ? "pinned" : "all",
+  });
+}
+
+function getI18nT() {
+  try {
+    return useI18n().t;
+  } catch {
+    return ((key: string, ..._args: unknown[]) => key) as ReturnType<typeof useI18n>["t"];
+  }
+}
+
+export const useQueryStore = defineStore("query", () => {
+  const t = getI18nT();
+  const settingsStore = useSettingsStore();
+  const tabs = ref<QueryTab[]>([]);
+  const activeTabId = ref<string | null>(null);
+  const isOpenTabsLoaded = ref(false);
+  const activeTabHistory = ref<string[]>([]);
+  const showCloseConfirm = ref(false);
+  const pendingCloseTabId = ref<string | null>(null);
+  const pendingBatchCloseTabIds = ref<string[] | null>(null);
+  const pendingBatchCloseFinalActiveTabId = ref<string | null | undefined>(undefined);
+  const isConfirmingAppClose = ref(false);
+  const closeConfirmContext = ref<CloseConfirmContext>("tab");
+  const tableStructureRefreshVersions = ref<Record<string, number>>({});
+  const savedSqlEditorPositionTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  let resultCacheTrimScheduled = false;
+  let resultCacheTrimRunning = false;
+  let resultCacheTrimRequested = false;
+
+  function tableStructureKey(connectionId: string, database: string, schema: string | undefined, tableName: string): string {
+    return [connectionId, database, schema || "", tableName].map((part) => part.toLowerCase()).join("\u0000");
+  }
+
+  function invalidateTableStructure(connectionId: string, database: string, schema: string | undefined, tableName: string) {
+    if (!tableName) return;
+    const key = tableStructureKey(connectionId, database, schema, tableName);
+    tableStructureRefreshVersions.value = {
+      ...tableStructureRefreshVersions.value,
+      [key]: (tableStructureRefreshVersions.value[key] ?? 0) + 1,
+    };
+  }
+
+  function tableStructureRefreshVersion(connectionId: string, database: string, schema: string | undefined, tableName: string): number {
+    return tableStructureRefreshVersions.value[tableStructureKey(connectionId, database, schema, tableName)] ?? 0;
+  }
+  const MAX_CACHED_RESULTS = 5;
+
+  async function closeResultSession(tab: QueryTab | undefined, preserveSessionId?: string) {
+    const sessionId = tab?.resultSessionId ?? tab?.result?.session_id;
+    if (!tab || !sessionId || sessionId === preserveSessionId) return;
+    try {
+      const catalog = tab.mode === "data" ? tab.tableMeta?.catalog : undefined;
+      const connection = catalog ? useConnectionStore().getConfig(tab.connectionId) : undefined;
+      const executionDatabase = dataTabExecutionDatabase(connection, tab.database, catalog);
+      await api.closeQuerySession(tab.connectionId, executionDatabase, sessionId, tab.id);
+    } catch (error) {
+      console.warn("[DBX][query-session:close:error]", { tabId: tab.id, sessionId, error });
+    } finally {
+      if (tab.resultSessionId === sessionId) tab.resultSessionId = undefined;
+      if (tab.result?.session_id === sessionId) tab.result.session_id = undefined;
+    }
+  }
+
+  async function closeClientSessionId(connectionId: string, database: string, clientSessionId: string, logContext: Record<string, unknown> = {}) {
+    try {
+      await api.closeClientConnectionSession(connectionId, database, clientSessionId);
+    } catch (error) {
+      console.warn("[DBX][client-session:close:error]", { ...logContext, clientSessionId, error });
+    }
+  }
+
+  async function closeClientConnectionSession(tab: QueryTab | undefined) {
+    if (!tab?.connectionId) return;
+    const catalog = tab.mode === "data" ? tab.tableMeta?.catalog : undefined;
+    const connection = catalog ? useConnectionStore().getConfig(tab.connectionId) : undefined;
+    const executionDatabase = dataTabExecutionDatabase(connection, tab.database, catalog);
+    const clientSessionIds = [...new Set([tabClientSessionId(tab), ...BACKGROUND_CLIENT_SESSION_SUFFIXES.map((suffix) => tabClientSessionId(tab, suffix)), tab.explainClientSessionId].filter((sessionId): sessionId is string => !!sessionId))];
+    for (const clientSessionId of clientSessionIds) {
+      await closeClientSessionId(tab.connectionId, executionDatabase, clientSessionId, { tabId: tab.id });
+    }
+  }
+
+  function touchResult(tab: QueryTab | undefined, accessedAt = Date.now()) {
+    if (tab?.result || tab?.results) {
+      tab.resultAccessedAt = accessedAt;
+      tab.resultCacheState = "memory";
+      tab.resultEvicted = undefined;
+    }
+  }
+
+  function clearResultPayload(tab: QueryTab, options: { evicted?: boolean } = {}) {
+    tab.result = undefined;
+    tab.results = undefined;
+    tab.activeResultIndex = undefined;
+    tab.resultLocalSortOriginalRows = undefined;
+    tab.resultLocalSortOriginalMongoDocuments = undefined;
+    tab.resultSortMode = undefined;
+    tab.resultSessionId = undefined;
+    tab.resultAccessedAt = undefined;
+    tab.queryAnalysis = undefined;
+    tab.querySourceColumns = undefined;
+    tab.queryEditabilityReason = undefined;
+    tab.mongoEditTarget = undefined;
+    if (tab.mode === "query") tab.tableMeta = undefined;
+    tab.resultEvicted = options.evicted ? true : undefined;
+    tab.resultCacheState = options.evicted ? tab.resultCacheState : undefined;
+    if (!options.evicted) {
+      if (tab.resultCacheKey) void deleteTabResultSnapshot(tab.resultCacheKey);
+      tab.resultCacheKey = undefined;
+    }
+  }
+
+  function clearResultRunSnapshots(tab: QueryTab) {
+    for (const run of tab.resultRuns ?? []) {
+      if (run.resultCacheKey) void deleteTabResultSnapshot(run.resultCacheKey);
+    }
+  }
+
+  function clearResultRunPayload(run: NonNullable<QueryTab["resultRuns"]>[number], options: { evicted?: boolean } = {}) {
+    run.result = undefined;
+    run.results = undefined;
+    run.resultLocalSortOriginalRows = undefined;
+    run.resultLocalSortOriginalMongoDocuments = undefined;
+    run.resultSessionId = undefined;
+    run.queryAnalysis = undefined;
+    run.querySourceColumns = undefined;
+    run.queryEditabilityReason = undefined;
+    run.mongoEditTarget = undefined;
+    run.tableMeta = undefined;
+    run.resultEvicted = options.evicted ? true : undefined;
+    run.resultCacheState = options.evicted ? "disk" : undefined;
+  }
+
+  function projectResultRun(tab: QueryTab, run: NonNullable<QueryTab["resultRuns"]>[number]) {
+    const activeIndex = run.activeResultIndex ?? 0;
+    tab.activeResultRunId = run.id;
+    tab.result = run.result ?? run.results?.[activeIndex];
+    tab.results = run.results;
+    tab.activeResultIndex = run.activeResultIndex;
+    tab.resultBaseSql = run.resultBaseSql;
+    tab.resultSortedSql = run.resultSortedSql;
+    tab.resultSortColumn = run.resultSortColumn;
+    tab.resultSortColumnIndex = run.resultSortColumnIndex;
+    tab.resultSortDirection = run.resultSortDirection;
+    tab.resultSortMode = run.resultSortMode;
+    tab.resultLocalSortOriginalRows = run.resultLocalSortOriginalRows;
+    tab.resultLocalSortOriginalMongoDocuments = run.resultLocalSortOriginalMongoDocuments;
+    tab.orderByInput = run.orderByInput;
+    tab.resultPageSql = run.resultPageSql;
+    tab.resultPageLimit = run.resultPageLimit;
+    tab.resultPageOffset = run.resultPageOffset;
+    tab.resultCountSql = run.resultCountSql;
+    tab.resultTotalRowCount = run.resultTotalRowCount;
+    tab.resultTotalRowCountLoading = run.resultTotalRowCountLoading;
+    tab.resultSessionId = run.resultSessionId;
+    tab.resultAccessedAt = run.resultAccessedAt;
+    tab.resultCacheKey = run.resultCacheKey;
+    tab.resultCacheState = run.resultCacheState;
+    tab.resultEvicted = run.resultEvicted;
+    tab.queryAnalysis = run.queryAnalysis;
+    tab.querySourceColumns = run.querySourceColumns;
+    tab.queryEditabilityReason = run.queryEditabilityReason;
+    tab.mongoEditTarget = run.mongoEditTarget;
+    tab.tableMeta = run.tableMeta;
+    touchResult(tab);
+  }
+
+  async function restoreResultRunPayload(tab: QueryTab, runId: string) {
+    const run = tab.resultRuns?.find((item) => item.id === runId);
+    if (!run || run.result || run.results?.length) return run;
+
+    const cacheKey = run.resultCacheKey ?? tab.resultCacheKey;
+    if (!cacheKey) return run;
+
+    const snapshot = await readTabResultSnapshot(cacheKey);
+    const snapshotRun = snapshot?.resultRuns?.find((item) => item.id === runId);
+    if (!snapshotRun) return run;
+
+    const restoredRun = markQueryResultRunsRowsRaw([
+      {
+        ...run,
+        ...snapshotRun,
+        result: snapshotRun.result ? markQueryResultRowsRaw(snapshotRun.result) : undefined,
+        results: snapshotRun.results ? markQueryResultsRowsRaw(snapshotRun.results) : undefined,
+        resultCacheState: "memory" as const,
+      },
+    ])[0]!;
+    tab.resultRuns = tab.resultRuns?.map((item) => (item.id === runId ? restoredRun : item));
+    return restoredRun;
+  }
+
+  async function setActiveResultRun(id: string, runId: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab) return false;
+    const run = await restoreResultRunPayload(tab, runId);
+    if (!run?.result && !run?.results?.length) return false;
+    projectResultRun(tab, run);
+    evictInactiveResultRunPayloads(tab);
+    return true;
+  }
+
+  async function removeResultRun(id: string, runId: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    const runIndex = tab?.resultRuns?.findIndex((run) => run.id === runId) ?? -1;
+    if (!tab || !tab.resultRuns || runIndex < 0) return false;
+
+    const removedRun = tab.resultRuns[runIndex];
+    if (removedRun?.resultCacheKey) void deleteTabResultSnapshot(removedRun.resultCacheKey);
+    const wasActive = tab.activeResultRunId === runId;
+    const remainingRuns = tab.resultRuns.filter((run) => run.id !== runId);
+    tab.resultRuns = remainingRuns;
+
+    if (!wasActive) return true;
+
+    const adjacentIndex = Math.min(runIndex, remainingRuns.length - 1);
+    for (let offset = 0; offset < remainingRuns.length; offset += 1) {
+      const candidate = remainingRuns[(adjacentIndex + offset) % remainingRuns.length];
+      // Disk-backed runs may have missing or unreadable snapshots; keep searching before clearing output.
+      if (candidate && (await setActiveResultRun(id, candidate.id))) return true;
+    }
+
+    tab.activeResultRunId = undefined;
+    clearResultPayload(tab);
+    return true;
+  }
+
+  function nextResultRunSequence(tab: QueryTab): number {
+    return (tab.resultRuns?.reduce((max, run) => Math.max(max, run.sequence), 0) ?? 0) + 1;
+  }
+
+  function persistResultRun(tab: QueryTab, run: NonNullable<QueryTab["resultRuns"]>[number]): Promise<boolean> {
+    const key = run.resultCacheKey ?? resultRunCacheKey(tab.id, run.id);
+    run.resultCacheKey = key;
+    run.resultCacheState = "memory";
+    return writeTabResultSnapshot(key, {
+      result: run.result,
+      results: run.results,
+      activeResultIndex: run.activeResultIndex,
+      resultRuns: [run],
+      activeResultRunId: run.id,
+      queryAnalysis: run.queryAnalysis,
+      querySourceColumns: run.querySourceColumns,
+      queryEditabilityReason: run.queryEditabilityReason,
+      tableMeta: run.tableMeta,
+      resultPageSql: run.resultPageSql,
+      resultPageLimit: run.resultPageLimit,
+      resultPageOffset: run.resultPageOffset,
+      resultCountSql: run.resultCountSql,
+      resultTotalRowCount: run.resultTotalRowCount,
+      cachedAt: Date.now(),
+    });
+  }
+
+  function evictInactiveResultRunPayloads(tab: QueryTab) {
+    const activeRunId = tab.activeResultRunId;
+    if (!activeRunId || !tab.resultRuns?.length) return;
+
+    for (const run of tab.resultRuns) {
+      if (run.id === activeRunId || !resultRunHasPayload(run)) continue;
+      const runId = run.id;
+      void persistResultRun(tab, run).then((cached) => {
+        const currentRun = tab.resultRuns?.find((item) => item.id === runId);
+        if (!cached || !currentRun || currentRun.id === tab.activeResultRunId || !resultRunHasPayload(currentRun)) return;
+        if (tab.result === currentRun.result || (currentRun.results && tab.results === currentRun.results)) return;
+        clearResultRunPayload(currentRun, { evicted: true });
+      });
+    }
+  }
+
+  function captureDisplayedResultRun(tab: QueryTab, sql: string, createdAt = Date.now()) {
+    if (tab.mode !== "query" || !tab.result) return;
+    const sequence = nextResultRunSequence(tab);
+    const run: NonNullable<QueryTab["resultRuns"]>[number] = {
+      id: uuid(),
+      title: `Run ${sequence}`,
+      sequence,
+      sql,
+      createdAt,
+      result: tab.result,
+      results: tab.results,
+      activeResultIndex: tab.activeResultIndex,
+      resultBaseSql: tab.resultBaseSql,
+      resultSortedSql: tab.resultSortedSql,
+      resultSortColumn: tab.resultSortColumn,
+      resultSortColumnIndex: tab.resultSortColumnIndex,
+      resultSortDirection: tab.resultSortDirection,
+      resultSortMode: tab.resultSortMode,
+      resultLocalSortOriginalRows: tab.resultLocalSortOriginalRows,
+      resultLocalSortOriginalMongoDocuments: tab.resultLocalSortOriginalMongoDocuments,
+      orderByInput: tab.orderByInput,
+      resultPageSql: tab.resultPageSql,
+      resultPageLimit: tab.resultPageLimit,
+      resultPageOffset: tab.resultPageOffset,
+      resultCountSql: tab.resultCountSql,
+      resultTotalRowCount: tab.resultTotalRowCount,
+      resultTotalRowCountLoading: tab.resultTotalRowCountLoading,
+      resultSessionId: tab.resultSessionId,
+      resultAccessedAt: tab.resultAccessedAt,
+      resultCacheKey: tab.resultCacheKey,
+      resultCacheState: tab.resultCacheState,
+      resultEvicted: tab.resultEvicted,
+      queryAnalysis: tab.queryAnalysis,
+      querySourceColumns: tab.querySourceColumns,
+      queryEditabilityReason: tab.queryEditabilityReason,
+      mongoEditTarget: tab.mongoEditTarget,
+      tableMeta: tab.tableMeta,
+    };
+    void persistResultRun(tab, run);
+    tab.resultRuns = [...(tab.resultRuns ?? []), run];
+    tab.activeResultRunId = run.id;
+    evictInactiveResultRunPayloads(tab);
+  }
+
+  function toggleResultAutoSave(id: string): boolean {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab || tab.mode !== "query") return false;
+    tab.resultAutoSave = tab.resultAutoSave ? undefined : true;
+    if (tab.resultAutoSave && tab.result && !tab.activeResultRunId) {
+      captureDisplayedResultRun(tab, tab.resultBaseSql ?? tab.lastExecutedSql ?? tab.sql);
+    }
+    return tab.resultAutoSave === true;
+  }
+
+  function syncActiveResultRunFromDisplayed(tab: QueryTab) {
+    if (!tab.activeResultRunId || !tab.resultRuns?.length) return;
+    const index = tab.resultRuns.findIndex((run) => run.id === tab.activeResultRunId);
+    if (index < 0) return;
+    const run = {
+      ...tab.resultRuns[index],
+      result: tab.result,
+      results: tab.results,
+      activeResultIndex: tab.activeResultIndex,
+      resultBaseSql: tab.resultBaseSql,
+      resultSortedSql: tab.resultSortedSql,
+      resultSortColumn: tab.resultSortColumn,
+      resultSortColumnIndex: tab.resultSortColumnIndex,
+      resultSortDirection: tab.resultSortDirection,
+      resultSortMode: tab.resultSortMode,
+      resultLocalSortOriginalRows: tab.resultLocalSortOriginalRows,
+      resultLocalSortOriginalMongoDocuments: tab.resultLocalSortOriginalMongoDocuments,
+      orderByInput: tab.orderByInput,
+      resultPageSql: tab.resultPageSql,
+      resultPageLimit: tab.resultPageLimit,
+      resultPageOffset: tab.resultPageOffset,
+      resultCountSql: tab.resultCountSql,
+      resultTotalRowCount: tab.resultTotalRowCount,
+      resultTotalRowCountLoading: tab.resultTotalRowCountLoading,
+      resultSessionId: tab.resultSessionId,
+      resultAccessedAt: tab.resultAccessedAt,
+      resultCacheKey: tab.resultCacheKey,
+      resultCacheState: tab.resultCacheState,
+      resultEvicted: tab.resultEvicted,
+      queryAnalysis: tab.queryAnalysis,
+      querySourceColumns: tab.querySourceColumns,
+      queryEditabilityReason: tab.queryEditabilityReason,
+      mongoEditTarget: tab.mongoEditTarget,
+      tableMeta: tab.tableMeta,
+    };
+    void persistResultRun(tab, run);
+    tab.resultRuns[index] = run;
+  }
+
+  function syncDisplayedResultRun(tab: QueryTab, sql: string) {
+    if (tab.mode !== "query" || !tab.result) return;
+    if (tab.activeResultRunId) {
+      syncActiveResultRunFromDisplayed(tab);
+    } else if (tab.resultAutoSave) {
+      captureDisplayedResultRun(tab, sql);
+    }
+  }
+
+  function assignDisplayedResult(tab: QueryTab, result: QueryResult) {
+    tab.result = markQueryResultRowsRaw(result);
+    if (tab.results?.length) {
+      const activeIndex = tab.activeResultIndex ?? 0;
+      if (activeIndex >= 0 && activeIndex < tab.results.length) {
+        tab.results[activeIndex] = tab.result;
+      }
+    }
+  }
+
+  function sortTabResultLocally(id: string, column: string, columnIndex: number, direction: DataGridSortDirection | null) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab?.result) return;
+
+    if (!tab.resultLocalSortOriginalRows) {
+      tab.resultLocalSortOriginalRows = tab.result.rows.slice();
+      tab.resultLocalSortOriginalMongoDocuments = tab.result.mongo_documents?.slice();
+    }
+
+    const originalRows = tab.resultLocalSortOriginalRows;
+    const rowIndexes = direction ? sortDataGridRowIndexes(originalRows, columnIndex, direction) : originalRows.map((_, index) => index);
+    const rows = rowIndexes.map((index) => originalRows[index]!);
+    const originalMongoDocuments = tab.resultLocalSortOriginalMongoDocuments;
+    const mongo_documents = originalMongoDocuments ? rowIndexes.map((index) => originalMongoDocuments[index]) : undefined;
+    assignDisplayedResult(tab, { ...tab.result, rows, mongo_documents });
+
+    tab.resultSortColumn = direction ? column : undefined;
+    tab.resultSortColumnIndex = direction ? columnIndex : undefined;
+    tab.resultSortDirection = direction ?? undefined;
+    tab.resultSortMode = direction ? "local" : undefined;
+    tab.resultSortedSql = undefined;
+    if (!direction) {
+      tab.resultLocalSortOriginalRows = undefined;
+      tab.resultLocalSortOriginalMongoDocuments = undefined;
+    }
+
+    touchResult(tab);
+    syncDisplayedResultRun(tab, tab.resultBaseSql ?? tab.lastExecutedSql ?? tab.sql);
+  }
+
+  function resultRunHasPayload(run: NonNullable<QueryTab["resultRuns"]>[number]): boolean {
+    return !!run.result || !!run.results?.length;
+  }
+
+  function resultSnapshotHasPayload(snapshot: NonNullable<ReturnType<typeof buildTabResultSnapshot>>): boolean {
+    return !!snapshot.result || !!snapshot.results?.length || !!snapshot.resultRuns?.some(resultRunHasPayload);
+  }
+
+  async function evictCachedResult(tab: QueryTab) {
+    await closeResultSession(tab);
+    const cacheKey = tabResultCacheKey(tab.id);
+    const cached = await writeTabResultSnapshot(cacheKey, buildTabResultSnapshot(tab));
+    tab.resultCacheKey = cached ? cacheKey : undefined;
+    tab.resultCacheState = cached ? "disk" : "missing";
+    clearResultPayload(tab, { evicted: true });
+  }
+
+  function applyRestoredOpenTabs(restored: { tabs: QueryTab[]; activeTabId: string | null }) {
+    tabs.value = restored.tabs;
+    activeTabId.value = restored.activeTabId;
+    activeTabHistory.value = restored.activeTabId ? [restored.activeTabId] : [];
+    for (const tab of restored.tabs) {
+      if (tab.mode === "data") void deleteTabResultSnapshot(tabResultCacheKey(tab.id));
+    }
+  }
+
+  async function initOpenTabs() {
+    if (isOpenTabsLoaded.value) return;
+    const saved = await api.loadOpenTabsState().catch(() => null);
+    if (saved?.tabs && Array.isArray(saved.tabs)) {
+      const restored = restoreSavedTabsFromPayload(saved);
+      applyRestoredOpenTabs(restored);
+      if (useSettingsStore().editorSettings.openTabsRestoreMode === "none") {
+        // Restore is explicitly disabled, so stale saved payloads should not
+        // reappear if the user later changes the setting.
+        clearLegacySavedTabs();
+        await saveTabs(tabs.value, activeTabId.value).catch(() => undefined);
+      }
+      isOpenTabsLoaded.value = true;
+      return;
+    }
+
+    const legacy = loadLegacySavedTabs();
+    if (legacy.rawTabs || legacy.rawActiveTabId) {
+      const restored = restoreLegacySavedTabs();
+      applyRestoredOpenTabs(restored);
+      if (useSettingsStore().editorSettings.openTabsRestoreMode === "none") {
+        // Restore is explicitly disabled, so keeping the legacy startup payload
+        // would resurrect old tabs if the user later changes the setting.
+        clearLegacySavedTabs();
+        isOpenTabsLoaded.value = true;
+        return;
+      }
+      try {
+        await saveTabs(tabs.value, activeTabId.value);
+        // Keep old desktop installs readable until the async store has the
+        // migrated state; only then remove the synchronous startup payload.
+        clearLegacySavedTabs();
+      } catch {
+        /* keep legacy values for a later migration attempt */
+      }
+    }
+    isOpenTabsLoaded.value = true;
+  }
+
+  const _persistSnapshot = computed(() =>
+    tabs.value.map((t) => ({
+      id: t.id,
+      title: t.title,
+      connectionId: t.connectionId,
+      database: t.database,
+      schema: t.schema,
+      sql: t.sql,
+      savedSqlId: t.savedSqlId,
+      externalSqlPath: t.externalSqlPath,
+      lastExecutedSql: t.lastExecutedSql,
+      resultBaseSql: t.resultBaseSql,
+      resultSortedSql: t.resultSortedSql,
+      resultSortColumn: t.resultSortColumn,
+      resultSortColumnIndex: t.resultSortColumnIndex,
+      resultSortDirection: t.resultSortDirection,
+      resultSortMode: t.resultSortMode,
+      orderByInput: t.orderByInput,
+      resultPageLimit: t.resultPageLimit,
+      resultPageOffset: t.resultPageOffset,
+      whereInput: t.whereInput,
+      pinned: t.pinned,
+      mode: t.mode,
+      resultAutoSave: t.resultAutoSave,
+      structureTableName: t.structureTableName,
+      objectBrowser: t.objectBrowser,
+      objectSource: t.objectSource,
+      tableMeta: t.tableMeta,
+      mongoEditTarget: t.mongoEditTarget,
+      resultEvicted: t.resultEvicted,
+      resultCacheKey: t.resultCacheKey,
+    })),
+  );
+
+  let _persistTimer: ReturnType<typeof setTimeout> | null = null;
+  watch(
+    [_persistSnapshot, activeTabId],
+    () => {
+      if (_persistTimer) clearTimeout(_persistTimer);
+      _persistTimer = setTimeout(() => {
+        void saveTabs(tabs.value, activeTabId.value).catch(() => {});
+        _persistTimer = null;
+      }, 300);
+    },
+    { flush: "post" },
+  );
+
+  // Immediately flush any pending debounced persist so the on-disk content
+  // reflects the latest in-memory tabs without waiting for the 300ms debounce.
+  // Lets callers (e.g. tests that reload the store) read back persisted state
+  // deterministically instead of racing the debounce timer.
+  function flushPendingPersist(): Promise<void> {
+    if (_persistTimer) {
+      clearTimeout(_persistTimer);
+      _persistTimer = null;
+    }
+    return saveTabs(tabs.value, activeTabId.value);
+  }
+
+  function findTabByIdentity(connectionId: string, database: string, title: string, mode: QueryTab["mode"], schema?: string) {
+    return tabs.value.find((tab) => tab.connectionId === connectionId && tab.database === database && tab.title === title && tab.mode === mode && (tab.schema || "") === (schema || ""));
+  }
+
+  function createTab(connectionId: string, database: string, title?: string, mode: QueryTab["mode"] = "query", schema?: string) {
+    if (title) {
+      const existing = findTabByIdentity(connectionId, database, title, mode, schema);
+      if (existing) {
+        switchTab(existing.id);
+        return existing.id;
+      }
+    }
+
+    const id = uuid();
+    const tab: QueryTab = {
+      id,
+      title: title || `query_${tabs.value.length + 1}`,
+      customTitle: mode === "query" && !!title ? true : undefined,
+      connectionId,
+      database,
+      schema,
+      sql: "",
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode,
+    };
+    if (mode === "query") tab.originalSql = "";
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    return id;
+  }
+
+  function refreshExternalSqlFileTitles() {
+    const externalTabs = tabs.value.filter((tab) => tab.mode === "query" && tab.externalSqlPath);
+    const titles = externalSqlFileDisplayTitles(externalTabs.map((tab) => tab.externalSqlPath!));
+    externalTabs.forEach((tab, index) => {
+      tab.title = titles[index];
+      tab.customTitle = true;
+    });
+  }
+
+  function openExternalSqlFile(connectionId: string, database: string, path: string, sql: string) {
+    const normalizedPath = normalizeExternalSqlPath(path);
+    const existing = tabs.value.find((tab) => tab.mode === "query" && tab.externalSqlPath && normalizeExternalSqlPath(tab.externalSqlPath) === normalizedPath);
+    if (existing) {
+      switchTab(existing.id);
+      return existing.id;
+    }
+
+    // File-backed tabs are identified by their full path, not their basename.
+    // Bypassing createTab avoids overwriting another file with the same name.
+    const id = uuid();
+    const tab: QueryTab = {
+      id,
+      title: "",
+      customTitle: true,
+      connectionId,
+      database,
+      sql,
+      originalSql: sql,
+      externalSqlPath: path,
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode: "query",
+    };
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    refreshExternalSqlFileTitles();
+    return id;
+  }
+
+  function openObjectBrowser(connectionId: string, database: string, schema?: string, catalog?: string) {
+    const title = catalog ? `${catalog}.${database} objects` : schema ? `${schema} objects` : `${database} objects`;
+    const existing = tabs.value.find((tab) => tab.mode === "objects" && tab.connectionId === connectionId && tab.database === database && (tab.objectBrowser?.catalog || "") === (catalog || "") && (tab.objectBrowser?.schema || "") === (schema || ""));
+    if (existing) {
+      switchTab(existing.id);
+      return existing.id;
+    }
+
+    const id = uuid();
+    const tab: QueryTab = {
+      id,
+      title,
+      connectionId,
+      database,
+      schema,
+      sql: "",
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode: "objects",
+      objectBrowser: {
+        catalog,
+        schema,
+        objectType: "tables",
+      },
+    };
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    return id;
+  }
+
+  function switchTab(tabId: string) {
+    activeTabId.value = tabId;
+    settingsStore.settingsPageActive = false;
+  }
+
+  function openUserAdmin(connectionId: string) {
+    const existing = tabs.value.find((tab) => tab.mode === "users" && tab.connectionId === connectionId);
+    if (existing) {
+      switchTab(existing.id);
+      return existing.id;
+    }
+
+    const conn = useConnectionStore().getConfig(connectionId);
+    const id = uuid();
+    const tab: QueryTab = {
+      id,
+      title: t("userAdmin.title"),
+      connectionId,
+      database: conn?.database || "",
+      sql: "",
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode: "users",
+    };
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    return id;
+  }
+
+  function openDamengJobAdmin(connectionId: string) {
+    const existing = tabs.value.find((tab) => tab.mode === "dameng-jobs" && tab.connectionId === connectionId);
+    if (existing) {
+      switchTab(existing.id);
+      return existing.id;
+    }
+
+    const conn = useConnectionStore().getConfig(connectionId);
+    const id = uuid();
+    const tab: QueryTab = {
+      id,
+      title: t("damengJobAdmin.title"),
+      connectionId,
+      database: conn?.database || "",
+      sql: "",
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode: "dameng-jobs",
+    };
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    return id;
+  }
+
+  function openMongoBucket(connectionId: string, database: string, bucketName: string) {
+    const title = `${database}.${bucketName}`;
+    const existing = tabs.value.find((tab) => tab.mode === "mongo-bucket" && tab.connectionId === connectionId && tab.database === database && tab.mongoBucket?.bucketName === bucketName);
+    if (existing) {
+      switchTab(existing.id);
+      return existing.id;
+    }
+
+    const id = uuid();
+    const tab: QueryTab = {
+      id,
+      title,
+      connectionId,
+      database,
+      sql: bucketName,
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode: "mongo-bucket",
+      mongoBucket: {
+        bucketName,
+      },
+    };
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    return id;
+  }
+
+  function openMongoGridFs(connectionId: string, database: string) {
+    const existing = tabs.value.find((tab) => tab.mode === "mongo-gridfs" && tab.connectionId === connectionId && tab.database === database);
+    if (existing) {
+      switchTab(existing.id);
+      return existing.id;
+    }
+
+    const id = uuid();
+    const tab: QueryTab = {
+      id,
+      title: "GridFS",
+      connectionId,
+      database,
+      sql: "",
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode: "mongo-gridfs",
+    };
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    return id;
+  }
+
+  function openMqAdmin(connectionId: string, target?: { tenant?: string; initialTab?: QueryTab["mqInitialTab"] }) {
+    const existing = tabs.value.find((tab) => tab.mode === "mq" && tab.connectionId === connectionId);
+    if (existing) {
+      if (target?.tenant) existing.mqTenant = target.tenant;
+      if (target?.initialTab) existing.mqInitialTab = target.initialTab;
+      switchTab(existing.id);
+      return existing.id;
+    }
+
+    const conn = useConnectionStore().getConfig(connectionId);
+    const id = uuid();
+    const tab: QueryTab = {
+      id,
+      title: `${conn?.name || "Message Queue"} Admin`,
+      connectionId,
+      database: conn?.database || "",
+      sql: "",
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode: "mq",
+      mqTenant: target?.tenant,
+      mqInitialTab: target?.initialTab,
+    };
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    return id;
+  }
+
+  function openNacosAdmin(connectionId: string, target?: { namespace?: string; namespaceName?: string }) {
+    const namespace = target?.namespace ?? "";
+    const namespaceName = target?.namespaceName || (namespace ? namespace : "public");
+    const existing = tabs.value.find((tab) => tab.mode === "nacos" && tab.connectionId === connectionId && (tab.nacosNamespace || "") === namespace);
+    if (existing) {
+      existing.nacosNamespaceName = namespaceName;
+      if (!existing.customTitle) existing.title = `${useConnectionStore().getConfig(connectionId)?.name || "Nacos"}:${namespaceName}`;
+      switchTab(existing.id);
+      return existing.id;
+    }
+
+    const conn = useConnectionStore().getConfig(connectionId);
+    const id = uuid();
+    const tab: QueryTab = {
+      id,
+      title: `${conn?.name || "Nacos"}:${namespaceName}`,
+      connectionId,
+      database: conn?.database || "",
+      sql: "",
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode: "nacos",
+      nacosNamespace: namespace,
+      nacosNamespaceName: namespaceName,
+    };
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    return id;
+  }
+
+  function applyTableStructureInitialTab(tab: QueryTab, initialTab?: TableInfoTab, initialTarget?: TableStructureEditorTarget) {
+    if (!initialTab && !initialTarget?.name) return;
+    if (initialTab) tab.structureInitialTab = initialTab;
+    tab.structureInitialTarget = initialTarget?.name ? initialTarget : undefined;
+    tab.structureInitialTabRequestId = (tab.structureInitialTabRequestId ?? 0) + 1;
+  }
+
+  function openTableStructure(connectionId: string, database: string, schema?: string, tableName?: string, initialTab?: TableInfoTab, initialTarget?: TableStructureEditorTarget) {
+    const resolvedTableName = tableName || "";
+    if (resolvedTableName) {
+      const existing = tabs.value.find((tab) => tab.mode === "structure" && tab.connectionId === connectionId && tab.database === database && (tab.structureTableName || "") === resolvedTableName);
+      if (existing) {
+        applyTableStructureInitialTab(existing, initialTab, initialTarget);
+        switchTab(existing.id);
+        return existing.id;
+      }
+    }
+
+    const title = resolvedTableName ? t("structureEditor.editTabTitle", { tableName: resolvedTableName }) : t("structureEditor.createTitle");
+    const id = uuid();
+    const tab: QueryTab = {
+      id,
+      title,
+      connectionId,
+      database,
+      schema,
+      sql: "",
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode: "structure",
+      structureTableName: resolvedTableName,
+      structureInitialTab: initialTab,
+      structureInitialTabRequestId: initialTab || initialTarget?.name ? 1 : undefined,
+      structureInitialTarget: initialTarget?.name ? initialTarget : undefined,
+    };
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    return id;
+  }
+
+  function isTabDirty(tab: QueryTab): boolean {
+    if (tab.mode !== "query") return false;
+    if (!tab.externalSqlPath && !tab.sql.trim()) return false;
+    const original = tab.originalSql;
+    if (original === undefined) return !!tab.savedSqlId;
+    return tab.sql !== original;
+  }
+
+  const hasDirtyTabs = computed(() => tabs.value.some((tab) => isTabDirty(tab)));
+  const shouldConfirmUnsavedSqlClose = computed(() => useSettingsStore().editorSettings.confirmUnsavedSqlClose);
+
+  const closeConfirmDirtyTabIds = computed(() => {
+    if (isConfirmingAppClose.value) return tabs.value.filter((tab) => isTabDirty(tab)).map((tab) => tab.id);
+    if (pendingBatchCloseTabIds.value) {
+      return pendingBatchCloseTabIds.value
+        .map((id) => tabs.value.find((tab) => tab.id === id))
+        .filter((tab): tab is QueryTab => !!tab && isTabDirty(tab))
+        .map((tab) => tab.id);
+    }
+    const pendingTab = pendingCloseTabId.value ? tabs.value.find((tab) => tab.id === pendingCloseTabId.value) : undefined;
+    return pendingTab && isTabDirty(pendingTab) ? [pendingTab.id] : [];
+  });
+
+  function showDirtyTabCloseConfirm(tab: QueryTab, context: CloseConfirmContext) {
+    pendingCloseTabId.value = tab.id;
+    closeConfirmContext.value = context;
+    activeTabId.value = tab.id;
+    showCloseConfirm.value = true;
+  }
+
+  function markTabClean(tab: QueryTab | undefined) {
+    if (tab) tab.originalSql = tab.sql;
+  }
+
+  function persistSavedSqlEditorPosition(tab: QueryTab | undefined) {
+    if (!tab?.savedSqlId || tab.mode !== "query") return;
+    const pending = savedSqlEditorPositionTimers.get(tab.savedSqlId);
+    if (pending) {
+      clearTimeout(pending);
+      savedSqlEditorPositionTimers.delete(tab.savedSqlId);
+    }
+    saveSavedSqlEditorPosition(
+      createSavedSqlEditorPosition({
+        savedSqlId: tab.savedSqlId,
+        sql: tab.sql,
+        selection: tab.editorSelection,
+        viewport: tab.editorViewport,
+      }),
+    );
+  }
+
+  function queueSavedSqlEditorPositionPersist(tab: QueryTab | undefined) {
+    if (!tab?.savedSqlId || tab.mode !== "query") return;
+    const pending = savedSqlEditorPositionTimers.get(tab.savedSqlId);
+    if (pending) clearTimeout(pending);
+    const tabId = tab.id;
+    const savedSqlId = tab.savedSqlId;
+    const timer = setTimeout(() => {
+      savedSqlEditorPositionTimers.delete(savedSqlId);
+      persistSavedSqlEditorPosition(tabs.value.find((item) => item.id === tabId));
+    }, SAVED_SQL_EDITOR_POSITION_PERSIST_DELAY_MS);
+    savedSqlEditorPositionTimers.set(savedSqlId, timer);
+  }
+
+  function discardTabChanges(id: string) {
+    const tab = tabs.value.find((item) => item.id === id);
+    if (!tab || tab.mode !== "query") return false;
+    if (tab.originalSql !== undefined) {
+      tab.sql = tab.originalSql;
+      return true;
+    }
+    if (tab.savedSqlId) {
+      tab.sql = "";
+      return true;
+    }
+    tab.sql = "";
+    tab.originalSql = "";
+    return true;
+  }
+
+  function finishPendingBatchClose() {
+    const finalActiveTabId = pendingBatchCloseFinalActiveTabId.value;
+    pendingBatchCloseTabIds.value = null;
+    pendingBatchCloseFinalActiveTabId.value = undefined;
+    if (finalActiveTabId !== undefined) {
+      activeTabId.value = finalActiveTabId && tabs.value.some((tab) => tab.id === finalActiveTabId) ? finalActiveTabId : null;
+    }
+  }
+
+  function continuePendingBatchClose() {
+    const pendingIds = pendingBatchCloseTabIds.value;
+    if (!pendingIds) return;
+
+    const remainingIds = pendingIds.filter((id) => tabs.value.some((tab) => tab.id === id));
+    pendingBatchCloseTabIds.value = remainingIds;
+    if (remainingIds.length === 0) {
+      finishPendingBatchClose();
+      return;
+    }
+
+    const dirtyTab = shouldConfirmUnsavedSqlClose.value ? remainingIds.map((id) => tabs.value.find((tab) => tab.id === id)).find((tab): tab is QueryTab => !!tab && isTabDirty(tab)) : undefined;
+    if (dirtyTab) {
+      // Batch close must pause before dropping dirty query tabs so the existing save/discard dialog can protect unsaved SQL.
+      showDirtyTabCloseConfirm(dirtyTab, "batch");
+      return;
+    }
+
+    finishPendingBatchClose();
+    for (const id of remainingIds) closeTab(id, { force: true });
+  }
+
+  function beginBatchClose(ids: string[], finalActiveTabId?: string | null) {
+    const uniqueIds = [...new Set(ids)].filter((id) => tabs.value.some((tab) => tab.id === id));
+    if (uniqueIds.length === 0) return;
+    pendingBatchCloseTabIds.value = uniqueIds;
+    pendingBatchCloseFinalActiveTabId.value = finalActiveTabId;
+    continuePendingBatchClose();
+  }
+
+  function resumePendingBatchCloseAfter(id: string) {
+    const pendingIds = pendingBatchCloseTabIds.value;
+    if (!pendingIds?.includes(id)) return;
+    pendingBatchCloseTabIds.value = pendingIds.filter((pendingId) => pendingId !== id);
+    continuePendingBatchClose();
+  }
+
+  function closeTab(id: string, { force = false }: { force?: boolean } = {}) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab) return;
+    if (!force && shouldConfirmUnsavedSqlClose.value && isTabDirty(tab)) {
+      showDirtyTabCloseConfirm(tab, "tab");
+      return;
+    }
+    const idx = tabs.value.findIndex((t) => t.id === id);
+    if (idx < 0) return;
+    persistSavedSqlEditorPosition(tabs.value[idx]);
+    clearDataGridPendingSnapshotsForTab(id);
+    if (tabs.value[idx].txnSessionId) void rollbackTransaction(id);
+    if (tabs.value[idx].isExecuting) void cancelTabExecution(id);
+    if (tabs.value[idx].isExplaining) void cancelTabExplain(id);
+    void closeResultSession(tabs.value[idx]);
+    void closeClientConnectionSession(tabs.value[idx]);
+    clearResultRunSnapshots(tabs.value[idx]);
+    clearResultPayload(tabs.value[idx]);
+    tabs.value.splice(idx, 1);
+    if (tab.externalSqlPath) refreshExternalSqlFileTitles();
+    if (activeTabId.value === id) {
+      activeTabId.value = fallbackActiveTabAfterClose(id, idx);
+    }
+    if (force) resumePendingBatchCloseAfter(id);
+  }
+
+  function forceClosePendingTab() {
+    const id = pendingCloseTabId.value;
+    const confirmingAppClose = isConfirmingAppClose.value;
+    pendingCloseTabId.value = null;
+    showCloseConfirm.value = false;
+    closeConfirmContext.value = "tab";
+    if (confirmingAppClose) {
+      if (id) discardTabChanges(id);
+      isConfirmingAppClose.value = false;
+      return;
+    }
+    if (id) closeTab(id, { force: true });
+  }
+
+  function forceCloseAllPendingTabs() {
+    const dirtyIds = closeConfirmDirtyTabIds.value;
+    const pendingId = pendingCloseTabId.value;
+    const batchIds = pendingBatchCloseTabIds.value?.filter((id) => tabs.value.some((tab) => tab.id === id)) ?? null;
+    const finalActiveTabId = pendingBatchCloseFinalActiveTabId.value;
+    const confirmingAppClose = isConfirmingAppClose.value;
+
+    pendingCloseTabId.value = null;
+    showCloseConfirm.value = false;
+    pendingBatchCloseTabIds.value = null;
+    pendingBatchCloseFinalActiveTabId.value = undefined;
+    isConfirmingAppClose.value = false;
+    closeConfirmContext.value = "tab";
+
+    for (const id of dirtyIds) discardTabChanges(id);
+    if (confirmingAppClose) return;
+
+    const idsToClose = batchIds ?? (pendingId ? [pendingId] : []);
+    for (const id of idsToClose) closeTab(id, { force: true });
+    if (finalActiveTabId !== undefined) {
+      activeTabId.value = finalActiveTabId && tabs.value.some((tab) => tab.id === finalActiveTabId) ? finalActiveTabId : null;
+    }
+  }
+
+  function cancelClosePendingTab() {
+    pendingCloseTabId.value = null;
+    showCloseConfirm.value = false;
+    pendingBatchCloseTabIds.value = null;
+    pendingBatchCloseFinalActiveTabId.value = undefined;
+    isConfirmingAppClose.value = false;
+    closeConfirmContext.value = "tab";
+  }
+
+  function saveAndClosePendingTab() {
+    const id = pendingCloseTabId.value;
+    pendingCloseTabId.value = null;
+    showCloseConfirm.value = false;
+    isConfirmingAppClose.value = false;
+    closeConfirmContext.value = "tab";
+    if (id) return id;
+    return null;
+  }
+
+  function suspendCloseConfirm() {
+    showCloseConfirm.value = false;
+  }
+
+  function resumeCloseConfirm() {
+    const dirtyId = closeConfirmDirtyTabIds.value[0];
+    const dirtyTab = dirtyId ? tabs.value.find((tab) => tab.id === dirtyId) : undefined;
+    if (!dirtyTab) return false;
+    pendingCloseTabId.value = dirtyTab.id;
+    activeTabId.value = dirtyTab.id;
+    showCloseConfirm.value = true;
+    return true;
+  }
+
+  function completePendingCloseAfterSaveAll() {
+    const pendingId = pendingCloseTabId.value;
+    const batchIds = pendingBatchCloseTabIds.value?.filter((id) => tabs.value.some((tab) => tab.id === id)) ?? null;
+    const finalActiveTabId = pendingBatchCloseFinalActiveTabId.value;
+    const confirmingAppClose = isConfirmingAppClose.value;
+
+    pendingCloseTabId.value = null;
+    showCloseConfirm.value = false;
+    pendingBatchCloseTabIds.value = null;
+    pendingBatchCloseFinalActiveTabId.value = undefined;
+    isConfirmingAppClose.value = false;
+    closeConfirmContext.value = "tab";
+
+    if (confirmingAppClose) return "app" as const;
+
+    const idsToClose = batchIds ?? (pendingId ? [pendingId] : []);
+    for (const id of idsToClose) closeTab(id, { force: true });
+    if (finalActiveTabId !== undefined) {
+      activeTabId.value = finalActiveTabId && tabs.value.some((tab) => tab.id === finalActiveTabId) ? finalActiveTabId : null;
+    }
+    return "tabs" as const;
+  }
+
+  function closeOtherTabs(id: string) {
+    if (!tabs.value.some((tab) => tab.id === id)) return;
+    beginBatchClose(
+      tabs.value.filter((tab) => tab.id !== id).map((tab) => tab.id),
+      id,
+    );
+  }
+
+  function finalActiveTabAfterClosing(ids: string[]) {
+    const closingIds = new Set(ids);
+    const activeTab = activeTabId.value ? tabs.value.find((tab) => tab.id === activeTabId.value) : undefined;
+    if (activeTab && !closingIds.has(activeTab.id)) return activeTab.id;
+    return tabs.value.find((tab) => !closingIds.has(tab.id))?.id ?? null;
+  }
+
+  function closeOtherRegularTabs(id: string) {
+    const tab = tabs.value.find((item) => item.id === id);
+    if (!tab || tab.pinned) return;
+    beginBatchClose(
+      tabs.value.filter((item) => !item.pinned && item.id !== id).map((item) => item.id),
+      id,
+    );
+  }
+
+  function closeRegularTabs() {
+    const ids = tabs.value.filter((tab) => !tab.pinned).map((tab) => tab.id);
+    beginBatchClose(ids, finalActiveTabAfterClosing(ids));
+  }
+
+  function closeOtherFixedTabs(id: string) {
+    const tab = tabs.value.find((item) => item.id === id);
+    if (!tab || !tab.pinned) return;
+    beginBatchClose(
+      tabs.value.filter((item) => item.pinned && item.id !== id).map((item) => item.id),
+      id,
+    );
+  }
+
+  function closeFixedTabs() {
+    const ids = tabs.value.filter((tab) => tab.pinned).map((tab) => tab.id);
+    beginBatchClose(ids, finalActiveTabAfterClosing(ids));
+  }
+
+  function closeAllTabs() {
+    beginBatchClose(
+      tabs.value.map((tab) => tab.id),
+      null,
+    );
+  }
+
+  function requestAppCloseConfirmation() {
+    if (!shouldConfirmUnsavedSqlClose.value) return false;
+    const dirtyTab = tabs.value.find((tab) => isTabDirty(tab));
+    if (!dirtyTab) return false;
+    isConfirmingAppClose.value = true;
+    showDirtyTabCloseConfirm(dirtyTab, "app");
+    return true;
+  }
+
+  function duplicateTab(id: string) {
+    const idx = tabs.value.findIndex((t) => t.id === id);
+    if (idx < 0) return;
+    const original = tabs.value[idx];
+    const newId = uuid();
+    const newTab: QueryTab = {
+      id: newId,
+      title: original.title,
+      customTitle: original.customTitle,
+      connectionId: original.connectionId,
+      database: original.database,
+      schema: original.schema,
+      sql: original.sql,
+      savedSqlId: original.savedSqlId,
+      lastExecutedSql: undefined,
+      resultBaseSql: original.resultBaseSql,
+      resultSortedSql: undefined,
+      resultSortColumn: undefined,
+      resultSortColumnIndex: undefined,
+      resultSortDirection: undefined,
+      resultSortMode: undefined,
+      resultLocalSortOriginalRows: undefined,
+      resultLocalSortOriginalMongoDocuments: undefined,
+      orderByInput: undefined,
+      resultPageSql: undefined,
+      resultPageLimit: undefined,
+      resultPageOffset: undefined,
+      resultCountSql: undefined,
+      resultTotalRowCount: undefined,
+      resultTotalRowCountLoading: undefined,
+      resultSessionId: undefined,
+      resultAccessedAt: undefined,
+      resultCacheKey: undefined,
+      resultCacheState: undefined,
+      pinned: false,
+      result: undefined,
+      results: undefined,
+      activeResultIndex: undefined,
+      explainPlan: undefined,
+      explainError: undefined,
+      explainSql: undefined,
+      lastExplainedSql: undefined,
+      isExecuting: false,
+      isCancelling: false,
+      queryExecutionStartedAt: undefined,
+      editorViewport: undefined,
+      editorSelection: undefined,
+      executionId: undefined,
+      isExplaining: false,
+      explainExecutionId: undefined,
+      mode: original.mode,
+      mqTenant: original.mqTenant,
+      mqInitialTab: original.mqInitialTab,
+      nacosNamespace: original.nacosNamespace,
+      nacosNamespaceName: original.nacosNamespaceName,
+      structureTableName: original.structureTableName,
+      structureDraft: original.structureDraft ? cloneTabDraft(original.structureDraft) : undefined,
+      objectBrowser: original.objectBrowser ? { ...original.objectBrowser } : undefined,
+      objectSource: original.objectSource ? { ...original.objectSource } : undefined,
+      tableMeta: original.tableMeta ? { ...original.tableMeta, columns: [...original.tableMeta.columns], primaryKeys: [...original.tableMeta.primaryKeys] } : undefined,
+      queryAnalysis: original.queryAnalysis ? { ...original.queryAnalysis, sources: original.queryAnalysis.sources?.map((source) => ({ ...source })), columns: original.queryAnalysis.columns.map((c) => ({ ...c })) } : undefined,
+      querySourceColumns: original.querySourceColumns ? [...original.querySourceColumns] : undefined,
+      queryEditabilityReason: original.queryEditabilityReason,
+      resultEvicted: undefined,
+      whereInput: original.whereInput,
+      previewSql: original.previewSql,
+    };
+    tabs.value.splice(idx + 1, 0, newTab);
+    activeTabId.value = newId;
+  }
+
+  function closeTabsWhere(predicate: (tab: QueryTab) => boolean) {
+    const closingIds = new Set(tabs.value.filter((tab) => predicate(tab)).map((tab) => tab.id));
+    if (closingIds.size === 0) return;
+
+    tabs.value
+      .filter((tab) => closingIds.has(tab.id))
+      .forEach((tab) => {
+        clearDataGridPendingSnapshotsForTab(tab.id);
+        if (tab.txnSessionId) void rollbackTransaction(tab.id);
+        if (tab.isExecuting) void cancelTabExecution(tab.id);
+        if (tab.isExplaining) void cancelTabExplain(tab.id);
+        void closeResultSession(tab);
+        void closeClientConnectionSession(tab);
+        clearResultRunSnapshots(tab);
+        clearResultPayload(tab);
+      });
+
+    const activeClosingIndex = tabs.value.findIndex((tab) => tab.id === activeTabId.value && closingIds.has(tab.id));
+    tabs.value = tabs.value.filter((tab) => !closingIds.has(tab.id));
+    if (activeClosingIndex >= 0) {
+      activeTabId.value = tabs.value[Math.min(activeClosingIndex, tabs.value.length - 1)]?.id ?? null;
+    }
+  }
+
+  function closeConnectionTabs(connectionId: string) {
+    closeTabsWhere((tab) => tab.connectionId === connectionId);
+  }
+
+  function closeDatabaseTabs(connectionId: string, database: string) {
+    closeTabsWhere((tab) => tab.connectionId === connectionId && tab.database === database);
+  }
+
+  function tabMatchesDroppedTableObject(tab: QueryTab, target: DroppedTableObjectTarget): boolean {
+    if (tab.connectionId !== target.connectionId || tab.database !== target.database) return false;
+    const targetSchemas = droppedTableObjectSchemaCandidates(target);
+
+    if (tab.mode === "data") {
+      const tableMeta = tableMetaForDataTab(tab);
+      if (!tableMeta || tableMeta.tableName !== target.name) return false;
+      return targetSchemas.has(normalizeOptionalSchema(tableMeta.schema ?? tab.schema));
+    }
+
+    if ((target.objectType ?? "TABLE") === "TABLE" && tab.mode === "structure") {
+      if ((tab.structureTableName || "") !== target.name) return false;
+      return targetSchemas.has(normalizeOptionalSchema(tab.schema));
+    }
+
+    return false;
+  }
+
+  function tabMatchesTableDataRefreshTarget(tab: QueryTab, target: TableDataRefreshTarget): boolean {
+    if (tab.mode !== "data" || tab.connectionId !== target.connectionId || tab.database !== target.database) return false;
+    const tableMeta = tableMetaForDataTab(tab);
+    if (!tableMeta || tableMeta.tableName !== target.name) return false;
+    if ((tableMeta.catalog || "") !== (target.catalog || "")) return false;
+    const targetSchemas = droppedTableObjectSchemaCandidates(target);
+    return targetSchemas.has(normalizeOptionalSchema(tableMeta.schema ?? tab.schema));
+  }
+
+  function closeDroppedTableObjectTabs(target: DroppedTableObjectTarget) {
+    // A dropped table-like object makes existing data/structure tabs stale; close
+    // them immediately instead of letting the next refresh fail against a missing object.
+    closeTabsWhere((tab) => tabMatchesDroppedTableObject(tab, target));
+  }
+
+  async function refreshDataTabsForTable(target: TableDataRefreshTarget): Promise<number> {
+    const matchingTabs = tabs.value.filter((tab) => tabMatchesTableDataRefreshTarget(tab, target));
+    if (matchingTabs.length === 0) return 0;
+
+    const settingsStore = useSettingsStore();
+    let refreshed = 0;
+
+    for (const tab of matchingTabs) {
+      const tableMeta = tableMetaForDataTab(tab);
+      if (!tableMeta?.tableName) continue;
+      const conn = useConnectionStore().getConfig(tab.connectionId);
+      const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
+      const primaryKeys = tab.tableMeta ? tab.tableMeta.primaryKeys : tableMeta.primaryKeys;
+      const sortOrder = tab.resultSortColumn && tab.resultSortDirection ? `${quoteTableIdentifier(effectiveDbType, tab.resultSortColumn)} ${tab.resultSortDirection.toUpperCase()}` : undefined;
+      const orderBy = tab.orderByInput?.trim() || sortOrder;
+      const limit = tab.resultPageLimit ?? settingsStore.editorSettings.pageSize ?? tableOpenPageLimit();
+      const offset = tab.resultPageOffset ?? 0;
+      const sql = await buildTableSelectSql({
+        databaseType: effectiveDbType,
+        schema: tableMeta.schema,
+        tableName: tableMeta.tableName,
+        tableType: tableMeta.tableType,
+        catalog: tableMeta.catalog,
+        columns: tableMeta.columns.map((column) => column.name),
+        primaryKeys,
+        includeRowId: usesSyntheticRowIdKey(effectiveDbType, primaryKeys, tableMeta.tableType),
+        whereInput: tab.whereInput,
+        orderBy,
+        limit,
+        offset,
+      });
+      updateSql(tab.id, sql);
+      await executeTabSql(tab.id, sql, {
+        pagination: { limit, offset },
+        preserveResultDuringExecution: true,
+      });
+      refreshed += 1;
+    }
+
+    return refreshed;
+  }
+
+  function releaseTabsWhere(predicate: (tab: QueryTab) => boolean) {
+    closeTabsWhere((tab) => predicate(tab) && tab.mode !== "query");
+    tabs.value
+      .filter((tab) => predicate(tab))
+      .forEach((tab) => {
+        rollbackTabTransaction(tab, { resetAutoCommit: true });
+        if (tab.isExecuting) void cancelTabExecution(tab.id);
+        if (tab.isExplaining) void cancelTabExplain(tab.id);
+        void closeResultSession(tab);
+        void closeClientConnectionSession(tab);
+        clearResultPayload(tab);
+      });
+  }
+
+  function releaseConnectionTabs(connectionId: string) {
+    releaseTabsWhere((tab) => tab.connectionId === connectionId);
+  }
+
+  function releaseDatabaseTabs(connectionId: string, database: string) {
+    releaseTabsWhere((tab) => tab.connectionId === connectionId && tab.database === database);
+  }
+
+  function isDatabaseOpen(connectionId: string, database: string) {
+    return tabs.value.some((tab) => tab.connectionId === connectionId && tab.database === database);
+  }
+
+  function rollbackTabsWhere(predicate: (tab: QueryTab) => boolean, options?: { resetAutoCommit?: boolean }) {
+    tabs.value.filter((tab) => predicate(tab)).forEach((tab) => rollbackTabTransaction(tab, options));
+  }
+
+  function rollbackConnectionTransactions(connectionId: string) {
+    rollbackTabsWhere((tab) => tab.connectionId === connectionId, { resetAutoCommit: true });
+  }
+
+  function rollbackDatabaseTransactions(connectionId: string, database: string) {
+    rollbackTabsWhere((tab) => tab.connectionId === connectionId && tab.database === database, { resetAutoCommit: true });
+  }
+
+  function updateSql(id: string, sql: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (tab) {
+      tab.sql = sql;
+      queueSavedSqlEditorPositionPersist(tab);
+    }
+  }
+
+  function setAutoCommit(id: string, autoCommit: boolean) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (tab) {
+      const wasManual = tab.autoCommit === false;
+      tab.autoCommit = autoCommit;
+      if (autoCommit && wasManual) {
+        if (tab.txnSessionId) {
+          void rollbackTransaction(id);
+        } else {
+          tab.txnAutoRolledBack = false;
+        }
+      }
+    }
+  }
+
+  function rollbackTabTransaction(tab: QueryTab, options?: { resetAutoCommit?: boolean }) {
+    if (tab.txnSessionId) void rollbackTransaction(tab.id);
+    if (options?.resetAutoCommit) tab.autoCommit = true;
+    tab.txnAutoRolledBack = false;
+  }
+
+  async function commitTransaction(id: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab?.txnSessionId) return;
+    try {
+      await api.commitManualTransaction(tab.txnSessionId);
+    } finally {
+      tab.txnSessionId = undefined;
+      tab.txnAutoRolledBack = false;
+    }
+  }
+
+  async function rollbackTransaction(id: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab?.txnSessionId) return;
+    try {
+      await api.rollbackManualTransaction(tab.txnSessionId);
+    } finally {
+      tab.txnSessionId = undefined;
+      tab.txnAutoRolledBack = false;
+    }
+  }
+
+  function updateEditorViewport(id: string, viewport: { scrollTop: number; scrollLeft: number }) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab) return;
+    if (tab.editorViewport?.scrollTop === viewport.scrollTop && tab.editorViewport?.scrollLeft === viewport.scrollLeft) return;
+    tab.editorViewport = viewport;
+    queueSavedSqlEditorPositionPersist(tab);
+  }
+
+  function updateEditorSelection(id: string, selection: { anchor: number; head: number }) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab) return;
+    tab.editorSelection = selection;
+    queueSavedSqlEditorPositionPersist(tab);
+  }
+
+  function updateObjectBrowserViewport(id: string, viewport: ObjectBrowserViewport) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab || tab.mode !== "objects") return;
+    const previous = tab.objectBrowser?.viewport;
+    if (previous?.scrollTop === viewport.scrollTop && previous.viewMode === viewport.viewMode) return;
+    tab.objectBrowser = { ...tab.objectBrowser, viewport };
+  }
+
+  function renameTab(id: string, title: string) {
+    const trimmed = title.trim();
+    if (!trimmed) return false;
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab || tab.mode !== "query") return false;
+    const normalizedTitle = tab.savedSqlId ? ensureSqlExtension(trimmed) : trimmed;
+    const previousTitle = tab.title;
+    tab.title = normalizedTitle;
+    tab.customTitle = true;
+    if (tab.savedSqlId) {
+      const savedSqlStore = useSavedSqlStore();
+      const existing = savedSqlStore.getFile(tab.savedSqlId);
+      if (existing && existing.name !== normalizedTitle) {
+        void savedSqlStore.renameFile(tab.savedSqlId, normalizedTitle).catch((error) => {
+          console.warn("[DBX][saved-sql:rename:error]", error);
+          tab.title = previousTitle;
+        });
+      }
+    }
+    return true;
+  }
+
+  function linkSavedSql(id: string, savedSqlId: string, title?: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab) return;
+    tab.savedSqlId = savedSqlId;
+    tab.externalSqlPath = undefined;
+    if (title) {
+      tab.title = title;
+      tab.customTitle = true;
+    }
+  }
+
+  function linkExternalSqlPath(id: string, path: string, title?: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab) return;
+    tab.externalSqlPath = path;
+    tab.savedSqlId = undefined;
+    if (title) {
+      tab.title = title;
+      tab.customTitle = true;
+    }
+    markTabClean(tab);
+    refreshExternalSqlFileTitles();
+  }
+
+  function openSavedSql(file: SavedSqlFile) {
+    const existing = tabs.value.find((tab) => tab.savedSqlId === file.id);
+    if (existing) {
+      persistSavedSqlEditorPosition(existing);
+      if (!existing.sql && file.sql) {
+        existing.sql = file.sql;
+        existing.originalSql = file.sql;
+        const restored = restoreSavedSqlEditorPosition(file.id, file.sql);
+        existing.editorSelection = restored.selection;
+        existing.editorViewport = restored.viewport;
+      }
+      switchTab(existing.id);
+      return existing.id;
+    }
+
+    const id = uuid();
+    const restoredPosition = restoreSavedSqlEditorPosition(file.id, file.sql);
+    const tab: QueryTab = {
+      id,
+      title: file.name,
+      customTitle: true,
+      connectionId: file.connectionId,
+      database: file.database,
+      schema: file.schema,
+      sql: file.sql,
+      savedSqlId: file.id,
+      originalSql: file.sql,
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode: "query",
+      editorSelection: restoredPosition.selection,
+      editorViewport: restoredPosition.viewport,
+    };
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    return id;
+  }
+
+  async function hydrateSavedSqlTabs() {
+    await initSavedSqlEditorPositions();
+    const savedSqlStore = useSavedSqlStore();
+    const linkedTabs = tabs.value.filter((tab) => tab.savedSqlId && tab.sql === "");
+    for (const tab of linkedTabs) {
+      const file = await savedSqlStore.ensureFileContent(tab.savedSqlId!);
+      if (!file) continue;
+      tab.title = tab.customTitle ? tab.title : file.name;
+      tab.connectionId = file.connectionId;
+      tab.database = file.database;
+      tab.schema = file.schema;
+      tab.sql = file.sql;
+      tab.originalSql = file.sql;
+      const restored = restoreSavedSqlEditorPosition(file.id, file.sql);
+      tab.editorSelection = restored.selection;
+      tab.editorViewport = restored.viewport;
+    }
+  }
+
+  function togglePinnedTab(id: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab) return;
+    tab.pinned = !tab.pinned;
+    tabs.value = orderPinnedFirst(tabs.value, (item) => !!item.pinned);
+  }
+
+  function reorderTab(id: string, targetId: string, position: "before" | "after") {
+    const fromIdx = tabs.value.findIndex((t) => t.id === id);
+    const toIdx = tabs.value.findIndex((t) => t.id === targetId);
+    if (fromIdx < 0 || toIdx < 0 || fromIdx === toIdx) return;
+    const [tab] = tabs.value.splice(fromIdx, 1);
+    const newToIdx = tabs.value.findIndex((t) => t.id === targetId);
+    tabs.value.splice(newToIdx + (position === "after" ? 1 : 0), 0, tab);
+    tabs.value = orderPinnedFirst(tabs.value, (item) => !!item.pinned);
+  }
+
+  function updateDatabase(id: string, database: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab || tab.database === database) return;
+    rollbackTabTransaction(tab);
+    void closeResultSession(tab);
+    void closeClientConnectionSession(tab);
+    tab.database = database;
+    tab.schema = undefined;
+    tab.objectBrowser = undefined;
+    clearResultPayload(tab);
+    tab.lastExecutedSql = undefined;
+    tab.resultBaseSql = undefined;
+    tab.resultSortedSql = undefined;
+    clearExplain(tab);
+    tab.tableMeta = undefined;
+  }
+
+  function updateSchema(id: string, schema: string | undefined) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab || tab.schema === schema) return;
+    rollbackTabTransaction(tab);
+    tab.schema = schema;
+    if (tab.mode === "objects") tab.objectBrowser = { ...tab.objectBrowser, schema, viewport: undefined };
+  }
+
+  function updateConnection(id: string, connectionId: string, database = "") {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab || tab.connectionId === connectionId) return;
+    rollbackTabTransaction(tab, { resetAutoCommit: true });
+    void closeResultSession(tab);
+    void closeClientConnectionSession(tab);
+    tab.connectionId = connectionId;
+    tab.database = database;
+    tab.schema = undefined;
+    clearResultPayload(tab);
+    tab.lastExecutedSql = undefined;
+    tab.resultBaseSql = undefined;
+    tab.resultSortedSql = undefined;
+    clearExplain(tab);
+    tab.tableMeta = undefined;
+
+    // Sync connection change back to the saved SQL file if this tab is linked
+    if (tab.savedSqlId) {
+      const savedSqlStore = useSavedSqlStore();
+      void savedSqlStore.ensureFileContent(tab.savedSqlId).then((existing) => {
+        if (!existing) return;
+        return savedSqlStore.saveFile({
+          id: existing.id,
+          connectionId,
+          name: existing.name,
+          database,
+          schema: existing.schema,
+          sql: existing.sql,
+        });
+      });
+    }
+  }
+
+  function setTableMeta(id: string, meta: NonNullable<QueryTab["tableMeta"]>) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (tab) {
+      tab.tableMeta = meta;
+      tab.tableMetaUpdatedAt = Date.now();
+    }
+  }
+
+  function setObjectSource(id: string, objectSource: NonNullable<QueryTab["objectSource"]>) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (tab) tab.objectSource = objectSource;
+  }
+
+  function setExecuting(id: string, isExecuting: boolean) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab) return;
+    tab.isExecuting = isExecuting;
+    tab.queryExecutionStartedAt = isExecuting ? Date.now() : undefined;
+    if (!isExecuting) {
+      tab.isCancelling = false;
+      tab.executionId = undefined;
+    }
+  }
+
+  function setExecutingWithId(id: string, executionId: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab) return;
+    tab.isExecuting = true;
+    tab.executionId = executionId;
+    tab.isCancelling = false;
+    tab.queryExecutionStartedAt = Date.now();
+  }
+
+  function clearExplain(tab: QueryTab) {
+    tab.explainPlan = undefined;
+    tab.explainTableResult = undefined;
+    tab.explainError = undefined;
+    tab.explainTableError = undefined;
+    tab.explainSql = undefined;
+    tab.explainTableSql = undefined;
+    tab.lastExplainedSql = undefined;
+    tab.isExplaining = false;
+    tab.explainExecutionId = undefined;
+    tab.explainClientSessionId = undefined;
+  }
+
+  function toErrorResult(e: any): NonNullable<QueryTab["result"]> {
+    const message = e instanceof Error ? e.message : String(e);
+    return markQueryResultRowsRaw({
+      columns: ["Error"],
+      execution_error: true,
+      rows: [[message]],
+      affected_rows: 0,
+      execution_time_ms: 0,
+    });
+  }
+
+  function setErrorResult(id: string, e: any) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab) return;
+    tab.result = toErrorResult(e);
+    tab.results = undefined;
+    tab.activeResultIndex = undefined;
+    tab.resultSessionId = undefined;
+    tab.isExecuting = false;
+    tab.isCancelling = false;
+    tab.queryExecutionStartedAt = undefined;
+    tab.executionId = undefined;
+  }
+
+  function clearAcknowledgedCancelIfStillRunning(id: string, executionId: string) {
+    setTimeout(() => {
+      const current = tabs.value.find((t) => t.id === id);
+      if (!current || current.executionId !== executionId || !current.isCancelling) return;
+      current.isExecuting = false;
+      current.isCancelling = false;
+      current.executionId = undefined;
+      current.queryExecutionStartedAt = undefined;
+      current.result = toErrorResult(new Error("Query canceled"));
+      current.results = undefined;
+      current.activeResultIndex = undefined;
+      current.resultSessionId = undefined;
+      touchResult(current);
+    }, CANCEL_ACK_SETTLE_TIMEOUT_MS);
+  }
+
+  async function executeCurrentTab() {
+    const tab = tabs.value.find((t) => t.id === activeTabId.value);
+    if (!tab || !tab.sql.trim()) return;
+
+    await executeCurrentSql(tab.sql);
+  }
+
+  async function executeCurrentSql(sql: string, options?: { skipRedisSafetyCheck?: boolean }) {
+    if (!activeTabId.value) return;
+    await executeTabSql(activeTabId.value, sql, { resultBaseSql: sql, resultSortedSql: undefined, ...options });
+  }
+
+  type QueryMetadataPatch = Pick<QueryTab, "queryAnalysis" | "querySourceColumns" | "queryEditabilityReason" | "tableMeta">;
+
+  type LoadedEditableSource = {
+    source: EditableQuerySource;
+    analysis: EditableQueryInfo;
+    tableMeta: NonNullable<QueryTab["tableMeta"]>;
+  };
+
+  interface EditableQueryExecutionPreparation {
+    sql: string;
+    metadataSql: string;
+    hiddenPrimaryKeys: HiddenPrimaryKeyProjection[];
+  }
+
+  function applyQueryMetadataPatch(tab: QueryTab, patch: QueryMetadataPatch) {
+    tab.queryAnalysis = patch.queryAnalysis;
+    tab.querySourceColumns = patch.querySourceColumns;
+    tab.queryEditabilityReason = patch.queryEditabilityReason;
+    tab.mongoEditTarget = undefined;
+    tab.tableMeta = patch.tableMeta;
+  }
+
+  async function loadEditableQuerySource(tab: QueryTab, analysis: EditableQueryInfo, source: EditableQuerySource, conn: ConnectionConfig | undefined, dbType: string, traceId?: string, elapsed?: () => string): Promise<LoadedEditableSource> {
+    let schema = source.schema || tab.schema;
+    if (!schema) {
+      if (dbType === "postgres" || dbType === "kwdb") schema = "public";
+      else schema = "";
+    }
+    // Oracle-family connection databases are service names, not schemas. When
+    // the query does not qualify a schema, let the driver resolve the current
+    // login user's schema instead of looking up metadata under the service name.
+    const resolvedSchema = ORACLE_LIKE_METADATA_TYPES.has(dbType) && !schema ? "" : metadataSchemaForConnection(conn, tab.database, schema || undefined);
+    const metadataSchema = normalizeOracleLikeMetadataIdentifier(dbType, resolvedSchema || undefined, source.schema ? source.schemaQuoted : false) || "";
+    const metadataTableName = normalizeOracleLikeMetadataIdentifier(dbType, source.tableName, source.tableNameQuoted)!;
+    const metadataCatalog = normalizeOracleLikeMetadataIdentifier(dbType, source.catalog, source.catalogQuoted);
+    const metadataSource: EditableQuerySource = {
+      ...source,
+      catalog: metadataCatalog,
+      schema: metadataSchema || undefined,
+      tableName: metadataTableName,
+    };
+    const knownTableType = tab.tableMeta?.tableName.toLowerCase() === metadataTableName.toLowerCase() && normalizeOptionalSchema(tab.tableMeta.schema) === normalizeOptionalSchema(metadataSchema) ? tab.tableMeta.tableType : undefined;
+    console.info("[DBX][executeTabSql:metadata:table:start]", {
+      traceId,
+      schema: metadataSchema,
+      table: metadataTableName,
+      alias: source.alias,
+      elapsed: elapsed?.(),
+    });
+    const loadedMetadata = await loadTableMetadata({
+      connectionId: tab.connectionId,
+      database: tab.database,
+      schema: metadataSchema,
+      tableName: metadataTableName,
+      tableType: knownTableType,
+      databaseType: dbType,
+      driverProfile: conn?.driver_profile || conn?.db_type,
+      catalog: metadataCatalog,
+      traceLogger: (event) => console.debug("[DBX][executeTabSql:metadata:table-trace]", { sourceTraceId: traceId, ...event }),
+    });
+    const columns = loadedMetadata.metadata.columns;
+    const primaryKeys = loadedMetadata.metadata.primaryKeys;
+    console.info("[DBX][executeTabSql:metadata:table:done]", {
+      traceId,
+      columnCount: columns.length,
+      primaryKeyCount: primaryKeys.length,
+      cacheStatus: loadedMetadata.cacheStatus,
+      ageMs: Math.round(loadedMetadata.ageMs),
+      elapsed: elapsed?.(),
+    });
+    return {
+      source: metadataSource,
+      analysis: normalizeOracleLikeQueryAnalysis(dbType, cloneAnalysisForSource(analysis, metadataSource), metadataSchema || undefined, metadataTableName),
+      tableMeta: {
+        catalog: metadataCatalog,
+        schema: metadataSchema || undefined,
+        tableName: metadataTableName,
+        tableType: loadedMetadata.metadata.tableType,
+        columns,
+        primaryKeys,
+      },
+    };
+  }
+
+  function missingPrimaryKeysForSource(primaryKeys: string[], analysis: EditableQueryInfo, sourceKey: string): string[] {
+    if (analysis.selectStar) return [];
+    const selectedColumns = new Set(analysis.columns.flatMap((column) => (column.sourceName && column.sourceKey === sourceKey ? [column.sourceName.toLowerCase()] : [])));
+    return primaryKeys.filter((primaryKey) => !selectedColumns.has(primaryKey.toLowerCase()));
+  }
+
+  async function prepareEditableQueryExecution(tab: QueryTab, sql: string, conn: ConnectionConfig | undefined, databaseType: DatabaseType | undefined, traceId: string, elapsed: () => string): Promise<EditableQueryExecutionPreparation> {
+    const unchanged = { sql, metadataSql: sql, hiddenPrimaryKeys: [] };
+    if (!databaseType || !HIDDEN_QUERY_KEY_DATABASE_TYPES.has(databaseType) || !tab.connectionId || !tab.database) return unchanged;
+
+    try {
+      const editability = analyzeEditableQueryEditability(sql);
+      if (!editability.editable || !editability.analysis) return unchanged;
+      const analysis = editability.analysis;
+      const sources = editableQuerySources(analysis);
+      if (sources.length !== 1 || analysis.distinct || analysis.selectStar) return unchanged;
+
+      const loaded = await loadEditableQuerySource(tab, analysis, sources[0]!, conn, databaseType, traceId, elapsed);
+      if (loaded.tableMeta.tableType?.toUpperCase().includes("VIEW")) return unchanged;
+      const metadataAnalysis = expandStarProjectionColumnsForSource(bindUnqualifiedColumnsForSource(loaded.analysis, loaded.source, loaded.tableMeta.columns), loaded.source, loaded.tableMeta.columns);
+      // Hidden row identifiers are limited to declared primary keys. Unique
+      // indexes, views, and synthetic ROWID fallbacks keep the prior behavior.
+      const primaryKeys = loaded.tableMeta.columns.filter((column) => column.is_primary_key).map((column) => column.name);
+      if (primaryKeys.length === 0) return unchanged;
+
+      const missingPrimaryKeys = missingPrimaryKeysForSource(primaryKeys, metadataAnalysis, loaded.source.key);
+      if (missingPrimaryKeys.length === 0) return unchanged;
+      const primaryKeySet = new Set(primaryKeys.map((primaryKey) => primaryKey.toLowerCase()));
+      const hasWritableProjection = metadataAnalysis.columns.some((column) => column.sourceName && column.sourceKey === loaded.source.key && !primaryKeySet.has(column.sourceName.toLowerCase()));
+      if (!hasWritableProjection) return unchanged;
+
+      const rewritten = buildQueryWithHiddenPrimaryKeys({
+        sql,
+        databaseType,
+        primaryKeys: missingPrimaryKeys,
+        existingResultNames: metadataAnalysis.columns.map((column) => column.resultName),
+      });
+      if (!rewritten) return unchanged;
+      console.info("[DBX][executeTabSql:hidden-primary-keys]", {
+        traceId,
+        table: loaded.tableMeta.tableName,
+        keyCount: rewritten.projections.length,
+        elapsed: elapsed(),
+      });
+      return { sql: rewritten.sql, metadataSql: rewritten.sql, hiddenPrimaryKeys: rewritten.projections };
+    } catch (error) {
+      // Metadata enrichment is optional. Query execution must retain its prior
+      // behavior when metadata is unavailable or the SQL cannot be rewritten.
+      console.warn("[DBX][executeTabSql:hidden-primary-keys:skip]", { traceId, error, elapsed: elapsed() });
+      return unchanged;
+    }
+  }
+
+  async function buildQueryMetadataPatch(tab: QueryTab, sql: string, traceId?: string, elapsed?: () => string): Promise<QueryMetadataPatch | undefined> {
+    if (tab.mode !== "query") return;
+    if (!tab.result || !tab.result.columns.length) {
+      return {
+        queryAnalysis: undefined,
+        querySourceColumns: undefined,
+        queryEditabilityReason: undefined,
+        tableMeta: undefined,
+      };
+    }
+
+    console.info("[DBX][executeTabSql:metadata:editability:start]", { traceId, elapsed: elapsed?.() });
+    const editability = await api.analyzeEditableQueryEditability(sql);
+    console.info("[DBX][executeTabSql:metadata:editability:done]", {
+      traceId,
+      editable: editability.editable,
+      reason: editability.editable ? undefined : editability.reason,
+      elapsed: elapsed?.(),
+    });
+    if (!editability.editable) {
+      return {
+        queryAnalysis: undefined,
+        querySourceColumns: undefined,
+        queryEditabilityReason: editability.reason,
+        tableMeta: undefined,
+      };
+    }
+    const analysis = editability.analysis;
+
+    if (!tab.connectionId || !tab.database) {
+      return {
+        queryAnalysis: undefined,
+        querySourceColumns: undefined,
+        queryEditabilityReason: "metadata-unavailable",
+        tableMeta: undefined,
+      };
+    }
+
+    const connStore = useConnectionStore();
+    const conn = connStore.getConfig(tab.connectionId);
+    const dbType = conn?.db_type || "";
+    const sources = editableQuerySources(analysis);
+    const loadedSources: LoadedEditableSource[] = [];
+    try {
+      for (const source of sources) {
+        loadedSources.push(await loadEditableQuerySource(tab, analysis, source, conn, dbType, traceId, elapsed));
+      }
+
+      const allSourceColumns = loadedSources.map((source) => ({ source: source.source, columns: source.tableMeta.columns }));
+      // Match DBeaver's safety model: a joined result is writable only when one
+      // source table has a complete row identifier and at least one writable column.
+      const candidates = loadedSources
+        .map((loaded) => {
+          const metadataAnalysis = expandStarProjectionColumnsForSource(bindUnqualifiedColumnsForSource(loaded.analysis, loaded.source, loaded.tableMeta.columns, allSourceColumns), loaded.source, loaded.tableMeta.columns);
+          const primaryKeys = loaded.tableMeta.primaryKeys;
+          const sourceColumns = sourceColumnsForResult(metadataAnalysis, tab.result!.columns, loaded.source.key);
+          const primaryKeysPresent = allPrimaryKeysPresent(primaryKeys, tab.result!.columns, metadataAnalysis, loaded.source.key);
+          const keylessAllowed = sources.length === 1 && canUseKeylessRowPredicate(dbType as DatabaseType, primaryKeys);
+          const primaryKeySet = new Set(primaryKeys.map((key) => key.toLowerCase()));
+          const editableSourceColumnCount = (sourceColumns ?? []).filter((column) => column && !primaryKeySet.has(column.toLowerCase())).length;
+          return {
+            ...loaded,
+            analysis: metadataAnalysis,
+            sourceColumns,
+            primaryKeysPresent,
+            keylessAllowed,
+            editableSourceColumnCount,
+          };
+        })
+        .filter((loaded) => (loaded.primaryKeysPresent || loaded.keylessAllowed) && !!loaded.sourceColumns && loaded.editableSourceColumnCount > 0);
+
+      if (loadedSources.length === 1) {
+        const loaded = loadedSources[0]!;
+        const metadataAnalysis = expandStarProjectionColumnsForSource(bindUnqualifiedColumnsForSource(loaded.analysis, loaded.source, loaded.tableMeta.columns, allSourceColumns), loaded.source, loaded.tableMeta.columns);
+        const primaryKeys = loaded.tableMeta.primaryKeys;
+        if (primaryKeys.length === 0 && !canUseKeylessRowPredicate(dbType as DatabaseType, primaryKeys)) {
+          return {
+            queryAnalysis: undefined,
+            querySourceColumns: undefined,
+            queryEditabilityReason: "no-primary-key",
+            tableMeta: loaded.tableMeta,
+          };
+        }
+
+        if (!allPrimaryKeysPresent(primaryKeys, tab.result.columns, metadataAnalysis, loaded.source.key)) {
+          return {
+            queryAnalysis: undefined,
+            querySourceColumns: undefined,
+            queryEditabilityReason: "primary-key-not-returned",
+            tableMeta: loaded.tableMeta,
+          };
+        }
+
+        if (!allEditableColumnsWriteable(metadataAnalysis, tab.result.columns)) {
+          return {
+            queryAnalysis: undefined,
+            querySourceColumns: undefined,
+            queryEditabilityReason: "aliased-columns",
+            tableMeta: loaded.tableMeta,
+          };
+        }
+
+        return {
+          queryAnalysis: metadataAnalysis,
+          querySourceColumns: sourceColumnsForResult(metadataAnalysis, tab.result.columns, loaded.source.key),
+          queryEditabilityReason: undefined,
+          tableMeta: loaded.tableMeta,
+        };
+      }
+
+      if (candidates.length === 0) {
+        return {
+          queryAnalysis: undefined,
+          querySourceColumns: undefined,
+          queryEditabilityReason: loadedSources.some((loaded) => loaded.tableMeta.primaryKeys.length > 0) ? "primary-key-not-returned" : "no-primary-key",
+          tableMeta: undefined,
+        };
+      }
+
+      if (candidates.length > 1) {
+        return {
+          queryAnalysis: undefined,
+          querySourceColumns: undefined,
+          queryEditabilityReason: "complex-source",
+          tableMeta: undefined,
+        };
+      }
+
+      const target = candidates[0]!;
+      const queryAnalysis = {
+        ...target.analysis,
+        allowInsertDelete: false,
+        multiSource: true,
+      };
+      return {
+        queryAnalysis,
+        querySourceColumns: target.sourceColumns,
+        queryEditabilityReason: undefined,
+        tableMeta: target.tableMeta,
+      };
+    } catch (err) {
+      console.error("[DBX] ERROR fetching columns for query metadata:", err);
+      return {
+        queryAnalysis: undefined,
+        querySourceColumns: undefined,
+        queryEditabilityReason: "metadata-unavailable",
+        tableMeta: undefined,
+      };
+    }
+  }
+
+  function analyzeQueryMetadataInBackground(tabId: string, sql: string, result: QueryResult, traceId: string, elapsed: () => string, hiddenPrimaryKeys: HiddenPrimaryKeyProjection[] = []) {
+    void (async () => {
+      const tab = tabs.value.find((t) => t.id === tabId);
+      if (!tab || tab.result !== result) return;
+      console.info("[DBX][executeTabSql:metadata:start]", { traceId, elapsed: elapsed() });
+      const patch = await buildQueryMetadataPatch(tab, sql, traceId, elapsed);
+      if (patch?.queryAnalysis && hiddenPrimaryKeys.length > 0) {
+        patch.queryAnalysis = { ...patch.queryAnalysis, allowInsert: false };
+      }
+      const current = tabs.value.find((t) => t.id === tabId);
+      if (patch && current?.result === result) {
+        applyQueryMetadataPatch(current, patch);
+        syncActiveResultRunFromDisplayed(current);
+        console.info("[DBX][executeTabSql:metadata:done]", { traceId, elapsed: elapsed() });
+      } else {
+        console.warn("[DBX][executeTabSql:metadata:stale]", { traceId, elapsed: elapsed() });
+      }
+    })();
+  }
+
+  function setQueryTotalRowCountIfCurrent(tabId: string, executionId: string, result: QueryResult, totalRowCount: number | undefined) {
+    const current = tabs.value.find((t) => t.id === tabId);
+    if (!current || (current.mode !== "query" && current.mode !== "data")) return;
+    if (current.executionId !== executionId && current.result !== result) return;
+    current.resultTotalRowCount = totalRowCount;
+    current.resultTotalRowCountLoading = false;
+    syncActiveResultRunFromDisplayed(current);
+  }
+
+  type TotalRowCountSqlTarget = { sql: string; schema?: string };
+
+  function countQueryTotalRowsInBackground(options: {
+    tabId: string;
+    connectionId: string;
+    database: string;
+    schema?: string;
+    countSql?: string;
+    countSqlTarget?: () => Promise<TotalRowCountSqlTarget | undefined>;
+    result: QueryResult;
+    pageLimit?: number;
+    pageOffset?: number;
+    executionId: string;
+    traceId: string;
+    elapsed: () => string;
+    timeoutSecs: number;
+  }) {
+    const resultRowCount = options.result.rows.length;
+    if (resultRowCount <= 0) {
+      setQueryTotalRowCountIfCurrent(options.tabId, options.executionId, options.result, undefined);
+      return;
+    }
+    if (typeof options.pageLimit === "number" && resultRowCount < options.pageLimit) {
+      setQueryTotalRowCountIfCurrent(options.tabId, options.executionId, options.result, (options.pageOffset ?? 0) + resultRowCount);
+      return;
+    }
+
+    // A full page was returned, so more rows may exist and determining the true
+    // total requires a potentially expensive COUNT(*) over the user's query.
+    // Only run it automatically when the user opted in; otherwise leave the
+    // total unknown and let them trigger it on demand from the result grid
+    // (matches DBeaver's default of not counting large result sets).
+    if (!useSettingsStore().editorSettings.autoCalculateTotalRows) {
+      setQueryTotalRowCountIfCurrent(options.tabId, options.executionId, options.result, undefined);
+      return;
+    }
+
+    const clientSessionId = tabClientSessionId({ id: options.tabId }, "count");
+    const countExecutionId = `${options.executionId}:count`;
+    void (async () => {
+      try {
+        const countTarget = options.countSql ? { sql: options.countSql, schema: options.schema } : await options.countSqlTarget?.();
+        if (!countTarget?.sql) {
+          setQueryTotalRowCountIfCurrent(options.tabId, options.executionId, options.result, undefined);
+          return;
+        }
+        console.info("[DBX][executeTabSql:count:start]", { traceId: options.traceId, elapsed: options.elapsed() });
+        const countResult = await api.executeQuery(options.connectionId, options.database, countTarget.sql, countTarget.schema, countExecutionId, {
+          clientSessionId,
+          timeoutSecs: options.timeoutSecs,
+        });
+        const total = Number(countResult.rows?.[0]?.[0] ?? 0);
+        if (!Number.isFinite(total) || total < 0) {
+          setQueryTotalRowCountIfCurrent(options.tabId, options.executionId, options.result, undefined);
+          return;
+        }
+        setQueryTotalRowCountIfCurrent(options.tabId, options.executionId, options.result, total);
+        console.info("[DBX][executeTabSql:count:done]", {
+          traceId: options.traceId,
+          total,
+          elapsed: options.elapsed(),
+        });
+      } catch (error) {
+        setQueryTotalRowCountIfCurrent(options.tabId, options.executionId, options.result, undefined);
+        console.warn("[DBX][executeTabSql:count:error]", {
+          traceId: options.traceId,
+          elapsed: options.elapsed(),
+          error,
+        });
+      } finally {
+        void closeClientSessionId(options.connectionId, options.database, clientSessionId, { tabId: options.tabId });
+      }
+    })();
+  }
+
+  async function executeTabSql(
+    id: string,
+    sql: string,
+    options?: {
+      resultBaseSql?: string;
+      resultSortedSql?: string | undefined;
+      querySort?: {
+        resultColumns: string[];
+        columnIndex: number;
+        column: string;
+        direction: "asc" | "desc";
+      };
+      pagination?: { limit: number; offset: number; sessionId?: string };
+      mongoSafety?: MongoAggregateSafetyOptions;
+      preserveResultDuringExecution?: boolean;
+      preserveTotalRowCountDuringExecution?: boolean;
+      preserveActiveResultIndex?: boolean;
+      replaceActiveResultInGroup?: boolean;
+      skipRedisSafetyCheck?: boolean;
+      sourceTraceId?: string;
+      skipEnsureConnected?: boolean;
+    },
+  ) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab || !sql.trim()) return;
+
+    const executionId = uuid();
+    const traceId = executionId.slice(0, 8);
+    const startedAt = performance.now();
+    const elapsed = () => `${Math.round(performance.now() - startedAt)}ms`;
+    tab.isExecuting = true;
+    tab.isCancelling = false;
+    if (!tab.queryExecutionStartedAt) {
+      tab.queryExecutionStartedAt = Date.now();
+    }
+    tab.executionId = executionId;
+    tab.lastExecutedSql = sql;
+    tab.resultLocalSortOriginalRows = undefined;
+    tab.resultLocalSortOriginalMongoDocuments = undefined;
+    const updateActiveResultRun = !!tab.activeResultRunId && options?.preserveResultDuringExecution === true;
+    if (!updateActiveResultRun) {
+      tab.activeResultRunId = undefined;
+    }
+    if (!options?.preserveTotalRowCountDuringExecution) {
+      tab.resultTotalRowCount = undefined;
+    }
+    tab.resultTotalRowCountLoading = false;
+    const previousResultSessionClose = closeResultSession(tab, options?.pagination?.sessionId);
+    if (!options?.preserveResultDuringExecution || !tab.result) {
+      clearResultPayload(tab);
+    }
+    console.info("[DBX][executeTabSql:start]", {
+      traceId,
+      tabId: id,
+      mode: tab.mode,
+      connectionId: tab.connectionId,
+      database: tab.database,
+      schema: tab.schema,
+      sourceTraceId: options?.sourceTraceId,
+      sql,
+    });
+    const queryBaseSql = options?.resultBaseSql ?? sql;
+    let sqlToExecute = sql;
+    let resultSortedSql = options?.resultSortedSql;
+    let queryMetadataSql = queryBaseSql;
+    let hiddenPrimaryKeys: HiddenPrimaryKeyProjection[] = [];
+    let pageSql: string | undefined;
+    let pageLimit: number | undefined;
+    let pageOffset: number | undefined;
+    let countSql: string | undefined;
+    let useAgentResultSession = false;
+    try {
+      const connStore = useConnectionStore();
+      let conn = connStore.getConfig(tab.connectionId);
+      const parsedMongoCommands = conn?.db_type === "mongodb" ? splitMongoCommandRanges(sql) : undefined;
+      let mongoCommands = parsedMongoCommands ?? [];
+      const mongoNeedsConnection = mongoCommands.some(({ command }) => command.kind !== "use");
+
+      if (options?.skipEnsureConnected) {
+        console.info("[DBX][executeTabSql:ensure-connected:skip]", { traceId, elapsed: elapsed(), reason: "caller" });
+      } else if (conn?.db_type === "mongodb" && mongoCommands.length > 0 && !mongoNeedsConnection) {
+        console.info("[DBX][executeTabSql:ensure-connected:skip]", { traceId, elapsed: elapsed(), reason: "mongo-use-only" });
+      } else {
+        console.info("[DBX][executeTabSql:ensure-connected:start]", { traceId, elapsed: elapsed() });
+        await connStore.ensureConnected(tab.connectionId);
+        console.info("[DBX][executeTabSql:ensure-connected:done]", { traceId, elapsed: elapsed() });
+      }
+      conn = connStore.getConfig(tab.connectionId);
+      if (parsedMongoCommands === undefined && conn?.db_type === "mongodb") {
+        mongoCommands = splitMongoCommandRanges(sql);
+      }
+      const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
+      const executionDatabase = dataTabExecutionDatabase(conn, tab.database, tab.mode === "data" ? tab.tableMeta?.catalog : undefined);
+      const useAgentCursor = usesAgentCursorForQuery(conn?.db_type);
+      const queryTimeoutSecs = queryTimeoutSecsForConnection(conn);
+      const settingsStore = useSettingsStore();
+      console.info("[DBX][executeTabSql:previous-session-close:start]", { traceId, elapsed: elapsed() });
+      await previousResultSessionClose;
+      console.info("[DBX][executeTabSql:previous-session-close:done]", { traceId, elapsed: elapsed() });
+
+      // Redis command execution — split multi-line input into individual commands
+      if (conn?.db_type === "redis") {
+        await connStore.ensureConnected(tab.connectionId);
+        let currentDb = Number(tab.database) || 0;
+        const commands = sql
+          .split("\n")
+          .map((line) => line.trim())
+          .filter((line) => line.length > 0);
+        if (commands.length === 0) return;
+        console.info("[DBX][executeTabSql:redis:start]", { traceId, db: currentDb, commandCount: commands.length, sql });
+
+        const allResults: QueryResult[] = [];
+        const skipSafety = options?.skipRedisSafetyCheck;
+        let hadMutatingCommand = false;
+        for (const command of commands) {
+          try {
+            const result = await api.redisExecuteCommand(tab.connectionId, currentDb, command, skipSafety);
+            allResults.push(markQueryResultRowsRaw(annotateQueryResultSource(redisCommandResultToQueryResult(result.value, performance.now() - startedAt, result.command), command)));
+            // Track db switches from SELECT N so later commands in the same batch run on the right db.
+            currentDb = nextRedisCommandDb(currentDb, command, result.value);
+            // Write commands (SET/DEL/...) mutate the key set — drop the cached key-name completion
+            // for the db this command ran on so the next autocomplete fetch reflects the new keys.
+            if (isRedisMutatingCommand(command)) {
+              hadMutatingCommand = true;
+              connStore.invalidateCompletionCache(tab.connectionId, String(currentDb));
+            }
+          } catch (e: any) {
+            allResults.push(annotateQueryResultSource({ columns: ["Error"], rows: [[e?.message ?? String(e)]], affected_rows: 0, execution_time_ms: 0 }, command));
+          }
+        }
+        console.info("[DBX][executeTabSql:redis:done]", { traceId, commandCount: commands.length, elapsed: elapsed() });
+
+        const current = tabs.value.find((t) => t.id === id);
+        if (current?.executionId === executionId) {
+          if (allResults.length > 1) {
+            const activeResultIndex = allResults.findIndex((r) => !r.columns.includes("Error"));
+            const resultIndex = preservedResultIndex(allResults, current.activeResultIndex, options?.preserveActiveResultIndex) ?? (activeResultIndex >= 0 ? activeResultIndex : 0);
+            current.results = allResults;
+            current.activeResultIndex = resultIndex;
+            current.result = allResults[resultIndex];
+          } else {
+            current.results = undefined;
+            current.activeResultIndex = undefined;
+            current.result = allResults[0];
+          }
+          touchResult(current);
+          current.queryAnalysis = undefined;
+          current.querySourceColumns = undefined;
+          current.queryEditabilityReason = undefined;
+          current.mongoEditTarget = undefined;
+          current.tableMeta = undefined;
+          current.resultBaseSql = options?.resultBaseSql ?? sql;
+          current.resultSortedSql = options?.resultSortedSql;
+          syncDisplayedResultRun(current, options?.resultBaseSql ?? sql);
+          // Reflect db switches from SELECT N in the tab so the toolbar dropdown, tab title and
+          // sidebar stay in sync with the command's effective db.
+          if (current.database !== String(currentDb)) {
+            current.database = String(currentDb);
+          }
+        }
+        // Refresh the sidebar db key counts (INFO keyspace) when at least one command in
+        // this batch mutated the key set, so `dbN (count)` stays accurate without a manual
+        // refresh. Fire-and-forget: never block result display.
+        if (hadMutatingCommand) {
+          void connStore.refreshRedisDbKeyCounts(tab.connectionId);
+        }
+        return;
+      }
+
+      if (mongoCommands.length > 0) {
+        console.info("[DBX][executeTabSql:mongo:start]", { traceId, database: tab.database, commandCount: mongoCommands.length, sql });
+
+        const allResults: QueryResult[] = [];
+        // Track the effective db as we walk the batch so later commands observe
+        // earlier `use ...` statements in the same editor selection.
+        let currentDatabase = tab.database;
+        let mongoEditTarget: QueryTab["mongoEditTarget"] | undefined;
+
+        for (const parsedCommand of mongoCommands) {
+          const mongoCommand = parsedCommand.command;
+          const sourceStatement = parsedCommand.text;
+          const commandStartedAt = performance.now();
+          const annotateMongoResult = (result: QueryResult): QueryResult => {
+            const annotated = annotateQueryResultSource(result, sourceStatement);
+            if ("collection" in mongoCommand) {
+              annotated.sourceLabel = currentDatabase ? `${currentDatabase}.${mongoCommand.collection}` : mongoCommand.collection;
+            }
+            return annotated;
+          };
+          try {
+            switch (mongoCommand.kind) {
+              case "find": {
+                console.info("[DBX][executeTabSql:mongo-find:start]", { traceId, collection: mongoCommand.collection, database: currentDatabase });
+                const result = await api.mongoFindDocuments(tab.connectionId, currentDatabase, mongoCommand.collection, mongoCommand.skip, mongoCommand.limit, mongoCommand.filter, mongoCommand.projection, mongoCommand.sort, executionId);
+                const queryResult = markQueryResultRowsRaw(annotateMongoResult(mongoDocumentsToQueryResult(result.documents, performance.now() - commandStartedAt, result.total)));
+                allResults.push(queryResult);
+                mongoEditTarget = mongoCommands.length === 1 && queryResult.columns.includes("_id") ? { collection: mongoCommand.collection, idColumn: "_id" } : undefined;
+                console.info("[DBX][executeTabSql:mongo-find:done]", {
+                  traceId,
+                  collection: mongoCommand.collection,
+                  database: currentDatabase,
+                  rowCount: result.documents.length,
+                  total: result.total,
+                  elapsed: elapsed(),
+                });
+                break;
+              }
+              case "version": {
+                console.info("[DBX][executeTabSql:mongo-version:start]", { traceId, database: currentDatabase });
+                const version = await api.mongoServerVersion(tab.connectionId, currentDatabase, executionId);
+                allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoVersionToQueryResult(version, performance.now() - commandStartedAt))));
+                mongoEditTarget = undefined;
+                console.info("[DBX][executeTabSql:mongo-version:done]", {
+                  traceId,
+                  database: currentDatabase,
+                  version,
+                  elapsed: elapsed(),
+                });
+                break;
+              }
+              case "countDocuments": {
+                console.info("[DBX][executeTabSql:mongo-count:start]", { traceId, collection: mongoCommand.collection, database: currentDatabase });
+                const result = await api.mongoFindDocuments(tab.connectionId, currentDatabase, mongoCommand.collection, 0, 1, mongoCommand.filter, undefined, undefined, executionId);
+                allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoCountToQueryResult(result.total, performance.now() - commandStartedAt))));
+                mongoEditTarget = undefined;
+                console.info("[DBX][executeTabSql:mongo-count:done]", {
+                  traceId,
+                  collection: mongoCommand.collection,
+                  database: currentDatabase,
+                  total: result.total,
+                  elapsed: elapsed(),
+                });
+                break;
+              }
+              case "aggregate": {
+                if (options?.mongoSafety) {
+                  const safety = evaluateMongoAggregateSafety(mongoCommand, options.mongoSafety);
+                  if (!safety.allowed) throw new Error(safety.reason);
+                }
+                console.info("[DBX][executeTabSql:mongo-aggregate:start]", { traceId, collection: mongoCommand.collection, database: currentDatabase });
+                const aggregateMaxRows = normalizeResultPageSize(pageLimit ?? options?.pagination?.limit ?? settingsStore.editorSettings.pageSize);
+                const result = await api.mongoAggregateDocuments(tab.connectionId, currentDatabase, mongoCommand.collection, mongoCommand.pipeline, aggregateMaxRows, executionId);
+                allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoDocumentsToQueryResult(result.documents, performance.now() - commandStartedAt, result.total))));
+                mongoEditTarget = undefined;
+                console.info("[DBX][executeTabSql:mongo-aggregate:done]", {
+                  traceId,
+                  collection: mongoCommand.collection,
+                  database: currentDatabase,
+                  rowCount: result.documents.length,
+                  total: result.total,
+                  elapsed: elapsed(),
+                });
+                break;
+              }
+              case "getIndexes": {
+                console.info("[DBX][executeTabSql:mongo-indexes:start]", { traceId, collection: mongoCommand.collection, database: currentDatabase });
+                const indexes = await api.listIndexes(tab.connectionId, currentDatabase, "", mongoCommand.collection);
+                allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoIndexesToQueryResult(indexes, performance.now() - commandStartedAt))));
+                mongoEditTarget = undefined;
+                console.info("[DBX][executeTabSql:mongo-indexes:done]", {
+                  traceId,
+                  collection: mongoCommand.collection,
+                  database: currentDatabase,
+                  indexCount: indexes.length,
+                  elapsed: elapsed(),
+                });
+                break;
+              }
+              case "collectionStats": {
+                console.info("[DBX][executeTabSql:mongo-collection-stats:start]", {
+                  traceId,
+                  collection: mongoCommand.collection,
+                  metric: mongoCommand.metric,
+                  database: currentDatabase,
+                });
+                const stats = await api.mongoCollectionStats(tab.connectionId, currentDatabase, mongoCommand.collection, mongoCommand.scale, executionId);
+                allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoCollectionStatsToQueryResult(mongoCommand.metric, stats as unknown as Record<string, unknown>, performance.now() - commandStartedAt))));
+                mongoEditTarget = undefined;
+                console.info("[DBX][executeTabSql:mongo-collection-stats:done]", {
+                  traceId,
+                  collection: mongoCommand.collection,
+                  metric: mongoCommand.metric,
+                  database: currentDatabase,
+                  elapsed: elapsed(),
+                });
+                break;
+              }
+              case "insert":
+              case "update":
+              case "delete":
+              case "createIndex":
+              case "dropIndex":
+              case "dropIndexes":
+              case "dropCollection": {
+                if (options?.mongoSafety) {
+                  const safety = evaluateMongoWriteSafety(mongoCommand, options.mongoSafety);
+                  if (!safety.allowed) throw new Error(safety.reason);
+                }
+                console.info("[DBX][executeTabSql:mongo-write:start]", {
+                  traceId,
+                  database: currentDatabase,
+                  kind: mongoCommand.kind,
+                  collection: mongoCommand.collection,
+                });
+                mongoEditTarget = undefined;
+                if (mongoCommand.kind === "insert") {
+                  const result = await api.mongoInsertDocuments(tab.connectionId, currentDatabase, mongoCommand.collection, mongoCommand.docsJson);
+                  allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoWriteToQueryResult(result.affected_rows, performance.now() - commandStartedAt))));
+                } else if (mongoCommand.kind === "update") {
+                  const result = await api.mongoUpdateDocuments(tab.connectionId, currentDatabase, mongoCommand.collection, mongoCommand.filter, mongoCommand.update, mongoCommand.many, mongoCommand.options);
+                  allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoWriteToQueryResult(result.affected_rows, performance.now() - commandStartedAt))));
+                } else if (mongoCommand.kind === "createIndex") {
+                  const result = await api.mongoCreateIndex(tab.connectionId, currentDatabase, mongoCommand.collection, mongoCommand.keys, mongoCommand.options);
+                  allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoCreateIndexToQueryResult(result.name, performance.now() - commandStartedAt))));
+                } else if (mongoCommand.kind === "dropIndex" || mongoCommand.kind === "dropIndexes") {
+                  const result = await api.mongoDropIndexes(tab.connectionId, currentDatabase, mongoCommand.collection, mongoCommand.kind === "dropIndex" ? mongoCommand.index : mongoCommand.indexes, mongoCommand.kind === "dropIndex");
+                  allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoDroppedIndexesToQueryResult(result.dropped_names, performance.now() - commandStartedAt))));
+                } else if (mongoCommand.kind === "dropCollection") {
+                  await api.mongoDropCollection(tab.connectionId, currentDatabase, mongoCommand.collection);
+                  allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoWriteToQueryResult(1, performance.now() - commandStartedAt))));
+                } else {
+                  const result = await api.mongoDeleteDocuments(tab.connectionId, currentDatabase, mongoCommand.collection, mongoCommand.filter, mongoCommand.many);
+                  allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoWriteToQueryResult(result.affected_rows, performance.now() - commandStartedAt))));
+                }
+                console.info("[DBX][executeTabSql:mongo-write:done]", {
+                  traceId,
+                  database: currentDatabase,
+                  kind: mongoCommand.kind,
+                  collection: mongoCommand.collection,
+                  elapsed: elapsed(),
+                });
+                break;
+              }
+              case "use": {
+                currentDatabase = mongoCommand.database;
+                allResults.push(markQueryResultRowsRaw(annotateMongoResult(mongoUseToQueryResult(currentDatabase, performance.now() - commandStartedAt))));
+                mongoEditTarget = undefined;
+                console.info("[DBX][executeTabSql:mongo-use:done]", {
+                  traceId,
+                  database: currentDatabase,
+                  elapsed: elapsed(),
+                });
+                break;
+              }
+            }
+          } catch (error: any) {
+            // Surface per-command failures inline and continue collecting results
+            // for the rest of the batch, matching the grouped-result UX.
+            allResults.push(annotateMongoResult(toErrorResult(error)));
+            mongoEditTarget = undefined;
+          }
+        }
+
+        console.info("[DBX][executeTabSql:mongo:done]", {
+          traceId,
+          database: currentDatabase,
+          commandCount: mongoCommands.length,
+          elapsed: elapsed(),
+        });
+
+        const current = tabs.value.find((t) => t.id === id);
+        if (current?.executionId === executionId) {
+          const activeGroupIndex = current.activeResultIndex;
+          const activeGroupResults = current.results;
+          const shouldReplaceActiveResultInGroup = options?.replaceActiveResultInGroup === true && allResults.length === 1 && Array.isArray(activeGroupResults) && typeof activeGroupIndex === "number" && activeGroupIndex >= 0 && activeGroupIndex < activeGroupResults.length;
+          if (shouldReplaceActiveResultInGroup) {
+            current.results = activeGroupResults.slice();
+            current.results[activeGroupIndex] = allResults[0];
+            current.result = allResults[0];
+          } else if (allResults.length > 1) {
+            // Open grouped output on the first non-error result when possible so
+            // mixed success/error batches land on the most useful table first.
+            const activeResultIndex = allResults.findIndex((result) => !result.columns.includes("Error"));
+            const resultIndex = preservedResultIndex(allResults, current.activeResultIndex, options?.preserveActiveResultIndex) ?? (activeResultIndex >= 0 ? activeResultIndex : 0);
+            current.results = allResults;
+            current.activeResultIndex = resultIndex;
+            current.result = allResults[resultIndex];
+          } else {
+            current.results = undefined;
+            current.activeResultIndex = undefined;
+            current.result = allResults[0];
+          }
+          touchResult(current);
+          current.queryAnalysis = undefined;
+          current.querySourceColumns = undefined;
+          current.queryEditabilityReason = undefined;
+          current.mongoEditTarget = mongoCommands.length === 1 ? mongoEditTarget : undefined;
+          current.tableMeta = undefined;
+          current.resultBaseSql = shouldReplaceActiveResultInGroup ? (current.resultBaseSql ?? options?.resultBaseSql ?? sql) : (options?.resultBaseSql ?? sql);
+          current.resultSortedSql = options?.resultSortedSql;
+          syncDisplayedResultRun(current, current.resultBaseSql ?? options?.resultBaseSql ?? sql);
+          if (current.database !== currentDatabase) current.database = currentDatabase;
+        }
+        return;
+      }
+
+      if (tab.mode === "query") {
+        const prepared = await prepareEditableQueryExecution(tab, sqlToExecute, conn, effectiveDbType, traceId, elapsed);
+        sqlToExecute = prepared.sql;
+        queryMetadataSql = prepared.metadataSql;
+        hiddenPrimaryKeys = prepared.hiddenPrimaryKeys;
+        if (options?.querySort) {
+          const sorted = await api.buildSortedQuerySql({
+            originalSql: sqlToExecute,
+            databaseType: effectiveDbType,
+            resultColumns: [...options.querySort.resultColumns, ...hiddenPrimaryKeys.map((projection) => projection.alias)],
+            columnIndex: options.querySort.columnIndex,
+            column: options.querySort.column,
+            direction: options.querySort.direction,
+          });
+          if (!sorted.ok || !sorted.sql) throw new Error("Unable to build sorted query SQL");
+          sqlToExecute = sorted.sql;
+          resultSortedSql = sorted.sql;
+        }
+        const pagination = options?.pagination ?? { limit: settingsStore.editorSettings.pageSize, offset: 0 };
+        const plan = await api.prepareQueryPaginationExecutionPlan({
+          sql: sqlToExecute,
+          queryBaseSql,
+          databaseType: effectiveDbType,
+          pagination,
+          useAgentCursor,
+          firstPageUsesActualSql: hiddenPrimaryKeys.length > 0,
+        });
+        sqlToExecute = plan.sqlToExecute;
+        pageSql = plan.pageSql;
+        pageLimit = plan.pageLimit;
+        pageOffset = plan.pageOffset;
+        countSql = plan.countSql;
+        useAgentResultSession = plan.useAgentResultSession;
+      } else if (tab.mode === "data") {
+        pageLimit = options?.pagination?.limit ?? tableOpenPageLimit();
+        pageOffset = options?.pagination?.offset ?? 0;
+      }
+
+      const executionSchema = connectionQueryExecutionSchema(conn, tab.database, tab.schema, tab.mode === "data");
+      const frontendTimeoutSecs = frontendQueryTimeoutSecsForSql(sqlToExecute, effectiveDbType, queryTimeoutSecs);
+      const sourceLabelDatabase = tab.database || conn?.database;
+
+      let executionPromise: Promise<QueryResult[]>;
+      if (tab.autoCommit === false) {
+        if (!tab.txnSessionId) {
+          console.info("[DBX][executeTabSql:begin-manual-txn:start]", { traceId, elapsed: elapsed() });
+          tab.txnSessionId = await api.beginManualTransaction(tab.connectionId, executionDatabase, executionSchema);
+          console.info("[DBX][executeTabSql:begin-manual-txn:done]", { traceId, txnSessionId: tab.txnSessionId, elapsed: elapsed() });
+        }
+        console.info("[DBX][executeTabSql:execute-in-txn:invoke]", { traceId, txnSessionId: tab.txnSessionId, elapsed: elapsed() });
+        executionPromise = api.executeInManualTransaction(tab.txnSessionId, sqlToExecute, executionDatabase, executionSchema, pageLimit);
+      } else {
+        console.info("[DBX][executeTabSql:execute-multi:start]", { traceId, elapsed: elapsed() });
+        // Query and data tabs use a tab-scoped pool so repeated executions keep
+        // connection-local state and avoid MySQL pool resets on every refresh.
+        const clientSessionId = tab.mode === "query" || tab.mode === "data" ? tabClientSessionId(tab) : undefined;
+        const executionOptions = {
+          ...(typeof pageLimit === "number"
+            ? useAgentResultSession
+              ? {
+                  fetchSize: pageLimit,
+                  pageSize: pageLimit,
+                  resultSessionId: options?.pagination?.sessionId,
+                }
+              : { maxRows: pageLimit, fetchSize: pageLimit }
+            : {}),
+          ...(clientSessionId ? { clientSessionId } : {}),
+          timeoutSecs: queryTimeoutSecs,
+        };
+        console.info("[DBX][executeTabSql:execute-multi:invoke]", {
+          traceId,
+          elapsed: elapsed(),
+          executionSchema,
+          optionKeys: Object.keys(executionOptions),
+          clientSession: Boolean(clientSessionId),
+        });
+        executionPromise = api.executeMulti(tab.connectionId, executionDatabase, sqlToExecute, executionSchema, executionId, executionOptions);
+      }
+      const results = annotateQueryResultSources(markQueryResultsRowsRaw(await withFrontendQueryTimeout(executionPromise, frontendTimeoutSecs, t("editor.queryTimeoutError", { seconds: frontendTimeoutSecs }))), queryBaseSql, sourceLabelDatabase, effectiveDbType);
+      if (hiddenPrimaryKeys.length > 0 && results.length === 1) {
+        const hiddenIndexes = hiddenResultColumnIndexes(results[0]!.columns, hiddenPrimaryKeys);
+        if (hiddenIndexes.length > 0) results[0]!.hidden_column_indexes = hiddenIndexes;
+        if (hiddenIndexes.length !== hiddenPrimaryKeys.length) queryMetadataSql = queryBaseSql;
+      } else if (hiddenPrimaryKeys.length > 0) {
+        queryMetadataSql = queryBaseSql;
+      }
+      console.info("[DBX][executeTabSql:execute-multi:done]", {
+        traceId,
+        resultCount: results.length,
+        rowCounts: results.map((result) => result.rows.length),
+        columnCounts: results.map((result) => result.columns.length),
+        elapsed: elapsed(),
+      });
+      const current = tabs.value.find((t) => t.id === id);
+      if (current?.executionId === executionId) {
+        const activeGroupIndex = current.activeResultIndex;
+        const activeGroupResults = current.results;
+        const shouldReplaceActiveResultInGroup = options?.replaceActiveResultInGroup === true && results.length === 1 && Array.isArray(activeGroupResults) && typeof activeGroupIndex === "number" && activeGroupIndex >= 0 && activeGroupIndex < activeGroupResults.length;
+        if (shouldReplaceActiveResultInGroup) {
+          current.results = activeGroupResults.slice();
+          current.results[activeGroupIndex] = results[0];
+          current.result = results[0];
+        } else if (results.length > 1) {
+          const errorResultIndex = results.findIndex((result) => isMysqlExecutionErrorResult(result, conn?.db_type));
+          const activeResultIndex = results.findIndex((result) => result.columns.length > 0);
+          const resultIndex = errorResultIndex >= 0 ? errorResultIndex : (preservedResultIndex(results, current.activeResultIndex, options?.preserveActiveResultIndex) ?? (activeResultIndex >= 0 ? activeResultIndex : 0));
+          current.results = results;
+          current.activeResultIndex = resultIndex;
+          current.result = results[resultIndex];
+        } else {
+          current.results = undefined;
+          current.activeResultIndex = undefined;
+          current.result = results[0];
+        }
+        current.resultBaseSql = shouldReplaceActiveResultInGroup ? (current.resultBaseSql ?? queryBaseSql) : queryBaseSql;
+        current.resultSortedSql = resultSortedSql;
+        current.resultPageSql = pageSql;
+        current.resultPageLimit = pageLimit;
+        current.resultPageOffset = pageOffset;
+        current.resultCountSql = countSql;
+        current.resultSessionId = current.result?.session_id ?? undefined;
+        if (!options?.preserveTotalRowCountDuringExecution) {
+          current.resultTotalRowCount = undefined;
+        }
+        const resultRowCount = current.result?.rows.length ?? 0;
+        const totalKnownFromIncompletePage = !!current.result && typeof pageLimit === "number" && resultRowCount < pageLimit;
+        const dataCountTarget =
+          current.mode === "data"
+            ? (() => {
+                const tableMeta = tableMetaForDataTab(current);
+                if (!tableMeta?.tableName) return undefined;
+                return {
+                  databaseType: effectiveDbType,
+                  catalog: tableMeta.catalog,
+                  schema: tableMeta.schema,
+                  tableName: tableMeta.tableName,
+                  whereInput: current.whereInput?.trim() || undefined,
+                };
+              })()
+            : undefined;
+        const canAutoCalculateTotalRows = !!current.result && resultRowCount > 0 && !totalKnownFromIncompletePage && settingsStore.editorSettings.autoCalculateTotalRows && ((current.mode === "query" && !!countSql) || (current.mode === "data" && !!dataCountTarget));
+        current.resultTotalRowCountLoading = canAutoCalculateTotalRows;
+        // Server-side pagination without a countSql: the backend (currently
+        // the Elasticsearch driver) already reports the true match total via
+        // affected_rows. Use it directly so the result-grid can compute the
+        // page count without issuing a separate COUNT query.
+        let totalRowCountResolved = false;
+        if (current.result && current.mode === "query" && typeof pageLimit === "number" && !countSql && typeof current.result.affected_rows === "number" && current.result.affected_rows > current.result.rows.length) {
+          current.resultTotalRowCount = current.result.affected_rows;
+          current.resultTotalRowCountLoading = false;
+          totalRowCountResolved = true;
+        }
+        touchResult(current);
+        syncDisplayedResultRun(current, queryBaseSql);
+        if (!totalRowCountResolved && (current.mode === "query" || current.mode === "data") && current.result) {
+          countQueryTotalRowsInBackground({
+            tabId: id,
+            connectionId: current.connectionId,
+            database: current.database,
+            schema: current.schema,
+            countSql,
+            countSqlTarget: dataCountTarget
+              ? async () => ({
+                  sql: await api.buildDataGridCountSql(dataCountTarget),
+                  schema: undefined,
+                })
+              : undefined,
+            result: current.result,
+            pageLimit,
+            pageOffset,
+            executionId,
+            traceId,
+            elapsed,
+            timeoutSecs: queryTimeoutSecs,
+          });
+        }
+        console.info("[DBX][executeTabSql:result:assigned]", {
+          traceId,
+          activeResultIndex: current.activeResultIndex,
+          rowCount: current.result?.rows.length ?? 0,
+          columnCount: current.result?.columns.length ?? 0,
+          backendMs: current.result?.execution_time_ms,
+          elapsed: elapsed(),
+        });
+        if (current.mode === "query" && current.result) analyzeQueryMetadataInBackground(id, queryMetadataSql, current.result, traceId, elapsed, hiddenPrimaryKeys);
+      } else {
+        console.warn("[DBX][executeTabSql:stale-result]", {
+          traceId,
+          currentExecutionId: current?.executionId,
+          elapsed: elapsed(),
+        });
+      }
+    } catch (e: any) {
+      console.error("[DBX][executeTabSql:error]", { traceId, elapsed: elapsed(), error: e });
+      // Sync connection state if the error indicates a lost connection
+      useConnectionStore().recordConnectionLostError(tab.connectionId, e);
+      // Handle manual transaction auto-rollback (e.g. deadlock detected by server,
+      // statement error inside a manual transaction, or idle timeout).
+      if (tab.autoCommit === false) {
+        const errMsg: string = e?.message ?? String(e);
+        if (/rolled.?back/i.test(errMsg) || errMsg.includes("已自动回滚")) {
+          tab.txnSessionId = undefined;
+          tab.txnAutoRolledBack = true;
+        }
+      }
+      const current = tabs.value.find((t) => t.id === id);
+      if (current?.executionId === executionId) {
+        const errorResult = toErrorResult(e);
+        const activeGroupIndex = current.activeResultIndex;
+        const activeGroupResults = current.results;
+        const shouldReplaceActiveResultInGroup = options?.replaceActiveResultInGroup === true && Array.isArray(activeGroupResults) && typeof activeGroupIndex === "number" && activeGroupIndex >= 0 && activeGroupIndex < activeGroupResults.length;
+        if (shouldReplaceActiveResultInGroup) {
+          current.results = activeGroupResults.slice();
+          current.results[activeGroupIndex] = errorResult;
+          current.result = errorResult;
+        } else {
+          current.result = errorResult;
+          current.results = undefined;
+          current.activeResultIndex = undefined;
+        }
+        current.queryAnalysis = undefined;
+        current.querySourceColumns = undefined;
+        current.queryEditabilityReason = undefined;
+        current.mongoEditTarget = undefined;
+        if (current.mode !== "data") current.tableMeta = undefined;
+        current.resultBaseSql = shouldReplaceActiveResultInGroup ? (current.resultBaseSql ?? queryBaseSql) : queryBaseSql;
+        current.resultSortedSql = resultSortedSql;
+        current.resultPageSql = pageSql;
+        current.resultPageLimit = pageLimit;
+        current.resultPageOffset = pageOffset;
+        current.resultCountSql = countSql;
+        current.resultSessionId = undefined;
+        current.resultTotalRowCount = undefined;
+        current.resultTotalRowCountLoading = false;
+        touchResult(current);
+        syncDisplayedResultRun(current, queryBaseSql);
+      }
+    } finally {
+      const current = tabs.value.find((t) => t.id === id);
+      if (current?.executionId === executionId) {
+        current.isExecuting = false;
+        current.isCancelling = false;
+        current.queryExecutionStartedAt = undefined;
+        current.executionId = undefined;
+        console.info("[DBX][executeTabSql:finish]", { traceId, elapsed: elapsed() });
+      } else {
+        console.warn("[DBX][executeTabSql:finish-stale]", {
+          traceId,
+          currentExecutionId: current?.executionId,
+          elapsed: elapsed(),
+        });
+      }
+    }
+    scheduleResultCacheTrim();
+  }
+
+  async function explainTabSql(id: string, sql: string, databaseType?: DatabaseType, explainMode?: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab) return { ok: false as const, reason: "empty" as const };
+    const conn = useConnectionStore().getConfig(tab.connectionId);
+    const queryTimeoutSecs = queryTimeoutSecsForConnection(conn);
+    const executionId = uuid();
+
+    tab.isExplaining = true;
+    tab.explainExecutionId = executionId;
+    tab.explainPlan = undefined;
+    tab.explainTableResult = undefined;
+    tab.explainError = undefined;
+    tab.explainTableError = undefined;
+    tab.explainSql = undefined;
+    tab.explainTableSql = undefined;
+    tab.lastExplainedSql = sql;
+
+    // DM and Oracle agents expose native text plans. DM also supports autotrace.
+    if (databaseType === "dameng" || databaseType === "oracle") {
+      let explainSql = sql;
+      if (databaseType === "oracle") {
+        const built = await buildExplainSql(databaseType, sql);
+        if (!built.ok) {
+          tab.isExplaining = false;
+          tab.explainExecutionId = undefined;
+          tab.explainPlan = undefined;
+          tab.explainError = built.reason;
+          return built;
+        }
+        explainSql = built.sql;
+      }
+
+      // Autotrace executes the SQL, so keep its stricter safety check.
+      if (databaseType === "dameng" && explainMode === "autotrace") {
+        const DANGER_RE = /^\s*(DROP|DELETE|TRUNCATE|ALTER|UPDATE|MERGE|REPLACE)\b/i;
+        const cleaned = sql
+          .replace(/\/\*[\s\S]*?\*\//g, " ")
+          .replace(/--.*$/gm, " ")
+          .replace(/#.*$/gm, " ");
+        if (cleaned.split(";").some((stmt) => DANGER_RE.test(stmt))) {
+          tab.isExplaining = false;
+          tab.explainExecutionId = undefined;
+          return { ok: false as const, reason: "unsafe" as const };
+        }
+      }
+      try {
+        const mode = databaseType === "dameng" && explainMode === "autotrace" ? "autotrace" : "explain";
+        const planText = (await api.getExplainInfo(tab.connectionId, tab.database, tab.schema, sql, mode)) as string | undefined;
+        const current = tabs.value.find((t) => t.id === id);
+        if (current?.explainExecutionId === executionId) {
+          if (planText && planText.length > 0) {
+            current.explainPlan = databaseType === "oracle" ? parseOracleExplainText(planText) : parseDamengExplainText(planText);
+            current.explainSql = explainSql;
+            current.explainError = undefined;
+          } else {
+            current.explainPlan = undefined;
+            current.explainError = "No explain plan returned";
+          }
+        }
+      } catch (e: any) {
+        const current = tabs.value.find((t) => t.id === id);
+        if (current?.explainExecutionId === executionId) {
+          current.explainPlan = undefined;
+          current.explainError = String(e?.message || e);
+        }
+      } finally {
+        const current = tabs.value.find((t) => t.id === id);
+        if (current?.explainExecutionId === executionId) {
+          current.isExplaining = false;
+          current.explainExecutionId = undefined;
+        }
+      }
+      return { ok: true as const, sql: explainSql };
+    }
+
+    if (databaseType === "mysql") {
+      let tableBuilt: BuildExplainSqlResult;
+      let jsonBuilt: BuildExplainSqlResult;
+      try {
+        [tableBuilt, jsonBuilt] = await Promise.all([buildExplainSql(databaseType, sql, "standard"), buildExplainSql(databaseType, sql, "json")]);
+      } catch (e: any) {
+        const current = tabs.value.find((t) => t.id === id);
+        if (current?.explainExecutionId === executionId) {
+          current.isExplaining = false;
+          current.explainExecutionId = undefined;
+          current.explainError = String(e?.message || e);
+        }
+        return { ok: true as const, sql: "" };
+      }
+      if (tabs.value.find((t) => t.id === id)?.explainExecutionId !== executionId) {
+        return { ok: true as const, sql: jsonBuilt.ok ? jsonBuilt.sql : "" };
+      }
+      if (!tableBuilt.ok || !jsonBuilt.ok) {
+        const failed = !tableBuilt.ok ? tableBuilt : jsonBuilt;
+        const reason = !tableBuilt.ok ? tableBuilt.reason : !jsonBuilt.ok ? jsonBuilt.reason : "unsupported";
+        const current = tabs.value.find((t) => t.id === id);
+        if (current?.explainExecutionId === executionId) {
+          current.isExplaining = false;
+          current.explainExecutionId = undefined;
+          current.explainError = reason;
+        }
+        return failed;
+      }
+
+      tab.explainTableSql = tableBuilt.sql;
+      tab.explainSql = jsonBuilt.sql;
+      // Keep the two EXPLAIN statements on the same one-connection MySQL session.
+      const clientSessionId = `${tabClientSessionId(tab, "explain")}:${executionId}`;
+      tab.explainClientSessionId = clientSessionId;
+      try {
+        try {
+          const tableResult = await api.executeQuery(tab.connectionId, tab.database, tableBuilt.sql, tab.schema, executionId, {
+            clientSessionId,
+            timeoutSecs: queryTimeoutSecs,
+          });
+          const current = tabs.value.find((t) => t.id === id);
+          if (current?.explainExecutionId === executionId) {
+            current.explainTableResult = markQueryResultRowsRaw(tableResult);
+            current.explainTableError = undefined;
+          }
+        } catch (e: any) {
+          const current = tabs.value.find((t) => t.id === id);
+          if (current?.explainExecutionId === executionId) {
+            current.explainTableResult = undefined;
+            current.explainTableError = String(e?.message || e);
+          }
+        }
+
+        // A canceled or superseded standard request must not start the JSON request.
+        if (tabs.value.find((t) => t.id === id)?.explainExecutionId !== executionId) {
+          return { ok: true as const, sql: jsonBuilt.sql };
+        }
+
+        try {
+          const jsonResult = await api.executeQuery(tab.connectionId, tab.database, jsonBuilt.sql, tab.schema, executionId, {
+            clientSessionId,
+            timeoutSecs: queryTimeoutSecs,
+          });
+          const current = tabs.value.find((t) => t.id === id);
+          if (current?.explainExecutionId === executionId) {
+            current.explainPlan = parseExplainResult("mysql", jsonResult);
+            current.explainError = undefined;
+          }
+        } catch (e: any) {
+          const current = tabs.value.find((t) => t.id === id);
+          if (current?.explainExecutionId === executionId) {
+            current.explainPlan = undefined;
+            current.explainError = String(e?.message || e);
+          }
+        }
+      } finally {
+        const current = tabs.value.find((t) => t.id === id);
+        if (current?.explainExecutionId === executionId) {
+          current.isExplaining = false;
+          current.explainExecutionId = undefined;
+        }
+        if (current?.explainClientSessionId === clientSessionId) current.explainClientSessionId = undefined;
+        void closeClientSessionId(tab.connectionId, tab.database, clientSessionId, { tabId: tab.id, explainExecutionId: executionId });
+      }
+      return { ok: true as const, sql: jsonBuilt.sql };
+    }
+
+    const built = await buildExplainSql(databaseType, sql);
+    if (!built.ok) {
+      tab.explainPlan = undefined;
+      tab.explainError = built.reason;
+      tab.isExplaining = false;
+      tab.explainExecutionId = undefined;
+      return built;
+    }
+
+    tab.explainSql = built.sql;
+    const clientSessionId = tabClientSessionId(tab, "explain");
+    try {
+      const result = await api.executeQuery(tab.connectionId, tab.database, built.sql, tab.schema, executionId, {
+        clientSessionId,
+        timeoutSecs: queryTimeoutSecs,
+      });
+      const current = tabs.value.find((t) => t.id === id);
+      if (current?.explainExecutionId === executionId) {
+        current.explainPlan = parseExplainResult(databaseType as "mysql" | "postgres", result);
+        current.explainError = undefined;
+      }
+    } catch (e: any) {
+      const current = tabs.value.find((t) => t.id === id);
+      if (current?.explainExecutionId === executionId) {
+        current.explainPlan = undefined;
+        current.explainError = String(e?.message || e);
+      }
+    } finally {
+      const current = tabs.value.find((t) => t.id === id);
+      if (current?.explainExecutionId === executionId) {
+        current.isExplaining = false;
+        current.explainExecutionId = undefined;
+      }
+      void closeClientSessionId(tab.connectionId, tab.database, clientSessionId, { tabId: tab.id });
+    }
+    return { ok: true as const, sql: built.sql };
+  }
+
+  async function cancelTabExecution(id: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab || !canCancelQueryExecution(tab)) return false;
+
+    const executionId = tab.executionId;
+    if (!executionId) return false;
+    tab.isCancelling = true;
+    try {
+      const canceled = await withCancelQueryTimeout(api.cancelQuery(executionId));
+      if (canceled) {
+        clearAcknowledgedCancelIfStillRunning(id, executionId);
+      }
+      if (!canceled) {
+        const current = tabs.value.find((t) => t.id === id);
+        if (current && current.executionId === executionId) {
+          current.isExecuting = false;
+          current.isCancelling = false;
+          current.executionId = undefined;
+          current.queryExecutionStartedAt = undefined;
+        }
+      }
+      return canceled;
+    } catch (e: any) {
+      // Sync connection state if the error indicates a lost connection
+      if (tab) useConnectionStore().recordConnectionLostError(tab.connectionId, e);
+      const current = tabs.value.find((t) => t.id === id);
+      if (current && current.executionId === executionId) {
+        current.isExecuting = false;
+        current.isCancelling = false;
+        current.executionId = undefined;
+        current.queryExecutionStartedAt = undefined;
+        current.result = toErrorResult(e);
+      }
+      return false;
+    }
+  }
+
+  async function cancelTabExplain(id: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab?.isExplaining || !tab.explainExecutionId) return false;
+
+    const executionId = tab.explainExecutionId;
+    // Invalidate locally before the remote cancellation call so no later stage can start.
+    tab.isExplaining = false;
+    tab.explainExecutionId = undefined;
+    try {
+      return await api.cancelQuery(executionId);
+    } catch {
+      return false;
+    }
+  }
+
+  function setActiveResultIndex(id: string, index: number) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab?.results || index < 0 || index >= tab.results.length) return;
+    tab.activeResultIndex = index;
+    tab.result = tab.results[index];
+    tab.resultLocalSortOriginalRows = undefined;
+    tab.resultLocalSortOriginalMongoDocuments = undefined;
+    tab.resultSortColumn = undefined;
+    tab.resultSortColumnIndex = undefined;
+    tab.resultSortDirection = undefined;
+    tab.resultSortMode = undefined;
+    tab.resultSortedSql = undefined;
+    touchResult(tab);
+    tab.queryAnalysis = undefined;
+    tab.querySourceColumns = undefined;
+    tab.queryEditabilityReason = undefined;
+    tab.mongoEditTarget = undefined;
+    syncActiveResultRunFromDisplayed(tab);
+  }
+
+  function notifyConnectionMayBeLost() {
+    const stuck = tabs.value.filter((t) => t.isExecuting);
+    if (stuck.length > 0) {
+      const connStore = useConnectionStore();
+      stuck.forEach((tab) => {
+        tab.isExecuting = false;
+        tab.isCancelling = false;
+        tab.queryExecutionStartedAt = undefined;
+        tab.executionId = undefined;
+        const error = new Error(t("editor.connectionMayBeLost"));
+        tab.result = toErrorResult(error);
+        connStore.markConnectionLost(tab.connectionId, error);
+      });
+    }
+  }
+
+  async function trimResultCache() {
+    const inactive = tabs.value.filter((t) => t.id !== activeTabId.value && (t.result || t.results)).sort((a, b) => (a.resultAccessedAt ?? 0) - (b.resultAccessedAt ?? 0));
+    if (inactive.length > MAX_CACHED_RESULTS) {
+      const toEvict = inactive.slice(0, inactive.length - MAX_CACHED_RESULTS);
+      await Promise.all(toEvict.map((t) => evictCachedResult(t)));
+    }
+  }
+
+  function scheduleResultCacheTrim() {
+    resultCacheTrimRequested = true;
+    if (resultCacheTrimScheduled || resultCacheTrimRunning) return;
+    resultCacheTrimScheduled = true;
+
+    const run = () => {
+      resultCacheTrimScheduled = false;
+      void runRequestedResultCacheTrim();
+    };
+
+    // Eviction serializes large result payloads; schedule it after the result
+    // assignment so the grid can paint before cache maintenance starts.
+    if (typeof window !== "undefined" && "requestIdleCallback" in window) {
+      window.requestIdleCallback(run, { timeout: 1500 });
+    } else {
+      setTimeout(run, 0);
+    }
+  }
+
+  async function runRequestedResultCacheTrim() {
+    if (resultCacheTrimRunning) return;
+    resultCacheTrimRunning = true;
+    try {
+      while (resultCacheTrimRequested) {
+        resultCacheTrimRequested = false;
+        await trimResultCache();
+      }
+    } finally {
+      resultCacheTrimRunning = false;
+      if (resultCacheTrimRequested) scheduleResultCacheTrim();
+    }
+  }
+
+  function rememberActiveTab(id: string | null) {
+    if (!id || !tabs.value.some((tab) => tab.id === id)) return;
+    activeTabHistory.value = [...activeTabHistory.value.filter((tabId) => tabId !== id), id];
+  }
+
+  function fallbackActiveTabAfterClose(closedId: string, closedIndex: number): string | null {
+    const remainingIds = new Set(tabs.value.map((tab) => tab.id));
+    // Prefer the most recently focused remaining tab. This preserves the
+    // source query tab when a transient table-info/data tab is closed.
+    const history = activeTabHistory.value.filter((tabId) => tabId !== closedId && remainingIds.has(tabId));
+    activeTabHistory.value = history;
+    return [...history].reverse().find((tabId) => remainingIds.has(tabId)) ?? tabs.value[Math.min(closedIndex, tabs.value.length - 1)]?.id ?? null;
+  }
+
+  watch(
+    activeTabId,
+    (id) => {
+      rememberActiveTab(id);
+      touchResult(tabs.value.find((tab) => tab.id === id));
+    },
+    { flush: "sync" },
+  );
+
+  function restoreCachedResultPayload(tab: QueryTab, snapshot: Awaited<ReturnType<typeof readTabResultSnapshot>>) {
+    if (!snapshot) return false;
+    const results = snapshot.results ? markQueryResultsRowsRaw(snapshot.results) : undefined;
+    const activeIndex = snapshot.activeResultIndex ?? 0;
+    tab.results = results;
+    tab.activeResultIndex = snapshot.activeResultIndex;
+    tab.result = snapshot.result ? markQueryResultRowsRaw(snapshot.result) : results?.[activeIndex] ? markQueryResultRowsRaw(results[activeIndex]) : undefined;
+    tab.resultLocalSortOriginalRows = snapshot.resultLocalSortOriginalRows ? markRaw(snapshot.resultLocalSortOriginalRows) : undefined;
+    tab.resultLocalSortOriginalMongoDocuments = snapshot.resultLocalSortOriginalMongoDocuments ? markRaw(snapshot.resultLocalSortOriginalMongoDocuments) : undefined;
+    tab.resultRuns = snapshot.resultRuns ? markQueryResultRunsRowsRaw(snapshot.resultRuns) : tab.resultRuns;
+    tab.activeResultRunId = snapshot.activeResultRunId ?? tab.activeResultRunId;
+    if (!tab.result && !tab.results && !tab.resultRuns) return false;
+
+    tab.queryAnalysis = snapshot.queryAnalysis;
+    tab.querySourceColumns = snapshot.querySourceColumns;
+    tab.queryEditabilityReason = snapshot.queryEditabilityReason;
+    tab.mongoEditTarget = snapshot.mongoEditTarget;
+    tab.tableMeta = snapshot.tableMeta;
+    tab.resultPageSql = snapshot.resultPageSql;
+    tab.resultPageLimit = snapshot.resultPageLimit;
+    tab.resultPageOffset = snapshot.resultPageOffset;
+    tab.resultCountSql = snapshot.resultCountSql;
+    tab.resultTotalRowCount = snapshot.resultTotalRowCount;
+    tab.resultTotalRowCountLoading = false;
+    tab.resultSessionId = undefined;
+    tab.resultEvicted = undefined;
+    tab.resultCacheState = "memory";
+    touchResult(tab);
+    return true;
+  }
+
+  async function hydrateResultRunsForArchive(tab: QueryTab, snapshot: NonNullable<ReturnType<typeof buildTabResultSnapshot>>) {
+    if (!snapshot.resultRuns?.length) return snapshot;
+    const resultRuns = await Promise.all(
+      snapshot.resultRuns.map(async (run) => {
+        if (resultRunHasPayload(run)) return run;
+        const cacheKey = run.resultCacheKey ?? tab.resultRuns?.find((item) => item.id === run.id)?.resultCacheKey;
+        if (!cacheKey) return run;
+        const cached = await readTabResultSnapshot(cacheKey);
+        return cached?.resultRuns?.find((item) => item.id === run.id) ?? run;
+      }),
+    );
+    return { ...snapshot, resultRuns };
+  }
+
+  async function resultArchiveSnapshotForTab(tab: QueryTab) {
+    let snapshot = buildTabResultSnapshot(tab);
+    if (tab.resultCacheKey && (!snapshot || tab.resultEvicted || !resultSnapshotHasPayload(snapshot))) {
+      snapshot = (await readTabResultSnapshot(tab.resultCacheKey)) ?? snapshot;
+    }
+    if (snapshot) snapshot = await hydrateResultRunsForArchive(tab, snapshot);
+    return snapshot && resultSnapshotHasPayload(snapshot) ? snapshot : undefined;
+  }
+
+  async function exportResultArchive(id: string): Promise<Uint8Array | undefined> {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab || tab.mode !== "query") return undefined;
+    const snapshot = await resultArchiveSnapshotForTab(tab);
+    if (!snapshot) return undefined;
+    return encodeQueryResultArchive(tab, snapshot);
+  }
+
+  function openResultArchiveTab(archive: DecodedQueryResultArchive): string | undefined {
+    const id = uuid();
+    const title = archive.tab.title.trim() || t("tabs.importedResultArchive");
+    const tab: QueryTab = {
+      id,
+      title,
+      customTitle: true,
+      connectionId: archive.tab.connectionId,
+      database: archive.tab.database,
+      schema: archive.tab.schema,
+      sql: archive.tab.sql,
+      originalSql: archive.tab.sql,
+      lastExecutedSql: archive.tab.lastExecutedSql,
+      resultBaseSql: archive.tab.resultBaseSql,
+      resultSortedSql: archive.tab.resultSortedSql,
+      isExecuting: false,
+      isCancelling: false,
+      isExplaining: false,
+      mode: "query",
+    };
+    if (!restoreCachedResultPayload(tab, archive.snapshot)) return undefined;
+    const activeRun = tab.resultRuns?.find((run) => run.id === tab.activeResultRunId) ?? tab.resultRuns?.[0];
+    if (activeRun) projectResultRun(tab, activeRun);
+    tabs.value.push(tab);
+    activeTabId.value = id;
+    return id;
+  }
+
+  async function importResultArchive(bytes: Uint8Array | ArrayBuffer): Promise<string | undefined> {
+    const archive = await decodeQueryResultArchive(bytes);
+    if (!archive) return undefined;
+    return openResultArchiveTab(archive);
+  }
+
+  async function reloadEvictedTab(id: string) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab || !tab.resultEvicted) return;
+    if (tab.resultCacheKey) {
+      const restored = restoreCachedResultPayload(tab, await readTabResultSnapshot(tab.resultCacheKey));
+      if (restored) return;
+      tab.resultCacheState = "missing";
+    }
+    tab.resultEvicted = false;
+    const sql = tab.lastExecutedSql ?? tab.sql;
+    if (!sql?.trim()) return;
+    await executeTabSql(tab.id, sql, {
+      resultBaseSql: tab.resultBaseSql ?? sql,
+      resultSortedSql: tab.resultSortedSql,
+      pagination:
+        tab.mode === "data"
+          ? {
+              limit: tab.resultPageLimit ?? tableOpenPageLimit(),
+              offset: tab.resultPageOffset ?? 0,
+            }
+          : undefined,
+    });
+  }
+
+  async function fetchTabResultForExport(id: string, onProgress?: (info: { rowsExported: number; totalRows: number | null }) => void): Promise<QueryResult | undefined> {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab?.result) return undefined;
+
+    if (tab.mode === "data") {
+      const connStore = useConnectionStore();
+      await connStore.ensureConnected(tab.connectionId);
+      const conn = connStore.getConfig(tab.connectionId);
+      const tableMeta = tableMetaForDataTab(tab);
+      if (!tableMeta?.tableName) return tab.result;
+
+      // Use the already-computed total row count as a progress estimate so the
+      // export dialog shows a moving bar instead of a stuck 0 while paginating.
+      const totalRows = typeof tab.resultTotalRowCount === "number" ? tab.resultTotalRowCount : null;
+      const pageLimit = TABLE_DATA_EXPORT_PAGE_SIZE;
+      const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
+      const primaryKeys = tab.tableMeta ? tab.tableMeta.primaryKeys : tableMeta.primaryKeys;
+      const sortOrder = tab.resultSortColumn && tab.resultSortDirection ? `${quoteTableIdentifier(effectiveDbType, tab.resultSortColumn)} ${tab.resultSortDirection.toUpperCase()}` : undefined;
+      const orderBy = tab.orderByInput?.trim() || sortOrder;
+      const queryTimeoutSecs = queryTimeoutSecsForConnection(conn);
+      const executionDatabase = dataTabExecutionDatabase(conn, tab.database, tableMeta.catalog);
+      const rows: QueryResult["rows"] = [];
+      let columns: string[] = [];
+      let executionTimeMs = 0;
+      let offset = 0;
+      const clientSessionId = tabClientSessionId(tab, "export");
+      const exportExecutionId = uuid();
+
+      try {
+        while (true) {
+          const sql = await api.buildTableSelectSql({
+            databaseType: effectiveDbType,
+            schema: tableMeta.schema,
+            tableName: tableMeta.tableName,
+            tableType: tableMeta.tableType,
+            catalog: tableMeta.catalog,
+            columns: tableMeta.columns.map((column) => column.name),
+            primaryKeys,
+            whereInput: tab.whereInput,
+            orderBy,
+            limit: pageLimit,
+            offset,
+          });
+          const results = await api.executeMulti(tab.connectionId, executionDatabase, sql, undefined, exportExecutionId, {
+            maxRows: pageLimit,
+            fetchSize: pageLimit,
+            clientSessionId,
+            timeoutSecs: queryTimeoutSecs,
+          });
+          const result = results[0];
+          if (!result) break;
+          if (columns.length === 0) columns = result.columns;
+          rows.push(...result.rows);
+          executionTimeMs += result.execution_time_ms ?? 0;
+          onProgress?.({ rowsExported: rows.length, totalRows });
+          if (result.rows.length < pageLimit) break;
+          offset += result.rows.length;
+        }
+      } finally {
+        void closeClientSessionId(tab.connectionId, executionDatabase, clientSessionId, { tabId: tab.id });
+      }
+
+      return {
+        columns: columns.length ? columns : tab.result.columns,
+        rows,
+        affected_rows: 0,
+        execution_time_ms: executionTimeMs,
+        truncated: false,
+        has_more: false,
+      };
+    }
+
+    if (tab.mode !== "query") return tab.result;
+
+    const sql = queryResultExecutionSql(tab);
+    if (!sql.trim()) return tab.result;
+
+    const connStore = useConnectionStore();
+    await connStore.ensureConnected(tab.connectionId);
+    const conn = connStore.getConfig(tab.connectionId);
+    const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
+    const queryTimeoutSecs = queryTimeoutSecsForConnection(conn);
+    const useAgentCursor = usesAgentCursorForQuery(conn?.db_type);
+    const queryBaseSql = queryResultBaseSql(tab);
+    const exportSettings = useSettingsStore().editorSettings;
+    const exportRowLimit = exportSettings.exportRowLimitEnabled ? exportSettings.exportRowLimit : Number.POSITIVE_INFINITY;
+    const agentExportMaxRows = exportSettings.exportRowLimitEnabled ? exportSettings.exportRowLimit : 2_147_483_647;
+    // Use the already-computed total row count as a progress estimate so the
+    // export dialog shows a moving bar instead of a stuck 0 while paginating.
+    const totalRows = typeof tab.resultTotalRowCount === "number" ? Math.min(tab.resultTotalRowCount, exportRowLimit) : null;
+    const pageLimit = Math.max(tab.resultPageLimit ?? 0, TABLE_DATA_EXPORT_PAGE_SIZE);
+    const rows: QueryResult["rows"] = [];
+    let columns: string[] = [];
+    let executionTimeMs = 0;
+    let offset = 0;
+    let sessionId: string | undefined;
+    const clientSessionId = tabClientSessionId(tab, "export");
+    const exportExecutionId = uuid();
+
+    try {
+      while (rows.length < exportRowLimit) {
+        const remaining = exportRowLimit - rows.length;
+        const effectivePageLimit = Math.min(pageLimit, remaining);
+        const plan = await api.prepareQueryPaginationExecutionPlan({
+          sql,
+          queryBaseSql,
+          databaseType: effectiveDbType,
+          pagination: { limit: effectivePageLimit, offset, sessionId },
+          useAgentCursor,
+          firstPageUsesActualSql: true,
+        });
+        if (typeof plan.pageLimit !== "number" || typeof plan.pageOffset !== "number") return tab.result;
+        const executionOptions = plan.useAgentResultSession
+          ? {
+              maxRows: agentExportMaxRows,
+              fetchSize: plan.pageLimit,
+              pageSize: plan.pageLimit,
+              resultSessionId: sessionId,
+              clientSessionId,
+              timeoutSecs: queryTimeoutSecs,
+            }
+          : { maxRows: plan.pageLimit, fetchSize: plan.pageLimit, clientSessionId, timeoutSecs: queryTimeoutSecs };
+        const results = await api.executeMulti(tab.connectionId, tab.database, plan.sqlToExecute, tab.schema, exportExecutionId, executionOptions);
+        const result = results[0];
+        if (!result) break;
+        if (columns.length === 0) columns = result.columns;
+        rows.push(...result.rows);
+        executionTimeMs += result.execution_time_ms ?? 0;
+        onProgress?.({ rowsExported: rows.length, totalRows });
+        sessionId = result.session_id ?? undefined;
+        const shouldFetchNextPage = plan.useAgentResultSession ? result.has_more === true : result.rows.length >= plan.pageLimit;
+        if (!shouldFetchNextPage || rows.length >= exportRowLimit) break;
+        offset += result.rows.length;
+      }
+    } finally {
+      if (sessionId) void api.closeQuerySession(tab.connectionId, tab.database, sessionId, clientSessionId);
+      void closeClientSessionId(tab.connectionId, tab.database, clientSessionId, { tabId: tab.id });
+    }
+
+    return {
+      columns: columns.length ? columns : tab.result.columns,
+      rows,
+      affected_rows: 0,
+      execution_time_ms: executionTimeMs,
+      truncated: false,
+      has_more: false,
+    };
+  }
+
+  async function buildQueryResultExportRequest(id: string, options: BuildQueryResultExportRequestOptions) {
+    const tab = tabs.value.find((t) => t.id === id);
+    if (!tab?.result || tab.mode !== "query") return undefined;
+
+    const sql = queryResultExecutionSql(tab);
+    if (!sql.trim()) return undefined;
+
+    const connStore = useConnectionStore();
+    await connStore.ensureConnected(tab.connectionId);
+    const conn = connStore.getConfig(tab.connectionId);
+    const settings = useSettingsStore().editorSettings;
+    const effectiveDbType = effectiveDatabaseTypeForConnection(conn);
+    if (!effectiveDbType) return undefined;
+    const useAgentCursor = usesAgentCursorForQuery(conn?.db_type);
+    const queryBaseSql = queryResultBaseSql(tab);
+    const rowLimit = settings.exportRowLimitEnabled ? settings.exportRowLimit : null;
+    const totalRows = typeof tab.resultTotalRowCount === "number" ? (rowLimit === null ? tab.resultTotalRowCount : Math.min(tab.resultTotalRowCount, rowLimit)) : null;
+    const clientSessionId = tabClientSessionId(tab, "export");
+
+    return {
+      exportId: options.exportId,
+      connectionId: tab.connectionId,
+      database: tab.database,
+      schema: tab.schema,
+      sql,
+      queryBaseSql,
+      databaseType: effectiveDbType,
+      useAgentCursor,
+      filePath: options.filePath,
+      format: options.format,
+      pageSize: settings.exportBatchSize,
+      rowLimit,
+      totalRows,
+      timeoutSecs: queryTimeoutSecsForConnection(conn),
+      keysetOptimizationEnabled: settings.queryExportKeysetOptimizationEnabled,
+      clientSessionId,
+      executionId: uuid(),
+    };
+  }
+
+  return {
+    tabs,
+    activeTabId,
+    isOpenTabsLoaded,
+    initOpenTabs,
+    showCloseConfirm,
+    pendingCloseTabId,
+    closeConfirmContext,
+    closeConfirmDirtyTabIds,
+    hasDirtyTabs,
+    isConfirmingAppClose,
+    createTab,
+    switchTab,
+    closeTab,
+    forceClosePendingTab,
+    forceCloseAllPendingTabs,
+    cancelClosePendingTab,
+    flushPendingPersist,
+    saveAndClosePendingTab,
+    suspendCloseConfirm,
+    resumeCloseConfirm,
+    completePendingCloseAfterSaveAll,
+    isTabDirty,
+    markTabClean,
+    discardTabChanges,
+    requestAppCloseConfirmation,
+    closeOtherTabs,
+    closeOtherRegularTabs,
+    closeRegularTabs,
+    closeOtherFixedTabs,
+    closeFixedTabs,
+    closeAllTabs,
+    duplicateTab,
+    closeConnectionTabs,
+    closeDatabaseTabs,
+    closeDroppedTableObjectTabs,
+    refreshDataTabsForTable,
+    releaseConnectionTabs,
+    releaseDatabaseTabs,
+    isDatabaseOpen,
+    rollbackConnectionTransactions,
+    rollbackDatabaseTransactions,
+    updateSql,
+    updateEditorViewport,
+    updateEditorSelection,
+    updateObjectBrowserViewport,
+    setAutoCommit,
+    commitTransaction,
+    rollbackTransaction,
+    renameTab,
+    openObjectBrowser,
+    openMongoGridFs,
+    openMongoBucket,
+    openUserAdmin,
+    openDamengJobAdmin,
+    openMqAdmin,
+    openNacosAdmin,
+    openTableStructure,
+    linkSavedSql,
+    linkExternalSqlPath,
+    openExternalSqlFile,
+    openSavedSql,
+    hydrateSavedSqlTabs,
+    togglePinnedTab,
+    reorderTab,
+    updateDatabase,
+    updateSchema,
+    updateConnection,
+    setTableMeta,
+    invalidateTableStructure,
+    tableStructureRefreshVersion,
+    setObjectSource,
+    setExecuting,
+    setExecutingWithId,
+    setErrorResult,
+    toggleResultAutoSave,
+    setActiveResultRun,
+    removeResultRun,
+    setActiveResultIndex,
+    executeCurrentTab,
+    executeCurrentSql,
+    executeTabSql,
+    sortTabResultLocally,
+    explainTabSql,
+    cancelTabExecution,
+    cancelTabExplain,
+    reloadEvictedTab,
+    exportResultArchive,
+    importResultArchive,
+    fetchTabResultForExport,
+    buildQueryResultExportRequest,
+    notifyConnectionMayBeLost,
+  };
+});
diff --git a/apps/desktop/src/stores/savedSqlStore.ts b/apps/desktop/src/stores/savedSqlStore.ts
new file mode 100644
index 0000000..417e72a
--- /dev/null
+++ b/apps/desktop/src/stores/savedSqlStore.ts
@@ -0,0 +1,593 @@
+import { defineStore } from "pinia";
+import { computed, ref } from "vue";
+import { uuid } from "@/lib/common/utils";
+import * as api from "@/lib/backend/api";
+import { forgetSavedSqlEditorPosition } from "@/lib/app/savedSqlEditorPosition";
+import { ensureSqlExtension } from "@/lib/savedSql/savedSqlFileName";
+import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
+import { useSettingsStore } from "@/stores/settingsStore";
+import type { SavedSqlFile, SavedSqlFolder, SavedSqlLibrary } from "@/types/database";
+
+const LEGACY_STORAGE_KEY = "dbx-saved-sql-library";
+
+interface SavedSqlState {
+  folders: SavedSqlFolder[];
+  files: SavedSqlFile[];
+}
+
+interface SaveFileInput {
+  id?: string;
+  connectionId: string;
+  folderId?: string;
+  name: string;
+  database: string;
+  schema?: string;
+  sql: string;
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function sortFoldersByOrder(items: SavedSqlFolder[]) {
+  return [...items].sort((a, b) => {
+    const orderDiff = (a.orderIndex ?? 0) - (b.orderIndex ?? 0);
+    if (orderDiff !== 0) return orderDiff;
+    return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
+  });
+}
+
+function sortFilesByOrder(items: SavedSqlFile[]) {
+  return [...items].sort((a, b) => {
+    const orderDiff = (a.orderIndex ?? 0) - (b.orderIndex ?? 0);
+    if (orderDiff !== 0) return orderDiff;
+    return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
+  });
+}
+
+function reindexFolders(items: SavedSqlFolder[]) {
+  return items.map((folder, index) => ({ ...folder, orderIndex: index }));
+}
+
+function reindexFiles(items: SavedSqlFile[], folderId?: string) {
+  return items.map((file, index) => ({
+    ...file,
+    folderId,
+    orderIndex: index,
+  }));
+}
+
+function maxOrderIndex(values: Array<{ orderIndex?: number }>) {
+  return values.reduce((max, item) => Math.max(max, item.orderIndex ?? -1), -1);
+}
+
+function folderDepth(items: SavedSqlFolder[], folderId: string) {
+  const byId = new Map(items.map((folder) => [folder.id, folder]));
+  const seen = new Set<string>();
+  let depth = 0;
+  let current = byId.get(folderId);
+  while (current?.parentFolderId && !seen.has(current.parentFolderId)) {
+    seen.add(current.parentFolderId);
+    depth++;
+    current = byId.get(current.parentFolderId);
+  }
+  return depth;
+}
+
+function loadLegacyState(): SavedSqlState {
+  try {
+    const raw = localStorage.getItem(LEGACY_STORAGE_KEY);
+    if (!raw) return { folders: [], files: [] };
+    const parsed = JSON.parse(raw) as Partial<SavedSqlState>;
+    return {
+      folders: Array.isArray(parsed.folders) ? parsed.folders.filter((item) => item?.id && item?.connectionId) : [],
+      files: Array.isArray(parsed.files) ? parsed.files.filter((item) => item?.id && item?.connectionId) : [],
+    };
+  } catch {
+    return { folders: [], files: [] };
+  }
+}
+
+export const useSavedSqlStore = defineStore("savedSql", () => {
+  const folders = ref<SavedSqlFolder[]>([]);
+  const files = ref<SavedSqlFile[]>([]);
+  const isLoaded = ref(false);
+  let pendingSync: Promise<void> | null = null;
+  let initFromStoragePromise: Promise<void> | null = null;
+  const pendingFolderCreates = new Map<string, Promise<SavedSqlFolder>>();
+
+  const version = ref(0);
+  function bumpVersion() {
+    version.value++;
+  }
+
+  function applyLibrary(library: SavedSqlLibrary) {
+    folders.value = library.folders;
+    files.value = library.files.map((file) => ({ ...file, sqlLoaded: file.sqlLoaded ?? Boolean(file.sql) }));
+    bumpVersion();
+  }
+
+  async function migrateLegacyLocalStorage() {
+    const legacy = loadLegacyState();
+    if (legacy.folders.length === 0 && legacy.files.length === 0) return;
+
+    for (const folder of legacy.folders) {
+      await api.saveSavedSqlFolder(folder);
+    }
+    for (const file of legacy.files) {
+      await api.saveSavedSqlFile(file);
+    }
+    localStorage.removeItem(LEGACY_STORAGE_KEY);
+  }
+
+  async function initFromStorage() {
+    if (isLoaded.value) return;
+    if (!initFromStoragePromise) {
+      initFromStoragePromise = (async () => {
+        await migrateLegacyLocalStorage();
+        applyLibrary(await api.loadSavedSqlLibrary());
+        isLoaded.value = true;
+      })().finally(() => {
+        initFromStoragePromise = null;
+      });
+    }
+    await initFromStoragePromise;
+  }
+
+  function listFolders(connectionId: string) {
+    return listChildFolders(connectionId);
+  }
+
+  function listChildFolders(connectionId: string, parentFolderId?: string) {
+    return sortFoldersByOrder(folders.value.filter((folder) => folder.connectionId === connectionId && (folder.parentFolderId || "") === (parentFolderId || "")));
+  }
+
+  function listFiles(connectionId: string, folderId?: string) {
+    return sortFilesByOrder(files.value.filter((file) => file.connectionId === connectionId && (file.folderId || "") === (folderId || "")));
+  }
+
+  function folderCreateKey(connectionId: string, name: string, parentFolderId?: string) {
+    return JSON.stringify([connectionId, parentFolderId || "", name]);
+  }
+
+  function getFile(id: string) {
+    return files.value.find((file) => file.id === id);
+  }
+
+  async function ensureFileContent(id: string) {
+    const existing = getFile(id);
+    if (!existing) return undefined;
+    if (existing.sqlLoaded !== false) return existing;
+
+    const loaded = await api.loadSavedSqlFile(id);
+    if (!loaded) return existing;
+    const hydrated = { ...loaded, sqlLoaded: true };
+    files.value = files.value.map((file) => (file.id === id ? hydrated : file));
+    bumpVersion();
+    return hydrated;
+  }
+
+  async function createFolder(connectionId: string, name: string, parentFolderId?: string) {
+    const key = folderCreateKey(connectionId, name, parentFolderId);
+    const pending = pendingFolderCreates.get(key);
+    if (pending) return pending;
+
+    const createPromise = (async () => {
+      const timestamp = nowIso();
+      const folder: SavedSqlFolder = {
+        id: uuid(),
+        connectionId,
+        parentFolderId: parentFolderId || undefined,
+        name,
+        orderIndex: maxOrderIndex(folders.value.filter((item) => item.connectionId === connectionId && (item.parentFolderId || "") === (parentFolderId || ""))) + 1,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+      };
+      const saved = await api.saveSavedSqlFolder(folder);
+      folders.value = [...folders.value.filter((item) => item.id !== saved.id), saved];
+      bumpVersion();
+      await syncToLocalDirectory();
+      return saved;
+    })();
+
+    pendingFolderCreates.set(key, createPromise);
+    try {
+      return await createPromise;
+    } finally {
+      if (pendingFolderCreates.get(key) === createPromise) {
+        pendingFolderCreates.delete(key);
+      }
+    }
+  }
+
+  async function renameFolder(id: string, name: string) {
+    const existing = folders.value.find((folder) => folder.id === id);
+    if (!existing) return;
+    const saved = await api.saveSavedSqlFolder({ ...existing, name, updatedAt: nowIso() });
+    folders.value = folders.value.map((folder) => (folder.id === id ? saved : folder));
+    bumpVersion();
+    await syncToLocalDirectory();
+  }
+
+  async function deleteFolder(id: string) {
+    const removedIds = descendantFolderIds(id);
+    await api.deleteSavedSqlFolder(id);
+    folders.value = folders.value.filter((folder) => !removedIds.has(folder.id));
+    files.value = files.value.filter((file) => !file.folderId || !removedIds.has(file.folderId));
+    bumpVersion();
+    await syncToLocalDirectory();
+  }
+
+  async function saveFile(input: SaveFileInput) {
+    const timestamp = nowIso();
+    const existing = input.id ? getFile(input.id) : undefined;
+    const hasFolderIdInput = Object.prototype.hasOwnProperty.call(input, "folderId");
+    const file: SavedSqlFile = existing
+      ? {
+          ...existing,
+          // Partial metadata updates should not move files out of their folder.
+          // Callers that intentionally move to root pass `folderId: undefined`.
+          folderId: hasFolderIdInput ? input.folderId || undefined : existing.folderId,
+          name: input.name,
+          database: input.database,
+          schema: input.schema,
+          sql: input.sql,
+          sqlLoaded: true,
+          connectionId: input.connectionId,
+          updatedAt: timestamp,
+        }
+      : {
+          id: uuid(),
+          connectionId: input.connectionId,
+          folderId: input.folderId || undefined,
+          name: input.name,
+          database: input.database,
+          schema: input.schema,
+          sql: input.sql,
+          sqlLoaded: true,
+          orderIndex: maxOrderIndex(files.value.filter((file) => file.connectionId === input.connectionId && (file.folderId || "") === (input.folderId || undefined || ""))) + 1,
+          createdAt: timestamp,
+          updatedAt: timestamp,
+        };
+    const saved = await api.saveSavedSqlFile(file);
+    files.value = [...files.value.filter((item) => item.id !== saved.id), { ...saved, sqlLoaded: true }];
+    bumpVersion();
+    await syncToLocalDirectory();
+    return saved;
+  }
+
+  async function renameFile(id: string, name: string) {
+    const existing = getFile(id);
+    if (!existing) return;
+    const normalizedName = ensureSqlExtension(name);
+    const saved = await api.saveSavedSqlFile({ ...existing, name: normalizedName, updatedAt: nowIso() });
+    files.value = files.value.map((file) => (file.id === id ? { ...saved, sql: file.sql, sqlLoaded: file.sqlLoaded } : file));
+    bumpVersion();
+
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const queryStore = useQueryStore();
+    for (const tab of queryStore.tabs) {
+      if (tab.savedSqlId === id) {
+        tab.title = saved.name;
+        tab.customTitle = true;
+      }
+    }
+
+    await syncToLocalDirectory();
+  }
+
+  async function recordFileUsage(id: string) {
+    const existing = getFile(id);
+    if (!existing) return;
+    try {
+      const saved = await api.saveSavedSqlFile({
+        ...existing,
+        openCount: (existing.openCount ?? 0) + 1,
+        openedAt: nowIso(),
+      });
+      files.value = files.value.map((file) => (file.id === id ? { ...saved, sql: file.sql, sqlLoaded: file.sqlLoaded } : file));
+      bumpVersion();
+      return saved;
+    } catch (error) {
+      console.warn("[DBX][saved-sql:usage:error]", error);
+      return existing;
+    }
+  }
+
+  async function deleteFile(id: string) {
+    await api.deleteSavedSqlFile(id);
+    files.value = files.value.filter((file) => file.id !== id);
+    bumpVersion();
+    await syncToLocalDirectory();
+
+    // Close all tabs that reference this saved SQL file
+    const { useQueryStore } = await import("@/stores/queryStore");
+    const queryStore = useQueryStore();
+    const tabsToClose = queryStore.tabs.filter((tab) => tab.savedSqlId === id);
+    for (const tab of tabsToClose) {
+      queryStore.closeTab(tab.id, { force: true });
+    }
+    forgetSavedSqlEditorPosition(id);
+  }
+
+  async function persistFolders(nextFolders: SavedSqlFolder[]) {
+    const reindexed = nextFolders.map((folder) => ({ ...folder, updatedAt: folder.updatedAt || nowIso() }));
+    await Promise.all(reindexed.map((folder) => api.saveSavedSqlFolder(folder)));
+    folders.value = reindexed;
+    bumpVersion();
+    await syncToLocalDirectory();
+  }
+
+  async function persistFiles(nextFiles: SavedSqlFile[]) {
+    const savedFiles = await Promise.all(nextFiles.map((file) => api.saveSavedSqlFile(file)));
+    files.value = savedFiles.map((saved) => {
+      const existing = files.value.find((file) => file.id === saved.id);
+      return { ...saved, sql: existing?.sql ?? saved.sql, sqlLoaded: existing?.sqlLoaded ?? saved.sqlLoaded };
+    });
+    bumpVersion();
+    await syncToLocalDirectory();
+  }
+
+  async function syncEntries() {
+    const folderById = new Map(folders.value.map((folder) => [folder.id, folder]));
+    const folderPath = (folderId?: string): string | undefined => {
+      if (!folderId) return undefined;
+      const parts: string[] = [];
+      const seen = new Set<string>();
+      let current = folderById.get(folderId);
+      while (current && !seen.has(current.id)) {
+        seen.add(current.id);
+        parts.unshift(current.name);
+        current = current.parentFolderId ? folderById.get(current.parentFolderId) : undefined;
+      }
+      return parts.join("/");
+    };
+    const loadedFiles = await Promise.all(sortFilesByOrder(files.value).map((file) => ensureFileContent(file.id)));
+    return loadedFiles
+      .filter((file): file is SavedSqlFile => Boolean(file))
+      .map((file) => ({
+        folderName: folderPath(file.folderId),
+        fileName: file.name,
+        sql: file.sql,
+      }));
+  }
+
+  async function syncToLocalDirectory() {
+    if (!isTauriRuntime()) return;
+    const settingsStore = useSettingsStore();
+    const targetDir = settingsStore.desktopSettings.saved_sql_sync_dir?.trim();
+    if (!targetDir) return;
+
+    const entries = await syncEntries();
+    const syncPromise = pendingSync?.catch(() => {}).then(() => api.syncSavedSqlDirectory({ targetDir, entries })) ?? api.syncSavedSqlDirectory({ targetDir, entries });
+    pendingSync = syncPromise;
+    try {
+      await syncPromise;
+    } catch (error) {
+      console.warn("[DBX][saved-sql:sync:error]", error);
+    } finally {
+      if (pendingSync === syncPromise) {
+        pendingSync = null;
+      }
+    }
+  }
+
+  async function reorderFolders(draggedId: string, targetId: string, position: "before" | "after") {
+    const dragged = folders.value.find((folder) => folder.id === draggedId);
+    const target = folders.value.find((folder) => folder.id === targetId);
+    if (!dragged || !target || dragged.id === target.id) return;
+    if (descendantFolderIds(draggedId).has(targetId)) return;
+
+    const timestamp = nowIso();
+    const targetParentFolderId = target.parentFolderId || undefined;
+    const previousParentFolderId = dragged.parentFolderId || undefined;
+    const ordered = sortFoldersByOrder(folders.value.filter((folder) => (folder.parentFolderId || "") === (targetParentFolderId || "")));
+    const remaining = ordered.filter((folder) => folder.id !== draggedId);
+    const targetIndex = remaining.findIndex((folder) => folder.id === targetId);
+    const insertIndex = position === "before" ? targetIndex : targetIndex + 1;
+    remaining.splice(insertIndex, 0, { ...dragged, parentFolderId: targetParentFolderId, updatedAt: timestamp });
+
+    const updatedTargetGroup = reindexFolders(remaining).map((folder) => ({
+      ...folder,
+      parentFolderId: targetParentFolderId,
+      updatedAt: timestamp,
+    }));
+    const updatedSourceGroup =
+      previousParentFolderId === targetParentFolderId
+        ? []
+        : reindexFolders(sortFoldersByOrder(folders.value.filter((folder) => folder.id !== draggedId && (folder.parentFolderId || "") === (previousParentFolderId || "")))).map((folder) => ({
+            ...folder,
+            updatedAt: timestamp,
+          }));
+    const untouched = folders.value.filter((folder) => folder.id !== draggedId && (folder.parentFolderId || "") !== (targetParentFolderId || "") && (folder.parentFolderId || "") !== (previousParentFolderId || ""));
+    await persistFolders([...untouched, ...updatedSourceGroup, ...updatedTargetGroup]);
+  }
+
+  function descendantFolderIds(folderId: string) {
+    const ids = new Set<string>([folderId]);
+    let changed = true;
+    while (changed) {
+      changed = false;
+      for (const folder of folders.value) {
+        if (folder.parentFolderId && ids.has(folder.parentFolderId) && !ids.has(folder.id)) {
+          ids.add(folder.id);
+          changed = true;
+        }
+      }
+    }
+    return ids;
+  }
+
+  async function moveFolderToFolder(folderId: string, parentFolderId?: string) {
+    const target = folders.value.find((folder) => folder.id === folderId);
+    if (!target) return;
+    const nextParentFolderId = parentFolderId || undefined;
+    if ((target.parentFolderId || undefined) === nextParentFolderId) return;
+    if (nextParentFolderId && descendantFolderIds(folderId).has(nextParentFolderId)) return;
+
+    const timestamp = nowIso();
+    const previousParentFolderId = target.parentFolderId || undefined;
+    const sourceGroup = reindexFolders(sortFoldersByOrder(folders.value.filter((folder) => folder.id !== folderId && (folder.parentFolderId || "") === (previousParentFolderId || "")))).map((folder) => ({ ...folder, updatedAt: timestamp }));
+    const destinationGroup = reindexFolders([...sortFoldersByOrder(folders.value.filter((folder) => folder.id !== folderId && (folder.parentFolderId || "") === (nextParentFolderId || ""))), { ...target, parentFolderId: nextParentFolderId, updatedAt: timestamp }]).map((folder) => ({
+      ...folder,
+      parentFolderId: nextParentFolderId,
+      updatedAt: timestamp,
+    }));
+    const untouched = folders.value.filter((folder) => folder.id !== folderId && (folder.parentFolderId || "") !== (previousParentFolderId || "") && (folder.parentFolderId || "") !== (nextParentFolderId || ""));
+    await persistFolders([...untouched, ...sourceGroup, ...destinationGroup]);
+  }
+
+  async function moveFileToFolder(fileId: string, folderId?: string) {
+    const target = files.value.find((file) => file.id === fileId);
+    if (!target) return;
+    const targetFolderId = folderId || undefined;
+    if ((target.folderId || undefined) === targetFolderId) return;
+
+    const timestamp = nowIso();
+    const sourceGroup = sortFilesByOrder(files.value.filter((file) => (file.folderId || "") === (target.folderId || ""))).filter((file) => file.id !== fileId);
+    const destinationGroup = sortFilesByOrder(files.value.filter((file) => file.id !== fileId && (file.folderId || "") === (targetFolderId || "")));
+
+    const movedFile: SavedSqlFile = {
+      ...target,
+      folderId: targetFolderId,
+      updatedAt: timestamp,
+    };
+
+    const nextSource = reindexFiles(sourceGroup, target.folderId || undefined).map((file) => ({
+      ...file,
+      updatedAt: timestamp,
+    }));
+    const nextDestination = reindexFiles([...destinationGroup, movedFile], targetFolderId).map((file) => ({
+      ...file,
+      updatedAt: timestamp,
+    }));
+
+    const untouched = files.value.filter((file) => file.id !== fileId && (file.folderId || "") !== (target.folderId || "") && (file.folderId || "") !== (targetFolderId || ""));
+
+    await persistFiles([...untouched, ...nextSource, ...nextDestination]);
+  }
+
+  async function moveFilesToFolder(fileIds: string[], folderId?: string) {
+    const uniqueIds = [...new Set(fileIds)];
+    if (uniqueIds.length === 0) return;
+
+    const targetFolderId = folderId || undefined;
+    const movingFiles = uniqueIds.map((id) => files.value.find((file) => file.id === id)).filter((file): file is SavedSqlFile => Boolean(file));
+    const filesToMove = movingFiles.filter((file) => (file.folderId || undefined) !== targetFolderId);
+    if (filesToMove.length === 0) return;
+    const moveIdSet = new Set(filesToMove.map((file) => file.id));
+
+    const timestamp = nowIso();
+    const affectedFolderIds = new Set<string>(filesToMove.map((file) => file.folderId || ""));
+    affectedFolderIds.add(targetFolderId || "");
+
+    const movedFiles = filesToMove.map((file) => ({
+      ...file,
+      folderId: targetFolderId,
+      updatedAt: timestamp,
+    }));
+
+    // Reindex each touched folder separately so moving a batch out of one
+    // folder never rewrites unrelated siblings into the destination folder.
+    const nextAffectedFiles = Array.from(affectedFolderIds).flatMap((groupId) => {
+      const normalizedGroupId = groupId || undefined;
+      const remaining = sortFilesByOrder(files.value.filter((file) => (file.folderId || "") === groupId && !moveIdSet.has(file.id)));
+      const group = groupId === (targetFolderId || "") ? [...remaining, ...movedFiles] : remaining;
+      return reindexFiles(group, normalizedGroupId).map((file) => ({
+        ...file,
+        updatedAt: timestamp,
+      }));
+    });
+    const untouched = files.value.filter((file) => !affectedFolderIds.has(file.folderId || "") && !moveIdSet.has(file.id));
+
+    await persistFiles([...untouched, ...nextAffectedFiles]);
+  }
+
+  async function reorderFiles(draggedId: string, targetId: string, position: "before" | "after") {
+    const dragged = files.value.find((file) => file.id === draggedId);
+    const target = files.value.find((file) => file.id === targetId);
+    if (!dragged || !target || dragged.id === target.id) return;
+
+    const targetFolderId = target.folderId || undefined;
+    const groupFiles = sortFilesByOrder(files.value.filter((file) => (file.folderId || "") === (targetFolderId || "")));
+    const remainingGroup = groupFiles.filter((file) => file.id !== draggedId);
+    const draggedNext: SavedSqlFile = {
+      ...dragged,
+      folderId: targetFolderId,
+      updatedAt: nowIso(),
+    };
+    const targetIndex = remainingGroup.findIndex((file) => file.id === targetId);
+    const insertIndex = position === "before" ? targetIndex : targetIndex + 1;
+    remainingGroup.splice(insertIndex, 0, draggedNext);
+
+    const updatedGroup = reindexFiles(remainingGroup, targetFolderId).map((file) => ({
+      ...file,
+      updatedAt: draggedNext.updatedAt,
+    }));
+
+    const previousGroupId = dragged.folderId || undefined;
+    const sourceGroup = previousGroupId === targetFolderId ? [] : reindexFiles(sortFilesByOrder(files.value.filter((file) => file.id !== draggedId && (file.folderId || "") === (previousGroupId || ""))), previousGroupId).map((file) => ({ ...file, updatedAt: draggedNext.updatedAt }));
+
+    const untouched = files.value.filter((file) => file.id !== draggedId && (file.folderId || "") !== (targetFolderId || "") && (file.folderId || "") !== (previousGroupId || ""));
+
+    await persistFiles([...untouched, ...sourceGroup, ...updatedGroup]);
+  }
+
+  const allFolders = computed(() => sortFoldersByOrder(folders.value));
+
+  const allFoldersTreeOrder = computed(() =>
+    [...folders.value].sort((a, b) => {
+      const depthDiff = folderDepth(folders.value, a.id) - folderDepth(folders.value, b.id);
+      if (depthDiff !== 0) return depthDiff;
+      const orderDiff = (a.orderIndex ?? 0) - (b.orderIndex ?? 0);
+      if (orderDiff !== 0) return orderDiff;
+      return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
+    }),
+  );
+
+  const allFiles = computed(() => sortFilesByOrder(files.value));
+
+  function filesInFolder(folderId: string) {
+    return allFiles.value.filter((f) => f.folderId === folderId);
+  }
+
+  function filesWithoutFolder() {
+    return allFiles.value.filter((f) => !f.folderId);
+  }
+
+  function orphanedFileIds(activeConnectionIds: Set<string>) {
+    return new Set(files.value.filter((f) => !activeConnectionIds.has(f.connectionId)).map((f) => f.id));
+  }
+
+  return {
+    folders,
+    files,
+    isLoaded,
+    version,
+    initFromStorage,
+    listFolders,
+    listChildFolders,
+    listFiles,
+    getFile,
+    ensureFileContent,
+    createFolder,
+    renameFolder,
+    deleteFolder,
+    saveFile,
+    renameFile,
+    recordFileUsage,
+    deleteFile,
+    reorderFolders,
+    moveFolderToFolder,
+    reorderFiles,
+    moveFileToFolder,
+    moveFilesToFolder,
+    syncToLocalDirectory,
+    allFolders,
+    allFoldersTreeOrder,
+    allFiles,
+    filesInFolder,
+    filesWithoutFolder,
+    orphanedFileIds,
+  };
+});
diff --git a/apps/desktop/src/stores/settingsStore.ts b/apps/desktop/src/stores/settingsStore.ts
new file mode 100644
index 0000000..6c1fc85
--- /dev/null
+++ b/apps/desktop/src/stores/settingsStore.ts
@@ -0,0 +1,1107 @@
+import { defineStore } from "pinia";
+import { ref } from "vue";
+import * as api from "@/lib/backend/api";
+import { normalizeColumnFormatter, normalizeCustomColumnFormatter, type ColumnFormatterConfig, type CustomColumnFormatterConfig } from "@/lib/dataGrid/columnFormatter";
+import { normalizeShortcutSettings, type ShortcutSettings } from "@/lib/editor/shortcutRegistry";
+import { normalizeResultPageSize } from "@/lib/dataGrid/paginationPageSize";
+import { normalizeSidebarHiddenTablePrefixes } from "@/lib/sidebar/sidebarTableNameDisplay";
+import { DEFAULT_SQL_FORMATTER_SETTINGS, normalizeSqlFormatterSettings, type SqlFormatterSettings } from "@/lib/sql/sqlFormatterConfig";
+import { normalizeSqlVariableSyntaxOverrides, type SqlVariableSyntaxOverrides } from "@/lib/sql/sqlVariableSyntax";
+import type { SidebarActivation } from "@/lib/sidebar/treeNodeClick";
+import type { SqlSnippet } from "@/types/database";
+import { DEFAULT_SQL_SNIPPETS } from "@/lib/sql/sqlCompletion";
+import { setDebugLoggingEnabled } from "@/lib/backend/debugLog";
+import { DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS, normalizeTableColumnTemplateFields } from "@/lib/table/tableColumnTemplates";
+import { DEFAULT_UI_FONT_FAMILY } from "@/lib/app/appFonts";
+import { safeLocalStorageGet, safeLocalStorageRemove } from "@/lib/backend/safeStorage";
+
+export type AiProvider = "claude" | "openai" | "gemini" | "deepseek" | "qwen" | "ollama" | "openai-compatible" | "codex-cli" | "custom";
+export type AiApiStyle = "completions" | "responses" | "anthropic-messages";
+export type AiAuthMethod = "api-key" | "bearer";
+export type AiReasoningLevel = "default" | "minimal" | "low" | "medium" | "high";
+
+export interface AiConfig {
+  provider: AiProvider;
+  apiKey: string;
+  authMethod: AiAuthMethod;
+  endpoint: string;
+  model: string;
+  apiStyle: AiApiStyle;
+  proxyEnabled?: boolean;
+  proxyUrl?: string;
+  enableThinking?: boolean;
+  reasoningLevel?: AiReasoningLevel;
+  contextWindow?: number;
+  codexCliPath?: string | null;
+  codexCliEnv?: Record<string, string>;
+}
+
+export interface AiTestConnectionResult {
+  success: boolean;
+  message: string;
+  latencyMs?: number;
+  modelUsed: string;
+  errorCategory?: string;
+}
+
+export interface DesktopSettings {
+  show_tray_icon: boolean;
+  icon_theme: DesktopIconTheme;
+  quit_on_close: boolean;
+  close_action_prompted: boolean;
+  debug_logging_enabled: boolean;
+  duckdb_worker_process_isolation: boolean;
+  duckdb_worker_max_processes: number;
+  saved_sql_sync_dir?: string | null;
+  driver_store_dir?: string | null;
+  plugin_store_dir?: string | null;
+  agent_store_dir?: string | null;
+  sidebar_table_page_size?: number | null;
+}
+
+export type DesktopIconTheme = "default" | "black";
+
+export type InterfaceLayout = "separated" | "classic";
+
+export type UpdateDownloadSource = "official" | "cnb" | "atomgit";
+export type SqlSemanticDiagnosticsMode = "auto" | "enabled" | "disabled";
+export type OpenTabsRestoreMode = "all" | "pinned" | "none";
+
+export const DEFAULT_SIDEBAR_TABLE_PAGE_SIZE = 1000;
+export const DUCKDB_WORKER_MAX_PROCESSES_MIN = 1;
+export const DUCKDB_WORKER_MAX_PROCESSES_MAX = 16;
+export const DUCKDB_WORKER_MAX_PROCESSES_DEFAULT = 4;
+const SQL_SEMANTIC_DIAGNOSTICS_AUTO_ENABLED = false;
+
+export const DEFAULT_DESKTOP_SETTINGS: DesktopSettings = {
+  show_tray_icon: true,
+  icon_theme: "default",
+  quit_on_close: false,
+  close_action_prompted: false,
+  debug_logging_enabled: false,
+  duckdb_worker_process_isolation: false,
+  duckdb_worker_max_processes: DUCKDB_WORKER_MAX_PROCESSES_DEFAULT,
+  saved_sql_sync_dir: null,
+  driver_store_dir: null,
+  plugin_store_dir: null,
+  agent_store_dir: null,
+  sidebar_table_page_size: DEFAULT_SIDEBAR_TABLE_PAGE_SIZE,
+};
+
+export function normalizeDesktopSettings(settings: Partial<DesktopSettings> | null | undefined): DesktopSettings {
+  const iconTheme = settings?.icon_theme === "black" ? "black" : DEFAULT_DESKTOP_SETTINGS.icon_theme;
+  const sidebarTablePageSize = typeof settings?.sidebar_table_page_size === "number" && settings.sidebar_table_page_size > 0 ? settings.sidebar_table_page_size : DEFAULT_DESKTOP_SETTINGS.sidebar_table_page_size;
+  return {
+    show_tray_icon: settings?.show_tray_icon ?? DEFAULT_DESKTOP_SETTINGS.show_tray_icon,
+    icon_theme: iconTheme,
+    quit_on_close: settings?.quit_on_close ?? DEFAULT_DESKTOP_SETTINGS.quit_on_close,
+    close_action_prompted: settings?.close_action_prompted ?? DEFAULT_DESKTOP_SETTINGS.close_action_prompted,
+    debug_logging_enabled: settings?.debug_logging_enabled ?? DEFAULT_DESKTOP_SETTINGS.debug_logging_enabled,
+    duckdb_worker_process_isolation: settings?.duckdb_worker_process_isolation ?? DEFAULT_DESKTOP_SETTINGS.duckdb_worker_process_isolation,
+    duckdb_worker_max_processes: normalizeDuckDbWorkerMaxProcesses(settings?.duckdb_worker_max_processes),
+    saved_sql_sync_dir: settings?.saved_sql_sync_dir?.trim() || DEFAULT_DESKTOP_SETTINGS.saved_sql_sync_dir,
+    driver_store_dir: settings?.driver_store_dir?.trim() || DEFAULT_DESKTOP_SETTINGS.driver_store_dir,
+    plugin_store_dir: settings?.plugin_store_dir?.trim() || DEFAULT_DESKTOP_SETTINGS.plugin_store_dir,
+    agent_store_dir: settings?.agent_store_dir?.trim() || DEFAULT_DESKTOP_SETTINGS.agent_store_dir,
+    sidebar_table_page_size: sidebarTablePageSize,
+  };
+}
+
+export function normalizeDuckDbWorkerMaxProcesses(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DUCKDB_WORKER_MAX_PROCESSES_DEFAULT;
+  return Math.min(DUCKDB_WORKER_MAX_PROCESSES_MAX, Math.max(DUCKDB_WORKER_MAX_PROCESSES_MIN, Math.round(value)));
+}
+
+export interface AiProviderPreset extends Omit<AiConfig, "apiKey"> {
+  label: string;
+  iconSlug?: string;
+  requiresApiKey: boolean;
+}
+
+export const AI_PROVIDER_PRESETS: Record<AiProvider, AiProviderPreset> = {
+  claude: {
+    label: "Claude",
+    iconSlug: "anthropic",
+    provider: "claude",
+    endpoint: "https://api.anthropic.com/v1/messages",
+    model: "claude-sonnet-4-20250514",
+    apiStyle: "completions",
+    authMethod: "api-key",
+    requiresApiKey: true,
+  },
+  openai: {
+    label: "OpenAI",
+    iconSlug: "openai",
+    provider: "openai",
+    endpoint: "https://api.openai.com/v1/chat/completions",
+    model: "gpt-4o-mini",
+    apiStyle: "completions",
+    authMethod: "bearer",
+    requiresApiKey: true,
+  },
+  gemini: {
+    label: "Gemini",
+    iconSlug: "googlegemini",
+    provider: "gemini",
+    endpoint: "https://generativelanguage.googleapis.com",
+    model: "gemini-1.5-pro",
+    apiStyle: "completions",
+    authMethod: "api-key",
+    requiresApiKey: true,
+  },
+  deepseek: {
+    label: "DeepSeek",
+    iconSlug: "deepseek",
+    provider: "deepseek",
+    endpoint: "https://api.deepseek.com/v1",
+    model: "deepseek-v4-flash",
+    apiStyle: "completions",
+    authMethod: "bearer",
+    requiresApiKey: true,
+  },
+  qwen: {
+    label: "Qwen",
+    iconSlug: "alibabacloud",
+    provider: "qwen",
+    endpoint: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+    model: "qwen-plus",
+    apiStyle: "completions",
+    authMethod: "bearer",
+    requiresApiKey: true,
+  },
+  ollama: {
+    label: "Ollama",
+    iconSlug: "ollama",
+    provider: "ollama",
+    endpoint: "http://localhost:11434/v1",
+    model: "llama3.1",
+    apiStyle: "completions",
+    authMethod: "bearer",
+    requiresApiKey: false,
+  },
+  "openai-compatible": {
+    label: "OpenAI Compatible",
+    iconSlug: "openai",
+    provider: "openai-compatible",
+    endpoint: "",
+    model: "",
+    apiStyle: "completions",
+    authMethod: "bearer",
+    requiresApiKey: true,
+  },
+  "codex-cli": {
+    label: "Codex CLI",
+    iconSlug: "codex",
+    provider: "codex-cli",
+    endpoint: "",
+    model: "default",
+    apiStyle: "completions",
+    authMethod: "bearer",
+    requiresApiKey: false,
+  },
+  custom: {
+    label: "Custom",
+    provider: "custom",
+    endpoint: "",
+    model: "",
+    apiStyle: "completions",
+    authMethod: "bearer",
+    requiresApiKey: true,
+  },
+};
+
+const defaultConfigs: Record<AiProvider, Omit<AiConfig, "apiKey">> = Object.fromEntries(
+  Object.entries(AI_PROVIDER_PRESETS).map(([provider, preset]) => {
+    const { label: _label, iconSlug: _iconSlug, requiresApiKey: _requiresApiKey, ...config } = preset;
+    return [provider, config];
+  }),
+) as Record<AiProvider, Omit<AiConfig, "apiKey">>;
+
+const AI_REASONING_LEVELS: AiReasoningLevel[] = ["default", "minimal", "low", "medium", "high"];
+const AI_ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function normalizeAiReasoningLevel(value: unknown): AiReasoningLevel {
+  return typeof value === "string" && AI_REASONING_LEVELS.includes(value as AiReasoningLevel) ? (value as AiReasoningLevel) : "default";
+}
+
+export function normalizeAiEnv(value: unknown): Record<string, string> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const result: Record<string, string> = {};
+  for (const [rawKey, rawValue] of Object.entries(value as Record<string, unknown>)) {
+    const key = rawKey.trim();
+    if (!key || !AI_ENV_KEY_RE.test(key)) continue;
+    result[key] = rawValue == null ? "" : String(rawValue);
+  }
+  return result;
+}
+
+export function normalizeAiConfig(config: Partial<AiConfig> | null | undefined): AiConfig {
+  const provider = config?.provider && config.provider in AI_PROVIDER_PRESETS ? config.provider : inferAiProviderFromConfig(config);
+  return {
+    ...defaultConfigs[provider],
+    apiKey: config?.apiKey ?? "",
+    ...config,
+    provider,
+    apiStyle: config?.apiStyle ?? defaultConfigs[provider].apiStyle,
+    authMethod: config?.authMethod ?? defaultConfigs[provider].authMethod,
+    proxyEnabled: !!config?.proxyEnabled,
+    proxyUrl: config?.proxyUrl ?? "",
+    enableThinking: config?.enableThinking ?? true,
+    reasoningLevel: normalizeAiReasoningLevel(config?.reasoningLevel),
+    contextWindow: config?.contextWindow ?? undefined,
+    codexCliPath: config?.codexCliPath?.trim() || undefined,
+    codexCliEnv: normalizeAiEnv(config?.codexCliEnv),
+  };
+}
+
+function inferAiProviderFromConfig(config: Partial<AiConfig> | null | undefined): AiProvider {
+  const endpoint = config?.endpoint?.toLowerCase() ?? "";
+  const model = config?.model?.toLowerCase() ?? "";
+  if (endpoint.includes("deepseek") || model.includes("deepseek")) return "deepseek";
+  if (endpoint.includes("dashscope") || endpoint.includes("aliyuncs") || model.includes("qwen")) return "qwen";
+  if (endpoint.includes("generativelanguage.googleapis.com") || model.includes("gemini")) return "gemini";
+  if (endpoint.includes("localhost:11434") || endpoint.includes("127.0.0.1:11434")) return "ollama";
+  if (endpoint.includes("openai.com") || model.startsWith("gpt-")) return "openai";
+  return "claude";
+}
+
+export type EditorTheme =
+  | "app"
+  | "one-dark"
+  | "vscode-dark"
+  | "vscode-light"
+  | "nord"
+  | "okaidia"
+  | "material"
+  | "duotone-light"
+  | "duotone-dark"
+  | "xcode"
+  | "xcode-dark"
+  | "idea-light"
+  | "idea-dark"
+  | "jetbrains-light"
+  | "jetbrains-dark"
+  | "cursor-light"
+  | "cursor-dark"
+  | "claude-light"
+  | "claude-dark"
+  | "custom";
+
+const STRUCTURE_EDITOR_DENSITIES = ["compact", "standard", "comfortable"] as const;
+export type StructureEditorDensity = (typeof STRUCTURE_EDITOR_DENSITIES)[number];
+const COLUMN_WIDTH_DENSITIES = ["compact", "standard", "comfortable"] as const;
+export type ColumnWidthDensity = (typeof COLUMN_WIDTH_DENSITIES)[number];
+const CELL_DETAIL_PANEL_LAYOUTS = ["bottom", "right"] as const;
+export type CellDetailPanelLayout = (typeof CELL_DETAIL_PANEL_LAYOUTS)[number];
+const DATA_GRID_RENDER_MODES = ["dom", "canvas"] as const;
+export type DataGridRenderMode = (typeof DATA_GRID_RENDER_MODES)[number];
+const DATA_GRID_SEARCH_MODES = ["filter", "highlight"] as const;
+export type DataGridSearchMode = (typeof DATA_GRID_SEARCH_MODES)[number];
+export const TABLE_FONT_SIZE_MIN = 8;
+export const TABLE_FONT_SIZE_MAX = 16;
+export const TABLE_FONT_SIZE_DEFAULT = 13;
+const DISCONNECT_TAB_HANDLING_MODES = ["close-tabs", "keep-tabs-clear-results", "keep-tabs-keep-results"] as const;
+export type DisconnectTabHandlingMode = (typeof DISCONNECT_TAB_HANDLING_MODES)[number];
+
+export interface CustomThemeColors {
+  keyword: string;
+  field: string;
+  function: string;
+  string: string;
+  number: string;
+  comment: string;
+  table: string;
+  operator: string;
+  type: string;
+  builtin: string;
+  background?: string;
+  foreground?: string;
+}
+
+export const DEFAULT_CUSTOM_THEME_COLORS: CustomThemeColors = {
+  keyword: "#cba6f7",
+  field: "#f9e2af",
+  function: "#89dceb",
+  string: "#a6e3a1",
+  number: "#fab387",
+  comment: "#6c7086",
+  table: "#a6e3a1",
+  operator: "#89b4fa",
+  type: "#89b4fa",
+  builtin: "#f38ba8",
+};
+
+export interface CustomThemeDdlColors {
+  addedRowBg: string;
+  addedRowBgAlpha: number;
+  removedRowBg: string;
+  removedRowBgAlpha: number;
+  modifiedRowBg: string;
+  modifiedRowBgAlpha: number;
+  modifiedCharBg: string;
+  modifiedCharBgAlpha: number;
+}
+
+export const DEFAULT_CUSTOM_THEME_DDL_COLORS: CustomThemeDdlColors = {
+  addedRowBg: "#22c55e",
+  addedRowBgAlpha: 10,
+  removedRowBg: "#ef4444",
+  removedRowBgAlpha: 10,
+  modifiedRowBg: "#eab308",
+  modifiedRowBgAlpha: 10,
+  modifiedCharBg: "#f59e0b",
+  modifiedCharBgAlpha: 50,
+};
+
+export interface CustomTheme {
+  id: string;
+  name: string;
+  colors: CustomThemeColors;
+  ddlColors: CustomThemeDdlColors;
+}
+
+export const DEFAULT_CUSTOM_THEMES: CustomTheme[] = [{ id: "default", name: "Custom", colors: { ...DEFAULT_CUSTOM_THEME_COLORS }, ddlColors: { ...DEFAULT_CUSTOM_THEME_DDL_COLORS } }];
+
+export interface EditorSettings {
+  fontFamily: string;
+  fontSize: number;
+  uiFontFamily: string;
+  uiScale: number;
+  theme: EditorTheme;
+  customThemeColors: CustomThemeColors;
+  customThemes: CustomTheme[];
+  activeCustomThemeId: string;
+  executeMode: "all" | "current";
+  showExecutionTargetPicker: boolean;
+  showStatementRunButtons: boolean;
+  showCurrentStatementFrame: boolean;
+  showInsertValueHints: boolean;
+  autoAliasTables: boolean;
+  wordWrap: boolean;
+  vimModeEnabled: boolean;
+  autoCloseBrackets: boolean;
+  sqlSemanticDiagnosticsMode: SqlSemanticDiagnosticsMode;
+  sqlSemanticDiagnosticsEnabled: boolean;
+  confirmDangerousSqlExecution: boolean;
+  confirmUnsavedSqlClose: boolean;
+  compactTabTitle: boolean;
+  appLayout: "separated" | "classic";
+  pageSize: number;
+  infiniteScroll: boolean;
+  infiniteScrollMaxRows: number;
+  autoCalculateTotalRows: boolean;
+  mongoViewMode: "document" | "table";
+  showColumnCommentsInHeader: boolean;
+  showColumnTypesInHeader: boolean;
+  compactColumnHeaderActions: boolean;
+  columnWidthDensity: ColumnWidthDensity;
+  dataGridQuickEntry: boolean;
+  dataGridRenderMode: DataGridRenderMode;
+  dataGridSearchMode: DataGridSearchMode;
+  tableFontSize: number;
+  structureEditorDensity: StructureEditorDensity;
+  tableInfoDrawerWidth: number;
+  cellDetailDrawerWidth: number;
+  cellDetailPanelLayout: CellDetailPanelLayout;
+  cellDetailJsonFormatted: boolean;
+  shortcuts: ShortcutSettings;
+  sqlFormatter: SqlFormatterSettings;
+  sidebarActivation: SidebarActivation;
+  sidebarObjectDisplay: "grouped" | "simple";
+  sidebarTableSearchEnabled: boolean;
+  autoSelectActiveSidebarNode: boolean;
+  openTabsRestoreMode: OpenTabsRestoreMode;
+  disconnectTabHandlingMode: DisconnectTabHandlingMode;
+  reuseDataTab: boolean;
+  updateNotificationsEnabled: boolean;
+  sidebarHiddenTablePrefixes: string[];
+  sidebarHideTableComments: boolean;
+  sidebarAllowHorizontalScroll: boolean;
+  columnFormatters: Record<string, ColumnFormatterConfig>;
+  customColumnFormatters: Record<string, CustomColumnFormatterConfig>;
+  snippets: SqlSnippet[];
+  tableColumnTemplateFields: string[];
+  exportBatchSize: number;
+  exportRowLimitEnabled: boolean;
+  exportRowLimit: number;
+  queryExportKeysetOptimizationEnabled: boolean;
+  updateDownloadSource: UpdateDownloadSource;
+  toolbarItems: ToolbarItems;
+  objectBrowserShowCheckbox: boolean;
+  objectBrowserViewMode: "list" | "grid";
+  sqlVariableSyntaxOverrides: SqlVariableSyntaxOverrides;
+}
+
+export interface ToolbarItems {
+  dataTransfer: boolean;
+  driverManager: boolean;
+  sqlFile: boolean;
+  schemaDiff: boolean;
+  dataCompare: boolean;
+  checkUpdates: boolean;
+  sqlLibrary: boolean;
+  sqlFileTree: boolean;
+  history: boolean;
+  ai: boolean;
+  theme: boolean;
+  github: boolean;
+}
+
+export const DEFAULT_TOOLBAR_ITEMS: ToolbarItems = {
+  dataTransfer: true,
+  driverManager: true,
+  sqlFile: true,
+  schemaDiff: true,
+  dataCompare: true,
+  checkUpdates: true,
+  sqlLibrary: true,
+  sqlFileTree: true,
+  history: true,
+  ai: true,
+  theme: true,
+  github: true,
+};
+
+export const EDITOR_THEMES: { value: EditorTheme; label: string; dark: boolean }[] = [
+  { value: "app", label: "Follow app theme", dark: false },
+  { value: "one-dark", label: "One Dark", dark: true },
+  { value: "vscode-dark", label: "VS Dark+", dark: true },
+  { value: "vscode-light", label: "VS Light+", dark: false },
+  { value: "nord", label: "Nord", dark: true },
+  { value: "okaidia", label: "Okaidia", dark: true },
+  { value: "material", label: "Material", dark: true },
+  { value: "duotone-light", label: "Duotone Light", dark: false },
+  { value: "duotone-dark", label: "Duotone Dark", dark: true },
+  { value: "xcode", label: "Xcode", dark: false },
+  { value: "xcode-dark", label: "Xcode Dark", dark: true },
+  { value: "idea-light", label: "IDEA Light", dark: false },
+  { value: "idea-dark", label: "IDEA Darcula", dark: true },
+  { value: "jetbrains-light", label: "JetBrains Light", dark: false },
+  { value: "jetbrains-dark", label: "JetBrains Dark", dark: true },
+  { value: "cursor-light", label: "Cursor Light", dark: false },
+  { value: "cursor-dark", label: "Cursor Dark", dark: true },
+  { value: "claude-light", label: "Claude Code Light", dark: false },
+  { value: "claude-dark", label: "Claude Code Dark", dark: true },
+  { value: "custom", label: "Custom", dark: true },
+];
+
+const EDITOR_THEME_VALUES = new Set<EditorTheme>(EDITOR_THEMES.map((theme) => theme.value));
+
+export const FONT_FAMILIES: { value: string; label: string }[] = [
+  { value: "'Fira Code', 'Cascadia Code', 'Cascadia Mono', 'JetBrains Mono', monospace", label: "Fira Code" },
+  { value: "'JetBrains Mono', 'Fira Code', monospace", label: "JetBrains Mono" },
+  { value: "'Cascadia Code', 'Cascadia Mono', monospace", label: "Cascadia Code" },
+  { value: "'Source Code Pro', monospace", label: "Source Code Pro" },
+  { value: "'SF Mono', 'Menlo', monospace", label: "SF Mono / Menlo" },
+  { value: "'Consolas', 'Courier New', monospace", label: "Consolas" },
+  { value: "monospace", label: "System Monospace" },
+];
+
+export const DEFAULT_EDITOR_SETTINGS: EditorSettings = {
+  fontFamily: "'Fira Code', 'Cascadia Code', 'Cascadia Mono', 'JetBrains Mono', monospace",
+  fontSize: 13,
+  uiFontFamily: DEFAULT_UI_FONT_FAMILY,
+  uiScale: 1,
+  theme: "app",
+  customThemeColors: { ...DEFAULT_CUSTOM_THEME_COLORS },
+  customThemes: [...DEFAULT_CUSTOM_THEMES],
+  activeCustomThemeId: "default",
+  executeMode: "all",
+  showExecutionTargetPicker: false,
+  showStatementRunButtons: true,
+  showCurrentStatementFrame: true,
+  showInsertValueHints: true,
+  autoAliasTables: true,
+  wordWrap: false,
+  vimModeEnabled: false,
+  autoCloseBrackets: true,
+  sqlSemanticDiagnosticsMode: "auto",
+  sqlSemanticDiagnosticsEnabled: SQL_SEMANTIC_DIAGNOSTICS_AUTO_ENABLED,
+  confirmDangerousSqlExecution: true,
+  confirmUnsavedSqlClose: true,
+  compactTabTitle: false,
+  appLayout: "classic",
+  pageSize: 100,
+  infiniteScroll: false,
+  infiniteScrollMaxRows: 5000,
+  autoCalculateTotalRows: false,
+  mongoViewMode: "document",
+  showColumnCommentsInHeader: true,
+  showColumnTypesInHeader: true,
+  compactColumnHeaderActions: true,
+  columnWidthDensity: "standard",
+  dataGridQuickEntry: false,
+  dataGridRenderMode: "canvas",
+  dataGridSearchMode: "filter",
+  tableFontSize: TABLE_FONT_SIZE_DEFAULT,
+  structureEditorDensity: "compact",
+  tableInfoDrawerWidth: 320,
+  cellDetailDrawerWidth: 380,
+  cellDetailPanelLayout: "bottom",
+  cellDetailJsonFormatted: false,
+  shortcuts: normalizeShortcutSettings(),
+  sqlFormatter: normalizeSqlFormatterSettings(DEFAULT_SQL_FORMATTER_SETTINGS),
+  sidebarActivation: "single",
+  sidebarObjectDisplay: "grouped",
+  sidebarTableSearchEnabled: false,
+  autoSelectActiveSidebarNode: false,
+  openTabsRestoreMode: "all",
+  disconnectTabHandlingMode: "close-tabs",
+  reuseDataTab: false,
+  updateNotificationsEnabled: true,
+  sidebarHiddenTablePrefixes: [],
+  sidebarHideTableComments: false,
+  sidebarAllowHorizontalScroll: false,
+  columnFormatters: {},
+  customColumnFormatters: {},
+  snippets: DEFAULT_SQL_SNIPPETS,
+  tableColumnTemplateFields: [...DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS],
+  exportBatchSize: 2000,
+  exportRowLimitEnabled: false,
+  exportRowLimit: 100000,
+  queryExportKeysetOptimizationEnabled: true,
+  updateDownloadSource: "official",
+  toolbarItems: { ...DEFAULT_TOOLBAR_ITEMS },
+  objectBrowserShowCheckbox: false,
+  objectBrowserViewMode: "list",
+  sqlVariableSyntaxOverrides: {},
+};
+
+export const STORAGE_KEY = "dbx-editor-settings";
+const OLD_FONT_SIZE_KEY = "dbx-query-editor-font-size";
+const EXPORT_BATCH_SIZE_DEFAULT_MIGRATION_KEY = "dbx-export-batch-size-default-migrated-v1";
+const LEGACY_DEFAULT_EXPORT_BATCH_SIZE = 10000;
+const MIN_UI_SCALE = 0.75;
+const MAX_UI_SCALE = 2;
+
+function normalizeUiScale(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_EDITOR_SETTINGS.uiScale;
+  return Math.min(MAX_UI_SCALE, Math.max(MIN_UI_SCALE, Math.round(value * 100) / 100));
+}
+
+function normalizeFontFamily(value: unknown, fallback: string): string {
+  if (typeof value !== "string") return fallback;
+  const trimmed = value.trim();
+  return trimmed || fallback;
+}
+
+function normalizeDrawerWidth(value: unknown, min: number, fallback: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(900, Math.max(min, Math.round(value)));
+}
+
+function normalizeStructureEditorDensity(value: unknown): StructureEditorDensity {
+  return STRUCTURE_EDITOR_DENSITIES.includes(value as StructureEditorDensity) ? (value as StructureEditorDensity) : DEFAULT_EDITOR_SETTINGS.structureEditorDensity;
+}
+function normalizeColumnWidthDensity(value: unknown): ColumnWidthDensity {
+  return COLUMN_WIDTH_DENSITIES.includes(value as ColumnWidthDensity) ? (value as ColumnWidthDensity) : DEFAULT_EDITOR_SETTINGS.columnWidthDensity;
+}
+
+function normalizeCellDetailPanelLayout(value: unknown): CellDetailPanelLayout {
+  return CELL_DETAIL_PANEL_LAYOUTS.includes(value as CellDetailPanelLayout) ? (value as CellDetailPanelLayout) : DEFAULT_EDITOR_SETTINGS.cellDetailPanelLayout;
+}
+
+function normalizeDataGridRenderMode(value: unknown): DataGridRenderMode {
+  return DATA_GRID_RENDER_MODES.includes(value as DataGridRenderMode) ? (value as DataGridRenderMode) : DEFAULT_EDITOR_SETTINGS.dataGridRenderMode;
+}
+
+function normalizeDataGridSearchMode(value: unknown): DataGridSearchMode {
+  return DATA_GRID_SEARCH_MODES.includes(value as DataGridSearchMode) ? (value as DataGridSearchMode) : DEFAULT_EDITOR_SETTINGS.dataGridSearchMode;
+}
+
+function normalizeTableFontSize(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return TABLE_FONT_SIZE_DEFAULT;
+  return Math.min(TABLE_FONT_SIZE_MAX, Math.max(TABLE_FONT_SIZE_MIN, Math.round(value)));
+}
+
+function normalizeUpdateDownloadSource(value: unknown): UpdateDownloadSource {
+  if (value === "atomgit") return "atomgit";
+  return value === "cnb" ? "cnb" : DEFAULT_EDITOR_SETTINGS.updateDownloadSource;
+}
+
+function normalizeSqlSemanticDiagnosticsMode(value: unknown, legacyEnabled?: unknown): SqlSemanticDiagnosticsMode {
+  if (value === "auto" || value === "enabled" || value === "disabled") return value;
+  if (typeof legacyEnabled === "boolean") return legacyEnabled ? "enabled" : "disabled";
+  return DEFAULT_EDITOR_SETTINGS.sqlSemanticDiagnosticsMode;
+}
+
+function sqlSemanticDiagnosticsEnabledForMode(mode: SqlSemanticDiagnosticsMode): boolean {
+  if (mode === "enabled") return true;
+  if (mode === "disabled") return false;
+  return SQL_SEMANTIC_DIAGNOSTICS_AUTO_ENABLED;
+}
+
+function normalizeDisconnectTabHandlingMode(value: unknown, legacyCloseTabsOnDisconnect?: unknown): DisconnectTabHandlingMode {
+  if (DISCONNECT_TAB_HANDLING_MODES.includes(value as DisconnectTabHandlingMode)) {
+    return value as DisconnectTabHandlingMode;
+  }
+  if (value === "clear-state") return "keep-tabs-clear-results";
+  if (value === "keep-tabs") return "keep-tabs-keep-results";
+  if (typeof legacyCloseTabsOnDisconnect === "boolean") {
+    return legacyCloseTabsOnDisconnect ? "close-tabs" : "keep-tabs-clear-results";
+  }
+  return DEFAULT_EDITOR_SETTINGS.disconnectTabHandlingMode;
+}
+
+function normalizeOpenTabsRestoreMode(value: unknown, legacyRestoreOpenTabsOnLaunch?: unknown): OpenTabsRestoreMode {
+  if (value === "all" || value === "pinned" || value === "none") return value;
+  if (typeof legacyRestoreOpenTabsOnLaunch === "boolean") return legacyRestoreOpenTabsOnLaunch ? "all" : "none";
+  return DEFAULT_EDITOR_SETTINGS.openTabsRestoreMode;
+}
+
+function normalizeColumnFormatters(value: unknown): Record<string, ColumnFormatterConfig> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const formatters: Record<string, ColumnFormatterConfig> = {};
+  for (const [key, formatter] of Object.entries(value as Record<string, unknown>)) {
+    const normalized = normalizeColumnFormatter(formatter);
+    if (normalized) formatters[key] = normalized;
+  }
+  return formatters;
+}
+
+function normalizeCustomColumnFormatters(value: unknown): Record<string, CustomColumnFormatterConfig> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  const formatters: Record<string, CustomColumnFormatterConfig> = {};
+  for (const formatter of Object.values(value as Record<string, unknown>)) {
+    const normalized = normalizeCustomColumnFormatter(formatter);
+    if (normalized) formatters[normalized.id] = normalized;
+  }
+  return formatters;
+}
+
+function normalizeSqlSnippets(value: unknown, existing?: SqlSnippet[]): SqlSnippet[] {
+  if (!Array.isArray(value)) return existing ?? DEFAULT_SQL_SNIPPETS;
+  if (value.length === 0) return [];
+  const valid: SqlSnippet[] = [];
+  const seenPrefixes = new Set<string>();
+  for (const item of value) {
+    if (!item || typeof item !== "object" || typeof item.id !== "string" || !item.id || typeof item.label !== "string" || !item.label || typeof item.prefix !== "string" || !item.prefix || typeof item.body !== "string") {
+      continue;
+    }
+    if (seenPrefixes.has(item.prefix)) continue;
+    seenPrefixes.add(item.prefix);
+    // Older settings do not have this field; only an explicit false disables a snippet.
+    valid.push({ id: item.id, label: item.label, prefix: item.prefix, body: item.body, enabled: item.enabled !== false });
+  }
+  if (valid.length === 0) return existing ?? DEFAULT_SQL_SNIPPETS;
+  return valid;
+}
+
+function normalizeToolbarItems(items: Partial<ToolbarItems> | undefined): ToolbarItems {
+  const defaults = DEFAULT_TOOLBAR_ITEMS;
+  if (!items || typeof items !== "object") return { ...defaults };
+  return {
+    dataTransfer: items.dataTransfer ?? defaults.dataTransfer,
+    driverManager: items.driverManager ?? defaults.driverManager,
+    sqlFile: items.sqlFile ?? defaults.sqlFile,
+    schemaDiff: items.schemaDiff ?? defaults.schemaDiff,
+    dataCompare: items.dataCompare ?? defaults.dataCompare,
+    checkUpdates: items.checkUpdates ?? defaults.checkUpdates,
+    sqlLibrary: items.sqlLibrary ?? defaults.sqlLibrary,
+    sqlFileTree: items.sqlFileTree ?? defaults.sqlFileTree,
+    history: items.history ?? defaults.history,
+    ai: items.ai ?? defaults.ai,
+    theme: items.theme ?? defaults.theme,
+    github: items.github ?? defaults.github,
+  };
+}
+
+export function normalizeEditorSettings(settings: Partial<EditorSettings>, existing?: EditorSettings): EditorSettings {
+  const sqlSemanticDiagnosticsMode = normalizeSqlSemanticDiagnosticsMode(settings.sqlSemanticDiagnosticsMode, settings.sqlSemanticDiagnosticsEnabled);
+  return {
+    fontFamily: normalizeFontFamily(settings.fontFamily, DEFAULT_EDITOR_SETTINGS.fontFamily),
+    fontSize: settings.fontSize ?? DEFAULT_EDITOR_SETTINGS.fontSize,
+    uiFontFamily: normalizeFontFamily(settings.uiFontFamily, DEFAULT_EDITOR_SETTINGS.uiFontFamily),
+    uiScale: normalizeUiScale(settings.uiScale),
+    theme: settings.theme && EDITOR_THEME_VALUES.has(settings.theme) ? settings.theme : DEFAULT_EDITOR_SETTINGS.theme,
+    customThemeColors: {
+      ...DEFAULT_CUSTOM_THEME_COLORS,
+      ...settings.customThemeColors,
+    },
+    customThemes: (() => {
+      if (Array.isArray(settings.customThemes) && settings.customThemes.length > 0) {
+        return settings.customThemes.map((theme) => {
+          const renamed = theme.name === "默认" ? { ...theme, name: "Custom" } : { ...theme };
+          return {
+            ...renamed,
+            colors: { ...DEFAULT_CUSTOM_THEME_COLORS, ...renamed.colors },
+            ddlColors: { ...DEFAULT_CUSTOM_THEME_DDL_COLORS, ...(renamed as any).ddlColors },
+          };
+        });
+      }
+      return settings.customThemeColors
+        ? [
+            {
+              id: "migrated",
+              name: "Migrated",
+              colors: { ...DEFAULT_CUSTOM_THEME_COLORS, ...settings.customThemeColors },
+              ddlColors: { ...DEFAULT_CUSTOM_THEME_DDL_COLORS },
+            },
+          ]
+        : [];
+    })(),
+    activeCustomThemeId: settings.activeCustomThemeId ?? "default",
+    executeMode: settings.executeMode ?? DEFAULT_EDITOR_SETTINGS.executeMode,
+    showExecutionTargetPicker: settings.showExecutionTargetPicker ?? DEFAULT_EDITOR_SETTINGS.showExecutionTargetPicker,
+    showStatementRunButtons: typeof settings.showStatementRunButtons === "boolean" ? settings.showStatementRunButtons : DEFAULT_EDITOR_SETTINGS.showStatementRunButtons,
+    showCurrentStatementFrame: typeof settings.showCurrentStatementFrame === "boolean" ? settings.showCurrentStatementFrame : DEFAULT_EDITOR_SETTINGS.showCurrentStatementFrame,
+    showInsertValueHints: typeof settings.showInsertValueHints === "boolean" ? settings.showInsertValueHints : DEFAULT_EDITOR_SETTINGS.showInsertValueHints,
+    autoAliasTables: settings.autoAliasTables ?? DEFAULT_EDITOR_SETTINGS.autoAliasTables,
+    wordWrap: settings.wordWrap ?? DEFAULT_EDITOR_SETTINGS.wordWrap,
+    vimModeEnabled: typeof settings.vimModeEnabled === "boolean" ? settings.vimModeEnabled : DEFAULT_EDITOR_SETTINGS.vimModeEnabled,
+    autoCloseBrackets: typeof settings.autoCloseBrackets === "boolean" ? settings.autoCloseBrackets : DEFAULT_EDITOR_SETTINGS.autoCloseBrackets,
+    sqlSemanticDiagnosticsMode,
+    sqlSemanticDiagnosticsEnabled: sqlSemanticDiagnosticsEnabledForMode(sqlSemanticDiagnosticsMode),
+    confirmDangerousSqlExecution: settings.confirmDangerousSqlExecution ?? DEFAULT_EDITOR_SETTINGS.confirmDangerousSqlExecution,
+    confirmUnsavedSqlClose: settings.confirmUnsavedSqlClose ?? DEFAULT_EDITOR_SETTINGS.confirmUnsavedSqlClose,
+    compactTabTitle: settings.compactTabTitle ?? DEFAULT_EDITOR_SETTINGS.compactTabTitle,
+    appLayout: settings.appLayout ?? DEFAULT_EDITOR_SETTINGS.appLayout,
+    pageSize: normalizeResultPageSize(settings.pageSize),
+    infiniteScroll: settings.infiniteScroll ?? DEFAULT_EDITOR_SETTINGS.infiniteScroll,
+    infiniteScrollMaxRows: typeof settings.infiniteScrollMaxRows === "number" && settings.infiniteScrollMaxRows >= 1000 && settings.infiniteScrollMaxRows <= 50000 ? Math.round(settings.infiniteScrollMaxRows) : DEFAULT_EDITOR_SETTINGS.infiniteScrollMaxRows,
+    autoCalculateTotalRows: settings.autoCalculateTotalRows ?? DEFAULT_EDITOR_SETTINGS.autoCalculateTotalRows,
+    mongoViewMode: settings.mongoViewMode === "table" ? "table" : DEFAULT_EDITOR_SETTINGS.mongoViewMode,
+    showColumnCommentsInHeader: settings.showColumnCommentsInHeader ?? DEFAULT_EDITOR_SETTINGS.showColumnCommentsInHeader,
+    showColumnTypesInHeader: settings.showColumnTypesInHeader ?? DEFAULT_EDITOR_SETTINGS.showColumnTypesInHeader,
+    compactColumnHeaderActions: settings.compactColumnHeaderActions ?? DEFAULT_EDITOR_SETTINGS.compactColumnHeaderActions,
+    columnWidthDensity: normalizeColumnWidthDensity(settings.columnWidthDensity),
+    dataGridQuickEntry: settings.dataGridQuickEntry ?? DEFAULT_EDITOR_SETTINGS.dataGridQuickEntry,
+    dataGridRenderMode: normalizeDataGridRenderMode(settings.dataGridRenderMode),
+    dataGridSearchMode: normalizeDataGridSearchMode(settings.dataGridSearchMode),
+    tableFontSize: normalizeTableFontSize(settings.tableFontSize),
+    structureEditorDensity: normalizeStructureEditorDensity(settings.structureEditorDensity),
+    tableInfoDrawerWidth: normalizeDrawerWidth(settings.tableInfoDrawerWidth, 240, DEFAULT_EDITOR_SETTINGS.tableInfoDrawerWidth),
+    cellDetailDrawerWidth: normalizeDrawerWidth(settings.cellDetailDrawerWidth, 260, DEFAULT_EDITOR_SETTINGS.cellDetailDrawerWidth),
+    cellDetailPanelLayout: normalizeCellDetailPanelLayout(settings.cellDetailPanelLayout),
+    cellDetailJsonFormatted: typeof settings.cellDetailJsonFormatted === "boolean" ? settings.cellDetailJsonFormatted : DEFAULT_EDITOR_SETTINGS.cellDetailJsonFormatted,
+    shortcuts: normalizeShortcutSettings(settings.shortcuts),
+    sqlFormatter: normalizeSqlFormatterSettings(settings.sqlFormatter),
+    sidebarActivation: settings.sidebarActivation === "single" || settings.sidebarActivation === "double" ? settings.sidebarActivation : DEFAULT_EDITOR_SETTINGS.sidebarActivation,
+    sidebarObjectDisplay: settings.sidebarObjectDisplay === "simple" || settings.sidebarObjectDisplay === "grouped" ? settings.sidebarObjectDisplay : DEFAULT_EDITOR_SETTINGS.sidebarObjectDisplay,
+    sidebarTableSearchEnabled: typeof settings.sidebarTableSearchEnabled === "boolean" ? settings.sidebarTableSearchEnabled : DEFAULT_EDITOR_SETTINGS.sidebarTableSearchEnabled,
+    autoSelectActiveSidebarNode: settings.autoSelectActiveSidebarNode ?? DEFAULT_EDITOR_SETTINGS.autoSelectActiveSidebarNode,
+    openTabsRestoreMode: normalizeOpenTabsRestoreMode((settings as Partial<EditorSettings>).openTabsRestoreMode, (settings as Partial<EditorSettings> & { restoreOpenTabsOnLaunch?: boolean }).restoreOpenTabsOnLaunch),
+    disconnectTabHandlingMode: normalizeDisconnectTabHandlingMode((settings as Partial<EditorSettings>).disconnectTabHandlingMode, (settings as Partial<EditorSettings> & { closeQueryTabsOnDisconnect?: boolean }).closeQueryTabsOnDisconnect),
+    reuseDataTab: settings.reuseDataTab ?? DEFAULT_EDITOR_SETTINGS.reuseDataTab,
+    updateNotificationsEnabled: settings.updateNotificationsEnabled ?? DEFAULT_EDITOR_SETTINGS.updateNotificationsEnabled,
+    sidebarHiddenTablePrefixes: normalizeSidebarHiddenTablePrefixes(settings.sidebarHiddenTablePrefixes),
+    sidebarHideTableComments: settings.sidebarHideTableComments ?? DEFAULT_EDITOR_SETTINGS.sidebarHideTableComments,
+    sidebarAllowHorizontalScroll: settings.sidebarAllowHorizontalScroll ?? DEFAULT_EDITOR_SETTINGS.sidebarAllowHorizontalScroll,
+    columnFormatters: normalizeColumnFormatters(settings.columnFormatters),
+    customColumnFormatters: normalizeCustomColumnFormatters(settings.customColumnFormatters),
+    snippets: normalizeSqlSnippets(settings.snippets, existing?.snippets),
+    tableColumnTemplateFields: normalizeTableColumnTemplateFields(settings.tableColumnTemplateFields),
+    exportBatchSize: typeof settings.exportBatchSize === "number" && settings.exportBatchSize >= 100 && settings.exportBatchSize <= 100000 ? Math.round(settings.exportBatchSize) : DEFAULT_EDITOR_SETTINGS.exportBatchSize,
+    exportRowLimitEnabled: typeof settings.exportRowLimitEnabled === "boolean" ? settings.exportRowLimitEnabled : DEFAULT_EDITOR_SETTINGS.exportRowLimitEnabled,
+    exportRowLimit: typeof settings.exportRowLimit === "number" && settings.exportRowLimit >= 100 && settings.exportRowLimit <= 2147483647 ? Math.round(settings.exportRowLimit) : DEFAULT_EDITOR_SETTINGS.exportRowLimit,
+    queryExportKeysetOptimizationEnabled: typeof settings.queryExportKeysetOptimizationEnabled === "boolean" ? settings.queryExportKeysetOptimizationEnabled : DEFAULT_EDITOR_SETTINGS.queryExportKeysetOptimizationEnabled,
+    updateDownloadSource: normalizeUpdateDownloadSource(settings.updateDownloadSource),
+    toolbarItems: normalizeToolbarItems(settings.toolbarItems),
+    objectBrowserShowCheckbox: typeof settings.objectBrowserShowCheckbox === "boolean" ? settings.objectBrowserShowCheckbox : DEFAULT_EDITOR_SETTINGS.objectBrowserShowCheckbox,
+    objectBrowserViewMode: settings.objectBrowserViewMode === "grid" ? "grid" : DEFAULT_EDITOR_SETTINGS.objectBrowserViewMode,
+    sqlVariableSyntaxOverrides: normalizeSqlVariableSyntaxOverrides(settings.sqlVariableSyntaxOverrides),
+  };
+}
+
+function loadLegacyEditorSettings(): EditorSettings | null {
+  const raw = safeLocalStorageGet(STORAGE_KEY);
+  if (raw) {
+    try {
+      const parsed = JSON.parse(raw) as Partial<EditorSettings>;
+      if (parsed.exportBatchSize === LEGACY_DEFAULT_EXPORT_BATCH_SIZE && safeLocalStorageGet(EXPORT_BATCH_SIZE_DEFAULT_MIGRATION_KEY) !== "1") {
+        parsed.exportBatchSize = DEFAULT_EDITOR_SETTINGS.exportBatchSize;
+      }
+      return normalizeEditorSettings(parsed);
+    } catch {
+      return null;
+    }
+  }
+
+  const oldSize = safeLocalStorageGet(OLD_FONT_SIZE_KEY);
+  if (!oldSize) return null;
+  const parsed = parseInt(oldSize, 10);
+  return Number.isNaN(parsed) ? null : normalizeEditorSettings({ fontSize: parsed });
+}
+
+function clearLegacyEditorSettings() {
+  safeLocalStorageRemove(STORAGE_KEY);
+  safeLocalStorageRemove(OLD_FONT_SIZE_KEY);
+  safeLocalStorageRemove(EXPORT_BATCH_SIZE_DEFAULT_MIGRATION_KEY);
+}
+
+function saveEditorSettings(settings: EditorSettings) {
+  void api.saveEditorSettings(settings).catch(() => {});
+}
+
+export const useSettingsStore = defineStore("settings", () => {
+  const settingsPageActive = ref(false);
+  const aiConfig = ref<AiConfig>(normalizeAiConfig({ provider: "claude" }));
+  const isAiConfigLoaded = ref(false);
+  const aiProviderConfigs = ref<Partial<Record<AiProvider, AiConfig>>>({});
+  const desktopSettings = ref<DesktopSettings>({ ...DEFAULT_DESKTOP_SETTINGS });
+  const isDesktopSettingsLoaded = ref(false);
+  const isEditorSettingsLoaded = ref(false);
+
+  const editorSettings = ref<EditorSettings>(normalizeEditorSettings({}));
+
+  async function initEditorSettings() {
+    if (isEditorSettingsLoaded.value) return;
+    const saved = await api.loadEditorSettings().catch(() => null);
+    if (saved && typeof saved === "object" && !Array.isArray(saved)) {
+      editorSettings.value = normalizeEditorSettings(saved as Partial<EditorSettings>);
+      isEditorSettingsLoaded.value = true;
+      return;
+    }
+
+    const legacy = loadLegacyEditorSettings();
+    if (legacy) {
+      editorSettings.value = legacy;
+      try {
+        await api.saveEditorSettings(legacy);
+        // Existing desktop users keep settings in localStorage; remove them only
+        // after the async store has accepted the migrated value.
+        clearLegacyEditorSettings();
+      } catch {
+        /* keep legacy values for a later migration attempt */
+      }
+    }
+    isEditorSettingsLoaded.value = true;
+  }
+
+  async function initDesktopSettings() {
+    if (isDesktopSettingsLoaded.value) return;
+    desktopSettings.value = normalizeDesktopSettings(await api.loadDesktopSettings().catch(() => null));
+    setDebugLoggingEnabled(desktopSettings.value.debug_logging_enabled);
+    isDesktopSettingsLoaded.value = true;
+  }
+
+  async function updateDesktopSettings(partial: Partial<DesktopSettings>) {
+    const previous = desktopSettings.value;
+    const next = {
+      ...desktopSettings.value,
+      ...partial,
+    };
+    desktopSettings.value = normalizeDesktopSettings(next);
+    setDebugLoggingEnabled(desktopSettings.value.debug_logging_enabled);
+    try {
+      await api.saveDesktopSettings(desktopSettings.value);
+    } catch (error) {
+      desktopSettings.value = previous;
+      setDebugLoggingEnabled(previous.debug_logging_enabled);
+      throw error;
+    }
+  }
+
+  async function initAiConfig() {
+    if (isAiConfigLoaded.value) return;
+    const legacy = localStorage.getItem("dbx-ai-config");
+    const [savedActive, savedProviderConfigs] = await Promise.all([api.loadAiConfig().catch(() => null), api.loadAiProviderConfigs().catch(() => null) as Promise<Partial<Record<AiProvider, AiConfig>> | null>]);
+
+    if (savedActive) {
+      aiConfig.value = normalizeAiConfig(savedActive);
+    } else if (legacy) {
+      aiConfig.value = normalizeAiConfig(JSON.parse(legacy));
+      await api.saveAiConfig(aiConfig.value).catch(() => {});
+      localStorage.removeItem("dbx-ai-config");
+    }
+
+    if (savedProviderConfigs) {
+      aiProviderConfigs.value = savedProviderConfigs;
+    }
+
+    // Ensure active config is reflected in provider map (overwrite if exists, to guarantee consistency)
+    const activeProvider = aiConfig.value.provider;
+    aiProviderConfigs.value[activeProvider] = { ...aiConfig.value };
+
+    isAiConfigLoaded.value = true;
+  }
+
+  function updateAiConfig(config: Partial<AiConfig>) {
+    const previousProvider = aiConfig.value.provider;
+    const targetProvider = config.provider;
+    const switchingProvider = !!targetProvider && targetProvider !== previousProvider;
+
+    if (switchingProvider) {
+      // Save current provider's config before switching
+      aiProviderConfigs.value[previousProvider] = { ...aiConfig.value };
+      api.saveAiProviderConfig(previousProvider, aiConfig.value).catch(() => {});
+
+      // Restore saved config for target provider, or use preset defaults
+      const savedConfig = aiProviderConfigs.value[targetProvider];
+      if (savedConfig) {
+        aiConfig.value = normalizeAiConfig({ ...savedConfig, provider: targetProvider });
+      } else {
+        aiConfig.value = normalizeAiConfig({ provider: targetProvider });
+      }
+      // Don't merge caller fields when switching — caller passes only { provider }
+    } else {
+      // Not switching provider — apply partial update
+      Object.assign(aiConfig.value, config);
+    }
+
+    aiProviderConfigs.value[aiConfig.value.provider] = { ...aiConfig.value };
+    api.saveAiConfig(aiConfig.value).catch(() => {});
+    api.saveAiProviderConfig(aiConfig.value.provider, aiConfig.value).catch(() => {});
+  }
+
+  function isConfigured(): boolean {
+    const preset = AI_PROVIDER_PRESETS[aiConfig.value.provider];
+    if (aiConfig.value.provider === "codex-cli") return true;
+    return !!aiConfig.value.endpoint && !!aiConfig.value.model && (!preset.requiresApiKey || !!aiConfig.value.apiKey);
+  }
+
+  function isAiProviderConfigured(provider: AiProvider): boolean {
+    const config = aiProviderConfigs.value[provider];
+    if (!config) return false;
+    if (provider === "codex-cli") return true;
+    const preset = AI_PROVIDER_PRESETS[provider];
+    return !!config.endpoint?.trim() && !!config.model?.trim() && (!preset.requiresApiKey || !!config.apiKey?.trim());
+  }
+
+  function updateEditorSettings(partial: Partial<EditorSettings>) {
+    if (partial.fontFamily !== undefined) editorSettings.value.fontFamily = normalizeFontFamily(partial.fontFamily, DEFAULT_EDITOR_SETTINGS.fontFamily);
+    if (partial.fontSize !== undefined) editorSettings.value.fontSize = partial.fontSize;
+    if (partial.uiFontFamily !== undefined) editorSettings.value.uiFontFamily = normalizeFontFamily(partial.uiFontFamily, DEFAULT_EDITOR_SETTINGS.uiFontFamily);
+    if (partial.uiScale !== undefined) editorSettings.value.uiScale = normalizeUiScale(partial.uiScale);
+    if (partial.theme !== undefined) editorSettings.value.theme = partial.theme;
+    if (partial.customThemeColors !== undefined) {
+      editorSettings.value.customThemeColors = {
+        ...editorSettings.value.customThemeColors,
+        ...partial.customThemeColors,
+      };
+    }
+    if (partial.customThemes !== undefined) {
+      editorSettings.value.customThemes = Array.isArray(partial.customThemes) ? partial.customThemes : editorSettings.value.customThemes;
+    }
+    if (partial.activeCustomThemeId !== undefined) {
+      editorSettings.value.activeCustomThemeId = partial.activeCustomThemeId;
+    }
+    if (partial.customThemes !== undefined || partial.activeCustomThemeId !== undefined) {
+      const themes = editorSettings.value.customThemes;
+      const activeId = editorSettings.value.activeCustomThemeId;
+      const activeTheme = themes.find((t) => t.id === activeId) || themes[0];
+      if (activeTheme) {
+        editorSettings.value.customThemeColors = { ...activeTheme.colors };
+      }
+    }
+    if (partial.executeMode !== undefined) editorSettings.value.executeMode = partial.executeMode;
+    if (partial.showExecutionTargetPicker !== undefined) editorSettings.value.showExecutionTargetPicker = partial.showExecutionTargetPicker;
+    if (partial.showStatementRunButtons !== undefined) editorSettings.value.showStatementRunButtons = partial.showStatementRunButtons === true;
+    if (partial.showCurrentStatementFrame !== undefined) editorSettings.value.showCurrentStatementFrame = partial.showCurrentStatementFrame === true;
+    if (partial.showInsertValueHints !== undefined) editorSettings.value.showInsertValueHints = partial.showInsertValueHints === true;
+    if (partial.autoAliasTables !== undefined) editorSettings.value.autoAliasTables = partial.autoAliasTables;
+    if (partial.wordWrap !== undefined) editorSettings.value.wordWrap = partial.wordWrap;
+    if (partial.vimModeEnabled !== undefined) editorSettings.value.vimModeEnabled = partial.vimModeEnabled === true;
+    if (partial.autoCloseBrackets !== undefined) editorSettings.value.autoCloseBrackets = partial.autoCloseBrackets === true;
+    if (partial.sqlSemanticDiagnosticsMode !== undefined || partial.sqlSemanticDiagnosticsEnabled !== undefined) {
+      const nextMode = normalizeSqlSemanticDiagnosticsMode(partial.sqlSemanticDiagnosticsMode, partial.sqlSemanticDiagnosticsEnabled);
+      editorSettings.value.sqlSemanticDiagnosticsMode = nextMode;
+      editorSettings.value.sqlSemanticDiagnosticsEnabled = sqlSemanticDiagnosticsEnabledForMode(nextMode);
+    }
+    if (partial.confirmDangerousSqlExecution !== undefined) editorSettings.value.confirmDangerousSqlExecution = partial.confirmDangerousSqlExecution;
+    if (partial.confirmUnsavedSqlClose !== undefined) editorSettings.value.confirmUnsavedSqlClose = partial.confirmUnsavedSqlClose;
+    if (partial.compactTabTitle !== undefined) editorSettings.value.compactTabTitle = partial.compactTabTitle;
+    if (partial.appLayout !== undefined) editorSettings.value.appLayout = partial.appLayout;
+    if (partial.pageSize !== undefined) editorSettings.value.pageSize = normalizeResultPageSize(partial.pageSize);
+    if (partial.infiniteScroll !== undefined) editorSettings.value.infiniteScroll = partial.infiniteScroll;
+    if (partial.infiniteScrollMaxRows !== undefined)
+      editorSettings.value.infiniteScrollMaxRows = typeof partial.infiniteScrollMaxRows === "number" && partial.infiniteScrollMaxRows >= 1000 && partial.infiniteScrollMaxRows <= 50000 ? Math.round(partial.infiniteScrollMaxRows) : DEFAULT_EDITOR_SETTINGS.infiniteScrollMaxRows;
+    if (partial.autoCalculateTotalRows !== undefined) editorSettings.value.autoCalculateTotalRows = partial.autoCalculateTotalRows === true;
+    if (partial.mongoViewMode !== undefined) editorSettings.value.mongoViewMode = partial.mongoViewMode;
+    if (partial.showColumnCommentsInHeader !== undefined) editorSettings.value.showColumnCommentsInHeader = partial.showColumnCommentsInHeader;
+    if (partial.showColumnTypesInHeader !== undefined) editorSettings.value.showColumnTypesInHeader = partial.showColumnTypesInHeader;
+    if (partial.compactColumnHeaderActions !== undefined) editorSettings.value.compactColumnHeaderActions = partial.compactColumnHeaderActions;
+    if (partial.columnWidthDensity !== undefined) editorSettings.value.columnWidthDensity = normalizeColumnWidthDensity(partial.columnWidthDensity);
+    if (partial.dataGridQuickEntry !== undefined) editorSettings.value.dataGridQuickEntry = partial.dataGridQuickEntry;
+    if (partial.dataGridRenderMode !== undefined) editorSettings.value.dataGridRenderMode = normalizeDataGridRenderMode(partial.dataGridRenderMode);
+    if (partial.dataGridSearchMode !== undefined) editorSettings.value.dataGridSearchMode = normalizeDataGridSearchMode(partial.dataGridSearchMode);
+    if (partial.tableFontSize !== undefined) editorSettings.value.tableFontSize = normalizeTableFontSize(partial.tableFontSize);
+    if (partial.structureEditorDensity !== undefined) editorSettings.value.structureEditorDensity = normalizeStructureEditorDensity(partial.structureEditorDensity);
+    if (partial.tableInfoDrawerWidth !== undefined) editorSettings.value.tableInfoDrawerWidth = normalizeDrawerWidth(partial.tableInfoDrawerWidth, 240, DEFAULT_EDITOR_SETTINGS.tableInfoDrawerWidth);
+    if (partial.cellDetailDrawerWidth !== undefined) editorSettings.value.cellDetailDrawerWidth = normalizeDrawerWidth(partial.cellDetailDrawerWidth, 260, DEFAULT_EDITOR_SETTINGS.cellDetailDrawerWidth);
+    if (partial.cellDetailPanelLayout !== undefined) editorSettings.value.cellDetailPanelLayout = normalizeCellDetailPanelLayout(partial.cellDetailPanelLayout);
+    if (partial.cellDetailJsonFormatted !== undefined) editorSettings.value.cellDetailJsonFormatted = partial.cellDetailJsonFormatted === true;
+    if (partial.shortcuts !== undefined) editorSettings.value.shortcuts = normalizeShortcutSettings(partial.shortcuts);
+    if (partial.sqlFormatter !== undefined) editorSettings.value.sqlFormatter = normalizeSqlFormatterSettings(partial.sqlFormatter);
+    if (partial.sidebarActivation !== undefined) editorSettings.value.sidebarActivation = partial.sidebarActivation;
+    if (partial.sidebarObjectDisplay !== undefined) editorSettings.value.sidebarObjectDisplay = partial.sidebarObjectDisplay;
+    if (partial.sidebarTableSearchEnabled !== undefined) editorSettings.value.sidebarTableSearchEnabled = partial.sidebarTableSearchEnabled;
+    if (partial.autoSelectActiveSidebarNode !== undefined) editorSettings.value.autoSelectActiveSidebarNode = partial.autoSelectActiveSidebarNode;
+    if (partial.openTabsRestoreMode !== undefined) editorSettings.value.openTabsRestoreMode = normalizeOpenTabsRestoreMode(partial.openTabsRestoreMode);
+    if (partial.disconnectTabHandlingMode !== undefined) editorSettings.value.disconnectTabHandlingMode = normalizeDisconnectTabHandlingMode(partial.disconnectTabHandlingMode);
+    if (partial.reuseDataTab !== undefined) editorSettings.value.reuseDataTab = partial.reuseDataTab;
+    if (partial.updateNotificationsEnabled !== undefined) editorSettings.value.updateNotificationsEnabled = partial.updateNotificationsEnabled;
+    if (partial.sidebarHiddenTablePrefixes !== undefined) editorSettings.value.sidebarHiddenTablePrefixes = normalizeSidebarHiddenTablePrefixes(partial.sidebarHiddenTablePrefixes);
+    if (partial.sidebarHideTableComments !== undefined) editorSettings.value.sidebarHideTableComments = partial.sidebarHideTableComments;
+    if (partial.sidebarAllowHorizontalScroll !== undefined) editorSettings.value.sidebarAllowHorizontalScroll = partial.sidebarAllowHorizontalScroll;
+    if (partial.columnFormatters !== undefined) editorSettings.value.columnFormatters = partial.columnFormatters;
+    if (partial.customColumnFormatters !== undefined) editorSettings.value.customColumnFormatters = partial.customColumnFormatters;
+    if (partial.snippets !== undefined) editorSettings.value.snippets = normalizeSqlSnippets(partial.snippets);
+    if (partial.tableColumnTemplateFields !== undefined) editorSettings.value.tableColumnTemplateFields = normalizeTableColumnTemplateFields(partial.tableColumnTemplateFields);
+    if (partial.exportBatchSize !== undefined) editorSettings.value.exportBatchSize = Math.min(100000, Math.max(100, Math.round(partial.exportBatchSize)));
+    if (partial.exportRowLimitEnabled !== undefined) editorSettings.value.exportRowLimitEnabled = partial.exportRowLimitEnabled;
+    if (partial.exportRowLimit !== undefined) editorSettings.value.exportRowLimit = Math.min(2147483647, Math.max(100, Math.round(partial.exportRowLimit)));
+    if (partial.queryExportKeysetOptimizationEnabled !== undefined) editorSettings.value.queryExportKeysetOptimizationEnabled = partial.queryExportKeysetOptimizationEnabled;
+    if (partial.updateDownloadSource !== undefined) editorSettings.value.updateDownloadSource = normalizeUpdateDownloadSource(partial.updateDownloadSource);
+    if (partial.toolbarItems !== undefined) editorSettings.value.toolbarItems = normalizeToolbarItems(partial.toolbarItems);
+    if (partial.objectBrowserShowCheckbox !== undefined) editorSettings.value.objectBrowserShowCheckbox = partial.objectBrowserShowCheckbox === true;
+    if (partial.objectBrowserViewMode !== undefined) editorSettings.value.objectBrowserViewMode = partial.objectBrowserViewMode === "grid" ? "grid" : "list";
+    if (partial.sqlVariableSyntaxOverrides !== undefined) editorSettings.value.sqlVariableSyntaxOverrides = normalizeSqlVariableSyntaxOverrides(partial.sqlVariableSyntaxOverrides);
+    saveEditorSettings(editorSettings.value);
+  }
+
+  function updateColumnFormatter(key: string, formatter: ColumnFormatterConfig | undefined) {
+    const columnFormatters = { ...editorSettings.value.columnFormatters };
+    const normalized = normalizeColumnFormatter(formatter);
+    if (normalized) {
+      columnFormatters[key] = normalized;
+    } else {
+      delete columnFormatters[key];
+    }
+    updateEditorSettings({ columnFormatters });
+  }
+
+  function upsertCustomColumnFormatter(formatter: CustomColumnFormatterConfig): CustomColumnFormatterConfig | undefined {
+    const normalized = normalizeCustomColumnFormatter(formatter);
+    if (!normalized) return undefined;
+    updateEditorSettings({
+      customColumnFormatters: {
+        ...editorSettings.value.customColumnFormatters,
+        [normalized.id]: normalized,
+      },
+    });
+    return normalized;
+  }
+
+  function deleteCustomColumnFormatter(id: string) {
+    const customColumnFormatters = { ...editorSettings.value.customColumnFormatters };
+    delete customColumnFormatters[id];
+    const columnFormatters = Object.fromEntries(
+      Object.entries(editorSettings.value.columnFormatters).filter(([, formatter]) => {
+        return formatter.kind !== "custom-ref" || formatter.formatterId !== id;
+      }),
+    );
+    updateEditorSettings({ customColumnFormatters, columnFormatters });
+  }
+
+  return {
+    settingsPageActive,
+    aiConfig,
+    isAiConfigLoaded,
+    aiProviderConfigs,
+    initAiConfig,
+    updateAiConfig,
+    isConfigured,
+    isAiProviderConfigured,
+    isEditorSettingsLoaded,
+    editorSettings,
+    desktopSettings,
+    initEditorSettings,
+    updateEditorSettings,
+    initDesktopSettings,
+    updateDesktopSettings,
+    updateColumnFormatter,
+    upsertCustomColumnFormatter,
+    deleteCustomColumnFormatter,
+  };
+});
diff --git a/apps/desktop/src/stores/tunnelProfileStore.ts b/apps/desktop/src/stores/tunnelProfileStore.ts
new file mode 100644
index 0000000..6de718e
--- /dev/null
+++ b/apps/desktop/src/stores/tunnelProfileStore.ts
@@ -0,0 +1,48 @@
+import { ref } from "vue";
+import { defineStore } from "pinia";
+import * as api from "@/lib/backend/api";
+import type { TunnelProfile } from "@/types/database";
+
+/**
+ * Shared tunnel profiles (Settings > Tunnels). Connections reference a
+ * profile by id via `transport_layers[].profile_id`; the backend resolves
+ * the reference at connect time, so profile edits reach every referencing
+ * connection without touching the stored connections.
+ */
+export const useTunnelProfileStore = defineStore("tunnelProfiles", () => {
+  const profiles = ref<TunnelProfile[]>([]);
+  const isLoaded = ref(false);
+
+  async function init() {
+    if (isLoaded.value) return;
+    await refresh();
+  }
+
+  async function refresh() {
+    try {
+      profiles.value = (await api.loadTunnelProfiles()) || [];
+      isLoaded.value = true;
+    } catch {
+      // Backend unavailable (e.g. stale web session): keep previous state and
+      // retry on the next init/refresh call.
+    }
+  }
+
+  function profileById(id: string | undefined): TunnelProfile | undefined {
+    if (!id) return undefined;
+    return profiles.value.find((profile) => profile.id === id);
+  }
+
+  async function saveProfiles(next: TunnelProfile[]) {
+    const previous = profiles.value;
+    profiles.value = next;
+    try {
+      await api.saveTunnelProfiles(next);
+    } catch (error) {
+      profiles.value = previous;
+      throw error;
+    }
+  }
+
+  return { profiles, isLoaded, init, refresh, profileById, saveProfiles };
+});
diff --git a/apps/desktop/src/styles/__tests__/legacyWebviewFallback.spec.ts b/apps/desktop/src/styles/__tests__/legacyWebviewFallback.spec.ts
new file mode 100644
index 0000000..5ca13e4
--- /dev/null
+++ b/apps/desktop/src/styles/__tests__/legacyWebviewFallback.spec.ts
@@ -0,0 +1,27 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+const globalsCss = readFileSync(new URL("../globals.css", import.meta.url), "utf8");
+
+describe("legacy WebView CSS fallbacks", () => {
+  it("scopes component overrides to WebViews without OKLCH support", () => {
+    const fallbackStart = globalsCss.indexOf("@supports not (color: oklch(0.5 0.1 180))");
+    const tabsOverride = globalsCss.indexOf('[data-slot="tabs-trigger"]');
+    const splitpanesStart = globalsCss.indexOf("/* Splitpanes */");
+
+    expect(fallbackStart).toBeGreaterThan(-1);
+    expect(tabsOverride).toBeGreaterThan(fallbackStart);
+    expect(splitpanesStart).toBeGreaterThan(tabsOverride);
+
+    let nestingDepth = 0;
+    let tabsNestingDepth = 0;
+    for (let index = globalsCss.indexOf("{", fallbackStart); index < splitpanesStart; index++) {
+      if (globalsCss[index] === "{") nestingDepth++;
+      if (globalsCss[index] === "}") nestingDepth--;
+      if (index === tabsOverride) tabsNestingDepth = nestingDepth;
+    }
+
+    expect(tabsNestingDepth).toBeGreaterThan(0);
+    expect(nestingDepth).toBe(0);
+  });
+});
diff --git a/apps/desktop/src/styles/globals.css b/apps/desktop/src/styles/globals.css
new file mode 100644
index 0000000..91e3629
--- /dev/null
+++ b/apps/desktop/src/styles/globals.css
@@ -0,0 +1,2144 @@
+@font-face {
+  font-family: "Geist Variable";
+  font-style: normal;
+  font-display: swap;
+  font-weight: 100 900;
+  src: url("/fonts/geist-latin-ext-wght-normal.woff2") format("woff2-variations");
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+
+@font-face {
+  font-family: "Geist Variable";
+  font-style: normal;
+  font-display: swap;
+  font-weight: 100 900;
+  src: url("/fonts/geist-latin-wght-normal.woff2") format("woff2-variations");
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+  font-family: "Geist Variable Tabular";
+  font-style: normal;
+  font-display: swap;
+  font-weight: 100 900;
+  font-feature-settings: "tnum";
+  src: url("/fonts/geist-latin-ext-wght-normal.woff2") format("woff2-variations");
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+
+@font-face {
+  font-family: "Geist Variable Tabular";
+  font-style: normal;
+  font-display: swap;
+  font-weight: 100 900;
+  font-feature-settings: "tnum";
+  src: url("/fonts/geist-latin-wght-normal.woff2") format("woff2-variations");
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@import "tailwindcss";
+@source "../**/*.{vue,ts,tsx,js,jsx,html}";
+
+@import "tw-animate-css";
+
+@import "shadcn-vue/tailwind.css";
+
+@custom-variant dark (&:is(.dark *));
+
+@theme inline {
+  --font-sans: "Geist Variable", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", "Segoe UI", system-ui, sans-serif;
+  --font-heading: var(--font-sans);
+  --color-sidebar-ring: var(--sidebar-ring);
+  --color-sidebar-border: var(--sidebar-border);
+  --color-sidebar-accent-foreground: var(--sidebar-accent-foreground);
+  --color-sidebar-accent: var(--sidebar-accent);
+  --color-sidebar-primary-foreground: var(--sidebar-primary-foreground);
+  --color-sidebar-primary: var(--sidebar-primary);
+  --color-sidebar-foreground: var(--sidebar-foreground);
+  --color-sidebar: var(--sidebar);
+  --color-chart-5: var(--chart-5);
+  --color-chart-4: var(--chart-4);
+  --color-chart-3: var(--chart-3);
+  --color-chart-2: var(--chart-2);
+  --color-chart-1: var(--chart-1);
+  --color-ring: var(--ring);
+  --color-input: var(--input);
+  --color-border: var(--border);
+  --color-destructive: var(--destructive);
+  --color-accent-foreground: var(--accent-foreground);
+  --color-accent: var(--accent);
+  --color-muted-foreground: var(--muted-foreground);
+  --color-muted: var(--muted);
+  --color-secondary-foreground: var(--secondary-foreground);
+  --color-secondary: var(--secondary);
+  --color-primary-foreground: var(--primary-foreground);
+  --color-primary: var(--primary);
+  --color-popover-foreground: var(--popover-foreground);
+  --color-popover: var(--popover);
+  --color-card-foreground: var(--card-foreground);
+  --color-card: var(--card);
+  --color-foreground: var(--foreground);
+  --color-background: var(--background);
+  --radius-sm: calc(var(--radius) - 4px);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-lg: var(--radius);
+  --radius-xl: calc(var(--radius) + 4px);
+}
+
+:root {
+  --background: rgb(255 255 255);
+  --foreground: rgb(10 10 10);
+  --card: rgb(255 255 255);
+  --card-foreground: rgb(10 10 10);
+  --popover: rgb(255 255 255);
+  --popover-foreground: rgb(10 10 10);
+  --primary: rgb(23 23 23);
+  --primary-foreground: rgb(250 250 250);
+  --secondary: rgb(245 245 245);
+  --secondary-foreground: rgb(23 23 23);
+  --muted: rgb(245 245 245);
+  --muted-foreground: rgb(115 115 115);
+  --accent: rgb(245 245 245);
+  --accent-foreground: rgb(23 23 23);
+  --destructive: rgb(231 0 11);
+  --destructive-rgb: 231, 0, 11;
+  --border: rgb(229 229 229);
+  --input: rgb(229 229 229);
+  --ring: rgb(161 161 161);
+  --chart-1: rgb(212 212 212);
+  --chart-2: rgb(115 115 115);
+  --chart-3: rgb(82 82 82);
+  --chart-4: rgb(64 64 64);
+  --chart-5: rgb(38 38 38);
+  --radius: 0.625rem;
+  --sidebar: rgb(250 250 250);
+  --sidebar-foreground: rgb(10 10 10);
+  --sidebar-primary: rgb(23 23 23);
+  --sidebar-primary-foreground: rgb(250 250 250);
+  --sidebar-accent: rgb(245 245 245);
+  --sidebar-accent-foreground: rgb(23 23 23);
+  --sidebar-border: rgb(229 229 229);
+  --sidebar-ring: rgb(161 161 161);
+  --dbx-window-top-border: rgb(0 0 0 / 0.35);
+}
+
+.dark {
+  --background: rgb(19 20 22);
+  --foreground: rgb(215 215 219);
+  --card: rgb(27 27 30);
+  --card-foreground: rgb(215 215 219);
+  --popover: rgb(30 30 32);
+  --popover-foreground: rgb(221 221 226);
+  --primary: rgb(208 208 214);
+  --primary-foreground: rgb(19 20 22);
+  --secondary: rgb(42 42 45);
+  --secondary-foreground: rgb(215 215 219);
+  --muted: rgb(42 42 45);
+  --muted-foreground: rgb(151 152 157);
+  --accent: rgb(46 47 51);
+  --accent-foreground: rgb(221 221 226);
+  --destructive: rgb(243 98 95);
+  --destructive-rgb: 243, 98, 95;
+  --border: rgb(110 110 114 / 0.28);
+  --input: rgb(110 110 114 / 0.34);
+  --ring: rgb(133 134 139);
+  --chart-1: rgb(212 212 212);
+  --chart-2: rgb(115 115 115);
+  --chart-3: rgb(82 82 82);
+  --chart-4: rgb(64 64 64);
+  --chart-5: rgb(38 38 38);
+  --sidebar: rgb(25 25 28);
+  --sidebar-foreground: rgb(208 208 213);
+  --sidebar-primary: rgb(20 71 230);
+  --sidebar-primary-foreground: rgb(234 235 239);
+  --sidebar-accent: rgb(44 44 48);
+  --sidebar-accent-foreground: rgb(221 221 226);
+  --sidebar-border: rgb(110 110 114 / 0.28);
+  --sidebar-ring: rgb(133 134 139);
+  --dbx-window-top-border: rgb(255 255 255 / 0.18);
+}
+
+html.theme-soft {
+  --background: rgb(250 251 253);
+  --foreground: rgb(40 44 52);
+  --card: rgb(255 255 255);
+  --card-foreground: rgb(36 40 48);
+  --popover: rgb(255 255 255);
+  --popover-foreground: rgb(36 40 48);
+  --primary: rgb(46 95 166);
+  --primary-foreground: rgb(247 250 255);
+  --secondary: rgb(237 241 246);
+  --secondary-foreground: rgb(47 53 63);
+  --muted: rgb(237 241 246);
+  --muted-foreground: rgb(104 113 126);
+  --accent: rgb(226 233 242);
+  --accent-foreground: rgb(36 44 57);
+  --destructive: rgb(197 68 58);
+  --border: rgb(208 215 224);
+  --input: rgb(198 207 218);
+  --ring: rgb(110 128 154);
+  --chart-1: rgb(84 125 191);
+  --chart-2: rgb(80 150 137);
+  --chart-3: rgb(184 128 58);
+  --chart-4: rgb(136 115 194);
+  --chart-5: rgb(191 94 89);
+  --sidebar: rgb(239 242 246);
+  --sidebar-foreground: rgb(48 54 65);
+  --sidebar-primary: rgb(46 95 166);
+  --sidebar-primary-foreground: rgb(247 250 255);
+  --sidebar-accent: rgb(224 231 241);
+  --sidebar-accent-foreground: rgb(34 41 52);
+  --sidebar-border: rgb(202 210 221);
+  --sidebar-ring: rgb(110 128 154);
+  --dbx-chrome: rgb(236 240 245);
+  --dbx-chrome-muted: rgb(231 236 243);
+  --dbx-content: rgb(255 255 255);
+  --dbx-editor-toolbar: rgb(246 248 251);
+  --dbx-gutter: rgb(229 234 241);
+  --dbx-sidebar-header: rgb(233 238 244);
+}
+
+html.theme-soft.dark {
+  --background: rgb(31 33 37);
+  --foreground: rgb(202 206 214);
+  --card: rgb(38 41 46);
+  --card-foreground: rgb(202 206 214);
+  --popover: rgb(42 45 51);
+  --popover-foreground: rgb(207 211 218);
+  --primary: rgb(157 177 205);
+  --primary-foreground: rgb(27 30 34);
+  --secondary: rgb(47 51 58);
+  --secondary-foreground: rgb(201 205 213);
+  --muted: rgb(47 51 58);
+  --muted-foreground: rgb(146 153 164);
+  --accent: rgb(55 60 69);
+  --accent-foreground: rgb(208 212 219);
+  --destructive: rgb(224 101 93);
+  --border: rgb(104 112 126 / 0.34);
+  --input: rgb(116 126 142 / 0.36);
+  --ring: rgb(138 148 164);
+  --chart-1: rgb(131 157 199);
+  --chart-2: rgb(111 168 153);
+  --chart-3: rgb(199 151 91);
+  --chart-4: rgb(160 145 207);
+  --chart-5: rgb(209 116 111);
+  --sidebar: rgb(34 37 42);
+  --sidebar-foreground: rgb(193 198 207);
+  --sidebar-primary: rgb(157 177 205);
+  --sidebar-primary-foreground: rgb(27 30 34);
+  --sidebar-accent: rgb(45 50 58);
+  --sidebar-accent-foreground: rgb(205 210 218);
+  --sidebar-border: rgb(105 114 128 / 0.32);
+  --sidebar-ring: rgb(138 148 164);
+  --dbx-chrome: rgb(39 43 49);
+  --dbx-chrome-muted: rgb(43 47 54);
+  --dbx-content: rgb(33 36 41);
+  --dbx-editor-toolbar: rgb(36 39 44);
+  --dbx-gutter: rgb(27 30 34);
+  --dbx-sidebar-header: rgb(38 42 48);
+}
+
+html.theme-graphite {
+  --background: rgb(249 250 252);
+  --foreground: rgb(42 45 51);
+  --card: rgb(255 255 255);
+  --card-foreground: rgb(39 42 48);
+  --popover: rgb(255 255 255);
+  --popover-foreground: rgb(39 42 48);
+  --primary: rgb(72 80 93);
+  --primary-foreground: rgb(248 250 252);
+  --secondary: rgb(238 240 244);
+  --secondary-foreground: rgb(49 53 61);
+  --muted: rgb(238 240 244);
+  --muted-foreground: rgb(106 112 123);
+  --accent: rgb(226 230 236);
+  --accent-foreground: rgb(39 44 53);
+  --destructive: rgb(198 72 62);
+  --border: rgb(210 215 224);
+  --input: rgb(198 204 214);
+  --ring: rgb(116 125 139);
+  --chart-1: rgb(92 107 127);
+  --chart-2: rgb(80 143 132);
+  --chart-3: rgb(178 132 74);
+  --chart-4: rgb(121 113 173);
+  --chart-5: rgb(184 94 91);
+  --sidebar: rgb(235 238 243);
+  --sidebar-foreground: rgb(48 52 60);
+  --sidebar-primary: rgb(72 80 93);
+  --sidebar-primary-foreground: rgb(248 250 252);
+  --sidebar-accent: rgb(222 227 235);
+  --sidebar-accent-foreground: rgb(39 44 53);
+  --sidebar-border: rgb(202 208 218);
+  --sidebar-ring: rgb(116 125 139);
+  --dbx-chrome: rgb(232 236 242);
+  --dbx-chrome-muted: rgb(226 231 238);
+  --dbx-content: rgb(255 255 255);
+  --dbx-editor-toolbar: rgb(246 248 251);
+  --dbx-gutter: rgb(224 229 237);
+  --dbx-sidebar-header: rgb(229 233 240);
+}
+
+html.theme-graphite.dark {
+  --background: rgb(30 32 36);
+  --foreground: rgb(198 201 207);
+  --card: rgb(38 40 45);
+  --card-foreground: rgb(199 202 208);
+  --popover: rgb(42 44 50);
+  --popover-foreground: rgb(205 208 214);
+  --primary: rgb(174 181 192);
+  --primary-foreground: rgb(27 29 33);
+  --secondary: rgb(47 50 57);
+  --secondary-foreground: rgb(199 202 208);
+  --muted: rgb(47 50 57);
+  --muted-foreground: rgb(144 150 160);
+  --accent: rgb(55 58 66);
+  --accent-foreground: rgb(207 210 216);
+  --destructive: rgb(223 101 92);
+  --border: rgb(104 110 122 / 0.34);
+  --input: rgb(115 123 137 / 0.36);
+  --ring: rgb(138 145 158);
+  --chart-1: rgb(146 158 176);
+  --chart-2: rgb(110 165 151);
+  --chart-3: rgb(198 150 92);
+  --chart-4: rgb(151 142 199);
+  --chart-5: rgb(206 113 109);
+  --sidebar: rgb(33 35 40);
+  --sidebar-foreground: rgb(190 195 203);
+  --sidebar-primary: rgb(174 181 192);
+  --sidebar-primary-foreground: rgb(27 29 33);
+  --sidebar-accent: rgb(45 48 55);
+  --sidebar-accent-foreground: rgb(204 208 215);
+  --sidebar-border: rgb(104 110 122 / 0.32);
+  --sidebar-ring: rgb(138 145 158);
+  --dbx-chrome: rgb(38 41 47);
+  --dbx-chrome-muted: rgb(43 46 53);
+  --dbx-content: rgb(32 34 39);
+  --dbx-editor-toolbar: rgb(36 38 43);
+  --dbx-gutter: rgb(27 29 33);
+  --dbx-sidebar-header: rgb(37 40 46);
+}
+
+html.theme-cobalt {
+  --background: rgb(247 250 253);
+  --foreground: rgb(32 43 58);
+  --card: rgb(255 255 255);
+  --card-foreground: rgb(30 41 56);
+  --popover: rgb(255 255 255);
+  --popover-foreground: rgb(30 41 56);
+  --primary: rgb(43 99 183);
+  --primary-foreground: rgb(247 250 255);
+  --secondary: rgb(232 240 250);
+  --secondary-foreground: rgb(38 52 70);
+  --muted: rgb(232 240 250);
+  --muted-foreground: rgb(96 111 130);
+  --accent: rgb(216 229 246);
+  --accent-foreground: rgb(31 48 72);
+  --destructive: rgb(197 70 61);
+  --border: rgb(200 212 229);
+  --input: rgb(187 204 224);
+  --ring: rgb(85 119 165);
+  --chart-1: rgb(60 111 191);
+  --chart-2: rgb(75 145 159);
+  --chart-3: rgb(180 130 64);
+  --chart-4: rgb(132 113 190);
+  --chart-5: rgb(190 91 95);
+  --sidebar: rgb(232 239 248);
+  --sidebar-foreground: rgb(37 51 68);
+  --sidebar-primary: rgb(43 99 183);
+  --sidebar-primary-foreground: rgb(247 250 255);
+  --sidebar-accent: rgb(214 228 246);
+  --sidebar-accent-foreground: rgb(31 48 72);
+  --sidebar-border: rgb(195 209 228);
+  --sidebar-ring: rgb(85 119 165);
+  --dbx-chrome: rgb(228 236 247);
+  --dbx-chrome-muted: rgb(221 231 245);
+  --dbx-content: rgb(255 255 255);
+  --dbx-editor-toolbar: rgb(244 248 253);
+  --dbx-gutter: rgb(218 229 243);
+  --dbx-sidebar-header: rgb(224 234 246);
+}
+
+html.theme-cobalt.dark {
+  --background: rgb(25 31 42);
+  --foreground: rgb(198 207 219);
+  --card: rgb(31 38 51);
+  --card-foreground: rgb(200 209 221);
+  --popover: rgb(35 43 58);
+  --popover-foreground: rgb(206 214 225);
+  --primary: rgb(137 173 223);
+  --primary-foreground: rgb(20 28 39);
+  --secondary: rgb(43 53 70);
+  --secondary-foreground: rgb(200 209 221);
+  --muted: rgb(43 53 70);
+  --muted-foreground: rgb(143 155 171);
+  --accent: rgb(49 62 82);
+  --accent-foreground: rgb(209 218 229);
+  --destructive: rgb(224 101 94);
+  --border: rgb(101 119 144 / 0.34);
+  --input: rgb(109 130 158 / 0.36);
+  --ring: rgb(133 154 184);
+  --chart-1: rgb(133 173 229);
+  --chart-2: rgb(107 172 184);
+  --chart-3: rgb(199 151 90);
+  --chart-4: rgb(158 143 207);
+  --chart-5: rgb(209 114 116);
+  --sidebar: rgb(28 35 48);
+  --sidebar-foreground: rgb(191 202 216);
+  --sidebar-primary: rgb(137 173 223);
+  --sidebar-primary-foreground: rgb(20 28 39);
+  --sidebar-accent: rgb(42 54 72);
+  --sidebar-accent-foreground: rgb(206 215 227);
+  --sidebar-border: rgb(101 119 144 / 0.32);
+  --sidebar-ring: rgb(133 154 184);
+  --dbx-chrome: rgb(32 40 54);
+  --dbx-chrome-muted: rgb(37 47 63);
+  --dbx-content: rgb(27 34 46);
+  --dbx-editor-toolbar: rgb(30 38 51);
+  --dbx-gutter: rgb(22 28 38);
+  --dbx-sidebar-header: rgb(31 39 53);
+}
+
+html.theme-sage {
+  --background: rgb(248 250 248);
+  --foreground: rgb(36 48 43);
+  --card: rgb(255 255 255);
+  --card-foreground: rgb(34 46 41);
+  --popover: rgb(255 255 255);
+  --popover-foreground: rgb(34 46 41);
+  --primary: rgb(58 123 106);
+  --primary-foreground: rgb(246 252 249);
+  --secondary: rgb(233 241 237);
+  --secondary-foreground: rgb(42 58 52);
+  --muted: rgb(233 241 237);
+  --muted-foreground: rgb(97 113 106);
+  --accent: rgb(219 234 227);
+  --accent-foreground: rgb(31 55 47);
+  --destructive: rgb(196 72 61);
+  --border: rgb(203 217 211);
+  --input: rgb(190 208 200);
+  --ring: rgb(88 135 119);
+  --chart-1: rgb(63 132 112);
+  --chart-2: rgb(74 137 168);
+  --chart-3: rgb(180 132 68);
+  --chart-4: rgb(132 115 185);
+  --chart-5: rgb(188 95 90);
+  --sidebar: rgb(235 242 238);
+  --sidebar-foreground: rgb(38 54 48);
+  --sidebar-primary: rgb(58 123 106);
+  --sidebar-primary-foreground: rgb(246 252 249);
+  --sidebar-accent: rgb(218 234 227);
+  --sidebar-accent-foreground: rgb(31 55 47);
+  --sidebar-border: rgb(197 213 206);
+  --sidebar-ring: rgb(88 135 119);
+  --dbx-chrome: rgb(231 239 235);
+  --dbx-chrome-muted: rgb(225 235 230);
+  --dbx-content: rgb(255 255 255);
+  --dbx-editor-toolbar: rgb(245 248 246);
+  --dbx-gutter: rgb(221 233 227);
+  --dbx-sidebar-header: rgb(228 237 233);
+}
+
+html.theme-sage.dark {
+  --background: rgb(27 35 33);
+  --foreground: rgb(198 208 204);
+  --card: rgb(34 43 40);
+  --card-foreground: rgb(200 210 206);
+  --popover: rgb(38 48 45);
+  --popover-foreground: rgb(206 216 212);
+  --primary: rgb(138 184 169);
+  --primary-foreground: rgb(22 32 29);
+  --secondary: rgb(44 57 53);
+  --secondary-foreground: rgb(200 210 206);
+  --muted: rgb(44 57 53);
+  --muted-foreground: rgb(143 157 151);
+  --accent: rgb(50 65 60);
+  --accent-foreground: rgb(208 218 214);
+  --destructive: rgb(224 102 94);
+  --border: rgb(100 122 113 / 0.34);
+  --input: rgb(107 132 122 / 0.36);
+  --ring: rgb(132 159 149);
+  --chart-1: rgb(134 188 170);
+  --chart-2: rgb(111 170 190);
+  --chart-3: rgb(199 151 91);
+  --chart-4: rgb(154 143 203);
+  --chart-5: rgb(207 114 108);
+  --sidebar: rgb(30 39 36);
+  --sidebar-foreground: rgb(191 203 198);
+  --sidebar-primary: rgb(138 184 169);
+  --sidebar-primary-foreground: rgb(22 32 29);
+  --sidebar-accent: rgb(43 58 53);
+  --sidebar-accent-foreground: rgb(205 217 212);
+  --sidebar-border: rgb(100 122 113 / 0.32);
+  --sidebar-ring: rgb(132 159 149);
+  --dbx-chrome: rgb(34 45 41);
+  --dbx-chrome-muted: rgb(39 51 47);
+  --dbx-content: rgb(29 38 35);
+  --dbx-editor-toolbar: rgb(32 42 39);
+  --dbx-gutter: rgb(24 31 29);
+  --dbx-sidebar-header: rgb(33 43 40);
+}
+
+html.theme-amber {
+  --background: rgb(255 252 242);
+  --foreground: rgb(56 48 32);
+  --card: rgb(255 255 250);
+  --card-foreground: rgb(51 44 30);
+  --popover: rgb(255 255 250);
+  --popover-foreground: rgb(51 44 30);
+  --primary: rgb(149 95 28);
+  --primary-foreground: rgb(255 250 236);
+  --secondary: rgb(247 238 213);
+  --secondary-foreground: rgb(68 56 36);
+  --muted: rgb(247 238 213);
+  --muted-foreground: rgb(123 105 70);
+  --accent: rgb(239 219 174);
+  --accent-foreground: rgb(65 48 24);
+  --destructive: rgb(191 72 57);
+  --border: rgb(224 207 168);
+  --input: rgb(211 191 148);
+  --ring: rgb(166 119 47);
+  --chart-1: rgb(171 111 34);
+  --chart-2: rgb(93 137 112);
+  --chart-3: rgb(69 124 162);
+  --chart-4: rgb(134 111 178);
+  --chart-5: rgb(184 90 87);
+  --sidebar: rgb(247 238 213);
+  --sidebar-foreground: rgb(61 51 33);
+  --sidebar-primary: rgb(149 95 28);
+  --sidebar-primary-foreground: rgb(255 250 236);
+  --sidebar-accent: rgb(239 221 181);
+  --sidebar-accent-foreground: rgb(65 48 24);
+  --sidebar-border: rgb(218 199 158);
+  --sidebar-ring: rgb(166 119 47);
+  --dbx-chrome: rgb(244 233 203);
+  --dbx-chrome-muted: rgb(239 226 191);
+  --dbx-content: rgb(255 255 250);
+  --dbx-editor-toolbar: rgb(252 247 232);
+  --dbx-gutter: rgb(235 219 181);
+  --dbx-sidebar-header: rgb(242 229 196);
+}
+
+html.theme-amber.dark {
+  --background: rgb(37 34 27);
+  --foreground: rgb(217 208 188);
+  --card: rgb(45 41 32);
+  --card-foreground: rgb(219 210 191);
+  --popover: rgb(50 46 36);
+  --popover-foreground: rgb(225 216 197);
+  --primary: rgb(213 169 75);
+  --primary-foreground: rgb(34 29 21);
+  --secondary: rgb(59 53 40);
+  --secondary-foreground: rgb(218 209 190);
+  --muted: rgb(59 53 40);
+  --muted-foreground: rgb(163 150 123);
+  --accent: rgb(71 61 43);
+  --accent-foreground: rgb(228 219 199);
+  --destructive: rgb(225 104 92);
+  --border: rgb(129 112 77 / 0.36);
+  --input: rgb(141 121 83 / 0.38);
+  --ring: rgb(185 151 84);
+  --chart-1: rgb(214 170 78);
+  --chart-2: rgb(121 171 139);
+  --chart-3: rgb(103 161 198);
+  --chart-4: rgb(160 143 205);
+  --chart-5: rgb(210 115 111);
+  --sidebar: rgb(41 37 29);
+  --sidebar-foreground: rgb(210 200 180);
+  --sidebar-primary: rgb(213 169 75);
+  --sidebar-primary-foreground: rgb(34 29 21);
+  --sidebar-accent: rgb(57 50 36);
+  --sidebar-accent-foreground: rgb(224 215 196);
+  --sidebar-border: rgb(129 112 77 / 0.34);
+  --sidebar-ring: rgb(185 151 84);
+  --dbx-chrome: rgb(48 43 33);
+  --dbx-chrome-muted: rgb(54 48 36);
+  --dbx-content: rgb(39 36 28);
+  --dbx-editor-toolbar: rgb(43 39 31);
+  --dbx-gutter: rgb(32 29 23);
+  --dbx-sidebar-header: rgb(46 41 32);
+}
+
+html.theme-blush {
+  --background: rgb(255 248 251);
+  --foreground: rgb(61 48 56);
+  --card: rgb(255 255 255);
+  --card-foreground: rgb(57 45 53);
+  --popover: rgb(255 255 255);
+  --popover-foreground: rgb(57 45 53);
+  --primary: rgb(184 86 123);
+  --primary-foreground: rgb(255 248 251);
+  --secondary: rgb(246 232 239);
+  --secondary-foreground: rgb(74 55 67);
+  --muted: rgb(246 232 239);
+  --muted-foreground: rgb(126 98 115);
+  --accent: rgb(239 213 226);
+  --accent-foreground: rgb(83 50 68);
+  --destructive: rgb(197 69 64);
+  --border: rgb(226 202 214);
+  --input: rgb(214 187 201);
+  --ring: rgb(188 111 141);
+  --chart-1: rgb(190 88 126);
+  --chart-2: rgb(117 141 190);
+  --chart-3: rgb(116 157 132);
+  --chart-4: rgb(180 132 74);
+  --chart-5: rgb(137 108 183);
+  --sidebar: rgb(248 234 241);
+  --sidebar-foreground: rgb(66 50 60);
+  --sidebar-primary: rgb(184 86 123);
+  --sidebar-primary-foreground: rgb(255 248 251);
+  --sidebar-accent: rgb(239 214 226);
+  --sidebar-accent-foreground: rgb(83 50 68);
+  --sidebar-border: rgb(220 195 208);
+  --sidebar-ring: rgb(188 111 141);
+  --dbx-chrome: rgb(246 230 238);
+  --dbx-chrome-muted: rgb(240 220 230);
+  --dbx-content: rgb(255 255 255);
+  --dbx-editor-toolbar: rgb(253 246 250);
+  --dbx-gutter: rgb(237 216 227);
+  --dbx-sidebar-header: rgb(243 225 235);
+}
+
+html.theme-blush.dark {
+  --background: rgb(42 35 40);
+  --foreground: rgb(221 205 214);
+  --card: rgb(52 42 49);
+  --card-foreground: rgb(223 207 216);
+  --popover: rgb(58 47 55);
+  --popover-foreground: rgb(230 214 222);
+  --primary: rgb(226 160 184);
+  --primary-foreground: rgb(39 29 35);
+  --secondary: rgb(67 52 62);
+  --secondary-foreground: rgb(222 206 215);
+  --muted: rgb(67 52 62);
+  --muted-foreground: rgb(166 140 154);
+  --accent: rgb(82 59 72);
+  --accent-foreground: rgb(231 216 224);
+  --destructive: rgb(226 102 96);
+  --border: rgb(139 108 124 / 0.35);
+  --input: rgb(151 116 134 / 0.38);
+  --ring: rgb(202 143 164);
+  --chart-1: rgb(225 160 184);
+  --chart-2: rgb(134 159 211);
+  --chart-3: rgb(126 178 151);
+  --chart-4: rgb(202 152 93);
+  --chart-5: rgb(170 145 207);
+  --sidebar: rgb(47 38 45);
+  --sidebar-foreground: rgb(214 197 207);
+  --sidebar-primary: rgb(226 160 184);
+  --sidebar-primary-foreground: rgb(39 29 35);
+  --sidebar-accent: rgb(66 51 61);
+  --sidebar-accent-foreground: rgb(229 213 222);
+  --sidebar-border: rgb(139 108 124 / 0.33);
+  --sidebar-ring: rgb(202 143 164);
+  --dbx-chrome: rgb(55 44 52);
+  --dbx-chrome-muted: rgb(62 49 58);
+  --dbx-content: rgb(44 36 42);
+  --dbx-editor-toolbar: rgb(50 40 47);
+  --dbx-gutter: rgb(37 30 35);
+  --dbx-sidebar-header: rgb(52 42 49);
+}
+
+html.theme-vscode {
+  --background: rgb(255 255 255);
+  --foreground: rgb(51 51 51);
+  --card: rgb(255 255 255);
+  --card-foreground: rgb(45 45 45);
+  --popover: rgb(255 255 255);
+  --popover-foreground: rgb(45 45 45);
+  --primary: rgb(0 122 204);
+  --primary-foreground: rgb(255 255 255);
+  --secondary: rgb(243 243 243);
+  --secondary-foreground: rgb(51 51 51);
+  --muted: rgb(243 243 243);
+  --muted-foreground: rgb(106 106 106);
+  --accent: rgb(229 241 251);
+  --accent-foreground: rgb(0 74 122);
+  --destructive: rgb(196 72 62);
+  --border: rgb(224 224 224);
+  --input: rgb(206 206 206);
+  --ring: rgb(0 122 204);
+  --chart-1: rgb(0 122 204);
+  --chart-2: rgb(64 143 114);
+  --chart-3: rgb(186 133 62);
+  --chart-4: rgb(126 112 190);
+  --chart-5: rgb(190 90 90);
+  --sidebar: rgb(243 243 243);
+  --sidebar-foreground: rgb(51 51 51);
+  --sidebar-primary: rgb(0 122 204);
+  --sidebar-primary-foreground: rgb(255 255 255);
+  --sidebar-accent: rgb(230 230 230);
+  --sidebar-accent-foreground: rgb(45 45 45);
+  --sidebar-border: rgb(216 216 216);
+  --sidebar-ring: rgb(0 122 204);
+  --dbx-chrome: rgb(221 221 221);
+  --dbx-chrome-muted: rgb(232 232 232);
+  --dbx-content: rgb(255 255 255);
+  --dbx-editor-toolbar: rgb(246 246 246);
+  --dbx-gutter: rgb(229 229 229);
+  --dbx-sidebar-header: rgb(236 236 236);
+}
+
+html.theme-vscode.dark {
+  --background: rgb(30 30 30);
+  --foreground: rgb(204 204 204);
+  --card: rgb(37 37 38);
+  --card-foreground: rgb(204 204 204);
+  --popover: rgb(45 45 48);
+  --popover-foreground: rgb(212 212 212);
+  --primary: rgb(0 122 204);
+  --primary-foreground: rgb(255 255 255);
+  --secondary: rgb(45 45 48);
+  --secondary-foreground: rgb(204 204 204);
+  --muted: rgb(45 45 48);
+  --muted-foreground: rgb(133 133 133);
+  --accent: rgb(38 79 120);
+  --accent-foreground: rgb(235 244 255);
+  --destructive: rgb(241 112 105);
+  --border: rgb(60 60 60);
+  --input: rgb(70 70 70);
+  --ring: rgb(0 122 204);
+  --chart-1: rgb(55 148 255);
+  --chart-2: rgb(78 201 176);
+  --chart-3: rgb(220 180 120);
+  --chart-4: rgb(197 134 192);
+  --chart-5: rgb(244 135 113);
+  --sidebar: rgb(37 37 38);
+  --sidebar-foreground: rgb(204 204 204);
+  --sidebar-primary: rgb(0 122 204);
+  --sidebar-primary-foreground: rgb(255 255 255);
+  --sidebar-accent: rgb(45 45 48);
+  --sidebar-accent-foreground: rgb(212 212 212);
+  --sidebar-border: rgb(60 60 60);
+  --sidebar-ring: rgb(0 122 204);
+  --dbx-chrome: rgb(51 51 51);
+  --dbx-chrome-muted: rgb(45 45 48);
+  --dbx-content: rgb(30 30 30);
+  --dbx-editor-toolbar: rgb(37 37 38);
+  --dbx-gutter: rgb(27 27 28);
+  --dbx-sidebar-header: rgb(45 45 48);
+}
+
+html.theme-idea {
+  --background: rgb(250 250 250);
+  --foreground: rgb(43 43 43);
+  --card: rgb(255 255 255);
+  --card-foreground: rgb(40 40 40);
+  --popover: rgb(255 255 255);
+  --popover-foreground: rgb(40 40 40);
+  --primary: rgb(75 110 175);
+  --primary-foreground: rgb(255 255 255);
+  --secondary: rgb(239 240 242);
+  --secondary-foreground: rgb(47 49 52);
+  --muted: rgb(239 240 242);
+  --muted-foreground: rgb(106 109 113);
+  --accent: rgb(218 231 249);
+  --accent-foreground: rgb(34 68 124);
+  --destructive: rgb(196 72 62);
+  --border: rgb(213 215 219);
+  --input: rgb(200 203 209);
+  --ring: rgb(75 110 175);
+  --chart-1: rgb(75 110 175);
+  --chart-2: rgb(78 139 119);
+  --chart-3: rgb(181 128 62);
+  --chart-4: rgb(132 112 184);
+  --chart-5: rgb(188 91 87);
+  --sidebar: rgb(235 236 240);
+  --sidebar-foreground: rgb(47 49 52);
+  --sidebar-primary: rgb(75 110 175);
+  --sidebar-primary-foreground: rgb(255 255 255);
+  --sidebar-accent: rgb(222 226 233);
+  --sidebar-accent-foreground: rgb(34 68 124);
+  --sidebar-border: rgb(207 210 216);
+  --sidebar-ring: rgb(75 110 175);
+  --dbx-chrome: rgb(230 231 235);
+  --dbx-chrome-muted: rgb(224 226 231);
+  --dbx-content: rgb(255 255 255);
+  --dbx-editor-toolbar: rgb(246 247 249);
+  --dbx-gutter: rgb(222 225 231);
+  --dbx-sidebar-header: rgb(229 231 236);
+}
+
+html.theme-idea.dark {
+  --background: rgb(43 43 43);
+  --foreground: rgb(187 187 187);
+  --card: rgb(60 63 65);
+  --card-foreground: rgb(187 187 187);
+  --popover: rgb(67 70 72);
+  --popover-foreground: rgb(200 200 200);
+  --primary: rgb(106 135 197);
+  --primary-foreground: rgb(30 32 34);
+  --secondary: rgb(60 63 65);
+  --secondary-foreground: rgb(187 187 187);
+  --muted: rgb(60 63 65);
+  --muted-foreground: rgb(139 141 143);
+  --accent: rgb(72 78 86);
+  --accent-foreground: rgb(210 218 234);
+  --destructive: rgb(226 104 96);
+  --border: rgb(85 86 87);
+  --input: rgb(96 97 98);
+  --ring: rgb(106 135 197);
+  --chart-1: rgb(106 135 197);
+  --chart-2: rgb(98 170 142);
+  --chart-3: rgb(204 152 88);
+  --chart-4: rgb(166 145 205);
+  --chart-5: rgb(211 115 108);
+  --sidebar: rgb(49 51 53);
+  --sidebar-foreground: rgb(184 186 188);
+  --sidebar-primary: rgb(106 135 197);
+  --sidebar-primary-foreground: rgb(30 32 34);
+  --sidebar-accent: rgb(62 66 70);
+  --sidebar-accent-foreground: rgb(206 214 229);
+  --sidebar-border: rgb(85 86 87);
+  --sidebar-ring: rgb(106 135 197);
+  --dbx-chrome: rgb(60 63 65);
+  --dbx-chrome-muted: rgb(55 58 60);
+  --dbx-content: rgb(43 43 43);
+  --dbx-editor-toolbar: rgb(50 53 55);
+  --dbx-gutter: rgb(38 38 38);
+  --dbx-sidebar-header: rgb(55 58 60);
+}
+
+html.theme-xcode {
+  --background: rgb(250 252 255);
+  --foreground: rgb(31 41 55);
+  --card: rgb(255 255 255);
+  --card-foreground: rgb(29 39 53);
+  --popover: rgb(255 255 255);
+  --popover-foreground: rgb(29 39 53);
+  --primary: rgb(10 132 255);
+  --primary-foreground: rgb(255 255 255);
+  --secondary: rgb(235 239 245);
+  --secondary-foreground: rgb(43 55 72);
+  --muted: rgb(235 239 245);
+  --muted-foreground: rgb(98 110 126);
+  --accent: rgb(219 236 255);
+  --accent-foreground: rgb(0 75 153);
+  --destructive: rgb(200 71 62);
+  --border: rgb(207 216 228);
+  --input: rgb(194 206 221);
+  --ring: rgb(10 132 255);
+  --chart-1: rgb(10 132 255);
+  --chart-2: rgb(78 145 163);
+  --chart-3: rgb(184 132 67);
+  --chart-4: rgb(130 113 190);
+  --chart-5: rgb(190 92 90);
+  --sidebar: rgb(242 245 250);
+  --sidebar-foreground: rgb(43 55 72);
+  --sidebar-primary: rgb(10 132 255);
+  --sidebar-primary-foreground: rgb(255 255 255);
+  --sidebar-accent: rgb(224 235 250);
+  --sidebar-accent-foreground: rgb(0 75 153);
+  --sidebar-border: rgb(201 211 224);
+  --sidebar-ring: rgb(10 132 255);
+  --dbx-chrome: rgb(233 237 243);
+  --dbx-chrome-muted: rgb(226 232 240);
+  --dbx-content: rgb(255 255 255);
+  --dbx-editor-toolbar: rgb(247 249 252);
+  --dbx-gutter: rgb(221 229 239);
+  --dbx-sidebar-header: rgb(235 240 247);
+}
+
+html.theme-xcode.dark {
+  --background: rgb(31 35 41);
+  --foreground: rgb(215 221 231);
+  --card: rgb(37 41 50);
+  --card-foreground: rgb(216 222 232);
+  --popover: rgb(45 51 59);
+  --popover-foreground: rgb(224 229 237);
+  --primary: rgb(10 132 255);
+  --primary-foreground: rgb(255 255 255);
+  --secondary: rgb(45 51 59);
+  --secondary-foreground: rgb(216 222 232);
+  --muted: rgb(45 51 59);
+  --muted-foreground: rgb(149 158 173);
+  --accent: rgb(29 69 117);
+  --accent-foreground: rgb(222 238 255);
+  --destructive: rgb(229 105 96);
+  --border: rgb(94 106 124 / 0.42);
+  --input: rgb(104 118 139 / 0.44);
+  --ring: rgb(86 160 255);
+  --chart-1: rgb(86 160 255);
+  --chart-2: rgb(111 174 190);
+  --chart-3: rgb(203 153 90);
+  --chart-4: rgb(160 144 207);
+  --chart-5: rgb(211 116 111);
+  --sidebar: rgb(37 41 50);
+  --sidebar-foreground: rgb(207 214 225);
+  --sidebar-primary: rgb(10 132 255);
+  --sidebar-primary-foreground: rgb(255 255 255);
+  --sidebar-accent: rgb(45 54 68);
+  --sidebar-accent-foreground: rgb(220 236 255);
+  --sidebar-border: rgb(94 106 124 / 0.38);
+  --sidebar-ring: rgb(86 160 255);
+  --dbx-chrome: rgb(45 51 59);
+  --dbx-chrome-muted: rgb(39 45 53);
+  --dbx-content: rgb(31 35 41);
+  --dbx-editor-toolbar: rgb(35 39 46);
+  --dbx-gutter: rgb(25 29 34);
+  --dbx-sidebar-header: rgb(42 47 56);
+}
+
+html.theme-jetbrains {
+  --background: rgb(248 249 251);
+  --foreground: rgb(31 35 40);
+  --card: rgb(255 255 255);
+  --card-foreground: rgb(28 32 37);
+  --popover: rgb(255 255 255);
+  --popover-foreground: rgb(28 32 37);
+  --primary: rgb(108 93 211);
+  --primary-foreground: rgb(255 255 255);
+  --secondary: rgb(235 237 241);
+  --secondary-foreground: rgb(43 48 56);
+  --muted: rgb(235 237 241);
+  --muted-foreground: rgb(100 108 119);
+  --accent: rgb(229 225 251);
+  --accent-foreground: rgb(66 52 153);
+  --destructive: rgb(198 72 62);
+  --border: rgb(211 216 224);
+  --input: rgb(198 204 214);
+  --ring: rgb(108 93 211);
+  --chart-1: rgb(108 93 211);
+  --chart-2: rgb(57 151 167);
+  --chart-3: rgb(184 132 67);
+  --chart-4: rgb(72 125 197);
+  --chart-5: rgb(190 91 90);
+  --sidebar: rgb(242 243 245);
+  --sidebar-foreground: rgb(43 48 56);
+  --sidebar-primary: rgb(108 93 211);
+  --sidebar-primary-foreground: rgb(255 255 255);
+  --sidebar-accent: rgb(229 231 236);
+  --sidebar-accent-foreground: rgb(66 52 153);
+  --sidebar-border: rgb(205 210 219);
+  --sidebar-ring: rgb(108 93 211);
+  --dbx-chrome: rgb(235 237 241);
+  --dbx-chrome-muted: rgb(228 231 236);
+  --dbx-content: rgb(255 255 255);
+  --dbx-editor-toolbar: rgb(247 248 250);
+  --dbx-gutter: rgb(224 228 235);
+  --dbx-sidebar-header: rgb(237 239 243);
+}
+
+html.theme-jetbrains.dark {
+  --background: rgb(30 31 34);
+  --foreground: rgb(223 225 229);
+  --card: rgb(43 45 48);
+  --card-foreground: rgb(223 225 229);
+  --popover: rgb(49 51 56);
+  --popover-foreground: rgb(231 233 237);
+  --primary: rgb(123 97 255);
+  --primary-foreground: rgb(255 255 255);
+  --secondary: rgb(43 45 48);
+  --secondary-foreground: rgb(223 225 229);
+  --muted: rgb(43 45 48);
+  --muted-foreground: rgb(161 164 171);
+  --accent: rgb(61 58 89);
+  --accent-foreground: rgb(233 231 255);
+  --destructive: rgb(229 105 96);
+  --border: rgb(77 80 86);
+  --input: rgb(89 92 99);
+  --ring: rgb(123 97 255);
+  --chart-1: rgb(123 97 255);
+  --chart-2: rgb(75 190 202);
+  --chart-3: rgb(207 155 91);
+  --chart-4: rgb(105 162 230);
+  --chart-5: rgb(214 116 111);
+  --sidebar: rgb(43 45 48);
+  --sidebar-foreground: rgb(215 218 224);
+  --sidebar-primary: rgb(123 97 255);
+  --sidebar-primary-foreground: rgb(255 255 255);
+  --sidebar-accent: rgb(54 56 61);
+  --sidebar-accent-foreground: rgb(232 231 255);
+  --sidebar-border: rgb(77 80 86);
+  --sidebar-ring: rgb(123 97 255);
+  --dbx-chrome: rgb(43 45 48);
+  --dbx-chrome-muted: rgb(37 39 42);
+  --dbx-content: rgb(30 31 34);
+  --dbx-editor-toolbar: rgb(35 37 40);
+  --dbx-gutter: rgb(24 25 28);
+  --dbx-sidebar-header: rgb(39 41 44);
+}
+
+html.theme-cursor {
+  --background: rgb(251 252 254);
+  --foreground: rgb(31 36 45);
+  --card: rgb(255 255 255);
+  --card-foreground: rgb(28 33 42);
+  --popover: rgb(255 255 255);
+  --popover-foreground: rgb(28 33 42);
+  --primary: rgb(59 130 246);
+  --primary-foreground: rgb(255 255 255);
+  --secondary: rgb(239 241 245);
+  --secondary-foreground: rgb(42 49 60);
+  --muted: rgb(239 241 245);
+  --muted-foreground: rgb(101 111 126);
+  --accent: rgb(222 235 255);
+  --accent-foreground: rgb(31 79 154);
+  --destructive: rgb(198 72 62);
+  --border: rgb(213 218 226);
+  --input: rgb(199 206 217);
+  --ring: rgb(59 130 246);
+  --chart-1: rgb(59 130 246);
+  --chart-2: rgb(78 151 166);
+  --chart-3: rgb(184 132 67);
+  --chart-4: rgb(132 112 190);
+  --chart-5: rgb(190 91 90);
+  --sidebar: rgb(244 245 247);
+  --sidebar-foreground: rgb(42 49 60);
+  --sidebar-primary: rgb(59 130 246);
+  --sidebar-primary-foreground: rgb(255 255 255);
+  --sidebar-accent: rgb(230 234 241);
+  --sidebar-accent-foreground: rgb(31 79 154);
+  --sidebar-border: rgb(207 213 223);
+  --sidebar-ring: rgb(59 130 246);
+  --dbx-chrome: rgb(242 243 245);
+  --dbx-chrome-muted: rgb(234 237 242);
+  --dbx-content: rgb(255 255 255);
+  --dbx-editor-toolbar: rgb(247 248 250);
+  --dbx-gutter: rgb(228 232 239);
+  --dbx-sidebar-header: rgb(238 240 244);
+}
+
+html.theme-cursor.dark {
+  --background: rgb(15 17 26);
+  --foreground: rgb(213 215 222);
+  --card: rgb(21 24 33);
+  --card-foreground: rgb(214 216 223);
+  --popover: rgb(27 30 39);
+  --popover-foreground: rgb(223 225 232);
+  --primary: rgb(107 164 255);
+  --primary-foreground: rgb(8 12 20);
+  --secondary: rgb(27 30 39);
+  --secondary-foreground: rgb(214 216 223);
+  --muted: rgb(27 30 39);
+  --muted-foreground: rgb(142 149 164);
+  --accent: rgb(31 51 82);
+  --accent-foreground: rgb(222 236 255);
+  --destructive: rgb(228 104 96);
+  --border: rgb(82 91 111 / 0.42);
+  --input: rgb(93 104 128 / 0.44);
+  --ring: rgb(107 164 255);
+  --chart-1: rgb(107 164 255);
+  --chart-2: rgb(91 187 199);
+  --chart-3: rgb(204 154 91);
+  --chart-4: rgb(162 143 207);
+  --chart-5: rgb(213 116 111);
+  --sidebar: rgb(21 24 33);
+  --sidebar-foreground: rgb(205 209 219);
+  --sidebar-primary: rgb(107 164 255);
+  --sidebar-primary-foreground: rgb(8 12 20);
+  --sidebar-accent: rgb(28 34 46);
+  --sidebar-accent-foreground: rgb(219 233 255);
+  --sidebar-border: rgb(82 91 111 / 0.38);
+  --sidebar-ring: rgb(107 164 255);
+  --dbx-chrome: rgb(27 30 39);
+  --dbx-chrome-muted: rgb(24 27 36);
+  --dbx-content: rgb(15 17 26);
+  --dbx-editor-toolbar: rgb(20 23 32);
+  --dbx-gutter: rgb(11 13 20);
+  --dbx-sidebar-header: rgb(25 28 38);
+}
+
+html.theme-claude {
+  --background: rgb(251 247 239);
+  --foreground: rgb(51 43 35);
+  --card: rgb(255 253 248);
+  --card-foreground: rgb(48 40 32);
+  --popover: rgb(255 253 248);
+  --popover-foreground: rgb(48 40 32);
+  --primary: rgb(184 107 60);
+  --primary-foreground: rgb(255 250 243);
+  --secondary: rgb(242 231 219);
+  --secondary-foreground: rgb(65 53 43);
+  --muted: rgb(242 231 219);
+  --muted-foreground: rgb(117 98 81);
+  --accent: rgb(234 216 198);
+  --accent-foreground: rgb(99 54 31);
+  --destructive: rgb(195 73 61);
+  --border: rgb(221 205 187);
+  --input: rgb(209 190 169);
+  --ring: rgb(184 107 60);
+  --chart-1: rgb(184 107 60);
+  --chart-2: rgb(84 139 119);
+  --chart-3: rgb(75 124 160);
+  --chart-4: rgb(135 112 178);
+  --chart-5: rgb(188 92 87);
+  --sidebar: rgb(239 231 220);
+  --sidebar-foreground: rgb(58 48 39);
+  --sidebar-primary: rgb(184 107 60);
+  --sidebar-primary-foreground: rgb(255 250 243);
+  --sidebar-accent: rgb(231 216 200);
+  --sidebar-accent-foreground: rgb(99 54 31);
+  --sidebar-border: rgb(215 199 181);
+  --sidebar-ring: rgb(184 107 60);
+  --dbx-chrome: rgb(241 231 219);
+  --dbx-chrome-muted: rgb(234 222 209);
+  --dbx-content: rgb(255 253 248);
+  --dbx-editor-toolbar: rgb(248 241 233);
+  --dbx-gutter: rgb(230 216 199);
+  --dbx-sidebar-header: rgb(236 226 214);
+}
+
+html.theme-claude.dark {
+  --background: rgb(33 31 28);
+  --foreground: rgb(216 208 196);
+  --card: rgb(42 39 35);
+  --card-foreground: rgb(219 211 199);
+  --popover: rgb(49 45 40);
+  --popover-foreground: rgb(226 218 206);
+  --primary: rgb(210 138 95);
+  --primary-foreground: rgb(35 27 21);
+  --secondary: rgb(55 49 43);
+  --secondary-foreground: rgb(219 211 199);
+  --muted: rgb(55 49 43);
+  --muted-foreground: rgb(163 150 134);
+  --accent: rgb(68 56 47);
+  --accent-foreground: rgb(232 222 210);
+  --destructive: rgb(226 103 95);
+  --border: rgb(127 108 91 / 0.38);
+  --input: rgb(138 117 98 / 0.4);
+  --ring: rgb(210 138 95);
+  --chart-1: rgb(210 138 95);
+  --chart-2: rgb(116 177 149);
+  --chart-3: rgb(101 161 198);
+  --chart-4: rgb(160 143 205);
+  --chart-5: rgb(211 115 109);
+  --sidebar: rgb(42 39 35);
+  --sidebar-foreground: rgb(210 201 188);
+  --sidebar-primary: rgb(210 138 95);
+  --sidebar-primary-foreground: rgb(35 27 21);
+  --sidebar-accent: rgb(56 50 44);
+  --sidebar-accent-foreground: rgb(229 219 207);
+  --sidebar-border: rgb(127 108 91 / 0.35);
+  --sidebar-ring: rgb(210 138 95);
+  --dbx-chrome: rgb(49 45 40);
+  --dbx-chrome-muted: rgb(55 49 43);
+  --dbx-content: rgb(33 31 28);
+  --dbx-editor-toolbar: rgb(39 36 32);
+  --dbx-gutter: rgb(27 25 23);
+  --dbx-sidebar-header: rgb(45 41 37);
+}
+
+@supports (color: oklch(1 0 0)) {
+  :root {
+    --background: oklch(1 0 0);
+    --foreground: oklch(0.145 0 0);
+    --card: oklch(1 0 0);
+    --card-foreground: oklch(0.145 0 0);
+    --popover: oklch(1 0 0);
+    --popover-foreground: oklch(0.145 0 0);
+    --primary: oklch(0.205 0 0);
+    --primary-foreground: oklch(0.985 0 0);
+    --secondary: oklch(0.97 0 0);
+    --secondary-foreground: oklch(0.205 0 0);
+    --muted: oklch(0.97 0 0);
+    --muted-foreground: oklch(0.556 0 0);
+    --accent: oklch(0.97 0 0);
+    --accent-foreground: oklch(0.205 0 0);
+    --destructive: oklch(0.577 0.245 27.325);
+    --border: oklch(0.922 0 0);
+    --input: oklch(0.922 0 0);
+    --ring: oklch(0.708 0 0);
+    --chart-1: oklch(0.87 0 0);
+    --chart-2: oklch(0.556 0 0);
+    --chart-3: oklch(0.439 0 0);
+    --chart-4: oklch(0.371 0 0);
+    --chart-5: oklch(0.269 0 0);
+    --sidebar: oklch(0.985 0 0);
+    --sidebar-foreground: oklch(0.145 0 0);
+    --sidebar-primary: oklch(0.205 0 0);
+    --sidebar-primary-foreground: oklch(0.985 0 0);
+    --sidebar-accent: oklch(0.97 0 0);
+    --sidebar-accent-foreground: oklch(0.205 0 0);
+    --sidebar-border: oklch(0.922 0 0);
+    --sidebar-ring: oklch(0.708 0 0);
+  }
+
+  .dark {
+    --background: oklch(0.19 0.004 285);
+    --foreground: oklch(0.88 0.006 285);
+    --card: oklch(0.225 0.005 285);
+    --card-foreground: oklch(0.88 0.006 285);
+    --popover: oklch(0.235 0.005 285);
+    --popover-foreground: oklch(0.89 0.006 285);
+    --primary: oklch(0.86 0.008 285);
+    --primary-foreground: oklch(0.19 0.004 285);
+    --secondary: oklch(0.285 0.006 285);
+    --secondary-foreground: oklch(0.88 0.006 285);
+    --muted: oklch(0.285 0.006 285);
+    --muted-foreground: oklch(0.68 0.008 285);
+    --accent: oklch(0.305 0.008 285);
+    --accent-foreground: oklch(0.9 0.006 285);
+    --destructive: oklch(0.68 0.18 24);
+    --border: oklch(0.54 0.006 285 / 28%);
+    --input: oklch(0.54 0.006 285 / 34%);
+    --ring: oklch(0.62 0.008 285);
+    --chart-1: oklch(0.87 0 0);
+    --chart-2: oklch(0.556 0 0);
+    --chart-3: oklch(0.439 0 0);
+    --chart-4: oklch(0.371 0 0);
+    --chart-5: oklch(0.269 0 0);
+    --sidebar: oklch(0.215 0.005 285);
+    --sidebar-foreground: oklch(0.86 0.006 285);
+    --sidebar-primary: oklch(0.488 0.243 264.376);
+    --sidebar-primary-foreground: oklch(0.94 0.006 285);
+    --sidebar-accent: oklch(0.295 0.006 285);
+    --sidebar-accent-foreground: oklch(0.9 0.006 285);
+    --sidebar-border: oklch(0.54 0.006 285 / 28%);
+    --sidebar-ring: oklch(0.62 0.008 285);
+  }
+
+  html.theme-soft {
+    --background: oklch(0.985 0.003 255);
+    --foreground: oklch(0.315 0.018 255);
+    --card: oklch(1 0 0);
+    --card-foreground: oklch(0.295 0.018 255);
+    --popover: oklch(1 0 0);
+    --popover-foreground: oklch(0.295 0.018 255);
+    --primary: oklch(0.48 0.115 255);
+    --primary-foreground: oklch(0.985 0.006 255);
+    --secondary: oklch(0.955 0.008 255);
+    --secondary-foreground: oklch(0.36 0.02 255);
+    --muted: oklch(0.955 0.008 255);
+    --muted-foreground: oklch(0.53 0.024 255);
+    --accent: oklch(0.925 0.014 255);
+    --accent-foreground: oklch(0.32 0.03 255);
+    --destructive: oklch(0.55 0.16 28);
+    --border: oklch(0.875 0.012 255);
+    --input: oklch(0.835 0.018 255);
+    --ring: oklch(0.61 0.045 255);
+    --chart-1: oklch(0.57 0.12 255);
+    --chart-2: oklch(0.62 0.09 180);
+    --chart-3: oklch(0.65 0.12 70);
+    --chart-4: oklch(0.62 0.1 300);
+    --chart-5: oklch(0.63 0.13 28);
+    --sidebar: oklch(0.955 0.007 255);
+    --sidebar-foreground: oklch(0.35 0.022 255);
+    --sidebar-primary: oklch(0.48 0.115 255);
+    --sidebar-primary-foreground: oklch(0.985 0.006 255);
+    --sidebar-accent: oklch(0.92 0.014 255);
+    --sidebar-accent-foreground: oklch(0.31 0.03 255);
+    --sidebar-border: oklch(0.855 0.014 255);
+    --sidebar-ring: oklch(0.61 0.045 255);
+    --dbx-chrome: oklch(0.948 0.008 255);
+    --dbx-chrome-muted: oklch(0.93 0.012 255);
+    --dbx-content: oklch(1 0 0);
+    --dbx-editor-toolbar: oklch(0.973 0.005 255);
+    --dbx-gutter: oklch(0.925 0.011 255);
+    --dbx-sidebar-header: oklch(0.94 0.009 255);
+  }
+
+  html.theme-soft.dark {
+    --background: oklch(0.245 0.009 260);
+    --foreground: oklch(0.835 0.014 260);
+    --card: oklch(0.285 0.011 260);
+    --card-foreground: oklch(0.835 0.014 260);
+    --popover: oklch(0.305 0.012 260);
+    --popover-foreground: oklch(0.855 0.014 260);
+    --primary: oklch(0.76 0.045 260);
+    --primary-foreground: oklch(0.22 0.01 260);
+    --secondary: oklch(0.345 0.013 260);
+    --secondary-foreground: oklch(0.83 0.014 260);
+    --muted: oklch(0.345 0.013 260);
+    --muted-foreground: oklch(0.68 0.018 260);
+    --accent: oklch(0.385 0.018 260);
+    --accent-foreground: oklch(0.86 0.014 260);
+    --destructive: oklch(0.68 0.16 26);
+    --border: oklch(0.62 0.018 260 / 34%);
+    --input: oklch(0.66 0.02 260 / 36%);
+    --ring: oklch(0.68 0.025 260);
+    --chart-1: oklch(0.69 0.08 255);
+    --chart-2: oklch(0.7 0.09 180);
+    --chart-3: oklch(0.72 0.11 70);
+    --chart-4: oklch(0.7 0.08 300);
+    --chart-5: oklch(0.7 0.12 28);
+    --sidebar: oklch(0.265 0.011 260);
+    --sidebar-foreground: oklch(0.805 0.015 260);
+    --sidebar-primary: oklch(0.76 0.045 260);
+    --sidebar-primary-foreground: oklch(0.22 0.01 260);
+    --sidebar-accent: oklch(0.335 0.016 260);
+    --sidebar-accent-foreground: oklch(0.85 0.014 260);
+    --sidebar-border: oklch(0.62 0.018 260 / 32%);
+    --sidebar-ring: oklch(0.68 0.025 260);
+    --dbx-chrome: oklch(0.295 0.012 260);
+    --dbx-chrome-muted: oklch(0.32 0.013 260);
+    --dbx-content: oklch(0.255 0.01 260);
+    --dbx-editor-toolbar: oklch(0.275 0.01 260);
+    --dbx-gutter: oklch(0.215 0.01 260);
+    --dbx-sidebar-header: oklch(0.285 0.012 260);
+  }
+}
+
+html.disable-transitions,
+html.disable-transitions *,
+html.disable-transitions *::before,
+html.disable-transitions *::after {
+  transition-duration: 0s !important;
+  animation-duration: 0s !important;
+}
+
+body.dbx-table-reference-dragging,
+body.dbx-table-reference-dragging * {
+  user-select: none !important;
+  -webkit-user-select: none !important;
+}
+
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
+  }
+  html,
+  body,
+  #root {
+    width: 100%;
+    height: 100%;
+    overflow: hidden;
+    overscroll-behavior: none;
+  }
+  body {
+    @apply font-sans bg-background text-foreground;
+    text-rendering: geometricPrecision;
+    font-synthesis: none;
+  }
+  button,
+  [role="button"],
+  [role="menuitem"],
+  [role="option"],
+  [role="tab"],
+  [role="checkbox"],
+  [role="radio"],
+  [role="switch"],
+  select,
+  summary,
+  label,
+  a[href] {
+    cursor: pointer;
+    user-select: none;
+  }
+}
+
+.dbx-desktop-window-frame {
+  position: relative;
+}
+
+.dbx-desktop-window-frame::before {
+  content: "";
+  position: absolute;
+  z-index: 80;
+  top: 0;
+  right: 0;
+  left: 0;
+  height: 1px;
+  pointer-events: none;
+  background: var(--dbx-window-top-border);
+}
+
+.dbx-editor-font-family {
+  font-family: var(--dbx-editor-font-family, var(--font-mono, monospace));
+}
+
+:root {
+  --dbx-data-grid-font-family: "Geist Variable Tabular", "Geist Variable", "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif;
+}
+
+.dbx-data-grid-font-family {
+  font-family: var(--dbx-data-grid-font-family);
+  font-size: 12.5px;
+}
+
+/* Tailwind CSS v4 targets Safari 16.4+. Keep these legacy WebKit fallbacks
+ * isolated so supported WebViews continue using the generated component CSS. */
+@supports not (color: oklch(0.5 0.1 180)) {
+@media (min-width: 640px) {
+  .sm\:flex-row {
+    flex-direction: row !important;
+  }
+
+  .sm\:justify-end {
+    justify-content: flex-end !important;
+  }
+
+  .sm\:grid-cols-3 {
+    grid-template-columns: repeat(3, minmax(0, 1fr)) !important;
+  }
+}
+
+@media (min-width: 768px) {
+  .md\:w-full {
+    width: 100% !important;
+  }
+
+  .md\:grid-cols-2 {
+    grid-template-columns: repeat(2, minmax(0, 1fr)) !important;
+  }
+
+  .md\:grid-cols-\[1fr_auto\] {
+    grid-template-columns: 1fr auto !important;
+  }
+
+  .md\:grid-cols-\[minmax\(0\,1fr\)_180px_auto\] {
+    grid-template-columns: minmax(0, 1fr) 180px auto !important;
+  }
+}
+
+@media (min-width: 1024px) {
+  .lg\:block {
+    display: block !important;
+  }
+
+  .lg\:hidden {
+    display: none !important;
+  }
+
+  .lg\:grid {
+    display: grid !important;
+  }
+
+  .lg\:flex-row {
+    flex-direction: row !important;
+  }
+
+  .lg\:flex-col {
+    flex-direction: column !important;
+  }
+
+  .lg\:items-center {
+    align-items: center !important;
+  }
+
+  .lg\:justify-between {
+    justify-content: space-between !important;
+  }
+
+  .lg\:justify-end {
+    justify-content: flex-end !important;
+  }
+
+  .lg\:w-40 {
+    width: 10rem !important;
+  }
+
+  .lg\:overflow-x-hidden {
+    overflow-x: hidden !important;
+  }
+
+  .lg\:overflow-y-auto {
+    overflow-y: auto !important;
+  }
+
+  .lg\:border-b-0 {
+    border-bottom-width: 0 !important;
+  }
+
+  .lg\:border-r {
+    border-right-width: 1px !important;
+  }
+
+  .lg\:pb-0 {
+    padding-bottom: 0 !important;
+  }
+
+  .lg\:pr-3 {
+    padding-right: 0.75rem !important;
+  }
+
+  .lg\:text-right {
+    text-align: right !important;
+  }
+
+  .lg\:grid-cols-6 {
+    grid-template-columns: repeat(6, minmax(0, 1fr)) !important;
+  }
+
+  .lg\:grid-cols-\[1\.2fr_0\.8fr\] {
+    grid-template-columns: minmax(0, 1.2fr) minmax(0, 0.8fr) !important;
+  }
+
+  .lg\:grid-cols-\[minmax\(0\,1\.6fr\)_72px_56px_76px_58px_76px_72px\] {
+    grid-template-columns: minmax(0, 1.6fr) 72px 56px 76px 58px 76px 72px !important;
+  }
+}
+
+[data-slot="dialog-content"] {
+  width: calc(100vw - 2rem);
+  max-width: 24rem;
+  border: 1px solid rgb(229, 229, 229);
+  border-color: rgb(229, 229, 229) !important;
+  box-shadow: 0 18px 50px rgba(0, 0, 0, 0.16);
+}
+
+.dark [data-slot="dialog-content"] {
+  border-color: rgba(110, 110, 114, 0.28) !important;
+  box-shadow: 0 18px 50px rgba(0, 0, 0, 0.45);
+}
+
+[data-slot="dialog-content"][class~="max-w-sm"] {
+  max-width: 24rem !important;
+}
+
+[data-slot="dialog-content"][class~="max-w-md"] {
+  max-width: 28rem !important;
+}
+
+[data-slot="dialog-content"][class~="max-w-lg"] {
+  max-width: 32rem !important;
+}
+
+[data-slot="dialog-content"][class~="max-w-xl"] {
+  max-width: 36rem !important;
+}
+
+[data-slot="dialog-content"][class~="max-w-2xl"] {
+  max-width: 42rem !important;
+}
+
+[data-slot="dialog-content"][class~="max-w-4xl"] {
+  max-width: 56rem !important;
+}
+
+[data-slot="dialog-content"][class~="max-w-5xl"] {
+  max-width: 64rem !important;
+}
+
+[data-slot="dialog-content"][class~="max-w-190"] {
+  max-width: 47.5rem !important;
+}
+
+[data-slot="dialog-content"][class*="max-w-[92vw]"] {
+  max-width: 92vw !important;
+}
+
+[data-slot="dialog-content"][class*="max-w-[94vw]"] {
+  max-width: 94vw !important;
+}
+
+[data-slot="dialog-content"][class*="max-w-[1100px]"] {
+  max-width: 1100px !important;
+}
+
+[data-slot="tabs"][data-orientation="horizontal"] {
+  flex-direction: column !important;
+}
+
+[data-slot="tabs"][data-orientation="vertical"] {
+  flex-direction: row !important;
+}
+
+[data-slot="tabs-list"] {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: fit-content;
+  border-radius: 6px;
+  color: var(--muted-foreground);
+}
+
+[data-slot="tabs-list"][data-variant="default"] {
+  min-height: 2rem;
+  padding: 3px;
+  background: var(--muted);
+}
+
+[data-slot="tabs-list"][data-variant="line"] {
+  gap: 0.25rem;
+  padding: 3px;
+  background: transparent;
+  border-radius: 0;
+}
+
+[data-slot="tabs"][data-orientation="vertical"] > [data-slot="tabs-list"] {
+  flex-direction: column !important;
+  height: fit-content;
+}
+
+[data-slot="tabs-trigger"] {
+  position: relative;
+  display: inline-flex;
+  flex: 1 1 0%;
+  align-items: center;
+  justify-content: center;
+  min-width: 0;
+  height: calc(100% - 1px);
+  padding: 0.125rem 0.375rem;
+  gap: 0.375rem;
+  border: 1px solid transparent;
+  border-radius: 0.375rem;
+  color: rgba(10, 10, 10, 0.6);
+  font-size: 0.875rem;
+  font-weight: 500;
+  line-height: 1.25rem;
+  white-space: nowrap;
+  transition:
+    color 150ms ease,
+    background-color 150ms ease,
+    border-color 150ms ease,
+    box-shadow 150ms ease;
+}
+
+[data-slot="tabs"][data-orientation="vertical"] [data-slot="tabs-trigger"] {
+  width: 100%;
+  justify-content: flex-start;
+}
+
+[data-slot="tabs-trigger"]:hover {
+  color: var(--foreground);
+}
+
+[data-slot="tabs-trigger"]:focus-visible {
+  border-color: var(--ring);
+  outline: 1px solid var(--ring);
+  box-shadow: 0 0 0 3px rgba(161, 161, 161, 0.5);
+}
+
+[data-slot="tabs-list"][data-variant="default"] > [data-slot="tabs-trigger"][aria-selected="true"],
+[data-slot="tabs-list"][data-variant="default"] > [data-slot="tabs-trigger"][data-state="active"],
+[data-slot="tabs-list"][data-variant="default"] > [data-slot="tabs-trigger"][data-active] {
+  color: var(--foreground);
+  background: var(--background);
+  border-color: transparent;
+  box-shadow:
+    0 1px 2px rgba(0, 0, 0, 0.08),
+    0 1px 1px rgba(0, 0, 0, 0.04);
+}
+
+[data-slot="tabs-list"][data-variant="line"] > [data-slot="tabs-trigger"] {
+  background: transparent;
+  box-shadow: none;
+}
+
+[data-slot="tabs-list"][data-variant="line"] > [data-slot="tabs-trigger"][aria-selected="true"],
+[data-slot="tabs-list"][data-variant="line"] > [data-slot="tabs-trigger"][data-state="active"],
+[data-slot="tabs-list"][data-variant="line"] > [data-slot="tabs-trigger"][data-active] {
+  color: var(--foreground);
+  background: transparent;
+  border-color: transparent;
+  box-shadow: none;
+}
+
+[data-slot="tabs-list"][data-variant="line"] > [data-slot="tabs-trigger"]::after {
+  content: "";
+  position: absolute;
+  background: var(--foreground);
+  opacity: 0;
+  transition: opacity 150ms ease;
+}
+
+[data-slot="tabs"][data-orientation="horizontal"] [data-slot="tabs-list"][data-variant="line"] > [data-slot="tabs-trigger"]::after {
+  left: 0;
+  right: 0;
+  bottom: -5px;
+  height: 2px;
+}
+
+[data-slot="tabs"][data-orientation="vertical"] [data-slot="tabs-list"][data-variant="line"] > [data-slot="tabs-trigger"]::after {
+  top: 0;
+  right: -4px;
+  bottom: 0;
+  width: 2px;
+}
+
+[data-slot="tabs-list"][data-variant="line"] > [data-slot="tabs-trigger"][aria-selected="true"]::after,
+[data-slot="tabs-list"][data-variant="line"] > [data-slot="tabs-trigger"][data-state="active"]::after,
+[data-slot="tabs-list"][data-variant="line"] > [data-slot="tabs-trigger"][data-active]::after {
+  opacity: 1;
+}
+
+.dark [data-slot="tabs-trigger"] {
+  color: var(--muted-foreground);
+}
+
+.dark [data-slot="tabs-trigger"]:hover {
+  color: var(--foreground);
+}
+
+.dark [data-slot="tabs-list"][data-variant="default"] > [data-slot="tabs-trigger"][aria-selected="true"],
+.dark [data-slot="tabs-list"][data-variant="default"] > [data-slot="tabs-trigger"][data-state="active"],
+.dark [data-slot="tabs-list"][data-variant="default"] > [data-slot="tabs-trigger"][data-active] {
+  color: var(--foreground);
+  background: rgba(110, 110, 114, 0.3);
+  border-color: var(--input);
+  box-shadow:
+    0 1px 2px rgba(0, 0, 0, 0.22),
+    0 1px 1px rgba(0, 0, 0, 0.16);
+}
+
+[data-slot="tabs-content"] {
+  min-width: 0;
+}
+
+.dark [data-grid-root] .data-grid-header-shell,
+.dark [data-grid-root] .data-grid-header-cell,
+.dark [data-grid-root] .data-grid-transpose-header,
+.dark [data-grid-root] [data-grid-column-index] {
+  background-color: rgb(24, 25, 27) !important;
+}
+
+.dark [data-grid-root] .data-grid-header-row,
+.dark [data-grid-root] .data-grid-transpose-header {
+  color: rgb(215, 215, 219) !important;
+}
+
+.dark [data-grid-root] .data-grid-header-cell:hover,
+.dark [data-grid-root] [data-grid-column-index]:hover {
+  background-color: rgb(38, 39, 42) !important;
+}
+
+@media (min-width: 640px) {
+  [data-slot="dialog-footer"] {
+    flex-direction: row !important;
+    justify-content: flex-end !important;
+  }
+
+  [data-slot="dialog-content"][class~="sm:max-w-sm"] {
+    max-width: 24rem !important;
+  }
+
+  [data-slot="dialog-content"][class~="sm:max-w-md"] {
+    max-width: 28rem !important;
+  }
+
+  [data-slot="dialog-content"][class~="sm:max-w-lg"] {
+    max-width: 32rem !important;
+  }
+
+  [data-slot="dialog-content"][class~="sm:max-w-xl"] {
+    max-width: 36rem !important;
+  }
+
+  [data-slot="dialog-content"][class~="sm:max-w-2xl"] {
+    max-width: 42rem !important;
+  }
+
+  [data-slot="dialog-content"][class~="sm:max-w-3xl"] {
+    max-width: 48rem !important;
+  }
+
+  [data-slot="dialog-content"][class~="sm:max-w-4xl"] {
+    max-width: 56rem !important;
+  }
+
+  [data-slot="dialog-content"][class~="sm:max-w-5xl"] {
+    max-width: 64rem !important;
+  }
+
+  [data-slot="dialog-content"][class~="sm:max-w-190"] {
+    max-width: 47.5rem !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[360px]"] {
+    max-width: 360px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[380px]"] {
+    max-width: 380px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[400px]"] {
+    max-width: 400px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[420px]"] {
+    max-width: 420px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[440px]"] {
+    max-width: 440px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[460px]"] {
+    max-width: 460px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[480px]"] {
+    max-width: 480px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[500px]"] {
+    max-width: 500px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[520px]"] {
+    max-width: 520px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[560px]"] {
+    max-width: 560px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[660px]"] {
+    max-width: 660px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[720px]"] {
+    max-width: 720px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[760px]"] {
+    max-width: 760px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[780px]"] {
+    max-width: 780px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[840px]"] {
+    max-width: 840px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[860px]"] {
+    max-width: 860px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[900px]"] {
+    max-width: 900px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[960px]"] {
+    max-width: 960px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[980px]"] {
+    max-width: 980px !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:max-w-[calc(100vw-2rem)]"] {
+    max-width: calc(100vw - 2rem) !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:!max-w-[92vw]"] {
+    max-width: 92vw !important;
+  }
+
+  [data-slot="dialog-content"][class*="sm:!max-w-[min(920px,calc(100vw-48px))]"] {
+    max-width: min(920px, calc(100vw - 48px)) !important;
+  }
+}
+}
+
+/* Splitpanes */
+.splitpanes--horizontal .splitpanes__pane {
+  transition: none !important;
+}
+.splitpanes--vertical > .splitpanes__splitter {
+  width: 3px !important;
+  border-left: 1px solid var(--border);
+  background: transparent;
+  cursor: col-resize;
+}
+.splitpanes--horizontal > .splitpanes__splitter {
+  height: 3px !important;
+  border-top: 1px solid var(--border);
+  background: transparent;
+  cursor: row-resize;
+}
+.splitpanes__splitter:hover {
+  background: rgb(39 132 213) !important;
+  background: oklch(0.6 0.15 250) !important;
+}
+
+/* Panel resize handles */
+.app-panel-gutter {
+  background: rgb(243 243 243);
+  background: oklch(0.965 0 0);
+}
+.dark .app-panel-gutter {
+  background: rgb(23 23 25);
+  background: oklch(0.205 0.004 285);
+}
+:is(.theme-soft, .theme-graphite, .theme-cobalt, .theme-sage, .theme-amber, .theme-blush, .theme-vscode, .theme-idea, .theme-xcode, .theme-jetbrains, .theme-cursor, .theme-claude) .app-panel-gutter {
+  background: var(--dbx-gutter);
+}
+:is(.theme-soft, .theme-graphite, .theme-cobalt, .theme-sage, .theme-amber, .theme-blush, .theme-vscode, .theme-idea, .theme-xcode, .theme-jetbrains, .theme-cursor, .theme-claude) .app-toolbar,
+:is(.theme-soft, .theme-graphite, .theme-cobalt, .theme-sage, .theme-amber, .theme-blush, .theme-vscode, .theme-idea, .theme-xcode, .theme-jetbrains, .theme-cursor, .theme-claude) .app-tab-bar {
+  border-color: var(--border);
+  background: var(--dbx-chrome);
+}
+:is(.theme-soft, .theme-graphite, .theme-cobalt, .theme-sage, .theme-amber, .theme-blush, .theme-vscode, .theme-idea, .theme-xcode, .theme-jetbrains, .theme-cursor, .theme-claude) .app-sidebar-panel {
+  color: var(--sidebar-foreground);
+  background: var(--sidebar);
+}
+:is(.theme-soft, .theme-graphite, .theme-cobalt, .theme-sage, .theme-amber, .theme-blush, .theme-vscode, .theme-idea, .theme-xcode, .theme-jetbrains, .theme-cursor, .theme-claude) .app-layout-classic > .app-sidebar-panel {
+  border-right: 1px solid var(--sidebar-border);
+}
+:is(.theme-soft, .theme-graphite, .theme-cobalt, .theme-sage, .theme-amber, .theme-blush, .theme-vscode, .theme-idea, .theme-xcode, .theme-jetbrains, .theme-cursor, .theme-claude) .app-sidebar-toolbar,
+:is(.theme-soft, .theme-graphite, .theme-cobalt, .theme-sage, .theme-amber, .theme-blush, .theme-vscode, .theme-idea, .theme-xcode, .theme-jetbrains, .theme-cursor, .theme-claude) .connection-tree-search,
+:is(.theme-soft, .theme-graphite, .theme-cobalt, .theme-sage, .theme-amber, .theme-blush, .theme-vscode, .theme-idea, .theme-xcode, .theme-jetbrains, .theme-cursor, .theme-claude) .sticky-database-header {
+  border-color: var(--sidebar-border);
+  background: var(--dbx-sidebar-header);
+}
+:is(.theme-soft, .theme-graphite, .theme-cobalt, .theme-sage, .theme-amber, .theme-blush, .theme-vscode, .theme-idea, .theme-xcode, .theme-jetbrains, .theme-cursor, .theme-claude) .app-editor-toolbar {
+  border-color: var(--border);
+  background: var(--dbx-editor-toolbar);
+}
+:is(.theme-soft, .theme-graphite, .theme-cobalt, .theme-sage, .theme-amber, .theme-blush, .theme-vscode, .theme-idea, .theme-xcode, .theme-jetbrains, .theme-cursor, .theme-claude) .app-layout-classic > .min-w-0,
+:is(.theme-soft, .theme-graphite, .theme-cobalt, .theme-sage, .theme-amber, .theme-blush, .theme-vscode, .theme-idea, .theme-xcode, .theme-jetbrains, .theme-cursor, .theme-claude) .app-layout-classic > .flex-1 {
+  background: var(--dbx-content);
+}
+.app-layout-classic .panel-resize-handle {
+  width: 3px;
+}
+.app-layout-classic .panel-resize-handle--right {
+  right: 0;
+  border-right: 1px solid var(--border);
+}
+.app-layout-classic .panel-resize-handle--left {
+  left: 0;
+  border-left: 1px solid var(--border);
+}
+.app-layout-classic .panel-resize-handle:hover,
+.app-layout-classic .panel-resize-handle:active {
+  background: rgb(39 132 213);
+  background: oklch(0.6 0.15 250);
+}
+
+.panel-resize-handle {
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  width: 7px;
+  cursor: col-resize;
+  z-index: 10;
+  background: transparent;
+}
+.panel-resize-handle--right {
+  right: -4px;
+}
+.panel-resize-handle--left {
+  left: -4px;
+}
+.panel-resize-handle::before {
+  display: none;
+}
+
+/* Frosted glass menus */
+.cn-menu-translucent {
+  backdrop-filter: blur(8px) saturate(1.6) !important;
+  -webkit-backdrop-filter: blur(8px) saturate(1.6) !important;
+  background-color: rgb(255 255 255 / 0.95) !important;
+  background-color: oklch(1 0 0 / 0.95) !important;
+  box-shadow: none !important;
+  border: 0.5px solid rgb(0 0 0 / 0.12) !important;
+  border: 0.5px solid oklch(0 0 0 / 0.12) !important;
+  --tw-ring-shadow: none !important;
+}
+.dark .cn-menu-translucent {
+  background-color: rgb(23 23 23 / 0.82) !important;
+  background-color: oklch(0.205 0 0 / 0.82) !important;
+  border-color: rgb(255 255 255 / 0.1) !important;
+  border-color: oklch(1 0 0 / 0.1) !important;
+}
+
+[data-slot="context-menu-content"],
+[data-slot="context-menu-sub-content"],
+[data-slot="dropdown-menu-content"],
+[data-slot="dropdown-menu-sub-content"],
+[data-slot="select-content"],
+.cn-menu-translucent {
+  background-color: rgba(255, 255, 255, 0.96) !important;
+  border: 1px solid rgba(0, 0, 0, 0.1) !important;
+  box-shadow: 0 12px 32px rgba(0, 0, 0, 0.12) !important;
+  --tw-ring-color: transparent !important;
+  --tw-ring-shadow: 0 0 transparent !important;
+  --tw-shadow: 0 0 transparent !important;
+}
+
+.dark [data-slot="context-menu-content"],
+.dark [data-slot="context-menu-sub-content"],
+.dark [data-slot="dropdown-menu-content"],
+.dark [data-slot="dropdown-menu-sub-content"],
+.dark [data-slot="select-content"],
+.dark .cn-menu-translucent {
+  background-color: rgba(23, 23, 23, 0.94) !important;
+  border-color: rgba(255, 255, 255, 0.12) !important;
+  box-shadow: 0 12px 32px rgba(0, 0, 0, 0.45) !important;
+}
+
+/* A few compound pickers render their own separate surface cards. */
+[data-slot="select-content"][data-naked-surface],
+.dark [data-slot="select-content"][data-naked-surface] {
+  background: transparent !important;
+  border: 0 !important;
+  box-shadow: none !important;
+  backdrop-filter: none !important;
+  -webkit-backdrop-filter: none !important;
+}
+
+[data-slot="context-menu-item"]:hover,
+[data-slot="context-menu-item"]:focus,
+[data-slot="context-menu-item"][data-highlighted],
+[data-slot="context-menu-checkbox-item"]:hover,
+[data-slot="context-menu-checkbox-item"]:focus,
+[data-slot="context-menu-checkbox-item"][data-highlighted],
+[data-slot="context-menu-radio-item"]:hover,
+[data-slot="context-menu-radio-item"]:focus,
+[data-slot="context-menu-radio-item"][data-highlighted],
+[data-slot="context-menu-sub-trigger"]:hover,
+[data-slot="context-menu-sub-trigger"]:focus,
+[data-slot="context-menu-sub-trigger"][data-highlighted],
+[data-slot="context-menu-sub-trigger"][data-state="open"],
+[data-slot="context-menu-sub-trigger"][data-open],
+[data-slot="dropdown-menu-item"]:hover,
+[data-slot="dropdown-menu-item"]:focus,
+[data-slot="dropdown-menu-item"][data-highlighted],
+[data-slot="dropdown-menu-checkbox-item"]:hover,
+[data-slot="dropdown-menu-checkbox-item"]:focus,
+[data-slot="dropdown-menu-checkbox-item"][data-highlighted],
+[data-slot="dropdown-menu-radio-item"]:hover,
+[data-slot="dropdown-menu-radio-item"]:focus,
+[data-slot="dropdown-menu-radio-item"][data-highlighted],
+[data-slot="dropdown-menu-sub-trigger"]:hover,
+[data-slot="dropdown-menu-sub-trigger"]:focus,
+[data-slot="dropdown-menu-sub-trigger"][data-highlighted],
+[data-slot="dropdown-menu-sub-trigger"][data-state="open"],
+[data-slot="dropdown-menu-sub-trigger"][data-open],
+[data-slot="select-item"]:hover,
+[data-slot="select-item"]:focus,
+[data-slot="select-item"][data-highlighted],
+[role="menuitem"]:hover,
+[role="menuitem"]:focus {
+  background-color: rgba(23, 23, 23, 0.08) !important;
+  color: rgb(23, 23, 23) !important;
+}
+
+[data-slot="context-menu-item"]:hover svg,
+[data-slot="context-menu-item"]:focus svg,
+[data-slot="context-menu-item"][data-highlighted] svg,
+[data-slot="context-menu-checkbox-item"]:hover svg,
+[data-slot="context-menu-checkbox-item"]:focus svg,
+[data-slot="context-menu-checkbox-item"][data-highlighted] svg,
+[data-slot="context-menu-radio-item"]:hover svg,
+[data-slot="context-menu-radio-item"]:focus svg,
+[data-slot="context-menu-radio-item"][data-highlighted] svg,
+[data-slot="context-menu-sub-trigger"]:hover svg,
+[data-slot="context-menu-sub-trigger"]:focus svg,
+[data-slot="context-menu-sub-trigger"][data-highlighted] svg,
+[data-slot="context-menu-sub-trigger"][data-state="open"] svg,
+[data-slot="context-menu-sub-trigger"][data-open] svg,
+[data-slot="dropdown-menu-item"]:hover svg,
+[data-slot="dropdown-menu-item"]:focus svg,
+[data-slot="dropdown-menu-item"][data-highlighted] svg,
+[data-slot="dropdown-menu-checkbox-item"]:hover svg,
+[data-slot="dropdown-menu-checkbox-item"]:focus svg,
+[data-slot="dropdown-menu-checkbox-item"][data-highlighted] svg,
+[data-slot="dropdown-menu-radio-item"]:hover svg,
+[data-slot="dropdown-menu-radio-item"]:focus svg,
+[data-slot="dropdown-menu-radio-item"][data-highlighted] svg,
+[data-slot="dropdown-menu-sub-trigger"]:hover svg,
+[data-slot="dropdown-menu-sub-trigger"]:focus svg,
+[data-slot="dropdown-menu-sub-trigger"][data-highlighted] svg,
+[data-slot="dropdown-menu-sub-trigger"][data-state="open"] svg,
+[data-slot="dropdown-menu-sub-trigger"][data-open] svg,
+[data-slot="select-item"]:hover svg,
+[data-slot="select-item"]:focus svg,
+[data-slot="select-item"][data-highlighted] svg,
+[role="menuitem"]:hover svg,
+[role="menuitem"]:focus svg {
+  color: currentColor !important;
+}
+
+[data-slot="context-menu-item"][data-variant="destructive"]:hover,
+[data-slot="context-menu-item"][data-variant="destructive"]:focus,
+[data-slot="context-menu-item"][data-variant="destructive"][data-highlighted],
+[data-slot="dropdown-menu-item"][data-variant="destructive"]:hover,
+[data-slot="dropdown-menu-item"][data-variant="destructive"]:focus,
+[data-slot="dropdown-menu-item"][data-variant="destructive"][data-highlighted] {
+  background-color: rgba(var(--destructive-rgb), 0.1) !important;
+  color: rgb(var(--destructive-rgb)) !important;
+}
+
+.dark [data-slot="context-menu-item"]:hover,
+.dark [data-slot="context-menu-item"]:focus,
+.dark [data-slot="context-menu-item"][data-highlighted],
+.dark [data-slot="context-menu-checkbox-item"]:hover,
+.dark [data-slot="context-menu-checkbox-item"]:focus,
+.dark [data-slot="context-menu-checkbox-item"][data-highlighted],
+.dark [data-slot="context-menu-radio-item"]:hover,
+.dark [data-slot="context-menu-radio-item"]:focus,
+.dark [data-slot="context-menu-radio-item"][data-highlighted],
+.dark [data-slot="context-menu-sub-trigger"]:hover,
+.dark [data-slot="context-menu-sub-trigger"]:focus,
+.dark [data-slot="context-menu-sub-trigger"][data-highlighted],
+.dark [data-slot="context-menu-sub-trigger"][data-state="open"],
+.dark [data-slot="context-menu-sub-trigger"][data-open],
+.dark [data-slot="dropdown-menu-item"]:hover,
+.dark [data-slot="dropdown-menu-item"]:focus,
+.dark [data-slot="dropdown-menu-item"][data-highlighted],
+.dark [data-slot="dropdown-menu-checkbox-item"]:hover,
+.dark [data-slot="dropdown-menu-checkbox-item"]:focus,
+.dark [data-slot="dropdown-menu-checkbox-item"][data-highlighted],
+.dark [data-slot="dropdown-menu-radio-item"]:hover,
+.dark [data-slot="dropdown-menu-radio-item"]:focus,
+.dark [data-slot="dropdown-menu-radio-item"][data-highlighted],
+.dark [data-slot="dropdown-menu-sub-trigger"]:hover,
+.dark [data-slot="dropdown-menu-sub-trigger"]:focus,
+.dark [data-slot="dropdown-menu-sub-trigger"][data-highlighted],
+.dark [data-slot="dropdown-menu-sub-trigger"][data-state="open"],
+.dark [data-slot="dropdown-menu-sub-trigger"][data-open],
+.dark [data-slot="select-item"]:hover,
+.dark [data-slot="select-item"]:focus,
+.dark [data-slot="select-item"][data-highlighted],
+.dark [role="menuitem"]:hover,
+.dark [role="menuitem"]:focus {
+  background-color: rgba(255, 255, 255, 0.12) !important;
+  color: rgb(245, 245, 245) !important;
+}
+
+/* Tailwind 4 falls back from bg-destructive/<alpha> to solid --destructive
+   when color-mix() is unavailable in older WebKit. Keep dangerous-action
+   surfaces translucent so red text/icons remain legible on macOS 12 WebView. */
+.bg-destructive\/5 {
+  background-color: rgba(var(--destructive-rgb), 0.05);
+}
+.bg-destructive\/10,
+.hover\:bg-destructive\/10:hover,
+.focus\:bg-destructive\/10:focus,
+.focus-visible\:bg-destructive\/10:focus-visible,
+.data-\[variant\=destructive\]\:focus\:bg-destructive\/10[data-variant="destructive"]:focus {
+  background-color: rgba(var(--destructive-rgb), 0.1);
+}
+.bg-destructive\/15,
+.hover\:bg-destructive\/15:hover {
+  background-color: rgba(var(--destructive-rgb), 0.15);
+}
+.bg-destructive\/20,
+.\[a\]\:hover\:bg-destructive\/20:is(a):hover,
+.hover\:bg-destructive\/20:hover,
+.dark\:bg-destructive\/20:is(.dark *),
+.dark\:focus\:bg-destructive\/20:is(.dark *):focus,
+.dark\:hover\:bg-destructive\/20:is(.dark *):hover,
+.dark\:data-\[variant\=destructive\]\:focus\:bg-destructive\/20:is(.dark *)[data-variant="destructive"]:focus {
+  background-color: rgba(var(--destructive-rgb), 0.2);
+}
+.bg-destructive\/30,
+.dark\:hover\:bg-destructive\/30:is(.dark *):hover {
+  background-color: rgba(var(--destructive-rgb), 0.3);
+}
+
+@supports (background-color: color-mix(in oklab, red 10%, transparent)) {
+  .bg-destructive\/5 {
+    background-color: color-mix(in oklab, var(--destructive) 5%, transparent);
+  }
+  .bg-destructive\/10,
+  .hover\:bg-destructive\/10:hover,
+  .focus\:bg-destructive\/10:focus,
+  .focus-visible\:bg-destructive\/10:focus-visible,
+  .data-\[variant\=destructive\]\:focus\:bg-destructive\/10[data-variant="destructive"]:focus {
+    background-color: color-mix(in oklab, var(--destructive) 10%, transparent);
+  }
+  .bg-destructive\/15,
+  .hover\:bg-destructive\/15:hover {
+    background-color: color-mix(in oklab, var(--destructive) 15%, transparent);
+  }
+  .bg-destructive\/20,
+  .\[a\]\:hover\:bg-destructive\/20:is(a):hover,
+  .hover\:bg-destructive\/20:hover,
+  .dark\:bg-destructive\/20:is(.dark *),
+  .dark\:focus\:bg-destructive\/20:is(.dark *):focus,
+  .dark\:hover\:bg-destructive\/20:is(.dark *):hover,
+  .dark\:data-\[variant\=destructive\]\:focus\:bg-destructive\/20:is(.dark *)[data-variant="destructive"]:focus {
+    background-color: color-mix(in oklab, var(--destructive) 20%, transparent);
+  }
+  .bg-destructive\/30,
+  .dark\:hover\:bg-destructive\/30:is(.dark *):hover {
+    background-color: color-mix(in oklab, var(--destructive) 30%, transparent);
+  }
+}
diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.ts
new file mode 100644
index 0000000..324aee3
--- /dev/null
+++ b/apps/desktop/src/types/database.ts
@@ -0,0 +1,904 @@
+export type DatabaseType =
+  | "mysql"
+  | "postgres"
+  | "sqlite"
+  | "rqlite"
+  | "turso"
+  | "cloudflare-d1"
+  | "redis"
+  | "duckdb"
+  | "clickhouse"
+  | "sqlserver"
+  | "mongodb"
+  | "oracle"
+  | "elasticsearch"
+  | "qdrant"
+  | "milvus"
+  | "weaviate"
+  | "chromadb"
+  | "doris"
+  | "starrocks"
+  | "manticoresearch"
+  | "databend"
+  | "redshift"
+  | "dameng"
+  | "gaussdb"
+  | "kingbase"
+  | "highgo"
+  | "vastbase"
+  | "goldendb"
+  | "kwdb"
+  | "yashandb"
+  | "databricks"
+  | "saphana"
+  | "teradata"
+  | "vertica"
+  | "firebird"
+  | "exasol"
+  | "opengauss"
+  | "oceanbase-oracle"
+  | "questdb"
+  | "gbase"
+  | "access"
+  | "h2"
+  | "snowflake"
+  | "trino"
+  | "prestosql"
+  | "hive"
+  | "spark"
+  | "db2"
+  | "informix"
+  | "neo4j"
+  | "cassandra"
+  | "bigquery"
+  | "kylin"
+  | "sundb"
+  | "oscar"
+  | "tdengine"
+  | "xugu"
+  | "iotdb"
+  | "etcd"
+  | "zookeeper"
+  | "iris"
+  | "influxdb"
+  | "jdbc"
+  | "mq"
+  | "nacos";
+
+export interface SqlSnippet {
+  id: string;
+  label: string;
+  prefix: string;
+  body: string;
+  enabled?: boolean;
+}
+
+export type CompletionAssistantObjectKind = "database" | "schema" | "table" | "view" | "routine" | "procedure" | "function" | "column";
+
+export type CompletionAssistantCandidateKind = "database" | "schema" | "table" | "view" | "procedure" | "function" | "column" | "object";
+
+export type CompletionAssistantMatchMode = "prefix" | "contains";
+
+export interface CompletionAssistantRequest {
+  connection_id: string;
+  database: string;
+  schema?: string | null;
+  object_kinds?: CompletionAssistantObjectKind[];
+  mask?: string;
+  case_sensitive?: boolean;
+  global_search?: boolean;
+  max_results?: number | null;
+  search_in_comments?: boolean;
+  search_in_definitions?: boolean;
+  parent_schema?: string | null;
+  parent_name?: string | null;
+  match_mode?: CompletionAssistantMatchMode | null;
+}
+
+export interface CompletionAssistantCandidate {
+  name: string;
+  kind: CompletionAssistantCandidateKind;
+  database?: string | null;
+  schema?: string | null;
+  parent_schema?: string | null;
+  parent_name?: string | null;
+  comment?: string | null;
+  data_type?: string | null;
+}
+
+export interface CompletionAssistantResponse {
+  candidates: CompletionAssistantCandidate[];
+  incomplete: boolean;
+  fallback_used: boolean;
+}
+
+export interface ConnectionConfig {
+  id: string;
+  name: string;
+  db_type: DatabaseType;
+  driver_profile?: string;
+  driver_label?: string;
+  url_params?: string;
+  agent_java_options?: string[];
+  host: string;
+  port: number;
+  username: string;
+  password: string;
+  database?: string;
+  visible_databases?: string[];
+  visible_schemas?: Record<string, string[]>;
+  attached_databases?: AttachedDatabaseConfig[];
+  color?: string;
+  transport_layers?: TransportLayerConfig[];
+  connect_timeout_secs?: number;
+  query_timeout_secs?: number;
+  idle_timeout_secs?: number;
+  keepalive_interval_secs?: number;
+  ssl?: boolean;
+  ca_cert_path?: string;
+  client_cert_path?: string;
+  client_key_path?: string;
+  sysdba?: boolean;
+  oracle_connection_type?: "service_name" | "sid";
+  connection_string?: string;
+  jdbc_driver_class?: string;
+  jdbc_driver_paths?: string[];
+  redis_connection_mode?: "standalone" | "sentinel" | "cluster";
+  redis_sentinel_master?: string;
+  redis_sentinel_nodes?: string;
+  redis_sentinel_username?: string;
+  redis_sentinel_password?: string;
+  redis_sentinel_tls?: boolean;
+  redis_cluster_nodes?: string;
+  redis_key_separator?: string;
+  redis_scan_page_size?: number;
+  etcd_endpoints?: string;
+  gbase_server?: string;
+  informix_server?: string;
+  external_config?: unknown;
+  one_time?: boolean;
+  read_only?: boolean;
+  /** Explicit production marker for every database reachable through this connection. */
+  is_production?: boolean;
+  /** Database-level production markers for multi-database connections. */
+  production_databases?: string[];
+}
+
+export type TransportLayerConfig = ({ type: "ssh" } & SshTunnelConfig) | ({ type: "proxy" } & ProxyTunnelConfig) | ({ type: "http_tunnel" } & HttpTunnelConfig);
+
+/**
+ * A shared tunnel configuration managed in Settings > Tunnels. Structurally a
+ * `TransportLayerConfig`; its `id` is what connection layers reference via
+ * `profile_id`. Edits to a profile apply to every referencing connection the
+ * next time it connects.
+ */
+export type TunnelProfile = TransportLayerConfig;
+
+export interface SshTunnelConfig {
+  id: string;
+  name?: string;
+  enabled?: boolean;
+  host: string;
+  port: number;
+  user: string;
+  password?: string;
+  key_path?: string;
+  key_passphrase?: string;
+  connect_timeout_secs?: number;
+  expose_lan?: boolean;
+  use_ssh_agent?: boolean;
+  ssh_agent_sock_path?: string;
+  /**
+   * UI-facing choice of login method. Drives which credential inputs the
+   * connection dialog shows; the backend still probes "none" then falls
+   * back to key > password > agent based on which fields are non-empty,
+   * independent of this selector (see `db/ssh_tunnel.rs`).
+   *
+   * `"agent"` is a legacy value: it's no longer offered as a dropdown
+   * choice for new connections, but is preserved and displayed read-only
+   * for connections that already have `use_ssh_agent` configured.
+   */
+  auth_method?: "password" | "key" | "agent" | "none";
+  /**
+   * When set, this layer references a shared tunnel profile; the profile's
+   * configuration replaces this layer's fields at connect time (only `id`
+   * and `enabled` are kept).
+   */
+  profile_id?: string;
+}
+
+export interface SshConfigHostEntry {
+  alias: string;
+  host_name?: string;
+  port?: number;
+  user?: string;
+  identity_file?: string;
+}
+
+export interface ProxyTunnelConfig {
+  id: string;
+  name?: string;
+  enabled?: boolean;
+  proxy_type?: "socks5" | "http";
+  host: string;
+  port: number;
+  username?: string;
+  password?: string;
+  /** See {@link SshTunnelConfig.profile_id}. */
+  profile_id?: string;
+}
+
+export interface HttpTunnelConfig {
+  id: string;
+  name?: string;
+  enabled?: boolean;
+  url: string;
+  token?: string;
+  connect_timeout_secs?: number;
+  /** See {@link SshTunnelConfig.profile_id}. */
+  profile_id?: string;
+}
+
+export interface AttachedDatabaseConfig {
+  name: string;
+  path: string;
+}
+
+export interface PluginDriverManifest {
+  id: string;
+  label: string;
+  kind: string;
+  database_type?: string;
+}
+
+export interface PluginManifest {
+  id: string;
+  name: string;
+  version?: string;
+  protocol_version?: number;
+  description?: string;
+  executable?: string;
+  drivers: PluginDriverManifest[];
+}
+
+export interface InstalledPlugin {
+  manifest: PluginManifest;
+  path: string;
+}
+
+export interface JdbcDriverInfo {
+  name: string;
+  path: string;
+  size: number;
+  bundle_id?: string | null;
+}
+
+export interface JdbcMavenArtifactInfo {
+  group_id: string;
+  artifact_id: string;
+  version: string;
+  classifier: string;
+  extension: string;
+  file_name: string;
+  path: string;
+  size: number;
+  sha256: string;
+}
+
+export interface JdbcMavenBundleInfo {
+  id: string;
+  coordinate: string;
+  scope: string;
+  repositories: string[];
+  installed_at: string;
+  path: string;
+  artifacts: JdbcMavenArtifactInfo[];
+}
+
+export interface JdbcLocalArtifactInfo {
+  file_name: string;
+  path: string;
+  size: number;
+  sha256: string;
+}
+
+export interface JdbcLocalBundleInfo {
+  id: string;
+  name: string;
+  installed_at: string;
+  path: string;
+  artifacts: JdbcLocalArtifactInfo[];
+}
+
+export interface JdbcPluginStatus {
+  installed: boolean;
+  version?: string | null;
+  protocol_version?: number | null;
+  compatible: boolean;
+  latest_version?: string | null;
+  latest_protocol_version?: number | null;
+  update_available: boolean;
+  path: string;
+}
+
+export interface DatabaseInfo {
+  name: string;
+}
+
+export interface SchemaInfo {
+  name: string;
+  comment?: string | null;
+}
+
+export interface LinkedServerInfo {
+  name: string;
+  product?: string | null;
+  provider?: string | null;
+  data_source?: string | null;
+}
+
+/** A catalog exposed by a multi-catalog engine (Doris / StarRocks). */
+export interface CatalogInfo {
+  name: string;
+  catalog_type: string;
+  is_current: boolean;
+  comment?: string | null;
+}
+
+export interface TableInfo {
+  name: string;
+  table_type: string;
+  comment?: string | null;
+  parent_schema?: string | null;
+  parent_name?: string | null;
+}
+
+export type DatabaseObjectType = "TABLE" | "VIEW" | "MATERIALIZED_VIEW" | "PROCEDURE" | "FUNCTION" | "SEQUENCE" | "PACKAGE" | "PACKAGE_BODY";
+
+export interface ObjectInfo {
+  name: string;
+  object_type: DatabaseObjectType | string;
+  schema?: string | null;
+  signature?: string | null;
+  comment?: string | null;
+  created_at?: string | null;
+  updated_at?: string | null;
+  parent_schema?: string | null;
+  parent_name?: string | null;
+}
+
+export interface ObjectStatistics {
+  name: string;
+  schema?: string | null;
+  estimated_rows?: number | null;
+  total_bytes?: number | null;
+}
+
+export type ObjectSourceKind = "VIEW" | "MATERIALIZED_VIEW" | "PROCEDURE" | "FUNCTION" | "SEQUENCE" | "PACKAGE" | "PACKAGE_BODY";
+
+export interface ObjectSource {
+  name: string;
+  object_type: ObjectSourceKind;
+  schema?: string | null;
+  source: string;
+  editable?: boolean;
+}
+
+export interface ColumnInfo {
+  name: string;
+  data_type: string;
+  is_nullable: boolean;
+  column_default: string | null;
+  is_primary_key: boolean;
+  extra: string | null;
+  comment?: string | null;
+  numeric_precision?: number | null;
+  numeric_scale?: number | null;
+  character_maximum_length?: number | null;
+  enum_values?: string[] | null;
+  character_set?: string | null;
+  collation?: string | null;
+}
+
+export interface IndexInfo {
+  name: string;
+  columns: string[];
+  is_unique: boolean;
+  is_primary: boolean;
+  filter?: string | null;
+  index_type?: string | null;
+  included_columns?: string[] | null;
+  comment?: string | null;
+}
+
+export interface ForeignKeyInfo {
+  name: string;
+  column: string;
+  ref_schema?: string | null;
+  ref_table: string;
+  ref_column: string;
+  on_update?: string | null;
+  on_delete?: string | null;
+}
+
+export interface TriggerInfo {
+  name: string;
+  event: string;
+  timing: string;
+  statement?: string | null;
+}
+
+export interface FunctionInfo {
+  name: string;
+  function_type: string;
+  data_type: string;
+  definition: string;
+  arguments: string;
+}
+
+export interface SequenceInfo {
+  name: string;
+  data_type: string;
+  start_value: string;
+  min_value: string;
+  max_value: string;
+  increment: string;
+  cycle: boolean;
+  last_value?: string | null;
+}
+
+export interface RuleInfo {
+  name: string;
+  table_name: string;
+  definition: string;
+}
+
+export interface ExtensionInfo {
+  name: string;
+  version: string;
+  comment?: string | null;
+  schema?: string | null;
+}
+
+export interface OwnerInfo {
+  object_name: string;
+  object_type: string;
+  owner: string;
+}
+
+export interface QueryResult {
+  columns: string[];
+  /** Set for synthesized query execution failures. */
+  execution_error?: true;
+  /** Internal row identifiers appended to editable query results. */
+  hidden_column_indexes?: number[];
+  /**
+   * Database type name for each column, parallel to `columns`. Optional and may
+   * be shorter/empty when a driver cannot supply types (schemaless stores,
+   * fallback query paths, older backends). Consumers must tolerate gaps.
+   */
+  column_types?: string[];
+  /**
+   * Sortable for each column. Parallel to `columns`. Optional and may
+   * be shorter/empty when a driver cannot supply sortable information.
+   */
+  column_sortables?: boolean[];
+  rows: (string | number | boolean | null)[][];
+  /**
+   * Original MongoDB documents, kept in lockstep with `rows` for document
+   * preview. This is populated only for MongoDB document query results.
+   */
+  mongo_documents?: unknown[];
+  affected_rows: number;
+  execution_time_ms: number;
+  truncated?: boolean;
+  session_id?: string | null;
+  has_more?: boolean;
+  sourceLabel?: string;
+  sourceStatement?: string;
+}
+
+export interface QueryResultRun {
+  id: string;
+  title: string;
+  sequence: number;
+  sql: string;
+  createdAt: number;
+  result?: QueryResult;
+  results?: QueryResult[];
+  activeResultIndex?: number;
+  resultBaseSql?: string;
+  resultSortedSql?: string;
+  resultSortColumn?: string;
+  resultSortColumnIndex?: number;
+  resultSortDirection?: "asc" | "desc";
+  resultSortMode?: "database" | "local";
+  resultLocalSortOriginalRows?: QueryResult["rows"];
+  resultLocalSortOriginalMongoDocuments?: QueryResult["mongo_documents"];
+  orderByInput?: string;
+  resultPageSql?: string;
+  resultPageLimit?: number;
+  resultPageOffset?: number;
+  resultCountSql?: string;
+  resultTotalRowCount?: number;
+  resultTotalRowCountLoading?: boolean;
+  resultSessionId?: string;
+  resultAccessedAt?: number;
+  resultCacheKey?: string;
+  resultCacheState?: "memory" | "disk" | "missing";
+  resultEvicted?: boolean;
+  queryAnalysis?: QueryTab["queryAnalysis"];
+  querySourceColumns?: QueryTab["querySourceColumns"];
+  queryEditabilityReason?: QueryTab["queryEditabilityReason"];
+  mongoEditTarget?: QueryTab["mongoEditTarget"];
+  tableMeta?: QueryTab["tableMeta"];
+}
+
+export interface SqlTextSpan {
+  start_line: number;
+  start_column: number;
+  end_line: number;
+  end_column: number;
+}
+
+export interface SqlTableReference {
+  name: string;
+  schema?: string | null;
+  alias?: string | null;
+  span: SqlTextSpan;
+  scope_id?: number;
+}
+
+export interface SqlColumnReference {
+  name: string;
+  qualifier?: string | null;
+  span: SqlTextSpan;
+  scope_id?: number;
+}
+
+export interface SqlReferenceScope {
+  id: number;
+  parent_id?: number | null;
+}
+
+export interface SqlReferenceAnalysis {
+  tables: SqlTableReference[];
+  columns: SqlColumnReference[];
+  scopes?: SqlReferenceScope[];
+}
+
+export type TreeNodeType =
+  | "connection"
+  | "connection-group"
+  | "database"
+  | "doris-catalog"
+  | "linked-server-root"
+  | "linked-server"
+  | "linked-server-catalog"
+  | "linked-server-schema"
+  | "schema"
+  | "table"
+  | "view"
+  | "materialized_view"
+  | "procedure"
+  | "function"
+  | "sequence"
+  | "package"
+  | "package-body"
+  | "group-columns"
+  | "group-indexes"
+  | "group-fkeys"
+  | "group-triggers"
+  | "group-tables"
+  | "group-views"
+  | "group-materialized-views"
+  | "group-procedures"
+  | "group-functions"
+  | "group-sequences"
+  | "group-packages"
+  | "group-partitions"
+  | "group-extensions"
+  | "extension"
+  | "object-browser"
+  | "user-admin"
+  | "dameng-job-admin"
+  | "saved-sql-root"
+  | "saved-sql-folder"
+  | "saved-sql-file"
+  | "table-search-control"
+  | "load-more"
+  | "column"
+  | "index"
+  | "fkey"
+  | "trigger"
+  | "redis-db"
+  | "mq-tenant"
+  | "nacos-namespace"
+  | "etcd-root"
+  | "zookeeper-root"
+  | "mongo-db"
+  | "mongo-gridfs"
+  | "mongo-buckets"
+  | "mongo-bucket"
+  | "mongo-collection"
+  | "vector-database"
+  | "vector-collection"
+  | "elasticsearch-index";
+
+export interface ConnectionGroup {
+  id: string;
+  name: string;
+  collapsed: boolean;
+}
+
+export type SidebarOrderEntry = { type: "group"; id: string; children?: SidebarOrderEntry[]; connectionIds?: string[] } | { type: "connection"; id: string };
+
+export interface SidebarLayout {
+  groups: ConnectionGroup[];
+  order: SidebarOrderEntry[];
+}
+
+export interface TreeNode {
+  id: string;
+  label: string;
+  type: TreeNodeType;
+  children?: TreeNode[];
+  isLoading?: boolean;
+  isExpanded?: boolean;
+  pinned?: boolean;
+  connectionId?: string;
+  database?: string;
+  catalog?: string;
+  catalogType?: string;
+  linkedServer?: string;
+  linkedCatalog?: string;
+  linkedSchema?: string;
+  mqTenant?: string;
+  mqInitialTab?: "topics";
+  nacosNamespace?: string;
+  nacosNamespaceName?: string;
+  schema?: string;
+  tableName?: string;
+  objectName?: string;
+  signature?: string;
+  tableType?: string;
+  comment?: string | null;
+  objectCount?: number;
+  loadedKeyCount?: number;
+  totalKeyCount?: number;
+  partitionParentSchema?: string;
+  partitionParentName?: string;
+  hiddenChildren?: TreeNode[];
+  tableSearchParentId?: string;
+  savedSqlId?: string;
+  savedSqlFolderId?: string;
+  meta?: ColumnInfo | IndexInfo | ForeignKeyInfo | TriggerInfo | ExtensionInfo | VectorCollectionMeta;
+  loadMore?: {
+    parentId: string;
+    offset: number;
+    pageSize: number;
+  };
+}
+
+export type TableInfoTab = "columns" | "indexes" | "foreignKeys" | "triggers" | "ddl";
+
+export interface TableStructureEditorTarget {
+  kind: "column" | "index";
+  name: string;
+}
+
+export interface TableStructureEditorDraft {
+  activeTab: TableInfoTab;
+  newTableName: string;
+  tableComment: string;
+  originalTableComment: string;
+  columns: import("@/lib/table/tableStructureEditorSql").EditableStructureColumn[];
+  indexes: import("@/lib/table/tableStructureEditorSql").EditableStructureIndex[];
+  foreignKeys: import("@/lib/table/tableStructureEditorSql").EditableStructureForeignKey[];
+  triggers: import("@/lib/table/tableStructureEditorSql").EditableStructureTrigger[];
+  scrollPositions?: Partial<Record<TableInfoTab, TableStructureEditorViewport>>;
+  initialized: boolean;
+}
+
+export interface TableStructureEditorViewport {
+  scrollTop: number;
+  scrollLeft: number;
+}
+
+export type ObjectBrowserViewMode = "list" | "grid";
+
+export interface ObjectBrowserViewport {
+  scrollTop: number;
+  viewMode: ObjectBrowserViewMode;
+}
+
+export interface QueryTab {
+  id: string;
+  title: string;
+  customTitle?: boolean;
+  connectionId: string;
+  database: string;
+  schema?: string;
+  sql: string;
+  savedSqlId?: string;
+  externalSqlPath?: string;
+  originalSql?: string;
+  lastExecutedSql?: string;
+  resultBaseSql?: string;
+  resultSortedSql?: string;
+  resultSortColumn?: string;
+  resultSortColumnIndex?: number;
+  resultSortDirection?: "asc" | "desc";
+  resultSortMode?: "database" | "local";
+  resultLocalSortOriginalRows?: QueryResult["rows"];
+  resultLocalSortOriginalMongoDocuments?: QueryResult["mongo_documents"];
+  orderByInput?: string;
+  resultPageSql?: string;
+  resultPageLimit?: number;
+  resultPageOffset?: number;
+  resultCountSql?: string;
+  resultTotalRowCount?: number;
+  resultTotalRowCountLoading?: boolean;
+  resultSessionId?: string;
+  resultAccessedAt?: number;
+  resultCacheKey?: string;
+  resultCacheState?: "memory" | "disk" | "missing";
+  pinned?: boolean;
+  result?: QueryResult;
+  results?: QueryResult[];
+  activeResultIndex?: number;
+  resultRuns?: QueryResultRun[];
+  activeResultRunId?: string;
+  resultAutoSave?: boolean;
+  explainPlan?: import("@/lib/diagram/explainPlan").ParsedExplainPlan;
+  /** MySQL's regular EXPLAIN result, kept alongside its JSON visual plan. */
+  explainTableResult?: QueryResult;
+  explainError?: string;
+  explainTableError?: string;
+  explainSql?: string;
+  explainTableSql?: string;
+  lastExplainedSql?: string;
+  isExecuting: boolean;
+  isCancelling?: boolean;
+  queryExecutionStartedAt?: number;
+  editorViewport?: {
+    scrollTop: number;
+    scrollLeft: number;
+  };
+  editorSelection?: {
+    anchor: number;
+    head: number;
+  };
+  executionId?: string;
+  isExplaining?: boolean;
+  explainExecutionId?: string;
+  /** Per-run connection session for sequential MySQL explain formats. */
+  explainClientSessionId?: string;
+  mode: "data" | "query" | "redis" | "redis-dashboard" | "mongo" | "mongo-gridfs" | "mongo-bucket" | "vector" | "etcd" | "zookeeper" | "mq" | "nacos" | "objects" | "structure" | "users" | "dameng-jobs";
+  mqTenant?: string;
+  mqInitialTab?: "topics";
+  nacosNamespace?: string;
+  nacosNamespaceName?: string;
+  structureTableName?: string;
+  structureInitialTab?: TableInfoTab;
+  structureInitialTabRequestId?: number;
+  structureInitialTarget?: TableStructureEditorTarget;
+  structureDraft?: TableStructureEditorDraft;
+  objectBrowser?: {
+    catalog?: string;
+    schema?: string;
+    objectType?: "tables";
+    viewport?: ObjectBrowserViewport;
+  };
+  objectSource?: {
+    schema?: string;
+    name: string;
+    objectType: ObjectSourceKind;
+  };
+  tableMeta?: {
+    schema?: string;
+    tableName: string;
+    tableType?: string;
+    catalog?: string;
+    columns: ColumnInfo[];
+    primaryKeys: string[];
+  };
+  tableMetaUpdatedAt?: number;
+  tableInfoTab?: TableInfoTab;
+  queryAnalysis?: {
+    catalog?: string;
+    catalogQuoted?: boolean;
+    schema?: string;
+    schemaQuoted?: boolean;
+    tableName: string;
+    tableNameQuoted?: boolean;
+    tableAlias?: string;
+    selectStar: boolean;
+    editableSourceKey?: string;
+    multiSource?: boolean;
+    allowInsert?: boolean;
+    allowInsertDelete?: boolean;
+    sources?: {
+      key: string;
+      catalog?: string;
+      catalogQuoted?: boolean;
+      schema?: string;
+      schemaQuoted?: boolean;
+      tableName: string;
+      tableNameQuoted?: boolean;
+      alias?: string;
+    }[];
+    columns: {
+      sourceName?: string;
+      sourceNameQuoted?: boolean;
+      sourceQualifier?: string;
+      sourceKey?: string;
+      star?: boolean;
+      resultName: string;
+      expression: string;
+    }[];
+  };
+  querySourceColumns?: Array<string | undefined>;
+  queryEditabilityReason?: "not-select" | "cte" | "set-operation" | "aggregation" | "external-source" | "complex-source" | "computed-columns" | "no-table" | "no-primary-key" | "primary-key-not-returned" | "aliased-columns" | "metadata-unavailable";
+  mongoEditTarget?: {
+    collection: string;
+    idColumn: "_id";
+  };
+  mongoBucket?: {
+    bucketName: string;
+  };
+  resultEvicted?: boolean;
+  whereInput?: string;
+  previewSql?: string;
+  /** Whether to use auto-commit mode (default true). When false, multiple statements are
+   *  wrapped in a single transaction. */
+  autoCommit?: boolean;
+  /** Session ID for an active manual transaction, set after beginManualTransaction */
+  txnSessionId?: string;
+  /** Set to true when a manual transaction was auto-rolled back due to inactivity */
+  txnAutoRolledBack?: boolean;
+}
+
+export interface SavedSqlFolder {
+  id: string;
+  connectionId: string;
+  parentFolderId?: string;
+  name: string;
+  orderIndex?: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SavedSqlFile {
+  id: string;
+  connectionId: string;
+  folderId?: string;
+  name: string;
+  database: string;
+  schema?: string;
+  sql: string;
+  sqlLoaded?: boolean;
+  orderIndex?: number;
+  openCount?: number;
+  openedAt?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface SavedSqlLibrary {
+  folders: SavedSqlFolder[];
+  files: SavedSqlFile[];
+}
+
+export interface VectorCollectionMeta {
+  dimension?: number;
+  collectionId?: string;
+}
+
+export interface CollectionInfo {
+  name: string;
+  id: string;
+  dimension?: number;
+  kind?: "collection" | "bucket";
+  bucketName?: string;
+}
diff --git a/apps/desktop/src/types/editor.ts b/apps/desktop/src/types/editor.ts
new file mode 100644
index 0000000..3dbcc4a
--- /dev/null
+++ b/apps/desktop/src/types/editor.ts
@@ -0,0 +1,11 @@
+export type EditNodeKind = "object" | "array" | "value";
+
+export interface EditNode {
+  key: string;
+  keyName: string;
+  kind: EditNodeKind;
+  valueText: string;
+  readonlyKey: boolean;
+  readonlyValue: boolean;
+  children: EditNode[];
+}
diff --git a/apps/desktop/src/types/influxdb.ts b/apps/desktop/src/types/influxdb.ts
new file mode 100644
index 0000000..187580d
--- /dev/null
+++ b/apps/desktop/src/types/influxdb.ts
@@ -0,0 +1,6 @@
+export type InfluxDbVersion = "1" | "2";
+
+export interface InfluxDbExternalConfig {
+  version?: InfluxDbVersion;
+  org?: string;
+}
diff --git a/apps/desktop/src/types/mq.ts b/apps/desktop/src/types/mq.ts
new file mode 100644
index 0000000..08a20ba
--- /dev/null
+++ b/apps/desktop/src/types/mq.ts
@@ -0,0 +1,290 @@
+// Message queue admin types, matching dbx-core/src/mq/types.rs
+
+export type MqSystemKind = "pulsar" | "kafka" | "rocketmq";
+
+export interface MqCapabilities {
+  supportsTenants: boolean;
+  supportsNamespaces: boolean;
+  supportsPartitionedTopics: boolean;
+  supportsSubscriptions: boolean;
+  supportsCreateSubscription: boolean;
+  supportsResetCursor: boolean;
+  supportsSkipMessages: boolean;
+  supportsClearBacklog: boolean;
+  supportsPeekMessages: boolean;
+  supportsExpireMessages: boolean;
+  supportsRateLimits: boolean;
+  supportsBacklogQuota: boolean;
+  supportsRetention: boolean;
+  supportsPermissions: boolean;
+  supportsGeoReplication: boolean;
+  supportsTokenManagement: boolean;
+  supportsRawAdminApi: boolean;
+  supportsSendMessage?: boolean;
+}
+
+export interface MqClusterInfo {
+  systemKind: MqSystemKind;
+  serverVersion?: string;
+  resolvedProfile: string;
+  versionDetection: string;
+  capabilities: MqCapabilities;
+  extra?: unknown;
+}
+
+export interface MqAuth {
+  kind: "none" | "token" | "basic" | "apiKey" | "oauth2";
+  token?: string;
+  username?: string;
+  password?: string;
+  header?: string;
+  value?: string;
+  issuerUrl?: string;
+  clientId?: string;
+  clientSecret?: string;
+  audience?: string;
+  scope?: string;
+}
+
+export interface MqAdminConfig {
+  systemKind: MqSystemKind;
+  adminUrl: string;
+  auth?: MqAuth;
+  tlsSkipVerify?: boolean;
+  pinnedVersion?: string;
+  tokenSigning?: MqTokenSigningConfig;
+  extra?: unknown;
+}
+
+export type MqTokenSigningAlgorithm = "hs256" | "rs256";
+
+export interface MqTokenSigningConfig {
+  algorithm: MqTokenSigningAlgorithm;
+  key: string;
+}
+
+export interface MqTokenIssueRequest {
+  subject: string;
+  expiresInSeconds?: number;
+  scope?: PolicyScope;
+  actions: AuthAction[];
+  note?: string;
+}
+
+export interface MqTokenRecord {
+  id: string;
+  connectionId: string;
+  subject: string;
+  algorithm: MqTokenSigningAlgorithm;
+  tokenFingerprint: string;
+  scope?: PolicyScope;
+  actions: AuthAction[];
+  expiresAt?: string;
+  createdAt: string;
+  note: string;
+}
+
+export interface MqIssuedToken {
+  token: string;
+  record: MqTokenRecord;
+}
+
+// Tenant
+export interface TenantInfo {
+  name: string;
+  adminRoles: string[];
+  allowedClusters: string[];
+}
+
+export interface TenantConfig {
+  adminRoles: string[];
+  allowedClusters: string[];
+}
+
+// Namespace
+export interface NamespaceRef {
+  tenant: string;
+  namespace: string;
+}
+
+export interface NamespaceInfo {
+  tenant: string;
+  namespace: string;
+  adminRoles: string[];
+}
+
+export interface NamespaceConfig {
+  clusters?: string[];
+  bundles?: number;
+}
+
+// Topic
+export interface TopicRef {
+  tenant: string;
+  namespace: string;
+  topic: string;
+  persistent: boolean;
+  partitioned?: boolean;
+}
+
+export interface TopicInfo {
+  name: string;
+  shortName: string;
+  partitioned: boolean;
+  partitions?: number;
+  persistent: boolean;
+}
+
+export interface ListTopicsOpts {
+  includeNonPersistent?: boolean;
+}
+
+export interface TopicStats {
+  msgRateIn: number;
+  msgRateOut: number;
+  msgThroughputIn: number;
+  msgThroughputOut: number;
+  storageSize: number;
+  backlogSize: number;
+  msgInCounter: number;
+  msgOutCounter: number;
+  subscriptionCount: number;
+  producerCount: number;
+  raw?: unknown;
+}
+
+// Subscription
+export interface SubscriptionInfo {
+  name: string;
+  subType: string;
+  msgBacklog: number;
+  msgRateOut: number;
+  msgThroughputOut: number;
+  consumers: ConsumerInfo[];
+}
+
+export interface ConsumerInfo {
+  consumerName: string;
+  msgRateOut: number;
+  msgThroughputOut: number;
+  availablePermits: number;
+  address: string;
+  clientVersion: string;
+}
+
+export interface ProducerInfo {
+  producerId: number;
+  producerName: string;
+  msgRateIn: number;
+  msgThroughputIn: number;
+  address: string;
+  clientVersion: string;
+}
+
+export type ResetPosition = { kind: "earliest" } | { kind: "latest" } | { kind: "timestamp"; timestampMs: number } | { kind: "messageId"; ledgerId: number; entryId: number };
+
+export type SkipCount = { kind: "all" } | { kind: "count"; count: number };
+
+export interface BacklogStats {
+  msgBacklog: number;
+  backlogSize: number;
+}
+
+export interface ClusterInfo {
+  clusterId?: string;
+  brokerCount: number;
+  controllerId?: number;
+  controllerHost?: string;
+  brokers: BrokerNode[];
+  raw?: Record<string, unknown>;
+}
+
+export interface BrokerNode {
+  id: number;
+  host: string;
+  port: number;
+  rack?: string;
+}
+
+export interface PeekedMessage {
+  position: number;
+  messageId?: string;
+  key?: string;
+  publishTime?: string;
+  eventTime?: string;
+  properties: Record<string, string>;
+  headers: Record<string, string>;
+  payloadBase64: string;
+  payloadText?: string;
+}
+
+export interface PeekMessagesOptions {
+  partition?: number;
+  offset?: number;
+}
+
+// Policy scope
+export type PolicyScope = { level: "namespace"; tenant: string; namespace: string } | { level: "topic"; tenant: string; namespace: string; topic: string; persistent: boolean };
+
+export interface PublishRate {
+  publishThrottlingRateInMsg: number;
+  publishThrottlingRateInByte: number;
+}
+
+export interface DispatchRate {
+  dispatchThrottlingRateInMsg: number;
+  dispatchThrottlingRateInByte: number;
+  ratePeriodInSecond: number;
+}
+
+export interface SubscribeRate {
+  subscribeThrottlingRatePerConsumer: number;
+  ratePeriodInSecond: number;
+}
+
+export interface BacklogQuota {
+  limitSize: number;
+  limitTime: number;
+  policy: string;
+  quotaType: string;
+}
+
+export interface RetentionPolicy {
+  retentionTimeInMinutes: number;
+  retentionSizeInMb: number;
+}
+
+export type AuthAction = "produce" | "consume" | "functions" | "sources" | "sinks" | "packages";
+
+export type PermissionMap = Record<string, AuthAction[]>;
+
+// Raw request
+export interface MqRawRequest {
+  method: string;
+  path: string;
+  query?: Record<string, string>;
+  body?: unknown;
+}
+
+export interface MqRawResponse {
+  status: number;
+  body: unknown;
+  text?: string;
+}
+
+// Send message (produce)
+export interface SendMessageRequest {
+  topic: string;
+  key?: string;
+  payloadBase64: string;
+  payloadText?: string;
+  headers: Record<string, string>;
+  partition?: number;
+}
+
+export interface SendMessageResponse {
+  topic: string;
+  partition: number;
+  offset: number;
+  timestamp?: string;
+}
diff --git a/apps/desktop/src/types/nacos.ts b/apps/desktop/src/types/nacos.ts
new file mode 100644
index 0000000..b581dfe
--- /dev/null
+++ b/apps/desktop/src/types/nacos.ts
@@ -0,0 +1,202 @@
+export interface NacosCapabilities {
+  supportsConfigManagement: boolean;
+  supportsConfigHistory?: boolean;
+  supportsServiceManagement: boolean;
+  supportsInstanceUpdate: boolean;
+  supportsRawApi: boolean;
+}
+
+export interface NacosConnectionInfo {
+  serverAddr: string;
+  displayServerAddr: string;
+  namespace: string;
+  serverVersion?: string;
+  auth: string;
+  capabilities: NacosCapabilities;
+  raw?: unknown;
+}
+
+export interface NacosNamespaceInfo {
+  namespace: string;
+  namespaceShowName: string;
+  namespaceDesc?: string;
+  configCount?: number;
+  quota?: number;
+  namespaceType?: number;
+}
+
+export interface NacosNamespaceCreate {
+  namespaceId?: string;
+  namespaceName: string;
+  namespaceDesc?: string;
+}
+
+export interface NacosNamespaceUpdate {
+  namespaceId: string;
+  namespaceName: string;
+  namespaceDesc?: string;
+}
+
+export interface NacosAuthConfig {
+  kind: "none" | "usernamePassword";
+  username?: string;
+  password?: string;
+}
+
+export interface NacosAdminConfig {
+  serverAddr: string;
+  namespace?: string;
+  contextPath?: string;
+  auth?: NacosAuthConfig;
+  tlsSkipVerify?: boolean;
+  pageSize?: number;
+}
+
+export interface NacosConfigQuery {
+  namespace?: string;
+  group?: string;
+  dataId?: string;
+  appName?: string;
+  search?: string;
+  pageNo?: number;
+  pageSize?: number;
+}
+
+export interface NacosConfigItem {
+  dataId: string;
+  group: string;
+  namespace: string;
+  appName?: string;
+  desc?: string;
+  tags?: string;
+  configType?: string;
+  md5?: string;
+  encryptedDataKey?: string;
+  content?: string;
+}
+
+export interface NacosConfigList {
+  pageNo: number;
+  pageSize: number;
+  totalCount: number;
+  items: NacosConfigItem[];
+}
+
+export interface NacosConfigKey {
+  namespace?: string;
+  dataId: string;
+  group: string;
+}
+
+export interface NacosConfigUpsert extends NacosConfigKey {
+  content: string;
+  configType?: string;
+  appName?: string;
+  desc?: string;
+  tags?: string;
+}
+
+export interface NacosConfigHistoryQuery extends NacosConfigKey {
+  pageNo?: number;
+  pageSize?: number;
+}
+
+export interface NacosConfigHistoryItem {
+  historyId: string;
+  nid?: number;
+  dataId: string;
+  group: string;
+  namespace: string;
+  appName?: string;
+  operation?: string;
+  operator?: string;
+  lastModifiedTime?: string;
+  configType?: string;
+  tags?: string;
+  md5?: string;
+}
+
+export interface NacosConfigHistoryList {
+  pageNo: number;
+  pageSize: number;
+  totalCount: number;
+  items: NacosConfigHistoryItem[];
+}
+
+export interface NacosConfigHistoryKey extends NacosConfigKey {
+  historyId: string;
+  nid?: number;
+}
+
+export interface NacosConfigRollbackRequest extends NacosConfigHistoryKey {}
+
+export interface NacosServiceQuery {
+  namespace?: string;
+  groupName?: string;
+  serviceName?: string;
+  pageNo?: number;
+  pageSize?: number;
+}
+
+export interface NacosServiceInfo {
+  serviceName: string;
+  groupName?: string;
+  clusterCount?: number;
+  ipCount?: number;
+  healthyInstanceCount?: number;
+  triggerFlag?: string;
+}
+
+export interface NacosServiceList {
+  pageNo: number;
+  pageSize: number;
+  totalCount: number;
+  items: NacosServiceInfo[];
+}
+
+export interface NacosInstanceQuery {
+  namespace?: string;
+  serviceName: string;
+  groupName?: string;
+  clusters?: string;
+}
+
+export interface NacosInstanceInfo {
+  ip: string;
+  port: number;
+  serviceName?: string;
+  clusterName?: string;
+  groupName?: string;
+  healthy?: boolean;
+  enabled?: boolean;
+  ephemeral?: boolean;
+  weight?: number;
+  metadata?: unknown;
+}
+
+export interface NacosInstanceUpdate {
+  namespace?: string;
+  serviceName: string;
+  ip: string;
+  port: number;
+  groupName?: string;
+  clusterName?: string;
+  healthy?: boolean;
+  enabled?: boolean;
+  ephemeral?: boolean;
+  weight?: number;
+  metadata?: unknown;
+}
+
+export interface NacosRawRequest {
+  method: string;
+  path: string;
+  query?: Record<string, string>;
+  body?: unknown;
+}
+
+export interface NacosRawResponse {
+  status: number;
+  body: unknown;
+  text?: string;
+}
diff --git a/apps/desktop/src/types/schemaDiff.ts b/apps/desktop/src/types/schemaDiff.ts
new file mode 100644
index 0000000..4a3444a
--- /dev/null
+++ b/apps/desktop/src/types/schemaDiff.ts
@@ -0,0 +1,136 @@
+export type SchemaDiffTableFilterPriority = "include" | "exclude";
+
+export interface SchemaDiffCompareOptions {
+  tables: boolean;
+  primaryKeys: boolean;
+  foreignKeys: boolean;
+  uniqueKeys: boolean;
+  checks: boolean;
+  exclusions: boolean;
+  views: boolean;
+  functions: boolean;
+  indexes: boolean;
+  sequences: boolean;
+  triggers: boolean;
+  rules: boolean;
+  owners: boolean;
+  cascadeDelete: boolean;
+  sequenceLastValues: boolean;
+  compareColumnOrder: boolean;
+  tableIncludePattern: string;
+  tableExcludePattern: string;
+  tableFilterPriority: SchemaDiffTableFilterPriority;
+}
+
+export interface SchemaDiffConfig {
+  id: string;
+  name: string;
+  createdAt: number;
+  updatedAt: number;
+  sourceConnectionId: string;
+  sourceDatabase: string;
+  sourceSchema: string;
+  targetConnectionId: string;
+  targetDatabase: string;
+  targetSchema: string;
+  options: SchemaDiffCompareOptions;
+}
+
+export interface SchemaDiffOptionItem {
+  id: BooleanSchemaDiffCompareOptionKey;
+  labelKey: string;
+  defaultChecked: boolean;
+  children?: SchemaDiffOptionItem[];
+}
+
+export type BooleanSchemaDiffCompareOptionKey = {
+  [K in keyof SchemaDiffCompareOptions]: SchemaDiffCompareOptions[K] extends boolean ? K : never;
+}[keyof SchemaDiffCompareOptions];
+
+export type SchemaDiffOptionsMap = Partial<Record<string, SchemaDiffOptionItem[]>>;
+
+export const DEFAULT_POSTGRES_OPTIONS: SchemaDiffCompareOptions = {
+  tables: true,
+  primaryKeys: true,
+  foreignKeys: true,
+  uniqueKeys: true,
+  checks: true,
+  exclusions: true,
+  views: true,
+  functions: true,
+  indexes: true,
+  sequences: true,
+  triggers: true,
+  rules: true,
+  owners: true,
+  cascadeDelete: false,
+  sequenceLastValues: true,
+  compareColumnOrder: false,
+  tableIncludePattern: "",
+  tableExcludePattern: "",
+  tableFilterPriority: "exclude",
+};
+
+export const DEFAULT_MYSQL_OPTIONS: SchemaDiffCompareOptions = {
+  tables: true,
+  primaryKeys: true,
+  foreignKeys: true,
+  uniqueKeys: true,
+  checks: true,
+  exclusions: false,
+  views: true,
+  functions: false,
+  indexes: true,
+  sequences: false,
+  triggers: true,
+  rules: false,
+  owners: false,
+  cascadeDelete: false,
+  sequenceLastValues: false,
+  compareColumnOrder: false,
+  tableIncludePattern: "",
+  tableExcludePattern: "",
+  tableFilterPriority: "exclude",
+};
+
+export function getDefaultOptionsForDbType(dbType: string): SchemaDiffCompareOptions {
+  if (dbType === "postgres" || dbType === "opengauss") {
+    return { ...DEFAULT_POSTGRES_OPTIONS };
+  }
+  return { ...DEFAULT_MYSQL_OPTIONS };
+}
+
+export function normalizeSchemaDiffCompareOptions(options: Partial<SchemaDiffCompareOptions> | null | undefined, dbType = "postgres"): SchemaDiffCompareOptions {
+  return {
+    ...getDefaultOptionsForDbType(dbType),
+    ...options,
+  };
+}
+
+export function createEmptyConfig(id: string, name: string): SchemaDiffConfig {
+  const now = Date.now();
+  return {
+    id,
+    name,
+    createdAt: now,
+    updatedAt: now,
+    sourceConnectionId: "",
+    sourceDatabase: "",
+    sourceSchema: "",
+    targetConnectionId: "",
+    targetDatabase: "",
+    targetSchema: "",
+    options: { ...DEFAULT_POSTGRES_OPTIONS },
+  };
+}
+
+export function cloneConfig(config: SchemaDiffConfig, newId: string, newName: string): SchemaDiffConfig {
+  const now = Date.now();
+  return {
+    ...config,
+    id: newId,
+    name: newName,
+    createdAt: now,
+    updatedAt: now,
+  };
+}
diff --git a/apps/desktop/src/types/vue-virtual-scroller.d.ts b/apps/desktop/src/types/vue-virtual-scroller.d.ts
new file mode 100644
index 0000000..4ac9824
--- /dev/null
+++ b/apps/desktop/src/types/vue-virtual-scroller.d.ts
@@ -0,0 +1,7 @@
+declare module "vue-virtual-scroller" {
+  const VueVirtualScroller: any;
+  export const RecycleScroller: any;
+  export const DynamicScroller: any;
+  export const DynamicScrollerItem: any;
+  export default VueVirtualScroller;
+}
diff --git a/apps/desktop/tsconfig.json b/apps/desktop/tsconfig.json
new file mode 100644
index 0000000..17cb366
--- /dev/null
+++ b/apps/desktop/tsconfig.json
@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2021", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "incremental": true,
+    "tsBuildInfoFile": "../../node_modules/.cache/vue-tsc/desktop.tsbuildinfo",
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "preserve",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue"],
+  "exclude": ["src/**/__tests__/**"]
+}
diff --git a/apps/desktop/vite.config.ts b/apps/desktop/vite.config.ts
new file mode 100644
index 0000000..ea88e10
--- /dev/null
+++ b/apps/desktop/vite.config.ts
@@ -0,0 +1,105 @@
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import tailwindcss from "@tailwindcss/vite";
+import path from "path";
+
+const host = process.env.TAURI_DEV_HOST;
+const isTauri = !!host || !!process.env.TAURI_ENV_ARCH;
+const configuredBasePath = process.env.VITE_DBX_BASE_PATH || process.env.DBX_PUBLIC_BASE_PATH;
+const manualChunks: Record<string, string[]> = {
+  codemirror: ["codemirror", "@codemirror/lang-sql", "@codemirror/view", "@codemirror/state", "@codemirror/autocomplete", "@codemirror/commands", "@codemirror/theme-one-dark"],
+  "vue-echarts": ["vue-echarts"],
+  ui: ["reka-ui"],
+  marked: ["marked"],
+};
+
+function chunkNameForEchartsModule(id: string): string {
+  const echartsPath = id.split("/node_modules/echarts/").pop() ?? "";
+
+  if (echartsPath === "charts.js" || echartsPath.startsWith("lib/chart/")) {
+    return "echarts-charts";
+  }
+
+  if (echartsPath === "components.js" || echartsPath.startsWith("lib/component/")) {
+    return "echarts-components";
+  }
+
+  if (echartsPath === "renderers.js" || echartsPath.startsWith("lib/renderer/")) {
+    return "echarts-renderers";
+  }
+
+  return "echarts-core";
+}
+
+function chunkNameForModule(id: string): string | undefined {
+  const normalizedId = id.replaceAll("\\", "/");
+
+  if (normalizedId.includes("/node_modules/echarts/")) {
+    return chunkNameForEchartsModule(normalizedId);
+  }
+
+  for (const [chunkName, packages] of Object.entries(manualChunks)) {
+    if (packages.some((pkg) => normalizedId.includes(`/node_modules/${pkg}/`))) {
+      return chunkName;
+    }
+  }
+
+  return undefined;
+}
+
+function normalizeViteBase(value: string | undefined): string {
+  const trimmed = value?.trim();
+  if (!trimmed) return "./";
+  if (trimmed === "." || trimmed === "./") return "./";
+  const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+  return withLeadingSlash.endsWith("/") ? withLeadingSlash : `${withLeadingSlash}/`;
+}
+
+const viteBase = normalizeViteBase(configuredBasePath);
+const publicBasePath = viteBase.startsWith("/") ? viteBase.replace(/\/+$/, "") : "";
+const apiProxyPath = publicBasePath ? `${publicBasePath}/api` : "/api";
+const backendUrl = process.env.DBX_BACKEND_URL || "http://localhost:4224";
+
+export default defineConfig(async () => ({
+  root: __dirname,
+  base: viteBase,
+  plugins: [vue(), tailwindcss()],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+  clearScreen: false,
+  build: {
+    outDir: "../../dist",
+    emptyOutDir: true,
+    rollupOptions: {
+      output: {
+        manualChunks: chunkNameForModule,
+      },
+    },
+  },
+  server: {
+    port: isTauri ? 1420 : undefined,
+    strictPort: isTauri,
+    host: host || false,
+    hmr: host
+      ? {
+          protocol: "ws",
+          host,
+          port: 1421,
+        }
+      : undefined,
+    proxy: {
+      [apiProxyPath]: {
+        target: backendUrl,
+        changeOrigin: true,
+        ws: true,
+        rewrite: publicBasePath ? (requestPath) => requestPath.slice(publicBasePath.length) || "/" : undefined,
+      },
+    },
+    watch: {
+      ignored: ["**/src-tauri/**"],
+    },
+  },
+}));
diff --git a/crates/README.md b/crates/README.md
new file mode 100644
index 0000000..adaf564
--- /dev/null
+++ b/crates/README.md
@@ -0,0 +1,10 @@
+# Crates
+
+Rust crates for DBX live here.
+
+## Directories
+
+- `dbx-core/` - shared database core, drivers, schema/query logic, import/export, transfer, and plugin support.
+- `dbx-web/` - the Docker/web backend service binary published as `dbx-web`.
+
+The workspace root is defined in the repository-level `Cargo.toml`.
diff --git a/crates/dbx-core/Cargo.toml b/crates/dbx-core/Cargo.toml
new file mode 100644
index 0000000..5f6a8d3
--- /dev/null
+++ b/crates/dbx-core/Cargo.toml
@@ -0,0 +1,84 @@
+[package]
+name = "dbx-core"
+version = "0.1.0"
+edition = "2021"
+license = "Apache-2.0"
+
+[[bin]]
+name = "duckdb-worker-test-host"
+path = "tests/support/duckdb_worker_test_host.rs"
+required-features = ["duckdb-bundled"]
+test = false
+bench = false
+
+[[bin]]
+name = "duckdb-worker-hanging-connect-test-host"
+path = "tests/support/duckdb_worker_hanging_connect_test_host.rs"
+required-features = ["duckdb-bundled"]
+test = false
+
+[[bin]]
+name = "duckdb-worker-pid-test-host"
+path = "tests/support/duckdb_worker_pid_test_host.rs"
+required-features = ["duckdb-bundled"]
+test = false
+bench = false
+
+[[bin]]
+name = "duckdb-worker-file-lock-owner"
+path = "tests/support/duckdb_worker_file_lock_owner.rs"
+required-features = ["duckdb-bundled"]
+test = false
+bench = false
+
+[features]
+default = ["duckdb-bundled", "mq-admin", "sqlite-sqlcipher"]
+duckdb-bundled = ["duckdb/bundled"]
+mq-admin = []
+sqlite-sqlcipher = ["rusqlite/bundled-sqlcipher-vendored-openssl"]
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = { version = "1.0", features = ["arbitrary_precision", "preserve_order"] }
+regex = "1"
+rayon = "1"
+percent-encoding = "2"
+encoding_rs = "0.8"
+log = "0.4"
+tokio = { version = "1", features = ["full"] }
+tokio-util = { version = "0.7", features = ["compat"] }
+chrono = { version = "0.4", features = ["serde"] }
+rust_decimal = { version = "1", features = ["serde", "db-postgres"] }
+anyhow = "1"
+uuid = { version = "1", features = ["v4", "serde"] }
+tokio-postgres = { version = "0.7", features = ["with-chrono-0_4", "with-uuid-1", "with-serde_json-1"] }
+deadpool-postgres = { version = "0.14", features = ["rt_tokio_1"] }
+tokio-postgres-rustls = "0.13"
+webpki-roots = "0.26"
+rusqlite = { version = "0.32", features = ["bundled", "load_extension", "backup", "functions", "column_decltype"] }
+mysql_async = { version = "0.36", default-features = false, features = ["default-rustls", "client_ed25519", "chrono", "rust_decimal"] }
+sqlparser = { version = "0.62.0", features = ["visitor"] }
+redis = { version = "0.32.2", features = ["tokio-comp", "tls-rustls", "tls-rustls-insecure", "tokio-rustls-comp", "sentinel", "cluster-async"] }
+rustls = { version = "0.23", features = ["aws-lc-rs"] }
+rustls-pemfile = "2.2"
+duckdb = { version = "1.3.2", optional = true }
+tiberius = { version = "0.12.3", default-features = false, features = ["tds73", "chrono", "rust_decimal", "rustls", "sql-browser-tokio"] }
+reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls", "socks"] }
+futures = "0.3"
+iana-time-zone = "0.1"
+mongodb = "3.2.5"
+russh = "0.60"
+pageant = "0.2"
+portpicker = "0.1.1"
+csv = "1"
+calamine = "0.30.1"
+base64 = "0.22"
+jsonwebtoken = "9"
+aes-gcm = "0.10"
+argon2 = "0.5"
+sha2 = "0.10"
+async-trait = "0.1"
+bytes = "1"
+font-kit = "0.14.3"
+zip = { version = "4", default-features = false, features = ["deflate"] }
+sysinfo = { version = "0.32", features = ["system"] }
diff --git a/crates/dbx-core/assets/agent-protocol-v1.json b/crates/dbx-core/assets/agent-protocol-v1.json
new file mode 100644
index 0000000..c108483
--- /dev/null
+++ b/crates/dbx-core/assets/agent-protocol-v1.json
@@ -0,0 +1,88 @@
+{
+  "protocolVersion": 1,
+  "handshakeMethod": "handshake",
+  "handshakeResponseFields": [
+    "protocolVersion",
+    "agentProtocolVersion",
+    "capabilities"
+  ],
+  "allCapabilities": [
+    "connect",
+    "test_connection",
+    "metadata",
+    "query",
+    "paged_query",
+    "transaction",
+    "ddl",
+    "kv"
+  ],
+  "capabilities": [
+    "connect",
+    "test_connection",
+    "metadata",
+    "query",
+    "paged_query",
+    "transaction",
+    "ddl"
+  ],
+  "defaultSqlCapabilities": [
+    "connect",
+    "test_connection",
+    "metadata",
+    "query",
+    "paged_query",
+    "transaction",
+    "ddl"
+  ],
+  "commonMethods": [
+    "handshake",
+    "connect",
+    "test_connection",
+    "validate_connection",
+    "list_databases",
+    "list_schemas",
+    "list_tables",
+    "list_objects",
+    "list_data_types",
+    "completion_assistant_search_v1",
+    "get_object_source",
+    "get_table_ddl",
+    "get_columns",
+    "list_indexes",
+    "list_foreign_keys",
+    "list_triggers",
+    "execute_query",
+    "execute_query_page",
+    "fetch_query_page",
+    "close_query_session",
+    "start_table_read",
+    "fetch_table_read_page",
+    "close_table_read_session",
+    "get_explain_info",
+    "execute_batch",
+    "execute_transaction",
+    "disconnect",
+    "shutdown"
+  ],
+  "mongoLegacyMethods": [
+    "list_databases",
+    "list_collections",
+    "find_documents",
+    "find_documents_extended_json",
+    "server_version",
+    "create_index",
+    "drop_indexes",
+    "drop_collection",
+    "insert_document",
+    "update_document",
+    "update_documents",
+    "delete_document",
+    "delete_documents"
+  ],
+  "kvMethods": [
+    "kv_list_prefix",
+    "kv_get",
+    "kv_put",
+    "kv_delete"
+  ]
+}
diff --git a/crates/dbx-core/assets/database-drivers.manifest.json b/crates/dbx-core/assets/database-drivers.manifest.json
new file mode 100644
index 0000000..cd3c6b8
--- /dev/null
+++ b/crates/dbx-core/assets/database-drivers.manifest.json
@@ -0,0 +1,1890 @@
+{
+  "schemaVersion": 1,
+  "drivers": [
+    {
+      "dbType": "mysql",
+      "label": "MySQL",
+      "runtimeMode": "native",
+      "mcpMode": "direct",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": true,
+      "skipTcpProbe": false,
+      "defaultPort": 3306,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": true,
+        "sqlExplain": true,
+        "userAdmin": true,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "postgres",
+      "label": "PostgreSQL",
+      "runtimeMode": "native",
+      "mcpMode": "direct",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 5432,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": true,
+        "sqlExplain": true,
+        "userAdmin": true,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "sqlite",
+      "label": "SQLite",
+      "runtimeMode": "file",
+      "mcpMode": "direct",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": true,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "rqlite",
+      "label": "RQLite",
+      "runtimeMode": "native",
+      "mcpMode": "direct",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 4001,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": true,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "cloudflare-d1",
+      "label": "Cloudflare D1",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 443,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": true,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "redis",
+      "label": "Redis",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 6379,
+      "supportLevel": "connect",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": false,
+        "objectBrowser": false,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": false,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "duckdb",
+      "label": "DuckDB",
+      "runtimeMode": "file",
+      "mcpMode": "bridge",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "clickhouse",
+      "label": "ClickHouse",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 8123,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "sqlserver",
+      "label": "SQL Server",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 1433,
+      "supportLevel": "operate",
+      "driverProfiles": [
+        {
+          "profile": "sqlserver-legacy",
+          "agentKey": "sqlserver-legacy"
+        }
+      ],
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": true,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "mongodb",
+      "label": "MongoDB (Legacy)",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "mongodb",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 27017,
+      "supportLevel": "connect",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": false,
+        "objectBrowser": false,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": true,
+        "sqlFileExecution": false,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "oracle",
+      "label": "Oracle",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "oracle",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 1521,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": true,
+        "sqlExplain": true,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "elasticsearch",
+      "label": "Elasticsearch",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 9200,
+      "supportLevel": "connect",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": false,
+        "objectBrowser": false,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": false,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "qdrant",
+      "label": "Qdrant",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 6333,
+      "supportLevel": "browse",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": false,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": false,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "chromadb",
+      "label": "ChromaDB",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 8000,
+      "supportLevel": "browse",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": false,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": false,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "milvus",
+      "label": "Milvus",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 19530,
+      "supportLevel": "browse",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": false,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": false,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "weaviate",
+      "label": "Weaviate",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 8080,
+      "supportLevel": "browse",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": false,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": false,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "doris",
+      "label": "Doris",
+      "runtimeMode": "native",
+      "mcpMode": "direct",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 9030,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "starrocks",
+      "label": "StarRocks",
+      "runtimeMode": "native",
+      "mcpMode": "direct",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 9030,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "manticoresearch",
+      "label": "Manticore Search",
+      "runtimeMode": "native",
+      "mcpMode": "direct",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 9306,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": false,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "redshift",
+      "label": "Redshift",
+      "runtimeMode": "native",
+      "mcpMode": "direct",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 5439,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": true,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "dameng",
+      "label": "达梦 DM8",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "dameng",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 5236,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": true,
+        "sqlExplain": true,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "kingbase",
+      "label": "人大金仓 KingbaseES",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "kingbase",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 54321,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": true,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "highgo",
+      "label": "瀚高 HighGo",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "highgo",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 5866,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": true,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "vastbase",
+      "label": "Vastbase",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "vastbase",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 5432,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": true,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "goldendb",
+      "label": "GoldenDB",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "goldendb",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 3306,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": true,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "databend",
+      "label": "Databend",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "databend",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 8000,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "gaussdb",
+      "label": "GaussDB",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 8000,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": true,
+        "sqlExplain": false,
+        "userAdmin": true,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "kwdb",
+      "label": "KWDB",
+      "runtimeMode": "native",
+      "mcpMode": "direct",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 26257,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": true,
+        "sqlExplain": false,
+        "userAdmin": true,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "yashandb",
+      "label": "崖山 YashanDB",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "yashandb",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 1688,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "databricks",
+      "label": "Databricks SQL",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "databricks",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 443,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "saphana",
+      "label": "SAP HANA",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "saphana",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 30015,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "teradata",
+      "label": "Teradata",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "teradata",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 1025,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "vertica",
+      "label": "Vertica",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "vertica",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 5433,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "firebird",
+      "label": "Firebird",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "firebird",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 3050,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "exasol",
+      "label": "Exasol",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "exasol",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 8563,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "opengauss",
+      "label": "openGauss",
+      "runtimeMode": "native",
+      "mcpMode": "bridge",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 5432,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": true,
+        "sqlExplain": false,
+        "userAdmin": true,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "questdb",
+      "label": "QuestDB",
+      "runtimeMode": "native",
+      "mcpMode": "direct",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 8812,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": true,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "oceanbase-oracle",
+      "label": "OceanBase Oracle Mode",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "oceanbase-oracle",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 2883,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": true,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "gbase",
+      "label": "GBase 8a",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "gbase8a",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 5258,
+      "driverProfiles": [
+        {
+          "profile": "gbase8s",
+          "label": "GBase 8s",
+          "agentKey": "gbase8s"
+        },
+        {
+          "profile": "gbase8a",
+          "label": "GBase 8a",
+          "agentKey": "gbase8a"
+        }
+      ],
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "access",
+      "label": "Microsoft Access",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "access",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": true,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "h2",
+      "label": "H2",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "h2",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 9092,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "snowflake",
+      "label": "Snowflake",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "snowflake",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 443,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "trino",
+      "label": "Trino",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "trino",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 8080,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "prestosql",
+      "label": "PrestoSQL",
+      "runtimeMode": "external",
+      "mcpMode": "bridge",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": false,
+      "defaultPort": 8080,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "hive",
+      "label": "Apache Hive",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "hive",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 10000,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "db2",
+      "label": "IBM DB2",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "db2",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 50000,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "informix",
+      "label": "IBM Informix",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "informix",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 9088,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "neo4j",
+      "label": "Neo4j",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "neo4j",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 7687,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "cassandra",
+      "label": "Apache Cassandra",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "cassandra",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 9042,
+      "supportLevel": "understand",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "bigquery",
+      "label": "Google BigQuery",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "bigquery",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "kylin",
+      "label": "Apache Kylin",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "kylin",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 7070,
+      "supportLevel": "understand",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "sundb",
+      "label": "SunDB",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "sundb",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 22581,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "oscar",
+      "label": "神通 OSCAR",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "oscar",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 2003,
+      "supportLevel": "browse",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "tdengine",
+      "label": "TDengine",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "tdengine",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 6041,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "xugu",
+      "label": "虚谷 XuguDB",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "xugu",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 5138,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "etcd",
+      "label": "etcd",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "etcd",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 2379,
+      "supportLevel": "connect",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": false,
+        "objectBrowser": false,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": false,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "zookeeper",
+      "label": "Apache ZooKeeper",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "zookeeper",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 2181,
+      "supportLevel": "connect",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": false,
+        "objectBrowser": false,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": false,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "mq",
+      "label": "Message Queue",
+      "runtimeMode": "native",
+      "mcpMode": "unsupported",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 8080,
+      "driverProfiles": [
+        {
+          "profile": "kafka",
+          "label": "Apache Kafka",
+          "agentKey": "kafka"
+        }
+      ],
+      "supportLevel": "connect",
+      "capabilities": {
+        "queryExecution": false,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": false,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "iotdb",
+      "label": "Apache IoTDB",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "iotdb",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 6667,
+      "supportLevel": "understand",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "iris",
+      "label": "InterSystems IRIS",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "iris",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 1972,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": true,
+        "schemaSearch": true,
+        "diagram": true,
+        "tableDataEdit": false,
+        "tableStructureEdit": true,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    },
+    {
+      "dbType": "influxdb",
+      "label": "InfluxDB",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "influxdb",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 8086,
+      "supportLevel": "connect",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": true,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "jdbc",
+      "label": "JDBC",
+      "runtimeMode": "external",
+      "mcpMode": "bridge",
+      "singleConnectionPool": true,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "supportLevel": "browse",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": false,
+        "diagram": false,
+        "tableDataEdit": false,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": false,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": false
+      }
+    },
+    {
+      "dbType": "spark",
+      "label": "Apache Spark",
+      "runtimeMode": "agent",
+      "mcpMode": "bridge",
+      "agentKey": "spark",
+      "singleConnectionPool": false,
+      "metadataConnectionScoped": false,
+      "skipTcpProbe": true,
+      "defaultPort": 10015,
+      "supportLevel": "operate",
+      "capabilities": {
+        "queryExecution": true,
+        "metadataBrowse": true,
+        "objectBrowser": true,
+        "objectSource": false,
+        "schemaSearch": true,
+        "diagram": false,
+        "tableDataEdit": true,
+        "tableStructureEdit": false,
+        "tableImport": false,
+        "dataTransfer": true,
+        "sqlFileExecution": true,
+        "databaseCreate": false,
+        "fieldLineage": false,
+        "sqlExplain": false,
+        "userAdmin": false,
+        "driverManagement": true
+      }
+    }
+  ]
+}
diff --git a/crates/dbx-core/src/agent_catalog.rs b/crates/dbx-core/src/agent_catalog.rs
new file mode 100644
index 0000000..3ce98df
--- /dev/null
+++ b/crates/dbx-core/src/agent_catalog.rs
@@ -0,0 +1,371 @@
+use std::collections::HashSet;
+
+use crate::models::connection::DatabaseType;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct AgentCatalogEntry {
+    pub db_type: DatabaseType,
+    pub key: &'static str,
+    pub label: &'static str,
+    pub store_visible: bool,
+    pub profiles: &'static [AgentDriverProfile],
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AgentDriverProfile {
+    pub profile: &'static str,
+    pub key: &'static str,
+    pub label: &'static str,
+    pub store_visible: bool,
+}
+
+const ORACLE_PROFILES: &[AgentDriverProfile] = &[
+    AgentDriverProfile { profile: "oracle-legacy", key: "oracle", label: "Oracle", store_visible: false },
+    AgentDriverProfile { profile: "oracle-10g", key: "oracle", label: "Oracle", store_visible: false },
+];
+
+const GBASE_PROFILES: &[AgentDriverProfile] = &[
+    AgentDriverProfile { profile: "gbase8s", key: "gbase8s", label: "GBase 8s", store_visible: true },
+    AgentDriverProfile { profile: "gbase8a", key: "gbase8a", label: "GBase 8a", store_visible: true },
+];
+
+const MONGODB_PROFILES: &[AgentDriverProfile] = &[AgentDriverProfile {
+    profile: "mongodb-legacy",
+    key: "mongodb",
+    label: "MongoDB (Legacy)",
+    store_visible: false,
+}];
+
+const H2_PROFILES: &[AgentDriverProfile] =
+    &[AgentDriverProfile { profile: "h2-legacy", key: "h2-legacy", label: "H2 2.1 Legacy", store_visible: true }];
+
+const EXTRA_AGENT_LABELS: &[(&str, &str)] =
+    &[("kafka", "Apache Kafka"), ("sqlserver-legacy", "SQL Server legacy compatibility component")];
+const EXTRA_DRIVER_STORE_ENTRIES: &[(&str, &str)] =
+    &[("kafka", "Apache Kafka"), ("sqlserver-legacy", "SQL Server legacy compatibility component")];
+
+const AGENT_CATALOG: &[AgentCatalogEntry] = &[
+    AgentCatalogEntry {
+        db_type: DatabaseType::Dameng,
+        key: "dameng",
+        label: "达梦 DM8",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Kingbase,
+        key: "kingbase",
+        label: "人大金仓 KingbaseES",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Highgo,
+        key: "highgo",
+        label: "瀚高 HighGo",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Vastbase,
+        key: "vastbase",
+        label: "Vastbase",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Goldendb,
+        key: "goldendb",
+        label: "GoldenDB",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Databend,
+        key: "databend",
+        label: "Databend",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Databricks,
+        key: "databricks",
+        label: "Databricks SQL",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::SapHana,
+        key: "saphana",
+        label: "SAP HANA",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Teradata,
+        key: "teradata",
+        label: "Teradata",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Vertica,
+        key: "vertica",
+        label: "Vertica",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Firebird,
+        key: "firebird",
+        label: "Firebird",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Exasol,
+        key: "exasol",
+        label: "Exasol",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::OceanbaseOracle,
+        key: "oceanbase-oracle",
+        label: "OceanBase Oracle Mode",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Gbase,
+        key: "gbase8a",
+        label: "GBase 8a",
+        store_visible: true,
+        profiles: GBASE_PROFILES,
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Access,
+        key: "access",
+        label: "Microsoft Access",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Oracle,
+        key: "oracle",
+        label: "Oracle",
+        store_visible: true,
+        profiles: ORACLE_PROFILES,
+    },
+    AgentCatalogEntry { db_type: DatabaseType::H2, key: "h2", label: "H2", store_visible: true, profiles: H2_PROFILES },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Snowflake,
+        key: "snowflake",
+        label: "Snowflake",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Trino,
+        key: "trino",
+        label: "Trino",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Hive,
+        key: "hive",
+        label: "Apache Hive",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Spark,
+        key: "spark",
+        label: "Apache Spark",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry { db_type: DatabaseType::Db2, key: "db2", label: "IBM DB2", store_visible: true, profiles: &[] },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Informix,
+        key: "informix",
+        label: "IBM Informix",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::InfluxDb,
+        key: "influxdb",
+        label: "InfluxDB",
+        store_visible: false,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Neo4j,
+        key: "neo4j",
+        label: "Neo4j",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Cassandra,
+        key: "cassandra",
+        label: "Apache Cassandra",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Bigquery,
+        key: "bigquery",
+        label: "Google BigQuery",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Kylin,
+        key: "kylin",
+        label: "Apache Kylin",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Sundb,
+        key: "sundb",
+        label: "SunDB",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Oscar,
+        key: "oscar",
+        label: "神通 OSCAR",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Yashandb,
+        key: "yashandb",
+        label: "崖山 YashanDB",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Tdengine,
+        key: "tdengine",
+        label: "TDengine",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Xugu,
+        key: "xugu",
+        label: "虚谷 XuguDB",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Iotdb,
+        key: "iotdb",
+        label: "Apache IoTDB",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry { db_type: DatabaseType::Etcd, key: "etcd", label: "etcd", store_visible: true, profiles: &[] },
+    AgentCatalogEntry {
+        db_type: DatabaseType::ZooKeeper,
+        key: "zookeeper",
+        label: "Apache ZooKeeper",
+        store_visible: true,
+        profiles: &[],
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::MongoDb,
+        key: "mongodb",
+        label: "MongoDB (Legacy)",
+        store_visible: true,
+        profiles: MONGODB_PROFILES,
+    },
+    AgentCatalogEntry {
+        db_type: DatabaseType::Iris,
+        key: "iris",
+        label: "InterSystems IRIS",
+        store_visible: true,
+        profiles: &[],
+    },
+];
+
+pub fn entries() -> &'static [AgentCatalogEntry] {
+    AGENT_CATALOG
+}
+
+pub fn agent_key(db_type: &DatabaseType, driver_profile: Option<&str>) -> Option<&'static str> {
+    if *db_type == DatabaseType::MessageQueue {
+        return (driver_profile == Some("kafka")).then_some("kafka");
+    }
+    if *db_type == DatabaseType::SqlServer {
+        return driver_profile
+            .is_some_and(|profile| profile.eq_ignore_ascii_case("sqlserver-legacy"))
+            .then_some("sqlserver-legacy");
+    }
+    let entry = entry_for_db_type(db_type)?;
+    if let Some(driver_profile) = driver_profile {
+        if let Some(profile) = entry.profiles.iter().find(|profile| profile.profile == driver_profile) {
+            return Some(profile.key);
+        }
+    }
+    Some(entry.key)
+}
+
+pub fn is_agent_type(db_type: &DatabaseType) -> bool {
+    entry_for_db_type(db_type).is_some()
+}
+
+pub fn driver_store_entries() -> impl Iterator<Item = (&'static str, &'static str)> {
+    let mut seen = HashSet::new();
+    entries()
+        .iter()
+        .flat_map(move |entry| {
+            let base = entry.store_visible.then_some((entry.key, entry.label));
+            let profiles = entry
+                .profiles
+                .iter()
+                .filter(|profile| profile.store_visible)
+                .map(|profile| (profile.key, profile.label));
+            base.into_iter().chain(profiles)
+        })
+        .chain(EXTRA_DRIVER_STORE_ENTRIES.iter().copied())
+        .filter(move |(key, _)| seen.insert(*key))
+}
+
+pub fn label_for_key(agent_key: &str) -> Option<&'static str> {
+    if let Some((_, label)) = EXTRA_AGENT_LABELS.iter().find(|(key, _)| *key == agent_key) {
+        return Some(label);
+    }
+    for entry in entries() {
+        if entry.key == agent_key {
+            return Some(entry.label);
+        }
+        if let Some(profile) = entry.profiles.iter().find(|profile| profile.key == agent_key) {
+            return Some(profile.label);
+        }
+    }
+    None
+}
+
+fn entry_for_db_type(db_type: &DatabaseType) -> Option<&'static AgentCatalogEntry> {
+    entries().iter().find(|entry| entry.db_type == *db_type)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn h2_legacy_profile_uses_separate_agent() {
+        assert_eq!(agent_key(&DatabaseType::H2, None), Some("h2"));
+        assert_eq!(agent_key(&DatabaseType::H2, Some("h2")), Some("h2"));
+        assert_eq!(agent_key(&DatabaseType::H2, Some("h2-legacy")), Some("h2-legacy"));
+        assert!(driver_store_entries().any(|(key, label)| key == "h2-legacy" && label == "H2 2.1 Legacy"));
+    }
+}
diff --git a/crates/dbx-core/src/agent_connection.rs b/crates/dbx-core/src/agent_connection.rs
new file mode 100644
index 0000000..21216d5
--- /dev/null
+++ b/crates/dbx-core/src/agent_connection.rs
@@ -0,0 +1,1066 @@
+use percent_encoding::{percent_decode_str, utf8_percent_encode, NON_ALPHANUMERIC};
+
+use crate::models::connection::{ConnectionConfig, DatabaseType};
+use crate::path_utils::expand_tilde;
+
+const OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_KEY: &str = "compatibleOjdbcVersion";
+const OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_PARAM: &str = "compatibleOjdbcVersion=8";
+
+pub fn agent_connect_params(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> serde_json::Value {
+    let agent_database = if config.db_type == DatabaseType::MongoDb {
+        mongo_agent_database(config, database)
+    } else if matches!(config.db_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle) {
+        oracle_agent_database(config, database)
+    } else if matches!(config.db_type, DatabaseType::Kingbase | DatabaseType::Highgo | DatabaseType::Vastbase) {
+        postgres_like_agent_database(config, database).to_string()
+    } else if is_h2_file_connection(config) {
+        h2_agent_database(config)
+    } else {
+        database.to_string()
+    };
+    let connection_string = if config.db_type == DatabaseType::MongoDb {
+        config.connection_url_with_host(host, port)
+    } else if config.db_type == DatabaseType::Oracle {
+        oracle_jdbc_connection_string(config, host, port, database)
+    } else if config.db_type == DatabaseType::OceanbaseOracle {
+        oceanbase_oracle_jdbc_connection_string(config, host, port, database)
+    } else if matches!(config.db_type, DatabaseType::Kingbase | DatabaseType::Highgo | DatabaseType::Vastbase) {
+        postgres_like_agent_jdbc_connection_string(config, host, port, database)
+    } else if config.db_type == DatabaseType::SapHana {
+        sap_hana_jdbc_connection_string(config, host, port, database)
+    } else if matches!(config.db_type, DatabaseType::Trino | DatabaseType::PrestoSql) {
+        trino_like_jdbc_connection_string(config, host, port, database)
+    } else if config.db_type == DatabaseType::H2 {
+        h2_agent_jdbc_connection_string(config)
+    } else {
+        config.connection_string.as_deref().unwrap_or("").to_string()
+    };
+    let etcd_endpoints =
+        if config.db_type == DatabaseType::Etcd { normalize_etcd_endpoints(config, host, port) } else { String::new() };
+    let zookeeper_connect_string = if config.db_type == DatabaseType::ZooKeeper {
+        normalize_zookeeper_connect_string(config, host, port)
+    } else {
+        String::new()
+    };
+    let (agent_host, agent_port) = if is_h2_file_connection(config) { ("", 0) } else { (host, port) };
+
+    serde_json::json!({
+        "host": agent_host,
+        "port": agent_port,
+        "database": agent_database,
+        "username": config.username,
+        "password": config.password,
+        "sysdba": oracle_uses_sysdba(config),
+        "url_params": config.url_params.as_deref().unwrap_or(""),
+        "connection_string": connection_string,
+        "ssl": config.ssl,
+        "ca_cert_path": config.ca_cert_path,
+        "client_cert_path": config.client_cert_path,
+        "client_key_path": config.client_key_path,
+        "etcd_endpoints": etcd_endpoints,
+        "zookeeper_connect_string": zookeeper_connect_string,
+        "gbase_server": config.gbase_server,
+        "informix_server": config.informix_server,
+        "jdbc_driver_class": config.jdbc_driver_class.as_deref().unwrap_or(""),
+        "jdbc_driver_paths": &config.jdbc_driver_paths,
+    })
+}
+
+fn oracle_uses_sysdba(config: &ConnectionConfig) -> bool {
+    config.sysdba || (config.db_type == DatabaseType::Oracle && config.username.trim().eq_ignore_ascii_case("sys"))
+}
+
+fn oracle_agent_database(config: &ConnectionConfig, database: &str) -> String {
+    let database = database.trim();
+    if database.is_empty() || !oracle_uses_sysdba(config) || database.to_uppercase().starts_with("SYSDBA:") {
+        return database.to_string();
+    }
+    format!("SYSDBA:{database}")
+}
+
+fn mongo_agent_database(config: &ConnectionConfig, database: &str) -> String {
+    if let Some(database) = non_empty_database(database) {
+        return database.to_string();
+    }
+    if let Some(database) = config.database.as_deref().and_then(non_empty_database) {
+        return database.to_string();
+    }
+    if let Some(database) = config.connection_string.as_deref().and_then(mongo_uri_database) {
+        return database;
+    }
+    "admin".to_string()
+}
+
+fn non_empty_database(database: &str) -> Option<&str> {
+    let database = database.trim();
+    (!database.is_empty()).then_some(database)
+}
+
+pub fn is_h2_file_connection(config: &ConnectionConfig) -> bool {
+    config.db_type == DatabaseType::H2
+        && (config.connection_string.as_deref().is_some_and(is_h2_file_jdbc_url)
+            || (config.port == 0 && !config.host.trim().is_empty()))
+}
+
+pub fn h2_agent_jdbc_connection_string(config: &ConnectionConfig) -> String {
+    if let Some(connection_string) =
+        config.connection_string.as_deref().map(str::trim).filter(|value| !value.is_empty())
+    {
+        if is_h2_file_jdbc_url(connection_string) {
+            return normalize_h2_file_jdbc_url(connection_string).unwrap_or_else(|| connection_string.to_string());
+        }
+        return connection_string.to_string();
+    }
+    if is_h2_file_connection(config) {
+        return h2_file_jdbc_url(&config.host);
+    }
+    String::new()
+}
+
+fn h2_agent_database(config: &ConnectionConfig) -> String {
+    let jdbc_url = h2_agent_jdbc_connection_string(config);
+    jdbc_url.strip_prefix("jdbc:h2:").unwrap_or(&jdbc_url).to_string()
+}
+
+pub fn h2_file_jdbc_url(path: &str) -> String {
+    let url = h2_file_jdbc_url_base(path);
+    format!("{url};AUTO_SERVER=TRUE")
+}
+
+fn h2_file_jdbc_url_base(path: &str) -> String {
+    let path = h2_jdbc_file_base_path(path);
+    format!("jdbc:h2:file:{path}")
+}
+
+pub fn h2_jdbc_file_base_path(path: &str) -> String {
+    let path = expand_tilde(path.trim());
+    let lower = path.to_ascii_lowercase();
+    for suffix in [".mv.db", ".h2.db"] {
+        if lower.ends_with(suffix) {
+            return path[..path.len() - suffix.len()].to_string();
+        }
+    }
+    path
+}
+
+pub fn h2_file_path_from_jdbc_url(connection_string: &str) -> Option<String> {
+    let connection_string = connection_string.trim();
+    h2_file_jdbc_url_prefix(connection_string).map(|prefix| {
+        let raw_path = connection_string[prefix.len()..].split(';').next().unwrap_or("");
+        if prefix.eq_ignore_ascii_case("jdbc:h2:split:") {
+            raw_path
+                .split_once(':')
+                .and_then(|(block_size, path)| block_size.chars().all(|ch| ch.is_ascii_digit()).then_some(path))
+                .unwrap_or(raw_path)
+                .to_string()
+        } else {
+            raw_path.to_string()
+        }
+    })
+}
+
+fn h2_file_jdbc_url_prefix(connection_string: &str) -> Option<&'static str> {
+    ["jdbc:h2:file:", "jdbc:h2:split:"]
+        .into_iter()
+        .find(|prefix| connection_string.get(..prefix.len()).is_some_and(|value| value.eq_ignore_ascii_case(prefix)))
+}
+
+fn normalize_h2_file_jdbc_url(connection_string: &str) -> Option<String> {
+    let connection_string = connection_string.trim();
+    let prefix = "jdbc:h2:file:";
+    if !connection_string.get(..prefix.len())?.eq_ignore_ascii_case(prefix) {
+        return None;
+    }
+    let rest = &connection_string[prefix.len()..];
+    let (path, options) = rest.split_once(';').map(|(path, options)| (path, Some(options))).unwrap_or((rest, None));
+    let mut url = if options.is_some() { h2_file_jdbc_url_base(path) } else { h2_file_jdbc_url(path) };
+    if let Some(options) = options {
+        url.push(';');
+        url.push_str(options);
+    }
+    Some(url)
+}
+
+fn is_h2_file_jdbc_url(connection_string: &str) -> bool {
+    h2_file_jdbc_url_prefix(connection_string.trim()).is_some()
+}
+
+fn mongo_uri_database(uri: &str) -> Option<String> {
+    let rest = uri.strip_prefix("mongodb://").or_else(|| uri.strip_prefix("mongodb+srv://"))?;
+    let (_, after_hosts) = rest.split_once('/')?;
+    let database = after_hosts.split(['?', '#']).next()?.trim();
+    if database.is_empty() {
+        return None;
+    }
+    Some(percent_decode_str(database).decode_utf8_lossy().into_owned())
+}
+
+pub fn mongo_legacy_error_with_auth_hint(err: &str) -> String {
+    let Some(source_start) = err.find("source='") else {
+        return err.to_string();
+    };
+    if !err.contains("Exception authenticating MongoCredential") || err.contains("Current authentication database:") {
+        return err.to_string();
+    }
+    let source = &err[source_start + "source='".len()..];
+    let Some(source_end) = source.find('\'') else {
+        return err.to_string();
+    };
+    let source = &source[..source_end];
+    format!(
+        "{err}\n\nCurrent authentication database: {source}. If this user was created in admin, set Authentication database to admin or add authSource=admin to URL params."
+    )
+}
+
+pub fn mongo_uses_legacy_driver(config: &ConnectionConfig) -> bool {
+    config.driver_profile.as_deref().is_some_and(|profile| {
+        profile.eq_ignore_ascii_case("mongodb-legacy")
+            || profile.eq_ignore_ascii_case("mongodb_legacy")
+            || profile.eq_ignore_ascii_case("legacy")
+    })
+}
+
+pub fn should_retry_mongo_with_legacy_driver(err: &str) -> bool {
+    let normalized = err.to_lowercase();
+    if normalized.contains("wire version") {
+        return true;
+    }
+
+    let looks_like_handshake_io_error = normalized.contains("unexpected end of file")
+        || normalized.contains("connection reset by peer")
+        || normalized.contains("broken pipe");
+    looks_like_handshake_io_error
+        && (normalized.contains("server selection timeout")
+            || normalized.contains("no available servers")
+            || normalized.contains("topology:")
+            || normalized.contains("i/o error"))
+}
+
+pub fn oracle_error_with_driver_hint(config: &ConnectionConfig, err: &str) -> String {
+    if config.db_type != DatabaseType::Oracle {
+        return err.to_string();
+    }
+
+    let normalized = err.to_lowercase();
+    if !normalized.contains("ora-12541") && !err.contains("没有监听程序") {
+        return err.to_string();
+    }
+
+    format!("{err}\n\nOracle listener was not reachable. If the host and port are correct, try switching between Service Name and SID.")
+}
+
+pub fn oracle_alternate_connect_configs(config: &ConnectionConfig, err: &str) -> Vec<ConnectionConfig> {
+    if config.db_type != DatabaseType::Oracle {
+        return Vec::new();
+    }
+    if config.connection_string.as_deref().is_some_and(|value| !value.trim().is_empty()) {
+        return Vec::new();
+    }
+    if !oracle_listener_error_can_retry(err) {
+        return Vec::new();
+    }
+
+    let database = config.effective_database().unwrap_or("").trim();
+    if database.is_empty() {
+        return Vec::new();
+    }
+
+    let host = config.host.trim();
+    let port = config.port;
+    let current_url = oracle_jdbc_connection_string(config, host, port, database);
+    let service_url = oracle_service_jdbc_url(host, port, database);
+    let sid_url = oracle_sid_jdbc_url(host, port, database);
+    let legacy_service_url = oracle_legacy_service_jdbc_url(host, port, database);
+    let descriptor_service_url = oracle_descriptor_jdbc_url(host, port, database, "SERVICE_NAME");
+    let descriptor_sid_url = oracle_descriptor_jdbc_url(host, port, database, "SID");
+
+    let normalized = err.to_lowercase();
+    let candidates = if normalized.contains("ora-12505") {
+        vec![service_url, descriptor_service_url, legacy_service_url]
+    } else if normalized.contains("ora-12514") {
+        vec![sid_url, descriptor_sid_url, legacy_service_url]
+    } else {
+        match config.oracle_connection_type.as_deref() {
+            Some("sid") => vec![service_url, legacy_service_url, descriptor_sid_url, descriptor_service_url],
+            _ => vec![sid_url, legacy_service_url, descriptor_service_url, descriptor_sid_url],
+        }
+    };
+
+    let mut urls = Vec::new();
+    for url in candidates {
+        if url == current_url || urls.iter().any(|seen| seen == &url) {
+            continue;
+        }
+        urls.push(url);
+    }
+
+    urls.into_iter()
+        .map(|url| {
+            let mut retry = config.clone();
+            retry.oracle_connection_type = None;
+            retry.connection_string = Some(url);
+            retry
+        })
+        .collect()
+}
+
+fn oracle_jdbc_connection_string(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> String {
+    if let Some(connection_string) = config.connection_string.as_deref().filter(|value| !value.trim().is_empty()) {
+        let connection_string = connection_string.trim();
+        if host == config.host && port == config.port {
+            return connection_string.to_string();
+        }
+        return crate::models::connection::rewrite_jdbc_url_host(connection_string, host, port);
+    }
+
+    let database = database.trim();
+    if database.is_empty() {
+        return String::new();
+    }
+
+    if config.oracle_connection_type.as_deref() == Some("sid") {
+        oracle_sid_jdbc_url(host, port, database)
+    } else {
+        oracle_service_jdbc_url(host, port, database)
+    }
+}
+
+fn oracle_listener_error_can_retry(err: &str) -> bool {
+    let normalized = err.to_lowercase();
+    normalized.contains("ora-12505")
+        || normalized.contains("ora-12514")
+        || normalized.contains("ora-12541")
+        || normalized.contains("no listener")
+        || err.contains("没有监听程序")
+}
+
+fn oracle_service_jdbc_url(host: &str, port: u16, database: &str) -> String {
+    format!("jdbc:oracle:thin:@//{host}:{port}/{database}")
+}
+
+fn oracle_sid_jdbc_url(host: &str, port: u16, database: &str) -> String {
+    format!("jdbc:oracle:thin:@{host}:{port}:{database}")
+}
+
+fn oracle_legacy_service_jdbc_url(host: &str, port: u16, database: &str) -> String {
+    format!("jdbc:oracle:thin:@{host}:{port}/{database}")
+}
+
+fn oracle_descriptor_jdbc_url(host: &str, port: u16, database: &str, key: &str) -> String {
+    format!("jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST={host})(PORT={port}))(CONNECT_DATA=({key}={database})))")
+}
+
+fn oceanbase_oracle_jdbc_connection_string(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> String {
+    if let Some(connection_string) = config.connection_string.as_deref().filter(|value| !value.trim().is_empty()) {
+        let connection_string = connection_string.trim();
+        let url = if host == config.host && port == config.port {
+            connection_string.to_string()
+        } else {
+            crate::models::connection::rewrite_jdbc_url_host(connection_string, host, port)
+        };
+        if url_has_query_key(&url, OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_KEY) {
+            return url;
+        }
+        return append_agent_url_params(url, Some(OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_PARAM));
+    }
+
+    let database = database.trim();
+    if database.is_empty() {
+        return String::new();
+    }
+
+    let base = format!("jdbc:oceanbase://{host}:{port}/{database}");
+    append_agent_url_params(base, Some(&oceanbase_oracle_jdbc_params(config)))
+}
+
+fn oceanbase_oracle_jdbc_params(config: &ConnectionConfig) -> String {
+    let user_params = normalize_agent_url_params(config.url_params.as_deref());
+    let mut params = Vec::new();
+    if !user_params.is_empty() {
+        params.push(user_params.to_string());
+    }
+    if !url_params_has_key(user_params, OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_KEY) {
+        params.push(OCEANBASE_ORACLE_COMPATIBLE_OJDBC_VERSION_PARAM.to_string());
+    }
+    params.join("&")
+}
+
+fn postgres_like_agent_jdbc_connection_string(
+    config: &ConnectionConfig,
+    host: &str,
+    port: u16,
+    database: &str,
+) -> String {
+    let scheme = match config.db_type {
+        DatabaseType::Kingbase => "kingbase8",
+        DatabaseType::Highgo => "highgo",
+        DatabaseType::Vastbase => "vastbase",
+        _ => unreachable!("postgres-like agent JDBC URL requested for {:?}", config.db_type),
+    };
+    let database = postgres_like_agent_database(config, database);
+    let base = format!("jdbc:{scheme}://{host}:{port}/{database}");
+    append_agent_url_params(base, config.url_params.as_deref())
+}
+
+fn postgres_like_agent_database<'a>(config: &'a ConnectionConfig, database: &'a str) -> &'a str {
+    let database = database.trim();
+    if !database.is_empty() {
+        return database;
+    }
+    // Vastbase/PostgreSQL-compatible JDBC drivers can reject an empty catalog path.
+    config.effective_database().unwrap_or("")
+}
+
+pub fn oracle_alternate_connect_config(config: &ConnectionConfig, err: &str) -> Option<ConnectionConfig> {
+    oracle_alternate_connect_configs(config, err).into_iter().next()
+}
+
+pub fn oracle_alternate_connect_config_labels(configs: &[ConnectionConfig]) -> Vec<String> {
+    configs
+        .iter()
+        .map(|config| {
+            config
+                .connection_string
+                .as_deref()
+                .map(oracle_connection_string_label)
+                .unwrap_or_else(|| config.oracle_connection_type.as_deref().unwrap_or("service_name").to_string())
+        })
+        .collect()
+}
+
+fn oracle_connection_string_label(connection_string: &str) -> String {
+    let upper = connection_string.to_ascii_uppercase();
+    if upper.contains("(SERVICE_NAME=") {
+        "descriptor service name".to_string()
+    } else if upper.contains("(SID=") {
+        "descriptor SID".to_string()
+    } else if connection_string.starts_with("jdbc:oracle:thin:@//") {
+        "service name".to_string()
+    } else if connection_string.contains(':') && !connection_string.contains('/') {
+        "SID".to_string()
+    } else {
+        "legacy service name".to_string()
+    }
+}
+
+fn sap_hana_jdbc_connection_string(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> String {
+    let database = database.trim();
+    let params = config.url_params.as_deref().unwrap_or("").trim().trim_start_matches('?');
+    let has_database_name = params
+        .split(['&', ';'])
+        .any(|part| part.split_once('=').map(|(key, _)| key.eq_ignore_ascii_case("databaseName")).unwrap_or(false));
+
+    let mut query_parts = Vec::new();
+    if !database.is_empty() && !has_database_name {
+        query_parts.push(format!("databaseName={}", utf8_percent_encode(database, NON_ALPHANUMERIC)));
+    }
+    if !params.is_empty() {
+        query_parts.push(params.to_string());
+    }
+
+    if query_parts.is_empty() {
+        format!("jdbc:sap://{host}:{port}")
+    } else {
+        format!("jdbc:sap://{host}:{port}/?{}", query_parts.join("&"))
+    }
+}
+
+pub fn trino_like_jdbc_connection_string(config: &ConnectionConfig, host: &str, port: u16, database: &str) -> String {
+    let jdbc_scheme = match config.db_type {
+        DatabaseType::PrestoSql => "presto",
+        _ => "trino",
+    };
+    let jdbc_prefix = format!("jdbc:{jdbc_scheme}:");
+    let base = config
+        .connection_string
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| value.get(..jdbc_prefix.len()).is_some_and(|prefix| prefix.eq_ignore_ascii_case(&jdbc_prefix)))
+        .map(|connection_string| {
+            if host == config.host && port == config.port {
+                connection_string.to_string()
+            } else {
+                crate::models::connection::rewrite_jdbc_url_host(connection_string, host, port)
+            }
+        })
+        .unwrap_or_else(|| {
+            let database = database.trim();
+            if database.is_empty() {
+                format!("jdbc:{jdbc_scheme}://{host}:{port}")
+            } else {
+                format!("jdbc:{jdbc_scheme}://{host}:{port}/{database}")
+            }
+        });
+
+    let params = trino_agent_jdbc_params(config, &base);
+    if params.is_empty() {
+        base
+    } else {
+        append_agent_url_params(base, Some(&params))
+    }
+}
+
+fn trino_agent_jdbc_params(config: &ConnectionConfig, base: &str) -> String {
+    let user_params = normalize_agent_url_params(config.url_params.as_deref());
+    let mut params = Vec::new();
+    if !user_params.is_empty() {
+        params.push(user_params.to_string());
+    }
+    if config.ssl && !url_params_has_key(user_params, "SSL") && !url_has_query_key(base, "SSL") {
+        params.push("SSL=true".to_string());
+    }
+    params.join("&")
+}
+
+fn normalize_etcd_endpoints(config: &ConnectionConfig, host: &str, port: u16) -> String {
+    let endpoints = config.etcd_endpoints.trim();
+    if !endpoints.is_empty() {
+        return endpoints.to_string();
+    }
+    let scheme = if config.ssl { "https" } else { "http" };
+    format!("{scheme}://{host}:{port}")
+}
+
+fn normalize_zookeeper_connect_string(config: &ConnectionConfig, host: &str, port: u16) -> String {
+    config
+        .connection_string
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string)
+        .unwrap_or_else(|| format!("{host}:{port}"))
+}
+
+fn normalize_agent_url_params(params: Option<&str>) -> &str {
+    params.unwrap_or("").trim().trim_start_matches(['?', '&'])
+}
+
+fn url_has_query_key(url: &str, key: &str) -> bool {
+    let Some((_, query)) = url.split_once('?') else {
+        return false;
+    };
+    let query = query.split('#').next().unwrap_or(query);
+    url_params_has_key(query, key)
+}
+
+fn url_params_has_key(params: &str, key: &str) -> bool {
+    params
+        .split(['&', ';'])
+        .filter_map(|part| {
+            let part = part.trim();
+            if part.is_empty() {
+                return None;
+            }
+            Some(part.split_once('=').map(|(param_key, _)| param_key).unwrap_or(part).trim())
+        })
+        .any(|param_key| param_key.eq_ignore_ascii_case(key))
+}
+
+fn append_agent_url_params(base: String, params: Option<&str>) -> String {
+    let params = normalize_agent_url_params(params);
+    if params.is_empty() {
+        return base;
+    }
+    let separator = if base.contains('?') { '&' } else { '?' };
+    format!("{base}{separator}{params}")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::models::connection::{
+        default_connect_timeout_secs, default_idle_timeout_secs, default_keepalive_interval_secs,
+        default_query_timeout_secs, default_redis_key_separator,
+    };
+
+    fn config(db_type: DatabaseType, database: Option<&str>) -> ConnectionConfig {
+        ConnectionConfig {
+            id: "conn".to_string(),
+            name: "Connection".to_string(),
+            db_type,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 3306,
+            username: "user".to_string(),
+            password: "secret".to_string(),
+            database: database.map(str::to_string),
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: default_connect_timeout_secs(),
+            query_timeout_secs: default_query_timeout_secs(),
+            idle_timeout_secs: default_idle_timeout_secs(),
+            keepalive_interval_secs: default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    #[test]
+    fn mongodb_database_falls_back_to_uri_database() {
+        let mut cfg = config(DatabaseType::MongoDb, None);
+        cfg.connection_string = Some("mongodb://user:secret@127.0.0.1:27017/app_db?authSource=admin".to_string());
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 27017, "");
+
+        assert_eq!(params["database"], "app_db");
+    }
+
+    #[test]
+    fn h2_file_path_builds_jdbc_file_url_and_strips_database_suffix() {
+        assert_eq!(h2_file_jdbc_url("/tmp/app.mv.db"), "jdbc:h2:file:/tmp/app;AUTO_SERVER=TRUE");
+        assert_eq!(h2_file_jdbc_url("/tmp/App.MV.DB"), "jdbc:h2:file:/tmp/App;AUTO_SERVER=TRUE");
+        assert_eq!(h2_file_jdbc_url("/tmp/legacy.h2.db"), "jdbc:h2:file:/tmp/legacy;AUTO_SERVER=TRUE");
+        assert_eq!(h2_file_jdbc_url("/tmp/app"), "jdbc:h2:file:/tmp/app;AUTO_SERVER=TRUE");
+    }
+
+    #[test]
+    fn h2_file_connection_passes_jdbc_file_url_to_agent() {
+        let mut cfg = config(DatabaseType::H2, None);
+        cfg.host = "/tmp/app.mv.db".to_string();
+        cfg.port = 0;
+
+        let params = agent_connect_params(&cfg, "/tmp/app.mv.db", 0, "");
+
+        assert_eq!(params["host"], "");
+        assert_eq!(params["port"], 0);
+        assert_eq!(params["database"], "file:/tmp/app;AUTO_SERVER=TRUE");
+        assert_eq!(params["connection_string"], "jdbc:h2:file:/tmp/app;AUTO_SERVER=TRUE");
+    }
+
+    #[test]
+    fn h2_file_connection_normalizes_existing_jdbc_file_url_and_preserves_options() {
+        let mut cfg = config(DatabaseType::H2, None);
+        cfg.connection_string = Some("jdbc:h2:file:/tmp/app.mv.db;AUTO_SERVER=TRUE".to_string());
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 9092, "test");
+
+        assert_eq!(params["host"], "");
+        assert_eq!(params["port"], 0);
+        assert_eq!(params["database"], "file:/tmp/app;AUTO_SERVER=TRUE");
+        assert_eq!(params["connection_string"], "jdbc:h2:file:/tmp/app;AUTO_SERVER=TRUE");
+    }
+
+    #[test]
+    fn h2_split_connection_string_is_treated_as_file_mode() {
+        let mut cfg = config(DatabaseType::H2, None);
+        cfg.connection_string = Some("jdbc:h2:split:28:C:/dbx-test/h2/sample-db;AUTO_SERVER=TRUE".to_string());
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 9092, "test");
+
+        assert_eq!(
+            h2_file_path_from_jdbc_url(cfg.connection_string.as_deref().unwrap()).as_deref(),
+            Some("C:/dbx-test/h2/sample-db")
+        );
+        assert_eq!(params["host"], "");
+        assert_eq!(params["port"], 0);
+        assert_eq!(params["database"], "split:28:C:/dbx-test/h2/sample-db;AUTO_SERVER=TRUE");
+        assert_eq!(params["connection_string"], "jdbc:h2:split:28:C:/dbx-test/h2/sample-db;AUTO_SERVER=TRUE");
+    }
+
+    #[test]
+    fn h2_tcp_connection_keeps_empty_agent_connection_string() {
+        let mut cfg = config(DatabaseType::H2, Some("test"));
+        cfg.host = "127.0.0.1".to_string();
+        cfg.port = 9092;
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 9092, "test");
+
+        assert_eq!(params["host"], "127.0.0.1");
+        assert_eq!(params["port"], 9092);
+        assert_eq!(params["database"], "test");
+        assert_eq!(params["connection_string"], "");
+    }
+
+    #[test]
+    fn vastbase_agent_url_defaults_to_postgres_database_when_empty() {
+        let cfg = config(DatabaseType::Vastbase, Some(""));
+
+        let params = agent_connect_params(&cfg, "vastbase.example.com", 5432, "");
+
+        assert_eq!(params["database"], "postgres");
+        assert_eq!(params["connection_string"], "jdbc:vastbase://vastbase.example.com:5432/postgres");
+    }
+
+    #[test]
+    fn zookeeper_agent_params_preserve_configured_connect_string() {
+        let mut cfg = config(DatabaseType::ZooKeeper, None);
+        cfg.connection_string = Some("zk-1:2181,zk-2:2181/app".to_string());
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 2181, "");
+
+        assert_eq!(params["connection_string"], "zk-1:2181,zk-2:2181/app");
+        assert_eq!(params["zookeeper_connect_string"], "zk-1:2181,zk-2:2181/app");
+    }
+
+    #[test]
+    fn zookeeper_agent_params_fall_back_to_host_port_connect_string() {
+        let cfg = config(DatabaseType::ZooKeeper, None);
+
+        let params = agent_connect_params(&cfg, "zk.local", 2281, "");
+
+        assert_eq!(params["connection_string"], "");
+        assert_eq!(params["zookeeper_connect_string"], "zk.local:2281");
+    }
+
+    #[test]
+    fn mongo_auth_hint_preserves_original_error() {
+        let err = "Agent RPC error: Exception authenticating MongoCredential{mechanism=SCRAM-SHA-1, userName='rwuser', source='admin'}";
+
+        let hinted = mongo_legacy_error_with_auth_hint(err);
+
+        assert!(hinted.starts_with(err));
+        assert!(hinted.contains("Current authentication database: admin"));
+    }
+
+    #[test]
+    fn oracle_listener_error_adds_driver_version_hint_for_default_profile() {
+        let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
+        cfg.driver_profile = Some("oracle".to_string());
+        let err = "Agent RPC error (-1): ORA-12541: TNS:no listener";
+
+        let hinted = oracle_error_with_driver_hint(&cfg, err);
+
+        assert!(hinted.starts_with(err));
+        assert!(hinted.contains("Service Name"));
+        assert!(hinted.contains("SID"));
+    }
+
+    #[test]
+    fn oracle_listener_error_hint_skips_non_oracle_databases() {
+        let err = "Agent RPC error (-1): ORA-12541: TNS:no listener";
+        let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
+
+        assert!(oracle_error_with_driver_hint(&cfg, err).contains("Service Name"));
+
+        cfg.db_type = DatabaseType::OceanbaseOracle;
+        cfg.driver_profile = None;
+        assert_eq!(oracle_error_with_driver_hint(&cfg, err), err);
+    }
+
+    #[test]
+    fn oracle_url_uses_sid_or_service_name() {
+        let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
+        cfg.oracle_connection_type = Some("sid".to_string());
+
+        let sid = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCL");
+        assert_eq!(sid["connection_string"], "jdbc:oracle:thin:@oracle.example.com:1521:ORCL");
+
+        cfg.oracle_connection_type = Some("service_name".to_string());
+        let service = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCL");
+        assert_eq!(service["connection_string"], "jdbc:oracle:thin:@//oracle.example.com:1521/ORCL");
+    }
+
+    #[test]
+    fn oracle_sys_user_connects_as_sysdba_for_agent_protocol() {
+        let mut cfg = config(DatabaseType::Oracle, Some("ORCLPDB1"));
+        cfg.username = "SYS".to_string();
+        cfg.oracle_connection_type = Some("service_name".to_string());
+
+        let params = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCLPDB1");
+
+        assert_eq!(params["database"], "SYSDBA:ORCLPDB1");
+        assert_eq!(params["sysdba"], true);
+        assert_eq!(params["connection_string"], "jdbc:oracle:thin:@//oracle.example.com:1521/ORCLPDB1");
+    }
+
+    #[test]
+    fn oracle_sysdba_checkbox_connects_as_sysdba_for_agent_protocol() {
+        let mut cfg = config(DatabaseType::Oracle, Some("ORCLPDB1"));
+        cfg.username = "system".to_string();
+        cfg.sysdba = true;
+
+        let params = agent_connect_params(&cfg, "oracle.example.com", 1521, "ORCLPDB1");
+
+        assert_eq!(params["database"], "SYSDBA:ORCLPDB1");
+        assert_eq!(params["sysdba"], true);
+    }
+
+    #[test]
+    fn oceanbase_oracle_uses_oceanbase_jdbc_connection_string_for_agent_protocol() {
+        let mut cfg = config(DatabaseType::OceanbaseOracle, Some("sys"));
+        cfg.host = "oceanbase.example.com".to_string();
+        cfg.port = 2881;
+
+        let params = agent_connect_params(&cfg, "oceanbase.example.com", 2881, "sys");
+
+        assert_eq!(params["database"], "sys");
+        assert_eq!(params["sysdba"], false);
+        assert_eq!(
+            params["connection_string"],
+            "jdbc:oceanbase://oceanbase.example.com:2881/sys?compatibleOjdbcVersion=8"
+        );
+    }
+
+    #[test]
+    fn oceanbase_oracle_jdbc_url_appends_params_and_rewrites_forwarded_host() {
+        let mut cfg = config(DatabaseType::OceanbaseOracle, Some("sys"));
+        cfg.host = "oceanbase.example.com".to_string();
+        cfg.port = 2881;
+        cfg.url_params = Some("useSSL=false".to_string());
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 12881, "sys");
+
+        assert_eq!(
+            params["connection_string"],
+            "jdbc:oceanbase://127.0.0.1:12881/sys?useSSL=false&compatibleOjdbcVersion=8"
+        );
+    }
+
+    #[test]
+    fn oceanbase_oracle_jdbc_url_keeps_explicit_compatible_ojdbc_version() {
+        let mut cfg = config(DatabaseType::OceanbaseOracle, Some("sys"));
+        cfg.host = "oceanbase.example.com".to_string();
+        cfg.port = 2881;
+        cfg.url_params = Some("compatibleOjdbcVersion=6&useSSL=false".to_string());
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 12881, "sys");
+
+        assert_eq!(
+            params["connection_string"],
+            "jdbc:oceanbase://127.0.0.1:12881/sys?compatibleOjdbcVersion=6&useSSL=false"
+        );
+    }
+
+    #[test]
+    fn oceanbase_oracle_custom_jdbc_url_gets_compatible_ojdbc_version_and_forwarded_host() {
+        let mut cfg = config(DatabaseType::OceanbaseOracle, Some("sys"));
+        cfg.host = "oceanbase.example.com".to_string();
+        cfg.port = 2881;
+        cfg.connection_string = Some("jdbc:oceanbase://oceanbase.example.com:2881/sys?useSSL=false".to_string());
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 12881, "sys");
+
+        assert_eq!(
+            params["connection_string"],
+            "jdbc:oceanbase://127.0.0.1:12881/sys?useSSL=false&compatibleOjdbcVersion=8"
+        );
+    }
+
+    #[test]
+    fn oracle_url_preserves_custom_jdbc_descriptor_and_rewrites_host_port() {
+        let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
+        cfg.host = "oracle.example.com".to_string();
+        cfg.port = 1521;
+        cfg.connection_string = Some(
+            "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=oracle.example.com)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=ORCL)))"
+                .to_string(),
+        );
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 11521, "ORCL");
+
+        assert_eq!(
+            params["connection_string"],
+            "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=127.0.0.1)(PORT=11521))(CONNECT_DATA=(SERVICE_NAME=ORCL)))"
+        );
+    }
+
+    #[test]
+    fn oracle_url_preserves_custom_jdbc_descriptor_without_forwarding() {
+        let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
+        cfg.host = "form-host.example.com".to_string();
+        cfg.port = 1521;
+        cfg.connection_string = Some(
+            "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=descriptor-host.example.com)(PORT=1522))(CONNECT_DATA=(SERVICE_NAME=ORCL)))"
+                .to_string(),
+        );
+
+        let params = agent_connect_params(&cfg, "form-host.example.com", 1521, "ORCL");
+
+        assert_eq!(
+            params["connection_string"],
+            "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=descriptor-host.example.com)(PORT=1522))(CONNECT_DATA=(SERVICE_NAME=ORCL)))"
+        );
+    }
+
+    #[test]
+    fn oracle_listener_errors_can_switch_descriptor() {
+        let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
+        cfg.driver_profile = Some("oracle".to_string());
+        cfg.oracle_connection_type = Some("service_name".to_string());
+
+        let retry = oracle_alternate_connect_config(&cfg, "ORA-12514: listener does not know service").unwrap();
+
+        assert_eq!(retry.connection_string.as_deref(), Some("jdbc:oracle:thin:@127.0.0.1:3306:ORCL"));
+        assert!(oracle_alternate_connect_config(&retry, "ORA-01017: invalid username/password").is_none());
+        assert!(oracle_alternate_connect_config(&cfg, "ORA-12541: TNS:no listener").is_some());
+    }
+
+    #[test]
+    fn oracle_custom_connection_string_skips_alternate_descriptor_retry() {
+        let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
+        cfg.driver_profile = Some("oracle".to_string());
+        cfg.oracle_connection_type = Some("service_name".to_string());
+        cfg.connection_string = Some("jdbc:oracle:thin:@//oracle.example.com:1521/ORCL".to_string());
+
+        assert!(oracle_alternate_connect_config(&cfg, "ORA-12514: listener does not know service").is_none());
+    }
+
+    #[test]
+    fn oracle_no_listener_errors_try_common_jdbc_url_variants() {
+        let mut cfg = config(DatabaseType::Oracle, Some("ORCL"));
+        cfg.host = "oracle.example.com".to_string();
+        cfg.port = 1521;
+        cfg.driver_profile = Some("oracle".to_string());
+        cfg.oracle_connection_type = Some("service_name".to_string());
+
+        let retries = oracle_alternate_connect_configs(&cfg, "ORA-12541: TNS:no listener");
+        let urls: Vec<_> = retries.iter().filter_map(|retry| retry.connection_string.as_deref()).collect();
+
+        assert_eq!(
+            urls,
+            vec![
+                "jdbc:oracle:thin:@oracle.example.com:1521:ORCL",
+                "jdbc:oracle:thin:@oracle.example.com:1521/ORCL",
+                "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=oracle.example.com)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=ORCL)))",
+                "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=oracle.example.com)(PORT=1521))(CONNECT_DATA=(SID=ORCL)))",
+            ]
+        );
+    }
+
+    #[test]
+    fn sap_hana_url_includes_selected_database_and_params() {
+        let mut cfg = config(DatabaseType::SapHana, Some("TENANT1"));
+        cfg.url_params = Some("encrypt=true".to_string());
+
+        let params = agent_connect_params(&cfg, "hana.example.com", 30013, "TENANT1");
+
+        assert_eq!(params["connection_string"], "jdbc:sap://hana.example.com:30013/?databaseName=TENANT1&encrypt=true");
+    }
+
+    #[test]
+    fn trino_agent_url_uses_jdbc_scheme_without_ssl_by_default() {
+        let mut cfg = config(DatabaseType::Trino, Some("hive"));
+        cfg.host = "trino.example.com".to_string();
+        cfg.port = 8080;
+
+        let params = agent_connect_params(&cfg, "trino.example.com", 8080, "hive");
+
+        assert_eq!(params["connection_string"], "jdbc:trino://trino.example.com:8080/hive");
+        assert_eq!(params["ssl"], false);
+    }
+
+    #[test]
+    fn prestosql_jdbc_url_uses_presto_jdbc_scheme() {
+        let mut cfg = config(DatabaseType::PrestoSql, Some("hive/default"));
+        cfg.host = "presto.example.com".to_string();
+        cfg.port = 9090;
+
+        let params = agent_connect_params(&cfg, "presto.example.com", 9090, "hive/default");
+
+        assert_eq!(params["connection_string"], "jdbc:presto://presto.example.com:9090/hive/default");
+        assert_eq!(params["ssl"], false);
+    }
+
+    #[test]
+    fn prestosql_custom_jdbc_url_rewrites_forwarded_host() {
+        let mut cfg = config(DatabaseType::PrestoSql, Some("hive/default"));
+        cfg.host = "presto.internal".to_string();
+        cfg.port = 9090;
+        cfg.connection_string = Some("jdbc:presto://presto.internal:9090/hive/default?source=dbx".to_string());
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 19090, "hive/default");
+
+        assert_eq!(params["connection_string"], "jdbc:presto://127.0.0.1:19090/hive/default?source=dbx");
+    }
+
+    #[test]
+    fn trino_agent_url_appends_ssl_when_enabled() {
+        let mut cfg = config(DatabaseType::Trino, Some("hive"));
+        cfg.ssl = true;
+
+        let params = agent_connect_params(&cfg, "trino.example.com", 8443, "hive");
+
+        assert_eq!(params["connection_string"], "jdbc:trino://trino.example.com:8443/hive?SSL=true");
+    }
+
+    #[test]
+    fn trino_agent_url_preserves_ssl_verification_and_avoids_duplicate_ssl() {
+        let mut cfg = config(DatabaseType::Trino, Some("hive"));
+        cfg.ssl = true;
+        cfg.url_params = Some("ssl=true&SSLVerification=NONE".to_string());
+
+        let params = agent_connect_params(&cfg, "trino.example.com", 8443, "hive");
+
+        assert_eq!(
+            params["connection_string"],
+            "jdbc:trino://trino.example.com:8443/hive?ssl=true&SSLVerification=NONE"
+        );
+    }
+
+    #[test]
+    fn trino_agent_url_preserves_tls_store_params() {
+        let mut cfg = config(DatabaseType::Trino, Some("hive"));
+        cfg.ssl = true;
+        cfg.url_params = Some(
+            "SSLTrustStorePath=C:\\certs\\trino.jks&SSLTrustStorePassword=secret&SSLKeyStorePath=C:\\certs\\client.jks"
+                .to_string(),
+        );
+
+        let params = agent_connect_params(&cfg, "trino.example.com", 8443, "hive");
+
+        assert_eq!(
+            params["connection_string"],
+            "jdbc:trino://trino.example.com:8443/hive?SSLTrustStorePath=C:\\certs\\trino.jks&SSLTrustStorePassword=secret&SSLKeyStorePath=C:\\certs\\client.jks&SSL=true"
+        );
+    }
+
+    #[test]
+    fn trino_agent_url_uses_forwarded_host_and_port_with_params() {
+        let mut cfg = config(DatabaseType::Trino, Some("hive"));
+        cfg.host = "trino.internal".to_string();
+        cfg.port = 8443;
+        cfg.ssl = true;
+        cfg.url_params = Some("SSLVerification=NONE".to_string());
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 15443, "hive");
+
+        assert_eq!(params["connection_string"], "jdbc:trino://127.0.0.1:15443/hive?SSLVerification=NONE&SSL=true");
+    }
+
+    #[test]
+    fn trino_agent_custom_jdbc_url_rewrites_forwarded_host_and_preserves_query_ssl() {
+        let mut cfg = config(DatabaseType::Trino, Some("hive"));
+        cfg.host = "trino.internal".to_string();
+        cfg.port = 8443;
+        cfg.ssl = true;
+        cfg.connection_string = Some("jdbc:trino://trino.internal:8443/hive?SSL=true&source=dbx".to_string());
+        cfg.url_params = Some("SSLVerification=NONE".to_string());
+
+        let params = agent_connect_params(&cfg, "127.0.0.1", 15443, "hive");
+
+        assert_eq!(
+            params["connection_string"],
+            "jdbc:trino://127.0.0.1:15443/hive?SSL=true&source=dbx&SSLVerification=NONE"
+        );
+    }
+}
diff --git a/crates/dbx-core/src/agent_events.rs b/crates/dbx-core/src/agent_events.rs
new file mode 100644
index 0000000..162187f
--- /dev/null
+++ b/crates/dbx-core/src/agent_events.rs
@@ -0,0 +1,94 @@
+use serde::{Deserialize, Serialize};
+
+/// Events emitted by the agent loop, streamed to the frontend via SSE.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum AgentEvent {
+    /// A turn in the agent loop has started.
+    TurnStart { turn: u32 },
+    /// Text delta from the LLM response.
+    TextDelta { delta: String },
+    /// Reasoning/thinking delta (for models that support it).
+    ReasoningDelta { delta: String },
+    /// The LLM wants to call a tool.
+    ToolCallStart { tool_call_id: String, tool_name: String, args: serde_json::Value },
+    /// A tool execution has completed.
+    ToolCallEnd { tool_call_id: String, tool_name: String, result: serde_json::Value, is_error: bool },
+    /// A turn in the agent loop has ended.
+    TurnEnd { turn: u32 },
+    /// The agent loop has finished.
+    AgentEnd { input_tokens: Option<u32>, output_tokens: Option<u32> },
+    /// Context was compacted to stay within context window limits.
+    ContextCompacted {
+        summary: String,
+        summary_tokens: u32,
+        compacted_messages: usize,
+        estimated_before: u32,
+        estimated_after: u32,
+    },
+    /// An error occurred during the agent loop.
+    Error { message: String },
+}
+
+/// A unified tool call extracted from any provider's response.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolCall {
+    pub id: String,
+    pub name: String,
+    pub arguments: serde_json::Value,
+}
+
+/// Result of executing a tool.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolResult {
+    pub tool_call_id: String,
+    pub tool_name: String,
+    pub content: String,
+    pub is_error: bool,
+    /// Structured explain data (QueryResult) for explain_query tool results.
+    /// Set only by execute_explain_query; None for all other tools.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub explain_data: Option<serde_json::Value>,
+}
+
+/// Definition of a tool available to the agent.
+#[derive(Debug, Clone)]
+pub struct ToolDefinition {
+    pub name: &'static str,
+    pub description: &'static str,
+    pub parameters: serde_json::Value,
+    pub read_only: bool,
+    /// Whether this tool can be executed in parallel with other tools.
+    /// false = must run sequentially (e.g. execute_query).
+    pub parallel_ok: bool,
+}
+
+impl ToolDefinition {
+    /// Convert to OpenAI-compatible tool JSON for the API request.
+    pub fn to_openai_tool(&self) -> serde_json::Value {
+        serde_json::json!({
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": self.parameters
+            }
+        })
+    }
+    /// Convert to Anthropic-compatible tool JSON.
+    pub fn to_anthropic_tool(&self) -> serde_json::Value {
+        serde_json::json!({
+            "name": self.name,
+            "description": self.description,
+            "input_schema": self.parameters
+        })
+    }
+    /// Convert to Gemini-compatible function declaration.
+    pub fn to_gemini_tool(&self) -> serde_json::Value {
+        serde_json::json!({
+            "name": self.name,
+            "description": self.description,
+            "parameters": self.parameters
+        })
+    }
+}
diff --git a/crates/dbx-core/src/agent_explain.rs b/crates/dbx-core/src/agent_explain.rs
new file mode 100644
index 0000000..9db8d5a
--- /dev/null
+++ b/crates/dbx-core/src/agent_explain.rs
@@ -0,0 +1,75 @@
+use serde_json::Value;
+
+use crate::connection::{AppState, PoolKind};
+use crate::query_execution_sql::{is_safe_dameng_autotrace_sql, is_safe_explain_sql};
+
+pub async fn get_agent_explain_info_core(
+    state: &AppState,
+    connection_id: &str,
+    database: Option<&str>,
+    schema: Option<&str>,
+    sql: &str,
+    mode: Option<&str>,
+) -> Result<String, String> {
+    let mode = mode.unwrap_or("explain");
+    let safe = if mode.eq_ignore_ascii_case("autotrace") {
+        is_safe_dameng_autotrace_sql(sql)
+    } else {
+        is_safe_explain_sql(sql)
+    };
+    if !safe {
+        return Err("unsafe".to_string());
+    }
+
+    let database_for_pool = database.filter(|value| !value.trim().is_empty());
+    state.get_or_create_pool(connection_id, database_for_pool).await?;
+
+    let client = {
+        let connections = state.connections.read().await;
+        let pool = connections.get(connection_id).ok_or_else(|| "Connection not found".to_string())?;
+        match pool {
+            PoolKind::Agent(client) => client.clone(),
+            _ => return Err("Connection is not an agent-based connection".to_string()),
+        }
+    };
+
+    let timeout_secs = {
+        let configs = state.configs.read().await;
+        configs.get(connection_id).ok_or_else(|| "Connection config not found".to_string())?.query_timeout_secs
+    };
+
+    let params = serde_json::json!({
+        "sql": sql,
+        "database": database.unwrap_or_default(),
+        "schema": schema.unwrap_or_default(),
+        "timeoutSecs": timeout_secs as i64,
+        "mode": mode,
+    });
+    let mut client = client.lock().await;
+    let result: Value = client.get_explain_info(params).await?;
+    decode_agent_explain_result(result)
+}
+
+fn decode_agent_explain_result(result: Value) -> Result<String, String> {
+    match result {
+        Value::String(plan) => Ok(plan),
+        Value::Object(object) => Ok(object.get("plan").and_then(Value::as_str).unwrap_or_default().to_string()),
+        value => Err(format!("Unexpected result type from getExplainInfo: {value:?}")),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn decodes_string_and_object_agent_explain_results() {
+        assert_eq!(decode_agent_explain_result(Value::String("plan text".to_string())).unwrap(), "plan text");
+        assert_eq!(
+            decode_agent_explain_result(serde_json::json!({ "plan": "object plan", "has_actual_stats": false }))
+                .unwrap(),
+            "object plan"
+        );
+        assert!(decode_agent_explain_result(serde_json::json!(["unexpected"])).is_err());
+    }
+}
diff --git a/crates/dbx-core/src/agent_kv.rs b/crates/dbx-core/src/agent_kv.rs
new file mode 100644
index 0000000..8b279c6
--- /dev/null
+++ b/crates/dbx-core/src/agent_kv.rs
@@ -0,0 +1,420 @@
+use serde::{Deserialize, Serialize};
+
+use crate::connection::{AppState, PoolKind};
+use crate::db::agent_driver::{AgentCapability, AgentKvMethod};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvValue {
+    pub encoding: KvValueEncoding,
+    pub data: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum KvValueEncoding {
+    Utf8,
+    Base64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvKeyMetadata {
+    pub create_revision: Option<i64>,
+    pub mod_revision: Option<i64>,
+    pub version: Option<i64>,
+    pub lease: Option<i64>,
+    pub value_size: Option<u64>,
+    pub czxid: Option<i64>,
+    pub mzxid: Option<i64>,
+    pub pzxid: Option<i64>,
+    pub ctime: Option<i64>,
+    pub mtime: Option<i64>,
+    pub cversion: Option<i64>,
+    pub aversion: Option<i64>,
+    pub ephemeral_owner: Option<i64>,
+    pub data_length: Option<u64>,
+    pub num_children: Option<i64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvKeySummary {
+    pub key: String,
+    #[serde(flatten)]
+    pub metadata: KvKeyMetadata,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvListPrefixRequest {
+    pub prefix: String,
+    pub limit: usize,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub continuation: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub recursive: Option<bool>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvListPrefixResponse {
+    pub keys: Vec<KvKeySummary>,
+    pub continuation: Option<String>,
+    pub revision: Option<i64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvGetRequest {
+    pub key: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvGetResponse {
+    pub found: bool,
+    pub key: Option<String>,
+    pub value: Option<KvValue>,
+    pub metadata: Option<KvKeyMetadata>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvPutRequest {
+    pub key: String,
+    pub value: KvValue,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lease: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub write_mode: Option<KvWriteMode>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub create_mode: Option<KvCreateMode>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvPutOptions {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub lease: Option<i64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub write_mode: Option<KvWriteMode>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub create_mode: Option<KvCreateMode>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum KvWriteMode {
+    Upsert,
+    Create,
+    Update,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum KvCreateMode {
+    Persistent,
+    Ephemeral,
+    PersistentSequential,
+    EphemeralSequential,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvPutResponse {
+    pub revision: Option<i64>,
+    pub key: Option<String>,
+    pub created_key: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvDeleteRequest {
+    pub key: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct KvDeleteResponse {
+    pub deleted: u64,
+    pub revision: Option<i64>,
+}
+
+pub fn kv_list_prefix_params(prefix: &str, limit: usize, continuation: Option<&str>) -> serde_json::Value {
+    kv_list_prefix_params_with_options(prefix, limit, continuation, None)
+}
+
+pub fn kv_list_prefix_params_with_options(
+    prefix: &str,
+    limit: usize,
+    continuation: Option<&str>,
+    recursive: Option<bool>,
+) -> serde_json::Value {
+    serde_json::to_value(KvListPrefixRequest {
+        prefix: prefix.to_string(),
+        limit,
+        continuation: continuation.map(str::to_string),
+        recursive,
+    })
+    .expect("KV list prefix request should serialize")
+}
+
+pub fn kv_get_params(key: &str) -> serde_json::Value {
+    serde_json::to_value(KvGetRequest { key: key.to_string() }).expect("KV get request should serialize")
+}
+
+pub fn kv_put_params(key: &str, value: KvValue, lease: Option<i64>) -> serde_json::Value {
+    kv_put_params_with_options(key, value, KvPutOptions { lease, ..KvPutOptions::default() })
+}
+
+pub fn kv_put_params_with_options(key: &str, value: KvValue, options: KvPutOptions) -> serde_json::Value {
+    serde_json::to_value(KvPutRequest {
+        key: key.to_string(),
+        value,
+        lease: options.lease,
+        write_mode: options.write_mode,
+        create_mode: options.create_mode,
+    })
+    .expect("KV put request should serialize")
+}
+
+pub fn kv_delete_params(key: &str) -> serde_json::Value {
+    serde_json::to_value(KvDeleteRequest { key: key.to_string() }).expect("KV delete request should serialize")
+}
+
+pub async fn kv_list_prefix_core(
+    state: &AppState,
+    connection_id: &str,
+    prefix: &str,
+    limit: usize,
+    continuation: Option<&str>,
+) -> Result<KvListPrefixResponse, String> {
+    kv_list_prefix_core_with_options(state, connection_id, prefix, limit, continuation, None).await
+}
+
+pub async fn kv_list_prefix_core_with_options(
+    state: &AppState,
+    connection_id: &str,
+    prefix: &str,
+    limit: usize,
+    continuation: Option<&str>,
+    recursive: Option<bool>,
+) -> Result<KvListPrefixResponse, String> {
+    call_agent_kv(
+        state,
+        connection_id,
+        AgentKvMethod::ListPrefix,
+        kv_list_prefix_params_with_options(prefix, limit, continuation, recursive),
+    )
+    .await
+}
+
+pub async fn kv_get_core(state: &AppState, connection_id: &str, key: &str) -> Result<KvGetResponse, String> {
+    call_agent_kv(state, connection_id, AgentKvMethod::Get, kv_get_params(key)).await
+}
+
+pub async fn kv_put_core(
+    state: &AppState,
+    connection_id: &str,
+    key: &str,
+    value: KvValue,
+    lease: Option<i64>,
+) -> Result<KvPutResponse, String> {
+    kv_put_core_with_options(state, connection_id, key, value, KvPutOptions { lease, ..KvPutOptions::default() }).await
+}
+
+pub async fn kv_put_core_with_options(
+    state: &AppState,
+    connection_id: &str,
+    key: &str,
+    value: KvValue,
+    options: KvPutOptions,
+) -> Result<KvPutResponse, String> {
+    call_agent_kv(state, connection_id, AgentKvMethod::Put, kv_put_params_with_options(key, value, options)).await
+}
+
+pub async fn kv_delete_core(state: &AppState, connection_id: &str, key: &str) -> Result<KvDeleteResponse, String> {
+    call_agent_kv(state, connection_id, AgentKvMethod::Delete, kv_delete_params(key)).await
+}
+
+async fn ensure_agent_kv_pool(state: &AppState, connection_id: &str) -> Result<(), String> {
+    state.get_or_create_pool(connection_id, None).await.map(|_| ())
+}
+
+async fn call_agent_kv<T: serde::de::DeserializeOwned + Send + 'static>(
+    state: &AppState,
+    connection_id: &str,
+    method: AgentKvMethod,
+    params: serde_json::Value,
+) -> Result<T, String> {
+    ensure_agent_kv_pool(state, connection_id).await?;
+
+    let connections = state.connections.read().await;
+    let pool = connections.get(connection_id).ok_or("Connection not found")?;
+    match pool {
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            if !client.supports_capability(AgentCapability::Kv) {
+                return Err("Agent does not support key-value operations".to_string());
+            }
+            client.call_kv_method(method, params).await
+        }
+        _ => Err("Not an agent key-value connection".to_string()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn serializes_kv_list_prefix_params() {
+        assert_eq!(
+            kv_list_prefix_params("/config/", 100, Some("next-token")),
+            serde_json::json!({
+                "prefix": "/config/",
+                "limit": 100,
+                "continuation": "next-token"
+            })
+        );
+        assert_eq!(
+            kv_list_prefix_params("", 50, None),
+            serde_json::json!({
+                "prefix": "",
+                "limit": 50
+            })
+        );
+    }
+
+    #[test]
+    fn serializes_kv_list_prefix_params_with_recursive_false() {
+        assert_eq!(
+            kv_list_prefix_params_with_options("/app", 200, None, Some(false)),
+            serde_json::json!({
+                "prefix": "/app",
+                "limit": 200,
+                "recursive": false
+            })
+        );
+    }
+
+    #[test]
+    fn serializes_kv_get_put_delete_params() {
+        assert_eq!(kv_get_params("/app/name"), serde_json::json!({ "key": "/app/name" }));
+        assert_eq!(
+            kv_put_params("/app/name", KvValue { encoding: KvValueEncoding::Utf8, data: "dbx".to_string() }, Some(42),),
+            serde_json::json!({
+                "key": "/app/name",
+                "value": {
+                    "encoding": "utf8",
+                    "data": "dbx"
+                },
+                "lease": 42
+            })
+        );
+        assert_eq!(kv_delete_params("/app/name"), serde_json::json!({ "key": "/app/name" }));
+    }
+
+    #[test]
+    fn serializes_kv_put_options_without_changing_default_shape() {
+        let value = KvValue { encoding: KvValueEncoding::Utf8, data: "dbx".to_string() };
+        assert_eq!(
+            kv_put_params("/app/name", value.clone(), None),
+            serde_json::json!({
+                "key": "/app/name",
+                "value": {
+                    "encoding": "utf8",
+                    "data": "dbx"
+                }
+            })
+        );
+        assert_eq!(
+            kv_put_params_with_options(
+                "/jobs/job-",
+                value,
+                KvPutOptions {
+                    write_mode: Some(KvWriteMode::Create),
+                    create_mode: Some(KvCreateMode::EphemeralSequential),
+                    ..KvPutOptions::default()
+                },
+            ),
+            serde_json::json!({
+                "key": "/jobs/job-",
+                "value": {
+                    "encoding": "utf8",
+                    "data": "dbx"
+                },
+                "writeMode": "create",
+                "createMode": "ephemeral_sequential"
+            })
+        );
+    }
+
+    #[test]
+    fn decodes_kv_list_prefix_response() {
+        let decoded: KvListPrefixResponse = serde_json::from_value(serde_json::json!({
+            "keys": [{
+                "key": "/app/name",
+                "createRevision": 1,
+                "modRevision": 2,
+                "version": 3,
+                "lease": 0,
+                "valueSize": 5
+            }],
+            "continuation": "next-token",
+            "revision": 9
+        }))
+        .unwrap();
+
+        assert_eq!(decoded.keys[0].key, "/app/name");
+        assert_eq!(decoded.keys[0].metadata.mod_revision, Some(2));
+        assert_eq!(decoded.continuation.as_deref(), Some("next-token"));
+        assert_eq!(decoded.revision, Some(9));
+    }
+
+    #[test]
+    fn decodes_kv_put_response_with_created_key() {
+        let decoded: KvPutResponse = serde_json::from_value(serde_json::json!({
+            "key": "/jobs/job-0000000001",
+            "createdKey": "/jobs/job-0000000001"
+        }))
+        .unwrap();
+
+        assert_eq!(decoded.revision, None);
+        assert_eq!(decoded.key.as_deref(), Some("/jobs/job-0000000001"));
+        assert_eq!(decoded.created_key.as_deref(), Some("/jobs/job-0000000001"));
+    }
+
+    #[test]
+    fn decodes_zookeeper_metadata_fields() {
+        let decoded: KvGetResponse = serde_json::from_value(serde_json::json!({
+            "found": true,
+            "key": "/admin",
+            "value": {
+                "encoding": "utf8",
+                "data": ""
+            },
+            "metadata": {
+                "czxid": 27,
+                "mzxid": 27,
+                "pzxid": 39825,
+                "ctime": 1780674584000_i64,
+                "mtime": 1780674585000_i64,
+                "cversion": 5,
+                "aversion": 0,
+                "ephemeralOwner": 0,
+                "dataLength": 0,
+                "numChildren": 5
+            }
+        }))
+        .unwrap();
+
+        let metadata = decoded.metadata.unwrap();
+        assert_eq!(metadata.czxid, Some(27));
+        assert_eq!(metadata.mzxid, Some(27));
+        assert_eq!(metadata.pzxid, Some(39825));
+        assert_eq!(metadata.ephemeral_owner, Some(0));
+        assert_eq!(metadata.num_children, Some(5));
+    }
+}
diff --git a/crates/dbx-core/src/agent_loop.rs b/crates/dbx-core/src/agent_loop.rs
new file mode 100644
index 0000000..fe408d8
--- /dev/null
+++ b/crates/dbx-core/src/agent_loop.rs
@@ -0,0 +1,1397 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+
+use futures::future::join_all;
+use futures::FutureExt;
+use serde_json::json;
+use tokio::sync::Notify;
+
+use crate::agent_events::{AgentEvent, ToolCall, ToolDefinition, ToolResult};
+use crate::agent_tools;
+use crate::ai::{self, AiCompletionRequest, AiConfig, AiMessage, AiProvider, AiStreamChunk, AiTaskContract};
+use crate::ai_cli_agent::CliAgentCommandSpec;
+use crate::connection::AppState;
+use crate::models::connection::DatabaseType;
+use crate::token_usage::TokenUsage;
+
+/// Maximum number of agent loop turns to prevent infinite loops.
+const MAX_AGENT_TURNS: u32 = 30;
+const MAX_TOOL_RESULT_CONTEXT_CHARS: usize = 12_000;
+const TOOL_RESULT_HEAD_CHARS: usize = 4_000;
+const TOOL_RESULT_TAIL_CHARS: usize = 4_000;
+const TOOL_RESULT_SAMPLE_ITEMS: usize = 5;
+const MAX_CONTRACT_REPAIR_ATTEMPTS: u32 = 2;
+
+fn take_text(m: &std::sync::Mutex<String>) -> String {
+    m.lock().unwrap_or_else(|e| e.into_inner()).clone()
+}
+
+/// Convert a streaming AI chunk into agent events for the frontend.
+/// Pure function — no side effects, easily testable.
+fn chunk_to_events(chunk: &AiStreamChunk) -> Vec<AgentEvent> {
+    let mut events = Vec::new();
+    if !chunk.delta.is_empty() {
+        events.push(AgentEvent::TextDelta { delta: chunk.delta.clone() });
+    }
+    if let Some(ref reasoning) = chunk.reasoning_delta {
+        events.push(AgentEvent::ReasoningDelta { delta: reasoning.clone() });
+    }
+    events
+}
+
+enum LoopExit {
+    Completed,
+    Cancelled,
+    Interrupted(String),
+    Exhausted,
+}
+
+impl LoopExit {
+    fn should_break_turns(&self) -> bool {
+        matches!(self, LoopExit::Cancelled | LoopExit::Interrupted(_))
+    }
+}
+
+enum CompactResult {
+    Skipped,
+    Compacted,
+    Cancelled,
+}
+
+/// Context for an agent loop run.
+pub struct AgentLoopContext {
+    pub state: Arc<AppState>,
+    pub connection_id: String,
+    pub database: String,
+    pub db_type: DatabaseType,
+    pub cli_mcp_server_command: Option<CliAgentCommandSpec>,
+    pub sql_permissions: agent_tools::AgentSqlPermissions,
+}
+
+/// Check if the provider supports function calling / tool use.
+/// Returns false for providers that are known to lack reliable tool support.
+fn provider_supports_function_calling(config: &AiConfig) -> bool {
+    match config.provider {
+        // Ollama function calling support varies by model/version; conservative default is false.
+        // Users with capable models can override via openai-compatible with an Ollama endpoint.
+        AiProvider::Ollama => false,
+        _ => true,
+    }
+}
+
+/// Run the agent loop: call LLM with tools, execute tool calls, feed results back, repeat.
+///
+/// The `on_event` callback receives streaming events for the frontend.
+/// Returns the final accumulated assistant text.
+///
+/// If the provider does not support function calling (e.g., Ollama), automatically
+/// degrades to a text-only completion with schema context injected into the system prompt.
+#[allow(clippy::too_many_arguments)]
+pub async fn run_agent_loop(
+    config: &AiConfig,
+    system_prompt: &str,
+    messages: &[AiMessage],
+    agent_ctx: &AgentLoopContext,
+    on_event: impl Fn(AgentEvent) + Send + Sync + Clone + 'static,
+    cancelled: &Notify,
+    max_tokens: Option<u32>,
+    task_contract: Option<&AiTaskContract>,
+    is_agent_mode: bool,
+) -> Result<String, String> {
+    let contract_system_prompt = augment_system_prompt_with_task_contract(system_prompt, task_contract, is_agent_mode);
+    let system_prompt = contract_system_prompt.as_str();
+
+    if matches!(config.provider, AiProvider::CodexCli) {
+        let connection_name = {
+            let configs = agent_ctx.state.configs.read().await;
+            configs
+                .get(&agent_ctx.connection_id)
+                .map(|config| config.name.clone())
+                .unwrap_or_else(|| agent_ctx.connection_id.clone())
+        };
+        let prompt =
+            crate::ai_codex_cli::build_codex_prompt(system_prompt, messages, agent_ctx.sql_permissions.allow_writes);
+        return crate::ai_codex_cli::run_codex_agent(
+            config,
+            &prompt,
+            crate::ai_codex_cli::CodexRunOptions {
+                connection_id: agent_ctx.connection_id.clone(),
+                connection_name,
+                database: agent_ctx.database.clone(),
+                agent_mode: is_agent_mode,
+                allow_writes: agent_ctx.sql_permissions.allow_writes,
+                allow_dangerous: agent_ctx.sql_permissions.allow_dangerous,
+                mcp_server_command: agent_ctx.cli_mcp_server_command.clone(),
+            },
+            cancelled,
+            on_event,
+        )
+        .await;
+    }
+
+    // Auto-degrade: providers without function calling fall back to text-only completion.
+    if !provider_supports_function_calling(config) {
+        return run_agent_loop_text_only(
+            config,
+            system_prompt,
+            messages,
+            agent_ctx,
+            on_event,
+            cancelled,
+            max_tokens,
+            task_contract,
+        )
+        .await;
+    }
+    let tools = if is_agent_mode {
+        agent_tools::all_tools(agent_ctx.db_type, agent_ctx.sql_permissions)
+    } else {
+        agent_tools::read_only_tools(agent_ctx.db_type)
+    };
+    let task_contract = task_contract.cloned();
+    let mut conversation_messages: Vec<AiMessage> = messages.to_vec();
+    let mut final_text = String::new();
+    let mut loop_exit = LoopExit::Exhausted;
+    let mut total_usage = TokenUsage::default();
+    let mut contract_repair_attempts = 0;
+
+    for turn in 0..MAX_AGENT_TURNS {
+        // Check for cancellation before each turn
+        if cancelled.notified().now_or_never().is_some() {
+            loop_exit = LoopExit::Cancelled;
+            break;
+        }
+
+        // Check and maybe compact context
+        if matches!(
+            maybe_compact(
+                config,
+                system_prompt,
+                &tools,
+                &mut conversation_messages,
+                max_tokens,
+                &on_event,
+                cancelled,
+                false,
+            )
+            .await,
+            CompactResult::Cancelled
+        ) {
+            loop_exit = LoopExit::Cancelled;
+            break;
+        }
+
+        on_event(AgentEvent::TurnStart { turn });
+
+        let mut stream_result: Option<(Vec<ToolCall>, Option<TokenUsage>, String)> = None;
+        let mut last_stream_error: Option<String> = None;
+
+        for attempt in 0..2 {
+            // Build the LLM request with tools. Rebuild after retry compaction so the request
+            // reflects the latest conversation_messages.
+            let request = build_tool_request(
+                config,
+                system_prompt,
+                &conversation_messages,
+                &tools,
+                max_tokens,
+                task_contract.clone(),
+            );
+
+            // Stream the LLM response, collecting text and tool_calls.
+            let accumulated_text = Arc::new(Mutex::new(String::new()));
+            let emitted_any_chunk = Arc::new(AtomicBool::new(false));
+            let session_id =
+                if attempt == 0 { format!("agent-turn-{turn}") } else { format!("agent-turn-{turn}-retry") };
+
+            let acc = accumulated_text.clone();
+            let emitted = emitted_any_chunk.clone();
+            let on_event2 = on_event.clone();
+            let on_chunk = move |chunk: AiStreamChunk| {
+                if !chunk.delta.is_empty() {
+                    emitted.store(true, Ordering::Relaxed);
+                    acc.lock().unwrap_or_else(|e| e.into_inner()).push_str(&chunk.delta);
+                }
+                if chunk.reasoning_delta.is_some() {
+                    emitted.store(true, Ordering::Relaxed);
+                }
+                for event in chunk_to_events(&chunk) {
+                    on_event2(event);
+                }
+            };
+
+            match stream_with_tools(config, &request, &session_id, &tools, cancelled, on_chunk).await {
+                Ok((tool_calls, usage)) => {
+                    let accumulated_text = take_text(&accumulated_text);
+                    stream_result = Some((tool_calls, usage, accumulated_text));
+                    break;
+                }
+                Err(err)
+                    if attempt == 0 && is_context_length_error(&err) && !emitted_any_chunk.load(Ordering::Relaxed) =>
+                {
+                    last_stream_error = Some(err);
+                    let compacted = maybe_compact(
+                        config,
+                        system_prompt,
+                        &tools,
+                        &mut conversation_messages,
+                        max_tokens,
+                        &on_event,
+                        cancelled,
+                        true,
+                    )
+                    .await;
+                    match compacted {
+                        CompactResult::Compacted => continue,
+                        CompactResult::Cancelled => {
+                            loop_exit = LoopExit::Cancelled;
+                            break;
+                        }
+                        CompactResult::Skipped => {
+                            final_text = take_text(&accumulated_text);
+                            loop_exit =
+                                LoopExit::Interrupted(last_stream_error.take().unwrap_or_else(|| {
+                                    "LLM request failed after context compaction retry".to_string()
+                                }));
+                        }
+                    }
+                    break;
+                }
+                Err(err) if err == ai::AGENT_CANCELLED_ERROR => {
+                    final_text = take_text(&accumulated_text);
+                    loop_exit = LoopExit::Cancelled;
+                    break;
+                }
+                Err(err) => {
+                    final_text = take_text(&accumulated_text);
+                    loop_exit = LoopExit::Interrupted(err);
+                    break;
+                }
+            }
+        }
+
+        if loop_exit.should_break_turns() {
+            break;
+        }
+
+        let Some((collected_tool_calls, turn_usage, accumulated_text)) = stream_result else {
+            return Err(
+                last_stream_error.unwrap_or_else(|| "LLM request failed after context compaction retry".to_string())
+            );
+        };
+
+        if let Some(usage) = turn_usage {
+            total_usage.add(&usage);
+        }
+
+        on_event(AgentEvent::TurnEnd { turn });
+
+        // Add assistant message to conversation (including tool_use blocks)
+        conversation_messages.push(AiMessage {
+            role: "assistant".to_string(),
+            content: accumulated_text.clone(),
+            tool_call_id: None,
+            tool_calls: collected_tool_calls
+                .iter()
+                .map(|tc| ai::ToolCallRef { id: tc.id.clone(), name: tc.name.clone(), arguments: tc.arguments.clone() })
+                .collect(),
+        });
+
+        if collected_tool_calls.is_empty() {
+            match validate_final_answer(task_contract.as_ref(), &accumulated_text) {
+                FinalAnswerCheck::Satisfied => {
+                    final_text = accumulated_text;
+                    loop_exit = LoopExit::Completed;
+                    break;
+                }
+                FinalAnswerCheck::NeedsRepair(reason) if contract_repair_attempts < MAX_CONTRACT_REPAIR_ATTEMPTS => {
+                    contract_repair_attempts += 1;
+                    conversation_messages.push(AiMessage {
+                        role: "user".to_string(),
+                        content: build_contract_repair_prompt(task_contract.as_ref(), is_agent_mode, &reason),
+                        tool_call_id: None,
+                        tool_calls: Vec::new(),
+                    });
+                    continue;
+                }
+                FinalAnswerCheck::NeedsRepair(reason) => {
+                    let message = append_contract_failure_note(accumulated_text, &reason);
+                    on_event(AgentEvent::TextDelta { delta: message.clone() });
+                    final_text = message;
+                    loop_exit = LoopExit::Completed;
+                    break;
+                }
+            }
+        }
+
+        // Honor a cancellation that arrived after the stream finished but before we
+        // run the requested tools; otherwise a long execute_query would keep running.
+        if cancelled.notified().now_or_never().is_some() {
+            final_text = accumulated_text;
+            loop_exit = LoopExit::Cancelled;
+            break;
+        }
+
+        // Execute each tool call
+        // Emit all ToolCallStart events first
+        for tc in &collected_tool_calls {
+            on_event(AgentEvent::ToolCallStart {
+                tool_call_id: tc.id.clone(),
+                tool_name: tc.name.clone(),
+                args: tc.arguments.clone(),
+            });
+        }
+
+        // Execute tool calls: parallel for read tools, sequential for execute_query
+        let state2 = Arc::clone(&agent_ctx.state);
+        let conn2 = agent_ctx.connection_id.clone();
+        let db2 = agent_ctx.database.clone();
+        let db_type = agent_ctx.db_type;
+        let sql_permissions = agent_ctx.sql_permissions;
+
+        // Split by index into parallel and sequential groups using tool metadata
+        let tool_parallel_map: std::collections::HashMap<&str, bool> =
+            tools.iter().map(|t| (t.name, t.parallel_ok)).collect();
+        let (parallel_indices, sequential_indices): (Vec<usize>, Vec<usize>) = (0..collected_tool_calls.len())
+            .partition(|&i| *tool_parallel_map.get(collected_tool_calls[i].name.as_str()).unwrap_or(&false));
+
+        let make_tc =
+            |tc: &ToolCall| ToolCall { id: tc.id.clone(), name: tc.name.clone(), arguments: tc.arguments.clone() };
+
+        // Run parallel group
+        let parallel_futures: Vec<_> = parallel_indices
+            .iter()
+            .map(|&i| {
+                let tc = make_tc(&collected_tool_calls[i]);
+                let state = Arc::clone(&state2);
+                let conn = conn2.clone();
+                let db = db2.clone();
+                async move { agent_tools::execute_tool(&tc, &state, &conn, &db, &db_type, sql_permissions).await }
+            })
+            .collect();
+        let parallel_results = join_all(parallel_futures).await;
+
+        // Run sequential group one-by-one
+        let mut sequential_results = Vec::with_capacity(sequential_indices.len());
+        for &i in &sequential_indices {
+            let tc = make_tc(&collected_tool_calls[i]);
+            sequential_results
+                .push(agent_tools::execute_tool(&tc, &state2, &conn2, &db2, &db_type, sql_permissions).await);
+        }
+
+        // Merge results back into original order
+        let mut results: Vec<Option<ToolResult>> = vec![None; collected_tool_calls.len()];
+        for (pos, &i) in parallel_indices.iter().enumerate() {
+            results[i] = Some(parallel_results[pos].clone());
+        }
+        for (pos, &i) in sequential_indices.iter().enumerate() {
+            results[i] = Some(sequential_results[pos].clone());
+        }
+        let results: Vec<ToolResult> = results.into_iter().map(|r| r.unwrap()).collect();
+
+        // Process results in order, emitting ToolCallEnd events
+        for (tc, result) in collected_tool_calls.iter().zip(results) {
+            on_event(AgentEvent::ToolCallEnd {
+                tool_call_id: tc.id.clone(),
+                tool_name: tc.name.clone(),
+                result: match &result.explain_data {
+                    Some(ed) => json!({ "content": result.content, "explain_data": ed }),
+                    None => json!({ "content": result.content }),
+                },
+                is_error: result.is_error,
+            });
+            conversation_messages.push(AiMessage {
+                role: "tool".to_string(),
+                content: tool_result_for_followup_context(&tc.name, &result.content),
+                tool_call_id: Some(tc.id.clone()),
+                tool_calls: Vec::new(),
+            });
+        }
+    }
+
+    match loop_exit {
+        LoopExit::Completed => {}
+        LoopExit::Cancelled => {
+            let message = if final_text.trim().is_empty() {
+                "Agent run was cancelled before producing output.".to_string()
+            } else {
+                "\n\nAgent run was cancelled. Partial output above was preserved.".to_string()
+            };
+            on_event(AgentEvent::TextDelta { delta: message.clone() });
+            final_text.push_str(&message);
+        }
+        LoopExit::Interrupted(error) => {
+            let message = if final_text.trim().is_empty() {
+                format!("Agent stream stopped before completion: {error}.")
+            } else {
+                format!("\n\nAgent stream stopped before completion: {error}. Partial output above was preserved.")
+            };
+            on_event(AgentEvent::TextDelta { delta: message.clone() });
+            final_text.push_str(&message);
+        }
+        LoopExit::Exhausted => {
+            let message = if final_text.trim().is_empty() {
+                format!("Agent reached the {MAX_AGENT_TURNS}-turn safety limit before producing output. Send Continue to let the agent keep working.")
+            } else {
+                format!(
+                    "\n\nAgent reached the {MAX_AGENT_TURNS}-turn safety limit before a final answer. The partial output above was preserved; send Continue to let the agent keep working."
+                )
+            };
+            on_event(AgentEvent::TextDelta { delta: message.clone() });
+            final_text.push_str(&message);
+        }
+    }
+
+    on_event(AgentEvent::AgentEnd {
+        input_tokens: if total_usage.input_tokens > 0 { Some(total_usage.input_tokens) } else { None },
+        output_tokens: if total_usage.output_tokens > 0 { Some(total_usage.output_tokens) } else { None },
+    });
+    Ok(final_text)
+}
+
+/// Build an LLM request that includes tool definitions.
+fn build_tool_request(
+    config: &AiConfig,
+    system_prompt: &str,
+    messages: &[AiMessage],
+    _tools: &[ToolDefinition], // Tools are injected in ai::stream_with_tools, not via AiCompletionRequest.
+    max_tokens: Option<u32>,
+    task_contract: Option<AiTaskContract>,
+) -> AiCompletionRequest {
+    // Note: tools are passed via the body, not via AiCompletionRequest.
+    // The actual injection happens in stream_with_tools.
+    AiCompletionRequest {
+        config: config.clone(),
+        system_prompt: system_prompt.to_string(),
+        messages: messages.to_vec(),
+        task_contract,
+        max_tokens: max_tokens.or(Some(4096)),
+    }
+}
+
+fn augment_system_prompt_with_task_contract(
+    system_prompt: &str,
+    task_contract: Option<&AiTaskContract>,
+    is_agent_mode: bool,
+) -> String {
+    let Some(contract) = task_contract else {
+        return system_prompt.to_string();
+    };
+
+    let action = contract.action.as_deref().unwrap_or("unknown");
+    let mode = contract.mode.as_deref().unwrap_or(if is_agent_mode { "agent" } else { "ask" });
+    let user_request = contract.user_request.as_deref().unwrap_or("(not provided)");
+    let mode_rule = if action_requires_sql_deliverable(action) {
+        "This is a SQL-producing action: produce the final SQL in a fenced ```sql code block. Use tools only as intermediate evidence for schema/dialect; do not stop at a tool-result summary. In Agent mode, execute a query only when the original request explicitly asks for real data/results, not when it merely asks to generate SQL."
+    } else {
+        match action.to_ascii_lowercase().as_str() {
+            "general" => "This is a general Q&A mode. Answer the user's question directly and naturally using your knowledge and any available database context. Adapt to the user's intent.",
+            "query" => "This is a data-query task: call execute_query to obtain real results, then answer based on the actual data. Do not stop after merely outputting SQL text.",
+            "exploreschema" => "This is a schema-inspection task: use list_tables/get_columns to obtain authoritative structure, then summarize. Do not execute data queries unless the user explicitly asks for data.",
+            "executeandexplain" => "This is an execute-and-explain task: call execute_query to run the current SQL, then explain the real results.",
+            _ if is_agent_mode => "For data-query intents, obtain real results with execute_query when safe; otherwise state the blocker.",
+            _ => "In Ask mode, produce SQL/explanation only and do not claim execution.",
+        }
+    };
+
+    format!(
+        "{system_prompt}\n\n[TASK CONTRACT]\n\
+Original user request: {user_request}\n\
+Action: {action}\n\
+Mode: {mode}\n\
+Tool results are intermediate evidence. Continue the original task after every tool call; never treat a tool-result summary as the final answer unless the user explicitly requested that summary.\n\
+{mode_rule}\n\
+If the final deliverable cannot be produced safely, state the exact missing information and ask one concise clarification question."
+    )
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum FinalAnswerCheck {
+    Satisfied,
+    NeedsRepair(String),
+}
+
+fn validate_final_answer(task_contract: Option<&AiTaskContract>, text: &str) -> FinalAnswerCheck {
+    let Some(contract) = task_contract else {
+        return FinalAnswerCheck::Satisfied;
+    };
+
+    let action = contract.action.as_deref().unwrap_or_default();
+    if action_requires_sql_deliverable(action)
+        && !contains_sql_deliverable(text)
+        && !looks_like_blocker_or_clarification(text)
+    {
+        return FinalAnswerCheck::NeedsRepair(
+            "SQL-producing actions require a final SQL code block, or a concise blocker/clarification when SQL cannot be produced safely.".to_string(),
+        );
+    }
+
+    FinalAnswerCheck::Satisfied
+}
+
+fn build_contract_repair_prompt(task_contract: Option<&AiTaskContract>, is_agent_mode: bool, reason: &str) -> String {
+    let action = task_contract.and_then(|c| c.action.as_deref()).unwrap_or("unknown");
+    let mode = task_contract.and_then(|c| c.mode.as_deref()).unwrap_or(if is_agent_mode { "agent" } else { "ask" });
+    let user_request = task_contract.and_then(|c| c.user_request.as_deref()).unwrap_or("(not provided)");
+    let mode_rule = if action_requires_sql_deliverable(action) {
+        "For this SQL-producing action, produce SQL in a fenced ```sql code block. Tool results are evidence only; do not answer by summarizing schema/tool output. Execute a query only when the original request explicitly asks for real data/results."
+    } else {
+        match action.to_ascii_lowercase().as_str() {
+            "general" => "For this general Q&A, answer the user's question directly and naturally.",
+            "query" => "For this data-query task, call execute_query and answer based on real data; do not stop at SQL text or a schema summary.",
+            "exploreschema" => "For this schema-inspection task, summarize real structure from list_tables/get_columns; do not invent columns.",
+            "executeandexplain" => "For this execute-and-explain task, run the current SQL via execute_query and explain the real results.",
+            _ if is_agent_mode => "If the original request asks for real data and it can be answered safely, call execute_query before the final answer.",
+            _ => "In Ask mode, generate SQL and concise explanation only; do not claim the SQL was executed.",
+        }
+    };
+
+    format!(
+        "[SYSTEM-GENERATED TASK CONTRACT CHECK]\n\
+Your previous response did not satisfy the current task contract.\n\
+Issue: {reason}\n\
+Original user request: {user_request}\n\
+Action: {action}\n\
+Mode: {mode}\n\n\
+Tool results in the conversation are intermediate evidence only. Continue the original user task; do not summarize tool results unless the user explicitly requested a summary.\n\
+{mode_rule}\n\
+Produce a final answer that satisfies the action contract now. If required tables/columns are missing or ambiguous, state exactly what is missing and ask one concise clarification question."
+    )
+}
+
+fn action_requires_sql_deliverable(action: &str) -> bool {
+    matches!(action.to_ascii_lowercase().as_str(), "generate" | "optimize" | "fix" | "convert" | "sampledata")
+}
+
+fn append_contract_failure_note(text: String, reason: &str) -> String {
+    if text.trim().is_empty() {
+        return format!("Unable to produce a contract-compliant final answer: {reason}");
+    }
+
+    format!("{text}\n\nTask contract warning: {reason}")
+}
+
+fn contains_sql_deliverable(text: &str) -> bool {
+    let lower = text.to_ascii_lowercase();
+    let mut rest = lower.as_str();
+
+    while let Some(fence_start) = rest.find("```") {
+        let after_open = &rest[fence_start + 3..];
+        let Some(info_end) = after_open.find('\n') else {
+            return false;
+        };
+        let info = after_open[..info_end].trim();
+        let after_info = &after_open[info_end + 1..];
+        let Some(fence_end) = after_info.find("```") else {
+            return false;
+        };
+        let body = &after_info[..fence_end];
+
+        if (info.is_empty() || info.starts_with("sql")) && contains_sql_keyword(body) {
+            return true;
+        }
+
+        rest = &after_info[fence_end + 3..];
+    }
+
+    false
+}
+
+fn contains_sql_keyword(lower_text: &str) -> bool {
+    lower_text.split(|ch: char| !ch.is_ascii_alphanumeric() && ch != '_').any(|token| {
+        matches!(
+            token,
+            "select" | "with" | "show" | "describe" | "explain" | "insert" | "update" | "delete" | "create" | "alter"
+        )
+    })
+}
+
+fn looks_like_blocker_or_clarification(text: &str) -> bool {
+    let lower = text.to_ascii_lowercase();
+    let markers = [
+        "missing",
+        "not enough",
+        "cannot determine",
+        "can't determine",
+        "unable to determine",
+        "which column",
+        "please clarify",
+        "need to know",
+        "缺少",
+        "不足",
+        "无法确定",
+        "不能确定",
+        "没有找到",
+        "未找到",
+        "请确认",
+        "请提供",
+        "需要明确",
+        "哪个字段",
+    ];
+    markers.iter().any(|marker| lower.contains(marker))
+}
+
+/// Stream an LLM response with tool support, parsing tool_calls from SSE deltas.
+///
+/// Reasoning and tool call arguments are emitted incrementally as they arrive.
+/// Assistant text is buffered until it satisfies the task contract so an
+/// intermediate tool-result summary is not shown as the final answer.
+async fn stream_with_tools(
+    config: &AiConfig,
+    request: &AiCompletionRequest,
+    session_id: &str,
+    tools: &[ToolDefinition],
+    cancelled: &Notify,
+    on_chunk: impl Fn(AiStreamChunk) + Send + Sync + 'static,
+) -> Result<(Vec<ToolCall>, Option<TokenUsage>), String> {
+    // Return early if the user cancelled before the LLM call started.
+    if cancelled.notified().now_or_never().is_some() {
+        return Err(ai::AGENT_CANCELLED_ERROR.to_string());
+    }
+
+    ai::stream_with_tools(config, request, session_id, tools, cancelled, on_chunk).await
+}
+
+fn is_context_length_error(error: &str) -> bool {
+    let lower = error.to_lowercase();
+    [
+        "context length",
+        "context_length",
+        "maximum context",
+        "max context",
+        "token limit",
+        "too many tokens",
+        "prompt is too long",
+        "input is too long",
+        "reduce the length",
+    ]
+    .iter()
+    .any(|marker| lower.contains(marker))
+}
+
+/// Text-only fallback for providers that don't support function calling.
+///
+/// Injects database schema context into the system prompt so the LLM can still
+/// give informed answers, then performs a single non-streaming completion.
+#[allow(clippy::too_many_arguments)]
+async fn run_agent_loop_text_only(
+    config: &AiConfig,
+    system_prompt: &str,
+    messages: &[AiMessage],
+    agent_ctx: &AgentLoopContext,
+    on_event: impl Fn(AgentEvent) + Send + Sync + 'static,
+    cancelled: &Notify,
+    max_tokens: Option<u32>,
+    task_contract: Option<&AiTaskContract>,
+) -> Result<String, String> {
+    // Build a schema-enriched system prompt so the LLM can answer schema questions
+    // even without tool access.
+    let enriched_prompt = build_schema_prompt(agent_ctx, system_prompt).await;
+
+    // Honor a cancellation requested while loading schema context.
+    if cancelled.notified().now_or_never().is_some() {
+        on_event(AgentEvent::AgentEnd { input_tokens: None, output_tokens: None });
+        return Ok("Agent run was cancelled before producing output.".to_string());
+    }
+
+    let mut request = AiCompletionRequest {
+        config: config.clone(),
+        system_prompt: enriched_prompt,
+        messages: messages.to_vec(),
+        task_contract: task_contract.cloned(),
+        max_tokens: max_tokens.or(Some(4096)),
+    };
+
+    for attempt in 0..=MAX_CONTRACT_REPAIR_ATTEMPTS {
+        // Use non-streaming completions so contract repair can suppress incomplete drafts.
+        // Race the (non-cancellable) HTTP call against cancellation so Stop still works.
+        let result = tokio::select! {
+            result = ai::complete(&request) => result?,
+            _ = cancelled.notified() => {
+                on_event(AgentEvent::AgentEnd { input_tokens: None, output_tokens: None });
+                return Ok("Agent run was cancelled before producing output.".to_string());
+            }
+        };
+        match validate_final_answer(task_contract, &result) {
+            FinalAnswerCheck::Satisfied => {
+                on_event(AgentEvent::TextDelta { delta: result.clone() });
+                on_event(AgentEvent::AgentEnd { input_tokens: None, output_tokens: None });
+                return Ok(result);
+            }
+            FinalAnswerCheck::NeedsRepair(reason) if attempt < MAX_CONTRACT_REPAIR_ATTEMPTS => {
+                request.messages.push(AiMessage {
+                    role: "assistant".to_string(),
+                    content: result,
+                    tool_call_id: None,
+                    tool_calls: Vec::new(),
+                });
+                request.messages.push(AiMessage {
+                    role: "user".to_string(),
+                    content: build_contract_repair_prompt(task_contract, false, &reason),
+                    tool_call_id: None,
+                    tool_calls: Vec::new(),
+                });
+            }
+            FinalAnswerCheck::NeedsRepair(reason) => {
+                let message = append_contract_failure_note(result, &reason);
+                on_event(AgentEvent::TextDelta { delta: message.clone() });
+                on_event(AgentEvent::AgentEnd { input_tokens: None, output_tokens: None });
+                return Ok(message);
+            }
+        }
+    }
+
+    Err("Text-only agent fallback failed to produce a final answer".to_string())
+}
+
+/// Build a system prompt enriched with database schema information
+/// for text-only mode where the LLM cannot use tools.
+async fn build_schema_prompt(agent_ctx: &AgentLoopContext, system_prompt: &str) -> String {
+    let mut enriched = system_prompt.to_string();
+
+    // Fetch real schema data using the same core functions the tools would use
+    let tables_result = crate::schema::list_tables_core(
+        &agent_ctx.state,
+        &agent_ctx.connection_id,
+        &agent_ctx.database,
+        "",
+        None,
+        Some(50), // smaller limit for prompt injection
+        None,
+        None,
+    )
+    .await;
+
+    match tables_result {
+        Ok(tables) if !tables.is_empty() => {
+            enriched.push_str("\n\n## Database Schema (for context — no tools available)\n");
+            enriched.push_str(&format!("Database: {}\n", agent_ctx.database));
+            enriched.push_str("Tables:\n");
+            for t in &tables {
+                enriched.push_str(&format!("  - {} ({})", t.name, t.table_type));
+                if let Some(ref comment) = t.comment {
+                    if !comment.trim().is_empty() {
+                        enriched.push_str(&format!(" — {}", comment.trim()));
+                    }
+                }
+                enriched.push('\n');
+            }
+        }
+        _ => {
+            enriched.push_str("\n\n(Note: Unable to load database schema for this request.)\n");
+        }
+    }
+
+    enriched
+}
+
+/// Estimate text tokens conservatively for mixed English, Chinese, SQL, and JSON content.
+fn estimate_text_tokens(text: &str) -> u32 {
+    let chars = text.chars().count() as u32;
+    if chars == 0 {
+        return 0;
+    }
+
+    let non_ascii = text.chars().filter(|c| !c.is_ascii()).count() as u32;
+    let alpha = non_ascii as f32 / chars as f32;
+    let ascii_est = (text.len() as f32 / 3.5).ceil();
+    let nonascii_est = (chars as f32 * 1.2).ceil();
+    let estimated = (ascii_est * (1.0 - alpha) + nonascii_est * alpha).ceil() as u32;
+    estimated.max(1)
+}
+
+fn estimate_message_tokens(message: &AiMessage) -> u32 {
+    let mut tokens = estimate_text_tokens(&message.content) + 4;
+
+    if let Some(tool_call_id) = &message.tool_call_id {
+        tokens += estimate_text_tokens(tool_call_id) + 2;
+    }
+
+    for tool_call in &message.tool_calls {
+        tokens += estimate_text_tokens(&tool_call.id) + estimate_text_tokens(&tool_call.name) + 4;
+        if let Ok(args) = serde_json::to_string(&tool_call.arguments) {
+            tokens += estimate_text_tokens(&args);
+        }
+    }
+
+    tokens
+}
+
+/// Estimate tokens for a slice of messages.
+fn estimate_tokens(messages: &[AiMessage]) -> u32 {
+    messages.iter().map(estimate_message_tokens).sum()
+}
+
+fn estimate_tool_schema_tokens(tools: &[ToolDefinition]) -> u32 {
+    tools
+        .iter()
+        .map(|tool| {
+            let schema_tokens =
+                serde_json::to_string(&tool.parameters).map(|schema| estimate_text_tokens(&schema)).unwrap_or_default();
+            estimate_text_tokens(tool.name) + estimate_text_tokens(tool.description) + schema_tokens + 16
+        })
+        .sum()
+}
+
+fn estimate_current_prompt_tokens(system_prompt: &str, tools: &[ToolDefinition], messages: &[AiMessage]) -> u32 {
+    estimate_text_tokens(system_prompt) + estimate_tool_schema_tokens(tools) + estimate_tokens(messages) + 16
+}
+
+/// Returns the context window size for a given model name.
+fn context_window_for_model(model: &str) -> u32 {
+    let m = model.to_lowercase();
+    // GPT-4.1 family: 1M context
+    if m.contains("gpt-4.1") {
+        return 1_000_000;
+    }
+    if m.contains("claude") || m.contains("o1") || m.starts_with("o3") || m.starts_with("o4") {
+        200_000
+    } else if m.contains("gpt-4") {
+        128_000
+    } else if m.contains("gemini") {
+        1_000_000
+    } else {
+        128_000
+    }
+}
+
+fn prompt_budget(window: u32, max_tokens: Option<u32>) -> u32 {
+    let output_reserve = max_tokens.unwrap_or(4096).min(window / 2);
+    let safety_reserve = (window / 10).clamp(2048, 16_384).min(window / 2);
+    window.saturating_sub(output_reserve).saturating_sub(safety_reserve)
+}
+
+fn keep_recent_budget(prompt_budget: u32) -> u32 {
+    if prompt_budget <= 4096 {
+        prompt_budget / 2
+    } else {
+        (prompt_budget * 6 / 10).clamp(4096, 50_000)
+    }
+}
+
+const COMPACT_SYSTEM_PROMPT: &str = "\
+You are a conversation summarizer. Produce a concise structured summary of the conversation \
+provided. Format:\n\
+## Progress\n## Key Decisions\n## Critical Context\n## Next Steps\n\
+Be factual. No commentary.";
+
+async fn maybe_compact(
+    config: &AiConfig,
+    system_prompt: &str,
+    tools: &[ToolDefinition],
+    messages: &mut Vec<AiMessage>,
+    max_tokens: Option<u32>,
+    on_event: &(impl Fn(AgentEvent) + Send + Sync),
+    cancelled: &Notify,
+    force: bool,
+) -> CompactResult {
+    let window = config.context_window.unwrap_or_else(|| context_window_for_model(&config.model));
+    let budget = prompt_budget(window, max_tokens);
+    let estimated_before = estimate_current_prompt_tokens(system_prompt, tools, messages);
+
+    if !force && estimated_before <= budget {
+        return CompactResult::Skipped;
+    }
+
+    if messages.len() <= 2 {
+        return CompactResult::Skipped;
+    }
+
+    // Find cut point: keep a dynamic budget of recent messages and summarize older context.
+    let keep_recent_tokens = if force { keep_recent_budget(budget) / 2 } else { keep_recent_budget(budget) };
+    let mut recent_tokens = 0u32;
+    let mut cut = messages.len();
+    for i in (0..messages.len()).rev() {
+        let t = estimate_message_tokens(&messages[i]);
+        if recent_tokens + t > keep_recent_tokens && i > 0 {
+            cut = i + 1;
+            break;
+        }
+        recent_tokens += t;
+        cut = i;
+    }
+
+    if cut >= messages.len() {
+        cut = messages.len().saturating_sub(1);
+    }
+
+    let cut = adjust_cut_for_tool_pair_integrity(messages, cut);
+
+    // Always keep messages[0] (the original user question) verbatim outside the summary.
+    // Only summarize messages[1..cut].
+    if cut <= 1 {
+        return CompactResult::Skipped;
+    }
+    let summary_start = 1usize;
+
+    let compacted_messages = cut - summary_start;
+
+    let convo_text: String = messages[summary_start..cut].iter().map(format_message_for_summary).collect();
+
+    let summary_request = AiCompletionRequest {
+        config: config.clone(),
+        system_prompt: COMPACT_SYSTEM_PROMPT.to_string(),
+        messages: vec![AiMessage {
+            role: "user".to_string(),
+            content: format!("<conversation>\n{convo_text}</conversation>\n\nSummarize the above."),
+            tool_call_id: None,
+            tool_calls: Vec::new(),
+        }],
+        task_contract: None,
+        max_tokens: Some(1024),
+    };
+
+    let summary = match cancelled.notified().now_or_never() {
+        Some(_) => return CompactResult::Cancelled,
+        None => match tokio::select! {
+            result = ai::complete(&summary_request) => result,
+            _ = cancelled.notified() => return CompactResult::Cancelled,
+        } {
+            Ok(s) => s,
+            Err(_) => fallback_summary(messages, cut),
+        },
+    };
+
+    let summary = if validate_summary(&summary) { summary } else { fallback_summary(messages, cut) };
+
+    let summary_tokens = estimate_text_tokens(&summary) + 4;
+
+    let summary_content = format!(
+        "[SYSTEM-GENERATED CONTEXT SUMMARY - earlier conversation compressed; background only, not a new user request]\n\n{summary}"
+    );
+
+    messages.drain(summary_start..cut);
+    messages.insert(
+        summary_start,
+        AiMessage {
+            role: "user".to_string(),
+            content: summary_content.clone(),
+            tool_call_id: None,
+            tool_calls: Vec::new(),
+        },
+    );
+
+    let estimated_after = estimate_current_prompt_tokens(system_prompt, tools, messages);
+
+    on_event(AgentEvent::ContextCompacted {
+        summary: summary_content,
+        summary_tokens,
+        compacted_messages,
+        estimated_before,
+        estimated_after,
+    });
+    CompactResult::Compacted
+}
+
+fn tool_result_for_followup_context(tool_name: &str, content: &str) -> String {
+    let result = compact_tool_result_for_context(tool_name, content);
+    format!(
+        "[TOOL RESULT - INTERMEDIATE EVIDENCE]\n\
+Tool: {tool_name}\n\
+Use this result to continue the original user task. Do not summarize this tool result as the final answer unless the user explicitly asked for a tool-result or schema summary.\n\n\
+{result}"
+    )
+}
+
+fn compact_tool_result_for_context(tool_name: &str, content: &str) -> String {
+    if content.chars().count() <= MAX_TOOL_RESULT_CONTEXT_CHARS {
+        return content.to_string();
+    }
+
+    if let Ok(value) = serde_json::from_str::<serde_json::Value>(content) {
+        return compact_json_tool_result(tool_name, content, &value);
+    }
+
+    compact_text_tool_result(tool_name, content)
+}
+
+fn compact_json_tool_result(tool_name: &str, original: &str, value: &serde_json::Value) -> String {
+    let compacted = match value {
+        serde_json::Value::Array(items) => json!({
+            "type": "array",
+            "totalItems": items.len(),
+            "head": items.iter().take(TOOL_RESULT_SAMPLE_ITEMS).collect::<Vec<_>>(),
+            "tail": items.iter().rev().take(TOOL_RESULT_SAMPLE_ITEMS).collect::<Vec<_>>().into_iter().rev().collect::<Vec<_>>(),
+        }),
+        serde_json::Value::Object(map) => {
+            let mut object = serde_json::Map::new();
+            object.insert("type".to_string(), json!("object"));
+            object.insert("keys".to_string(), json!(map.keys().cloned().collect::<Vec<_>>()));
+            for (key, field_value) in map {
+                match field_value {
+                    serde_json::Value::Array(items) if items.len() > TOOL_RESULT_SAMPLE_ITEMS * 2 => {
+                        object.insert(
+                            key.clone(),
+                            json!({
+                                "totalItems": items.len(),
+                                "head": items.iter().take(TOOL_RESULT_SAMPLE_ITEMS).collect::<Vec<_>>(),
+                                "tail": items.iter().rev().take(TOOL_RESULT_SAMPLE_ITEMS).collect::<Vec<_>>().into_iter().rev().collect::<Vec<_>>(),
+                            }),
+                        );
+                    }
+                    _ => {
+                        object.insert(key.clone(), field_value.clone());
+                    }
+                }
+            }
+            serde_json::Value::Object(object)
+        }
+        _ => value.clone(),
+    };
+
+    let compacted_text = serde_json::to_string_pretty(&compacted).unwrap_or_else(|_| compacted.to_string());
+    if compacted_text.chars().count() <= MAX_TOOL_RESULT_CONTEXT_CHARS {
+        format!(
+            "[TOOL RESULT COMPACTED FOR CONTEXT]\nTool: {tool_name}\nOriginal chars: {}\nCompaction: parsed JSON with sampled arrays/fields. UI events preserve the full result.\n\n{}",
+            original.chars().count(),
+            compacted_text
+        )
+    } else {
+        compact_text_tool_result(tool_name, original)
+    }
+}
+
+fn compact_text_tool_result(tool_name: &str, content: &str) -> String {
+    let original_chars = content.chars().count();
+    let head = content.chars().take(TOOL_RESULT_HEAD_CHARS).collect::<String>();
+    let tail_chars = content.chars().rev().take(TOOL_RESULT_TAIL_CHARS).collect::<Vec<_>>();
+    let tail = tail_chars.into_iter().rev().collect::<String>();
+    format!(
+        "[TOOL RESULT COMPACTED FOR CONTEXT]\nTool: {tool_name}\nOriginal chars: {original_chars}\nCompaction: kept the head and tail; middle omitted. UI events preserve the full result.\n\n{head}\n\n...[middle omitted from tool result context]...\n\n{tail}"
+    )
+}
+
+fn validate_summary(summary: &str) -> bool {
+    let trimmed = summary.trim();
+    trimmed.len() >= 50 && trimmed.len() <= 6000
+}
+
+fn fallback_summary(messages: &[AiMessage], cut: usize) -> String {
+    // summary_start=1: messages[0] is kept verbatim, only messages[1..cut] are compacted.
+    let compacted_messages = &messages[1..cut];
+    let tool_calls = compacted_messages.iter().filter(|m| !m.tool_calls.is_empty()).count();
+    let tool_results = compacted_messages.iter().filter(|m| m.role == "tool").count();
+    let user_messages = compacted_messages.iter().filter(|m| m.role == "user").count();
+    let assistant_messages = compacted_messages.iter().filter(|m| m.role == "assistant").count();
+
+    let recent_roles = compacted_messages
+        .iter()
+        .rev()
+        .take(8)
+        .map(|message| format!("{}{}", message.role, if message.content.is_empty() { "" } else { ": content" }))
+        .collect::<Vec<_>>()
+        .join(", ");
+
+    [
+        "## Progress".to_string(),
+        "- Context summarized by fallback generator because the LLM summary was unavailable or low quality.".to_string(),
+        "## Key Decisions".to_string(),
+        format!(
+            "- Compacted {} messages: {} user, {} assistant, {} tool results, {} assistant tool-call messages.",
+            compacted_messages.len(), user_messages, assistant_messages, tool_results, tool_calls
+        ),
+        "## Critical Context".to_string(),
+        format!("- Recent compacted roles: {recent_roles}"),
+        "## Next Steps".to_string(),
+        "- Continue from the remaining recent conversation and recover any missing detail from tool handles or source paths if needed.".to_string(),
+    ]
+    .join("\n")
+}
+
+fn adjust_cut_for_tool_pair_integrity(messages: &[AiMessage], mut cut: usize) -> usize {
+    if cut >= messages.len() {
+        return cut;
+    }
+
+    while cut < messages.len() && messages[cut].role == "tool" {
+        let Some(origin) = find_originating_assistant(messages, cut) else {
+            break;
+        };
+        if origin >= cut {
+            break;
+        }
+        cut = origin;
+    }
+
+    cut
+}
+
+fn find_originating_assistant(messages: &[AiMessage], tool_index: usize) -> Option<usize> {
+    let tool_call_id = messages.get(tool_index)?.tool_call_id.as_deref();
+
+    for i in (0..tool_index).rev() {
+        let message = &messages[i];
+        if message.role != "assistant" {
+            continue;
+        }
+
+        if let Some(tool_call_id) = tool_call_id {
+            if message.tool_calls.iter().any(|tool_call| tool_call.id == tool_call_id) {
+                return Some(i);
+            }
+        } else if !message.tool_calls.is_empty() {
+            return Some(i);
+        }
+    }
+
+    None
+}
+
+fn format_message_for_summary(message: &AiMessage) -> String {
+    let mut header = format!("[{}", message.role);
+    if let Some(tool_call_id) = &message.tool_call_id {
+        header.push_str(&format!(" tool_call_id={tool_call_id}"));
+    }
+    if !message.tool_calls.is_empty() {
+        let tool_names =
+            message.tool_calls.iter().map(|tool_call| tool_call.name.as_str()).collect::<Vec<_>>().join(", ");
+        header.push_str(&format!(" tool_calls={tool_names}"));
+    }
+    header.push(']');
+
+    format!("{header}: {}\n", summarize_message_content(&message.content))
+}
+
+fn summarize_message_content(content: &str) -> String {
+    let char_count = content.chars().count();
+    if char_count <= 4000 {
+        return content.to_string();
+    }
+
+    let head = content.chars().take(1500).collect::<String>();
+    let tail_chars = content.chars().rev().take(1500).collect::<Vec<_>>();
+    let tail = tail_chars.into_iter().rev().collect::<String>();
+    format!("{head}\n\n...[middle omitted for summary input]...\n\n{tail}")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn generate_contract(user_request: &str, mode: &str) -> AiTaskContract {
+        AiTaskContract {
+            action: Some("generate".to_string()),
+            mode: Some(mode.to_string()),
+            user_request: Some(user_request.to_string()),
+        }
+    }
+
+    #[test]
+    fn generate_contract_rejects_schema_summary_without_sql() {
+        let contract = generate_contract("帮我生成统计 2026年1月2日新注册会员数量的 sql", "ask");
+        let answer = "The tb_customer table contains comprehensive customer information with key columns:\n\nCore Identity\n- c_no: customer id\nContact Information\n- c_tele: mobile";
+
+        let check = validate_final_answer(Some(&contract), answer);
+
+        assert!(matches!(check, FinalAnswerCheck::NeedsRepair(_)));
+    }
+
+    #[test]
+    fn generate_contract_accepts_sql_code_block() {
+        let contract = generate_contract("帮我生成统计新注册会员数量的 sql", "ask");
+        let answer = "```sql\nSELECT COUNT(*) AS member_count FROM tb_customer WHERE created_at >= '2026-01-02' AND created_at < '2026-01-03';\n```";
+
+        let check = validate_final_answer(Some(&contract), answer);
+
+        assert_eq!(check, FinalAnswerCheck::Satisfied);
+    }
+
+    #[test]
+    fn generate_contract_rejects_unfenced_sql_mention() {
+        let contract = generate_contract("帮我生成统计新注册会员数量的 sql", "ask");
+        let answer = "You can use SQL to query the table, for example SELECT COUNT(*) FROM tb_customer.";
+
+        let check = validate_final_answer(Some(&contract), answer);
+
+        assert!(matches!(check, FinalAnswerCheck::NeedsRepair(_)));
+    }
+
+    #[test]
+    fn generate_contract_accepts_missing_column_blocker() {
+        let contract = generate_contract("帮我生成统计新注册会员数量的 sql", "ask");
+        let answer = "没有找到明确表示会员注册时间的字段，请确认应该使用哪个字段作为注册时间。";
+
+        let check = validate_final_answer(Some(&contract), answer);
+
+        assert_eq!(check, FinalAnswerCheck::Satisfied);
+    }
+
+    #[test]
+    fn agent_generate_sql_accepts_sql_without_execute_query() {
+        let contract = generate_contract("统计 2026年1月2日新注册会员数量", "agent");
+        let answer = "```sql\nSELECT COUNT(*) FROM tb_customer;\n```";
+
+        let check = validate_final_answer(Some(&contract), answer);
+
+        assert_eq!(check, FinalAnswerCheck::Satisfied);
+    }
+
+    #[test]
+    fn agent_generate_sql_prompt_does_not_force_execution() {
+        let contract = generate_contract("帮我生成统计 2026年1月2日新注册会员数量的 sql", "agent");
+
+        let prompt = augment_system_prompt_with_task_contract("base", Some(&contract), true);
+
+        assert!(prompt.contains("SQL-producing action"));
+        assert!(prompt.contains("execute a query only when the original request explicitly asks for real data/results"));
+    }
+
+    #[test]
+    fn wraps_tool_results_as_intermediate_evidence() {
+        let wrapped = tool_result_for_followup_context("get_columns", "Columns of tb_customer:\n  - c_no: VARCHAR");
+
+        assert!(wrapped.contains("INTERMEDIATE EVIDENCE"));
+        assert!(wrapped.contains("continue the original user task"));
+        assert!(wrapped.contains("Columns of tb_customer"));
+    }
+
+    // --- chunk_to_events tests ---
+
+    #[test]
+    fn chunk_to_events_emits_text_delta_for_text() {
+        let chunk = AiStreamChunk {
+            session_id: "test".to_string(),
+            delta: "hello".to_string(),
+            reasoning_delta: None,
+            done: false,
+        };
+        let events = chunk_to_events(&chunk);
+        assert_eq!(events.len(), 1);
+        assert!(matches!(&events[0], AgentEvent::TextDelta { delta } if delta == "hello"));
+    }
+
+    #[test]
+    fn chunk_to_events_emits_reasoning_delta_for_reasoning() {
+        let chunk = AiStreamChunk {
+            session_id: "test".to_string(),
+            delta: String::new(),
+            reasoning_delta: Some("thinking...".to_string()),
+            done: false,
+        };
+        let events = chunk_to_events(&chunk);
+        assert_eq!(events.len(), 1);
+        assert!(matches!(&events[0], AgentEvent::ReasoningDelta { delta } if delta == "thinking..."));
+    }
+
+    #[test]
+    fn chunk_to_events_emits_both_for_mixed_chunk() {
+        let chunk = AiStreamChunk {
+            session_id: "test".to_string(),
+            delta: "answer".to_string(),
+            reasoning_delta: Some("thinking...".to_string()),
+            done: false,
+        };
+        let events = chunk_to_events(&chunk);
+        assert_eq!(events.len(), 2);
+        assert!(matches!(&events[0], AgentEvent::TextDelta { delta } if delta == "answer"));
+        assert!(matches!(&events[1], AgentEvent::ReasoningDelta { delta } if delta == "thinking..."));
+    }
+
+    #[test]
+    fn chunk_to_events_returns_empty_for_empty_chunk() {
+        let chunk =
+            AiStreamChunk { session_id: "test".to_string(), delta: String::new(), reasoning_delta: None, done: false };
+        let events = chunk_to_events(&chunk);
+        assert!(events.is_empty());
+    }
+
+    #[test]
+    fn chunk_to_events_reasoning_only_no_text() {
+        let chunk = AiStreamChunk {
+            session_id: "test".to_string(),
+            delta: String::new(),
+            reasoning_delta: Some("reasoning".to_string()),
+            done: false,
+        };
+        let events = chunk_to_events(&chunk);
+        assert_eq!(events.len(), 1);
+        assert!(matches!(&events[0], AgentEvent::ReasoningDelta { .. }));
+    }
+
+    #[test]
+    fn chunk_to_events_text_only_no_reasoning() {
+        let chunk = AiStreamChunk {
+            session_id: "test".to_string(),
+            delta: "text only".to_string(),
+            reasoning_delta: None,
+            done: false,
+        };
+        let events = chunk_to_events(&chunk);
+        assert_eq!(events.len(), 1);
+        assert!(matches!(&events[0], AgentEvent::TextDelta { .. }));
+    }
+
+    // --- Agent task-action contract tests (query / exploreSchema / executeAndExplain) ---
+
+    fn contract_for(action: &str, user_request: &str, mode: &str) -> AiTaskContract {
+        AiTaskContract {
+            action: Some(action.to_string()),
+            mode: Some(mode.to_string()),
+            user_request: Some(user_request.to_string()),
+        }
+    }
+
+    #[test]
+    fn query_action_contract_requires_execute_query() {
+        let contract = contract_for("query", "统计今天订单数", "agent");
+        let prompt = augment_system_prompt_with_task_contract("base", Some(&contract), true);
+
+        assert!(prompt.contains("data-query task"), "prompt should mark this as a data-query task");
+        assert!(prompt.contains("call execute_query"), "prompt should instruct the LLM to call execute_query");
+        assert!(!prompt.contains("SQL-producing action"), "query must not be treated as a SQL-producing action");
+    }
+
+    #[test]
+    fn explore_schema_contract_uses_metadata_tools_not_execute_query() {
+        let contract = contract_for("exploreSchema", "看一下 orders 表的结构", "agent");
+        let prompt = augment_system_prompt_with_task_contract("base", Some(&contract), true);
+
+        assert!(prompt.contains("schema-inspection task"));
+        assert!(prompt.contains("list_tables/get_columns"));
+        assert!(prompt.contains("Do not execute data queries"));
+    }
+
+    #[test]
+    fn execute_and_explain_contract_runs_current_sql() {
+        let contract = contract_for("executeAndExplain", "执行并解释当前 SQL", "agent");
+        let prompt = augment_system_prompt_with_task_contract("base", Some(&contract), true);
+
+        assert!(prompt.contains("execute-and-explain task"));
+        assert!(prompt.contains("run the current SQL"));
+    }
+
+    #[test]
+    fn task_actions_do_not_require_sql_deliverable() {
+        // query / exploreSchema / executeAndExplain are task-oriented, not SQL-producing:
+        // a final answer without a fenced SQL block must still satisfy the contract.
+        let answer_without_sql = "今天共有 42 笔订单。";
+        for action in ["query", "exploreSchema", "executeAndExplain"] {
+            let contract = contract_for(action, "统计今天订单数", "agent");
+            assert_eq!(
+                validate_final_answer(Some(&contract), answer_without_sql),
+                FinalAnswerCheck::Satisfied,
+                "action {action} should not require a SQL deliverable",
+            );
+        }
+    }
+
+    #[test]
+    fn query_action_repair_prompt_targets_execute_query() {
+        let contract = contract_for("query", "统计今天订单数", "agent");
+        let repair = build_contract_repair_prompt(Some(&contract), true, "previous answer did not execute");
+
+        assert!(repair.contains("data-query task"));
+        assert!(repair.contains("call execute_query"));
+    }
+
+    #[test]
+    fn general_action_skips_sql_validation() {
+        let contract = AiTaskContract {
+            action: Some("general".to_string()),
+            mode: Some("ask".to_string()),
+            user_request: Some("你好".to_string()),
+        };
+        let answer = "你好！我是 DBX 的数据库助手。有什么可以帮你的吗？";
+        assert_eq!(validate_final_answer(Some(&contract), answer), FinalAnswerCheck::Satisfied);
+    }
+}
diff --git a/crates/dbx-core/src/agent_manager.rs b/crates/dbx-core/src/agent_manager.rs
new file mode 100644
index 0000000..5e54c1e
--- /dev/null
+++ b/crates/dbx-core/src/agent_manager.rs
@@ -0,0 +1,942 @@
+use std::ffi::OsStr;
+use std::fs::File;
+use std::io::Read;
+use std::path::{Path, PathBuf};
+
+use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+
+use crate::db::agent_driver::{AgentDriverClient, AgentLaunchSpec, AgentMethod};
+use crate::models::connection::DatabaseType;
+
+pub const DEFAULT_JRE_KEY: &str = "21";
+pub const DOWNLOAD_CACHE_DIR_NAME: &str = "download-cache";
+pub const DOWNLOAD_CACHE_MAX_AGE_DAYS: u64 = 7;
+
+fn default_jre_key() -> String {
+    DEFAULT_JRE_KEY.to_string()
+}
+
+fn is_valid_jar_file(path: &Path) -> bool {
+    if !path.is_file() {
+        return false;
+    }
+    let Some(file) = File::open(path).ok() else {
+        return false;
+    };
+    let Some(mut archive) = zip::ZipArchive::new(file).ok() else {
+        return false;
+    };
+    let Some(mut manifest) = archive.by_name("META-INF/MANIFEST.MF").ok() else {
+        return false;
+    };
+    let mut manifest_text = String::new();
+    manifest.read_to_string(&mut manifest_text).is_ok() && manifest_text.contains("Main-Class:")
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentRegistry {
+    #[serde(default)]
+    pub jre: Option<JreInfo>,
+    #[serde(default)]
+    pub jres: std::collections::HashMap<String, JreInfo>,
+    pub drivers: std::collections::HashMap<String, DriverInfo>,
+}
+
+impl AgentRegistry {
+    pub fn resolve_jre(&self, key: &str) -> Option<&JreInfo> {
+        if !self.jres.is_empty() {
+            return self.jres.get(key);
+        }
+        if key == DEFAULT_JRE_KEY {
+            self.jre.as_ref()
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    fn test_manager(name: &str) -> AgentManager {
+        let dir = std::env::temp_dir().join(format!("dbx-agent-manager-{name}-{}", uuid::Uuid::new_v4()));
+        AgentManager::new_with_base_dir(dir)
+    }
+
+    fn touch(path: &Path) {
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent).unwrap();
+        }
+        fs::write(path, b"").unwrap();
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+
+            let mut permissions = fs::metadata(path).unwrap().permissions();
+            permissions.set_mode(0o755);
+            fs::set_permissions(path, permissions).unwrap();
+        }
+    }
+
+    #[test]
+    fn cleanup_pending_jre_removes_stash_dirs_and_persists() {
+        let manager = test_manager("pending-cleanup");
+        std::fs::create_dir_all(manager.base_dir()).unwrap();
+        let stash = manager.base_dir().join("jre-21.old-1700000000-deadbeef");
+        std::fs::create_dir_all(&stash).unwrap();
+        std::fs::write(stash.join("dummy"), b"x").unwrap();
+
+        let mut state = AgentState::default();
+        state.pending_jre_cleanup.push(stash.clone());
+        manager.save_state(&state).unwrap();
+
+        // Re-create the manager (simulates app restart).
+        let manager2 = AgentManager::new_with_base_dir(manager.base_dir().clone());
+
+        assert!(!stash.exists(), "stash dir should be removed");
+        let after = manager2.load_state();
+        assert!(after.pending_jre_cleanup.is_empty(), "cleanup should drain the list on success");
+    }
+
+    #[test]
+    fn cleanup_orphan_jre_dirs_removes_unrecorded_stash() {
+        let manager = test_manager("orphan-cleanup");
+        std::fs::create_dir_all(manager.base_dir()).unwrap();
+        let orphan = manager.base_dir().join("jre-21.old-1234567890-cafe");
+        std::fs::create_dir_all(&orphan).unwrap();
+
+        // Re-create manager — it should sweep orphans even without state.
+        let _manager2 = AgentManager::new_with_base_dir(manager.base_dir().clone());
+
+        assert!(!orphan.exists(), "orphan stash should be swept");
+    }
+
+    #[test]
+    fn cleanup_skips_active_jre_dir() {
+        let manager = test_manager("orphan-skip-active");
+        std::fs::create_dir_all(manager.base_dir()).unwrap();
+        let active = manager.jre_dir(DEFAULT_JRE_KEY); // jre-21
+        std::fs::create_dir_all(&active).unwrap();
+
+        let _manager2 = AgentManager::new_with_base_dir(manager.base_dir().clone());
+
+        assert!(active.exists(), "active jre-<key> dir must not be touched (no .old- in name)");
+    }
+
+    #[test]
+    fn agent_state_back_compat_without_pending_jre_cleanup() {
+        // Old state JSON without pending_jre_cleanup must still deserialize.
+        let json = r#"{
+            "jre_versions": {},
+            "installed_drivers": {},
+            "java_runtime": {"mode": "managed"}
+        }"#;
+        let state: AgentState = serde_json::from_str(json).expect("deserialize legacy state");
+        assert!(state.pending_jre_cleanup.is_empty());
+    }
+
+    #[test]
+    fn resolves_managed_java_runtime_by_default() {
+        let manager = test_manager("managed");
+        let java = manager.jre_java_path(DEFAULT_JRE_KEY);
+        touch(&java);
+
+        let state = AgentState::default();
+
+        assert_eq!(manager.resolve_java_runtime(&state, DEFAULT_JRE_KEY).unwrap(), java);
+    }
+
+    #[test]
+    fn resolves_custom_java_runtime_when_configured() {
+        let manager = test_manager("custom");
+        let custom_java = manager.base_dir().join("custom").join("bin").join("java");
+        touch(&custom_java);
+        let state = AgentState {
+            java_runtime: JavaRuntimeConfig {
+                mode: JavaRuntimeMode::Custom,
+                custom_java_path: Some(custom_java.to_string_lossy().to_string()),
+            },
+            ..AgentState::default()
+        };
+
+        assert_eq!(manager.resolve_java_runtime(&state, DEFAULT_JRE_KEY).unwrap(), custom_java);
+    }
+
+    #[test]
+    fn rejects_missing_custom_java_runtime() {
+        let manager = test_manager("missing-custom");
+        let state = AgentState {
+            java_runtime: JavaRuntimeConfig {
+                mode: JavaRuntimeMode::Custom,
+                custom_java_path: Some(manager.base_dir().join("missing-java").to_string_lossy().to_string()),
+            },
+            ..AgentState::default()
+        };
+
+        let err = manager.resolve_java_runtime(&state, DEFAULT_JRE_KEY).unwrap_err();
+
+        assert!(err.contains("Custom Java runtime does not exist"));
+    }
+
+    #[test]
+    fn stores_configured_app_version_for_agent_handshake() {
+        let dir = std::env::temp_dir().join(format!("dbx-agent-manager-version-{}", uuid::Uuid::new_v4()));
+        let manager = AgentManager::new_with_base_dir_and_app_version(dir, "0.5.13");
+
+        assert_eq!(manager.agent_app_version(), "0.5.13");
+    }
+
+    #[test]
+    fn resolves_system_java_runtime_from_path() {
+        let manager = test_manager("system");
+        let system_java = manager.base_dir().join("bin").join(if cfg!(windows) { "java.exe" } else { "java" });
+        touch(&system_java);
+        let path = std::env::join_paths([system_java.parent().unwrap()]).unwrap();
+
+        assert_eq!(resolve_system_java_path(Some(path.as_os_str())).unwrap(), system_java);
+    }
+
+    #[tokio::test]
+    async fn runtime_gateway_returns_existing_missing_driver_error() {
+        let manager = test_manager("missing-driver");
+
+        let err = match manager.spawn(&DatabaseType::H2, None).await {
+            Ok(_) => panic!("missing driver should fail"),
+            Err(err) => err,
+        };
+
+        assert_eq!(err, "h2 driver is not installed. Please install it from the Driver Manager.");
+    }
+
+    #[tokio::test]
+    async fn runtime_gateway_returns_existing_missing_java_error() {
+        let manager = test_manager("missing-java");
+        let jar = manager.driver_jar_path("h2");
+        touch(&jar);
+
+        let err = match manager.spawn(&DatabaseType::H2, None).await {
+            Ok(_) => panic!("missing Java runtime should fail"),
+            Err(err) => err,
+        };
+
+        assert_eq!(err, "JRE 21 runtime is not installed. Please install it from the Driver Manager.");
+    }
+
+    #[tokio::test]
+    async fn runtime_gateway_resolves_profile_specific_keys() {
+        let manager = test_manager("profile-key");
+
+        assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Oracle, Some("oracle-10g")), Some("oracle"));
+        assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Oracle, Some("oracle-legacy")), Some("oracle"));
+        assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Oracle, None), Some("oracle"));
+        assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Gbase, Some("gbase8s")), Some("gbase8s"));
+        assert_eq!(AgentManager::db_type_to_agent_key(&DatabaseType::Gbase, None), Some("gbase8a"));
+        manager.stop_daemon_by_key("oracle").await;
+        manager.stop_daemon_by_key("gbase8s").await;
+    }
+
+    #[test]
+    fn resolves_native_agent_launch_when_agent_executable_exists() {
+        let manager = test_manager("native-agent");
+        let native = manager.driver_native_path("dameng");
+        touch(&native);
+
+        let launch = manager
+            .resolve_agent_launch_spec(&AgentState::default(), "dameng", DEFAULT_JRE_KEY)
+            .expect("native launch should resolve");
+
+        assert_eq!(launch.program, native);
+        assert_eq!(launch.args, Vec::<String>::new());
+        assert_eq!(launch.working_dir.as_deref(), Some(manager.driver_dir("dameng").as_path()));
+    }
+
+    #[test]
+    fn resolves_manifest_agent_launch_with_driver_dir_templates() {
+        let manager = test_manager("manifest-agent");
+        let driver_dir = manager.driver_dir("dameng-go");
+        fs::create_dir_all(driver_dir.join("bin")).unwrap();
+        fs::write(
+            manager.driver_launch_config_path("dameng-go"),
+            r#"{
+                "command": "bin/dameng-agent",
+                "args": ["--config", "{driver_dir}/config.json"],
+                "working_dir": "{driver_dir}"
+            }"#,
+        )
+        .unwrap();
+
+        let launch = manager
+            .resolve_agent_launch_spec(&AgentState::default(), "dameng-go", DEFAULT_JRE_KEY)
+            .expect("manifest launch should resolve");
+
+        assert_eq!(launch.program, driver_dir.join("bin").join("dameng-agent"));
+        assert_eq!(
+            launch.args,
+            vec!["--config".to_string(), driver_dir.join("config.json").to_string_lossy().to_string()]
+        );
+        assert_eq!(launch.working_dir.as_deref(), Some(driver_dir.as_path()));
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JreInfo {
+    pub version: String,
+    pub platforms: std::collections::HashMap<String, ArtifactInfo>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DriverInfo {
+    pub version: String,
+    pub label: String,
+    pub min_app_version: String,
+    #[serde(default)]
+    pub jar: Option<ArtifactInfo>,
+    #[serde(default)]
+    pub native: std::collections::HashMap<String, ArtifactInfo>,
+    #[serde(default = "default_jre_key")]
+    pub jre: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ArtifactInfo {
+    pub url: String,
+    pub size: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct AgentState {
+    #[serde(default)]
+    pub jre_version: Option<String>,
+    #[serde(default)]
+    pub jre_versions: std::collections::HashMap<String, String>,
+    #[serde(default)]
+    pub installed_drivers: std::collections::HashMap<String, InstalledDriver>,
+    #[serde(default)]
+    pub java_runtime: JavaRuntimeConfig,
+    /// Old JRE directories that could not be deleted in-place during a
+    /// reinstall on Windows; renamed aside (`<name>.old-<ts>-<rand>`) and
+    /// cleaned up best-effort on next `AgentManager::new`.
+    #[serde(default)]
+    pub pending_jre_cleanup: Vec<PathBuf>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct InstalledDriver {
+    pub version: String,
+    pub installed_at: String,
+    #[serde(default = "default_jre_key")]
+    pub jre: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentLaunchConfig {
+    pub command: String,
+    #[serde(default)]
+    pub args: Vec<String>,
+    #[serde(default)]
+    pub working_dir: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(rename_all = "snake_case")]
+pub enum JavaRuntimeMode {
+    #[default]
+    Managed,
+    System,
+    Custom,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct JavaRuntimeConfig {
+    #[serde(default)]
+    pub mode: JavaRuntimeMode,
+    #[serde(default)]
+    pub custom_java_path: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AgentDriverInfo {
+    pub db_type: String,
+    pub label: String,
+    pub version: String,
+    pub size: u64,
+    pub installed: bool,
+    pub installed_version: Option<String>,
+    pub update_available: bool,
+    pub requires_java_runtime: bool,
+    pub jre: String,
+    pub jre_installed: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DriverStoreUsageItem {
+    pub id: String,
+    pub bytes: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DriverStoreUsage {
+    pub total_bytes: u64,
+    pub jre_bytes: u64,
+    pub agent_driver_bytes: u64,
+    #[serde(default)]
+    pub download_cache_bytes: u64,
+    pub jdbc_plugin_bytes: u64,
+    pub jdbc_driver_bytes: u64,
+    pub jres: Vec<DriverStoreUsageItem>,
+    pub agent_drivers: Vec<DriverStoreUsageItem>,
+}
+
+pub struct AgentManager {
+    base_dir: PathBuf,
+    app_version: String,
+    pub(crate) daemons: Mutex<std::collections::HashMap<String, AgentDriverClient>>,
+}
+
+impl Default for AgentManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl AgentManager {
+    pub fn new() -> Self {
+        let home =
+            std::env::var(if cfg!(windows) { "USERPROFILE" } else { "HOME" }).unwrap_or_else(|_| ".".to_string());
+        Self::new_with_base_dir(PathBuf::from(home).join(".dbx").join("agents"))
+    }
+
+    pub fn new_with_base_dir(base_dir: PathBuf) -> Self {
+        Self::new_with_base_dir_and_app_version(base_dir, env!("CARGO_PKG_VERSION"))
+    }
+
+    pub fn new_with_base_dir_and_app_version(base_dir: PathBuf, app_version: impl Into<String>) -> Self {
+        let mgr =
+            Self { base_dir, app_version: app_version.into(), daemons: Mutex::new(std::collections::HashMap::new()) };
+        mgr.migrate_legacy_jre();
+        mgr.cleanup_pending_jre_dirs();
+        mgr.cleanup_orphan_jre_dirs();
+        mgr
+    }
+
+    fn migrate_legacy_jre(&self) {
+        let legacy = self.base_dir.join("jre");
+        let versioned = self.jre_dir(DEFAULT_JRE_KEY);
+        if legacy.exists() && !versioned.exists() {
+            let _ = std::fs::rename(&legacy, &versioned);
+        }
+    }
+
+    /// Best-effort cleanup of `pending_jre_cleanup` paths recorded by previous
+    /// runs that fell back to renaming an old JRE aside on Windows. Successful
+    /// removals are pruned from the persisted state. Failures are kept for the
+    /// next launch and never block startup. (Issue #1100, D6.)
+    fn cleanup_pending_jre_dirs(&self) {
+        let mut state = self.load_state();
+        if state.pending_jre_cleanup.is_empty() {
+            return;
+        }
+        let mut remaining = Vec::new();
+        for path in std::mem::take(&mut state.pending_jre_cleanup) {
+            if !path.exists() {
+                continue;
+            }
+            match std::fs::remove_dir_all(&path) {
+                Ok(()) => log::info!("Cleaned up pending JRE stash: {}", path.display()),
+                Err(err) => {
+                    log::warn!("Pending JRE cleanup failed for {}: {err}", path.display());
+                    remaining.push(path);
+                }
+            }
+        }
+        state.pending_jre_cleanup = remaining;
+        if let Err(err) = self.save_state(&state) {
+            log::warn!("Failed to persist post-cleanup AgentState: {err}");
+        }
+    }
+
+    /// Sweep `base_dir` for orphan `*.old-*` JRE stash directories left behind
+    /// by previous runs (e.g. process crashed before the stash was recorded).
+    /// Best-effort — failures are ignored.
+    fn cleanup_orphan_jre_dirs(&self) {
+        let entries = match std::fs::read_dir(&self.base_dir) {
+            Ok(e) => e,
+            Err(_) => return,
+        };
+        for entry in entries.flatten() {
+            let Some(name) = entry.file_name().to_str().map(str::to_string) else {
+                continue;
+            };
+            // Match `<...>.old-<digits>-<...>` (typically `jre-21.old-...`),
+            // which is the suffix scheme used by stash_old_jre_dir.
+            if !name.starts_with("jre-") || !name.contains(".old-") {
+                continue;
+            }
+            let path = entry.path();
+            if !path.is_dir() {
+                continue;
+            }
+            match std::fs::remove_dir_all(&path) {
+                Ok(()) => log::info!("Cleaned up orphan JRE stash: {}", path.display()),
+                Err(err) => log::warn!("Orphan JRE cleanup failed for {}: {err}", path.display()),
+            }
+        }
+    }
+
+    pub fn base_dir(&self) -> &PathBuf {
+        &self.base_dir
+    }
+
+    pub fn agent_app_version(&self) -> &str {
+        &self.app_version
+    }
+
+    pub fn jre_dir(&self, jre_key: &str) -> PathBuf {
+        self.base_dir.join(format!("jre-{jre_key}"))
+    }
+
+    pub fn jre_java_path(&self, jre_key: &str) -> PathBuf {
+        let dir = self.jre_dir(jre_key);
+        let java_name = if cfg!(windows) { "java.exe" } else { "java" };
+        let flat = dir.join("bin").join(java_name);
+        if flat.exists() {
+            return flat;
+        }
+        // Some macOS runtimes are unpacked with a Contents/Home/ layout.
+        let macos = dir.join("Contents").join("Home").join("bin").join(java_name);
+        if macos.exists() {
+            return macos;
+        }
+        flat
+    }
+
+    pub fn driver_dir(&self, db_type: &str) -> PathBuf {
+        self.base_dir.join("drivers").join(db_type)
+    }
+
+    pub fn driver_jar_path(&self, db_type: &str) -> PathBuf {
+        self.driver_dir(db_type).join("agent.jar")
+    }
+
+    pub fn driver_native_path(&self, db_type: &str) -> PathBuf {
+        let executable_name = if cfg!(windows) { "agent.exe" } else { "agent" };
+        self.driver_dir(db_type).join(executable_name)
+    }
+
+    pub fn driver_launch_config_path(&self, db_type: &str) -> PathBuf {
+        self.driver_dir(db_type).join("agent-launch.json")
+    }
+
+    pub fn download_cache_dir(&self) -> PathBuf {
+        self.base_dir.join(DOWNLOAD_CACHE_DIR_NAME)
+    }
+
+    pub fn download_cache_max_age_days(&self) -> u64 {
+        DOWNLOAD_CACHE_MAX_AGE_DAYS
+    }
+
+    fn state_path(&self) -> PathBuf {
+        self.base_dir.join("state.json")
+    }
+
+    pub fn load_state(&self) -> AgentState {
+        std::fs::read_to_string(self.state_path()).ok().and_then(|s| serde_json::from_str(&s).ok()).unwrap_or_default()
+    }
+
+    pub fn save_state(&self, state: &AgentState) -> Result<(), String> {
+        let dir = self.base_dir.clone();
+        std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
+        let json = serde_json::to_string_pretty(state).map_err(|e| e.to_string())?;
+        std::fs::write(self.state_path(), json).map_err(|e| e.to_string())
+    }
+
+    pub fn is_jre_installed(&self, jre_key: &str) -> bool {
+        self.jre_java_path(jre_key).exists()
+    }
+
+    pub fn is_driver_installed(&self, db_type: &str) -> bool {
+        self.is_driver_jar_valid(db_type)
+            || self.driver_native_path(db_type).exists()
+            || self.driver_launch_config_path(db_type).exists()
+    }
+
+    pub fn is_driver_jar_valid(&self, db_type: &str) -> bool {
+        is_valid_jar_file(&self.driver_jar_path(db_type))
+    }
+
+    pub fn driver_requires_java_runtime(&self, db_type: &str) -> bool {
+        self.is_driver_jar_valid(db_type)
+            && !self.driver_native_path(db_type).exists()
+            && !self.driver_launch_config_path(db_type).exists()
+    }
+
+    pub fn resolve_agent_launch_spec(
+        &self,
+        state: &AgentState,
+        driver_key: &str,
+        jre_key: &str,
+    ) -> Result<AgentLaunchSpec, String> {
+        self.resolve_agent_launch_spec_with_extra_args(state, driver_key, jre_key, &[])
+    }
+
+    pub fn resolve_agent_launch_spec_with_extra_args(
+        &self,
+        state: &AgentState,
+        driver_key: &str,
+        jre_key: &str,
+        extra_java_args: &[String],
+    ) -> Result<AgentLaunchSpec, String> {
+        let driver_dir = self.driver_dir(driver_key);
+        let config_path = self.driver_launch_config_path(driver_key);
+        if config_path.exists() {
+            return self.resolve_configured_agent_launch_spec(driver_key, &driver_dir, &config_path);
+        }
+
+        let native_path = self.driver_native_path(driver_key);
+        if native_path.exists() {
+            return Ok(AgentLaunchSpec::new(native_path).with_working_dir(driver_dir));
+        }
+
+        let jar_path = self.driver_jar_path(driver_key);
+        if jar_path.exists() {
+            let java = self.resolve_java_runtime(state, jre_key)?;
+            if !is_valid_jar_file(&jar_path) {
+                return Err(format!(
+                    "{driver_key} driver jar is invalid or corrupt. Please reinstall it from the Driver Manager."
+                ));
+            }
+            return Ok(AgentLaunchSpec::java_jar_with_extra_args(java, jar_path, extra_java_args));
+        }
+
+        Err(format!("{driver_key} driver is not installed. Please install it from the Driver Manager."))
+    }
+
+    fn resolve_configured_agent_launch_spec(
+        &self,
+        driver_key: &str,
+        driver_dir: &Path,
+        config_path: &Path,
+    ) -> Result<AgentLaunchSpec, String> {
+        let json = std::fs::read_to_string(config_path)
+            .map_err(|e| format!("Failed to read {driver_key} agent launch config: {e}"))?;
+        let config: AgentLaunchConfig = serde_json::from_str(&json)
+            .map_err(|e| format!("Failed to parse {driver_key} agent launch config: {e}"))?;
+        let command = config.command.trim();
+        if command.is_empty() {
+            return Err(format!("{driver_key} agent launch config command is empty"));
+        }
+        let working_dir = config
+            .working_dir
+            .as_deref()
+            .map(|value| self.resolve_driver_launch_path(driver_dir, value))
+            .transpose()?
+            .unwrap_or_else(|| driver_dir.to_path_buf());
+        let program = self.resolve_driver_launch_path(driver_dir, command)?;
+        let args = config.args.iter().map(|arg| self.expand_agent_launch_template(driver_dir, arg)).collect::<Vec<_>>();
+        Ok(AgentLaunchSpec::new(program).with_args(args).with_working_dir(working_dir))
+    }
+
+    fn resolve_driver_launch_path(&self, driver_dir: &Path, value: &str) -> Result<PathBuf, String> {
+        let expanded = self.expand_agent_launch_template(driver_dir, value);
+        let path = PathBuf::from(&expanded);
+        if path.is_absolute() || expanded.contains('/') || expanded.contains('\\') || expanded.starts_with('.') {
+            return Ok(if path.is_absolute() { path } else { driver_dir.join(path) });
+        }
+        Ok(path)
+    }
+
+    fn expand_agent_launch_template(&self, driver_dir: &Path, value: &str) -> String {
+        value
+            .replace("{driver_dir}", &driver_dir.to_string_lossy())
+            .replace("{agent_dir}", &self.base_dir.to_string_lossy())
+            .replace("{platform}", Self::current_platform())
+    }
+
+    pub fn collect_driver_store_usage(&self, plugin_root: &Path) -> DriverStoreUsage {
+        let mut jres = Vec::new();
+        let mut jre_bytes = 0u64;
+        if let Ok(entries) = std::fs::read_dir(&self.base_dir) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if !path.is_dir() {
+                    continue;
+                }
+                let Some(name) = path.file_name().and_then(|v| v.to_str()) else {
+                    continue;
+                };
+                if !name.starts_with("jre-") {
+                    continue;
+                }
+                let key = name.trim_start_matches("jre-").to_string();
+                let bytes = path_size_bytes(&path);
+                jre_bytes = jre_bytes.saturating_add(bytes);
+                jres.push(DriverStoreUsageItem { id: key, bytes });
+            }
+        }
+        jres.sort_by(|left, right| left.id.cmp(&right.id));
+
+        let mut agent_drivers = Vec::new();
+        let mut agent_driver_bytes = 0u64;
+        let drivers_root = self.base_dir.join("drivers");
+        if let Ok(entries) = std::fs::read_dir(&drivers_root) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if !path.is_dir() {
+                    continue;
+                }
+                let Some(id) = path.file_name().and_then(|v| v.to_str()) else {
+                    continue;
+                };
+                let bytes = path_size_bytes(&path);
+                agent_driver_bytes = agent_driver_bytes.saturating_add(bytes);
+                agent_drivers.push(DriverStoreUsageItem { id: id.to_string(), bytes });
+            }
+        }
+        agent_drivers.sort_by(|left, right| left.id.cmp(&right.id));
+
+        let jdbc_root = plugin_root.join("jdbc");
+        let jdbc_driver_root = jdbc_root.join("drivers");
+        let jdbc_driver_bytes = path_size_bytes(&jdbc_driver_root);
+        let jdbc_total_bytes = path_size_bytes(&jdbc_root);
+        let jdbc_plugin_bytes = jdbc_total_bytes.saturating_sub(jdbc_driver_bytes);
+        let download_cache_bytes = path_size_bytes(&self.download_cache_dir());
+
+        DriverStoreUsage {
+            total_bytes: jre_bytes
+                .saturating_add(agent_driver_bytes)
+                .saturating_add(download_cache_bytes)
+                .saturating_add(jdbc_plugin_bytes)
+                .saturating_add(jdbc_driver_bytes),
+            jre_bytes,
+            agent_driver_bytes,
+            download_cache_bytes,
+            jdbc_plugin_bytes,
+            jdbc_driver_bytes,
+            jres,
+            agent_drivers,
+        }
+    }
+
+    pub fn resolve_java_runtime(&self, state: &AgentState, jre_key: &str) -> Result<PathBuf, String> {
+        match state.java_runtime.mode {
+            JavaRuntimeMode::Managed => {
+                if !self.is_jre_installed(jre_key) {
+                    return Err(format!(
+                        "JRE {jre_key} runtime is not installed. Please install it from the Driver Manager."
+                    ));
+                }
+                Ok(self.jre_java_path(jre_key))
+            }
+            JavaRuntimeMode::System => resolve_system_java_path(None).ok_or_else(|| {
+                "System Java runtime was not found on PATH. Please install Java or choose a custom Java executable."
+                    .to_string()
+            }),
+            JavaRuntimeMode::Custom => {
+                let path = state
+                    .java_runtime
+                    .custom_java_path
+                    .as_deref()
+                    .map(str::trim)
+                    .filter(|path| !path.is_empty())
+                    .ok_or_else(|| "Custom Java runtime path is empty. Please choose a Java executable.".to_string())?;
+                resolve_custom_java_path(path)
+            }
+        }
+    }
+
+    pub async fn stop_daemons(&self) {
+        crate::agent_runtime::stop_daemons(self).await;
+    }
+
+    pub async fn stop_daemon_by_key(&self, agent_key: &str) {
+        crate::agent_runtime::stop_daemon_by_key(self, agent_key).await;
+    }
+
+    pub async fn restart_daemon_by_key(&self, agent_key: &str) -> Result<(), String> {
+        crate::agent_runtime::restart_daemon_by_key(self, agent_key).await
+    }
+
+    pub async fn active_daemon_keys(&self) -> Vec<String> {
+        self.daemons.lock().await.keys().cloned().collect()
+    }
+
+    pub fn db_type_to_agent_key(db_type: &DatabaseType, driver_profile: Option<&str>) -> Option<&'static str> {
+        crate::agent_runtime::db_type_to_agent_key(db_type, driver_profile)
+    }
+
+    pub fn is_agent_type(db_type: &DatabaseType) -> bool {
+        crate::agent_runtime::is_agent_type(db_type)
+    }
+
+    pub async fn spawn(
+        &self,
+        db_type: &DatabaseType,
+        driver_profile: Option<&str>,
+    ) -> Result<AgentDriverClient, String> {
+        self.spawn_with_extra_java_args(db_type, driver_profile, &[]).await
+    }
+
+    pub async fn spawn_with_extra_java_args(
+        &self,
+        db_type: &DatabaseType,
+        driver_profile: Option<&str>,
+        extra_java_args: &[String],
+    ) -> Result<AgentDriverClient, String> {
+        crate::agent_runtime::spawn_connection_client(self, db_type, driver_profile, extra_java_args).await
+    }
+
+    pub async fn call_daemon<T: serde::de::DeserializeOwned + Send + 'static>(
+        &self,
+        db_type: &DatabaseType,
+        driver_profile: Option<&str>,
+        method: &str,
+        params: serde_json::Value,
+    ) -> Result<T, String> {
+        crate::agent_runtime::call_daemon(self, db_type, driver_profile, method, params).await
+    }
+
+    pub async fn call_daemon_with_timeout<T: serde::de::DeserializeOwned + Send + 'static>(
+        &self,
+        db_type: &DatabaseType,
+        driver_profile: Option<&str>,
+        method: &str,
+        params: serde_json::Value,
+        timeout_duration: Option<std::time::Duration>,
+    ) -> Result<T, String> {
+        crate::agent_runtime::call_daemon_with_timeout(self, db_type, driver_profile, method, params, timeout_duration)
+            .await
+    }
+
+    pub async fn call_daemon_method<T: serde::de::DeserializeOwned + Send + 'static>(
+        &self,
+        db_type: &DatabaseType,
+        driver_profile: Option<&str>,
+        method: AgentMethod,
+        params: serde_json::Value,
+    ) -> Result<T, String> {
+        crate::agent_runtime::call_daemon_method(self, db_type, driver_profile, method, params).await
+    }
+
+    pub async fn call_daemon_method_with_timeout<T: serde::de::DeserializeOwned + Send + 'static>(
+        &self,
+        db_type: &DatabaseType,
+        driver_profile: Option<&str>,
+        method: AgentMethod,
+        params: serde_json::Value,
+        timeout_duration: Option<std::time::Duration>,
+    ) -> Result<T, String> {
+        crate::agent_runtime::call_daemon_method_with_timeout(
+            self,
+            db_type,
+            driver_profile,
+            method,
+            params,
+            timeout_duration,
+        )
+        .await
+    }
+
+    pub async fn download_file(url: &str, dest: &Path) -> Result<(), String> {
+        if let Some(parent) = dest.parent() {
+            std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+        }
+        let resp = reqwest::get(url).await.map_err(|e| format!("Download failed: {e}"))?;
+        if !resp.status().is_success() {
+            return Err(format!("Download failed with status: {}", resp.status()));
+        }
+        let bytes = resp.bytes().await.map_err(|e| format!("Download read failed: {e}"))?;
+        std::fs::write(dest, &bytes).map_err(|e| format!("Failed to write file: {e}"))
+    }
+
+    pub fn current_platform() -> &'static str {
+        if cfg!(target_os = "macos") && cfg!(target_arch = "aarch64") {
+            "macos-aarch64"
+        } else if cfg!(target_os = "macos") && cfg!(target_arch = "x86_64") {
+            "macos-x64"
+        } else if cfg!(target_os = "linux") && cfg!(target_arch = "aarch64") {
+            "linux-aarch64"
+        } else if cfg!(target_os = "linux") && cfg!(target_arch = "x86_64") {
+            "linux-x64"
+        } else if cfg!(target_os = "windows") && cfg!(target_arch = "aarch64") {
+            "windows-aarch64"
+        } else if cfg!(target_os = "windows") && cfg!(target_arch = "x86_64") {
+            "windows-x64"
+        } else {
+            "unknown"
+        }
+    }
+}
+
+fn path_size_bytes(path: &Path) -> u64 {
+    if let Ok(meta) = std::fs::symlink_metadata(path) {
+        if meta.is_file() {
+            return meta.len();
+        }
+        if !meta.is_dir() {
+            return 0;
+        }
+    } else {
+        return 0;
+    }
+
+    let mut total = 0u64;
+    if let Ok(entries) = std::fs::read_dir(path) {
+        for entry in entries.flatten() {
+            total = total.saturating_add(path_size_bytes(&entry.path()));
+        }
+    }
+    total
+}
+
+fn java_executable_name() -> &'static str {
+    if cfg!(windows) {
+        "java.exe"
+    } else {
+        "java"
+    }
+}
+
+fn resolve_custom_java_path(path: &str) -> Result<PathBuf, String> {
+    let raw = PathBuf::from(path);
+    if is_executable_file(&raw) {
+        return Ok(raw);
+    }
+
+    let flat = raw.join("bin").join(java_executable_name());
+    if is_executable_file(&flat) {
+        return Ok(flat);
+    }
+
+    let macos = raw.join("Contents").join("Home").join("bin").join(java_executable_name());
+    if is_executable_file(&macos) {
+        return Ok(macos);
+    }
+
+    Err(format!("Custom Java runtime does not exist or is not a Java executable: {}", raw.display()))
+}
+
+fn resolve_system_java_path(path_var: Option<&OsStr>) -> Option<PathBuf> {
+    let path_var = path_var.map(|p| p.to_owned()).or_else(|| std::env::var_os("PATH"))?;
+    std::env::split_paths(&path_var)
+        .map(|dir| dir.join(java_executable_name()))
+        .find(|candidate| is_executable_file(candidate))
+}
+
+fn is_executable_file(path: &Path) -> bool {
+    if !path.is_file() {
+        return false;
+    }
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+
+        path.metadata().map(|meta| meta.permissions().mode() & 0o111 != 0).unwrap_or(false)
+    }
+    #[cfg(not(unix))]
+    {
+        true
+    }
+}
diff --git a/crates/dbx-core/src/agent_runtime.rs b/crates/dbx-core/src/agent_runtime.rs
new file mode 100644
index 0000000..4849f0a
--- /dev/null
+++ b/crates/dbx-core/src/agent_runtime.rs
@@ -0,0 +1,180 @@
+use serde::de::DeserializeOwned;
+use std::time::Duration;
+
+use crate::agent_manager::{AgentManager, DEFAULT_JRE_KEY};
+use crate::database_capabilities;
+use crate::db::agent_driver::{AgentDriverClient, AgentMethod};
+use crate::models::connection::DatabaseType;
+
+pub fn db_type_to_agent_key(db_type: &DatabaseType, driver_profile: Option<&str>) -> Option<&'static str> {
+    database_capabilities::agent_key(db_type, driver_profile)
+}
+
+pub fn is_agent_type(db_type: &DatabaseType) -> bool {
+    database_capabilities::is_agent_type(db_type)
+}
+
+pub async fn stop_daemons(manager: &AgentManager) {
+    manager.daemons.lock().await.clear();
+}
+
+pub async fn stop_daemon_by_key(manager: &AgentManager, agent_key: &str) {
+    manager.daemons.lock().await.remove(agent_key);
+}
+
+pub async fn restart_daemon_by_key(manager: &AgentManager, agent_key: &str) -> Result<(), String> {
+    manager.daemons.lock().await.remove(agent_key);
+    let client = spawn_client_for_key(manager, agent_key, &[]).await?;
+    manager.daemons.lock().await.insert(agent_key.to_string(), client);
+    Ok(())
+}
+
+pub async fn spawn_connection_client(
+    manager: &AgentManager,
+    db_type: &DatabaseType,
+    driver_profile: Option<&str>,
+    extra_java_args: &[String],
+) -> Result<AgentDriverClient, String> {
+    let keys = runtime_agent_key_candidates(db_type, driver_profile)
+        .ok_or_else(|| format!("{:?} is not an agent-driven database type", db_type))?;
+    spawn_first_available_client(manager, &keys, extra_java_args).await
+}
+
+pub async fn call_daemon<T: DeserializeOwned + Send + 'static>(
+    manager: &AgentManager,
+    db_type: &DatabaseType,
+    driver_profile: Option<&str>,
+    method: &str,
+    params: serde_json::Value,
+) -> Result<T, String> {
+    let keys = runtime_agent_key_candidates(db_type, driver_profile)
+        .ok_or_else(|| format!("{:?} is not an agent-driven database type", db_type))?;
+    let key = first_installed_agent_key(manager, &keys).unwrap_or(keys[0]).to_string();
+
+    let mut daemons = manager.daemons.lock().await;
+
+    if !daemons.contains_key(&key) {
+        let client = spawn_client_for_key(manager, &key, &[]).await?;
+        daemons.insert(key.clone(), client);
+    }
+
+    let client = daemons.get_mut(&key).unwrap();
+    match client.call::<T>(method, params.clone()).await {
+        Ok(result) => Ok(result),
+        Err(err) => {
+            log::warn!("[agent] daemon call failed, respawning: {err}");
+            daemons.remove(&key);
+            let mut new_client = spawn_client_for_key(manager, &key, &[]).await?;
+            let result = new_client.call::<T>(method, params).await?;
+            daemons.insert(key, new_client);
+            Ok(result)
+        }
+    }
+}
+
+pub async fn call_daemon_with_timeout<T: DeserializeOwned + Send + 'static>(
+    manager: &AgentManager,
+    db_type: &DatabaseType,
+    driver_profile: Option<&str>,
+    method: &str,
+    params: serde_json::Value,
+    timeout_duration: Option<Duration>,
+) -> Result<T, String> {
+    let keys = runtime_agent_key_candidates(db_type, driver_profile)
+        .ok_or_else(|| format!("{:?} is not an agent-driven database type", db_type))?;
+    let key = first_installed_agent_key(manager, &keys).unwrap_or(keys[0]).to_string();
+
+    let mut daemons = manager.daemons.lock().await;
+
+    if !daemons.contains_key(&key) {
+        let client = spawn_client_for_key(manager, &key, &[]).await?;
+        daemons.insert(key.clone(), client);
+    }
+
+    let client = daemons.get_mut(&key).unwrap();
+    match client.call_with_timeout::<T>(method, params.clone(), timeout_duration).await {
+        Ok(result) => Ok(result),
+        Err(err) => {
+            log::warn!("[agent] daemon call failed, respawning: {err}");
+            daemons.remove(&key);
+            let mut new_client = spawn_client_for_key(manager, &key, &[]).await?;
+            let result = new_client.call_with_timeout::<T>(method, params, timeout_duration).await?;
+            daemons.insert(key, new_client);
+            Ok(result)
+        }
+    }
+}
+
+pub async fn call_daemon_method<T: DeserializeOwned + Send + 'static>(
+    manager: &AgentManager,
+    db_type: &DatabaseType,
+    driver_profile: Option<&str>,
+    method: AgentMethod,
+    params: serde_json::Value,
+) -> Result<T, String> {
+    call_daemon(manager, db_type, driver_profile, method.as_str(), params).await
+}
+
+pub async fn call_daemon_method_with_timeout<T: DeserializeOwned + Send + 'static>(
+    manager: &AgentManager,
+    db_type: &DatabaseType,
+    driver_profile: Option<&str>,
+    method: AgentMethod,
+    params: serde_json::Value,
+    timeout_duration: Option<Duration>,
+) -> Result<T, String> {
+    call_daemon_with_timeout(manager, db_type, driver_profile, method.as_str(), params, timeout_duration).await
+}
+
+fn runtime_agent_key_candidates(db_type: &DatabaseType, driver_profile: Option<&str>) -> Option<Vec<&'static str>> {
+    let primary = db_type_to_agent_key(db_type, driver_profile)?;
+    Some(vec![primary])
+}
+
+fn first_installed_agent_key<'a>(manager: &AgentManager, keys: &'a [&'static str]) -> Option<&'a str> {
+    keys.iter().copied().find(|key| manager.is_driver_installed(key))
+}
+
+async fn spawn_first_available_client(
+    manager: &AgentManager,
+    keys: &[&'static str],
+    extra_java_args: &[String],
+) -> Result<AgentDriverClient, String> {
+    let mut last_error = None;
+    for key in keys {
+        match spawn_client_for_key(manager, key, extra_java_args).await {
+            Ok(client) => return Ok(client),
+            Err(err) => last_error = Some(err),
+        }
+    }
+    Err(last_error.unwrap_or_else(|| "No agent driver candidates available".to_string()))
+}
+
+async fn spawn_client_for_key(
+    manager: &AgentManager,
+    key: &str,
+    extra_java_args: &[String],
+) -> Result<AgentDriverClient, String> {
+    let state = manager.load_state();
+    let jre_key = state.installed_drivers.get(key).map(|driver| driver.jre.as_str()).unwrap_or(DEFAULT_JRE_KEY);
+
+    let launch = manager.resolve_agent_launch_spec_with_extra_args(&state, key, jre_key, extra_java_args)?;
+    let mut client = AgentDriverClient::spawn(launch).await?;
+    client.try_optional_handshake(manager.agent_app_version()).await;
+    Ok(client)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn prestosql_does_not_use_agent_driver() {
+        assert_eq!(runtime_agent_key_candidates(&DatabaseType::PrestoSql, None), None);
+    }
+
+    #[test]
+    fn trino_uses_only_trino_agent_driver() {
+        assert_eq!(runtime_agent_key_candidates(&DatabaseType::Trino, None).unwrap(), vec!["trino"]);
+    }
+}
diff --git a/crates/dbx-core/src/agent_service.rs b/crates/dbx-core/src/agent_service.rs
new file mode 100644
index 0000000..1e99f67
--- /dev/null
+++ b/crates/dbx-core/src/agent_service.rs
@@ -0,0 +1,1648 @@
+use std::hash::{Hash, Hasher};
+use std::io::Read;
+use std::path::{Path, PathBuf};
+use std::time::Duration;
+
+use crate::agent_catalog;
+use crate::agent_manager::{
+    AgentDriverInfo, AgentManager, AgentRegistry, InstalledDriver, JavaRuntimeMode, DEFAULT_JRE_KEY,
+};
+use crate::DownloadSource;
+
+/// Number of attempts to delete a JRE directory before giving up (Windows
+/// experiences transient `ERROR_ACCESS_DENIED` when java.exe is still mapped
+/// or anti-virus is scanning the archive). POSIX returns 1 — `unlink` of an
+/// in-use file always succeeds.
+const JRE_REMOVE_ATTEMPTS: usize = if cfg!(windows) { 6 } else { 1 };
+
+/// Exponential-ish backoff between retries. Total wait ≈ 1.55s on Windows.
+const JRE_REMOVE_BACKOFF_MS: &[u64] = &[50, 100, 200, 400, 400, 400];
+
+/// Delete an old JRE directory, retrying on Windows to cover the daemon-exit
+/// and AV-scan release window. Returns the original `std::io::Error` when all
+/// retries fail so callers can decide whether to fall back to rename-stash.
+fn remove_jre_dir_with_retry(path: &Path) -> std::io::Result<()> {
+    if !path.exists() {
+        return Ok(());
+    }
+    let mut last_err: Option<std::io::Error> = None;
+    for i in 0..JRE_REMOVE_ATTEMPTS {
+        match std::fs::remove_dir_all(path) {
+            Ok(()) => return Ok(()),
+            Err(err) => {
+                log::warn!(
+                    "remove_dir_all({}) attempt {}/{} failed: {err}",
+                    path.display(),
+                    i + 1,
+                    JRE_REMOVE_ATTEMPTS
+                );
+                last_err = Some(err);
+                if i + 1 < JRE_REMOVE_ATTEMPTS {
+                    let delay_ms = JRE_REMOVE_BACKOFF_MS.get(i).copied().unwrap_or(400);
+                    std::thread::sleep(Duration::from_millis(delay_ms));
+                }
+            }
+        }
+    }
+    Err(last_err.unwrap_or_else(|| std::io::Error::other("remove_dir_all failed without an error")))
+}
+
+/// Render a friendly Chinese error message when the old JRE directory cannot
+/// be replaced. On Windows, lists likely culprits (process holding java.exe,
+/// AV scanning) and suggests restarting dbx; on POSIX returns a concise
+/// message. The original OS error is appended in parentheses for support.
+fn format_jre_dir_remove_error(path: &Path, os_err: &std::io::Error) -> String {
+    if cfg!(windows) {
+        format!(
+            "无法删除旧的 JRE 目录：{}\n\
+             可能的原因：\n  \
+             - 仍有 dbx Agent / java 进程占用该目录\n  \
+             - 防病毒软件正在扫描\n\
+             请关闭可能持有该目录的进程，或重启 dbx 后重试。\n\
+             （原始错误：{os_err}）",
+            path.display()
+        )
+    } else {
+        format!("无法删除旧的 JRE 目录：{}（原始错误：{os_err}）", path.display())
+    }
+}
+
+/// Windows-only: rename the old JRE dir to a unique sibling so the install
+/// can continue even when files inside are still mapped. Returns the stash
+/// path so the caller can record it for later cleanup. On POSIX this is
+/// unreachable (callers gate on `cfg(windows)` after a failed remove).
+#[cfg(windows)]
+fn stash_old_jre_dir(path: &Path) -> std::io::Result<PathBuf> {
+    use std::time::SystemTime;
+
+    let file_name = path
+        .file_name()
+        .and_then(|name| name.to_str())
+        .ok_or_else(|| std::io::Error::other("JRE directory has no file name"))?;
+    let ts = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).map(|d| d.as_secs()).unwrap_or(0);
+    // uuid::Uuid::new_v4() is already a workspace dependency — use its short
+    // form for a unique suffix without pulling in `rand`.
+    let rand = uuid::Uuid::new_v4().simple().to_string();
+    let stash = path.with_file_name(format!("{file_name}.old-{ts}-{rand}"));
+    std::fs::rename(path, &stash)?;
+    Ok(stash)
+}
+
+/// Replace an old JRE directory in-place: try retried `remove_dir_all` first;
+/// on Windows fall back to rename-stash if removal fails. Returns the stash
+/// path (Some) if the rename fallback was used so the caller can persist it
+/// for startup cleanup, or None if the directory was deleted outright (or
+/// did not exist).
+fn replace_old_jre_dir(am: &AgentManager, path: &Path) -> Result<Option<PathBuf>, String> {
+    match remove_jre_dir_with_retry(path) {
+        Ok(()) => Ok(None),
+        Err(remove_err) => {
+            #[cfg(windows)]
+            {
+                match stash_old_jre_dir(path) {
+                    Ok(stash) => {
+                        log::warn!("remove_dir_all failed, stashed old JRE at {} ({remove_err})", stash.display());
+                        // Persist immediately so a crash before extraction
+                        // still leaves the stash recorded for cleanup.
+                        let mut state = am.load_state();
+                        state.pending_jre_cleanup.push(stash.clone());
+                        if let Err(save_err) = am.save_state(&state) {
+                            log::warn!("Failed to persist pending_jre_cleanup: {save_err}");
+                        }
+                        Ok(Some(stash))
+                    }
+                    Err(rename_err) => {
+                        log::warn!(
+                            "remove_dir_all and rename both failed for {}: remove={remove_err}, rename={rename_err}",
+                            path.display()
+                        );
+                        Err(format_jre_dir_remove_error(path, &remove_err))
+                    }
+                }
+            }
+            #[cfg(not(windows))]
+            {
+                let _ = am; // silence unused warning on POSIX
+                Err(format_jre_dir_remove_error(path, &remove_err))
+            }
+        }
+    }
+}
+
+const REGISTRY_PATH: &str = "https://github.com/t8y2/dbx/releases/download/agents-latest/agent-registry.json";
+const REGISTRY_R2_PATH: &str = "agents/agent-registry.json";
+
+static REGISTRY_CACHE: std::sync::LazyLock<
+    tokio::sync::Mutex<std::collections::HashMap<DownloadSource, (std::time::Instant, AgentRegistry)>>,
+> = std::sync::LazyLock::new(|| tokio::sync::Mutex::new(std::collections::HashMap::new()));
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
+pub struct AgentProgressEvent {
+    pub step: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub downloaded: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub total: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub db_type: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub current: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub total_drivers: Option<u32>,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
+pub struct AgentDriverUpdateIssue {
+    pub db_type: String,
+    pub error: String,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq, Default)]
+pub struct UpgradeAllAgentDriversResult {
+    pub upgraded: u32,
+    pub failed: Vec<AgentDriverUpdateIssue>,
+}
+
+impl AgentProgressEvent {
+    pub fn step(step: impl Into<String>) -> Self {
+        Self { step: step.into(), downloaded: None, total: None, db_type: None, current: None, total_drivers: None }
+    }
+
+    pub fn transfer(step: impl Into<String>, downloaded: u64, total: u64) -> Self {
+        Self { downloaded: Some(downloaded), total: Some(total), ..Self::step(step) }
+    }
+
+    pub fn with_batch(mut self, db_type: Option<&str>, current: Option<u32>, total_drivers: Option<u32>) -> Self {
+        self.db_type = db_type.map(ToString::to_string);
+        self.current = current;
+        self.total_drivers = total_drivers;
+        self
+    }
+}
+
+pub fn build_agent_list(am: &AgentManager, registry: Option<&AgentRegistry>) -> Vec<AgentDriverInfo> {
+    let local_state = am.load_state();
+    let use_managed_jre = local_state.java_runtime.mode == JavaRuntimeMode::Managed;
+    agent_catalog::driver_store_entries()
+        .map(|(key, label)| {
+            let jar_valid = am.is_driver_jar_valid(key);
+            let native_installed = am.driver_native_path(key).exists();
+            let launch_config_installed = am.driver_launch_config_path(key).exists();
+            let installed = jar_valid || native_installed || launch_config_installed;
+            let local = local_state.installed_drivers.get(key);
+            let remote = registry.and_then(|r| agent_registry_driver(r, key));
+            let remote_requires_java_runtime = remote.is_some_and(remote_driver_requires_java_runtime);
+            let requires_java_runtime = if installed {
+                jar_valid && !native_installed && !launch_config_installed
+            } else {
+                remote_requires_java_runtime
+            };
+            let jre_key = remote
+                .map(|r| r.jre.clone())
+                .or_else(|| local.map(|l| l.jre.clone()))
+                .unwrap_or_else(|| DEFAULT_JRE_KEY.to_string());
+            let remote_jre_version = registry.and_then(|r| r.resolve_jre(&jre_key)).map(|j| &j.version);
+            let local_jre_version = installed_jre_version(&local_state, &jre_key);
+            let jre_update_available = installed
+                && requires_java_runtime
+                && use_managed_jre
+                && (!am.is_jre_installed(&jre_key)
+                    || remote_jre_version.is_some_and(|version| local_jre_version != Some(version)));
+            AgentDriverInfo {
+                db_type: key.to_string(),
+                label: label.to_string(),
+                version: remote.map(|r| r.version.clone()).unwrap_or_default(),
+                size: remote.and_then(driver_download_artifact).map(|artifact| artifact.size).unwrap_or(0),
+                installed,
+                installed_version: local.map(|l| l.version.clone()),
+                update_available: match (local, remote) {
+                    (Some(l), Some(r)) => l.version != r.version || jre_update_available,
+                    _ => false,
+                },
+                requires_java_runtime,
+                jre: jre_key.clone(),
+                jre_installed: !requires_java_runtime || am.is_jre_installed(&jre_key),
+            }
+        })
+        .collect()
+}
+
+fn driver_download_artifact(driver: &crate::agent_manager::DriverInfo) -> Option<&crate::agent_manager::ArtifactInfo> {
+    driver.native.get(AgentManager::current_platform()).or(driver.jar.as_ref())
+}
+
+fn remote_driver_requires_java_runtime(driver: &crate::agent_manager::DriverInfo) -> bool {
+    driver.jar.is_some() && !driver.native.contains_key(AgentManager::current_platform())
+}
+
+fn installed_jre_version<'a>(state: &'a crate::agent_manager::AgentState, jre_key: &str) -> Option<&'a String> {
+    state
+        .jre_versions
+        .get(jre_key)
+        .or_else(|| (jre_key == DEFAULT_JRE_KEY).then_some(state.jre_version.as_ref()).flatten())
+}
+
+fn mark_executable(path: &Path) -> Result<(), String> {
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let mut permissions = std::fs::metadata(path).map_err(|err| err.to_string())?.permissions();
+        permissions.set_mode(0o755);
+        std::fs::set_permissions(path, permissions).map_err(|err| err.to_string())?;
+    }
+    #[cfg(not(unix))]
+    {
+        let _ = path;
+    }
+    Ok(())
+}
+
+pub fn jre_needs_install(am: &AgentManager, registry: &AgentRegistry, jre_key: &str) -> bool {
+    let state = am.load_state();
+    if state.java_runtime.mode != JavaRuntimeMode::Managed {
+        return false;
+    }
+    if !am.is_jre_installed(jre_key) {
+        return true;
+    }
+    registry.resolve_jre(jre_key).is_some_and(|jre| state.jre_versions.get(jre_key) != Some(&jre.version))
+}
+
+pub fn local_agent_jar_candidates(db_type: &str) -> Vec<PathBuf> {
+    let jar_name = format!("dbx-agent-{db_type}.jar");
+    let mut candidates = Vec::new();
+
+    for agents_dir in local_agents_dir_candidates() {
+        candidates.push(agent_driver_jar_path(&agents_dir, db_type, &jar_name));
+        candidates.push(agent_legacy_jar_path(&agents_dir, db_type, &jar_name));
+    }
+
+    candidates
+}
+
+fn local_agents_dir_candidates() -> Vec<PathBuf> {
+    let mut candidates = vec![PathBuf::from("agents"), PathBuf::from("..").join("agents")];
+    if let Some(workspace_root) = PathBuf::from(env!("CARGO_MANIFEST_DIR")).parent().and_then(|path| path.parent()) {
+        candidates.push(workspace_root.join("agents"));
+    }
+    candidates.push(PathBuf::from("..").join("dbx-agents"));
+    candidates.push(PathBuf::from("dbx-agents"));
+    candidates
+}
+
+fn agent_driver_jar_path(agents_dir: &Path, db_type: &str, jar_name: &str) -> PathBuf {
+    agents_dir.join("drivers").join(db_type).join("build").join("libs").join(jar_name)
+}
+
+fn agent_legacy_jar_path(agents_dir: &Path, db_type: &str, jar_name: &str) -> PathBuf {
+    agents_dir.join(db_type).join("build").join("libs").join(jar_name)
+}
+
+pub fn find_local_agent_jar(db_type: &str) -> Option<PathBuf> {
+    local_agent_jar_candidates(db_type).into_iter().find(|path| path.exists())
+}
+
+pub fn install_local_agent(am: &AgentManager, db_type: &str, source: PathBuf) -> Result<(), String> {
+    let jar_path = am.driver_jar_path(db_type);
+    let parent = jar_path.parent().ok_or_else(|| format!("Invalid driver path: {}", jar_path.display()))?;
+    std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+    std::fs::copy(&source, &jar_path).map_err(|e| format!("Failed to copy local agent jar: {e}"))?;
+    if !am.is_driver_jar_valid(db_type) {
+        std::fs::remove_file(&jar_path).ok();
+        return Err(format!("Local agent jar is invalid or corrupt: {}", source.display()));
+    }
+
+    let mut local_state = am.load_state();
+    local_state.installed_drivers.insert(
+        db_type.to_string(),
+        InstalledDriver {
+            version: "0.1.0-local".to_string(),
+            installed_at: chrono::Utc::now().to_rfc3339(),
+            jre: DEFAULT_JRE_KEY.to_string(),
+        },
+    );
+    am.save_state(&local_state)
+}
+
+pub async fn fetch_registry() -> Result<AgentRegistry, String> {
+    fetch_registry_from(DownloadSource::Official).await
+}
+
+pub async fn fetch_registry_from(source: DownloadSource) -> Result<AgentRegistry, String> {
+    {
+        let cache = REGISTRY_CACHE.lock().await;
+        if let Some((ts, registry)) = cache.get(&source) {
+            if ts.elapsed() < std::time::Duration::from_secs(300) {
+                return Ok(registry.clone());
+            }
+        }
+    }
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(10))
+        .build()
+        .map_err(|err| format!("Failed to create HTTP client: {err}"))?;
+    let resp = open_download_response(&client, source, REGISTRY_PATH, REGISTRY_R2_PATH, "dbx-agent-manager")
+        .await
+        .map_err(|err| format!("Failed to fetch agent registry: {err}"))?;
+    let registry: AgentRegistry = resp.json().await.map_err(|err| format!("Failed to parse registry: {err}"))?;
+    REGISTRY_CACHE.lock().await.insert(source, (std::time::Instant::now(), registry.clone()));
+    Ok(registry)
+}
+
+async fn open_download_response(
+    client: &reqwest::Client,
+    source: DownloadSource,
+    github_url: &str,
+    r2_path: &str,
+    user_agent: &str,
+) -> Result<reqwest::Response, String> {
+    let mut errors = Vec::new();
+    for url in source.download_candidate_urls(github_url, r2_path)? {
+        match client
+            .get(&url)
+            .header(reqwest::header::USER_AGENT, user_agent)
+            .header(reqwest::header::ACCEPT_ENCODING, "identity")
+            .send()
+            .await
+            .and_then(|response| response.error_for_status())
+        {
+            Ok(response) => return Ok(response),
+            Err(error) => errors.push(format!("{url}: {error}")),
+        }
+    }
+    Err(errors.join("; "))
+}
+
+pub async fn invalidate_registry_cache() {
+    REGISTRY_CACHE.lock().await.clear();
+}
+
+pub async fn install_agent_driver(
+    am: &AgentManager,
+    db_type: &str,
+    progress: impl Fn(AgentProgressEvent),
+) -> Result<(), String> {
+    install_agent_driver_from(am, db_type, DownloadSource::Official, progress).await
+}
+
+pub async fn install_agent_driver_from(
+    am: &AgentManager,
+    db_type: &str,
+    source: DownloadSource,
+    progress: impl Fn(AgentProgressEvent),
+) -> Result<(), String> {
+    install_agent_driver_with_batch(am, db_type, source, &progress, None, None).await
+}
+
+pub async fn upgrade_all_agent_drivers(
+    am: &AgentManager,
+    progress: impl Fn(AgentProgressEvent),
+) -> Result<UpgradeAllAgentDriversResult, String> {
+    upgrade_all_agent_drivers_from(am, DownloadSource::Official, progress).await
+}
+
+pub async fn upgrade_all_agent_drivers_from(
+    am: &AgentManager,
+    source: DownloadSource,
+    progress: impl Fn(AgentProgressEvent),
+) -> Result<UpgradeAllAgentDriversResult, String> {
+    let registry = fetch_registry_from(source).await?;
+    let agents = build_agent_list(am, Some(&registry));
+    let updatable: Vec<&AgentDriverInfo> = agents.iter().filter(|agent| agent.update_available).collect();
+    let total = updatable.len() as u32;
+    let mut result = UpgradeAllAgentDriversResult::default();
+
+    for (index, agent) in updatable.iter().enumerate() {
+        match install_agent_driver_from_registry(
+            am,
+            &registry,
+            source,
+            &agent.db_type,
+            &progress,
+            Some((index + 1) as u32),
+            Some(total),
+        )
+        .await
+        {
+            Ok(()) => result.upgraded += 1,
+            Err(error) => {
+                log::warn!("Failed to update {} agent driver: {}", agent.db_type, error);
+                result.failed.push(AgentDriverUpdateIssue { db_type: agent.db_type.clone(), error });
+            }
+        }
+    }
+
+    progress(AgentProgressEvent::step("all-done"));
+    Ok(result)
+}
+
+pub async fn uninstall_agent_driver(am: &AgentManager, db_type: &str) -> Result<(), String> {
+    prune_driver_download_cache(am, db_type)?;
+    let jar_path = am.driver_jar_path(db_type);
+    if jar_path.exists() {
+        std::fs::remove_file(&jar_path).map_err(|err| err.to_string())?;
+    }
+    if let Some(driver_dir) = jar_path.parent() {
+        if driver_dir.exists() {
+            std::fs::remove_dir_all(driver_dir).map_err(|err| err.to_string())?;
+        }
+    }
+    let mut local_state = am.load_state();
+    local_state.installed_drivers.remove(db_type);
+    am.save_state(&local_state)?;
+    am.stop_daemon_by_key(db_type).await;
+    Ok(())
+}
+
+pub fn clear_agent_download_cache(am: &AgentManager) -> Result<(), String> {
+    remove_download_cache_entries(am, |_| true, "download cache")
+}
+
+pub async fn uninstall_agent_jre(am: &AgentManager, jre_key: &str) -> Result<(), String> {
+    let local_state = am.load_state();
+    let dependents: Vec<&str> = local_state
+        .installed_drivers
+        .iter()
+        .filter(|(_, driver)| driver.jre == jre_key)
+        .map(|(k, _)| k.as_str())
+        .collect();
+    if !dependents.is_empty() {
+        return Err(format!("JRE {} 正在被以下驱动使用: {}，请先卸载这些驱动", jre_key, dependents.join(", ")));
+    }
+    // Stop daemons first so any java.exe holding the JRE files exits before
+    // we try to remove the directory (Windows ERROR_ACCESS_DENIED otherwise).
+    am.stop_daemons().await;
+    let jre_dir = am.jre_dir(jre_key);
+    if let Err(err) = remove_jre_dir_with_retry(&jre_dir) {
+        return Err(format_jre_dir_remove_error(&jre_dir, &err));
+    }
+    let mut local_state = am.load_state();
+    local_state.jre_versions.remove(jre_key);
+    am.save_state(&local_state)?;
+    Ok(())
+}
+
+pub async fn reinstall_agent_jre(
+    am: &AgentManager,
+    jre_key: &str,
+    progress: impl Fn(AgentProgressEvent),
+) -> Result<(), String> {
+    reinstall_agent_jre_from(am, jre_key, DownloadSource::Official, progress).await
+}
+
+pub async fn reinstall_agent_jre_from(
+    am: &AgentManager,
+    jre_key: &str,
+    source: DownloadSource,
+    progress: impl Fn(AgentProgressEvent),
+) -> Result<(), String> {
+    let registry = fetch_registry_from(source).await?;
+    let jre_info = registry.resolve_jre(jre_key).ok_or_else(|| format!("No JRE definition for version: {jre_key}"))?;
+    let platform = AgentManager::current_platform();
+    let platform_jre = jre_info
+        .platforms
+        .get(platform)
+        .ok_or_else(|| format!("No JRE {jre_key} available for platform: {platform}"))?;
+    let jre_archive = am.base_dir().join("jre-download.tar.gz");
+    download_with_progress(
+        am,
+        &progress,
+        "jre",
+        source,
+        &platform_jre.url,
+        &r2_path_with_cache_buster(&github_url_to_r2_path(&platform_jre.url, "jre"), &jre_info.version),
+        &jre_archive,
+        platform_jre.size,
+        Some(CacheIdentity::Jre { key: jre_key, version: &jre_info.version }),
+        None,
+        None,
+        None,
+    )
+    .await?;
+    let jre_dir = am.jre_dir(jre_key);
+    // Stop daemons before deleting so java.exe processes release file
+    // handles on Windows (Issue #1100). Falls back to a rename-stash if the
+    // directory still cannot be removed.
+    am.stop_daemons().await;
+    replace_old_jre_dir(am, &jre_dir)?;
+    extract_tar_gz(&jre_archive, &jre_dir)?;
+    std::fs::remove_file(&jre_archive).ok();
+    let mut local_state = am.load_state();
+    local_state.jre_versions.insert(jre_key.to_string(), jre_info.version.clone());
+    am.save_state(&local_state)?;
+    cleanup_jre_download_cache_after_success(am, jre_key);
+    progress(AgentProgressEvent::step("done"));
+    Ok(())
+}
+
+pub fn import_agents_from_zip(
+    am: &AgentManager,
+    zip_path: &Path,
+    progress: impl Fn(AgentProgressEvent),
+) -> Result<OfflineImportResult, String> {
+    import_offline_zip(am, zip_path, |p| {
+        progress(AgentProgressEvent {
+            step: p.step,
+            downloaded: Some(p.current as u64),
+            total: Some(p.total as u64),
+            db_type: Some(p.label),
+            current: Some(p.current),
+            total_drivers: Some(p.total),
+        });
+    })
+}
+
+async fn install_agent_driver_with_batch(
+    am: &AgentManager,
+    db_type: &str,
+    source: DownloadSource,
+    progress: &impl Fn(AgentProgressEvent),
+    current: Option<u32>,
+    total_drivers: Option<u32>,
+) -> Result<(), String> {
+    match fetch_registry_from(source).await {
+        Ok(registry) => {
+            match install_agent_driver_from_registry(am, &registry, source, db_type, progress, current, total_drivers)
+                .await
+            {
+                Ok(()) => Ok(()),
+                Err(registry_err) => {
+                    if let Some(local_jar) = find_local_agent_jar(db_type) {
+                        install_local_agent_with_registry_jre(
+                            am,
+                            &registry,
+                            source,
+                            db_type,
+                            local_jar,
+                            progress,
+                            current,
+                            total_drivers,
+                        )
+                        .await?;
+                        return Ok(());
+                    }
+                    Err(registry_err)
+                }
+            }
+        }
+        Err(registry_err) => {
+            if let Some(local_jar) = find_local_agent_jar(db_type) {
+                install_local_agent(am, db_type, local_jar)?;
+                am.stop_daemon_by_key(db_type).await;
+                progress(AgentProgressEvent::step("done"));
+                return Ok(());
+            }
+            Err(registry_err)
+        }
+    }
+}
+
+async fn ensure_jre_from_registry(
+    am: &AgentManager,
+    registry: &AgentRegistry,
+    source: DownloadSource,
+    jre_key: &str,
+    db_type: &str,
+    progress: &impl Fn(AgentProgressEvent),
+    current: Option<u32>,
+    total_drivers: Option<u32>,
+) -> Result<(), String> {
+    let jre_info = registry.resolve_jre(jre_key).ok_or_else(|| format!("No JRE definition for version: {jre_key}"))?;
+    let platform = AgentManager::current_platform();
+    let platform_jre = jre_info
+        .platforms
+        .get(platform)
+        .ok_or_else(|| format!("No JRE {jre_key} available for platform: {platform}"))?;
+    let jre_archive = am.base_dir().join("jre-download.tar.gz");
+    progress(AgentProgressEvent::transfer("jre", 0, platform_jre.size).with_batch(
+        Some(db_type),
+        current,
+        total_drivers,
+    ));
+    download_with_progress(
+        am,
+        progress,
+        "jre",
+        source,
+        &platform_jre.url,
+        &r2_path_with_cache_buster(&github_url_to_r2_path(&platform_jre.url, "jre"), &jre_info.version),
+        &jre_archive,
+        platform_jre.size,
+        Some(CacheIdentity::Jre { key: jre_key, version: &jre_info.version }),
+        Some(db_type),
+        current,
+        total_drivers,
+    )
+    .await?;
+    progress(AgentProgressEvent::transfer("jre-extract", 0, 0).with_batch(Some(db_type), current, total_drivers));
+    let jre_dir = am.jre_dir(jre_key);
+    // Stop daemons first (Windows ERROR_ACCESS_DENIED, Issue #1100).
+    am.stop_daemons().await;
+    replace_old_jre_dir(am, &jre_dir)?;
+    extract_tar_gz(&jre_archive, &jre_dir)?;
+    std::fs::remove_file(&jre_archive).ok();
+    cleanup_jre_download_cache_after_success(am, jre_key);
+    Ok(())
+}
+
+async fn install_local_agent_with_registry_jre(
+    am: &AgentManager,
+    registry: &AgentRegistry,
+    source: DownloadSource,
+    db_type: &str,
+    local_jar: PathBuf,
+    progress: &impl Fn(AgentProgressEvent),
+    current: Option<u32>,
+    total_drivers: Option<u32>,
+) -> Result<(), String> {
+    let jre_key = DEFAULT_JRE_KEY;
+    if jre_needs_install(am, registry, jre_key) {
+        ensure_jre_from_registry(am, registry, source, jre_key, db_type, progress, current, total_drivers).await?;
+    }
+    install_local_agent(am, db_type, local_jar)?;
+    if let Some(jre_info) = registry.resolve_jre(jre_key) {
+        let mut local_state = am.load_state();
+        local_state.jre_versions.insert(jre_key.to_string(), jre_info.version.clone());
+        am.save_state(&local_state)?;
+    }
+    am.stop_daemon_by_key(db_type).await;
+    progress(AgentProgressEvent::step("done"));
+    Ok(())
+}
+
+async fn install_agent_driver_from_registry(
+    am: &AgentManager,
+    registry: &AgentRegistry,
+    source: DownloadSource,
+    db_type: &str,
+    progress: &impl Fn(AgentProgressEvent),
+    current: Option<u32>,
+    total_drivers: Option<u32>,
+) -> Result<(), String> {
+    let Some(driver) = agent_registry_driver(registry, db_type) else {
+        if let Some(local_jar) = find_local_agent_jar(db_type) {
+            install_local_agent_with_registry_jre(
+                am,
+                registry,
+                source,
+                db_type,
+                local_jar,
+                progress,
+                current,
+                total_drivers,
+            )
+            .await?;
+            return Ok(());
+        }
+        return Err(format!("Unknown driver type: {db_type}"));
+    };
+    let jre_key = &driver.jre;
+    let native_artifact = driver.native.get(AgentManager::current_platform());
+    let jar_artifact = driver.jar.as_ref();
+    let requires_java_runtime = native_artifact.is_none();
+    let needs_jre = requires_java_runtime && jre_needs_install(am, registry, jre_key);
+
+    if needs_jre {
+        ensure_jre_from_registry(am, registry, source, jre_key, db_type, progress, current, total_drivers).await?;
+    }
+
+    let (artifact, target_path, is_native_artifact) = if let Some(native) = native_artifact {
+        (native, am.driver_native_path(db_type), true)
+    } else if let Some(jar) = jar_artifact {
+        (jar, am.driver_jar_path(db_type), false)
+    } else {
+        return Err(format!("No driver artifact available for {db_type}"));
+    };
+    if let Some(parent) = target_path.parent() {
+        std::fs::create_dir_all(parent).map_err(|err| format!("Failed to create driver directory: {err}"))?;
+    }
+    progress(AgentProgressEvent::transfer("driver", 0, artifact.size).with_batch(
+        Some(db_type),
+        current,
+        total_drivers,
+    ));
+    download_with_progress(
+        am,
+        progress,
+        "driver",
+        source,
+        &artifact.url,
+        &r2_path_with_cache_buster(&github_url_to_r2_path(&artifact.url, "driver"), &driver.version),
+        &target_path,
+        artifact.size,
+        Some(CacheIdentity::Driver { db_type, version: &driver.version }),
+        Some(db_type),
+        current,
+        total_drivers,
+    )
+    .await?;
+    // Some drivers publish both a native agent and a legacy JAR fallback. Only
+    // validate the artifact type that was actually installed.
+    if !is_native_artifact && !am.is_driver_jar_valid(db_type) {
+        std::fs::remove_file(&target_path).ok();
+        return Err(format!("Downloaded driver jar is invalid or corrupt: {}", target_path.display()));
+    }
+    if is_native_artifact {
+        mark_executable(&target_path)?;
+        std::fs::remove_file(am.driver_jar_path(db_type)).ok();
+    } else {
+        std::fs::remove_file(am.driver_native_path(db_type)).ok();
+    }
+
+    let mut local_state = am.load_state();
+    if requires_java_runtime {
+        if let Some(jre_info) = registry.resolve_jre(jre_key) {
+            local_state.jre_versions.insert(jre_key.clone(), jre_info.version.clone());
+        }
+    }
+    local_state.installed_drivers.insert(
+        db_type.to_string(),
+        InstalledDriver {
+            version: driver.version.clone(),
+            installed_at: chrono::Utc::now().to_rfc3339(),
+            jre: jre_key.clone(),
+        },
+    );
+    am.save_state(&local_state)?;
+    am.stop_daemon_by_key(db_type).await;
+    cleanup_driver_download_cache_after_success(am, db_type);
+    progress(AgentProgressEvent::step("done"));
+    Ok(())
+}
+
+fn agent_registry_driver<'a>(
+    registry: &'a AgentRegistry,
+    db_type: &str,
+) -> Option<&'a crate::agent_manager::DriverInfo> {
+    registry.drivers.get(db_type)
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn download_with_progress(
+    am: &AgentManager,
+    progress: &impl Fn(AgentProgressEvent),
+    step: &str,
+    source: DownloadSource,
+    url: &str,
+    r2_path: &str,
+    dest: &std::path::Path,
+    total_size: u64,
+    cache_identity: Option<CacheIdentity<'_>>,
+    db_type: Option<&str>,
+    current: Option<u32>,
+    total_drivers: Option<u32>,
+) -> Result<(), String> {
+    const DOWNLOAD_ATTEMPTS: usize = 4;
+
+    if let Some(parent) = dest.parent() {
+        std::fs::create_dir_all(parent).map_err(|err| err.to_string())?;
+    }
+    let tmp = download_temp_path(dest);
+    let tmp_source = download_source_path(&tmp);
+    let cache_path = cached_download_path(am, url, total_size, cache_identity, dest);
+    prune_download_cache(am).ok();
+    if cached_download_is_valid(am, &cache_path, total_size) {
+        std::fs::copy(&cache_path, &tmp).map_err(|err| format!("Failed to copy cached download: {err}"))?;
+        progress(AgentProgressEvent::transfer(step, total_size, total_size).with_batch(
+            db_type,
+            current,
+            total_drivers,
+        ));
+        return replace_download(&tmp, dest);
+    }
+
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(300))
+        .build()
+        .map_err(|err| format!("Failed to create HTTP client: {err}"))?;
+    let mut last_err = None;
+    let mut completed = false;
+    for attempt in 1..=DOWNLOAD_ATTEMPTS {
+        let mut resume_from = std::fs::metadata(&tmp).map(|meta| meta.len()).unwrap_or(0);
+        let resume_source = std::fs::read_to_string(&tmp_source).ok().map(|value| value.trim().to_string());
+        if resume_from > 0 && resume_source.is_none() {
+            std::fs::remove_file(&tmp).ok();
+            resume_from = 0;
+        }
+        if total_size > 0 && resume_from > total_size {
+            std::fs::remove_file(&tmp).ok();
+            std::fs::remove_file(&tmp_source).ok();
+            resume_from = 0;
+        }
+        if total_size > 0 && resume_from == total_size {
+            progress(AgentProgressEvent::transfer(step, total_size, total_size).with_batch(
+                db_type,
+                current,
+                total_drivers,
+            ));
+            completed = true;
+            break;
+        }
+
+        let (mut resp, resumed, source_url) = match open_agent_download_response(
+            &client,
+            source,
+            url,
+            r2_path,
+            "dbx-agent-manager",
+            resume_from,
+            total_size,
+            resume_source.as_deref(),
+        )
+        .await
+        {
+            Ok(value) => value,
+            Err(err) => {
+                if resume_from > 0 {
+                    std::fs::remove_file(&tmp).ok();
+                    std::fs::remove_file(&tmp_source).ok();
+                }
+                last_err = Some(err);
+                continue;
+            }
+        };
+        let starting_size = if resumed { resume_from } else { 0 };
+        let content_length = total_size.max(starting_size + resp.content_length().unwrap_or(0));
+        let mut file = if resumed {
+            std::fs::OpenOptions::new()
+                .append(true)
+                .open(&tmp)
+                .map_err(|err| format!("Failed to open temp file for resume: {err}"))?
+        } else {
+            std::fs::File::create(&tmp).map_err(|err| format!("Failed to create temp file: {err}"))?
+        };
+        std::fs::write(&tmp_source, &source_url).map_err(|err| format!("Failed to write download source: {err}"))?;
+        let mut downloaded = starting_size;
+        let transfer_result = async {
+            while let Some(chunk) = resp.chunk().await.map_err(|err| format!("Download stream error: {err}"))? {
+                std::io::Write::write_all(&mut file, &chunk).map_err(|err| format!("Failed to write chunk: {err}"))?;
+                downloaded += chunk.len() as u64;
+                progress(AgentProgressEvent::transfer(step, downloaded, content_length).with_batch(
+                    db_type,
+                    current,
+                    total_drivers,
+                ));
+            }
+            std::io::Write::flush(&mut file).map_err(|err| format!("Failed to flush temp file: {err}"))
+        }
+        .await;
+        drop(file);
+
+        if let Err(err) = transfer_result {
+            last_err = Some(format!("{err} (attempt {attempt}/{DOWNLOAD_ATTEMPTS}, source {source_url})"));
+            continue;
+        }
+
+        let actual_size = std::fs::metadata(&tmp).map(|meta| meta.len()).unwrap_or(0);
+        if total_size == 0 || actual_size == total_size {
+            completed = true;
+            break;
+        }
+        if actual_size > total_size {
+            std::fs::remove_file(&tmp).ok();
+            std::fs::remove_file(&tmp_source).ok();
+        }
+        last_err = Some(format!(
+            "Downloaded {step} is incomplete: expected {total_size} bytes, got {actual_size} bytes (attempt {attempt}/{DOWNLOAD_ATTEMPTS}, source {source_url})"
+        ));
+    }
+    if !completed {
+        let actual_size = std::fs::metadata(&tmp).map(|meta| meta.len()).unwrap_or(0);
+        return Err(last_err.unwrap_or_else(|| {
+            format!("Downloaded {step} is incomplete: expected {total_size} bytes, got {actual_size} bytes")
+        }));
+    }
+    std::fs::remove_file(&tmp_source).ok();
+    if let Some(parent) = cache_path.parent() {
+        if let Err(err) = std::fs::create_dir_all(parent) {
+            log::warn!("Failed to create agent download cache directory: {err}");
+        } else if let Err(err) = std::fs::copy(&tmp, &cache_path) {
+            log::warn!("Failed to cache agent download: {err}");
+        }
+    }
+    replace_download(&tmp, dest)
+}
+
+async fn open_agent_download_response(
+    client: &reqwest::Client,
+    source: DownloadSource,
+    github_url: &str,
+    r2_path: &str,
+    user_agent: &str,
+    resume_from: u64,
+    expected_size: u64,
+    resume_source: Option<&str>,
+) -> Result<(reqwest::Response, bool, String), String> {
+    let mut errors = Vec::new();
+    for candidate_url in source.download_candidate_urls(github_url, r2_path)? {
+        if resume_from > 0 && resume_source.is_some_and(|source| source != candidate_url) {
+            continue;
+        }
+        let mut request = client
+            .get(&candidate_url)
+            .header(reqwest::header::USER_AGENT, user_agent)
+            .header(reqwest::header::ACCEPT_ENCODING, "identity");
+        if resume_from > 0 {
+            request = request.header(reqwest::header::RANGE, format!("bytes={resume_from}-"));
+        }
+        let resp = match request.send().await {
+            Ok(resp) => resp,
+            Err(err) => {
+                errors.push(format!("{candidate_url}: {err}"));
+                continue;
+            }
+        };
+        let status = resp.status();
+        if expected_size > 0 {
+            let response_size = response_total_size(&resp, resume_from);
+            if response_size != Some(expected_size) {
+                let found = response_size.map_or_else(|| "unknown".to_string(), |size| size.to_string());
+                errors.push(format!(
+                    "{candidate_url}: artifact size mismatch, expected {expected_size} bytes, got {found} bytes"
+                ));
+                continue;
+            }
+        }
+        if resume_from > 0 && status == reqwest::StatusCode::PARTIAL_CONTENT {
+            return Ok((resp, true, candidate_url));
+        }
+        if status.is_success() {
+            return match resp.error_for_status() {
+                Ok(resp) => Ok((resp, false, candidate_url)),
+                Err(err) => Err(format!("{candidate_url}: {err}")),
+            };
+        }
+        errors.push(format!("{candidate_url}: HTTP {status}"));
+    }
+    Err(format!("Failed to download artifact: {}", errors.join("; ")))
+}
+
+fn response_total_size(resp: &reqwest::Response, resume_from: u64) -> Option<u64> {
+    if resp.status() == reqwest::StatusCode::PARTIAL_CONTENT {
+        return resp
+            .headers()
+            .get(reqwest::header::CONTENT_RANGE)
+            .and_then(|value| value.to_str().ok())
+            .and_then(content_range_total_size);
+    }
+    resp.content_length().map(|size| size + resume_from)
+}
+
+fn content_range_total_size(value: &str) -> Option<u64> {
+    value.rsplit('/').next()?.parse().ok()
+}
+
+#[derive(Debug, Clone, Copy)]
+enum CacheIdentity<'a> {
+    Driver { db_type: &'a str, version: &'a str },
+    Jre { key: &'a str, version: &'a str },
+}
+
+impl CacheIdentity<'_> {
+    fn hash_key(self) -> String {
+        match self {
+            Self::Driver { db_type, version } => format!("driver:{db_type}:{version}"),
+            Self::Jre { key, version } => format!("jre:{key}:{version}"),
+        }
+    }
+
+    fn file_prefix(self) -> String {
+        match self {
+            Self::Driver { db_type, version } => {
+                format!("driver-{}-{}", cache_file_token(db_type), cache_file_token(version))
+            }
+            Self::Jre { key, version } => format!("jre-{}-{}", cache_file_token(key), cache_file_token(version)),
+        }
+    }
+}
+
+fn cached_download_path(
+    am: &AgentManager,
+    url: &str,
+    total_size: u64,
+    cache_identity: Option<CacheIdentity<'_>>,
+    dest: &std::path::Path,
+) -> std::path::PathBuf {
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    url.hash(&mut hasher);
+    total_size.hash(&mut hasher);
+    let identity_hash_key = cache_identity.map(CacheIdentity::hash_key);
+    identity_hash_key.hash(&mut hasher);
+    let hash = hasher.finish();
+    let file_name = dest.file_name().and_then(|name| name.to_str()).unwrap_or("download");
+    let prefix = cache_identity.map(CacheIdentity::file_prefix).unwrap_or_else(|| "download".to_string());
+    am.download_cache_dir().join(format!("{prefix}-{hash:016x}-{file_name}"))
+}
+
+fn cached_download_is_valid(am: &AgentManager, path: &std::path::Path, expected_size: u64) -> bool {
+    let Ok(meta) = std::fs::metadata(path) else {
+        return false;
+    };
+    if !meta.is_file() {
+        return false;
+    }
+    if expected_size > 0 && meta.len() != expected_size {
+        let _ = std::fs::remove_file(path);
+        return false;
+    }
+    let max_age = std::time::Duration::from_secs(am.download_cache_max_age_days() * 24 * 60 * 60);
+    if meta.modified().ok().and_then(|modified| modified.elapsed().ok()).is_some_and(|age| age > max_age) {
+        let _ = std::fs::remove_file(path);
+        return false;
+    }
+    true
+}
+
+fn prune_download_cache(am: &AgentManager) -> Result<(), String> {
+    let cache_dir = am.download_cache_dir();
+    let max_age = std::time::Duration::from_secs(am.download_cache_max_age_days() * 24 * 60 * 60);
+    let Ok(entries) = std::fs::read_dir(&cache_dir) else {
+        return Ok(());
+    };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        let Ok(meta) = entry.metadata() else {
+            continue;
+        };
+        if meta.modified().ok().and_then(|modified| modified.elapsed().ok()).is_some_and(|age| age > max_age) {
+            let _ = if meta.is_dir() { std::fs::remove_dir_all(path) } else { std::fs::remove_file(path) };
+        }
+    }
+    Ok(())
+}
+
+fn prune_driver_download_cache(am: &AgentManager, db_type: &str) -> Result<(), String> {
+    let prefix = format!("driver-{}-", cache_file_token(db_type));
+    remove_download_cache_entries(am, |name| name.starts_with(&prefix), "cached driver download")
+}
+
+fn prune_jre_download_cache(am: &AgentManager, jre_key: &str) -> Result<(), String> {
+    let prefix = format!("jre-{}-", cache_file_token(jre_key));
+    remove_download_cache_entries(am, |name| name.starts_with(&prefix), "cached JRE download")
+}
+
+fn cleanup_driver_download_cache_after_success(am: &AgentManager, db_type: &str) {
+    if let Err(err) = prune_driver_download_cache(am, db_type) {
+        log::warn!("Failed to clean cached download for {db_type}: {err}");
+    }
+}
+
+fn cleanup_jre_download_cache_after_success(am: &AgentManager, jre_key: &str) {
+    if let Err(err) = prune_jre_download_cache(am, jre_key) {
+        log::warn!("Failed to clean cached JRE download for {jre_key}: {err}");
+    }
+}
+
+fn remove_download_cache_entries(
+    am: &AgentManager,
+    should_remove: impl Fn(&str) -> bool,
+    context: &str,
+) -> Result<(), String> {
+    let cache_dir = am.download_cache_dir();
+    let Ok(entries) = std::fs::read_dir(&cache_dir) else {
+        return Ok(());
+    };
+    for entry in entries.flatten() {
+        let path = entry.path();
+        let Some(name) = path.file_name().and_then(|value| value.to_str()) else {
+            continue;
+        };
+        if !should_remove(name) {
+            continue;
+        }
+        let meta = match entry.metadata() {
+            Ok(meta) => meta,
+            Err(_) => continue,
+        };
+        if meta.is_dir() {
+            std::fs::remove_dir_all(&path).map_err(|err| format!("Failed to remove {context}: {err}"))?;
+        } else {
+            std::fs::remove_file(&path).map_err(|err| format!("Failed to remove {context}: {err}"))?;
+        }
+    }
+    Ok(())
+}
+
+fn cache_file_token(value: &str) -> String {
+    let token = value
+        .chars()
+        .map(|ch| if ch.is_ascii_alphanumeric() || ch == '-' || ch == '_' || ch == '.' { ch } else { '-' })
+        .collect::<String>()
+        .trim_matches('-')
+        .to_string();
+    if token.is_empty() {
+        "unknown".to_string()
+    } else {
+        token
+    }
+}
+
+fn r2_path_with_cache_buster(r2_path: &str, version: &str) -> String {
+    let separator = if r2_path.contains('?') { '&' } else { '?' };
+    format!("{r2_path}{separator}v={}", cache_file_token(version))
+}
+
+pub fn github_url_to_r2_path(github_url: &str, category: &str) -> String {
+    let filename = github_url.rsplit('/').next().unwrap_or(github_url);
+    match category {
+        "jre" => format!("agents/jre/{filename}"),
+        "driver" => format!("agents/drivers/{filename}"),
+        _ => format!("agents/{filename}"),
+    }
+}
+
+pub fn ensure_driver_app_version(
+    db_type: &str,
+    driver: &crate::agent_manager::DriverInfo,
+    current_version: &str,
+) -> Result<(), String> {
+    if is_app_version_compatible(&driver.min_app_version, current_version) {
+        return Ok(());
+    }
+    Err(format!(
+        "{db_type} driver {} requires DBX {} or newer. Current DBX version is {}.",
+        driver.version, driver.min_app_version, current_version
+    ))
+}
+
+pub fn is_app_version_compatible(min_app_version: &str, current_version: &str) -> bool {
+    !crate::update::is_newer_version(min_app_version, current_version)
+}
+
+pub fn download_temp_path(dest: &std::path::Path) -> std::path::PathBuf {
+    let file_name = dest.file_name().and_then(|name| name.to_str()).unwrap_or("download");
+    dest.with_file_name(format!("{file_name}.download"))
+}
+
+fn download_source_path(tmp: &std::path::Path) -> std::path::PathBuf {
+    tmp.with_extension(format!(
+        "{}source",
+        tmp.extension()
+            .and_then(|extension| extension.to_str())
+            .map(|extension| format!("{extension}."))
+            .unwrap_or_default()
+    ))
+}
+
+pub fn replace_download(tmp: &std::path::Path, dest: &std::path::Path) -> Result<(), String> {
+    if let Some(parent) = dest.parent() {
+        std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+    }
+    if dest.exists() {
+        let backup = backup_path(dest);
+        std::fs::rename(dest, &backup).map_err(|e| format!("Failed to back up existing file: {e}"))?;
+        match std::fs::rename(tmp, dest) {
+            Ok(()) => {
+                std::fs::remove_file(&backup).ok();
+                Ok(())
+            }
+            Err(err) => {
+                let _ = std::fs::rename(&backup, dest);
+                Err(format!("Failed to replace downloaded file: {err}"))
+            }
+        }
+    } else {
+        std::fs::rename(tmp, dest).map_err(|e| format!("Failed to move downloaded file into place: {e}"))
+    }
+}
+
+fn backup_path(dest: &std::path::Path) -> std::path::PathBuf {
+    let file_name = dest.file_name().and_then(|name| name.to_str()).unwrap_or("download");
+    dest.with_file_name(format!("{file_name}.backup-{}", uuid::Uuid::new_v4()))
+}
+
+// ──────────── Offline import ────────────
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct OfflineImportProgress {
+    pub step: String,
+    pub current: u32,
+    pub total: u32,
+    pub label: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct OfflineImportResult {
+    pub jre_installed: Vec<String>,
+    pub drivers_installed: Vec<String>,
+    pub drivers_skipped: Vec<String>,
+}
+
+pub fn import_offline_zip(
+    am: &AgentManager,
+    zip_path: &Path,
+    progress: impl Fn(OfflineImportProgress),
+) -> Result<OfflineImportResult, String> {
+    let file = std::fs::File::open(zip_path).map_err(|e| format!("Failed to open ZIP file: {e}"))?;
+    let mut archive = zip::ZipArchive::new(file).map_err(|e| format!("Invalid ZIP file: {e}"))?;
+
+    let registry = read_registry_from_zip(&mut archive)?;
+
+    let platform = AgentManager::current_platform();
+    let mut local_state = am.load_state();
+    let mut result =
+        OfflineImportResult { jre_installed: Vec::new(), drivers_installed: Vec::new(), drivers_skipped: Vec::new() };
+
+    let jre_entries: Vec<(String, String)> = (0..archive.len())
+        .filter_map(|i| {
+            let entry = archive.by_index(i).ok()?;
+            let name = entry.name().to_string();
+            if name.starts_with("jre/") && name.ends_with(".tar.gz") && name.contains(platform) {
+                let jre_key = extract_jre_key_from_filename(&name)?;
+                Some((jre_key, name))
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    let driver_entries: Vec<(String, String, bool)> = (0..archive.len())
+        .filter_map(|i| {
+            let entry = archive.by_index(i).ok()?;
+            let name = entry.name().to_string();
+            if name.starts_with("drivers/") && name.ends_with(".jar") {
+                let db_type = extract_db_type_from_filename(&name)?;
+                Some((db_type, name, false))
+            } else if name.starts_with("drivers/") {
+                let db_type = db_type_for_native_offline_entry(&registry, platform, &name)?;
+                Some((db_type, name, true))
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    let total = (jre_entries.len() + driver_entries.len()) as u32;
+    let mut current: u32 = 0;
+
+    for (jre_key, entry_name) in &jre_entries {
+        current += 1;
+        let jre_version = registry.resolve_jre(jre_key).map(|j| j.version.clone());
+        let existing_version = local_state.jre_versions.get(jre_key);
+        if am.is_jre_installed(jre_key) && existing_version == jre_version.as_ref() {
+            continue;
+        }
+
+        progress(OfflineImportProgress { step: "jre-extract".into(), current, total, label: format!("JRE {jre_key}") });
+
+        let mut entry = archive.by_name(entry_name).map_err(|e| format!("Failed to read {entry_name}: {e}"))?;
+        let tmp_archive = am.base_dir().join(format!("jre-offline-{jre_key}.tar.gz"));
+        {
+            let mut out =
+                std::fs::File::create(&tmp_archive).map_err(|e| format!("Failed to create temp file: {e}"))?;
+            std::io::copy(&mut entry, &mut out).map_err(|e| format!("Failed to extract JRE archive: {e}"))?;
+        }
+
+        let jre_dir = am.jre_dir(jre_key);
+        // Daemons cannot be stopped from a sync function safely; the retry +
+        // Windows rename fallback in replace_old_jre_dir still handles a
+        // locked directory. Daemon shutdown for the foreground install paths
+        // happens in `reinstall_agent_jre` and `install_agent_driver_*`.
+        replace_old_jre_dir(am, &jre_dir)?;
+        extract_tar_gz(&tmp_archive, &jre_dir)?;
+        std::fs::remove_file(&tmp_archive).ok();
+
+        if let Some(ver) = jre_version {
+            local_state.jre_versions.insert(jre_key.clone(), ver);
+        }
+        result.jre_installed.push(jre_key.clone());
+    }
+
+    for (db_type, entry_name, is_native) in &driver_entries {
+        current += 1;
+
+        if let Some(remote_driver) = registry.drivers.get(db_type) {
+            if let Some(installed) = local_state.installed_drivers.get(db_type) {
+                if installed.version != "0.1.0-local"
+                    && installed.version != "local"
+                    && !crate::update::is_newer_version(&remote_driver.version, &installed.version)
+                {
+                    result.drivers_skipped.push(db_type.clone());
+                    continue;
+                }
+            }
+        }
+
+        progress(OfflineImportProgress {
+            step: "driver".into(),
+            current,
+            total,
+            label: agent_catalog::label_for_key(db_type).unwrap_or(db_type).to_string(),
+        });
+
+        let driver_path = if *is_native { am.driver_native_path(db_type) } else { am.driver_jar_path(db_type) };
+        if let Some(parent) = driver_path.parent() {
+            std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+        }
+        let mut entry = archive.by_name(entry_name).map_err(|e| format!("Failed to read {entry_name}: {e}"))?;
+        let mut out = std::fs::File::create(&driver_path).map_err(|e| format!("Failed to write driver: {e}"))?;
+        std::io::copy(&mut entry, &mut out).map_err(|e| format!("Failed to copy driver: {e}"))?;
+        if *is_native {
+            mark_executable(&driver_path)?;
+            std::fs::remove_file(am.driver_jar_path(db_type)).ok();
+        } else {
+            // Offline bundles are user-supplied; reject corrupt JARs before state says the driver is installed.
+            if !am.is_driver_jar_valid(db_type) {
+                std::fs::remove_file(&driver_path).ok();
+                return Err(format!("Offline agent jar is invalid or corrupt: {entry_name}"));
+            }
+            std::fs::remove_file(am.driver_native_path(db_type)).ok();
+        }
+
+        let version = registry.drivers.get(db_type).map(|d| d.version.clone()).unwrap_or_else(|| "local".to_string());
+        let jre_key =
+            registry.drivers.get(db_type).map(|d| d.jre.clone()).unwrap_or_else(|| DEFAULT_JRE_KEY.to_string());
+
+        local_state.installed_drivers.insert(
+            db_type.clone(),
+            InstalledDriver { version, installed_at: chrono::Utc::now().to_rfc3339(), jre: jre_key },
+        );
+        result.drivers_installed.push(db_type.clone());
+    }
+
+    am.save_state(&local_state)?;
+    Ok(result)
+}
+
+fn read_registry_from_zip(archive: &mut zip::ZipArchive<std::fs::File>) -> Result<AgentRegistry, String> {
+    let mut entry = archive
+        .by_name("agent-registry.json")
+        .map_err(|_| "ZIP 文件中未找到 agent-registry.json，请确认这是有效的离线驱动包".to_string())?;
+    let mut buf = String::new();
+    entry.read_to_string(&mut buf).map_err(|e| format!("Failed to read agent-registry.json: {e}"))?;
+    serde_json::from_str(&buf).map_err(|e| format!("Invalid agent-registry.json: {e}"))
+}
+
+fn extract_jre_key_from_filename(name: &str) -> Option<String> {
+    let filename = name.rsplit('/').next()?;
+    let rest = filename.strip_prefix("jre-")?;
+    let key = rest.split('-').next()?;
+    if key.is_empty() {
+        return None;
+    }
+    Some(key.to_string())
+}
+
+fn extract_db_type_from_filename(name: &str) -> Option<String> {
+    let filename = name.rsplit('/').next()?;
+    let rest = filename.strip_prefix("dbx-agent-")?;
+    let db_type = rest.strip_suffix(".jar")?;
+    if db_type.is_empty() {
+        return None;
+    }
+    Some(db_type.to_string())
+}
+
+fn db_type_for_native_offline_entry(registry: &AgentRegistry, platform: &str, name: &str) -> Option<String> {
+    let filename = name.rsplit('/').next()?;
+    registry.drivers.iter().find_map(|(db_type, driver)| {
+        let artifact = driver.native.get(platform)?;
+        let artifact_filename = artifact.url.rsplit('/').next()?;
+        (artifact_filename == filename).then(|| db_type.clone())
+    })
+}
+
+fn extract_tar_gz(archive: &Path, dest: &Path) -> Result<(), String> {
+    std::fs::create_dir_all(dest).map_err(|e| e.to_string())?;
+    let status = crate::process::new_std_command("tar")
+        .args(["xzf", &archive.to_string_lossy(), "-C", &dest.to_string_lossy(), "--strip-components=1"])
+        .status()
+        .map_err(|e| format!("Failed to extract archive: {e}"))?;
+    if !status.success() {
+        return Err("Failed to extract JRE archive".to_string());
+    }
+    Ok(())
+}
+
+pub fn import_agent_jar(am: &AgentManager, db_type: &str, jar_path: &Path) -> Result<(), String> {
+    if !jar_path.exists() {
+        return Err(format!("File not found: {}", jar_path.display()));
+    }
+    install_local_agent(am, db_type, jar_path.to_path_buf())
+}
+
+// ──────────── Tests ────────────
+
+#[cfg(test)]
+mod agent_download_url_tests {
+    use super::*;
+
+    #[test]
+    fn r2_cache_buster_uses_version_query() {
+        assert_eq!(
+            r2_path_with_cache_buster("agents/jre/dbx-jre-21-macos-x64.tar.gz", "21.0.11+7"),
+            "agents/jre/dbx-jre-21-macos-x64.tar.gz?v=21.0.11-7"
+        );
+    }
+
+    #[test]
+    fn r2_cache_buster_preserves_existing_query() {
+        assert_eq!(
+            r2_path_with_cache_buster("agents/drivers/dbx-agent-h2.jar?mirror=r2", "0.5.33"),
+            "agents/drivers/dbx-agent-h2.jar?mirror=r2&v=0.5.33"
+        );
+    }
+}
+
+#[cfg(test)]
+mod agent_registry_install_tests {
+    use super::*;
+    use crate::agent_manager::{ArtifactInfo, DriverInfo, JavaRuntimeConfig};
+
+    fn test_manager(name: &str) -> AgentManager {
+        let dir = std::env::temp_dir().join(format!("dbx-agent-registry-install-{name}-{}", uuid::Uuid::new_v4()));
+        AgentManager::new_with_base_dir(dir)
+    }
+
+    fn registry_with_native_and_legacy_jar(
+        db_type: &str,
+        version: &str,
+        native_url: &str,
+        native_size: u64,
+    ) -> AgentRegistry {
+        let mut drivers = std::collections::HashMap::new();
+        drivers.insert(
+            db_type.to_string(),
+            DriverInfo {
+                version: version.to_string(),
+                label: db_type.to_string(),
+                min_app_version: "0.1.0".to_string(),
+                jre: DEFAULT_JRE_KEY.to_string(),
+                jar: Some(ArtifactInfo {
+                    url: format!("https://example.com/dbx-agent-{db_type}-legacy-placeholder.jar"),
+                    size: 0,
+                }),
+                native: [(
+                    AgentManager::current_platform().to_string(),
+                    ArtifactInfo { url: native_url.to_string(), size: native_size },
+                )]
+                .into_iter()
+                .collect(),
+            },
+        );
+        AgentRegistry { jre: None, jres: std::collections::HashMap::new(), drivers }
+    }
+
+    fn registry_with_jar(db_type: &str, version: &str, url: &str, size: u64) -> AgentRegistry {
+        let mut drivers = std::collections::HashMap::new();
+        drivers.insert(
+            db_type.to_string(),
+            DriverInfo {
+                version: version.to_string(),
+                label: db_type.to_string(),
+                min_app_version: "0.1.0".to_string(),
+                jre: DEFAULT_JRE_KEY.to_string(),
+                jar: Some(ArtifactInfo { url: url.to_string(), size }),
+                native: std::collections::HashMap::new(),
+            },
+        );
+        AgentRegistry { jre: None, jres: std::collections::HashMap::new(), drivers }
+    }
+
+    fn write_cached_driver_download(
+        am: &AgentManager,
+        db_type: &str,
+        version: &str,
+        url: &str,
+        dest: &Path,
+        bytes: &[u8],
+    ) -> PathBuf {
+        let cache_path =
+            cached_download_path(am, url, bytes.len() as u64, Some(CacheIdentity::Driver { db_type, version }), dest);
+        std::fs::create_dir_all(cache_path.parent().unwrap()).unwrap();
+        std::fs::write(&cache_path, bytes).unwrap();
+        cache_path
+    }
+
+    #[tokio::test]
+    async fn registry_install_accepts_native_driver_with_legacy_jar_fallback() {
+        let manager = test_manager("native-with-jar-fallback");
+        let db_type = "oracle";
+        let version = "0.1.31";
+        let native_url = "https://example.com/dbx-agent-oracle";
+        let native_bytes = b"native-agent";
+        let registry = registry_with_native_and_legacy_jar(db_type, version, native_url, native_bytes.len() as u64);
+        let native_path = manager.driver_native_path(db_type);
+        let cache_path =
+            write_cached_driver_download(&manager, db_type, version, native_url, &native_path, native_bytes);
+        let progress = |_| {};
+
+        install_agent_driver_from_registry(
+            &manager,
+            &registry,
+            DownloadSource::Official,
+            db_type,
+            &progress,
+            None,
+            None,
+        )
+        .await
+        .unwrap();
+
+        assert_eq!(std::fs::read(&native_path).unwrap(), native_bytes);
+        assert!(!cache_path.exists());
+        assert!(!manager.driver_jar_path(db_type).exists());
+        assert_eq!(manager.load_state().installed_drivers.get(db_type).unwrap().version, version);
+    }
+
+    #[tokio::test]
+    async fn registry_install_rejects_corrupt_downloaded_jar() {
+        let manager = test_manager("corrupt-jar");
+        let db_type = "h2";
+        let version = "0.2.0";
+        let jar_url = "https://example.com/dbx-agent-h2.jar";
+        let jar_bytes = b"jar";
+        let registry = registry_with_jar(db_type, version, jar_url, jar_bytes.len() as u64);
+        let jar_path = manager.driver_jar_path(db_type);
+        let cache_path = write_cached_driver_download(&manager, db_type, version, jar_url, &jar_path, jar_bytes);
+        manager
+            .save_state(&crate::agent_manager::AgentState {
+                java_runtime: JavaRuntimeConfig { mode: JavaRuntimeMode::System, custom_java_path: None },
+                ..Default::default()
+            })
+            .unwrap();
+        let progress = |_| {};
+
+        let err = install_agent_driver_from_registry(
+            &manager,
+            &registry,
+            DownloadSource::Official,
+            db_type,
+            &progress,
+            None,
+            None,
+        )
+        .await
+        .unwrap_err();
+
+        assert!(err.contains("invalid or corrupt"));
+        assert!(cache_path.exists());
+        assert!(!jar_path.exists());
+        assert!(!manager.load_state().installed_drivers.contains_key(db_type));
+    }
+}
+
+#[cfg(test)]
+mod jre_dir_remove_tests {
+    use super::*;
+
+    fn unique_tmp(name: &str) -> PathBuf {
+        std::env::temp_dir().join(format!("dbx-jre-remove-{name}-{}", uuid::Uuid::new_v4()))
+    }
+
+    #[test]
+    fn remove_returns_ok_when_path_missing() {
+        let path = unique_tmp("missing");
+        assert!(!path.exists());
+        assert!(remove_jre_dir_with_retry(&path).is_ok());
+    }
+
+    #[test]
+    fn remove_deletes_existing_dir() {
+        let dir = unique_tmp("happy");
+        std::fs::create_dir_all(dir.join("bin")).unwrap();
+        std::fs::write(dir.join("bin").join("java"), b"x").unwrap();
+        assert!(dir.exists());
+        remove_jre_dir_with_retry(&dir).expect("happy path delete");
+        assert!(!dir.exists());
+    }
+
+    #[test]
+    fn windows_error_message_lists_root_causes_and_path() {
+        let path = PathBuf::from("/tmp/dbx-jre-test");
+        let err = std::io::Error::new(std::io::ErrorKind::PermissionDenied, "拒绝访问。 (os error 5)");
+        let rendered = format_jre_dir_remove_error(&path, &err);
+        assert!(rendered.contains(&path.display().to_string()), "missing path: {rendered}");
+        assert!(rendered.contains("（原始错误："), "missing original error wrapper: {rendered}");
+        assert!(rendered.contains("拒绝访问"), "missing original error text: {rendered}");
+        if cfg!(windows) {
+            assert!(rendered.starts_with("无法删除旧的 JRE 目录："), "wrong prefix: {rendered}");
+            assert!(rendered.contains("Agent / java 进程占用"), "missing process advice: {rendered}");
+            assert!(rendered.contains("重启 dbx 后重试"), "missing restart advice: {rendered}");
+        } else {
+            // POSIX path: short form, no Windows-specific advice.
+            assert!(rendered.contains("无法删除旧的 JRE 目录"));
+            assert!(!rendered.contains("防病毒"));
+        }
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn stash_old_jre_dir_renames_and_is_unique() {
+        let base = unique_tmp("stash-unique");
+        std::fs::create_dir_all(&base).unwrap();
+        let jre_a = base.join("jre-21");
+        std::fs::create_dir_all(&jre_a).unwrap();
+        let stash_a = stash_old_jre_dir(&jre_a).expect("first stash");
+        assert!(stash_a.exists(), "stash dir should exist after rename");
+        assert!(!jre_a.exists(), "original dir should be gone after rename");
+
+        // Recreate original and stash again — name must differ.
+        std::fs::create_dir_all(&jre_a).unwrap();
+        let stash_b = stash_old_jre_dir(&jre_a).expect("second stash");
+        assert_ne!(stash_a, stash_b, "stash names must be unique across calls");
+
+        // Cleanup.
+        let _ = std::fs::remove_dir_all(&base);
+    }
+}
diff --git a/crates/dbx-core/src/agent_tools.rs b/crates/dbx-core/src/agent_tools.rs
new file mode 100644
index 0000000..2ddda1e
--- /dev/null
+++ b/crates/dbx-core/src/agent_tools.rs
@@ -0,0 +1,917 @@
+use std::sync::Arc;
+
+use serde_json::json;
+
+use crate::agent_events::{ToolCall, ToolDefinition, ToolResult};
+use crate::connection::AppState;
+use crate::db::vector_driver;
+use crate::models::connection::DatabaseType;
+use crate::query::QueryExecutionOptions;
+use crate::query_execution_sql::{build_explain_sql, supports_explain_plan, supports_sql_query, ExplainSqlOptions};
+use crate::sql_risk::SqlRisk;
+use crate::types::QueryResult;
+
+/// Maximum number of tables returned by list_tables tool.
+const LIST_TABLES_LIMIT: usize = 200;
+
+/// Maximum number of rows returned by execute_query tool.
+const EXECUTE_QUERY_LIMIT: usize = 50;
+
+/// Maximum number of rows returned by get_sample_data tool.
+const SAMPLE_DATA_LIMIT: usize = 20;
+
+/// Maximum number of rows returned by browse_collection tool.
+const BROWSE_COLLECTION_LIMIT: usize = 20;
+
+/// Absolute maximum rows any query tool may request.
+const MAX_ALLOWED_ROWS: usize = 100;
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct AgentSqlPermissions {
+    pub allow_writes: bool,
+    pub allow_dangerous: bool,
+}
+
+fn sql_risk_allowed(risk: SqlRisk, permissions: AgentSqlPermissions) -> bool {
+    match risk {
+        SqlRisk::ReadOnly => true,
+        SqlRisk::Write => permissions.allow_writes,
+        SqlRisk::Ddl => permissions.allow_dangerous,
+        SqlRisk::Transaction => false,
+    }
+}
+
+/// Returns true for vector database types (Qdrant, Milvus, Weaviate, ChromaDb).
+/// If modifying this, also update VECTOR_DB_TYPES in apps/desktop/src/lib/ai.ts.
+pub fn is_vector_db(db_type: DatabaseType) -> bool {
+    matches!(db_type, DatabaseType::Qdrant | DatabaseType::Milvus | DatabaseType::Weaviate | DatabaseType::ChromaDb)
+}
+
+/// Get read-only tool definitions for the given database type.
+/// Returns vector tools for vector DBs, SQL tools otherwise.
+pub fn read_only_tools(db_type: DatabaseType) -> Vec<ToolDefinition> {
+    if is_vector_db(db_type) {
+        vec![list_collections_tool()]
+    } else {
+        vec![list_tables_tool(), get_columns_tool()]
+    }
+}
+
+/// Get all available tool definitions for the given database type.
+/// Includes read-only tools plus execute_query, get_sample_data, and
+/// explain_query for database types that support them.
+pub fn all_tools(db_type: DatabaseType, sql_permissions: AgentSqlPermissions) -> Vec<ToolDefinition> {
+    if is_vector_db(db_type) {
+        return vec![list_collections_tool(), browse_collection_tool()];
+    }
+    let mut tools = vec![list_tables_tool(), get_columns_tool()];
+    if supports_sql_query(db_type) {
+        tools.push(execute_query_tool(sql_permissions));
+        tools.push(get_sample_data_tool());
+    }
+    if supports_explain_plan(Some(db_type)) {
+        tools.push(explain_query_tool());
+    }
+    tools
+}
+
+/// list_tables tool definition.
+fn list_tables_tool() -> ToolDefinition {
+    ToolDefinition {
+        name: "list_tables",
+        description: "List all tables and views in the current database. Returns table names, types, and comments.",
+        parameters: json!({
+            "type": "object",
+            "properties": {
+                "schema": {
+                    "type": "string",
+                    "description": "Schema name to list tables from (optional, defaults to current database)"
+                }
+            },
+            "required": []
+        }),
+        read_only: true,
+        parallel_ok: true,
+    }
+}
+
+/// get_columns tool definition.
+fn get_columns_tool() -> ToolDefinition {
+    ToolDefinition {
+        name: "get_columns",
+        description:
+            "Get column definitions for a table: names, types, primary keys, nullable, defaults, and comments. \
+             Use this when the user asks about table structure, column details, or field information — \
+             even if some schema context was provided, this tool returns the authoritative and complete column list.",
+        parameters: json!({
+            "type": "object",
+            "properties": {
+                "table": {
+                    "type": "string",
+                    "description": "Table name to get columns for"
+                },
+                "schema": {
+                    "type": "string",
+                    "description": "Schema name (optional, defaults to current database)"
+                }
+            },
+            "required": ["table"]
+        }),
+        read_only: true,
+        // get_columns runs sequentially: concurrent metadata queries can exhaust
+        // single-connection drivers (e.g. DuckDB), causing cascading tool errors.
+        parallel_ok: false,
+    }
+}
+/// execute_query tool definition.
+fn execute_query_tool(sql_permissions: AgentSqlPermissions) -> ToolDefinition {
+    let description = if sql_permissions.allow_dangerous {
+        "Execute SQL after the user explicitly confirmed this operation. Read queries, writes, and DDL are allowed for this run."
+    } else if sql_permissions.allow_writes {
+        "Execute SQL after the user explicitly confirmed this operation. Read queries and non-DDL writes are allowed for this run."
+    } else {
+        "Execute a read-only SQL query and return results (max 50 rows). Only SELECT, WITH, SHOW, DESCRIBE, EXPLAIN statements are allowed. Write operations (INSERT/UPDATE/DELETE/DDL) are blocked."
+    };
+    ToolDefinition {
+        name: "execute_query",
+        description,
+        parameters: json!({
+            "type": "object",
+            "properties": {
+                "sql": {
+                    "type": "string",
+                    "description": "The SQL query to execute"
+                },
+                "limit": {
+                    "type": "number",
+                    "description": "Max rows to return (default 50, max 100)"
+                }
+            },
+            "required": ["sql"]
+        }),
+        read_only: true,
+        parallel_ok: false,
+    }
+}
+
+/// get_sample_data tool definition.
+fn get_sample_data_tool() -> ToolDefinition {
+    ToolDefinition {
+        name: "get_sample_data",
+        description: "Get sample rows from a table to understand its data. Returns up to 20 rows.",
+        parameters: json!({
+            "type": "object",
+            "properties": {
+                "table": {
+                    "type": "string",
+                    "description": "Table name"
+                },
+                "schema": {
+                    "type": "string",
+                    "description": "Schema name (optional)"
+                },
+                "limit": {
+                    "type": "number",
+                    "description": "Max rows (default 20)"
+                }
+            },
+            "required": ["table"]
+        }),
+        read_only: true,
+        parallel_ok: true,
+    }
+}
+
+/// explain_query tool definition (Phase 3).
+fn explain_query_tool() -> ToolDefinition {
+    ToolDefinition {
+        name: "explain_query",
+        description: "Get the execution plan for a SQL query using EXPLAIN. \
+                      Shows how the database will execute the query (scan type, indexes, cost). \
+                      Only read-only queries (SELECT, WITH, SHOW, DESCRIBE, EXPLAIN) are allowed. \
+                      Use this to analyze query performance and suggest index optimizations.",
+        parameters: json!({
+            "type": "object",
+            "properties": {
+                "sql": {
+                    "type": "string",
+                    "description": "The SQL query to explain (must be read-only)"
+                }
+            },
+            "required": ["sql"]
+        }),
+        read_only: true,
+        parallel_ok: true,
+    }
+}
+
+/// list_collections tool definition (vector databases).
+fn list_collections_tool() -> ToolDefinition {
+    ToolDefinition {
+        name: "list_collections",
+        description: "List all collections in the current vector database. Returns collection names and dimensions.",
+        parameters: json!({
+            "type": "object",
+            "properties": {},
+            "required": []
+        }),
+        read_only: true,
+        parallel_ok: true,
+    }
+}
+
+/// browse_collection tool definition (vector databases).
+fn browse_collection_tool() -> ToolDefinition {
+    ToolDefinition {
+        name: "browse_collection",
+        description: "Browse documents in a collection. Returns up to 20 items with payload/metadata (vectors excluded for compactness). For ChromaDB, use the collection id (UUID from list_collections) instead of the collection name.",
+        parameters: json!({
+            "type": "object",
+            "properties": {
+                "collection": {
+                    "type": "string",
+                    "description": "Collection name"
+                },
+                "limit": {
+                    "type": "number",
+                    "description": "Max items to return (default 20, max 100)"
+                }
+            },
+            "required": ["collection"]
+        }),
+        read_only: true,
+        parallel_ok: true,
+    }
+}
+
+/// Execute a tool call and return the result.
+pub async fn execute_tool(
+    tool_call: &ToolCall,
+    state: &Arc<AppState>,
+    connection_id: &str,
+    database: &str,
+    db_type: &DatabaseType,
+    sql_permissions: AgentSqlPermissions,
+) -> ToolResult {
+    let result = match tool_call.name.as_str() {
+        "list_tables" => execute_list_tables(tool_call, state, connection_id, database, db_type).await,
+        "get_columns" => execute_get_columns(tool_call, state, connection_id, database, db_type).await,
+        "execute_query" => {
+            execute_execute_query(tool_call, state, connection_id, database, db_type, sql_permissions).await
+        }
+        "get_sample_data" => execute_get_sample_data(tool_call, state, connection_id, database, db_type).await,
+        "list_collections" => execute_list_collections(tool_call, state, connection_id, database, db_type).await,
+        "browse_collection" => execute_browse_collection(tool_call, state, connection_id, database, db_type).await,
+        "explain_query" => {
+            let (text_result, explain_data) =
+                execute_explain_query(tool_call, state, connection_id, database, db_type).await;
+            match text_result {
+                Ok(content) => {
+                    return ToolResult {
+                        tool_call_id: tool_call.id.clone(),
+                        tool_name: tool_call.name.clone(),
+                        content,
+                        is_error: false,
+                        explain_data,
+                    };
+                }
+                Err(err) => {
+                    return ToolResult {
+                        tool_call_id: tool_call.id.clone(),
+                        tool_name: tool_call.name.clone(),
+                        content: format!("Error: {err}"),
+                        is_error: true,
+                        explain_data: None,
+                    };
+                }
+            }
+        }
+        _ => Err(format!("Unknown tool: {}", tool_call.name)),
+    };
+
+    match result {
+        Ok(content) => ToolResult {
+            tool_call_id: tool_call.id.clone(),
+            tool_name: tool_call.name.clone(),
+            content,
+            is_error: false,
+            explain_data: None,
+        },
+        Err(err) => ToolResult {
+            tool_call_id: tool_call.id.clone(),
+            tool_name: tool_call.name.clone(),
+            content: format!("Error: {err}"),
+            is_error: true,
+            explain_data: None,
+        },
+    }
+}
+
+async fn execute_list_tables(
+    tool_call: &ToolCall,
+    state: &Arc<AppState>,
+    connection_id: &str,
+    database: &str,
+    _db_type: &DatabaseType,
+) -> Result<String, String> {
+    let schema = tool_call.arguments.get("schema").and_then(|v| v.as_str()).unwrap_or("").to_string();
+
+    // Request one extra to detect whether more tables exist beyond the limit.
+    let tables = crate::schema::list_tables_core(
+        state,
+        connection_id,
+        database,
+        &schema,
+        None,
+        Some(LIST_TABLES_LIMIT + 1),
+        None,
+        None,
+    )
+    .await
+    .map_err(|e| format!("Failed to list tables: {e}"))?;
+
+    let total = tables.len();
+    let truncated = total > LIST_TABLES_LIMIT;
+
+    let mut lines = Vec::new();
+    let display_count = if truncated { LIST_TABLES_LIMIT } else { total };
+    for table in tables.iter().take(display_count) {
+        let mut line = format!("- {} ({})", table.name, table.table_type);
+        if let Some(comment) = &table.comment {
+            let trimmed = comment.trim();
+            if !trimmed.is_empty() {
+                line.push_str(&format!(" -- {}", trimmed));
+            }
+        }
+        lines.push(line);
+    }
+
+    if truncated {
+        lines.push(format!("... (showing {LIST_TABLES_LIMIT} of {total} tables)"));
+    }
+
+    if lines.is_empty() {
+        return Ok("No tables found in this database/schema.".to_string());
+    }
+
+    Ok(lines.join("\n"))
+}
+
+async fn execute_get_columns(
+    tool_call: &ToolCall,
+    state: &Arc<AppState>,
+    connection_id: &str,
+    database: &str,
+    _db_type: &DatabaseType,
+) -> Result<String, String> {
+    let table = tool_call
+        .arguments
+        .get("table")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing required parameter: table")?
+        .trim()
+        .to_string();
+
+    if table.is_empty() {
+        return Err("Table name cannot be empty".to_string());
+    }
+    if table.len() > 256 {
+        return Err(format!("Table name too long: {} characters (max 256)", table.len()));
+    }
+    // Reject names with characters that are unlikely to be valid identifiers
+    if table.contains(';') || table.contains('\'') || table.contains('"') || table.contains('\\') {
+        return Err(format!("Table name contains invalid characters: '{}'", table));
+    }
+
+    let schema = tool_call.arguments.get("schema").and_then(|v| v.as_str()).unwrap_or("").to_string();
+
+    let columns = crate::schema::get_columns_core(state, connection_id, database, &schema, &table)
+        .await
+        .map_err(|e| format!("Failed to get columns for {table}: {e}"))?;
+
+    if columns.is_empty() {
+        return Ok(format!("No columns found for table '{table}'."));
+    }
+
+    let mut lines = Vec::new();
+    lines.push(format!("Columns of {table}:"));
+    for col in &columns {
+        let mut flags: Vec<String> = Vec::new();
+        if col.is_primary_key {
+            flags.push("PK".to_string());
+        }
+        if col.is_nullable {
+            flags.push("nullable".to_string());
+        } else {
+            flags.push("NOT NULL".to_string());
+        }
+        if let Some(default) = &col.column_default {
+            if !default.is_empty() {
+                flags.push(format!("default {default}"));
+            }
+        }
+        if let Some(extra) = &col.extra {
+            if !extra.is_empty() {
+                flags.push(extra.clone());
+            }
+        }
+
+        let flags_str = if flags.is_empty() { String::new() } else { format!(" ({})", flags.join(", ")) };
+
+        let comment_str = col
+            .comment
+            .as_ref()
+            .filter(|c| !c.trim().is_empty())
+            .map(|c| format!(" -- {}", c.trim()))
+            .unwrap_or_default();
+
+        lines.push(format!("  - {}: {}{}{}", col.name, col.data_type, flags_str, comment_str));
+    }
+
+    Ok(lines.join("\n"))
+}
+
+/// Execute a read-only SQL query via the execute_query tool.
+async fn execute_execute_query(
+    tool_call: &ToolCall,
+    state: &Arc<AppState>,
+    connection_id: &str,
+    database: &str,
+    db_type: &DatabaseType,
+    sql_permissions: AgentSqlPermissions,
+) -> Result<String, String> {
+    let sql = tool_call.arguments.get("sql").and_then(|v| v.as_str()).ok_or("Missing required parameter: sql")?.trim();
+
+    if sql.is_empty() {
+        return Err("SQL query cannot be empty".to_string());
+    }
+
+    let limit = tool_call
+        .arguments
+        .get("limit")
+        .and_then(|v| v.as_u64())
+        .map(|l| (l as usize).min(MAX_ALLOWED_ROWS))
+        .unwrap_or(EXECUTE_QUERY_LIMIT);
+
+    // Classify SQL risk using the concrete database dialect.
+    let risk = crate::sql_risk::classify_sql_risk_for_database(sql, *db_type)?;
+    let connection_config = state.configs.read().await.get(connection_id).cloned();
+    if let Some(config) = connection_config {
+        if risk != SqlRisk::ReadOnly && crate::production_safety::targets_production_database(&config, database, sql) {
+            return Err("Blocked: AI agents cannot execute writes or DDL on a production database. Return the SQL for the user to review and execute manually in DBX.".to_string());
+        }
+    }
+    if !sql_risk_allowed(risk, sql_permissions) {
+        if risk == SqlRisk::Transaction {
+            return Err("Blocked: transaction control statements are not available to the AI agent.".to_string());
+        }
+        return Err(format!(
+            "Blocked: {} statement detected. Ask the user to confirm the proposed database change before executing it.",
+            risk
+        ));
+    }
+
+    // Execute query using existing infrastructure
+    let options = QueryExecutionOptions { max_rows: Some(limit), timeout_secs: Some(30), ..Default::default() };
+    let result =
+        crate::query::execute_sql_statement_with_options(state, connection_id, database, sql, None, None, options)
+            .await?;
+
+    format_query_result_as_text(&result, limit)
+}
+
+/// Format a QueryResult as a Markdown table for LLM consumption.
+fn format_query_result_as_text(result: &QueryResult, limit: usize) -> Result<String, String> {
+    if result.rows.is_empty() {
+        return Ok("Query returned 0 rows.".to_string());
+    }
+
+    let mut lines = Vec::new();
+
+    // Header row
+    lines.push(format!("| {} |", result.columns.join(" | ")));
+    // Separator row
+    lines.push(format!("|{}|", result.columns.iter().map(|_| "---").collect::<Vec<_>>().join("|")));
+
+    // Data rows
+    for row in &result.rows {
+        let cells: Vec<String> = row
+            .iter()
+            .map(|v| match v {
+                serde_json::Value::Null => "NULL".to_string(),
+                serde_json::Value::String(s) => {
+                    // Truncate long strings to keep result compact
+                    if s.len() > 200 {
+                        let truncated: String =
+                            s.char_indices().take_while(|(i, _)| *i < 200).map(|(_, c)| c).collect();
+                        format!("{}...", truncated)
+                    } else {
+                        s.clone()
+                    }
+                }
+                other => other.to_string(),
+            })
+            .collect();
+        lines.push(format!("| {} |", cells.join(" | ")));
+    }
+
+    // Truncation notice
+    if result.truncated || result.rows.len() >= limit {
+        lines.push(format!("... (showing {} rows, result may be truncated)", result.rows.len()));
+    }
+
+    // Stats line
+    lines.push(format!("({} rows, {}ms)", result.rows.len(), result.execution_time_ms));
+
+    Ok(lines.join("\n"))
+}
+
+/// Get sample data from a table via the get_sample_data tool.
+async fn execute_get_sample_data(
+    tool_call: &ToolCall,
+    state: &Arc<AppState>,
+    connection_id: &str,
+    database: &str,
+    db_type: &DatabaseType,
+) -> Result<String, String> {
+    let table =
+        tool_call.arguments.get("table").and_then(|v| v.as_str()).ok_or("Missing required parameter: table")?.trim();
+
+    if table.is_empty() {
+        return Err("Table name cannot be empty".to_string());
+    }
+    if table.contains(';') || table.contains('\'') || table.contains('"') || table.contains('\\') {
+        return Err(format!("Table name contains invalid characters: '{}'", table));
+    }
+
+    let schema = tool_call.arguments.get("schema").and_then(|v| v.as_str());
+    let limit = tool_call
+        .arguments
+        .get("limit")
+        .and_then(|v| v.as_u64())
+        .map(|l| (l as usize).min(MAX_ALLOWED_ROWS))
+        .unwrap_or(SAMPLE_DATA_LIMIT);
+
+    // Build SELECT * FROM table LIMIT N
+    let schema_prefix = schema.filter(|s| !s.is_empty()).map(|s| format!("\"{}\".", s)).unwrap_or_default();
+    let sql = format!("SELECT * FROM {}\"{}\" LIMIT {}", schema_prefix, table, limit);
+
+    // Delegate to execute_execute_query with a synthetic tool call
+    let synthetic_call = ToolCall {
+        id: tool_call.id.clone(),
+        name: "execute_query".to_string(),
+        arguments: serde_json::json!({ "sql": sql, "limit": limit }),
+    };
+    execute_execute_query(&synthetic_call, state, connection_id, database, db_type, AgentSqlPermissions::default())
+        .await
+}
+
+/// Execute an EXPLAIN query via the explain_query tool.
+/// Returns (text_for_llm, optional_explain_data_for_frontend).
+async fn execute_explain_query(
+    tool_call: &ToolCall,
+    state: &Arc<AppState>,
+    connection_id: &str,
+    database: &str,
+    db_type: &DatabaseType,
+) -> (Result<String, String>, Option<serde_json::Value>) {
+    let sql = match tool_call.arguments.get("sql").and_then(|v| v.as_str()) {
+        Some(s) => s.trim(),
+        None => return (Err("Missing required parameter: sql".to_string()), None),
+    };
+
+    if sql.is_empty() {
+        return (Err("SQL query cannot be empty".to_string()), None);
+    }
+
+    // Classify SQL risk – only ReadOnly queries can be explained
+    let risk = match crate::sql_risk::classify_sql_risk_for_database(sql, *db_type) {
+        Ok(r) => r,
+        Err(e) => return (Err(e), None),
+    };
+    match risk {
+        SqlRisk::ReadOnly => { /* proceed */ }
+        _ => {
+            return (
+                Err(format!(
+                    "Blocked: {} statement detected. Only read-only queries (SELECT, SHOW, DESCRIBE, EXPLAIN) can be analyzed.",
+                    risk
+                )),
+                None,
+            );
+        }
+    }
+
+    if *db_type == DatabaseType::Oracle {
+        return match crate::agent_explain::get_agent_explain_info_core(
+            state,
+            connection_id,
+            Some(database),
+            None,
+            sql,
+            Some("explain"),
+        )
+        .await
+        {
+            Ok(plan) => (Ok(plan.clone()), Some(serde_json::Value::String(plan))),
+            Err(error) => (Err(error), None),
+        };
+    }
+
+    // Build the database-specific EXPLAIN SQL
+    let explain_result =
+        build_explain_sql(ExplainSqlOptions { database_type: Some(*db_type), format: None, sql: sql.to_string() });
+
+    let explain_sql = match (explain_result.ok, explain_result.sql) {
+        (true, Some(sql)) => sql,
+        (true, None) => return (Err("EXPLAIN SQL is empty".to_string()), None),
+        (false, _) => {
+            let reason = explain_result.reason.unwrap_or_else(|| "unknown".to_string());
+            return (Err(format!("Cannot explain this query: {}. The database type may not support EXPLAIN, or the query may be unsafe.", reason)), None);
+        }
+    };
+
+    // Execute the EXPLAIN query
+    let options = QueryExecutionOptions { max_rows: Some(100), timeout_secs: Some(30), ..Default::default() };
+    let result = match crate::query::execute_sql_statement_with_options(
+        state,
+        connection_id,
+        database,
+        &explain_sql,
+        None,
+        None,
+        options,
+    )
+    .await
+    {
+        Ok(r) => r,
+        Err(e) => return (Err(e), None),
+    };
+
+    // Serialize the raw QueryResult for the frontend ExplainPlanViewer
+    let explain_data = serde_json::to_value(&result).ok();
+    let text = match format_query_result_as_text(&result, 100) {
+        Ok(t) => t,
+        Err(e) => return (Err(e), None),
+    };
+
+    (Ok(text), explain_data)
+}
+
+/// Execute list_collections tool (vector databases).
+async fn execute_list_collections(
+    _tool_call: &ToolCall,
+    state: &Arc<AppState>,
+    connection_id: &str,
+    database: &str,
+    _db_type: &DatabaseType,
+) -> Result<String, String> {
+    let collections = crate::schema::list_vector_collections_core(state, connection_id, database)
+        .await
+        .map_err(|e| format!("Failed to list collections: {e}"))?;
+
+    if collections.is_empty() {
+        return Ok("No collections found.".to_string());
+    }
+
+    let mut lines: Vec<String> = collections
+        .iter()
+        .map(|c| {
+            let mut line = format!("- {} (COLLECTION)", c.name);
+            if let Some(dim) = c.dimension {
+                line.push_str(&format!(" -- {}d", dim));
+            }
+            line.push_str(&format!(" [id: {}]", c.id));
+            line
+        })
+        .collect();
+
+    if lines.len() > LIST_TABLES_LIMIT {
+        lines.truncate(LIST_TABLES_LIMIT);
+        lines.push(format!("... (showing {LIST_TABLES_LIMIT} of {} collections)", collections.len()));
+    }
+
+    Ok(lines.join("\n"))
+}
+
+/// Execute browse_collection tool (vector databases).
+/// Generates a database-specific REST query and executes it.
+async fn execute_browse_collection(
+    tool_call: &ToolCall,
+    state: &Arc<AppState>,
+    connection_id: &str,
+    database: &str,
+    db_type: &DatabaseType,
+) -> Result<String, String> {
+    let collection = tool_call
+        .arguments
+        .get("collection")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing required parameter: collection")?
+        .trim();
+
+    if collection.is_empty() {
+        return Err("Collection name cannot be empty".to_string());
+    }
+
+    let limit = tool_call
+        .arguments
+        .get("limit")
+        .and_then(|v| v.as_u64())
+        .map(|l| (l as usize).min(MAX_ALLOWED_ROWS))
+        .unwrap_or(BROWSE_COLLECTION_LIMIT);
+
+    // ChromaDB requires UUID in URL path, not collection name.
+    // If the collection param is already a UUID (from list_collections output), use it directly.
+    let collection_id = if *db_type == DatabaseType::ChromaDb && !is_uuid(collection) {
+        resolve_chroma_collection_uuid(state, connection_id, database, collection).await?
+    } else {
+        collection.to_string()
+    };
+
+    let query = build_browse_query(db_type, &collection_id, database, limit)?;
+
+    let options = QueryExecutionOptions { max_rows: Some(limit), timeout_secs: Some(30), ..Default::default() };
+    let result =
+        crate::query::execute_sql_statement_with_options(state, connection_id, database, &query, None, None, options)
+            .await?;
+
+    format_query_result_as_text(&result, limit)
+}
+
+/// Build a browse query for the given vector database type.
+/// Intentionally omits offset/pagination — Agent browse only fetches the first N items.
+fn build_browse_query(
+    db_type: &DatabaseType,
+    collection: &str,
+    database: &str,
+    limit: usize,
+) -> Result<String, String> {
+    let collection = collection.trim();
+    if collection.is_empty() {
+        return Err("Collection name cannot be empty".to_string());
+    }
+    let limit = limit.max(1) as u64;
+
+    match db_type {
+        DatabaseType::Qdrant => Ok(format!(
+            "POST /collections/{}/points/scroll\n{}",
+            vector_driver::path_segment(collection),
+            serde_json::json!({ "limit": limit, "with_payload": true, "with_vector": false })
+        )),
+        // Milvus v2 omitting outputFields defaults to returning only scalar fields (no vectors).
+        DatabaseType::Milvus => Ok(format!(
+            "POST /v2/vectordb/entities/query\n{}",
+            serde_json::json!({
+                "dbName": if database.is_empty() { "default" } else { database },
+                "collectionName": collection,
+                "filter": "", "limit": limit
+            })
+        )),
+        DatabaseType::Weaviate => {
+            Ok(format!("GET /v1/objects?class={}&limit={}", vector_driver::query_value(collection), limit))
+        }
+        // TODO: ChromaDB Cloud 支持自定义租户和数据库，当前只实现了本地部署
+        // （固定 default_tenant / default_database），后续支持云服务时需改为可配置。
+        DatabaseType::ChromaDb => Ok(format!(
+            "POST /api/v2/tenants/default_tenant/databases/default_database/collections/{}/get\n{}",
+            collection,
+            serde_json::json!({ "limit": limit, "include": ["documents", "metadatas"] })
+        )),
+        _ => Err(format!("Unsupported database type: {:?}", db_type)),
+    }
+}
+
+/// Check if a string looks like a UUID (simple check — 36 chars with 4 hyphens).
+fn is_uuid(s: &str) -> bool {
+    s.len() == 36
+        && s.chars().filter(|&c| c == '-').count() == 4
+        && s.chars().all(|c| c.is_ascii_hexdigit() || c == '-')
+}
+
+/// Resolve a ChromaDB collection name to its UUID by listing all collections.
+async fn resolve_chroma_collection_uuid(
+    state: &Arc<AppState>,
+    connection_id: &str,
+    database: &str,
+    name: &str,
+) -> Result<String, String> {
+    let collections = crate::schema::list_vector_collections_core(state, connection_id, database).await?;
+    collections
+        .into_iter()
+        .find(|c| c.name == name)
+        .map(|c| c.id)
+        .ok_or_else(|| format!("Collection '{name}' not found"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn vector_read_only_tools_do_not_include_collection_browsing() {
+        let tools = read_only_tools(DatabaseType::Qdrant);
+        let names: Vec<&str> = tools.iter().map(|tool| tool.name).collect();
+
+        assert_eq!(names, vec!["list_collections"]);
+    }
+
+    #[test]
+    fn vector_agent_tools_include_collection_browsing() {
+        let tools = all_tools(DatabaseType::Qdrant, AgentSqlPermissions::default());
+        let names: Vec<&str> = tools.iter().map(|tool| tool.name).collect();
+
+        assert_eq!(names, vec!["list_collections", "browse_collection"]);
+    }
+
+    #[test]
+    fn confirmed_sql_permissions_update_execute_query_contract() {
+        let tools = all_tools(DatabaseType::Mysql, AgentSqlPermissions { allow_writes: true, allow_dangerous: true });
+        let execute_query = tools.iter().find(|tool| tool.name == "execute_query").unwrap();
+
+        assert!(execute_query.description.contains("explicitly confirmed"));
+        assert!(execute_query.description.contains("DDL"));
+    }
+
+    #[test]
+    fn sql_permissions_keep_writes_blocked_until_confirmation() {
+        assert!(!sql_risk_allowed(SqlRisk::Write, AgentSqlPermissions::default()));
+        assert!(!sql_risk_allowed(SqlRisk::Ddl, AgentSqlPermissions::default()));
+        assert!(sql_risk_allowed(SqlRisk::Ddl, AgentSqlPermissions { allow_writes: true, allow_dangerous: true }));
+        assert!(!sql_risk_allowed(
+            SqlRisk::Transaction,
+            AgentSqlPermissions { allow_writes: true, allow_dangerous: true }
+        ));
+    }
+
+    #[test]
+    fn oracle_agent_tools_include_explain_query() {
+        let tools = all_tools(DatabaseType::Oracle, AgentSqlPermissions::default());
+        let names: Vec<&str> = tools.iter().map(|tool| tool.name).collect();
+
+        assert!(names.contains(&"explain_query"));
+    }
+
+    #[test]
+    fn build_browse_query_qdrant() {
+        let q = build_browse_query(&DatabaseType::Qdrant, "articles", "", 10).unwrap();
+        assert!(q.starts_with("POST /collections/articles/points/scroll"));
+        assert!(q.contains("\"limit\":10"));
+        assert!(q.contains("\"with_payload\":true"));
+    }
+
+    #[test]
+    fn build_browse_query_qdrant_encodes_url_chars() {
+        let q = build_browse_query(&DatabaseType::Qdrant, "my collection", "", 10).unwrap();
+        assert!(q.starts_with("POST /collections/my%20collection/points/scroll"));
+    }
+
+    #[test]
+    fn build_browse_query_milvus() {
+        let q = build_browse_query(&DatabaseType::Milvus, "articles", "custom_db", 20).unwrap();
+        assert!(q.starts_with("POST /v2/vectordb/entities/query"));
+        assert!(q.contains("\"dbName\":\"custom_db\""));
+        assert!(q.contains("\"collectionName\":\"articles\""));
+        assert!(q.contains("\"limit\":20"));
+        assert!(!q.contains("outputFields"));
+    }
+
+    #[test]
+    fn build_browse_query_milvus_default_db() {
+        let q = build_browse_query(&DatabaseType::Milvus, "articles", "", 10).unwrap();
+        assert!(q.contains("\"dbName\":\"default\""));
+    }
+
+    #[test]
+    fn build_browse_query_weaviate() {
+        let q = build_browse_query(&DatabaseType::Weaviate, "Articles", "", 5).unwrap();
+        assert_eq!(q, "GET /v1/objects?class=Articles&limit=5");
+    }
+
+    #[test]
+    fn build_browse_query_weaviate_encodes_query_param() {
+        let q = build_browse_query(&DatabaseType::Weaviate, "A&B", "", 5).unwrap();
+        assert!(q.contains("class=A%26B"));
+    }
+
+    #[test]
+    fn build_browse_query_chromadb() {
+        let q = build_browse_query(&DatabaseType::ChromaDb, "uuid-123", "", 15).unwrap();
+        assert!(
+            q.starts_with("POST /api/v2/tenants/default_tenant/databases/default_database/collections/uuid-123/get")
+        );
+        assert!(q.contains("\"limit\":15"));
+    }
+
+    #[test]
+    fn build_browse_query_rejects_empty_collection() {
+        let result = build_browse_query(&DatabaseType::Qdrant, "  ", "", 10);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn build_browse_query_rejects_unsupported_type() {
+        let result = build_browse_query(&DatabaseType::Postgres, "articles", "", 10);
+        assert!(result.is_err());
+    }
+}
diff --git a/crates/dbx-core/src/ai.rs b/crates/dbx-core/src/ai.rs
new file mode 100644
index 0000000..68f08a7
--- /dev/null
+++ b/crates/dbx-core/src/ai.rs
@@ -0,0 +1,3338 @@
+use crate::token_usage::TokenUsage;
+use futures::StreamExt;
+use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
+use serde::{Deserialize, Serialize};
+use serde_json::json;
+use std::collections::{HashMap, HashSet};
+use std::net::IpAddr;
+use std::path::Path;
+use std::sync::{Arc, LazyLock};
+use tokio::sync::{Notify, RwLock};
+
+// ---------------------------------------------------------------------------
+// Stream cancel registry
+// ---------------------------------------------------------------------------
+
+static AI_STREAMS: LazyLock<RwLock<HashMap<String, Arc<Notify>>>> = LazyLock::new(|| RwLock::new(HashMap::new()));
+
+pub async fn register_stream(session_id: &str) -> Arc<Notify> {
+    let notify = Arc::new(Notify::new());
+    AI_STREAMS.write().await.insert(session_id.to_string(), notify.clone());
+    notify
+}
+
+pub async fn cancel_stream(session_id: &str) -> bool {
+    if let Some(notify) = AI_STREAMS.read().await.get(session_id) {
+        notify.notify_one();
+        true
+    } else {
+        false
+    }
+}
+
+pub async fn unregister_stream(session_id: &str) {
+    AI_STREAMS.write().await.remove(session_id);
+}
+
+/// Error returned by streaming functions when the user cancels mid-stream.
+///
+/// `run_agent_loop` matches on this exact string to distinguish a cancellation
+/// from a normal completion and stop the loop cleanly. Streaming functions MUST
+/// return this (not `Ok`) when `cancelled` fires, otherwise the agent loop
+/// treats the truncated turn as a normal completion and keeps going.
+pub const AGENT_CANCELLED_ERROR: &str = "Agent loop cancelled";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum AiProvider {
+    #[serde(alias = "anthropic")]
+    Claude,
+    Openai,
+    Gemini,
+    Deepseek,
+    Qwen,
+    Ollama,
+    #[serde(rename = "openai-compatible")]
+    OpenaiCompatible,
+    #[serde(rename = "codex-cli")]
+    CodexCli,
+    Custom,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum AiApiStyle {
+    #[default]
+    Completions,
+    Responses,
+    #[serde(rename = "anthropic-messages")]
+    AnthropicMessages,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "kebab-case")]
+pub enum AiAuthMethod {
+    #[default]
+    ApiKey,
+    Bearer,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+#[serde(rename_all = "kebab-case")]
+pub enum AiReasoningLevel {
+    #[default]
+    Default,
+    Minimal,
+    Low,
+    Medium,
+    High,
+}
+
+impl AiReasoningLevel {
+    pub fn as_codex_effort(&self) -> Option<&'static str> {
+        match self {
+            AiReasoningLevel::Default => None,
+            AiReasoningLevel::Minimal => Some("minimal"),
+            AiReasoningLevel::Low => Some("low"),
+            AiReasoningLevel::Medium => Some("medium"),
+            AiReasoningLevel::High => Some("high"),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiConfig {
+    pub provider: AiProvider,
+    #[serde(default)]
+    pub api_key: String,
+    #[serde(default)]
+    pub auth_method: AiAuthMethod,
+    #[serde(default)]
+    pub endpoint: String,
+    #[serde(default)]
+    pub model: String,
+    #[serde(default)]
+    pub api_style: AiApiStyle,
+    #[serde(default)]
+    pub proxy_enabled: bool,
+    #[serde(default)]
+    pub proxy_url: String,
+    #[serde(default = "default_enable_thinking")]
+    pub enable_thinking: bool,
+    #[serde(default)]
+    pub reasoning_level: AiReasoningLevel,
+    #[serde(default)]
+    pub context_window: Option<u32>,
+    #[serde(default)]
+    pub codex_cli_path: Option<String>,
+    #[serde(default)]
+    pub codex_cli_env: HashMap<String, String>,
+}
+
+fn default_enable_thinking() -> bool {
+    true
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiMessage {
+    pub role: String,
+    pub content: String,
+    /// Tool call ID for tool results (role="tool"). Used to associate
+    /// a tool result with its originating tool call in multi-turn loops.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tool_call_id: Option<String>,
+    /// Tool calls made by the assistant (role="assistant"). Used to
+    /// reconstruct tool_use content blocks for providers like Anthropic
+    /// that require them in the conversation history.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub tool_calls: Vec<ToolCallRef>,
+}
+
+/// A lightweight reference to a tool call within an assistant message.
+/// Stores the id, name, and arguments needed to reconstruct provider-specific
+/// tool_use content blocks (e.g. Anthropic's `{"type":"tool_use", ...}`).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ToolCallRef {
+    pub id: String,
+    pub name: String,
+    pub arguments: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct AiTaskContract {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub action: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mode: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub user_request: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiCompletionRequest {
+    pub config: AiConfig,
+    pub system_prompt: String,
+    pub messages: Vec<AiMessage>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub task_contract: Option<AiTaskContract>,
+    pub max_tokens: Option<u32>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AiStreamChunk {
+    pub session_id: String,
+    pub delta: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reasoning_delta: Option<String>,
+    pub done: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiChatMessage {
+    pub role: String,
+    pub content: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub mentions: Option<serde_json::Value>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub reasoning: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub kind: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub covered_messages: Option<usize>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiConversation {
+    pub id: String,
+    pub title: String,
+    pub connection_name: String,
+    pub database: String,
+    pub messages: Vec<AiChatMessage>,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct AiModelInfo {
+    pub id: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub display_name: Option<String>,
+}
+
+/// Result of an AI connection test (mirrors CC-Switch's StreamCheckResult).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiTestConnectionResult {
+    pub success: bool,
+    pub message: String,
+    /// First-chunk latency in milliseconds, if successful.
+    pub latency_ms: Option<u64>,
+    pub model_used: String,
+    /// Error category for the frontend to render specific guidance.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error_category: Option<String>,
+}
+
+// ---------------------------------------------------------------------------
+// Pure helpers
+// ---------------------------------------------------------------------------
+
+/// Ensure the endpoint has an OpenAI API version prefix (`/v1`) when the user
+/// entered a bare origin without any path.  This handles the common mistake of
+/// entering a host like `https://api.example.com` without the `/v1` path that
+/// most OpenAI-compatible providers require.
+///
+/// Strategy (mirrors CC-Switch):
+/// 1. Already ends with `/v1` → return as-is.
+/// 2. Pure origin (no path after host) → append `/v1`.
+/// 3. Has a custom path → leave it alone (user probably knows what they're doing).
+fn ensure_openai_version_prefix(endpoint: &str) -> String {
+    let ep = endpoint.trim().trim_end_matches('/');
+    if ep.ends_with("/v1") {
+        return ep.to_string();
+    }
+    // Check whether the URL is a bare origin with no path segment.
+    let origin_only = match ep.split_once("://") {
+        Some((_scheme, rest)) => !rest.contains('/'),
+        None => !ep.contains('/'),
+    };
+    if origin_only {
+        format!("{ep}/v1")
+    } else {
+        ep.to_string()
+    }
+}
+
+fn ensure_anthropic_version_prefix(endpoint: &str) -> String {
+    let ep = endpoint.trim().trim_end_matches('/');
+    if ep.ends_with("/v1") {
+        ep.to_string()
+    } else {
+        format!("{ep}/v1")
+    }
+}
+
+pub fn resolve_endpoint(config: &AiConfig) -> String {
+    let ep = config.endpoint.trim().trim_end_matches('/');
+    if matches!(config.provider, AiProvider::Gemini) {
+        if ep.ends_with(":generateContent") || ep.ends_with(":streamGenerateContent") {
+            return ep.to_string();
+        }
+        let base = ep.trim_end_matches("/v1beta");
+        return format!("{base}/v1beta/models/{}:generateContent", config.model);
+    }
+    if ep.ends_with("/chat/completions") || ep.ends_with("/responses") || ep.ends_with("/messages") {
+        return ep.to_string();
+    }
+    if uses_anthropic_messages_api(config) {
+        let base = ensure_anthropic_version_prefix(ep);
+        return format!("{base}/messages");
+    }
+    match config.provider {
+        AiProvider::Openai
+        | AiProvider::Deepseek
+        | AiProvider::Qwen
+        | AiProvider::Ollama
+        | AiProvider::OpenaiCompatible
+        | AiProvider::Custom => {
+            let base = ensure_openai_version_prefix(ep);
+            if config.api_style == AiApiStyle::Responses {
+                format!("{base}/responses")
+            } else {
+                format!("{base}/chat/completions")
+            }
+        }
+        AiProvider::Claude | AiProvider::CodexCli | AiProvider::Gemini => unreachable!(),
+    }
+}
+
+pub fn uses_anthropic_messages_api(config: &AiConfig) -> bool {
+    matches!(config.provider, AiProvider::Claude)
+        || matches!(config.provider, AiProvider::Custom) && config.api_style == AiApiStyle::AnthropicMessages
+}
+
+fn resolve_gemini_stream_endpoint(config: &AiConfig) -> String {
+    let endpoint = resolve_endpoint(config);
+    if endpoint.ends_with(":streamGenerateContent") {
+        endpoint
+    } else {
+        endpoint.replace(":generateContent", ":streamGenerateContent")
+    }
+}
+
+pub fn resolve_model_list_endpoint(config: &AiConfig) -> Result<String, String> {
+    if matches!(config.provider, AiProvider::Gemini) {
+        return Err("Model listing is only supported for OpenAI-compatible and Claude providers".to_string());
+    }
+
+    let ep = config.endpoint.trim().trim_end_matches('/');
+    if ep.is_empty() {
+        return Err("Endpoint is required".to_string());
+    }
+    if ep.ends_with("/models") {
+        return Ok(ep.to_string());
+    }
+
+    let base = ep
+        .strip_suffix("/chat/completions")
+        .or_else(|| ep.strip_suffix("/responses"))
+        .or_else(|| ep.strip_suffix("/messages"))
+        .unwrap_or(ep)
+        .trim_end_matches('/');
+
+    if uses_anthropic_messages_api(config) {
+        let base = ensure_anthropic_version_prefix(base);
+        return Ok(format!("{base}/models"));
+    }
+
+    let base = ensure_openai_version_prefix(base);
+
+    Ok(format!("{base}/models"))
+}
+
+pub fn stream_data_payload(line: &str) -> Option<&str> {
+    let line = line.trim();
+    if line.is_empty() || line.starts_with(':') || line.starts_with("event:") || line.starts_with("id:") {
+        return None;
+    }
+    if let Some(data) = line.strip_prefix("data:") {
+        return Some(data.trim_start());
+    }
+    if line.starts_with('{') {
+        return Some(line);
+    }
+    None
+}
+
+fn drain_next_stream_line(buffer: &mut Vec<u8>) -> Result<Option<String>, String> {
+    let Some(pos) = buffer.iter().position(|byte| *byte == b'\n') else {
+        return Ok(None);
+    };
+    let mut line = buffer.drain(..=pos).collect::<Vec<u8>>();
+    if line.last() == Some(&b'\n') {
+        line.pop();
+    }
+    String::from_utf8(line).map(Some).map_err(|e| format!("AI stream returned invalid UTF-8: {e}"))
+}
+
+pub fn claude_stream_text(event: &serde_json::Value) -> Option<&str> {
+    if event["type"] == "content_block_delta" {
+        return event["delta"]["text"].as_str();
+    }
+    None
+}
+
+fn text_from_content_value(value: &serde_json::Value) -> Option<String> {
+    if let Some(text) = value.as_str().filter(|text| !text.is_empty()) {
+        return Some(text.to_string());
+    }
+
+    value.as_array().and_then(|parts| {
+        let text = parts
+            .iter()
+            .filter_map(|part| {
+                part["text"]
+                    .as_str()
+                    .or_else(|| part["content"].as_str())
+                    .or_else(|| part["input_text"].as_str())
+                    .or_else(|| part["output_text"].as_str())
+            })
+            .collect::<Vec<_>>()
+            .join("");
+        (!text.is_empty()).then_some(text)
+    })
+}
+
+pub fn openai_response_text(data: &serde_json::Value) -> String {
+    data["choices"]
+        .get(0)
+        .and_then(|choice| {
+            text_from_content_value(&choice["message"]["content"])
+                .or_else(|| text_from_content_value(&choice["text"]))
+                .or_else(|| text_from_content_value(&choice["delta"]["content"]))
+        })
+        .or_else(|| text_from_content_value(&data["content"]))
+        .or_else(|| {
+            let text = responses_text(data);
+            (!text.is_empty()).then_some(text)
+        })
+        .unwrap_or_default()
+}
+
+pub fn openai_stream_text(event: &serde_json::Value) -> Option<String> {
+    event["choices"]
+        .get(0)
+        .and_then(|choice| {
+            text_from_content_value(&choice["delta"]["content"])
+                .or_else(|| text_from_content_value(&choice["message"]["content"]))
+                .or_else(|| text_from_content_value(&choice["text"]))
+        })
+        .or_else(|| text_from_content_value(&event["content"]))
+        .or_else(|| event["delta"].as_str().filter(|text| !text.is_empty()).map(ToString::to_string))
+}
+
+pub fn openai_stream_reasoning(event: &serde_json::Value) -> Option<&str> {
+    event["choices"]
+        .get(0)
+        .and_then(|choice| {
+            choice["delta"]["reasoning_content"]
+                .as_str()
+                .or_else(|| choice["delta"]["reasoning"].as_str())
+                .or_else(|| choice["delta"]["thinking"].as_str())
+        })
+        .filter(|text| !text.is_empty())
+}
+
+pub fn responses_stream_text(event: &serde_json::Value) -> Option<&str> {
+    let event_type = event["type"].as_str().unwrap_or_default();
+    if !event_type.is_empty() && event_type != "response.output_text.delta" {
+        return None;
+    }
+
+    event["delta"].as_str().filter(|s| !s.is_empty())
+}
+
+fn responses_max_output_tokens(max_tokens: Option<u32>) -> u32 {
+    max_tokens.unwrap_or(2048).max(16)
+}
+
+fn responses_token_usage(event: &serde_json::Value) -> Option<TokenUsage> {
+    let usage = event.get("usage").or_else(|| event.get("response").and_then(|response| response.get("usage")))?;
+    let input = usage.get("input_tokens").and_then(|v| v.as_u64())?;
+    let output = usage.get("output_tokens").and_then(|v| v.as_u64())?;
+    Some(TokenUsage { input_tokens: input as u32, output_tokens: output as u32 })
+}
+
+fn is_openai_api_endpoint(endpoint: &str) -> bool {
+    reqwest::Url::parse(endpoint)
+        .ok()
+        .and_then(|url| url.host_str().map(|host| host.eq_ignore_ascii_case("api.openai.com")))
+        .unwrap_or(false)
+}
+
+fn is_openai_api_config(config: &AiConfig) -> bool {
+    // OpenAI provider can be routed through a custom proxy while still requiring OpenAI request semantics.
+    matches!(config.provider, AiProvider::Openai) || is_openai_api_endpoint(&config.endpoint)
+}
+
+fn is_openai_reasoning_model(model: &str) -> bool {
+    let model = model.trim().to_ascii_lowercase();
+    model.starts_with("gpt-5") || model.starts_with("o1") || model.starts_with("o3") || model.starts_with("o4")
+}
+
+fn uses_openai_max_completion_tokens(config: &AiConfig) -> bool {
+    is_openai_api_config(config) && is_openai_reasoning_model(&config.model)
+}
+
+fn set_chat_completion_token_limit(body: &mut serde_json::Value, config: &AiConfig, max_tokens: u32) {
+    if uses_openai_max_completion_tokens(config) {
+        body["max_completion_tokens"] = json!(max_tokens);
+    } else {
+        body["max_tokens"] = json!(max_tokens);
+    }
+}
+
+/// Kimi K2.5+ models (including K2.7-Code) handle thinking flags differently
+/// and reject the OpenAI-compatible `extra_body.chat_template_kwargs` toggle.
+///
+/// Matches `kimi-k2.5`, `kimi-k2.6`, `kimi-k2.7-code`, K3+, and future versions,
+/// while excluding older K2 variants (`kimi-k2`, `kimi-k2-thinking`, etc.).
+/// Regex equivalent: /kimi-k(?:2\.[5-9]\d*|[3-9]\d*)/
+fn is_kimi_model(model: &str) -> bool {
+    let model = model.trim().to_ascii_lowercase();
+    if let Some(rest) = model.strip_prefix("kimi-k") {
+        if rest.starts_with("2.") && rest.len() > 2 {
+            // K2.x — the digit after "2." must be >= 5 (so K2.5+)
+            rest[2..].chars().next().is_some_and(|c| c.is_ascii_digit() && c >= '5')
+        } else {
+            // K3+ — first char must be digit >= 3
+            rest.chars().next().is_some_and(|c| c.is_ascii_digit() && c >= '3')
+        }
+    } else {
+        false
+    }
+}
+
+fn apply_chat_completion_thinking_toggle(body: &mut serde_json::Value, config: &AiConfig) {
+    if config.enable_thinking {
+        return;
+    }
+
+    if matches!(config.provider, AiProvider::Ollama) {
+        // Ollama's OpenAI-compatible API uses reasoning_effort instead of
+        // forwarding provider-specific chat template arguments.
+        body["reasoning_effort"] = json!("none");
+    } else if !is_kimi_model(&config.model) {
+        body["extra_body"] = json!({
+            "chat_template_kwargs": { "enable_thinking": false }
+        });
+    }
+}
+
+fn responses_text(data: &serde_json::Value) -> String {
+    if let Some(text) = data["output_text"].as_str().filter(|text| !text.is_empty()) {
+        return text.to_string();
+    }
+
+    data["output"]
+        .as_array()
+        .and_then(|items| {
+            items.iter().find_map(|item| {
+                item["content"].as_array().and_then(|parts| parts.iter().find_map(|p| p["text"].as_str()))
+            })
+        })
+        .unwrap_or_default()
+        .to_string()
+}
+
+pub fn gemini_text(data: &serde_json::Value) -> String {
+    data["candidates"]
+        .get(0)
+        .and_then(|candidate| candidate["content"]["parts"].as_array())
+        .map(|parts| parts.iter().filter_map(|part| part["text"].as_str()).collect::<Vec<_>>().join(""))
+        .unwrap_or_default()
+}
+
+pub fn extract_error(data: &serde_json::Value) -> Option<String> {
+    data["error"]["message"].as_str().or_else(|| data["error"].as_str()).map(ToString::to_string)
+}
+
+pub fn build_responses_input(system_prompt: &str, messages: &[AiMessage]) -> serde_json::Value {
+    let mut input = Vec::new();
+    if !system_prompt.is_empty() {
+        input.push(json!({
+            "role": "developer",
+            "content": system_prompt,
+        }));
+    }
+    for m in messages {
+        input.push(json!({
+            "role": m.role,
+            "content": m.content,
+        }));
+    }
+    json!(input)
+}
+
+fn build_responses_input_with_tools(system_prompt: &str, messages: &[AiMessage]) -> serde_json::Value {
+    let mut input = Vec::new();
+    if !system_prompt.is_empty() {
+        input.push(json!({
+            "role": "developer",
+            "content": system_prompt,
+        }));
+    }
+
+    for message in messages {
+        if message.role == "tool" {
+            input.push(json!({
+                "type": "function_call_output",
+                "call_id": message.tool_call_id.as_deref().unwrap_or_default(),
+                "output": message.content,
+            }));
+            continue;
+        }
+
+        if message.role == "assistant" && !message.tool_calls.is_empty() {
+            if !message.content.is_empty() {
+                input.push(json!({
+                    "role": "assistant",
+                    "content": message.content,
+                }));
+            }
+            for tool_call in &message.tool_calls {
+                input.push(json!({
+                    "type": "function_call",
+                    "call_id": tool_call.id,
+                    "name": tool_call.name,
+                    "arguments": tool_call.arguments.to_string(),
+                }));
+            }
+            continue;
+        }
+
+        input.push(json!({
+            "role": message.role,
+            "content": message.content,
+        }));
+    }
+
+    json!(input)
+}
+
+fn responses_function_tool(tool: &crate::agent_events::ToolDefinition) -> serde_json::Value {
+    json!({
+        "type": "function",
+        "name": tool.name,
+        "description": tool.description,
+        "parameters": tool.parameters,
+    })
+}
+
+fn responses_tool_index(
+    event: &serde_json::Value,
+    item_indices: &mut HashMap<String, u32>,
+    next_index: &mut u32,
+) -> (String, u32) {
+    let item = &event["item"];
+    let item_id = item["id"]
+        .as_str()
+        .or_else(|| event["item_id"].as_str())
+        .map(ToString::to_string)
+        .unwrap_or_else(|| format!("responses-tool-{next_index}"));
+    let index = item_indices.get(&item_id).copied().unwrap_or_else(|| {
+        let index = event["output_index"].as_u64().map(|i| i as u32).unwrap_or(*next_index);
+        *next_index = (*next_index).max(index + 1);
+        item_indices.insert(item_id.clone(), index);
+        index
+    });
+    (item_id, index)
+}
+
+fn emit_responses_function_call_item(
+    event: &serde_json::Value,
+    item_indices: &mut HashMap<String, u32>,
+    started_indices: &mut HashSet<u32>,
+    argument_indices: &mut HashSet<u32>,
+    next_index: &mut u32,
+    on_event: &impl Fn(StreamToolEvent),
+) -> Option<u32> {
+    let item = &event["item"];
+    if item["type"].as_str() != Some("function_call") {
+        return None;
+    }
+
+    let (_item_id, index) = responses_tool_index(event, item_indices, next_index);
+    if started_indices.insert(index) {
+        let id = item["call_id"].as_str().or_else(|| item["id"].as_str()).unwrap_or_default().to_string();
+        let name = item["name"].as_str().unwrap_or_default().to_string();
+        on_event(StreamToolEvent::ToolCallStart { index, id, name });
+    }
+
+    if !argument_indices.contains(&index) {
+        if let Some(arguments) = item["arguments"].as_str().filter(|s| !s.is_empty()) {
+            argument_indices.insert(index);
+            on_event(StreamToolEvent::ToolCallDelta { index, fragment: arguments.to_string() });
+        }
+    }
+
+    Some(index)
+}
+
+// ---------------------------------------------------------------------------
+// Validation helper
+// ---------------------------------------------------------------------------
+
+fn validate_config(config: &AiConfig) -> Result<(), String> {
+    if matches!(config.provider, AiProvider::CodexCli) {
+        return Ok(());
+    }
+    if !matches!(config.provider, AiProvider::Ollama) && config.api_key.trim().is_empty() {
+        return Err("API key is required".to_string());
+    }
+    if config.endpoint.trim().is_empty() {
+        return Err("Endpoint is required".to_string());
+    }
+    if config.model.trim().is_empty() {
+        return Err("Model is required".to_string());
+    }
+    Ok(())
+}
+
+fn validate_model_list_config(config: &AiConfig) -> Result<(), String> {
+    if matches!(config.provider, AiProvider::CodexCli) {
+        return Ok(());
+    }
+    if !matches!(config.provider, AiProvider::Ollama) && config.api_key.trim().is_empty() {
+        return Err("API key is required".to_string());
+    }
+    resolve_model_list_endpoint(config).map(|_| ())
+}
+
+pub fn maybe_bearer_headers(config: &AiConfig) -> Result<HeaderMap, String> {
+    let mut headers = HeaderMap::new();
+    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+    if !config.api_key.trim().is_empty() {
+        headers.insert(
+            AUTHORIZATION,
+            HeaderValue::from_str(&format!("Bearer {}", config.api_key)).map_err(|e| e.to_string())?,
+        );
+    }
+    Ok(headers)
+}
+
+pub fn claude_headers(config: &AiConfig) -> Result<HeaderMap, String> {
+    let mut headers = HeaderMap::new();
+    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+    match config.auth_method {
+        AiAuthMethod::Bearer => {
+            headers.insert(
+                AUTHORIZATION,
+                HeaderValue::from_str(&format!("Bearer {}", config.api_key)).map_err(|e| e.to_string())?,
+            );
+        }
+        AiAuthMethod::ApiKey => {
+            headers.insert("x-api-key", HeaderValue::from_str(&config.api_key).map_err(|e| e.to_string())?);
+        }
+    }
+    headers.insert("anthropic-version", HeaderValue::from_static("2023-06-01"));
+    Ok(headers)
+}
+
+fn normalize_ai_proxy_url(proxy_url: &str) -> String {
+    let proxy_url = proxy_url.trim();
+    if proxy_url.contains("://") || proxy_url.is_empty() {
+        proxy_url.to_string()
+    } else {
+        format!("http://{proxy_url}")
+    }
+}
+
+fn ai_endpoint_is_loopback(config: &AiConfig) -> bool {
+    let endpoint = resolve_endpoint(config);
+    let Ok(url) = reqwest::Url::parse(&endpoint) else {
+        return false;
+    };
+    let Some(host) = url.host_str() else {
+        return false;
+    };
+    host.eq_ignore_ascii_case("localhost") || host.parse::<IpAddr>().map(|addr| addr.is_loopback()).unwrap_or(false)
+}
+
+pub fn build_ai_http_client(config: &AiConfig, timeout_secs: u64) -> Result<reqwest::Client, String> {
+    let mut builder = reqwest::Client::builder().timeout(std::time::Duration::from_secs(timeout_secs));
+    if config.proxy_enabled && !config.proxy_url.trim().is_empty() && !ai_endpoint_is_loopback(config) {
+        let proxy_url = normalize_ai_proxy_url(&config.proxy_url);
+        let proxy = reqwest::Proxy::all(&proxy_url).map_err(|e| format!("Invalid AI proxy URL: {e}"))?;
+        builder = builder.proxy(proxy);
+    }
+    builder.build().map_err(|e| e.to_string())
+}
+
+// ---------------------------------------------------------------------------
+// Model listing
+// ---------------------------------------------------------------------------
+
+fn parse_model_list_response(data: &serde_json::Value) -> Result<Vec<AiModelInfo>, String> {
+    let items = data["data"].as_array().ok_or_else(|| "Invalid model list response".to_string())?;
+    let mut seen = HashSet::new();
+    let mut models = Vec::new();
+
+    for item in items {
+        let Some(id) = item["id"].as_str().filter(|id| !id.trim().is_empty()) else {
+            continue;
+        };
+        if !seen.insert(id.to_string()) {
+            continue;
+        }
+
+        let display_name = item["display_name"]
+            .as_str()
+            .or_else(|| item["name"].as_str())
+            .filter(|name| !name.trim().is_empty() && *name != id)
+            .map(ToString::to_string);
+
+        models.push(AiModelInfo { id: id.to_string(), display_name });
+    }
+
+    Ok(models)
+}
+
+async fn list_claude_models(client: &reqwest::Client, config: &AiConfig) -> Result<Vec<AiModelInfo>, String> {
+    let res = client
+        .get(resolve_model_list_endpoint(config)?)
+        .headers(claude_headers(config)?)
+        .send()
+        .await
+        .map_err(|e| format!("Claude model list request failed: {e}"))?;
+
+    let status = res.status();
+    let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+    if !status.is_success() {
+        return Err(extract_error(&data).unwrap_or_else(|| format!("Claude model list API error: {status}")));
+    }
+
+    parse_model_list_response(&data)
+}
+
+async fn list_openai_compatible_models(
+    client: &reqwest::Client,
+    config: &AiConfig,
+) -> Result<Vec<AiModelInfo>, String> {
+    let res = client
+        .get(resolve_model_list_endpoint(config)?)
+        .headers(maybe_bearer_headers(config)?)
+        .send()
+        .await
+        .map_err(|e| format!("AI model list request failed: {e}"))?;
+
+    let status = res.status();
+    let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+    if !status.is_success() {
+        return Err(extract_error(&data).unwrap_or_else(|| format!("Model list API error: {status}")));
+    }
+
+    parse_model_list_response(&data)
+}
+
+pub async fn list_models_core(config: &AiConfig) -> Result<Vec<AiModelInfo>, String> {
+    if matches!(config.provider, AiProvider::CodexCli) {
+        return crate::ai_codex_cli::list_codex_models(config).await;
+    }
+    validate_model_list_config(config)?;
+
+    let client = build_ai_http_client(config, 30)?;
+
+    match config.provider {
+        AiProvider::Claude => list_claude_models(&client, config).await,
+        AiProvider::Openai
+        | AiProvider::Deepseek
+        | AiProvider::Qwen
+        | AiProvider::Ollama
+        | AiProvider::OpenaiCompatible => list_openai_compatible_models(&client, config).await,
+        AiProvider::Custom => {
+            if uses_anthropic_messages_api(config) {
+                list_claude_models(&client, config).await
+            } else {
+                list_openai_compatible_models(&client, config).await
+            }
+        }
+        AiProvider::CodexCli => unreachable!(),
+        AiProvider::Gemini => {
+            Err("Model listing is only supported for OpenAI-compatible and Claude providers".to_string())
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Non-streaming calls
+// ---------------------------------------------------------------------------
+
+pub async fn call_claude(client: &reqwest::Client, request: AiCompletionRequest) -> Result<String, String> {
+    let body = json!({
+        "model": request.config.model,
+        "max_tokens": request.max_tokens.unwrap_or(2048),
+        "system": claude_system_prompt(&request.system_prompt),
+        "messages": request.messages,
+    });
+
+    let res = client
+        .post(resolve_endpoint(&request.config))
+        .headers(claude_headers(&request.config)?)
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("Claude request failed: {e}"))?;
+
+    let status = res.status();
+    let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+    if !status.is_success() {
+        return Err(extract_error(&data).unwrap_or_else(|| format!("Claude API error: {status}")));
+    }
+
+    Ok(data["content"]
+        .as_array()
+        .and_then(|items| items.iter().find_map(|item| item["text"].as_str()))
+        .unwrap_or_default()
+        .to_string())
+}
+
+pub async fn call_openai_compatible(client: &reqwest::Client, request: AiCompletionRequest) -> Result<String, String> {
+    let headers = maybe_bearer_headers(&request.config)?;
+
+    let mut messages = vec![json!({ "role": "system", "content": request.system_prompt })];
+    messages.extend(request.messages.iter().map(|message| json!({ "role": message.role, "content": message.content })));
+
+    let mut body_obj = json!({
+        "model": request.config.model,
+        "messages": messages,
+    });
+    set_chat_completion_token_limit(&mut body_obj, &request.config, request.max_tokens.unwrap_or(2048));
+    apply_chat_completion_thinking_toggle(&mut body_obj, &request.config);
+
+    let res = client
+        .post(resolve_endpoint(&request.config))
+        .headers(headers)
+        .json(&body_obj)
+        .send()
+        .await
+        .map_err(|e| format!("AI request failed: {e}"))?;
+
+    let status = res.status();
+    let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+    if !status.is_success() {
+        return Err(extract_error(&data).unwrap_or_else(|| format!("API error: {status}")));
+    }
+
+    Ok(openai_response_text(&data))
+}
+
+pub async fn call_responses_api(client: &reqwest::Client, request: AiCompletionRequest) -> Result<String, String> {
+    let headers = maybe_bearer_headers(&request.config)?;
+
+    let body = json!({
+        "model": request.config.model,
+        "input": build_responses_input(&request.system_prompt, &request.messages),
+        "max_output_tokens": responses_max_output_tokens(request.max_tokens),
+    });
+
+    let res = client
+        .post(resolve_endpoint(&request.config))
+        .headers(headers)
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("AI request failed: {e}"))?;
+
+    let status = res.status();
+    let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+    if !status.is_success() {
+        return Err(extract_error(&data).unwrap_or_else(|| format!("API error: {status}")));
+    }
+
+    Ok(responses_text(&data))
+}
+
+pub async fn call_gemini(client: &reqwest::Client, request: AiCompletionRequest) -> Result<String, String> {
+    let mut contents = Vec::new();
+    for message in &request.messages {
+        let role = if message.role == "assistant" { "model" } else { "user" };
+        contents.push(json!({
+            "role": role,
+            "parts": [{ "text": message.content }],
+        }));
+    }
+
+    let body = json!({
+        "systemInstruction": {
+            "parts": [{ "text": request.system_prompt }],
+        },
+        "contents": contents,
+        "generationConfig": {
+            "maxOutputTokens": request.max_tokens.unwrap_or(2048),
+        },
+    });
+
+    let res = client
+        .post(resolve_endpoint(&request.config))
+        .query(&[("key", request.config.api_key.as_str())])
+        .header(CONTENT_TYPE, "application/json")
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("Gemini request failed: {e}"))?;
+
+    let status = res.status();
+    let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+    if !status.is_success() {
+        return Err(extract_error(&data).unwrap_or_else(|| format!("Gemini API error: {status}")));
+    }
+
+    Ok(gemini_text(&data))
+}
+
+// ---------------------------------------------------------------------------
+// High-level: test_connection_core / complete
+// ---------------------------------------------------------------------------
+
+/// Read the SSE byte stream until the first content-bearing chunk arrives,
+/// then return its latency and the delta text.  Used by `test_connection_core`
+/// to mirror CC-Switch's streaming probe approach.
+async fn measure_first_stream_chunk(
+    mut byte_stream: impl futures::Stream<Item = Result<bytes::Bytes, reqwest::Error>> + Unpin,
+    start: std::time::Instant,
+    is_claude: bool,
+    is_gemini: bool,
+) -> Result<(u64, String), String> {
+    let mut buf = Vec::new();
+    while let Some(chunk) = byte_stream.next().await {
+        let chunk = chunk.map_err(|e| format!("stream read error: {e}"))?;
+        buf.extend_from_slice(&chunk);
+
+        while let Some(line) = drain_next_stream_line(&mut buf)? {
+            let Some(data) = stream_data_payload(&line) else { continue };
+            if data == "[DONE]" {
+                // stream finished without content — not a real failure but rare
+                return Err("no content in response".to_string());
+            }
+
+            // Parse the JSON to extract the text delta
+            let parsed: serde_json::Value = serde_json::from_str(data).map_err(|e| format!("JSON parse error: {e}"))?;
+
+            let delta = if is_claude {
+                // Accept both text and thinking deltas — thinking is often the first
+                // streamed content when extended thinking is enabled.
+                claude_stream_text(&parsed).or_else(|| parsed["delta"]["thinking"].as_str()).map(|s| s.to_string())
+            } else if is_gemini {
+                let text = gemini_text(&parsed);
+                if text.is_empty() {
+                    None
+                } else {
+                    Some(text)
+                }
+            } else {
+                // Accept text, reasoning, or responses content as the first chunk.
+                openai_stream_text(&parsed)
+                    .or_else(|| openai_stream_reasoning(&parsed).map(|s| s.to_string()))
+                    .or_else(|| Some(responses_text(&parsed)))
+            };
+
+            if let Some(text) = delta {
+                if !text.trim().is_empty() {
+                    let latency = start.elapsed().as_millis() as u64;
+                    return Ok((latency, text));
+                }
+            }
+        }
+    }
+    Err("stream ended without content".to_string())
+}
+
+const TEST_PROMPT: &str = "Who are you?";
+
+/// Fallback system prompt for the Anthropic (Claude) API.
+///
+/// Anthropic rejects requests whose `system` field is an empty string with
+/// `system: text content blocks must be non-empty`. When the caller has no
+/// system prompt we send this minimal placeholder so the request stays valid.
+const CLAUDE_DEFAULT_SYSTEM: &str = "You are a helpful assistant.";
+
+/// Returns a non-empty system prompt for Claude requests, substituting a
+/// default when the provided prompt is empty or whitespace-only.
+fn claude_system_prompt(system_prompt: &str) -> &str {
+    if system_prompt.trim().is_empty() {
+        CLAUDE_DEFAULT_SYSTEM
+    } else {
+        system_prompt
+    }
+}
+
+pub async fn test_connection_core(config: &AiConfig) -> Result<AiTestConnectionResult, String> {
+    if matches!(config.provider, AiProvider::CodexCli) {
+        return crate::ai_codex_cli::test_codex_connection(config).await;
+    }
+    validate_config(config)?;
+
+    let client = build_ai_http_client(config, 15)?;
+    let start = std::time::Instant::now();
+
+    let is_claude = uses_anthropic_messages_api(config);
+    let is_gemini = matches!(config.provider, AiProvider::Gemini);
+    let model = config.model.clone();
+
+    // Build the streaming request and get the byte stream
+    let byte_stream = match config.provider {
+        AiProvider::Claude => {
+            let body = json!({
+                "model": &model,
+                "max_tokens": 16,
+                "system": CLAUDE_DEFAULT_SYSTEM,
+                "messages": [{ "role": "user", "content": TEST_PROMPT }],
+                "stream": true,
+            });
+            let res = client
+                .post(resolve_endpoint(config))
+                .headers(claude_headers(config)?)
+                .json(&body)
+                .send()
+                .await
+                .map_err(|e| format!("Claude request failed: {e}"))?;
+            if !res.status().is_success() {
+                let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+                return Err(categorize_error(&data, config));
+            }
+            res.bytes_stream()
+        }
+        AiProvider::Gemini => {
+            // Gemini only returns SSE from streamGenerateContent; generateContent
+            // returns one JSON document even when alt=sse is supplied.
+            let ep = resolve_gemini_stream_endpoint(config);
+            let res = client
+                .post(&ep)
+                .header(CONTENT_TYPE, "application/json")
+                .query(&[("key", config.api_key.as_str()), ("alt", "sse")])
+                .json(&json!({
+                    "contents": [{ "parts": [{ "text": TEST_PROMPT }], "role": "user" }],
+                    "generationConfig": { "maxOutputTokens": 16 },
+                }))
+                .send()
+                .await
+                .map_err(|e| format!("Gemini request failed: {e}"))?;
+            if !res.status().is_success() {
+                let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+                return Err(categorize_error(&data, config));
+            }
+            res.bytes_stream()
+        }
+        AiProvider::Custom if uses_anthropic_messages_api(config) => {
+            let body = json!({
+                "model": &model,
+                "max_tokens": 16,
+                "system": CLAUDE_DEFAULT_SYSTEM,
+                "messages": [{ "role": "user", "content": TEST_PROMPT }],
+                "stream": true,
+            });
+            let res = client
+                .post(resolve_endpoint(config))
+                .headers(claude_headers(config)?)
+                .json(&body)
+                .send()
+                .await
+                .map_err(|e| format!("Claude request failed: {e}"))?;
+            if !res.status().is_success() {
+                let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+                return Err(categorize_error(&data, config));
+            }
+            res.bytes_stream()
+        }
+        _ => {
+            // OpenAI-compatible providers
+            let mut body_obj = if config.api_style == AiApiStyle::Responses {
+                json!({
+                    "model": &model,
+                    "input": [{ "role": "user", "content": TEST_PROMPT }],
+                    "max_output_tokens": 16,
+                    "stream": true,
+                })
+            } else {
+                let messages = vec![json!({ "role": "user", "content": TEST_PROMPT })];
+                let mut body = json!({
+                    "model": &model,
+                    "messages": messages,
+                    "stream": true,
+                });
+                set_chat_completion_token_limit(&mut body, config, 16);
+                body
+            };
+            if config.api_style != AiApiStyle::Responses {
+                apply_chat_completion_thinking_toggle(&mut body_obj, config);
+            }
+            let ep = resolve_endpoint(config);
+            let res = client
+                .post(&ep)
+                .headers(maybe_bearer_headers(config)?)
+                .json(&body_obj)
+                .send()
+                .await
+                .map_err(|e| format!("AI request failed: {e}"))?;
+            if !res.status().is_success() {
+                let status = res.status();
+                let body = res.text().await.unwrap_or_default();
+                // Try JSON first (APIs like OpenAI return structured error bodies)
+                if let Ok(data) = serde_json::from_str::<serde_json::Value>(&body) {
+                    let raw = extract_error(&data).unwrap_or_else(|| "API error".to_string());
+                    return Err(format!("[{}] {}", classify_error(&raw), raw));
+                }
+                // Non-JSON body — show HTTP status + raw body
+                let msg = if body.trim().is_empty() {
+                    format!("HTTP {}", status)
+                } else {
+                    format!("HTTP {}: {}", status, body.trim())
+                };
+                return Err(format!("[{}] {}", classify_error(&msg), msg));
+            }
+            res.bytes_stream()
+        }
+    };
+
+    match measure_first_stream_chunk(byte_stream, start, is_claude, is_gemini).await {
+        Ok((latency, _delta)) => Ok(AiTestConnectionResult {
+            success: true,
+            message: format!("OK — {}ms", latency),
+            latency_ms: Some(latency),
+            model_used: model,
+            error_category: None,
+        }),
+        Err(e) => {
+            let category = classify_error(&e);
+            Err(format!("[{category}] {e}"))
+        }
+    }
+}
+
+/// Map known API error bodies to a short category string.
+fn categorize_error(data: &serde_json::Value, _config: &AiConfig) -> String {
+    let raw = extract_error(data).unwrap_or_else(|| "API error".to_string());
+    let category = classify_error(&raw);
+    format!("[{category}] {raw}")
+}
+
+fn classify_error(msg: &str) -> &'static str {
+    let lower = msg.to_ascii_lowercase();
+    if lower.contains("401")
+        || lower.contains("unauthorized")
+        || lower.contains("invalid api key")
+        || lower.contains("incorrect api key")
+    {
+        "auth"
+    } else if lower.contains("404") || lower.contains("not found") || lower.contains("model not found") {
+        "modelNotFound"
+    } else if lower.contains("429") || lower.contains("rate limit") || lower.contains("too many requests") {
+        "rateLimit"
+    } else if lower.contains("timeout") || lower.contains("timed out") || lower.contains("504") {
+        "timeout"
+    } else if lower.contains("connect")
+        || lower.contains("dns")
+        || lower.contains("resolve")
+        || lower.contains("502")
+        || lower.contains("503")
+    {
+        "network"
+    } else {
+        "unknown"
+    }
+}
+
+pub async fn complete(request: &AiCompletionRequest) -> Result<String, String> {
+    validate_config(&request.config)?;
+
+    if matches!(request.config.provider, AiProvider::CodexCli) {
+        return Err("Codex CLI provider is only supported in DBX AI agent mode".to_string());
+    }
+
+    let client = build_ai_http_client(&request.config, 60)?;
+
+    match request.config.provider {
+        AiProvider::Claude => call_claude(&client, request.clone()).await,
+        AiProvider::Gemini => call_gemini(&client, request.clone()).await,
+        AiProvider::CodexCli => unreachable!(),
+        AiProvider::Openai
+        | AiProvider::Deepseek
+        | AiProvider::Qwen
+        | AiProvider::Ollama
+        | AiProvider::OpenaiCompatible => {
+            if request.config.api_style == AiApiStyle::Responses {
+                call_responses_api(&client, request.clone()).await
+            } else {
+                call_openai_compatible(&client, request.clone()).await
+            }
+        }
+        AiProvider::Custom => {
+            if uses_anthropic_messages_api(&request.config) {
+                call_claude(&client, request.clone()).await
+            } else if request.config.api_style == AiApiStyle::Responses {
+                call_responses_api(&client, request.clone()).await
+            } else {
+                call_openai_compatible(&client, request.clone()).await
+            }
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Streaming
+// ---------------------------------------------------------------------------
+
+pub async fn stream(
+    session_id: &str,
+    request: &AiCompletionRequest,
+    cancelled: &Notify,
+    on_chunk: impl Fn(AiStreamChunk),
+) -> Result<(), String> {
+    validate_config(&request.config)?;
+
+    if matches!(request.config.provider, AiProvider::CodexCli) {
+        return Err("Codex CLI provider is only supported in DBX AI agent mode".to_string());
+    }
+
+    let stream_timeout = if request.config.enable_thinking { 600 } else { 120 };
+    let client = build_ai_http_client(&request.config, stream_timeout)?;
+
+    match request.config.provider {
+        AiProvider::Claude => stream_claude(&client, session_id, request, cancelled, &on_chunk).await,
+        AiProvider::Gemini => stream_gemini(&client, session_id, request, cancelled, &on_chunk).await,
+        AiProvider::CodexCli => unreachable!(),
+        AiProvider::Openai
+        | AiProvider::Deepseek
+        | AiProvider::Qwen
+        | AiProvider::Ollama
+        | AiProvider::OpenaiCompatible => {
+            if request.config.api_style == AiApiStyle::Responses {
+                stream_responses_api(&client, session_id, request, cancelled, &on_chunk).await
+            } else {
+                stream_openai(&client, session_id, request, cancelled, &on_chunk).await
+            }
+        }
+        AiProvider::Custom => {
+            if uses_anthropic_messages_api(&request.config) {
+                stream_claude(&client, session_id, request, cancelled, &on_chunk).await
+            } else if request.config.api_style == AiApiStyle::Responses {
+                stream_responses_api(&client, session_id, request, cancelled, &on_chunk).await
+            } else {
+                stream_openai(&client, session_id, request, cancelled, &on_chunk).await
+            }
+        }
+    }
+}
+
+async fn stream_claude(
+    client: &reqwest::Client,
+    session_id: &str,
+    request: &AiCompletionRequest,
+    cancelled: &Notify,
+    on_chunk: &impl Fn(AiStreamChunk),
+) -> Result<(), String> {
+    let body = json!({
+        "model": request.config.model,
+        "max_tokens": request.max_tokens.unwrap_or(2048),
+        "system": claude_system_prompt(&request.system_prompt),
+        "messages": request.messages,
+        "stream": true,
+    });
+
+    let res = client
+        .post(resolve_endpoint(&request.config))
+        .headers(claude_headers(&request.config)?)
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("Claude request failed: {e}"))?;
+
+    if !res.status().is_success() {
+        let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+        return Err(extract_error(&data).unwrap_or_else(|| "Claude API error".to_string()));
+    }
+
+    let mut byte_stream = res.bytes_stream();
+    let mut buf = Vec::new();
+
+    loop {
+        tokio::select! {
+            chunk = byte_stream.next() => {
+                let Some(chunk) = chunk else { break };
+                let chunk = chunk.map_err(|e| e.to_string())?;
+                buf.extend_from_slice(&chunk);
+
+                let mut finished = false;
+                while let Some(line) = drain_next_stream_line(&mut buf)? {
+                    let Some(data) = stream_data_payload(&line) else { continue };
+                    if data == "[DONE]" {
+                        finished = true;
+                        break;
+                    }
+
+                    if let Ok(event) = serde_json::from_str::<serde_json::Value>(data) {
+                        if let Some(text) = claude_stream_text(&event) {
+                            on_chunk(AiStreamChunk {
+                                session_id: session_id.to_string(),
+                                delta: text.to_string(),
+                                reasoning_delta: None,
+                                done: false,
+                            });
+                        }
+                    }
+                }
+
+                if finished { break; }
+            }
+            _ = cancelled.notified() => { break; }
+        }
+    }
+
+    on_chunk(AiStreamChunk {
+        session_id: session_id.to_string(),
+        delta: String::new(),
+        reasoning_delta: None,
+        done: true,
+    });
+
+    Ok(())
+}
+
+async fn stream_openai(
+    client: &reqwest::Client,
+    session_id: &str,
+    request: &AiCompletionRequest,
+    cancelled: &Notify,
+    on_chunk: &impl Fn(AiStreamChunk),
+) -> Result<(), String> {
+    let headers = maybe_bearer_headers(&request.config)?;
+
+    let mut messages = vec![json!({ "role": "system", "content": request.system_prompt })];
+    messages.extend(request.messages.iter().map(|m| json!({ "role": m.role, "content": m.content })));
+
+    let mut body_obj = json!({
+        "model": request.config.model,
+        "messages": messages,
+        "stream": true,
+    });
+    set_chat_completion_token_limit(&mut body_obj, &request.config, request.max_tokens.unwrap_or(2048));
+    apply_chat_completion_thinking_toggle(&mut body_obj, &request.config);
+
+    let res = client
+        .post(resolve_endpoint(&request.config))
+        .headers(headers)
+        .json(&body_obj)
+        .send()
+        .await
+        .map_err(|e| format!("AI request failed: {e}"))?;
+
+    if !res.status().is_success() {
+        let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+        return Err(extract_error(&data).unwrap_or_else(|| "API error".to_string()));
+    }
+
+    let mut byte_stream = res.bytes_stream();
+    let mut buf = Vec::new();
+
+    loop {
+        tokio::select! {
+            chunk = byte_stream.next() => {
+                let Some(chunk) = chunk else { break };
+                let chunk = chunk.map_err(|e| e.to_string())?;
+                buf.extend_from_slice(&chunk);
+
+                let mut finished = false;
+                while let Some(line) = drain_next_stream_line(&mut buf)? {
+                    let Some(data) = stream_data_payload(&line) else { continue };
+                    if data == "[DONE]" {
+                        finished = true;
+                        break;
+                    }
+
+                    if let Ok(event) = serde_json::from_str::<serde_json::Value>(data) {
+                        if let Some(reasoning) = openai_stream_reasoning(&event) {
+                            on_chunk(AiStreamChunk {
+                                session_id: session_id.to_string(),
+                                delta: String::new(),
+                                reasoning_delta: Some(reasoning.to_string()),
+                                done: false,
+                            });
+                        }
+                        if let Some(text) = openai_stream_text(&event) {
+                            on_chunk(AiStreamChunk {
+                                session_id: session_id.to_string(),
+                                delta: text,
+                                reasoning_delta: None,
+                                done: false,
+                            });
+                        }
+                    }
+                }
+
+                if finished { break; }
+            }
+            _ = cancelled.notified() => { break; }
+        }
+    }
+
+    on_chunk(AiStreamChunk {
+        session_id: session_id.to_string(),
+        delta: String::new(),
+        reasoning_delta: None,
+        done: true,
+    });
+
+    Ok(())
+}
+
+async fn stream_responses_api(
+    client: &reqwest::Client,
+    session_id: &str,
+    request: &AiCompletionRequest,
+    cancelled: &Notify,
+    on_chunk: &impl Fn(AiStreamChunk),
+) -> Result<(), String> {
+    let headers = maybe_bearer_headers(&request.config)?;
+
+    let body = json!({
+        "model": request.config.model,
+        "input": build_responses_input(&request.system_prompt, &request.messages),
+        "max_output_tokens": responses_max_output_tokens(request.max_tokens),
+        "stream": true,
+    });
+
+    let res = client
+        .post(resolve_endpoint(&request.config))
+        .headers(headers)
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("AI request failed: {e}"))?;
+
+    if !res.status().is_success() {
+        let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+        return Err(extract_error(&data).unwrap_or_else(|| "API error".to_string()));
+    }
+
+    let mut byte_stream = res.bytes_stream();
+    let mut buf = Vec::new();
+
+    loop {
+        tokio::select! {
+            chunk = byte_stream.next() => {
+                let Some(chunk) = chunk else { break };
+                let chunk = chunk.map_err(|e| e.to_string())?;
+                buf.extend_from_slice(&chunk);
+
+                let mut finished = false;
+                while let Some(line) = drain_next_stream_line(&mut buf)? {
+                    let Some(data) = stream_data_payload(&line) else { continue };
+                    if data == "[DONE]" {
+                        finished = true;
+                        break;
+                    }
+
+                    if let Ok(event) = serde_json::from_str::<serde_json::Value>(data) {
+                        if let Some(text) = responses_stream_text(&event) {
+                            on_chunk(AiStreamChunk {
+                                session_id: session_id.to_string(),
+                                delta: text.to_string(),
+                                reasoning_delta: None,
+                                done: false,
+                            });
+                        }
+                    }
+                }
+
+                if finished { break; }
+            }
+            _ = cancelled.notified() => { break; }
+        }
+    }
+
+    on_chunk(AiStreamChunk {
+        session_id: session_id.to_string(),
+        delta: String::new(),
+        reasoning_delta: None,
+        done: true,
+    });
+
+    Ok(())
+}
+
+async fn stream_gemini(
+    client: &reqwest::Client,
+    session_id: &str,
+    request: &AiCompletionRequest,
+    cancelled: &Notify,
+    on_chunk: &impl Fn(AiStreamChunk),
+) -> Result<(), String> {
+    let mut contents = Vec::new();
+    for message in &request.messages {
+        let role = if message.role == "assistant" { "model" } else { "user" };
+        contents.push(json!({
+            "role": role,
+            "parts": [{ "text": message.content }],
+        }));
+    }
+
+    let body = json!({
+        "systemInstruction": {
+            "parts": [{ "text": request.system_prompt }],
+        },
+        "contents": contents,
+        "generationConfig": {
+            "maxOutputTokens": request.max_tokens.unwrap_or(2048),
+        },
+    });
+
+    let res = client
+        .post(resolve_gemini_stream_endpoint(&request.config))
+        .query(&[("key", request.config.api_key.as_str()), ("alt", "sse")])
+        .header(CONTENT_TYPE, "application/json")
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("Gemini request failed: {e}"))?;
+
+    if !res.status().is_success() {
+        let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+        return Err(extract_error(&data).unwrap_or_else(|| "Gemini API error".to_string()));
+    }
+
+    let mut byte_stream = res.bytes_stream();
+    let mut buf = Vec::new();
+
+    loop {
+        tokio::select! {
+            chunk = byte_stream.next() => {
+                let Some(chunk) = chunk else { break };
+                let chunk = chunk.map_err(|e| e.to_string())?;
+                buf.extend_from_slice(&chunk);
+
+                while let Some(line) = drain_next_stream_line(&mut buf)? {
+                    let Some(data) = stream_data_payload(&line) else { continue };
+                    if let Ok(event) = serde_json::from_str::<serde_json::Value>(data) {
+                        let text = gemini_text(&event);
+                        if !text.is_empty() {
+                            on_chunk(AiStreamChunk {
+                                session_id: session_id.to_string(),
+                                delta: text,
+                                reasoning_delta: None,
+                                done: false,
+                            });
+                        }
+                    }
+                }
+            }
+            _ = cancelled.notified() => { break; }
+        }
+    }
+
+    on_chunk(AiStreamChunk {
+        session_id: session_id.to_string(),
+        delta: String::new(),
+        reasoning_delta: None,
+        done: true,
+    });
+
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------
+// Streaming with tools (agent loop)
+// ---------------------------------------------------------------------------
+
+/// Events emitted by provider-specific streaming-with-tools functions.
+/// The public `stream_with_tools` entry point uses these to accumulate
+/// tool calls and forward text/reasoning chunks to the caller.
+pub enum StreamToolEvent {
+    /// A text or reasoning delta for the frontend.
+    Chunk(AiStreamChunk),
+    /// A tool_use / function_call block has started.
+    ToolCallStart { index: u32, id: String, name: String },
+    /// An argument fragment for an in-progress tool call.
+    ToolCallDelta { index: u32, fragment: String },
+    /// A tool_use / function_call block has ended.
+    ToolCallComplete { index: u32 },
+}
+
+/// Partially accumulated tool call during streaming.
+#[derive(Debug)]
+struct PartialToolCall {
+    id: String,
+    name: String,
+    arguments: String,
+}
+
+/// Accumulates streaming tool-call events into complete `ToolCall` objects.
+#[derive(Debug)]
+pub struct StreamingToolCallAccumulator {
+    calls: std::collections::HashMap<u32, PartialToolCall>,
+    ordered_indices: Vec<u32>,
+}
+
+impl Default for StreamingToolCallAccumulator {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl StreamingToolCallAccumulator {
+    pub fn new() -> Self {
+        Self { calls: std::collections::HashMap::new(), ordered_indices: Vec::new() }
+    }
+
+    pub fn process(&mut self, event: StreamToolEvent, on_chunk: &impl Fn(AiStreamChunk)) {
+        match event {
+            StreamToolEvent::Chunk(chunk) => on_chunk(chunk),
+            StreamToolEvent::ToolCallStart { index, id, name } => {
+                // Merge with any existing entry for this index instead of
+                // overwriting it. Some OpenAI-compatible providers (e.g. GLM)
+                // re-send `id` (as an empty string) or omit `name` on
+                // subsequent delta chunks; a blind insert would wipe a
+                // previously-correct name and reset accumulated arguments,
+                // producing "Unknown tool:" errors.
+                if let Some(existing) = self.calls.get_mut(&index) {
+                    if !id.is_empty() {
+                        existing.id = id;
+                    }
+                    if !name.is_empty() {
+                        existing.name = name;
+                    }
+                } else {
+                    self.calls.insert(index, PartialToolCall { id, name, arguments: String::new() });
+                }
+                if !self.ordered_indices.contains(&index) {
+                    self.ordered_indices.push(index);
+                }
+            }
+            StreamToolEvent::ToolCallDelta { index, fragment } => {
+                if let Some(tc) = self.calls.get_mut(&index) {
+                    tc.arguments.push_str(&fragment);
+                }
+            }
+            StreamToolEvent::ToolCallComplete { index: _ } => {
+                // Nothing extra to do — the call is already accumulated.
+            }
+        }
+    }
+
+    pub fn finalize(self) -> Vec<crate::agent_events::ToolCall> {
+        let mut result = Vec::new();
+        for idx in &self.ordered_indices {
+            if let Some(tc) = self.calls.get(idx) {
+                let args: serde_json::Value = serde_json::from_str(&tc.arguments).unwrap_or(json!({}));
+                result.push(crate::agent_events::ToolCall {
+                    id: tc.id.clone(),
+                    name: tc.name.clone(),
+                    arguments: args,
+                });
+            }
+        }
+        result
+    }
+}
+
+/// Streaming Claude call with tool support.
+/// Returns a stream of `StreamToolEvent` via the `on_event` callback.
+async fn stream_claude_with_tools(
+    client: &reqwest::Client,
+    session_id: &str,
+    request: &AiCompletionRequest,
+    tools: &[crate::agent_events::ToolDefinition],
+    cancelled: &Notify,
+    on_event: &impl Fn(StreamToolEvent),
+) -> Result<Option<TokenUsage>, String> {
+    let mut messages: Vec<serde_json::Value> = Vec::new();
+    let mut pending_tool_results: Vec<serde_json::Value> = Vec::new();
+    for m in &request.messages {
+        if m.role == "tool" {
+            // Collect consecutive tool results; flush as a single user message.
+            pending_tool_results.push(json!({
+                "type": "tool_result",
+                "tool_use_id": m.tool_call_id.as_deref().unwrap_or_default(),
+                "content": m.content
+            }));
+        } else {
+            // Flush any pending tool results before emitting a non-tool message.
+            if !pending_tool_results.is_empty() {
+                messages.push(json!({
+                    "role": "user",
+                    "content": std::mem::take(&mut pending_tool_results)
+                }));
+            }
+            if m.role == "assistant" && !m.tool_calls.is_empty() {
+                let mut content_blocks: Vec<serde_json::Value> = Vec::new();
+                if !m.content.is_empty() {
+                    content_blocks.push(json!({ "type": "text", "text": m.content }));
+                }
+                for tc in &m.tool_calls {
+                    content_blocks
+                        .push(json!({ "type": "tool_use", "id": tc.id, "name": tc.name, "input": tc.arguments }));
+                }
+                messages.push(json!({ "role": "assistant", "content": content_blocks }));
+            } else {
+                messages.push(json!({ "role": m.role, "content": m.content }));
+            }
+        }
+    }
+    // Flush any remaining tool results at the end of the message list.
+    if !pending_tool_results.is_empty() {
+        messages.push(json!({
+            "role": "user",
+            "content": std::mem::take(&mut pending_tool_results)
+        }));
+    }
+
+    let tool_json: Vec<serde_json::Value> = tools.iter().map(|t| t.to_anthropic_tool()).collect();
+
+    let body = json!({
+        "model": request.config.model,
+        "max_tokens": request.max_tokens.unwrap_or(4096),
+        "system": claude_system_prompt(&request.system_prompt),
+        "messages": messages,
+        "tools": tool_json,
+        "stream": true,
+    });
+
+    let res = client
+        .post(resolve_endpoint(&request.config))
+        .headers(claude_headers(&request.config)?)
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("Claude request failed: {e}"))?;
+
+    if !res.status().is_success() {
+        let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+        return Err(extract_error(&data).unwrap_or_else(|| "Claude API error".to_string()));
+    }
+
+    let mut byte_stream = res.bytes_stream();
+    let mut buf = Vec::new();
+    // Track the current content block index and type for tool_use blocks
+    let mut current_block_index: Option<u32> = None;
+    let mut current_block_type: Option<String> = None;
+    let mut token_usage: Option<TokenUsage> = None;
+
+    loop {
+        tokio::select! {
+            chunk = byte_stream.next() => {
+                let Some(chunk) = chunk else { break };
+                let chunk = chunk.map_err(|e| e.to_string())?;
+                buf.extend_from_slice(&chunk);
+
+                let mut finished = false;
+                while let Some(line) = drain_next_stream_line(&mut buf)? {
+                    let Some(data) = stream_data_payload(&line) else { continue };
+                    if data == "[DONE]" {
+                        finished = true;
+                        break;
+                    }
+
+                    if let Ok(event) = serde_json::from_str::<serde_json::Value>(data) {
+                        let event_type = event["type"].as_str().unwrap_or("");
+
+                        match event_type {
+                            // message_start carries input_tokens (prompt cost)
+                            "message_start" => {
+                                if let Some(i) = event["message"]["usage"]["input_tokens"].as_u64() {
+                                    let existing_output = token_usage.as_ref().map(|u| u.output_tokens).unwrap_or(0);
+                                    token_usage = Some(TokenUsage { input_tokens: i as u32, output_tokens: existing_output });
+                                }
+                            }
+                            // message_delta carries output_tokens (generation cost)
+                            "message_delta" => {
+                                if let Some(o) = event["usage"]["output_tokens"].as_u64() {
+                                    let existing_input = token_usage.as_ref().map(|u| u.input_tokens).unwrap_or(0);
+                                    token_usage = Some(TokenUsage { input_tokens: existing_input, output_tokens: o as u32 });
+                                }
+                            }
+                            "content_block_start" => {
+                                let idx = event["index"].as_u64().unwrap_or(0) as u32;
+                                let block_type = event["content_block"]["type"].as_str().unwrap_or("");
+                                current_block_index = Some(idx);
+                                current_block_type = Some(block_type.to_string());
+
+                                if block_type == "tool_use" {
+                                    let id = event["content_block"]["id"].as_str().unwrap_or_default().to_string();
+                                    let name = event["content_block"]["name"].as_str().unwrap_or_default().to_string();
+                                    on_event(StreamToolEvent::ToolCallStart { index: idx, id, name });
+                                }
+                            }
+                            "content_block_delta" => {
+                                let idx = event["index"].as_u64().unwrap_or(0) as u32;
+                                let delta_type = event["delta"]["type"].as_str().unwrap_or("");
+
+                                match delta_type {
+                                    "text_delta" => {
+                                        if let Some(text) = event["delta"]["text"].as_str() {
+                                            on_event(StreamToolEvent::Chunk(AiStreamChunk {
+                                                session_id: session_id.to_string(),
+                                                delta: text.to_string(),
+                                                reasoning_delta: None,
+                                                done: false,
+                                            }));
+                                        }
+                                    }
+                                    "thinking_delta" => {
+                                        if let Some(thinking) = event["delta"]["thinking"].as_str() {
+                                            on_event(StreamToolEvent::Chunk(AiStreamChunk {
+                                                session_id: session_id.to_string(),
+                                                delta: String::new(),
+                                                reasoning_delta: Some(thinking.to_string()),
+                                                done: false,
+                                            }));
+                                        }
+                                    }
+                                    "input_json_delta" => {
+                                        if let Some(fragment) = event["delta"]["partial_json"].as_str() {
+                                            on_event(StreamToolEvent::ToolCallDelta {
+                                                index: idx,
+                                                fragment: fragment.to_string(),
+                                            });
+                                        }
+                                    }
+                                    _ => {}
+                                }
+                            }
+                            "content_block_stop" => {
+                                if let Some(idx) = current_block_index.take() {
+                                    if current_block_type.as_deref() == Some("tool_use") {
+                                        on_event(StreamToolEvent::ToolCallComplete { index: idx });
+                                    }
+                                }
+                                current_block_type = None;
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+
+                if finished { break; }
+            }
+            _ = cancelled.notified() => {
+                return Err(AGENT_CANCELLED_ERROR.to_string());
+            }
+        }
+    }
+
+    Ok(token_usage)
+}
+
+/// Streaming OpenAI-compatible call with tool support.
+async fn stream_openai_with_tools(
+    client: &reqwest::Client,
+    session_id: &str,
+    request: &AiCompletionRequest,
+    tools: &[crate::agent_events::ToolDefinition],
+    cancelled: &Notify,
+    on_event: &impl Fn(StreamToolEvent),
+) -> Result<Option<TokenUsage>, String> {
+    let headers = maybe_bearer_headers(&request.config)?;
+
+    let mut messages = vec![json!({ "role": "system", "content": request.system_prompt })];
+    messages.extend(request.messages.iter().map(|m| {
+        let mut msg = json!({ "role": m.role, "content": m.content });
+        if m.role == "tool" {
+            if let Some(ref tc_id) = m.tool_call_id {
+                msg["tool_call_id"] = json!(tc_id);
+            }
+        } else if m.role == "assistant" && !m.tool_calls.is_empty() {
+            let calls: Vec<serde_json::Value> = m
+                .tool_calls
+                .iter()
+                .map(|tc| {
+                    json!({
+                        "id": tc.id,
+                        "type": "function",
+                        "function": {
+                            "name": tc.name,
+                            "arguments": tc.arguments.to_string()
+                        }
+                    })
+                })
+                .collect();
+            msg["tool_calls"] = json!(calls);
+        }
+        msg
+    }));
+
+    let tool_json: Vec<serde_json::Value> = tools.iter().map(|t| t.to_openai_tool()).collect();
+
+    let mut body = json!({
+        "model": request.config.model,
+        "messages": messages,
+        "tools": tool_json,
+        "tool_choice": "auto",
+        "stream": true,
+        "stream_options": { "include_usage": true },
+    });
+    set_chat_completion_token_limit(&mut body, &request.config, request.max_tokens.unwrap_or(4096));
+
+    if !request.config.enable_thinking {
+        if matches!(request.config.provider, AiProvider::Ollama) {
+            apply_chat_completion_thinking_toggle(&mut body, &request.config);
+        } else if matches!(request.config.provider, AiProvider::Deepseek) {
+            // DeepSeek uses its own thinking field for tool-enabled requests.
+            body["thinking"] = json!({ "type": "disabled" });
+        }
+    }
+
+    let res = client
+        .post(resolve_endpoint(&request.config))
+        .headers(headers)
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("AI request failed: {e}"))?;
+
+    if !res.status().is_success() {
+        let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+        return Err(extract_error(&data).unwrap_or_else(|| "API error".to_string()));
+    }
+
+    let mut byte_stream = res.bytes_stream();
+    let mut buf = Vec::new();
+    let mut token_usage: Option<TokenUsage> = None;
+
+    loop {
+        tokio::select! {
+            chunk = byte_stream.next() => {
+                let Some(chunk) = chunk else { break };
+                let chunk = chunk.map_err(|e| e.to_string())?;
+                buf.extend_from_slice(&chunk);
+
+                let mut finished = false;
+                while let Some(line) = drain_next_stream_line(&mut buf)? {
+                    let Some(data) = stream_data_payload(&line) else { continue };
+                    if data == "[DONE]" {
+                        finished = true;
+                        break;
+                    }
+
+                    if let Ok(event) = serde_json::from_str::<serde_json::Value>(data) {
+                        // Token usage (final chunk from OpenAI with include_usage)
+                        if let Some(usage) = event.get("usage") {
+                            if let (Some(p), Some(c)) = (
+                                usage.get("prompt_tokens").and_then(|v| v.as_u64()),
+                                usage.get("completion_tokens").and_then(|v| v.as_u64()),
+                            ) {
+                                token_usage = Some(TokenUsage { input_tokens: p as u32, output_tokens: c as u32 });
+                            }
+                        }
+                        // Reasoning
+                        if let Some(reasoning) = openai_stream_reasoning(&event) {
+                            on_event(StreamToolEvent::Chunk(AiStreamChunk {
+                                session_id: session_id.to_string(),
+                                delta: String::new(),
+                                reasoning_delta: Some(reasoning.to_string()),
+                                done: false,
+                            }));
+                        }
+                        // Text
+                        if let Some(text) = openai_stream_text(&event) {
+                            on_event(StreamToolEvent::Chunk(AiStreamChunk {
+                                session_id: session_id.to_string(),
+                                delta: text,
+                                reasoning_delta: None,
+                                done: false,
+                            }));
+                        }
+                        // Tool calls
+                        if let Some(tool_calls) = event["choices"].get(0).and_then(|c| c["delta"]["tool_calls"].as_array()) {
+                            for tc in tool_calls {
+                                let idx = tc["index"].as_u64().unwrap_or(0) as u32;
+                                // The first delta carries the tool call id and
+                                // function name. Some OpenAI-compatible providers
+                                // (e.g. GLM) send id="" on subsequent deltas, so
+                                // only a non-empty id marks a genuine start.
+                                if let Some(id) = tc["id"].as_str().filter(|s| !s.is_empty()) {
+                                    let name = tc["function"]["name"].as_str().unwrap_or_default().to_string();
+                                    on_event(StreamToolEvent::ToolCallStart { index: idx, id: id.to_string(), name });
+                                }
+                                // Argument fragments
+                                if let Some(fragment) = tc["function"]["arguments"].as_str() {
+                                    on_event(StreamToolEvent::ToolCallDelta { index: idx, fragment: fragment.to_string() });
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if finished { break; }
+            }
+            _ = cancelled.notified() => {
+                return Err(AGENT_CANCELLED_ERROR.to_string());
+            }
+        }
+    }
+
+    Ok(token_usage)
+}
+
+async fn stream_responses_with_tools(
+    client: &reqwest::Client,
+    session_id: &str,
+    request: &AiCompletionRequest,
+    tools: &[crate::agent_events::ToolDefinition],
+    cancelled: &Notify,
+    on_event: &impl Fn(StreamToolEvent),
+) -> Result<Option<TokenUsage>, String> {
+    let headers = maybe_bearer_headers(&request.config)?;
+    let tool_json: Vec<serde_json::Value> = tools.iter().map(responses_function_tool).collect();
+
+    let body = json!({
+        "model": request.config.model,
+        "input": build_responses_input_with_tools(&request.system_prompt, &request.messages),
+        "max_output_tokens": responses_max_output_tokens(request.max_tokens),
+        "tools": tool_json,
+        "tool_choice": "auto",
+        "stream": true,
+    });
+
+    let res = client
+        .post(resolve_endpoint(&request.config))
+        .headers(headers)
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("AI request failed: {e}"))?;
+
+    if !res.status().is_success() {
+        let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+        return Err(extract_error(&data).unwrap_or_else(|| "API error".to_string()));
+    }
+
+    let mut byte_stream = res.bytes_stream();
+    let mut buf = Vec::new();
+    let mut item_indices: HashMap<String, u32> = HashMap::new();
+    let mut started_indices: HashSet<u32> = HashSet::new();
+    let mut argument_indices: HashSet<u32> = HashSet::new();
+    let mut next_index: u32 = 0;
+    let mut token_usage: Option<TokenUsage> = None;
+
+    loop {
+        tokio::select! {
+            chunk = byte_stream.next() => {
+                let Some(chunk) = chunk else { break };
+                let chunk = chunk.map_err(|e| e.to_string())?;
+                buf.extend_from_slice(&chunk);
+
+                let mut finished = false;
+                while let Some(line) = drain_next_stream_line(&mut buf)? {
+                    let Some(data) = stream_data_payload(&line) else { continue };
+                    if data == "[DONE]" {
+                        finished = true;
+                        break;
+                    }
+
+                    if let Ok(event) = serde_json::from_str::<serde_json::Value>(data) {
+                        if let Some(usage) = responses_token_usage(&event) {
+                            token_usage = Some(usage);
+                        }
+
+                        if let Some(text) = responses_stream_text(&event) {
+                            on_event(StreamToolEvent::Chunk(AiStreamChunk {
+                                session_id: session_id.to_string(),
+                                delta: text.to_string(),
+                                reasoning_delta: None,
+                                done: false,
+                            }));
+                        }
+
+                        match event["type"].as_str().unwrap_or_default() {
+                            "response.output_item.added" => {
+                                emit_responses_function_call_item(
+                                    &event,
+                                    &mut item_indices,
+                                    &mut started_indices,
+                                    &mut argument_indices,
+                                    &mut next_index,
+                                    on_event,
+                                );
+                            }
+                            "response.output_item.done" => {
+                                if let Some(index) = emit_responses_function_call_item(
+                                    &event,
+                                    &mut item_indices,
+                                    &mut started_indices,
+                                    &mut argument_indices,
+                                    &mut next_index,
+                                    on_event,
+                                ) {
+                                    on_event(StreamToolEvent::ToolCallComplete { index });
+                                }
+                            }
+                            "response.function_call_arguments.delta" => {
+                                let index = event["item_id"]
+                                    .as_str()
+                                    .and_then(|id| item_indices.get(id).copied())
+                                    .or_else(|| event["output_index"].as_u64().map(|i| i as u32))
+                                    .unwrap_or(0);
+                                if let Some(fragment) = event["delta"].as_str() {
+                                    argument_indices.insert(index);
+                                    on_event(StreamToolEvent::ToolCallDelta { index, fragment: fragment.to_string() });
+                                }
+                            }
+                            "response.function_call_arguments.done" => {
+                                let index = event["item_id"]
+                                    .as_str()
+                                    .and_then(|id| item_indices.get(id).copied())
+                                    .or_else(|| event["output_index"].as_u64().map(|i| i as u32))
+                                    .unwrap_or(0);
+                                on_event(StreamToolEvent::ToolCallComplete { index });
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+
+                if finished { break; }
+            }
+            _ = cancelled.notified() => {
+                return Err(AGENT_CANCELLED_ERROR.to_string());
+            }
+        }
+    }
+
+    Ok(token_usage)
+}
+
+/// Streaming Gemini call with tool support.
+async fn stream_gemini_with_tools(
+    client: &reqwest::Client,
+    session_id: &str,
+    request: &AiCompletionRequest,
+    tools: &[crate::agent_events::ToolDefinition],
+    cancelled: &Notify,
+    on_event: &impl Fn(StreamToolEvent),
+) -> Result<Option<TokenUsage>, String> {
+    let mut contents: Vec<serde_json::Value> = Vec::new();
+    let mut pending_function_responses: Vec<serde_json::Value> = Vec::new();
+    for m in &request.messages {
+        if m.role == "tool" {
+            let tool_name = m
+                .tool_call_id
+                .as_deref()
+                .and_then(|s| s.strip_prefix("gemini-tc-"))
+                .and_then(|s| s.rsplit_once('-').map(|x| x.0))
+                .unwrap_or("unknown");
+            pending_function_responses.push(json!({
+                "functionResponse": {
+                    "name": tool_name,
+                    "response": { "content": m.content }
+                }
+            }));
+        } else {
+            // Flush any pending function responses before emitting a non-tool message.
+            if !pending_function_responses.is_empty() {
+                contents.push(json!({
+                    "role": "user",
+                    "parts": std::mem::take(&mut pending_function_responses)
+                }));
+            }
+            if m.role == "assistant" && !m.tool_calls.is_empty() {
+                let mut parts: Vec<serde_json::Value> = Vec::new();
+                if !m.content.is_empty() {
+                    parts.push(json!({ "text": m.content }));
+                }
+                for tc in &m.tool_calls {
+                    parts.push(json!({ "functionCall": { "name": tc.name, "args": tc.arguments } }));
+                }
+                contents.push(json!({ "role": "model", "parts": parts }));
+            } else {
+                let role = if m.role == "assistant" { "model" } else { "user" };
+                contents.push(json!({ "role": role, "parts": [{ "text": m.content }] }));
+            }
+        }
+    }
+    // Flush any remaining function responses at the end of the message list.
+    if !pending_function_responses.is_empty() {
+        contents.push(json!({
+            "role": "user",
+            "parts": std::mem::take(&mut pending_function_responses)
+        }));
+    }
+
+    let tool_declarations: Vec<serde_json::Value> = tools.iter().map(|t| t.to_gemini_tool()).collect();
+
+    let body = json!({
+        "contents": contents,
+        "systemInstruction": { "parts": [{ "text": request.system_prompt }] },
+        "tools": [{ "functionDeclarations": tool_declarations }],
+        "generationConfig": {
+            "maxOutputTokens": request.max_tokens.unwrap_or(4096),
+        }
+    });
+
+    let res = client
+        .post(resolve_gemini_stream_endpoint(&request.config))
+        .query(&[("key", request.config.api_key.as_str()), ("alt", "sse")])
+        .header(CONTENT_TYPE, "application/json")
+        .json(&body)
+        .send()
+        .await
+        .map_err(|e| format!("Gemini request failed: {e}"))?;
+
+    if !res.status().is_success() {
+        let data: serde_json::Value = res.json().await.map_err(|e| e.to_string())?;
+        return Err(extract_error(&data).unwrap_or_else(|| "Gemini API error".to_string()));
+    }
+
+    let mut byte_stream = res.bytes_stream();
+    let mut buf = Vec::new();
+    let mut tool_call_idx: u32 = 0;
+    let mut token_usage: Option<TokenUsage> = None;
+
+    loop {
+        tokio::select! {
+            chunk = byte_stream.next() => {
+                let Some(chunk) = chunk else { break };
+                let chunk = chunk.map_err(|e| e.to_string())?;
+                buf.extend_from_slice(&chunk);
+
+                while let Some(line) = drain_next_stream_line(&mut buf)? {
+                    let Some(data) = stream_data_payload(&line) else { continue };
+                    if let Ok(event) = serde_json::from_str::<serde_json::Value>(data) {
+                        // Token usage (overwrite each chunk, keep last value)
+                        if let (Some(p), Some(c)) = (
+                            event["usageMetadata"]["promptTokenCount"].as_u64(),
+                            event["usageMetadata"]["candidatesTokenCount"].as_u64(),
+                        ) {
+                            token_usage = Some(TokenUsage { input_tokens: p as u32, output_tokens: c as u32 });
+                        }
+                        if let Some(candidates) = event["candidates"].as_array() {
+                            if let Some(parts) = candidates[0]["content"]["parts"].as_array() {
+                                for part in parts {
+                                    // Text
+                                    if let Some(text) = part["text"].as_str() {
+                                        on_event(StreamToolEvent::Chunk(AiStreamChunk {
+                                            session_id: session_id.to_string(),
+                                            delta: text.to_string(),
+                                            reasoning_delta: None,
+                                            done: false,
+                                        }));
+                                    }
+                                    // Function call (Gemini sends complete objects, not deltas)
+                                    if let Some(fc) = part.get("functionCall") {
+                                        let name = fc["name"].as_str().unwrap_or_default().to_string();
+                                        let args = fc["args"].clone();
+                                        let id = format!("gemini-tc-{name}-{tool_call_idx}");
+                                        let args_str = args.to_string();
+                                        on_event(StreamToolEvent::ToolCallStart {
+                                            index: tool_call_idx,
+                                            id: id.clone(),
+                                            name: name.clone(),
+                                        });
+                                        on_event(StreamToolEvent::ToolCallDelta {
+                                            index: tool_call_idx,
+                                            fragment: args_str,
+                                        });
+                                        on_event(StreamToolEvent::ToolCallComplete { index: tool_call_idx });
+                                        tool_call_idx += 1;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            _ = cancelled.notified() => {
+                return Err(AGENT_CANCELLED_ERROR.to_string());
+            }
+        }
+    }
+
+    Ok(token_usage)
+}
+
+/// Public entry point: stream an LLM call with tool support, accumulating tool calls.
+/// Returns completed tool calls and token usage when the stream finishes.
+pub async fn stream_with_tools(
+    config: &AiConfig,
+    request: &AiCompletionRequest,
+    session_id: &str,
+    tools: &[crate::agent_events::ToolDefinition],
+    cancelled: &Notify,
+    on_chunk: impl Fn(AiStreamChunk),
+) -> Result<(Vec<crate::agent_events::ToolCall>, Option<TokenUsage>), String> {
+    validate_config(config)?;
+
+    let stream_timeout = if config.enable_thinking { 600 } else { 120 };
+    let client = build_ai_http_client(config, stream_timeout)?;
+
+    let accumulator = Arc::new(std::sync::Mutex::new(StreamingToolCallAccumulator::new()));
+
+    let token_usage = match config.provider {
+        AiProvider::Claude => {
+            stream_claude_with_tools(&client, session_id, request, tools, cancelled, &|event| {
+                accumulator.lock().unwrap().process(event, &on_chunk);
+            })
+            .await?
+        }
+        AiProvider::Gemini => {
+            stream_gemini_with_tools(&client, session_id, request, tools, cancelled, &|event| {
+                accumulator.lock().unwrap().process(event, &on_chunk);
+            })
+            .await?
+        }
+        AiProvider::Custom if uses_anthropic_messages_api(config) => {
+            stream_claude_with_tools(&client, session_id, request, tools, cancelled, &|event| {
+                accumulator.lock().unwrap().process(event, &on_chunk);
+            })
+            .await?
+        }
+        _ if config.api_style == AiApiStyle::Responses => {
+            stream_responses_with_tools(&client, session_id, request, tools, cancelled, &|event| {
+                accumulator.lock().unwrap().process(event, &on_chunk);
+            })
+            .await?
+        }
+        _ => {
+            stream_openai_with_tools(&client, session_id, request, tools, cancelled, &|event| {
+                accumulator.lock().unwrap().process(event, &on_chunk);
+            })
+            .await?
+        }
+    };
+
+    let tool_calls = Arc::try_unwrap(accumulator)
+        .expect("stream_with_tools: accumulator Arc should have single owner")
+        .into_inner()
+        .expect("stream_with_tools: accumulator Mutex should not be poisoned")
+        .finalize();
+
+    Ok((tool_calls, token_usage))
+}
+
+// ---------------------------------------------------------------------------
+// Conversation persistence (path-based)
+// ---------------------------------------------------------------------------
+
+const MAX_CONVERSATIONS: usize = 50;
+
+pub fn read_conversations(path: &Path) -> Result<Vec<AiConversation>, String> {
+    if !path.exists() {
+        return Ok(vec![]);
+    }
+    let json = std::fs::read_to_string(path).map_err(|e| e.to_string())?;
+    serde_json::from_str(&json).map_err(|e| e.to_string())
+}
+
+pub fn write_conversations(path: &Path, conversations: &[AiConversation]) -> Result<(), String> {
+    let json = serde_json::to_string(conversations).map_err(|e| e.to_string())?;
+    std::fs::write(path, json).map_err(|e| e.to_string())
+}
+
+pub fn save_conversation(path: &Path, conversation: AiConversation) -> Result<(), String> {
+    let mut conversations = read_conversations(path)?;
+    if let Some(pos) = conversations.iter().position(|c| c.id == conversation.id) {
+        conversations[pos] = conversation;
+    } else {
+        conversations.insert(0, conversation);
+        conversations.truncate(MAX_CONVERSATIONS);
+    }
+    write_conversations(path, &conversations)
+}
+
+pub fn load_conversations(path: &Path) -> Result<Vec<AiConversation>, String> {
+    read_conversations(path)
+}
+
+pub fn delete_conversation(path: &Path, id: &str) -> Result<(), String> {
+    let conversations: Vec<AiConversation> = read_conversations(path)?.into_iter().filter(|c| c.id != id).collect();
+    write_conversations(path, &conversations)
+}
+
+pub fn save_config(path: &Path, config: &AiConfig) -> Result<(), String> {
+    let json = serde_json::to_string_pretty(config).map_err(|e| e.to_string())?;
+    std::fs::write(path, json).map_err(|e| e.to_string())
+}
+
+pub fn load_config(path: &Path) -> Result<Option<AiConfig>, String> {
+    if !path.exists() {
+        return Ok(None);
+    }
+    let json = std::fs::read_to_string(path).map_err(|e| e.to_string())?;
+    serde_json::from_str(&json).map(Some).map_err(|e| e.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::cell::RefCell;
+    use std::collections::{HashMap, HashSet};
+
+    use super::{
+        apply_chat_completion_thinking_toggle, build_ai_http_client, build_responses_input_with_tools, claude_headers,
+        claude_system_prompt, drain_next_stream_line, emit_responses_function_call_item, gemini_text, is_kimi_model,
+        openai_response_text, openai_stream_reasoning, openai_stream_text, parse_model_list_response, resolve_endpoint,
+        resolve_gemini_stream_endpoint, resolve_model_list_endpoint, responses_function_tool,
+        responses_max_output_tokens, responses_stream_text, responses_text, responses_token_usage,
+        set_chat_completion_token_limit, stream_data_payload, uses_anthropic_messages_api, validate_config, AiApiStyle,
+        AiAuthMethod, AiConfig, AiMessage, AiModelInfo, AiProvider, AiReasoningLevel, StreamToolEvent,
+        StreamingToolCallAccumulator, ToolCallRef, AUTHORIZATION, CLAUDE_DEFAULT_SYSTEM, TEST_PROMPT,
+    };
+
+    /// Reproduce the "Unknown tool:" bug: some OpenAI-compatible providers
+    /// (e.g. GLM via proxy) re-send the `id` field in every tool-call delta.
+    /// The second delta carries `id` but omits `function.name`, so the OpenAI
+    /// parser emits a second ToolCallStart with an empty name. The
+    /// accumulator's `insert` then overwrites the previously-correct name.
+    #[test]
+    fn accumulator_preserves_name_when_provider_resends_id() {
+        let mut acc = StreamingToolCallAccumulator::new();
+        let noop = |_chunk| {};
+
+        // First chunk: id + name present (standard OpenAI first delta)
+        acc.process(
+            StreamToolEvent::ToolCallStart { index: 0, id: "call_1".to_string(), name: "get_columns".to_string() },
+            &noop,
+        );
+        acc.process(StreamToolEvent::ToolCallDelta { index: 0, fragment: "{\"table\":".to_string() }, &noop);
+
+        // Second chunk: provider re-sends `id` but omits `function.name`.
+        // The OpenAI parser sees `id` is Some and emits ToolCallStart with
+        // name = "" (from unwrap_or_default()).
+        acc.process(StreamToolEvent::ToolCallStart { index: 0, id: "call_1".to_string(), name: String::new() }, &noop);
+        acc.process(StreamToolEvent::ToolCallDelta { index: 0, fragment: "\"record_trip_id_t\"}".to_string() }, &noop);
+
+        let calls = acc.finalize();
+        assert_eq!(calls.len(), 1, "expected exactly one accumulated tool call");
+        assert_eq!(
+            calls[0].name, "get_columns",
+            "tool name was wiped to empty by a re-sent ToolCallStart — this is the \"Unknown tool:\" bug"
+        );
+        assert_eq!(calls[0].arguments["table"], "record_trip_id_t", "arguments were reset by a re-sent ToolCallStart");
+    }
+
+    #[test]
+    fn stream_line_decoder_preserves_split_multibyte_utf8() {
+        let text = "\u{8bf4}\u{660e}";
+        let json = serde_json::json!({ "delta": text }).to_string();
+        let line = format!("data: {json}\n");
+        let bytes = line.as_bytes();
+        let split = bytes.iter().position(|byte| *byte >= 0x80).unwrap() + 1;
+        let mut buffer = Vec::new();
+
+        buffer.extend_from_slice(&bytes[..split]);
+        assert_eq!(drain_next_stream_line(&mut buffer).unwrap(), None);
+
+        buffer.extend_from_slice(&bytes[split..]);
+        let decoded = drain_next_stream_line(&mut buffer).unwrap().unwrap();
+        let payload = stream_data_payload(&decoded).unwrap();
+        let parsed: serde_json::Value = serde_json::from_str(payload).unwrap();
+
+        assert_eq!(parsed["delta"].as_str(), Some(text));
+        assert!(!decoded.contains('\u{fffd}'));
+    }
+
+    #[test]
+    fn ai_config_proxy_fields_default_for_legacy_config() {
+        let config: AiConfig = serde_json::from_value(serde_json::json!({
+            "provider": "openai",
+            "apiKey": "key",
+            "endpoint": "https://api.openai.com/v1/chat/completions",
+            "model": "gpt-4o",
+            "apiStyle": "completions"
+        }))
+        .unwrap();
+
+        assert!(!config.proxy_enabled);
+        assert_eq!(config.proxy_url, "");
+        assert!(config.enable_thinking);
+        assert_eq!(config.auth_method, AiAuthMethod::ApiKey);
+        assert!(config.codex_cli_env.is_empty());
+    }
+
+    #[test]
+    fn ai_http_client_rejects_invalid_proxy_url() {
+        let config = AiConfig {
+            provider: AiProvider::Openai,
+            api_key: "key".to_string(),
+            auth_method: AiAuthMethod::Bearer,
+            endpoint: "https://api.openai.com/v1/chat/completions".to_string(),
+            model: "gpt-4o".to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: true,
+            proxy_url: "not a proxy url".to_string(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+
+        let err = build_ai_http_client(&config, 1).unwrap_err();
+
+        assert!(err.contains("Invalid AI proxy URL"));
+    }
+
+    #[test]
+    fn ai_http_client_accepts_proxy_host_port_without_scheme() {
+        let config = AiConfig {
+            provider: AiProvider::Openai,
+            api_key: "key".to_string(),
+            auth_method: AiAuthMethod::Bearer,
+            endpoint: "https://api.openai.com/v1/chat/completions".to_string(),
+            model: "gpt-4o".to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: true,
+            proxy_url: "127.0.0.1:7890".to_string(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+
+        build_ai_http_client(&config, 1).unwrap();
+    }
+
+    #[test]
+    fn ai_http_client_bypasses_proxy_for_loopback_endpoint() {
+        let config = AiConfig {
+            provider: AiProvider::OpenaiCompatible,
+            api_key: "key".to_string(),
+            auth_method: AiAuthMethod::Bearer,
+            endpoint: "http://127.0.0.1:3456/v1".to_string(),
+            model: "gpt-4o".to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: true,
+            proxy_url: "not a proxy url".to_string(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+
+        build_ai_http_client(&config, 1).unwrap();
+    }
+
+    #[test]
+    fn resolves_gemini_and_ollama_endpoints() {
+        let gemini = AiConfig {
+            provider: AiProvider::Gemini,
+            api_key: "key".to_string(),
+            auth_method: AiAuthMethod::ApiKey,
+            endpoint: "https://generativelanguage.googleapis.com".to_string(),
+            model: "gemini-1.5-pro".to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+
+        assert_eq!(
+            resolve_endpoint(&gemini),
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro:generateContent"
+        );
+        assert_eq!(
+            resolve_gemini_stream_endpoint(&gemini),
+            "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro:streamGenerateContent"
+        );
+
+        let ollama = AiConfig {
+            provider: AiProvider::Ollama,
+            api_key: String::new(),
+            auth_method: AiAuthMethod::Bearer,
+            endpoint: "http://localhost:11434/v1".to_string(),
+            model: "llama3.1".to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+
+        assert_eq!(resolve_endpoint(&ollama), "http://localhost:11434/v1/chat/completions");
+        assert!(validate_config(&ollama).is_ok());
+    }
+
+    #[test]
+    fn resolves_model_list_endpoints_from_base_and_completion_urls() {
+        let openai = AiConfig {
+            provider: AiProvider::Openai,
+            api_key: "key".to_string(),
+            auth_method: AiAuthMethod::Bearer,
+            endpoint: "https://api.openai.com/v1/chat/completions".to_string(),
+            model: String::new(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+        assert_eq!(resolve_model_list_endpoint(&openai).unwrap(), "https://api.openai.com/v1/models");
+
+        let claude = AiConfig {
+            provider: AiProvider::Claude,
+            api_key: "key".to_string(),
+            auth_method: AiAuthMethod::ApiKey,
+            endpoint: "https://api.anthropic.com/v1/messages".to_string(),
+            model: String::new(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+        assert_eq!(resolve_model_list_endpoint(&claude).unwrap(), "https://api.anthropic.com/v1/models");
+    }
+
+    #[test]
+    fn custom_anthropic_messages_style_uses_claude_endpoints() {
+        let config = AiConfig {
+            provider: AiProvider::Custom,
+            api_key: "key".to_string(),
+            auth_method: AiAuthMethod::ApiKey,
+            endpoint: "https://gateway.example.com/anthropic/v1".to_string(),
+            model: "claude-sonnet-4-20250514".to_string(),
+            api_style: AiApiStyle::AnthropicMessages,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+
+        assert!(uses_anthropic_messages_api(&config));
+        assert_eq!(resolve_endpoint(&config), "https://gateway.example.com/anthropic/v1/messages");
+        assert_eq!(resolve_model_list_endpoint(&config).unwrap(), "https://gateway.example.com/anthropic/v1/models");
+
+        let full_messages =
+            AiConfig { endpoint: "https://gateway.example.com/anthropic/v1/messages".to_string(), ..config.clone() };
+        assert_eq!(resolve_endpoint(&full_messages), "https://gateway.example.com/anthropic/v1/messages");
+        assert_eq!(
+            resolve_model_list_endpoint(&full_messages).unwrap(),
+            "https://gateway.example.com/anthropic/v1/models"
+        );
+
+        let bare_origin = AiConfig { endpoint: "https://gateway.example.com".to_string(), ..config.clone() };
+        assert_eq!(resolve_endpoint(&bare_origin), "https://gateway.example.com/v1/messages");
+        assert_eq!(resolve_model_list_endpoint(&bare_origin).unwrap(), "https://gateway.example.com/v1/models");
+
+        let kimi_coding = AiConfig {
+            endpoint: "https://api.kimi.com/coding/".to_string(),
+            model: "kimi-for-coding".to_string(),
+            ..config.clone()
+        };
+        assert_eq!(resolve_endpoint(&kimi_coding), "https://api.kimi.com/coding/v1/messages");
+        assert_eq!(resolve_model_list_endpoint(&kimi_coding).unwrap(), "https://api.kimi.com/coding/v1/models");
+    }
+
+    #[test]
+    fn auto_adds_v1_to_openai_compatible_endpoints() {
+        // Endpoint without /v1 — auto add
+        let config = AiConfig {
+            provider: AiProvider::OpenaiCompatible,
+            api_key: "key".to_string(),
+            auth_method: AiAuthMethod::Bearer,
+            endpoint: "https://api.example.com".to_string(),
+            model: "test-model".to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+        assert_eq!(resolve_endpoint(&config), "https://api.example.com/v1/chat/completions");
+        assert_eq!(resolve_model_list_endpoint(&config).unwrap(), "https://api.example.com/v1/models");
+
+        // Endpoint with /v1 already present — no change
+        let config_v1 = AiConfig { endpoint: "https://api.example.com/v1".to_string(), ..config.clone() };
+        assert_eq!(resolve_endpoint(&config_v1), "https://api.example.com/v1/chat/completions");
+        assert_eq!(resolve_model_list_endpoint(&config_v1).unwrap(), "https://api.example.com/v1/models");
+
+        // Endpoint with /v2 — no change
+        let config_v2 = AiConfig { endpoint: "https://api.example.com/v2".to_string(), ..config.clone() };
+        assert_eq!(resolve_endpoint(&config_v2), "https://api.example.com/v2/chat/completions");
+
+        // Full path already specified — no change
+        let config_full =
+            AiConfig { endpoint: "https://api.openai.com/v1/chat/completions".to_string(), ..config.clone() };
+        assert_eq!(resolve_endpoint(&config_full), "https://api.openai.com/v1/chat/completions");
+
+        // Responses API style with /v1 missing
+        let config_responses = AiConfig { api_style: AiApiStyle::Responses, ..config.clone() };
+        assert_eq!(resolve_endpoint(&config_responses), "https://api.example.com/v1/responses");
+
+        // Ollama preset already has /v1 — no change
+        let ollama = AiConfig {
+            provider: AiProvider::Ollama,
+            endpoint: "http://localhost:11434/v1".to_string(),
+            ..config.clone()
+        };
+        assert_eq!(resolve_endpoint(&ollama), "http://localhost:11434/v1/chat/completions");
+
+        // Custom path without /v1 — left alone (CC-Switch strategy: only bare origin gets auto /v1)
+        let custom_path = AiConfig { endpoint: "https://my-gateway.com/api".to_string(), ..config.clone() };
+        assert_eq!(resolve_endpoint(&custom_path), "https://my-gateway.com/api/chat/completions");
+        assert_eq!(resolve_model_list_endpoint(&custom_path).unwrap(), "https://my-gateway.com/api/models");
+
+        // Bare host with port — add /v1
+        let bare_with_port = AiConfig { endpoint: "http://localhost:8080".to_string(), ..config.clone() };
+        assert_eq!(resolve_endpoint(&bare_with_port), "http://localhost:8080/v1/chat/completions");
+    }
+
+    #[test]
+    fn claude_headers_support_api_key_and_bearer_auth() {
+        let mut config = AiConfig {
+            provider: AiProvider::Claude,
+            api_key: "secret".to_string(),
+            auth_method: AiAuthMethod::ApiKey,
+            endpoint: "https://api.anthropic.com/v1/messages".to_string(),
+            model: "claude-sonnet-4-20250514".to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+
+        let api_key_headers = claude_headers(&config).unwrap();
+        assert_eq!(api_key_headers.get("x-api-key").unwrap(), "secret");
+        assert!(api_key_headers.get(AUTHORIZATION).is_none());
+
+        config.auth_method = AiAuthMethod::Bearer;
+        let bearer_headers = claude_headers(&config).unwrap();
+        assert_eq!(bearer_headers.get(AUTHORIZATION).unwrap(), "Bearer secret");
+        assert!(bearer_headers.get("x-api-key").is_none());
+    }
+
+    #[test]
+    fn claude_system_prompt_substitutes_default_when_empty() {
+        // Empty or whitespace-only prompts must fall back to a non-empty value,
+        // otherwise Anthropic rejects the request with
+        // "system: text content blocks must be non-empty".
+        assert_eq!(claude_system_prompt(""), CLAUDE_DEFAULT_SYSTEM);
+        assert_eq!(claude_system_prompt("   \n\t"), CLAUDE_DEFAULT_SYSTEM);
+        assert!(!CLAUDE_DEFAULT_SYSTEM.is_empty());
+
+        // Real prompts pass through unchanged.
+        assert_eq!(claude_system_prompt("Be concise."), "Be concise.");
+    }
+
+    #[test]
+    fn parses_openai_and_claude_model_list_items() {
+        let data = serde_json::json!({
+            "data": [
+                { "id": "gpt-4o-mini" },
+                { "id": "claude-sonnet-4-20250514", "display_name": "Claude Sonnet 4" },
+                { "id": "gpt-4o-mini" },
+                { "display_name": "Missing ID" }
+            ]
+        });
+
+        assert_eq!(
+            parse_model_list_response(&data).unwrap(),
+            vec![
+                AiModelInfo { id: "gpt-4o-mini".to_string(), display_name: None },
+                AiModelInfo {
+                    id: "claude-sonnet-4-20250514".to_string(),
+                    display_name: Some("Claude Sonnet 4".to_string())
+                },
+            ]
+        );
+    }
+
+    #[test]
+    fn responses_api_clamps_tiny_output_token_requests() {
+        assert_eq!(responses_max_output_tokens(Some(1)), 16);
+        assert_eq!(responses_max_output_tokens(Some(16)), 16);
+        assert_eq!(responses_max_output_tokens(Some(2400)), 2400);
+        assert_eq!(responses_max_output_tokens(None), 2048);
+    }
+
+    #[test]
+    fn responses_stream_text_reads_current_delta_shapes() {
+        assert_eq!(
+            responses_stream_text(&serde_json::json!({
+                "type": "response.output_text.delta",
+                "delta": "SELECT"
+            })),
+            Some("SELECT")
+        );
+        assert_eq!(
+            responses_stream_text(&serde_json::json!({
+                "type": "response.output_text.done",
+                "text": "SELECT 1;"
+            })),
+            None
+        );
+    }
+
+    #[test]
+    fn responses_token_usage_reads_stream_completed_response_usage() {
+        let completed_usage = responses_token_usage(&serde_json::json!({
+            "type": "response.completed",
+            "response": {
+                "usage": {
+                    "input_tokens": 12,
+                    "output_tokens": 34
+                }
+            }
+        }))
+        .unwrap();
+        assert_eq!(completed_usage.input_tokens, 12);
+        assert_eq!(completed_usage.output_tokens, 34);
+
+        let top_level_usage = responses_token_usage(&serde_json::json!({
+            "usage": {
+                "input_tokens": 56,
+                "output_tokens": 78
+            }
+        }))
+        .unwrap();
+        assert_eq!(top_level_usage.input_tokens, 56);
+        assert_eq!(top_level_usage.output_tokens, 78);
+    }
+
+    #[test]
+    fn responses_tools_use_responses_schema() {
+        let input = build_responses_input_with_tools(
+            "system",
+            &[
+                AiMessage {
+                    role: "user".to_string(),
+                    content: "inspect db".to_string(),
+                    tool_call_id: None,
+                    tool_calls: Vec::new(),
+                },
+                AiMessage {
+                    role: "assistant".to_string(),
+                    content: String::new(),
+                    tool_call_id: None,
+                    tool_calls: vec![ToolCallRef {
+                        id: "call_1".to_string(),
+                        name: "list_tables".to_string(),
+                        arguments: serde_json::json!({"schema": "public"}),
+                    }],
+                },
+                AiMessage {
+                    role: "tool".to_string(),
+                    content: "users".to_string(),
+                    tool_call_id: Some("call_1".to_string()),
+                    tool_calls: Vec::new(),
+                },
+            ],
+        );
+
+        assert_eq!(input[0]["role"], "developer");
+        assert_eq!(input[2]["type"], "function_call");
+        assert_eq!(input[2]["call_id"], "call_1");
+        assert_eq!(input[2]["arguments"], "{\"schema\":\"public\"}");
+        assert_eq!(input[3]["type"], "function_call_output");
+        assert_eq!(input[3]["call_id"], "call_1");
+
+        let tool = crate::agent_events::ToolDefinition {
+            name: "list_tables",
+            description: "List tables",
+            parameters: serde_json::json!({"type": "object"}),
+            read_only: true,
+            parallel_ok: true,
+        };
+        let tool_json = responses_function_tool(&tool);
+        assert_eq!(tool_json["type"], "function");
+        assert_eq!(tool_json["name"], "list_tables");
+        assert!(tool_json.get("function").is_none());
+    }
+
+    #[test]
+    fn responses_tool_done_item_can_supply_complete_function_call() {
+        let mut accumulator = StreamingToolCallAccumulator::new();
+        let mut item_indices = HashMap::new();
+        let mut started_indices = HashSet::new();
+        let mut argument_indices = HashSet::new();
+        let mut next_index = 0;
+        let event = serde_json::json!({
+            "type": "response.output_item.done",
+            "output_index": 0,
+            "item": {
+                "id": "fc_1",
+                "type": "function_call",
+                "call_id": "call_1",
+                "name": "list_tables",
+                "arguments": "{\"schema\":\"public\"}"
+            }
+        });
+        let events = RefCell::new(Vec::new());
+        if let Some(index) = emit_responses_function_call_item(
+            &event,
+            &mut item_indices,
+            &mut started_indices,
+            &mut argument_indices,
+            &mut next_index,
+            &|event| events.borrow_mut().push(event),
+        ) {
+            events.borrow_mut().push(StreamToolEvent::ToolCallComplete { index });
+        }
+        for event in events.into_inner() {
+            accumulator.process(event, &|_| {});
+        }
+
+        let calls = accumulator.finalize();
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].id, "call_1");
+        assert_eq!(calls[0].name, "list_tables");
+        assert_eq!(calls[0].arguments["schema"], "public");
+    }
+
+    #[test]
+    fn responses_tool_arguments_are_not_duplicated_when_done_follows_delta() {
+        let mut accumulator = StreamingToolCallAccumulator::new();
+        let mut item_indices = HashMap::new();
+        let mut started_indices = HashSet::new();
+        let mut argument_indices = HashSet::new();
+        let mut next_index = 0;
+        let added = serde_json::json!({
+            "type": "response.output_item.added",
+            "output_index": 0,
+            "item": {
+                "id": "fc_1",
+                "type": "function_call",
+                "call_id": "call_1",
+                "name": "list_tables"
+            }
+        });
+        let done = serde_json::json!({
+            "type": "response.output_item.done",
+            "output_index": 0,
+            "item": {
+                "id": "fc_1",
+                "type": "function_call",
+                "call_id": "call_1",
+                "name": "list_tables",
+                "arguments": "{\"schema\":\"public\"}"
+            }
+        });
+
+        let events = RefCell::new(Vec::new());
+        emit_responses_function_call_item(
+            &added,
+            &mut item_indices,
+            &mut started_indices,
+            &mut argument_indices,
+            &mut next_index,
+            &|event| events.borrow_mut().push(event),
+        );
+        for event in events.take() {
+            accumulator.process(event, &|_| {});
+        }
+
+        let delta_index = item_indices.get("fc_1").copied().unwrap();
+        argument_indices.insert(delta_index);
+        accumulator.process(
+            StreamToolEvent::ToolCallDelta { index: delta_index, fragment: "{\"schema\":\"public\"}".to_string() },
+            &|_| {},
+        );
+
+        if let Some(index) = emit_responses_function_call_item(
+            &done,
+            &mut item_indices,
+            &mut started_indices,
+            &mut argument_indices,
+            &mut next_index,
+            &|event| events.borrow_mut().push(event),
+        ) {
+            events.borrow_mut().push(StreamToolEvent::ToolCallComplete { index });
+        }
+        for event in events.into_inner() {
+            accumulator.process(event, &|_| {});
+        }
+
+        let calls = accumulator.finalize();
+        assert_eq!(calls.len(), 1);
+        assert_eq!(calls[0].arguments, serde_json::json!({"schema": "public"}));
+    }
+
+    #[test]
+    fn detects_kimi_models_that_skip_extra_body_thinking_toggle() {
+        assert!(is_kimi_model("kimi-k2.7-code"));
+        assert!(is_kimi_model("kimi-k2.6"));
+        assert!(is_kimi_model("kimi-k2.5"));
+        assert!(is_kimi_model("kimi-k3"));
+
+        // Older K2 variants should not skip OpenAI-compatible thinking toggles.
+        assert!(!is_kimi_model("kimi-k2"));
+        assert!(!is_kimi_model("kimi-k2-thinking"));
+        assert!(!is_kimi_model("kimi-k2-0711-preview"));
+        assert!(!is_kimi_model("kimi-k2.4"));
+    }
+
+    #[test]
+    fn uses_max_completion_tokens_for_openai_reasoning_chat_completions() {
+        let mut config = AiConfig {
+            provider: AiProvider::Openai,
+            api_key: "key".to_string(),
+            auth_method: AiAuthMethod::Bearer,
+            endpoint: "https://api.openai.com/v1/chat/completions".to_string(),
+            model: "gpt-5.5".to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+
+        let mut body = serde_json::json!({
+            "model": &config.model,
+            "messages": [{ "role": "user", "content": TEST_PROMPT }],
+            "stream": true,
+        });
+        set_chat_completion_token_limit(&mut body, &config, 1024);
+
+        assert_eq!(body.get("max_completion_tokens"), Some(&serde_json::json!(1024)));
+        assert!(body.get("max_tokens").is_none());
+
+        config.model = "gpt-4o".to_string();
+        let mut body = serde_json::json!({
+            "model": &config.model,
+            "messages": [{ "role": "user", "content": TEST_PROMPT }],
+            "stream": true,
+        });
+        set_chat_completion_token_limit(&mut body, &config, 1024);
+
+        assert_eq!(body.get("max_tokens"), Some(&serde_json::json!(1024)));
+        assert!(body.get("max_completion_tokens").is_none());
+
+        config.endpoint = "http://localhost:11434/v1".to_string();
+        config.model = "gpt-5-proxy".to_string();
+        let mut body = serde_json::json!({
+            "model": &config.model,
+            "messages": [{ "role": "user", "content": TEST_PROMPT }],
+            "stream": true,
+        });
+        set_chat_completion_token_limit(&mut body, &config, 1024);
+
+        assert_eq!(body.get("max_completion_tokens"), Some(&serde_json::json!(1024)));
+        assert!(body.get("max_tokens").is_none());
+
+        config.provider = AiProvider::OpenaiCompatible;
+        config.endpoint = "http://localhost:11434/v1".to_string();
+        config.model = "gpt-5-local".to_string();
+        let mut body = serde_json::json!({
+            "model": &config.model,
+            "messages": [{ "role": "user", "content": TEST_PROMPT }],
+            "stream": true,
+        });
+        set_chat_completion_token_limit(&mut body, &config, 1024);
+
+        assert_eq!(body.get("max_tokens"), Some(&serde_json::json!(1024)));
+        assert!(body.get("max_completion_tokens").is_none());
+    }
+
+    #[test]
+    fn omits_extra_body_for_kimi_test_connection_body() {
+        let config = AiConfig {
+            provider: AiProvider::OpenaiCompatible,
+            api_key: "key".to_string(),
+            auth_method: AiAuthMethod::Bearer,
+            endpoint: "https://api.moonshot.cn/v1".to_string(),
+            model: "kimi-k2.5".to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: false,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+        let mut body = serde_json::json!({
+            "model": &config.model,
+            "messages": [{ "role": "user", "content": TEST_PROMPT }],
+            "max_tokens": 16,
+            "stream": true,
+        });
+
+        apply_chat_completion_thinking_toggle(&mut body, &config);
+
+        assert!(body.get("extra_body").is_none());
+        assert!(body.get("reasoning_effort").is_none());
+    }
+
+    #[test]
+    fn keeps_extra_body_thinking_toggle_for_other_compatible_providers() {
+        let config = AiConfig {
+            provider: AiProvider::OpenaiCompatible,
+            api_key: "key".to_string(),
+            auth_method: AiAuthMethod::Bearer,
+            endpoint: "https://example.com/v1".to_string(),
+            model: "qwen3".to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: false,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+        let mut body = serde_json::json!({ "model": &config.model });
+
+        apply_chat_completion_thinking_toggle(&mut body, &config);
+
+        assert_eq!(
+            body.get("extra_body"),
+            Some(&serde_json::json!({
+                "chat_template_kwargs": { "enable_thinking": false }
+            }))
+        );
+        assert!(body.get("reasoning_effort").is_none());
+    }
+
+    #[test]
+    fn uses_reasoning_effort_to_disable_ollama_thinking() {
+        let config = AiConfig {
+            provider: AiProvider::Ollama,
+            api_key: String::new(),
+            auth_method: AiAuthMethod::Bearer,
+            endpoint: "http://localhost:11434/v1".to_string(),
+            model: "deepseek-r1:14b".to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: false,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        };
+        let mut body = serde_json::json!({
+            "model": &config.model,
+            "messages": [{ "role": "user", "content": TEST_PROMPT }],
+        });
+
+        apply_chat_completion_thinking_toggle(&mut body, &config);
+
+        assert_eq!(body.get("reasoning_effort"), Some(&serde_json::json!("none")));
+        assert!(body.get("extra_body").is_none());
+    }
+
+    #[test]
+    fn parses_responses_text_from_current_and_nested_shapes() {
+        assert_eq!(
+            responses_text(&serde_json::json!({
+                "output_text": "SELECT 1;"
+            })),
+            "SELECT 1;"
+        );
+
+        assert_eq!(
+            responses_text(&serde_json::json!({
+                "output": [{
+                    "content": [{ "type": "output_text", "text": "SELECT 2;" }]
+                }]
+            })),
+            "SELECT 2;"
+        );
+    }
+
+    #[test]
+    fn parses_openai_compatible_proxy_response_shapes() {
+        assert_eq!(
+            openai_response_text(&serde_json::json!({
+                "choices": [{
+                    "message": {
+                        "content": [
+                            { "type": "text", "text": "SELECT " },
+                            { "type": "text", "text": "1;" }
+                        ]
+                    }
+                }]
+            })),
+            "SELECT 1;"
+        );
+
+        assert_eq!(
+            openai_stream_text(&serde_json::json!({
+                "type": "response.output_text.delta",
+                "delta": "SELECT 2;"
+            }))
+            .as_deref(),
+            Some("SELECT 2;")
+        );
+    }
+
+    #[test]
+    fn parses_ollama_openai_reasoning_stream_chunks() {
+        assert_eq!(
+            openai_stream_reasoning(&serde_json::json!({
+                "choices": [{ "delta": { "reasoning": "thinking..." } }]
+            })),
+            Some("thinking...")
+        );
+        assert_eq!(
+            openai_stream_reasoning(&serde_json::json!({
+                "choices": [{ "delta": { "thinking": "planning..." } }]
+            })),
+            Some("planning...")
+        );
+    }
+
+    #[test]
+    fn parses_gemini_text_and_provider_aliases() {
+        let data = serde_json::json!({
+            "candidates": [{
+                "content": {
+                    "parts": [
+                        { "text": "SELECT " },
+                        { "text": "1;" }
+                    ]
+                }
+            }]
+        });
+
+        assert_eq!(gemini_text(&data), "SELECT 1;");
+
+        let claude: AiConfig = serde_json::from_value(serde_json::json!({
+            "provider": "anthropic",
+            "apiKey": "key",
+            "endpoint": "https://api.anthropic.com/v1/messages",
+            "model": "claude-sonnet-4-20250514"
+        }))
+        .unwrap();
+
+        assert!(matches!(claude.provider, AiProvider::Claude));
+    }
+}
diff --git a/crates/dbx-core/src/ai_cli_agent.rs b/crates/dbx-core/src/ai_cli_agent.rs
new file mode 100644
index 0000000..f81eaa0
--- /dev/null
+++ b/crates/dbx-core/src/ai_cli_agent.rs
@@ -0,0 +1,543 @@
+use crate::agent_events::AgentEvent;
+use crate::ai::{AiMessage, AiModelInfo};
+use crate::token_usage::TokenUsage;
+use serde_json::Value;
+use std::ffi::OsStr;
+use std::process::Stdio;
+use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
+use tokio::process::Command;
+use tokio::sync::Notify;
+
+#[derive(Debug, Clone)]
+pub struct CliAgentRunOptions {
+    pub connection_id: String,
+    pub connection_name: String,
+    pub database: String,
+    pub agent_mode: bool,
+    pub allow_writes: bool,
+    pub allow_dangerous: bool,
+    pub mcp_server_command: Option<CliAgentCommandSpec>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CliAgentCommandSpec {
+    pub program: String,
+    pub args: Vec<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CliAgentJsonlDialect {
+    CodexExec,
+}
+
+pub struct CliAgentProcessSpec {
+    pub command: CliAgentCommandSpec,
+    pub env: Vec<(String, String)>,
+    pub stdin: Option<String>,
+    pub dialect: CliAgentJsonlDialect,
+    pub classify_spawn_error: fn(&str) -> String,
+    pub classify_run_error: fn(&str) -> String,
+}
+
+pub fn toml_string(value: &str) -> String {
+    serde_json::to_string(value).unwrap_or_else(|_| "\"\"".to_string())
+}
+
+pub fn toml_string_array(values: &[&str]) -> String {
+    let items = values.iter().map(|value| toml_string(value)).collect::<Vec<_>>().join(", ");
+    format!("[{items}]")
+}
+
+pub fn dbx_mcp_enabled_tools(agent_mode: bool) -> Vec<&'static str> {
+    let mut tools = vec!["dbx_list_connections", "dbx_list_tables", "dbx_describe_table", "dbx_get_schema_context"];
+    if agent_mode {
+        tools.push("dbx_execute_query");
+        tools.push("dbx_execute_redis_command");
+    }
+    tools
+}
+
+pub fn dbx_mcp_scope_env(options: &CliAgentRunOptions) -> Vec<(&'static str, String)> {
+    vec![
+        ("DBX_MCP_ALLOW_WRITES", if options.allow_writes { "1" } else { "0" }.to_string()),
+        ("DBX_MCP_ALLOW_DANGEROUS_SQL", if options.allow_dangerous { "1" } else { "0" }.to_string()),
+        ("DBX_MCP_SCOPE_CONNECTION_ID", options.connection_id.clone()),
+        ("DBX_MCP_SCOPE_CONNECTION_NAME", options.connection_name.clone()),
+        ("DBX_MCP_SCOPE_DATABASE", options.database.clone()),
+    ]
+}
+
+pub fn append_config_overrides(args: &mut Vec<String>, overrides: impl IntoIterator<Item = String>) {
+    for override_arg in overrides {
+        args.push("-c".to_string());
+        args.push(override_arg);
+    }
+}
+
+pub fn build_cli_agent_prompt(
+    provider_label: &str,
+    system_prompt: &str,
+    messages: &[AiMessage],
+    allow_write_sql: bool,
+) -> String {
+    let database_access = if allow_write_sql {
+        "The user explicitly confirmed the proposed database change. DBX MCP tools may execute write and DDL SQL for this run only."
+    } else {
+        "Use the DBX MCP tools when you need live database schema or read-only query results."
+    };
+    let mut sections = vec![
+        format!("You are running inside DBX Desktop as the {provider_label} CLI provider."),
+        database_access.to_string(),
+        "Do not modify files or run shell commands. The DBX MCP server is the only intended tool surface.".to_string(),
+        String::new(),
+        "## System instructions".to_string(),
+        system_prompt.to_string(),
+        String::new(),
+        "## Conversation".to_string(),
+    ];
+
+    for message in messages {
+        sections.push(format!("### {}", message.role));
+        sections.push(message.content.clone());
+        if !message.tool_calls.is_empty() {
+            sections.push(format!("[Previous tool calls omitted from CLI replay: {}]", message.tool_calls.len()));
+        }
+        sections.push(String::new());
+    }
+
+    sections.join("\n")
+}
+
+pub fn model_infos(ids: &[&str]) -> Vec<AiModelInfo> {
+    ids.iter().map(|id| AiModelInfo { id: (*id).to_string(), display_name: None }).collect()
+}
+
+pub fn cli_command(program: impl AsRef<OsStr>) -> Command {
+    crate::process::new_tokio_command(program)
+}
+
+pub async fn list_json_models_or_default(
+    program: String,
+    args: impl IntoIterator<Item = String>,
+    default_models: &[&str],
+) -> Result<Vec<AiModelInfo>, String> {
+    let output = cli_command(program).args(args).output().await;
+
+    let Ok(output) = output else {
+        return Ok(model_infos(default_models));
+    };
+    if !output.status.success() {
+        return Ok(model_infos(default_models));
+    }
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let Ok(data) = serde_json::from_str::<Value>(&stdout) else {
+        return Ok(model_infos(default_models));
+    };
+
+    let mut models = Vec::new();
+    collect_model_ids(&data, &mut models);
+    models.sort();
+    models.dedup();
+
+    if models.is_empty() {
+        Ok(model_infos(default_models))
+    } else {
+        let mut result = vec![AiModelInfo { id: "default".to_string(), display_name: None }];
+        result.extend(models.into_iter().map(|id| AiModelInfo { id, display_name: None }));
+        Ok(result)
+    }
+}
+
+fn collect_model_ids(value: &Value, out: &mut Vec<String>) {
+    match value {
+        Value::Object(map) => {
+            if let Some(id) = map.get("id").and_then(Value::as_str).or_else(|| map.get("name").and_then(Value::as_str))
+            {
+                if !id.trim().is_empty() {
+                    out.push(id.to_string());
+                }
+            }
+            for child in map.values() {
+                collect_model_ids(child, out);
+            }
+        }
+        Value::Array(items) => {
+            for item in items {
+                collect_model_ids(item, out);
+            }
+        }
+        _ => {}
+    }
+}
+
+#[derive(Default)]
+struct ParsedCliAgentEvent {
+    events: Vec<AgentEvent>,
+    final_text: Option<String>,
+    error: Option<String>,
+}
+
+pub fn parse_cli_jsonl_event(line: &str, dialect: CliAgentJsonlDialect) -> Option<Vec<AgentEvent>> {
+    let parsed = parse_cli_jsonl_line(line, dialect);
+    if parsed.events.is_empty() {
+        None
+    } else {
+        Some(parsed.events)
+    }
+}
+
+fn parse_cli_jsonl_line(line: &str, dialect: CliAgentJsonlDialect) -> ParsedCliAgentEvent {
+    match dialect {
+        CliAgentJsonlDialect::CodexExec => parse_codex_jsonl_line(line),
+    }
+}
+
+fn parse_codex_jsonl_line(line: &str) -> ParsedCliAgentEvent {
+    let Ok(value) = serde_json::from_str::<Value>(line) else {
+        return ParsedCliAgentEvent::default();
+    };
+
+    let event_type = value.get("type").and_then(Value::as_str).unwrap_or_default();
+    match event_type {
+        "item.started" => parse_codex_item_started(&value),
+        "item.completed" => parse_codex_item_completed(&value),
+        "turn.completed" => parse_codex_turn_completed(&value),
+        "turn.failed" | "error" => {
+            let message = codex_error_message(&value);
+            ParsedCliAgentEvent {
+                error: Some(message.clone()),
+                events: vec![AgentEvent::Error { message }],
+                ..Default::default()
+            }
+        }
+        _ => ParsedCliAgentEvent::default(),
+    }
+}
+
+fn parse_codex_item_started(value: &Value) -> ParsedCliAgentEvent {
+    let item = &value["item"];
+    let item_type = item.get("type").and_then(Value::as_str).unwrap_or_default();
+    if is_mcp_tool_item(item_type) {
+        ParsedCliAgentEvent {
+            events: vec![AgentEvent::ToolCallStart {
+                tool_call_id: cli_item_id(item),
+                tool_name: cli_tool_name(item),
+                args: cli_tool_args(item),
+            }],
+            ..Default::default()
+        }
+    } else {
+        ParsedCliAgentEvent::default()
+    }
+}
+
+fn parse_codex_item_completed(value: &Value) -> ParsedCliAgentEvent {
+    let item = &value["item"];
+    let item_type = item.get("type").and_then(Value::as_str).unwrap_or_default();
+
+    if item_type == "agent_message" {
+        if let Some(text) = cli_text(item) {
+            return ParsedCliAgentEvent {
+                final_text: Some(text.clone()),
+                events: vec![AgentEvent::TextDelta { delta: text }],
+                ..Default::default()
+            };
+        }
+    }
+
+    if item_type == "reasoning" {
+        if let Some(text) = cli_text(item) {
+            return ParsedCliAgentEvent {
+                events: vec![AgentEvent::ReasoningDelta { delta: text }],
+                ..Default::default()
+            };
+        }
+    }
+
+    if is_mcp_tool_item(item_type) {
+        return ParsedCliAgentEvent {
+            events: vec![AgentEvent::ToolCallEnd {
+                tool_call_id: cli_item_id(item),
+                tool_name: cli_tool_name(item),
+                result: cli_tool_result(item),
+                is_error: item.get("status").and_then(Value::as_str).map(|status| status == "failed").unwrap_or(false),
+            }],
+            ..Default::default()
+        };
+    }
+
+    ParsedCliAgentEvent::default()
+}
+
+fn parse_codex_turn_completed(value: &Value) -> ParsedCliAgentEvent {
+    let usage = value.get("usage").and_then(|usage| {
+        let input =
+            usage.get("input_tokens").or_else(|| usage.get("prompt_tokens")).and_then(Value::as_u64).unwrap_or(0)
+                as u32;
+        let output =
+            usage.get("output_tokens").or_else(|| usage.get("completion_tokens")).and_then(Value::as_u64).unwrap_or(0)
+                as u32;
+        (input > 0 || output > 0).then_some(TokenUsage { input_tokens: input, output_tokens: output })
+    });
+
+    ParsedCliAgentEvent {
+        events: vec![AgentEvent::AgentEnd {
+            input_tokens: usage.as_ref().and_then(|u| (u.input_tokens > 0).then_some(u.input_tokens)),
+            output_tokens: usage.as_ref().and_then(|u| (u.output_tokens > 0).then_some(u.output_tokens)),
+        }],
+        ..Default::default()
+    }
+}
+
+fn is_mcp_tool_item(item_type: &str) -> bool {
+    item_type == "mcp_tool_call" || item_type == "mcp_tool" || item_type == "tool_call"
+}
+
+fn cli_item_id(item: &Value) -> String {
+    item.get("id")
+        .and_then(Value::as_str)
+        .or_else(|| item.get("call_id").and_then(Value::as_str))
+        .unwrap_or("cli-tool-call")
+        .to_string()
+}
+
+fn cli_tool_name(item: &Value) -> String {
+    item.get("tool_name")
+        .and_then(Value::as_str)
+        .or_else(|| item.get("tool").and_then(Value::as_str))
+        .or_else(|| item.get("name").and_then(Value::as_str))
+        .or_else(|| item.get("server_tool_name").and_then(Value::as_str))
+        .unwrap_or("cli_tool")
+        .to_string()
+}
+
+fn cli_tool_args(item: &Value) -> Value {
+    item.get("arguments")
+        .or_else(|| item.get("args"))
+        .or_else(|| item.get("input"))
+        .cloned()
+        .unwrap_or(Value::Object(Default::default()))
+}
+
+fn cli_tool_result(item: &Value) -> Value {
+    non_null_field(item, "result")
+        .or_else(|| non_null_field(item, "output"))
+        .or_else(|| non_null_field(item, "content"))
+        .or_else(|| non_null_field(item, "error"))
+        .cloned()
+        .unwrap_or(Value::Null)
+}
+
+fn non_null_field<'a>(value: &'a Value, key: &str) -> Option<&'a Value> {
+    value.get(key).filter(|field| !field.is_null())
+}
+
+fn cli_text(item: &Value) -> Option<String> {
+    item.get("text")
+        .and_then(Value::as_str)
+        .or_else(|| item.get("message").and_then(Value::as_str))
+        .or_else(|| item.get("content").and_then(Value::as_str))
+        .map(ToString::to_string)
+}
+
+fn codex_error_message(value: &Value) -> String {
+    value
+        .get("message")
+        .and_then(Value::as_str)
+        .or_else(|| value.get("error").and_then(Value::as_str))
+        .or_else(|| value.get("error").and_then(|e| e.get("message")).and_then(Value::as_str))
+        .unwrap_or("CLI agent failed")
+        .to_string()
+}
+
+pub async fn run_cli_jsonl_agent(
+    spec: CliAgentProcessSpec,
+    cancelled: &Notify,
+    on_event: impl Fn(AgentEvent) + Send + Sync + 'static,
+) -> Result<String, String> {
+    let mut command = cli_command(&spec.command.program);
+    let mut child = command
+        .args(&spec.command.args)
+        .envs(spec.env.iter().map(|(key, value)| (key.as_str(), value.as_str())))
+        .stdin(if spec.stdin.is_some() { Stdio::piped() } else { Stdio::null() })
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .spawn()
+        .map_err(|e| (spec.classify_spawn_error)(&e.to_string()))?;
+
+    if let Some(input) = spec.stdin {
+        let mut stdin = child.stdin.take().ok_or_else(|| "CLI agent stdin not available".to_string())?;
+        stdin.write_all(input.as_bytes()).await.map_err(|e| format!("Failed to write CLI agent stdin: {e}"))?;
+        stdin.shutdown().await.map_err(|e| format!("Failed to close CLI agent stdin: {e}"))?;
+    }
+
+    let stdout = child.stdout.take().ok_or_else(|| "Failed to capture CLI agent stdout".to_string())?;
+    let stderr = child.stderr.take().ok_or_else(|| "Failed to capture CLI agent stderr".to_string())?;
+    let mut lines = BufReader::new(stdout).lines();
+    let stderr_task = tokio::spawn(async move {
+        let mut reader = BufReader::new(stderr);
+        let mut buf = String::new();
+        let _ = reader.read_to_string(&mut buf).await;
+        buf
+    });
+
+    let mut final_text = String::new();
+    let mut saw_agent_end = false;
+    let mut terminal_error: Option<String> = None;
+
+    loop {
+        tokio::select! {
+            line = lines.next_line() => {
+                let line = match line {
+                    Ok(Some(line)) => line,
+                    Ok(None) => break,
+                    Err(e) => {
+                        terminal_error = Some(format!("CLI agent stream read failed: {e}"));
+                        let _ = child.kill().await;
+                        break;
+                    }
+                };
+                let parsed = parse_cli_jsonl_line(&line, spec.dialect);
+                if let Some(text) = parsed.final_text {
+                    final_text.push_str(&text);
+                }
+                for event in parsed.events {
+                    if matches!(event, AgentEvent::AgentEnd { .. }) {
+                        saw_agent_end = true;
+                    }
+                    on_event(event);
+                }
+                if let Some(error) = parsed.error {
+                    terminal_error = Some(error);
+                    let _ = child.kill().await;
+                    break;
+                }
+            }
+            _ = cancelled.notified() => {
+                terminal_error = Some("Agent loop cancelled".to_string());
+                let _ = child.kill().await;
+                break;
+            }
+        }
+    }
+
+    let status = child.wait().await.map_err(|e| format!("CLI agent wait failed: {e}"))?;
+    let stderr = stderr_task.await.unwrap_or_default();
+
+    if let Some(error) = terminal_error {
+        return Err(error);
+    }
+
+    if !status.success() {
+        return Err((spec.classify_run_error)(&stderr));
+    }
+
+    if !saw_agent_end {
+        on_event(AgentEvent::AgentEnd { input_tokens: None, output_tokens: None });
+    }
+
+    Ok(final_text)
+}
+
+#[cfg(all(test, unix))]
+mod tests {
+    use super::*;
+    use std::process::Command as StdCommand;
+    use std::time::{SystemTime, UNIX_EPOCH};
+    use tokio::time::{sleep, timeout, Duration};
+
+    fn classify_spawn_error(message: &str) -> String {
+        message.to_string()
+    }
+
+    fn classify_run_error(message: &str) -> String {
+        message.to_string()
+    }
+
+    fn process_is_alive(pid: &str) -> bool {
+        StdCommand::new("kill")
+            .args(["-0", pid])
+            .stdout(std::process::Stdio::null())
+            .stderr(std::process::Stdio::null())
+            .status()
+            .map(|status| status.success())
+            .unwrap_or(false)
+    }
+
+    #[tokio::test]
+    async fn jsonl_agent_applies_env_to_child() {
+        let spec = CliAgentProcessSpec {
+            command: CliAgentCommandSpec {
+                program: "sh".to_string(),
+                args: vec![
+                    "-c".to_string(),
+                    "printf '%s\n' \"{\\\"type\\\":\\\"item.completed\\\",\\\"item\\\":{\\\"type\\\":\\\"agent_message\\\",\\\"text\\\":\\\"$DBX_TEST_ENV\\\"}}\" \"{\\\"type\\\":\\\"turn.completed\\\"}\"".to_string(),
+                ],
+            },
+            env: vec![("DBX_TEST_ENV".to_string(), "from-env".to_string())],
+            stdin: None,
+            dialect: CliAgentJsonlDialect::CodexExec,
+            classify_spawn_error,
+            classify_run_error,
+        };
+
+        let result = run_cli_jsonl_agent(spec, &Notify::new(), |_| {}).await.unwrap();
+
+        assert_eq!(result, "from-env");
+    }
+
+    #[tokio::test]
+    async fn jsonl_agent_writes_stdin_to_child() {
+        let spec = CliAgentProcessSpec {
+            command: CliAgentCommandSpec {
+                program: "sh".to_string(),
+                args: vec![
+                    "-c".to_string(),
+                    "input=$(cat); printf '%s\n' \"{\\\"type\\\":\\\"item.completed\\\",\\\"item\\\":{\\\"type\\\":\\\"agent_message\\\",\\\"text\\\":\\\"$input\\\"}}\" \"{\\\"type\\\":\\\"turn.completed\\\"}\"".to_string(),
+                ],
+            },
+            env: Vec::new(),
+            stdin: Some("prompt from stdin".to_string()),
+            dialect: CliAgentJsonlDialect::CodexExec,
+            classify_spawn_error,
+            classify_run_error,
+        };
+
+        let result = run_cli_jsonl_agent(spec, &Notify::new(), |_| {}).await.unwrap();
+
+        assert_eq!(result, "prompt from stdin");
+    }
+
+    #[tokio::test]
+    async fn jsonl_error_kills_and_waits_for_child() {
+        let pid_file = std::env::temp_dir().join(format!(
+            "dbx-cli-agent-error-{}-{}",
+            std::process::id(),
+            SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos()
+        ));
+        let script = format!(
+            "echo $$ > {}; printf '%s\\n' '{{\"type\":\"turn.failed\",\"message\":\"boom\"}}'; exec sleep 30",
+            pid_file.display()
+        );
+
+        let spec = CliAgentProcessSpec {
+            command: CliAgentCommandSpec { program: "sh".to_string(), args: vec!["-c".to_string(), script] },
+            env: Vec::new(),
+            stdin: None,
+            dialect: CliAgentJsonlDialect::CodexExec,
+            classify_spawn_error,
+            classify_run_error,
+        };
+
+        let result = timeout(Duration::from_secs(3), run_cli_jsonl_agent(spec, &Notify::new(), |_| {}))
+            .await
+            .expect("runner should return after JSONL error");
+
+        assert_eq!(result.unwrap_err(), "boom");
+        sleep(Duration::from_millis(100)).await;
+        let pid = std::fs::read_to_string(&pid_file).expect("child pid should be captured");
+        assert!(!process_is_alive(pid.trim()));
+        let _ = std::fs::remove_file(pid_file);
+    }
+}
diff --git a/crates/dbx-core/src/ai_codex_cli.rs b/crates/dbx-core/src/ai_codex_cli.rs
new file mode 100644
index 0000000..27b788e
--- /dev/null
+++ b/crates/dbx-core/src/ai_codex_cli.rs
@@ -0,0 +1,1021 @@
+use crate::agent_events::AgentEvent;
+use crate::ai::{AiConfig, AiModelInfo, AiTestConnectionResult};
+use crate::ai_cli_agent::{
+    append_config_overrides, build_cli_agent_prompt, cli_command, dbx_mcp_enabled_tools, dbx_mcp_scope_env,
+    model_infos, parse_cli_jsonl_event, run_cli_jsonl_agent, toml_string, toml_string_array, CliAgentCommandSpec,
+    CliAgentJsonlDialect, CliAgentProcessSpec, CliAgentRunOptions,
+};
+use serde_json::Value;
+use std::collections::{BTreeMap, BTreeSet};
+use std::env;
+use std::path::{Path, PathBuf};
+use std::process::Stdio;
+use std::time::Instant;
+use tokio::sync::Notify;
+
+const DEFAULT_CODEX_MODELS: &[&str] = &["default", "gpt-5.5", "gpt-5.4-mini"];
+#[cfg(not(windows))]
+const CODEX_PATH_MARKER: &str = "__DBX_CODEX_PATH__";
+
+pub type CodexRunOptions = CliAgentRunOptions;
+pub type CodexCommandSpec = CliAgentCommandSpec;
+
+fn codex_program(config: &AiConfig) -> String {
+    config.codex_cli_path.as_deref().map(str::trim).filter(|path| !path.is_empty()).unwrap_or("codex").to_string()
+}
+
+async fn resolve_codex_command(config: &AiConfig) -> CodexCommandSpec {
+    let configured = codex_program(config);
+    if is_path_like_program(&configured) {
+        let expanded = expand_tilde(&configured);
+        return codex_command_for_program(direct_program_path(&expanded).unwrap_or(expanded));
+    }
+    if let Some(path) = resolve_program_path(&configured).await {
+        codex_command_for_program(path)
+    } else {
+        CodexCommandSpec { program: configured, args: Vec::new() }
+    }
+}
+
+fn codex_command_for_program(program: String) -> CodexCommandSpec {
+    #[cfg(windows)]
+    if let Some(command) = windows_npm_codex_shim_command(&program) {
+        return command;
+    }
+
+    CodexCommandSpec { program, args: Vec::new() }
+}
+
+#[cfg(windows)]
+fn windows_npm_codex_shim_command(program: &str) -> Option<CodexCommandSpec> {
+    let path = Path::new(program);
+    let extension = path.extension()?.to_str()?.to_ascii_lowercase();
+    if extension != "cmd" && extension != "bat" {
+        return None;
+    }
+
+    let parent = path.parent()?;
+    let codex_js = parent.join("node_modules").join("@openai").join("codex").join("bin").join("codex.js");
+    if !codex_js.is_file() {
+        return None;
+    }
+
+    let bundled_node = parent.join("node.exe");
+    let node = if bundled_node.is_file() { bundled_node.to_string_lossy().to_string() } else { "node".to_string() };
+
+    Some(CodexCommandSpec { program: node, args: vec![codex_js.to_string_lossy().to_string()] })
+}
+
+fn codex_process_env(config: &AiConfig, command: &CodexCommandSpec) -> Result<Vec<(String, String)>, String> {
+    let mut env = BTreeMap::from_iter(codex_cli_env(config)?);
+    if let Some(dir) = command.parent_dir() {
+        let user_path = env.get("PATH").map(String::as_str);
+        env.insert("PATH".to_string(), merged_path_with_dir(&dir, user_path));
+    }
+    Ok(env.into_iter().collect())
+}
+
+trait CommandParentDir {
+    fn parent_dir(&self) -> Option<String>;
+}
+
+impl CommandParentDir for CodexCommandSpec {
+    fn parent_dir(&self) -> Option<String> {
+        Path::new(&self.program)
+            .parent()
+            .filter(|parent| !parent.as_os_str().is_empty())
+            .map(|parent| parent.to_string_lossy().to_string())
+    }
+}
+
+async fn resolve_program_path(program: &str) -> Option<String> {
+    if let Some(path) = direct_program_path(program) {
+        return Some(path);
+    }
+    if let Some(path) = common_program_path(program) {
+        return Some(path);
+    }
+    shell_program_path(program).await
+}
+
+fn direct_program_path(program: &str) -> Option<String> {
+    let path = Path::new(program);
+    if !path.is_absolute() {
+        return None;
+    }
+
+    if path.is_dir() {
+        return launchable_program_in_dir(path, "codex");
+    }
+
+    if path.is_file() {
+        #[cfg(windows)]
+        return windows_launchable_program_path(path);
+        #[cfg(not(windows))]
+        return Some(path.to_string_lossy().to_string());
+    }
+
+    None
+}
+
+fn launchable_program_in_dir(dir: &Path, program: &str) -> Option<String> {
+    program_path_candidates(dir, program)
+        .into_iter()
+        .find(|candidate| is_launchable_program_path(candidate) && candidate.is_file())
+        .map(|path| path.to_string_lossy().to_string())
+}
+
+#[cfg(windows)]
+fn windows_launchable_program_path(path: &Path) -> Option<String> {
+    if is_windows_launchable_program(path) {
+        return Some(path.to_string_lossy().to_string());
+    }
+    let parent = path.parent()?;
+    let stem = path.file_name()?.to_str()?;
+    program_path_candidates(parent, stem)
+        .into_iter()
+        .find(|candidate| is_windows_launchable_program(candidate))
+        .and_then(|candidate| candidate.is_file().then(|| candidate.to_string_lossy().to_string()))
+}
+
+#[cfg(windows)]
+fn is_windows_launchable_program(path: &Path) -> bool {
+    matches!(
+        path.extension().and_then(|extension| extension.to_str()).map(str::to_ascii_lowercase).as_deref(),
+        Some("exe" | "cmd" | "bat" | "com")
+    )
+}
+
+fn common_program_path(program: &str) -> Option<String> {
+    common_executable_dirs()
+        .into_iter()
+        .flat_map(|dir| program_path_candidates(&dir, program))
+        .filter(|path| is_launchable_program_path(path))
+        .find(|path| path.is_file())
+        .map(|path| path.to_string_lossy().to_string())
+}
+
+#[cfg(not(windows))]
+fn is_launchable_program_path(_path: &Path) -> bool {
+    true
+}
+
+#[cfg(windows)]
+fn is_launchable_program_path(path: &Path) -> bool {
+    is_windows_launchable_program(path)
+}
+
+#[cfg(not(windows))]
+fn program_path_candidates(dir: &Path, program: &str) -> Vec<PathBuf> {
+    vec![dir.join(program)]
+}
+
+#[cfg(windows)]
+fn program_path_candidates(dir: &Path, program: &str) -> Vec<PathBuf> {
+    let path = Path::new(program);
+    if path.extension().is_some() {
+        return vec![dir.join(program)];
+    }
+    [".cmd", ".exe", ".bat", ".com", "", ".ps1"]
+        .iter()
+        .map(|extension| dir.join(format!("{program}{extension}")))
+        .collect()
+}
+
+#[cfg(not(windows))]
+async fn shell_program_path(program: &str) -> Option<String> {
+    let script = shell_resolve_script(program);
+    let mut command = cli_command(user_shell());
+    command.args(user_shell_args(&script));
+    command.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
+    let output = command.output().await.ok()?;
+    output.status.success().then_some(())?;
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    stdout
+        .find(CODEX_PATH_MARKER)
+        .and_then(|index| {
+            stdout[index + CODEX_PATH_MARKER.len()..].lines().map(str::trim).find(|line| !line.is_empty())
+        })
+        .filter(|path| Path::new(path).is_file())
+        .map(ToString::to_string)
+}
+
+#[cfg(windows)]
+async fn shell_program_path(program: &str) -> Option<String> {
+    let script = format!("(Get-Command -All {} -ErrorAction SilentlyContinue).Source", windows_shell_quote(program));
+    let mut command = cli_command("powershell.exe");
+    command.args(["-NoProfile", "-Command", &script]);
+    command.stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
+    let output = command.output().await.ok()?;
+    output.status.success().then_some(())?;
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    first_windows_program_path(&stdout)
+}
+
+#[cfg(windows)]
+fn first_windows_program_path(value: &str) -> Option<String> {
+    let paths = value.lines().map(str::trim).filter(|line| !line.is_empty()).collect::<Vec<_>>();
+    paths
+        .into_iter()
+        .find(|path| is_windows_launchable_program(Path::new(path)) && Path::new(path).is_file())
+        .map(ToOwned::to_owned)
+}
+
+#[cfg(windows)]
+fn windows_shell_quote(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+fn is_path_like_program(program: &str) -> bool {
+    program.contains('/') || program.contains('\\') || program.starts_with('~')
+}
+
+fn expand_tilde(path: &str) -> String {
+    crate::path_utils::expand_tilde(path)
+}
+
+fn common_executable_dirs() -> Vec<PathBuf> {
+    let mut dirs = Vec::new();
+    if let Ok(path) = env::var("PATH") {
+        dirs.extend(env::split_paths(&path));
+    }
+    #[cfg(windows)]
+    {
+        if let Ok(app_data) = env::var("APPDATA") {
+            dirs.push(PathBuf::from(app_data).join("npm"));
+        }
+    }
+    #[cfg(not(windows))]
+    {
+        dirs.extend([
+            PathBuf::from("/opt/homebrew/bin"),
+            PathBuf::from("/usr/local/bin"),
+            PathBuf::from("/usr/bin"),
+            PathBuf::from("/bin"),
+            PathBuf::from("/usr/sbin"),
+            PathBuf::from("/sbin"),
+        ]);
+    }
+    dirs
+}
+
+fn merged_path_with_dir(dir: &str, user_path: Option<&str>) -> String {
+    let mut seen = BTreeSet::new();
+    let mut dirs = vec![PathBuf::from(dir)];
+    if let Some(path) = user_path {
+        dirs.extend(env::split_paths(path));
+    }
+    dirs.extend(common_executable_dirs());
+    let paths = dirs.into_iter().filter(|path| seen.insert(path.clone())).collect::<Vec<_>>();
+    env::join_paths(paths).unwrap_or_default().to_string_lossy().to_string()
+}
+
+#[cfg(not(windows))]
+fn user_shell() -> String {
+    env::var("SHELL").ok().filter(|value| !value.trim().is_empty()).unwrap_or_else(|| {
+        if Path::new("/bin/zsh").exists() {
+            "/bin/zsh".to_string()
+        } else {
+            "/bin/sh".to_string()
+        }
+    })
+}
+
+#[cfg(not(windows))]
+fn user_shell_args(script: &str) -> Vec<String> {
+    let shell = user_shell();
+    let shell_name = Path::new(&shell).file_name().and_then(|value| value.to_str()).unwrap_or_default();
+    match shell_name {
+        "fish" => vec!["-l".to_string(), "-i".to_string(), "-c".to_string(), script.to_string()],
+        "bash" => vec![
+            "--noprofile".to_string(),
+            "--norc".to_string(),
+            "-i".to_string(),
+            "-c".to_string(),
+            bash_login_script(script),
+        ],
+        "sh" | "dash" => vec!["-ic".to_string(), script.to_string()],
+        "zsh" => vec!["-ilc".to_string(), script.to_string()],
+        _ => vec!["-lc".to_string(), script.to_string()],
+    }
+}
+
+#[cfg(not(windows))]
+fn bash_login_script(script: &str) -> String {
+    format!(
+        "for dbx_profile in ~/.bash_profile ~/.bash_login ~/.profile ~/.bashrc; do \
+         [ -r \"$dbx_profile\" ] && . \"$dbx_profile\"; \
+         done; unset dbx_profile; {script}"
+    )
+}
+
+#[cfg(not(windows))]
+fn shell_resolve_script(program: &str) -> String {
+    format!("printf '%s\\n' {}; command -v {}", shell_quote(CODEX_PATH_MARKER), shell_quote(program))
+}
+
+#[cfg(not(windows))]
+fn shell_quote(value: &str) -> String {
+    if value.is_empty() {
+        return "''".to_string();
+    }
+    format!("'{}'", value.replace('\'', "'\"'\"'"))
+}
+
+fn validate_codex_program(config: &AiConfig) -> Result<String, String> {
+    let program = codex_program(config);
+    if starts_with_env_assignment(&program) {
+        return Err("[codexCliPathInvalid] Codex CLI path should contain only the executable path. Add environment variables in the Codex CLI environment variables section.".to_string());
+    }
+    if is_path_like_program(&program) {
+        let expanded = expand_tilde(&program);
+        let path = Path::new(&expanded);
+        if path.is_dir() && direct_program_path(&expanded).is_none() {
+            return Err("[codexCliPathInvalid] Codex CLI path should point to the Codex executable or a directory containing codex.".to_string());
+        }
+    }
+    Ok(program)
+}
+
+pub fn codex_cli_env(config: &AiConfig) -> Result<Vec<(String, String)>, String> {
+    let mut env = BTreeMap::new();
+    for (key, value) in &config.codex_cli_env {
+        let key = key.trim();
+        if key.is_empty() {
+            continue;
+        }
+        if !is_env_var_name(key) {
+            return Err(format!(
+                "[codexEnvInvalid] Invalid Codex CLI environment variable name `{key}`. Use names like HTTPS_PROXY."
+            ));
+        }
+        if is_reserved_dbx_mcp_env_name(key) {
+            return Err(format!(
+                "[codexEnvReserved] `{key}` is managed by DBX for the scoped MCP server and cannot be set here."
+            ));
+        }
+        env.insert(key.to_string(), value.clone());
+    }
+    Ok(env.into_iter().collect())
+}
+
+fn starts_with_env_assignment(program: &str) -> bool {
+    let Some(first_token) = program.split_whitespace().next() else {
+        return false;
+    };
+    let Some((key, _)) = first_token.split_once('=') else {
+        return false;
+    };
+    is_env_var_name(key)
+}
+
+fn is_env_var_name(name: &str) -> bool {
+    let mut chars = name.chars();
+    let Some(first) = chars.next() else {
+        return false;
+    };
+    (first == '_' || first.is_ascii_alphabetic()) && chars.all(|ch| ch == '_' || ch.is_ascii_alphanumeric())
+}
+
+fn is_reserved_dbx_mcp_env_name(name: &str) -> bool {
+    name.to_ascii_uppercase().starts_with("DBX_MCP_")
+}
+
+pub fn codex_enabled_tools(agent_mode: bool) -> Vec<&'static str> {
+    dbx_mcp_enabled_tools(agent_mode)
+}
+
+fn codex_mcp_config_overrides(options: &CodexRunOptions) -> Vec<String> {
+    let mcp_command =
+        options.mcp_server_command.as_ref().map(|command| command.program.as_str()).unwrap_or("dbx-mcp-server");
+    let mut overrides = vec![
+        format!("mcp_servers.dbx.command={}", toml_string(mcp_command)),
+        "mcp_servers.dbx.required=true".to_string(),
+        "mcp_servers.dbx.startup_timeout_sec=20".to_string(),
+        "mcp_servers.dbx.tool_timeout_sec=120".to_string(),
+        "mcp_servers.dbx.default_tools_approval_mode=\"approve\"".to_string(),
+        format!("mcp_servers.dbx.enabled_tools={}", toml_string_array(&dbx_mcp_enabled_tools(options.agent_mode))),
+    ];
+    if let Some(command) = options.mcp_server_command.as_ref().filter(|command| !command.args.is_empty()) {
+        let args = command.args.iter().map(String::as_str).collect::<Vec<_>>();
+        overrides.push(format!("mcp_servers.dbx.args={}", toml_string_array(&args)));
+    }
+    overrides.extend(
+        dbx_mcp_scope_env(options)
+            .into_iter()
+            .map(|(name, value)| format!("mcp_servers.dbx.env.{name}={}", toml_string(&value))),
+    );
+    overrides
+}
+
+pub fn build_codex_exec_command(config: &AiConfig, _prompt: &str, options: &CodexRunOptions) -> CodexCommandSpec {
+    let mut args = vec![
+        "exec".to_string(),
+        "--json".to_string(),
+        "--skip-git-repo-check".to_string(),
+        "--sandbox".to_string(),
+        "read-only".to_string(),
+    ];
+    let mut config_overrides = vec!["features.shell_tool=false".to_string(), "web_search=\"disabled\"".to_string()];
+    if let Some(reasoning_effort) = config.reasoning_level.as_codex_effort() {
+        config_overrides.push(format!("model_reasoning_effort={}", toml_string(reasoning_effort)));
+    }
+    append_config_overrides(&mut args, config_overrides.into_iter().chain(codex_mcp_config_overrides(options)));
+
+    let model = config.model.trim();
+    if !model.is_empty() && !model.eq_ignore_ascii_case("default") {
+        args.push("--model".to_string());
+        args.push(model.to_string());
+    }
+
+    args.push("-".to_string());
+
+    CodexCommandSpec { program: codex_program(config), args }
+}
+
+pub fn build_codex_prompt(system_prompt: &str, messages: &[crate::ai::AiMessage], allow_write_sql: bool) -> String {
+    build_cli_agent_prompt("Codex", system_prompt, messages, allow_write_sql)
+}
+
+pub async fn list_codex_models(config: &AiConfig) -> Result<Vec<AiModelInfo>, String> {
+    validate_codex_program(config)?;
+    let command = resolve_codex_command(config).await;
+    let output = cli_command(&command.program)
+        .args(command.args.iter().map(String::as_str))
+        .args(["debug", "models"])
+        .envs(codex_process_env(config, &command)?.iter().map(|(key, value)| (key.as_str(), value.as_str())))
+        .output()
+        .await;
+
+    let Ok(output) = output else {
+        return Ok(model_infos(DEFAULT_CODEX_MODELS));
+    };
+    if !output.status.success() {
+        return Ok(model_infos(DEFAULT_CODEX_MODELS));
+    }
+
+    Ok(parse_codex_models(&String::from_utf8_lossy(&output.stdout))
+        .unwrap_or_else(|| model_infos(DEFAULT_CODEX_MODELS)))
+}
+
+fn parse_codex_models(stdout: &str) -> Option<Vec<AiModelInfo>> {
+    let json_start = stdout.find('{')?;
+    let data = serde_json::from_str::<Value>(&stdout[json_start..]).ok()?;
+    let models = data.get("models").and_then(Value::as_array)?;
+
+    let mut result = vec![AiModelInfo { id: "default".to_string(), display_name: Some("Default".to_string()) }];
+    for model in models {
+        let Some(id) = model
+            .get("slug")
+            .and_then(Value::as_str)
+            .or_else(|| model.get("id").and_then(Value::as_str))
+            .map(str::trim)
+            .filter(|id| !id.is_empty())
+        else {
+            continue;
+        };
+        if result.iter().any(|existing| existing.id == id) {
+            continue;
+        }
+        let display_name = model
+            .get("display_name")
+            .and_then(Value::as_str)
+            .map(str::trim)
+            .filter(|name| !name.is_empty())
+            .map(ToString::to_string);
+        result.push(AiModelInfo { id: id.to_string(), display_name });
+    }
+
+    (result.len() > 1).then_some(result)
+}
+
+pub async fn test_codex_connection(config: &AiConfig) -> Result<AiTestConnectionResult, String> {
+    let start = Instant::now();
+    validate_codex_program(config)?;
+    let codex_command = resolve_codex_command(config).await;
+    let mut command = cli_command(&codex_command.program);
+    command.args(codex_command.args.iter().map(String::as_str));
+    command.args(["login", "status"]);
+    command.envs(codex_process_env(config, &codex_command)?.iter().map(|(key, value)| (key.as_str(), value.as_str())));
+
+    let output = command.output().await.map_err(|e| classify_codex_spawn_error(&e.to_string()))?;
+
+    if output.status.success() {
+        Ok(AiTestConnectionResult {
+            success: true,
+            message: format!("OK - {}ms", start.elapsed().as_millis()),
+            latency_ms: Some(start.elapsed().as_millis() as u64),
+            model_used: config.model.trim().to_string(),
+            error_category: None,
+        })
+    } else {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        Err(classify_codex_run_error(&stderr))
+    }
+}
+
+fn classify_codex_spawn_error(message: &str) -> String {
+    if message.contains("No such file") || message.contains("not found") {
+        "[codexNotInstalled] Codex CLI was not found. Install Codex CLI or set the Codex CLI path in DBX AI settings."
+            .to_string()
+    } else if is_command_line_too_long_error(message) {
+        "[codexCommandLineTooLong] Codex CLI command line is too long. Update DBX so Codex prompts are sent through stdin instead of process arguments."
+            .to_string()
+    } else {
+        format!("[codexRunFailed] Failed to start Codex CLI: {message}")
+    }
+}
+
+fn is_command_line_too_long_error(message: &str) -> bool {
+    let lower = message.to_ascii_lowercase();
+    message.contains("os error 206")
+        || message.contains("文件名或扩展名太长")
+        || lower.contains("filename or extension is too long")
+        || lower.contains("the filename or extension is too long")
+}
+
+fn classify_codex_run_error(stderr: &str) -> String {
+    let lower = stderr.to_ascii_lowercase();
+    if lower.contains("not authenticated") || lower.contains("login") || lower.contains("auth") {
+        format!("[codexNotAuthenticated] Codex CLI is not authenticated. Run `codex login` and try again. {stderr}")
+    } else if lower.contains("dbx-mcp-server") || lower.contains("enoent") {
+        format!("[dbxMcpMissing] DBX MCP server was not found. Install @dbx-app/mcp-server and try again. {stderr}")
+    } else if lower.contains("mcp") && (lower.contains("dbx") || lower.contains("server")) {
+        format!("[codexMcpStartupFailed] Codex could not start the DBX MCP server. {stderr}")
+    } else {
+        format!("[codexRunFailed] Codex CLI failed. {stderr}")
+    }
+}
+
+pub fn parse_codex_jsonl_event(line: &str) -> Option<Vec<AgentEvent>> {
+    parse_cli_jsonl_event(line, CliAgentJsonlDialect::CodexExec)
+}
+
+pub async fn run_codex_agent(
+    config: &AiConfig,
+    prompt: &str,
+    options: CodexRunOptions,
+    cancelled: &Notify,
+    on_event: impl Fn(AgentEvent) + Send + Sync + 'static,
+) -> Result<String, String> {
+    validate_codex_program(config)?;
+    let mut command = build_codex_exec_command(config, prompt, &options);
+    let resolved_command = resolve_codex_command(config).await;
+    command.program = resolved_command.program;
+    command.args.splice(0..0, resolved_command.args);
+    let env = codex_process_env(config, &command)?;
+    run_cli_jsonl_agent(
+        CliAgentProcessSpec {
+            command,
+            env,
+            stdin: Some(prompt.to_string()),
+            dialect: CliAgentJsonlDialect::CodexExec,
+            classify_spawn_error: classify_codex_spawn_error,
+            classify_run_error: classify_codex_run_error,
+        },
+        cancelled,
+        on_event,
+    )
+    .await
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(windows))]
+    use super::shell_quote;
+    use super::{
+        build_codex_exec_command, classify_codex_spawn_error, codex_cli_env, codex_enabled_tools, is_path_like_program,
+        parse_codex_jsonl_event, parse_codex_models, validate_codex_program, CodexRunOptions, DEFAULT_CODEX_MODELS,
+    };
+    #[cfg(not(windows))]
+    use super::{codex_process_env, common_executable_dirs, merged_path_with_dir};
+    #[cfg(windows)]
+    use super::{
+        direct_program_path, first_windows_program_path, program_path_candidates, resolve_codex_command,
+        windows_npm_codex_shim_command,
+    };
+    use crate::agent_events::AgentEvent;
+    use crate::ai::{AiApiStyle, AiAuthMethod, AiConfig, AiProvider, AiReasoningLevel};
+    use crate::ai_cli_agent::{model_infos, CliAgentCommandSpec};
+
+    fn codex_config(model: &str) -> AiConfig {
+        AiConfig {
+            provider: AiProvider::CodexCli,
+            api_key: String::new(),
+            auth_method: AiAuthMethod::Bearer,
+            endpoint: String::new(),
+            model: model.to_string(),
+            api_style: AiApiStyle::Completions,
+            proxy_enabled: false,
+            proxy_url: String::new(),
+            enable_thinking: true,
+            reasoning_level: AiReasoningLevel::Default,
+            context_window: None,
+            codex_cli_path: None,
+            codex_cli_env: Default::default(),
+        }
+    }
+
+    fn run_options() -> CodexRunOptions {
+        CodexRunOptions {
+            connection_id: "conn-1".to_string(),
+            connection_name: "local".to_string(),
+            database: "demo".to_string(),
+            agent_mode: true,
+            allow_writes: false,
+            allow_dangerous: false,
+            mcp_server_command: None,
+        }
+    }
+
+    #[test]
+    fn builds_codex_command_with_scoped_mcp_and_omits_default_model() {
+        let spec = build_codex_exec_command(&codex_config("default"), "hello", &run_options());
+
+        assert_eq!(spec.program, "codex");
+        assert!(spec.args.contains(&"--json".to_string()));
+        assert_eq!(spec.args.last().map(String::as_str), Some("-"));
+        assert!(!spec.args.contains(&"hello".to_string()));
+        assert!(!spec.args.contains(&"--model".to_string()));
+        assert!(!spec.args.contains(&"--ask-for-approval".to_string()));
+        assert!(spec.args.contains(&"mcp_servers.dbx.command=\"dbx-mcp-server\"".to_string()));
+        assert!(spec.args.contains(&"mcp_servers.dbx.default_tools_approval_mode=\"approve\"".to_string()));
+        assert!(spec.args.contains(&"mcp_servers.dbx.env.DBX_MCP_ALLOW_WRITES=\"0\"".to_string()));
+        assert!(spec.args.contains(&"mcp_servers.dbx.env.DBX_MCP_ALLOW_DANGEROUS_SQL=\"0\"".to_string()));
+        assert!(spec.args.contains(&"mcp_servers.dbx.env.DBX_MCP_SCOPE_CONNECTION_ID=\"conn-1\"".to_string()));
+        assert!(spec.args.iter().any(|arg| arg.contains("dbx_execute_query")));
+    }
+
+    #[test]
+    fn builds_codex_command_with_non_default_model_and_ask_tools() {
+        let mut options = run_options();
+        options.agent_mode = false;
+        let spec = build_codex_exec_command(&codex_config("gpt-5.5"), "hello", &options);
+
+        let model_pos = spec.args.iter().position(|arg| arg == "--model").unwrap();
+        assert_eq!(spec.args[model_pos + 1], "gpt-5.5");
+        assert!(!codex_enabled_tools(false).contains(&"dbx_execute_query"));
+        assert!(spec.args.iter().any(|arg| arg.contains("dbx_get_schema_context")));
+        assert!(!spec.args.iter().any(|arg| arg.contains("dbx_execute_query")));
+    }
+
+    #[test]
+    fn builds_codex_command_with_resolved_mcp_server_path() {
+        let mut options = run_options();
+        options.mcp_server_command = Some(CliAgentCommandSpec {
+            program: "/opt/dbx/bin/dbx-mcp-server".to_string(),
+            args: vec!["--stdio".to_string()],
+        });
+        let spec = build_codex_exec_command(&codex_config("default"), "hello", &options);
+
+        assert!(spec.args.contains(&"mcp_servers.dbx.command=\"/opt/dbx/bin/dbx-mcp-server\"".to_string()));
+        assert!(spec.args.contains(&"mcp_servers.dbx.args=[\"--stdio\"]".to_string()));
+    }
+
+    #[test]
+    fn builds_codex_command_with_reasoning_effort_override() {
+        let mut config = codex_config("default");
+        config.reasoning_level = AiReasoningLevel::High;
+        let spec = build_codex_exec_command(&config, "hello", &run_options());
+
+        assert!(!spec.args.contains(&"--reasoning-effort".to_string()));
+        assert!(spec.args.contains(&"model_reasoning_effort=\"high\"".to_string()));
+    }
+
+    #[test]
+    fn path_like_codex_programs_are_detected() {
+        assert!(is_path_like_program("/opt/homebrew/bin/codex"));
+        assert!(is_path_like_program("~/bin/codex"));
+        assert!(is_path_like_program(r"C:\Tools\codex.exe"));
+        assert!(!is_path_like_program("codex"));
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn windows_codex_lookup_prefers_cmd_over_extensionless_shim() {
+        let candidates = program_path_candidates(std::path::Path::new(r"C:\nvm4w\nodejs"), "codex");
+
+        assert_eq!(candidates[0], std::path::Path::new(r"C:\nvm4w\nodejs\codex.cmd"));
+        assert!(candidates.iter().position(|path| path == std::path::Path::new(r"C:\nvm4w\nodejs\codex")).unwrap() > 0);
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn windows_shell_lookup_prefers_launchable_command() {
+        let dir = std::env::temp_dir().join(format!("dbx-codex-test-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let extensionless = dir.join("codex");
+        let cmd = dir.join("codex.cmd");
+        std::fs::write(&extensionless, "#!/bin/sh\n").unwrap();
+        std::fs::write(&cmd, "@echo off\n").unwrap();
+
+        let output = format!("{}\n{}\n", extensionless.display(), cmd.display());
+        let resolved = first_windows_program_path(&output).unwrap();
+
+        assert_eq!(resolved, cmd.to_string_lossy());
+        let _ = std::fs::remove_file(extensionless);
+        let _ = std::fs::remove_file(cmd);
+        let _ = std::fs::remove_dir(dir);
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn windows_direct_extensionless_path_uses_cmd_sibling() {
+        let dir = std::env::temp_dir().join(format!("dbx-codex-direct-test-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let extensionless = dir.join("codex");
+        let cmd = dir.join("codex.cmd");
+        std::fs::write(&extensionless, "#!/bin/sh\n").unwrap();
+        std::fs::write(&cmd, "@echo off\n").unwrap();
+
+        let resolved = direct_program_path(extensionless.to_string_lossy().as_ref()).unwrap();
+
+        assert_eq!(resolved, cmd.to_string_lossy().as_ref());
+        let _ = std::fs::remove_file(extensionless);
+        let _ = std::fs::remove_file(cmd);
+        let _ = std::fs::remove_dir(dir);
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn windows_direct_extensionless_path_is_not_launchable_without_sibling() {
+        let dir = std::env::temp_dir().join(format!("dbx-codex-direct-missing-test-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let extensionless = dir.join("codex");
+        std::fs::write(&extensionless, "#!/bin/sh\n").unwrap();
+
+        let resolved = direct_program_path(extensionless.to_string_lossy().as_ref());
+
+        assert!(resolved.is_none());
+        let _ = std::fs::remove_file(extensionless);
+        let _ = std::fs::remove_dir(dir);
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn windows_direct_directory_path_uses_codex_cmd_inside() {
+        let dir = std::env::temp_dir().join(format!("dbx-codex-direct-dir-test-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let extensionless = dir.join("codex");
+        let cmd = dir.join("codex.cmd");
+        std::fs::write(&extensionless, "#!/bin/sh\n").unwrap();
+        std::fs::write(&cmd, "@echo off\n").unwrap();
+
+        let resolved = direct_program_path(dir.to_string_lossy().as_ref()).unwrap();
+
+        assert_eq!(resolved, cmd.to_string_lossy().as_ref());
+        let _ = std::fs::remove_file(extensionless);
+        let _ = std::fs::remove_file(cmd);
+        let _ = std::fs::remove_dir(dir);
+    }
+
+    #[tokio::test]
+    #[cfg(windows)]
+    async fn windows_configured_nvm_directory_resolves_codex_cmd_shim() {
+        let dir = std::env::temp_dir().join(format!("dbx-codex-nvm-dir-test-{}", std::process::id()));
+        let bin_dir = dir.join("node_modules").join("@openai").join("codex").join("bin");
+        std::fs::create_dir_all(&bin_dir).unwrap();
+        let cmd = dir.join("codex.cmd");
+        let node = dir.join("node.exe");
+        let codex_js = bin_dir.join("codex.js");
+        std::fs::write(&cmd, "@echo off\nnode codex.js %*\n").unwrap();
+        std::fs::write(&node, "").unwrap();
+        std::fs::write(&codex_js, "#!/usr/bin/env node\n").unwrap();
+
+        let mut config = codex_config("default");
+        config.codex_cli_path = Some(dir.to_string_lossy().to_string());
+
+        let command = resolve_codex_command(&config).await;
+
+        assert_eq!(command.program, node.to_string_lossy().as_ref());
+        assert_eq!(command.args, vec![codex_js.to_string_lossy().to_string()]);
+        let _ = std::fs::remove_file(cmd);
+        let _ = std::fs::remove_file(node);
+        let _ = std::fs::remove_file(codex_js);
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[test]
+    #[cfg(windows)]
+    fn windows_npm_codex_cmd_shim_uses_node_directly() {
+        let dir = std::env::temp_dir().join(format!("dbx-codex-npm-shim-test-{}", std::process::id()));
+        let bin_dir = dir.join("node_modules").join("@openai").join("codex").join("bin");
+        std::fs::create_dir_all(&bin_dir).unwrap();
+        let cmd = dir.join("codex.cmd");
+        let node = dir.join("node.exe");
+        let codex_js = bin_dir.join("codex.js");
+        std::fs::write(&cmd, "@echo off\nnode codex.js %*\n").unwrap();
+        std::fs::write(&node, "").unwrap();
+        std::fs::write(&codex_js, "#!/usr/bin/env node\n").unwrap();
+
+        let command = windows_npm_codex_shim_command(cmd.to_string_lossy().as_ref()).unwrap();
+
+        assert_eq!(command.program, node.to_string_lossy().as_ref());
+        assert_eq!(command.args, vec![codex_js.to_string_lossy().to_string()]);
+        let _ = std::fs::remove_file(cmd);
+        let _ = std::fs::remove_file(node);
+        let _ = std::fs::remove_file(codex_js);
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[test]
+    #[cfg(not(windows))]
+    fn common_codex_lookup_dirs_include_homebrew_and_system_paths() {
+        let dirs = common_executable_dirs();
+
+        assert!(dirs.iter().any(|dir| dir == std::path::Path::new("/opt/homebrew/bin")));
+        assert!(dirs.iter().any(|dir| dir == std::path::Path::new("/usr/local/bin")));
+        assert!(dirs.iter().any(|dir| dir == std::path::Path::new("/usr/bin")));
+    }
+
+    #[test]
+    #[cfg(not(windows))]
+    fn codex_command_env_prepends_resolved_program_dir_and_keeps_node_dirs() {
+        let config = codex_config("default");
+        let command = CliAgentCommandSpec { program: "/opt/homebrew/bin/codex".to_string(), args: Vec::new() };
+        let env = codex_process_env(&config, &command).unwrap();
+        let path = env.iter().find(|(key, _)| key == "PATH").map(|(_, value)| value).unwrap();
+        let dirs = std::env::split_paths(path).collect::<Vec<_>>();
+
+        assert_eq!(dirs.first().unwrap(), std::path::Path::new("/opt/homebrew/bin"));
+        assert!(dirs.iter().any(|dir| dir == std::path::Path::new("/usr/bin")));
+    }
+
+    #[test]
+    #[cfg(not(windows))]
+    fn merged_path_deduplicates_codex_dir() {
+        let path = merged_path_with_dir("/opt/homebrew/bin", None);
+        let dirs = std::env::split_paths(&path).collect::<Vec<_>>();
+        let count = dirs.iter().filter(|dir| *dir == std::path::Path::new("/opt/homebrew/bin")).count();
+
+        assert_eq!(count, 1);
+    }
+
+    #[test]
+    #[cfg(not(windows))]
+    fn codex_process_env_keeps_resolved_program_dir_before_user_path() {
+        let mut config = codex_config("default");
+        config.codex_cli_env.insert("PATH".to_string(), "/custom/bin:/usr/bin".to_string());
+        let command = CliAgentCommandSpec { program: "/opt/homebrew/bin/codex".to_string(), args: Vec::new() };
+
+        let env = codex_process_env(&config, &command).unwrap();
+        let path = env.iter().find(|(key, _)| key == "PATH").map(|(_, value)| value).unwrap();
+        let dirs = std::env::split_paths(path).collect::<Vec<_>>();
+
+        assert_eq!(dirs.first().unwrap(), std::path::Path::new("/opt/homebrew/bin"));
+        assert!(dirs.iter().any(|dir| dir == std::path::Path::new("/custom/bin")));
+    }
+
+    #[test]
+    #[cfg(not(windows))]
+    fn shell_quote_handles_codex_program_names() {
+        assert_eq!(shell_quote("codex"), "'codex'");
+        assert_eq!(shell_quote("can't"), "'can'\"'\"'t'");
+    }
+
+    #[test]
+    fn default_model_list_matches_plan() {
+        assert_eq!(model_infos(DEFAULT_CODEX_MODELS), model_infos(&["default", "gpt-5.5", "gpt-5.4-mini"]));
+    }
+
+    #[test]
+    fn normalizes_codex_cli_env() {
+        let mut config = codex_config("default");
+        config.codex_cli_env.insert(" HTTPS_PROXY ".to_string(), "http://proxy:9800".to_string());
+        config.codex_cli_env.insert("NO_PROXY".to_string(), "localhost,127.0.0.1".to_string());
+        config.codex_cli_env.insert("".to_string(), "ignored".to_string());
+
+        let env = codex_cli_env(&config).unwrap();
+
+        assert_eq!(
+            env,
+            vec![
+                ("HTTPS_PROXY".to_string(), "http://proxy:9800".to_string()),
+                ("NO_PROXY".to_string(), "localhost,127.0.0.1".to_string())
+            ]
+        );
+    }
+
+    #[test]
+    fn rejects_invalid_codex_cli_env_name() {
+        let mut config = codex_config("default");
+        config.codex_cli_env.insert("BAD-NAME".to_string(), "value".to_string());
+
+        let err = codex_cli_env(&config).unwrap_err();
+
+        assert!(err.contains("[codexEnvInvalid]"));
+    }
+
+    #[test]
+    fn rejects_reserved_dbx_mcp_env_name() {
+        let mut config = codex_config("default");
+        config.codex_cli_env.insert("DBX_MCP_ALLOW_DANGEROUS_SQL".to_string(), "1".to_string());
+
+        let err = codex_cli_env(&config).unwrap_err();
+
+        assert!(err.contains("[codexEnvReserved]"));
+    }
+
+    #[test]
+    fn rejects_shell_style_env_prefix_in_codex_cli_path() {
+        let mut config = codex_config("default");
+        config.codex_cli_path = Some("HTTPS_PROXY=http://proxy:9800 /opt/homebrew/bin/codex".to_string());
+
+        let err = validate_codex_program(&config).unwrap_err();
+
+        assert!(err.contains("[codexCliPathInvalid]"));
+        assert!(err.contains("environment variables section"));
+    }
+
+    #[test]
+    fn rejects_directory_without_codex_in_codex_cli_path() {
+        let dir = std::env::temp_dir().join(format!("dbx-codex-empty-dir-test-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let mut config = codex_config("default");
+        config.codex_cli_path = Some(dir.to_string_lossy().to_string());
+
+        let err = validate_codex_program(&config).unwrap_err();
+
+        assert!(err.contains("[codexCliPathInvalid]"));
+        let _ = std::fs::remove_dir(dir);
+    }
+
+    #[test]
+    fn parses_codex_model_catalog_without_service_tiers() {
+        let models = parse_codex_models(
+            r#"{"models":[{"slug":"gpt-5.5","display_name":"GPT-5.5","service_tiers":[{"id":"priority","name":"Priority"}]},{"slug":"gpt-5.4-mini","display_name":"GPT-5.4 mini"}]}"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            models.iter().map(|model| model.id.as_str()).collect::<Vec<_>>(),
+            vec!["default", "gpt-5.5", "gpt-5.4-mini"]
+        );
+        assert_eq!(models[1].display_name.as_deref(), Some("GPT-5.5"));
+        assert!(!models.iter().any(|model| model.id == "priority" || model.id == "Priority"));
+    }
+
+    #[test]
+    fn classifies_windows_command_line_too_long_spawn_error() {
+        let err = classify_codex_spawn_error("文件名或扩展名太长。 (os error 206)");
+
+        assert!(err.contains("[codexCommandLineTooLong]"));
+    }
+
+    #[test]
+    fn parses_codex_jsonl_events() {
+        assert!(parse_codex_jsonl_event(r#"{"type":"thread.started","thread_id":"t"}"#).is_none());
+
+        let started = parse_codex_jsonl_event(
+            r#"{"type":"item.started","item":{"id":"tool-1","type":"mcp_tool_call","tool_name":"dbx_list_tables","arguments":{"schema":"public"}}}"#,
+        )
+        .unwrap();
+        assert!(matches!(&started[0], AgentEvent::ToolCallStart { tool_name, .. } if tool_name == "dbx_list_tables"));
+
+        let completed = parse_codex_jsonl_event(
+            r#"{"type":"item.completed","item":{"id":"msg-1","type":"agent_message","text":"Done"}}"#,
+        )
+        .unwrap();
+        assert!(matches!(&completed[0], AgentEvent::TextDelta { delta } if delta == "Done"));
+
+        let tool_done = parse_codex_jsonl_event(
+            r#"{"type":"item.completed","item":{"id":"tool-1","type":"mcp_tool_call","tool_name":"dbx_list_tables","result":{"content":"users"}}}"#,
+        )
+        .unwrap();
+        assert!(
+            matches!(&tool_done[0], AgentEvent::ToolCallEnd { tool_name, is_error, .. } if tool_name == "dbx_list_tables" && !is_error)
+        );
+
+        let current_started = parse_codex_jsonl_event(
+            r#"{"type":"item.started","item":{"id":"item_0","type":"mcp_tool_call","server":"dbx","tool":"dbx_execute_query","arguments":{"sql":"SELECT 1"},"result":null,"error":null,"status":"in_progress"}}"#,
+        )
+        .unwrap();
+        assert!(
+            matches!(&current_started[0], AgentEvent::ToolCallStart { tool_name, args, .. } if tool_name == "dbx_execute_query" && args["sql"] == "SELECT 1")
+        );
+
+        let current_tool_done = parse_codex_jsonl_event(
+            r#"{"type":"item.completed","item":{"id":"item_0","type":"mcp_tool_call","server":"dbx","tool":"dbx_execute_query","arguments":{"sql":"SELECT 1"},"result":{"content":[{"type":"text","text":"ok"}],"structured_content":null},"error":null,"status":"completed"}}"#,
+        )
+        .unwrap();
+        assert!(
+            matches!(&current_tool_done[0], AgentEvent::ToolCallEnd { tool_name, result, is_error, .. } if tool_name == "dbx_execute_query" && result["content"][0]["text"] == "ok" && !is_error)
+        );
+
+        let current_tool_error = parse_codex_jsonl_event(
+            r#"{"type":"item.completed","item":{"id":"item_0","type":"mcp_tool_call","server":"dbx","tool":"dbx_execute_query","arguments":{"sql":"SELECT 1"},"result":null,"error":{"message":"user cancelled MCP tool call"},"status":"failed"}}"#,
+        )
+        .unwrap();
+        assert!(
+            matches!(&current_tool_error[0], AgentEvent::ToolCallEnd { tool_name, result, is_error, .. } if tool_name == "dbx_execute_query" && result["message"] == "user cancelled MCP tool call" && *is_error)
+        );
+
+        let turn_done =
+            parse_codex_jsonl_event(r#"{"type":"turn.completed","usage":{"input_tokens":12,"output_tokens":3}}"#)
+                .unwrap();
+        assert!(matches!(&turn_done[0], AgentEvent::AgentEnd { input_tokens: Some(12), output_tokens: Some(3) }));
+
+        let failed = parse_codex_jsonl_event(r#"{"type":"turn.failed","message":"boom"}"#).unwrap();
+        assert!(matches!(&failed[0], AgentEvent::Error { message } if message == "boom"));
+    }
+}
diff --git a/crates/dbx-core/src/cloud_sync.rs b/crates/dbx-core/src/cloud_sync.rs
new file mode 100644
index 0000000..9dc8743
--- /dev/null
+++ b/crates/dbx-core/src/cloud_sync.rs
@@ -0,0 +1,1468 @@
+use aes_gcm::{
+    aead::{rand_core::RngCore, Aead, OsRng},
+    Aes256Gcm, KeyInit, Nonce,
+};
+use argon2::{Algorithm, Argon2, Params, Version};
+use base64::{engine::general_purpose::STANDARD as BASE64, engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
+use chrono::Utc;
+use reqwest::{header, Client, Method, StatusCode, Url};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+use crate::ai::AiConfig;
+use crate::connection_secrets::{
+    MQ_AUTH_API_KEY_VALUE_KEY, MQ_AUTH_CLIENT_SECRET_KEY, MQ_AUTH_PASSWORD_KEY, MQ_AUTH_TOKEN_KEY,
+    MQ_TOKEN_SIGNING_KEY, NACOS_AUTH_PASSWORD_KEY,
+};
+use crate::models::connection::{ConnectionConfig, DatabaseType, TransportLayerConfig};
+use crate::saved_sql::SavedSqlLibrary;
+use crate::storage::{DesktopSettings, Storage};
+
+const SNAPSHOT_SCHEMA_VERSION: u32 = 1;
+const DEFAULT_REMOTE_PATH: &str = "DBX/sync/snapshot.json";
+const DEFAULT_SNIPPET_FILE_NAME: &str = "dbx-sync.json";
+const GITHUB_API_BASE: &str = "https://api.github.com";
+const GITEE_API_BASE: &str = "https://gitee.com/api/v5";
+const SECRET_KEYS: &[&str] = &[
+    "password",
+    "ssh_password",
+    "ssh_key_passphrase",
+    "proxy_password",
+    "redis_sentinel_password",
+    "connection_string",
+    MQ_AUTH_TOKEN_KEY,
+    MQ_AUTH_PASSWORD_KEY,
+    MQ_AUTH_API_KEY_VALUE_KEY,
+    MQ_AUTH_CLIENT_SECRET_KEY,
+    MQ_TOKEN_SIGNING_KEY,
+    NACOS_AUTH_PASSWORD_KEY,
+];
+const SSH_TUNNEL_SECRET_PREFIX: &str = "ssh_tunnels.";
+const TRANSPORT_LAYER_SECRET_PREFIX: &str = "transport_layers.";
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavConfig {
+    pub endpoint: String,
+    pub username: Option<String>,
+    pub password: Option<String>,
+    pub remote_path: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SnippetProvider {
+    #[serde(rename = "github", alias = "git_hub")]
+    GitHub,
+    #[serde(rename = "gitee")]
+    Gitee,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SnippetSyncConfig {
+    pub provider: SnippetProvider,
+    pub token: Option<String>,
+    pub snippet_id: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SnippetTokenStatus {
+    pub has_saved_token: bool,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavPasswordStatus {
+    pub has_saved_password: bool,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavSyncSecretsStatus {
+    pub enabled: bool,
+    pub has_saved_passphrase: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SyncSnapshot {
+    pub schema_version: u32,
+    pub exported_at: String,
+    pub app_version: String,
+    pub connections: Vec<ConnectionConfig>,
+    /// Shared tunnel profiles (secrets scrubbed). `None` means the snapshot
+    /// predates tunnel profiles — applying it leaves local profiles alone.
+    #[serde(default)]
+    pub tunnel_profiles: Option<Vec<TransportLayerConfig>>,
+    pub sidebar_layout: Option<serde_json::Value>,
+    pub pinned_tree_node_ids: Vec<String>,
+    pub saved_sql: SavedSqlLibrary,
+    pub desktop_settings: DesktopSettings,
+    pub editor_settings: Option<serde_json::Value>,
+    pub encrypted_secrets: Option<EncryptedSecretsBlob>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EncryptedSecretsBlob {
+    pub version: u32,
+    pub kdf: String,
+    pub cipher: String,
+    pub salt: String,
+    pub nonce: String,
+    pub ciphertext: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SensitiveSyncPayload {
+    pub connection_secrets: Vec<ConnectionSecretSnapshot>,
+    pub ai_config: Option<AiConfig>,
+    /// Full tunnel profiles including their secrets.
+    #[serde(default)]
+    pub tunnel_profiles: Option<Vec<TransportLayerConfig>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ConnectionSecretSnapshot {
+    pub connection_id: String,
+    pub key: String,
+    pub secret: String,
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct ApplySnapshotOptions<'a> {
+    pub secrets_passphrase: Option<&'a str>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApplySnapshotSummary {
+    pub encrypted_secrets_present: bool,
+    pub secrets_applied: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavSyncSummary {
+    pub remote_path: String,
+    pub bytes: usize,
+    pub exported_at: Option<String>,
+    pub app_version: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SnippetSyncSummary {
+    pub provider: SnippetProvider,
+    pub snippet_id: String,
+    pub bytes: usize,
+    pub exported_at: Option<String>,
+    pub app_version: Option<String>,
+}
+
+pub async fn build_sync_snapshot(
+    storage: &Storage,
+    app_version: impl Into<String>,
+    editor_settings: Option<serde_json::Value>,
+    secrets_passphrase: Option<&str>,
+) -> Result<SyncSnapshot, String> {
+    let mut connections = storage.load_connections().await?;
+    let mut tunnel_profiles = storage.load_tunnel_profiles().await?;
+    let encrypted_secrets = match normalized_passphrase(secrets_passphrase) {
+        Some(passphrase) => Some(encrypt_sensitive_payload(
+            &build_sensitive_payload(storage, &connections, &tunnel_profiles).await?,
+            passphrase,
+        )?),
+        None => None,
+    };
+    for config in &mut connections {
+        scrub_connection_secrets(config);
+    }
+    for profile in &mut tunnel_profiles {
+        profile.scrub_secrets();
+    }
+
+    Ok(SyncSnapshot {
+        schema_version: SNAPSHOT_SCHEMA_VERSION,
+        exported_at: Utc::now().to_rfc3339(),
+        app_version: app_version.into(),
+        connections,
+        tunnel_profiles: Some(tunnel_profiles),
+        sidebar_layout: storage.load_sidebar_layout().await?,
+        pinned_tree_node_ids: storage.load_pinned_tree_node_ids().await?,
+        saved_sql: storage.load_saved_sql_library().await?,
+        desktop_settings: storage.load_desktop_settings().await?,
+        editor_settings,
+        encrypted_secrets,
+    })
+}
+
+pub async fn build_sync_snapshot_with_saved_secrets(
+    storage: &Storage,
+    app_version: impl Into<String>,
+    editor_settings: Option<serde_json::Value>,
+    secrets_passphrase: Option<&str>,
+) -> Result<SyncSnapshot, String> {
+    match normalized_passphrase(secrets_passphrase) {
+        Some(passphrase) => build_sync_snapshot(storage, app_version, editor_settings, Some(passphrase)).await,
+        None => {
+            let saved_passphrase = resolve_webdav_sync_secrets_passphrase(storage).await?;
+            build_sync_snapshot(storage, app_version, editor_settings, saved_passphrase.as_deref()).await
+        }
+    }
+}
+
+pub async fn apply_sync_snapshot(
+    storage: &Storage,
+    snapshot: &SyncSnapshot,
+    options: ApplySnapshotOptions<'_>,
+) -> Result<ApplySnapshotSummary, String> {
+    if snapshot.schema_version != SNAPSHOT_SCHEMA_VERSION {
+        return Err(format!("Unsupported sync snapshot schema version: {}", snapshot.schema_version));
+    }
+
+    let encrypted_secrets_present = snapshot.encrypted_secrets.is_some();
+    let sensitive_payload = match (&snapshot.encrypted_secrets, normalized_passphrase(options.secrets_passphrase)) {
+        (Some(blob), Some(passphrase)) => Some(decrypt_sensitive_payload(blob, passphrase)?),
+        _ => None,
+    };
+
+    let mut connections = snapshot.connections.clone();
+    for config in &mut connections {
+        scrub_connection_secrets(config);
+    }
+
+    storage.save_connection_metadata_preserving_secrets(&connections).await?;
+    if let Some(profiles) = &snapshot.tunnel_profiles {
+        storage.save_tunnel_profiles_preserving_secrets(profiles).await?;
+    }
+    if let Some(layout) = &snapshot.sidebar_layout {
+        storage.save_sidebar_layout(layout).await?;
+    }
+    storage.save_pinned_tree_node_ids(&snapshot.pinned_tree_node_ids).await?;
+    storage.replace_saved_sql_library(&snapshot.saved_sql).await?;
+    storage.save_desktop_settings(&snapshot.desktop_settings).await?;
+    if let Some(payload) = &sensitive_payload {
+        clear_connection_secrets(storage, &connections).await?;
+        apply_sensitive_payload(storage, payload).await?;
+    }
+    Ok(ApplySnapshotSummary { encrypted_secrets_present, secrets_applied: sensitive_payload.is_some() })
+}
+
+pub struct WebDavClient {
+    http: Client,
+    config: WebDavConfig,
+}
+
+pub struct SnippetSyncClient {
+    http: Client,
+    config: SnippetSyncConfig,
+}
+
+pub async fn webdav_saved_password_status(
+    storage: &Storage,
+    config: &WebDavConfig,
+) -> Result<WebDavPasswordStatus, String> {
+    let account = webdav_password_account(config);
+    Ok(WebDavPasswordStatus { has_saved_password: storage.load_webdav_password_blob(&account).await?.is_some() })
+}
+
+pub async fn save_webdav_password(storage: &Storage, config: &WebDavConfig, password: &str) -> Result<(), String> {
+    let secret = storage.load_or_create_local_device_secret().await?;
+    let blob = encrypt_text_with_secret(password, &secret)?;
+    let value = serde_json::to_value(blob).map_err(|e| e.to_string())?;
+    storage.save_webdav_password_blob(&webdav_password_account(config), &value).await
+}
+
+pub async fn forget_webdav_password(storage: &Storage, config: &WebDavConfig) -> Result<(), String> {
+    storage.delete_webdav_password_blob(&webdav_password_account(config)).await
+}
+
+pub async fn resolve_webdav_password(storage: &Storage, config: &mut WebDavConfig) -> Result<(), String> {
+    if config.password.as_deref().is_some_and(|password| !password.is_empty()) {
+        return Ok(());
+    }
+    let Some(value) = storage.load_webdav_password_blob(&webdav_password_account(config)).await? else {
+        return Ok(());
+    };
+    let blob: EncryptedSecretsBlob = serde_json::from_value(value).map_err(|e| e.to_string())?;
+    let secret = storage.load_or_create_local_device_secret().await?;
+    config.password = Some(decrypt_text_with_secret(&blob, &secret)?);
+    Ok(())
+}
+
+pub async fn snippet_saved_token_status(
+    storage: &Storage,
+    config: &SnippetSyncConfig,
+) -> Result<SnippetTokenStatus, String> {
+    let account = snippet_token_account(config.provider);
+    Ok(SnippetTokenStatus { has_saved_token: storage.load_webdav_password_blob(&account).await?.is_some() })
+}
+
+pub async fn save_snippet_token(storage: &Storage, config: &SnippetSyncConfig, token: &str) -> Result<(), String> {
+    let secret = storage.load_or_create_local_device_secret().await?;
+    let blob = encrypt_text_with_secret(token, &secret)?;
+    let value = serde_json::to_value(blob).map_err(|e| e.to_string())?;
+    storage.save_webdav_password_blob(&snippet_token_account(config.provider), &value).await
+}
+
+pub async fn forget_snippet_token(storage: &Storage, config: &SnippetSyncConfig) -> Result<(), String> {
+    storage.delete_webdav_password_blob(&snippet_token_account(config.provider)).await
+}
+
+pub async fn resolve_snippet_token(storage: &Storage, config: &mut SnippetSyncConfig) -> Result<(), String> {
+    if config.token.as_deref().is_some_and(|token| !token.trim().is_empty()) {
+        return Ok(());
+    }
+    let Some(value) = storage.load_webdav_password_blob(&snippet_token_account(config.provider)).await? else {
+        return Ok(());
+    };
+    let blob: EncryptedSecretsBlob = serde_json::from_value(value).map_err(|e| e.to_string())?;
+    let secret = storage.load_or_create_local_device_secret().await?;
+    config.token = Some(decrypt_text_with_secret(&blob, &secret)?);
+    Ok(())
+}
+
+pub async fn webdav_sync_secrets_status(storage: &Storage) -> Result<WebDavSyncSecretsStatus, String> {
+    Ok(WebDavSyncSecretsStatus {
+        enabled: storage.load_webdav_sync_secrets_enabled().await?,
+        has_saved_passphrase: storage.load_webdav_sync_secrets_passphrase_blob().await?.is_some(),
+    })
+}
+
+pub async fn save_webdav_sync_secrets_preference(
+    storage: &Storage,
+    enabled: bool,
+    passphrase: Option<&str>,
+) -> Result<(), String> {
+    let normalized = normalized_passphrase(passphrase);
+    let blob = match normalized {
+        Some(passphrase) => {
+            let secret = storage.load_or_create_local_device_secret().await?;
+            let blob = encrypt_text_with_secret(passphrase, &secret)?;
+            Some(serde_json::to_value(blob).map_err(|e| e.to_string())?)
+        }
+        None => None,
+    };
+    storage.save_webdav_sync_secrets_preference(enabled, blob.as_ref()).await
+}
+
+pub async fn forget_webdav_sync_secrets_passphrase(storage: &Storage) -> Result<(), String> {
+    storage.delete_webdav_sync_secrets_passphrase_blob().await
+}
+
+pub async fn resolve_webdav_sync_secrets_passphrase(storage: &Storage) -> Result<Option<String>, String> {
+    if !storage.load_webdav_sync_secrets_enabled().await? {
+        return Ok(None);
+    }
+    let Some(value) = storage.load_webdav_sync_secrets_passphrase_blob().await? else {
+        return Ok(None);
+    };
+    let blob: EncryptedSecretsBlob = serde_json::from_value(value).map_err(|e| e.to_string())?;
+    let secret = storage.load_or_create_local_device_secret().await?;
+    decrypt_text_with_secret(&blob, &secret).map(Some)
+}
+
+impl WebDavClient {
+    pub fn new(config: WebDavConfig) -> Self {
+        Self { http: Client::new(), config }
+    }
+
+    pub fn remote_path(&self) -> String {
+        normalized_remote_path(self.config.remote_path.as_deref())
+    }
+
+    pub async fn test(&self) -> Result<(), String> {
+        let method = Method::from_bytes(b"PROPFIND").map_err(|e| e.to_string())?;
+        let response = self.request(method, "")?.header("Depth", "0").send().await.map_err(|e| e.to_string())?;
+        let status = response.status();
+        if status.is_success() {
+            Ok(())
+        } else {
+            Err(format!("WebDAV test failed with HTTP {status}"))
+        }
+    }
+
+    pub async fn put_snapshot(&self, snapshot: &SyncSnapshot) -> Result<WebDavSyncSummary, String> {
+        let remote_path = self.remote_path();
+        self.ensure_parent_collections(&remote_path).await?;
+        let bytes = serde_json::to_vec_pretty(snapshot).map_err(|e| e.to_string())?;
+        let response = self
+            .request(Method::PUT, &remote_path)?
+            .header(header::CONTENT_TYPE, "application/json")
+            .body(bytes.clone())
+            .send()
+            .await
+            .map_err(|e| e.to_string())?;
+        let status = response.status();
+        if !status.is_success() {
+            return Err(format!("WebDAV upload failed with HTTP {status}"));
+        }
+        Ok(WebDavSyncSummary {
+            remote_path,
+            bytes: bytes.len(),
+            exported_at: Some(snapshot.exported_at.clone()),
+            app_version: Some(snapshot.app_version.clone()),
+        })
+    }
+
+    pub async fn get_snapshot(&self) -> Result<(SyncSnapshot, WebDavSyncSummary), String> {
+        let remote_path = self.remote_path();
+        let response = self.request(Method::GET, &remote_path)?.send().await.map_err(|e| e.to_string())?;
+        let status = response.status();
+        if !status.is_success() {
+            return Err(format!("WebDAV download failed with HTTP {status}"));
+        }
+        let bytes = response.bytes().await.map_err(|e| e.to_string())?;
+        let snapshot: SyncSnapshot = serde_json::from_slice(&bytes).map_err(|e| e.to_string())?;
+        let summary = WebDavSyncSummary {
+            remote_path,
+            bytes: bytes.len(),
+            exported_at: Some(snapshot.exported_at.clone()),
+            app_version: Some(snapshot.app_version.clone()),
+        };
+        Ok((snapshot, summary))
+    }
+
+    async fn ensure_parent_collections(&self, remote_path: &str) -> Result<(), String> {
+        let method = Method::from_bytes(b"MKCOL").map_err(|e| e.to_string())?;
+        for parent in parent_collection_paths(remote_path) {
+            let response = self.request(method.clone(), &parent)?.send().await.map_err(|e| e.to_string())?;
+            let status = response.status();
+            if status.is_success() || status == StatusCode::METHOD_NOT_ALLOWED {
+                continue;
+            }
+            return Err(format!("Failed to create WebDAV collection '{parent}' with HTTP {status}"));
+        }
+        Ok(())
+    }
+
+    fn request(&self, method: Method, remote_path: &str) -> Result<reqwest::RequestBuilder, String> {
+        let url = self.remote_url(remote_path)?;
+        let mut request = self.http.request(method, url);
+        if let Some(username) = self.config.username.as_deref().filter(|value| !value.is_empty()) {
+            request = request.basic_auth(username, self.config.password.clone());
+        }
+        Ok(request)
+    }
+
+    fn remote_url(&self, remote_path: &str) -> Result<Url, String> {
+        let endpoint = self.config.endpoint.trim();
+        if endpoint.is_empty() {
+            return Err("WebDAV endpoint is required".to_string());
+        }
+        let base = if endpoint.ends_with('/') { endpoint.to_string() } else { format!("{endpoint}/") };
+        let base = Url::parse(&base).map_err(|e| e.to_string())?;
+        base.join(remote_path.trim_start_matches('/')).map_err(|e| e.to_string())
+    }
+}
+
+impl SnippetSyncClient {
+    pub fn new(config: SnippetSyncConfig) -> Self {
+        Self { http: Client::new(), config }
+    }
+
+    pub async fn test(&self) -> Result<(), String> {
+        self.require_token()?;
+        let url = match (self.config.provider, normalized_snippet_id(self.config.snippet_id.as_deref())) {
+            (SnippetProvider::GitHub, Some(id)) => format!("{GITHUB_API_BASE}/gists/{id}"),
+            (SnippetProvider::GitHub, None) => format!("{GITHUB_API_BASE}/user"),
+            (SnippetProvider::Gitee, Some(id)) => format!("{GITEE_API_BASE}/gists/{id}"),
+            (SnippetProvider::Gitee, None) => format!("{GITEE_API_BASE}/user"),
+        };
+        let response = self.request(Method::GET, &url)?.send().await.map_err(|e| e.to_string())?;
+        ensure_snippet_success(response.status(), "test")
+    }
+
+    pub async fn put_snapshot(&self, snapshot: &SyncSnapshot) -> Result<SnippetSyncSummary, String> {
+        self.require_token()?;
+        let bytes = serde_json::to_vec_pretty(snapshot).map_err(|e| e.to_string())?;
+        let content = String::from_utf8(bytes.clone()).map_err(|e| e.to_string())?;
+        let existing_id = normalized_snippet_id(self.config.snippet_id.as_deref());
+        let (method, url) = match (self.config.provider, existing_id) {
+            (SnippetProvider::GitHub, Some(id)) => (Method::PATCH, format!("{GITHUB_API_BASE}/gists/{id}")),
+            (SnippetProvider::GitHub, None) => (Method::POST, format!("{GITHUB_API_BASE}/gists")),
+            (SnippetProvider::Gitee, Some(id)) => (Method::PATCH, format!("{GITEE_API_BASE}/gists/{id}")),
+            (SnippetProvider::Gitee, None) => (Method::POST, format!("{GITEE_API_BASE}/gists")),
+        };
+
+        let response = match self.config.provider {
+            SnippetProvider::GitHub => {
+                let payload = serde_json::json!({
+                    "description": "DBX encrypted configuration sync",
+                    "public": false,
+                    "files": { DEFAULT_SNIPPET_FILE_NAME: { "content": content } }
+                });
+                self.request(method, &url)?.json(&payload).send().await
+            }
+            SnippetProvider::Gitee => {
+                let payload = gitee_snippet_payload(content);
+                // Gitee validates `files` as a nested object; form encoding turns it into a string and is rejected.
+                self.request(method, &url)?.json(&payload).send().await
+            }
+        }
+        .map_err(|e| e.to_string())?;
+        let status = response.status();
+        let response_body = response.text().await.map_err(|e| e.to_string())?;
+        ensure_snippet_response_success(status, "upload", &response_body)?;
+        let value: serde_json::Value = serde_json::from_str(&response_body).map_err(|e| e.to_string())?;
+        let snippet_id = snippet_response_id(&value)
+            .or_else(|| existing_id.map(str::to_string))
+            .ok_or_else(|| "Snippet API response did not include an id".to_string())?;
+        Ok(SnippetSyncSummary {
+            provider: self.config.provider,
+            snippet_id,
+            bytes: bytes.len(),
+            exported_at: Some(snapshot.exported_at.clone()),
+            app_version: Some(snapshot.app_version.clone()),
+        })
+    }
+
+    pub async fn get_snapshot(&self) -> Result<(SyncSnapshot, SnippetSyncSummary), String> {
+        self.require_token()?;
+        let snippet_id = normalized_snippet_id(self.config.snippet_id.as_deref())
+            .ok_or_else(|| "Snippet id is required for download".to_string())?;
+        let url = match self.config.provider {
+            SnippetProvider::GitHub => format!("{GITHUB_API_BASE}/gists/{snippet_id}"),
+            SnippetProvider::Gitee => format!("{GITEE_API_BASE}/gists/{snippet_id}"),
+        };
+        let response = self.request(Method::GET, &url)?.send().await.map_err(|e| e.to_string())?;
+        let status = response.status();
+        let response_body = response.text().await.map_err(|e| e.to_string())?;
+        ensure_snippet_response_success(status, "download", &response_body)?;
+        let value: serde_json::Value = serde_json::from_str(&response_body).map_err(|e| e.to_string())?;
+        let (content, raw_url) = snippet_file_content(&value, DEFAULT_SNIPPET_FILE_NAME)?;
+        let content = match content {
+            Some(content) => content,
+            None => {
+                let raw_url = raw_url.ok_or_else(|| "Snippet file content is unavailable".to_string())?;
+                let response = self.request(Method::GET, &raw_url)?.send().await.map_err(|e| e.to_string())?;
+                ensure_snippet_success(response.status(), "raw download")?;
+                response.text().await.map_err(|e| e.to_string())?
+            }
+        };
+        let snapshot: SyncSnapshot = serde_json::from_str(&content).map_err(|e| e.to_string())?;
+        let summary = SnippetSyncSummary {
+            provider: self.config.provider,
+            snippet_id: snippet_id.to_string(),
+            bytes: content.len(),
+            exported_at: Some(snapshot.exported_at.clone()),
+            app_version: Some(snapshot.app_version.clone()),
+        };
+        Ok((snapshot, summary))
+    }
+
+    fn require_token(&self) -> Result<&str, String> {
+        self.config
+            .token
+            .as_deref()
+            .map(str::trim)
+            .filter(|token| !token.is_empty())
+            .ok_or_else(|| "Access token is required".to_string())
+    }
+
+    fn request(&self, method: Method, url: &str) -> Result<reqwest::RequestBuilder, String> {
+        let token = self.require_token()?;
+        let request = self.http.request(method, url);
+        Ok(match self.config.provider {
+            SnippetProvider::GitHub => request
+                .header(header::ACCEPT, "application/vnd.github+json")
+                .header(header::USER_AGENT, "DBX")
+                .header("X-GitHub-Api-Version", "2022-11-28")
+                .bearer_auth(token),
+            // Gitee API v5 documents access_token as a request parameter rather than an Authorization header.
+            SnippetProvider::Gitee => request.query(&[("access_token", token)]),
+        })
+    }
+}
+
+fn scrub_connection_secrets(config: &mut ConnectionConfig) {
+    config.password.clear();
+    for layer in &mut config.transport_layers {
+        match layer {
+            TransportLayerConfig::Ssh(ssh) => {
+                ssh.password.clear();
+                ssh.key_passphrase.clear();
+            }
+            TransportLayerConfig::Proxy(proxy) => {
+                proxy.password.clear();
+            }
+            TransportLayerConfig::HttpTunnel(http) => {
+                http.token.clear();
+            }
+        }
+    }
+    config.redis_sentinel_password.clear();
+    config.connection_string = None;
+    scrub_mq_external_config_secrets(config);
+    scrub_nacos_auth_secrets(config);
+}
+
+fn webdav_password_account(config: &WebDavConfig) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update(config.endpoint.trim().as_bytes());
+    hasher.update(b"\n");
+    hasher.update(config.username.as_deref().unwrap_or("").trim().as_bytes());
+    URL_SAFE_NO_PAD.encode(hasher.finalize())
+}
+
+async fn build_sensitive_payload(
+    storage: &Storage,
+    connections: &[ConnectionConfig],
+    tunnel_profiles: &[TransportLayerConfig],
+) -> Result<SensitiveSyncPayload, String> {
+    let mut connection_secrets = Vec::new();
+    for config in connections {
+        push_secret(&mut connection_secrets, &config.id, "password", &config.password);
+        for (index, layer) in config.transport_layers.iter().enumerate() {
+            match layer {
+                TransportLayerConfig::Ssh(ssh) => {
+                    push_secret(
+                        &mut connection_secrets,
+                        &config.id,
+                        &transport_layer_ssh_password_key(index, layer),
+                        &ssh.password,
+                    );
+                    push_secret(
+                        &mut connection_secrets,
+                        &config.id,
+                        &transport_layer_ssh_key_passphrase_key(index, layer),
+                        &ssh.key_passphrase,
+                    );
+                }
+                TransportLayerConfig::Proxy(proxy) => {
+                    push_secret(
+                        &mut connection_secrets,
+                        &config.id,
+                        &transport_layer_proxy_password_key(index, layer),
+                        &proxy.password,
+                    );
+                }
+                TransportLayerConfig::HttpTunnel(http) => {
+                    push_secret(
+                        &mut connection_secrets,
+                        &config.id,
+                        &transport_layer_http_tunnel_token_key(index, layer),
+                        &http.token,
+                    );
+                }
+            }
+        }
+        push_secret(&mut connection_secrets, &config.id, "redis_sentinel_password", &config.redis_sentinel_password);
+        if let Some(connection_string) = &config.connection_string {
+            push_secret(&mut connection_secrets, &config.id, "connection_string", connection_string);
+        }
+        push_mq_external_config_secrets(&mut connection_secrets, config);
+        push_nacos_external_config_secrets(&mut connection_secrets, config);
+    }
+
+    Ok(SensitiveSyncPayload {
+        connection_secrets,
+        ai_config: storage.load_ai_config().await?,
+        tunnel_profiles: Some(tunnel_profiles.to_vec()),
+    })
+}
+
+fn push_mq_external_config_secrets(secrets: &mut Vec<ConnectionSecretSnapshot>, config: &ConnectionConfig) {
+    let Some(external_config) = config.external_config.as_ref() else {
+        return;
+    };
+    if let Some(auth) = external_config.get("auth").and_then(serde_json::Value::as_object) {
+        match auth.get("kind").and_then(serde_json::Value::as_str) {
+            Some("token") => push_json_secret(secrets, &config.id, MQ_AUTH_TOKEN_KEY, auth, "token"),
+            Some("basic") => push_json_secret(secrets, &config.id, MQ_AUTH_PASSWORD_KEY, auth, "password"),
+            Some("apiKey") | Some("api_key") | Some("apikey") => {
+                push_json_secret(secrets, &config.id, MQ_AUTH_API_KEY_VALUE_KEY, auth, "value")
+            }
+            Some("oauth2") => push_json_secret(secrets, &config.id, MQ_AUTH_CLIENT_SECRET_KEY, auth, "clientSecret"),
+            _ => {}
+        }
+    }
+    if let Some(signing) = external_config.get("tokenSigning").and_then(serde_json::Value::as_object) {
+        push_json_secret(secrets, &config.id, MQ_TOKEN_SIGNING_KEY, signing, "key");
+    }
+}
+
+fn scrub_mq_external_config_secrets(config: &mut ConnectionConfig) {
+    if config.db_type != DatabaseType::MessageQueue {
+        return;
+    }
+    let Some(external_config) = config.external_config.as_mut() else {
+        return;
+    };
+    if let Some(auth) = external_config.get_mut("auth").and_then(serde_json::Value::as_object_mut) {
+        match auth.get("kind").and_then(serde_json::Value::as_str) {
+            Some("token") => scrub_json_secret(auth, "token"),
+            Some("basic") => scrub_json_secret(auth, "password"),
+            Some("apiKey") | Some("api_key") | Some("apikey") => scrub_json_secret(auth, "value"),
+            Some("oauth2") => scrub_json_secret(auth, "clientSecret"),
+            _ => {}
+        }
+    }
+    if let Some(signing) = external_config.get_mut("tokenSigning").and_then(serde_json::Value::as_object_mut) {
+        scrub_json_secret(signing, "key");
+    }
+}
+
+fn push_nacos_external_config_secrets(secrets: &mut Vec<ConnectionSecretSnapshot>, config: &ConnectionConfig) {
+    if config.db_type != DatabaseType::Nacos {
+        return;
+    }
+    let Some(auth) = config
+        .external_config
+        .as_ref()
+        .and_then(|external_config| external_config.get("auth"))
+        .and_then(serde_json::Value::as_object)
+    else {
+        return;
+    };
+    if auth.get("kind").and_then(serde_json::Value::as_str) == Some("usernamePassword") {
+        push_json_secret(secrets, &config.id, NACOS_AUTH_PASSWORD_KEY, auth, "password");
+    }
+}
+
+fn push_json_secret(
+    secrets: &mut Vec<ConnectionSecretSnapshot>,
+    connection_id: &str,
+    key: &str,
+    object: &serde_json::Map<String, serde_json::Value>,
+    field: &str,
+) {
+    if let Some(secret) = object.get(field).and_then(serde_json::Value::as_str) {
+        push_secret(secrets, connection_id, key, secret);
+    }
+}
+
+fn push_secret(secrets: &mut Vec<ConnectionSecretSnapshot>, connection_id: &str, key: &str, secret: &str) {
+    if secret.is_empty() {
+        return;
+    }
+    secrets.push(ConnectionSecretSnapshot {
+        connection_id: connection_id.to_string(),
+        key: key.to_string(),
+        secret: secret.to_string(),
+    });
+}
+
+fn scrub_nacos_auth_secrets(config: &mut ConnectionConfig) {
+    if config.db_type != DatabaseType::Nacos {
+        return;
+    }
+    let Some(auth) = config
+        .external_config
+        .as_mut()
+        .and_then(|external_config| external_config.get_mut("auth"))
+        .and_then(serde_json::Value::as_object_mut)
+    else {
+        return;
+    };
+    if auth.get("kind").and_then(serde_json::Value::as_str) == Some("usernamePassword") && auth.contains_key("password")
+    {
+        scrub_json_secret(auth, "password");
+    }
+}
+
+fn scrub_json_secret(object: &mut serde_json::Map<String, serde_json::Value>, field: &str) {
+    if object.contains_key(field) {
+        object.insert(field.to_string(), serde_json::Value::String(String::new()));
+    }
+}
+
+async fn apply_sensitive_payload(storage: &Storage, payload: &SensitiveSyncPayload) -> Result<(), String> {
+    for secret in &payload.connection_secrets {
+        if !SECRET_KEYS.contains(&secret.key.as_str())
+            && !secret.key.starts_with(SSH_TUNNEL_SECRET_PREFIX)
+            && !secret.key.starts_with(TRANSPORT_LAYER_SECRET_PREFIX)
+        {
+            continue;
+        }
+        storage.set_secret(&secret.connection_id, &secret.key, &secret.secret).await?;
+    }
+    if let Some(ai_config) = &payload.ai_config {
+        storage.save_ai_config(ai_config).await?;
+    }
+    if let Some(profiles) = &payload.tunnel_profiles {
+        storage.save_tunnel_profiles(profiles).await?;
+    }
+    Ok(())
+}
+
+async fn clear_connection_secrets(storage: &Storage, connections: &[ConnectionConfig]) -> Result<(), String> {
+    for config in connections {
+        for key in SECRET_KEYS {
+            storage.delete_secret(&config.id, key).await?;
+        }
+        for (index, layer) in config.transport_layers.iter().enumerate() {
+            match layer {
+                TransportLayerConfig::Ssh(_) => {
+                    storage.delete_secret(&config.id, &transport_layer_ssh_password_key(index, layer)).await?;
+                    storage.delete_secret(&config.id, &transport_layer_ssh_key_passphrase_key(index, layer)).await?;
+                }
+                TransportLayerConfig::Proxy(_) => {
+                    storage.delete_secret(&config.id, &transport_layer_proxy_password_key(index, layer)).await?;
+                }
+                TransportLayerConfig::HttpTunnel(_) => {
+                    storage.delete_secret(&config.id, &transport_layer_http_tunnel_token_key(index, layer)).await?;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn transport_layer_secret_segment(index: usize, layer: &TransportLayerConfig) -> String {
+    let id = layer.id().trim();
+    if id.is_empty() {
+        index.to_string()
+    } else {
+        id.to_string()
+    }
+}
+
+fn transport_layer_ssh_password_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.ssh_password", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn transport_layer_ssh_key_passphrase_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.ssh_key_passphrase", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn transport_layer_proxy_password_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.proxy_password", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn transport_layer_http_tunnel_token_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.http_tunnel_token", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn encrypt_sensitive_payload(payload: &SensitiveSyncPayload, passphrase: &str) -> Result<EncryptedSecretsBlob, String> {
+    let plaintext = serde_json::to_vec(payload).map_err(|e| e.to_string())?;
+    encrypt_bytes_with_secret(&plaintext, passphrase)
+}
+
+fn decrypt_sensitive_payload(blob: &EncryptedSecretsBlob, passphrase: &str) -> Result<SensitiveSyncPayload, String> {
+    let plaintext = decrypt_bytes_with_secret(blob, passphrase)
+        .map_err(|_| "Failed to decrypt synced secrets. Check the sync password.".to_string())?;
+    serde_json::from_slice(&plaintext).map_err(|e| e.to_string())
+}
+
+fn encrypt_text_with_secret(value: &str, secret: &str) -> Result<EncryptedSecretsBlob, String> {
+    encrypt_bytes_with_secret(value.as_bytes(), secret)
+}
+
+fn decrypt_text_with_secret(blob: &EncryptedSecretsBlob, secret: &str) -> Result<String, String> {
+    let plaintext = decrypt_bytes_with_secret(blob, secret)?;
+    String::from_utf8(plaintext).map_err(|e| e.to_string())
+}
+
+fn encrypt_bytes_with_secret(plaintext: &[u8], secret: &str) -> Result<EncryptedSecretsBlob, String> {
+    let mut salt = [0u8; 16];
+    let mut nonce = [0u8; 12];
+    OsRng.fill_bytes(&mut salt);
+    OsRng.fill_bytes(&mut nonce);
+    let key = derive_secret_key(secret, &salt)?;
+    let cipher = Aes256Gcm::new_from_slice(&key).map_err(|e| e.to_string())?;
+    let ciphertext = cipher.encrypt(Nonce::from_slice(&nonce), plaintext).map_err(|e| e.to_string())?;
+    Ok(EncryptedSecretsBlob {
+        version: 1,
+        kdf: "argon2id".to_string(),
+        cipher: "aes-256-gcm".to_string(),
+        salt: BASE64.encode(salt),
+        nonce: BASE64.encode(nonce),
+        ciphertext: BASE64.encode(ciphertext),
+    })
+}
+
+fn decrypt_bytes_with_secret(blob: &EncryptedSecretsBlob, secret: &str) -> Result<Vec<u8>, String> {
+    if blob.version != 1 || blob.kdf != "argon2id" || blob.cipher != "aes-256-gcm" {
+        return Err("Unsupported encrypted secrets format".to_string());
+    }
+    let salt = BASE64.decode(&blob.salt).map_err(|e| e.to_string())?;
+    let nonce = BASE64.decode(&blob.nonce).map_err(|e| e.to_string())?;
+    let ciphertext = BASE64.decode(&blob.ciphertext).map_err(|e| e.to_string())?;
+    if nonce.len() != 12 {
+        return Err("Invalid encrypted secrets nonce".to_string());
+    }
+    let key = derive_secret_key(secret, &salt)?;
+    let cipher = Aes256Gcm::new_from_slice(&key).map_err(|e| e.to_string())?;
+    cipher
+        .decrypt(Nonce::from_slice(&nonce), ciphertext.as_ref())
+        .map_err(|_| "Failed to decrypt saved secret.".to_string())
+}
+
+fn derive_secret_key(passphrase: &str, salt: &[u8]) -> Result<[u8; 32], String> {
+    let params = Params::new(19 * 1024, 2, 1, Some(32)).map_err(|e| e.to_string())?;
+    let argon2 = Argon2::new(Algorithm::Argon2id, Version::V0x13, params);
+    let mut key = [0u8; 32];
+    argon2.hash_password_into(passphrase.as_bytes(), salt, &mut key).map_err(|e| e.to_string())?;
+    Ok(key)
+}
+
+fn normalized_passphrase(passphrase: Option<&str>) -> Option<&str> {
+    passphrase.map(str::trim).filter(|value| !value.is_empty())
+}
+
+fn normalized_snippet_id(snippet_id: Option<&str>) -> Option<&str> {
+    snippet_id.map(str::trim).filter(|value| !value.is_empty())
+}
+
+fn snippet_token_account(provider: SnippetProvider) -> String {
+    match provider {
+        SnippetProvider::GitHub => "snippet-token:github".to_string(),
+        SnippetProvider::Gitee => "snippet-token:gitee".to_string(),
+    }
+}
+
+fn ensure_snippet_success(status: StatusCode, operation: &str) -> Result<(), String> {
+    if status.is_success() {
+        Ok(())
+    } else {
+        Err(format!("Snippet {operation} failed with HTTP {status}"))
+    }
+}
+
+fn ensure_snippet_response_success(status: StatusCode, operation: &str, response_body: &str) -> Result<(), String> {
+    if status.is_success() {
+        return Ok(());
+    }
+    let message = serde_json::from_str::<serde_json::Value>(response_body)
+        .ok()
+        .and_then(|value| {
+            value
+                .get("message")
+                .or_else(|| value.get("error_description"))
+                .and_then(serde_json::Value::as_str)
+                .map(str::to_string)
+        })
+        .unwrap_or_else(|| response_body.trim().chars().take(300).collect());
+    if message.is_empty() {
+        Err(format!("Snippet {operation} failed with HTTP {status}"))
+    } else {
+        Err(format!("Snippet {operation} failed with HTTP {status}: {message}"))
+    }
+}
+
+fn snippet_response_id(value: &serde_json::Value) -> Option<String> {
+    if let Some(id) = value.get("id").and_then(serde_json::Value::as_str) {
+        return Some(id.to_string());
+    }
+    // Some Gitee endpoints historically document an array response despite returning one created snippet.
+    value.as_array()?.first()?.get("id")?.as_str().map(str::to_string)
+}
+
+fn gitee_snippet_payload(content: String) -> serde_json::Value {
+    serde_json::json!({
+        "description": "DBX configuration sync",
+        "public": false,
+        "files": { DEFAULT_SNIPPET_FILE_NAME: { "content": content } }
+    })
+}
+
+fn snippet_file_content(
+    value: &serde_json::Value,
+    file_name: &str,
+) -> Result<(Option<String>, Option<String>), String> {
+    let files = value.get("files").ok_or_else(|| "Snippet response did not include files".to_string())?;
+    let files = if let Some(value) = files.as_str() {
+        serde_json::from_str::<serde_json::Value>(value).map_err(|e| e.to_string())?
+    } else {
+        files.clone()
+    };
+    let file = files
+        .get(file_name)
+        .or_else(|| files.as_object().and_then(|files| files.values().next()))
+        .ok_or_else(|| format!("Snippet does not contain {file_name}"))?;
+    let truncated = file.get("truncated").and_then(serde_json::Value::as_bool).unwrap_or(false);
+    let content =
+        if truncated { None } else { file.get("content").and_then(serde_json::Value::as_str).map(str::to_string) };
+    let raw_url = file.get("raw_url").and_then(serde_json::Value::as_str).map(str::to_string);
+    Ok((content, raw_url))
+}
+
+fn normalized_remote_path(value: Option<&str>) -> String {
+    let value = value.unwrap_or(DEFAULT_REMOTE_PATH).trim().replace('\\', "/");
+    let mut parts: Vec<&str> = Vec::new();
+    for part in value.split('/') {
+        let part = part.trim();
+        if part.is_empty() || part == "." {
+            continue;
+        }
+        if part == ".." {
+            // Keep the WebDAV target inside the configured endpoint when users paste OS paths.
+            parts.pop();
+            continue;
+        }
+        parts.push(part);
+    }
+
+    if parts.is_empty() {
+        DEFAULT_REMOTE_PATH.to_string()
+    } else {
+        parts.join("/")
+    }
+}
+
+fn parent_collection_paths(remote_path: &str) -> Vec<String> {
+    let parts = remote_path.trim_matches('/').split('/').filter(|part| !part.is_empty()).collect::<Vec<_>>();
+    if parts.len() <= 1 {
+        return Vec::new();
+    }
+
+    let mut paths = Vec::with_capacity(parts.len() - 1);
+    for index in 1..parts.len() {
+        paths.push(parts[..index].join("/"));
+    }
+    paths
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        apply_sync_snapshot, build_sync_snapshot, build_sync_snapshot_with_saved_secrets, decrypt_sensitive_payload,
+        encrypt_sensitive_payload, forget_webdav_sync_secrets_passphrase, gitee_snippet_payload,
+        normalized_remote_path, parent_collection_paths, resolve_webdav_sync_secrets_passphrase,
+        save_webdav_sync_secrets_preference, scrub_connection_secrets, snippet_file_content, snippet_response_id,
+        webdav_sync_secrets_status, ApplySnapshotOptions, ConnectionSecretSnapshot, SensitiveSyncPayload,
+    };
+    use crate::connection_secrets::NACOS_AUTH_PASSWORD_KEY;
+    use crate::models::connection::{
+        default_redis_key_separator, ConnectionConfig, DatabaseType, SshTunnelConfig, TransportLayerConfig,
+    };
+    use crate::storage::Storage;
+
+    fn temp_db_path(name: &str) -> std::path::PathBuf {
+        std::env::temp_dir().join(format!("dbx-cloud-sync-{name}-{}.db", uuid::Uuid::new_v4()))
+    }
+
+    #[test]
+    fn gitee_snippet_payload_keeps_files_as_nested_object() {
+        let payload = gitee_snippet_payload("snapshot".to_string());
+
+        assert_eq!(payload["files"]["dbx-sync.json"]["content"], "snapshot");
+        assert!(payload["files"].is_object());
+        assert_eq!(payload["public"], false);
+    }
+
+    fn postgres_connection(id: &str, password: &str) -> ConnectionConfig {
+        ConnectionConfig {
+            id: id.to_string(),
+            name: "Postgres".to_string(),
+            db_type: DatabaseType::Postgres,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 5432,
+            username: "app".to_string(),
+            password: password.to_string(),
+            database: Some("app_db".to_string()),
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: 0,
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    fn nacos_connection(id: &str, password: &str) -> ConnectionConfig {
+        ConnectionConfig {
+            id: id.to_string(),
+            name: "Nacos".to_string(),
+            db_type: DatabaseType::Nacos,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 8848,
+            username: "nacos".to_string(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: 0,
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: Some(serde_json::json!({
+                "namespace": "public",
+                "group": "DEFAULT_GROUP",
+                "auth": {
+                    "kind": "usernamePassword",
+                    "username": "nacos",
+                    "password": password
+                }
+            })),
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    fn nacos_auth_password(config: &ConnectionConfig) -> Option<&str> {
+        config.external_config.as_ref()?.get("auth")?.get("password")?.as_str()
+    }
+
+    #[test]
+    fn normalizes_empty_remote_path_to_default() {
+        assert_eq!(normalized_remote_path(None), "DBX/sync/snapshot.json");
+        assert_eq!(normalized_remote_path(Some("")), "DBX/sync/snapshot.json");
+        assert_eq!(normalized_remote_path(Some("///\\\\//")), "DBX/sync/snapshot.json");
+    }
+
+    #[test]
+    fn normalizes_remote_path_separators() {
+        assert_eq!(normalized_remote_path(Some("/custom/snapshot.json")), "custom/snapshot.json");
+        assert_eq!(normalized_remote_path(Some(r"\DBX\sync\snapshot.json")), "DBX/sync/snapshot.json");
+        assert_eq!(normalized_remote_path(Some("///DBX//sync/./snapshot.json")), "DBX/sync/snapshot.json");
+        assert_eq!(normalized_remote_path(Some("DBX/sync/../snapshot.json")), "DBX/snapshot.json");
+    }
+
+    #[test]
+    fn returns_parent_collection_paths_from_leaf() {
+        assert_eq!(parent_collection_paths("dbx/sync/snapshot.json"), vec!["dbx".to_string(), "dbx/sync".to_string()]);
+        assert_eq!(
+            parent_collection_paths(&normalized_remote_path(Some(r"\DBX\sync\snapshot.json"))),
+            vec!["DBX".to_string(), "DBX/sync".to_string()]
+        );
+    }
+
+    #[test]
+    fn scrubs_connection_secret_fields() {
+        let mut config = ConnectionConfig {
+            id: "id".to_string(),
+            name: "name".to_string(),
+            db_type: DatabaseType::Postgres,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "localhost".to_string(),
+            port: 5432,
+            username: "user".to_string(),
+            password: "secret".to_string(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: vec![
+                TransportLayerConfig::Ssh(crate::models::connection::SshTunnelConfig {
+                    profile_id: String::new(),
+                    id: "hop-1".to_string(),
+                    name: String::new(),
+                    enabled: true,
+                    host: "bastion".to_string(),
+                    port: 22,
+                    user: "user".to_string(),
+                    password: "hop-password".to_string(),
+                    key_path: String::new(),
+                    key_passphrase: "hop-passphrase".to_string(),
+                    connect_timeout_secs: 5,
+                    expose_lan: false,
+                    use_ssh_agent: false,
+                    ssh_agent_sock_path: String::new(),
+                    auth_method: "password".to_string(),
+                }),
+                TransportLayerConfig::HttpTunnel(crate::models::connection::HttpTunnelConfig {
+                    profile_id: String::new(),
+                    id: "http".to_string(),
+                    name: String::new(),
+                    enabled: true,
+                    url: "https://dbx.example.com/dbx_tunnel.php".to_string(),
+                    token: "tunnel-token".to_string(),
+                    connect_timeout_secs: 10,
+                }),
+            ],
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: 0,
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: Some("postgres://secret".to_string()),
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: "sentinel".to_string(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        };
+        scrub_connection_secrets(&mut config);
+        assert!(config.password.is_empty());
+        match &config.transport_layers[0] {
+            TransportLayerConfig::Ssh(ssh) => {
+                assert!(ssh.password.is_empty());
+                assert!(ssh.key_passphrase.is_empty());
+            }
+            _ => panic!("expected ssh layer"),
+        }
+        match &config.transport_layers[1] {
+            TransportLayerConfig::HttpTunnel(http) => assert!(http.token.is_empty()),
+            _ => panic!("expected http tunnel layer"),
+        }
+        assert!(config.redis_sentinel_password.is_empty());
+        assert!(config.connection_string.is_none());
+    }
+
+    #[test]
+    fn encrypted_sensitive_payload_round_trips() {
+        let payload = SensitiveSyncPayload {
+            tunnel_profiles: None,
+            connection_secrets: vec![
+                ConnectionSecretSnapshot {
+                    connection_id: "c1".to_string(),
+                    key: "password".to_string(),
+                    secret: "secret".to_string(),
+                },
+                ConnectionSecretSnapshot {
+                    connection_id: "c1".to_string(),
+                    key: "transport_layers.hop-1.ssh_password".to_string(),
+                    secret: "hop-secret".to_string(),
+                },
+            ],
+            ai_config: None,
+        };
+        let encrypted = encrypt_sensitive_payload(&payload, "sync-pass").unwrap();
+        assert_ne!(encrypted.ciphertext, "secret");
+        let decrypted = decrypt_sensitive_payload(&encrypted, "sync-pass").unwrap();
+        assert_eq!(decrypted.connection_secrets[0].secret, "secret");
+        assert_eq!(decrypted.connection_secrets[1].secret, "hop-secret");
+    }
+
+    #[test]
+    fn encrypted_sensitive_payload_rejects_wrong_passphrase() {
+        let payload = SensitiveSyncPayload {
+            tunnel_profiles: None,
+            connection_secrets: vec![ConnectionSecretSnapshot {
+                connection_id: "c1".to_string(),
+                key: "password".to_string(),
+                secret: "secret".to_string(),
+            }],
+            ai_config: None,
+        };
+        let encrypted = encrypt_sensitive_payload(&payload, "sync-pass").unwrap();
+        assert!(decrypt_sensitive_payload(&encrypted, "wrong-pass").is_err());
+    }
+
+    #[test]
+    fn snippet_response_id_supports_github_object_and_gitee_array() {
+        assert_eq!(snippet_response_id(&serde_json::json!({ "id": "github-id" })).as_deref(), Some("github-id"));
+        assert_eq!(snippet_response_id(&serde_json::json!([{ "id": "gitee-id" }])).as_deref(), Some("gitee-id"));
+    }
+
+    #[test]
+    fn snippet_provider_uses_frontend_wire_values() {
+        assert_eq!(serde_json::to_string(&super::SnippetProvider::GitHub).unwrap(), "\"github\"");
+        assert_eq!(
+            serde_json::from_str::<super::SnippetProvider>("\"github\"").unwrap(),
+            super::SnippetProvider::GitHub
+        );
+        assert_eq!(
+            serde_json::from_str::<super::SnippetProvider>("\"git_hub\"").unwrap(),
+            super::SnippetProvider::GitHub
+        );
+        assert_eq!(serde_json::to_string(&super::SnippetProvider::Gitee).unwrap(), "\"gitee\"");
+    }
+
+    #[test]
+    fn snippet_file_content_uses_raw_url_for_truncated_github_files() {
+        let value = serde_json::json!({
+            "files": {
+                "dbx-sync.json": {
+                    "content": "truncated",
+                    "truncated": true,
+                    "raw_url": "https://example.com/raw"
+                }
+            }
+        });
+        assert_eq!(
+            snippet_file_content(&value, "dbx-sync.json").unwrap(),
+            (None, Some("https://example.com/raw".to_string()))
+        );
+    }
+
+    #[test]
+    fn snippet_file_content_parses_gitee_string_files() {
+        let files = serde_json::json!({ "dbx-sync.json": { "content": "{}" } }).to_string();
+        let value = serde_json::json!({ "files": files });
+        assert_eq!(snippet_file_content(&value, "dbx-sync.json").unwrap(), (Some("{}".to_string()), None));
+    }
+
+    #[tokio::test]
+    async fn webdav_sync_secrets_preference_round_trips_and_clears_passphrase() {
+        let storage = Storage::open(&temp_db_path("sync-secrets-preference")).await.unwrap();
+
+        let status = webdav_sync_secrets_status(&storage).await.unwrap();
+        assert!(!status.enabled);
+        assert!(!status.has_saved_passphrase);
+        assert_eq!(resolve_webdav_sync_secrets_passphrase(&storage).await.unwrap(), None);
+
+        save_webdav_sync_secrets_preference(&storage, true, Some("sync-pass")).await.unwrap();
+
+        let status = webdav_sync_secrets_status(&storage).await.unwrap();
+        assert!(status.enabled);
+        assert!(status.has_saved_passphrase);
+        assert_eq!(resolve_webdav_sync_secrets_passphrase(&storage).await.unwrap().as_deref(), Some("sync-pass"));
+
+        forget_webdav_sync_secrets_passphrase(&storage).await.unwrap();
+        let status = webdav_sync_secrets_status(&storage).await.unwrap();
+        assert!(status.enabled);
+        assert!(!status.has_saved_passphrase);
+        assert_eq!(resolve_webdav_sync_secrets_passphrase(&storage).await.unwrap(), None);
+    }
+
+    #[tokio::test]
+    async fn saved_sync_passphrase_encrypts_snapshot_secrets_without_exposing_connection_passwords() {
+        let storage = Storage::open(&temp_db_path("saved-sync-snapshot")).await.unwrap();
+        storage.save_connections(&[postgres_connection("pg", "db-secret")]).await.unwrap();
+
+        let plain_snapshot =
+            build_sync_snapshot_with_saved_secrets(&storage, "test-version", None, None).await.unwrap();
+        assert!(plain_snapshot.encrypted_secrets.is_none());
+        assert_eq!(plain_snapshot.connections[0].password, "");
+
+        save_webdav_sync_secrets_preference(&storage, true, Some("sync-pass")).await.unwrap();
+        let encrypted_snapshot =
+            build_sync_snapshot_with_saved_secrets(&storage, "test-version", None, None).await.unwrap();
+
+        assert_eq!(encrypted_snapshot.connections[0].password, "");
+        let encrypted = encrypted_snapshot.encrypted_secrets.as_ref().expect("encrypted secrets");
+        let decrypted = decrypt_sensitive_payload(encrypted, "sync-pass").unwrap();
+        assert!(decrypted.connection_secrets.iter().any(|secret| {
+            secret.connection_id == "pg" && secret.key == "password" && secret.secret == "db-secret"
+        }));
+    }
+
+    #[tokio::test]
+    async fn saved_sync_passphrase_encrypts_nacos_auth_password_without_exposing_it() {
+        let storage = Storage::open(&temp_db_path("saved-sync-nacos-snapshot")).await.unwrap();
+        storage.save_connections(&[nacos_connection("nacos", "nacos-secret")]).await.unwrap();
+
+        save_webdav_sync_secrets_preference(&storage, true, Some("sync-pass")).await.unwrap();
+        let encrypted_snapshot =
+            build_sync_snapshot_with_saved_secrets(&storage, "test-version", None, None).await.unwrap();
+
+        assert_eq!(nacos_auth_password(&encrypted_snapshot.connections[0]), Some(""));
+        let public_json = serde_json::to_string(&encrypted_snapshot.connections).unwrap();
+        assert!(!public_json.contains("nacos-secret"));
+        let encrypted = encrypted_snapshot.encrypted_secrets.as_ref().expect("encrypted secrets");
+        let decrypted = decrypt_sensitive_payload(encrypted, "sync-pass").unwrap();
+        assert!(decrypted.connection_secrets.iter().any(|secret| {
+            secret.connection_id == "nacos" && secret.key == NACOS_AUTH_PASSWORD_KEY && secret.secret == "nacos-secret"
+        }));
+    }
+
+    #[tokio::test]
+    async fn sync_snapshot_round_trips_tunnel_profiles() {
+        let storage = Storage::open(&temp_db_path("tunnel-profiles-src")).await.unwrap();
+        let profile = TransportLayerConfig::Ssh(SshTunnelConfig {
+            id: "profile-1".to_string(),
+            name: "Bastion".to_string(),
+            enabled: true,
+            host: "bastion.example.com".to_string(),
+            port: 22,
+            user: "deploy".to_string(),
+            password: "tunnel-secret".to_string(),
+            key_path: String::new(),
+            key_passphrase: String::new(),
+            connect_timeout_secs: 5,
+            expose_lan: false,
+            use_ssh_agent: false,
+            ssh_agent_sock_path: String::new(),
+            auth_method: "password".to_string(),
+            profile_id: String::new(),
+        });
+        storage.save_tunnel_profiles(std::slice::from_ref(&profile)).await.unwrap();
+
+        let snapshot = build_sync_snapshot(&storage, "test-version", None, Some("sync-pass")).await.unwrap();
+
+        // The plain snapshot carries the profiles with secrets scrubbed.
+        let public_profiles = snapshot.tunnel_profiles.as_ref().expect("tunnel profiles in snapshot");
+        let public_json = serde_json::to_string(public_profiles).unwrap();
+        assert!(!public_json.contains("tunnel-secret"));
+
+        // Applying with the passphrase restores the full profile on the target.
+        let target = Storage::open(&temp_db_path("tunnel-profiles-dst")).await.unwrap();
+        apply_sync_snapshot(&target, &snapshot, ApplySnapshotOptions { secrets_passphrase: Some("sync-pass") })
+            .await
+            .unwrap();
+        assert_eq!(target.load_tunnel_profiles().await.unwrap(), vec![profile]);
+    }
+}
diff --git a/crates/dbx-core/src/connection.rs b/crates/dbx-core/src/connection.rs
new file mode 100644
index 0000000..36dd3b1
--- /dev/null
+++ b/crates/dbx-core/src/connection.rs
@@ -0,0 +1,4882 @@
+use std::collections::{HashMap, HashSet};
+use std::path::PathBuf;
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio::sync::{Mutex, RwLock};
+use tokio::task::JoinHandle;
+
+use mysql_async::prelude::Queryable;
+use mysql_async::Row as MysqlRow;
+
+use crate::agent_connection::{
+    agent_connect_params, h2_file_path_from_jdbc_url, is_h2_file_connection, mongo_legacy_error_with_auth_hint,
+    mongo_uses_legacy_driver, oracle_alternate_connect_config_labels, oracle_alternate_connect_configs,
+    oracle_error_with_driver_hint, should_retry_mongo_with_legacy_driver, trino_like_jdbc_connection_string,
+};
+use crate::agent_manager::{JavaRuntimeMode, DEFAULT_JRE_KEY};
+use crate::database_capabilities;
+use crate::db;
+use crate::db::agent_driver::AgentMethod;
+use crate::db::http_tunnel::HttpTunnelManager;
+use crate::db::proxy_tunnel::ProxyTunnelManager;
+use crate::db::ssh_tunnel::TunnelManager;
+use crate::models::connection::{
+    parse_jdbc_host_port, parse_mongo_first_host, rewrite_jdbc_url_host, ConnectionConfig, DatabaseType,
+    TransportLayerConfig,
+};
+use crate::path_utils::expand_tilde;
+use crate::plugins::{PluginDriverSession, PluginRegistry, PluginRuntimeEnv};
+use crate::query_cancel::RunningQueries;
+use crate::storage::{normalize_duckdb_worker_max_processes, Storage, DUCKDB_WORKER_MAX_PROCESSES_DEFAULT};
+
+pub const JDBC_PLUGIN_NOT_INSTALLED: &str =
+    "JDBC plugin is not installed. Install the optional JDBC plugin to use this connection.";
+pub const PRESTOSQL_JDBC_DRIVER_CLASS: &str = "io.prestosql.jdbc.PrestoDriver";
+const SQLSERVER_LEGACY_DRIVER_INSTALL_HINT: &str =
+    "Install the SQL Server legacy compatibility component from Driver Manager, or open the connection settings and enable SQL Server legacy compatibility mode again.";
+const DEFAULT_AGENT_CONNECT_TIMEOUT_SECS: u64 = 30;
+const ACCESS_AGENT_CONNECT_TIMEOUT_SECS: u64 = 30;
+const POOL_CLOSE_TIMEOUT_SECS: u64 = 3;
+const HEALTH_CHECK_POOL_ACQUIRE_TIMEOUT: Duration = Duration::from_millis(500);
+
+#[cfg(feature = "duckdb-bundled")]
+mod duckdb_types {
+    use std::sync::Arc;
+    pub type DuckDbHandle = Arc<crate::db::duckdb_driver::DuckDbConnection>;
+    pub type DuckDbWorkerHandle = Arc<crate::db::duckdb_worker_process::DuckDbWorkerClient>;
+    pub type ExternalTabularHandle = Arc<crate::external::ExternalPool>;
+}
+#[cfg(not(feature = "duckdb-bundled"))]
+mod duckdb_types {
+    pub type DuckDbHandle = ();
+    pub type DuckDbWorkerHandle = ();
+    pub type ExternalTabularHandle = ();
+}
+
+use duckdb_types::{DuckDbHandle, DuckDbWorkerHandle, ExternalTabularHandle};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum MysqlMode {
+    Normal,
+    Bare,
+    OceanBaseOracle,
+}
+
+fn is_oceanbase_mysql_config(config: &ConnectionConfig) -> bool {
+    config.db_type == DatabaseType::Mysql
+        && config.driver_profile.as_deref().is_some_and(|profile| profile.eq_ignore_ascii_case("oceanbase"))
+}
+
+pub(crate) fn oceanbase_mysql_query_timeout_sql(config: &ConnectionConfig, timeout_secs: u64) -> Option<String> {
+    if !is_oceanbase_mysql_config(config) || timeout_secs == 0 {
+        return None;
+    }
+    let timeout_us = timeout_secs.saturating_mul(1_000_000);
+    Some(format!("SET ob_query_timeout = {timeout_us}"))
+}
+
+fn oceanbase_mysql_setup_queries(config: &ConnectionConfig) -> Vec<String> {
+    oceanbase_mysql_query_timeout_sql(config, config.query_timeout_secs).into_iter().collect()
+}
+
+pub enum PoolKind {
+    Mysql(db::mysql::MySqlPool, MysqlMode),
+    Postgres(deadpool_postgres::Pool),
+    Sqlite(db::sqlite::SqliteHandle),
+    Rqlite(db::rqlite_driver::RqliteClient),
+    Turso(db::turso_driver::TursoClient),
+    CloudflareD1(db::cloudflare_d1_driver::CloudflareD1Client),
+    Redis(db::redis_driver::RedisConnection),
+    DuckDb(DuckDbHandle),
+    DuckDbWorker(DuckDbWorkerHandle),
+    MongoDb(mongodb::Client),
+    ClickHouse(db::clickhouse_driver::ChClient),
+    SqlServer(Arc<tokio::sync::Mutex<db::sqlserver::SqlServerClient>>),
+    Elasticsearch(db::elasticsearch_driver::EsClient),
+    VectorDb(db::vector_driver::VectorClient),
+    InfluxDb(db::influxdb_driver::InfluxdbClient),
+    Agent(Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>),
+    ExternalTabular(ExternalTabularHandle),
+    ExternalDriver {
+        driver_id: String,
+        config: Arc<ConnectionConfig>,
+        session: Arc<PluginDriverSession>,
+    },
+    /// Message queue admin connection (not a data query pool; serves as a
+    /// marker that this connection_id is a valid MQ admin connection).
+    MessageQueue,
+    /// Nacos admin connection marker.
+    Nacos,
+}
+
+/// Held connection for a manual transaction session
+pub enum TxnConnection {
+    Postgres(Box<deadpool_postgres::Object>),
+    Mysql(mysql_async::Conn),
+}
+
+pub struct TransactionSession {
+    pub connection: Arc<Mutex<TxnConnection>>,
+    pub pool_key: String,
+    pub last_activity: std::time::Instant,
+    pub busy: bool,
+    pub connection_id: String,
+    pub database: String,
+    pub schema: Option<String>,
+}
+
+macro_rules! agent_connection_pool_database_type {
+    () => {
+        DatabaseType::Dameng
+            | DatabaseType::Kingbase
+            | DatabaseType::Highgo
+            | DatabaseType::Vastbase
+            | DatabaseType::Goldendb
+            | DatabaseType::Databend
+            | DatabaseType::Yashandb
+            | DatabaseType::Databricks
+            | DatabaseType::SapHana
+            | DatabaseType::Teradata
+            | DatabaseType::Vertica
+            | DatabaseType::Firebird
+            | DatabaseType::Exasol
+            | DatabaseType::OceanbaseOracle
+            | DatabaseType::Gbase
+            | DatabaseType::Oracle
+            | DatabaseType::H2
+            | DatabaseType::Snowflake
+            | DatabaseType::Trino
+            | DatabaseType::Hive
+            | DatabaseType::Spark
+            | DatabaseType::Db2
+            | DatabaseType::Informix
+            | DatabaseType::Neo4j
+            | DatabaseType::Cassandra
+            | DatabaseType::Bigquery
+            | DatabaseType::Kylin
+            | DatabaseType::Sundb
+            | DatabaseType::Oscar
+            | DatabaseType::Tdengine
+            | DatabaseType::Xugu
+            | DatabaseType::Iotdb
+            | DatabaseType::Etcd
+            | DatabaseType::ZooKeeper
+            | DatabaseType::Iris
+            | DatabaseType::Access
+    };
+}
+
+pub struct AppState {
+    pub connections: Arc<RwLock<HashMap<String, PoolKind>>>,
+    keepalive_tasks: Arc<RwLock<HashMap<String, JoinHandle<()>>>>,
+    pool_activity: Arc<RwLock<HashMap<String, PoolActivity>>>,
+    connection_attempts: RwLock<HashMap<String, ConnectionAttemptState>>,
+    pub configs: RwLock<HashMap<String, ConnectionConfig>>,
+    pub running_queries: RunningQueries,
+    pub tunnels: TunnelManager,
+    pub proxy_tunnels: ProxyTunnelManager,
+    pub http_tunnels: HttpTunnelManager,
+    pub storage: Storage,
+    pub plugins: PluginRegistry,
+    pub agent_manager: crate::agent_manager::AgentManager,
+    pub nacos_registry: crate::nacos::NacosAdminRegistry,
+    duckdb_worker_process_isolation: AtomicBool,
+    duckdb_worker_max_processes: AtomicUsize,
+    /// PostgreSQL TLS cancel context, keyed by pool_key.
+    /// Used to reconstruct a TLS connector compatible with the original connection when cancelling.
+    postgres_cancel_contexts: Arc<RwLock<HashMap<String, db::postgres::PostgresCancelContext>>>,
+    pub transaction_sessions: Arc<RwLock<HashMap<String, TransactionSession>>>,
+    #[cfg(feature = "mq-admin")]
+    pub mq_registry: crate::mq::MqAdminRegistry,
+}
+
+#[derive(Clone, Copy)]
+#[cfg_attr(not(test), allow(dead_code))]
+struct PoolActivity {
+    last_used_at: Instant,
+}
+
+#[derive(Clone, Copy)]
+struct ConnectionAttemptState {
+    server_attempt: u64,
+    client_attempt: Option<u64>,
+}
+
+impl PoolActivity {
+    fn now() -> Self {
+        Self { last_used_at: Instant::now() }
+    }
+}
+
+pub struct PoolActivityTouch {
+    pool_key: String,
+    connections: Arc<RwLock<HashMap<String, PoolKind>>>,
+    pool_activity: Arc<RwLock<HashMap<String, PoolActivity>>>,
+}
+
+impl Drop for PoolActivityTouch {
+    fn drop(&mut self) {
+        let pool_key = self.pool_key.clone();
+        let connections = self.connections.clone();
+        let pool_activity = self.pool_activity.clone();
+        let Ok(handle) = tokio::runtime::Handle::try_current() else {
+            return;
+        };
+        handle.spawn(async move {
+            if !connections.read().await.contains_key(&pool_key) {
+                return;
+            }
+            pool_activity.write().await.insert(pool_key, PoolActivity::now());
+        });
+    }
+}
+
+pub fn metadata_connection_config(config: &ConnectionConfig) -> ConnectionConfig {
+    let mut db_config = config.canonicalized();
+    if database_capabilities::is_metadata_connection_scoped(&db_config.db_type) {
+        db_config.database = None;
+    }
+    db_config
+}
+
+pub fn database_connection_config(config: &ConnectionConfig, database: Option<&str>) -> ConnectionConfig {
+    let mut db_config = if database.is_some() { config.clone() } else { metadata_connection_config(config) };
+    if let Some(db) = database {
+        if !matches!(
+            db_config.db_type,
+            DatabaseType::Oracle
+                | DatabaseType::Dameng
+                | DatabaseType::MongoDb
+                | DatabaseType::OceanbaseOracle
+                | DatabaseType::CloudflareD1
+        ) {
+            db_config.database = Some(db.to_string());
+        }
+    }
+    db_config
+}
+
+pub fn prestosql_jdbc_config_for_endpoint(config: &ConnectionConfig, host: &str, port: u16) -> ConnectionConfig {
+    let mut jdbc_config = config.clone();
+    jdbc_config.connection_string =
+        Some(trino_like_jdbc_connection_string(config, host, port, config.effective_database().unwrap_or("")));
+    if jdbc_config.jdbc_driver_class.as_deref().is_none_or(|value| value.trim().is_empty()) {
+        jdbc_config.jdbc_driver_class = Some(PRESTOSQL_JDBC_DRIVER_CLASS.to_string());
+    }
+    jdbc_config
+}
+
+pub fn sqlserver_legacy_agent_config(config: &ConnectionConfig) -> ConnectionConfig {
+    let mut legacy_config = config.clone();
+    legacy_config.driver_profile = Some(db::sqlserver::SQLSERVER_LEGACY_DRIVER_PROFILE.to_string());
+    legacy_config.driver_label = Some(db::sqlserver::SQLSERVER_LEGACY_DRIVER_LABEL.to_string());
+    legacy_config
+}
+
+pub fn sqlserver_legacy_agent_error(native_error: &str, agent_error: &str) -> String {
+    let install_hint = if agent_error.contains("driver is not installed") {
+        format!("\n\n{SQLSERVER_LEGACY_DRIVER_INSTALL_HINT}")
+    } else {
+        String::new()
+    };
+    format!(
+        "{native_error}\n\nFallback with SQL Server legacy compatibility component failed: {agent_error}{install_hint}"
+    )
+}
+
+pub async fn connect_mysql_metadata_pool(
+    config: &ConnectionConfig,
+    db_config: &ConnectionConfig,
+    host: &str,
+    port: u16,
+    connect_timeout: std::time::Duration,
+    max_connections: usize,
+) -> Result<(db::mysql::MySqlPool, MysqlMode), String> {
+    let url = connection_url_for_endpoint(db_config, host, port);
+    let idle_timeout_secs = Some(db_config.idle_timeout_secs);
+    let extra_setup_queries = oceanbase_mysql_setup_queries(db_config);
+    if db_config.needs_bare_mysql() {
+        return match connect_bare_mysql_pool_with_setup(
+            db_config,
+            &url,
+            connect_timeout,
+            max_connections,
+            &extra_setup_queries,
+        )
+        .await
+        {
+            Ok(pool) => Ok((pool, MysqlMode::Bare)),
+            Err(err) => {
+                let fallback_url = mysql_metadata_fallback_url(config, db_config, host, port);
+                if let Some(fallback_url) = fallback_url {
+                    log::info!(
+                        "MySQL metadata connection without a default database failed ({err}); retrying with configured default database."
+                    );
+                    connect_bare_mysql_pool_with_setup(
+                        db_config,
+                        &fallback_url,
+                        connect_timeout,
+                        max_connections,
+                        &extra_setup_queries,
+                    )
+                    .await
+                    .map(|pool| (pool, MysqlMode::Bare))
+                } else if let Some(db) = db_config.effective_database() {
+                    let mut unscoped_config = db_config.clone();
+                    unscoped_config.database = None;
+                    let unscoped_url = connection_url_for_endpoint(&unscoped_config, host, port);
+                    log::info!("MySQL connection with database in URL failed ({err}); retrying without database in URL and using USE statement.");
+                    connect_bare_mysql_pool_with_setup_database(
+                        &unscoped_config,
+                        &unscoped_url,
+                        connect_timeout,
+                        max_connections,
+                        db,
+                        &extra_setup_queries,
+                    )
+                    .await
+                    .map(|pool| (pool, MysqlMode::Bare))
+                } else {
+                    Err(err)
+                }
+            }
+        };
+    }
+
+    match db::mysql::connect_with_ca_cert_pool_limit_idle_and_setup(
+        &url,
+        Some(&db_config.ca_cert_path),
+        connect_timeout,
+        max_connections,
+        idle_timeout_secs,
+        &extra_setup_queries,
+    )
+    .await
+    {
+        Ok(pool) => {
+            let mode = detect_ob_oracle_mode(config, &pool).await;
+            Ok((pool, mode))
+        }
+        Err(err) => {
+            let fallback_url = mysql_metadata_fallback_url(config, db_config, host, port);
+            if let Some(fallback_url) = fallback_url {
+                log::info!(
+                    "MySQL metadata connection without a default database failed ({err}); retrying with configured default database."
+                );
+                let pool = db::mysql::connect_with_ca_cert_pool_limit_idle_and_setup(
+                    &fallback_url,
+                    Some(&config.ca_cert_path),
+                    connect_timeout,
+                    max_connections,
+                    idle_timeout_secs,
+                    &extra_setup_queries,
+                )
+                .await?;
+                let mode = detect_ob_oracle_mode(config, &pool).await;
+                Ok((pool, mode))
+            } else if let Some(db) = db_config.effective_database() {
+                let mut unscoped_config = db_config.clone();
+                unscoped_config.database = None;
+                let unscoped_url = connection_url_for_endpoint(&unscoped_config, host, port);
+                log::info!("MySQL connection with database in URL failed ({err}); retrying without database in URL and using USE statement.");
+                let pool = db::mysql::connect_with_ca_cert_pool_limit_idle_and_setup_database(
+                    &unscoped_url,
+                    Some(&config.ca_cert_path),
+                    connect_timeout,
+                    max_connections,
+                    idle_timeout_secs,
+                    Some(db),
+                    &extra_setup_queries,
+                )
+                .await?;
+                let mode = detect_ob_oracle_mode(config, &pool).await;
+                Ok((pool, mode))
+            } else {
+                Err(err)
+            }
+        }
+    }
+}
+
+pub async fn connect_bare_metadata_pool(
+    db_config: &ConnectionConfig,
+    host: &str,
+    port: u16,
+    connect_timeout: std::time::Duration,
+    max_connections: usize,
+) -> Result<db::mysql::MySqlPool, String> {
+    let url = connection_url_for_endpoint(db_config, host, port);
+    let extra_setup_queries = oceanbase_mysql_setup_queries(db_config);
+    if db_config.effective_database().is_none() {
+        return connect_bare_mysql_pool_with_setup(
+            db_config,
+            &url,
+            connect_timeout,
+            max_connections,
+            &extra_setup_queries,
+        )
+        .await;
+    }
+
+    let mut unscoped_config = db_config.clone();
+    unscoped_config.database = None;
+    let unscoped_url = connection_url_for_endpoint(&unscoped_config, host, port);
+    if unscoped_url == url {
+        return connect_bare_mysql_pool_with_setup(
+            db_config,
+            &url,
+            connect_timeout,
+            max_connections,
+            &extra_setup_queries,
+        )
+        .await;
+    }
+
+    let preferred =
+        connect_bare_mysql_pool_with_setup(db_config, &url, connect_timeout, max_connections, &extra_setup_queries);
+    let unscoped = connect_bare_mysql_pool_with_setup(
+        db_config,
+        &unscoped_url,
+        connect_timeout,
+        max_connections,
+        &extra_setup_queries,
+    );
+    tokio::pin!(preferred);
+    tokio::pin!(unscoped);
+
+    tokio::select! {
+        result = &mut preferred => match result {
+            Ok(pool) => Ok(pool),
+            Err(preferred_err) => match (&mut unscoped).await {
+                Ok(pool) => Ok(pool),
+                Err(unscoped_err) => Err(format!(
+                    "Connection with the configured database failed: {preferred_err}\n\nConnection without a default database also failed: {unscoped_err}"
+                )),
+            },
+        },
+        result = &mut unscoped => match result {
+            Ok(pool) => Ok(pool),
+            Err(unscoped_err) => match (&mut preferred).await {
+                Ok(pool) => Ok(pool),
+                Err(preferred_err) => Err(format!(
+                    "Connection with the configured database failed: {preferred_err}\n\nConnection without a default database also failed: {unscoped_err}"
+                )),
+            },
+        },
+    }
+}
+
+async fn connect_bare_mysql_pool_with_setup(
+    db_config: &ConnectionConfig,
+    url: &str,
+    connect_timeout: std::time::Duration,
+    max_connections: usize,
+    extra_setup_queries: &[String],
+) -> Result<db::mysql::MySqlPool, String> {
+    if db_config.bare_mysql_uses_tls() {
+        let idle_timeout_secs = Some(db_config.idle_timeout_secs);
+        db::mysql::connect_compatible_with_ca_cert_pool_limit_idle_and_setup(
+            url,
+            Some(&db_config.ca_cert_path),
+            connect_timeout,
+            max_connections,
+            idle_timeout_secs,
+            extra_setup_queries,
+        )
+        .await
+    } else {
+        db::mysql::connect_bare_with_pool_limit_and_setup(url, connect_timeout, max_connections, extra_setup_queries)
+            .await
+    }
+}
+
+async fn connect_bare_mysql_pool_with_setup_database(
+    db_config: &ConnectionConfig,
+    url: &str,
+    connect_timeout: std::time::Duration,
+    max_connections: usize,
+    setup_database: &str,
+    extra_setup_queries: &[String],
+) -> Result<db::mysql::MySqlPool, String> {
+    // Some MySQL proxies reject the default database in the handshake; pass it
+    // separately so DB-layer setup keeps the normal charset/catalog/USE order.
+    if db_config.bare_mysql_uses_tls() {
+        let idle_timeout_secs = Some(db_config.idle_timeout_secs);
+        db::mysql::connect_compatible_with_ca_cert_pool_limit_idle_and_setup_database(
+            url,
+            Some(&db_config.ca_cert_path),
+            connect_timeout,
+            max_connections,
+            idle_timeout_secs,
+            Some(setup_database),
+            extra_setup_queries,
+        )
+        .await
+    } else {
+        db::mysql::connect_bare_with_pool_limit_and_setup_database(
+            url,
+            connect_timeout,
+            max_connections,
+            Some(setup_database),
+            extra_setup_queries,
+        )
+        .await
+    }
+}
+
+fn mysql_metadata_fallback_url(
+    config: &ConnectionConfig,
+    db_config: &ConnectionConfig,
+    host: &str,
+    port: u16,
+) -> Option<String> {
+    if db_config.db_type != DatabaseType::Mysql || db_config.effective_database().is_some() {
+        return None;
+    }
+    config.effective_database()?;
+    Some(connection_url_for_endpoint(config, host, port))
+}
+
+impl AppState {
+    pub fn new(storage: Storage) -> Self {
+        Self::new_with_plugin_dir(storage, default_plugin_dir())
+    }
+
+    pub fn new_with_plugin_dir(storage: Storage, plugin_dir: PathBuf) -> Self {
+        Self::new_with_plugin_dir_and_app_version(storage, plugin_dir, env!("CARGO_PKG_VERSION"))
+    }
+
+    pub fn new_with_plugin_dir_and_app_version(
+        storage: Storage,
+        plugin_dir: PathBuf,
+        app_version: impl Into<String>,
+    ) -> Self {
+        Self::new_with_plugin_and_agent_dir_and_app_version(storage, plugin_dir, default_agent_dir(), app_version)
+    }
+
+    pub fn new_with_plugin_and_agent_dir_and_app_version(
+        storage: Storage,
+        plugin_dir: PathBuf,
+        agent_dir: PathBuf,
+        app_version: impl Into<String>,
+    ) -> Self {
+        Self {
+            connections: Arc::new(RwLock::new(HashMap::new())),
+            keepalive_tasks: Arc::new(RwLock::new(HashMap::new())),
+            pool_activity: Arc::new(RwLock::new(HashMap::new())),
+            connection_attempts: RwLock::new(HashMap::new()),
+            configs: RwLock::new(HashMap::new()),
+            running_queries: RunningQueries::default(),
+            tunnels: TunnelManager::new(),
+            proxy_tunnels: ProxyTunnelManager::new(),
+            http_tunnels: HttpTunnelManager::new(),
+            storage,
+            plugins: PluginRegistry::new(plugin_dir),
+            agent_manager: crate::agent_manager::AgentManager::new_with_base_dir_and_app_version(
+                agent_dir,
+                app_version,
+            ),
+            nacos_registry: crate::nacos::NacosAdminRegistry::new(),
+            duckdb_worker_process_isolation: AtomicBool::new(false),
+            duckdb_worker_max_processes: AtomicUsize::new(DUCKDB_WORKER_MAX_PROCESSES_DEFAULT),
+            postgres_cancel_contexts: Arc::new(RwLock::new(HashMap::new())),
+            transaction_sessions: Arc::new(RwLock::new(HashMap::new())),
+            #[cfg(feature = "mq-admin")]
+            mq_registry: crate::mq::MqAdminRegistry::new(),
+        }
+    }
+
+    pub fn jdbc_unavailable_error(&self) -> String {
+        match self.plugins.find_driver("jdbc") {
+            Ok(Some(_)) => "JDBC plugin is installed, but the connection could not be opened.".to_string(),
+            Ok(None) => JDBC_PLUGIN_NOT_INSTALLED.to_string(),
+            Err(err) => format!("Failed to inspect JDBC plugin: {err}"),
+        }
+    }
+
+    pub fn set_duckdb_worker_process_isolation_enabled(&self, enabled: bool) {
+        self.duckdb_worker_process_isolation.store(enabled, Ordering::Relaxed);
+    }
+
+    pub fn set_duckdb_worker_max_processes(&self, max_processes: usize) {
+        self.duckdb_worker_max_processes.store(normalize_duckdb_worker_max_processes(max_processes), Ordering::Relaxed);
+    }
+
+    pub async fn apply_duckdb_worker_process_isolation(&self, enabled: bool) {
+        let previous = self.duckdb_worker_process_isolation.swap(enabled, Ordering::Relaxed);
+        if previous != enabled {
+            self.remove_duckdb_pools_detached().await;
+        }
+    }
+
+    pub async fn test_external_driver(&self, driver_id: &str, config: &ConnectionConfig) -> Result<String, String> {
+        let params = serde_json::json!({ "connection": config });
+        let env = self.external_driver_runtime_env(driver_id)?;
+        self.plugins
+            .invoke_driver_with_env_and_timeout::<serde_json::Value>(
+                driver_id,
+                "testConnection",
+                params,
+                env,
+                Some(external_driver_connect_timeout(config)),
+            )
+            .await?;
+        Ok("Connection successful".to_string())
+    }
+
+    pub async fn external_driver_pool(&self, driver_id: &str, config: &ConnectionConfig) -> Result<PoolKind, String> {
+        let env = self.external_driver_runtime_env(driver_id)?;
+        let session = self.plugins.start_driver_session_with_env(driver_id, env).await?;
+        let params = serde_json::json!({ "connection": config });
+        session
+            .invoke_with_timeout::<serde_json::Value>("connect", params, Some(external_driver_connect_timeout(config)))
+            .await?;
+        Ok(PoolKind::ExternalDriver { driver_id: driver_id.to_string(), config: Arc::new(config.clone()), session })
+    }
+
+    pub async fn test_sqlserver_connection_with_legacy_fallback(
+        &self,
+        config: &ConnectionConfig,
+        host: &str,
+        port: u16,
+        connect_timeout: Duration,
+    ) -> Result<String, String> {
+        match db::sqlserver::connect(
+            host,
+            port,
+            &config.username,
+            &config.password,
+            config.database.as_deref(),
+            config.url_params.as_deref(),
+            connect_timeout,
+        )
+        .await
+        {
+            Ok(_) => Ok("Connection successful".to_string()),
+            Err(native_error)
+                if db::sqlserver::sqlserver_legacy_compatibility_enabled(config.url_params.as_deref()) =>
+            {
+                let legacy_config = sqlserver_legacy_agent_config(config);
+                let connect_params =
+                    agent_connect_params(&legacy_config, host, port, legacy_config.effective_database().unwrap_or(""));
+                let mut client = self
+                    .agent_manager
+                    .spawn(&legacy_config.db_type, legacy_config.driver_profile.as_deref())
+                    .await
+                    .map_err(|err| sqlserver_legacy_agent_error(&native_error, &err))?;
+                client
+                    .call_method_with_timeout::<serde_json::Value>(
+                        AgentMethod::TestConnection,
+                        connect_params,
+                        Some(agent_connect_timeout(&legacy_config)),
+                    )
+                    .await
+                    .map_err(|err| sqlserver_legacy_agent_error(&native_error, &err))?;
+                client.disconnect().await.ok();
+                Ok("Connection successful (via SQL Server legacy compatibility driver)".to_string())
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    pub async fn connect_sqlserver_pool_with_legacy_fallback(
+        &self,
+        config: &ConnectionConfig,
+        host: &str,
+        port: u16,
+        connect_timeout: Duration,
+    ) -> Result<PoolKind, String> {
+        match db::sqlserver::connect(
+            host,
+            port,
+            &config.username,
+            &config.password,
+            config.database.as_deref(),
+            config.url_params.as_deref(),
+            connect_timeout,
+        )
+        .await
+        {
+            Ok(client) => Ok(PoolKind::SqlServer(Arc::new(tokio::sync::Mutex::new(client)))),
+            Err(native_error)
+                if db::sqlserver::sqlserver_legacy_compatibility_enabled(config.url_params.as_deref()) =>
+            {
+                let legacy_config = sqlserver_legacy_agent_config(config);
+                let connect_params =
+                    agent_connect_params(&legacy_config, host, port, legacy_config.effective_database().unwrap_or(""));
+                let mut client = self
+                    .agent_manager
+                    .spawn(&legacy_config.db_type, legacy_config.driver_profile.as_deref())
+                    .await
+                    .map_err(|err| sqlserver_legacy_agent_error(&native_error, &err))?;
+                client
+                    .call_method_with_timeout::<serde_json::Value>(
+                        AgentMethod::Connect,
+                        connect_params,
+                        Some(agent_connect_timeout(&legacy_config)),
+                    )
+                    .await
+                    .map_err(|err| sqlserver_legacy_agent_error(&native_error, &err))?;
+                Ok(PoolKind::Agent(Arc::new(tokio::sync::Mutex::new(client))))
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    pub fn external_driver_runtime_env(&self, driver_id: &str) -> Result<PluginRuntimeEnv, String> {
+        if driver_id != "jdbc" {
+            return Ok(PluginRuntimeEnv::default());
+        }
+        let state = self.agent_manager.load_state();
+        if state.java_runtime.mode == JavaRuntimeMode::Managed && !self.agent_manager.is_jre_installed(DEFAULT_JRE_KEY)
+        {
+            return Ok(PluginRuntimeEnv::default());
+        }
+        let java = self.agent_manager.resolve_java_runtime(&state, DEFAULT_JRE_KEY)?;
+        Ok(PluginRuntimeEnv::default().with_var("DBX_JAVA_BIN", java.to_string_lossy().to_string()))
+    }
+
+    pub async fn insert_connection_pool(&self, pool_key: String, pool: PoolKind, config: &ConnectionConfig) {
+        self.stop_keepalive_task(&pool_key).await;
+        self.pool_activity.write().await.insert(pool_key.clone(), PoolActivity::now());
+        self.start_keepalive_task(&pool_key, &pool, config).await;
+        let previous_key = pool_key.clone();
+        let previous = self.connections.write().await.insert(pool_key, pool);
+        if let Some(pool) = previous {
+            close_pool_kind_with_timeout(previous_key, pool).await;
+        }
+    }
+
+    pub async fn begin_connection_attempt(&self, connection_id: &str) -> u64 {
+        self.begin_connection_attempt_with_client_attempt(connection_id, None).await
+    }
+
+    pub async fn begin_connection_attempt_with_client_attempt(
+        &self,
+        connection_id: &str,
+        client_attempt: Option<u64>,
+    ) -> u64 {
+        let mut attempts = self.connection_attempts.write().await;
+        let next = attempts.get(connection_id).map(|state| state.server_attempt).unwrap_or(0).wrapping_add(1);
+        attempts.insert(connection_id.to_string(), ConnectionAttemptState { server_attempt: next, client_attempt });
+        next
+    }
+
+    pub async fn supersede_connection_attempt(&self, connection_id: &str) {
+        self.begin_connection_attempt(connection_id).await;
+    }
+
+    pub async fn supersede_connection_attempt_if_client_attempt(
+        &self,
+        connection_id: &str,
+        client_attempt: u64,
+    ) -> bool {
+        let mut attempts = self.connection_attempts.write().await;
+        let Some(current) = attempts.get(connection_id).copied() else {
+            return false;
+        };
+        if current.client_attempt != Some(client_attempt) {
+            return false;
+        }
+        attempts.insert(
+            connection_id.to_string(),
+            ConnectionAttemptState { server_attempt: current.server_attempt.wrapping_add(1), client_attempt: None },
+        );
+        true
+    }
+
+    async fn connection_attempt_is_current(&self, connection_id: &str, attempt: u64) -> bool {
+        self.connection_attempts.read().await.get(connection_id).map(|state| state.server_attempt) == Some(attempt)
+    }
+
+    pub async fn ensure_current_connection_attempt(
+        &self,
+        connection_id: &str,
+        attempt: Option<u64>,
+    ) -> Result<(), String> {
+        let Some(attempt) = attempt else {
+            return Ok(());
+        };
+        if self.connection_attempt_is_current(connection_id, attempt).await {
+            Ok(())
+        } else {
+            Err("Connection attempt was superseded by a newer attempt".to_string())
+        }
+    }
+
+    pub async fn insert_connection_pool_for_attempt(
+        &self,
+        connection_id: &str,
+        attempt: u64,
+        pool_key: String,
+        pool: PoolKind,
+        config: &ConnectionConfig,
+    ) -> Result<(), String> {
+        if let Err(err) = self.ensure_current_connection_attempt(connection_id, Some(attempt)).await {
+            close_pool_kind_with_timeout(pool_key, pool).await;
+            return Err(err);
+        }
+        self.insert_connection_pool(pool_key, pool, config).await;
+        Ok(())
+    }
+
+    async fn discard_stale_connection_attempt_pool(
+        &self,
+        connection_id: &str,
+        pool_key: String,
+        pool: PoolKind,
+        config: &ConnectionConfig,
+    ) {
+        // mq_registry only exists in mq-admin builds; other builds reject MQ connects before a pool is created.
+        #[cfg(feature = "mq-admin")]
+        if matches!(pool, PoolKind::MessageQueue) {
+            self.mq_registry.drop_connection(connection_id).await;
+        }
+        self.reset_connection_transport_for_config(connection_id, config).await;
+        close_pool_kind_with_timeout(pool_key, pool).await;
+    }
+
+    async fn start_keepalive_task(&self, pool_key: &str, pool: &PoolKind, config: &ConnectionConfig) {
+        let interval_secs = config.keepalive_interval_secs;
+        let mut target = keepalive_target_from_pool(pool, config);
+        if interval_secs == 0 {
+            return;
+        }
+        if interval_secs > 0 && target.is_none() {
+            log::debug!(
+                "Connection keepalive requested for '{pool_key}', but this database driver does not keep a pingable client handle."
+            );
+            return;
+        };
+
+        let key = pool_key.to_string();
+        let interval = Duration::from_secs(interval_secs.max(1));
+        let timeout = Duration::from_secs(config.effective_connect_timeout_secs().max(1));
+        let connections = self.connections.clone();
+        let keepalive_tasks = self.keepalive_tasks.clone();
+        let pool_activity = self.pool_activity.clone();
+        let cancel_contexts = self.postgres_cancel_contexts.clone();
+        let running_queries = self.running_queries.clone();
+        let handle = tokio::spawn(async move {
+            loop {
+                tokio::time::sleep(interval).await;
+
+                if running_queries.is_pool_active(&key) {
+                    continue;
+                }
+
+                if let Some(target) = target.as_mut() {
+                    let result = tokio::time::timeout(timeout, ping_keepalive_target(target, timeout)).await;
+                    match result {
+                        Ok(Ok(())) => {}
+                        Ok(Err(err)) => {
+                            log::warn!("Connection keepalive failed for '{key}': {err}; invalidating pool");
+                            keepalive_tasks.write().await.remove(&key);
+                            pool_activity.write().await.remove(&key);
+                            cancel_contexts.write().await.remove(&key);
+                            let removed = connections.write().await.remove(&key);
+                            if let Some(pool) = removed {
+                                close_pool_kind_with_timeout(key, pool).await;
+                            }
+                            break;
+                        }
+                        Err(_) => {
+                            log::warn!(
+                                "Connection keepalive timed out for '{key}' after {}s; invalidating pool",
+                                timeout.as_secs()
+                            );
+                            keepalive_tasks.write().await.remove(&key);
+                            pool_activity.write().await.remove(&key);
+                            cancel_contexts.write().await.remove(&key);
+                            let removed = connections.write().await.remove(&key);
+                            if let Some(pool) = removed {
+                                close_pool_kind_with_timeout(key, pool).await;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+        });
+        let previous = self.keepalive_tasks.write().await.insert(pool_key.to_string(), handle);
+        if let Some(previous) = previous {
+            previous.abort();
+        }
+    }
+
+    async fn stop_keepalive_task(&self, pool_key: &str) {
+        let task = self.keepalive_tasks.write().await.remove(pool_key);
+        if let Some(task) = task {
+            task.abort();
+        }
+    }
+
+    async fn stop_keepalive_tasks(&self, pool_keys: &[String]) {
+        let mut tasks = self.keepalive_tasks.write().await;
+        for pool_key in pool_keys {
+            if let Some(task) = tasks.remove(pool_key) {
+                task.abort();
+            }
+        }
+    }
+
+    pub async fn touch_pool_activity(&self, pool_key: &str) {
+        self.pool_activity.write().await.insert(pool_key.to_string(), PoolActivity::now());
+    }
+
+    /// Get the PostgreSQL TLS cancel context (used to reconstruct the TLS connector when cancelling a query).
+    pub async fn get_postgres_cancel_context(&self, pool_key: &str) -> Option<db::postgres::PostgresCancelContext> {
+        self.postgres_cancel_contexts.read().await.get(pool_key).cloned()
+    }
+
+    pub fn pool_activity_touch(&self, pool_key: &str) -> PoolActivityTouch {
+        PoolActivityTouch {
+            pool_key: pool_key.to_string(),
+            connections: self.connections.clone(),
+            pool_activity: self.pool_activity.clone(),
+        }
+    }
+
+    pub async fn get_or_create_pool(&self, connection_id: &str, database: Option<&str>) -> Result<String, String> {
+        self.get_or_create_pool_for_session(connection_id, database, None).await
+    }
+
+    pub async fn get_or_create_pool_for_connection_attempt(
+        &self,
+        connection_id: &str,
+        database: Option<&str>,
+        attempt: u64,
+    ) -> Result<String, String> {
+        self.get_or_create_pool_for_session_inner(connection_id, database, None, Some(attempt)).await
+    }
+
+    pub async fn get_or_create_pool_for_session(
+        &self,
+        connection_id: &str,
+        database: Option<&str>,
+        client_session_id: Option<&str>,
+    ) -> Result<String, String> {
+        self.get_or_create_pool_for_session_inner(connection_id, database, client_session_id, None).await
+    }
+
+    async fn get_or_create_pool_for_session_inner(
+        &self,
+        connection_id: &str,
+        database: Option<&str>,
+        client_session_id: Option<&str>,
+        connection_attempt: Option<u64>,
+    ) -> Result<String, String> {
+        let config = {
+            let configs = self.configs.read().await;
+            configs.get(connection_id).ok_or("Connection config not found")?.clone()
+        };
+        let db_type = Some(config.db_type);
+
+        let base_pool_key = base_pool_key_for(db_type, connection_id, database, false);
+        let pool_key = session_scoped_pool_key_for(Some(&config), base_pool_key, client_session_id);
+
+        let conns = self.connections.read().await;
+        if conns.contains_key(&pool_key) {
+            drop(conns);
+            if self.remove_pool_if_duckdb_isolation_mismatch(&pool_key).await {
+                // Recreate below using the current DuckDB isolation mode.
+            } else if !self.remove_stale_connection_pool(&pool_key).await {
+                self.touch_pool_activity(&pool_key).await;
+                return Ok(pool_key);
+            }
+        } else {
+            drop(conns);
+        }
+
+        let db_config = database_connection_config(&config, database);
+
+        validate_h2_file_connection(&db_config)?;
+        self.ensure_current_connection_attempt(connection_id, connection_attempt).await?;
+        let (host, port) = self.connection_host_port(connection_id, &db_config).await?;
+        if let Err(err) = self.ensure_current_connection_attempt(connection_id, connection_attempt).await {
+            self.reset_connection_transport_for_config(connection_id, &db_config).await;
+            return Err(err);
+        }
+        probe_connection_endpoint(&db_config, &host, port).await?;
+        if let Err(err) = self.ensure_current_connection_attempt(connection_id, connection_attempt).await {
+            self.reset_connection_transport_for_config(connection_id, &db_config).await;
+            return Err(err);
+        }
+        let url = connection_url_for_endpoint(&db_config, &host, port);
+        let connect_timeout = std::time::Duration::from_secs(db_config.effective_connect_timeout_secs());
+        let idle_timeout = std::time::Duration::from_secs(db_config.idle_timeout_secs);
+        let mysql_pool_max_connections = mysql_pool_max_connections_for_session(client_session_id);
+        let pool = match db_config.db_type {
+            DatabaseType::Mysql => {
+                let (pool, mode) = connect_mysql_metadata_pool(
+                    &config,
+                    &db_config,
+                    &host,
+                    port,
+                    connect_timeout,
+                    mysql_pool_max_connections,
+                )
+                .await?;
+                PoolKind::Mysql(pool, mode)
+            }
+            DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::ManticoreSearch => {
+                let pool = if database.is_none() {
+                    connect_bare_metadata_pool(&db_config, &host, port, connect_timeout, mysql_pool_max_connections)
+                        .await?
+                } else {
+                    connect_bare_mysql_pool_with_setup(
+                        &db_config,
+                        &url,
+                        connect_timeout,
+                        mysql_pool_max_connections,
+                        &oceanbase_mysql_setup_queries(&db_config),
+                    )
+                    .await?
+                };
+                PoolKind::Mysql(pool, MysqlMode::Bare)
+            }
+            DatabaseType::Postgres
+            | DatabaseType::Redshift
+            | DatabaseType::Gaussdb
+            | DatabaseType::Kwdb
+            | DatabaseType::Questdb
+            | DatabaseType::OpenGauss => {
+                let pg_pool = db::postgres::connect(&url, connect_timeout).await?;
+                // Build TLS cancel context for reconstructing TLS connection during cancel
+                if let Some(ctx) = db::postgres::build_postgres_cancel_context(&url) {
+                    self.postgres_cancel_contexts.write().await.insert(pool_key.clone(), ctx);
+                }
+                PoolKind::Postgres(pg_pool)
+            }
+            DatabaseType::Sqlite => {
+                let extensions = db::sqlite::sqlite_extension_specs_from_url_params(db_config.url_params.as_deref())
+                    .into_iter()
+                    .map(|mut extension| {
+                        extension.path = expand_tilde(&extension.path);
+                        extension
+                    })
+                    .collect();
+                PoolKind::Sqlite(
+                    db::sqlite::connect_path_with_cipher_key_and_extensions(
+                        &expand_tilde(&db_config.host),
+                        &db_config.password,
+                        extensions,
+                    )
+                    .await?,
+                )
+            }
+            DatabaseType::Rqlite => {
+                let client = db::rqlite_driver::RqliteClient::new(
+                    &url,
+                    db_config.url_params.as_deref(),
+                    &db_config.username,
+                    &db_config.password,
+                    db_config.ssl,
+                    connect_timeout,
+                )?;
+                db::rqlite_driver::test_connection(&client, connect_timeout).await?;
+                PoolKind::Rqlite(client)
+            }
+            DatabaseType::Turso => {
+                let auth_token = if !db_config.password.is_empty() {
+                    db_config.password.clone()
+                } else {
+                    db_config.url_params.as_deref().and_then(extract_auth_token_from_params).unwrap_or_default()
+                };
+                let client = db::turso_driver::TursoClient::new(&url, &auth_token, db_config.ssl, connect_timeout)?;
+                db::turso_driver::test_connection(&client, connect_timeout).await?;
+                PoolKind::Turso(client)
+            }
+            DatabaseType::CloudflareD1 => {
+                PoolKind::CloudflareD1(db::cloudflare_d1_driver::connect(&db_config, connect_timeout).await?)
+            }
+            DatabaseType::Redis => {
+                let con = if db_config.uses_redis_cluster() {
+                    db::redis_driver::RedisConnection::Cluster(
+                        self.connect_redis_cluster(connection_id, &db_config).await?,
+                    )
+                } else if db_config.uses_redis_sentinel() {
+                    db::redis_driver::RedisConnection::Direct(tokio::sync::Mutex::new(
+                        self.connect_redis_sentinel(connection_id, &db_config).await?,
+                    ))
+                } else {
+                    db::redis_driver::RedisConnection::Direct(tokio::sync::Mutex::new(
+                        db::redis_driver::connect_standalone(&db_config, &host, port, connect_timeout).await?,
+                    ))
+                };
+                PoolKind::Redis(con)
+            }
+            #[cfg(feature = "duckdb-bundled")]
+            DatabaseType::DuckDb => {
+                if self.duckdb_worker_process_isolation.load(Ordering::Relaxed) {
+                    let attached_databases = db_config
+                        .attached_databases
+                        .iter()
+                        .map(|attached| crate::models::connection::AttachedDatabaseConfig {
+                            name: attached.name.clone(),
+                            path: expand_tilde(&attached.path),
+                        })
+                        .collect();
+                    let client = db::duckdb_worker_process::DuckDbWorkerClient::open_with_process_limit(
+                        expand_tilde(&db_config.host),
+                        attached_databases,
+                        self.duckdb_worker_max_processes.load(Ordering::Relaxed),
+                    )
+                    .await?;
+                    PoolKind::DuckDbWorker(Arc::new(client))
+                } else {
+                    let con = db::duckdb_driver::connect_path(&expand_tilde(&db_config.host))?;
+                    {
+                        let locked = con.lock().map_err(|e| e.to_string())?;
+                        for attached in &db_config.attached_databases {
+                            crate::schema::duckdb_attach_database(
+                                &locked,
+                                &attached.name,
+                                &expand_tilde(&attached.path),
+                            )?;
+                        }
+                    }
+                    PoolKind::DuckDb(con)
+                }
+            }
+            #[cfg(not(feature = "duckdb-bundled"))]
+            DatabaseType::DuckDb => {
+                return Err("DuckDB support is not compiled in this build. Rebuild with default features.".to_string());
+            }
+            DatabaseType::MongoDb => {
+                if mongo_uses_legacy_driver(&db_config) {
+                    log::info!("Using configured MongoDB legacy driver for connection_id={connection_id}");
+                    let connect_params = serde_json::json!({ "connection": agent_connect_params(&db_config, &host, port, db_config.effective_database().unwrap_or("")) });
+                    let mut client = self.agent_manager.spawn(&DatabaseType::MongoDb, Some("mongodb-legacy")).await?;
+                    client.connect(connect_params).await.map_err(|err| mongo_legacy_error_with_auth_hint(&err))?;
+                    PoolKind::Agent(Arc::new(tokio::sync::Mutex::new(client)))
+                } else {
+                    let native_err = match db::mongo_driver::connect(&url, connect_timeout, idle_timeout).await {
+                        Ok(client) => match db::mongo_driver::test_connection(
+                            &client,
+                            connect_timeout,
+                            db_config.effective_database(),
+                        )
+                        .await
+                        {
+                            Ok(()) => {
+                                // Re-check: another task may have created the pool while we were connecting.
+                                if self.connections.read().await.contains_key(&pool_key) {
+                                    close_pool_kind_with_timeout(pool_key.clone(), PoolKind::MongoDb(client)).await;
+                                    return Ok(pool_key);
+                                }
+                                if let Err(err) =
+                                    self.ensure_current_connection_attempt(connection_id, connection_attempt).await
+                                {
+                                    self.discard_stale_connection_attempt_pool(
+                                        connection_id,
+                                        pool_key.clone(),
+                                        PoolKind::MongoDb(client),
+                                        &db_config,
+                                    )
+                                    .await;
+                                    return Err(err);
+                                }
+                                self.insert_connection_pool(pool_key.clone(), PoolKind::MongoDb(client), &db_config)
+                                    .await;
+                                return Ok(pool_key);
+                            }
+                            Err(e) => e,
+                        },
+                        Err(e) => e,
+                    };
+                    if should_retry_mongo_with_legacy_driver(&native_err) {
+                        log::info!("Native MongoDB driver failed ({native_err}), falling back to agent driver");
+                        let connect_params = serde_json::json!({ "connection": agent_connect_params(&db_config, &host, port, db_config.effective_database().unwrap_or("")) });
+                        let mut client =
+                            self.agent_manager.spawn(&DatabaseType::MongoDb, Some("mongodb-legacy")).await?;
+                        client.connect(connect_params).await.map_err(|err| {
+                            format!(
+                                "{native_err}\n\nFallback with MongoDB (Legacy) driver failed: {}",
+                                mongo_legacy_error_with_auth_hint(&err)
+                            )
+                        })?;
+                        PoolKind::Agent(Arc::new(tokio::sync::Mutex::new(client)))
+                    } else {
+                        return Err(native_err);
+                    }
+                }
+            }
+            DatabaseType::ClickHouse => {
+                let username = if db_config.username.is_empty() { None } else { Some(db_config.username.clone()) };
+                let password = if db_config.password.is_empty() { None } else { Some(db_config.password.clone()) };
+                let client = db::clickhouse_driver::ChClient::new_with_ca_cert(
+                    &url,
+                    username,
+                    password,
+                    Some(&db_config.ca_cert_path),
+                    connect_timeout,
+                )?;
+                db::clickhouse_driver::test_connection(&client, connect_timeout).await?;
+                PoolKind::ClickHouse(client)
+            }
+            DatabaseType::SqlServer => {
+                self.connect_sqlserver_pool_with_legacy_fallback(&db_config, &host, port, connect_timeout).await?
+            }
+            DatabaseType::Elasticsearch => {
+                let mut client = db::elasticsearch_driver::EsClient::from_config(
+                    &url,
+                    Some(&db_config.username),
+                    Some(&db_config.password),
+                    db_config.ssl,
+                    db_config.url_params.as_deref(),
+                    connect_timeout,
+                );
+                db::elasticsearch_driver::test_connection(&mut client, connect_timeout).await?;
+                PoolKind::Elasticsearch(client)
+            }
+            DatabaseType::Qdrant | DatabaseType::Milvus | DatabaseType::Weaviate | DatabaseType::ChromaDb => {
+                let kind = match db_config.db_type {
+                    DatabaseType::Qdrant => db::vector_driver::VectorDbKind::Qdrant,
+                    DatabaseType::Milvus => db::vector_driver::VectorDbKind::Milvus,
+                    DatabaseType::Weaviate => db::vector_driver::VectorDbKind::Weaviate,
+                    DatabaseType::ChromaDb => db::vector_driver::VectorDbKind::ChromaDb,
+                    _ => unreachable!(),
+                };
+                let client = db::vector_driver::VectorClient::new(
+                    kind,
+                    &url,
+                    Some(&db_config.username),
+                    Some(&db_config.password),
+                    db_config.ssl,
+                    connect_timeout,
+                );
+                db::vector_driver::test_connection(&client, connect_timeout).await?;
+                PoolKind::VectorDb(client)
+            }
+            DatabaseType::InfluxDb => {
+                let client = db::influxdb_driver::InfluxdbClient::new_for_config(&url, &db_config, connect_timeout)?;
+                db::influxdb_driver::test_connection(&client, connect_timeout).await?;
+                PoolKind::InfluxDb(client)
+            }
+            DatabaseType::Nacos => {
+                let admin_config = self.nacos_admin_config_for_connection(connection_id, &config).await?;
+                let adapter = self.nacos_registry.build_transient_config(admin_config).await?;
+                adapter.test_connection().await?;
+                PoolKind::Nacos
+            }
+            agent_connection_pool_database_type!() => {
+                let connect_params =
+                    agent_connect_params(&db_config, &host, port, db_config.effective_database().unwrap_or(""));
+                // Kerberos JVM properties are connection-scoped; shared agent daemons must not inherit them.
+                let mut client = self
+                    .agent_manager
+                    .spawn_with_extra_java_args(
+                        &db_config.db_type,
+                        db_config.driver_profile.as_deref(),
+                        &db_config.agent_java_options,
+                    )
+                    .await?;
+                let connect_result = client
+                    .call_method_with_timeout::<serde_json::Value>(
+                        AgentMethod::Connect,
+                        connect_params,
+                        Some(agent_connect_timeout(&db_config)),
+                    )
+                    .await;
+                if let Err(err) = connect_result {
+                    let alternate_configs = oracle_alternate_connect_configs(&db_config, &err);
+                    if !alternate_configs.is_empty() {
+                        log::warn!(
+                            "Oracle connect failed with {:?} descriptor: {}. Retrying with Oracle JDBC URL variants: {:?}.",
+                            db_config.oracle_connection_type,
+                            err,
+                            oracle_alternate_connect_config_labels(&alternate_configs)
+                        );
+                        let mut fallback_errors = Vec::new();
+                        let mut connected = false;
+                        for alternate_config in alternate_configs {
+                            let label = oracle_alternate_connect_config_labels(std::slice::from_ref(&alternate_config))
+                                .into_iter()
+                                .next()
+                                .unwrap_or_else(|| "alternate".to_string());
+                            match client
+                                .call_method_with_timeout::<serde_json::Value>(
+                                    AgentMethod::Connect,
+                                    agent_connect_params(
+                                        &alternate_config,
+                                        &host,
+                                        port,
+                                        alternate_config.effective_database().unwrap_or(""),
+                                    ),
+                                    Some(agent_connect_timeout(&alternate_config)),
+                                )
+                                .await
+                            {
+                                Ok(_) => {
+                                    connected = true;
+                                    break;
+                                }
+                                Err(alternate_err) => {
+                                    fallback_errors.push(format!("{label}: {alternate_err}"));
+                                }
+                            }
+                        }
+                        if !connected {
+                            return Err(format!(
+                                "{err}\n\nFallback with alternate Oracle JDBC URLs failed: {}",
+                                fallback_errors.join("\n")
+                            ));
+                        }
+                    } else {
+                        return Err(oracle_error_with_driver_hint(&db_config, &err));
+                    }
+                }
+                PoolKind::Agent(Arc::new(tokio::sync::Mutex::new(client)))
+            }
+            DatabaseType::PrestoSql => {
+                let jdbc_config = prestosql_jdbc_config_for_endpoint(&db_config, &host, port);
+                self.external_driver_pool("jdbc", &jdbc_config).await?
+            }
+            DatabaseType::Jdbc => {
+                let mut jdbc_config = db_config.clone();
+                if host != config.host || port != config.port {
+                    if let Some(ref url) = jdbc_config.connection_string {
+                        jdbc_config.connection_string = Some(rewrite_jdbc_url_host(url, &host, port));
+                    }
+                }
+                self.external_driver_pool("jdbc", &jdbc_config).await?
+            }
+            #[cfg(feature = "mq-admin")]
+            DatabaseType::MessageQueue => {
+                // MQ admin connections don't hold a data query pool. We just test
+                // connectivity via the mq_registry and insert a marker so this
+                // connection_id is recognized as valid.
+                let mqc = self.mq_admin_config_for_connection(connection_id, &config).await?;
+                let kafka_launch = crate::mq::service::resolve_kafka_launch_spec(&mqc, self);
+                let adapter = match self.mq_registry.get_or_build_config(connection_id, mqc, kafka_launch).await {
+                    Ok(adapter) => adapter,
+                    Err(err) => {
+                        self.mq_registry.drop_connection(connection_id).await;
+                        return Err(err);
+                    }
+                };
+                if let Err(err) = adapter.test_connection().await {
+                    self.mq_registry.drop_connection(connection_id).await;
+                    return Err(err);
+                }
+                if let Err(err) = self.ensure_current_connection_attempt(connection_id, connection_attempt).await {
+                    self.mq_registry.drop_connection(connection_id).await;
+                    self.reset_connection_transport_for_config(connection_id, &db_config).await;
+                    return Err(err);
+                }
+                PoolKind::MessageQueue
+            }
+            #[cfg(not(feature = "mq-admin"))]
+            DatabaseType::MessageQueue => {
+                return Err(
+                    "Message queue admin support is not compiled in this build. Rebuild with the 'mq-admin' feature."
+                        .to_string(),
+                );
+            }
+        };
+
+        if let Err(err) = self.ensure_current_connection_attempt(connection_id, connection_attempt).await {
+            self.discard_stale_connection_attempt_pool(connection_id, pool_key.clone(), pool, &db_config).await;
+            return Err(err);
+        }
+        self.insert_connection_pool(pool_key.clone(), pool, &db_config).await;
+        Ok(pool_key)
+    }
+
+    /// Returns the enabled transport layers for a connection with tunnel
+    /// profile references resolved: a layer carrying a `profile_id` is
+    /// replaced by the shared profile from storage (Settings > Tunnels), so
+    /// edits to a profile take effect for every connection referencing it.
+    /// Fails when a referenced profile no longer exists — connecting without
+    /// the intended tunnel would silently bypass it.
+    pub async fn resolved_transport_layers(
+        &self,
+        config: &ConnectionConfig,
+    ) -> Result<Vec<TransportLayerConfig>, String> {
+        let layers = config.effective_transport_layers();
+        if layers.iter().all(|layer| layer.profile_id().is_empty()) {
+            return Ok(layers);
+        }
+
+        let profiles: HashMap<String, TransportLayerConfig> = self
+            .storage
+            .load_tunnel_profiles()
+            .await?
+            .into_iter()
+            .map(|profile| (profile.id().to_string(), profile))
+            .collect();
+
+        layers
+            .into_iter()
+            .map(|layer| {
+                let profile_id = layer.profile_id();
+                if profile_id.is_empty() {
+                    return Ok(layer);
+                }
+                let Some(profile) = profiles.get(profile_id) else {
+                    let label = if layer.name().is_empty() { profile_id } else { layer.name() };
+                    return Err(format!(
+                        "Tunnel profile '{label}' referenced by this connection no longer exists. Re-create it in Settings > Tunnels or edit the connection's tunnel settings."
+                    ));
+                };
+                // Validate the stored reference again at connect time because synced or
+                // externally supplied configs may bypass the editor's type constraints.
+                if !layer.same_type_as(profile) {
+                    return Err(format!(
+                        "Tunnel profile '{}' has a different type than the referencing transport layer.",
+                        if layer.name().is_empty() { profile_id } else { layer.name() }
+                    ));
+                }
+                Ok(layer.resolved_from_profile(profile))
+            })
+            .collect()
+    }
+
+    pub async fn connection_host_port(
+        &self,
+        connection_id: &str,
+        config: &ConnectionConfig,
+    ) -> Result<(String, u16), String> {
+        let transport_layers = self.resolved_transport_layers(config).await?;
+        if transport_layers.is_empty() {
+            return Ok((config.host.clone(), config.port));
+        }
+
+        let (remote_host, remote_port) = connection_remote_endpoint(config);
+        let local_port = db::transport_layer_tunnel::start_transport_layers(
+            connection_id,
+            &transport_layers,
+            &remote_host,
+            remote_port,
+            &self.tunnels,
+            &self.proxy_tunnels,
+            &self.http_tunnels,
+        )
+        .await?;
+
+        Ok(("127.0.0.1".to_string(), local_port))
+    }
+
+    pub async fn connect_redis_sentinel(
+        &self,
+        connection_id: &str,
+        config: &ConnectionConfig,
+    ) -> Result<redis::aio::MultiplexedConnection, String> {
+        let transport_layers = self.resolved_transport_layers(config).await?;
+        if transport_layers.is_empty() {
+            return db::redis_driver::connect_sentinel(config).await;
+        }
+
+        let result = async {
+            let sentinel_nodes = db::redis_driver::redis_sentinel_node_endpoints(config)?;
+            let connect_timeout = std::time::Duration::from_secs(config.effective_connect_timeout_secs());
+            let layer_count = transport_layers.len();
+            let mut last_error = None;
+
+            for sentinel in sentinel_nodes {
+                let sentinel_tunnel_id = redis_sentinel_transport_id(connection_id, "sentinel", &sentinel);
+                let sentinel_local_port = match db::transport_layer_tunnel::start_transport_layers(
+                    &sentinel_tunnel_id,
+                    &transport_layers,
+                    &sentinel.host,
+                    sentinel.port,
+                    &self.tunnels,
+                    &self.proxy_tunnels,
+                    &self.http_tunnels,
+                )
+                .await
+                {
+                    Ok(port) => port,
+                    Err(err) => {
+                        last_error =
+                            Some(format!("Redis Sentinel {}:{} transport failed: {err}", sentinel.host, sentinel.port));
+                        continue;
+                    }
+                };
+
+                let master =
+                    match db::redis_driver::discover_sentinel_master(config, "127.0.0.1", sentinel_local_port).await {
+                        Ok(master) => master,
+                        Err(err) => {
+                            last_error = Some(format!(
+                                "Redis Sentinel {}:{} master lookup failed: {err}",
+                                sentinel.host, sentinel.port
+                            ));
+                            db::transport_layer_tunnel::stop_transport_layers(
+                                &sentinel_tunnel_id,
+                                layer_count,
+                                &self.tunnels,
+                                &self.proxy_tunnels,
+                                &self.http_tunnels,
+                            )
+                            .await;
+                            continue;
+                        }
+                    };
+
+                let master_tunnel_id = redis_sentinel_transport_id(connection_id, "master", &master);
+                let master_local_port = match db::transport_layer_tunnel::start_transport_layers(
+                    &master_tunnel_id,
+                    &transport_layers,
+                    &master.host,
+                    master.port,
+                    &self.tunnels,
+                    &self.proxy_tunnels,
+                    &self.http_tunnels,
+                )
+                .await
+                {
+                    Ok(port) => port,
+                    Err(err) => {
+                        last_error = Some(format!(
+                            "Redis Sentinel master {}:{} transport failed: {err}",
+                            master.host, master.port
+                        ));
+                        db::transport_layer_tunnel::stop_transport_layers(
+                            &sentinel_tunnel_id,
+                            layer_count,
+                            &self.tunnels,
+                            &self.proxy_tunnels,
+                            &self.http_tunnels,
+                        )
+                        .await;
+                        continue;
+                    }
+                };
+
+                match db::redis_driver::connect_standalone(config, "127.0.0.1", master_local_port, connect_timeout)
+                    .await
+                {
+                    Ok(con) => return Ok(con),
+                    Err(err) => {
+                        last_error = Some(format!(
+                            "Redis Sentinel master {}:{} connection failed: {err}",
+                            master.host, master.port
+                        ));
+                        db::transport_layer_tunnel::stop_transport_layers(
+                            &master_tunnel_id,
+                            layer_count,
+                            &self.tunnels,
+                            &self.proxy_tunnels,
+                            &self.http_tunnels,
+                        )
+                        .await;
+                        db::transport_layer_tunnel::stop_transport_layers(
+                            &sentinel_tunnel_id,
+                            layer_count,
+                            &self.tunnels,
+                            &self.proxy_tunnels,
+                            &self.http_tunnels,
+                        )
+                        .await;
+                    }
+                }
+            }
+
+            Err(last_error.unwrap_or_else(|| "Redis Sentinel master discovery failed".to_string()))
+        }
+        .await;
+
+        if result.is_err() {
+            let redis_sentinel_prefix = redis_sentinel_transport_prefix(connection_id);
+            self.tunnels.stop_tunnels_with_prefix(&redis_sentinel_prefix).await;
+            self.proxy_tunnels.stop_tunnels_with_prefix(&redis_sentinel_prefix).await;
+            self.http_tunnels.stop_tunnels_with_prefix(&redis_sentinel_prefix).await;
+        }
+
+        result
+    }
+
+    pub async fn connect_redis_cluster(
+        &self,
+        connection_id: &str,
+        config: &ConnectionConfig,
+    ) -> Result<db::redis_driver::RedisClusterPool, String> {
+        let transport_layers = self.resolved_transport_layers(config).await?;
+        if transport_layers.is_empty() {
+            return db::redis_driver::connect_cluster(config).await;
+        }
+
+        let result = async {
+            let seed_nodes = db::redis_driver::redis_cluster_seed_nodes(config)?;
+            let seed_routes = self.redis_cluster_node_routes(connection_id, &transport_layers, &seed_nodes).await?;
+            let (auth, slot_ranges) =
+                db::redis_driver::discover_cluster_slot_ranges_from_routes(config, &seed_routes).await?;
+            let master_nodes = db::redis_driver::unique_master_nodes(&slot_ranges);
+            let node_routes = self.redis_cluster_node_routes(connection_id, &transport_layers, &master_nodes).await?;
+
+            db::redis_driver::connect_routed_cluster(config, seed_routes, slot_ranges, node_routes, auth).await
+        }
+        .await;
+
+        if result.is_err() {
+            let redis_cluster_prefix = redis_cluster_transport_prefix(connection_id);
+            self.tunnels.stop_tunnels_with_prefix(&redis_cluster_prefix).await;
+            self.proxy_tunnels.stop_tunnels_with_prefix(&redis_cluster_prefix).await;
+            self.http_tunnels.stop_tunnels_with_prefix(&redis_cluster_prefix).await;
+        }
+
+        result
+    }
+
+    async fn redis_cluster_node_routes(
+        &self,
+        connection_id: &str,
+        transport_layers: &[crate::models::connection::TransportLayerConfig],
+        nodes: &[db::redis_driver::RedisNodeEndpoint],
+    ) -> Result<Vec<db::redis_driver::RedisNodeRoute>, String> {
+        let mut routes = Vec::with_capacity(nodes.len());
+        for node in nodes {
+            let tunnel_id = redis_cluster_transport_id(connection_id, node);
+            let local_port = db::transport_layer_tunnel::start_transport_layers(
+                &tunnel_id,
+                transport_layers,
+                &node.host,
+                node.port,
+                &self.tunnels,
+                &self.proxy_tunnels,
+                &self.http_tunnels,
+            )
+            .await?;
+            routes.push(db::redis_driver::RedisNodeRoute {
+                advertised: node.clone(),
+                connect: db::redis_driver::RedisNodeEndpoint { host: "127.0.0.1".to_string(), port: local_port },
+            });
+        }
+        Ok(routes)
+    }
+
+    #[cfg(feature = "mq-admin")]
+    pub async fn mq_admin_config_for_connection(
+        &self,
+        connection_id: &str,
+        config: &ConnectionConfig,
+    ) -> Result<crate::mq::config::MqAdminConfig, String> {
+        let mqc = crate::mq::config::MqAdminConfig::from_connection(config)?;
+        if !config.has_effective_transport_layers() {
+            return Ok(mqc);
+        }
+
+        let (host, port) = self.connection_host_port(connection_id, config).await?;
+        Ok(mqc.with_connect_override(&host, port))
+    }
+
+    pub async fn nacos_admin_config_for_connection(
+        &self,
+        connection_id: &str,
+        config: &ConnectionConfig,
+    ) -> Result<crate::nacos::config::NacosAdminConfig, String> {
+        let nacos_config = crate::nacos::config::NacosAdminConfig::from_connection(config)?;
+        if !config.has_effective_transport_layers() {
+            return Ok(nacos_config);
+        }
+
+        let (host, port) = self.connection_host_port(connection_id, config).await?;
+        nacos_config.with_server_endpoint(&host, port)
+    }
+
+    async fn remove_stale_connection_pool(&self, pool_key: &str) -> bool {
+        if self.running_queries.is_pool_active(pool_key) {
+            return false;
+        }
+
+        let stale = {
+            let connections = self.connections.read().await;
+            let Some(pool) = connections.get(pool_key) else {
+                return false;
+            };
+            match pool {
+                PoolKind::Mysql(pool, _) => {
+                    let pool = pool.clone();
+                    drop(connections);
+                    match tokio::time::timeout(HEALTH_CHECK_POOL_ACQUIRE_TIMEOUT, pool.get_conn()).await {
+                        // Pool saturation means active work, not a dead connection. Removing this pool would
+                        // start a competing reconnect while foreground queries and metadata are still running.
+                        Err(_) => {
+                            log::debug!("MySQL connection pool '{pool_key}' is busy; skipping health probe");
+                            false
+                        }
+                        Ok(Err(err)) => {
+                            log::warn!("MySQL connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                        Ok(Ok(mut conn)) => {
+                            let timeout = crate::db::connection_timeout();
+                            match tokio::time::timeout(timeout, conn.ping()).await {
+                                Ok(Ok(())) => false,
+                                Ok(Err(err)) => {
+                                    log::warn!("MySQL connection pool '{pool_key}' is stale: {err}");
+                                    true
+                                }
+                                Err(_) => {
+                                    log::warn!("MySQL connection pool '{pool_key}' is stale: health check timed out");
+                                    true
+                                }
+                            }
+                        }
+                    }
+                }
+                PoolKind::Postgres(pool) => {
+                    let pool = pool.clone();
+                    drop(connections);
+                    let timeout = crate::db::connection_timeout();
+                    match tokio::time::timeout(HEALTH_CHECK_POOL_ACQUIRE_TIMEOUT, pool.get()).await {
+                        Ok(Ok(client)) => match tokio::time::timeout(timeout, client.simple_query("SELECT 1")).await {
+                            Ok(Ok(_)) => false,
+                            Ok(Err(err)) => {
+                                log::warn!("PostgreSQL connection pool '{pool_key}' is stale: {err}");
+                                true
+                            }
+                            Err(_) => {
+                                log::warn!("PostgreSQL connection pool '{pool_key}' is stale: health check timed out");
+                                true
+                            }
+                        },
+                        Ok(Err(err)) => {
+                            log::warn!("PostgreSQL connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                        Err(_) => {
+                            log::debug!("PostgreSQL connection pool '{pool_key}' is busy; skipping health probe");
+                            false
+                        }
+                    }
+                }
+                PoolKind::SqlServer(client) => {
+                    let client = client.clone();
+                    drop(connections);
+                    let mut client = client.lock().await;
+                    match db::sqlserver::test_connection(&mut client).await {
+                        Ok(()) => false,
+                        Err(err) => {
+                            log::warn!("SQL Server connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                    }
+                }
+                PoolKind::Redis(redis) => match db::redis_driver::test_connection(redis).await {
+                    Ok(()) => false,
+                    Err(err) => {
+                        log::warn!("Redis connection pool '{pool_key}' is stale: {err}");
+                        true
+                    }
+                },
+                PoolKind::MongoDb(client) => {
+                    let client = client.clone();
+                    drop(connections);
+                    let (connect_timeout, database) = {
+                        let configs = self.configs.read().await;
+                        let config = config_for_pool_key(pool_key, &configs);
+                        (
+                            config
+                                .map(|config| Duration::from_secs(config.effective_connect_timeout_secs().max(1)))
+                                .unwrap_or_else(|| Duration::from_secs(1)),
+                            config.and_then(|config| config.effective_database().map(str::to_string)),
+                        )
+                    };
+                    match db::mongo_driver::test_connection(&client, connect_timeout, database.as_deref()).await {
+                        Ok(()) => false,
+                        Err(err) => {
+                            log::warn!("MongoDB connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                    }
+                }
+                PoolKind::ClickHouse(client) => {
+                    let client = client.clone();
+                    drop(connections);
+                    let timeout = crate::db::connection_timeout();
+                    match db::clickhouse_driver::test_connection(&client, timeout).await {
+                        Ok(()) => false,
+                        Err(err) => {
+                            log::warn!("ClickHouse connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                    }
+                }
+                PoolKind::Elasticsearch(client) => {
+                    let mut client = client.clone();
+                    drop(connections);
+                    let timeout = crate::db::connection_timeout();
+                    match db::elasticsearch_driver::test_connection(&mut client, timeout).await {
+                        Ok(()) => false,
+                        Err(err) => {
+                            log::warn!("Elasticsearch connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                    }
+                }
+                PoolKind::VectorDb(client) => {
+                    let client = client.clone();
+                    drop(connections);
+                    let timeout = crate::db::connection_timeout();
+                    match db::vector_driver::test_connection(&client, timeout).await {
+                        Ok(()) => false,
+                        Err(err) => {
+                            log::warn!("VectorDB connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                    }
+                }
+                PoolKind::InfluxDb(client) => {
+                    let client = client.clone();
+                    drop(connections);
+                    let timeout = crate::db::connection_timeout();
+                    match db::influxdb_driver::test_connection(&client, timeout).await {
+                        Ok(()) => false,
+                        Err(err) => {
+                            log::warn!("InfluxDB connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                    }
+                }
+                PoolKind::Rqlite(client) => {
+                    let client = client.clone();
+                    drop(connections);
+                    let timeout = crate::db::connection_timeout();
+                    match db::rqlite_driver::test_connection(&client, timeout).await {
+                        Ok(()) => false,
+                        Err(err) => {
+                            log::warn!("rqlite connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                    }
+                }
+                PoolKind::Turso(client) => {
+                    let client = client.clone();
+                    drop(connections);
+                    let timeout = crate::db::connection_timeout();
+                    match db::turso_driver::test_connection(&client, timeout).await {
+                        Ok(()) => false,
+                        Err(err) => {
+                            log::warn!("Turso connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                    }
+                }
+                PoolKind::CloudflareD1(client) => {
+                    let client = client.clone();
+                    drop(connections);
+                    let timeout = crate::db::connection_timeout();
+                    match db::cloudflare_d1_driver::test_connection(&client, timeout).await {
+                        Ok(()) => false,
+                        Err(err) => {
+                            log::warn!("Cloudflare D1 connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                    }
+                }
+                PoolKind::Agent(client) => {
+                    let client = client.clone();
+                    drop(connections);
+                    let mut agent = client.lock().await;
+                    let timeout = crate::db::connection_timeout();
+                    match agent.validate_connection(Some(timeout)).await {
+                        Ok(_) => false,
+                        Err(err) if is_agent_validate_connection_unsupported(&err) => {
+                            log::debug!(
+                                "Agent connection pool '{pool_key}' does not support validate_connection; keeping pool"
+                            );
+                            false
+                        }
+                        Err(err) => {
+                            log::warn!("Agent connection pool '{pool_key}' is stale: {err}");
+                            true
+                        }
+                    }
+                }
+                PoolKind::Sqlite(_)
+                | PoolKind::DuckDb(_)
+                | PoolKind::DuckDbWorker(_)
+                | PoolKind::ExternalTabular(_)
+                | PoolKind::ExternalDriver { .. }
+                | PoolKind::MessageQueue
+                | PoolKind::Nacos => false,
+            }
+        };
+
+        if !stale {
+            return false;
+        }
+
+        self.stop_keepalive_task(pool_key).await;
+        self.pool_activity.write().await.remove(pool_key);
+        self.postgres_cancel_contexts.write().await.remove(pool_key);
+        let removed = self.connections.write().await.remove(pool_key);
+        if let Some(pool) = removed {
+            close_pool_kind_with_timeout(pool_key.to_string(), pool).await;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub async fn reconnect_pool(&self, connection_id: &str, database: Option<&str>) -> Result<String, String> {
+        self.reconnect_pool_for_session(connection_id, database, None).await
+    }
+
+    pub async fn reconnect_pool_for_session(
+        &self,
+        connection_id: &str,
+        database: Option<&str>,
+        client_session_id: Option<&str>,
+    ) -> Result<String, String> {
+        let config = {
+            let configs = self.configs.read().await;
+            configs.get(connection_id).cloned()
+        };
+        let db_type = config.as_ref().map(|config| config.db_type);
+        let base_pool_key = base_pool_key_for(db_type, connection_id, database, true);
+        let pool_key = session_scoped_pool_key_for(config.as_ref(), base_pool_key, client_session_id);
+        if self.uses_forwarded_transport(connection_id).await {
+            self.remove_connection_pools(connection_id).await;
+            self.reset_connection_transport(connection_id).await;
+        } else {
+            self.stop_keepalive_task(&pool_key).await;
+            self.pool_activity.write().await.remove(&pool_key);
+            self.postgres_cancel_contexts.write().await.remove(&pool_key);
+            let removed = self.connections.write().await.remove(&pool_key);
+            if let Some(pool) = removed {
+                close_pool_kind_with_timeout(pool_key.clone(), pool).await;
+            }
+        }
+        self.get_or_create_pool_for_session(connection_id, database, client_session_id).await
+    }
+
+    pub async fn close_client_session_pool(
+        &self,
+        connection_id: &str,
+        database: Option<&str>,
+        client_session_id: &str,
+    ) -> Result<bool, String> {
+        let session = normalize_client_session_id(Some(client_session_id));
+        let Some(session) = session else {
+            return Ok(false);
+        };
+        let config = {
+            let configs = self.configs.read().await;
+            configs.get(connection_id).cloned()
+        };
+        let db_type = config.as_ref().map(|config| config.db_type);
+        let base_pool_key = base_pool_key_for(db_type, connection_id, database, false);
+        let pool_key = session_scoped_pool_key_for(config.as_ref(), base_pool_key.clone(), Some(&session));
+        if pool_key == base_pool_key {
+            return Ok(false);
+        }
+        self.stop_keepalive_task(&pool_key).await;
+        self.pool_activity.write().await.remove(&pool_key);
+        self.postgres_cancel_contexts.write().await.remove(&pool_key);
+        let removed = self.connections.write().await.remove(&pool_key);
+        if let Some(pool) = removed {
+            close_pool_kind_with_timeout(pool_key, pool).await;
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    pub async fn remove_pool_by_key(&self, pool_key: &str) -> bool {
+        self.stop_keepalive_task(pool_key).await;
+        self.pool_activity.write().await.remove(pool_key);
+        self.postgres_cancel_contexts.write().await.remove(pool_key);
+        let removed = self.connections.write().await.remove(pool_key);
+        if let Some(pool) = removed {
+            close_pool_kind_with_timeout(pool_key.to_string(), pool).await;
+            true
+        } else {
+            false
+        }
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    async fn remove_pool_by_key_detached(&self, pool_key: &str) -> bool {
+        self.stop_keepalive_task(pool_key).await;
+        self.pool_activity.write().await.remove(pool_key);
+        self.postgres_cancel_contexts.write().await.remove(pool_key);
+        let removed = self.connections.write().await.remove(pool_key);
+        if let Some(pool) = removed {
+            close_removed_pools_in_background(vec![(pool_key.to_string(), pool)]);
+            true
+        } else {
+            false
+        }
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    async fn remove_pool_if_duckdb_isolation_mismatch(&self, pool_key: &str) -> bool {
+        let isolation_enabled = self.duckdb_worker_process_isolation.load(Ordering::Relaxed);
+        let mismatch = {
+            let connections = self.connections.read().await;
+            match connections.get(pool_key) {
+                Some(PoolKind::DuckDb(_)) => isolation_enabled,
+                Some(PoolKind::DuckDbWorker(_)) => !isolation_enabled,
+                _ => false,
+            }
+        };
+        if mismatch {
+            self.remove_pool_by_key_detached(pool_key).await
+        } else {
+            false
+        }
+    }
+
+    #[cfg(not(feature = "duckdb-bundled"))]
+    async fn remove_pool_if_duckdb_isolation_mismatch(&self, _pool_key: &str) -> bool {
+        false
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    pub fn spawn_duckdb_pool_cleanup(&self, pool_key: String, con: DuckDbHandle) {
+        let connections = self.connections.clone();
+        let keepalive_tasks = self.keepalive_tasks.clone();
+        let pool_activity = self.pool_activity.clone();
+        let postgres_cancel_contexts = self.postgres_cancel_contexts.clone();
+        tokio::spawn(async move {
+            while Arc::strong_count(&con) > 2 {
+                tokio::time::sleep(Duration::from_millis(50)).await;
+            }
+            if let Some(handle) = keepalive_tasks.write().await.remove(&pool_key) {
+                handle.abort();
+            }
+            pool_activity.write().await.remove(&pool_key);
+            postgres_cancel_contexts.write().await.remove(&pool_key);
+            let removed = {
+                let mut conns = connections.write().await;
+                match conns.get(&pool_key) {
+                    Some(PoolKind::DuckDb(current)) if Arc::ptr_eq(current, &con) => conns.remove(&pool_key),
+                    _ => None,
+                }
+            };
+            if let Some(pool) = removed {
+                // Keep the old DuckDB pool marked as draining until it is no longer
+                // visible in the pool map, otherwise a concurrent query could reuse it.
+                con.clear_draining();
+                drop(con);
+                close_pool_kind_with_timeout(pool_key, pool).await;
+            }
+        });
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    pub fn spawn_duckdb_draining_cleanup(
+        &self,
+        pool_key: String,
+        con: DuckDbHandle,
+        task: JoinHandle<Result<db::QueryResult, String>>,
+    ) {
+        let connections = self.connections.clone();
+        let keepalive_tasks = self.keepalive_tasks.clone();
+        let pool_activity = self.pool_activity.clone();
+        let postgres_cancel_contexts = self.postgres_cancel_contexts.clone();
+        tokio::spawn(async move {
+            let _ = task.await;
+            while Arc::strong_count(&con) > 2 {
+                tokio::time::sleep(Duration::from_millis(50)).await;
+            }
+            if let Some(handle) = keepalive_tasks.write().await.remove(&pool_key) {
+                handle.abort();
+            }
+            pool_activity.write().await.remove(&pool_key);
+            postgres_cancel_contexts.write().await.remove(&pool_key);
+            let removed = {
+                let mut conns = connections.write().await;
+                match conns.get(&pool_key) {
+                    Some(PoolKind::DuckDb(current)) if Arc::ptr_eq(current, &con) => conns.remove(&pool_key),
+                    _ => None,
+                }
+            };
+            if let Some(pool) = removed {
+                // Keep the old DuckDB pool marked as draining until it is no longer
+                // visible in the pool map, otherwise a concurrent query could reuse it.
+                con.clear_draining();
+                drop(con);
+                close_pool_kind_with_timeout(pool_key, pool).await;
+            }
+        });
+    }
+
+    pub async fn close_database_pool(&self, connection_id: &str, database: Option<&str>) -> Result<bool, String> {
+        let db_type = {
+            let configs = self.configs.read().await;
+            configs.get(connection_id).map(|c| c.db_type)
+        };
+        if database.is_some() && db_type.is_some_and(|db_type| shares_database_pool_with_connection(&db_type)) {
+            return Ok(false);
+        }
+        let base_pool_key = base_pool_key_for(db_type, connection_id, database, false);
+        let session_prefix = format!("{base_pool_key}:session:");
+        let keys_to_remove: Vec<String> = self
+            .connections
+            .read()
+            .await
+            .keys()
+            .filter(|key| *key == &base_pool_key || key.starts_with(&session_prefix))
+            .cloned()
+            .collect();
+        self.stop_keepalive_tasks(&keys_to_remove).await;
+        {
+            let mut activity = self.pool_activity.write().await;
+            let mut cancel_contexts = self.postgres_cancel_contexts.write().await;
+            for key in &keys_to_remove {
+                activity.remove(key);
+                cancel_contexts.remove(key);
+            }
+        }
+        let mut conns = self.connections.write().await;
+        let mut removed = Vec::with_capacity(keys_to_remove.len());
+        for key in keys_to_remove {
+            if let Some(pool) = conns.remove(&key) {
+                removed.push((key, pool));
+            }
+        }
+        drop(conns);
+        let closed = !removed.is_empty();
+        for (key, pool) in removed {
+            close_pool_kind_with_timeout(key, pool).await;
+        }
+        Ok(closed)
+    }
+
+    pub async fn active_agent_driver_keys(&self) -> HashSet<String> {
+        let configs = self.configs.read().await;
+        let connections = self.connections.read().await;
+        let mut keys = HashSet::new();
+
+        for (pool_key, pool) in connections.iter() {
+            if !matches!(pool, PoolKind::Agent(_)) {
+                continue;
+            }
+            let Some(config) = config_for_pool_key(pool_key, &configs) else {
+                continue;
+            };
+            if let Some(agent_key) = crate::agent_manager::AgentManager::db_type_to_agent_key(
+                &config.db_type,
+                config.driver_profile.as_deref(),
+            ) {
+                keys.insert(agent_key.to_string());
+            }
+        }
+
+        drop(connections);
+        drop(configs);
+
+        for key in self.agent_manager.active_daemon_keys().await {
+            keys.insert(key);
+        }
+
+        keys
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    pub async fn duckdb_existing_pool_is_usable_for_config(&self, config: &ConnectionConfig) -> Result<bool, String> {
+        if config.db_type != DatabaseType::DuckDb {
+            return Ok(false);
+        }
+
+        let matches_existing_config = {
+            let configs = self.configs.read().await;
+            configs.get(&config.id).is_some_and(|existing| {
+                existing.db_type == DatabaseType::DuckDb && duckdb_paths_match(&existing.host, &config.host)
+            })
+        };
+        if !matches_existing_config {
+            return Ok(false);
+        }
+
+        let duckdb_pool = {
+            let conns = self.connections.read().await;
+            match conns.get(&config.id) {
+                Some(PoolKind::DuckDb(con)) => Some(con.clone()),
+                _ => None,
+            }
+        };
+
+        let Some(con) = duckdb_pool else {
+            return Ok(false);
+        };
+
+        let locked = con.lock().map_err(|e| e.to_string())?;
+        locked.execute_batch("SELECT 1;").map_err(|e| format!("DuckDb connection failed: {e}"))?;
+        Ok(true)
+    }
+
+    pub async fn reset_connection_transport(&self, connection_id: &str) {
+        let layer_count = {
+            let configs = self.configs.read().await;
+            configs.get(connection_id).map(|config| config.effective_transport_layers().len()).unwrap_or(0)
+        };
+        self.reset_connection_transport_layers(connection_id, layer_count).await;
+    }
+
+    pub async fn reset_connection_transport_for_config(&self, connection_id: &str, config: &ConnectionConfig) {
+        let existing_layer_count = {
+            let configs = self.configs.read().await;
+            configs.get(connection_id).map(|config| config.effective_transport_layers().len()).unwrap_or(0)
+        };
+        let layer_count = existing_layer_count.max(config.effective_transport_layers().len());
+        self.reset_connection_transport_layers(connection_id, layer_count).await;
+    }
+
+    async fn reset_connection_transport_layers(&self, connection_id: &str, layer_count: usize) {
+        let redis_cluster_prefix = redis_cluster_transport_prefix(connection_id);
+        self.tunnels.stop_tunnels_with_prefix(&redis_cluster_prefix).await;
+        self.proxy_tunnels.stop_tunnels_with_prefix(&redis_cluster_prefix).await;
+        self.http_tunnels.stop_tunnels_with_prefix(&redis_cluster_prefix).await;
+        let redis_sentinel_prefix = redis_sentinel_transport_prefix(connection_id);
+        self.tunnels.stop_tunnels_with_prefix(&redis_sentinel_prefix).await;
+        self.proxy_tunnels.stop_tunnels_with_prefix(&redis_sentinel_prefix).await;
+        self.http_tunnels.stop_tunnels_with_prefix(&redis_sentinel_prefix).await;
+        db::transport_layer_tunnel::stop_transport_layers(
+            connection_id,
+            layer_count,
+            &self.tunnels,
+            &self.proxy_tunnels,
+            &self.http_tunnels,
+        )
+        .await;
+        self.tunnels.stop_tunnel(connection_id).await;
+        self.proxy_tunnels.stop_tunnel(connection_id).await;
+        self.http_tunnels.stop_tunnel(connection_id).await;
+    }
+
+    /// Health-check the base connection pool for a given connection_id.
+    /// Returns `Ok(())` if the pool exists and is healthy, `Err` otherwise.
+    /// If the pool is unhealthy it is removed from the map so subsequent
+    /// `get_or_create_pool` calls will transparently recreate it.
+    pub async fn check_connection_health(&self, connection_id: &str) -> Result<(), String> {
+        let db_type = {
+            let configs = self.configs.read().await;
+            configs.get(connection_id).map(|c| c.db_type)
+        };
+        let pool_key = base_pool_key_for(db_type, connection_id, None, false);
+
+        // Check if pool exists first
+        {
+            let connections = self.connections.read().await;
+            if !connections.contains_key(&pool_key) {
+                return Err("No active connection pool found".to_string());
+            }
+        }
+
+        // `remove_stale_connection_pool` returns true if the pool was stale (and removed)
+        if self.remove_stale_connection_pool(&pool_key).await {
+            return Err("Connection pool is unhealthy".to_string());
+        }
+        Ok(())
+    }
+
+    pub async fn refresh_connections(&self) {
+        // Clone pool handles under a short-lived read lock, then release it
+        // before performing I/O-heavy health checks to avoid blocking writers.
+        // Redis pools are handled separately because RedisConnection cannot be cloned.
+        let (checks, redis_keys): (Vec<(String, PoolKind)>, Vec<String>) = {
+            let conns = self.connections.read().await;
+            let mut checks = Vec::with_capacity(conns.len());
+            let mut redis_keys = Vec::new();
+            for (key, pool) in conns.iter() {
+                match pool {
+                    PoolKind::Redis(_) => redis_keys.push(key.clone()),
+                    _ => checks.push((key.clone(), clone_pool_kind(pool))),
+                }
+            }
+            (checks, redis_keys)
+        };
+
+        let mut dead_keys = Vec::new();
+        let timeout = crate::db::connection_timeout();
+
+        // Check cloned pools (async I/O, no lock held)
+        for (key, pool) in &checks {
+            let healthy = match pool {
+                PoolKind::Mysql(p, _) => match db::mysql::get_conn_with_health_check(p).await {
+                    Ok(_) => true,
+                    Err(e) => {
+                        log::warn!("MySQL connection pool '{key}' is unhealthy: {e}");
+                        false
+                    }
+                },
+                PoolKind::Postgres(p) => match tokio::time::timeout(timeout, p.get()).await {
+                    Ok(Ok(client)) => match tokio::time::timeout(timeout, client.simple_query("SELECT 1")).await {
+                        Ok(Ok(_)) => true,
+                        Ok(Err(e)) => {
+                            log::warn!("PostgreSQL connection pool '{key}' is unhealthy: {e}");
+                            false
+                        }
+                        Err(_) => {
+                            log::warn!("PostgreSQL connection pool '{key}' is unhealthy: health check timed out");
+                            false
+                        }
+                    },
+                    Ok(Err(e)) => {
+                        log::warn!("PostgreSQL connection pool '{key}' is unhealthy: {e}");
+                        false
+                    }
+                    Err(_) => {
+                        log::warn!("PostgreSQL connection pool '{key}' is unhealthy: get connection timed out");
+                        false
+                    }
+                },
+                PoolKind::SqlServer(client) => {
+                    let mut client = client.lock().await;
+                    match db::sqlserver::test_connection(&mut client).await {
+                        Ok(()) => true,
+                        Err(e) => {
+                            log::warn!("SQL Server connection pool '{key}' is unhealthy: {e}");
+                            false
+                        }
+                    }
+                }
+                PoolKind::MongoDb(client) => match db::mongo_driver::test_connection(client, timeout, None).await {
+                    Ok(()) => true,
+                    Err(e) => {
+                        log::warn!("MongoDB connection pool '{key}' is unhealthy: {e}");
+                        false
+                    }
+                },
+                PoolKind::ClickHouse(client) => match db::clickhouse_driver::test_connection(client, timeout).await {
+                    Ok(()) => true,
+                    Err(e) => {
+                        log::warn!("ClickHouse connection pool '{key}' is unhealthy: {e}");
+                        false
+                    }
+                },
+                PoolKind::Elasticsearch(client) => {
+                    let mut client = client.clone();
+                    match db::elasticsearch_driver::test_connection(&mut client, timeout).await {
+                        Ok(()) => true,
+                        Err(e) => {
+                            log::warn!("Elasticsearch connection pool '{key}' is unhealthy: {e}");
+                            false
+                        }
+                    }
+                }
+                PoolKind::VectorDb(client) => match db::vector_driver::test_connection(client, timeout).await {
+                    Ok(()) => true,
+                    Err(e) => {
+                        log::warn!("VectorDB connection pool '{key}' is unhealthy: {e}");
+                        false
+                    }
+                },
+                PoolKind::InfluxDb(client) => match db::influxdb_driver::test_connection(client, timeout).await {
+                    Ok(()) => true,
+                    Err(e) => {
+                        log::warn!("InfluxDB connection pool '{key}' is unhealthy: {e}");
+                        false
+                    }
+                },
+                PoolKind::Rqlite(client) => match db::rqlite_driver::test_connection(client, timeout).await {
+                    Ok(()) => true,
+                    Err(e) => {
+                        log::warn!("rqlite connection pool '{key}' is unhealthy: {e}");
+                        false
+                    }
+                },
+                PoolKind::Turso(client) => match db::turso_driver::test_connection(client, timeout).await {
+                    Ok(()) => true,
+                    Err(e) => {
+                        log::warn!("Turso connection pool '{key}' is unhealthy: {e}");
+                        false
+                    }
+                },
+                PoolKind::CloudflareD1(client) => {
+                    match db::cloudflare_d1_driver::test_connection(client, timeout).await {
+                        Ok(()) => true,
+                        Err(e) => {
+                            log::warn!("Cloudflare D1 connection pool '{key}' is unhealthy: {e}");
+                            false
+                        }
+                    }
+                }
+                PoolKind::Agent(client) => {
+                    let mut agent = client.lock().await;
+                    match agent.test_connection(serde_json::json!({})).await {
+                        Ok(_) => true,
+                        Err(e) => {
+                            log::warn!("Agent connection pool '{key}' is unhealthy: {e}");
+                            false
+                        }
+                    }
+                }
+                PoolKind::Sqlite(_)
+                | PoolKind::DuckDb(_)
+                | PoolKind::DuckDbWorker(_)
+                | PoolKind::ExternalTabular(_)
+                | PoolKind::ExternalDriver { .. }
+                | PoolKind::MessageQueue
+                | PoolKind::Nacos => true,
+                PoolKind::Redis(_) => unreachable!("Redis handled separately"),
+            };
+            if !healthy {
+                dead_keys.push(key.clone());
+            }
+        }
+
+        // Check Redis pools (read lock held briefly, no cloning needed)
+        {
+            let conns = self.connections.read().await;
+            for key in &redis_keys {
+                if let Some(PoolKind::Redis(redis)) = conns.get(key) {
+                    match db::redis_driver::test_connection(redis).await {
+                        Ok(()) => {}
+                        Err(e) => {
+                            log::warn!("Redis connection pool '{key}' is unhealthy: {e}");
+                            dead_keys.push(key.clone());
+                        }
+                    }
+                }
+            }
+        }
+
+        // Remove dead pools
+        if !dead_keys.is_empty() {
+            self.stop_keepalive_tasks(&dead_keys).await;
+            {
+                let mut activity = self.pool_activity.write().await;
+                for key in &dead_keys {
+                    activity.remove(key);
+                }
+            }
+            let mut conns = self.connections.write().await;
+            let mut removed = Vec::with_capacity(dead_keys.len());
+            for key in &dead_keys {
+                if let Some(pool) = conns.remove(key) {
+                    removed.push((key.clone(), pool));
+                }
+            }
+            drop(conns);
+            close_removed_pools(removed).await;
+        }
+
+        // Re-establish SSH tunnels that have died
+        let tunnel_connection_ids: Vec<String> = {
+            let configs = self.configs.read().await;
+            configs.iter().filter(|(_, c)| c.has_effective_transport_layers()).map(|(id, _)| id.clone()).collect()
+        };
+        for connection_id in tunnel_connection_ids {
+            self.reset_connection_transport(&connection_id).await;
+            // Tunnels will be re-created on next pool access via connection_host_port
+        }
+    }
+
+    pub async fn remove_connection_pools(&self, connection_id: &str) {
+        let removed = self.drain_connection_pools(connection_id).await;
+        close_removed_pools(removed).await;
+    }
+
+    pub async fn remove_connection_pools_detached(&self, connection_id: &str) {
+        let removed = self.drain_connection_pools(connection_id).await;
+        close_removed_pools_in_background(removed);
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    async fn remove_duckdb_pools_detached(&self) {
+        let removed = self.drain_duckdb_pools().await;
+        close_removed_pools_in_background(removed);
+    }
+
+    #[cfg(not(feature = "duckdb-bundled"))]
+    async fn remove_duckdb_pools_detached(&self) {}
+
+    pub async fn remove_external_driver_pools(&self, driver_id: &str) {
+        let removed = self.drain_external_driver_pools(driver_id).await;
+        close_removed_pools(removed).await;
+    }
+
+    async fn drain_connection_pools(&self, connection_id: &str) -> Vec<(String, PoolKind)> {
+        let pool_prefix = format!("{connection_id}:");
+        let keys_to_remove: Vec<String> = self
+            .connections
+            .read()
+            .await
+            .keys()
+            .filter(|k| *k == connection_id || k.starts_with(&pool_prefix))
+            .cloned()
+            .collect();
+        self.stop_keepalive_tasks(&keys_to_remove).await;
+        {
+            let mut activity = self.pool_activity.write().await;
+            let mut cancel_contexts = self.postgres_cancel_contexts.write().await;
+            for key in &keys_to_remove {
+                activity.remove(key);
+                cancel_contexts.remove(key);
+            }
+        }
+        let mut conns = self.connections.write().await;
+        let mut removed = Vec::with_capacity(keys_to_remove.len());
+        for key in keys_to_remove {
+            if let Some(pool) = conns.remove(&key) {
+                removed.push((key, pool));
+            }
+        }
+        drop(conns);
+        // Also drop the MQ admin adapter if this is an MQ connection.
+        #[cfg(feature = "mq-admin")]
+        self.mq_registry.drop_connection(connection_id).await;
+        removed
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    async fn drain_duckdb_pools(&self) -> Vec<(String, PoolKind)> {
+        let keys_to_remove: Vec<String> = self
+            .connections
+            .read()
+            .await
+            .iter()
+            .filter_map(|(key, pool)| match pool {
+                PoolKind::DuckDb(_) | PoolKind::DuckDbWorker(_) => Some(key.clone()),
+                _ => None,
+            })
+            .collect();
+        self.stop_keepalive_tasks(&keys_to_remove).await;
+        {
+            let mut activity = self.pool_activity.write().await;
+            let mut cancel_contexts = self.postgres_cancel_contexts.write().await;
+            for key in &keys_to_remove {
+                activity.remove(key);
+                cancel_contexts.remove(key);
+            }
+        }
+        let mut conns = self.connections.write().await;
+        let mut removed = Vec::with_capacity(keys_to_remove.len());
+        for key in keys_to_remove {
+            if let Some(pool) = conns.remove(&key) {
+                removed.push((key, pool));
+            }
+        }
+        removed
+    }
+
+    async fn drain_external_driver_pools(&self, driver_id: &str) -> Vec<(String, PoolKind)> {
+        let keys_to_remove: Vec<String> = self
+            .connections
+            .read()
+            .await
+            .iter()
+            .filter_map(|(key, pool)| match pool {
+                PoolKind::ExternalDriver { driver_id: pool_driver_id, .. } if pool_driver_id == driver_id => {
+                    Some(key.clone())
+                }
+                _ => None,
+            })
+            .collect();
+        self.stop_keepalive_tasks(&keys_to_remove).await;
+        {
+            let mut activity = self.pool_activity.write().await;
+            for key in &keys_to_remove {
+                activity.remove(key);
+            }
+        }
+        let mut conns = self.connections.write().await;
+        let mut removed = Vec::with_capacity(keys_to_remove.len());
+        for key in keys_to_remove {
+            if let Some(pool) = conns.remove(&key) {
+                removed.push((key, pool));
+            }
+        }
+        removed
+    }
+
+    async fn uses_forwarded_transport(&self, connection_id: &str) -> bool {
+        let configs = self.configs.read().await;
+        configs.get(connection_id).is_some_and(|config| config.has_effective_transport_layers())
+    }
+}
+
+enum KeepaliveTarget {
+    Mysql(db::mysql::MySqlPool),
+    Postgres(deadpool_postgres::Pool),
+    Rqlite(db::rqlite_driver::RqliteClient),
+    Turso(db::turso_driver::TursoClient),
+    MongoDb { client: mongodb::Client, database: Option<String> },
+    ClickHouse(db::clickhouse_driver::ChClient),
+    SqlServer(Arc<tokio::sync::Mutex<db::sqlserver::SqlServerClient>>),
+    Elasticsearch(db::elasticsearch_driver::EsClient),
+    VectorDb(db::vector_driver::VectorClient),
+    InfluxDb(db::influxdb_driver::InfluxdbClient),
+    Agent(Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>),
+}
+
+fn keepalive_target_from_pool(pool: &PoolKind, config: &ConnectionConfig) -> Option<KeepaliveTarget> {
+    match pool {
+        PoolKind::Mysql(pool, _) => Some(KeepaliveTarget::Mysql(pool.clone())),
+        PoolKind::Postgres(pool) => Some(KeepaliveTarget::Postgres(pool.clone())),
+        PoolKind::Rqlite(client) => Some(KeepaliveTarget::Rqlite(client.clone())),
+        PoolKind::Turso(client) => Some(KeepaliveTarget::Turso(client.clone())),
+        PoolKind::MongoDb(client) => Some(KeepaliveTarget::MongoDb {
+            client: client.clone(),
+            database: config.effective_database().map(str::to_string),
+        }),
+        PoolKind::ClickHouse(client) => Some(KeepaliveTarget::ClickHouse(client.clone())),
+        PoolKind::SqlServer(client) => Some(KeepaliveTarget::SqlServer(client.clone())),
+        PoolKind::Elasticsearch(client) => Some(KeepaliveTarget::Elasticsearch(client.clone())),
+        PoolKind::VectorDb(client) => Some(KeepaliveTarget::VectorDb(client.clone())),
+        PoolKind::InfluxDb(client) => Some(KeepaliveTarget::InfluxDb(client.clone())),
+        PoolKind::Agent(client) => Some(KeepaliveTarget::Agent(client.clone())),
+        _ => None,
+    }
+}
+
+async fn ping_keepalive_target(target: &mut KeepaliveTarget, timeout: Duration) -> Result<(), String> {
+    match target {
+        KeepaliveTarget::Mysql(pool) => {
+            let mut conn = db::mysql::get_conn_with_health_check(pool).await?;
+            conn.ping().await.map_err(|e| e.to_string())
+        }
+        KeepaliveTarget::Postgres(pool) => {
+            let client = pool.get().await.map_err(|e| format!("PostgreSQL pool error: {e}"))?;
+            client.simple_query("SELECT 1").await.map(|_| ()).map_err(|e| e.to_string())
+        }
+        KeepaliveTarget::Rqlite(client) => db::rqlite_driver::test_connection(client, timeout).await,
+        KeepaliveTarget::Turso(client) => db::turso_driver::test_connection(client, timeout).await,
+        KeepaliveTarget::MongoDb { client, database } => {
+            db::mongo_driver::test_connection(client, timeout, database.as_deref()).await
+        }
+        KeepaliveTarget::ClickHouse(client) => db::clickhouse_driver::test_connection(client, timeout).await,
+        KeepaliveTarget::SqlServer(client) => {
+            let Ok(mut client) = client.try_lock() else {
+                return Ok(());
+            };
+            db::sqlserver::test_connection(&mut client).await
+        }
+        KeepaliveTarget::Elasticsearch(client) => db::elasticsearch_driver::test_connection(client, timeout).await,
+        KeepaliveTarget::VectorDb(client) => db::vector_driver::test_connection(client, timeout).await,
+        KeepaliveTarget::InfluxDb(client) => db::influxdb_driver::test_connection(client, timeout).await,
+        KeepaliveTarget::Agent(client) => {
+            let Ok(mut client) = client.try_lock() else {
+                return Ok(());
+            };
+            match client.validate_connection(Some(timeout)).await {
+                Ok(_) => Ok(()),
+                Err(err) if is_agent_validate_connection_unsupported(&err) => Ok(()),
+                Err(err) => {
+                    client.kill();
+                    Err(err)
+                }
+            }
+        }
+    }
+}
+
+fn is_agent_validate_connection_unsupported(err: &str) -> bool {
+    let lower = err.to_ascii_lowercase();
+    lower.contains("validate_connection") && (lower.contains("unknown method") || lower.contains("method not found"))
+}
+
+fn connection_remote_endpoint(config: &ConnectionConfig) -> (String, u16) {
+    if config.db_type == DatabaseType::MongoDb {
+        config
+            .connection_string
+            .as_deref()
+            .filter(|s| !s.is_empty())
+            .and_then(parse_mongo_first_host)
+            .unwrap_or_else(|| (config.host.clone(), config.port))
+    } else if config.db_type == DatabaseType::Jdbc {
+        config
+            .connection_string
+            .as_deref()
+            .filter(|s| !s.is_empty())
+            .and_then(parse_jdbc_host_port)
+            .unwrap_or_else(|| (config.host.clone(), config.port))
+    } else if config.db_type == DatabaseType::MessageQueue {
+        parse_mq_admin_host_port(config).unwrap_or_else(|| (config.host.clone(), config.port))
+    } else if config.db_type == DatabaseType::Nacos {
+        parse_nacos_server_host_port(config).unwrap_or_else(|| (config.host.clone(), config.port))
+    } else {
+        (config.host.clone(), config.port)
+    }
+}
+
+fn parse_mq_admin_host_port(config: &ConnectionConfig) -> Option<(String, u16)> {
+    let value = config
+        .external_config
+        .as_ref()?
+        .get("adminUrl")
+        .or_else(|| config.external_config.as_ref()?.get("admin_url"))?
+        .as_str()?
+        .trim();
+    if value.is_empty() {
+        return None;
+    }
+    let url = reqwest::Url::parse(value).ok()?;
+    let host = url.host_str()?.to_string();
+    let port = url.port_or_known_default()?;
+    Some((host, port))
+}
+
+fn parse_nacos_server_host_port(config: &ConnectionConfig) -> Option<(String, u16)> {
+    let value = config
+        .external_config
+        .as_ref()?
+        .get("serverAddr")
+        .or_else(|| config.external_config.as_ref()?.get("server_addr"))?
+        .as_str()?
+        .trim();
+    if value.is_empty() {
+        return None;
+    }
+    let url = reqwest::Url::parse(value).ok()?;
+    let host = url.host_str()?.to_string();
+    let port = url.port_or_known_default()?;
+    Some((host, port))
+}
+
+fn normalize_client_session_id(client_session_id: Option<&str>) -> Option<String> {
+    client_session_id.map(str::trim).filter(|session| !session.is_empty()).map(|session| session.replace(':', "_"))
+}
+
+pub fn task_client_session_id(task_kind: &str, task_id: &str) -> String {
+    format!("{task_kind}:{task_id}")
+}
+
+fn mysql_pool_max_connections_for_session(client_session_id: Option<&str>) -> usize {
+    if normalize_client_session_id(client_session_id).is_some() {
+        1
+    } else {
+        10
+    }
+}
+
+fn redis_cluster_transport_prefix(connection_id: &str) -> String {
+    format!("{connection_id}:redis-cluster:")
+}
+
+fn redis_cluster_transport_id(connection_id: &str, endpoint: &db::redis_driver::RedisNodeEndpoint) -> String {
+    format!(
+        "{}{host}:{port}",
+        redis_cluster_transport_prefix(connection_id),
+        host = endpoint.host,
+        port = endpoint.port
+    )
+}
+
+fn redis_sentinel_transport_prefix(connection_id: &str) -> String {
+    format!("{connection_id}:redis-sentinel:")
+}
+
+fn redis_sentinel_transport_id(
+    connection_id: &str,
+    role: &str,
+    endpoint: &db::redis_driver::RedisNodeEndpoint,
+) -> String {
+    format!(
+        "{}{role}:{host}:{port}",
+        redis_sentinel_transport_prefix(connection_id),
+        host = endpoint.host,
+        port = endpoint.port
+    )
+}
+
+fn session_scoped_pool_key(base_pool_key: String, client_session_id: Option<&str>) -> String {
+    normalize_client_session_id(client_session_id)
+        .map(|session| format!("{base_pool_key}:session:{session}"))
+        .unwrap_or(base_pool_key)
+}
+
+#[cfg(test)]
+fn is_session_scoped_pool_key(pool_key: &str) -> bool {
+    pool_key.contains(":session:")
+}
+
+pub(crate) fn config_for_pool_key<'a>(
+    pool_key: &str,
+    configs: &'a HashMap<String, ConnectionConfig>,
+) -> Option<&'a ConnectionConfig> {
+    configs
+        .iter()
+        .filter(|(connection_id, _)| {
+            pool_key.strip_prefix(connection_id.as_str()).is_some_and(|rest| rest.is_empty() || rest.starts_with(':'))
+        })
+        .max_by_key(|(connection_id, _)| connection_id.len())
+        .map(|(_, config)| config)
+}
+
+fn session_scoped_pool_key_for(
+    config: Option<&ConnectionConfig>,
+    base_pool_key: String,
+    client_session_id: Option<&str>,
+) -> String {
+    let shares_base_pool = config.is_some_and(|config| {
+        matches!(config.db_type, DatabaseType::DuckDb | DatabaseType::CloudflareD1)
+            || (config.db_type == DatabaseType::Sqlite && db::sqlite::is_memory_database_path(&config.host))
+    });
+    if shares_base_pool {
+        // DuckDB and D1 already use connection-scoped handles. In-memory SQLite databases
+        // only exist inside one connection, so a session-scoped handle would point tabs at
+        // a different empty database.
+        return base_pool_key;
+    }
+    session_scoped_pool_key(base_pool_key, client_session_id)
+}
+
+fn clone_pool_kind(pool: &PoolKind) -> PoolKind {
+    match pool {
+        PoolKind::Mysql(p, mode) => PoolKind::Mysql(p.clone(), *mode),
+        PoolKind::Postgres(p) => PoolKind::Postgres(p.clone()),
+        PoolKind::Sqlite(p) => PoolKind::Sqlite(p.clone()),
+        PoolKind::Rqlite(client) => PoolKind::Rqlite(client.clone()),
+        PoolKind::Turso(client) => PoolKind::Turso(client.clone()),
+        PoolKind::CloudflareD1(client) => PoolKind::CloudflareD1(client.clone()),
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::DuckDb(con) => PoolKind::DuckDb(con.clone()),
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::DuckDbWorker(client) => PoolKind::DuckDbWorker(client.clone()),
+        #[cfg(not(feature = "duckdb-bundled"))]
+        PoolKind::DuckDb(con) => PoolKind::DuckDb(con.clone()),
+        #[cfg(not(feature = "duckdb-bundled"))]
+        PoolKind::DuckDbWorker(client) => PoolKind::DuckDbWorker(client.clone()),
+        PoolKind::MongoDb(client) => PoolKind::MongoDb(client.clone()),
+        PoolKind::ClickHouse(client) => PoolKind::ClickHouse(client.clone()),
+        PoolKind::SqlServer(client) => PoolKind::SqlServer(client.clone()),
+        PoolKind::Elasticsearch(client) => PoolKind::Elasticsearch(client.clone()),
+        PoolKind::VectorDb(client) => PoolKind::VectorDb(client.clone()),
+        PoolKind::InfluxDb(client) => PoolKind::InfluxDb(client.clone()),
+        PoolKind::Agent(client) => PoolKind::Agent(client.clone()),
+        PoolKind::ExternalTabular(ext) => PoolKind::ExternalTabular(ext.clone()),
+        PoolKind::ExternalDriver { driver_id, config, session } => {
+            PoolKind::ExternalDriver { driver_id: driver_id.clone(), config: config.clone(), session: session.clone() }
+        }
+        PoolKind::MessageQueue => PoolKind::MessageQueue,
+        PoolKind::Nacos => PoolKind::Nacos,
+        PoolKind::Redis(_) => panic!("clone_pool_kind not supported for Redis — handled separately"),
+    }
+}
+
+pub async fn close_pool_kind(pool: PoolKind) {
+    match pool {
+        PoolKind::Mysql(p, _) => {
+            let _ = p.disconnect().await;
+        }
+        PoolKind::Postgres(p) => p.close(),
+        PoolKind::Sqlite(_) => {}
+        PoolKind::Rqlite(_) => {}
+        PoolKind::Turso(_) => {}
+        PoolKind::CloudflareD1(_) => {}
+        PoolKind::Redis(conn) => {
+            drop(conn);
+        }
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::DuckDb(con) => {
+            crate::db::duckdb_driver::close_connection(con);
+        }
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::DuckDbWorker(client) => {
+            client.shutdown().await;
+        }
+        #[cfg(not(feature = "duckdb-bundled"))]
+        PoolKind::DuckDb(_) => {}
+        #[cfg(not(feature = "duckdb-bundled"))]
+        PoolKind::DuckDbWorker(_) => {}
+        PoolKind::MongoDb(client) => {
+            drop(client);
+        }
+        PoolKind::ClickHouse(client) => {
+            drop(client);
+        }
+        PoolKind::SqlServer(client) => {
+            drop(client);
+        }
+        PoolKind::Elasticsearch(client) => {
+            drop(client);
+        }
+        PoolKind::VectorDb(client) => {
+            drop(client);
+        }
+        PoolKind::InfluxDb(client) => {
+            drop(client);
+        }
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            let _ = client.disconnect().await;
+        }
+        PoolKind::ExternalTabular(_) => {}
+        PoolKind::ExternalDriver { session, .. } => {
+            session.shutdown().await;
+        }
+        PoolKind::MessageQueue => {}
+        PoolKind::Nacos => {}
+    }
+}
+
+async fn close_removed_pools(removed: Vec<(String, PoolKind)>) {
+    for (pool_key, pool) in removed {
+        close_pool_kind_with_timeout(pool_key, pool).await;
+    }
+}
+
+fn close_removed_pools_in_background(removed: Vec<(String, PoolKind)>) {
+    if removed.is_empty() {
+        return;
+    }
+    tokio::spawn(async move {
+        close_removed_pools(removed).await;
+    });
+}
+
+async fn close_pool_kind_with_timeout(pool_key: String, pool: PoolKind) {
+    match tokio::time::timeout(Duration::from_secs(POOL_CLOSE_TIMEOUT_SECS), close_pool_kind(pool)).await {
+        Ok(()) => {}
+        Err(_) => log::warn!(
+            "Timed out closing connection pool '{pool_key}' after {POOL_CLOSE_TIMEOUT_SECS}s; cleanup will continue by dropping the pool handle."
+        ),
+    }
+}
+
+fn extract_auth_token_from_params(params: &str) -> Option<String> {
+    params
+        .trim()
+        .trim_start_matches('?')
+        .split('&')
+        .filter_map(|pair| pair.split_once('='))
+        .find(|(key, _)| {
+            let k = key.trim().to_ascii_lowercase();
+            k == "auth_token" || k == "authtoken" || k == "auth-token"
+        })
+        .map(|(_, value)| value.trim().to_string())
+}
+
+fn base_pool_key_for(
+    db_type: Option<DatabaseType>,
+    connection_id: &str,
+    database: Option<&str>,
+    include_elasticsearch_single_pool: bool,
+) -> String {
+    let is_single_connection_pool = db_type.as_ref().is_some_and(|db_type| {
+        let is_single = database_capabilities::is_single_connection_pool(db_type)
+            || (include_elasticsearch_single_pool
+                && matches!(
+                    db_type,
+                    DatabaseType::Elasticsearch
+                        | DatabaseType::Qdrant
+                        | DatabaseType::Milvus
+                        | DatabaseType::Weaviate
+                        | DatabaseType::ChromaDb
+                ));
+        is_single && (!database_capabilities::is_agent_type(db_type) || shares_database_pool_with_connection(db_type))
+    });
+
+    if is_single_connection_pool {
+        connection_id.to_string()
+    } else {
+        match database.map(str::trim).filter(|db| !db.is_empty()) {
+            Some(db) => format!("{connection_id}:{db}"),
+            None => connection_id.to_string(),
+        }
+    }
+}
+
+fn shares_database_pool_with_connection(db_type: &DatabaseType) -> bool {
+    matches!(db_type, DatabaseType::Oracle)
+}
+
+#[cfg(test)]
+fn uses_agent_connection_pool(db_type: &DatabaseType) -> bool {
+    matches!(*db_type, agent_connection_pool_database_type!())
+}
+
+#[cfg(test)]
+fn uses_bare_mysql_pool(db_type: &DatabaseType) -> bool {
+    matches!(db_type, DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::ManticoreSearch)
+}
+
+fn default_plugin_dir() -> PathBuf {
+    default_dbx_dir().join("plugins")
+}
+
+pub fn default_agent_dir() -> PathBuf {
+    default_dbx_dir().join("agents")
+}
+
+fn default_dbx_dir() -> PathBuf {
+    let home = std::env::var(if cfg!(windows) { "USERPROFILE" } else { "HOME" }).unwrap_or_else(|_| ".".to_string());
+    PathBuf::from(home).join(".dbx")
+}
+
+pub fn connection_url_for_endpoint(config: &ConnectionConfig, host: &str, port: u16) -> String {
+    let normalized = native_postgres_url_config(config);
+    let config = normalized.as_ref().unwrap_or(config);
+    if host == config.host && port == config.port {
+        config.connection_url()
+    } else {
+        config.connection_url_with_host(host, port)
+    }
+}
+
+pub fn redacted_connection_url_for_endpoint(config: &ConnectionConfig, host: &str, port: u16) -> String {
+    let normalized = native_postgres_url_config(config);
+    let config = normalized.as_ref().unwrap_or(config);
+    if host == config.host && port == config.port {
+        config.redacted_connection_url()
+    } else {
+        config.redacted_connection_url_with_host(host, port)
+    }
+}
+
+pub fn agent_connect_timeout(config: &ConnectionConfig) -> std::time::Duration {
+    let min_timeout = if config.db_type == DatabaseType::Access {
+        ACCESS_AGENT_CONNECT_TIMEOUT_SECS
+    } else {
+        DEFAULT_AGENT_CONNECT_TIMEOUT_SECS
+    };
+    std::time::Duration::from_secs(config.effective_connect_timeout_secs().max(min_timeout))
+}
+
+fn external_driver_connect_timeout(config: &ConnectionConfig) -> std::time::Duration {
+    agent_connect_timeout(config)
+}
+
+fn native_postgres_url_config(config: &ConnectionConfig) -> Option<ConnectionConfig> {
+    match config.db_type {
+        DatabaseType::Gaussdb | DatabaseType::Kwdb | DatabaseType::OpenGauss | DatabaseType::Questdb => {
+            let mut normalized = config.clone();
+            normalized.database = normalized.effective_database().map(str::to_string);
+            if matches!(config.db_type, DatabaseType::Gaussdb | DatabaseType::Kwdb) {
+                let params = normalized.url_params.as_deref().unwrap_or("").trim().trim_start_matches('?');
+                if !params.to_lowercase().contains("sslmode=") {
+                    normalized.url_params = Some(if params.is_empty() {
+                        if config.ssl {
+                            "sslmode=require".to_string()
+                        } else {
+                            "sslmode=disable".to_string()
+                        }
+                    } else {
+                        let sslmode = if config.ssl { "sslmode=require" } else { "sslmode=disable" };
+                        format!("{sslmode}&{params}")
+                    });
+                }
+            }
+            normalized.db_type = DatabaseType::Postgres;
+            Some(normalized)
+        }
+        _ => None,
+    }
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_paths_match(left: &str, right: &str) -> bool {
+    let left = expand_tilde(left);
+    let right = expand_tilde(right);
+
+    if db::duckdb_driver::is_memory_database_path(&left) || db::duckdb_driver::is_memory_database_path(&right) {
+        return left.trim().eq_ignore_ascii_case(right.trim());
+    }
+
+    if let (Ok(left_path), Ok(right_path)) = (std::fs::canonicalize(&left), std::fs::canonicalize(&right)) {
+        return left_path == right_path;
+    }
+
+    if cfg!(windows) {
+        left.eq_ignore_ascii_case(&right)
+    } else {
+        left == right
+    }
+}
+
+pub async fn probe_connection_endpoint(config: &ConnectionConfig, host: &str, port: u16) -> Result<(), String> {
+    if !uses_tcp_probe(config, host, port) {
+        return Ok(());
+    }
+    let timeout = std::time::Duration::from_secs(config.effective_connect_timeout_secs());
+    db::probe_tcp_endpoint(&format!("{:?}", config.db_type), host, port, timeout).await
+}
+
+fn validate_h2_file_connection(config: &ConnectionConfig) -> Result<(), String> {
+    if !is_h2_file_connection(config) {
+        return Ok(());
+    }
+    let path = config
+        .connection_string
+        .as_deref()
+        .and_then(h2_file_path_from_jdbc_url)
+        .filter(|path| !path.trim().is_empty())
+        .unwrap_or_else(|| config.host.clone());
+    validate_h2_database_path(&path)
+}
+
+fn validate_h2_database_path(path: &str) -> Result<(), String> {
+    let first_err = match db::validate_file_path(path, |_| false) {
+        Ok(()) => return Ok(()),
+        Err(err) => err,
+    };
+
+    for suffix in [".mv.db", ".h2.db"] {
+        if path.ends_with(suffix) {
+            continue;
+        }
+        let candidate = format!("{path}{suffix}");
+        if db::validate_file_path(&candidate, |_| false).is_ok() {
+            return Ok(());
+        }
+    }
+
+    Err(first_err)
+}
+
+fn uses_tcp_probe(config: &ConnectionConfig, host: &str, port: u16) -> bool {
+    if config.db_type == DatabaseType::MongoDb
+        && config.connection_string.as_deref().is_some_and(|value| !value.is_empty())
+    {
+        return false;
+    }
+    if database_capabilities::skips_tcp_probe(&config.db_type) {
+        return false;
+    }
+    if is_original_endpoint(config, host, port) {
+        return false;
+    }
+    true
+}
+
+fn is_original_endpoint(config: &ConnectionConfig, host: &str, port: u16) -> bool {
+    host == config.host && port == config.port
+}
+
+async fn detect_ob_oracle_mode(config: &ConnectionConfig, pool: &db::mysql::MySqlPool) -> MysqlMode {
+    let profile = config.driver_profile.as_deref().unwrap_or("").to_lowercase();
+    if !profile.contains("oceanbase") {
+        return MysqlMode::Normal;
+    }
+    let mut conn = match pool.get_conn().await {
+        Ok(c) => c,
+        Err(_) => return MysqlMode::Normal,
+    };
+    let result = conn.query_iter("SHOW VARIABLES LIKE 'ob_compatibility_mode'").await;
+    let rows: Vec<MysqlRow> = match result {
+        Ok(r) => match r.collect_and_drop().await {
+            Ok(rows) => rows,
+            Err(_) => return MysqlMode::Normal,
+        },
+        Err(_) => return MysqlMode::Normal,
+    };
+    match rows.first() {
+        Some(row) => {
+            let val: String = row.get(1).unwrap_or_default();
+            if val.to_lowercase() == "oracle" {
+                MysqlMode::OceanBaseOracle
+            } else {
+                MysqlMode::Normal
+            }
+        }
+        None => MysqlMode::Normal,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        agent_connect_timeout, connection_remote_endpoint, connection_url_for_endpoint, database_connection_config,
+        metadata_connection_config, mysql_metadata_fallback_url, oceanbase_mysql_query_timeout_sql,
+        oceanbase_mysql_setup_queries, prestosql_jdbc_config_for_endpoint, redacted_connection_url_for_endpoint,
+        redis_sentinel_transport_id, redis_sentinel_transport_prefix, sqlserver_legacy_agent_config,
+        sqlserver_legacy_agent_error, task_client_session_id, uses_bare_mysql_pool, uses_tcp_probe,
+        validate_h2_database_path, AppState, MysqlMode, PoolKind, PRESTOSQL_JDBC_DRIVER_CLASS,
+    };
+    use crate::agent_connection::{
+        agent_connect_params, mongo_legacy_error_with_auth_hint, mongo_uses_legacy_driver,
+        oracle_alternate_connect_config, should_retry_mongo_with_legacy_driver,
+    };
+    use crate::agent_manager::{AgentState, JavaRuntimeConfig, JavaRuntimeMode, DEFAULT_JRE_KEY};
+    use crate::database_capabilities;
+    use crate::db;
+    use crate::models::connection::{
+        default_connect_timeout_secs, default_redis_key_separator, ConnectionConfig, DatabaseType, HttpTunnelConfig,
+        ProxyTunnelConfig, ProxyType, SshTunnelConfig, TransportLayerConfig,
+    };
+    use crate::query;
+    use crate::schema;
+    use crate::storage::Storage;
+    use std::time::{Duration, Instant};
+
+    fn mysql_config(database: Option<&str>) -> ConnectionConfig {
+        ConnectionConfig {
+            id: "conn".to_string(),
+            name: "MySQL".to_string(),
+            db_type: DatabaseType::Mysql,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 3306,
+            username: "root".to_string(),
+            password: "secret".to_string(),
+            database: database.map(str::to_string),
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: default_connect_timeout_secs(),
+            query_timeout_secs: crate::models::connection::default_query_timeout_secs(),
+            idle_timeout_secs: crate::models::connection::default_idle_timeout_secs(),
+            keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    #[test]
+    fn task_client_session_ids_are_stable_and_isolated() {
+        assert_eq!(task_client_session_id("table-export", "job-1"), "table-export:job-1");
+        assert_ne!(task_client_session_id("table-export", "job-1"), task_client_session_id("database-export", "job-1"));
+        assert_ne!(task_client_session_id("table-export", "job-1"), task_client_session_id("table-export", "job-2"));
+    }
+
+    #[test]
+    fn access_agent_connect_timeout_has_longer_default_floor() {
+        let mut config = mysql_config(None);
+        config.db_type = DatabaseType::Access;
+        config.connect_timeout_secs = 5;
+        assert_eq!(agent_connect_timeout(&config).as_secs(), 30);
+
+        config.connect_timeout_secs = 45;
+        assert_eq!(agent_connect_timeout(&config).as_secs(), 45);
+    }
+
+    #[test]
+    fn non_access_agent_connect_timeout_uses_standard_floor() {
+        let mut config = mysql_config(None);
+        config.db_type = DatabaseType::Oracle;
+        config.connect_timeout_secs = 5;
+        assert_eq!(agent_connect_timeout(&config).as_secs(), 30);
+
+        config.connect_timeout_secs = 45;
+        assert_eq!(agent_connect_timeout(&config).as_secs(), 45);
+    }
+
+    #[test]
+    fn prestosql_jdbc_config_sets_presto_url_and_driver_class() {
+        let mut config = mysql_config(Some("hive/default"));
+        config.db_type = DatabaseType::PrestoSql;
+        config.host = "presto.example.com".to_string();
+        config.port = 9090;
+
+        let jdbc_config = prestosql_jdbc_config_for_endpoint(&config, "127.0.0.1", 19090);
+
+        assert_eq!(jdbc_config.connection_string.as_deref(), Some("jdbc:presto://127.0.0.1:19090/hive/default"));
+        assert_eq!(jdbc_config.jdbc_driver_class.as_deref(), Some(PRESTOSQL_JDBC_DRIVER_CLASS));
+    }
+
+    #[test]
+    fn prestosql_jdbc_config_preserves_custom_driver_class_and_paths() {
+        let mut config = mysql_config(Some("hive"));
+        config.db_type = DatabaseType::PrestoSql;
+        config.jdbc_driver_class = Some("custom.PrestoDriver".to_string());
+        config.jdbc_driver_paths = vec!["D:\\software\\jar\\presto-jdbc-350.jar".to_string()];
+
+        let jdbc_config = prestosql_jdbc_config_for_endpoint(&config, "presto.example.com", 9090);
+
+        assert_eq!(jdbc_config.jdbc_driver_class.as_deref(), Some("custom.PrestoDriver"));
+        assert_eq!(jdbc_config.jdbc_driver_paths, vec!["D:\\software\\jar\\presto-jdbc-350.jar"]);
+    }
+
+    #[test]
+    fn sqlserver_legacy_agent_config_marks_hidden_profile() {
+        let mut config = mysql_config(Some("master"));
+        config.db_type = DatabaseType::SqlServer;
+
+        let legacy = sqlserver_legacy_agent_config(&config);
+
+        assert_eq!(legacy.db_type, DatabaseType::SqlServer);
+        assert_eq!(legacy.driver_profile.as_deref(), Some(crate::db::sqlserver::SQLSERVER_LEGACY_DRIVER_PROFILE));
+        assert_eq!(legacy.driver_label.as_deref(), Some(crate::db::sqlserver::SQLSERVER_LEGACY_DRIVER_LABEL));
+    }
+
+    #[test]
+    fn sqlserver_legacy_agent_error_mentions_driver_manager_when_missing() {
+        let message = sqlserver_legacy_agent_error(
+            "native failed",
+            "sqlserver-legacy driver is not installed. Please install it from the Driver Manager.",
+        );
+
+        assert!(message.contains("native failed"));
+        assert!(message.contains("Fallback with SQL Server legacy compatibility component failed"));
+        assert!(message.contains("Driver Manager"));
+        assert!(message.contains("enable SQL Server legacy compatibility mode again"));
+    }
+
+    #[test]
+    fn agent_connect_params_include_url_params() {
+        let mut config = mysql_config(Some("testdb"));
+        config.username = "informix".to_string();
+        config.password = "in4mix".to_string();
+        config.url_params = Some("INFORMIXSERVER=informix;CLIENT_LOCALE=en_US.utf8".to_string());
+
+        let params = agent_connect_params(&config, "172.26.128.159", 20013, "testdb");
+
+        assert_eq!(params["host"], "172.26.128.159");
+        assert_eq!(params["port"], 20013);
+        assert_eq!(params["database"], "testdb");
+        assert_eq!(params["username"], "informix");
+        assert_eq!(params["password"], "in4mix");
+        assert_eq!(params["url_params"], "INFORMIXSERVER=informix;CLIENT_LOCALE=en_US.utf8");
+    }
+
+    #[test]
+    fn databend_uses_agent_pool_not_bare_mysql_pool() {
+        assert!(uses_bare_mysql_pool(&DatabaseType::Doris));
+        assert!(uses_bare_mysql_pool(&DatabaseType::StarRocks));
+        assert!(uses_bare_mysql_pool(&DatabaseType::ManticoreSearch));
+        assert!(!uses_bare_mysql_pool(&DatabaseType::Databend));
+        assert!(database_capabilities::is_agent_type(&DatabaseType::Databend));
+        assert!(super::uses_agent_connection_pool(&DatabaseType::ZooKeeper));
+    }
+
+    #[test]
+    fn validates_h2_database_base_path_when_mv_db_file_exists() {
+        let dir = std::env::temp_dir().join(format!("dbx-h2-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let file_path = dir.join("app.mv.db");
+        std::fs::write(&file_path, b"h2").unwrap();
+        let base_path = dir.join("app");
+
+        validate_h2_database_path(base_path.to_str().unwrap()).unwrap();
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
+    #[test]
+    fn rejects_missing_h2_database_path() {
+        let dir = std::env::temp_dir().join(format!("dbx-h2-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let missing_path = dir.join("missing");
+
+        let err = validate_h2_database_path(missing_path.to_str().unwrap()).unwrap_err();
+
+        assert!(err.contains("File does not exist"));
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
+    #[test]
+    fn agent_connect_params_build_mongodb_connection_string_from_form_fields() {
+        let mut config = mysql_config(Some("RestCloud_V45PUB_Gateway"));
+        config.db_type = DatabaseType::MongoDb;
+        config.host = "172.22.4.42".to_string();
+        config.port = 27017;
+        config.username = "mongouser".to_string();
+        config.password = "secret".to_string();
+        config.url_params = Some("authSource=admin&authMechanism=SCRAM-SHA-1".to_string());
+
+        let params = agent_connect_params(&config, "172.22.4.42", 27017, "RestCloud_V45PUB_Gateway");
+
+        assert_eq!(params["connection_string"], "mongodb://mongouser:secret@172.22.4.42:27017/RestCloud%5FV45PUB%5FGateway?authSource=admin&authMechanism=SCRAM-SHA-1");
+    }
+
+    #[test]
+    fn agent_connect_params_mongodb_uses_connection_string_database_when_database_is_empty() {
+        let mut config = mysql_config(None);
+        config.db_type = DatabaseType::MongoDb;
+        config.connection_string =
+            Some("mongodb://mongouser:secret@172.22.4.42:27017/RestCloud_V45PUB_Gateway?authSource=admin".to_string());
+
+        let params = agent_connect_params(&config, "172.22.4.42", 27017, "");
+
+        assert_eq!(params["database"], "RestCloud_V45PUB_Gateway");
+    }
+
+    #[test]
+    fn mongo_legacy_auth_error_adds_auth_source_hint() {
+        let err = "Agent RPC error: Exception authenticating MongoCredential{mechanism=SCRAM-SHA-1, userName='rwuser', source='gray_lite_twin_fat'}";
+
+        assert_eq!(
+            mongo_legacy_error_with_auth_hint(err),
+            "Agent RPC error: Exception authenticating MongoCredential{mechanism=SCRAM-SHA-1, userName='rwuser', source='gray_lite_twin_fat'}\n\nCurrent authentication database: gray_lite_twin_fat. If this user was created in admin, set Authentication database to admin or add authSource=admin to URL params."
+        );
+    }
+
+    #[test]
+    fn oceanbase_mysql_setup_queries_follow_query_timeout() {
+        let mut config = mysql_config(Some("dbx"));
+        config.driver_profile = Some("oceanbase".to_string());
+        config.query_timeout_secs = 30;
+
+        assert_eq!(oceanbase_mysql_setup_queries(&config), vec!["SET ob_query_timeout = 30000000"]);
+    }
+
+    #[test]
+    fn oceanbase_mysql_query_timeout_sql_accepts_large_timeout() {
+        let mut config = mysql_config(Some("dbx"));
+        config.driver_profile = Some("oceanbase".to_string());
+
+        assert_eq!(
+            oceanbase_mysql_query_timeout_sql(&config, 300_000),
+            Some("SET ob_query_timeout = 300000000000".to_string())
+        );
+    }
+
+    #[test]
+    fn oceanbase_mysql_setup_queries_skip_disabled_timeout() {
+        let mut config = mysql_config(Some("dbx"));
+        config.driver_profile = Some("oceanbase".to_string());
+        config.query_timeout_secs = 0;
+
+        assert!(oceanbase_mysql_setup_queries(&config).is_empty());
+    }
+
+    #[test]
+    fn oceanbase_mysql_setup_queries_do_not_apply_to_plain_mysql() {
+        let mut config = mysql_config(Some("dbx"));
+        config.query_timeout_secs = 30;
+
+        assert!(oceanbase_mysql_setup_queries(&config).is_empty());
+    }
+
+    #[test]
+    fn mongo_legacy_retry_covers_old_server_handshake_eof() {
+        let err = r#"MongoDB connection failed: Kind: Server selection timeout: No available servers. Topology: { Type: Unknown, Servers: [ { Address: db.example.com:27017, Type: Unknown, Error: Kind: I/O error: unexpected end of file } ] }"#;
+
+        assert!(mongo_uses_legacy_driver(&ConnectionConfig {
+            driver_profile: Some("mongodb-legacy".to_string()),
+            ..mysql_config(None)
+        }));
+        assert!(should_retry_mongo_with_legacy_driver(err));
+        assert!(should_retry_mongo_with_legacy_driver("server reports wire version 5, but this driver requires 8"));
+        assert!(!should_retry_mongo_with_legacy_driver("Authentication failed."));
+    }
+
+    #[test]
+    fn agent_connect_params_build_oracle_service_connection_string() {
+        let mut config = mysql_config(Some("ORCLPDB1"));
+        config.db_type = DatabaseType::Oracle;
+        config.host = "oracle.example.com".to_string();
+        config.port = 1521;
+        config.username = "system".to_string();
+        config.password = "oracle".to_string();
+        config.sysdba = true;
+        config.oracle_connection_type = Some("service_name".to_string());
+
+        let params = agent_connect_params(&config, "oracle.example.com", 1521, "ORCLPDB1");
+
+        assert_eq!(params["database"], "SYSDBA:ORCLPDB1");
+        assert_eq!(params["sysdba"], true);
+        assert_eq!(params["connection_string"], "jdbc:oracle:thin:@//oracle.example.com:1521/ORCLPDB1");
+    }
+
+    #[test]
+    fn agent_connect_params_build_postgres_like_agent_connection_string_for_selected_database() {
+        let cases = [
+            (
+                DatabaseType::Kingbase,
+                "kingbase.example.com",
+                54321,
+                "jdbc:kingbase8://kingbase.example.com:54321/platform_face_jgj",
+                "jdbc:kingbase8://kingbase.example.com:54321/platform_face_freezer_jgj?sslmode=disable",
+            ),
+            (
+                DatabaseType::Highgo,
+                "highgo.example.com",
+                5866,
+                "jdbc:highgo://highgo.example.com:5866/highgo",
+                "jdbc:highgo://highgo.example.com:5866/platform_face_freezer_jgj?sslmode=disable",
+            ),
+            (
+                DatabaseType::Vastbase,
+                "vastbase.example.com",
+                5432,
+                "jdbc:vastbase://vastbase.example.com:5432/postgres",
+                "jdbc:vastbase://vastbase.example.com:5432/platform_face_freezer_jgj?sslmode=disable",
+            ),
+        ];
+
+        for (db_type, host, port, stale_connection_string, expected_connection_string) in cases {
+            let mut config = mysql_config(Some("platform_face_jgj"));
+            config.db_type = db_type;
+            config.host = host.to_string();
+            config.port = port;
+            config.username = "system".to_string();
+            config.password = "secret".to_string();
+            config.url_params = Some("sslmode=disable".to_string());
+            config.connection_string = Some(stale_connection_string.to_string());
+
+            let params = agent_connect_params(&config, host, port, "platform_face_freezer_jgj");
+
+            assert_eq!(params["database"], "platform_face_freezer_jgj");
+            assert_eq!(params["connection_string"], expected_connection_string);
+        }
+    }
+
+    #[test]
+    fn agent_connect_params_build_oracle_sid_connection_string() {
+        let mut config = mysql_config(Some("ORCL"));
+        config.db_type = DatabaseType::Oracle;
+        config.oracle_connection_type = Some("sid".to_string());
+
+        let params = agent_connect_params(&config, "127.0.0.1", 11521, "ORCL");
+
+        assert_eq!(params["connection_string"], "jdbc:oracle:thin:@127.0.0.1:11521:ORCL");
+    }
+
+    #[test]
+    fn agent_connect_params_preserve_legacy_oracle_configs_as_service_name() {
+        let mut config = mysql_config(Some("ORCL"));
+        config.db_type = DatabaseType::Oracle;
+        config.oracle_connection_type = None;
+
+        let params = agent_connect_params(&config, "127.0.0.1", 11521, "ORCL");
+
+        assert_eq!(params["connection_string"], "jdbc:oracle:thin:@//127.0.0.1:11521/ORCL");
+    }
+
+    #[test]
+    fn oracle_listener_errors_can_retry_with_alternate_connect_descriptor() {
+        let mut config = mysql_config(Some("ORCL"));
+        config.db_type = DatabaseType::Oracle;
+        config.driver_profile = Some("oracle".to_string());
+        config.oracle_connection_type = Some("service_name".to_string());
+
+        let retry = oracle_alternate_connect_config(
+            &config,
+            "Agent RPC error (-1): ORA-12514: listener does not currently know of service requested",
+        )
+        .expect("listener errors should allow alternate descriptor retry");
+        assert_eq!(retry.driver_profile.as_deref(), Some("oracle"));
+        assert_eq!(retry.connection_string.as_deref(), Some("jdbc:oracle:thin:@127.0.0.1:3306:ORCL"));
+
+        let mut sid_config = config.clone();
+        sid_config.oracle_connection_type = Some("sid".to_string());
+        let service_retry = oracle_alternate_connect_config(
+            &sid_config,
+            "Agent RPC error (-1): ORA-12505: listener does not currently know of SID given",
+        )
+        .expect("SID listener errors should allow service-name retry");
+        assert_eq!(service_retry.connection_string.as_deref(), Some("jdbc:oracle:thin:@//127.0.0.1:3306/ORCL"));
+
+        assert!(oracle_alternate_connect_config(&config, "ORA-12541: TNS:no listener").is_some());
+    }
+
+    #[test]
+    fn oracle_alternate_descriptor_retry_skips_non_listener_errors() {
+        let mut config = mysql_config(Some("ORCL"));
+        config.db_type = DatabaseType::Oracle;
+        config.driver_profile = Some("oracle".to_string());
+
+        assert!(oracle_alternate_connect_config(&config, "ORA-01017: invalid username/password").is_none());
+    }
+
+    #[test]
+    fn oracle_alternate_descriptor_retry_skips_custom_connection_strings() {
+        let mut config = mysql_config(Some("ORCL"));
+        config.db_type = DatabaseType::Oracle;
+        config.driver_profile = Some("oracle".to_string());
+        config.connection_string = Some("jdbc:oracle:thin:@//oracle.example.com:1521/ORCL".to_string());
+
+        assert!(oracle_alternate_connect_config(&config, "ORA-12514: listener does not know service").is_none());
+    }
+
+    #[test]
+    fn agent_connect_params_build_saphana_connection_string_from_database_and_url_params() {
+        let mut config = mysql_config(Some("TENANT1"));
+        config.db_type = DatabaseType::SapHana;
+        config.host = "hana.example.com".to_string();
+        config.port = 30013;
+        config.username = "SYSTEM".to_string();
+        config.password = "secret".to_string();
+        config.url_params = Some("encrypt=true".to_string());
+
+        let params = agent_connect_params(&config, "hana.example.com", 30013, "TENANT1");
+
+        assert_eq!(params["database"], "TENANT1");
+        assert_eq!(params["connection_string"], "jdbc:sap://hana.example.com:30013/?databaseName=TENANT1&encrypt=true");
+    }
+
+    async fn test_app_state() -> (AppState, std::path::PathBuf) {
+        let dir = std::env::temp_dir().join(format!("dbx-core-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        (AppState::new(storage), dir)
+    }
+
+    fn touch_executable(path: &std::path::Path) {
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent).unwrap();
+        }
+        std::fs::write(path, b"").unwrap();
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+
+            let mut permissions = std::fs::metadata(path).unwrap().permissions();
+            permissions.set_mode(0o755);
+            std::fs::set_permissions(path, permissions).unwrap();
+        }
+    }
+
+    #[tokio::test]
+    async fn app_state_uses_explicit_agent_dir() {
+        let dir = std::env::temp_dir().join(format!("dbx-core-agent-dir-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let agent_dir = dir.join("agents");
+
+        let state = AppState::new_with_plugin_and_agent_dir_and_app_version(
+            storage,
+            dir.join("plugins"),
+            agent_dir.clone(),
+            "0.0.0-test",
+        );
+
+        assert_eq!(state.agent_manager.base_dir(), &agent_dir);
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn stale_connection_attempt_cannot_replace_newer_pool() {
+        let (state, dir) = test_app_state().await;
+        let mut config = mysql_config(None);
+        config.name = "SQLite".to_string();
+        config.db_type = DatabaseType::Sqlite;
+        config.host = dir.join("current.db").to_string_lossy().to_string();
+        let old_attempt = state.begin_connection_attempt("conn").await;
+        let new_attempt = state.begin_connection_attempt("conn").await;
+        let current_pool =
+            db::sqlite::connect_path_create_if_missing(&dir.join("current.db").to_string_lossy()).await.unwrap();
+        let stale_pool =
+            db::sqlite::connect_path_create_if_missing(&dir.join("stale.db").to_string_lossy()).await.unwrap();
+
+        state
+            .insert_connection_pool_for_attempt(
+                "conn",
+                new_attempt,
+                "conn".to_string(),
+                PoolKind::Sqlite(current_pool),
+                &config,
+            )
+            .await
+            .unwrap();
+
+        let result = state
+            .insert_connection_pool_for_attempt(
+                "conn",
+                old_attempt,
+                "conn".to_string(),
+                PoolKind::Sqlite(stale_pool),
+                &config,
+            )
+            .await;
+
+        assert!(result.is_err());
+        let conns = state.connections.read().await;
+        assert!(matches!(conns.get("conn"), Some(PoolKind::Sqlite(_))));
+        assert_eq!(conns.len(), 1);
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    #[ignore = "requires DBX_TEST_MYSQL_URL"]
+    async fn live_mysql_health_check_keeps_saturated_pool() {
+        let url = std::env::var("DBX_TEST_MYSQL_URL").expect("DBX_TEST_MYSQL_URL is required");
+        let (state, dir) = test_app_state().await;
+        let config = mysql_config(Some("testdb"));
+        let pool = db::mysql::connect_bare_with_pool_limit(&url, Duration::from_secs(5), 1).await.unwrap();
+        state
+            .insert_connection_pool("conn".to_string(), PoolKind::Mysql(pool.clone(), MysqlMode::Normal), &config)
+            .await;
+        let held_connection = pool.get_conn().await.unwrap();
+
+        let started = Instant::now();
+        state.check_connection_health("conn").await.unwrap();
+
+        assert!(started.elapsed() < Duration::from_secs(2));
+        assert!(state.connections.read().await.contains_key("conn"));
+        drop(held_connection);
+        state.remove_connection_pools_detached("conn").await;
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn jdbc_plugin_env_uses_managed_jre_when_installed() {
+        let dir = std::env::temp_dir().join(format!("dbx-core-jdbc-managed-jre-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new_with_plugin_and_agent_dir_and_app_version(
+            storage,
+            dir.join("plugins"),
+            dir.join("agents"),
+            "0.0.0-test",
+        );
+        let java = state.agent_manager.jre_java_path(DEFAULT_JRE_KEY);
+        touch_executable(&java);
+
+        let env = state.external_driver_runtime_env("jdbc").unwrap();
+
+        assert_eq!(env.get("DBX_JAVA_BIN"), Some(java.to_string_lossy().as_ref()));
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn jdbc_plugin_env_keeps_wrapper_fallback_when_managed_jre_is_missing() {
+        let dir = std::env::temp_dir().join(format!("dbx-core-jdbc-missing-jre-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new_with_plugin_and_agent_dir_and_app_version(
+            storage,
+            dir.join("plugins"),
+            dir.join("agents"),
+            "0.0.0-test",
+        );
+
+        let env = state.external_driver_runtime_env("jdbc").unwrap();
+
+        assert_eq!(env.get("DBX_JAVA_BIN"), None);
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn jdbc_plugin_env_uses_custom_java_runtime() {
+        let dir = std::env::temp_dir().join(format!("dbx-core-jdbc-custom-jre-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new_with_plugin_and_agent_dir_and_app_version(
+            storage,
+            dir.join("plugins"),
+            dir.join("agents"),
+            "0.0.0-test",
+        );
+        let java = dir.join("custom").join("bin").join(if cfg!(windows) { "java.exe" } else { "java" });
+        touch_executable(&java);
+        state
+            .agent_manager
+            .save_state(&AgentState {
+                java_runtime: JavaRuntimeConfig {
+                    mode: JavaRuntimeMode::Custom,
+                    custom_java_path: Some(java.to_string_lossy().to_string()),
+                },
+                ..AgentState::default()
+            })
+            .unwrap();
+
+        let env = state.external_driver_runtime_env("jdbc").unwrap();
+
+        assert_eq!(env.get("DBX_JAVA_BIN"), Some(java.to_string_lossy().as_ref()));
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    fn live_postgres_like_config(
+        db_type: DatabaseType,
+        host: &str,
+        port: u16,
+        username: &str,
+        password: &str,
+        url_params: Option<&str>,
+    ) -> ConnectionConfig {
+        let mut config = mysql_config(Some("postgres"));
+        config.db_type = db_type;
+        config.host = host.to_string();
+        config.port = port;
+        config.username = username.to_string();
+        config.password = password.to_string();
+        config.url_params = url_params.map(str::to_string);
+        config
+    }
+
+    async fn assert_live_postgres_like_query(config: ConnectionConfig) {
+        let url = connection_url_for_endpoint(&config, &config.host, config.port);
+        let pool = db::postgres::connect(&url, std::time::Duration::from_secs(config.effective_connect_timeout_secs()))
+            .await
+            .unwrap_or_else(|err| {
+                panic!("failed to connect to {:?} at {}:{}: {}", config.db_type, config.host, config.port, err)
+            });
+        let result =
+            db::postgres::execute_query(&pool, "SELECT current_database(), current_schema()").await.unwrap_or_else(
+                |err| panic!("failed to query {:?} at {}:{}: {}", config.db_type, config.host, config.port, err),
+            );
+        assert_eq!(result.rows.len(), 1);
+        pool.close();
+    }
+
+    #[test]
+    fn mysql_metadata_connection_ignores_saved_default_database() {
+        let config = mysql_config(Some("app"));
+
+        let metadata = metadata_connection_config(&config);
+
+        assert_eq!(metadata.database, None);
+        assert_eq!(metadata.db_type, DatabaseType::Mysql);
+    }
+
+    #[test]
+    fn mysql_metadata_fallback_uses_saved_default_database() {
+        let config = mysql_config(Some("app"));
+        let metadata = metadata_connection_config(&config);
+
+        assert_eq!(
+            mysql_metadata_fallback_url(&config, &metadata, &config.host, config.port),
+            Some("mysql://root:secret@127.0.0.1:3306/app?ssl-mode=disabled&charset=utf8mb4".to_string())
+        );
+    }
+
+    #[test]
+    fn mysql_metadata_fallback_is_unavailable_without_default_database() {
+        let config = mysql_config(None);
+        let metadata = metadata_connection_config(&config);
+
+        assert_eq!(mysql_metadata_fallback_url(&config, &metadata, &config.host, config.port), None);
+    }
+
+    #[test]
+    fn mysql_database_connection_keeps_requested_database() {
+        let config = mysql_config(Some("app"));
+
+        let scoped = database_connection_config(&config, Some("analytics"));
+
+        assert_eq!(scoped.database.as_deref(), Some("analytics"));
+    }
+
+    #[test]
+    fn gaussdb_database_connection_keeps_requested_database() {
+        let mut config = mysql_config(Some("postgres"));
+        config.db_type = DatabaseType::Gaussdb;
+
+        let scoped = database_connection_config(&config, Some("analytics"));
+
+        assert_eq!(scoped.database.as_deref(), Some("analytics"));
+    }
+
+    #[test]
+    fn gaussdb_endpoint_url_uses_postgres_scheme_for_native_driver() {
+        let mut config = mysql_config(Some("postgres"));
+        config.db_type = DatabaseType::Gaussdb;
+        config.username = "gaussdb".to_string();
+        config.password = "secret".to_string();
+
+        assert_eq!(
+            connection_url_for_endpoint(&config, &config.host, config.port),
+            "postgres://gaussdb:secret@127.0.0.1:3306/postgres?sslmode=disable"
+        );
+        assert_eq!(
+            redacted_connection_url_for_endpoint(&config, &config.host, config.port),
+            "postgres://127.0.0.1:3306/postgres?sslmode=disable"
+        );
+    }
+
+    #[test]
+    fn kwdb_endpoint_url_uses_postgres_scheme_for_native_driver() {
+        let mut config = mysql_config(None);
+        config.db_type = DatabaseType::Kwdb;
+        config.username = "root".to_string();
+        config.password = "secret".to_string();
+        config.port = 26257;
+
+        assert_eq!(
+            connection_url_for_endpoint(&config, &config.host, config.port),
+            "postgres://root:secret@127.0.0.1:26257/defaultdb?sslmode=disable"
+        );
+        assert_eq!(
+            redacted_connection_url_for_endpoint(&config, &config.host, config.port),
+            "postgres://127.0.0.1:26257/defaultdb?sslmode=disable"
+        );
+    }
+
+    #[test]
+    fn kwdb_endpoint_url_keeps_explicit_sslmode() {
+        let mut config = mysql_config(None);
+        config.db_type = DatabaseType::Kwdb;
+        config.username = "root".to_string();
+        config.password = "secret".to_string();
+        config.port = 26257;
+        config.url_params = Some("sslmode=require&application_name=dbx".to_string());
+
+        assert_eq!(
+            connection_url_for_endpoint(&config, &config.host, config.port),
+            "postgres://root:secret@127.0.0.1:26257/defaultdb?sslmode=require&application_name=dbx"
+        );
+    }
+
+    #[test]
+    fn opengauss_endpoint_url_uses_postgres_scheme_for_native_driver() {
+        let mut config = mysql_config(Some("postgres"));
+        config.db_type = DatabaseType::OpenGauss;
+        config.username = "gaussdb".to_string();
+        config.password = "secret".to_string();
+
+        assert_eq!(
+            connection_url_for_endpoint(&config, &config.host, config.port),
+            "postgres://gaussdb:secret@127.0.0.1:3306/postgres"
+        );
+    }
+
+    #[test]
+    fn gaussdb_endpoint_url_keeps_explicit_sslmode() {
+        let mut config = mysql_config(Some("postgres"));
+        config.db_type = DatabaseType::Gaussdb;
+        config.username = "gaussdb".to_string();
+        config.password = "secret".to_string();
+        config.url_params = Some("sslmode=require&application_name=dbx".to_string());
+
+        assert_eq!(
+            connection_url_for_endpoint(&config, &config.host, config.port),
+            "postgres://gaussdb:secret@127.0.0.1:3306/postgres?sslmode=require&application_name=dbx"
+        );
+    }
+
+    #[test]
+    fn gaussdb_endpoint_url_uses_require_sslmode_when_tls_enabled() {
+        let mut config = mysql_config(Some("postgres"));
+        config.db_type = DatabaseType::Gaussdb;
+        config.username = "gaussdb".to_string();
+        config.password = "secret".to_string();
+        config.ssl = true;
+
+        assert_eq!(
+            connection_url_for_endpoint(&config, &config.host, config.port),
+            "postgres://gaussdb:secret@127.0.0.1:3306/postgres?sslmode=require"
+        );
+    }
+
+    #[test]
+    fn gaussdb_endpoint_url_prepends_default_sslmode_to_custom_params() {
+        let mut config = mysql_config(Some("postgres"));
+        config.db_type = DatabaseType::Gaussdb;
+        config.username = "gaussdb".to_string();
+        config.password = "secret".to_string();
+        config.url_params = Some("application_name=dbx".to_string());
+
+        assert_eq!(
+            connection_url_for_endpoint(&config, &config.host, config.port),
+            "postgres://gaussdb:secret@127.0.0.1:3306/postgres?sslmode=disable&application_name=dbx"
+        );
+    }
+
+    #[test]
+    fn mongodb_database_connection_keeps_saved_database_for_auth() {
+        let mut config = mysql_config(Some("admin"));
+        config.db_type = DatabaseType::MongoDb;
+
+        let scoped = database_connection_config(&config, Some("shop"));
+
+        assert_eq!(scoped.database.as_deref(), Some("admin"));
+    }
+
+    #[test]
+    fn cloudflare_d1_query_namespace_does_not_replace_database_id() {
+        let mut config = mysql_config(Some("database-uuid"));
+        config.db_type = DatabaseType::CloudflareD1;
+
+        let scoped = database_connection_config(&config, Some("main"));
+
+        assert_eq!(scoped.database.as_deref(), Some("database-uuid"));
+        assert_eq!(
+            super::base_pool_key_for(Some(DatabaseType::CloudflareD1), "d1-conn", Some("main"), false),
+            "d1-conn"
+        );
+    }
+
+    #[test]
+    fn oracle_database_connection_ignores_requested_database() {
+        let mut config = mysql_config(Some("ORCL"));
+        config.db_type = DatabaseType::Oracle;
+
+        let scoped = database_connection_config(&config, Some("analytics"));
+
+        assert_eq!(scoped.database.as_deref(), Some("ORCL"));
+    }
+
+    #[test]
+    fn oracle_reuses_connection_scoped_pool_for_schema_database_keys() {
+        assert_eq!(
+            super::base_pool_key_for(Some(DatabaseType::Oracle), "oracle-conn", Some("ORCLPDB1"), false),
+            "oracle-conn"
+        );
+    }
+
+    #[test]
+    fn other_agent_single_connection_types_keep_database_scoped_pool_keys() {
+        assert_eq!(
+            super::base_pool_key_for(Some(DatabaseType::Kingbase), "kingbase-conn", Some("app1"), false),
+            "kingbase-conn:app1"
+        );
+        assert_eq!(
+            super::base_pool_key_for(Some(DatabaseType::MongoDb), "mongo-conn", Some("shop"), false),
+            "mongo-conn:shop"
+        );
+    }
+
+    #[test]
+    fn non_agent_single_connection_types_still_share_pool_keys() {
+        assert_eq!(
+            super::base_pool_key_for(Some(DatabaseType::Sqlite), "sqlite-conn", Some("main"), false),
+            "sqlite-conn"
+        );
+        assert_eq!(
+            super::base_pool_key_for(Some(DatabaseType::DuckDb), "duckdb-conn", Some("analytics"), false),
+            "duckdb-conn"
+        );
+        assert_eq!(
+            super::base_pool_key_for(Some(DatabaseType::Jdbc), "jdbc-conn", Some("analytics"), false),
+            "jdbc-conn"
+        );
+    }
+
+    #[test]
+    fn session_scoped_pool_keys_are_sanitized_and_detected() {
+        let mysql = mysql_config(Some("analytics"));
+        let key =
+            super::session_scoped_pool_key_for(Some(&mysql), "mysql-conn:analytics".to_string(), Some("tab-1:count"));
+
+        assert_eq!(key, "mysql-conn:analytics:session:tab-1_count");
+        assert!(super::is_session_scoped_pool_key(&key));
+        assert!(!super::is_session_scoped_pool_key("mysql-conn:analytics"));
+
+        let mut duckdb = mysql_config(None);
+        duckdb.db_type = DatabaseType::DuckDb;
+        assert_eq!(
+            super::session_scoped_pool_key_for(Some(&duckdb), "duckdb-conn".to_string(), Some("tab-1")),
+            "duckdb-conn"
+        );
+        let mut sqlite_memory = mysql_config(None);
+        sqlite_memory.db_type = DatabaseType::Sqlite;
+        sqlite_memory.host = " :MeMoRy: ".to_string();
+        assert_eq!(
+            super::session_scoped_pool_key_for(Some(&sqlite_memory), "sqlite-memory".to_string(), Some("tab-1")),
+            "sqlite-memory"
+        );
+
+        sqlite_memory.host = "/tmp/dbx-session-test.sqlite".to_string();
+        assert_eq!(
+            super::session_scoped_pool_key_for(Some(&sqlite_memory), "sqlite-file".to_string(), Some("tab-1")),
+            "sqlite-file:session:tab-1"
+        );
+
+        let mut cloudflare_d1 = mysql_config(None);
+        cloudflare_d1.db_type = DatabaseType::CloudflareD1;
+        assert_eq!(
+            super::session_scoped_pool_key_for(Some(&cloudflare_d1), "d1-conn".to_string(), Some("tab-1")),
+            "d1-conn"
+        );
+    }
+
+    #[test]
+    fn redis_sentinel_transport_ids_are_connection_scoped_by_role_and_endpoint() {
+        let endpoint = db::redis_driver::RedisNodeEndpoint { host: "10.0.0.8".to_string(), port: 6379 };
+
+        assert_eq!(redis_sentinel_transport_prefix("redis-prod"), "redis-prod:redis-sentinel:");
+        assert_eq!(
+            redis_sentinel_transport_id("redis-prod", "master", &endpoint),
+            "redis-prod:redis-sentinel:master:10.0.0.8:6379"
+        );
+    }
+
+    #[test]
+    fn mysql_pool_size_keeps_session_pools_single_connection() {
+        assert_eq!(super::mysql_pool_max_connections_for_session(None), 10);
+        assert_eq!(super::mysql_pool_max_connections_for_session(Some("")), 10);
+        assert_eq!(super::mysql_pool_max_connections_for_session(Some("tab-1")), 1);
+    }
+
+    #[test]
+    fn prestosql_uses_external_driver_pool_not_agent_pool() {
+        assert!(!super::uses_agent_connection_pool(&DatabaseType::PrestoSql));
+        assert!(super::uses_agent_connection_pool(&DatabaseType::Trino));
+    }
+
+    #[test]
+    fn mysql_hostname_connections_skip_tcp_probe() {
+        let mut config = mysql_config(Some("app"));
+        config.host = "mysql.example.com".to_string();
+
+        assert!(!uses_tcp_probe(&config, "mysql.example.com", 3306));
+        config.host = "192.0.2.10".to_string();
+        assert!(!uses_tcp_probe(&config, "192.0.2.10", 3306));
+        assert!(uses_tcp_probe(&config, "127.0.0.1", 53306));
+    }
+
+    #[test]
+    fn native_direct_connections_skip_tcp_probe() {
+        for db_type in [
+            DatabaseType::Postgres,
+            DatabaseType::Redshift,
+            DatabaseType::Redis,
+            DatabaseType::ClickHouse,
+            DatabaseType::SqlServer,
+            DatabaseType::Elasticsearch,
+            DatabaseType::Kwdb,
+        ] {
+            let mut config = mysql_config(Some("app"));
+            config.db_type = db_type;
+            config.host = "db.example.com".to_string();
+
+            assert!(!uses_tcp_probe(&config, "db.example.com", config.port), "{db_type:?} hostname");
+            config.host = "192.0.2.10".to_string();
+            assert!(!uses_tcp_probe(&config, "192.0.2.10", config.port), "{db_type:?} ip");
+            assert!(uses_tcp_probe(&config, "127.0.0.1", 54000), "{db_type:?} forwarded");
+        }
+    }
+
+    #[test]
+    fn h2_agent_connections_skip_tcp_probe_for_file_and_tcp_modes() {
+        let mut file_config = mysql_config(None);
+        file_config.db_type = DatabaseType::H2;
+        file_config.host = "/tmp/app.mv.db".to_string();
+        file_config.port = 0;
+
+        assert!(!uses_tcp_probe(&file_config, "/tmp/app.mv.db", 0));
+
+        let mut tcp_config = mysql_config(Some("test"));
+        tcp_config.db_type = DatabaseType::H2;
+        tcp_config.host = "127.0.0.1".to_string();
+        tcp_config.port = 9092;
+
+        assert!(!uses_tcp_probe(&tcp_config, "127.0.0.1", 9092));
+    }
+
+    #[tokio::test]
+    async fn sqlite_get_or_create_pool_initializes_connection_for_web_route() {
+        let (state, dir) = test_app_state().await;
+        let db_path = dir.join("app.db");
+        std::fs::File::create(&db_path).unwrap();
+        let mut config = mysql_config(None);
+        config.id = "sqlite-conn".to_string();
+        config.name = "SQLite".to_string();
+        config.db_type = DatabaseType::Sqlite;
+        config.host = db_path.to_string_lossy().to_string();
+        config.port = 0;
+
+        state.configs.write().await.insert(config.id.clone(), config);
+
+        let pool_key = state.get_or_create_pool("sqlite-conn", None).await.unwrap();
+        assert_eq!(pool_key, "sqlite-conn");
+
+        let databases = schema::list_databases_core(&state, "sqlite-conn").await.unwrap();
+        assert_eq!(databases.len(), 1);
+        assert_eq!(databases[0].name, "main");
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[tokio::test]
+    async fn duckdb_existing_pool_can_be_used_for_connection_test() {
+        let (state, dir) = test_app_state().await;
+        let db_path = dir.join("app.duckdb");
+        duckdb::Connection::open(&db_path).unwrap();
+        let mut config = mysql_config(None);
+        config.id = "duckdb-conn".to_string();
+        config.name = "DuckDB".to_string();
+        config.db_type = DatabaseType::DuckDb;
+        config.host = db_path.to_string_lossy().to_string();
+        config.port = 0;
+
+        state.configs.write().await.insert(config.id.clone(), config.clone());
+        state.get_or_create_pool("duckdb-conn", None).await.unwrap();
+
+        assert!(state.duckdb_existing_pool_is_usable_for_config(&config).await.unwrap());
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[tokio::test]
+    async fn applying_duckdb_worker_isolation_drops_existing_duckdb_pools() {
+        let (state, dir) = test_app_state().await;
+        let db_path = dir.join("app.duckdb");
+        duckdb::Connection::open(&db_path).unwrap();
+        let mut config = mysql_config(None);
+        config.id = "duckdb-conn".to_string();
+        config.name = "DuckDB".to_string();
+        config.db_type = DatabaseType::DuckDb;
+        config.host = db_path.to_string_lossy().to_string();
+        config.port = 0;
+
+        state.configs.write().await.insert(config.id.clone(), config);
+        state.get_or_create_pool("duckdb-conn", None).await.unwrap();
+        assert!(matches!(state.connections.read().await.get("duckdb-conn"), Some(PoolKind::DuckDb(_))));
+
+        state.apply_duckdb_worker_process_isolation(true).await;
+
+        assert!(!state.connections.read().await.contains_key("duckdb-conn"));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[tokio::test]
+    async fn duckdb_pool_mode_mismatch_removes_existing_pool() {
+        let (state, dir) = test_app_state().await;
+        let db_path = dir.join("app.duckdb");
+        duckdb::Connection::open(&db_path).unwrap();
+        let mut config = mysql_config(None);
+        config.id = "duckdb-conn".to_string();
+        config.name = "DuckDB".to_string();
+        config.db_type = DatabaseType::DuckDb;
+        config.host = db_path.to_string_lossy().to_string();
+        config.port = 0;
+
+        state.configs.write().await.insert(config.id.clone(), config);
+        state.get_or_create_pool("duckdb-conn", None).await.unwrap();
+        assert!(matches!(state.connections.read().await.get("duckdb-conn"), Some(PoolKind::DuckDb(_))));
+
+        state.set_duckdb_worker_process_isolation_enabled(true);
+
+        assert!(state.remove_pool_if_duckdb_isolation_mismatch("duckdb-conn").await);
+        assert!(!state.connections.read().await.contains_key("duckdb-conn"));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn remove_connection_pools_clears_base_and_database_scoped_pools() {
+        let (state, dir) = test_app_state().await;
+        let pool = crate::db::sqlite::connect_path(":memory:").await.unwrap();
+
+        {
+            let mut conns = state.connections.write().await;
+            conns.insert("conn".to_string(), PoolKind::Sqlite(pool.clone()));
+            conns.insert("conn:analytics".to_string(), PoolKind::Sqlite(pool.clone()));
+            conns.insert("conn:session:tab-1".to_string(), PoolKind::Sqlite(pool.clone()));
+            conns.insert("conn:analytics:session:tab-1".to_string(), PoolKind::Sqlite(pool.clone()));
+            conns.insert("other".to_string(), PoolKind::Sqlite(pool));
+        }
+
+        state.remove_connection_pools("conn").await;
+
+        let conns = state.connections.read().await;
+        assert!(!conns.contains_key("conn"));
+        assert!(!conns.contains_key("conn:analytics"));
+        assert!(!conns.contains_key("conn:session:tab-1"));
+        assert!(!conns.contains_key("conn:analytics:session:tab-1"));
+        assert!(conns.contains_key("other"));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn pool_activity_touch_updates_existing_pool_only() {
+        let (state, dir) = test_app_state().await;
+        let pool = crate::db::sqlite::connect_path(":memory:").await.unwrap();
+        let pool_key = "conn:session:tab-1";
+
+        state.connections.write().await.insert(pool_key.to_string(), PoolKind::Sqlite(pool));
+        state.pool_activity.write().await.insert(
+            pool_key.to_string(),
+            super::PoolActivity { last_used_at: std::time::Instant::now() - std::time::Duration::from_secs(10) },
+        );
+
+        {
+            let _touch = state.pool_activity_touch(pool_key);
+        }
+        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+        let elapsed = state.pool_activity.read().await.get(pool_key).unwrap().last_used_at.elapsed();
+        assert!(elapsed < std::time::Duration::from_secs(10));
+
+        {
+            let _touch = state.pool_activity_touch(pool_key);
+            state.connections.write().await.remove(pool_key);
+            state.pool_activity.write().await.remove(pool_key);
+        }
+        tokio::time::sleep(std::time::Duration::from_millis(10)).await;
+        assert!(!state.pool_activity.read().await.contains_key(pool_key));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn session_scoped_pool_is_not_closed_by_idle_timeout() {
+        let (state, dir) = test_app_state().await;
+        let pool_key = "conn:session:tab-1";
+        let pool = crate::db::sqlite::connect_path(":memory:").await.unwrap();
+        let mut config = mysql_config(None);
+        config.idle_timeout_secs = 1;
+        config.keepalive_interval_secs = 0;
+
+        state.connections.write().await.insert(pool_key.to_string(), PoolKind::Sqlite(pool));
+        state.pool_activity.write().await.insert(
+            pool_key.to_string(),
+            super::PoolActivity { last_used_at: std::time::Instant::now() - std::time::Duration::from_secs(10) },
+        );
+        let pool = super::clone_pool_kind(state.connections.read().await.get(pool_key).unwrap());
+        state.start_keepalive_task(pool_key, &pool, &config).await;
+
+        tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+
+        assert!(state.connections.read().await.contains_key(pool_key));
+        assert!(!state.keepalive_tasks.read().await.contains_key(pool_key));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn close_client_session_pool_releases_session_scoped_pool() {
+        let (state, dir) = test_app_state().await;
+        let mut config = mysql_config(None);
+        config.id = "conn".to_string();
+        config.db_type = DatabaseType::Sqlite;
+        state.configs.write().await.insert(config.id.clone(), config);
+
+        let pool_key = "conn:session:tab-1";
+        let pool = crate::db::sqlite::connect_path(":memory:").await.unwrap();
+        state.connections.write().await.insert(pool_key.to_string(), PoolKind::Sqlite(pool));
+        state.pool_activity.write().await.insert(pool_key.to_string(), super::PoolActivity::now());
+
+        assert!(state.close_client_session_pool("conn", None, "tab-1").await.unwrap());
+        assert!(!state.connections.read().await.contains_key(pool_key));
+        assert!(!state.pool_activity.read().await.contains_key(pool_key));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[test]
+    fn agent_validate_connection_unknown_method_is_not_stale() {
+        assert!(super::is_agent_validate_connection_unsupported(
+            "Agent RPC error (-1): Unknown method: validate_connection"
+        ));
+        assert!(super::is_agent_validate_connection_unsupported(
+            "Agent RPC error (-32601): Method not found: validate_connection"
+        ));
+        assert!(!super::is_agent_validate_connection_unsupported("Agent RPC error (-1): Connection timed out"));
+        assert!(!super::is_agent_validate_connection_unsupported("Agent RPC error (-1): Unknown method: kv_put"));
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[tokio::test]
+    async fn duckdb_client_session_reuses_base_pool_to_avoid_file_locks() {
+        let (state, dir) = test_app_state().await;
+        let db_path = dir.join("session.duckdb");
+        duckdb::Connection::open(&db_path).unwrap();
+        let mut config = mysql_config(None);
+        config.id = "duckdb-conn".to_string();
+        config.name = "DuckDB".to_string();
+        config.db_type = DatabaseType::DuckDb;
+        config.host = db_path.to_string_lossy().to_string();
+        config.port = 0;
+
+        state.configs.write().await.insert(config.id.clone(), config.clone());
+        let base_pool_key = state.get_or_create_pool("duckdb-conn", None).await.unwrap();
+        let pool_key = state.get_or_create_pool_for_session("duckdb-conn", Some("main"), Some("tab-1")).await.unwrap();
+        assert_eq!(pool_key, base_pool_key);
+
+        assert!(!state.close_client_session_pool("duckdb-conn", Some("main"), "tab-1").await.unwrap());
+
+        let conns = state.connections.read().await;
+        assert!(conns.contains_key("duckdb-conn"));
+        assert!(!conns.contains_key("duckdb-conn:session:tab-1"));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn sqlite_memory_client_sessions_share_the_same_database() {
+        let (state, dir) = test_app_state().await;
+        let mut config = mysql_config(None);
+        config.id = "sqlite-memory".to_string();
+        config.name = "SQLite memory".to_string();
+        config.db_type = DatabaseType::Sqlite;
+        config.host = ":memory:".to_string();
+        config.password.clear();
+        config.port = 0;
+
+        state.configs.write().await.insert(config.id.clone(), config);
+        let base_pool_key = state.get_or_create_pool("sqlite-memory", None).await.unwrap();
+        let query_pool_key =
+            state.get_or_create_pool_for_session("sqlite-memory", Some("main"), Some("query-tab")).await.unwrap();
+        let data_pool_key =
+            state.get_or_create_pool_for_session("sqlite-memory", Some("main"), Some("data-tab")).await.unwrap();
+
+        assert_eq!(query_pool_key, base_pool_key);
+        assert_eq!(data_pool_key, base_pool_key);
+
+        let handle = {
+            let connections = state.connections.read().await;
+            match connections.get(&base_pool_key) {
+                Some(PoolKind::Sqlite(handle)) => handle.clone(),
+                _ => panic!("expected SQLite pool"),
+            }
+        };
+        handle
+            .with_connection(|connection| {
+                connection
+                    .execute_batch("CREATE TABLE test (id INTEGER); INSERT INTO test VALUES (42);")
+                    .map_err(|error| error.to_string())
+            })
+            .unwrap();
+        let value = handle
+            .with_connection(|connection| {
+                connection
+                    .query_row("SELECT id FROM test", [], |row| row.get::<_, i64>(0))
+                    .map_err(|error| error.to_string())
+            })
+            .unwrap();
+        assert_eq!(value, 42);
+
+        assert!(!state.close_client_session_pool("sqlite-memory", Some("main"), "query-tab").await.unwrap());
+        assert!(state.connections.read().await.contains_key(&base_pool_key));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn close_database_pool_removes_database_and_session_scoped_pools_only() {
+        let (state, dir) = test_app_state().await;
+        let mut config = mysql_config(None);
+        config.id = "conn".to_string();
+        state.configs.write().await.insert(config.id.clone(), config);
+        let pool = crate::db::sqlite::connect_path(":memory:").await.unwrap();
+
+        {
+            let mut conns = state.connections.write().await;
+            conns.insert("conn".to_string(), PoolKind::Sqlite(pool.clone()));
+            conns.insert("conn:analytics".to_string(), PoolKind::Sqlite(pool.clone()));
+            conns.insert("conn:analytics:session:tab-1".to_string(), PoolKind::Sqlite(pool.clone()));
+            conns.insert("conn:billing".to_string(), PoolKind::Sqlite(pool));
+        }
+
+        assert!(state.close_database_pool("conn", Some("analytics")).await.unwrap());
+
+        let conns = state.connections.read().await;
+        assert!(conns.contains_key("conn"));
+        assert!(!conns.contains_key("conn:analytics"));
+        assert!(!conns.contains_key("conn:analytics:session:tab-1"));
+        assert!(conns.contains_key("conn:billing"));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    fn ssh_layer(id: &str, profile_id: &str) -> SshTunnelConfig {
+        SshTunnelConfig {
+            id: id.to_string(),
+            name: String::new(),
+            enabled: true,
+            host: String::new(),
+            port: 22,
+            user: String::new(),
+            password: String::new(),
+            key_path: String::new(),
+            key_passphrase: String::new(),
+            connect_timeout_secs: 5,
+            expose_lan: false,
+            use_ssh_agent: false,
+            ssh_agent_sock_path: String::new(),
+            auth_method: String::new(),
+            profile_id: profile_id.to_string(),
+        }
+    }
+
+    fn proxy_layer(id: &str, profile_id: &str) -> ProxyTunnelConfig {
+        ProxyTunnelConfig {
+            id: id.to_string(),
+            name: String::new(),
+            enabled: true,
+            proxy_type: ProxyType::Socks5,
+            host: String::new(),
+            port: 1080,
+            username: String::new(),
+            password: String::new(),
+            profile_id: profile_id.to_string(),
+        }
+    }
+
+    fn http_tunnel_layer(id: &str, profile_id: &str) -> HttpTunnelConfig {
+        HttpTunnelConfig {
+            id: id.to_string(),
+            name: String::new(),
+            enabled: true,
+            url: String::new(),
+            token: String::new(),
+            connect_timeout_secs: 10,
+            profile_id: profile_id.to_string(),
+        }
+    }
+
+    #[tokio::test]
+    async fn resolved_transport_layers_substitutes_shared_profiles() {
+        let (state, dir) = test_app_state().await;
+
+        let mut profile = ssh_layer("shared-bastion", "");
+        profile.name = "Bastion".to_string();
+        profile.host = "bastion.example.com".to_string();
+        profile.user = "deploy".to_string();
+        profile.password = "s3cret".to_string();
+        profile.auth_method = "password".to_string();
+        state.storage.save_tunnel_profiles(&[TransportLayerConfig::Ssh(profile)]).await.unwrap();
+
+        let mut config = mysql_config(Some("app"));
+        config.transport_layers = vec![TransportLayerConfig::Ssh(ssh_layer("layer-1", "shared-bastion"))];
+
+        let resolved = state.resolved_transport_layers(&config).await.unwrap();
+        assert_eq!(resolved.len(), 1);
+        match &resolved[0] {
+            TransportLayerConfig::Ssh(ssh) => {
+                // Profile supplies the configuration; the layer keeps its identity.
+                assert_eq!(ssh.id, "layer-1");
+                assert_eq!(ssh.profile_id, "shared-bastion");
+                assert_eq!(ssh.host, "bastion.example.com");
+                assert_eq!(ssh.user, "deploy");
+                assert_eq!(ssh.password, "s3cret");
+            }
+            other => panic!("expected ssh layer, got {other:?}"),
+        }
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn resolved_transport_layers_fails_closed_on_missing_profile() {
+        let (state, dir) = test_app_state().await;
+
+        let mut config = mysql_config(Some("app"));
+        config.transport_layers = vec![TransportLayerConfig::Ssh(ssh_layer("layer-1", "deleted-profile"))];
+
+        let err = state.resolved_transport_layers(&config).await.unwrap_err();
+        assert!(err.contains("no longer exists"), "unexpected error: {err}");
+
+        // Disabled reference layers are filtered out before resolution, so a
+        // dangling reference on a disabled layer must not block connecting.
+        let mut disabled = ssh_layer("layer-1", "deleted-profile");
+        disabled.enabled = false;
+        config.transport_layers = vec![TransportLayerConfig::Ssh(disabled)];
+        assert!(state.resolved_transport_layers(&config).await.unwrap().is_empty());
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn resolved_transport_layers_rejects_mismatched_profile_types() {
+        let (state, dir) = test_app_state().await;
+
+        let mismatches = [
+            (
+                TransportLayerConfig::Ssh(ssh_layer("layer", "shared")),
+                TransportLayerConfig::Proxy(proxy_layer("shared", "")),
+            ),
+            (
+                TransportLayerConfig::Proxy(proxy_layer("layer", "shared")),
+                TransportLayerConfig::HttpTunnel(http_tunnel_layer("shared", "")),
+            ),
+            (
+                TransportLayerConfig::HttpTunnel(http_tunnel_layer("layer", "shared")),
+                TransportLayerConfig::Ssh(ssh_layer("shared", "")),
+            ),
+        ];
+
+        for (layer, profile) in mismatches {
+            state.storage.save_tunnel_profiles(&[profile]).await.unwrap();
+            let mut config = mysql_config(Some("app"));
+            config.transport_layers = vec![layer];
+
+            let error = state.resolved_transport_layers(&config).await.unwrap_err();
+            assert!(error.contains("different type"));
+        }
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn proxy_connection_uses_local_forward_endpoint() {
+        let (state, dir) = test_app_state().await;
+        let mut config = mysql_config(Some("app"));
+        config.transport_layers = vec![TransportLayerConfig::Proxy(ProxyTunnelConfig {
+            profile_id: String::new(),
+            id: "proxy".to_string(),
+            name: String::new(),
+            enabled: true,
+            proxy_type: ProxyType::Socks5,
+            host: "127.0.0.1".to_string(),
+            port: 65000,
+            username: String::new(),
+            password: String::new(),
+        })];
+
+        let (host, port) = state.connection_host_port("proxied", &config).await.unwrap();
+
+        assert_eq!(host, "127.0.0.1");
+        assert_ne!(port, config.port);
+        state.proxy_tunnels.stop_tunnel("proxied:transport:0").await;
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[test]
+    fn mq_remote_endpoint_comes_from_admin_url_when_host_fields_are_empty() {
+        let mut config = mysql_config(None);
+        config.db_type = DatabaseType::MessageQueue;
+        config.host = String::new();
+        config.port = 0;
+        config.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "https://broker.internal:8443/pulsar-admin?tenant=public",
+            "auth": { "kind": "none" }
+        }));
+
+        assert_eq!(connection_remote_endpoint(&config), ("broker.internal".to_string(), 8443));
+    }
+
+    #[cfg(feature = "mq-admin")]
+    #[tokio::test]
+    async fn mq_admin_config_preserves_admin_url_and_uses_forwarded_connect_override() {
+        let (state, dir) = test_app_state().await;
+        let mut config = mysql_config(None);
+        config.id = "proxied-mq".to_string();
+        config.db_type = DatabaseType::MessageQueue;
+        config.host = String::new();
+        config.port = 0;
+        config.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "https://broker.internal:8443/pulsar-admin?tenant=public",
+            "auth": { "kind": "none" }
+        }));
+        config.transport_layers = vec![TransportLayerConfig::Proxy(ProxyTunnelConfig {
+            profile_id: String::new(),
+            id: "proxy".to_string(),
+            name: String::new(),
+            enabled: true,
+            proxy_type: ProxyType::Socks5,
+            host: "127.0.0.1".to_string(),
+            port: 65000,
+            username: String::new(),
+            password: String::new(),
+        })];
+
+        let mqc = state.mq_admin_config_for_connection("proxied-mq", &config).await.unwrap();
+
+        assert_eq!(mqc.admin_url, "https://broker.internal:8443/pulsar-admin?tenant=public");
+        let connect_override = mqc.connect_override.expect("MQ transport should set a connect override");
+        assert_eq!(connect_override.host, "127.0.0.1");
+        assert_ne!(connect_override.port, 8443);
+        state.proxy_tunnels.stop_tunnel("proxied-mq:transport:0").await;
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn nacos_admin_config_allows_domain_server_addr_without_transport_override() {
+        let (state, dir) = test_app_state().await;
+        let mut config = mysql_config(None);
+        config.id = "aliyun-nacos".to_string();
+        config.db_type = DatabaseType::Nacos;
+        config.host = "example.com".to_string();
+        config.port = 8848;
+        config.external_config = Some(serde_json::json!({
+            "serverAddr": "https://nacos.aliyuncs.com:8848",
+            "namespace": "public",
+            "contextPath": "/nacos",
+            "auth": { "kind": "none" }
+        }));
+
+        let nacos_config = state.nacos_admin_config_for_connection("aliyun-nacos", &config).await.unwrap();
+
+        assert_eq!(nacos_config.server_addr, "https://nacos.aliyuncs.com:8848");
+        assert!(nacos_config.connect_override.is_none());
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn nacos_admin_config_rewrites_server_addr_to_forwarded_endpoint() {
+        let (state, dir) = test_app_state().await;
+        let mut config = mysql_config(None);
+        config.id = "proxied-nacos".to_string();
+        config.db_type = DatabaseType::Nacos;
+        config.host = "192.168.2.51".to_string();
+        config.port = 10840;
+        config.external_config = Some(serde_json::json!({
+            "serverAddr": "http://192.168.2.51:10840",
+            "namespace": "public",
+            "contextPath": "",
+            "auth": { "kind": "none" }
+        }));
+        config.transport_layers = vec![TransportLayerConfig::Proxy(ProxyTunnelConfig {
+            profile_id: String::new(),
+            id: "proxy".to_string(),
+            name: String::new(),
+            enabled: true,
+            proxy_type: ProxyType::Socks5,
+            host: "127.0.0.1".to_string(),
+            port: 65000,
+            username: String::new(),
+            password: String::new(),
+        })];
+
+        let nacos_config = state.nacos_admin_config_for_connection("proxied-nacos", &config).await.unwrap();
+
+        assert!(nacos_config.server_addr.starts_with("http://127.0.0.1:"));
+        assert_ne!(nacos_config.server_addr, "http://192.168.2.51:10840");
+        assert!(nacos_config.connect_override.is_none());
+        state.proxy_tunnels.stop_tunnel("proxied-nacos:transport:0").await;
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    #[ignore = "requires a reachable GaussDB instance via environment variables"]
+    async fn live_gaussdb_native_connection_succeeds() {
+        let host = std::env::var("DBX_TEST_GAUSSDB_HOST").expect("DBX_TEST_GAUSSDB_HOST not set");
+        let port = std::env::var("DBX_TEST_GAUSSDB_PORT")
+            .expect("DBX_TEST_GAUSSDB_PORT not set")
+            .parse::<u16>()
+            .expect("DBX_TEST_GAUSSDB_PORT should be a u16");
+        let username = std::env::var("DBX_TEST_GAUSSDB_USER").expect("DBX_TEST_GAUSSDB_USER not set");
+        let password = std::env::var("DBX_TEST_GAUSSDB_PASSWORD").expect("DBX_TEST_GAUSSDB_PASSWORD not set");
+        let url_params = std::env::var("DBX_TEST_GAUSSDB_URL_PARAMS").ok();
+
+        assert_live_postgres_like_query(live_postgres_like_config(
+            DatabaseType::Gaussdb,
+            &host,
+            port,
+            &username,
+            &password,
+            url_params.as_deref(),
+        ))
+        .await;
+    }
+
+    #[tokio::test]
+    #[ignore = "requires a reachable openGauss instance via environment variables"]
+    async fn live_opengauss_native_connection_succeeds() {
+        let host = std::env::var("DBX_TEST_OPENGAUSS_HOST").expect("DBX_TEST_OPENGAUSS_HOST not set");
+        let port = std::env::var("DBX_TEST_OPENGAUSS_PORT")
+            .expect("DBX_TEST_OPENGAUSS_PORT not set")
+            .parse::<u16>()
+            .expect("DBX_TEST_OPENGAUSS_PORT should be a u16");
+        let username = std::env::var("DBX_TEST_OPENGAUSS_USER").expect("DBX_TEST_OPENGAUSS_USER not set");
+        let password = std::env::var("DBX_TEST_OPENGAUSS_PASSWORD").expect("DBX_TEST_OPENGAUSS_PASSWORD not set");
+        let url_params = std::env::var("DBX_TEST_OPENGAUSS_URL_PARAMS").ok();
+
+        assert_live_postgres_like_query(live_postgres_like_config(
+            DatabaseType::OpenGauss,
+            &host,
+            port,
+            &username,
+            &password,
+            url_params.as_deref(),
+        ))
+        .await;
+    }
+
+    #[tokio::test]
+    #[ignore = "requires a reachable KWDB instance via environment variables"]
+    async fn live_kwdb_native_connection_succeeds() {
+        let host = std::env::var("DBX_TEST_KWDB_HOST").expect("DBX_TEST_KWDB_HOST not set");
+        let port = std::env::var("DBX_TEST_KWDB_PORT")
+            .expect("DBX_TEST_KWDB_PORT not set")
+            .parse::<u16>()
+            .expect("DBX_TEST_KWDB_PORT should be a u16");
+        let username = std::env::var("DBX_TEST_KWDB_USER").unwrap_or_else(|_| "root".to_string());
+        let password = std::env::var("DBX_TEST_KWDB_PASSWORD").unwrap_or_default();
+        let database = std::env::var("DBX_TEST_KWDB_DATABASE").unwrap_or_else(|_| "defaultdb".to_string());
+        let url_params = std::env::var("DBX_TEST_KWDB_URL_PARAMS").unwrap_or_else(|_| "sslmode=disable".to_string());
+
+        let mut config = mysql_config(Some(&database));
+        config.id = "kwdb-live".to_string();
+        config.db_type = DatabaseType::Kwdb;
+        config.host = host;
+        config.port = port;
+        config.username = username;
+        config.password = password;
+        config.url_params = Some(url_params);
+
+        let (state, dir) = test_app_state().await;
+        state.configs.write().await.insert(config.id.clone(), config);
+        let pool_key = state.get_or_create_pool("kwdb-live", None).await.unwrap();
+        let pool = {
+            let connections = state.connections.read().await;
+            match connections.get(&pool_key).expect("KWDB pool should be created") {
+                PoolKind::Postgres(pool) => pool.clone(),
+                _ => panic!("KWDB should use the PostgreSQL pool path"),
+            }
+        };
+        let result = query::execute_sql_statement(
+            &state,
+            "kwdb-live",
+            &database,
+            "SELECT current_database(), current_schema()",
+            None,
+            None,
+        )
+        .await
+        .unwrap_or_else(|err| panic!("failed to query live KWDB: {err}"));
+        assert_eq!(result.rows.len(), 1);
+        let database_column_index = result
+            .columns
+            .iter()
+            .position(|column| column == "current_database")
+            .expect("current_database column should be present");
+        assert_eq!(result.rows[0].get(database_column_index).and_then(|value| value.as_str()), Some(database.as_str()));
+        let databases = schema::list_databases_core(&state, "kwdb-live").await.unwrap();
+        assert!(databases.iter().any(|database| database.name == "defaultdb"));
+        let test_schema = "dbx_kwdb_live";
+        db::postgres::execute_query(&pool, &format!("DROP SCHEMA IF EXISTS {test_schema} CASCADE"))
+            .await
+            .unwrap_or_else(|err| panic!("failed to clean KWDB test schema: {err}"));
+        query::execute_sql_statement(
+            &state,
+            "kwdb-live",
+            &database,
+            &format!("CREATE SCHEMA {test_schema}"),
+            None,
+            None,
+        )
+        .await
+        .unwrap_or_else(|err| panic!("failed to create KWDB test schema: {err}"));
+        query::execute_sql_statement(
+            &state,
+            "kwdb-live",
+            &database,
+            "CREATE TABLE devices (id INT PRIMARY KEY, name STRING, active BOOL)",
+            Some(test_schema),
+            None,
+        )
+        .await
+        .unwrap_or_else(|err| panic!("failed to create KWDB test table: {err}"));
+        query::execute_sql_statement(
+            &state,
+            "kwdb-live",
+            &database,
+            "INSERT INTO devices (id, name, active) VALUES (1, 'meter-a', true)",
+            Some(test_schema),
+            None,
+        )
+        .await
+        .unwrap_or_else(|err| panic!("failed to insert KWDB test row: {err}"));
+        let query_result = query::execute_sql_statement(
+            &state,
+            "kwdb-live",
+            &database,
+            "SELECT name, active FROM devices WHERE id = 1",
+            Some(test_schema),
+            None,
+        )
+        .await
+        .unwrap_or_else(|err| panic!("failed to query KWDB test row: {err}"));
+        assert_eq!(query_result.rows.len(), 1);
+        assert_eq!(query_result.rows[0].first().and_then(|value| value.as_str()), Some("meter-a"));
+
+        let schemas = schema::list_schemas_core(&state, "kwdb-live", &database).await.unwrap();
+        assert!(schemas.iter().any(|schema| schema == test_schema));
+        let tables = schema::list_tables_core(&state, "kwdb-live", &database, test_schema, None, None, None, None)
+            .await
+            .unwrap();
+        assert!(tables.iter().any(|table| table.name == "devices" && table.table_type == "BASE TABLE"));
+        let columns = schema::get_columns_core(&state, "kwdb-live", &database, test_schema, "devices").await.unwrap();
+        let id_column = columns.iter().find(|column| column.name == "id").expect("id column should be listed");
+        assert!(id_column.data_type.to_lowercase().contains("int"));
+        let name_column = columns.iter().find(|column| column.name == "name").expect("name column should be listed");
+        assert!(name_column.data_type.to_lowercase().contains("text"));
+        let active_column =
+            columns.iter().find(|column| column.name == "active").expect("active column should be listed");
+        assert!(active_column.data_type.to_lowercase().contains("bool"));
+        db::postgres::execute_query(&pool, &format!("DROP SCHEMA {test_schema} CASCADE"))
+            .await
+            .unwrap_or_else(|err| panic!("failed to drop KWDB test schema: {err}"));
+        pool.close();
+        let _ = std::fs::remove_dir_all(dir);
+    }
+}
diff --git a/crates/dbx-core/src/connection_secrets.rs b/crates/dbx-core/src/connection_secrets.rs
new file mode 100644
index 0000000..b72efe6
--- /dev/null
+++ b/crates/dbx-core/src/connection_secrets.rs
@@ -0,0 +1,1106 @@
+use crate::models::connection::{ConnectionConfig, DatabaseType, TransportLayerConfig};
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::path::{Path, PathBuf};
+
+pub const MAIN_PASSWORD_KEY: &str = "password";
+pub const SSH_PASSWORD_KEY: &str = "ssh_password";
+pub const SSH_KEY_PASSPHRASE_KEY: &str = "ssh_key_passphrase";
+pub const SSH_TUNNEL_SECRET_PREFIX: &str = "ssh_tunnels.";
+pub const TRANSPORT_LAYER_SECRET_PREFIX: &str = "transport_layers.";
+pub const PROXY_PASSWORD_KEY: &str = "proxy_password";
+pub const REDIS_SENTINEL_PASSWORD_KEY: &str = "redis_sentinel_password";
+pub const CONNECTION_STRING_KEY: &str = "connection_string";
+pub const MQ_AUTH_SECRET_PREFIX: &str = "mq.auth.";
+pub const MQ_AUTH_TOKEN_KEY: &str = "mq.auth.token";
+pub const MQ_AUTH_PASSWORD_KEY: &str = "mq.auth.password";
+pub const MQ_AUTH_API_KEY_VALUE_KEY: &str = "mq.auth.api_key_value";
+pub const MQ_AUTH_CLIENT_SECRET_KEY: &str = "mq.auth.client_secret";
+pub const MQ_TOKEN_SIGNING_SECRET_PREFIX: &str = "mq.token_signing.";
+pub const MQ_TOKEN_SIGNING_KEY: &str = "mq.token_signing.key";
+pub const NACOS_AUTH_SECRET_PREFIX: &str = "nacos.auth.";
+pub const NACOS_AUTH_PASSWORD_KEY: &str = "nacos.auth.password";
+
+pub trait ConnectionSecretStore {
+    fn set_secret(&self, connection_id: &str, key: &str, secret: &str) -> Result<(), String>;
+    fn get_secret(&self, connection_id: &str, key: &str) -> Result<Option<String>, String>;
+    fn delete_secret(&self, connection_id: &str, key: &str) -> Result<(), String>;
+    fn delete_secret_prefix(&self, _connection_id: &str, _key_prefix: &str) -> Result<(), String> {
+        Ok(())
+    }
+}
+
+pub struct FileSecretStore {
+    path: PathBuf,
+}
+
+impl FileSecretStore {
+    pub fn new(path: PathBuf) -> Self {
+        Self { path }
+    }
+
+    fn read_store(&self) -> HashMap<String, String> {
+        match std::fs::read_to_string(&self.path) {
+            Ok(json) => match serde_json::from_str(&json) {
+                Ok(map) => map,
+                Err(e) => {
+                    log::warn!(
+                        "Failed to parse secret store at {:?}: {}. Returning empty store. This may indicate file corruption.",
+                        self.path, e
+                    );
+                    HashMap::default()
+                }
+            },
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => HashMap::default(),
+            Err(e) => {
+                log::warn!("Failed to read secret store at {:?}: {}. Returning empty store.", self.path, e);
+                HashMap::default()
+            }
+        }
+    }
+
+    fn write_store(&self, map: &HashMap<String, String>) -> Result<(), String> {
+        let json = serde_json::to_string_pretty(map).map_err(|e| e.to_string())?;
+        std::fs::write(&self.path, json).map_err(|e| e.to_string())
+    }
+}
+
+impl ConnectionSecretStore for FileSecretStore {
+    fn set_secret(&self, connection_id: &str, key: &str, secret: &str) -> Result<(), String> {
+        let mut map = self.read_store();
+        map.insert(secret_account(connection_id, key), secret.to_string());
+        self.write_store(&map)
+    }
+
+    fn get_secret(&self, connection_id: &str, key: &str) -> Result<Option<String>, String> {
+        Ok(self.read_store().get(&secret_account(connection_id, key)).cloned())
+    }
+
+    fn delete_secret(&self, connection_id: &str, key: &str) -> Result<(), String> {
+        let mut map = self.read_store();
+        map.remove(&secret_account(connection_id, key));
+        self.write_store(&map)
+    }
+
+    fn delete_secret_prefix(&self, connection_id: &str, key_prefix: &str) -> Result<(), String> {
+        let mut map = self.read_store();
+        let account_prefix = secret_account(connection_id, key_prefix);
+        map.retain(|key, _| !key.starts_with(&account_prefix));
+        self.write_store(&map)
+    }
+}
+
+pub fn save_connections_to_file(
+    path: &Path,
+    configs: &[ConnectionConfig],
+    store: &dyn ConnectionSecretStore,
+) -> Result<(), String> {
+    delete_removed_connection_secrets(path, configs, store)?;
+    for config in configs {
+        persist_secret(store, &config.id, MAIN_PASSWORD_KEY, &config.password)?;
+        delete_secret_prefix(store, &config.id, TRANSPORT_LAYER_SECRET_PREFIX)?;
+        for (index, layer) in config.transport_layers.iter().enumerate() {
+            persist_transport_layer_secrets(store, &config.id, index, layer)?;
+        }
+        persist_secret(store, &config.id, REDIS_SENTINEL_PASSWORD_KEY, &config.redis_sentinel_password)?;
+        persist_optional_secret(store, &config.id, CONNECTION_STRING_KEY, config.connection_string.as_deref())?;
+        persist_mq_auth_secrets(store, config)?;
+        persist_mq_token_signing_secret(store, config)?;
+
+        // New configs persist transport-layer secrets only. Remove legacy transport secret slots after the
+        // migrated layer values have been written so old configs do not keep two sources of truth.
+        store.delete_secret(&config.id, SSH_PASSWORD_KEY)?;
+        store.delete_secret(&config.id, SSH_KEY_PASSPHRASE_KEY)?;
+        store.delete_secret(&config.id, PROXY_PASSWORD_KEY)?;
+        delete_secret_prefix(store, &config.id, SSH_TUNNEL_SECRET_PREFIX)?;
+    }
+
+    write_sanitized_connections(path, configs)
+}
+
+pub fn load_connections_from_file(
+    path: &Path,
+    store: &dyn ConnectionSecretStore,
+) -> Result<Vec<ConnectionConfig>, String> {
+    if !path.exists() {
+        return Ok(vec![]);
+    }
+
+    let mut configs = read_connections(path)?;
+    let mut needs_rewrite = false;
+    for config in &mut configs {
+        if config.password.is_empty() {
+            if let Some(secret) = store.get_secret(&config.id, MAIN_PASSWORD_KEY)? {
+                config.password = secret;
+            }
+        } else {
+            store.set_secret(&config.id, MAIN_PASSWORD_KEY, &config.password)?;
+            needs_rewrite = true;
+        }
+
+        hydrate_transport_layer_secrets(store, config, &mut needs_rewrite)?;
+
+        if config.redis_sentinel_password.is_empty() {
+            if let Some(secret) = store.get_secret(&config.id, REDIS_SENTINEL_PASSWORD_KEY)? {
+                config.redis_sentinel_password = secret;
+            }
+        } else {
+            store.set_secret(&config.id, REDIS_SENTINEL_PASSWORD_KEY, &config.redis_sentinel_password)?;
+            needs_rewrite = true;
+        }
+
+        match config.connection_string.as_deref().filter(|secret| !secret.is_empty()) {
+            Some(secret) => {
+                store.set_secret(&config.id, CONNECTION_STRING_KEY, secret)?;
+                needs_rewrite = true;
+            }
+            None => {
+                if let Some(secret) = store.get_secret(&config.id, CONNECTION_STRING_KEY)? {
+                    config.connection_string = Some(secret);
+                }
+            }
+        }
+        hydrate_mq_auth_secrets(store, config, &mut needs_rewrite)?;
+        hydrate_mq_token_signing_secret(store, config, &mut needs_rewrite)?;
+    }
+
+    if needs_rewrite {
+        write_sanitized_connections(path, &configs)?;
+    }
+
+    Ok(configs)
+}
+
+fn persist_transport_layer_secrets(
+    store: &dyn ConnectionSecretStore,
+    connection_id: &str,
+    index: usize,
+    layer: &TransportLayerConfig,
+) -> Result<(), String> {
+    match layer {
+        TransportLayerConfig::Ssh(ssh) => {
+            persist_secret(store, connection_id, &transport_layer_ssh_password_key(index, layer), &ssh.password)?;
+            persist_secret(
+                store,
+                connection_id,
+                &transport_layer_ssh_key_passphrase_key(index, layer),
+                &ssh.key_passphrase,
+            )?;
+        }
+        TransportLayerConfig::Proxy(proxy) => {
+            persist_secret(store, connection_id, &transport_layer_proxy_password_key(index, layer), &proxy.password)?;
+        }
+        TransportLayerConfig::HttpTunnel(http) => {
+            persist_secret(store, connection_id, &transport_layer_http_tunnel_token_key(index, layer), &http.token)?;
+        }
+    }
+    Ok(())
+}
+
+fn hydrate_transport_layer_secrets(
+    store: &dyn ConnectionSecretStore,
+    config: &mut ConnectionConfig,
+    needs_rewrite: &mut bool,
+) -> Result<(), String> {
+    for index in 0..config.transport_layers.len() {
+        let layer_for_key = config.transport_layers[index].clone();
+        match &mut config.transport_layers[index] {
+            TransportLayerConfig::Ssh(ssh) => {
+                let password_key = transport_layer_ssh_password_key(index, &layer_for_key);
+                if ssh.password.is_empty() {
+                    if let Some(secret) = store.get_secret(&config.id, &password_key)?.or(legacy_ssh_password_secret(
+                        store,
+                        &config.id,
+                        index,
+                        &layer_for_key,
+                    )?) {
+                        ssh.password = secret;
+                    }
+                } else {
+                    store.set_secret(&config.id, &password_key, &ssh.password)?;
+                    *needs_rewrite = true;
+                }
+
+                let passphrase_key = transport_layer_ssh_key_passphrase_key(index, &layer_for_key);
+                if ssh.key_passphrase.is_empty() {
+                    if let Some(secret) = store
+                        .get_secret(&config.id, &passphrase_key)?
+                        .or(legacy_ssh_key_passphrase_secret(store, &config.id, index, &layer_for_key)?)
+                    {
+                        ssh.key_passphrase = secret;
+                    }
+                } else {
+                    store.set_secret(&config.id, &passphrase_key, &ssh.key_passphrase)?;
+                    *needs_rewrite = true;
+                }
+            }
+            TransportLayerConfig::Proxy(proxy) => {
+                let password_key = transport_layer_proxy_password_key(index, &layer_for_key);
+                if proxy.password.is_empty() {
+                    if let Some(secret) = store.get_secret(&config.id, &password_key)?.or(legacy_proxy_password_secret(
+                        store,
+                        &config.id,
+                        &layer_for_key,
+                    )?) {
+                        proxy.password = secret;
+                    }
+                } else {
+                    store.set_secret(&config.id, &password_key, &proxy.password)?;
+                    *needs_rewrite = true;
+                }
+            }
+            TransportLayerConfig::HttpTunnel(http) => {
+                let token_key = transport_layer_http_tunnel_token_key(index, &layer_for_key);
+                if http.token.is_empty() {
+                    if let Some(secret) = store.get_secret(&config.id, &token_key)? {
+                        http.token = secret;
+                    }
+                } else {
+                    store.set_secret(&config.id, &token_key, &http.token)?;
+                    *needs_rewrite = true;
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn legacy_ssh_password_secret(
+    store: &dyn ConnectionSecretStore,
+    connection_id: &str,
+    index: usize,
+    layer: &TransportLayerConfig,
+) -> Result<Option<String>, String> {
+    if let TransportLayerConfig::Ssh(ssh) = layer {
+        if ssh.id == "legacy" {
+            if let Some(secret) = store.get_secret(connection_id, SSH_PASSWORD_KEY)? {
+                return Ok(Some(secret));
+            }
+        }
+        store.get_secret(connection_id, &ssh_tunnel_password_key(index, ssh))
+    } else {
+        Ok(None)
+    }
+}
+
+fn legacy_ssh_key_passphrase_secret(
+    store: &dyn ConnectionSecretStore,
+    connection_id: &str,
+    index: usize,
+    layer: &TransportLayerConfig,
+) -> Result<Option<String>, String> {
+    if let TransportLayerConfig::Ssh(ssh) = layer {
+        if ssh.id == "legacy" {
+            if let Some(secret) = store.get_secret(connection_id, SSH_KEY_PASSPHRASE_KEY)? {
+                return Ok(Some(secret));
+            }
+        }
+        store.get_secret(connection_id, &ssh_tunnel_key_passphrase_key(index, ssh))
+    } else {
+        Ok(None)
+    }
+}
+
+fn legacy_proxy_password_secret(
+    store: &dyn ConnectionSecretStore,
+    connection_id: &str,
+    layer: &TransportLayerConfig,
+) -> Result<Option<String>, String> {
+    if matches!(layer, TransportLayerConfig::Proxy(proxy) if proxy.id == "legacy-proxy") {
+        store.get_secret(connection_id, PROXY_PASSWORD_KEY)
+    } else {
+        Ok(None)
+    }
+}
+
+fn delete_removed_connection_secrets(
+    path: &Path,
+    configs: &[ConnectionConfig],
+    store: &dyn ConnectionSecretStore,
+) -> Result<(), String> {
+    if !path.exists() {
+        return Ok(());
+    }
+
+    let previous = match read_connections(path) {
+        Ok(configs) => configs,
+        Err(_) => return Ok(()),
+    };
+    let current_ids: HashSet<&str> = configs.iter().map(|config| config.id.as_str()).collect();
+    for config in previous {
+        if current_ids.contains(config.id.as_str()) {
+            continue;
+        }
+        store.delete_secret(&config.id, MAIN_PASSWORD_KEY)?;
+        store.delete_secret(&config.id, SSH_PASSWORD_KEY)?;
+        store.delete_secret(&config.id, SSH_KEY_PASSPHRASE_KEY)?;
+        delete_secret_prefix(store, &config.id, SSH_TUNNEL_SECRET_PREFIX)?;
+        delete_secret_prefix(store, &config.id, TRANSPORT_LAYER_SECRET_PREFIX)?;
+        store.delete_secret(&config.id, CONNECTION_STRING_KEY)?;
+        delete_secret_prefix(store, &config.id, MQ_AUTH_SECRET_PREFIX)?;
+        delete_secret_prefix(store, &config.id, MQ_TOKEN_SIGNING_SECRET_PREFIX)?;
+    }
+    Ok(())
+}
+
+fn persist_secret(
+    store: &dyn ConnectionSecretStore,
+    connection_id: &str,
+    key: &str,
+    secret: &str,
+) -> Result<(), String> {
+    if secret.is_empty() {
+        store.delete_secret(connection_id, key)
+    } else {
+        store.set_secret(connection_id, key, secret)
+    }
+}
+
+fn persist_optional_secret(
+    store: &dyn ConnectionSecretStore,
+    connection_id: &str,
+    key: &str,
+    secret: Option<&str>,
+) -> Result<(), String> {
+    match secret.filter(|secret| !secret.is_empty()) {
+        Some(secret) => store.set_secret(connection_id, key, secret),
+        None => store.delete_secret(connection_id, key),
+    }
+}
+
+fn delete_secret_prefix(
+    store: &dyn ConnectionSecretStore,
+    connection_id: &str,
+    key_prefix: &str,
+) -> Result<(), String> {
+    store.delete_secret_prefix(connection_id, key_prefix)
+}
+
+fn persist_mq_auth_secrets(store: &dyn ConnectionSecretStore, config: &ConnectionConfig) -> Result<(), String> {
+    if config.db_type != DatabaseType::MessageQueue {
+        delete_secret_prefix(store, &config.id, MQ_AUTH_SECRET_PREFIX)?;
+        return Ok(());
+    }
+
+    let Some(auth) = mq_auth_object(config.external_config.as_ref()) else {
+        delete_secret_prefix(store, &config.id, MQ_AUTH_SECRET_PREFIX)?;
+        return Ok(());
+    };
+
+    match mq_auth_kind(auth).as_deref() {
+        Some("none") => delete_secret_prefix(store, &config.id, MQ_AUTH_SECRET_PREFIX)?,
+        Some("token") => replace_mq_auth_secret(store, &config.id, MQ_AUTH_TOKEN_KEY, auth, "token")?,
+        Some("basic") => replace_mq_auth_secret(store, &config.id, MQ_AUTH_PASSWORD_KEY, auth, "password")?,
+        Some("apiKey") | Some("api_key") | Some("apikey") => {
+            replace_mq_auth_secret(store, &config.id, MQ_AUTH_API_KEY_VALUE_KEY, auth, "value")?
+        }
+        Some("oauth2") => replace_mq_auth_secret(store, &config.id, MQ_AUTH_CLIENT_SECRET_KEY, auth, "clientSecret")?,
+        _ => delete_secret_prefix(store, &config.id, MQ_AUTH_SECRET_PREFIX)?,
+    }
+
+    Ok(())
+}
+
+fn replace_mq_auth_secret(
+    store: &dyn ConnectionSecretStore,
+    connection_id: &str,
+    key: &str,
+    auth: &serde_json::Map<String, serde_json::Value>,
+    field: &str,
+) -> Result<(), String> {
+    let current = auth.get(field).and_then(serde_json::Value::as_str).filter(|secret| !secret.is_empty());
+    let existing = if current.is_none() { store.get_secret(connection_id, key)? } else { None };
+    delete_secret_prefix(store, connection_id, MQ_AUTH_SECRET_PREFIX)?;
+    match current {
+        Some(secret) => store.set_secret(connection_id, key, secret),
+        None => match existing {
+            Some(secret) => store.set_secret(connection_id, key, &secret),
+            None => Ok(()),
+        },
+    }
+}
+
+fn persist_mq_token_signing_secret(store: &dyn ConnectionSecretStore, config: &ConnectionConfig) -> Result<(), String> {
+    if config.db_type != DatabaseType::MessageQueue {
+        delete_secret_prefix(store, &config.id, MQ_TOKEN_SIGNING_SECRET_PREFIX)?;
+        return Ok(());
+    }
+
+    let Some(signing) = mq_token_signing_object(config.external_config.as_ref()) else {
+        delete_secret_prefix(store, &config.id, MQ_TOKEN_SIGNING_SECRET_PREFIX)?;
+        return Ok(());
+    };
+
+    persist_json_secret_if_present(store, &config.id, MQ_TOKEN_SIGNING_KEY, signing, "key")
+}
+
+fn hydrate_mq_auth_secrets(
+    store: &dyn ConnectionSecretStore,
+    config: &mut ConnectionConfig,
+    needs_rewrite: &mut bool,
+) -> Result<(), String> {
+    if config.db_type != DatabaseType::MessageQueue {
+        return Ok(());
+    }
+
+    let Some(auth) = mq_auth_object_mut(config.external_config.as_mut()) else {
+        return Ok(());
+    };
+
+    match mq_auth_kind(auth).as_deref() {
+        Some("token") => hydrate_json_secret(store, &config.id, MQ_AUTH_TOKEN_KEY, auth, "token", needs_rewrite)?,
+        Some("basic") => hydrate_json_secret(store, &config.id, MQ_AUTH_PASSWORD_KEY, auth, "password", needs_rewrite)?,
+        Some("apiKey") | Some("api_key") | Some("apikey") => {
+            hydrate_json_secret(store, &config.id, MQ_AUTH_API_KEY_VALUE_KEY, auth, "value", needs_rewrite)?
+        }
+        Some("oauth2") => {
+            hydrate_json_secret(store, &config.id, MQ_AUTH_CLIENT_SECRET_KEY, auth, "clientSecret", needs_rewrite)?
+        }
+        _ => {}
+    }
+
+    Ok(())
+}
+
+fn hydrate_mq_token_signing_secret(
+    store: &dyn ConnectionSecretStore,
+    config: &mut ConnectionConfig,
+    needs_rewrite: &mut bool,
+) -> Result<(), String> {
+    if config.db_type != DatabaseType::MessageQueue {
+        return Ok(());
+    }
+
+    let Some(signing) = mq_token_signing_object_mut(config.external_config.as_mut()) else {
+        return Ok(());
+    };
+
+    hydrate_json_secret(store, &config.id, MQ_TOKEN_SIGNING_KEY, signing, "key", needs_rewrite)
+}
+
+fn persist_json_secret_if_present(
+    store: &dyn ConnectionSecretStore,
+    connection_id: &str,
+    key: &str,
+    auth: &serde_json::Map<String, serde_json::Value>,
+    field: &str,
+) -> Result<(), String> {
+    match auth.get(field).and_then(serde_json::Value::as_str).filter(|secret| !secret.is_empty()) {
+        Some(secret) => store.set_secret(connection_id, key, secret),
+        None => Ok(()),
+    }
+}
+
+fn hydrate_json_secret(
+    store: &dyn ConnectionSecretStore,
+    connection_id: &str,
+    key: &str,
+    auth: &mut serde_json::Map<String, serde_json::Value>,
+    field: &str,
+    needs_rewrite: &mut bool,
+) -> Result<(), String> {
+    match auth.get(field).and_then(serde_json::Value::as_str).filter(|secret| !secret.is_empty()) {
+        Some(secret) => {
+            store.set_secret(connection_id, key, secret)?;
+            *needs_rewrite = true;
+        }
+        None => {
+            if let Some(secret) = store.get_secret(connection_id, key)? {
+                auth.insert(field.to_string(), serde_json::Value::String(secret));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn scrub_mq_auth_secrets(config: &mut ConnectionConfig) {
+    let Some(auth) = mq_auth_object_mut(config.external_config.as_mut()) else {
+        return;
+    };
+    match mq_auth_kind(auth).as_deref() {
+        Some("token") => scrub_json_secret(auth, "token"),
+        Some("basic") => scrub_json_secret(auth, "password"),
+        Some("apiKey") | Some("api_key") | Some("apikey") => scrub_json_secret(auth, "value"),
+        Some("oauth2") => scrub_json_secret(auth, "clientSecret"),
+        _ => {}
+    }
+}
+
+fn scrub_mq_token_signing_secret(config: &mut ConnectionConfig) {
+    let Some(signing) = mq_token_signing_object_mut(config.external_config.as_mut()) else {
+        return;
+    };
+    scrub_json_secret(signing, "key");
+}
+
+fn scrub_json_secret(auth: &mut serde_json::Map<String, serde_json::Value>, field: &str) {
+    if auth.contains_key(field) {
+        auth.insert(field.to_string(), serde_json::Value::String(String::new()));
+    }
+}
+
+fn mq_auth_kind(auth: &serde_json::Map<String, serde_json::Value>) -> Option<String> {
+    auth.get("kind").and_then(serde_json::Value::as_str).map(ToString::to_string)
+}
+
+fn mq_auth_object(value: Option<&serde_json::Value>) -> Option<&serde_json::Map<String, serde_json::Value>> {
+    value?.get("auth")?.as_object()
+}
+
+fn mq_auth_object_mut(
+    value: Option<&mut serde_json::Value>,
+) -> Option<&mut serde_json::Map<String, serde_json::Value>> {
+    value?.get_mut("auth")?.as_object_mut()
+}
+
+fn mq_token_signing_object(value: Option<&serde_json::Value>) -> Option<&serde_json::Map<String, serde_json::Value>> {
+    value?.get("tokenSigning")?.as_object()
+}
+
+fn mq_token_signing_object_mut(
+    value: Option<&mut serde_json::Value>,
+) -> Option<&mut serde_json::Map<String, serde_json::Value>> {
+    value?.get_mut("tokenSigning")?.as_object_mut()
+}
+
+fn ssh_tunnel_secret_segment(index: usize, hop: &crate::models::connection::SshTunnelConfig) -> String {
+    if hop.id.trim().is_empty() {
+        index.to_string()
+    } else {
+        hop.id.clone()
+    }
+}
+
+fn ssh_tunnel_password_key(index: usize, hop: &crate::models::connection::SshTunnelConfig) -> String {
+    format!("{}{}.password", SSH_TUNNEL_SECRET_PREFIX, ssh_tunnel_secret_segment(index, hop))
+}
+
+fn ssh_tunnel_key_passphrase_key(index: usize, hop: &crate::models::connection::SshTunnelConfig) -> String {
+    format!("{}{}.key_passphrase", SSH_TUNNEL_SECRET_PREFIX, ssh_tunnel_secret_segment(index, hop))
+}
+
+fn transport_layer_secret_segment(index: usize, layer: &TransportLayerConfig) -> String {
+    let id = layer.id().trim();
+    if id.is_empty() {
+        index.to_string()
+    } else {
+        id.to_string()
+    }
+}
+
+fn transport_layer_ssh_password_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.ssh_password", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn transport_layer_ssh_key_passphrase_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.ssh_key_passphrase", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn transport_layer_proxy_password_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.proxy_password", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn transport_layer_http_tunnel_token_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.http_tunnel_token", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn read_connections(path: &Path) -> Result<Vec<ConnectionConfig>, String> {
+    let json = std::fs::read_to_string(path).map_err(|e| e.to_string())?;
+    serde_json::from_str(&json).map_err(|e| e.to_string())
+}
+
+fn write_sanitized_connections(path: &Path, configs: &[ConnectionConfig]) -> Result<(), String> {
+    let sanitized = sanitize_connections(configs);
+    let json = serde_json::to_string_pretty(&sanitized).map_err(|e| e.to_string())?;
+    std::fs::write(path, json).map_err(|e| e.to_string())
+}
+
+fn sanitize_connections(configs: &[ConnectionConfig]) -> Vec<ConnectionConfig> {
+    configs
+        .iter()
+        .cloned()
+        .map(|mut config| {
+            config.password.clear();
+            for layer in &mut config.transport_layers {
+                match layer {
+                    TransportLayerConfig::Ssh(ssh) => {
+                        ssh.password.clear();
+                        ssh.key_passphrase.clear();
+                    }
+                    TransportLayerConfig::Proxy(proxy) => {
+                        proxy.password.clear();
+                    }
+                    TransportLayerConfig::HttpTunnel(http) => {
+                        http.token.clear();
+                    }
+                }
+            }
+            config.redis_sentinel_password.clear();
+            config.connection_string = None;
+            scrub_mq_auth_secrets(&mut config);
+            scrub_mq_token_signing_secret(&mut config);
+            config
+        })
+        .collect()
+}
+
+pub fn secret_account(connection_id: &str, key: &str) -> String {
+    format!("connection:{connection_id}:{key}")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        load_connections_from_file, save_connections_to_file, ConnectionSecretStore, CONNECTION_STRING_KEY,
+        MAIN_PASSWORD_KEY, MQ_AUTH_PASSWORD_KEY, MQ_AUTH_TOKEN_KEY, MQ_TOKEN_SIGNING_KEY, REDIS_SENTINEL_PASSWORD_KEY,
+        SSH_PASSWORD_KEY,
+    };
+    use crate::models::connection::{
+        ConnectionConfig, DatabaseType, HttpTunnelConfig, SshTunnelConfig, TransportLayerConfig,
+    };
+    use std::cell::RefCell;
+    use std::collections::HashMap;
+    use std::path::Path;
+
+    #[derive(Default)]
+    struct MemorySecretStore {
+        values: RefCell<HashMap<String, String>>,
+        deleted: RefCell<Vec<String>>,
+    }
+
+    impl MemorySecretStore {
+        fn set_existing(&self, connection_id: &str, key: &str, value: &str) {
+            self.values.borrow_mut().insert(secret_key(connection_id, key), value.to_string());
+        }
+
+        fn get_existing(&self, connection_id: &str, key: &str) -> Option<String> {
+            self.values.borrow().get(&secret_key(connection_id, key)).cloned()
+        }
+
+        fn was_deleted(&self, connection_id: &str, key: &str) -> bool {
+            self.deleted.borrow().contains(&secret_key(connection_id, key))
+        }
+    }
+
+    impl ConnectionSecretStore for MemorySecretStore {
+        fn set_secret(&self, connection_id: &str, key: &str, secret: &str) -> Result<(), String> {
+            self.values.borrow_mut().insert(secret_key(connection_id, key), secret.to_string());
+            Ok(())
+        }
+
+        fn get_secret(&self, connection_id: &str, key: &str) -> Result<Option<String>, String> {
+            Ok(self.values.borrow().get(&secret_key(connection_id, key)).cloned())
+        }
+
+        fn delete_secret(&self, connection_id: &str, key: &str) -> Result<(), String> {
+            self.values.borrow_mut().remove(&secret_key(connection_id, key));
+            self.deleted.borrow_mut().push(secret_key(connection_id, key));
+            Ok(())
+        }
+
+        fn delete_secret_prefix(&self, connection_id: &str, key_prefix: &str) -> Result<(), String> {
+            let prefix = secret_key(connection_id, key_prefix);
+            self.values.borrow_mut().retain(|key, _| !key.starts_with(&prefix));
+            self.deleted.borrow_mut().push(prefix);
+            Ok(())
+        }
+    }
+
+    fn secret_key(connection_id: &str, key: &str) -> String {
+        format!("{connection_id}:{key}")
+    }
+
+    fn temp_connections_file(name: &str) -> std::path::PathBuf {
+        let dir = std::env::temp_dir().join(format!("dbx-connection-secrets-test-{}-{name}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        dir.join("connections.json")
+    }
+
+    fn connection(id: &str, password: &str, _ssh_password: &str) -> ConnectionConfig {
+        ConnectionConfig {
+            id: id.to_string(),
+            name: format!("{id} connection"),
+            db_type: DatabaseType::Postgres,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "localhost".to_string(),
+            port: 5432,
+            username: "postgres".to_string(),
+            password: password.to_string(),
+            database: Some("postgres".to_string()),
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: crate::models::connection::default_connect_timeout_secs(),
+            query_timeout_secs: crate::models::connection::default_query_timeout_secs(),
+            idle_timeout_secs: crate::models::connection::default_idle_timeout_secs(),
+            keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: crate::models::connection::default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    fn ssh_hop(id: &str, password: &str, passphrase: &str) -> SshTunnelConfig {
+        SshTunnelConfig {
+            profile_id: String::new(),
+            id: id.to_string(),
+            name: String::new(),
+            enabled: true,
+            host: "bastion".to_string(),
+            port: 22,
+            user: "user".to_string(),
+            password: password.to_string(),
+            key_path: "~/.ssh/id_ed25519".to_string(),
+            key_passphrase: passphrase.to_string(),
+            connect_timeout_secs: 5,
+            expose_lan: false,
+            use_ssh_agent: false,
+            ssh_agent_sock_path: String::new(),
+            auth_method: "key".to_string(),
+        }
+    }
+
+    fn http_tunnel(id: &str, token: &str) -> TransportLayerConfig {
+        TransportLayerConfig::HttpTunnel(HttpTunnelConfig {
+            profile_id: String::new(),
+            id: id.to_string(),
+            name: String::new(),
+            enabled: true,
+            url: "https://dbx.example.com/dbx_tunnel.php".to_string(),
+            token: token.to_string(),
+            connect_timeout_secs: 10,
+        })
+    }
+
+    fn read_configs(path: &Path) -> Vec<ConnectionConfig> {
+        let json = std::fs::read_to_string(path).unwrap();
+        serde_json::from_str(&json).unwrap()
+    }
+
+    #[test]
+    fn save_connections_moves_passwords_to_secret_store_and_redacts_file() {
+        let path = temp_connections_file("save-redacts");
+        let store = MemorySecretStore::default();
+        let mut config = connection("main", "db-secret", "ssh-secret");
+        config.transport_layers = vec![TransportLayerConfig::Ssh(ssh_hop("hop-1", "hop-secret", "hop-key"))];
+        config.redis_sentinel_password = "sentinel-secret".to_string();
+        let configs = vec![config];
+
+        save_connections_to_file(&path, &configs, &store).unwrap();
+
+        assert_eq!(store.get_existing("main", MAIN_PASSWORD_KEY).as_deref(), Some("db-secret"));
+        assert_eq!(store.get_existing("main", "transport_layers.hop-1.ssh_password").as_deref(), Some("hop-secret"));
+        assert_eq!(store.get_existing("main", "transport_layers.hop-1.ssh_key_passphrase").as_deref(), Some("hop-key"));
+        assert_eq!(store.get_existing("main", REDIS_SENTINEL_PASSWORD_KEY).as_deref(), Some("sentinel-secret"));
+        let persisted = read_configs(&path);
+        assert_eq!(persisted[0].password, "");
+        match &persisted[0].transport_layers[0] {
+            TransportLayerConfig::Ssh(ssh) => {
+                assert_eq!(ssh.password, "");
+                assert_eq!(ssh.key_passphrase, "");
+            }
+            _ => panic!("expected ssh layer"),
+        }
+        assert_eq!(persisted[0].redis_sentinel_password, "");
+    }
+
+    #[test]
+    fn load_connections_restores_passwords_from_secret_store() {
+        let path = temp_connections_file("load-restores");
+        let store = MemorySecretStore::default();
+        store.set_existing("main", MAIN_PASSWORD_KEY, "db-secret");
+        store.set_existing("main", SSH_PASSWORD_KEY, "ssh-secret");
+        store.set_existing("main", "ssh_tunnels.hop-1.password", "hop-secret");
+        store.set_existing("main", "ssh_tunnels.hop-1.key_passphrase", "hop-key");
+        store.set_existing("main", REDIS_SENTINEL_PASSWORD_KEY, "sentinel-secret");
+        let mut sanitized_config = connection("main", "", "");
+        sanitized_config.transport_layers = vec![TransportLayerConfig::Ssh(ssh_hop("hop-1", "", ""))];
+        let sanitized = vec![sanitized_config];
+        std::fs::write(&path, serde_json::to_string_pretty(&sanitized).unwrap()).unwrap();
+
+        let loaded = load_connections_from_file(&path, &store).unwrap();
+
+        assert_eq!(loaded[0].password, "db-secret");
+        match &loaded[0].transport_layers[0] {
+            TransportLayerConfig::Ssh(ssh) => {
+                assert_eq!(ssh.password, "hop-secret");
+                assert_eq!(ssh.key_passphrase, "hop-key");
+            }
+            _ => panic!("expected ssh layer"),
+        }
+        assert_eq!(loaded[0].redis_sentinel_password, "sentinel-secret");
+    }
+
+    #[test]
+    fn save_and_load_connections_move_http_tunnel_token_to_secret_store() {
+        let path = temp_connections_file("http-tunnel-token");
+        let store = MemorySecretStore::default();
+        let mut config = connection("main", "", "");
+        config.transport_layers = vec![http_tunnel("http", "tunnel-secret")];
+
+        save_connections_to_file(&path, &[config], &store).unwrap();
+
+        assert_eq!(
+            store.get_existing("main", "transport_layers.http.http_tunnel_token").as_deref(),
+            Some("tunnel-secret")
+        );
+        let persisted = read_configs(&path);
+        match &persisted[0].transport_layers[0] {
+            TransportLayerConfig::HttpTunnel(http) => assert_eq!(http.token, ""),
+            _ => panic!("expected http tunnel layer"),
+        }
+
+        let loaded = load_connections_from_file(&path, &store).unwrap();
+        match &loaded[0].transport_layers[0] {
+            TransportLayerConfig::HttpTunnel(http) => assert_eq!(http.token, "tunnel-secret"),
+            _ => panic!("expected http tunnel layer"),
+        }
+    }
+
+    #[test]
+    fn load_connections_migrates_plaintext_passwords_and_rewrites_sanitized_file() {
+        let path = temp_connections_file("migrates-plaintext");
+        let store = MemorySecretStore::default();
+        let legacy = serde_json::json!([{
+            "id": "legacy",
+            "name": "legacy connection",
+            "db_type": "postgres",
+            "host": "localhost",
+            "port": 5432,
+            "username": "postgres",
+            "password": "plain-db",
+            "database": "postgres",
+            "ssh_enabled": true,
+            "ssh_host": "bastion",
+            "ssh_port": 22,
+            "ssh_user": "user",
+            "ssh_password": "plain-ssh"
+        }]);
+        std::fs::write(&path, serde_json::to_string_pretty(&legacy).unwrap()).unwrap();
+
+        let loaded = load_connections_from_file(&path, &store).unwrap();
+
+        assert_eq!(loaded[0].password, "plain-db");
+        match &loaded[0].transport_layers[0] {
+            TransportLayerConfig::Ssh(ssh) => assert_eq!(ssh.password, "plain-ssh"),
+            _ => panic!("expected ssh layer"),
+        }
+        assert_eq!(store.get_existing("legacy", MAIN_PASSWORD_KEY).as_deref(), Some("plain-db"));
+        assert_eq!(store.get_existing("legacy", "transport_layers.legacy.ssh_password").as_deref(), Some("plain-ssh"));
+        let persisted = read_configs(&path);
+        assert_eq!(persisted[0].password, "");
+        match &persisted[0].transport_layers[0] {
+            TransportLayerConfig::Ssh(ssh) => assert_eq!(ssh.password, ""),
+            _ => panic!("expected ssh layer"),
+        }
+    }
+
+    #[test]
+    fn save_connections_deletes_secrets_for_removed_connections() {
+        let path = temp_connections_file("deletes-removed");
+        let store = MemorySecretStore::default();
+        let previous = vec![connection("old", "", ""), connection("kept", "", "")];
+        std::fs::write(&path, serde_json::to_string_pretty(&previous).unwrap()).unwrap();
+        store.set_existing("old", MAIN_PASSWORD_KEY, "old-db");
+        store.set_existing("old", SSH_PASSWORD_KEY, "old-ssh");
+        store.set_existing("kept", MAIN_PASSWORD_KEY, "kept-db");
+
+        save_connections_to_file(&path, &[connection("kept", "new-db", "")], &store).unwrap();
+
+        assert!(store.was_deleted("old", MAIN_PASSWORD_KEY));
+        assert!(store.was_deleted("old", SSH_PASSWORD_KEY));
+        assert_eq!(store.get_existing("kept", MAIN_PASSWORD_KEY).as_deref(), Some("new-db"));
+    }
+
+    #[test]
+    fn save_connections_moves_connection_string_to_secret_store_and_restores_it() {
+        let path = temp_connections_file("connection-string");
+        let store = MemorySecretStore::default();
+        let mut config = connection("mongo", "", "");
+        config.db_type = DatabaseType::MongoDb;
+        config.connection_string = Some("mongodb://user:secret@localhost/app".to_string());
+
+        save_connections_to_file(&path, &[config], &store).unwrap();
+
+        assert_eq!(
+            store.get_existing("mongo", CONNECTION_STRING_KEY).as_deref(),
+            Some("mongodb://user:secret@localhost/app")
+        );
+        let persisted = read_configs(&path);
+        assert_eq!(persisted[0].connection_string, None);
+
+        let loaded = load_connections_from_file(&path, &store).unwrap();
+        assert_eq!(loaded[0].connection_string.as_deref(), Some("mongodb://user:secret@localhost/app"));
+    }
+
+    #[test]
+    fn save_connections_moves_mq_auth_secrets_to_secret_store_and_restores_them() {
+        let path = temp_connections_file("mq-auth");
+        let store = MemorySecretStore::default();
+        let mut config = connection("pulsar", "", "");
+        config.db_type = DatabaseType::MessageQueue;
+        config.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "http://localhost:8080",
+            "auth": {
+                "kind": "token",
+                "token": "mq-token-secret"
+            }
+        }));
+
+        save_connections_to_file(&path, &[config], &store).unwrap();
+
+        assert_eq!(store.get_existing("pulsar", "mq.auth.token").as_deref(), Some("mq-token-secret"));
+        let persisted_json = std::fs::read_to_string(&path).unwrap();
+        assert!(!persisted_json.contains("mq-token-secret"));
+
+        let loaded = load_connections_from_file(&path, &store).unwrap();
+        let auth = loaded[0].external_config.as_ref().and_then(|value| value.get("auth")).expect("restored MQ auth");
+        assert_eq!(auth.get("token").and_then(serde_json::Value::as_str), Some("mq-token-secret"));
+    }
+
+    #[test]
+    fn save_connections_moves_mq_basic_and_oauth_secrets_to_secret_store_and_restores_them() {
+        let path = temp_connections_file("mq-auth-multiple");
+        let store = MemorySecretStore::default();
+        let mut basic = connection("basic", "", "");
+        basic.db_type = DatabaseType::MessageQueue;
+        basic.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "http://localhost:8080",
+            "auth": {
+                "kind": "basic",
+                "username": "admin",
+                "password": "basic-secret"
+            }
+        }));
+        let mut oauth = connection("oauth", "", "");
+        oauth.db_type = DatabaseType::MessageQueue;
+        oauth.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "http://localhost:8080",
+            "auth": {
+                "kind": "oauth2",
+                "issuerUrl": "https://issuer/token",
+                "clientId": "client",
+                "clientSecret": "oauth-secret"
+            }
+        }));
+
+        save_connections_to_file(&path, &[basic, oauth], &store).unwrap();
+
+        assert_eq!(store.get_existing("basic", "mq.auth.password").as_deref(), Some("basic-secret"));
+        assert_eq!(store.get_existing("oauth", "mq.auth.client_secret").as_deref(), Some("oauth-secret"));
+        let persisted_json = std::fs::read_to_string(&path).unwrap();
+        assert!(!persisted_json.contains("basic-secret"));
+        assert!(!persisted_json.contains("oauth-secret"));
+
+        let loaded = load_connections_from_file(&path, &store).unwrap();
+        let basic_auth = loaded[0].external_config.as_ref().and_then(|value| value.get("auth")).unwrap();
+        let oauth_auth = loaded[1].external_config.as_ref().and_then(|value| value.get("auth")).unwrap();
+        assert_eq!(basic_auth.get("password").and_then(serde_json::Value::as_str), Some("basic-secret"));
+        assert_eq!(oauth_auth.get("clientSecret").and_then(serde_json::Value::as_str), Some("oauth-secret"));
+    }
+
+    #[test]
+    fn save_connections_preserves_existing_mq_secret_when_config_is_sanitized() {
+        let path = temp_connections_file("mq-auth-preserve");
+        let store = MemorySecretStore::default();
+        store.set_existing("pulsar", "mq.auth.token", "existing-token");
+        let mut config = connection("pulsar", "", "");
+        config.db_type = DatabaseType::MessageQueue;
+        config.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "http://localhost:8080",
+            "auth": {
+                "kind": "token",
+                "token": ""
+            }
+        }));
+
+        save_connections_to_file(&path, &[config], &store).unwrap();
+
+        assert_eq!(store.get_existing("pulsar", "mq.auth.token").as_deref(), Some("existing-token"));
+        let loaded = load_connections_from_file(&path, &store).unwrap();
+        let auth = loaded[0].external_config.as_ref().and_then(|value| value.get("auth")).unwrap();
+        assert_eq!(auth.get("token").and_then(serde_json::Value::as_str), Some("existing-token"));
+    }
+
+    #[test]
+    fn save_connections_deletes_stale_mq_auth_secrets_when_kind_changes() {
+        let path = temp_connections_file("mq-auth-kind-change");
+        let store = MemorySecretStore::default();
+        store.set_existing("pulsar", MQ_AUTH_TOKEN_KEY, "old-token");
+        let mut config = connection("pulsar", "", "");
+        config.db_type = DatabaseType::MessageQueue;
+        config.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "http://localhost:8080",
+            "auth": {
+                "kind": "basic",
+                "username": "admin",
+                "password": "basic-secret"
+            }
+        }));
+
+        save_connections_to_file(&path, &[config], &store).unwrap();
+
+        assert_eq!(store.get_existing("pulsar", MQ_AUTH_TOKEN_KEY), None);
+        assert_eq!(store.get_existing("pulsar", MQ_AUTH_PASSWORD_KEY).as_deref(), Some("basic-secret"));
+    }
+
+    #[test]
+    fn save_connections_moves_mq_token_signing_key_to_secret_store_and_restores_it() {
+        let path = temp_connections_file("mq-token-signing");
+        let store = MemorySecretStore::default();
+        let mut config = connection("pulsar", "", "");
+        config.db_type = DatabaseType::MessageQueue;
+        config.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "http://localhost:8080",
+            "auth": { "kind": "none" },
+            "tokenSigning": {
+                "algorithm": "hs256",
+                "key": "broker-signing-secret"
+            }
+        }));
+
+        save_connections_to_file(&path, &[config], &store).unwrap();
+
+        assert_eq!(store.get_existing("pulsar", MQ_TOKEN_SIGNING_KEY).as_deref(), Some("broker-signing-secret"));
+        let persisted_json = std::fs::read_to_string(&path).unwrap();
+        assert!(!persisted_json.contains("broker-signing-secret"));
+
+        let loaded = load_connections_from_file(&path, &store).unwrap();
+        let signing = loaded[0].external_config.as_ref().and_then(|value| value.get("tokenSigning")).unwrap();
+        assert_eq!(signing.get("key").and_then(serde_json::Value::as_str), Some("broker-signing-secret"));
+    }
+}
diff --git a/crates/dbx-core/src/csv_export.rs b/crates/dbx-core/src/csv_export.rs
new file mode 100644
index 0000000..21b6f7b
--- /dev/null
+++ b/crates/dbx-core/src/csv_export.rs
@@ -0,0 +1,201 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::fs::File;
+use std::io::{BufWriter, Write};
+
+use crate::connection::AppState;
+use crate::models::connection::DatabaseType;
+use crate::query::{execute_sql_statement_with_options, QueryExecutionOptions};
+use crate::sql_dialect::{build_table_data_select_sql, TableDataSelectSqlOptions};
+
+const TABLE_DATA_EXPORT_PAGE_SIZE: usize = 10_000;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableCsvExportOptions {
+    pub file_path: String,
+    pub connection_id: String,
+    pub database: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub table_name: String,
+    #[serde(default)]
+    pub columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub page_size: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout_secs: Option<u64>,
+}
+
+pub(crate) fn escape_csv(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+pub(crate) fn value_to_csv_text(value: &Value) -> String {
+    match value {
+        Value::Null => String::new(),
+        Value::Bool(v) => v.to_string(),
+        Value::Number(v) => v.to_string(),
+        Value::String(v) => v.clone(),
+        other => other.to_string(),
+    }
+}
+
+pub(crate) fn value_to_query_result_csv_text(value: &Value) -> String {
+    match value {
+        Value::Null => "NULL".to_string(),
+        other => value_to_csv_text(other),
+    }
+}
+
+/// Format query-result rows as CSV text without a header row, using the
+/// query-result NULL semantics (NULL → "NULL"). Used by the streaming
+/// query-result export for batches after the first.
+pub fn format_query_result_csv_rows(rows: &[Vec<Value>]) -> String {
+    rows.iter()
+        .map(|row| {
+            row.iter().map(|cell| escape_csv(&value_to_query_result_csv_text(cell))).collect::<Vec<_>>().join(",")
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn format_csv_with_value_formatter(
+    columns: &[String],
+    rows: &[Vec<Value>],
+    value_formatter: fn(&Value) -> String,
+) -> String {
+    let header = columns.iter().map(|col| escape_csv(col)).collect::<Vec<_>>().join(",");
+    let body = rows
+        .iter()
+        .map(|row| row.iter().map(|cell| escape_csv(&value_formatter(cell))).collect::<Vec<_>>().join(","))
+        .collect::<Vec<_>>()
+        .join("\n");
+    format!("{header}\n{body}")
+}
+
+pub fn format_csv(columns: &[String], rows: &[Vec<Value>]) -> String {
+    format_csv_with_value_formatter(columns, rows, value_to_csv_text)
+}
+
+pub fn format_query_result_csv(columns: &[String], rows: &[Vec<Value>]) -> String {
+    format_csv_with_value_formatter(columns, rows, value_to_query_result_csv_text)
+}
+
+fn write_csv_row(writer: &mut impl Write, values: impl IntoIterator<Item = String>) -> Result<(), String> {
+    let mut first = true;
+    for value in values {
+        if !first {
+            writer.write_all(b",").map_err(|err| err.to_string())?;
+        }
+        first = false;
+        writer.write_all(escape_csv(&value).as_bytes()).map_err(|err| err.to_string())?;
+    }
+    Ok(())
+}
+
+async fn connection_database_type(state: &AppState, connection_id: &str) -> Result<DatabaseType, String> {
+    state
+        .configs
+        .read()
+        .await
+        .get(connection_id)
+        .map(|config| config.db_type)
+        .ok_or_else(|| format!("Connection config not found: {connection_id}"))
+}
+
+pub async fn export_table_data_csv_core(state: &AppState, options: TableCsvExportOptions) -> Result<u64, String> {
+    let database_type = connection_database_type(state, &options.connection_id).await?;
+    let page_size = options.page_size.unwrap_or(TABLE_DATA_EXPORT_PAGE_SIZE).max(1);
+    let mut writer =
+        BufWriter::new(File::create(&options.file_path).map_err(|err| format!("Failed to write CSV file: {err}"))?);
+    writer.write_all("\u{FEFF}".as_bytes()).map_err(|err| err.to_string())?;
+
+    let mut offset = 0usize;
+    let mut rows_exported = 0u64;
+    let mut wrote_header = false;
+
+    loop {
+        let sql = build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(database_type),
+            schema: options.schema.clone(),
+            table_name: options.table_name.clone(),
+            table_type: None,
+            primary_keys: Vec::new(),
+            columns: options.columns.clone(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(page_size),
+            offset: Some(offset),
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        });
+        let result = execute_sql_statement_with_options(
+            state,
+            &options.connection_id,
+            &options.database,
+            &sql,
+            options.schema.as_deref(),
+            None,
+            QueryExecutionOptions {
+                max_rows: Some(page_size),
+                timeout_secs: options.timeout_secs,
+                ..Default::default()
+            },
+        )
+        .await?;
+
+        if !wrote_header {
+            write_csv_row(&mut writer, result.columns)?;
+            wrote_header = true;
+        }
+
+        let fetched = result.rows.len();
+        if fetched == 0 {
+            break;
+        }
+        for row in result.rows {
+            writer.write_all(b"\n").map_err(|err| err.to_string())?;
+            write_csv_row(&mut writer, row.iter().map(value_to_csv_text))?;
+        }
+
+        rows_exported += fetched as u64;
+        if fetched < page_size {
+            break;
+        }
+        offset += fetched;
+    }
+
+    if rows_exported == 0 {
+        writer.write_all(b"\n").map_err(|err| err.to_string())?;
+    }
+    writer.flush().map_err(|err| err.to_string())?;
+    Ok(rows_exported)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{format_csv, format_query_result_csv};
+    use serde_json::json;
+
+    #[test]
+    fn formats_csv_with_header_and_escaped_values() {
+        let out = format_csv(&["id".to_string(), "name".to_string()], &[vec![json!(1), json!("Ada \"Lovelace\"")]]);
+        assert_eq!(out, "\"id\",\"name\"\n\"1\",\"Ada \"\"Lovelace\"\"\"");
+    }
+
+    #[test]
+    fn formats_null_as_empty_cell() {
+        let out = format_csv(&["id".to_string(), "note".to_string()], &[vec![json!(1), Value::Null]]);
+        assert_eq!(out, "\"id\",\"note\"\n\"1\",\"\"");
+    }
+
+    #[test]
+    fn formats_query_result_null_as_null_text() {
+        let out = format_query_result_csv(&["id".to_string(), "note".to_string()], &[vec![json!(1), Value::Null]]);
+        assert_eq!(out, "\"id\",\"note\"\n\"1\",\"NULL\"");
+    }
+
+    use serde_json::Value;
+}
diff --git a/crates/dbx-core/src/data_compare.rs b/crates/dbx-core/src/data_compare.rs
new file mode 100644
index 0000000..f38cd61
--- /dev/null
+++ b/crates/dbx-core/src/data_compare.rs
@@ -0,0 +1,1541 @@
+use std::collections::{HashMap, HashSet};
+
+use rayon::prelude::*;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use crate::connection::AppState;
+use crate::data_grid_sql::{format_grid_sql_literal as format_data_grid_sql_literal, DataGridColumnInfo};
+use crate::models::connection::DatabaseType;
+use crate::query::{execute_sql_statement_with_options, QueryExecutionOptions};
+use crate::schema::get_columns_core;
+use crate::sql_dialect::{
+    build_count_table_sql, firebird_rows_clause, pagination_strategy, qualified_table_name, quote_table_identifier,
+    PaginationContext, TablePaginationStrategy,
+};
+use crate::transfer::{generate_comment_ddl, generate_create_table_ddl};
+
+const DATA_SYNC_INSERT_BATCH_SIZE: usize = 500;
+const DATA_SYNC_CONDITION_BATCH_SIZE: usize = 200;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CompareDataRowsOptions {
+    pub columns: Vec<String>,
+    pub key_columns: Vec<String>,
+    #[serde(default)]
+    pub source_rows: Vec<Vec<Value>>,
+    #[serde(default)]
+    pub target_rows: Vec<Vec<Value>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataComparePreparationOptions {
+    pub table_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub columns: Vec<String>,
+    pub key_columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub column_info: Vec<DataGridColumnInfo>,
+    #[serde(default)]
+    pub source_rows: Vec<Vec<Value>>,
+    #[serde(default)]
+    pub target_rows: Vec<Vec<Value>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataCompareFromTablesOptions {
+    pub source_connection_id: String,
+    pub source_database: String,
+    pub source_schema: String,
+    pub source_table: String,
+    pub target_connection_id: String,
+    pub target_database: String,
+    pub target_schema: String,
+    pub target_table: String,
+    pub columns: Vec<String>,
+    pub key_columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub fetch_batch_size: Option<usize>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataCompareMissingTargetOptions {
+    pub source_connection_id: String,
+    pub source_database: String,
+    pub source_schema: String,
+    pub source_table: String,
+    pub target_connection_id: String,
+    pub target_database: String,
+    pub target_schema: String,
+    pub target_table: String,
+    #[serde(default)]
+    pub key_columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub fetch_batch_size: Option<usize>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataCompareChangedCell {
+    pub column: String,
+    pub source: Value,
+    pub target: Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataCompareRow {
+    pub key: String,
+    pub key_values: HashMap<String, Value>,
+    pub values: HashMap<String, Value>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataCompareModifiedRow {
+    pub key: String,
+    pub key_values: HashMap<String, Value>,
+    pub source_values: HashMap<String, Value>,
+    pub target_values: HashMap<String, Value>,
+    pub changes: Vec<DataCompareChangedCell>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataCompareResult {
+    pub added: Vec<DataCompareRow>,
+    pub removed: Vec<DataCompareRow>,
+    pub modified: Vec<DataCompareModifiedRow>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataComparePreparation {
+    pub result: DataCompareResult,
+    pub sync_statements: Vec<String>,
+    pub sync_sql: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataCompareSyncPlanTableOptions {
+    pub table_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub columns: Vec<String>,
+    pub key_columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub column_info: Vec<DataGridColumnInfo>,
+    pub diff: DataCompareResult,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub pre_sync_statements: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataCompareSyncPlanOptions {
+    #[serde(default)]
+    pub tables: Vec<DataCompareSyncPlanTableOptions>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataCompareSyncPlan {
+    pub insert_count: usize,
+    pub update_count: usize,
+    pub delete_count: usize,
+    pub statement_count: usize,
+    pub sync_statements: Vec<String>,
+    pub sync_sql: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataCompareFromTablesPreparation {
+    pub result: DataCompareResult,
+    pub sync_statements: Vec<String>,
+    pub sync_sql: String,
+    #[serde(default)]
+    pub pre_sync_statements: Vec<String>,
+    pub source_row_count: u64,
+    pub target_row_count: u64,
+    pub source_truncated: bool,
+    pub target_truncated: bool,
+}
+
+pub fn prepare_data_compare(options: DataComparePreparationOptions) -> Result<DataComparePreparation, String> {
+    let DataComparePreparationOptions {
+        table_name,
+        schema,
+        columns,
+        key_columns,
+        column_info,
+        source_rows,
+        target_rows,
+        database_type,
+    } = options;
+    let result = compare_data_rows(CompareDataRowsOptions {
+        columns: columns.clone(),
+        key_columns: key_columns.clone(),
+        source_rows,
+        target_rows,
+    })?;
+    let sync_plan = build_data_compare_sync_plan_from_refs(&[DataCompareSyncPlanTableRef {
+        table_name: &table_name,
+        schema: schema.as_deref(),
+        columns: &columns,
+        key_columns: &key_columns,
+        column_info: &column_info,
+        diff: &result,
+        database_type,
+        pre_sync_statements: &[],
+    }]);
+    Ok(DataComparePreparation { result, sync_statements: sync_plan.sync_statements, sync_sql: sync_plan.sync_sql })
+}
+
+pub async fn prepare_data_compare_from_tables(
+    state: &AppState,
+    options: DataCompareFromTablesOptions,
+) -> Result<DataCompareFromTablesPreparation, String> {
+    let source_database_type = connection_database_type(state, &options.source_connection_id).await?;
+    let target_database_type = connection_database_type(state, &options.target_connection_id).await?;
+    let fetch_batch_size = options.fetch_batch_size.unwrap_or(1000).max(1);
+
+    let source_count_sql =
+        build_count_table_sql(Some(source_database_type), Some(&options.source_schema), &options.source_table);
+    let target_count_sql =
+        build_count_table_sql(Some(target_database_type), Some(&options.target_schema), &options.target_table);
+
+    let (source_count_result, target_count_result) = tokio::try_join!(
+        execute_sql_statement_with_options(
+            state,
+            &options.source_connection_id,
+            &options.source_database,
+            &source_count_sql,
+            Some(&options.source_schema),
+            None,
+            QueryExecutionOptions { max_rows: Some(1), ..Default::default() },
+        ),
+        execute_sql_statement_with_options(
+            state,
+            &options.target_connection_id,
+            &options.target_database,
+            &target_count_sql,
+            Some(&options.target_schema),
+            None,
+            QueryExecutionOptions { max_rows: Some(1), ..Default::default() },
+        )
+    )?;
+    let source_row_count = first_count(&source_count_result.rows)?;
+    let target_row_count = first_count(&target_count_result.rows)?;
+
+    let (source_rows, target_rows) = tokio::try_join!(
+        fetch_compare_rows(
+            state,
+            &options.source_connection_id,
+            &options.source_database,
+            &options.source_schema,
+            &options.source_table,
+            &options.columns,
+            &options.key_columns,
+            source_database_type,
+            fetch_batch_size,
+        ),
+        fetch_compare_rows(
+            state,
+            &options.target_connection_id,
+            &options.target_database,
+            &options.target_schema,
+            &options.target_table,
+            &options.columns,
+            &options.key_columns,
+            target_database_type,
+            fetch_batch_size,
+        )
+    )?;
+    let target_columns = get_columns_core(
+        state,
+        &options.target_connection_id,
+        &options.target_database,
+        &options.target_schema,
+        &options.target_table,
+    )
+    .await?;
+
+    let preparation = prepare_data_compare(DataComparePreparationOptions {
+        table_name: options.target_table,
+        schema: Some(options.target_schema),
+        columns: options.columns,
+        key_columns: options.key_columns,
+        column_info: target_columns.into_iter().map(data_grid_column_info).collect(),
+        source_rows,
+        target_rows,
+        database_type: Some(target_database_type),
+    })?;
+
+    Ok(DataCompareFromTablesPreparation {
+        result: preparation.result,
+        sync_statements: preparation.sync_statements,
+        sync_sql: preparation.sync_sql,
+        pre_sync_statements: Vec::new(),
+        source_row_count,
+        target_row_count,
+        source_truncated: false,
+        target_truncated: false,
+    })
+}
+
+pub async fn prepare_data_compare_missing_target(
+    state: &AppState,
+    options: DataCompareMissingTargetOptions,
+) -> Result<DataCompareFromTablesPreparation, String> {
+    let source_database_type = connection_database_type(state, &options.source_connection_id).await?;
+    let target_database_type = connection_database_type(state, &options.target_connection_id).await?;
+    let fetch_batch_size = options.fetch_batch_size.unwrap_or(1000).max(1);
+    let source_columns = get_columns_core(
+        state,
+        &options.source_connection_id,
+        &options.source_database,
+        &options.source_schema,
+        &options.source_table,
+    )
+    .await?;
+    let column_names = source_columns.iter().map(|column| column.name.clone()).collect::<Vec<_>>();
+
+    let source_count_sql =
+        build_count_table_sql(Some(source_database_type), Some(&options.source_schema), &options.source_table);
+    let source_count_result = execute_sql_statement_with_options(
+        state,
+        &options.source_connection_id,
+        &options.source_database,
+        &source_count_sql,
+        Some(&options.source_schema),
+        None,
+        QueryExecutionOptions { max_rows: Some(1), ..Default::default() },
+    )
+    .await?;
+    let source_row_count = first_count(&source_count_result.rows)?;
+    let source_rows = fetch_compare_rows(
+        state,
+        &options.source_connection_id,
+        &options.source_database,
+        &options.source_schema,
+        &options.source_table,
+        &column_names,
+        &options.key_columns,
+        source_database_type,
+        fetch_batch_size,
+    )
+    .await?;
+    let result = missing_target_diff(&column_names, &options.key_columns, source_rows);
+    let mut pre_sync_statements = Vec::new();
+    pre_sync_statements.push(format!(
+        "{};",
+        generate_create_table_ddl(
+            &source_columns,
+            &options.target_table,
+            &options.source_schema,
+            &options.target_schema,
+            &target_database_type,
+            &source_database_type,
+            None,
+        )
+    ));
+    pre_sync_statements.extend(
+        generate_comment_ddl(
+            &source_columns,
+            &options.target_table,
+            &options.target_schema,
+            &target_database_type,
+            None,
+        )
+        .into_iter()
+        .map(|statement| format!("{statement};")),
+    );
+
+    let column_info = source_columns.iter().cloned().map(data_grid_column_info).collect::<Vec<_>>();
+    let sync_plan = build_data_compare_sync_plan_from_refs(&[DataCompareSyncPlanTableRef {
+        table_name: &options.target_table,
+        schema: Some(&options.target_schema),
+        columns: &column_names,
+        key_columns: &options.key_columns,
+        column_info: &column_info,
+        diff: &result,
+        database_type: Some(target_database_type),
+        pre_sync_statements: &pre_sync_statements,
+    }]);
+
+    Ok(DataCompareFromTablesPreparation {
+        result,
+        sync_statements: sync_plan.sync_statements,
+        sync_sql: sync_plan.sync_sql,
+        pre_sync_statements,
+        source_row_count,
+        target_row_count: 0,
+        source_truncated: false,
+        target_truncated: false,
+    })
+}
+
+pub fn build_data_compare_sync_plan(options: DataCompareSyncPlanOptions) -> DataCompareSyncPlan {
+    let tables = options
+        .tables
+        .iter()
+        .map(|table| DataCompareSyncPlanTableRef {
+            table_name: &table.table_name,
+            schema: table.schema.as_deref(),
+            columns: &table.columns,
+            key_columns: &table.key_columns,
+            column_info: &table.column_info,
+            diff: &table.diff,
+            database_type: table.database_type,
+            pre_sync_statements: &table.pre_sync_statements,
+        })
+        .collect::<Vec<_>>();
+    build_data_compare_sync_plan_from_refs(&tables)
+}
+
+#[derive(Debug, Clone, Copy)]
+struct DataCompareSyncPlanTableRef<'a> {
+    table_name: &'a str,
+    schema: Option<&'a str>,
+    columns: &'a [String],
+    key_columns: &'a [String],
+    column_info: &'a [DataGridColumnInfo],
+    diff: &'a DataCompareResult,
+    database_type: Option<DatabaseType>,
+    pre_sync_statements: &'a [String],
+}
+
+fn build_data_compare_sync_plan_from_refs(tables: &[DataCompareSyncPlanTableRef<'_>]) -> DataCompareSyncPlan {
+    let mut sync_statements = Vec::new();
+    let mut insert_count = 0;
+    let mut update_count = 0;
+    let mut delete_count = 0;
+
+    for table in tables {
+        insert_count += table.diff.added.len();
+        update_count += table.diff.modified.len();
+        delete_count += table.diff.removed.len();
+        sync_statements.extend(table.pre_sync_statements.iter().cloned());
+        sync_statements.extend(generate_data_sync_statements(&GenerateDataSyncSqlOptions {
+            table_name: table.table_name,
+            schema: table.schema,
+            columns: table.columns,
+            key_columns: table.key_columns,
+            column_info: table.column_info,
+            diff: table.diff,
+            database_type: table.database_type,
+        }));
+    }
+
+    let statement_count = sync_statements.len();
+    let sync_sql = sync_statements.join("\n");
+    DataCompareSyncPlan { insert_count, update_count, delete_count, statement_count, sync_statements, sync_sql }
+}
+
+fn missing_target_diff(columns: &[String], key_columns: &[String], source_rows: Vec<Vec<Value>>) -> DataCompareResult {
+    let added = source_rows
+        .into_iter()
+        .enumerate()
+        .map(|(index, row)| {
+            let values = row_object_owned(columns, row);
+            let key = if key_columns.is_empty() { index.to_string() } else { key_for(&values, key_columns) };
+            DataCompareRow { key, key_values: key_values(&values, key_columns), values }
+        })
+        .collect();
+
+    DataCompareResult { added, removed: Vec::new(), modified: Vec::new() }
+}
+
+pub fn compare_data_rows(options: CompareDataRowsOptions) -> Result<DataCompareResult, String> {
+    if options.key_columns.is_empty() {
+        return Err("At least one key column is required for data comparison".to_string());
+    }
+
+    let column_indexes = column_index_map(&options.columns);
+    let (source, source_order) =
+        collect_compare_rows(&options.columns, &options.key_columns, &column_indexes, options.source_rows, "source")?;
+    let (target, target_order) =
+        collect_compare_rows(&options.columns, &options.key_columns, &column_indexes, options.target_rows, "target")?;
+    let key_columns: HashSet<&str> = options.key_columns.iter().map(String::as_str).collect();
+
+    let mut added = Vec::new();
+    let mut modified = Vec::new();
+
+    for key in &source_order {
+        let source_values = source.get(key).expect("source key should exist");
+        let Some(target_values) = target.get(key) else {
+            added.push(DataCompareRow {
+                key: key.clone(),
+                key_values: key_values_for_row(source_values, &options.key_columns, &column_indexes),
+                values: row_object(&options.columns, source_values),
+            });
+            continue;
+        };
+
+        let changes = options
+            .columns
+            .iter()
+            .filter(|column| !key_columns.contains(column.as_str()))
+            .filter_map(|column| {
+                let index = column_indexes.get(column.as_str()).copied()?;
+                let source_value = row_value(source_values, index);
+                let target_value = row_value(target_values, index);
+                (source_value != target_value).then(|| DataCompareChangedCell {
+                    column: column.clone(),
+                    source: source_value.clone(),
+                    target: target_value.clone(),
+                })
+            })
+            .collect::<Vec<_>>();
+
+        if !changes.is_empty() {
+            modified.push(DataCompareModifiedRow {
+                key: key.clone(),
+                key_values: key_values_for_row(source_values, &options.key_columns, &column_indexes),
+                source_values: row_object(&options.columns, source_values),
+                target_values: row_object(&options.columns, target_values),
+                changes,
+            });
+        }
+    }
+
+    let mut removed = Vec::new();
+    for key in &target_order {
+        if let Some(target_values) = target.get(key).filter(|_| !source.contains_key(key)) {
+            removed.push(DataCompareRow {
+                key: key.clone(),
+                key_values: key_values_for_row(target_values, &options.key_columns, &column_indexes),
+                values: row_object(&options.columns, target_values),
+            });
+        }
+    }
+
+    Ok(DataCompareResult { added, removed, modified })
+}
+
+static NULL_VALUE: Value = Value::Null;
+
+type CompareRowValues = Vec<Value>;
+type CompareRowMap = HashMap<String, CompareRowValues>;
+
+fn column_index_map(columns: &[String]) -> HashMap<&str, usize> {
+    let mut indexes = HashMap::with_capacity(columns.len());
+    for (index, column) in columns.iter().enumerate() {
+        indexes.insert(column.as_str(), index);
+    }
+    indexes
+}
+
+fn collect_compare_rows(
+    columns: &[String],
+    key_columns: &[String],
+    column_indexes: &HashMap<&str, usize>,
+    rows: Vec<Vec<Value>>,
+    label: &str,
+) -> Result<(CompareRowMap, Vec<String>), String> {
+    let mut items = HashMap::with_capacity(rows.len());
+    let mut order = Vec::with_capacity(rows.len());
+
+    for row in rows {
+        let key = key_for_row(&row, key_columns, column_indexes);
+        if items.contains_key(&key) {
+            return Err(format!("Duplicate {label} key: {key}"));
+        }
+        order.push(key.clone());
+        items.insert(key, normalize_row_len(row, columns.len()));
+    }
+
+    Ok((items, order))
+}
+
+#[derive(Debug, Clone, Copy)]
+struct GenerateDataSyncSqlOptions<'a> {
+    table_name: &'a str,
+    schema: Option<&'a str>,
+    columns: &'a [String],
+    key_columns: &'a [String],
+    column_info: &'a [DataGridColumnInfo],
+    diff: &'a DataCompareResult,
+    database_type: Option<DatabaseType>,
+}
+
+fn row_object(columns: &[String], row: &[Value]) -> HashMap<String, Value> {
+    columns
+        .iter()
+        .enumerate()
+        .map(|(index, column)| (column.clone(), row.get(index).cloned().unwrap_or(Value::Null)))
+        .collect()
+}
+
+fn row_object_owned(columns: &[String], row: Vec<Value>) -> HashMap<String, Value> {
+    let mut values = HashMap::with_capacity(columns.len());
+    let mut row_values = row.into_iter();
+    for column in columns {
+        values.insert(column.clone(), row_values.next().unwrap_or(Value::Null));
+    }
+    values
+}
+
+fn key_for(row: &HashMap<String, Value>, key_columns: &[String]) -> String {
+    key_columns.iter().map(|column| json_stringify(&value_for(row, column))).collect::<Vec<_>>().join("\u{001f}")
+}
+
+fn key_for_row(row: &[Value], key_columns: &[String], column_indexes: &HashMap<&str, usize>) -> String {
+    key_columns
+        .iter()
+        .map(|column| {
+            column_indexes
+                .get(column.as_str())
+                .map(|index| json_stringify(row_value(row, *index)))
+                .unwrap_or_else(|| json_stringify(&NULL_VALUE))
+        })
+        .collect::<Vec<_>>()
+        .join("\u{001f}")
+}
+
+fn key_values(row: &HashMap<String, Value>, key_columns: &[String]) -> HashMap<String, Value> {
+    key_columns.iter().map(|column| (column.clone(), value_for(row, column))).collect()
+}
+
+fn key_values_for_row(
+    row: &[Value],
+    key_columns: &[String],
+    column_indexes: &HashMap<&str, usize>,
+) -> HashMap<String, Value> {
+    key_columns
+        .iter()
+        .map(|column| {
+            let value =
+                column_indexes.get(column.as_str()).map(|index| row_value(row, *index).clone()).unwrap_or(Value::Null);
+            (column.clone(), value)
+        })
+        .collect()
+}
+
+fn value_for(row: &HashMap<String, Value>, column: &str) -> Value {
+    row.get(column).cloned().unwrap_or(Value::Null)
+}
+
+fn row_value(row: &[Value], index: usize) -> &Value {
+    row.get(index).unwrap_or(&NULL_VALUE)
+}
+
+fn normalize_row_len(mut row: Vec<Value>, column_len: usize) -> Vec<Value> {
+    if row.len() < column_len {
+        row.resize(column_len, Value::Null);
+    }
+    row
+}
+
+fn json_stringify(value: &Value) -> String {
+    serde_json::to_string(value).unwrap_or_else(|_| "null".to_string())
+}
+
+fn generate_data_sync_statements(options: &GenerateDataSyncSqlOptions<'_>) -> Vec<String> {
+    let table = qualified_table_name(options.database_type, options.schema, options.table_name);
+    let columns = options
+        .columns
+        .iter()
+        .map(|column| quote_table_identifier(options.database_type, column))
+        .collect::<Vec<_>>()
+        .join(", ");
+    let column_info = options.column_info;
+    let added = generate_insert_sync_statements(options, &table, &columns, column_info);
+    let modified = generate_update_sync_statements(options, &table, column_info);
+    let removed = generate_delete_sync_statements(options, &table, column_info);
+
+    let mut statements = Vec::with_capacity(added.len() + modified.len() + removed.len());
+    statements.extend(added);
+    statements.extend(modified);
+    statements.extend(removed);
+    statements
+}
+
+fn generate_insert_sync_statements(
+    options: &GenerateDataSyncSqlOptions<'_>,
+    table: &str,
+    columns: &str,
+    column_info: &[DataGridColumnInfo],
+) -> Vec<String> {
+    options
+        .diff
+        .added
+        .par_chunks(DATA_SYNC_INSERT_BATCH_SIZE)
+        .map(|chunk| {
+            let values = chunk
+                .iter()
+                .map(|row| {
+                    let row_values = options
+                        .columns
+                        .iter()
+                        .map(|column| {
+                            format_grid_sql_literal(
+                                row.values.get(column).unwrap_or(&Value::Null),
+                                options.database_type,
+                                column_info_for(column_info, column),
+                            )
+                        })
+                        .collect::<Vec<_>>()
+                        .join(", ");
+                    format!("({row_values})")
+                })
+                .collect::<Vec<_>>()
+                .join(", ");
+            format!("INSERT INTO {table} ({columns}) VALUES {values};")
+        })
+        .collect()
+}
+
+fn generate_update_sync_statements(
+    options: &GenerateDataSyncSqlOptions<'_>,
+    table: &str,
+    column_info: &[DataGridColumnInfo],
+) -> Vec<String> {
+    options
+        .diff
+        .modified
+        .par_chunks(DATA_SYNC_CONDITION_BATCH_SIZE)
+        .flat_map_iter(|chunk| {
+            if chunk.len() == 1 {
+                return vec![generate_single_update_statement(options, table, column_info, &chunk[0])];
+            }
+            let changed_columns = options
+                .columns
+                .iter()
+                .filter(|column| chunk.iter().any(|row| row.changes.iter().any(|change| change.column == **column)))
+                .collect::<Vec<_>>();
+            if changed_columns.is_empty() {
+                return Vec::new();
+            }
+            let assignments = changed_columns
+                .iter()
+                .map(|column| {
+                    let quoted_column = quote_table_identifier(options.database_type, column);
+                    let cases = chunk
+                        .iter()
+                        .filter_map(|row| {
+                            let change = row.changes.iter().find(|change| change.column == **column)?;
+                            Some(format!(
+                                "WHEN {} THEN {}",
+                                where_by_key(&row.key_values, options.key_columns, options.database_type, column_info),
+                                format_grid_sql_literal(
+                                    &change.source,
+                                    options.database_type,
+                                    column_info_for(column_info, column),
+                                )
+                            ))
+                        })
+                        .collect::<Vec<_>>()
+                        .join(" ");
+                    format!("{quoted_column} = CASE {cases} ELSE {quoted_column} END")
+                })
+                .collect::<Vec<_>>()
+                .join(", ");
+            let where_clause = chunk
+                .iter()
+                .map(|row| {
+                    format!(
+                        "({})",
+                        where_by_key(&row.key_values, options.key_columns, options.database_type, column_info)
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join(" OR ");
+            vec![format!("UPDATE {table} SET {assignments} WHERE {where_clause};")]
+        })
+        .collect()
+}
+
+fn generate_single_update_statement(
+    options: &GenerateDataSyncSqlOptions<'_>,
+    table: &str,
+    column_info: &[DataGridColumnInfo],
+    row: &DataCompareModifiedRow,
+) -> String {
+    let assignments = row
+        .changes
+        .iter()
+        .map(|change| {
+            format!(
+                "{} = {}",
+                quote_table_identifier(options.database_type, &change.column),
+                format_grid_sql_literal(
+                    &change.source,
+                    options.database_type,
+                    column_info_for(column_info, &change.column),
+                )
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(", ");
+    format!(
+        "UPDATE {table} SET {assignments} WHERE {};",
+        where_by_key(&row.key_values, options.key_columns, options.database_type, column_info)
+    )
+}
+
+fn generate_delete_sync_statements(
+    options: &GenerateDataSyncSqlOptions<'_>,
+    table: &str,
+    column_info: &[DataGridColumnInfo],
+) -> Vec<String> {
+    options
+        .diff
+        .removed
+        .par_chunks(DATA_SYNC_CONDITION_BATCH_SIZE)
+        .map(|chunk| {
+            if chunk.len() == 1 {
+                return format!(
+                    "DELETE FROM {table} WHERE {};",
+                    where_by_key(&chunk[0].key_values, options.key_columns, options.database_type, column_info)
+                );
+            }
+            let where_clause = chunk
+                .iter()
+                .map(|row| {
+                    format!(
+                        "({})",
+                        where_by_key(&row.key_values, options.key_columns, options.database_type, column_info)
+                    )
+                })
+                .collect::<Vec<_>>()
+                .join(" OR ");
+            format!("DELETE FROM {table} WHERE {where_clause};")
+        })
+        .collect()
+}
+
+async fn connection_database_type(state: &AppState, connection_id: &str) -> Result<DatabaseType, String> {
+    state
+        .configs
+        .read()
+        .await
+        .get(connection_id)
+        .map(|config| config.db_type)
+        .ok_or_else(|| format!("Connection config not found: {connection_id}"))
+}
+
+fn first_count(rows: &[Vec<Value>]) -> Result<u64, String> {
+    let value = rows.first().and_then(|row| row.first()).ok_or_else(|| "COUNT query returned no rows".to_string())?;
+    match value {
+        Value::Number(number) => {
+            number.as_u64().or_else(|| number.as_i64().and_then(|value| u64::try_from(value).ok()))
+        }
+        Value::String(text) => text.parse::<u64>().ok(),
+        _ => None,
+    }
+    .ok_or_else(|| format!("COUNT query returned non-numeric value: {value}"))
+}
+
+fn build_data_compare_select_sql(
+    database_type: DatabaseType,
+    schema: &str,
+    table_name: &str,
+    columns: &[String],
+    key_columns: &[String],
+    row_limit: usize,
+    offset: usize,
+) -> String {
+    let table = qualified_table_name(Some(database_type), Some(schema), table_name);
+    let select_columns = if columns.is_empty() {
+        "*".to_string()
+    } else {
+        columns.iter().map(|column| quote_table_identifier(Some(database_type), column)).collect::<Vec<_>>().join(", ")
+    };
+    let order_by = if key_columns.is_empty() {
+        String::new()
+    } else {
+        format!(
+            " ORDER BY {}",
+            key_columns
+                .iter()
+                .map(|column| format!("{} ASC", quote_table_identifier(Some(database_type), column)))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+    let order_expression = if key_columns.is_empty() {
+        "(SELECT NULL)".to_string()
+    } else {
+        key_columns
+            .iter()
+            .map(|column| format!("{} ASC", quote_table_identifier(Some(database_type), column)))
+            .collect::<Vec<_>>()
+            .join(", ")
+    };
+
+    match pagination_strategy(Some(database_type), PaginationContext::BoundedRead) {
+        TablePaginationStrategy::Db2FetchFirst | TablePaginationStrategy::FetchFirst => {
+            let offset_sql = if offset > 0 { format!(" OFFSET {offset} ROWS") } else { String::new() };
+            format!("SELECT {select_columns} FROM {table}{order_by}{offset_sql} FETCH FIRST {row_limit} ROWS ONLY")
+        }
+        TablePaginationStrategy::Rownum => build_rownum_data_compare_select_sql(
+            database_type,
+            &table,
+            &select_columns,
+            &order_by,
+            columns,
+            row_limit,
+            offset,
+        ),
+        TablePaginationStrategy::SqlServerTop => {
+            if offset == 0 {
+                return format!("SELECT TOP ({row_limit}) {select_columns} FROM {table}{order_by}");
+            }
+            let page_alias = quote_table_identifier(Some(DatabaseType::SqlServer), "dbx_page");
+            let row_number_alias = quote_table_identifier(Some(DatabaseType::SqlServer), "__dbx_row_num");
+            let end = offset + row_limit;
+            format!(
+                "WITH {page_alias} AS (SELECT {select_columns}, ROW_NUMBER() OVER (ORDER BY {order_expression}) AS {row_number_alias} FROM {table}) SELECT {select_columns} FROM {page_alias} WHERE {row_number_alias} > {offset} AND {row_number_alias} <= {end} ORDER BY {row_number_alias}"
+            )
+        }
+        TablePaginationStrategy::IrisTop => format!("SELECT TOP {row_limit} {select_columns} FROM {table}{order_by}"),
+        TablePaginationStrategy::InformixFirst => {
+            let row_limit_clause =
+                if offset > 0 { format!("SKIP {offset} FIRST {row_limit}") } else { format!("FIRST {row_limit}") };
+            format!("SELECT {row_limit_clause} {select_columns} FROM {table}{order_by}")
+        }
+        TablePaginationStrategy::FirebirdRows => {
+            let rows = firebird_rows_clause(row_limit, offset);
+            format!("SELECT {select_columns} FROM {table}{order_by} {rows}")
+        }
+        TablePaginationStrategy::AgentMaxRows => format!("SELECT {select_columns} FROM {table}{order_by};"),
+        TablePaginationStrategy::Unbounded => format!("SELECT {select_columns} FROM {table}{order_by}"),
+        TablePaginationStrategy::QuestDbLimit => {
+            if offset > 0 {
+                let upper_bound = offset + row_limit;
+                format!("SELECT {select_columns} FROM {table}{order_by} LIMIT {offset}, {upper_bound}")
+            } else {
+                format!("SELECT {select_columns} FROM {table}{order_by} LIMIT {row_limit}")
+            }
+        }
+        TablePaginationStrategy::LimitOffset => {
+            let offset_sql = if offset > 0 { format!(" OFFSET {offset}") } else { String::new() };
+            format!("SELECT {select_columns} FROM {table}{order_by} LIMIT {row_limit}{offset_sql};")
+        }
+    }
+}
+
+fn build_rownum_data_compare_select_sql(
+    database_type: DatabaseType,
+    table: &str,
+    select_columns: &str,
+    order_by: &str,
+    columns: &[String],
+    row_limit: usize,
+    offset: usize,
+) -> String {
+    let base = format!("SELECT {select_columns} FROM {table}{order_by}");
+    if offset == 0 {
+        return format!("SELECT {select_columns} FROM ({base}) WHERE ROWNUM <= {row_limit}");
+    }
+
+    let row_number_alias = quote_table_identifier(Some(database_type), "__dbx_row_num");
+    let end = offset + row_limit;
+    let outer_columns = if columns.is_empty() {
+        "*".to_string()
+    } else {
+        columns.iter().map(|column| quote_table_identifier(Some(database_type), column)).collect::<Vec<_>>().join(", ")
+    };
+    format!(
+        "SELECT {outer_columns} FROM (SELECT dbx_inner.*, ROWNUM AS {row_number_alias} FROM ({base}) dbx_inner WHERE ROWNUM <= {end}) WHERE {row_number_alias} > {offset}"
+    )
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn fetch_compare_rows(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    table_name: &str,
+    columns: &[String],
+    key_columns: &[String],
+    database_type: DatabaseType,
+    fetch_batch_size: usize,
+) -> Result<Vec<Vec<Value>>, String> {
+    let mut rows = Vec::new();
+    let mut offset = 0usize;
+
+    loop {
+        let sql = build_data_compare_select_sql(
+            database_type,
+            schema,
+            table_name,
+            columns,
+            key_columns,
+            fetch_batch_size,
+            offset,
+        );
+        let result = execute_sql_statement_with_options(
+            state,
+            connection_id,
+            database,
+            &sql,
+            Some(schema),
+            None,
+            QueryExecutionOptions { max_rows: Some(fetch_batch_size), ..Default::default() },
+        )
+        .await?;
+        let fetched = result.rows.len();
+        if fetched == 0 {
+            break;
+        }
+        rows.extend(result.rows);
+        if fetched < fetch_batch_size {
+            break;
+        }
+        offset += fetched;
+    }
+
+    Ok(rows)
+}
+
+fn where_by_key(
+    key_values: &HashMap<String, Value>,
+    key_columns: &[String],
+    database_type: Option<DatabaseType>,
+    column_info: &[DataGridColumnInfo],
+) -> String {
+    key_columns
+        .iter()
+        .map(|column| {
+            format!(
+                "{} = {}",
+                quote_table_identifier(database_type, column),
+                format_grid_sql_literal(
+                    key_values.get(column).unwrap_or(&Value::Null),
+                    database_type,
+                    column_info_for(column_info, column),
+                )
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(" AND ")
+}
+
+fn format_grid_sql_literal(
+    value: &Value,
+    database_type: Option<DatabaseType>,
+    column_info: Option<&DataGridColumnInfo>,
+) -> String {
+    format_data_grid_sql_literal(value, database_type, column_info)
+}
+
+fn column_info_for<'a>(columns: &'a [DataGridColumnInfo], name: &str) -> Option<&'a DataGridColumnInfo> {
+    let normalized = name.to_ascii_lowercase();
+    columns.iter().find(|column| column.name.to_ascii_lowercase() == normalized)
+}
+
+fn data_grid_column_info(column: crate::types::ColumnInfo) -> DataGridColumnInfo {
+    DataGridColumnInfo {
+        name: column.name,
+        data_type: column.data_type,
+        is_nullable: column.is_nullable,
+        is_primary_key: column.is_primary_key,
+        column_default: column.column_default,
+        extra: column.extra,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::models::connection::DatabaseType;
+    use serde_json::json;
+
+    fn data_compare_column(name: &str, data_type: &str) -> DataGridColumnInfo {
+        DataGridColumnInfo {
+            name: name.to_string(),
+            data_type: data_type.to_string(),
+            is_nullable: true,
+            is_primary_key: false,
+            column_default: None,
+            extra: None,
+        }
+    }
+
+    #[test]
+    fn compares_rows_by_primary_key_and_reports_added_removed_and_modified_rows() {
+        let diff = compare_data_rows(CompareDataRowsOptions {
+            columns: vec!["id".to_string(), "name".to_string(), "active".to_string()],
+            key_columns: vec!["id".to_string()],
+            source_rows: vec![
+                vec![json!(1), json!("Ada"), json!(true)],
+                vec![json!(2), json!("Bob"), json!(false)],
+                vec![json!(4), json!("Dora"), json!(true)],
+            ],
+            target_rows: vec![
+                vec![json!(1), json!("Ada"), json!(true)],
+                vec![json!(2), json!("Bobby"), json!(false)],
+                vec![json!(3), json!("Cara"), json!(true)],
+            ],
+        })
+        .expect("data comparison should succeed");
+
+        assert_eq!(
+            diff.added.iter().map(|row| row.key_values.get("id").cloned()).collect::<Vec<_>>(),
+            vec![Some(json!(4))]
+        );
+        assert_eq!(
+            diff.removed.iter().map(|row| row.key_values.get("id").cloned()).collect::<Vec<_>>(),
+            vec![Some(json!(3))]
+        );
+        assert_eq!(diff.modified[0].changes[0].column, "name");
+        assert_eq!(diff.modified[0].changes[0].source, json!("Bob"));
+        assert_eq!(diff.modified[0].changes[0].target, json!("Bobby"));
+    }
+
+    #[test]
+    fn generates_data_synchronization_sql() {
+        let preparation = prepare_data_compare(DataComparePreparationOptions {
+            table_name: "users".to_string(),
+            schema: Some("public".to_string()),
+            columns: vec!["id".to_string(), "name".to_string(), "active".to_string()],
+            key_columns: vec!["id".to_string()],
+            column_info: Vec::new(),
+            source_rows: vec![vec![json!(1), json!("Ada"), json!(true)], vec![json!(2), json!("Bob"), json!(false)]],
+            target_rows: vec![
+                vec![json!(1), json!("Ada Lovelace"), json!(true)],
+                vec![json!(3), json!("Cara"), json!(true)],
+            ],
+            database_type: Some(DatabaseType::Postgres),
+        })
+        .expect("data compare preparation should succeed");
+
+        assert_eq!(
+            preparation.sync_sql,
+            [
+                "INSERT INTO \"public\".\"users\" (\"id\", \"name\", \"active\") VALUES (2, 'Bob', FALSE);",
+                "UPDATE \"public\".\"users\" SET \"name\" = 'Ada' WHERE \"id\" = 1;",
+                "DELETE FROM \"public\".\"users\" WHERE \"id\" = 3;",
+            ]
+            .join("\n")
+        );
+        assert_eq!(preparation.sync_statements.len(), 3);
+    }
+
+    #[test]
+    fn generates_mysql_bit_synchronization_literals_without_string_quotes() {
+        let preparation = prepare_data_compare(DataComparePreparationOptions {
+            table_name: "users".to_string(),
+            schema: None,
+            columns: vec!["id".to_string(), "enabled".to_string(), "flags".to_string()],
+            key_columns: vec!["id".to_string()],
+            column_info: vec![
+                data_compare_column("id", "int"),
+                data_compare_column("enabled", "bit(1)"),
+                data_compare_column("flags", "bit(8)"),
+            ],
+            source_rows: vec![vec![json!(1), json!("0"), json!("10101010")]],
+            target_rows: vec![vec![json!(1), json!("1"), json!("00000001")]],
+            database_type: Some(DatabaseType::Mysql),
+        })
+        .expect("data compare preparation should succeed");
+
+        assert_eq!(preparation.sync_sql, "UPDATE `users` SET `enabled` = 0, `flags` = b'10101010' WHERE `id` = 1;");
+    }
+
+    #[test]
+    fn builds_batch_sync_plan_from_selected_diffs() {
+        let plan = build_data_compare_sync_plan(DataCompareSyncPlanOptions {
+            tables: vec![DataCompareSyncPlanTableOptions {
+                table_name: "users".to_string(),
+                schema: Some("public".to_string()),
+                columns: vec!["id".to_string(), "name".to_string()],
+                key_columns: vec!["id".to_string()],
+                column_info: Vec::new(),
+                diff: DataCompareResult {
+                    added: vec![DataCompareRow {
+                        key: "1".to_string(),
+                        key_values: HashMap::from([(String::from("id"), json!(1))]),
+                        values: HashMap::from([(String::from("id"), json!(1)), (String::from("name"), json!("Ada"))]),
+                    }],
+                    removed: Vec::new(),
+                    modified: vec![DataCompareModifiedRow {
+                        key: "2".to_string(),
+                        key_values: HashMap::from([(String::from("id"), json!(2))]),
+                        source_values: HashMap::from([
+                            (String::from("id"), json!(2)),
+                            (String::from("name"), json!("Bob")),
+                        ]),
+                        target_values: HashMap::from([
+                            (String::from("id"), json!(2)),
+                            (String::from("name"), json!("Bobby")),
+                        ]),
+                        changes: vec![DataCompareChangedCell {
+                            column: "name".to_string(),
+                            source: json!("Bob"),
+                            target: json!("Bobby"),
+                        }],
+                    }],
+                },
+                database_type: Some(DatabaseType::Postgres),
+                pre_sync_statements: Vec::new(),
+            }],
+        });
+
+        assert_eq!(plan.insert_count, 1);
+        assert_eq!(plan.update_count, 1);
+        assert_eq!(plan.delete_count, 0);
+        assert_eq!(plan.statement_count, 2);
+    }
+
+    #[test]
+    fn batches_added_rows_into_multi_value_insert_statements() {
+        let plan = build_data_compare_sync_plan(DataCompareSyncPlanOptions {
+            tables: vec![DataCompareSyncPlanTableOptions {
+                table_name: "users".to_string(),
+                schema: Some("public".to_string()),
+                columns: vec!["id".to_string(), "name".to_string()],
+                key_columns: vec!["id".to_string()],
+                column_info: Vec::new(),
+                diff: DataCompareResult {
+                    added: vec![
+                        DataCompareRow {
+                            key: "1".to_string(),
+                            key_values: HashMap::from([(String::from("id"), json!(1))]),
+                            values: HashMap::from([
+                                (String::from("id"), json!(1)),
+                                (String::from("name"), json!("Ada")),
+                            ]),
+                        },
+                        DataCompareRow {
+                            key: "2".to_string(),
+                            key_values: HashMap::from([(String::from("id"), json!(2))]),
+                            values: HashMap::from([
+                                (String::from("id"), json!(2)),
+                                (String::from("name"), json!("Bob")),
+                            ]),
+                        },
+                    ],
+                    removed: Vec::new(),
+                    modified: Vec::new(),
+                },
+                database_type: Some(DatabaseType::Postgres),
+                pre_sync_statements: Vec::new(),
+            }],
+        });
+
+        assert_eq!(plan.insert_count, 2);
+        assert_eq!(plan.statement_count, 1);
+        assert_eq!(plan.sync_sql, "INSERT INTO \"public\".\"users\" (\"id\", \"name\") VALUES (1, 'Ada'), (2, 'Bob');");
+    }
+
+    #[test]
+    fn batches_modified_rows_into_case_update_statements() {
+        let plan = build_data_compare_sync_plan(DataCompareSyncPlanOptions {
+            tables: vec![DataCompareSyncPlanTableOptions {
+                table_name: "users".to_string(),
+                schema: None,
+                columns: vec!["id".to_string(), "name".to_string(), "active".to_string()],
+                key_columns: vec!["id".to_string()],
+                column_info: Vec::new(),
+                diff: DataCompareResult {
+                    added: Vec::new(),
+                    removed: Vec::new(),
+                    modified: vec![
+                        DataCompareModifiedRow {
+                            key: "1".to_string(),
+                            key_values: HashMap::from([(String::from("id"), json!(1))]),
+                            source_values: HashMap::new(),
+                            target_values: HashMap::new(),
+                            changes: vec![DataCompareChangedCell {
+                                column: "name".to_string(),
+                                source: json!("Ada"),
+                                target: json!("Ada old"),
+                            }],
+                        },
+                        DataCompareModifiedRow {
+                            key: "2".to_string(),
+                            key_values: HashMap::from([(String::from("id"), json!(2))]),
+                            source_values: HashMap::new(),
+                            target_values: HashMap::new(),
+                            changes: vec![
+                                DataCompareChangedCell {
+                                    column: "name".to_string(),
+                                    source: json!("Bob"),
+                                    target: json!("Bob old"),
+                                },
+                                DataCompareChangedCell {
+                                    column: "active".to_string(),
+                                    source: json!(false),
+                                    target: json!(true),
+                                },
+                            ],
+                        },
+                    ],
+                },
+                database_type: Some(DatabaseType::Mysql),
+                pre_sync_statements: Vec::new(),
+            }],
+        });
+
+        assert_eq!(plan.update_count, 2);
+        assert_eq!(plan.statement_count, 1);
+        assert_eq!(
+            plan.sync_sql,
+            "UPDATE `users` SET `name` = CASE WHEN `id` = 1 THEN 'Ada' WHEN `id` = 2 THEN 'Bob' ELSE `name` END, `active` = CASE WHEN `id` = 2 THEN FALSE ELSE `active` END WHERE (`id` = 1) OR (`id` = 2);"
+        );
+    }
+
+    #[test]
+    fn batches_removed_rows_into_or_delete_statements() {
+        let plan = build_data_compare_sync_plan(DataCompareSyncPlanOptions {
+            tables: vec![DataCompareSyncPlanTableOptions {
+                table_name: "users".to_string(),
+                schema: Some("public".to_string()),
+                columns: vec!["id".to_string(), "name".to_string()],
+                key_columns: vec!["id".to_string()],
+                column_info: Vec::new(),
+                diff: DataCompareResult {
+                    added: Vec::new(),
+                    removed: vec![
+                        DataCompareRow {
+                            key: "1".to_string(),
+                            key_values: HashMap::from([(String::from("id"), json!(1))]),
+                            values: HashMap::new(),
+                        },
+                        DataCompareRow {
+                            key: "2".to_string(),
+                            key_values: HashMap::from([(String::from("id"), json!(2))]),
+                            values: HashMap::new(),
+                        },
+                    ],
+                    modified: Vec::new(),
+                },
+                database_type: Some(DatabaseType::Postgres),
+                pre_sync_statements: Vec::new(),
+            }],
+        });
+
+        assert_eq!(plan.delete_count, 2);
+        assert_eq!(plan.statement_count, 1);
+        assert_eq!(plan.sync_sql, "DELETE FROM \"public\".\"users\" WHERE (\"id\" = 1) OR (\"id\" = 2);");
+    }
+
+    #[test]
+    fn borrowed_sync_plan_builder_matches_owned_plan() {
+        let columns = vec!["id".to_string(), "name".to_string()];
+        let key_columns = vec!["id".to_string()];
+        let column_info = Vec::new();
+        let pre_sync_statements = vec!["CREATE TABLE \"public\".\"users\" (\"id\" integer);".to_string()];
+        let diff = DataCompareResult {
+            added: vec![DataCompareRow {
+                key: "1".to_string(),
+                key_values: HashMap::from([(String::from("id"), json!(1))]),
+                values: HashMap::from([(String::from("id"), json!(1)), (String::from("name"), json!("Ada"))]),
+            }],
+            removed: vec![DataCompareRow {
+                key: "3".to_string(),
+                key_values: HashMap::from([(String::from("id"), json!(3))]),
+                values: HashMap::from([(String::from("id"), json!(3)), (String::from("name"), json!("Cara"))]),
+            }],
+            modified: vec![DataCompareModifiedRow {
+                key: "2".to_string(),
+                key_values: HashMap::from([(String::from("id"), json!(2))]),
+                source_values: HashMap::from([(String::from("id"), json!(2)), (String::from("name"), json!("Bob"))]),
+                target_values: HashMap::from([(String::from("id"), json!(2)), (String::from("name"), json!("Bobby"))]),
+                changes: vec![DataCompareChangedCell {
+                    column: "name".to_string(),
+                    source: json!("Bob"),
+                    target: json!("Bobby"),
+                }],
+            }],
+        };
+
+        let owned_plan = build_data_compare_sync_plan(DataCompareSyncPlanOptions {
+            tables: vec![DataCompareSyncPlanTableOptions {
+                table_name: "users".to_string(),
+                schema: Some("public".to_string()),
+                columns: columns.clone(),
+                key_columns: key_columns.clone(),
+                column_info: column_info.clone(),
+                diff: diff.clone(),
+                database_type: Some(DatabaseType::Postgres),
+                pre_sync_statements: pre_sync_statements.clone(),
+            }],
+        });
+        let borrowed_plan = build_data_compare_sync_plan_from_refs(&[DataCompareSyncPlanTableRef {
+            table_name: "users",
+            schema: Some("public"),
+            columns: &columns,
+            key_columns: &key_columns,
+            column_info: &column_info,
+            diff: &diff,
+            database_type: Some(DatabaseType::Postgres),
+            pre_sync_statements: &pre_sync_statements,
+        }]);
+
+        assert_eq!(borrowed_plan.insert_count, owned_plan.insert_count);
+        assert_eq!(borrowed_plan.update_count, owned_plan.update_count);
+        assert_eq!(borrowed_plan.delete_count, owned_plan.delete_count);
+        assert_eq!(borrowed_plan.statement_count, owned_plan.statement_count);
+        assert_eq!(borrowed_plan.sync_statements, owned_plan.sync_statements);
+        assert_eq!(borrowed_plan.sync_sql, owned_plan.sync_sql);
+    }
+
+    #[test]
+    fn build_sync_plan_keeps_missing_target_create_table_statement() {
+        let plan = build_data_compare_sync_plan(DataCompareSyncPlanOptions {
+            tables: vec![DataCompareSyncPlanTableOptions {
+                table_name: "users".to_string(),
+                schema: Some("public".to_string()),
+                columns: vec!["id".to_string(), "name".to_string()],
+                key_columns: Vec::new(),
+                column_info: Vec::new(),
+                diff: DataCompareResult {
+                    added: vec![DataCompareRow {
+                        key: "0".to_string(),
+                        key_values: HashMap::new(),
+                        values: HashMap::from([(String::from("id"), json!(1)), (String::from("name"), json!("Ada"))]),
+                    }],
+                    removed: Vec::new(),
+                    modified: Vec::new(),
+                },
+                database_type: Some(DatabaseType::Postgres),
+                pre_sync_statements: vec!["CREATE TABLE \"public\".\"users\" (\"id\" integer);".to_string()],
+            }],
+        });
+
+        assert_eq!(plan.insert_count, 1);
+        assert_eq!(plan.statement_count, 2);
+        assert!(plan.sync_sql.starts_with("CREATE TABLE"));
+        assert!(plan.sync_sql.contains("INSERT INTO \"public\".\"users\""));
+    }
+
+    #[test]
+    fn requires_at_least_one_key_column() {
+        let err = compare_data_rows(CompareDataRowsOptions {
+            columns: vec!["id".to_string()],
+            key_columns: Vec::new(),
+            source_rows: vec![vec![json!(1)]],
+            target_rows: vec![vec![json!(1)]],
+        })
+        .expect_err("missing key columns should fail");
+
+        assert!(err.contains("At least one key column"));
+    }
+
+    #[test]
+    fn rejects_duplicate_row_keys() {
+        let err = compare_data_rows(CompareDataRowsOptions {
+            columns: vec!["id".to_string(), "name".to_string()],
+            key_columns: vec!["id".to_string()],
+            source_rows: vec![vec![json!(1), json!("Ada")], vec![json!(1), json!("Ada Clone")]],
+            target_rows: vec![vec![json!(1), json!("Ada")]],
+        })
+        .expect_err("duplicate source keys should fail");
+
+        assert!(err.contains("Duplicate source key"));
+    }
+
+    #[test]
+    fn builds_backend_table_select_sql_with_explicit_columns_and_key_order() {
+        assert_eq!(
+            build_data_compare_select_sql(
+                DatabaseType::Postgres,
+                "public",
+                "users",
+                &["id".to_string(), "name".to_string()],
+                &["id".to_string()],
+                1000,
+                0,
+            ),
+            "SELECT \"id\", \"name\" FROM \"public\".\"users\" ORDER BY \"id\" ASC LIMIT 1000;"
+        );
+    }
+
+    #[test]
+    fn builds_backend_table_select_sql_for_sqlserver_limit_syntax() {
+        assert_eq!(
+            build_data_compare_select_sql(
+                DatabaseType::SqlServer,
+                "dbo",
+                "users",
+                &["id".to_string(), "name".to_string()],
+                &["id".to_string()],
+                50,
+                0,
+            ),
+            "SELECT TOP (50) [id], [name] FROM [dbo].[users] ORDER BY [id] ASC"
+        );
+    }
+
+    #[test]
+    fn builds_backend_table_select_sql_for_firebird_rows_syntax() {
+        assert_eq!(
+            build_data_compare_select_sql(
+                DatabaseType::Firebird,
+                "ignored",
+                "USERS",
+                &["ID".to_string(), "NAME".to_string()],
+                &["ID".to_string()],
+                25,
+                50,
+            ),
+            "SELECT \"ID\", \"NAME\" FROM \"USERS\" ORDER BY \"ID\" ASC ROWS 51 TO 75"
+        );
+    }
+
+    #[test]
+    fn builds_backend_table_select_sql_for_oceanbase_oracle_rownum_pages() {
+        assert_eq!(
+            build_data_compare_select_sql(
+                DatabaseType::OceanbaseOracle,
+                "APP",
+                "EVENTS",
+                &["ID".to_string(), "NAME".to_string()],
+                &["ID".to_string()],
+                25,
+                0,
+            ),
+            "SELECT \"ID\", \"NAME\" FROM (SELECT \"ID\", \"NAME\" FROM \"APP\".\"EVENTS\" ORDER BY \"ID\" ASC) WHERE ROWNUM <= 25"
+        );
+        assert_eq!(
+            build_data_compare_select_sql(
+                DatabaseType::OceanbaseOracle,
+                "APP",
+                "EVENTS",
+                &["ID".to_string(), "NAME".to_string()],
+                &["ID".to_string()],
+                25,
+                50,
+            ),
+            "SELECT \"ID\", \"NAME\" FROM (SELECT dbx_inner.*, ROWNUM AS \"__dbx_row_num\" FROM (SELECT \"ID\", \"NAME\" FROM \"APP\".\"EVENTS\" ORDER BY \"ID\" ASC) dbx_inner WHERE ROWNUM <= 75) WHERE \"__dbx_row_num\" > 50"
+        );
+    }
+
+    #[test]
+    fn shared_sql_dialect_helpers_build_data_compare_table_sql() {
+        use crate::sql_dialect::build_count_table_sql as build_shared_count_table_sql;
+
+        assert_eq!(
+            build_shared_count_table_sql(Some(DatabaseType::Postgres), Some("public"), "users"),
+            "SELECT COUNT(*) AS row_count FROM \"public\".\"users\""
+        );
+        assert_eq!(
+            build_data_compare_select_sql(
+                DatabaseType::Oracle,
+                "APP",
+                "EVENTS",
+                &["ID".to_string(), "NAME".to_string()],
+                &["ID".to_string()],
+                25,
+                0,
+            ),
+            "SELECT \"ID\", \"NAME\" FROM \"APP\".\"EVENTS\" ORDER BY \"ID\" ASC FETCH FIRST 25 ROWS ONLY"
+        );
+    }
+}
diff --git a/crates/dbx-core/src/data_grid_neo4j_sql.rs b/crates/dbx-core/src/data_grid_neo4j_sql.rs
new file mode 100644
index 0000000..28945e0
--- /dev/null
+++ b/crates/dbx-core/src/data_grid_neo4j_sql.rs
@@ -0,0 +1,176 @@
+use serde_json::Value;
+
+use super::*;
+use crate::models::connection::DatabaseType;
+
+pub(super) fn build_neo4j_data_grid_save_statements(options: &DataGridSaveStatementOptions) -> Vec<String> {
+    let label = quote_ident(Some(DatabaseType::Neo4j), &options.table_meta.table_name);
+    let mut statements = Vec::new();
+
+    for (row_index, changes) in &options.dirty_rows {
+        let Some(row) = options.rows.get(*row_index) else {
+            continue;
+        };
+        let sets = changes
+            .iter()
+            .filter_map(|(column_index, value)| {
+                let column = options.columns.get(*column_index)?;
+                if is_neo4j_element_id(Some(DatabaseType::Neo4j), Some(column)) {
+                    return None;
+                }
+                Some(format!(
+                    "n.{} = {}",
+                    quote_ident(Some(DatabaseType::Neo4j), column),
+                    format_grid_sql_literal(value, Some(DatabaseType::Neo4j), None)
+                ))
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+        if sets.is_empty() {
+            continue;
+        }
+        statements
+            .push(format!("MATCH (n:{label}) WHERE {} SET {sets};", neo4j_element_id_predicate(&options.columns, row)));
+    }
+
+    for row_index in &options.deleted_rows {
+        let Some(row) = options.rows.get(*row_index) else {
+            continue;
+        };
+        statements.push(format!(
+            "MATCH (n:{label}) WHERE {} DETACH DELETE n;",
+            neo4j_element_id_predicate(&options.columns, row)
+        ));
+    }
+
+    for row in &options.new_rows {
+        let props = options
+            .columns
+            .iter()
+            .enumerate()
+            .filter(|(_, column)| !is_neo4j_element_id(Some(DatabaseType::Neo4j), Some(column)))
+            .filter_map(|(index, column)| {
+                let value = row.get(index).unwrap_or(&Value::Null);
+                if value.is_null() {
+                    return None;
+                }
+                Some(format!(
+                    "{}: {}",
+                    quote_ident(Some(DatabaseType::Neo4j), column),
+                    format_grid_sql_literal(value, Some(DatabaseType::Neo4j), None)
+                ))
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+        statements.push(if props.is_empty() {
+            format!("CREATE (n:{label});")
+        } else {
+            format!("CREATE (n:{label} {{{props}}});")
+        });
+    }
+
+    statements
+}
+
+pub(super) fn build_neo4j_data_grid_rollback_statements(options: &DataGridSaveStatementOptions) -> Vec<String> {
+    let label = quote_ident(Some(DatabaseType::Neo4j), &options.table_meta.table_name);
+    let mut statements = Vec::new();
+
+    for row in &options.new_rows {
+        let where_clause = neo4j_row_property_where(&options.columns, row);
+        statements.push(if where_clause.is_empty() {
+            format!("MATCH (n:{label}) DETACH DELETE n;")
+        } else {
+            format!("MATCH (n:{label}) WHERE {where_clause} DETACH DELETE n;")
+        });
+    }
+
+    for row_index in &options.deleted_rows {
+        let Some(row) = options.rows.get(*row_index) else {
+            continue;
+        };
+        let props = options
+            .columns
+            .iter()
+            .enumerate()
+            .filter(|(_, column)| !is_neo4j_element_id(Some(DatabaseType::Neo4j), Some(column)))
+            .filter_map(|(index, column)| {
+                let value = row.get(index).unwrap_or(&Value::Null);
+                if value.is_null() {
+                    return None;
+                }
+                Some(format!(
+                    "{}: {}",
+                    quote_ident(Some(DatabaseType::Neo4j), column),
+                    format_grid_sql_literal(value, Some(DatabaseType::Neo4j), None)
+                ))
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+        statements.push(if props.is_empty() {
+            format!("CREATE (n:{label});")
+        } else {
+            format!("CREATE (n:{label} {{{props}}});")
+        });
+    }
+
+    for (row_index, changes) in &options.dirty_rows {
+        let Some(row) = options.rows.get(*row_index) else {
+            continue;
+        };
+        let sets = changes
+            .iter()
+            .filter_map(|(column_index, _)| {
+                let column = options.columns.get(*column_index)?;
+                if is_neo4j_element_id(Some(DatabaseType::Neo4j), Some(column)) {
+                    return None;
+                }
+                Some(format!(
+                    "n.{} = {}",
+                    quote_ident(Some(DatabaseType::Neo4j), column),
+                    format_grid_sql_literal(
+                        row.get(*column_index).unwrap_or(&Value::Null),
+                        Some(DatabaseType::Neo4j),
+                        None
+                    )
+                ))
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+        if sets.is_empty() {
+            continue;
+        }
+        statements
+            .push(format!("MATCH (n:{label}) WHERE {} SET {sets};", neo4j_element_id_predicate(&options.columns, row)));
+    }
+
+    statements
+}
+
+fn neo4j_element_id_predicate(columns: &[String], row: &[Value]) -> String {
+    let index = columns.iter().position(|column| column == DBX_NEO4J_ELEMENT_ID_COLUMN).unwrap_or(usize::MAX);
+    format!(
+        "elementId(n) = {}",
+        format_grid_sql_literal(row.get(index).unwrap_or(&Value::Null), Some(DatabaseType::Neo4j), None)
+    )
+}
+
+fn neo4j_row_property_where(columns: &[String], row: &[Value]) -> String {
+    columns
+        .iter()
+        .enumerate()
+        .filter_map(|(index, column)| {
+            if is_neo4j_element_id(Some(DatabaseType::Neo4j), Some(column)) {
+                return None;
+            }
+            let value = row.get(index).unwrap_or(&Value::Null);
+            let ident = format!("n.{}", quote_ident(Some(DatabaseType::Neo4j), column));
+            if value.is_null() {
+                Some(format!("{ident} IS NULL"))
+            } else {
+                Some(format!("{ident} = {}", format_grid_sql_literal(value, Some(DatabaseType::Neo4j), None)))
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(" AND ")
+}
diff --git a/crates/dbx-core/src/data_grid_sql.rs b/crates/dbx-core/src/data_grid_sql.rs
new file mode 100644
index 0000000..9b8ee77
--- /dev/null
+++ b/crates/dbx-core/src/data_grid_sql.rs
@@ -0,0 +1,3936 @@
+use chrono::{Local, NaiveDateTime};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+#[path = "data_grid_neo4j_sql.rs"]
+mod data_grid_neo4j_sql;
+use data_grid_neo4j_sql::{build_neo4j_data_grid_rollback_statements, build_neo4j_data_grid_save_statements};
+
+#[path = "data_grid_tdengine_sql.rs"]
+mod data_grid_tdengine_sql;
+use data_grid_tdengine_sql::{
+    build_tdengine_data_grid_rollback_statements, build_tdengine_data_grid_save_statements,
+    validate_tdengine_existing_rows, validate_tdengine_inserted_rows,
+};
+
+use crate::models::connection::DatabaseType;
+use crate::sql_dialect::{
+    firebird_rows_clause, quote_table_identifier, table_pagination_strategy, uses_single_row_insert_statements,
+    TablePaginationStrategy,
+};
+use crate::transfer::{format_ch_array_sql_literal, format_pg_array_sql_literal};
+
+const DBX_ROWID_COLUMN: &str = "__DBX_ROWID";
+pub(crate) const DBX_NEO4J_ELEMENT_ID_COLUMN: &str = "__DBX_ELEMENT_ID";
+pub(crate) const DBX_TDENGINE_TBNAME_COLUMN: &str = "tbname";
+const DATA_GRID_COLUMN_DISTINCT_VALUES_DEFAULT_LIMIT: usize = 1000;
+const DATA_GRID_COLUMN_DISTINCT_VALUES_MAX_LIMIT: usize = 1000;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataGridTableMeta {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub catalog: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub table_name: String,
+    #[serde(default)]
+    pub primary_keys: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub columns: Option<Vec<DataGridColumnInfo>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DataGridColumnInfo {
+    pub name: String,
+    #[serde(default)]
+    pub data_type: String,
+    #[serde(default)]
+    pub is_nullable: bool,
+    #[serde(default)]
+    pub is_primary_key: bool,
+    #[serde(default)]
+    pub column_default: Option<String>,
+    #[serde(default)]
+    pub extra: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataGridSaveStatementOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub table_meta: DataGridTableMeta,
+    pub columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source_columns: Option<Vec<Option<String>>>,
+    #[serde(default)]
+    pub rows: Vec<Vec<Value>>,
+    #[serde(default)]
+    pub dirty_rows: Vec<(usize, Vec<(usize, Value)>)>,
+    #[serde(default)]
+    pub deleted_rows: Vec<usize>,
+    #[serde(default)]
+    pub new_rows: Vec<Vec<Value>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataGridCopyUpdateStatementOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub table_meta: DataGridTableMeta,
+    pub columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source_columns: Option<Vec<Option<String>>>,
+    #[serde(default)]
+    pub rows: Vec<Vec<Value>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataGridCopyInsertStatementOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table_meta: Option<DataGridTableMeta>,
+    pub columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub column_types: Option<Vec<Option<String>>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source_columns: Option<Vec<Option<String>>>,
+    #[serde(default)]
+    pub rows: Vec<Vec<Value>>,
+    #[serde(default)]
+    pub exclude_primary_keys: bool,
+    #[serde(default)]
+    pub insert_mode: DataGridCopyInsertMode,
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum DataGridCopyInsertMode {
+    #[default]
+    Merged,
+    RowByRow,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum DataGridContextFilterMode {
+    Equals,
+    NotEquals,
+    IsNull,
+    IsNotNull,
+    Like,
+    NotLike,
+    LessThan,
+    GreaterThan,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataGridContextFilterConditionOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub column_name: String,
+    pub mode: DataGridContextFilterMode,
+    pub value: Value,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub column_info: Option<DataGridColumnInfo>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataGridColumnValueFilterConditionOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub column_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub column_info: Option<DataGridColumnInfo>,
+    pub raw_value: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataGridColumnValuesFilterConditionOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub column_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub column_info: Option<DataGridColumnInfo>,
+    #[serde(default)]
+    pub values: Vec<Value>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataGridColumnDistinctValuesSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub catalog: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub table_name: String,
+    pub column_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub column_info: Option<DataGridColumnInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub where_input: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub search_value: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit: Option<usize>,
+    #[serde(default)]
+    pub include_counts: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataGridCountSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub catalog: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub table_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub where_input: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HiveTablePropertiesSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub table_name: String,
+    pub property_name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DataGridSavePreparation {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub validation_error: Option<String>,
+    pub statements: Vec<String>,
+    pub rollback_statements: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub execution_schema: Option<String>,
+}
+
+pub fn prepare_data_grid_save(options: DataGridSaveStatementOptions) -> DataGridSavePreparation {
+    let validation_error = validate_data_grid_save(&options);
+    if validation_error.is_some() {
+        return DataGridSavePreparation {
+            validation_error,
+            statements: Vec::new(),
+            rollback_statements: Vec::new(),
+            execution_schema: data_grid_save_execution_schema(options.database_type, &options.table_meta),
+        };
+    }
+
+    DataGridSavePreparation {
+        validation_error: None,
+        statements: build_data_grid_save_statements(&options),
+        rollback_statements: build_data_grid_rollback_statements(&options),
+        execution_schema: data_grid_save_execution_schema(options.database_type, &options.table_meta),
+    }
+}
+
+pub fn build_data_grid_copy_update_statements(options: DataGridCopyUpdateStatementOptions) -> Vec<String> {
+    if matches!(options.database_type, Some(DatabaseType::Neo4j | DatabaseType::Tdengine)) {
+        return Vec::new();
+    }
+    let primary_keys = &options.table_meta.primary_keys;
+    if primary_keys.is_empty() {
+        return Vec::new();
+    }
+
+    let save_columns = effective_copy_columns(options.source_columns.as_deref(), &options.columns);
+    let column_info = options.table_meta.columns.as_deref().unwrap_or(&[]);
+    let primary_key_indexes: Vec<Option<usize>> =
+        primary_keys.iter().map(|primary_key| find_column_index(&save_columns, primary_key)).collect();
+    if primary_key_indexes.iter().any(Option::is_none) {
+        return Vec::new();
+    }
+    let primary_key_indexes: Vec<usize> = primary_key_indexes.into_iter().flatten().collect();
+    let primary_key_set: Vec<String> =
+        primary_keys.iter().map(|primary_key| normalize_column_name(primary_key)).collect();
+    let writable_indexes: Vec<(&str, usize)> = save_columns
+        .iter()
+        .enumerate()
+        .filter_map(|(index, column)| Some((column.as_deref()?, index)))
+        .filter(|(column, _)| !primary_key_set.contains(&normalize_column_name(column)))
+        .filter(|(column, _)| !is_oracle_row_id(options.database_type, Some(column)))
+        .collect();
+
+    if writable_indexes.is_empty() {
+        return Vec::new();
+    }
+
+    let table = crate::sql_dialect::qualified_table_name_with_catalog(
+        options.database_type,
+        options.table_meta.catalog.as_deref(),
+        options.table_meta.schema.as_deref(),
+        &options.table_meta.table_name,
+    );
+    let mut statements = Vec::new();
+    for row in &options.rows {
+        if primary_key_indexes.iter().any(|index| row.get(*index).unwrap_or(&Value::Null).is_null()) {
+            continue;
+        }
+        let sets = writable_indexes
+            .iter()
+            .map(|(column, index)| {
+                format!(
+                    "{} = {}",
+                    quote_ident(options.database_type, column),
+                    format_grid_sql_literal(
+                        row.get(*index).unwrap_or(&Value::Null),
+                        options.database_type,
+                        column_info_for(column_info, column)
+                    )
+                )
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+        if sets.is_empty() {
+            continue;
+        }
+        let where_clause = primary_keys
+            .iter()
+            .enumerate()
+            .map(|(index, primary_key)| {
+                build_column_predicate(
+                    options.database_type,
+                    primary_key,
+                    row.get(primary_key_indexes[index]).unwrap_or(&Value::Null),
+                    column_info_for(column_info, primary_key),
+                    false,
+                )
+            })
+            .collect::<Vec<_>>()
+            .join(" AND ");
+        statements.push(data_grid_statement(
+            options.database_type,
+            data_grid_update_sql(options.database_type, &table, &sets, &where_clause),
+        ));
+    }
+    statements
+}
+
+pub fn build_data_grid_copy_insert_statement(options: DataGridCopyInsertStatementOptions) -> Option<String> {
+    let save_columns = effective_copy_columns(options.source_columns.as_deref(), &options.columns);
+    let column_info = options.table_meta.as_ref().and_then(|meta| meta.columns.as_deref()).unwrap_or(&[]);
+    let primary_key_set: Vec<String> = options
+        .table_meta
+        .as_ref()
+        .map(|meta| meta.primary_keys.iter().map(|primary_key| normalize_column_name(primary_key)).collect())
+        .unwrap_or_default();
+    let insertable_columns: Vec<(&str, usize)> = save_columns
+        .iter()
+        .enumerate()
+        .filter_map(|(index, column)| Some((column.as_deref()?, index)))
+        .filter(|(column, _)| {
+            !is_grid_insert_omitted_column(options.database_type, column_info_for(column_info, column), Some(column))
+        })
+        .collect();
+    let insert_columns: Vec<(&str, usize)> = insertable_columns
+        .iter()
+        .copied()
+        .filter(|(column, _)| {
+            !options.exclude_primary_keys || !primary_key_set.contains(&normalize_column_name(column))
+        })
+        .collect();
+
+    if options.exclude_primary_keys && insert_columns.len() == insertable_columns.len() {
+        return None;
+    }
+    if insert_columns.is_empty() || options.rows.is_empty() {
+        return None;
+    }
+
+    let table = options.table_meta.as_ref().map_or_else(
+        || "table_name".to_string(),
+        |meta| {
+            crate::sql_dialect::qualified_table_name_with_catalog(
+                options.database_type,
+                meta.catalog.as_deref(),
+                meta.schema.as_deref(),
+                &meta.table_name,
+            )
+        },
+    );
+    let columns = insert_columns
+        .iter()
+        .map(|(column, _)| quote_ident(options.database_type, column))
+        .collect::<Vec<_>>()
+        .join(", ");
+    let value_rows = options
+        .rows
+        .iter()
+        .map(|row| {
+            format!(
+                "({})",
+                insert_columns
+                    .iter()
+                    .map(|(column, index)| {
+                        format_grid_copy_insert_sql_literal(
+                            row.get(*index).unwrap_or(&Value::Null),
+                            options.database_type,
+                            copy_column_info(
+                                column_info,
+                                column,
+                                options
+                                    .column_types
+                                    .as_deref()
+                                    .and_then(|types| types.get(*index))
+                                    .and_then(|value| value.as_deref()),
+                            )
+                            .as_ref(),
+                        )
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            )
+        })
+        .collect::<Vec<_>>();
+    if options.insert_mode == DataGridCopyInsertMode::RowByRow
+        || options.database_type.is_some_and(uses_single_row_insert_statements)
+    {
+        return Some(
+            value_rows
+                .iter()
+                .map(|values| format!("INSERT INTO {table} ({columns}) VALUES {values};"))
+                .collect::<Vec<_>>()
+                .join("\n"),
+        );
+    }
+    Some(format!(
+        "INSERT INTO {table} ({columns}) VALUES{}{};",
+        if value_rows.len() == 1 { " " } else { "\n" },
+        value_rows.join(",\n")
+    ))
+}
+
+pub fn build_data_grid_context_filter_condition(options: DataGridContextFilterConditionOptions) -> Option<String> {
+    let column = column_filter_ref(options.database_type, &options.column_name);
+    let like_column = column_like_filter_ref(options.database_type, &options.column_name, options.column_info.as_ref());
+    let value = &options.value;
+    match options.mode {
+        DataGridContextFilterMode::IsNull => Some(format!("{column} IS NULL")),
+        DataGridContextFilterMode::IsNotNull => Some(format!("{column} IS NOT NULL")),
+        DataGridContextFilterMode::Equals if value.is_null() => Some(format!("{column} IS NULL")),
+        DataGridContextFilterMode::NotEquals if value.is_null() => Some(format!("{column} IS NOT NULL")),
+        DataGridContextFilterMode::Like => Some(format!(
+            "{like_column} LIKE {}",
+            format_grid_sql_literal(
+                &Value::String(format!("%{}%", value_to_filter_text(value))),
+                options.database_type,
+                None
+            )
+        )),
+        DataGridContextFilterMode::NotLike => Some(format!(
+            "{like_column} NOT LIKE {}",
+            format_grid_sql_literal(
+                &Value::String(format!("%{}%", value_to_filter_text(value))),
+                options.database_type,
+                None
+            )
+        )),
+        DataGridContextFilterMode::LessThan => Some(format!(
+            "{column} < {}",
+            format_grid_sql_literal(value, options.database_type, options.column_info.as_ref())
+        )),
+        DataGridContextFilterMode::GreaterThan => Some(format!(
+            "{column} > {}",
+            format_grid_sql_literal(value, options.database_type, options.column_info.as_ref())
+        )),
+        DataGridContextFilterMode::Equals => Some(format!(
+            "{column} = {}",
+            format_grid_sql_literal(value, options.database_type, options.column_info.as_ref())
+        )),
+        DataGridContextFilterMode::NotEquals => Some(format!(
+            "{column} <> {}",
+            format_grid_sql_literal(value, options.database_type, options.column_info.as_ref())
+        )),
+    }
+}
+
+pub fn build_data_grid_column_value_filter_condition(
+    options: DataGridColumnValueFilterConditionOptions,
+) -> Option<String> {
+    let text = options.raw_value.trim();
+    if text.is_empty() {
+        return None;
+    }
+    let column = column_filter_ref(options.database_type, &options.column_name);
+    if text.eq_ignore_ascii_case("null") {
+        return Some(format!("{column} IS NULL"));
+    }
+    let value = parse_typed_filter_value(text, options.column_info.as_ref());
+    Some(format!("{column} = {}", format_grid_sql_literal(&value, options.database_type, options.column_info.as_ref())))
+}
+
+pub fn build_data_grid_column_values_filter_condition(
+    options: DataGridColumnValuesFilterConditionOptions,
+) -> Option<String> {
+    if options.values.is_empty() {
+        return None;
+    }
+
+    let column = column_filter_ref(options.database_type, &options.column_name);
+    let mut has_null = false;
+    let mut literals = Vec::new();
+    for value in &options.values {
+        if value.is_null() {
+            has_null = true;
+            continue;
+        }
+        let literal = format_grid_sql_literal(value, options.database_type, options.column_info.as_ref());
+        if !literals.contains(&literal) {
+            literals.push(literal);
+        }
+    }
+
+    let mut predicates = Vec::new();
+    if has_null {
+        predicates.push(format!("{column} IS NULL"));
+    }
+    if !literals.is_empty() {
+        let list = literals.join(", ");
+        if literals.len() == 1 {
+            predicates.push(format!("{column} = {list}"));
+        } else if options.database_type == Some(DatabaseType::Neo4j) {
+            predicates.push(format!("{column} IN [{list}]"));
+        } else {
+            predicates.push(format!("{column} IN ({list})"));
+        }
+    }
+
+    match predicates.len() {
+        0 => None,
+        1 => predicates.into_iter().next(),
+        _ => Some(format!("({})", predicates.join(" OR "))),
+    }
+}
+
+pub fn build_data_grid_column_distinct_values_sql(options: DataGridColumnDistinctValuesSqlOptions) -> String {
+    if options.database_type == Some(DatabaseType::Neo4j) {
+        return build_neo4j_data_grid_column_distinct_values_sql(&options);
+    }
+
+    let limit = data_grid_column_distinct_values_limit(options.limit);
+    let table = crate::sql_dialect::qualified_table_name_with_catalog(
+        options.database_type,
+        options.catalog.as_deref(),
+        options.schema.as_deref(),
+        &options.table_name,
+    );
+    let column = column_filter_ref(options.database_type, &options.column_name);
+    let mut predicates = Vec::new();
+    let predicate = crate::sql_dialect::normalize_where_input(options.where_input.as_deref());
+    if !predicate.is_empty() {
+        predicates.push(format!("({predicate})"));
+    }
+    if let Some(search_predicate) = data_grid_column_distinct_values_search_predicate(&options) {
+        predicates.push(search_predicate);
+    }
+    let where_clause =
+        if predicates.is_empty() { String::new() } else { format!(" WHERE {}", predicates.join(" AND ")) };
+    let select_list = if options.include_counts {
+        format!("{column} AS dbx_value, COUNT(*) AS dbx_count")
+    } else {
+        format!("{column} AS dbx_value")
+    };
+    let group_by = format!(" GROUP BY {column}");
+    let order_by = if options.include_counts { " ORDER BY dbx_count DESC, dbx_value" } else { " ORDER BY dbx_value" };
+    let from_clause = format!(" FROM {table}{where_clause}{group_by}{order_by}");
+
+    match table_pagination_strategy(options.database_type) {
+        TablePaginationStrategy::SqlServerTop => format!("SELECT TOP ({limit}) {select_list}{from_clause}"),
+        TablePaginationStrategy::IrisTop => format!("SELECT TOP {limit} {select_list}{from_clause}"),
+        TablePaginationStrategy::InformixFirst => format!("SELECT FIRST {limit} {select_list}{from_clause}"),
+        TablePaginationStrategy::FirebirdRows => {
+            let rows = firebird_rows_clause(limit, 0);
+            format!("SELECT {select_list}{from_clause} {rows}")
+        }
+        TablePaginationStrategy::Db2FetchFirst | TablePaginationStrategy::FetchFirst => {
+            format!("SELECT {select_list}{from_clause} FETCH FIRST {limit} ROWS ONLY")
+        }
+        TablePaginationStrategy::Rownum => {
+            let inner = format!("SELECT {select_list}{from_clause}");
+            format!("SELECT * FROM ({inner}) WHERE ROWNUM <= {limit}")
+        }
+        TablePaginationStrategy::AgentMaxRows | TablePaginationStrategy::Unbounded => {
+            format!("SELECT {select_list}{from_clause}")
+        }
+        TablePaginationStrategy::QuestDbLimit | TablePaginationStrategy::LimitOffset => {
+            format!("SELECT {select_list}{from_clause} LIMIT {limit}")
+        }
+    }
+}
+
+pub fn build_data_grid_count_sql(options: DataGridCountSqlOptions) -> String {
+    let table = crate::sql_dialect::qualified_table_name_with_catalog(
+        options.database_type,
+        options.catalog.as_deref(),
+        options.schema.as_deref(),
+        &options.table_name,
+    );
+    let predicate = crate::sql_dialect::normalize_where_input(options.where_input.as_deref());
+    let where_clause = if predicate.is_empty() { String::new() } else { format!(" WHERE ({predicate})") };
+    format!("SELECT COUNT(*) AS cnt FROM {table}{where_clause}")
+}
+
+pub fn build_hive_table_properties_sql(options: HiveTablePropertiesSqlOptions) -> String {
+    let table = qualified_table_name(Some(DatabaseType::Hive), options.schema.as_deref(), &options.table_name);
+    let property = options.property_name.replace('\'', "''");
+    format!("SHOW TBLPROPERTIES {table} ('{property}')")
+}
+
+fn data_grid_column_distinct_values_limit(limit: Option<usize>) -> usize {
+    limit.unwrap_or(DATA_GRID_COLUMN_DISTINCT_VALUES_DEFAULT_LIMIT).clamp(1, DATA_GRID_COLUMN_DISTINCT_VALUES_MAX_LIMIT)
+}
+
+fn data_grid_column_distinct_values_search_predicate(
+    options: &DataGridColumnDistinctValuesSqlOptions,
+) -> Option<String> {
+    let search = options.search_value.as_deref()?.trim();
+    if search.is_empty() {
+        return None;
+    }
+    if !options.column_info.as_ref().map(|column| is_textual_column_type(&column.data_type)).unwrap_or(true)
+        && !is_postgres_like_pattern_database(options.database_type)
+    {
+        let column = column_filter_ref(options.database_type, &options.column_name);
+        let value = parse_typed_filter_value(search, options.column_info.as_ref());
+        return Some(format!(
+            "{column} = {}",
+            format_grid_sql_literal(&value, options.database_type, options.column_info.as_ref())
+        ));
+    }
+    let column = column_like_filter_ref(options.database_type, &options.column_name, options.column_info.as_ref());
+    let pattern = Value::String(format!("%{search}%"));
+    Some(format!("{column} LIKE {}", format_grid_sql_literal(&pattern, options.database_type, None)))
+}
+
+fn build_neo4j_data_grid_column_distinct_values_sql(options: &DataGridColumnDistinctValuesSqlOptions) -> String {
+    let limit = data_grid_column_distinct_values_limit(options.limit);
+    let label = quote_ident(Some(DatabaseType::Neo4j), &options.table_name);
+    let column = column_filter_ref(Some(DatabaseType::Neo4j), &options.column_name);
+    let mut predicates = Vec::new();
+    let predicate = crate::sql_dialect::normalize_where_input(options.where_input.as_deref());
+    if !predicate.is_empty() {
+        predicates.push(predicate);
+    }
+    if let Some(search) = options.search_value.as_deref().map(str::trim).filter(|value| !value.is_empty()) {
+        predicates.push(format!(
+            "toString({column}) CONTAINS {}",
+            format_grid_sql_literal(&Value::String(search.to_string()), Some(DatabaseType::Neo4j), None)
+        ));
+    }
+    let where_clause =
+        if predicates.is_empty() { String::new() } else { format!(" WHERE {}", predicates.join(" AND ")) };
+    if options.include_counts {
+        format!(
+            "MATCH (n:{label}){where_clause} RETURN {column} AS dbx_value, count(*) AS dbx_count ORDER BY dbx_count DESC, dbx_value LIMIT {limit}"
+        )
+    } else {
+        format!(
+            "MATCH (n:{label}){where_clause} RETURN DISTINCT {column} AS dbx_value ORDER BY dbx_value LIMIT {limit}"
+        )
+    }
+}
+
+fn validate_data_grid_save(options: &DataGridSaveStatementOptions) -> Option<String> {
+    if let Some(error) = validate_tdengine_inserted_rows(options) {
+        return Some(error);
+    }
+    if let Some(error) = validate_inserted_primary_keys(options) {
+        return Some(error);
+    }
+    if let Some(error) = validate_tdengine_existing_rows(options) {
+        return Some(error);
+    }
+
+    let not_null_columns: Vec<String> = options
+        .table_meta
+        .columns
+        .as_deref()
+        .unwrap_or(&[])
+        .iter()
+        .filter(|column| {
+            !column.is_nullable
+                && column.column_default.is_none()
+                && !is_auto_generated_column(column)
+                && !is_non_identity_generated_column(Some(column))
+                && !is_oracle_row_id(options.database_type, Some(&column.name))
+        })
+        .map(|column| normalize_column_name(&column.name))
+        .collect();
+    if let Some(error) = validate_clickhouse_mutable_updates(options) {
+        return Some(error);
+    }
+
+    if not_null_columns.is_empty() {
+        return None;
+    }
+
+    for (_, changes) in &options.dirty_rows {
+        for (column_index, value) in changes {
+            let source_column = effective_column(options, *column_index);
+            if is_null_write_to_not_null_column(options.database_type, &not_null_columns, source_column, value) {
+                return Some(null_write_error(source_column.unwrap_or_default()));
+            }
+        }
+    }
+
+    for row in &options.new_rows {
+        for column_index in 0..options.columns.len() {
+            let source_column = effective_column(options, column_index);
+            if is_null_write_to_not_null_column(
+                options.database_type,
+                &not_null_columns,
+                source_column,
+                row.get(column_index).unwrap_or(&Value::Null),
+            ) {
+                return Some(null_write_error(source_column.unwrap_or_default()));
+            }
+        }
+    }
+
+    None
+}
+
+fn validate_clickhouse_mutable_updates(options: &DataGridSaveStatementOptions) -> Option<String> {
+    if options.database_type != Some(DatabaseType::ClickHouse) || options.dirty_rows.is_empty() {
+        return None;
+    }
+    let save_columns = effective_columns(options);
+    let column_info = options.table_meta.columns.as_deref().unwrap_or(&[]);
+    let primary_key_set: Vec<String> =
+        options.table_meta.primary_keys.iter().map(|primary_key| normalize_column_name(primary_key)).collect();
+    let has_clickhouse_key_metadata = !primary_key_set.is_empty()
+        || column_info.iter().any(|column| is_clickhouse_partition_key_column(options.database_type, Some(column)));
+    if !has_clickhouse_key_metadata {
+        return None;
+    }
+
+    for (_, changes) in &options.dirty_rows {
+        if changes.is_empty() {
+            continue;
+        }
+        let has_mutable_column = changes.iter().any(|(column_index, _)| {
+            let Some(column) = save_columns.get(*column_index).and_then(|column| column.as_deref()) else {
+                return false;
+            };
+            !is_grid_update_omitted_column(
+                options.database_type,
+                column_info_for(column_info, column),
+                Some(column),
+                &primary_key_set,
+            )
+        });
+        if !has_mutable_column {
+            return Some(clickhouse_no_mutable_columns_error());
+        }
+    }
+    None
+}
+
+fn validate_inserted_primary_keys(options: &DataGridSaveStatementOptions) -> Option<String> {
+    let primary_keys = &options.table_meta.primary_keys;
+    if primary_keys.is_empty() || options.new_rows.is_empty() {
+        return None;
+    }
+
+    let save_columns = effective_columns(options);
+    let primary_key_indexes: Vec<Option<usize>> =
+        primary_keys.iter().map(|primary_key| find_column_index(&save_columns, primary_key)).collect();
+    if primary_key_indexes.iter().any(Option::is_none) {
+        return None;
+    }
+    let primary_key_indexes: Vec<usize> = primary_key_indexes.into_iter().flatten().collect();
+
+    let mut existing_keys: Vec<String> = Vec::new();
+    for row in &options.rows {
+        if let Some(key) = primary_key_value_key(&primary_key_indexes, row) {
+            existing_keys.push(key);
+        }
+    }
+
+    let mut new_keys: Vec<String> = Vec::new();
+    for row in &options.new_rows {
+        let Some(key) = primary_key_value_key(&primary_key_indexes, row) else {
+            continue;
+        };
+        if existing_keys.contains(&key) || new_keys.contains(&key) {
+            return Some(duplicate_primary_key_error(
+                primary_keys,
+                &primary_key_indexes,
+                row,
+                existing_keys.contains(&key),
+            ));
+        }
+        new_keys.push(key);
+    }
+
+    None
+}
+
+fn build_data_grid_save_statements(options: &DataGridSaveStatementOptions) -> Vec<String> {
+    if options.database_type == Some(DatabaseType::Neo4j) {
+        return build_neo4j_data_grid_save_statements(options);
+    }
+    if options.database_type == Some(DatabaseType::Tdengine) {
+        return build_tdengine_data_grid_save_statements(options);
+    }
+
+    let save_columns = effective_columns(options);
+    let column_info = options.table_meta.columns.as_deref().unwrap_or(&[]);
+    let table = crate::sql_dialect::qualified_table_name_with_catalog(
+        options.database_type,
+        options.table_meta.catalog.as_deref(),
+        options.table_meta.schema.as_deref(),
+        &options.table_meta.table_name,
+    );
+    let mut statements = Vec::new();
+    let primary_key_set: Vec<String> =
+        options.table_meta.primary_keys.iter().map(|primary_key| normalize_column_name(primary_key)).collect();
+
+    for (row_index, changes) in &options.dirty_rows {
+        let Some(row) = options.rows.get(*row_index) else {
+            continue;
+        };
+        let sets = changes
+            .iter()
+            .filter_map(|(column_index, value)| {
+                let column = save_columns.get(*column_index)?.as_deref()?;
+                if is_grid_update_omitted_column(
+                    options.database_type,
+                    column_info_for(column_info, column),
+                    Some(column),
+                    &primary_key_set,
+                ) {
+                    return None;
+                }
+                Some(format!(
+                    "{} = {}",
+                    quote_ident(options.database_type, column),
+                    format_grid_save_sql_literal(value, options.database_type, column_info_for(column_info, column))
+                ))
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+        if sets.is_empty() {
+            continue;
+        }
+        let where_clause = build_primary_key_where(
+            options.database_type,
+            &options.table_meta.primary_keys,
+            &save_columns,
+            row,
+            column_info,
+        );
+        statements.push(data_grid_statement(
+            options.database_type,
+            data_grid_update_sql(options.database_type, &table, &sets, &where_clause),
+        ));
+    }
+
+    for row_index in &options.deleted_rows {
+        let Some(row) = options.rows.get(*row_index) else {
+            continue;
+        };
+        let where_clause = build_primary_key_where(
+            options.database_type,
+            &options.table_meta.primary_keys,
+            &save_columns,
+            row,
+            column_info,
+        );
+        statements.push(data_grid_statement(
+            options.database_type,
+            data_grid_delete_sql(options.database_type, &table, &where_clause),
+        ));
+    }
+
+    for row in &options.new_rows {
+        let insert_pairs: Vec<(&str, &Value)> = save_columns
+            .iter()
+            .enumerate()
+            .filter_map(|(index, column)| Some((column.as_deref()?, row.get(index).unwrap_or(&Value::Null))))
+            .filter(|(column, value)| {
+                let column_info = column_info_for(column_info, column);
+                // Empty generated values must be omitted so the database can apply AUTO_INCREMENT/IDENTITY semantics.
+                !column_info.is_some_and(is_auto_generated_column) || !grid_value_is_empty(value)
+            })
+            .filter(|(column, _)| {
+                !is_grid_insert_omitted_column(
+                    options.database_type,
+                    column_info_for(column_info, column),
+                    Some(column),
+                )
+            })
+            .filter(|(_, value)| !value.is_null())
+            .collect();
+        if insert_pairs.is_empty() {
+            continue;
+        }
+        let columns = insert_pairs
+            .iter()
+            .map(|(column, _)| quote_ident(options.database_type, column))
+            .collect::<Vec<_>>()
+            .join(", ");
+        let values = insert_pairs
+            .iter()
+            .map(|(column, value)| {
+                format_grid_save_sql_literal(value, options.database_type, column_info_for(column_info, column))
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+        statements.push(data_grid_statement(
+            options.database_type,
+            format!("INSERT INTO {table} ({columns}) VALUES ({values})"),
+        ));
+    }
+
+    statements
+}
+
+fn build_data_grid_rollback_statements(options: &DataGridSaveStatementOptions) -> Vec<String> {
+    if options.database_type == Some(DatabaseType::Neo4j) {
+        return build_neo4j_data_grid_rollback_statements(options);
+    }
+    if options.database_type == Some(DatabaseType::Tdengine) {
+        return build_tdengine_data_grid_rollback_statements(options);
+    }
+    if options.database_type == Some(DatabaseType::ClickHouse) {
+        return Vec::new();
+    }
+
+    let save_columns = effective_columns(options);
+    let column_info = options.table_meta.columns.as_deref().unwrap_or(&[]);
+    let table = qualified_table_name(
+        options.database_type,
+        options.table_meta.schema.as_deref(),
+        &options.table_meta.table_name,
+    );
+    let mut statements = Vec::new();
+
+    for row in &options.new_rows {
+        let where_clause = build_save_row_where(options.database_type, &save_columns, row, column_info);
+        if !where_clause.is_empty() {
+            statements
+                .push(data_grid_statement(options.database_type, format!("DELETE FROM {table} WHERE {where_clause}")));
+        }
+    }
+
+    for row_index in &options.deleted_rows {
+        let Some(row) = options.rows.get(*row_index) else {
+            continue;
+        };
+        let insert_pairs: Vec<(&str, &Value)> = save_columns
+            .iter()
+            .enumerate()
+            .filter_map(|(index, column)| Some((column.as_deref()?, row.get(index).unwrap_or(&Value::Null))))
+            .filter(|(column, _)| {
+                !is_grid_insert_omitted_column(
+                    options.database_type,
+                    column_info_for(column_info, column),
+                    Some(column),
+                )
+            })
+            .collect();
+        let columns = insert_pairs
+            .iter()
+            .map(|(column, _)| quote_ident(options.database_type, column))
+            .collect::<Vec<_>>()
+            .join(", ");
+        let values = insert_pairs
+            .iter()
+            .map(|(column, value)| {
+                format_grid_sql_literal(value, options.database_type, column_info_for(column_info, column))
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+        statements.push(data_grid_statement(
+            options.database_type,
+            format!("INSERT INTO {table} ({columns}) VALUES ({values})"),
+        ));
+    }
+
+    for (row_index, changes) in &options.dirty_rows {
+        let Some(row) = options.rows.get(*row_index) else {
+            continue;
+        };
+        let mut after_row = row.clone();
+        for (column_index, value) in changes {
+            if *column_index < after_row.len() {
+                after_row[*column_index] = value.clone();
+            }
+        }
+        let writable_changes: Vec<(&(usize, Value), &str)> = changes
+            .iter()
+            .filter_map(|change @ (column_index, _)| {
+                let column = save_columns.get(*column_index)?.as_deref()?;
+                if is_grid_update_omitted_column(
+                    options.database_type,
+                    column_info_for(column_info, column),
+                    Some(column),
+                    &[],
+                ) {
+                    return None;
+                }
+                Some((change, column))
+            })
+            .collect();
+        let sets = writable_changes
+            .iter()
+            .map(|((column_index, _), column)| {
+                format!(
+                    "{} = {}",
+                    quote_ident(options.database_type, column),
+                    format_grid_sql_literal(
+                        row.get(*column_index).unwrap_or(&Value::Null),
+                        options.database_type,
+                        column_info_for(column_info, column)
+                    )
+                )
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+        if sets.is_empty() {
+            continue;
+        }
+        let mut predicates = vec![build_primary_key_where(
+            options.database_type,
+            &options.table_meta.primary_keys,
+            &save_columns,
+            &after_row,
+            column_info,
+        )];
+        predicates.extend(writable_changes.iter().map(|((_, value), column)| {
+            build_save_column_predicate(
+                options.database_type,
+                column,
+                value,
+                column_info_for(column_info, column),
+                true,
+            )
+        }));
+        statements.push(data_grid_statement(
+            options.database_type,
+            format!(
+                "UPDATE {table} SET {sets} WHERE {}",
+                predicates.into_iter().filter(|part| !part.is_empty()).collect::<Vec<_>>().join(" AND ")
+            ),
+        ));
+    }
+
+    statements
+}
+
+pub(crate) fn effective_columns(options: &DataGridSaveStatementOptions) -> Vec<Option<String>> {
+    match &options.source_columns {
+        Some(source_columns) if source_columns.len() == options.columns.len() => source_columns.clone(),
+        _ => options.columns.iter().map(|column| Some(column.clone())).collect(),
+    }
+}
+
+fn effective_copy_columns(source_columns: Option<&[Option<String>]>, columns: &[String]) -> Vec<Option<String>> {
+    match source_columns {
+        Some(source_columns) if source_columns.len() == columns.len() => source_columns.to_vec(),
+        _ => columns.iter().map(|column| Some(column.clone())).collect(),
+    }
+}
+
+fn copy_column_info(
+    column_info: &[DataGridColumnInfo],
+    column: &str,
+    fallback_type: Option<&str>,
+) -> Option<DataGridColumnInfo> {
+    if let Some(info) = column_info_for(column_info, column) {
+        return Some(info.clone());
+    }
+    fallback_type.map(|data_type| DataGridColumnInfo {
+        name: column.to_string(),
+        data_type: data_type.to_string(),
+        is_nullable: true,
+        is_primary_key: false,
+        column_default: None,
+        extra: None,
+    })
+}
+
+fn effective_column(options: &DataGridSaveStatementOptions, index: usize) -> Option<&str> {
+    match &options.source_columns {
+        Some(source_columns) if source_columns.len() == options.columns.len() => source_columns.get(index)?.as_deref(),
+        _ => options.columns.get(index).map(String::as_str),
+    }
+}
+
+fn data_grid_save_execution_schema(
+    database_type: Option<DatabaseType>,
+    table_meta: &DataGridTableMeta,
+) -> Option<String> {
+    if matches!(database_type, Some(DatabaseType::Neo4j | DatabaseType::Oracle)) {
+        return None;
+    }
+    table_meta.schema.clone()
+}
+
+pub fn normalize_data_grid_save_error(database_type: Option<DatabaseType>, error: &str) -> String {
+    if database_type == Some(DatabaseType::Hive)
+        && (error.contains("Attempt to do update or delete") || error.contains("Error 10294"))
+    {
+        return "Hive UPDATE/DELETE are not enabled for this table or server. Add rows with INSERT, or enable ACID transactional tables in Hive before editing/deleting existing rows.".to_string();
+    }
+    error.to_string()
+}
+
+fn format_grid_copy_insert_sql_literal(
+    value: &Value,
+    database_type: Option<DatabaseType>,
+    column_info: Option<&DataGridColumnInfo>,
+) -> String {
+    if is_oracle_temporal_literal_database(database_type) {
+        if let Some(text) = value.as_str() {
+            if let Some(literal) =
+                format_oracle_temporal_literal(text, column_info.map(|column| column.data_type.as_str()))
+            {
+                return literal;
+            }
+        }
+    }
+    format_grid_sql_literal(value, database_type, column_info)
+}
+
+pub fn format_grid_sql_literal(
+    value: &Value,
+    database_type: Option<DatabaseType>,
+    column_info: Option<&DataGridColumnInfo>,
+) -> String {
+    if value.is_null() {
+        return "NULL".to_string();
+    }
+    // Boolean values on BIT columns always use numeric 0/1.
+    // This covers MySQL, SQL Server, and any other database where BIT
+    // is a numeric/boolean type rather than a bit-string type like
+    // PostgreSQL's bit(n).
+    if let Some(value) = value.as_bool() {
+        if is_bit_literal_column(column_info) {
+            return if value { "1" } else { "0" }.to_string();
+        }
+        return if value { "TRUE" } else { "FALSE" }.to_string();
+    }
+    if is_mysql_bit_literal_column(database_type, column_info) {
+        if let Some(number) = value.as_number() {
+            return number.to_string();
+        }
+        if let Some(text) = value.as_str().and_then(format_mysql_bit_literal_text) {
+            return text;
+        }
+    }
+    if let Some(number) = value.as_number() {
+        return number.to_string();
+    }
+    if let Some(arr) = value.as_array() {
+        if matches!(database_type, Some(DatabaseType::ClickHouse) | Some(DatabaseType::Databend)) {
+            return format_ch_array_sql_literal(arr);
+        }
+        return format_pg_array_sql_literal(arr);
+    }
+    let text = value.as_str().map_or_else(|| value.to_string(), ToString::to_string);
+    if is_mysql_binary_literal_column(database_type, column_info) {
+        if let Some(literal) = format_mysql_binary_literal_text(&text) {
+            // DBX result values expose binary columns as prefixed hex; keep them
+            // as MySQL hex literals so copied INSERT/UPDATE SQL round-trips bytes.
+            return literal;
+        }
+    }
+    if column_info.map(|column| is_numeric_type(&column.data_type)).unwrap_or(false) && is_numeric_literal(&text) {
+        // BigDecimal/BigInteger cells cross JSON-RPC as strings so browsers cannot round them.
+        return text;
+    }
+    if database_type == Some(DatabaseType::ManticoreSearch) {
+        if let Some(typed_value) = manticore_typed_attribute_value(&text, column_info) {
+            return format_grid_sql_literal(&typed_value, database_type, column_info);
+        }
+    }
+    if text.is_empty() {
+        return if database_type == Some(DatabaseType::SqlServer) { "N''" } else { "''" }.to_string();
+    }
+    // MySQL geometry columns: wrap WKT text with ST_GeomFromText()
+    if is_mysql_geometry_literal_database(database_type)
+        && column_info.map(|column| is_geometry_column_type(&column.data_type)).unwrap_or(false)
+    {
+        let escaped = text.replace('\\', "\\\\").replace('\'', "''");
+        return format!("ST_GeomFromText('{}')", escaped);
+    }
+    if is_oracle_temporal_literal_database(database_type) {
+        if let Some(literal) =
+            format_oracle_temporal_literal(&text, column_info.map(|column| column.data_type.as_str()))
+        {
+            return literal;
+        }
+    }
+    let literal_text = if database_type == Some(DatabaseType::Tdengine) {
+        format_tdengine_timestamp_literal_text(&text)
+    } else if database_type == Some(DatabaseType::SqlServer) {
+        crate::sqlserver_temporal::normalize_sqlserver_temporal_literal(
+            &text,
+            column_info.map(|column| column.data_type.as_str()),
+        )
+        .unwrap_or(text)
+    } else if is_mysql_datetime_literal_database(database_type)
+        && column_info.map(|column| is_temporal_column_type(&column.data_type)).unwrap_or(true)
+    {
+        format_mysql_temporal_literal_text(&text, column_info.map(|column| column.data_type.as_str()))
+    } else {
+        text
+    };
+    let escaped = format!("'{}'", literal_text.replace('\\', "\\\\").replace('\'', "''"));
+    if database_type == Some(DatabaseType::SqlServer) {
+        format!("N{escaped}")
+    } else {
+        escaped
+    }
+}
+
+fn format_grid_save_sql_literal(
+    value: &Value,
+    database_type: Option<DatabaseType>,
+    column_info: Option<&DataGridColumnInfo>,
+) -> String {
+    if empty_string_saves_as_null(value, column_info) {
+        "NULL".to_string()
+    } else {
+        format_grid_sql_literal(value, database_type, column_info)
+    }
+}
+
+fn empty_string_saves_as_null(value: &Value, column_info: Option<&DataGridColumnInfo>) -> bool {
+    value.as_str() == Some("")
+        && column_info.is_some_and(|column| column.is_nullable && !is_textual_column_type(&column.data_type))
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum OracleTemporalKind {
+    Date,
+    Timestamp,
+    TimestampWithTimeZone,
+}
+
+fn is_oracle_temporal_literal_database(database_type: Option<DatabaseType>) -> bool {
+    matches!(database_type, Some(DatabaseType::Oracle | DatabaseType::OceanbaseOracle))
+}
+
+fn format_oracle_temporal_literal(text: &str, data_type: Option<&str>) -> Option<String> {
+    let kind = oracle_temporal_column_kind(data_type?)?;
+    let parts = regex_like_oracle_temporal(text)?;
+    let fraction = parts.fraction.as_deref().unwrap_or_default();
+    let datetime = format!("{} {}{}", parts.date, parts.time, fraction);
+    match kind {
+        OracleTemporalKind::Date if oracle_temporal_parts_are_midnight(&parts) => {
+            Some(format!("DATE '{}'", parts.date))
+        }
+        OracleTemporalKind::Date => Some(format!("TO_DATE('{} {}', 'YYYY-MM-DD HH24:MI:SS')", parts.date, parts.time)),
+        OracleTemporalKind::Timestamp => {
+            let mask = oracle_timestamp_format_mask(datetime.contains('.'));
+            Some(format!("TO_TIMESTAMP('{datetime}', '{mask}')"))
+        }
+        OracleTemporalKind::TimestampWithTimeZone => {
+            if parts.zone.is_empty() {
+                let mask = oracle_timestamp_format_mask(datetime.contains('.'));
+                return Some(format!("TO_TIMESTAMP('{datetime}', '{mask}')"));
+            }
+            let zone = oracle_timezone_suffix(&parts.zone);
+            let mask = oracle_timestamp_format_mask(datetime.contains('.'));
+            Some(format!("TO_TIMESTAMP_TZ('{datetime} {zone}', '{mask} TZH:TZM')"))
+        }
+    }
+}
+
+fn oracle_temporal_parts_are_midnight(parts: &Rfc3339Parts) -> bool {
+    parts.time == "00:00:00"
+        && parts
+            .fraction
+            .as_deref()
+            .map(|fraction| fraction.trim_start_matches('.').chars().all(|ch| ch == '0'))
+            .unwrap_or(true)
+}
+
+fn oracle_temporal_column_kind(data_type: &str) -> Option<OracleTemporalKind> {
+    let lower = data_type.trim().to_ascii_lowercase();
+    let base = lower.split(['(', ' ']).next().unwrap_or("");
+    match base {
+        "date" => Some(OracleTemporalKind::Date),
+        "timestamp" if lower.contains("with time zone") || lower.contains("with local time zone") => {
+            Some(OracleTemporalKind::TimestampWithTimeZone)
+        }
+        "timestamp" => Some(OracleTemporalKind::Timestamp),
+        _ => None,
+    }
+}
+
+fn oracle_timestamp_format_mask(has_fraction: bool) -> &'static str {
+    if has_fraction {
+        "YYYY-MM-DD HH24:MI:SS.FF"
+    } else {
+        "YYYY-MM-DD HH24:MI:SS"
+    }
+}
+
+fn oracle_timezone_suffix(zone: &str) -> String {
+    if zone.eq_ignore_ascii_case("z") {
+        "+00:00".to_string()
+    } else {
+        zone.to_string()
+    }
+}
+
+fn regex_like_oracle_temporal(text: &str) -> Option<Rfc3339Parts> {
+    if let Some(parts) = regex_like_rfc3339(text) {
+        return Some(parts);
+    }
+    regex_like_local_datetime(text)
+}
+
+fn regex_like_local_datetime(text: &str) -> Option<Rfc3339Parts> {
+    let bytes = text.as_bytes();
+    if bytes.len() < 10 || bytes.get(4) != Some(&b'-') || bytes.get(7) != Some(&b'-') {
+        return None;
+    }
+    let date = &text[0..10];
+    if bytes.len() == 10 {
+        return Some(Rfc3339Parts {
+            date: date.to_string(),
+            time: "00:00:00".to_string(),
+            fraction: None,
+            zone: String::new(),
+        });
+    }
+    let separator = *bytes.get(10)?;
+    if separator != b'T' && separator != b' ' {
+        return None;
+    }
+    if bytes.len() < 19 || bytes.get(13) != Some(&b':') || bytes.get(16) != Some(&b':') {
+        return None;
+    }
+    let time = &text[11..19];
+    let rest = &text[19..];
+    let fraction = if let Some(rest) = rest.strip_prefix('.') {
+        let digit_count = rest.chars().take_while(|ch| ch.is_ascii_digit()).count();
+        if digit_count == 0 || digit_count > 9 || digit_count != rest.len() {
+            return None;
+        }
+        Some(format!(".{}", &rest[..digit_count]))
+    } else if rest.is_empty() {
+        None
+    } else {
+        return None;
+    };
+    Some(Rfc3339Parts { date: date.to_string(), time: time.to_string(), fraction, zone: String::new() })
+}
+
+fn is_mysql_bit_literal_column(database_type: Option<DatabaseType>, column_info: Option<&DataGridColumnInfo>) -> bool {
+    is_mysql_datetime_literal_database(database_type)
+        && column_info.map(|column| is_bit_column_type(&column.data_type)).unwrap_or(false)
+}
+
+fn is_bit_literal_column(column_info: Option<&DataGridColumnInfo>) -> bool {
+    column_info.map(|column| is_bit_column_type(&column.data_type)).unwrap_or(false)
+}
+
+fn is_bit_column_type(data_type: &str) -> bool {
+    let lower = data_type.to_ascii_lowercase();
+    lower.split(|ch: char| !ch.is_ascii_alphanumeric()).any(|token| {
+        // SQL Server/tiberius reports nullable BIT result columns as `bitn`.
+        // They still need numeric 0/1 literals in generated UPDATE SQL.
+        matches!(token, "bit" | "bitn")
+    })
+}
+
+fn is_mysql_geometry_literal_database(database_type: Option<DatabaseType>) -> bool {
+    matches!(
+        database_type,
+        Some(
+            DatabaseType::Mysql
+                | DatabaseType::Doris
+                | DatabaseType::StarRocks
+                | DatabaseType::Goldendb
+                | DatabaseType::Sundb
+        )
+    )
+}
+
+fn is_mysql_binary_literal_column(
+    database_type: Option<DatabaseType>,
+    column_info: Option<&DataGridColumnInfo>,
+) -> bool {
+    database_type == Some(DatabaseType::Mysql)
+        && column_info.map(|column| is_mysql_binary_column_type(&column.data_type)).unwrap_or(false)
+}
+
+fn is_mysql_binary_column_type(data_type: &str) -> bool {
+    let lower = data_type.trim().to_ascii_lowercase();
+    let base = lower.split(['(', ':', ' ']).next().unwrap_or("").trim();
+    matches!(base, "binary" | "varbinary" | "blob" | "tinyblob" | "mediumblob" | "longblob")
+}
+
+fn format_mysql_binary_literal_text(text: &str) -> Option<String> {
+    let trimmed = text.trim();
+    let hex = trimmed.strip_prefix("0x")?;
+    if hex.chars().all(|ch| ch.is_ascii_hexdigit()) {
+        Some(if hex.is_empty() { "X''".to_string() } else { trimmed.to_string() })
+    } else {
+        None
+    }
+}
+
+fn is_geometry_column_type(data_type: &str) -> bool {
+    let lower = data_type.to_ascii_lowercase();
+    let base = lower.split('(').next().unwrap_or(&lower).trim();
+    matches!(
+        base,
+        "geometry"
+            | "point"
+            | "linestring"
+            | "polygon"
+            | "multipoint"
+            | "multilinestring"
+            | "multipolygon"
+            | "geometrycollection"
+    )
+}
+
+fn manticore_typed_attribute_value(text: &str, column_info: Option<&DataGridColumnInfo>) -> Option<Value> {
+    let data_type = column_info?.data_type.to_ascii_lowercase();
+    if is_boolean_type(&data_type) && text.eq_ignore_ascii_case("true") {
+        return Some(Value::Bool(true));
+    }
+    if is_boolean_type(&data_type) && text.eq_ignore_ascii_case("false") {
+        return Some(Value::Bool(false));
+    }
+    if is_numeric_type(&data_type) && is_numeric_literal(text) {
+        return text.parse::<serde_json::Number>().ok().map(Value::Number);
+    }
+    None
+}
+
+fn format_mysql_bit_literal_text(text: &str) -> Option<String> {
+    let trimmed = text.trim();
+    if trimmed.eq_ignore_ascii_case("true") {
+        return Some("1".to_string());
+    }
+    if trimmed.eq_ignore_ascii_case("false") {
+        return Some("0".to_string());
+    }
+    if trimmed.chars().all(|ch| ch.is_ascii_digit()) && !trimmed.is_empty() {
+        return Some(if trimmed.len() == 1 {
+            trimmed.to_string()
+        } else if trimmed.chars().all(|ch| matches!(ch, '0' | '1')) {
+            format!("b'{trimmed}'")
+        } else {
+            trimmed.to_string()
+        });
+    }
+    let lower = trimmed.to_ascii_lowercase();
+    if lower.starts_with("b'") && trimmed.ends_with('\'') {
+        let bits = &trimmed[2..trimmed.len() - 1];
+        if !bits.is_empty() && bits.chars().all(|ch| matches!(ch, '0' | '1')) {
+            return Some(format!("b'{bits}'"));
+        }
+    }
+    None
+}
+
+fn is_mysql_datetime_literal_database(database_type: Option<DatabaseType>) -> bool {
+    matches!(
+        database_type,
+        Some(
+            DatabaseType::Mysql
+                | DatabaseType::Doris
+                | DatabaseType::StarRocks
+                | DatabaseType::Goldendb
+                | DatabaseType::Sundb
+        )
+    )
+}
+
+fn format_mysql_temporal_literal_text(text: &str, data_type: Option<&str>) -> String {
+    let Some(captures) = regex_like_rfc3339(text) else {
+        return text.to_string();
+    };
+    match temporal_column_kind(data_type) {
+        Some("date") => captures.date,
+        Some("time") => {
+            format!("{}{}", captures.time, normalize_mysql_fractional_seconds(captures.fraction.as_deref()))
+        }
+        _ => format!(
+            "{} {}{}",
+            captures.date,
+            captures.time,
+            normalize_mysql_fractional_seconds(captures.fraction.as_deref())
+        ),
+    }
+}
+
+struct Rfc3339Parts {
+    date: String,
+    time: String,
+    fraction: Option<String>,
+    zone: String,
+}
+
+fn regex_like_rfc3339(text: &str) -> Option<Rfc3339Parts> {
+    let bytes = text.as_bytes();
+    if bytes.len() < 20 || bytes.get(4) != Some(&b'-') || bytes.get(7) != Some(&b'-') {
+        return None;
+    }
+    let separator = *bytes.get(10)?;
+    if separator != b'T' && separator != b' ' {
+        return None;
+    }
+    if bytes.get(13) != Some(&b':') || bytes.get(16) != Some(&b':') {
+        return None;
+    }
+    let date = &text[0..10];
+    let time = &text[11..19];
+    let rest = &text[19..];
+    let (fraction, zone) = if let Some(rest) = rest.strip_prefix('.') {
+        let digit_count = rest.chars().take_while(|ch| ch.is_ascii_digit()).count();
+        if digit_count == 0 || digit_count > 9 {
+            return None;
+        }
+        (Some(format!(".{}", &rest[..digit_count])), &rest[digit_count..])
+    } else {
+        (None, rest)
+    };
+    if zone == "Z" || zone == "z" || is_timezone_offset(zone) {
+        Some(Rfc3339Parts { date: date.to_string(), time: time.to_string(), fraction, zone: zone.to_string() })
+    } else {
+        None
+    }
+}
+
+fn is_timezone_offset(value: &str) -> bool {
+    let bytes = value.as_bytes();
+    bytes.len() == 6
+        && matches!(bytes[0], b'+' | b'-')
+        && bytes[3] == b':'
+        && bytes[1].is_ascii_digit()
+        && bytes[2].is_ascii_digit()
+        && bytes[4].is_ascii_digit()
+        && bytes[5].is_ascii_digit()
+}
+
+fn normalize_mysql_fractional_seconds(fraction: Option<&str>) -> String {
+    match fraction {
+        Some(fraction) if fraction.len() > 7 => fraction[..7].to_string(),
+        Some(fraction) => fraction.to_string(),
+        None => String::new(),
+    }
+}
+
+fn is_temporal_column_type(data_type: &str) -> bool {
+    temporal_column_kind(Some(data_type)).is_some()
+}
+
+fn temporal_column_kind(data_type: Option<&str>) -> Option<&'static str> {
+    let base =
+        data_type.unwrap_or("").trim().to_ascii_lowercase().split(['(', ':', ' ']).next().unwrap_or("").to_string();
+    match base.as_str() {
+        "date" => Some("date"),
+        "time" => Some("time"),
+        "datetime" | "timestamp" => Some("datetime"),
+        _ => None,
+    }
+}
+
+fn format_tdengine_timestamp_literal_text(text: &str) -> String {
+    let Some((date, time, fraction)) = parse_tdengine_timestamp(text) else {
+        return text.to_string();
+    };
+    format!(
+        "{date}T{time}{}{suffix}",
+        normalize_fractional_seconds(fraction.as_deref()),
+        suffix = local_timezone_offset_suffix(text)
+    )
+}
+
+fn parse_tdengine_timestamp(text: &str) -> Option<(String, String, Option<String>)> {
+    if text.len() < 19 {
+        return None;
+    }
+    let bytes = text.as_bytes();
+    if bytes.get(4) != Some(&b'-') || bytes.get(7) != Some(&b'-') || bytes.get(10) != Some(&b' ') {
+        return None;
+    }
+    if bytes.get(13) != Some(&b':') || bytes.get(16) != Some(&b':') {
+        return None;
+    }
+    let date = text[0..10].to_string();
+    let time = text[11..19].to_string();
+    let rest = &text[19..];
+    if rest.is_empty() {
+        return Some((date, time, None));
+    }
+    let fraction = rest.strip_prefix('.')?;
+    if fraction.is_empty() || fraction.len() > 9 || !fraction.chars().all(|ch| ch.is_ascii_digit()) {
+        return None;
+    }
+    Some((date, time, Some(format!(".{fraction}"))))
+}
+
+fn normalize_fractional_seconds(fraction: Option<&str>) -> String {
+    match fraction {
+        Some(fraction) if fraction.len() >= 4 => fraction[..4].to_string(),
+        Some(fraction) => format!("{fraction:0<4}"),
+        None => ".000".to_string(),
+    }
+}
+
+fn local_timezone_offset_suffix(text: &str) -> String {
+    let naive = NaiveDateTime::parse_from_str(&text.replace(' ', "T"), "%Y-%m-%dT%H:%M:%S%.f").ok();
+    let offset_minutes = naive
+        .and_then(|dt| {
+            let local = dt.and_local_timezone(Local).earliest()?;
+            Some(local.offset().local_minus_utc() / -60)
+        })
+        .unwrap_or_else(|| Local::now().offset().local_minus_utc() / -60);
+    let sign = if offset_minutes <= 0 { "+" } else { "-" };
+    let abs = offset_minutes.abs();
+    format!("{sign}{:02}:{:02}", abs / 60, abs % 60)
+}
+
+fn build_primary_key_where(
+    database_type: Option<DatabaseType>,
+    primary_keys: &[String],
+    columns: &[Option<String>],
+    row: &[Value],
+    column_info: &[DataGridColumnInfo],
+) -> String {
+    if primary_keys.is_empty() && uses_keyless_row_predicate(database_type) {
+        return build_row_where(database_type, columns, row, column_info);
+    }
+    primary_keys
+        .iter()
+        .map(|primary_key| {
+            let value = row
+                .get(
+                    columns
+                        .iter()
+                        .position(|column| column.as_deref() == Some(primary_key.as_str()))
+                        .unwrap_or(usize::MAX),
+                )
+                .unwrap_or(&Value::Null);
+            build_column_predicate(database_type, primary_key, value, column_info_for(column_info, primary_key), false)
+        })
+        .collect::<Vec<_>>()
+        .join(" AND ")
+}
+
+fn build_row_where(
+    database_type: Option<DatabaseType>,
+    columns: &[Option<String>],
+    row: &[Value],
+    column_info: &[DataGridColumnInfo],
+) -> String {
+    columns
+        .iter()
+        .enumerate()
+        .filter_map(|(index, column)| {
+            let column = column.as_deref()?;
+            if is_oracle_row_id(database_type, Some(column)) {
+                return None;
+            }
+            Some(build_column_predicate(
+                database_type,
+                column,
+                row.get(index).unwrap_or(&Value::Null),
+                column_info_for(column_info, column),
+                true,
+            ))
+        })
+        .collect::<Vec<_>>()
+        .join(" AND ")
+}
+
+fn build_save_row_where(
+    database_type: Option<DatabaseType>,
+    columns: &[Option<String>],
+    row: &[Value],
+    column_info: &[DataGridColumnInfo],
+) -> String {
+    columns
+        .iter()
+        .enumerate()
+        .filter_map(|(index, column)| {
+            let column = column.as_deref()?;
+            if is_oracle_row_id(database_type, Some(column)) {
+                return None;
+            }
+            Some(build_save_column_predicate(
+                database_type,
+                column,
+                row.get(index).unwrap_or(&Value::Null),
+                column_info_for(column_info, column),
+                true,
+            ))
+        })
+        .collect::<Vec<_>>()
+        .join(" AND ")
+}
+
+fn build_column_predicate(
+    database_type: Option<DatabaseType>,
+    column: &str,
+    value: &Value,
+    column_info: Option<&DataGridColumnInfo>,
+    use_binary_text_comparison: bool,
+) -> String {
+    let ident = predicate_ident(database_type, column);
+    if value.is_null() {
+        format!("{ident} IS NULL")
+    } else if use_binary_text_comparison && uses_mysql_binary_text_predicate(database_type, value, column_info) {
+        format!("BINARY {ident} = {}", format_grid_sql_literal(value, database_type, column_info))
+    } else {
+        format!("{ident} = {}", format_grid_sql_literal(value, database_type, column_info))
+    }
+}
+
+fn build_save_column_predicate(
+    database_type: Option<DatabaseType>,
+    column: &str,
+    value: &Value,
+    column_info: Option<&DataGridColumnInfo>,
+    use_binary_text_comparison: bool,
+) -> String {
+    let ident = predicate_ident(database_type, column);
+    if value.is_null() || empty_string_saves_as_null(value, column_info) {
+        format!("{ident} IS NULL")
+    } else if use_binary_text_comparison && uses_mysql_binary_text_predicate(database_type, value, column_info) {
+        format!("BINARY {ident} = {}", format_grid_save_sql_literal(value, database_type, column_info))
+    } else {
+        format!("{ident} = {}", format_grid_save_sql_literal(value, database_type, column_info))
+    }
+}
+
+fn data_grid_statement(database_type: Option<DatabaseType>, sql: String) -> String {
+    if database_type == Some(DatabaseType::ManticoreSearch) {
+        sql
+    } else {
+        format!("{sql};")
+    }
+}
+
+fn data_grid_update_sql(database_type: Option<DatabaseType>, table: &str, sets: &str, where_clause: &str) -> String {
+    if database_type == Some(DatabaseType::ClickHouse) {
+        format!("ALTER TABLE {table} UPDATE {sets} WHERE {where_clause}")
+    } else {
+        format!("UPDATE {table} SET {sets} WHERE {where_clause}")
+    }
+}
+
+fn data_grid_delete_sql(database_type: Option<DatabaseType>, table: &str, where_clause: &str) -> String {
+    if database_type == Some(DatabaseType::ClickHouse) {
+        format!("ALTER TABLE {table} DELETE WHERE {where_clause}")
+    } else {
+        format!("DELETE FROM {table} WHERE {where_clause}")
+    }
+}
+
+fn uses_mysql_binary_text_predicate(
+    database_type: Option<DatabaseType>,
+    value: &Value,
+    column_info: Option<&DataGridColumnInfo>,
+) -> bool {
+    database_type == Some(DatabaseType::Mysql)
+        && value.is_string()
+        && column_info.map(|column| is_textual_column_type(&column.data_type)).unwrap_or(false)
+}
+
+fn is_textual_column_type(data_type: &str) -> bool {
+    let lower = data_type.trim().to_ascii_lowercase();
+    let base = lower.split(['(', ':', ' ']).next().unwrap_or("").trim();
+    matches!(
+        base,
+        "char"
+            | "character"
+            | "varchar"
+            | "varchar2"
+            | "nvarchar"
+            | "nvarchar2"
+            | "nchar"
+            | "string"
+            | "text"
+            | "tinytext"
+            | "mediumtext"
+            | "longtext"
+            | "ntext"
+            | "clob"
+            | "nclob"
+            | "enum"
+            | "set"
+    ) || lower.starts_with("character varying")
+        || lower.starts_with("national character varying")
+}
+
+fn is_oracle_row_id(database_type: Option<DatabaseType>, name: Option<&str>) -> bool {
+    database_type == Some(DatabaseType::Oracle) && name.is_some_and(|name| name.eq_ignore_ascii_case(DBX_ROWID_COLUMN))
+}
+
+pub(crate) fn is_neo4j_element_id(database_type: Option<DatabaseType>, name: Option<&str>) -> bool {
+    database_type == Some(DatabaseType::Neo4j) && name == Some(DBX_NEO4J_ELEMENT_ID_COLUMN)
+}
+
+fn is_auto_generated_column(column: &DataGridColumnInfo) -> bool {
+    column
+        .extra
+        .as_deref()
+        .unwrap_or("")
+        .to_ascii_lowercase()
+        .split(|ch: char| !ch.is_ascii_alphanumeric() && ch != '_')
+        .any(|part| matches!(part, "auto_increment" | "autoincrement" | "identity"))
+}
+
+fn grid_value_is_empty(value: &Value) -> bool {
+    value.is_null() || value.as_str().is_some_and(str::is_empty)
+}
+
+fn is_grid_insert_omitted_column(
+    database_type: Option<DatabaseType>,
+    column_info: Option<&DataGridColumnInfo>,
+    name: Option<&str>,
+) -> bool {
+    is_oracle_row_id(database_type, name)
+        || is_postgres_tsvector_column(database_type, column_info)
+        || is_non_identity_generated_column(column_info)
+}
+
+fn is_grid_update_omitted_column(
+    database_type: Option<DatabaseType>,
+    column_info: Option<&DataGridColumnInfo>,
+    name: Option<&str>,
+    primary_key_set: &[String],
+) -> bool {
+    is_oracle_row_id(database_type, name)
+        || is_clickhouse_key_column(database_type, column_info, name, primary_key_set)
+        || is_non_identity_generated_column(column_info)
+}
+
+fn is_clickhouse_key_column(
+    database_type: Option<DatabaseType>,
+    column_info: Option<&DataGridColumnInfo>,
+    name: Option<&str>,
+    primary_key_set: &[String],
+) -> bool {
+    if database_type != Some(DatabaseType::ClickHouse) {
+        return false;
+    }
+    column_info.is_some_and(|column| column.is_primary_key)
+        || is_clickhouse_partition_key_column(database_type, column_info)
+        || name.is_some_and(|name| primary_key_set.contains(&normalize_column_name(name)))
+}
+
+fn is_clickhouse_partition_key_column(
+    database_type: Option<DatabaseType>,
+    column_info: Option<&DataGridColumnInfo>,
+) -> bool {
+    database_type == Some(DatabaseType::ClickHouse)
+        && column_info.and_then(|column| column.extra.as_deref()).is_some_and(|extra| {
+            extra.split(|ch: char| !ch.is_ascii_alphanumeric() && ch != '_').any(|part| part == "partition_key")
+        })
+}
+
+fn is_postgres_tsvector_column(database_type: Option<DatabaseType>, column_info: Option<&DataGridColumnInfo>) -> bool {
+    database_type == Some(DatabaseType::Postgres)
+        && column_info.map(|column| is_postgres_tsvector_type(&column.data_type)).unwrap_or(false)
+}
+
+fn is_postgres_tsvector_type(data_type: &str) -> bool {
+    let normalized = data_type.trim().trim_matches('"').to_ascii_lowercase();
+    normalized == "tsvector" || normalized.ends_with(".tsvector")
+}
+
+fn is_non_identity_generated_column(column_info: Option<&DataGridColumnInfo>) -> bool {
+    let extra = column_info.and_then(|column| column.extra.as_deref()).unwrap_or("").to_ascii_lowercase();
+    extra.contains("generated always as") && !extra.contains("identity")
+}
+
+fn is_null_write_to_not_null_column(
+    database_type: Option<DatabaseType>,
+    not_null_columns: &[String],
+    column: Option<&str>,
+    value: &Value,
+) -> bool {
+    let Some(column) = column else {
+        return false;
+    };
+    if is_oracle_row_id(database_type, Some(column)) || is_neo4j_element_id(database_type, Some(column)) {
+        return false;
+    }
+    value.is_null() && not_null_columns.iter().any(|not_null| not_null == &normalize_column_name(column))
+}
+
+fn find_column_index(columns: &[Option<String>], target: &str) -> Option<usize> {
+    let normalized_target = normalize_column_name(target);
+    columns
+        .iter()
+        .position(|column| column.as_deref().map(normalize_column_name).unwrap_or_default() == normalized_target)
+}
+
+fn primary_key_value_key(primary_key_indexes: &[usize], row: &[Value]) -> Option<String> {
+    let values: Vec<Value> =
+        primary_key_indexes.iter().map(|index| row.get(*index).cloned().unwrap_or(Value::Null)).collect();
+    if values.iter().any(Value::is_null) {
+        return None;
+    }
+    serde_json::to_string(&values).ok()
+}
+
+fn duplicate_primary_key_error(
+    primary_keys: &[String],
+    primary_key_indexes: &[usize],
+    row: &[Value],
+    matches_existing_row: bool,
+) -> String {
+    let key_summary = primary_keys
+        .iter()
+        .enumerate()
+        .map(|(index, primary_key)| {
+            format!(
+                "{} = {}",
+                primary_key,
+                format_key_value_for_message(row.get(primary_key_indexes[index]).unwrap_or(&Value::Null))
+            )
+        })
+        .collect::<Vec<_>>()
+        .join(", ");
+    let source = if matches_existing_row { "the existing primary key" } else { "another new row's primary key" };
+    format!("New row duplicates {source} ({key_summary}). Change the key before saving.")
+}
+
+fn format_key_value_for_message(value: &Value) -> String {
+    if value.is_null() {
+        return "NULL".to_string();
+    }
+    if let Some(value) = value.as_str() {
+        return format!("\"{}\"", value.replace('"', "\\\""));
+    }
+    value.to_string()
+}
+
+fn normalize_column_name(name: &str) -> String {
+    name.to_ascii_uppercase()
+}
+
+fn null_write_error(column: &str) -> String {
+    format!("Column \"{column}\" does not allow NULL.")
+}
+
+fn clickhouse_no_mutable_columns_error() -> String {
+    "ClickHouse primary or partition key columns cannot be updated. Change a non-key column before saving.".to_string()
+}
+
+fn predicate_ident(database_type: Option<DatabaseType>, name: &str) -> String {
+    if is_oracle_row_id(database_type, Some(name)) {
+        "ROWIDTOCHAR(ROWID)".to_string()
+    } else {
+        quote_ident(database_type, name)
+    }
+}
+
+pub(crate) fn quote_ident(database_type: Option<DatabaseType>, name: &str) -> String {
+    quote_table_identifier(database_type, name)
+}
+
+pub(crate) fn qualified_table_name(
+    database_type: Option<DatabaseType>,
+    schema: Option<&str>,
+    table_name: &str,
+) -> String {
+    crate::sql_dialect::qualified_table_name(database_type, schema, table_name)
+}
+
+fn column_filter_ref(database_type: Option<DatabaseType>, column_name: &str) -> String {
+    let quoted = quote_ident(database_type, column_name);
+    if database_type == Some(DatabaseType::Neo4j) {
+        format!("n.{quoted}")
+    } else {
+        quoted
+    }
+}
+
+fn column_like_filter_ref(
+    database_type: Option<DatabaseType>,
+    column_name: &str,
+    column_info: Option<&DataGridColumnInfo>,
+) -> String {
+    let column = column_filter_ref(database_type, column_name);
+    if is_postgres_like_pattern_database(database_type)
+        && column_info.map(|column_info| !is_textual_column_type(&column_info.data_type)).unwrap_or(true)
+    {
+        format!("{column}::text")
+    } else {
+        column
+    }
+}
+
+fn is_postgres_like_pattern_database(database_type: Option<DatabaseType>) -> bool {
+    matches!(
+        database_type,
+        Some(
+            DatabaseType::Postgres
+                | DatabaseType::Redshift
+                | DatabaseType::Gaussdb
+                | DatabaseType::Kwdb
+                | DatabaseType::Kingbase
+                | DatabaseType::Highgo
+                | DatabaseType::Vastbase
+                | DatabaseType::OpenGauss
+        )
+    )
+}
+
+fn value_to_filter_text(value: &Value) -> String {
+    if let Some(value) = value.as_str() {
+        value.to_string()
+    } else if value.is_null() {
+        String::new()
+    } else {
+        value.to_string()
+    }
+}
+
+fn parse_typed_filter_value(text: &str, column_info: Option<&DataGridColumnInfo>) -> Value {
+    let unquoted = unwrap_matching_quotes(text);
+    let data_type = column_info.map(|column| column.data_type.to_ascii_lowercase()).unwrap_or_default();
+    if is_boolean_type(&data_type) && unquoted.eq_ignore_ascii_case("true") {
+        return Value::Bool(true);
+    }
+    if is_boolean_type(&data_type) && unquoted.eq_ignore_ascii_case("false") {
+        return Value::Bool(false);
+    }
+    if (is_numeric_type(&data_type) || data_type.is_empty()) && is_numeric_literal(&unquoted) {
+        if let Ok(number) = unquoted.parse::<serde_json::Number>() {
+            return Value::Number(number);
+        }
+    }
+    Value::String(unquoted)
+}
+
+fn unwrap_matching_quotes(text: &str) -> String {
+    let mut chars = text.chars();
+    let Some(first) = chars.next() else {
+        return String::new();
+    };
+    let Some(last) = text.chars().last() else {
+        return String::new();
+    };
+    if text.len() >= 2 && ((first == '\'' && last == '\'') || (first == '"' && last == '"')) {
+        text[1..text.len() - 1].to_string()
+    } else {
+        text.to_string()
+    }
+}
+
+fn is_numeric_type(data_type: &str) -> bool {
+    let lower = data_type.to_ascii_lowercase();
+    [
+        "int",
+        "integer",
+        "bigint",
+        "smallint",
+        "tinyint",
+        "mediumint",
+        "serial",
+        "number",
+        "numeric",
+        "decimal",
+        "float",
+        "double",
+        "real",
+        "money",
+    ]
+    .iter()
+    .any(|part| lower.split(|ch: char| !ch.is_ascii_alphanumeric()).any(|token| token == *part))
+}
+
+fn is_boolean_type(data_type: &str) -> bool {
+    let lower = data_type.to_ascii_lowercase();
+    lower
+        .split(|ch: char| !ch.is_ascii_alphanumeric())
+        .any(|token| matches!(token, "bool" | "boolean" | "bit" | "bitn"))
+}
+
+fn is_numeric_literal(text: &str) -> bool {
+    if text.trim() != text || text.is_empty() {
+        return false;
+    }
+    text.parse::<f64>().is_ok_and(f64::is_finite)
+        && text.chars().all(|ch| ch.is_ascii_digit() || matches!(ch, '+' | '-' | '.' | 'e' | 'E'))
+        && text.chars().any(|ch| ch.is_ascii_digit())
+}
+
+fn uses_keyless_row_predicate(database_type: Option<DatabaseType>) -> bool {
+    matches!(
+        database_type,
+        Some(
+            DatabaseType::Mysql
+                | DatabaseType::ManticoreSearch
+                | DatabaseType::Postgres
+                | DatabaseType::Sqlite
+                | DatabaseType::Rqlite
+                | DatabaseType::Turso
+                | DatabaseType::CloudflareD1
+                | DatabaseType::DuckDb
+                | DatabaseType::SqlServer
+                | DatabaseType::Oracle
+                | DatabaseType::Doris
+                | DatabaseType::StarRocks
+                | DatabaseType::Redshift
+                | DatabaseType::Dameng
+                | DatabaseType::Gaussdb
+                | DatabaseType::Kwdb
+                | DatabaseType::Kingbase
+                | DatabaseType::Highgo
+                | DatabaseType::Vastbase
+                | DatabaseType::Goldendb
+                | DatabaseType::Yashandb
+                | DatabaseType::Oscar
+                | DatabaseType::Databricks
+                | DatabaseType::SapHana
+                | DatabaseType::Teradata
+                | DatabaseType::Vertica
+                | DatabaseType::Firebird
+                | DatabaseType::Exasol
+                | DatabaseType::OpenGauss
+                | DatabaseType::Questdb
+                | DatabaseType::OceanbaseOracle
+                | DatabaseType::Gbase
+                | DatabaseType::Access
+                | DatabaseType::H2
+                | DatabaseType::Snowflake
+                | DatabaseType::Db2
+                | DatabaseType::Informix
+                | DatabaseType::Bigquery
+                | DatabaseType::Sundb
+                | DatabaseType::Databend
+                | DatabaseType::Hive
+                | DatabaseType::Iris
+        )
+    )
+}
+
+pub(crate) fn column_info_for<'a>(columns: &'a [DataGridColumnInfo], name: &str) -> Option<&'a DataGridColumnInfo> {
+    let normalized = normalize_column_name(name);
+    columns.iter().find(|column| normalize_column_name(&column.name) == normalized)
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    fn column(name: &str, data_type: &str, nullable: bool, extra: Option<&str>) -> DataGridColumnInfo {
+        DataGridColumnInfo {
+            name: name.to_string(),
+            data_type: data_type.to_string(),
+            is_nullable: nullable,
+            is_primary_key: false,
+            column_default: None,
+            extra: extra.map(ToString::to_string),
+        }
+    }
+
+    #[test]
+    fn builds_copy_update_statements() {
+        let statements = build_data_grid_copy_update_statements(DataGridCopyUpdateStatementOptions {
+            database_type: Some(DatabaseType::Postgres),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("public".to_string()),
+                table_name: "users".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: None,
+            },
+            columns: vec!["id".to_string(), "name".to_string(), "status".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("Ada"), json!("active")]],
+        });
+        assert_eq!(
+            statements,
+            vec!["UPDATE \"public\".\"users\" SET \"name\" = 'Ada', \"status\" = 'active' WHERE \"id\" = 1;"]
+        );
+    }
+
+    #[test]
+    fn builds_copy_insert_statement_without_primary_keys() {
+        let statement = build_data_grid_copy_insert_statement(DataGridCopyInsertStatementOptions {
+            database_type: Some(DatabaseType::Mysql),
+            table_meta: Some(DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "users".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: None,
+            }),
+            columns: vec!["id".to_string(), "login_name".to_string(), "display_name".to_string()],
+            column_types: None,
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("ada"), json!("Ada")], vec![json!(2), json!("linus"), json!("Linus")]],
+            exclude_primary_keys: true,
+            insert_mode: DataGridCopyInsertMode::Merged,
+        });
+        assert_eq!(
+            statement.as_deref(),
+            Some("INSERT INTO `users` (`login_name`, `display_name`) VALUES\n('ada', 'Ada'),\n('linus', 'Linus');")
+        );
+    }
+
+    #[test]
+    fn builds_copy_insert_statement_row_by_row() {
+        let statement = build_data_grid_copy_insert_statement(DataGridCopyInsertStatementOptions {
+            database_type: Some(DatabaseType::Mysql),
+            table_meta: Some(DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "users".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: None,
+            }),
+            columns: vec!["id".to_string(), "login_name".to_string(), "display_name".to_string()],
+            column_types: None,
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("ada"), json!("Ada")], vec![json!(2), json!("linus"), json!("Linus")]],
+            exclude_primary_keys: false,
+            insert_mode: DataGridCopyInsertMode::RowByRow,
+        });
+        assert_eq!(
+            statement.as_deref(),
+            Some(
+                "INSERT INTO `users` (`id`, `login_name`, `display_name`) VALUES (1, 'ada', 'Ada');\nINSERT INTO `users` (`id`, `login_name`, `display_name`) VALUES (2, 'linus', 'Linus');"
+            )
+        );
+    }
+
+    #[test]
+    fn oracle_copy_insert_statement_uses_one_statement_per_row() {
+        let statement = build_data_grid_copy_insert_statement(DataGridCopyInsertStatementOptions {
+            database_type: Some(DatabaseType::Oracle),
+            table_meta: Some(DataGridTableMeta {
+                catalog: None,
+                schema: Some("APP".to_string()),
+                table_name: "USERS".to_string(),
+                primary_keys: vec!["ID".to_string()],
+                columns: None,
+            }),
+            columns: vec!["ID".to_string(), "NAME".to_string()],
+            column_types: None,
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("Ada")], vec![json!(2), json!("Linus")]],
+            exclude_primary_keys: false,
+            insert_mode: DataGridCopyInsertMode::Merged,
+        });
+
+        assert_eq!(
+            statement.as_deref(),
+            Some("INSERT INTO \"APP\".\"USERS\" (\"ID\", \"NAME\") VALUES (1, 'Ada');\nINSERT INTO \"APP\".\"USERS\" (\"ID\", \"NAME\") VALUES (2, 'Linus');")
+        );
+    }
+
+    #[test]
+    fn mysql_copy_statements_preserve_blob_hex_literals() {
+        let table_meta = DataGridTableMeta {
+            catalog: None,
+            schema: None,
+            table_name: "reports".to_string(),
+            primary_keys: vec!["id".to_string()],
+            columns: Some(vec![column("id", "int", false, None), column("payload", "MEDIUMBLOB", true, None)]),
+        };
+        let columns = vec!["id".to_string(), "payload".to_string()];
+        let rows = vec![vec![json!(1), json!("0x0001abff")], vec![json!(2), json!("0x")]];
+
+        let insert = build_data_grid_copy_insert_statement(DataGridCopyInsertStatementOptions {
+            database_type: Some(DatabaseType::Mysql),
+            table_meta: Some(table_meta.clone()),
+            columns: columns.clone(),
+            column_types: None,
+            source_columns: None,
+            rows: rows.clone(),
+            exclude_primary_keys: false,
+            insert_mode: DataGridCopyInsertMode::Merged,
+        });
+        assert_eq!(
+            insert.as_deref(),
+            Some("INSERT INTO `reports` (`id`, `payload`) VALUES\n(1, 0x0001abff),\n(2, X'');")
+        );
+
+        let updates = build_data_grid_copy_update_statements(DataGridCopyUpdateStatementOptions {
+            database_type: Some(DatabaseType::Mysql),
+            table_meta,
+            columns,
+            source_columns: None,
+            rows,
+        });
+        assert_eq!(
+            updates,
+            vec![
+                "UPDATE `reports` SET `payload` = 0x0001abff WHERE `id` = 1;",
+                "UPDATE `reports` SET `payload` = X'' WHERE `id` = 2;"
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_text_columns_keep_prefixed_hex_strings_quoted() {
+        assert_eq!(
+            format_grid_sql_literal(
+                &json!("0x0001abff"),
+                Some(DatabaseType::Mysql),
+                Some(&column("note", "varchar(64)", true, None)),
+            ),
+            "'0x0001abff'"
+        );
+        assert_eq!(
+            format_grid_sql_literal(
+                &json!("0xnothex"),
+                Some(DatabaseType::Mysql),
+                Some(&column("payload", "blob", true, None)),
+            ),
+            "'0xnothex'"
+        );
+    }
+
+    #[test]
+    fn builds_copy_insert_statement_omits_postgres_tsvector_columns() {
+        let statement = build_data_grid_copy_insert_statement(DataGridCopyInsertStatementOptions {
+            database_type: Some(DatabaseType::Postgres),
+            table_meta: Some(DataGridTableMeta {
+                catalog: None,
+                schema: Some("public".to_string()),
+                table_name: "articles".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![
+                    column("id", "integer", false, None),
+                    column("title", "text", false, None),
+                    column("search_vector", "tsvector", true, None),
+                ]),
+            }),
+            columns: vec!["id".to_string(), "title".to_string(), "search_vector".to_string()],
+            column_types: None,
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("Hello"), json!("'hello':1A")]],
+            exclude_primary_keys: false,
+            insert_mode: DataGridCopyInsertMode::Merged,
+        });
+
+        assert_eq!(
+            statement.as_deref(),
+            Some("INSERT INTO \"public\".\"articles\" (\"id\", \"title\") VALUES (1, 'Hello');")
+        );
+    }
+
+    #[test]
+    fn oracle_copy_insert_uses_result_column_types_for_date_literals() {
+        let statement = build_data_grid_copy_insert_statement(DataGridCopyInsertStatementOptions {
+            database_type: Some(DatabaseType::Oracle),
+            table_meta: None,
+            columns: vec!["ID".to_string(), "CREATED_ON".to_string(), "RAW_TEXT".to_string()],
+            column_types: Some(vec![
+                Some("NUMBER".to_string()),
+                Some("DATE".to_string()),
+                Some("VARCHAR2".to_string()),
+            ]),
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("2022-08-25T09:58:43Z"), json!("2022-08-25T09:58:43Z")]],
+            exclude_primary_keys: false,
+            insert_mode: DataGridCopyInsertMode::Merged,
+        });
+
+        assert_eq!(
+            statement.as_deref(),
+            Some("INSERT INTO table_name (\"ID\", \"CREATED_ON\", \"RAW_TEXT\") VALUES (1, TO_DATE('2022-08-25 09:58:43', 'YYYY-MM-DD HH24:MI:SS'), '2022-08-25T09:58:43Z');")
+        );
+    }
+
+    #[test]
+    fn builds_filter_conditions() {
+        assert_eq!(
+            build_data_grid_column_value_filter_condition(DataGridColumnValueFilterConditionOptions {
+                database_type: Some(DatabaseType::Mysql),
+                column_name: "id".to_string(),
+                column_info: Some(column("id", "int", false, None)),
+                raw_value: "49436".to_string(),
+            })
+            .as_deref(),
+            Some("`id` = 49436")
+        );
+        assert_eq!(
+            build_data_grid_context_filter_condition(DataGridContextFilterConditionOptions {
+                database_type: Some(DatabaseType::Postgres),
+                column_name: "status".to_string(),
+                mode: DataGridContextFilterMode::Like,
+                value: json!("active"),
+                column_info: Some(column("status", "varchar", true, None)),
+            })
+            .as_deref(),
+            Some("\"status\" LIKE '%active%'")
+        );
+        assert_eq!(
+            build_data_grid_context_filter_condition(DataGridContextFilterConditionOptions {
+                database_type: Some(DatabaseType::Postgres),
+                column_name: "update_date".to_string(),
+                mode: DataGridContextFilterMode::Like,
+                value: json!("128"),
+                column_info: Some(column("update_date", "bigint", false, None)),
+            })
+            .as_deref(),
+            Some("\"update_date\"::text LIKE '%128%'")
+        );
+        assert_eq!(
+            build_data_grid_context_filter_condition(DataGridContextFilterConditionOptions {
+                database_type: Some(DatabaseType::Postgres),
+                column_name: "created_at".to_string(),
+                mode: DataGridContextFilterMode::NotLike,
+                value: json!("2026"),
+                column_info: Some(column("created_at", "timestamp without time zone", false, None)),
+            })
+            .as_deref(),
+            Some("\"created_at\"::text NOT LIKE '%2026%'")
+        );
+        assert_eq!(
+            build_data_grid_column_value_filter_condition(DataGridColumnValueFilterConditionOptions {
+                database_type: Some(DatabaseType::SqlServer),
+                column_name: "active".to_string(),
+                column_info: Some(column("active", "bitn", false, None)),
+                raw_value: "false".to_string(),
+            })
+            .as_deref(),
+            Some("[active] = 0")
+        );
+    }
+
+    #[test]
+    fn builds_multi_value_filter_conditions() {
+        assert_eq!(
+            build_data_grid_column_values_filter_condition(DataGridColumnValuesFilterConditionOptions {
+                database_type: Some(DatabaseType::Postgres),
+                column_name: "status".to_string(),
+                column_info: Some(column("status", "varchar", true, None)),
+                values: vec![json!("active"), json!("pending"), Value::Null, json!("active")],
+            })
+            .as_deref(),
+            Some("(\"status\" IS NULL OR \"status\" IN ('active', 'pending'))")
+        );
+        assert_eq!(
+            build_data_grid_column_values_filter_condition(DataGridColumnValuesFilterConditionOptions {
+                database_type: Some(DatabaseType::Mysql),
+                column_name: "id".to_string(),
+                column_info: Some(column("id", "int", false, None)),
+                values: vec![json!(42)],
+            })
+            .as_deref(),
+            Some("`id` = 42")
+        );
+    }
+
+    #[test]
+    fn builds_column_distinct_values_sql() {
+        assert_eq!(
+            build_data_grid_column_distinct_values_sql(DataGridColumnDistinctValuesSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                catalog: None,
+                schema: Some("public".to_string()),
+                table_name: "users".to_string(),
+                column_name: "status".to_string(),
+                column_info: Some(column("status", "varchar", true, None)),
+                where_input: Some("WHERE deleted_at IS NULL;".to_string()),
+                search_value: Some("act".to_string()),
+                limit: None,
+                include_counts: true,
+            }),
+            "SELECT \"status\" AS dbx_value, COUNT(*) AS dbx_count FROM \"public\".\"users\" WHERE (deleted_at IS NULL) AND \"status\" LIKE '%act%' GROUP BY \"status\" ORDER BY dbx_count DESC, dbx_value LIMIT 1000"
+        );
+        assert_eq!(
+            build_data_grid_column_distinct_values_sql(DataGridColumnDistinctValuesSqlOptions {
+                database_type: Some(DatabaseType::SqlServer),
+                catalog: None,
+                schema: None,
+                table_name: "users".to_string(),
+                column_name: "status".to_string(),
+                column_info: Some(column("status", "nvarchar", true, None)),
+                where_input: None,
+                search_value: None,
+                limit: Some(25),
+                include_counts: false,
+            }),
+            "SELECT TOP (25) [status] AS dbx_value FROM [users] GROUP BY [status] ORDER BY dbx_value"
+        );
+        assert_eq!(
+            build_data_grid_column_distinct_values_sql(DataGridColumnDistinctValuesSqlOptions {
+                database_type: Some(DatabaseType::SqlServer),
+                catalog: None,
+                schema: None,
+                table_name: "users".to_string(),
+                column_name: "id".to_string(),
+                column_info: Some(column("id", "int", false, None)),
+                where_input: None,
+                search_value: Some("42".to_string()),
+                limit: Some(25),
+                include_counts: true,
+            }),
+            "SELECT TOP (25) [id] AS dbx_value, COUNT(*) AS dbx_count FROM [users] WHERE [id] = 42 GROUP BY [id] ORDER BY dbx_count DESC, dbx_value"
+        );
+        assert_eq!(
+            build_data_grid_column_distinct_values_sql(DataGridColumnDistinctValuesSqlOptions {
+                database_type: Some(DatabaseType::Oracle),
+                catalog: None,
+                schema: Some("APP".to_string()),
+                table_name: "EVENTS".to_string(),
+                column_name: "KIND".to_string(),
+                column_info: Some(column("KIND", "VARCHAR2", true, None)),
+                where_input: None,
+                search_value: None,
+                limit: Some(10),
+                include_counts: true,
+            }),
+            "SELECT * FROM (SELECT \"KIND\" AS dbx_value, COUNT(*) AS dbx_count FROM \"APP\".\"EVENTS\" GROUP BY \"KIND\" ORDER BY dbx_count DESC, dbx_value) WHERE ROWNUM <= 10"
+        );
+        assert_eq!(
+            build_data_grid_column_distinct_values_sql(DataGridColumnDistinctValuesSqlOptions {
+                database_type: Some(DatabaseType::Firebird),
+                catalog: None,
+                schema: None,
+                table_name: "USERS".to_string(),
+                column_name: "STATUS".to_string(),
+                column_info: Some(column("STATUS", "varchar(32)", true, None)),
+                where_input: Some("WHERE DELETED_AT IS NULL".to_string()),
+                search_value: None,
+                limit: Some(25),
+                include_counts: false,
+            }),
+            "SELECT \"STATUS\" AS dbx_value FROM \"USERS\" WHERE (DELETED_AT IS NULL) GROUP BY \"STATUS\" ORDER BY dbx_value ROWS 25"
+        );
+        // Doris / StarRocks external-catalog tables are addressed with a 3-part name.
+        assert_eq!(
+            build_data_grid_column_distinct_values_sql(DataGridColumnDistinctValuesSqlOptions {
+                database_type: Some(DatabaseType::Doris),
+                catalog: Some("iceberg_catalog".to_string()),
+                schema: Some("sales".to_string()),
+                table_name: "orders".to_string(),
+                column_name: "status".to_string(),
+                column_info: Some(column("status", "varchar", true, None)),
+                where_input: None,
+                search_value: None,
+                limit: Some(10),
+                include_counts: false,
+            }),
+            "SELECT `status` AS dbx_value FROM `iceberg_catalog`.`sales`.`orders` GROUP BY `status` ORDER BY dbx_value LIMIT 10"
+        );
+        assert_eq!(
+            build_data_grid_column_distinct_values_sql(DataGridColumnDistinctValuesSqlOptions {
+                database_type: Some(DatabaseType::StarRocks),
+                catalog: Some("hive_catalog".to_string()),
+                schema: None,
+                table_name: "orders".to_string(),
+                column_name: "status".to_string(),
+                column_info: Some(column("status", "varchar", true, None)),
+                where_input: None,
+                search_value: None,
+                limit: Some(10),
+                include_counts: true,
+            }),
+            "SELECT `status` AS dbx_value, COUNT(*) AS dbx_count FROM `hive_catalog`.`orders` GROUP BY `status` ORDER BY dbx_count DESC, dbx_value LIMIT 10"
+        );
+        // The built-in `internal` catalog is never prefixed.
+        assert_eq!(
+            build_data_grid_column_distinct_values_sql(DataGridColumnDistinctValuesSqlOptions {
+                database_type: Some(DatabaseType::Doris),
+                catalog: Some("internal".to_string()),
+                schema: None,
+                table_name: "orders".to_string(),
+                column_name: "status".to_string(),
+                column_info: Some(column("status", "varchar", true, None)),
+                where_input: None,
+                search_value: None,
+                limit: Some(10),
+                include_counts: false,
+            }),
+            "SELECT `status` AS dbx_value FROM `orders` GROUP BY `status` ORDER BY dbx_value LIMIT 10"
+        );
+    }
+
+    #[test]
+    fn builds_grid_count_sql() {
+        assert_eq!(
+            build_data_grid_count_sql(DataGridCountSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                catalog: None,
+                schema: Some("public".to_string()),
+                table_name: "users".to_string(),
+                where_input: Some("WHERE active = true;".to_string()),
+            }),
+            "SELECT COUNT(*) AS cnt FROM \"public\".\"users\" WHERE (active = true)"
+        );
+        assert_eq!(
+            build_data_grid_count_sql(DataGridCountSqlOptions {
+                database_type: Some(DatabaseType::Doris),
+                catalog: Some("iceberg_catalog".to_string()),
+                schema: Some("sales".to_string()),
+                table_name: "orders".to_string(),
+                where_input: Some("WHERE active = true;".to_string()),
+            }),
+            "SELECT COUNT(*) AS cnt FROM `iceberg_catalog`.`sales`.`orders` WHERE (active = true)"
+        );
+        assert_eq!(
+            build_data_grid_count_sql(DataGridCountSqlOptions {
+                database_type: Some(DatabaseType::StarRocks),
+                catalog: Some("hive_catalog".to_string()),
+                schema: None,
+                table_name: "orders".to_string(),
+                where_input: None,
+            }),
+            "SELECT COUNT(*) AS cnt FROM `hive_catalog`.`orders`"
+        );
+    }
+
+    #[test]
+    fn builds_hive_table_properties_sql() {
+        assert_eq!(
+            build_hive_table_properties_sql(HiveTablePropertiesSqlOptions {
+                schema: Some("default".to_string()),
+                table_name: "events".to_string(),
+                property_name: "transactional".to_string(),
+            }),
+            "SHOW TBLPROPERTIES `default`.`events` ('transactional')"
+        );
+    }
+
+    #[test]
+    fn formats_temporal_copy_literals() {
+        assert_eq!(
+            format_grid_sql_literal(&json!("2026-05-12T00:00:00+00:00"), Some(DatabaseType::Mysql), None),
+            "'2026-05-12 00:00:00'"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("2026-05-12T00:00:00.123456Z"), Some(DatabaseType::Mysql), None),
+            "'2026-05-12 00:00:00.123456'"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("2026-05-12 00:00:00.123456"), Some(DatabaseType::Mysql), None),
+            "'2026-05-12 00:00:00.123456'"
+        );
+    }
+
+    #[test]
+    fn formats_sqlserver_datetime_copy_literals_with_supported_precision() {
+        let datetime = column("date1", "datetime", true, None);
+        let datetime2 = column("date2", "datetime2(7)", true, None);
+        let raw_text = column("note", "nvarchar(64)", true, None);
+
+        assert_eq!(
+            format_grid_sql_literal(
+                &json!("2026-06-29 10:11:12.896666666"),
+                Some(DatabaseType::SqlServer),
+                Some(&datetime)
+            ),
+            "N'2026-06-29 10:11:12.897'"
+        );
+        assert_eq!(
+            format_grid_sql_literal(
+                &json!("2026-06-29 10:11:12.8966666"),
+                Some(DatabaseType::SqlServer),
+                Some(&datetime2)
+            ),
+            "N'2026-06-29 10:11:12.8966666'"
+        );
+        assert_eq!(
+            format_grid_sql_literal(
+                &json!("2026-06-29 10:11:12.123456"),
+                Some(DatabaseType::SqlServer),
+                Some(&datetime2)
+            ),
+            "N'2026-06-29 10:11:12.1234560'"
+        );
+        assert_eq!(
+            format_grid_sql_literal(
+                &json!("2026-06-29 10:11:12.896666666"),
+                Some(DatabaseType::SqlServer),
+                Some(&raw_text)
+            ),
+            "N'2026-06-29 10:11:12.896666666'"
+        );
+    }
+
+    #[test]
+    fn formats_oracle_temporal_literals_without_nls_parsing() {
+        let timestamp = column("created_at", "TIMESTAMP(6)", true, None);
+        let timestamp_tz = column("recorded_at", "TIMESTAMP(6) WITH TIME ZONE", true, None);
+        let timestamp_ltz = column("local_recorded_at", "TIMESTAMP(6) WITH LOCAL TIME ZONE", true, None);
+        let date = column("event_day", "DATE", true, None);
+        let text = column("raw_text", "VARCHAR2(64)", true, None);
+
+        assert_eq!(
+            format_grid_sql_literal(&json!("2022-08-25T09:58:43Z"), Some(DatabaseType::Oracle), Some(&timestamp)),
+            "TO_TIMESTAMP('2022-08-25 09:58:43', 'YYYY-MM-DD HH24:MI:SS')"
+        );
+        assert_eq!(
+            format_grid_sql_literal(
+                &json!("2022-08-25T09:58:43.123456+08:00"),
+                Some(DatabaseType::Oracle),
+                Some(&timestamp_tz)
+            ),
+            "TO_TIMESTAMP_TZ('2022-08-25 09:58:43.123456 +08:00', 'YYYY-MM-DD HH24:MI:SS.FF TZH:TZM')"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("2022-08-25T09:58:43Z"), Some(DatabaseType::Oracle), Some(&timestamp_ltz)),
+            "TO_TIMESTAMP_TZ('2022-08-25 09:58:43 +00:00', 'YYYY-MM-DD HH24:MI:SS TZH:TZM')"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("2022-08-25T09:58:43Z"), Some(DatabaseType::Oracle), Some(&date)),
+            "TO_DATE('2022-08-25 09:58:43', 'YYYY-MM-DD HH24:MI:SS')"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("2022-08-25T09:58:43Z"), Some(DatabaseType::Oracle), Some(&text)),
+            "'2022-08-25T09:58:43Z'"
+        );
+    }
+
+    #[test]
+    fn formats_oracle_temporal_literals_from_editor_values_without_nls_parsing() {
+        let timestamp = column("created_at", "TIMESTAMP(6)", true, None);
+        let date = column("event_day", "DATE", true, None);
+
+        assert_eq!(
+            format_grid_sql_literal(&json!("2022-08-25 09:58:43"), Some(DatabaseType::Oracle), Some(&timestamp)),
+            "TO_TIMESTAMP('2022-08-25 09:58:43', 'YYYY-MM-DD HH24:MI:SS')"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("2022-08-25 09:58:43.123456"), Some(DatabaseType::Oracle), Some(&timestamp)),
+            "TO_TIMESTAMP('2022-08-25 09:58:43.123456', 'YYYY-MM-DD HH24:MI:SS.FF')"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("2022-08-25 09:58:43.654321"), Some(DatabaseType::Oracle), Some(&timestamp)),
+            "TO_TIMESTAMP('2022-08-25 09:58:43.654321', 'YYYY-MM-DD HH24:MI:SS.FF')"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("2022-08-25 09:58:43"), Some(DatabaseType::Oracle), Some(&date)),
+            "TO_DATE('2022-08-25 09:58:43', 'YYYY-MM-DD HH24:MI:SS')"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("2022-08-25"), Some(DatabaseType::Oracle), Some(&date)),
+            "DATE '2022-08-25'"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("2022-08-25T00:00:00Z"), Some(DatabaseType::Oracle), Some(&date)),
+            "DATE '2022-08-25'"
+        );
+    }
+
+    #[test]
+    fn formats_numeric_string_literals_for_numeric_columns_without_quotes() {
+        let number = column("amount", "NUMBER(20,0)", true, None);
+        let text = column("code", "VARCHAR2(32)", true, None);
+
+        assert_eq!(
+            format_grid_sql_literal(&json!("12345678901234567890"), Some(DatabaseType::Oracle), Some(&number)),
+            "12345678901234567890"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("12345678901234567890"), Some(DatabaseType::Oracle), Some(&text)),
+            "'12345678901234567890'"
+        );
+        assert_eq!(
+            format_grid_sql_literal(&json!("123-not-a-number"), Some(DatabaseType::Oracle), Some(&number)),
+            "'123-not-a-number'"
+        );
+    }
+
+    #[test]
+    fn prepares_sqlserver_bigint_update_from_numeric_string() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::SqlServer),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbo".to_string()),
+                table_name: "users".to_string(),
+                primary_keys: vec!["Id".to_string()],
+                columns: Some(vec![column("Id", "int", false, None), column("UserId", "bigint", true, None)]),
+            },
+            columns: vec!["Id".to_string(), "UserId".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!(142189065666650_i64)]],
+            dirty_rows: vec![(0, vec![(1, json!("144847503924137986"))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(result.statements, vec!["UPDATE [dbo].[users] SET [UserId] = 144847503924137986 WHERE [Id] = 1;"]);
+    }
+
+    #[test]
+    fn prepares_oracle_timestamp_insert_from_iso_grid_value() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Oracle),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("APP".to_string()),
+                table_name: "EVENTS".to_string(),
+                primary_keys: vec!["ID".to_string()],
+                columns: Some(vec![
+                    column("ID", "NUMBER", false, None),
+                    column("CREATED_AT", "TIMESTAMP(6)", true, None),
+                ]),
+            },
+            columns: vec!["ID".to_string(), "CREATED_AT".to_string()],
+            source_columns: None,
+            rows: vec![],
+            dirty_rows: vec![],
+            deleted_rows: vec![],
+            new_rows: vec![vec![json!(1), json!("2022-08-25T09:58:43Z")]],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(
+            result.statements,
+            vec![
+                "INSERT INTO \"APP\".\"EVENTS\" (\"ID\", \"CREATED_AT\") VALUES (1, TO_TIMESTAMP('2022-08-25 09:58:43', 'YYYY-MM-DD HH24:MI:SS'));"
+            ]
+        );
+    }
+
+    #[test]
+    fn formats_mysql_bit_literals_without_string_quotes() {
+        let bit = column("flag", "bit(1)", true, None);
+        let bit_string = column("flags", "bit(8)", true, None);
+
+        assert_eq!(format_grid_sql_literal(&json!("0"), Some(DatabaseType::Mysql), Some(&bit)), "0");
+        assert_eq!(format_grid_sql_literal(&json!("1"), Some(DatabaseType::Mysql), Some(&bit)), "1");
+        assert_eq!(format_grid_sql_literal(&json!(true), Some(DatabaseType::Mysql), Some(&bit)), "1");
+        assert_eq!(
+            format_grid_sql_literal(&json!("10101010"), Some(DatabaseType::Mysql), Some(&bit_string)),
+            "b'10101010'"
+        );
+        assert_eq!(format_grid_sql_literal(&json!("0"), Some(DatabaseType::Postgres), Some(&bit)), "'0'");
+    }
+
+    #[test]
+    fn prepares_sqlserver_bitn_updates_with_numeric_literals() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::SqlServer),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbo".to_string()),
+                table_name: "flags".to_string(),
+                primary_keys: vec![],
+                columns: Some(vec![column("id", "int", false, None), column("active", "bitn", false, None)]),
+            },
+            columns: vec!["id".to_string(), "active".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!(false)]],
+            dirty_rows: vec![(0, vec![(1, json!(true))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(result.statements, vec!["UPDATE [dbo].[flags] SET [active] = 1 WHERE [id] = 1 AND [active] = 0;"]);
+        assert_eq!(
+            result.rollback_statements,
+            vec!["UPDATE [dbo].[flags] SET [active] = 0 WHERE [id] = 1 AND [active] = 1 AND [active] = 1;"]
+        );
+        for sql in result.statements.iter().chain(result.rollback_statements.iter()) {
+            assert!(!sql.contains("TRUE"));
+            assert!(!sql.contains("FALSE"));
+        }
+    }
+
+    #[test]
+    fn saves_empty_nullable_mysql_numeric_cell_as_null() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Mysql),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "employees".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![column("id", "int(11)", false, None), column("age", "int(11)", true, None)]),
+            },
+            columns: vec!["id".to_string(), "age".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(2), json!(36)]],
+            dirty_rows: vec![(0, vec![(1, json!(""))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(result.statements, vec!["UPDATE `employees` SET `age` = NULL WHERE `id` = 2;"]);
+        assert_eq!(
+            result.rollback_statements,
+            vec!["UPDATE `employees` SET `age` = 36 WHERE `id` = 2 AND `age` IS NULL;"]
+        );
+    }
+
+    #[test]
+    fn keeps_empty_nullable_mysql_text_cell_as_empty_string() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Mysql),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "employees".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![column("id", "int(11)", false, None), column("name", "varchar(50)", true, None)]),
+            },
+            columns: vec!["id".to_string(), "name".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(2), json!("Ada")]],
+            dirty_rows: vec![(0, vec![(1, json!(""))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(result.statements, vec!["UPDATE `employees` SET `name` = '' WHERE `id` = 2;"]);
+        assert_eq!(
+            result.rollback_statements,
+            vec!["UPDATE `employees` SET `name` = 'Ada' WHERE `id` = 2 AND BINARY `name` = '';"]
+        );
+    }
+
+    #[test]
+    fn preserves_mysql_text_cell_line_breaks() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Mysql),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "employees".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![column("id", "int(11)", false, None), column("name", "varchar(50)", true, None)]),
+            },
+            columns: vec!["id".to_string(), "name".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(2), json!("Ada")]],
+            dirty_rows: vec![(0, vec![(1, json!("111\n222"))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(result.statements, vec!["UPDATE `employees` SET `name` = '111\n222' WHERE `id` = 2;"]);
+        assert_eq!(
+            result.rollback_statements,
+            vec!["UPDATE `employees` SET `name` = 'Ada' WHERE `id` = 2 AND BINARY `name` = '111\n222';"]
+        );
+    }
+
+    #[test]
+    fn prepares_sqlserver_save_statements() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::SqlServer),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("game".to_string()),
+                table_name: "player states".to_string(),
+                primary_keys: vec!["role id".to_string()],
+                columns: None,
+            },
+            columns: vec!["role id".to_string(), "state".to_string(), "updated at".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(42), json!("old"), json!("2026-05-03")]],
+            dirty_rows: vec![(0, vec![(1, json!("ready")), (2, json!("2026-05-04"))])],
+            deleted_rows: vec![0],
+            new_rows: vec![vec![json!(43), json!("new"), json!("2026-05-05")]],
+        });
+
+        assert_eq!(
+            result.statements,
+            vec![
+                "UPDATE [game].[player states] SET [state] = N'ready', [updated at] = N'2026-05-04' WHERE [role id] = 42;",
+                "DELETE FROM [game].[player states] WHERE [role id] = 42;",
+                "INSERT INTO [game].[player states] ([role id], [state], [updated at]) VALUES (43, N'new', N'2026-05-05');",
+            ]
+        );
+    }
+
+    #[test]
+    fn prepares_tdengine_child_table_delete_from_stable_row() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbx_tdengine_demo".to_string()),
+                table_name: "meters".to_string(),
+                primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string()],
+                columns: Some(vec![column("ts", "TIMESTAMP", false, None), column("voltage", "FLOAT", true, None)]),
+            },
+            columns: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string(), "voltage".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!("codex_delete_verify"), json!("2026-07-10T13:59:00.456+08:00"), json!(221.5)]],
+            dirty_rows: vec![],
+            deleted_rows: vec![0],
+            new_rows: vec![],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(
+            result.statements,
+            vec!["DELETE FROM `dbx_tdengine_demo`.`codex_delete_verify` WHERE `ts` = '2026-07-10T13:59:00.456+08:00';"]
+        );
+        assert_eq!(
+            result.rollback_statements,
+            vec!["INSERT INTO `dbx_tdengine_demo`.`meters` (`tbname`, `ts`, `voltage`) VALUES ('codex_delete_verify', '2026-07-10T13:59:00.456+08:00', 221.5);"]
+        );
+    }
+
+    #[test]
+    fn rejects_tdengine_composite_key_delete_from_same_timestamp_stable_rows() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbx_tdengine_demo".to_string()),
+                table_name: "meters".to_string(),
+                primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string(), "seq".to_string()],
+                columns: Some(vec![
+                    column("ts", "TIMESTAMP", false, None),
+                    column("seq", "INT", false, Some("COMPOSITE KEY")),
+                    column("voltage", "FLOAT", true, None),
+                ]),
+            },
+            columns: vec![
+                DBX_TDENGINE_TBNAME_COLUMN.to_string(),
+                "ts".to_string(),
+                "seq".to_string(),
+                "voltage".to_string(),
+            ],
+            source_columns: None,
+            rows: vec![
+                vec![json!("device_a"), json!("2026-07-10T13:59:00.456+08:00"), json!(1), json!(221.5)],
+                vec![json!("device_a"), json!("2026-07-10T13:59:00.456+08:00"), json!(2), json!(222.5)],
+            ],
+            dirty_rows: vec![],
+            deleted_rows: vec![1],
+            new_rows: vec![],
+        });
+
+        assert_eq!(
+            result.validation_error,
+            Some("TDengine tables with composite keys do not support row deletion.".to_string())
+        );
+        assert!(result.statements.is_empty());
+        assert!(result.rollback_statements.is_empty());
+    }
+
+    #[test]
+    fn prepares_tdengine_delete_from_direct_child_table_row() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbx_tdengine_demo".to_string()),
+                table_name: "codex_grid_accept_20260710".to_string(),
+                primary_keys: vec!["ts".to_string()],
+                columns: Some(vec![column("ts", "TIMESTAMP", false, None), column("voltage", "FLOAT", true, None)]),
+            },
+            columns: vec!["ts".to_string(), "voltage".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!("2026-07-10T16:00:00.111+08:00"), json!(220.1)]],
+            dirty_rows: vec![],
+            deleted_rows: vec![0],
+            new_rows: vec![],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(
+            result.statements,
+            vec!["DELETE FROM `dbx_tdengine_demo`.`codex_grid_accept_20260710` WHERE `ts` = '2026-07-10T16:00:00.111+08:00';"]
+        );
+        assert_eq!(
+            result.rollback_statements,
+            vec!["INSERT INTO `dbx_tdengine_demo`.`codex_grid_accept_20260710` (`ts`, `voltage`) VALUES ('2026-07-10T16:00:00.111+08:00', 220.1);"]
+        );
+    }
+
+    #[test]
+    fn prepares_tdengine_overwrite_for_direct_child_table_row() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbx_tdengine_demo".to_string()),
+                table_name: "codex_grid_update_verify_20260710".to_string(),
+                primary_keys: vec!["ts".to_string()],
+                columns: Some(vec![
+                    column("ts", "TIMESTAMP", false, None),
+                    column("voltage", "FLOAT", true, None),
+                    column("current", "FLOAT", true, None),
+                ]),
+            },
+            columns: vec!["ts".to_string(), "voltage".to_string(), "current".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!("2026-07-10T16:30:00.444+08:00"), json!(220.0), json!(1.0)]],
+            dirty_rows: vec![(0, vec![(1, json!(229.9))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(
+            result.statements,
+            vec!["INSERT INTO `dbx_tdengine_demo`.`codex_grid_update_verify_20260710` (`ts`, `voltage`, `current`) VALUES ('2026-07-10T16:30:00.444+08:00', 229.9, 1.0);"]
+        );
+        assert_eq!(
+            result.rollback_statements,
+            vec!["INSERT INTO `dbx_tdengine_demo`.`codex_grid_update_verify_20260710` (`ts`, `voltage`, `current`) VALUES ('2026-07-10T16:30:00.444+08:00', 220.0, 1.0);"]
+        );
+    }
+
+    #[test]
+    fn prepares_tdengine_composite_key_overwrite_and_rollback_for_same_timestamp_child_rows() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbx_tdengine_demo".to_string()),
+                table_name: "device_a".to_string(),
+                primary_keys: vec!["ts".to_string(), "seq".to_string()],
+                columns: Some(vec![
+                    column("ts", "TIMESTAMP", false, None),
+                    column("seq", "INT", false, Some("COMPOSITE KEY")),
+                    column("voltage", "FLOAT", true, None),
+                ]),
+            },
+            columns: vec!["ts".to_string(), "seq".to_string(), "voltage".to_string()],
+            source_columns: None,
+            rows: vec![
+                vec![json!("2026-07-10T16:30:00.444+08:00"), json!(1), json!(220.0)],
+                vec![json!("2026-07-10T16:30:00.444+08:00"), json!(2), json!(221.0)],
+            ],
+            dirty_rows: vec![(1, vec![(2, json!(229.9))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(
+            result.statements,
+            vec!["INSERT INTO `dbx_tdengine_demo`.`device_a` (`ts`, `seq`, `voltage`) VALUES ('2026-07-10T16:30:00.444+08:00', 2, 229.9);"]
+        );
+        assert_eq!(
+            result.rollback_statements,
+            vec!["INSERT INTO `dbx_tdengine_demo`.`device_a` (`ts`, `seq`, `voltage`) VALUES ('2026-07-10T16:30:00.444+08:00', 2, 221.0);"]
+        );
+    }
+
+    #[test]
+    fn prepares_tdengine_stable_insert_with_child_table_identity() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbx_tdengine_demo".to_string()),
+                table_name: "issue_3121_devices".to_string(),
+                primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string()],
+                columns: Some(vec![
+                    column("ts", "TIMESTAMP", false, None),
+                    column("reading", "FLOAT", true, None),
+                    column("site", "VARCHAR", true, Some("TAG")),
+                ]),
+            },
+            columns: vec![
+                DBX_TDENGINE_TBNAME_COLUMN.to_string(),
+                "ts".to_string(),
+                "reading".to_string(),
+                "site".to_string(),
+            ],
+            source_columns: None,
+            rows: vec![],
+            dirty_rows: vec![],
+            deleted_rows: vec![],
+            new_rows: vec![vec![
+                json!("codex_issue3121_insert_verify"),
+                json!("2026-07-10T17:48:51.000+08:00"),
+                json!(1.0),
+                json!("codex-lab"),
+            ]],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(
+            result.statements,
+            vec!["INSERT INTO `dbx_tdengine_demo`.`issue_3121_devices` (`tbname`, `ts`, `reading`, `site`) VALUES ('codex_issue3121_insert_verify', '2026-07-10T17:48:51.000+08:00', 1.0, 'codex-lab');"]
+        );
+        assert_eq!(
+            result.rollback_statements,
+            vec!["DELETE FROM `dbx_tdengine_demo`.`codex_issue3121_insert_verify` WHERE `ts` = '2026-07-10T17:48:51.000+08:00';"]
+        );
+    }
+
+    #[test]
+    fn skips_tdengine_composite_key_insert_rollback_for_same_timestamp_rows() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbx_tdengine_demo".to_string()),
+                table_name: "meters".to_string(),
+                primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string(), "seq".to_string()],
+                columns: Some(vec![
+                    column("ts", "TIMESTAMP", false, None),
+                    column("seq", "INT", false, Some("COMPOSITE KEY")),
+                    column("voltage", "FLOAT", true, None),
+                ]),
+            },
+            columns: vec![
+                DBX_TDENGINE_TBNAME_COLUMN.to_string(),
+                "ts".to_string(),
+                "seq".to_string(),
+                "voltage".to_string(),
+            ],
+            source_columns: None,
+            rows: vec![],
+            dirty_rows: vec![],
+            deleted_rows: vec![],
+            new_rows: vec![
+                vec![json!("device_a"), json!("2026-07-10T17:48:51.000+08:00"), json!(1), json!(221.0)],
+                vec![json!("device_a"), json!("2026-07-10T17:48:51.000+08:00"), json!(2), json!(222.0)],
+            ],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(
+            result.statements,
+            vec![
+                "INSERT INTO `dbx_tdengine_demo`.`meters` (`tbname`, `ts`, `seq`, `voltage`) VALUES ('device_a', '2026-07-10T17:48:51.000+08:00', 1, 221.0);",
+                "INSERT INTO `dbx_tdengine_demo`.`meters` (`tbname`, `ts`, `seq`, `voltage`) VALUES ('device_a', '2026-07-10T17:48:51.000+08:00', 2, 222.0);",
+            ]
+        );
+        assert!(result.rollback_statements.is_empty());
+    }
+
+    #[test]
+    fn rejects_tdengine_stable_insert_without_child_table_identity() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbx_tdengine_demo".to_string()),
+                table_name: "issue_3121_devices".to_string(),
+                primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string()],
+                columns: Some(vec![column("ts", "TIMESTAMP", false, None), column("reading", "FLOAT", true, None)]),
+            },
+            columns: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string(), "reading".to_string()],
+            source_columns: None,
+            rows: vec![],
+            dirty_rows: vec![],
+            deleted_rows: vec![],
+            new_rows: vec![vec![Value::Null, json!("2026-07-10T17:48:51.000+08:00"), json!(1.0)]],
+        });
+
+        assert_eq!(
+            result.validation_error,
+            Some("TDengine STABLE inserts require a child table name (tbname).".to_string())
+        );
+        assert!(result.statements.is_empty());
+        assert!(result.rollback_statements.is_empty());
+    }
+
+    #[test]
+    fn rejects_tdengine_delete_without_child_table_identity() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbx_tdengine_demo".to_string()),
+                table_name: "meters".to_string(),
+                primary_keys: vec![DBX_TDENGINE_TBNAME_COLUMN.to_string(), "ts".to_string()],
+                columns: Some(vec![column("ts", "TIMESTAMP", false, None)]),
+            },
+            columns: vec!["ts".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!("2026-07-10T13:59:00.456+08:00")]],
+            dirty_rows: vec![],
+            deleted_rows: vec![0],
+            new_rows: vec![],
+        });
+
+        assert_eq!(
+            result.validation_error,
+            Some("TDengine row editing requires all row identifier columns in the result.".to_string())
+        );
+        assert!(result.statements.is_empty());
+    }
+
+    #[test]
+    fn rejects_tdengine_existing_row_edit_when_composite_key_is_missing() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbx_tdengine_demo".to_string()),
+                table_name: "device_a".to_string(),
+                primary_keys: vec!["ts".to_string(), "seq".to_string()],
+                columns: Some(vec![
+                    column("ts", "TIMESTAMP", false, None),
+                    column("seq", "INT", false, Some("COMPOSITE KEY")),
+                    column("voltage", "FLOAT", true, None),
+                ]),
+            },
+            columns: vec!["ts".to_string(), "voltage".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!("2026-07-10T16:30:00.444+08:00"), json!(220.0)]],
+            dirty_rows: vec![(0, vec![(1, json!(229.9))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(
+            result.validation_error,
+            Some("TDengine row editing requires all row identifier columns in the result.".to_string())
+        );
+        assert!(result.statements.is_empty());
+        assert!(result.rollback_statements.is_empty());
+    }
+
+    #[test]
+    fn rejects_tdengine_existing_row_identity_changes() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("dbx_tdengine_demo".to_string()),
+                table_name: "device_a".to_string(),
+                primary_keys: vec!["ts".to_string(), "seq".to_string()],
+                columns: Some(vec![
+                    column("ts", "TIMESTAMP", false, None),
+                    column("seq", "INT", false, Some("COMPOSITE KEY")),
+                    column("voltage", "FLOAT", true, None),
+                ]),
+            },
+            columns: vec!["ts".to_string(), "seq".to_string(), "voltage".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!("2026-07-10T16:30:00.444+08:00"), json!(2), json!(220.0)]],
+            dirty_rows: vec![(0, vec![(1, json!(3))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(result.validation_error, Some("TDengine row identifier columns cannot be edited.".to_string()));
+        assert!(result.statements.is_empty());
+        assert!(result.rollback_statements.is_empty());
+    }
+
+    #[test]
+    fn prepares_databend_save_statements() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Databend),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("default".to_string()),
+                table_name: "people".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![column("id", "int", false, None), column("name", "string", true, None)]),
+            },
+            columns: vec!["id".to_string(), "name".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("Ada")]],
+            dirty_rows: vec![(0, vec![(1, json!("Linus"))])],
+            deleted_rows: vec![0],
+            new_rows: vec![vec![json!(2), json!("Grace")]],
+        });
+
+        assert_eq!(
+            result.statements,
+            vec![
+                "UPDATE `default`.`people` SET `name` = 'Linus' WHERE `id` = 1;",
+                "DELETE FROM `default`.`people` WHERE `id` = 1;",
+                "INSERT INTO `default`.`people` (`id`, `name`) VALUES (2, 'Grace');",
+            ]
+        );
+    }
+
+    #[test]
+    fn prepares_clickhouse_mutation_save_statements() {
+        let mut id_column = column("id", "UInt64", false, None);
+        id_column.is_primary_key = true;
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::ClickHouse),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("default".to_string()),
+                table_name: "people".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![id_column, column("name", "String", true, None)]),
+            },
+            columns: vec!["id".to_string(), "name".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("Ada")]],
+            dirty_rows: vec![(0, vec![(1, json!("Linus"))])],
+            deleted_rows: vec![0],
+            new_rows: vec![vec![json!(2), json!("Grace")]],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(
+            result.statements,
+            vec![
+                "ALTER TABLE `people` UPDATE `name` = 'Linus' WHERE `id` = 1;",
+                "ALTER TABLE `people` DELETE WHERE `id` = 1;",
+                "INSERT INTO `people` (`id`, `name`) VALUES (2, 'Grace');",
+            ]
+        );
+        assert!(result.rollback_statements.is_empty());
+    }
+
+    #[test]
+    fn rejects_clickhouse_key_only_update() {
+        let mut id_column = column("id", "UInt64", false, None);
+        id_column.is_primary_key = true;
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::ClickHouse),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("default".to_string()),
+                table_name: "people".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![id_column, column("name", "String", true, None)]),
+            },
+            columns: vec!["id".to_string(), "name".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("Ada")]],
+            dirty_rows: vec![(0, vec![(0, json!(2))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(
+            result.validation_error,
+            Some(
+                "ClickHouse primary or partition key columns cannot be updated. Change a non-key column before saving."
+                    .to_string()
+            )
+        );
+        assert!(result.statements.is_empty());
+    }
+
+    #[test]
+    fn omits_clickhouse_partition_key_update_assignments() {
+        let mut event_date_column = column("event_date", "Date", false, Some("partition_key"));
+        event_date_column.is_primary_key = false;
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::ClickHouse),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("default".to_string()),
+                table_name: "events".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![
+                    column("id", "UInt64", false, None),
+                    event_date_column,
+                    column("name", "String", true, None),
+                ]),
+            },
+            columns: vec!["id".to_string(), "event_date".to_string(), "name".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("2026-06-24"), json!("Ada")]],
+            dirty_rows: vec![(0, vec![(1, json!("2026-06-25")), (2, json!("Linus"))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(result.statements, vec!["ALTER TABLE `events` UPDATE `name` = 'Linus' WHERE `id` = 1;"]);
+    }
+
+    #[test]
+    fn rejects_clickhouse_partition_key_only_update() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::ClickHouse),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("default".to_string()),
+                table_name: "events".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![
+                    column("id", "UInt64", false, None),
+                    column("event_date", "Date", false, Some("partition_key")),
+                    column("name", "String", true, None),
+                ]),
+            },
+            columns: vec!["id".to_string(), "event_date".to_string(), "name".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("2026-06-24"), json!("Ada")]],
+            dirty_rows: vec![(0, vec![(1, json!("2026-06-25"))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(
+            result.validation_error,
+            Some(
+                "ClickHouse primary or partition key columns cannot be updated. Change a non-key column before saving."
+                    .to_string()
+            )
+        );
+        assert!(result.statements.is_empty());
+    }
+
+    #[test]
+    fn builds_clickhouse_copy_update_statements() {
+        let statements = build_data_grid_copy_update_statements(DataGridCopyUpdateStatementOptions {
+            database_type: Some(DatabaseType::ClickHouse),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("default".to_string()),
+                table_name: "people".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![column("id", "UInt64", false, None), column("name", "String", true, None)]),
+            },
+            columns: vec!["id".to_string(), "name".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("Ada")]],
+        });
+
+        assert_eq!(statements, vec!["ALTER TABLE `people` UPDATE `name` = 'Ada' WHERE `id` = 1;"]);
+    }
+
+    #[test]
+    fn doris_external_catalog_save_and_copy_statements_use_catalog_scope() {
+        let table_meta = DataGridTableMeta {
+            catalog: Some("iceberg_catalog".to_string()),
+            schema: Some("sales".to_string()),
+            table_name: "orders".to_string(),
+            primary_keys: vec!["id".to_string()],
+            columns: Some(vec![column("id", "bigint", false, None), column("status", "varchar", true, None)]),
+        };
+
+        let copy_updates = build_data_grid_copy_update_statements(DataGridCopyUpdateStatementOptions {
+            database_type: Some(DatabaseType::Doris),
+            table_meta: table_meta.clone(),
+            columns: vec!["id".to_string(), "status".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("paid")]],
+        });
+        assert_eq!(
+            copy_updates,
+            vec!["UPDATE `iceberg_catalog`.`sales`.`orders` SET `status` = 'paid' WHERE `id` = 1;"]
+        );
+
+        let copy_insert = build_data_grid_copy_insert_statement(DataGridCopyInsertStatementOptions {
+            database_type: Some(DatabaseType::Doris),
+            table_meta: Some(table_meta.clone()),
+            columns: vec!["id".to_string(), "status".to_string()],
+            column_types: None,
+            source_columns: None,
+            rows: vec![vec![json!(2), json!("new")]],
+            exclude_primary_keys: false,
+            insert_mode: DataGridCopyInsertMode::Merged,
+        });
+        assert_eq!(
+            copy_insert.as_deref(),
+            Some("INSERT INTO `iceberg_catalog`.`sales`.`orders` (`id`, `status`) VALUES (2, 'new');")
+        );
+
+        let save = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Doris),
+            table_meta,
+            columns: vec!["id".to_string(), "status".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("pending")], vec![json!(3), json!("cancelled")]],
+            dirty_rows: vec![(0, vec![(1, json!("paid"))])],
+            deleted_rows: vec![1],
+            new_rows: vec![vec![json!(4), json!("new")]],
+        });
+        assert_eq!(
+            save.statements,
+            vec![
+                "UPDATE `iceberg_catalog`.`sales`.`orders` SET `status` = 'paid' WHERE `id` = 1;",
+                "DELETE FROM `iceberg_catalog`.`sales`.`orders` WHERE `id` = 3;",
+                "INSERT INTO `iceberg_catalog`.`sales`.`orders` (`id`, `status`) VALUES (4, 'new');",
+            ]
+        );
+        assert!(save.validation_error.is_none());
+    }
+
+    #[test]
+    fn prepares_databend_keyless_save_statements_with_row_predicate() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Databend),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("default".to_string()),
+                table_name: "people".to_string(),
+                primary_keys: vec![],
+                columns: Some(vec![column("id", "int", true, None), column("name", "string", true, None)]),
+            },
+            columns: vec!["id".to_string(), "name".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("Ada")]],
+            dirty_rows: vec![(0, vec![(1, json!("Linus"))])],
+            deleted_rows: vec![0],
+            new_rows: vec![],
+        });
+
+        assert_eq!(
+            result.statements,
+            vec![
+                "UPDATE `default`.`people` SET `name` = 'Linus' WHERE `id` = 1 AND `name` = 'Ada';",
+                "DELETE FROM `default`.`people` WHERE `id` = 1 AND `name` = 'Ada';",
+            ]
+        );
+    }
+
+    #[test]
+    fn prepares_oscar_keyless_save_statements_with_schema_qualified_row_predicate() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Oscar),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("SYSDBA".to_string()),
+                table_name: "PEOPLE".to_string(),
+                primary_keys: vec![],
+                columns: Some(vec![column("ID", "INTEGER", true, None), column("NAME", "VARCHAR", true, None)]),
+            },
+            columns: vec!["ID".to_string(), "NAME".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!(1), json!("Ada")]],
+            dirty_rows: vec![(0, vec![(1, json!("Linus"))])],
+            deleted_rows: vec![0],
+            new_rows: vec![],
+        });
+
+        assert_eq!(
+            result.statements,
+            vec![
+                "UPDATE \"SYSDBA\".\"PEOPLE\" SET \"NAME\" = 'Linus' WHERE \"ID\" = 1 AND \"NAME\" = 'Ada';",
+                "DELETE FROM \"SYSDBA\".\"PEOPLE\" WHERE \"ID\" = 1 AND \"NAME\" = 'Ada';",
+            ]
+        );
+    }
+
+    #[test]
+    fn skips_expression_only_source_columns() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Postgres),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("public".to_string()),
+                table_name: "ihli_data".to_string(),
+                primary_keys: vec!["iso3".to_string(), "year".to_string()],
+                columns: None,
+            },
+            columns: vec!["iso3".to_string(), "year".to_string(), "country_name".to_string(), "score".to_string()],
+            source_columns: Some(vec![
+                Some("iso3".to_string()),
+                Some("year".to_string()),
+                Some("country_name".to_string()),
+                None,
+            ]),
+            rows: vec![vec![json!("LUX"), json!(2007), json!("Luxembourg"), json!(50242.1)]],
+            dirty_rows: vec![(0, vec![(2, json!("Luxembourg City")), (3, json!(999))])],
+            deleted_rows: vec![],
+            new_rows: vec![vec![json!("USA"), json!(2008), json!("United States"), json!(43000)]],
+        });
+
+        assert_eq!(
+            result.statements,
+            vec![
+                r#"UPDATE "public"."ihli_data" SET "country_name" = 'Luxembourg City' WHERE "iso3" = 'LUX' AND "year" = 2007;"#,
+                r#"INSERT INTO "public"."ihli_data" ("iso3", "year", "country_name") VALUES ('USA', 2008, 'United States');"#,
+            ]
+        );
+    }
+
+    #[test]
+    fn formats_mysql_temporal_columns_by_target_type() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Mysql),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "policies".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![
+                    column("id", "int", false, None),
+                    column("insurance_start_time", "datetime", true, None),
+                    column("raw_text", "varchar(64)", true, None),
+                    column("coverage_day", "date", true, None),
+                    column("start_clock", "time", true, None),
+                ]),
+            },
+            columns: vec![
+                "id".to_string(),
+                "insurance_start_time".to_string(),
+                "raw_text".to_string(),
+                "coverage_day".to_string(),
+                "start_clock".to_string(),
+            ],
+            source_columns: None,
+            rows: vec![vec![
+                json!(1),
+                json!("2026-05-12T00:00:00+00:00"),
+                json!("old"),
+                json!("2026-05-12T00:00:00+00:00"),
+                json!("2026-05-12T09:30:45+00:00"),
+            ]],
+            dirty_rows: vec![(
+                0,
+                vec![
+                    (1, json!("2026-05-12T00:00:00+00:00")),
+                    (2, json!("2026-05-12T00:00:00+00:00")),
+                    (3, json!("2026-05-12T00:00:00+00:00")),
+                    (4, json!("2026-05-12T09:30:45+00:00")),
+                ],
+            )],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(
+            result.statements,
+            vec!["UPDATE `policies` SET `insurance_start_time` = '2026-05-12 00:00:00', `raw_text` = '2026-05-12T00:00:00+00:00', `coverage_day` = '2026-05-12', `start_clock` = '09:30:45' WHERE `id` = 1;"]
+        );
+    }
+
+    #[test]
+    fn mysql_primary_key_text_predicates_do_not_use_binary_comparison() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Mysql),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "school".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![column("id", "varchar(32)", true, None), column("age", "varchar(8)", false, None)]),
+            },
+            columns: vec!["id".to_string(), "age".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!("0001492305e412e88086bd582d2678e0"), json!("17")]],
+            dirty_rows: vec![(0, vec![(1, json!("18"))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(
+            result.statements,
+            vec!["UPDATE `school` SET `age` = '18' WHERE `id` = '0001492305e412e88086bd582d2678e0';"]
+        );
+    }
+
+    #[test]
+    fn mysql_row_text_predicates_use_binary_comparison_for_width_sensitive_edits() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Mysql),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "parts".to_string(),
+                primary_keys: vec![],
+                columns: Some(vec![column("code", "varchar(32)", true, None)]),
+            },
+            columns: vec!["code".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!("S471355(0)")]],
+            dirty_rows: vec![(0, vec![(0, json!("S471355（0）"))])],
+            deleted_rows: vec![],
+            new_rows: vec![],
+        });
+
+        assert_eq!(
+            result.statements,
+            vec!["UPDATE `parts` SET `code` = 'S471355（0）' WHERE BINARY `code` = 'S471355(0)';"]
+        );
+        assert_eq!(
+            result.rollback_statements,
+            vec![
+                "UPDATE `parts` SET `code` = 'S471355(0)' WHERE BINARY `code` = 'S471355（0）' AND BINARY `code` = 'S471355（0）';"
+            ]
+        );
+    }
+
+    #[test]
+    fn prepares_manticore_save_statements_without_trailing_semicolons() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::ManticoreSearch),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "rt_products".to_string(),
+                primary_keys: vec![],
+                columns: Some(vec![column("id", "bigint", false, None), column("title", "text", true, None)]),
+            },
+            columns: vec!["id".to_string(), "title".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!("1"), json!("old")], vec![json!("2"), json!("deleted")]],
+            dirty_rows: vec![(0, vec![(1, json!("new"))])],
+            deleted_rows: vec![1],
+            new_rows: vec![vec![json!("3"), json!("inserted")]],
+        });
+
+        assert_eq!(
+            result.statements,
+            vec![
+                "UPDATE `rt_products` SET `title` = 'new' WHERE `id` = 1 AND `title` = 'old'",
+                "DELETE FROM `rt_products` WHERE `id` = 2 AND `title` = 'deleted'",
+                "INSERT INTO `rt_products` (`id`, `title`) VALUES (3, 'inserted')",
+            ]
+        );
+        assert!(result.rollback_statements.iter().all(|statement| !statement.ends_with(';')));
+    }
+
+    #[test]
+    fn validates_duplicate_inserted_primary_keys() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Postgres),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "education_data".to_string(),
+                primary_keys: vec!["country_code".to_string(), "year".to_string()],
+                columns: None,
+            },
+            columns: vec!["country_code".to_string(), "year".to_string(), "value".to_string()],
+            source_columns: None,
+            rows: vec![vec![json!("ALB"), json!(2021), json!(0.812)]],
+            dirty_rows: vec![],
+            deleted_rows: vec![],
+            new_rows: vec![vec![json!("ALB"), json!(2021), json!(0.913)]],
+        });
+
+        assert_eq!(
+            result.validation_error,
+            Some(r#"New row duplicates the existing primary key (country_code = "ALB", year = 2021). Change the key before saving."#.to_string())
+        );
+        assert!(result.statements.is_empty());
+    }
+
+    fn pk_column(name: &str, data_type: &str, nullable: bool, extra: Option<&str>) -> DataGridColumnInfo {
+        DataGridColumnInfo {
+            name: name.to_string(),
+            data_type: data_type.to_string(),
+            is_nullable: nullable,
+            is_primary_key: true,
+            column_default: None,
+            extra: extra.map(ToString::to_string),
+        }
+    }
+
+    #[test]
+    fn prepare_data_grid_save_skips_sqlite_autoincrement_pk_validation() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Sqlite),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "OnlineLogs".to_string(),
+                primary_keys: vec!["OnlineLogId".to_string()],
+                columns: Some(vec![
+                    pk_column("OnlineLogId", "INTEGER", false, Some("autoincrement")),
+                    column("LogTime", "TEXT", false, None),
+                ]),
+            },
+            columns: vec!["OnlineLogId".to_string(), "LogTime".to_string()],
+            source_columns: None,
+            rows: vec![],
+            dirty_rows: vec![],
+            deleted_rows: vec![],
+            new_rows: vec![vec![Value::Null, json!("2026-06-12T00:00:00Z")]],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(result.statements, vec![r#"INSERT INTO "OnlineLogs" ("LogTime") VALUES ('2026-06-12T00:00:00Z');"#]);
+    }
+
+    #[test]
+    fn prepare_data_grid_save_includes_explicit_sqlite_pk_value() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Sqlite),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "OnlineLogs".to_string(),
+                primary_keys: vec!["OnlineLogId".to_string()],
+                columns: Some(vec![
+                    pk_column("OnlineLogId", "INTEGER", false, Some("autoincrement")),
+                    column("LogTime", "TEXT", false, None),
+                ]),
+            },
+            columns: vec!["OnlineLogId".to_string(), "LogTime".to_string()],
+            source_columns: None,
+            rows: vec![],
+            dirty_rows: vec![],
+            deleted_rows: vec![],
+            new_rows: vec![vec![json!(42), json!("2026-06-12T00:00:00Z")]],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(
+            result.statements,
+            vec![r#"INSERT INTO "OnlineLogs" ("OnlineLogId", "LogTime") VALUES (42, '2026-06-12T00:00:00Z');"#]
+        );
+    }
+
+    #[test]
+    fn prepare_data_grid_save_omits_empty_mysql_auto_increment_value() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Mysql),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: Some("app".to_string()),
+                table_name: "users".to_string(),
+                primary_keys: vec!["id".to_string()],
+                columns: Some(vec![
+                    pk_column("id", "BIGINT", false, Some("auto_increment")),
+                    column("name", "VARCHAR", false, None),
+                ]),
+            },
+            columns: vec!["id".to_string(), "name".to_string()],
+            source_columns: None,
+            rows: vec![],
+            dirty_rows: vec![],
+            deleted_rows: vec![],
+            new_rows: vec![vec![json!(""), json!("Ada")]],
+        });
+
+        assert_eq!(result.validation_error, None);
+        assert_eq!(result.statements, vec!["INSERT INTO `app`.`users` (`name`) VALUES ('Ada');"]);
+    }
+
+    #[test]
+    fn prepare_data_grid_save_still_validates_other_not_null_columns_in_sqlite() {
+        let result = prepare_data_grid_save(DataGridSaveStatementOptions {
+            database_type: Some(DatabaseType::Sqlite),
+            table_meta: DataGridTableMeta {
+                catalog: None,
+                schema: None,
+                table_name: "OnlineLogs".to_string(),
+                primary_keys: vec!["OnlineLogId".to_string()],
+                columns: Some(vec![
+                    pk_column("OnlineLogId", "INTEGER", false, Some("autoincrement")),
+                    column("LogTime", "TEXT", false, None),
+                ]),
+            },
+            columns: vec!["OnlineLogId".to_string(), "LogTime".to_string()],
+            source_columns: None,
+            rows: vec![],
+            dirty_rows: vec![],
+            deleted_rows: vec![],
+            new_rows: vec![vec![Value::Null, Value::Null]],
+        });
+
+        assert_eq!(result.validation_error, Some(r#"Column "LogTime" does not allow NULL."#.to_string()));
+        assert!(result.statements.is_empty());
+    }
+}
diff --git a/crates/dbx-core/src/data_grid_tdengine_sql.rs b/crates/dbx-core/src/data_grid_tdengine_sql.rs
new file mode 100644
index 0000000..966273e
--- /dev/null
+++ b/crates/dbx-core/src/data_grid_tdengine_sql.rs
@@ -0,0 +1,300 @@
+use serde_json::Value;
+
+use super::*;
+use crate::models::connection::DatabaseType;
+
+pub(super) fn build_tdengine_data_grid_save_statements(options: &DataGridSaveStatementOptions) -> Vec<String> {
+    let save_columns = effective_columns(options);
+    let mut statements = Vec::new();
+    let has_tbname = save_columns
+        .iter()
+        .any(|column| column.as_deref().is_some_and(|column| column.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN)));
+    let requires_tbname = options
+        .table_meta
+        .primary_keys
+        .iter()
+        .any(|primary_key| primary_key.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN));
+
+    if has_tbname || !requires_tbname {
+        for (row_index, changes) in &options.dirty_rows {
+            let Some(row) = options.rows.get(*row_index) else {
+                continue;
+            };
+            let mut after_row = row.clone();
+            for (column_index, value) in changes {
+                if *column_index < after_row.len() {
+                    after_row[*column_index] = value.clone();
+                }
+            }
+            if let Some(statement) = build_tdengine_insert_statement(options, &save_columns, &after_row) {
+                statements.push(statement);
+            }
+        }
+    }
+
+    for row_index in &options.deleted_rows {
+        let Some(row) = options.rows.get(*row_index) else {
+            continue;
+        };
+        if let Some(statement) = build_tdengine_delete_statement(options, &save_columns, row) {
+            statements.push(statement);
+        }
+    }
+
+    for row in &options.new_rows {
+        if let Some(statement) = build_tdengine_insert_statement(options, &save_columns, row) {
+            statements.push(statement);
+        }
+    }
+
+    statements
+}
+
+pub(super) fn build_tdengine_data_grid_rollback_statements(options: &DataGridSaveStatementOptions) -> Vec<String> {
+    if has_tdengine_composite_primary_key(options) && !options.new_rows.is_empty() {
+        return Vec::new();
+    }
+
+    let save_columns = effective_columns(options);
+    let mut statements = Vec::new();
+
+    for row in &options.new_rows {
+        if let Some(statement) = build_tdengine_delete_statement(options, &save_columns, row) {
+            statements.push(statement);
+        }
+    }
+
+    for row_index in &options.deleted_rows {
+        let Some(row) = options.rows.get(*row_index) else {
+            continue;
+        };
+        if let Some(statement) = build_tdengine_insert_statement(options, &save_columns, row) {
+            statements.push(statement);
+        }
+    }
+
+    for (row_index, _) in &options.dirty_rows {
+        let Some(row) = options.rows.get(*row_index) else {
+            continue;
+        };
+        if let Some(statement) = build_tdengine_insert_statement(options, &save_columns, row) {
+            statements.push(statement);
+        }
+    }
+
+    statements
+}
+
+pub(super) fn validate_tdengine_inserted_rows(options: &DataGridSaveStatementOptions) -> Option<String> {
+    if options.database_type != Some(DatabaseType::Tdengine) || options.new_rows.is_empty() {
+        return None;
+    }
+
+    let requires_tbname = options
+        .table_meta
+        .primary_keys
+        .iter()
+        .any(|primary_key| primary_key.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN));
+    if !requires_tbname {
+        return None;
+    }
+
+    let save_columns = effective_columns(options);
+    if options
+        .new_rows
+        .iter()
+        .any(|row| tdengine_tbname_value(&save_columns, row).is_none_or(|tbname| tbname.trim().is_empty()))
+    {
+        return Some(tdengine_insert_identity_error());
+    }
+
+    None
+}
+
+pub(super) fn validate_tdengine_existing_rows(options: &DataGridSaveStatementOptions) -> Option<String> {
+    if options.database_type != Some(DatabaseType::Tdengine)
+        || (options.deleted_rows.is_empty() && options.dirty_rows.is_empty())
+    {
+        return None;
+    }
+
+    if has_tdengine_composite_primary_key(options) && !options.deleted_rows.is_empty() {
+        return Some(tdengine_composite_key_delete_error());
+    }
+
+    let save_columns = effective_columns(options);
+    let primary_keys = tdengine_row_primary_keys(options);
+    let requires_tbname = options
+        .table_meta
+        .primary_keys
+        .iter()
+        .any(|primary_key| primary_key.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN));
+    if (requires_tbname
+        && !save_columns.iter().any(|column| {
+            column.as_deref().is_some_and(|column| column.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN))
+        }))
+        || primary_keys.is_empty()
+        || primary_keys.iter().any(|primary_key| find_column_index(&save_columns, primary_key).is_none())
+    {
+        return Some(tdengine_row_identity_error());
+    }
+
+    if options.dirty_rows.iter().any(|(_, changes)| {
+        changes.iter().any(|(column_index, _)| {
+            save_columns.get(*column_index).and_then(Option::as_deref).is_some_and(|column| {
+                options.table_meta.primary_keys.iter().any(|primary_key| primary_key.eq_ignore_ascii_case(column))
+            })
+        })
+    }) {
+        return Some(tdengine_row_identity_readonly_error());
+    }
+
+    for row_index in
+        options.deleted_rows.iter().copied().chain(options.dirty_rows.iter().map(|(row_index, _)| *row_index))
+    {
+        let Some(row) = options.rows.get(row_index) else {
+            return Some(tdengine_row_identity_error());
+        };
+        if (requires_tbname && tdengine_tbname_value(&save_columns, row).is_none_or(|tbname| tbname.trim().is_empty()))
+            || primary_keys.iter().any(|primary_key| {
+                find_column_index(&save_columns, primary_key)
+                    .and_then(|index| row.get(index))
+                    .is_none_or(Value::is_null)
+            })
+        {
+            return Some(tdengine_row_identity_error());
+        }
+    }
+
+    None
+}
+
+fn build_tdengine_delete_statement(
+    options: &DataGridSaveStatementOptions,
+    save_columns: &[Option<String>],
+    row: &[Value],
+) -> Option<String> {
+    if has_tdengine_composite_primary_key(options) {
+        return None;
+    }
+
+    let table_name = tdengine_tbname_value(save_columns, row).unwrap_or_else(|| options.table_meta.table_name.clone());
+    let primary_keys = tdengine_row_primary_keys(options);
+    let where_clause = build_primary_key_where(
+        Some(DatabaseType::Tdengine),
+        &primary_keys,
+        save_columns,
+        row,
+        options.table_meta.columns.as_deref().unwrap_or(&[]),
+    );
+    if where_clause.is_empty() {
+        return None;
+    }
+    let table = qualified_table_name(Some(DatabaseType::Tdengine), options.table_meta.schema.as_deref(), &table_name);
+    Some(data_grid_statement(
+        Some(DatabaseType::Tdengine),
+        data_grid_delete_sql(Some(DatabaseType::Tdengine), &table, &where_clause),
+    ))
+}
+
+fn tdengine_row_primary_keys(options: &DataGridSaveStatementOptions) -> Vec<String> {
+    options
+        .table_meta
+        .primary_keys
+        .iter()
+        .filter(|primary_key| !primary_key.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN))
+        .cloned()
+        .collect()
+}
+
+fn has_tdengine_composite_primary_key(options: &DataGridSaveStatementOptions) -> bool {
+    tdengine_row_primary_keys(options).len() > 1
+}
+
+fn tdengine_row_identity_error() -> String {
+    "TDengine row editing requires all row identifier columns in the result.".to_string()
+}
+
+fn tdengine_row_identity_readonly_error() -> String {
+    "TDengine row identifier columns cannot be edited.".to_string()
+}
+
+fn tdengine_composite_key_delete_error() -> String {
+    "TDengine tables with composite keys do not support row deletion.".to_string()
+}
+
+fn tdengine_insert_identity_error() -> String {
+    "TDengine STABLE inserts require a child table name (tbname).".to_string()
+}
+
+fn build_tdengine_insert_statement(
+    options: &DataGridSaveStatementOptions,
+    save_columns: &[Option<String>],
+    row: &[Value],
+) -> Option<String> {
+    let tbname = tdengine_tbname_value(save_columns, row);
+    let table = qualified_table_name(
+        Some(DatabaseType::Tdengine),
+        options.table_meta.schema.as_deref(),
+        &options.table_meta.table_name,
+    );
+    let tag_columns = tdengine_tag_columns(options.table_meta.columns.as_deref());
+    let insert_pairs: Vec<(&str, &Value)> = save_columns
+        .iter()
+        .enumerate()
+        .filter_map(|(index, column)| Some((column.as_deref()?, row.get(index).unwrap_or(&Value::Null))))
+        .filter(|(_, value)| !value.is_null())
+        .filter(|(column, _)| {
+            tdengine_can_insert_column(column, &options.table_meta.table_name, tbname.as_deref(), &tag_columns)
+        })
+        .collect();
+    if insert_pairs.is_empty() {
+        return None;
+    }
+    let columns = insert_pairs
+        .iter()
+        .map(|(column, _)| quote_ident(Some(DatabaseType::Tdengine), column))
+        .collect::<Vec<_>>()
+        .join(", ");
+    let values = insert_pairs
+        .iter()
+        .map(|(_, value)| format_grid_sql_literal(value, Some(DatabaseType::Tdengine), None))
+        .collect::<Vec<_>>()
+        .join(", ");
+    Some(format!("INSERT INTO {table} ({columns}) VALUES ({values});"))
+}
+
+fn tdengine_tbname_value(save_columns: &[Option<String>], row: &[Value]) -> Option<String> {
+    let index = save_columns.iter().position(|column| {
+        column.as_deref().is_some_and(|column| column.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN))
+    })?;
+    let value = row.get(index)?;
+    if value.is_null() {
+        None
+    } else if let Some(value) = value.as_str() {
+        Some(value.to_string())
+    } else {
+        Some(value.to_string())
+    }
+}
+
+fn tdengine_can_insert_column(column: &str, table_name: &str, tbname: Option<&str>, tag_columns: &[String]) -> bool {
+    let normalized = column.to_ascii_lowercase();
+    let target_is_child_table = tbname.is_none_or(|tbname| tbname == table_name);
+    if !target_is_child_table {
+        return true;
+    }
+    if normalized == DBX_TDENGINE_TBNAME_COLUMN {
+        return false;
+    }
+    !tag_columns.iter().any(|tag| tag == &normalized)
+}
+
+fn tdengine_tag_columns(columns: Option<&[DataGridColumnInfo]>) -> Vec<String> {
+    columns
+        .unwrap_or(&[])
+        .iter()
+        .filter(|column| column.extra.as_deref().unwrap_or("").to_ascii_lowercase().contains("tag"))
+        .map(|column| column.name.to_ascii_lowercase())
+        .collect()
+}
diff --git a/crates/dbx-core/src/database_capabilities.rs b/crates/dbx-core/src/database_capabilities.rs
new file mode 100644
index 0000000..48ac74f
--- /dev/null
+++ b/crates/dbx-core/src/database_capabilities.rs
@@ -0,0 +1,89 @@
+use crate::agent_catalog;
+use crate::models::connection::DatabaseType;
+
+pub fn agent_key(db_type: &DatabaseType, driver_profile: Option<&str>) -> Option<&'static str> {
+    agent_catalog::agent_key(db_type, driver_profile)
+}
+
+pub fn is_agent_type(db_type: &DatabaseType) -> bool {
+    agent_catalog::is_agent_type(db_type)
+}
+
+pub fn is_single_connection_pool(db_type: &DatabaseType) -> bool {
+    matches!(
+        db_type,
+        DatabaseType::Sqlite
+            | DatabaseType::DuckDb
+            | DatabaseType::Rqlite
+            | DatabaseType::Turso
+            | DatabaseType::CloudflareD1
+            | DatabaseType::MongoDb
+            | DatabaseType::Oracle
+            | DatabaseType::Dameng
+            | DatabaseType::Kingbase
+            | DatabaseType::Highgo
+            | DatabaseType::Vastbase
+            | DatabaseType::Goldendb
+            | DatabaseType::Yashandb
+            | DatabaseType::Oscar
+            | DatabaseType::Firebird
+            | DatabaseType::Iris
+            | DatabaseType::OceanbaseOracle
+            | DatabaseType::Access
+            | DatabaseType::Jdbc
+    )
+}
+
+pub fn is_metadata_connection_scoped(db_type: &DatabaseType) -> bool {
+    matches!(db_type, DatabaseType::Mysql)
+}
+
+pub fn skips_tcp_probe(db_type: &DatabaseType) -> bool {
+    matches!(
+        db_type,
+        DatabaseType::Sqlite
+            | DatabaseType::DuckDb
+            | DatabaseType::Turso
+            | DatabaseType::CloudflareD1
+            | DatabaseType::Jdbc
+            | DatabaseType::MessageQueue
+    ) || is_agent_type(db_type)
+}
+
+/// Database types whose connection backs onto a single local file (or may, in the
+/// case of H2 file mode). Used to decide whether to expose a "reveal in file
+/// manager" affordance. Whether the H2 connection is actually in file mode must
+/// be determined separately by parsing the JDBC URL.
+pub fn is_local_file_db_type(db_type: &DatabaseType) -> bool {
+    matches!(db_type, DatabaseType::Sqlite | DatabaseType::DuckDb | DatabaseType::Access | DatabaseType::H2)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn local_file_db_types_match_expected_set() {
+        assert!(is_local_file_db_type(&DatabaseType::Sqlite));
+        assert!(is_local_file_db_type(&DatabaseType::DuckDb));
+        assert!(is_local_file_db_type(&DatabaseType::Access));
+        assert!(is_local_file_db_type(&DatabaseType::H2));
+    }
+
+    #[test]
+    fn non_local_file_db_types_rejected() {
+        assert!(!is_local_file_db_type(&DatabaseType::Mysql));
+        assert!(!is_local_file_db_type(&DatabaseType::Postgres));
+        assert!(!is_local_file_db_type(&DatabaseType::Redis));
+        assert!(!is_local_file_db_type(&DatabaseType::MongoDb));
+        assert!(!is_local_file_db_type(&DatabaseType::Turso));
+        assert!(!is_local_file_db_type(&DatabaseType::CloudflareD1));
+        assert!(!is_local_file_db_type(&DatabaseType::Rqlite));
+    }
+
+    #[test]
+    fn cloudflare_d1_uses_a_single_http_pool_without_tcp_probe() {
+        assert!(is_single_connection_pool(&DatabaseType::CloudflareD1));
+        assert!(skips_tcp_probe(&DatabaseType::CloudflareD1));
+    }
+}
diff --git a/crates/dbx-core/src/database_export.rs b/crates/dbx-core/src/database_export.rs
new file mode 100644
index 0000000..3ea9851
--- /dev/null
+++ b/crates/dbx-core/src/database_export.rs
@@ -0,0 +1,2060 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::collections::HashSet;
+use std::io::Write;
+use tokio::sync::RwLock;
+
+use crate::connection::task_client_session_id;
+use crate::models::connection::DatabaseType;
+use crate::object_source_sql::build_export_object_source_sql;
+use crate::sql_dialect::{qualified_table_name, quote_table_identifier, uses_single_row_insert_statements};
+use crate::transfer::{
+    format_ch_array_sql_literal, format_pg_array_sql_literal, is_identity_column_extra, quote_identifier,
+    selected_columns_include_identity_extras, wrap_dameng_identity_insert_sql,
+    wrap_dameng_identity_insert_sql_for_table,
+};
+
+static EXPORT_CANCELLED: std::sync::LazyLock<RwLock<HashSet<String>>> =
+    std::sync::LazyLock::new(|| RwLock::new(HashSet::new()));
+
+pub fn database_export_client_session_id(export_id: &str) -> String {
+    task_client_session_id("database-export", export_id)
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DatabaseExportRequest {
+    pub export_id: String,
+    pub connection_id: String,
+    pub database: String,
+    pub schema: String,
+    pub file_path: String,
+    #[serde(default)]
+    pub selected_tables: Vec<String>,
+    pub include_structure: bool,
+    pub include_data: bool,
+    pub include_objects: bool,
+    #[serde(default)]
+    pub drop_table_if_exists: bool,
+    pub batch_size: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExportProgress {
+    pub export_id: String,
+    pub current_object: String,
+    pub object_index: usize,
+    pub total_objects: usize,
+    pub rows_exported: u64,
+    pub total_rows: Option<u64>,
+    pub status: ExportStatus,
+    pub error: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum ExportStatus {
+    Running,
+    Writing,
+    Done,
+    Error,
+    Cancelled,
+}
+
+pub const DATABASE_EXPORT_ROW_LIMIT: usize = 10_000;
+pub const DATABASE_EXPORT_PAGE_SIZE: usize = 500;
+pub const DATABASE_EXPORT_INSERT_BATCH_SIZE: usize = 100;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct PostgresExportSequence {
+    name: String,
+    data_type: String,
+    start_value: String,
+    min_value: String,
+    max_value: String,
+    increment: String,
+    cycle: bool,
+    cache_value: String,
+    last_value: Option<String>,
+    owner_table: Option<String>,
+    owner_column: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExportedTableSql {
+    pub display_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub qualified_table_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ddl: Option<String>,
+    #[serde(default)]
+    pub columns: Vec<String>,
+    #[serde(default)]
+    pub column_types: Vec<Option<String>>,
+    #[serde(default)]
+    pub column_extras: Vec<Option<String>>,
+    #[serde(default)]
+    pub rows: Vec<Vec<Value>>,
+    #[serde(default)]
+    pub truncated: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildExportInsertStatementsOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table_name: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub qualified_table_name: Option<String>,
+    #[serde(default)]
+    pub columns: Vec<String>,
+    #[serde(default)]
+    pub column_types: Vec<Option<String>>,
+    #[serde(default)]
+    pub column_extras: Vec<Option<String>>,
+    #[serde(default)]
+    pub rows: Vec<Vec<Value>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<usize>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildExportSqlInsertOptions {
+    #[serde(flatten)]
+    pub insert: BuildExportInsertStatementsOptions,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDatabaseSqlExportOptions {
+    pub database_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub exported_at: Option<String>,
+    #[serde(default)]
+    pub tables: Vec<ExportedTableSql>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub row_limit_per_table: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub insert_batch_size: Option<usize>,
+    /// Optional connection info for FK-aware table ordering.
+    /// When set, the caller should sort tables by dependency before passing them
+    /// to `build_database_sql_export`.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub connection_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+}
+
+pub fn format_export_sql_literal(value: &Value) -> String {
+    format_export_sql_literal_for_database(value, None)
+}
+
+fn format_export_sql_literal_for_database(value: &Value, database_type: Option<DatabaseType>) -> String {
+    if value.is_null() {
+        return "NULL".to_string();
+    }
+    if let Some(number) = value.as_number() {
+        return number.to_string();
+    }
+    if let Some(value) = value.as_bool() {
+        return if value { "TRUE" } else { "FALSE" }.to_string();
+    }
+    if let Some(arr) = value.as_array() {
+        return format_pg_array_sql_literal(arr);
+    }
+    let text = value.as_str().map_or_else(|| value.to_string(), ToString::to_string);
+    quote_export_sql_string_for_database(&text, database_type)
+}
+
+fn format_export_sql_literal_typed(
+    value: &Value,
+    database_type: Option<DatabaseType>,
+    column_type: Option<&str>,
+) -> String {
+    if is_postgres_json_export_column(database_type, column_type) {
+        return format_postgres_json_export_literal(value);
+    }
+    if is_postgres_vector_export_column(database_type, column_type) {
+        return format_postgres_vector_export_literal(value);
+    }
+    if matches!(database_type, Some(DatabaseType::Mysql)) && column_type.is_some_and(is_mysql_bit_type) {
+        return format_mysql_bit_literal(value);
+    }
+    if is_mysql_compatible_export_literal_target(database_type) {
+        if column_type.is_some_and(is_mysql_binary_export_type) {
+            if let Some(literal) = format_mysql_binary_export_literal(value) {
+                return literal;
+            }
+        }
+        if column_type.is_some_and(is_export_numeric_type) {
+            if let Some(literal) = format_export_numeric_literal(value) {
+                return literal;
+            }
+        }
+    }
+    if let Some(arr) = value.as_array() {
+        if matches!(database_type, Some(DatabaseType::ClickHouse) | Some(DatabaseType::Databend)) {
+            return format_ch_array_sql_literal(arr);
+        }
+    }
+    if let Some(literal) = format_oracle_export_date_literal(value, database_type, column_type) {
+        return literal;
+    }
+    if let Some(literal) = format_export_temporal_literal(value, database_type, column_type) {
+        return literal;
+    }
+    format_export_sql_literal_for_database(value, database_type)
+}
+
+fn format_postgres_json_export_literal(value: &Value) -> String {
+    if value.is_null() {
+        return "NULL".to_string();
+    }
+    let text = value.as_str().map_or_else(|| value.to_string(), ToString::to_string);
+    // PostgreSQL standard strings keep backslashes literal; JSON text needs its
+    // own escape sequences, so only SQL-escape the surrounding string delimiter.
+    postgres_string_literal(&text)
+}
+
+fn format_postgres_vector_export_literal(value: &Value) -> String {
+    if value.is_null() {
+        return "NULL".to_string();
+    }
+    let text = match value {
+        // pgvector vector/halfvec are scalar extension types whose importable
+        // literal grammar uses square brackets, unlike PostgreSQL arrays.
+        Value::Array(arr) => format_postgres_vector_export_text(arr),
+        Value::String(text) => text.to_string(),
+        _ => value.to_string(),
+    };
+    postgres_string_literal(&text)
+}
+
+fn format_postgres_vector_export_text(arr: &[Value]) -> String {
+    let elements = arr.iter().map(format_postgres_vector_export_element).collect::<Vec<_>>();
+    format!("[{}]", elements.join(","))
+}
+
+fn format_postgres_vector_export_element(value: &Value) -> String {
+    match value {
+        Value::String(text) => text.trim().to_string(),
+        Value::Number(number) => number.to_string(),
+        Value::Bool(value) => value.to_string(),
+        Value::Null => "NULL".to_string(),
+        _ => value.to_string(),
+    }
+}
+
+fn quote_export_sql_string(text: &str) -> String {
+    format!("'{}'", text.replace('\\', "\\\\").replace('\'', "''"))
+}
+
+fn quote_export_sql_string_for_database(text: &str, database_type: Option<DatabaseType>) -> String {
+    if is_mysql_compatible_export_literal_target(database_type) {
+        quote_mysql_compatible_export_sql_string(text)
+    } else {
+        quote_export_sql_string(text)
+    }
+}
+
+fn quote_mysql_compatible_export_sql_string(text: &str) -> String {
+    format!("'{}'", escape_mysql_compatible_export_sql_string(text))
+}
+
+fn escape_mysql_compatible_export_sql_string(text: &str) -> String {
+    let mut escaped = String::with_capacity(text.len());
+    for ch in text.chars() {
+        match ch {
+            // MySQL-family dumps should keep control characters out of the
+            // physical script layout while relying on the dialect's escapes.
+            '\0' => escaped.push_str("\\0"),
+            '\x08' => escaped.push_str("\\b"),
+            '\n' => escaped.push_str("\\n"),
+            '\r' => escaped.push_str("\\r"),
+            '\t' => escaped.push_str("\\t"),
+            '\x0c' => escaped.push_str("\\f"),
+            '\x1a' => escaped.push_str("\\Z"),
+            '\\' => escaped.push_str("\\\\"),
+            '\'' => escaped.push_str("''"),
+            _ => escaped.push(ch),
+        }
+    }
+    escaped
+}
+
+fn is_mysql_compatible_export_literal_target(database_type: Option<DatabaseType>) -> bool {
+    matches!(
+        database_type,
+        Some(DatabaseType::Mysql | DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::Goldendb)
+    )
+}
+
+fn format_oracle_export_date_literal(
+    value: &Value,
+    database_type: Option<DatabaseType>,
+    column_type: Option<&str>,
+) -> Option<String> {
+    if !matches!(database_type, Some(DatabaseType::Oracle | DatabaseType::OceanbaseOracle)) {
+        return None;
+    }
+    if export_temporal_column_kind(database_type, column_type?)? != ExportTemporalKind::DateTime {
+        return None;
+    }
+    let lower = column_type?.trim().trim_matches('"').to_ascii_lowercase();
+    let base = lower.split(['(', ' ', '\t', '\n']).next().unwrap_or("");
+    if base != "date" {
+        return None;
+    }
+    let parts = parse_export_date_parts(value.as_str()?)?;
+    Some(format_oracle_export_date_parts_literal(&parts))
+}
+
+fn format_oracle_export_date_parts_literal(parts: &ExportRfc3339Parts) -> String {
+    if export_temporal_parts_are_midnight(parts) {
+        format!("DATE '{}'", parts.date)
+    } else {
+        format!("TO_DATE('{} {}', 'YYYY-MM-DD HH24:MI:SS')", parts.date, parts.time)
+    }
+}
+
+fn export_temporal_parts_are_midnight(parts: &ExportRfc3339Parts) -> bool {
+    parts.time == "00:00:00"
+        && parts
+            .fraction
+            .as_deref()
+            .map(|fraction| fraction.trim_start_matches('.').chars().all(|ch| ch == '0'))
+            .unwrap_or(true)
+}
+
+fn format_export_temporal_literal(
+    value: &Value,
+    database_type: Option<DatabaseType>,
+    column_type: Option<&str>,
+) -> Option<String> {
+    let text = value.as_str()?;
+    let column_type = column_type?;
+    if database_type == Some(DatabaseType::SqlServer) {
+        return crate::sqlserver_temporal::normalize_sqlserver_temporal_literal(text, Some(column_type))
+            .map(|text| quote_export_sql_string(&text));
+    }
+    let kind = export_temporal_column_kind(database_type, column_type)?;
+    format_rfc3339_export_temporal_text(text, kind, database_type).map(|text| quote_export_sql_string(&text))
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ExportTemporalKind {
+    Date,
+    Time,
+    DateTime,
+    DateTimeWithTimeZone,
+}
+
+fn export_temporal_column_kind(database_type: Option<DatabaseType>, column_type: &str) -> Option<ExportTemporalKind> {
+    let lower = column_type.trim().trim_matches('"').to_ascii_lowercase();
+    let base = lower.split(['(', ' ', '\t', '\n']).next().unwrap_or("");
+    match base {
+        "date" if matches!(database_type, Some(DatabaseType::Oracle | DatabaseType::OceanbaseOracle)) => {
+            Some(ExportTemporalKind::DateTime)
+        }
+        "date" => Some(ExportTemporalKind::Date),
+        "time" => Some(ExportTemporalKind::Time),
+        "datetime" | "datetime2" | "smalldatetime" | "datetime64" => Some(ExportTemporalKind::DateTime),
+        "datetimeoffset" | "timestamptz" => Some(ExportTemporalKind::DateTimeWithTimeZone),
+        _ if lower.starts_with("timestamp")
+            && (lower.contains("with time zone") || lower.contains("with local time zone")) =>
+        {
+            Some(ExportTemporalKind::DateTimeWithTimeZone)
+        }
+        _ if lower.starts_with("timestamp") => Some(ExportTemporalKind::DateTime),
+        _ => None,
+    }
+}
+
+fn format_rfc3339_export_temporal_text(
+    text: &str,
+    kind: ExportTemporalKind,
+    database_type: Option<DatabaseType>,
+) -> Option<String> {
+    let parts = parse_export_rfc3339_parts(text)?;
+    let fraction = normalize_export_fraction(parts.fraction.as_deref(), database_type);
+    match kind {
+        ExportTemporalKind::Date => Some(parts.date),
+        ExportTemporalKind::Time => Some(format!("{}{fraction}", parts.time)),
+        ExportTemporalKind::DateTime => Some(format!("{} {}{fraction}", parts.date, parts.time)),
+        ExportTemporalKind::DateTimeWithTimeZone => {
+            Some(format!("{} {}{fraction}{}", parts.date, parts.time, normalize_export_timezone(&parts.zone)))
+        }
+    }
+}
+
+struct ExportRfc3339Parts {
+    date: String,
+    time: String,
+    fraction: Option<String>,
+    zone: String,
+}
+
+fn parse_export_date_parts(text: &str) -> Option<ExportRfc3339Parts> {
+    parse_export_rfc3339_parts(text).or_else(|| parse_export_local_temporal_parts(text))
+}
+
+fn parse_export_local_temporal_parts(text: &str) -> Option<ExportRfc3339Parts> {
+    let bytes = text.as_bytes();
+    if bytes.len() < 10 || bytes.get(4) != Some(&b'-') || bytes.get(7) != Some(&b'-') {
+        return None;
+    }
+    let date = &text[0..10];
+    if !date.as_bytes().iter().enumerate().all(|(index, byte)| matches!(index, 4 | 7) || byte.is_ascii_digit()) {
+        return None;
+    }
+    if bytes.len() == 10 {
+        return Some(ExportRfc3339Parts {
+            date: date.to_string(),
+            time: "00:00:00".to_string(),
+            fraction: None,
+            zone: String::new(),
+        });
+    }
+    let separator = *bytes.get(10)?;
+    if separator != b'T' && separator != b' ' {
+        return None;
+    }
+    if bytes.len() < 19 || bytes.get(13) != Some(&b':') || bytes.get(16) != Some(&b':') {
+        return None;
+    }
+    let time = &text[11..19];
+    if !time.as_bytes().iter().enumerate().all(|(index, byte)| matches!(index, 2 | 5) || byte.is_ascii_digit()) {
+        return None;
+    }
+    let rest = &text[19..];
+    let fraction = if let Some(rest) = rest.strip_prefix('.') {
+        let digit_count = rest.chars().take_while(|ch| ch.is_ascii_digit()).count();
+        if digit_count == 0 || digit_count > 9 || digit_count != rest.len() {
+            return None;
+        }
+        Some(format!(".{}", &rest[..digit_count]))
+    } else if rest.is_empty() {
+        None
+    } else {
+        return None;
+    };
+    Some(ExportRfc3339Parts { date: date.to_string(), time: time.to_string(), fraction, zone: String::new() })
+}
+
+fn parse_export_rfc3339_parts(text: &str) -> Option<ExportRfc3339Parts> {
+    let bytes = text.as_bytes();
+    if bytes.len() < 20 || bytes.get(4) != Some(&b'-') || bytes.get(7) != Some(&b'-') {
+        return None;
+    }
+    let separator = *bytes.get(10)?;
+    if separator != b'T' && separator != b' ' {
+        return None;
+    }
+    if bytes.get(13) != Some(&b':') || bytes.get(16) != Some(&b':') {
+        return None;
+    }
+    let date = &text[0..10];
+    let time = &text[11..19];
+    let rest = &text[19..];
+    let (fraction, zone) = if let Some(rest) = rest.strip_prefix('.') {
+        let digit_count = rest.chars().take_while(|ch| ch.is_ascii_digit()).count();
+        if digit_count == 0 || digit_count > 9 {
+            return None;
+        }
+        (Some(format!(".{}", &rest[..digit_count])), &rest[digit_count..])
+    } else {
+        (None, rest)
+    };
+    if zone.eq_ignore_ascii_case("z") || is_export_timezone_offset(zone) {
+        Some(ExportRfc3339Parts { date: date.to_string(), time: time.to_string(), fraction, zone: zone.to_string() })
+    } else {
+        None
+    }
+}
+
+fn normalize_export_fraction(fraction: Option<&str>, database_type: Option<DatabaseType>) -> String {
+    match fraction {
+        Some(fraction) if database_type == Some(DatabaseType::Mysql) && fraction.len() > 7 => fraction[..7].to_string(),
+        Some(fraction) => fraction.to_string(),
+        None => String::new(),
+    }
+}
+
+fn normalize_export_timezone(zone: &str) -> String {
+    if zone.eq_ignore_ascii_case("z") {
+        "+00:00".to_string()
+    } else {
+        zone.to_string()
+    }
+}
+
+fn is_export_timezone_offset(value: &str) -> bool {
+    let bytes = value.as_bytes();
+    bytes.len() == 6
+        && matches!(bytes[0], b'+' | b'-')
+        && bytes[3] == b':'
+        && bytes[1].is_ascii_digit()
+        && bytes[2].is_ascii_digit()
+        && bytes[4].is_ascii_digit()
+        && bytes[5].is_ascii_digit()
+}
+
+fn is_mysql_bit_type(column_type: &str) -> bool {
+    let trimmed = column_type.trim();
+    let lower = trimmed.to_ascii_lowercase();
+    lower == "bit" || lower.starts_with("bit(") || lower.starts_with("bit ")
+}
+
+fn format_mysql_bit_literal(value: &Value) -> String {
+    match value {
+        Value::Null => "NULL".to_string(),
+        Value::Bool(value) => {
+            if *value {
+                "b'1'".to_string()
+            } else {
+                "b'0'".to_string()
+            }
+        }
+        Value::Number(value) => {
+            let s = value.to_string();
+            if s == "0" || s == "1" {
+                format!("b'{s}'")
+            } else {
+                s
+            }
+        }
+        Value::String(value) => {
+            let trimmed = value.trim();
+            if trimmed.eq_ignore_ascii_case("true") {
+                return "b'1'".to_string();
+            }
+            if trimmed.eq_ignore_ascii_case("false") {
+                return "b'0'".to_string();
+            }
+            if trimmed == "0" || trimmed == "1" {
+                return format!("b'{trimmed}'");
+            }
+            if !trimmed.is_empty() && trimmed.bytes().all(|byte| byte == b'0' || byte == b'1') {
+                return format!("b'{trimmed}'");
+            }
+            format!("b'{}'", escape_mysql_compatible_export_sql_string(value))
+        }
+        other => format_export_sql_literal(other),
+    }
+}
+
+fn is_mysql_binary_export_type(column_type: &str) -> bool {
+    let lower = column_type.trim().to_ascii_lowercase();
+    let base = lower.split(['(', ':', ' ', '\t', '\n']).next().unwrap_or("").trim();
+    matches!(base, "binary" | "varbinary" | "blob" | "tinyblob" | "mediumblob" | "longblob")
+}
+
+fn format_mysql_binary_export_literal(value: &Value) -> Option<String> {
+    match value {
+        Value::Null => Some("NULL".to_string()),
+        Value::String(text) => format_mysql_binary_export_literal_text(text),
+        _ => None,
+    }
+}
+
+fn format_mysql_binary_export_literal_text(text: &str) -> Option<String> {
+    let trimmed = text.trim();
+    let hex = trimmed.strip_prefix("0x").or_else(|| trimmed.strip_prefix("0X"))?;
+    if hex.chars().all(|ch| ch.is_ascii_hexdigit()) {
+        // DBX exposes MySQL binary cells as 0x-prefixed hex text. Keep it as a
+        // MySQL hex literal so exported INSERT statements round-trip bytes.
+        Some(if hex.is_empty() { "X''".to_string() } else { format!("0x{hex}") })
+    } else {
+        None
+    }
+}
+
+fn is_export_numeric_type(column_type: &str) -> bool {
+    let lower = column_type.to_ascii_lowercase();
+    [
+        "int",
+        "integer",
+        "bigint",
+        "smallint",
+        "tinyint",
+        "mediumint",
+        "serial",
+        "number",
+        "numeric",
+        "decimal",
+        "dec",
+        "fixed",
+        "float",
+        "double",
+        "real",
+    ]
+    .iter()
+    .any(|part| lower.split(|ch: char| !ch.is_ascii_alphanumeric()).any(|token| token == *part))
+}
+
+fn format_export_numeric_literal(value: &Value) -> Option<String> {
+    match value {
+        Value::Number(number) => Some(number.to_string()),
+        Value::String(text) if is_export_numeric_literal(text) => Some(text.to_string()),
+        _ => None,
+    }
+}
+
+fn is_export_numeric_literal(text: &str) -> bool {
+    if text.trim() != text || text.is_empty() {
+        return false;
+    }
+    text.parse::<f64>().is_ok_and(f64::is_finite)
+        && text.chars().all(|ch| ch.is_ascii_digit() || matches!(ch, '+' | '-' | '.' | 'e' | 'E'))
+        && text.chars().any(|ch| ch.is_ascii_digit())
+}
+
+pub fn build_export_insert_statements(options: BuildExportInsertStatementsOptions) -> Result<Vec<String>, String> {
+    if options.columns.is_empty() || options.rows.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let table = export_qualified_table_name(
+        options.database_type,
+        options.schema.as_deref(),
+        options.table_name.as_deref(),
+        options.qualified_table_name.as_deref(),
+    )?;
+    let insert_columns = options
+        .columns
+        .iter()
+        .enumerate()
+        .filter(|(index, _)| {
+            !is_postgres_tsvector_export_column(
+                options.database_type,
+                options.column_types.get(*index).and_then(|value| value.as_deref()),
+            )
+        })
+        .collect::<Vec<_>>();
+    if insert_columns.is_empty() {
+        return Ok(Vec::new());
+    }
+    let batch_size = if options.database_type.is_some_and(uses_single_row_insert_statements) {
+        1
+    } else {
+        options.batch_size.unwrap_or(DATABASE_EXPORT_INSERT_BATCH_SIZE).max(1)
+    };
+    let columns = insert_columns
+        .iter()
+        .map(|(_, column)| quote_table_identifier(options.database_type, column))
+        .collect::<Vec<_>>()
+        .join(", ");
+    let mut statements = Vec::new();
+    let needs_dameng_identity_insert = options.database_type == Some(DatabaseType::Dameng)
+        && insert_columns.iter().any(|(index, _)| {
+            is_identity_column_extra(options.column_extras.get(*index).and_then(|value| value.as_deref()))
+        });
+
+    for rows in options.rows.chunks(batch_size) {
+        let values = rows
+            .iter()
+            .map(|row| {
+                let values = insert_columns
+                    .iter()
+                    .map(|(index, _)| {
+                        let value = row.get(*index).unwrap_or(&Value::Null);
+                        format_export_sql_literal_typed(
+                            value,
+                            options.database_type,
+                            options.column_types.get(*index).and_then(|value| value.as_deref()),
+                        )
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                format!("({values})")
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+        let insert_sql = format!("INSERT INTO {table} ({columns}) VALUES {values};");
+        if needs_dameng_identity_insert {
+            statements.push(wrap_dameng_identity_insert_sql_for_table(&insert_sql, &table));
+        } else {
+            statements.push(insert_sql);
+        }
+    }
+
+    Ok(statements)
+}
+
+fn is_postgres_tsvector_export_column(database_type: Option<DatabaseType>, column_type: Option<&str>) -> bool {
+    database_type == Some(DatabaseType::Postgres)
+        && column_type
+            .map(|column_type| {
+                let normalized = column_type.trim().trim_matches('"').to_ascii_lowercase();
+                normalized == "tsvector" || normalized.ends_with(".tsvector")
+            })
+            .unwrap_or(false)
+}
+
+fn is_postgres_json_export_column(database_type: Option<DatabaseType>, column_type: Option<&str>) -> bool {
+    database_type == Some(DatabaseType::Postgres)
+        && column_type
+            .map(|column_type| {
+                let normalized = column_type.trim().trim_matches('"').to_ascii_lowercase();
+                matches!(normalized.as_str(), "json" | "jsonb")
+                    || normalized.ends_with(".json")
+                    || normalized.ends_with(".jsonb")
+            })
+            .unwrap_or(false)
+}
+
+fn is_postgres_vector_export_column(database_type: Option<DatabaseType>, column_type: Option<&str>) -> bool {
+    database_type == Some(DatabaseType::Postgres)
+        && column_type
+            .map(|column_type| {
+                let normalized = column_type.trim().trim_matches('"').to_ascii_lowercase();
+                let base = normalized.split(['(', ' ', '\t', '\n']).next().unwrap_or("").trim_matches('"');
+                matches!(base, "vector" | "halfvec") || base.ends_with(".vector") || base.ends_with(".halfvec")
+            })
+            .unwrap_or(false)
+}
+
+pub fn build_export_sql_insert(options: BuildExportSqlInsertOptions) -> Result<String, String> {
+    build_export_insert_statements(options.insert).map(|statements| statements.join("\n"))
+}
+
+pub fn build_database_sql_export(options: BuildDatabaseSqlExportOptions) -> Result<String, String> {
+    let exported_at = options.exported_at.unwrap_or_else(|| chrono::Utc::now().to_rfc3339());
+    let row_limit = options.row_limit_per_table.unwrap_or(DATABASE_EXPORT_ROW_LIMIT);
+    let insert_batch_size = options.insert_batch_size.unwrap_or(DATABASE_EXPORT_INSERT_BATCH_SIZE);
+    let mut lines = vec![
+        "-- DBX database export".to_string(),
+        format!("-- Database: {}", options.database_name),
+        format!("-- Exported at: {exported_at}"),
+        format!("-- Row limit per table: {row_limit}"),
+        String::new(),
+    ];
+
+    for table in options.tables {
+        if let Some(ddl) = table.ddl.as_ref().map(|ddl| ddl.trim()).filter(|ddl| !ddl.is_empty()) {
+            let ddl = normalize_export_table_ddl(ddl, table.database_type);
+            lines.push(format!("-- Structure for {}", table.display_name));
+            lines.push(format!("{};", ddl.trim_end_matches(';')));
+            lines.push(String::new());
+        }
+
+        lines.push(format!("-- Data for {}", table.display_name));
+        if table.truncated {
+            lines.push(format!("-- Exported rows: {} (truncated at {row_limit})", table.rows.len()));
+        } else {
+            lines.push(format!("-- Exported rows: {}", table.rows.len()));
+        }
+
+        let inserts = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: table.database_type,
+            schema: table.schema,
+            table_name: table.table_name,
+            qualified_table_name: table.qualified_table_name,
+            columns: table.columns,
+            column_types: table.column_types,
+            column_extras: table.column_extras,
+            rows: table.rows,
+            batch_size: Some(insert_batch_size),
+        })?;
+        if inserts.is_empty() {
+            lines.push("-- No rows".to_string());
+        } else {
+            lines.extend(inserts);
+        }
+        lines.push(String::new());
+    }
+
+    Ok(lines.join("\n"))
+}
+
+fn export_qualified_table_name(
+    database_type: Option<DatabaseType>,
+    schema: Option<&str>,
+    table_name: Option<&str>,
+    qualified_name: Option<&str>,
+) -> Result<String, String> {
+    if let Some(name) = qualified_name.filter(|name| !name.trim().is_empty()) {
+        return Ok(name.to_string());
+    }
+    let table_name = table_name
+        .filter(|name| !name.trim().is_empty())
+        .ok_or_else(|| "tableName is required when qualifiedTableName is not provided".to_string())?;
+    Ok(qualified_table_name(database_type, schema, table_name))
+}
+
+fn normalize_export_table_ddl(ddl: &str, database_type: Option<DatabaseType>) -> String {
+    if database_type != Some(DatabaseType::Mysql) {
+        return ddl.to_string();
+    }
+
+    static LEGACY_MYSQL_ROW_FORMAT_RE: std::sync::LazyLock<regex::Regex> =
+        std::sync::LazyLock::new(|| regex::Regex::new(r"(?i)\bROW_FORMAT\s*=\s*(COMPACT|REDUNDANT)\b").unwrap());
+
+    LEGACY_MYSQL_ROW_FORMAT_RE.replace_all(ddl, "ROW_FORMAT=DYNAMIC").into_owned()
+}
+
+fn postgres_sequence_qualified_name(schema: &str, sequence_name: &str) -> String {
+    let db_type = DatabaseType::Postgres;
+    if schema.trim().is_empty() {
+        quote_identifier(sequence_name, &db_type)
+    } else {
+        format!("{}.{}", quote_identifier(schema, &db_type), quote_identifier(sequence_name, &db_type))
+    }
+}
+
+fn postgres_string_literal(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+fn generate_postgres_sequence_create_ddl(sequence: &PostgresExportSequence, schema: &str) -> String {
+    let qualified_name = postgres_sequence_qualified_name(schema, &sequence.name);
+    let cycle = if sequence.cycle { "CYCLE" } else { "NO CYCLE" };
+    format!(
+        "CREATE SEQUENCE IF NOT EXISTS {qualified_name}\n  AS {data_type}\n  START WITH {start_value}\n  INCREMENT BY {increment}\n  MINVALUE {min_value}\n  MAXVALUE {max_value}\n  CACHE {cache_value}\n  {cycle}",
+        data_type = sequence.data_type,
+        start_value = sequence.start_value,
+        increment = sequence.increment,
+        min_value = sequence.min_value,
+        max_value = sequence.max_value,
+        cache_value = sequence.cache_value,
+    )
+}
+
+fn generate_postgres_sequence_owner_ddl(sequence: &PostgresExportSequence, schema: &str) -> Option<String> {
+    let owner_table = sequence.owner_table.as_deref()?;
+    let owner_column = sequence.owner_column.as_deref()?;
+    Some(format!(
+        "ALTER SEQUENCE {} OWNED BY {}.{}",
+        postgres_sequence_qualified_name(schema, &sequence.name),
+        crate::transfer::qualified_table(owner_table, schema, &DatabaseType::Postgres),
+        quote_identifier(owner_column, &DatabaseType::Postgres)
+    ))
+}
+
+fn generate_postgres_sequence_setval_sql(sequence: &PostgresExportSequence, schema: &str) -> Option<String> {
+    let last_value = sequence.last_value.as_deref()?.trim();
+    if last_value.is_empty() {
+        return None;
+    }
+
+    let sequence_literal = postgres_string_literal(&postgres_sequence_qualified_name(schema, &sequence.name));
+    match (sequence.owner_table.as_deref(), sequence.owner_column.as_deref()) {
+        (Some(owner_table), Some(owner_column)) => {
+            let owner_table = crate::transfer::qualified_table(owner_table, schema, &DatabaseType::Postgres);
+            let owner_column = quote_identifier(owner_column, &DatabaseType::Postgres);
+            Some(format!(
+                "SELECT setval({sequence_literal}, GREATEST(COALESCE(MAX({owner_column}), {last_value}), {last_value}), true) FROM {owner_table}"
+            ))
+        }
+        _ => Some(format!("SELECT setval({sequence_literal}, {last_value}, true)")),
+    }
+}
+
+async fn list_postgres_export_sequences(
+    state: &crate::connection::AppState,
+    pool_key: &str,
+    schema: &str,
+    selected_tables: &[String],
+    include_objects: bool,
+) -> Result<Vec<PostgresExportSequence>, String> {
+    let pool = {
+        let connections = state.connections.read().await;
+        match connections.get(pool_key) {
+            Some(crate::connection::PoolKind::Postgres(pool)) => pool.clone(),
+            _ => return Ok(Vec::new()),
+        }
+    };
+    let client = pool.get().await.map_err(|e| e.to_string())?;
+    let rows = client
+        .query(
+            "SELECT c.relname, \
+              COALESCE(format_type(s.seqtypid, NULL), 'bigint'), \
+              COALESCE(s.seqstart::text, '1'), \
+              COALESCE(s.seqmin::text, '1'), \
+              COALESCE(s.seqmax::text, '9223372036854775807'), \
+              COALESCE(s.seqincrement::text, '1'), \
+              COALESCE(s.seqcycle, false), \
+              COALESCE(s.seqcache::text, '1'), \
+              t.relname, \
+              a.attname \
+             FROM pg_class c \
+             JOIN pg_namespace n ON n.oid = c.relnamespace \
+             LEFT JOIN pg_sequence s ON s.seqrelid = c.oid \
+             LEFT JOIN pg_depend d ON d.classid = 'pg_class'::regclass \
+               AND d.objid = c.oid \
+               AND d.refclassid = 'pg_class'::regclass \
+               AND d.deptype IN ('a', 'i') \
+             LEFT JOIN pg_class t ON t.oid = d.refobjid \
+             LEFT JOIN pg_namespace tn ON tn.oid = t.relnamespace AND tn.nspname = n.nspname \
+             LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = d.refobjsubid \
+             WHERE c.relkind = 'S' AND n.nspname = $1 \
+             ORDER BY c.relname",
+            &[&schema],
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let selected: HashSet<&str> = selected_tables.iter().map(String::as_str).collect();
+    let mut sequences = rows
+        .iter()
+        .map(|row| PostgresExportSequence {
+            name: row.get::<_, String>(0),
+            data_type: row.get::<_, String>(1),
+            start_value: row.get::<_, String>(2),
+            min_value: row.get::<_, String>(3),
+            max_value: row.get::<_, String>(4),
+            increment: row.get::<_, String>(5),
+            cycle: row.get::<_, bool>(6),
+            cache_value: row.get::<_, String>(7),
+            last_value: None,
+            owner_table: row.get::<_, Option<String>>(8),
+            owner_column: row.get::<_, Option<String>>(9),
+        })
+        .filter(|sequence| {
+            selected.is_empty()
+                || sequence.owner_table.as_deref().map(|owner_table| selected.contains(owner_table)).unwrap_or(false)
+        })
+        .filter(|sequence| sequence.owner_table.is_some() || (include_objects && selected.is_empty()))
+        .collect::<Vec<_>>();
+
+    if sequences.is_empty() {
+        return Ok(sequences);
+    }
+
+    if let Ok(rows) = client
+        .query(
+            "SELECT c.relname, pg_sequence_last_value(c.oid)::text \
+             FROM pg_class c \
+             JOIN pg_namespace n ON n.oid = c.relnamespace \
+             WHERE c.relkind = 'S' AND n.nspname = $1",
+            &[&schema],
+        )
+        .await
+    {
+        for row in rows {
+            let name: String = row.get(0);
+            let last_value: Option<String> = row.get(1);
+            if let Some(sequence) = sequences.iter_mut().find(|sequence| sequence.name == name) {
+                sequence.last_value = last_value;
+            }
+        }
+    }
+
+    Ok(sequences)
+}
+
+pub async fn is_export_cancelled(export_id: &str) -> bool {
+    EXPORT_CANCELLED.read().await.contains(export_id)
+}
+
+pub async fn set_export_cancelled(export_id: &str) {
+    EXPORT_CANCELLED.write().await.insert(export_id.to_string());
+}
+
+pub async fn clear_export_cancelled(export_id: &str) {
+    EXPORT_CANCELLED.write().await.remove(export_id);
+}
+
+pub async fn export_database_sql_core(
+    state: &crate::connection::AppState,
+    request: &DatabaseExportRequest,
+    on_progress: impl Fn(ExportProgress),
+) -> Result<(), String> {
+    // 1. Get database type
+    let db_type = state
+        .configs
+        .read()
+        .await
+        .get(&request.connection_id)
+        .map(|c| c.db_type)
+        .ok_or_else(|| format!("Connection config not found: {}", request.connection_id))?;
+
+    // 2. Get pool
+    let client_session_id = database_export_client_session_id(&request.export_id);
+    let pool_key = state
+        .get_or_create_pool_for_session(&request.connection_id, Some(&request.database), Some(&client_session_id))
+        .await?;
+
+    // 3. List tables
+    let all_tables = crate::schema::list_tables_core(
+        state,
+        &request.connection_id,
+        &request.database,
+        &request.schema,
+        None,
+        None,
+        None,
+        None,
+    )
+    .await?;
+    let all_tables = filter_selected_table_infos(all_tables, &request.selected_tables);
+
+    // 4. Create file
+    let mut file = std::fs::File::create(&request.file_path).map_err(|e| format!("Failed to write file: {e}"))?;
+
+    // 5. Write header
+    let timestamp = chrono::Local::now().format("%Y-%m-%d %H:%M:%S");
+    writeln!(file, "-- Database export: {}", request.database).map_err(|e| format!("Failed to write file: {e}"))?;
+    writeln!(file, "-- Date: {timestamp}").map_err(|e| format!("Failed to write file: {e}"))?;
+    writeln!(file, "-- Generated by DBX").map_err(|e| format!("Failed to write file: {e}"))?;
+    writeln!(file).map_err(|e| format!("Failed to write file: {e}"))?;
+
+    // 6. For MySQL: disable foreign key checks
+    if matches!(db_type, DatabaseType::Mysql) {
+        writeln!(file, "SET FOREIGN_KEY_CHECKS = 0;\n").map_err(|e| format!("Failed to write file: {e}"))?;
+    }
+
+    // 7. Separate tables and views
+    let mut tables: Vec<_> = all_tables.iter().filter(|t| !t.table_type.contains("VIEW")).collect();
+    let views: Vec<_> = all_tables.iter().filter(|t| t.table_type.contains("VIEW")).collect();
+    let postgres_sequences = if request.include_structure && matches!(db_type, DatabaseType::Postgres) {
+        match list_postgres_export_sequences(
+            state,
+            &pool_key,
+            &request.schema,
+            &request.selected_tables,
+            request.include_objects,
+        )
+        .await
+        {
+            Ok(sequences) => sequences,
+            Err(e) => {
+                writeln!(file, "-- ERROR exporting sequences: {e}")
+                    .map_err(|e| format!("Failed to write file: {e}"))?;
+                Vec::new()
+            }
+        }
+    } else {
+        Vec::new()
+    };
+
+    // Sort tables by foreign key dependency so referenced (parent) tables are
+    // exported before referencing (child) tables.
+    if tables.len() > 1 {
+        let table_names: Vec<String> = tables.iter().map(|t| t.name.clone()).collect();
+        if let Ok(sorted_names) = crate::transfer::sort_tables_by_fk_dependency(
+            state,
+            &request.connection_id,
+            &request.database,
+            &request.schema,
+            &table_names,
+            true,
+        )
+        .await
+        {
+            tables.sort_by_key(|t| sorted_names.iter().position(|n| n == &t.name).unwrap_or(usize::MAX));
+        }
+    }
+
+    // 8. Calculate total objects
+    let mut total_objects = tables.len() + views.len() + postgres_sequences.len();
+
+    // We'll add procedures/functions count later if include_objects
+    let mut procedures: Vec<String> = Vec::new();
+    let mut functions: Vec<String> = Vec::new();
+
+    if request.include_objects && request.selected_tables.is_empty() {
+        if let Ok(objects) = crate::schema::list_objects_core(
+            state,
+            &request.connection_id,
+            &request.database,
+            &request.schema,
+            None,
+            None,
+            None,
+            None,
+        )
+        .await
+        {
+            for obj in &objects {
+                let ot = obj.object_type.to_uppercase();
+                if ot.contains("PROCEDURE") {
+                    procedures.push(obj.name.clone());
+                } else if ot.contains("FUNCTION") {
+                    functions.push(obj.name.clone());
+                }
+            }
+        }
+        total_objects += procedures.len() + functions.len();
+    }
+
+    let mut object_index: usize = 0;
+
+    // Export tables
+    let batch_size = if request.batch_size == 0 { 1000 } else { request.batch_size };
+
+    for sequence in postgres_sequences.iter().filter(|sequence| sequence.owner_table.is_none()) {
+        if is_export_cancelled(&request.export_id).await {
+            return Err("Export cancelled".to_string());
+        }
+
+        on_progress(ExportProgress {
+            export_id: request.export_id.clone(),
+            current_object: sequence.name.clone(),
+            object_index,
+            total_objects,
+            rows_exported: 0,
+            total_rows: None,
+            status: ExportStatus::Running,
+            error: None,
+        });
+
+        writeln!(file, "{};\n", generate_postgres_sequence_create_ddl(sequence, &request.schema))
+            .map_err(|e| format!("Failed to write file: {e}"))?;
+        object_index += 1;
+    }
+
+    for table_info in &tables {
+        // Check cancellation
+        if is_export_cancelled(&request.export_id).await {
+            on_progress(ExportProgress {
+                export_id: request.export_id.clone(),
+                current_object: table_info.name.clone(),
+                object_index,
+                total_objects,
+                rows_exported: 0,
+                total_rows: None,
+                status: ExportStatus::Cancelled,
+                error: None,
+            });
+            return Ok(());
+        }
+
+        let table_name = &table_info.name;
+
+        // Emit Running progress
+        on_progress(ExportProgress {
+            export_id: request.export_id.clone(),
+            current_object: table_name.clone(),
+            object_index,
+            total_objects,
+            rows_exported: 0,
+            total_rows: None,
+            status: ExportStatus::Running,
+            error: None,
+        });
+
+        // Export structure
+        if request.include_structure {
+            if request.drop_table_if_exists {
+                writeln!(file, "{}\n", drop_table_if_exists_sql(table_name, &request.schema, &db_type))
+                    .map_err(|e| format!("Failed to write file: {e}"))?;
+            }
+            for sequence in postgres_sequences
+                .iter()
+                .filter(|sequence| sequence.owner_table.as_deref() == Some(table_name.as_str()))
+            {
+                on_progress(ExportProgress {
+                    export_id: request.export_id.clone(),
+                    current_object: sequence.name.clone(),
+                    object_index,
+                    total_objects,
+                    rows_exported: 0,
+                    total_rows: None,
+                    status: ExportStatus::Running,
+                    error: None,
+                });
+
+                writeln!(file, "{};\n", generate_postgres_sequence_create_ddl(sequence, &request.schema))
+                    .map_err(|e| format!("Failed to write file: {e}"))?;
+                object_index += 1;
+            }
+            match crate::schema::get_table_ddl_core(
+                state,
+                &request.connection_id,
+                &request.database,
+                &request.schema,
+                table_name,
+                None,
+            )
+            .await
+            {
+                Ok(ddl) => {
+                    let ddl = normalize_export_table_ddl(&ddl, Some(db_type));
+                    writeln!(file, "{};\n", ddl).map_err(|e| format!("Failed to write file: {e}"))?;
+                }
+                Err(e) => {
+                    writeln!(file, "-- ERROR exporting table {table_name}: {e}")
+                        .map_err(|e| format!("Failed to write file: {e}"))?;
+                }
+            }
+        }
+
+        // Export data
+        if request.include_data {
+            // Get columns
+            let columns = match crate::schema::get_columns_core(
+                state,
+                &request.connection_id,
+                &request.database,
+                &request.schema,
+                table_name,
+            )
+            .await
+            {
+                Ok(cols) => cols,
+                Err(e) => {
+                    writeln!(file, "-- ERROR exporting table {table_name}: {e}")
+                        .map_err(|e| format!("Failed to write file: {e}"))?;
+                    object_index += 1;
+                    continue;
+                }
+            };
+            let col_names = columns.iter().map(|c| c.name.clone()).collect::<Vec<_>>();
+            let col_types = columns.iter().map(|c| Some(c.data_type.clone())).collect::<Vec<_>>();
+            let col_extras = columns.iter().map(|c| c.extra.clone()).collect::<Vec<_>>();
+
+            if !col_names.is_empty() {
+                // Get row count
+                let count_query = crate::transfer::count_sql(table_name, &request.schema, &db_type);
+                let total_rows = match crate::transfer::execute_read_on_pool(state, &pool_key, &count_query).await {
+                    Ok(result) => result.rows.first().and_then(|r| r.first()).and_then(|v| match v {
+                        serde_json::Value::Number(n) => n.as_u64(),
+                        serde_json::Value::String(s) => s.parse::<u64>().ok(),
+                        _ => None,
+                    }),
+                    Err(_) => None,
+                };
+
+                // Loop batches
+                let mut offset: u64 = 0;
+                let mut rows_exported: u64 = 0;
+
+                loop {
+                    // Check cancellation between batches
+                    if is_export_cancelled(&request.export_id).await {
+                        on_progress(ExportProgress {
+                            export_id: request.export_id.clone(),
+                            current_object: table_name.clone(),
+                            object_index,
+                            total_objects,
+                            rows_exported,
+                            total_rows,
+                            status: ExportStatus::Cancelled,
+                            error: None,
+                        });
+                        return Ok(());
+                    }
+
+                    let sql = crate::transfer::pagination_sql(
+                        &col_names,
+                        table_name,
+                        &request.schema,
+                        &db_type,
+                        offset,
+                        batch_size,
+                    );
+
+                    let result = match crate::transfer::execute_read_on_pool(state, &pool_key, &sql).await {
+                        Ok(r) => r,
+                        Err(e) => {
+                            writeln!(file, "-- ERROR exporting data for table {table_name}: {e}")
+                                .map_err(|e| format!("Failed to write file: {e}"))?;
+                            break;
+                        }
+                    };
+
+                    let row_count = result.rows.len();
+                    if row_count == 0 {
+                        break;
+                    }
+
+                    let mut insert_sql = crate::transfer::generate_insert_typed(
+                        &col_names,
+                        &col_types,
+                        &result.rows,
+                        table_name,
+                        &request.schema,
+                        &db_type,
+                    );
+                    if db_type == DatabaseType::Dameng
+                        && selected_columns_include_identity_extras(&col_names, &col_extras)
+                    {
+                        insert_sql = wrap_dameng_identity_insert_sql(&insert_sql, table_name, &request.schema);
+                    }
+
+                    if !insert_sql.is_empty() {
+                        if insert_sql.trim_end().ends_with(';') {
+                            writeln!(file, "{}\n", insert_sql).map_err(|e| format!("Failed to write file: {e}"))?;
+                        } else {
+                            writeln!(file, "{};\n", insert_sql).map_err(|e| format!("Failed to write file: {e}"))?;
+                        }
+                    }
+
+                    rows_exported += row_count as u64;
+                    offset += row_count as u64;
+
+                    on_progress(ExportProgress {
+                        export_id: request.export_id.clone(),
+                        current_object: table_name.clone(),
+                        object_index,
+                        total_objects,
+                        rows_exported,
+                        total_rows,
+                        status: ExportStatus::Running,
+                        error: None,
+                    });
+
+                    if row_count < batch_size {
+                        break;
+                    }
+                }
+            }
+        }
+
+        object_index += 1;
+    }
+
+    if request.include_structure && !postgres_sequences.is_empty() {
+        for sequence in &postgres_sequences {
+            if let Some(sql) = generate_postgres_sequence_owner_ddl(sequence, &request.schema) {
+                writeln!(file, "{};\n", sql).map_err(|e| format!("Failed to write file: {e}"))?;
+            }
+        }
+        for sequence in &postgres_sequences {
+            if let Some(sql) = generate_postgres_sequence_setval_sql(sequence, &request.schema) {
+                writeln!(file, "{};\n", sql).map_err(|e| format!("Failed to write file: {e}"))?;
+            }
+        }
+    }
+
+    // Export views (if include_objects)
+    if request.include_objects {
+        for view_info in &views {
+            if is_export_cancelled(&request.export_id).await {
+                return Err("Export cancelled".to_string());
+            }
+
+            let view_name = &view_info.name;
+
+            on_progress(ExportProgress {
+                export_id: request.export_id.clone(),
+                current_object: view_name.clone(),
+                object_index,
+                total_objects,
+                rows_exported: 0,
+                total_rows: None,
+                status: ExportStatus::Running,
+                error: None,
+            });
+
+            match crate::schema::get_object_source_core(
+                state,
+                &request.connection_id,
+                &request.database,
+                &request.schema,
+                view_name,
+                crate::db::ObjectSourceKind::View,
+                None,
+            )
+            .await
+            {
+                Ok(obj_source) => {
+                    let source =
+                        build_export_object_source_sql(db_type, crate::db::ObjectSourceKind::View, &obj_source.source);
+                    if !source.is_empty() {
+                        writeln!(file, "{source}\n").map_err(|e| format!("Failed to write file: {e}"))?;
+                    }
+                }
+                Err(e) => {
+                    writeln!(file, "-- ERROR exporting view {view_name}: {e}")
+                        .map_err(|e| format!("Failed to write file: {e}"))?;
+                }
+            }
+
+            object_index += 1;
+        }
+
+        // Export procedures
+        for proc_name in &procedures {
+            if is_export_cancelled(&request.export_id).await {
+                return Err("Export cancelled".to_string());
+            }
+
+            on_progress(ExportProgress {
+                export_id: request.export_id.clone(),
+                current_object: proc_name.clone(),
+                object_index,
+                total_objects,
+                rows_exported: 0,
+                total_rows: None,
+                status: ExportStatus::Running,
+                error: None,
+            });
+
+            match crate::schema::get_object_source_core(
+                state,
+                &request.connection_id,
+                &request.database,
+                &request.schema,
+                proc_name,
+                crate::db::ObjectSourceKind::Procedure,
+                None,
+            )
+            .await
+            {
+                Ok(obj_source) => {
+                    let source = build_export_object_source_sql(
+                        db_type,
+                        crate::db::ObjectSourceKind::Procedure,
+                        &obj_source.source,
+                    );
+                    if !source.is_empty() {
+                        writeln!(file, "{source}\n").map_err(|e| format!("Failed to write file: {e}"))?;
+                    }
+                }
+                Err(e) => {
+                    writeln!(file, "-- ERROR exporting procedure {proc_name}: {e}")
+                        .map_err(|e| format!("Failed to write file: {e}"))?;
+                }
+            }
+
+            object_index += 1;
+        }
+
+        // Export functions
+        for func_name in &functions {
+            if is_export_cancelled(&request.export_id).await {
+                return Err("Export cancelled".to_string());
+            }
+
+            on_progress(ExportProgress {
+                export_id: request.export_id.clone(),
+                current_object: func_name.clone(),
+                object_index,
+                total_objects,
+                rows_exported: 0,
+                total_rows: None,
+                status: ExportStatus::Running,
+                error: None,
+            });
+
+            match crate::schema::get_object_source_core(
+                state,
+                &request.connection_id,
+                &request.database,
+                &request.schema,
+                func_name,
+                crate::db::ObjectSourceKind::Function,
+                None,
+            )
+            .await
+            {
+                Ok(obj_source) => {
+                    let source = build_export_object_source_sql(
+                        db_type,
+                        crate::db::ObjectSourceKind::Function,
+                        &obj_source.source,
+                    );
+                    if !source.is_empty() {
+                        writeln!(file, "{source}\n").map_err(|e| format!("Failed to write file: {e}"))?;
+                    }
+                }
+                Err(e) => {
+                    writeln!(file, "-- ERROR exporting function {func_name}: {e}")
+                        .map_err(|e| format!("Failed to write file: {e}"))?;
+                }
+            }
+
+            object_index += 1;
+        }
+    }
+
+    // For MySQL: re-enable foreign key checks
+    if matches!(db_type, DatabaseType::Mysql) {
+        writeln!(file, "SET FOREIGN_KEY_CHECKS = 1;").map_err(|e| format!("Failed to write file: {e}"))?;
+    }
+
+    // Emit Done progress
+    on_progress(ExportProgress {
+        export_id: request.export_id.clone(),
+        current_object: String::new(),
+        object_index,
+        total_objects,
+        rows_exported: 0,
+        total_rows: None,
+        status: ExportStatus::Done,
+        error: None,
+    });
+
+    Ok(())
+}
+
+fn filter_selected_table_infos(
+    tables: Vec<crate::types::TableInfo>,
+    selected_tables: &[String],
+) -> Vec<crate::types::TableInfo> {
+    if selected_tables.is_empty() {
+        return tables;
+    }
+    let selected: HashSet<&str> = selected_tables.iter().map(String::as_str).collect();
+    tables.into_iter().filter(|table| selected.contains(table.name.as_str())).collect()
+}
+
+fn drop_table_if_exists_sql(table_name: &str, schema: &str, db_type: &DatabaseType) -> String {
+    format!("DROP TABLE IF EXISTS {};", crate::transfer::qualified_table(table_name, schema, db_type))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        build_database_sql_export, build_export_insert_statements, drop_table_if_exists_sql,
+        filter_selected_table_infos, format_export_sql_literal, generate_postgres_sequence_create_ddl,
+        generate_postgres_sequence_owner_ddl, generate_postgres_sequence_setval_sql, normalize_export_table_ddl,
+        BuildDatabaseSqlExportOptions, BuildExportInsertStatementsOptions, ExportedTableSql, PostgresExportSequence,
+        DATABASE_EXPORT_INSERT_BATCH_SIZE, DATABASE_EXPORT_ROW_LIMIT,
+    };
+    use crate::models::connection::DatabaseType;
+    use crate::types::TableInfo;
+    use serde_json::{json, Value};
+
+    fn table(name: &str, table_type: &str) -> TableInfo {
+        TableInfo {
+            name: name.to_string(),
+            table_type: table_type.to_string(),
+            comment: None,
+            parent_schema: None,
+            parent_name: None,
+        }
+    }
+
+    #[test]
+    fn filters_export_tables_by_selected_names() {
+        let tables = vec![table("users", "TABLE"), table("orders", "TABLE"), table("active_users", "VIEW")];
+
+        let filtered = filter_selected_table_infos(tables, &["active_users".to_string(), "users".to_string()]);
+
+        assert_eq!(filtered.iter().map(|table| table.name.as_str()).collect::<Vec<_>>(), vec!["users", "active_users"]);
+    }
+
+    #[test]
+    fn keeps_all_export_tables_when_selection_is_empty() {
+        let tables = vec![table("users", "TABLE"), table("orders", "TABLE")];
+
+        let filtered = filter_selected_table_infos(tables.clone(), &[]);
+
+        assert_eq!(filtered.iter().map(|table| table.name.as_str()).collect::<Vec<_>>(), vec!["users", "orders"]);
+    }
+
+    #[test]
+    fn builds_drop_table_if_exists_with_qualified_mysql_name() {
+        let sql = drop_table_if_exists_sql("users", "app", &DatabaseType::Mysql);
+
+        assert_eq!(sql, "DROP TABLE IF EXISTS `users`;");
+    }
+
+    #[test]
+    fn builds_drop_table_if_exists_without_empty_schema() {
+        let sql = drop_table_if_exists_sql("users", "", &DatabaseType::Postgres);
+
+        assert_eq!(sql, "DROP TABLE IF EXISTS \"users\";");
+    }
+
+    #[test]
+    fn formats_sql_literals_for_export_inserts() {
+        assert_eq!(format_export_sql_literal(&Value::Null), "NULL");
+        assert_eq!(format_export_sql_literal(&json!(42)), "42");
+        assert_eq!(format_export_sql_literal(&json!(true)), "TRUE");
+        assert_eq!(format_export_sql_literal(&json!("O'Hara")), "'O''Hara'");
+    }
+
+    #[test]
+    fn mysql_export_inserts_escape_control_characters() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Mysql),
+            schema: None,
+            table_name: Some("notes".to_string()),
+            qualified_table_name: None,
+            columns: vec!["body".to_string()],
+            column_types: vec![Some("text".to_string())],
+            column_extras: Vec::new(),
+            rows: vec![vec![json!("line1\nline2\tcol\rend\\slash\0\x1aO'Hara")]],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec!["INSERT INTO `notes` (`body`) VALUES ('line1\\nline2\\tcol\\rend\\\\slash\\0\\ZO''Hara');"]
+        );
+    }
+
+    #[test]
+    fn doris_export_inserts_escape_control_characters() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Doris),
+            schema: Some("warehouse".to_string()),
+            table_name: Some("events".to_string()),
+            qualified_table_name: None,
+            columns: vec!["message".to_string()],
+            column_types: vec![Some("varchar(255)".to_string())],
+            column_extras: Vec::new(),
+            rows: vec![vec![json!("first\nsecond\tthird")]],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(statements, vec!["INSERT INTO `warehouse`.`events` (`message`) VALUES ('first\\nsecond\\tthird');"]);
+    }
+
+    #[test]
+    fn postgres_export_inserts_keep_literal_control_characters() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Postgres),
+            schema: Some("public".to_string()),
+            table_name: Some("notes".to_string()),
+            qualified_table_name: None,
+            columns: vec!["body".to_string()],
+            column_types: vec![Some("text".to_string())],
+            column_extras: Vec::new(),
+            rows: vec![vec![json!("line1\nline2\tend")]],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(statements, vec!["INSERT INTO \"public\".\"notes\" (\"body\") VALUES ('line1\nline2\tend');"]);
+    }
+
+    #[test]
+    fn postgres_jsonb_export_preserves_json_escape_sequences() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Postgres),
+            schema: Some("public".to_string()),
+            table_name: Some("events".to_string()),
+            qualified_table_name: None,
+            columns: vec!["payload".to_string()],
+            column_types: vec![Some("jsonb".to_string())],
+            column_extras: Vec::new(),
+            rows: vec![vec![json!(r#"{"text":"say \"hi\"","path":"C:\\tmp","quote":"O'Hara"}"#)]],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                r#"INSERT INTO "public"."events" ("payload") VALUES ('{"text":"say \"hi\"","path":"C:\\tmp","quote":"O''Hara"}');"#
+            ]
+        );
+    }
+
+    #[test]
+    fn postgres_vector_export_preserves_pgvector_bracket_literals() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Postgres),
+            schema: Some("public".to_string()),
+            table_name: Some("items".to_string()),
+            qualified_table_name: None,
+            columns: vec![
+                "id".to_string(),
+                "embedding".to_string(),
+                "qualified_embedding".to_string(),
+                "labels".to_string(),
+            ],
+            column_types: vec![
+                Some("integer".to_string()),
+                Some("vector(2)".to_string()),
+                Some("public.vector".to_string()),
+                Some("text[]".to_string()),
+            ],
+            column_extras: Vec::new(),
+            rows: vec![vec![json!(1), json!([1.2, 3.4]), json!(["5", "6"]), json!(["x", "y"])]],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                r#"INSERT INTO "public"."items" ("id", "embedding", "qualified_embedding", "labels") VALUES (1, '[1.2,3.4]', '[5,6]', '{"x","y"}');"#
+            ]
+        );
+    }
+
+    #[test]
+    fn builds_batched_insert_statements_for_export() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Mysql),
+            schema: None,
+            table_name: Some("users".to_string()),
+            qualified_table_name: None,
+            columns: vec!["id".to_string(), "name".to_string()],
+            column_types: Vec::new(),
+            column_extras: Vec::new(),
+            rows: vec![vec![json!(1), json!("Ada")], vec![json!(2), json!("O'Hara")], vec![json!(3), json!("Linus")]],
+            batch_size: Some(2),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                "INSERT INTO `users` (`id`, `name`) VALUES (1, 'Ada'), (2, 'O''Hara');",
+                "INSERT INTO `users` (`id`, `name`) VALUES (3, 'Linus');",
+            ]
+        );
+    }
+
+    #[test]
+    fn oracle_export_inserts_use_one_statement_per_row() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Oracle),
+            schema: Some("APP".to_string()),
+            table_name: Some("USERS".to_string()),
+            qualified_table_name: None,
+            columns: vec!["ID".to_string(), "NAME".to_string()],
+            column_types: Vec::new(),
+            column_extras: Vec::new(),
+            rows: vec![vec![json!(1), json!("Ada")], vec![json!(2), json!("Linus")]],
+            batch_size: Some(100),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                "INSERT INTO \"APP\".\"USERS\" (\"ID\", \"NAME\") VALUES (1, 'Ada');",
+                "INSERT INTO \"APP\".\"USERS\" (\"ID\", \"NAME\") VALUES (2, 'Linus');",
+            ]
+        );
+    }
+
+    #[test]
+    fn oracle_date_columns_export_as_date_literals() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Oracle),
+            schema: Some("APP".to_string()),
+            table_name: Some("EVENTS".to_string()),
+            qualified_table_name: None,
+            columns: vec!["ID".to_string(), "CREATED_ON".to_string(), "RAW_TEXT".to_string()],
+            column_types: vec![Some("NUMBER".to_string()), Some("DATE".to_string()), Some("VARCHAR2(64)".to_string())],
+            column_extras: Vec::new(),
+            rows: vec![
+                vec![json!(1), json!("2022-08-25T09:58:43Z"), json!("2022-08-25T09:58:43Z")],
+                vec![json!(2), json!("2022-08-25T00:00:00Z"), json!("2022-08-25T00:00:00Z")],
+            ],
+            batch_size: Some(100),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                "INSERT INTO \"APP\".\"EVENTS\" (\"ID\", \"CREATED_ON\", \"RAW_TEXT\") VALUES (1, TO_DATE('2022-08-25 09:58:43', 'YYYY-MM-DD HH24:MI:SS'), '2022-08-25T09:58:43Z');",
+                "INSERT INTO \"APP\".\"EVENTS\" (\"ID\", \"CREATED_ON\", \"RAW_TEXT\") VALUES (2, DATE '2022-08-25', '2022-08-25T00:00:00Z');",
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_bit_columns_export_without_quoted_string_values() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Mysql),
+            schema: None,
+            table_name: Some("flags".to_string()),
+            qualified_table_name: None,
+            columns: vec!["enabled".to_string(), "mask".to_string(), "label".to_string()],
+            column_types: vec![Some("bit(1)".to_string()), Some("BIT(4)".to_string()), Some("varchar(20)".to_string())],
+            column_extras: Vec::new(),
+            rows: vec![vec![json!("1"), json!("1010"), json!("1010")], vec![json!(false), json!(3), json!("off")]],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec!["INSERT INTO `flags` (`enabled`, `mask`, `label`) VALUES (b'1', b'1010', '1010'), (b'0', 3, 'off');"]
+        );
+    }
+
+    #[test]
+    fn mysql_export_uses_typed_literals_for_numeric_and_blob_columns() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Mysql),
+            schema: None,
+            table_name: Some("t_test_01".to_string()),
+            qualified_table_name: None,
+            columns: vec!["id".to_string(), "f_blob".to_string(), "note".to_string()],
+            column_types: vec![Some("int".to_string()), Some("blob".to_string()), Some("varchar(64)".to_string())],
+            column_extras: Vec::new(),
+            rows: vec![
+                vec![json!("1"), json!("0x68656c6c6f"), json!("0x68656c6c6f")],
+                vec![json!("2"), json!("0X"), json!("1")],
+            ],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                "INSERT INTO `t_test_01` (`id`, `f_blob`, `note`) VALUES (1, 0x68656c6c6f, '0x68656c6c6f'), (2, X'', '1');"
+            ]
+        );
+    }
+
+    #[test]
+    fn temporal_columns_export_without_rfc3339_separator_or_utc_suffix() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Mysql),
+            schema: None,
+            table_name: Some("events".to_string()),
+            qualified_table_name: None,
+            columns: vec!["id".to_string(), "created_at".to_string(), "created_on".to_string(), "raw_text".to_string()],
+            column_types: vec![
+                Some("int".to_string()),
+                Some("timestamp".to_string()),
+                Some("date".to_string()),
+                Some("varchar(64)".to_string()),
+            ],
+            column_extras: Vec::new(),
+            rows: vec![vec![
+                json!(1),
+                json!("2026-06-12T10:11:12.123456789Z"),
+                json!("2026-06-12T10:11:12Z"),
+                json!("2026-06-12T10:11:12Z"),
+            ]],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                "INSERT INTO `events` (`id`, `created_at`, `created_on`, `raw_text`) VALUES (1, '2026-06-12 10:11:12.123456', '2026-06-12', '2026-06-12T10:11:12Z');"
+            ]
+        );
+    }
+
+    #[test]
+    fn postgres_timestamptz_export_keeps_timezone_without_rfc3339_t_separator() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Postgres),
+            schema: Some("public".to_string()),
+            table_name: Some("events".to_string()),
+            qualified_table_name: None,
+            columns: vec!["recorded_at".to_string(), "local_at".to_string()],
+            column_types: vec![
+                Some("timestamp with time zone".to_string()),
+                Some("timestamp without time zone".to_string()),
+            ],
+            column_extras: Vec::new(),
+            rows: vec![vec![json!("2026-06-12T10:11:12Z"), json!("2026-06-12T18:11:12+08:00")]],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                "INSERT INTO \"public\".\"events\" (\"recorded_at\", \"local_at\") VALUES ('2026-06-12 10:11:12+00:00', '2026-06-12 18:11:12');"
+            ]
+        );
+    }
+
+    #[test]
+    fn sqlserver_rowversion_timestamp_type_is_not_treated_as_datetime() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::SqlServer),
+            schema: Some("dbo".to_string()),
+            table_name: Some("events".to_string()),
+            qualified_table_name: None,
+            columns: vec!["row_version".to_string(), "created_at".to_string()],
+            column_types: vec![Some("timestamp".to_string()), Some("datetime2(3)".to_string())],
+            column_extras: Vec::new(),
+            rows: vec![vec![json!("2026-06-12T10:11:12Z"), json!("2026-06-12T10:11:12.1234567Z")]],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                "INSERT INTO [dbo].[events] ([row_version], [created_at]) VALUES ('2026-06-12T10:11:12Z', '2026-06-12 10:11:12.123');"
+            ]
+        );
+    }
+
+    #[test]
+    fn postgres_tsvector_columns_are_omitted_from_sql_insert_export() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Postgres),
+            schema: Some("public".to_string()),
+            table_name: Some("articles".to_string()),
+            qualified_table_name: None,
+            columns: vec!["id".to_string(), "title".to_string(), "search_vector".to_string()],
+            column_types: vec![Some("integer".to_string()), Some("text".to_string()), Some("tsvector".to_string())],
+            column_extras: Vec::new(),
+            rows: vec![vec![json!(1), json!("Hello"), json!("'hello':1A")]],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(statements, vec!["INSERT INTO \"public\".\"articles\" (\"id\", \"title\") VALUES (1, 'Hello');"]);
+    }
+
+    #[test]
+    fn dameng_identity_export_inserts_enable_identity_insert() {
+        let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+            database_type: Some(DatabaseType::Dameng),
+            schema: Some("SYSDBA".to_string()),
+            table_name: Some("USERS".to_string()),
+            qualified_table_name: None,
+            columns: vec!["ID".to_string(), "NAME".to_string()],
+            column_types: vec![Some("INT".to_string()), Some("VARCHAR(20)".to_string())],
+            column_extras: vec![Some("identity".to_string()), None],
+            rows: vec![vec![json!(1), json!("Ada")]],
+            batch_size: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                "SET IDENTITY_INSERT \"SYSDBA\".\"USERS\" ON;\nINSERT INTO \"SYSDBA\".\"USERS\" (\"ID\", \"NAME\") VALUES (1, 'Ada');\nSET IDENTITY_INSERT \"SYSDBA\".\"USERS\" OFF;"
+            ]
+        );
+    }
+
+    #[test]
+    fn builds_database_sql_export_with_ddl_before_data() {
+        let sql = build_database_sql_export(BuildDatabaseSqlExportOptions {
+            database_name: "app".to_string(),
+            exported_at: Some("2026-05-02T00:00:00.000Z".to_string()),
+            tables: vec![ExportedTableSql {
+                display_name: "users".to_string(),
+                database_type: Some(DatabaseType::Mysql),
+                schema: None,
+                table_name: Some("users".to_string()),
+                qualified_table_name: None,
+                ddl: Some("CREATE TABLE `users` (`id` int);".to_string()),
+                columns: vec!["id".to_string()],
+                column_types: Vec::new(),
+                column_extras: Vec::new(),
+                rows: vec![vec![json!(1)]],
+                truncated: true,
+            }],
+            row_limit_per_table: Some(DATABASE_EXPORT_ROW_LIMIT),
+            insert_batch_size: Some(DATABASE_EXPORT_INSERT_BATCH_SIZE),
+            connection_id: None,
+            database: None,
+            schema: None,
+        })
+        .unwrap();
+
+        assert_eq!(
+            sql,
+            [
+                "-- DBX database export".to_string(),
+                "-- Database: app".to_string(),
+                "-- Exported at: 2026-05-02T00:00:00.000Z".to_string(),
+                format!("-- Row limit per table: {DATABASE_EXPORT_ROW_LIMIT}"),
+                String::new(),
+                "-- Structure for users".to_string(),
+                "CREATE TABLE `users` (`id` int);".to_string(),
+                String::new(),
+                "-- Data for users".to_string(),
+                format!("-- Exported rows: 1 (truncated at {DATABASE_EXPORT_ROW_LIMIT})"),
+                "INSERT INTO `users` (`id`) VALUES (1);".to_string(),
+                String::new(),
+            ]
+            .join("\n")
+        );
+    }
+
+    #[test]
+    fn normalizes_legacy_mysql_row_format_for_export_compatibility() {
+        let ddl = "CREATE TABLE `wide_table` (\n  `payload` varchar(4096) DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT";
+
+        let normalized = normalize_export_table_ddl(ddl, Some(DatabaseType::Mysql));
+
+        assert_eq!(
+            normalized,
+            "CREATE TABLE `wide_table` (\n  `payload` varchar(4096) DEFAULT NULL\n) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC"
+        );
+    }
+
+    #[test]
+    fn normalizes_lowercase_redundant_mysql_row_format_for_export_compatibility() {
+        let ddl = "CREATE TABLE `wide_table` (`payload` varchar(4096)) engine=InnoDB row_format = redundant";
+
+        let normalized = normalize_export_table_ddl(ddl, Some(DatabaseType::Mysql));
+
+        assert_eq!(normalized, "CREATE TABLE `wide_table` (`payload` varchar(4096)) engine=InnoDB ROW_FORMAT=DYNAMIC");
+    }
+
+    #[test]
+    fn preserves_non_legacy_or_non_mysql_row_formats() {
+        let mysql_ddl = "CREATE TABLE `ok` (`payload` text) ENGINE=InnoDB ROW_FORMAT=COMPRESSED";
+        let postgres_ddl = "CREATE TABLE users (payload text) ROW_FORMAT=COMPACT";
+
+        assert_eq!(normalize_export_table_ddl(mysql_ddl, Some(DatabaseType::Mysql)), mysql_ddl);
+        assert_eq!(normalize_export_table_ddl(postgres_ddl, Some(DatabaseType::Postgres)), postgres_ddl);
+    }
+
+    fn postgres_sequence(name: &str) -> PostgresExportSequence {
+        PostgresExportSequence {
+            name: name.to_string(),
+            data_type: "integer".to_string(),
+            start_value: "1".to_string(),
+            min_value: "1".to_string(),
+            max_value: "2147483647".to_string(),
+            increment: "1".to_string(),
+            cycle: false,
+            cache_value: "1".to_string(),
+            last_value: Some("42".to_string()),
+            owner_table: Some("permissions".to_string()),
+            owner_column: Some("id".to_string()),
+        }
+    }
+
+    #[test]
+    fn postgres_sequence_create_ddl_is_importable_before_table_ddl() {
+        let ddl = generate_postgres_sequence_create_ddl(&postgres_sequence("permissions_id_seq"), "public");
+
+        assert_eq!(
+            ddl,
+            [
+                "CREATE SEQUENCE IF NOT EXISTS \"public\".\"permissions_id_seq\"",
+                "  AS integer",
+                "  START WITH 1",
+                "  INCREMENT BY 1",
+                "  MINVALUE 1",
+                "  MAXVALUE 2147483647",
+                "  CACHE 1",
+                "  NO CYCLE",
+            ]
+            .join("\n")
+        );
+    }
+
+    #[test]
+    fn postgres_sequence_owner_and_setval_sql_are_qualified() {
+        let sequence = postgres_sequence("permissions_id_seq");
+
+        assert_eq!(
+            generate_postgres_sequence_owner_ddl(&sequence, "public").as_deref(),
+            Some("ALTER SEQUENCE \"public\".\"permissions_id_seq\" OWNED BY \"public\".\"permissions\".\"id\"")
+        );
+        assert_eq!(
+            generate_postgres_sequence_setval_sql(&sequence, "public").as_deref(),
+            Some(
+                "SELECT setval('\"public\".\"permissions_id_seq\"', GREATEST(COALESCE(MAX(\"id\"), 42), 42), true) FROM \"public\".\"permissions\""
+            )
+        );
+    }
+}
diff --git a/crates/dbx-core/src/database_search_sql.rs b/crates/dbx-core/src/database_search_sql.rs
new file mode 100644
index 0000000..036736d
--- /dev/null
+++ b/crates/dbx-core/src/database_search_sql.rs
@@ -0,0 +1,359 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use crate::models::connection::DatabaseType;
+use crate::sql_dialect::{
+    firebird_rows_clause, pagination_strategy, qualified_table_name, quote_table_identifier, PaginationContext,
+    TablePaginationStrategy,
+};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct DatabaseSearchColumn {
+    pub name: String,
+    pub data_type: String,
+    #[serde(default)]
+    pub is_primary_key: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DatabaseSearchSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub table_name: String,
+    #[serde(default)]
+    pub columns: Vec<DatabaseSearchColumn>,
+    pub term: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit: Option<usize>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DatabaseSearchSql {
+    pub sql: String,
+    pub searchable_columns: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SearchResultWhereOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default)]
+    pub columns: Vec<DatabaseSearchColumn>,
+    #[serde(default)]
+    pub result_columns: Vec<String>,
+    #[serde(default)]
+    pub row: Vec<Value>,
+    #[serde(default)]
+    pub matched_columns: Vec<String>,
+}
+
+const TEXT_TYPES: &[&str] =
+    &["char", "text", "clob", "varchar", "nvarchar", "nchar", "uuid", "uniqueidentifier", "enum"];
+const NUMBER_TYPES: &[&str] = &["int", "serial", "number", "numeric", "decimal", "float", "double", "real", "money"];
+const SKIPPED_TYPES: &[&str] = &["blob", "binary", "bytea", "image", "geometry", "geography"];
+
+pub fn is_text_search_column(column: &DatabaseSearchColumn) -> bool {
+    let data_type = column.data_type.to_ascii_lowercase();
+    if SKIPPED_TYPES.iter().any(|skipped| data_type.contains(skipped)) {
+        return false;
+    }
+    TEXT_TYPES.iter().any(|text_type| data_type.contains(text_type))
+}
+
+pub fn is_numeric_search_column(column: &DatabaseSearchColumn) -> bool {
+    let data_type = column.data_type.to_ascii_lowercase();
+    if SKIPPED_TYPES.iter().any(|skipped| data_type.contains(skipped)) {
+        return false;
+    }
+    NUMBER_TYPES.iter().any(|number_type| data_type.contains(number_type))
+}
+
+pub fn build_database_search_sql(options: DatabaseSearchSqlOptions) -> Option<DatabaseSearchSql> {
+    let term = clean_term(&options.term);
+    if term.is_empty() {
+        return None;
+    }
+
+    let text_columns: Vec<_> = options.columns.iter().filter(|column| is_text_search_column(column)).collect();
+    let numeric_term = parse_numeric_term(&term);
+    let numeric_columns: Vec<_> = if numeric_term.is_some() {
+        options.columns.iter().filter(|column| is_numeric_search_column(column)).collect()
+    } else {
+        Vec::new()
+    };
+
+    let mut conditions = Vec::new();
+    for column in &text_columns {
+        let identifier = quote_table_identifier(options.database_type, &column.name);
+        conditions.push(format!(
+            "{} LIKE {} ESCAPE '~'",
+            text_cast_expression(options.database_type, &identifier),
+            sql_string_literal(&like_pattern(&term))
+        ));
+    }
+    for column in &numeric_columns {
+        let identifier = quote_table_identifier(options.database_type, &column.name);
+        conditions.push(format!("{identifier} = {}", numeric_term.as_deref().unwrap_or_default()));
+    }
+    if conditions.is_empty() {
+        return None;
+    }
+
+    let table = qualified_table_name(options.database_type, options.schema.as_deref(), &options.table_name);
+    let where_clause = conditions.join(" OR ");
+    let limit = clamp_limit(options.limit);
+    let searchable_columns =
+        text_columns.iter().chain(numeric_columns.iter()).map(|column| column.name.clone()).collect();
+
+    let sql = match pagination_strategy(options.database_type, PaginationContext::BoundedRead) {
+        TablePaginationStrategy::SqlServerTop => format!("SELECT TOP {limit} * FROM {table} WHERE ({where_clause})"),
+        TablePaginationStrategy::IrisTop => format!("SELECT TOP {limit} * FROM {table} WHERE ({where_clause})"),
+        TablePaginationStrategy::InformixFirst => format!("SELECT FIRST {limit} * FROM {table} WHERE ({where_clause})"),
+        TablePaginationStrategy::FirebirdRows => {
+            let rows = firebird_rows_clause(limit, 0);
+            format!("SELECT * FROM {table} WHERE ({where_clause}) {rows}")
+        }
+        TablePaginationStrategy::Db2FetchFirst | TablePaginationStrategy::FetchFirst => {
+            format!("SELECT * FROM {table} WHERE ({where_clause}) FETCH FIRST {limit} ROWS ONLY")
+        }
+        TablePaginationStrategy::Rownum => {
+            format!("SELECT * FROM (SELECT * FROM {table} WHERE ({where_clause})) WHERE ROWNUM <= {limit}")
+        }
+        TablePaginationStrategy::AgentMaxRows => format!("SELECT * FROM {table} WHERE ({where_clause});"),
+        TablePaginationStrategy::QuestDbLimit | TablePaginationStrategy::LimitOffset => {
+            format!("SELECT * FROM {table} WHERE ({where_clause}) LIMIT {limit};")
+        }
+        TablePaginationStrategy::Unbounded => format!("SELECT * FROM {table} WHERE ({where_clause})"),
+    };
+
+    Some(DatabaseSearchSql { sql, searchable_columns })
+}
+
+pub fn build_search_result_where(options: SearchResultWhereOptions) -> String {
+    let mut value_by_column = std::collections::HashMap::new();
+    for (index, column) in options.result_columns.iter().enumerate() {
+        if let Some(value) = options.row.get(index) {
+            value_by_column.insert(column.to_ascii_lowercase(), value);
+        }
+    }
+
+    let primary_columns: Vec<_> = options
+        .columns
+        .iter()
+        .filter(|column| column.is_primary_key && value_by_column.contains_key(&column.name.to_ascii_lowercase()))
+        .collect();
+    let fallback_columns: Vec<_> = options
+        .columns
+        .iter()
+        .filter(|column| {
+            options.matched_columns.iter().any(|name| name.eq_ignore_ascii_case(&column.name))
+                && value_by_column.contains_key(&column.name.to_ascii_lowercase())
+        })
+        .collect();
+    let selected_columns = if primary_columns.is_empty() { fallback_columns } else { primary_columns };
+
+    selected_columns
+        .iter()
+        .take(3)
+        .map(|column| {
+            let identifier = quote_table_identifier(options.database_type, &column.name);
+            let value = value_by_column.get(&column.name.to_ascii_lowercase()).copied().unwrap_or(&Value::Null);
+            if value.is_null() {
+                format!("{identifier} IS NULL")
+            } else {
+                format!("{identifier} = {}", sql_value_literal(options.database_type, column, value))
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(" AND ")
+}
+
+fn clean_term(term: &str) -> String {
+    term.trim().to_string()
+}
+
+fn clamp_limit(limit: Option<usize>) -> usize {
+    limit.unwrap_or(20).clamp(1, 100)
+}
+
+fn parse_numeric_term(term: &str) -> Option<String> {
+    let trimmed = clean_term(term);
+    if trimmed.is_empty() {
+        return None;
+    }
+    let bytes = trimmed.as_bytes();
+    let start = usize::from(matches!(bytes.first(), Some(b'+') | Some(b'-')));
+    let number = &trimmed[start..];
+    if number.is_empty() {
+        return None;
+    }
+    let mut dot_count = 0;
+    let mut digit_count = 0;
+    for ch in number.chars() {
+        if ch == '.' {
+            dot_count += 1;
+            if dot_count > 1 {
+                return None;
+            }
+        } else if ch.is_ascii_digit() {
+            digit_count += 1;
+        } else {
+            return None;
+        }
+    }
+    if digit_count == 0 {
+        None
+    } else {
+        Some(trimmed)
+    }
+}
+
+fn sql_string_literal(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+fn like_pattern(term: &str) -> String {
+    let mut pattern = String::from("%");
+    for ch in clean_term(term).to_ascii_lowercase().chars() {
+        if matches!(ch, '~' | '%' | '_') {
+            pattern.push('~');
+        }
+        pattern.push(ch);
+    }
+    pattern.push('%');
+    pattern
+}
+
+fn text_cast_expression(database_type: Option<DatabaseType>, identifier: &str) -> String {
+    match database_type {
+        Some(DatabaseType::Mysql) => format!("LOWER(CAST({identifier} AS CHAR))"),
+        Some(DatabaseType::SqlServer) => format!("LOWER(CAST({identifier} AS NVARCHAR(MAX)))"),
+        Some(DatabaseType::Oracle | DatabaseType::OceanbaseOracle) => {
+            format!("LOWER(CAST({identifier} AS VARCHAR2(4000)))")
+        }
+        Some(DatabaseType::ClickHouse) => format!("lower(toString({identifier}))"),
+        _ => format!("LOWER(CAST({identifier} AS TEXT))"),
+    }
+}
+
+fn sql_value_literal(database_type: Option<DatabaseType>, column: &DatabaseSearchColumn, value: &Value) -> String {
+    match value {
+        Value::Null => "NULL".to_string(),
+        Value::Number(number) => number.to_string(),
+        Value::Bool(value) => {
+            if *value {
+                "TRUE".to_string()
+            } else {
+                "FALSE".to_string()
+            }
+        }
+        Value::String(value) => {
+            if is_numeric_search_column(column) && parse_numeric_term(value).is_some() {
+                return value.trim().to_string();
+            }
+            if database_type == Some(DatabaseType::SqlServer) {
+                format!("N{}", sql_string_literal(value))
+            } else {
+                sql_string_literal(value)
+            }
+        }
+        other => sql_string_literal(&other.to_string()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn col(name: &str, data_type: &str, is_primary_key: bool) -> DatabaseSearchColumn {
+        DatabaseSearchColumn { name: name.to_string(), data_type: data_type.to_string(), is_primary_key }
+    }
+
+    #[test]
+    fn builds_table_search_query_over_text_columns() {
+        let query = build_database_search_sql(DatabaseSearchSqlOptions {
+            database_type: Some(DatabaseType::Mysql),
+            schema: None,
+            table_name: "users".to_string(),
+            columns: vec![col("id", "bigint", true), col("email", "varchar", false), col("avatar", "blob", false)],
+            term: "alice@example.com".to_string(),
+            limit: Some(20),
+        })
+        .unwrap();
+
+        assert_eq!(query.searchable_columns, vec!["email"]);
+        assert_eq!(
+            query.sql,
+            "SELECT * FROM `users` WHERE (LOWER(CAST(`email` AS CHAR)) LIKE '%alice@example.com%' ESCAPE '~') LIMIT 20;"
+        );
+    }
+
+    #[test]
+    fn adds_numeric_predicates_only_for_numeric_terms() {
+        let query = build_database_search_sql(DatabaseSearchSqlOptions {
+            database_type: Some(DatabaseType::Postgres),
+            schema: Some("public".to_string()),
+            table_name: "orders".to_string(),
+            columns: vec![col("id", "integer", true), col("note", "text", false)],
+            term: "42".to_string(),
+            limit: Some(10),
+        })
+        .unwrap();
+
+        assert_eq!(query.searchable_columns, vec!["note", "id"]);
+        assert!(query.sql.contains("\"id\" = 42"));
+        assert!(query.sql.contains("FROM \"public\".\"orders\""));
+    }
+
+    #[test]
+    fn builds_oceanbase_oracle_search_query_with_rownum_limit() {
+        let query = build_database_search_sql(DatabaseSearchSqlOptions {
+            database_type: Some(DatabaseType::OceanbaseOracle),
+            schema: Some("APP".to_string()),
+            table_name: "USERS".to_string(),
+            columns: vec![col("NAME", "varchar2", false)],
+            term: "alice".to_string(),
+            limit: Some(20),
+        })
+        .unwrap();
+
+        assert_eq!(query.searchable_columns, vec!["NAME"]);
+        assert_eq!(
+            query.sql,
+            "SELECT * FROM (SELECT * FROM \"APP\".\"USERS\" WHERE (LOWER(CAST(\"NAME\" AS VARCHAR2(4000))) LIKE '%alice%' ESCAPE '~')) WHERE ROWNUM <= 20"
+        );
+    }
+
+    #[test]
+    fn returns_none_for_tables_without_searchable_columns() {
+        assert_eq!(
+            build_database_search_sql(DatabaseSearchSqlOptions {
+                database_type: Some(DatabaseType::Sqlite),
+                schema: None,
+                table_name: "files".to_string(),
+                columns: vec![col("payload", "blob", false)],
+                term: "needle".to_string(),
+                limit: None,
+            }),
+            None
+        );
+    }
+
+    #[test]
+    fn builds_stable_where_predicate_for_opening_result_rows() {
+        let where_clause = build_search_result_where(SearchResultWhereOptions {
+            database_type: Some(DatabaseType::SqlServer),
+            columns: vec![col("id", "integer", true), col("email", "varchar", false)],
+            result_columns: vec!["id".to_string(), "email".to_string()],
+            row: vec![Value::from(42), Value::from("alice@example.com")],
+            matched_columns: Vec::new(),
+        });
+
+        assert_eq!(where_clause, "[id] = 42");
+    }
+}
diff --git a/crates/dbx-core/src/db/agent_driver.rs b/crates/dbx-core/src/db/agent_driver.rs
new file mode 100644
index 0000000..d65dc8e
--- /dev/null
+++ b/crates/dbx-core/src/db/agent_driver.rs
@@ -0,0 +1,1988 @@
+use std::collections::VecDeque;
+use std::io::{BufRead, BufReader, BufWriter, Write};
+use std::path::{Path, PathBuf};
+use std::process::{Child, ChildStderr, ChildStdin, ChildStdout, Command, Stdio};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+
+use serde::de::DeserializeOwned;
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use tokio_util::sync::CancellationToken;
+
+pub const AGENT_PROTOCOL_VERSION: u32 = 1;
+const RPC_TIMEOUT_SECS: u64 = 30;
+const STARTUP_TIMEOUT_SECS: u64 = 15;
+const STDERR_TAIL_LINES: usize = 20;
+const AGENT_EXIT_DIAGNOSTIC_WAIT_MS: u64 = 1_000;
+const AGENT_EXIT_DIAGNOSTIC_POLL_MS: u64 = 10;
+const AGENT_JAVA_OPTS_ENV: &str = "DBX_AGENT_JAVA_OPTS";
+const AGENT_JAVA_TOO_OLD_MESSAGE: &str =
+    "Agent requires Java 21, but DBX started it with an older Java runtime. Use DBX managed JRE 21 or select a Java 21 executable in Driver Manager.";
+
+pub struct AgentDriverClient {
+    child: Child,
+    stdin: Option<BufWriter<ChildStdin>>,
+    stdout: Option<BufReader<ChildStdout>>,
+    stderr_tail: Arc<Mutex<StderrTail>>,
+    handshake: Option<AgentHandshake>,
+    next_id: u64,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AgentLaunchSpec {
+    pub program: PathBuf,
+    pub args: Vec<String>,
+    pub working_dir: Option<PathBuf>,
+}
+
+impl AgentLaunchSpec {
+    pub fn new(program: impl Into<PathBuf>) -> Self {
+        Self { program: program.into(), args: Vec::new(), working_dir: None }
+    }
+
+    pub fn java_jar(java_path: impl Into<PathBuf>, jar_path: impl AsRef<Path>) -> Self {
+        Self::java_jar_with_extra_args(java_path, jar_path, &[])
+    }
+
+    pub fn java_jar_with_extra_args(
+        java_path: impl Into<PathBuf>,
+        jar_path: impl AsRef<Path>,
+        extra_java_args: &[String],
+    ) -> Self {
+        let jar_path = jar_path.as_ref();
+        Self {
+            program: java_path.into(),
+            args: agent_java_args_with_extra_args(&jar_path.to_string_lossy(), extra_java_args),
+            working_dir: jar_path.parent().map(Path::to_path_buf),
+        }
+    }
+
+    pub fn with_args(mut self, args: impl IntoIterator<Item = impl Into<String>>) -> Self {
+        self.args = args.into_iter().map(Into::into).collect();
+        self
+    }
+
+    pub fn with_working_dir(mut self, working_dir: impl Into<PathBuf>) -> Self {
+        self.working_dir = Some(working_dir.into());
+        self
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentHandshake {
+    pub protocol_version: u32,
+    pub agent_protocol_version: u32,
+    pub capabilities: Vec<String>,
+}
+
+impl AgentHandshake {
+    pub fn supports(&self, capability: AgentCapability) -> bool {
+        self.capabilities.iter().any(|value| value == capability.as_str())
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AgentCapability {
+    Connect,
+    TestConnection,
+    Metadata,
+    Query,
+    PagedQuery,
+    Transaction,
+    Ddl,
+    Kv,
+}
+
+impl AgentCapability {
+    pub const ALL: [Self; 8] = [
+        Self::Connect,
+        Self::TestConnection,
+        Self::Metadata,
+        Self::Query,
+        Self::PagedQuery,
+        Self::Transaction,
+        Self::Ddl,
+        Self::Kv,
+    ];
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Connect => "connect",
+            Self::TestConnection => "test_connection",
+            Self::Metadata => "metadata",
+            Self::Query => "query",
+            Self::PagedQuery => "paged_query",
+            Self::Transaction => "transaction",
+            Self::Ddl => "ddl",
+            Self::Kv => "kv",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AgentMethod {
+    Handshake,
+    Connect,
+    TestConnection,
+    ValidateConnection,
+    ListDatabases,
+    ListSchemas,
+    ListTables,
+    ListObjects,
+    ListDataTypes,
+    CompletionAssistantSearchV1,
+    GetObjectSource,
+    GetColumns,
+    ListIndexes,
+    ListForeignKeys,
+    ListTriggers,
+    GetTableDdl,
+    ExecuteQuery,
+    ExecuteQueryPage,
+    FetchQueryPage,
+    CloseQuerySession,
+    StartTableRead,
+    FetchTableReadPage,
+    CloseTableReadSession,
+    GetExplainInfo,
+    ExecuteBatch,
+    ExecuteTransaction,
+    Disconnect,
+    Shutdown,
+}
+
+impl AgentMethod {
+    pub const ALL: [Self; 28] = [
+        Self::Handshake,
+        Self::Connect,
+        Self::TestConnection,
+        Self::ValidateConnection,
+        Self::ListDatabases,
+        Self::ListSchemas,
+        Self::ListTables,
+        Self::ListObjects,
+        Self::ListDataTypes,
+        Self::CompletionAssistantSearchV1,
+        Self::GetObjectSource,
+        Self::GetTableDdl,
+        Self::GetColumns,
+        Self::ListIndexes,
+        Self::ListForeignKeys,
+        Self::ListTriggers,
+        Self::ExecuteQuery,
+        Self::ExecuteQueryPage,
+        Self::FetchQueryPage,
+        Self::CloseQuerySession,
+        Self::StartTableRead,
+        Self::FetchTableReadPage,
+        Self::CloseTableReadSession,
+        Self::GetExplainInfo,
+        Self::ExecuteBatch,
+        Self::ExecuteTransaction,
+        Self::Disconnect,
+        Self::Shutdown,
+    ];
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Handshake => "handshake",
+            Self::Connect => "connect",
+            Self::TestConnection => "test_connection",
+            Self::ValidateConnection => "validate_connection",
+            Self::ListDatabases => "list_databases",
+            Self::ListSchemas => "list_schemas",
+            Self::ListTables => "list_tables",
+            Self::ListObjects => "list_objects",
+            Self::ListDataTypes => "list_data_types",
+            Self::CompletionAssistantSearchV1 => "completion_assistant_search_v1",
+            Self::GetObjectSource => "get_object_source",
+            Self::GetTableDdl => "get_table_ddl",
+            Self::GetColumns => "get_columns",
+            Self::ListIndexes => "list_indexes",
+            Self::ListForeignKeys => "list_foreign_keys",
+            Self::ListTriggers => "list_triggers",
+            Self::ExecuteQuery => "execute_query",
+            Self::ExecuteQueryPage => "execute_query_page",
+            Self::FetchQueryPage => "fetch_query_page",
+            Self::CloseQuerySession => "close_query_session",
+            Self::StartTableRead => "start_table_read",
+            Self::FetchTableReadPage => "fetch_table_read_page",
+            Self::CloseTableReadSession => "close_table_read_session",
+            Self::GetExplainInfo => "get_explain_info",
+            Self::ExecuteBatch => "execute_batch",
+            Self::ExecuteTransaction => "execute_transaction",
+            Self::Disconnect => "disconnect",
+            Self::Shutdown => "shutdown",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentTableReadStartParams {
+    pub sql: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub database: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub page_size: usize,
+    pub max_rows: usize,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub fetch_size: Option<usize>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentTableReadPageParams {
+    pub session_id: String,
+    pub page_size: usize,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentTableReadCloseParams {
+    pub session_id: String,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MongoAgentMethod {
+    ListDatabases,
+    ListCollections,
+    FindDocuments,
+    FindDocumentsExtendedJson,
+    ServerVersion,
+    CreateIndex,
+    DropIndexes,
+    DropCollection,
+    InsertDocument,
+    UpdateDocument,
+    UpdateDocuments,
+    DeleteDocument,
+    DeleteDocuments,
+}
+
+impl MongoAgentMethod {
+    pub const ALL: [Self; 13] = [
+        Self::ListDatabases,
+        Self::ListCollections,
+        Self::FindDocuments,
+        Self::FindDocumentsExtendedJson,
+        Self::ServerVersion,
+        Self::CreateIndex,
+        Self::DropIndexes,
+        Self::DropCollection,
+        Self::InsertDocument,
+        Self::UpdateDocument,
+        Self::UpdateDocuments,
+        Self::DeleteDocument,
+        Self::DeleteDocuments,
+    ];
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::ListDatabases => "list_databases",
+            Self::ListCollections => "list_collections",
+            Self::FindDocuments => "find_documents",
+            Self::FindDocumentsExtendedJson => "find_documents_extended_json",
+            Self::ServerVersion => "server_version",
+            Self::CreateIndex => "create_index",
+            Self::DropIndexes => "drop_indexes",
+            Self::DropCollection => "drop_collection",
+            Self::InsertDocument => "insert_document",
+            Self::UpdateDocument => "update_document",
+            Self::UpdateDocuments => "update_documents",
+            Self::DeleteDocument => "delete_document",
+            Self::DeleteDocuments => "delete_documents",
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AgentKvMethod {
+    ListPrefix,
+    Get,
+    Put,
+    Delete,
+}
+
+impl AgentKvMethod {
+    pub const ALL: [Self; 4] = [Self::ListPrefix, Self::Get, Self::Put, Self::Delete];
+
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::ListPrefix => "kv_list_prefix",
+            Self::Get => "kv_get",
+            Self::Put => "kv_put",
+            Self::Delete => "kv_delete",
+        }
+    }
+}
+
+struct StderrTail {
+    lines: VecDeque<String>,
+    capacity: usize,
+}
+
+impl Default for StderrTail {
+    fn default() -> Self {
+        Self::with_capacity(STDERR_TAIL_LINES)
+    }
+}
+
+impl StderrTail {
+    fn with_capacity(capacity: usize) -> Self {
+        Self { lines: VecDeque::with_capacity(capacity), capacity }
+    }
+
+    fn push_line(&mut self, line: String) {
+        if self.capacity == 0 {
+            return;
+        }
+        while self.lines.len() >= self.capacity {
+            self.lines.pop_front();
+        }
+        self.lines.push_back(line.trim_end().to_string());
+    }
+
+    fn snapshot(&self) -> String {
+        self.lines.iter().filter(|line| !line.trim().is_empty()).cloned().collect::<Vec<_>>().join("\n")
+    }
+}
+
+impl AgentDriverClient {
+    /// Spawn an agent process and wait for it to signal readiness.
+    ///
+    /// Agents can be Java JARs, native executables, or script runtimes as long as
+    /// they speak the DBX stdin/stdout JSON-RPC protocol.
+    /// Blocks (async) until the agent writes `{"ready":true}` to stdout.
+    pub async fn spawn(launch: AgentLaunchSpec) -> Result<Self, String> {
+        let mut command = crate::process::new_std_command(&launch.program);
+        command.args(&launch.args).stdin(Stdio::piped()).stdout(Stdio::piped()).stderr(Stdio::piped());
+        if let Some(working_dir) = &launch.working_dir {
+            command.current_dir(working_dir);
+        }
+        remove_agent_proxy_env(&mut command);
+
+        let mut child =
+            command.spawn().map_err(|e| format!("Failed to spawn agent process {}: {e}", launch_display(&launch)))?;
+
+        let child_stdin = child.stdin.take().ok_or("Failed to capture agent stdin")?;
+        let child_stdout = child.stdout.take().ok_or("Failed to capture agent stdout")?;
+        let child_stderr = child.stderr.take().ok_or("Failed to capture agent stderr")?;
+
+        let stdin = BufWriter::new(child_stdin);
+        let mut stdout = BufReader::new(child_stdout);
+        let stderr_tail = Arc::new(Mutex::new(StderrTail::default()));
+        start_stderr_collector(child_stderr, stderr_tail.clone());
+
+        // Wait for the agent to signal readiness with {"ready":true}.
+        // Some JDBC drivers (e.g. DM8) write banners to stdout during class
+        // loading.  Skip non-JSON lines so driver output doesn't break the
+        // JSON-RPC handshake.
+        let startup_result = tokio::time::timeout(
+            Duration::from_secs(STARTUP_TIMEOUT_SECS),
+            tokio::task::spawn_blocking(move || loop {
+                let line = read_agent_line(&mut stdout, "startup line")?;
+                let trimmed = line.trim();
+                if trimmed.is_empty() {
+                    continue;
+                }
+                match serde_json::from_str::<Value>(trimmed) {
+                    Ok(v) if v.get("ready") == Some(&Value::Bool(true)) => return Ok(stdout),
+                    Ok(_) => return Err(format!("Agent did not send ready signal, got: {line}")),
+                    Err(_) => {
+                        log::warn!("[agent:stdout] ignoring non-JSON line during startup: {trimmed}");
+                        continue;
+                    }
+                }
+            }),
+        )
+        .await;
+
+        let ready_stdout = match startup_result {
+            Ok(Ok(Ok(stdout))) => stdout,
+            Ok(Ok(Err(e))) => {
+                return Err(format_agent_startup_error(&e, &mut child, &stderr_tail));
+            }
+            Ok(Err(e)) => {
+                return Err(format_agent_startup_error(
+                    &format!("Agent startup task failed: {e}"),
+                    &mut child,
+                    &stderr_tail,
+                ));
+            }
+            Err(_) => {
+                return Err(format_agent_startup_error(
+                    &format!("Agent startup timed out ({STARTUP_TIMEOUT_SECS}s)"),
+                    &mut child,
+                    &stderr_tail,
+                ));
+            }
+        };
+
+        Ok(Self { child, stdin: Some(stdin), stdout: Some(ready_stdout), stderr_tail, handshake: None, next_id: 0 })
+    }
+
+    /// Send a JSON-RPC 2.0 request and wait for the response.
+    pub async fn call<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        method: &str,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_with_timeout(method, params, Some(Duration::from_secs(RPC_TIMEOUT_SECS))).await
+    }
+
+    /// Send a JSON-RPC 2.0 request and wait for the response.
+    /// `None` disables the client-side RPC timeout for long-running query calls.
+    pub async fn call_with_timeout<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        method: &str,
+        params: Value,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_with_timeout_and_cancel(method, params, timeout_duration, None).await
+    }
+
+    /// Send a JSON-RPC 2.0 request and wait for the response.
+    /// If cancellation happens while a response is pending, kill the agent
+    /// process because the stdio stream cannot safely skip that response.
+    pub async fn call_with_timeout_and_cancel<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        method: &str,
+        params: Value,
+        timeout_duration: Option<Duration>,
+        cancel_token: Option<CancellationToken>,
+    ) -> Result<T, String> {
+        self.next_id += 1;
+        let id = self.next_id;
+
+        let request = serde_json::json!({
+            "jsonrpc": "2.0",
+            "id": id,
+            "method": method,
+            "params": params,
+        });
+        let request_line =
+            serde_json::to_string(&request).map_err(|e| format!("Failed to serialize JSON-RPC request: {e}"))?;
+
+        // Write request to stdin
+        let write_result = {
+            let writer = self.stdin.as_mut().ok_or("Agent stdin not available")?;
+            writer
+                .write_all(request_line.as_bytes())
+                .map_err(|e| format!("Failed to write to agent stdin: {e}"))
+                .and_then(|_| {
+                    writer.write_all(b"\n").map_err(|e| format!("Failed to write newline to agent stdin: {e}"))
+                })
+                .and_then(|_| writer.flush().map_err(|e| format!("Failed to flush agent stdin: {e}")))
+        };
+        if let Err(e) = write_result {
+            return Err(self.format_agent_process_error(&e));
+        }
+
+        // Read response from stdout (blocking, with timeout)
+        let mut reader = self.stdout.take().ok_or("Agent stdout not available")?;
+
+        let response_task = tokio::task::spawn_blocking(move || {
+            let line = match read_agent_line(&mut reader, "response") {
+                Ok(line) => line,
+                Err(e) => return (reader, Err(e)),
+            };
+
+            let resp: Value = match serde_json::from_str(line.trim()) {
+                Ok(v) => v,
+                Err(e) => {
+                    return (reader, Err(format!("Invalid JSON response from agent: {e}")));
+                }
+            };
+
+            let result = if let Some(err) = resp.get("error") {
+                let msg = err.get("message").and_then(|m| m.as_str()).unwrap_or("Unknown agent error");
+                let code = err.get("code").and_then(|c| c.as_i64()).unwrap_or(-1);
+                Err(format!("Agent RPC error ({code}): {msg}"))
+            } else if let Some(result_val) = resp.get("result") {
+                serde_json::from_value::<T>(result_val.clone())
+                    .map_err(|e| format!("Failed to deserialize agent result: {e}"))
+            } else {
+                Err(format!("Agent response missing both 'result' and 'error': {line}"))
+            };
+
+            (reader, result)
+        });
+        let (returned_reader, result) = match (timeout_duration, cancel_token) {
+            (Some(duration), Some(token)) => {
+                tokio::select! {
+                    biased;
+                    _ = token.cancelled() => {
+                        self.kill();
+                        return Err("Query canceled".to_string());
+                    }
+                    result = tokio::time::timeout(duration, response_task) => match result {
+                        Ok(result) => result,
+                        Err(_) => {
+                            self.kill();
+                            return Err(format!("Agent RPC call timed out ({}s)", duration.as_secs()));
+                        }
+                    },
+                }
+            }
+            (Some(duration), None) => match tokio::time::timeout(duration, response_task).await {
+                Ok(result) => result,
+                Err(_) => {
+                    self.kill();
+                    return Err(format!("Agent RPC call timed out ({}s)", duration.as_secs()));
+                }
+            },
+            (None, Some(token)) => {
+                tokio::select! {
+                    biased;
+                    _ = token.cancelled() => {
+                        self.kill();
+                        return Err("Query canceled".to_string());
+                    }
+                    result = response_task => result,
+                }
+            }
+            (None, None) => response_task.await,
+        }
+        .map_err(|e| format!("Agent RPC task failed: {e}"))?;
+
+        let _ = self.stdout.insert(returned_reader);
+        result.map_err(|e| self.format_agent_process_error(&e))
+    }
+
+    pub async fn call_method<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        method: AgentMethod,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call(method.as_str(), params).await
+    }
+
+    pub async fn call_method_with_timeout<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        method: AgentMethod,
+        params: Value,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_with_timeout(method.as_str(), params, timeout_duration).await
+    }
+
+    pub async fn call_method_with_timeout_and_cancel<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        method: AgentMethod,
+        params: Value,
+        timeout_duration: Option<Duration>,
+        cancel_token: Option<CancellationToken>,
+    ) -> Result<T, String> {
+        self.call_with_timeout_and_cancel(method.as_str(), params, timeout_duration, cancel_token).await
+    }
+
+    pub async fn connect(&mut self, params: Value) -> Result<Value, String> {
+        self.call_method(AgentMethod::Connect, params).await
+    }
+
+    pub async fn test_connection(&mut self, params: Value) -> Result<Value, String> {
+        self.call_method(AgentMethod::TestConnection, params).await
+    }
+
+    pub async fn validate_connection(&mut self, timeout_duration: Option<Duration>) -> Result<Value, String> {
+        self.call_method_with_timeout(AgentMethod::ValidateConnection, serde_json::json!({}), timeout_duration).await
+    }
+
+    pub async fn disconnect(&mut self) -> Result<Value, String> {
+        self.call_method(AgentMethod::Disconnect, serde_json::json!({})).await
+    }
+
+    pub async fn list_databases<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(AgentMethod::ListDatabases, serde_json::json!({}), timeout_duration).await
+    }
+
+    pub async fn list_schemas<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.list_schemas_filtered(database, None, timeout_duration).await
+    }
+
+    pub async fn list_schemas_filtered<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        visible_schemas: Option<&[String]>,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        let mut params = serde_json::json!({ "database": database });
+        if let Some(visible_schemas) = visible_schemas {
+            params["visible_schemas"] = serde_json::json!(visible_schemas);
+        }
+        self.call_method_with_timeout(AgentMethod::ListSchemas, params, timeout_duration).await
+    }
+
+    pub async fn list_tables<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        schema: &str,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.list_tables_filtered(database, schema, None, timeout_duration).await
+    }
+
+    pub async fn list_tables_filtered<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        schema: &str,
+        object_types: Option<&[String]>,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.list_tables_constrained(database, schema, None, None, None, object_types, timeout_duration).await
+    }
+
+    pub async fn list_tables_constrained<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        schema: &str,
+        filter: Option<&str>,
+        limit: Option<usize>,
+        offset: Option<usize>,
+        object_types: Option<&[String]>,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        let mut params = agent_schema_params(database, schema);
+        if let Some(filter) = filter.map(str::trim).filter(|filter| !filter.is_empty()) {
+            params["filter"] = serde_json::json!(filter);
+        }
+        if let Some(limit) = limit {
+            params["limit"] = serde_json::json!(limit);
+        }
+        if let Some(offset) = offset {
+            params["offset"] = serde_json::json!(offset);
+        }
+        if let Some(object_types) = object_types {
+            params["object_types"] = serde_json::json!(object_types);
+        }
+        self.call_method_with_timeout(AgentMethod::ListTables, params, timeout_duration).await
+    }
+
+    pub async fn list_objects<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        schema: &str,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.list_objects_constrained(database, schema, None, None, None, None, timeout_duration).await
+    }
+
+    pub async fn list_objects_constrained<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        schema: &str,
+        filter: Option<&str>,
+        limit: Option<usize>,
+        offset: Option<usize>,
+        object_types: Option<&[String]>,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        let mut params = agent_schema_params(database, schema);
+        if let Some(filter) = filter.map(str::trim).filter(|filter| !filter.is_empty()) {
+            params["filter"] = serde_json::json!(filter);
+        }
+        if let Some(limit) = limit {
+            params["limit"] = serde_json::json!(limit);
+        }
+        if let Some(offset) = offset {
+            params["offset"] = serde_json::json!(offset);
+        }
+        if let Some(object_types) = object_types {
+            params["object_types"] = serde_json::json!(object_types);
+        }
+        self.call_method_with_timeout(AgentMethod::ListObjects, params, timeout_duration).await
+    }
+
+    pub async fn list_data_types<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(
+            AgentMethod::ListDataTypes,
+            serde_json::json!({ "database": database }),
+            timeout_duration,
+        )
+        .await
+    }
+
+    pub async fn completion_assistant_search<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        request: &crate::types::CompletionAssistantRequest,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(
+            AgentMethod::CompletionAssistantSearchV1,
+            serde_json::to_value(request).map_err(|e| e.to_string())?,
+            timeout_duration,
+        )
+        .await
+    }
+
+    pub async fn get_object_source<T: DeserializeOwned + Send + 'static, K: Serialize>(
+        &mut self,
+        database: &str,
+        schema: &str,
+        name: &str,
+        object_type: &K,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(
+            AgentMethod::GetObjectSource,
+            agent_object_source_params(database, schema, name, object_type),
+            timeout_duration,
+        )
+        .await
+    }
+
+    pub async fn get_columns<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        schema: &str,
+        table: &str,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(
+            AgentMethod::GetColumns,
+            agent_schema_table_params(database, schema, table),
+            timeout_duration,
+        )
+        .await
+    }
+
+    pub async fn list_indexes<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        schema: &str,
+        table: &str,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(
+            AgentMethod::ListIndexes,
+            agent_schema_table_params(database, schema, table),
+            timeout_duration,
+        )
+        .await
+    }
+
+    pub async fn list_foreign_keys<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        schema: &str,
+        table: &str,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(
+            AgentMethod::ListForeignKeys,
+            agent_schema_table_params(database, schema, table),
+            timeout_duration,
+        )
+        .await
+    }
+
+    pub async fn list_triggers<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        schema: &str,
+        table: &str,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(
+            AgentMethod::ListTriggers,
+            agent_schema_table_params(database, schema, table),
+            timeout_duration,
+        )
+        .await
+    }
+
+    pub async fn get_table_ddl<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+        schema: &str,
+        table: &str,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(
+            AgentMethod::GetTableDdl,
+            agent_schema_table_params(database, schema, table),
+            timeout_duration,
+        )
+        .await
+    }
+
+    pub async fn execute_query<T: DeserializeOwned + Send + 'static>(&mut self, params: Value) -> Result<T, String> {
+        self.call_method(AgentMethod::ExecuteQuery, params).await
+    }
+
+    pub async fn execute_query_with_timeout<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(AgentMethod::ExecuteQuery, params, timeout_duration).await
+    }
+
+    pub async fn execute_query_with_timeout_and_cancel<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+        timeout_duration: Option<Duration>,
+        cancel_token: Option<CancellationToken>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout_and_cancel(AgentMethod::ExecuteQuery, params, timeout_duration, cancel_token)
+            .await
+    }
+
+    pub async fn execute_query_page<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_method(AgentMethod::ExecuteQueryPage, params).await
+    }
+
+    pub async fn execute_query_page_with_timeout<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(AgentMethod::ExecuteQueryPage, params, timeout_duration).await
+    }
+
+    pub async fn execute_query_page_with_timeout_and_cancel<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+        timeout_duration: Option<Duration>,
+        cancel_token: Option<CancellationToken>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout_and_cancel(AgentMethod::ExecuteQueryPage, params, timeout_duration, cancel_token)
+            .await
+    }
+
+    pub async fn fetch_query_page<T: DeserializeOwned + Send + 'static>(&mut self, params: Value) -> Result<T, String> {
+        self.call_method(AgentMethod::FetchQueryPage, params).await
+    }
+
+    pub async fn fetch_query_page_with_timeout<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(AgentMethod::FetchQueryPage, params, timeout_duration).await
+    }
+
+    pub async fn fetch_query_page_with_timeout_and_cancel<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+        timeout_duration: Option<Duration>,
+        cancel_token: Option<CancellationToken>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout_and_cancel(AgentMethod::FetchQueryPage, params, timeout_duration, cancel_token)
+            .await
+    }
+
+    pub async fn get_explain_info<T: DeserializeOwned + Send + 'static>(&mut self, params: Value) -> Result<T, String> {
+        self.call_method(AgentMethod::GetExplainInfo, params).await
+    }
+
+    pub async fn close_query_session<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        session_id: &str,
+    ) -> Result<T, String> {
+        self.call_method(AgentMethod::CloseQuerySession, agent_close_query_session_params(session_id)).await
+    }
+
+    pub async fn start_table_read<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: AgentTableReadStartParams,
+    ) -> Result<T, String> {
+        self.call_method(AgentMethod::StartTableRead, serde_json::to_value(params).map_err(|e| e.to_string())?).await
+    }
+
+    pub async fn fetch_table_read_page<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        session_id: &str,
+        page_size: usize,
+    ) -> Result<T, String> {
+        self.call_method(
+            AgentMethod::FetchTableReadPage,
+            serde_json::to_value(AgentTableReadPageParams { session_id: session_id.to_string(), page_size })
+                .map_err(|e| e.to_string())?,
+        )
+        .await
+    }
+
+    pub async fn close_table_read_session<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        session_id: &str,
+    ) -> Result<T, String> {
+        self.call_method(
+            AgentMethod::CloseTableReadSession,
+            serde_json::to_value(AgentTableReadCloseParams { session_id: session_id.to_string() })
+                .map_err(|e| e.to_string())?,
+        )
+        .await
+    }
+
+    pub async fn execute_transaction<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: Option<&str>,
+        statements: &[String],
+        schema: Option<&str>,
+    ) -> Result<T, String> {
+        self.call_method(AgentMethod::ExecuteTransaction, agent_transaction_params(database, statements, schema)).await
+    }
+
+    pub async fn execute_batch<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: Option<&str>,
+        statements: &[String],
+        schema: Option<&str>,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String> {
+        self.call_method_with_timeout(
+            AgentMethod::ExecuteBatch,
+            agent_transaction_params(database, statements, schema),
+            timeout_duration,
+        )
+        .await
+    }
+
+    pub async fn call_mongo_method<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        method: MongoAgentMethod,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call(method.as_str(), params).await
+    }
+
+    pub async fn call_kv_method<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        method: AgentKvMethod,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call(method.as_str(), params).await
+    }
+
+    pub async fn mongo_list_databases<T: DeserializeOwned + Send + 'static>(&mut self) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::ListDatabases, serde_json::json!({})).await
+    }
+
+    pub async fn mongo_list_collections<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::ListCollections, mongo_database_params(database)).await
+    }
+
+    pub async fn mongo_find_documents<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::FindDocuments, params).await
+    }
+
+    /// Calls the Mongo agent read method that returns MongoDB relaxed Extended JSON.
+    pub async fn mongo_find_documents_extended_json<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::FindDocumentsExtendedJson, params).await
+    }
+
+    pub async fn mongo_server_version<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        database: &str,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::ServerVersion, mongo_database_params(database)).await
+    }
+
+    pub async fn mongo_create_index<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::CreateIndex, params).await
+    }
+
+    pub async fn mongo_drop_indexes<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::DropIndexes, params).await
+    }
+
+    pub async fn mongo_drop_collection<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::DropCollection, params).await
+    }
+
+    pub async fn mongo_insert_document<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::InsertDocument, params).await
+    }
+
+    pub async fn mongo_update_document<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::UpdateDocument, params).await
+    }
+
+    pub async fn mongo_update_documents<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::UpdateDocuments, params).await
+    }
+
+    pub async fn mongo_delete_document<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::DeleteDocument, params).await
+    }
+
+    pub async fn mongo_delete_documents<T: DeserializeOwned + Send + 'static>(
+        &mut self,
+        params: Value,
+    ) -> Result<T, String> {
+        self.call_mongo_method(MongoAgentMethod::DeleteDocuments, params).await
+    }
+
+    pub async fn try_optional_handshake(&mut self, app_version: &str) -> Option<AgentHandshake> {
+        match self.call_method::<AgentHandshake>(AgentMethod::Handshake, agent_handshake_params(app_version)).await {
+            Ok(handshake) => {
+                log::info!(
+                    "[agent] handshake complete: protocol={}, agent_protocol={}, capabilities={:?}",
+                    handshake.protocol_version,
+                    handshake.agent_protocol_version,
+                    handshake.capabilities
+                );
+                self.handshake = Some(handshake.clone());
+                Some(handshake)
+            }
+            Err(err) if is_unsupported_handshake_error(&err) => {
+                log::info!("[agent] handshake unsupported by this driver; continuing with legacy protocol");
+                None
+            }
+            Err(err) => {
+                log::warn!("[agent] handshake failed; continuing with legacy protocol: {err}");
+                None
+            }
+        }
+    }
+
+    pub fn handshake(&self) -> Option<&AgentHandshake> {
+        self.handshake.as_ref()
+    }
+
+    pub fn supports_capability(&self, capability: AgentCapability) -> bool {
+        agent_supports_capability(self.handshake.as_ref(), capability)
+    }
+
+    /// Send a shutdown message to the agent and wait for the process to exit.
+    pub async fn shutdown(&mut self) {
+        // Try to send a shutdown RPC; ignore errors if the agent is already gone
+        let shutdown_result: Result<Value, String> = self.call_method(AgentMethod::Shutdown, Value::Null).await;
+        if let Err(e) = &shutdown_result {
+            log::warn!("Agent shutdown RPC failed: {e}");
+        }
+
+        // Drop stdin to signal EOF
+        self.stdin.take();
+
+        // Wait for the child to exit
+        match self.child.wait() {
+            Ok(status) => log::info!("Agent process exited with {status}"),
+            Err(e) => log::warn!("Failed to wait for agent process: {e}"),
+        }
+    }
+
+    /// Forcefully kill the agent process.
+    pub fn kill(&mut self) {
+        self.stdin.take();
+        self.stdout.take();
+        if let Err(e) = self.child.kill() {
+            log::warn!("Failed to kill agent process: {e}");
+        }
+        // Reap the child to avoid zombie processes.
+        // Use try_wait() with a timeout instead of blocking wait() to avoid
+        // hanging in Drop during async cleanup. Poll up to 100ms for the
+        // process to exit after kill().
+        for _ in 0..10 {
+            match self.child.try_wait() {
+                Ok(Some(_status)) => return,
+                Ok(None) => std::thread::sleep(Duration::from_millis(10)),
+                Err(e) => {
+                    log::warn!("Failed to wait for agent process: {e}");
+                    return;
+                }
+            }
+        }
+        // Final blocking wait as a last resort
+        if let Err(e) = self.child.wait() {
+            log::warn!("Final wait failed for agent process: {e}");
+        }
+    }
+
+    pub fn pid(&self) -> u32 {
+        self.child.id()
+    }
+
+    pub fn stderr_tail_snapshot(&self) -> String {
+        self.stderr_tail.lock().map(|tail| tail.snapshot()).unwrap_or_default()
+    }
+}
+
+pub fn agent_handshake_params(app_version: &str) -> Value {
+    serde_json::json!({
+        "appVersion": app_version,
+        "supportedProtocolVersions": [AGENT_PROTOCOL_VERSION],
+    })
+}
+
+pub fn is_unsupported_handshake_error(error: &str) -> bool {
+    error.contains("Unknown method: handshake")
+        || error.contains("Method not found: handshake")
+        || error.contains("method not found: handshake")
+}
+
+pub fn agent_supports_capability(handshake: Option<&AgentHandshake>, capability: AgentCapability) -> bool {
+    if capability == AgentCapability::Kv {
+        return handshake.map(|value| value.supports(capability)).unwrap_or(false);
+    }
+    handshake.map(|value| value.supports(capability)).unwrap_or(true)
+}
+
+pub fn agent_schema_params(database: &str, schema: &str) -> Value {
+    serde_json::json!({ "database": database, "schema": schema })
+}
+
+pub fn agent_schema_table_params(database: &str, schema: &str, table: &str) -> Value {
+    serde_json::json!({ "database": database, "schema": schema, "table": table })
+}
+
+pub fn agent_object_source_params<K: Serialize>(database: &str, schema: &str, name: &str, object_type: &K) -> Value {
+    serde_json::json!({ "database": database, "schema": schema, "name": name, "object_type": object_type })
+}
+
+pub fn agent_close_query_session_params(session_id: &str) -> Value {
+    serde_json::json!({ "sessionId": session_id })
+}
+
+pub fn agent_transaction_params(database: Option<&str>, statements: &[String], schema: Option<&str>) -> Value {
+    let database = database.map(str::trim).filter(|database| !database.is_empty());
+    serde_json::json!({
+        "database": database,
+        "statements": statements,
+        "schema": schema,
+    })
+}
+
+pub fn mongo_database_params(database: &str) -> Value {
+    serde_json::json!({ "database": database })
+}
+
+pub fn mongo_collection_params(database: &str, collection: &str) -> Value {
+    serde_json::json!({ "database": database, "collection": collection })
+}
+
+pub fn mongo_document_id_params(database: &str, collection: &str, id: &str) -> Value {
+    serde_json::json!({ "database": database, "collection": collection, "id": id })
+}
+
+#[cfg(test)]
+fn agent_java_args(jar_path: &str) -> Vec<String> {
+    agent_java_args_with_extra(jar_path, std::env::var(AGENT_JAVA_OPTS_ENV).ok().as_deref())
+}
+
+#[cfg(test)]
+fn agent_java_args_with_extra(jar_path: &str, extra_opts: Option<&str>) -> Vec<String> {
+    agent_java_args_with_extra_opts(jar_path, extra_opts, &[])
+}
+
+fn agent_java_args_with_extra_args(jar_path: &str, extra_java_args: &[String]) -> Vec<String> {
+    agent_java_args_with_extra_opts(jar_path, std::env::var(AGENT_JAVA_OPTS_ENV).ok().as_deref(), extra_java_args)
+}
+
+fn agent_java_args_with_extra_opts(
+    jar_path: &str,
+    extra_opts: Option<&str>,
+    extra_java_args: &[String],
+) -> Vec<String> {
+    let mut args = vec![
+        "-Dfile.encoding=UTF-8",
+        "-Dsun.stdout.encoding=UTF-8",
+        "-Dsun.stderr.encoding=UTF-8",
+        "-Djava.net.useSystemProxies=false",
+        "-Dhttp.proxyHost=",
+        "-Dhttps.proxyHost=",
+        "-DsocksProxyHost=",
+        "-Doracle.net.disableOob=true",
+        "-Doracle.jdbc.javaNetNio=false",
+    ]
+    .into_iter()
+    .map(str::to_string)
+    .collect::<Vec<_>>();
+
+    if agent_jar_path_matches_key(jar_path, "kingbase") || agent_jar_path_matches_key(jar_path, "informix") {
+        args.push("-Djava.net.preferIPv4Stack=true".to_string());
+    }
+
+    // Hive/Kerberos JDBC drivers read JAAS and krb5 settings during JVM startup,
+    // so users need a process-level escape hatch before the agent jar is loaded.
+    if let Some(extra) = extra_opts {
+        args.extend(parse_agent_java_opts(extra));
+    }
+    args.extend(extra_java_args.iter().map(|arg| arg.trim()).filter(|arg| !arg.is_empty()).map(str::to_string));
+
+    args.push("--add-opens=java.sql/java.sql=ALL-UNNAMED".to_string());
+
+    args.extend(["-XX:TieredStopAtLevel=1", "-XX:+UseSerialGC", "-jar", jar_path].into_iter().map(str::to_string));
+
+    args
+}
+
+fn parse_agent_java_opts(opts: &str) -> Vec<String> {
+    let mut args = Vec::new();
+    let mut current = String::new();
+    let mut quote = None;
+    let mut chars = opts.chars().peekable();
+
+    while let Some(ch) = chars.next() {
+        match (quote, ch) {
+            (None, ch) if ch.is_whitespace() => {
+                if !current.is_empty() {
+                    args.push(std::mem::take(&mut current));
+                }
+            }
+            (None, '\'' | '"') => quote = Some(ch),
+            (Some(q), ch) if ch == q => quote = None,
+            (Some('"'), '\\') => {
+                if let Some(&next) = chars.peek() {
+                    if next == '"' || next == '\\' {
+                        current.push(chars.next().unwrap());
+                    } else {
+                        current.push(ch);
+                    }
+                } else {
+                    current.push(ch);
+                }
+            }
+            _ => current.push(ch),
+        }
+    }
+
+    if !current.is_empty() {
+        args.push(current);
+    }
+
+    args
+}
+
+fn agent_jar_path_matches_key(jar_path: &str, key: &str) -> bool {
+    Path::new(jar_path).components().any(|component| component.as_os_str().to_string_lossy() == key)
+}
+
+fn launch_display(launch: &AgentLaunchSpec) -> String {
+    let mut parts = vec![launch.program.to_string_lossy().to_string()];
+    parts.extend(launch.args.iter().cloned());
+    parts.join(" ")
+}
+
+fn remove_agent_proxy_env(command: &mut Command) {
+    for key in agent_proxy_env_vars() {
+        command.env_remove(key);
+    }
+}
+
+fn agent_proxy_env_vars() -> &'static [&'static str] {
+    &["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "all_proxy", "no_proxy"]
+}
+
+fn read_agent_line<R: BufRead>(reader: &mut R, context: &str) -> Result<String, String> {
+    const MAX_RESPONSE_BYTES: usize = 512 * 1024 * 1024;
+    let mut bytes = Vec::new();
+    loop {
+        let available = reader.fill_buf().map_err(|e| format!("Failed to read {context} from agent: {e}"))?;
+        if available.is_empty() {
+            break;
+        }
+        if let Some(pos) = available.iter().position(|&b| b == b'\n') {
+            bytes.extend_from_slice(&available[..=pos]);
+            reader.consume(pos + 1);
+            break;
+        }
+        bytes.extend_from_slice(available);
+        let len = available.len();
+        reader.consume(len);
+        if bytes.len() > MAX_RESPONSE_BYTES {
+            return Err(format!("Agent {context} exceeded maximum size ({} bytes)", MAX_RESPONSE_BYTES));
+        }
+    }
+    if bytes.is_empty() {
+        return Err(format!("Failed to read {context} from agent: end of stream"));
+    }
+    Ok(String::from_utf8_lossy(&bytes).into_owned())
+}
+
+fn start_stderr_collector(stderr: ChildStderr, stderr_tail: Arc<Mutex<StderrTail>>) {
+    std::thread::spawn(move || {
+        let mut reader = BufReader::new(stderr);
+        let mut line = String::new();
+        loop {
+            line.clear();
+            match reader.read_line(&mut line) {
+                Ok(0) => break,
+                Ok(_) => {
+                    log::warn!("[agent:stderr] {}", line.trim_end());
+                    if let Ok(mut tail) = stderr_tail.lock() {
+                        tail.push_line(line.clone());
+                    }
+                }
+                Err(err) => {
+                    log::warn!("[agent:stderr] failed to read stderr: {err}");
+                    break;
+                }
+            }
+        }
+    });
+}
+
+fn child_exit_status(child: &mut Child) -> Option<String> {
+    match child.try_wait() {
+        Ok(Some(status)) => Some(status.to_string()),
+        Ok(None) => None,
+        Err(err) => Some(format!("status unavailable: {err}")),
+    }
+}
+
+fn child_exit_status_after_short_wait(child: &mut Child) -> Option<String> {
+    let deadline = Instant::now() + Duration::from_millis(AGENT_EXIT_DIAGNOSTIC_WAIT_MS);
+    loop {
+        if let Some(status) = child_exit_status(child) {
+            return Some(status);
+        }
+        if Instant::now() >= deadline {
+            return None;
+        }
+        std::thread::sleep(Duration::from_millis(AGENT_EXIT_DIAGNOSTIC_POLL_MS));
+    }
+}
+
+fn stderr_tail_snapshot(stderr_tail: &Arc<Mutex<StderrTail>>) -> StderrTail {
+    let snapshot = stderr_tail.lock().map(|tail| tail.snapshot()).unwrap_or_default();
+    let mut tail = StderrTail::with_capacity(STDERR_TAIL_LINES);
+    for line in snapshot.lines() {
+        tail.push_line(line.to_string());
+    }
+    tail
+}
+
+fn format_agent_process_error(base: &str, exit_status: Option<String>, stderr_tail: &StderrTail) -> String {
+    let stderr = stderr_tail.snapshot();
+    let mut parts = Vec::new();
+    if let Some(hint) = agent_process_error_hint(&stderr) {
+        parts.push(hint.to_string());
+        parts.push(format!("details: {base}"));
+    } else {
+        parts.push(base.to_string());
+    }
+    if let Some(status) = exit_status {
+        parts.push(format!("agent process exited with {status}"));
+    }
+    if !stderr.is_empty() {
+        parts.push(format!("recent stderr:\n{stderr}"));
+    }
+    parts.join(". ")
+}
+
+fn agent_process_error_hint(stderr: &str) -> Option<&'static str> {
+    let lower = stderr.to_ascii_lowercase();
+    if lower.contains("unsupportedclassversionerror")
+        && (lower.contains("class file version 65.0") || lower.contains("only recognizes class file versions up to"))
+    {
+        return Some(AGENT_JAVA_TOO_OLD_MESSAGE);
+    }
+    None
+}
+
+fn format_agent_startup_error(base: &str, child: &mut Child, stderr_tail: &Arc<Mutex<StderrTail>>) -> String {
+    format_agent_process_error(base, child_exit_status_after_short_wait(child), &stderr_tail_snapshot(stderr_tail))
+}
+
+impl AgentDriverClient {
+    fn format_agent_process_error(&mut self, base: &str) -> String {
+        // Runtime RPC errors are common SQL/driver paths. Do not wait for the
+        // child to exit unless startup diagnostics already expect the process to die.
+        format_agent_process_error(base, child_exit_status(&mut self.child), &stderr_tail_snapshot(&self.stderr_tail))
+    }
+}
+
+impl Drop for AgentDriverClient {
+    fn drop(&mut self) {
+        self.kill();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        agent_close_query_session_params, agent_handshake_params, agent_java_args, agent_java_args_with_extra,
+        agent_java_args_with_extra_opts, agent_object_source_params, agent_proxy_env_vars, agent_schema_params,
+        agent_schema_table_params, agent_supports_capability, agent_transaction_params, format_agent_process_error,
+        format_agent_startup_error, is_unsupported_handshake_error, mongo_collection_params, mongo_database_params,
+        mongo_document_id_params, parse_agent_java_opts, read_agent_line, start_stderr_collector, AgentCapability,
+        AgentDriverClient, AgentHandshake, AgentKvMethod, AgentMethod, AgentTableReadCloseParams,
+        AgentTableReadPageParams, AgentTableReadStartParams, MongoAgentMethod, StderrTail, AGENT_PROTOCOL_VERSION,
+    };
+    use std::io::Cursor;
+    use std::process::{Command, Stdio};
+    use std::sync::{Arc, Mutex};
+
+    #[test]
+    fn agent_java_args_include_oracle_network_compatibility_flags() {
+        let args = agent_java_args("/tmp/dbx-agent-oracle.jar");
+
+        assert!(args.iter().any(|arg| arg == "-Doracle.net.disableOob=true"));
+        assert!(args.iter().any(|arg| arg == "-Doracle.jdbc.javaNetNio=false"));
+    }
+
+    #[test]
+    fn agent_java_args_open_java_sql_for_legacy_timestamp_serializers() {
+        let args = agent_java_args("/tmp/dbx-agent-dameng.jar");
+
+        assert!(args.iter().any(|arg| arg == "--add-opens=java.sql/java.sql=ALL-UNNAMED"));
+    }
+
+    #[test]
+    fn agent_java_args_disable_ambient_proxy_settings() {
+        let args = agent_java_args("/tmp/dbx-agent-opengauss.jar");
+
+        assert!(args.iter().any(|arg| arg == "-Djava.net.useSystemProxies=false"));
+        assert!(args.iter().any(|arg| arg == "-Dhttp.proxyHost="));
+        assert!(args.iter().any(|arg| arg == "-Dhttps.proxyHost="));
+        assert!(args.iter().any(|arg| arg == "-DsocksProxyHost="));
+    }
+
+    #[test]
+    fn agent_java_args_prefer_ipv4_for_kingbase() {
+        let args = agent_java_args("/tmp/dbx/drivers/kingbase/agent.jar");
+
+        assert!(args.iter().any(|arg| arg == "-Djava.net.preferIPv4Stack=true"));
+    }
+
+    #[test]
+    fn agent_java_args_prefer_ipv4_for_informix() {
+        let args = agent_java_args("/tmp/dbx/drivers/informix/agent.jar");
+
+        assert!(args.iter().any(|arg| arg == "-Djava.net.preferIPv4Stack=true"));
+    }
+
+    #[test]
+    fn agent_java_args_do_not_prefer_ipv4_for_other_agents() {
+        let args = agent_java_args("/tmp/dbx/drivers/highgo/agent.jar");
+
+        assert!(!args.iter().any(|arg| arg == "-Djava.net.preferIPv4Stack=true"));
+    }
+
+    #[test]
+    fn agent_java_args_include_custom_jvm_options_before_jar() {
+        let args = agent_java_args_with_extra(
+            "/tmp/dbx/drivers/hive/agent.jar",
+            Some("-Djava.security.auth.login.config=C:\\jaas.conf -Djavax.security.auth.useSubjectCredsOnly=false"),
+        );
+
+        let login_config = args
+            .iter()
+            .position(|arg| arg == "-Djava.security.auth.login.config=C:\\jaas.conf")
+            .expect("custom JAAS option should be present");
+        let jar = args.iter().position(|arg| arg == "-jar").expect("agent jar marker should be present");
+
+        assert!(login_config < jar);
+        assert!(args.iter().any(|arg| arg == "-Djavax.security.auth.useSubjectCredsOnly=false"));
+    }
+
+    #[test]
+    fn agent_java_args_include_connection_jvm_options_after_env_options() {
+        let args = agent_java_args_with_extra_opts(
+            "/tmp/dbx/drivers/hive/agent.jar",
+            Some("-Djava.security.krb5.conf=/etc/global-krb5.conf"),
+            &["-Djava.security.krb5.conf=/etc/connection-krb5.conf".to_string()],
+        );
+
+        let global = args
+            .iter()
+            .position(|arg| arg == "-Djava.security.krb5.conf=/etc/global-krb5.conf")
+            .expect("global krb5 option should be present");
+        let connection = args
+            .iter()
+            .position(|arg| arg == "-Djava.security.krb5.conf=/etc/connection-krb5.conf")
+            .expect("connection krb5 option should be present");
+        let jar = args.iter().position(|arg| arg == "-jar").expect("agent jar marker should be present");
+
+        assert!(global < connection);
+        assert!(connection < jar);
+    }
+
+    #[test]
+    fn agent_java_opts_parser_preserves_quoted_windows_paths() {
+        let args = parse_agent_java_opts(
+            r#"-Djava.security.krb5.conf="C:\Program Files\MIT\Kerberos5\krb5.ini" -Dsun.security.krb5.debug=true"#,
+        );
+
+        assert_eq!(
+            args,
+            vec![
+                "-Djava.security.krb5.conf=C:\\Program Files\\MIT\\Kerberos5\\krb5.ini",
+                "-Dsun.security.krb5.debug=true"
+            ]
+        );
+    }
+
+    #[test]
+    fn agent_process_environment_removes_common_proxy_variables() {
+        let proxy_env_vars = agent_proxy_env_vars();
+
+        for key in
+            ["HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "NO_PROXY", "http_proxy", "https_proxy", "all_proxy", "no_proxy"]
+        {
+            assert!(proxy_env_vars.contains(&key));
+        }
+    }
+
+    #[test]
+    fn decodes_non_utf8_agent_lines_lossily() {
+        let mut reader =
+            Cursor::new(vec![b'{', b'"', b'e', b'r', b'r', b'o', b'r', b'"', b':', 0xB2, 0xE2, b'}', b'\n']);
+
+        let line = read_agent_line(&mut reader, "response").expect("line should be readable");
+
+        assert_eq!(line, format!("{{\"error\":{}}}\n", "\u{fffd}\u{fffd}"));
+    }
+
+    #[test]
+    fn formats_agent_process_error_with_exit_status_and_stderr_tail() {
+        let mut stderr_tail = StderrTail::default();
+        stderr_tail.push_line("java.lang.NoClassDefFoundError: org/apache/hive/jdbc/HiveDriver".to_string());
+        stderr_tail.push_line("\tat com.dbx.agent.hive.HiveAgent.connect(HiveAgent.kt:21)".to_string());
+
+        let message = format_agent_process_error(
+            "Failed to read response from agent: end of stream",
+            Some("exit status: 1".to_string()),
+            &stderr_tail,
+        );
+
+        assert!(message.contains("Failed to read response from agent: end of stream"));
+        assert!(message.contains("agent process exited with exit status: 1"));
+        assert!(message.contains("recent stderr:"));
+        assert!(message.contains("NoClassDefFoundError"));
+        assert!(message.contains("HiveAgent.connect"));
+    }
+
+    #[test]
+    fn startup_error_waits_briefly_for_exit_status_and_stderr_tail() {
+        let mut child = Command::new("sh")
+            .arg("-c")
+            .arg("sleep 0.05; echo 'java.lang.UnsupportedClassVersionError: class file version 65.0' >&2; exit 1")
+            .stderr(Stdio::piped())
+            .spawn()
+            .expect("child should start");
+        let stderr_tail = Arc::new(Mutex::new(StderrTail::default()));
+        start_stderr_collector(child.stderr.take().expect("stderr should be piped"), Arc::clone(&stderr_tail));
+
+        let message = format_agent_startup_error(
+            "Failed to read startup line from agent: end of stream",
+            &mut child,
+            &stderr_tail,
+        );
+
+        assert!(message.contains("Failed to read startup line from agent: end of stream"));
+        assert!(message.contains("agent process exited with exit status: 1"));
+        assert!(message.contains("Agent requires Java 21"));
+        assert!(message.contains("details: Failed to read startup line from agent: end of stream"));
+        assert!(message.contains("UnsupportedClassVersionError"));
+    }
+
+    #[test]
+    fn runtime_agent_process_error_does_not_wait_for_live_child() {
+        let child = Command::new("sh")
+            .arg("-c")
+            .arg("sleep 2")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .spawn()
+            .expect("child should start");
+        let mut client = AgentDriverClient {
+            child,
+            stdin: None,
+            stdout: None,
+            stderr_tail: Arc::new(Mutex::new(StderrTail::default())),
+            handshake: None,
+            next_id: 0,
+        };
+
+        let started_at = std::time::Instant::now();
+        let message = client.format_agent_process_error("Agent RPC error (-1): syntax error");
+
+        assert!(started_at.elapsed() < std::time::Duration::from_millis(500));
+        assert!(message.contains("Agent RPC error (-1): syntax error"));
+        assert!(!message.contains("agent process exited"));
+    }
+
+    #[test]
+    fn stderr_tail_keeps_recent_lines_only() {
+        let mut stderr_tail = StderrTail::with_capacity(3);
+        stderr_tail.push_line("line 1".to_string());
+        stderr_tail.push_line("line 2".to_string());
+        stderr_tail.push_line("line 3".to_string());
+        stderr_tail.push_line("line 4".to_string());
+
+        assert_eq!(stderr_tail.snapshot(), "line 2\nline 3\nline 4");
+    }
+
+    #[test]
+    fn builds_agent_handshake_request_params() {
+        let params = agent_handshake_params("0.5.13");
+
+        assert_eq!(params["appVersion"], "0.5.13");
+        assert_eq!(params["supportedProtocolVersions"], serde_json::json!([AGENT_PROTOCOL_VERSION]));
+    }
+
+    #[test]
+    fn decodes_agent_handshake_response() {
+        let handshake: AgentHandshake = serde_json::from_value(serde_json::json!({
+            "protocolVersion": 1,
+            "agentProtocolVersion": 1,
+            "capabilities": ["connect", "query", "metadata"]
+        }))
+        .unwrap();
+
+        assert_eq!(handshake.protocol_version, 1);
+        assert_eq!(handshake.agent_protocol_version, 1);
+        assert_eq!(handshake.capabilities, vec!["connect", "query", "metadata"]);
+    }
+
+    #[test]
+    fn defines_agent_protocol_capabilities() {
+        assert_eq!(AgentCapability::Connect.as_str(), "connect");
+        assert_eq!(AgentCapability::TestConnection.as_str(), "test_connection");
+        assert_eq!(AgentCapability::Metadata.as_str(), "metadata");
+        assert_eq!(AgentCapability::Query.as_str(), "query");
+        assert_eq!(AgentCapability::PagedQuery.as_str(), "paged_query");
+        assert_eq!(AgentCapability::Transaction.as_str(), "transaction");
+        assert_eq!(AgentCapability::Ddl.as_str(), "ddl");
+        assert_eq!(AgentCapability::Kv.as_str(), "kv");
+        assert_eq!(AgentCapability::ALL.len(), 8);
+    }
+
+    #[test]
+    fn defines_agent_protocol_methods() {
+        assert_eq!(AgentMethod::Handshake.as_str(), "handshake");
+        assert_eq!(AgentMethod::Connect.as_str(), "connect");
+        assert_eq!(AgentMethod::TestConnection.as_str(), "test_connection");
+        assert_eq!(AgentMethod::ValidateConnection.as_str(), "validate_connection");
+        assert_eq!(AgentMethod::ListDatabases.as_str(), "list_databases");
+        assert_eq!(AgentMethod::ListSchemas.as_str(), "list_schemas");
+        assert_eq!(AgentMethod::ListTables.as_str(), "list_tables");
+        assert_eq!(AgentMethod::ListObjects.as_str(), "list_objects");
+        assert_eq!(AgentMethod::ListDataTypes.as_str(), "list_data_types");
+        assert_eq!(AgentMethod::CompletionAssistantSearchV1.as_str(), "completion_assistant_search_v1");
+        assert_eq!(AgentMethod::GetObjectSource.as_str(), "get_object_source");
+        assert_eq!(AgentMethod::GetColumns.as_str(), "get_columns");
+        assert_eq!(AgentMethod::ListIndexes.as_str(), "list_indexes");
+        assert_eq!(AgentMethod::ListForeignKeys.as_str(), "list_foreign_keys");
+        assert_eq!(AgentMethod::ListTriggers.as_str(), "list_triggers");
+        assert_eq!(AgentMethod::GetTableDdl.as_str(), "get_table_ddl");
+        assert_eq!(AgentMethod::ExecuteQuery.as_str(), "execute_query");
+        assert_eq!(AgentMethod::ExecuteQueryPage.as_str(), "execute_query_page");
+        assert_eq!(AgentMethod::FetchQueryPage.as_str(), "fetch_query_page");
+        assert_eq!(AgentMethod::CloseQuerySession.as_str(), "close_query_session");
+        assert_eq!(AgentMethod::StartTableRead.as_str(), "start_table_read");
+        assert_eq!(AgentMethod::FetchTableReadPage.as_str(), "fetch_table_read_page");
+        assert_eq!(AgentMethod::CloseTableReadSession.as_str(), "close_table_read_session");
+        assert_eq!(AgentMethod::ExecuteBatch.as_str(), "execute_batch");
+        assert_eq!(AgentMethod::ExecuteTransaction.as_str(), "execute_transaction");
+        assert_eq!(AgentMethod::Disconnect.as_str(), "disconnect");
+        assert_eq!(AgentMethod::Shutdown.as_str(), "shutdown");
+    }
+
+    #[test]
+    fn defines_mongo_agent_protocol_methods() {
+        assert_eq!(MongoAgentMethod::ListDatabases.as_str(), "list_databases");
+        assert_eq!(MongoAgentMethod::ListCollections.as_str(), "list_collections");
+        assert_eq!(MongoAgentMethod::FindDocuments.as_str(), "find_documents");
+        assert_eq!(MongoAgentMethod::FindDocumentsExtendedJson.as_str(), "find_documents_extended_json");
+        assert_eq!(MongoAgentMethod::ServerVersion.as_str(), "server_version");
+        assert_eq!(MongoAgentMethod::CreateIndex.as_str(), "create_index");
+        assert_eq!(MongoAgentMethod::DropIndexes.as_str(), "drop_indexes");
+        assert_eq!(MongoAgentMethod::DropCollection.as_str(), "drop_collection");
+        assert_eq!(MongoAgentMethod::InsertDocument.as_str(), "insert_document");
+        assert_eq!(MongoAgentMethod::UpdateDocument.as_str(), "update_document");
+        assert_eq!(MongoAgentMethod::UpdateDocuments.as_str(), "update_documents");
+        assert_eq!(MongoAgentMethod::DeleteDocument.as_str(), "delete_document");
+        assert_eq!(MongoAgentMethod::DeleteDocuments.as_str(), "delete_documents");
+    }
+
+    #[test]
+    fn defines_kv_agent_protocol_methods() {
+        assert_eq!(AgentKvMethod::ListPrefix.as_str(), "kv_list_prefix");
+        assert_eq!(AgentKvMethod::Get.as_str(), "kv_get");
+        assert_eq!(AgentKvMethod::Put.as_str(), "kv_put");
+        assert_eq!(AgentKvMethod::Delete.as_str(), "kv_delete");
+        assert_eq!(AgentKvMethod::ALL.len(), 4);
+    }
+
+    #[test]
+    fn exposes_schema_and_query_protocol_wrappers() {
+        let _list_databases = AgentDriverClient::list_databases::<serde_json::Value>;
+        let _list_schemas = AgentDriverClient::list_schemas::<serde_json::Value>;
+        let _list_tables = AgentDriverClient::list_tables::<serde_json::Value>;
+        let _list_objects = AgentDriverClient::list_objects::<serde_json::Value>;
+        let _get_object_source = AgentDriverClient::get_object_source::<serde_json::Value, serde_json::Value>;
+        let _get_columns = AgentDriverClient::get_columns::<serde_json::Value>;
+        let _list_indexes = AgentDriverClient::list_indexes::<serde_json::Value>;
+        let _list_foreign_keys = AgentDriverClient::list_foreign_keys::<serde_json::Value>;
+        let _list_triggers = AgentDriverClient::list_triggers::<serde_json::Value>;
+        let _get_table_ddl = AgentDriverClient::get_table_ddl::<serde_json::Value>;
+        let _execute_query = AgentDriverClient::execute_query::<serde_json::Value>;
+        let _execute_query_page = AgentDriverClient::execute_query_page::<serde_json::Value>;
+        let _fetch_query_page = AgentDriverClient::fetch_query_page::<serde_json::Value>;
+        let _close_query_session = AgentDriverClient::close_query_session::<serde_json::Value>;
+        let _execute_batch = AgentDriverClient::execute_batch::<serde_json::Value>;
+        let _execute_transaction = AgentDriverClient::execute_transaction::<serde_json::Value>;
+    }
+
+    #[test]
+    fn exposes_mongo_protocol_wrappers() {
+        let _mongo_list_databases = AgentDriverClient::mongo_list_databases::<serde_json::Value>;
+        let _mongo_list_collections = AgentDriverClient::mongo_list_collections::<serde_json::Value>;
+        let _mongo_find_documents = AgentDriverClient::mongo_find_documents::<serde_json::Value>;
+        let _mongo_find_documents_extended_json =
+            AgentDriverClient::mongo_find_documents_extended_json::<serde_json::Value>;
+        let _mongo_server_version = AgentDriverClient::mongo_server_version::<serde_json::Value>;
+        let _mongo_create_index = AgentDriverClient::mongo_create_index::<serde_json::Value>;
+        let _mongo_drop_indexes = AgentDriverClient::mongo_drop_indexes::<serde_json::Value>;
+        let _mongo_drop_collection = AgentDriverClient::mongo_drop_collection::<serde_json::Value>;
+        let _mongo_insert_document = AgentDriverClient::mongo_insert_document::<serde_json::Value>;
+        let _mongo_update_document = AgentDriverClient::mongo_update_document::<serde_json::Value>;
+        let _mongo_update_documents = AgentDriverClient::mongo_update_documents::<serde_json::Value>;
+        let _mongo_delete_document = AgentDriverClient::mongo_delete_document::<serde_json::Value>;
+        let _mongo_delete_documents = AgentDriverClient::mongo_delete_documents::<serde_json::Value>;
+    }
+
+    #[test]
+    fn exposes_kv_protocol_wrapper() {
+        let _call_kv_method = AgentDriverClient::call_kv_method::<serde_json::Value>;
+    }
+
+    #[test]
+    fn exposes_table_read_protocol_wrappers() {
+        let _start_table_read = AgentDriverClient::start_table_read::<serde_json::Value>;
+        let _fetch_table_read_page = AgentDriverClient::fetch_table_read_page::<serde_json::Value>;
+        let _close_table_read_session = AgentDriverClient::close_table_read_session::<serde_json::Value>;
+    }
+
+    #[test]
+    fn serializes_table_read_params_with_agent_field_names() {
+        let start = serde_json::to_value(AgentTableReadStartParams {
+            sql: "SELECT * FROM users".to_string(),
+            database: Some("ORCL".to_string()),
+            schema: Some("APP".to_string()),
+            page_size: 500,
+            max_rows: 1000,
+            fetch_size: Some(500),
+        })
+        .unwrap();
+        assert_eq!(
+            start,
+            serde_json::json!({
+                "sql": "SELECT * FROM users",
+                "database": "ORCL",
+                "schema": "APP",
+                "pageSize": 500,
+                "maxRows": 1000,
+                "fetchSize": 500,
+            })
+        );
+
+        let page = serde_json::to_value(AgentTableReadPageParams { session_id: "table-1".to_string(), page_size: 250 })
+            .unwrap();
+        assert_eq!(page, serde_json::json!({ "sessionId": "table-1", "pageSize": 250 }));
+
+        let close = serde_json::to_value(AgentTableReadCloseParams { session_id: "table-1".to_string() }).unwrap();
+        assert_eq!(close, serde_json::json!({ "sessionId": "table-1" }));
+    }
+
+    #[test]
+    fn agent_query_result_default_column_types_is_empty_vec() {
+        // Old agent JARs predate the column_types field. Rust tolerates the
+        // missing field via #[serde(default)] on db::QueryResult.column_types
+        // and consumers must see an empty vector rather than an error.
+        let json = serde_json::json!({
+            "columns": ["id", "name"],
+            "rows": [[1, "Ada"]],
+            "affected_rows": 0,
+            "execution_time_ms": 1
+        });
+        let result: crate::types::QueryResult = serde_json::from_value(json).expect("deserialize legacy agent result");
+        assert_eq!(result.columns, vec!["id".to_string(), "name".to_string()]);
+        assert!(result.column_types.is_empty(), "missing column_types must default to empty");
+        assert_eq!(result.rows.len(), 1);
+    }
+
+    #[test]
+    fn agent_query_result_passes_through_column_types_when_present() {
+        // New PostgresLike agents (HighGo / KingBase / Vastbase / openGauss /
+        // GaussDB) include column_types alongside columns so the desktop UI
+        // can detect geometry/geography columns and offer the map preview.
+        let json = serde_json::json!({
+            "columns": ["id", "geom"],
+            "column_types": ["int4", "geometry"],
+            "rows": [[1, "POINT(116.397 39.908)"]],
+            "affected_rows": 0,
+            "execution_time_ms": 5
+        });
+        let result: crate::types::QueryResult = serde_json::from_value(json).expect("deserialize agent result");
+        assert_eq!(result.column_types, vec!["int4".to_string(), "geometry".to_string()]);
+        assert_eq!(result.rows[0][1], serde_json::json!("POINT(116.397 39.908)"));
+    }
+
+    #[test]
+    fn builds_mongo_agent_request_params() {
+        assert_eq!(mongo_database_params("app"), serde_json::json!({ "database": "app" }));
+        assert_eq!(
+            mongo_collection_params("app", "orders"),
+            serde_json::json!({ "database": "app", "collection": "orders" })
+        );
+        assert_eq!(
+            mongo_document_id_params("app", "orders", "abc"),
+            serde_json::json!({ "database": "app", "collection": "orders", "id": "abc" })
+        );
+    }
+
+    #[test]
+    fn builds_schema_table_and_transaction_params() {
+        assert_eq!(
+            agent_schema_params("sales", "public"),
+            serde_json::json!({ "database": "sales", "schema": "public" })
+        );
+        assert_eq!(
+            agent_schema_table_params("sales", "public", "orders"),
+            serde_json::json!({ "database": "sales", "schema": "public", "table": "orders" })
+        );
+        assert_eq!(
+            agent_object_source_params("sales", "public", "active_users", &"VIEW"),
+            serde_json::json!({
+                "database": "sales",
+                "schema": "public",
+                "name": "active_users",
+                "object_type": "VIEW",
+            })
+        );
+        assert_eq!(agent_close_query_session_params("session-1"), serde_json::json!({ "sessionId": "session-1" }));
+        assert_eq!(
+            agent_transaction_params(Some("sales"), &["BEGIN".to_string(), "COMMIT".to_string()], Some("public")),
+            serde_json::json!({ "database": "sales", "statements": ["BEGIN", "COMMIT"], "schema": "public" })
+        );
+    }
+
+    #[test]
+    fn agent_protocol_matches_contract_file() {
+        let contract: serde_json::Value =
+            serde_json::from_str(include_str!("../../assets/agent-protocol-v1.json")).unwrap();
+
+        assert_eq!(contract["protocolVersion"], AGENT_PROTOCOL_VERSION);
+        assert_eq!(contract["handshakeMethod"], AgentMethod::Handshake.as_str());
+        assert_eq!(
+            string_array(&contract["handshakeResponseFields"]),
+            vec!["protocolVersion", "agentProtocolVersion", "capabilities"]
+        );
+        assert_eq!(
+            string_array(&contract["allCapabilities"]),
+            AgentCapability::ALL.iter().map(|method| method.as_str()).collect::<Vec<_>>()
+        );
+        assert_eq!(string_array(&contract["capabilities"]), default_sql_capabilities());
+        assert_eq!(string_array(&contract["defaultSqlCapabilities"]), default_sql_capabilities());
+        assert_eq!(
+            string_array(&contract["commonMethods"]),
+            AgentMethod::ALL.iter().map(|method| method.as_str()).collect::<Vec<_>>()
+        );
+        assert_eq!(
+            string_array(&contract["mongoLegacyMethods"]),
+            MongoAgentMethod::ALL.iter().map(|method| method.as_str()).collect::<Vec<_>>()
+        );
+        assert_eq!(
+            string_array(&contract["kvMethods"]),
+            AgentKvMethod::ALL.iter().map(|method| method.as_str()).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn checks_handshake_capability_support() {
+        let handshake = AgentHandshake {
+            protocol_version: AGENT_PROTOCOL_VERSION,
+            agent_protocol_version: AGENT_PROTOCOL_VERSION,
+            capabilities: vec!["connect".to_string(), "metadata".to_string()],
+        };
+
+        assert!(handshake.supports(AgentCapability::Connect));
+        assert!(handshake.supports(AgentCapability::Metadata));
+        assert!(!handshake.supports(AgentCapability::Query));
+        assert!(!handshake.supports(AgentCapability::Kv));
+    }
+
+    #[test]
+    fn treats_missing_handshake_as_legacy_capability_support() {
+        let handshake = AgentHandshake {
+            protocol_version: AGENT_PROTOCOL_VERSION,
+            agent_protocol_version: AGENT_PROTOCOL_VERSION,
+            capabilities: vec!["connect".to_string()],
+        };
+
+        assert!(agent_supports_capability(None, AgentCapability::Query));
+        assert!(agent_supports_capability(Some(&handshake), AgentCapability::Connect));
+        assert!(!agent_supports_capability(Some(&handshake), AgentCapability::Query));
+        assert!(!agent_supports_capability(None, AgentCapability::Kv));
+        assert!(!agent_supports_capability(Some(&handshake), AgentCapability::Kv));
+    }
+
+    #[test]
+    fn treats_unknown_handshake_method_as_compatible_fallback() {
+        assert!(is_unsupported_handshake_error("Agent RPC error (-1): Unknown method: handshake"));
+        assert!(!is_unsupported_handshake_error("Agent RPC error (-1): Connection failed"));
+    }
+
+    fn string_array(value: &serde_json::Value) -> Vec<&str> {
+        value.as_array().unwrap().iter().map(|item| item.as_str().unwrap()).collect()
+    }
+
+    fn default_sql_capabilities() -> Vec<&'static str> {
+        [
+            AgentCapability::Connect,
+            AgentCapability::TestConnection,
+            AgentCapability::Metadata,
+            AgentCapability::Query,
+            AgentCapability::PagedQuery,
+            AgentCapability::Transaction,
+            AgentCapability::Ddl,
+        ]
+        .iter()
+        .map(|capability| capability.as_str())
+        .collect()
+    }
+}
diff --git a/crates/dbx-core/src/db/clickhouse_driver.rs b/crates/dbx-core/src/db/clickhouse_driver.rs
new file mode 100644
index 0000000..583f600
--- /dev/null
+++ b/crates/dbx-core/src/db/clickhouse_driver.rs
@@ -0,0 +1,785 @@
+use futures::StreamExt;
+use reqwest::{Certificate, Client as HttpClient};
+use serde::Deserialize;
+use std::fs;
+use std::time::{Duration, Instant};
+use tokio_util::sync::CancellationToken;
+
+use super::{http_client_builder, with_connection_timeout};
+use crate::query::{canceled_error, MAX_ROWS};
+use crate::sql::starts_with_executable_sql_keyword;
+use crate::types::{ColumnInfo, DatabaseInfo, IndexInfo, ObjectStatistics, QueryResult, TableInfo};
+
+pub struct ChClient {
+    http: HttpClient,
+    base_url: String,
+    username: Option<String>,
+    password: Option<String>,
+}
+
+impl ChClient {
+    pub fn new(url: &str, username: Option<String>, password: Option<String>, timeout: Duration) -> Self {
+        let http = http_client_builder(timeout).build().unwrap_or_else(|_| HttpClient::new());
+        Self { http, base_url: url.trim_end_matches('/').to_string(), username, password }
+    }
+
+    pub fn new_with_ca_cert(
+        url: &str,
+        username: Option<String>,
+        password: Option<String>,
+        ca_cert_path: Option<&str>,
+        timeout: Duration,
+    ) -> Result<Self, String> {
+        let mut builder = http_client_builder(timeout);
+        if let Some(path) = ca_cert_path.map(str::trim).filter(|path| !path.is_empty()) {
+            let path = expand_cert_path(path);
+            let cert_bytes =
+                fs::read(&path).map_err(|e| format!("Failed to read ClickHouse CA certificate at {path}: {e}"))?;
+            let cert = Certificate::from_pem(&cert_bytes)
+                .or_else(|_| Certificate::from_der(&cert_bytes))
+                .map_err(|e| format!("Failed to parse ClickHouse CA certificate at {path}: {e}"))?;
+            builder = builder.add_root_certificate(cert);
+        }
+        let http = builder.build().map_err(|e| format!("Failed to configure ClickHouse HTTP client: {e}"))?;
+        Ok(Self { http, base_url: url.trim_end_matches('/').to_string(), username, password })
+    }
+}
+
+fn expand_cert_path(path: &str) -> String {
+    let home = || std::env::var(if cfg!(windows) { "USERPROFILE" } else { "HOME" }).ok();
+    if path == "~" || path.starts_with("~/") || path.starts_with("~\\") {
+        if let Some(home) = home() {
+            return format!("{}{}", home, &path[1..]);
+        }
+    }
+    if let Some(rest) = path.strip_prefix("$HOME") {
+        if let Some(home) = home() {
+            return format!("{home}{rest}");
+        }
+    }
+    if let Some(rest) = path.strip_prefix("${HOME}") {
+        if let Some(home) = home() {
+            return format!("{home}{rest}");
+        }
+    }
+    if let Some(rest) = path.strip_prefix("%USERPROFILE%") {
+        if let Ok(home) = std::env::var("USERPROFILE") {
+            return format!("{home}{rest}");
+        }
+    }
+    path.to_string()
+}
+
+impl Clone for ChClient {
+    fn clone(&self) -> Self {
+        Self {
+            http: self.http.clone(),
+            base_url: self.base_url.clone(),
+            username: self.username.clone(),
+            password: self.password.clone(),
+        }
+    }
+}
+
+#[derive(Deserialize)]
+struct ChJsonResult {
+    meta: Vec<ChColumn>,
+    data: Vec<Vec<serde_json::Value>>,
+    #[serde(default)]
+    #[allow(dead_code)]
+    rows: usize,
+}
+
+#[derive(Deserialize)]
+struct ChColumn {
+    name: String,
+    #[serde(rename = "type")]
+    _type: String,
+}
+
+enum QueryResultLimit {
+    Unlimited,
+    Limited(usize),
+}
+
+enum QueryResultFormat {
+    JsonCompact,
+    JsonCompactEachRowWithNamesAndTypes,
+}
+
+const CLICKHOUSE_STREAM_ROW_LIMIT_REACHED: &str = "__DBX_CLICKHOUSE_STREAM_ROW_LIMIT_REACHED__";
+
+impl QueryResultFormat {
+    fn as_str(&self) -> &'static str {
+        match self {
+            QueryResultFormat::JsonCompact => "JSONCompact",
+            QueryResultFormat::JsonCompactEachRowWithNamesAndTypes => "JSONCompactEachRowWithNamesAndTypes",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum ClickHouseQueryStreamItem {
+    Columns { columns: Vec<String>, column_types: Vec<String> },
+    Row(Vec<serde_json::Value>),
+}
+
+fn build_query_url(base_url: &str, database: Option<&str>, limit: QueryResultLimit) -> String {
+    build_query_url_with_format(base_url, database, limit, QueryResultFormat::JsonCompact)
+}
+
+fn build_query_url_with_format(
+    base_url: &str,
+    database: Option<&str>,
+    limit: QueryResultLimit,
+    format: QueryResultFormat,
+) -> String {
+    let mut url = format!("{}/?default_format={}", base_url, format.as_str());
+    if let Some(db) = database {
+        url.push_str(&format!("&database={db}"));
+    }
+    if let QueryResultLimit::Limited(max_rows) = limit {
+        url.push_str(&format!("&max_result_rows={max_rows}&result_overflow_mode=break"));
+    }
+    url
+}
+
+#[derive(Default)]
+struct ClickHouseStreamParser {
+    line_index: usize,
+    columns: Vec<String>,
+}
+
+impl ClickHouseStreamParser {
+    fn parse_line(&mut self, line: &str) -> Result<Option<ClickHouseQueryStreamItem>, String> {
+        let line = line.trim_end_matches('\r');
+        if line.trim().is_empty() {
+            return Ok(None);
+        }
+
+        match self.line_index {
+            0 => {
+                self.columns = parse_stream_string_array(line, "column names")?;
+                self.line_index = 1;
+                Ok(None)
+            }
+            1 => {
+                let column_types = parse_stream_string_array(line, "column types")?;
+                self.line_index = 2;
+                Ok(Some(ClickHouseQueryStreamItem::Columns { columns: self.columns.clone(), column_types }))
+            }
+            _ => {
+                let row = parse_stream_value_array(line, "row")?;
+                self.line_index += 1;
+                Ok(Some(ClickHouseQueryStreamItem::Row(row)))
+            }
+        }
+    }
+
+    fn finish(&self) -> Result<(), String> {
+        if self.line_index == 1 {
+            return Err("ClickHouse stream ended before column types were received".to_string());
+        }
+        Ok(())
+    }
+}
+
+fn parse_stream_string_array(line: &str, label: &str) -> Result<Vec<String>, String> {
+    parse_stream_value_array(line, label).map(|values| {
+        values
+            .into_iter()
+            .map(|value| match value {
+                serde_json::Value::String(value) => value,
+                other => other.to_string(),
+            })
+            .collect()
+    })
+}
+
+fn parse_stream_value_array(line: &str, label: &str) -> Result<Vec<serde_json::Value>, String> {
+    serde_json::from_str(line).map_err(|e| format!("ClickHouse stream parse error in {label}: {e}"))
+}
+
+fn process_stream_buffer(
+    buffer: &mut Vec<u8>,
+    parser: &mut ClickHouseStreamParser,
+    on_item: &mut impl FnMut(ClickHouseQueryStreamItem) -> Result<(), String>,
+) -> Result<(), String> {
+    while let Some(newline) = buffer.iter().position(|byte| *byte == b'\n') {
+        let line_bytes: Vec<u8> = buffer.drain(..=newline).collect();
+        let line_bytes = &line_bytes[..line_bytes.len().saturating_sub(1)];
+        let line =
+            std::str::from_utf8(line_bytes).map_err(|e| format!("ClickHouse stream contains invalid UTF-8: {e}"))?;
+        if let Some(item) = parser.parse_line(line)? {
+            on_item(item)?;
+        }
+    }
+    Ok(())
+}
+
+fn process_stream_remainder(
+    buffer: &mut Vec<u8>,
+    parser: &mut ClickHouseStreamParser,
+    on_item: &mut impl FnMut(ClickHouseQueryStreamItem) -> Result<(), String>,
+) -> Result<(), String> {
+    if !buffer.is_empty() {
+        let line = std::str::from_utf8(buffer).map_err(|e| format!("ClickHouse stream contains invalid UTF-8: {e}"))?;
+        if let Some(item) = parser.parse_line(line)? {
+            on_item(item)?;
+        }
+        buffer.clear();
+    }
+    parser.finish()
+}
+
+fn build_request(client: &ChClient, req: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
+    match (&client.username, &client.password) {
+        (Some(u), Some(p)) if !u.is_empty() => req.basic_auth(u, Some(p)),
+        (Some(u), None) if !u.is_empty() => req.basic_auth(u, None::<&str>),
+        _ => req,
+    }
+}
+
+async fn ch_query(client: &ChClient, sql: &str, database: Option<&str>) -> Result<ChJsonResult, String> {
+    ch_query_with_limit(client, sql, database, QueryResultLimit::Unlimited).await
+}
+
+async fn ch_query_with_limit(
+    client: &ChClient,
+    sql: &str,
+    database: Option<&str>,
+    limit: QueryResultLimit,
+) -> Result<ChJsonResult, String> {
+    let url = build_query_url(&client.base_url, database, limit);
+    log::info!("[clickhouse] query url={url} user={:?} has_pass={}", client.username, client.password.is_some());
+    let req = build_request(client, client.http.post(&url).body(sql.to_string()));
+    let resp = req.send().await.map_err(|e| format!("ClickHouse request failed: {e}"))?;
+    log::info!("[clickhouse] response status={}", resp.status());
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        log::error!("[clickhouse] error body: {body}");
+        return Err(format!("ClickHouse error: {body}"));
+    }
+    resp.json::<ChJsonResult>().await.map_err(|e| format!("ClickHouse parse error: {e}"))
+}
+
+pub async fn stream_query_with_max_rows(
+    client: &ChClient,
+    database: &str,
+    sql: &str,
+    max_rows: Option<usize>,
+    cancel_token: Option<CancellationToken>,
+    mut on_item: impl FnMut(ClickHouseQueryStreamItem) -> Result<(), String>,
+) -> Result<(), String> {
+    let max_rows = max_rows.map(|max_rows| max_rows.max(1));
+    let limit = max_rows.map(QueryResultLimit::Limited).unwrap_or(QueryResultLimit::Unlimited);
+    let url = build_query_url_with_format(
+        &client.base_url,
+        Some(database),
+        limit,
+        QueryResultFormat::JsonCompactEachRowWithNamesAndTypes,
+    );
+    log::info!("[clickhouse] stream query url={url} user={:?} has_pass={}", client.username, client.password.is_some());
+    let req = build_request(client, client.http.post(&url).body(sql.to_string()));
+    let resp = req.send().await.map_err(|e| format!("ClickHouse request failed: {e}"))?;
+    log::info!("[clickhouse] stream response status={}", resp.status());
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        log::error!("[clickhouse] stream error body: {body}");
+        return Err(format!("ClickHouse error: {body}"));
+    }
+
+    let mut stream = resp.bytes_stream();
+    let mut buffer = Vec::new();
+    let mut parser = ClickHouseStreamParser::default();
+    let mut rows_seen = 0usize;
+    let mut emit_item = |item: ClickHouseQueryStreamItem| -> Result<(), String> {
+        if matches!(item, ClickHouseQueryStreamItem::Row(_)) {
+            rows_seen = rows_seen.saturating_add(1);
+        }
+        on_item(item)?;
+        if max_rows.is_some_and(|max_rows| rows_seen >= max_rows) {
+            return Err(CLICKHOUSE_STREAM_ROW_LIMIT_REACHED.to_string());
+        }
+        Ok(())
+    };
+
+    loop {
+        let chunk = match cancel_token.as_ref() {
+            Some(token) => {
+                tokio::select! {
+                    biased;
+                    _ = token.cancelled() => return Err(canceled_error()),
+                    chunk = stream.next() => chunk,
+                }
+            }
+            None => stream.next().await,
+        };
+        let Some(chunk) = chunk else {
+            break;
+        };
+        let chunk = chunk.map_err(|e| format!("ClickHouse stream read failed: {e}"))?;
+        buffer.extend_from_slice(&chunk);
+        match process_stream_buffer(&mut buffer, &mut parser, &mut emit_item) {
+            Err(error) if error == CLICKHOUSE_STREAM_ROW_LIMIT_REACHED => return Ok(()),
+            result => result?,
+        }
+    }
+
+    match process_stream_remainder(&mut buffer, &mut parser, &mut emit_item) {
+        Err(error) if error == CLICKHOUSE_STREAM_ROW_LIMIT_REACHED => Ok(()),
+        result => result,
+    }
+}
+
+fn query_result_row_limit(max_rows: Option<usize>) -> usize {
+    max_rows.unwrap_or(MAX_ROWS).max(1)
+}
+
+fn clickhouse_literal(value: &str) -> String {
+    value.replace('\\', "\\\\").replace('\'', "\\'")
+}
+
+fn json_value_as_u64(value: Option<&serde_json::Value>) -> Option<u64> {
+    value.and_then(|value| value.as_u64().or_else(|| value.as_str().and_then(|text| text.parse::<u64>().ok())))
+}
+
+fn json_value_as_i64(value: Option<&serde_json::Value>) -> Option<i64> {
+    value.and_then(|value| {
+        value
+            .as_i64()
+            .or_else(|| value.as_u64().and_then(|value| i64::try_from(value).ok()))
+            .or_else(|| value.as_str().and_then(|text| text.parse::<i64>().ok()))
+    })
+}
+
+fn split_clickhouse_expression_list(value: &str) -> Vec<String> {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        return Vec::new();
+    }
+
+    let inner = trimmed.strip_prefix("tuple(").and_then(|rest| rest.strip_suffix(')')).unwrap_or(trimmed);
+    let mut items = Vec::new();
+    let mut start = 0;
+    let mut depth = 0i32;
+    let mut quote: Option<char> = None;
+    let mut escaped = false;
+
+    for (idx, ch) in inner.char_indices() {
+        if let Some(q) = quote {
+            if escaped {
+                escaped = false;
+            } else if ch == '\\' {
+                escaped = true;
+            } else if ch == q {
+                quote = None;
+            }
+            continue;
+        }
+
+        match ch {
+            '\'' | '"' | '`' => quote = Some(ch),
+            '(' | '[' | '{' => depth += 1,
+            ')' | ']' | '}' => depth = (depth - 1).max(0),
+            ',' if depth == 0 => {
+                let item = inner[start..idx].trim();
+                if !item.is_empty() {
+                    items.push(item.to_string());
+                }
+                start = idx + ch.len_utf8();
+            }
+            _ => {}
+        }
+    }
+
+    let item = inner[start..].trim();
+    if !item.is_empty() {
+        items.push(item.to_string());
+    }
+    items
+}
+
+fn clickhouse_index_from_skipping_row(row: &[serde_json::Value]) -> IndexInfo {
+    let index_type = row.get(2).and_then(|v| v.as_str()).unwrap_or("").to_string();
+    let granularity = json_value_as_u64(row.get(3));
+    IndexInfo {
+        name: row.first().and_then(|v| v.as_str()).unwrap_or("").to_string(),
+        columns: split_clickhouse_expression_list(row.get(1).and_then(|v| v.as_str()).unwrap_or("")),
+        is_unique: false,
+        is_primary: false,
+        filter: None,
+        index_type: Some(match granularity {
+            Some(value) => format!("{index_type} GRANULARITY {value}"),
+            None => index_type,
+        }),
+        included_columns: None,
+        comment: None,
+    }
+}
+
+fn clickhouse_object_statistics_from_row(row: &[serde_json::Value], database: &str) -> Option<ObjectStatistics> {
+    let name = row.first().and_then(|value| value.as_str()).unwrap_or("").trim();
+    (!name.is_empty()).then(|| ObjectStatistics {
+        name: name.to_string(),
+        schema: Some(database.to_string()),
+        estimated_rows: json_value_as_i64(row.get(1)),
+        total_bytes: json_value_as_i64(row.get(2)),
+    })
+}
+
+fn clickhouse_table_info_from_row(row: &[serde_json::Value]) -> TableInfo {
+    let engine = row.get(1).and_then(|v| v.as_str()).unwrap_or("");
+    let table_type = if engine.contains("View") { "VIEW" } else { "BASE TABLE" };
+    TableInfo {
+        name: row.first().and_then(|v| v.as_str()).unwrap_or("").to_string(),
+        table_type: table_type.to_string(),
+        comment: row.get(2).and_then(|v| v.as_str()).filter(|value| !value.is_empty()).map(str::to_string),
+        parent_schema: None,
+        parent_name: None,
+    }
+}
+
+fn limited_query_result(result: ChJsonResult, execution_time_ms: u128, max_rows: Option<usize>) -> QueryResult {
+    let columns: Vec<String> = result.meta.iter().map(|c| c.name.clone()).collect();
+    let column_types: Vec<String> = result.meta.iter().map(|c| c._type.clone()).collect();
+    let mut rows = result.data;
+    let row_limit = query_result_row_limit(max_rows);
+    let truncated = rows.len() > row_limit;
+    if truncated {
+        rows.truncate(row_limit);
+    }
+    QueryResult {
+        columns,
+        column_types,
+        column_sortables: vec![],
+        rows,
+        affected_rows: 0,
+        execution_time_ms,
+        truncated,
+        session_id: None,
+        has_more: false,
+    }
+}
+
+pub async fn test_connection(client: &ChClient, timeout: Duration) -> Result<(), String> {
+    let url = format!("{}/?query=SELECT%201", client.base_url);
+    let req = build_request(client, client.http.get(&url));
+    let resp = with_connection_timeout("ClickHouse", timeout, async {
+        req.send().await.map_err(|e| format!("ClickHouse connection failed: {e}"))
+    })
+    .await?;
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        return Err(format!("ClickHouse error: {body}"));
+    }
+    Ok(())
+}
+
+pub async fn list_databases(client: &ChClient) -> Result<Vec<DatabaseInfo>, String> {
+    let result = ch_query(client, "SELECT name FROM system.databases ORDER BY name", None).await?;
+    Ok(result.data.iter().map(|row| DatabaseInfo { name: row[0].as_str().unwrap_or("").to_string() }).collect())
+}
+
+pub async fn list_tables(client: &ChClient, database: &str) -> Result<Vec<TableInfo>, String> {
+    let database_lit = clickhouse_literal(database);
+    let sql_with_comment =
+        format!("SELECT name, engine, comment FROM system.tables WHERE database = '{database_lit}' ORDER BY name");
+    let result = match ch_query(client, &sql_with_comment, Some(database)).await {
+        Ok(result) => result,
+        Err(error) => {
+            log::debug!("Falling back to ClickHouse table list without comments: {error}");
+            let sql = format!("SELECT name, engine FROM system.tables WHERE database = '{database_lit}' ORDER BY name");
+            ch_query(client, &sql, Some(database)).await?
+        }
+    };
+    Ok(result.data.iter().map(|row| clickhouse_table_info_from_row(row)).collect())
+}
+
+pub async fn list_object_statistics(client: &ChClient, database: &str) -> Result<Vec<ObjectStatistics>, String> {
+    let database_lit = clickhouse_literal(database);
+    let sql = format!(
+        "SELECT name, total_rows, total_bytes \
+         FROM system.tables \
+         WHERE database = '{database_lit}' \
+         ORDER BY name"
+    );
+    let result = ch_query(client, &sql, Some(database)).await?;
+    Ok(result.data.iter().filter_map(|row| clickhouse_object_statistics_from_row(row, database)).collect())
+}
+
+pub async fn get_columns(client: &ChClient, database: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let sql = format!(
+        "SELECT name, type, default_kind, default_expression, is_in_primary_key, is_in_partition_key, comment \
+         FROM system.columns WHERE database = '{}' AND table = '{}' ORDER BY position",
+        database.replace('\'', "\\'"),
+        table.replace('\'', "\\'")
+    );
+    let result = ch_query(client, &sql, Some(database)).await?;
+    Ok(result
+        .data
+        .iter()
+        .map(|row| {
+            let data_type = row.get(1).and_then(|v| v.as_str()).unwrap_or("").to_string();
+            let is_nullable = data_type.starts_with("Nullable");
+            let is_pk = row.get(4).and_then(|v| v.as_u64()).unwrap_or(0) == 1;
+            let is_partition_key = row.get(5).and_then(|v| v.as_u64()).unwrap_or(0) == 1;
+            let default_kind = row.get(2).and_then(|v| v.as_str()).unwrap_or("");
+            let default_expr = row.get(3).and_then(|v| v.as_str()).unwrap_or("");
+            let column_default = if default_kind.is_empty() { None } else { Some(default_expr.to_string()) };
+            ColumnInfo {
+                name: row[0].as_str().unwrap_or("").to_string(),
+                data_type,
+                is_nullable,
+                column_default,
+                is_primary_key: is_pk,
+                extra: is_partition_key.then(|| "partition_key".to_string()),
+                comment: row.get(6).and_then(|v| v.as_str()).filter(|value| !value.is_empty()).map(str::to_string),
+                numeric_precision: None,
+                numeric_scale: None,
+                character_maximum_length: None,
+                enum_values: None,
+                ..Default::default()
+            }
+        })
+        .collect())
+}
+
+pub async fn list_indexes(client: &ChClient, database: &str, table: &str) -> Result<Vec<IndexInfo>, String> {
+    let database_lit = clickhouse_literal(database);
+    let table_lit = clickhouse_literal(table);
+    let primary_sql = format!(
+        "SELECT primary_key FROM system.tables WHERE database = '{database_lit}' AND name = '{table_lit}' LIMIT 1"
+    );
+    let skipping_sql = format!(
+        "SELECT name, expr, type, granularity \
+         FROM system.data_skipping_indices \
+         WHERE database = '{database_lit}' AND table = '{table_lit}' \
+         ORDER BY name"
+    );
+
+    let mut indexes = Vec::new();
+    let primary_result = ch_query(client, &primary_sql, Some(database)).await?;
+    if let Some(primary_key) = primary_result
+        .data
+        .first()
+        .and_then(|row| row.first())
+        .and_then(|value| value.as_str())
+        .filter(|value| !value.trim().is_empty())
+    {
+        indexes.push(IndexInfo {
+            name: "PRIMARY".to_string(),
+            columns: split_clickhouse_expression_list(primary_key),
+            is_unique: false,
+            is_primary: true,
+            filter: None,
+            index_type: Some("primary".to_string()),
+            included_columns: None,
+            comment: None,
+        });
+    }
+
+    let skipping_result = ch_query(client, &skipping_sql, Some(database)).await?;
+    indexes.extend(skipping_result.data.iter().map(|row| clickhouse_index_from_skipping_row(row)));
+    Ok(indexes)
+}
+
+pub async fn execute_query(client: &ChClient, database: &str, sql: &str) -> Result<QueryResult, String> {
+    execute_query_with_max_rows(client, database, sql, None).await
+}
+
+pub async fn execute_query_with_max_rows(
+    client: &ChClient,
+    database: &str,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<QueryResult, String> {
+    let start = Instant::now();
+    let row_limit = query_result_row_limit(max_rows);
+
+    if starts_with_executable_sql_keyword(sql, &["SELECT", "SHOW", "DESCRIBE", "EXPLAIN", "WITH"]) {
+        let result = ch_query_with_limit(client, sql, Some(database), QueryResultLimit::Limited(row_limit + 1)).await?;
+        Ok(limited_query_result(result, start.elapsed().as_millis(), Some(row_limit)))
+    } else {
+        let url = build_query_url(&client.base_url, Some(database), QueryResultLimit::Unlimited);
+        let req = build_request(client, client.http.post(&url).body(sql.to_string()));
+        let resp = req.send().await.map_err(|e| format!("ClickHouse request failed: {e}"))?;
+        if !resp.status().is_success() {
+            let body = resp.text().await.unwrap_or_default();
+            return Err(format!("ClickHouse error: {body}"));
+        }
+        Ok(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: 0,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn query_url_for_result_sets_adds_row_limit_break_settings() {
+        let url = build_query_url(
+            "http://localhost:8123",
+            Some("analytics"),
+            QueryResultLimit::Limited(crate::query::MAX_ROWS + 1),
+        );
+
+        assert_eq!(
+            url,
+            "http://localhost:8123/?default_format=JSONCompact&database=analytics&max_result_rows=10001&result_overflow_mode=break"
+        );
+    }
+
+    #[test]
+    fn stream_query_url_uses_line_delimited_names_and_types_format() {
+        let url = build_query_url_with_format(
+            "http://localhost:8123",
+            Some("analytics"),
+            QueryResultLimit::Limited(500),
+            QueryResultFormat::JsonCompactEachRowWithNamesAndTypes,
+        );
+
+        assert_eq!(
+            url,
+            "http://localhost:8123/?default_format=JSONCompactEachRowWithNamesAndTypes&database=analytics&max_result_rows=500&result_overflow_mode=break"
+        );
+    }
+
+    #[test]
+    fn stream_parser_reads_columns_types_and_rows_across_chunks() {
+        let mut buffer = b"[\"id\",\"name\"]\n[\"UInt64\",\"String\"]\n[1,\"Ada\"]\n[2,\"Linus\"".to_vec();
+        let mut parser = ClickHouseStreamParser::default();
+        let mut items = Vec::new();
+
+        process_stream_buffer(&mut buffer, &mut parser, &mut |item| {
+            items.push(item);
+            Ok(())
+        })
+        .unwrap();
+        buffer.extend_from_slice(b"]\n");
+        process_stream_remainder(&mut buffer, &mut parser, &mut |item| {
+            items.push(item);
+            Ok(())
+        })
+        .unwrap();
+
+        assert_eq!(
+            items,
+            vec![
+                ClickHouseQueryStreamItem::Columns {
+                    columns: vec!["id".to_string(), "name".to_string()],
+                    column_types: vec!["UInt64".to_string(), "String".to_string()],
+                },
+                ClickHouseQueryStreamItem::Row(vec![serde_json::json!(1), serde_json::json!("Ada")]),
+                ClickHouseQueryStreamItem::Row(vec![serde_json::json!(2), serde_json::json!("Linus")]),
+            ]
+        );
+    }
+
+    #[test]
+    fn limited_query_result_truncates_extra_probe_row() {
+        let result = ChJsonResult {
+            meta: vec![ChColumn { name: "id".to_string(), _type: "UInt64".to_string() }],
+            data: (0..=crate::query::MAX_ROWS).map(|value| vec![serde_json::Value::Number(value.into())]).collect(),
+            rows: crate::query::MAX_ROWS + 1,
+        };
+
+        let result = limited_query_result(result, 12, None);
+
+        assert_eq!(result.columns, vec!["id"]);
+        assert_eq!(result.rows.len(), crate::query::MAX_ROWS);
+        assert_eq!(result.execution_time_ms, 12);
+        assert!(result.truncated);
+    }
+
+    #[test]
+    fn splits_clickhouse_expression_lists_without_splitting_function_args() {
+        assert_eq!(split_clickhouse_expression_list("user_id, cityHash64(email, status), event_time"), {
+            vec!["user_id".to_string(), "cityHash64(email, status)".to_string(), "event_time".to_string()]
+        });
+        assert_eq!(split_clickhouse_expression_list("tuple(user_id, event_time)"), {
+            vec!["user_id".to_string(), "event_time".to_string()]
+        });
+    }
+
+    #[test]
+    fn maps_clickhouse_data_skipping_index_row() {
+        let row = vec![
+            serde_json::Value::String("idx_email".to_string()),
+            serde_json::Value::String("lower(email)".to_string()),
+            serde_json::Value::String("bloom_filter".to_string()),
+            serde_json::Value::String("4".to_string()),
+        ];
+
+        let index = clickhouse_index_from_skipping_row(&row);
+
+        assert_eq!(index.name, "idx_email");
+        assert_eq!(index.columns, vec!["lower(email)"]);
+        assert_eq!(index.index_type.as_deref(), Some("bloom_filter GRANULARITY 4"));
+        assert!(!index.is_primary);
+    }
+
+    #[test]
+    fn maps_clickhouse_object_statistics_row() {
+        let row = vec![
+            serde_json::Value::String("events".to_string()),
+            serde_json::Value::String("1234".to_string()),
+            serde_json::Value::Number(8192.into()),
+        ];
+
+        let stat = clickhouse_object_statistics_from_row(&row, "analytics").expect("stat row");
+
+        assert_eq!(stat.name, "events");
+        assert_eq!(stat.schema.as_deref(), Some("analytics"));
+        assert_eq!(stat.estimated_rows, Some(1234));
+        assert_eq!(stat.total_bytes, Some(8192));
+    }
+
+    #[test]
+    fn skips_clickhouse_object_statistics_rows_without_name() {
+        let row = vec![
+            serde_json::Value::String(" ".to_string()),
+            serde_json::Value::Number(1.into()),
+            serde_json::Value::Number(2.into()),
+        ];
+
+        assert!(clickhouse_object_statistics_from_row(&row, "analytics").is_none());
+    }
+
+    #[test]
+    fn maps_clickhouse_table_info_with_comment() {
+        let row = vec![
+            serde_json::Value::String("events".to_string()),
+            serde_json::Value::String("MergeTree".to_string()),
+            serde_json::Value::String("event stream".to_string()),
+        ];
+
+        let table = clickhouse_table_info_from_row(&row);
+
+        assert_eq!(table.name, "events");
+        assert_eq!(table.table_type, "BASE TABLE");
+        assert_eq!(table.comment.as_deref(), Some("event stream"));
+    }
+
+    #[test]
+    fn maps_clickhouse_table_info_without_comment_column() {
+        let row =
+            vec![serde_json::Value::String("active_users".to_string()), serde_json::Value::String("View".to_string())];
+
+        let table = clickhouse_table_info_from_row(&row);
+
+        assert_eq!(table.name, "active_users");
+        assert_eq!(table.table_type, "VIEW");
+        assert_eq!(table.comment, None);
+    }
+}
diff --git a/crates/dbx-core/src/db/cloudflare_d1/import.rs b/crates/dbx-core/src/db/cloudflare_d1/import.rs
new file mode 100644
index 0000000..69fd543
--- /dev/null
+++ b/crates/dbx-core/src/db/cloudflare_d1/import.rs
@@ -0,0 +1,94 @@
+use crate::models::connection::DatabaseType;
+use crate::table_import::{mapping_indexes_for_columns, ImportSqlBatch, TableImportColumnMapping};
+use crate::transfer::generate_insert_typed;
+
+use super::sql_limits::build_sql_batches;
+
+pub(crate) fn build_import_insert_batches(
+    rows: &[Vec<serde_json::Value>],
+    source_columns: &[String],
+    mappings: &[TableImportColumnMapping],
+    target_column_types: &[(String, String)],
+    table: &str,
+    schema: &str,
+    max_rows: usize,
+) -> Result<Vec<ImportSqlBatch>, String> {
+    let mapped = mapping_indexes_for_columns(source_columns, mappings)?;
+    let columns = mapped.iter().map(|(_, target)| target.clone()).collect::<Vec<_>>();
+    let column_types = columns
+        .iter()
+        .map(|column| {
+            target_column_types
+                .iter()
+                .find(|(name, _)| name.eq_ignore_ascii_case(column))
+                .map(|(_, data_type)| data_type.clone())
+        })
+        .collect::<Vec<_>>();
+    let rows = rows
+        .iter()
+        .map(|row| {
+            mapped
+                .iter()
+                .map(|(source_index, _)| row.get(*source_index).cloned().unwrap_or(serde_json::Value::Null))
+                .collect::<Vec<_>>()
+        })
+        .collect::<Vec<_>>();
+
+    build_sql_batches(rows.len(), max_rows, "import row", |range| {
+        generate_insert_typed(&columns, &column_types, &rows[range], table, schema, &DatabaseType::CloudflareD1)
+    })
+    .map(|batches| {
+        batches.into_iter().map(|batch| ImportSqlBatch { sql: batch.sql, row_count: batch.item_count }).collect()
+    })
+}
+
+pub(crate) fn build_streaming_import_insert_batch(
+    rows: &[Vec<serde_json::Value>],
+    source_columns: &[String],
+    mappings: &[TableImportColumnMapping],
+    target_column_types: &[(String, String)],
+    table: &str,
+    schema: &str,
+    max_rows: usize,
+) -> Result<Option<ImportSqlBatch>, String> {
+    let batches =
+        build_import_insert_batches(rows, source_columns, mappings, target_column_types, table, schema, max_rows)?;
+    if batches.is_empty() {
+        return Ok(None);
+    }
+    let row_count = batches.iter().map(|batch| batch.row_count).sum();
+    let sql = batches.into_iter().map(|batch| batch.sql).collect::<Vec<_>>().join(";\n");
+    Ok(Some(ImportSqlBatch { sql, row_count }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn streaming_import_joins_individually_size_limited_statements() {
+        let rows = vec![vec![serde_json::json!("a".repeat(60_000))], vec![serde_json::json!("b".repeat(60_000))]];
+        let columns = vec!["value".to_string()];
+        let mappings = vec![TableImportColumnMapping {
+            source_column: "value".to_string(),
+            target_column: "value".to_string(),
+            target_data_type: None,
+        }];
+
+        let batch = crate::table_import::build_import_insert_batch_from_rows(
+            &rows,
+            &columns,
+            &mappings,
+            &[],
+            "events",
+            "main",
+            &DatabaseType::CloudflareD1,
+        )
+        .unwrap()
+        .unwrap();
+
+        assert_eq!(batch.row_count, 2);
+        assert_eq!(batch.sql.split(";\n").count(), 2);
+        assert!(batch.sql.split(";\n").all(|statement| statement.len() <= super::super::MAX_SQL_STATEMENT_BYTES));
+    }
+}
diff --git a/crates/dbx-core/src/db/cloudflare_d1/mod.rs b/crates/dbx-core/src/db/cloudflare_d1/mod.rs
new file mode 100644
index 0000000..d608007
--- /dev/null
+++ b/crates/dbx-core/src/db/cloudflare_d1/mod.rs
@@ -0,0 +1,628 @@
+use reqwest::Client as HttpClient;
+use serde::Deserialize;
+use std::time::{Duration, Instant};
+
+use super::{http_client_builder, json_value_for_js, with_connection_timeout};
+use crate::models::connection::ConnectionConfig;
+use crate::types::{
+    ColumnInfo, DatabaseInfo, ForeignKeyInfo, IndexInfo, ObjectSource, ObjectSourceKind, QueryResult, TableInfo,
+    TriggerInfo,
+};
+
+mod import;
+mod sql_guard;
+mod sql_lexer;
+mod sql_limits;
+#[cfg(test)]
+mod transfer_tests;
+mod trigger;
+
+pub(crate) use import::{build_import_insert_batches, build_streaming_import_insert_batch};
+pub use sql_limits::MAX_SQL_STATEMENT_BYTES;
+
+const CLOUDFLARE_API_BASE_URL: &str = "https://api.cloudflare.com/client/v4";
+
+#[derive(Clone)]
+pub struct CloudflareD1Client {
+    http: HttpClient,
+    endpoint: String,
+    api_token: String,
+}
+
+impl CloudflareD1Client {
+    pub fn new(account_id: &str, database_id: &str, api_token: &str, timeout: Duration) -> Result<Self, String> {
+        let account_id = required_identifier(account_id, "Cloudflare Account ID")?;
+        let database_id = required_identifier(database_id, "Cloudflare D1 Database ID")?;
+        let endpoint = format!("{CLOUDFLARE_API_BASE_URL}/accounts/{account_id}/d1/database/{database_id}/raw");
+        Self::with_endpoint(endpoint, api_token, timeout)
+    }
+
+    fn with_endpoint(endpoint: String, api_token: &str, timeout: Duration) -> Result<Self, String> {
+        let api_token = required_field(api_token, "Cloudflare API Token")?;
+        let http = http_client_builder(timeout)
+            .build()
+            .map_err(|error| format!("Failed to configure Cloudflare D1 HTTP client: {error}"))?;
+        Ok(Self { http, endpoint, api_token: api_token.to_string() })
+    }
+
+    fn post_raw(&self, sql: &str) -> reqwest::RequestBuilder {
+        self.http
+            .post(&self.endpoint)
+            .bearer_auth(&self.api_token)
+            .header(reqwest::header::CONTENT_TYPE, "application/json")
+            .json(&serde_json::json!({ "sql": sql }))
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct D1ApiResponse {
+    #[serde(default)]
+    success: Option<bool>,
+    #[serde(default)]
+    errors: Vec<D1ApiError>,
+    #[serde(default)]
+    result: Vec<D1StatementResult>,
+}
+
+#[derive(Debug, Deserialize)]
+struct D1ApiError {
+    #[serde(default)]
+    code: Option<u64>,
+    message: String,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct D1StatementResult {
+    #[serde(default)]
+    success: Option<bool>,
+    #[serde(default)]
+    results: D1RawResult,
+    #[serde(default)]
+    meta: D1Meta,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct D1RawResult {
+    #[serde(default)]
+    columns: Vec<String>,
+    #[serde(default)]
+    rows: Vec<Vec<serde_json::Value>>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct D1Meta {
+    #[serde(default)]
+    changes: Option<u64>,
+}
+
+pub async fn test_connection(client: &CloudflareD1Client, timeout: Duration) -> Result<(), String> {
+    with_connection_timeout("Cloudflare D1", timeout, async { send_raw(client, "SELECT 1").await.map(|_| ()) }).await
+}
+
+pub async fn connect(config: &ConnectionConfig, timeout: Duration) -> Result<CloudflareD1Client, String> {
+    let client = CloudflareD1Client::new(
+        &config.host,
+        config.database.as_deref().unwrap_or_default(),
+        &config.password,
+        timeout,
+    )?;
+    test_connection(&client, timeout).await?;
+    Ok(client)
+}
+
+pub async fn list_databases(_client: &CloudflareD1Client) -> Result<Vec<DatabaseInfo>, String> {
+    Ok(vec![DatabaseInfo { name: "main".to_string() }])
+}
+
+pub async fn list_tables(client: &CloudflareD1Client, _schema: &str) -> Result<Vec<TableInfo>, String> {
+    let result = query_inner(
+        client,
+        "SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\' AND name <> '_cf_KV' ORDER BY name",
+    )
+    .await?;
+    Ok(result
+        .rows
+        .into_iter()
+        .map(|row| {
+            let table_type = value_as_string(row.get(1)).unwrap_or_else(|| "table".to_string());
+            TableInfo {
+                name: value_as_string(row.first()).unwrap_or_default(),
+                table_type: if table_type.eq_ignore_ascii_case("view") { "VIEW" } else { "BASE TABLE" }.to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            }
+        })
+        .collect())
+}
+
+pub async fn get_columns(client: &CloudflareD1Client, _schema: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    // table_info omits generated columns; table_xinfo exposes them and marks
+    // virtual/stored generated columns with hidden values 2 and 3.
+    let result = query_inner(client, &format!("PRAGMA table_xinfo({})", sqlite_ident(table))).await?;
+    Ok(result
+        .rows
+        .into_iter()
+        .map(|row| {
+            let hidden = value_by_column(&result.columns, &row, "hidden")
+                .and_then(|value| value.parse::<i64>().ok())
+                .unwrap_or(0);
+            ColumnInfo {
+                name: value_by_column(&result.columns, &row, "name").unwrap_or_default(),
+                data_type: value_by_column(&result.columns, &row, "type").unwrap_or_default(),
+                is_nullable: value_by_column(&result.columns, &row, "notnull")
+                    .and_then(|value| value.parse::<i64>().ok())
+                    .unwrap_or(0)
+                    == 0,
+                column_default: value_by_column(&result.columns, &row, "dflt_value"),
+                is_primary_key: value_by_column(&result.columns, &row, "pk")
+                    .and_then(|value| value.parse::<i64>().ok())
+                    .unwrap_or(0)
+                    > 0,
+                extra: match hidden {
+                    2 => Some("generated always as virtual".to_string()),
+                    3 => Some("generated always as stored".to_string()),
+                    _ => None,
+                },
+                comment: None,
+                numeric_precision: None,
+                numeric_scale: None,
+                character_maximum_length: None,
+                enum_values: None,
+                ..Default::default()
+            }
+        })
+        .collect())
+}
+
+pub async fn list_indexes(client: &CloudflareD1Client, _schema: &str, table: &str) -> Result<Vec<IndexInfo>, String> {
+    let result = query_inner(client, &format!("PRAGMA index_list({})", sqlite_ident(table))).await?;
+    let mut indexes = Vec::new();
+    for row in result.rows {
+        let name = value_by_column(&result.columns, &row, "name").unwrap_or_default();
+        if name.is_empty() {
+            continue;
+        }
+        let is_unique =
+            value_by_column(&result.columns, &row, "unique").and_then(|value| value.parse::<i64>().ok()).unwrap_or(0)
+                != 0;
+        let origin = value_by_column(&result.columns, &row, "origin").unwrap_or_default();
+        let column_result = query_inner(client, &format!("PRAGMA index_info({})", sqlite_ident(&name))).await?;
+        let columns =
+            column_result.rows.iter().filter_map(|row| value_by_column(&column_result.columns, row, "name")).collect();
+        indexes.push(IndexInfo {
+            name,
+            columns,
+            is_unique,
+            is_primary: origin == "pk",
+            filter: None,
+            index_type: None,
+            included_columns: None,
+            comment: None,
+        });
+    }
+    Ok(indexes)
+}
+
+pub async fn list_foreign_keys(
+    client: &CloudflareD1Client,
+    _schema: &str,
+    table: &str,
+) -> Result<Vec<ForeignKeyInfo>, String> {
+    let result = query_inner(client, &format!("PRAGMA foreign_key_list({})", sqlite_ident(table))).await?;
+    Ok(result
+        .rows
+        .into_iter()
+        .map(|row| ForeignKeyInfo {
+            name: format!("fk_{}", value_by_column(&result.columns, &row, "id").unwrap_or_else(|| "0".to_string())),
+            column: value_by_column(&result.columns, &row, "from").unwrap_or_default(),
+            ref_schema: None,
+            ref_table: value_by_column(&result.columns, &row, "table").unwrap_or_default(),
+            ref_column: value_by_column(&result.columns, &row, "to").unwrap_or_default(),
+            on_update: value_by_column(&result.columns, &row, "on_update"),
+            on_delete: value_by_column(&result.columns, &row, "on_delete"),
+        })
+        .collect())
+}
+
+pub async fn list_triggers(
+    client: &CloudflareD1Client,
+    _schema: &str,
+    table: &str,
+) -> Result<Vec<TriggerInfo>, String> {
+    let result = query_inner(
+        client,
+        &format!(
+            "SELECT name, sql FROM sqlite_master WHERE type = 'trigger' AND tbl_name = {} ORDER BY name",
+            sqlite_string(table)
+        ),
+    )
+    .await?;
+    Ok(result
+        .rows
+        .into_iter()
+        .map(|row| {
+            let statement = value_as_string(row.get(1));
+            let metadata = trigger::metadata_from_sql(statement.as_deref().unwrap_or_default());
+            TriggerInfo {
+                name: value_as_string(row.first()).unwrap_or_default(),
+                event: metadata.event.to_string(),
+                timing: metadata.timing.to_string(),
+                statement,
+            }
+        })
+        .collect())
+}
+
+pub async fn table_ddl(client: &CloudflareD1Client, table: &str) -> Result<String, String> {
+    first_string_cell(
+        query_inner(
+            client,
+            &format!("SELECT sql FROM sqlite_master WHERE type='table' AND name={}", sqlite_string(table)),
+        )
+        .await?,
+    )
+}
+
+pub async fn object_source(
+    client: &CloudflareD1Client,
+    name: &str,
+    object_type: &ObjectSourceKind,
+) -> Result<ObjectSource, String> {
+    let kind = match object_type {
+        ObjectSourceKind::View => "view",
+        _ => return Err("Object source is not supported for this Cloudflare D1 object type".to_string()),
+    };
+    let source = first_string_cell(
+        query_inner(
+            client,
+            &format!(
+                "SELECT sql FROM sqlite_master WHERE type={} AND name={}",
+                sqlite_string(kind),
+                sqlite_string(name)
+            ),
+        )
+        .await?,
+    )?;
+    Ok(ObjectSource { name: name.to_string(), object_type: object_type.clone(), schema: None, source, editable: None })
+}
+
+pub async fn execute_query_with_max_rows(
+    client: &CloudflareD1Client,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<QueryResult, String> {
+    let start = Instant::now();
+    let sql = sql.trim();
+    if sql.is_empty() {
+        return Ok(empty_query_result(start.elapsed().as_millis()));
+    }
+    sql_guard::validate_sql(sql)?;
+    sql_limits::validate_statement_sizes(sql)?;
+    let mut statements = send_raw(client, sql).await?;
+    let affected_rows: u64 = statements.iter().filter_map(|statement| statement.meta.changes).sum();
+    let display = statements.pop().unwrap_or_default();
+    Ok(query_result(display.results, affected_rows, start.elapsed().as_millis(), max_rows))
+}
+
+async fn query_inner(client: &CloudflareD1Client, sql: &str) -> Result<D1RawResult, String> {
+    send_raw(client, sql)
+        .await?
+        .into_iter()
+        .next()
+        .map(|statement| statement.results)
+        .ok_or_else(|| "Cloudflare D1 returned no result".to_string())
+}
+
+async fn send_raw(client: &CloudflareD1Client, sql: &str) -> Result<Vec<D1StatementResult>, String> {
+    let response =
+        client.post_raw(sql).send().await.map_err(|error| format!("Cloudflare D1 request failed: {error}"))?;
+    let status = response.status();
+    let body = response.text().await.map_err(|error| format!("Cloudflare D1 response read failed: {error}"))?;
+    let parsed: D1ApiResponse = serde_json::from_str(&body)
+        .map_err(|error| format!("Cloudflare D1 response parse failed: {error}; body: {}", response_excerpt(&body)))?;
+    if !status.is_success() || parsed.success == Some(false) {
+        return Err(format_d1_error(status.as_u16(), &parsed.errors, &body));
+    }
+    if parsed.result.iter().any(|result| result.success == Some(false)) {
+        return Err(format_d1_error(status.as_u16(), &parsed.errors, &body));
+    }
+    if parsed.result.is_empty() {
+        return Err("Cloudflare D1 returned no statement results".to_string());
+    }
+    Ok(parsed.result)
+}
+
+fn query_result(
+    mut result: D1RawResult,
+    affected_rows: u64,
+    execution_time_ms: u128,
+    max_rows: Option<usize>,
+) -> QueryResult {
+    result.rows = result.rows.into_iter().map(|row| row.into_iter().map(json_value_for_js).collect()).collect();
+    let row_limit = max_rows.unwrap_or(crate::query::MAX_ROWS).max(1);
+    let truncated = result.rows.len() > row_limit;
+    if truncated {
+        result.rows.truncate(row_limit);
+    }
+    QueryResult {
+        columns: result.columns,
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: result.rows,
+        affected_rows,
+        execution_time_ms,
+        truncated,
+        session_id: None,
+        has_more: false,
+    }
+}
+
+fn empty_query_result(execution_time_ms: u128) -> QueryResult {
+    query_result(D1RawResult::default(), 0, execution_time_ms, None)
+}
+
+fn format_d1_error(status: u16, errors: &[D1ApiError], body: &str) -> String {
+    let details = errors
+        .iter()
+        .map(|error| match error.code {
+            Some(code) => format!("{} ({code})", error.message),
+            None => error.message.clone(),
+        })
+        .collect::<Vec<_>>()
+        .join("; ");
+    if details.is_empty() {
+        format!("Cloudflare D1 API error ({status}): {}", response_excerpt(body))
+    } else {
+        format!("Cloudflare D1 API error ({status}): {details}")
+    }
+}
+
+fn response_excerpt(body: &str) -> String {
+    const MAX_CHARS: usize = 1_000;
+    let mut excerpt = body.chars().take(MAX_CHARS).collect::<String>();
+    if body.chars().count() > MAX_CHARS {
+        excerpt.push('…');
+    }
+    excerpt
+}
+
+fn required_field<'a>(value: &'a str, label: &str) -> Result<&'a str, String> {
+    let value = value.trim();
+    if value.is_empty() {
+        Err(format!("{label} is required"))
+    } else {
+        Ok(value)
+    }
+}
+
+fn required_identifier<'a>(value: &'a str, label: &str) -> Result<&'a str, String> {
+    let value = required_field(value, label)?;
+    if value.chars().all(|character| character.is_ascii_alphanumeric() || character == '-' || character == '_') {
+        Ok(value)
+    } else {
+        Err(format!("{label} contains invalid characters"))
+    }
+}
+
+fn first_string_cell(result: D1RawResult) -> Result<String, String> {
+    result
+        .rows
+        .first()
+        .and_then(|row| row.first())
+        .and_then(|value| value_as_string(Some(value)))
+        .ok_or_else(|| "Object not found".to_string())
+}
+
+fn value_by_column(columns: &[String], row: &[serde_json::Value], name: &str) -> Option<String> {
+    columns
+        .iter()
+        .position(|column| column.eq_ignore_ascii_case(name))
+        .and_then(|index| row.get(index))
+        .and_then(|value| value_as_string(Some(value)))
+}
+
+fn value_as_string(value: Option<&serde_json::Value>) -> Option<String> {
+    match value? {
+        serde_json::Value::Null => None,
+        serde_json::Value::String(value) => Some(value.clone()),
+        serde_json::Value::Number(value) => Some(value.to_string()),
+        serde_json::Value::Bool(value) => Some(value.to_string()),
+        other => Some(other.to_string()),
+    }
+}
+
+fn sqlite_ident(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+fn sqlite_string(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+    #[test]
+    fn validates_required_connection_fields() {
+        let timeout = Duration::from_secs(1);
+        assert!(CloudflareD1Client::new("", "database", "token", timeout).err().unwrap().contains("Account ID"));
+        assert!(CloudflareD1Client::new("account", "", "token", timeout).err().unwrap().contains("Database ID"));
+        assert!(CloudflareD1Client::new("account", "database", "", timeout).err().unwrap().contains("API Token"));
+        assert!(CloudflareD1Client::new("account/path", "database", "token", timeout)
+            .err()
+            .unwrap()
+            .contains("invalid characters"));
+    }
+
+    #[test]
+    fn parses_raw_api_response() {
+        let response: D1ApiResponse = serde_json::from_value(serde_json::json!({
+            "success": true,
+            "errors": [],
+            "result": [{
+                "success": true,
+                "results": { "columns": ["id", "name"], "rows": [[1, "Ada"]] },
+                "meta": { "changes": 0 }
+            }]
+        }))
+        .unwrap();
+        assert_eq!(response.success, Some(true));
+        assert_eq!(response.result[0].results.columns, ["id", "name"]);
+        assert_eq!(response.result[0].results.rows[0], [serde_json::json!(1), serde_json::json!("Ada")]);
+    }
+
+    #[test]
+    fn converts_and_truncates_query_result() {
+        let raw = D1RawResult {
+            columns: vec!["id".to_string()],
+            rows: vec![vec![serde_json::json!(1)], vec![serde_json::json!(2)]],
+        };
+        let result = query_result(raw, 0, 5, Some(1));
+        assert_eq!(result.rows, vec![vec![serde_json::json!(1)]]);
+        assert!(result.truncated);
+    }
+
+    #[test]
+    fn limits_error_response_excerpts() {
+        let excerpt = response_excerpt(&"x".repeat(1_100));
+        assert_eq!(excerpt.chars().count(), 1_001);
+        assert!(excerpt.ends_with('…'));
+    }
+
+    #[tokio::test]
+    async fn sends_bearer_authenticated_raw_query_and_maps_response() {
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let address = listener.local_addr().unwrap();
+        let server = tokio::spawn(async move {
+            let (mut socket, _) = listener.accept().await.unwrap();
+            let request = read_http_request(&mut socket).await;
+            assert!(request.starts_with("POST /raw HTTP/1.1"));
+            assert!(request.to_ascii_lowercase().contains("authorization: bearer test-token"));
+            assert!(request.contains("\"sql\":\"SELECT 1\""));
+
+            let body = r#"{"success":true,"errors":[],"result":[{"success":true,"results":{"columns":["1"],"rows":[[1]]},"meta":{"changes":0}}]}"#;
+            let response = format!(
+                "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+                body.len(),
+                body
+            );
+            socket.write_all(response.as_bytes()).await.unwrap();
+        });
+
+        let client =
+            CloudflareD1Client::with_endpoint(format!("http://{address}/raw"), "test-token", Duration::from_secs(2))
+                .unwrap();
+        let result = execute_query_with_max_rows(&client, "SELECT 1", None).await.unwrap();
+        assert_eq!(result.columns, ["1"]);
+        assert_eq!(result.rows, vec![vec![serde_json::json!(1)]]);
+        server.await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn lists_tables_and_views_from_sqlite_master() {
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let address = listener.local_addr().unwrap();
+        let server = tokio::spawn(async move {
+            let (mut socket, _) = listener.accept().await.unwrap();
+            let request = read_http_request(&mut socket).await;
+            assert!(request.contains("sqlite_master"));
+            assert!(request.contains("name <> '_cf_KV'"));
+            assert!(!request.contains("d1_%"));
+
+            let body = r#"{"success":true,"errors":[],"result":[{"success":true,"results":{"columns":["name","type"],"rows":[["users","table"],["active_users","view"]]},"meta":{"changes":0}}]}"#;
+            let response = format!(
+                "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+                body.len(),
+                body
+            );
+            socket.write_all(response.as_bytes()).await.unwrap();
+        });
+
+        let client =
+            CloudflareD1Client::with_endpoint(format!("http://{address}/raw"), "test-token", Duration::from_secs(2))
+                .unwrap();
+        let tables = list_tables(&client, "main").await.unwrap();
+        assert_eq!(tables.len(), 2);
+        assert_eq!(tables[0].name, "users");
+        assert_eq!(tables[0].table_type, "BASE TABLE");
+        assert_eq!(tables[1].name, "active_users");
+        assert_eq!(tables[1].table_type, "VIEW");
+        server.await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn lists_generated_columns_from_table_xinfo() {
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let address = listener.local_addr().unwrap();
+        let server = tokio::spawn(async move {
+            let (mut socket, _) = listener.accept().await.unwrap();
+            let request = read_http_request(&mut socket).await;
+            assert!(request.contains("PRAGMA table_xinfo"));
+
+            let body = r#"{"success":true,"errors":[],"result":[{"success":true,"results":{"columns":["cid","name","type","notnull","dflt_value","pk","hidden"],"rows":[[0,"price","INTEGER",1,null,0,0],[1,"tax","INTEGER",0,null,0,2],[2,"total","INTEGER",0,null,0,3]]},"meta":{"changes":0}}]}"#;
+            let response = format!(
+                "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+                body.len(),
+                body
+            );
+            socket.write_all(response.as_bytes()).await.unwrap();
+        });
+
+        let client =
+            CloudflareD1Client::with_endpoint(format!("http://{address}/raw"), "test-token", Duration::from_secs(2))
+                .unwrap();
+        let columns = get_columns(&client, "main", "orders").await.unwrap();
+        assert_eq!(columns.len(), 3);
+        assert_eq!(columns[0].extra, None);
+        assert_eq!(columns[1].extra.as_deref(), Some("generated always as virtual"));
+        assert_eq!(columns[2].extra.as_deref(), Some("generated always as stored"));
+        server.await.unwrap();
+    }
+
+    #[test]
+    fn rejects_oversized_statements_but_allows_large_multi_statement_batches() {
+        let oversized = format!("SELECT '{}'", "x".repeat(MAX_SQL_STATEMENT_BYTES));
+        let error = sql_limits::validate_statement_sizes(&oversized).unwrap_err();
+        assert!(error.contains("statement 1"));
+        assert!(error.contains("100000 bytes"));
+
+        let first = format!("SELECT '{}'", "a".repeat(60_000));
+        let second = format!("SELECT '{}'", "b".repeat(60_000));
+        assert!(sql_limits::validate_statement_sizes(&format!("{first}; {second}")).is_ok());
+
+        let trigger = format!(
+            "CREATE TRIGGER audit AFTER INSERT ON users BEGIN INSERT INTO logs VALUES ('{}'); INSERT INTO logs VALUES ('{}'); END",
+            "a".repeat(60_000),
+            "b".repeat(60_000)
+        );
+        assert!(sql_limits::validate_statement_sizes(&trigger).is_err());
+    }
+
+    async fn read_http_request(socket: &mut tokio::net::TcpStream) -> String {
+        let mut bytes = Vec::new();
+        let mut buffer = [0_u8; 2048];
+        loop {
+            let read = socket.read(&mut buffer).await.unwrap();
+            if read == 0 {
+                break;
+            }
+            bytes.extend_from_slice(&buffer[..read]);
+            let Some(header_end) = bytes.windows(4).position(|window| window == b"\r\n\r\n") else {
+                continue;
+            };
+            let headers = String::from_utf8_lossy(&bytes[..header_end]);
+            let content_length = headers
+                .lines()
+                .find_map(|line| line.split_once(':').filter(|(name, _)| name.eq_ignore_ascii_case("content-length")))
+                .and_then(|(_, value)| value.trim().parse::<usize>().ok())
+                .unwrap_or(0);
+            if bytes.len() >= header_end + 4 + content_length {
+                break;
+            }
+        }
+        String::from_utf8(bytes).unwrap()
+    }
+}
diff --git a/crates/dbx-core/src/db/cloudflare_d1/sql_guard.rs b/crates/dbx-core/src/db/cloudflare_d1/sql_guard.rs
new file mode 100644
index 0000000..8edd3dc
--- /dev/null
+++ b/crates/dbx-core/src/db/cloudflare_d1/sql_guard.rs
@@ -0,0 +1,168 @@
+use super::sql_lexer::{complete_sql_statements, lex_sql, SqlLexeme};
+
+const SUPPORTED_PRAGMAS: &[&str] = &[
+    "case_sensitive_like",
+    "defer_foreign_keys",
+    "foreign_key_check",
+    "foreign_key_list",
+    "foreign_keys",
+    "ignore_check_constraints",
+    "index_info",
+    "index_list",
+    "index_xinfo",
+    "legacy_alter_table",
+    "optimize",
+    "quick_check",
+    "recursive_triggers",
+    "reverse_unordered_selects",
+    "table_info",
+    "table_list",
+    "table_xinfo",
+];
+
+pub(super) fn validate_sql(sql: &str) -> Result<(), String> {
+    for statement in complete_sql_statements(sql) {
+        validate_statement(statement)?;
+    }
+    Ok(())
+}
+
+fn validate_statement(statement: &str) -> Result<(), String> {
+    let lexemes = lex_sql(statement);
+    let words = lexemes
+        .iter()
+        .filter_map(|lexeme| match lexeme {
+            SqlLexeme::Word(word) => Some(*word),
+            SqlLexeme::Number(_) | SqlLexeme::Symbol(_) | SqlLexeme::Semicolon(_) => None,
+        })
+        .collect::<Vec<_>>();
+    let Some(first) = words.first() else {
+        return Ok(());
+    };
+
+    if ["BEGIN", "COMMIT", "END", "ROLLBACK", "SAVEPOINT", "RELEASE", "START"]
+        .iter()
+        .any(|keyword| first.eq_ignore_ascii_case(keyword))
+    {
+        return Err(
+            "Cloudflare D1 does not support explicit transaction or savepoint statements. Submit the SQL statements together without BEGIN, COMMIT, ROLLBACK, SAVEPOINT, or RELEASE."
+                .to_string(),
+        );
+    }
+
+    if first.eq_ignore_ascii_case("ATTACH") || first.eq_ignore_ascii_case("DETACH") {
+        return Err(
+            "Cloudflare D1 does not support ATTACH or DETACH. Each connection targets one provider-managed D1 database."
+                .to_string(),
+        );
+    }
+
+    if first.eq_ignore_ascii_case("CREATE") {
+        validate_create_statement(&words)?;
+    }
+
+    if first.eq_ignore_ascii_case("PRAGMA") {
+        validate_pragma(&words, &lexemes)?;
+    }
+
+    Ok(())
+}
+
+fn validate_create_statement(words: &[&str]) -> Result<(), String> {
+    if words.get(1).is_some_and(|word| word.eq_ignore_ascii_case("TEMP") || word.eq_ignore_ascii_case("TEMPORARY")) {
+        return Err(
+            "Cloudflare D1 does not support temporary tables, indexes, views, or triggers. Create a persistent object instead."
+                .to_string(),
+        );
+    }
+
+    let creates_virtual_table = words
+        .get(1..3)
+        .is_some_and(|prefix| prefix[0].eq_ignore_ascii_case("VIRTUAL") && prefix[1].eq_ignore_ascii_case("TABLE"));
+    if !creates_virtual_table {
+        return Ok(());
+    }
+
+    let module =
+        words.iter().position(|word| word.eq_ignore_ascii_case("USING")).and_then(|index| words.get(index + 1));
+    if module.is_some_and(|module| module.eq_ignore_ascii_case("fts5") || module.eq_ignore_ascii_case("fts5vocab")) {
+        return Ok(());
+    }
+
+    Err("Cloudflare D1 only supports FTS5 and fts5vocab virtual table modules.".to_string())
+}
+
+fn validate_pragma(words: &[&str], lexemes: &[SqlLexeme<'_>]) -> Result<(), String> {
+    let mut pragma = words.get(1).copied();
+    if pragma.is_some_and(|word| word.eq_ignore_ascii_case("main") || word.eq_ignore_ascii_case("temp")) {
+        pragma = words.get(2).copied();
+    }
+    let Some(pragma) = pragma else {
+        return Err("Cloudflare D1 requires a supported PRAGMA name.".to_string());
+    };
+
+    if !SUPPORTED_PRAGMAS.iter().any(|supported| pragma.eq_ignore_ascii_case(supported)) {
+        return Err(format!(
+            "Cloudflare D1 does not support PRAGMA {pragma}. Use one of the documented D1-compatible PRAGMA statements."
+        ));
+    }
+
+    if pragma.eq_ignore_ascii_case("optimize") && contains_negative_one(lexemes) {
+        return Err("Cloudflare D1 does not support PRAGMA optimize(-1); use PRAGMA optimize instead.".to_string());
+    }
+
+    Ok(())
+}
+
+fn contains_negative_one(lexemes: &[SqlLexeme<'_>]) -> bool {
+    lexemes
+        .windows(2)
+        .any(|pair| matches!(pair[0], SqlLexeme::Symbol(b'-')) && matches!(pair[1], SqlLexeme::Number("1")))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn accepts_supported_d1_sql_features() {
+        assert!(validate_sql(
+            "CREATE TRIGGER audit AFTER INSERT ON users BEGIN INSERT INTO logs VALUES (NEW.id); END;"
+        )
+        .is_ok());
+        assert!(
+            validate_sql("CREATE VIRTUAL TABLE docs USING fts5(title, body); SELECT json_extract('{}', '$');").is_ok()
+        );
+        assert!(validate_sql("PRAGMA table_info(users); PRAGMA optimize;").is_ok());
+    }
+
+    #[test]
+    fn rejects_explicit_transaction_control() {
+        for sql in [
+            "BEGIN; INSERT INTO users VALUES (1); COMMIT;",
+            "SAVEPOINT before_update",
+            "ROLLBACK TO before_update",
+            "RELEASE before_update",
+        ] {
+            let error = validate_sql(sql).unwrap_err();
+            assert!(error.contains("does not support explicit transaction"));
+        }
+    }
+
+    #[test]
+    fn rejects_attached_temporary_and_unknown_virtual_databases() {
+        assert!(validate_sql("ATTACH DATABASE 'other.db' AS other").unwrap_err().contains("ATTACH"));
+        assert!(validate_sql("CREATE TEMP TABLE scratch(id INTEGER)").unwrap_err().contains("temporary"));
+        assert!(validate_sql("CREATE VIRTUAL TABLE places USING rtree(id, min_x, max_x)")
+            .unwrap_err()
+            .contains("only supports FTS5"));
+    }
+
+    #[test]
+    fn rejects_unsupported_pragma_forms() {
+        assert!(validate_sql("PRAGMA journal_mode=WAL").unwrap_err().contains("PRAGMA journal_mode"));
+        assert!(validate_sql("PRAGMA data_version").unwrap_err().contains("PRAGMA data_version"));
+        assert!(validate_sql("PRAGMA optimize(-1)").unwrap_err().contains("optimize(-1)"));
+        assert!(validate_sql("PRAGMA optimize /* -1 is only a comment */").is_ok());
+    }
+}
diff --git a/crates/dbx-core/src/db/cloudflare_d1/sql_lexer.rs b/crates/dbx-core/src/db/cloudflare_d1/sql_lexer.rs
new file mode 100644
index 0000000..e4a66a2
--- /dev/null
+++ b/crates/dbx-core/src/db/cloudflare_d1/sql_lexer.rs
@@ -0,0 +1,180 @@
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub(super) enum SqlLexeme<'a> {
+    Word(&'a str),
+    Number(&'a str),
+    Symbol(u8),
+    Semicolon(usize),
+}
+
+pub(super) fn lex_sql(sql: &str) -> Vec<SqlLexeme<'_>> {
+    let bytes = sql.as_bytes();
+    let mut lexemes = Vec::new();
+    let mut index = 0;
+
+    while index < bytes.len() {
+        match bytes[index] {
+            b'-' if bytes.get(index + 1) == Some(&b'-') => {
+                index += 2;
+                while index < bytes.len() && bytes[index] != b'\n' {
+                    index += 1;
+                }
+            }
+            b'/' if bytes.get(index + 1) == Some(&b'*') => {
+                index += 2;
+                while index + 1 < bytes.len() && !(bytes[index] == b'*' && bytes[index + 1] == b'/') {
+                    index += 1;
+                }
+                index = (index + 2).min(bytes.len());
+            }
+            quote @ (b'\'' | b'"' | b'`') => {
+                index += 1;
+                while index < bytes.len() {
+                    if bytes[index] != quote {
+                        index += 1;
+                        continue;
+                    }
+                    if bytes.get(index + 1) == Some(&quote) {
+                        index += 2;
+                    } else {
+                        index += 1;
+                        break;
+                    }
+                }
+            }
+            b'[' => {
+                index += 1;
+                while index < bytes.len() {
+                    if bytes[index] != b']' {
+                        index += 1;
+                        continue;
+                    }
+                    if bytes.get(index + 1) == Some(&b']') {
+                        index += 2;
+                    } else {
+                        index += 1;
+                        break;
+                    }
+                }
+            }
+            b';' => {
+                lexemes.push(SqlLexeme::Semicolon(index));
+                index += 1;
+            }
+            byte if byte.is_ascii_digit() => {
+                let start = index;
+                index += 1;
+                while index < bytes.len() && bytes[index].is_ascii_digit() {
+                    index += 1;
+                }
+                lexemes.push(SqlLexeme::Number(&sql[start..index]));
+            }
+            byte if byte.is_ascii_alphabetic() || byte == b'_' => {
+                let start = index;
+                index += 1;
+                while index < bytes.len()
+                    && (bytes[index].is_ascii_alphanumeric() || matches!(bytes[index], b'_' | b'$'))
+                {
+                    index += 1;
+                }
+                lexemes.push(SqlLexeme::Word(&sql[start..index]));
+            }
+            byte if matches!(byte, b'(' | b')' | b'=' | b'.' | b',' | b'-' | b'+') => {
+                lexemes.push(SqlLexeme::Symbol(byte));
+                index += 1;
+            }
+            _ => index += 1,
+        }
+    }
+
+    lexemes
+}
+
+pub(super) fn complete_sql_statements(sql: &str) -> Vec<&str> {
+    let mut statements = Vec::new();
+    let mut statement_start = 0;
+    let mut prefix = Vec::with_capacity(3);
+    let mut is_trigger = false;
+    let mut trigger_body_started = false;
+    let mut trigger_depth = 0_usize;
+
+    for lexeme in lex_sql(sql) {
+        match lexeme {
+            SqlLexeme::Word(word) => {
+                if prefix.len() < 3 {
+                    prefix.push(word);
+                    is_trigger = is_create_trigger_prefix(&prefix);
+                }
+
+                if !is_trigger {
+                    continue;
+                }
+                if !trigger_body_started && word.eq_ignore_ascii_case("BEGIN") {
+                    trigger_body_started = true;
+                    trigger_depth = 1;
+                } else if trigger_body_started
+                    && (word.eq_ignore_ascii_case("BEGIN") || word.eq_ignore_ascii_case("CASE"))
+                {
+                    trigger_depth += 1;
+                } else if trigger_body_started && word.eq_ignore_ascii_case("END") {
+                    trigger_depth = trigger_depth.saturating_sub(1);
+                }
+            }
+            SqlLexeme::Semicolon(position) => {
+                if is_trigger && trigger_body_started && trigger_depth > 0 {
+                    continue;
+                }
+                push_statement(sql, statement_start, position, &mut statements);
+                statement_start = position + 1;
+                prefix.clear();
+                is_trigger = false;
+                trigger_body_started = false;
+                trigger_depth = 0;
+            }
+            SqlLexeme::Number(_) | SqlLexeme::Symbol(_) => {}
+        }
+    }
+
+    push_statement(sql, statement_start, sql.len(), &mut statements);
+    statements
+}
+
+fn is_create_trigger_prefix(words: &[&str]) -> bool {
+    words.first().is_some_and(|word| word.eq_ignore_ascii_case("CREATE"))
+        && (words.get(1).is_some_and(|word| word.eq_ignore_ascii_case("TRIGGER"))
+            || (words
+                .get(1)
+                .is_some_and(|word| word.eq_ignore_ascii_case("TEMP") || word.eq_ignore_ascii_case("TEMPORARY"))
+                && words.get(2).is_some_and(|word| word.eq_ignore_ascii_case("TRIGGER"))))
+}
+
+fn push_statement<'a>(sql: &'a str, start: usize, end: usize, statements: &mut Vec<&'a str>) {
+    let statement = sql[start..end].trim();
+    if !statement.is_empty() {
+        statements.push(statement);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn keeps_trigger_body_semicolons_in_one_statement() {
+        let sql = "CREATE TRIGGER audit AFTER UPDATE ON users BEGIN INSERT INTO logs VALUES ('a;b'); UPDATE stats SET value = CASE WHEN value > 0 THEN value ELSE 0 END; END; SELECT 1;";
+        let statements = complete_sql_statements(sql);
+
+        assert_eq!(statements.len(), 2);
+        assert!(statements[0].starts_with("CREATE TRIGGER"));
+        assert!(statements[0].ends_with("END"));
+        assert_eq!(statements[1], "SELECT 1");
+    }
+
+    #[test]
+    fn ignores_trigger_words_in_comments_and_strings() {
+        let sql = "SELECT 'CREATE TRIGGER fake; BEGIN END'; -- CREATE TRIGGER ignored\nSELECT 2;";
+        assert_eq!(
+            complete_sql_statements(sql),
+            ["SELECT 'CREATE TRIGGER fake; BEGIN END'", "-- CREATE TRIGGER ignored\nSELECT 2"]
+        );
+    }
+}
diff --git a/crates/dbx-core/src/db/cloudflare_d1/sql_limits.rs b/crates/dbx-core/src/db/cloudflare_d1/sql_limits.rs
new file mode 100644
index 0000000..c623e8b
--- /dev/null
+++ b/crates/dbx-core/src/db/cloudflare_d1/sql_limits.rs
@@ -0,0 +1,115 @@
+use std::ops::Range;
+
+pub const MAX_SQL_STATEMENT_BYTES: usize = 100_000;
+
+#[derive(Debug, PartialEq, Eq)]
+pub(super) struct SqlBatch {
+    pub sql: String,
+    pub item_count: usize,
+}
+
+pub(super) fn build_sql_batches<F>(
+    item_count: usize,
+    max_items: usize,
+    item_label: &str,
+    render: F,
+) -> Result<Vec<SqlBatch>, String>
+where
+    F: Fn(Range<usize>) -> String,
+{
+    let mut batches = Vec::new();
+    let mut start = 0;
+    let max_items = max_items.max(1);
+
+    while start < item_count {
+        let mut end = start + 1;
+        let mut accepted = render(start..end);
+        if accepted.len() > MAX_SQL_STATEMENT_BYTES {
+            return Err(format!(
+                "Cloudflare D1 {item_label} {} generates a {}-byte SQL statement; the maximum is {MAX_SQL_STATEMENT_BYTES} bytes. Reduce the value size because a single item cannot be split safely.",
+                start + 1,
+                accepted.len()
+            ));
+        }
+
+        while end < item_count && end - start < max_items {
+            let candidate = render(start..end + 1);
+            if candidate.len() > MAX_SQL_STATEMENT_BYTES {
+                break;
+            }
+            accepted = candidate;
+            end += 1;
+        }
+
+        if !accepted.trim().is_empty() {
+            batches.push(SqlBatch { sql: accepted, item_count: end - start });
+        }
+        start = end;
+    }
+
+    Ok(batches)
+}
+
+pub(super) fn validate_statement_sizes(sql: &str) -> Result<(), String> {
+    let statements = super::sql_lexer::complete_sql_statements(sql);
+    for (index, statement) in statements.iter().enumerate() {
+        if statement.len() > MAX_SQL_STATEMENT_BYTES {
+            return Err(statement_size_error(index + 1, statement.len()));
+        }
+    }
+    Ok(())
+}
+
+fn statement_size_error(index: usize, byte_len: usize) -> String {
+    format!(
+        "Cloudflare D1 SQL statement {index} is {byte_len} bytes; the maximum is {MAX_SQL_STATEMENT_BYTES} bytes. Split the statement or reduce the batch/value size."
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn splits_utf8_sql_batches_by_bytes() {
+        let rows = ["你".repeat(20_000), "好".repeat(20_000)];
+        let batches = build_sql_batches(rows.len(), 100, "import row", |range| {
+            format!("INSERT INTO events VALUES ('{}')", rows[range].join("'), ('"))
+        })
+        .unwrap();
+
+        assert_eq!(batches.len(), 2);
+        assert!(batches.iter().all(|batch| batch.sql.len() <= MAX_SQL_STATEMENT_BYTES));
+    }
+
+    #[test]
+    fn rejects_a_single_oversized_item() {
+        let error = build_sql_batches(1, 100, "import row", |_| {
+            format!("INSERT INTO events VALUES ('{}')", "x".repeat(MAX_SQL_STATEMENT_BYTES))
+        })
+        .unwrap_err();
+
+        assert!(error.contains("import row 1"));
+        assert!(error.contains("maximum is 100000 bytes"));
+    }
+
+    #[test]
+    fn validates_trigger_and_other_batch_statements_individually() {
+        let trigger = "CREATE TRIGGER audit AFTER UPDATE ON users BEGIN INSERT INTO logs VALUES (NEW.id); END";
+        let first = format!("SELECT '{}'", "a".repeat(60_000));
+        let second = format!("SELECT '{}'", "b".repeat(60_000));
+
+        assert!(validate_statement_sizes(&format!("{trigger}; {first}; {second}")).is_ok());
+    }
+
+    #[test]
+    fn rejects_an_oversized_complete_trigger_statement() {
+        let trigger = format!(
+            "CREATE TRIGGER audit AFTER UPDATE ON users BEGIN INSERT INTO logs VALUES ('{}'); INSERT INTO logs VALUES ('{}'); END",
+            "a".repeat(60_000),
+            "b".repeat(60_000)
+        );
+
+        assert!(validate_statement_sizes(&trigger).is_err());
+    }
+}
diff --git a/crates/dbx-core/src/db/cloudflare_d1/transfer_tests.rs b/crates/dbx-core/src/db/cloudflare_d1/transfer_tests.rs
new file mode 100644
index 0000000..a1d56c1
--- /dev/null
+++ b/crates/dbx-core/src/db/cloudflare_d1/transfer_tests.rs
@@ -0,0 +1,19 @@
+use serde_json::json;
+
+use crate::models::connection::DatabaseType;
+use crate::transfer::generate_upsert_typed;
+
+#[test]
+fn uses_sqlite_upsert_syntax() {
+    let sql = generate_upsert_typed(
+        &[String::from("id"), String::from("name")],
+        &[Some(String::from("integer")), Some(String::from("text"))],
+        &[vec![json!(1), json!("Ada")]],
+        "users",
+        "main",
+        &DatabaseType::CloudflareD1,
+        &[String::from("id")],
+    );
+
+    assert!(sql.contains("ON CONFLICT (\"id\") DO UPDATE SET"));
+}
diff --git a/crates/dbx-core/src/db/cloudflare_d1/trigger.rs b/crates/dbx-core/src/db/cloudflare_d1/trigger.rs
new file mode 100644
index 0000000..4d72853
--- /dev/null
+++ b/crates/dbx-core/src/db/cloudflare_d1/trigger.rs
@@ -0,0 +1,71 @@
+use super::sql_lexer::{lex_sql, SqlLexeme};
+
+pub(super) struct TriggerMetadata {
+    pub timing: &'static str,
+    pub event: &'static str,
+}
+
+pub(super) fn metadata_from_sql(sql: &str) -> TriggerMetadata {
+    let words = lex_sql(sql)
+        .into_iter()
+        .filter_map(|lexeme| match lexeme {
+            SqlLexeme::Word(word) => Some(word),
+            SqlLexeme::Number(_) | SqlLexeme::Symbol(_) | SqlLexeme::Semicolon(_) => None,
+        })
+        .collect::<Vec<_>>();
+    let declaration_start =
+        words.iter().position(|word| word.eq_ignore_ascii_case("TRIGGER")).map_or(0, |index| index + 1);
+    let declaration_end = words[declaration_start..]
+        .iter()
+        .position(|word| word.eq_ignore_ascii_case("ON") || word.eq_ignore_ascii_case("BEGIN"))
+        .map_or(words.len(), |index| declaration_start + index);
+    let declaration = &words[declaration_start..declaration_end];
+
+    let timing = if declaration
+        .windows(2)
+        .any(|words| words[0].eq_ignore_ascii_case("INSTEAD") && words[1].eq_ignore_ascii_case("OF"))
+    {
+        "INSTEAD OF"
+    } else if declaration.iter().any(|word| word.eq_ignore_ascii_case("AFTER")) {
+        "AFTER"
+    } else {
+        // SQLite defaults to BEFORE when no timing keyword is present.
+        "BEFORE"
+    };
+    let event = declaration
+        .iter()
+        .find_map(|word| ["DELETE", "INSERT", "UPDATE"].into_iter().find(|event| word.eq_ignore_ascii_case(event)))
+        .unwrap_or("UNKNOWN");
+
+    TriggerMetadata { timing, event }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn reads_event_from_declaration_not_trigger_body() {
+        let metadata = metadata_from_sql(
+            "CREATE TRIGGER audit AFTER UPDATE ON users BEGIN INSERT INTO audit_log VALUES (NEW.id); END",
+        );
+
+        assert_eq!(metadata.timing, "AFTER");
+        assert_eq!(metadata.event, "UPDATE");
+    }
+
+    #[test]
+    fn supports_default_and_instead_of_timing() {
+        let default_timing = metadata_from_sql(
+            "CREATE TRIGGER update_customer UPDATE OF name ON customers BEGIN DELETE FROM cache; END",
+        );
+        let instead_of = metadata_from_sql(
+            "CREATE TRIGGER [insert] INSTEAD OF INSERT ON customer_view BEGIN UPDATE customers SET name = NEW.name; END",
+        );
+
+        assert_eq!(default_timing.timing, "BEFORE");
+        assert_eq!(default_timing.event, "UPDATE");
+        assert_eq!(instead_of.timing, "INSTEAD OF");
+        assert_eq!(instead_of.event, "INSERT");
+    }
+}
diff --git a/crates/dbx-core/src/db/duckdb_driver.rs b/crates/dbx-core/src/db/duckdb_driver.rs
new file mode 100644
index 0000000..2da89c8
--- /dev/null
+++ b/crates/dbx-core/src/db/duckdb_driver.rs
@@ -0,0 +1,171 @@
+#![cfg(feature = "duckdb-bundled")]
+
+use std::fs;
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::sync::Mutex;
+
+pub struct DuckDbConnection {
+    connection: Mutex<duckdb::Connection>,
+    interrupt_handle: Arc<duckdb::InterruptHandle>,
+    draining: AtomicBool,
+}
+
+impl DuckDbConnection {
+    pub fn new(connection: duckdb::Connection) -> Self {
+        let interrupt_handle = connection.interrupt_handle();
+        Self { connection: Mutex::new(connection), interrupt_handle, draining: AtomicBool::new(false) }
+    }
+
+    pub fn lock(&self) -> std::sync::LockResult<std::sync::MutexGuard<'_, duckdb::Connection>> {
+        self.connection.lock()
+    }
+
+    pub fn interrupt_handle(&self) -> Arc<duckdb::InterruptHandle> {
+        self.interrupt_handle.clone()
+    }
+
+    pub fn mark_draining(&self) {
+        self.draining.store(true, Ordering::SeqCst);
+    }
+
+    pub fn clear_draining(&self) {
+        self.draining.store(false, Ordering::SeqCst);
+    }
+
+    pub fn is_draining(&self) -> bool {
+        self.draining.load(Ordering::SeqCst)
+    }
+
+    fn into_inner(self) -> std::sync::LockResult<duckdb::Connection> {
+        self.connection.into_inner()
+    }
+}
+
+/// Connects to a DuckDb database file with file validation.
+///
+/// # Arguments
+/// * `path` - The file path to the DuckDb database
+///
+/// # Returns
+/// * `Ok(Arc<DuckDbConnection>)` on successful connection
+/// * `Err(String)` with descriptive error message if connection fails
+pub fn connect_path(path: &str) -> Result<Arc<DuckDbConnection>, String> {
+    let is_memory = is_memory_database_path(path);
+    if !is_memory {
+        validate_duckdb_path(path)?;
+        remove_empty_placeholder_file(path)?;
+    }
+
+    let connection = if is_memory { duckdb::Connection::open_in_memory() } else { duckdb::Connection::open(path) }
+        .map_err(|e| format!("DuckDb connection failed: {e}"))?;
+
+    Ok(Arc::new(DuckDbConnection::new(connection)))
+}
+
+fn validate_duckdb_path(path: &str) -> Result<(), String> {
+    if path.is_empty() {
+        return Err("Database file path cannot be empty".to_string());
+    }
+    if path.contains('\0') {
+        return Err("Database file path contains null characters".to_string());
+    }
+    if is_network_path(path) {
+        return Ok(());
+    }
+    let path_obj = Path::new(path);
+    if path_obj.is_dir() {
+        return Err(format!("Database file path is a directory, not a file: {}", path));
+    }
+    if !path_obj.exists() {
+        // DuckDB creates a new database file on open when the parent directory
+        // exists. Only reject paths whose parent directory is missing.
+        if let Some(parent) = path_obj.parent() {
+            if !parent.as_os_str().is_empty() && !parent.exists() {
+                return Err(format!("Parent directory does not exist: {}", parent.display()));
+            }
+        }
+    }
+    Ok(())
+}
+
+fn remove_empty_placeholder_file(path: &str) -> Result<(), String> {
+    let path_obj = Path::new(path);
+    if is_network_path(path) || !path_obj.exists() {
+        return Ok(());
+    }
+
+    let metadata = fs::metadata(path_obj).map_err(|e| format!("Failed to read database file metadata: {e}"))?;
+    if metadata.is_file() && metadata.len() == 0 {
+        fs::remove_file(path_obj).map_err(|e| format!("Failed to replace empty DuckDB placeholder file: {e}"))?;
+    }
+    Ok(())
+}
+
+fn is_network_path(path: &str) -> bool {
+    path.starts_with("\\\\") || path.starts_with("//") || path.contains("wsl.localhost") || path.contains("wsl$")
+}
+
+pub fn is_memory_database_path(path: &str) -> bool {
+    path.trim().eq_ignore_ascii_case(":memory:")
+}
+
+/// Closes a DuckDB connection, releasing the file lock.
+///
+/// Unlike relying on Drop, this calls `duckdb_disconnect` synchronously
+/// so the file handle is released before this function returns.
+/// On Windows this prevents "file already in use" errors when reconnecting.
+pub fn close_connection(con: Arc<DuckDbConnection>) {
+    match Arc::try_unwrap(con) {
+        Ok(handle) => match handle.into_inner() {
+            Ok(conn) => {
+                let _ = conn.close();
+            }
+            Err(poisoned) => {
+                let _ = poisoned.into_inner().close();
+            }
+        },
+        Err(_) => {
+            // Arc still referenced elsewhere (e.g. running queries);
+            // the last holder will drop and close the connection.
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn connect_path_supports_memory_database() {
+        let con = connect_path(":memory:").expect("connect in-memory DuckDB");
+        let locked = con.lock().expect("lock connection");
+
+        locked.execute_batch("CREATE TABLE memory_probe AS SELECT 42 AS id;").expect("create table");
+        let value: i32 = locked.query_row("SELECT id FROM memory_probe;", [], |row| row.get(0)).expect("select row");
+
+        assert_eq!(value, 42);
+    }
+
+    #[test]
+    fn interrupt_handle_is_available_while_connection_is_locked() {
+        let con = connect_path(":memory:").expect("connect in-memory DuckDB");
+        let _locked = con.lock().expect("lock connection");
+
+        let _interrupt_handle = con.interrupt_handle();
+    }
+
+    #[test]
+    fn connect_path_replaces_empty_placeholder_file() {
+        let path = std::env::temp_dir().join(format!("dbx-duckdb-empty-{}.duckdb", uuid::Uuid::new_v4()));
+        std::fs::write(&path, "").expect("write empty placeholder");
+        assert_eq!(std::fs::metadata(&path).expect("placeholder metadata").len(), 0);
+
+        let con = connect_path(path.to_string_lossy().as_ref()).expect("connect empty placeholder DuckDB file");
+        close_connection(con);
+
+        assert!(std::fs::metadata(&path).expect("database metadata").len() > 0);
+        let _ = std::fs::remove_file(path);
+    }
+}
diff --git a/crates/dbx-core/src/db/duckdb_worker_process.rs b/crates/dbx-core/src/db/duckdb_worker_process.rs
new file mode 100644
index 0000000..5a0db9c
--- /dev/null
+++ b/crates/dbx-core/src/db/duckdb_worker_process.rs
@@ -0,0 +1,620 @@
+#![cfg(feature = "duckdb-bundled")]
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::process::Stdio;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex as StdMutex, OnceLock};
+use std::time::Duration;
+
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::process::{Child, ChildStdin};
+use tokio::sync::{oneshot, Mutex, OwnedSemaphorePermit, Semaphore};
+use tokio_util::sync::CancellationToken;
+
+use crate::db;
+use crate::db::duckdb_worker_protocol::{
+    DuckDbWorkerConnectParams, DuckDbWorkerError, DuckDbWorkerExecuteParams, DuckDbWorkerMethod, DuckDbWorkerRequest,
+    DuckDbWorkerResponse,
+};
+use crate::models::connection::AttachedDatabaseConfig;
+use crate::storage::{normalize_duckdb_worker_max_processes, DUCKDB_WORKER_MAX_PROCESSES_DEFAULT};
+
+/// Error code the worker reports when a query error left the DuckDB connection poisoned
+/// (see the duckdb-rs Parser Error bug). The client kills the worker on this code so the
+/// next request starts a fresh one. Must match the code emitted in `duckdb_worker_runtime`.
+const DUCKDB_WORKER_POISONED_CODE: &str = "duckdb_worker_poisoned";
+const DUCKDB_WORKER_REQUEST_TIMEOUT_CODE: &str = "duckdb_worker_request_timeout";
+const DEFAULT_WORKER_REQUEST_TIMEOUT: Duration = Duration::from_secs(60);
+const DEFAULT_WORKER_KILL_WAIT: Duration = Duration::from_secs(3);
+const DEFAULT_WORKER_START_WAIT: Duration = Duration::from_secs(5);
+type PendingRequests = Arc<Mutex<HashMap<String, PendingRequest>>>;
+
+struct PendingRequest {
+    generation: u64,
+    sender: oneshot::Sender<DuckDbWorkerResponse>,
+}
+
+#[derive(Clone)]
+pub struct DuckDbWorkerClient {
+    inner: Arc<DuckDbWorkerClientInner>,
+}
+
+struct DuckDbWorkerClientInner {
+    state: Mutex<WorkerProcessState>,
+    pending: PendingRequests,
+    connect_lock: Mutex<()>,
+    query_lock: Mutex<()>,
+    process_limiter: Arc<Semaphore>,
+    process_limit: usize,
+    executable: PathBuf,
+    connect_params: DuckDbWorkerConnectParams,
+    request_timeout: Duration,
+    worker_start_timeout: Duration,
+    next_id: AtomicU64,
+}
+
+#[derive(Default)]
+struct WorkerProcessState {
+    child: Option<Child>,
+    stdin: Option<ChildStdin>,
+    connected: bool,
+    generation: u64,
+}
+
+impl DuckDbWorkerClient {
+    pub async fn open(path: String, attached_databases: Vec<AttachedDatabaseConfig>) -> Result<Self, String> {
+        let executable = std::env::current_exe().map_err(|e| e.to_string())?;
+        Self::open_with_executable(executable, path, attached_databases).await
+    }
+
+    pub async fn open_with_process_limit(
+        path: String,
+        attached_databases: Vec<AttachedDatabaseConfig>,
+        process_limit: usize,
+    ) -> Result<Self, String> {
+        let executable = std::env::current_exe().map_err(|e| e.to_string())?;
+        Self::open_with_executable_and_process_limit(executable, path, attached_databases, process_limit).await
+    }
+
+    pub async fn open_with_executable(
+        executable: PathBuf,
+        path: String,
+        attached_databases: Vec<AttachedDatabaseConfig>,
+    ) -> Result<Self, String> {
+        Self::open_with_executable_and_process_limit(
+            executable,
+            path,
+            attached_databases,
+            DUCKDB_WORKER_MAX_PROCESSES_DEFAULT,
+        )
+        .await
+    }
+
+    pub async fn open_with_executable_and_process_limit(
+        executable: PathBuf,
+        path: String,
+        attached_databases: Vec<AttachedDatabaseConfig>,
+        process_limit: usize,
+    ) -> Result<Self, String> {
+        let client = Self::new_unconnected_with_timeouts(
+            executable,
+            path,
+            attached_databases,
+            process_limit,
+            DEFAULT_WORKER_REQUEST_TIMEOUT,
+            DEFAULT_WORKER_START_WAIT,
+        );
+        client.ensure_connected().await?;
+        Ok(client)
+    }
+
+    #[doc(hidden)]
+    pub fn new_unconnected_with_timeouts(
+        executable: PathBuf,
+        path: String,
+        attached_databases: Vec<AttachedDatabaseConfig>,
+        process_limit: usize,
+        request_timeout: Duration,
+        worker_start_timeout: Duration,
+    ) -> Self {
+        let (process_limiter, process_limit) = duckdb_worker_process_limiter(process_limit);
+        Self {
+            inner: Arc::new(DuckDbWorkerClientInner {
+                state: Mutex::new(WorkerProcessState::default()),
+                pending: Arc::new(Mutex::new(HashMap::new())),
+                connect_lock: Mutex::new(()),
+                query_lock: Mutex::new(()),
+                process_limiter,
+                process_limit,
+                executable,
+                connect_params: DuckDbWorkerConnectParams { path, attached_databases },
+                request_timeout,
+                worker_start_timeout,
+                next_id: AtomicU64::new(1),
+            }),
+        }
+    }
+
+    pub async fn execute(
+        &self,
+        database: Option<String>,
+        sql: String,
+        max_rows: Option<usize>,
+        cancel_token: Option<CancellationToken>,
+        query_timeout: Option<Duration>,
+    ) -> Result<db::QueryResult, String> {
+        let _query_guard = self.inner.query_lock.lock().await;
+        let client = self.clone();
+        // Cancellation and timeout restart the worker via cancel_or_kill below. An ordinary
+        // query error (parser/binder/catalog/runtime) leaves the worker healthy, so we keep it
+        // alive to preserve session-local state (:memory: contents, temp tables, SET, raw ATTACH).
+        // The one exception is a poisoned connection: duckdb-rs can leave the connection unusable
+        // after a syntax Parser Error, and the worker reports that with `duckdb_worker_poisoned`.
+        // We kill on that code so the next request restarts a fresh worker. Killing here (rather
+        // than letting the worker self-exit) avoids racing our own next request against a dying
+        // worker, and OS-level kill never runs the destructor that would abort the process.
+        let future = async move {
+            client.ensure_connected().await?;
+            match client
+                .send_request_structured::<db::QueryResult>(
+                    DuckDbWorkerMethod::Execute,
+                    DuckDbWorkerExecuteParams { sql, database, max_rows },
+                    None,
+                )
+                .await
+            {
+                Ok(result) => Ok(result),
+                Err(error) => {
+                    if error.code == DUCKDB_WORKER_POISONED_CODE {
+                        client.kill().await;
+                    }
+                    Err(error.message)
+                }
+            }
+        };
+        tokio::pin!(future);
+
+        match (cancel_token, query_timeout) {
+            (Some(token), Some(duration)) => {
+                tokio::select! {
+                    biased;
+                    _ = token.cancelled() => self.cancel_or_kill(crate::query::canceled_error()).await,
+                    result = &mut future => result,
+                    _ = tokio::time::sleep(duration) => self.cancel_or_kill(crate::query::timeout_error()).await,
+                }
+            }
+            (Some(token), None) => {
+                tokio::select! {
+                    biased;
+                    _ = token.cancelled() => self.cancel_or_kill(crate::query::canceled_error()).await,
+                    result = &mut future => result,
+                }
+            }
+            (None, Some(duration)) => {
+                tokio::select! {
+                    result = &mut future => result,
+                    _ = tokio::time::sleep(duration) => self.cancel_or_kill(crate::query::timeout_error()).await,
+                }
+            }
+            (None, None) => future.await,
+        }
+    }
+
+    async fn cancel_or_kill(&self, final_error: String) -> Result<db::QueryResult, String> {
+        let _ = self.cancel().await;
+        Err(final_error)
+    }
+
+    pub async fn list_databases(&self) -> Result<Vec<db::DatabaseInfo>, String> {
+        self.metadata_request(DuckDbWorkerMethod::ListDatabases, serde_json::json!({})).await
+    }
+
+    pub async fn list_schemas(&self, database: String) -> Result<Vec<String>, String> {
+        self.metadata_request(DuckDbWorkerMethod::ListSchemas, serde_json::json!({ "database": database })).await
+    }
+
+    pub async fn list_tables(&self, database: String, schema: String) -> Result<Vec<db::TableInfo>, String> {
+        self.metadata_request(
+            DuckDbWorkerMethod::ListTables,
+            serde_json::json!({ "database": database, "schema": schema }),
+        )
+        .await
+    }
+
+    pub async fn list_columns(
+        &self,
+        database: String,
+        schema: String,
+        table: String,
+    ) -> Result<Vec<db::ColumnInfo>, String> {
+        self.metadata_request(
+            DuckDbWorkerMethod::ListColumns,
+            serde_json::json!({ "database": database, "schema": schema, "table": table }),
+        )
+        .await
+    }
+
+    pub async fn attach_database(&self, attached: AttachedDatabaseConfig) -> Result<(), String> {
+        self.metadata_request::<serde_json::Value>(DuckDbWorkerMethod::AttachDatabase, attached).await?;
+        Ok(())
+    }
+
+    /// Runs a metadata request that executes synchronously inside the worker's stdin loop.
+    /// If it times out the worker is likely stuck inside DuckDB and can no longer read further
+    /// requests, so we kill it; the next call restarts a fresh worker via `ensure_connected`.
+    /// Ordinary errors (e.g. a missing table) leave the worker healthy and do not kill it.
+    async fn metadata_request<T>(&self, method: DuckDbWorkerMethod, params: impl serde::Serialize) -> Result<T, String>
+    where
+        T: serde::de::DeserializeOwned,
+    {
+        let timeout = self.inner.request_timeout;
+        match tokio::time::timeout(timeout, self.request::<T>(method, params, None)).await {
+            Ok(result) => result,
+            Err(_) => {
+                self.kill().await;
+                Err(format!("DuckDB worker request timed out after {}s", timeout.as_secs()))
+            }
+        }
+    }
+
+    pub async fn cancel(&self) -> Result<(), String> {
+        self.kill().await;
+        Ok(())
+    }
+
+    pub async fn shutdown(&self) {
+        let _ = self
+            .send_request::<serde_json::Value>(
+                DuckDbWorkerMethod::Shutdown,
+                serde_json::json!({}),
+                Some(self.inner.request_timeout),
+            )
+            .await;
+        self.kill().await;
+    }
+
+    pub async fn kill(&self) {
+        let (child, generation) = {
+            let mut state = self.inner.state.lock().await;
+            let child = state.child.take();
+            let generation = state.generation;
+            state.stdin = None;
+            state.connected = false;
+            (child, generation)
+        };
+
+        if let Some(mut child) = child {
+            let _ = child.start_kill();
+            match tokio::time::timeout(DEFAULT_WORKER_KILL_WAIT, child.wait()).await {
+                Ok(Ok(status)) => log::info!("[duckdb-worker:kill:exit] status={status}"),
+                Ok(Err(err)) => log::warn!("[duckdb-worker:kill:wait-failed] error={err}"),
+                Err(_) => {
+                    log::warn!("[duckdb-worker:kill:wait-timeout] wait_ms={}", DEFAULT_WORKER_KILL_WAIT.as_millis())
+                }
+            }
+        }
+        self.fail_pending_for_generation(generation, "duckdb_worker_killed", "DuckDB worker process was killed").await;
+    }
+
+    async fn request<T>(
+        &self,
+        method: DuckDbWorkerMethod,
+        params: impl serde::Serialize,
+        timeout: Option<Duration>,
+    ) -> Result<T, String>
+    where
+        T: serde::de::DeserializeOwned,
+    {
+        self.ensure_connected().await?;
+        self.send_request(method, params, timeout).await
+    }
+
+    async fn ensure_connected(&self) -> Result<(), String> {
+        let _guard = self.inner.connect_lock.lock().await;
+        {
+            let mut state = self.inner.state.lock().await;
+            self.ensure_started_locked(&mut state).await?;
+            if state.connected {
+                return Ok(());
+            }
+        }
+
+        let mut attempts = 0;
+        loop {
+            match self
+                .send_request_structured::<serde_json::Value>(
+                    DuckDbWorkerMethod::Connect,
+                    self.inner.connect_params.clone(),
+                    Some(self.inner.request_timeout),
+                )
+                .await
+            {
+                Ok(_) => break,
+                Err(error) => {
+                    let retry_delay = duckdb_connect_file_lock_retry_delay(attempts, &error.message);
+                    // A failed Connect leaves this worker without a valid session. Keep no stale
+                    // child around, especially after OS file-lock errors where the user may retry
+                    // once the competing process exits.
+                    self.kill().await;
+                    if let Some(delay) = retry_delay {
+                        attempts += 1;
+                        log::warn!(
+                            "[duckdb-worker:connect-retry] attempt={} delay_ms={} error={}",
+                            attempts,
+                            delay.as_millis(),
+                            error.message
+                        );
+                        tokio::time::sleep(delay).await;
+                        continue;
+                    }
+                    return Err(error.message);
+                }
+            }
+        }
+
+        let mut state = self.inner.state.lock().await;
+        state.connected = true;
+        Ok(())
+    }
+
+    async fn ensure_started_locked(&self, state: &mut WorkerProcessState) -> Result<(), String> {
+        let should_restart = match state.child.as_mut() {
+            Some(child) => match child.try_wait() {
+                Ok(Some(status)) => {
+                    log::warn!("[duckdb-worker:exit] status={status}");
+                    true
+                }
+                Ok(None) => return Ok(()),
+                Err(err) => {
+                    log::warn!("[duckdb-worker:exit-check-failed] error={err}");
+                    true
+                }
+            },
+            None => true,
+        };
+
+        if should_restart {
+            state.child = None;
+            state.stdin = None;
+            state.connected = false;
+        }
+        state.generation = state.generation.wrapping_add(1);
+        let generation = state.generation;
+
+        let permit =
+            tokio::time::timeout(self.inner.worker_start_timeout, self.inner.process_limiter.clone().acquire_owned())
+                .await
+                .map_err(|_| duckdb_worker_process_limit_error(self.inner.process_limit))?
+                .map_err(|_| "DuckDB worker process limiter is closed".to_string())?;
+
+        log::info!("[duckdb-worker:start] executable={}", self.inner.executable.display());
+        let mut child = crate::process::new_tokio_command(&self.inner.executable)
+            .arg("--duckdb-worker")
+            .stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::inherit())
+            .kill_on_drop(true)
+            .spawn()
+            .map_err(|e| format!("Failed to start DuckDB worker: {e}"))?;
+
+        let stdin = child.stdin.take().ok_or("DuckDB worker stdin unavailable")?;
+        let stdout = child.stdout.take().ok_or("DuckDB worker stdout unavailable")?;
+        spawn_stdout_reader(stdout, self.inner.pending.clone(), generation, permit);
+
+        state.child = Some(child);
+        state.stdin = Some(stdin);
+        state.connected = false;
+        Ok(())
+    }
+
+    async fn send_request<T>(
+        &self,
+        method: DuckDbWorkerMethod,
+        params: impl serde::Serialize,
+        timeout: Option<Duration>,
+    ) -> Result<T, String>
+    where
+        T: serde::de::DeserializeOwned,
+    {
+        self.send_request_structured(method, params, timeout).await.map_err(|error| error.message)
+    }
+
+    /// Like `send_request` but preserves the worker error `code` so callers can react to
+    /// specific conditions (e.g. `duckdb_worker_poisoned`). A protocol/transport failure is
+    /// surfaced as an error with code `duckdb_worker_error`.
+    async fn send_request_structured<T>(
+        &self,
+        method: DuckDbWorkerMethod,
+        params: impl serde::Serialize,
+        timeout: Option<Duration>,
+    ) -> Result<T, DuckDbWorkerError>
+    where
+        T: serde::de::DeserializeOwned,
+    {
+        let id = format!("duckdb-worker-{}", self.inner.next_id.fetch_add(1, Ordering::Relaxed));
+        let request = DuckDbWorkerRequest::new(&id, method, params)?;
+        let line = serde_json::to_string(&request).map_err(|e| e.to_string())?;
+        let (tx, rx) = oneshot::channel();
+
+        let write_result = async {
+            let mut state = self.inner.state.lock().await;
+            self.ensure_started_locked(&mut state).await?;
+            if method != DuckDbWorkerMethod::Connect && !state.connected {
+                return Err("DuckDB worker is not connected".to_string());
+            }
+            let generation = state.generation;
+            self.inner.pending.lock().await.insert(id.clone(), PendingRequest { generation, sender: tx });
+            let stdin = state.stdin.as_mut().ok_or("DuckDB worker stdin unavailable")?;
+            stdin.write_all(line.as_bytes()).await.map_err(|e| e.to_string())?;
+            stdin.write_all(b"\n").await.map_err(|e| e.to_string())?;
+            stdin.flush().await.map_err(|e| e.to_string())
+        }
+        .await;
+
+        if let Err(err) = write_result {
+            self.inner.pending.lock().await.remove(&id);
+            return Err(err.into());
+        }
+
+        let response = match timeout {
+            Some(timeout) => match tokio::time::timeout(timeout, rx).await {
+                Ok(Ok(response)) => response,
+                Ok(Err(_)) => return Err("DuckDB worker response channel closed".into()),
+                Err(_) => {
+                    self.inner.pending.lock().await.remove(&id);
+                    return Err(DuckDbWorkerError::new(
+                        DUCKDB_WORKER_REQUEST_TIMEOUT_CODE,
+                        format!("DuckDB worker request timed out after {}s", timeout.as_secs()),
+                    ));
+                }
+            },
+            None => rx.await.map_err(|_| DuckDbWorkerError::from("DuckDB worker response channel closed"))?,
+        };
+
+        if !response.ok {
+            let error = response
+                .error
+                .unwrap_or_else(|| DuckDbWorkerError::new("duckdb_worker_error", "DuckDB worker request failed"));
+            return Err(error);
+        }
+
+        let result = response.result.unwrap_or(serde_json::Value::Null);
+        serde_json::from_value(result).map_err(|e| DuckDbWorkerError::from(e.to_string()))
+    }
+
+    async fn fail_pending_for_generation(&self, generation: u64, code: &'static str, message: &'static str) {
+        let pending = {
+            let mut pending = self.inner.pending.lock().await;
+            let ids = pending
+                .iter()
+                .filter_map(|(id, request)| (request.generation == generation).then(|| id.clone()))
+                .collect::<Vec<_>>();
+            ids.into_iter().filter_map(|id| pending.remove(&id).map(|request| (id, request.sender))).collect::<Vec<_>>()
+        };
+        for (id, sender) in pending {
+            let _ = sender.send(DuckDbWorkerResponse::err(id, DuckDbWorkerError::new(code, message)));
+        }
+    }
+}
+
+struct WorkerProcessLimiterState {
+    limit: usize,
+    limiter: Arc<Semaphore>,
+}
+
+fn duckdb_worker_process_limiter(process_limit: usize) -> (Arc<Semaphore>, usize) {
+    static LIMITER: OnceLock<StdMutex<WorkerProcessLimiterState>> = OnceLock::new();
+    let process_limit = normalize_duckdb_worker_max_processes(process_limit);
+    let state = LIMITER.get_or_init(|| {
+        StdMutex::new(WorkerProcessLimiterState {
+            limit: process_limit,
+            limiter: Arc::new(Semaphore::new(process_limit)),
+        })
+    });
+    let mut state = state.lock().expect("DuckDB worker process limiter lock poisoned");
+    if state.limit != process_limit && state.limiter.available_permits() == state.limit {
+        *state = WorkerProcessLimiterState { limit: process_limit, limiter: Arc::new(Semaphore::new(process_limit)) };
+    }
+    (state.limiter.clone(), state.limit)
+}
+
+fn duckdb_worker_process_limit_error(process_limit: usize) -> String {
+    format!(
+        "DuckDB worker process limit reached (max {}). Close another DuckDB worker connection or retry later.",
+        process_limit
+    )
+}
+
+fn duckdb_connect_file_lock_retry_delay(attempts: usize, message: &str) -> Option<Duration> {
+    if !is_transient_duckdb_file_lock_error(message) {
+        return None;
+    }
+    match attempts {
+        0 => Some(Duration::from_millis(50)),
+        1 => Some(Duration::from_millis(100)),
+        2 => Some(Duration::from_millis(200)),
+        3 => Some(Duration::from_millis(400)),
+        4 => Some(Duration::from_millis(800)),
+        _ => None,
+    }
+}
+
+fn is_transient_duckdb_file_lock_error(message: &str) -> bool {
+    let lower = message.to_ascii_lowercase();
+    let mentions_file_open = lower.contains("cannot open file")
+        || lower.contains("could not set lock")
+        || lower.contains("file is already open");
+    let mentions_lock = lower.contains("file is already open")
+        || lower.contains("being used by another process")
+        || lower.contains("conflicting lock")
+        || lower.contains("process cannot access the file")
+        || lower.contains("sharing violation")
+        || lower.contains("resource temporarily unavailable")
+        || message.contains("另一个程序正在使用")
+        || message.contains("进程无法访问");
+    mentions_file_open && mentions_lock
+}
+
+fn spawn_stdout_reader(
+    stdout: tokio::process::ChildStdout,
+    pending: PendingRequests,
+    generation: u64,
+    permit: OwnedSemaphorePermit,
+) {
+    tokio::spawn(async move {
+        let _permit = permit;
+        let mut lines = BufReader::new(stdout).lines();
+        loop {
+            match lines.next_line().await {
+                Ok(Some(line)) => {
+                    if line.trim().is_empty() {
+                        continue;
+                    }
+                    match serde_json::from_str::<DuckDbWorkerResponse>(&line) {
+                        Ok(response) => {
+                            let sender = {
+                                let mut pending = pending.lock().await;
+                                let matches_generation = pending
+                                    .get(&response.id)
+                                    .map(|request| request.generation == generation)
+                                    .unwrap_or(false);
+                                if matches_generation {
+                                    pending.remove(&response.id).map(|request| request.sender)
+                                } else {
+                                    None
+                                }
+                            };
+                            if let Some(sender) = sender {
+                                let _ = sender.send(response);
+                            }
+                        }
+                        Err(err) => {
+                            log::warn!("[duckdb-worker:invalid-response] error={err} line={line}");
+                        }
+                    }
+                }
+                Ok(None) => break,
+                Err(err) => {
+                    log::warn!("[duckdb-worker:stdout-error] error={err}");
+                    break;
+                }
+            }
+        }
+
+        let pending = {
+            let mut pending = pending.lock().await;
+            let ids = pending
+                .iter()
+                .filter_map(|(id, request)| (request.generation == generation).then(|| id.clone()))
+                .collect::<Vec<_>>();
+            ids.into_iter().filter_map(|id| pending.remove(&id).map(|request| (id, request.sender))).collect::<Vec<_>>()
+        };
+        for (id, sender) in pending {
+            let _ = sender.send(DuckDbWorkerResponse::err(
+                id,
+                DuckDbWorkerError::new("duckdb_worker_exited", "DuckDB worker process exited"),
+            ));
+        }
+    });
+}
diff --git a/crates/dbx-core/src/db/duckdb_worker_protocol.rs b/crates/dbx-core/src/db/duckdb_worker_protocol.rs
new file mode 100644
index 0000000..868607b
--- /dev/null
+++ b/crates/dbx-core/src/db/duckdb_worker_protocol.rs
@@ -0,0 +1,178 @@
+#![cfg(feature = "duckdb-bundled")]
+
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+
+use crate::models::connection::AttachedDatabaseConfig;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DuckDbWorkerRequest {
+    pub id: String,
+    pub method: DuckDbWorkerMethod,
+    #[serde(default)]
+    pub params: serde_json::Value,
+}
+
+impl DuckDbWorkerRequest {
+    pub fn new(id: impl Into<String>, method: DuckDbWorkerMethod, params: impl Serialize) -> Result<Self, String> {
+        let params = serde_json::to_value(params).map_err(|e| e.to_string())?;
+        Ok(Self { id: id.into(), method, params })
+    }
+
+    pub fn parse_params<T: DeserializeOwned>(&self) -> Result<T, DuckDbWorkerError> {
+        serde_json::from_value(self.params.clone()).map_err(|err| {
+            DuckDbWorkerError::new("invalid_params", format!("Invalid params for {:?}: {err}", self.method))
+        })
+    }
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum DuckDbWorkerMethod {
+    Connect,
+    Execute,
+    ListDatabases,
+    ListSchemas,
+    ListTables,
+    ListColumns,
+    AttachDatabase,
+    Cancel,
+    Shutdown,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct DuckDbWorkerResponse {
+    pub id: String,
+    pub ok: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub result: Option<serde_json::Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<DuckDbWorkerError>,
+}
+
+impl DuckDbWorkerResponse {
+    pub fn ok(id: impl Into<String>, result: impl Serialize) -> Self {
+        match serde_json::to_value(result) {
+            Ok(result) => Self { id: id.into(), ok: true, result: Some(result), error: None },
+            Err(err) => Self::err(id, DuckDbWorkerError::new("serialization_failed", err.to_string())),
+        }
+    }
+
+    pub fn ok_empty(id: impl Into<String>) -> Self {
+        Self { id: id.into(), ok: true, result: None, error: None }
+    }
+
+    pub fn err(id: impl Into<String>, error: DuckDbWorkerError) -> Self {
+        Self { id: id.into(), ok: false, result: None, error: Some(error) }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct DuckDbWorkerError {
+    pub code: String,
+    pub message: String,
+}
+
+impl DuckDbWorkerError {
+    pub fn new(code: impl Into<String>, message: impl Into<String>) -> Self {
+        Self { code: code.into(), message: message.into() }
+    }
+
+    pub fn from_message(code: &'static str, error: impl ToString) -> Self {
+        Self::new(code, error.to_string())
+    }
+}
+
+impl From<String> for DuckDbWorkerError {
+    fn from(message: String) -> Self {
+        Self::new("duckdb_worker_error", message)
+    }
+}
+
+impl From<&str> for DuckDbWorkerError {
+    fn from(message: &str) -> Self {
+        Self::new("duckdb_worker_error", message)
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct DuckDbWorkerConnectParams {
+    pub path: String,
+    #[serde(default)]
+    pub attached_databases: Vec<AttachedDatabaseConfig>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct DuckDbWorkerExecuteParams {
+    pub sql: String,
+    #[serde(default)]
+    pub database: Option<String>,
+    #[serde(default)]
+    pub max_rows: Option<usize>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct DuckDbWorkerDatabaseParams {
+    pub database: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct DuckDbWorkerTableParams {
+    pub database: String,
+    pub schema: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct DuckDbWorkerColumnParams {
+    pub database: String,
+    pub schema: String,
+    pub table: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn protocol_round_trips_connect_request() {
+        let request = DuckDbWorkerRequest::new(
+            "req-1",
+            DuckDbWorkerMethod::Connect,
+            DuckDbWorkerConnectParams {
+                path: "D:/tmp/app.duckdb".to_string(),
+                attached_databases: vec![AttachedDatabaseConfig {
+                    name: "analytics".to_string(),
+                    path: "D:/tmp/analytics.duckdb".to_string(),
+                }],
+            },
+        )
+        .expect("serialize request");
+
+        let json = serde_json::to_string(&request).expect("request json");
+        let parsed: DuckDbWorkerRequest = serde_json::from_str(&json).expect("parse request");
+        let params: DuckDbWorkerConnectParams = parsed.parse_params().expect("parse params");
+
+        assert_eq!(parsed.id, "req-1");
+        assert_eq!(parsed.method, DuckDbWorkerMethod::Connect);
+        assert_eq!(params.path, "D:/tmp/app.duckdb");
+        assert_eq!(params.attached_databases[0].name, "analytics");
+    }
+
+    #[test]
+    fn protocol_round_trips_error_response() {
+        let response = DuckDbWorkerResponse::err(
+            "req-2",
+            DuckDbWorkerError::new("duckdb_open_failed", "DuckDB connection failed"),
+        );
+
+        let json = serde_json::to_string(&response).expect("response json");
+        let parsed: DuckDbWorkerResponse = serde_json::from_str(&json).expect("parse response");
+
+        assert!(!parsed.ok);
+        assert_eq!(parsed.error.expect("error").code, "duckdb_open_failed");
+    }
+}
diff --git a/crates/dbx-core/src/db/duckdb_worker_runtime.rs b/crates/dbx-core/src/db/duckdb_worker_runtime.rs
new file mode 100644
index 0000000..ac0cdb0
--- /dev/null
+++ b/crates/dbx-core/src/db/duckdb_worker_runtime.rs
@@ -0,0 +1,566 @@
+#![cfg(feature = "duckdb-bundled")]
+
+use std::sync::{Arc, Mutex};
+
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, Stdout};
+
+use crate::db;
+use crate::db::duckdb_worker_protocol::{
+    DuckDbWorkerColumnParams, DuckDbWorkerConnectParams, DuckDbWorkerDatabaseParams, DuckDbWorkerError,
+    DuckDbWorkerExecuteParams, DuckDbWorkerMethod, DuckDbWorkerRequest, DuckDbWorkerResponse, DuckDbWorkerTableParams,
+};
+use crate::models::connection::AttachedDatabaseConfig;
+use crate::path_utils::expand_tilde;
+
+#[derive(Default)]
+pub struct DuckDbWorkerSession {
+    connection: Option<Arc<db::duckdb_driver::DuckDbConnection>>,
+    attached_names: Vec<String>,
+}
+
+impl DuckDbWorkerSession {
+    pub fn connect(&mut self, params: DuckDbWorkerConnectParams) -> Result<(), String> {
+        let path = expand_tilde(&params.path);
+        let connection = db::duckdb_driver::connect_path(&path)?;
+        let mut attached_names = Vec::new();
+        {
+            let locked = connection.lock().map_err(|e| e.to_string())?;
+            for attached in &params.attached_databases {
+                let path = expand_tilde(&attached.path);
+                crate::schema::duckdb_attach_database(&locked, &attached.name, &path)?;
+                attached_names.push(attached.name.clone());
+            }
+        }
+        self.connection = Some(connection);
+        self.attached_names = attached_names;
+        Ok(())
+    }
+
+    pub fn execute(&mut self, params: DuckDbWorkerExecuteParams) -> Result<db::QueryResult, String> {
+        let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
+        let locked = connection.lock().map_err(|e| e.to_string())?;
+        let result = crate::query::duckdb_execute_for_database(
+            &locked,
+            &self.attached_names,
+            params.database.as_deref(),
+            &params.sql,
+            params.max_rows,
+        )?;
+        if let Some(name) = duckdb_attached_name_from_attach_sql(&params.sql) {
+            if !self.attached_names.iter().any(|attached| attached.eq_ignore_ascii_case(&name)) {
+                self.attached_names.push(name);
+            }
+        }
+        Ok(result)
+    }
+
+    pub fn list_databases(&self) -> Result<Vec<db::DatabaseInfo>, String> {
+        let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
+        let locked = connection.lock().map_err(|e| e.to_string())?;
+        crate::schema::duckdb_list_databases_with_attached(&locked, &self.attached_names)
+    }
+
+    pub fn list_schemas(&self, params: DuckDbWorkerDatabaseParams) -> Result<Vec<String>, String> {
+        let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
+        let locked = connection.lock().map_err(|e| e.to_string())?;
+        crate::schema::duckdb_list_schemas_with_attached(&locked, &params.database, &self.attached_names)
+    }
+
+    pub fn list_tables(&self, params: DuckDbWorkerTableParams) -> Result<Vec<db::TableInfo>, String> {
+        let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
+        let locked = connection.lock().map_err(|e| e.to_string())?;
+        crate::schema::duckdb_query_tables_in_database_with_attached(
+            &locked,
+            &params.database,
+            &params.schema,
+            &self.attached_names,
+        )
+    }
+
+    pub fn list_columns(&self, params: DuckDbWorkerColumnParams) -> Result<Vec<db::ColumnInfo>, String> {
+        let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
+        let locked = connection.lock().map_err(|e| e.to_string())?;
+        crate::schema::duckdb_query_columns_in_database_with_attached(
+            &locked,
+            &params.database,
+            &params.schema,
+            &params.table,
+            &self.attached_names,
+        )
+    }
+
+    pub fn attach_database(&mut self, attached: AttachedDatabaseConfig) -> Result<(), String> {
+        let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
+        let locked = connection.lock().map_err(|e| e.to_string())?;
+        let path = expand_tilde(&attached.path);
+        crate::schema::duckdb_attach_database(&locked, &attached.name, &path)?;
+        self.attached_names.push(attached.name);
+        Ok(())
+    }
+
+    fn interrupt_handle(&self) -> Result<Arc<duckdb::InterruptHandle>, String> {
+        let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
+        Ok(connection.interrupt_handle())
+    }
+
+    /// Probes whether the connection is still usable after an execute error.
+    ///
+    /// duckdb-rs 1.10503.1 has a bug where `Connection::prepare()` failing at the
+    /// `duckdb_extract_statements` stage (a syntax `Parser Error`) permanently poisons
+    /// the connection: every later operation returns `resource deadlock would occur`,
+    /// and dropping the connection aborts the whole process. Benign errors (binder,
+    /// catalog, runtime) do not poison the connection.
+    ///
+    /// This probe runs a trivial query through `execute_batch`, which uses the
+    /// non-poisoning `duckdb_query_arrow` path and fails fast on a poisoned connection.
+    /// It returns `true` when the connection is healthy and safe to reuse.
+    fn is_connection_healthy(&self) -> bool {
+        match self.connection.as_ref() {
+            Some(connection) => match connection.lock() {
+                Ok(locked) => locked.execute_batch("SELECT 1").is_ok(),
+                Err(_) => false,
+            },
+            None => false,
+        }
+    }
+}
+
+#[derive(Clone, Default)]
+struct DuckDbWorkerRuntime {
+    session: Arc<Mutex<DuckDbWorkerSession>>,
+    active_interrupt: Arc<Mutex<Option<Arc<duckdb::InterruptHandle>>>>,
+}
+
+struct WorkerHandleResult {
+    response: Option<DuckDbWorkerResponse>,
+    shutdown: bool,
+}
+
+impl DuckDbWorkerRuntime {
+    async fn handle_request(
+        &self,
+        request: DuckDbWorkerRequest,
+        stdout: Arc<tokio::sync::Mutex<Stdout>>,
+    ) -> WorkerHandleResult {
+        match request.method {
+            DuckDbWorkerMethod::Connect => self.handle_session_request(request, |session, request| {
+                session.connect(request.parse_params()?)?;
+                Ok(DuckDbWorkerResponse::ok(request.id, serde_json::json!({ "connected": true })))
+            }),
+            DuckDbWorkerMethod::ListDatabases => self.handle_session_request(request, |session, request| {
+                Ok(DuckDbWorkerResponse::ok(request.id, session.list_databases()?))
+            }),
+            DuckDbWorkerMethod::ListSchemas => self.handle_session_request(request, |session, request| {
+                let params = request.parse_params()?;
+                Ok(DuckDbWorkerResponse::ok(request.id, session.list_schemas(params)?))
+            }),
+            DuckDbWorkerMethod::ListTables => self.handle_session_request(request, |session, request| {
+                let params = request.parse_params()?;
+                Ok(DuckDbWorkerResponse::ok(request.id, session.list_tables(params)?))
+            }),
+            DuckDbWorkerMethod::ListColumns => self.handle_session_request(request, |session, request| {
+                let params = request.parse_params()?;
+                Ok(DuckDbWorkerResponse::ok(request.id, session.list_columns(params)?))
+            }),
+            DuckDbWorkerMethod::AttachDatabase => self.handle_session_request(request, |session, request| {
+                session.attach_database(request.parse_params()?)?;
+                Ok(DuckDbWorkerResponse::ok_empty(request.id))
+            }),
+            DuckDbWorkerMethod::Execute => {
+                if self.active_interrupt.lock().unwrap_or_else(|e| e.into_inner()).is_some() {
+                    return WorkerHandleResult {
+                        response: Some(DuckDbWorkerResponse::err(
+                            request.id,
+                            DuckDbWorkerError::new("duckdb_worker_busy", "DuckDB worker is already executing a query"),
+                        )),
+                        shutdown: false,
+                    };
+                }
+
+                let interrupt_handle = match self.session.lock().unwrap_or_else(|e| e.into_inner()).interrupt_handle() {
+                    Ok(handle) => handle,
+                    Err(err) => {
+                        return WorkerHandleResult {
+                            response: Some(DuckDbWorkerResponse::err(
+                                request.id,
+                                DuckDbWorkerError::from_message("duckdb_not_connected", err),
+                            )),
+                            shutdown: false,
+                        }
+                    }
+                };
+                *self.active_interrupt.lock().unwrap_or_else(|e| e.into_inner()) = Some(interrupt_handle);
+
+                let session = self.session.clone();
+                let active_interrupt = self.active_interrupt.clone();
+                tokio::spawn(async move {
+                    let id = request.id.clone();
+                    let params = request.parse_params::<DuckDbWorkerExecuteParams>();
+                    let (result, poisoned) = match params {
+                        Ok(params) => {
+                            let probe_session = session.clone();
+                            tokio::task::spawn_blocking(move || {
+                                let mut session = probe_session.lock().unwrap_or_else(|e| e.into_inner());
+                                let result = session.execute(params);
+                                // Only probe connection health when execute failed: a syntax
+                                // Parser Error can poison the connection (duckdb-rs bug), and any
+                                // later use — including drop — would abort the process.
+                                let poisoned = result.is_err() && !session.is_connection_healthy();
+                                (result, poisoned)
+                            })
+                            .await
+                            .map_err(|e| e.to_string())
+                            .unwrap_or_else(|err| (Err(err), true))
+                        }
+                        Err(err) => (Err(err.message), false),
+                    };
+                    *active_interrupt.lock().unwrap_or_else(|e| e.into_inner()) = None;
+                    let response = match result {
+                        Ok(result) => DuckDbWorkerResponse::ok(id, result),
+                        // A poisoned connection cannot be reused or even safely dropped in-process.
+                        // Report a distinct code so the parent kills this worker (OS-level, skipping
+                        // destructors) and restarts a fresh one on the next request. We must not exit
+                        // here ourselves: process::exit races the parent's next request, which could
+                        // be written to a dying worker. Killing on the parent side has no such window.
+                        Err(err) if poisoned => {
+                            log::warn!("[duckdb-worker:poisoned-connection] reporting to parent for restart");
+                            DuckDbWorkerResponse::err(
+                                id,
+                                DuckDbWorkerError::from_message("duckdb_worker_poisoned", err),
+                            )
+                        }
+                        Err(err) => {
+                            DuckDbWorkerResponse::err(id, DuckDbWorkerError::from_message("duckdb_execute_failed", err))
+                        }
+                    };
+                    write_response(stdout, &response).await;
+                });
+
+                WorkerHandleResult { response: None, shutdown: false }
+            }
+            DuckDbWorkerMethod::Cancel => {
+                if let Some(handle) = self.active_interrupt.lock().unwrap_or_else(|e| e.into_inner()).as_ref() {
+                    handle.interrupt();
+                }
+                WorkerHandleResult {
+                    response: Some(DuckDbWorkerResponse::ok(request.id, serde_json::json!({ "cancelled": true }))),
+                    shutdown: false,
+                }
+            }
+            DuckDbWorkerMethod::Shutdown => WorkerHandleResult {
+                response: Some(DuckDbWorkerResponse::ok(request.id, serde_json::json!({ "shutdown": true }))),
+                shutdown: true,
+            },
+        }
+    }
+
+    fn handle_session_request(
+        &self,
+        request: DuckDbWorkerRequest,
+        handler: impl FnOnce(
+            &mut DuckDbWorkerSession,
+            DuckDbWorkerRequest,
+        ) -> Result<DuckDbWorkerResponse, DuckDbWorkerError>,
+    ) -> WorkerHandleResult {
+        let id = request.id.clone();
+        if self.active_interrupt.lock().unwrap_or_else(|e| e.into_inner()).is_some() {
+            return WorkerHandleResult {
+                response: Some(DuckDbWorkerResponse::err(
+                    id,
+                    DuckDbWorkerError::new("duckdb_worker_busy", "DuckDB worker is executing a query"),
+                )),
+                shutdown: false,
+            };
+        }
+        let response = {
+            match self.session.try_lock() {
+                Ok(mut session) => match handler(&mut session, request) {
+                    Ok(response) => response,
+                    Err(err) => DuckDbWorkerResponse::err(id, err),
+                },
+                Err(_) => DuckDbWorkerResponse::err(
+                    id,
+                    DuckDbWorkerError::new("duckdb_worker_busy", "DuckDB worker session is busy"),
+                ),
+            }
+        };
+        WorkerHandleResult { response: Some(response), shutdown: false }
+    }
+}
+
+pub async fn run_stdio_worker() -> Result<(), String> {
+    let runtime = DuckDbWorkerRuntime::default();
+    let stdout = Arc::new(tokio::sync::Mutex::new(tokio::io::stdout()));
+    let stdin = BufReader::new(tokio::io::stdin());
+    let mut lines = stdin.lines();
+
+    loop {
+        let line = lines.next_line().await.map_err(|e| e.to_string())?;
+        let Some(line) = line else {
+            std::process::exit(0);
+        };
+        if line.trim().is_empty() {
+            continue;
+        }
+        let request: DuckDbWorkerRequest = match serde_json::from_str(&line) {
+            Ok(request) => request,
+            Err(err) => {
+                let response = DuckDbWorkerResponse::err(
+                    "",
+                    DuckDbWorkerError::new("invalid_json", format!("Invalid worker request JSON: {err}")),
+                );
+                write_response(stdout.clone(), &response).await;
+                continue;
+            }
+        };
+        let result = runtime.handle_request(request, stdout.clone()).await;
+        if let Some(response) = result.response {
+            write_response(stdout.clone(), &response).await;
+        }
+        if result.shutdown {
+            break;
+        }
+    }
+    Ok(())
+}
+
+async fn write_response(stdout: Arc<tokio::sync::Mutex<Stdout>>, response: &DuckDbWorkerResponse) {
+    let Ok(line) = serde_json::to_string(response) else {
+        return;
+    };
+    let mut stdout = stdout.lock().await;
+    let _ = stdout.write_all(line.as_bytes()).await;
+    let _ = stdout.write_all(b"\n").await;
+    let _ = stdout.flush().await;
+}
+
+fn duckdb_attached_name_from_attach_sql(sql: &str) -> Option<String> {
+    let trimmed = sql.trim_start();
+    let first_word = trimmed.split(|ch: char| ch.is_whitespace() || ch == ';').next().unwrap_or_default();
+    if !first_word.eq_ignore_ascii_case("ATTACH") {
+        return None;
+    }
+
+    let as_index = find_as_keyword_outside_quotes(trimmed)?;
+    parse_identifier_after_as(&trimmed[as_index + 2..])
+}
+
+fn find_as_keyword_outside_quotes(sql: &str) -> Option<usize> {
+    let bytes = sql.as_bytes();
+    let mut i = 0;
+    let mut in_single = false;
+    let mut in_double = false;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'\'' if !in_double => {
+                if in_single && i + 1 < bytes.len() && bytes[i + 1] == b'\'' {
+                    i += 2;
+                    continue;
+                }
+                in_single = !in_single;
+            }
+            b'"' if !in_single => {
+                if in_double && i + 1 < bytes.len() && bytes[i + 1] == b'"' {
+                    i += 2;
+                    continue;
+                }
+                in_double = !in_double;
+            }
+            b'a' | b'A' if !in_single && !in_double && i + 1 < bytes.len() => {
+                if (bytes[i + 1] == b's' || bytes[i + 1] == b'S')
+                    && is_sql_word_boundary(bytes.get(i.wrapping_sub(1)).copied())
+                    && is_sql_word_boundary(bytes.get(i + 2).copied())
+                {
+                    return Some(i);
+                }
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    None
+}
+
+fn is_sql_word_boundary(byte: Option<u8>) -> bool {
+    !matches!(byte, Some(b'a'..=b'z' | b'A'..=b'Z' | b'0'..=b'9' | b'_'))
+}
+
+fn parse_identifier_after_as(input: &str) -> Option<String> {
+    let input = input.trim_start();
+    if input.is_empty() {
+        return None;
+    }
+    if let Some(rest) = input.strip_prefix('"') {
+        let mut name = String::new();
+        let mut chars = rest.chars().peekable();
+        while let Some(ch) = chars.next() {
+            if ch == '"' {
+                if chars.peek() == Some(&'"') {
+                    name.push('"');
+                    chars.next();
+                    continue;
+                }
+                return (!name.trim().is_empty()).then_some(name);
+            }
+            name.push(ch);
+        }
+        return None;
+    }
+
+    let name = input.split(|ch: char| ch.is_whitespace() || ch == ';').next().unwrap_or_default().trim();
+    (!name.is_empty()).then(|| name.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn worker_session_connects_to_memory_duckdb() {
+        let mut session = DuckDbWorkerSession::default();
+
+        session
+            .connect(DuckDbWorkerConnectParams { path: ":memory:".to_string(), attached_databases: Vec::new() })
+            .expect("connect");
+
+        assert_eq!(session.list_databases().expect("list databases")[0].name, "main");
+    }
+
+    #[test]
+    fn worker_session_executes_select_query() {
+        let mut session = DuckDbWorkerSession::default();
+        session
+            .connect(DuckDbWorkerConnectParams { path: ":memory:".to_string(), attached_databases: Vec::new() })
+            .expect("connect");
+
+        let result = session
+            .execute(DuckDbWorkerExecuteParams { sql: "SELECT 1 AS value".to_string(), database: None, max_rows: None })
+            .expect("execute");
+
+        assert_eq!(result.columns, vec!["value"]);
+        assert_eq!(result.rows, vec![vec![serde_json::json!(1)]]);
+    }
+
+    #[test]
+    fn worker_session_lists_tables_and_columns() {
+        let mut session = DuckDbWorkerSession::default();
+        session
+            .connect(DuckDbWorkerConnectParams { path: ":memory:".to_string(), attached_databases: Vec::new() })
+            .expect("connect");
+        session
+            .execute(DuckDbWorkerExecuteParams {
+                sql: "CREATE TABLE users (id INTEGER PRIMARY KEY, name VARCHAR)".to_string(),
+                database: None,
+                max_rows: None,
+            })
+            .expect("create table");
+
+        let schemas =
+            session.list_schemas(DuckDbWorkerDatabaseParams { database: "main".to_string() }).expect("list schemas");
+        let tables = session
+            .list_tables(DuckDbWorkerTableParams { database: "main".to_string(), schema: "main".to_string() })
+            .expect("list tables");
+        let columns = session
+            .list_columns(DuckDbWorkerColumnParams {
+                database: "main".to_string(),
+                schema: "main".to_string(),
+                table: "users".to_string(),
+            })
+            .expect("list columns");
+
+        assert!(schemas.iter().any(|schema| schema == "main"));
+        assert!(tables.iter().any(|table| table.name == "users"));
+        assert!(columns.iter().any(|column| column.name == "id" && column.is_primary_key));
+    }
+
+    #[test]
+    fn worker_session_attaches_database() {
+        let dir = std::env::temp_dir().join(format!("dbx-duckdb-worker-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        let attached_path = dir.join("analytics.duckdb");
+        {
+            let con = duckdb::Connection::open(&attached_path).expect("create attached db");
+            con.execute_batch("CREATE TABLE events (id INTEGER);").expect("create attached table");
+        }
+        let mut session = DuckDbWorkerSession::default();
+        session
+            .connect(DuckDbWorkerConnectParams { path: ":memory:".to_string(), attached_databases: Vec::new() })
+            .expect("connect");
+
+        session
+            .attach_database(AttachedDatabaseConfig {
+                name: "analytics".to_string(),
+                path: attached_path.to_string_lossy().to_string(),
+            })
+            .expect("attach");
+
+        let databases = session.list_databases().expect("list databases");
+        let tables = session
+            .list_tables(DuckDbWorkerTableParams { database: "analytics".to_string(), schema: "main".to_string() })
+            .expect("list tables");
+        assert!(databases.iter().any(|database| database.name == "analytics"));
+        assert!(tables.iter().any(|table| table.name == "events"));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[test]
+    fn worker_session_tracks_attach_sql_alias() {
+        let dir = std::env::temp_dir().join(format!("dbx-duckdb-worker-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        let attached_path = dir.join("sales.duckdb");
+        {
+            let con = duckdb::Connection::open(&attached_path).expect("create attached db");
+            con.execute_batch("CREATE TABLE orders (id INTEGER);").expect("create attached table");
+        }
+        let mut session = DuckDbWorkerSession::default();
+        session
+            .connect(DuckDbWorkerConnectParams { path: ":memory:".to_string(), attached_databases: Vec::new() })
+            .expect("connect");
+
+        session
+            .execute(DuckDbWorkerExecuteParams {
+                sql: format!("ATTACH '{}' AS \"sales db\";", attached_path.to_string_lossy().replace('\'', "''")),
+                database: None,
+                max_rows: None,
+            })
+            .expect("attach sql");
+
+        assert!(session.attached_names.iter().any(|name| name == "sales db"));
+        let tables = session
+            .list_tables(DuckDbWorkerTableParams { database: "sales db".to_string(), schema: "main".to_string() })
+            .expect("list tables");
+        assert!(tables.iter().any(|table| table.name == "orders"));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn metadata_returns_busy_while_query_is_active() {
+        let runtime = DuckDbWorkerRuntime::default();
+        let stdout = Arc::new(tokio::sync::Mutex::new(tokio::io::stdout()));
+        *runtime.active_interrupt.lock().unwrap_or_else(|e| e.into_inner()) =
+            Some(duckdb::Connection::open_in_memory().expect("connection").interrupt_handle());
+
+        let result = runtime
+            .handle_request(
+                DuckDbWorkerRequest::new("req-busy", DuckDbWorkerMethod::ListDatabases, serde_json::json!({}))
+                    .expect("request"),
+                stdout,
+            )
+            .await;
+
+        let response = result.response.expect("response");
+        assert!(!response.ok);
+        assert_eq!(response.error.expect("error").code, "duckdb_worker_busy");
+    }
+
+    #[test]
+    fn attach_sql_alias_parser_handles_generated_sql() {
+        assert_eq!(
+            duckdb_attached_name_from_attach_sql("ATTACH 'D:\\tmp\\sales.duckdb' AS \"sales db\";"),
+            Some("sales db".to_string())
+        );
+        assert_eq!(duckdb_attached_name_from_attach_sql("select 'not attach' as value"), None);
+    }
+}
diff --git a/crates/dbx-core/src/db/elasticsearch_driver.rs b/crates/dbx-core/src/db/elasticsearch_driver.rs
new file mode 100644
index 0000000..0baad89
--- /dev/null
+++ b/crates/dbx-core/src/db/elasticsearch_driver.rs
@@ -0,0 +1,2096 @@
+use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
+use reqwest::Client as HttpClient;
+use serde::Deserialize;
+use serde_json::Value;
+use std::collections::HashSet;
+use std::error::Error;
+use std::time::Duration;
+
+use super::{http_client_builder, with_connection_timeout};
+use crate::db::mongo_driver::MongoDocumentResult;
+
+const ELASTICSEARCH_PATH_SEGMENT_ENCODE_SET: &AsciiSet = &CONTROLS
+    .add(b' ')
+    .add(b'"')
+    .add(b'#')
+    .add(b'%')
+    .add(b'/')
+    .add(b'<')
+    .add(b'>')
+    .add(b'?')
+    .add(b'[')
+    .add(b'\\')
+    .add(b']')
+    .add(b'^')
+    .add(b'`')
+    .add(b'{')
+    .add(b'|')
+    .add(b'}');
+
+const ELASTICSEARCH_QUERY_VALUE_ENCODE_SET: &AsciiSet =
+    &CONTROLS.add(b' ').add(b'"').add(b'#').add(b'%').add(b'&').add(b'+').add(b'/').add(b'=').add(b'?');
+
+pub struct EsClient {
+    http: HttpClient,
+    base_url: String,
+    fallback_base_urls: Vec<String>,
+    auth: Option<(String, String)>,
+}
+
+impl EsClient {
+    pub fn new(
+        url: &str,
+        username: Option<&str>,
+        password: Option<&str>,
+        accept_invalid_certs: bool,
+        timeout: Duration,
+    ) -> Self {
+        let base_url = url.trim_end_matches('/').to_string();
+        let auth = match (username, password) {
+            (Some(u), Some(p)) if !u.is_empty() => Some((u.to_string(), p.to_string())),
+            _ => None,
+        };
+        let builder = http_client_builder(timeout).danger_accept_invalid_certs(accept_invalid_certs);
+        let http = builder.build().unwrap_or_else(|_| HttpClient::new());
+        let fallback_base_urls = elasticsearch_base_url_fallbacks(&base_url);
+        Self { http, base_url, fallback_base_urls, auth }
+    }
+
+    pub fn from_config(
+        url: &str,
+        username: Option<&str>,
+        password: Option<&str>,
+        tls_enabled: bool,
+        url_params: Option<&str>,
+        timeout: Duration,
+    ) -> Self {
+        Self::new(url, username, password, elasticsearch_accept_invalid_certs(tls_enabled, url_params), timeout)
+    }
+
+    fn get(&self, path: &str) -> reqwest::RequestBuilder {
+        let req = self.http.get(format!("{}{}", self.base_url, path));
+        self.with_auth(req)
+    }
+
+    fn post(&self, path: &str) -> reqwest::RequestBuilder {
+        let req = self.http.post(format!("{}{}", self.base_url, path));
+        self.with_auth(req)
+    }
+
+    fn put(&self, path: &str) -> reqwest::RequestBuilder {
+        let req = self.http.put(format!("{}{}", self.base_url, path));
+        self.with_auth(req)
+    }
+
+    fn delete(&self, path: &str) -> reqwest::RequestBuilder {
+        let req = self.http.delete(format!("{}{}", self.base_url, path));
+        self.with_auth(req)
+    }
+
+    fn with_auth(&self, req: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
+        if let Some((ref user, ref pass)) = self.auth {
+            req.basic_auth(user, Some(pass))
+        } else {
+            req
+        }
+    }
+}
+
+impl Clone for EsClient {
+    fn clone(&self) -> Self {
+        Self {
+            http: self.http.clone(),
+            base_url: self.base_url.clone(),
+            fallback_base_urls: self.fallback_base_urls.clone(),
+            auth: self.auth.clone(),
+        }
+    }
+}
+
+pub async fn test_connection(client: &mut EsClient, timeout: Duration) -> Result<(), String> {
+    let mut errors = Vec::new();
+    let urls = std::iter::once(client.base_url.clone()).chain(client.fallback_base_urls.clone());
+
+    for base_url in urls {
+        client.base_url = base_url.clone();
+        let resp = with_connection_timeout("Elasticsearch", timeout, async {
+            client.get("/").send().await.map_err(|e| {
+                format!(
+                    "Elasticsearch connection failed for {}: {}",
+                    redact_elasticsearch_url(&base_url),
+                    format_reqwest_error(&e)
+                )
+            })
+        })
+        .await;
+
+        let resp = match resp {
+            Ok(resp) => resp,
+            Err(err) => {
+                errors.push(err);
+                continue;
+            }
+        };
+
+        if !resp.status().is_success() {
+            let status = resp.status();
+            let body = resp.text().await.unwrap_or_default();
+            return Err(format!("Elasticsearch error ({status}): {body}"));
+        }
+        return Ok(());
+    }
+
+    if errors.is_empty() {
+        Err("Elasticsearch connection failed: no URL candidates".to_string())
+    } else {
+        Err(errors.join("; "))
+    }
+}
+
+pub fn elasticsearch_accept_invalid_certs(tls_enabled: bool, url_params: Option<&str>) -> bool {
+    tls_enabled
+        || elasticsearch_url_params_flag(url_params, "sslmode", &["disable", "allow"])
+        || elasticsearch_url_params_flag(url_params, "tlsverify", &["false", "0", "no", "off"])
+        || elasticsearch_url_params_flag(url_params, "verify", &["false", "0", "no", "off"])
+        || elasticsearch_url_params_flag(url_params, "insecure", &["true", "1", "yes", "on"])
+        || elasticsearch_url_params_flag(url_params, "accept_invalid_certs", &["true", "1", "yes", "on"])
+}
+
+fn elasticsearch_url_params_flag(params: Option<&str>, key: &str, expected_values: &[&str]) -> bool {
+    params.unwrap_or("").trim().trim_start_matches('?').split('&').filter_map(|pair| pair.split_once('=')).any(
+        |(k, v)| {
+            k.trim().eq_ignore_ascii_case(key)
+                && expected_values.iter().any(|expected| v.trim().eq_ignore_ascii_case(expected))
+        },
+    )
+}
+
+fn elasticsearch_base_url_fallbacks(base_url: &str) -> Vec<String> {
+    let Ok(parsed) = reqwest::Url::parse(base_url) else {
+        return Vec::new();
+    };
+    let Some(host) = parsed.host_str() else {
+        return Vec::new();
+    };
+    if !host.eq_ignore_ascii_case("localhost") {
+        return Vec::new();
+    }
+
+    let mut fallback = parsed;
+    if fallback.set_host(Some("127.0.0.1")).is_ok() {
+        vec![fallback.as_str().trim_end_matches('/').to_string()]
+    } else {
+        Vec::new()
+    }
+}
+
+fn elasticsearch_index_path(index: &str, endpoint: &str) -> String {
+    format!("/{}/{}", elasticsearch_path_segment(index), endpoint.trim_start_matches('/'))
+}
+
+fn elasticsearch_path_segment(value: &str) -> String {
+    utf8_percent_encode(value, ELASTICSEARCH_PATH_SEGMENT_ENCODE_SET).to_string()
+}
+
+fn elasticsearch_query_value(value: &str) -> String {
+    utf8_percent_encode(value, ELASTICSEARCH_QUERY_VALUE_ENCODE_SET).to_string()
+}
+
+fn elasticsearch_document_path(index: &str, id: &str, routing: Option<&str>) -> String {
+    let base = format!("/{}/_doc/{}", elasticsearch_path_segment(index), elasticsearch_path_segment(id));
+    if let Some(routing) = routing.map(str::trim).filter(|value| !value.is_empty()) {
+        format!("{base}?routing={}&refresh=true", elasticsearch_query_value(routing))
+    } else {
+        format!("{base}?refresh=true")
+    }
+}
+
+fn redact_elasticsearch_url(url: &str) -> String {
+    let Ok(mut parsed) = reqwest::Url::parse(url) else {
+        return url.to_string();
+    };
+    if !parsed.username().is_empty() {
+        let _ = parsed.set_username("user");
+    }
+    if parsed.password().is_some() {
+        let _ = parsed.set_password(Some("password"));
+    }
+    parsed.as_str().trim_end_matches('/').to_string()
+}
+
+fn format_reqwest_error(err: &reqwest::Error) -> String {
+    let mut parts = vec![err.to_string()];
+    let mut source = err.source();
+    while let Some(err) = source {
+        let text = err.to_string();
+        if !text.is_empty() && !parts.iter().any(|part| part == &text) {
+            parts.push(text);
+        }
+        source = err.source();
+    }
+    parts.join(": ")
+}
+
+#[derive(Deserialize)]
+struct CatIndex {
+    index: String,
+}
+
+pub async fn list_indices(client: &EsClient) -> Result<Vec<String>, String> {
+    let resp = client
+        .get("/_cat/indices?format=json&h=index")
+        .send()
+        .await
+        .map_err(|e| format!("Elasticsearch request failed: {e}"))?;
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        return Err(format!("Elasticsearch error: {body}"));
+    }
+    let indices: Vec<CatIndex> = resp.json().await.map_err(|e| format!("Elasticsearch parse error: {e}"))?;
+    let mut names: Vec<String> = indices.into_iter().filter(|i| !i.index.starts_with('.')).map(|i| i.index).collect();
+    names.sort();
+    Ok(names)
+}
+
+pub async fn get_columns(client: &EsClient, index: &str) -> Result<Vec<crate::db::ColumnInfo>, String> {
+    let path = elasticsearch_index_path(index, "_mapping");
+    let resp = client.get(&path).send().await.map_err(|e| format!("Elasticsearch request failed: {e}"))?;
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        return Err(format!("Elasticsearch error: {body}"));
+    }
+
+    let body: Value = resp.json().await.map_err(|e| format!("Elasticsearch parse error: {e}"))?;
+    let mut seen = HashSet::new();
+    let mut columns = Vec::new();
+
+    if let Some(indices) = body.as_object() {
+        for index_mapping in indices.values() {
+            if let Some(properties) = mapping_properties(index_mapping) {
+                collect_mapping_columns("", properties, &mut seen, &mut columns);
+            }
+        }
+    }
+
+    columns.sort_by(|left, right| left.name.cmp(&right.name));
+    Ok(columns)
+}
+
+fn mapping_properties(mapping: &Value) -> Option<&serde_json::Map<String, Value>> {
+    if let Some(properties) = mapping.pointer("/mappings/properties").and_then(Value::as_object) {
+        return Some(properties);
+    }
+
+    mapping
+        .get("mappings")
+        .and_then(Value::as_object)?
+        .values()
+        .find_map(|typed_mapping| typed_mapping.get("properties").and_then(Value::as_object))
+}
+
+fn collect_mapping_columns(
+    prefix: &str,
+    properties: &serde_json::Map<String, Value>,
+    seen: &mut HashSet<String>,
+    columns: &mut Vec<crate::db::ColumnInfo>,
+) {
+    for (name, definition) in properties {
+        let field_name = if prefix.is_empty() { name.clone() } else { format!("{prefix}.{name}") };
+        let field_type = definition.get("type").and_then(Value::as_str);
+
+        if let Some(data_type) = field_type {
+            push_mapping_column(&field_name, data_type, seen, columns);
+        }
+
+        if let Some(fields) = definition.get("fields").and_then(Value::as_object) {
+            collect_mapping_columns(&field_name, fields, seen, columns);
+        }
+
+        if let Some(children) = definition.get("properties").and_then(Value::as_object) {
+            collect_mapping_columns(&field_name, children, seen, columns);
+        }
+    }
+}
+
+fn push_mapping_column(
+    name: &str,
+    data_type: &str,
+    seen: &mut HashSet<String>,
+    columns: &mut Vec<crate::db::ColumnInfo>,
+) {
+    if !seen.insert(name.to_string()) {
+        return;
+    }
+
+    columns.push(crate::db::ColumnInfo {
+        name: name.to_string(),
+        data_type: data_type.to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        numeric_precision: None,
+        numeric_scale: None,
+        character_maximum_length: None,
+        enum_values: None,
+        ..Default::default()
+    });
+}
+
+#[derive(Deserialize)]
+struct SearchResponse {
+    hits: SearchHits,
+}
+
+#[derive(Deserialize)]
+struct SearchHits {
+    total: HitsTotal,
+    hits: Vec<SearchHit>,
+}
+
+enum HitsTotal {
+    Count(u64),
+    Value { value: u64 },
+}
+
+impl HitsTotal {
+    fn value(&self) -> u64 {
+        match self {
+            Self::Count(value) | Self::Value { value } => *value,
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for HitsTotal {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let value = serde_json::Value::deserialize(deserializer)?;
+        if let Some(count) = value.as_u64() {
+            return Ok(Self::Count(count));
+        }
+        if let Some(count) = value.get("value").and_then(serde_json::Value::as_u64) {
+            return Ok(Self::Value { value: count });
+        }
+        Err(serde::de::Error::custom("expected hits.total as a number or an object with value"))
+    }
+}
+
+#[derive(Deserialize)]
+struct SearchHit {
+    #[serde(rename = "_id")]
+    id: String,
+    #[serde(rename = "_routing")]
+    routing: Option<String>,
+    #[serde(rename = "_source")]
+    source: serde_json::Value,
+}
+
+pub async fn find_documents(
+    client: &EsClient,
+    index: &str,
+    skip: u64,
+    limit: i64,
+    filter: Option<&str>,
+    sort: Option<&str>,
+) -> Result<MongoDocumentResult, String> {
+    let body = build_find_documents_body(skip, limit, filter, sort)?;
+
+    let path = elasticsearch_index_path(index, "_search");
+    let resp = client.post(&path).json(&body).send().await.map_err(|e| format!("Elasticsearch request failed: {e}"))?;
+
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        return Err(format!("Elasticsearch error: {body}"));
+    }
+
+    let result: SearchResponse = resp.json().await.map_err(|e| format!("Elasticsearch parse error: {e}"))?;
+
+    let documents: Vec<serde_json::Value> = result
+        .hits
+        .hits
+        .into_iter()
+        .map(|hit| {
+            let mut doc = match hit.source {
+                serde_json::Value::Object(map) => map,
+                _ => serde_json::Map::new(),
+            };
+            doc.insert("_id".to_string(), serde_json::Value::String(hit.id));
+            if let Some(routing) = hit.routing {
+                doc.insert("_routing".to_string(), serde_json::Value::String(routing));
+            }
+            serde_json::Value::Object(doc)
+        })
+        .collect();
+
+    Ok(MongoDocumentResult { documents, total: result.hits.total.value() })
+}
+
+fn build_find_documents_body(
+    skip: u64,
+    limit: i64,
+    filter: Option<&str>,
+    sort: Option<&str>,
+) -> Result<serde_json::Value, String> {
+    let mut body = serde_json::Map::new();
+    body.insert("from".to_string(), serde_json::json!(skip));
+    body.insert("size".to_string(), serde_json::json!(limit));
+
+    if let Some(query) = elasticsearch_query_from_document_filter(filter)? {
+        body.insert("query".to_string(), query);
+    }
+
+    body.insert("sort".to_string(), elasticsearch_sort_from_document_sort(sort)?);
+    Ok(serde_json::Value::Object(body))
+}
+
+fn elasticsearch_query_from_document_filter(filter: Option<&str>) -> Result<Option<serde_json::Value>, String> {
+    let Some(filter) = filter.map(str::trim).filter(|value| !value.is_empty()) else {
+        return Ok(None);
+    };
+    let value: serde_json::Value = serde_json::from_str(filter).map_err(|e| format!("Invalid filter JSON: {e}"))?;
+    let query = translate_document_filter_value(&value)?;
+    Ok(query)
+}
+
+fn translate_document_filter_value(value: &serde_json::Value) -> Result<Option<serde_json::Value>, String> {
+    let Some(object) = value.as_object() else {
+        return Err("Elasticsearch filter must be a JSON object".to_string());
+    };
+    if object.is_empty() {
+        return Ok(None);
+    }
+
+    let mut must = Vec::new();
+    for (key, value) in object {
+        match key.as_str() {
+            "$and" => must.extend(translate_logical_filter_array("$and", value)?),
+            "$or" => {
+                let should = translate_logical_filter_array("$or", value)?;
+                if !should.is_empty() {
+                    must.push(serde_json::json!({ "bool": { "should": should, "minimum_should_match": 1 } }));
+                }
+            }
+            key if key.starts_with('$') => {
+                return Err(format!("Unsupported Elasticsearch filter operator: {key}"));
+            }
+            field => must.push(translate_field_filter(field, value)?),
+        }
+    }
+
+    Ok(single_or_bool_filter(must))
+}
+
+fn translate_logical_filter_array(operator: &str, value: &serde_json::Value) -> Result<Vec<serde_json::Value>, String> {
+    let items = value.as_array().ok_or_else(|| format!("{operator} must be an array"))?;
+    let mut queries = Vec::new();
+    for item in items {
+        if let Some(query) = translate_document_filter_value(item)? {
+            queries.push(query);
+        }
+    }
+    Ok(queries)
+}
+
+fn translate_field_filter(field: &str, value: &serde_json::Value) -> Result<serde_json::Value, String> {
+    let Some(object) = value.as_object() else {
+        return Ok(term_or_null_query(field, value));
+    };
+    if object.keys().any(|key| key.starts_with('$')) {
+        return translate_field_operator_filter(field, object);
+    }
+    Ok(term_or_null_query(field, value))
+}
+
+fn translate_field_operator_filter(
+    field: &str,
+    object: &serde_json::Map<String, serde_json::Value>,
+) -> Result<serde_json::Value, String> {
+    let mut must = Vec::new();
+    let mut must_not = Vec::new();
+    let mut range = serde_json::Map::new();
+
+    for (operator, value) in object {
+        match operator.as_str() {
+            "$options" => {}
+            "$ne" => {
+                if value.is_null() {
+                    must.push(serde_json::json!({ "exists": { "field": field } }));
+                } else {
+                    must_not.push(serde_json::json!({ "term": { field: value.clone() } }));
+                }
+            }
+            "$gt" => {
+                range.insert("gt".to_string(), value.clone());
+            }
+            "$gte" => {
+                range.insert("gte".to_string(), value.clone());
+            }
+            "$lt" => {
+                range.insert("lt".to_string(), value.clone());
+            }
+            "$lte" => {
+                range.insert("lte".to_string(), value.clone());
+            }
+            "$regex" => {
+                must.push(regex_like_query(field, value, object.get("$options"))?);
+            }
+            "$not" => {
+                let Some(inner) = value.as_object() else {
+                    return Err("$not must be a JSON object".to_string());
+                };
+                if let Some(regex) = inner.get("$regex") {
+                    must_not.push(regex_like_query(
+                        field,
+                        regex,
+                        inner.get("$options").or_else(|| object.get("$options")),
+                    )?);
+                } else {
+                    return Err("Unsupported Elasticsearch $not filter".to_string());
+                }
+            }
+            other => return Err(format!("Unsupported Elasticsearch field filter operator: {other}")),
+        }
+    }
+
+    if !range.is_empty() {
+        must.push(serde_json::json!({ "range": { field: serde_json::Value::Object(range) } }));
+    }
+
+    match (must.len(), must_not.is_empty()) {
+        (1, true) => Ok(must.remove(0)),
+        (0, false) => Ok(serde_json::json!({ "bool": { "must_not": must_not } })),
+        _ => {
+            let mut bool_query = serde_json::Map::new();
+            if !must.is_empty() {
+                bool_query.insert("must".to_string(), serde_json::Value::Array(must));
+            }
+            if !must_not.is_empty() {
+                bool_query.insert("must_not".to_string(), serde_json::Value::Array(must_not));
+            }
+            Ok(serde_json::json!({ "bool": bool_query }))
+        }
+    }
+}
+
+fn term_or_null_query(field: &str, value: &serde_json::Value) -> serde_json::Value {
+    if value.is_null() {
+        serde_json::json!({ "bool": { "must_not": [{ "exists": { "field": field } }] } })
+    } else {
+        serde_json::json!({ "term": { field: value.clone() } })
+    }
+}
+
+fn regex_like_query(
+    field: &str,
+    value: &serde_json::Value,
+    options: Option<&serde_json::Value>,
+) -> Result<serde_json::Value, String> {
+    let pattern = value.as_str().ok_or_else(|| "$regex must be a string for Elasticsearch filters".to_string())?;
+    let case_insensitive = options
+        .and_then(serde_json::Value::as_str)
+        .is_some_and(|value| value.chars().any(|ch| ch.eq_ignore_ascii_case(&'i')));
+    Ok(serde_json::json!({
+        "wildcard": {
+            field: {
+                "value": wildcard_contains_pattern(pattern),
+                "case_insensitive": case_insensitive
+            }
+        }
+    }))
+}
+
+fn wildcard_contains_pattern(pattern: &str) -> String {
+    if pattern.starts_with('*') || pattern.ends_with('*') {
+        pattern.to_string()
+    } else {
+        format!("*{}*", pattern)
+    }
+}
+
+fn single_or_bool_filter(mut queries: Vec<serde_json::Value>) -> Option<serde_json::Value> {
+    match queries.len() {
+        0 => None,
+        1 => queries.pop(),
+        _ => Some(serde_json::json!({ "bool": { "filter": queries } })),
+    }
+}
+
+fn elasticsearch_sort_from_document_sort(sort: Option<&str>) -> Result<serde_json::Value, String> {
+    let Some(sort) = sort.map(str::trim).filter(|value| !value.is_empty()) else {
+        return Ok(serde_json::json!(["_doc"]));
+    };
+    let value: serde_json::Value = serde_json::from_str(sort).map_err(|e| format!("Invalid sort JSON: {e}"))?;
+    let object = value.as_object().ok_or_else(|| "Elasticsearch sort must be a JSON object".to_string())?;
+    if object.is_empty() {
+        return Ok(serde_json::json!(["_doc"]));
+    }
+
+    let items = object
+        .iter()
+        .map(|(field, direction)| {
+            let order = match direction {
+                serde_json::Value::Number(number) if number.as_i64().unwrap_or(1) < 0 => "desc",
+                serde_json::Value::String(value) if value.eq_ignore_ascii_case("desc") => "desc",
+                _ => "asc",
+            };
+            serde_json::json!({ field: { "order": order } })
+        })
+        .collect::<Vec<_>>();
+    Ok(serde_json::Value::Array(items))
+}
+
+pub async fn insert_document(client: &EsClient, index: &str, doc_json: &str) -> Result<String, String> {
+    let doc = elasticsearch_document_body_from_json(doc_json)?;
+
+    let path = elasticsearch_index_path(index, "_doc?refresh=true");
+    let resp = client.post(&path).json(&doc).send().await.map_err(|e| format!("Elasticsearch request failed: {e}"))?;
+
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        return Err(format!("Elasticsearch error: {body}"));
+    }
+
+    let result: serde_json::Value = resp.json().await.map_err(|e| format!("Elasticsearch parse error: {e}"))?;
+    Ok(result["_id"].as_str().unwrap_or("").to_string())
+}
+
+pub async fn update_document(
+    client: &EsClient,
+    index: &str,
+    id: &str,
+    doc_json: &str,
+    routing: Option<&str>,
+) -> Result<u64, String> {
+    let (doc, routing) = elasticsearch_document_body_and_routing_from_json(doc_json, routing)?;
+
+    let path = elasticsearch_document_path(index, id, routing.as_deref());
+    let resp = client.put(&path).json(&doc).send().await.map_err(|e| format!("Elasticsearch request failed: {e}"))?;
+
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        return Err(format!("Elasticsearch error: {body}"));
+    }
+
+    Ok(1)
+}
+
+fn elasticsearch_document_body_from_json(doc_json: &str) -> Result<serde_json::Value, String> {
+    elasticsearch_document_body_and_routing_from_json(doc_json, None).map(|(doc, _)| doc)
+}
+
+fn elasticsearch_document_body_and_routing_from_json(
+    doc_json: &str,
+    routing: Option<&str>,
+) -> Result<(serde_json::Value, Option<String>), String> {
+    let mut doc: serde_json::Value = serde_json::from_str(doc_json).map_err(|e| format!("Invalid JSON: {e}"))?;
+    let mut routing = routing.map(str::trim).filter(|value| !value.is_empty()).map(str::to_string);
+    if let serde_json::Value::Object(map) = &mut doc {
+        map.remove("_id");
+        if routing.is_none() {
+            routing = map.get("_routing").and_then(elasticsearch_routing_from_value);
+        }
+        map.remove("_routing");
+    }
+    Ok((doc, routing))
+}
+
+fn elasticsearch_routing_from_value(value: &serde_json::Value) -> Option<String> {
+    match value {
+        serde_json::Value::String(value) => {
+            let trimmed = value.trim();
+            (!trimmed.is_empty()).then(|| trimmed.to_string())
+        }
+        _ => None,
+    }
+}
+
+pub async fn delete_document(client: &EsClient, index: &str, id: &str, routing: Option<&str>) -> Result<u64, String> {
+    let path = elasticsearch_document_path(index, id, routing);
+    let resp = client.delete(&path).send().await.map_err(|e| format!("Elasticsearch request failed: {e}"))?;
+
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        return Err(format!("Elasticsearch error: {body}"));
+    }
+
+    Ok(1)
+}
+
+pub async fn execute_rest_query(client: &EsClient, input: &str) -> Result<crate::types::QueryResult, String> {
+    let start = std::time::Instant::now();
+    let input = input.trim();
+
+    if let Some(search_query) = parse_select_star_search_query(input) {
+        return execute_search_query(client, search_query, start).await;
+    }
+
+    if is_elasticsearch_sql_query(input) {
+        // `SELECT *` with clauses our simple parser doesn't cover (WHERE, IN,
+        // BETWEEN, LIKE, ...). Translate the SQL to an ES `_search` body
+        // ourselves rather than going through ES's `_sql` endpoint — `_sql`
+        // refuses several common shapes (LIKE on a `text` field with no
+        // `.keyword`, `SELECT *` returning an array field like `host.ip`, ...)
+        // that translate cleanly to raw DSL. Adapt first so that hyphenated
+        // index names (`aifanfan-python-bot-logs-*`) and `@timestamp`-style
+        // identifiers come out as double-quoted identifiers sqlparser will
+        // accept.
+        let adapted_for_translator = adapt_elasticsearch_sql_query(input);
+        match crate::db::elasticsearch_sql::translate_select_star(&adapted_for_translator) {
+            Ok(Some(translated)) => {
+                return execute_translated_select_star(client, translated, start).await;
+            }
+            Ok(None) => {}
+            Err(message) => return Err(format!("Elasticsearch SQL error: {message}")),
+        }
+
+        return execute_sql_query(client, input, start).await;
+    }
+
+    let (method, rest) = input.split_once(char::is_whitespace).ok_or("Invalid query: expected METHOD /path")?;
+    let method = method.to_uppercase();
+
+    let (path, body) = if let Some(pos) = rest.find('\n') {
+        let p = rest[..pos].trim();
+        let b = rest[pos + 1..].trim();
+        (p, if b.is_empty() { None } else { Some(b) })
+    } else {
+        (rest.trim(), None)
+    };
+
+    let path = if path.starts_with('/') { path.to_string() } else { format!("/{path}") };
+
+    let resp = match method.as_str() {
+        "GET" => {
+            let req = client.get(&path);
+            if let Some(b) = body {
+                let json: serde_json::Value = serde_json::from_str(b).map_err(|e| format!("Invalid JSON body: {e}"))?;
+                req.json(&json).send().await
+            } else {
+                req.send().await
+            }
+        }
+        "POST" => {
+            let req = client.post(&path);
+            if let Some(b) = body {
+                let json: serde_json::Value = serde_json::from_str(b).map_err(|e| format!("Invalid JSON body: {e}"))?;
+                req.json(&json).send().await
+            } else {
+                req.send().await
+            }
+        }
+        "PUT" => {
+            let req = client.put(&path);
+            if let Some(b) = body {
+                let json: serde_json::Value = serde_json::from_str(b).map_err(|e| format!("Invalid JSON body: {e}"))?;
+                req.json(&json).send().await
+            } else {
+                req.send().await
+            }
+        }
+        "DELETE" => {
+            let req = client.delete(&path);
+            if let Some(b) = body {
+                let json: serde_json::Value = serde_json::from_str(b).map_err(|e| format!("Invalid JSON body: {e}"))?;
+                req.json(&json).send().await
+            } else {
+                req.send().await
+            }
+        }
+        _ => return Err(format!("Unsupported HTTP method: {method}. Use GET, POST, PUT, or DELETE.")),
+    }
+    .map_err(|e| format!("Elasticsearch request failed: {e}"))?;
+
+    let status = resp.status().as_u16();
+    let body = resp.text().await.map_err(|e| format!("Elasticsearch response read failed: {e}"))?;
+
+    parse_elasticsearch_rest_response(status, &body, start)
+}
+
+// Size to use when `SELECT *` is run without an explicit LIMIT — large enough
+// to be useful, small enough that the user doesn't accidentally pull millions
+// of documents. The result-grid surfaces the index's true total separately so
+// the user can see how much was actually held back.
+const AUTO_PAGED_SELECT_STAR_SIZE: usize = 100;
+
+struct ElasticsearchSearchQuery {
+    index: String,
+    body: serde_json::Value,
+    // True when the SQL came through the pagination plan (it carries OFFSET).
+    // In that case the result-grid total must reflect the index's true match
+    // count so the front-end can compute the total page count. A bare
+    // user-written `LIMIT N` (no OFFSET) is the "give me exactly N rows" case
+    // and reports affected_rows = N for client-side paging.
+    from_plan_pagination: bool,
+}
+
+async fn execute_search_query(
+    client: &EsClient,
+    query: ElasticsearchSearchQuery,
+    start: std::time::Instant,
+) -> Result<crate::types::QueryResult, String> {
+    let report_index_total = query.from_plan_pagination;
+    let path = elasticsearch_index_path(&query.index, "_search");
+    let resp =
+        client.post(&path).json(&query.body).send().await.map_err(|e| format!("Elasticsearch request failed: {e}"))?;
+    let status = resp.status().as_u16();
+    let body: serde_json::Value = resp.json().await.unwrap_or_else(|_| serde_json::Value::Null);
+    // Capture the index's true match total before the body is consumed by the
+    // parser — needed below when we report total instead of rows.len().
+    let index_total = body.pointer("/hits/total/value").and_then(|v| v.as_u64());
+
+    let mut result = parse_elasticsearch_response(status, body, start)?;
+    if report_index_total {
+        if let Some(total) = index_total {
+            result.affected_rows = total;
+        }
+    }
+    Ok(result)
+}
+
+fn parse_elasticsearch_response(
+    status: u16,
+    body: serde_json::Value,
+    start: std::time::Instant,
+) -> Result<crate::types::QueryResult, String> {
+    if let Some(result) = parse_sql_response(&body, start) {
+        Ok(result)
+    } else if let Some(aggs) = body.get("aggregations").or_else(|| body.get("aggs")).and_then(|v| v.as_object()) {
+        let (columns, rows) = parse_aggregations(aggs);
+        if !columns.is_empty() {
+            let row_count = rows.len() as u64;
+            Ok(crate::types::QueryResult {
+                columns,
+                column_types: Vec::new(),
+                column_sortables: vec![],
+                rows,
+                affected_rows: row_count,
+                execution_time_ms: start.elapsed().as_millis(),
+                truncated: false,
+                session_id: None,
+                has_more: false,
+            })
+        } else {
+            Ok(json_response_result(status, &body, start))
+        }
+    } else if let Some(hits) = body.pointer("/hits/hits").and_then(|v| v.as_array()) {
+        // Treat any `_search`-shaped body as the hits result, even when empty —
+        // a 0-row match is a valid empty result, not a reason to fall back to
+        // the raw-JSON status/response view.
+        let mut all_keys = Vec::<String>::new();
+        let docs: Vec<serde_json::Map<String, serde_json::Value>> = hits
+            .iter()
+            .map(|hit| {
+                let mut row = serde_json::Map::new();
+                if let Some(source) = hit.get("_source").and_then(|s| s.as_object()) {
+                    for (k, v) in source {
+                        row.insert(k.clone(), v.clone());
+                    }
+                }
+                row.insert("_id".to_string(), hit.get("_id").cloned().unwrap_or(serde_json::Value::Null));
+                if let Some(routing) = hit.get("_routing") {
+                    row.insert("_routing".to_string(), routing.clone());
+                }
+                for k in row.keys() {
+                    if !all_keys.contains(k) {
+                        all_keys.push(k.clone());
+                    }
+                }
+                row
+            })
+            .collect();
+        if all_keys.is_empty() {
+            // 0 hits → there's no doc to derive columns from; surface `_id`
+            // so the grid at least shows a column header for the empty set.
+            all_keys.push("_id".to_string());
+        }
+
+        let rows: Vec<Vec<serde_json::Value>> = docs
+            .iter()
+            .map(|doc| {
+                all_keys
+                    .iter()
+                    .map(|k| {
+                        doc.get(k)
+                            .map(|v| match v {
+                                serde_json::Value::String(s) => serde_json::Value::String(s.clone()),
+                                other => serde_json::Value::String(other.to_string()),
+                            })
+                            .unwrap_or(serde_json::Value::Null)
+                    })
+                    .collect()
+            })
+            .collect();
+
+        let row_count = rows.len() as u64;
+
+        Ok(crate::types::QueryResult {
+            columns: all_keys,
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows,
+            affected_rows: row_count,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    } else {
+        Ok(json_response_result(status, &body, start))
+    }
+}
+
+fn json_response_result(status: u16, body: &serde_json::Value, start: std::time::Instant) -> crate::types::QueryResult {
+    let body_text = serde_json::to_string_pretty(body).unwrap_or_else(|_| body.to_string());
+    raw_json_response_result(status, body_text, start)
+}
+
+fn raw_json_response_result(
+    status: u16,
+    body_text: impl Into<String>,
+    start: std::time::Instant,
+) -> crate::types::QueryResult {
+    crate::types::QueryResult {
+        columns: vec!["status".to_string(), "response".to_string()],
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: vec![vec![serde_json::Value::Number(status.into()), serde_json::Value::String(body_text.into())]],
+        affected_rows: 0,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    }
+}
+
+fn parse_elasticsearch_rest_response(
+    status: u16,
+    body_text: &str,
+    start: std::time::Instant,
+) -> Result<crate::types::QueryResult, String> {
+    if body_text.trim().is_empty() {
+        return Ok(json_response_result(status, &serde_json::Value::Null, start));
+    }
+
+    if serde_json::from_str::<serde_json::Value>(body_text).is_ok() {
+        // Validate the payload as JSON, but retain the HTTP body verbatim so
+        // numeric literals are not changed by a parse/serialize round trip.
+        return Ok(raw_json_response_result(status, body_text, start));
+    }
+
+    // CAT APIs default to text/plain for human-readable output. Keep those
+    // responses visible instead of dropping them when JSON parsing is not valid.
+    let rows: Vec<Vec<serde_json::Value>> =
+        body_text.lines().map(|line| vec![serde_json::Value::String(line.to_string())]).collect();
+    let affected_rows = rows.len() as u64;
+    Ok(crate::types::QueryResult {
+        columns: vec!["response".to_string()],
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows,
+        affected_rows,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+fn parse_select_star_search_query(input: &str) -> Option<ElasticsearchSearchQuery> {
+    let mut cursor = skip_sql_whitespace(input, 0);
+    cursor = consume_sql_keyword(input, cursor, "select")?;
+    cursor = skip_sql_whitespace(input, cursor);
+    if next_char_at(input, cursor)? != '*' {
+        return None;
+    }
+    cursor += '*'.len_utf8();
+    cursor = skip_sql_whitespace(input, cursor);
+    cursor = consume_sql_keyword(input, cursor, "from")?;
+    cursor = skip_sql_whitespace(input, cursor);
+
+    let (index, next_cursor) = read_sql_token(input, cursor)?;
+    cursor = next_cursor;
+
+    let mut sort_field = None;
+    let mut sort_order = "asc";
+    let mut limit = None;
+    let mut offset: Option<usize> = None;
+
+    loop {
+        cursor = skip_sql_whitespace(input, cursor);
+        if cursor >= input.len() {
+            break;
+        }
+        if next_char_at(input, cursor) == Some(';') {
+            cursor += ';'.len_utf8();
+            cursor = skip_sql_whitespace(input, cursor);
+            if cursor == input.len() {
+                break;
+            }
+            return None;
+        }
+
+        if is_keyword_at(input, cursor, "order") {
+            cursor = consume_sql_keyword(input, cursor, "order")?;
+            cursor = skip_sql_whitespace(input, cursor);
+            cursor = consume_sql_keyword(input, cursor, "by")?;
+            cursor = skip_sql_whitespace(input, cursor);
+            let (field, next_cursor) = read_sql_token(input, cursor)?;
+            sort_field = Some(field);
+            cursor = skip_sql_whitespace(input, next_cursor);
+            if is_keyword_at(input, cursor, "asc") {
+                sort_order = "asc";
+                cursor = consume_sql_keyword(input, cursor, "asc")?;
+            } else if is_keyword_at(input, cursor, "desc") {
+                sort_order = "desc";
+                cursor = consume_sql_keyword(input, cursor, "desc")?;
+            }
+        } else if is_keyword_at(input, cursor, "limit") {
+            cursor = consume_sql_keyword(input, cursor, "limit")?;
+            cursor = skip_sql_whitespace(input, cursor);
+            let (value, next_cursor) = read_while(input, cursor, |ch| ch.is_ascii_digit());
+            limit = value.parse::<usize>().ok();
+            cursor = next_cursor;
+        } else if is_keyword_at(input, cursor, "offset") {
+            cursor = consume_sql_keyword(input, cursor, "offset")?;
+            cursor = skip_sql_whitespace(input, cursor);
+            let (value, next_cursor) = read_while(input, cursor, |ch| ch.is_ascii_digit());
+            offset = value.parse::<usize>().ok();
+            cursor = next_cursor;
+        } else {
+            return None;
+        }
+    }
+
+    // The pagination plan emits `LIMIT N OFFSET M` (always with OFFSET, even
+    // when 0) for ES; a user-written SQL that only has `LIMIT N` leaves
+    // OFFSET absent. We use that as the signal for whether the front-end is
+    // driving server-side pagination — in that case affected_rows must reflect
+    // the index's true total so the grid can compute the total page count.
+    let from_plan_pagination = offset.is_some();
+    let effective_size = limit.unwrap_or(AUTO_PAGED_SELECT_STAR_SIZE);
+    let effective_from = offset.unwrap_or(0);
+    let mut body = serde_json::Map::new();
+    body.insert("size".to_string(), serde_json::json!(effective_size));
+    if effective_from > 0 {
+        body.insert("from".to_string(), serde_json::json!(effective_from));
+    }
+
+    if let Some(field) = sort_field {
+        let mut sort_item = serde_json::Map::new();
+        sort_item.insert(field, serde_json::json!({ "order": sort_order }));
+        body.insert("sort".to_string(), serde_json::Value::Array(vec![serde_json::Value::Object(sort_item)]));
+    }
+
+    Some(ElasticsearchSearchQuery { index, body: serde_json::Value::Object(body), from_plan_pagination })
+}
+
+fn is_elasticsearch_sql_query(input: &str) -> bool {
+    input
+        .trim_start()
+        .split_once(char::is_whitespace)
+        .map(|(keyword, _)| keyword.eq_ignore_ascii_case("select"))
+        .unwrap_or_else(|| input.trim_start().eq_ignore_ascii_case("select"))
+}
+
+async fn execute_translated_select_star(
+    client: &EsClient,
+    translated: crate::db::elasticsearch_sql::TranslatedSelectStar,
+    start: std::time::Instant,
+) -> Result<crate::types::QueryResult, String> {
+    let report_index_total = !translated.user_limited;
+    let path = elasticsearch_index_path(&translated.index, "_search");
+    let resp = client
+        .post(&path)
+        .json(&translated.body)
+        .send()
+        .await
+        .map_err(|e| format!("Elasticsearch request failed: {e}"))?;
+    let status = resp.status().as_u16();
+    let body: serde_json::Value = resp.json().await.unwrap_or_else(|_| serde_json::Value::Null);
+    let index_total = body.pointer("/hits/total/value").and_then(|v| v.as_u64());
+
+    let mut result = parse_elasticsearch_response(status, body, start)?;
+    if report_index_total {
+        if let Some(total) = index_total {
+            result.affected_rows = total;
+        }
+    }
+    Ok(result)
+}
+
+async fn execute_sql_query(
+    client: &EsClient,
+    query: &str,
+    start: std::time::Instant,
+) -> Result<crate::types::QueryResult, String> {
+    let query = adapt_elasticsearch_sql_query(query);
+    let body = serde_json::json!({ "query": query });
+    let resp =
+        client.post("/_sql").json(&body).send().await.map_err(|e| format!("Elasticsearch request failed: {e}"))?;
+    let status = resp.status();
+    let response_body: serde_json::Value = resp.json().await.unwrap_or_else(|_| serde_json::Value::Null);
+
+    if !status.is_success() {
+        return Err(format_sql_error(status, &response_body));
+    }
+
+    parse_sql_response(&response_body, start).ok_or_else(|| {
+        let pretty = serde_json::to_string_pretty(&response_body).unwrap_or_else(|_| response_body.to_string());
+        format!("Unexpected Elasticsearch SQL response: {pretty}")
+    })
+}
+
+fn adapt_elasticsearch_sql_query(query: &str) -> String {
+    let mut output = String::with_capacity(query.len());
+    let mut index = 0;
+    let mut state = SqlScanState::Normal;
+
+    while let Some(ch) = next_char_at(query, index) {
+        match state {
+            SqlScanState::Normal => match ch {
+                '\'' => {
+                    output.push(ch);
+                    index += ch.len_utf8();
+                    state = SqlScanState::SingleQuoted;
+                }
+                '"' => {
+                    output.push(ch);
+                    index += ch.len_utf8();
+                    state = SqlScanState::DoubleQuoted;
+                }
+                '`' => {
+                    output.push(ch);
+                    index += ch.len_utf8();
+                    state = SqlScanState::BacktickQuoted;
+                }
+                '-' if query[index..].starts_with("--") => {
+                    output.push_str("--");
+                    index += 2;
+                    state = SqlScanState::LineComment;
+                }
+                '/' if query[index..].starts_with("/*") => {
+                    output.push_str("/*");
+                    index += 2;
+                    state = SqlScanState::BlockComment;
+                }
+                '@' if is_at_identifier_boundary(&output) => {
+                    let (identifier, next_index) = read_while(query, index, is_elasticsearch_identifier_part);
+                    output.push('"');
+                    output.push_str(identifier);
+                    output.push('"');
+                    index = next_index;
+                }
+                _ => {
+                    if let Some(keyword) = relation_keyword_at(query, index) {
+                        index = quote_relation_after_keyword(query, index, keyword, &mut output);
+                    } else {
+                        output.push(ch);
+                        index += ch.len_utf8();
+                    }
+                }
+            },
+            SqlScanState::SingleQuoted => {
+                if copy_quoted_char(query, &mut index, ch, '\'', &mut output) {
+                    state = SqlScanState::Normal;
+                }
+            }
+            SqlScanState::DoubleQuoted => {
+                if copy_quoted_char(query, &mut index, ch, '"', &mut output) {
+                    state = SqlScanState::Normal;
+                }
+            }
+            SqlScanState::BacktickQuoted => {
+                if copy_quoted_char(query, &mut index, ch, '`', &mut output) {
+                    state = SqlScanState::Normal;
+                }
+            }
+            SqlScanState::LineComment => {
+                output.push(ch);
+                index += ch.len_utf8();
+                if ch == '\n' {
+                    state = SqlScanState::Normal;
+                }
+            }
+            SqlScanState::BlockComment => {
+                if query[index..].starts_with("*/") {
+                    output.push_str("*/");
+                    index += 2;
+                    state = SqlScanState::Normal;
+                } else {
+                    output.push(ch);
+                    index += ch.len_utf8();
+                }
+            }
+        }
+    }
+
+    output
+}
+
+fn quote_relation_after_keyword(query: &str, index: usize, keyword: &str, output: &mut String) -> usize {
+    let mut cursor = index + keyword.len();
+    output.push_str(&query[index..cursor]);
+
+    while let Some(ch) = next_char_at(query, cursor) {
+        if !ch.is_whitespace() {
+            break;
+        }
+        output.push(ch);
+        cursor += ch.len_utf8();
+    }
+
+    if matches!(next_char_at(query, cursor), Some('"' | '`' | '\'' | '(')) {
+        return cursor;
+    }
+
+    let relation_start = cursor;
+    while let Some(ch) = next_char_at(query, cursor) {
+        if !is_relation_name_char(ch) {
+            break;
+        }
+        cursor += ch.len_utf8();
+    }
+
+    let relation = &query[relation_start..cursor];
+    if relation_name_needs_quotes(relation) {
+        output.push('"');
+        output.push_str(relation);
+        output.push('"');
+    } else {
+        output.push_str(relation);
+    }
+
+    cursor
+}
+
+fn copy_quoted_char(query: &str, index: &mut usize, ch: char, quote: char, output: &mut String) -> bool {
+    output.push(ch);
+    *index += ch.len_utf8();
+
+    if ch != quote {
+        return false;
+    }
+
+    if next_char_at(query, *index).is_some_and(|next| next == quote) {
+        output.push(quote);
+        *index += quote.len_utf8();
+        false
+    } else {
+        true
+    }
+}
+
+fn read_while(query: &str, start: usize, predicate: fn(char) -> bool) -> (&str, usize) {
+    let mut cursor = start;
+    while let Some(ch) = next_char_at(query, cursor) {
+        if !predicate(ch) {
+            break;
+        }
+        cursor += ch.len_utf8();
+    }
+
+    (&query[start..cursor], cursor)
+}
+
+fn skip_sql_whitespace(query: &str, mut cursor: usize) -> usize {
+    while let Some(ch) = next_char_at(query, cursor) {
+        if !ch.is_whitespace() {
+            break;
+        }
+        cursor += ch.len_utf8();
+    }
+
+    cursor
+}
+
+fn consume_sql_keyword(query: &str, cursor: usize, keyword: &str) -> Option<usize> {
+    is_keyword_at(query, cursor, keyword).then_some(cursor + keyword.len())
+}
+
+fn read_sql_token(query: &str, cursor: usize) -> Option<(String, usize)> {
+    let quote = match next_char_at(query, cursor)? {
+        '"' => Some('"'),
+        '`' => Some('`'),
+        _ => None,
+    };
+
+    if let Some(quote) = quote {
+        let mut output = String::new();
+        let mut next_cursor = cursor + quote.len_utf8();
+        while let Some(ch) = next_char_at(query, next_cursor) {
+            next_cursor += ch.len_utf8();
+            if ch == quote {
+                if next_char_at(query, next_cursor).is_some_and(|next| next == quote) {
+                    output.push(quote);
+                    next_cursor += quote.len_utf8();
+                } else {
+                    return Some((output, next_cursor));
+                }
+            } else {
+                output.push(ch);
+            }
+        }
+        return None;
+    }
+
+    let (token, next_cursor) = read_while(query, cursor, is_relation_name_char);
+    (!token.is_empty()).then(|| (token.to_string(), next_cursor))
+}
+
+fn relation_keyword_at(query: &str, index: usize) -> Option<&'static str> {
+    ["from", "join"].into_iter().find(|keyword| is_keyword_at(query, index, keyword))
+}
+
+#[derive(Clone, Copy)]
+enum SqlScanState {
+    Normal,
+    SingleQuoted,
+    DoubleQuoted,
+    BacktickQuoted,
+    LineComment,
+    BlockComment,
+}
+
+fn is_at_identifier_boundary(output: &str) -> bool {
+    output.chars().next_back().is_none_or(|ch| !is_sql_identifier_part(ch))
+}
+
+fn is_sql_identifier_part(ch: char) -> bool {
+    ch.is_ascii_alphanumeric() || matches!(ch, '_' | '.')
+}
+
+fn is_elasticsearch_identifier_part(ch: char) -> bool {
+    ch.is_ascii_alphanumeric() || matches!(ch, '_' | '.' | '-' | '@')
+}
+
+fn is_relation_name_char(ch: char) -> bool {
+    !ch.is_whitespace() && !matches!(ch, ',' | ';' | '(' | ')')
+}
+
+fn relation_name_needs_quotes(relation: &str) -> bool {
+    relation.chars().any(|ch| matches!(ch, '-' | '*' | '@'))
+}
+
+fn is_keyword_at(query: &str, index: usize, keyword: &str) -> bool {
+    query.get(index..index + keyword.len()).is_some_and(|candidate| candidate.eq_ignore_ascii_case(keyword))
+        && query[..index].chars().next_back().is_none_or(|ch| !is_keyword_boundary_char(ch))
+        && query[index + keyword.len()..].chars().next().is_none_or(|ch| !is_keyword_boundary_char(ch))
+}
+
+fn is_keyword_boundary_char(ch: char) -> bool {
+    ch.is_ascii_alphanumeric() || ch == '_'
+}
+
+fn next_char_at(query: &str, index: usize) -> Option<char> {
+    query.get(index..)?.chars().next()
+}
+
+fn parse_sql_response(body: &serde_json::Value, start: std::time::Instant) -> Option<crate::types::QueryResult> {
+    let columns = body.get("columns")?.as_array()?;
+    let rows = body.get("rows")?.as_array()?;
+    let column_names: Vec<String> = columns
+        .iter()
+        .filter_map(|column| column.get("name").and_then(|name| name.as_str()).map(str::to_string))
+        .collect();
+
+    if column_names.is_empty() && !columns.is_empty() {
+        return None;
+    }
+
+    let result_rows: Vec<Vec<serde_json::Value>> =
+        rows.iter().filter_map(|row| row.as_array().map(|values| values.to_vec())).collect();
+
+    Some(crate::types::QueryResult {
+        columns: column_names,
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: result_rows,
+        affected_rows: rows.len() as u64,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated: false,
+        session_id: body.get("cursor").and_then(|cursor| cursor.as_str()).map(str::to_string),
+        has_more: body.get("cursor").and_then(|cursor| cursor.as_str()).is_some(),
+    })
+}
+
+fn format_sql_error(status: reqwest::StatusCode, body: &serde_json::Value) -> String {
+    let detail = body
+        .pointer("/error/reason")
+        .and_then(|reason| reason.as_str())
+        .map(str::to_string)
+        .unwrap_or_else(|| serde_json::to_string_pretty(body).unwrap_or_else(|_| body.to_string()));
+
+    if status == reqwest::StatusCode::NOT_FOUND {
+        format!("Elasticsearch SQL API is not available ({status}): {detail}")
+    } else {
+        format!("Elasticsearch SQL error ({status}): {detail}")
+    }
+}
+
+fn parse_aggregations(aggs: &serde_json::Map<String, serde_json::Value>) -> (Vec<String>, Vec<Vec<serde_json::Value>>) {
+    for (_name, agg_value) in aggs {
+        if let Some(buckets) = agg_value.get("buckets").and_then(|b| b.as_array()) {
+            if buckets.is_empty() {
+                continue;
+            }
+            let mut all_keys = Vec::<String>::new();
+            let mut bucket_rows = Vec::new();
+
+            for bucket in buckets {
+                if let Some(obj) = bucket.as_object() {
+                    let mut row = serde_json::Map::new();
+                    for (k, v) in obj {
+                        if let Some(sub) = v.as_object() {
+                            if let Some(val) = sub.get("value") {
+                                row.insert(k.clone(), val.clone());
+                            } else {
+                                row.insert(k.clone(), serde_json::Value::String(v.to_string()));
+                            }
+                        } else {
+                            row.insert(k.clone(), v.clone());
+                        }
+                    }
+                    for key in row.keys() {
+                        if !all_keys.contains(key) {
+                            all_keys.push(key.clone());
+                        }
+                    }
+                    bucket_rows.push(row);
+                }
+            }
+
+            let rows = bucket_rows
+                .iter()
+                .map(|br| {
+                    all_keys
+                        .iter()
+                        .map(|k| {
+                            br.get(k)
+                                .map(|v| match v {
+                                    serde_json::Value::String(s) => serde_json::Value::String(s.clone()),
+                                    other => serde_json::Value::String(other.to_string()),
+                                })
+                                .unwrap_or(serde_json::Value::Null)
+                        })
+                        .collect()
+                })
+                .collect();
+
+            return (all_keys, rows);
+        }
+    }
+
+    let mut columns = Vec::new();
+    let mut values = Vec::new();
+    for (name, agg_value) in aggs {
+        if let Some(obj) = agg_value.as_object() {
+            if let Some(val) = obj.get("value") {
+                columns.push(name.clone());
+                values.push(match val {
+                    serde_json::Value::String(s) => serde_json::Value::String(s.clone()),
+                    other => serde_json::Value::String(other.to_string()),
+                });
+            }
+        }
+    }
+    if !columns.is_empty() {
+        return (columns, vec![values]);
+    }
+
+    (Vec::new(), Vec::new())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        build_find_documents_body, elasticsearch_accept_invalid_certs, elasticsearch_base_url_fallbacks,
+        redact_elasticsearch_url, EsClient, SearchResponse,
+    };
+    use serde_json::json;
+    use std::time::Duration;
+
+    async fn read_http_request(socket: &mut tokio::net::TcpStream) -> String {
+        use tokio::io::AsyncReadExt;
+
+        let mut bytes = Vec::new();
+        let mut buffer = [0_u8; 1024];
+        loop {
+            let read = socket.read(&mut buffer).await.unwrap();
+            assert!(read > 0, "HTTP request ended before its body was received");
+            bytes.extend_from_slice(&buffer[..read]);
+
+            let Some(headers_end) = bytes.windows(4).position(|window| window == b"\r\n\r\n") else {
+                continue;
+            };
+            let content_length = std::str::from_utf8(&bytes[..headers_end])
+                .unwrap()
+                .lines()
+                .find_map(|line| {
+                    let (name, value) = line.split_once(':')?;
+                    name.eq_ignore_ascii_case("content-length").then(|| value.trim().parse::<usize>().unwrap())
+                })
+                .unwrap_or(0);
+            let request_end = headers_end + 4 + content_length;
+            if bytes.len() >= request_end {
+                bytes.truncate(request_end);
+                return String::from_utf8(bytes).unwrap();
+            }
+        }
+    }
+
+    #[test]
+    fn url_params_can_disable_elasticsearch_tls_verification() {
+        assert!(elasticsearch_accept_invalid_certs(false, Some("sslmode=disable")));
+        assert!(elasticsearch_accept_invalid_certs(false, Some("?tlsVerify=false")));
+        assert!(elasticsearch_accept_invalid_certs(false, Some("verify=0")));
+        assert!(elasticsearch_accept_invalid_certs(false, Some("insecure=true")));
+        assert!(elasticsearch_accept_invalid_certs(false, Some("accept_invalid_certs=on")));
+        assert!(!elasticsearch_accept_invalid_certs(false, Some("sslmode=require&verify=true")));
+    }
+
+    #[test]
+    fn tls_checkbox_keeps_legacy_insecure_elasticsearch_behavior() {
+        assert!(elasticsearch_accept_invalid_certs(true, None));
+    }
+
+    #[test]
+    fn localhost_elasticsearch_url_falls_back_to_ipv4_loopback() {
+        assert_eq!(
+            elasticsearch_base_url_fallbacks("https://localhost:9200"),
+            vec!["https://127.0.0.1:9200".to_string()]
+        );
+        assert_eq!(elasticsearch_base_url_fallbacks("https://search.example.com:9200"), Vec::<String>::new());
+    }
+
+    #[test]
+    fn elasticsearch_client_from_config_uses_url_params_for_tls_verification() {
+        let client = EsClient::from_config(
+            "https://localhost:9200/",
+            Some("elastic"),
+            Some("secret"),
+            false,
+            Some("sslmode=disable"),
+            Duration::from_secs(1),
+        );
+
+        assert_eq!(client.base_url, "https://localhost:9200");
+        assert_eq!(client.fallback_base_urls, vec!["https://127.0.0.1:9200"]);
+    }
+
+    #[test]
+    fn redacts_elasticsearch_url_credentials_in_errors() {
+        assert_eq!(
+            redact_elasticsearch_url("https://elastic:secret@localhost:9200"),
+            "https://user:password@localhost:9200"
+        );
+    }
+
+    #[test]
+    fn encodes_elasticsearch_index_path_segments() {
+        assert_eq!(super::elasticsearch_index_path("%kuzzle.users", "_search"), "/%25kuzzle.users/_search");
+        assert_eq!(super::elasticsearch_index_path("logs-*", "_search"), "/logs-*/_search");
+        assert_eq!(super::elasticsearch_index_path("logs/2026", "_mapping"), "/logs%2F2026/_mapping");
+    }
+
+    #[test]
+    fn encodes_elasticsearch_document_id_path_segment() {
+        assert_eq!(super::elasticsearch_path_segment("a%b/c"), "a%25b%2Fc");
+    }
+
+    #[test]
+    fn builds_elasticsearch_document_path_with_routing() {
+        assert_eq!(
+            super::elasticsearch_document_path("orders/2026", "a%b/c", Some("tenant/a&b")),
+            "/orders%2F2026/_doc/a%25b%2Fc?routing=tenant%2Fa%26b&refresh=true"
+        );
+        assert_eq!(super::elasticsearch_document_path("orders", "1", None), "/orders/_doc/1?refresh=true");
+    }
+
+    #[test]
+    fn elasticsearch_sql_detection_does_not_treat_rest_methods_as_sql() {
+        assert!(super::is_elasticsearch_sql_query("SELECT * FROM index_task_v1"));
+        assert!(super::is_elasticsearch_sql_query(" select count(*) from index_task_v1"));
+        assert!(!super::is_elasticsearch_sql_query("GET /index_task_v1/_mapping"));
+        assert!(!super::is_elasticsearch_sql_query("POST /index_task_v1/_search\n{}"));
+        assert!(!super::is_elasticsearch_sql_query("DELETE /index_task_v1/_doc/1"));
+    }
+
+    #[test]
+    fn builds_elasticsearch_find_body_with_filter_and_sort() {
+        let body = build_find_documents_body(20, 10, Some(r#"{"city":"长治"}"#), Some(r#"{"created_at":-1}"#)).unwrap();
+
+        assert_eq!(
+            body,
+            json!({
+                "from": 20,
+                "size": 10,
+                "query": { "term": { "city": "长治" } },
+                "sort": [{ "created_at": { "order": "desc" } }]
+            })
+        );
+    }
+
+    #[test]
+    fn builds_elasticsearch_find_body_with_structured_filter_operators() {
+        let body = build_find_documents_body(
+            0,
+            100,
+            Some(
+                r#"{
+                    "$and": [
+                        {"city": {"$ne": "上海"}},
+                        {"age": {"$gt": 18, "$lte": 60}},
+                        {"name": {"$not": {"$regex": "test", "$options": "i"}}}
+                    ]
+                }"#,
+            ),
+            None,
+        )
+        .unwrap();
+
+        assert_eq!(
+            body,
+            json!({
+                "from": 0,
+                "size": 100,
+                "query": {
+                    "bool": {
+                        "filter": [
+                            { "bool": { "must_not": [{ "term": { "city": "上海" } }] } },
+                            { "range": { "age": { "gt": 18, "lte": 60 } } },
+                            {
+                                "bool": {
+                                    "must_not": [
+                                        {
+                                            "wildcard": {
+                                                "name": {
+                                                    "value": "*test*",
+                                                    "case_insensitive": true
+                                                }
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        ]
+                    }
+                },
+                "sort": ["_doc"]
+            })
+        );
+    }
+
+    #[test]
+    fn builds_elasticsearch_find_body_with_or_filter() {
+        let body =
+            build_find_documents_body(0, 50, Some(r#"{"$or":[{"city":"长治"},{"city":"上海"}]}"#), None).unwrap();
+
+        assert_eq!(
+            body["query"],
+            json!({
+                "bool": {
+                    "should": [
+                        { "term": { "city": "长治" } },
+                        { "term": { "city": "上海" } }
+                    ],
+                    "minimum_should_match": 1
+                }
+            })
+        );
+    }
+
+    #[test]
+    fn parses_search_total_from_elasticsearch_6_number_shape() {
+        let response: SearchResponse = serde_json::from_value(json!({
+            "hits": {
+                "total": 5,
+                "hits": []
+            }
+        }))
+        .unwrap();
+
+        assert_eq!(response.hits.total.value(), 5);
+    }
+
+    #[test]
+    fn parses_search_total_from_elasticsearch_7_object_shape() {
+        let response: SearchResponse = serde_json::from_value(json!({
+            "hits": {
+                "total": { "value": 5, "relation": "eq" },
+                "hits": []
+            }
+        }))
+        .unwrap();
+
+        assert_eq!(response.hits.total.value(), 5);
+    }
+
+    #[test]
+    fn parses_elasticsearch_hit_routing_metadata() {
+        let response: SearchResponse = serde_json::from_value(json!({
+            "hits": {
+                "total": { "value": 1, "relation": "eq" },
+                "hits": [
+                    { "_id": "doc-1", "_routing": "tenant-1", "_source": { "name": "Alice" } }
+                ]
+            }
+        }))
+        .unwrap();
+
+        assert_eq!(response.hits.hits[0].routing.as_deref(), Some("tenant-1"));
+    }
+
+    #[test]
+    fn parses_search_response_rows_with_routing_metadata() {
+        let result = super::parse_elasticsearch_response(
+            200,
+            json!({
+                "hits": {
+                    "hits": [
+                        { "_id": "doc-1", "_routing": "tenant-1", "_source": { "name": "Alice" } }
+                    ]
+                }
+            }),
+            std::time::Instant::now(),
+        )
+        .unwrap();
+
+        assert_ne!(result.columns, vec!["status", "response"]);
+        let name_idx = result.columns.iter().position(|column| column == "name").unwrap();
+        assert_eq!(result.rows[0][name_idx], json!("Alice"));
+        let routing_idx = result.columns.iter().position(|column| column == "_routing").unwrap();
+        assert_eq!(result.rows[0][routing_idx], json!("tenant-1"));
+    }
+
+    #[test]
+    fn keeps_sql_api_response_tabular() {
+        let result = super::parse_elasticsearch_response(
+            200,
+            json!({
+                "columns": [{ "name": "name" }],
+                "rows": [["Alice"]]
+            }),
+            std::time::Instant::now(),
+        )
+        .unwrap();
+
+        assert_eq!(result.columns, vec!["name"]);
+        assert_eq!(result.rows, vec![vec![json!("Alice")]]);
+    }
+
+    #[test]
+    fn parses_aggregation_response_before_empty_hits() {
+        let result = super::parse_elasticsearch_response(
+            200,
+            json!({
+                "hits": {
+                    "total": { "value": 5, "relation": "eq" },
+                    "hits": []
+                },
+                "aggregations": {
+                    "by_status": {
+                        "doc_count_error_upper_bound": 0,
+                        "sum_other_doc_count": 0,
+                        "buckets": [
+                            { "key": "paid", "doc_count": 3 },
+                            { "key": "cancelled", "doc_count": 1 },
+                            { "key": "pending", "doc_count": 1 }
+                        ]
+                    }
+                }
+            }),
+            std::time::Instant::now(),
+        )
+        .unwrap();
+
+        let key_idx = result.columns.iter().position(|column| column == "key").unwrap();
+        let count_idx = result.columns.iter().position(|column| column == "doc_count").unwrap();
+
+        assert_eq!(result.rows.len(), 3);
+        assert_eq!(result.rows[0][key_idx], json!("paid"));
+        assert_eq!(result.rows[0][count_idx], json!("3"));
+        assert_eq!(result.affected_rows, 3);
+    }
+
+    #[test]
+    fn parses_plain_text_rest_response_without_dropping_body() {
+        let body =
+            "health status index           docs.count store.size\ngreen  open   app-log-2026-07 42         10mb\n";
+        let result = super::parse_elasticsearch_rest_response(200, body, std::time::Instant::now()).unwrap();
+
+        assert_eq!(result.columns, vec!["response"]);
+        assert_eq!(result.rows.len(), 2);
+        assert_eq!(result.rows[0][0], json!("health status index           docs.count store.size"));
+        assert_eq!(result.rows[1][0], json!("green  open   app-log-2026-07 42         10mb"));
+        assert_eq!(result.affected_rows, 2);
+    }
+
+    #[test]
+    fn keeps_mapping_rest_response_numeric_literals_lossless() {
+        let body = r#"{
+  "products": {
+    "mappings": {
+      "_meta": {
+        "largest_id": 123456789012345678901234567890,
+        "ratio": 0.123456789012345678901234567890,
+        "estimate": 1e400
+      },
+      "properties": { "name": { "type": "keyword" } }
+    }
+  }
+}"#;
+        let result = super::parse_elasticsearch_rest_response(200, body, std::time::Instant::now()).unwrap();
+
+        assert_eq!(result.columns, vec!["status", "response"]);
+        assert_eq!(result.rows[0][0], json!(200));
+        assert_eq!(result.rows[0][1].as_str(), Some(body));
+    }
+
+    #[tokio::test]
+    async fn execute_rest_query_keeps_plain_text_response_body() {
+        use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+        let body =
+            "health status index           docs.count store.size\ngreen  open   app-log-2026-07 42         10mb\n";
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        let server = tokio::spawn(async move {
+            let (mut socket, _) = listener.accept().await.unwrap();
+            let mut request = [0_u8; 1024];
+            let read = socket.read(&mut request).await.unwrap();
+            let request = String::from_utf8_lossy(&request[..read]);
+            assert!(request.starts_with("GET /_cat/indices "));
+            let response = format!(
+                "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+                body.len(),
+                body
+            );
+            socket.write_all(response.as_bytes()).await.unwrap();
+        });
+
+        let client = EsClient::new(&format!("http://{addr}"), None, None, false, Duration::from_secs(1));
+        let result = super::execute_rest_query(&client, "GET /_cat/indices").await.unwrap();
+        server.await.unwrap();
+
+        assert_eq!(result.columns, vec!["response"]);
+        assert_eq!(result.rows.len(), 2);
+        assert_eq!(result.rows[1][0], json!("green  open   app-log-2026-07 42         10mb"));
+    }
+
+    #[tokio::test]
+    async fn execute_rest_query_preserves_numeric_literals_from_http_body() {
+        use tokio::io::AsyncWriteExt;
+
+        let response_body = r#"{"largest_id":123456789012345678901234567890,"ratio":0.123456789012345678901234567890,"estimate":1e400}"#;
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        let server = tokio::spawn(async move {
+            let (mut socket, _) = listener.accept().await.unwrap();
+            let request = read_http_request(&mut socket).await;
+            assert!(request.starts_with("GET /products/_mapping "));
+            let response = format!(
+                "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+                response_body.len(),
+                response_body
+            );
+            socket.write_all(response.as_bytes()).await.unwrap();
+        });
+
+        let client = EsClient::new(&format!("http://{addr}"), None, None, false, Duration::from_secs(1));
+        let result = super::execute_rest_query(&client, "GET /products/_mapping").await.unwrap();
+        server.await.unwrap();
+
+        assert_eq!(result.columns, vec!["status", "response"]);
+        assert_eq!(result.rows[0][0], json!(200));
+        assert_eq!(result.rows[0][1].as_str(), Some(response_body));
+    }
+
+    #[tokio::test]
+    async fn execute_rest_delete_sends_json_body() {
+        use tokio::io::AsyncWriteExt;
+
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        let server = tokio::spawn(async move {
+            let (mut socket, _) = listener.accept().await.unwrap();
+            let request = read_http_request(&mut socket).await;
+            let (headers, body) = request.split_once("\r\n\r\n").unwrap();
+            assert!(headers.starts_with("DELETE /_search/scroll "));
+            assert_eq!(serde_json::from_str::<serde_json::Value>(body).unwrap(), json!({ "scroll_id": ["scroll-1"] }));
+
+            let response_body = r#"{"succeeded":true,"num_freed":1}"#;
+            let response = format!(
+                "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+                response_body.len(),
+                response_body
+            );
+            socket.write_all(response.as_bytes()).await.unwrap();
+        });
+
+        let client = EsClient::new(&format!("http://{addr}"), None, None, false, Duration::from_secs(1));
+        let result =
+            super::execute_rest_query(&client, "DELETE /_search/scroll\n{\"scroll_id\":[\"scroll-1\"]}").await.unwrap();
+        server.await.unwrap();
+
+        assert_eq!(result.columns, vec!["status", "response"]);
+        assert_eq!(result.rows[0][0], json!(200));
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(result.rows[0][1].as_str().unwrap()).unwrap(),
+            json!({ "succeeded": true, "num_freed": 1 })
+        );
+    }
+
+    #[tokio::test]
+    async fn execute_rest_query_keeps_json_error_response() {
+        use tokio::io::AsyncWriteExt;
+
+        let response_body = r#"{"error":{"type":"index_not_found_exception","reason":"no such index"},"status":404}"#;
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        let server = tokio::spawn(async move {
+            let (mut socket, _) = listener.accept().await.unwrap();
+            let request = read_http_request(&mut socket).await;
+            assert!(request.starts_with("GET /missing/_mapping "));
+            let response = format!(
+                "HTTP/1.1 404 Not Found\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+                response_body.len(),
+                response_body
+            );
+            socket.write_all(response.as_bytes()).await.unwrap();
+        });
+
+        let client = EsClient::new(&format!("http://{addr}"), None, None, false, Duration::from_secs(1));
+        let result = super::execute_rest_query(&client, "GET /missing/_mapping").await.unwrap();
+        server.await.unwrap();
+
+        assert_eq!(result.columns, vec!["status", "response"]);
+        assert_eq!(result.rows[0][0], json!(404));
+        assert_eq!(
+            serde_json::from_str::<serde_json::Value>(result.rows[0][1].as_str().unwrap()).unwrap(),
+            json!({ "error": { "type": "index_not_found_exception", "reason": "no such index" }, "status": 404 })
+        );
+    }
+
+    #[tokio::test]
+    async fn execute_select_query_keeps_search_response_tabular() {
+        use tokio::io::AsyncWriteExt;
+
+        let response_body = r#"{"hits":{"hits":[{"_id":"product-1","_source":{"name":"Notebook"}}]}}"#;
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        let server = tokio::spawn(async move {
+            let (mut socket, _) = listener.accept().await.unwrap();
+            let request = read_http_request(&mut socket).await;
+            assert!(request.starts_with("POST /products/_search "));
+            let response = format!(
+                "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+                response_body.len(),
+                response_body
+            );
+            socket.write_all(response.as_bytes()).await.unwrap();
+        });
+
+        let client = EsClient::new(&format!("http://{addr}"), None, None, false, Duration::from_secs(1));
+        let result = super::execute_rest_query(&client, "SELECT * FROM products LIMIT 1").await.unwrap();
+        server.await.unwrap();
+
+        assert_ne!(result.columns, vec!["status", "response"]);
+        let name_idx = result.columns.iter().position(|column| column == "name").unwrap();
+        assert_eq!(result.rows[0][name_idx], json!("Notebook"));
+    }
+
+    #[tokio::test]
+    async fn execute_rest_search_preserves_full_json_response() {
+        use tokio::io::{AsyncReadExt, AsyncWriteExt};
+
+        let body = json!({
+            "took": 3,
+            "hits": {
+                "total": { "value": 1, "relation": "eq" },
+                "max_score": 1.0,
+                "hits": [{
+                    "_index": "products",
+                    "_id": "product-1",
+                    "_score": 1.0,
+                    "_source": { "name": "Notebook", "price": 1299 },
+                    "highlight": { "name": ["<em>Note</em>book"] }
+                }]
+            },
+            "aggregations": {
+                "by_category": {
+                    "buckets": [{ "key": "electronics", "doc_count": 1 }]
+                }
+            }
+        });
+        let response_body = body.to_string();
+        let server_response_body = response_body.clone();
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        let server = tokio::spawn(async move {
+            let (mut socket, _) = listener.accept().await.unwrap();
+            let mut request = [0_u8; 4096];
+            let read = socket.read(&mut request).await.unwrap();
+            let request = String::from_utf8_lossy(&request[..read]);
+            assert!(request.starts_with("POST /products/_search "));
+            let response = format!(
+                "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}",
+                server_response_body.len(),
+                server_response_body
+            );
+            socket.write_all(response.as_bytes()).await.unwrap();
+        });
+
+        let client = EsClient::new(&format!("http://{addr}"), None, None, false, Duration::from_secs(1));
+        let result =
+            super::execute_rest_query(&client, "POST /products/_search\n{\"query\":{\"match_all\":{}}}").await.unwrap();
+        server.await.unwrap();
+
+        assert_eq!(result.columns, vec!["status", "response"]);
+        assert_eq!(result.rows[0][0], json!(200));
+        let response = result.rows[0][1].as_str().unwrap();
+        assert_eq!(response, response_body);
+        assert_eq!(serde_json::from_str::<serde_json::Value>(response).unwrap(), body);
+    }
+
+    #[test]
+    fn document_body_removes_elasticsearch_id_metadata() {
+        let doc = super::elasticsearch_document_body_from_json(r#"{"_id":"abc","_routing":"tenant-1","name":"Alice"}"#)
+            .unwrap();
+
+        assert_eq!(doc, json!({ "name": "Alice" }));
+    }
+
+    #[test]
+    fn document_body_extracts_elasticsearch_routing_metadata() {
+        let (doc, routing) = super::elasticsearch_document_body_and_routing_from_json(
+            r#"{"_id":"abc","_routing":"tenant-1","name":"Alice"}"#,
+            None,
+        )
+        .unwrap();
+
+        assert_eq!(doc, json!({ "name": "Alice" }));
+        assert_eq!(routing.as_deref(), Some("tenant-1"));
+    }
+
+    #[test]
+    fn explicit_elasticsearch_routing_overrides_document_metadata() {
+        let (doc, routing) = super::elasticsearch_document_body_and_routing_from_json(
+            r#"{"_id":"abc","_routing":"tenant-1","name":"Alice"}"#,
+            Some("tenant-2"),
+        )
+        .unwrap();
+
+        assert_eq!(doc, json!({ "name": "Alice" }));
+        assert_eq!(routing.as_deref(), Some("tenant-2"));
+    }
+
+    #[test]
+    fn document_body_preserves_user_field_order() {
+        let doc = super::elasticsearch_document_body_from_json(r#"{"z":1,"_id":"abc","a":2}"#).unwrap();
+
+        assert_eq!(serde_json::to_string(&doc).unwrap(), r#"{"z":1,"a":2}"#);
+    }
+}
diff --git a/crates/dbx-core/src/db/elasticsearch_sql.rs b/crates/dbx-core/src/db/elasticsearch_sql.rs
new file mode 100644
index 0000000..afe6755
--- /dev/null
+++ b/crates/dbx-core/src/db/elasticsearch_sql.rs
@@ -0,0 +1,426 @@
+// SQL → Elasticsearch `_search` DSL translator.
+//
+// ES SQL's `_sql` endpoint refuses several common shapes — `LIKE` on a `text`
+// field with no `.keyword` sub-field, `SELECT *` returning an array field
+// like `host.ip`, ... — even though the same intent is easy to express with
+// the raw query DSL. So instead of delegating to ES SQL (or its
+// `_sql/translate` cousin, which lives in the same engine), we parse the
+// SQL ourselves with `sqlparser-rs` and emit a `_search` body.
+
+use serde_json::{json, Map, Value as Json};
+use sqlparser::ast::{
+    BinaryOperator, Expr, OrderByExpr, OrderByKind, Query, Select, SelectItem, SetExpr, Statement, TableFactor,
+    UnaryOperator, Value as SqlValue,
+};
+use sqlparser::dialect::GenericDialect;
+use sqlparser::parser::Parser;
+
+const AUTO_PAGED_SELECT_STAR_SIZE: usize = 100;
+
+pub struct TranslatedSelectStar {
+    pub index: String,
+    pub body: Json,
+    /// User wrote `LIMIT N` (no OFFSET) — explicit row cap.
+    pub user_limited: bool,
+    /// SQL had OFFSET — signals this came from the pagination plan.
+    pub from_plan_pagination: bool,
+}
+
+/// Try to translate a `SELECT * FROM <index> [WHERE …] [ORDER BY …]
+/// [LIMIT N] [OFFSET M]` statement into a `_search` body.
+///
+/// Returns `Ok(None)` if the statement isn't a recognised `SELECT *` shape
+/// (caller should fall back to a different path). Returns `Err` if it IS a
+/// `SELECT *` but a clause is unsupported (so the caller surfaces a clear
+/// error rather than silently downgrading).
+pub fn translate_select_star(sql: &str) -> Result<Option<TranslatedSelectStar>, String> {
+    let dialect = GenericDialect {};
+    let statements = Parser::parse_sql(&dialect, sql).map_err(|e| format!("SQL parse error: {e}"))?;
+    let Some(stmt) = statements.first() else {
+        return Ok(None);
+    };
+    let Statement::Query(query) = stmt else {
+        return Ok(None);
+    };
+    let SetExpr::Select(select) = query.body.as_ref() else {
+        return Ok(None);
+    };
+    if !is_select_star(select) {
+        return Ok(None);
+    }
+    let Some(source) = single_table_source(select)? else {
+        return Ok(None);
+    };
+
+    let mut body: Map<String, Json> = Map::new();
+    if let Some(where_expr) = &select.selection {
+        body.insert("query".to_string(), translate_predicate(where_expr, source.alias.as_deref())?);
+    }
+    if let Some(order_by) = &query.order_by {
+        if let OrderByKind::Expressions(items) = &order_by.kind {
+            if let Some(sort) = translate_order_by(items, source.alias.as_deref())? {
+                body.insert("sort".to_string(), sort);
+            }
+        }
+    }
+
+    let (limit, offset) = extract_limit_offset(query)?;
+    let user_limited = limit.is_some() && offset.is_none();
+    let from_plan_pagination = offset.is_some();
+    let effective_size = limit.unwrap_or(AUTO_PAGED_SELECT_STAR_SIZE);
+    let effective_from = offset.unwrap_or(0);
+    body.insert("size".to_string(), json!(effective_size));
+    if effective_from > 0 {
+        body.insert("from".to_string(), json!(effective_from));
+    }
+
+    Ok(Some(TranslatedSelectStar { index: source.index, body: Json::Object(body), user_limited, from_plan_pagination }))
+}
+
+fn is_select_star(select: &Select) -> bool {
+    select.projection.len() == 1 && matches!(select.projection.first(), Some(SelectItem::Wildcard(_)))
+}
+
+struct SelectSource {
+    index: String,
+    alias: Option<String>,
+}
+
+fn single_table_source(select: &Select) -> Result<Option<SelectSource>, String> {
+    if select.from.len() != 1 {
+        return Ok(None);
+    }
+    let table = &select.from[0];
+    if !table.joins.is_empty() {
+        return Err("JOINs are not supported in Elasticsearch SQL translation".to_string());
+    }
+    let TableFactor::Table { name, alias, .. } = &table.relation else {
+        return Ok(None);
+    };
+    let joined = name
+        .0
+        .iter()
+        .map(|part| match part {
+            sqlparser::ast::ObjectNamePart::Identifier(ident) => ident.value.clone(),
+            other => format!("{other}"),
+        })
+        .collect::<Vec<_>>()
+        .join(".");
+    Ok(Some(SelectSource { index: joined, alias: alias.as_ref().map(|alias| alias.name.value.clone()) }))
+}
+
+fn translate_predicate(expr: &Expr, table_alias: Option<&str>) -> Result<Json, String> {
+    match expr {
+        Expr::Nested(inner) => translate_predicate(inner, table_alias),
+        Expr::BinaryOp { left, op, right } => translate_binary_op(left, op, right, table_alias),
+        Expr::Like { negated, expr, pattern, .. } | Expr::ILike { negated, expr, pattern, .. } => {
+            translate_like(*negated, expr, pattern, table_alias)
+        }
+        Expr::InList { expr, list, negated } => translate_in_list(expr, list, *negated, table_alias),
+        Expr::IsNull(inner) => translate_is_null(inner, false, table_alias),
+        Expr::IsNotNull(inner) => translate_is_null(inner, true, table_alias),
+        Expr::Between { expr, negated, low, high } => translate_between(expr, *negated, low, high, table_alias),
+        Expr::UnaryOp { op: UnaryOperator::Not, expr } => {
+            let inner = translate_predicate(expr, table_alias)?;
+            Ok(json!({ "bool": { "must_not": [inner] } }))
+        }
+        other => Err(format!("Unsupported WHERE expression: {other}")),
+    }
+}
+
+fn translate_binary_op(
+    left: &Expr,
+    op: &BinaryOperator,
+    right: &Expr,
+    table_alias: Option<&str>,
+) -> Result<Json, String> {
+    match op {
+        BinaryOperator::And => {
+            let mut must = Vec::new();
+            collect_and(left, &mut must, table_alias)?;
+            collect_and(right, &mut must, table_alias)?;
+            Ok(json!({ "bool": { "must": must } }))
+        }
+        BinaryOperator::Or => {
+            let mut should = Vec::new();
+            collect_or(left, &mut should, table_alias)?;
+            collect_or(right, &mut should, table_alias)?;
+            Ok(json!({ "bool": { "should": should, "minimum_should_match": 1 } }))
+        }
+        BinaryOperator::Eq => term_clause(left, right, table_alias),
+        BinaryOperator::NotEq => {
+            let inner = term_clause(left, right, table_alias)?;
+            Ok(json!({ "bool": { "must_not": [inner] } }))
+        }
+        BinaryOperator::Gt => range_clause(left, right, "gt", table_alias),
+        BinaryOperator::Lt => range_clause(left, right, "lt", table_alias),
+        BinaryOperator::GtEq => range_clause(left, right, "gte", table_alias),
+        BinaryOperator::LtEq => range_clause(left, right, "lte", table_alias),
+        other => Err(format!("Unsupported operator: {other}")),
+    }
+}
+
+fn collect_and(expr: &Expr, out: &mut Vec<Json>, table_alias: Option<&str>) -> Result<(), String> {
+    if let Expr::BinaryOp { left, op: BinaryOperator::And, right } = expr {
+        collect_and(left, out, table_alias)?;
+        collect_and(right, out, table_alias)?;
+    } else {
+        out.push(translate_predicate(expr, table_alias)?);
+    }
+    Ok(())
+}
+
+fn collect_or(expr: &Expr, out: &mut Vec<Json>, table_alias: Option<&str>) -> Result<(), String> {
+    if let Expr::BinaryOp { left, op: BinaryOperator::Or, right } = expr {
+        collect_or(left, out, table_alias)?;
+        collect_or(right, out, table_alias)?;
+    } else {
+        out.push(translate_predicate(expr, table_alias)?);
+    }
+    Ok(())
+}
+
+fn term_clause(left: &Expr, right: &Expr, table_alias: Option<&str>) -> Result<Json, String> {
+    let field = field_path(left, table_alias)?;
+    let value = literal_to_json(right)?;
+    Ok(json!({ "term": { field: value } }))
+}
+
+fn range_clause(left: &Expr, right: &Expr, key: &str, table_alias: Option<&str>) -> Result<Json, String> {
+    let field = field_path(left, table_alias)?;
+    let value = literal_to_json(right)?;
+    Ok(json!({ "range": { field: { key: value } } }))
+}
+
+fn translate_like(negated: bool, expr: &Expr, pattern: &Expr, table_alias: Option<&str>) -> Result<Json, String> {
+    let field = field_path(expr, table_alias)?;
+    let pattern_str = match literal_string(pattern)? {
+        Some(s) => s,
+        None => return Err("LIKE pattern must be a string literal".to_string()),
+    };
+
+    // Optimise the common `prefix%` shape into a `prefix` query — cheaper than
+    // `wildcard` and supported on any analyzed text field.
+    let is_prefix = !pattern_str.starts_with('%')
+        && pattern_str.ends_with('%')
+        && !pattern_str[..pattern_str.len() - 1].contains(['%', '_']);
+    let query = if is_prefix {
+        let prefix = &pattern_str[..pattern_str.len() - 1];
+        json!({ "prefix": { field: prefix } })
+    } else {
+        let es_pattern = sql_like_to_wildcard(&pattern_str);
+        json!({
+            "wildcard": {
+                field: { "value": es_pattern, "case_insensitive": true }
+            }
+        })
+    };
+
+    if negated {
+        Ok(json!({ "bool": { "must_not": [query] } }))
+    } else {
+        Ok(query)
+    }
+}
+
+fn translate_in_list(expr: &Expr, list: &[Expr], negated: bool, table_alias: Option<&str>) -> Result<Json, String> {
+    let field = field_path(expr, table_alias)?;
+    let values: Vec<Json> = list.iter().map(literal_to_json).collect::<Result<_, _>>()?;
+    let query = json!({ "terms": { field: values } });
+    if negated {
+        Ok(json!({ "bool": { "must_not": [query] } }))
+    } else {
+        Ok(query)
+    }
+}
+
+fn translate_is_null(expr: &Expr, negated: bool, table_alias: Option<&str>) -> Result<Json, String> {
+    let field = field_path(expr, table_alias)?;
+    let exists = json!({ "exists": { "field": field } });
+    if negated {
+        // IS NOT NULL → field exists
+        Ok(exists)
+    } else {
+        Ok(json!({ "bool": { "must_not": [exists] } }))
+    }
+}
+
+fn translate_between(
+    expr: &Expr,
+    negated: bool,
+    low: &Expr,
+    high: &Expr,
+    table_alias: Option<&str>,
+) -> Result<Json, String> {
+    let field = field_path(expr, table_alias)?;
+    let lo = literal_to_json(low)?;
+    let hi = literal_to_json(high)?;
+    let query = json!({ "range": { field: { "gte": lo, "lte": hi } } });
+    if negated {
+        Ok(json!({ "bool": { "must_not": [query] } }))
+    } else {
+        Ok(query)
+    }
+}
+
+fn translate_order_by(items: &[OrderByExpr], table_alias: Option<&str>) -> Result<Option<Json>, String> {
+    let mut sort = Vec::new();
+    for item in items {
+        let field = field_path(&item.expr, table_alias)?;
+        let order = if item.options.asc.unwrap_or(true) { "asc" } else { "desc" };
+        sort.push(json!({ field: { "order": order } }));
+    }
+    if sort.is_empty() {
+        Ok(None)
+    } else {
+        Ok(Some(Json::Array(sort)))
+    }
+}
+
+fn extract_limit_offset(query: &Query) -> Result<(Option<usize>, Option<usize>), String> {
+    let limit = match &query.limit_clause {
+        Some(sqlparser::ast::LimitClause::LimitOffset { limit, .. }) => {
+            limit.as_ref().map(usize_literal).transpose()?
+        }
+        _ => None,
+    };
+    let offset = match &query.limit_clause {
+        Some(sqlparser::ast::LimitClause::LimitOffset { offset: Some(off), .. }) => Some(usize_literal(&off.value)?),
+        _ => None,
+    };
+    Ok((limit, offset))
+}
+
+fn usize_literal(expr: &Expr) -> Result<usize, String> {
+    match expr {
+        Expr::Value(v) => match &v.value {
+            SqlValue::Number(n, _) => n.parse::<usize>().map_err(|e| format!("Invalid number: {e}")),
+            other => Err(format!("Expected integer literal, got {other:?}")),
+        },
+        other => Err(format!("Expected integer literal, got {other}")),
+    }
+}
+
+fn field_path(expr: &Expr, table_alias: Option<&str>) -> Result<String, String> {
+    match expr {
+        Expr::Identifier(ident) => Ok(ident.value.clone()),
+        Expr::CompoundIdentifier(parts) => {
+            let mut field_parts = parts.iter().map(|p| p.value.clone()).collect::<Vec<_>>();
+            if let (Some(alias), Some(first)) = (table_alias, field_parts.first()) {
+                // Dotted Elasticsearch fields are valid document paths; only
+                // strip a known SQL table alias such as `ass.agencyCode`.
+                if first.eq_ignore_ascii_case(alias) {
+                    field_parts.remove(0);
+                }
+            }
+            Ok(field_parts.join("."))
+        }
+        other => Err(format!("Expected column name, got {other}")),
+    }
+}
+
+fn literal_to_json(expr: &Expr) -> Result<Json, String> {
+    let Expr::Value(v) = expr else {
+        return Err(format!("Expected literal value, got {expr}"));
+    };
+    match &v.value {
+        SqlValue::SingleQuotedString(s) | SqlValue::DoubleQuotedString(s) => Ok(Json::String(s.clone())),
+        SqlValue::Number(n, _) => serde_json::from_str::<Json>(n).map_err(|e| format!("Invalid number {n}: {e}")),
+        SqlValue::Boolean(b) => Ok(Json::Bool(*b)),
+        SqlValue::Null => Ok(Json::Null),
+        other => Err(format!("Unsupported literal: {other:?}")),
+    }
+}
+
+fn literal_string(expr: &Expr) -> Result<Option<String>, String> {
+    let Expr::Value(v) = expr else {
+        return Err(format!("Expected string literal, got {expr}"));
+    };
+    Ok(match &v.value {
+        SqlValue::SingleQuotedString(s) | SqlValue::DoubleQuotedString(s) => Some(s.clone()),
+        _ => None,
+    })
+}
+
+/// Convert SQL LIKE pattern to ES wildcard pattern.
+/// SQL: `%` = any chars, `_` = single char. Backslash escapes both.
+/// ES wildcard: `*` = any chars, `?` = single char. `\` escapes `*` / `?` / `\`.
+fn sql_like_to_wildcard(pattern: &str) -> String {
+    let mut out = String::with_capacity(pattern.len());
+    let mut chars = pattern.chars().peekable();
+    while let Some(ch) = chars.next() {
+        match ch {
+            '\\' => {
+                if let Some(&next) = chars.peek() {
+                    out.push(next);
+                    chars.next();
+                }
+            }
+            '%' => out.push('*'),
+            '_' => out.push('?'),
+            '*' | '?' => {
+                // Escape ES wildcard metacharacters that the user wrote literally.
+                out.push('\\');
+                out.push(ch);
+            }
+            _ => out.push(ch),
+        }
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::translate_select_star;
+    use serde_json::json;
+
+    #[test]
+    fn translate_select_star_strips_table_alias_from_where_fields() {
+        let translated = translate_select_star(
+            "SELECT * FROM assets002 AS ass WHERE ass.agencyCode = '035021' AND ass.mofDivCode = '420108000'",
+        )
+        .unwrap()
+        .unwrap();
+
+        assert_eq!(translated.index, "assets002");
+        assert_eq!(
+            translated.body["query"],
+            json!({
+                "bool": {
+                    "must": [
+                        { "term": { "agencyCode": "035021" } },
+                        { "term": { "mofDivCode": "420108000" } }
+                    ]
+                }
+            })
+        );
+    }
+
+    #[test]
+    fn translate_select_star_strips_table_alias_before_nested_field_path() {
+        let translated =
+            translate_select_star("SELECT * FROM assets002 ass WHERE ass.department.code = 'A01'").unwrap().unwrap();
+
+        assert_eq!(translated.body["query"], json!({ "term": { "department.code": "A01" } }));
+    }
+
+    #[test]
+    fn translate_select_star_preserves_unaliased_dotted_document_fields() {
+        let translated = translate_select_star("SELECT * FROM logs WHERE host.ip = '127.0.0.1'").unwrap().unwrap();
+
+        assert_eq!(translated.body["query"], json!({ "term": { "host.ip": "127.0.0.1" } }));
+    }
+
+    #[test]
+    fn translate_select_star_strips_alias_in_like_and_order_by() {
+        let translated = translate_select_star(
+            "SELECT * FROM assets002 ass WHERE ass.assetName LIKE 'car%' ORDER BY ass.createdAt DESC LIMIT 10",
+        )
+        .unwrap()
+        .unwrap();
+
+        assert_eq!(translated.body["query"], json!({ "prefix": { "assetName": "car" } }));
+        assert_eq!(translated.body["sort"], json!([{ "createdAt": { "order": "desc" } }]));
+        assert_eq!(translated.body["size"], json!(10));
+    }
+}
diff --git a/crates/dbx-core/src/db/file_validator.rs b/crates/dbx-core/src/db/file_validator.rs
new file mode 100644
index 0000000..0899ead
--- /dev/null
+++ b/crates/dbx-core/src/db/file_validator.rs
@@ -0,0 +1,131 @@
+use std::path::Path;
+
+use crate::path_utils::expand_tilde;
+
+/// Validates a file path for database connections.
+///
+/// Performs comprehensive checks including:
+/// - Empty path validation
+/// - Null character detection
+/// - File existence (for local paths)
+/// - File type validation (must be a file, not directory)
+/// - Network path detection (skips validation for network paths)
+///
+/// # Arguments
+/// * `path` - The file path to validate
+/// * `is_network_path` - Closure to determine if path is a network path
+///
+/// # Returns
+/// * `Ok(())` if validation passes
+/// * `Err(String)` with descriptive error message if validation fails
+pub fn validate_file_path<F>(path: &str, is_network_path: F) -> Result<(), String>
+where
+    F: Fn(&str) -> bool,
+{
+    // Check if path is empty
+    if path.is_empty() {
+        return Err("File path cannot be empty".to_string());
+    }
+
+    // Check if path contains invalid characters
+    if path.contains('\0') {
+        return Err("File path contains null characters".to_string());
+    }
+
+    let expanded = expand_tilde(path);
+    let path_obj = Path::new(&expanded);
+
+    // For non-network paths, perform file system checks
+    if !is_network_path(path) {
+        if !path_obj.exists() {
+            return Err(format!("File does not exist: {}", path));
+        }
+
+        // Check if path is actually a file, not a directory
+        if path_obj.is_dir() {
+            return Err(format!("File path is a directory, not a file: {}", path));
+        }
+
+        // Check if path is a valid file
+        if !path_obj.is_file() {
+            return Err(format!("File path is not a valid file: {}", path));
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn is_network_path_test(path: &str) -> bool {
+        path.starts_with("\\\\") || path.starts_with("//")
+    }
+
+    #[test]
+    fn test_empty_path() {
+        let result = validate_file_path("", is_network_path_test);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("empty"));
+    }
+
+    #[test]
+    fn test_null_character() {
+        let result = validate_file_path("path\0invalid", is_network_path_test);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("null"));
+    }
+
+    #[test]
+    fn test_network_path_skips_validation() {
+        let result = validate_file_path("//network/path/nonexistent.db", is_network_path_test);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_nonexistent_local_file() {
+        let result = validate_file_path("/nonexistent/path/to/file.db", is_network_path_test);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("does not exist"));
+    }
+
+    #[test]
+    fn test_tilde_expands_to_home() {
+        let home = std::env::var("HOME").unwrap_or_default();
+        if home.is_empty() {
+            return; // skip if no HOME
+        }
+        let result = validate_file_path(&format!("{}/.bashrc", home), is_network_path_test);
+        // $HOME/.bashrc may or may not exist, but the path shouldn't contain literal ~
+        // We just verify no error mentioning tilde
+        if let Err(e) = &result {
+            assert!(!e.contains('~'), "Error should not contain literal tilde: {e}");
+        }
+    }
+
+    #[test]
+    fn test_tilde_only() {
+        let home = std::env::var("HOME").unwrap_or_default();
+        if home.is_empty() {
+            return;
+        }
+        let result = validate_file_path("~", |_| true); // treat as network to skip fs check
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_no_tilde_unchanged() {
+        let result = validate_file_path("/absolute/path", is_network_path_test);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("/absolute/path"));
+    }
+
+    #[test]
+    fn test_tilde_without_slash_not_expanded() {
+        // ~user form is not expanded, treated literally
+        let result = validate_file_path("~nonexistentuser", is_network_path_test);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains('~'));
+    }
+}
diff --git a/crates/dbx-core/src/db/http_tunnel.rs b/crates/dbx-core/src/db/http_tunnel.rs
new file mode 100644
index 0000000..8a4b51b
--- /dev/null
+++ b/crates/dbx-core/src/db/http_tunnel.rs
@@ -0,0 +1,413 @@
+use bytes::Bytes;
+use reqwest::header::{HeaderValue, AUTHORIZATION, CONTENT_TYPE};
+use reqwest::{Client, StatusCode, Url};
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::{TcpListener, TcpStream};
+use tokio::sync::Mutex;
+use tokio::task::JoinHandle;
+use tokio::time::{timeout, Duration};
+use uuid::Uuid;
+
+const DEFAULT_CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
+const TCP_READ_BUFFER_SIZE: usize = 16 * 1024;
+const HTTP_READ_WAIT_MS: u64 = 1_000;
+const HTTP_REQUEST_TIMEOUT: Duration = Duration::from_secs(15);
+
+#[derive(Default)]
+pub struct HttpTunnelManager {
+    tunnels: Mutex<HashMap<String, (JoinHandle<()>, u16)>>,
+}
+
+impl HttpTunnelManager {
+    pub fn new() -> Self {
+        Self { tunnels: Mutex::new(HashMap::new()) }
+    }
+
+    pub async fn start_tunnel(
+        &self,
+        connection_id: &str,
+        tunnel_url: &str,
+        token: &str,
+        connect_timeout_secs: u64,
+        remote_host: &str,
+        remote_port: u16,
+    ) -> Result<u16, String> {
+        if let Some(local_port) = self.local_port(connection_id).await {
+            return Ok(local_port);
+        }
+        let local_port = portpicker::pick_unused_port().ok_or("No available port")?;
+        let listener = TcpListener::bind(("127.0.0.1", local_port))
+            .await
+            .map_err(|e| format!("Failed to bind HTTP tunnel local port: {e}"))?;
+
+        let endpoint =
+            Arc::new(HttpTunnelEndpoint::new(tunnel_url, token, connect_timeout_secs, remote_host, remote_port)?);
+        let handle = tokio::spawn(http_tunnel_forward_loop(listener, endpoint));
+
+        let mut tunnels = self.tunnels.lock().await;
+        if let Some((_, existing_port)) = tunnels.get(connection_id) {
+            handle.abort();
+            return Ok(*existing_port);
+        }
+
+        tunnels.insert(connection_id.to_string(), (handle, local_port));
+        Ok(local_port)
+    }
+
+    pub async fn local_port(&self, connection_id: &str) -> Option<u16> {
+        self.tunnels.lock().await.get(connection_id).map(|(_, port)| *port)
+    }
+
+    pub async fn stop_tunnel(&self, connection_id: &str) {
+        if let Some((handle, _)) = self.tunnels.lock().await.remove(connection_id) {
+            handle.abort();
+        }
+    }
+
+    pub async fn stop_tunnels_with_prefix(&self, connection_id_prefix: &str) {
+        let mut tunnels = self.tunnels.lock().await;
+        let keys: Vec<String> = tunnels.keys().filter(|key| key.starts_with(connection_id_prefix)).cloned().collect();
+        for key in keys {
+            if let Some((handle, _)) = tunnels.remove(&key) {
+                handle.abort();
+            }
+        }
+    }
+}
+
+struct HttpTunnelEndpoint {
+    url: String,
+    token: String,
+    connect_timeout: Duration,
+    target_host: String,
+    target_port: u16,
+    client: Client,
+}
+
+impl HttpTunnelEndpoint {
+    fn new(
+        tunnel_url: &str,
+        token: &str,
+        connect_timeout_secs: u64,
+        remote_host: &str,
+        remote_port: u16,
+    ) -> Result<Self, String> {
+        validate_script_url(tunnel_url)?;
+        Ok(Self {
+            url: tunnel_url.trim().to_string(),
+            token: token.trim().to_string(),
+            connect_timeout: effective_connect_timeout(connect_timeout_secs),
+            target_host: remote_host.to_string(),
+            target_port: remote_port,
+            client: Client::new(),
+        })
+    }
+}
+
+async fn http_tunnel_forward_loop(listener: TcpListener, endpoint: Arc<HttpTunnelEndpoint>) {
+    loop {
+        let (inbound, _) = match listener.accept().await {
+            Ok(pair) => pair,
+            Err(_) => break,
+        };
+        let endpoint = endpoint.clone();
+        tokio::spawn(async move {
+            let _ = bridge_tcp_to_http_script(inbound, endpoint).await;
+        });
+    }
+}
+
+async fn bridge_tcp_to_http_script(mut inbound: TcpStream, endpoint: Arc<HttpTunnelEndpoint>) -> Result<(), String> {
+    let session = Uuid::new_v4().simple().to_string();
+    open_session(&endpoint, &session).await?;
+
+    let (mut tcp_reader, mut tcp_writer) = inbound.split();
+    let tcp_to_http = async {
+        let mut buf = vec![0_u8; TCP_READ_BUFFER_SIZE];
+        loop {
+            let n = tcp_reader.read(&mut buf).await.map_err(|e| format!("Failed to read local TCP stream: {e}"))?;
+            if n == 0 {
+                return Ok::<(), String>(());
+            }
+            write_session(&endpoint, &session, Bytes::copy_from_slice(&buf[..n])).await?;
+        }
+    };
+
+    let http_to_tcp = async {
+        loop {
+            let bytes = read_session(&endpoint, &session).await?;
+            if !bytes.is_empty() {
+                tcp_writer.write_all(&bytes).await.map_err(|e| format!("Failed to write local TCP stream: {e}"))?;
+            }
+        }
+    };
+
+    let result = tokio::select! {
+        result = tcp_to_http => result,
+        result = http_to_tcp => result,
+    };
+    let _ = close_session(&endpoint, &session).await;
+    result
+}
+
+async fn open_session(endpoint: &HttpTunnelEndpoint, session: &str) -> Result<(), String> {
+    let url = script_url(
+        &endpoint.url,
+        "open",
+        session,
+        Some((&endpoint.target_host, endpoint.target_port)),
+        Some(endpoint.connect_timeout.as_secs()),
+        None,
+    )?;
+    let response = timeout(
+        endpoint.connect_timeout + HTTP_REQUEST_TIMEOUT,
+        authorized_request(endpoint, endpoint.client.post(url)).send(),
+    )
+    .await
+    .map_err(|_| "HTTP tunnel script open timed out".to_string())?
+    .map_err(|e| format!("Failed to open HTTP tunnel script session: {e}"))?;
+    ensure_success(response, "open HTTP tunnel script session").await
+}
+
+async fn write_session(endpoint: &HttpTunnelEndpoint, session: &str, data: Bytes) -> Result<(), String> {
+    let url = script_url(&endpoint.url, "write", session, None, None, None)?;
+    let response = timeout(
+        HTTP_REQUEST_TIMEOUT,
+        authorized_request(endpoint, endpoint.client.post(url))
+            .header(CONTENT_TYPE, "application/octet-stream")
+            .body(data)
+            .send(),
+    )
+    .await
+    .map_err(|_| "HTTP tunnel script write timed out".to_string())?
+    .map_err(|e| format!("Failed to write HTTP tunnel script session: {e}"))?;
+    ensure_success(response, "write HTTP tunnel script session").await
+}
+
+async fn read_session(endpoint: &HttpTunnelEndpoint, session: &str) -> Result<Bytes, String> {
+    let url = script_url(&endpoint.url, "read", session, None, None, Some(HTTP_READ_WAIT_MS))?;
+    let response = timeout(HTTP_REQUEST_TIMEOUT, authorized_request(endpoint, endpoint.client.post(url)).send())
+        .await
+        .map_err(|_| "HTTP tunnel script read timed out".to_string())?
+        .map_err(|e| format!("Failed to read HTTP tunnel script session: {e}"))?;
+    let status = response.status();
+    if status == StatusCode::NO_CONTENT {
+        return Ok(Bytes::new());
+    }
+    if status == StatusCode::OK {
+        return response.bytes().await.map_err(|e| format!("Failed to read HTTP tunnel script response: {e}"));
+    }
+    if status == StatusCode::GONE {
+        return Err("HTTP tunnel script session closed".to_string());
+    }
+    Err(error_response_message(response, "read HTTP tunnel script session").await)
+}
+
+async fn close_session(endpoint: &HttpTunnelEndpoint, session: &str) -> Result<(), String> {
+    let url = script_url(&endpoint.url, "close", session, None, None, None)?;
+    let response = timeout(HTTP_REQUEST_TIMEOUT, authorized_request(endpoint, endpoint.client.post(url)).send())
+        .await
+        .map_err(|_| "HTTP tunnel script close timed out".to_string())?
+        .map_err(|e| format!("Failed to close HTTP tunnel script session: {e}"))?;
+    ensure_success(response, "close HTTP tunnel script session").await
+}
+
+fn authorized_request(endpoint: &HttpTunnelEndpoint, builder: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
+    if endpoint.token.is_empty() {
+        return builder;
+    }
+    match HeaderValue::from_str(&endpoint.token) {
+        Ok(token) => builder
+            .header("X-DBX-Tunnel-Token", token.clone())
+            .header(AUTHORIZATION, format!("Bearer {}", endpoint.token)),
+        Err(_) => builder,
+    }
+}
+
+async fn ensure_success(response: reqwest::Response, action: &str) -> Result<(), String> {
+    if response.status().is_success() {
+        Ok(())
+    } else {
+        Err(error_response_message(response, action).await)
+    }
+}
+
+async fn error_response_message(response: reqwest::Response, action: &str) -> String {
+    let status = response.status();
+    let body = response.text().await.unwrap_or_default();
+    if body.trim().is_empty() {
+        format!("Failed to {action}: HTTP {status}")
+    } else {
+        format!("Failed to {action}: HTTP {status}: {}", body.trim())
+    }
+}
+
+fn script_url(
+    tunnel_url: &str,
+    action: &str,
+    session: &str,
+    target: Option<(&str, u16)>,
+    connect_timeout_secs: Option<u64>,
+    wait_ms: Option<u64>,
+) -> Result<Url, String> {
+    let mut url = validate_script_url(tunnel_url)?;
+    url.query_pairs_mut().append_pair("dbx_action", action).append_pair("dbx_session", session);
+    if let Some((host, port)) = target {
+        url.query_pairs_mut().append_pair("dbx_target_host", host).append_pair("dbx_target_port", &port.to_string());
+    }
+    if let Some(connect_timeout_secs) = connect_timeout_secs {
+        url.query_pairs_mut()
+            .append_pair("dbx_connect_timeout", &effective_connect_timeout_secs(connect_timeout_secs).to_string());
+    }
+    if let Some(wait_ms) = wait_ms {
+        url.query_pairs_mut().append_pair("dbx_wait_ms", &wait_ms.to_string());
+    }
+    Ok(url)
+}
+
+fn validate_script_url(tunnel_url: &str) -> Result<Url, String> {
+    let trimmed = tunnel_url.trim();
+    if trimmed.is_empty() {
+        return Err("HTTP tunnel script URL is required".to_string());
+    }
+    let url = Url::parse(trimmed).map_err(|e| format!("HTTP tunnel script URL is invalid: {e}"))?;
+    match url.scheme() {
+        "http" | "https" => Ok(url),
+        other => Err(format!("Unsupported HTTP tunnel script URL scheme: {other}")),
+    }
+}
+
+fn effective_connect_timeout(value: u64) -> Duration {
+    Duration::from_secs(effective_connect_timeout_secs(value))
+}
+
+fn effective_connect_timeout_secs(value: u64) -> u64 {
+    if value == 0 {
+        DEFAULT_CONNECT_TIMEOUT.as_secs()
+    } else {
+        value.clamp(1, 300)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{script_url, validate_script_url, HttpTunnelManager};
+    use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
+    use tokio::net::{TcpListener, TcpStream};
+    use tokio::sync::Mutex;
+
+    #[test]
+    fn script_url_preserves_existing_query_and_appends_action() {
+        let url = script_url(
+            "https://gateway.example.com/dbx_tunnel.php?keep=1",
+            "open",
+            "session-1",
+            Some(("mysql.internal", 3306)),
+            Some(10),
+            None,
+        )
+        .unwrap();
+
+        assert_eq!(
+            url.as_str(),
+            "https://gateway.example.com/dbx_tunnel.php?keep=1&dbx_action=open&dbx_session=session-1&dbx_target_host=mysql.internal&dbx_target_port=3306&dbx_connect_timeout=10"
+        );
+    }
+
+    #[test]
+    fn script_url_rejects_non_http_schemes() {
+        let err = validate_script_url("file:///tmp/tunnel.php").unwrap_err();
+
+        assert!(err.contains("Unsupported HTTP tunnel script URL scheme"));
+    }
+
+    #[tokio::test]
+    async fn manager_forwards_bytes_through_http_script_protocol() {
+        let script = MockScript::start().await;
+        let manager = HttpTunnelManager::new();
+        let local_port = manager.start_tunnel("test", &script.url, "secret", 5, "mysql.internal", 3306).await.unwrap();
+        let mut client = TcpStream::connect(("127.0.0.1", local_port)).await.unwrap();
+        client.write_all(b"ping").await.unwrap();
+        let mut response = [0_u8; 4];
+        client.read_exact(&mut response).await.unwrap();
+
+        assert_eq!(&response, b"ping");
+
+        manager.stop_tunnel("test").await;
+        script.handle.abort();
+    }
+
+    struct MockScript {
+        url: String,
+        handle: tokio::task::JoinHandle<()>,
+    }
+
+    impl MockScript {
+        async fn start() -> Self {
+            let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
+            let addr = listener.local_addr().unwrap();
+            let buffered = std::sync::Arc::new(Mutex::new(Vec::<u8>::new()));
+            let handle = {
+                let buffered = buffered.clone();
+                tokio::spawn(async move {
+                    loop {
+                        let Ok((stream, _)) = listener.accept().await else {
+                            break;
+                        };
+                        let buffered = buffered.clone();
+                        tokio::spawn(async move {
+                            handle_mock_http_request(stream, buffered).await;
+                        });
+                    }
+                })
+            };
+            Self { url: format!("http://{addr}/dbx_tunnel.php"), handle }
+        }
+    }
+
+    async fn handle_mock_http_request(stream: TcpStream, buffered: std::sync::Arc<Mutex<Vec<u8>>>) {
+        let mut reader = BufReader::new(stream);
+        let mut request_line = String::new();
+        reader.read_line(&mut request_line).await.unwrap();
+        let mut content_length = 0_usize;
+        loop {
+            let mut line = String::new();
+            reader.read_line(&mut line).await.unwrap();
+            let trimmed = line.trim_end();
+            if trimmed.is_empty() {
+                break;
+            }
+            let lower = trimmed.to_ascii_lowercase();
+            if let Some(value) = lower.strip_prefix("content-length:") {
+                content_length = value.trim().parse().unwrap();
+            }
+        }
+        let mut body = vec![0_u8; content_length];
+        reader.read_exact(&mut body).await.unwrap();
+        let mut stream = reader.into_inner();
+        if request_line.contains("dbx_action=write") {
+            buffered.lock().await.extend_from_slice(&body);
+            write_http_response(&mut stream, "200 OK", b"OK").await;
+        } else if request_line.contains("dbx_action=read") {
+            let bytes = {
+                let mut buffered = buffered.lock().await;
+                std::mem::take(&mut *buffered)
+            };
+            if bytes.is_empty() {
+                write_http_response(&mut stream, "204 No Content", b"").await;
+            } else {
+                write_http_response(&mut stream, "200 OK", &bytes).await;
+            }
+        } else {
+            write_http_response(&mut stream, "200 OK", b"OK").await;
+        }
+    }
+
+    async fn write_http_response(stream: &mut TcpStream, status: &str, body: &[u8]) {
+        let header = format!("HTTP/1.1 {status}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", body.len());
+        stream.write_all(header.as_bytes()).await.unwrap();
+        stream.write_all(body).await.unwrap();
+    }
+}
diff --git a/crates/dbx-core/src/db/influxdb_driver.rs b/crates/dbx-core/src/db/influxdb_driver.rs
new file mode 100644
index 0000000..234ae86
--- /dev/null
+++ b/crates/dbx-core/src/db/influxdb_driver.rs
@@ -0,0 +1,790 @@
+use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
+use reqwest::{Certificate, Client as HttpClient, Response};
+use serde::{Deserialize, Serialize};
+use std::fs;
+use std::time::{Duration, Instant};
+
+use super::with_connection_timeout;
+use crate::models::connection::ConnectionConfig;
+use crate::sql::starts_with_executable_sql_keyword;
+use crate::types::{ColumnInfo, DatabaseInfo, QueryResult, TableInfo};
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum InfluxdbApiVersion {
+    V1,
+    V2,
+}
+
+pub struct InfluxdbClient {
+    http: HttpClient,
+    base_url: String,
+    username: Option<String>,
+    password: Option<String>,
+    url_params: Option<String>,
+    version: InfluxdbApiVersion,
+    org: Option<String>,
+}
+
+impl InfluxdbClient {
+    pub fn new(
+        url: &str,
+        username: Option<String>,
+        password: Option<String>,
+        url_params: Option<String>,
+        timeout: Duration,
+    ) -> Self {
+        let http = HttpClient::builder().connect_timeout(timeout).build().unwrap_or_else(|_| HttpClient::new());
+        Self {
+            http,
+            base_url: url.trim_end_matches('/').to_string(),
+            username,
+            password,
+            url_params,
+            version: InfluxdbApiVersion::V1,
+            org: None,
+        }
+    }
+
+    pub fn new_with_ca_cert(
+        url: &str,
+        username: Option<String>,
+        password: Option<String>,
+        url_params: Option<String>,
+        ca_cert_path: Option<&str>,
+        timeout: Duration,
+    ) -> Result<Self, String> {
+        let http = build_http_client(ca_cert_path, timeout)?;
+        Ok(Self {
+            http,
+            base_url: url.trim_end_matches('/').to_string(),
+            username,
+            password,
+            url_params,
+            version: InfluxdbApiVersion::V1,
+            org: None,
+        })
+    }
+
+    pub fn new_for_config(url: &str, config: &ConnectionConfig, timeout: Duration) -> Result<Self, String> {
+        let version = influxdb_api_version(config.external_config.as_ref());
+        let org = influxdb_org(config.external_config.as_ref());
+        // InfluxDB 2.x authenticates with a token and scopes requests by org/bucket.
+        let (username, password) = match version {
+            InfluxdbApiVersion::V1 => (
+                (!config.username.is_empty()).then_some(config.username.clone()),
+                (!config.password.is_empty()).then_some(config.password.clone()),
+            ),
+            InfluxdbApiVersion::V2 => (None, (!config.password.is_empty()).then_some(config.password.clone())),
+        };
+        let http = build_http_client(Some(&config.ca_cert_path), timeout)?;
+        Ok(Self {
+            http,
+            base_url: url.trim_end_matches('/').to_string(),
+            username,
+            password,
+            url_params: config.url_params.clone(),
+            version,
+            org,
+        })
+    }
+}
+
+fn build_http_client(ca_cert_path: Option<&str>, timeout: Duration) -> Result<HttpClient, String> {
+    let mut builder = HttpClient::builder().connect_timeout(timeout);
+    if let Some(path) = ca_cert_path.map(str::trim).filter(|path| !path.is_empty()) {
+        let path = expand_cert_path(path);
+        let cert_bytes =
+            fs::read(&path).map_err(|e| format!("Failed to read InfluxDB CA certificate at {path}: {e}"))?;
+        let cert = Certificate::from_pem(&cert_bytes)
+            .or_else(|_| Certificate::from_der(&cert_bytes))
+            .map_err(|e| format!("Failed to parse InfluxDB CA certificate at {path}: {e}"))?;
+        builder = builder.add_root_certificate(cert);
+    }
+    builder.build().map_err(|e| format!("Failed to configure InfluxDB HTTP client: {e}"))
+}
+
+fn influxdb_api_version(external_config: Option<&serde_json::Value>) -> InfluxdbApiVersion {
+    match external_config.and_then(|value| value.get("version")).and_then(serde_json::Value::as_str).map(str::trim) {
+        Some("2" | "v2" | "V2") => InfluxdbApiVersion::V2,
+        _ => InfluxdbApiVersion::V1,
+    }
+}
+
+fn influxdb_org(external_config: Option<&serde_json::Value>) -> Option<String> {
+    external_config
+        .and_then(|value| value.get("org").or_else(|| value.get("organization")))
+        .and_then(serde_json::Value::as_str)
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string)
+}
+
+fn expand_cert_path(path: &str) -> String {
+    let home = || std::env::var(if cfg!(windows) { "USERPROFILE" } else { "HOME" }).ok();
+    if path == "~" || path.starts_with("~/") || path.starts_with("~\\") {
+        if let Some(home) = home() {
+            return format!("{}{}", home, &path[1..]);
+        }
+    }
+    if let Some(rest) = path.strip_prefix("$HOME") {
+        if let Some(home) = home() {
+            return format!("{home}{rest}");
+        }
+    }
+    if let Some(rest) = path.strip_prefix("${HOME}") {
+        if let Some(home) = home() {
+            return format!("{home}{rest}");
+        }
+    }
+    if let Some(rest) = path.strip_prefix("%USERPROFILE%") {
+        if let Ok(home) = std::env::var("USERPROFILE") {
+            return format!("{home}{rest}");
+        }
+    }
+    path.to_string()
+}
+
+impl Clone for InfluxdbClient {
+    fn clone(&self) -> Self {
+        Self {
+            http: self.http.clone(),
+            base_url: self.base_url.clone(),
+            username: self.username.clone(),
+            password: self.password.clone(),
+            url_params: self.url_params.clone(),
+            version: self.version,
+            org: self.org.clone(),
+        }
+    }
+}
+
+#[derive(Deserialize, Default)]
+struct InfluxErrorResult {
+    #[serde(default)]
+    #[serde(rename = "error", alias = "err")]
+    error: Option<String>,
+    #[serde(default)]
+    message: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct InfluxJsonResult {
+    results: Vec<InfluxQueryResult>,
+}
+
+#[derive(Deserialize)]
+#[allow(dead_code)]
+struct InfluxQueryResult {
+    /// The `statement_id` field may not be included in older versions (such as 1.1)
+    #[serde(default)]
+    #[allow(dead_code)]
+    statement_id: usize,
+    #[serde(default)]
+    #[allow(dead_code)]
+    series: Vec<InfluxSeries>,
+}
+
+#[derive(Deserialize)]
+#[allow(dead_code)]
+struct InfluxSeries {
+    #[serde(default)]
+    #[allow(dead_code)]
+    name: String,
+    columns: Vec<String>,
+    values: Vec<Vec<serde_json::Value>>,
+}
+
+#[derive(Deserialize)]
+struct InfluxBucketsResult {
+    #[serde(default)]
+    buckets: Vec<InfluxBucket>,
+}
+
+#[derive(Deserialize)]
+struct InfluxBucket {
+    name: String,
+}
+
+#[derive(Serialize)]
+struct FluxQueryRequest<'a> {
+    query: &'a str,
+    #[serde(rename = "type")]
+    query_type: &'static str,
+}
+
+fn build_query_url(client: &InfluxdbClient, database: Option<&str>, sql: &str) -> String {
+    let mut params: Vec<String> = vec![];
+    if let Some(url_params) = &client.url_params {
+        params.push(url_params.to_string())
+    }
+    if let Some(db) = database {
+        params.push(format!("db={db}"));
+    }
+    let encoded_sql = utf8_percent_encode(sql, NON_ALPHANUMERIC);
+    params.push(format!("q={encoded_sql}"));
+    format!("{}/query?{}", &client.base_url, params.join("&").as_str())
+}
+
+fn encode_url_param(value: &str) -> String {
+    utf8_percent_encode(value, NON_ALPHANUMERIC).to_string()
+}
+
+fn build_v2_buckets_url(client: &InfluxdbClient, offset: usize) -> Result<String, String> {
+    let org = client.org.as_deref().ok_or_else(|| "InfluxDB 2.x organization is required".to_string())?;
+    Ok(format!("{}/api/v2/buckets?org={}&limit=100&offset={offset}", &client.base_url, encode_url_param(org)))
+}
+
+fn build_v2_query_url(client: &InfluxdbClient) -> Result<String, String> {
+    let org = client.org.as_deref().ok_or_else(|| "InfluxDB 2.x organization is required".to_string())?;
+    Ok(format!("{}/api/v2/query?org={}", &client.base_url, encode_url_param(org)))
+}
+
+fn build_request(client: &InfluxdbClient, req: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
+    if client.version == InfluxdbApiVersion::V2 {
+        if let Some(token) = client.password.as_deref().map(str::trim).filter(|token| !token.is_empty()) {
+            return req.header("Authorization", format!("Token {token}"));
+        }
+        return req;
+    }
+    match (&client.username, &client.password) {
+        (Some(u), Some(p)) if !u.is_empty() => req.basic_auth(u, Some(p)),
+        (Some(u), None) if !u.is_empty() => req.basic_auth(u, None::<&str>),
+        _ => req,
+    }
+}
+
+fn require_v2_token(client: &InfluxdbClient) -> Result<(), String> {
+    if client.password.as_deref().map(str::trim).filter(|token| !token.is_empty()).is_none() {
+        return Err("InfluxDB 2.x token is required".to_string());
+    }
+    Ok(())
+}
+
+async fn influx_query(client: &InfluxdbClient, sql: &str, database: Option<&str>) -> Result<InfluxJsonResult, String> {
+    let url = build_query_url(client, database, sql);
+    log::info!("[influxdb] query url={url} username={:?} password={}", client.username, client.password.is_some());
+
+    let req = if starts_with_executable_sql_keyword(sql, &["SELECT", "SHOW"]) {
+        build_request(client, client.http.get(&url))
+    } else {
+        build_request(client, client.http.post(&url))
+    };
+
+    let resp = req.send().await.map_err(|e| format!("InfluxDB request failed: {e}"))?;
+    log::info!("[influxdb] response status={}", resp.status());
+    if !resp.status().is_success() {
+        return handle_influx_error(resp).await;
+    }
+    let response_text = resp.text().await.unwrap_or_default();
+    serde_json::from_str::<InfluxJsonResult>(&response_text)
+        .map_err(|e| format!("InfluxDB parse error: {e}; response: {response_text}"))
+}
+
+async fn influx_v2_buckets(client: &InfluxdbClient, timeout: Duration) -> Result<Vec<InfluxBucket>, String> {
+    require_v2_token(client)?;
+    let mut buckets = Vec::new();
+    let mut offset = 0;
+    loop {
+        let url = build_v2_buckets_url(client, offset)?;
+        let req = build_request(client, client.http.get(&url));
+        let resp = with_connection_timeout("InfluxDB", timeout, async {
+            req.send().await.map_err(|e| format!("InfluxDB connection failed: {e}"))
+        })
+        .await?;
+        if !resp.status().is_success() {
+            return handle_influx_error(resp).await;
+        }
+        let body = resp.text().await.unwrap_or_default();
+        let mut page = serde_json::from_str::<InfluxBucketsResult>(&body)
+            .map(|result| result.buckets)
+            .map_err(|e| format!("InfluxDB parse error: {e}; response: {body}"))?;
+        let page_len = page.len();
+        buckets.append(&mut page);
+        if page_len < 100 {
+            break;
+        }
+        offset += page_len;
+    }
+    Ok(buckets)
+}
+
+async fn influx_flux_query(client: &InfluxdbClient, sql: &str) -> Result<QueryResult, String> {
+    require_v2_token(client)?;
+    let start = Instant::now();
+    let url = build_v2_query_url(client)?;
+    let body = FluxQueryRequest { query: sql, query_type: "flux" };
+    let resp = build_request(client, client.http.post(&url).json(&body))
+        .send()
+        .await
+        .map_err(|e| format!("InfluxDB request failed: {e}"))?;
+    if !resp.status().is_success() {
+        return handle_influx_error(resp).await;
+    }
+    let response_text = resp.text().await.unwrap_or_default();
+    parse_flux_csv(&response_text, start)
+}
+
+pub async fn test_connection(client: &InfluxdbClient, timeout: Duration) -> Result<(), String> {
+    if client.version == InfluxdbApiVersion::V2 {
+        influx_v2_buckets(client, timeout).await?;
+        return Ok(());
+    }
+    let url = build_query_url(client, None, "SHOW DATABASES");
+    let req = build_request(client, client.http.get(&url));
+    let resp = with_connection_timeout("InfluxDB", timeout, async {
+        req.send().await.map_err(|e| format!("InfluxDB connection failed: {e}"))
+    })
+    .await?;
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        return Err(format!("InfluxDB error: {body}"));
+    }
+    Ok(())
+}
+
+pub async fn list_databases(client: &InfluxdbClient) -> Result<Vec<DatabaseInfo>, String> {
+    if client.version == InfluxdbApiVersion::V2 {
+        return Ok(influx_v2_buckets(client, Duration::from_secs(30))
+            .await?
+            .into_iter()
+            .map(|bucket| DatabaseInfo { name: bucket.name })
+            .collect());
+    }
+    let result = influx_query(client, "SHOW DATABASES", None).await?;
+    Ok(result
+        .results
+        .iter()
+        .flat_map(|r| &r.series)
+        .flat_map(|s| &s.values)
+        .map(|row| DatabaseInfo { name: row[0].as_str().unwrap_or("").to_string() })
+        .collect())
+}
+
+pub async fn list_tables(client: &InfluxdbClient, database: &str) -> Result<Vec<TableInfo>, String> {
+    if client.version == InfluxdbApiVersion::V2 {
+        let query = format!(
+            "import \"influxdata/influxdb/schema\"\nschema.measurements(bucket: \"{}\", start: 0)",
+            escape_flux_string(database)
+        );
+        let result = influx_flux_query(client, &query).await?;
+        return Ok(flux_column_values(&result, "_value")
+            .into_iter()
+            .map(|name| TableInfo {
+                name,
+                table_type: "TABLE".to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            })
+            .collect());
+    }
+    let result = influx_query(client, "SHOW MEASUREMENTS", Some(database)).await?;
+    let empty = vec![];
+    let series = result.results.first().map(|r| &r.series).unwrap_or(&empty);
+    if series.is_empty() {
+        return Ok(vec![]);
+    }
+    let first_series = &series[0];
+    Ok(first_series
+        .values
+        .iter()
+        .map(|row| TableInfo {
+            name: row[0].as_str().unwrap_or("").to_string(),
+            table_type: "TABLE".to_string(),
+            comment: None,
+            parent_schema: None,
+            parent_name: None,
+        })
+        .collect())
+}
+
+pub async fn get_columns(client: &InfluxdbClient, database: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    if client.version == InfluxdbApiVersion::V2 {
+        return get_columns_v2(client, database, table).await;
+    }
+    let empty = vec![];
+
+    let tag_sql = format!("SHOW TAG KEYS FROM \"{}\"", table);
+    let tag_result = influx_query(client, &tag_sql, Some(database)).await?;
+    let tag_series = tag_result.results.first().map(|r| &r.series).unwrap_or(&empty);
+
+    let field_sql = format!("SHOW FIELD KEYS FROM \"{}\"", table);
+    let field_result = influx_query(client, &field_sql, Some(database)).await?;
+    let field_series = field_result.results.first().map(|r| &r.series).unwrap_or(&empty);
+
+    let time_col = ColumnInfo {
+        name: "time".to_string(),
+        data_type: "timestamp".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: true,
+        extra: None,
+        comment: None,
+        numeric_precision: None,
+        numeric_scale: None,
+        character_maximum_length: None,
+        enum_values: None,
+        ..Default::default()
+    };
+
+    let cols: Vec<ColumnInfo> = std::iter::once(time_col)
+        .chain(tag_series.first().into_iter().flat_map(|s| s.values.iter()).map(|row| ColumnInfo {
+            name: row[0].as_str().unwrap_or("").to_string(),
+            data_type: "string".to_string(),
+            is_nullable: true,
+            column_default: None,
+            is_primary_key: true,
+            extra: None,
+            comment: None,
+            numeric_precision: None,
+            numeric_scale: None,
+            character_maximum_length: None,
+            enum_values: None,
+            ..Default::default()
+        }))
+        .chain(field_series.first().into_iter().flat_map(|s| s.values.iter()).map(|row| {
+            let data_type = row.get(1).and_then(|v| v.as_str()).unwrap_or("unknown").to_string();
+            ColumnInfo {
+                name: row[0].as_str().unwrap_or("").to_string(),
+                data_type,
+                is_nullable: true,
+                column_default: None,
+                is_primary_key: false,
+                extra: None,
+                comment: None,
+                numeric_precision: None,
+                numeric_scale: None,
+                character_maximum_length: None,
+                enum_values: None,
+                ..Default::default()
+            }
+        }))
+        .collect();
+
+    Ok(cols)
+}
+
+pub async fn execute_query(client: &InfluxdbClient, database: &str, sql: &str) -> Result<QueryResult, String> {
+    if client.version == InfluxdbApiVersion::V2 && looks_like_flux_query(sql) {
+        return influx_flux_query(client, sql).await;
+    }
+    let start = Instant::now();
+    let json = influx_query(client, sql, Some(database)).await?;
+    let series = json.results.iter().flat_map(|r| &r.series).next();
+    match series {
+        Some(s) => Ok(QueryResult {
+            columns: s.columns.clone(),
+            column_types: vec![],
+            column_sortables: s.columns.iter().map(|_| false).collect(),
+            rows: s.values.clone(),
+            affected_rows: s.values.len() as u64,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        }),
+        None => Ok(QueryResult {
+            columns: vec![],
+            column_types: vec![],
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: 0,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        }),
+    }
+}
+
+async fn get_columns_v2(client: &InfluxdbClient, bucket: &str, measurement: &str) -> Result<Vec<ColumnInfo>, String> {
+    let tag_query = format!(
+        "import \"influxdata/influxdb/schema\"\nschema.measurementTagKeys(bucket: \"{}\", measurement: \"{}\", start: 0)",
+        escape_flux_string(bucket),
+        escape_flux_string(measurement)
+    );
+    let field_query = format!(
+        "import \"influxdata/influxdb/schema\"\nschema.measurementFieldKeys(bucket: \"{}\", measurement: \"{}\", start: 0)",
+        escape_flux_string(bucket),
+        escape_flux_string(measurement)
+    );
+    let tag_result = influx_flux_query(client, &tag_query).await?;
+    let field_result = influx_flux_query(client, &field_query).await?;
+    let time_col = ColumnInfo {
+        name: "time".to_string(),
+        data_type: "timestamp".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: true,
+        extra: None,
+        comment: None,
+        numeric_precision: None,
+        numeric_scale: None,
+        character_maximum_length: None,
+        enum_values: None,
+        ..Default::default()
+    };
+    let tag_cols = flux_column_values(&tag_result, "_value")
+        .into_iter()
+        .filter(|name| !is_influx_system_column(name))
+        .map(|name| ColumnInfo {
+            name,
+            data_type: "string".to_string(),
+            is_nullable: true,
+            column_default: None,
+            is_primary_key: true,
+            extra: None,
+            comment: None,
+            numeric_precision: None,
+            numeric_scale: None,
+            character_maximum_length: None,
+            enum_values: None,
+            ..Default::default()
+        });
+    let field_cols = flux_column_values(&field_result, "_value").into_iter().map(|name| ColumnInfo {
+        name,
+        data_type: "field".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        numeric_precision: None,
+        numeric_scale: None,
+        character_maximum_length: None,
+        enum_values: None,
+        ..Default::default()
+    });
+    Ok(std::iter::once(time_col).chain(tag_cols).chain(field_cols).collect())
+}
+
+fn escape_flux_string(value: &str) -> String {
+    value.replace('\\', "\\\\").replace('"', "\\\"")
+}
+
+fn looks_like_flux_query(sql: &str) -> bool {
+    let trimmed = sql.trim_start().to_ascii_lowercase();
+    trimmed.starts_with("from(")
+        || trimmed.starts_with("import ")
+        || trimmed.starts_with("option ")
+        || trimmed.contains("|>")
+}
+
+fn is_influx_system_column(name: &str) -> bool {
+    matches!(name, "_start" | "_stop" | "_time" | "_value" | "_field" | "_measurement")
+}
+
+fn flux_column_values(result: &QueryResult, column: &str) -> Vec<String> {
+    let Some(index) = result.columns.iter().position(|name| name == column) else {
+        return Vec::new();
+    };
+    result
+        .rows
+        .iter()
+        .filter_map(|row| row.get(index).and_then(serde_json::Value::as_str))
+        .filter(|value| !value.trim().is_empty())
+        .map(str::to_string)
+        .collect()
+}
+
+fn parse_flux_csv(text: &str, start: Instant) -> Result<QueryResult, String> {
+    let mut headers: Option<Vec<String>> = None;
+    let mut rows = Vec::new();
+    let mut reader = csv::ReaderBuilder::new().has_headers(false).from_reader(text.as_bytes());
+    for record in reader.records() {
+        let record = record.map_err(|e| format!("InfluxDB Flux CSV parse error: {e}"))?;
+        if record.is_empty() || record.iter().all(|value| value.trim().is_empty()) {
+            continue;
+        }
+        if record.get(0).is_some_and(|value| value.starts_with('#')) {
+            continue;
+        }
+        if headers.is_none() {
+            let mut parsed = record.iter().map(str::to_string).collect::<Vec<_>>();
+            if parsed.first().is_some_and(|value| value.is_empty()) {
+                parsed.remove(0);
+            }
+            headers = Some(parsed);
+            continue;
+        }
+        let mut values =
+            record
+                .iter()
+                .map(|value| {
+                    if value.is_empty() {
+                        serde_json::Value::Null
+                    } else {
+                        serde_json::Value::String(value.to_string())
+                    }
+                })
+                .collect::<Vec<_>>();
+        if values.len() == headers.as_ref().map(Vec::len).unwrap_or_default() + 1
+            && record.get(0).is_some_and(|value| value.is_empty())
+        {
+            values.remove(0);
+        }
+        rows.push(values);
+    }
+    let columns = headers.unwrap_or_default();
+    Ok(QueryResult {
+        column_sortables: columns.iter().map(|_| false).collect(),
+        columns,
+        column_types: vec![],
+        affected_rows: rows.len() as u64,
+        rows,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+async fn handle_influx_error<T>(resp: Response) -> Result<T, String> {
+    let status = resp.status();
+
+    let status_message = match status {
+        reqwest::StatusCode::UNAUTHORIZED => Some("Unauthorized access."),
+        reqwest::StatusCode::FORBIDDEN => Some("Access denied."),
+        reqwest::StatusCode::NOT_FOUND => Some("Database not found."),
+        reqwest::StatusCode::UNPROCESSABLE_ENTITY => Some("Unprocessable entity."),
+        _ => None,
+    };
+
+    let error_msg = if let Some(msg) = status_message {
+        msg.to_string()
+    } else {
+        // 尝试从响应体中解析错误信息
+        let error_body = resp.text().await.unwrap_or_default();
+        extract_error_message(&error_body).unwrap_or_else(|| {
+            if error_body.trim().is_empty() {
+                "Unknown error.".to_string()
+            } else {
+                error_body
+            }
+        })
+    };
+
+    log::warn!("[influxdb] error response: status = {}, message = {}", status, error_msg);
+    Err(format!("InfluxDB error: status = {}, message = {}", status.as_str(), error_msg))
+}
+
+/// 从 InfluxDB 错误响应中提取错误消息
+fn extract_error_message(body: &str) -> Option<String> {
+    if body.trim().is_empty() {
+        return None;
+    }
+
+    serde_json::from_str::<InfluxErrorResult>(body).ok().and_then(|error_json| {
+        // 优先使用 error 字段，其次使用 message 字段
+        error_json
+            .error
+            .filter(|msg| !msg.trim().is_empty())
+            .or_else(|| error_json.message.filter(|msg| !msg.trim().is_empty()))
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn v1_client() -> InfluxdbClient {
+        InfluxdbClient {
+            http: reqwest::Client::new(),
+            base_url: "http://localhost:8086".to_string(),
+            username: None,
+            password: None,
+            url_params: None,
+            version: InfluxdbApiVersion::V1,
+            org: None,
+        }
+    }
+
+    #[test]
+    fn query_url() {
+        let client = v1_client();
+        let url = build_query_url(&client, Some("sample"), "SHOW DATABASES");
+
+        assert_eq!(url, "http://localhost:8086/query?db=sample&q=SHOW%20DATABASES");
+    }
+
+    #[test]
+    fn v2_config_uses_token_auth_and_org_urls() {
+        let config: ConnectionConfig = serde_json::from_value(json!({
+            "id": "influx-v2",
+            "name": "InfluxDB 2",
+            "db_type": "influxdb",
+            "host": "127.0.0.1",
+            "port": 8086,
+            "username": "ignored-user",
+            "password": "token-value",
+            "database": "metrics",
+            "external_config": {
+                "version": "2",
+                "org": "DBX Org"
+            }
+        }))
+        .unwrap();
+
+        let client = InfluxdbClient::new_for_config("http://localhost:8086/", &config, Duration::from_secs(1)).unwrap();
+
+        assert_eq!(client.version, InfluxdbApiVersion::V2);
+        assert_eq!(client.username, None);
+        assert_eq!(client.password.as_deref(), Some("token-value"));
+        assert_eq!(client.org.as_deref(), Some("DBX Org"));
+        assert_eq!(
+            build_v2_buckets_url(&client, 0).unwrap(),
+            "http://localhost:8086/api/v2/buckets?org=DBX%20Org&limit=100&offset=0"
+        );
+        assert_eq!(build_v2_query_url(&client).unwrap(), "http://localhost:8086/api/v2/query?org=DBX%20Org");
+    }
+
+    #[test]
+    fn v2_config_accepts_organization_alias() {
+        let config: ConnectionConfig = serde_json::from_value(json!({
+            "id": "influx-v2",
+            "name": "InfluxDB 2",
+            "db_type": "influxdb",
+            "host": "127.0.0.1",
+            "port": 8086,
+            "username": "",
+            "password": "token-value",
+            "external_config": {
+                "version": "v2",
+                "organization": "alias-org"
+            }
+        }))
+        .unwrap();
+
+        let client = InfluxdbClient::new_for_config("http://localhost:8086", &config, Duration::from_secs(1)).unwrap();
+
+        assert_eq!(client.version, InfluxdbApiVersion::V2);
+        assert_eq!(client.org.as_deref(), Some("alias-org"));
+    }
+
+    #[test]
+    fn parses_flux_csv_annotations() {
+        let csv = "\
+#datatype,string,long,dateTime:RFC3339,string,double
+#group,false,false,false,true,false
+#default,_result,,,,
+,result,table,_time,_measurement,_value
+,,0,2026-07-06T00:00:00Z,cpu,42.5
+";
+
+        let result = parse_flux_csv(csv, Instant::now()).unwrap();
+
+        assert_eq!(result.columns, vec!["result", "table", "_time", "_measurement", "_value"]);
+        assert_eq!(result.rows.len(), 1);
+        assert_eq!(result.rows[0][3], serde_json::Value::String("cpu".to_string()));
+        assert_eq!(result.rows[0][4], serde_json::Value::String("42.5".to_string()));
+    }
+
+    #[test]
+    fn recognizes_influx_system_columns() {
+        assert!(is_influx_system_column("_start"));
+        assert!(is_influx_system_column("_measurement"));
+        assert!(!is_influx_system_column("host"));
+        assert!(!is_influx_system_column("usage"));
+    }
+}
diff --git a/crates/dbx-core/src/db/manticoresearch.rs b/crates/dbx-core/src/db/manticoresearch.rs
new file mode 100644
index 0000000..3e5abad
--- /dev/null
+++ b/crates/dbx-core/src/db/manticoresearch.rs
@@ -0,0 +1,237 @@
+use mysql_async::prelude::*;
+use std::collections::HashMap;
+
+use crate::types::{ColumnInfo, IndexInfo, ObjectInfo};
+
+use super::mysql::{self, MySqlPool};
+
+fn quote_identifier(value: &str) -> String {
+    format!("`{}`", value.replace('`', "``"))
+}
+
+fn row_get<T, I>(row: &mysql_async::Row, index: I) -> Option<T>
+where
+    T: mysql_async::prelude::FromValue,
+    I: mysql_async::prelude::ColumnIndex,
+{
+    row.get_opt::<T, I>(index).and_then(|result| result.ok())
+}
+
+fn get_str_by_name(row: &mysql_async::Row, name: &str) -> String {
+    row_get::<String, _>(row, name)
+        .or_else(|| row_get::<Vec<u8>, _>(row, name).map(|bytes| String::from_utf8_lossy(&bytes).to_string()))
+        .unwrap_or_default()
+}
+
+fn get_opt_str(row: &mysql_async::Row, name: &str) -> Option<String> {
+    row_get::<String, _>(row, name)
+        .or_else(|| row_get::<Vec<u8>, _>(row, name).map(|bytes| String::from_utf8_lossy(&bytes).to_string()))
+}
+
+fn preferred_metadata(primary: Option<String>, fallback: Option<String>) -> Option<String> {
+    primary.filter(|value| !value.trim().is_empty()).or_else(|| fallback.filter(|value| !value.trim().is_empty()))
+}
+
+pub async fn list_objects(pool: &MySqlPool, database: &str) -> Result<Vec<ObjectInfo>, String> {
+    let (tables, functions) = tokio::join!(mysql::list_tables_show(pool, database), list_udf_objects(pool, database));
+    let mut objects: Vec<ObjectInfo> = tables?
+        .into_iter()
+        .map(|table| ObjectInfo {
+            name: table.name,
+            object_type: "TABLE".to_string(),
+            schema: Some(database.to_string()),
+            signature: None,
+            comment: table.comment,
+            created_at: None,
+            updated_at: None,
+            parent_schema: table.parent_schema,
+            parent_name: table.parent_name,
+        })
+        .collect();
+
+    match functions {
+        Ok(functions) => objects.extend(functions),
+        Err(err) => log::warn!("Skipping UDFs for Manticore Search database `{}` in object browser: {}", database, err),
+    }
+
+    Ok(objects)
+}
+
+async fn list_udf_objects(pool: &MySqlPool, database: &str) -> Result<Vec<ObjectInfo>, String> {
+    let mut conn = pool.get_conn().await.map_err(|err| err.to_string())?;
+    let result = conn.query_iter("SHOW PLUGINS").await.map_err(|err| err.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|err| err.to_string())?;
+    Ok(rows
+        .iter()
+        .filter_map(|row| {
+            plugin_object(
+                &get_str_by_name(row, "Type"),
+                &get_str_by_name(row, "Name"),
+                get_opt_str(row, "Library").as_deref(),
+                get_opt_str(row, "Extra").as_deref(),
+                database,
+            )
+        })
+        .collect())
+}
+
+fn plugin_object(
+    plugin_type: &str,
+    name: &str,
+    library: Option<&str>,
+    extra: Option<&str>,
+    database: &str,
+) -> Option<ObjectInfo> {
+    if !plugin_type.eq_ignore_ascii_case("udf") {
+        return None;
+    }
+    let name = name.trim();
+    if name.is_empty() {
+        return None;
+    }
+    let mut comment_parts = Vec::new();
+    if let Some(library) = library.map(str::trim).filter(|value| !value.is_empty()) {
+        comment_parts.push(format!("SONAME {library}"));
+    }
+    if let Some(return_type) = extra.map(str::trim).filter(|value| !value.is_empty()) {
+        comment_parts.push(format!("RETURNS {return_type}"));
+    }
+    Some(ObjectInfo {
+        name: name.to_string(),
+        object_type: "FUNCTION".to_string(),
+        schema: Some(database.to_string()),
+        signature: None,
+        comment: if comment_parts.is_empty() { None } else { Some(comment_parts.join(", ")) },
+        created_at: None,
+        updated_at: None,
+        parent_schema: None,
+        parent_name: None,
+    })
+}
+
+pub async fn get_columns(pool: &MySqlPool, database: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let mut columns = mysql::get_columns_show(pool, database, table).await?;
+    let properties = column_properties(pool, database, table).await.unwrap_or_default();
+    for column in &mut columns {
+        if let Some(property) = properties.get(&column.name.to_lowercase()) {
+            column.extra = preferred_metadata(column.extra.take(), Some(property.clone()));
+        }
+    }
+    Ok(columns)
+}
+
+async fn column_properties(pool: &MySqlPool, database: &str, table: &str) -> Result<HashMap<String, String>, String> {
+    let sql = show_columns_sql(database, table, true);
+    let mut conn = pool.get_conn().await.map_err(|err| err.to_string())?;
+    let rows: Vec<mysql_async::Row> = match conn.query_iter(&sql).await {
+        Ok(result) => result.collect_and_drop().await.map_err(|err| err.to_string())?,
+        Err(_) => {
+            let sql = show_columns_sql(database, table, false);
+            let result = conn.query_iter(&sql).await.map_err(|err| err.to_string())?;
+            result.collect_and_drop().await.map_err(|err| err.to_string())?
+        }
+    };
+    Ok(rows
+        .iter()
+        .filter_map(|row| {
+            let name = get_str_by_name(row, "Field").trim().to_string();
+            if name.is_empty() {
+                return None;
+            }
+            get_opt_str(row, "Properties")
+                .filter(|value| !value.trim().is_empty())
+                .map(|properties| (name.to_lowercase(), properties))
+        })
+        .collect())
+}
+
+fn show_columns_sql(database: &str, table: &str, full: bool) -> String {
+    let prefix = if full { "SHOW FULL COLUMNS FROM" } else { "SHOW COLUMNS FROM" };
+    if database.trim().is_empty() {
+        format!("{prefix} {}", quote_identifier(table))
+    } else {
+        format!("{prefix} {}.{}", quote_identifier(database), quote_identifier(table))
+    }
+}
+
+pub async fn list_indexes(pool: &MySqlPool, table: &str) -> Result<Vec<IndexInfo>, String> {
+    let sql = list_indexes_sql(table);
+    let mut conn = pool.get_conn().await.map_err(|err| err.to_string())?;
+    let result = conn.query_iter(&sql).await.map_err(|err| err.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|err| err.to_string())?;
+
+    Ok(rows.iter().map(index_info_from_row).collect())
+}
+
+fn list_indexes_sql(table: &str) -> String {
+    format!("SHOW TABLE INDEXES FROM {}", quote_identifier(table))
+}
+
+fn index_info_from_row(row: &mysql_async::Row) -> IndexInfo {
+    let name = get_str_by_name(row, "Name");
+    let enabled = get_str_by_name(row, "Enabled");
+    let percent = get_str_by_name(row, "Percent");
+    let comment_parts: Vec<String> = [
+        (!enabled.is_empty()).then(|| format!("Enabled: {enabled}")),
+        (!percent.is_empty()).then(|| format!("Percent: {percent}")),
+    ]
+    .into_iter()
+    .flatten()
+    .collect();
+
+    IndexInfo {
+        name: name.clone(),
+        columns: vec![name],
+        is_unique: false,
+        is_primary: false,
+        filter: None,
+        index_type: Some(get_str_by_name(row, "Type")),
+        included_columns: None,
+        comment: (!comment_parts.is_empty()).then(|| comment_parts.join(", ")),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn show_metadata_uses_unqualified_table_names_when_database_is_empty() {
+        assert_eq!(show_columns_sql("", "idx", true), "SHOW FULL COLUMNS FROM `idx`");
+    }
+
+    #[test]
+    fn column_extra_falls_back_to_properties() {
+        assert_eq!(
+            preferred_metadata(Some("auto_increment".to_string()), Some("indexed attribute".to_string())),
+            Some("auto_increment".to_string())
+        );
+        assert_eq!(
+            preferred_metadata(Some("  ".to_string()), Some("indexed attribute".to_string())),
+            Some("indexed attribute".to_string())
+        );
+        assert_eq!(preferred_metadata(None, Some("  ".to_string())), None);
+    }
+
+    #[test]
+    fn indexes_sql_uses_show_table_indexes() {
+        assert_eq!(list_indexes_sql("materials"), "SHOW TABLE INDEXES FROM `materials`");
+        assert_eq!(list_indexes_sql("odd`name"), "SHOW TABLE INDEXES FROM `odd``name`");
+    }
+
+    #[test]
+    fn udf_plugin_maps_to_function_object() {
+        let object = plugin_object("udf", "sequence", Some("udfexample.dll"), Some("INT"), "app").expect("udf plugin");
+
+        assert_eq!(object.name, "sequence");
+        assert_eq!(object.object_type, "FUNCTION");
+        assert_eq!(object.schema.as_deref(), Some("app"));
+        assert_eq!(object.comment.as_deref(), Some("SONAME udfexample.dll, RETURNS INT"));
+    }
+
+    #[test]
+    fn non_udf_plugins_are_not_sidebar_functions() {
+        assert!(plugin_object("ranker", "bm25", Some("ranker.so"), None, "app").is_none());
+        assert!(plugin_object("udf", "   ", Some("udf.so"), Some("INT"), "app").is_none());
+    }
+}
diff --git a/crates/dbx-core/src/db/mod.rs b/crates/dbx-core/src/db/mod.rs
new file mode 100644
index 0000000..089e1d1
--- /dev/null
+++ b/crates/dbx-core/src/db/mod.rs
@@ -0,0 +1,167 @@
+pub mod agent_driver;
+pub mod clickhouse_driver;
+pub mod cloudflare_d1;
+pub use cloudflare_d1 as cloudflare_d1_driver;
+pub mod duckdb_driver;
+#[cfg(feature = "duckdb-bundled")]
+pub mod duckdb_worker_process;
+#[cfg(feature = "duckdb-bundled")]
+pub mod duckdb_worker_protocol;
+#[cfg(feature = "duckdb-bundled")]
+pub mod duckdb_worker_runtime;
+pub mod elasticsearch_driver;
+pub mod elasticsearch_sql;
+pub mod file_validator;
+pub mod http_tunnel;
+pub mod influxdb_driver;
+pub mod manticoresearch;
+pub mod mongo_driver;
+pub mod mysql;
+pub mod ob_oracle;
+pub mod postgres;
+pub mod proxy_tunnel;
+pub mod questdb;
+pub mod redis_driver;
+pub mod rqlite_driver;
+pub mod sqlite;
+pub mod sqlserver;
+pub mod ssh_tunnel;
+pub mod transport_layer_tunnel;
+pub mod turso_driver;
+pub mod vector_driver;
+pub mod wkb;
+
+use reqwest::ClientBuilder;
+use std::future::Future;
+use std::time::Duration;
+
+// Re-export types so that `db::QueryResult` etc. work within dbx-core
+pub use crate::types::*;
+pub use file_validator::validate_file_path;
+
+pub const CONNECTION_TIMEOUT_SECS: u64 = 5;
+pub const TCP_PROBE_TIMEOUT_SECS: u64 = 3;
+
+pub fn connection_timeout() -> Duration {
+    Duration::from_secs(CONNECTION_TIMEOUT_SECS)
+}
+
+pub fn http_client_builder(timeout: Duration) -> ClientBuilder {
+    reqwest::Client::builder().connect_timeout(timeout).no_proxy()
+}
+
+const JS_MAX_SAFE_INTEGER: i64 = 9_007_199_254_740_991;
+
+pub fn safe_i64_to_json(v: i64) -> serde_json::Value {
+    if !(-JS_MAX_SAFE_INTEGER..=JS_MAX_SAFE_INTEGER).contains(&v) {
+        serde_json::Value::String(v.to_string())
+    } else {
+        serde_json::Value::Number(v.into())
+    }
+}
+
+pub fn safe_u64_to_json(v: u64) -> serde_json::Value {
+    if v > JS_MAX_SAFE_INTEGER as u64 {
+        serde_json::Value::String(v.to_string())
+    } else {
+        serde_json::Value::Number(v.into())
+    }
+}
+
+pub fn json_value_for_js(value: serde_json::Value) -> serde_json::Value {
+    match value {
+        serde_json::Value::Number(number) => {
+            if let Some(value) = number.as_i64() {
+                safe_i64_to_json(value)
+            } else if let Some(value) = number.as_u64() {
+                safe_u64_to_json(value)
+            } else {
+                serde_json::Value::Number(number)
+            }
+        }
+        serde_json::Value::Array(values) => {
+            serde_json::Value::Array(values.into_iter().map(json_value_for_js).collect())
+        }
+        serde_json::Value::Object(entries) => {
+            serde_json::Value::Object(entries.into_iter().map(|(key, value)| (key, json_value_for_js(value))).collect())
+        }
+        value => value,
+    }
+}
+
+pub(crate) fn hex_encode(bytes: &[u8]) -> String {
+    const HEX: &[u8; 16] = b"0123456789abcdef";
+    let mut out = String::with_capacity(bytes.len() * 2);
+    for &byte in bytes {
+        out.push(HEX[(byte >> 4) as usize] as char);
+        out.push(HEX[(byte & 0x0f) as usize] as char);
+    }
+    out
+}
+
+pub(crate) fn binary_value_to_json(bytes: &[u8]) -> serde_json::Value {
+    serde_json::Value::String(format!("0x{}", hex_encode(bytes)))
+}
+
+pub fn tcp_probe_timeout() -> Duration {
+    Duration::from_secs(TCP_PROBE_TIMEOUT_SECS)
+}
+
+pub fn parse_connect_timeout(url: &str) -> Duration {
+    parse_connect_timeout_with_fallback(url, connection_timeout())
+}
+
+pub fn parse_connect_timeout_with_fallback(url: &str, fallback: Duration) -> Duration {
+    let Some(query) = url.split('?').nth(1) else {
+        return fallback;
+    };
+    for param in query.split('&') {
+        let trimmed = param.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        let (key, value) = match trimmed.split_once('=') {
+            Some(pair) => pair,
+            None => continue,
+        };
+        if key.eq_ignore_ascii_case("connect_timeout")
+            || key.eq_ignore_ascii_case("connectTimeout")
+            || key.eq_ignore_ascii_case("connection_timeout")
+            || key.eq_ignore_ascii_case("connectionTimeout")
+        {
+            if let Ok(v) = value.parse::<u64>() {
+                if (1..=300).contains(&v) {
+                    return Duration::from_secs(v);
+                }
+            }
+        }
+    }
+    fallback
+}
+
+pub async fn with_connection_timeout<T, F>(label: &str, timeout: Duration, future: F) -> Result<T, String>
+where
+    F: Future<Output = Result<T, String>>,
+{
+    tokio::time::timeout(timeout, future)
+        .await
+        .map_err(|_| format!("{label} connection timed out ({}s)", timeout.as_secs()))?
+}
+
+pub async fn probe_tcp_endpoint(label: &str, host: &str, port: u16, timeout: Duration) -> Result<(), String> {
+    tokio::time::timeout(timeout, tokio::net::TcpStream::connect((host, port)))
+        .await
+        .map_err(|_| format!("{label} TCP connection timed out ({}s)", timeout.as_secs()))?
+        .map(|_| ())
+        .map_err(|e| format!("{label} TCP connection failed: {e}"))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn binary_values_are_displayed_as_prefixed_hex() {
+        assert_eq!(binary_value_to_json(&[0x00, 0x01, 0xab, 0xff]), serde_json::json!("0x0001abff"));
+    }
+}
diff --git a/crates/dbx-core/src/db/mongo_driver.rs b/crates/dbx-core/src/db/mongo_driver.rs
new file mode 100644
index 0000000..474bf7b
--- /dev/null
+++ b/crates/dbx-core/src/db/mongo_driver.rs
@@ -0,0 +1,1832 @@
+use mongodb::{
+    bson::{doc, oid::ObjectId, Bson, DateTime, Document},
+    options::{ClientOptions, GridFsBucketOptions, IndexOptions},
+    Client, Database, IndexModel,
+};
+use serde::{Deserialize, Serialize};
+
+use super::with_connection_timeout;
+use crate::document_ops::{MongoGridFsBucketInfo, MongoGridFsFileInfo};
+use crate::types::IndexInfo;
+use futures::{io::AsyncReadExt, io::AsyncWriteExt, TryStreamExt};
+use percent_encoding::percent_decode_str;
+use std::{collections::HashSet, time::Duration};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MongoDocumentResult {
+    pub documents: Vec<serde_json::Value>,
+    pub total: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MongoDropIndexesResult {
+    pub dropped_names: Vec<String>,
+    pub affected_rows: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct MongoCollectionStatsResult {
+    pub count: serde_json::Value,
+    pub size: serde_json::Value,
+    #[serde(rename = "avgObjSize")]
+    pub avg_obj_size: serde_json::Value,
+    #[serde(rename = "storageSize")]
+    pub storage_size: serde_json::Value,
+    #[serde(rename = "totalIndexSize")]
+    pub total_index_size: serde_json::Value,
+    pub nindexes: serde_json::Value,
+}
+
+pub async fn connect(url: &str, timeout: Duration, idle_timeout: Duration) -> Result<Client, String> {
+    let url = normalize_mongo_uri_direct_connection(url);
+    let is_multi_host = is_multi_host_mongo_uri(&url);
+    let parse_timeout = if is_multi_host { std::cmp::max(timeout * 2, Duration::from_secs(10)) } else { timeout };
+
+    with_connection_timeout("MongoDB", parse_timeout, async {
+        let mut options = ClientOptions::parse(&url).await.map_err(|e| format!("MongoDB connection failed: {e}"))?;
+        options.connect_timeout = Some(timeout);
+        options.server_selection_timeout =
+            if is_multi_host { Some(std::cmp::max(timeout * 2, Duration::from_secs(10))) } else { Some(timeout) };
+        // Close idle connections before the server-side timeout drops them,
+        // preventing "Broken pipe" (os error 32) or "unexpected end of file".
+        // 0 means no idle timeout (keep connections alive indefinitely).
+        if idle_timeout.as_secs() > 0 {
+            options.max_idle_time = Some(idle_timeout);
+        }
+        // For single-host connections, force direct connection to avoid replica
+        // set discovery. This is essential when connecting through a TCP proxy
+        // or NAT where the driver would otherwise receive internal IPs from
+        // the replica set handshake and fail to connect.
+        if !is_multi_host {
+            options.direct_connection = Some(true);
+        }
+        Client::with_options(options).map_err(|e| format!("MongoDB connection failed: {e}"))
+    })
+    .await
+}
+
+fn normalize_mongo_uri_direct_connection(uri: &str) -> String {
+    if !is_multi_host_mongo_uri(uri) || !mongo_uri_has_direct_connection_true(uri) {
+        return uri.to_string();
+    }
+
+    let (before_fragment, fragment) =
+        uri.split_once('#').map(|(base, fragment)| (base, Some(fragment))).unwrap_or((uri, None));
+    let Some((base, query)) = before_fragment.split_once('?') else {
+        return uri.to_string();
+    };
+    let params =
+        query.split('&').filter(|part| !mongo_url_param_is_direct_connection_true(part)).collect::<Vec<_>>().join("&");
+
+    let mut normalized = if params.is_empty() { base.to_string() } else { format!("{base}?{params}") };
+    if let Some(fragment) = fragment {
+        normalized.push('#');
+        normalized.push_str(fragment);
+    }
+    normalized
+}
+
+fn is_multi_host_mongo_uri(url: &str) -> bool {
+    if url.get(..14).is_some_and(|scheme| scheme.eq_ignore_ascii_case("mongodb+srv://")) {
+        // SRV URLs expand to a DNS seed list during driver parsing, so forcing
+        // directConnection would be rejected even though the URI shows one host.
+        return true;
+    }
+    let rest = match url.strip_prefix("mongodb://").or_else(|| url.strip_prefix("mongodb+srv://")) {
+        Some(r) => r,
+        None => return false,
+    };
+    let authority = match rest.split('/').next() {
+        Some(a) => a,
+        None => return false,
+    };
+    let host_section = match authority.rfind('@') {
+        Some(idx) => &authority[idx + 1..],
+        None => authority,
+    };
+    host_section.contains(',')
+}
+
+fn mongo_uri_has_direct_connection_true(uri: &str) -> bool {
+    uri.split_once('?')
+        .map(|(_, query)| {
+            query.split('#').next().unwrap_or("").split('&').any(mongo_url_param_is_direct_connection_true)
+        })
+        .unwrap_or(false)
+}
+
+fn mongo_url_param_is_direct_connection_true(part: &str) -> bool {
+    let Some((key, value)) = part.split_once('=') else {
+        return false;
+    };
+    percent_decode_str(key).decode_utf8_lossy().eq_ignore_ascii_case("directConnection")
+        && percent_decode_str(value).decode_utf8_lossy().eq_ignore_ascii_case("true")
+}
+
+pub async fn test_connection(client: &Client, timeout: Duration, database: Option<&str>) -> Result<(), String> {
+    let database = database.map(str::trim).filter(|value| !value.is_empty()).unwrap_or("admin");
+    let client = client.clone();
+    let database = database.to_string();
+    with_connection_timeout("MongoDB", timeout, async move {
+        client
+            .database(&database)
+            .run_command(doc! { "ping": 1 })
+            .await
+            .map(|_| ())
+            .map_err(|e| format!("MongoDB connection failed: {e}"))
+    })
+    .await
+}
+
+pub async fn server_version(client: &Client, database: &str) -> Result<String, String> {
+    let database = database.trim();
+    let database = if database.is_empty() { "admin" } else { database };
+    let result = client.database(database).run_command(doc! { "buildInfo": 1 }).await.map_err(|e| e.to_string())?;
+    server_version_from_build_info(&result)
+}
+
+fn server_version_from_build_info(result: &Document) -> Result<String, String> {
+    result.get_str("version").map(str::to_string).map_err(|e| format!("MongoDB server version not found: {e}"))
+}
+
+pub async fn collection_stats(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    scale: Option<serde_json::Number>,
+) -> Result<MongoCollectionStatsResult, String> {
+    let database = database.trim();
+    let collection = collection.trim();
+    if database.is_empty() {
+        return Err("Database name is required".to_string());
+    }
+    if collection.is_empty() {
+        return Err("Collection name is required".to_string());
+    }
+
+    let result = client
+        .database(database)
+        .run_command(collection_stats_command_document(collection, scale.as_ref()))
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(collection_stats_result_from_document(&result))
+}
+
+fn collection_stats_command_document(collection: &str, scale: Option<&serde_json::Number>) -> Document {
+    let mut command = doc! { "collStats": collection };
+    if let Some(scale) = scale {
+        command.insert("scale", json_value_to_bson(&serde_json::Value::Number(scale.clone())));
+    }
+    command
+}
+
+fn collection_stats_result_from_document(result: &Document) -> MongoCollectionStatsResult {
+    MongoCollectionStatsResult {
+        count: collection_stats_field(result, "count"),
+        size: collection_stats_field(result, "size"),
+        avg_obj_size: collection_stats_field(result, "avgObjSize"),
+        storage_size: collection_stats_field(result, "storageSize"),
+        total_index_size: collection_stats_field(result, "totalIndexSize"),
+        nindexes: collection_stats_field(result, "nindexes"),
+    }
+}
+
+fn collection_stats_field(result: &Document, key: &str) -> serde_json::Value {
+    result.get(key).map(bson_to_json).unwrap_or(serde_json::Value::Null)
+}
+
+pub async fn list_databases(client: &Client) -> Result<Vec<String>, String> {
+    client.list_database_names().await.map_err(|e| e.to_string())
+}
+
+pub async fn list_collections(client: &Client, database: &str) -> Result<Vec<String>, String> {
+    client.database(database).list_collection_names().await.map_err(|e| e.to_string())
+}
+
+pub async fn list_gridfs_files(
+    client: &Client,
+    database: &str,
+    bucket: &str,
+    filter: Option<&str>,
+    sort: Option<&str>,
+) -> Result<Vec<MongoGridFsFileInfo>, String> {
+    let bucket = normalized_gridfs_bucket_name(bucket)?;
+    let collection_name = format!("{bucket}.files");
+    let collection = client.database(database).collection::<Document>(&collection_name);
+    let filter_doc = gridfs_file_filter_document(filter)?;
+    let sort_doc = gridfs_file_sort_document(sort)?;
+    let mut cursor = collection.find(filter_doc).sort(sort_doc).await.map_err(|e| e.to_string())?;
+    let mut files = Vec::new();
+    while cursor.advance().await.map_err(|e| e.to_string())? {
+        let doc = cursor.deserialize_current().map_err(|e| e.to_string())?;
+        files.push(gridfs_file_info_from_document(&doc));
+    }
+    Ok(files)
+}
+
+fn gridfs_file_filter_document(filter: Option<&str>) -> Result<Document, String> {
+    match filter {
+        Some(raw) if !raw.trim().is_empty() => {
+            let json: serde_json::Value = serde_json::from_str(raw).map_err(|e| format!("Invalid filter JSON: {e}"))?;
+            json_filter_to_document(&json)
+        }
+        _ => Ok(doc! {}),
+    }
+}
+
+fn gridfs_file_sort_document(sort: Option<&str>) -> Result<Document, String> {
+    match sort {
+        Some(raw) if !raw.trim().is_empty() => {
+            let json: serde_json::Value = serde_json::from_str(raw).map_err(|e| format!("Invalid sort JSON: {e}"))?;
+            json_object_to_document(&json).map_err(|e| format!("Invalid sort: {e}"))
+        }
+        _ => Ok(doc! { "uploadDate": -1_i32, "_id": -1_i32 }),
+    }
+}
+
+pub async fn gridfs_bucket_summary(
+    client: &Client,
+    database: &str,
+    bucket: &str,
+) -> Result<MongoGridFsBucketInfo, String> {
+    let bucket = normalized_gridfs_bucket_name(bucket)?;
+    let collection = client.database(database).collection::<Document>(&format!("{bucket}.files"));
+    let mut cursor = collection
+        .aggregate(vec![doc! {
+            "$group": {
+                "_id": Bson::Null,
+                "fileCount": { "$sum": 1_i32 },
+                "totalBytes": { "$sum": "$length" },
+            }
+        }])
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let mut file_count = 0_u64;
+    let mut total_bytes = 0_i64;
+    if cursor.advance().await.map_err(|e| e.to_string())? {
+        let doc = cursor.deserialize_current().map_err(|e| e.to_string())?;
+        file_count =
+            doc.get_i64("fileCount").or_else(|_| doc.get_i32("fileCount").map(i64::from)).unwrap_or(0).max(0) as u64;
+        total_bytes = doc.get_i64("totalBytes").or_else(|_| doc.get_i32("totalBytes").map(i64::from)).unwrap_or(0);
+    }
+
+    Ok(MongoGridFsBucketInfo { name: bucket, file_count, total_bytes })
+}
+
+pub async fn create_gridfs_bucket(client: &Client, database: &str, bucket: &str) -> Result<(), String> {
+    let bucket = normalized_gridfs_bucket_name(bucket)?;
+    let database = client.database(database);
+    let files_name = format!("{bucket}.files");
+    let chunks_name = format!("{bucket}.chunks");
+    let existing: HashSet<String> =
+        database.list_collection_names().await.map_err(|e| e.to_string())?.into_iter().collect();
+
+    if !existing.contains(&files_name) {
+        database.create_collection(&files_name).await.map_err(|e| e.to_string())?;
+    }
+    if !existing.contains(&chunks_name) {
+        database.create_collection(&chunks_name).await.map_err(|e| e.to_string())?;
+    }
+
+    database
+        .collection::<Document>(&files_name)
+        .create_index(
+            IndexModel::builder()
+                .keys(doc! { "filename": 1_i32, "uploadDate": 1_i32 })
+                .options(IndexOptions::builder().name(Some("filename_1_uploadDate_1".to_string())).build())
+                .build(),
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+    database
+        .collection::<Document>(&chunks_name)
+        .create_index(
+            IndexModel::builder()
+                .keys(doc! { "files_id": 1_i32, "n": 1_i32 })
+                .options(IndexOptions::builder().name(Some("files_id_1_n_1".to_string())).unique(Some(true)).build())
+                .build(),
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+
+    Ok(())
+}
+
+pub async fn delete_gridfs_bucket(client: &Client, database: &str, bucket: &str) -> Result<(), String> {
+    let bucket = normalized_gridfs_bucket_name(bucket)?;
+    let database = client.database(database);
+    drop_collection_if_exists(&database, &format!("{bucket}.files")).await?;
+    drop_collection_if_exists(&database, &format!("{bucket}.chunks")).await?;
+    Ok(())
+}
+
+pub async fn download_gridfs_file(
+    client: &Client,
+    database: &str,
+    bucket: &str,
+    file_id: &str,
+) -> Result<Vec<u8>, String> {
+    let bucket = normalized_gridfs_bucket_name(bucket)?;
+    let trimmed = file_id.trim();
+    if trimmed.is_empty() {
+        return Err("GridFS file id is required".to_string());
+    }
+
+    let bson_id = parse_gridfs_file_id(trimmed)?;
+
+    let files_collection = client.database(database).collection::<Document>(&format!("{bucket}.files"));
+    let file_doc = files_collection
+        .find_one(doc! { "_id": bson_id.clone() })
+        .await
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "GridFS file not found".to_string())?;
+    let bucket =
+        client.database(database).gridfs_bucket(GridFsBucketOptions::builder().bucket_name(bucket.to_string()).build());
+    let mut stream = bucket
+        .open_download_stream(file_doc.get("_id").cloned().unwrap_or(bson_id))
+        .await
+        .map_err(|e| e.to_string())?;
+    let mut bytes = Vec::new();
+    stream.read_to_end(&mut bytes).await.map_err(|e| e.to_string())?;
+    Ok(bytes)
+}
+
+pub async fn upload_gridfs_file(
+    client: &Client,
+    database: &str,
+    bucket: &str,
+    file_name: &str,
+    data: &[u8],
+    content_type: Option<&str>,
+) -> Result<String, String> {
+    let bucket = normalized_gridfs_bucket_name(bucket)?;
+    let file_name = file_name.trim();
+    if file_name.is_empty() {
+        return Err("GridFS file name is required".to_string());
+    }
+
+    create_gridfs_bucket(client, database, &bucket).await?;
+
+    let database_ref = client.database(database);
+    let gridfs_bucket = database_ref.gridfs_bucket(GridFsBucketOptions::builder().bucket_name(bucket.clone()).build());
+    let mut upload_action = gridfs_bucket.open_upload_stream(file_name);
+    if let Some(content_type) = content_type.map(str::trim).filter(|value| !value.is_empty()) {
+        upload_action = upload_action.metadata(doc! { "contentType": content_type });
+    }
+    let mut stream = upload_action.await.map_err(|e| e.to_string())?;
+    let file_id = stream.id().clone();
+    stream.write_all(data).await.map_err(|e| e.to_string())?;
+    stream.close().await.map_err(|e| e.to_string())?;
+
+    if let Some(content_type) = content_type.map(str::trim).filter(|value| !value.is_empty()) {
+        database_ref
+            .collection::<Document>(&format!("{bucket}.files"))
+            .update_one(doc! { "_id": file_id.clone() }, doc! { "$set": { "contentType": content_type } })
+            .await
+            .map_err(|e| e.to_string())?;
+    }
+
+    Ok(gridfs_file_id_to_string(&file_id))
+}
+
+pub async fn delete_gridfs_file(client: &Client, database: &str, bucket: &str, file_id: &str) -> Result<(), String> {
+    let bucket = normalized_gridfs_bucket_name(bucket)?;
+    let bson_id = parse_gridfs_file_id(file_id.trim())?;
+    client
+        .database(database)
+        .gridfs_bucket(GridFsBucketOptions::builder().bucket_name(bucket).build())
+        .delete(bson_id)
+        .await
+        .map_err(|e| e.to_string())
+}
+
+fn gridfs_file_id_to_string(id: &Bson) -> String {
+    match id {
+        Bson::ObjectId(value) => value.to_hex(),
+        Bson::String(value) => value.clone(),
+        _ => id.clone().into_relaxed_extjson().to_string(),
+    }
+}
+
+fn gridfs_upload_date_to_string(value: &DateTime) -> String {
+    value.try_to_rfc3339_string().unwrap_or_else(|_| value.timestamp_millis().to_string())
+}
+
+fn gridfs_file_info_from_document(doc: &Document) -> MongoGridFsFileInfo {
+    let id = gridfs_file_id_to_string(doc.get("_id").unwrap_or(&Bson::Null));
+    let filename = doc.get_str("filename").ok().map(str::to_string);
+    let length = doc.get_i64("length").or_else(|_| doc.get_i32("length").map(i64::from)).unwrap_or(0);
+    let chunk_size =
+        doc.get_i32("chunkSize").or_else(|_| doc.get_i64("chunkSize").map(|value| value as i32)).unwrap_or(0);
+    let upload_date = doc.get_datetime("uploadDate").ok().map(gridfs_upload_date_to_string);
+    let metadata = doc.get_document("metadata").ok().map(|value| Bson::Document(value.clone()).into_relaxed_extjson());
+    let md5 = doc.get_str("md5").ok().map(str::to_string);
+    let content_type = doc.get_str("contentType").ok().map(str::to_string).or_else(|| {
+        doc.get_document("metadata").ok().and_then(|meta| meta.get_str("contentType").ok().map(str::to_string))
+    });
+    let aliases = doc.get_array("aliases").ok().and_then(|values| {
+        let aliases: Vec<String> = values.iter().filter_map(|value| value.as_str().map(str::to_string)).collect();
+        if aliases.is_empty() {
+            None
+        } else {
+            Some(aliases)
+        }
+    });
+
+    MongoGridFsFileInfo { id, filename, length, chunk_size, upload_date, metadata, md5, content_type, aliases }
+}
+
+fn parse_gridfs_file_id(file_id: &str) -> Result<Bson, String> {
+    if let Ok(value) = serde_json::from_str::<serde_json::Value>(file_id) {
+        return Bson::try_from(value).map_err(|e| format!("Invalid GridFS file id: {e}"));
+    }
+
+    if let Ok(object_id) = ObjectId::parse_str(file_id) {
+        return Ok(Bson::ObjectId(object_id));
+    }
+
+    Ok(Bson::String(file_id.to_string()))
+}
+
+fn normalized_gridfs_bucket_name(bucket: &str) -> Result<String, String> {
+    let bucket = bucket.trim();
+    if bucket.is_empty() {
+        return Err("GridFS bucket name is required".to_string());
+    }
+    if bucket.ends_with(".files") || bucket.ends_with(".chunks") {
+        return Err("Use the GridFS bucket name without the .files or .chunks suffix".to_string());
+    }
+    Ok(bucket.to_string())
+}
+
+async fn drop_collection_if_exists(database: &Database, collection_name: &str) -> Result<(), String> {
+    match database.collection::<Document>(collection_name).drop().await {
+        Ok(()) => Ok(()),
+        Err(error) if mongo_namespace_missing(&error.to_string()) => Ok(()),
+        Err(error) => Err(error.to_string()),
+    }
+}
+
+fn mongo_namespace_missing(error: &str) -> bool {
+    let lower = error.to_lowercase();
+    lower.contains("ns not found") || lower.contains("namespace not found")
+}
+
+pub async fn create_database(client: &Client, database: &str) -> Result<(), String> {
+    let database = database.trim();
+    if database.is_empty() {
+        return Err("Database name is required".to_string());
+    }
+    client.database(database).create_collection("dbx_init").await.map_err(|e| e.to_string())
+}
+
+pub async fn drop_database(client: &Client, database: &str) -> Result<(), String> {
+    let database = database.trim();
+    if database.is_empty() {
+        return Err("Database name is required".to_string());
+    }
+    client.database(database).drop().await.map_err(|e| e.to_string())
+}
+
+pub async fn drop_collection(client: &Client, database: &str, collection: &str) -> Result<(), String> {
+    let database = database.trim();
+    let collection = collection.trim();
+    if database.is_empty() {
+        return Err("Database name is required".to_string());
+    }
+    if collection.is_empty() {
+        return Err("Collection name is required".to_string());
+    }
+    client.database(database).collection::<Document>(collection).drop().await.map_err(|e| e.to_string())
+}
+
+pub async fn list_indexes(client: &Client, database: &str, collection: &str) -> Result<Vec<IndexInfo>, String> {
+    let col = client.database(database).collection::<Document>(collection);
+    let mut cursor = col.list_indexes().await.map_err(|e| e.to_string())?;
+    let mut indexes = Vec::new();
+    while let Some(model) = cursor.try_next().await.map_err(|e| e.to_string())? {
+        indexes.push(index_info_from_model(model));
+    }
+    Ok(indexes)
+}
+
+fn index_info_from_model(model: IndexModel) -> IndexInfo {
+    let name = model.options.as_ref().and_then(|options| options.name.clone()).unwrap_or_else(|| {
+        model.keys.iter().map(|(field, value)| format!("{field}_{value}")).collect::<Vec<_>>().join("_")
+    });
+    let columns = model.keys.keys().cloned().collect::<Vec<_>>();
+    let index_type = if model.keys.is_empty() {
+        None
+    } else {
+        Some(model.keys.iter().map(|(field, value)| format!("{field}: {value}")).collect::<Vec<_>>().join(", "))
+    };
+    let filter = model
+        .options
+        .as_ref()
+        .and_then(|options| options.partial_filter_expression.as_ref())
+        .map(|filter| bson_to_json(&Bson::Document(filter.clone())).to_string());
+    IndexInfo {
+        is_unique: model.options.as_ref().and_then(|options| options.unique).unwrap_or(false),
+        is_primary: name == "_id_",
+        name,
+        columns,
+        filter,
+        index_type,
+        included_columns: None,
+        comment: None,
+    }
+}
+
+pub async fn find_documents(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    skip: u64,
+    limit: i64,
+    filter: Option<&str>,
+    projection: Option<&str>,
+    sort: Option<&str>,
+) -> Result<MongoDocumentResult, String> {
+    let col = client.database(database).collection::<Document>(collection);
+
+    let filter_doc: Document = match filter {
+        Some(f) if !f.trim().is_empty() => {
+            let json: serde_json::Value = serde_json::from_str(f).map_err(|e| format!("Invalid filter JSON: {e}"))?;
+            json_filter_to_document(&json)?
+        }
+        _ => doc! {},
+    };
+
+    let total = if filter_doc.is_empty() {
+        col.estimated_document_count().await.map_err(|e| e.to_string())?
+    } else {
+        col.count_documents(filter_doc.clone()).await.map_err(|e| e.to_string())?
+    };
+
+    let mut find = col.find(filter_doc).skip(skip).limit(limit);
+    if let Some(p) = projection {
+        if !p.trim().is_empty() {
+            let json: serde_json::Value =
+                serde_json::from_str(p).map_err(|e| format!("Invalid projection JSON: {e}"))?;
+            let projection_doc = json_object_to_document(&json).map_err(|e| format!("Invalid projection: {e}"))?;
+            find = find.projection(projection_doc);
+        }
+    }
+    if let Some(s) = sort {
+        if !s.trim().is_empty() {
+            let json: serde_json::Value = serde_json::from_str(s).map_err(|e| format!("Invalid sort JSON: {e}"))?;
+            let sort_doc = json_object_to_document(&json).map_err(|e| format!("Invalid sort: {e}"))?;
+            find = find.sort(sort_doc);
+        }
+    }
+
+    let mut cursor = find.await.map_err(|e| e.to_string())?;
+
+    let mut documents = Vec::new();
+    while cursor.advance().await.map_err(|e| e.to_string())? {
+        let doc = cursor.deserialize_current().map_err(|e| e.to_string())?;
+        documents.push(bson_to_json(&Bson::Document(doc)));
+    }
+
+    Ok(MongoDocumentResult { documents, total })
+}
+
+/// Find MongoDB documents as relaxed Extended JSON for MongoDB transfer paths.
+#[allow(clippy::too_many_arguments)]
+pub async fn find_documents_extended_json(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    skip: u64,
+    limit: i64,
+    filter: Option<&str>,
+    projection: Option<&str>,
+    sort: Option<&str>,
+) -> Result<MongoDocumentResult, String> {
+    let col = client.database(database).collection::<Document>(collection);
+
+    let filter_doc: Document = match filter {
+        Some(f) if !f.trim().is_empty() => {
+            let json: serde_json::Value = serde_json::from_str(f).map_err(|e| format!("Invalid filter JSON: {e}"))?;
+            json_filter_to_document(&json)?
+        }
+        _ => doc! {},
+    };
+
+    let total = if filter_doc.is_empty() {
+        col.estimated_document_count().await.map_err(|e| e.to_string())?
+    } else {
+        col.count_documents(filter_doc.clone()).await.map_err(|e| e.to_string())?
+    };
+
+    let mut find = col.find(filter_doc).skip(skip).limit(limit);
+    if let Some(p) = projection {
+        if !p.trim().is_empty() {
+            let json: serde_json::Value =
+                serde_json::from_str(p).map_err(|e| format!("Invalid projection JSON: {e}"))?;
+            let projection_doc = json_object_to_document(&json).map_err(|e| format!("Invalid projection: {e}"))?;
+            find = find.projection(projection_doc);
+        }
+    }
+    if let Some(s) = sort {
+        if !s.trim().is_empty() {
+            let json: serde_json::Value = serde_json::from_str(s).map_err(|e| format!("Invalid sort JSON: {e}"))?;
+            let sort_doc = json_object_to_document(&json).map_err(|e| format!("Invalid sort: {e}"))?;
+            find = find.sort(sort_doc);
+        }
+    }
+
+    let mut cursor = find.await.map_err(|e| e.to_string())?;
+
+    let mut documents = Vec::new();
+    while cursor.advance().await.map_err(|e| e.to_string())? {
+        let doc = cursor.deserialize_current().map_err(|e| e.to_string())?;
+        documents.push(Bson::Document(doc).into_relaxed_extjson());
+    }
+
+    Ok(MongoDocumentResult { documents, total })
+}
+
+pub async fn aggregate_documents(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    pipeline_json: &str,
+    max_rows: Option<usize>,
+) -> Result<MongoDocumentResult, String> {
+    let json: serde_json::Value =
+        serde_json::from_str(pipeline_json).map_err(|e| format!("Invalid pipeline JSON: {e}"))?;
+    let pipeline_values = json.as_array().ok_or_else(|| "Aggregate pipeline must be a JSON array".to_string())?;
+    let pipeline = pipeline_values
+        .iter()
+        .map(|value| json_object_to_document(value).map_err(|e| format!("Invalid pipeline stage: {e}")))
+        .collect::<Result<Vec<Document>, String>>()?;
+    let col = client.database(database).collection::<Document>(collection);
+    let mut cursor = col.aggregate(pipeline).await.map_err(|e| e.to_string())?;
+    let max_rows = max_rows.unwrap_or(100);
+    let fetch_limit = max_rows.saturating_add(1);
+    let mut documents = Vec::new();
+    while documents.len() < fetch_limit && cursor.advance().await.map_err(|e| e.to_string())? {
+        let doc = cursor.deserialize_current().map_err(|e| e.to_string())?;
+        documents.push(bson_to_json(&Bson::Document(doc)));
+    }
+    let total = documents.len() as u64;
+    if documents.len() > max_rows {
+        documents.truncate(max_rows);
+    }
+    Ok(MongoDocumentResult { documents, total })
+}
+
+pub async fn create_index(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    keys_json: &str,
+    options_json: Option<&str>,
+) -> Result<String, String> {
+    let keys_value: serde_json::Value =
+        serde_json::from_str(keys_json).map_err(|e| format!("Invalid index keys JSON: {e}"))?;
+    let keys = json_object_to_document(&keys_value).map_err(|e| format!("Invalid index keys: {e}"))?;
+    if keys.is_empty() {
+        return Err("Index keys are required".to_string());
+    }
+
+    let options = match options_json.map(str::trim).filter(|json| !json.is_empty()) {
+        Some(json) => {
+            let value: serde_json::Value =
+                serde_json::from_str(json).map_err(|e| format!("Invalid index options JSON: {e}"))?;
+            let doc = json_object_to_document(&value).map_err(|e| format!("Invalid index options: {e}"))?;
+            Some(mongodb::bson::from_document::<IndexOptions>(doc).map_err(|e| format!("Invalid index options: {e}"))?)
+        }
+        None => None,
+    };
+
+    let col = client.database(database).collection::<Document>(collection);
+    let result =
+        col.create_index(IndexModel::builder().keys(keys).options(options).build()).await.map_err(|e| e.to_string())?;
+    Ok(result.index_name)
+}
+
+pub async fn drop_indexes(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    indexes_json: Option<&str>,
+    single: bool,
+) -> Result<MongoDropIndexesResult, String> {
+    let database = database.trim();
+    let collection = collection.trim();
+    if database.is_empty() {
+        return Err("Database name is required".to_string());
+    }
+    if collection.is_empty() {
+        return Err("Collection name is required".to_string());
+    }
+
+    let index = parse_drop_indexes_value(indexes_json, single)?;
+    let before = list_indexes(client, database, collection).await?;
+    client
+        .database(database)
+        .run_command(doc! { "dropIndexes": collection, "index": index })
+        .await
+        .map_err(|e| e.to_string())?;
+    let after = list_indexes(client, database, collection).await?;
+    let dropped_names = diff_dropped_index_names(&before, &after);
+    Ok(MongoDropIndexesResult { affected_rows: dropped_names.len() as u64, dropped_names })
+}
+
+fn diff_dropped_index_names(before: &[IndexInfo], after: &[IndexInfo]) -> Vec<String> {
+    let remaining = after.iter().map(|index| index.name.as_str()).collect::<HashSet<_>>();
+    before.iter().filter(|index| !remaining.contains(index.name.as_str())).map(|index| index.name.clone()).collect()
+}
+
+fn parse_drop_indexes_value(indexes_json: Option<&str>, single: bool) -> Result<Bson, String> {
+    match indexes_json.map(str::trim).filter(|value| !value.is_empty()) {
+        Some(json) => parse_drop_indexes_json(json, single),
+        None if single => Err("dropIndex requires a string index name or JSON document".to_string()),
+        None => Ok(Bson::String("*".to_string())),
+    }
+}
+
+fn parse_drop_indexes_json(json: &str, single: bool) -> Result<Bson, String> {
+    let value: serde_json::Value = serde_json::from_str(json).map_err(|e| format!("Invalid index JSON: {e}"))?;
+    if single {
+        validate_single_drop_index_value(&value)?;
+    } else {
+        validate_multi_drop_indexes_value(&value)?;
+    }
+    Ok(json_value_to_bson(&value))
+}
+
+fn validate_single_drop_index_value(value: &serde_json::Value) -> Result<(), String> {
+    match value {
+        serde_json::Value::String(name) => {
+            if name.trim().is_empty() {
+                Err("Index name is required".to_string())
+            } else if name == "*" {
+                Err(r#"dropIndex does not accept "*"; use dropIndexes() or dropIndexes("*") instead"#.to_string())
+            } else {
+                Ok(())
+            }
+        }
+        serde_json::Value::Object(doc) if doc.is_empty() => Err("Index specification is required".to_string()),
+        serde_json::Value::Object(_) => Ok(()),
+        serde_json::Value::Array(_) => {
+            Err("dropIndex only accepts a string index name or JSON document; arrays are not supported".to_string())
+        }
+        _ => Err("dropIndex only accepts a string index name or JSON document".to_string()),
+    }
+}
+
+fn validate_multi_drop_indexes_value(value: &serde_json::Value) -> Result<(), String> {
+    match value {
+        serde_json::Value::String(name) => {
+            if name.trim().is_empty() {
+                Err("Index name is required".to_string())
+            } else {
+                Ok(())
+            }
+        }
+        serde_json::Value::Object(doc) if doc.is_empty() => Err("Index specification is required".to_string()),
+        serde_json::Value::Object(_) => Ok(()),
+        serde_json::Value::Array(items) if items.is_empty() => {
+            Err("dropIndexes only accepts non-empty string arrays".to_string())
+        }
+        serde_json::Value::Array(items) => {
+            if items.iter().all(|item| matches!(item, serde_json::Value::String(name) if !name.trim().is_empty())) {
+                Ok(())
+            } else {
+                Err("dropIndexes only accepts arrays of string index names".to_string())
+            }
+        }
+        _ => Err("dropIndexes only accepts a string index name, JSON document, or string array".to_string()),
+    }
+}
+
+pub async fn insert_document(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    doc_json: &str,
+) -> Result<String, String> {
+    let value: serde_json::Value = serde_json::from_str(doc_json).map_err(|e| format!("Invalid JSON: {e}"))?;
+    let doc = json_object_to_document(&value).map_err(|e| format!("Invalid document: {e}"))?;
+    let col = client.database(database).collection::<Document>(collection);
+    let result = col.insert_one(doc).await.map_err(|e| e.to_string())?;
+    Ok(format!("{}", result.inserted_id))
+}
+
+pub async fn insert_documents(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    docs_json: &str,
+) -> Result<u64, String> {
+    let json: serde_json::Value = serde_json::from_str(docs_json).map_err(|e| format!("Invalid JSON: {e}"))?;
+    let docs = match json {
+        serde_json::Value::Array(values) => values
+            .into_iter()
+            .map(|value| json_object_to_document(&value).map_err(|e| format!("Invalid document: {e}")))
+            .collect::<Result<Vec<Document>, String>>()?,
+        value => vec![json_object_to_document(&value).map_err(|e| format!("Invalid document: {e}"))?],
+    };
+    if docs.is_empty() {
+        return Ok(0);
+    }
+    let col = client.database(database).collection::<Document>(collection);
+    let result = col.insert_many(docs).await.map_err(|e| e.to_string())?;
+    Ok(result.inserted_ids.len() as u64)
+}
+
+pub async fn insert_documents_extended_json(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    docs_json: &str,
+) -> Result<u64, String> {
+    let json: serde_json::Value = serde_json::from_str(docs_json).map_err(|e| format!("Invalid JSON: {e}"))?;
+    let docs = match json {
+        serde_json::Value::Array(values) => values
+            .into_iter()
+            .map(|value| json_object_to_document_extended_json(&value).map_err(|e| format!("Invalid document: {e}")))
+            .collect::<Result<Vec<Document>, String>>()?,
+        value => vec![json_object_to_document_extended_json(&value).map_err(|e| format!("Invalid document: {e}"))?],
+    };
+    if docs.is_empty() {
+        return Ok(0);
+    }
+    let col = client.database(database).collection::<Document>(collection);
+    let result = col.insert_many(docs).await.map_err(|e| e.to_string())?;
+    Ok(result.inserted_ids.len() as u64)
+}
+
+pub async fn update_document(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    id: &str,
+    doc_json: &str,
+) -> Result<u64, String> {
+    let value: serde_json::Value = serde_json::from_str(doc_json).map_err(|e| format!("Invalid JSON: {e}"))?;
+    let col = client.database(database).collection::<Document>(collection);
+    let update_doc = json_object_to_document(&value).map_err(|e| format!("Invalid document: {e}"))?;
+    if is_update_operator_document(&update_doc) {
+        for filter in document_id_filters(id) {
+            let result = col.update_one(filter, update_doc.clone()).await.map_err(|e| e.to_string())?;
+            if result.matched_count > 0 {
+                return Ok(result.modified_count);
+            }
+        }
+        return Ok(0);
+    }
+
+    for filter in document_id_filters(id) {
+        let current = col.find_one(filter.clone()).await.map_err(|e| e.to_string())?;
+        let mut new_doc = json_object_to_document_preserving_existing(&value, current.as_ref())
+            .map_err(|e| format!("Invalid document: {e}"))?;
+        new_doc.remove("_id");
+        let result = col.replace_one(filter, new_doc.clone()).await.map_err(|e| e.to_string())?;
+        if result.matched_count > 0 {
+            return Ok(result.modified_count);
+        }
+    }
+    Ok(0)
+}
+
+fn is_update_operator_document(doc: &Document) -> bool {
+    !doc.is_empty() && doc.keys().all(|key| key.starts_with('$'))
+}
+
+pub async fn update_documents(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    filter_json: &str,
+    update_json: &str,
+    many: bool,
+    options_json: Option<&str>,
+) -> Result<u64, String> {
+    let filter_value: serde_json::Value =
+        serde_json::from_str(filter_json).map_err(|e| format!("Invalid filter JSON: {e}"))?;
+    let update_value: serde_json::Value =
+        serde_json::from_str(update_json).map_err(|e| format!("Invalid update JSON: {e}"))?;
+    let filter = json_filter_to_document(&filter_value).map_err(|e| format!("Invalid filter: {e}"))?;
+    let update = json_object_to_document(&update_value).map_err(|e| format!("Invalid update: {e}"))?;
+    let array_filters = parse_update_array_filters(options_json)?;
+    let col = client.database(database).collection::<Document>(collection);
+    let result = if many {
+        let mut action = col.update_many(filter, update);
+        if let Some(filters) = array_filters {
+            action = action.array_filters(filters);
+        }
+        action.await.map_err(|e| e.to_string())?
+    } else {
+        let mut action = col.update_one(filter, update);
+        if let Some(filters) = array_filters {
+            action = action.array_filters(filters);
+        }
+        action.await.map_err(|e| e.to_string())?
+    };
+    Ok(result.modified_count)
+}
+
+#[derive(Default, Deserialize)]
+#[serde(rename_all = "camelCase", deny_unknown_fields)]
+struct MongoUpdateOptions {
+    array_filters: Option<Vec<serde_json::Value>>,
+}
+
+fn parse_update_array_filters(options_json: Option<&str>) -> Result<Option<Vec<Document>>, String> {
+    let Some(raw) = options_json.filter(|value| !value.trim().is_empty()) else {
+        return Ok(None);
+    };
+    let options: MongoUpdateOptions = serde_json::from_str(raw).map_err(|e| format!("Invalid update options: {e}"))?;
+    options
+        .array_filters
+        .map(|filters| {
+            filters
+                .iter()
+                .map(json_filter_to_document)
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|e| format!("Invalid arrayFilters: {e}"))
+        })
+        .transpose()
+}
+
+pub async fn delete_document(client: &Client, database: &str, collection: &str, id: &str) -> Result<u64, String> {
+    let col = client.database(database).collection::<Document>(collection);
+    for filter in document_id_filters(id) {
+        let result = col.delete_one(filter).await.map_err(|e| e.to_string())?;
+        if result.deleted_count > 0 {
+            return Ok(result.deleted_count);
+        }
+    }
+    Ok(0)
+}
+
+fn document_id_filters(id: &str) -> Vec<Document> {
+    let string_filter = doc! { "_id": Bson::String(id.to_string()) };
+    match ObjectId::parse_str(id) {
+        Ok(oid) => vec![doc! { "_id": Bson::ObjectId(oid) }, string_filter],
+        Err(_) => vec![string_filter],
+    }
+}
+
+pub async fn delete_documents(
+    client: &Client,
+    database: &str,
+    collection: &str,
+    filter_json: &str,
+    many: bool,
+) -> Result<u64, String> {
+    let filter_value: serde_json::Value =
+        serde_json::from_str(filter_json).map_err(|e| format!("Invalid filter JSON: {e}"))?;
+    let filter = json_filter_to_document(&filter_value).map_err(|e| format!("Invalid filter: {e}"))?;
+    let col = client.database(database).collection::<Document>(collection);
+    let result = if many {
+        col.delete_many(filter).await.map_err(|e| e.to_string())?
+    } else {
+        col.delete_one(filter).await.map_err(|e| e.to_string())?
+    };
+    Ok(result.deleted_count)
+}
+
+fn bson_to_json(bson: &Bson) -> serde_json::Value {
+    match bson {
+        Bson::Double(v) => serde_json::json!(v),
+        Bson::String(v) => serde_json::Value::String(v.clone()),
+        Bson::Boolean(v) => serde_json::Value::Bool(*v),
+        Bson::Null => serde_json::Value::Null,
+        Bson::Int32(v) => serde_json::json!(v),
+        Bson::Int64(v) => super::safe_i64_to_json(*v),
+        Bson::ObjectId(oid) => serde_json::Value::String(oid.to_hex()),
+        Bson::DateTime(dt) => serde_json::Value::String(format!(
+            "ISODate(\"{}\")",
+            dt.try_to_rfc3339_string().unwrap_or_else(|_| dt.to_string())
+        )),
+        Bson::Array(arr) => serde_json::Value::Array(arr.iter().map(bson_to_json).collect()),
+        Bson::Document(doc) => {
+            let mut map = serde_json::Map::new();
+            for (k, v) in doc {
+                map.insert(k.clone(), bson_to_json(v));
+            }
+            serde_json::Value::Object(map)
+        }
+        _ => serde_json::Value::String(format!("{bson}")),
+    }
+}
+
+/// Convert a `serde_json::Value` (JSON object) to a BSON `Document`,
+/// handling MongoDB extended JSON conventions such as `{"$oid":"..."}`.
+pub fn json_object_to_document(value: &serde_json::Value) -> Result<Document, String> {
+    match json_value_to_bson(value) {
+        Bson::Document(doc) => Ok(doc),
+        other => Err(format!("Expected a JSON object, got {other:?}")),
+    }
+}
+
+fn json_object_to_document_extended_json(value: &serde_json::Value) -> Result<Document, String> {
+    match Bson::try_from(value.clone()).map_err(|e| e.to_string())? {
+        Bson::Document(doc) => Ok(doc),
+        other => Err(format!("Expected a JSON object, got {other:?}")),
+    }
+}
+
+fn json_object_to_document_preserving_existing(
+    value: &serde_json::Value,
+    existing: Option<&Document>,
+) -> Result<Document, String> {
+    match (value, existing) {
+        (serde_json::Value::Object(obj), Some(existing)) => Ok(obj
+            .iter()
+            .map(|(key, value)| {
+                let bson = existing
+                    .get(key)
+                    .map(|existing_bson| json_value_to_bson_preserving_existing(value, existing_bson))
+                    .unwrap_or_else(|| json_value_to_bson(value));
+                (key.clone(), bson)
+            })
+            .collect()),
+        _ => json_object_to_document(value),
+    }
+}
+
+pub fn json_filter_to_document(value: &serde_json::Value) -> Result<Document, String> {
+    match json_filter_value_to_bson(value, None) {
+        Bson::Document(doc) => Ok(doc),
+        other => Err(format!("Expected a JSON object, got {other:?}")),
+    }
+}
+
+fn json_value_to_bson_preserving_existing(value: &serde_json::Value, existing: &Bson) -> Bson {
+    if &bson_to_json(existing) == value {
+        return existing.clone();
+    }
+
+    match (value, existing) {
+        (serde_json::Value::Array(values), Bson::Array(existing_values)) => Bson::Array(
+            values
+                .iter()
+                .enumerate()
+                .map(|(index, item)| {
+                    existing_values
+                        .get(index)
+                        .map(|existing_item| json_value_to_bson_preserving_existing(item, existing_item))
+                        .unwrap_or_else(|| json_value_to_bson(item))
+                })
+                .collect(),
+        ),
+        (serde_json::Value::Object(obj), Bson::Document(existing_doc)) => Bson::Document(
+            obj.iter()
+                .map(|(key, item)| {
+                    let bson = existing_doc
+                        .get(key)
+                        .map(|existing_item| json_value_to_bson_preserving_existing(item, existing_item))
+                        .unwrap_or_else(|| json_value_to_bson(item));
+                    (key.clone(), bson)
+                })
+                .collect(),
+        ),
+        _ => json_value_to_bson(value),
+    }
+}
+
+fn json_value_to_bson(value: &serde_json::Value) -> Bson {
+    match value {
+        serde_json::Value::Null => Bson::Null,
+        serde_json::Value::Bool(b) => Bson::Boolean(*b),
+        serde_json::Value::Number(n) => {
+            if let Some(i) = n.as_i64() {
+                Bson::Int64(i)
+            } else if let Some(f) = n.as_f64() {
+                Bson::Double(f)
+            } else {
+                Bson::Null
+            }
+        }
+        serde_json::Value::String(s) => {
+            parse_mongo_shell_date(s).map(Bson::DateTime).unwrap_or_else(|| Bson::String(s.clone()))
+        }
+        serde_json::Value::Array(arr) => Bson::Array(arr.iter().map(json_value_to_bson).collect()),
+        serde_json::Value::Object(obj) => {
+            // Extended JSON: {"$oid":"..."} → BSON ObjectId
+            if obj.len() == 1 {
+                if let Some(serde_json::Value::String(hex)) = obj.get("$oid") {
+                    if let Ok(oid) = ObjectId::parse_str(hex) {
+                        return Bson::ObjectId(oid);
+                    }
+                }
+                if let Some(date) = parse_extended_json_date(obj) {
+                    return Bson::DateTime(date);
+                }
+            }
+            let doc: Document = obj.iter().map(|(k, v)| (k.clone(), json_value_to_bson(v))).collect();
+            Bson::Document(doc)
+        }
+    }
+}
+
+fn parse_mongo_shell_date(value: &str) -> Option<DateTime> {
+    let trimmed = value.trim();
+    if let Some(inner) = trimmed.strip_prefix("ISODate(").or_else(|| trimmed.strip_prefix("new Date(")) {
+        let inner = inner.strip_suffix(')')?.trim();
+        let quoted = inner
+            .strip_prefix('"')
+            .and_then(|value| value.strip_suffix('"'))
+            .or_else(|| inner.strip_prefix('\'').and_then(|value| value.strip_suffix('\'')))?;
+        return DateTime::parse_rfc3339_str(quoted).ok();
+    }
+    parse_legacy_mongo_date_display(trimmed)
+}
+
+fn parse_legacy_mongo_date_display(value: &str) -> Option<DateTime> {
+    let (date, time) = value.split_once(' ').or_else(|| value.split_once('T'))?;
+    if date.len() != 10 || time.len() < 8 || time.len() > 12 {
+        return None;
+    }
+    if !date
+        .chars()
+        .enumerate()
+        .all(|(index, ch)| matches!(index, 4 | 7) && ch == '-' || !matches!(index, 4 | 7) && ch.is_ascii_digit())
+    {
+        return None;
+    }
+    let (seconds, millis) = time.split_once('.').unwrap_or((time, "000"));
+    if seconds.len() != 8 || millis.is_empty() || millis.len() > 3 {
+        return None;
+    }
+    if !seconds
+        .chars()
+        .enumerate()
+        .all(|(index, ch)| matches!(index, 2 | 5) && ch == ':' || !matches!(index, 2 | 5) && ch.is_ascii_digit())
+    {
+        return None;
+    }
+    if !millis.chars().all(|ch| ch.is_ascii_digit()) {
+        return None;
+    }
+    DateTime::parse_rfc3339_str(format!("{date}T{seconds}.{}Z", format!("{millis:0<3}"))).ok()
+}
+
+fn parse_extended_json_date(obj: &serde_json::Map<String, serde_json::Value>) -> Option<DateTime> {
+    match obj.get("$date")? {
+        serde_json::Value::String(value) => DateTime::parse_rfc3339_str(value).ok(),
+        serde_json::Value::Number(value) => value.as_i64().map(DateTime::from_millis),
+        serde_json::Value::Object(inner) if inner.len() == 1 => match inner.get("$numberLong") {
+            Some(serde_json::Value::String(value)) => value.parse::<i64>().ok().map(DateTime::from_millis),
+            Some(serde_json::Value::Number(value)) => value.as_i64().map(DateTime::from_millis),
+            _ => None,
+        },
+        _ => None,
+    }
+}
+
+fn json_filter_value_to_bson(value: &serde_json::Value, field_name: Option<&str>) -> Bson {
+    if field_name == Some("_id") {
+        if let Some(id) = value.as_str() {
+            return id_equality_bson(id);
+        }
+    }
+
+    match value {
+        serde_json::Value::Array(arr) => {
+            Bson::Array(arr.iter().map(|item| json_filter_value_to_bson(item, None)).collect())
+        }
+        serde_json::Value::Object(obj) => {
+            if obj.len() == 1 {
+                if let Some(serde_json::Value::String(hex)) = obj.get("$oid") {
+                    if let Ok(oid) = ObjectId::parse_str(hex) {
+                        return Bson::ObjectId(oid);
+                    }
+                }
+                // Extended JSON dates must be decoded in filters too, otherwise
+                // {"$date": ...} reaches the server as a raw document: a bare
+                // { field: {"$date": ...} } fails with "unknown operator: $date"
+                // and { field: {"$gte": {"$date": ...}} } silently matches nothing.
+                if let Some(date) = parse_extended_json_date(obj) {
+                    return Bson::DateTime(date);
+                }
+            }
+
+            if field_name == Some("_id") && obj.keys().all(|key| key.starts_with('$')) {
+                let mut doc = Document::new();
+                for (key, item) in obj {
+                    match key.as_str() {
+                        "$eq" => {
+                            if let Some(id) = item.as_str() {
+                                doc.insert("$in", object_id_string_variants(id));
+                            } else {
+                                doc.insert(key, json_filter_value_to_bson(item, None));
+                            }
+                        }
+                        "$ne" => {
+                            if let Some(id) = item.as_str() {
+                                doc.insert("$nin", object_id_string_variants(id));
+                            } else {
+                                doc.insert(key, json_filter_value_to_bson(item, None));
+                            }
+                        }
+                        "$in" | "$nin" => {
+                            if let Some(items) = item.as_array() {
+                                doc.insert(key, expand_object_id_string_array(items));
+                            } else {
+                                doc.insert(key, json_filter_value_to_bson(item, None));
+                            }
+                        }
+                        _ => {
+                            doc.insert(key, json_filter_value_to_bson(item, None));
+                        }
+                    }
+                }
+                return Bson::Document(doc);
+            }
+
+            let doc: Document = obj.iter().map(|(k, v)| (k.clone(), json_filter_value_to_bson(v, Some(k)))).collect();
+            Bson::Document(doc)
+        }
+        _ => json_value_to_bson(value),
+    }
+}
+
+fn id_equality_bson(id: &str) -> Bson {
+    let variants = object_id_string_variants(id);
+    if variants.len() == 1 {
+        variants.into_iter().next().unwrap_or(Bson::String(id.to_string()))
+    } else {
+        Bson::Document(doc! { "$in": variants })
+    }
+}
+
+fn object_id_string_variants(id: &str) -> Vec<Bson> {
+    match ObjectId::parse_str(id) {
+        Ok(oid) => vec![Bson::ObjectId(oid), Bson::String(id.to_string())],
+        Err(_) => vec![Bson::String(id.to_string())],
+    }
+}
+
+fn expand_object_id_string_array(items: &[serde_json::Value]) -> Bson {
+    let mut values = Vec::new();
+    for item in items {
+        if let Some(id) = item.as_str() {
+            values.extend(object_id_string_variants(id));
+        } else {
+            values.push(json_filter_value_to_bson(item, None));
+        }
+    }
+    Bson::Array(values)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn update_options_parse_array_filters() {
+        let filters = parse_update_array_filters(Some(r#"{"arrayFilters":[{"item.id":322678},{"item.active":true}]}"#))
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(filters, vec![doc! { "item.id": 322678_i64 }, doc! { "item.active": true }]);
+    }
+
+    #[test]
+    fn update_options_reject_unsupported_fields() {
+        let error = parse_update_array_filters(Some(r#"{"upsert":true}"#)).unwrap_err();
+
+        assert!(error.starts_with("Invalid update options:"));
+        assert!(error.contains("unknown field `upsert`"));
+    }
+
+    #[test]
+    fn multi_seed_uri_removes_direct_connection_true_before_driver_parse() {
+        let uri =
+            "mongodb://read:pass@host1:27017,host2:27017/admin?directConnection=true&replicaSet=rs0&authSource=admin";
+
+        let normalized = normalize_mongo_uri_direct_connection(uri);
+
+        assert_eq!(normalized, "mongodb://read:pass@host1:27017,host2:27017/admin?replicaSet=rs0&authSource=admin");
+    }
+
+    #[test]
+    fn multi_seed_uri_removes_encoded_direct_connection_true_and_keeps_fragment() {
+        let uri = "mongodb://host1:27017,host2:27017/admin?authSource=admin&direct%43onnection=TRUE#read";
+
+        let normalized = normalize_mongo_uri_direct_connection(uri);
+
+        assert_eq!(normalized, "mongodb://host1:27017,host2:27017/admin?authSource=admin#read");
+    }
+
+    #[test]
+    fn srv_uri_removes_direct_connection_true_before_driver_parse() {
+        let uri = "mongodb+srv://read:pass@cluster.example.net/admin?tls=true&directConnection=true&replicaSet=rs0";
+
+        let normalized = normalize_mongo_uri_direct_connection(uri);
+
+        assert_eq!(normalized, "mongodb+srv://read:pass@cluster.example.net/admin?tls=true&replicaSet=rs0");
+        assert!(is_multi_host_mongo_uri(&normalized));
+    }
+
+    #[test]
+    fn single_seed_uri_keeps_direct_connection_true() {
+        let uri = "mongodb://host1:27017/admin?directConnection=true&authSource=admin";
+
+        let normalized = normalize_mongo_uri_direct_connection(uri);
+
+        assert_eq!(normalized, uri);
+    }
+
+    #[test]
+    fn multi_seed_uri_keeps_direct_connection_false() {
+        let uri = "mongodb://host1:27017,host2:27017/admin?directConnection=false&replicaSet=rs0";
+
+        let normalized = normalize_mongo_uri_direct_connection(uri);
+
+        assert_eq!(normalized, uri);
+    }
+
+    #[test]
+    fn document_id_filters_try_object_id_then_string_for_hex_ids() {
+        let id = "507f1f77bcf86cd799439011";
+        let filters = document_id_filters(id);
+
+        assert_eq!(filters.len(), 2);
+        assert!(matches!(filters[0].get("_id"), Some(Bson::ObjectId(_))));
+        assert!(matches!(filters[1].get("_id"), Some(Bson::String(value)) if value == id));
+    }
+
+    #[test]
+    fn document_id_filters_use_string_only_for_non_hex_ids() {
+        let id = "customer-42";
+        let filters = document_id_filters(id);
+
+        assert_eq!(filters.len(), 1);
+        assert!(matches!(filters[0].get("_id"), Some(Bson::String(value)) if value == id));
+    }
+
+    #[test]
+    fn json_filter_to_document_matches_object_id_and_string_for_id_hex() {
+        let id = "507f1f77bcf86cd799439011";
+        let filter = serde_json::json!({ "_id": id });
+        let doc = json_filter_to_document(&filter).unwrap();
+
+        let Some(Bson::Document(id_filter)) = doc.get("_id") else {
+            panic!("expected _id operator document");
+        };
+        let Some(Bson::Array(values)) = id_filter.get("$in") else {
+            panic!("expected _id $in variants");
+        };
+        assert!(matches!(values.first(), Some(Bson::ObjectId(_))));
+        assert!(matches!(values.get(1), Some(Bson::String(value)) if value == id));
+    }
+
+    #[test]
+    fn json_filter_to_document_expands_id_operator_variants() {
+        let id = "507f1f77bcf86cd799439011";
+        let filter = serde_json::json!({ "$and": [{ "_id": { "$eq": id } }] });
+        let doc = json_filter_to_document(&filter).unwrap();
+
+        let Some(Bson::Array(and_items)) = doc.get("$and") else {
+            panic!("expected $and array");
+        };
+        let Some(Bson::Document(first)) = and_items.first() else {
+            panic!("expected first $and document");
+        };
+        let Some(Bson::Document(id_filter)) = first.get("_id") else {
+            panic!("expected _id operator document");
+        };
+        assert!(matches!(id_filter.get("$in"), Some(Bson::Array(values)) if values.len() == 2));
+    }
+
+    #[test]
+    fn json_filter_to_document_leaves_non_id_hex_strings_alone() {
+        let id = "507f1f77bcf86cd799439011";
+        let filter = serde_json::json!({ "owner_id": id });
+        let doc = json_filter_to_document(&filter).unwrap();
+
+        assert!(matches!(doc.get("owner_id"), Some(Bson::String(value)) if value == id));
+    }
+
+    #[test]
+    fn json_filter_to_document_decodes_extended_json_dates() {
+        let iso = "2025-02-25T04:57:39.965Z";
+        let expected = DateTime::parse_rfc3339_str(iso).unwrap();
+
+        // Direct equality must yield a BSON DateTime, not a raw { "$date": ... }
+        // document that the server rejects with "unknown operator: $date".
+        let filter = serde_json::json!({ "createdAt": { "$date": iso } });
+        let doc = json_filter_to_document(&filter).unwrap();
+        assert_eq!(doc.get("createdAt"), Some(&Bson::DateTime(expected)));
+
+        // Range operands must be decoded too, otherwise $gte compares against a
+        // sub-document and silently matches nothing.
+        let range = serde_json::json!({ "createdAt": { "$gte": { "$date": iso } } });
+        let range_doc = json_filter_to_document(&range).unwrap();
+        let Some(Bson::Document(op)) = range_doc.get("createdAt") else {
+            panic!("expected operator document");
+        };
+        assert_eq!(op.get("$gte"), Some(&Bson::DateTime(expected)));
+    }
+
+    #[test]
+    fn bson_to_json_displays_date_as_mongo_isodate() {
+        let date = DateTime::parse_rfc3339_str("2026-06-10T13:59:31.287Z").unwrap();
+        let value = bson_to_json(&Bson::DateTime(date));
+
+        assert_eq!(value, serde_json::json!("ISODate(\"2026-06-10T13:59:31.287Z\")"));
+    }
+
+    #[test]
+    fn bson_to_json_preserves_unsafe_int64_for_js() {
+        let value = bson_to_json(&Bson::Int64(2_326_645_729_978_441_729));
+
+        assert_eq!(value, serde_json::json!("2326645729978441729"));
+    }
+
+    #[test]
+    fn bson_to_json_keeps_safe_int64_as_number() {
+        let value = bson_to_json(&Bson::Int64(42));
+
+        assert_eq!(value, serde_json::json!(42));
+    }
+
+    #[test]
+    fn bson_to_json_displays_object_id_as_string() {
+        let oid = ObjectId::parse_str("507f1f77bcf86cd799439011").unwrap();
+        let value = bson_to_json(&Bson::ObjectId(oid));
+
+        assert_eq!(value, serde_json::json!("507f1f77bcf86cd799439011"));
+    }
+
+    #[test]
+    fn bson_to_extended_json_preserves_nested_object_ids() {
+        let oid = ObjectId::parse_str("507f1f77bcf86cd799439011").unwrap();
+        let nested_oid = ObjectId::parse_str("507f191e810c19729de860ea").unwrap();
+        let value = Bson::Document(doc! {
+            "_id": Bson::ObjectId(oid),
+            "owner": { "id": Bson::ObjectId(nested_oid) },
+            "tags": [Bson::ObjectId(nested_oid)],
+        })
+        .into_relaxed_extjson();
+
+        assert_eq!(
+            value,
+            serde_json::json!({
+                "_id": { "$oid": "507f1f77bcf86cd799439011" },
+                "owner": { "id": { "$oid": "507f191e810c19729de860ea" } },
+                "tags": [{ "$oid": "507f191e810c19729de860ea" }],
+            })
+        );
+    }
+
+    #[test]
+    fn index_info_from_model_maps_mongodb_index_metadata() {
+        let model = IndexModel::builder()
+            .keys(doc! { "tenant_id": 1, "created_at": -1 })
+            .options(
+                IndexOptions::builder()
+                    .name("tenant_created_idx".to_string())
+                    .unique(true)
+                    .partial_filter_expression(doc! { "archived": false })
+                    .build(),
+            )
+            .build();
+
+        let index = index_info_from_model(model);
+
+        assert_eq!(index.name, "tenant_created_idx");
+        assert_eq!(index.columns, vec!["tenant_id", "created_at"]);
+        assert!(index.is_unique);
+        assert!(!index.is_primary);
+        assert_eq!(index.index_type.as_deref(), Some("tenant_id: 1, created_at: -1"));
+        assert_eq!(index.filter.as_deref(), Some("{\"archived\":false}"));
+    }
+
+    #[test]
+    fn index_info_from_model_marks_default_id_index_as_primary() {
+        let model = IndexModel::builder()
+            .keys(doc! { "_id": 1 })
+            .options(IndexOptions::builder().name("_id_".to_string()).unique(true).build())
+            .build();
+
+        let index = index_info_from_model(model);
+
+        assert_eq!(index.columns, vec!["_id"]);
+        assert!(index.is_unique);
+        assert!(index.is_primary);
+    }
+
+    #[test]
+    fn parse_drop_indexes_value_validates_drop_index_arguments() {
+        assert!(matches!(
+            parse_drop_indexes_value(Some(r#""users_email_unique""#), true),
+            Ok(Bson::String(name)) if name == "users_email_unique"
+        ));
+        assert!(matches!(
+            parse_drop_indexes_value(Some(r#"{"email":1}"#), true),
+            Ok(Bson::Document(doc)) if doc.get_i64("email").ok() == Some(1)
+        ));
+
+        let wildcard = parse_drop_indexes_value(Some(r#""*""#), true).unwrap_err();
+        assert!(wildcard.contains("dropIndex does not accept"));
+
+        let array = parse_drop_indexes_value(Some(r#"["a_1"]"#), true).unwrap_err();
+        assert!(array.contains("arrays are not supported"));
+
+        let empty = parse_drop_indexes_value(None, true).unwrap_err();
+        assert!(empty.contains("dropIndex requires"));
+    }
+
+    #[test]
+    fn parse_drop_indexes_value_validates_drop_indexes_arguments() {
+        assert!(matches!(
+            parse_drop_indexes_value(None, false),
+            Ok(Bson::String(name)) if name == "*"
+        ));
+        assert!(matches!(
+            parse_drop_indexes_value(Some(r#""*""#), false),
+            Ok(Bson::String(name)) if name == "*"
+        ));
+        assert!(matches!(
+            parse_drop_indexes_value(Some(r#""users_email_unique""#), false),
+            Ok(Bson::String(name)) if name == "users_email_unique"
+        ));
+        assert!(matches!(
+            parse_drop_indexes_value(Some(r#"{"email":1}"#), false),
+            Ok(Bson::Document(doc)) if doc.get_i64("email").ok() == Some(1)
+        ));
+        assert!(matches!(
+            parse_drop_indexes_value(Some(r#"["a_1","b_1"]"#), false),
+            Ok(Bson::Array(values))
+                if values
+                    == vec![Bson::String("a_1".to_string()), Bson::String("b_1".to_string())]
+        ));
+
+        let invalid_array = parse_drop_indexes_value(Some(r#"[{"a":1}]"#), false).unwrap_err();
+        assert!(invalid_array.contains("arrays of string index names"));
+    }
+
+    #[test]
+    fn diff_dropped_index_names_reports_removed_indexes() {
+        let before = vec![
+            IndexInfo {
+                name: "_id_".to_string(),
+                columns: vec!["_id".to_string()],
+                is_unique: true,
+                is_primary: true,
+                filter: None,
+                index_type: Some("_id: 1".to_string()),
+                included_columns: None,
+                comment: None,
+            },
+            IndexInfo {
+                name: "users_email_unique".to_string(),
+                columns: vec!["email".to_string()],
+                is_unique: true,
+                is_primary: false,
+                filter: None,
+                index_type: Some("email: 1".to_string()),
+                included_columns: None,
+                comment: None,
+            },
+            IndexInfo {
+                name: "users_status_idx".to_string(),
+                columns: vec!["status".to_string()],
+                is_unique: false,
+                is_primary: false,
+                filter: None,
+                index_type: Some("status: 1".to_string()),
+                included_columns: None,
+                comment: None,
+            },
+        ];
+        let after = vec![before[0].clone(), before[2].clone()];
+
+        assert_eq!(diff_dropped_index_names(&before, &after), vec!["users_email_unique".to_string()]);
+    }
+
+    #[test]
+    fn json_object_to_document_parses_extended_json_date() {
+        let value = serde_json::json!({
+            "created_at": { "$date": "2026-06-10T13:59:31.287Z" },
+            "updated_at": { "$date": { "$numberLong": "1781099971287" } }
+        });
+        let doc = json_object_to_document(&value).unwrap();
+
+        assert!(matches!(doc.get("created_at"), Some(Bson::DateTime(_))));
+        assert!(matches!(
+            doc.get("updated_at"),
+            Some(Bson::DateTime(value)) if value.timestamp_millis() == 1_781_099_971_287
+        ));
+    }
+
+    #[test]
+    fn json_object_to_document_parses_extended_json_object_id() {
+        let value = serde_json::json!({
+            "_id": { "$oid": "507f1f77bcf86cd799439011" },
+        });
+        let doc = json_object_to_document(&value).unwrap();
+
+        assert!(matches!(doc.get("_id"), Some(Bson::ObjectId(oid)) if oid.to_hex() == "507f1f77bcf86cd799439011"));
+    }
+
+    #[test]
+    fn json_object_to_document_extended_json_parses_official_wrappers() {
+        let value = serde_json::json!({
+            "_id": { "$oid": "507f1f77bcf86cd799439011" },
+            "created_at": { "$date": "2026-06-10T13:59:31.287Z" },
+            "count": { "$numberLong": "42" },
+        });
+        let doc = json_object_to_document_extended_json(&value).unwrap();
+
+        assert!(matches!(doc.get("_id"), Some(Bson::ObjectId(oid)) if oid.to_hex() == "507f1f77bcf86cd799439011"));
+        assert!(matches!(doc.get("created_at"), Some(Bson::DateTime(_))));
+        assert!(matches!(doc.get("count"), Some(Bson::Int64(42))));
+    }
+
+    #[test]
+    fn parse_gridfs_file_id_accepts_extended_json_object_id() {
+        let id = parse_gridfs_file_id(r#"{"$oid":"507f1f77bcf86cd799439011"}"#).unwrap();
+
+        assert!(matches!(id, Bson::ObjectId(oid) if oid.to_hex() == "507f1f77bcf86cd799439011"));
+    }
+
+    #[test]
+    fn parse_gridfs_file_id_accepts_json_string_ids() {
+        let id = parse_gridfs_file_id(r#""report-42""#).unwrap();
+
+        assert!(matches!(id, Bson::String(value) if value == "report-42"));
+    }
+
+    #[test]
+    fn gridfs_file_id_to_string_keeps_plain_strings_unquoted() {
+        let id = gridfs_file_id_to_string(&Bson::String("report-42".to_string()));
+
+        assert_eq!(id, "report-42");
+    }
+
+    #[test]
+    fn gridfs_file_info_includes_navicat_style_metadata_fields() {
+        let info = gridfs_file_info_from_document(&doc! {
+            "_id": "report-42",
+            "filename": "report.zip",
+            "length": 128_i64,
+            "chunkSize": 255_i32,
+            "md5": "abc123",
+            "contentType": "application/zip",
+            "aliases": ["archive", "nightly"],
+        });
+
+        assert_eq!(info.id, "report-42");
+        assert_eq!(info.filename.as_deref(), Some("report.zip"));
+        assert_eq!(info.md5.as_deref(), Some("abc123"));
+        assert_eq!(info.content_type.as_deref(), Some("application/zip"));
+        assert_eq!(info.aliases, Some(vec!["archive".to_string(), "nightly".to_string()]));
+    }
+
+    #[test]
+    fn gridfs_file_sort_uses_upload_date_desc_by_default() {
+        assert_eq!(gridfs_file_sort_document(None).unwrap(), doc! { "uploadDate": -1_i32, "_id": -1_i32 });
+    }
+
+    #[test]
+    fn gridfs_file_sort_parses_explicit_sort_json() {
+        assert_eq!(gridfs_file_sort_document(Some(r#"{"filename":1}"#)).unwrap(), doc! { "filename": 1_i64 });
+    }
+
+    #[test]
+    fn json_object_to_document_parses_find_projection() {
+        let value = serde_json::json!({
+            "title": 1,
+            "_id": 0,
+        });
+        let doc = json_object_to_document(&value).unwrap();
+
+        assert!(matches!(doc.get("title"), Some(Bson::Int64(1))));
+        assert!(matches!(doc.get("_id"), Some(Bson::Int64(0))));
+    }
+
+    #[test]
+    fn server_version_from_build_info_reads_version_field() {
+        let version = server_version_from_build_info(&doc! { "version": "4.4.29" }).unwrap();
+
+        assert_eq!(version, "4.4.29");
+    }
+
+    #[test]
+    fn server_version_from_build_info_rejects_missing_version() {
+        let error = server_version_from_build_info(&doc! { "ok": 1 }).unwrap_err();
+
+        assert!(error.contains("MongoDB server version not found"));
+    }
+
+    #[test]
+    fn collection_stats_result_reads_expected_fields() {
+        let result = collection_stats_result_from_document(&doc! {
+            "count": 12_i64,
+            "size": 4096_i64,
+            "avgObjSize": 341.3_f64,
+            "storageSize": 8192_i64,
+            "totalIndexSize": 2048_i64,
+            "nindexes": 3_i32,
+        });
+
+        assert_eq!(
+            result,
+            MongoCollectionStatsResult {
+                count: serde_json::json!(12),
+                size: serde_json::json!(4096),
+                avg_obj_size: serde_json::json!(341.3),
+                storage_size: serde_json::json!(8192),
+                total_index_size: serde_json::json!(2048),
+                nindexes: serde_json::json!(3),
+            }
+        );
+    }
+
+    #[test]
+    fn collection_stats_result_fills_missing_fields_with_null() {
+        let result = collection_stats_result_from_document(&doc! {
+            "count": 7_i32,
+            "storageSize": 512_i32,
+        });
+
+        assert_eq!(result.count, serde_json::json!(7));
+        assert_eq!(result.size, serde_json::Value::Null);
+        assert_eq!(result.avg_obj_size, serde_json::Value::Null);
+        assert_eq!(result.storage_size, serde_json::json!(512));
+        assert_eq!(result.total_index_size, serde_json::Value::Null);
+        assert_eq!(result.nindexes, serde_json::Value::Null);
+    }
+
+    #[test]
+    fn collection_stats_command_serializes_scale() {
+        let command = collection_stats_command_document("users", Some(&serde_json::Number::from(1024)));
+
+        assert_eq!(command.get_str("collStats").unwrap(), "users");
+        assert!(matches!(command.get("scale"), Some(Bson::Int64(1024))));
+    }
+
+    #[test]
+    fn json_object_to_document_parses_mongo_shell_isodate_strings() {
+        let value = serde_json::json!({
+            "created_at": "ISODate(\"2026-06-10T13:59:31.287Z\")",
+            "updated_at": "new Date('2026-06-10T14:59:31.287Z')",
+        });
+        let doc = json_object_to_document(&value).unwrap();
+
+        assert!(matches!(doc.get("created_at"), Some(Bson::DateTime(_))));
+        assert!(matches!(doc.get("updated_at"), Some(Bson::DateTime(_))));
+    }
+
+    #[test]
+    fn json_object_to_document_parses_legacy_date_display_strings() {
+        let value = serde_json::json!({
+            "created_at": "2025-08-14 02:25:43.718",
+        });
+        let doc = json_object_to_document(&value).unwrap();
+
+        assert!(matches!(
+            doc.get("created_at"),
+            Some(Bson::DateTime(value)) if value.timestamp_millis() == 1_755_138_343_718
+        ));
+    }
+
+    #[test]
+    fn detects_update_operator_documents() {
+        assert!(is_update_operator_document(&doc! { "$set": { "name": "Ada" } }));
+        assert!(is_update_operator_document(&doc! { "$set": { "name": "Ada" }, "$unset": { "old": "" } }));
+        assert!(!is_update_operator_document(&doc! { "name": "Ada" }));
+        assert!(!is_update_operator_document(&Document::new()));
+    }
+
+    #[test]
+    fn json_object_to_document_preserves_unchanged_bson_date_fields() {
+        let date = DateTime::parse_rfc3339_str("2026-06-10T13:59:31.287Z").unwrap();
+        let existing = doc! {
+            "_id": "doc-1",
+            "created_at": Bson::DateTime(date),
+            "name": "before",
+            "profile": {
+                "last_seen": Bson::DateTime(date),
+                "status": "old",
+            },
+        };
+        let displayed = bson_to_json(&Bson::Document(existing.clone()));
+        let mut edited = displayed.as_object().cloned().unwrap();
+        edited.insert("name".to_string(), serde_json::json!("after"));
+        if let Some(serde_json::Value::Object(profile)) = edited.get_mut("profile") {
+            profile.insert("status".to_string(), serde_json::json!("new"));
+        }
+
+        let doc =
+            json_object_to_document_preserving_existing(&serde_json::Value::Object(edited), Some(&existing)).unwrap();
+
+        assert!(matches!(doc.get("created_at"), Some(Bson::DateTime(value)) if *value == date));
+        let Some(Bson::Document(profile)) = doc.get("profile") else {
+            panic!("expected profile document");
+        };
+        assert!(matches!(profile.get("last_seen"), Some(Bson::DateTime(value)) if *value == date));
+        assert!(matches!(profile.get("status"), Some(Bson::String(value)) if value == "new"));
+    }
+}
diff --git a/crates/dbx-core/src/db/mysql.rs b/crates/dbx-core/src/db/mysql.rs
new file mode 100644
index 0000000..9f3fc1a
--- /dev/null
+++ b/crates/dbx-core/src/db/mysql.rs
@@ -0,0 +1,4956 @@
+use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
+use futures::StreamExt;
+use mysql_async::consts::ColumnType;
+use mysql_async::prelude::*;
+use percent_encoding::percent_decode_str;
+use rust_decimal::Decimal;
+use std::borrow::Cow;
+use std::collections::{HashMap, HashSet};
+use std::path::PathBuf;
+use std::sync::atomic::AtomicBool;
+use std::time::Duration;
+use std::time::Instant;
+use tokio_util::sync::CancellationToken;
+
+use crate::models::connection::DatabaseType;
+use crate::sql::starts_with_executable_sql_keyword;
+use crate::types::{
+    ColumnInfo, CompletionAssistantCandidate, CompletionAssistantCandidateKind, CompletionAssistantMatchMode,
+    CompletionAssistantObjectKind, CompletionAssistantRequest, CompletionAssistantResponse, DatabaseInfo,
+    ForeignKeyInfo, IndexInfo, ObjectInfo, ObjectStatistics, QueryResult, TableInfo, TriggerInfo,
+};
+
+use super::file_validator::validate_file_path;
+
+pub type MySqlPool = mysql_async::Pool;
+const MYSQL_TCP_KEEPALIVE_MS: u32 = 30_000;
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct MySqlQueryDialect {
+    supports_admin_show_results: bool,
+}
+
+impl MySqlQueryDialect {
+    pub fn for_connection(db_type: DatabaseType, driver_profile: Option<&str>) -> Self {
+        let profile = driver_profile.map(str::to_ascii_lowercase);
+        Self {
+            supports_admin_show_results: matches!(
+                db_type,
+                DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::ManticoreSearch
+            ) || profile
+                .as_deref()
+                .is_some_and(|profile| matches!(profile, "doris" | "selectdb" | "starrocks" | "manticoresearch")),
+        }
+    }
+}
+
+pub enum MySqlQueryStreamItem {
+    Columns { columns: Vec<String>, column_types: Vec<String> },
+    Row(Vec<serde_json::Value>),
+}
+
+fn quote_value(s: &str) -> String {
+    format!("'{}'", s.replace('\\', "\\\\").replace('\'', "\\'"))
+}
+
+fn quote_identifier(s: &str) -> String {
+    format!("`{}`", s.replace('`', "``"))
+}
+
+fn quote_table_ref(database: &str, table: &str) -> String {
+    if database.trim().is_empty() {
+        quote_identifier(table)
+    } else {
+        format!("{}.{}", quote_identifier(database), quote_identifier(table))
+    }
+}
+
+fn row_get<T, I>(row: &mysql_async::Row, index: I) -> Option<T>
+where
+    T: mysql_async::prelude::FromValue,
+    I: mysql_async::prelude::ColumnIndex,
+{
+    row.get_opt::<T, I>(index).and_then(|result| result.ok())
+}
+
+fn get_str(row: &mysql_async::Row, idx: usize) -> String {
+    row_get::<String, _>(row, idx)
+        .or_else(|| row_get::<Vec<u8>, _>(row, idx).map(|b| String::from_utf8_lossy(&b).to_string()))
+        .unwrap_or_default()
+}
+
+fn get_str_by_name(row: &mysql_async::Row, name: &str) -> String {
+    row_get::<String, _>(row, name)
+        .or_else(|| row_get::<Vec<u8>, _>(row, name).map(|b| String::from_utf8_lossy(&b).to_string()))
+        .unwrap_or_default()
+}
+
+fn get_opt_str(row: &mysql_async::Row, name: &str) -> Option<String> {
+    row_get::<String, _>(row, name)
+        .or_else(|| row_get::<Vec<u8>, _>(row, name).map(|b| String::from_utf8_lossy(&b).to_string()))
+}
+
+/// First non-empty string value among the named columns (e.g. Doris `CatalogName`
+/// vs StarRocks `Catalog`). Returns an empty string when none of the columns
+/// are present or all are empty.
+fn first_nonempty_str_by_name(row: &mysql_async::Row, names: &[&str]) -> String {
+    for name in names {
+        let value = get_str_by_name(row, name);
+        if !value.is_empty() {
+            return value;
+        }
+    }
+    String::new()
+}
+
+fn get_opt_metadata_string(row: &mysql_async::Row, name: &str) -> Option<String> {
+    get_opt_str(row, name)
+        .or_else(|| row_get::<NaiveDateTime, _>(row, name).map(|value| value.to_string()))
+        .or_else(|| row_get::<NaiveDate, _>(row, name).map(|value| value.to_string()))
+        .or_else(|| row_get::<NaiveTime, _>(row, name).map(|value| value.to_string()))
+}
+
+fn numeric_metadata_u64_to_i32(value: Option<u64>) -> Option<i32> {
+    value.and_then(|v| i32::try_from(v).ok())
+}
+
+fn numeric_metadata_i64_to_i32(value: Option<i64>) -> Option<i32> {
+    value.and_then(|v| i32::try_from(v).ok())
+}
+
+fn numeric_metadata_str_to_i32(value: Option<String>) -> Option<i32> {
+    value.and_then(|v| v.parse::<i64>().ok()).and_then(|v| i32::try_from(v).ok())
+}
+
+fn get_opt_i32(row: &mysql_async::Row, name: &str) -> Option<i32> {
+    row_get::<i32, _>(row, name)
+        .or_else(|| numeric_metadata_i64_to_i32(row_get::<i64, _>(row, name)))
+        .or_else(|| numeric_metadata_u64_to_i32(row_get::<u64, _>(row, name)))
+        .or_else(|| numeric_metadata_str_to_i32(row_get::<String, _>(row, name)))
+        .or_else(|| {
+            row_get::<Vec<u8>, _>(row, name)
+                .and_then(|b| String::from_utf8(b).ok())
+                .and_then(|v| numeric_metadata_str_to_i32(Some(v)))
+        })
+}
+
+fn get_opt_i64(row: &mysql_async::Row, name: &str) -> Option<i64> {
+    row_get::<i64, _>(row, name)
+        .or_else(|| row_get::<u64, _>(row, name).and_then(|value| i64::try_from(value).ok()))
+        .or_else(|| row_get::<String, _>(row, name).and_then(|value| value.parse::<i64>().ok()))
+        .or_else(|| {
+            row_get::<Vec<u8>, _>(row, name)
+                .and_then(|b| String::from_utf8(b).ok())
+                .and_then(|value| value.parse::<i64>().ok())
+        })
+}
+
+#[cfg(test)]
+fn mysql_datetime_to_string(value: NaiveDateTime) -> String {
+    value.to_string()
+}
+
+#[cfg(test)]
+fn is_mysql_lossless_integer_type(type_name: &str) -> bool {
+    let upper_type = type_name.to_uppercase();
+    upper_type.contains("BIGINT") || upper_type.contains("LARGEINT")
+}
+
+fn is_lossless_integer_column(column: &mysql_async::Column) -> bool {
+    matches!(column.column_type(), ColumnType::MYSQL_TYPE_LONGLONG | ColumnType::MYSQL_TYPE_NEWDECIMAL)
+}
+
+fn is_mysql_binary_charset(column: &mysql_async::Column) -> bool {
+    column.character_set() == 63
+}
+
+fn is_mysql_blob_column(column: &mysql_async::Column) -> bool {
+    is_mysql_binary_charset(column)
+        && matches!(
+            column.column_type(),
+            ColumnType::MYSQL_TYPE_BLOB
+                | ColumnType::MYSQL_TYPE_LONG_BLOB
+                | ColumnType::MYSQL_TYPE_MEDIUM_BLOB
+                | ColumnType::MYSQL_TYPE_TINY_BLOB
+        )
+}
+
+fn is_mysql_binary_string_column(column: &mysql_async::Column) -> bool {
+    is_mysql_binary_charset(column)
+        && matches!(
+            column.column_type(),
+            ColumnType::MYSQL_TYPE_STRING | ColumnType::MYSQL_TYPE_VAR_STRING | ColumnType::MYSQL_TYPE_VARCHAR
+        )
+}
+
+fn mysql_printable_binary_preview(bytes: &[u8]) -> Option<String> {
+    let trimmed = bytes.strip_suffix(&[0]).map_or(bytes, |mut value| {
+        while let Some(rest) = value.strip_suffix(&[0]) {
+            value = rest;
+        }
+        value
+    });
+    if trimmed.is_empty() {
+        return Some(String::new());
+    }
+
+    let text = std::str::from_utf8(trimmed).ok()?;
+    text.chars().all(|ch| !ch.is_control() || matches!(ch, '\t' | '\n' | '\r')).then(|| text.to_string())
+}
+
+fn mysql_blob_preview(bytes: &[u8], label: &str) -> serde_json::Value {
+    if label == "BLOB" {
+        return super::binary_value_to_json(bytes);
+    }
+    serde_json::Value::String(format!("({label}) {} bytes", bytes.len()))
+}
+
+fn mysql_bit_value_to_string(bytes: &[u8], column: &mysql_async::Column) -> String {
+    let bit_len = column.column_length();
+    if bit_len > 1 {
+        let total_bits = bytes.len() * 8;
+        let mut bits = String::with_capacity(total_bits);
+        for byte in bytes {
+            bits.push_str(&format!("{byte:08b}"));
+        }
+        let start = bits.len().saturating_sub(bit_len as usize);
+        return bits[start..].to_string();
+    }
+
+    let val = bytes.iter().fold(0u64, |acc, &b| (acc << 8) | b as u64);
+    val.to_string()
+}
+
+fn mysql_bytes_to_json(bytes: Vec<u8>, column: &mysql_async::Column) -> serde_json::Value {
+    if is_mysql_blob_column(column) {
+        return mysql_blob_preview(&bytes, "BLOB");
+    }
+    if is_mysql_binary_string_column(column) {
+        return mysql_printable_binary_preview(&bytes)
+            .map(serde_json::Value::String)
+            .unwrap_or_else(|| super::binary_value_to_json(&bytes));
+    }
+    serde_json::Value::String(String::from_utf8_lossy(&bytes).to_string())
+}
+
+/// Map a MySQL column to a user-facing type name for the result-grid header.
+/// Returns the bare lowercase type name (no length/precision/signedness), which
+/// is enough for display; unknown variants fall back to a lowercased debug name.
+pub(crate) fn mysql_column_type_name(ty: ColumnType) -> String {
+    use mysql_async::consts::ColumnType::*;
+    match ty {
+        MYSQL_TYPE_TINY => "tinyint",
+        MYSQL_TYPE_SHORT => "smallint",
+        MYSQL_TYPE_INT24 => "mediumint",
+        MYSQL_TYPE_LONG => "int",
+        MYSQL_TYPE_LONGLONG => "bigint",
+        MYSQL_TYPE_FLOAT => "float",
+        MYSQL_TYPE_DOUBLE => "double",
+        MYSQL_TYPE_DECIMAL | MYSQL_TYPE_NEWDECIMAL => "decimal",
+        MYSQL_TYPE_BIT => "bit",
+        MYSQL_TYPE_YEAR => "year",
+        MYSQL_TYPE_DATE | MYSQL_TYPE_NEWDATE => "date",
+        MYSQL_TYPE_TIME | MYSQL_TYPE_TIME2 => "time",
+        MYSQL_TYPE_DATETIME | MYSQL_TYPE_DATETIME2 => "datetime",
+        MYSQL_TYPE_TIMESTAMP | MYSQL_TYPE_TIMESTAMP2 => "timestamp",
+        MYSQL_TYPE_JSON => "json",
+        MYSQL_TYPE_ENUM => "enum",
+        MYSQL_TYPE_SET => "set",
+        MYSQL_TYPE_TINY_BLOB => "tinyblob",
+        MYSQL_TYPE_MEDIUM_BLOB => "mediumblob",
+        MYSQL_TYPE_LONG_BLOB => "longblob",
+        MYSQL_TYPE_BLOB => "blob",
+        MYSQL_TYPE_VARCHAR | MYSQL_TYPE_VAR_STRING => "varchar",
+        MYSQL_TYPE_STRING => "char",
+        MYSQL_TYPE_GEOMETRY => "geometry",
+        MYSQL_TYPE_NULL => "null",
+        other => return format!("{:?}", other).to_lowercase(),
+    }
+    .to_string()
+}
+
+pub(crate) fn mysql_value_to_json(row: &mysql_async::Row, idx: usize) -> serde_json::Value {
+    let Some(column) = row.columns_ref().get(idx) else {
+        return serde_json::Value::Null;
+    };
+
+    let Some(value) = row.as_ref(idx) else {
+        return serde_json::Value::Null;
+    };
+    if matches!(value, mysql_async::Value::NULL) {
+        return serde_json::Value::Null;
+    }
+
+    if is_mysql_binary_string_column(column) {
+        return row_get::<Vec<u8>, _>(row, idx)
+            .map(|bytes| mysql_bytes_to_json(bytes, column))
+            .unwrap_or(serde_json::Value::Null);
+    }
+
+    match column.column_type() {
+        ColumnType::MYSQL_TYPE_JSON => {
+            if let Some(v) = row_get::<String, _>(row, idx) {
+                return serde_json::Value::String(v);
+            }
+        }
+        ColumnType::MYSQL_TYPE_DECIMAL | ColumnType::MYSQL_TYPE_NEWDECIMAL | ColumnType::MYSQL_TYPE_LONGLONG => {
+            if is_lossless_integer_column(column) {
+                return row
+                    .get_opt::<String, usize>(idx)
+                    .and_then(|result| result.ok())
+                    .map(serde_json::Value::String)
+                    .or_else(|| {
+                        row_get::<Decimal, _>(row, idx).map(|v: Decimal| serde_json::Value::String(v.to_string()))
+                    })
+                    .or_else(|| row_get::<i64, _>(row, idx).map(|v| serde_json::Value::String(v.to_string())))
+                    .or_else(|| row_get::<u64, _>(row, idx).map(|v| serde_json::Value::String(v.to_string())))
+                    .or_else(|| row_get::<Vec<u8>, _>(row, idx).map(|bytes| mysql_bytes_to_json(bytes, column)))
+                    .unwrap_or(serde_json::Value::Null);
+            }
+            return row
+                .get_opt::<Decimal, usize>(idx)
+                .and_then(|result| result.ok())
+                .map(|v: Decimal| serde_json::Value::String(v.to_string()))
+                .unwrap_or(serde_json::Value::Null);
+        }
+        ColumnType::MYSQL_TYPE_BIT => {
+            return row_get::<Vec<u8>, _>(row, idx)
+                .map(|bytes| serde_json::Value::String(mysql_bit_value_to_string(&bytes, column)))
+                .unwrap_or(serde_json::Value::Null);
+        }
+        ColumnType::MYSQL_TYPE_BLOB
+        | ColumnType::MYSQL_TYPE_LONG_BLOB
+        | ColumnType::MYSQL_TYPE_MEDIUM_BLOB
+        | ColumnType::MYSQL_TYPE_TINY_BLOB
+        | ColumnType::MYSQL_TYPE_GEOMETRY => {
+            return row_get::<Vec<u8>, _>(row, idx)
+                .map(|bytes| {
+                    if matches!(column.column_type(), ColumnType::MYSQL_TYPE_GEOMETRY) {
+                        // MySQL prefixes geometry WKB with a 4-byte SRID.
+                        // Strip it before passing to the WKB parser.
+                        let wkb = if bytes.len() >= 4 { &bytes[4..] } else { &bytes };
+                        super::wkb::wkb_to_wkt(wkb)
+                            .map(serde_json::Value::String)
+                            .unwrap_or_else(|| super::binary_value_to_json(&bytes))
+                    } else {
+                        mysql_bytes_to_json(bytes, column)
+                    }
+                })
+                .unwrap_or(serde_json::Value::Null);
+        }
+        ColumnType::MYSQL_TYPE_TIMESTAMP
+        | ColumnType::MYSQL_TYPE_TIMESTAMP2
+        | ColumnType::MYSQL_TYPE_DATETIME
+        | ColumnType::MYSQL_TYPE_DATETIME2
+        | ColumnType::MYSQL_TYPE_DATE
+        | ColumnType::MYSQL_TYPE_TIME
+        | ColumnType::MYSQL_TYPE_TIME2
+        | ColumnType::MYSQL_TYPE_NEWDATE => {
+            if let Some(value) = mysql_temporal_value_to_json(
+                column.column_type(),
+                row_get::<NaiveDateTime, _>(row, idx),
+                row_get::<NaiveDate, _>(row, idx),
+                row_get::<NaiveTime, _>(row, idx),
+            ) {
+                return value;
+            }
+        }
+        _ => {}
+    }
+
+    row_get::<String, _>(row, idx)
+        .map(|s| serde_json::Value::String(fix_potential_double_encoding(&s)))
+        .or_else(|| row_get::<i64, _>(row, idx).map(super::safe_i64_to_json))
+        .or_else(|| row_get::<u64, _>(row, idx).map(super::safe_u64_to_json))
+        .or_else(|| row_get::<i32, _>(row, idx).map(|v| serde_json::Value::Number(v.into())))
+        .or_else(|| row_get::<i16, _>(row, idx).map(|v| serde_json::Value::Number(v.into())))
+        .or_else(|| {
+            row_get::<f64, _>(row, idx).map(|v| {
+                serde_json::Number::from_f64(v).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null)
+            })
+        })
+        .or_else(|| row_get::<bool, _>(row, idx).map(serde_json::Value::Bool))
+        .or_else(|| row_get::<Vec<u8>, _>(row, idx).map(|bytes| mysql_bytes_to_json(bytes, column)))
+        .unwrap_or(serde_json::Value::Null)
+}
+
+fn mysql_temporal_value_to_json(
+    column_type: ColumnType,
+    datetime: Option<NaiveDateTime>,
+    date: Option<NaiveDate>,
+    time: Option<NaiveTime>,
+) -> Option<serde_json::Value> {
+    let value = match column_type {
+        ColumnType::MYSQL_TYPE_DATE | ColumnType::MYSQL_TYPE_NEWDATE => {
+            date.map(|value| value.to_string()).or_else(|| datetime.map(|value| value.date().to_string()))?
+        }
+        ColumnType::MYSQL_TYPE_TIME | ColumnType::MYSQL_TYPE_TIME2 => time.map(|value| value.to_string())?,
+        ColumnType::MYSQL_TYPE_TIMESTAMP
+        | ColumnType::MYSQL_TYPE_TIMESTAMP2
+        | ColumnType::MYSQL_TYPE_DATETIME
+        | ColumnType::MYSQL_TYPE_DATETIME2 => datetime
+            .map(|value| value.to_string())
+            .or_else(|| date.map(|value| value.to_string()))
+            .or_else(|| time.map(|value| value.to_string()))?,
+        _ => return None,
+    };
+    Some(serde_json::Value::String(value))
+}
+
+pub async fn connect(url: &str, fallback_timeout: Duration) -> Result<MySqlPool, String> {
+    connect_with_ca_cert(url, None, fallback_timeout).await
+}
+
+pub async fn connect_with_ca_cert(
+    url: &str,
+    ca_cert_path: Option<&str>,
+    fallback_timeout: Duration,
+) -> Result<MySqlPool, String> {
+    connect_with_ca_cert_and_pool_limit(url, ca_cert_path, fallback_timeout, 10).await
+}
+
+pub async fn connect_with_ca_cert_and_pool_limit(
+    url: &str,
+    ca_cert_path: Option<&str>,
+    fallback_timeout: Duration,
+    max_connections: usize,
+) -> Result<MySqlPool, String> {
+    connect_with_ca_cert_pool_limit_and_idle(url, ca_cert_path, fallback_timeout, max_connections, None).await
+}
+
+pub async fn connect_with_ca_cert_pool_limit_and_idle(
+    url: &str,
+    ca_cert_path: Option<&str>,
+    fallback_timeout: Duration,
+    max_connections: usize,
+    idle_timeout_secs: Option<u64>,
+) -> Result<MySqlPool, String> {
+    connect_with_ca_cert_pool_limit_idle_and_setup(
+        url,
+        ca_cert_path,
+        fallback_timeout,
+        max_connections,
+        idle_timeout_secs,
+        &[],
+    )
+    .await
+}
+
+pub async fn connect_with_ca_cert_pool_limit_idle_and_setup(
+    url: &str,
+    ca_cert_path: Option<&str>,
+    fallback_timeout: Duration,
+    max_connections: usize,
+    idle_timeout_secs: Option<u64>,
+    extra_setup_queries: &[String],
+) -> Result<MySqlPool, String> {
+    connect_with_ca_cert_pool_limit_idle_and_setup_database(
+        url,
+        ca_cert_path,
+        fallback_timeout,
+        max_connections,
+        idle_timeout_secs,
+        None,
+        extra_setup_queries,
+    )
+    .await
+}
+
+pub async fn connect_with_ca_cert_pool_limit_idle_and_setup_database(
+    url: &str,
+    ca_cert_path: Option<&str>,
+    fallback_timeout: Duration,
+    max_connections: usize,
+    idle_timeout_secs: Option<u64>,
+    setup_database: Option<&str>,
+    extra_setup_queries: &[String],
+) -> Result<MySqlPool, String> {
+    connect_with_ca_cert_pool_limit_idle_setup_database_with_mode(
+        url,
+        ca_cert_path,
+        fallback_timeout,
+        max_connections,
+        idle_timeout_secs,
+        setup_database,
+        extra_setup_queries,
+        MySqlSetupMode::Standard,
+    )
+    .await
+}
+
+pub async fn connect_compatible_with_ca_cert_pool_limit_idle_and_setup(
+    url: &str,
+    ca_cert_path: Option<&str>,
+    fallback_timeout: Duration,
+    max_connections: usize,
+    idle_timeout_secs: Option<u64>,
+    extra_setup_queries: &[String],
+) -> Result<MySqlPool, String> {
+    connect_compatible_with_ca_cert_pool_limit_idle_and_setup_database(
+        url,
+        ca_cert_path,
+        fallback_timeout,
+        max_connections,
+        idle_timeout_secs,
+        None,
+        extra_setup_queries,
+    )
+    .await
+}
+
+pub async fn connect_compatible_with_ca_cert_pool_limit_idle_and_setup_database(
+    url: &str,
+    ca_cert_path: Option<&str>,
+    fallback_timeout: Duration,
+    max_connections: usize,
+    idle_timeout_secs: Option<u64>,
+    setup_database: Option<&str>,
+    extra_setup_queries: &[String],
+) -> Result<MySqlPool, String> {
+    connect_with_ca_cert_pool_limit_idle_setup_database_with_mode(
+        url,
+        ca_cert_path,
+        fallback_timeout,
+        max_connections,
+        idle_timeout_secs,
+        setup_database,
+        extra_setup_queries,
+        MySqlSetupMode::Compatible,
+    )
+    .await
+}
+
+async fn connect_with_ca_cert_pool_limit_idle_setup_database_with_mode(
+    url: &str,
+    ca_cert_path: Option<&str>,
+    fallback_timeout: Duration,
+    max_connections: usize,
+    idle_timeout_secs: Option<u64>,
+    setup_database: Option<&str>,
+    extra_setup_queries: &[String],
+    setup_mode: MySqlSetupMode,
+) -> Result<MySqlPool, String> {
+    let timeout = super::parse_connect_timeout_with_fallback(url, fallback_timeout);
+    let pool = create_pool(
+        url,
+        ca_cert_path,
+        max_connections,
+        idle_timeout_secs,
+        setup_database,
+        extra_setup_queries,
+        setup_mode,
+    )?;
+    let result = verify_pool_connection_with_setup_fallback(
+        pool,
+        timeout,
+        url,
+        ca_cert_path,
+        max_connections,
+        idle_timeout_secs,
+        setup_database,
+        extra_setup_queries,
+        setup_mode,
+    )
+    .await;
+
+    if let Err(ref e) = result {
+        if mysql_error_should_retry_without_ssl(e) {
+            if let Some(fallback_url) = ssl_fallback_url(url) {
+                log::info!("SSL handshake failed, retrying with ssl-mode=disabled");
+                let fallback_pool = create_pool(
+                    &fallback_url,
+                    None,
+                    max_connections,
+                    idle_timeout_secs,
+                    setup_database,
+                    extra_setup_queries,
+                    setup_mode,
+                )?;
+                return verify_pool_connection_with_setup_fallback(
+                    fallback_pool,
+                    timeout,
+                    &fallback_url,
+                    None,
+                    max_connections,
+                    idle_timeout_secs,
+                    setup_database,
+                    extra_setup_queries,
+                    setup_mode,
+                )
+                .await;
+            }
+        }
+    }
+
+    result
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+struct MySqlTlsFiles {
+    sslcert: Option<String>,
+    sslkey: Option<String>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum MySqlSetupMode {
+    Standard,
+    Compatible,
+}
+
+impl MySqlSetupMode {
+    fn set_group_concat_max_len(self) -> bool {
+        self == Self::Standard
+    }
+}
+
+async fn verify_pool_connection_with_setup_fallback(
+    pool: MySqlPool,
+    timeout: Duration,
+    url: &str,
+    ca_cert_path: Option<&str>,
+    max_connections: usize,
+    idle_timeout_secs: Option<u64>,
+    setup_database: Option<&str>,
+    extra_setup_queries: &[String],
+    setup_mode: MySqlSetupMode,
+) -> Result<MySqlPool, String> {
+    match verify_pool_connection(&pool, timeout).await {
+        Ok(()) => Ok(pool),
+        Err(err) => {
+            let Some(fallback_mode) = mysql_setup_mode_retry_without_group_concat(setup_mode, &err) else {
+                return Err(err);
+            };
+            log::info!(
+                "MySQL server rejected optional group_concat_max_len setup; retrying without that session setting"
+            );
+            let fallback_pool = create_pool(
+                url,
+                ca_cert_path,
+                max_connections,
+                idle_timeout_secs,
+                setup_database,
+                extra_setup_queries,
+                fallback_mode,
+            )?;
+            verify_pool_connection(&fallback_pool, timeout).await.map(|_| fallback_pool)
+        }
+    }
+}
+
+fn mysql_setup_mode_retry_without_group_concat(setup_mode: MySqlSetupMode, error: &str) -> Option<MySqlSetupMode> {
+    // group_concat_max_len improves real MySQL metadata reads, but some MySQL-compatible proxies reject the variable.
+    if setup_mode.set_group_concat_max_len() && mysql_error_should_retry_without_group_concat_max_len(error) {
+        return Some(MySqlSetupMode::Compatible);
+    }
+    None
+}
+
+fn create_pool(
+    url: &str,
+    ca_cert_path: Option<&str>,
+    max_connections: usize,
+    idle_timeout_secs: Option<u64>,
+    setup_database: Option<&str>,
+    extra_setup_queries: &[String],
+    setup_mode: MySqlSetupMode,
+) -> Result<MySqlPool, String> {
+    let tls_url = mysql_tls_url(url)?;
+    let opts =
+        mysql_async::Opts::from_url(&mysql_async_url(&tls_url.url)).map_err(|e| format!("Invalid MySQL URL: {e}"))?;
+    let tcp_host = mysql_async_tcp_host(opts.ip_or_hostname()).to_string();
+    let base_ssl_opts = opts.ssl_opts().cloned();
+    let max_connections = max_connections.max(1);
+    // Single-connection pools (max_connections == 1) are client session pools that
+    // must preserve session state (e.g. TEMPORARY TABLEs) across queries.
+    // Disable COM_RESET_CONNECTION for these pools to avoid clearing that state.
+    let inactive_ttl =
+        idle_timeout_secs.filter(|&s| s >= 30).map(Duration::from_secs).unwrap_or(Duration::from_secs(300));
+    let pool_opts = mysql_async::PoolOpts::new()
+        .with_constraints(mysql_async::PoolConstraints::new(1, max_connections).unwrap())
+        .with_inactive_connection_ttl(inactive_ttl)
+        .with_reset_connection(max_connections > 1);
+    let setup_queries = match (setup_database, setup_mode) {
+        (Some(database), MySqlSetupMode::Standard) => {
+            mysql_setup_queries_for_database(url, Some(database), extra_setup_queries)
+        }
+        (None, MySqlSetupMode::Standard) => mysql_setup_queries(url, extra_setup_queries),
+        (Some(database), MySqlSetupMode::Compatible) => {
+            mysql_setup_queries_for_database_with_mode(url, Some(database), extra_setup_queries, setup_mode)
+        }
+        (None, MySqlSetupMode::Compatible) => mysql_setup_queries_with_mode(url, extra_setup_queries, setup_mode),
+    };
+    let mut builder = mysql_async::OptsBuilder::from_opts(opts)
+        .ip_or_hostname(tcp_host)
+        .stmt_cache_size(0)
+        .prefer_socket(false)
+        .pool_opts(Some(pool_opts))
+        .tcp_keepalive(Some(MYSQL_TCP_KEEPALIVE_MS))
+        .setup(setup_queries);
+    if let Some(ssl_opts) = mysql_ssl_opts(base_ssl_opts, url, ca_cert_path, &tls_url.files)? {
+        builder = builder.ssl_opts(ssl_opts);
+    }
+    Ok(MySqlPool::new(builder))
+}
+
+fn mysql_async_tcp_host(host: &str) -> &str {
+    if let Some(inner) = host.strip_prefix('[').and_then(|value| value.strip_suffix(']')) {
+        // mysql_async preserves IPv6 brackets when converting URL opts into an
+        // OptsBuilder, but the builder TCP path resolves host strings directly.
+        if inner.parse::<std::net::Ipv6Addr>().is_ok() {
+            return inner;
+        }
+    }
+    host
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct MySqlTlsUrl {
+    url: String,
+    files: MySqlTlsFiles,
+}
+
+fn mysql_tls_url(url: &str) -> Result<MySqlTlsUrl, String> {
+    let Some(query_start) = url.find('?') else {
+        return Ok(MySqlTlsUrl { url: url.to_string(), files: MySqlTlsFiles::default() });
+    };
+
+    let prefix = &url[..query_start];
+    let suffix = &url[query_start + 1..];
+    let (query_string, fragment) = suffix.split_once('#').map_or((suffix, ""), |(query, fragment)| (query, fragment));
+    let mut files = MySqlTlsFiles::default();
+    let mut kept_params = Vec::new();
+
+    for param in query_string.split('&') {
+        if param.is_empty() {
+            continue;
+        }
+
+        let Some((key, value)) = param.split_once('=') else {
+            kept_params.push(param.to_string());
+            continue;
+        };
+
+        if mysql_tls_file_param_is(key, "cert") || mysql_tls_file_param_is(key, "key") {
+            let decoded = percent_decode_str(value)
+                .decode_utf8()
+                .map_err(|_| format!("Invalid URL encoding in {key}"))?
+                .into_owned();
+            validate_file_path(&decoded, |_| false).map_err(|e| format!("{key}: {e}"))?;
+
+            if mysql_tls_file_param_is(key, "cert") {
+                files.sslcert = Some(decoded);
+            } else {
+                files.sslkey = Some(decoded);
+            }
+        } else {
+            kept_params.push(param.to_string());
+        }
+    }
+
+    let mut sanitized_url = prefix.to_string();
+    if !kept_params.is_empty() {
+        sanitized_url.push('?');
+        sanitized_url.push_str(&kept_params.join("&"));
+    }
+    if !fragment.is_empty() {
+        sanitized_url.push('#');
+        sanitized_url.push_str(fragment);
+    }
+
+    Ok(MySqlTlsUrl { url: sanitized_url, files })
+}
+
+fn mysql_tls_file_param_is(key: &str, target: &str) -> bool {
+    let normalized = key.to_ascii_lowercase().replace(['-', '_'], "");
+    normalized == format!("ssl{target}")
+}
+
+fn mysql_ssl_opts(
+    base_ssl_opts: Option<mysql_async::SslOpts>,
+    url: &str,
+    ca_cert_path: Option<&str>,
+    files: &MySqlTlsFiles,
+) -> Result<Option<mysql_async::SslOpts>, String> {
+    let ca_cert_path = ca_cert_path.map(str::trim).filter(|path| !path.is_empty());
+    let has_client_identity = files.sslcert.as_deref().is_some() || files.sslkey.as_deref().is_some();
+    if !mysql_url_attempts_ssl(url) && !has_client_identity {
+        return Ok(None);
+    }
+
+    let mut ssl_opts = base_ssl_opts.unwrap_or_default();
+    if let Some(ca_cert_path) = ca_cert_path.filter(|_| mysql_url_attempts_ssl(url) || has_client_identity) {
+        ssl_opts = ssl_opts.with_root_certs(vec![PathBuf::from(ca_cert_path).into()]);
+        if !mysql_url_verifies_identity(url) {
+            ssl_opts = ssl_opts.with_danger_skip_domain_validation(true);
+        }
+    }
+
+    match (files.sslcert.as_deref(), files.sslkey.as_deref()) {
+        (Some(cert_path), Some(key_path)) => {
+            ssl_opts = ssl_opts.with_client_identity(Some(mysql_async::ClientIdentity::new(
+                PathBuf::from(cert_path).into(),
+                PathBuf::from(key_path).into(),
+            )));
+        }
+        (Some(_), None) => return Err("MySQL ssl-cert requires ssl-key".to_string()),
+        (None, Some(_)) => return Err("MySQL ssl-key requires ssl-cert".to_string()),
+        (None, None) => {}
+    }
+
+    Ok(Some(ssl_opts))
+}
+
+fn mysql_setup_queries(url: &str, extra_setup_queries: &[String]) -> Vec<String> {
+    mysql_setup_queries_with_mode(url, extra_setup_queries, MySqlSetupMode::Standard)
+}
+
+fn mysql_setup_queries_for_database(
+    url: &str,
+    setup_database: Option<&str>,
+    extra_setup_queries: &[String],
+) -> Vec<String> {
+    mysql_setup_queries_for_database_with_mode(url, setup_database, extra_setup_queries, MySqlSetupMode::Standard)
+}
+
+fn mysql_setup_queries_with_mode(url: &str, extra_setup_queries: &[String], setup_mode: MySqlSetupMode) -> Vec<String> {
+    mysql_setup_queries_for_database_with_mode(url, None, extra_setup_queries, setup_mode)
+}
+
+fn mysql_setup_queries_for_database_with_mode(
+    url: &str,
+    setup_database: Option<&str>,
+    extra_setup_queries: &[String],
+    setup_mode: MySqlSetupMode,
+) -> Vec<String> {
+    let charset = mysql_connection_charset(url).unwrap_or("utf8mb4");
+    let catalog = mysql_connection_catalog(url);
+    let database = setup_database.map(ToOwned::to_owned).or_else(|| mysql_connection_database(url));
+    let mut queries = Vec::new();
+    if let Some(database) = database.as_deref() {
+        queries.push(format!("USE {}", quote_identifier(database)));
+    }
+    if let Some(time_zone) = mysql_connection_time_zone(url) {
+        queries.push(format!("SET time_zone = {}", quote_value(&time_zone)));
+    }
+    queries.push(format!("SET NAMES {charset}"));
+    // MySQL defaults group_concat_max_len to 1024, which silently truncates
+    // GROUP_CONCAT results. Skip it for MySQL protocol-compatible databases
+    // such as old StarRocks versions that reject unknown MySQL variables.
+    if setup_mode.set_group_concat_max_len() {
+        queries.push("SET @@group_concat_max_len = 1048576".to_string());
+    }
+    // StarRocks/Doris expose external storage (Paimon, Hive, ...) through a
+    // catalog. `SET catalog` must run *before* `USE <database>` (the database
+    // lives in the external catalog and is unknown to the default one).
+    // mysql_async drains the setup list back-to-front (Vec::pop), so push it
+    // last to make it execute first. The handshake does not send the database
+    // as schema (see `mysql_async_url`, which strips the path when a catalog is
+    // configured), so the connection establishes in the default catalog and
+    // this setup query is what switches it. The pool re-runs these queries
+    // after every connection reset, so the catalog stays current.
+    if let Some(catalog) = catalog.as_deref() {
+        queries.push(format!("SET catalog = {}", quote_identifier(catalog)));
+    }
+    queries.extend(extra_setup_queries.iter().cloned());
+    queries
+}
+
+fn should_enable_explicit_timestamp_defaults(sql: &str) -> bool {
+    if !starts_with_executable_sql_keyword(sql, &["CREATE", "ALTER"]) {
+        return false;
+    }
+    let lower = sql.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    lower.contains("timestamp") && lower.contains("default null")
+}
+
+fn explicit_timestamp_defaults_sql(enabled: bool) -> &'static str {
+    if enabled {
+        "SET SESSION explicit_defaults_for_timestamp = ON"
+    } else {
+        "SET SESSION explicit_defaults_for_timestamp = OFF"
+    }
+}
+
+async fn enable_explicit_timestamp_defaults_for_query(conn: &mut mysql_async::Conn, sql: &str) -> Option<bool> {
+    if !should_enable_explicit_timestamp_defaults(sql) {
+        return None;
+    }
+
+    let previous = match conn.query_first::<u8, _>("SELECT @@SESSION.explicit_defaults_for_timestamp").await {
+        Ok(Some(value)) => value != 0,
+        Ok(None) => {
+            log::debug!("Skipping MySQL explicit timestamp defaults compatibility setting: variable was empty");
+            return None;
+        }
+        Err(err) => {
+            log::debug!("Skipping MySQL explicit timestamp defaults compatibility setting: {err}");
+            return None;
+        }
+    };
+
+    if previous {
+        return None;
+    }
+
+    if let Err(err) = conn.query_drop(explicit_timestamp_defaults_sql(true)).await {
+        log::debug!("Skipping MySQL explicit timestamp defaults compatibility setting: {err}");
+        return None;
+    }
+
+    Some(previous)
+}
+
+async fn restore_explicit_timestamp_defaults_for_query(conn: &mut mysql_async::Conn, previous: Option<bool>) {
+    if let Some(previous) = previous {
+        if let Err(err) = conn.query_drop(explicit_timestamp_defaults_sql(previous)).await {
+            log::warn!("Failed to restore MySQL explicit timestamp defaults session setting: {err}");
+        }
+    }
+}
+
+fn mysql_connection_charset(url: &str) -> Option<&str> {
+    let (_, query) = url.split_once('?')?;
+    query.split('&').find_map(|segment| {
+        let (key, value) = segment.split_once('=')?;
+        if !key.eq_ignore_ascii_case("charset") {
+            return None;
+        }
+        let value = value.trim();
+        is_safe_mysql_charset_name(value).then_some(value)
+    })
+}
+
+fn mysql_connection_database(url: &str) -> Option<String> {
+    let rest = url.strip_prefix("mysql://")?;
+    let (_, path_and_query) = rest.split_once('/')?;
+    let path = path_and_query.split(['?', '#']).next().unwrap_or(path_and_query);
+    let database = path.trim_start_matches('/').split('/').next().unwrap_or("").trim();
+    if database.is_empty() {
+        return None;
+    }
+    percent_decode_str(database).decode_utf8().ok().map(|value| value.into_owned())
+}
+
+/// Extracts an opt-in `catalog=<name>` URL parameter. dbx strips it from the
+/// URL before handing it to mysql_async (see `is_dbx_handled_mysql_url_param`)
+/// and instead emits `SET catalog = <name>` during connection setup. This is
+/// how StarRocks/Doris connections reach an external catalog such as Paimon.
+fn mysql_connection_catalog(url: &str) -> Option<String> {
+    let (_, query) = url.split_once('?')?;
+    let query = query.split('#').next().unwrap_or(query);
+    query.split('&').find_map(|segment| {
+        let (key, value) = segment.split_once('=')?;
+        if !key.eq_ignore_ascii_case("catalog") {
+            return None;
+        }
+        let value = value.trim();
+        if value.is_empty() {
+            return None;
+        }
+        percent_decode_str(value).decode_utf8().ok().map(|value| value.into_owned())
+    })
+}
+
+fn is_safe_mysql_charset_name(value: &str) -> bool {
+    !value.is_empty() && value.bytes().all(|byte| byte.is_ascii_alphanumeric() || byte == b'_')
+}
+
+fn mysql_connection_time_zone(url: &str) -> Option<String> {
+    let (_, query) = url.split_once('?')?;
+    let mut jdbc_time_zone: Option<String> = None;
+    let mut go_location: Option<String> = None;
+
+    for segment in query.split('&') {
+        let Some((raw_key, raw_value)) = segment.split_once('=') else {
+            continue;
+        };
+        let key = percent_decode_str(raw_key).decode_utf8_lossy();
+        let value = percent_decode_str(raw_value).decode_utf8_lossy().trim().to_string();
+        if value.is_empty() {
+            continue;
+        }
+
+        if key.eq_ignore_ascii_case("time_zone")
+            || key.eq_ignore_ascii_case("time-zone")
+            || key.eq_ignore_ascii_case("timezone")
+        {
+            if let Some(value) = normalize_mysql_time_zone_value(&value) {
+                return Some(value);
+            }
+        } else if key.eq_ignore_ascii_case("connectionTimeZone") || key.eq_ignore_ascii_case("serverTimezone") {
+            if jdbc_time_zone.is_none() {
+                jdbc_time_zone = normalize_mysql_time_zone_value(&value);
+            }
+        } else if key.eq_ignore_ascii_case("loc") && go_location.is_none() {
+            go_location = normalize_mysql_time_zone_value(&value);
+        }
+    }
+
+    jdbc_time_zone.or(go_location)
+}
+
+fn normalize_mysql_time_zone_value(value: &str) -> Option<String> {
+    let value = value.trim();
+    if value.is_empty() {
+        return None;
+    }
+    if value.eq_ignore_ascii_case("local") {
+        return Some(local_mysql_time_zone_offset());
+    }
+    if value.eq_ignore_ascii_case("utc") || value.eq_ignore_ascii_case("z") {
+        return Some("+00:00".to_string());
+    }
+    if value.eq_ignore_ascii_case("system") {
+        return Some("SYSTEM".to_string());
+    }
+    if let Some(offset) = normalize_mysql_time_zone_offset(value) {
+        return Some(offset);
+    }
+    if let Some(offset_part) = value
+        .strip_prefix("GMT")
+        .or_else(|| value.strip_prefix("gmt"))
+        .or_else(|| value.strip_prefix("UTC"))
+        .or_else(|| value.strip_prefix("utc"))
+    {
+        if let Some(offset) = normalize_mysql_time_zone_offset(offset_part) {
+            return Some(offset);
+        }
+    }
+    is_safe_mysql_time_zone_name(value).then(|| value.to_string())
+}
+
+fn normalize_mysql_time_zone_offset(value: &str) -> Option<String> {
+    let value = value.trim();
+    let (sign, rest) = match value.as_bytes().first().copied()? {
+        b'+' => ('+', &value[1..]),
+        b'-' => ('-', &value[1..]),
+        _ => return None,
+    };
+    let (hours, minutes) =
+        if let Some((hours, minutes)) = rest.split_once(':') { (hours, minutes) } else { (rest, "0") };
+    if hours.is_empty() || hours.len() > 2 || minutes.is_empty() || minutes.len() > 2 {
+        return None;
+    }
+    let hours = hours.parse::<u8>().ok()?;
+    let minutes = minutes.parse::<u8>().ok()?;
+    if hours > 14 || minutes > 59 || (hours == 14 && minutes != 0) {
+        return None;
+    }
+    Some(format!("{sign}{hours:02}:{minutes:02}"))
+}
+
+fn local_mysql_time_zone_offset() -> String {
+    let seconds = chrono::Local::now().offset().local_minus_utc();
+    let sign = if seconds < 0 { '-' } else { '+' };
+    let seconds = seconds.abs();
+    let hours = seconds / 3600;
+    let minutes = (seconds % 3600) / 60;
+    format!("{sign}{hours:02}:{minutes:02}")
+}
+
+fn is_safe_mysql_time_zone_name(value: &str) -> bool {
+    !value.is_empty()
+        && value.bytes().all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'/' | b'_' | b'-' | b'+' | b':'))
+}
+
+async fn verify_pool_connection(pool: &MySqlPool, timeout: Duration) -> Result<(), String> {
+    super::with_connection_timeout("MySQL", timeout, async {
+        let mut conn = pool.get_conn().await.map_err(|e| format!("MySQL connection failed: {e}"))?;
+        conn.ping().await.map_err(|e| format!("MySQL ping failed: {e}"))?;
+        Ok(())
+    })
+    .await
+}
+
+fn mysql_error_should_retry_without_ssl(error: &str) -> bool {
+    let error = error.to_ascii_lowercase();
+    error.contains("handshakefailure")
+        || error.contains("handshake")
+        || error.contains("tls connection")
+        || error.contains("server closed session")
+        // Some older MySQL proxies report a failed preferred-TLS probe as a
+        // protocol packet error instead of a TLS handshake error.
+        || error.contains("packet out of order")
+        // Some MySQL-compatible servers report a preferred-TLS attempt as a
+        // normal server error instead of a TLS handshake error.
+        || (error.contains("client asked for ssl") && error.contains("server does not have this capability"))
+}
+
+fn mysql_error_should_retry_with_text_protocol(error: &str) -> bool {
+    let lower = error.to_ascii_lowercase();
+    (lower.contains("1105") && lower.contains("hy000"))
+        || (lower.contains("1615") && lower.contains("re-prepared"))
+        || lower.contains("com_stmt_prepare")
+        || lower.contains("can't parse")
+        || lower.contains("buf doesn't have enough data")
+        || lower.contains("prepared statement protocol")
+        || lower.contains("this command is not supported in the prepared statement protocol yet")
+}
+
+fn mysql_error_should_retry_without_group_concat_max_len(error: &str) -> bool {
+    let lower = error.to_ascii_lowercase();
+    lower.contains("group_concat_max_len") && (lower.contains("1193") || lower.contains("unknown system variable"))
+}
+
+fn ssl_fallback_url(url: &str) -> Option<String> {
+    if mysql_url_requires_ssl(url) {
+        return None;
+    }
+
+    let (base_url, fragment) = url.split_once('#').map_or((url, ""), |(base, fragment)| (base, fragment));
+    let Some(query_start) = base_url.find('?') else {
+        let mut fallback = format!("{base_url}?ssl-mode=disabled");
+        if !fragment.is_empty() {
+            fallback.push('#');
+            fallback.push_str(fragment);
+        }
+        return Some(fallback);
+    };
+    let prefix = &base_url[..query_start];
+    let query_string = &base_url[query_start + 1..];
+    let mut changed = false;
+    let mut kept_params = Vec::new();
+
+    for param in query_string.split('&') {
+        if param.is_empty() {
+            continue;
+        }
+        let Some((key, value)) = param.split_once('=') else {
+            kept_params.push(param.to_string());
+            continue;
+        };
+        if (key.eq_ignore_ascii_case("ssl-mode") || key.eq_ignore_ascii_case("sslmode"))
+            && matches!(value.to_ascii_lowercase().replace('-', "_").as_str(), "preferred" | "prefer")
+        {
+            if !changed {
+                kept_params.push("ssl-mode=disabled".to_string());
+            }
+            changed = true;
+        } else {
+            kept_params.push(param.to_string());
+        }
+    }
+
+    if !changed
+        && !kept_params.iter().any(|part| {
+            part.split_once('=')
+                .is_some_and(|(key, _)| key.eq_ignore_ascii_case("ssl-mode") || key.eq_ignore_ascii_case("sslmode"))
+        })
+    {
+        kept_params.push("ssl-mode=disabled".to_string());
+        changed = true;
+    }
+
+    if changed {
+        let mut fallback = prefix.to_string();
+        if !kept_params.is_empty() {
+            fallback.push('?');
+            fallback.push_str(&kept_params.join("&"));
+        }
+        if !fragment.is_empty() {
+            fallback.push('#');
+            fallback.push_str(fragment);
+        }
+        Some(fallback)
+    } else {
+        None
+    }
+}
+
+fn mysql_url_requires_ssl(url: &str) -> bool {
+    let Some((_, query)) = url.split_once('?') else {
+        return false;
+    };
+    query.split('&').any(|segment| {
+        let Some((key, value)) = segment.split_once('=') else {
+            return false;
+        };
+        let key = key.trim();
+        let value = value.trim();
+        (key.eq_ignore_ascii_case("require_ssl") && value.eq_ignore_ascii_case("true"))
+            || mysql_tls_file_param_is(key, "cert")
+            || mysql_tls_file_param_is(key, "key")
+            || ((key.eq_ignore_ascii_case("ssl-mode") || key.eq_ignore_ascii_case("sslmode"))
+                && matches!(
+                    value.to_ascii_lowercase().replace('-', "_").as_str(),
+                    "required" | "require" | "verify_ca" | "verify_identity"
+                ))
+    })
+}
+
+fn mysql_url_attempts_ssl(url: &str) -> bool {
+    if mysql_url_requires_ssl(url) {
+        return true;
+    }
+
+    let Some((_, query)) = url.split_once('?') else {
+        return false;
+    };
+    query.split('&').any(|segment| {
+        let Some((key, value)) = segment.split_once('=') else {
+            return false;
+        };
+        let key = key.trim();
+        let value = value.trim();
+        (key.eq_ignore_ascii_case("ssl-mode") || key.eq_ignore_ascii_case("sslmode"))
+            && matches!(value.to_ascii_lowercase().replace('-', "_").as_str(), "preferred" | "prefer")
+    })
+}
+
+fn mysql_url_verifies_identity(url: &str) -> bool {
+    let Some((_, query)) = url.split_once('?') else {
+        return false;
+    };
+    query.split('&').any(|segment| {
+        let Some((key, value)) = segment.split_once('=') else {
+            return false;
+        };
+        let key = key.trim();
+        let value = value.trim();
+        (key.eq_ignore_ascii_case("verify_identity") && value.eq_ignore_ascii_case("true"))
+            || ((key.eq_ignore_ascii_case("ssl-mode") || key.eq_ignore_ascii_case("sslmode"))
+                && matches!(value.to_ascii_lowercase().replace('-', "_").as_str(), "verify_identity"))
+    })
+}
+
+fn is_jdbc_param(key: &str) -> bool {
+    matches!(
+        key.to_ascii_lowercase().as_str(),
+        "useunicode"
+            | "characterencoding"
+            | "zerodatetimebehavior"
+            | "usessl"
+            | "servertimezone"
+            | "allowpublickeyretrieval"
+            | "autoreconnect"
+            | "maxreconnects"
+            | "uselegacydatetimecode"
+            | "usecompression"
+            | "cacheprepstmts"
+            | "useserverprepstmts"
+            | "useconfigs"
+            | "usecursorfetch"
+            | "defaultfetchsize"
+            | "usejdbccomplianttimezoneshift"
+            | "usesspscompatibletimezoneshift"
+            | "failoverreadonly"
+            | "maxallowedpacket"
+            | "tinyint1isbit"
+            | "transformedbitisboolean"
+            | "yearisdatetype"
+            | "createdatabaseifnotexist"
+            | "allowmultiqueries"
+            | "noaccesstoprocedurebodies"
+            | "nullcatalogmeanscurrent"
+            | "nullnamepatternmatchesall"
+            | "dumponqueriesexception"
+            | "enablequerytimeouts"
+            | "useinformationschema"
+            | "gatherperfmetrics"
+            | "reportmetricsintervalmillis"
+            | "maxquerysizetolog"
+            | "packetdebugbuffersize"
+            | "usenanosforelapsedtime"
+            | "slowquerythresholdmillis"
+            | "autoslowlog"
+            | "explainslowqueries"
+            | "resultsetsizethreshold"
+            | "nettimeoutforstreamingresults"
+            | "useusageadvisor"
+    )
+}
+
+fn is_dbx_handled_mysql_url_param(key: &str) -> bool {
+    matches!(
+        key.to_ascii_lowercase().as_str(),
+        "charset"
+            | "catalog"
+            | "time_zone"
+            | "time-zone"
+            | "timezone"
+            | "connect_timeout"
+            | "connecttimeout"
+            | "parsetime"
+            | "loc"
+            | "connectiontimezone"
+            | "servertimezone"
+            | "forceconnectiontimezonetosession"
+    )
+}
+
+fn is_mysql_cleartext_password_param(key: &str) -> bool {
+    matches!(key.to_ascii_lowercase().as_str(), "allowcleartextpasswords" | "enable_cleartext_plugin")
+}
+
+fn mysql_url_param_value_is_true(value: &str) -> bool {
+    matches!(value.trim().to_ascii_lowercase().as_str(), "true" | "1" | "yes" | "on")
+}
+
+/// Strips the database path from a `mysql://[user[:pass]@]host[:port][/path]`
+/// URL, returning only the scheme and authority. Used so mysql_async does not
+/// send the database as the schema during the MySQL handshake (StarRocks would
+/// reject an external-catalog database before `SET catalog` runs in setup).
+fn strip_mysql_url_path(base: &str) -> &str {
+    let Some(rest) = base.strip_prefix("mysql://") else {
+        return base;
+    };
+    match rest.find('/') {
+        Some(idx) => &base[.."mysql://".len() + idx],
+        None => base,
+    }
+}
+
+fn mysql_async_url(url: &str) -> Cow<'_, str> {
+    let Some((base, query)) = url.split_once('?') else {
+        return Cow::Borrowed(url);
+    };
+
+    let original_count = query.split('&').filter(|segment| !segment.trim().is_empty()).count();
+    let mut filtered: Vec<String> = Vec::new();
+    let mut changed = false;
+    let mut has_catalog = false;
+    let mut enable_cleartext_plugin = false;
+    for segment in query.split('&') {
+        let segment = segment.trim();
+        if segment.is_empty() {
+            changed = true;
+            continue;
+        }
+
+        let Some((key, value)) = segment.split_once('=') else {
+            filtered.push(segment.to_string());
+            continue;
+        };
+        if key.eq_ignore_ascii_case("catalog") {
+            has_catalog = true;
+        }
+        if is_mysql_cleartext_password_param(key) {
+            changed = true;
+            enable_cleartext_plugin |= mysql_url_param_value_is_true(value);
+            continue;
+        }
+        if is_dbx_handled_mysql_url_param(key) {
+            changed = true;
+            continue;
+        }
+        if key.eq_ignore_ascii_case("ssl-mode") || key.eq_ignore_ascii_case("sslmode") {
+            changed = true;
+            match value.to_ascii_lowercase().replace('-', "_").as_str() {
+                "disabled" | "disable" => filtered.push("require_ssl=false".to_string()),
+                "preferred" | "prefer" => {
+                    filtered.push("require_ssl=true".to_string());
+                    filtered.push("verify_ca=false".to_string());
+                    filtered.push("verify_identity=false".to_string());
+                }
+                "required" | "require" => {
+                    filtered.push("require_ssl=true".to_string());
+                    filtered.push("verify_ca=false".to_string());
+                    filtered.push("verify_identity=false".to_string());
+                }
+                "verify_ca" => {
+                    filtered.push("require_ssl=true".to_string());
+                    filtered.push("verify_identity=false".to_string());
+                }
+                "verify_identity" => filtered.push("require_ssl=true".to_string()),
+                _ => {}
+            }
+            continue;
+        }
+        if is_jdbc_param(key) {
+            changed = true;
+            continue;
+        }
+        filtered.push(segment.to_string());
+    }
+    if enable_cleartext_plugin {
+        filtered.push("enable_cleartext_plugin=true".to_string());
+    }
+
+    // When a catalog is configured, the database in the URL path must not be
+    // sent as the schema during the MySQL handshake. Strip the path so mysql_async
+    // connects without a default schema; the database is selected via setup queries.
+    let base = if has_catalog { strip_mysql_url_path(base) } else { base };
+
+    if !changed && filtered.len() == original_count && !has_catalog {
+        Cow::Borrowed(url)
+    } else if filtered.is_empty() {
+        Cow::Owned(base.to_string())
+    } else {
+        Cow::Owned(format!("{base}?{}", filtered.join("&")))
+    }
+}
+
+pub async fn connect_bare(url: &str, fallback_timeout: Duration) -> Result<MySqlPool, String> {
+    connect_bare_with_pool_limit(url, fallback_timeout, 3).await
+}
+
+pub async fn connect_bare_with_pool_limit(
+    url: &str,
+    fallback_timeout: Duration,
+    max_connections: usize,
+) -> Result<MySqlPool, String> {
+    connect_bare_with_pool_limit_and_setup(url, fallback_timeout, max_connections, &[]).await
+}
+
+pub async fn connect_bare_with_pool_limit_and_setup(
+    url: &str,
+    fallback_timeout: Duration,
+    max_connections: usize,
+    extra_setup_queries: &[String],
+) -> Result<MySqlPool, String> {
+    connect_bare_with_pool_limit_and_setup_database(url, fallback_timeout, max_connections, None, extra_setup_queries)
+        .await
+}
+
+pub async fn connect_bare_with_pool_limit_and_setup_database(
+    url: &str,
+    fallback_timeout: Duration,
+    max_connections: usize,
+    setup_database: Option<&str>,
+    extra_setup_queries: &[String],
+) -> Result<MySqlPool, String> {
+    let timeout = super::parse_connect_timeout_with_fallback(url, fallback_timeout);
+    let pool =
+        create_pool(url, None, max_connections, None, setup_database, extra_setup_queries, MySqlSetupMode::Compatible)?;
+    verify_pool_connection(&pool, timeout).await.map(|_| pool)
+}
+
+pub async fn list_databases(pool: &MySqlPool) -> Result<Vec<DatabaseInfo>, String> {
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let result = match conn.query_iter("SELECT SCHEMA_NAME FROM information_schema.SCHEMATA ORDER BY SCHEMA_NAME").await
+    {
+        Ok(result) => result,
+        Err(err) => {
+            log::debug!("Falling back to SHOW DATABASES after information_schema.SCHEMATA failed: {err}");
+            return list_databases_show(pool).await;
+        }
+    };
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    let databases = database_infos_from_names(rows.iter().map(|row| get_str(row, 0)), false);
+
+    if databases.is_empty() {
+        log::debug!("Falling back to SHOW DATABASES after information_schema.SCHEMATA returned no named databases");
+        return list_databases_show(pool).await;
+    }
+
+    Ok(databases)
+}
+
+pub async fn list_databases_show(pool: &MySqlPool) -> Result<Vec<DatabaseInfo>, String> {
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let result = conn.query_iter("SHOW DATABASES").await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    Ok(database_infos_from_names(rows.iter().map(|row| get_str(row, 0)), true))
+}
+
+fn database_infos_from_names(
+    names: impl IntoIterator<Item = String>,
+    include_catalogless_when_blank: bool,
+) -> Vec<DatabaseInfo> {
+    let mut saw_row = false;
+    let mut databases: Vec<DatabaseInfo> = names
+        .into_iter()
+        .filter_map(|name| {
+            saw_row = true;
+            let name = name.trim().to_string();
+            (!name.is_empty()).then_some(DatabaseInfo { name })
+        })
+        .collect();
+    databases.sort_by(|a, b| a.name.cmp(&b.name));
+    if databases.is_empty() && saw_row && include_catalogless_when_blank {
+        return vec![DatabaseInfo { name: String::new() }];
+    }
+    databases
+}
+
+pub async fn list_tables(pool: &MySqlPool, database: &str) -> Result<Vec<TableInfo>, String> {
+    list_tables_filtered(pool, database, None, None, None, None).await
+}
+
+pub async fn list_tables_filtered(
+    pool: &MySqlPool,
+    database: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<&[String]>,
+) -> Result<Vec<TableInfo>, String> {
+    let sql = list_tables_sql(database, filter, limit, offset, object_types);
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let result = match conn.query_iter(&sql).await {
+        Ok(result) => result,
+        Err(err) => {
+            log::debug!(
+                "Falling back to SHOW TABLES for database `{database}` after information_schema.TABLES failed: {err}"
+            );
+            return list_tables_show(pool, database)
+                .await
+                .map(|tables| filter_list_tables_fallback(tables, filter, limit, offset, object_types));
+        }
+    };
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+
+    let tables: Vec<TableInfo> = rows
+        .iter()
+        .filter_map(|row| {
+            let name = get_str_by_name(row, "TABLE_NAME").trim().to_string();
+            (!name.is_empty()).then_some(TableInfo {
+                name,
+                table_type: get_str_by_name(row, "TABLE_TYPE"),
+                comment: get_opt_str(row, "TABLE_COMMENT")
+                    .map(|s| fix_potential_double_encoding(&s))
+                    .filter(|s| !s.is_empty()),
+                parent_schema: None,
+                parent_name: None,
+            })
+        })
+        .collect();
+
+    if tables.is_empty() && should_fallback_empty_list_tables(filter) {
+        log::debug!("Falling back to SHOW TABLES for database `{database}` after information_schema.TABLES returned no named tables");
+        return list_tables_show(pool, database)
+            .await
+            .map(|tables| filter_list_tables_fallback(tables, filter, limit, offset, object_types));
+    }
+
+    Ok(tables)
+}
+
+fn should_fallback_empty_list_tables(filter: Option<&str>) -> bool {
+    // MySQL proxies such as MyCat can return an empty information_schema.TABLES
+    // even when SHOW TABLES exposes objects. Avoid the fallback for active
+    // searches so normal MySQL "no match" queries do not rescan large schemas.
+    !filter.is_some_and(|filter| !filter.trim().is_empty())
+}
+
+fn filter_list_tables_fallback(
+    tables: Vec<TableInfo>,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<&[String]>,
+) -> Vec<TableInfo> {
+    let filter = filter.unwrap_or("").trim();
+    let normalized_object_types: Vec<String> = object_types
+        .unwrap_or(&[])
+        .iter()
+        .map(|object_type| object_type.to_ascii_uppercase().replace(' ', "_"))
+        .collect();
+    let wants_table =
+        normalized_object_types.is_empty() || normalized_object_types.iter().any(|object_type| object_type == "TABLE");
+    let wants_view =
+        normalized_object_types.is_empty() || normalized_object_types.iter().any(|object_type| object_type == "VIEW");
+
+    tables
+        .into_iter()
+        .filter(|table| {
+            crate::sql::contains_or_fuzzy_match(&table.name, filter)
+                || table.comment.as_deref().is_some_and(|comment| crate::sql::contains_or_fuzzy_match(comment, filter))
+        })
+        .filter(|table| if table.table_type.eq_ignore_ascii_case("VIEW") { wants_view } else { wants_table })
+        .skip(offset.unwrap_or(0))
+        .take(limit.unwrap_or(usize::MAX))
+        .collect()
+}
+
+fn list_tables_sql(
+    database: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<&[String]>,
+) -> String {
+    let mut sql = format!(
+        "SELECT TABLE_NAME, TABLE_TYPE, TABLE_COMMENT FROM information_schema.TABLES WHERE TABLE_SCHEMA = {}",
+        quote_value(database),
+    );
+    if let Some(object_types) = object_types.filter(|object_types| !object_types.is_empty()) {
+        let wants_table = object_types
+            .iter()
+            .map(|object_type| object_type.to_ascii_uppercase().replace(' ', "_"))
+            .any(|object_type| object_type == "TABLE");
+        let wants_view = object_types
+            .iter()
+            .map(|object_type| object_type.to_ascii_uppercase().replace(' ', "_"))
+            .any(|object_type| object_type == "VIEW");
+        match (wants_table, wants_view) {
+            (true, false) => sql.push_str(" AND TABLE_TYPE <> 'VIEW'"),
+            (false, true) => sql.push_str(" AND TABLE_TYPE = 'VIEW'"),
+            (false, false) => sql.push_str(" AND 1 = 0"),
+            (true, true) => {}
+        }
+    }
+    if let Some(filter) = filter.map(str::trim).filter(|filter| !filter.is_empty()) {
+        let escaped = filter.to_ascii_lowercase().replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_");
+        let pattern = format!("%{}%", escaped);
+        if crate::sql::fuzzy_filter_enabled(filter) {
+            let fuzzy_pattern = crate::sql::fuzzy_like_pattern_with_escape(&filter.to_ascii_lowercase(), |value| {
+                value.replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_")
+            });
+            sql.push_str(&format!(
+                " AND (LOWER(TABLE_NAME) LIKE {} ESCAPE '\\\\' OR LOWER(TABLE_COMMENT) LIKE {} ESCAPE '\\\\' OR LOWER(TABLE_NAME) LIKE {} ESCAPE '\\\\' OR LOWER(TABLE_COMMENT) LIKE {} ESCAPE '\\\\')",
+                quote_value(&pattern),
+                quote_value(&pattern),
+                quote_value(&fuzzy_pattern),
+                quote_value(&fuzzy_pattern)
+            ));
+        } else {
+            sql.push_str(&format!(
+                " AND (LOWER(TABLE_NAME) LIKE {} ESCAPE '\\\\' OR LOWER(TABLE_COMMENT) LIKE {} ESCAPE '\\\\')",
+                quote_value(&pattern),
+                quote_value(&pattern)
+            ));
+        }
+    }
+    sql.push_str(" ORDER BY TABLE_NAME");
+    if let Some(limit) = limit {
+        sql.push_str(&format!(" LIMIT {}", limit));
+    }
+    if let Some(offset) = offset.filter(|offset| *offset > 0) {
+        sql.push_str(&format!(" OFFSET {}", offset));
+    }
+    sql
+}
+
+pub async fn completion_assistant_search(
+    pool: &MySqlPool,
+    request: &CompletionAssistantRequest,
+) -> Result<CompletionAssistantResponse, String> {
+    let database = request.schema.as_deref().filter(|schema| !schema.trim().is_empty()).unwrap_or(&request.database);
+    let limit = request.max_results.unwrap_or(100).clamp(1, 1000);
+    let kinds = if request.object_kinds.is_empty() {
+        vec![CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View]
+    } else {
+        request.object_kinds.clone()
+    };
+    let pattern = mysql_completion_like_pattern(&request.mask, request.match_mode.as_ref());
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let mut candidates = Vec::new();
+
+    if kinds
+        .iter()
+        .any(|kind| matches!(kind, CompletionAssistantObjectKind::Database | CompletionAssistantObjectKind::Schema))
+    {
+        let sql = mysql_completion_schemas_sql(&pattern, limit.saturating_sub(candidates.len()));
+        let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+        let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+        for row in rows {
+            let schema_name = get_str_by_name(&row, "schema_name");
+            candidates.push(CompletionAssistantCandidate {
+                name: schema_name.clone(),
+                kind: CompletionAssistantCandidateKind::Schema,
+                database: Some(schema_name.clone()),
+                schema: Some(schema_name),
+                parent_schema: None,
+                parent_name: None,
+                comment: None,
+                data_type: None,
+            });
+        }
+    }
+
+    if candidates.len() < limit && kinds.iter().any(CompletionAssistantObjectKind::is_table_like) {
+        let sql = mysql_completion_tables_sql(database, &pattern, &kinds, limit.saturating_sub(candidates.len()));
+        let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+        let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+        for row in rows {
+            let table_type = get_str_by_name(&row, "table_type");
+            candidates.push(CompletionAssistantCandidate {
+                name: get_str_by_name(&row, "object_name"),
+                kind: if table_type.eq_ignore_ascii_case("VIEW") {
+                    CompletionAssistantCandidateKind::View
+                } else {
+                    CompletionAssistantCandidateKind::Table
+                },
+                database: Some(database.to_string()),
+                schema: Some(database.to_string()),
+                parent_schema: None,
+                parent_name: None,
+                comment: get_opt_str(&row, "object_comment")
+                    .map(|s| fix_potential_double_encoding(&s))
+                    .filter(|s| !s.is_empty()),
+                data_type: None,
+            });
+        }
+    }
+
+    if candidates.len() < limit && kinds.iter().any(CompletionAssistantObjectKind::is_routine_like) {
+        let sql = mysql_completion_routines_sql(database, &pattern, &kinds, limit.saturating_sub(candidates.len()));
+        let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+        let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+        for row in rows {
+            let routine_type = get_str_by_name(&row, "routine_type");
+            candidates.push(CompletionAssistantCandidate {
+                name: get_str_by_name(&row, "object_name"),
+                kind: if routine_type.eq_ignore_ascii_case("PROCEDURE") {
+                    CompletionAssistantCandidateKind::Procedure
+                } else {
+                    CompletionAssistantCandidateKind::Function
+                },
+                database: Some(database.to_string()),
+                schema: Some(database.to_string()),
+                parent_schema: None,
+                parent_name: None,
+                comment: get_opt_str(&row, "object_comment")
+                    .map(|s| fix_potential_double_encoding(&s))
+                    .filter(|s| !s.is_empty()),
+                data_type: get_opt_str(&row, "data_type"),
+            });
+        }
+    }
+
+    if candidates.len() < limit && kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Column)) {
+        if let Some(table) = request.parent_name.as_deref().filter(|table| !table.trim().is_empty()) {
+            let sql = mysql_completion_columns_sql(database, table, &pattern, limit.saturating_sub(candidates.len()));
+            let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+            let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+            for row in rows {
+                candidates.push(CompletionAssistantCandidate {
+                    name: get_str_by_name(&row, "object_name"),
+                    kind: CompletionAssistantCandidateKind::Column,
+                    database: Some(database.to_string()),
+                    schema: Some(database.to_string()),
+                    parent_schema: Some(database.to_string()),
+                    parent_name: Some(table.to_string()),
+                    comment: get_opt_str(&row, "object_comment")
+                        .map(|s| fix_potential_double_encoding(&s))
+                        .filter(|s| !s.is_empty()),
+                    data_type: Some(get_str_by_name(&row, "data_type")),
+                });
+            }
+        }
+    }
+
+    Ok(CompletionAssistantResponse { incomplete: candidates.len() >= limit, candidates, fallback_used: false })
+}
+
+fn mysql_completion_schemas_sql(pattern: &str, limit: usize) -> String {
+    format!(
+        "SELECT SCHEMA_NAME AS schema_name \
+         FROM information_schema.SCHEMATA \
+         WHERE SCHEMA_NAME LIKE {} ESCAPE '\\\\' \
+         ORDER BY SCHEMA_NAME LIMIT {}",
+        quote_value(pattern),
+        limit,
+    )
+}
+
+fn mysql_completion_tables_sql(
+    database: &str,
+    pattern: &str,
+    kinds: &[CompletionAssistantObjectKind],
+    limit: usize,
+) -> String {
+    let table_types = mysql_completion_table_types(kinds);
+    format!(
+        "SELECT TABLE_NAME AS object_name, TABLE_TYPE AS table_type, TABLE_COMMENT AS object_comment \
+         FROM information_schema.TABLES \
+         WHERE TABLE_SCHEMA = {db} AND TABLE_NAME LIKE {pattern} ESCAPE '\\\\' AND TABLE_TYPE IN ({table_types}) \
+         ORDER BY TABLE_NAME LIMIT {limit}",
+        db = quote_value(database),
+        pattern = quote_value(pattern),
+        table_types = table_types,
+        limit = limit,
+    )
+}
+
+fn mysql_completion_routines_sql(
+    database: &str,
+    pattern: &str,
+    kinds: &[CompletionAssistantObjectKind],
+    limit: usize,
+) -> String {
+    let routine_types = mysql_completion_routine_types(kinds);
+    format!(
+        "SELECT ROUTINE_NAME AS object_name, ROUTINE_TYPE AS routine_type, ROUTINE_COMMENT AS object_comment, DATA_TYPE AS data_type \
+         FROM information_schema.ROUTINES \
+         WHERE ROUTINE_SCHEMA = {db} AND ROUTINE_NAME LIKE {pattern} ESCAPE '\\\\' AND ROUTINE_TYPE IN ({routine_types}) \
+         ORDER BY ROUTINE_NAME LIMIT {limit}",
+        db = quote_value(database),
+        pattern = quote_value(pattern),
+        routine_types = routine_types,
+        limit = limit,
+    )
+}
+
+fn mysql_completion_columns_sql(database: &str, table: &str, pattern: &str, limit: usize) -> String {
+    format!(
+        "SELECT COLUMN_NAME AS object_name, COLUMN_TYPE AS data_type, COLUMN_COMMENT AS object_comment \
+         FROM information_schema.COLUMNS \
+         WHERE TABLE_SCHEMA = {db} AND TABLE_NAME = {table} AND COLUMN_NAME LIKE {pattern} ESCAPE '\\\\' \
+         ORDER BY ORDINAL_POSITION LIMIT {limit}",
+        db = quote_value(database),
+        table = quote_value(table),
+        pattern = quote_value(pattern),
+        limit = limit,
+    )
+}
+
+fn mysql_completion_table_types(kinds: &[CompletionAssistantObjectKind]) -> String {
+    let mut types = Vec::new();
+    if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Table)) {
+        types.push("'BASE TABLE'");
+        types.push("'SYSTEM VERSIONED'");
+    }
+    if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::View)) {
+        types.push("'VIEW'");
+    }
+    if types.is_empty() {
+        "'BASE TABLE','VIEW'".to_string()
+    } else {
+        types.join(",")
+    }
+}
+
+fn mysql_completion_routine_types(kinds: &[CompletionAssistantObjectKind]) -> String {
+    let mut types = Vec::new();
+    if kinds
+        .iter()
+        .any(|kind| matches!(kind, CompletionAssistantObjectKind::Procedure | CompletionAssistantObjectKind::Routine))
+    {
+        types.push("'PROCEDURE'");
+    }
+    if kinds
+        .iter()
+        .any(|kind| matches!(kind, CompletionAssistantObjectKind::Function | CompletionAssistantObjectKind::Routine))
+    {
+        types.push("'FUNCTION'");
+    }
+    if types.is_empty() {
+        "'PROCEDURE','FUNCTION'".to_string()
+    } else {
+        types.join(",")
+    }
+}
+
+fn mysql_completion_like_pattern(value: &str, mode: Option<&CompletionAssistantMatchMode>) -> String {
+    if value.trim().is_empty() || value == "%" {
+        return "%".to_string();
+    }
+    let escaped = value.trim().replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_");
+    match mode.unwrap_or(&CompletionAssistantMatchMode::Prefix) {
+        CompletionAssistantMatchMode::Prefix => format!("{escaped}%"),
+        CompletionAssistantMatchMode::Contains => format!("%{escaped}%"),
+    }
+}
+
+fn table_comment_sql(database: &str, table: &str) -> String {
+    format!(
+        "SELECT TABLE_COMMENT \
+         FROM information_schema.TABLES \
+         WHERE TABLE_SCHEMA = {} AND TABLE_NAME = {} AND TABLE_TYPE <> 'VIEW' \
+         LIMIT 1",
+        quote_value(database),
+        quote_value(table),
+    )
+}
+
+pub async fn get_table_comment(pool: &MySqlPool, database: &str, table: &str) -> Result<Option<String>, String> {
+    let sql = table_comment_sql(database, table);
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .first()
+        .and_then(|row| get_opt_str(row, "TABLE_COMMENT"))
+        .map(|s| fix_potential_double_encoding(&s))
+        .filter(|s| !s.is_empty()))
+}
+
+#[derive(Clone, Debug, Default)]
+struct TableStatusMeta {
+    comment: Option<String>,
+    created_at: Option<String>,
+    updated_at: Option<String>,
+}
+
+async fn list_table_status_show(pool: &MySqlPool, database: &str) -> Result<HashMap<String, TableStatusMeta>, String> {
+    let sql = if database.trim().is_empty() {
+        "SHOW TABLE STATUS".to_string()
+    } else {
+        format!("SHOW TABLE STATUS FROM {}", quote_identifier(database))
+    };
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .map(|row| {
+            (
+                get_str_by_name(row, "Name"),
+                TableStatusMeta {
+                    comment: get_opt_metadata_string(row, "Comment")
+                        .map(|s| fix_potential_double_encoding(&s))
+                        .filter(|s| !s.is_empty()),
+                    created_at: get_opt_metadata_string(row, "Create_time"),
+                    updated_at: get_opt_metadata_string(row, "Update_time"),
+                },
+            )
+        })
+        .filter(|(name, _)| !name.is_empty())
+        .collect())
+}
+
+async fn list_table_names_show(pool: &MySqlPool, database: &str) -> Result<Vec<TableInfo>, String> {
+    let sql = show_tables_sql(database, true);
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let rows: Vec<mysql_async::Row> = match conn.query_iter(&sql).await {
+        Ok(result) => result.collect_and_drop().await.map_err(|e| e.to_string())?,
+        Err(_) => {
+            let sql = show_tables_sql(database, false);
+            let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+            result.collect_and_drop().await.map_err(|e| e.to_string())?
+        }
+    };
+    let mut tables: Vec<TableInfo> = rows
+        .iter()
+        .filter_map(|row| {
+            let name = get_str(row, 0).trim().to_string();
+            if name.is_empty() {
+                return None;
+            }
+            let table_type = get_str(row, 1);
+            Some(TableInfo {
+                name,
+                table_type: if table_type.is_empty() { "TABLE".to_string() } else { table_type },
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            })
+        })
+        .collect();
+    tables.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(tables)
+}
+
+fn show_tables_sql(database: &str, full: bool) -> String {
+    let prefix = if full { "SHOW FULL TABLES" } else { "SHOW TABLES" };
+    if database.trim().is_empty() {
+        prefix.to_string()
+    } else {
+        format!("{prefix} FROM {}", quote_identifier(database))
+    }
+}
+
+async fn list_tables_show_with_status(
+    pool: &MySqlPool,
+    database: &str,
+) -> Result<(Vec<TableInfo>, HashMap<String, TableStatusMeta>), String> {
+    let (tables, status) = tokio::join!(list_table_names_show(pool, database), list_table_status_show(pool, database));
+    let mut tables = tables?;
+    let status = match status {
+        Ok(status) => status,
+        Err(err) => {
+            log::warn!("Skipping table status for database `{}`: {}", database, err);
+            HashMap::new()
+        }
+    };
+    for table in &mut tables {
+        if let Some(meta) = status.get(&table.name) {
+            table.comment = meta.comment.clone();
+        }
+    }
+    Ok((tables, status))
+}
+
+pub async fn list_tables_show(pool: &MySqlPool, database: &str) -> Result<Vec<TableInfo>, String> {
+    list_tables_show_with_status(pool, database).await.map(|(tables, _)| tables)
+}
+
+fn requested_object_type(object_types: Option<&[String]>, object_type: &str) -> bool {
+    object_types.is_none_or(|types| {
+        types.is_empty() || types.iter().any(|candidate| candidate.eq_ignore_ascii_case(object_type))
+    })
+}
+
+fn sql_pagination(limit: Option<usize>, offset: Option<usize>) -> String {
+    limit.map_or_else(String::new, |limit| format!(" LIMIT {limit} OFFSET {}", offset.unwrap_or(0)))
+}
+
+fn list_tables_objects_sql(
+    database: &str,
+    object_types: Option<&[String]>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+) -> String {
+    let wants_tables = requested_object_type(object_types, "TABLE");
+    let wants_views = requested_object_type(object_types, "VIEW");
+    let type_filter = match (wants_tables, wants_views) {
+        (true, false) => " AND TABLE_TYPE <> 'VIEW'",
+        (false, true) => " AND TABLE_TYPE = 'VIEW'",
+        _ => "",
+    };
+    format!(
+        "SELECT TABLE_NAME AS object_name, \
+           CASE WHEN TABLE_TYPE = 'VIEW' THEN 'VIEW' ELSE 'TABLE' END AS object_type, \
+           TABLE_COMMENT AS object_comment, \
+           CREATE_TIME AS created_at, \
+           UPDATE_TIME AS updated_at, \
+           NULL AS parent_schema, NULL AS parent_name, \
+           CASE WHEN TABLE_TYPE = 'VIEW' THEN 1 ELSE 0 END AS sort_order \
+         FROM information_schema.TABLES \
+         WHERE TABLE_SCHEMA = {db}{type_filter} \
+         ORDER BY sort_order, object_name{pagination}",
+        db = quote_value(database),
+        pagination = sql_pagination(limit, offset),
+    )
+}
+
+fn list_routines_sql(
+    database: &str,
+    object_types: Option<&[String]>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+) -> String {
+    let routine_types = [
+        ("PROCEDURE", requested_object_type(object_types, "PROCEDURE")),
+        ("FUNCTION", requested_object_type(object_types, "FUNCTION")),
+    ]
+    .into_iter()
+    .filter_map(|(routine_type, requested)| requested.then_some(format!("'{}'", routine_type)))
+    .collect::<Vec<_>>()
+    .join(", ");
+    format!(
+        "SELECT ROUTINE_NAME AS object_name, ROUTINE_TYPE AS object_type, NULL AS object_comment, \
+           NULL AS created_at, NULL AS updated_at, \
+           NULL AS parent_schema, NULL AS parent_name, \
+           CASE WHEN ROUTINE_TYPE = 'PROCEDURE' THEN 2 ELSE 3 END AS sort_order \
+         FROM information_schema.ROUTINES \
+         WHERE ROUTINE_SCHEMA = {db} AND ROUTINE_TYPE IN ({routine_types}) \
+         ORDER BY sort_order, object_name{pagination}",
+        db = quote_value(database),
+        pagination = sql_pagination(limit, offset),
+    )
+}
+
+fn list_completion_triggers_sql(database: &str) -> String {
+    format!(
+        "SELECT TRIGGER_NAME AS object_name, 'TRIGGER' AS object_type, NULL AS object_comment, \
+           CREATED AS created_at, NULL AS updated_at, \
+           TRIGGER_SCHEMA AS parent_schema, EVENT_OBJECT_TABLE AS parent_name, \
+           4 AS sort_order \
+         FROM information_schema.TRIGGERS \
+         WHERE TRIGGER_SCHEMA = {db} \
+         ORDER BY object_name",
+        db = quote_value(database),
+    )
+}
+
+fn row_to_object(row: &mysql_async::Row, database: &str) -> ObjectInfo {
+    ObjectInfo {
+        name: get_str_by_name(row, "object_name"),
+        object_type: get_str_by_name(row, "object_type"),
+        schema: Some(database.to_string()),
+        signature: None,
+        comment: get_opt_str(row, "object_comment")
+            .map(|s| fix_potential_double_encoding(&s))
+            .filter(|s| !s.is_empty()),
+        created_at: get_opt_str(row, "created_at"),
+        updated_at: get_opt_str(row, "updated_at"),
+        parent_schema: get_opt_str(row, "parent_schema"),
+        parent_name: get_opt_str(row, "parent_name"),
+    }
+}
+
+pub struct PagedObjectList {
+    pub objects: Vec<ObjectInfo>,
+    pub paging_applied: bool,
+}
+
+fn object_query_supports_paging(object_types: Option<&[String]>) -> bool {
+    let Some(object_types) = object_types.filter(|types| !types.is_empty()) else {
+        return false;
+    };
+    let uses_table_source = object_types
+        .iter()
+        .any(|object_type| object_type.eq_ignore_ascii_case("TABLE") || object_type.eq_ignore_ascii_case("VIEW"));
+    let uses_routine_source = object_types.iter().any(|object_type| {
+        object_type.eq_ignore_ascii_case("PROCEDURE") || object_type.eq_ignore_ascii_case("FUNCTION")
+    });
+    let all_types_supported = object_types.iter().all(|object_type| {
+        object_type.eq_ignore_ascii_case("TABLE")
+            || object_type.eq_ignore_ascii_case("VIEW")
+            || object_type.eq_ignore_ascii_case("PROCEDURE")
+            || object_type.eq_ignore_ascii_case("FUNCTION")
+    });
+    all_types_supported && uses_table_source != uses_routine_source
+}
+
+pub async fn list_objects(
+    pool: &MySqlPool,
+    database: &str,
+    object_types: Option<&[String]>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+) -> Result<PagedObjectList, String> {
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let wants_tables = requested_object_type(object_types, "TABLE") || requested_object_type(object_types, "VIEW");
+    let wants_routines =
+        requested_object_type(object_types, "PROCEDURE") || requested_object_type(object_types, "FUNCTION");
+    let paging_applied = limit.is_some() && object_query_supports_paging(object_types);
+    let (query_limit, query_offset) = if paging_applied { (limit, offset) } else { (None, None) };
+    let mut objects = Vec::new();
+
+    if wants_tables {
+        let tables_sql = list_tables_objects_sql(database, object_types, query_limit, query_offset);
+        let result = match conn.query_iter(&tables_sql).await {
+            Ok(result) => result,
+            Err(err) => {
+                log::debug!(
+                    "Falling back to SHOW TABLES for object browser database `{database}` after information_schema.TABLES failed: {err}"
+                );
+                return list_table_objects_show(pool, database)
+                    .await
+                    .map(|objects| PagedObjectList { objects, paging_applied: false });
+            }
+        };
+        let table_rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+        if table_rows.is_empty() && !wants_routines {
+            log::debug!(
+                "Falling back to SHOW TABLES for object browser database `{database}` after information_schema.TABLES returned no named tables"
+            );
+            return list_table_objects_show(pool, database)
+                .await
+                .map(|objects| PagedObjectList { objects, paging_applied: false });
+        }
+        objects.extend(table_rows.iter().map(|row| row_to_object(row, database)));
+    }
+
+    // Routines are queried separately: some MySQL-compatible servers (sharding proxies,
+    // OceanBase/TiDB variants, restricted accounts) reject information_schema.ROUTINES with
+    // ER_UNKNOWN_ERROR (1105). Degrading gracefully keeps tables/views usable.
+    if wants_routines {
+        let routines_sql = list_routines_sql(database, object_types, query_limit, query_offset);
+        match conn.query_iter(&routines_sql).await {
+            Ok(result) => match result.collect_and_drop::<mysql_async::Row>().await {
+                Ok(routine_rows) => {
+                    objects.extend(routine_rows.iter().map(|row| row_to_object(row, database)));
+                }
+                Err(e) => {
+                    log::warn!("Skipping routines for database `{}` in object browser: {}", database, e);
+                }
+            },
+            Err(e) => {
+                log::warn!("Skipping routines for database `{}` in object browser: {}", database, e);
+            }
+        }
+    }
+
+    Ok(PagedObjectList { objects, paging_applied })
+}
+
+pub async fn list_object_statistics(pool: &MySqlPool, database: &str) -> Result<Vec<ObjectStatistics>, String> {
+    let sql = format!(
+        "SELECT TABLE_NAME, TABLE_ROWS, COALESCE(DATA_LENGTH, 0) + COALESCE(INDEX_LENGTH, 0) AS TOTAL_BYTES \
+         FROM information_schema.TABLES \
+         WHERE TABLE_SCHEMA = {} AND TABLE_TYPE <> 'VIEW' \
+         ORDER BY TABLE_NAME",
+        quote_value(database),
+    );
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .filter_map(|row| {
+            let name = get_str_by_name(row, "TABLE_NAME").trim().to_string();
+            (!name.is_empty()).then_some(ObjectStatistics {
+                name,
+                schema: Some(database.to_string()),
+                estimated_rows: get_opt_i64(row, "TABLE_ROWS"),
+                total_bytes: get_opt_i64(row, "TOTAL_BYTES"),
+            })
+        })
+        .collect())
+}
+
+pub async fn list_table_objects_show(pool: &MySqlPool, database: &str) -> Result<Vec<ObjectInfo>, String> {
+    let (tables, routines) =
+        tokio::join!(list_tables_show_with_status(pool, database), list_routine_objects(pool, database));
+    let (tables, status) = tables?;
+    let mut objects: Vec<ObjectInfo> = tables
+        .into_iter()
+        .map(|table| {
+            let meta = status.get(&table.name);
+            ObjectInfo {
+                name: table.name,
+                object_type: if table.table_type.eq_ignore_ascii_case("VIEW") { "VIEW" } else { "TABLE" }.to_string(),
+                schema: Some(database.to_string()),
+                signature: None,
+                comment: table.comment,
+                created_at: meta.and_then(|meta| meta.created_at.clone()),
+                updated_at: meta.and_then(|meta| meta.updated_at.clone()),
+                parent_schema: table.parent_schema,
+                parent_name: table.parent_name,
+            }
+        })
+        .collect();
+
+    match routines {
+        Ok(routines) => objects.extend(routines),
+        Err(err) => log::warn!("Skipping routines for database `{}` in object browser: {}", database, err),
+    }
+
+    Ok(objects)
+}
+
+async fn list_routine_objects(pool: &MySqlPool, database: &str) -> Result<Vec<ObjectInfo>, String> {
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let routines_sql = list_routines_sql(database, None, None, None);
+    let result = conn.query_iter(&routines_sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    Ok(rows.iter().map(|row| row_to_object(row, database)).collect())
+}
+
+pub async fn list_completion_objects(pool: &MySqlPool, database: &str) -> Result<Vec<ObjectInfo>, String> {
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let mut objects = Vec::new();
+
+    let routines_sql = list_routines_sql(database, None, None, None);
+    match conn.query_iter(&routines_sql).await {
+        Ok(result) => match result.collect_and_drop::<mysql_async::Row>().await {
+            Ok(rows) => objects.extend(rows.iter().map(|row| row_to_object(row, database))),
+            Err(e) => log::warn!("Skipping routines for completion in database `{}`: {}", database, e),
+        },
+        Err(e) => log::warn!("Skipping routines for completion in database `{}`: {}", database, e),
+    }
+
+    let triggers_sql = list_completion_triggers_sql(database);
+    match conn.query_iter(&triggers_sql).await {
+        Ok(result) => match result.collect_and_drop::<mysql_async::Row>().await {
+            Ok(rows) => objects.extend(rows.iter().map(|row| row_to_object(row, database))),
+            Err(e) => log::warn!("Skipping triggers for completion in database `{}`: {}", database, e),
+        },
+        Err(e) => log::warn!("Skipping triggers for completion in database `{}`: {}", database, e),
+    }
+
+    Ok(objects)
+}
+
+fn columns_sql(database: &str, table: &str) -> String {
+    format!(
+        "SELECT c.COLUMN_NAME, c.DATA_TYPE, c.COLUMN_TYPE, c.IS_NULLABLE, c.COLUMN_DEFAULT, c.EXTRA, \
+         c.COLUMN_COMMENT, c.COLUMN_KEY, c.NUMERIC_PRECISION, c.NUMERIC_SCALE, c.CHARACTER_MAXIMUM_LENGTH, \
+         c.CHARACTER_SET_NAME, c.COLLATION_NAME \
+         FROM information_schema.COLUMNS c \
+         WHERE c.TABLE_SCHEMA = {} AND c.TABLE_NAME = {} \
+         ORDER BY c.ORDINAL_POSITION",
+        quote_value(database),
+        quote_value(table),
+    )
+}
+
+/// Attempt to reverse CP1252→UTF-8 double-encoding.
+///
+/// When Chinese text is written to MySQL through a connection with the wrong
+/// charset (e.g. latin1/CP1252), each byte of the correct UTF-8 representation
+/// is stored as a separate CP1252 character, then re-encoded as UTF-8 on read.
+///
+/// Example: "主键" → UTF-8 bytes [E4 B8 BB E9 94 AE]
+///   → each byte → CP1252 char → UTF-8 re-encoded → garbled text
+///   → reversal: map each char back to its CP1252 byte, decode as UTF-8
+fn fix_potential_double_encoding(s: &str) -> String {
+    // Map each character to its CP1252 byte value
+    let mut bytes = Vec::with_capacity(s.len());
+    for c in s.chars() {
+        let byte = match c as u32 {
+            // Characters in CP1252 that differ from Latin-1 (0x80-0x9F range)
+            0x20AC => 0x80, // €
+            0x201A => 0x82, // ‚
+            0x0192 => 0x83, // ƒ
+            0x201E => 0x84, // „
+            0x2026 => 0x85, // …
+            0x2020 => 0x86, // †
+            0x2021 => 0x87, // ‡
+            0x02C6 => 0x88, // ˆ
+            0x2030 => 0x89, // ‰
+            0x0160 => 0x8A, // Š
+            0x2039 => 0x8B, // ‹
+            0x0152 => 0x8C, // Œ
+            0x017D => 0x8E, // Ž
+            0x2018 => 0x91, // '
+            0x2019 => 0x92, // '
+            0x201C => 0x93, // " left double quotation mark
+            0x201D => 0x94, // " right double quotation mark
+            0x2022 => 0x95, // •
+            0x2013 => 0x96, // –
+            0x2014 => 0x97, // —
+            0x02DC => 0x98, // ˜
+            0x2122 => 0x99, // ™
+            0x0161 => 0x9A, // š
+            0x203A => 0x9B, // ›
+            0x0153 => 0x9C, // œ
+            0x017E => 0x9E, // ž
+            0x0178 => 0x9F, // Ÿ
+            v if v <= 0xFF => v as u8,
+            _ => return s.to_string(), // contains non-Latin1 char, skip
+        };
+        bytes.push(byte);
+    }
+
+    // Try decoding the bytes as UTF-8
+    match String::from_utf8(bytes) {
+        Ok(decoded) => {
+            // Only use the decoded version if it actually contains
+            // multi-byte UTF-8 characters (CJK, etc. > U+00FF),
+            // confirming the reversal was successful
+            if decoded.chars().any(|c| c > '\u{00FF}') {
+                decoded
+            } else {
+                s.to_string()
+            }
+        }
+        Err(_) => s.to_string(),
+    }
+}
+
+fn parse_mysql_enum_values(column_type: &str) -> Option<Vec<String>> {
+    let trimmed = column_type.trim();
+    if !trimmed.get(..5)?.eq_ignore_ascii_case("enum(") || !trimmed.ends_with(')') {
+        return None;
+    }
+
+    let inner = &trimmed[5..trimmed.len() - 1];
+    let mut chars = inner.chars().peekable();
+    let mut values = Vec::new();
+
+    loop {
+        while matches!(chars.peek(), Some(c) if c.is_whitespace()) {
+            chars.next();
+        }
+        match chars.next() {
+            Some('\'') => {}
+            None if values.is_empty() => return Some(values),
+            _ => return None,
+        }
+
+        let mut value = String::new();
+        loop {
+            match chars.next() {
+                Some('\'') => {
+                    if matches!(chars.peek(), Some('\'')) {
+                        chars.next();
+                        value.push('\'');
+                    } else {
+                        break;
+                    }
+                }
+                Some('\\') => match chars.next() {
+                    Some('0') => value.push('\0'),
+                    Some('b') => value.push('\u{0008}'),
+                    Some('n') => value.push('\n'),
+                    Some('r') => value.push('\r'),
+                    Some('t') => value.push('\t'),
+                    Some('Z') => value.push('\u{001A}'),
+                    Some(c @ ('\\' | '\'' | '"')) => value.push(c),
+                    Some(c) => value.push(c),
+                    None => return None,
+                },
+                Some(c) => value.push(c),
+                None => return None,
+            }
+        }
+        values.push(value);
+
+        while matches!(chars.peek(), Some(c) if c.is_whitespace()) {
+            chars.next();
+        }
+        match chars.next() {
+            Some(',') => continue,
+            None => return Some(values),
+            _ => return None,
+        }
+    }
+}
+
+pub async fn get_columns(pool: &MySqlPool, database: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let sql = columns_sql(database, table);
+    let mut conn = get_conn_with_health_check(pool).await?;
+    let result = match conn.query_iter(&sql).await {
+        Ok(result) => result,
+        Err(err) => {
+            log::debug!(
+                "Falling back to SHOW COLUMNS for `{database}`.`{table}` after information_schema.COLUMNS failed: {err}"
+            );
+            return get_columns_show(pool, database, table).await;
+        }
+    };
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+
+    let columns: Vec<ColumnInfo> = rows
+        .iter()
+        .filter_map(|row| {
+            let name = get_str_by_name(row, "COLUMN_NAME").trim().to_string();
+            if name.is_empty() {
+                return None;
+            }
+            let column_key = get_str_by_name(row, "COLUMN_KEY");
+            let data_type = get_str_by_name(row, "DATA_TYPE");
+            let column_type = get_str_by_name(row, "COLUMN_TYPE");
+            let enum_values = if data_type.eq_ignore_ascii_case("enum") {
+                // MySQL exposes enum literals only through COLUMN_TYPE. Parse the SQL literal
+                // syntax in Rust so empty values, quotes, and backslash escapes survive intact.
+                parse_mysql_enum_values(&column_type)
+            } else {
+                None
+            };
+            Some(ColumnInfo {
+                is_primary_key: column_key.eq_ignore_ascii_case("PRI"),
+                name,
+                data_type: column_type,
+                is_nullable: get_str_by_name(row, "IS_NULLABLE") == "YES",
+                column_default: get_opt_str(row, "COLUMN_DEFAULT"),
+                extra: get_opt_str(row, "EXTRA"),
+                comment: get_opt_str(row, "COLUMN_COMMENT")
+                    .map(|s| fix_potential_double_encoding(&s))
+                    .filter(|s| !s.is_empty()),
+                numeric_precision: get_opt_i32(row, "NUMERIC_PRECISION"),
+                numeric_scale: get_opt_i32(row, "NUMERIC_SCALE"),
+                character_maximum_length: get_opt_i32(row, "CHARACTER_MAXIMUM_LENGTH"),
+                enum_values,
+                character_set: get_opt_str(row, "CHARACTER_SET_NAME").filter(|s| !s.is_empty()),
+                collation: get_opt_str(row, "COLLATION_NAME").filter(|s| !s.is_empty()),
+            })
+        })
+        .collect();
+
+    if columns.is_empty() {
+        log::debug!(
+            "Falling back to SHOW COLUMNS for `{database}`.`{table}` after information_schema.COLUMNS returned no named columns"
+        );
+        return get_columns_show(pool, database, table).await;
+    }
+
+    Ok(columns)
+}
+
+pub async fn get_columns_show(pool: &MySqlPool, database: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let sql = show_columns_sql(database, table, true);
+    let mut conn = get_conn_with_health_check(pool).await?;
+    let rows: Vec<mysql_async::Row> = match conn.query_iter(&sql).await {
+        Ok(result) => result.collect_and_drop().await.map_err(|e| e.to_string())?,
+        Err(_) => {
+            let sql = show_columns_sql(database, table, false);
+            let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+            result.collect_and_drop().await.map_err(|e| e.to_string())?
+        }
+    };
+    Ok(rows
+        .iter()
+        .filter_map(|row| {
+            let name = get_str_by_name(row, "Field").trim().to_string();
+            if name.is_empty() {
+                return None;
+            }
+            let key = get_str_by_name(row, "Key");
+            let collation = get_opt_str(row, "Collation").filter(|s| !s.is_empty());
+            Some(ColumnInfo {
+                name,
+                data_type: get_str_by_name(row, "Type"),
+                is_nullable: get_str_by_name(row, "Null").eq_ignore_ascii_case("YES"),
+                column_default: get_opt_str(row, "Default"),
+                is_primary_key: key.eq_ignore_ascii_case("PRI"),
+                extra: get_opt_str(row, "Extra"),
+                comment: get_opt_str(row, "Comment")
+                    .map(|s| fix_potential_double_encoding(&s))
+                    .filter(|s| !s.is_empty()),
+                numeric_precision: None,
+                numeric_scale: None,
+                character_maximum_length: None,
+                enum_values: None,
+                character_set: collation
+                    .as_deref()
+                    .and_then(|c| c.split_once('_').map(|(charset, _)| charset.to_string()))
+                    .filter(|s| !s.is_empty()),
+                collation,
+            })
+        })
+        .collect())
+}
+
+fn show_columns_sql(database: &str, table: &str, full: bool) -> String {
+    let prefix = if full { "SHOW FULL COLUMNS FROM" } else { "SHOW COLUMNS FROM" };
+    if database.trim().is_empty() {
+        format!("{prefix} {}", quote_identifier(table))
+    } else {
+        format!("{prefix} {}.{}", quote_identifier(database), quote_identifier(table))
+    }
+}
+
+fn query_result_row_limit(max_rows: Option<usize>) -> usize {
+    max_rows.unwrap_or(crate::query::MAX_ROWS).max(1)
+}
+
+fn should_collect_text_result_set(sql: &str, row_limit: usize, max_rows: Option<usize>) -> bool {
+    max_rows.is_some_and(|_| mysql_top_level_limit(sql).is_some_and(|limit| limit <= row_limit))
+}
+
+fn mysql_top_level_limit(sql: &str) -> Option<usize> {
+    let sql = sql.trim().trim_end_matches(';');
+    let bytes = sql.as_bytes();
+    let mut depth = 0usize;
+    let mut i = 0;
+
+    while i < bytes.len() {
+        i = skip_sql_whitespace_and_comments(bytes, i);
+        if i >= bytes.len() {
+            break;
+        }
+
+        let ch = bytes[i];
+        if matches!(ch, b'\'' | b'"' | b'`') {
+            i = skip_mysql_quoted(sql, i, ch);
+            continue;
+        }
+        if ch == b'(' {
+            depth += 1;
+            i += 1;
+            continue;
+        }
+        if ch == b')' {
+            depth = depth.saturating_sub(1);
+            i += 1;
+            continue;
+        }
+        if depth == 0 && mysql_keyword_at(sql, i, "LIMIT") {
+            return parse_mysql_limit_value(sql, i + "LIMIT".len());
+        }
+        // Move to next byte, but ensure we stay on a UTF-8 boundary
+        i += 1;
+        while i < bytes.len() && !sql.is_char_boundary(i) {
+            i += 1;
+        }
+    }
+
+    None
+}
+
+fn parse_mysql_limit_value(sql: &str, start: usize) -> Option<usize> {
+    let bytes = sql.as_bytes();
+    let mut i = skip_sql_whitespace_and_comments(bytes, start);
+    let first = parse_usize_token(sql, &mut i)?;
+    i = skip_sql_whitespace_and_comments(bytes, i);
+
+    if i < bytes.len() && bytes[i] == b',' {
+        i = skip_sql_whitespace_and_comments(bytes, i + 1);
+        return parse_usize_token(sql, &mut i);
+    }
+
+    Some(first)
+}
+
+fn parse_usize_token(sql: &str, i: &mut usize) -> Option<usize> {
+    let bytes = sql.as_bytes();
+    let start = *i;
+    while *i < bytes.len() && bytes[*i].is_ascii_digit() {
+        *i += 1;
+    }
+    if *i == start {
+        return None;
+    }
+    // Ensure the slice is valid UTF-8 before parsing
+    std::str::from_utf8(&bytes[start..*i]).ok()?.parse().ok()
+}
+
+fn mysql_keyword_at(sql: &str, i: usize, keyword: &str) -> bool {
+    let end = i + keyword.len();
+    if end > sql.len() {
+        return false;
+    }
+    // Ensure indices are on UTF-8 boundaries before slicing
+    if !sql.is_char_boundary(i) || !sql.is_char_boundary(end) {
+        return false;
+    }
+    sql[i..end].eq_ignore_ascii_case(keyword)
+        && (i == 0 || !is_mysql_identifier_byte(sql.as_bytes()[i - 1]))
+        && (end == sql.len() || !is_mysql_identifier_byte(sql.as_bytes()[end]))
+}
+
+fn is_mysql_identifier_byte(byte: u8) -> bool {
+    byte.is_ascii_alphanumeric() || matches!(byte, b'_' | b'$')
+}
+
+fn skip_mysql_quoted(sql: &str, start: usize, quote: u8) -> usize {
+    let bytes = sql.as_bytes();
+    let mut i = start + 1;
+    while i < bytes.len() {
+        if bytes[i] == quote {
+            if i + 1 < bytes.len() && bytes[i + 1] == quote {
+                i += 2;
+                continue;
+            }
+            return i + 1;
+        }
+        if quote == b'\'' && bytes[i] == b'\\' {
+            i = (i + 2).min(bytes.len());
+            continue;
+        }
+        i += 1;
+    }
+    bytes.len()
+}
+
+/// Get a connection from the pool with a health check. If the connection is dead
+/// (e.g. after app was backgrounded), it tries again with a fresh connection.
+pub async fn get_conn_with_health_check(pool: &MySqlPool) -> Result<mysql_async::Conn, String> {
+    get_conn_with_health_check_with_timeout(pool, super::connection_timeout()).await
+}
+
+pub async fn get_conn_with_health_check_with_timeout(
+    pool: &MySqlPool,
+    timeout: Duration,
+) -> Result<mysql_async::Conn, String> {
+    get_conn_with_health_check_with_cancel(pool, timeout, timeout, None).await
+}
+
+pub async fn get_conn_with_health_check_with_cancel(
+    pool: &MySqlPool,
+    timeout: Duration,
+    cleanup_timeout: Duration,
+    cancel_token: Option<&CancellationToken>,
+) -> Result<mysql_async::Conn, String> {
+    let start = Instant::now();
+    let mut conn = get_conn_with_timeout_and_cancel(pool, timeout, cancel_token).await?;
+    match ping_conn_with_timeout_and_cancel(&mut conn, timeout, cancel_token).await {
+        Ok(()) => {
+            log::debug!(
+                "[db:health.check:done] elapsed_ms={} timeout_ms={}",
+                start.elapsed().as_millis(),
+                timeout.as_millis()
+            );
+            Ok(conn)
+        }
+        Err(err) if err == crate::query::QUERY_CANCELED => {
+            let _ = tokio::time::timeout(cleanup_timeout, conn.disconnect()).await;
+            Err(err)
+        }
+        Err(err) => {
+            log::warn!(
+                "[db:health.check:error] elapsed_ms={} timeout_ms={} error={}; retrying",
+                start.elapsed().as_millis(),
+                timeout.as_millis(),
+                err
+            );
+            let _ = tokio::time::timeout(cleanup_timeout, conn.disconnect()).await;
+            let mut conn = get_conn_with_timeout_and_cancel(pool, timeout, cancel_token).await?;
+            if let Err(err) = ping_conn_with_timeout_and_cancel(&mut conn, timeout, cancel_token).await {
+                if err == crate::query::QUERY_CANCELED {
+                    let _ = tokio::time::timeout(cleanup_timeout, conn.disconnect()).await;
+                }
+                return Err(err);
+            }
+            log::info!(
+                "[db:health.check:recovered] elapsed_ms={} timeout_ms={}",
+                start.elapsed().as_millis(),
+                timeout.as_millis()
+            );
+            Ok(conn)
+        }
+    }
+}
+
+async fn get_conn_with_timeout_and_cancel(
+    pool: &MySqlPool,
+    timeout: Duration,
+    cancel_token: Option<&CancellationToken>,
+) -> Result<mysql_async::Conn, String> {
+    let get_future = async {
+        tokio::time::timeout(timeout, pool.get_conn())
+            .await
+            .map_err(|_| "MySQL get connection timed out".to_string())?
+            .map_err(|e| e.to_string())
+    };
+
+    match cancel_token {
+        Some(token) => {
+            tokio::select! {
+                biased;
+                _ = token.cancelled() => Err(crate::query::canceled_error()),
+                result = get_future => result,
+            }
+        }
+        None => get_future.await,
+    }
+}
+
+pub async fn get_conn_with_timeout(pool: &MySqlPool, timeout: Duration) -> Result<mysql_async::Conn, String> {
+    tokio::time::timeout(timeout, pool.get_conn())
+        .await
+        .map_err(|_| "MySQL get connection timed out".to_string())?
+        .map_err(|e| e.to_string())
+}
+
+async fn ping_conn_with_timeout_and_cancel(
+    conn: &mut mysql_async::Conn,
+    timeout: Duration,
+    cancel_token: Option<&CancellationToken>,
+) -> Result<(), String> {
+    let ping_future = async {
+        tokio::time::timeout(timeout, conn.ping())
+            .await
+            .map_err(|_| "MySQL ping timed out".to_string())?
+            .map_err(|e| e.to_string())
+    };
+
+    match cancel_token {
+        Some(token) => {
+            tokio::select! {
+                biased;
+                _ = token.cancelled() => Err(crate::query::canceled_error()),
+                result = ping_future => result,
+            }
+        }
+        None => ping_future.await,
+    }
+}
+
+async fn execute_result_set_with_text_protocol_on_conn(
+    conn: &mut mysql_async::Conn,
+    sql: &str,
+    row_limit: usize,
+    max_rows: Option<usize>,
+    start: Instant,
+) -> Result<QueryResult, String> {
+    let mut result = conn.query_iter(sql).await.map_err(|e| e.to_string())?;
+    if !advance_to_result_set_with_columns(&mut result).await? {
+        return Ok(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: result.affected_rows(),
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        });
+    }
+    let columns: Vec<String> = result.columns_ref().iter().map(|c| c.name_str().to_string()).collect();
+    let column_types: Vec<String> =
+        result.columns_ref().iter().map(|c| mysql_column_type_name(c.column_type())).collect();
+
+    if should_collect_text_result_set(sql, row_limit, max_rows) {
+        let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+        let truncated = rows.len() > row_limit;
+        let result_rows = rows
+            .iter()
+            .take(row_limit)
+            .map(|row| (0..row.len()).map(|i| mysql_value_to_json(row, i)).collect())
+            .collect();
+
+        return Ok(QueryResult {
+            columns,
+            column_types,
+            column_sortables: vec![],
+            rows: result_rows,
+            affected_rows: 0,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated,
+            session_id: None,
+            has_more: false,
+        });
+    }
+
+    let mut result_rows: Vec<Vec<serde_json::Value>> = Vec::new();
+    let mut stream = result
+        .stream::<mysql_async::Row>()
+        .await
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "Empty result set stream".to_string())?;
+
+    while let Some(row) = stream.next().await {
+        let row = row.map_err(|e| e.to_string())?;
+        let values: Vec<serde_json::Value> = (0..row.len()).map(|i| mysql_value_to_json(&row, i)).collect();
+        result_rows.push(values);
+        if result_rows.len() > row_limit {
+            break;
+        }
+    }
+
+    let truncated = result_rows.len() > row_limit;
+    if truncated {
+        result_rows.truncate(row_limit);
+    }
+
+    Ok(QueryResult {
+        columns,
+        column_types,
+        column_sortables: vec![],
+        rows: result_rows,
+        affected_rows: 0,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+async fn advance_to_result_set_with_columns(
+    result: &mut mysql_async::QueryResult<'_, '_, mysql_async::TextProtocol>,
+) -> Result<bool, String> {
+    while result.columns_ref().is_empty() {
+        if result.is_empty() {
+            return Ok(false);
+        }
+        let _: Vec<mysql_async::Row> = result.collect().await.map_err(|e| e.to_string())?;
+    }
+    Ok(!result.columns_ref().is_empty())
+}
+
+async fn execute_result_set_with_prepared_protocol_on_conn(
+    conn: &mut mysql_async::Conn,
+    sql: &str,
+    row_limit: usize,
+    start: Instant,
+) -> Result<QueryResult, String> {
+    let mut result = conn.exec_iter(sql, ()).await.map_err(|e| e.to_string())?;
+    let columns: Vec<String> = result.columns_ref().iter().map(|c| c.name_str().to_string()).collect();
+    let column_types: Vec<String> =
+        result.columns_ref().iter().map(|c| mysql_column_type_name(c.column_type())).collect();
+
+    let mut result_rows: Vec<Vec<serde_json::Value>> = Vec::new();
+    let mut stream = result
+        .stream::<mysql_async::Row>()
+        .await
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "Empty result set stream".to_string())?;
+
+    while let Some(row) = stream.next().await {
+        let row = row.map_err(|e| e.to_string())?;
+        let values: Vec<serde_json::Value> = (0..row.len()).map(|i| mysql_value_to_json(&row, i)).collect();
+        result_rows.push(values);
+        if result_rows.len() > row_limit {
+            break;
+        }
+    }
+
+    let truncated = result_rows.len() > row_limit;
+    if truncated {
+        result_rows.truncate(row_limit);
+    }
+
+    Ok(QueryResult {
+        columns,
+        column_types,
+        column_sortables: vec![],
+        rows: result_rows,
+        affected_rows: 0,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+pub async fn execute_query(pool: &MySqlPool, sql: &str, bare: bool) -> Result<QueryResult, String> {
+    execute_query_with_max_rows(pool, sql, bare, None, MySqlQueryDialect::default()).await
+}
+
+pub async fn execute_query_with_max_rows(
+    pool: &MySqlPool,
+    sql: &str,
+    bare: bool,
+    max_rows: Option<usize>,
+    dialect: MySqlQueryDialect,
+) -> Result<QueryResult, String> {
+    let mut conn = get_conn_with_health_check(pool).await?;
+    execute_query_on_conn_with_max_rows(&mut conn, sql, bare, max_rows, dialect).await
+}
+
+pub async fn stream_query_rows(
+    pool: &MySqlPool,
+    sql: &str,
+    bare: bool,
+    max_rows: Option<usize>,
+    dialect: MySqlQueryDialect,
+    cancelled: &AtomicBool,
+    mut on_row: impl FnMut(&[serde_json::Value]) -> Result<(), String>,
+) -> Result<u64, String> {
+    let mut conn = get_conn_with_health_check(pool).await?;
+    stream_query_result_on_conn(&mut conn, sql, bare, max_rows, dialect, cancelled, |item| {
+        if let MySqlQueryStreamItem::Row(row) = item {
+            on_row(&row)?;
+        }
+        Ok(())
+    })
+    .await
+}
+
+pub async fn stream_query_result_on_conn(
+    conn: &mut mysql_async::Conn,
+    sql: &str,
+    bare: bool,
+    max_rows: Option<usize>,
+    dialect: MySqlQueryDialect,
+    cancelled: &AtomicBool,
+    mut on_item: impl FnMut(MySqlQueryStreamItem) -> Result<(), String>,
+) -> Result<u64, String> {
+    let row_limit = max_rows.unwrap_or(usize::MAX);
+
+    if bare || prefers_text_protocol_query(sql, dialect) {
+        stream_query_result_text(conn, sql, row_limit, cancelled, &mut on_item).await
+    } else {
+        match stream_query_result_prepared(conn, sql, row_limit, cancelled, &mut on_item).await {
+            Ok(rows) => Ok(rows),
+            Err(err) if mysql_error_should_retry_with_text_protocol(&err) => {
+                stream_query_result_text(conn, sql, row_limit, cancelled, &mut on_item).await
+            }
+            Err(err) => Err(err),
+        }
+    }
+}
+
+async fn stream_query_result_text(
+    conn: &mut mysql_async::Conn,
+    sql: &str,
+    row_limit: usize,
+    cancelled: &AtomicBool,
+    on_item: &mut impl FnMut(MySqlQueryStreamItem) -> Result<(), String>,
+) -> Result<u64, String> {
+    let mut result = conn.query_iter(sql).await.map_err(|e| e.to_string())?;
+    if !advance_to_result_set_with_columns(&mut result).await? {
+        return Ok(0);
+    }
+    let columns: Vec<String> = result.columns_ref().iter().map(|c| c.name_str().to_string()).collect();
+    let column_types: Vec<String> =
+        result.columns_ref().iter().map(|c| mysql_column_type_name(c.column_type())).collect();
+    on_item(MySqlQueryStreamItem::Columns { columns, column_types })?;
+
+    let mut stream = result
+        .stream::<mysql_async::Row>()
+        .await
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "Empty result set stream".to_string())?;
+    let mut rows_exported = 0_u64;
+
+    while let Some(row) = stream.next().await {
+        if cancelled.load(std::sync::atomic::Ordering::SeqCst) {
+            return Err(crate::query::canceled_error());
+        }
+        if rows_exported as usize >= row_limit {
+            break;
+        }
+        let row = row.map_err(|e| e.to_string())?;
+        let values: Vec<serde_json::Value> = (0..row.len()).map(|i| mysql_value_to_json(&row, i)).collect();
+        on_item(MySqlQueryStreamItem::Row(values))?;
+        rows_exported += 1;
+    }
+
+    Ok(rows_exported)
+}
+
+async fn stream_query_result_prepared(
+    conn: &mut mysql_async::Conn,
+    sql: &str,
+    row_limit: usize,
+    cancelled: &AtomicBool,
+    on_item: &mut impl FnMut(MySqlQueryStreamItem) -> Result<(), String>,
+) -> Result<u64, String> {
+    let mut result = conn.exec_iter(sql, ()).await.map_err(|e| e.to_string())?;
+    let columns: Vec<String> = result.columns_ref().iter().map(|c| c.name_str().to_string()).collect();
+    if columns.is_empty() {
+        return Ok(0);
+    }
+    let column_types: Vec<String> =
+        result.columns_ref().iter().map(|c| mysql_column_type_name(c.column_type())).collect();
+    on_item(MySqlQueryStreamItem::Columns { columns, column_types })?;
+
+    let mut stream = result
+        .stream::<mysql_async::Row>()
+        .await
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| "Empty result set stream".to_string())?;
+    let mut rows_exported = 0_u64;
+
+    while let Some(row) = stream.next().await {
+        if cancelled.load(std::sync::atomic::Ordering::SeqCst) {
+            return Err(crate::query::canceled_error());
+        }
+        if rows_exported as usize >= row_limit {
+            break;
+        }
+        let row = row.map_err(|e| e.to_string())?;
+        let values: Vec<serde_json::Value> = (0..row.len()).map(|i| mysql_value_to_json(&row, i)).collect();
+        on_item(MySqlQueryStreamItem::Row(values))?;
+        rows_exported += 1;
+    }
+
+    Ok(rows_exported)
+}
+
+pub async fn kill_query(pool: &MySqlPool, connection_id: u32) -> Result<(), String> {
+    let start = Instant::now();
+    let timeout = super::connection_timeout();
+    let mut conn = tokio::time::timeout(timeout, pool.get_conn())
+        .await
+        .map_err(|_| {
+            log::warn!(
+                "[db:cancel:error] elapsed_ms={} timeout_ms={} error=MySQL kill connection checkout timed out",
+                start.elapsed().as_millis(),
+                timeout.as_millis()
+            );
+            "MySQL kill connection checkout timed out".to_string()
+        })?
+        .map_err(|e| e.to_string())?;
+    tokio::time::timeout(timeout, conn.query_drop(format!("KILL QUERY {connection_id}")))
+        .await
+        .map_err(|_| {
+            log::warn!(
+                "[db:cancel:error] elapsed_ms={} timeout_ms={} error=MySQL KILL QUERY timed out",
+                start.elapsed().as_millis(),
+                timeout.as_millis()
+            );
+            "MySQL KILL QUERY timed out".to_string()
+        })?
+        .map_err(|e| e.to_string())?;
+    log::info!("[db:cancel:done] elapsed_ms={} timeout_ms={}", start.elapsed().as_millis(), timeout.as_millis());
+    Ok(())
+}
+
+pub async fn kill_query_with_opts(opts: mysql_async::Opts, connection_id: u32) -> Result<(), String> {
+    let start = Instant::now();
+    let timeout = super::connection_timeout();
+    let mut conn = tokio::time::timeout(timeout, mysql_async::Conn::new(opts))
+        .await
+        .map_err(|_| {
+            log::warn!(
+                "[db:cancel:error] elapsed_ms={} timeout_ms={} error=MySQL kill connection timed out",
+                start.elapsed().as_millis(),
+                timeout.as_millis()
+            );
+            "MySQL kill connection timed out".to_string()
+        })?
+        .map_err(|e| e.to_string())?;
+    tokio::time::timeout(timeout, conn.query_drop(format!("KILL QUERY {connection_id}")))
+        .await
+        .map_err(|_| {
+            log::warn!(
+                "[db:cancel:error] elapsed_ms={} timeout_ms={} error=MySQL KILL QUERY execution timed out",
+                start.elapsed().as_millis(),
+                timeout.as_millis()
+            );
+            "MySQL KILL QUERY execution timed out".to_string()
+        })?
+        .map_err(|e| e.to_string())?;
+    log::info!("[db:cancel:done] elapsed_ms={} timeout_ms={}", start.elapsed().as_millis(), timeout.as_millis());
+    Ok(())
+}
+
+pub async fn execute_query_on_conn_with_max_rows(
+    conn: &mut mysql_async::Conn,
+    sql: &str,
+    bare: bool,
+    max_rows: Option<usize>,
+    dialect: MySqlQueryDialect,
+) -> Result<QueryResult, String> {
+    let start = Instant::now();
+    let row_limit = query_result_row_limit(max_rows);
+
+    if is_result_set_query(sql, dialect) {
+        if bare || prefers_text_protocol_query(sql, dialect) {
+            execute_result_set_with_text_protocol_on_conn(conn, sql, row_limit, max_rows, start).await
+        } else {
+            match execute_result_set_with_prepared_protocol_on_conn(conn, sql, row_limit, start).await {
+                Ok(result) => Ok(result),
+                Err(err) if mysql_error_should_retry_with_text_protocol(&err) => {
+                    execute_result_set_with_text_protocol_on_conn(conn, sql, row_limit, max_rows, start).await
+                }
+                Err(err) => Err(err),
+            }
+        }
+    } else {
+        let previous_explicit_timestamp_defaults = enable_explicit_timestamp_defaults_for_query(conn, sql).await;
+        let result = match conn.query_iter(sql).await {
+            Ok(result) => result,
+            Err(err) => {
+                restore_explicit_timestamp_defaults_for_query(conn, previous_explicit_timestamp_defaults).await;
+                return Err(err.to_string());
+            }
+        };
+        let affected_rows = result.affected_rows();
+        let drop_result = result.drop_result().await;
+        restore_explicit_timestamp_defaults_for_query(conn, previous_explicit_timestamp_defaults).await;
+        drop_result.map_err(|e| e.to_string())?;
+
+        Ok(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    }
+}
+
+fn prefers_text_protocol_query(sql: &str, dialect: MySqlQueryDialect) -> bool {
+    // User-entered result-set queries are not parameterized in DBX. Text protocol
+    // avoids binary result decoding bugs in MySQL-compatible servers and proxies.
+    is_result_set_query(sql, dialect) || requires_text_protocol_query(sql, dialect)
+}
+
+fn is_result_set_query(sql: &str, dialect: MySqlQueryDialect) -> bool {
+    starts_with_executable_sql_keyword(sql, &["SELECT", "SHOW", "DESCRIBE", "EXPLAIN", "WITH", "CALL"])
+        || dialect.supports_admin_show_results && is_admin_show_query(sql)
+}
+
+fn requires_text_protocol_query(sql: &str, dialect: MySqlQueryDialect) -> bool {
+    if dialect.supports_admin_show_results && is_admin_show_query(sql) {
+        return true;
+    }
+
+    if !starts_with_executable_sql_keyword(sql, &["SHOW"]) {
+        return false;
+    }
+
+    let tokens =
+        sql.trim().trim_end_matches(';').split_whitespace().map(|token| token.to_ascii_lowercase()).collect::<Vec<_>>();
+    if tokens.len() >= 2 && tokens[0] == "show" && tokens[1] == "grants" {
+        return true;
+    }
+
+    matches!(
+        tokens.iter().map(String::as_str).collect::<Vec<_>>().as_slice(),
+        ["show", "processlist"]
+            | ["show", "full", "processlist"]
+            | ["show", "slave", "status"]
+            | ["show", "replica", "status"]
+    )
+}
+
+fn is_admin_show_query(sql: &str) -> bool {
+    let tokens = leading_sql_word_tokens(sql, 2);
+    tokens.first().is_some_and(|token| token == "admin") && tokens.get(1).is_some_and(|token| token == "show")
+}
+
+fn leading_sql_word_tokens(sql: &str, limit: usize) -> Vec<String> {
+    let bytes = sql.as_bytes();
+    let mut i = 0;
+    let mut tokens = Vec::new();
+
+    while i < bytes.len() && tokens.len() < limit {
+        i = skip_sql_whitespace_and_comments(bytes, i);
+        let start = i;
+        while i < bytes.len() && (bytes[i].is_ascii_alphabetic() || bytes[i] == b'_') {
+            i += 1;
+        }
+        if i == start {
+            break;
+        }
+        tokens.push(sql[start..i].to_ascii_lowercase());
+    }
+
+    tokens
+}
+
+fn skip_sql_whitespace_and_comments(bytes: &[u8], mut i: usize) -> usize {
+    loop {
+        while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+            i += 1;
+        }
+
+        if i + 1 < bytes.len() && bytes[i] == b'-' && bytes[i + 1] == b'-' {
+            i += 2;
+            while i < bytes.len() && bytes[i] != b'\n' {
+                i += 1;
+            }
+            continue;
+        }
+
+        if i < bytes.len() && bytes[i] == b'#' {
+            i += 1;
+            while i < bytes.len() && bytes[i] != b'\n' {
+                i += 1;
+            }
+            continue;
+        }
+
+        if i + 1 < bytes.len() && bytes[i] == b'/' && bytes[i + 1] == b'*' {
+            i += 2;
+            while i + 1 < bytes.len() && !(bytes[i] == b'*' && bytes[i + 1] == b'/') {
+                i += 1;
+            }
+            i = (i + 2).min(bytes.len());
+            continue;
+        }
+
+        return i;
+    }
+}
+
+pub async fn list_indexes(pool: &MySqlPool, database: &str, table: &str) -> Result<Vec<IndexInfo>, String> {
+    let sql = format!(
+        "SELECT INDEX_NAME, GROUP_CONCAT(COLUMN_NAME ORDER BY SEQ_IN_INDEX) AS columns, \
+         MIN(NON_UNIQUE) = 0 AS is_unique, INDEX_NAME = 'PRIMARY' AS is_primary, \
+         INDEX_TYPE, MAX(NULLIF(INDEX_COMMENT, '')) AS INDEX_COMMENT \
+         FROM information_schema.STATISTICS \
+         WHERE TABLE_SCHEMA = {} AND TABLE_NAME = {} \
+         GROUP BY INDEX_NAME, INDEX_TYPE \
+         ORDER BY INDEX_NAME",
+        quote_value(database),
+        quote_value(table),
+    );
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let cols_str = get_str_by_name(row, "columns");
+            IndexInfo {
+                name: get_str_by_name(row, "INDEX_NAME"),
+                columns: cols_str.split(',').filter(|s| !s.is_empty()).map(|s| s.to_string()).collect(),
+                is_unique: row.get::<bool, &str>("is_unique").unwrap_or(false),
+                is_primary: row.get::<bool, &str>("is_primary").unwrap_or(false),
+                filter: None,
+                index_type: Some(get_str_by_name(row, "INDEX_TYPE")),
+                included_columns: None,
+                comment: get_opt_str(row, "INDEX_COMMENT").filter(|value| !value.is_empty()),
+            }
+        })
+        .collect())
+}
+
+pub async fn list_doris_family_indexes(
+    pool: &MySqlPool,
+    database: &str,
+    table: &str,
+) -> Result<Vec<IndexInfo>, String> {
+    let statistics_result = list_indexes(pool, database, table).await;
+    let mut indexes = match &statistics_result {
+        Ok(indexes) => indexes.clone(),
+        Err(err) => {
+            log::debug!(
+                "Falling back to SHOW CREATE TABLE for Doris-family indexes on `{database}`.`{table}` after information_schema.STATISTICS failed: {err}"
+            );
+            Vec::new()
+        }
+    };
+
+    match show_create_table_ddl(pool, database, table).await {
+        Ok(ddl) => {
+            merge_index_infos(&mut indexes, doris_indexes_from_create_table_ddl(&ddl));
+            Ok(indexes)
+        }
+        Err(ddl_err) => {
+            if indexes.is_empty() {
+                if let Err(statistics_err) = statistics_result {
+                    return Err(format!(
+                        "{statistics_err}; SHOW CREATE TABLE fallback failed for Doris-family indexes: {ddl_err}"
+                    ));
+                }
+            }
+            Ok(indexes)
+        }
+    }
+}
+
+pub async fn show_create_table_ddl(pool: &MySqlPool, database: &str, table: &str) -> Result<String, String> {
+    let sql = format!("SHOW CREATE TABLE {}", quote_table_ref(database, table));
+    let mut conn = get_conn_with_health_check(pool).await?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    let row = rows.first().ok_or("DDL not found")?;
+    row.get_opt::<String, usize>(1)
+        .and_then(|result| result.ok())
+        .or_else(|| {
+            row.get_opt::<Vec<u8>, usize>(1)
+                .and_then(|result| result.ok())
+                .map(|b| String::from_utf8_lossy(&b).to_string())
+        })
+        .ok_or_else(|| "Failed to read DDL".to_string())
+}
+
+// ---------------------------------------------------------------------------
+// Doris / StarRocks multi-catalog support.
+//
+// These engines expose external catalogs (iceberg, hive, jdbc, ...) alongside
+// the native `internal` catalog via `SHOW CATALOGS`. The functions below address
+// objects in a specific catalog using 3-part qualified names
+// (`<catalog>.<database>.<table>`), which the engines accept directly without
+// needing to `SWITCH` the session catalog.
+// ---------------------------------------------------------------------------
+
+/// Build a 2-part qualified identifier `` `<catalog>`.`<database>` ``.
+fn doris_catalog_database_ref(catalog: &str, database: &str) -> String {
+    format!("{}.{}", quote_identifier(catalog), quote_identifier(database))
+}
+
+/// Build a 3-part qualified identifier `` `<catalog>`.`<database>`.`<table>` ``.
+fn doris_catalog_table_ref(catalog: &str, database: &str, table: &str) -> String {
+    format!("{}.{}.{}", quote_identifier(catalog), quote_identifier(database), quote_identifier(table))
+}
+
+/// `SHOW CATALOGS` → list of catalogs visible to the current user.
+///
+/// Column layouts differ between engines: Doris exposes `CatalogName` (with
+/// `CatalogId`/`IsCurrent`/`CreateTime`/`LastUpdateTime`), while StarRocks
+/// exposes `Catalog` (only `Type`/`Comment`, no `IsCurrent`). The name is read
+/// from either column; missing trailing columns degrade gracefully to
+/// empty/None. The built-in catalog is named `internal` in Doris and
+/// `default_catalog` in StarRocks (both with `Type=internal`); detection is
+/// type-based (see `CatalogInfo::is_internal`), not name-based.
+pub async fn list_doris_catalogs(pool: &MySqlPool) -> Result<Vec<crate::db::CatalogInfo>, String> {
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let result = conn.query_iter("SHOW CATALOGS").await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    let catalogs: Vec<crate::db::CatalogInfo> = rows
+        .iter()
+        .filter_map(|row| {
+            // Doris column is `CatalogName`; StarRocks column is `Catalog`.
+            let name = first_nonempty_str_by_name(row, &["CatalogName", "Catalog"]).trim().to_string();
+            if name.is_empty() {
+                return None;
+            }
+            let catalog_type = get_str_by_name(row, "Type").trim().to_string();
+            let is_current = {
+                let value = get_str_by_name(row, "IsCurrent").trim().to_ascii_lowercase();
+                !value.is_empty() && value != "no" && value != "false" && value != "0"
+            };
+            let comment = get_opt_str(row, "Comment").map(|s| s.trim().to_string()).filter(|s| !s.is_empty());
+            Some(crate::db::CatalogInfo { name, catalog_type, is_current, comment })
+        })
+        .collect();
+    Ok(normalize_doris_catalogs(catalogs))
+}
+
+/// Sort with the built-in catalog first, then the rest alphabetically by name.
+/// The built-in catalog is identified by `CatalogInfo::is_internal` (type-based)
+/// rather than by name, so StarRocks `default_catalog` sorts first just like
+/// Doris `internal`. No synthetic catalog is injected: `SHOW CATALOGS` always
+/// lists the built-in catalog on both engines, and a single-catalog result is
+/// handled by the flat-sidebar fallback in the caller.
+fn normalize_doris_catalogs(mut catalogs: Vec<crate::db::CatalogInfo>) -> Vec<crate::db::CatalogInfo> {
+    catalogs.sort_by(|a, b| match (a.is_internal(), b.is_internal()) {
+        (true, false) => std::cmp::Ordering::Less,
+        (false, true) => std::cmp::Ordering::Greater,
+        _ => a.name.cmp(&b.name),
+    });
+    catalogs
+}
+
+/// `SHOW DATABASES FROM <catalog>` → databases in the given catalog.
+pub async fn list_databases_show_from(pool: &MySqlPool, catalog: &str) -> Result<Vec<DatabaseInfo>, String> {
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let sql = format!("SHOW DATABASES FROM {}", quote_identifier(catalog));
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    Ok(database_infos_from_names(rows.iter().map(|row| get_str(row, 0)), false))
+}
+
+/// `SHOW TABLES FROM <catalog>.<database>` → tables in an external catalog.
+///
+/// External catalogs do not support `SHOW TABLE STATUS`, so comments/status are
+/// not fetched (the caller only needs names + types for browsing).
+pub async fn list_tables_show_from(pool: &MySqlPool, catalog: &str, database: &str) -> Result<Vec<TableInfo>, String> {
+    let sql = format!("SHOW TABLES FROM {}", doris_catalog_database_ref(catalog, database));
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    let mut tables: Vec<TableInfo> = rows
+        .iter()
+        .filter_map(|row| {
+            let name = get_str(row, 0).trim().to_string();
+            if name.is_empty() {
+                return None;
+            }
+            // SHOW FULL TABLES exposes a type column; plain SHOW TABLES does not.
+            let table_type = get_str(row, 1);
+            Some(TableInfo {
+                name,
+                table_type: if table_type.trim().is_empty() { "TABLE".to_string() } else { table_type },
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            })
+        })
+        .collect();
+    tables.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(tables)
+}
+
+/// `SHOW COLUMNS FROM <catalog>.<database>.<table>` → columns of an external
+/// catalog table. Falls back to `DESCRIBE` if `SHOW COLUMNS` is rejected.
+pub async fn get_columns_show_from(
+    pool: &MySqlPool,
+    catalog: &str,
+    database: &str,
+    table: &str,
+) -> Result<Vec<ColumnInfo>, String> {
+    let qualified = doris_catalog_table_ref(catalog, database, table);
+    let full_sql = format!("SHOW FULL COLUMNS FROM {qualified}");
+    let plain_sql = format!("SHOW COLUMNS FROM {qualified}");
+    let describe_sql = format!("DESCRIBE {qualified}");
+    let mut conn = get_conn_with_health_check(pool).await?;
+    let rows: Vec<mysql_async::Row> = match conn.query_iter(&full_sql).await {
+        Ok(result) => result.collect_and_drop().await.map_err(|e| e.to_string())?,
+        Err(_) => match conn.query_iter(&plain_sql).await {
+            Ok(result) => result.collect_and_drop().await.map_err(|e| e.to_string())?,
+            Err(_) => {
+                let result = conn.query_iter(&describe_sql).await.map_err(|e| e.to_string())?;
+                result.collect_and_drop().await.map_err(|e| e.to_string())?
+            }
+        },
+    };
+    Ok(rows
+        .iter()
+        .filter_map(|row| {
+            let name = get_str_by_name(row, "Field").trim().to_string();
+            if name.is_empty() {
+                return None;
+            }
+            let key = get_str_by_name(row, "Key");
+            let collation = get_opt_str(row, "Collation").filter(|s| !s.is_empty());
+            Some(ColumnInfo {
+                name,
+                data_type: get_str_by_name(row, "Type"),
+                is_nullable: get_str_by_name(row, "Null").eq_ignore_ascii_case("YES"),
+                column_default: get_opt_str(row, "Default"),
+                is_primary_key: key.eq_ignore_ascii_case("PRI"),
+                extra: get_opt_str(row, "Extra"),
+                comment: get_opt_str(row, "Comment")
+                    .map(|s| fix_potential_double_encoding(&s))
+                    .filter(|s| !s.is_empty()),
+                numeric_precision: None,
+                numeric_scale: None,
+                character_maximum_length: None,
+                enum_values: None,
+                character_set: collation
+                    .as_deref()
+                    .and_then(|c| c.split_once('_').map(|(charset, _)| charset.to_string()))
+                    .filter(|s| !s.is_empty()),
+                collation,
+            })
+        })
+        .collect())
+}
+
+/// `SHOW CREATE TABLE <catalog>.<database>.<table>` → DDL for an external
+/// catalog table.
+pub async fn show_create_table_ddl_from(
+    pool: &MySqlPool,
+    catalog: &str,
+    database: &str,
+    table: &str,
+) -> Result<String, String> {
+    let sql = format!("SHOW CREATE TABLE {}", doris_catalog_table_ref(catalog, database, table));
+    let mut conn = get_conn_with_health_check(pool).await?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    let row = rows.first().ok_or("DDL not found")?;
+    row.get_opt::<String, usize>(1)
+        .and_then(|result| result.ok())
+        .or_else(|| {
+            row.get_opt::<Vec<u8>, usize>(1)
+                .and_then(|result| result.ok())
+                .map(|b| String::from_utf8_lossy(&b).to_string())
+        })
+        .ok_or_else(|| "Failed to read DDL".to_string())
+}
+
+/// Best-effort index listing for an external catalog table. External catalogs
+/// generally do not expose MySQL-style index metadata via `information_schema`
+/// (that view is scoped to the internal catalog), so indexes are derived from
+/// `SHOW CREATE TABLE` parsing. Returns empty on failure (graceful degradation
+/// — indexes are informational for external tables).
+pub async fn list_doris_catalog_indexes(
+    pool: &MySqlPool,
+    catalog: &str,
+    database: &str,
+    table: &str,
+) -> Result<Vec<IndexInfo>, String> {
+    let ddl = show_create_table_ddl_from(pool, catalog, database, table).await?;
+    Ok(doris_indexes_from_create_table_ddl(&ddl))
+}
+
+fn merge_index_infos(target: &mut Vec<IndexInfo>, parsed: Vec<IndexInfo>) {
+    let mut seen_names: HashSet<String> = target.iter().map(|index| index.name.to_ascii_lowercase()).collect();
+    for index in parsed {
+        if index.columns.is_empty() {
+            continue;
+        }
+        if seen_names.contains(&index.name.to_ascii_lowercase())
+            || target.iter().any(|existing| {
+                existing.is_unique == index.is_unique
+                    && existing.is_primary == index.is_primary
+                    && existing.columns == index.columns
+            })
+        {
+            continue;
+        }
+        seen_names.insert(index.name.to_ascii_lowercase());
+        target.push(index);
+    }
+}
+
+fn doris_indexes_from_create_table_ddl(ddl: &str) -> Vec<IndexInfo> {
+    let mut indexes = Vec::new();
+    for raw_line in ddl.lines() {
+        let line = trim_ddl_definition_line(raw_line);
+        if line.is_empty() {
+            continue;
+        }
+        let upper = line.to_ascii_uppercase();
+        if upper.starts_with("PRIMARY KEY") {
+            if let Some(index) = doris_table_key_index("PRIMARY", line, true, true, "PRIMARY KEY") {
+                indexes.push(index);
+            }
+        } else if upper.starts_with("UNIQUE KEY") {
+            if let Some(index) = doris_table_key_index("UNIQUE KEY", line, true, false, "UNIQUE KEY") {
+                indexes.push(index);
+            }
+        } else if upper.starts_with("INDEX ") {
+            if let Some(index) = doris_secondary_index(line) {
+                indexes.push(index);
+            }
+        }
+    }
+    indexes
+}
+
+fn trim_ddl_definition_line(line: &str) -> &str {
+    let mut trimmed = line.trim();
+    if let Some(rest) = trimmed.strip_prefix(',') {
+        trimmed = rest.trim_start();
+    }
+    while let Some(rest) = trimmed.strip_suffix(',') {
+        trimmed = rest.trim_end();
+    }
+    trimmed
+}
+
+fn doris_table_key_index(
+    name: &str,
+    line: &str,
+    is_unique: bool,
+    is_primary: bool,
+    index_type: &str,
+) -> Option<IndexInfo> {
+    let columns = parse_mysql_index_columns(first_parenthesized_content(line)?);
+    if columns.is_empty() {
+        return None;
+    }
+    Some(IndexInfo {
+        name: name.to_string(),
+        columns,
+        is_unique,
+        is_primary,
+        filter: None,
+        index_type: Some(index_type.to_string()),
+        included_columns: None,
+        comment: None,
+    })
+}
+
+fn doris_secondary_index(line: &str) -> Option<IndexInfo> {
+    let (_, rest) = split_keyword_prefix(line, "INDEX")?;
+    let (name, after_name) = read_mysql_identifier(rest.trim_start())?;
+    let columns = parse_mysql_index_columns(first_parenthesized_content(after_name)?);
+    if columns.is_empty() {
+        return None;
+    }
+    Some(IndexInfo {
+        name,
+        columns,
+        is_unique: false,
+        is_primary: false,
+        filter: None,
+        index_type: mysql_keyword_argument(after_name, "USING").or_else(|| Some("INDEX".to_string())),
+        included_columns: None,
+        comment: mysql_quoted_string_argument(after_name, "COMMENT"),
+    })
+}
+
+fn split_keyword_prefix<'a>(line: &'a str, keyword: &str) -> Option<(&'a str, &'a str)> {
+    if line.len() < keyword.len() || !line[..keyword.len()].eq_ignore_ascii_case(keyword) {
+        return None;
+    }
+    let rest = &line[keyword.len()..];
+    if !rest.is_empty() && is_mysql_identifier_byte(rest.as_bytes()[0]) {
+        return None;
+    }
+    Some((&line[..keyword.len()], rest))
+}
+
+fn read_mysql_identifier(input: &str) -> Option<(String, &str)> {
+    let input = input.trim_start();
+    if input.is_empty() {
+        return None;
+    }
+    let bytes = input.as_bytes();
+    if bytes[0] == b'`' {
+        let mut i = 1;
+        let mut value = String::new();
+        while i < bytes.len() {
+            if bytes[i] == b'`' {
+                if i + 1 < bytes.len() && bytes[i + 1] == b'`' {
+                    value.push('`');
+                    i += 2;
+                    continue;
+                }
+                return Some((value, &input[i + 1..]));
+            }
+            let ch = input[i..].chars().next()?;
+            value.push(ch);
+            i += ch.len_utf8();
+        }
+        return None;
+    }
+
+    let end = input.find(|ch: char| ch.is_whitespace() || matches!(ch, '(' | ')' | ',')).unwrap_or(input.len());
+    if end == 0 {
+        return None;
+    }
+    Some((input[..end].to_string(), &input[end..]))
+}
+
+fn first_parenthesized_content(input: &str) -> Option<&str> {
+    let bytes = input.as_bytes();
+    let mut depth = 0usize;
+    let mut start = None;
+    let mut i = 0usize;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'\'' | b'"' | b'`' => {
+                i = skip_mysql_quoted(input, i, bytes[i]);
+                continue;
+            }
+            b'(' => {
+                if depth == 0 {
+                    start = Some(i + 1);
+                }
+                depth += 1;
+            }
+            b')' if depth > 0 => {
+                depth -= 1;
+                if depth == 0 {
+                    return start.map(|start| &input[start..i]);
+                }
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    None
+}
+
+fn split_top_level_csv(input: &str) -> Vec<&str> {
+    let bytes = input.as_bytes();
+    let mut parts = Vec::new();
+    let mut depth = 0usize;
+    let mut start = 0usize;
+    let mut i = 0usize;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'\'' | b'"' | b'`' => {
+                i = skip_mysql_quoted(input, i, bytes[i]);
+                continue;
+            }
+            b'(' => depth += 1,
+            b')' if depth > 0 => depth -= 1,
+            b',' if depth == 0 => {
+                parts.push(input[start..i].trim());
+                start = i + 1;
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    parts.push(input[start..].trim());
+    parts
+}
+
+fn parse_mysql_index_columns(input: &str) -> Vec<String> {
+    split_top_level_csv(input)
+        .into_iter()
+        .filter_map(|part| read_mysql_identifier(part).map(|(column, _)| column))
+        .filter(|column| !column.is_empty())
+        .collect()
+}
+
+fn mysql_keyword_argument(input: &str, keyword: &str) -> Option<String> {
+    let bytes = input.as_bytes();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'\'' | b'"' | b'`' => {
+                i = skip_mysql_quoted(input, i, bytes[i]);
+                continue;
+            }
+            _ if mysql_keyword_at(input, i, keyword) => {
+                return read_mysql_identifier(&input[i + keyword.len()..]).map(|(value, _)| value);
+            }
+            _ => i += 1,
+        }
+    }
+    None
+}
+
+fn mysql_quoted_string_argument(input: &str, keyword: &str) -> Option<String> {
+    let bytes = input.as_bytes();
+    let mut i = 0usize;
+    while i < bytes.len() {
+        match bytes[i] {
+            b'\'' | b'"' | b'`' => {
+                i = skip_mysql_quoted(input, i, bytes[i]);
+                continue;
+            }
+            _ if mysql_keyword_at(input, i, keyword) => {
+                let rest = input[i + keyword.len()..].trim_start();
+                if rest.as_bytes().first().copied() != Some(b'\'') {
+                    return None;
+                }
+                let end = skip_mysql_quoted(rest, 0, b'\'');
+                if end <= 1 || end > rest.len() {
+                    return None;
+                }
+                return Some(rest[1..end - 1].replace("\\'", "'").replace("''", "'"));
+            }
+            _ => i += 1,
+        }
+    }
+    None
+}
+
+pub async fn list_foreign_keys(pool: &MySqlPool, database: &str, table: &str) -> Result<Vec<ForeignKeyInfo>, String> {
+    let column_sql = format!(
+        "SELECT CONSTRAINT_NAME, COLUMN_NAME, REFERENCED_TABLE_SCHEMA, \
+         REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME \
+         FROM information_schema.KEY_COLUMN_USAGE \
+         WHERE TABLE_SCHEMA = {} AND TABLE_NAME = {} \
+         AND REFERENCED_TABLE_NAME IS NOT NULL \
+         ORDER BY CONSTRAINT_NAME, ORDINAL_POSITION",
+        quote_value(database),
+        quote_value(table),
+    );
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let column_result = conn.query_iter(&column_sql).await.map_err(|e| e.to_string())?;
+    let column_rows: Vec<mysql_async::Row> = column_result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    if column_rows.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    // MySQL 5.7 materializes information_schema tables without normal indexes.
+    // Avoid joining two metadata tables because the join can scan the entire catalog.
+    let rule_sql = format!(
+        "SELECT CONSTRAINT_NAME, UPDATE_RULE, DELETE_RULE \
+         FROM information_schema.REFERENTIAL_CONSTRAINTS \
+         WHERE CONSTRAINT_SCHEMA = {} AND TABLE_NAME = {}",
+        quote_value(database),
+        quote_value(table),
+    );
+    let rule_result = conn.query_iter(&rule_sql).await.map_err(|e| e.to_string())?;
+    let rule_rows: Vec<mysql_async::Row> = rule_result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    let rules = rule_rows
+        .iter()
+        .map(|row| {
+            (
+                get_str_by_name(row, "CONSTRAINT_NAME"),
+                (get_str_by_name(row, "UPDATE_RULE"), get_str_by_name(row, "DELETE_RULE")),
+            )
+        })
+        .collect::<HashMap<_, _>>();
+
+    Ok(column_rows
+        .iter()
+        .map(|row| {
+            let name = get_str_by_name(row, "CONSTRAINT_NAME");
+            let (on_update, on_delete) = rules.get(&name).cloned().unwrap_or_default();
+            ForeignKeyInfo {
+                name,
+                column: get_str_by_name(row, "COLUMN_NAME"),
+                ref_schema: Some(get_str_by_name(row, "REFERENCED_TABLE_SCHEMA")),
+                ref_table: get_str_by_name(row, "REFERENCED_TABLE_NAME"),
+                ref_column: get_str_by_name(row, "REFERENCED_COLUMN_NAME"),
+                on_update: Some(on_update).filter(|value| !value.is_empty()),
+                on_delete: Some(on_delete).filter(|value| !value.is_empty()),
+            }
+        })
+        .collect())
+}
+
+pub async fn list_triggers(pool: &MySqlPool, database: &str, table: &str) -> Result<Vec<TriggerInfo>, String> {
+    let sql = format!(
+        "SELECT TRIGGER_NAME, EVENT_MANIPULATION, ACTION_TIMING, ACTION_STATEMENT \
+         FROM information_schema.TRIGGERS \
+         WHERE TRIGGER_SCHEMA = {} AND EVENT_OBJECT_TABLE = {} \
+         ORDER BY TRIGGER_NAME",
+        quote_value(database),
+        quote_value(table),
+    );
+    let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| TriggerInfo {
+            name: get_str_by_name(row, "TRIGGER_NAME"),
+            event: get_str_by_name(row, "EVENT_MANIPULATION"),
+            timing: get_str_by_name(row, "ACTION_TIMING"),
+            statement: Some(get_str_by_name(row, "ACTION_STATEMENT")).filter(|value| !value.is_empty()),
+        })
+        .collect())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::db::connection_timeout;
+    use mysql_async::consts::ColumnFlags;
+
+    #[test]
+    fn mysql_column_type_names_map_to_friendly_names() {
+        use mysql_async::consts::ColumnType::*;
+        assert_eq!(mysql_column_type_name(MYSQL_TYPE_TINY), "tinyint");
+        assert_eq!(mysql_column_type_name(MYSQL_TYPE_LONG), "int");
+        assert_eq!(mysql_column_type_name(MYSQL_TYPE_LONGLONG), "bigint");
+        assert_eq!(mysql_column_type_name(MYSQL_TYPE_NEWDECIMAL), "decimal");
+        assert_eq!(mysql_column_type_name(MYSQL_TYPE_VARCHAR), "varchar");
+        assert_eq!(mysql_column_type_name(MYSQL_TYPE_VAR_STRING), "varchar");
+        assert_eq!(mysql_column_type_name(MYSQL_TYPE_STRING), "char");
+        assert_eq!(mysql_column_type_name(MYSQL_TYPE_DATETIME), "datetime");
+        assert_eq!(mysql_column_type_name(MYSQL_TYPE_JSON), "json");
+        assert_eq!(mysql_column_type_name(MYSQL_TYPE_BLOB), "blob");
+    }
+
+    #[test]
+    fn mysql_with_queries_are_treated_as_result_sets() {
+        let sql = "WITH RECURSIVE org_tree AS (SELECT 1 AS id) SELECT id FROM org_tree";
+        assert!(is_result_set_query(sql, MySqlQueryDialect::default()));
+    }
+
+    #[test]
+    fn mysql_desc_queries_are_treated_as_result_sets() {
+        assert!(is_result_set_query("DESC users", MySqlQueryDialect::default()));
+    }
+
+    #[test]
+    fn mysql_call_queries_are_treated_as_text_result_sets() {
+        let dialect = MySqlQueryDialect::default();
+
+        assert!(is_result_set_query("CALL proc_test1()", dialect));
+        assert!(prefers_text_protocol_query("CALL proc_test1()", dialect));
+    }
+
+    #[test]
+    fn starrocks_admin_show_queries_are_treated_as_result_sets() {
+        let sql = "ADMIN SHOW FRONTEND CONFIG LIKE '%default_replication_num%'";
+        let dialect = MySqlQueryDialect::for_connection(DatabaseType::StarRocks, None);
+
+        assert!(is_result_set_query(sql, dialect));
+        assert!(requires_text_protocol_query(sql, dialect));
+    }
+
+    #[test]
+    fn doris_admin_show_queries_are_treated_as_result_sets() {
+        let sql = "ADMIN SHOW FRONTEND CONFIG LIKE '%default_replication_num%'";
+        let dialect = MySqlQueryDialect::for_connection(DatabaseType::Doris, None);
+
+        assert!(is_result_set_query(sql, dialect));
+        assert!(requires_text_protocol_query(sql, dialect));
+    }
+
+    #[test]
+    fn mysql_starrocks_profile_admin_show_queries_are_treated_as_result_sets() {
+        let sql = "ADMIN SHOW FRONTEND CONFIG LIKE '%default_replication_num%'";
+        let dialect = MySqlQueryDialect::for_connection(DatabaseType::Mysql, Some("starrocks"));
+
+        assert!(is_result_set_query(sql, dialect));
+        assert!(requires_text_protocol_query(sql, dialect));
+    }
+
+    #[test]
+    fn mysql_admin_show_queries_are_not_treated_as_result_sets() {
+        let sql = "ADMIN SHOW FRONTEND CONFIG LIKE '%default_replication_num%'";
+        let dialect = MySqlQueryDialect::for_connection(DatabaseType::Mysql, None);
+
+        assert!(!is_result_set_query(sql, dialect));
+        assert!(!requires_text_protocol_query(sql, dialect));
+    }
+
+    #[test]
+    fn admin_show_detection_skips_leading_comments() {
+        let sql = "-- inspect FE config\nADMIN /* StarRocks */ SHOW FRONTEND CONFIG";
+        let dialect = MySqlQueryDialect::for_connection(DatabaseType::StarRocks, None);
+
+        assert!(is_result_set_query(sql, dialect));
+        assert!(requires_text_protocol_query(sql, dialect));
+    }
+
+    #[test]
+    fn admin_set_queries_are_not_treated_as_result_sets() {
+        let dialect = MySqlQueryDialect::for_connection(DatabaseType::StarRocks, None);
+        assert!(!is_result_set_query("ADMIN SET FRONTEND CONFIG ('default_replication_num' = '1')", dialect));
+    }
+
+    #[test]
+    fn numeric_metadata_accepts_unsigned_information_schema_values() {
+        assert_eq!(numeric_metadata_u64_to_i32(Some(65)), Some(65));
+    }
+
+    #[test]
+    fn numeric_metadata_ignores_values_outside_frontend_range() {
+        assert_eq!(numeric_metadata_u64_to_i32(Some(i32::MAX as u64 + 1)), None);
+        assert_eq!(numeric_metadata_u64_to_i32(None), None);
+    }
+
+    #[test]
+    fn mysql_list_tables_objects_sql_includes_timestamps() {
+        let sql = list_tables_objects_sql("app", None, None, None);
+
+        assert!(sql.contains("information_schema.TABLES"));
+        assert!(!sql.contains("information_schema.ROUTINES"));
+        assert!(!sql.contains("UNION"));
+        assert!(sql.contains("CREATE_TIME"));
+        assert!(sql.contains("UPDATE_TIME"));
+    }
+
+    #[test]
+    fn mysql_list_tables_sql_applies_filter_limit_and_offset() {
+        let sql = list_tables_sql("app", Some("user_%"), Some(101), Some(200), None);
+
+        assert!(sql.contains("FROM information_schema.TABLES"));
+        assert!(sql.contains("TABLE_SCHEMA = 'app'"));
+        assert!(sql.contains("LOWER(TABLE_NAME) LIKE '%user\\\\_\\\\%%' ESCAPE '\\\\'"));
+        assert!(sql.contains("LOWER(TABLE_COMMENT) LIKE '%user\\\\_\\\\%%' ESCAPE '\\\\'"));
+        assert!(sql.contains("LOWER(TABLE_NAME) LIKE '%u%s%e%r%\\\\_%\\\\%%' ESCAPE '\\\\'"));
+        assert!(sql.contains("LOWER(TABLE_COMMENT) LIKE '%u%s%e%r%\\\\_%\\\\%%' ESCAPE '\\\\'"));
+        assert!(sql.contains("ORDER BY TABLE_NAME"));
+        assert!(sql.contains("LIMIT 101"));
+        assert!(sql.contains("OFFSET 200"));
+    }
+
+    #[test]
+    fn mysql_list_tables_sql_adds_fuzzy_filter_pattern() {
+        let sql = list_tables_sql("app", Some("sysu"), Some(100), None, None);
+
+        assert!(sql.contains("LOWER(TABLE_NAME) LIKE '%sysu%' ESCAPE '\\\\'"));
+        assert!(sql.contains("LOWER(TABLE_COMMENT) LIKE '%sysu%' ESCAPE '\\\\'"));
+        assert!(sql.contains("LOWER(TABLE_NAME) LIKE '%s%y%s%u%' ESCAPE '\\\\'"));
+        assert!(sql.contains("LOWER(TABLE_COMMENT) LIKE '%s%y%s%u%' ESCAPE '\\\\'"));
+    }
+
+    #[test]
+    fn mysql_list_tables_sql_skips_fuzzy_filter_for_single_character() {
+        let sql = list_tables_sql("app", Some("u"), Some(100), None, None);
+
+        assert!(sql.contains("LOWER(TABLE_NAME) LIKE '%u%' ESCAPE '\\\\'"));
+        assert!(sql.contains("LOWER(TABLE_COMMENT) LIKE '%u%' ESCAPE '\\\\'"));
+        assert_eq!(sql.matches("LOWER(TABLE_NAME) LIKE").count(), 1);
+        assert_eq!(sql.matches("LOWER(TABLE_COMMENT) LIKE").count(), 1);
+        assert!(!sql.contains(" OR LOWER(TABLE_NAME) LIKE"));
+    }
+
+    #[test]
+    fn mysql_list_tables_sql_filters_table_type_before_pagination() {
+        let tables = vec!["TABLE".to_string()];
+        let table_sql = list_tables_sql("app", None, Some(1000), None, Some(&tables));
+        assert!(table_sql.contains("TABLE_TYPE <> 'VIEW'"));
+        assert!(table_sql.find("TABLE_TYPE <> 'VIEW'") < table_sql.find("ORDER BY TABLE_NAME"));
+        assert!(table_sql.find("ORDER BY TABLE_NAME") < table_sql.find("LIMIT 1000"));
+
+        let views = vec!["VIEW".to_string()];
+        let view_sql = list_tables_sql("app", None, Some(1000), None, Some(&views));
+        assert!(view_sql.contains("TABLE_TYPE = 'VIEW'"));
+    }
+
+    #[test]
+    fn mysql_empty_list_tables_fallback_allows_sidebar_paging_and_type_filters() {
+        assert!(should_fallback_empty_list_tables(None));
+        assert!(should_fallback_empty_list_tables(Some("")));
+        assert!(should_fallback_empty_list_tables(Some("  ")));
+        assert!(!should_fallback_empty_list_tables(Some("missing")));
+    }
+
+    #[test]
+    fn mysql_show_tables_fallback_applies_filter_type_limit_and_offset() {
+        let rows = vec![
+            TableInfo {
+                name: "audit_2024".to_string(),
+                table_type: "BASE TABLE".to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+            TableInfo {
+                name: "audit_view".to_string(),
+                table_type: "VIEW".to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+            TableInfo {
+                name: "audit_2025".to_string(),
+                table_type: "BASE TABLE".to_string(),
+                comment: Some("purchase order history".to_string()),
+                parent_schema: None,
+                parent_name: None,
+            },
+        ];
+        let filtered = filter_list_tables_fallback(rows, Some("audit"), Some(1), Some(1), Some(&["TABLE".to_string()]));
+
+        assert_eq!(filtered.iter().map(|table| table.name.as_str()).collect::<Vec<_>>(), vec!["audit_2025"]);
+
+        let rows = vec![TableInfo {
+            name: "t_0001".to_string(),
+            table_type: "BASE TABLE".to_string(),
+            comment: Some("food orders".to_string()),
+            parent_schema: None,
+            parent_name: None,
+        }];
+        let filtered = filter_list_tables_fallback(rows, Some("ood"), None, None, Some(&["TABLE".to_string()]));
+
+        assert_eq!(filtered.iter().map(|table| table.name.as_str()).collect::<Vec<_>>(), vec!["t_0001"]);
+    }
+
+    #[test]
+    fn mysql_table_comment_sql_targets_single_table() {
+        let sql = table_comment_sql("app", "users");
+
+        assert!(sql.contains("SELECT TABLE_COMMENT"));
+        assert!(sql.contains("TABLE_SCHEMA = 'app'"));
+        assert!(sql.contains("TABLE_NAME = 'users'"));
+        assert!(sql.contains("TABLE_TYPE <> 'VIEW'"));
+        assert!(sql.contains("LIMIT 1"));
+        assert!(!sql.contains("ORDER BY"));
+    }
+
+    #[test]
+    fn mysql_database_infos_filter_blank_names_and_keep_catalogless_marker() {
+        let regular = database_infos_from_names(vec!["".to_string(), " app ".to_string(), "mysql".to_string()], true);
+        assert_eq!(regular.iter().map(|db| db.name.as_str()).collect::<Vec<_>>(), vec!["app", "mysql"]);
+
+        let catalogless = database_infos_from_names(vec!["".to_string(), "   ".to_string()], true);
+        assert_eq!(catalogless.iter().map(|db| db.name.as_str()).collect::<Vec<_>>(), vec![""]);
+
+        let no_marker = database_infos_from_names(vec!["".to_string()], false);
+        assert!(no_marker.is_empty());
+    }
+
+    #[test]
+    fn mysql_show_metadata_sql_supports_catalogless_services() {
+        assert_eq!(show_tables_sql("", true), "SHOW FULL TABLES");
+        assert_eq!(show_tables_sql("", false), "SHOW TABLES");
+        assert_eq!(show_tables_sql("app", true), "SHOW FULL TABLES FROM `app`");
+        assert_eq!(show_columns_sql("", "idx", true), "SHOW FULL COLUMNS FROM `idx`");
+        assert_eq!(show_columns_sql("app", "idx", false), "SHOW COLUMNS FROM `app`.`idx`");
+    }
+
+    #[test]
+    fn mysql_list_routines_sql_is_independent_of_tables() {
+        let sql = list_routines_sql("app", None, None, None);
+
+        assert!(sql.contains("information_schema.ROUTINES"));
+        assert!(!sql.contains("information_schema.TABLES"));
+        assert!(!sql.contains("UNION"));
+        assert!(sql.contains("'PROCEDURE'"));
+        assert!(sql.contains("'FUNCTION'"));
+        assert!(!sql.contains("LAST_ALTERED"));
+        assert!(!sql.contains("CREATED AS created_at"));
+    }
+
+    #[test]
+    fn mysql_list_routines_sql_honors_requested_type_and_paging() {
+        let object_types = vec!["PROCEDURE".to_string()];
+        let sql = list_routines_sql("app", Some(&object_types), Some(101), Some(200));
+
+        assert!(sql.contains("ROUTINE_TYPE IN ('PROCEDURE')"));
+        assert!(!sql.contains("'FUNCTION'"));
+        assert!(sql.ends_with("LIMIT 101 OFFSET 200"));
+    }
+
+    #[test]
+    fn mysql_list_tables_objects_sql_honors_requested_type_and_paging() {
+        let object_types = vec!["VIEW".to_string()];
+        let sql = list_tables_objects_sql("app", Some(&object_types), Some(51), Some(100));
+
+        assert!(sql.contains("TABLE_TYPE = 'VIEW'"));
+        assert!(sql.ends_with("LIMIT 51 OFFSET 100"));
+    }
+
+    #[test]
+    fn mysql_object_query_only_pages_within_one_metadata_source() {
+        assert!(object_query_supports_paging(Some(&["PROCEDURE".to_string()])));
+        assert!(object_query_supports_paging(Some(&["TABLE".to_string(), "VIEW".to_string()])));
+        assert!(!object_query_supports_paging(Some(&["TABLE".to_string(), "PROCEDURE".to_string()])));
+        assert!(!object_query_supports_paging(None));
+    }
+
+    #[test]
+    fn mysql_completion_triggers_sql_lists_database_triggers() {
+        let sql = list_completion_triggers_sql("app");
+
+        assert!(sql.contains("information_schema.TRIGGERS"));
+        assert!(sql.contains("'TRIGGER' AS object_type"));
+        assert!(sql.contains("EVENT_OBJECT_TABLE AS parent_name"));
+        assert!(sql.contains("TRIGGER_SCHEMA = 'app'"));
+    }
+
+    #[test]
+    fn mysql_completion_like_pattern_uses_prefix_by_default() {
+        assert_eq!(mysql_completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Prefix)), "Temp%");
+        assert_eq!(mysql_completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Contains)), "%Temp%");
+        assert_eq!(
+            mysql_completion_like_pattern("order_100%", Some(&CompletionAssistantMatchMode::Prefix)),
+            "order\\_100\\%%"
+        );
+    }
+
+    #[test]
+    fn mysql_completion_sql_filters_before_limit() {
+        let table_sql = mysql_completion_tables_sql(
+            "app",
+            "Temp%",
+            &[CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View],
+            100,
+        );
+        let routine_sql =
+            mysql_completion_routines_sql("app", "%audit%", &[CompletionAssistantObjectKind::Routine], 50);
+        let column_sql = mysql_completion_columns_sql("app", "users", "id%", 25);
+
+        assert!(table_sql.contains("TABLE_NAME LIKE 'Temp%' ESCAPE '\\\\'"));
+        assert!(table_sql.contains("TABLE_TYPE IN ('BASE TABLE','SYSTEM VERSIONED','VIEW')"));
+        assert!(table_sql.contains("ORDER BY TABLE_NAME LIMIT 100"));
+        assert!(routine_sql.contains("ROUTINE_NAME LIKE '%audit%' ESCAPE '\\\\'"));
+        assert!(routine_sql.contains("ROUTINE_TYPE IN ('PROCEDURE','FUNCTION')"));
+        assert!(column_sql.contains("COLUMN_NAME LIKE 'id%' ESCAPE '\\\\'"));
+        assert!(column_sql.contains("ORDER BY ORDINAL_POSITION LIMIT 25"));
+    }
+
+    #[test]
+    fn mysql_columns_sql_uses_column_key_for_primary_keys_without_join() {
+        let sql = columns_sql("app", "users");
+
+        assert!(sql.contains("information_schema.COLUMNS"));
+        assert!(!sql.contains("KEY_COLUMN_USAGE"));
+        assert!(!sql.contains("CONSTRAINT_NAME = 'PRIMARY'"));
+        assert!(sql.contains("c.COLUMN_KEY"));
+        assert!(sql.contains("c.DATA_TYPE"));
+        assert!(sql.contains("c.COLUMN_TYPE"));
+        assert!(!sql.contains("COLLATE"));
+        assert!(!sql.contains("AS ENUM_VALUES"));
+    }
+
+    #[test]
+    fn parse_mysql_enum_values_preserves_mysql_literal_edges() {
+        assert_eq!(
+            parse_mysql_enum_values("enum('pending','active','archived')"),
+            Some(vec!["pending".to_string(), "active".to_string(), "archived".to_string()])
+        );
+        assert_eq!(parse_mysql_enum_values("ENUM('','a')"), Some(vec!["".to_string(), "a".to_string()]));
+        assert_eq!(parse_mysql_enum_values("enum('x'',''y','z')"), Some(vec!["x','y".to_string(), "z".to_string()]));
+        assert_eq!(
+            parse_mysql_enum_values(r#"enum('it''s','quote\"d','back\\slash')"#),
+            Some(vec!["it's".to_string(), "quote\"d".to_string(), "back\\slash".to_string()])
+        );
+        assert_eq!(parse_mysql_enum_values("varchar(255)"), None);
+    }
+
+    #[test]
+    fn doris_create_table_ddl_indexes_include_unique_key_and_inverted_indexes() {
+        let ddl = r#"
+CREATE TABLE `bfm_org` (
+  `org_id` bigint NULL,
+  `ORG_CODE` varchar(255) NULL,
+  `ORG_NAME` varchar(255) NULL,
+  INDEX org_id_idx (`org_id`) USING INVERTED,
+  INDEX org_code_idx (`ORG_CODE`) USING INVERTED,
+  INDEX org_name_idx (`ORG_NAME`) USING INVERTED
+) ENGINE=OLAP
+UNIQUE KEY(`org_id`)
+COMMENT '部门信息表'
+DISTRIBUTED BY HASH(`org_id`) BUCKETS 4
+"#;
+
+        let indexes = doris_indexes_from_create_table_ddl(ddl);
+
+        assert_eq!(indexes.len(), 4);
+        assert_eq!(indexes[0].name, "org_id_idx");
+        assert_eq!(indexes[0].columns, vec!["org_id"]);
+        assert!(!indexes[0].is_unique);
+        assert_eq!(indexes[0].index_type.as_deref(), Some("INVERTED"));
+        assert_eq!(indexes[3].name, "UNIQUE KEY");
+        assert_eq!(indexes[3].columns, vec!["org_id"]);
+        assert!(indexes[3].is_unique);
+        assert!(!indexes[3].is_primary);
+        assert_eq!(indexes[3].index_type.as_deref(), Some("UNIQUE KEY"));
+    }
+
+    #[test]
+    fn doris_create_table_ddl_index_parser_handles_quoted_names_and_comments() {
+        let ddl = r#"
+CREATE TABLE `search_test` (
+  `name``part` varchar(64) NULL,
+  INDEX `idx``name` (`name``part`) USING NGRAM_BF COMMENT 'name''s index'
+) ENGINE=OLAP
+UNIQUE KEY(`tenant_id`, `name``part`)
+"#;
+
+        let indexes = doris_indexes_from_create_table_ddl(ddl);
+
+        assert_eq!(indexes.len(), 2);
+        assert_eq!(indexes[0].name, "idx`name");
+        assert_eq!(indexes[0].columns, vec!["name`part"]);
+        assert_eq!(indexes[0].index_type.as_deref(), Some("NGRAM_BF"));
+        assert_eq!(indexes[0].comment.as_deref(), Some("name's index"));
+        assert_eq!(indexes[1].columns, vec!["tenant_id", "name`part"]);
+        assert!(indexes[1].is_unique);
+    }
+
+    #[test]
+    fn mysql_largeint_uses_lossless_integer_decoding() {
+        assert!(is_mysql_lossless_integer_type("LARGEINT"));
+    }
+
+    fn mysql_test_column(
+        column_type: ColumnType,
+        character_set: u16,
+        flags: ColumnFlags,
+        column_length: u32,
+    ) -> mysql_async::Column {
+        mysql_async::Column::new(column_type)
+            .with_character_set(character_set)
+            .with_flags(flags)
+            .with_column_length(column_length)
+    }
+
+    #[test]
+    fn mysql_binary_preview_keeps_binary_collation_varchar_as_text() {
+        let column = mysql_test_column(ColumnType::MYSQL_TYPE_VAR_STRING, 45, ColumnFlags::BINARY_FLAG, 64);
+
+        assert_eq!(mysql_bytes_to_json(b"SN-A0001".to_vec(), &column), serde_json::json!("SN-A0001"));
+    }
+
+    #[test]
+    fn mysql_binary_preview_renders_binary_and_varbinary_like_navicat_text_preview() {
+        let binary_column = mysql_test_column(ColumnType::MYSQL_TYPE_STRING, 63, ColumnFlags::BINARY_FLAG, 8);
+        let varbinary_column = mysql_test_column(ColumnType::MYSQL_TYPE_VAR_STRING, 63, ColumnFlags::BINARY_FLAG, 8);
+
+        assert_eq!(mysql_bytes_to_json(b"150010\0\0".to_vec(), &binary_column), serde_json::json!("150010"));
+        assert_eq!(mysql_bytes_to_json(b"150010".to_vec(), &varbinary_column), serde_json::json!("150010"));
+    }
+
+    #[test]
+    fn mysql_binary_preview_falls_back_to_hex_for_unprintable_bytes() {
+        let binary_column = mysql_test_column(ColumnType::MYSQL_TYPE_STRING, 63, ColumnFlags::BINARY_FLAG, 8);
+        let varbinary_column = mysql_test_column(ColumnType::MYSQL_TYPE_VAR_STRING, 63, ColumnFlags::BINARY_FLAG, 8);
+
+        assert_eq!(mysql_bytes_to_json(vec![0x01, 0x02, 0x03, 0x04], &binary_column), serde_json::json!("0x01020304"));
+        assert_eq!(
+            mysql_bytes_to_json(vec![0xde, 0xad, 0xbe, 0xef], &varbinary_column),
+            serde_json::json!("0xdeadbeef")
+        );
+    }
+
+    #[test]
+    fn mysql_binary_preview_uses_charset_to_separate_blob_from_text() {
+        let text_column = mysql_test_column(ColumnType::MYSQL_TYPE_BLOB, 45, ColumnFlags::empty(), 65_535);
+        let blob_column = mysql_test_column(ColumnType::MYSQL_TYPE_BLOB, 63, ColumnFlags::BLOB_FLAG, 65_535);
+
+        assert_eq!(mysql_bytes_to_json(b"hello".to_vec(), &text_column), serde_json::json!("hello"));
+        assert_eq!(mysql_bytes_to_json(vec![0x00, 0x01, 0xab, 0xff], &blob_column), serde_json::json!("0x0001abff"));
+    }
+
+    #[test]
+    fn mysql_bit_preview_uses_boolean_or_bit_string_text() {
+        let bit_one = mysql_test_column(ColumnType::MYSQL_TYPE_BIT, 63, ColumnFlags::UNSIGNED_FLAG, 1);
+        let bit_eight = mysql_test_column(ColumnType::MYSQL_TYPE_BIT, 63, ColumnFlags::UNSIGNED_FLAG, 8);
+
+        assert_eq!(mysql_bit_value_to_string(&[1], &bit_one), "1");
+        assert_eq!(mysql_bit_value_to_string(&[0b1010_1010], &bit_eight), "10101010");
+    }
+
+    #[test]
+    fn mysql_column_key_marks_primary() {
+        let column_key = "PRI";
+        let is_pk = column_key.eq_ignore_ascii_case("PRI");
+        assert!(is_pk);
+    }
+
+    #[test]
+    fn mysql_management_show_queries_use_text_protocol() {
+        assert!(requires_text_protocol_query("SHOW PROCESSLIST", MySqlQueryDialect::default()));
+        assert!(requires_text_protocol_query("show full processlist", MySqlQueryDialect::default()));
+        assert!(requires_text_protocol_query("SHOW SLAVE STATUS", MySqlQueryDialect::default()));
+        assert!(requires_text_protocol_query("show replica status", MySqlQueryDialect::default()));
+        assert!(requires_text_protocol_query("SHOW GRANTS", MySqlQueryDialect::default()));
+        assert!(requires_text_protocol_query("SHOW GRANTS FOR 'repl'@'%'", MySqlQueryDialect::default()));
+        assert!(!requires_text_protocol_query("SHOW TABLES", MySqlQueryDialect::default()));
+        assert!(!requires_text_protocol_query("SELECT * FROM users", MySqlQueryDialect::default()));
+    }
+
+    #[test]
+    fn mysql_user_result_sets_prefer_text_protocol() {
+        let dialect = MySqlQueryDialect::default();
+
+        assert!(prefers_text_protocol_query("SELECT * FROM users", dialect));
+        assert!(prefers_text_protocol_query("WITH recent AS (SELECT 1 AS id) SELECT id FROM recent", dialect));
+        assert!(prefers_text_protocol_query("SHOW TABLES", dialect));
+        assert!(!prefers_text_protocol_query("UPDATE users SET name = 'Ada' WHERE id = 1", dialect));
+    }
+
+    #[test]
+    fn mysql_text_result_sets_use_buffered_collection_for_bounded_page_queries() {
+        assert!(should_collect_text_result_set("SELECT * FROM users LIMIT 100;", 100, Some(100)));
+        assert!(should_collect_text_result_set("SELECT * FROM users ORDER BY id LIMIT 25 OFFSET 50;", 100, Some(100)));
+        assert!(should_collect_text_result_set("SELECT * FROM users LIMIT 20, 50;", 100, Some(100)));
+    }
+
+    #[test]
+    fn mysql_text_result_sets_keep_streaming_when_unbounded_or_too_large() {
+        assert!(!should_collect_text_result_set("SELECT * FROM users", 100, Some(100)));
+        assert!(!should_collect_text_result_set("SELECT * FROM users LIMIT 1000000", 100, Some(100)));
+        assert!(!should_collect_text_result_set("SELECT * FROM users LIMIT 100", 100, None));
+        assert!(!should_collect_text_result_set("SELECT * FROM (SELECT * FROM audit LIMIT 100) t", 100, Some(100)));
+    }
+
+    #[test]
+    fn mysql_binary_decode_parse_errors_retry_with_text_protocol() {
+        assert!(mysql_error_should_retry_with_text_protocol(
+            "Input/output error: can't parse: buf doesn't have enough data"
+        ));
+    }
+
+    #[test]
+    fn mysql_timestamp_default_null_ddl_enables_explicit_defaults() {
+        let create_sql = r#"
+            CREATE TABLE `referral_record` (
+                `id` BINARY(16) NOT NULL,
+                `created_at` TIMESTAMP(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
+                `updated_at` TIMESTAMP(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6),
+                `deleted_at` TIMESTAMP(6) DEFAULT NULL,
+                PRIMARY KEY (`id`)
+            ) ENGINE = InnoDB
+        "#;
+
+        assert!(should_enable_explicit_timestamp_defaults(create_sql));
+        assert!(should_enable_explicit_timestamp_defaults(
+            "ALTER TABLE referral_record ADD deleted_at TIMESTAMP DEFAULT NULL"
+        ));
+        assert!(!should_enable_explicit_timestamp_defaults("CREATE TABLE t (deleted_at DATETIME(6) DEFAULT NULL)"));
+        assert!(!should_enable_explicit_timestamp_defaults("SELECT 'TIMESTAMP DEFAULT NULL'"));
+        assert_eq!(explicit_timestamp_defaults_sql(true), "SET SESSION explicit_defaults_for_timestamp = ON");
+        assert_eq!(explicit_timestamp_defaults_sql(false), "SET SESSION explicit_defaults_for_timestamp = OFF");
+    }
+
+    #[test]
+    fn mysql_tls_session_close_errors_retry_without_ssl() {
+        let error = "MySQL connection failed: error communicating with database: \
+            encountered error while attempting to establish a TLS connection: \
+            server closed session with no notification";
+
+        assert!(mysql_error_should_retry_without_ssl(error));
+    }
+
+    #[test]
+    fn mysql_server_without_ssl_capability_retries_without_ssl() {
+        let error =
+            "MySQL connection failed: Driver error: `Client asked for SSL but server does not have this capability'";
+
+        assert!(mysql_error_should_retry_without_ssl(error));
+    }
+
+    #[test]
+    fn mysql_packet_out_of_order_can_retry_without_ssl() {
+        let error = "MySQL connection failed: Input/output error: Input/output error: packet out of order";
+
+        assert!(mysql_error_should_retry_without_ssl(error));
+    }
+
+    #[test]
+    fn mysql_tcp_keepalive_uses_milliseconds_not_seconds() {
+        assert_eq!(MYSQL_TCP_KEEPALIVE_MS, 30_000);
+        assert!(MYSQL_TCP_KEEPALIVE_MS >= 1_000);
+    }
+
+    #[test]
+    fn mysql_async_builder_host_strips_ipv6_url_brackets() {
+        let opts = mysql_async::Opts::from_url("mysql://root:secret@[2001:db8::1]:3306/app").unwrap();
+
+        assert_eq!(opts.ip_or_hostname(), "[2001:db8::1]");
+        assert_eq!(mysql_async_tcp_host(opts.ip_or_hostname()), "2001:db8::1");
+
+        let builder_opts = mysql_async::Opts::from(
+            mysql_async::OptsBuilder::from_opts(opts).ip_or_hostname(mysql_async_tcp_host("[2001:db8::1]").to_string()),
+        );
+        assert_eq!(builder_opts.ip_or_hostname(), "2001:db8::1");
+        assert_eq!(builder_opts.tcp_port(), 3306);
+    }
+
+    #[test]
+    fn mysql_async_builder_host_only_strips_valid_ipv6_literals() {
+        assert_eq!(mysql_async_tcp_host("2001:db8::1"), "2001:db8::1");
+        assert_eq!(mysql_async_tcp_host("[mysql.example.com]"), "[mysql.example.com]");
+        assert_eq!(mysql_async_tcp_host("mysql.example.com"), "mysql.example.com");
+    }
+
+    #[test]
+    fn mysql_tls_url_strips_client_identity_params_before_driver_parse() {
+        let dir = std::env::temp_dir();
+        let cert = dir.join(format!("dbx-mysql-client-cert-{}.pem", std::process::id()));
+        let key = dir.join(format!("dbx-mysql-client-key-{}.pem", std::process::id()));
+        std::fs::write(&cert, "not a real cert").unwrap();
+        std::fs::write(&key, "not a real key").unwrap();
+
+        let url = format!(
+            "mysql://root:secret@localhost/test?require_ssl=true&ssl-cert={}&ssl-key={}&charset=utf8mb4",
+            cert.display(),
+            key.display()
+        );
+        let parsed = mysql_tls_url(&url).unwrap();
+
+        assert_eq!(parsed.url, "mysql://root:secret@localhost/test?require_ssl=true&charset=utf8mb4");
+        assert_eq!(parsed.files.sslcert.as_deref(), Some(cert.to_str().unwrap()));
+        assert_eq!(parsed.files.sslkey.as_deref(), Some(key.to_str().unwrap()));
+        mysql_async::Opts::from_url(&mysql_async_url(&parsed.url)).unwrap();
+
+        let _ = std::fs::remove_file(cert);
+        let _ = std::fs::remove_file(key);
+    }
+
+    #[test]
+    fn mysql_tls_rejects_unpaired_client_cert_and_key() {
+        let files = MySqlTlsFiles { sslcert: Some("/tmp/client.crt".to_string()), sslkey: None };
+
+        let error = mysql_ssl_opts(None, "mysql://root@localhost/db?require_ssl=true", None, &files).unwrap_err();
+        assert!(error.contains("ssl-key"));
+    }
+
+    #[test]
+    fn mysql_tls_client_identity_requires_ssl() {
+        assert!(mysql_url_requires_ssl("mysql://root@localhost/db?ssl-cert=/tmp/client.crt&ssl-key=/tmp/client.key"));
+    }
+
+    #[test]
+    fn mysql_preferred_tls_attempts_ssl_without_requiring_it() {
+        let url = "mysql://root@localhost/db?ssl-mode=preferred&charset=utf8mb4";
+
+        assert!(!mysql_url_requires_ssl(url));
+        assert!(mysql_url_attempts_ssl(url));
+        assert_eq!(
+            ssl_fallback_url(url),
+            Some("mysql://root@localhost/db?ssl-mode=disabled&charset=utf8mb4".to_string())
+        );
+        assert!(mysql_ssl_opts(None, url, None, &MySqlTlsFiles::default()).unwrap().is_some());
+    }
+
+    #[test]
+    fn mysql_preferred_tls_handles_sslmode_prefer_alias() {
+        let url = "mysql://root@localhost/db?sslmode=prefer&charset=utf8mb4#session";
+
+        assert!(!mysql_url_requires_ssl(url));
+        assert!(mysql_url_attempts_ssl(url));
+        assert_eq!(
+            ssl_fallback_url(url),
+            Some("mysql://root@localhost/db?ssl-mode=disabled&charset=utf8mb4#session".to_string())
+        );
+        assert_eq!(
+            ssl_fallback_url("mysql://root@localhost/db#session"),
+            Some("mysql://root@localhost/db?ssl-mode=disabled#session".to_string())
+        );
+    }
+
+    #[test]
+    fn mysql_unknown_error_can_retry_with_text_protocol() {
+        let error = "error returned from database: 1105 (HY000): Unknown error";
+
+        assert!(mysql_error_should_retry_with_text_protocol(error));
+    }
+
+    #[test]
+    fn mysql_unsupported_prepare_command_can_retry_with_text_protocol() {
+        let error = "ERROR PX000 (3000): [a2jupsonbbv6zai1gomo5whu36ndqy] Unsupported command: COM_STMT_PREPARE";
+
+        assert!(mysql_error_should_retry_with_text_protocol(error));
+    }
+
+    #[test]
+    fn mysql_reprepared_statement_error_can_retry_with_text_protocol() {
+        let error = "Server error: ERROR HY000 (1615): Prepared statement needs to be re-prepared";
+
+        assert!(mysql_error_should_retry_with_text_protocol(error));
+    }
+
+    #[test]
+    fn mysql_group_concat_setup_error_retries_without_session_variable() {
+        let error = "MySQL connection failed: Server error: `ERROR HY000 (1193): Unknown system variable,stmt:SET @@group_concat_max_len = 1048576'";
+
+        assert!(mysql_error_should_retry_without_group_concat_max_len(error));
+        assert_eq!(
+            mysql_setup_mode_retry_without_group_concat(MySqlSetupMode::Standard, error),
+            Some(MySqlSetupMode::Compatible)
+        );
+    }
+
+    #[test]
+    fn mysql_group_concat_setup_retry_is_narrow() {
+        assert!(!mysql_error_should_retry_without_group_concat_max_len(
+            "MySQL connection failed: Server error: `ERROR HY000 (1193): Unknown system variable,stmt:SET @@sql_mode = ANSI'"
+        ));
+        assert_eq!(
+            mysql_setup_mode_retry_without_group_concat(
+                MySqlSetupMode::Compatible,
+                "Server error: ERROR HY000 (1193): Unknown system variable,stmt:SET @@group_concat_max_len = 1048576"
+            ),
+            None
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_select_requested_database_before_session_init() {
+        let queries = mysql_setup_queries("mysql://root:secret@localhost:3306/app?charset=utf8mb4", &[]);
+
+        assert_eq!(queries, vec!["USE `app`", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]);
+    }
+
+    #[test]
+    fn mysql_setup_queries_skip_use_when_database_missing() {
+        let queries = mysql_setup_queries("mysql://root:secret@localhost:3306?charset=utf8mb4", &[]);
+
+        assert_eq!(queries, vec!["SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]);
+    }
+
+    #[test]
+    fn mysql_compatible_setup_queries_skip_group_concat_variable() {
+        let queries = mysql_setup_queries_with_mode(
+            "mysql://root:secret@localhost:9030/analytics?charset=utf8mb4",
+            &[],
+            MySqlSetupMode::Compatible,
+        );
+
+        assert_eq!(queries, vec!["USE `analytics`", "SET NAMES utf8mb4"]);
+    }
+
+    #[test]
+    fn mysql_compatible_setup_queries_keep_catalog_and_extra_queries() {
+        let extra = vec!["SET ob_query_timeout = 30000000".to_string()];
+        let queries = mysql_setup_queries_with_mode(
+            "mysql://root:secret@localhost:9030/clip?catalog=paimon_catalog",
+            &extra,
+            MySqlSetupMode::Compatible,
+        );
+
+        assert_eq!(
+            queries,
+            vec![
+                "USE `clip`",
+                "SET NAMES utf8mb4",
+                "SET catalog = `paimon_catalog`",
+                "SET ob_query_timeout = 30000000"
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_decode_database_name_from_url() {
+        let queries = mysql_setup_queries("mysql://root:secret@localhost:3306/db%2Fname?charset=utf8mb4", &[]);
+
+        assert_eq!(queries, vec!["USE `db/name`", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]);
+    }
+
+    #[test]
+    fn mysql_setup_queries_can_select_database_without_url_path() {
+        let queries = mysql_setup_queries_for_database(
+            "mysql://root:secret@localhost:3306?charset=utf8mb4",
+            Some("app`proxy"),
+            &[],
+        );
+
+        assert_eq!(queries, vec!["USE `app``proxy`", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]);
+    }
+
+    #[test]
+    fn mysql_datetime_utc_values_display_without_rfc3339_offset() {
+        let value = NaiveDateTime::new(
+            NaiveDate::from_ymd_opt(2026, 5, 12).unwrap(),
+            NaiveTime::from_hms_opt(0, 0, 0).unwrap(),
+        );
+
+        assert_eq!(mysql_datetime_to_string(value), "2026-05-12 00:00:00");
+    }
+
+    #[test]
+    fn mysql_date_values_display_without_midnight_time() {
+        let date = NaiveDate::from_ymd_opt(2026, 6, 10).unwrap();
+        let datetime = date.and_hms_opt(0, 0, 0).unwrap();
+
+        assert_eq!(
+            mysql_temporal_value_to_json(ColumnType::MYSQL_TYPE_DATE, Some(datetime), Some(date), None),
+            Some(serde_json::json!("2026-06-10"))
+        );
+    }
+
+    #[test]
+    fn mysql_datetime_values_keep_time_component() {
+        let datetime = NaiveDate::from_ymd_opt(2026, 6, 10).unwrap().and_hms_opt(12, 34, 56).unwrap();
+
+        assert_eq!(
+            mysql_temporal_value_to_json(ColumnType::MYSQL_TYPE_DATETIME, Some(datetime), None, None),
+            Some(serde_json::json!("2026-06-10 12:34:56"))
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires remote MariaDB with ed25519 user"]
+    async fn test_ed25519_auth() {
+        let url = "mysql://edtest:test123@172.26.128.159:20026/testdb";
+        let pool = super::connect(url, std::time::Duration::from_secs(5)).await.expect("connect with ed25519");
+        let mut conn = pool.get_conn().await.expect("get connection");
+        conn.ping().await.expect("ping");
+        let _ = conn.disconnect().await;
+        let _ = pool.disconnect().await;
+    }
+
+    #[test]
+    fn parse_connect_timeout_extracts_underscore_form() {
+        let url = "mysql://host:3306/db?connect_timeout=30";
+        assert_eq!(crate::db::parse_connect_timeout(url), Duration::from_secs(30));
+    }
+
+    #[test]
+    fn parse_connect_timeout_extracts_camelcase_form() {
+        let url = "mysql://host:3306/db?connectTimeout=60";
+        assert_eq!(crate::db::parse_connect_timeout(url), Duration::from_secs(60));
+    }
+
+    #[test]
+    fn parse_connect_timeout_ignores_out_of_range() {
+        let default = connection_timeout();
+        let url = "mysql://host:3306/db?connect_timeout=999";
+        assert_eq!(crate::db::parse_connect_timeout(url), default);
+        let url2 = "mysql://host:3306/db?connect_timeout=0";
+        assert_eq!(crate::db::parse_connect_timeout(url2), default);
+    }
+
+    #[test]
+    fn parse_connect_timeout_returns_default_when_missing() {
+        let default = connection_timeout();
+        let url = "mysql://host:3306/db?ssl-mode=preferred&charset=utf8mb4";
+        assert_eq!(crate::db::parse_connect_timeout(url), default);
+    }
+
+    #[test]
+    fn parse_connect_timeout_returns_default_when_no_query() {
+        let default = connection_timeout();
+        let url = "mysql://host:3306/db";
+        assert_eq!(crate::db::parse_connect_timeout(url), default);
+    }
+
+    #[test]
+    fn mysql_async_url_translates_standard_required_ssl_mode() {
+        let url = "mysql://host:3306/db?ssl-mode=required&charset=utf8mb4";
+
+        assert_eq!(
+            mysql_async_url(url).as_ref(),
+            "mysql://host:3306/db?require_ssl=true&verify_ca=false&verify_identity=false"
+        );
+    }
+
+    #[test]
+    fn mysql_async_url_translates_preferred_ssl_mode_to_tls_attempt() {
+        let url = "mysql://host:3306/db?ssl-mode=preferred&charset=utf8mb4";
+
+        assert_eq!(
+            mysql_async_url(url).as_ref(),
+            "mysql://host:3306/db?require_ssl=true&verify_ca=false&verify_identity=false"
+        );
+    }
+
+    #[test]
+    fn mysql_async_url_translates_disabled_ssl_mode_even_when_param_count_matches() {
+        let url = "mysql://host:3306/db?ssl-mode=disabled";
+
+        assert_eq!(mysql_async_url(url).as_ref(), "mysql://host:3306/db?require_ssl=false");
+    }
+
+    #[test]
+    fn mysql_async_url_translates_verify_identity_ssl_mode_even_when_param_count_matches() {
+        let url = "mysql://host:3306/db?sslmode=verify_identity";
+
+        assert_eq!(mysql_async_url(url).as_ref(), "mysql://host:3306/db?require_ssl=true");
+    }
+
+    #[test]
+    fn mysql_async_url_strips_jdbc_params() {
+        let url = "mysql://host:3306/db?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true";
+        assert_eq!(mysql_async_url(url).as_ref(), "mysql://host:3306/db");
+    }
+
+    #[test]
+    fn mysql_async_url_keeps_valid_params_while_stripping_jdbc() {
+        let url = "mysql://host:3306/db?useUnicode=true&characterEncoding=utf8&require_ssl=true&charset=utf8mb4&autoReconnect=true&allowMultiQueries=true";
+        assert_eq!(mysql_async_url(url).as_ref(), "mysql://host:3306/db?require_ssl=true");
+    }
+
+    #[test]
+    fn mysql_async_url_normalizes_cleartext_password_auth_alias() {
+        let url = "mysql://host:3306/db?allowCleartextPasswords=true&charset=utf8mb4";
+        assert_eq!(mysql_async_url(url).as_ref(), "mysql://host:3306/db?enable_cleartext_plugin=true");
+    }
+
+    #[test]
+    fn mysql_async_url_deduplicates_cleartext_password_auth_params() {
+        let url = "mysql://host:3306/db?allowCleartextPasswords=true&enable_cleartext_plugin=true&require_ssl=true";
+        assert_eq!(mysql_async_url(url).as_ref(), "mysql://host:3306/db?require_ssl=true&enable_cleartext_plugin=true");
+    }
+
+    #[test]
+    fn mysql_async_url_omits_disabled_cleartext_password_auth_params() {
+        let url = "mysql://host:3306/db?allowCleartextPasswords=false&enable_cleartext_plugin=&require_ssl=true";
+        assert_eq!(mysql_async_url(url).as_ref(), "mysql://host:3306/db?require_ssl=true");
+    }
+
+    #[test]
+    fn mysql_async_url_strips_go_and_timezone_compat_params() {
+        let url = "mysql://host:3306/db?charset=utf8mb4&parseTime=True&loc=Local&connectionTimeZone=Asia%2FShanghai&forceConnectionTimeZoneToSession=true&require_ssl=true";
+
+        assert_eq!(mysql_async_url(url).as_ref(), "mysql://host:3306/db?require_ssl=true");
+    }
+
+    #[test]
+    fn mysql_async_url_strips_database_path_when_catalog_present() {
+        // With a catalog configured, the database path must not reach mysql_async
+        // (it would be sent as the handshake schema and rejected before SET catalog).
+        assert_eq!(
+            mysql_async_url("mysql://root:secret@host:3306/clip?catalog=paimon_catalog").as_ref(),
+            "mysql://root:secret@host:3306"
+        );
+        assert_eq!(
+            mysql_async_url("mysql://host:3306/clip?catalog=paimon_catalog&require_ssl=true").as_ref(),
+            "mysql://host:3306?require_ssl=true"
+        );
+    }
+
+    #[test]
+    fn mysql_async_url_keeps_database_path_when_catalog_absent() {
+        assert_eq!(
+            mysql_async_url("mysql://host:3306/clip?require_ssl=true").as_ref(),
+            "mysql://host:3306/clip?require_ssl=true"
+        );
+        assert_eq!(mysql_async_url("mysql://host:3306/clip").as_ref(), "mysql://host:3306/clip");
+    }
+
+    #[test]
+    fn ssl_fallback_does_not_disable_required_tls() {
+        assert_eq!(ssl_fallback_url("mysql://host:3306/db?require_ssl=true&charset=utf8mb4"), None);
+        assert_eq!(ssl_fallback_url("mysql://host:3306/db?ssl-mode=verify_ca&charset=utf8mb4"), None);
+    }
+
+    #[test]
+    fn mysql_setup_queries_default_to_utf8mb4() {
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db", &[]),
+            vec!["USE `db`", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_use_safe_custom_charset() {
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db?ssl-mode=preferred&charset=gbk", &[]),
+            vec!["USE `db`", "SET NAMES gbk", "SET @@group_concat_max_len = 1048576"]
+        );
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db?charset=utf8mb4;DROP TABLE users", &[]),
+            vec!["USE `db`", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_include_extra_setup_queries() {
+        let extra = vec!["SET ob_query_timeout = 30000000".to_string()];
+
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db", &extra),
+            vec![
+                "USE `db`",
+                "SET NAMES utf8mb4",
+                "SET @@group_concat_max_len = 1048576",
+                "SET ob_query_timeout = 30000000"
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_apply_explicit_time_zone() {
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db?time_zone=%2B08%3A00&charset=utf8mb4", &[]),
+            vec!["USE `db`", "SET time_zone = '+08:00'", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]
+        );
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db?time-zone=Asia%2FShanghai", &[]),
+            vec![
+                "USE `db`",
+                "SET time_zone = 'Asia/Shanghai'",
+                "SET NAMES utf8mb4",
+                "SET @@group_concat_max_len = 1048576"
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_apply_jdbc_time_zone_aliases() {
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db?serverTimezone=GMT%2B8", &[]),
+            vec!["USE `db`", "SET time_zone = '+08:00'", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]
+        );
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db?connectionTimeZone=UTC", &[]),
+            vec!["USE `db`", "SET time_zone = '+00:00'", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_apply_go_loc_when_no_explicit_time_zone_exists() {
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db?loc=Asia%2FShanghai", &[]),
+            vec![
+                "USE `db`",
+                "SET time_zone = 'Asia/Shanghai'",
+                "SET NAMES utf8mb4",
+                "SET @@group_concat_max_len = 1048576"
+            ]
+        );
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db?time_zone=%2B08%3A00&loc=UTC", &[]),
+            vec!["USE `db`", "SET time_zone = '+08:00'", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_ignore_unsafe_time_zone_values() {
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db?time_zone=%2B08%3A00%27%3BDROP%20TABLE%20users", &[]),
+            vec!["USE `db`", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_switch_catalog_when_present() {
+        // `SET catalog` is pushed last so mysql_async's back-to-front setup
+        // execution (Vec::pop) runs it before `USE <database>`.
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/clip?catalog=paimon_catalog", &[]),
+            vec![
+                "USE `clip`",
+                "SET NAMES utf8mb4",
+                "SET @@group_concat_max_len = 1048576",
+                "SET catalog = `paimon_catalog`"
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_switch_catalog_without_database() {
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/?catalog=paimon_catalog", &[]),
+            vec!["SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576", "SET catalog = `paimon_catalog`"]
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_decodes_catalog_parameter() {
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db?catalog=my%5Fcatalog", &[]),
+            vec!["USE `db`", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576", "SET catalog = `my_catalog`"]
+        );
+    }
+
+    #[test]
+    fn mysql_setup_queries_omits_catalog_when_absent() {
+        assert_eq!(
+            mysql_setup_queries("mysql://host:3306/db?charset=utf8mb4", &[]),
+            vec!["USE `db`", "SET NAMES utf8mb4", "SET @@group_concat_max_len = 1048576"]
+        );
+    }
+
+    fn doris_catalog_info(name: &str, catalog_type: &str, is_current: bool) -> crate::db::CatalogInfo {
+        crate::db::CatalogInfo {
+            name: name.to_string(),
+            catalog_type: catalog_type.to_string(),
+            is_current,
+            comment: None,
+        }
+    }
+
+    #[test]
+    fn doris_catalog_database_ref_backtick_qualifies_two_parts() {
+        assert_eq!(doris_catalog_database_ref("iceberg_catalog", "sales"), "`iceberg_catalog`.`sales`");
+    }
+
+    #[test]
+    fn doris_catalog_table_ref_backtick_qualifies_three_parts() {
+        assert_eq!(doris_catalog_table_ref("iceberg_catalog", "sales", "orders"), "`iceberg_catalog`.`sales`.`orders`");
+    }
+
+    #[test]
+    fn doris_catalog_refs_escape_embedded_backticks() {
+        assert_eq!(doris_catalog_database_ref("a`b", "c`d"), "`a``b`.`c``d`");
+        assert_eq!(doris_catalog_table_ref("a`b", "c`d", "e`f"), "`a``b`.`c``d`.`e``f`");
+    }
+
+    #[test]
+    fn normalize_doris_catalogs_does_not_inject_missing_internal() {
+        // SHOW CATALOGS always lists the built-in catalog on both engines, so a
+        // missing internal catalog is not synthesized — the caller's flat-sidebar
+        // fallback handles a single/empty result instead.
+        let catalogs = vec![
+            doris_catalog_info("iceberg_catalog", "iceberg", true),
+            doris_catalog_info("hive_catalog", "hive", false),
+        ];
+        let normalized = normalize_doris_catalogs(catalogs);
+        let names: Vec<&str> = normalized.iter().map(|c| c.name.as_str()).collect();
+        assert_eq!(names, vec!["hive_catalog", "iceberg_catalog"]);
+        assert!(!normalized.iter().any(|c| c.is_internal()));
+    }
+
+    #[test]
+    fn normalize_doris_catalogs_keeps_existing_internal_first() {
+        let catalogs = vec![
+            doris_catalog_info("iceberg_catalog", "iceberg", false),
+            doris_catalog_info("internal", "internal", true),
+            doris_catalog_info("hive_catalog", "hive", false),
+        ];
+        let normalized = normalize_doris_catalogs(catalogs);
+        let names: Vec<&str> = normalized.iter().map(|c| c.name.as_str()).collect();
+        assert_eq!(names, vec!["internal", "hive_catalog", "iceberg_catalog"]);
+    }
+
+    #[test]
+    fn normalize_doris_catalogs_sorts_starrocks_default_catalog_first() {
+        // StarRocks names its built-in catalog `default_catalog` (Type=Internal);
+        // detection is type-based, so it sorts first just like Doris `internal`.
+        let catalogs = vec![
+            doris_catalog_info("hive_catalog", "hive", false),
+            doris_catalog_info("default_catalog", "Internal", true),
+        ];
+        let normalized = normalize_doris_catalogs(catalogs);
+        let names: Vec<&str> = normalized.iter().map(|c| c.name.as_str()).collect();
+        assert_eq!(names, vec!["default_catalog", "hive_catalog"]);
+        assert!(normalized[0].is_internal());
+        assert!(!normalized[1].is_internal());
+    }
+
+    #[test]
+    fn normalize_doris_catalogs_detects_internal_by_type_not_name() {
+        // A catalog literally named `internal` but with an external type is NOT
+        // the built-in catalog and must not sort first.
+        let catalogs =
+            vec![doris_catalog_info("internal", "iceberg", false), doris_catalog_info("hive_catalog", "hive", false)];
+        let normalized = normalize_doris_catalogs(catalogs);
+        let names: Vec<&str> = normalized.iter().map(|c| c.name.as_str()).collect();
+        assert_eq!(names, vec!["hive_catalog", "internal"]);
+        assert!(!normalized.iter().any(|c| c.is_internal()));
+    }
+
+    #[test]
+    fn normalize_doris_catalogs_handles_empty_input() {
+        let normalized = normalize_doris_catalogs(Vec::new());
+        assert!(normalized.is_empty());
+    }
+}
diff --git a/crates/dbx-core/src/db/ob_oracle.rs b/crates/dbx-core/src/db/ob_oracle.rs
new file mode 100644
index 0000000..cd1b5d2
--- /dev/null
+++ b/crates/dbx-core/src/db/ob_oracle.rs
@@ -0,0 +1,303 @@
+use mysql_async::prelude::*;
+
+use crate::types::{ColumnInfo, DatabaseInfo, ForeignKeyInfo, IndexInfo, ObjectInfo, TableInfo, TriggerInfo};
+
+fn row_get<T, I>(row: &mysql_async::Row, index: I) -> Option<T>
+where
+    T: mysql_async::prelude::FromValue,
+    I: mysql_async::prelude::ColumnIndex,
+{
+    row.get_opt::<T, I>(index).and_then(|result| result.ok())
+}
+
+fn quote_value(s: &str) -> String {
+    format!("'{}'", s.replace('\\', "\\\\").replace('\'', "\\'"))
+}
+
+fn get_str(row: &mysql_async::Row, idx: usize) -> String {
+    row_get::<String, _>(row, idx)
+        .or_else(|| row_get::<Vec<u8>, _>(row, idx).map(|b| String::from_utf8_lossy(&b).to_string()))
+        .unwrap_or_default()
+}
+
+fn get_opt_str(row: &mysql_async::Row, idx: usize) -> Option<String> {
+    row_get::<String, _>(row, idx)
+        .or_else(|| row_get::<Vec<u8>, _>(row, idx).map(|b| String::from_utf8_lossy(&b).to_string()))
+}
+
+fn get_opt_i32(row: &mysql_async::Row, idx: usize) -> Option<i32> {
+    row_get::<i32, _>(row, idx).or_else(|| row_get::<i64, _>(row, idx).and_then(|v| i32::try_from(v).ok()))
+}
+
+fn list_user_schemas_sql() -> &'static str {
+    "SELECT USERNAME FROM ALL_USERS \
+     WHERE USERNAME NOT IN ('SYS','LBACSYS','__public') \
+     ORDER BY USERNAME"
+}
+
+pub async fn list_databases(pool: &mysql_async::Pool) -> Result<Vec<DatabaseInfo>, String> {
+    let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?;
+    let result = conn.query_iter(list_user_schemas_sql()).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+
+    Ok(rows.iter().map(|row| DatabaseInfo { name: get_str(row, 0) }).collect())
+}
+
+pub async fn list_schemas(pool: &mysql_async::Pool) -> Result<Vec<String>, String> {
+    list_databases(pool).await.map(|databases| databases.into_iter().map(|database| database.name).collect())
+}
+
+pub async fn list_tables(pool: &mysql_async::Pool, schema: &str) -> Result<Vec<TableInfo>, String> {
+    let sql = format!(
+        "SELECT TABLE_NAME, 'TABLE' AS TABLE_TYPE FROM ALL_TABLES WHERE OWNER = {s} \
+         UNION ALL \
+         SELECT VIEW_NAME, 'VIEW' AS TABLE_TYPE FROM ALL_VIEWS WHERE OWNER = {s} \
+         ORDER BY 1",
+        s = quote_value(schema),
+    );
+    let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| TableInfo {
+            name: get_str(row, 0),
+            table_type: get_str(row, 1),
+            comment: None,
+            parent_schema: None,
+            parent_name: None,
+        })
+        .collect())
+}
+
+fn list_objects_sql(schema: &str) -> String {
+    format!(
+        "SELECT TABLE_NAME AS OBJECT_NAME, 'TABLE' AS OBJECT_TYPE, 0 AS SORT_ORDER \
+         FROM ALL_TABLES WHERE OWNER = {s} \
+         UNION ALL \
+         SELECT VIEW_NAME AS OBJECT_NAME, 'VIEW' AS OBJECT_TYPE, 1 AS SORT_ORDER \
+         FROM ALL_VIEWS WHERE OWNER = {s} \
+         UNION ALL \
+         SELECT OBJECT_NAME, OBJECT_TYPE, CASE WHEN OBJECT_TYPE = 'PROCEDURE' THEN 2 ELSE 3 END AS SORT_ORDER \
+         FROM ALL_PROCEDURES \
+         WHERE OWNER = {s} AND OBJECT_TYPE IN ('PROCEDURE', 'FUNCTION') AND PROCEDURE_NAME IS NULL \
+         UNION ALL \
+         SELECT OBJECT_NAME, CASE OBJECT_TYPE WHEN 'PACKAGE BODY' THEN 'PACKAGE_BODY' ELSE OBJECT_TYPE END AS OBJECT_TYPE, \
+                CASE WHEN OBJECT_TYPE = 'PACKAGE' THEN 4 ELSE 5 END AS SORT_ORDER \
+         FROM ALL_OBJECTS \
+         WHERE OWNER = {s} AND OBJECT_TYPE IN ('PACKAGE', 'PACKAGE BODY') \
+         ORDER BY SORT_ORDER, OBJECT_NAME",
+        s = quote_value(schema),
+    )
+}
+
+pub async fn list_objects(pool: &mysql_async::Pool, schema: &str) -> Result<Vec<ObjectInfo>, String> {
+    let sql = list_objects_sql(schema);
+    let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| ObjectInfo {
+            name: get_str(row, 0),
+            object_type: get_str(row, 1),
+            schema: Some(schema.to_string()),
+            signature: None,
+            comment: None,
+            created_at: None,
+            updated_at: None,
+            parent_schema: None,
+            parent_name: None,
+        })
+        .collect())
+}
+
+pub async fn get_columns(pool: &mysql_async::Pool, schema: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let sql = format!(
+        "SELECT c.COLUMN_NAME, c.DATA_TYPE, c.NULLABLE, c.DATA_DEFAULT, \
+         c.DATA_LENGTH, c.DATA_PRECISION, c.DATA_SCALE, c.COLUMN_ID, \
+         CASE WHEN cc.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END AS IS_PK \
+         FROM ALL_TAB_COLUMNS c \
+         LEFT JOIN ( \
+           SELECT cols.OWNER, cols.TABLE_NAME, cols.COLUMN_NAME \
+           FROM ALL_CONS_COLUMNS cols \
+           JOIN ALL_CONSTRAINTS con ON con.CONSTRAINT_NAME = cols.CONSTRAINT_NAME AND con.OWNER = cols.OWNER \
+           WHERE con.CONSTRAINT_TYPE = 'P' \
+         ) cc ON cc.OWNER = c.OWNER AND cc.TABLE_NAME = c.TABLE_NAME AND cc.COLUMN_NAME = c.COLUMN_NAME \
+         WHERE c.OWNER = {s} AND c.TABLE_NAME = {t} \
+         ORDER BY c.COLUMN_ID",
+        s = quote_value(schema),
+        t = quote_value(table),
+    );
+    let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let data_type = get_str(row, 1);
+            let precision = get_opt_i32(row, 5);
+            let scale = get_opt_i32(row, 6);
+            let length = get_opt_i32(row, 4);
+            let display_type = format_oracle_type(&data_type, precision, scale, length);
+            ColumnInfo {
+                name: get_str(row, 0),
+                data_type: display_type,
+                is_nullable: get_str(row, 2) == "Y",
+                column_default: get_opt_str(row, 3).map(|s| s.trim().to_string()).filter(|s| !s.is_empty()),
+                is_primary_key: row_get::<i32, _>(row, 8).unwrap_or(0) == 1,
+                extra: None,
+                comment: None,
+                numeric_precision: precision,
+                numeric_scale: scale,
+                character_maximum_length: length,
+                enum_values: None,
+                ..Default::default()
+            }
+        })
+        .collect())
+}
+
+fn format_oracle_type(data_type: &str, precision: Option<i32>, scale: Option<i32>, length: Option<i32>) -> String {
+    match data_type.to_uppercase().as_str() {
+        "NUMBER" => match (precision, scale) {
+            (Some(p), Some(s)) if s > 0 => format!("NUMBER({p},{s})"),
+            (Some(p), _) => format!("NUMBER({p})"),
+            _ => "NUMBER".to_string(),
+        },
+        "VARCHAR2" | "NVARCHAR2" | "CHAR" | "NCHAR" | "RAW" => match length {
+            Some(l) => format!("{data_type}({l})"),
+            None => data_type.to_string(),
+        },
+        _ => data_type.to_string(),
+    }
+}
+
+pub async fn list_indexes(pool: &mysql_async::Pool, schema: &str, table: &str) -> Result<Vec<IndexInfo>, String> {
+    let sql = format!(
+        "SELECT ai.INDEX_NAME, \
+         LISTAGG(aic.COLUMN_NAME, ',') WITHIN GROUP (ORDER BY aic.COLUMN_POSITION) AS COLUMNS, \
+         ai.UNIQUENESS, \
+         CASE WHEN ac.CONSTRAINT_TYPE = 'P' THEN 1 ELSE 0 END AS IS_PRIMARY \
+         FROM ALL_INDEXES ai \
+         JOIN ALL_IND_COLUMNS aic ON ai.INDEX_NAME = aic.INDEX_NAME AND ai.TABLE_OWNER = aic.TABLE_OWNER \
+         LEFT JOIN ALL_CONSTRAINTS ac ON ac.INDEX_NAME = ai.INDEX_NAME AND ac.OWNER = ai.TABLE_OWNER AND ac.CONSTRAINT_TYPE = 'P' \
+         WHERE ai.TABLE_OWNER = {s} AND ai.TABLE_NAME = {t} \
+         GROUP BY ai.INDEX_NAME, ai.UNIQUENESS, ac.CONSTRAINT_TYPE \
+         ORDER BY ai.INDEX_NAME",
+        s = quote_value(schema),
+        t = quote_value(table),
+    );
+    let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let cols_str = get_str(row, 1);
+            IndexInfo {
+                name: get_str(row, 0),
+                columns: cols_str.split(',').filter(|s| !s.is_empty()).map(|s| s.to_string()).collect(),
+                is_unique: get_str(row, 2) == "UNIQUE",
+                is_primary: row_get::<i32, _>(row, 3).unwrap_or(0) == 1,
+                filter: None,
+                index_type: None,
+                included_columns: None,
+                comment: None,
+            }
+        })
+        .collect())
+}
+
+pub async fn list_foreign_keys(
+    pool: &mysql_async::Pool,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<ForeignKeyInfo>, String> {
+    let sql = format!(
+        "SELECT ac.CONSTRAINT_NAME, acc.COLUMN_NAME, \
+         ac2.OWNER AS R_OWNER, ac2.TABLE_NAME AS R_TABLE, acc2.COLUMN_NAME AS R_COLUMN \
+         FROM ALL_CONSTRAINTS ac \
+         JOIN ALL_CONS_COLUMNS acc ON ac.CONSTRAINT_NAME = acc.CONSTRAINT_NAME AND ac.OWNER = acc.OWNER \
+         JOIN ALL_CONSTRAINTS ac2 ON ac.R_CONSTRAINT_NAME = ac2.CONSTRAINT_NAME AND ac.R_OWNER = ac2.OWNER \
+         JOIN ALL_CONS_COLUMNS acc2 ON ac2.CONSTRAINT_NAME = acc2.CONSTRAINT_NAME AND ac2.OWNER = acc2.OWNER \
+           AND acc.POSITION = acc2.POSITION \
+         WHERE ac.CONSTRAINT_TYPE = 'R' AND ac.OWNER = {s} AND ac.TABLE_NAME = {t} \
+         ORDER BY ac.CONSTRAINT_NAME, acc.POSITION",
+        s = quote_value(schema),
+        t = quote_value(table),
+    );
+    let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| ForeignKeyInfo {
+            name: get_str(row, 0),
+            column: get_str(row, 1),
+            ref_schema: Some(get_str(row, 2)),
+            ref_table: get_str(row, 3),
+            ref_column: get_str(row, 4),
+            on_update: None,
+            on_delete: None,
+        })
+        .collect())
+}
+
+pub async fn list_triggers(pool: &mysql_async::Pool, schema: &str, table: &str) -> Result<Vec<TriggerInfo>, String> {
+    let sql = format!(
+        "SELECT TRIGGER_NAME, TRIGGERING_EVENT, TRIGGER_TYPE \
+         FROM ALL_TRIGGERS \
+         WHERE TABLE_OWNER = {s} AND TABLE_NAME = {t} \
+         ORDER BY TRIGGER_NAME",
+        s = quote_value(schema),
+        t = quote_value(table),
+    );
+    let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let trigger_type = get_str(row, 2);
+            let timing = if trigger_type.contains("BEFORE") {
+                "BEFORE"
+            } else if trigger_type.contains("AFTER") {
+                "AFTER"
+            } else {
+                "INSTEAD OF"
+            };
+            TriggerInfo { name: get_str(row, 0), event: get_str(row, 1), timing: timing.to_string(), statement: None }
+        })
+        .collect())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ob_oracle_list_objects_sql_includes_routines() {
+        let sql = list_objects_sql("DLJPM");
+
+        assert!(sql.contains("ALL_TABLES"));
+        assert!(sql.contains("ALL_VIEWS"));
+        assert!(sql.contains("ALL_PROCEDURES"));
+        assert!(sql.contains("'PROCEDURE'"));
+        assert!(sql.contains("'FUNCTION'"));
+        assert!(sql.contains("ALL_OBJECTS"));
+        assert!(sql.contains("'PACKAGE'"));
+        assert!(sql.contains("'PACKAGE BODY'"));
+    }
+
+    #[test]
+    fn ob_oracle_user_schema_sql_keeps_auditor_schema_available() {
+        assert!(!list_user_schemas_sql().contains("ORAAUDITOR"));
+    }
+}
diff --git a/crates/dbx-core/src/db/postgres.rs b/crates/dbx-core/src/db/postgres.rs
new file mode 100644
index 0000000..a95603a
--- /dev/null
+++ b/crates/dbx-core/src/db/postgres.rs
@@ -0,0 +1,4223 @@
+use chrono::{DateTime, Local, NaiveDate, NaiveDateTime, NaiveTime};
+use deadpool_postgres::{ManagerConfig, Pool, PoolError, RecyclingMethod, Runtime};
+use futures::{SinkExt, StreamExt};
+use percent_encoding::percent_decode_str;
+use rust_decimal::Decimal;
+use rustls::client::danger::{HandshakeSignatureValid, ServerCertVerified, ServerCertVerifier};
+use rustls::client::verify_server_cert_signed_by_trust_anchor;
+use rustls::crypto::{verify_tls12_signature, verify_tls13_signature, CryptoProvider};
+use rustls::pki_types::{CertificateDer, PrivateKeyDer, ServerName, UnixTime};
+use rustls::server::ParsedCertificate;
+use std::fs::File;
+use std::future::Future;
+use std::io::BufReader;
+use std::str::FromStr;
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tokio_postgres::config::SslMode;
+use tokio_postgres::types::{FromSql, Type};
+use tokio_postgres::{NoTls, Row, SimpleQueryMessage};
+use tokio_util::sync::CancellationToken;
+
+use super::file_validator::validate_file_path;
+use crate::query::DbOperationBudget;
+use crate::sql::starts_with_executable_sql_keyword;
+use crate::types::{
+    ColumnInfo, CompletionAssistantCandidate, CompletionAssistantCandidateKind, CompletionAssistantMatchMode,
+    CompletionAssistantObjectKind, CompletionAssistantRequest, CompletionAssistantResponse, DatabaseInfo,
+    ExtensionInfo, ForeignKeyInfo, FunctionInfo, IndexInfo, ObjectInfo, ObjectStatistics, OwnerInfo, QueryResult,
+    RuleInfo, SchemaInfo, SequenceInfo, TableInfo, TriggerInfo,
+};
+
+fn pg_temporal_to_json_value(row: &Row, idx: usize) -> Option<serde_json::Value> {
+    if let Ok(v) = row.try_get::<_, DateTime<Local>>(idx) {
+        return Some(serde_json::Value::String(format_pg_timestamptz(v)));
+    }
+    if let Ok(v) = row.try_get::<_, NaiveDateTime>(idx) {
+        return Some(serde_json::Value::String(v.to_string()));
+    }
+    if let Ok(v) = row.try_get::<_, NaiveDate>(idx) {
+        return Some(serde_json::Value::String(v.to_string()));
+    }
+    if let Ok(v) = row.try_get::<_, NaiveTime>(idx) {
+        return Some(serde_json::Value::String(v.to_string()));
+    }
+    None
+}
+
+struct PgSystemU32(u32);
+
+impl<'a> FromSql<'a> for PgSystemU32 {
+    fn from_sql(_: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn std::error::Error + Sync + Send>> {
+        let bytes: [u8; 4] = raw.try_into().map_err(|_| "expected 4 bytes for PostgreSQL system u32")?;
+        Ok(Self(u32::from_be_bytes(bytes)))
+    }
+
+    fn accepts(ty: &Type) -> bool {
+        matches!(*ty, Type::XID | Type::CID)
+    }
+}
+
+/// A `FromSql` adapter that accepts any PostgreSQL type and reads its raw
+/// bytes as a UTF-8 string. This is used as a last-resort fallback to handle
+/// custom types (enums, domains, etc.) that tokio_postgres cannot map to
+/// built-in Rust types in the binary protocol.
+struct PgAnyString(String);
+
+impl<'a> FromSql<'a> for PgAnyString {
+    fn from_sql(_: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn std::error::Error + Sync + Send>> {
+        std::str::from_utf8(raw)
+            .map(|s| PgAnyString(s.to_string()))
+            .map_err(|e| Box::new(e) as Box<dyn std::error::Error + Sync + Send>)
+    }
+
+    fn accepts(_: &Type) -> bool {
+        true
+    }
+}
+
+/// A `FromSql` adapter that accepts any PostgreSQL type and returns the raw
+/// bytes unchanged. Used to decode custom types like pgvector whose binary
+/// format we handle ourselves.
+struct PgRawBytes(Vec<u8>);
+
+impl<'a> FromSql<'a> for PgRawBytes {
+    fn from_sql(_: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn std::error::Error + Sync + Send>> {
+        Ok(PgRawBytes(raw.to_vec()))
+    }
+
+    fn accepts(_: &Type) -> bool {
+        true
+    }
+}
+
+/// Decode pgvector binary format into a Vec<f32>.
+///
+/// pgvector binary layout (big-endian):
+/// - 2 bytes: dimensions (uint16)
+/// - 2 bytes: unused (padding)
+/// - N*4 bytes: IEEE 754 f32 values
+fn decode_pgvector_bytes(raw: &[u8]) -> Option<Vec<f32>> {
+    if raw.len() < 4 {
+        return None;
+    }
+    let dims = u16::from_be_bytes([raw[0], raw[1]]) as usize;
+    let expected_len = 4 + dims * 4;
+    if raw.len() != expected_len {
+        return None;
+    }
+    let floats: Vec<f32> =
+        raw[4..].chunks_exact(4).map(|chunk| f32::from_be_bytes([chunk[0], chunk[1], chunk[2], chunk[3]])).collect();
+    Some(floats)
+}
+
+fn pg_u32_number(v: u32) -> serde_json::Value {
+    serde_json::Value::Number(serde_json::Number::from(v))
+}
+
+fn pg_system_u32_to_json(row: &Row, idx: usize) -> Option<serde_json::Value> {
+    if let Ok(v) = row.try_get::<_, u32>(idx) {
+        return Some(pg_u32_number(v));
+    }
+    row.try_get::<_, PgSystemU32>(idx).ok().map(|v| pg_u32_number(v.0))
+}
+
+fn pg_optional_array_to_json<T>(
+    values: Vec<Option<T>>,
+    map_value: impl Fn(T) -> serde_json::Value,
+) -> serde_json::Value {
+    serde_json::Value::Array(
+        values.into_iter().map(|value| value.map(&map_value).unwrap_or(serde_json::Value::Null)).collect(),
+    )
+}
+
+fn pg_float_number(v: f64) -> serde_json::Value {
+    serde_json::Number::from_f64(v).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null)
+}
+
+fn decode_pg_network_address_bytes(raw: &[u8], force_cidr_output: bool) -> Option<String> {
+    let family = *raw.first()?;
+    let bits = *raw.get(1)?;
+    let is_cidr = *raw.get(2)? != 0;
+    let addr_len = *raw.get(3)? as usize;
+    let addr = raw.get(4..)?;
+    if addr.len() != addr_len {
+        return None;
+    }
+
+    let (address, host_bits) = match (family, addr_len) {
+        (2, 4) => {
+            let bytes: [u8; 4] = addr.try_into().ok()?;
+            (std::net::IpAddr::V4(std::net::Ipv4Addr::from(bytes)).to_string(), 32)
+        }
+        (3, 16) => {
+            let bytes: [u8; 16] = addr.try_into().ok()?;
+            (std::net::IpAddr::V6(std::net::Ipv6Addr::from(bytes)).to_string(), 128)
+        }
+        _ => return None,
+    };
+
+    if bits > host_bits {
+        return None;
+    }
+
+    if force_cidr_output || is_cidr || bits != host_bits {
+        Some(format!("{address}/{bits}"))
+    } else {
+        Some(address)
+    }
+}
+
+fn decode_pg_macaddr_bytes(raw: &[u8]) -> Option<String> {
+    if !matches!(raw.len(), 6 | 8) {
+        return None;
+    }
+    Some(raw.iter().map(|byte| format!("{byte:02x}")).collect::<Vec<_>>().join(":"))
+}
+
+fn decode_pg_bit_string_bytes(raw: &[u8]) -> Option<String> {
+    let mut cursor = 0;
+    let bit_len = read_i32_be(raw, &mut cursor)?;
+    if bit_len < 0 {
+        return None;
+    }
+    let bit_len = bit_len as usize;
+    let data = raw.get(cursor..)?;
+    if data.len() != bit_len.div_ceil(8) {
+        return None;
+    }
+
+    let mut bits = String::with_capacity(bit_len);
+    for index in 0..bit_len {
+        let byte = data[index / 8];
+        let bit = (byte >> (7 - (index % 8))) & 1;
+        bits.push(if bit == 1 { '1' } else { '0' });
+    }
+    Some(bits)
+}
+
+fn pg_network_address_to_json_value(row: &Row, idx: usize, force_cidr_output: bool) -> Option<serde_json::Value> {
+    row.try_get::<_, PgRawBytes>(idx)
+        .ok()
+        .and_then(|raw| decode_pg_network_address_bytes(&raw.0, force_cidr_output))
+        .map(serde_json::Value::String)
+}
+
+fn pg_macaddr_to_json_value(row: &Row, idx: usize) -> Option<serde_json::Value> {
+    row.try_get::<_, PgRawBytes>(idx)
+        .ok()
+        .and_then(|raw| decode_pg_macaddr_bytes(&raw.0))
+        .map(serde_json::Value::String)
+}
+
+fn pg_bit_string_to_json_value(row: &Row, idx: usize) -> Option<serde_json::Value> {
+    row.try_get::<_, PgRawBytes>(idx)
+        .ok()
+        .and_then(|raw| decode_pg_bit_string_bytes(&raw.0))
+        .map(serde_json::Value::String)
+}
+
+fn pg_network_address_array_to_json_value(row: &Row, idx: usize, force_cidr_output: bool) -> Option<serde_json::Value> {
+    row.try_get::<_, Vec<Option<PgRawBytes>>>(idx).ok().map(|values| {
+        pg_optional_array_to_json(values, |raw| {
+            decode_pg_network_address_bytes(&raw.0, force_cidr_output)
+                .map(serde_json::Value::String)
+                .unwrap_or_else(|| super::binary_value_to_json(&raw.0))
+        })
+    })
+}
+
+fn pg_macaddr_array_to_json_value(row: &Row, idx: usize) -> Option<serde_json::Value> {
+    row.try_get::<_, Vec<Option<PgRawBytes>>>(idx).ok().map(|values| {
+        pg_optional_array_to_json(values, |raw| {
+            decode_pg_macaddr_bytes(&raw.0)
+                .map(serde_json::Value::String)
+                .unwrap_or_else(|| super::binary_value_to_json(&raw.0))
+        })
+    })
+}
+
+fn pg_bit_string_array_to_json_value(row: &Row, idx: usize) -> Option<serde_json::Value> {
+    row.try_get::<_, Vec<Option<PgRawBytes>>>(idx).ok().map(|values| {
+        pg_optional_array_to_json(values, |raw| {
+            decode_pg_bit_string_bytes(&raw.0)
+                .map(serde_json::Value::String)
+                .unwrap_or_else(|| super::binary_value_to_json(&raw.0))
+        })
+    })
+}
+
+fn pg_array_to_json_value(row: &Row, idx: usize) -> Option<serde_json::Value> {
+    if let Ok(values) = row.try_get::<_, Vec<Option<String>>>(idx) {
+        return Some(pg_optional_array_to_json(values, serde_json::Value::String));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<bool>>>(idx) {
+        return Some(pg_optional_array_to_json(values, serde_json::Value::Bool));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<Decimal>>>(idx) {
+        return Some(pg_optional_array_to_json(values, |v| serde_json::Value::String(v.to_string())));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<uuid::Uuid>>>(idx) {
+        return Some(pg_optional_array_to_json(values, |v| serde_json::Value::String(v.to_string())));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<DateTime<Local>>>>(idx) {
+        return Some(pg_optional_array_to_json(values, |v| serde_json::Value::String(format_pg_timestamptz(v))));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<NaiveDateTime>>>(idx) {
+        return Some(pg_optional_array_to_json(values, |v| serde_json::Value::String(v.to_string())));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<NaiveDate>>>(idx) {
+        return Some(pg_optional_array_to_json(values, |v| serde_json::Value::String(v.to_string())));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<NaiveTime>>>(idx) {
+        return Some(pg_optional_array_to_json(values, |v| serde_json::Value::String(v.to_string())));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<u32>>>(idx) {
+        return Some(pg_optional_array_to_json(values, pg_u32_number));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<i8>>>(idx) {
+        return Some(pg_optional_array_to_json(values, |v| serde_json::Value::Number(v.into())));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<i16>>>(idx) {
+        return Some(pg_optional_array_to_json(values, |v| serde_json::Value::Number(v.into())));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<i32>>>(idx) {
+        return Some(pg_optional_array_to_json(values, |v| serde_json::Value::Number(v.into())));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<i64>>>(idx) {
+        return Some(pg_optional_array_to_json(values, super::safe_i64_to_json));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<f32>>>(idx) {
+        return Some(pg_optional_array_to_json(values, |v| pg_float_number(v as f64)));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<f64>>>(idx) {
+        return Some(pg_optional_array_to_json(values, pg_float_number));
+    }
+    if let Ok(values) = row.try_get::<_, Vec<Option<PgAnyString>>>(idx) {
+        return Some(pg_optional_array_to_json(values, |v| serde_json::Value::String(v.0)));
+    }
+    None
+}
+
+fn format_pg_timestamptz(value: DateTime<Local>) -> String {
+    value.to_rfc3339()
+}
+
+pub(crate) fn pg_value_to_json(row: &Row, idx: usize, type_name: &str) -> serde_json::Value {
+    let upper = type_name.to_uppercase();
+
+    if upper == "BYTEA" {
+        return row
+            .try_get::<_, Vec<u8>>(idx)
+            .map(|bytes| super::binary_value_to_json(&bytes))
+            .unwrap_or(serde_json::Value::Null);
+    }
+
+    if upper == "JSON" || upper == "JSONB" {
+        if let Ok(v) = row.try_get::<_, serde_json::Value>(idx) {
+            return serde_json::Value::String(v.to_string());
+        }
+        if let Ok(v) = row.try_get::<_, String>(idx) {
+            return serde_json::Value::String(v);
+        }
+        return serde_json::Value::Null;
+    }
+
+    if upper == "BOOL" {
+        return row.try_get::<_, bool>(idx).map(serde_json::Value::Bool).unwrap_or(serde_json::Value::Null);
+    }
+
+    if upper.contains("TIMESTAMP")
+        || upper == "DATE"
+        || upper == "TIME"
+        || upper == "TIMETZ"
+        || upper.contains("INTERVAL")
+    {
+        if let Some(v) = pg_temporal_to_json_value(row, idx) {
+            return v;
+        }
+    }
+
+    if upper == "NUMERIC" || upper == "DECIMAL" || upper == "MONEY" {
+        return row
+            .try_get::<_, Decimal>(idx)
+            .map(|v: Decimal| serde_json::Value::String(v.to_string()))
+            .unwrap_or(serde_json::Value::Null);
+    }
+
+    if upper == "UUID" {
+        return row
+            .try_get::<_, uuid::Uuid>(idx)
+            .map(|v| serde_json::Value::String(v.to_string()))
+            .unwrap_or(serde_json::Value::Null);
+    }
+
+    if matches!(upper.as_str(), "INET" | "CIDR") {
+        return pg_network_address_to_json_value(row, idx, upper == "CIDR").unwrap_or(serde_json::Value::Null);
+    }
+
+    if matches!(upper.as_str(), "MACADDR" | "MACADDR8") {
+        return pg_macaddr_to_json_value(row, idx).unwrap_or(serde_json::Value::Null);
+    }
+
+    if matches!(upper.as_str(), "BIT" | "VARBIT") {
+        return pg_bit_string_to_json_value(row, idx).unwrap_or(serde_json::Value::Null);
+    }
+
+    if upper == "TSVECTOR" {
+        return row
+            .try_get::<_, PgRawBytes>(idx)
+            .ok()
+            .and_then(|raw| decode_tsvector_bytes(&raw.0))
+            .map(serde_json::Value::String)
+            .unwrap_or(serde_json::Value::Null);
+    }
+
+    if matches!(upper.as_str(), "OID" | "XID" | "CID") {
+        return pg_system_u32_to_json(row, idx).unwrap_or(serde_json::Value::Null);
+    }
+
+    if matches!(upper.as_str(), "_INET" | "_CIDR") {
+        return pg_network_address_array_to_json_value(row, idx, upper == "_CIDR").unwrap_or(serde_json::Value::Null);
+    }
+
+    if matches!(upper.as_str(), "_MACADDR" | "_MACADDR8") {
+        return pg_macaddr_array_to_json_value(row, idx).unwrap_or(serde_json::Value::Null);
+    }
+
+    if matches!(upper.as_str(), "_BIT" | "_VARBIT") {
+        return pg_bit_string_array_to_json_value(row, idx).unwrap_or(serde_json::Value::Null);
+    }
+
+    if upper.starts_with('_') {
+        return pg_array_to_json_value(row, idx).unwrap_or(serde_json::Value::Null);
+    }
+
+    if upper == "VECTOR" || upper.starts_with("VECTOR(") {
+        if let Ok(PgRawBytes(raw)) = row.try_get::<_, PgRawBytes>(idx) {
+            if let Some(floats) = decode_pgvector_bytes(&raw) {
+                return serde_json::Value::Array(
+                    floats
+                        .into_iter()
+                        .map(|v| {
+                            serde_json::Number::from_f64((v as f64 * 1_000_000.0).round() / 1_000_000.0)
+                                .map(serde_json::Value::Number)
+                                .unwrap_or(serde_json::Value::Null)
+                        })
+                        .collect(),
+                );
+            }
+        }
+        return serde_json::Value::Null;
+    }
+
+    if upper == "GEOMETRY" || upper == "GEOGRAPHY" {
+        if let Ok(PgRawBytes(raw)) = row.try_get::<_, PgRawBytes>(idx) {
+            return super::wkb::wkb_to_wkt(&raw)
+                .map(serde_json::Value::String)
+                .unwrap_or_else(|| super::binary_value_to_json(&raw));
+        }
+        return serde_json::Value::Null;
+    }
+
+    row.try_get::<_, String>(idx)
+        .map(serde_json::Value::String)
+        .or_else(|e| pg_system_u32_to_json(row, idx).ok_or(e))
+        .or_else(|_| row.try_get::<_, i64>(idx).map(super::safe_i64_to_json))
+        .or_else(|_| row.try_get::<_, i32>(idx).map(|v| serde_json::Value::Number(v.into())))
+        .or_else(|_| row.try_get::<_, i16>(idx).map(|v| serde_json::Value::Number(v.into())))
+        .or_else(|_| row.try_get::<_, i8>(idx).map(|v| serde_json::Value::Number(v.into())))
+        .or_else(|e| pg_array_to_json_value(row, idx).ok_or(e))
+        .or_else(|_| {
+            row.try_get::<_, f64>(idx).map(|v| {
+                serde_json::Number::from_f64(v).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null)
+            })
+        })
+        .or_else(|_| {
+            row.try_get::<_, f32>(idx).map(|v| {
+                serde_json::Number::from_f64((v as f64 * 1_000_000.0).round() / 1_000_000.0)
+                    .map(serde_json::Value::Number)
+                    .unwrap_or(serde_json::Value::Null)
+            })
+        })
+        .or_else(|_| row.try_get::<_, bool>(idx).map(serde_json::Value::Bool))
+        .or_else(|_| row.try_get::<_, uuid::Uuid>(idx).map(|v| serde_json::Value::String(v.to_string())))
+        .or_else(|e| pg_temporal_to_json_value(row, idx).ok_or(e))
+        .or_else(|_| row.try_get::<_, Vec<u8>>(idx).map(|bytes| super::binary_value_to_json(&bytes)))
+        .or_else(|_| row.try_get::<_, PgAnyString>(idx).map(|v| serde_json::Value::String(v.0)))
+        .or_else(|_| row.try_get::<_, PgRawBytes>(idx).map(|v| super::binary_value_to_json(&v.0)))
+        .unwrap_or(serde_json::Value::Null)
+}
+
+fn decode_tsvector_bytes(raw: &[u8]) -> Option<String> {
+    let mut cursor = 0;
+    let count = read_i32_be(raw, &mut cursor)?;
+    if count < 0 {
+        return None;
+    }
+
+    let mut entries = Vec::with_capacity(count as usize);
+    for _ in 0..count {
+        let start = cursor;
+        while cursor < raw.len() && raw[cursor] != 0 {
+            cursor += 1;
+        }
+        if cursor >= raw.len() {
+            return None;
+        }
+        let lexeme = std::str::from_utf8(&raw[start..cursor]).ok()?;
+        cursor += 1;
+
+        let position_count = read_u16_be(raw, &mut cursor)? as usize;
+        let mut positions = Vec::with_capacity(position_count);
+        for _ in 0..position_count {
+            let encoded = read_u16_be(raw, &mut cursor)?;
+            let position = encoded & 0x3fff;
+            let weight = match encoded >> 14 {
+                3 => "A",
+                2 => "B",
+                1 => "C",
+                _ => "",
+            };
+            positions.push(format!("{position}{weight}"));
+        }
+
+        let mut entry = format!("'{}'", escape_tsvector_lexeme(lexeme));
+        if !positions.is_empty() {
+            entry.push(':');
+            entry.push_str(&positions.join(","));
+        }
+        entries.push(entry);
+    }
+
+    if cursor == raw.len() {
+        Some(entries.join(" "))
+    } else {
+        None
+    }
+}
+
+fn read_i32_be(raw: &[u8], cursor: &mut usize) -> Option<i32> {
+    let bytes: [u8; 4] = raw.get(*cursor..*cursor + 4)?.try_into().ok()?;
+    *cursor += 4;
+    Some(i32::from_be_bytes(bytes))
+}
+
+fn read_u16_be(raw: &[u8], cursor: &mut usize) -> Option<u16> {
+    let bytes: [u8; 2] = raw.get(*cursor..*cursor + 2)?.try_into().ok()?;
+    *cursor += 2;
+    Some(u16::from_be_bytes(bytes))
+}
+
+fn escape_tsvector_lexeme(value: &str) -> String {
+    value.replace('\\', "\\\\").replace('\'', "''")
+}
+
+fn pg_error_to_string(err: tokio_postgres::Error) -> String {
+    err.as_db_error().map(ToString::to_string).unwrap_or_else(|| err.to_string())
+}
+
+fn pg_db_error_to_string(err: &tokio_postgres::error::DbError) -> String {
+    format!("{err} (SQLSTATE {})", err.code().code())
+}
+
+fn pg_error_from_sources(err: &(dyn std::error::Error + 'static)) -> Option<String> {
+    let mut current = Some(err);
+    while let Some(source) = current {
+        if let Some(pg_error) = source.downcast_ref::<tokio_postgres::Error>() {
+            if let Some(db_error) = pg_error.as_db_error() {
+                return Some(pg_db_error_to_string(db_error));
+            }
+        }
+        if let Some(db_error) = source.downcast_ref::<tokio_postgres::error::DbError>() {
+            return Some(pg_db_error_to_string(db_error));
+        }
+        current = source.source();
+    }
+    None
+}
+
+fn error_with_sources_to_string(err: &(dyn std::error::Error + 'static)) -> String {
+    let mut messages = vec![err.to_string()];
+    let mut current = err.source();
+    while let Some(source) = current {
+        let message = source.to_string();
+        if !messages.iter().any(|existing| existing == &message) {
+            messages.push(message);
+        }
+        current = source.source();
+    }
+    messages.join(": ")
+}
+
+fn pg_pool_error_to_string(err: PoolError) -> String {
+    pg_error_from_sources(&err).unwrap_or_else(|| error_with_sources_to_string(&err))
+}
+
+fn should_retry_postgres_text_query(err: &tokio_postgres::Error) -> bool {
+    let message = err.as_db_error().map(ToString::to_string).unwrap_or_else(|| err.to_string()).to_ascii_lowercase();
+    should_retry_postgres_text_query_message(&message)
+}
+
+fn should_retry_postgres_text_query_message(message: &str) -> bool {
+    message.contains("no binary output function")
+        || message.contains("no binary send function")
+        || message.contains("cannot display a value of type")
+}
+
+fn should_retry_postgres_stale_cache(err: &tokio_postgres::Error) -> bool {
+    let message = err.as_db_error().map(ToString::to_string).unwrap_or_else(|| err.to_string()).to_ascii_lowercase();
+    message.contains("cached plan must not change result type")
+}
+
+async fn postgres_query_cached(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    params: &[&(dyn tokio_postgres::types::ToSql + Sync)],
+) -> Result<Vec<Row>, tokio_postgres::Error> {
+    let stmt = client.prepare_cached(sql).await?;
+    match client.query(&stmt, params).await {
+        Ok(rows) => Ok(rows),
+        Err(err) if should_retry_postgres_stale_cache(&err) => {
+            // Metadata queries can be cached while a table/view definition is
+            // changed from another session. Evict and retry once with fresh
+            // statement/type metadata instead of surfacing PostgreSQL's stale
+            // cached-plan error to the UI.
+            log::warn!("[postgres][metadata:stale_cache] evicting cached statement: {}", pg_error_to_string(err));
+            client.statement_cache.remove(sql, &[]);
+            client.clear_type_cache();
+            let stmt = client.prepare_cached(sql).await?;
+            client.query(&stmt, params).await
+        }
+        Err(err) => Err(err),
+    }
+}
+
+async fn postgres_query_one_cached(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    params: &[&(dyn tokio_postgres::types::ToSql + Sync)],
+) -> Result<Row, tokio_postgres::Error> {
+    let stmt = client.prepare_cached(sql).await?;
+    match client.query_one(&stmt, params).await {
+        Ok(row) => Ok(row),
+        Err(err) if should_retry_postgres_stale_cache(&err) => {
+            // Same stale-cache protection as postgres_query_cached, for scalar
+            // catalog probes such as pg_proc feature detection.
+            log::warn!("[postgres][metadata:stale_cache] evicting cached statement: {}", pg_error_to_string(err));
+            client.statement_cache.remove(sql, &[]);
+            client.clear_type_cache();
+            let stmt = client.prepare_cached(sql).await?;
+            client.query_one(&stmt, params).await
+        }
+        Err(err) => Err(err),
+    }
+}
+
+async fn execute_select_prepared(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    start: Instant,
+    row_limit: usize,
+) -> Result<QueryResult, tokio_postgres::Error> {
+    let prepared_start = Instant::now();
+    let stmt = client.prepare_cached(sql).await?;
+    log::info!(
+        "[postgres][select:prepare_cached:done] elapsed_ms={} total_ms={}",
+        prepared_start.elapsed().as_millis(),
+        start.elapsed().as_millis()
+    );
+    let columns: Vec<String> = stmt.columns().iter().map(|c| c.name().to_string()).collect();
+    let column_types: Vec<String> = stmt.columns().iter().map(|c| c.type_().name().to_string()).collect();
+
+    let params: Vec<&(dyn tokio_postgres::types::ToSql + Sync)> = Vec::new();
+    let query_start = Instant::now();
+    let stream = client.query_raw(&stmt, params).await?;
+    log::info!(
+        "[postgres][select:query_raw:done] elapsed_ms={} total_ms={} column_count={}",
+        query_start.elapsed().as_millis(),
+        start.elapsed().as_millis(),
+        columns.len()
+    );
+    tokio::pin!(stream);
+    let mut result_rows: Vec<Vec<serde_json::Value>> = Vec::new();
+    let mut truncated = false;
+
+    let rows_start = Instant::now();
+    while let Some(row_result) = stream.next().await {
+        if result_rows.len() >= row_limit {
+            truncated = true;
+            break;
+        }
+        let row = row_result?;
+        result_rows.push(
+            (0..row.columns().len())
+                .map(|i| pg_value_to_json(&row, i, column_types.get(i).map(String::as_str).unwrap_or("")))
+                .collect(),
+        );
+    }
+    log::info!(
+        "[postgres][select:rows:done] elapsed_ms={} total_ms={} row_count={} truncated={}",
+        rows_start.elapsed().as_millis(),
+        start.elapsed().as_millis(),
+        result_rows.len(),
+        truncated
+    );
+
+    Ok(QueryResult {
+        columns,
+        column_types,
+        column_sortables: Vec::new(),
+        rows: result_rows,
+        affected_rows: 0,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+async fn execute_select_text(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    start: Instant,
+    row_limit: usize,
+) -> Result<QueryResult, String> {
+    let messages = client.simple_query(sql).await.map_err(pg_error_to_string)?;
+    let mut columns: Vec<String> = Vec::new();
+    let mut result_rows: Vec<Vec<serde_json::Value>> = Vec::new();
+    let mut truncated = false;
+
+    for message in messages {
+        match message {
+            SimpleQueryMessage::RowDescription(cols) => {
+                columns = cols.iter().map(|c| c.name().to_string()).collect();
+            }
+            SimpleQueryMessage::Row(row) => {
+                if columns.is_empty() {
+                    columns = row.columns().iter().map(|c| c.name().to_string()).collect();
+                }
+                if result_rows.len() >= row_limit {
+                    truncated = true;
+                    continue;
+                }
+                let mut values = Vec::with_capacity(row.len());
+                for i in 0..row.len() {
+                    values.push(match row.try_get(i).map_err(pg_error_to_string)? {
+                        Some(value) => serde_json::Value::String(value.to_string()),
+                        None => serde_json::Value::Null,
+                    });
+                }
+                result_rows.push(values);
+            }
+            SimpleQueryMessage::CommandComplete(_) => {}
+            _ => {}
+        }
+    }
+
+    Ok(QueryResult {
+        columns,
+        column_types: Vec::new(),
+        column_sortables: Vec::new(),
+        rows: result_rows,
+        affected_rows: 0,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+async fn execute_select_query(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    start: Instant,
+    row_limit: usize,
+) -> Result<QueryResult, String> {
+    match execute_select_prepared(client, sql, start, row_limit).await {
+        Ok(result) => Ok(result),
+        Err(err) if should_retry_postgres_stale_cache(&err) => {
+            // The cached prepared statement is stale (e.g. the view or table
+            // schema changed since the statement was prepared). Evict the
+            // stale entry and retry with a fresh server-side prepare.
+            log::warn!("[postgres][select:stale_cache] evicting cached statement: {}", pg_error_to_string(err));
+            client.statement_cache.remove(sql, &[]);
+            match execute_select_prepared(client, sql, start, row_limit).await {
+                Ok(result) => Ok(result),
+                Err(err) if should_retry_postgres_text_query(&err) => {
+                    execute_select_text(client, sql, start, row_limit).await
+                }
+                Err(err) => Err(pg_error_to_string(err)),
+            }
+        }
+        Err(err) if should_retry_postgres_text_query(&err) => execute_select_text(client, sql, start, row_limit).await,
+        Err(err) => Err(pg_error_to_string(err)),
+    }
+}
+
+pub enum PostgresQueryStreamItem {
+    Columns { columns: Vec<String>, column_types: Vec<String> },
+    Row(Vec<serde_json::Value>),
+}
+
+enum PostgresQueryStreamError {
+    Postgres { err: tokio_postgres::Error, emitted: bool },
+    Export(String),
+}
+
+impl PostgresQueryStreamError {
+    fn into_string(self) -> String {
+        match self {
+            Self::Postgres { err, .. } => pg_error_to_string(err),
+            Self::Export(err) => err,
+        }
+    }
+}
+
+async fn stream_select_query_prepared(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    row_limit: Option<usize>,
+    on_item: &mut impl FnMut(PostgresQueryStreamItem) -> Result<(), String>,
+) -> Result<u64, PostgresQueryStreamError> {
+    let stmt =
+        client.prepare_cached(sql).await.map_err(|err| PostgresQueryStreamError::Postgres { err, emitted: false })?;
+    let columns: Vec<String> = stmt.columns().iter().map(|c| c.name().to_string()).collect();
+    let column_types: Vec<String> = stmt.columns().iter().map(|c| c.type_().name().to_string()).collect();
+
+    let params: Vec<&(dyn tokio_postgres::types::ToSql + Sync)> = Vec::new();
+    let stream = client
+        .query_raw(&stmt, params)
+        .await
+        .map_err(|err| PostgresQueryStreamError::Postgres { err, emitted: false })?;
+    tokio::pin!(stream);
+    let mut rows_streamed = 0_u64;
+    let mut columns_emitted = false;
+    while let Some(row_result) = stream.next().await {
+        if row_limit.is_some_and(|limit| rows_streamed as usize >= limit) {
+            break;
+        }
+        let row = row_result
+            .map_err(|err| PostgresQueryStreamError::Postgres { err, emitted: columns_emitted || rows_streamed > 0 })?;
+        if !columns_emitted {
+            on_item(PostgresQueryStreamItem::Columns { columns: columns.clone(), column_types: column_types.clone() })
+                .map_err(PostgresQueryStreamError::Export)?;
+            columns_emitted = true;
+        }
+        let values = (0..row.columns().len())
+            .map(|i| pg_value_to_json(&row, i, column_types.get(i).map(String::as_str).unwrap_or("")))
+            .collect();
+        on_item(PostgresQueryStreamItem::Row(values)).map_err(PostgresQueryStreamError::Export)?;
+        rows_streamed += 1;
+    }
+    if !columns_emitted {
+        on_item(PostgresQueryStreamItem::Columns { columns, column_types })
+            .map_err(PostgresQueryStreamError::Export)?;
+    }
+    Ok(rows_streamed)
+}
+
+async fn stream_select_query_text(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    row_limit: Option<usize>,
+    on_item: &mut impl FnMut(PostgresQueryStreamItem) -> Result<(), String>,
+) -> Result<u64, String> {
+    let stream = client.simple_query_raw(sql).await.map_err(pg_error_to_string)?;
+    tokio::pin!(stream);
+    let mut columns: Vec<String> = Vec::new();
+    let mut rows_streamed = 0_u64;
+    while let Some(message) = stream.next().await {
+        match message.map_err(pg_error_to_string)? {
+            SimpleQueryMessage::RowDescription(cols) => {
+                columns = cols.iter().map(|c| c.name().to_string()).collect();
+                on_item(PostgresQueryStreamItem::Columns { columns: columns.clone(), column_types: Vec::new() })?;
+            }
+            SimpleQueryMessage::Row(row) => {
+                if row_limit.is_some_and(|limit| rows_streamed as usize >= limit) {
+                    break;
+                }
+                if columns.is_empty() {
+                    columns = row.columns().iter().map(|c| c.name().to_string()).collect();
+                    on_item(PostgresQueryStreamItem::Columns { columns: columns.clone(), column_types: Vec::new() })?;
+                }
+                let mut values = Vec::with_capacity(row.len());
+                for i in 0..row.len() {
+                    values.push(match row.try_get(i).map_err(pg_error_to_string)? {
+                        Some(value) => serde_json::Value::String(value.to_string()),
+                        None => serde_json::Value::Null,
+                    });
+                }
+                on_item(PostgresQueryStreamItem::Row(values))?;
+                rows_streamed += 1;
+            }
+            SimpleQueryMessage::CommandComplete(_) => {}
+            _ => {}
+        }
+    }
+    Ok(rows_streamed)
+}
+
+async fn stream_select_query_inner(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    row_limit: Option<usize>,
+    on_item: &mut impl FnMut(PostgresQueryStreamItem) -> Result<(), String>,
+) -> Result<u64, String> {
+    match stream_select_query_prepared(client, sql, row_limit, on_item).await {
+        Ok(rows) => Ok(rows),
+        Err(PostgresQueryStreamError::Postgres { err, emitted: false }) if should_retry_postgres_stale_cache(&err) => {
+            // The cached prepared statement can become stale after schema changes.
+            // Evict and retry once, matching the normal query execution path.
+            log::warn!("[postgres][stream:stale_cache] evicting cached statement: {}", pg_error_to_string(err));
+            client.statement_cache.remove(sql, &[]);
+            match stream_select_query_prepared(client, sql, row_limit, on_item).await {
+                Ok(rows) => Ok(rows),
+                Err(PostgresQueryStreamError::Postgres { err, emitted: false })
+                    if should_retry_postgres_text_query(&err) =>
+                {
+                    stream_select_query_text(client, sql, row_limit, on_item).await
+                }
+                Err(err) => Err(err.into_string()),
+            }
+        }
+        Err(PostgresQueryStreamError::Postgres { err, emitted: false }) if should_retry_postgres_text_query(&err) => {
+            stream_select_query_text(client, sql, row_limit, on_item).await
+        }
+        Err(err) => Err(err.into_string()),
+    }
+}
+
+pub async fn stream_query_rows(
+    pool: &Pool,
+    sql: &str,
+    max_rows: Option<usize>,
+    cancelled: &AtomicBool,
+    mut on_row: impl FnMut(&[serde_json::Value]) -> Result<(), String>,
+) -> Result<u64, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    match stream_query_rows_on_client(&client, sql, max_rows, cancelled, &mut on_row).await {
+        Ok(rows) => Ok(rows),
+        Err(error) if should_retry_postgres_text_query_message(&error.to_ascii_lowercase()) => {
+            stream_query_rows_text_on_client(&client, sql, max_rows, cancelled, &mut on_row).await
+        }
+        Err(error) => Err(error),
+    }
+}
+
+async fn stream_query_rows_on_client(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    max_rows: Option<usize>,
+    cancelled: &AtomicBool,
+    on_row: &mut impl FnMut(&[serde_json::Value]) -> Result<(), String>,
+) -> Result<u64, String> {
+    let stmt = client.prepare_cached(sql).await.map_err(pg_error_to_string)?;
+    let column_types: Vec<String> = stmt.columns().iter().map(|c| c.type_().name().to_string()).collect();
+    let params: Vec<&(dyn tokio_postgres::types::ToSql + Sync)> = Vec::new();
+    let stream = client.query_raw(&stmt, params).await.map_err(pg_error_to_string)?;
+    tokio::pin!(stream);
+    let row_limit = max_rows.unwrap_or(usize::MAX);
+    let mut rows_exported = 0_u64;
+
+    while let Some(row_result) = stream.next().await {
+        if cancelled.load(std::sync::atomic::Ordering::SeqCst) {
+            return Err(crate::query::canceled_error());
+        }
+        if rows_exported as usize >= row_limit {
+            break;
+        }
+        let row = row_result.map_err(pg_error_to_string)?;
+        let values: Vec<serde_json::Value> = (0..row.columns().len())
+            .map(|i| pg_value_to_json(&row, i, column_types.get(i).map(String::as_str).unwrap_or("")))
+            .collect();
+        on_row(&values)?;
+        rows_exported += 1;
+    }
+
+    Ok(rows_exported)
+}
+
+async fn stream_query_rows_text_on_client(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    max_rows: Option<usize>,
+    cancelled: &AtomicBool,
+    on_row: &mut impl FnMut(&[serde_json::Value]) -> Result<(), String>,
+) -> Result<u64, String> {
+    let messages = client.simple_query(sql).await.map_err(pg_error_to_string)?;
+    let row_limit = max_rows.unwrap_or(usize::MAX);
+    let mut rows_exported = 0_u64;
+
+    for message in messages {
+        if cancelled.load(std::sync::atomic::Ordering::SeqCst) {
+            return Err(crate::query::canceled_error());
+        }
+        if rows_exported as usize >= row_limit {
+            break;
+        }
+        if let SimpleQueryMessage::Row(row) = message {
+            let mut values = Vec::with_capacity(row.len());
+            for i in 0..row.len() {
+                values.push(match row.try_get(i).map_err(pg_error_to_string)? {
+                    Some(value) => serde_json::Value::String(value.to_string()),
+                    None => serde_json::Value::Null,
+                });
+            }
+            on_row(&values)?;
+            rows_exported += 1;
+        }
+    }
+
+    Ok(rows_exported)
+}
+
+pub async fn connect(url: &str, fallback_timeout: Duration) -> Result<Pool, String> {
+    let url_with_keepalive = inject_postgres_keepalive_params(url);
+    let postgres_url = postgres_connection_url(&url_with_keepalive)?;
+    let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
+
+    let timeout = super::parse_connect_timeout_with_fallback(url, fallback_timeout);
+    let tz = iana_time_zone::get_timezone().unwrap_or_else(|_| "UTC".to_string());
+
+    super::with_connection_timeout("PostgreSQL", timeout, async {
+        let pg_config = tokio_postgres::Config::from_str(&postgres_url.url)
+            .map_err(|e| format!("Invalid PostgreSQL connection URL: {e}"))?;
+
+        // Fast recycling only checks whether the connection is already closed
+        // instead of issuing a validation query on every checkout, saving one
+        // round-trip per query. Connections that went stale without being
+        // observed are caught when the query runs and recovered by the
+        // executor's ReconnectAndRetry path (see pool_error_action / do_execute
+        // in query.rs).
+        let mgr_config = ManagerConfig { recycling_method: RecyclingMethod::Fast };
+        let tls_config = postgres_tls_config(
+            &pg_config,
+            &postgres_url.ssl_files,
+            postgres_url.accepts_invalid_certs,
+            postgres_url.verifies_hostname,
+        )?;
+        let mgr = deadpool_postgres::Manager::from_config(
+            pg_config.clone(),
+            tokio_postgres_rustls::MakeRustlsConnect::new(tls_config),
+            mgr_config,
+        );
+        let pool = Pool::builder(mgr)
+            .max_size(10)
+            .runtime(Runtime::Tokio1)
+            .wait_timeout(Some(timeout))
+            .create_timeout(Some(timeout))
+            .recycle_timeout(Some(timeout))
+            .build()
+            .map_err(|e| format!("Failed to create PostgreSQL pool: {e}"))?;
+
+        // Verify connectivity and set timezone. Only set timezone if the user
+        // hasn't already specified one via connection parameters (e.g. options=-c timezone=...)
+        let client =
+            pool.get().await.map_err(|e| format!("PostgreSQL connection failed: {}", pg_pool_error_to_string(e)))?;
+        if !pg_url_has_timezone_setting(url) {
+            client
+                .execute(&format!("SET timezone = '{}'", tz.replace('\'', "''")), &[])
+                .await
+                .map_err(|e| format!("PostgreSQL SET timezone failed: {e}"))?;
+        }
+
+        Ok(pool)
+    })
+    .await
+}
+
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub struct PostgresSslFiles {
+    pub sslcert: Option<String>,
+    pub sslkey: Option<String>,
+    pub sslrootcert: Option<String>,
+}
+
+/// TLS context info, used to reconstruct the TLS connector when cancelling a query.
+#[derive(Debug, Clone)]
+pub struct PostgresCancelContext {
+    pub ssl_files: PostgresSslFiles,
+    pub accepts_invalid_certs: bool,
+    pub verifies_hostname: bool,
+    pub ssl_mode: SslMode,
+}
+
+/// Build a TLS cancel context from the connection URL.
+/// Returns None if URL parsing fails or sslmode=disable (no TLS cancel needed).
+pub fn build_postgres_cancel_context(url: &str) -> Option<PostgresCancelContext> {
+    let postgres_url = postgres_connection_url(url).ok()?;
+    let pg_config = tokio_postgres::Config::from_str(&postgres_url.url).ok()?;
+    if pg_config.get_ssl_mode() == SslMode::Disable {
+        return None;
+    }
+    Some(PostgresCancelContext {
+        ssl_files: postgres_url.ssl_files,
+        accepts_invalid_certs: postgres_url.accepts_invalid_certs,
+        verifies_hostname: postgres_url.verifies_hostname,
+        ssl_mode: pg_config.get_ssl_mode(),
+    })
+}
+
+/// Reconstruct a TLS connector from the cancel context, used for TLS connection cancellation.
+fn make_rustls_connect_from_context(
+    ctx: &PostgresCancelContext,
+) -> Result<tokio_postgres_rustls::MakeRustlsConnect, String> {
+    // Build a minimal pg_config solely for ssl_mode determination
+    let mut pg_config = tokio_postgres::Config::new();
+    pg_config.ssl_mode(ctx.ssl_mode);
+    let tls_config = postgres_tls_config(&pg_config, &ctx.ssl_files, ctx.accepts_invalid_certs, ctx.verifies_hostname)?;
+    Ok(tokio_postgres_rustls::MakeRustlsConnect::new(tls_config))
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct PostgresConnectionUrl {
+    url: String,
+    ssl_files: PostgresSslFiles,
+    accepts_invalid_certs: bool,
+    verifies_hostname: bool,
+}
+
+/// Inject TCP keepalive parameters into the PostgreSQL URL (only when the user has not explicitly specified them).
+/// Default parameters shorten half-open connection detection time, suitable for desktop/VPN/NAT environments.
+fn inject_postgres_keepalive_params(url: &str) -> String {
+    let (base, fragment) = url.split_once('#').map_or((url, ""), |(base, fragment)| (base, fragment));
+    let query = base.split('?').nth(1);
+    let has_keepalives = query
+        .map(|q| q.split('&').any(|p| p.split('=').next().is_some_and(|k| k.eq_ignore_ascii_case("keepalives"))))
+        .unwrap_or(false);
+    if has_keepalives {
+        return url.to_string(); // User has explicitly configured keepalive
+    }
+    let separator = if base.contains('?') { "&" } else { "?" };
+    let injected =
+        format!("{base}{separator}keepalives=1&keepalives_idle=30&keepalives_interval=10&keepalives_retries=3");
+    if fragment.is_empty() {
+        injected
+    } else {
+        format!("{injected}#{fragment}")
+    }
+}
+
+fn postgres_connection_url(url: &str) -> Result<PostgresConnectionUrl, String> {
+    let Some(query_start) = url.find('?') else {
+        let pg_config =
+            tokio_postgres::Config::from_str(url).map_err(|e| format!("Invalid PostgreSQL connection URL: {e}"))?;
+        return Ok(PostgresConnectionUrl {
+            url: url.to_string(),
+            ssl_files: PostgresSslFiles::default(),
+            accepts_invalid_certs: postgres_sslmode_accepts_invalid_certs(pg_config.get_ssl_mode()),
+            verifies_hostname: false,
+        });
+    };
+
+    let prefix = &url[..query_start];
+    let suffix = &url[query_start + 1..];
+    let (query_string, fragment) = suffix.split_once('#').map_or((suffix, ""), |(query, fragment)| (query, fragment));
+    let mut ssl_files = PostgresSslFiles::default();
+    let mut kept_params = Vec::new();
+    let mut accepts_invalid_certs = true;
+    let mut verifies_hostname = false;
+
+    for param in query_string.split('&') {
+        if param.is_empty() {
+            continue;
+        }
+
+        let Some((key, value)) = param.split_once('=') else {
+            kept_params.push(param.to_string());
+            continue;
+        };
+
+        if key.eq_ignore_ascii_case("sslcert")
+            || key.eq_ignore_ascii_case("sslkey")
+            || key.eq_ignore_ascii_case("sslrootcert")
+        {
+            let decoded = percent_decode_str(value)
+                .decode_utf8()
+                .map_err(|_| format!("Invalid URL encoding in {key}"))?
+                .into_owned();
+            validate_file_path(&decoded, |_| false).map_err(|e| format!("{key}: {e}"))?;
+
+            if key.eq_ignore_ascii_case("sslcert") {
+                ssl_files.sslcert = Some(decoded);
+            } else if key.eq_ignore_ascii_case("sslkey") {
+                ssl_files.sslkey = Some(decoded);
+            } else {
+                ssl_files.sslrootcert = Some(decoded);
+            }
+        } else if key.eq_ignore_ascii_case("channel_binding") {
+            // channel_binding=require fails when the server does not offer
+            // SCRAM-SHA-256-PLUS (e.g. Neon). Normalize require→prefer so
+            // channel binding is used when available but does not cause a
+            // hard failure when the server doesn't support it.
+            match value.to_ascii_lowercase().as_str() {
+                "require" => kept_params.push("channel_binding=prefer".to_string()),
+                _ => kept_params.push(param.to_string()),
+            }
+        } else if key.eq_ignore_ascii_case("sslmode") {
+            match value.to_ascii_lowercase().as_str() {
+                "verify-ca" => {
+                    accepts_invalid_certs = false;
+                    kept_params.push("sslmode=require".to_string());
+                }
+                "verify-full" | "verify_identity" | "verify-identity" => {
+                    accepts_invalid_certs = false;
+                    verifies_hostname = true;
+                    kept_params.push("sslmode=require".to_string());
+                }
+                "disable" => {
+                    accepts_invalid_certs = false;
+                    kept_params.push(param.to_string());
+                }
+                "prefer" | "require" => {
+                    accepts_invalid_certs = true;
+                    kept_params.push(param.to_string());
+                }
+                _ => kept_params.push(param.to_string()),
+            }
+        } else {
+            kept_params.push(param.to_string());
+        }
+    }
+
+    let mut sanitized_url = prefix.to_string();
+    if !kept_params.is_empty() {
+        sanitized_url.push('?');
+        sanitized_url.push_str(&kept_params.join("&"));
+    }
+    if !fragment.is_empty() {
+        sanitized_url.push('#');
+        sanitized_url.push_str(fragment);
+    }
+
+    Ok(PostgresConnectionUrl { url: sanitized_url, ssl_files, accepts_invalid_certs, verifies_hostname })
+}
+
+fn postgres_tls_config(
+    pg_config: &tokio_postgres::Config,
+    ssl_files: &PostgresSslFiles,
+    accepts_invalid_certs: bool,
+    verifies_hostname: bool,
+) -> Result<rustls::ClientConfig, String> {
+    if pg_config.get_ssl_mode() != SslMode::Disable && accepts_invalid_certs {
+        let provider = Arc::new(rustls::crypto::aws_lc_rs::default_provider());
+        let builder = rustls::ClientConfig::builder()
+            .dangerous()
+            .with_custom_certificate_verifier(Arc::new(NoPostgresCertVerification { provider }));
+        return postgres_tls_client_auth(builder, ssl_files);
+    }
+
+    let root_store = postgres_root_cert_store(ssl_files)?;
+    let builder = if verifies_hostname {
+        rustls::ClientConfig::builder().with_root_certificates(root_store)
+    } else {
+        let provider = Arc::new(rustls::crypto::aws_lc_rs::default_provider());
+        rustls::ClientConfig::builder().dangerous().with_custom_certificate_verifier(Arc::new(
+            PostgresCaOnlyCertVerification { provider, roots: Arc::new(root_store) },
+        ))
+    };
+    postgres_tls_client_auth(builder, ssl_files)
+}
+
+fn postgres_root_cert_store(ssl_files: &PostgresSslFiles) -> Result<rustls::RootCertStore, String> {
+    let mut root_store = rustls::RootCertStore::empty();
+    if let Some(path) = ssl_files.sslrootcert.as_deref() {
+        let certs = read_postgres_pem_certs("sslrootcert", path)?;
+        let (valid_count, _) = root_store.add_parsable_certificates(certs);
+        if valid_count == 0 {
+            return Err(format!("sslrootcert: no valid CA certificates found in {path}"));
+        }
+    } else {
+        root_store.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
+    }
+    Ok(root_store)
+}
+
+fn postgres_tls_client_auth(
+    builder: rustls::ConfigBuilder<rustls::ClientConfig, rustls::client::WantsClientCert>,
+    ssl_files: &PostgresSslFiles,
+) -> Result<rustls::ClientConfig, String> {
+    match (ssl_files.sslcert.as_deref(), ssl_files.sslkey.as_deref()) {
+        (Some(cert_path), Some(key_path)) => {
+            let certs = read_postgres_pem_certs("sslcert", cert_path)?;
+            if certs.is_empty() {
+                return Err(format!("sslcert: no certificates found in {cert_path}"));
+            }
+            let private_key = read_postgres_private_key(key_path)?;
+            builder
+                .with_client_auth_cert(certs, private_key)
+                .map_err(|e| format!("PostgreSQL client certificate/key mismatch or invalid key: {e}"))
+        }
+        (Some(_), None) => Err("PostgreSQL sslcert requires sslkey".to_string()),
+        (None, Some(_)) => Err("PostgreSQL sslkey requires sslcert".to_string()),
+        (None, None) => Ok(builder.with_no_client_auth()),
+    }
+}
+
+fn read_postgres_pem_certs(label: &str, path: &str) -> Result<Vec<CertificateDer<'static>>, String> {
+    let file = File::open(path).map_err(|e| format!("{label}: failed to open {path}: {e}"))?;
+    let mut reader = BufReader::new(file);
+    rustls_pemfile::certs(&mut reader)
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|e| format!("{label}: failed to read PEM certificates from {path}: {e}"))
+}
+
+fn read_postgres_private_key(path: &str) -> Result<PrivateKeyDer<'static>, String> {
+    let file = File::open(path).map_err(|e| format!("sslkey: failed to open {path}: {e}"))?;
+    let mut reader = BufReader::new(file);
+    rustls_pemfile::private_key(&mut reader)
+        .map_err(|e| format!("sslkey: failed to read PEM private key from {path}: {e}"))?
+        .ok_or_else(|| format!("sslkey: no private key found in {path}"))
+}
+
+fn postgres_sslmode_accepts_invalid_certs(ssl_mode: SslMode) -> bool {
+    matches!(ssl_mode, SslMode::Prefer | SslMode::Require)
+}
+
+#[derive(Debug)]
+struct NoPostgresCertVerification {
+    provider: Arc<CryptoProvider>,
+}
+
+impl ServerCertVerifier for NoPostgresCertVerification {
+    fn verify_server_cert(
+        &self,
+        _end_entity: &CertificateDer<'_>,
+        _intermediates: &[CertificateDer<'_>],
+        _server_name: &ServerName<'_>,
+        _ocsp_response: &[u8],
+        _now: UnixTime,
+    ) -> Result<ServerCertVerified, rustls::Error> {
+        Ok(ServerCertVerified::assertion())
+    }
+
+    fn verify_tls12_signature(
+        &self,
+        _message: &[u8],
+        cert: &CertificateDer<'_>,
+        _dss: &rustls::DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        self.accept_tls_signature_for_unverified_cert(cert)
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        _message: &[u8],
+        cert: &CertificateDer<'_>,
+        _dss: &rustls::DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        self.accept_tls_signature_for_unverified_cert(cert)
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
+        self.provider.signature_verification_algorithms.supported_schemes()
+    }
+}
+
+impl NoPostgresCertVerification {
+    fn accept_tls_signature_for_unverified_cert(
+        &self,
+        _cert: &CertificateDer<'_>,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        // PostgreSQL sslmode=prefer/require does not authenticate the server certificate.
+        // Avoid rustls' default signature helpers here because they parse the certificate
+        // before chain verification and reject legacy server certificates that libpq/JDBC
+        // still accept in these non-verifying modes.
+        Ok(HandshakeSignatureValid::assertion())
+    }
+}
+
+#[derive(Debug)]
+struct PostgresCaOnlyCertVerification {
+    provider: Arc<CryptoProvider>,
+    roots: Arc<rustls::RootCertStore>,
+}
+
+impl ServerCertVerifier for PostgresCaOnlyCertVerification {
+    fn verify_server_cert(
+        &self,
+        end_entity: &CertificateDer<'_>,
+        intermediates: &[CertificateDer<'_>],
+        _server_name: &ServerName<'_>,
+        _ocsp_response: &[u8],
+        now: UnixTime,
+    ) -> Result<ServerCertVerified, rustls::Error> {
+        let cert = ParsedCertificate::try_from(end_entity)?;
+        verify_server_cert_signed_by_trust_anchor(
+            &cert,
+            &self.roots,
+            intermediates,
+            now,
+            self.provider.signature_verification_algorithms.all,
+        )?;
+        Ok(ServerCertVerified::assertion())
+    }
+
+    fn verify_tls12_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &rustls::DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        verify_tls12_signature(message, cert, dss, &self.provider.signature_verification_algorithms)
+    }
+
+    fn verify_tls13_signature(
+        &self,
+        message: &[u8],
+        cert: &CertificateDer<'_>,
+        dss: &rustls::DigitallySignedStruct,
+    ) -> Result<HandshakeSignatureValid, rustls::Error> {
+        verify_tls13_signature(message, cert, dss, &self.provider.signature_verification_algorithms)
+    }
+
+    fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {
+        self.provider.signature_verification_algorithms.supported_schemes()
+    }
+}
+
+/// Check whether the user's connection URL already specifies a timezone via
+/// the `options` parameter so we don't overwrite it with the local timezone.
+fn pg_url_has_timezone_setting(url: &str) -> bool {
+    let lower = url.to_lowercase();
+    // Match "timezone=" anywhere after the query string, covering:
+    //   ?options=-c timezone=Asia/Shanghai
+    //   ?options=--timezone=UTC
+    // Also handles URL-encoded forms like timezone%3D
+    if let Some(query) = lower.split('?').nth(1) {
+        if query.contains("timezone=") || query.contains("timezone%3d") {
+            return true;
+        }
+    }
+    false
+}
+
+#[cfg(test)]
+fn validate_postgres_ssl_paths(url: &str) -> Result<(), String> {
+    postgres_connection_url(url).map(|_| ())
+}
+
+pub async fn list_databases(pool: &Pool) -> Result<Vec<DatabaseInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(
+        &client,
+        "SELECT datname FROM pg_database \
+         WHERE datallowconn = true \
+         ORDER BY datname",
+        &[],
+    )
+    .await
+    .map_err(|e| e.to_string())?;
+
+    Ok(rows.iter().map(|row| DatabaseInfo { name: pg_row_try_string(row, 0) }).collect())
+}
+
+pub async fn list_tables(pool: &Pool, schema: &str) -> Result<Vec<TableInfo>, String> {
+    list_tables_filtered(pool, schema, None, None, None).await
+}
+
+pub async fn list_tables_filtered(
+    pool: &Pool,
+    schema: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+) -> Result<Vec<TableInfo>, String> {
+    let schema = if schema.is_empty() { "public" } else { schema };
+    let filter = filter.unwrap_or("").trim();
+    let filter_pattern = like_contains_pattern(filter);
+    let fuzzy_filter_pattern =
+        if crate::sql::fuzzy_filter_enabled(filter) { like_fuzzy_pattern(filter) } else { String::new() };
+    let limit_param = limit.and_then(|value| i64::try_from(value).ok());
+    let offset_param = offset.and_then(|value| i64::try_from(value).ok()).unwrap_or(0);
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(
+        &client,
+        postgres_tables_sql(),
+        &[&schema, &filter_pattern, &fuzzy_filter_pattern, &limit_param, &offset_param],
+    )
+    .await
+    .map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| TableInfo {
+            name: pg_row_try_string(row, 0),
+            table_type: pg_row_try_string(row, 1),
+            comment: row.try_get::<_, Option<String>>(2).ok().flatten().filter(|s| !s.is_empty()),
+            parent_schema: row.try_get::<_, Option<String>>(3).ok().flatten().filter(|s| !s.is_empty()),
+            parent_name: row.try_get::<_, Option<String>>(4).ok().flatten().filter(|s| !s.is_empty()),
+        })
+        .collect())
+}
+
+pub async fn completion_assistant_search(
+    pool: &Pool,
+    request: &CompletionAssistantRequest,
+) -> Result<CompletionAssistantResponse, String> {
+    let schema = request.schema.as_deref().or(request.parent_schema.as_deref());
+    let routine_schema = schema.unwrap_or("public");
+    let limit = request.max_results.unwrap_or(100).clamp(1, 1000);
+    let kinds = if request.object_kinds.is_empty() {
+        vec![CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View]
+    } else {
+        request.object_kinds.clone()
+    };
+    let pattern = postgres_completion_like_pattern(&request.mask, request.match_mode.as_ref());
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let mut candidates = Vec::new();
+
+    if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Schema)) {
+        for row in postgres_query_cached(
+            &client,
+            "SELECT nspname FROM pg_catalog.pg_namespace \
+             WHERE nspname NOT LIKE 'pg_%' AND nspname <> 'information_schema' \
+               AND ($1 = '%%' OR nspname ILIKE $1 ESCAPE '~') \
+             ORDER BY nspname LIMIT $2",
+            &[&pattern, &(limit as i64)],
+        )
+        .await
+        .map_err(|e| e.to_string())?
+        {
+            let schema_name: String = pg_row_try_string(&row, 0);
+            candidates.push(CompletionAssistantCandidate {
+                name: schema_name.clone(),
+                kind: CompletionAssistantCandidateKind::Schema,
+                database: Some(request.database.clone()),
+                schema: Some(schema_name),
+                parent_schema: None,
+                parent_name: None,
+                comment: None,
+                data_type: None,
+            });
+        }
+    }
+
+    if candidates.len() < limit && kinds.iter().any(CompletionAssistantObjectKind::is_table_like) {
+        let relkinds = postgres_completion_relkinds(&kinds);
+        let rows = postgres_query_cached(
+            &client,
+            postgres_completion_tables_sql(),
+            &[&schema, &pattern, &relkinds, &((limit - candidates.len()) as i64)],
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+        for row in rows {
+            let table_type: String = pg_row_try_string(&row, 2);
+            candidates.push(CompletionAssistantCandidate {
+                name: pg_row_try_string(&row, 0),
+                kind: if table_type.contains("VIEW") {
+                    CompletionAssistantCandidateKind::View
+                } else {
+                    CompletionAssistantCandidateKind::Table
+                },
+                database: Some(request.database.clone()),
+                schema: Some(pg_row_try_string(&row, 1)),
+                parent_schema: row.try_get::<_, Option<String>>(4).ok().flatten(),
+                parent_name: row.try_get::<_, Option<String>>(5).ok().flatten(),
+                comment: row.try_get::<_, Option<String>>(3).ok().flatten(),
+                data_type: None,
+            });
+        }
+    }
+
+    if candidates.len() < limit && kinds.iter().any(CompletionAssistantObjectKind::is_routine_like) {
+        let prokinds = postgres_completion_prokinds(&kinds);
+        let rows = postgres_query_cached(
+            &client,
+            postgres_completion_routines_sql(),
+            &[&routine_schema, &pattern, &prokinds, &((limit - candidates.len()) as i64)],
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+        for row in rows {
+            let routine_type: String = pg_row_try_string(&row, 2);
+            candidates.push(CompletionAssistantCandidate {
+                name: pg_row_try_string(&row, 0),
+                kind: if routine_type == "PROCEDURE" {
+                    CompletionAssistantCandidateKind::Procedure
+                } else {
+                    CompletionAssistantCandidateKind::Function
+                },
+                database: Some(request.database.clone()),
+                schema: Some(pg_row_try_string(&row, 1)),
+                parent_schema: None,
+                parent_name: None,
+                comment: row.try_get::<_, Option<String>>(3).ok().flatten(),
+                data_type: row.try_get::<_, Option<String>>(4).ok().flatten(),
+            });
+        }
+    }
+
+    if candidates.len() < limit && kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Column)) {
+        let table = request.parent_name.as_deref().unwrap_or("");
+        if !table.is_empty() {
+            // Unqualified PostgreSQL objects resolve through search_path, so column
+            // metadata must use the same visible relation instead of assuming public.
+            let resolved_schema = match schema {
+                Some(schema) => Some(schema.to_string()),
+                None => postgres_query_cached(&client, postgres_visible_table_schema_sql(), &[&table])
+                    .await
+                    .map_err(|e| e.to_string())?
+                    .first()
+                    .map(|row| pg_row_try_string(row, 0)),
+            };
+            let Some(resolved_schema) = resolved_schema else {
+                return Ok(CompletionAssistantResponse { incomplete: false, candidates, fallback_used: false });
+            };
+            let rows = postgres_query_cached(
+                &client,
+                postgres_completion_columns_sql(),
+                &[&resolved_schema, &table, &pattern, &((limit - candidates.len()) as i64)],
+            )
+            .await
+            .map_err(|e| e.to_string())?;
+            for row in rows {
+                candidates.push(CompletionAssistantCandidate {
+                    name: pg_row_try_string(&row, 0),
+                    kind: CompletionAssistantCandidateKind::Column,
+                    database: Some(request.database.clone()),
+                    schema: Some(resolved_schema.clone()),
+                    parent_schema: Some(resolved_schema.clone()),
+                    parent_name: Some(table.to_string()),
+                    comment: row.try_get::<_, Option<String>>(2).ok().flatten(),
+                    data_type: Some(pg_row_try_string(&row, 1)),
+                });
+            }
+        }
+    }
+
+    Ok(CompletionAssistantResponse { incomplete: candidates.len() >= limit, candidates, fallback_used: false })
+}
+
+fn postgres_completion_tables_sql() -> &'static str {
+    "SELECT c.relname, n.nspname, \
+            CASE c.relkind WHEN 'v' THEN 'VIEW' WHEN 'm' THEN 'VIEW' ELSE 'TABLE' END AS table_type, \
+            obj_description(c.oid) AS table_comment, \
+            CASE WHEN pc.relkind = 'p' THEN pn.nspname ELSE NULL END AS parent_schema, \
+            CASE WHEN pc.relkind = 'p' THEN pc.relname ELSE NULL END AS parent_name \
+     FROM pg_catalog.pg_class c \
+     JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+     LEFT JOIN pg_catalog.pg_inherits i ON i.inhrelid = c.oid \
+     LEFT JOIN pg_catalog.pg_class pc ON pc.oid = i.inhparent \
+     LEFT JOIN pg_catalog.pg_namespace pn ON pn.oid = pc.relnamespace \
+     WHERE ($1::text IS NOT NULL AND n.nspname = $1 \
+            OR $1::text IS NULL AND pg_catalog.pg_table_is_visible(c.oid)) \
+       AND c.relkind = ANY($3) \
+       AND ($2 = '%%' OR c.relname ILIKE $2 ESCAPE '~') \
+     ORDER BY c.relname LIMIT $4"
+}
+
+fn postgres_completion_routines_sql() -> &'static str {
+    "SELECT p.proname, n.nspname, CASE p.prokind WHEN 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END, \
+            obj_description(p.oid) AS routine_comment, COALESCE(pg_get_function_result(p.oid), '') AS data_type \
+     FROM pg_catalog.pg_proc p \
+     JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+     WHERE n.nspname = $1 AND p.prokind = ANY($3) \
+       AND ($2 = '%%' OR p.proname ILIKE $2 ESCAPE '~') \
+     ORDER BY p.proname LIMIT $4"
+}
+
+fn postgres_completion_columns_sql() -> &'static str {
+    "SELECT a.attname, pg_catalog.format_type(a.atttypid, a.atttypmod), col_description(c.oid, a.attnum) \
+     FROM pg_catalog.pg_attribute a \
+     JOIN pg_catalog.pg_class c ON c.oid = a.attrelid \
+     JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+     WHERE n.nspname = $1 AND c.relname = $2 AND a.attnum > 0 AND NOT a.attisdropped \
+       AND ($3 = '%%' OR a.attname ILIKE $3 ESCAPE '~') \
+     ORDER BY a.attnum LIMIT $4"
+}
+
+fn postgres_visible_table_schema_sql() -> &'static str {
+    "SELECT n.nspname FROM pg_catalog.pg_class c \
+     JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+     WHERE c.relname = $1 AND pg_catalog.pg_table_is_visible(c.oid) \
+     LIMIT 1"
+}
+
+fn postgres_completion_relkinds(kinds: &[CompletionAssistantObjectKind]) -> Vec<String> {
+    let mut relkinds = Vec::new();
+    if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Table)) {
+        relkinds.extend(["r", "p", "f"].into_iter().map(str::to_string));
+    }
+    if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::View)) {
+        relkinds.extend(["v", "m"].into_iter().map(str::to_string));
+    }
+    relkinds
+}
+
+fn postgres_completion_prokinds(kinds: &[CompletionAssistantObjectKind]) -> Vec<String> {
+    let mut prokinds = Vec::new();
+    if kinds
+        .iter()
+        .any(|kind| matches!(kind, CompletionAssistantObjectKind::Procedure | CompletionAssistantObjectKind::Routine))
+    {
+        prokinds.push("p".to_string());
+    }
+    if kinds
+        .iter()
+        .any(|kind| matches!(kind, CompletionAssistantObjectKind::Function | CompletionAssistantObjectKind::Routine))
+    {
+        prokinds.push("f".to_string());
+    }
+    prokinds
+}
+
+fn postgres_completion_like_pattern(value: &str, mode: Option<&CompletionAssistantMatchMode>) -> String {
+    if value.trim().is_empty() || value == "%" {
+        return "%%".to_string();
+    }
+    let escaped = value.trim().replace('~', "~~").replace('%', "~%").replace('_', "~_");
+    match mode.unwrap_or(&CompletionAssistantMatchMode::Prefix) {
+        CompletionAssistantMatchMode::Prefix => format!("{escaped}%"),
+        CompletionAssistantMatchMode::Contains => format!("%{escaped}%"),
+    }
+}
+
+pub async fn get_table_comment(pool: &Pool, schema: &str, table: &str) -> Result<Option<String>, String> {
+    let schema = if schema.is_empty() { "public" } else { schema };
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(&client, postgres_table_comment_sql(), &[&schema, &table])
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(rows.first().and_then(|row| row.try_get::<_, Option<String>>(0).ok().flatten()).filter(|s| !s.is_empty()))
+}
+
+fn postgres_table_comment_sql() -> &'static str {
+    "SELECT obj_description(c.oid) AS table_comment \
+     FROM pg_catalog.pg_class c \
+     JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+     WHERE n.nspname = $1 AND c.relname = $2 AND c.relkind IN ('r','m','f','p') \
+     LIMIT 1"
+}
+
+fn postgres_tables_sql() -> &'static str {
+    // PostgreSQL and Redshift can infer different wire types for LIMIT/OFFSET
+    // placeholders. Keep them explicit so the shared i64 parameters serialize reliably.
+    "SELECT c.relname AS table_name, \
+         CASE c.relkind WHEN 'r' THEN 'BASE TABLE' WHEN 'v' THEN 'VIEW' \
+           WHEN 'm' THEN 'MATERIALIZED_VIEW' WHEN 'f' THEN 'FOREIGN TABLE' \
+           WHEN 'p' THEN 'BASE TABLE' END AS table_type, \
+         obj_description(c.oid) AS table_comment, \
+         CASE WHEN pc.relkind = 'p' THEN pn.nspname ELSE NULL END AS parent_schema, \
+         CASE WHEN pc.relkind = 'p' THEN pc.relname ELSE NULL END AS parent_name \
+         FROM pg_catalog.pg_class c \
+         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+         LEFT JOIN pg_catalog.pg_inherits i ON i.inhrelid = c.oid \
+         LEFT JOIN pg_catalog.pg_class pc ON pc.oid = i.inhparent \
+         LEFT JOIN pg_catalog.pg_namespace pn ON pn.oid = pc.relnamespace \
+         WHERE n.nspname = $1 AND c.relkind IN ('r','v','m','f','p') \
+           AND ($2 = '%%' OR c.relname ILIKE $2 ESCAPE '~' OR ($3 <> '' AND c.relname ILIKE $3 ESCAPE '~')) \
+         ORDER BY c.relname \
+         LIMIT CAST($4 AS BIGINT) OFFSET CAST($5 AS BIGINT)"
+}
+
+fn like_contains_pattern(value: &str) -> String {
+    if value.is_empty() {
+        return "%%".to_string();
+    }
+
+    let mut pattern = String::with_capacity(value.len() + 2);
+    pattern.push('%');
+    for ch in value.chars() {
+        if ch == '~' || ch == '%' || ch == '_' {
+            pattern.push('~');
+        }
+        pattern.push(ch);
+    }
+    pattern.push('%');
+    pattern
+}
+
+fn like_fuzzy_pattern(value: &str) -> String {
+    crate::sql::fuzzy_like_pattern_with_escape(value, |value| {
+        let mut escaped = String::with_capacity(value.len() + 1);
+        for ch in value.chars() {
+            if ch == '~' || ch == '%' || ch == '_' {
+                escaped.push('~');
+            }
+            escaped.push(ch);
+        }
+        escaped
+    })
+}
+
+fn list_object_relations_sql(include_timestamps: bool) -> &'static str {
+    if include_timestamps {
+        return "SELECT c.relname AS object_name, \
+       CASE c.relkind \
+         WHEN 'v' THEN 'VIEW' \
+         WHEN 'm' THEN 'MATERIALIZED_VIEW' \
+         WHEN 'S' THEN 'SEQUENCE' \
+         ELSE 'TABLE' \
+       END AS object_type, \
+       obj_description(c.oid) AS object_comment, \
+       stat.creation::text AS created_at, \
+       COALESCE( \
+         CASE WHEN current_setting('track_commit_timestamp', true) = 'on' \
+           THEN pg_xact_commit_timestamp(c.xmin)::text END, \
+         stat.modification::text \
+       ) AS updated_at, \
+       CASE WHEN pc.relkind = 'p' THEN pn.nspname ELSE NULL END AS parent_schema, \
+       CASE WHEN pc.relkind = 'p' THEN pc.relname ELSE NULL END AS parent_name, \
+       NULL::text AS signature, \
+       CASE c.relkind WHEN 'v' THEN 1 WHEN 'm' THEN 1 WHEN 'S' THEN 4 ELSE 0 END AS sort_order \
+     FROM pg_catalog.pg_class c \
+     JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+     LEFT JOIN pg_catalog.pg_inherits i ON i.inhrelid = c.oid \
+     LEFT JOIN pg_catalog.pg_class pc ON pc.oid = i.inhparent \
+     LEFT JOIN pg_catalog.pg_namespace pn ON pn.oid = pc.relnamespace \
+     LEFT JOIN LATERAL pg_stat_file( \
+       CASE WHEN c.relkind IN ('r','m','f','p') THEN pg_relation_filepath(c.oid) END, true \
+     ) stat ON true \
+     WHERE n.nspname = $1 AND c.relkind IN ('r','v','m','f','p','S')";
+    }
+
+    "SELECT c.relname AS object_name, \
+       CASE c.relkind \
+         WHEN 'v' THEN 'VIEW' \
+         WHEN 'm' THEN 'MATERIALIZED_VIEW' \
+         WHEN 'S' THEN 'SEQUENCE' \
+         ELSE 'TABLE' \
+       END AS object_type, \
+       obj_description(c.oid) AS object_comment, \
+       NULL::text AS created_at, \
+       NULL::text AS updated_at, \
+       CASE WHEN pc.relkind = 'p' THEN pn.nspname ELSE NULL END AS parent_schema, \
+       CASE WHEN pc.relkind = 'p' THEN pc.relname ELSE NULL END AS parent_name, \
+       NULL::text AS signature, \
+       CASE c.relkind WHEN 'v' THEN 1 WHEN 'm' THEN 1 WHEN 'S' THEN 4 ELSE 0 END AS sort_order \
+     FROM pg_catalog.pg_class c \
+     JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+     LEFT JOIN pg_catalog.pg_inherits i ON i.inhrelid = c.oid \
+     LEFT JOIN pg_catalog.pg_class pc ON pc.oid = i.inhparent \
+     LEFT JOIN pg_catalog.pg_namespace pn ON pn.oid = pc.relnamespace \
+     WHERE n.nspname = $1 AND c.relkind IN ('r','v','m','f','p','S')"
+}
+
+fn list_object_routines_sql(include_timestamps: bool, has_proc_prokind: bool, has_proc_prosp: bool) -> &'static str {
+    if has_proc_prokind && has_proc_prosp {
+        if include_timestamps {
+            return "SELECT p.proname AS object_name, \
+       CASE WHEN p.prokind = 'p' OR p.prosp THEN 'PROCEDURE' ELSE 'FUNCTION' END AS object_type, \
+       obj_description(p.oid) AS object_comment, \
+       NULL::text AS created_at, \
+       CASE WHEN current_setting('track_commit_timestamp', true) = 'on' \
+         THEN pg_xact_commit_timestamp(p.xmin)::text END AS updated_at, \
+       NULL::text AS parent_schema, \
+       NULL::text AS parent_name, \
+       pg_get_function_identity_arguments(p.oid) AS signature, \
+       CASE WHEN p.prokind = 'p' OR p.prosp THEN 2 ELSE 3 END AS sort_order \
+     FROM pg_catalog.pg_proc p \
+     JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+     WHERE n.nspname = $1 AND (p.prokind IN ('p','f') OR p.prosp)";
+        }
+
+        return "SELECT p.proname AS object_name, \
+       CASE WHEN p.prokind = 'p' OR p.prosp THEN 'PROCEDURE' ELSE 'FUNCTION' END AS object_type, \
+       obj_description(p.oid) AS object_comment, \
+       NULL::text AS created_at, \
+       NULL::text AS updated_at, \
+       NULL::text AS parent_schema, \
+       NULL::text AS parent_name, \
+       pg_get_function_identity_arguments(p.oid) AS signature, \
+       CASE WHEN p.prokind = 'p' OR p.prosp THEN 2 ELSE 3 END AS sort_order \
+     FROM pg_catalog.pg_proc p \
+     JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+     WHERE n.nspname = $1 AND (p.prokind IN ('p','f') OR p.prosp)";
+    }
+
+    if has_proc_prokind {
+        if include_timestamps {
+            return "SELECT p.proname AS object_name, \
+       CASE p.prokind WHEN 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END AS object_type, \
+       obj_description(p.oid) AS object_comment, \
+       NULL::text AS created_at, \
+       CASE WHEN current_setting('track_commit_timestamp', true) = 'on' \
+         THEN pg_xact_commit_timestamp(p.xmin)::text END AS updated_at, \
+       NULL::text AS parent_schema, \
+       NULL::text AS parent_name, \
+       pg_get_function_identity_arguments(p.oid) AS signature, \
+       CASE p.prokind WHEN 'p' THEN 2 ELSE 3 END AS sort_order \
+     FROM pg_catalog.pg_proc p \
+     JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+     WHERE n.nspname = $1 AND p.prokind IN ('p','f')";
+        }
+
+        return "SELECT p.proname AS object_name, \
+       CASE p.prokind WHEN 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END AS object_type, \
+       obj_description(p.oid) AS object_comment, \
+       NULL::text AS created_at, \
+       NULL::text AS updated_at, \
+       NULL::text AS parent_schema, \
+       NULL::text AS parent_name, \
+       pg_get_function_identity_arguments(p.oid) AS signature, \
+       CASE p.prokind WHEN 'p' THEN 2 ELSE 3 END AS sort_order \
+     FROM pg_catalog.pg_proc p \
+     JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+     WHERE n.nspname = $1 AND p.prokind IN ('p','f')";
+    }
+
+    if has_proc_prosp {
+        if include_timestamps {
+            return "SELECT p.proname AS object_name, \
+       CASE WHEN p.prosp THEN 'PROCEDURE' ELSE 'FUNCTION' END AS object_type, \
+       obj_description(p.oid) AS object_comment, \
+       NULL::text AS created_at, \
+       CASE WHEN current_setting('track_commit_timestamp', true) = 'on' \
+         THEN pg_xact_commit_timestamp(p.xmin)::text END AS updated_at, \
+       NULL::text AS parent_schema, \
+       NULL::text AS parent_name, \
+       pg_get_function_identity_arguments(p.oid) AS signature, \
+       CASE WHEN p.prosp THEN 2 ELSE 3 END AS sort_order \
+     FROM pg_catalog.pg_proc p \
+     JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+     WHERE n.nspname = $1 AND NOT p.proisagg AND NOT p.proiswindow";
+        }
+
+        return "SELECT p.proname AS object_name, \
+       CASE WHEN p.prosp THEN 'PROCEDURE' ELSE 'FUNCTION' END AS object_type, \
+       obj_description(p.oid) AS object_comment, \
+       NULL::text AS created_at, \
+       NULL::text AS updated_at, \
+       NULL::text AS parent_schema, \
+       NULL::text AS parent_name, \
+       pg_get_function_identity_arguments(p.oid) AS signature, \
+       CASE WHEN p.prosp THEN 2 ELSE 3 END AS sort_order \
+     FROM pg_catalog.pg_proc p \
+     JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+     WHERE n.nspname = $1 AND NOT p.proisagg AND NOT p.proiswindow";
+    }
+
+    if include_timestamps {
+        return "SELECT p.proname AS object_name, \
+       'FUNCTION' AS object_type, \
+       obj_description(p.oid) AS object_comment, \
+       NULL::text AS created_at, \
+       CASE WHEN current_setting('track_commit_timestamp', true) = 'on' \
+         THEN pg_xact_commit_timestamp(p.xmin)::text END AS updated_at, \
+       NULL::text AS parent_schema, \
+       NULL::text AS parent_name, \
+       pg_get_function_identity_arguments(p.oid) AS signature, \
+       3 AS sort_order \
+     FROM pg_catalog.pg_proc p \
+     JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+     WHERE n.nspname = $1 AND NOT p.proisagg AND NOT p.proiswindow";
+    }
+
+    "SELECT p.proname AS object_name, \
+       'FUNCTION' AS object_type, \
+       obj_description(p.oid) AS object_comment, \
+       NULL::text AS created_at, \
+       NULL::text AS updated_at, \
+       NULL::text AS parent_schema, \
+       NULL::text AS parent_name, \
+       pg_get_function_identity_arguments(p.oid) AS signature, \
+       3 AS sort_order \
+     FROM pg_catalog.pg_proc p \
+     JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+     WHERE n.nspname = $1 AND NOT p.proisagg AND NOT p.proiswindow"
+}
+
+fn list_objects_sql(
+    include_timestamps: bool,
+    has_proc_prokind: bool,
+    has_proc_prosp: bool,
+    has_function_identity_arguments: bool,
+) -> String {
+    let sql = format!(
+        "{} UNION ALL {} ORDER BY sort_order, object_name",
+        list_object_relations_sql(include_timestamps),
+        list_object_routines_sql(include_timestamps, has_proc_prokind, has_proc_prosp)
+    );
+    if has_function_identity_arguments {
+        sql
+    } else {
+        // Redshift and older PostgreSQL-compatible servers may only expose the
+        // older formatter. It includes argument names but still distinguishes
+        // overloads instead of making the whole schema browser unavailable.
+        sql.replace("pg_get_function_identity_arguments(p.oid)", "pg_get_function_arguments(p.oid)")
+    }
+}
+
+fn postgres_has_function_identity_arguments_sql() -> &'static str {
+    "SELECT EXISTS ( \
+       SELECT 1 \
+       FROM pg_catalog.pg_proc p \
+       JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+       WHERE n.nspname = 'pg_catalog' \
+         AND p.proname = 'pg_get_function_identity_arguments' \
+     )"
+}
+
+async fn postgres_has_function_identity_arguments(client: &deadpool_postgres::Client) -> Result<bool, String> {
+    let row = postgres_query_one_cached(client, postgres_has_function_identity_arguments_sql(), &[])
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(pg_row_try_bool(&row, 0).unwrap_or(false))
+}
+
+fn postgres_proc_has_prokind_sql() -> &'static str {
+    "SELECT EXISTS ( \
+       SELECT 1 \
+       FROM pg_catalog.pg_attribute \
+       WHERE attrelid = 'pg_catalog.pg_proc'::regclass \
+         AND attname = 'prokind' \
+         AND NOT attisdropped \
+     )"
+}
+
+async fn postgres_proc_has_prokind(client: &deadpool_postgres::Client) -> Result<bool, String> {
+    let row =
+        postgres_query_one_cached(client, postgres_proc_has_prokind_sql(), &[]).await.map_err(|e| e.to_string())?;
+    Ok(pg_row_try_bool(&row, 0).unwrap_or(false))
+}
+
+fn postgres_proc_has_prosp_sql() -> &'static str {
+    "SELECT EXISTS ( \
+       SELECT 1 \
+       FROM pg_catalog.pg_attribute \
+       WHERE attrelid = 'pg_catalog.pg_proc'::regclass \
+         AND attname = 'prosp' \
+         AND NOT attisdropped \
+     )"
+}
+
+async fn postgres_proc_has_prosp(client: &deadpool_postgres::Client) -> Result<bool, String> {
+    let row = postgres_query_one_cached(client, postgres_proc_has_prosp_sql(), &[]).await.map_err(|e| e.to_string())?;
+    Ok(pg_row_try_bool(&row, 0).unwrap_or(false))
+}
+
+async fn list_objects_rows(
+    client: &deadpool_postgres::Client,
+    schema: &str,
+    include_timestamps: bool,
+    has_proc_prokind: bool,
+    has_proc_prosp: bool,
+    has_function_identity_arguments: bool,
+) -> Result<Vec<Row>, String> {
+    let sql = list_objects_sql(include_timestamps, has_proc_prokind, has_proc_prosp, has_function_identity_arguments);
+    postgres_query_cached(client, &sql, &[&schema]).await.map_err(|e| e.to_string())
+}
+
+pub async fn list_objects(pool: &Pool, schema: &str) -> Result<Vec<ObjectInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let has_proc_prokind = postgres_proc_has_prokind(&client).await?;
+    // Some GaussDB-compatible catalogs expose prosp alongside, or instead of,
+    // PostgreSQL 11's prokind. Treat prosp as an extra procedure signal.
+    let has_proc_prosp = postgres_proc_has_prosp(&client).await?;
+    let has_function_identity_arguments = postgres_has_function_identity_arguments(&client).await?;
+    let rows = match list_objects_rows(
+        &client,
+        schema,
+        true,
+        has_proc_prokind,
+        has_proc_prosp,
+        has_function_identity_arguments,
+    )
+    .await
+    {
+        Ok(rows) => rows,
+        Err(primary_error) => {
+            log::debug!("[postgres][list_objects:timestamp-fallback] primary_error={}", primary_error);
+            match list_objects_rows(
+                &client,
+                schema,
+                false,
+                has_proc_prokind,
+                has_proc_prosp,
+                has_function_identity_arguments,
+            )
+            .await
+            {
+                Ok(rows) => rows,
+                Err(fallback_error) => {
+                    return Err(format!("{primary_error}; timestamp fallback failed: {fallback_error}"));
+                }
+            }
+        }
+    };
+
+    Ok(rows
+        .iter()
+        .map(|row| ObjectInfo {
+            name: pg_row_try_string(row, 0),
+            object_type: pg_row_try_string(row, 1),
+            schema: Some(schema.to_string()),
+            comment: row.try_get::<_, Option<String>>(2).ok().flatten().filter(|s| !s.is_empty()),
+            created_at: row.try_get::<_, Option<String>>(3).ok().flatten().filter(|s| !s.is_empty()),
+            updated_at: row.try_get::<_, Option<String>>(4).ok().flatten().filter(|s| !s.is_empty()),
+            parent_schema: row.try_get::<_, Option<String>>(5).ok().flatten().filter(|s| !s.is_empty()),
+            parent_name: row.try_get::<_, Option<String>>(6).ok().flatten().filter(|s| !s.is_empty()),
+            signature: row.try_get::<_, Option<String>>(7).ok().flatten(),
+        })
+        .collect())
+}
+
+pub async fn list_object_statistics(pool: &Pool, schema: &str) -> Result<Vec<ObjectStatistics>, String> {
+    let schema = if schema.is_empty() { "public" } else { schema };
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(
+        &client,
+        "SELECT c.relname, \
+                GREATEST(c.reltuples, 0)::bigint AS estimated_rows, \
+                pg_catalog.pg_total_relation_size(c.oid)::bigint AS total_bytes \
+         FROM pg_catalog.pg_class c \
+         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+         WHERE n.nspname = $1 AND c.relkind IN ('r','m','f','p') \
+         ORDER BY c.relname",
+        &[&schema],
+    )
+    .await
+    .map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .map(|row| ObjectStatistics {
+            name: pg_row_try_string(row, 0),
+            schema: Some(schema.to_string()),
+            estimated_rows: row.try_get::<_, i64>(1).ok(),
+            total_bytes: row.try_get::<_, i64>(2).ok(),
+        })
+        .collect())
+}
+
+pub async fn list_schemas(pool: &Pool) -> Result<Vec<String>, String> {
+    Ok(list_schema_infos(pool).await?.into_iter().map(|schema| schema.name).collect())
+}
+
+pub async fn list_schema_infos(pool: &Pool) -> Result<Vec<SchemaInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(
+        &client,
+        "SELECT n.nspname AS schema_name, d.description AS schema_comment \
+         FROM pg_catalog.pg_namespace n \
+         LEFT JOIN pg_catalog.pg_description d \
+           ON d.objoid = n.oid \
+          AND d.objsubid = 0 \
+          AND d.classoid = 'pg_namespace'::regclass \
+         WHERE n.nspname NOT IN ('information_schema', 'pg_catalog', 'pg_toast') \
+         AND n.nspname NOT LIKE 'pg_toast_temp_%' \
+         AND n.nspname NOT LIKE 'pg_temp_%' \
+         ORDER BY n.nspname",
+        &[],
+    )
+    .await
+    .map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| SchemaInfo {
+            name: pg_row_try_string(row, 0),
+            comment: row.try_get::<_, Option<String>>(1).ok().flatten(),
+        })
+        .collect())
+}
+
+const POSTGRES_COLUMNS_SQL: &str = "SELECT a.attname AS column_name, \
+             format_type(a.atttypid, a.atttypmod) AS full_type, \
+             COALESCE(c.is_nullable = 'YES', NOT a.attnotnull) AS is_nullable, \
+             CASE WHEN a.attgenerated <> '' THEN NULL ELSE pg_get_expr(ad.adbin, ad.adrelid) END AS column_default, \
+             EXISTS ( \
+               SELECT 1 FROM pg_constraint co \
+               JOIN pg_index i ON i.indrelid = co.conrelid AND co.conindid = i.indexrelid \
+               WHERE co.conrelid = a.attrelid AND co.contype = 'p' \
+               AND a.attnum = ANY(i.indkey) \
+             ) AS is_pk, \
+             col_description(a.attrelid, a.attnum) AS column_comment, \
+             CASE a.attidentity \
+               WHEN 'd' THEN 'generated by default as identity' || CASE WHEN pseq.seqstart IS NOT NULL THEN format(' (start with %s increment by %s)', pseq.seqstart, pseq.seqincrement) ELSE '' END \
+               WHEN 'a' THEN 'generated always as identity' || CASE WHEN pseq.seqstart IS NOT NULL THEN format(' (start with %s increment by %s)', pseq.seqstart, pseq.seqincrement) ELSE '' END \
+               ELSE CASE a.attgenerated \
+                 WHEN 's' THEN 'generated always as (' || pg_get_expr(ad.adbin, ad.adrelid) || ') stored' \
+                 WHEN 'v' THEN 'generated always as (' || pg_get_expr(ad.adbin, ad.adrelid) || ') virtual' \
+                 ELSE NULL \
+               END \
+             END AS column_extra, \
+             CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 \
+               THEN ((a.atttypmod - 4) >> 16) & 65535 ELSE NULL END AS numeric_precision, \
+             CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 \
+               THEN (a.atttypmod - 4) & 65535 ELSE NULL END AS numeric_scale, \
+             CASE WHEN t.typname IN ('varchar', 'bpchar') AND a.atttypmod > 0 \
+               THEN a.atttypmod - 4 ELSE NULL END AS character_maximum_length, \
+             CASE WHEN enum_t.oid IS NULL THEN NULL \
+               ELSE COALESCE((SELECT array_to_json(array_agg(e.enumlabel ORDER BY e.enumsortorder))::text \
+                              FROM pg_enum e WHERE e.enumtypid = enum_t.oid), '[]') END AS enum_values \
+             FROM pg_attribute a \
+             JOIN pg_type t ON t.oid = a.atttypid \
+             LEFT JOIN pg_type enum_t ON enum_t.oid = CASE WHEN t.typtype = 'd' THEN t.typbasetype WHEN t.typtype = 'e' THEN t.oid ELSE NULL END AND enum_t.typtype = 'e' \
+             LEFT JOIN pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum \
+             LEFT JOIN pg_depend dep ON dep.refobjid = a.attrelid AND dep.refobjsubid = a.attnum AND dep.deptype = 'i' \
+             LEFT JOIN pg_sequence pseq ON pseq.seqrelid = dep.objid \
+             LEFT JOIN information_schema.columns c \
+               ON c.table_schema = $1 AND c.table_name = $2 AND c.column_name = a.attname \
+             WHERE a.attrelid = (quote_ident($1) || '.' || quote_ident($2))::regclass \
+             AND a.attnum > 0 AND NOT a.attisdropped \
+             ORDER BY a.attnum";
+
+const POSTGRES_COLUMNS_COMPAT_SQL: &str = "SELECT a.attname AS column_name, \
+             format_type(a.atttypid, a.atttypmod) AS full_type, \
+             COALESCE(c.is_nullable = 'YES', NOT a.attnotnull) AS is_nullable, \
+             pg_get_expr(ad.adbin, ad.adrelid) AS column_default, \
+             EXISTS ( \
+               SELECT 1 FROM pg_constraint co \
+               JOIN pg_index i ON i.indrelid = co.conrelid AND co.conindid = i.indexrelid \
+               WHERE co.conrelid = a.attrelid AND co.contype = 'p' \
+               AND a.attnum = ANY(i.indkey) \
+             ) AS is_pk, \
+             col_description(a.attrelid, a.attnum) AS column_comment, \
+             NULL::text AS column_extra, \
+             CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 \
+               THEN ((a.atttypmod - 4) >> 16) & 65535 ELSE NULL END AS numeric_precision, \
+             CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 \
+               THEN (a.atttypmod - 4) & 65535 ELSE NULL END AS numeric_scale, \
+             CASE WHEN t.typname IN ('varchar', 'bpchar') AND a.atttypmod > 0 \
+               THEN a.atttypmod - 4 ELSE NULL END AS character_maximum_length, \
+             NULL::text AS enum_values \
+             FROM pg_attribute a \
+             JOIN pg_type t ON t.oid = a.atttypid \
+             LEFT JOIN pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum \
+             LEFT JOIN information_schema.columns c \
+               ON c.table_schema = $1 AND c.table_name = $2 AND c.column_name = a.attname \
+             WHERE a.attrelid = (quote_ident($1) || '.' || quote_ident($2))::regclass \
+             AND a.attnum > 0 AND NOT a.attisdropped \
+             ORDER BY a.attnum";
+
+const POSTGRES_COLUMNS_INFORMATION_SCHEMA_SQL: &str = "SELECT c.column_name, \
+             CASE WHEN c.data_type = 'USER-DEFINED' THEN c.udt_name ELSE c.data_type END AS full_type, \
+             c.is_nullable = 'YES' AS is_nullable, \
+             c.column_default, \
+             EXISTS ( \
+               SELECT 1 FROM information_schema.table_constraints tc \
+               JOIN information_schema.key_column_usage kcu \
+                 ON kcu.constraint_catalog = tc.constraint_catalog \
+                AND kcu.constraint_schema = tc.constraint_schema \
+                AND kcu.constraint_name = tc.constraint_name \
+                AND kcu.table_schema = tc.table_schema \
+                AND kcu.table_name = tc.table_name \
+               WHERE tc.constraint_type = 'PRIMARY KEY' \
+                 AND tc.table_schema = c.table_schema \
+                 AND tc.table_name = c.table_name \
+                 AND kcu.column_name = c.column_name \
+             ) AS is_pk, \
+             NULL::text AS column_comment, \
+             NULL::text AS column_extra, \
+             CAST(c.numeric_precision AS int) AS numeric_precision, \
+             CAST(c.numeric_scale AS int) AS numeric_scale, \
+             CAST(c.character_maximum_length AS int) AS character_maximum_length, \
+             NULL::text AS enum_values \
+             FROM information_schema.columns c \
+             WHERE c.table_schema = $1 AND c.table_name = $2 \
+             ORDER BY c.ordinal_position";
+
+fn parse_enum_values_from_row(row: &Row, index: usize) -> Option<Vec<String>> {
+    let raw = row.try_get::<_, Option<String>>(index).ok().flatten()?;
+    serde_json::from_str::<Vec<String>>(&raw).ok()
+}
+
+/// Read a boolean column from a PostgreSQL row, tolerating databases that
+/// encode booleans as integers (0/1) or text ('t'/'f') instead of the standard
+/// `bool` OID.  Returns `None` when the column is NULL or truly unreadable.
+fn pg_row_try_bool(row: &Row, idx: usize) -> Option<bool> {
+    if let Ok(v) = row.try_get::<_, bool>(idx) {
+        return Some(v);
+    }
+    if let Ok(v) = row.try_get::<_, i32>(idx) {
+        return Some(v != 0);
+    }
+    if let Ok(v) = row.try_get::<_, i16>(idx) {
+        return Some(v != 0);
+    }
+    if let Ok(Some(v)) = row.try_get::<_, Option<String>>(idx) {
+        match v.as_str() {
+            "t" | "true" | "1" | "yes" | "YES" => return Some(true),
+            "f" | "false" | "0" | "no" | "NO" => return Some(false),
+            _ => return None,
+        }
+    }
+    None
+}
+
+/// Read a String column from a PostgreSQL row, tolerating databases that
+/// return text as other types.  Falls back to i64/i32/i16/bool formatting.
+fn pg_row_try_string(row: &Row, idx: usize) -> String {
+    if let Ok(v) = row.try_get::<_, String>(idx) {
+        return v;
+    }
+    if let Ok(v) = row.try_get::<_, i64>(idx) {
+        return v.to_string();
+    }
+    if let Ok(v) = row.try_get::<_, i32>(idx) {
+        return v.to_string();
+    }
+    if let Ok(v) = row.try_get::<_, i16>(idx) {
+        return v.to_string();
+    }
+    if let Some(v) = pg_row_try_bool(row, idx) {
+        return v.to_string();
+    }
+    String::new()
+}
+
+fn column_info_from_row(row: &Row) -> ColumnInfo {
+    let full_type = row.try_get::<_, Option<String>>(1).ok().flatten().unwrap_or_default();
+    ColumnInfo {
+        name: pg_row_try_string(row, 0),
+        data_type: full_type,
+        is_nullable: pg_row_try_bool(row, 2).unwrap_or(true),
+        column_default: row.try_get::<_, Option<String>>(3).ok().flatten(),
+        is_primary_key: pg_row_try_bool(row, 4).unwrap_or(false),
+        extra: row.try_get::<_, Option<String>>(6).ok().flatten(),
+        comment: row.try_get::<_, Option<String>>(5).ok().flatten(),
+        numeric_precision: row.try_get::<_, Option<i32>>(7).ok().flatten(),
+        numeric_scale: row.try_get::<_, Option<i32>>(8).ok().flatten(),
+        character_maximum_length: row.try_get::<_, Option<i32>>(9).ok().flatten(),
+        enum_values: parse_enum_values_from_row(row, 10),
+        ..Default::default()
+    }
+}
+
+async fn get_columns_with_sql(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<ColumnInfo>, tokio_postgres::Error> {
+    let rows = postgres_query_cached(client, sql, &[&schema, &table]).await?;
+
+    Ok(rows.iter().map(column_info_from_row).collect())
+}
+
+pub async fn get_columns(pool: &Pool, schema: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let schema = if schema.is_empty() { "public" } else { schema };
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    match get_columns_with_sql(&client, POSTGRES_COLUMNS_SQL, schema, table).await {
+        Ok(columns) => Ok(columns),
+        Err(primary_error) => match get_columns_with_sql(&client, POSTGRES_COLUMNS_COMPAT_SQL, schema, table).await {
+            Ok(columns) => Ok(columns),
+            Err(fallback_error) => {
+                let primary_message = pg_error_to_string(primary_error);
+                let fallback_message = pg_error_to_string(fallback_error);
+                match get_columns_with_sql(&client, POSTGRES_COLUMNS_INFORMATION_SCHEMA_SQL, schema, table).await {
+                    Ok(columns) => Ok(columns),
+                    Err(information_schema_error) => {
+                        let information_schema_message = pg_error_to_string(information_schema_error);
+                        log::debug!(
+                            "[postgres][get_columns:compat-failed] primary_error={} fallback_error={} information_schema_error={}",
+                            primary_message,
+                            fallback_message,
+                            information_schema_message
+                        );
+                        Err(information_schema_message)
+                    }
+                }
+            }
+        },
+    }
+}
+
+pub(crate) fn pg_quote_ident(ident: &str) -> String {
+    format!("\"{}\"", ident.replace('"', "\"\""))
+}
+
+fn query_result_row_limit(max_rows: Option<usize>) -> usize {
+    max_rows.unwrap_or(crate::query::MAX_ROWS).max(1)
+}
+
+pub async fn execute_query(pool: &Pool, sql: &str) -> Result<QueryResult, String> {
+    execute_query_with_max_rows(pool, sql, None).await
+}
+
+pub async fn execute_query_with_max_rows(
+    pool: &Pool,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<QueryResult, String> {
+    let start = Instant::now();
+    let row_limit = query_result_row_limit(max_rows);
+
+    if starts_with_executable_sql_keyword(sql, &["SELECT", "SHOW", "EXPLAIN", "WITH", "TABLE"]) {
+        let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+        execute_select_query(&client, sql, start, row_limit).await
+    } else {
+        let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+        let affected = client.execute(sql, &[]).await.map_err(pg_error_to_string)?;
+        clear_postgres_caches_after_ddl(pool, Some(&client), sql);
+
+        Ok(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: Vec::new(),
+            rows: vec![],
+            affected_rows: affected,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    }
+}
+
+pub async fn execute_query_with_max_rows_and_cancel(
+    pool: &Pool,
+    sql: &str,
+    max_rows: Option<usize>,
+    cancel_token: Option<CancellationToken>,
+    budget: DbOperationBudget,
+    cancel_context: Option<PostgresCancelContext>,
+) -> Result<QueryResult, String> {
+    let client = checkout_postgres_client(pool, cancel_token.as_ref(), budget.checkout_timeout).await?;
+    let pg_cancel_token = client.cancel_token();
+    wait_postgres_query(
+        pg_cancel_token,
+        cancel_context,
+        cancel_token,
+        budget.query_timeout,
+        budget.cancel_timeout,
+        execute_query_with_max_rows_inner(&client, sql, max_rows),
+    )
+    .await
+}
+
+pub async fn stream_select_query_with_cancel(
+    pool: &Pool,
+    schema: Option<&str>,
+    sql: &str,
+    max_rows: Option<usize>,
+    cancel_token: Option<CancellationToken>,
+    budget: DbOperationBudget,
+    cancel_context: Option<PostgresCancelContext>,
+    on_item: impl FnMut(PostgresQueryStreamItem) -> Result<(), String>,
+) -> Result<u64, String> {
+    let start = Instant::now();
+    let client = checkout_postgres_client(pool, cancel_token.as_ref(), budget.checkout_timeout).await?;
+    let mut on_item = on_item;
+    let row_limit = max_rows.map(|limit| limit.max(1));
+    let schema = schema.map(str::trim).filter(|schema| !schema.is_empty());
+    let schema_was_set = schema.is_some_and(|_| !is_transaction_recovery_statement(sql));
+
+    if let Some(schema) = schema.filter(|_| schema_was_set) {
+        // Match normal query execution: export may reference unqualified names
+        // in the active schema, so the streaming path must use the same search_path.
+        execute_postgres_infra_statement(
+            &client,
+            &format!("SET search_path TO {}, public", pg_quote_ident(schema)),
+            budget.recycle_timeout,
+            "schema.set",
+        )
+        .await?;
+    }
+
+    let pg_cancel_token = client.cancel_token();
+    let result = wait_postgres_query(
+        pg_cancel_token,
+        cancel_context,
+        cancel_token,
+        budget.query_timeout,
+        budget.cancel_timeout,
+        stream_select_query_inner(&client, sql, row_limit, &mut on_item),
+    )
+    .await;
+
+    if schema_was_set {
+        let reset_result = reset_postgres_search_path(&client, budget.cleanup_timeout, start).await;
+        match (result, reset_result) {
+            (Ok(rows), Ok(())) => Ok(rows),
+            (Err(query_err), Ok(())) => Err(query_err),
+            (Ok(_), Err(reset_err)) => Err(reset_err),
+            (Err(query_err), Err(reset_err)) => Err(format!("{query_err}; {reset_err}")),
+        }
+    } else {
+        result
+    }
+}
+
+pub async fn execute_query_with_schema(pool: &Pool, schema: &str, sql: &str) -> Result<QueryResult, String> {
+    execute_query_with_schema_and_max_rows(pool, schema, sql, None).await
+}
+
+pub async fn execute_query_with_schema_and_max_rows(
+    pool: &Pool,
+    schema: &str,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<QueryResult, String> {
+    let start = Instant::now();
+    let checkout_start = Instant::now();
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    log::info!(
+        "[postgres][execute_with_schema:pool:done] elapsed_ms={} total_ms={} schema={}",
+        checkout_start.elapsed().as_millis(),
+        start.elapsed().as_millis(),
+        schema
+    );
+    if is_transaction_recovery_statement(sql) {
+        log::info!(
+            "[postgres][execute_with_schema:skip-search-path] total_ms={} reason=transaction-recovery",
+            start.elapsed().as_millis()
+        );
+        return execute_query_with_max_rows_inner(&client, sql, max_rows).await;
+    }
+
+    let set_schema_start = Instant::now();
+    execute_postgres_infra_statement(
+        &client,
+        &format!("SET search_path TO {}, public", pg_quote_ident(schema)),
+        super::connection_timeout(),
+        "schema.set",
+    )
+    .await?;
+    log::info!(
+        "[postgres][execute_with_schema:set-search-path:done] elapsed_ms={} total_ms={}",
+        set_schema_start.elapsed().as_millis(),
+        start.elapsed().as_millis()
+    );
+
+    let query_start = Instant::now();
+    let result = execute_query_with_max_rows_inner(&client, sql, max_rows).await;
+    if result.is_ok() {
+        clear_postgres_caches_after_ddl(pool, Some(&client), sql);
+    }
+    log::info!(
+        "[postgres][execute_with_schema:query:done] elapsed_ms={} total_ms={} ok={}",
+        query_start.elapsed().as_millis(),
+        start.elapsed().as_millis(),
+        result.is_ok()
+    );
+
+    let reset_result = reset_postgres_search_path(&client, super::connection_timeout(), start).await;
+    merge_postgres_query_and_reset_result(result, reset_result)
+}
+
+pub async fn execute_query_with_schema_and_max_rows_and_cancel(
+    pool: &Pool,
+    schema: &str,
+    sql: &str,
+    max_rows: Option<usize>,
+    cancel_token: Option<CancellationToken>,
+    budget: DbOperationBudget,
+    cancel_context: Option<PostgresCancelContext>,
+) -> Result<QueryResult, String> {
+    let start = Instant::now();
+    let checkout_start = Instant::now();
+    let client = checkout_postgres_client(pool, cancel_token.as_ref(), budget.checkout_timeout).await?;
+    log::info!(
+        "[postgres][execute_with_schema:pool:done] elapsed_ms={} total_ms={} schema={}",
+        checkout_start.elapsed().as_millis(),
+        start.elapsed().as_millis(),
+        schema
+    );
+    if is_transaction_recovery_statement(sql) {
+        log::info!(
+            "[postgres][execute_with_schema:skip-search-path] total_ms={} reason=transaction-recovery",
+            start.elapsed().as_millis()
+        );
+        let pg_cancel_token = client.cancel_token();
+        return wait_postgres_query(
+            pg_cancel_token,
+            cancel_context,
+            cancel_token,
+            budget.query_timeout,
+            budget.cancel_timeout,
+            execute_query_with_max_rows_inner(&client, sql, max_rows),
+        )
+        .await;
+    }
+
+    let set_schema_start = Instant::now();
+    execute_postgres_infra_statement(
+        &client,
+        &format!("SET search_path TO {}, public", pg_quote_ident(schema)),
+        budget.recycle_timeout,
+        "schema.set",
+    )
+    .await?;
+    log::info!(
+        "[postgres][execute_with_schema:set-search-path:done] elapsed_ms={} total_ms={}",
+        set_schema_start.elapsed().as_millis(),
+        start.elapsed().as_millis()
+    );
+
+    let query_start = Instant::now();
+    let pg_cancel_token = client.cancel_token();
+    let result = wait_postgres_query(
+        pg_cancel_token,
+        cancel_context,
+        cancel_token,
+        budget.query_timeout,
+        budget.cancel_timeout,
+        execute_query_with_max_rows_inner(&client, sql, max_rows),
+    )
+    .await;
+    if result.is_ok() {
+        clear_postgres_caches_after_ddl(pool, Some(&client), sql);
+    }
+    log::info!(
+        "[postgres][execute_with_schema:query:done] elapsed_ms={} total_ms={} ok={}",
+        query_start.elapsed().as_millis(),
+        start.elapsed().as_millis(),
+        result.is_ok()
+    );
+
+    let reset_result = reset_postgres_search_path(&client, budget.cleanup_timeout, start).await;
+    merge_postgres_query_and_reset_result(result, reset_result)
+}
+
+async fn reset_postgres_search_path(
+    client: &deadpool_postgres::Client,
+    timeout_duration: Duration,
+    start: Instant,
+) -> Result<(), String> {
+    let reset_start = Instant::now();
+    match execute_postgres_infra_statement(client, "RESET search_path", timeout_duration, "schema.reset").await {
+        Ok(_) => {
+            log::info!(
+                "[postgres][execute_with_schema:reset-search-path:done] elapsed_ms={} total_ms={}",
+                reset_start.elapsed().as_millis(),
+                start.elapsed().as_millis()
+            );
+            Ok(())
+        }
+        Err(err) => {
+            log::warn!(
+                "[postgres][execute_with_schema:reset-search-path:error] elapsed_ms={} total_ms={} error={}",
+                reset_start.elapsed().as_millis(),
+                start.elapsed().as_millis(),
+                err
+            );
+            Err(postgres_schema_reset_cleanup_error(err))
+        }
+    }
+}
+
+fn merge_postgres_query_and_reset_result(
+    query_result: Result<QueryResult, String>,
+    reset_result: Result<(), String>,
+) -> Result<QueryResult, String> {
+    match (query_result, reset_result) {
+        (Ok(result), Ok(())) => Ok(result),
+        (Err(query_err), Ok(())) => Err(query_err),
+        (Ok(_), Err(reset_err)) => Err(reset_err),
+        (Err(query_err), Err(reset_err)) => Err(format!("{query_err}; {reset_err}")),
+    }
+}
+
+fn postgres_schema_reset_cleanup_error(err: String) -> String {
+    format!("PostgreSQL schema.reset cleanup failed: {err}")
+}
+
+pub(crate) async fn execute_postgres_infra_statement(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    timeout_duration: Duration,
+    stage: &str,
+) -> Result<u64, String> {
+    tokio::time::timeout(timeout_duration, client.execute(sql, &[]))
+        .await
+        .map_err(|_| format!("PostgreSQL {stage} timed out after {} seconds", timeout_duration.as_secs()))?
+        .map_err(pg_error_to_string)
+}
+
+pub(crate) async fn wait_postgres_operation<T, F>(
+    pg_cancel_token: tokio_postgres::CancelToken,
+    cancel_context: Option<PostgresCancelContext>,
+    timeout_duration: Option<Duration>,
+    cancel_timeout: Duration,
+    future: F,
+) -> Result<T, String>
+where
+    F: Future<Output = Result<T, String>>,
+{
+    wait_postgres_query(pg_cancel_token, cancel_context, None, timeout_duration, cancel_timeout, future).await
+}
+
+async fn wait_postgres_query<T, F>(
+    pg_cancel_token: tokio_postgres::CancelToken,
+    cancel_context: Option<PostgresCancelContext>,
+    cancel_token: Option<CancellationToken>,
+    timeout_duration: Option<Duration>,
+    cancel_timeout: Duration,
+    future: F,
+) -> Result<T, String>
+where
+    F: Future<Output = Result<T, String>>,
+{
+    match (cancel_token, timeout_duration) {
+        (Some(token), Some(duration)) => {
+            tokio::select! {
+                biased;
+                _ = token.cancelled() => {
+                    cancel_postgres_query(pg_cancel_token, cancel_context.as_ref(), cancel_timeout).await;
+                    Err(crate::query::canceled_error())
+                }
+                result = tokio::time::timeout(duration, future) => match result {
+                    Ok(result) => result,
+                    Err(_) => {
+                        cancel_postgres_query(pg_cancel_token, cancel_context.as_ref(), cancel_timeout).await;
+                        Err(format!("Query timed out after {} seconds", duration.as_secs()))
+                    }
+                },
+            }
+        }
+        (None, Some(duration)) => match tokio::time::timeout(duration, future).await {
+            Ok(result) => result,
+            Err(_) => {
+                cancel_postgres_query(pg_cancel_token, cancel_context.as_ref(), cancel_timeout).await;
+                Err(format!("Query timed out after {} seconds", duration.as_secs()))
+            }
+        },
+        (Some(token), None) => {
+            tokio::select! {
+                biased;
+                _ = token.cancelled() => {
+                    cancel_postgres_query(pg_cancel_token, cancel_context.as_ref(), cancel_timeout).await;
+                    Err(crate::query::canceled_error())
+                }
+                result = future => result,
+            }
+        }
+        (None, None) => future.await,
+    }
+}
+
+/// PostgreSQL pool checkout with timeout and cancel token support.
+/// When the checkout phase is stuck, the cancel token can terminate the wait early.
+/// The timeout error message includes "checkout timed out" to ensure is_connection_error can classify it correctly.
+pub async fn checkout_postgres_client(
+    pool: &Pool,
+    cancel_token: Option<&CancellationToken>,
+    checkout_timeout: Duration,
+) -> Result<deadpool_postgres::Object, String> {
+    let start = Instant::now();
+    let get_future = async {
+        tokio::time::timeout(checkout_timeout, pool.get())
+            .await
+            .map_err(|_| {
+                let elapsed = start.elapsed().as_millis();
+                log::warn!(
+                    "[db:pool.checkout:error] elapsed_ms={} timeout_ms={} error=checkout timed out",
+                    elapsed,
+                    checkout_timeout.as_millis()
+                );
+                format!("PostgreSQL connection pool checkout timed out ({}s)", checkout_timeout.as_secs())
+            })?
+            .map_err(|e| {
+                let elapsed = start.elapsed().as_millis();
+                let err = pg_pool_error_to_string(e);
+                log::warn!(
+                    "[db:pool.checkout:error] elapsed_ms={} timeout_ms={} error={}",
+                    elapsed,
+                    checkout_timeout.as_millis(),
+                    err
+                );
+                format!("PostgreSQL connection pool checkout failed: {err}")
+            })
+    };
+
+    let result = match cancel_token {
+        Some(token) => tokio::select! {
+            biased;
+            _ = token.cancelled() => {
+                log::info!(
+                    "[db:pool.checkout:cancelled] elapsed_ms={} timeout_ms={}",
+                    start.elapsed().as_millis(),
+                    checkout_timeout.as_millis()
+                );
+                return Err(crate::query::canceled_error());
+            }
+            result = get_future => result,
+        },
+        None => get_future.await,
+    };
+    if result.is_ok() {
+        log::debug!(
+            "[db:pool.checkout:done] elapsed_ms={} timeout_ms={}",
+            start.elapsed().as_millis(),
+            checkout_timeout.as_millis()
+        );
+    }
+    result
+}
+
+async fn cancel_postgres_query(
+    pg_cancel_token: tokio_postgres::CancelToken,
+    cancel_context: Option<&PostgresCancelContext>,
+    cancel_timeout: Duration,
+) {
+    let cancel_timeout = postgres_cancel_attempt_timeout(cancel_timeout, cancel_context);
+    if let Some(ctx) = cancel_context {
+        match make_rustls_connect_from_context(ctx) {
+            Ok(tls) => match tokio::time::timeout(cancel_timeout, pg_cancel_token.cancel_query(tls)).await {
+                Ok(Ok(())) => return,
+                Ok(Err(err)) => {
+                    log::warn!("Failed to send PostgreSQL TLS cancel request: {err}");
+                    return;
+                }
+                Err(_) => {
+                    log::warn!("Timed out sending PostgreSQL TLS cancel request ({}s)", cancel_timeout.as_secs());
+                    return;
+                }
+            },
+            Err(err) => {
+                log::warn!("Failed to build TLS connector for cancel: {err}; falling back to NoTls cancel");
+            }
+        }
+    }
+    match tokio::time::timeout(cancel_timeout, pg_cancel_token.cancel_query(NoTls)).await {
+        Ok(Ok(())) => {}
+        Ok(Err(err)) => log::warn!("Failed to send PostgreSQL cancel request: {err}"),
+        Err(_) => log::warn!("Timed out sending PostgreSQL cancel request ({}s)", cancel_timeout.as_secs()),
+    }
+}
+
+fn postgres_cancel_attempt_timeout(
+    cancel_timeout: Duration,
+    _cancel_context: Option<&PostgresCancelContext>,
+) -> Duration {
+    cancel_timeout
+}
+
+fn is_transaction_recovery_statement(sql: &str) -> bool {
+    starts_with_executable_sql_keyword(sql, &["ROLLBACK", "ABORT", "COMMIT", "END"])
+}
+
+async fn execute_query_with_max_rows_inner(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<QueryResult, String> {
+    let start = Instant::now();
+    let row_limit = query_result_row_limit(max_rows);
+
+    if starts_with_executable_sql_keyword(sql, &["SELECT", "SHOW", "EXPLAIN", "WITH", "TABLE"]) {
+        execute_select_query(client, sql, start, row_limit).await
+    } else {
+        let affected = client.execute(sql, &[]).await.map_err(pg_error_to_string)?;
+
+        Ok(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: Vec::new(),
+            rows: vec![],
+            affected_rows: affected,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    }
+}
+
+const POSTGRES_INDEXES_SQL: &str = "SELECT i.relname AS index_name, \
+             array_agg(COALESCE(a.attname, pg_get_indexdef(ix.indexrelid, k.n::int, true)) ORDER BY k.n) AS columns, \
+             ix.indisunique AS is_unique, \
+             ix.indisprimary AS is_primary, \
+             pg_get_expr(ix.indpred, ix.indrelid) AS filter_expr, \
+             am.amname AS index_type, \
+             ix.indnkeyatts AS nkeyatts, \
+             ix.indkey AS indkey, \
+             obj_description(i.oid, 'pg_class') AS index_comment \
+             FROM pg_index ix \
+             JOIN pg_class t ON t.oid = ix.indrelid \
+             JOIN pg_class i ON i.oid = ix.indexrelid \
+             JOIN pg_namespace n ON n.oid = t.relnamespace \
+             JOIN pg_am am ON am.oid = i.relam \
+             JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, n) ON true \
+             LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum AND k.attnum > 0 \
+             WHERE n.nspname = $1 AND t.relname = $2 \
+             GROUP BY i.relname, i.oid, ix.indisunique, ix.indisprimary, ix.indpred, ix.indrelid, am.amname, ix.indnkeyatts, ix.indkey \
+             ORDER BY i.relname";
+
+const POSTGRES_INDEXES_COMPAT_SQL: &str = "SELECT i.relname AS index_name, \
+             ARRAY( \
+               SELECT COALESCE(a.attname, pg_get_indexdef(ix.indexrelid, pos.n, true)) \
+               FROM generate_series(1, array_length(string_to_array(ix.indkey::text, ' '), 1)) AS pos(n) \
+               LEFT JOIN pg_attribute a \
+                 ON a.attrelid = t.oid \
+                AND a.attnum = (string_to_array(ix.indkey::text, ' '))[pos.n]::int2 \
+                AND a.attnum > 0 \
+               ORDER BY pos.n \
+             ) AS columns, \
+             ix.indisunique AS is_unique, \
+             ix.indisprimary AS is_primary, \
+             pg_get_expr(ix.indpred, ix.indrelid) AS filter_expr, \
+             am.amname AS index_type, \
+             NULL::smallint AS nkeyatts, \
+             ix.indkey AS indkey, \
+             obj_description(i.oid, 'pg_class') AS index_comment \
+             FROM pg_index ix \
+             JOIN pg_class t ON t.oid = ix.indrelid \
+             JOIN pg_class i ON i.oid = ix.indexrelid \
+             JOIN pg_namespace n ON n.oid = t.relnamespace \
+             JOIN pg_am am ON am.oid = i.relam \
+             WHERE n.nspname = $1 AND t.relname = $2 \
+             ORDER BY i.relname";
+
+const POSTGRES_OWNERS_SQL: &str =
+    "SELECT n.nspname, c.relname, c.relkind::text AS relkind, pg_get_userbyid(c.relowner) \
+     FROM pg_class c \
+     JOIN pg_namespace n ON n.oid = c.relnamespace \
+     WHERE n.nspname = $1 \
+       AND c.relkind IN ('r', 'v', 'm', 'S', 'f', 'p')";
+
+fn postgres_owner_object_type(relkind: &str) -> &str {
+    match relkind {
+        "r" => "TABLE",
+        "v" => "VIEW",
+        "m" => "MATERIALIZED_VIEW",
+        "S" => "SEQUENCE",
+        "f" => "FOREIGN TABLE",
+        "p" => "PARTITIONED TABLE",
+        "I" => "PARTITIONED INDEX",
+        _ => relkind,
+    }
+}
+
+async fn list_indexes_with_sql(
+    client: &deadpool_postgres::Client,
+    sql: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<IndexInfo>, tokio_postgres::Error> {
+    let rows = postgres_query_cached(client, sql, &[&schema, &table]).await?;
+
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let all_cols: Vec<String> = row.try_get::<_, Vec<String>>(1).unwrap_or_default();
+            let nkeyatts = row.try_get::<_, Option<i16>>(6).ok().flatten().unwrap_or(all_cols.len() as i16) as usize;
+            let split_at = nkeyatts.min(all_cols.len());
+            let key_cols = all_cols[..split_at].to_vec();
+            let included = if split_at < all_cols.len() { all_cols[split_at..].to_vec() } else { vec![] };
+            IndexInfo {
+                name: pg_row_try_string(row, 0),
+                columns: key_cols,
+                is_unique: pg_row_try_bool(row, 2).unwrap_or(false),
+                is_primary: pg_row_try_bool(row, 3).unwrap_or(false),
+                filter: row.try_get::<_, Option<String>>(4).ok().flatten(),
+                index_type: row.try_get::<_, Option<String>>(5).ok().flatten(),
+                included_columns: if included.is_empty() { None } else { Some(included) },
+                comment: row.try_get::<_, Option<String>>(8).ok().flatten(),
+            }
+        })
+        .collect())
+}
+
+pub async fn list_indexes(pool: &Pool, schema: &str, table: &str) -> Result<Vec<IndexInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    match list_indexes_with_sql(&client, POSTGRES_INDEXES_SQL, schema, table).await {
+        Ok(indexes) => Ok(indexes),
+        Err(primary_error) => match list_indexes_with_sql(&client, POSTGRES_INDEXES_COMPAT_SQL, schema, table).await {
+            Ok(indexes) => Ok(indexes),
+            Err(fallback_error) => {
+                let primary_message = pg_error_to_string(primary_error);
+                let fallback_message = pg_error_to_string(fallback_error);
+                log::debug!(
+                    "[postgres][list_indexes:compat-failed] primary_error={} fallback_error={}",
+                    primary_message,
+                    fallback_message
+                );
+                Err(fallback_message)
+            }
+        },
+    }
+}
+
+fn postgres_foreign_keys_sql() -> &'static str {
+    "SELECT fk.constraint_name, fk.column_name, \
+     pk.table_schema AS ref_schema, pk.table_name AS ref_table, pk.column_name AS ref_column, \
+     rc.update_rule AS on_update, rc.delete_rule AS on_delete \
+     FROM information_schema.table_constraints tc \
+     JOIN information_schema.key_column_usage fk \
+       ON fk.constraint_name = tc.constraint_name \
+       AND fk.constraint_schema = tc.constraint_schema \
+       AND fk.table_schema = tc.table_schema \
+       AND fk.table_name = tc.table_name \
+     JOIN information_schema.referential_constraints rc \
+       ON rc.constraint_name = tc.constraint_name \
+       AND rc.constraint_schema = tc.constraint_schema \
+     JOIN information_schema.key_column_usage pk \
+       ON pk.constraint_name = rc.unique_constraint_name \
+       AND pk.constraint_schema = rc.unique_constraint_schema \
+       AND pk.ordinal_position = fk.position_in_unique_constraint \
+     WHERE tc.constraint_type = 'FOREIGN KEY' \
+       AND fk.table_schema = $1 AND fk.table_name = $2 \
+     ORDER BY fk.constraint_name, fk.ordinal_position"
+}
+
+fn postgres_foreign_key_action(value: String) -> Option<String> {
+    let value = value.trim();
+    if value.is_empty() {
+        None
+    } else {
+        Some(value.to_string())
+    }
+}
+
+pub async fn list_foreign_keys(pool: &Pool, schema: &str, table: &str) -> Result<Vec<ForeignKeyInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(&client, postgres_foreign_keys_sql(), &[&schema, &table])
+        .await
+        .map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| ForeignKeyInfo {
+            name: pg_row_try_string(row, 0),
+            column: pg_row_try_string(row, 1),
+            ref_schema: Some(pg_row_try_string(row, 2)),
+            ref_table: pg_row_try_string(row, 3),
+            ref_column: pg_row_try_string(row, 4),
+            on_update: postgres_foreign_key_action(pg_row_try_string(row, 5)),
+            on_delete: postgres_foreign_key_action(pg_row_try_string(row, 6)),
+        })
+        .collect())
+}
+
+pub async fn list_triggers(pool: &Pool, schema: &str, table: &str) -> Result<Vec<TriggerInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(
+        &client,
+        "SELECT trigger_name, event_manipulation, action_timing \
+         FROM information_schema.triggers \
+         WHERE trigger_schema = $1 AND event_object_table = $2 \
+         ORDER BY trigger_name",
+        &[&schema, &table],
+    )
+    .await
+    .map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| TriggerInfo {
+            name: pg_row_try_string(row, 0),
+            event: pg_row_try_string(row, 1),
+            timing: pg_row_try_string(row, 2),
+            statement: None,
+        })
+        .collect())
+}
+
+fn postgres_functions_sql(has_proc_prokind: bool) -> &'static str {
+    if has_proc_prokind {
+        return "SELECT p.proname, \
+                    CASE p.prokind WHEN 'f' THEN 'FUNCTION' WHEN 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END, \
+                    COALESCE(pg_get_function_result(p.oid), ''), \
+                    pg_get_functiondef(p.oid), \
+                    COALESCE(pg_get_function_arguments(p.oid), '') \
+             FROM pg_proc p \
+             JOIN pg_namespace n ON n.oid = p.pronamespace \
+             WHERE n.nspname = $1 AND p.prokind IN ('f', 'p') \
+             ORDER BY p.proname";
+    }
+
+    // PostgreSQL 10 and older do not have pg_proc.prokind; procedures were
+    // introduced with prokind, so the legacy path can only return functions.
+    "SELECT p.proname, \
+                    'FUNCTION', \
+                    COALESCE(pg_get_function_result(p.oid), ''), \
+                    pg_get_functiondef(p.oid), \
+                    COALESCE(pg_get_function_arguments(p.oid), '') \
+             FROM pg_proc p \
+             JOIN pg_namespace n ON n.oid = p.pronamespace \
+             WHERE n.nspname = $1 AND NOT p.proisagg AND NOT p.proiswindow \
+             ORDER BY p.proname"
+}
+
+pub async fn list_functions(pool: &Pool, schema: &str) -> Result<Vec<FunctionInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    // Use pg_proc + pg_get_functiondef() instead of information_schema.routines
+    // for reliable function definition retrieval (information_schema.routines.routine_definition
+    // is NULL for non-SQL functions like plpgsql)
+    let has_proc_prokind = postgres_proc_has_prokind(&client).await?;
+    let rows = postgres_query_cached(&client, postgres_functions_sql(has_proc_prokind), &[&schema])
+        .await
+        .map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let def: String = pg_row_try_string(row, 3);
+            // Remove schema qualification from CREATE FUNCTION statement
+            // to avoid false differences when comparing across schemas.
+            // Handle both "schema.name" and schema.name formats.
+            let normalized_def = def
+                .replace(&format!("CREATE OR REPLACE FUNCTION \"{}\".", schema), "CREATE OR REPLACE FUNCTION ")
+                .replace(&format!("CREATE OR REPLACE FUNCTION {}.", schema), "CREATE OR REPLACE FUNCTION ");
+            FunctionInfo {
+                name: pg_row_try_string(row, 0),
+                function_type: pg_row_try_string(row, 1),
+                data_type: pg_row_try_string(row, 2),
+                definition: normalized_def,
+                arguments: pg_row_try_string(row, 4),
+            }
+        })
+        .collect())
+}
+
+pub async fn list_sequences(pool: &Pool, schema: &str, with_last_values: bool) -> Result<Vec<SequenceInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    // Use pg_class + pg_sequence + pg_namespace instead of pg_sequences view
+    // for better compatibility and permission handling
+    let rows = postgres_query_cached(
+        &client,
+        "SELECT c.relname, \
+          COALESCE(format_type(s.seqtypid, NULL), 'bigint'), \
+          COALESCE(s.seqstart::text, '1'), \
+          COALESCE(s.seqmin::text, '1'), \
+          COALESCE(s.seqmax::text, '9223372036854775807'), \
+          COALESCE(s.seqincrement::text, '1'), \
+          CASE WHEN s.seqcycle THEN 'YES' ELSE 'NO' END \
+         FROM pg_class c \
+         JOIN pg_namespace n ON n.oid = c.relnamespace \
+         LEFT JOIN pg_sequence s ON s.seqrelid = c.oid \
+         WHERE c.relkind = 'S' AND n.nspname = $1 \
+         ORDER BY c.relname",
+        &[&schema],
+    )
+    .await
+    .map_err(|e| e.to_string())?;
+
+    let mut sequences: Vec<SequenceInfo> = rows
+        .iter()
+        .map(|row| SequenceInfo {
+            name: pg_row_try_string(row, 0),
+            data_type: pg_row_try_string(row, 1),
+            start_value: pg_row_try_string(row, 2),
+            min_value: pg_row_try_string(row, 3),
+            max_value: pg_row_try_string(row, 4),
+            increment: pg_row_try_string(row, 5),
+            cycle: pg_row_try_string(row, 6) == "YES",
+            last_value: None,
+        })
+        .collect();
+
+    if with_last_values {
+        // Batch query: get last values for all sequences in one query
+        let sql = "SELECT c.relname, pg_sequence_last_value(c.oid) \
+                   FROM pg_class c \
+                   JOIN pg_namespace n ON n.oid = c.relnamespace \
+                   WHERE c.relkind = 'S' AND n.nspname = $1";
+        if let Ok(rows) = postgres_query_cached(&client, sql, &[&schema]).await {
+            for row in rows {
+                let name: String = pg_row_try_string(&row, 0);
+                if let Ok(val) = row.try_get::<_, i64>(1) {
+                    if let Some(seq) = sequences.iter_mut().find(|s| s.name == name) {
+                        seq.last_value = Some(val.to_string());
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(sequences)
+}
+
+pub async fn list_rules(pool: &Pool, schema: &str) -> Result<Vec<RuleInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(
+        &client,
+        "SELECT schemaname, tablename, rulename, definition \
+         FROM pg_rules \
+         WHERE schemaname = $1 \
+         ORDER BY rulename",
+        &[&schema],
+    )
+    .await
+    .map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| RuleInfo {
+            name: pg_row_try_string(row, 2),
+            table_name: pg_row_try_string(row, 1),
+            definition: pg_row_try_string(row, 3),
+        })
+        .collect())
+}
+
+pub async fn list_extensions(pool: &Pool, schema: &str) -> Result<Vec<ExtensionInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(
+        &client,
+        "SELECT e.extname, COALESCE(e.extversion, '') AS extversion, d.description, n.nspname \
+         FROM pg_catalog.pg_extension e \
+         JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace \
+         LEFT JOIN pg_catalog.pg_description d ON d.objoid = e.oid AND d.classoid = 'pg_extension'::regclass \
+         WHERE n.nspname = $1 \
+         ORDER BY e.extname",
+        &[&schema],
+    )
+    .await
+    .map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| ExtensionInfo {
+            name: pg_row_try_string(row, 0),
+            version: pg_row_try_string(row, 1),
+            comment: row.try_get::<_, Option<String>>(2).ok().flatten().filter(|s| !s.is_empty()),
+            schema: Some(schema.to_string()),
+        })
+        .collect())
+}
+
+pub async fn list_available_extensions(pool: &Pool) -> Result<Vec<ExtensionInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(
+        &client,
+        "SELECT name, default_version, comment \
+         FROM pg_catalog.pg_available_extensions \
+         WHERE installed_version IS NULL \
+         ORDER BY name",
+        &[],
+    )
+    .await
+    .map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| ExtensionInfo {
+            name: pg_row_try_string(row, 0),
+            version: pg_row_try_string(row, 1),
+            comment: row.try_get::<_, Option<String>>(2).ok().flatten().filter(|s| !s.is_empty()),
+            schema: None,
+        })
+        .collect())
+}
+
+pub async fn list_owners(pool: &Pool, schema: &str) -> Result<Vec<OwnerInfo>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let rows = postgres_query_cached(&client, POSTGRES_OWNERS_SQL, &[&schema]).await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let relkind: String = pg_row_try_string(row, 2);
+            OwnerInfo {
+                object_name: pg_row_try_string(row, 1),
+                object_type: postgres_owner_object_type(&relkind).to_string(),
+                owner: pg_row_try_string(row, 3),
+            }
+        })
+        .collect())
+}
+
+/// Execute multiple SQL statements in a single round-trip using batch_execute.
+/// Best for DDL scripts where per-statement affected-row counts are not needed.
+pub async fn execute_batch(pool: &Pool, statements: &[String]) -> Result<(), String> {
+    let combined = statements.iter().map(|s| s.trim()).filter(|s| !s.is_empty()).collect::<Vec<_>>().join(";\n");
+    if combined.is_empty() {
+        return Ok(());
+    }
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    client.batch_execute(&combined).await.map_err(pg_error_to_string)?;
+    clear_postgres_caches_after_ddl(pool, Some(&client), &combined);
+    Ok(())
+}
+
+pub async fn terminate_current_user_database_backends(pool: &Pool, database: &str) -> Result<u64, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    client
+        .execute(
+            "SELECT pg_terminate_backend(pid) \
+             FROM pg_stat_activity \
+             WHERE datname = $1 \
+               AND pid <> pg_backend_pid() \
+               AND usename = current_user",
+            &[&database],
+        )
+        .await
+        .map_err(pg_error_to_string)
+}
+
+fn clear_postgres_caches_after_ddl(pool: &Pool, client: Option<&deadpool_postgres::Client>, sql: &str) {
+    if !invalidates_postgres_statement_cache(sql) {
+        return;
+    }
+    pool.manager().statement_caches.clear();
+    if let Some(client) = client {
+        client.clear_type_cache();
+    }
+}
+
+fn invalidates_postgres_statement_cache(sql: &str) -> bool {
+    let trimmed = sql.trim_start();
+    starts_with_executable_sql_keyword(
+        trimmed,
+        &["ALTER", "CREATE", "DROP", "TRUNCATE", "COMMENT", "REINDEX", "VACUUM"],
+    )
+}
+
+/// Export data via COPY TO STDOUT. `sql` must be a complete COPY statement, e.g.
+/// `COPY table (col1, col2) TO STDOUT (FORMAT CSV, HEADER)`.
+/// Returns the raw COPY output bytes.
+pub async fn copy_out(pool: &Pool, sql: &str) -> Result<Vec<u8>, String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let stream = client.copy_out(sql).await.map_err(pg_error_to_string)?;
+    tokio::pin!(stream);
+    let mut result = Vec::new();
+    while let Some(chunk) = stream.next().await {
+        result.extend_from_slice(&chunk.map_err(pg_error_to_string)?);
+    }
+    Ok(result)
+}
+
+/// Import data via COPY FROM STDIN. `sql` must be a complete COPY statement, e.g.
+/// `COPY table (col1, col2) FROM STDIN (FORMAT CSV)`.
+/// `data` is the raw input in the format specified by the COPY command.
+pub async fn copy_in(pool: &Pool, sql: &str, data: &[u8]) -> Result<(), String> {
+    let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
+    let sink = client.copy_in::<str, bytes::Bytes>(sql).await.map_err(pg_error_to_string)?;
+    let mut sink = Box::pin(sink);
+    sink.as_mut().send(bytes::Bytes::copy_from_slice(data)).await.map_err(pg_error_to_string)?;
+    sink.as_mut().close().await.map_err(pg_error_to_string)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::process::Command;
+    use std::time::Instant;
+    use tokio_postgres::types::FromSql;
+
+    struct DockerPostgres {
+        name: String,
+        port: u16,
+    }
+
+    impl DockerPostgres {
+        fn url(&self) -> String {
+            format!("postgres://postgres:postgres@127.0.0.1:{}/postgres?sslmode=disable", self.port)
+        }
+    }
+
+    impl Drop for DockerPostgres {
+        fn drop(&mut self) {
+            let _ = Command::new("docker").args(["rm", "-f", &self.name]).status();
+        }
+    }
+
+    fn docker_ready() -> bool {
+        Command::new("docker")
+            .args(["version", "--format", "{{.Server.Version}}"])
+            .output()
+            .map(|output| output.status.success())
+            .unwrap_or(false)
+    }
+
+    async fn start_docker_postgres() -> Option<DockerPostgres> {
+        if !docker_ready() {
+            eprintln!("skipping docker-backed postgres test because Docker is unavailable");
+            return None;
+        }
+
+        let port = portpicker::pick_unused_port().expect("pick unused postgres port");
+        let container = DockerPostgres { name: format!("dbx-postgres-enum-{}", uuid::Uuid::new_v4()), port };
+
+        let status = Command::new("docker")
+            .args([
+                "run",
+                "-d",
+                "--rm",
+                "--name",
+                &container.name,
+                "-e",
+                "POSTGRES_PASSWORD=postgres",
+                "-e",
+                "POSTGRES_USER=postgres",
+                "-e",
+                "POSTGRES_DB=postgres",
+                "-p",
+                &format!("{port}:5432"),
+                "postgres:16-alpine",
+            ])
+            .status()
+            .expect("start docker postgres");
+        assert!(status.success(), "docker run postgres container should succeed");
+
+        let deadline = Instant::now() + Duration::from_secs(60);
+        loop {
+            match connect(&container.url(), Duration::from_secs(2)).await {
+                Ok(pool) => {
+                    drop(pool);
+                    return Some(container);
+                }
+                Err(_) if Instant::now() < deadline => tokio::time::sleep(Duration::from_millis(500)).await,
+                Err(error) => panic!("docker postgres did not become ready: {error}"),
+            }
+        }
+    }
+
+    fn state_enum_values(columns: &[ColumnInfo]) -> Option<Vec<String>> {
+        columns.iter().find(|column| column.name == "state").and_then(|column| column.enum_values.clone())
+    }
+
+    // --- pg_quote_ident ---
+
+    #[test]
+    fn pg_system_u32_decodes_catalog_integer_types() {
+        let raw = 42_u32.to_be_bytes();
+
+        assert_eq!(u32::from_sql(&Type::OID, &raw).unwrap(), 42);
+        assert_eq!(PgSystemU32::from_sql(&Type::XID, &raw).unwrap().0, 42);
+        assert_eq!(PgSystemU32::from_sql(&Type::CID, &raw).unwrap().0, 42);
+        assert!(u32::accepts(&Type::OID));
+        assert!(PgSystemU32::accepts(&Type::XID));
+        assert!(PgSystemU32::accepts(&Type::CID));
+        assert!(!PgSystemU32::accepts(&Type::OID));
+        assert!(!PgSystemU32::accepts(&Type::INT4));
+    }
+
+    #[test]
+    fn pg_any_string_accepts_all_types_and_decodes_utf8() {
+        // Accepts any type — built-in, custom enum OIDs, domains, etc.
+        assert!(PgAnyString::accepts(&Type::TEXT));
+        assert!(PgAnyString::accepts(&Type::INT4));
+        assert!(PgAnyString::accepts(&Type::UNKNOWN));
+        assert!(PgAnyString::accepts(&Type::OID));
+        assert!(PgAnyString::accepts(&Type::BOOL));
+
+        let label = PgAnyString::from_sql(&Type::UNKNOWN, b"pending").unwrap();
+        assert_eq!(label.0, "pending");
+
+        let label = PgAnyString::from_sql(&Type::UNKNOWN, b"hello world").unwrap();
+        assert_eq!(label.0, "hello world");
+
+        // Non-UTF-8 bytes should fail gracefully
+        assert!(PgAnyString::from_sql(&Type::UNKNOWN, &[0xFF, 0xFE, 0xFD]).is_err());
+    }
+
+    #[test]
+    fn pg_raw_bytes_accepts_all_types_and_preserves_binary_payloads() {
+        assert!(PgRawBytes::accepts(&Type::TEXT));
+        assert!(PgRawBytes::accepts(&Type::UNKNOWN));
+        assert!(PgRawBytes::accepts(&Type::OID));
+
+        let raw = PgRawBytes::from_sql(&Type::UNKNOWN, &[0x01, 0xAB, 0xFF]).unwrap();
+        assert_eq!(raw.0, vec![0x01, 0xAB, 0xFF]);
+    }
+
+    #[test]
+    fn postgres_foreign_keys_sql_selects_referential_actions() {
+        let sql = postgres_foreign_keys_sql();
+
+        assert!(sql.contains("rc.update_rule AS on_update"));
+        assert!(sql.contains("rc.delete_rule AS on_delete"));
+        assert!(sql.contains("information_schema.referential_constraints rc"));
+    }
+
+    #[test]
+    fn postgres_foreign_key_action_keeps_non_empty_action() {
+        assert_eq!(postgres_foreign_key_action("CASCADE".to_string()), Some("CASCADE".to_string()));
+        assert_eq!(postgres_foreign_key_action(" SET NULL ".to_string()), Some("SET NULL".to_string()));
+        assert_eq!(postgres_foreign_key_action("".to_string()), None);
+        assert_eq!(postgres_foreign_key_action("  ".to_string()), None);
+    }
+
+    #[test]
+    fn decodes_tsvector_binary_output() {
+        let raw = [
+            0, 0, 0, 2, b'b', b'a', b'c', b'k', b'\\', b's', b'l', b'a', b's', b'h', 0, 0, 1, 0x80, 0x03, b'o', b'\'',
+            b'c', b'l', b'o', b'c', b'k', 0, 0, 2, 0, 1, 0xc0, 0x02,
+        ];
+
+        assert_eq!(decode_tsvector_bytes(&raw).as_deref(), Some("'back\\\\slash':3B 'o''clock':1,2A"));
+    }
+
+    fn decode_hex(hex: &str) -> Vec<u8> {
+        assert_eq!(hex.len() % 2, 0, "hex input must have an even number of chars");
+        (0..hex.len()).step_by(2).map(|idx| u8::from_str_radix(&hex[idx..idx + 2], 16).unwrap()).collect()
+    }
+
+    #[test]
+    fn decodes_postgres_inet_binary_output() {
+        assert_eq!(
+            decode_pg_network_address_bytes(&decode_hex("02200004c0a8010a"), false).as_deref(),
+            Some("192.168.1.10")
+        );
+        assert_eq!(
+            decode_pg_network_address_bytes(&decode_hex("0310001020010db8abcd00120000000000000001"), false).as_deref(),
+            Some("2001:db8:abcd:12::1/16")
+        );
+        assert_eq!(
+            decode_pg_network_address_bytes(&decode_hex("0340001020010db8abcd00120000000000000001"), false).as_deref(),
+            Some("2001:db8:abcd:12::1/64")
+        );
+    }
+
+    #[test]
+    fn decodes_postgres_cidr_binary_output() {
+        assert_eq!(
+            decode_pg_network_address_bytes(&decode_hex("02180104c0a80100"), true).as_deref(),
+            Some("192.168.1.0/24")
+        );
+        assert_eq!(
+            decode_pg_network_address_bytes(&decode_hex("02200104c0a8010a"), true).as_deref(),
+            Some("192.168.1.10/32")
+        );
+        assert_eq!(
+            decode_pg_network_address_bytes(&decode_hex("0380011000000000000000000000000000000001"), true).as_deref(),
+            Some("::1/128")
+        );
+    }
+
+    #[test]
+    fn rejects_invalid_postgres_network_binary_output() {
+        assert_eq!(decode_pg_network_address_bytes(&[], false), None);
+        assert_eq!(decode_pg_network_address_bytes(&decode_hex("04200004c0a8010a"), false), None);
+        assert_eq!(decode_pg_network_address_bytes(&decode_hex("02210004c0a8010a"), false), None);
+        assert_eq!(decode_pg_network_address_bytes(&decode_hex("02200004c0a801"), false), None);
+    }
+
+    #[test]
+    fn decodes_postgres_macaddr_binary_output() {
+        assert_eq!(decode_pg_macaddr_bytes(&decode_hex("08002b010203")).as_deref(), Some("08:00:2b:01:02:03"));
+        assert_eq!(
+            decode_pg_macaddr_bytes(&decode_hex("08002bfffe010203")).as_deref(),
+            Some("08:00:2b:ff:fe:01:02:03")
+        );
+        assert_eq!(decode_pg_macaddr_bytes(&decode_hex("08002b")), None);
+    }
+
+    #[test]
+    fn decodes_postgres_bit_string_binary_output() {
+        assert_eq!(decode_pg_bit_string_bytes(&decode_hex("00000005a8")).as_deref(), Some("10101"));
+        assert_eq!(decode_pg_bit_string_bytes(&decode_hex("00000009a880")).as_deref(), Some("101010001"));
+        assert_eq!(decode_pg_bit_string_bytes(&decode_hex("00000000")).as_deref(), Some(""));
+        assert_eq!(decode_pg_bit_string_bytes(&decode_hex("00000005a8ff")), None);
+        assert_eq!(decode_pg_bit_string_bytes(&decode_hex("ffffffff")), None);
+    }
+
+    #[test]
+    fn ewkb_point_with_srid_formats_as_wkt() {
+        let raw = decode_hex("0101000020E6100000C520B07268195D404E62105839F44340");
+        assert_eq!(super::super::wkb::wkb_to_wkt(&raw), Some("POINT(116.397 39.908)".to_string()));
+    }
+
+    #[test]
+    fn ewkb_multi_polygon_formats_as_wkt() {
+        let raw = decode_hex(
+            "0106000020E610000002000000010300000001000000050000000000000000005D4000000000000044400000000000405D4000000000000044400000000000405D4000000000008044400000000000005D4000000000008044400000000000005D400000000000004440010300000001000000050000000000000000805D4000000000008043400000000000C05D4000000000008043400000000000C05D4000000000000044400000000000805D4000000000000044400000000000805D400000000000804340",
+        );
+        assert_eq!(
+            super::super::wkb::wkb_to_wkt(&raw),
+            Some(
+                "MULTIPOLYGON(((116 40,117 40,117 41,116 41,116 40)),((118 39,119 39,119 40,118 40,118 39)))"
+                    .to_string()
+            )
+        );
+    }
+
+    #[test]
+    fn ewkb_geometry_collection_formats_as_wkt() {
+        let raw = decode_hex(
+            "0107000020E61000000200000001010000000000000000005D4000000000000044400102000000020000000000000000405D4000000000008044400000000000805D400000000000004540",
+        );
+        assert_eq!(
+            super::super::wkb::wkb_to_wkt(&raw),
+            Some("GEOMETRYCOLLECTION(POINT(116 40),LINESTRING(117 41,118 42))".to_string())
+        );
+    }
+
+    #[test]
+    fn pg_optional_array_to_json_preserves_text_values_and_nulls() {
+        let value = pg_optional_array_to_json(
+            vec![Some("productManager".to_string()), None, Some("projectOwner".to_string())],
+            serde_json::Value::String,
+        );
+
+        assert_eq!(value, serde_json::json!(["productManager", null, "projectOwner"]));
+    }
+
+    #[test]
+    fn pg_quote_ident_plain_identifier() {
+        assert_eq!(pg_quote_ident("public"), "\"public\"");
+    }
+
+    #[test]
+    fn pg_quote_ident_escapes_double_quotes() {
+        assert_eq!(pg_quote_ident("my\"schema"), "\"my\"\"schema\"");
+    }
+
+    #[test]
+    fn pg_quote_ident_empty_string() {
+        assert_eq!(pg_quote_ident(""), "\"\"");
+    }
+
+    #[test]
+    fn pg_quote_ident_special_chars() {
+        // PostgreSQL allows many special chars in quoted identifiers
+        let ident = "my schema with spaces";
+        assert_eq!(pg_quote_ident(ident), "\"my schema with spaces\"");
+    }
+
+    #[test]
+    fn pg_quote_ident_injection_attempt() {
+        // A malicious schema name that tries to break out of quotes
+        let malicious = r#"public"; DROP TABLE users; --"#;
+        let escaped = pg_quote_ident(malicious);
+        // Double quotes should be doubled, not breaking out
+        assert_eq!(escaped, r#""public""; DROP TABLE users; --""#);
+        assert!(escaped.matches('"').count().is_multiple_of(2), "quote count should be even");
+    }
+
+    // --- query_result_row_limit ---
+
+    #[test]
+    fn row_limit_uses_max_rows_when_present() {
+        assert_eq!(query_result_row_limit(Some(50)), 50);
+    }
+
+    #[test]
+    fn row_limit_falls_back_to_default() {
+        let default = crate::query::MAX_ROWS;
+        assert_eq!(query_result_row_limit(None), default);
+    }
+
+    #[test]
+    fn row_limit_clamps_zero_to_one() {
+        assert_eq!(query_result_row_limit(Some(0)), 1);
+    }
+
+    #[test]
+    fn row_limit_allows_max_rows_override() {
+        assert_eq!(query_result_row_limit(Some(5)), 5);
+    }
+
+    #[test]
+    fn timestamptz_display_preserves_local_offset() {
+        let text = format_pg_timestamptz(Local::now());
+        assert!(!text.ends_with("+00:00") || Local::now().offset().local_minus_utc() == 0);
+    }
+
+    // --- validate_postgres_ssl_paths ---
+
+    #[test]
+    fn ssl_validation_passes_for_clean_url() {
+        assert!(validate_postgres_ssl_paths("postgres://localhost/db").is_ok());
+    }
+
+    #[test]
+    fn ssl_validation_passes_for_url_without_query() {
+        assert!(validate_postgres_ssl_paths("host=localhost dbname=test").is_ok());
+    }
+
+    #[test]
+    fn ssl_validation_passes_for_irrelevant_params() {
+        assert!(validate_postgres_ssl_paths("postgres://localhost/db?sslmode=require&connect_timeout=10").is_ok());
+    }
+
+    #[test]
+    fn ssl_validation_rejects_nonexistent_sslcert_path() {
+        let result = validate_postgres_ssl_paths("postgres://localhost/db?sslcert=/nonexistent/path/cert.pem");
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("sslcert"), "error should mention sslcert");
+    }
+
+    #[test]
+    fn ssl_validation_rejects_nonexistent_sslkey_path() {
+        let result = validate_postgres_ssl_paths("postgres://localhost/db?sslkey=/nonexistent/path/key.pem");
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("sslkey"), "error should mention sslkey");
+    }
+
+    #[test]
+    fn ssl_validation_rejects_nonexistent_sslrootcert_path() {
+        let result = validate_postgres_ssl_paths("postgres://localhost/db?sslrootcert=/nonexistent/path/root.crt");
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("sslrootcert"), "error should mention sslrootcert");
+    }
+
+    #[test]
+    fn ssl_validation_rejects_path_traversal_in_sslcert() {
+        let result = validate_postgres_ssl_paths("postgres://localhost/db?sslcert=../../../etc/passwd");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn ssl_validation_handles_url_encoded_ssl_param() {
+        // %2F = '/', so sslcert=%2Ftmp%2Fcert.pem means sslcert=/tmp/cert.pem
+        let result = validate_postgres_ssl_paths("postgres://localhost/db?sslcert=%2Fnonexistent%2Fcert.pem");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn ssl_validation_handles_multiple_params() {
+        let result =
+            validate_postgres_ssl_paths("postgres://localhost/db?sslmode=require&sslcert=/nonexistent/cert.pem");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn postgres_connection_url_strips_ssl_file_params_before_driver_parse() {
+        let dir = std::env::temp_dir();
+        let cert = dir.join(format!("dbx-postgres-cert-{}.pem", std::process::id()));
+        let key = dir.join(format!("dbx-postgres-key-{}.pem", std::process::id()));
+        let root = dir.join(format!("dbx-postgres-root-{}.pem", std::process::id()));
+        std::fs::write(&cert, "not a real cert").unwrap();
+        std::fs::write(&key, "not a real key").unwrap();
+        std::fs::write(&root, "not a real root").unwrap();
+
+        let url = format!(
+            "postgres://localhost/db?sslmode=verify-full&sslcert={}&sslkey={}&sslrootcert={}&application_name=dbx",
+            cert.display(),
+            key.display(),
+            root.display()
+        );
+        let parsed = postgres_connection_url(&url).unwrap();
+
+        assert_eq!(parsed.url, "postgres://localhost/db?sslmode=require&application_name=dbx");
+        assert_eq!(parsed.ssl_files.sslcert.as_deref(), Some(cert.to_str().unwrap()));
+        assert_eq!(parsed.ssl_files.sslkey.as_deref(), Some(key.to_str().unwrap()));
+        assert_eq!(parsed.ssl_files.sslrootcert.as_deref(), Some(root.to_str().unwrap()));
+        assert!(!parsed.accepts_invalid_certs);
+        assert!(parsed.verifies_hostname);
+        tokio_postgres::Config::from_str(&parsed.url).unwrap();
+
+        let _ = std::fs::remove_file(cert);
+        let _ = std::fs::remove_file(key);
+        let _ = std::fs::remove_file(root);
+    }
+
+    #[test]
+    fn postgres_connection_url_keeps_verify_ca_ca_only_semantics() {
+        let parsed = postgres_connection_url("postgres://localhost/db?sslmode=verify-ca").unwrap();
+
+        assert_eq!(parsed.url, "postgres://localhost/db?sslmode=require");
+        assert!(!parsed.accepts_invalid_certs);
+        assert!(!parsed.verifies_hostname);
+    }
+
+    #[test]
+    fn postgres_connection_url_normalizes_channel_binding_require_to_prefer() {
+        let parsed =
+            postgres_connection_url("postgres://localhost/db?sslmode=require&channel_binding=require").unwrap();
+
+        assert_eq!(parsed.url, "postgres://localhost/db?sslmode=require&channel_binding=prefer");
+        // The sanitized URL must be parseable by the driver
+        tokio_postgres::Config::from_str(&parsed.url).unwrap();
+    }
+
+    #[test]
+    fn postgres_connection_url_keeps_channel_binding_prefer() {
+        let parsed = postgres_connection_url("postgres://localhost/db?channel_binding=prefer").unwrap();
+
+        assert_eq!(parsed.url, "postgres://localhost/db?channel_binding=prefer");
+        tokio_postgres::Config::from_str(&parsed.url).unwrap();
+    }
+
+    #[test]
+    fn postgres_tls_rejects_unpaired_client_cert_and_key() {
+        let _ = rustls::crypto::aws_lc_rs::default_provider().install_default();
+        let pg_config = tokio_postgres::Config::from_str("postgres://localhost/db?sslmode=require").unwrap();
+        let ssl_files =
+            PostgresSslFiles { sslcert: Some("/tmp/client.crt".to_string()), sslkey: None, sslrootcert: None };
+
+        let error = match postgres_tls_config(&pg_config, &ssl_files, true, false) {
+            Ok(_) => panic!("expected missing sslkey to fail"),
+            Err(error) => error,
+        };
+        assert!(error.contains("sslkey"));
+    }
+
+    #[test]
+    fn postgres_accept_all_tls_signature_does_not_parse_unverified_cert() {
+        let verifier = NoPostgresCertVerification { provider: Arc::new(rustls::crypto::aws_lc_rs::default_provider()) };
+        let malformed_cert = CertificateDer::from(vec![0x30, 0x03, 0x02, 0x01, 0x00]);
+
+        assert!(verifier.accept_tls_signature_for_unverified_cert(&malformed_cert).is_ok());
+    }
+
+    #[test]
+    fn inject_postgres_keepalive_params_preserves_url_fragment() {
+        let url = "postgres://localhost/app?sslmode=require#read-only";
+
+        assert_eq!(
+            inject_postgres_keepalive_params(url),
+            "postgres://localhost/app?sslmode=require&keepalives=1&keepalives_idle=30&keepalives_interval=10&keepalives_retries=3#read-only"
+        );
+    }
+
+    #[test]
+    fn postgres_cancel_attempt_timeout_is_single_budget() {
+        assert_eq!(postgres_cancel_attempt_timeout(Duration::from_secs(5), None), Duration::from_secs(5));
+        assert_eq!(
+            postgres_cancel_attempt_timeout(
+                Duration::from_secs(5),
+                Some(&PostgresCancelContext {
+                    ssl_files: PostgresSslFiles::default(),
+                    accepts_invalid_certs: true,
+                    verifies_hostname: false,
+                    ssl_mode: SslMode::Require,
+                })
+            ),
+            Duration::from_secs(5)
+        );
+    }
+
+    #[test]
+    fn postgres_cancel_context_omits_disabled_ssl_mode() {
+        assert!(build_postgres_cancel_context("postgres://localhost/app?sslmode=disable").is_none());
+    }
+
+    #[test]
+    fn postgres_tls_accepts_invalid_certs_for_require_sslmode() {
+        let pg_config = tokio_postgres::Config::from_str("postgres://localhost/db?sslmode=require").unwrap();
+
+        assert!(postgres_sslmode_accepts_invalid_certs(pg_config.get_ssl_mode()));
+    }
+
+    #[test]
+    fn postgres_tls_accepts_invalid_certs_for_default_prefer_sslmode() {
+        let pg_config = tokio_postgres::Config::from_str("postgres://localhost/db").unwrap();
+
+        assert!(postgres_sslmode_accepts_invalid_certs(pg_config.get_ssl_mode()));
+    }
+
+    #[test]
+    fn postgres_tls_keeps_verification_off_only_when_ssl_is_disabled() {
+        let pg_config = tokio_postgres::Config::from_str("postgres://localhost/db?sslmode=disable").unwrap();
+
+        assert!(!postgres_sslmode_accepts_invalid_certs(pg_config.get_ssl_mode()));
+    }
+
+    // --- SQL generation ---
+
+    #[test]
+    fn postgres_tables_sql_contains_expected_columns() {
+        let sql = postgres_tables_sql();
+        assert!(sql.contains("table_name"));
+        assert!(sql.contains("table_type"));
+        assert!(sql.contains("table_comment"));
+        assert!(sql.contains("pg_catalog.pg_inherits"));
+        assert!(sql.contains("parent_schema"));
+        assert!(sql.contains("parent_name"));
+        assert!(sql.contains("pc.relkind = 'p'"));
+        assert!(sql.contains("$1"));
+        assert!(sql.contains("BASE TABLE"));
+        assert!(sql.contains("VIEW"));
+        assert!(sql.contains("MATERIALIZED_VIEW"));
+        assert!(sql.contains("FOREIGN TABLE"));
+    }
+
+    #[test]
+    fn postgres_table_comment_sql_targets_single_table() {
+        let sql = postgres_table_comment_sql();
+
+        assert!(sql.contains("obj_description(c.oid)"));
+        assert!(sql.contains("n.nspname = $1"));
+        assert!(sql.contains("c.relname = $2"));
+        assert!(sql.contains("LIMIT 1"));
+        assert!(!sql.contains("ORDER BY"));
+    }
+
+    #[test]
+    fn postgres_column_metadata_reads_identity_extra() {
+        assert!(POSTGRES_COLUMNS_SQL.contains("a.attidentity"));
+        assert!(POSTGRES_COLUMNS_SQL.contains("pg_sequence"));
+        assert!(POSTGRES_COLUMNS_SQL.contains("generated by default as identity"));
+        assert!(POSTGRES_COLUMNS_SQL.contains("generated always as identity"));
+        assert!(POSTGRES_COLUMNS_SQL.contains("COALESCE(c.is_nullable = 'YES', NOT a.attnotnull)"));
+        assert!(POSTGRES_COLUMNS_SQL.contains("LEFT JOIN information_schema.columns"));
+        assert!(POSTGRES_COLUMNS_SQL.contains("pg_enum"));
+        assert!(POSTGRES_COLUMNS_SQL.contains("AS enum_values"));
+    }
+
+    #[test]
+    fn postgres_column_metadata_has_opengauss_compatible_fallback() {
+        assert!(!POSTGRES_COLUMNS_COMPAT_SQL.contains("a.attidentity"));
+        assert!(!POSTGRES_COLUMNS_COMPAT_SQL.contains("pg_sequence"));
+        assert!(POSTGRES_COLUMNS_COMPAT_SQL.contains("NULL::text AS column_extra"));
+        assert!(POSTGRES_COLUMNS_COMPAT_SQL.contains("col_description"));
+        assert!(POSTGRES_COLUMNS_COMPAT_SQL.contains("COALESCE(c.is_nullable = 'YES', NOT a.attnotnull)"));
+        assert!(POSTGRES_COLUMNS_COMPAT_SQL.contains("LEFT JOIN information_schema.columns"));
+        assert!(POSTGRES_COLUMNS_COMPAT_SQL.contains("NULL::text AS enum_values"));
+        assert!(!POSTGRES_COLUMNS_COMPAT_SQL.contains("pg_enum"));
+    }
+
+    #[test]
+    fn postgres_column_metadata_has_information_schema_fallback() {
+        assert!(POSTGRES_COLUMNS_INFORMATION_SCHEMA_SQL.contains("information_schema.columns"));
+        assert!(POSTGRES_COLUMNS_INFORMATION_SCHEMA_SQL.contains("information_schema.table_constraints"));
+        assert!(POSTGRES_COLUMNS_INFORMATION_SCHEMA_SQL.contains("information_schema.key_column_usage"));
+        assert!(POSTGRES_COLUMNS_INFORMATION_SCHEMA_SQL.contains("NULL::text AS enum_values"));
+        assert!(!POSTGRES_COLUMNS_INFORMATION_SCHEMA_SQL.contains("pg_attribute"));
+        assert!(!POSTGRES_COLUMNS_INFORMATION_SCHEMA_SQL.contains("regclass"));
+    }
+
+    #[tokio::test]
+    async fn postgres_column_metadata_query_returns_enum_values_against_real_postgres() {
+        let Some(container) = start_docker_postgres().await else {
+            return;
+        };
+
+        let pool = connect(&container.url(), Duration::from_secs(5)).await.expect("connect postgres");
+        let schema = format!("dbx_enum_meta_{}", std::process::id());
+        let schema_ident = format!("\"{}\"", schema.replace('\"', "\"\""));
+        let table = format!("{schema_ident}.orders");
+        let type_ident = format!("{schema_ident}.\"status\"");
+
+        execute_query(&pool, &format!("CREATE SCHEMA {schema_ident}")).await.expect("create schema");
+        execute_query(&pool, &format!("CREATE TYPE {type_ident} AS ENUM ('pending', 'active', 'archived')"))
+            .await
+            .expect("create enum type");
+        execute_query(&pool, &format!("CREATE TABLE {table} (id integer PRIMARY KEY, state {type_ident} NOT NULL)"))
+            .await
+            .expect("create table");
+
+        let client =
+            checkout_postgres_client(&pool, None, crate::db::connection_timeout()).await.expect("checkout client");
+
+        let columns =
+            get_columns_with_sql(&client, POSTGRES_COLUMNS_SQL, &schema, "orders").await.expect("primary columns");
+        assert_eq!(
+            state_enum_values(&columns),
+            Some(vec!["pending".to_string(), "active".to_string(), "archived".to_string()])
+        );
+    }
+
+    #[tokio::test]
+    #[ignore = "requires DBX_TEST_POSTGRES_URL pointing at a writable PostgreSQL database"]
+    async fn postgres_column_metadata_decode_type_mismatch_uses_fallbacks() {
+        let url = std::env::var("DBX_TEST_POSTGRES_URL").expect("DBX_TEST_POSTGRES_URL");
+        let pool = connect(&url, std::time::Duration::from_secs(5)).await.expect("connect postgres");
+        let client =
+            checkout_postgres_client(&pool, None, std::time::Duration::from_secs(5)).await.expect("checkout postgres");
+        let row = client
+            .query_one(
+                "SELECT \
+                   1::int4 AS column_name, \
+                   'text'::text AS full_type, \
+                   'YES'::text AS is_nullable, \
+                   NULL::text AS column_default, \
+                   1::int4 AS is_pk, \
+                   NULL::text AS column_comment, \
+                   NULL::text AS column_extra, \
+                   NULL::int4 AS numeric_precision, \
+                   NULL::int4 AS numeric_scale, \
+                   NULL::int4 AS character_maximum_length",
+                &[],
+            )
+            .await
+            .expect("query mismatched metadata row");
+
+        let info = column_info_from_row(&row);
+        // int4 column_name should be converted to string "1" instead of panicking
+        assert_eq!(info.name, "1");
+        // text 'YES' is not a standard bool, pg_row_try_bool falls back to string match
+        assert!(info.is_nullable);
+        // int4 1 should be interpreted as true for is_primary_key
+        assert!(info.is_primary_key);
+    }
+
+    #[test]
+    fn postgres_index_metadata_has_legacy_catalog_fallback() {
+        assert!(POSTGRES_INDEXES_SQL.contains("ix.indnkeyatts"));
+        assert!(!POSTGRES_INDEXES_COMPAT_SQL.contains("ix.indnkeyatts"));
+        assert!(POSTGRES_INDEXES_COMPAT_SQL.contains("NULL::smallint AS nkeyatts"));
+        assert!(!POSTGRES_INDEXES_COMPAT_SQL.contains("LATERAL"));
+        assert!(!POSTGRES_INDEXES_COMPAT_SQL.contains("WITH ORDINALITY"));
+        assert!(POSTGRES_INDEXES_COMPAT_SQL.contains("generate_series"));
+        assert!(POSTGRES_INDEXES_COMPAT_SQL.contains("string_to_array(ix.indkey::text, ' ')"));
+    }
+
+    #[test]
+    fn postgres_owner_metadata_casts_relkind_to_text() {
+        assert!(POSTGRES_OWNERS_SQL.contains("c.relkind::text AS relkind"));
+        assert!(POSTGRES_OWNERS_SQL.contains("c.relkind IN ('r', 'v', 'm', 'S', 'f', 'p')"));
+    }
+
+    #[test]
+    fn postgres_owner_object_type_maps_relkind_codes() {
+        assert_eq!(postgres_owner_object_type("r"), "TABLE");
+        assert_eq!(postgres_owner_object_type("v"), "VIEW");
+        assert_eq!(postgres_owner_object_type("m"), "MATERIALIZED_VIEW");
+        assert_eq!(postgres_owner_object_type("S"), "SEQUENCE");
+        assert_eq!(postgres_owner_object_type("f"), "FOREIGN TABLE");
+        assert_eq!(postgres_owner_object_type("p"), "PARTITIONED TABLE");
+        assert_eq!(postgres_owner_object_type("?"), "?");
+    }
+
+    #[test]
+    fn list_objects_sql_includes_routines() {
+        let sql = list_objects_sql(true, true, false, true);
+        assert!(sql.contains("pg_catalog.pg_class"));
+        assert!(sql.contains("pg_catalog.pg_proc"));
+        assert!(sql.contains("pg_catalog.pg_inherits"));
+        assert!(sql.contains("parent_schema"));
+        assert!(sql.contains("parent_name"));
+        assert!(sql.contains("NULL::text AS signature"));
+        assert!(sql.contains("pg_get_function_identity_arguments(p.oid) AS signature"));
+        assert!(sql.contains("pc.relkind = 'p'"));
+        assert!(sql.contains("pg_stat_file"));
+        assert!(sql.contains("pg_xact_commit_timestamp"));
+        assert!(sql.contains("'PROCEDURE'"));
+        assert!(sql.contains("'FUNCTION'"));
+    }
+
+    #[test]
+    fn list_objects_sql_without_timestamps_omits_stat_file() {
+        let sql = list_objects_sql(false, true, false, true);
+        assert!(!sql.contains("pg_stat_file"));
+        assert!(sql.contains("NULL::text AS created_at"));
+        assert!(sql.contains("NULL::text AS updated_at"));
+    }
+
+    #[test]
+    fn redshift_compatible_list_objects_sql_uses_legacy_argument_formatter() {
+        let sql = list_objects_sql(false, false, false, false);
+        assert!(sql.contains("pg_get_function_arguments(p.oid) AS signature"));
+        assert!(!sql.contains("pg_get_function_identity_arguments"));
+    }
+
+    #[test]
+    fn function_identity_arguments_probe_uses_pg_proc() {
+        let sql = postgres_has_function_identity_arguments_sql();
+        assert!(sql.contains("pg_catalog.pg_proc"));
+        assert!(sql.contains("n.nspname = 'pg_catalog'"));
+        assert!(sql.contains("p.proname = 'pg_get_function_identity_arguments'"));
+    }
+
+    #[test]
+    fn both_list_objects_sql_variants_use_parameter() {
+        assert!(list_objects_sql(true, true, true, true).contains("$1"));
+        assert!(list_objects_sql(false, true, true, true).contains("$1"));
+        assert!(list_objects_sql(true, true, false, true).contains("$1"));
+        assert!(list_objects_sql(false, true, false, true).contains("$1"));
+        assert!(list_objects_sql(true, false, true, true).contains("$1"));
+        assert!(list_objects_sql(false, false, true, true).contains("$1"));
+        assert!(list_objects_sql(true, false, false, true).contains("$1"));
+        assert!(list_objects_sql(false, false, false, true).contains("$1"));
+    }
+
+    #[test]
+    fn both_list_objects_sql_variants_include_pg_proc() {
+        assert!(list_objects_sql(true, true, true, true).contains("pg_catalog.pg_proc"));
+        assert!(list_objects_sql(false, true, true, true).contains("pg_catalog.pg_proc"));
+        assert!(list_objects_sql(true, true, false, true).contains("pg_catalog.pg_proc"));
+        assert!(list_objects_sql(false, true, false, true).contains("pg_catalog.pg_proc"));
+        assert!(list_objects_sql(true, false, true, true).contains("pg_catalog.pg_proc"));
+        assert!(list_objects_sql(false, false, true, true).contains("pg_catalog.pg_proc"));
+        assert!(list_objects_sql(true, false, false, true).contains("pg_catalog.pg_proc"));
+        assert!(list_objects_sql(false, false, false, true).contains("pg_catalog.pg_proc"));
+    }
+
+    #[test]
+    fn legacy_list_objects_sql_avoids_pg11_proc_kind_column() {
+        let sql = list_objects_sql(true, false, false, true);
+        assert!(!sql.contains("p.prokind"));
+        assert!(!sql.contains("p.prosp"));
+        assert!(sql.contains("NOT p.proisagg"));
+        assert!(sql.contains("NOT p.proiswindow"));
+        assert!(sql.contains("pg_get_function_identity_arguments(p.oid) AS signature"));
+        assert!(sql.contains("'FUNCTION' AS object_type"));
+        assert!(!sql.contains("'PROCEDURE'"));
+    }
+
+    #[test]
+    fn gaussdb_compatible_list_objects_sql_uses_prosp_when_prokind_is_missing() {
+        let sql = list_objects_sql(true, false, true, true);
+        assert!(!sql.contains("p.prokind"));
+        assert!(sql.contains("CASE WHEN p.prosp THEN 'PROCEDURE' ELSE 'FUNCTION' END AS object_type"));
+        assert!(sql.contains("CASE WHEN p.prosp THEN 2 ELSE 3 END AS sort_order"));
+        assert!(sql.contains("NOT p.proisagg"));
+        assert!(sql.contains("NOT p.proiswindow"));
+        assert!(sql.contains("pg_get_function_identity_arguments(p.oid) AS signature"));
+    }
+
+    #[test]
+    fn gaussdb_compatible_list_objects_sql_uses_prosp_with_prokind_when_available() {
+        let sql = list_objects_sql(true, true, true, true);
+        assert!(
+            sql.contains("CASE WHEN p.prokind = 'p' OR p.prosp THEN 'PROCEDURE' ELSE 'FUNCTION' END AS object_type")
+        );
+        assert!(sql.contains("CASE WHEN p.prokind = 'p' OR p.prosp THEN 2 ELSE 3 END AS sort_order"));
+        assert!(sql.contains("p.prokind IN ('p','f') OR p.prosp"));
+        assert!(sql.contains("pg_get_function_identity_arguments(p.oid) AS signature"));
+    }
+
+    #[test]
+    fn postgres_functions_sql_uses_proc_kind_when_available() {
+        let sql = postgres_functions_sql(true);
+        assert!(sql.contains("p.prokind IN ('f', 'p')"));
+        assert!(sql.contains("WHEN 'p' THEN 'PROCEDURE'"));
+        assert!(!sql.contains("p.proisagg"));
+        assert!(!sql.contains("p.proiswindow"));
+    }
+
+    #[test]
+    fn legacy_postgres_functions_sql_avoids_proc_kind_column() {
+        let sql = postgres_functions_sql(false);
+        assert!(!sql.contains("p.prokind"));
+        assert!(sql.contains("NOT p.proisagg"));
+        assert!(sql.contains("NOT p.proiswindow"));
+        assert!(sql.contains("'FUNCTION'"));
+        assert!(!sql.contains("'PROCEDURE'"));
+    }
+
+    #[test]
+    fn postgres_proc_has_prokind_sql_checks_catalog_attribute() {
+        let sql = postgres_proc_has_prokind_sql();
+        assert!(sql.contains("pg_catalog.pg_attribute"));
+        assert!(sql.contains("'pg_catalog.pg_proc'::regclass"));
+        assert!(sql.contains("attname = 'prokind'"));
+    }
+
+    #[test]
+    fn postgres_proc_has_prosp_sql_checks_catalog_attribute() {
+        let sql = postgres_proc_has_prosp_sql();
+        assert!(sql.contains("pg_catalog.pg_attribute"));
+        assert!(sql.contains("'pg_catalog.pg_proc'::regclass"));
+        assert!(sql.contains("attname = 'prosp'"));
+    }
+
+    #[test]
+    fn transaction_recovery_statement_detection_matches_common_postgres_commands() {
+        assert!(is_transaction_recovery_statement("ROLLBACK"));
+        assert!(is_transaction_recovery_statement("rollback work"));
+        assert!(is_transaction_recovery_statement("ABORT TRANSACTION"));
+        assert!(is_transaction_recovery_statement("commit"));
+        assert!(is_transaction_recovery_statement("END"));
+    }
+
+    #[test]
+    fn transaction_recovery_statement_detection_ignores_regular_queries() {
+        assert!(!is_transaction_recovery_statement("SELECT 1"));
+        assert!(!is_transaction_recovery_statement("BEGIN"));
+        assert!(!is_transaction_recovery_statement("UPDATE users SET name = 'dbx'"));
+    }
+
+    #[test]
+    fn postgres_ddl_detection_covers_schema_changing_statements() {
+        assert!(invalidates_postgres_statement_cache("ALTER TABLE users ADD COLUMN email text"));
+        assert!(invalidates_postgres_statement_cache("  CREATE INDEX idx_users_email ON users(email)"));
+        assert!(invalidates_postgres_statement_cache("COMMENT ON COLUMN users.email IS 'Email'"));
+        assert!(invalidates_postgres_statement_cache("DROP TABLE users"));
+        assert!(invalidates_postgres_statement_cache("TRUNCATE users"));
+        assert!(invalidates_postgres_statement_cache("REINDEX TABLE users"));
+        assert!(invalidates_postgres_statement_cache("VACUUM users"));
+    }
+
+    #[test]
+    fn postgres_ddl_detection_ignores_regular_dml_and_selects() {
+        assert!(!invalidates_postgres_statement_cache("SELECT * FROM users"));
+        assert!(!invalidates_postgres_statement_cache("UPDATE users SET name = 'Ada'"));
+        assert!(!invalidates_postgres_statement_cache("INSERT INTO users(name) VALUES ('Ada')"));
+        assert!(!invalidates_postgres_statement_cache("DELETE FROM users WHERE id = 1"));
+    }
+
+    // --- execute_batch ---
+
+    #[tokio::test]
+    async fn execute_batch_empty_statements_returns_ok() {
+        // Empty input should not error or try to connect
+        // We can't test with a real pool, but we can verify the empty-early-return logic
+        // by testing that an empty Vec doesn't need a pool reference
+        let statements: Vec<String> = vec![];
+        // This test validates the early return logic at code review level
+        // Actual execution requires a pool; we just verify the empty path exists
+        assert!(statements.is_empty());
+    }
+
+    #[tokio::test]
+    async fn execute_batch_whitespace_only_is_filtered() {
+        let statements = ["  ".to_string(), "\t\n".to_string(), "".to_string()];
+        let combined = statements.iter().map(|s| s.trim()).filter(|s| !s.is_empty()).collect::<Vec<_>>().join(";\n");
+        assert!(combined.is_empty());
+    }
+
+    #[test]
+    fn execute_batch_joins_with_semicolons() {
+        let statements = ["SELECT 1".to_string(), "SELECT 2".to_string()];
+        let combined = statements.iter().map(|s| s.trim()).filter(|s| !s.is_empty()).collect::<Vec<_>>().join(";\n");
+        assert_eq!(combined, "SELECT 1;\nSELECT 2");
+    }
+
+    // --- SET timezone escaping ---
+
+    #[test]
+    fn timezone_single_quotes_are_doubled() {
+        let tz = "UTC";
+        let escaped = tz.replace('\'', "''");
+        assert_eq!(escaped, "UTC");
+    }
+
+    #[test]
+    fn timezone_with_quote_is_escaped() {
+        let tz = "Some'Zone";
+        let escaped = tz.replace('\'', "''");
+        assert_eq!(escaped, "Some''Zone");
+    }
+
+    // --- pg_url_has_timezone_setting ---
+
+    #[test]
+    fn url_without_timezone_returns_false() {
+        assert!(!pg_url_has_timezone_setting("postgres://localhost/db"));
+        assert!(!pg_url_has_timezone_setting("postgres://localhost/db?sslmode=require"));
+    }
+
+    #[test]
+    fn url_with_options_timezone_returns_true() {
+        assert!(pg_url_has_timezone_setting("postgres://localhost/db?options=-c timezone=Asia/Shanghai"));
+    }
+
+    #[test]
+    fn url_with_url_encoded_timezone_returns_true() {
+        assert!(pg_url_has_timezone_setting("postgres://localhost/db?options=-c%20timezone%3DUTC"));
+    }
+
+    #[test]
+    fn url_with_uppercase_timezone_returns_true() {
+        assert!(pg_url_has_timezone_setting("postgres://localhost/db?options=--TimeZone=UTC"));
+    }
+
+    #[test]
+    fn like_contains_pattern_escapes_wildcards() {
+        assert_eq!(like_contains_pattern(""), "%%");
+        assert_eq!(like_contains_pattern("order_100%"), "%order~_100~%%");
+        assert_eq!(like_contains_pattern("tilde~name"), "%tilde~~name%");
+        assert_eq!(like_contains_pattern(r"foo\bar"), r"%foo\bar%");
+    }
+
+    #[test]
+    fn like_fuzzy_pattern_escapes_wildcards() {
+        assert_eq!(like_fuzzy_pattern(""), "%%");
+        assert_eq!(like_fuzzy_pattern("sysu"), "%s%y%s%u%");
+        assert_eq!(like_fuzzy_pattern("user_%"), "%u%s%e%r%~_%~%%");
+        assert_eq!(like_fuzzy_pattern("tilde~name"), "%t%i%l%d%e%~~%n%a%m%e%");
+    }
+
+    #[test]
+    fn postgres_tables_sql_uses_non_backslash_like_escape() {
+        let sql = postgres_tables_sql();
+
+        assert!(sql.contains("ILIKE $2 ESCAPE '~'"));
+        assert!(sql.contains("$3 <> ''"));
+        assert!(sql.contains("ILIKE $3 ESCAPE '~'"));
+        assert!(sql.contains("LIMIT CAST($4 AS BIGINT) OFFSET CAST($5 AS BIGINT)"));
+    }
+
+    #[test]
+    fn postgres_completion_like_pattern_uses_prefix_by_default() {
+        assert_eq!(postgres_completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Prefix)), "Temp%");
+        assert_eq!(postgres_completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Contains)), "%Temp%");
+        assert_eq!(
+            postgres_completion_like_pattern("order_100%", Some(&CompletionAssistantMatchMode::Prefix)),
+            "order~_100~%%"
+        );
+    }
+
+    #[test]
+    fn postgres_completion_sql_filters_before_limit() {
+        assert!(postgres_completion_tables_sql().contains("c.relname ILIKE $2 ESCAPE '~'"));
+        assert!(postgres_completion_tables_sql().contains("pg_catalog.pg_table_is_visible(c.oid)"));
+        assert!(postgres_completion_tables_sql().contains("ORDER BY c.relname LIMIT $4"));
+        assert!(postgres_completion_routines_sql().contains("p.proname ILIKE $2 ESCAPE '~'"));
+        assert!(postgres_completion_routines_sql().contains("ORDER BY p.proname LIMIT $4"));
+        assert!(postgres_completion_columns_sql().contains("a.attname ILIKE $3 ESCAPE '~'"));
+        assert!(postgres_visible_table_schema_sql().contains("pg_catalog.pg_table_is_visible(c.oid)"));
+    }
+}
diff --git a/crates/dbx-core/src/db/proxy_tunnel.rs b/crates/dbx-core/src/db/proxy_tunnel.rs
new file mode 100644
index 0000000..5a92732
--- /dev/null
+++ b/crates/dbx-core/src/db/proxy_tunnel.rs
@@ -0,0 +1,259 @@
+use crate::models::connection::ProxyType;
+use base64::engine::general_purpose::STANDARD as BASE64;
+use base64::Engine;
+use std::collections::HashMap;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::{TcpListener, TcpStream};
+use tokio::task::JoinHandle;
+use tokio::time::{timeout, Duration};
+
+const CONNECT_TIMEOUT: Duration = Duration::from_secs(10);
+
+#[derive(Default)]
+pub struct ProxyTunnelManager {
+    tunnels: tokio::sync::Mutex<HashMap<String, (JoinHandle<()>, u16)>>,
+}
+
+impl ProxyTunnelManager {
+    pub fn new() -> Self {
+        Self { tunnels: tokio::sync::Mutex::new(HashMap::new()) }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub async fn start_tunnel(
+        &self,
+        connection_id: &str,
+        proxy_type: ProxyType,
+        proxy_host: &str,
+        proxy_port: u16,
+        proxy_username: &str,
+        proxy_password: &str,
+        remote_host: &str,
+        remote_port: u16,
+    ) -> Result<u16, String> {
+        if let Some(local_port) = self.local_port(connection_id).await {
+            return Ok(local_port);
+        }
+
+        let local_port = portpicker::pick_unused_port().ok_or("No available port")?;
+        let listener = TcpListener::bind(("127.0.0.1", local_port))
+            .await
+            .map_err(|e| format!("Failed to bind proxy tunnel local port: {e}"))?;
+
+        let proxy = ProxyEndpoint {
+            proxy_type,
+            host: proxy_host.to_string(),
+            port: proxy_port,
+            username: proxy_username.to_string(),
+            password: proxy_password.to_string(),
+        };
+        let remote = RemoteEndpoint { host: remote_host.to_string(), port: remote_port };
+        let handle = tokio::spawn(proxy_forward_loop(listener, proxy, remote));
+
+        let mut tunnels = self.tunnels.lock().await;
+        if let Some((_, existing_port)) = tunnels.get(connection_id) {
+            handle.abort();
+            return Ok(*existing_port);
+        }
+
+        tunnels.insert(connection_id.to_string(), (handle, local_port));
+        Ok(local_port)
+    }
+
+    pub async fn local_port(&self, connection_id: &str) -> Option<u16> {
+        self.tunnels.lock().await.get(connection_id).map(|(_, port)| *port)
+    }
+
+    pub async fn stop_tunnel(&self, connection_id: &str) {
+        if let Some((handle, _)) = self.tunnels.lock().await.remove(connection_id) {
+            handle.abort();
+        }
+    }
+
+    pub async fn stop_tunnels_with_prefix(&self, connection_id_prefix: &str) {
+        let mut tunnels = self.tunnels.lock().await;
+        let keys: Vec<String> = tunnels.keys().filter(|key| key.starts_with(connection_id_prefix)).cloned().collect();
+        for key in keys {
+            if let Some((handle, _)) = tunnels.remove(&key) {
+                handle.abort();
+            }
+        }
+    }
+}
+
+#[derive(Clone)]
+struct ProxyEndpoint {
+    proxy_type: ProxyType,
+    host: String,
+    port: u16,
+    username: String,
+    password: String,
+}
+
+#[derive(Clone)]
+struct RemoteEndpoint {
+    host: String,
+    port: u16,
+}
+
+async fn proxy_forward_loop(listener: TcpListener, proxy: ProxyEndpoint, remote: RemoteEndpoint) {
+    loop {
+        let (mut inbound, _) = match listener.accept().await {
+            Ok(pair) => pair,
+            Err(_) => break,
+        };
+        let proxy = proxy.clone();
+        let remote = remote.clone();
+        tokio::spawn(async move {
+            let Ok(mut outbound) = connect_via_proxy(&proxy, &remote).await else {
+                return;
+            };
+            let _ = tokio::io::copy_bidirectional(&mut inbound, &mut outbound).await;
+        });
+    }
+}
+
+async fn connect_via_proxy(proxy: &ProxyEndpoint, remote: &RemoteEndpoint) -> Result<TcpStream, String> {
+    let stream = timeout(CONNECT_TIMEOUT, TcpStream::connect((proxy.host.as_str(), proxy.port)))
+        .await
+        .map_err(|_| "Proxy connection timed out".to_string())?
+        .map_err(|e| format!("Failed to connect proxy: {e}"))?;
+
+    match proxy.proxy_type {
+        ProxyType::Http => http_connect(stream, proxy, remote).await,
+        ProxyType::Socks5 => socks5_connect(stream, proxy, remote).await,
+    }
+}
+
+async fn http_connect(
+    mut stream: TcpStream,
+    proxy: &ProxyEndpoint,
+    remote: &RemoteEndpoint,
+) -> Result<TcpStream, String> {
+    let target = format!("{}:{}", remote.host, remote.port);
+    let mut request = format!("CONNECT {target} HTTP/1.1\r\nHost: {target}\r\n");
+    if !proxy.username.is_empty() || !proxy.password.is_empty() {
+        let token = BASE64.encode(format!("{}:{}", proxy.username, proxy.password));
+        request.push_str(&format!("Proxy-Authorization: Basic {token}\r\n"));
+    }
+    request.push_str("\r\n");
+    stream.write_all(request.as_bytes()).await.map_err(|e| format!("Failed to send CONNECT request: {e}"))?;
+
+    let mut response = Vec::new();
+    let mut buf = [0_u8; 1];
+    while !response.ends_with(b"\r\n\r\n") && response.len() < 8192 {
+        let n = stream.read(&mut buf).await.map_err(|e| format!("Failed to read CONNECT response: {e}"))?;
+        if n == 0 {
+            break;
+        }
+        response.push(buf[0]);
+    }
+    let text = String::from_utf8_lossy(&response);
+    if text.starts_with("HTTP/1.1 200") || text.starts_with("HTTP/1.0 200") {
+        Ok(stream)
+    } else {
+        let status = text.lines().next().unwrap_or("invalid proxy response");
+        Err(format!("HTTP proxy CONNECT failed: {status}"))
+    }
+}
+
+async fn socks5_connect(
+    mut stream: TcpStream,
+    proxy: &ProxyEndpoint,
+    remote: &RemoteEndpoint,
+) -> Result<TcpStream, String> {
+    let wants_auth = !proxy.username.is_empty() || !proxy.password.is_empty();
+    let methods: &[u8] = if wants_auth { &[0x00, 0x02] } else { &[0x00] };
+    let mut hello = vec![0x05, methods.len() as u8];
+    hello.extend_from_slice(methods);
+    stream.write_all(&hello).await.map_err(|e| format!("Failed to send SOCKS greeting: {e}"))?;
+
+    let mut method = [0_u8; 2];
+    stream.read_exact(&mut method).await.map_err(|e| format!("Failed to read SOCKS greeting: {e}"))?;
+    if method[0] != 0x05 {
+        return Err("Invalid SOCKS proxy version".to_string());
+    }
+    match method[1] {
+        0x00 => {}
+        0x02 => socks5_authenticate(&mut stream, proxy).await?,
+        0xff => return Err("SOCKS proxy rejected supported authentication methods".to_string()),
+        other => return Err(format!("SOCKS proxy selected unsupported auth method: {other}")),
+    }
+
+    let host = remote.host.as_bytes();
+    if host.len() > u8::MAX as usize {
+        return Err("Remote host is too long for SOCKS5 domain address".to_string());
+    }
+    let mut req = vec![0x05, 0x01, 0x00, 0x03, host.len() as u8];
+    req.extend_from_slice(host);
+    req.extend_from_slice(&remote.port.to_be_bytes());
+    stream.write_all(&req).await.map_err(|e| format!("Failed to send SOCKS connect request: {e}"))?;
+
+    let mut head = [0_u8; 4];
+    stream.read_exact(&mut head).await.map_err(|e| format!("Failed to read SOCKS connect response: {e}"))?;
+    if head[0] != 0x05 {
+        return Err("Invalid SOCKS connect response version".to_string());
+    }
+    if head[1] != 0x00 {
+        return Err(format!("SOCKS proxy connect failed with code {}", head[1]));
+    }
+    let addr_len = match head[3] {
+        0x01 => 4,
+        0x03 => {
+            let mut len = [0_u8; 1];
+            stream.read_exact(&mut len).await.map_err(|e| format!("Failed to read SOCKS bound address length: {e}"))?;
+            len[0] as usize
+        }
+        0x04 => 16,
+        other => return Err(format!("Unsupported SOCKS bound address type: {other}")),
+    };
+    let mut discard = vec![0_u8; addr_len + 2];
+    stream.read_exact(&mut discard).await.map_err(|e| format!("Failed to read SOCKS bound address: {e}"))?;
+    Ok(stream)
+}
+
+async fn socks5_authenticate(stream: &mut TcpStream, proxy: &ProxyEndpoint) -> Result<(), String> {
+    let username = proxy.username.as_bytes();
+    let password = proxy.password.as_bytes();
+    if username.len() > u8::MAX as usize || password.len() > u8::MAX as usize {
+        return Err("SOCKS username or password is too long".to_string());
+    }
+    let mut req = vec![0x01, username.len() as u8];
+    req.extend_from_slice(username);
+    req.push(password.len() as u8);
+    req.extend_from_slice(password);
+    stream.write_all(&req).await.map_err(|e| format!("Failed to send SOCKS authentication: {e}"))?;
+
+    let mut res = [0_u8; 2];
+    stream.read_exact(&mut res).await.map_err(|e| format!("Failed to read SOCKS authentication response: {e}"))?;
+    if res == [0x01, 0x00] {
+        Ok(())
+    } else {
+        Err("SOCKS proxy authentication failed".to_string())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ProxyTunnelManager;
+    use crate::models::connection::ProxyType;
+
+    #[tokio::test]
+    async fn start_tunnel_reuses_existing_local_port() {
+        let manager = ProxyTunnelManager::new();
+
+        let first_port = manager
+            .start_tunnel("connection", ProxyType::Http, "127.0.0.1", 8080, "", "", "db.internal", 5432)
+            .await
+            .expect("first proxy tunnel should start");
+        let second_port = manager
+            .start_tunnel("connection", ProxyType::Http, "127.0.0.1", 8081, "", "", "other-db.internal", 5433)
+            .await
+            .expect("existing proxy tunnel should be reused");
+
+        assert_eq!(second_port, first_port);
+        assert_eq!(manager.local_port("connection").await, Some(first_port));
+
+        manager.stop_tunnel("connection").await;
+    }
+}
diff --git a/crates/dbx-core/src/db/questdb.rs b/crates/dbx-core/src/db/questdb.rs
new file mode 100644
index 0000000..1894c3a
--- /dev/null
+++ b/crates/dbx-core/src/db/questdb.rs
@@ -0,0 +1,187 @@
+use crate::db;
+use crate::db::{ColumnInfo, IndexInfo, ObjectInfo, QueryResult, TableInfo};
+use crate::models::connection::DatabaseType;
+use crate::sql_dialect::quote_table_identifier;
+use deadpool_postgres::Pool;
+
+pub async fn list_objects(pool: &Pool, schema: &str) -> Result<Vec<ObjectInfo>, String> {
+    Ok(list_tables(pool, schema)
+        .await?
+        .iter()
+        .map(|t| ObjectInfo {
+            name: t.name.clone(),
+            object_type: t.table_type.clone(),
+            schema: None,
+            signature: None,
+            comment: t.comment.clone(),
+            created_at: None,
+            updated_at: None,
+            parent_schema: None,
+            parent_name: None,
+        })
+        .collect())
+}
+
+/// try query `table`, `view` and `materialized view` using statement supported by the newer version.
+/// if there is an error, rollback to the previous version of the statement
+pub async fn list_tables(pool: &Pool, _schema: &str) -> Result<Vec<TableInfo>, String> {
+    match list_tables_new_version(pool, _schema).await {
+        Ok(ddl) => Ok(ddl),
+        Err(_) => list_tables_older_version(pool, _schema).await,
+    }
+}
+
+async fn list_tables_new_version(pool: &Pool, _schema: &str) -> Result<Vec<TableInfo>, String> {
+    let client = pool.get().await.map_err(|e| e.to_string())?;
+
+    let stmt = client.prepare_cached(questdb_tables_sql_new_version()).await.map_err(|e| e.to_string())?;
+    let rows = client.query(&stmt, &[]).await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let table_type_col = row.get::<_, String>(1);
+            let table_type = match table_type_col.as_ref() {
+                "V" => "VIEW",
+                "M" => "MATERIALIZED_VIEW",
+                _ => "TABLE",
+            };
+            TableInfo {
+                name: row.get::<_, String>(0),
+                table_type: table_type.to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            }
+        })
+        .collect())
+}
+
+fn questdb_tables_sql_new_version() -> &'static str {
+    "SELECT table_name, table_type FROM tables"
+}
+
+async fn list_tables_older_version(pool: &Pool, _schema: &str) -> Result<Vec<TableInfo>, String> {
+    let client = pool.get().await.map_err(|e| e.to_string())?;
+
+    let stmt = client.prepare_cached(questdb_tables_sql_older_version()).await.map_err(|e| e.to_string())?;
+    let rows = client.query(&stmt, &[]).await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let mat_view_col = row.get::<_, bool>(1);
+            let table_type = if mat_view_col { "MATERIALIZED_VIEW" } else { "TABLE" };
+            TableInfo {
+                name: row.get::<_, String>(0),
+                table_type: table_type.to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            }
+        })
+        .collect())
+}
+
+fn questdb_tables_sql_older_version() -> &'static str {
+    "SELECT table_name, matView FROM tables"
+}
+
+pub async fn get_columns(pool: &Pool, _schema: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let client = pool.get().await.map_err(|e| e.to_string())?;
+    let sql = format!("SHOW COLUMNS FROM {}", quote_table_identifier(Some(DatabaseType::Questdb), table));
+    let stmt = client.prepare_cached(&sql).await.map_err(|e| e.to_string())?;
+    let rows = client.query(&stmt, &[]).await.map_err(|e| e.to_string())?;
+
+    let not_null_types: [&str; 3] = ["boolean", "byte", "short"];
+
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let column_type = row.get::<_, String>(1);
+            ColumnInfo {
+                name: row.get::<_, String>(0),
+                data_type: column_type.clone().to_lowercase(),
+                is_nullable: !not_null_types.contains(&column_type.as_str()),
+                column_default: None,
+                is_primary_key: column_type.eq_ignore_ascii_case("timestamp")
+                    || column_type.eq_ignore_ascii_case("symbol"),
+                extra: None,
+                comment: None,
+                numeric_precision: None,
+                numeric_scale: None,
+                character_maximum_length: None,
+                enum_values: None,
+                ..Default::default()
+            }
+        })
+        .collect())
+}
+
+pub async fn list_indexes(pool: &Pool, _schema: &str, table: &str) -> Result<Vec<IndexInfo>, String> {
+    let client = pool.get().await.map_err(|e| e.to_string())?;
+    let sql = format!("SHOW COLUMNS FROM {}", quote_table_identifier(Some(DatabaseType::Questdb), table));
+    let stmt = client.prepare_cached(&sql).await.map_err(|e| e.to_string())?;
+    let rows = client.query(&stmt, &[]).await.map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .filter(|r| r.get::<_, bool>(2))
+        .map(|row| {
+            let column: String = row.get::<_, String>(0);
+            let key_cols = vec![column];
+            IndexInfo {
+                name: row.get::<_, String>(0),
+                columns: key_cols,
+                is_unique: false,
+                is_primary: true,
+                filter: None,
+                index_type: None,
+                included_columns: None,
+                comment: None,
+            }
+        })
+        .collect())
+}
+
+pub async fn questdb_object_source(pool: &Pool, name: &str) -> Result<String, String> {
+    questdb_view_ddl(pool, name).await.map_err(|e| e.to_string())
+}
+
+pub async fn questdb_table_or_view_ddl(pool: &Pool, table_or_view: &str) -> Result<String, String> {
+    match questdb_view_ddl(pool, table_or_view).await {
+        Ok(ddl) => Ok(ddl),
+        Err(_) => questdb_table_ddl(pool, table_or_view).await,
+    }
+}
+
+async fn questdb_table_ddl(pool: &Pool, table: &str) -> Result<String, String> {
+    let sql = format!("SHOW CREATE TABLE {}", quote_table_identifier(Some(DatabaseType::Questdb), table));
+    first_string_cell(db::postgres::execute_query(pool, &sql).await?)
+}
+
+async fn questdb_view_ddl(pool: &Pool, view: &str) -> Result<String, String> {
+    match questdb_mat_view_ddl(pool, view).await {
+        Ok(ddl) => Ok(ddl),
+        Err(_) => questdb_normal_view_ddl(pool, view).await,
+    }
+}
+
+async fn questdb_mat_view_ddl(pool: &Pool, view: &str) -> Result<String, String> {
+    let sql = format!("SHOW CREATE MATERIALIZED VIEW {}", quote_table_identifier(Some(DatabaseType::Questdb), view));
+    first_string_cell(db::postgres::execute_query(pool, &sql).await?)
+}
+
+async fn questdb_normal_view_ddl(pool: &Pool, view: &str) -> Result<String, String> {
+    let sql = format!("SHOW CREATE VIEW {}", quote_table_identifier(Some(DatabaseType::Questdb), view));
+    first_string_cell(db::postgres::execute_query(pool, &sql).await?)
+}
+
+fn first_string_cell(result: QueryResult) -> Result<String, String> {
+    result
+        .rows
+        .first()
+        .and_then(|row| row.iter().find_map(|value| value.as_str().map(str::to_string)))
+        .filter(|value| !value.trim().is_empty())
+        .ok_or_else(|| "Object source not found".to_string())
+}
diff --git a/crates/dbx-core/src/db/redis_driver.rs b/crates/dbx-core/src/db/redis_driver.rs
new file mode 100644
index 0000000..9d459e2
--- /dev/null
+++ b/crates/dbx-core/src/db/redis_driver.rs
@@ -0,0 +1,3213 @@
+use crate::models::connection::ConnectionConfig;
+use base64::Engine;
+use redis::{
+    aio::ConnectionLike,
+    cluster::ClusterClient,
+    cluster_async::ClusterConnection,
+    sentinel::{Sentinel, SentinelNodeConnectionInfo},
+    Cmd, ConnectionAddr, ConnectionInfo, FromRedisValue, Pipeline, ProtocolVersion, RedisConnectionInfo, RedisFuture,
+    TlsMode, Value as RedisRawValue,
+};
+use serde::{Deserialize, Serialize};
+use tokio::sync::{Mutex, MutexGuard};
+
+use super::json_value_for_js;
+
+const STREAM_ENTRY_LIMIT: usize = 100;
+const COLLECTION_PAGE_SIZE: usize = 200;
+const HASH_FILTER_SCAN_MAX_ITERATIONS: usize = 10;
+const DEFAULT_REDIS_DATABASES: u32 = 16;
+const CLUSTER_CURSOR_NODE_BITS: u64 = 16;
+const CLUSTER_CURSOR_NODE_MASK: u64 = (1 << CLUSTER_CURSOR_NODE_BITS) - 1;
+const CLUSTER_CURSOR_SCAN_MASK: u64 = (1 << (64 - CLUSTER_CURSOR_NODE_BITS)) - 1;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RedisDatabaseInfo {
+    pub db: u32,
+    pub keys: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RedisKeyInfo {
+    pub key_display: String,
+    pub key_raw: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub key_type: String,
+    #[serde(default = "default_missing_ttl", skip_serializing_if = "is_missing_ttl")]
+    pub ttl: i64,
+    #[serde(default, skip_serializing_if = "is_zero_u64")]
+    pub size: u64,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub value_preview: String,
+}
+
+fn default_missing_ttl() -> i64 {
+    -2
+}
+
+fn is_missing_ttl(ttl: &i64) -> bool {
+    *ttl == -2
+}
+
+fn is_zero_u64(value: &u64) -> bool {
+    *value == 0
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RedisScanResult {
+    pub cursor: u64,
+    pub keys: Vec<RedisKeyInfo>,
+    pub total_keys: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RedisValue {
+    pub key_display: String,
+    pub key_raw: String,
+    pub ttl: i64,
+    pub redis_type: String,
+    pub data: RedisValueData,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum RedisBlobEncoding {
+    Utf8,
+    Binary,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RedisBlob {
+    pub raw_base64: String,
+    pub encoding: RedisBlobEncoding,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RedisListItem {
+    pub index: u64,
+    pub value: RedisBlob,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RedisSetItem {
+    pub member: RedisBlob,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RedisHashItem {
+    pub field: RedisBlob,
+    pub value: RedisBlob,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RedisZsetItem {
+    pub score: String,
+    pub member: RedisBlob,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RedisStreamField {
+    pub field: String,
+    pub value: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct RedisStreamEntry {
+    pub id: String,
+    pub fields: Vec<RedisStreamField>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum RedisValueData {
+    String {
+        content: RedisBlob,
+    },
+    Json {
+        value: serde_json::Value,
+    },
+    List {
+        items: Vec<RedisListItem>,
+        total: u64,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        scan_cursor: Option<u64>,
+    },
+    Set {
+        items: Vec<RedisSetItem>,
+        total: u64,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        scan_cursor: Option<u64>,
+    },
+    Hash {
+        items: Vec<RedisHashItem>,
+        total: u64,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        scan_cursor: Option<u64>,
+    },
+    Zset {
+        items: Vec<RedisZsetItem>,
+        total: u64,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        scan_cursor: Option<u64>,
+    },
+    Stream {
+        entries: Vec<RedisStreamEntry>,
+    },
+    Unknown,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "snake_case")]
+pub enum RedisCollectionPage {
+    List {
+        items: Vec<RedisListItem>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        scan_cursor: Option<u64>,
+    },
+    Set {
+        items: Vec<RedisSetItem>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        scan_cursor: Option<u64>,
+    },
+    Hash {
+        items: Vec<RedisHashItem>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        scan_cursor: Option<u64>,
+    },
+    Zset {
+        items: Vec<RedisZsetItem>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        scan_cursor: Option<u64>,
+    },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum RedisCommandSafety {
+    Allowed,
+    Write,
+    Confirm,
+    Blocked,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RedisCommandResult {
+    pub command: String,
+    pub safety: RedisCommandSafety,
+    pub value: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PubSubMessage {
+    pub channel: String,
+    pub pattern: Option<String>,
+    pub payload: String,
+}
+
+pub enum RedisConnection {
+    Direct(Mutex<redis::aio::MultiplexedConnection>),
+    Cluster(RedisClusterPool),
+}
+
+pub struct RedisClusterPool {
+    pub connection: Option<Mutex<ClusterConnection>>,
+    pub seed_nodes: Vec<RedisNodeEndpoint>,
+    pub seed_routes: Vec<RedisNodeRoute>,
+    pub slot_ranges: Vec<RedisClusterSlotRange>,
+    pub node_routes: Vec<RedisNodeRoute>,
+    pub tls: bool,
+    pub tls_insecure: bool,
+    pub username: String,
+    pub password: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RedisClusterAuth {
+    pub username: String,
+    pub password: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RedisSlowlogEntry {
+    pub id: u64,
+    pub timestamp: i64,
+    pub duration_micros: u64,
+    pub command: String,
+    pub client_addr: Option<String>,
+    pub client_name: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RedisNodeRoute {
+    pub advertised: RedisNodeEndpoint,
+    pub connect: RedisNodeEndpoint,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RedisClusterSlotRange {
+    pub start: u16,
+    pub end: u16,
+    pub master: RedisNodeEndpoint,
+}
+
+pub enum RedisClusterConnectionGuard<'a> {
+    Native(MutexGuard<'a, ClusterConnection>),
+    Direct(redis::aio::MultiplexedConnection),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct RedisAuthCandidate {
+    username: String,
+    password: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct RedisNodeEndpoint {
+    pub host: String,
+    pub port: u16,
+}
+
+impl ConnectionLike for RedisClusterConnectionGuard<'_> {
+    fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, RedisRawValue> {
+        match self {
+            RedisClusterConnectionGuard::Native(con) => con.req_packed_command(cmd),
+            RedisClusterConnectionGuard::Direct(con) => con.req_packed_command(cmd),
+        }
+    }
+
+    fn req_packed_commands<'a>(
+        &'a mut self,
+        cmd: &'a Pipeline,
+        offset: usize,
+        count: usize,
+    ) -> RedisFuture<'a, Vec<RedisRawValue>> {
+        match self {
+            RedisClusterConnectionGuard::Native(con) => con.req_packed_commands(cmd, offset, count),
+            RedisClusterConnectionGuard::Direct(con) => con.req_packed_commands(cmd, offset, count),
+        }
+    }
+
+    fn get_db(&self) -> i64 {
+        match self {
+            RedisClusterConnectionGuard::Native(con) => con.get_db(),
+            RedisClusterConnectionGuard::Direct(con) => con.get_db(),
+        }
+    }
+}
+
+pub async fn connect(url: &str, timeout: std::time::Duration) -> Result<redis::aio::MultiplexedConnection, String> {
+    let client = redis::Client::open(url).map_err(|e| format!("Redis connection failed: {e}"))?;
+    connect_client_with_timeout(client, timeout, "Redis").await
+}
+
+pub async fn connect_standalone(
+    config: &ConnectionConfig,
+    host: &str,
+    port: u16,
+    timeout: std::time::Duration,
+) -> Result<redis::aio::MultiplexedConnection, String> {
+    let mut last_error = None;
+    for auth in redis_auth_candidates(&config.username, &config.password) {
+        let client = redis::Client::open(connection_info(
+            host,
+            port,
+            config.ssl,
+            config.redis_tls_insecure(),
+            &auth.username,
+            &auth.password,
+            redis_database_index(config),
+        ))
+        .map_err(|e| format!("Redis connection failed: {e}"))?;
+        match connect_client_with_timeout(client, timeout, "Redis").await {
+            Ok(con) => return Ok(con),
+            Err(err) if last_error.is_none() || is_redis_auth_error(&err) => {
+                let should_retry = is_redis_auth_error(&err);
+                last_error = Some(err);
+                if !should_retry {
+                    break;
+                }
+            }
+            Err(err) => return Err(err),
+        }
+    }
+    Err(last_error.unwrap_or_else(|| "Redis connection failed".to_string()))
+}
+
+async fn connect_client_with_timeout(
+    client: redis::Client,
+    timeout: std::time::Duration,
+    label: &str,
+) -> Result<redis::aio::MultiplexedConnection, String> {
+    let mut con = tokio::time::timeout(timeout, client.get_multiplexed_async_connection())
+        .await
+        .map_err(|_| format!("{label} connection timed out ({}s)", timeout.as_secs()))?
+        .map_err(|e| format!("{label} connection failed: {e}"))?;
+
+    tokio::time::timeout(timeout, redis::cmd("PING").query_async::<String>(&mut con))
+        .await
+        .map_err(|_| format!("{label} ping timed out ({}s)", timeout.as_secs()))?
+        .map_err(|e| format!("{label} authentication failed or command rejected: {e}"))?;
+
+    Ok(con)
+}
+
+pub async fn connect_sentinel(config: &ConnectionConfig) -> Result<redis::aio::MultiplexedConnection, String> {
+    let service_name = config.redis_sentinel_master.trim();
+    if service_name.is_empty() {
+        return Err("Redis Sentinel master name is required".to_string());
+    }
+
+    let nodes = redis_sentinel_nodes(config)?;
+    let mut sentinel = Sentinel::build(nodes).map_err(|e| format!("Redis Sentinel connection failed: {e}"))?;
+    let node_connection_info = SentinelNodeConnectionInfo {
+        tls_mode: redis_tls_mode(config.ssl, config.redis_tls_insecure()),
+        redis_connection_info: Some(redis_connection_info(&config.username, &config.password, 0)),
+    };
+    let client = tokio::time::timeout(
+        super::connection_timeout(),
+        sentinel.async_master_for(service_name, Some(&node_connection_info)),
+    )
+    .await
+    .map_err(|_| format!("Redis Sentinel lookup timed out ({}s)", super::CONNECTION_TIMEOUT_SECS))?
+    .map_err(|e| format!("Redis Sentinel master lookup failed: {e}"))?;
+
+    connect_client(client).await
+}
+
+pub async fn discover_sentinel_master(
+    config: &ConnectionConfig,
+    host: &str,
+    port: u16,
+) -> Result<RedisNodeEndpoint, String> {
+    let service_name = config.redis_sentinel_master.trim();
+    if service_name.is_empty() {
+        return Err("Redis Sentinel master name is required".to_string());
+    }
+
+    let client = redis::Client::open(connection_info(
+        host,
+        port,
+        config.redis_sentinel_tls,
+        config.redis_tls_insecure(),
+        &config.redis_sentinel_username,
+        &config.redis_sentinel_password,
+        0,
+    ))
+    .map_err(|e| format!("Redis Sentinel connect failed: {e}"))?;
+    let mut con = connect_client_with_timeout(client, super::connection_timeout(), "Redis Sentinel").await?;
+    let raw = tokio::time::timeout(
+        super::connection_timeout(),
+        redis::cmd("SENTINEL").arg("get-master-addr-by-name").arg(service_name).query_async::<RedisRawValue>(&mut con),
+    )
+    .await
+    .map_err(|_| format!("Redis Sentinel master lookup timed out ({}s)", super::CONNECTION_TIMEOUT_SECS))?
+    .map_err(|e| format!("Redis Sentinel master lookup failed: {e}"))?;
+
+    redis_sentinel_master_endpoint(raw)
+}
+
+pub async fn connect_cluster(config: &ConnectionConfig) -> Result<RedisClusterPool, String> {
+    let seed_nodes = redis_cluster_seed_nodes(config)?;
+    let mut last_error = None;
+    for auth in redis_auth_candidates(&config.username, &config.password) {
+        let cluster_nodes: Vec<ConnectionInfo> = seed_nodes
+            .iter()
+            .map(|endpoint| {
+                connection_info(
+                    &endpoint.host,
+                    endpoint.port,
+                    config.ssl,
+                    config.redis_tls_insecure(),
+                    &auth.username,
+                    &auth.password,
+                    0,
+                )
+            })
+            .collect();
+        let client = ClusterClient::new(cluster_nodes).map_err(|e| format!("Redis cluster connection failed: {e}"))?;
+        let mut con = match tokio::time::timeout(super::connection_timeout(), client.get_async_connection())
+            .await
+            .map_err(|_| format!("Redis cluster connection timed out ({}s)", super::CONNECTION_TIMEOUT_SECS))?
+            .map_err(|e| format!("Redis cluster connection failed: {e}"))
+        {
+            Ok(con) => con,
+            Err(err) if last_error.is_none() || is_redis_auth_error(&err) => {
+                let should_retry = is_redis_auth_error(&err);
+                last_error = Some(err);
+                if should_retry {
+                    continue;
+                }
+                break;
+            }
+            Err(err) => return Err(err),
+        };
+
+        match tokio::time::timeout(super::connection_timeout(), redis::cmd("PING").query_async::<String>(&mut con))
+            .await
+            .map_err(|_| format!("Redis cluster ping timed out ({}s)", super::CONNECTION_TIMEOUT_SECS))?
+            .map_err(|e| format!("Redis cluster authentication failed or command rejected: {e}"))
+        {
+            Ok(_) => {
+                let seed_routes = identity_routes(&seed_nodes);
+                let slot_ranges = cluster_slot_ranges_from_routes(
+                    &seed_routes,
+                    config.ssl,
+                    config.redis_tls_insecure(),
+                    &auth.username,
+                    &auth.password,
+                )
+                .await
+                .unwrap_or_default();
+                let node_routes = identity_routes(&unique_master_nodes(&slot_ranges));
+                return Ok(RedisClusterPool {
+                    connection: Some(Mutex::new(con)),
+                    seed_nodes,
+                    seed_routes,
+                    slot_ranges,
+                    node_routes,
+                    tls: config.ssl,
+                    tls_insecure: config.redis_tls_insecure(),
+                    username: auth.username,
+                    password: auth.password,
+                });
+            }
+            Err(err) if last_error.is_none() || is_redis_auth_error(&err) => {
+                let should_retry = is_redis_auth_error(&err);
+                last_error = Some(err);
+                if !should_retry {
+                    break;
+                }
+            }
+            Err(err) => return Err(err),
+        }
+    }
+    Err(last_error.unwrap_or_else(|| "Redis cluster connection failed".to_string()))
+}
+
+pub async fn discover_cluster_slot_ranges_from_routes(
+    config: &ConnectionConfig,
+    seed_routes: &[RedisNodeRoute],
+) -> Result<(RedisClusterAuth, Vec<RedisClusterSlotRange>), String> {
+    let mut last_error = None;
+    for auth in redis_auth_candidates(&config.username, &config.password) {
+        match cluster_slot_ranges_from_routes(
+            seed_routes,
+            config.ssl,
+            config.redis_tls_insecure(),
+            &auth.username,
+            &auth.password,
+        )
+        .await
+        {
+            Ok(slot_ranges) if !slot_ranges.is_empty() => {
+                return Ok((RedisClusterAuth { username: auth.username, password: auth.password }, slot_ranges));
+            }
+            Ok(_) => {
+                last_error = Some("Redis cluster master discovery returned no slots".to_string());
+            }
+            Err(err) if last_error.is_none() || is_redis_auth_error(&err) => {
+                let should_retry = is_redis_auth_error(&err);
+                last_error = Some(err);
+                if !should_retry {
+                    break;
+                }
+            }
+            Err(err) => return Err(err),
+        }
+    }
+    Err(last_error.unwrap_or_else(|| "Redis cluster master discovery failed".to_string()))
+}
+
+pub async fn connect_routed_cluster(
+    config: &ConnectionConfig,
+    seed_routes: Vec<RedisNodeRoute>,
+    slot_ranges: Vec<RedisClusterSlotRange>,
+    node_routes: Vec<RedisNodeRoute>,
+    auth: RedisClusterAuth,
+) -> Result<RedisClusterPool, String> {
+    let seed_nodes = redis_cluster_seed_nodes(config)?;
+    let mut pool = RedisClusterPool {
+        connection: None,
+        seed_nodes,
+        seed_routes,
+        slot_ranges,
+        node_routes,
+        tls: config.ssl,
+        tls_insecure: config.redis_tls_insecure(),
+        username: auth.username,
+        password: auth.password,
+    };
+    if pool.node_routes.is_empty() {
+        pool.node_routes = identity_routes(&unique_master_nodes(&pool.slot_ranges));
+    }
+    {
+        let mut con = cluster_any_connection(&pool).await?;
+        redis_ping(&mut con, "Redis cluster").await?;
+    }
+    Ok(pool)
+}
+
+pub async fn test_connection(connection: &RedisConnection) -> Result<(), String> {
+    match connection {
+        RedisConnection::Direct(con) => {
+            let mut con = con.lock().await;
+            redis_ping(&mut *con, "Redis").await
+        }
+        RedisConnection::Cluster(cluster) => {
+            let mut con = cluster_any_connection(cluster).await?;
+            redis_ping(&mut con, "Redis cluster").await
+        }
+    }
+}
+
+async fn redis_ping<C>(con: &mut C, label: &str) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    tokio::time::timeout(super::connection_timeout(), redis::cmd("PING").query_async::<String>(con))
+        .await
+        .map_err(|_| format!("{label} ping timed out ({}s)", super::CONNECTION_TIMEOUT_SECS))?
+        .map(|_| ())
+        .map_err(|e| format!("{label} ping failed: {e}"))
+}
+
+fn redis_sentinel_nodes(config: &ConnectionConfig) -> Result<Vec<ConnectionInfo>, String> {
+    redis_sentinel_node_endpoints(config)?
+        .iter()
+        .map(|endpoint| {
+            Ok(connection_info(
+                &endpoint.host,
+                endpoint.port,
+                config.redis_sentinel_tls,
+                config.redis_tls_insecure(),
+                &config.redis_sentinel_username,
+                &config.redis_sentinel_password,
+                0,
+            ))
+        })
+        .collect()
+}
+
+pub fn redis_sentinel_node_endpoints(config: &ConnectionConfig) -> Result<Vec<RedisNodeEndpoint>, String> {
+    redis_node_endpoints(
+        config.redis_sentinel_nodes.trim(),
+        config.host.trim(),
+        config.port,
+        "Redis Sentinel node",
+        26379,
+    )
+}
+
+pub fn redis_cluster_seed_nodes(config: &ConnectionConfig) -> Result<Vec<RedisNodeEndpoint>, String> {
+    redis_node_endpoints(
+        config.redis_cluster_nodes.trim(),
+        config.host.trim(),
+        config.port,
+        "Redis cluster seed node",
+        6379,
+    )
+}
+
+fn redis_node_endpoints(
+    raw_nodes: &str,
+    fallback_host: &str,
+    fallback_port: u16,
+    label: &str,
+    default_port: u16,
+) -> Result<Vec<RedisNodeEndpoint>, String> {
+    let endpoints: Vec<String> = if raw_nodes.is_empty() {
+        vec![format!("{fallback_host}:{}", if fallback_port == 0 { default_port } else { fallback_port })]
+    } else {
+        raw_nodes
+            .split([',', ';', '\n', '\r'])
+            .map(str::trim)
+            .filter(|node| !node.is_empty())
+            .map(ToOwned::to_owned)
+            .collect()
+    };
+
+    if endpoints.is_empty() {
+        return Err(format!("At least one {label} is required"));
+    }
+
+    endpoints
+        .iter()
+        .map(|endpoint| {
+            let (host, port) = parse_redis_endpoint(endpoint, default_port)?;
+            Ok(RedisNodeEndpoint { host, port })
+        })
+        .collect()
+}
+
+fn redis_sentinel_master_endpoint(value: RedisRawValue) -> Result<RedisNodeEndpoint, String> {
+    let RedisRawValue::Array(parts) = value else {
+        return Err("Redis Sentinel master lookup returned an invalid response".to_string());
+    };
+    if parts.len() != 2 {
+        return Err("Redis Sentinel master lookup returned an invalid endpoint".to_string());
+    }
+    let Some(host) = redis_value_to_string(parts[0].clone()) else {
+        return Err("Redis Sentinel master lookup returned an invalid host".to_string());
+    };
+    let Some(port_text) = redis_value_to_string(parts[1].clone()) else {
+        return Err("Redis Sentinel master lookup returned an invalid port".to_string());
+    };
+    let port = parse_redis_port(&port_text)?;
+    Ok(RedisNodeEndpoint { host, port })
+}
+
+fn connection_info(
+    host: &str,
+    port: u16,
+    tls: bool,
+    insecure: bool,
+    username: &str,
+    password: &str,
+    db: i64,
+) -> ConnectionInfo {
+    let addr = if tls {
+        ConnectionAddr::TcpTls { host: host.to_string(), port, insecure, tls_params: None }
+    } else {
+        ConnectionAddr::Tcp(host.to_string(), port)
+    };
+    ConnectionInfo { addr, redis: redis_connection_info(username, password, db) }
+}
+
+fn redis_tls_mode(tls: bool, insecure: bool) -> Option<TlsMode> {
+    if !tls {
+        None
+    } else if insecure {
+        Some(TlsMode::Insecure)
+    } else {
+        Some(TlsMode::Secure)
+    }
+}
+
+fn redis_connection_info(username: &str, password: &str, db: i64) -> RedisConnectionInfo {
+    RedisConnectionInfo {
+        db,
+        username: non_empty_string(username),
+        password: non_empty_string(password),
+        protocol: ProtocolVersion::RESP2,
+    }
+}
+
+fn redis_auth_candidates(username: &str, password: &str) -> Vec<RedisAuthCandidate> {
+    let username = username.trim();
+    let password = password.trim();
+    let mut candidates = vec![RedisAuthCandidate { username: username.to_string(), password: password.to_string() }];
+    if !username.is_empty() && !password.is_empty() {
+        candidates.push(RedisAuthCandidate { username: String::new(), password: format!("{username}@{password}") });
+    }
+    candidates
+}
+
+fn redis_database_index(config: &ConnectionConfig) -> i64 {
+    config.effective_database().and_then(|database| database.parse::<i64>().ok()).unwrap_or(0)
+}
+
+fn is_redis_auth_error(error: &str) -> bool {
+    let error = error.to_ascii_lowercase();
+    error.contains("auth") || error.contains("wrongpass") || error.contains("invalid username-password")
+}
+
+fn non_empty_string(value: &str) -> Option<String> {
+    let value = value.trim();
+    if value.is_empty() {
+        None
+    } else {
+        Some(value.to_string())
+    }
+}
+
+fn parse_redis_endpoint(endpoint: &str, default_port: u16) -> Result<(String, u16), String> {
+    let endpoint = endpoint.trim();
+    if endpoint.is_empty() {
+        return Err("Redis node cannot be empty".to_string());
+    }
+    let endpoint = endpoint.strip_prefix("redis://").or_else(|| endpoint.strip_prefix("rediss://")).unwrap_or(endpoint);
+    let endpoint = endpoint.rsplit_once('@').map(|(_, tail)| tail).unwrap_or(endpoint);
+    let endpoint = endpoint.split(['/', '?', '#']).next().unwrap_or(endpoint);
+
+    if let Some(rest) = endpoint.strip_prefix('[') {
+        let Some((host, tail)) = rest.split_once(']') else {
+            return Err(format!("Invalid Redis node '{endpoint}'"));
+        };
+        let port = tail.strip_prefix(':').filter(|value| !value.is_empty()).map(parse_redis_port).transpose()?;
+        return Ok((host.to_string(), port.unwrap_or(default_port)));
+    }
+
+    if let Some((host, port)) = endpoint.rsplit_once(':') {
+        if !host.contains(':') && port.chars().all(|ch| ch.is_ascii_digit()) {
+            return Ok((host.to_string(), parse_redis_port(port)?));
+        }
+    }
+
+    Ok((endpoint.to_string(), default_port))
+}
+
+fn parse_redis_port(port: &str) -> Result<u16, String> {
+    port.parse::<u16>().map_err(|_| format!("Invalid Redis port '{port}'"))
+}
+
+async fn connect_client(client: redis::Client) -> Result<redis::aio::MultiplexedConnection, String> {
+    let mut con = tokio::time::timeout(super::connection_timeout(), client.get_multiplexed_async_connection())
+        .await
+        .map_err(|_| format!("Redis connection timed out ({}s)", super::CONNECTION_TIMEOUT_SECS))?
+        .map_err(|e| format!("Redis connection failed: {e}"))?;
+
+    tokio::time::timeout(super::connection_timeout(), redis::cmd("PING").query_async::<String>(&mut con))
+        .await
+        .map_err(|_| format!("Redis ping timed out ({}s)", super::CONNECTION_TIMEOUT_SECS))?
+        .map_err(|e| format!("Redis authentication failed or command rejected: {e}"))?;
+
+    Ok(con)
+}
+
+pub async fn connect_direct_node(
+    endpoint: &RedisNodeEndpoint,
+    tls: bool,
+    insecure: bool,
+    username: &str,
+    password: &str,
+) -> Result<redis::aio::MultiplexedConnection, String> {
+    let client =
+        redis::Client::open(connection_info(&endpoint.host, endpoint.port, tls, insecure, username, password, 0))
+            .map_err(|e| format!("Redis connection failed: {e}"))?;
+    connect_client(client).await
+}
+
+pub async fn connect_pubsub(
+    config: &ConnectionConfig,
+    host: &str,
+    port: u16,
+    timeout: std::time::Duration,
+) -> Result<redis::aio::PubSub, String> {
+    let mut last_error = None;
+    for auth in redis_auth_candidates(&config.username, &config.password) {
+        let client = redis::Client::open(connection_info(
+            host,
+            port,
+            config.ssl,
+            config.redis_tls_insecure(),
+            &auth.username,
+            &auth.password,
+            redis_database_index(config),
+        ))
+        .map_err(|e| format!("Redis connection failed: {e}"))?;
+        match tokio::time::timeout(timeout, client.get_async_pubsub()).await {
+            Ok(Ok(pubsub)) => return Ok(pubsub),
+            Ok(Err(err)) => {
+                let err_str = err.to_string();
+                if last_error.is_none() || is_redis_auth_error(&err_str) {
+                    let should_retry = is_redis_auth_error(&err_str);
+                    last_error = Some(err_str);
+                    if !should_retry {
+                        break;
+                    }
+                } else {
+                    return Err(err_str);
+                }
+            }
+            Err(_) => {
+                last_error = Some(format!("Redis PubSub connection timed out ({}s)", timeout.as_secs()));
+                break;
+            }
+        }
+    }
+    Err(last_error.unwrap_or_else(|| "Redis PubSub connection failed".to_string()))
+}
+
+pub async fn publish_message<C>(con: &mut C, channel: &str, message: &str) -> Result<u64, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("PUBLISH").arg(channel).arg(message).query_async(con).await.map_err(|e| e.to_string())
+}
+
+pub async fn list_databases<C>(con: &mut C) -> Result<Vec<RedisDatabaseInfo>, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let configured_count =
+        redis::cmd("CONFIG").arg("GET").arg("databases").query_async(con).await.ok().and_then(parse_database_count);
+
+    let keyspace_dbs = list_keyspace_databases(con).await.unwrap_or_default();
+    let database_count = configured_count.unwrap_or(DEFAULT_REDIS_DATABASES);
+    let max_db = keyspace_dbs.iter().map(|db| db.db).max().map(|db| db + 1).unwrap_or(0);
+    let visible_count = database_count.max(max_db).max(1);
+    let keyspace_counts =
+        keyspace_dbs.into_iter().map(|db| (db.db, db.keys)).collect::<std::collections::HashMap<_, _>>();
+
+    Ok((0..visible_count)
+        .map(|db| RedisDatabaseInfo { db, keys: keyspace_counts.get(&db).copied().unwrap_or(0) })
+        .collect())
+}
+
+fn parse_database_count(value: redis::Value) -> Option<u32> {
+    let values = match value {
+        redis::Value::Array(values) => values,
+        _ => return None,
+    };
+
+    values.windows(2).find_map(|pair| {
+        let key = String::from_redis_value(&pair[0]).ok()?;
+        if key.eq_ignore_ascii_case("databases") {
+            String::from_redis_value(&pair[1]).ok()?.parse().ok()
+        } else {
+            None
+        }
+    })
+}
+
+async fn list_keyspace_databases<C>(con: &mut C) -> Result<Vec<RedisDatabaseInfo>, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let info: String = redis::cmd("INFO").arg("keyspace").query_async(con).await.map_err(|e| e.to_string())?;
+
+    let mut dbs = Vec::new();
+    for line in info.lines() {
+        if line.starts_with("db") {
+            if let Some((db_part, stats_part)) = line.split_once(':') {
+                if let Some(num) = db_part.strip_prefix("db") {
+                    if let Ok(db) = num.parse::<u32>() {
+                        let keys = stats_part
+                            .split(',')
+                            .find_map(|part| part.strip_prefix("keys=").and_then(|value| value.parse::<u64>().ok()))
+                            .unwrap_or(0);
+                        dbs.push(RedisDatabaseInfo { db, keys });
+                    }
+                }
+            }
+        }
+    }
+    Ok(dbs)
+}
+
+pub async fn select_db<C>(con: &mut C, db: u32) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("SELECT").arg(db).query_async(con).await.map_err(|e| e.to_string())
+}
+
+pub fn ensure_cluster_db(db: u32) -> Result<(), String> {
+    if db == 0 {
+        Ok(())
+    } else {
+        Err("Redis Cluster only supports db0".to_string())
+    }
+}
+
+pub fn encode_cluster_cursor(node_index: usize, cursor: u64) -> Result<u64, String> {
+    if node_index > CLUSTER_CURSOR_NODE_MASK as usize {
+        return Err("Redis cluster cursor exceeded node limit".to_string());
+    }
+    if cursor > CLUSTER_CURSOR_SCAN_MASK {
+        return Err("Redis cluster cursor exceeded scan limit".to_string());
+    }
+    Ok(((node_index as u64) << (64 - CLUSTER_CURSOR_NODE_BITS)) | (cursor & CLUSTER_CURSOR_SCAN_MASK))
+}
+
+pub fn decode_cluster_cursor(cursor: u64) -> (usize, u64) {
+    if cursor == 0 {
+        return (0, 0);
+    }
+    let node_index = (cursor >> (64 - CLUSTER_CURSOR_NODE_BITS)) as usize;
+    let node_cursor = cursor & CLUSTER_CURSOR_SCAN_MASK;
+    (node_index, node_cursor)
+}
+
+pub async fn list_cluster_databases(pool: &RedisClusterPool) -> Result<Vec<RedisDatabaseInfo>, String> {
+    let master_nodes = cluster_master_nodes(pool).await?;
+    let keys = cluster_total_keys(pool, &master_nodes).await;
+    Ok(vec![RedisDatabaseInfo { db: 0, keys }])
+}
+
+pub async fn scan_cluster_keys_page(
+    pool: &RedisClusterPool,
+    cursor: u64,
+    pattern: &str,
+    count: usize,
+) -> Result<RedisScanResult, String> {
+    scan_cluster_keys_page_with_options(pool, cursor, pattern, count, true).await
+}
+
+pub async fn scan_cluster_keys_page_with_options(
+    pool: &RedisClusterPool,
+    cursor: u64,
+    pattern: &str,
+    count: usize,
+    include_types: bool,
+) -> Result<RedisScanResult, String> {
+    let master_nodes = cluster_master_nodes(pool).await?;
+    if master_nodes.is_empty() {
+        return Ok(RedisScanResult { cursor: 0, keys: Vec::new(), total_keys: 0 });
+    }
+
+    let (mut node_index, node_cursor) = decode_cluster_cursor(cursor);
+    if node_index >= master_nodes.len() {
+        node_index = 0;
+    }
+
+    let total_keys = cluster_total_keys(pool, &master_nodes).await;
+    for index in node_index..master_nodes.len() {
+        let endpoint = &master_nodes[index];
+        let mut con = connect_cluster_node(pool, endpoint).await?;
+        let current_cursor = if index == node_index { node_cursor } else { 0 };
+        let result = scan_keys_page_with_options(&mut con, current_cursor, pattern, count, include_types).await?;
+        if !result.keys.is_empty() {
+            let next_cursor = if result.cursor != 0 {
+                encode_cluster_cursor(index, result.cursor)?
+            } else if index + 1 < master_nodes.len() {
+                encode_cluster_cursor(index + 1, 0)?
+            } else {
+                0
+            };
+            return Ok(RedisScanResult { cursor: next_cursor, keys: result.keys, total_keys });
+        }
+        if result.cursor != 0 {
+            return Ok(RedisScanResult {
+                cursor: encode_cluster_cursor(index, result.cursor)?,
+                keys: Vec::new(),
+                total_keys,
+            });
+        }
+    }
+
+    Ok(RedisScanResult { cursor: 0, keys: Vec::new(), total_keys })
+}
+
+pub async fn scan_cluster_values_page(
+    pool: &RedisClusterPool,
+    cursor: u64,
+    pattern: &str,
+    query: &str,
+    include_key_matches: bool,
+    count: usize,
+) -> Result<RedisScanResult, String> {
+    let master_nodes = cluster_master_nodes(pool).await?;
+    if master_nodes.is_empty() {
+        return Ok(RedisScanResult { cursor: 0, keys: Vec::new(), total_keys: 0 });
+    }
+
+    let (mut node_index, node_cursor) = decode_cluster_cursor(cursor);
+    if node_index >= master_nodes.len() {
+        node_index = 0;
+    }
+
+    let total_keys = cluster_total_keys(pool, &master_nodes).await;
+    for index in node_index..master_nodes.len() {
+        let endpoint = &master_nodes[index];
+        let mut con = connect_cluster_node(pool, endpoint).await?;
+        let current_cursor = if index == node_index { node_cursor } else { 0 };
+        let result = scan_values_page(&mut con, current_cursor, pattern, query, include_key_matches, count).await?;
+        if !result.keys.is_empty() {
+            let next_cursor = if result.cursor != 0 {
+                encode_cluster_cursor(index, result.cursor)?
+            } else if index + 1 < master_nodes.len() {
+                encode_cluster_cursor(index + 1, 0)?
+            } else {
+                0
+            };
+            return Ok(RedisScanResult { cursor: next_cursor, keys: result.keys, total_keys });
+        }
+        if result.cursor != 0 {
+            return Ok(RedisScanResult {
+                cursor: encode_cluster_cursor(index, result.cursor)?,
+                keys: Vec::new(),
+                total_keys,
+            });
+        }
+    }
+
+    Ok(RedisScanResult { cursor: 0, keys: Vec::new(), total_keys })
+}
+
+pub async fn cluster_master_nodes(pool: &RedisClusterPool) -> Result<Vec<RedisNodeEndpoint>, String> {
+    if !pool.seed_routes.is_empty() {
+        return cluster_slot_ranges_from_routes(
+            &pool.seed_routes,
+            pool.tls,
+            pool.tls_insecure,
+            &pool.username,
+            &pool.password,
+        )
+        .await
+        .map(|slot_ranges| unique_master_nodes(&slot_ranges));
+    }
+    cluster_slot_ranges_from_seeds(&pool.seed_nodes, pool.tls, pool.tls_insecure, &pool.username, &pool.password)
+        .await
+        .map(|slot_ranges| unique_master_nodes(&slot_ranges))
+}
+
+pub async fn flush_cluster(pool: &RedisClusterPool) -> Result<(), String> {
+    let master_nodes = cluster_master_nodes(pool).await?;
+    for endpoint in master_nodes {
+        let mut con = connect_cluster_node(pool, &endpoint).await?;
+        flush_db(&mut con).await?;
+    }
+    Ok(())
+}
+
+async fn cluster_total_keys(pool: &RedisClusterPool, master_nodes: &[RedisNodeEndpoint]) -> u64 {
+    let mut total = 0;
+    for endpoint in master_nodes {
+        let Ok(mut con) = connect_cluster_node(pool, endpoint).await else {
+            continue;
+        };
+        total += redis::cmd("DBSIZE").query_async::<u64>(&mut con).await.unwrap_or(0);
+    }
+    total
+}
+
+async fn cluster_slot_ranges_from_seeds(
+    seed_nodes: &[RedisNodeEndpoint],
+    tls: bool,
+    insecure: bool,
+    username: &str,
+    password: &str,
+) -> Result<Vec<RedisClusterSlotRange>, String> {
+    let seed_routes = identity_routes(seed_nodes);
+    cluster_slot_ranges_from_routes(&seed_routes, tls, insecure, username, password).await
+}
+
+async fn cluster_slot_ranges_from_routes(
+    seed_routes: &[RedisNodeRoute],
+    tls: bool,
+    insecure: bool,
+    username: &str,
+    password: &str,
+) -> Result<Vec<RedisClusterSlotRange>, String> {
+    let mut last_error = None;
+    for route in seed_routes {
+        let mut con = match connect_direct_node(&route.connect, tls, insecure, username, password).await {
+            Ok(con) => con,
+            Err(err) => {
+                last_error = Some(err);
+                continue;
+            }
+        };
+        let raw: RedisRawValue = match redis::cmd("CLUSTER").arg("SLOTS").query_async(&mut con).await {
+            Ok(raw) => raw,
+            Err(err) => {
+                last_error = Some(err.to_string());
+                continue;
+            }
+        };
+        let slot_ranges = parse_cluster_slots(raw, &route.advertised.host)?;
+        if !slot_ranges.is_empty() {
+            return Ok(slot_ranges);
+        }
+    }
+
+    Err(last_error.unwrap_or_else(|| "Redis cluster master discovery failed".to_string()))
+}
+
+fn parse_cluster_slots(raw: RedisRawValue, fallback_host: &str) -> Result<Vec<RedisClusterSlotRange>, String> {
+    let RedisRawValue::Array(slots) = raw else {
+        return Err("Invalid Redis CLUSTER SLOTS response".to_string());
+    };
+
+    let mut slot_ranges = Vec::new();
+    for slot in slots {
+        let RedisRawValue::Array(parts) = slot else {
+            continue;
+        };
+        if parts.len() < 3 {
+            continue;
+        }
+        let Some(start_text) = redis_value_to_string(parts[0].clone()) else {
+            return Err("Invalid Redis cluster slot start".to_string());
+        };
+        let Some(end_text) = redis_value_to_string(parts[1].clone()) else {
+            return Err("Invalid Redis cluster slot end".to_string());
+        };
+        let start = parse_cluster_slot_number(&start_text)?;
+        let end = parse_cluster_slot_number(&end_text)?;
+        let Some(endpoint) = parse_cluster_slot_master(parts[2].clone(), fallback_host)? else {
+            continue;
+        };
+        slot_ranges.push(RedisClusterSlotRange { start, end, master: endpoint });
+    }
+    Ok(slot_ranges)
+}
+
+fn parse_cluster_slot_master(value: RedisRawValue, fallback_host: &str) -> Result<Option<RedisNodeEndpoint>, String> {
+    let RedisRawValue::Array(parts) = value else {
+        return Ok(None);
+    };
+    if parts.len() < 2 {
+        return Ok(None);
+    }
+    let host = match &parts[0] {
+        RedisRawValue::Nil => fallback_host.to_string(),
+        other => redis_value_to_string(other.clone()).unwrap_or_else(|| fallback_host.to_string()),
+    };
+    if host.trim().is_empty() {
+        return Ok(None);
+    }
+    let Some(port_text) = redis_value_to_string(parts[1].clone()) else {
+        return Err("Invalid Redis cluster node port".to_string());
+    };
+    let port = parse_redis_port(&port_text)?;
+    Ok(Some(RedisNodeEndpoint { host, port }))
+}
+
+fn parse_cluster_slot_number(value: &str) -> Result<u16, String> {
+    let slot = value.parse::<u16>().map_err(|_| format!("Invalid Redis cluster slot '{value}'"))?;
+    if slot > 16_383 {
+        return Err(format!("Invalid Redis cluster slot '{value}'"));
+    }
+    Ok(slot)
+}
+
+fn identity_routes(endpoints: &[RedisNodeEndpoint]) -> Vec<RedisNodeRoute> {
+    endpoints
+        .iter()
+        .cloned()
+        .map(|endpoint| RedisNodeRoute { advertised: endpoint.clone(), connect: endpoint })
+        .collect()
+}
+
+pub fn unique_master_nodes(slot_ranges: &[RedisClusterSlotRange]) -> Vec<RedisNodeEndpoint> {
+    let mut seen = std::collections::HashSet::new();
+    let mut nodes = Vec::new();
+    for slot_range in slot_ranges {
+        if seen.insert((slot_range.master.host.clone(), slot_range.master.port)) {
+            nodes.push(slot_range.master.clone());
+        }
+    }
+    nodes
+}
+
+pub async fn cluster_any_connection(pool: &RedisClusterPool) -> Result<RedisClusterConnectionGuard<'_>, String> {
+    if let Some(connection) = &pool.connection {
+        return Ok(RedisClusterConnectionGuard::Native(connection.lock().await));
+    }
+    let endpoint = pool
+        .node_routes
+        .first()
+        .or_else(|| pool.seed_routes.first())
+        .map(|route| &route.advertised)
+        .ok_or_else(|| "Redis cluster has no routable nodes".to_string())?;
+    connect_cluster_node(pool, endpoint).await.map(RedisClusterConnectionGuard::Direct)
+}
+
+pub async fn cluster_key_connection<'a>(
+    pool: &'a RedisClusterPool,
+    key: &[u8],
+) -> Result<RedisClusterConnectionGuard<'a>, String> {
+    if let Some(connection) = &pool.connection {
+        return Ok(RedisClusterConnectionGuard::Native(connection.lock().await));
+    }
+    let endpoint = cluster_master_for_key(pool, key)?;
+    connect_cluster_node(pool, &endpoint).await.map(RedisClusterConnectionGuard::Direct)
+}
+
+pub async fn connect_cluster_node(
+    pool: &RedisClusterPool,
+    advertised_endpoint: &RedisNodeEndpoint,
+) -> Result<redis::aio::MultiplexedConnection, String> {
+    let connect_endpoint = mapped_cluster_endpoint(pool, advertised_endpoint);
+    connect_direct_node(&connect_endpoint, pool.tls, pool.tls_insecure, &pool.username, &pool.password).await
+}
+
+fn mapped_cluster_endpoint(pool: &RedisClusterPool, advertised_endpoint: &RedisNodeEndpoint) -> RedisNodeEndpoint {
+    pool.node_routes
+        .iter()
+        .chain(pool.seed_routes.iter())
+        .find(|route| route.advertised == *advertised_endpoint)
+        .map(|route| route.connect.clone())
+        .unwrap_or_else(|| advertised_endpoint.clone())
+}
+
+fn cluster_master_for_key(pool: &RedisClusterPool, key: &[u8]) -> Result<RedisNodeEndpoint, String> {
+    let slot = redis_cluster_slot(key);
+    pool.slot_ranges
+        .iter()
+        .find(|range| range.start <= slot && slot <= range.end)
+        .map(|range| range.master.clone())
+        .ok_or_else(|| format!("Redis cluster slot {slot} has no known master"))
+}
+
+fn redis_cluster_slot(key: &[u8]) -> u16 {
+    let hashtag = key.iter().position(|byte| *byte == b'{').and_then(|start| {
+        key[start + 1..].iter().position(|byte| *byte == b'}').and_then(|relative_end| {
+            if relative_end == 0 {
+                None
+            } else {
+                Some(&key[start + 1..start + 1 + relative_end])
+            }
+        })
+    });
+    crc16_xmodem(hashtag.unwrap_or(key)) % 16_384
+}
+
+fn crc16_xmodem(bytes: &[u8]) -> u16 {
+    let mut crc = 0_u16;
+    for byte in bytes {
+        crc ^= (*byte as u16) << 8;
+        for _ in 0..8 {
+            if (crc & 0x8000) != 0 {
+                crc = (crc << 1) ^ 0x1021;
+            } else {
+                crc <<= 1;
+            }
+        }
+    }
+    crc
+}
+
+pub fn parse_command_argv(command_text: &str) -> Result<Vec<String>, String> {
+    // Strip trailing semicolons so commands like "HGETALL aaa;" work naturally
+    let command_text = command_text.trim_end().trim_end_matches(';');
+    let mut argv = Vec::new();
+    let mut current = String::new();
+    let mut chars = command_text.chars().peekable();
+    let mut quote: Option<char> = None;
+    let mut escaping = false;
+
+    while let Some(ch) = chars.next() {
+        if escaping {
+            current.push(match ch {
+                'n' => '\n',
+                'r' => '\r',
+                't' => '\t',
+                other => other,
+            });
+            escaping = false;
+            continue;
+        }
+
+        if ch == '\\' {
+            escaping = true;
+            continue;
+        }
+
+        if let Some(q) = quote {
+            if ch == q {
+                quote = None;
+            } else {
+                current.push(ch);
+            }
+            continue;
+        }
+
+        if ch == '"' || ch == '\'' {
+            quote = Some(ch);
+            continue;
+        }
+
+        if ch.is_whitespace() {
+            if !current.is_empty() {
+                argv.push(std::mem::take(&mut current));
+            }
+            while matches!(chars.peek(), Some(next) if next.is_whitespace()) {
+                chars.next();
+            }
+            continue;
+        }
+
+        current.push(ch);
+    }
+
+    if escaping {
+        current.push('\\');
+    }
+    if quote.is_some() {
+        return Err("Redis command has an unterminated quote".to_string());
+    }
+    if !current.is_empty() {
+        argv.push(current);
+    }
+    if argv.is_empty() {
+        return Err("Redis command is empty".to_string());
+    }
+    Ok(argv)
+}
+
+pub fn classify_command(command: &str) -> RedisCommandSafety {
+    match command.to_ascii_uppercase().as_str() {
+        "KEYS" | "FLUSHALL" | "SHUTDOWN" | "CONFIG" | "SAVE" | "BGSAVE" | "SLAVEOF" | "REPLICAOF" | "MIGRATE"
+        | "MODULE" | "SCRIPT" | "EVAL" | "EVALSHA" => RedisCommandSafety::Blocked,
+        "DEL" | "UNLINK" | "EXPIRE" | "EXPIREAT" | "PEXPIRE" | "PEXPIREAT" | "RENAME" | "RENAMENX" | "GETDEL"
+        | "HDEL" | "LPOP" | "RPOP" | "LREM" | "LTRIM" | "SPOP" | "SREM" | "ZREM" | "ZPOPMAX" | "ZPOPMIN" | "ZMPOP"
+        | "ZREMRANGEBYLEX" | "ZREMRANGEBYRANK" | "ZREMRANGEBYSCORE" | "XDEL" | "XTRIM" | "MOVE" | "SORT"
+        | "SDIFFSTORE" | "SINTERSTORE" | "SUNIONSTORE" | "ZDIFFSTORE" | "ZINTERSTORE" | "ZRANGESTORE"
+        | "ZUNIONSTORE" | "PFMERGE" | "GEOSEARCHSTORE" | "FLUSHDB" => RedisCommandSafety::Confirm,
+        "APPEND" | "BITFIELD" | "BITOP" | "COPY" | "DECR" | "DECRBY" | "GEOADD" | "GEORADIUS" | "GEORADIUSBYMEMBER"
+        | "GETSET" | "INCR" | "INCRBY" | "INCRBYFLOAT" | "SET" | "SETEX" | "PSETEX" | "SETNX" | "SETRANGE" | "MSET"
+        | "MSETNX" | "PERSIST" | "HSET" | "HMSET" | "HINCRBY" | "HINCRBYFLOAT" | "HSETNX" | "LINSERT" | "LSET"
+        | "LMOVE" | "LPUSH" | "LPUSHX" | "PFADD" | "RPUSH" | "RPUSHX" | "RESTORE" | "SADD" | "ZADD" | "ZINCRBY"
+        | "SETBIT" | "XADD" | "XACK" | "XAUTOCLAIM" | "XCLAIM" | "XSETID" => RedisCommandSafety::Write,
+        _ => RedisCommandSafety::Allowed,
+    }
+}
+
+pub fn redis_command_raw_to_json(value: RedisRawValue) -> serde_json::Value {
+    match value {
+        RedisRawValue::Nil => serde_json::Value::Null,
+        RedisRawValue::Array(values) => {
+            serde_json::Value::Array(values.into_iter().map(redis_command_raw_to_json).collect())
+        }
+        RedisRawValue::Map(values) => serde_json::Value::Array(
+            values
+                .into_iter()
+                .map(|(key, value)| {
+                    serde_json::json!({
+                        "key": redis_command_raw_to_json(key),
+                        "value": redis_command_raw_to_json(value),
+                    })
+                })
+                .collect(),
+        ),
+        RedisRawValue::Set(values) => {
+            serde_json::Value::Array(values.into_iter().map(redis_command_raw_to_json).collect())
+        }
+        RedisRawValue::Attribute { data, attributes } => serde_json::json!({
+            "data": redis_command_raw_to_json(*data),
+            "attributes": redis_command_raw_to_json(RedisRawValue::Map(attributes)),
+        }),
+        RedisRawValue::Push { kind, data } => serde_json::json!({
+            "kind": format!("{kind:?}"),
+            "data": redis_command_raw_to_json(RedisRawValue::Array(data)),
+        }),
+        RedisRawValue::BulkString(bytes) => {
+            let text = redis_bytes_to_display(&bytes);
+            let trimmed = text.trim();
+            if trimmed.starts_with('{') || trimmed.starts_with('[') {
+                if let Ok(json) = serde_json::from_str::<serde_json::Value>(trimmed) {
+                    return json_value_for_js(json);
+                }
+            }
+            serde_json::Value::String(text)
+        }
+        RedisRawValue::SimpleString(value) => serde_json::Value::String(value),
+        RedisRawValue::Okay => serde_json::Value::String("OK".to_string()),
+        RedisRawValue::Int(value) => super::safe_i64_to_json(value),
+        RedisRawValue::Double(value) => {
+            serde_json::Number::from_f64(value).map_or(serde_json::Value::Null, serde_json::Value::Number)
+        }
+        RedisRawValue::Boolean(value) => serde_json::Value::Bool(value),
+        RedisRawValue::VerbatimString { text, .. } => {
+            serde_json::Value::String(redis_bytes_to_display(text.as_bytes()))
+        }
+        RedisRawValue::BigNumber(value) => serde_json::Value::String(value.to_string()),
+        RedisRawValue::ServerError(error) => serde_json::Value::String(format!("{error:?}")),
+    }
+}
+
+pub fn is_redis_json_type(key_type: &str) -> bool {
+    matches!(key_type.to_ascii_uppercase().as_str(), "REJSON-RL" | "JSON")
+}
+
+pub fn redis_json_raw_to_json(value: RedisRawValue) -> Result<serde_json::Value, String> {
+    match redis_raw_to_json(value) {
+        serde_json::Value::Null => Ok(serde_json::Value::Null),
+        serde_json::Value::String(text) => {
+            serde_json::from_str(&text).map(json_value_for_js).map_err(|e| format!("Invalid RedisJSON value: {e}"))
+        }
+        other => Ok(json_value_for_js(other)),
+    }
+}
+
+pub fn redis_json_value_preview(value: &serde_json::Value) -> String {
+    const MAX_PREVIEW_LEN: usize = 160;
+    let text = serde_json::to_string(value).unwrap_or_else(|_| value.to_string());
+    if text.chars().count() <= MAX_PREVIEW_LEN {
+        return text;
+    }
+    let mut preview = text.chars().take(MAX_PREVIEW_LEN).collect::<String>();
+    preview.push('…');
+    preview
+}
+
+pub fn redis_key_value_preview(key_type: &str) -> String {
+    if is_redis_json_type(key_type) {
+        "{...}".to_string()
+    } else {
+        String::new()
+    }
+}
+
+pub async fn flush_db<C>(con: &mut C) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("FLUSHDB").query_async::<()>(con).await.map_err(|e| e.to_string())
+}
+
+/// Retrieve slowlog entries via `SLOWLOG GET <count>`.
+/// The response is a nested array where each entry has the structure:
+///   [id, timestamp_unix_secs, duration_micros, [arg1, arg2, ...], client_addr, client_name, ...]
+pub async fn get_slowlog<C>(con: &mut C, count: usize) -> Result<Vec<RedisSlowlogEntry>, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let raw: RedisRawValue = redis::cmd("SLOWLOG")
+        .arg("GET")
+        .arg(count as u64)
+        .query_async(con)
+        .await
+        .map_err(|e| format!("SLOWLOG GET failed: {e}"))?;
+
+    let RedisRawValue::Array(entries) = raw else {
+        return Err("SLOWLOG GET returned non-array response".to_string());
+    };
+
+    let mut result = Vec::with_capacity(entries.len());
+    for entry in entries {
+        let RedisRawValue::Array(fields) = entry else {
+            continue;
+        };
+        if fields.len() < 4 {
+            continue;
+        }
+
+        let id = redis_value_to_u64(&fields[0]).unwrap_or(0);
+        let timestamp = fields[1].clone();
+        let duration = fields[2].clone();
+        let args_raw = fields[3].clone();
+        let client_addr = if fields.len() > 4 { redis_raw_value_to_optional_string(&fields[4]) } else { None };
+        let client_name = if fields.len() > 5 { redis_raw_value_to_optional_string(&fields[5]) } else { None };
+
+        let command = match args_raw {
+            RedisRawValue::Array(args) => {
+                let mut parts = Vec::with_capacity(args.len());
+                for arg in args {
+                    if let Some(s) = redis_raw_value_to_command_arg(&arg) {
+                        parts.push(s);
+                    }
+                }
+                parts.join(" ")
+            }
+            _ => String::new(),
+        };
+
+        let timestamp_secs = match timestamp {
+            RedisRawValue::Int(i) => i,
+            RedisRawValue::BulkString(ref bytes) => {
+                std::str::from_utf8(bytes).ok().and_then(|s| s.parse::<i64>().ok()).unwrap_or(0)
+            }
+            _ => 0,
+        };
+
+        let duration_micros = match duration {
+            RedisRawValue::Int(i) => i as u64,
+            RedisRawValue::BulkString(ref bytes) => {
+                std::str::from_utf8(bytes).ok().and_then(|s| s.parse::<u64>().ok()).unwrap_or(0)
+            }
+            _ => 0,
+        };
+
+        result.push(RedisSlowlogEntry {
+            id,
+            timestamp: timestamp_secs,
+            duration_micros,
+            command,
+            client_addr,
+            client_name,
+        });
+    }
+
+    Ok(result)
+}
+
+/// Try to convert a RedisRawValue to an optional string (None for Nil).
+fn redis_raw_value_to_optional_string(v: &RedisRawValue) -> Option<String> {
+    match v {
+        RedisRawValue::BulkString(bytes) => {
+            if bytes.is_empty() {
+                None
+            } else {
+                std::str::from_utf8(bytes).ok().map(|s| s.to_string())
+            }
+        }
+        RedisRawValue::SimpleString(s) => Some(s.clone()),
+        RedisRawValue::Nil => None,
+        _ => None,
+    }
+}
+
+/// Convert a RedisRawValue to an command argument string.
+/// Unlike `redis_raw_value_to_optional_string`, this preserves empty strings
+/// and uses `redis_bytes_to_display` to handle non-UTF-8 binary data.
+fn redis_raw_value_to_command_arg(v: &RedisRawValue) -> Option<String> {
+    match v {
+        RedisRawValue::BulkString(bytes) => Some(redis_bytes_to_display(bytes)),
+        RedisRawValue::SimpleString(s) => Some(s.clone()),
+        RedisRawValue::Nil => None,
+        _ => None,
+    }
+}
+
+/// Try to convert a RedisRawValue to a u64.
+fn redis_value_to_u64(v: &RedisRawValue) -> Option<u64> {
+    match v {
+        RedisRawValue::Int(i) => Some(*i as u64),
+        RedisRawValue::BulkString(bytes) => std::str::from_utf8(bytes).ok().and_then(|s| s.parse().ok()),
+        _ => None,
+    }
+}
+
+/// Extract a string reference from a `RedisRawValue` if it is a BulkString or SimpleString.
+fn redis_raw_value_as_str(v: &RedisRawValue) -> Option<&str> {
+    match v {
+        RedisRawValue::BulkString(bytes) => std::str::from_utf8(bytes).ok(),
+        RedisRawValue::SimpleString(s) => Some(s.as_str()),
+        _ => None,
+    }
+}
+
+pub async fn execute_command<C>(
+    con: &mut C,
+    command_text: &str,
+    skip_safety_check: bool,
+) -> Result<RedisCommandResult, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let argv = parse_command_argv(command_text)?;
+    let command = argv[0].to_ascii_uppercase();
+    let safety = classify_command(&command);
+    if !skip_safety_check && safety == RedisCommandSafety::Blocked {
+        return Err(format!("Redis command is blocked for safety: {command}"));
+    }
+
+    let mut cmd = redis::cmd(&argv[0]);
+    for arg in argv.iter().skip(1) {
+        cmd.arg(arg);
+    }
+    let raw: RedisRawValue = cmd.query_async(con).await.map_err(|e| e.to_string())?;
+
+    // Special handling for INFO command in cluster mode.
+    // redis-rs ClusterConnection routes INFO to all primaries and
+    // aggregates the results as a Map(node_addr → full_info_text).
+
+    // We detect this pattern and return it as an array of
+    // [node_addr, info_text] pairs, which the frontend renders
+    // as a two-column (index → node_addr, value → info_text) table.
+    if command == "INFO" {
+        if let RedisRawValue::Map(entries) = &raw {
+            // Cluster-aggregated INFO has multi-line values starting with "# "
+            // (e.g. "# Server", "# Memory", "# Clients").
+            // This distinguishes it from a RESP3 standalone INFO map where values
+            // are single field values (e.g. "redis_version", "os") or nested maps.
+            let is_cluster_aggregation =
+                entries.iter().any(|(_, v)| redis_raw_value_as_str(v).is_some_and(|s| s.starts_with("# ")));
+
+            if is_cluster_aggregation {
+                let pairs: Vec<serde_json::Value> = entries
+                    .iter()
+                    .filter_map(|(key, value)| {
+                        let addr = redis_raw_value_as_str(key)?;
+                        let info = redis_raw_value_as_str(value)?;
+                        Some(serde_json::json!([addr, info]))
+                    })
+                    .collect();
+                return Ok(RedisCommandResult { command, safety, value: serde_json::Value::Array(pairs) });
+            }
+        }
+    }
+
+    Ok(RedisCommandResult { command, safety, value: redis_command_raw_to_json(raw) })
+}
+
+pub async fn scan_keys_page<C>(con: &mut C, cursor: u64, pattern: &str, count: usize) -> Result<RedisScanResult, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    scan_keys_batch(con, cursor, pattern, count, 1, true).await
+}
+
+pub async fn scan_keys_page_with_options<C>(
+    con: &mut C,
+    cursor: u64,
+    pattern: &str,
+    count: usize,
+    include_types: bool,
+) -> Result<RedisScanResult, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    scan_keys_batch(con, cursor, pattern, count, 1, include_types).await
+}
+
+/// Batch-scan keys with server-side multi-SCAN support.
+///
+/// Performs up to `max_iterations` SCAN cycles in a single call. TYPE metadata
+/// is optional so large key-name searches can avoid extra Redis work.
+/// DBSIZE is only called on the first iteration (cursor == 0).
+pub async fn scan_keys_batch<C>(
+    con: &mut C,
+    cursor: u64,
+    pattern: &str,
+    count: usize,
+    max_iterations: usize,
+    include_types: bool,
+) -> Result<RedisScanResult, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let iterations = max_iterations.max(1);
+    let total_keys: u64 = if cursor == 0 { redis::cmd("DBSIZE").query_async(con).await.unwrap_or(0) } else { 0 };
+
+    let is_exact_match = !pattern.contains('*') && !pattern.contains('?') && !pattern.contains('[');
+    if cursor == 0 && is_exact_match && !pattern.is_empty() {
+        match redis::cmd("EXISTS").arg(pattern).query_async::<bool>(con).await {
+            Ok(true) => {
+                let key_type: String = if include_types {
+                    redis::cmd("TYPE").arg(pattern).query_async(con).await.unwrap_or_else(|_| "unknown".to_string())
+                } else {
+                    String::new()
+                };
+
+                let value_preview = if include_types { redis_key_value_preview(&key_type) } else { String::new() };
+
+                let key_info = RedisKeyInfo {
+                    key_display: redis_key_bytes_to_display(pattern.as_bytes()),
+                    key_raw: redis_key_bytes_to_raw(pattern.as_bytes()),
+                    key_type,
+                    ttl: -2,
+                    size: 0,
+                    value_preview,
+                };
+                return Ok(RedisScanResult { cursor: 0, keys: vec![key_info], total_keys });
+            }
+            Ok(false) => {
+                return Ok(RedisScanResult { cursor: 0, keys: vec![], total_keys });
+            }
+            Err(_) => {}
+        }
+    }
+
+    let mut all_keys: Vec<RedisKeyInfo> = Vec::new();
+
+    let mut current_cursor = cursor;
+
+    for iteration in 0..iterations {
+        let raw: RedisRawValue = redis::cmd("SCAN")
+            .arg(current_cursor)
+            .arg("MATCH")
+            .arg(pattern)
+            .arg("COUNT")
+            .arg(count)
+            .query_async(con)
+            .await
+            .map_err(|e| e.to_string())?;
+
+        let (next_cursor, keys) = parse_scan_keys(raw)?;
+
+        if !keys.is_empty() {
+            let key_types: Vec<String> = if include_types {
+                let mut pipe = redis::pipe();
+                for key in &keys {
+                    pipe.cmd("TYPE").arg(key);
+                }
+                pipe.query_async(con).await.unwrap_or_default()
+            } else {
+                Vec::new()
+            };
+
+            for (index, key) in keys.iter().enumerate() {
+                let key_type = if include_types {
+                    key_types.get(index).cloned().unwrap_or_else(|| "unknown".to_string())
+                } else {
+                    String::new()
+                };
+                let value_preview = if include_types {
+                    redis_key_value_preview(key_types.get(index).map(String::as_str).unwrap_or("unknown"))
+                } else {
+                    String::new()
+                };
+                all_keys.push(RedisKeyInfo {
+                    key_display: redis_key_bytes_to_display(key),
+                    key_raw: redis_key_bytes_to_raw(key),
+                    key_type,
+                    ttl: -2,
+                    size: 0,
+                    value_preview,
+                });
+            }
+        }
+
+        if next_cursor == 0 {
+            return Ok(RedisScanResult { cursor: 0, keys: all_keys, total_keys });
+        }
+        current_cursor = next_cursor;
+
+        // MATCH may yield sparse or empty batches. Keep scanning within the
+        // caller's bounded budget, but stop once this result page is full.
+        if !should_continue_key_scan(all_keys.len(), count, iteration + 1, iterations) {
+            break;
+        }
+    }
+
+    Ok(RedisScanResult { cursor: current_cursor, keys: all_keys, total_keys })
+}
+
+fn should_continue_key_scan(
+    matched_keys: usize,
+    target_keys: usize,
+    completed_iterations: usize,
+    max_iterations: usize,
+) -> bool {
+    matched_keys < target_keys.max(1) && completed_iterations < max_iterations.max(1)
+}
+
+pub async fn scan_values_page<C>(
+    con: &mut C,
+    cursor: u64,
+    pattern: &str,
+    query: &str,
+    include_key_matches: bool,
+    count: usize,
+) -> Result<RedisScanResult, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    // Only call DBSIZE on the first page (cursor == 0) to avoid redundant work.
+    let total_keys: u64 = if cursor == 0 { redis::cmd("DBSIZE").query_async(con).await.unwrap_or(0) } else { 0 };
+    if query.trim().is_empty() {
+        return Ok(RedisScanResult { cursor, keys: Vec::new(), total_keys });
+    }
+
+    let scan_count = count.max(1);
+    let raw: RedisRawValue = redis::cmd("SCAN")
+        .arg(cursor)
+        .arg("MATCH")
+        .arg(pattern)
+        .arg("COUNT")
+        .arg(scan_count)
+        .query_async(con)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let (next_cursor, keys) = parse_scan_keys(raw)?;
+    let mut result = Vec::new();
+    let keys: Vec<_> = keys
+        .into_iter()
+        .map(|key| {
+            let key_display = redis_key_bytes_to_display(&key);
+            let key_raw = redis_key_bytes_to_raw(&key);
+            let key_matches = include_key_matches && redis_key_matches_query(&key_display, &key_raw, query);
+            (key, key_display, key_raw, key_matches)
+        })
+        .collect();
+
+    let mut key_match_types = Vec::new();
+    if include_key_matches {
+        let mut pipe = redis::pipe();
+        let mut key_match_count = 0usize;
+        for (key, _, _, key_matches) in &keys {
+            if *key_matches {
+                pipe.cmd("TYPE").arg(key);
+                key_match_count += 1;
+            }
+        }
+        if key_match_count > 0 {
+            key_match_types = pipe.query_async(con).await.unwrap_or_default();
+        }
+    }
+
+    let mut key_match_type_index = 0usize;
+    for (key, key_display, key_raw, key_matches) in keys {
+        if key_matches {
+            let key_type = key_match_types.get(key_match_type_index).cloned().unwrap_or_else(|| "unknown".to_string());
+            key_match_type_index += 1;
+            result.push(RedisKeyInfo {
+                key_display,
+                key_raw,
+                value_preview: redis_key_value_preview(&key_type),
+                key_type,
+                ttl: -2,
+                size: 0,
+            });
+            continue;
+        }
+
+        let Ok(value) = get_value(con, &key).await else {
+            continue;
+        };
+        if !redis_value_matches_query(&value, query) {
+            continue;
+        }
+
+        let value_preview = redis_search_value_preview(&value.data);
+        let size = redis_search_value_size(&value);
+        result.push(RedisKeyInfo {
+            key_display: value.key_display,
+            key_raw: value.key_raw,
+            key_type: value.redis_type,
+            ttl: value.ttl,
+            size,
+            value_preview,
+        });
+    }
+
+    Ok(RedisScanResult { cursor: next_cursor, keys: result, total_keys })
+}
+
+pub async fn get_value<C>(con: &mut C, key: &[u8]) -> Result<RedisValue, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let redis_type: String = redis::cmd("TYPE").arg(key).query_async(con).await.map_err(|e| e.to_string())?;
+
+    let ttl: i64 = redis::cmd("TTL").arg(key).query_async(con).await.unwrap_or(-1);
+
+    let data = match redis_type.as_str() {
+        "string" => {
+            let v: RedisRawValue = redis::cmd("GET").arg(key).query_async(con).await.map_err(|e| e.to_string())?;
+            RedisValueData::String {
+                content: redis_value_to_bytes(v)
+                    .map(|bytes| redis_blob_from_bytes(&bytes))
+                    .ok_or_else(|| "Redis string payload is not byte-addressable".to_string())?,
+            }
+        }
+        "list" => {
+            let len: u64 = redis::cmd("LLEN").arg(key).query_async(con).await.unwrap_or(0);
+            let end = (COLLECTION_PAGE_SIZE as i64) - 1;
+            let v: RedisRawValue =
+                redis::cmd("LRANGE").arg(key).arg(0).arg(end).query_async(con).await.map_err(|e| e.to_string())?;
+            let cursor = if len > COLLECTION_PAGE_SIZE as u64 { Some(COLLECTION_PAGE_SIZE as u64) } else { None };
+            RedisValueData::List { items: redis_list_items_from_raw(v, 0), total: len, scan_cursor: cursor }
+        }
+        "set" => {
+            let len: u64 = redis::cmd("SCARD").arg(key).query_async(con).await.unwrap_or(0);
+            let (cursor, items) = sscan_page_raw(con, key, 0, COLLECTION_PAGE_SIZE).await?;
+            RedisValueData::Set { items, total: len, scan_cursor: (cursor > 0).then_some(cursor) }
+        }
+        "zset" => {
+            let len: u64 = redis::cmd("ZCARD").arg(key).query_async(con).await.unwrap_or(0);
+            let (cursor, items) = zscan_page_raw(con, key, 0, COLLECTION_PAGE_SIZE).await?;
+            RedisValueData::Zset { items, total: len, scan_cursor: (cursor > 0).then_some(cursor) }
+        }
+        "hash" => {
+            let len: u64 = redis::cmd("HLEN").arg(key).query_async(con).await.unwrap_or(0);
+            let (cursor, items) = hscan_page_raw(con, key, 0, COLLECTION_PAGE_SIZE, None).await?;
+            RedisValueData::Hash { items, total: len, scan_cursor: (cursor > 0).then_some(cursor) }
+        }
+        "stream" => RedisValueData::Stream { entries: get_stream_entries(con, key).await? },
+        key_type if is_redis_json_type(key_type) => {
+            let raw: RedisRawValue =
+                redis::cmd("JSON.GET").arg(key).query_async(con).await.map_err(|e| e.to_string())?;
+            RedisValueData::Json { value: redis_json_raw_to_json(raw)? }
+        }
+        _ => RedisValueData::Unknown,
+    };
+
+    Ok(RedisValue {
+        key_display: redis_key_bytes_to_display(key),
+        key_raw: redis_key_bytes_to_raw(key),
+        redis_type,
+        ttl,
+        data,
+    })
+}
+
+fn redis_value_matches_query(value: &RedisValue, query: &str) -> bool {
+    let query = query.trim();
+    if query.is_empty() {
+        return false;
+    }
+    redis_search_value_text(&value.data).to_lowercase().contains(&query.to_lowercase())
+}
+
+fn redis_key_matches_query(key_display: &str, key_raw: &str, query: &str) -> bool {
+    let query = query.trim();
+    if query.is_empty() {
+        return false;
+    }
+    let query = query.to_lowercase();
+    key_display.to_lowercase().contains(&query) || key_raw.to_lowercase().contains(&query)
+}
+
+fn redis_search_value_text(value: &RedisValueData) -> String {
+    match value {
+        RedisValueData::String { content } => redis_blob_display_text(content),
+        RedisValueData::Json { value } => serde_json::to_string(value).unwrap_or_else(|_| value.to_string()),
+        RedisValueData::List { items, .. } => {
+            items.iter().map(|item| redis_blob_display_text(&item.value)).collect::<Vec<_>>().join(" ")
+        }
+        RedisValueData::Set { items, .. } => {
+            items.iter().map(|item| redis_blob_display_text(&item.member)).collect::<Vec<_>>().join(" ")
+        }
+        RedisValueData::Hash { items, .. } => items
+            .iter()
+            .flat_map(|item| [redis_blob_display_text(&item.field), redis_blob_display_text(&item.value)])
+            .collect::<Vec<_>>()
+            .join(" "),
+        RedisValueData::Zset { items, .. } => items
+            .iter()
+            .flat_map(|item| [item.score.clone(), redis_blob_display_text(&item.member)])
+            .collect::<Vec<_>>()
+            .join(" "),
+        RedisValueData::Stream { entries } => entries
+            .iter()
+            .flat_map(|entry| {
+                entry.fields.iter().flat_map(|field| [field.field.clone(), field.value.clone()]).collect::<Vec<_>>()
+            })
+            .collect::<Vec<_>>()
+            .join(" "),
+        RedisValueData::Unknown => String::new(),
+    }
+}
+
+fn redis_search_value_preview(value: &RedisValueData) -> String {
+    const MAX_PREVIEW_LEN: usize = 160;
+    let text = redis_search_value_text(value);
+    if text.chars().count() <= MAX_PREVIEW_LEN {
+        return text;
+    }
+    let mut preview = text.chars().take(MAX_PREVIEW_LEN).collect::<String>();
+    preview.push('…');
+    preview
+}
+
+fn redis_search_value_size(value: &RedisValue) -> u64 {
+    match &value.data {
+        RedisValueData::String { content } => base64::engine::general_purpose::STANDARD
+            .decode(&content.raw_base64)
+            .map(|bytes| bytes.len() as u64)
+            .unwrap_or(0),
+        RedisValueData::Json { value } => serde_json::to_vec(value).map(|bytes| bytes.len() as u64).unwrap_or(0),
+        RedisValueData::List { total, .. }
+        | RedisValueData::Set { total, .. }
+        | RedisValueData::Hash { total, .. }
+        | RedisValueData::Zset { total, .. } => *total,
+        RedisValueData::Stream { entries } => entries.len() as u64,
+        RedisValueData::Unknown => 0,
+    }
+}
+
+async fn get_stream_entries<C>(con: &mut C, key: &[u8]) -> Result<Vec<RedisStreamEntry>, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let raw: RedisRawValue = redis::cmd("XRANGE")
+        .arg(key)
+        .arg("-")
+        .arg("+")
+        .arg("COUNT")
+        .arg(STREAM_ENTRY_LIMIT)
+        .query_async(con)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    Ok(parse_stream_entries(raw))
+}
+
+fn parse_scan_keys(raw: RedisRawValue) -> Result<(u64, Vec<Vec<u8>>), String> {
+    let RedisRawValue::Array(parts) = raw else {
+        return Err("Invalid Redis SCAN response".to_string());
+    };
+    if parts.len() != 2 {
+        return Err("Invalid Redis SCAN response".to_string());
+    }
+
+    let cursor = redis_value_to_string(parts[0].clone())
+        .ok_or_else(|| "Invalid Redis SCAN cursor".to_string())?
+        .parse::<u64>()
+        .map_err(|_| "Invalid Redis SCAN cursor".to_string())?;
+
+    let RedisRawValue::Array(keys) = &parts[1] else {
+        return Err("Invalid Redis SCAN keys payload".to_string());
+    };
+
+    let mut parsed = Vec::with_capacity(keys.len());
+    for key in keys {
+        parsed.push(redis_value_to_bytes(key.clone()).ok_or_else(|| "Invalid Redis key payload".to_string())?);
+    }
+
+    Ok((cursor, parsed))
+}
+
+fn parse_stream_entries(raw: RedisRawValue) -> Vec<RedisStreamEntry> {
+    match raw {
+        RedisRawValue::Array(entries) => entries.into_iter().filter_map(parse_stream_entry).collect(),
+        _ => Vec::new(),
+    }
+}
+
+fn parse_stream_entry(entry: RedisRawValue) -> Option<RedisStreamEntry> {
+    let mut parts = match entry {
+        RedisRawValue::Array(parts) if parts.len() == 2 => parts.into_iter(),
+        _ => return None,
+    };
+
+    let id = redis_value_to_string(parts.next()?)?;
+    let fields = match parts.next()? {
+        RedisRawValue::Array(fields) => fields,
+        _ => return None,
+    };
+
+    let mut parsed_fields = Vec::new();
+    let mut fields = fields.into_iter();
+    while let Some(field) = fields.next() {
+        let Some(value) = fields.next() else {
+            break;
+        };
+        if let Some(field_name) = redis_value_to_string(field) {
+            let value = redis_value_to_string(value).unwrap_or_default();
+            parsed_fields.push(RedisStreamField { field: field_name, value });
+        }
+    }
+
+    Some(RedisStreamEntry { id, fields: parsed_fields })
+}
+
+fn redis_value_to_string(value: RedisRawValue) -> Option<String> {
+    match value {
+        RedisRawValue::BulkString(bytes) => Some(redis_bytes_to_display(&bytes)),
+        RedisRawValue::SimpleString(value) => Some(value),
+        RedisRawValue::Int(value) => Some(value.to_string()),
+        RedisRawValue::Double(value) => Some(value.to_string()),
+        RedisRawValue::Boolean(value) => Some(value.to_string()),
+        RedisRawValue::VerbatimString { text, .. } => Some(redis_bytes_to_display(text.as_bytes())),
+        RedisRawValue::Okay => Some("OK".to_string()),
+        _ => None,
+    }
+}
+
+fn redis_value_to_bytes(value: RedisRawValue) -> Option<Vec<u8>> {
+    match value {
+        RedisRawValue::BulkString(bytes) => Some(bytes),
+        RedisRawValue::SimpleString(value) => Some(value.into_bytes()),
+        RedisRawValue::Int(value) => Some(value.to_string().into_bytes()),
+        RedisRawValue::Double(value) => Some(value.to_string().into_bytes()),
+        RedisRawValue::Boolean(value) => Some(value.to_string().into_bytes()),
+        RedisRawValue::VerbatimString { text, .. } => Some(text.into_bytes()),
+        RedisRawValue::Okay => Some(b"OK".to_vec()),
+        _ => None,
+    }
+}
+
+fn redis_blob_from_bytes(bytes: &[u8]) -> RedisBlob {
+    RedisBlob {
+        raw_base64: base64::engine::general_purpose::STANDARD.encode(bytes),
+        encoding: if std::str::from_utf8(bytes).is_ok() { RedisBlobEncoding::Utf8 } else { RedisBlobEncoding::Binary },
+    }
+}
+
+fn redis_blob_display_text(blob: &RedisBlob) -> String {
+    let bytes = base64::engine::general_purpose::STANDARD.decode(&blob.raw_base64).unwrap_or_default();
+    if matches!(blob.encoding, RedisBlobEncoding::Utf8) {
+        if let Ok(text) = std::str::from_utf8(&bytes) {
+            return text.to_string();
+        }
+    }
+    redis_bytes_to_display(&bytes)
+}
+
+fn redis_list_items_from_raw(value: RedisRawValue, start_index: u64) -> Vec<RedisListItem> {
+    match value {
+        RedisRawValue::Array(values) => values
+            .into_iter()
+            .enumerate()
+            .filter_map(|(offset, value)| {
+                redis_value_to_bytes(value).map(|bytes| RedisListItem {
+                    index: start_index + offset as u64,
+                    value: redis_blob_from_bytes(&bytes),
+                })
+            })
+            .collect(),
+        _ => Vec::new(),
+    }
+}
+
+fn redis_raw_to_json(value: RedisRawValue) -> serde_json::Value {
+    match value {
+        RedisRawValue::Nil => serde_json::Value::Null,
+        RedisRawValue::Array(values) => serde_json::Value::Array(values.into_iter().map(redis_raw_to_json).collect()),
+        other => serde_json::Value::String(redis_value_to_string(other).unwrap_or_default()),
+    }
+}
+
+fn redis_bytes_to_display(bytes: &[u8]) -> String {
+    if let Ok(text) = std::str::from_utf8(bytes) {
+        return text.replace('\\', "\\\\");
+    }
+
+    let mut output = String::new();
+    for &byte in bytes {
+        match byte {
+            b'\\' => output.push_str("\\\\"),
+            0x20..=0x7e => output.push(byte as char),
+            _ => output.push_str(&format!("\\x{:02x}", byte)),
+        }
+    }
+    output
+}
+
+pub fn redis_key_bytes_to_display(bytes: &[u8]) -> String {
+    redis_bytes_to_display(bytes)
+}
+
+pub fn redis_key_bytes_to_raw(bytes: &[u8]) -> String {
+    base64::engine::general_purpose::STANDARD.encode(bytes)
+}
+
+pub fn redis_key_raw_to_bytes(value: &str) -> Result<Vec<u8>, String> {
+    base64::engine::general_purpose::STANDARD.decode(value).map_err(|e| format!("Invalid Redis key encoding: {e}"))
+}
+
+pub async fn set_string<C>(con: &mut C, key: &[u8], value: &str, ttl: Option<i64>) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("SET").arg(key).arg(value).query_async::<()>(con).await.map_err(|e| e.to_string())?;
+    if let Some(t) = ttl {
+        if t > 0 {
+            redis::cmd("EXPIRE").arg(key).arg(t).query_async::<()>(con).await.map_err(|e| e.to_string())?;
+        }
+    }
+    Ok(())
+}
+
+pub async fn delete_key<C>(con: &mut C, key: &[u8]) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("DEL").arg(key).query_async::<()>(con).await.map_err(|e| e.to_string())
+}
+
+async fn apply_expire_if_needed<C>(con: &mut C, key: &[u8], ttl: Option<i64>) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    if let Some(t) = ttl {
+        if t > 0 {
+            redis::cmd("EXPIRE").arg(key).arg(t).query_async::<()>(con).await.map_err(|e| e.to_string())?;
+        }
+    }
+    Ok(())
+}
+
+pub async fn hash_set<C>(con: &mut C, key: &[u8], field: &str, value: &str, ttl: Option<i64>) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("HSET").arg(key).arg(field).arg(value).query_async::<()>(con).await.map_err(|e| e.to_string())?;
+    apply_expire_if_needed(con, key, ttl).await
+}
+
+pub async fn hash_del<C>(con: &mut C, key: &[u8], field: &str) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("HDEL").arg(key).arg(field).query_async::<()>(con).await.map_err(|e| e.to_string())
+}
+
+pub async fn list_push<C>(con: &mut C, key: &[u8], value: &str, ttl: Option<i64>) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("RPUSH").arg(key).arg(value).query_async::<()>(con).await.map_err(|e| e.to_string())?;
+    apply_expire_if_needed(con, key, ttl).await
+}
+
+pub async fn list_set<C>(con: &mut C, key: &[u8], index: i64, value: &str) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("LSET").arg(key).arg(index).arg(value).query_async::<()>(con).await.map_err(|e| e.to_string())
+}
+
+pub async fn list_remove<C>(con: &mut C, key: &[u8], index: i64) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let placeholder = "__DELETED_PLACEHOLDER__";
+    redis::cmd("LSET").arg(key).arg(index).arg(placeholder).query_async::<()>(con).await.map_err(|e| e.to_string())?;
+    redis::cmd("LREM").arg(key).arg(1).arg(placeholder).query_async::<()>(con).await.map_err(|e| e.to_string())
+}
+
+pub async fn set_add<C>(con: &mut C, key: &[u8], member: &str, ttl: Option<i64>) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("SADD").arg(key).arg(member).query_async::<()>(con).await.map_err(|e| e.to_string())?;
+    apply_expire_if_needed(con, key, ttl).await
+}
+
+pub async fn set_remove<C>(con: &mut C, key: &[u8], member: &str) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("SREM").arg(key).arg(member).query_async::<()>(con).await.map_err(|e| e.to_string())
+}
+
+pub async fn zadd<C>(con: &mut C, key: &[u8], member: &str, score: f64, ttl: Option<i64>) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("ZADD").arg(key).arg(score).arg(member).query_async::<()>(con).await.map_err(|e| e.to_string())?;
+    apply_expire_if_needed(con, key, ttl).await
+}
+
+pub async fn zrem<C>(con: &mut C, key: &[u8], member: &str) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("ZREM").arg(key).arg(member).query_async::<()>(con).await.map_err(|e| e.to_string())
+}
+
+pub async fn stream_add<C>(
+    con: &mut C,
+    key: &[u8],
+    entry_id: &str,
+    fields: &[(String, String)],
+    ttl: Option<i64>,
+) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let mut cmd = redis::cmd("XADD");
+    cmd.arg(key).arg(entry_id);
+    for (field, value) in fields {
+        cmd.arg(field.as_str()).arg(value.as_str());
+    }
+    cmd.query_async::<()>(con).await.map_err(|e| e.to_string())?;
+    apply_expire_if_needed(con, key, ttl).await
+}
+
+pub async fn json_set<C>(con: &mut C, key: &[u8], value: &str, ttl: Option<i64>) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    redis::cmd("JSON.SET").arg(key).arg("$").arg(value).query_async::<()>(con).await.map_err(|e| e.to_string())?;
+    apply_expire_if_needed(con, key, ttl).await
+}
+
+pub async fn check_json_module<C>(con: &mut C) -> Result<bool, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let raw: RedisRawValue = redis::cmd("MODULE").arg("LIST").query_async(con).await.map_err(|e| e.to_string())?;
+    Ok(match raw {
+        RedisRawValue::Array(modules) => modules.iter().any(|module| {
+            if let RedisRawValue::Array(kvs) = module {
+                kvs.get(1)
+                    .is_some_and(|v| matches!(v, RedisRawValue::BulkString(n) if n.eq_ignore_ascii_case(b"ReJSON")))
+            } else {
+                false
+            }
+        }),
+        _ => false,
+    })
+}
+
+pub async fn set_ttl<C>(con: &mut C, key: &[u8], ttl: i64) -> Result<(), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    if ttl > 0 {
+        redis::cmd("EXPIRE").arg(key).arg(ttl).query_async::<()>(con).await.map_err(|e| e.to_string())
+    } else {
+        redis::cmd("PERSIST").arg(key).query_async::<()>(con).await.map_err(|e| e.to_string())
+    }
+}
+
+pub async fn delete_keys<C>(con: &mut C, keys: &[Vec<u8>]) -> Result<u64, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let mut cmd = redis::cmd("DEL");
+    for key in keys {
+        cmd.arg(key.as_slice());
+    }
+    cmd.query_async(con).await.map_err(|e| e.to_string())
+}
+
+pub async fn load_more_collection<C>(
+    con: &mut C,
+    key: &[u8],
+    key_type: &str,
+    cursor: u64,
+    count: usize,
+    filter_query: Option<&str>,
+) -> Result<RedisCollectionPage, String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    match key_type {
+        "list" => {
+            let start = cursor as i64;
+            let end = start + count as i64 - 1;
+            let v: RedisRawValue =
+                redis::cmd("LRANGE").arg(key).arg(start).arg(end).query_async(con).await.map_err(|e| e.to_string())?;
+            let len: u64 = redis::cmd("LLEN").arg(key).query_async(con).await.unwrap_or(0);
+            let next = cursor + count as u64;
+            Ok(RedisCollectionPage::List {
+                items: redis_list_items_from_raw(v, cursor),
+                scan_cursor: (next < len).then_some(next),
+            })
+        }
+        "set" => {
+            let (next_cursor, items) = sscan_page_raw(con, key, cursor, count).await?;
+            Ok(RedisCollectionPage::Set { items, scan_cursor: (next_cursor > 0).then_some(next_cursor) })
+        }
+        "zset" => {
+            let (next_cursor, items) = zscan_page_raw(con, key, cursor, count).await?;
+            Ok(RedisCollectionPage::Zset { items, scan_cursor: (next_cursor > 0).then_some(next_cursor) })
+        }
+        "hash" => {
+            let (next_cursor, items) = if let Some(query) = filter_query.filter(|query| !query.is_empty()) {
+                hscan_filtered_page_raw(con, key, cursor, count, query).await?
+            } else {
+                hscan_page_raw(con, key, cursor, count, None).await?
+            };
+            Ok(RedisCollectionPage::Hash { items, scan_cursor: (next_cursor > 0).then_some(next_cursor) })
+        }
+        _ => Err(format!("Pagination not supported for type: {key_type}")),
+    }
+}
+
+async fn hscan_page_raw<C>(
+    con: &mut C,
+    key: &[u8],
+    cursor: u64,
+    count: usize,
+    match_pattern: Option<&str>,
+) -> Result<(u64, Vec<RedisHashItem>), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let mut cmd = redis::cmd("HSCAN");
+    cmd.arg(key).arg(cursor).arg("COUNT").arg(count);
+    if let Some(pattern) = match_pattern {
+        cmd.arg("MATCH").arg(pattern);
+    }
+    let raw: RedisRawValue = cmd.query_async(con).await.map_err(|e| e.to_string())?;
+    parse_scan_hash_entries(raw)
+}
+
+async fn hscan_filtered_page_raw<C>(
+    con: &mut C,
+    key: &[u8],
+    cursor: u64,
+    count: usize,
+    query: &str,
+) -> Result<(u64, Vec<RedisHashItem>), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let mut cur = cursor;
+    let mut items = Vec::new();
+    let target = count.max(1);
+
+    for _ in 0..HASH_FILTER_SCAN_MAX_ITERATIONS {
+        let (next, page) = hscan_page_raw(con, key, cur, target, None).await?;
+        items.extend(page.into_iter().filter(|item| hash_entry_matches_query(item, query)));
+        cur = next;
+        // HSCAN MATCH only checks field names, so value search has to filter returned pairs client-side.
+        // Keep a hard scan bound so sparse value matches cannot turn one UI search into a full hash walk.
+        if cur == 0 || items.len() >= target {
+            break;
+        }
+    }
+
+    Ok((cur, items))
+}
+
+fn hash_entry_matches_query(item: &RedisHashItem, query: &str) -> bool {
+    let query = query.to_lowercase();
+    if query.is_empty() {
+        return true;
+    }
+    let field = redis_blob_display_text(&item.field);
+    let value = redis_blob_display_text(&item.value);
+    field.to_lowercase().contains(&query) || value.to_lowercase().contains(&query)
+}
+
+async fn sscan_page_raw<C>(
+    con: &mut C,
+    key: &[u8],
+    cursor: u64,
+    count: usize,
+) -> Result<(u64, Vec<RedisSetItem>), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let raw: RedisRawValue = redis::cmd("SSCAN")
+        .arg(key)
+        .arg(cursor)
+        .arg("COUNT")
+        .arg(count)
+        .query_async(con)
+        .await
+        .map_err(|e| e.to_string())?;
+    parse_scan_members(raw)
+}
+
+async fn zscan_page_raw<C>(
+    con: &mut C,
+    key: &[u8],
+    cursor: u64,
+    count: usize,
+) -> Result<(u64, Vec<RedisZsetItem>), String>
+where
+    C: ConnectionLike + Send + Sync + Unpin,
+{
+    let raw: RedisRawValue = redis::cmd("ZSCAN")
+        .arg(key)
+        .arg(cursor)
+        .arg("COUNT")
+        .arg(count)
+        .query_async(con)
+        .await
+        .map_err(|e| e.to_string())?;
+    let (next_cursor, items) = parse_scan_pairs(raw)?;
+    Ok((next_cursor, items.into_iter().map(|(member, score)| RedisZsetItem { score, member }).collect()))
+}
+
+fn parse_scan_pairs(raw: RedisRawValue) -> Result<(u64, Vec<(RedisBlob, String)>), String> {
+    let RedisRawValue::Array(parts) = raw else {
+        return Err("Invalid SCAN response".to_string());
+    };
+    if parts.len() != 2 {
+        return Err("Invalid SCAN response".to_string());
+    }
+
+    let cursor = redis_value_to_string(parts[0].clone())
+        .ok_or("Invalid cursor")?
+        .parse::<u64>()
+        .map_err(|_| "Invalid cursor".to_string())?;
+
+    let RedisRawValue::Array(entries) = &parts[1] else {
+        return Err("Invalid SCAN entries".to_string());
+    };
+
+    let mut items = Vec::new();
+    let mut iter = entries.iter();
+    while let Some(a) = iter.next() {
+        let Some(b) = iter.next() else { break };
+        let member = redis_value_to_bytes(a.clone())
+            .map(|bytes| redis_blob_from_bytes(&bytes))
+            .ok_or_else(|| "Invalid SCAN member payload".to_string())?;
+        let value = redis_value_to_string(b.clone()).unwrap_or_default();
+        items.push((member, value));
+    }
+
+    Ok((cursor, items))
+}
+
+fn parse_scan_hash_entries(raw: RedisRawValue) -> Result<(u64, Vec<RedisHashItem>), String> {
+    let RedisRawValue::Array(parts) = raw else {
+        return Err("Invalid SCAN response".to_string());
+    };
+    if parts.len() != 2 {
+        return Err("Invalid SCAN response".to_string());
+    }
+
+    let cursor = redis_value_to_string(parts[0].clone())
+        .ok_or("Invalid cursor")?
+        .parse::<u64>()
+        .map_err(|_| "Invalid cursor".to_string())?;
+
+    let RedisRawValue::Array(entries) = &parts[1] else {
+        return Err("Invalid SCAN entries".to_string());
+    };
+
+    let mut items = Vec::new();
+    let mut iter = entries.iter();
+    while let Some(field) = iter.next() {
+        let Some(value) = iter.next() else { break };
+        let field = redis_value_to_bytes(field.clone())
+            .map(|bytes| redis_blob_from_bytes(&bytes))
+            .ok_or_else(|| "Invalid hash field payload".to_string())?;
+        let value = redis_value_to_bytes(value.clone())
+            .map(|bytes| redis_blob_from_bytes(&bytes))
+            .ok_or_else(|| "Invalid hash value payload".to_string())?;
+        items.push(RedisHashItem { field, value });
+    }
+
+    Ok((cursor, items))
+}
+
+fn parse_scan_members(raw: RedisRawValue) -> Result<(u64, Vec<RedisSetItem>), String> {
+    let RedisRawValue::Array(parts) = raw else {
+        return Err("Invalid SCAN response".to_string());
+    };
+    if parts.len() != 2 {
+        return Err("Invalid SCAN response".to_string());
+    }
+
+    let cursor = redis_value_to_string(parts[0].clone())
+        .ok_or("Invalid cursor")?
+        .parse::<u64>()
+        .map_err(|_| "Invalid cursor".to_string())?;
+
+    let RedisRawValue::Array(entries) = &parts[1] else {
+        return Err("Invalid SCAN entries".to_string());
+    };
+
+    let items = entries
+        .iter()
+        .filter_map(|value| {
+            redis_value_to_bytes(value.clone()).map(|bytes| RedisSetItem { member: redis_blob_from_bytes(&bytes) })
+        })
+        .collect();
+
+    Ok((cursor, items))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::VecDeque;
+
+    use super::{
+        classify_command, connection_info, decode_cluster_cursor, encode_cluster_cursor, is_redis_json_type,
+        parse_cluster_slots, parse_command_argv, parse_database_count, parse_redis_endpoint, parse_scan_keys,
+        parse_stream_entries, redis_auth_candidates, redis_blob_from_bytes, redis_cluster_slot,
+        redis_command_raw_to_json, redis_database_index, redis_json_raw_to_json, redis_json_value_preview,
+        redis_key_bytes_to_display, redis_key_bytes_to_raw, redis_key_matches_query, redis_key_raw_to_bytes,
+        redis_key_value_preview, redis_raw_to_json, redis_sentinel_master_endpoint, redis_value_matches_query,
+        redis_value_to_bytes, RedisAuthCandidate, RedisBlob, RedisBlobEncoding, RedisClusterSlotRange,
+        RedisCollectionPage, RedisCommandSafety, RedisHashItem, RedisNodeEndpoint, RedisRawValue, RedisSetItem,
+        RedisStreamEntry, RedisStreamField, RedisValue, RedisValueData,
+    };
+    use crate::models::connection::ConnectionConfig;
+    use redis::{aio::ConnectionLike, Cmd, ConnectionAddr, Pipeline, RedisFuture};
+
+    struct FakeRedisConnection {
+        responses: VecDeque<RedisRawValue>,
+        commands: Vec<String>,
+    }
+
+    impl FakeRedisConnection {
+        fn new(responses: Vec<RedisRawValue>) -> Self {
+            Self { responses: responses.into(), commands: Vec::new() }
+        }
+
+        fn command_count(&self, command: &str) -> usize {
+            let needle = format!("\r\n{command}\r\n");
+            self.commands.iter().filter(|packed| packed.contains(&needle)).count()
+        }
+    }
+
+    impl ConnectionLike for FakeRedisConnection {
+        fn req_packed_command<'a>(&'a mut self, cmd: &'a Cmd) -> RedisFuture<'a, RedisRawValue> {
+            self.commands.push(String::from_utf8_lossy(&cmd.get_packed_command()).into_owned());
+            let response = self.responses.pop_front().unwrap_or(RedisRawValue::Nil);
+            Box::pin(async move { Ok(response) })
+        }
+
+        fn req_packed_commands<'a>(
+            &'a mut self,
+            _cmd: &'a Pipeline,
+            _offset: usize,
+            _count: usize,
+        ) -> RedisFuture<'a, Vec<RedisRawValue>> {
+            Box::pin(async move { Ok(Vec::new()) })
+        }
+
+        fn get_db(&self) -> i64 {
+            0
+        }
+    }
+
+    fn bulk(value: &str) -> RedisRawValue {
+        RedisRawValue::BulkString(value.as_bytes().to_vec())
+    }
+
+    fn scan_response(cursor: &str, keys: Vec<&str>) -> RedisRawValue {
+        RedisRawValue::Array(vec![
+            bulk(cursor),
+            RedisRawValue::Array(
+                keys.into_iter().map(|key| RedisRawValue::BulkString(key.as_bytes().to_vec())).collect(),
+            ),
+        ])
+    }
+
+    fn hscan_response(cursor: &str, pairs: Vec<(&str, &str)>) -> RedisRawValue {
+        let entries = pairs.into_iter().flat_map(|(field, value)| [bulk(field), bulk(value)]).collect();
+        RedisRawValue::Array(vec![bulk(cursor), RedisRawValue::Array(entries)])
+    }
+
+    fn text_blob(value: &str) -> RedisBlob {
+        redis_blob_from_bytes(value.as_bytes())
+    }
+
+    fn redis_value(redis_type: &str, data: RedisValueData) -> RedisValue {
+        RedisValue {
+            key_display: "test:key".to_string(),
+            key_raw: redis_key_bytes_to_raw(b"test:key"),
+            ttl: -1,
+            redis_type: redis_type.to_string(),
+            data,
+        }
+    }
+
+    fn string_value(value: &str) -> RedisValue {
+        redis_value("string", RedisValueData::String { content: text_blob(value) })
+    }
+
+    fn hash_value(entries: &[(&str, &str)]) -> RedisValue {
+        redis_value(
+            "hash",
+            RedisValueData::Hash {
+                items: entries
+                    .iter()
+                    .map(|(field, value)| RedisHashItem { field: text_blob(field), value: text_blob(value) })
+                    .collect(),
+                total: entries.len() as u64,
+                scan_cursor: None,
+            },
+        )
+    }
+
+    fn set_value(entries: &[&str]) -> RedisValue {
+        redis_value(
+            "set",
+            RedisValueData::Set {
+                items: entries.iter().map(|value| RedisSetItem { member: text_blob(value) }).collect(),
+                total: entries.len() as u64,
+                scan_cursor: None,
+            },
+        )
+    }
+
+    #[test]
+    fn parses_stream_entries() {
+        let raw = RedisRawValue::Array(vec![RedisRawValue::Array(vec![
+            bulk("1714470000000-0"),
+            RedisRawValue::Array(vec![bulk("event"), bulk("login"), bulk("user_id"), bulk("42")]),
+        ])]);
+
+        let parsed = parse_stream_entries(raw);
+
+        assert_eq!(
+            parsed,
+            vec![RedisStreamEntry {
+                id: "1714470000000-0".to_string(),
+                fields: vec![
+                    RedisStreamField { field: "event".to_string(), value: "login".to_string() },
+                    RedisStreamField { field: "user_id".to_string(), value: "42".to_string() },
+                ],
+            }]
+        );
+    }
+
+    #[test]
+    fn skips_malformed_stream_entries() {
+        let raw = RedisRawValue::Array(vec![
+            RedisRawValue::Array(vec![bulk("1714470000000-0")]),
+            RedisRawValue::Array(vec![
+                bulk("1714470000001-0"),
+                RedisRawValue::Array(vec![bulk("event"), bulk("logout")]),
+            ]),
+        ]);
+
+        let parsed = parse_stream_entries(raw);
+
+        assert_eq!(
+            parsed,
+            vec![RedisStreamEntry {
+                id: "1714470000001-0".to_string(),
+                fields: vec![RedisStreamField { field: "event".to_string(), value: "logout".to_string() }],
+            }]
+        );
+    }
+
+    #[test]
+    fn parses_configured_database_count() {
+        let value = RedisRawValue::Array(vec![
+            RedisRawValue::BulkString(b"databases".to_vec()),
+            RedisRawValue::BulkString(b"32".to_vec()),
+        ]);
+
+        assert_eq!(parse_database_count(value), Some(32));
+    }
+
+    #[test]
+    fn formats_binary_keys_like_rdm() {
+        let bytes = [0xAC, 0xED, 0x00, 0x05, b't', 0x00, b'A', b'\\'];
+
+        assert_eq!(redis_key_bytes_to_display(&bytes), "\\xac\\xed\\x00\\x05t\\x00A\\\\");
+    }
+
+    #[test]
+    fn preserves_utf8_keys_as_readable_text() {
+        let bytes = "用户:配置".as_bytes();
+
+        assert_eq!(redis_key_bytes_to_display(bytes), "用户:配置");
+    }
+
+    #[test]
+    fn round_trips_raw_key_transport() {
+        let bytes = b"\xAC\xED\x00\x05t\x00token";
+        let encoded = redis_key_bytes_to_raw(bytes);
+
+        assert_eq!(redis_key_raw_to_bytes(&encoded).unwrap(), bytes);
+    }
+
+    #[test]
+    fn parses_scan_response_with_binary_keys() {
+        let raw = RedisRawValue::Array(vec![
+            RedisRawValue::BulkString(b"17".to_vec()),
+            RedisRawValue::Array(vec![
+                RedisRawValue::BulkString(vec![0xAC, 0xED, 0x00, 0x05, b't']),
+                RedisRawValue::BulkString(b"plain:key".to_vec()),
+            ]),
+        ]);
+
+        let (cursor, keys) = parse_scan_keys(raw).unwrap();
+
+        assert_eq!(cursor, 17);
+        assert_eq!(keys, vec![vec![0xAC, 0xED, 0x00, 0x05, b't'], b"plain:key".to_vec()]);
+    }
+
+    #[tokio::test]
+    async fn scan_keys_batch_respects_iteration_limit_on_empty_cursor_pages() {
+        let mut con = FakeRedisConnection::new(vec![
+            RedisRawValue::Int(3001),
+            scan_response("512", vec![]),
+            scan_response("0", vec!["user:room:snapshot:200063:1"]),
+        ]);
+
+        let result = super::scan_keys_batch(&mut con, 0, "user:room:snapshot:200063:*", 1000, 1, false).await.unwrap();
+
+        assert_eq!(result.cursor, 512);
+        assert!(result.keys.is_empty());
+        assert_eq!(con.command_count("SCAN"), 1);
+    }
+
+    #[tokio::test]
+    async fn scan_keys_batch_can_skip_empty_cursor_pages_for_sparse_match() {
+        let key = "user:room:snapshot:200063:1";
+        let mut con = FakeRedisConnection::new(vec![
+            RedisRawValue::Int(3001),
+            scan_response("512", vec![]),
+            scan_response("0", vec![key]),
+        ]);
+
+        let result = super::scan_keys_batch(&mut con, 0, "user:room:snapshot:200063:*", 1000, 2, false).await.unwrap();
+
+        assert_eq!(result.cursor, 0);
+        assert_eq!(result.total_keys, 3001);
+        assert_eq!(result.keys.len(), 1);
+        assert_eq!(result.keys[0].key_display, key);
+        assert_eq!(result.keys[0].key_raw, redis_key_bytes_to_raw(key.as_bytes()));
+        assert_eq!(con.command_count("SCAN"), 2);
+    }
+
+    #[tokio::test]
+    async fn filtered_hash_load_more_matches_fields_and_keeps_scan_cursor() {
+        let mut con = FakeRedisConnection::new(vec![
+            hscan_response("512", vec![("user:1", "Ada")]),
+            hscan_response("0", vec![("user:2", "Bob")]),
+        ]);
+
+        let result = super::load_more_collection(&mut con, b"hash-key", "hash", 0, 1, Some("user")).await.unwrap();
+
+        let RedisCollectionPage::Hash { items, scan_cursor } = result else {
+            panic!("expected hash collection page");
+        };
+        assert_eq!(scan_cursor, Some(512));
+        assert_eq!(items, vec![RedisHashItem { field: text_blob("user:1"), value: text_blob("Ada") }]);
+        assert_eq!(con.command_count("HSCAN"), 1);
+        assert!(!con.commands[0].contains("\r\nMATCH\r\n"));
+    }
+
+    #[tokio::test]
+    async fn filtered_hash_load_more_matches_values() {
+        let mut con =
+            FakeRedisConnection::new(vec![hscan_response("0", vec![("status", "Ada Lovelace"), ("name", "Bob")])]);
+
+        let result = super::load_more_collection(&mut con, b"hash-key", "hash", 0, 20, Some("lovelace")).await.unwrap();
+
+        let RedisCollectionPage::Hash { items, scan_cursor } = result else {
+            panic!("expected hash collection page");
+        };
+        assert_eq!(scan_cursor, None);
+        assert_eq!(items, vec![RedisHashItem { field: text_blob("status"), value: text_blob("Ada Lovelace") }]);
+        assert_eq!(con.command_count("HSCAN"), 1);
+        assert!(!con.commands[0].contains("\r\nMATCH\r\n"));
+    }
+
+    #[tokio::test]
+    async fn filtered_hash_load_more_caps_sparse_scan_iterations() {
+        let responses = (1..=super::HASH_FILTER_SCAN_MAX_ITERATIONS + 1)
+            .map(|cursor| hscan_response(&cursor.to_string(), vec![]))
+            .collect();
+        let mut con = FakeRedisConnection::new(responses);
+
+        let result = super::load_more_collection(&mut con, b"hash-key", "hash", 0, 20, Some("missing")).await.unwrap();
+
+        let RedisCollectionPage::Hash { items, scan_cursor } = result else {
+            panic!("expected hash collection page");
+        };
+        assert_eq!(scan_cursor, Some(super::HASH_FILTER_SCAN_MAX_ITERATIONS as u64));
+        assert!(items.is_empty());
+        assert_eq!(con.command_count("HSCAN"), super::HASH_FILTER_SCAN_MAX_ITERATIONS);
+    }
+
+    #[test]
+    fn formats_binary_string_values_like_rdm() {
+        let raw = RedisRawValue::BulkString(vec![0xAC, 0xED, 0x00, 0x05, b's', b'r']);
+
+        let value = redis_raw_to_json(raw);
+
+        assert_eq!(value, serde_json::Value::String("\\xac\\xed\\x00\\x05sr".to_string()));
+    }
+
+    #[test]
+    fn does_not_treat_utf8_with_backslashes_as_binary() {
+        let raw = RedisRawValue::BulkString(br#"C:\Users\path"#.to_vec());
+
+        let blob = redis_value_to_bytes(raw).map(|bytes| redis_blob_from_bytes(&bytes)).unwrap();
+        assert_eq!(blob.encoding, RedisBlobEncoding::Utf8);
+    }
+
+    #[test]
+    fn preserves_non_ascii_utf8_as_utf8() {
+        let raw = RedisRawValue::BulkString("你好，redis".as_bytes().to_vec());
+
+        let blob = redis_value_to_bytes(raw).map(|bytes| redis_blob_from_bytes(&bytes)).unwrap();
+        assert_eq!(blob.encoding, RedisBlobEncoding::Utf8);
+    }
+
+    #[test]
+    fn parses_command_text_with_quotes_and_escapes() {
+        let argv = parse_command_argv(r#"SET "user:1" "Ada \"Lovelace\"""#).unwrap();
+
+        assert_eq!(argv, vec!["SET", "user:1", "Ada \"Lovelace\""]);
+    }
+
+    #[test]
+    fn rejects_empty_command_text() {
+        assert_eq!(parse_command_argv("   ").unwrap_err(), "Redis command is empty");
+    }
+
+    #[test]
+    fn matches_redis_values_case_insensitively() {
+        assert!(redis_value_matches_query(&string_value("Hello Redis"), "redis"));
+        assert!(redis_value_matches_query(&hash_value(&[("field", "Ada Lovelace")]), "lovelace"));
+        assert!(!redis_value_matches_query(&string_value("Hello Redis"), ""));
+        assert!(!redis_value_matches_query(&string_value("Hello Redis"), "mysql"));
+    }
+
+    #[test]
+    fn matches_redis_keys_case_insensitively() {
+        assert!(redis_key_matches_query("User:42:Profile", "User:42:Profile", "profile"));
+        assert!(redis_key_matches_query("binary key", "ff75736572", "FF75"));
+        assert!(!redis_key_matches_query("User:42:Profile", "User:42:Profile", ""));
+        assert!(!redis_key_matches_query("User:42:Profile", "User:42:Profile", "order"));
+    }
+
+    #[test]
+    fn sparse_key_scan_continues_after_empty_iterations() {
+        assert!(super::should_continue_key_scan(0, 1000, 8, 50));
+    }
+
+    #[test]
+    fn key_scan_stops_when_result_page_is_full() {
+        assert!(!super::should_continue_key_scan(1000, 1000, 3, 50));
+        assert!(!super::should_continue_key_scan(1200, 1000, 3, 50));
+    }
+
+    #[test]
+    fn key_scan_respects_iteration_budget() {
+        assert!(!super::should_continue_key_scan(0, 1000, 50, 50));
+        assert!(!super::should_continue_key_scan(0, 0, 1, 1));
+    }
+
+    #[test]
+    fn matches_hash_field_name_in_value_search() {
+        let hash_value = hash_value(&[("name", "Alice"), ("email", "alice@example.com")]);
+        assert!(redis_value_matches_query(&hash_value, "name"));
+        assert!(redis_value_matches_query(&hash_value, "email"));
+    }
+
+    #[test]
+    fn matches_hash_field_value_in_value_search() {
+        let hash_value = hash_value(&[("name", "Alice"), ("email", "alice@example.com")]);
+        assert!(redis_value_matches_query(&hash_value, "alice"));
+        assert!(redis_value_matches_query(&hash_value, "example"));
+    }
+
+    #[test]
+    fn empty_hash_does_not_match() {
+        let empty_hash = hash_value(&[]);
+        assert!(!redis_value_matches_query(&empty_hash, "anything"));
+    }
+
+    #[test]
+    fn non_hash_array_unaffected() {
+        let set_value = set_value(&["member1", "member2", "hello"]);
+        assert!(redis_value_matches_query(&set_value, "member1"));
+        assert!(redis_value_matches_query(&set_value, "hello"));
+        assert!(!redis_value_matches_query(&set_value, "nonexistent"));
+    }
+
+    #[test]
+    fn classifies_safe_confirmed_and_blocked_commands() {
+        assert_eq!(classify_command("GET"), RedisCommandSafety::Allowed);
+        assert_eq!(classify_command("set"), RedisCommandSafety::Write);
+        assert_eq!(classify_command("hset"), RedisCommandSafety::Write);
+        assert_eq!(classify_command("del"), RedisCommandSafety::Confirm);
+        assert_eq!(classify_command("flushdb"), RedisCommandSafety::Confirm);
+        assert_eq!(classify_command("KEYS"), RedisCommandSafety::Blocked);
+        assert_eq!(classify_command("flushall"), RedisCommandSafety::Blocked);
+        assert_eq!(classify_command("eval"), RedisCommandSafety::Blocked);
+    }
+
+    #[test]
+    fn converts_command_results_to_json() {
+        let raw = RedisRawValue::Array(vec![
+            RedisRawValue::SimpleString("OK".to_string()),
+            RedisRawValue::Int(2),
+            RedisRawValue::Nil,
+        ]);
+
+        assert_eq!(redis_command_raw_to_json(raw), serde_json::json!(["OK", 2, null]));
+    }
+
+    #[test]
+    fn converts_command_unsafe_int64_to_string_for_js() {
+        let raw = RedisRawValue::Int(2_326_645_729_978_441_729);
+
+        assert_eq!(redis_command_raw_to_json(raw), serde_json::json!("2326645729978441729"));
+    }
+
+    #[test]
+    fn converts_bulkstring_json_with_unsafe_int64_for_js() {
+        let raw = RedisRawValue::BulkString(br#"{"uid":2321205972557213697,"name":"test"}"#.to_vec());
+
+        assert_eq!(redis_command_raw_to_json(raw), serde_json::json!({"uid": "2321205972557213697", "name": "test"}));
+    }
+
+    #[test]
+    fn keeps_plain_bulkstring_as_is() {
+        let raw = RedisRawValue::BulkString(b"hello world".to_vec());
+        assert_eq!(redis_command_raw_to_json(raw), serde_json::json!("hello world"));
+    }
+
+    #[test]
+    fn keeps_string_like_number_as_string() {
+        let raw = RedisRawValue::BulkString(b"42".to_vec());
+        assert_eq!(redis_command_raw_to_json(raw), serde_json::json!("42"));
+    }
+
+    #[test]
+    fn recognizes_redis_json_module_key_types() {
+        assert!(is_redis_json_type("ReJSON-RL"));
+        assert!(is_redis_json_type("json"));
+        assert!(!is_redis_json_type("string"));
+    }
+
+    #[test]
+    fn parses_redis_sentinel_endpoints_with_default_ports() {
+        assert_eq!(parse_redis_endpoint("sentinel.local:26380", 26379).unwrap(), ("sentinel.local".to_string(), 26380));
+        assert_eq!(
+            parse_redis_endpoint("redis://user:pass@sentinel.local:26380/0", 26379).unwrap(),
+            ("sentinel.local".to_string(), 26380)
+        );
+        assert_eq!(parse_redis_endpoint("sentinel.local", 26379).unwrap(), ("sentinel.local".to_string(), 26379));
+        assert_eq!(parse_redis_endpoint("[::1]:26380", 26379).unwrap(), ("::1".to_string(), 26380));
+        assert_eq!(parse_redis_endpoint("::1", 26379).unwrap(), ("::1".to_string(), 26379));
+    }
+
+    #[test]
+    fn parses_redis_sentinel_master_lookup_response() {
+        let raw = RedisRawValue::Array(vec![bulk("10.0.0.8"), bulk("6379")]);
+
+        assert_eq!(
+            redis_sentinel_master_endpoint(raw).unwrap(),
+            RedisNodeEndpoint { host: "10.0.0.8".to_string(), port: 6379 }
+        );
+    }
+
+    #[test]
+    fn rejects_invalid_redis_sentinel_master_lookup_response() {
+        let raw = RedisRawValue::Array(vec![bulk("10.0.0.8")]);
+
+        assert_eq!(
+            redis_sentinel_master_endpoint(raw).unwrap_err(),
+            "Redis Sentinel master lookup returned an invalid endpoint"
+        );
+    }
+
+    #[test]
+    fn redis_connection_info_marks_tls_as_insecure_when_requested() {
+        let info = connection_info("cache.example.com", 6379, true, true, "default", "secret", 0);
+
+        assert!(matches!(info.addr, ConnectionAddr::TcpTls { insecure: true, .. }));
+    }
+
+    #[test]
+    fn redis_connection_info_preserves_acl_username_and_password() {
+        let info = connection_info("cache.example.com", 6379, false, false, "app-user", "secret", 0);
+
+        assert_eq!(info.redis.username.as_deref(), Some("app-user"));
+        assert_eq!(info.redis.password.as_deref(), Some("secret"));
+    }
+
+    #[test]
+    fn redis_auth_candidates_try_username_at_password_fallback() {
+        let candidates = redis_auth_candidates("app-user", "secret");
+
+        assert_eq!(
+            candidates,
+            vec![
+                RedisAuthCandidate { username: "app-user".to_string(), password: "secret".to_string() },
+                RedisAuthCandidate { username: String::new(), password: "app-user@secret".to_string() },
+            ]
+        );
+    }
+
+    #[test]
+    fn redis_database_index_uses_numeric_database_only() {
+        let mut config = ConnectionConfig {
+            id: "redis".to_string(),
+            name: "Redis".to_string(),
+            db_type: crate::models::connection::DatabaseType::Redis,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "cache.example.com".to_string(),
+            port: 6379,
+            username: String::new(),
+            password: String::new(),
+            database: Some("4".to_string()),
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: crate::models::connection::default_connect_timeout_secs(),
+            query_timeout_secs: crate::models::connection::default_query_timeout_secs(),
+            idle_timeout_secs: crate::models::connection::default_idle_timeout_secs(),
+            keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: crate::models::connection::default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        };
+
+        assert_eq!(redis_database_index(&config), 4);
+        config.database = Some("not-a-number".to_string());
+        assert_eq!(redis_database_index(&config), 0);
+    }
+
+    #[test]
+    fn encodes_and_decodes_cluster_scan_cursor() {
+        let encoded = encode_cluster_cursor(12, 3456).unwrap();
+
+        assert_eq!(decode_cluster_cursor(encoded), (12, 3456));
+        assert_eq!(decode_cluster_cursor(0), (0, 0));
+    }
+
+    #[test]
+    fn parses_cluster_slots_master_nodes() {
+        let raw = RedisRawValue::Array(vec![
+            RedisRawValue::Array(vec![
+                RedisRawValue::Int(0),
+                RedisRawValue::Int(5460),
+                RedisRawValue::Array(vec![
+                    RedisRawValue::BulkString(b"10.0.0.1".to_vec()),
+                    RedisRawValue::Int(7000),
+                    RedisRawValue::BulkString(b"node-a".to_vec()),
+                ]),
+            ]),
+            RedisRawValue::Array(vec![
+                RedisRawValue::Int(5461),
+                RedisRawValue::Int(10922),
+                RedisRawValue::Array(vec![
+                    RedisRawValue::BulkString(b"10.0.0.2".to_vec()),
+                    RedisRawValue::Int(7001),
+                    RedisRawValue::BulkString(b"node-b".to_vec()),
+                ]),
+            ]),
+        ]);
+
+        assert_eq!(
+            parse_cluster_slots(raw, "127.0.0.1").unwrap(),
+            vec![
+                RedisClusterSlotRange {
+                    start: 0,
+                    end: 5460,
+                    master: RedisNodeEndpoint { host: "10.0.0.1".to_string(), port: 7000 },
+                },
+                RedisClusterSlotRange {
+                    start: 5461,
+                    end: 10922,
+                    master: RedisNodeEndpoint { host: "10.0.0.2".to_string(), port: 7001 },
+                },
+            ]
+        );
+    }
+
+    #[test]
+    fn calculates_redis_cluster_hash_tag_slots() {
+        assert_eq!(redis_cluster_slot(b"issue1246:{user}:a"), redis_cluster_slot(b"issue1246:{user}:b"));
+        assert_ne!(redis_cluster_slot(b"issue1246:{user}:a"), redis_cluster_slot(b"issue1246:{other}:a"));
+    }
+
+    #[test]
+    fn parses_redis_json_get_bulk_string() {
+        let raw = bulk(r#"{"id":1,"embedding":[0.1,0.2],"meta":{"source":"test"}}"#);
+
+        assert_eq!(
+            redis_json_raw_to_json(raw).unwrap(),
+            serde_json::json!({
+                "id": 1,
+                "embedding": [0.1, 0.2],
+                "meta": { "source": "test" }
+            })
+        );
+    }
+
+    #[test]
+    fn parses_redis_json_unsafe_int64_as_string_for_js() {
+        let raw = bulk(r#"{"id":2326645729978441729,"nested":[1,2326645729978441728]}"#);
+
+        assert_eq!(
+            redis_json_raw_to_json(raw).unwrap(),
+            serde_json::json!({
+                "id": "2326645729978441729",
+                "nested": [1, "2326645729978441728"]
+            })
+        );
+    }
+
+    #[test]
+    fn builds_compact_redis_json_value_preview() {
+        let value = serde_json::json!({ "id": 1, "embedding": [0.1, 0.2] });
+
+        assert_eq!(redis_json_value_preview(&value), r#"{"id":1,"embedding":[0.1,0.2]}"#);
+    }
+
+    #[test]
+    fn uses_lightweight_redis_json_placeholder_for_key_scan_preview() {
+        assert_eq!(redis_key_value_preview("ReJSON-RL"), "{...}");
+        assert_eq!(redis_key_value_preview("string"), "");
+    }
+}
diff --git a/crates/dbx-core/src/db/rqlite_driver.rs b/crates/dbx-core/src/db/rqlite_driver.rs
new file mode 100644
index 0000000..f7ace1e
--- /dev/null
+++ b/crates/dbx-core/src/db/rqlite_driver.rs
@@ -0,0 +1,450 @@
+use reqwest::Client as HttpClient;
+use serde::Deserialize;
+use std::time::{Duration, Instant};
+
+use super::{http_client_builder, with_connection_timeout};
+use crate::sql::starts_with_executable_sql_keyword;
+use crate::types::{
+    ColumnInfo, DatabaseInfo, ForeignKeyInfo, IndexInfo, ObjectSource, ObjectSourceKind, QueryResult, TableInfo,
+    TriggerInfo,
+};
+
+#[derive(Clone)]
+pub struct RqliteClient {
+    http: HttpClient,
+    base_url: String,
+    query_params: String,
+    auth: Option<(String, String)>,
+}
+
+impl RqliteClient {
+    pub fn new(
+        url: &str,
+        url_params: Option<&str>,
+        username: &str,
+        password: &str,
+        tls_enabled: bool,
+        timeout: Duration,
+    ) -> Result<Self, String> {
+        let mut builder = http_client_builder(timeout);
+        if rqlite_accept_invalid_certs(tls_enabled, url_params) {
+            builder = builder.danger_accept_invalid_certs(true);
+        }
+        let http = builder.build().map_err(|e| format!("Failed to configure rqlite HTTP client: {e}"))?;
+        let auth = if username.trim().is_empty() { None } else { Some((username.to_string(), password.to_string())) };
+        Ok(Self {
+            http,
+            base_url: url.trim_end_matches('/').split('?').next().unwrap_or(url).to_string(),
+            query_params: normalize_rqlite_url_params(url_params),
+            auth,
+        })
+    }
+
+    fn post_json(&self, path: &str, sql: &str) -> reqwest::RequestBuilder {
+        let req = self.http.post(self.endpoint(path)).json(&[sql]);
+        self.with_auth(req)
+    }
+
+    fn with_auth(&self, req: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
+        if let Some((ref user, ref pass)) = self.auth {
+            req.basic_auth(user, Some(pass))
+        } else {
+            req
+        }
+    }
+
+    fn endpoint(&self, path: &str) -> String {
+        if self.query_params.is_empty() {
+            format!("{}{}", self.base_url, path)
+        } else {
+            format!("{}{}?{}", self.base_url, path, self.query_params)
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+struct RqliteResponse {
+    results: Vec<RqliteResult>,
+}
+
+#[derive(Debug, Deserialize)]
+struct RqliteResult {
+    #[serde(default)]
+    columns: Vec<String>,
+    #[serde(default)]
+    values: Vec<Vec<serde_json::Value>>,
+    #[serde(default)]
+    rows_affected: Option<u64>,
+    #[serde(default)]
+    error: Option<String>,
+}
+
+enum RqliteEndpoint {
+    Query,
+    Execute,
+}
+
+impl RqliteEndpoint {
+    fn path(&self) -> &'static str {
+        match self {
+            Self::Query => "/db/query",
+            Self::Execute => "/db/execute",
+        }
+    }
+}
+
+pub async fn test_connection(client: &RqliteClient, timeout: Duration) -> Result<(), String> {
+    with_connection_timeout("rqlite", timeout, async { query_one(client, "SELECT 1").await.map(|_| ()) }).await
+}
+
+pub async fn list_databases(_client: &RqliteClient) -> Result<Vec<DatabaseInfo>, String> {
+    Ok(vec![DatabaseInfo { name: "main".to_string() }])
+}
+
+pub async fn list_tables(client: &RqliteClient, _schema: &str) -> Result<Vec<TableInfo>, String> {
+    let result = query_one(
+        client,
+        "SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY name",
+    )
+    .await?;
+    Ok(result
+        .values
+        .into_iter()
+        .map(|row| {
+            let table_type = value_as_string(row.get(1)).unwrap_or_else(|| "table".to_string());
+            TableInfo {
+                name: value_as_string(row.first()).unwrap_or_default(),
+                table_type: if table_type.eq_ignore_ascii_case("view") { "VIEW" } else { "BASE TABLE" }.to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            }
+        })
+        .collect())
+}
+
+pub async fn get_columns(client: &RqliteClient, _schema: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let result = query_one(client, &format!("PRAGMA table_info({})", sqlite_ident(table))).await?;
+    Ok(result
+        .values
+        .into_iter()
+        .map(|row| ColumnInfo {
+            name: value_by_column(&result.columns, &row, "name").unwrap_or_default(),
+            data_type: value_by_column(&result.columns, &row, "type").unwrap_or_default(),
+            is_nullable: value_by_column(&result.columns, &row, "notnull")
+                .and_then(|value| value.parse::<i64>().ok())
+                .unwrap_or(0)
+                == 0,
+            column_default: value_by_column(&result.columns, &row, "dflt_value"),
+            is_primary_key: value_by_column(&result.columns, &row, "pk")
+                .and_then(|value| value.parse::<i64>().ok())
+                .unwrap_or(0)
+                > 0,
+            extra: None,
+            comment: None,
+            numeric_precision: None,
+            numeric_scale: None,
+            character_maximum_length: None,
+            enum_values: None,
+            ..Default::default()
+        })
+        .collect())
+}
+
+pub async fn list_indexes(client: &RqliteClient, _schema: &str, table: &str) -> Result<Vec<IndexInfo>, String> {
+    let result = query_one(client, &format!("PRAGMA index_list({})", sqlite_ident(table))).await?;
+    let mut indexes = Vec::new();
+
+    for row in result.values {
+        let name = value_by_column(&result.columns, &row, "name").unwrap_or_default();
+        if name.is_empty() {
+            continue;
+        }
+        let is_unique =
+            value_by_column(&result.columns, &row, "unique").and_then(|value| value.parse::<i64>().ok()).unwrap_or(0)
+                != 0;
+        let origin = value_by_column(&result.columns, &row, "origin").unwrap_or_default();
+        let column_result = query_one(client, &format!("PRAGMA index_info({})", sqlite_ident(&name))).await?;
+        let columns = column_result
+            .values
+            .iter()
+            .filter_map(|row| value_by_column(&column_result.columns, row, "name"))
+            .collect();
+        indexes.push(IndexInfo {
+            name,
+            columns,
+            is_unique,
+            is_primary: origin == "pk",
+            filter: None,
+            index_type: None,
+            included_columns: None,
+            comment: None,
+        });
+    }
+
+    Ok(indexes)
+}
+
+pub async fn list_foreign_keys(
+    client: &RqliteClient,
+    _schema: &str,
+    table: &str,
+) -> Result<Vec<ForeignKeyInfo>, String> {
+    let result = query_one(client, &format!("PRAGMA foreign_key_list({})", sqlite_ident(table))).await?;
+    Ok(result
+        .values
+        .into_iter()
+        .map(|row| ForeignKeyInfo {
+            name: format!("fk_{}", value_by_column(&result.columns, &row, "id").unwrap_or_else(|| "0".to_string())),
+            column: value_by_column(&result.columns, &row, "from").unwrap_or_default(),
+            ref_schema: None,
+            ref_table: value_by_column(&result.columns, &row, "table").unwrap_or_default(),
+            ref_column: value_by_column(&result.columns, &row, "to").unwrap_or_default(),
+            on_update: None,
+            on_delete: None,
+        })
+        .collect())
+}
+
+pub async fn list_triggers(client: &RqliteClient, _schema: &str, table: &str) -> Result<Vec<TriggerInfo>, String> {
+    let result = query_one(
+        client,
+        &format!(
+            "SELECT name, sql FROM sqlite_master WHERE type = 'trigger' AND tbl_name = {} ORDER BY name",
+            sqlite_string(table)
+        ),
+    )
+    .await?;
+    Ok(result
+        .values
+        .into_iter()
+        .map(|row| {
+            let sql_text = value_as_string(row.get(1)).unwrap_or_default().to_uppercase();
+            let timing = if sql_text.contains("BEFORE") {
+                "BEFORE"
+            } else if sql_text.contains("AFTER") {
+                "AFTER"
+            } else {
+                "INSTEAD OF"
+            };
+            let event = if sql_text.contains("INSERT") {
+                "INSERT"
+            } else if sql_text.contains("UPDATE") {
+                "UPDATE"
+            } else {
+                "DELETE"
+            };
+            TriggerInfo {
+                name: value_as_string(row.first()).unwrap_or_default(),
+                event: event.to_string(),
+                timing: timing.to_string(),
+                statement: value_as_string(row.get(1)),
+            }
+        })
+        .collect())
+}
+
+pub async fn table_ddl(client: &RqliteClient, table: &str) -> Result<String, String> {
+    first_string_cell(
+        query_one(
+            client,
+            &format!("SELECT sql FROM sqlite_master WHERE type='table' AND name={}", sqlite_string(table)),
+        )
+        .await?,
+    )
+}
+
+pub async fn object_source(
+    client: &RqliteClient,
+    name: &str,
+    object_type: &ObjectSourceKind,
+) -> Result<ObjectSource, String> {
+    let kind = match object_type {
+        ObjectSourceKind::View => "view",
+        _ => return Err("Object source is not supported for this rqlite object type".to_string()),
+    };
+    let source = first_string_cell(
+        query_one(
+            client,
+            &format!(
+                "SELECT sql FROM sqlite_master WHERE type={} AND name={}",
+                sqlite_string(kind),
+                sqlite_string(name)
+            ),
+        )
+        .await?,
+    )?;
+    Ok(ObjectSource { name: name.to_string(), object_type: object_type.clone(), schema: None, source, editable: None })
+}
+
+pub async fn execute_query(client: &RqliteClient, sql: &str) -> Result<QueryResult, String> {
+    execute_query_with_max_rows(client, sql, None).await
+}
+
+pub async fn execute_query_with_max_rows(
+    client: &RqliteClient,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<QueryResult, String> {
+    let start = Instant::now();
+    if starts_with_executable_sql_keyword(sql, &["SELECT", "PRAGMA", "EXPLAIN", "WITH"]) {
+        let result = query_one(client, sql).await?;
+        Ok(query_result_from_rqlite_result(result, start.elapsed().as_millis(), max_rows))
+    } else {
+        let result = execute_one(client, sql).await?;
+        let affected_rows = result.rows_affected.unwrap_or(0);
+        Ok(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    }
+}
+
+async fn query_one(client: &RqliteClient, sql: &str) -> Result<RqliteResult, String> {
+    request_one(client, RqliteEndpoint::Query, sql).await
+}
+
+async fn execute_one(client: &RqliteClient, sql: &str) -> Result<RqliteResult, String> {
+    request_one(client, RqliteEndpoint::Execute, sql).await
+}
+
+async fn request_one(client: &RqliteClient, endpoint: RqliteEndpoint, sql: &str) -> Result<RqliteResult, String> {
+    let resp =
+        client.post_json(endpoint.path(), sql).send().await.map_err(|e| format!("rqlite request failed: {e}"))?;
+    let status = resp.status();
+    let body = resp.text().await.map_err(|e| format!("rqlite response read failed: {e}"))?;
+    if !status.is_success() {
+        return Err(format!("rqlite error ({status}): {body}"));
+    }
+    let response: RqliteResponse =
+        serde_json::from_str(&body).map_err(|e| format!("rqlite parse error: {e}; body: {body}"))?;
+    let result = response.results.into_iter().next().ok_or_else(|| "rqlite returned no result".to_string())?;
+    if let Some(error) = result.error.as_ref().filter(|error| !error.is_empty()) {
+        return Err(format!("rqlite error: {error}"));
+    }
+    Ok(result)
+}
+
+fn query_result_from_rqlite_result(
+    mut result: RqliteResult,
+    execution_time_ms: u128,
+    max_rows: Option<usize>,
+) -> QueryResult {
+    let row_limit = max_rows.unwrap_or(crate::query::MAX_ROWS).max(1);
+    let truncated = result.values.len() > row_limit;
+    if truncated {
+        result.values.truncate(row_limit);
+    }
+    QueryResult {
+        columns: result.columns,
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: result.values,
+        affected_rows: 0,
+        execution_time_ms,
+        truncated,
+        session_id: None,
+        has_more: false,
+    }
+}
+
+fn first_string_cell(result: RqliteResult) -> Result<String, String> {
+    result
+        .values
+        .first()
+        .and_then(|row| row.first())
+        .and_then(|value| value_as_string(Some(value)))
+        .ok_or_else(|| "Object not found".to_string())
+}
+
+fn value_by_column(columns: &[String], row: &[serde_json::Value], name: &str) -> Option<String> {
+    columns
+        .iter()
+        .position(|column| column.eq_ignore_ascii_case(name))
+        .and_then(|index| row.get(index))
+        .and_then(|value| value_as_string(Some(value)))
+}
+
+fn value_as_string(value: Option<&serde_json::Value>) -> Option<String> {
+    match value? {
+        serde_json::Value::Null => None,
+        serde_json::Value::String(value) => Some(value.clone()),
+        serde_json::Value::Number(value) => Some(value.to_string()),
+        serde_json::Value::Bool(value) => Some(value.to_string()),
+        other => Some(other.to_string()),
+    }
+}
+
+fn sqlite_ident(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+fn sqlite_string(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+fn normalize_rqlite_url_params(params: Option<&str>) -> String {
+    params
+        .unwrap_or("")
+        .trim()
+        .trim_start_matches('?')
+        .split('&')
+        .filter(|part| !part.is_empty())
+        .collect::<Vec<_>>()
+        .join("&")
+}
+
+fn rqlite_accept_invalid_certs(tls_enabled: bool, url_params: Option<&str>) -> bool {
+    tls_enabled
+        && url_params
+            .unwrap_or("")
+            .trim()
+            .trim_start_matches('?')
+            .split('&')
+            .filter_map(|pair| pair.split_once('='))
+            .any(|(key, value)| {
+                matches!(key.trim().to_ascii_lowercase().as_str(), "insecure" | "tls_insecure" | "accept_invalid_certs")
+                    && matches!(value.trim().to_ascii_lowercase().as_str(), "true" | "1" | "yes" | "on")
+            })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn converts_query_result_and_truncates_probe_rows() {
+        let result = RqliteResult {
+            columns: vec!["id".to_string(), "name".to_string()],
+            values: vec![
+                vec![serde_json::json!(1), serde_json::json!("Ada")],
+                vec![serde_json::json!(2), serde_json::json!("Linus")],
+            ],
+            rows_affected: None,
+            error: None,
+        };
+
+        let result = query_result_from_rqlite_result(result, 8, Some(1));
+
+        assert_eq!(result.columns, vec!["id", "name"]);
+        assert_eq!(result.rows, vec![vec![serde_json::json!(1), serde_json::json!("Ada")]]);
+        assert_eq!(result.execution_time_ms, 8);
+        assert!(result.truncated);
+    }
+
+    #[test]
+    fn maps_column_values_by_name() {
+        let columns = vec!["name".to_string(), "notnull".to_string(), "pk".to_string()];
+        let row = vec![serde_json::json!("id"), serde_json::json!(1), serde_json::json!(1)];
+
+        assert_eq!(value_by_column(&columns, &row, "NAME").as_deref(), Some("id"));
+        assert_eq!(value_by_column(&columns, &row, "notnull").as_deref(), Some("1"));
+    }
+}
diff --git a/crates/dbx-core/src/db/sqlite.rs b/crates/dbx-core/src/db/sqlite.rs
new file mode 100644
index 0000000..34ef2dc
--- /dev/null
+++ b/crates/dbx-core/src/db/sqlite.rs
@@ -0,0 +1,2258 @@
+use percent_encoding::percent_decode_str;
+use rusqlite::functions::{Context, FunctionFlags};
+use rusqlite::types::{Value, ValueRef};
+use rusqlite::{Connection, LoadExtensionGuard, OpenFlags};
+use std::collections::HashSet;
+use std::io::Read;
+use std::path::Path;
+use std::sync::{Arc, Mutex};
+use std::time::Instant;
+
+use super::file_validator::validate_file_path;
+use crate::sql::starts_with_executable_sql_keyword;
+use crate::types::{
+    ColumnInfo, CompletionAssistantCandidate, CompletionAssistantCandidateKind, CompletionAssistantMatchMode,
+    CompletionAssistantObjectKind, CompletionAssistantRequest, CompletionAssistantResponse, DatabaseInfo,
+    ForeignKeyInfo, IndexInfo, QueryResult, TableInfo, TriggerInfo,
+};
+
+const SQLITE_DATABASE_HEADER: &[u8; 16] = b"SQLite format 3\0";
+
+#[derive(Clone)]
+pub struct SqliteHandle {
+    conn: Arc<Mutex<Connection>>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SqliteExtensionSpec {
+    pub path: String,
+    pub entry_point: Option<String>,
+}
+
+impl SqliteHandle {
+    pub fn with_connection<T, F>(&self, f: F) -> Result<T, String>
+    where
+        F: FnOnce(&mut Connection) -> Result<T, String>,
+    {
+        let mut conn = self.conn.lock().map_err(|e| e.to_string())?;
+        f(&mut conn)
+    }
+}
+
+pub async fn connect_path(path: &str) -> Result<SqliteHandle, String> {
+    connect_path_with_options(path, false, None, Vec::new()).await
+}
+
+pub async fn connect_path_with_extensions(
+    path: &str,
+    extensions: Vec<SqliteExtensionSpec>,
+) -> Result<SqliteHandle, String> {
+    connect_path_with_options(path, false, None, extensions).await
+}
+
+pub async fn connect_path_with_cipher_key_and_extensions(
+    path: &str,
+    cipher_key: &str,
+    extensions: Vec<SqliteExtensionSpec>,
+) -> Result<SqliteHandle, String> {
+    connect_path_with_options(path, false, sqlite_cipher_key(cipher_key), extensions).await
+}
+
+pub async fn connect_path_create_if_missing(path: &str) -> Result<SqliteHandle, String> {
+    connect_path_with_options(path, true, None, Vec::new()).await
+}
+
+pub async fn connect_path_create_if_missing_with_extensions(
+    path: &str,
+    extensions: Vec<SqliteExtensionSpec>,
+) -> Result<SqliteHandle, String> {
+    connect_path_with_options(path, true, None, extensions).await
+}
+
+pub async fn connect_path_create_if_missing_with_cipher_key(
+    path: &str,
+    cipher_key: &str,
+) -> Result<SqliteHandle, String> {
+    connect_path_with_options(path, true, sqlite_cipher_key(cipher_key), Vec::new()).await
+}
+
+async fn connect_path_with_options(
+    path: &str,
+    create_if_missing: bool,
+    cipher_key: Option<String>,
+    extensions: Vec<SqliteExtensionSpec>,
+) -> Result<SqliteHandle, String> {
+    let path = path.to_string();
+    tokio::task::spawn_blocking(move || open_sqlite_handle(&path, create_if_missing, cipher_key, extensions))
+        .await
+        .map_err(|e| e.to_string())?
+}
+
+fn open_sqlite_handle(
+    path: &str,
+    create_if_missing: bool,
+    cipher_key: Option<String>,
+    extensions: Vec<SqliteExtensionSpec>,
+) -> Result<SqliteHandle, String> {
+    let is_memory = is_memory_database_path(path);
+    let encrypted = cipher_key.as_deref().is_some_and(|key| !key.is_empty());
+    ensure_sqlcipher_available(encrypted)?;
+    if !is_memory && !create_if_missing {
+        validate_file_path(path, is_network_path)?;
+    }
+
+    if !is_memory && create_if_missing {
+        ensure_parent_dir(path)?;
+    }
+    if !is_memory && !is_network_path(path) && !encrypted {
+        validate_existing_sqlite_file(path)?;
+    }
+
+    let sqlcipher_attempts: &[Option<i64>] = if encrypted { &[None, Some(3), Some(2), Some(1)] } else { &[None] };
+    let mut unlock_error: Option<String> = None;
+
+    for compatibility in sqlcipher_attempts {
+        let conn = open_sqlite_connection(path, create_if_missing)?;
+        if let Err(err) = apply_sqlcipher_key(&conn, cipher_key.as_deref(), *compatibility) {
+            unlock_error = Some(err);
+            continue;
+        }
+        conn.busy_timeout(std::time::Duration::from_secs(10)).map_err(|e| e.to_string())?;
+        load_sqlite_extensions(&conn, &extensions)?;
+        register_sqlite_compat_functions(&conn)?;
+
+        return Ok(SqliteHandle { conn: Arc::new(Mutex::new(conn)) });
+    }
+
+    Err(unlock_error.unwrap_or_else(|| "SQLCipher database unlock failed.".to_string()))
+}
+
+fn open_sqlite_connection(path: &str, create_if_missing: bool) -> Result<Connection, String> {
+    if is_memory_database_path(path) {
+        return Connection::open_in_memory().map_err(|e| format!("SQLite connection failed: {e}"));
+    }
+
+    let mut flags = OpenFlags::SQLITE_OPEN_READ_WRITE;
+    if create_if_missing {
+        flags |= OpenFlags::SQLITE_OPEN_CREATE;
+    }
+    if is_network_path(path) {
+        flags |= OpenFlags::SQLITE_OPEN_URI;
+        Connection::open_with_flags(sqlite_network_path_uri(path), flags)
+            .map_err(|e| format!("SQLite connection failed: {e}"))
+    } else {
+        Connection::open_with_flags(path, flags).map_err(|e| format!("SQLite connection failed: {e}"))
+    }
+}
+
+fn sqlite_cipher_key(cipher_key: &str) -> Option<String> {
+    if cipher_key.is_empty() {
+        None
+    } else {
+        Some(cipher_key.to_string())
+    }
+}
+
+#[cfg(feature = "sqlite-sqlcipher")]
+fn ensure_sqlcipher_available(_encrypted: bool) -> Result<(), String> {
+    Ok(())
+}
+
+#[cfg(not(feature = "sqlite-sqlcipher"))]
+fn ensure_sqlcipher_available(encrypted: bool) -> Result<(), String> {
+    if encrypted {
+        Err("SQLCipher support is not compiled in this build. Rebuild with the sqlite-sqlcipher feature.".to_string())
+    } else {
+        Ok(())
+    }
+}
+
+#[cfg(feature = "sqlite-sqlcipher")]
+fn apply_sqlcipher_key(conn: &Connection, cipher_key: Option<&str>, compatibility: Option<i64>) -> Result<(), String> {
+    let Some(cipher_key) = cipher_key.filter(|key| !key.is_empty()) else {
+        return Ok(());
+    };
+
+    // SQLCipher requires the key before the first schema read; the verification
+    // query turns wrong keys into an immediate connection error.
+    conn.pragma_update(None, "key", cipher_key).map_err(|e| format!("SQLCipher key setup failed: {e}"))?;
+    if let Some(compatibility) = compatibility {
+        conn.pragma_update(None, "cipher_compatibility", compatibility)
+            .map_err(|e| format!("SQLCipher compatibility setup failed: {e}"))?;
+    }
+    verify_sqlcipher_key(conn)
+        .map_err(|e| format!("SQLCipher database unlock failed. Check the SQLite password/key and file type: {e}"))?;
+    Ok(())
+}
+
+#[cfg(not(feature = "sqlite-sqlcipher"))]
+fn apply_sqlcipher_key(
+    _conn: &Connection,
+    _cipher_key: Option<&str>,
+    _compatibility: Option<i64>,
+) -> Result<(), String> {
+    Ok(())
+}
+
+#[cfg(feature = "sqlite-sqlcipher")]
+fn verify_sqlcipher_key(conn: &Connection) -> Result<(), rusqlite::Error> {
+    conn.query_row("SELECT count(*) FROM sqlite_master", [], |_| Ok(()))
+}
+
+fn register_sqlite_compat_functions(conn: &Connection) -> Result<(), String> {
+    let flags = FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC | FunctionFlags::SQLITE_INNOCUOUS;
+
+    if !sqlite_function_available(conn, "SELECT if(1, 2, 3)") {
+        conn.create_scalar_function("if", -1, flags, sqlite_if)
+            .map_err(|e| format!("SQLite compatibility function registration failed (if): {e}"))?;
+    }
+    if !sqlite_function_available(conn, "SELECT unistr('')") {
+        conn.create_scalar_function("unistr", 1, flags, sqlite_unistr)
+            .map_err(|e| format!("SQLite compatibility function registration failed (unistr): {e}"))?;
+    }
+
+    Ok(())
+}
+
+fn sqlite_function_available(conn: &Connection, sql: &str) -> bool {
+    conn.query_row(sql, [], |_| Ok(())).is_ok()
+}
+
+fn sqlite_if(ctx: &Context<'_>) -> rusqlite::Result<Value> {
+    if ctx.len() < 2 {
+        return Err(sqlite_function_error("if() requires at least two arguments"));
+    }
+
+    let mut i = 0;
+    while i + 1 < ctx.len() {
+        if sqlite_truthy(ctx.get_raw(i)) {
+            return Ok(sqlite_value_ref_to_owned(ctx.get_raw(i + 1)));
+        }
+        i += 2;
+    }
+
+    if ctx.len() % 2 == 1 {
+        Ok(sqlite_value_ref_to_owned(ctx.get_raw(ctx.len() - 1)))
+    } else {
+        Ok(Value::Null)
+    }
+}
+
+fn sqlite_unistr(ctx: &Context<'_>) -> rusqlite::Result<Value> {
+    let input = match ctx.get_raw(0) {
+        ValueRef::Null => return Ok(Value::Null),
+        ValueRef::Integer(value) => value.to_string(),
+        ValueRef::Real(value) => value.to_string(),
+        ValueRef::Text(value) | ValueRef::Blob(value) => String::from_utf8_lossy(value).into_owned(),
+    };
+
+    sqlite_unistr_text(&input).map(Value::Text)
+}
+
+fn sqlite_truthy(value: ValueRef<'_>) -> bool {
+    match value {
+        ValueRef::Null => false,
+        ValueRef::Integer(value) => value != 0,
+        ValueRef::Real(value) => value != 0.0,
+        ValueRef::Text(value) | ValueRef::Blob(value) => sqlite_text_numeric_truthy(&String::from_utf8_lossy(value)),
+    }
+}
+
+fn sqlite_text_numeric_truthy(text: &str) -> bool {
+    let trimmed = text.trim_start();
+    for end in (1..=trimmed.len()).rev() {
+        if trimmed.is_char_boundary(end) {
+            if let Ok(value) = trimmed[..end].parse::<f64>() {
+                return value != 0.0;
+            }
+        }
+    }
+    false
+}
+
+fn sqlite_value_ref_to_owned(value: ValueRef<'_>) -> Value {
+    match value {
+        ValueRef::Null => Value::Null,
+        ValueRef::Integer(value) => Value::Integer(value),
+        ValueRef::Real(value) => Value::Real(value),
+        ValueRef::Text(value) => Value::Text(String::from_utf8_lossy(value).into_owned()),
+        ValueRef::Blob(value) => Value::Blob(value.to_vec()),
+    }
+}
+
+fn sqlite_unistr_text(input: &str) -> rusqlite::Result<String> {
+    let chars: Vec<char> = input.chars().collect();
+    let mut result = String::with_capacity(input.len());
+    let mut i = 0;
+
+    while i < chars.len() {
+        if chars[i] != '\\' {
+            result.push(chars[i]);
+            i += 1;
+            continue;
+        }
+
+        if i + 1 >= chars.len() {
+            result.push('\\');
+            i += 1;
+            continue;
+        }
+
+        match chars[i + 1] {
+            '\\' => {
+                result.push('\\');
+                i += 2;
+            }
+            '+' => {
+                if let Some(ch) = sqlite_unistr_codepoint(&chars, i + 2, 6)? {
+                    result.push(ch);
+                    i += 8;
+                } else {
+                    result.push('\\');
+                    i += 1;
+                }
+            }
+            'u' => {
+                if let Some(ch) = sqlite_unistr_codepoint(&chars, i + 2, 4)? {
+                    result.push(ch);
+                    i += 6;
+                } else {
+                    result.push('\\');
+                    i += 1;
+                }
+            }
+            'U' => {
+                if let Some(ch) = sqlite_unistr_codepoint(&chars, i + 2, 8)? {
+                    result.push(ch);
+                    i += 10;
+                } else {
+                    result.push('\\');
+                    i += 1;
+                }
+            }
+            _ => {
+                if let Some(ch) = sqlite_unistr_codepoint(&chars, i + 1, 4)? {
+                    result.push(ch);
+                    i += 5;
+                } else {
+                    result.push('\\');
+                    i += 1;
+                }
+            }
+        }
+    }
+
+    Ok(result)
+}
+
+fn sqlite_unistr_codepoint(chars: &[char], start: usize, digits: usize) -> rusqlite::Result<Option<char>> {
+    if start + digits > chars.len() {
+        return Ok(None);
+    }
+
+    let mut value = 0_u32;
+    for ch in &chars[start..start + digits] {
+        let Some(digit) = ch.to_digit(16) else {
+            return Ok(None);
+        };
+        value = (value << 4) | digit;
+    }
+
+    std::char::from_u32(value)
+        .map(Some)
+        .ok_or_else(|| sqlite_function_error(format!("invalid Unicode codepoint: {value:#X}")))
+}
+
+fn sqlite_function_error(message: impl Into<String>) -> rusqlite::Error {
+    rusqlite::Error::UserFunctionError(Box::new(std::io::Error::new(std::io::ErrorKind::InvalidInput, message.into())))
+}
+
+pub fn path_has_sqlite_header(path: &Path) -> Result<bool, String> {
+    let mut file = std::fs::File::open(path).map_err(|e| format!("failed to open file: {e}"))?;
+    let mut header = [0_u8; 16];
+    match file.read_exact(&mut header) {
+        Ok(()) => Ok(&header == SQLITE_DATABASE_HEADER),
+        Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => Ok(false),
+        Err(e) => Err(format!("failed to read file header: {e}")),
+    }
+}
+
+fn validate_existing_sqlite_file(path: &str) -> Result<(), String> {
+    let path = Path::new(path);
+    if !path.exists() {
+        return Ok(());
+    }
+    let metadata = path.metadata().map_err(|e| format!("failed to inspect SQLite database file: {e}"))?;
+    if metadata.len() == 0 {
+        return Ok(());
+    }
+    if path_has_sqlite_header(path)? {
+        return Ok(());
+    }
+    Err("Selected file is not a valid SQLite database file.".to_string())
+}
+
+fn load_sqlite_extensions(conn: &Connection, extensions: &[SqliteExtensionSpec]) -> Result<(), String> {
+    if extensions.is_empty() {
+        return Ok(());
+    }
+
+    // Extension loading is enabled only for the trusted paths from the connection config.
+    let _guard =
+        unsafe { LoadExtensionGuard::new(conn) }.map_err(|e| format!("SQLite extension loading failed: {e}"))?;
+    for extension in extensions {
+        unsafe { conn.load_extension(&extension.path, extension.entry_point.as_deref()) }
+            .map_err(|e| format!("SQLite extension load failed ({}): {e}", extension.path))?;
+    }
+    Ok(())
+}
+
+pub fn sqlite_extension_specs_from_url_params(params: Option<&str>) -> Vec<SqliteExtensionSpec> {
+    params
+        .unwrap_or("")
+        .trim()
+        .trim_start_matches('?')
+        .split('&')
+        .filter_map(|part| {
+            let (raw_key, raw_value) = part.split_once('=').unwrap_or((part, ""));
+            let key = decode_url_param(raw_key);
+            if key != "sqlite_extension" && key != "sqlite_extensions" {
+                return None;
+            }
+            Some(decode_url_param(raw_value))
+        })
+        .flat_map(|value| value.lines().filter_map(parse_sqlite_extension_spec).collect::<Vec<_>>())
+        .collect()
+}
+
+fn parse_sqlite_extension_spec(value: &str) -> Option<SqliteExtensionSpec> {
+    let value = value.trim();
+    if value.is_empty() {
+        return None;
+    }
+    let (path, entry_point) = match value.rsplit_once('|') {
+        Some((path, entry_point)) if !path.trim().is_empty() && !entry_point.trim().is_empty() => {
+            (path.trim(), Some(entry_point.trim().to_string()))
+        }
+        _ => (value, None),
+    };
+    Some(SqliteExtensionSpec { path: path.to_string(), entry_point })
+}
+
+fn decode_url_param(value: &str) -> String {
+    percent_decode_str(&value.replace('+', " ")).decode_utf8_lossy().into_owned()
+}
+
+fn ensure_parent_dir(path: &str) -> Result<(), String> {
+    if let Some(parent) = Path::new(path).parent() {
+        if !parent.as_os_str().is_empty() {
+            std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+        }
+    }
+    Ok(())
+}
+
+fn is_network_path(path: &str) -> bool {
+    path.starts_with("\\\\") || path.starts_with("//") || path.contains("wsl.localhost") || path.contains("wsl$")
+}
+
+fn sqlite_network_path_uri(path: &str) -> String {
+    let (path_and_query, fragment) =
+        path.split_once('#').map_or((path, None), |(prefix, suffix)| (prefix, Some(suffix)));
+    let (file_path, query) = path_and_query.split_once('?').unwrap_or((path_and_query, ""));
+    let mut query = query.to_string();
+    if !sqlite_uri_query_has_param(&query, "nolock") {
+        if !query.is_empty() {
+            query.push('&');
+        }
+        // UNC/WSL shares may not support SQLite byte-range locks reliably. Use
+        // the cross-platform URI flag; unix-nolock is unavailable on Windows.
+        query.push_str("nolock=1");
+    }
+
+    let mut uri = format!("file:{file_path}");
+    if !query.is_empty() {
+        uri.push('?');
+        uri.push_str(&query);
+    }
+    if let Some(fragment) = fragment {
+        uri.push('#');
+        uri.push_str(fragment);
+    }
+    uri
+}
+
+fn sqlite_uri_query_has_param(query: &str, name: &str) -> bool {
+    query.split('&').any(|part| {
+        let key = part.split_once('=').map_or(part, |(key, _)| key);
+        key.eq_ignore_ascii_case(name)
+    })
+}
+
+pub fn is_memory_database_path(path: &str) -> bool {
+    path.trim().eq_ignore_ascii_case(":memory:")
+}
+
+#[cfg(test)]
+#[allow(clippy::items_after_test_module)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn connect_path_supports_memory_database_across_statements() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+
+        execute_query(&pool, "CREATE TABLE memory_probe (id INTEGER PRIMARY KEY, name TEXT);")
+            .await
+            .expect("create table");
+        execute_query(&pool, "INSERT INTO memory_probe (name) VALUES ('Ada');").await.expect("insert row");
+        let result = execute_query(&pool, "SELECT name FROM memory_probe WHERE id = 1;").await.expect("select row");
+
+        assert_eq!(result.rows[0][0], serde_json::json!("Ada"));
+    }
+
+    #[tokio::test]
+    async fn text_affinity_blob_bytes_display_as_utf8_text() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+
+        execute_query(
+            &pool,
+            "CREATE TABLE goods (data TEXT); INSERT INTO goods (data) VALUES (X'7b227469746c65223a22e4b8ade69687227d');",
+        )
+        .await
+        .expect("insert blob-backed JSON into TEXT column");
+        let result = execute_query(&pool, "SELECT data FROM goods").await.expect("select data");
+
+        assert_eq!(result.rows[0][0], serde_json::json!(r#"{"title":"中文"}"#));
+    }
+
+    #[tokio::test]
+    async fn blob_declared_columns_stay_hex_encoded() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+
+        execute_query(
+            &pool,
+            "CREATE TABLE goods (data BLOB); INSERT INTO goods (data) VALUES (X'7b227469746c65223a22e4b8ade69687227d');",
+        )
+        .await
+        .expect("insert blob-backed JSON into BLOB column");
+        let result = execute_query(&pool, "SELECT data FROM goods").await.expect("select data");
+
+        assert_eq!(result.rows[0][0], serde_json::json!("0x7b227469746c65223a22e4b8ade69687227d"));
+    }
+
+    #[tokio::test]
+    async fn create_if_missing_rejects_existing_non_sqlite_file() {
+        let path = std::env::temp_dir().join(format!("dbx-not-sqlite-{}.png", uuid::Uuid::new_v4()));
+        std::fs::write(&path, b"\x89PNG\r\n\x1a\nnot sqlite").unwrap();
+
+        let err = match connect_path_create_if_missing(path.to_str().unwrap()).await {
+            Ok(_) => panic!("non-SQLite file should be rejected"),
+            Err(err) => err,
+        };
+
+        assert!(err.contains("not a valid SQLite database"));
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[tokio::test]
+    async fn create_if_missing_allows_empty_custom_suffix_file() {
+        let path = std::env::temp_dir().join(format!("dbx-empty-sqlite-{}.conf", uuid::Uuid::new_v4()));
+        std::fs::write(&path, b"").unwrap();
+
+        let pool = connect_path_create_if_missing(path.to_str().unwrap()).await.expect("empty file can become SQLite");
+        execute_query(&pool, "CREATE TABLE t (id INTEGER);").await.expect("write sqlite schema");
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[tokio::test]
+    async fn create_if_missing_allows_sqlite_database_with_custom_suffix() {
+        let path = std::env::temp_dir().join(format!("dbx-custom-sqlite-{}.conf", uuid::Uuid::new_v4()));
+        {
+            let pool = connect_path_create_if_missing(path.to_str().unwrap()).await.expect("create sqlite");
+            execute_query(&pool, "CREATE TABLE t (id INTEGER);").await.expect("write sqlite schema");
+        }
+
+        let reopened = connect_path_create_if_missing(path.to_str().unwrap()).await.expect("reopen sqlite");
+        let result = execute_query(&reopened, "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 't';")
+            .await
+            .expect("query sqlite schema");
+        assert_eq!(result.rows[0][0], serde_json::json!("t"));
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[cfg(feature = "sqlite-sqlcipher")]
+    #[tokio::test]
+    async fn sqlcipher_key_creates_and_reopens_encrypted_database() {
+        let path = std::env::temp_dir().join(format!("dbx-sqlcipher-{}.db", uuid::Uuid::new_v4()));
+        let key = "secret key";
+
+        {
+            let pool = connect_path_create_if_missing_with_cipher_key(path.to_str().unwrap(), key)
+                .await
+                .expect("create encrypted sqlite");
+            execute_query(&pool, "CREATE TABLE t (name TEXT); INSERT INTO t VALUES ('encrypted');")
+                .await
+                .expect("write encrypted sqlite");
+        }
+
+        assert!(!path_has_sqlite_header(&path).expect("inspect encrypted header"));
+
+        let reopened = connect_path_with_cipher_key_and_extensions(path.to_str().unwrap(), key, Vec::new())
+            .await
+            .expect("reopen encrypted sqlite");
+        let result = execute_query(&reopened, "SELECT name FROM t").await.expect("read encrypted sqlite");
+        assert_eq!(result.rows[0][0], serde_json::json!("encrypted"));
+
+        let wrong_key =
+            match connect_path_with_cipher_key_and_extensions(path.to_str().unwrap(), "wrong key", Vec::new()).await {
+                Ok(_) => panic!("wrong key must fail"),
+                Err(err) => err,
+            };
+        assert!(wrong_key.contains("SQLCipher database unlock failed"));
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[cfg(feature = "sqlite-sqlcipher")]
+    #[tokio::test]
+    async fn sqlcipher_key_opens_legacy_compatible_database() {
+        let path = std::env::temp_dir().join(format!("dbx-sqlcipher-legacy-{}.db", uuid::Uuid::new_v4()));
+        let key = "legacy key";
+
+        {
+            let conn =
+                Connection::open_with_flags(&path, OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE)
+                    .expect("create legacy-compatible encrypted sqlite");
+            conn.pragma_update(None, "key", key).expect("set SQLCipher key");
+            conn.pragma_update(None, "cipher_compatibility", 3).expect("set SQLCipher compatibility");
+            conn.execute_batch("CREATE TABLE t (name TEXT); INSERT INTO t VALUES ('legacy');")
+                .expect("write legacy-compatible encrypted sqlite");
+        }
+
+        let reopened = connect_path_with_cipher_key_and_extensions(path.to_str().unwrap(), key, Vec::new())
+            .await
+            .expect("reopen legacy-compatible encrypted sqlite");
+        let result =
+            execute_query(&reopened, "SELECT name FROM t").await.expect("read legacy-compatible encrypted sqlite");
+        assert_eq!(result.rows[0][0], serde_json::json!("legacy"));
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[cfg(not(feature = "sqlite-sqlcipher"))]
+    #[tokio::test]
+    async fn sqlcipher_key_requires_sqlcipher_feature() {
+        let err =
+            match connect_path_with_cipher_key_and_extensions("/tmp/dbx-missing-sqlcipher.db", "secret", Vec::new())
+                .await
+            {
+                Ok(_) => panic!("SQLCipher key should require feature support"),
+                Err(err) => err,
+            };
+
+        assert!(err.contains("SQLCipher support is not compiled"));
+    }
+
+    #[test]
+    fn sqlite_extension_specs_parse_repeated_and_multiline_url_params() {
+        let params = "cache=shared&sqlite_extension=%2Fopt%2Fregexp.dylib&sqlite_extensions=%2Fopt%2Ftext.dylib%7Csqlite3_text_init%0A%2Fopt%2Fcrypto.dylib";
+
+        assert_eq!(
+            sqlite_extension_specs_from_url_params(Some(params)),
+            vec![
+                SqliteExtensionSpec { path: "/opt/regexp.dylib".to_string(), entry_point: None },
+                SqliteExtensionSpec {
+                    path: "/opt/text.dylib".to_string(),
+                    entry_point: Some("sqlite3_text_init".to_string()),
+                },
+                SqliteExtensionSpec { path: "/opt/crypto.dylib".to_string(), entry_point: None },
+            ],
+        );
+    }
+
+    #[test]
+    fn sqlite_extension_specs_ignore_empty_values() {
+        assert!(sqlite_extension_specs_from_url_params(Some("sqlite_extension=&sqlite_extensions=%0A")).is_empty());
+    }
+
+    #[test]
+    fn sqlite_network_path_uri_uses_cross_platform_nolock() {
+        let path = r"\\wsl.localhost\Ubuntu\home\app\data.db";
+
+        assert_eq!(sqlite_network_path_uri(path), r"file:\\wsl.localhost\Ubuntu\home\app\data.db?nolock=1");
+    }
+
+    #[test]
+    fn sqlite_network_path_uri_appends_nolock_to_existing_query() {
+        let path = r"\\wsl.localhost\Ubuntu\home\app\data.db?cache=shared";
+
+        assert_eq!(
+            sqlite_network_path_uri(path),
+            r"file:\\wsl.localhost\Ubuntu\home\app\data.db?cache=shared&nolock=1"
+        );
+    }
+
+    #[test]
+    fn sqlite_network_path_uri_preserves_explicit_nolock_query() {
+        let path = r"\\wsl.localhost\Ubuntu\home\app\data.db?nolock=1&cache=shared";
+
+        assert_eq!(
+            sqlite_network_path_uri(path),
+            r"file:\\wsl.localhost\Ubuntu\home\app\data.db?nolock=1&cache=shared"
+        );
+    }
+
+    #[test]
+    fn normalize_if_to_iif_basic() {
+        assert_eq!(normalize_sqlite_sql("SELECT if(1, 'a', 'b')"), "SELECT IIF(1, 'a', 'b')");
+        assert_eq!(normalize_sqlite_sql("SELECT if(1, if(0, 'x', 'y'), 'b')"), "SELECT IIF(1, IIF(0, 'x', 'y'), 'b')");
+    }
+
+    #[test]
+    fn normalize_substring_to_substr() {
+        assert_eq!(normalize_sqlite_sql("SELECT substring(name, 1, 3) FROM t"), "SELECT substr(name, 1, 3) FROM t");
+        assert_eq!(normalize_sqlite_sql("SELECT substring(name, 2) FROM t"), "SELECT substr(name, 2) FROM t");
+    }
+
+    #[test]
+    fn normalize_preserves_string_literals() {
+        let sql = "SELECT 'if(1,2,3)' AS literal, 'substring(x,1,2)', if(1, 'ok', 'no')";
+        let normalized = normalize_sqlite_sql(sql);
+        assert_eq!(normalized, "SELECT 'if(1,2,3)' AS literal, 'substring(x,1,2)', IIF(1, 'ok', 'no')");
+    }
+
+    #[test]
+    fn normalize_preserves_line_comments() {
+        let sql = "-- if(1,2,3) is a comment\nSELECT if(1, 'x', 'y')";
+        let normalized = normalize_sqlite_sql(sql);
+        assert_eq!(normalized, "-- if(1,2,3) is a comment\nSELECT IIF(1, 'x', 'y')");
+    }
+
+    #[test]
+    fn normalize_preserves_block_comments() {
+        let sql = "/* if(1,2,3) */ SELECT if(1, 'x', 'y')";
+        let normalized = normalize_sqlite_sql(sql);
+        assert_eq!(normalized, "/* if(1,2,3) */ SELECT IIF(1, 'x', 'y')");
+    }
+
+    #[test]
+    fn normalize_does_not_match_inside_words() {
+        let sql = "SELECT difference, stiff, ifsubstring FROM t";
+        let normalized = normalize_sqlite_sql(sql);
+        assert_eq!(normalized, sql);
+    }
+
+    #[test]
+    fn normalize_if_with_spaces_before_paren() {
+        assert_eq!(normalize_sqlite_sql("SELECT if  (1, 'a', 'b')"), "SELECT IIF  (1, 'a', 'b')");
+    }
+
+    #[test]
+    fn sqlite_unistr_decodes_documented_escapes() {
+        assert_eq!(
+            sqlite_unistr_text(r"a\0041\u0042\+000043\U00000044\\z").expect("decode unistr escapes"),
+            r"aABCD\z"
+        );
+    }
+
+    #[tokio::test]
+    async fn view_with_if_function_works_after_normalization() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+
+        execute_query(&pool, "CREATE TABLE t (x INTEGER); INSERT INTO t VALUES (1), (2), (3);")
+            .await
+            .expect("create and populate table");
+
+        execute_query(&pool, "CREATE VIEW v AS SELECT x, IIF(x > 1, 'big', 'small') AS label FROM t")
+            .await
+            .expect("create view");
+
+        let result = execute_query(&pool, "SELECT * FROM v ORDER BY x").await.expect("query view");
+
+        assert_eq!(result.rows.len(), 3);
+        assert_eq!(result.rows[0][1], serde_json::json!("small"));
+        assert_eq!(result.rows[1][1], serde_json::json!("big"));
+    }
+
+    #[tokio::test]
+    async fn view_with_stored_if_and_unistr_functions_can_be_described_and_queried() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+        pool.with_connection(|conn| {
+            conn.execute_batch("CREATE VIEW a AS SELECT if(1, unistr('hello'), 'world') AS a;")
+                .map_err(|e| e.to_string())
+        })
+        .expect("create view with original SQLite 3.50 functions");
+
+        let columns = get_columns(&pool, "", "a").await.expect("describe view");
+        assert_eq!(columns.len(), 1);
+        assert_eq!(columns[0].name, "a");
+
+        let result = execute_query(&pool, "SELECT * FROM a").await.expect("query view");
+        assert_eq!(result.rows[0][0], serde_json::json!("hello"));
+    }
+
+    #[tokio::test]
+    async fn if_rewrite_works_in_direct_query() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+
+        let result = execute_query(&pool, "SELECT if(1 = 1, 'yes', 'no') AS answer")
+            .await
+            .expect("if() should be rewritten to IIF()");
+
+        assert_eq!(result.rows[0][0], serde_json::json!("yes"));
+    }
+
+    #[tokio::test]
+    async fn bundled_sqlite_math_functions_are_available() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+
+        let floor_result =
+            execute_query(&pool, "WITH test(x) AS (VALUES (1.1), (1.2), (1.3)) SELECT FLOOR(x) FROM test")
+                .await
+                .expect("FLOOR() should be available");
+
+        assert_eq!(floor_result.rows.len(), 3);
+        for row in floor_result.rows {
+            assert_eq!(row[0].as_f64(), Some(1.0));
+        }
+
+        let result = execute_query(&pool, "SELECT ACOS(1.0), ACOSH(1.0), ASIN(0.0), CEIL(1.2), PI()")
+            .await
+            .expect("SQLite math functions should be available");
+
+        assert_eq!(result.rows[0][0].as_f64(), Some(0.0));
+        assert_eq!(result.rows[0][1].as_f64(), Some(0.0));
+        assert_eq!(result.rows[0][2].as_f64(), Some(0.0));
+        assert_eq!(result.rows[0][3].as_f64(), Some(2.0));
+        let pi = result.rows[0][4].as_f64().expect("PI() returns a real value");
+        assert!((std::f64::consts::PI - pi).abs() < 0.00001);
+    }
+
+    #[tokio::test]
+    async fn substring_rewrite_works_in_direct_query() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+
+        execute_query(&pool, "CREATE TABLE t (name TEXT); INSERT INTO t VALUES ('hello');").await.expect("setup");
+
+        let result = execute_query(&pool, "SELECT substring(name, 1, 2) AS s FROM t")
+            .await
+            .expect("substring() should be rewritten to substr()");
+
+        assert_eq!(result.rows[0][0], serde_json::json!("he"));
+    }
+
+    #[tokio::test]
+    async fn both_rewrites_combined() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+
+        execute_query(&pool, "CREATE TABLE t (x INTEGER); INSERT INTO t VALUES (1), (2);").await.expect("setup");
+
+        let result = execute_query(&pool, "SELECT substring(if(x > 1, 'big', 'small'), 1, 1) AS s FROM t ORDER BY x")
+            .await
+            .expect("combined rewrite");
+
+        assert_eq!(result.rows[0][0], serde_json::json!("s"));
+        assert_eq!(result.rows[1][0], serde_json::json!("b"));
+    }
+
+    fn parse_pk(sql: &str) -> Vec<String> {
+        let mut cols: Vec<String> = parse_sqlite_autoincrement_pk_columns(sql).into_iter().collect();
+        cols.sort();
+        cols
+    }
+
+    #[test]
+    fn parses_implicit_integer_primary_key_as_autoincrement() {
+        assert_eq!(parse_pk("CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT)"), vec!["id".to_string()]);
+    }
+
+    #[test]
+    fn parses_explicit_integer_primary_key_autoincrement() {
+        assert_eq!(
+            parse_pk("CREATE TABLE t (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT)"),
+            vec!["id".to_string()]
+        );
+    }
+
+    #[test]
+    fn parses_ef_core_style_named_constraint_primary_key_autoincrement() {
+        // The actual table from issue #1129.
+        let sql = r#"CREATE TABLE "OnlineLogs" (
+            "OnlineLogId" INTEGER NOT NULL CONSTRAINT "PK_OnlineLogs" PRIMARY KEY AUTOINCREMENT,
+            "LogTime" TEXT NOT NULL,
+            "ReportedAddresses" TEXT NOT NULL,
+            "DeviceId" TEXT NOT NULL
+        )"#;
+        assert_eq!(parse_pk(sql), vec!["onlinelogid".to_string()]);
+    }
+
+    #[test]
+    fn does_not_match_non_integer_primary_key() {
+        assert!(parse_sqlite_autoincrement_pk_columns("CREATE TABLE t (id INT PRIMARY KEY, name TEXT)").is_empty());
+        assert!(parse_sqlite_autoincrement_pk_columns("CREATE TABLE t (id BIGINT PRIMARY KEY, name TEXT)").is_empty());
+    }
+
+    #[test]
+    fn does_not_match_without_rowid_table() {
+        let sql = "CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT) WITHOUT ROWID";
+        assert!(parse_sqlite_autoincrement_pk_columns(sql).is_empty());
+    }
+
+    #[test]
+    fn does_not_match_composite_primary_key() {
+        let sql = "CREATE TABLE t (a INTEGER, b INTEGER, PRIMARY KEY (a, b))";
+        assert!(parse_sqlite_autoincrement_pk_columns(sql).is_empty());
+    }
+
+    #[test]
+    fn parses_table_level_single_column_primary_key_for_integer() {
+        let sql = "CREATE TABLE t (id INTEGER NOT NULL, name TEXT, PRIMARY KEY (id))";
+        assert_eq!(parse_pk(sql), vec!["id".to_string()]);
+    }
+
+    #[test]
+    fn ignores_non_pk_integer_not_null_column() {
+        let sql = "CREATE TABLE t (id INTEGER PRIMARY KEY, count INTEGER NOT NULL)";
+        assert_eq!(parse_pk(sql), vec!["id".to_string()]);
+    }
+
+    #[test]
+    fn parser_falls_back_to_empty_on_garbage_sql() {
+        assert!(parse_sqlite_autoincrement_pk_columns("not a create table statement").is_empty());
+        assert!(parse_sqlite_autoincrement_pk_columns("").is_empty());
+    }
+
+    #[test]
+    fn parser_skips_check_expression_with_primary_key_token() {
+        // PRIMARY KEY tokens inside a CHECK expression must not falsely mark the column.
+        let sql = r#"CREATE TABLE t (
+            id INTEGER,
+            kind TEXT CHECK (kind IN ('PRIMARY KEY', 'OTHER')),
+            PRIMARY KEY (id)
+        )"#;
+        assert_eq!(parse_pk(sql), vec!["id".to_string()]);
+    }
+
+    #[test]
+    fn parser_handles_block_and_line_comments() {
+        let sql = r#"CREATE TABLE t (
+            -- line comment with INTEGER PRIMARY KEY tokens
+            /* block comment INTEGER PRIMARY KEY */
+            id INTEGER PRIMARY KEY,
+            name TEXT
+        )"#;
+        assert_eq!(parse_pk(sql), vec!["id".to_string()]);
+    }
+
+    #[tokio::test]
+    async fn get_columns_marks_integer_primary_key_as_autoincrement() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+        execute_query(&pool, "CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT NOT NULL)").await.expect("create");
+
+        let cols = get_columns(&pool, "main", "t").await.expect("get_columns");
+        let id = cols.iter().find(|c| c.name == "id").expect("id col");
+        assert_eq!(id.extra.as_deref(), Some("autoincrement"));
+        let name = cols.iter().find(|c| c.name == "name").expect("name col");
+        assert!(name.extra.is_none());
+    }
+
+    #[tokio::test]
+    async fn get_columns_marks_ef_core_style_autoincrement_primary_key() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+        execute_query(
+            &pool,
+            r#"CREATE TABLE "OnlineLogs" (
+                "OnlineLogId" INTEGER NOT NULL CONSTRAINT "PK_OnlineLogs" PRIMARY KEY AUTOINCREMENT,
+                "LogTime" TEXT NOT NULL,
+                "DeviceId" TEXT NOT NULL
+            )"#,
+        )
+        .await
+        .expect("create");
+
+        let cols = get_columns(&pool, "main", "OnlineLogs").await.expect("get_columns");
+        let id = cols.iter().find(|c| c.name == "OnlineLogId").expect("OnlineLogId");
+        assert_eq!(id.extra.as_deref(), Some("autoincrement"));
+        for other in cols.iter().filter(|c| c.name != "OnlineLogId") {
+            assert!(other.extra.is_none(), "{} should not be autoincrement", other.name);
+        }
+    }
+
+    #[tokio::test]
+    async fn get_columns_skips_without_rowid_table() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+        execute_query(&pool, "CREATE TABLE t (id INTEGER PRIMARY KEY, name TEXT NOT NULL) WITHOUT ROWID")
+            .await
+            .expect("create");
+
+        let cols = get_columns(&pool, "main", "t").await.expect("get_columns");
+        let id = cols.iter().find(|c| c.name == "id").expect("id col");
+        assert!(id.extra.is_none());
+    }
+
+    #[tokio::test]
+    async fn get_columns_skips_composite_primary_key() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+        execute_query(&pool, "CREATE TABLE t (a INTEGER NOT NULL, b INTEGER NOT NULL, PRIMARY KEY (a, b))")
+            .await
+            .expect("create");
+
+        let cols = get_columns(&pool, "main", "t").await.expect("get_columns");
+        for col in &cols {
+            assert!(col.extra.is_none(), "{} should not be autoincrement", col.name);
+        }
+    }
+
+    #[tokio::test]
+    async fn get_columns_skips_non_integer_primary_key() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+        // Use BIGINT to avoid SQLite's strict-table parser quirks; INT is sometimes promoted in SQLite.
+        execute_query(&pool, "CREATE TABLE t (id BIGINT PRIMARY KEY, name TEXT)").await.expect("create");
+
+        let cols = get_columns(&pool, "main", "t").await.expect("get_columns");
+        let id = cols.iter().find(|c| c.name == "id").expect("id col");
+        assert!(id.extra.is_none());
+    }
+
+    #[tokio::test]
+    async fn completion_assistant_searches_sqlite_tables_and_columns_with_limit() {
+        let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
+        execute_query(
+            &pool,
+            "CREATE TABLE account(id INTEGER PRIMARY KEY, display_name TEXT); CREATE VIEW account_view AS SELECT id FROM account; CREATE TABLE audit_log(id INTEGER);",
+        )
+        .await
+        .expect("setup schema");
+
+        let tables = completion_assistant_search(
+            &pool,
+            &CompletionAssistantRequest {
+                connection_id: "c1".to_string(),
+                database: "main".to_string(),
+                schema: Some("main".to_string()),
+                object_kinds: vec![CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View],
+                mask: "account".to_string(),
+                case_sensitive: false,
+                global_search: false,
+                max_results: Some(1),
+                search_in_comments: false,
+                search_in_definitions: false,
+                parent_schema: Some("main".to_string()),
+                parent_name: None,
+                match_mode: Some(CompletionAssistantMatchMode::Prefix),
+            },
+        )
+        .await
+        .expect("table completion");
+
+        assert_eq!(tables.candidates.len(), 1);
+        assert!(tables.incomplete);
+        assert!(!tables.fallback_used);
+        assert_eq!(tables.candidates[0].name, "account");
+
+        let columns = completion_assistant_search(
+            &pool,
+            &CompletionAssistantRequest {
+                connection_id: "c1".to_string(),
+                database: "main".to_string(),
+                schema: Some("main".to_string()),
+                object_kinds: vec![CompletionAssistantObjectKind::Column],
+                mask: "name".to_string(),
+                case_sensitive: false,
+                global_search: false,
+                max_results: Some(10),
+                search_in_comments: false,
+                search_in_definitions: false,
+                parent_schema: Some("main".to_string()),
+                parent_name: Some("account".to_string()),
+                match_mode: Some(CompletionAssistantMatchMode::Contains),
+            },
+        )
+        .await
+        .expect("column completion");
+
+        assert_eq!(columns.candidates.len(), 1);
+        assert_eq!(columns.candidates[0].name, "display_name");
+        assert_eq!(columns.candidates[0].data_type.as_deref(), Some("TEXT"));
+    }
+}
+
+pub async fn list_databases(_pool: &SqliteHandle) -> Result<Vec<DatabaseInfo>, String> {
+    Ok(vec![DatabaseInfo { name: "main".to_string() }])
+}
+
+pub async fn list_tables(pool: &SqliteHandle, _schema: &str) -> Result<Vec<TableInfo>, String> {
+    let pool = pool.clone();
+    tokio::task::spawn_blocking(move || {
+        pool.with_connection(|conn| {
+            let mut stmt = conn
+                .prepare(
+                    "SELECT name, type FROM sqlite_master \
+                     WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY name",
+                )
+                .map_err(|e| e.to_string())?;
+            let rows = stmt
+                .query_map([], |row| {
+                    let table_type: String = row.get(1)?;
+                    Ok(TableInfo {
+                        name: row.get(0)?,
+                        table_type: if table_type == "view" { "VIEW".to_string() } else { "BASE TABLE".to_string() },
+                        comment: None,
+                        parent_schema: None,
+                        parent_name: None,
+                    })
+                })
+                .map_err(|e| e.to_string())?;
+            rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
+        })
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+pub async fn get_columns(pool: &SqliteHandle, _schema: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let pool = pool.clone();
+    let table = table.to_string();
+    tokio::task::spawn_blocking(move || {
+        let sql = format!("PRAGMA table_info(\"{}\")", table.replace('"', "\"\""));
+        pool.with_connection(|conn| {
+            let autoincrement_columns = sqlite_autoincrement_pk_columns(conn, &table).unwrap_or_default();
+            let mut stmt = conn.prepare(&sql).map_err(|e| e.to_string())?;
+            let rows = stmt
+                .query_map([], |row| {
+                    let name: String = row.get("name")?;
+                    let is_pk = row.get::<_, i32>("pk")? > 0;
+                    let extra = if is_pk && autoincrement_columns.contains(&name.to_ascii_lowercase()) {
+                        Some("autoincrement".to_string())
+                    } else {
+                        None
+                    };
+                    Ok(ColumnInfo {
+                        name,
+                        data_type: row.get("type")?,
+                        is_nullable: row.get::<_, i32>("notnull")? == 0,
+                        column_default: row.get("dflt_value")?,
+                        is_primary_key: is_pk,
+                        extra,
+                        comment: None,
+                        numeric_precision: None,
+                        numeric_scale: None,
+                        character_maximum_length: None,
+                        enum_values: None,
+                        ..Default::default()
+                    })
+                })
+                .map_err(|e| e.to_string())?;
+            rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
+        })
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+pub async fn completion_assistant_search(
+    pool: &SqliteHandle,
+    request: &CompletionAssistantRequest,
+) -> Result<CompletionAssistantResponse, String> {
+    let pool = pool.clone();
+    let request = request.clone();
+    tokio::task::spawn_blocking(move || pool.with_connection(|conn| sqlite_completion_assistant_search(conn, &request)))
+        .await
+        .map_err(|e| e.to_string())?
+}
+
+fn sqlite_completion_assistant_search(
+    conn: &mut Connection,
+    request: &CompletionAssistantRequest,
+) -> Result<CompletionAssistantResponse, String> {
+    let limit = request.max_results.unwrap_or(100).clamp(1, 1000);
+    let kinds = completion_object_kinds(request);
+    let mut candidates = Vec::new();
+
+    if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Schema)) {
+        for schema in sqlite_completion_schemas(conn, request, limit - candidates.len())? {
+            candidates.push(schema);
+            if candidates.len() >= limit {
+                return Ok(CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
+            }
+        }
+    }
+
+    if kinds.iter().any(CompletionAssistantObjectKind::is_table_like) {
+        for table in sqlite_completion_tables(conn, request, &kinds, limit - candidates.len())? {
+            candidates.push(table);
+            if candidates.len() >= limit {
+                return Ok(CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
+            }
+        }
+    }
+
+    if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Column)) {
+        for column in sqlite_completion_columns(conn, request, limit - candidates.len())? {
+            candidates.push(column);
+            if candidates.len() >= limit {
+                return Ok(CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
+            }
+        }
+    }
+
+    Ok(CompletionAssistantResponse { candidates, incomplete: false, fallback_used: false })
+}
+
+fn completion_object_kinds(request: &CompletionAssistantRequest) -> Vec<CompletionAssistantObjectKind> {
+    if request.object_kinds.is_empty() {
+        vec![CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View]
+    } else {
+        request.object_kinds.clone()
+    }
+}
+
+fn sqlite_completion_schemas(
+    conn: &mut Connection,
+    request: &CompletionAssistantRequest,
+    limit: usize,
+) -> Result<Vec<CompletionAssistantCandidate>, String> {
+    if limit == 0 {
+        return Ok(Vec::new());
+    }
+    let mut stmt = conn.prepare("PRAGMA database_list").map_err(|e| e.to_string())?;
+    let rows = stmt.query_map([], |row| row.get::<_, String>(1)).map_err(|e| e.to_string())?;
+    let mut schemas = rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())?;
+    schemas.sort_by_key(|schema| schema.to_lowercase());
+    Ok(schemas
+        .into_iter()
+        .filter(|schema| sqlite_completion_name_matches(schema, request))
+        .take(limit)
+        .map(|schema| CompletionAssistantCandidate {
+            name: schema.clone(),
+            kind: CompletionAssistantCandidateKind::Schema,
+            database: Some(request.database.clone()),
+            schema: Some(schema),
+            parent_schema: None,
+            parent_name: None,
+            comment: None,
+            data_type: None,
+        })
+        .collect())
+}
+
+fn sqlite_completion_tables(
+    conn: &mut Connection,
+    request: &CompletionAssistantRequest,
+    kinds: &[CompletionAssistantObjectKind],
+    limit: usize,
+) -> Result<Vec<CompletionAssistantCandidate>, String> {
+    if limit == 0 {
+        return Ok(Vec::new());
+    }
+    let schema = sqlite_completion_schema(request);
+    let mut type_filters = Vec::new();
+    if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Table)) {
+        type_filters.push("table");
+    }
+    if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::View)) {
+        type_filters.push("view");
+    }
+    if type_filters.is_empty() {
+        type_filters.extend(["table", "view"]);
+    }
+    let placeholders = std::iter::repeat("?").take(type_filters.len()).collect::<Vec<_>>().join(", ");
+    let sql = format!(
+        "SELECT name, type FROM {}.sqlite_master WHERE type IN ({}) AND name NOT LIKE 'sqlite_%' AND {} ORDER BY name LIMIT ?",
+        sqlite_quote_ident(&schema),
+        placeholders,
+        sqlite_completion_filter_sql("name", request)
+    );
+    let pattern = sqlite_completion_like_pattern(request);
+    let mut params: Vec<&dyn rusqlite::ToSql> =
+        type_filters.iter().map(|value| value as &dyn rusqlite::ToSql).collect();
+    params.push(&pattern);
+    params.push(&limit);
+    let mut stmt = conn.prepare(&sql).map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map(params.as_slice(), |row| {
+            let object_type = row.get::<_, String>(1)?;
+            Ok(CompletionAssistantCandidate {
+                name: row.get(0)?,
+                kind: if object_type.eq_ignore_ascii_case("view") {
+                    CompletionAssistantCandidateKind::View
+                } else {
+                    CompletionAssistantCandidateKind::Table
+                },
+                database: Some(request.database.clone()),
+                schema: Some(schema.clone()),
+                parent_schema: None,
+                parent_name: None,
+                comment: None,
+                data_type: None,
+            })
+        })
+        .map_err(|e| e.to_string())?;
+    rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
+}
+
+fn sqlite_completion_columns(
+    conn: &mut Connection,
+    request: &CompletionAssistantRequest,
+    limit: usize,
+) -> Result<Vec<CompletionAssistantCandidate>, String> {
+    if limit == 0 {
+        return Ok(Vec::new());
+    }
+    let Some(table) = request.parent_name.as_deref().filter(|table| !table.trim().is_empty()) else {
+        return Ok(Vec::new());
+    };
+    let schema = sqlite_completion_schema(request);
+    let sql = format!("PRAGMA {}.table_info({})", sqlite_quote_ident(&schema), sqlite_quote_string(table));
+    let mut stmt = conn.prepare(&sql).map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map([], |row| Ok((row.get::<_, String>("name")?, row.get::<_, String>("type")?)))
+        .map_err(|e| e.to_string())?;
+    let mut candidates = Vec::new();
+    for row in rows {
+        let (name, data_type) = row.map_err(|e| e.to_string())?;
+        if !sqlite_completion_name_matches(&name, request) {
+            continue;
+        }
+        candidates.push(CompletionAssistantCandidate {
+            name,
+            kind: CompletionAssistantCandidateKind::Column,
+            database: Some(request.database.clone()),
+            schema: Some(schema.clone()),
+            parent_schema: Some(schema.clone()),
+            parent_name: Some(table.to_string()),
+            comment: None,
+            data_type: Some(data_type),
+        });
+        if candidates.len() >= limit {
+            break;
+        }
+    }
+    Ok(candidates)
+}
+
+fn sqlite_completion_schema(request: &CompletionAssistantRequest) -> String {
+    request
+        .parent_schema
+        .as_deref()
+        .or(request.schema.as_deref())
+        .filter(|schema| !schema.trim().is_empty())
+        .unwrap_or("main")
+        .to_string()
+}
+
+fn sqlite_completion_name_matches(name: &str, request: &CompletionAssistantRequest) -> bool {
+    let mask = request.mask.trim().trim_matches('%');
+    if mask.is_empty() {
+        return true;
+    }
+    let (name, mask) = if request.case_sensitive {
+        (name.to_string(), mask.to_string())
+    } else {
+        (name.to_lowercase(), mask.to_lowercase())
+    };
+    match request.match_mode.as_ref().unwrap_or(&CompletionAssistantMatchMode::Prefix) {
+        CompletionAssistantMatchMode::Prefix => name.starts_with(&mask),
+        CompletionAssistantMatchMode::Contains => name.contains(&mask),
+    }
+}
+
+fn sqlite_completion_filter_sql(column: &str, request: &CompletionAssistantRequest) -> String {
+    if request.case_sensitive {
+        format!("{column} GLOB ?")
+    } else {
+        format!("LOWER({column}) LIKE LOWER(?) ESCAPE '\\'")
+    }
+}
+
+fn sqlite_completion_like_pattern(request: &CompletionAssistantRequest) -> String {
+    let mask = request.mask.trim().trim_matches('%');
+    let escaped = mask.replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_");
+    match request.match_mode.as_ref().unwrap_or(&CompletionAssistantMatchMode::Prefix) {
+        CompletionAssistantMatchMode::Prefix if request.case_sensitive => format!("{}*", mask.replace('[', "[[]")),
+        CompletionAssistantMatchMode::Contains if request.case_sensitive => format!("*{}*", mask.replace('[', "[[]")),
+        CompletionAssistantMatchMode::Prefix => format!("{escaped}%"),
+        CompletionAssistantMatchMode::Contains => format!("%{escaped}%"),
+    }
+}
+
+fn sqlite_quote_ident(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+fn sqlite_quote_string(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+/// Read `sqlite_master.sql` for `table` and return the lowercase column names that
+/// are rowid-alias autoincrement primary keys (i.e. SQLite will assign a value when
+/// the column is omitted from an INSERT). Returns `None` only on connection / query
+/// errors; an unparseable build statement yields `Some(empty)`.
+fn sqlite_autoincrement_pk_columns(conn: &Connection, table: &str) -> Option<HashSet<String>> {
+    let create_sql: Option<String> = conn
+        .query_row("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?1", [table], |row| row.get(0))
+        .ok()
+        .flatten();
+    Some(parse_sqlite_autoincrement_pk_columns(create_sql.as_deref()?))
+}
+
+/// Parse a SQLite `CREATE TABLE` statement and return the lowercase names of columns
+/// that are rowid-alias autoincrement primary keys.
+///
+/// A column is recognized when ALL of the following hold:
+/// - The table is NOT declared `WITHOUT ROWID`.
+/// - The column's declared type, after case-insensitive normalization, is exactly
+///   `INTEGER` (NOT `INT`, `BIGINT`, `SMALLINT`, etc.).
+/// - The column is the (only) primary key, declared either inline (`PRIMARY KEY`,
+///   optionally with `AUTOINCREMENT`) or via a single-column table-level
+///   `PRIMARY KEY (col)` constraint.
+///
+/// On any parse failure (malformed SQL, unrecognized syntax) the function returns
+/// an empty set rather than panicking — callers fall back to the conservative
+/// behavior of treating the column as a normal NOT NULL column.
+fn parse_sqlite_autoincrement_pk_columns(create_sql: &str) -> HashSet<String> {
+    let body = match extract_create_table_body(create_sql) {
+        Some(body) => body,
+        None => return HashSet::new(),
+    };
+    if has_without_rowid_clause(&body.tail) {
+        return HashSet::new();
+    }
+
+    let entries = split_table_body_entries(&body.body);
+
+    // First pass: find table-level PRIMARY KEY (col) — a single-column primary key
+    // that may apply to a column declared as INTEGER elsewhere in the body.
+    let mut table_level_pk: Option<String> = None;
+    let mut has_composite_table_pk = false;
+    for entry in &entries {
+        if let Some(cols) = parse_table_level_primary_key(entry) {
+            if cols.len() == 1 {
+                if table_level_pk.is_none() && !has_composite_table_pk {
+                    table_level_pk = Some(cols.into_iter().next().unwrap());
+                }
+            } else if cols.len() > 1 {
+                has_composite_table_pk = true;
+                table_level_pk = None;
+            }
+        }
+    }
+    if has_composite_table_pk {
+        return HashSet::new();
+    }
+
+    let mut found: HashSet<String> = HashSet::new();
+    let mut inline_pk_count = 0_usize;
+    let mut inline_pk_candidate: Option<String> = None;
+
+    for entry in &entries {
+        if parse_table_level_primary_key(entry).is_some() {
+            continue;
+        }
+        if is_table_level_constraint(entry) {
+            continue;
+        }
+        let Some(column) = parse_column_definition(entry) else {
+            continue;
+        };
+        if column.has_inline_pk {
+            inline_pk_count += 1;
+            inline_pk_candidate = Some(column.name.clone());
+            if column.is_integer_type {
+                found.insert(column.name.clone());
+            }
+        }
+        if let Some(ref pk_name) = table_level_pk {
+            if pk_name.eq_ignore_ascii_case(&column.name) && column.is_integer_type {
+                found.insert(column.name.clone());
+            }
+        }
+    }
+
+    // Multiple inline PRIMARY KEY columns means a composite key — clear the inline matches.
+    if inline_pk_count > 1 {
+        if let Some(name) = inline_pk_candidate {
+            found.remove(&name);
+        }
+        // Also drop any other inline PK columns we may have inserted.
+        // (Conservative: walk entries again and remove inline PK names that ended up in `found`.)
+        let mut to_remove: Vec<String> = Vec::new();
+        for entry in &entries {
+            if let Some(column) = parse_column_definition(entry) {
+                if column.has_inline_pk && found.contains(&column.name) {
+                    to_remove.push(column.name);
+                }
+            }
+        }
+        for name in to_remove {
+            found.remove(&name);
+        }
+    }
+
+    found
+}
+
+struct CreateTableBody {
+    body: String,
+    tail: String,
+}
+
+fn extract_create_table_body(create_sql: &str) -> Option<CreateTableBody> {
+    let stripped = strip_sql_comments(create_sql);
+    let lower = stripped.to_ascii_lowercase();
+    if !lower.contains("create") || !lower.contains("table") {
+        return None;
+    }
+    // Find the first top-level '(' after the table name.
+    let bytes = stripped.as_bytes();
+    let mut start = None;
+    for (i, &b) in bytes.iter().enumerate() {
+        if b == b'(' {
+            start = Some(i);
+            break;
+        }
+    }
+    let start = start?;
+    let mut depth = 0_usize;
+    let mut end = None;
+    let mut chars = stripped[start..].char_indices();
+    while let Some((rel, ch)) = chars.next() {
+        match ch {
+            '(' => depth += 1,
+            ')' => {
+                depth -= 1;
+                if depth == 0 {
+                    end = Some(start + rel);
+                    break;
+                }
+            }
+            '\'' | '"' | '`' => {
+                // skip a quoted string / identifier in the loop directly
+                let quote = ch;
+                while let Some((_, qch)) = chars.next() {
+                    if qch == quote {
+                        // SQLite supports doubled quote as escape inside identifiers.
+                        // Peek next char without consuming.
+                        let mut peek = chars.clone();
+                        if let Some((_, next_ch)) = peek.next() {
+                            if next_ch == quote {
+                                chars.next();
+                                continue;
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+            '[' => {
+                // SQL Server style identifier — closes at first ']'.
+                for (_, qch) in chars.by_ref() {
+                    if qch == ']' {
+                        break;
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+    let end = end?;
+    let body = stripped[start + 1..end].to_string();
+    let tail = stripped[end + 1..].to_string();
+    Some(CreateTableBody { body, tail })
+}
+
+fn has_without_rowid_clause(tail: &str) -> bool {
+    let normalized: String = tail.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    normalized.contains("without rowid")
+}
+
+fn strip_sql_comments(input: &str) -> String {
+    let mut out = String::with_capacity(input.len());
+    let bytes = input.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        let b = bytes[i];
+        if b == b'-' && i + 1 < bytes.len() && bytes[i + 1] == b'-' {
+            // line comment
+            i += 2;
+            while i < bytes.len() && bytes[i] != b'\n' {
+                i += 1;
+            }
+        } else if b == b'/' && i + 1 < bytes.len() && bytes[i + 1] == b'*' {
+            i += 2;
+            while i + 1 < bytes.len() && !(bytes[i] == b'*' && bytes[i + 1] == b'/') {
+                i += 1;
+            }
+            if i + 1 < bytes.len() {
+                i += 2;
+            } else {
+                i = bytes.len();
+            }
+        } else if b == b'\'' || b == b'"' || b == b'`' {
+            // copy quoted segment as-is (we still need it for identifier parsing later)
+            let quote = b;
+            out.push(b as char);
+            i += 1;
+            while i < bytes.len() {
+                let qb = bytes[i];
+                out.push(qb as char);
+                if qb == quote {
+                    if i + 1 < bytes.len() && bytes[i + 1] == quote {
+                        // doubled quote escape
+                        out.push(quote as char);
+                        i += 2;
+                        continue;
+                    }
+                    i += 1;
+                    break;
+                }
+                i += 1;
+            }
+        } else if b == b'[' {
+            out.push('[');
+            i += 1;
+            while i < bytes.len() {
+                let qb = bytes[i];
+                out.push(qb as char);
+                i += 1;
+                if qb == b']' {
+                    break;
+                }
+            }
+        } else {
+            // copy as char (handle multi-byte utf-8 by walking)
+            out.push(input[i..].chars().next().unwrap());
+            i += input[i..].chars().next().unwrap().len_utf8();
+        }
+    }
+    out
+}
+
+fn split_table_body_entries(body: &str) -> Vec<String> {
+    let mut entries = Vec::new();
+    let mut current = String::new();
+    let mut depth = 0_usize;
+    let mut chars = body.chars().peekable();
+    while let Some(ch) = chars.next() {
+        match ch {
+            '(' => {
+                depth += 1;
+                current.push(ch);
+            }
+            ')' => {
+                depth = depth.saturating_sub(1);
+                current.push(ch);
+            }
+            ',' if depth == 0 => {
+                let trimmed = current.trim();
+                if !trimmed.is_empty() {
+                    entries.push(trimmed.to_string());
+                }
+                current.clear();
+            }
+            '\'' | '"' | '`' => {
+                let quote = ch;
+                current.push(ch);
+                while let Some(qch) = chars.next() {
+                    current.push(qch);
+                    if qch == quote {
+                        if let Some(&next_ch) = chars.peek() {
+                            if next_ch == quote {
+                                current.push(chars.next().unwrap());
+                                continue;
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+            '[' => {
+                current.push(ch);
+                for qch in chars.by_ref() {
+                    current.push(qch);
+                    if qch == ']' {
+                        break;
+                    }
+                }
+            }
+            _ => current.push(ch),
+        }
+    }
+    let trimmed = current.trim();
+    if !trimmed.is_empty() {
+        entries.push(trimmed.to_string());
+    }
+    entries
+}
+
+struct ColumnDefinition {
+    name: String,
+    is_integer_type: bool,
+    has_inline_pk: bool,
+}
+
+fn parse_column_definition(entry: &str) -> Option<ColumnDefinition> {
+    let mut tokens = tokenize_entry(entry);
+    if tokens.is_empty() {
+        return None;
+    }
+    // Skip leading "CONSTRAINT name" if it appears (rare in column defs but tolerated).
+    if tokens[0].kind == TokenKind::Keyword && tokens[0].value.eq_ignore_ascii_case("constraint") && tokens.len() >= 2 {
+        // not a column definition
+        return None;
+    }
+    let name_token = tokens.remove(0);
+    if name_token.kind != TokenKind::Identifier {
+        return None;
+    }
+    let name_lower = name_token.value.to_ascii_lowercase();
+
+    // Type token: optional, followed by optional parenthesized size.
+    let mut is_integer_type = false;
+    if let Some(first) = tokens.first() {
+        if first.kind == TokenKind::Identifier {
+            if first.value.eq_ignore_ascii_case("integer") {
+                is_integer_type = true;
+            }
+            // consume the type token; also consume size like "(10, 2)"
+            tokens.remove(0);
+            if let Some(t) = tokens.first() {
+                if t.value == "(" {
+                    // consume balanced parens
+                    let mut depth = 0_usize;
+                    while !tokens.is_empty() {
+                        let t = tokens.remove(0);
+                        if t.value == "(" {
+                            depth += 1;
+                        } else if t.value == ")" {
+                            depth = depth.saturating_sub(1);
+                            if depth == 0 {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let has_inline_pk = tokens_contain_primary_key(&tokens);
+
+    Some(ColumnDefinition { name: name_lower, is_integer_type, has_inline_pk })
+}
+
+fn tokens_contain_primary_key(tokens: &[Token]) -> bool {
+    for window in tokens.windows(2) {
+        if window[0].kind == TokenKind::Keyword
+            && window[0].value.eq_ignore_ascii_case("primary")
+            && window[1].kind == TokenKind::Keyword
+            && window[1].value.eq_ignore_ascii_case("key")
+        {
+            return true;
+        }
+    }
+    false
+}
+
+fn is_table_level_constraint(entry: &str) -> bool {
+    let trimmed = entry.trim_start();
+    let lower = trimmed.to_ascii_lowercase();
+    lower.starts_with("constraint")
+        || lower.starts_with("primary key")
+        || lower.starts_with("unique")
+        || lower.starts_with("check")
+        || lower.starts_with("foreign key")
+}
+
+/// If the entry is a table-level `PRIMARY KEY (col[, col, ...])` constraint,
+/// return the lowercase column names. Otherwise `None`.
+fn parse_table_level_primary_key(entry: &str) -> Option<Vec<String>> {
+    let tokens = tokenize_entry(entry);
+    let mut idx = 0;
+    if idx < tokens.len()
+        && tokens[idx].kind == TokenKind::Keyword
+        && tokens[idx].value.eq_ignore_ascii_case("constraint")
+    {
+        idx += 1;
+        if idx < tokens.len() && tokens[idx].kind == TokenKind::Identifier {
+            idx += 1;
+        }
+    }
+    if idx + 1 >= tokens.len() {
+        return None;
+    }
+    if !(tokens[idx].kind == TokenKind::Keyword
+        && tokens[idx].value.eq_ignore_ascii_case("primary")
+        && tokens[idx + 1].kind == TokenKind::Keyword
+        && tokens[idx + 1].value.eq_ignore_ascii_case("key"))
+    {
+        return None;
+    }
+    idx += 2;
+    if idx >= tokens.len() || tokens[idx].value != "(" {
+        return None;
+    }
+    idx += 1;
+    let mut cols = Vec::new();
+    while idx < tokens.len() && tokens[idx].value != ")" {
+        if tokens[idx].kind == TokenKind::Identifier {
+            cols.push(tokens[idx].value.to_ascii_lowercase());
+        }
+        idx += 1;
+        // skip optional ASC/DESC and a comma
+        while idx < tokens.len() && tokens[idx].value != "," && tokens[idx].value != ")" {
+            idx += 1;
+        }
+        if idx < tokens.len() && tokens[idx].value == "," {
+            idx += 1;
+        }
+    }
+    Some(cols)
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum TokenKind {
+    Identifier,
+    Keyword,
+    Punct,
+    Other,
+}
+
+#[derive(Debug, Clone)]
+struct Token {
+    value: String,
+    kind: TokenKind,
+}
+
+fn tokenize_entry(entry: &str) -> Vec<Token> {
+    let mut tokens = Vec::new();
+    let mut chars = entry.chars().peekable();
+    while let Some(&ch) = chars.peek() {
+        if ch.is_whitespace() {
+            chars.next();
+            continue;
+        }
+        if ch == '"' || ch == '`' {
+            let quote = ch;
+            chars.next();
+            let mut value = String::new();
+            while let Some(&qch) = chars.peek() {
+                chars.next();
+                if qch == quote {
+                    if chars.peek() == Some(&quote) {
+                        value.push(quote);
+                        chars.next();
+                        continue;
+                    }
+                    break;
+                }
+                value.push(qch);
+            }
+            tokens.push(Token { value, kind: TokenKind::Identifier });
+            continue;
+        }
+        if ch == '[' {
+            chars.next();
+            let mut value = String::new();
+            while let Some(&qch) = chars.peek() {
+                chars.next();
+                if qch == ']' {
+                    break;
+                }
+                value.push(qch);
+            }
+            tokens.push(Token { value, kind: TokenKind::Identifier });
+            continue;
+        }
+        if ch == '\'' {
+            // string literal — skip
+            chars.next();
+            while let Some(&qch) = chars.peek() {
+                chars.next();
+                if qch == '\'' {
+                    if chars.peek() == Some(&'\'') {
+                        chars.next();
+                        continue;
+                    }
+                    break;
+                }
+            }
+            continue;
+        }
+        if ch == '(' || ch == ')' || ch == ',' {
+            chars.next();
+            tokens.push(Token { value: ch.to_string(), kind: TokenKind::Punct });
+            continue;
+        }
+        if ch.is_ascii_alphabetic() || ch == '_' {
+            let mut value = String::new();
+            while let Some(&wch) = chars.peek() {
+                if wch.is_ascii_alphanumeric() || wch == '_' {
+                    value.push(wch);
+                    chars.next();
+                } else {
+                    break;
+                }
+            }
+            let kind = if is_sql_keyword(&value) { TokenKind::Keyword } else { TokenKind::Identifier };
+            tokens.push(Token { value, kind });
+            continue;
+        }
+        // anything else — skip but record for completeness
+        chars.next();
+        tokens.push(Token { value: ch.to_string(), kind: TokenKind::Other });
+    }
+    tokens
+}
+
+fn is_sql_keyword(value: &str) -> bool {
+    matches!(
+        value.to_ascii_lowercase().as_str(),
+        "constraint"
+            | "primary"
+            | "key"
+            | "not"
+            | "null"
+            | "default"
+            | "unique"
+            | "check"
+            | "foreign"
+            | "references"
+            | "on"
+            | "delete"
+            | "update"
+            | "cascade"
+            | "set"
+            | "restrict"
+            | "no"
+            | "action"
+            | "deferrable"
+            | "initially"
+            | "deferred"
+            | "immediate"
+            | "match"
+            | "collate"
+            | "autoincrement"
+            | "asc"
+            | "desc"
+            | "generated"
+            | "always"
+            | "stored"
+            | "virtual"
+            | "as"
+    )
+}
+
+pub async fn list_indexes(pool: &SqliteHandle, _schema: &str, table: &str) -> Result<Vec<IndexInfo>, String> {
+    let pool = pool.clone();
+    let table = table.to_string();
+    tokio::task::spawn_blocking(move || {
+        let safe_table = table.replace('"', "\"\"");
+        pool.with_connection(|conn| {
+            let mut stmt = conn.prepare(&format!("PRAGMA index_list(\"{safe_table}\")")).map_err(|e| e.to_string())?;
+            let idx_rows = stmt
+                .query_map([], |row| {
+                    Ok((
+                        row.get::<_, String>("name")?,
+                        row.get::<_, i32>("unique")? != 0,
+                        row.get::<_, String>("origin")?,
+                    ))
+                })
+                .map_err(|e| e.to_string())?
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|e| e.to_string())?;
+
+            let mut indexes = Vec::new();
+            for (name, is_unique, origin) in idx_rows {
+                let safe_name = name.replace('"', "\"\"");
+                let mut col_stmt =
+                    conn.prepare(&format!("PRAGMA index_info(\"{safe_name}\")")).map_err(|e| e.to_string())?;
+                let columns = col_stmt
+                    .query_map([], |row| row.get::<_, String>("name"))
+                    .map_err(|e| e.to_string())?
+                    .collect::<Result<Vec<_>, _>>()
+                    .map_err(|e| e.to_string())?;
+
+                indexes.push(IndexInfo {
+                    name,
+                    columns,
+                    is_unique,
+                    is_primary: origin == "pk",
+                    filter: None,
+                    index_type: None,
+                    included_columns: None,
+                    comment: None,
+                });
+            }
+            Ok(indexes)
+        })
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+pub async fn list_foreign_keys(pool: &SqliteHandle, _schema: &str, table: &str) -> Result<Vec<ForeignKeyInfo>, String> {
+    let pool = pool.clone();
+    let table = table.to_string();
+    tokio::task::spawn_blocking(move || {
+        let sql = format!("PRAGMA foreign_key_list(\"{}\")", table.replace('"', "\"\""));
+        pool.with_connection(|conn| {
+            let mut stmt = conn.prepare(&sql).map_err(|e| e.to_string())?;
+            let rows = stmt
+                .query_map([], |row| {
+                    Ok(ForeignKeyInfo {
+                        name: format!("fk_{}", row.get::<_, i32>("id")?),
+                        column: row.get("from")?,
+                        ref_schema: None,
+                        ref_table: row.get("table")?,
+                        ref_column: row.get("to")?,
+                        on_update: None,
+                        on_delete: None,
+                    })
+                })
+                .map_err(|e| e.to_string())?;
+            rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
+        })
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+pub async fn list_triggers(pool: &SqliteHandle, _schema: &str, table: &str) -> Result<Vec<TriggerInfo>, String> {
+    let pool = pool.clone();
+    let table = table.to_string();
+    tokio::task::spawn_blocking(move || {
+        pool.with_connection(|conn| {
+            let mut stmt = conn
+                .prepare("SELECT name, sql FROM sqlite_master WHERE type = 'trigger' AND tbl_name = ? ORDER BY name")
+                .map_err(|e| e.to_string())?;
+            let rows = stmt
+                .query_map([table], |row| {
+                    let sql_text: Option<String> = row.get("sql")?;
+                    let upper = sql_text.clone().unwrap_or_default().to_uppercase();
+                    let timing = if upper.contains("BEFORE") {
+                        "BEFORE"
+                    } else if upper.contains("AFTER") {
+                        "AFTER"
+                    } else {
+                        "INSTEAD OF"
+                    };
+                    let event = if upper.contains("INSERT") {
+                        "INSERT"
+                    } else if upper.contains("UPDATE") {
+                        "UPDATE"
+                    } else {
+                        "DELETE"
+                    };
+                    Ok(TriggerInfo {
+                        name: row.get("name")?,
+                        event: event.to_string(),
+                        timing: timing.to_string(),
+                        statement: sql_text,
+                    })
+                })
+                .map_err(|e| e.to_string())?;
+            rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
+        })
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+pub async fn execute_query(pool: &SqliteHandle, sql: &str) -> Result<QueryResult, String> {
+    execute_query_with_max_rows(pool, sql, None).await
+}
+
+fn query_result_row_limit(max_rows: Option<usize>) -> usize {
+    max_rows.unwrap_or(crate::query::MAX_ROWS).max(1)
+}
+
+const SQLITE_FUNCTION_ALIASES: &[(&str, &str)] = &[("if", "IIF"), ("substring", "substr")];
+
+fn normalize_sqlite_sql(sql: &str) -> String {
+    let mut result = String::with_capacity(sql.len());
+    let chars: Vec<char> = sql.chars().collect();
+    let len = chars.len();
+    let mut i = 0;
+
+    while i < len {
+        if i + 1 < len && chars[i] == '-' && chars[i + 1] == '-' {
+            while i < len && chars[i] != '\n' {
+                result.push(chars[i]);
+                i += 1;
+            }
+            continue;
+        }
+
+        if i + 1 < len && chars[i] == '/' && chars[i + 1] == '*' {
+            while i + 1 < len && !(chars[i] == '*' && chars[i + 1] == '/') {
+                result.push(chars[i]);
+                i += 1;
+            }
+            if i + 1 < len {
+                result.push(chars[i]);
+                result.push(chars[i + 1]);
+                i += 2;
+            }
+            continue;
+        }
+
+        if chars[i] == '\'' {
+            result.push(chars[i]);
+            i += 1;
+            while i < len {
+                if chars[i] == '\'' {
+                    result.push('\'');
+                    i += 1;
+                    if i < len && chars[i] == '\'' {
+                        result.push('\'');
+                        i += 1;
+                    } else {
+                        break;
+                    }
+                } else {
+                    result.push(chars[i]);
+                    i += 1;
+                }
+            }
+            continue;
+        }
+
+        let prev = if i == 0 { '\0' } else { chars[i - 1] };
+        let boundary = !prev.is_alphanumeric() && prev != '_' && prev != '.';
+
+        if boundary {
+            let remaining: String = chars[i..].iter().collect();
+            let remaining_lower = remaining.to_lowercase();
+
+            let mut matched = false;
+            for (source, replacement) in SQLITE_FUNCTION_ALIASES {
+                if remaining_lower.starts_with(*source) && chars.get(i + source.len()) != Some(&'_') {
+                    let mut j = i + source.len();
+                    while j < len && chars[j].is_whitespace() {
+                        j += 1;
+                    }
+                    if j < len && chars[j] == '(' {
+                        let whitespace: String = chars[i + source.len()..j].iter().collect();
+                        result.push_str(replacement);
+                        result.push_str(&whitespace);
+                        i = j;
+                        matched = true;
+                        break;
+                    }
+                }
+            }
+            if matched {
+                continue;
+            }
+        }
+
+        result.push(chars[i]);
+        i += 1;
+    }
+
+    result
+}
+
+pub async fn execute_query_with_max_rows(
+    pool: &SqliteHandle,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<QueryResult, String> {
+    let pool = pool.clone();
+    let sql = normalize_sqlite_sql(sql);
+    tokio::task::spawn_blocking(move || execute_query_blocking(&pool, &sql, max_rows))
+        .await
+        .map_err(|e| e.to_string())?
+}
+
+fn execute_query_blocking(pool: &SqliteHandle, sql: &str, max_rows: Option<usize>) -> Result<QueryResult, String> {
+    let start = Instant::now();
+    let row_limit = query_result_row_limit(max_rows);
+
+    pool.with_connection(|conn| {
+        if starts_with_executable_sql_keyword(sql, &["SELECT", "PRAGMA", "EXPLAIN", "WITH"]) {
+            let mut stmt = conn.prepare(sql).map_err(|e| e.to_string())?;
+            let columns = stmt.column_names().iter().map(|name| name.to_string()).collect::<Vec<_>>();
+            let column_decl_types =
+                stmt.columns().iter().map(|column| column.decl_type().map(str::to_string)).collect::<Vec<_>>();
+            let mut rows = stmt.query([]).map_err(|e| e.to_string())?;
+            let mut result_rows = Vec::new();
+
+            while let Some(row) = rows.next().map_err(|e| e.to_string())? {
+                let mut values = Vec::with_capacity(columns.len());
+                for i in 0..columns.len() {
+                    values.push(value_ref_to_json(
+                        row.get_ref(i).map_err(|e| e.to_string())?,
+                        column_decl_types.get(i).and_then(Option::as_deref),
+                    ));
+                }
+                result_rows.push(values);
+                if result_rows.len() > row_limit {
+                    break;
+                }
+            }
+
+            let truncated = result_rows.len() > row_limit;
+            if truncated {
+                result_rows.truncate(row_limit);
+            }
+
+            Ok(QueryResult {
+                columns,
+                column_types: Vec::new(),
+                column_sortables: vec![],
+                rows: result_rows,
+                affected_rows: 0,
+                execution_time_ms: start.elapsed().as_millis(),
+                truncated,
+                session_id: None,
+                has_more: false,
+            })
+        } else {
+            conn.execute_batch(sql).map_err(|e| e.to_string())?;
+            Ok(QueryResult {
+                columns: vec![],
+                column_types: Vec::new(),
+                column_sortables: vec![],
+                rows: vec![],
+                affected_rows: conn.changes(),
+                execution_time_ms: start.elapsed().as_millis(),
+                truncated: false,
+                session_id: None,
+                has_more: false,
+            })
+        }
+    })
+}
+
+fn value_ref_to_json(value: ValueRef<'_>, column_decl_type: Option<&str>) -> serde_json::Value {
+    match value {
+        ValueRef::Null => serde_json::Value::Null,
+        ValueRef::Integer(v) => super::safe_i64_to_json(v),
+        ValueRef::Real(v) => {
+            serde_json::Number::from_f64(v).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null)
+        }
+        ValueRef::Text(v) => serde_json::Value::String(String::from_utf8_lossy(v).to_string()),
+        ValueRef::Blob(v) => sqlite_blob_value_to_json(v, column_decl_type),
+    }
+}
+
+fn sqlite_blob_value_to_json(bytes: &[u8], column_decl_type: Option<&str>) -> serde_json::Value {
+    if is_sqlite_text_affinity(column_decl_type) {
+        // SQLite columns can hold BLOB values even when declared as TEXT.
+        // Match common clients by showing valid UTF-8 bytes as text for text-affinity columns.
+        if let Ok(text) = std::str::from_utf8(bytes) {
+            return serde_json::Value::String(text.to_string());
+        }
+    }
+    super::binary_value_to_json(bytes)
+}
+
+fn is_sqlite_text_affinity(column_decl_type: Option<&str>) -> bool {
+    let upper = column_decl_type.unwrap_or("").to_ascii_uppercase();
+    upper.contains("CHAR") || upper.contains("CLOB") || upper.contains("TEXT")
+}
diff --git a/crates/dbx-core/src/db/sqlserver.rs b/crates/dbx-core/src/db/sqlserver.rs
new file mode 100644
index 0000000..6fa3738
--- /dev/null
+++ b/crates/dbx-core/src/db/sqlserver.rs
@@ -0,0 +1,2538 @@
+use crate::query::MAX_ROWS;
+use crate::sql::starts_with_executable_sql_keyword;
+use crate::types::{
+    ColumnInfo, DatabaseInfo, ForeignKeyInfo, IndexInfo, LinkedServerInfo, ObjectStatistics, QueryResult, TableInfo,
+    TriggerInfo,
+};
+use futures::{FutureExt, TryStreamExt};
+use rust_decimal::Decimal;
+use std::future::Future;
+use std::panic::AssertUnwindSafe;
+use std::time::{Duration, Instant};
+use tiberius::{AuthMethod, Client, ColumnData, Config, FromSql, QueryItem, QueryStream, SqlBrowser};
+use tokio::net::TcpStream;
+use tokio_util::compat::{Compat, TokioAsyncWriteCompatExt};
+use tokio_util::sync::CancellationToken;
+
+pub type SqlServerClient = Client<Compat<TcpStream>>;
+pub const SQLSERVER_DRIVER_PANIC_ERROR_PREFIX: &str = "SQL Server driver panic:";
+pub const SQLSERVER_LEGACY_DRIVER_PROFILE: &str = "sqlserver-legacy";
+pub const SQLSERVER_LEGACY_DRIVER_LABEL: &str = "SQL Server legacy compatibility component";
+const SIMPLE_QUERY_MODULE_KEYWORDS: &[&str] = &["FUNCTION", "PROC", "PROCEDURE", "TRIGGER", "VIEW"];
+// Match JDBC/tiberius `encrypt=false`: encrypt only login, then drop back to raw TDS.
+const SQLSERVER_LEGACY_ENCRYPTION_LEVEL: tiberius::EncryptionLevel = tiberius::EncryptionLevel::Off;
+// Some very old SQL Server setups only accepted DBX <= 0.5.48 because the fallback
+// advertised no encryption support at all. Keep it as the last-resort compatibility path.
+const SQLSERVER_UNSUPPORTED_ENCRYPTION_LEVEL: tiberius::EncryptionLevel = tiberius::EncryptionLevel::NotSupported;
+const SQLSERVER_LEGACY_ENCRYPTION_FALLBACKS: [(&str, tiberius::EncryptionLevel); 2] = [
+    ("login-only encryption", SQLSERVER_LEGACY_ENCRYPTION_LEVEL),
+    ("no-encryption compatibility fallback", SQLSERVER_UNSUPPORTED_ENCRYPTION_LEVEL),
+];
+
+#[derive(Debug, PartialEq, Eq)]
+struct SqlServerEndpoint<'a> {
+    host: &'a str,
+    instance_name: Option<&'a str>,
+}
+
+fn sqlserver_endpoint(host: &str) -> SqlServerEndpoint<'_> {
+    if let Some((server, instance)) = host.split_once('\\') {
+        if !server.trim().is_empty() && !instance.trim().is_empty() {
+            return SqlServerEndpoint { host: server.trim(), instance_name: Some(instance.trim()) };
+        }
+    }
+
+    SqlServerEndpoint { host: host.trim(), instance_name: None }
+}
+
+fn query_result_row_limit(max_rows: Option<usize>) -> usize {
+    max_rows.unwrap_or(MAX_ROWS).max(1)
+}
+
+pub async fn connect(
+    host: &str,
+    port: u16,
+    user: &str,
+    pass: &str,
+    database: Option<&str>,
+    _url_params: Option<&str>,
+    timeout: Duration,
+) -> Result<SqlServerClient, String> {
+    match try_connect(host, port, user, pass, database, tiberius::EncryptionLevel::Required, timeout).await {
+        Ok(client) => Ok(client),
+        Err(encrypted_error) => try_connect_legacy_sqlserver_encryption(host, port, user, pass, database, timeout)
+            .await
+            .map_err(|plain_error| {
+                if is_sqlserver_tls_handshake_error(&encrypted_error) {
+                    format!(
+                        "{encrypted_error}\n\nThis may be caused by an old SQL Server TLS/encryption configuration. \
+                         If you are connecting to SQL Server 2008/2008 R2/2012 or another legacy instance, \
+                         try SQL Server legacy compatibility mode. It first behaves like encrypt=false and, \
+                         when explicitly enabled, DBX can also fall back to the SQL Server legacy compatibility \
+                         driver for TLS 1.0 encrypted transport. Only use this mode on trusted networks, VPNs, \
+                         or SSH tunnels.\n\n\
+                         Automatic native legacy fallback also failed: {plain_error}"
+                    )
+                } else {
+                    plain_error
+                }
+            }),
+    }
+}
+
+async fn try_connect_legacy_sqlserver_encryption(
+    host: &str,
+    port: u16,
+    user: &str,
+    pass: &str,
+    database: Option<&str>,
+    timeout: Duration,
+) -> Result<SqlServerClient, String> {
+    let mut errors = Vec::new();
+    for (label, encryption) in SQLSERVER_LEGACY_ENCRYPTION_FALLBACKS {
+        match try_connect(host, port, user, pass, database, encryption, timeout).await {
+            Ok(client) => return Ok(client),
+            Err(error) => errors.push(format!("{label} failed: {error}")),
+        }
+    }
+
+    Err(errors.join("\n"))
+}
+
+pub fn sqlserver_legacy_compatibility_enabled(url_params: Option<&str>) -> bool {
+    let Some(params) = url_params.map(str::trim).filter(|params| !params.is_empty()) else {
+        return false;
+    };
+
+    params.trim_start_matches('?').split(['&', ';']).filter_map(|pair| pair.split_once('=')).any(|(key, value)| {
+        let key = key.trim();
+        let value = value.trim().to_ascii_lowercase();
+        let disabled = matches!(value.as_str(), "disabled" | "disable" | "false" | "0" | "off" | "no");
+        (key.eq_ignore_ascii_case("sqlserverEncryption") || key.eq_ignore_ascii_case("encrypt")) && disabled
+    })
+}
+
+fn is_sqlserver_tls_handshake_error(error: &str) -> bool {
+    let error = error.to_ascii_lowercase();
+    error.contains("tls") && (error.contains("handshake") || error.contains("eof") || error.contains("performing i/o"))
+}
+
+async fn try_connect(
+    host: &str,
+    port: u16,
+    user: &str,
+    pass: &str,
+    database: Option<&str>,
+    encryption: tiberius::EncryptionLevel,
+    timeout: Duration,
+) -> Result<SqlServerClient, String> {
+    let mut config = Config::new();
+    let endpoint = sqlserver_endpoint(host);
+    config.host(endpoint.host);
+    if let Some(instance_name) = endpoint.instance_name {
+        config.instance_name(instance_name);
+    } else {
+        config.port(port);
+    }
+    config.authentication(AuthMethod::sql_server(user, pass));
+    if let Some(db) = database {
+        config.database(db);
+    }
+    config.trust_cert();
+    config.encryption(encryption);
+
+    let tcp = if endpoint.instance_name.is_some() {
+        tokio::time::timeout(timeout, TcpStream::connect_named(&config))
+            .await
+            .map_err(|_| format!("SQL Server connection timed out ({}s)", timeout.as_secs()))?
+            .map_err(|e| format!("SQL Server connection failed: {e}"))?
+    } else {
+        tokio::time::timeout(timeout, TcpStream::connect(config.get_addr()))
+            .await
+            .map_err(|_| format!("SQL Server connection timed out ({}s)", timeout.as_secs()))?
+            .map_err(|e| format!("SQL Server connection failed: {e}"))?
+    };
+    tokio::time::timeout(timeout, Client::connect(config, tcp.compat_write()))
+        .await
+        .map_err(|_| format!("SQL Server handshake timed out ({}s)", timeout.as_secs()))?
+        .map_err(|e| format!("SQL Server connection failed: {e}"))
+}
+
+fn row_to_json(row: &tiberius::Row) -> Vec<serde_json::Value> {
+    row.cells().map(|(_, cell)| sqlserver_cell_to_json(cell)).collect()
+}
+
+fn columns_from_metadata(metadata: &tiberius::ResultMetadata) -> Vec<String> {
+    metadata.columns().iter().map(|c| c.name().to_string()).collect()
+}
+
+/// Map a tiberius column to a user-facing type name for the result-grid header.
+/// Uses the TDS column-type debug name lowercased; good enough for display, with
+/// no risk of mismatching the enum variants across tiberius versions.
+fn sqlserver_column_type_name(column: &tiberius::Column) -> String {
+    format!("{:?}", column.column_type()).to_lowercase()
+}
+
+fn column_types_from_metadata(metadata: &tiberius::ResultMetadata) -> Vec<String> {
+    metadata.columns().iter().map(sqlserver_column_type_name).collect()
+}
+
+async fn collect_first_result_limited(
+    mut stream: QueryStream<'_>,
+    start: Instant,
+    max_rows: Option<usize>,
+) -> Result<QueryResult, String> {
+    let row_limit = query_result_row_limit(max_rows);
+    let mut columns: Vec<String> = vec![];
+    let mut column_types: Vec<String> = vec![];
+    let mut rows: Vec<Vec<serde_json::Value>> = Vec::new();
+    let mut truncated = false;
+
+    while let Some(item) = stream.try_next().await.map_err(|e| e.to_string())? {
+        match item {
+            QueryItem::Metadata(metadata) if metadata.result_index() == 0 => {
+                columns = columns_from_metadata(&metadata);
+                column_types = column_types_from_metadata(&metadata);
+            }
+            QueryItem::Metadata(_) => {}
+            QueryItem::Row(row) if row.result_index() == 0 => {
+                if rows.len() < row_limit {
+                    rows.push(row_to_json(&row));
+                } else {
+                    truncated = true;
+                }
+            }
+            QueryItem::Row(_) => {}
+        }
+    }
+
+    Ok(QueryResult {
+        columns,
+        column_types,
+        column_sortables: vec![],
+        rows,
+        affected_rows: 0,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+struct SqlServerResultSet {
+    columns: Vec<String>,
+    column_types: Vec<String>,
+    rows: Vec<Vec<serde_json::Value>>,
+    truncated: bool,
+}
+
+pub struct SqlServerStreamExportSummary {
+    pub columns: Vec<String>,
+    pub rows_exported: u64,
+}
+
+pub enum SqlServerStreamItem<'a> {
+    Columns(&'a [String]),
+    Row(&'a [serde_json::Value]),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct SqlServerDescribedColumn {
+    name: Option<String>,
+    system_type_name: Option<String>,
+    user_type_schema: Option<String>,
+    user_type_name: Option<String>,
+}
+
+async fn sqlserver_driver_result<T, E, F>(future: F) -> Result<T, String>
+where
+    F: Future<Output = Result<T, E>>,
+    E: ToString,
+{
+    match AssertUnwindSafe(future).catch_unwind().await {
+        Ok(result) => result.map_err(|e| e.to_string()),
+        Err(_) => Err(format!(
+            "{SQLSERVER_DRIVER_PANIC_ERROR_PREFIX} the current client will be rebuilt. \
+                 Unsupported columns may need to be cast to text."
+        )),
+    }
+}
+
+pub fn is_driver_panic_error(error: &str) -> bool {
+    error.starts_with(SQLSERVER_DRIVER_PANIC_ERROR_PREFIX)
+}
+
+async fn describe_sqlserver_result_set(
+    client: &mut SqlServerClient,
+    sql: &str,
+) -> Result<Vec<SqlServerDescribedColumn>, String> {
+    let describe_sql = "\
+        SELECT name, system_type_name, user_type_schema, user_type_name \
+        FROM sys.dm_exec_describe_first_result_set(@P1, NULL, 0) \
+        WHERE error_number IS NULL AND is_hidden = 0 \
+        ORDER BY column_ordinal";
+    let stream = sqlserver_driver_result(client.query(describe_sql, &[&sql])).await?;
+    let rows = sqlserver_driver_result(stream.into_first_result()).await?;
+
+    Ok(rows
+        .iter()
+        .map(|row| SqlServerDescribedColumn {
+            name: row.try_get::<&str, _>(0).ok().flatten().map(str::to_string),
+            system_type_name: row.try_get::<&str, _>(1).ok().flatten().map(str::to_string),
+            user_type_schema: row.try_get::<&str, _>(2).ok().flatten().map(str::to_string),
+            user_type_name: row.try_get::<&str, _>(3).ok().flatten().map(str::to_string),
+        })
+        .collect())
+}
+
+async fn sqlserver_unsafe_type_query(client: &mut SqlServerClient, sql: &str) -> Result<Option<String>, String> {
+    if !is_single_sqlserver_select(sql) {
+        return Ok(None);
+    }
+    let columns = describe_sqlserver_result_set(client, sql).await?;
+    Ok(build_sqlserver_unsafe_type_query(sql, &columns))
+}
+
+fn build_sqlserver_unsafe_type_query(sql: &str, columns: &[SqlServerDescribedColumn]) -> Option<String> {
+    if columns.is_empty() || !columns.iter().any(is_sqlserver_unsafe_column) {
+        return None;
+    }
+    let statement = normalized_sqlserver_select_statement(sql)?;
+    let source_alias = quote_sqlserver_identifier("dbx_unsafe_source");
+    let source_columns = (0..columns.len()).map(sqlserver_source_column_name).collect::<Vec<_>>();
+    let source_alias_list =
+        source_columns.iter().map(|name| quote_sqlserver_identifier(name)).collect::<Vec<_>>().join(", ");
+    let select_list = columns
+        .iter()
+        .enumerate()
+        .map(|(index, column)| {
+            let output_name = sqlserver_output_column_name(column, index);
+            let quoted_output = quote_sqlserver_identifier(&output_name);
+            let source_column = quote_sqlserver_identifier(&source_columns[index]);
+            let value_ref = format!("{source_alias}.{source_column}");
+            if is_sqlserver_spatial_column(column) {
+                format!("{quoted_output} = CASE WHEN {value_ref} IS NULL THEN NULL ELSE {value_ref}.STAsText() END")
+            } else if is_sqlserver_variant_column(column) {
+                format!("{quoted_output} = CAST({value_ref} AS NVARCHAR(MAX))")
+            } else {
+                format!("{quoted_output} = {value_ref}")
+            }
+        })
+        .collect::<Vec<_>>()
+        .join(", ");
+
+    Some(format!("SELECT {select_list} FROM ({statement}) AS {source_alias}({source_alias_list})"))
+}
+
+fn is_sqlserver_unsafe_column(column: &SqlServerDescribedColumn) -> bool {
+    is_sqlserver_spatial_column(column) || is_sqlserver_variant_column(column)
+}
+
+fn is_sqlserver_spatial_column(column: &SqlServerDescribedColumn) -> bool {
+    [&column.system_type_name, &column.user_type_name].into_iter().flatten().any(|name| {
+        let normalized = name.trim().trim_matches(['[', ']']).to_ascii_lowercase();
+        normalized == "geometry"
+            || normalized == "geography"
+            || normalized.ends_with(".geometry")
+            || normalized.ends_with(".geography")
+    })
+}
+
+fn is_sqlserver_variant_column(column: &SqlServerDescribedColumn) -> bool {
+    [&column.system_type_name, &column.user_type_name].into_iter().flatten().any(|name| {
+        let normalized = name.trim().trim_matches(['[', ']']).to_ascii_lowercase();
+        normalized == "sql_variant" || normalized.ends_with(".sql_variant")
+    })
+}
+
+fn normalized_sqlserver_select_statement(sql: &str) -> Option<String> {
+    let statement = trim_sqlserver_statement(sql);
+    let trimmed = statement.trim_start();
+    if trimmed.is_empty() || !trimmed.get(..6).is_some_and(|prefix| prefix.eq_ignore_ascii_case("SELECT")) {
+        return None;
+    }
+    if has_top_level_select_into(trimmed) {
+        return None;
+    }
+
+    // Strip trailing ORDER BY so the statement can be used as a derived table
+    // subquery. SQL Server requires TOP / OFFSET / FOR XML alongside ORDER BY
+    // in subqueries, none of which are version-safe across 2008–2022.
+    let mut statement = trimmed.to_string();
+    let tokens = top_level_sqlserver_tokens(&statement);
+    for index in (0..tokens.len().saturating_sub(1)).rev() {
+        if tokens[index].text == "ORDER" && tokens.get(index + 1).is_some_and(|token| token.text == "BY") {
+            statement.truncate(tokens[index].start);
+            statement = statement.trim_end().to_string();
+            break;
+        }
+    }
+    Some(statement)
+}
+
+fn trim_sqlserver_statement(sql: &str) -> String {
+    let mut statement = sql.trim();
+    while let Some(stripped) = statement.strip_suffix(';') {
+        statement = stripped.trim_end();
+    }
+    statement.to_string()
+}
+
+fn is_single_sqlserver_select(sql: &str) -> bool {
+    let statements = crate::sql::split_sql_statements(sql);
+    if statements.len() != 1 {
+        return false;
+    }
+    let statement = statements[0].trim_start();
+    statement.get(..6).is_some_and(|prefix| prefix.eq_ignore_ascii_case("SELECT"))
+}
+
+fn sqlserver_source_column_name(index: usize) -> String {
+    format!("dbx_col_{}", index + 1)
+}
+
+fn sqlserver_output_column_name(column: &SqlServerDescribedColumn, index: usize) -> String {
+    column
+        .name
+        .as_deref()
+        .map(str::trim)
+        .filter(|name| !name.is_empty())
+        .map(str::to_string)
+        .unwrap_or_else(|| format!("column_{}", index + 1))
+}
+
+fn quote_sqlserver_identifier(identifier: &str) -> String {
+    format!("[{}]", identifier.replace(']', "]]"))
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct SqlServerToken {
+    text: String,
+    start: usize,
+}
+
+fn top_level_sqlserver_tokens(sql: &str) -> Vec<SqlServerToken> {
+    let mut tokens = Vec::new();
+    let mut i = 0;
+    let mut depth = 0usize;
+
+    while i < sql.len() {
+        let ch = next_char(sql, i);
+        let next = next_char_at(sql, i + ch.len_utf8());
+
+        if ch == '-' && next == Some('-') {
+            i += 2;
+            while i < sql.len() && next_char(sql, i) != '\n' {
+                i += next_char(sql, i).len_utf8();
+            }
+            continue;
+        }
+        if ch == '/' && next == Some('*') {
+            i += 2;
+            while i < sql.len() {
+                let current = next_char(sql, i);
+                let following = next_char_at(sql, i + current.len_utf8());
+                if current == '*' && following == Some('/') {
+                    i += 2;
+                    break;
+                }
+                i += current.len_utf8();
+            }
+            continue;
+        }
+        if matches!(ch, '\'' | '"') {
+            i = skip_sqlserver_quoted(sql, i, ch);
+            continue;
+        }
+        if ch == '[' {
+            i = skip_sqlserver_bracket_identifier(sql, i);
+            continue;
+        }
+        if ch == '(' {
+            depth += 1;
+            i += ch.len_utf8();
+            continue;
+        }
+        if ch == ')' {
+            depth = depth.saturating_sub(1);
+            i += ch.len_utf8();
+            continue;
+        }
+        if depth == 0 && is_sqlserver_token_start(ch) {
+            let start = i;
+            i += ch.len_utf8();
+            while i < sql.len() && is_sqlserver_token_part(next_char(sql, i)) {
+                i += next_char(sql, i).len_utf8();
+            }
+            tokens.push(SqlServerToken { text: sql[start..i].to_ascii_uppercase(), start });
+            continue;
+        }
+        i += ch.len_utf8();
+    }
+
+    tokens
+}
+
+fn has_top_level_select_into(sql: &str) -> bool {
+    let tokens = top_level_sqlserver_tokens(sql);
+    let Some(select_index) = tokens.iter().position(|token| token.text == "SELECT") else {
+        return false;
+    };
+    let from_index = tokens
+        .iter()
+        .enumerate()
+        .find(|(index, token)| *index > select_index && token.text == "FROM")
+        .map(|(index, _)| index)
+        .unwrap_or(tokens.len());
+    tokens[select_index + 1..from_index].iter().any(|token| token.text == "INTO")
+}
+
+fn skip_sqlserver_quoted(sql: &str, pos: usize, quote: char) -> usize {
+    let mut i = pos + quote.len_utf8();
+    while i < sql.len() {
+        let ch = next_char(sql, i);
+        let next = next_char_at(sql, i + ch.len_utf8());
+        if ch == quote {
+            if next == Some(quote) {
+                i += ch.len_utf8() + quote.len_utf8();
+                continue;
+            }
+            return i + ch.len_utf8();
+        }
+        i += ch.len_utf8();
+    }
+    sql.len()
+}
+
+fn skip_sqlserver_bracket_identifier(sql: &str, pos: usize) -> usize {
+    let mut i = pos + 1;
+    while i < sql.len() {
+        let ch = next_char(sql, i);
+        let next = next_char_at(sql, i + ch.len_utf8());
+        if ch == ']' {
+            if next == Some(']') {
+                i += 2;
+                continue;
+            }
+            return i + 1;
+        }
+        i += ch.len_utf8();
+    }
+    sql.len()
+}
+
+fn is_sqlserver_token_start(ch: char) -> bool {
+    ch.is_ascii_alphabetic() || ch == '_'
+}
+
+fn is_sqlserver_token_part(ch: char) -> bool {
+    ch.is_ascii_alphanumeric() || matches!(ch, '_' | '$' | '#')
+}
+
+fn next_char(sql: &str, index: usize) -> char {
+    sql[index..].chars().next().unwrap_or('\0')
+}
+
+fn next_char_at(sql: &str, index: usize) -> Option<char> {
+    if index >= sql.len() {
+        None
+    } else {
+        sql[index..].chars().next()
+    }
+}
+
+fn push_sqlserver_result_set(results: &mut Vec<QueryResult>, result: Option<SqlServerResultSet>, start: Instant) {
+    if let Some(result) = result {
+        if result.rows.is_empty() && result.columns.is_empty() {
+            return;
+        }
+        results.push(QueryResult {
+            columns: result.columns,
+            column_types: result.column_types,
+            column_sortables: vec![],
+            rows: result.rows,
+            affected_rows: 0,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: result.truncated,
+            session_id: None,
+            has_more: false,
+        });
+    }
+}
+
+async fn collect_result_sets_limited(
+    mut stream: QueryStream<'_>,
+    start: Instant,
+    max_rows: Option<usize>,
+) -> Result<Vec<QueryResult>, String> {
+    let row_limit = query_result_row_limit(max_rows);
+    let mut results = Vec::new();
+    let mut current: Option<SqlServerResultSet> = None;
+
+    while let Some(item) = stream.try_next().await.map_err(|e| e.to_string())? {
+        match item {
+            QueryItem::Metadata(metadata) => {
+                push_sqlserver_result_set(&mut results, current.take(), start);
+                current = Some(SqlServerResultSet {
+                    columns: columns_from_metadata(&metadata),
+                    column_types: column_types_from_metadata(&metadata),
+                    rows: Vec::new(),
+                    truncated: false,
+                });
+            }
+            QueryItem::Row(row) => {
+                let result = current.get_or_insert_with(|| SqlServerResultSet {
+                    columns: row.columns().iter().map(|c| c.name().to_string()).collect(),
+                    column_types: row.columns().iter().map(sqlserver_column_type_name).collect(),
+                    rows: Vec::new(),
+                    truncated: false,
+                });
+                if result.rows.len() < row_limit {
+                    result.rows.push(row_to_json(&row));
+                } else {
+                    result.truncated = true;
+                }
+            }
+        }
+    }
+
+    push_sqlserver_result_set(&mut results, current, start);
+    Ok(results)
+}
+
+pub async fn stream_first_result_set(
+    client: &mut SqlServerClient,
+    sql: &str,
+    row_limit: Option<usize>,
+    cancel_token: Option<CancellationToken>,
+    mut on_item: impl for<'a> FnMut(SqlServerStreamItem<'a>) -> Result<(), String>,
+) -> Result<SqlServerStreamExportSummary, String> {
+    let query_sql = match sqlserver_unsafe_type_query(client, sql).await {
+        Ok(Some(sql)) => sql,
+        Ok(None) | Err(_) => sql.to_string(),
+    };
+    let mut stream = sqlserver_driver_result(client.query(query_sql.as_str(), &[])).await?;
+    let mut active_result_index: Option<usize> = None;
+    let mut columns: Vec<String> = Vec::new();
+    let mut columns_emitted = false;
+    let mut rows_exported = 0_u64;
+
+    loop {
+        if cancel_token.as_ref().is_some_and(|token| token.is_cancelled()) {
+            return Err(crate::query::canceled_error());
+        }
+        let item = match cancel_token.as_ref() {
+            Some(token) => {
+                tokio::select! {
+                    biased;
+                    _ = token.cancelled() => return Err(crate::query::canceled_error()),
+                    item = stream.try_next() => item.map_err(|e| e.to_string())?,
+                }
+            }
+            None => stream.try_next().await.map_err(|e| e.to_string())?,
+        };
+        let Some(item) = item else {
+            break;
+        };
+        match item {
+            QueryItem::Metadata(metadata) => {
+                if active_result_index.is_none() {
+                    active_result_index = Some(metadata.result_index());
+                    columns = columns_from_metadata(&metadata);
+                    on_item(SqlServerStreamItem::Columns(&columns))?;
+                    columns_emitted = true;
+                }
+            }
+            QueryItem::Row(row) => {
+                if active_result_index.is_none() {
+                    active_result_index = Some(row.result_index());
+                    columns = row.columns().iter().map(|c| c.name().to_string()).collect();
+                    on_item(SqlServerStreamItem::Columns(&columns))?;
+                    columns_emitted = true;
+                }
+                if Some(row.result_index()) != active_result_index {
+                    continue;
+                }
+                if row_limit.is_some_and(|limit| rows_exported as usize >= limit) {
+                    break;
+                }
+                let values = row_to_json(&row);
+                on_item(SqlServerStreamItem::Row(&values))?;
+                rows_exported += 1;
+            }
+        }
+    }
+
+    if !columns_emitted {
+        on_item(SqlServerStreamItem::Columns(&columns))?;
+    }
+    Ok(SqlServerStreamExportSummary { columns, rows_exported })
+}
+
+fn sqlserver_cell_to_json(cell: &ColumnData<'static>) -> serde_json::Value {
+    if let Ok(Some(v)) = <&str as FromSql>::from_sql(cell) {
+        return serde_json::Value::String(v.to_string());
+    }
+    if let Ok(Some(v)) = <chrono::NaiveDateTime as FromSql>::from_sql(cell) {
+        let value = match cell {
+            ColumnData::DateTime(_) => crate::sqlserver_temporal::format_sqlserver_datetime_display(&v),
+            _ => v.to_string(),
+        };
+        return serde_json::Value::String(value);
+    }
+    if let Ok(Some(v)) = <chrono::NaiveDate as FromSql>::from_sql(cell) {
+        return serde_json::Value::String(v.to_string());
+    }
+    if let Ok(Some(v)) = <chrono::NaiveTime as FromSql>::from_sql(cell) {
+        return serde_json::Value::String(v.to_string());
+    }
+    if let Ok(Some(v)) = <chrono::DateTime<chrono::FixedOffset> as FromSql>::from_sql(cell) {
+        return serde_json::Value::String(v.to_rfc3339());
+    }
+    if let Ok(Some(v)) = <Decimal as FromSql>::from_sql(cell) {
+        return serde_json::Value::String(v.to_string());
+    }
+    if let Ok(Some(v)) = <u8 as FromSql>::from_sql(cell) {
+        return serde_json::Value::Number(v.into());
+    }
+    if let Ok(Some(v)) = <i16 as FromSql>::from_sql(cell) {
+        return serde_json::Value::Number(v.into());
+    }
+    if let Ok(Some(v)) = <i32 as FromSql>::from_sql(cell) {
+        return serde_json::Value::Number(v.into());
+    }
+    if let Ok(Some(v)) = <i64 as FromSql>::from_sql(cell) {
+        return super::safe_i64_to_json(v);
+    }
+    if let Ok(Some(v)) = <f32 as FromSql>::from_sql(cell) {
+        return serde_json::Number::from_f64(v as f64)
+            .map(serde_json::Value::Number)
+            .unwrap_or(serde_json::Value::Null);
+    }
+    if let Ok(Some(v)) = <f64 as FromSql>::from_sql(cell) {
+        return serde_json::Number::from_f64(v).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null);
+    }
+    if let Ok(Some(v)) = <bool as FromSql>::from_sql(cell) {
+        return serde_json::Value::Bool(v);
+    }
+    if let Ok(Some(v)) = <uuid::Uuid as FromSql>::from_sql(cell) {
+        return serde_json::Value::String(v.to_string());
+    }
+    if let Ok(Some(v)) = <Vec<u8> as tiberius::FromSqlOwned>::from_sql_owned(cell.clone()) {
+        return super::binary_value_to_json(&v);
+    }
+    serde_json::Value::Null
+}
+
+pub async fn list_databases(client: &mut SqlServerClient) -> Result<Vec<DatabaseInfo>, String> {
+    let stream = client
+        .query(
+            "SELECT name \
+             FROM sys.databases \
+             WHERE state = 0 \
+             ORDER BY name",
+            &[],
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows.iter().map(|row| DatabaseInfo { name: row.get::<&str, _>(0).unwrap_or("").to_string() }).collect())
+}
+
+pub async fn test_connection(client: &mut SqlServerClient) -> Result<(), String> {
+    crate::db::with_connection_timeout("SQL Server", crate::db::connection_timeout(), async {
+        let stream = client.simple_query("SELECT 1").await.map_err(|e| e.to_string())?;
+        let _ = stream.into_first_result().await.map_err(|e| e.to_string())?;
+        Ok(())
+    })
+    .await
+}
+
+pub async fn list_linked_servers(client: &mut SqlServerClient) -> Result<Vec<LinkedServerInfo>, String> {
+    let stream = client
+        .query(
+            "SELECT name, product, provider, data_source \
+             FROM sys.servers \
+             WHERE is_linked = 1 \
+             ORDER BY name",
+            &[],
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .map(|row| LinkedServerInfo {
+            name: row.get::<&str, _>(0).unwrap_or("").to_string(),
+            product: row.get::<&str, _>(1).filter(|value| !value.trim().is_empty()).map(str::to_string),
+            provider: row.get::<&str, _>(2).filter(|value| !value.trim().is_empty()).map(str::to_string),
+            data_source: row.get::<&str, _>(3).filter(|value| !value.trim().is_empty()).map(str::to_string),
+        })
+        .filter(|server| !server.name.trim().is_empty())
+        .collect())
+}
+
+pub async fn list_linked_server_catalogs(
+    client: &mut SqlServerClient,
+    server: &str,
+) -> Result<Vec<DatabaseInfo>, String> {
+    let stream = client.query("EXEC sp_catalogs @server_name = @P1", &[&server]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .filter_map(|row| row.get::<&str, _>(0).map(str::trim).filter(|name| !name.is_empty()))
+        .map(|name| DatabaseInfo { name: name.to_string() })
+        .collect())
+}
+
+pub async fn list_linked_server_schemas(
+    client: &mut SqlServerClient,
+    server: &str,
+    catalog: &str,
+) -> Result<Vec<String>, String> {
+    let tables = linked_server_table_rows(client, server, catalog, None, None).await?;
+    let mut schemas = Vec::new();
+    for table in tables {
+        if let Some(schema) = table.schema.filter(|value| !value.trim().is_empty()) {
+            if !schemas.iter().any(|existing: &String| existing.eq_ignore_ascii_case(&schema)) {
+                schemas.push(schema);
+            }
+        }
+    }
+    schemas.sort_by_key(|schema| (if schema.eq_ignore_ascii_case("dbo") { 0 } else { 1 }, schema.to_lowercase()));
+    Ok(schemas)
+}
+
+pub async fn list_linked_server_tables(
+    client: &mut SqlServerClient,
+    server: &str,
+    catalog: &str,
+    schema: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+) -> Result<Vec<TableInfo>, String> {
+    let filter = filter.map(str::trim).filter(|value| !value.is_empty()).map(str::to_lowercase);
+    let limit = limit.unwrap_or(usize::MAX);
+    let offset = offset.unwrap_or(0);
+    let rows = linked_server_table_rows(client, server, catalog, Some(schema), None).await?;
+    Ok(rows
+        .into_iter()
+        .filter(|row| filter.as_ref().is_none_or(|value| row.name.to_lowercase().contains(value)))
+        .skip(offset)
+        .take(limit)
+        .map(|row| TableInfo {
+            name: row.name,
+            table_type: normalize_linked_server_table_type(row.table_type.as_deref()),
+            comment: row.comment,
+            parent_schema: None,
+            parent_name: None,
+        })
+        .collect())
+}
+
+pub async fn get_linked_server_columns(
+    client: &mut SqlServerClient,
+    server: &str,
+    catalog: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<ColumnInfo>, String> {
+    let stream = client
+        .query(
+            "EXEC sp_columns_ex \
+             @table_server = @P1, \
+             @table_name = @P2, \
+             @table_schema = @P3, \
+             @table_catalog = @P4",
+            &[&server, &table, &schema, &catalog],
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .filter_map(|row| {
+            let name = row.get::<&str, _>(3)?.trim();
+            if name.is_empty() {
+                return None;
+            }
+            let base_type = row.get::<&str, _>(5).unwrap_or("").trim();
+            let column_size = linked_i32(row, 6);
+            let numeric_scale = linked_i32(row, 8);
+            let nullable = linked_i32(row, 10).unwrap_or(1) != 0;
+            let data_type = linked_server_column_type(base_type, column_size, numeric_scale);
+            Some(ColumnInfo {
+                name: name.to_string(),
+                data_type,
+                is_nullable: nullable,
+                column_default: row.get::<&str, _>(12).filter(|value| !value.trim().is_empty()).map(str::to_string),
+                is_primary_key: false,
+                extra: None,
+                comment: row.get::<&str, _>(11).filter(|value| !value.trim().is_empty()).map(str::to_string),
+                numeric_precision: column_size,
+                numeric_scale,
+                character_maximum_length: linked_i32(row, 15),
+                enum_values: None,
+                ..Default::default()
+            })
+        })
+        .collect())
+}
+
+struct LinkedServerTableRow {
+    schema: Option<String>,
+    name: String,
+    table_type: Option<String>,
+    comment: Option<String>,
+}
+
+async fn linked_server_table_rows(
+    client: &mut SqlServerClient,
+    server: &str,
+    catalog: &str,
+    schema: Option<&str>,
+    table_name: Option<&str>,
+) -> Result<Vec<LinkedServerTableRow>, String> {
+    let sql = format!(
+        "EXEC sp_tables_ex \
+         @table_server = {}, \
+         @table_name = {}, \
+         @table_schema = {}, \
+         @table_catalog = {}, \
+         @table_type = '''TABLE'',''VIEW''', \
+         @fUsePattern = 0",
+        sqlserver_nstring_literal(server),
+        sqlserver_optional_nstring_literal(table_name),
+        sqlserver_optional_nstring_literal(schema),
+        sqlserver_nstring_literal(catalog),
+    );
+    let stream = client.query(sql.as_str(), &[]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .filter_map(|row| {
+            let name = row.get::<&str, _>(2)?.trim();
+            if name.is_empty() {
+                return None;
+            }
+            Some(LinkedServerTableRow {
+                schema: row.get::<&str, _>(1).filter(|value| !value.trim().is_empty()).map(str::to_string),
+                name: name.to_string(),
+                table_type: row.get::<&str, _>(3).filter(|value| !value.trim().is_empty()).map(str::to_string),
+                comment: row.get::<&str, _>(4).filter(|value| !value.trim().is_empty()).map(str::to_string),
+            })
+        })
+        .collect())
+}
+
+fn sqlserver_optional_nstring_literal(value: Option<&str>) -> String {
+    value.filter(|value| !value.trim().is_empty()).map(sqlserver_nstring_literal).unwrap_or_else(|| "NULL".to_string())
+}
+
+fn sqlserver_nstring_literal(value: &str) -> String {
+    format!("N'{}'", value.replace('\'', "''"))
+}
+
+fn normalize_linked_server_table_type(value: Option<&str>) -> String {
+    let upper = value.unwrap_or("TABLE").to_ascii_uppercase();
+    if upper.contains("VIEW") {
+        "VIEW".to_string()
+    } else {
+        "BASE TABLE".to_string()
+    }
+}
+
+fn linked_server_column_type(base_type: &str, size: Option<i32>, scale: Option<i32>) -> String {
+    let lower = base_type.to_ascii_lowercase();
+    if matches!(lower.as_str(), "varchar" | "nvarchar" | "char" | "nchar" | "binary" | "varbinary") {
+        if let Some(size) = size {
+            if size > 0 {
+                return format!("{base_type}({size})");
+            }
+        }
+    }
+    if matches!(lower.as_str(), "decimal" | "numeric") {
+        if let (Some(size), Some(scale)) = (size, scale) {
+            return format!("{base_type}({size},{scale})");
+        }
+    }
+    base_type.to_string()
+}
+
+fn linked_i32(row: &tiberius::Row, index: usize) -> Option<i32> {
+    row.try_get::<i32, _>(index).ok().flatten().or_else(|| row.try_get::<i16, _>(index).ok().flatten().map(i32::from))
+}
+
+pub async fn list_schemas(client: &mut SqlServerClient) -> Result<Vec<String>, String> {
+    let sql = sqlserver_list_schemas_sql();
+    let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows.iter().map(|row| row.get::<&str, _>(0).unwrap_or("").to_string()).collect())
+}
+
+fn sqlserver_list_schemas_sql() -> String {
+    let excluded_schemas =
+        sqlserver_hidden_schema_names().iter().map(|name| format!("'{name}'")).collect::<Vec<_>>().join(",");
+    format!(
+        "SELECT s.name \
+         FROM sys.schemas s \
+         WHERE s.name NOT IN ({excluded_schemas}) \
+         ORDER BY CASE WHEN s.name = 'dbo' THEN 0 ELSE 1 END, s.name"
+    )
+}
+
+pub async fn list_tables(
+    client: &mut SqlServerClient,
+    schema: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+) -> Result<Vec<TableInfo>, String> {
+    let sql = sqlserver_list_tables_sql(schema, filter, limit, offset);
+    let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .map(|row| TableInfo {
+            name: row.get::<&str, _>(0).unwrap_or("").to_string(),
+            table_type: row.get::<&str, _>(1).unwrap_or("BASE TABLE").to_string(),
+            comment: row.get::<&str, _>(2).filter(|s: &&str| !s.is_empty()).map(|s: &str| s.to_string()),
+            parent_schema: None,
+            parent_name: None,
+        })
+        .collect())
+}
+
+pub async fn completion_assistant_search(
+    client: &mut SqlServerClient,
+    request: &crate::types::CompletionAssistantRequest,
+) -> Result<crate::types::CompletionAssistantResponse, String> {
+    let limit = request.max_results.unwrap_or(100).clamp(1, 1000);
+    let sql = sqlserver_completion_assistant_sql(request, limit);
+    let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    let candidates = rows
+        .iter()
+        .map(|row| {
+            let object_type = row.get::<&str, _>(2).unwrap_or("OBJECT");
+            crate::types::CompletionAssistantCandidate {
+                name: row.get::<&str, _>(0).unwrap_or("").to_string(),
+                kind: sqlserver_completion_candidate_kind(object_type),
+                database: Some(request.database.clone()),
+                schema: row.get::<&str, _>(1).map(str::to_string),
+                parent_schema: row.get::<&str, _>(3).map(str::to_string),
+                parent_name: row.get::<&str, _>(4).map(str::to_string),
+                comment: row.get::<&str, _>(5).filter(|s: &&str| !s.is_empty()).map(|s| (*s).to_string()),
+                data_type: row.get::<&str, _>(6).map(str::to_string),
+            }
+        })
+        .collect::<Vec<_>>();
+    Ok(crate::types::CompletionAssistantResponse {
+        incomplete: candidates.len() >= limit,
+        candidates,
+        fallback_used: false,
+    })
+}
+
+fn sqlserver_completion_candidate_kind(object_type: &str) -> crate::types::CompletionAssistantCandidateKind {
+    match object_type.to_ascii_uppercase().as_str() {
+        "SCHEMA" => crate::types::CompletionAssistantCandidateKind::Schema,
+        "TABLE" | "BASE TABLE" => crate::types::CompletionAssistantCandidateKind::Table,
+        "VIEW" => crate::types::CompletionAssistantCandidateKind::View,
+        "PROCEDURE" => crate::types::CompletionAssistantCandidateKind::Procedure,
+        "FUNCTION" => crate::types::CompletionAssistantCandidateKind::Function,
+        "COLUMN" => crate::types::CompletionAssistantCandidateKind::Column,
+        _ => crate::types::CompletionAssistantCandidateKind::Object,
+    }
+}
+
+fn sqlserver_completion_assistant_sql(request: &crate::types::CompletionAssistantRequest, limit: usize) -> String {
+    let object_kinds = if request.object_kinds.is_empty() {
+        vec![crate::types::CompletionAssistantObjectKind::Table, crate::types::CompletionAssistantObjectKind::View]
+    } else {
+        request.object_kinds.clone()
+    };
+    let mask = request.mask.trim();
+    let like_pattern = completion_like_pattern(mask, request.match_mode.as_ref());
+    let like_clause = if like_pattern == "%" {
+        String::new()
+    } else {
+        format!(" AND LOWER({}) LIKE LOWER('{like_pattern}') ESCAPE '\\' ", "name_expr")
+    };
+    let schema_filter = request
+        .schema
+        .as_deref()
+        .or(request.parent_schema.as_deref())
+        .filter(|schema| !schema.trim().is_empty())
+        .map(|schema| format!(" AND s.name = '{}' ", schema.replace('\'', "''")))
+        .unwrap_or_default();
+
+    let mut queries = Vec::new();
+    if (mask.starts_with('#') || mask.starts_with("%#"))
+        && object_kinds.iter().any(crate::types::CompletionAssistantObjectKind::is_table_like)
+    {
+        let object_like = sqlserver_completion_object_search_clause(request, &like_pattern);
+        queries.push(format!(
+            "SELECT TOP ({limit}) o.name, s.name AS schema_name, 'TABLE' AS object_type, CAST(NULL AS NVARCHAR(128)) AS parent_schema, CAST(NULL AS NVARCHAR(128)) AS parent_name, CAST(NULL AS NVARCHAR(MAX)) AS object_comment, CAST(NULL AS NVARCHAR(128)) AS data_type \
+             FROM tempdb.sys.all_objects o \
+             JOIN tempdb.sys.schemas s ON s.schema_id = o.schema_id \
+             WHERE o.type = 'U' {object_like}"
+        ));
+        return format!("SELECT * FROM ({}) AS dbx_completion ORDER BY name", queries.remove(0));
+    }
+    if object_kinds.iter().any(|kind| matches!(kind, crate::types::CompletionAssistantObjectKind::Schema)) {
+        let schema_like = like_clause.replace("name_expr", "s.name");
+        queries.push(format!(
+            "SELECT TOP ({limit}) s.name, s.name AS schema_name, 'SCHEMA' AS object_type, CAST(NULL AS NVARCHAR(128)) AS parent_schema, CAST(NULL AS NVARCHAR(128)) AS parent_name, CAST(NULL AS NVARCHAR(MAX)) AS object_comment, CAST(NULL AS NVARCHAR(128)) AS data_type \
+             FROM sys.schemas s \
+             WHERE s.name NOT IN ('guest','INFORMATION_SCHEMA','sys') {schema_like}"
+        ));
+    }
+    if object_kinds.iter().any(crate::types::CompletionAssistantObjectKind::is_table_like)
+        || object_kinds.iter().any(crate::types::CompletionAssistantObjectKind::is_routine_like)
+    {
+        let mut type_ids = Vec::new();
+        if object_kinds.iter().any(|kind| matches!(kind, crate::types::CompletionAssistantObjectKind::Table)) {
+            type_ids.push("'U'");
+        }
+        if object_kinds.iter().any(|kind| matches!(kind, crate::types::CompletionAssistantObjectKind::View)) {
+            type_ids.push("'V'");
+        }
+        if object_kinds.iter().any(|kind| {
+            matches!(
+                kind,
+                crate::types::CompletionAssistantObjectKind::Procedure
+                    | crate::types::CompletionAssistantObjectKind::Routine
+            )
+        }) {
+            type_ids.push("'P'");
+        }
+        if object_kinds.iter().any(|kind| {
+            matches!(
+                kind,
+                crate::types::CompletionAssistantObjectKind::Function
+                    | crate::types::CompletionAssistantObjectKind::Routine
+            )
+        }) {
+            type_ids.extend(["'FN'", "'IF'", "'TF'", "'FS'", "'FT'"]);
+        }
+        let object_like = sqlserver_completion_object_search_clause(request, &like_pattern);
+        let object_visibility = sqlserver_visible_object_predicate();
+        queries.push(format!(
+            "SELECT TOP ({limit}) o.name, s.name AS schema_name, \
+             CASE o.type WHEN 'U' THEN 'TABLE' WHEN 'V' THEN 'VIEW' WHEN 'P' THEN 'PROCEDURE' WHEN 'FN' THEN 'FUNCTION' WHEN 'IF' THEN 'FUNCTION' WHEN 'TF' THEN 'FUNCTION' WHEN 'FS' THEN 'FUNCTION' WHEN 'FT' THEN 'FUNCTION' ELSE o.type_desc END AS object_type, \
+             CAST(NULL AS NVARCHAR(128)) AS parent_schema, CAST(NULL AS NVARCHAR(128)) AS parent_name, ep.value AS object_comment, CAST(NULL AS NVARCHAR(128)) AS data_type \
+             FROM sys.objects o \
+             JOIN sys.schemas s ON s.schema_id = o.schema_id \
+             OUTER APPLY (SELECT CAST(ep.value AS NVARCHAR(MAX)) AS value FROM sys.extended_properties ep WHERE ep.major_id = o.object_id AND ep.minor_id = 0 AND ep.name = N'MS_Description') ep \
+             WHERE o.type IN ({}) AND {object_visibility} {schema_filter} {object_like}",
+            type_ids.join(",")
+        ));
+    }
+    if object_kinds.iter().any(|kind| matches!(kind, crate::types::CompletionAssistantObjectKind::Column)) {
+        let column_like = like_clause.replace("name_expr", "c.name");
+        let parent_table_filter = request
+            .parent_name
+            .as_deref()
+            .filter(|table| !table.trim().is_empty())
+            .map(|table| format!(" AND o.name = '{}' ", table.replace('\'', "''")))
+            .unwrap_or_default();
+        let object_visibility = sqlserver_visible_object_predicate();
+        queries.push(format!(
+            "SELECT TOP ({limit}) c.name, s.name AS schema_name, 'COLUMN' AS object_type, s.name AS parent_schema, o.name AS parent_name, CAST(NULL AS NVARCHAR(MAX)) AS object_comment, TYPE_NAME(c.user_type_id) AS data_type \
+             FROM sys.columns c \
+             JOIN sys.objects o ON o.object_id = c.object_id \
+             JOIN sys.schemas s ON s.schema_id = o.schema_id \
+             WHERE o.type IN ('U','V') AND {object_visibility} {schema_filter} {parent_table_filter} {column_like}"
+        ));
+    }
+
+    if queries.is_empty() {
+        format!("SELECT TOP (0) CAST('' AS NVARCHAR(128)) AS name, CAST('' AS NVARCHAR(128)) AS schema_name, CAST('' AS NVARCHAR(60)) AS object_type, CAST(NULL AS NVARCHAR(128)) AS parent_schema, CAST(NULL AS NVARCHAR(128)) AS parent_name, CAST(NULL AS NVARCHAR(MAX)) AS object_comment, CAST(NULL AS NVARCHAR(128)) AS data_type")
+    } else if queries.len() == 1 {
+        format!("SELECT * FROM ({}) AS dbx_completion ORDER BY name", queries.remove(0))
+    } else {
+        format!("SELECT TOP ({limit}) * FROM ({}) AS dbx_completion ORDER BY name", queries.join(" UNION ALL "))
+    }
+}
+
+fn sqlserver_completion_object_search_clause(
+    request: &crate::types::CompletionAssistantRequest,
+    like_pattern: &str,
+) -> String {
+    if like_pattern == "%" {
+        return String::new();
+    }
+    let mut predicates = vec![format!("LOWER(o.name) LIKE LOWER('{like_pattern}') ESCAPE '\\'")];
+    if request.search_in_comments {
+        predicates.push(format!("LOWER(COALESCE(ep.value, '')) LIKE LOWER('{like_pattern}') ESCAPE '\\'"));
+    }
+    if request.search_in_definitions {
+        predicates.push(format!(
+            "LOWER(COALESCE(OBJECT_DEFINITION(o.object_id), '')) LIKE LOWER('{like_pattern}') ESCAPE '\\'"
+        ));
+    }
+    format!(" AND ({}) ", predicates.join(" OR "))
+}
+
+fn completion_like_pattern(mask: &str, mode: Option<&crate::types::CompletionAssistantMatchMode>) -> String {
+    if mask.is_empty() || mask == "%" {
+        return "%".to_string();
+    }
+    let has_wildcard = mask.contains('%');
+    if has_wildcard {
+        return mask.split('%').map(escape_like_literal).collect::<Vec<_>>().join("%");
+    }
+    let escaped = escape_like_literal(mask);
+    match mode.unwrap_or(&crate::types::CompletionAssistantMatchMode::Prefix) {
+        crate::types::CompletionAssistantMatchMode::Prefix => format!("{escaped}%"),
+        crate::types::CompletionAssistantMatchMode::Contains => format!("%{escaped}%"),
+    }
+}
+
+fn sqlserver_list_tables_sql(
+    schema: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+) -> String {
+    let filter_clause = filter
+        .filter(|value| !value.trim().is_empty())
+        .map(|value| {
+            let contains_pattern = format!("%{}%", escape_like_literal(value.trim()));
+            if crate::sql::fuzzy_filter_enabled(value) {
+                let fuzzy_pattern =
+                    crate::sql::fuzzy_like_pattern_with_escape(value.trim(), escape_like_literal);
+                format!(
+                    " AND (LOWER(o.name) LIKE LOWER('{contains_pattern}') ESCAPE '\\' OR LOWER(o.name) LIKE LOWER('{fuzzy_pattern}') ESCAPE '\\') "
+                )
+            } else {
+                format!(" AND LOWER(o.name) LIKE LOWER('{contains_pattern}') ESCAPE '\\' ")
+            }
+        })
+        .unwrap_or_default();
+    let schema_escaped = schema.replace('\'', "''");
+    let base_columns = "o.name, CASE WHEN o.type = 'V' THEN 'VIEW' ELSE 'BASE TABLE' END, ep.value AS TABLE_COMMENT";
+    let base_from = "FROM sys.objects o \
+         JOIN sys.schemas s ON s.schema_id = o.schema_id \
+         OUTER APPLY (SELECT CAST(ep.value AS NVARCHAR(MAX)) AS value FROM sys.extended_properties ep \
+           WHERE ep.major_id = o.object_id AND ep.minor_id = 0 AND ep.name = N'MS_Description') ep";
+    let object_visibility = sqlserver_visible_object_predicate();
+    let base_where =
+        format!("WHERE s.name = '{schema_escaped}' AND o.type IN ('U','V') AND {object_visibility} {filter_clause}");
+    let order_by = "ORDER BY o.name";
+
+    // Use SELECT TOP for broad SQL Server version compatibility.
+    // OFFSET / FETCH NEXT is only available in SQL Server 2012+.
+    match (limit, offset) {
+        (Some(limit), Some(offset)) if offset > 0 => {
+            let end = offset + limit.min(1000);
+            format!(
+                "SELECT * FROM (\
+                 SELECT {base_columns}, ROW_NUMBER() OVER ({order_by}) AS __dbx_rn \
+                 {base_from} {base_where}\
+                 ) AS __dbx_page WHERE __dbx_rn > {offset} AND __dbx_rn <= {end} ORDER BY __dbx_rn"
+            )
+        }
+        (Some(limit), _) => {
+            format!("SELECT TOP ({}) {base_columns} {base_from} {base_where} {order_by}", limit.min(1000))
+        }
+        _ => {
+            format!("SELECT {base_columns} {base_from} {base_where} {order_by}")
+        }
+    }
+}
+
+fn escape_like_literal(value: &str) -> String {
+    value.replace('\\', "\\\\").replace('\'', "''").replace('%', "\\%").replace('_', "\\_").replace('[', "\\[")
+}
+
+fn sqlserver_visible_object_predicate() -> &'static str {
+    "(o.is_ms_shipped = 0 OR s.name = 'cdc')"
+}
+
+fn sqlserver_hidden_schema_names() -> &'static [&'static str] {
+    &[
+        "guest",
+        "INFORMATION_SCHEMA",
+        "sys",
+        "db_owner",
+        "db_accessadmin",
+        "db_securityadmin",
+        "db_ddladmin",
+        "db_backupoperator",
+        "db_datareader",
+        "db_datawriter",
+        "db_denydatareader",
+        "db_denydatawriter",
+    ]
+}
+
+pub async fn list_objects(client: &mut SqlServerClient, schema: &str) -> Result<Vec<crate::types::ObjectInfo>, String> {
+    let sql = sqlserver_list_objects_sql(schema);
+    let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .map(|row| crate::types::ObjectInfo {
+            name: row.get::<&str, _>(0).unwrap_or("").to_string(),
+            object_type: row.get::<&str, _>(1).unwrap_or("TABLE").to_string(),
+            schema: Some(schema.to_string()),
+            signature: None,
+            comment: row.get::<&str, _>(4).filter(|s: &&str| !s.is_empty()).map(|s: &str| s.to_string()),
+            created_at: row.get::<chrono::NaiveDateTime, _>(2).map(|value| value.to_string()),
+            updated_at: row.get::<chrono::NaiveDateTime, _>(3).map(|value| value.to_string()),
+            parent_schema: None,
+            parent_name: None,
+        })
+        .collect())
+}
+
+fn sqlserver_list_objects_sql(schema: &str) -> String {
+    let s = schema.replace('\'', "''");
+    let object_visibility = sqlserver_visible_object_predicate();
+    format!(
+        "SELECT o.name, \
+         CASE o.type \
+           WHEN 'U' THEN 'TABLE' \
+           WHEN 'V' THEN 'VIEW' \
+           WHEN 'P' THEN 'PROCEDURE' \
+           WHEN 'FN' THEN 'FUNCTION' \
+           WHEN 'IF' THEN 'FUNCTION' \
+           WHEN 'TF' THEN 'FUNCTION' \
+           WHEN 'FS' THEN 'FUNCTION' \
+           WHEN 'FT' THEN 'FUNCTION' \
+           ELSE o.type_desc \
+         END AS object_type, \
+         o.create_date, \
+         o.modify_date, \
+         ep.value AS object_comment \
+         FROM sys.objects o \
+         JOIN sys.schemas s ON s.schema_id = o.schema_id \
+         OUTER APPLY (SELECT CAST(ep.value AS NVARCHAR(MAX)) AS value FROM sys.extended_properties ep WHERE ep.major_id = o.object_id AND ep.minor_id = 0 AND ep.name = N'MS_Description') ep \
+         WHERE s.name = '{s}' \
+           AND o.type IN ('U','V','P','FN','IF','TF','FS','FT') \
+           AND {object_visibility} \
+         ORDER BY CASE o.type \
+           WHEN 'U' THEN 0 \
+           WHEN 'V' THEN 1 \
+           WHEN 'P' THEN 2 \
+           ELSE 3 \
+         END, o.name"
+    )
+}
+
+pub async fn list_object_statistics(
+    client: &mut SqlServerClient,
+    schema: &str,
+) -> Result<Vec<ObjectStatistics>, String> {
+    let s = schema.replace('\'', "''");
+    let object_visibility = sqlserver_visible_object_predicate();
+    let sql = format!(
+        "SELECT o.name, \
+                SUM(CASE WHEN ps.index_id IN (0, 1) THEN ps.row_count ELSE 0 END) AS estimated_rows, \
+                SUM(ps.reserved_page_count) * 8192 AS total_bytes \
+         FROM sys.objects o \
+         JOIN sys.schemas s ON s.schema_id = o.schema_id \
+         JOIN sys.dm_db_partition_stats ps ON ps.object_id = o.object_id \
+         WHERE s.name = '{s}' AND o.type = 'U' AND {object_visibility} \
+         GROUP BY o.object_id, o.name \
+         ORDER BY o.name"
+    );
+    let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .map(|row| ObjectStatistics {
+            name: row.get::<&str, _>(0).unwrap_or("").to_string(),
+            schema: Some(schema.to_string()),
+            estimated_rows: row
+                .try_get::<i64, _>(1)
+                .ok()
+                .flatten()
+                .or_else(|| row.try_get::<i32, _>(1).ok().flatten().map(i64::from)),
+            total_bytes: row
+                .try_get::<i64, _>(2)
+                .ok()
+                .flatten()
+                .or_else(|| row.try_get::<i32, _>(2).ok().flatten().map(i64::from)),
+        })
+        .filter(|stat| !stat.name.is_empty())
+        .collect())
+}
+
+pub async fn get_columns(client: &mut SqlServerClient, schema: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let sql = sqlserver_columns_sql(schema, table);
+    let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let base = row.get::<&str, _>(1).unwrap_or("").to_string();
+            let max_len = row
+                .try_get::<i32, _>(7)
+                .ok()
+                .flatten()
+                .or_else(|| row.try_get::<i16, _>(7).ok().flatten().map(|v| v as i32))
+                .or_else(|| row.try_get::<u8, _>(7).ok().flatten().map(|v| v as i32));
+            let dt_prec = row
+                .try_get::<i32, _>(8)
+                .ok()
+                .flatten()
+                .or_else(|| row.try_get::<i16, _>(8).ok().flatten().map(|v| v as i32))
+                .or_else(|| row.try_get::<u8, _>(8).ok().flatten().map(|v| v as i32));
+            let num_prec = row
+                .try_get::<i32, _>(5)
+                .ok()
+                .flatten()
+                .or_else(|| row.try_get::<i16, _>(5).ok().flatten().map(|v| v as i32))
+                .or_else(|| row.try_get::<u8, _>(5).ok().flatten().map(|v| v as i32));
+            let num_scale = row
+                .try_get::<i32, _>(6)
+                .ok()
+                .flatten()
+                .or_else(|| row.try_get::<i16, _>(6).ok().flatten().map(|v| v as i32))
+                .or_else(|| row.try_get::<u8, _>(6).ok().flatten().map(|v| v as i32));
+            let data_type = match base.to_lowercase().as_str() {
+                "varchar" => match max_len {
+                    Some(-1) => "varchar(max)".to_string(),
+                    Some(n) => format!("varchar({n})"),
+                    None => "varchar".to_string(),
+                },
+                "nvarchar" => match max_len {
+                    Some(-1) => "nvarchar(max)".to_string(),
+                    Some(n) => format!("nvarchar({n})"),
+                    None => "nvarchar".to_string(),
+                },
+                "varbinary" => match max_len {
+                    Some(-1) => "varbinary(max)".to_string(),
+                    Some(n) if n > 0 => format!("varbinary({n})"),
+                    _ => "varbinary".to_string(),
+                },
+                "char" | "nchar" | "binary" => match max_len {
+                    Some(n) if n > 0 => format!("{base}({n})"),
+                    _ => base,
+                },
+                "decimal" | "numeric" => match (num_prec, num_scale) {
+                    (Some(p), Some(s)) => format!("{base}({p},{s})"),
+                    _ => base,
+                },
+                "datetime2" | "datetimeoffset" | "time" => match dt_prec {
+                    Some(p) => format!("{base}({p})"),
+                    _ => base,
+                },
+                _ => base,
+            };
+            ColumnInfo {
+                name: row.get::<&str, _>(0).unwrap_or("").to_string(),
+                data_type,
+                is_nullable: row.get::<&str, _>(2).unwrap_or("NO") == "YES",
+                column_default: row.get::<&str, _>(3).map(|s| s.to_string()),
+                is_primary_key: row.get::<i32, _>(4).unwrap_or(0) == 1,
+                extra: row.get::<&str, _>(9).filter(|s: &&str| !s.is_empty()).map(|s: &str| s.to_string()),
+                comment: row.get::<&str, _>(10).filter(|s: &&str| !s.is_empty()).map(|s: &str| s.to_string()),
+                numeric_precision: num_prec,
+                numeric_scale: num_scale,
+                character_maximum_length: max_len,
+                enum_values: None,
+                ..Default::default()
+            }
+        })
+        .collect())
+}
+
+fn sqlserver_columns_sql(schema: &str, table: &str) -> String {
+    let s = schema.replace('\'', "''");
+    let t = table.replace('\'', "''");
+    format!(
+        "SELECT c.name AS COLUMN_NAME, \
+         ty.name AS DATA_TYPE, \
+         CASE WHEN c.is_nullable = 1 THEN 'YES' ELSE 'NO' END AS IS_NULLABLE, \
+         dc.definition AS COLUMN_DEFAULT, \
+         CASE WHEN pk.column_id IS NOT NULL THEN 1 ELSE 0 END AS IS_PK, \
+         CONVERT(INT, c.precision) AS NUMERIC_PRECISION, \
+         CONVERT(INT, c.scale) AS NUMERIC_SCALE, \
+         CASE \
+           WHEN ty.name IN ('nchar','nvarchar') AND c.max_length > 0 THEN CONVERT(INT, c.max_length / 2) \
+           WHEN c.max_length = -1 THEN -1 \
+           ELSE CONVERT(INT, c.max_length) \
+         END AS CHARACTER_MAXIMUM_LENGTH, \
+         CONVERT(INT, c.scale) AS DATETIME_PRECISION, \
+         CASE \
+           WHEN c.is_computed = 1 THEN 'computed' \
+           WHEN ic.column_id IS NOT NULL THEN 'identity(' + CONVERT(VARCHAR(38), ic.seed_value) + ',' + CONVERT(VARCHAR(38), ic.increment_value) + ')' \
+           ELSE NULL \
+         END AS COLUMN_EXTRA, \
+         ep.value AS COLUMN_COMMENT \
+         FROM sys.objects o \
+         JOIN sys.schemas s ON s.schema_id = o.schema_id \
+         JOIN sys.columns c ON c.object_id = o.object_id \
+         JOIN sys.types ty ON ty.user_type_id = c.user_type_id \
+         LEFT JOIN sys.default_constraints dc ON dc.object_id = c.default_object_id \
+         LEFT JOIN sys.identity_columns ic ON ic.object_id = c.object_id AND ic.column_id = c.column_id \
+         LEFT JOIN ( \
+           SELECT ic.object_id, ic.column_id \
+           FROM sys.indexes i \
+           JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id \
+           WHERE i.is_primary_key = 1 \
+         ) pk ON pk.object_id = c.object_id AND pk.column_id = c.column_id \
+         OUTER APPLY (SELECT CAST(ep.value AS NVARCHAR(MAX)) AS value FROM sys.extended_properties ep WHERE ep.major_id = c.object_id AND ep.minor_id = c.column_id AND ep.name = N'MS_Description') ep \
+         WHERE s.name = '{s}' AND o.name = '{t}' AND o.type IN ('U','V') \
+         ORDER BY c.column_id"
+    )
+}
+
+pub async fn list_indexes(client: &mut SqlServerClient, schema: &str, table: &str) -> Result<Vec<IndexInfo>, String> {
+    let sql = sqlserver_indexes_sql(schema, table);
+    let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .map(|row| {
+            let cols_str = row.get::<&str, _>(1).unwrap_or("");
+            let inc_str = row.get::<&str, _>(5).unwrap_or("");
+            IndexInfo {
+                name: row.get::<&str, _>(0).unwrap_or("").to_string(),
+                columns: cols_str.split(',').filter(|s| !s.is_empty()).map(|s| s.to_string()).collect(),
+                is_unique: row.get::<bool, _>(2).unwrap_or(false),
+                is_primary: row.get::<bool, _>(3).unwrap_or(false),
+                filter: row.get::<&str, _>(6).map(|s| s.to_string()),
+                index_type: row.get::<&str, _>(4).map(|s| s.to_string()),
+                included_columns: if inc_str.is_empty() {
+                    None
+                } else {
+                    Some(inc_str.split(',').map(|s| s.to_string()).collect())
+                },
+                comment: row.get::<&str, _>(7).filter(|s: &&str| !s.is_empty()).map(|s: &str| s.to_string()),
+            }
+        })
+        .collect())
+}
+
+fn sqlserver_indexes_sql(schema: &str, table: &str) -> String {
+    format!(
+        "SELECT i.name, \
+         STUFF((SELECT ',' + c2.name \
+                FROM sys.index_columns ic2 \
+                JOIN sys.columns c2 ON ic2.object_id = c2.object_id AND ic2.column_id = c2.column_id \
+                WHERE ic2.object_id = i.object_id AND ic2.index_id = i.index_id AND ic2.is_included_column = 0 \
+                ORDER BY ic2.key_ordinal \
+                FOR XML PATH(''), TYPE).value('.', 'nvarchar(max)'), 1, 1, '') AS columns, \
+         i.is_unique, i.is_primary_key, i.type_desc, \
+         STUFF((SELECT ',' + c3.name \
+                FROM sys.index_columns ic3 \
+                JOIN sys.columns c3 ON ic3.object_id = c3.object_id AND ic3.column_id = c3.column_id \
+                WHERE ic3.object_id = i.object_id AND ic3.index_id = i.index_id AND ic3.is_included_column = 1 \
+                ORDER BY ic3.index_column_id \
+                FOR XML PATH(''), TYPE).value('.', 'nvarchar(max)'), 1, 1, '') AS included_cols, \
+         i.filter_definition, \
+         ep.value AS index_comment \
+         FROM sys.indexes i \
+         OUTER APPLY (SELECT CAST(ep.value AS NVARCHAR(MAX)) AS value FROM sys.extended_properties ep WHERE ep.major_id = i.object_id AND ep.minor_id = i.index_id AND ep.name = N'MS_Description' AND ep.class = 7) ep \
+         WHERE i.object_id = OBJECT_ID('{s}.{t}') AND i.name IS NOT NULL \
+         ORDER BY i.name",
+        s = schema.replace('\'', "''"),
+        t = table.replace('\'', "''")
+    )
+}
+
+pub async fn list_foreign_keys(
+    client: &mut SqlServerClient,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<ForeignKeyInfo>, String> {
+    let sql = format!(
+        "SELECT fk.name, c.name, SCHEMA_NAME(rt.schema_id), rt.name, rc.name \
+         FROM sys.foreign_keys fk \
+         JOIN sys.foreign_key_columns fkc ON fk.object_id = fkc.constraint_object_id \
+         JOIN sys.columns c ON fkc.parent_object_id = c.object_id AND fkc.parent_column_id = c.column_id \
+         JOIN sys.tables rt ON fkc.referenced_object_id = rt.object_id \
+         JOIN sys.columns rc ON fkc.referenced_object_id = rc.object_id AND fkc.referenced_column_id = rc.column_id \
+         WHERE fk.parent_object_id = OBJECT_ID('{s}.{t}') \
+         ORDER BY fk.name, fkc.constraint_column_id",
+        s = schema.replace('\'', "''"),
+        t = table.replace('\'', "''")
+    );
+    let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .map(|row| ForeignKeyInfo {
+            name: row.get::<&str, _>(0).unwrap_or("").to_string(),
+            column: row.get::<&str, _>(1).unwrap_or("").to_string(),
+            ref_schema: Some(row.get::<&str, _>(2).unwrap_or("").to_string()),
+            ref_table: row.get::<&str, _>(3).unwrap_or("").to_string(),
+            ref_column: row.get::<&str, _>(4).unwrap_or("").to_string(),
+            on_update: None,
+            on_delete: None,
+        })
+        .collect())
+}
+
+pub async fn get_table_comment(
+    client: &mut SqlServerClient,
+    schema: &str,
+    table: &str,
+) -> Result<Option<String>, String> {
+    let sql = sqlserver_table_comment_sql(schema, table);
+    let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows.first().and_then(|row| row.get::<&str, _>(0)).filter(|s| !s.is_empty()).map(|s| s.to_string()))
+}
+
+fn sqlserver_table_comment_sql(schema: &str, table: &str) -> String {
+    let s = schema.replace('\'', "''");
+    let t = table.replace('\'', "''");
+    format!(
+        "SELECT CAST(ep.value AS NVARCHAR(MAX)) \
+         FROM sys.extended_properties ep \
+         WHERE ep.major_id = OBJECT_ID(QUOTENAME('{s}') + '.' + QUOTENAME('{t}')) \
+           AND ep.minor_id = 0 \
+           AND ep.name = N'MS_Description'"
+    )
+}
+
+pub async fn list_triggers(
+    client: &mut SqlServerClient,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<TriggerInfo>, String> {
+    let sql = format!(
+        "SELECT t.name, te.type_desc, CASE WHEN t.is_instead_of_trigger = 1 THEN 'INSTEAD OF' ELSE 'AFTER' END \
+         FROM sys.triggers t \
+         JOIN sys.trigger_events te ON t.object_id = te.object_id \
+         WHERE t.parent_id = OBJECT_ID('{s}.{t}') \
+         ORDER BY t.name",
+        s = schema.replace('\'', "''"),
+        t = table.replace('\'', "''")
+    );
+    let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
+    let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
+    Ok(rows
+        .iter()
+        .map(|row| TriggerInfo {
+            name: row.get::<&str, _>(0).unwrap_or("").to_string(),
+            event: row.get::<&str, _>(1).unwrap_or("").to_string(),
+            timing: row.get::<&str, _>(2).unwrap_or("AFTER").to_string(),
+            statement: None,
+        })
+        .collect())
+}
+
+pub async fn execute_query(client: &mut SqlServerClient, sql: &str) -> Result<QueryResult, String> {
+    execute_query_with_max_rows(client, sql, None).await
+}
+
+pub async fn execute_query_with_max_rows(
+    client: &mut SqlServerClient,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<QueryResult, String> {
+    let start = Instant::now();
+
+    if starts_with_executable_sql_keyword(sql, &["SELECT", "EXEC", "WITH", "TABLE"]) {
+        let query_sql = match sqlserver_unsafe_type_query(client, sql).await {
+            Ok(Some(sql)) => sql,
+            Ok(None) | Err(_) => sql.to_string(),
+        };
+        let stream = sqlserver_driver_result(client.query(query_sql.as_str(), &[])).await?;
+        let mut result = sqlserver_driver_result(collect_first_result_limited(stream, start, max_rows)).await?;
+        strip_dbx_sqlserver_row_number_column(&mut result, sql);
+        Ok(result)
+    } else if requires_simple_query_batch(sql) || is_transaction_control(sql) {
+        let stream = sqlserver_driver_result(client.simple_query(sql)).await?;
+        let _ = sqlserver_driver_result(collect_result_sets_limited(stream, start, max_rows)).await?;
+        Ok(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: 0,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    } else {
+        let result = sqlserver_driver_result(client.execute(sql, &[])).await?;
+        Ok(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: result.rows_affected().iter().sum::<u64>(),
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    }
+}
+
+pub async fn execute_batch(client: &mut SqlServerClient, sql: &str) -> Result<Vec<QueryResult>, String> {
+    execute_batch_with_max_rows(client, sql, None).await
+}
+
+pub async fn execute_batch_with_max_rows(
+    client: &mut SqlServerClient,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<Vec<QueryResult>, String> {
+    let start = Instant::now();
+    if sqlserver_batch_can_use_execute(sql) {
+        let result = sqlserver_driver_result(client.execute(sql, &[])).await?;
+        return Ok(vec![QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: result.rows_affected().iter().sum::<u64>(),
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        }]);
+    }
+
+    if is_single_sqlserver_select(sql) {
+        if let Ok(Some(query_sql)) = sqlserver_unsafe_type_query(client, sql).await {
+            let stream = sqlserver_driver_result(client.query(query_sql.as_str(), &[])).await?;
+            return sqlserver_driver_result(collect_first_result_limited(stream, start, max_rows)).await.map(
+                |mut result| {
+                    strip_dbx_sqlserver_row_number_column(&mut result, sql);
+                    vec![result]
+                },
+            );
+        }
+    }
+    let stream = sqlserver_driver_result(client.simple_query(sql)).await?;
+    let mut results = sqlserver_driver_result(collect_result_sets_limited(stream, start, max_rows)).await?;
+    for result in &mut results {
+        strip_dbx_sqlserver_row_number_column(result, sql);
+    }
+
+    if results.is_empty() {
+        results.push(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: 0,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        });
+    }
+
+    Ok(results)
+}
+
+fn strip_dbx_sqlserver_row_number_column(result: &mut QueryResult, sql: &str) {
+    if !is_dbx_sqlserver_row_number_page_sql(sql) {
+        return;
+    }
+    if !result.columns.last().is_some_and(|column| column.eq_ignore_ascii_case("__dbx_row_num")) {
+        return;
+    }
+
+    result.columns.pop();
+    if result.column_types.len() > result.columns.len() {
+        result.column_types.pop();
+    }
+    if result.column_sortables.len() > result.columns.len() {
+        result.column_sortables.pop();
+    }
+    for row in &mut result.rows {
+        if row.len() > result.columns.len() {
+            row.pop();
+        }
+    }
+}
+
+fn is_dbx_sqlserver_row_number_page_sql(sql: &str) -> bool {
+    let normalized = sql.to_ascii_uppercase();
+    normalized.contains("ROW_NUMBER() OVER")
+        && normalized.contains("[__DBX_ROW_NUM]")
+        && normalized.contains("DBX_PAGE_SOURCE.*")
+}
+
+fn sqlserver_batch_can_use_execute(sql: &str) -> bool {
+    !requires_simple_query_batch(sql)
+        && !sqlserver_batch_may_return_result_set(sql)
+        && !sqlserver_dml_output_returns_rows(sql)
+}
+
+fn sqlserver_batch_may_return_result_set(sql: &str) -> bool {
+    let tokens = top_level_sqlserver_tokens(sql);
+    tokens.iter().any(|token| matches!(token.text.as_str(), "SELECT" | "EXEC" | "EXECUTE" | "WITH" | "TABLE"))
+}
+
+fn sqlserver_dml_output_returns_rows(sql: &str) -> bool {
+    starts_with_executable_sql_keyword(sql, &["INSERT", "UPDATE", "DELETE", "MERGE"])
+        && first_sql_tokens(sql, 64).iter().any(|token| token.eq_ignore_ascii_case("OUTPUT"))
+}
+
+fn is_transaction_control(sql: &str) -> bool {
+    let tokens = first_sql_tokens(sql, 2);
+    if tokens.is_empty() {
+        return false;
+    }
+    let first = &tokens[0];
+    if first.eq_ignore_ascii_case("COMMIT") || first.eq_ignore_ascii_case("ROLLBACK") {
+        return true;
+    }
+    if first.eq_ignore_ascii_case("BEGIN") {
+        return tokens.get(1).is_some_and(|t| t.eq_ignore_ascii_case("TRANSACTION") || t.eq_ignore_ascii_case("TRAN"));
+    }
+    false
+}
+
+fn requires_simple_query_batch(sql: &str) -> bool {
+    let tokens = first_sql_tokens(sql, 4);
+    if tokens.len() >= 2 && tokens[0].eq_ignore_ascii_case("CREATE") && tokens[1].eq_ignore_ascii_case("SCHEMA") {
+        return true;
+    }
+
+    if tokens.len() >= 4
+        && tokens[0].eq_ignore_ascii_case("CREATE")
+        && tokens[1].eq_ignore_ascii_case("OR")
+        && tokens[2].eq_ignore_ascii_case("ALTER")
+    {
+        return SIMPLE_QUERY_MODULE_KEYWORDS.iter().any(|keyword| tokens[3].eq_ignore_ascii_case(keyword));
+    }
+
+    if tokens.len() >= 2 && (tokens[0].eq_ignore_ascii_case("CREATE") || tokens[0].eq_ignore_ascii_case("ALTER")) {
+        return SIMPLE_QUERY_MODULE_KEYWORDS.iter().any(|keyword| tokens[1].eq_ignore_ascii_case(keyword));
+    }
+
+    false
+}
+
+fn first_sql_tokens(sql: &str, limit: usize) -> Vec<String> {
+    let bytes = sql.as_bytes();
+    let mut tokens = Vec::new();
+    let mut i = 0;
+
+    while i < bytes.len() && tokens.len() < limit {
+        while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+            i += 1;
+        }
+
+        if i + 1 < bytes.len() && bytes[i] == b'-' && bytes[i + 1] == b'-' {
+            i += 2;
+            while i < bytes.len() && bytes[i] != b'\n' {
+                i += 1;
+            }
+            continue;
+        }
+
+        if i + 1 < bytes.len() && bytes[i] == b'/' && bytes[i + 1] == b'*' {
+            i += 2;
+            while i + 1 < bytes.len() && !(bytes[i] == b'*' && bytes[i + 1] == b'/') {
+                i += 1;
+            }
+            i = (i + 2).min(bytes.len());
+            continue;
+        }
+
+        let start = i;
+        while i < bytes.len() && (bytes[i].is_ascii_alphanumeric() || bytes[i] == b'_') {
+            i += 1;
+        }
+
+        if i > start {
+            tokens.push(sql[start..i].to_string());
+        } else {
+            i += 1;
+        }
+    }
+
+    tokens
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        build_sqlserver_unsafe_type_query, is_sqlserver_spatial_column, is_sqlserver_variant_column,
+        requires_simple_query_batch, sqlserver_batch_can_use_execute, sqlserver_cell_to_json, sqlserver_columns_sql,
+        sqlserver_completion_assistant_sql, sqlserver_dml_output_returns_rows, sqlserver_hidden_schema_names,
+        sqlserver_indexes_sql, sqlserver_list_objects_sql, sqlserver_list_schemas_sql, sqlserver_list_tables_sql,
+        sqlserver_table_comment_sql, sqlserver_visible_object_predicate, strip_dbx_sqlserver_row_number_column,
+        SqlServerDescribedColumn, SqlServerResultSet,
+    };
+    use crate::types::{
+        CompletionAssistantMatchMode, CompletionAssistantObjectKind, CompletionAssistantRequest, QueryResult,
+    };
+    use chrono::NaiveDate;
+    use std::time::Instant;
+    use tiberius::{ColumnData, IntoSql};
+
+    #[test]
+    fn sqlserver_endpoint_splits_named_instance_hosts() {
+        assert_eq!(
+            super::sqlserver_endpoint(r"192.168.1.10\SQL2022"),
+            super::SqlServerEndpoint { host: "192.168.1.10", instance_name: Some("SQL2022") }
+        );
+        assert_eq!(
+            super::sqlserver_endpoint(r" db.example.com\SQLEXPRESS "),
+            super::SqlServerEndpoint { host: "db.example.com", instance_name: Some("SQLEXPRESS") }
+        );
+    }
+
+    #[test]
+    fn sqlserver_endpoint_keeps_regular_hosts() {
+        assert_eq!(
+            super::sqlserver_endpoint("db.example.com"),
+            super::SqlServerEndpoint { host: "db.example.com", instance_name: None }
+        );
+        assert_eq!(
+            super::sqlserver_endpoint(r"db.example.com\"),
+            super::SqlServerEndpoint { host: r"db.example.com\", instance_name: None }
+        );
+    }
+
+    #[test]
+    fn sqlserver_connect_uses_named_instance_resolution() {
+        let source = include_str!("sqlserver.rs");
+        let try_connect = source.split("\nasync fn try_connect(").nth(1).unwrap();
+        let try_connect = try_connect.split("fn row_to_json").next().unwrap();
+        assert!(try_connect.contains("connect_named(&config)"));
+    }
+
+    #[test]
+    fn sqlserver_legacy_compatibility_flag_accepts_dbx_and_jdbc_params() {
+        assert!(!super::sqlserver_legacy_compatibility_enabled(None));
+        assert!(!super::sqlserver_legacy_compatibility_enabled(Some("encrypt=true")));
+        assert!(super::sqlserver_legacy_compatibility_enabled(Some("sqlserverEncryption=disabled")));
+        assert!(super::sqlserver_legacy_compatibility_enabled(Some("applicationName=dbx;sqlserverEncryption=off")));
+        assert!(super::sqlserver_legacy_compatibility_enabled(Some("?sqlserverEncryption=false&applicationName=dbx")));
+        assert!(super::sqlserver_legacy_compatibility_enabled(Some("applicationName=dbx;encrypt=false")));
+        assert!(super::sqlserver_legacy_compatibility_enabled(Some("?Encrypt=0&applicationName=dbx")));
+    }
+
+    #[test]
+    fn sqlserver_legacy_encryption_modes_cover_jdbc_and_no_encryption_fallback() {
+        assert_eq!(super::SQLSERVER_LEGACY_ENCRYPTION_LEVEL, tiberius::EncryptionLevel::Off);
+        assert_eq!(super::SQLSERVER_UNSUPPORTED_ENCRYPTION_LEVEL, tiberius::EncryptionLevel::NotSupported);
+    }
+
+    #[test]
+    fn sqlserver_automatic_fallback_preserves_v48_no_encryption_compatibility() {
+        let levels = super::SQLSERVER_LEGACY_ENCRYPTION_FALLBACKS.map(|(_, encryption)| encryption);
+        assert_eq!(levels, [tiberius::EncryptionLevel::Off, tiberius::EncryptionLevel::NotSupported]);
+    }
+
+    #[test]
+    fn sqlserver_tls_handshake_error_detection_matches_legacy_hint_cases() {
+        assert!(super::is_sqlserver_tls_handshake_error(
+            "SQL Server connection failed: An error occured during the attempt of performing I/O: tls handshake eof"
+        ));
+        assert!(super::is_sqlserver_tls_handshake_error("TLS handshake failed: unexpected EOF"));
+        assert!(!super::is_sqlserver_tls_handshake_error("SQL Server connection failed: Login failed for user"));
+    }
+
+    #[test]
+    fn sqlserver_module_definitions_require_simple_query_batch() {
+        assert!(requires_simple_query_batch("CREATE SCHEMA [analytics];"));
+        assert!(requires_simple_query_batch("CREATE FUNCTION dbo.fn_demo() RETURNS INT AS BEGIN RETURN 1; END;"));
+        assert!(requires_simple_query_batch("ALTER PROCEDURE dbo.usp_demo AS SELECT 1;"));
+        assert!(requires_simple_query_batch("CREATE OR ALTER VIEW dbo.vw_demo AS SELECT 1 AS id;"));
+        assert!(requires_simple_query_batch(
+            "-- comment\nALTER TRIGGER dbo.tr_demo ON dbo.t AFTER INSERT AS SELECT 1;"
+        ));
+    }
+
+    #[test]
+    fn sqlserver_regular_ddl_can_use_execute() {
+        assert!(!sqlserver_batch_can_use_execute("CREATE SCHEMA [analytics];"));
+        assert!(!requires_simple_query_batch("ALTER TABLE dbo.t ADD name NVARCHAR(20);"));
+        assert!(!requires_simple_query_batch("CREATE TABLE dbo.t(id INT);"));
+        assert!(!requires_simple_query_batch("UPDATE dbo.t SET id = 1;"));
+    }
+
+    #[test]
+    fn sqlserver_cud_batches_use_execute_for_affected_rows() {
+        assert!(sqlserver_batch_can_use_execute("UPDATE dbo.users SET active = 0 WHERE id = 1;"));
+        assert!(sqlserver_batch_can_use_execute("INSERT INTO dbo.users(id) VALUES (1);"));
+        assert!(sqlserver_batch_can_use_execute("DELETE FROM dbo.users WHERE id = 1;"));
+        assert!(sqlserver_batch_can_use_execute(
+            "MERGE dbo.t AS t USING dbo.s AS s ON t.id = s.id WHEN MATCHED THEN UPDATE SET name = s.name;"
+        ));
+    }
+
+    #[test]
+    fn sqlserver_result_returning_batches_keep_simple_query_path() {
+        assert!(!sqlserver_batch_can_use_execute("SELECT * FROM dbo.users;"));
+        assert!(!sqlserver_batch_can_use_execute("EXEC dbo.list_users;"));
+        assert!(!sqlserver_batch_can_use_execute("DECLARE @id INT = 1; EXEC dbo.list_users @id;"));
+        assert!(!sqlserver_batch_can_use_execute(
+            "DECLARE @id INT = 1; CREATE TABLE #t(id INT); INSERT INTO #t VALUES (@id); SELECT id FROM #t;"
+        ));
+        assert!(!sqlserver_batch_can_use_execute("WITH cte AS (SELECT 1 AS id) SELECT * FROM cte;"));
+        assert!(!sqlserver_batch_can_use_execute("UPDATE dbo.users SET active = 0 OUTPUT inserted.id WHERE id = 1;"));
+        assert!(sqlserver_batch_can_use_execute(
+            "DECLARE @id INT = 1; UPDATE dbo.users SET active = 0 WHERE id = @id;"
+        ));
+        assert!(sqlserver_dml_output_returns_rows("DELETE FROM dbo.users OUTPUT deleted.id WHERE id = 1;"));
+    }
+
+    #[test]
+    fn sqlserver_user_query_paths_do_not_collect_full_results_before_limiting() {
+        let source = include_str!("sqlserver.rs");
+        let execute_query = source.split("pub async fn execute_query").nth(1).unwrap();
+        let execute_query = execute_query.split("pub async fn execute_batch").next().unwrap();
+        assert!(!execute_query.contains("into_first_result"));
+
+        let execute_batch = source.split("pub async fn execute_batch").nth(1).unwrap();
+        let execute_batch = execute_batch.split("#[cfg(test)]").next().unwrap();
+        assert!(!execute_batch.contains("into_results"));
+    }
+
+    #[test]
+    fn sqlserver_index_metadata_sql_avoids_string_agg_for_older_compatibility_levels() {
+        let sql = sqlserver_indexes_sql("dbo", "DF_Rule");
+
+        assert!(!sql.contains("STRING_AGG"));
+        assert!(sql.contains("FOR XML PATH"));
+        assert!(sql.contains("OBJECT_ID('dbo.DF_Rule')"));
+    }
+
+    #[test]
+    fn sqlserver_indexes_sql_includes_index_comment_via_extended_properties() {
+        let sql = sqlserver_indexes_sql("dbo", "orders");
+
+        assert!(sql.contains("sys.extended_properties ep"));
+        assert!(sql.contains("ep.minor_id = i.index_id"));
+        assert!(sql.contains("MS_Description"));
+    }
+
+    #[test]
+    fn sqlserver_columns_sql_reads_column_comment_by_column_id() {
+        let sql = sqlserver_columns_sql("dbo", "orders");
+
+        assert!(sql.contains("FROM sys.objects o"));
+        assert!(sql.contains("JOIN sys.columns c ON c.object_id = o.object_id"));
+        assert!(sql.contains("sys.extended_properties ep"));
+        assert!(sql.contains("ep.major_id = c.object_id"));
+        assert!(sql.contains("ep.minor_id = c.column_id"));
+        assert!(sql.contains("MS_Description"));
+        assert!(sql.contains("c.is_computed = 1 THEN 'computed'"));
+    }
+
+    #[test]
+    fn sqlserver_table_comment_sql_queries_extended_properties() {
+        let sql = sqlserver_table_comment_sql("dbo", "users");
+
+        assert!(sql.contains("sys.extended_properties ep"));
+        assert!(sql.contains("ep.minor_id = 0"));
+        assert!(sql.contains("MS_Description"));
+        assert!(sql.contains("QUOTENAME('dbo')"));
+        assert!(sql.contains("QUOTENAME('users')"));
+    }
+
+    #[test]
+    fn sqlserver_metadata_sql_escapes_literals() {
+        let columns_sql = sqlserver_columns_sql("d'bo", "t'able");
+        let indexes_sql = sqlserver_indexes_sql("d'bo", "t'able");
+
+        assert!(columns_sql.contains("s.name = 'd''bo'"));
+        assert!(columns_sql.contains("o.name = 't''able'"));
+        assert!(columns_sql.contains("sys.identity_columns"));
+        assert!(indexes_sql.contains("OBJECT_ID('d''bo.t''able')"));
+    }
+
+    #[test]
+    fn sqlserver_list_objects_sql_includes_timestamps() {
+        let sql = sqlserver_list_objects_sql("dbo");
+
+        assert!(sql.contains("create_date"));
+        assert!(sql.contains("modify_date"));
+    }
+
+    #[test]
+    fn sqlserver_metadata_allows_cdc_system_shipped_objects() {
+        let predicate = sqlserver_visible_object_predicate();
+
+        assert_eq!(predicate, "(o.is_ms_shipped = 0 OR s.name = 'cdc')");
+        assert!(sqlserver_list_tables_sql("cdc", None, Some(200), None).contains(predicate));
+        assert!(sqlserver_list_objects_sql("cdc").contains(predicate));
+    }
+
+    #[test]
+    fn sqlserver_list_schemas_includes_empty_user_schemas() {
+        let sql = sqlserver_list_schemas_sql();
+
+        assert!(!sql.contains("sys.objects"));
+        assert!(sql.contains("s.name NOT IN"));
+        assert!(sql.contains("'db_owner'"));
+        assert!(sql.contains("'db_datareader'"));
+        assert!(sqlserver_hidden_schema_names().contains(&"sys"));
+    }
+
+    #[test]
+    fn sqlserver_list_tables_filter_is_case_insensitive() {
+        let sql = sqlserver_list_tables_sql("dbo", Some("temp"), Some(200), None);
+
+        assert!(sql.contains("LOWER(o.name) LIKE LOWER('%temp%') ESCAPE '\\'"));
+        assert!(sql.contains("LOWER(o.name) LIKE LOWER('%t%e%m%p%') ESCAPE '\\'"));
+        assert!(sql.contains("SELECT TOP (200)"));
+    }
+
+    #[test]
+    fn sqlserver_list_tables_filter_escapes_like_literals() {
+        let sql = sqlserver_list_tables_sql("dbo", Some("Temp_Table[%]"), Some(200), None);
+
+        assert!(sql.contains("LOWER(o.name) LIKE LOWER('%Temp\\_Table\\[\\%]%') ESCAPE '\\'"));
+        assert!(sql.contains("LOWER(o.name) LIKE LOWER('%T%e%m%p%\\_%T%a%b%l%e%\\[%\\%%]%') ESCAPE '\\'"));
+    }
+
+    #[test]
+    fn sqlserver_list_tables_filter_adds_fuzzy_pattern() {
+        let sql = sqlserver_list_tables_sql("dbo", Some("sysu"), Some(200), None);
+
+        assert!(sql.contains("LOWER(o.name) LIKE LOWER('%sysu%') ESCAPE '\\'"));
+        assert!(sql.contains("LOWER(o.name) LIKE LOWER('%s%y%s%u%') ESCAPE '\\'"));
+        assert!(sql.contains("SELECT TOP (200)"));
+    }
+
+    #[test]
+    fn sqlserver_list_tables_filter_skips_fuzzy_pattern_for_single_character() {
+        let sql = sqlserver_list_tables_sql("dbo", Some("u"), Some(200), None);
+
+        assert!(sql.contains("LOWER(o.name) LIKE LOWER('%u%') ESCAPE '\\'"));
+        assert!(!sql.contains(" OR LOWER(o.name) LIKE"));
+        assert!(sql.contains("SELECT TOP (200)"));
+    }
+
+    #[test]
+    fn sqlserver_completion_assistant_searches_objects_before_limiting() {
+        let request = CompletionAssistantRequest {
+            connection_id: "c1".to_string(),
+            database: "app".to_string(),
+            schema: Some("dbo".to_string()),
+            object_kinds: vec![CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View],
+            mask: "Temp".to_string(),
+            case_sensitive: false,
+            global_search: false,
+            max_results: Some(100),
+            search_in_comments: false,
+            search_in_definitions: false,
+            parent_schema: None,
+            parent_name: None,
+            match_mode: Some(CompletionAssistantMatchMode::Prefix),
+        };
+
+        let sql = sqlserver_completion_assistant_sql(&request, 100);
+
+        assert!(sql.contains("SELECT TOP (100)"));
+        assert!(sql.contains("FROM sys.objects o"));
+        assert!(sql.contains("o.type IN ('U','V')"));
+        assert!(sql.contains("s.name = 'dbo'"));
+        assert!(sql.contains("LOWER(o.name) LIKE LOWER('Temp%') ESCAPE '\\'"));
+        assert!(sql.contains("CAST(NULL AS NVARCHAR(128)) AS parent_schema"));
+        assert!(sql.contains("CAST(NULL AS NVARCHAR(128)) AS parent_name"));
+        assert!(sql.contains("CAST(NULL AS NVARCHAR(128)) AS data_type"));
+    }
+
+    #[test]
+    fn sqlserver_completion_assistant_searches_columns_by_parent_table() {
+        let request = CompletionAssistantRequest {
+            connection_id: "c1".to_string(),
+            database: "app".to_string(),
+            schema: Some("dbo".to_string()),
+            object_kinds: vec![CompletionAssistantObjectKind::Column],
+            mask: "id".to_string(),
+            case_sensitive: false,
+            global_search: false,
+            max_results: Some(50),
+            search_in_comments: false,
+            search_in_definitions: false,
+            parent_schema: Some("dbo".to_string()),
+            parent_name: Some("Users".to_string()),
+            match_mode: Some(CompletionAssistantMatchMode::Contains),
+        };
+
+        let sql = sqlserver_completion_assistant_sql(&request, 50);
+
+        assert!(sql.contains("FROM sys.columns c"));
+        assert!(sql.contains("o.name = 'Users'"));
+        assert!(sql.contains("LOWER(c.name) LIKE LOWER('%id%') ESCAPE '\\'"));
+        assert!(sql.contains("CAST(NULL AS NVARCHAR(MAX)) AS object_comment"));
+    }
+
+    #[test]
+    fn sqlserver_completion_assistant_searches_tempdb_for_temp_table_masks() {
+        let request = CompletionAssistantRequest {
+            connection_id: "c1".to_string(),
+            database: "app".to_string(),
+            schema: Some("dbo".to_string()),
+            object_kinds: vec![CompletionAssistantObjectKind::Table],
+            mask: "#Temp".to_string(),
+            case_sensitive: false,
+            global_search: false,
+            max_results: Some(100),
+            search_in_comments: false,
+            search_in_definitions: false,
+            parent_schema: None,
+            parent_name: None,
+            match_mode: Some(CompletionAssistantMatchMode::Prefix),
+        };
+
+        let sql = sqlserver_completion_assistant_sql(&request, 100);
+
+        assert!(sql.contains("FROM tempdb.sys.all_objects o"));
+        assert!(sql.contains("o.type = 'U'"));
+        assert!(sql.contains("LOWER(o.name) LIKE LOWER('#Temp%') ESCAPE '\\'"));
+        assert!(sql.contains("CAST(NULL AS NVARCHAR(128)) AS parent_schema"));
+        assert!(sql.contains("CAST(NULL AS NVARCHAR(MAX)) AS object_comment"));
+    }
+
+    #[test]
+    fn sqlserver_completion_assistant_generates_scoped_search_masks() {
+        assert_eq!(super::completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Prefix)), "Temp%");
+        assert_eq!(super::completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Contains)), "%Temp%");
+        assert_eq!(
+            super::completion_like_pattern("dbo.Temp%", Some(&CompletionAssistantMatchMode::Prefix)),
+            "dbo.Temp%"
+        );
+        assert_eq!(
+            super::completion_like_pattern("Temp_Table", Some(&CompletionAssistantMatchMode::Prefix)),
+            "Temp\\_Table%"
+        );
+    }
+
+    #[test]
+    fn sqlserver_completion_assistant_can_search_comments_and_definitions() {
+        let request = CompletionAssistantRequest {
+            connection_id: "c1".to_string(),
+            database: "app".to_string(),
+            schema: Some("dbo".to_string()),
+            object_kinds: vec![CompletionAssistantObjectKind::Procedure],
+            mask: "audit".to_string(),
+            case_sensitive: false,
+            global_search: false,
+            max_results: Some(100),
+            search_in_comments: true,
+            search_in_definitions: true,
+            parent_schema: None,
+            parent_name: None,
+            match_mode: Some(CompletionAssistantMatchMode::Contains),
+        };
+
+        let sql = sqlserver_completion_assistant_sql(&request, 100);
+
+        assert!(sql.contains("COALESCE(ep.value, '')"));
+        assert!(sql.contains("OBJECT_DEFINITION(o.object_id)"));
+        assert!(sql.contains("LOWER('%audit%')"));
+    }
+
+    #[test]
+    fn sqlserver_completion_assistant_casts_schema_and_empty_result_placeholders() {
+        let schema_request = CompletionAssistantRequest {
+            connection_id: "c1".to_string(),
+            database: "app".to_string(),
+            schema: None,
+            object_kinds: vec![CompletionAssistantObjectKind::Schema],
+            mask: "d".to_string(),
+            case_sensitive: false,
+            global_search: false,
+            max_results: Some(100),
+            search_in_comments: false,
+            search_in_definitions: false,
+            parent_schema: None,
+            parent_name: None,
+            match_mode: Some(CompletionAssistantMatchMode::Prefix),
+        };
+        let schema_sql = sqlserver_completion_assistant_sql(&schema_request, 100);
+
+        assert!(schema_sql.contains("CAST(NULL AS NVARCHAR(128)) AS parent_schema"));
+        assert!(schema_sql.contains("CAST(NULL AS NVARCHAR(128)) AS parent_name"));
+        assert!(schema_sql.contains("CAST(NULL AS NVARCHAR(MAX)) AS object_comment"));
+        assert!(schema_sql.contains("CAST(NULL AS NVARCHAR(128)) AS data_type"));
+
+        let empty_request = CompletionAssistantRequest {
+            object_kinds: vec![CompletionAssistantObjectKind::Database],
+            ..schema_request
+        };
+        let empty_sql = sqlserver_completion_assistant_sql(&empty_request, 100);
+
+        assert!(empty_sql.contains("CAST('' AS NVARCHAR(128)) AS name"));
+        assert!(empty_sql.contains("CAST(NULL AS NVARCHAR(128)) AS parent_schema"));
+        assert!(empty_sql.contains("CAST(NULL AS NVARCHAR(MAX)) AS object_comment"));
+    }
+
+    #[test]
+    fn sqlserver_tinyint_cells_are_json_numbers() {
+        assert_eq!(sqlserver_cell_to_json(&ColumnData::U8(Some(7))), serde_json::json!(7));
+    }
+
+    #[test]
+    fn sqlserver_datetime2_cells_are_json_strings() {
+        let datetime = NaiveDate::from_ymd_opt(2026, 5, 13).unwrap().and_hms_milli_opt(9, 8, 7, 123).unwrap();
+        let cell: ColumnData<'static> = datetime.into_sql();
+
+        assert_eq!(sqlserver_cell_to_json(&cell), serde_json::json!("2026-05-13 09:08:07.123"));
+    }
+
+    #[test]
+    fn sqlserver_datetime_cells_display_millisecond_precision() {
+        let cell = ColumnData::DateTime(Some(tiberius::time::DateTime::new(46_200, 11_001_869)));
+
+        assert_eq!(sqlserver_cell_to_json(&cell), serde_json::json!("2026-06-29 10:11:12.897"));
+    }
+
+    #[test]
+    fn sqlserver_binary_cells_are_json_hex_strings() {
+        let cell =
+            ColumnData::Binary(Some(std::borrow::Cow::Owned(vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xCF, 0x53])));
+
+        assert_eq!(sqlserver_cell_to_json(&cell), serde_json::json!("0x000000000001cf53"));
+    }
+
+    #[test]
+    fn sqlserver_strips_generated_row_number_pagination_column() {
+        let sql = "SELECT * FROM (SELECT dbx_page_source.*, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS [__dbx_row_num] FROM (SELECT id FROM users) dbx_page_source) dbx_page WHERE [__dbx_row_num] > 100 AND [__dbx_row_num] <= 200 ORDER BY [__dbx_row_num];";
+        let mut result = QueryResult {
+            columns: vec!["id".to_string(), "__dbx_row_num".to_string()],
+            column_types: vec!["int".to_string(), "bigint".to_string()],
+            column_sortables: vec![],
+            rows: vec![vec![serde_json::json!(42), serde_json::json!(101)]],
+            affected_rows: 0,
+            execution_time_ms: 1,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        };
+
+        strip_dbx_sqlserver_row_number_column(&mut result, sql);
+
+        assert_eq!(result.columns, vec!["id"]);
+        assert_eq!(result.column_types, vec!["int"]);
+        assert_eq!(result.rows, vec![vec![serde_json::json!(42)]]);
+    }
+
+    #[test]
+    fn sqlserver_detects_geometry_result_columns() {
+        assert!(is_sqlserver_spatial_column(&SqlServerDescribedColumn {
+            name: Some("polygon".to_string()),
+            system_type_name: Some("geometry".to_string()),
+            user_type_schema: Some("sys".to_string()),
+            user_type_name: Some("geometry".to_string()),
+        }));
+        assert!(is_sqlserver_spatial_column(&SqlServerDescribedColumn {
+            name: Some("shape".to_string()),
+            system_type_name: Some("geography".to_string()),
+            user_type_schema: Some("sys".to_string()),
+            user_type_name: Some("geography".to_string()),
+        }));
+        assert!(!is_sqlserver_spatial_column(&SqlServerDescribedColumn {
+            name: Some("name".to_string()),
+            system_type_name: Some("varchar(30)".to_string()),
+            user_type_schema: None,
+            user_type_name: None,
+        }));
+    }
+
+    #[test]
+    fn sqlserver_wraps_geometry_columns_as_text() {
+        let rewritten = build_sqlserver_unsafe_type_query(
+            "SELECT * FROM dbo.tLandPolygon;",
+            &[
+                SqlServerDescribedColumn {
+                    name: Some("landId".to_string()),
+                    system_type_name: Some("varchar(30)".to_string()),
+                    user_type_schema: None,
+                    user_type_name: None,
+                },
+                SqlServerDescribedColumn {
+                    name: Some("polygon".to_string()),
+                    system_type_name: Some("geometry".to_string()),
+                    user_type_schema: Some("sys".to_string()),
+                    user_type_name: Some("geometry".to_string()),
+                },
+            ],
+        )
+        .unwrap();
+
+        assert_eq!(
+            rewritten,
+            "SELECT [landId] = [dbx_unsafe_source].[dbx_col_1], [polygon] = CASE WHEN [dbx_unsafe_source].[dbx_col_2] IS NULL THEN NULL ELSE [dbx_unsafe_source].[dbx_col_2].STAsText() END FROM (SELECT * FROM dbo.tLandPolygon) AS [dbx_unsafe_source]([dbx_col_1], [dbx_col_2])"
+        );
+    }
+
+    #[test]
+    fn sqlserver_does_not_wrap_non_spatial_columns() {
+        assert_eq!(
+            build_sqlserver_unsafe_type_query(
+                "SELECT landId FROM dbo.tLandPolygon",
+                &[SqlServerDescribedColumn {
+                    name: Some("landId".to_string()),
+                    system_type_name: Some("varchar(30)".to_string()),
+                    user_type_schema: None,
+                    user_type_name: None,
+                }]
+            ),
+            None
+        );
+    }
+
+    #[test]
+    fn sqlserver_preserves_order_by_when_wrapping_geometry_columns() {
+        let rewritten = build_sqlserver_unsafe_type_query(
+            "SELECT landId, polygon FROM dbo.tLandPolygon ORDER BY landId DESC",
+            &[
+                SqlServerDescribedColumn {
+                    name: Some("landId".to_string()),
+                    system_type_name: Some("varchar(30)".to_string()),
+                    user_type_schema: None,
+                    user_type_name: None,
+                },
+                SqlServerDescribedColumn {
+                    name: Some("polygon".to_string()),
+                    system_type_name: Some("geometry".to_string()),
+                    user_type_schema: Some("sys".to_string()),
+                    user_type_name: Some("geometry".to_string()),
+                },
+            ],
+        )
+        .unwrap();
+
+        // ORDER BY is stripped from the inner query so it can be used as a
+        // derived table subquery across all SQL Server versions (2008–2022).
+        assert!(!rewritten.contains("ORDER BY"));
+        assert!(rewritten.contains("FROM dbo.tLandPolygon"));
+        assert!(rewritten.contains(".STAsText()"));
+    }
+
+    #[test]
+    fn sqlserver_keeps_empty_result_sets_when_metadata_exists() {
+        let mut results = Vec::new();
+        super::push_sqlserver_result_set(
+            &mut results,
+            Some(SqlServerResultSet {
+                columns: vec!["id".to_string(), "name".to_string()],
+                column_types: vec![],
+                rows: vec![],
+                truncated: false,
+            }),
+            Instant::now(),
+        );
+
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0].columns, vec!["id".to_string(), "name".to_string()]);
+        assert!(results[0].rows.is_empty());
+    }
+
+    #[test]
+    fn sqlserver_drops_truly_empty_result_sets_without_metadata() {
+        let mut results = Vec::new();
+        super::push_sqlserver_result_set(
+            &mut results,
+            Some(SqlServerResultSet { columns: vec![], column_types: vec![], rows: vec![], truncated: false }),
+            Instant::now(),
+        );
+
+        assert!(results.is_empty());
+    }
+
+    #[test]
+    fn sqlserver_detects_sql_variant_columns() {
+        assert!(is_sqlserver_variant_column(&SqlServerDescribedColumn {
+            name: Some("value".to_string()),
+            system_type_name: Some("sql_variant".to_string()),
+            user_type_schema: None,
+            user_type_name: None,
+        }));
+        assert!(is_sqlserver_variant_column(&SqlServerDescribedColumn {
+            name: Some("value".to_string()),
+            system_type_name: None,
+            user_type_schema: None,
+            user_type_name: Some("sql_variant".to_string()),
+        }));
+        assert!(!is_sqlserver_variant_column(&SqlServerDescribedColumn {
+            name: Some("name".to_string()),
+            system_type_name: Some("nvarchar(128)".to_string()),
+            user_type_schema: None,
+            user_type_name: None,
+        }));
+    }
+
+    #[test]
+    fn sqlserver_wraps_sql_variant_columns_as_nvarchar() {
+        let rewritten = build_sqlserver_unsafe_type_query(
+            "SELECT name, value FROM sys.extended_properties;",
+            &[
+                SqlServerDescribedColumn {
+                    name: Some("name".to_string()),
+                    system_type_name: Some("sysname".to_string()),
+                    user_type_schema: None,
+                    user_type_name: None,
+                },
+                SqlServerDescribedColumn {
+                    name: Some("value".to_string()),
+                    system_type_name: Some("sql_variant".to_string()),
+                    user_type_schema: None,
+                    user_type_name: None,
+                },
+            ],
+        )
+        .unwrap();
+
+        assert!(rewritten.contains("CAST("));
+        assert!(rewritten.contains("AS NVARCHAR(MAX))"));
+        assert!(rewritten.contains("FROM sys.extended_properties"));
+        // The name column should not be cast
+        assert_eq!(rewritten.matches("CAST(").count(), 1);
+    }
+
+    #[test]
+    fn sqlserver_does_not_wrap_non_variant_columns() {
+        assert_eq!(
+            build_sqlserver_unsafe_type_query(
+                "SELECT name FROM sys.extended_properties",
+                &[SqlServerDescribedColumn {
+                    name: Some("name".to_string()),
+                    system_type_name: Some("sysname".to_string()),
+                    user_type_schema: None,
+                    user_type_name: None,
+                }]
+            ),
+            None
+        );
+    }
+
+    #[test]
+    fn sqlserver_wraps_both_spatial_and_variant_columns() {
+        let rewritten = build_sqlserver_unsafe_type_query(
+            "SELECT id, shape, metadata FROM dbo.t;",
+            &[
+                SqlServerDescribedColumn {
+                    name: Some("id".to_string()),
+                    system_type_name: Some("int".to_string()),
+                    user_type_schema: None,
+                    user_type_name: None,
+                },
+                SqlServerDescribedColumn {
+                    name: Some("shape".to_string()),
+                    system_type_name: Some("geometry".to_string()),
+                    user_type_schema: Some("sys".to_string()),
+                    user_type_name: Some("geometry".to_string()),
+                },
+                SqlServerDescribedColumn {
+                    name: Some("metadata".to_string()),
+                    system_type_name: Some("sql_variant".to_string()),
+                    user_type_schema: None,
+                    user_type_name: None,
+                },
+            ],
+        )
+        .unwrap();
+
+        assert!(rewritten.contains(".STAsText()"));
+        assert!(rewritten.contains("CAST("));
+        assert!(rewritten.contains("AS NVARCHAR(MAX))"));
+        assert!(rewritten.contains("FROM dbo.t"));
+    }
+}
diff --git a/crates/dbx-core/src/db/ssh_tunnel.rs b/crates/dbx-core/src/db/ssh_tunnel.rs
new file mode 100644
index 0000000..624a359
--- /dev/null
+++ b/crates/dbx-core/src/db/ssh_tunnel.rs
@@ -0,0 +1,974 @@
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::fs;
+
+use crate::path_utils::expand_tilde;
+use std::sync::Arc;
+
+use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
+use base64::Engine;
+use russh::client::{self, Config, Handle};
+use russh::keys::agent::{client::AgentClient, AgentIdentity};
+use russh::keys::{decode_secret_key, key::PrivateKeyWithHashAlg, PrivateKey};
+use russh::{kex, mac, ChannelMsg, Preferred};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpListener;
+use tokio::sync::Mutex;
+use tokio::task::JoinHandle;
+use tokio::time::{Duration, MissedTickBehavior};
+
+use crate::models::connection::SshTunnelConfig;
+
+use super::file_validator::validate_file_path;
+
+/// Initial delay between SSH reconnect attempts.
+const INITIAL_RECONNECT_DELAY: Duration = Duration::from_secs(5);
+/// Maximum delay for exponential backoff.
+const MAX_RECONNECT_DELAY: Duration = Duration::from_secs(60);
+/// Maximum number of consecutive reconnect attempts before giving up.
+const MAX_RECONNECT_ATTEMPTS: u32 = 10;
+/// How often an idle local listener verifies that the SSH session still answers.
+const IDLE_SESSION_CHECK_INTERVAL: Duration = Duration::from_secs(30);
+/// Maximum time to wait for an explicit SSH ping response.
+const IDLE_SESSION_PING_TIMEOUT: Duration = Duration::from_secs(10);
+
+struct SshClient;
+
+impl client::Handler for SshClient {
+    type Error = russh::Error;
+
+    async fn check_server_key(
+        &mut self,
+        _server_public_key: &russh::keys::ssh_key::PublicKey,
+    ) -> Result<bool, Self::Error> {
+        Ok(true)
+    }
+}
+
+fn ssh_client_config() -> Config {
+    let mut preferred = Preferred::default();
+    let mut kex = preferred.kex.into_owned();
+    for algorithm in [kex::ECDH_SHA2_NISTP256, kex::ECDH_SHA2_NISTP384, kex::ECDH_SHA2_NISTP521, kex::DH_G14_SHA1] {
+        if !kex.contains(&algorithm) {
+            kex.push(algorithm);
+        }
+    }
+    preferred.kex = Cow::Owned(kex);
+
+    let mut mac = preferred.mac.into_owned();
+    // Keep SHA-1 MAC variants as last-resort fallbacks for legacy SSH proxies.
+    for algorithm in [mac::HMAC_SHA1_ETM, mac::HMAC_SHA1] {
+        if !mac.contains(&algorithm) {
+            mac.push(algorithm);
+        }
+    }
+    preferred.mac = Cow::Owned(mac);
+
+    Config { nodelay: true, keepalive_interval: Some(Duration::from_secs(30)), preferred, ..Default::default() }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn connect_and_authenticate(
+    ssh_host: &str,
+    ssh_port: u16,
+    ssh_user: &str,
+    ssh_password: &str,
+    ssh_key_path: &str,
+    ssh_key_passphrase: &str,
+    use_ssh_agent: bool,
+    ssh_agent_sock_path: &str,
+    auth_method: &str,
+    connect_timeout_secs: u64,
+) -> Result<Handle<SshClient>, String> {
+    let config = Arc::new(ssh_client_config());
+    let connect_timeout = Duration::from_secs(connect_timeout_secs);
+
+    let mut session =
+        tokio::time::timeout(connect_timeout, client::connect(config, (ssh_host, ssh_port), SshClient {}))
+            .await
+            .map_err(|_| format!("SSH connection timed out ({connect_timeout_secs}s)"))?
+            .map_err(|e| format!("SSH connection failed: {e}"))?;
+
+    // Probe with "none" authentication first. Some SSH proxies and jump-hosts
+    // accept connections without any credential, and this is also the standard
+    // SSH probe used to discover the auth methods the server supports.
+    let none_res = tokio::time::timeout(connect_timeout, session.authenticate_none(ssh_user))
+        .await
+        .map_err(|_| format!("SSH auth probe timed out ({connect_timeout_secs}s)"))?
+        .map_err(|e| format!("SSH auth probe failed: {e}"))?;
+    if none_res.success() {
+        return Ok(session);
+    }
+
+    // When auth_method is "none" and the probe was rejected, fail early
+    // instead of falling back to other credential methods.
+    if auth_method == "none" {
+        return Err("SSH authentication failed: server rejected the connection without credentials".to_string());
+    }
+
+    // "none" was rejected — fall back to the configured credential method.
+    // When auth_method is set, only try the matching method.
+    let try_key = auth_method.is_empty() && !ssh_key_path.is_empty() || auth_method == "key";
+    let try_password = auth_method.is_empty() && !ssh_password.is_empty() || auth_method == "password";
+    let try_agent = auth_method.is_empty() && use_ssh_agent || auth_method == "agent";
+
+    if try_key {
+        // Validate SSH key file path
+        validate_file_path(ssh_key_path, |_| false)?;
+
+        let passphrase = if ssh_key_passphrase.is_empty() { None } else { Some(ssh_key_passphrase) };
+        let key_pair =
+            load_ssh_private_key(ssh_key_path, passphrase).map_err(|e| format!("Failed to load SSH key: {e}"))?;
+        let auth_res = tokio::time::timeout(
+            connect_timeout,
+            session.authenticate_publickey(
+                ssh_user,
+                PrivateKeyWithHashAlg::new(
+                    Arc::new(key_pair),
+                    session.best_supported_rsa_hash().await.ok().flatten().flatten(),
+                ),
+            ),
+        )
+        .await
+        .map_err(|_| format!("SSH key auth timed out ({connect_timeout_secs}s)"))?
+        .map_err(|e| format!("SSH key auth failed: {e}"))?;
+        if !auth_res.success() {
+            return Err("SSH public key authentication failed".to_string());
+        }
+    } else if try_password {
+        let auth_res = tokio::time::timeout(connect_timeout, session.authenticate_password(ssh_user, ssh_password))
+            .await
+            .map_err(|_| format!("SSH password auth timed out ({connect_timeout_secs}s)"))?
+            .map_err(|e| format!("SSH password auth failed: {e}"))?;
+        if !auth_res.success() {
+            return Err("SSH password authentication failed".to_string());
+        }
+    } else if try_agent {
+        match try_authenticate_with_agent(&mut session, ssh_user, ssh_agent_sock_path, &connect_timeout).await {
+            Ok(()) => {}
+            Err(agent_err) => return Err(agent_err),
+        }
+    } else {
+        return Err(
+            "SSH authentication failed: \"none\" was rejected and no password, key, or ssh-agent is configured"
+                .to_string(),
+        );
+    }
+
+    Ok(session)
+}
+
+/// Try to authenticate using ssh-agent identities. Returns `Ok(())` on success,
+/// or an error describing why agent auth failed (unavailable, no identities, all rejected).
+async fn try_authenticate_with_agent(
+    session: &mut Handle<SshClient>,
+    ssh_user: &str,
+    ssh_agent_sock_path: &str,
+    connect_timeout: &Duration,
+) -> Result<(), String> {
+    #[cfg(unix)]
+    let mut agent = if ssh_agent_sock_path.is_empty() {
+        match AgentClient::connect_env().await {
+            Ok(a) => a,
+            Err(e) => {
+                return Err(format!("No SSH password or key provided, and ssh-agent is unavailable: {e}"));
+            }
+        }
+    } else {
+        match AgentClient::connect_uds(ssh_agent_sock_path).await {
+            Ok(a) => a,
+            Err(e) => {
+                return Err(format!(
+                    "No SSH password or key provided, and ssh-agent at '{}' is unavailable: {e}",
+                    ssh_agent_sock_path
+                ));
+            }
+        }
+    };
+
+    #[cfg(windows)]
+    let mut agent = {
+        let stream = pageant::PageantStream::new()
+            .await
+            .map_err(|e| format!("No SSH password or key provided, and ssh-agent (Pageant) is unavailable: {e}"))?;
+        AgentClient::connect(stream)
+    };
+
+    let identities = match agent.request_identities().await {
+        Ok(ids) if ids.is_empty() => {
+            return Err("No SSH password or key provided, and ssh-agent has no identities".to_string());
+        }
+        Ok(ids) => ids,
+        Err(e) => {
+            return Err(format!("No SSH password or key provided, and ssh-agent request failed: {e}"));
+        }
+    };
+
+    let hash_alg = session.best_supported_rsa_hash().await.ok().flatten().flatten();
+
+    let auth_result = tokio::time::timeout(*connect_timeout, async {
+        for identity in identities {
+            let result = match &identity {
+                AgentIdentity::PublicKey { key, .. } => {
+                    session.authenticate_publickey_with(ssh_user, key.clone(), hash_alg, &mut agent).await
+                }
+                AgentIdentity::Certificate { certificate, .. } => {
+                    session.authenticate_certificate_with(ssh_user, certificate.clone(), hash_alg, &mut agent).await
+                }
+            };
+
+            match result {
+                Ok(auth_res) if auth_res.success() => return Ok(()),
+                Ok(_) => continue,
+                Err(e) => {
+                    log::debug!("SSH agent identity ({}) auth failed: {e}", identity.comment());
+                    continue;
+                }
+            }
+        }
+        Err("No SSH password or key provided, and no ssh-agent identity was accepted".to_string())
+    })
+    .await;
+
+    match auth_result {
+        Ok(Ok(())) => Ok(()),
+        Ok(Err(e)) => Err(e),
+        Err(_) => Err("No SSH password or key provided, and ssh-agent auth timed out".to_string()),
+    }
+}
+
+fn load_ssh_private_key(path: &str, passphrase: Option<&str>) -> Result<PrivateKey, String> {
+    let expanded = expand_tilde(path);
+    let secret = fs::read_to_string(&expanded).map_err(|e| e.to_string())?;
+    match decode_secret_key(&secret, passphrase) {
+        Ok(key) => Ok(key),
+        Err(err) if is_ssh_key_character_encoding_error(&err.to_string()) => {
+            let sanitized = sanitize_unencrypted_openssh_comment(&secret)?;
+            decode_secret_key(&sanitized, passphrase).map_err(|retry_err| retry_err.to_string())
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+fn is_ssh_key_character_encoding_error(error: &str) -> bool {
+    error.contains("SshKey: character encoding invalid")
+}
+
+fn sanitize_unencrypted_openssh_comment(secret: &str) -> Result<String, String> {
+    const BEGIN: &str = "-----BEGIN OPENSSH PRIVATE KEY-----";
+    const END: &str = "-----END OPENSSH PRIVATE KEY-----";
+
+    if !secret.lines().any(|line| line == BEGIN) {
+        return Err("SSH key comment encoding is invalid and the key is not an OpenSSH private key".to_string());
+    }
+
+    let body = secret.lines().filter(|line| !line.starts_with("-----")).collect::<String>();
+    let mut bytes =
+        BASE64_STANDARD.decode(body.as_bytes()).map_err(|e| format!("OpenSSH key base64 decode failed: {e}"))?;
+
+    sanitize_unencrypted_openssh_comment_bytes(&mut bytes)?;
+
+    Ok(format!("{BEGIN}\n{}\n{END}\n", BASE64_STANDARD.encode(bytes)))
+}
+
+fn sanitize_unencrypted_openssh_comment_bytes(bytes: &mut Vec<u8>) -> Result<(), String> {
+    const AUTH_MAGIC: &[u8] = b"openssh-key-v1\0";
+
+    if !bytes.starts_with(AUTH_MAGIC) {
+        return Err("OpenSSH key header is invalid".to_string());
+    }
+
+    let mut pos = AUTH_MAGIC.len();
+    let ciphername = read_ssh_string(bytes, &mut pos)?;
+    if ciphername != b"none" {
+        return Err("SSH key comment encoding is invalid and encrypted OpenSSH keys cannot be sanitized".to_string());
+    }
+
+    let _kdfname = read_ssh_string(bytes, &mut pos)?;
+    let _kdfoptions = read_ssh_string(bytes, &mut pos)?;
+    let key_count = read_u32(bytes, &mut pos)?;
+    if key_count != 1 {
+        return Err("OpenSSH keys with multiple private keys are unsupported".to_string());
+    }
+
+    let _public_key = read_ssh_string(bytes, &mut pos)?;
+    let private_blob_len_pos = pos;
+    let private_blob = read_ssh_string(bytes, &mut pos)?;
+    let patched_private_blob = sanitize_private_blob_comment(private_blob)?;
+    let patched_private_blob_len = (patched_private_blob.len() as u32).to_be_bytes();
+
+    bytes.splice(private_blob_len_pos..pos, patched_private_blob_len.into_iter().chain(patched_private_blob));
+
+    Ok(())
+}
+
+fn sanitize_private_blob_comment(blob: &[u8]) -> Result<Vec<u8>, String> {
+    let unpadded_end = blob
+        .len()
+        .checked_sub(openssh_padding_len(blob)?)
+        .ok_or_else(|| "OpenSSH private key padding is invalid".to_string())?;
+    let comment_len_pos = find_trailing_ssh_string_len_pos(&blob[..unpadded_end])
+        .ok_or_else(|| "OpenSSH private key comment field was not found".to_string())?;
+
+    let mut patched = Vec::with_capacity(blob.len());
+    patched.extend_from_slice(&blob[..comment_len_pos]);
+    patched.extend_from_slice(&0u32.to_be_bytes());
+
+    let padding_len = padding_len_for_block(patched.len(), 8);
+    for value in 1..=padding_len {
+        patched.push(value as u8);
+    }
+
+    Ok(patched)
+}
+
+fn openssh_padding_len(bytes: &[u8]) -> Result<usize, String> {
+    for len in (1..=16).rev() {
+        if bytes.len() >= len
+            && bytes[bytes.len() - len..].iter().enumerate().all(|(index, byte)| *byte == (index + 1) as u8)
+        {
+            return Ok(len);
+        }
+    }
+
+    Err("OpenSSH private key padding is invalid".to_string())
+}
+
+fn find_trailing_ssh_string_len_pos(bytes: &[u8]) -> Option<usize> {
+    (8..bytes.len().saturating_sub(3)).rev().find(|pos| {
+        let Some(len_bytes) = bytes.get(*pos..*pos + 4) else {
+            return false;
+        };
+        let len = u32::from_be_bytes(len_bytes.try_into().expect("slice length checked")) as usize;
+        pos.checked_add(4).and_then(|value| value.checked_add(len)) == Some(bytes.len())
+    })
+}
+
+fn padding_len_for_block(len: usize, block_size: usize) -> usize {
+    let remainder = len % block_size;
+    if remainder == 0 {
+        block_size
+    } else {
+        block_size - remainder
+    }
+}
+
+fn read_ssh_string<'a>(bytes: &'a [u8], pos: &mut usize) -> Result<&'a [u8], String> {
+    let len = read_u32(bytes, pos)? as usize;
+    let end = pos.checked_add(len).ok_or_else(|| "OpenSSH key field length is invalid".to_string())?;
+    if end > bytes.len() {
+        return Err("OpenSSH key field is truncated".to_string());
+    }
+
+    let value = &bytes[*pos..end];
+    *pos = end;
+    Ok(value)
+}
+
+fn read_u32(bytes: &[u8], pos: &mut usize) -> Result<u32, String> {
+    let end = pos.checked_add(4).ok_or_else(|| "OpenSSH key field length is invalid".to_string())?;
+    let value = bytes.get(*pos..end).ok_or_else(|| "OpenSSH key field is truncated".to_string())?;
+    *pos = end;
+
+    Ok(u32::from_be_bytes(value.try_into().map_err(|_| "OpenSSH key field length is invalid".to_string())?))
+}
+
+/// Accept connections on the local listener and forward them through the SSH session.
+/// Returns when the SSH session dies (listener error or session.is_closed()).
+async fn forward_loop(session: &Handle<SshClient>, listener: &TcpListener, remote_host: &str, remote_port: u16) {
+    let mut idle_check = tokio::time::interval(IDLE_SESSION_CHECK_INTERVAL);
+    idle_check.set_missed_tick_behavior(MissedTickBehavior::Delay);
+
+    loop {
+        let accepted = tokio::select! {
+            result = listener.accept() => result,
+            _ = idle_check.tick() => {
+                if session.is_closed() {
+                    log::warn!("SSH session closed while tunnel was idle");
+                    break;
+                }
+                match tokio::time::timeout(IDLE_SESSION_PING_TIMEOUT, session.send_ping()).await {
+                    Ok(Ok(())) => continue,
+                    Ok(Err(e)) => {
+                        log::warn!("SSH idle ping failed: {e}");
+                        break;
+                    }
+                    Err(_) => {
+                        log::warn!("SSH idle ping timed out");
+                        break;
+                    }
+                }
+            }
+        };
+
+        let (mut stream, peer_addr) = match accepted {
+            Ok(v) => v,
+            Err(e) => {
+                log::error!("SSH tunnel listener error: {e}");
+                break;
+            }
+        };
+
+        // Check session health before opening a new channel
+        if session.is_closed() {
+            log::warn!("SSH session closed, exiting forward loop");
+            break;
+        }
+
+        let mut channel = match session
+            .channel_open_direct_tcpip(
+                remote_host,
+                remote_port.into(),
+                peer_addr.ip().to_string(),
+                peer_addr.port().into(),
+            )
+            .await
+        {
+            Ok(c) => c,
+            Err(e) => {
+                log::error!("SSH direct-tcpip failed: {e}");
+                break;
+            }
+        };
+
+        tokio::spawn(async move {
+            let mut buf = vec![0u8; 65536];
+            let mut stream_closed = false;
+
+            loop {
+                tokio::select! {
+                    r = stream.read(&mut buf), if !stream_closed => {
+                        match r {
+                            Ok(0) => {
+                                stream_closed = true;
+                                let _ = channel.eof().await;
+                            }
+                            Ok(n) => {
+                                if channel.data(&buf[..n]).await.is_err() {
+                                    break;
+                                }
+                            }
+                            Err(_) => break,
+                        }
+                    }
+                    msg = channel.wait() => {
+                        match msg {
+                            Some(ChannelMsg::Data { ref data }) => {
+                                if stream.write_all(data).await.is_err() {
+                                    break;
+                                }
+                            }
+                            Some(ChannelMsg::Eof) | None => break,
+                            _ => {}
+                        }
+                    }
+                }
+            }
+        });
+    }
+}
+
+/// Main tunnel task: runs the forward loop and automatically reconnects
+/// the SSH session when it drops. The local TcpListener survives across
+/// reconnections so the tunnel appears continuously available to clients.
+/// Uses exponential backoff for reconnect attempts and gives up after
+/// MAX_RECONNECT_ATTEMPTS to avoid log storms from permanent failures.
+#[allow(clippy::too_many_arguments)]
+async fn tunnel_reconnect_loop(
+    mut session: Handle<SshClient>,
+    connect_host: String,
+    connect_port: u16,
+    ssh_user: String,
+    ssh_password: String,
+    ssh_key_path: String,
+    ssh_key_passphrase: String,
+    use_ssh_agent: bool,
+    ssh_agent_sock_path: String,
+    auth_method: String,
+    connect_timeout_secs: u64,
+    listener: TcpListener,
+    remote_host: String,
+    remote_port: u16,
+) {
+    loop {
+        log::info!("SSH tunnel active: {}:{} -> {}:{}", connect_host, connect_port, remote_host, remote_port);
+
+        forward_loop(&session, &listener, &remote_host, remote_port).await;
+
+        log::warn!("SSH tunnel connection lost ({}:{}), reconnecting...", connect_host, connect_port);
+
+        // Reconnect with exponential backoff
+        let mut delay = INITIAL_RECONNECT_DELAY;
+        let mut attempts: u32 = 0;
+
+        loop {
+            if attempts >= MAX_RECONNECT_ATTEMPTS {
+                log::error!(
+                    "SSH tunnel ({connect_host}:{connect_port}): max reconnect attempts ({MAX_RECONNECT_ATTEMPTS}) exhausted, giving up"
+                );
+                return;
+            }
+
+            tokio::time::sleep(delay).await;
+
+            match connect_and_authenticate(
+                &connect_host,
+                connect_port,
+                &ssh_user,
+                &ssh_password,
+                &ssh_key_path,
+                &ssh_key_passphrase,
+                use_ssh_agent,
+                &ssh_agent_sock_path,
+                &auth_method,
+                connect_timeout_secs,
+            )
+            .await
+            {
+                Ok(new_session) => {
+                    session = new_session;
+                    log::info!(
+                        "SSH tunnel reconnected to {}:{} (attempt {})",
+                        connect_host,
+                        connect_port,
+                        attempts + 1
+                    );
+                    break;
+                }
+                Err(e) => {
+                    attempts += 1;
+                    log::error!(
+                        "SSH reconnect failed ({}:{}, attempt {attempts}/{MAX_RECONNECT_ATTEMPTS}): {e}",
+                        connect_host,
+                        connect_port,
+                    );
+                    // Exponential backoff: double the delay, cap at MAX_RECONNECT_DELAY
+                    delay = std::cmp::min(delay * 2, MAX_RECONNECT_DELAY);
+                }
+            }
+        }
+    }
+}
+
+struct TunnelEntry {
+    handles: Vec<JoinHandle<()>>,
+    local_port: u16,
+}
+
+#[cfg(test)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct PlannedTunnel {
+    connect_host: String,
+    connect_port: u16,
+    remote_host: String,
+    remote_port: u16,
+}
+
+pub struct TunnelManager {
+    tunnels: Mutex<HashMap<String, TunnelEntry>>,
+}
+
+impl Default for TunnelManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl TunnelManager {
+    pub fn new() -> Self {
+        Self { tunnels: Mutex::new(HashMap::new()) }
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub async fn start_tunnel(
+        &self,
+        connection_id: &str,
+        ssh_host: &str,
+        ssh_port: u16,
+        ssh_user: &str,
+        ssh_password: &str,
+        ssh_key_path: &str,
+        ssh_key_passphrase: &str,
+        use_ssh_agent: bool,
+        ssh_agent_sock_path: &str,
+        auth_method: &str,
+        connect_timeout_secs: u64,
+        remote_host: &str,
+        remote_port: u16,
+        expose_to_lan: bool,
+    ) -> Result<u16, String> {
+        // Check cache under lock to avoid race with concurrent callers.
+        // Also evict stale entries whose background task has exited.
+        {
+            let mut tunnels = self.tunnels.lock().await;
+            if let Some(port) = Self::get_active_port(&mut tunnels, connection_id) {
+                return Ok(port);
+            }
+        }
+        // Slow SSH connection — do this outside the lock.
+        let (handle, local_port) = spawn_tunnel(
+            ssh_host,
+            ssh_port,
+            ssh_user,
+            ssh_password,
+            ssh_key_path,
+            ssh_key_passphrase,
+            use_ssh_agent,
+            ssh_agent_sock_path,
+            auth_method,
+            connect_timeout_secs,
+            remote_host,
+            remote_port,
+            expose_to_lan,
+        )
+        .await?;
+
+        // Re-check under lock: another caller may have beaten us.
+        let mut tunnels = self.tunnels.lock().await;
+        if let Some(port) = Self::get_active_port(&mut tunnels, connection_id) {
+            // Another task already created a live tunnel; abort ours.
+            handle.abort();
+            return Ok(port);
+        }
+        tunnels.insert(connection_id.to_string(), TunnelEntry { handles: vec![handle], local_port });
+        Ok(local_port)
+    }
+
+    /// Returns the local port for a cached tunnel entry, or `None` if the entry
+    /// is stale (all background handles have exited).
+    fn get_active_port(tunnels: &mut HashMap<String, TunnelEntry>, connection_id: &str) -> Option<u16> {
+        let entry = tunnels.get(connection_id)?;
+        if entry.handles.iter().all(|h| h.is_finished()) {
+            tunnels.remove(connection_id);
+            return None;
+        }
+        Some(entry.local_port)
+    }
+
+    pub async fn start_chain(
+        &self,
+        connection_id: &str,
+        hops: &[SshTunnelConfig],
+        remote_host: &str,
+        remote_port: u16,
+    ) -> Result<u16, String> {
+        if hops.is_empty() {
+            return Err("No SSH tunnel hops configured".to_string());
+        }
+        // Check cache under lock; evict stale entries.
+        {
+            let mut tunnels = self.tunnels.lock().await;
+            if let Some(port) = Self::get_active_port(&mut tunnels, connection_id) {
+                return Ok(port);
+            }
+        }
+
+        let mut handles = Vec::new();
+        let mut next_connect_endpoint: Option<(String, u16)> = None;
+        let mut final_local_port = 0;
+
+        for (index, hop) in hops.iter().enumerate() {
+            let is_last = index + 1 == hops.len();
+            let (connect_host, connect_port) =
+                next_connect_endpoint.clone().unwrap_or_else(|| (hop.host.clone(), hop.port));
+            let (target_host, target_port) = if is_last {
+                (remote_host.to_string(), remote_port)
+            } else {
+                (hops[index + 1].host.clone(), hops[index + 1].port)
+            };
+
+            let (handle, local_port) = spawn_tunnel(
+                &connect_host,
+                connect_port,
+                &hop.user,
+                &hop.password,
+                &hop.key_path,
+                &hop.key_passphrase,
+                hop.use_ssh_agent,
+                &hop.ssh_agent_sock_path,
+                &hop.auth_method,
+                effective_hop_timeout(hop),
+                &target_host,
+                target_port,
+                is_last && hop.expose_lan,
+            )
+            .await
+            .map_err(|err| format!("SSH hop {} failed: {err}", index + 1))?;
+
+            handles.push(handle);
+            final_local_port = local_port;
+            next_connect_endpoint = Some(("127.0.0.1".to_string(), local_port));
+        }
+
+        // Re-check under lock: another caller may have beaten us.
+        let mut tunnels = self.tunnels.lock().await;
+        if let Some(port) = Self::get_active_port(&mut tunnels, connection_id) {
+            for handle in handles {
+                handle.abort();
+            }
+            return Ok(port);
+        }
+        tunnels.insert(connection_id.to_string(), TunnelEntry { handles, local_port: final_local_port });
+        Ok(final_local_port)
+    }
+
+    pub async fn local_port(&self, connection_id: &str) -> Option<u16> {
+        self.tunnels.lock().await.get(connection_id).map(|entry| entry.local_port)
+    }
+
+    pub async fn stop_tunnel(&self, connection_id: &str) {
+        if let Some(entry) = self.tunnels.lock().await.remove(connection_id) {
+            for handle in entry.handles {
+                handle.abort();
+            }
+        }
+    }
+
+    pub async fn stop_tunnels_with_prefix(&self, connection_id_prefix: &str) {
+        let mut tunnels = self.tunnels.lock().await;
+        let keys: Vec<String> = tunnels.keys().filter(|key| key.starts_with(connection_id_prefix)).cloned().collect();
+        for key in keys {
+            if let Some(entry) = tunnels.remove(&key) {
+                for handle in entry.handles {
+                    handle.abort();
+                }
+            }
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn spawn_tunnel(
+    connect_host: &str,
+    connect_port: u16,
+    ssh_user: &str,
+    ssh_password: &str,
+    ssh_key_path: &str,
+    ssh_key_passphrase: &str,
+    use_ssh_agent: bool,
+    ssh_agent_sock_path: &str,
+    auth_method: &str,
+    connect_timeout_secs: u64,
+    remote_host: &str,
+    remote_port: u16,
+    expose_to_lan: bool,
+) -> Result<(JoinHandle<()>, u16), String> {
+    let local_port = portpicker::pick_unused_port().ok_or("No available port")?;
+
+    let bind_addr = if expose_to_lan { "0.0.0.0" } else { "127.0.0.1" };
+    let listener =
+        TcpListener::bind((bind_addr, local_port)).await.map_err(|e| format!("Failed to bind local port: {e}"))?;
+
+    // Initial connection: fail fast on bad credentials
+    let session = connect_and_authenticate(
+        connect_host,
+        connect_port,
+        ssh_user,
+        ssh_password,
+        ssh_key_path,
+        ssh_key_passphrase,
+        use_ssh_agent,
+        ssh_agent_sock_path,
+        auth_method,
+        connect_timeout_secs,
+    )
+    .await?;
+
+    let handle = tokio::spawn(tunnel_reconnect_loop(
+        session,
+        connect_host.to_string(),
+        connect_port,
+        ssh_user.to_string(),
+        ssh_password.to_string(),
+        ssh_key_path.to_string(),
+        ssh_key_passphrase.to_string(),
+        use_ssh_agent,
+        ssh_agent_sock_path.to_string(),
+        auth_method.to_string(),
+        connect_timeout_secs,
+        listener,
+        remote_host.to_string(),
+        remote_port,
+    ));
+
+    Ok((handle, local_port))
+}
+
+fn effective_hop_timeout(hop: &SshTunnelConfig) -> u64 {
+    if hop.connect_timeout_secs == 0 {
+        crate::models::connection::default_ssh_connect_timeout_secs()
+    } else {
+        hop.connect_timeout_secs
+    }
+}
+
+#[cfg(test)]
+fn plan_chain(
+    hops: &[SshTunnelConfig],
+    remote_host: &str,
+    remote_port: u16,
+    local_ports: &[u16],
+) -> Vec<PlannedTunnel> {
+    let mut planned = Vec::new();
+    let mut next_connect_endpoint: Option<(String, u16)> = None;
+    for (index, hop) in hops.iter().enumerate() {
+        let is_last = index + 1 == hops.len();
+        let (connect_host, connect_port) =
+            next_connect_endpoint.clone().unwrap_or_else(|| (hop.host.clone(), hop.port));
+        let (target_host, target_port) = if is_last {
+            (remote_host.to_string(), remote_port)
+        } else {
+            (hops[index + 1].host.clone(), hops[index + 1].port)
+        };
+        planned.push(PlannedTunnel { connect_host, connect_port, remote_host: target_host, remote_port: target_port });
+        if let Some(local_port) = local_ports.get(index) {
+            next_connect_endpoint = Some(("127.0.0.1".to_string(), *local_port));
+        }
+    }
+    planned
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        effective_hop_timeout, openssh_padding_len, plan_chain, read_ssh_string,
+        sanitize_unencrypted_openssh_comment_bytes, ssh_client_config, PlannedTunnel, TunnelManager,
+    };
+    use crate::models::connection::{default_ssh_connect_timeout_secs, SshTunnelConfig};
+
+    fn push_u32(bytes: &mut Vec<u8>, value: u32) {
+        bytes.extend_from_slice(&value.to_be_bytes());
+    }
+
+    fn push_ssh_string(bytes: &mut Vec<u8>, value: &[u8]) {
+        push_u32(bytes, value.len() as u32);
+        bytes.extend_from_slice(value);
+    }
+
+    fn padded_private_blob(comment: &[u8]) -> Vec<u8> {
+        let mut blob = Vec::new();
+        push_u32(&mut blob, 7);
+        push_u32(&mut blob, 7);
+        blob.extend_from_slice(b"fake-private-key");
+        push_ssh_string(&mut blob, comment);
+        for value in 1..=(8 - (blob.len() % 8)) {
+            blob.push(value as u8);
+        }
+        blob
+    }
+
+    fn openssh_container(private_blob: &[u8]) -> Vec<u8> {
+        let mut bytes = b"openssh-key-v1\0".to_vec();
+        push_ssh_string(&mut bytes, b"none");
+        push_ssh_string(&mut bytes, b"none");
+        push_ssh_string(&mut bytes, b"");
+        push_u32(&mut bytes, 1);
+        push_ssh_string(&mut bytes, b"fake-public-key");
+        push_ssh_string(&mut bytes, private_blob);
+        bytes
+    }
+
+    fn hop(id: &str, host: &str, port: u16) -> SshTunnelConfig {
+        SshTunnelConfig {
+            profile_id: String::new(),
+            id: id.to_string(),
+            name: String::new(),
+            enabled: true,
+            host: host.to_string(),
+            port,
+            user: "user".to_string(),
+            password: "secret".to_string(),
+            key_path: String::new(),
+            key_passphrase: String::new(),
+            connect_timeout_secs: 5,
+            expose_lan: false,
+            use_ssh_agent: false,
+            ssh_agent_sock_path: String::new(),
+            auth_method: "password".to_string(),
+        }
+    }
+
+    #[test]
+    fn chain_plan_routes_each_hop_to_next_endpoint() {
+        let hops = vec![hop("a", "bastion-a", 22), hop("b", "bastion-b", 2200)];
+
+        let planned = plan_chain(&hops, "db.internal", 5432, &[41001, 41002]);
+
+        assert_eq!(
+            planned,
+            vec![
+                PlannedTunnel {
+                    connect_host: "bastion-a".to_string(),
+                    connect_port: 22,
+                    remote_host: "bastion-b".to_string(),
+                    remote_port: 2200,
+                },
+                PlannedTunnel {
+                    connect_host: "127.0.0.1".to_string(),
+                    connect_port: 41001,
+                    remote_host: "db.internal".to_string(),
+                    remote_port: 5432,
+                },
+            ]
+        );
+    }
+
+    #[test]
+    fn zero_hop_timeout_uses_default() {
+        let mut tunnel = hop("a", "bastion-a", 22);
+        tunnel.connect_timeout_secs = 0;
+
+        assert_eq!(effective_hop_timeout(&tunnel), default_ssh_connect_timeout_secs());
+    }
+
+    #[test]
+    fn ssh_client_config_keeps_legacy_kex_after_safe_defaults() {
+        let config = ssh_client_config();
+        let kex = config.preferred.kex;
+        let curve25519_index = kex.iter().position(|algorithm| *algorithm == russh::kex::CURVE25519).unwrap();
+        let ecdh_index = kex.iter().position(|algorithm| *algorithm == russh::kex::ECDH_SHA2_NISTP256).unwrap();
+        let group14_sha1_index = kex.iter().position(|algorithm| *algorithm == russh::kex::DH_G14_SHA1).unwrap();
+
+        assert!(curve25519_index < ecdh_index);
+        assert!(ecdh_index < group14_sha1_index);
+    }
+
+    #[test]
+    fn ssh_client_config_keeps_legacy_mac_after_safe_defaults() {
+        let config = ssh_client_config();
+        let mac = config.preferred.mac;
+        let sha2_etm_index = mac.iter().position(|algorithm| *algorithm == russh::mac::HMAC_SHA256_ETM).unwrap();
+        let sha1_etm_index = mac.iter().position(|algorithm| *algorithm == russh::mac::HMAC_SHA1_ETM).unwrap();
+        let sha1_index = mac.iter().position(|algorithm| *algorithm == russh::mac::HMAC_SHA1).unwrap();
+
+        assert!(sha2_etm_index < sha1_etm_index);
+        assert!(sha1_etm_index < sha1_index);
+    }
+
+    #[test]
+    fn sanitizes_invalid_openssh_private_key_comment() {
+        let mut key = openssh_container(&padded_private_blob(&[0xff, 0xfe, b'a']));
+
+        sanitize_unencrypted_openssh_comment_bytes(&mut key).unwrap();
+
+        let mut pos = b"openssh-key-v1\0".len();
+        assert_eq!(read_ssh_string(&key, &mut pos).unwrap(), b"none");
+        let _kdfname = read_ssh_string(&key, &mut pos).unwrap();
+        let _kdfoptions = read_ssh_string(&key, &mut pos).unwrap();
+        pos += 4;
+        let _public_key = read_ssh_string(&key, &mut pos).unwrap();
+        let private_blob = read_ssh_string(&key, &mut pos).unwrap();
+        let unpadded_end = private_blob.len() - openssh_padding_len(private_blob).unwrap();
+        let comment_len_pos = unpadded_end - 4;
+
+        assert_eq!(&private_blob[comment_len_pos..unpadded_end], &0u32.to_be_bytes());
+    }
+
+    #[tokio::test]
+    async fn local_port_reuses_existing_chain_entry() {
+        let manager = TunnelManager::new();
+
+        assert_eq!(manager.local_port("missing").await, None);
+        manager.stop_tunnel("missing").await;
+    }
+}
diff --git a/crates/dbx-core/src/db/transport_layer_tunnel.rs b/crates/dbx-core/src/db/transport_layer_tunnel.rs
new file mode 100644
index 0000000..9b0ee34
--- /dev/null
+++ b/crates/dbx-core/src/db/transport_layer_tunnel.rs
@@ -0,0 +1,438 @@
+use crate::models::connection::TransportLayerConfig;
+
+use super::http_tunnel::HttpTunnelManager;
+use super::proxy_tunnel::ProxyTunnelManager;
+use super::ssh_tunnel::TunnelManager;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct LayerEndpoint {
+    host: String,
+    port: u16,
+}
+
+impl LayerEndpoint {
+    fn localhost(port: u16) -> Self {
+        Self { host: "127.0.0.1".to_string(), port }
+    }
+}
+
+/// Resolves any `~/.ssh/config` aliases on SSH layers before endpoints are
+/// computed. Both `.endpoint()` read sites below (the current layer's own
+/// connect target, and an earlier layer's forward target when this layer is
+/// the *next* one in the chain) must see the resolved host/port rather than
+/// a literal alias string, so resolution happens once up front instead of
+/// only at the `start_tunnel` call site.
+fn resolve_ssh_layers(
+    layers: &[TransportLayerConfig],
+    resolve: impl Fn(&crate::models::connection::SshTunnelConfig) -> crate::models::connection::SshTunnelConfig,
+) -> Vec<TransportLayerConfig> {
+    layers
+        .iter()
+        .map(|layer| match layer {
+            TransportLayerConfig::Ssh(ssh) => TransportLayerConfig::Ssh(resolve(ssh)),
+            other => other.clone(),
+        })
+        .collect()
+}
+
+/// Starts an ordered transport layer chain and returns the final local port.
+///
+/// Each layer listens on a local port. The next layer connects to that local
+/// port, and the last layer forwards to `remote_host:remote_port`.
+pub async fn start_transport_layers(
+    connection_id: &str,
+    layers: &[TransportLayerConfig],
+    remote_host: &str,
+    remote_port: u16,
+    ssh_tunnels: &TunnelManager,
+    proxy_tunnels: &ProxyTunnelManager,
+    http_tunnels: &HttpTunnelManager,
+) -> Result<u16, String> {
+    if layers.is_empty() {
+        return Err("No transport layers configured".to_string());
+    }
+    validate_transport_layers(layers)?;
+
+    let layers = resolve_ssh_layers(layers, crate::ssh_config::resolve_ssh_tunnel_config);
+    let layers = layers.as_slice();
+
+    let mut next_connect_endpoint: Option<LayerEndpoint> = None;
+    let mut final_local_port = 0;
+
+    for (index, layer) in layers.iter().enumerate() {
+        let layer_id = layer_id(connection_id, index);
+        let is_last = index + 1 == layers.len();
+        let (layer_host, layer_port) = layer.endpoint();
+        let connect_endpoint = next_connect_endpoint
+            .clone()
+            .unwrap_or_else(|| LayerEndpoint { host: layer_host.to_string(), port: layer_port });
+        let target_endpoint = if is_last {
+            LayerEndpoint { host: remote_host.to_string(), port: remote_port }
+        } else {
+            let (next_host, next_port) = layers[index + 1].endpoint();
+            LayerEndpoint { host: next_host.to_string(), port: next_port }
+        };
+
+        let local_port = match layer {
+            TransportLayerConfig::Ssh(resolved) => ssh_tunnels
+                .start_tunnel(
+                    &layer_id,
+                    &connect_endpoint.host,
+                    connect_endpoint.port,
+                    &resolved.user,
+                    &resolved.password,
+                    &resolved.key_path,
+                    &resolved.key_passphrase,
+                    resolved.use_ssh_agent,
+                    &resolved.ssh_agent_sock_path,
+                    &resolved.auth_method,
+                    effective_ssh_connect_timeout_secs(resolved.connect_timeout_secs),
+                    &target_endpoint.host,
+                    target_endpoint.port,
+                    is_last && resolved.expose_lan,
+                )
+                .await
+                .map_err(|err| format!("SSH layer {} failed: {err}", index + 1))?,
+            TransportLayerConfig::Proxy(proxy) => proxy_tunnels
+                .start_tunnel(
+                    &layer_id,
+                    proxy.proxy_type,
+                    &connect_endpoint.host,
+                    connect_endpoint.port,
+                    &proxy.username,
+                    &proxy.password,
+                    &target_endpoint.host,
+                    target_endpoint.port,
+                )
+                .await
+                .map_err(|err| format!("Proxy layer {} failed: {err}", index + 1))?,
+            TransportLayerConfig::HttpTunnel(http) => http_tunnels
+                .start_tunnel(
+                    &layer_id,
+                    &http.url,
+                    &http.token,
+                    http.connect_timeout_secs,
+                    &target_endpoint.host,
+                    target_endpoint.port,
+                )
+                .await
+                .map_err(|err| format!("HTTP tunnel layer {} failed: {err}", index + 1))?,
+        };
+
+        final_local_port = local_port;
+        next_connect_endpoint = Some(LayerEndpoint::localhost(local_port));
+    }
+
+    Ok(final_local_port)
+}
+
+pub async fn stop_transport_layers(
+    connection_id: &str,
+    layer_count: usize,
+    ssh_tunnels: &TunnelManager,
+    proxy_tunnels: &ProxyTunnelManager,
+    http_tunnels: &HttpTunnelManager,
+) {
+    for index in 0..layer_count {
+        let layer_id = layer_id(connection_id, index);
+        ssh_tunnels.stop_tunnel(&layer_id).await;
+        proxy_tunnels.stop_tunnel(&layer_id).await;
+        http_tunnels.stop_tunnel(&layer_id).await;
+    }
+}
+
+fn validate_transport_layers(layers: &[TransportLayerConfig]) -> Result<(), String> {
+    for (index, layer) in layers.iter().enumerate() {
+        if matches!(layer, TransportLayerConfig::HttpTunnel(_)) && index != 0 {
+            return Err("HTTP tunnel must be the first transport layer".to_string());
+        }
+    }
+    Ok(())
+}
+
+fn layer_id(connection_id: &str, index: usize) -> String {
+    format!("{connection_id}:transport:{index}")
+}
+
+fn effective_ssh_connect_timeout_secs(value: u64) -> u64 {
+    if value == 0 {
+        crate::models::connection::default_ssh_connect_timeout_secs()
+    } else {
+        value
+    }
+}
+
+#[cfg(test)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum PlannedLayerType {
+    Ssh,
+    Proxy,
+    HttpTunnel,
+}
+
+#[cfg(test)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct PlannedTransportLayer {
+    layer_type: PlannedLayerType,
+    connect_host: String,
+    connect_port: u16,
+    remote_host: String,
+    remote_port: u16,
+}
+
+#[cfg(test)]
+fn plan_transport_layers(
+    layers: &[TransportLayerConfig],
+    remote_host: &str,
+    remote_port: u16,
+    local_ports: &[u16],
+) -> Vec<PlannedTransportLayer> {
+    plan_transport_layers_with_resolver(layers, remote_host, remote_port, local_ports, |ssh| ssh.clone())
+}
+
+/// Same as `plan_transport_layers`, but takes an explicit SSH-alias resolver
+/// so tests can exercise `~/.ssh/config` resolution without touching the real
+/// filesystem (mirrors `start_transport_layers`'s use of `resolve_ssh_layers`).
+#[cfg(test)]
+fn plan_transport_layers_with_resolver(
+    layers: &[TransportLayerConfig],
+    remote_host: &str,
+    remote_port: u16,
+    local_ports: &[u16],
+    resolve: impl Fn(&crate::models::connection::SshTunnelConfig) -> crate::models::connection::SshTunnelConfig,
+) -> Vec<PlannedTransportLayer> {
+    let layers = resolve_ssh_layers(layers, resolve);
+    let layers = layers.as_slice();
+    let mut planned = Vec::new();
+    let mut next_connect_endpoint: Option<(String, u16)> = None;
+    for (index, layer) in layers.iter().enumerate() {
+        let is_last = index + 1 == layers.len();
+        let (layer_host, layer_port) = layer.endpoint();
+        let (connect_host, connect_port) =
+            next_connect_endpoint.clone().unwrap_or_else(|| (layer_host.to_string(), layer_port));
+        let (target_host, target_port) = if is_last {
+            (remote_host.to_string(), remote_port)
+        } else {
+            let (next_host, next_port) = layers[index + 1].endpoint();
+            (next_host.to_string(), next_port)
+        };
+        let layer_type = match layer {
+            TransportLayerConfig::Ssh(_) => PlannedLayerType::Ssh,
+            TransportLayerConfig::Proxy(_) => PlannedLayerType::Proxy,
+            TransportLayerConfig::HttpTunnel(_) => PlannedLayerType::HttpTunnel,
+        };
+        planned.push(PlannedTransportLayer {
+            layer_type,
+            connect_host,
+            connect_port,
+            remote_host: target_host,
+            remote_port: target_port,
+        });
+        if let Some(local_port) = local_ports.get(index) {
+            next_connect_endpoint = Some(("127.0.0.1".to_string(), *local_port));
+        }
+    }
+    planned
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        plan_transport_layers, plan_transport_layers_with_resolver, validate_transport_layers, PlannedLayerType,
+        PlannedTransportLayer,
+    };
+    use crate::models::connection::{
+        HttpTunnelConfig, ProxyTunnelConfig, ProxyType, SshTunnelConfig, TransportLayerConfig,
+    };
+
+    fn ssh_layer(id: &str, host: &str, port: u16) -> TransportLayerConfig {
+        TransportLayerConfig::Ssh(SshTunnelConfig {
+            profile_id: String::new(),
+            id: id.to_string(),
+            name: String::new(),
+            enabled: true,
+            host: host.to_string(),
+            port,
+            user: "user".to_string(),
+            password: "secret".to_string(),
+            key_path: String::new(),
+            key_passphrase: String::new(),
+            connect_timeout_secs: 5,
+            expose_lan: false,
+            use_ssh_agent: false,
+            ssh_agent_sock_path: String::new(),
+            auth_method: "password".to_string(),
+        })
+    }
+
+    fn proxy_layer(id: &str, host: &str, port: u16) -> TransportLayerConfig {
+        TransportLayerConfig::Proxy(ProxyTunnelConfig {
+            profile_id: String::new(),
+            id: id.to_string(),
+            name: String::new(),
+            enabled: true,
+            proxy_type: ProxyType::Socks5,
+            host: host.to_string(),
+            port,
+            username: String::new(),
+            password: String::new(),
+        })
+    }
+
+    fn http_tunnel_layer(id: &str, url: &str) -> TransportLayerConfig {
+        TransportLayerConfig::HttpTunnel(HttpTunnelConfig {
+            profile_id: String::new(),
+            id: id.to_string(),
+            name: String::new(),
+            enabled: true,
+            url: url.to_string(),
+            token: String::new(),
+            connect_timeout_secs: 10,
+        })
+    }
+
+    #[test]
+    fn mixed_transport_plan_routes_layers_in_configured_order() {
+        let layers = vec![
+            ssh_layer("ssh-a", "bastion-a", 22),
+            proxy_layer("proxy", "proxy.internal", 1080),
+            ssh_layer("ssh-b", "bastion-b", 2200),
+        ];
+
+        let planned = plan_transport_layers(&layers, "db.internal", 5432, &[41001, 41002, 41003]);
+
+        assert_eq!(
+            planned,
+            vec![
+                PlannedTransportLayer {
+                    layer_type: PlannedLayerType::Ssh,
+                    connect_host: "bastion-a".to_string(),
+                    connect_port: 22,
+                    remote_host: "proxy.internal".to_string(),
+                    remote_port: 1080,
+                },
+                PlannedTransportLayer {
+                    layer_type: PlannedLayerType::Proxy,
+                    connect_host: "127.0.0.1".to_string(),
+                    connect_port: 41001,
+                    remote_host: "bastion-b".to_string(),
+                    remote_port: 2200,
+                },
+                PlannedTransportLayer {
+                    layer_type: PlannedLayerType::Ssh,
+                    connect_host: "127.0.0.1".to_string(),
+                    connect_port: 41002,
+                    remote_host: "db.internal".to_string(),
+                    remote_port: 5432,
+                },
+            ]
+        );
+    }
+
+    #[test]
+    fn http_tunnel_must_be_outermost_layer() {
+        let layers = vec![
+            ssh_layer("ssh-a", "bastion-a", 22),
+            http_tunnel_layer("http", "https://dbx.example.com/dbx_tunnel.php"),
+        ];
+
+        let err = validate_transport_layers(&layers).unwrap_err();
+
+        assert!(err.contains("HTTP tunnel must be the first transport layer"));
+    }
+
+    #[test]
+    fn single_ssh_hop_with_config_alias_connects_to_resolved_host_and_port() {
+        // RF-001 regression: a single SSH layer whose `host` is a
+        // `~/.ssh/config` alias must dial the resolved HostName/Port, not
+        // the literal alias string.
+        let layers = vec![ssh_layer("ssh-a", "myserver", 22)];
+
+        let planned = plan_transport_layers_with_resolver(&layers, "db.internal", 5432, &[], |ssh| {
+            assert_eq!(ssh.host, "myserver");
+            let mut resolved = ssh.clone();
+            resolved.host = "10.0.0.5".to_string();
+            resolved.port = 2222;
+            resolved
+        });
+
+        assert_eq!(
+            planned,
+            vec![PlannedTransportLayer {
+                layer_type: PlannedLayerType::Ssh,
+                connect_host: "10.0.0.5".to_string(),
+                connect_port: 2222,
+                remote_host: "db.internal".to_string(),
+                remote_port: 5432,
+            }]
+        );
+    }
+
+    #[test]
+    fn earlier_hop_forwards_to_resolved_alias_of_next_ssh_hop() {
+        // RF-002 regression: when hop N+1 is an SSH layer addressed by a
+        // config alias, hop N's forward target must be the resolved
+        // HostName/Port, not the literal alias (which the remote host at
+        // hop N cannot resolve).
+        let layers = vec![ssh_layer("ssh-a", "bastion-a", 22), ssh_layer("ssh-b", "myserver", 22)];
+
+        let planned = plan_transport_layers_with_resolver(&layers, "db.internal", 5432, &[41001], |ssh| {
+            let mut resolved = ssh.clone();
+            if ssh.host == "myserver" {
+                resolved.host = "10.0.0.5".to_string();
+                resolved.port = 2222;
+            }
+            resolved
+        });
+
+        assert_eq!(
+            planned,
+            vec![
+                PlannedTransportLayer {
+                    layer_type: PlannedLayerType::Ssh,
+                    connect_host: "bastion-a".to_string(),
+                    connect_port: 22,
+                    remote_host: "10.0.0.5".to_string(),
+                    remote_port: 2222,
+                },
+                PlannedTransportLayer {
+                    layer_type: PlannedLayerType::Ssh,
+                    connect_host: "127.0.0.1".to_string(),
+                    connect_port: 41001,
+                    remote_host: "db.internal".to_string(),
+                    remote_port: 5432,
+                },
+            ]
+        );
+    }
+
+    #[test]
+    fn http_tunnel_first_layer_targets_next_layer() {
+        let layers = vec![
+            http_tunnel_layer("http", "https://dbx.example.com/dbx_tunnel.php"),
+            ssh_layer("ssh-a", "bastion-a", 22),
+        ];
+
+        let planned = plan_transport_layers(&layers, "db.internal", 5432, &[41001, 41002]);
+
+        assert_eq!(
+            planned,
+            vec![
+                PlannedTransportLayer {
+                    layer_type: PlannedLayerType::HttpTunnel,
+                    connect_host: "".to_string(),
+                    connect_port: 0,
+                    remote_host: "bastion-a".to_string(),
+                    remote_port: 22,
+                },
+                PlannedTransportLayer {
+                    layer_type: PlannedLayerType::Ssh,
+                    connect_host: "127.0.0.1".to_string(),
+                    connect_port: 41001,
+                    remote_host: "db.internal".to_string(),
+                    remote_port: 5432,
+                },
+            ]
+        );
+    }
+}
diff --git a/crates/dbx-core/src/db/turso_driver.rs b/crates/dbx-core/src/db/turso_driver.rs
new file mode 100644
index 0000000..aff76be
--- /dev/null
+++ b/crates/dbx-core/src/db/turso_driver.rs
@@ -0,0 +1,750 @@
+use reqwest::Client as HttpClient;
+use serde::Deserialize;
+use std::time::{Duration, Instant};
+
+use super::{http_client_builder, with_connection_timeout};
+use crate::sql::starts_with_executable_sql_keyword;
+use crate::types::{
+    ColumnInfo, DatabaseInfo, ForeignKeyInfo, IndexInfo, ObjectSource, ObjectSourceKind, QueryResult, TableInfo,
+    TriggerInfo,
+};
+
+#[derive(Clone)]
+pub struct TursoClient {
+    http: HttpClient,
+    base_url: String,
+    auth_token: String,
+}
+
+impl TursoClient {
+    pub fn new(url: &str, auth_token: &str, tls_enabled: bool, timeout: Duration) -> Result<Self, String> {
+        let mut builder = http_client_builder(timeout);
+        if turso_accept_invalid_certs(tls_enabled) {
+            builder = builder.danger_accept_invalid_certs(true);
+        }
+        let http = builder.build().map_err(|e| format!("Failed to configure Turso HTTP client: {e}"))?;
+        Ok(Self { http, base_url: url.trim_end_matches('/').to_string(), auth_token: auth_token.to_string() })
+    }
+
+    fn post_pipeline(&self, sql: &str) -> reqwest::RequestBuilder {
+        let requests = vec![serde_json::json!({
+            "type": "execute",
+            "stmt": { "sql": sql }
+        })];
+        self.post_pipeline_requests(&requests)
+    }
+
+    fn post_pipeline_batch(&self, statements: &[&str]) -> reqwest::RequestBuilder {
+        let requests: Vec<_> = statements
+            .iter()
+            .map(|sql| {
+                serde_json::json!({
+                    "type": "execute",
+                    "stmt": { "sql": sql }
+                })
+            })
+            .collect();
+        self.post_pipeline_requests(&requests)
+    }
+
+    fn post_pipeline_requests(&self, requests: &[serde_json::Value]) -> reqwest::RequestBuilder {
+        self.http
+            .post(format!("{}/v2/pipeline", self.base_url))
+            .header("Authorization", format!("Bearer {}", self.auth_token))
+            .json(&serde_json::json!({ "requests": requests }))
+    }
+}
+
+/// Turso libSQL HTTP API response types
+
+#[derive(Debug, Deserialize)]
+struct TursoPipelineResponse {
+    #[serde(default)]
+    results: Vec<TursoPipelineResult>,
+    #[serde(default)]
+    #[allow(dead_code)]
+    baton: Option<String>,
+    #[serde(default)]
+    #[allow(dead_code)]
+    base_url: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TursoPipelineResult {
+    #[serde(rename = "type")]
+    result_type: String,
+    /// Present when result_type is "ok"
+    #[serde(default)]
+    response: Option<TursoResponseEnvelope>,
+    /// Present when result_type is "error"
+    #[serde(default)]
+    error: Option<TursoError>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TursoResponseEnvelope {
+    #[serde(rename = "type")]
+    #[allow(dead_code)]
+    response_type: String,
+    #[serde(default)]
+    result: Option<TursoResultSet>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TursoResultSet {
+    #[serde(default)]
+    cols: Vec<TursoColumn>,
+    #[serde(default)]
+    rows: Vec<Vec<TursoValue>>,
+    #[serde(default)]
+    #[allow(dead_code)]
+    rows_read: Option<u64>,
+    #[serde(default)]
+    #[allow(dead_code)]
+    rows_written: Option<u64>,
+    #[serde(default)]
+    affected_row_count: Option<u64>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+struct TursoColumn {
+    name: String,
+    #[serde(default)]
+    #[allow(dead_code)]
+    decltype: Option<String>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+struct TursoValue {
+    #[serde(rename = "type", default)]
+    value_type: String,
+    #[serde(default)]
+    value: Option<serde_json::Value>,
+}
+
+#[derive(Debug, Deserialize)]
+struct TursoError {
+    message: String,
+    #[serde(default)]
+    #[allow(dead_code)]
+    code: Option<String>,
+}
+
+// ─── Public API ───────────────────────────────────────────────────────────────
+
+pub async fn test_connection(client: &TursoClient, timeout: Duration) -> Result<(), String> {
+    with_connection_timeout("turso", timeout, async { execute_inner(client, "SELECT 1").await.map(|_| ()) }).await
+}
+
+pub async fn list_databases(_client: &TursoClient) -> Result<Vec<DatabaseInfo>, String> {
+    Ok(vec![DatabaseInfo { name: "main".to_string() }])
+}
+
+pub async fn list_tables(client: &TursoClient, _schema: &str) -> Result<Vec<TableInfo>, String> {
+    let result = query_inner(
+        client,
+        "SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY name",
+    )
+    .await?;
+    Ok(result
+        .values
+        .into_iter()
+        .map(|row| {
+            let table_type = value_as_string(row.get(1)).unwrap_or_else(|| "table".to_string());
+            TableInfo {
+                name: value_as_string(row.first()).unwrap_or_default(),
+                table_type: if table_type.eq_ignore_ascii_case("view") { "VIEW" } else { "BASE TABLE" }.to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            }
+        })
+        .collect())
+}
+
+pub async fn get_columns(client: &TursoClient, _schema: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
+    let result = query_inner(client, &format!("PRAGMA table_info({})", sqlite_ident(table))).await?;
+    Ok(result
+        .values
+        .into_iter()
+        .map(|row| ColumnInfo {
+            name: value_by_column(&result.columns, &row, "name").unwrap_or_default(),
+            data_type: value_by_column(&result.columns, &row, "type").unwrap_or_default(),
+            is_nullable: value_by_column(&result.columns, &row, "notnull")
+                .and_then(|value| value.parse::<i64>().ok())
+                .unwrap_or(0)
+                == 0,
+            column_default: value_by_column(&result.columns, &row, "dflt_value"),
+            is_primary_key: value_by_column(&result.columns, &row, "pk")
+                .and_then(|value| value.parse::<i64>().ok())
+                .unwrap_or(0)
+                > 0,
+            extra: None,
+            comment: None,
+            numeric_precision: None,
+            numeric_scale: None,
+            character_maximum_length: None,
+            enum_values: None,
+            ..Default::default()
+        })
+        .collect())
+}
+
+pub async fn list_indexes(client: &TursoClient, _schema: &str, table: &str) -> Result<Vec<IndexInfo>, String> {
+    let result = query_inner(client, &format!("PRAGMA index_list({})", sqlite_ident(table))).await?;
+    let mut indexes = Vec::new();
+
+    for row in result.values {
+        let name = value_by_column(&result.columns, &row, "name").unwrap_or_default();
+        if name.is_empty() {
+            continue;
+        }
+        let is_unique =
+            value_by_column(&result.columns, &row, "unique").and_then(|value| value.parse::<i64>().ok()).unwrap_or(0)
+                != 0;
+        let origin = value_by_column(&result.columns, &row, "origin").unwrap_or_default();
+        let column_result = query_inner(client, &format!("PRAGMA index_info({})", sqlite_ident(&name))).await?;
+        let columns = column_result
+            .values
+            .iter()
+            .filter_map(|row| value_by_column(&column_result.columns, row, "name"))
+            .collect();
+        indexes.push(IndexInfo {
+            name,
+            columns,
+            is_unique,
+            is_primary: origin == "pk",
+            filter: None,
+            index_type: None,
+            included_columns: None,
+            comment: None,
+        });
+    }
+
+    Ok(indexes)
+}
+
+pub async fn list_foreign_keys(
+    client: &TursoClient,
+    _schema: &str,
+    table: &str,
+) -> Result<Vec<ForeignKeyInfo>, String> {
+    let result = query_inner(client, &format!("PRAGMA foreign_key_list({})", sqlite_ident(table))).await?;
+    Ok(result
+        .values
+        .into_iter()
+        .map(|row| ForeignKeyInfo {
+            name: format!("fk_{}", value_by_column(&result.columns, &row, "id").unwrap_or_else(|| "0".to_string())),
+            column: value_by_column(&result.columns, &row, "from").unwrap_or_default(),
+            ref_schema: None,
+            ref_table: value_by_column(&result.columns, &row, "table").unwrap_or_default(),
+            ref_column: value_by_column(&result.columns, &row, "to").unwrap_or_default(),
+            on_update: None,
+            on_delete: None,
+        })
+        .collect())
+}
+
+pub async fn list_triggers(client: &TursoClient, _schema: &str, table: &str) -> Result<Vec<TriggerInfo>, String> {
+    let result = query_inner(
+        client,
+        &format!(
+            "SELECT name, sql FROM sqlite_master WHERE type = 'trigger' AND tbl_name = {} ORDER BY name",
+            sqlite_string(table)
+        ),
+    )
+    .await?;
+    Ok(result
+        .values
+        .into_iter()
+        .map(|row| {
+            let sql_text = value_as_string(row.get(1)).unwrap_or_default().to_uppercase();
+            let timing = if sql_text.contains("BEFORE") {
+                "BEFORE"
+            } else if sql_text.contains("AFTER") {
+                "AFTER"
+            } else {
+                "INSTEAD OF"
+            };
+            let event = if sql_text.contains("INSERT") {
+                "INSERT"
+            } else if sql_text.contains("UPDATE") {
+                "UPDATE"
+            } else {
+                "DELETE"
+            };
+            TriggerInfo {
+                name: value_as_string(row.first()).unwrap_or_default(),
+                event: event.to_string(),
+                timing: timing.to_string(),
+                statement: value_as_string(row.get(1)),
+            }
+        })
+        .collect())
+}
+
+pub async fn table_ddl(client: &TursoClient, table: &str) -> Result<String, String> {
+    first_string_cell(
+        query_inner(
+            client,
+            &format!("SELECT sql FROM sqlite_master WHERE type='table' AND name={}", sqlite_string(table)),
+        )
+        .await?,
+    )
+}
+
+pub async fn object_source(
+    client: &TursoClient,
+    name: &str,
+    object_type: &ObjectSourceKind,
+) -> Result<ObjectSource, String> {
+    let kind = match object_type {
+        ObjectSourceKind::View => "view",
+        _ => return Err("Object source is not supported for this Turso object type".to_string()),
+    };
+    let source = first_string_cell(
+        query_inner(
+            client,
+            &format!(
+                "SELECT sql FROM sqlite_master WHERE type={} AND name={}",
+                sqlite_string(kind),
+                sqlite_string(name)
+            ),
+        )
+        .await?,
+    )?;
+    Ok(ObjectSource { name: name.to_string(), object_type: object_type.clone(), schema: None, source, editable: None })
+}
+
+pub async fn execute_query(client: &TursoClient, sql: &str) -> Result<QueryResult, String> {
+    execute_query_with_max_rows(client, sql, None).await
+}
+
+pub async fn execute_query_with_max_rows(
+    client: &TursoClient,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<QueryResult, String> {
+    let start = Instant::now();
+
+    // Split multi-statement SQL: each statement in the pipeline is part of a
+    // single implicit transaction, so BEGIN/INSERT/COMMIT must travel together.
+    let statements: Vec<&str> = split_sql_statements(sql);
+    let is_reader = statements.len() == 1
+        && starts_with_executable_sql_keyword(statements[0], &["SELECT", "PRAGMA", "EXPLAIN", "WITH"]);
+
+    // Single-statement transaction control: Turso pipelines are implicitly
+    // auto-committed, so standalone BEGIN/COMMIT/ROLLBACK are no-ops.
+    let is_tx_control = statements.len() == 1
+        && starts_with_executable_sql_keyword(statements[0], &["BEGIN", "COMMIT", "ROLLBACK", "START", "END"]);
+
+    if is_tx_control {
+        return Ok(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: 0,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        });
+    }
+
+    if is_reader {
+        let result = query_inner(client, statements[0]).await?;
+        Ok(query_result_from_turso_result(result, start.elapsed().as_millis(), max_rows))
+    } else if statements.len() == 1 {
+        let affected_rows = execute_inner(client, statements[0]).await?;
+        Ok(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    } else {
+        // Batch multiple statements into a single pipeline for transactional integrity
+        let result_set = send_pipeline_batch(client, &statements).await?;
+        let affected = result_set.affected_row_count.unwrap_or(0);
+        Ok(QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: affected,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    }
+}
+
+/// Split SQL text on statement boundaries (naive split on `;` that respects
+/// basic quoting; sufficient for the multi-statement batching use case).
+fn split_sql_statements(sql: &str) -> Vec<&str> {
+    let trimmed = sql.trim();
+    if trimmed.is_empty() {
+        return vec![];
+    }
+    let mut stmts: Vec<&str> = Vec::new();
+    let mut start = 0;
+    let bytes = trimmed.as_bytes();
+    let mut in_single = false;
+    let mut in_double = false;
+    for (i, &b) in bytes.iter().enumerate() {
+        match b {
+            b'\'' if !in_double => in_single = !in_single,
+            b'"' if !in_single => in_double = !in_double,
+            b';' if !in_single && !in_double => {
+                let stmt = trimmed[start..i].trim();
+                if !stmt.is_empty() {
+                    stmts.push(stmt);
+                }
+                start = i + 1;
+            }
+            _ => {}
+        }
+    }
+    let last = trimmed[start..].trim();
+    if !last.is_empty() && last != ";" {
+        stmts.push(last);
+    }
+    stmts
+}
+
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+
+async fn query_inner(client: &TursoClient, sql: &str) -> Result<TursoExtractedResult, String> {
+    let result_set = send_pipeline_for_result_set(client, sql).await?;
+    Ok(extract_result(result_set))
+}
+
+async fn execute_inner(client: &TursoClient, sql: &str) -> Result<u64, String> {
+    let result_set = send_pipeline_for_result_set(client, sql).await?;
+    Ok(result_set.affected_row_count.unwrap_or(0))
+}
+
+async fn send_pipeline_for_result_set(client: &TursoClient, sql: &str) -> Result<TursoResultSet, String> {
+    let result = send_pipeline(client, sql).await?;
+    match result {
+        TursoPipelineResult { result_type, response: Some(resp), error: None } if result_type == "ok" => {
+            match resp.result {
+                Some(rs) => Ok(rs),
+                None => Err("Turso response missing result".to_string()),
+            }
+        }
+        TursoPipelineResult { error: Some(err), .. } => Err(format!("Turso error: {}", err.message)),
+        other => Err(format!("Unexpected Turso result type: {}", other.result_type)),
+    }
+}
+
+async fn send_pipeline(client: &TursoClient, sql: &str) -> Result<TursoPipelineResult, String> {
+    let resp = client.post_pipeline(sql).send().await.map_err(|e| format!("Turso request failed: {e}"))?;
+    let status = resp.status();
+    let body = resp.text().await.map_err(|e| format!("Turso response read failed: {e}"))?;
+    if !status.is_success() {
+        return Err(format!("Turso error ({}): {}", status.as_u16(), body));
+    }
+    let response: TursoPipelineResponse =
+        serde_json::from_str(&body).map_err(|e| format!("Turso parse error: {e}; body: {body}"))?;
+    response.results.into_iter().next().ok_or_else(|| "Turso returned no result".to_string())
+}
+
+async fn send_pipeline_batch(client: &TursoClient, statements: &[&str]) -> Result<TursoResultSet, String> {
+    let resp = client.post_pipeline_batch(statements).send().await.map_err(|e| format!("Turso request failed: {e}"))?;
+    let status = resp.status();
+    let body = resp.text().await.map_err(|e| format!("Turso response read failed: {e}"))?;
+    if !status.is_success() {
+        return Err(format!("Turso error ({}): {}", status.as_u16(), body));
+    }
+    let response: TursoPipelineResponse =
+        serde_json::from_str(&body).map_err(|e| format!("Turso parse error: {e}; body: {body}"))?;
+
+    // For batch, take the last result (COMMIT result for BEGIN/INSERT/COMMIT patterns)
+    let mut last_result_set =
+        TursoResultSet { cols: vec![], rows: vec![], rows_read: None, rows_written: None, affected_row_count: Some(0) };
+    for result in &response.results {
+        match result {
+            TursoPipelineResult { result_type, error: Some(err), .. } if result_type == "error" => {
+                return Err(format!("Turso error: {}", err.message));
+            }
+            TursoPipelineResult { response: Some(resp), .. } => {
+                if let Some(rs) = &resp.result {
+                    last_result_set = TursoResultSet {
+                        cols: rs.cols.clone(),
+                        rows: rs.rows.clone(),
+                        rows_read: rs.rows_read,
+                        rows_written: rs.rows_written,
+                        affected_row_count: Some(
+                            last_result_set.affected_row_count.unwrap_or(0) + rs.affected_row_count.unwrap_or(0),
+                        ),
+                    };
+                }
+            }
+            _ => {}
+        }
+    }
+    Ok(last_result_set)
+}
+
+/// Internal result representation with decoded columns and rows
+struct TursoExtractedResult {
+    columns: Vec<String>,
+    values: Vec<Vec<serde_json::Value>>,
+    #[allow(dead_code)]
+    rows_written: Option<u64>,
+}
+
+fn extract_result(result_set: TursoResultSet) -> TursoExtractedResult {
+    let columns: Vec<String> = result_set.cols.iter().map(|c| c.name.clone()).collect();
+    let values: Vec<Vec<serde_json::Value>> =
+        result_set.rows.into_iter().map(|row| row.into_iter().map(turso_value_to_json).collect()).collect();
+    TursoExtractedResult { columns, values, rows_written: result_set.rows_written }
+}
+
+fn turso_value_to_json(v: TursoValue) -> serde_json::Value {
+    match v.value {
+        Some(val) => match v.value_type.as_str() {
+            "integer" => val
+                .as_str()
+                .and_then(|s| s.parse::<i64>().ok())
+                .map(serde_json::Value::from)
+                .unwrap_or(serde_json::Value::Null),
+            "float" => val
+                .as_str()
+                .and_then(|s| s.parse::<f64>().ok())
+                .map(|f| serde_json::json!(f))
+                .unwrap_or(serde_json::Value::Null),
+            "text" => serde_json::Value::String(val.as_str().unwrap_or("").to_string()),
+            "null" => serde_json::Value::Null,
+            "blob" => {
+                // Blobs in Turso are base64-encoded strings
+                let hex = val.as_str().map(base64_to_hex).unwrap_or_else(|| val.to_string());
+                serde_json::Value::String(format!("0x{}", hex))
+            }
+            _ => {
+                // Fallback: try to use the raw value
+                val
+            }
+        },
+        None => serde_json::Value::Null,
+    }
+}
+
+fn base64_to_hex(_b64: &str) -> String {
+    // For blob values, we pass through as-is if not parseable
+    // A full base64→hex implementation can be added later
+    _b64.to_string()
+}
+
+fn query_result_from_turso_result(
+    mut result: TursoExtractedResult,
+    execution_time_ms: u128,
+    max_rows: Option<usize>,
+) -> QueryResult {
+    let row_limit = max_rows.unwrap_or(crate::query::MAX_ROWS).max(1);
+    let truncated = result.values.len() > row_limit;
+    if truncated {
+        result.values.truncate(row_limit);
+    }
+    QueryResult {
+        columns: result.columns,
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: result.values,
+        affected_rows: 0,
+        execution_time_ms,
+        truncated,
+        session_id: None,
+        has_more: false,
+    }
+}
+
+fn first_string_cell(result: TursoExtractedResult) -> Result<String, String> {
+    result
+        .values
+        .first()
+        .and_then(|row| row.first())
+        .and_then(|value| value_as_string(Some(value)))
+        .ok_or_else(|| "Object not found".to_string())
+}
+
+fn value_by_column(columns: &[String], row: &[serde_json::Value], name: &str) -> Option<String> {
+    columns
+        .iter()
+        .position(|column| column.eq_ignore_ascii_case(name))
+        .and_then(|index| row.get(index))
+        .and_then(|value| value_as_string(Some(value)))
+}
+
+fn value_as_string(value: Option<&serde_json::Value>) -> Option<String> {
+    match value? {
+        serde_json::Value::Null => None,
+        serde_json::Value::String(value) => Some(value.clone()),
+        serde_json::Value::Number(value) => Some(value.to_string()),
+        serde_json::Value::Bool(value) => Some(value.to_string()),
+        other => Some(other.to_string()),
+    }
+}
+
+fn sqlite_ident(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+fn sqlite_string(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+fn turso_accept_invalid_certs(tls_enabled: bool) -> bool {
+    tls_enabled
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn converts_query_result_and_truncates_rows() {
+        let result = TursoExtractedResult {
+            columns: vec!["id".to_string(), "name".to_string()],
+            values: vec![
+                vec![serde_json::json!(1), serde_json::json!("Ada")],
+                vec![serde_json::json!(2), serde_json::json!("Linus")],
+            ],
+            rows_written: None,
+        };
+
+        let result = query_result_from_turso_result(result, 8, Some(1));
+
+        assert_eq!(result.columns, vec!["id", "name"]);
+        assert_eq!(result.rows, vec![vec![serde_json::json!(1), serde_json::json!("Ada")]]);
+        assert_eq!(result.execution_time_ms, 8);
+        assert!(result.truncated);
+    }
+
+    #[test]
+    fn maps_column_values_by_name_case_insensitive() {
+        let columns = vec!["name".to_string(), "notnull".to_string(), "pk".to_string()];
+        let row = vec![serde_json::json!("id"), serde_json::json!(1), serde_json::json!(1)];
+
+        assert_eq!(value_by_column(&columns, &row, "NAME").as_deref(), Some("id"));
+        assert_eq!(value_by_column(&columns, &row, "notnull").as_deref(), Some("1"));
+    }
+
+    #[test]
+    fn split_sql_statements_splits_on_semicolons() {
+        assert_eq!(split_sql_statements("SELECT 1"), vec!["SELECT 1"]);
+        assert_eq!(
+            split_sql_statements("BEGIN; INSERT INTO t VALUES (1); COMMIT"),
+            vec!["BEGIN", "INSERT INTO t VALUES (1)", "COMMIT"]
+        );
+        assert_eq!(split_sql_statements("SELECT 1;  "), vec!["SELECT 1"]);
+        assert_eq!(split_sql_statements("  ;  "), Vec::<&str>::new());
+        assert_eq!(split_sql_statements("SELECT 'a;b' AS x"), vec!["SELECT 'a;b' AS x"]);
+        assert_eq!(split_sql_statements("SELECT \"a;b\" AS x; SELECT 2"), vec!["SELECT \"a;b\" AS x", "SELECT 2"]);
+    }
+
+    #[test]
+    fn value_as_string_converts_types() {
+        assert_eq!(value_as_string(Some(&serde_json::json!("hello"))), Some("hello".to_string()));
+        assert_eq!(value_as_string(Some(&serde_json::json!(42))), Some("42".to_string()));
+        assert_eq!(value_as_string(Some(&serde_json::json!(true))), Some("true".to_string()));
+        assert_eq!(value_as_string(Some(&serde_json::json!(null))), None);
+    }
+
+    #[test]
+    fn turso_value_integer_parsed() {
+        let v = TursoValue { value_type: "integer".to_string(), value: Some(serde_json::json!("42")) };
+        assert_eq!(turso_value_to_json(v), serde_json::json!(42));
+    }
+
+    #[test]
+    fn turso_value_text_parsed() {
+        let v = TursoValue { value_type: "text".to_string(), value: Some(serde_json::json!("hello")) };
+        assert_eq!(turso_value_to_json(v), serde_json::json!("hello"));
+    }
+
+    #[test]
+    fn turso_value_null_parsed() {
+        let v = TursoValue { value_type: "null".to_string(), value: None };
+        assert_eq!(turso_value_to_json(v), serde_json::Value::Null);
+    }
+
+    #[test]
+    #[allow(clippy::approx_constant)]
+    fn turso_value_float_parsed() {
+        let v = TursoValue { value_type: "float".to_string(), value: Some(serde_json::json!("3.14")) };
+        assert_eq!(turso_value_to_json(v), serde_json::json!(3.14));
+    }
+
+    #[test]
+    fn extract_result_decodes_rows_and_columns() {
+        let rs = TursoResultSet {
+            cols: vec![
+                TursoColumn { name: "id".to_string(), decltype: None },
+                TursoColumn { name: "name".to_string(), decltype: None },
+            ],
+            rows: vec![vec![
+                TursoValue { value_type: "integer".to_string(), value: Some(serde_json::json!("1")) },
+                TursoValue { value_type: "text".to_string(), value: Some(serde_json::json!("Ada")) },
+            ]],
+            rows_read: Some(1),
+            rows_written: Some(0),
+            affected_row_count: Some(0),
+        };
+
+        let result = extract_result(rs);
+        assert_eq!(result.columns, vec!["id", "name"]);
+        assert_eq!(result.values.len(), 1);
+        assert_eq!(result.values[0][0], serde_json::json!(1));
+        assert_eq!(result.values[0][1], serde_json::json!("Ada"));
+    }
+
+    #[test]
+    fn first_string_cell_returns_value() {
+        let result = TursoExtractedResult {
+            columns: vec!["sql".to_string()],
+            values: vec![vec![serde_json::json!("CREATE TABLE t (id INTEGER)")]],
+            rows_written: None,
+        };
+        assert_eq!(first_string_cell(result).unwrap(), "CREATE TABLE t (id INTEGER)");
+    }
+
+    #[test]
+    fn first_string_cell_empty_returns_error() {
+        let result = TursoExtractedResult { columns: vec!["sql".to_string()], values: vec![], rows_written: None };
+        assert!(first_string_cell(result).is_err());
+    }
+
+    #[test]
+    fn sqlite_ident_quotes_properly() {
+        assert_eq!(sqlite_ident("my_table"), "\"my_table\"");
+        assert_eq!(sqlite_ident("my\"table"), "\"my\"\"table\"");
+    }
+
+    #[test]
+    fn sqlite_string_quotes_properly() {
+        assert_eq!(sqlite_string("hello"), "'hello'");
+        assert_eq!(sqlite_string("it's"), "'it''s'");
+    }
+
+    #[test]
+    fn query_result_no_truncation_when_within_limit() {
+        let result = TursoExtractedResult {
+            columns: vec!["x".to_string()],
+            values: vec![vec![serde_json::json!(1)], vec![serde_json::json!(2)]],
+            rows_written: None,
+        };
+
+        let qr = query_result_from_turso_result(result, 5, Some(100));
+        assert_eq!(qr.rows.len(), 2);
+        assert!(!qr.truncated);
+    }
+}
diff --git a/crates/dbx-core/src/db/vector_driver.rs b/crates/dbx-core/src/db/vector_driver.rs
new file mode 100644
index 0000000..59aad27
--- /dev/null
+++ b/crates/dbx-core/src/db/vector_driver.rs
@@ -0,0 +1,879 @@
+use percent_encoding::{utf8_percent_encode, AsciiSet, CONTROLS};
+use reqwest::Client as HttpClient;
+use serde_json::{Map, Value};
+use std::error::Error;
+use std::time::{Duration, Instant};
+
+use super::{http_client_builder, with_connection_timeout};
+use crate::types::QueryResult;
+
+const PATH_SEGMENT_ENCODE_SET: &AsciiSet = &CONTROLS
+    .add(b' ')
+    .add(b'"')
+    .add(b'#')
+    .add(b'%')
+    .add(b'/')
+    .add(b'<')
+    .add(b'>')
+    .add(b'?')
+    .add(b'[')
+    .add(b'\\')
+    .add(b']')
+    .add(b'^')
+    .add(b'`')
+    .add(b'{')
+    .add(b'|')
+    .add(b'}');
+
+const QUERY_VALUE_ENCODE_SET: &AsciiSet = &PATH_SEGMENT_ENCODE_SET.add(b'&').add(b'=').add(b'+');
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CollectionInfo {
+    pub name: String,
+    pub id: String,
+    pub dimension: Option<u32>,
+    pub kind: Option<String>,
+    pub bucket_name: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum VectorDbKind {
+    Qdrant,
+    Milvus,
+    Weaviate,
+    ChromaDb,
+}
+
+impl VectorDbKind {
+    fn label(self) -> &'static str {
+        match self {
+            VectorDbKind::Qdrant => "Qdrant",
+            VectorDbKind::Milvus => "Milvus",
+            VectorDbKind::Weaviate => "Weaviate",
+            VectorDbKind::ChromaDb => "ChromaDB",
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct VectorClient {
+    kind: VectorDbKind,
+    http: HttpClient,
+    base_url: String,
+    auth: Option<VectorAuth>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+enum VectorAuth {
+    Basic(String, String),
+    Bearer(String),
+    ApiKey(String),
+    ChromaToken(String),
+}
+
+impl VectorClient {
+    pub fn new(
+        kind: VectorDbKind,
+        url: &str,
+        username: Option<&str>,
+        password: Option<&str>,
+        accept_invalid_certs: bool,
+        timeout: Duration,
+    ) -> Self {
+        let base_url = url.trim_end_matches('/').to_string();
+        let auth = vector_auth(kind, username, password);
+        let builder = http_client_builder(timeout).danger_accept_invalid_certs(accept_invalid_certs);
+        let http = builder.build().unwrap_or_else(|_| HttpClient::new());
+        Self { kind, http, base_url, auth }
+    }
+
+    fn get(&self, path: &str) -> reqwest::RequestBuilder {
+        self.with_auth(self.http.get(format!("{}{}", self.base_url, path)))
+    }
+
+    fn post(&self, path: &str) -> reqwest::RequestBuilder {
+        self.with_auth(self.http.post(format!("{}{}", self.base_url, path)))
+    }
+
+    fn put(&self, path: &str) -> reqwest::RequestBuilder {
+        self.with_auth(self.http.put(format!("{}{}", self.base_url, path)))
+    }
+
+    fn delete(&self, path: &str) -> reqwest::RequestBuilder {
+        self.with_auth(self.http.delete(format!("{}{}", self.base_url, path)))
+    }
+
+    fn with_auth(&self, req: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
+        match &self.auth {
+            Some(VectorAuth::Basic(user, pass)) => req.basic_auth(user, Some(pass)),
+            Some(VectorAuth::Bearer(token)) => req.bearer_auth(token),
+            Some(VectorAuth::ApiKey(token)) => req.header("api-key", token),
+            Some(VectorAuth::ChromaToken(token)) => req.header("x-chroma-token", token),
+            None => req,
+        }
+    }
+}
+
+fn vector_auth(kind: VectorDbKind, username: Option<&str>, password: Option<&str>) -> Option<VectorAuth> {
+    let username = username.unwrap_or("").trim();
+    let password = password.unwrap_or("");
+    match kind {
+        VectorDbKind::Qdrant if !username.is_empty() => {
+            Some(VectorAuth::Basic(username.to_string(), password.to_string()))
+        }
+        VectorDbKind::Qdrant if !password.is_empty() => Some(VectorAuth::ApiKey(password.to_string())),
+        VectorDbKind::Qdrant => None,
+        VectorDbKind::Milvus if !username.is_empty() => Some(VectorAuth::Bearer(format!("{username}:{password}"))),
+        VectorDbKind::Milvus => None,
+        VectorDbKind::Weaviate if !password.is_empty() => Some(VectorAuth::Bearer(password.to_string())),
+        VectorDbKind::Weaviate => None,
+        VectorDbKind::ChromaDb if !password.is_empty() => Some(VectorAuth::ChromaToken(password.to_string())),
+        VectorDbKind::ChromaDb => None,
+    }
+}
+
+pub async fn test_connection(client: &VectorClient, timeout: Duration) -> Result<(), String> {
+    let label = client.kind.label();
+    let path = match client.kind {
+        VectorDbKind::Qdrant => "/collections",
+        VectorDbKind::Milvus => "/v2/vectordb/collections/list",
+        VectorDbKind::Weaviate => "/v1/meta",
+        VectorDbKind::ChromaDb => "/api/v2/heartbeat",
+    };
+    let request = match client.kind {
+        VectorDbKind::Qdrant => client.get(path),
+        VectorDbKind::Milvus => client.post(path).json(&serde_json::json!({ "dbName": "default" })),
+        VectorDbKind::Weaviate => client.get(path),
+        VectorDbKind::ChromaDb => client.get(path),
+    };
+    let resp = with_connection_timeout(label, timeout, async {
+        request.send().await.map_err(|e| format!("{label} connection failed: {}", format_reqwest_error(&e)))
+    })
+    .await?;
+    ensure_success(label, resp).await.map(|_| ())
+}
+
+pub async fn list_collections(client: &VectorClient) -> Result<Vec<CollectionInfo>, String> {
+    list_collections_with_db(client, "").await
+}
+
+/// List collections, passing an optional database name (used by Milvus).
+pub(crate) async fn list_collections_with_db(
+    client: &VectorClient,
+    database: &str,
+) -> Result<Vec<CollectionInfo>, String> {
+    match client.kind {
+        VectorDbKind::Qdrant => list_qdrant_collections(client).await,
+        VectorDbKind::Milvus => list_milvus_collections(client, database).await,
+        VectorDbKind::Weaviate => list_weaviate_collections(client).await,
+        VectorDbKind::ChromaDb => list_chroma_collections(client).await,
+    }
+}
+
+/// List databases for a vector connection.
+/// Milvus supports multiple databases; other vector stores expose a single "default" namespace.
+pub async fn list_databases(client: &VectorClient) -> Result<Vec<String>, String> {
+    match client.kind {
+        VectorDbKind::Milvus => list_milvus_databases(client).await,
+        _ => Ok(vec!["default".to_string()]),
+    }
+}
+
+async fn list_milvus_databases(client: &VectorClient) -> Result<Vec<String>, String> {
+    // Older Milvus versions (pre-2.2) do not expose the databases endpoint; fall back to "default"
+    // so the connection stays browsable instead of failing the whole tree load.
+    //
+    // The endpoint rejects a bodyless POST with `{"code":1801,...}` (HTTP 200, no `data` field),
+    // so send an empty JSON object like every other Milvus v2 endpoint.
+    let body = match send_json(client.post("/v2/vectordb/databases/list").json(&serde_json::json!({})), "Milvus").await
+    {
+        Ok(body) => body,
+        Err(_) => return Ok(vec!["default".to_string()]),
+    };
+    let mut names: Vec<String> = match body.get("data") {
+        Some(Value::Array(items)) => items.iter().filter_map(milvus_database_name_from_item).collect(),
+        _ => Vec::new(),
+    };
+    if !names.iter().any(|name| name == "default") {
+        names.push("default".to_string());
+    }
+    names.sort_by(|a, b| a.cmp(b));
+    Ok(names)
+}
+
+fn milvus_database_name_from_item(item: &Value) -> Option<String> {
+    item.as_str()
+        .map(str::to_string)
+        .or_else(|| item.get("dbName").and_then(Value::as_str).map(str::to_string))
+        .or_else(|| item.get("name").and_then(Value::as_str).map(str::to_string))
+}
+
+async fn list_qdrant_collections(client: &VectorClient) -> Result<Vec<CollectionInfo>, String> {
+    let body = send_json(client.get("/collections"), "Qdrant").await?;
+    let mut infos: Vec<CollectionInfo> = body
+        .pointer("/result/collections")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .filter_map(|item| {
+            let name = item.get("name").and_then(Value::as_str)?;
+            Some(CollectionInfo {
+                name: name.to_string(),
+                id: name.to_string(),
+                dimension: None,
+                kind: None,
+                bucket_name: None,
+            })
+        })
+        .collect();
+    infos.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(infos)
+}
+
+async fn list_milvus_collections(client: &VectorClient, database: &str) -> Result<Vec<CollectionInfo>, String> {
+    let db_name = if database.is_empty() { "default" } else { database };
+    let body = send_json(
+        client.post("/v2/vectordb/collections/list").json(&serde_json::json!({ "dbName": db_name })),
+        "Milvus",
+    )
+    .await?;
+    let mut infos: Vec<CollectionInfo> = match body.get("data") {
+        Some(Value::Array(items)) => items
+            .iter()
+            .filter_map(|item| {
+                let name = collection_name_from_milvus_item(item)?;
+                Some(CollectionInfo { name: name.clone(), id: name, dimension: None, kind: None, bucket_name: None })
+            })
+            .collect(),
+        _ => Vec::new(),
+    };
+    infos.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(infos)
+}
+
+fn collection_name_from_milvus_item(item: &Value) -> Option<String> {
+    item.as_str()
+        .map(str::to_string)
+        .or_else(|| item.get("collectionName").and_then(Value::as_str).map(str::to_string))
+        .or_else(|| item.get("name").and_then(Value::as_str).map(str::to_string))
+}
+
+async fn list_weaviate_collections(client: &VectorClient) -> Result<Vec<CollectionInfo>, String> {
+    let body = send_json(client.get("/v1/schema"), "Weaviate").await?;
+    let mut infos: Vec<CollectionInfo> = weaviate_collection_names_from_schema(&body)
+        .into_iter()
+        .map(|name| CollectionInfo { name: name.clone(), id: name, dimension: None, kind: None, bucket_name: None })
+        .collect();
+    infos.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(infos)
+}
+
+async fn list_chroma_collections(client: &VectorClient) -> Result<Vec<CollectionInfo>, String> {
+    let body =
+        send_json(client.get("/api/v2/tenants/default_tenant/databases/default_database/collections"), "ChromaDB")
+            .await?;
+    let mut infos: Vec<CollectionInfo> = body
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter_map(|item| {
+            let name = item.get("name").and_then(Value::as_str)?;
+            let id = item.get("id").and_then(Value::as_str)?;
+            let dimension = item.get("dimension").and_then(|v| v.as_u64()).map(|d| d as u32);
+            Some(CollectionInfo {
+                name: name.to_string(),
+                id: id.to_string(),
+                dimension,
+                kind: None,
+                bucket_name: None,
+            })
+        })
+        .collect();
+    infos.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(infos)
+}
+
+pub async fn get_collection_detail(
+    client: &VectorClient,
+    database: &str,
+    collection: &str,
+) -> Result<CollectionInfo, String> {
+    match client.kind {
+        VectorDbKind::Qdrant => get_qdrant_collection_detail(client, collection).await,
+        VectorDbKind::Milvus => get_milvus_collection_detail(client, database, collection).await,
+        VectorDbKind::Weaviate => {
+            // Weaviate REST API does not expose vector dimension
+            Ok(CollectionInfo {
+                name: collection.to_string(),
+                id: collection.to_string(),
+                dimension: None,
+                kind: None,
+                bucket_name: None,
+            })
+        }
+        VectorDbKind::ChromaDb => get_chroma_collection_detail(client, collection).await,
+    }
+}
+
+async fn get_qdrant_collection_detail(client: &VectorClient, collection: &str) -> Result<CollectionInfo, String> {
+    let body = send_json(client.get(&format!("/collections/{}", path_segment(collection))), "Qdrant").await?;
+    let dim = body
+        .pointer("/result/config/params/vectors/size")
+        .and_then(Value::as_u64)
+        .or_else(|| {
+            body.pointer("/result/config/params/vectors")
+                .and_then(Value::as_object)
+                .and_then(|obj| obj.values().find_map(|v| v.get("size").and_then(|s| s.as_u64())))
+        })
+        .map(|d| d as u32);
+    Ok(CollectionInfo {
+        name: collection.to_string(),
+        id: collection.to_string(),
+        dimension: dim,
+        kind: None,
+        bucket_name: None,
+    })
+}
+
+fn milvus_vector_dim_from_field(field: &Value) -> Option<u32> {
+    if let Some(dim) = field.pointer("/params/dim").and_then(Value::as_u64) {
+        return Some(dim as u32);
+    }
+    if let Some(params) = field.get("params").and_then(Value::as_array) {
+        for param in params {
+            if param.get("key").and_then(Value::as_str) == Some("dim") {
+                if let Some(v) = param.get("value").and_then(Value::as_str) {
+                    return v.parse().ok();
+                }
+                if let Some(v) = param.get("value").and_then(Value::as_u64) {
+                    return Some(v as u32);
+                }
+            }
+        }
+    }
+    None
+}
+
+async fn get_milvus_collection_detail(
+    client: &VectorClient,
+    database: &str,
+    collection: &str,
+) -> Result<CollectionInfo, String> {
+    let db_name = if database.is_empty() { "default" } else { database };
+    let body = send_json(
+        client
+            .post("/v2/vectordb/collections/describe")
+            .json(&serde_json::json!({ "dbName": db_name, "collectionName": collection })),
+        "Milvus",
+    )
+    .await?;
+    if body.get("code").and_then(Value::as_i64) != Some(0) {
+        let msg = body.get("message").and_then(Value::as_str).unwrap_or("unknown error");
+        return Err(format!("Milvus collection detail error: {msg}"));
+    }
+    let fields = body.pointer("/data/fields").and_then(Value::as_array);
+    let dim = fields
+        .and_then(|f| {
+            f.iter().find(|f| {
+                let t = f.get("type");
+                t.and_then(Value::as_str) == Some("FloatVector")
+                    || t.and_then(Value::as_str) == Some("BinaryVector")
+                    || t.and_then(Value::as_i64) == Some(101)
+                    || t.and_then(Value::as_i64) == Some(102)
+            })
+        })
+        .and_then(milvus_vector_dim_from_field);
+    Ok(CollectionInfo {
+        name: collection.to_string(),
+        id: collection.to_string(),
+        dimension: dim,
+        kind: None,
+        bucket_name: None,
+    })
+}
+
+async fn get_chroma_collection_detail(client: &VectorClient, collection: &str) -> Result<CollectionInfo, String> {
+    let body = send_json(
+        client.get(&format!(
+            "/api/v2/tenants/default_tenant/databases/default_database/collections/{}",
+            path_segment(collection)
+        )),
+        "ChromaDB",
+    )
+    .await?;
+    let name = body.get("name").and_then(Value::as_str).unwrap_or(collection);
+    let id = body.get("id").and_then(Value::as_str).unwrap_or(collection);
+    let dimension = body.get("dimension").and_then(|v| v.as_u64()).map(|d| d as u32);
+    Ok(CollectionInfo { name: name.to_string(), id: id.to_string(), dimension, kind: None, bucket_name: None })
+}
+
+fn chroma_get_response_to_rows(body: &Value) -> Vec<Value> {
+    let flatten = |key: &str| -> Vec<Value> {
+        let raw = body.get(key).and_then(Value::as_array).cloned().unwrap_or_default();
+        let is_nested = raw.first().and_then(|v| v.as_array()).is_some();
+        if is_nested {
+            raw.iter().flat_map(|v| v.as_array().cloned().unwrap_or_default()).collect()
+        } else {
+            raw
+        }
+    };
+
+    let ids = flatten("ids");
+    let documents = flatten("documents");
+    let metadatas = flatten("metadatas");
+    let distances = flatten("distances");
+
+    ids.into_iter()
+        .enumerate()
+        .map(|(i, id_val)| {
+            let mut row = serde_json::Map::new();
+            row.insert("id".to_string(), id_val);
+            if let Some(doc) = documents.get(i) {
+                row.insert("document".to_string(), doc.clone());
+            }
+            if let Some(Value::Object(meta_obj)) = metadatas.get(i) {
+                for (k, v) in meta_obj {
+                    row.insert(k.clone(), v.clone());
+                }
+            }
+            if let Some(dist) = distances.get(i) {
+                row.insert("distance".to_string(), dist.clone());
+            }
+            Value::Object(row)
+        })
+        .collect()
+}
+
+fn weaviate_graphql_to_rows(body: &Value) -> Option<Vec<Value>> {
+    let get_obj = body.pointer("/data/Get")?.as_object()?;
+    let (_class_name, items) = get_obj.iter().next()?;
+    let items = items.as_array()?;
+    Some(
+        items
+            .iter()
+            .map(|item| {
+                let mut obj = match item {
+                    Value::Object(m) => m.clone(),
+                    _ => return item.clone(),
+                };
+                if let Some(Value::Object(additional)) = obj.remove("_additional") {
+                    for (k, v) in additional {
+                        obj.entry(k).or_insert(v);
+                    }
+                }
+                Value::Object(obj)
+            })
+            .collect(),
+    )
+}
+
+fn weaviate_collection_names_from_schema(body: &Value) -> Vec<String> {
+    body.get("classes")
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .filter_map(|item| item.get("class").and_then(Value::as_str).map(str::to_string))
+        .collect()
+}
+
+pub async fn find_documents(
+    client: &VectorClient,
+    database: &str,
+    collection: &str,
+    skip: u64,
+    limit: i64,
+) -> Result<crate::db::mongo_driver::MongoDocumentResult, String> {
+    if client.kind == VectorDbKind::ChromaDb {
+        let start = std::time::Instant::now();
+        let url = format!(
+            "{}/api/v2/tenants/default_tenant/databases/default_database/collections/{}/get",
+            client.base_url,
+            path_segment(collection),
+        );
+        let resp = client
+            .with_auth(client.http.post(&url))
+            .json(&serde_json::json!({
+                "limit": limit.max(1) as u64,
+                "offset": skip,
+                "include": ["documents", "metadatas"],
+            }))
+            .send()
+            .await
+            .map_err(|e| format!("ChromaDB request failed: {}", format_reqwest_error(&e)))?;
+        if !resp.status().is_success() {
+            let status = resp.status();
+            let body = resp.text().await.unwrap_or_default();
+            return Err(format!("ChromaDB error ({status}): {body}"));
+        }
+        let body: Value = resp.json().await.unwrap_or(Value::Null);
+        let rows = chroma_get_response_to_rows(&body);
+        let result = values_to_query_result(rows, start);
+        let documents = result
+            .rows
+            .into_iter()
+            .map(|row| {
+                let mut map = serde_json::Map::new();
+                for (idx, col) in result.columns.iter().enumerate() {
+                    map.insert(col.clone(), row.get(idx).cloned().unwrap_or(Value::Null));
+                }
+                Value::Object(map)
+            })
+            .collect();
+        return Ok(crate::db::mongo_driver::MongoDocumentResult { documents, total: result.affected_rows });
+    }
+
+    let query = match client.kind {
+        VectorDbKind::Qdrant => format!(
+            "POST /collections/{}/points/scroll\n{}",
+            path_segment(collection),
+            serde_json::json!({
+                "limit": limit.max(1) as u64,
+                "offset": if skip == 0 { Value::Null } else { Value::from(skip) },
+                "with_payload": true,
+                "with_vector": false,
+            })
+        ),
+        VectorDbKind::Milvus => format!(
+            "POST /v2/vectordb/entities/query\n{}",
+            serde_json::json!({
+                "dbName": if database.is_empty() { "default" } else { database },
+                "collectionName": collection,
+                "filter": "",
+                "limit": limit.max(1) as u64,
+                "offset": skip,
+                "outputFields": ["*"],
+            })
+        ),
+        VectorDbKind::Weaviate => {
+            format!("GET /v1/objects?class={}&limit={}&offset={}", query_value(collection), limit.max(1), skip)
+        }
+        VectorDbKind::ChromaDb => unreachable!("ChromaDB handled above"),
+    };
+    let result = execute_rest_query(client, &query).await?;
+    let documents = result
+        .rows
+        .into_iter()
+        .map(|row| {
+            let mut map = Map::new();
+            for (idx, column) in result.columns.iter().enumerate() {
+                map.insert(column.clone(), row.get(idx).cloned().unwrap_or(Value::Null));
+            }
+            Value::Object(map)
+        })
+        .collect();
+    Ok(crate::db::mongo_driver::MongoDocumentResult { documents, total: result.affected_rows })
+}
+
+pub async fn execute_rest_query(client: &VectorClient, input: &str) -> Result<QueryResult, String> {
+    let start = Instant::now();
+    let request = parse_rest_query(client, input)?;
+    let resp = request.send().await.map_err(|e| format!("{} request failed: {e}", client.kind.label()))?;
+    let status = resp.status().as_u16();
+    let body = resp.json::<Value>().await.unwrap_or(Value::Null);
+    if !(200..300).contains(&status) {
+        let detail = serde_json::to_string_pretty(&body).unwrap_or_else(|_| body.to_string());
+        return Err(format!("{} error ({status}): {detail}", client.kind.label()));
+    }
+    Ok(json_to_query_result(status, body, start))
+}
+
+fn parse_rest_query(client: &VectorClient, input: &str) -> Result<reqwest::RequestBuilder, String> {
+    let trimmed = input.trim();
+    if trimmed.is_empty() {
+        return Err(format!("{} query cannot be empty", client.kind.label()));
+    }
+
+    if !starts_with_http_method(trimmed) {
+        return default_collection_query(client, trimmed);
+    }
+
+    let (head, body) = trimmed.split_once('\n').map_or((trimmed, ""), |(head, body)| (head.trim(), body.trim()));
+    let mut parts = head.split_whitespace();
+    let method = parts.next().unwrap_or("").to_ascii_uppercase();
+    let path = parts.next().ok_or_else(|| "Vector query path is required".to_string())?;
+    let path = if path.starts_with('/') { path.to_string() } else { format!("/{path}") };
+    let req = match method.as_str() {
+        "GET" => client.get(&path),
+        "POST" => client.post(&path),
+        "PUT" => client.put(&path),
+        "DELETE" => client.delete(&path),
+        other => return Err(format!("Unsupported vector REST method: {other}")),
+    };
+    if body.is_empty() {
+        Ok(req)
+    } else {
+        let json: Value = serde_json::from_str(body).map_err(|e| format!("Vector query body must be JSON: {e}"))?;
+        Ok(req.json(&json))
+    }
+}
+
+fn default_collection_query(client: &VectorClient, collection: &str) -> Result<reqwest::RequestBuilder, String> {
+    let collection = collection.trim();
+    if collection.is_empty() {
+        return Err("Vector collection name cannot be empty".to_string());
+    }
+    match client.kind {
+        VectorDbKind::Qdrant => Ok(client
+            .post(&format!("/collections/{}/points/scroll", path_segment(collection)))
+            .json(&serde_json::json!({ "limit": 100, "with_payload": true, "with_vector": false }))),
+        VectorDbKind::Milvus => Ok(client.post("/v2/vectordb/entities/query").json(&serde_json::json!({
+            "dbName": "default",
+            "collectionName": collection,
+            "filter": "",
+            "limit": 100,
+            "outputFields": ["*"],
+        }))),
+        VectorDbKind::Weaviate => Ok(client.get(&format!("/v1/objects?class={}&limit=100", query_value(collection)))),
+        VectorDbKind::ChromaDb => Ok(client
+            .post(&format!(
+                "/api/v2/tenants/default_tenant/databases/default_database/collections/{}/get",
+                path_segment(collection)
+            ))
+            .json(&serde_json::json!({"limit": 100, "include": ["documents", "metadatas"]}))),
+    }
+}
+
+fn starts_with_http_method(input: &str) -> bool {
+    ["GET ", "POST ", "PUT ", "DELETE "].iter().any(|prefix| input.to_ascii_uppercase().starts_with(prefix))
+}
+
+pub(crate) fn path_segment(value: &str) -> String {
+    utf8_percent_encode(value, PATH_SEGMENT_ENCODE_SET).to_string()
+}
+
+pub(crate) fn query_value(value: &str) -> String {
+    utf8_percent_encode(value, QUERY_VALUE_ENCODE_SET).to_string()
+}
+
+async fn send_json(req: reqwest::RequestBuilder, label: &str) -> Result<Value, String> {
+    let resp = req.send().await.map_err(|e| format!("{label} request failed: {e}"))?;
+    let resp = ensure_success(label, resp).await?;
+    resp.json().await.map_err(|e| format!("{label} parse error: {e}"))
+}
+
+async fn ensure_success(label: &str, resp: reqwest::Response) -> Result<reqwest::Response, String> {
+    if resp.status().is_success() {
+        return Ok(resp);
+    }
+    let status = resp.status();
+    let body = resp.text().await.unwrap_or_default();
+    Err(format!("{label} error ({status}): {body}"))
+}
+
+fn json_to_query_result(status: u16, body: Value, start: Instant) -> QueryResult {
+    let rows_value =
+        body.pointer("/result/points").or_else(|| body.get("result")).or_else(|| body.get("data")).cloned();
+    if let Some(Value::Array(items)) = rows_value {
+        return values_to_query_result(items, start);
+    }
+    if let Some(Value::Array(items)) = body.get("objects").cloned() {
+        return values_to_query_result(items, start);
+    }
+    if let Some(Value::Array(items)) = body.pointer("/result/collections").cloned() {
+        return values_to_query_result(items, start);
+    }
+    if body.get("ids").and_then(Value::as_array).is_some() && body.get("documents").and_then(Value::as_array).is_some()
+    {
+        let rows = chroma_get_response_to_rows(&body);
+        return values_to_query_result(rows, start);
+    }
+    // Weaviate GraphQL search response
+    if let Some(items) = weaviate_graphql_to_rows(&body) {
+        return values_to_query_result(items, start);
+    }
+    QueryResult {
+        columns: vec!["status".to_string(), "response".to_string()],
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: vec![vec![
+            Value::Number(status.into()),
+            Value::String(serde_json::to_string_pretty(&body).unwrap_or_else(|_| body.to_string())),
+        ]],
+        affected_rows: 0,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    }
+}
+
+fn values_to_query_result(items: Vec<Value>, start: Instant) -> QueryResult {
+    let docs: Vec<Map<String, Value>> = items.into_iter().map(normalize_row_object).collect();
+    let mut columns = Vec::<String>::new();
+    for doc in &docs {
+        for key in doc.keys() {
+            if !columns.contains(key) {
+                columns.push(key.clone());
+            }
+        }
+    }
+    if columns.is_empty() {
+        columns.push("value".to_string());
+    }
+    let rows: Vec<Vec<Value>> = docs
+        .iter()
+        .map(|doc| columns.iter().map(|column| doc.get(column).cloned().unwrap_or(Value::Null)).collect())
+        .collect();
+    QueryResult {
+        columns,
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        affected_rows: rows.len() as u64,
+        rows,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    }
+}
+
+fn normalize_row_object(value: Value) -> Map<String, Value> {
+    match value {
+        Value::Object(mut object) => {
+            if let Some(Value::Object(payload)) = object.remove("payload") {
+                for (key, value) in payload {
+                    object.entry(key).or_insert(value);
+                }
+            }
+            if let Some(Value::Object(properties)) = object.remove("properties") {
+                for (key, value) in properties {
+                    object.entry(key).or_insert(value);
+                }
+            }
+            object
+        }
+        other => {
+            let mut object = Map::new();
+            object.insert("value".to_string(), other);
+            object
+        }
+    }
+}
+
+fn format_reqwest_error(err: &reqwest::Error) -> String {
+    let mut parts = vec![err.to_string()];
+    let mut source = err.source();
+    while let Some(err) = source {
+        let text = err.to_string();
+        if !text.is_empty() && !parts.iter().any(|part| part == &text) {
+            parts.push(text);
+        }
+        source = err.source();
+    }
+    parts.join(": ")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        chroma_get_response_to_rows, starts_with_http_method, values_to_query_result, vector_auth,
+        weaviate_collection_names_from_schema, CollectionInfo, VectorAuth, VectorDbKind,
+    };
+    use serde_json::json;
+    use std::time::Instant;
+
+    #[test]
+    fn detects_rest_queries_case_insensitively() {
+        assert!(starts_with_http_method("post /collections/foo"));
+        assert!(starts_with_http_method("GET /collections"));
+        assert!(!starts_with_http_method("collection_name"));
+    }
+
+    #[test]
+    fn flattens_qdrant_payload_columns() {
+        let result =
+            values_to_query_result(vec![json!({"id": 1, "score": 0.9, "payload": {"title": "hello"}})], Instant::now());
+        assert!(result.columns.contains(&"id".to_string()));
+        assert!(result.columns.contains(&"score".to_string()));
+        assert!(result.columns.contains(&"title".to_string()));
+    }
+
+    #[test]
+    fn extracts_weaviate_schema_class_names() {
+        let names = weaviate_collection_names_from_schema(&json!({
+            "classes": [
+                { "class": "Article" },
+                { "class": "Product" }
+            ]
+        }));
+        assert_eq!(names, vec!["Article".to_string(), "Product".to_string()]);
+    }
+
+    #[test]
+    fn flattens_weaviate_properties_columns() {
+        let result = values_to_query_result(
+            vec![json!({"id": "abc", "class": "Article", "properties": {"title": "hello"}})],
+            Instant::now(),
+        );
+        assert!(result.columns.contains(&"id".to_string()));
+        assert!(result.columns.contains(&"class".to_string()));
+        assert!(result.columns.contains(&"title".to_string()));
+    }
+
+    #[test]
+    fn uses_bearer_auth_for_weaviate_tokens_even_with_username() {
+        assert_eq!(
+            vector_auth(VectorDbKind::Weaviate, Some("user"), Some("token")),
+            Some(VectorAuth::Bearer("token".to_string()))
+        );
+    }
+
+    #[test]
+    fn chroma_db_uses_x_chroma_token_header() {
+        assert_eq!(
+            vector_auth(VectorDbKind::ChromaDb, None, Some("my-key")),
+            Some(VectorAuth::ChromaToken("my-key".to_string()))
+        );
+    }
+
+    #[test]
+    fn chroma_db_no_auth_when_no_password() {
+        assert_eq!(vector_auth(VectorDbKind::ChromaDb, None, None), None);
+    }
+
+    #[test]
+    fn parses_chroma_collection_list() {
+        let body = json!([
+            {"id": "uuid-123", "name": "my_collection", "dimension": 384},
+            {"id": "uuid-456", "name": "other", "dimension": 768}
+        ]);
+        let infos: Vec<CollectionInfo> = body
+            .as_array()
+            .unwrap()
+            .iter()
+            .filter_map(|item| {
+                let name = item.get("name").and_then(|v| v.as_str())?;
+                let id = item.get("id").and_then(|v| v.as_str())?;
+                Some(CollectionInfo {
+                    name: name.to_string(),
+                    id: id.to_string(),
+                    dimension: None,
+                    kind: None,
+                    bucket_name: None,
+                })
+            })
+            .collect();
+        assert_eq!(infos.len(), 2);
+        assert_eq!(infos[0].name, "my_collection");
+        assert_eq!(infos[0].id, "uuid-123");
+        assert_eq!(infos[1].name, "other");
+        assert_eq!(infos[1].id, "uuid-456");
+    }
+
+    #[test]
+    fn converts_chroma_column_major_to_rows() {
+        let body = json!({
+            "ids": ["id1", "id2"],
+            "documents": ["hello world", "test doc"],
+            "metadatas": [{"source": "test"}, {"source": "demo"}]
+        });
+        let rows = chroma_get_response_to_rows(&body);
+        assert_eq!(rows.len(), 2);
+        assert_eq!(rows[0]["id"], json!("id1"));
+        assert_eq!(rows[0]["document"], json!("hello world"));
+        assert_eq!(rows[0]["source"], json!("test"));
+        assert_eq!(rows[1]["id"], json!("id2"));
+        assert_eq!(rows[1]["source"], json!("demo"));
+    }
+}
diff --git a/crates/dbx-core/src/db/wkb.rs b/crates/dbx-core/src/db/wkb.rs
new file mode 100644
index 0000000..41bc5d6
--- /dev/null
+++ b/crates/dbx-core/src/db/wkb.rs
@@ -0,0 +1,312 @@
+/// Shared WKB (Well-Known Binary) geometry parsing shared by PostgreSQL (EWKB)
+/// and MySQL (standard WKB). Parses WKB bytes into WKT (Well-Known Text) strings.
+///
+/// Supports: POINT, LINESTRING, POLYGON, MULTIPOINT, MULTILINESTRING,
+/// MULTIPOLYGON, GEOMETRYCOLLECTION, and their Z/M/ZM variants.
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct WkbDimensions {
+    has_z: bool,
+    has_m: bool,
+}
+
+impl WkbDimensions {
+    fn suffix(self) -> &'static str {
+        match (self.has_z, self.has_m) {
+            (false, false) => "",
+            (true, false) => " Z",
+            (false, true) => " M",
+            (true, true) => " ZM",
+        }
+    }
+
+    fn coordinate_len(self) -> usize {
+        2 + usize::from(self.has_z) + usize::from(self.has_m)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+enum WkbGeometry {
+    Point { dims: WkbDimensions, coords: Option<Vec<f64>> },
+    LineString { dims: WkbDimensions, points: Vec<Vec<f64>> },
+    Polygon { dims: WkbDimensions, rings: Vec<Vec<Vec<f64>>> },
+    MultiPoint { dims: WkbDimensions, points: Vec<Option<Vec<f64>>> },
+    MultiLineString { dims: WkbDimensions, lines: Vec<Vec<Vec<f64>>> },
+    MultiPolygon { dims: WkbDimensions, polygons: Vec<Vec<Vec<Vec<f64>>>> },
+    GeometryCollection { dims: WkbDimensions, geometries: Vec<WkbGeometry> },
+}
+
+impl WkbGeometry {
+    fn to_wkt(&self) -> String {
+        match self {
+            Self::Point { dims, coords } => match coords {
+                Some(coords) => format!("POINT{}({})", dims.suffix(), format_wkb_coordinate(coords)),
+                None => format!("POINT{} EMPTY", dims.suffix()),
+            },
+            Self::LineString { dims, points } => {
+                if points.is_empty() {
+                    format!("LINESTRING{} EMPTY", dims.suffix())
+                } else {
+                    format!("LINESTRING{}({})", dims.suffix(), format_wkb_coordinate_sequence(points))
+                }
+            }
+            Self::Polygon { dims, rings } => {
+                if rings.is_empty() {
+                    format!("POLYGON{} EMPTY", dims.suffix())
+                } else {
+                    format!(
+                        "POLYGON{}({})",
+                        dims.suffix(),
+                        rings
+                            .iter()
+                            .map(|ring| format!("({})", format_wkb_coordinate_sequence(ring)))
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    )
+                }
+            }
+            Self::MultiPoint { dims, points } => {
+                if points.is_empty() {
+                    format!("MULTIPOINT{} EMPTY", dims.suffix())
+                } else {
+                    format!(
+                        "MULTIPOINT{}({})",
+                        dims.suffix(),
+                        points
+                            .iter()
+                            .map(|point| match point {
+                                Some(coords) => format!("({})", format_wkb_coordinate(coords)),
+                                None => "EMPTY".to_string(),
+                            })
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    )
+                }
+            }
+            Self::MultiLineString { dims, lines } => {
+                if lines.is_empty() {
+                    format!("MULTILINESTRING{} EMPTY", dims.suffix())
+                } else {
+                    format!(
+                        "MULTILINESTRING{}({})",
+                        dims.suffix(),
+                        lines
+                            .iter()
+                            .map(|line| format!("({})", format_wkb_coordinate_sequence(line)))
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    )
+                }
+            }
+            Self::MultiPolygon { dims, polygons } => {
+                if polygons.is_empty() {
+                    format!("MULTIPOLYGON{} EMPTY", dims.suffix())
+                } else {
+                    format!(
+                        "MULTIPOLYGON{}({})",
+                        dims.suffix(),
+                        polygons
+                            .iter()
+                            .map(|polygon| {
+                                format!(
+                                    "({})",
+                                    polygon
+                                        .iter()
+                                        .map(|ring| format!("({})", format_wkb_coordinate_sequence(ring)))
+                                        .collect::<Vec<_>>()
+                                        .join(",")
+                                )
+                            })
+                            .collect::<Vec<_>>()
+                            .join(",")
+                    )
+                }
+            }
+            Self::GeometryCollection { dims, geometries } => {
+                if geometries.is_empty() {
+                    format!("GEOMETRYCOLLECTION{} EMPTY", dims.suffix())
+                } else {
+                    format!(
+                        "GEOMETRYCOLLECTION{}({})",
+                        dims.suffix(),
+                        geometries.iter().map(WkbGeometry::to_wkt).collect::<Vec<_>>().join(",")
+                    )
+                }
+            }
+        }
+    }
+}
+
+fn format_wkb_coordinate(coords: &[f64]) -> String {
+    coords.iter().map(|value| value.to_string()).collect::<Vec<_>>().join(" ")
+}
+
+fn format_wkb_coordinate_sequence(points: &[Vec<f64>]) -> String {
+    points.iter().map(|point| format_wkb_coordinate(point)).collect::<Vec<_>>().join(",")
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum WkbEndian {
+    Big,
+    Little,
+}
+
+struct WkbReader<'a> {
+    raw: &'a [u8],
+    pos: usize,
+}
+
+impl<'a> WkbReader<'a> {
+    fn new(raw: &'a [u8]) -> Self {
+        Self { raw, pos: 0 }
+    }
+
+    fn read_u8(&mut self) -> Option<u8> {
+        let value = *self.raw.get(self.pos)?;
+        self.pos += 1;
+        Some(value)
+    }
+
+    fn read_array<const N: usize>(&mut self) -> Option<[u8; N]> {
+        let end = self.pos.checked_add(N)?;
+        let bytes: [u8; N] = self.raw.get(self.pos..end)?.try_into().ok()?;
+        self.pos = end;
+        Some(bytes)
+    }
+
+    fn read_u32(&mut self, endian: WkbEndian) -> Option<u32> {
+        let bytes = self.read_array::<4>()?;
+        Some(match endian {
+            WkbEndian::Big => u32::from_be_bytes(bytes),
+            WkbEndian::Little => u32::from_le_bytes(bytes),
+        })
+    }
+
+    fn read_f64(&mut self, endian: WkbEndian) -> Option<f64> {
+        let bytes = self.read_array::<8>()?;
+        Some(match endian {
+            WkbEndian::Big => f64::from_be_bytes(bytes),
+            WkbEndian::Little => f64::from_le_bytes(bytes),
+        })
+    }
+}
+
+fn parse_wkb_dimensions(type_word: u32) -> (u32, WkbDimensions, bool) {
+    let mut base_type = type_word & 0x1FFF_FFFF;
+    let mut dims = WkbDimensions { has_z: (type_word & 0x8000_0000) != 0, has_m: (type_word & 0x4000_0000) != 0 };
+    let has_srid = (type_word & 0x2000_0000) != 0;
+
+    if base_type >= 3000 {
+        dims.has_z = true;
+        dims.has_m = true;
+        base_type -= 3000;
+    } else if base_type >= 2000 {
+        dims.has_m = true;
+        base_type -= 2000;
+    } else if base_type >= 1000 {
+        dims.has_z = true;
+        base_type -= 1000;
+    }
+
+    (base_type, dims, has_srid)
+}
+
+fn read_wkb_point_coords(reader: &mut WkbReader<'_>, dims: WkbDimensions, allow_empty_point: bool) -> Option<Vec<f64>> {
+    let endian = match reader.read_u8()? {
+        0 => WkbEndian::Big,
+        1 => WkbEndian::Little,
+        _ => return None,
+    };
+    let type_word = reader.read_u32(endian)?;
+    let (base_type, parsed_dims, has_srid) = parse_wkb_dimensions(type_word);
+    if base_type != 1 || parsed_dims != dims {
+        return None;
+    }
+    if has_srid {
+        reader.read_u32(endian)?;
+    }
+    let coords = (0..parsed_dims.coordinate_len()).map(|_| reader.read_f64(endian)).collect::<Option<Vec<_>>>()?;
+    if allow_empty_point && coords.iter().all(|value| value.is_nan()) {
+        return None;
+    }
+    Some(coords)
+}
+
+fn parse_wkb_points(reader: &mut WkbReader<'_>, endian: WkbEndian, dims: WkbDimensions) -> Option<Vec<Vec<f64>>> {
+    let count = usize::try_from(reader.read_u32(endian)?).ok()?;
+    (0..count)
+        .map(|_| (0..dims.coordinate_len()).map(|_| reader.read_f64(endian)).collect::<Option<Vec<_>>>())
+        .collect::<Option<Vec<_>>>()
+}
+
+fn parse_wkb_geometry(reader: &mut WkbReader<'_>) -> Option<WkbGeometry> {
+    let endian = match reader.read_u8()? {
+        0 => WkbEndian::Big,
+        1 => WkbEndian::Little,
+        _ => return None,
+    };
+    let type_word = reader.read_u32(endian)?;
+    let (base_type, dims, has_srid) = parse_wkb_dimensions(type_word);
+    if has_srid {
+        reader.read_u32(endian)?;
+    }
+
+    match base_type {
+        1 => {
+            let coords = (0..dims.coordinate_len()).map(|_| reader.read_f64(endian)).collect::<Option<Vec<_>>>()?;
+            let coords = if coords.iter().all(|value| value.is_nan()) { None } else { Some(coords) };
+            Some(WkbGeometry::Point { dims, coords })
+        }
+        2 => Some(WkbGeometry::LineString { dims, points: parse_wkb_points(reader, endian, dims)? }),
+        3 => {
+            let ring_count = usize::try_from(reader.read_u32(endian)?).ok()?;
+            let rings = (0..ring_count).map(|_| parse_wkb_points(reader, endian, dims)).collect::<Option<Vec<_>>>()?;
+            Some(WkbGeometry::Polygon { dims, rings })
+        }
+        4 => {
+            let count = usize::try_from(reader.read_u32(endian)?).ok()?;
+            let points =
+                (0..count).map(|_| Some(read_wkb_point_coords(reader, dims, true))).collect::<Option<Vec<_>>>()?;
+            Some(WkbGeometry::MultiPoint { dims, points })
+        }
+        5 => {
+            let count = usize::try_from(reader.read_u32(endian)?).ok()?;
+            let lines = (0..count)
+                .map(|_| match parse_wkb_geometry(reader)? {
+                    WkbGeometry::LineString { points, .. } => Some(points),
+                    _ => None,
+                })
+                .collect::<Option<Vec<_>>>()?;
+            Some(WkbGeometry::MultiLineString { dims, lines })
+        }
+        6 => {
+            let count = usize::try_from(reader.read_u32(endian)?).ok()?;
+            let polygons = (0..count)
+                .map(|_| match parse_wkb_geometry(reader)? {
+                    WkbGeometry::Polygon { rings, .. } => Some(rings),
+                    _ => None,
+                })
+                .collect::<Option<Vec<_>>>()?;
+            Some(WkbGeometry::MultiPolygon { dims, polygons })
+        }
+        7 => {
+            let count = usize::try_from(reader.read_u32(endian)?).ok()?;
+            let geometries = (0..count).map(|_| parse_wkb_geometry(reader)).collect::<Option<Vec<_>>>()?;
+            Some(WkbGeometry::GeometryCollection { dims, geometries })
+        }
+        _ => None,
+    }
+}
+
+/// Parse WKB/EWKB bytes into a WKT (Well-Known Text) string.
+///
+/// Supports both standard WKB (MySQL) and Extended WKB (PostgreSQL/PostGIS).
+/// Returns `None` if the bytes cannot be parsed as valid WKB.
+pub(crate) fn wkb_to_wkt(raw: &[u8]) -> Option<String> {
+    let mut reader = WkbReader::new(raw);
+    let geometry = parse_wkb_geometry(&mut reader)?;
+    if reader.pos != raw.len() {
+        return None;
+    }
+    Some(geometry.to_wkt())
+}
diff --git a/crates/dbx-core/src/db_admin_sql.rs b/crates/dbx-core/src/db_admin_sql.rs
new file mode 100644
index 0000000..f0d2249
--- /dev/null
+++ b/crates/dbx-core/src/db_admin_sql.rs
@@ -0,0 +1,1605 @@
+use serde::{Deserialize, Serialize};
+
+use crate::models::connection::DatabaseType;
+use crate::sql_dialect::{is_schema_aware, qualified_table_name, quote_table_identifier};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum DatabaseObjectType {
+    Table,
+    View,
+    MaterializedView,
+    Procedure,
+    Function,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum TableChildObjectType {
+    Column,
+    Index,
+    ForeignKey,
+    Trigger,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RenameObjectSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub object_type: DatabaseObjectType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub old_name: String,
+    pub new_name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CreateDatabaseSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub driver_profile: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target: Option<DatabaseCreationTarget>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub parent: Option<String>,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub charset: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collation: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum DatabaseCreationTarget {
+    Database,
+    Schema,
+    Catalog,
+    Namespace,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[cfg(feature = "duckdb-bundled")]
+pub struct DuckDbAttachDatabaseSqlOptions {
+    pub path: String,
+    pub name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DropObjectSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub object_type: DatabaseObjectType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableAdminSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub table_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cascade: Option<bool>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DropTableChildObjectSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub object_type: TableChildObjectType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub table_name: String,
+    pub name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DatabaseNameSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SchemaNameSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DatabasePropertyEditSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub driver_profile: Option<String>,
+    pub target: DatabasePropertyTarget,
+    pub name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub charset: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collation: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub comment: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum DatabasePropertyTarget {
+    Database,
+    Schema,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DuplicateTableStructureSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub source_name: String,
+    pub target_name: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CopyTableDataSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub source_name: String,
+    pub target_name: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub columns: Option<Vec<String>>,
+    #[serde(default)]
+    pub postgres_overriding_system_value: bool,
+    #[serde(default)]
+    pub sqlserver_identity_insert: bool,
+}
+
+const MYSQL_COMPATIBLE_PROFILES: &[&str] =
+    &["mysql", "mariadb", "tidb", "oceanbase", "doris", "starrocks", "custom_mysql"];
+
+pub fn supports_create_database_charset(database_type: Option<DatabaseType>, driver_profile: Option<&str>) -> bool {
+    let normalized_profile = driver_profile.map(str::to_ascii_lowercase);
+    matches!(
+        database_type,
+        Some(DatabaseType::Mysql | DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::Goldendb)
+    ) || normalized_profile.as_deref().is_some_and(|profile| MYSQL_COMPATIBLE_PROFILES.contains(&profile))
+}
+
+pub fn build_create_database_sql(options: CreateDatabaseSqlOptions) -> Result<String, String> {
+    match options.target.unwrap_or(DatabaseCreationTarget::Database) {
+        DatabaseCreationTarget::Database => build_create_database_statement(&options),
+        // Schema creation is exposed through the same frontend dialog contract when the tree target is a database node.
+        DatabaseCreationTarget::Schema => {
+            build_create_schema_sql(SchemaNameSqlOptions { database_type: options.database_type, name: options.name })
+        }
+        DatabaseCreationTarget::Catalog => Err("Creating catalogs is not supported yet.".to_string()),
+        DatabaseCreationTarget::Namespace => Err("Creating namespaces is not supported yet.".to_string()),
+    }
+}
+
+fn build_create_database_statement(options: &CreateDatabaseSqlOptions) -> Result<String, String> {
+    if !supports_create_database_target(options.database_type) {
+        return Err(format!("Creating databases is not supported for {}.", database_label(options.database_type)));
+    }
+    let name = quote_table_identifier(options.database_type, &options.name);
+    let charset = clean_sql_option(options.charset.as_deref());
+    let collation = clean_sql_option(options.collation.as_deref());
+    if !supports_create_database_charset(options.database_type, options.driver_profile.as_deref()) || charset.is_empty()
+    {
+        return Ok(format!("CREATE DATABASE {name};"));
+    }
+    let collate_clause = if collation.is_empty() { String::new() } else { format!(" COLLATE {collation}") };
+    Ok(format!("CREATE DATABASE {name} CHARACTER SET {charset}{collate_clause};"))
+}
+
+pub fn supports_create_database_target(database_type: Option<DatabaseType>) -> bool {
+    matches!(
+        database_type,
+        Some(
+            DatabaseType::Mysql
+                | DatabaseType::Doris
+                | DatabaseType::StarRocks
+                | DatabaseType::Goldendb
+                | DatabaseType::ClickHouse
+                | DatabaseType::SqlServer
+                | DatabaseType::InfluxDb
+                | DatabaseType::Databend
+                | DatabaseType::Snowflake
+                | DatabaseType::Tdengine
+                | DatabaseType::Postgres
+                | DatabaseType::Redshift
+                | DatabaseType::Gaussdb
+                | DatabaseType::Kwdb
+                | DatabaseType::OpenGauss
+                | DatabaseType::Vastbase
+                | DatabaseType::Highgo
+                | DatabaseType::Kingbase
+                | DatabaseType::Yashandb
+        )
+    )
+}
+
+pub fn supports_create_schema_target(database_type: Option<DatabaseType>) -> bool {
+    matches!(
+        database_type,
+        Some(
+            DatabaseType::Postgres
+                | DatabaseType::Redshift
+                | DatabaseType::SqlServer
+                | DatabaseType::Db2
+                | DatabaseType::Gaussdb
+                | DatabaseType::Kwdb
+                | DatabaseType::Kingbase
+                | DatabaseType::Highgo
+                | DatabaseType::Vastbase
+                | DatabaseType::Yashandb
+                | DatabaseType::Dameng
+                | DatabaseType::Databricks
+                | DatabaseType::SapHana
+                | DatabaseType::Teradata
+                | DatabaseType::Vertica
+                | DatabaseType::Exasol
+                | DatabaseType::OpenGauss
+                | DatabaseType::Gbase
+                | DatabaseType::Trino
+                | DatabaseType::PrestoSql
+                | DatabaseType::H2
+                | DatabaseType::Informix
+                | DatabaseType::Xugu
+                | DatabaseType::Oscar
+                | DatabaseType::Iris
+                | DatabaseType::Snowflake
+        )
+    )
+}
+
+pub fn supports_database_property_charset(database_type: Option<DatabaseType>, driver_profile: Option<&str>) -> bool {
+    supports_create_database_charset(database_type, driver_profile)
+        && matches!(database_type, Some(DatabaseType::Mysql | DatabaseType::Goldendb))
+}
+
+pub fn supports_database_property_comment(database_type: Option<DatabaseType>) -> bool {
+    matches!(
+        database_type,
+        Some(
+            DatabaseType::Postgres
+                | DatabaseType::Gaussdb
+                | DatabaseType::Kwdb
+                | DatabaseType::Kingbase
+                | DatabaseType::Highgo
+                | DatabaseType::Vastbase
+                | DatabaseType::OpenGauss
+                | DatabaseType::Yashandb
+        )
+    )
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn build_duckdb_attach_database_sql(options: DuckDbAttachDatabaseSqlOptions) -> String {
+    format!(
+        "ATTACH {} AS {};",
+        quote_sql_string(&options.path),
+        quote_table_identifier(Some(DatabaseType::DuckDb), &options.name)
+    )
+}
+
+pub fn build_create_user_sql(username: &str, password: &str, tablespace: &str) -> String {
+    format!(
+        "CREATE USER {} IDENTIFIED BY {} DEFAULT TABLESPACE {};",
+        quote_table_identifier(Some(DatabaseType::Dameng), username),
+        quote_sql_string(password),
+        quote_table_identifier(Some(DatabaseType::Dameng), tablespace)
+    )
+}
+
+pub fn build_drop_object_sql(options: DropObjectSqlOptions) -> String {
+    let signature = if matches!(options.database_type, Some(DatabaseType::Postgres))
+        && matches!(options.object_type, DatabaseObjectType::Function | DatabaseObjectType::Procedure)
+    {
+        options.signature.as_deref().map(|value| format!("({value})")).unwrap_or_default()
+    } else {
+        String::new()
+    };
+    format!(
+        "DROP {} {}{};",
+        object_type_keyword(options.object_type),
+        qualified_name(options.database_type, options.schema.as_deref(), &options.name),
+        signature
+    )
+}
+
+pub fn build_drop_table_sql(options: TableAdminSqlOptions) -> String {
+    let table = qualified_name(options.database_type, options.schema.as_deref(), &options.table_name);
+    if matches!(options.database_type, Some(DatabaseType::Iotdb)) {
+        return format!("DELETE TIMESERIES {};", iotdb_timeseries_pattern(&table));
+    } else if matches!(options.database_type, Some(DatabaseType::InfluxDb)) {
+        return format!("DROP MEASUREMENT {};", table);
+    }
+    // CASCADE is valid for PostgreSQL-family dialects; keep default RESTRICT behavior elsewhere.
+    let cascade = if options.cascade.unwrap_or(false) && supports_drop_table_cascade(options.database_type) {
+        " CASCADE"
+    } else {
+        ""
+    };
+    format!("DROP TABLE {table}{cascade};")
+}
+
+fn supports_drop_table_cascade(database_type: Option<DatabaseType>) -> bool {
+    matches!(
+        database_type,
+        Some(
+            DatabaseType::Postgres
+                | DatabaseType::Redshift
+                | DatabaseType::Gaussdb
+                | DatabaseType::Kwdb
+                | DatabaseType::Kingbase
+                | DatabaseType::Highgo
+                | DatabaseType::Vastbase
+                | DatabaseType::OpenGauss
+        )
+    )
+}
+
+pub fn build_drop_table_child_object_sql(options: DropTableChildObjectSqlOptions) -> Result<String, String> {
+    let database_type = options.database_type;
+    let table = qualified_name(database_type, options.schema.as_deref(), &options.table_name);
+    let name = quote_rename_identifier(database_type, &options.name);
+    match options.object_type {
+        TableChildObjectType::Column => Ok(format!("ALTER TABLE {table} DROP COLUMN {name};")),
+        TableChildObjectType::Index => {
+            if matches!(database_type, Some(DatabaseType::ClickHouse | DatabaseType::Redshift)) {
+                return Err(format!("Dropping indexes is not supported for {}.", database_label(database_type)));
+            }
+            if matches!(database_type, Some(DatabaseType::Mysql | DatabaseType::Goldendb | DatabaseType::SqlServer)) {
+                return Ok(format!("DROP INDEX {name} ON {table};"));
+            }
+            if matches!(
+                database_type,
+                Some(
+                    DatabaseType::Postgres
+                        | DatabaseType::Gaussdb
+                        | DatabaseType::Kwdb
+                        | DatabaseType::OpenGauss
+                        | DatabaseType::Questdb
+                        | DatabaseType::Highgo
+                        | DatabaseType::Vastbase
+                        | DatabaseType::Kingbase
+                        | DatabaseType::Oracle
+                        | DatabaseType::Dameng
+                        | DatabaseType::OceanbaseOracle
+                        | DatabaseType::Iris
+                )
+            ) && options.schema.as_deref().is_some_and(|schema| !schema.is_empty())
+            {
+                let schema = quote_rename_identifier(database_type, options.schema.as_deref().unwrap());
+                return Ok(format!("DROP INDEX {schema}.{name};"));
+            }
+            Ok(format!("DROP INDEX {name};"))
+        }
+        TableChildObjectType::ForeignKey => {
+            if matches!(database_type, Some(DatabaseType::Mysql | DatabaseType::Goldendb)) {
+                Ok(format!("ALTER TABLE {table} DROP FOREIGN KEY {name};"))
+            } else {
+                Ok(format!("ALTER TABLE {table} DROP CONSTRAINT {name};"))
+            }
+        }
+        TableChildObjectType::Trigger => {
+            if matches!(
+                database_type,
+                Some(
+                    DatabaseType::Postgres
+                        | DatabaseType::Gaussdb
+                        | DatabaseType::Kwdb
+                        | DatabaseType::OpenGauss
+                        | DatabaseType::Questdb
+                        | DatabaseType::Highgo
+                        | DatabaseType::Vastbase
+                        | DatabaseType::Kingbase
+                )
+            ) {
+                Ok(format!("DROP TRIGGER {name} ON {table};"))
+            } else if matches!(database_type, Some(DatabaseType::SqlServer)) {
+                Ok(format!("DROP TRIGGER {name};"))
+            } else if database_type.is_some_and(is_schema_aware)
+                && options.schema.as_deref().is_some_and(|schema| !schema.is_empty())
+                && !matches!(database_type, Some(DatabaseType::Mysql | DatabaseType::Goldendb))
+            {
+                let schema = quote_rename_identifier(database_type, options.schema.as_deref().unwrap());
+                Ok(format!("DROP TRIGGER {schema}.{name};"))
+            } else {
+                Ok(format!("DROP TRIGGER {name};"))
+            }
+        }
+    }
+}
+
+pub fn build_empty_table_sql(options: TableAdminSqlOptions) -> String {
+    let table = qualified_name(options.database_type, options.schema.as_deref(), &options.table_name);
+    match options.database_type {
+        Some(DatabaseType::ClickHouse) => format!("ALTER TABLE {table} DELETE WHERE 1 = 1;"),
+        Some(DatabaseType::Bigquery) => format!("DELETE FROM {table} WHERE TRUE;"),
+        Some(DatabaseType::Cassandra | DatabaseType::Hive | DatabaseType::Kylin | DatabaseType::Questdb) => {
+            format!("TRUNCATE TABLE {table};")
+        }
+        Some(DatabaseType::Iotdb) => format!("DELETE FROM {};", iotdb_timeseries_pattern(&table)),
+        _ => format!("DELETE FROM {table};"),
+    }
+}
+
+pub fn build_truncate_table_sql(options: TableAdminSqlOptions) -> String {
+    let table = qualified_name(options.database_type, options.schema.as_deref(), &options.table_name);
+    if matches!(options.database_type, Some(DatabaseType::Iotdb)) {
+        format!("DELETE FROM {};", iotdb_timeseries_pattern(&table))
+    } else if matches!(options.database_type, Some(DatabaseType::Sqlite | DatabaseType::DuckDb)) {
+        format!("DELETE FROM {table};")
+    } else {
+        // TRUNCATE CASCADE is PostgreSQL-family syntax; other dialects keep their existing default.
+        let cascade = if options.cascade.unwrap_or(false) && supports_truncate_table_cascade(options.database_type) {
+            " CASCADE"
+        } else {
+            ""
+        };
+        format!("TRUNCATE TABLE {table}{cascade};")
+    }
+}
+
+fn supports_truncate_table_cascade(database_type: Option<DatabaseType>) -> bool {
+    matches!(
+        database_type,
+        Some(
+            DatabaseType::Postgres
+                | DatabaseType::Gaussdb
+                | DatabaseType::Kwdb
+                | DatabaseType::Kingbase
+                | DatabaseType::Highgo
+                | DatabaseType::Vastbase
+                | DatabaseType::OpenGauss
+        )
+    )
+}
+
+pub fn build_drop_database_sql(options: DatabaseNameSqlOptions) -> String {
+    format!("DROP DATABASE {};", quote_table_identifier(options.database_type, &options.name))
+}
+
+pub fn build_update_database_properties_sql(options: DatabasePropertyEditSqlOptions) -> Result<String, String> {
+    match options.target {
+        DatabasePropertyTarget::Database => {
+            if options.comment.is_some() {
+                return build_database_comment_sql(options.database_type, &options.name, options.comment.as_deref());
+            }
+            build_database_charset_sql(&options)
+        }
+        DatabasePropertyTarget::Schema => {
+            build_schema_comment_sql(options.database_type, &options.name, options.comment.as_deref())
+        }
+    }
+}
+
+fn build_database_charset_sql(options: &DatabasePropertyEditSqlOptions) -> Result<String, String> {
+    if !supports_database_property_charset(options.database_type, options.driver_profile.as_deref()) {
+        return Err(format!(
+            "Editing database charset/collation is not supported for {}.",
+            database_label(options.database_type)
+        ));
+    }
+    let charset = clean_sql_option(options.charset.as_deref());
+    let collation = clean_sql_option(options.collation.as_deref());
+    if charset.is_empty() && collation.is_empty() {
+        return Err("At least one charset or collation value is required.".to_string());
+    }
+    let mut sql = format!("ALTER DATABASE {}", quote_table_identifier(options.database_type, &options.name));
+    if !charset.is_empty() {
+        sql.push_str(&format!(" DEFAULT CHARACTER SET {charset}"));
+    }
+    if !collation.is_empty() {
+        sql.push_str(&format!(" DEFAULT COLLATE {collation}"));
+    }
+    sql.push(';');
+    Ok(sql)
+}
+
+fn build_database_comment_sql(
+    database_type: Option<DatabaseType>,
+    name: &str,
+    comment: Option<&str>,
+) -> Result<String, String> {
+    if !supports_database_property_comment(database_type) {
+        return Err(format!("Editing database comments is not supported for {}.", database_label(database_type)));
+    }
+    Ok(format!("COMMENT ON DATABASE {} IS {};", quote_table_identifier(database_type, name), comment_literal(comment)))
+}
+
+fn build_schema_comment_sql(
+    database_type: Option<DatabaseType>,
+    name: &str,
+    comment: Option<&str>,
+) -> Result<String, String> {
+    if !supports_database_property_comment(database_type) {
+        return Err(format!("Editing schema comments is not supported for {}.", database_label(database_type)));
+    }
+    Ok(format!("COMMENT ON SCHEMA {} IS {};", quote_table_identifier(database_type, name), comment_literal(comment)))
+}
+
+pub fn build_create_schema_sql(options: SchemaNameSqlOptions) -> Result<String, String> {
+    if !supports_create_schema_target(options.database_type) {
+        return Err(format!("Creating schemas is not supported for {}.", database_label(options.database_type)));
+    }
+    Ok(format!("CREATE SCHEMA {};", quote_table_identifier(options.database_type, &options.name)))
+}
+
+pub fn build_drop_schema_sql(options: SchemaNameSqlOptions) -> String {
+    let schema = quote_table_identifier(options.database_type, &options.name);
+    if matches!(options.database_type, Some(DatabaseType::Postgres | DatabaseType::Gaussdb | DatabaseType::Kwdb)) {
+        format!("DROP SCHEMA {schema} CASCADE;")
+    } else {
+        format!("DROP SCHEMA {schema};")
+    }
+}
+
+pub fn build_duplicate_table_structure_sql(options: DuplicateTableStructureSqlOptions) -> String {
+    let source = qualified_name(options.database_type, options.schema.as_deref(), &options.source_name);
+    let target = qualified_name(options.database_type, options.schema.as_deref(), &options.target_name);
+    if options.database_type == Some(DatabaseType::Mysql) {
+        return format!("CREATE TABLE {target} LIKE {source};");
+    }
+    if options.database_type == Some(DatabaseType::Questdb) {
+        return format!("CREATE TABLE {target} (LIKE {source});");
+    }
+    if options.database_type.is_some_and(is_postgres_like_structure_copy) {
+        return format!("CREATE TABLE {target} (LIKE {source} INCLUDING ALL);");
+    }
+    if options.database_type == Some(DatabaseType::SqlServer) {
+        return format!("SELECT TOP 0 * INTO {target} FROM {source};");
+    }
+    if options.database_type.is_some_and(uses_false_predicate_duplicate_structure) {
+        return format!("CREATE TABLE {target} AS SELECT * FROM {source} WHERE 1=0");
+    }
+    format!("CREATE TABLE {target} AS SELECT * FROM {source} WHERE 0;")
+}
+
+pub fn build_copy_table_data_sql(options: CopyTableDataSqlOptions) -> String {
+    let source = qualified_name(options.database_type, options.schema.as_deref(), &options.source_name);
+    let target = qualified_name(options.database_type, options.schema.as_deref(), &options.target_name);
+    let Some(columns) = options.columns.filter(|columns| !columns.is_empty()) else {
+        return format!("INSERT INTO {target} SELECT * FROM {source};");
+    };
+    let column_list = columns
+        .iter()
+        .map(|column| quote_table_identifier(options.database_type, column))
+        .collect::<Vec<_>>()
+        .join(", ");
+    let postgres_override = if options.postgres_overriding_system_value
+        && matches!(options.database_type, Some(DatabaseType::Postgres | DatabaseType::Gaussdb | DatabaseType::Kwdb))
+    {
+        " OVERRIDING SYSTEM VALUE"
+    } else {
+        ""
+    };
+    let insert_sql =
+        format!("INSERT INTO {target} ({column_list}){postgres_override} SELECT {column_list} FROM {source};");
+    if options.sqlserver_identity_insert && options.database_type == Some(DatabaseType::SqlServer) {
+        return format!("SET IDENTITY_INSERT {target} ON;\n{insert_sql}\nSET IDENTITY_INSERT {target} OFF;");
+    }
+    insert_sql
+}
+
+pub fn supports_object_rename(database_type: Option<DatabaseType>, object_type: DatabaseObjectType) -> bool {
+    let Some(database_type) = database_type else {
+        return false;
+    };
+    if database_type == DatabaseType::SqlServer {
+        return true;
+    }
+    if matches!(object_type, DatabaseObjectType::Procedure | DatabaseObjectType::Function) {
+        return false;
+    }
+    if database_type == DatabaseType::Sqlite {
+        return object_type == DatabaseObjectType::Table;
+    }
+    if matches!(database_type, DatabaseType::Mysql | DatabaseType::Goldendb) {
+        return matches!(object_type, DatabaseObjectType::Table | DatabaseObjectType::View);
+    }
+    if is_postgres_like_rename(database_type) || is_oracle_like_rename(database_type) {
+        return matches!(
+            object_type,
+            DatabaseObjectType::Table | DatabaseObjectType::View | DatabaseObjectType::MaterializedView
+        );
+    }
+    false
+}
+
+pub fn build_rename_object_sql(options: RenameObjectSqlOptions) -> Result<String, String> {
+    let database_type = options.database_type;
+    if !supports_object_rename(database_type, options.object_type) {
+        return Err(format!(
+            "Renaming {} is not supported for {}.",
+            object_type_keyword(options.object_type),
+            database_label(database_type)
+        ));
+    }
+
+    if database_type == Some(DatabaseType::SqlServer) {
+        return Ok(format!(
+            "EXEC sp_rename {}, {}, N'OBJECT';",
+            sqlserver_string(&sqlserver_object_name(options.schema.as_deref(), &options.old_name)),
+            sqlserver_string(&options.new_name)
+        ));
+    }
+
+    if matches!(database_type, Some(DatabaseType::Mysql | DatabaseType::Goldendb)) {
+        return Ok(format!(
+            "RENAME TABLE {} TO {};",
+            qualified_name(database_type, options.schema.as_deref(), &options.old_name),
+            qualified_name(database_type, options.schema.as_deref(), &options.new_name)
+        ));
+    }
+
+    if database_type == Some(DatabaseType::Sqlite) {
+        return Ok(format!(
+            "ALTER TABLE {} RENAME TO {};",
+            qualified_name(database_type, options.schema.as_deref(), &options.old_name),
+            quote_rename_identifier(database_type, &options.new_name)
+        ));
+    }
+
+    if database_type
+        .is_some_and(|database_type| is_postgres_like_rename(database_type) || is_oracle_like_rename(database_type))
+    {
+        return Ok(format!(
+            "ALTER {} {} RENAME TO {};",
+            object_type_keyword(options.object_type),
+            qualified_name(database_type, options.schema.as_deref(), &options.old_name),
+            quote_rename_identifier(database_type, &options.new_name)
+        ));
+    }
+
+    Err(format!(
+        "Renaming {} is not supported for {}.",
+        object_type_keyword(options.object_type),
+        database_label(database_type)
+    ))
+}
+
+fn is_postgres_like_rename(database_type: DatabaseType) -> bool {
+    matches!(
+        database_type,
+        DatabaseType::Postgres
+            | DatabaseType::Redshift
+            | DatabaseType::Gaussdb
+            | DatabaseType::Kwdb
+            | DatabaseType::Kingbase
+            | DatabaseType::Highgo
+            | DatabaseType::Vastbase
+    )
+}
+
+fn is_oracle_like_rename(database_type: DatabaseType) -> bool {
+    matches!(database_type, DatabaseType::Oracle | DatabaseType::Dameng)
+}
+
+fn is_postgres_like_structure_copy(database_type: DatabaseType) -> bool {
+    matches!(
+        database_type,
+        DatabaseType::Postgres
+            | DatabaseType::Redshift
+            | DatabaseType::Gaussdb
+            | DatabaseType::Kwdb
+            | DatabaseType::OpenGauss
+            | DatabaseType::Questdb
+    )
+}
+
+fn uses_false_predicate_duplicate_structure(database_type: DatabaseType) -> bool {
+    matches!(database_type, DatabaseType::Oracle | DatabaseType::Dameng | DatabaseType::Iris)
+}
+
+fn sqlserver_string(value: &str) -> String {
+    format!("N'{}'", value.replace('\'', "''"))
+}
+
+fn quote_rename_identifier(database_type: Option<DatabaseType>, name: &str) -> String {
+    if matches!(database_type, Some(DatabaseType::Mysql | DatabaseType::Goldendb)) {
+        format!("`{}`", name.replace('`', "``"))
+    } else {
+        quote_table_identifier(database_type, name)
+    }
+}
+
+fn qualified_name(database_type: Option<DatabaseType>, schema: Option<&str>, name: &str) -> String {
+    if matches!(database_type, Some(DatabaseType::Iotdb)) {
+        return qualified_table_name(database_type, schema, name);
+    }
+    if database_type.is_some_and(is_schema_aware) && schema.is_some_and(|schema| !schema.is_empty()) {
+        format!(
+            "{}.{}",
+            quote_rename_identifier(database_type, schema.unwrap()),
+            quote_rename_identifier(database_type, name)
+        )
+    } else {
+        quote_rename_identifier(database_type, name)
+    }
+}
+
+fn iotdb_timeseries_pattern(path: &str) -> String {
+    let path = path.trim().trim_end_matches(';');
+    if path.ends_with(".*") || path.ends_with(".**") {
+        path.to_string()
+    } else {
+        format!("{path}.*")
+    }
+}
+
+fn sqlserver_object_name(schema: Option<&str>, name: &str) -> String {
+    schema
+        .filter(|schema| !schema.is_empty())
+        .map(|schema| format!("{schema}.{name}"))
+        .unwrap_or_else(|| name.to_string())
+}
+
+fn object_type_keyword(object_type: DatabaseObjectType) -> &'static str {
+    match object_type {
+        DatabaseObjectType::Table => "TABLE",
+        DatabaseObjectType::View => "VIEW",
+        DatabaseObjectType::MaterializedView => "MATERIALIZED VIEW",
+        DatabaseObjectType::Procedure => "PROCEDURE",
+        DatabaseObjectType::Function => "FUNCTION",
+    }
+}
+
+fn clean_sql_option(value: Option<&str>) -> String {
+    value.unwrap_or("").trim().replace([';', ' ', '\n', '\r', '\t'], "")
+}
+
+fn quote_sql_string(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+fn comment_literal(value: Option<&str>) -> String {
+    match value.map(str::trim).filter(|value| !value.is_empty()) {
+        Some(value) => quote_sql_string(value),
+        None => "NULL".to_string(),
+    }
+}
+
+fn database_label(database_type: Option<DatabaseType>) -> String {
+    database_type
+        .and_then(|database_type| serde_json::to_value(database_type).ok())
+        .and_then(|value| value.as_str().map(str::to_string))
+        .unwrap_or_else(|| "this database".to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn builds_mysql_create_database_sql_with_charset_and_collation() {
+        assert_eq!(
+            build_create_database_sql(CreateDatabaseSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                driver_profile: Some("mysql".to_string()),
+                target: None,
+                parent: None,
+                name: "app db".to_string(),
+                charset: Some("utf8mb4".to_string()),
+                collation: Some("utf8mb4_unicode_ci".to_string()),
+            })
+            .unwrap(),
+            "CREATE DATABASE `app db` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"
+        );
+    }
+
+    #[test]
+    fn builds_goldendb_create_database_sql_with_mysql_charset_options() {
+        assert_eq!(
+            build_create_database_sql(CreateDatabaseSqlOptions {
+                database_type: Some(DatabaseType::Goldendb),
+                driver_profile: Some("goldendb".to_string()),
+                target: None,
+                parent: None,
+                name: "app_db".to_string(),
+                charset: Some("utf8mb4".to_string()),
+                collation: Some("utf8mb4_unicode_ci".to_string()),
+            })
+            .unwrap(),
+            "CREATE DATABASE `app_db` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"
+        );
+    }
+
+    #[test]
+    fn omits_create_database_charset_for_non_mysql_types() {
+        assert_eq!(
+            build_create_database_sql(CreateDatabaseSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                driver_profile: None,
+                target: None,
+                parent: None,
+                name: "analytics".to_string(),
+                charset: Some("utf8mb4".to_string()),
+                collation: Some("utf8mb4_unicode_ci".to_string()),
+            })
+            .unwrap(),
+            "CREATE DATABASE \"analytics\";"
+        );
+    }
+
+    #[test]
+    fn builds_vastbase_create_database_sql_without_mysql_charset_options() {
+        assert_eq!(
+            build_create_database_sql(CreateDatabaseSqlOptions {
+                database_type: Some(DatabaseType::Vastbase),
+                driver_profile: Some("vastbase".to_string()),
+                target: None,
+                parent: None,
+                name: "app_db".to_string(),
+                charset: Some("utf8mb4".to_string()),
+                collation: Some("utf8mb4_unicode_ci".to_string()),
+            })
+            .unwrap(),
+            "CREATE DATABASE \"app_db\";"
+        );
+    }
+
+    #[test]
+    fn builds_additional_verified_create_database_targets() {
+        assert_eq!(
+            build_create_database_sql(CreateDatabaseSqlOptions {
+                database_type: Some(DatabaseType::SqlServer),
+                driver_profile: None,
+                target: None,
+                parent: None,
+                name: "analytics db".to_string(),
+                charset: None,
+                collation: None,
+            })
+            .unwrap(),
+            "CREATE DATABASE [analytics db];"
+        );
+        assert_eq!(
+            build_create_database_sql(CreateDatabaseSqlOptions {
+                database_type: Some(DatabaseType::Snowflake),
+                driver_profile: None,
+                target: None,
+                parent: None,
+                name: "analytics db".to_string(),
+                charset: None,
+                collation: None,
+            })
+            .unwrap(),
+            "CREATE DATABASE \"analytics db\";"
+        );
+        assert_eq!(
+            build_create_database_sql(CreateDatabaseSqlOptions {
+                database_type: Some(DatabaseType::Databend),
+                driver_profile: None,
+                target: None,
+                parent: None,
+                name: "analytics db".to_string(),
+                charset: None,
+                collation: None,
+            })
+            .unwrap(),
+            "CREATE DATABASE `analytics db`;"
+        );
+        assert_eq!(
+            build_create_database_sql(CreateDatabaseSqlOptions {
+                database_type: Some(DatabaseType::Tdengine),
+                driver_profile: None,
+                target: None,
+                parent: None,
+                name: "analytics db".to_string(),
+                charset: None,
+                collation: None,
+            })
+            .unwrap(),
+            "CREATE DATABASE `analytics db`;"
+        );
+    }
+
+    #[test]
+    fn rejects_unsupported_create_database_targets() {
+        assert!(build_create_database_sql(CreateDatabaseSqlOptions {
+            database_type: Some(DatabaseType::Oracle),
+            driver_profile: None,
+            target: None,
+            parent: None,
+            name: "analytics".to_string(),
+            charset: None,
+            collation: None,
+        })
+        .unwrap_err()
+        .contains("Creating databases is not supported"));
+        assert!(build_create_database_sql(CreateDatabaseSqlOptions {
+            database_type: Some(DatabaseType::Jdbc),
+            driver_profile: None,
+            target: None,
+            parent: None,
+            name: "analytics".to_string(),
+            charset: None,
+            collation: None,
+        })
+        .unwrap_err()
+        .contains("Creating databases is not supported"));
+    }
+
+    #[test]
+    fn builds_mysql_database_property_charset_sql() {
+        assert_eq!(
+            build_update_database_properties_sql(DatabasePropertyEditSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                driver_profile: Some("mysql".to_string()),
+                target: DatabasePropertyTarget::Database,
+                name: "app db".to_string(),
+                charset: Some("utf8mb4".to_string()),
+                collation: Some("utf8mb4_unicode_ci".to_string()),
+                comment: None,
+            })
+            .unwrap(),
+            "ALTER DATABASE `app db` DEFAULT CHARACTER SET utf8mb4 DEFAULT COLLATE utf8mb4_unicode_ci;"
+        );
+        assert_eq!(
+            build_update_database_properties_sql(DatabasePropertyEditSqlOptions {
+                database_type: Some(DatabaseType::Goldendb),
+                driver_profile: None,
+                target: DatabasePropertyTarget::Database,
+                name: "app".to_string(),
+                charset: Some("utf8mb4".to_string()),
+                collation: None,
+                comment: None,
+            })
+            .unwrap(),
+            "ALTER DATABASE `app` DEFAULT CHARACTER SET utf8mb4;"
+        );
+    }
+
+    #[test]
+    fn builds_postgres_style_database_and_schema_comment_sql() {
+        assert_eq!(
+            build_update_database_properties_sql(DatabasePropertyEditSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                driver_profile: None,
+                target: DatabasePropertyTarget::Database,
+                name: "app db".to_string(),
+                charset: None,
+                collation: None,
+                comment: Some("owner's app".to_string()),
+            })
+            .unwrap(),
+            "COMMENT ON DATABASE \"app db\" IS 'owner''s app';"
+        );
+        assert_eq!(
+            build_update_database_properties_sql(DatabasePropertyEditSqlOptions {
+                database_type: Some(DatabaseType::Kingbase),
+                driver_profile: None,
+                target: DatabasePropertyTarget::Schema,
+                name: "public".to_string(),
+                charset: None,
+                collation: None,
+                comment: Some("".to_string()),
+            })
+            .unwrap(),
+            "COMMENT ON SCHEMA \"public\" IS NULL;"
+        );
+    }
+
+    #[test]
+    fn rejects_unsupported_database_property_sql() {
+        assert!(build_update_database_properties_sql(DatabasePropertyEditSqlOptions {
+            database_type: Some(DatabaseType::SqlServer),
+            driver_profile: None,
+            target: DatabasePropertyTarget::Database,
+            name: "master".to_string(),
+            charset: Some("utf8mb4".to_string()),
+            collation: None,
+            comment: None,
+        })
+        .unwrap_err()
+        .contains("charset/collation is not supported"));
+        assert!(build_update_database_properties_sql(DatabasePropertyEditSqlOptions {
+            database_type: Some(DatabaseType::Mysql),
+            driver_profile: None,
+            target: DatabasePropertyTarget::Database,
+            name: "app".to_string(),
+            charset: None,
+            collation: None,
+            comment: Some("comment".to_string()),
+        })
+        .unwrap_err()
+        .contains("database comments is not supported"));
+        assert!(build_update_database_properties_sql(DatabasePropertyEditSqlOptions {
+            database_type: Some(DatabaseType::DuckDb),
+            driver_profile: None,
+            target: DatabasePropertyTarget::Schema,
+            name: "main".to_string(),
+            charset: None,
+            collation: None,
+            comment: Some("comment".to_string()),
+        })
+        .unwrap_err()
+        .contains("schema comments is not supported"));
+    }
+
+    #[test]
+    fn recognizes_mysql_compatible_create_database_profiles() {
+        assert!(supports_create_database_charset(Some(DatabaseType::Mysql), Some("oceanbase")));
+        assert!(supports_create_database_charset(Some(DatabaseType::Mysql), Some("doris")));
+        assert!(supports_create_database_charset(Some(DatabaseType::Goldendb), Some("goldendb")));
+        assert!(!supports_create_database_charset(Some(DatabaseType::Postgres), None));
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn builds_duckdb_attach_sql() {
+        assert_eq!(
+            build_duckdb_attach_database_sql(DuckDbAttachDatabaseSqlOptions {
+                path: "/Users/me/O'Reilly analytics.duckdb".to_string(),
+                name: "report db".to_string(),
+            }),
+            "ATTACH '/Users/me/O''Reilly analytics.duckdb' AS \"report db\";"
+        );
+    }
+
+    #[test]
+    fn builds_dameng_create_user_sql_with_escaped_values() {
+        assert_eq!(
+            build_create_user_sql("app\"user", "pa'ss", "main\"space"),
+            "CREATE USER \"app\"\"user\" IDENTIFIED BY 'pa''ss' DEFAULT TABLESPACE \"main\"\"space\";"
+        );
+    }
+
+    #[test]
+    fn builds_drop_and_clear_table_sql() {
+        let options = TableAdminSqlOptions {
+            database_type: Some(DatabaseType::Postgres),
+            schema: Some("public".to_string()),
+            table_name: "events".to_string(),
+            cascade: None,
+        };
+        assert_eq!(build_drop_table_sql(options.clone()), "DROP TABLE \"public\".\"events\";");
+        assert_eq!(
+            build_drop_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                schema: Some("public".to_string()),
+                table_name: "events".to_string(),
+                cascade: Some(true),
+            }),
+            "DROP TABLE \"public\".\"events\" CASCADE;"
+        );
+        assert_eq!(
+            build_drop_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                schema: None,
+                table_name: "events".to_string(),
+                cascade: Some(true),
+            }),
+            "DROP TABLE `events`;"
+        );
+        assert_eq!(build_empty_table_sql(options.clone()), "DELETE FROM \"public\".\"events\";");
+        assert_eq!(build_truncate_table_sql(options.clone()), "TRUNCATE TABLE \"public\".\"events\";");
+        assert_eq!(
+            build_truncate_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                schema: Some("public".to_string()),
+                table_name: "events".to_string(),
+                cascade: Some(true),
+            }),
+            "TRUNCATE TABLE \"public\".\"events\" CASCADE;"
+        );
+        assert_eq!(
+            build_truncate_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                schema: None,
+                table_name: "events".to_string(),
+                cascade: Some(true),
+            }),
+            "TRUNCATE TABLE `events`;"
+        );
+        assert_eq!(
+            build_empty_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::ClickHouse),
+                schema: None,
+                table_name: "PresetSubjectInfo".to_string(),
+                cascade: None,
+            }),
+            "ALTER TABLE `PresetSubjectInfo` DELETE WHERE 1 = 1;"
+        );
+        assert_eq!(
+            build_truncate_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::ClickHouse),
+                schema: None,
+                table_name: "PresetSubjectInfo".to_string(),
+                cascade: None,
+            }),
+            "TRUNCATE TABLE `PresetSubjectInfo`;"
+        );
+        assert_eq!(
+            build_empty_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::Bigquery),
+                schema: None,
+                table_name: "events".to_string(),
+                cascade: None,
+            }),
+            "DELETE FROM `events` WHERE TRUE;"
+        );
+        assert_eq!(
+            build_empty_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::Cassandra),
+                schema: None,
+                table_name: "events".to_string(),
+                cascade: None,
+            }),
+            "TRUNCATE TABLE \"events\";"
+        );
+        assert_eq!(
+            build_truncate_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::DuckDb),
+                schema: None,
+                table_name: "events".to_string(),
+                cascade: None,
+            }),
+            "DELETE FROM \"events\";"
+        );
+        assert_eq!(
+            build_drop_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::Iotdb),
+                schema: Some("root.test".to_string()),
+                table_name: "DCU_101".to_string(),
+                cascade: None,
+            }),
+            "DELETE TIMESERIES root.test.DCU_101.*;"
+        );
+        assert_eq!(
+            build_empty_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::Iotdb),
+                schema: Some("root.test".to_string()),
+                table_name: "root.test.DCU_101".to_string(),
+                cascade: None,
+            }),
+            "DELETE FROM root.test.DCU_101.*;"
+        );
+        assert_eq!(
+            build_truncate_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::Iotdb),
+                schema: Some("root.test".to_string()),
+                table_name: "DCU_101".to_string(),
+                cascade: None,
+            }),
+            "DELETE FROM root.test.DCU_101.*;"
+        );
+
+        assert_eq!(
+            build_empty_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::Questdb),
+                schema: None,
+                table_name: "table_sample".to_string(),
+                cascade: None,
+            }),
+            "TRUNCATE TABLE `table_sample`;"
+        );
+        assert_eq!(
+            build_truncate_table_sql(TableAdminSqlOptions {
+                database_type: Some(DatabaseType::Questdb),
+                schema: None,
+                table_name: "table_sample".to_string(),
+                cascade: None,
+            }),
+            "TRUNCATE TABLE `table_sample`;"
+        );
+    }
+
+    #[test]
+    fn builds_drop_object_database_and_schema_sql() {
+        assert_eq!(
+            build_drop_object_sql(DropObjectSqlOptions {
+                database_type: Some(DatabaseType::SqlServer),
+                object_type: DatabaseObjectType::Procedure,
+                schema: Some("dbo".to_string()),
+                name: "refresh_cache".to_string(),
+                signature: None,
+            }),
+            "DROP PROCEDURE [dbo].[refresh_cache];"
+        );
+        assert_eq!(
+            build_drop_object_sql(DropObjectSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                object_type: DatabaseObjectType::Function,
+                schema: Some("public".to_string()),
+                name: "calc".to_string(),
+                signature: Some("integer, integer".to_string()),
+            }),
+            "DROP FUNCTION \"public\".\"calc\"(integer, integer);"
+        );
+        assert_eq!(
+            build_drop_database_sql(DatabaseNameSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                name: "app db".to_string(),
+            }),
+            "DROP DATABASE `app db`;"
+        );
+        assert_eq!(
+            build_create_schema_sql(SchemaNameSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                name: "analytics".to_string(),
+            })
+            .unwrap(),
+            "CREATE SCHEMA \"analytics\";"
+        );
+        assert_eq!(
+            build_create_schema_sql(SchemaNameSqlOptions {
+                database_type: Some(DatabaseType::SqlServer),
+                name: "analytics".to_string(),
+            })
+            .unwrap(),
+            "CREATE SCHEMA [analytics];"
+        );
+        assert_eq!(
+            build_create_schema_sql(SchemaNameSqlOptions {
+                database_type: Some(DatabaseType::Dameng),
+                name: "analytics".to_string(),
+            })
+            .unwrap(),
+            "CREATE SCHEMA \"analytics\";"
+        );
+        assert_eq!(
+            build_create_schema_sql(SchemaNameSqlOptions {
+                database_type: Some(DatabaseType::Db2),
+                name: "analytics".to_string(),
+            })
+            .unwrap(),
+            "CREATE SCHEMA \"analytics\";"
+        );
+        assert!(build_create_schema_sql(SchemaNameSqlOptions {
+            database_type: Some(DatabaseType::DuckDb),
+            name: "analytics".to_string(),
+        })
+        .unwrap_err()
+        .contains("Creating schemas is not supported"));
+        assert_eq!(
+            build_drop_schema_sql(SchemaNameSqlOptions {
+                database_type: Some(DatabaseType::Kwdb),
+                name: "analytics".to_string(),
+            }),
+            "DROP SCHEMA \"analytics\" CASCADE;"
+        );
+    }
+
+    #[test]
+    fn builds_drop_table_child_object_sql() {
+        assert_eq!(
+            build_drop_table_child_object_sql(DropTableChildObjectSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                object_type: TableChildObjectType::Column,
+                schema: Some("public".to_string()),
+                table_name: "orders".to_string(),
+                name: "status".to_string(),
+            })
+            .unwrap(),
+            "ALTER TABLE \"public\".\"orders\" DROP COLUMN \"status\";"
+        );
+        assert_eq!(
+            build_drop_table_child_object_sql(DropTableChildObjectSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                object_type: TableChildObjectType::Index,
+                schema: None,
+                table_name: "orders".to_string(),
+                name: "idx_orders_status".to_string(),
+            })
+            .unwrap(),
+            "DROP INDEX `idx_orders_status` ON `orders`;"
+        );
+        assert_eq!(
+            build_drop_table_child_object_sql(DropTableChildObjectSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                object_type: TableChildObjectType::Index,
+                schema: Some("public".to_string()),
+                table_name: "orders".to_string(),
+                name: "idx_orders_status".to_string(),
+            })
+            .unwrap(),
+            "DROP INDEX \"public\".\"idx_orders_status\";"
+        );
+        assert_eq!(
+            build_drop_table_child_object_sql(DropTableChildObjectSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                object_type: TableChildObjectType::ForeignKey,
+                schema: None,
+                table_name: "orders".to_string(),
+                name: "fk_orders_user".to_string(),
+            })
+            .unwrap(),
+            "ALTER TABLE `orders` DROP FOREIGN KEY `fk_orders_user`;"
+        );
+        assert_eq!(
+            build_drop_table_child_object_sql(DropTableChildObjectSqlOptions {
+                database_type: Some(DatabaseType::SqlServer),
+                object_type: TableChildObjectType::ForeignKey,
+                schema: Some("dbo".to_string()),
+                table_name: "orders".to_string(),
+                name: "fk_orders_user".to_string(),
+            })
+            .unwrap(),
+            "ALTER TABLE [dbo].[orders] DROP CONSTRAINT [fk_orders_user];"
+        );
+        assert_eq!(
+            build_drop_table_child_object_sql(DropTableChildObjectSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                object_type: TableChildObjectType::Trigger,
+                schema: Some("public".to_string()),
+                table_name: "orders".to_string(),
+                name: "orders_audit".to_string(),
+            })
+            .unwrap(),
+            "DROP TRIGGER \"orders_audit\" ON \"public\".\"orders\";"
+        );
+
+        assert_eq!(
+            build_drop_table_child_object_sql(DropTableChildObjectSqlOptions {
+                database_type: Some(DatabaseType::Questdb),
+                object_type: TableChildObjectType::Column,
+                schema: Some("public".to_string()),
+                table_name: "orders".to_string(),
+                name: "status".to_string(),
+            })
+            .unwrap(),
+            "ALTER TABLE `orders` DROP COLUMN `status`;"
+        );
+    }
+
+    #[test]
+    fn builds_duplicate_table_structure_sql() {
+        assert_eq!(
+            build_duplicate_table_structure_sql(DuplicateTableStructureSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                schema: None,
+                source_name: "users".to_string(),
+                target_name: "users_copy".to_string(),
+            }),
+            "CREATE TABLE `users_copy` LIKE `users`;"
+        );
+        assert_eq!(
+            build_duplicate_table_structure_sql(DuplicateTableStructureSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                schema: Some("public".to_string()),
+                source_name: "users".to_string(),
+                target_name: "users_copy".to_string(),
+            }),
+            "CREATE TABLE \"public\".\"users_copy\" (LIKE \"public\".\"users\" INCLUDING ALL);"
+        );
+        assert_eq!(
+            build_duplicate_table_structure_sql(DuplicateTableStructureSqlOptions {
+                database_type: Some(DatabaseType::Kwdb),
+                schema: Some("public".to_string()),
+                source_name: "users".to_string(),
+                target_name: "users_copy".to_string(),
+            }),
+            "CREATE TABLE \"public\".\"users_copy\" (LIKE \"public\".\"users\" INCLUDING ALL);"
+        );
+        assert_eq!(
+            build_duplicate_table_structure_sql(DuplicateTableStructureSqlOptions {
+                database_type: Some(DatabaseType::SqlServer),
+                schema: Some("dbo".to_string()),
+                source_name: "users".to_string(),
+                target_name: "users_copy".to_string(),
+            }),
+            "SELECT TOP 0 * INTO [dbo].[users_copy] FROM [dbo].[users];"
+        );
+        assert_eq!(
+            build_duplicate_table_structure_sql(DuplicateTableStructureSqlOptions {
+                database_type: Some(DatabaseType::Oracle),
+                schema: Some("HR".to_string()),
+                source_name: "USERS".to_string(),
+                target_name: "USERS_COPY".to_string(),
+            }),
+            "CREATE TABLE \"HR\".\"USERS_COPY\" AS SELECT * FROM \"HR\".\"USERS\" WHERE 1=0"
+        );
+        assert_eq!(
+            build_duplicate_table_structure_sql(DuplicateTableStructureSqlOptions {
+                database_type: Some(DatabaseType::Iris),
+                schema: Some("SQLUSER".to_string()),
+                source_name: "tb_a".to_string(),
+                target_name: "tb_a_copy".to_string(),
+            }),
+            "CREATE TABLE \"SQLUSER\".\"tb_a_copy\" AS SELECT * FROM \"SQLUSER\".\"tb_a\" WHERE 1=0"
+        );
+        assert_eq!(
+            build_duplicate_table_structure_sql(DuplicateTableStructureSqlOptions {
+                database_type: Some(DatabaseType::Questdb),
+                schema: None,
+                source_name: "users".to_string(),
+                target_name: "users_copy".to_string(),
+            }),
+            "CREATE TABLE `users_copy` (LIKE `users`);"
+        );
+    }
+
+    #[test]
+    fn builds_copy_table_data_sql() {
+        assert_eq!(
+            build_copy_table_data_sql(CopyTableDataSqlOptions {
+                database_type: Some(DatabaseType::Sqlite),
+                schema: None,
+                source_name: "users".to_string(),
+                target_name: "users_copy".to_string(),
+                columns: None,
+                postgres_overriding_system_value: false,
+                sqlserver_identity_insert: false,
+            }),
+            "INSERT INTO \"users_copy\" SELECT * FROM \"users\";"
+        );
+        assert_eq!(
+            build_copy_table_data_sql(CopyTableDataSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                schema: None,
+                source_name: "users".to_string(),
+                target_name: "users_copy".to_string(),
+                columns: Some(vec!["id".to_string(), "name".to_string()]),
+                postgres_overriding_system_value: false,
+                sqlserver_identity_insert: false,
+            }),
+            "INSERT INTO `users_copy` (`id`, `name`) SELECT `id`, `name` FROM `users`;"
+        );
+        assert_eq!(
+            build_copy_table_data_sql(CopyTableDataSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                schema: Some("public".to_string()),
+                source_name: "users".to_string(),
+                target_name: "users_copy".to_string(),
+                columns: Some(vec!["id".to_string(), "name".to_string()]),
+                postgres_overriding_system_value: true,
+                sqlserver_identity_insert: false,
+            }),
+            "INSERT INTO \"public\".\"users_copy\" (\"id\", \"name\") OVERRIDING SYSTEM VALUE SELECT \"id\", \"name\" FROM \"public\".\"users\";"
+        );
+        assert_eq!(
+            build_copy_table_data_sql(CopyTableDataSqlOptions {
+                database_type: Some(DatabaseType::SqlServer),
+                schema: Some("dbo".to_string()),
+                source_name: "users".to_string(),
+                target_name: "users_copy".to_string(),
+                columns: Some(vec!["id".to_string(), "name".to_string()]),
+                postgres_overriding_system_value: false,
+                sqlserver_identity_insert: true,
+            }),
+            "SET IDENTITY_INSERT [dbo].[users_copy] ON;\nINSERT INTO [dbo].[users_copy] ([id], [name]) SELECT [id], [name] FROM [dbo].[users];\nSET IDENTITY_INSERT [dbo].[users_copy] OFF;"
+        );
+    }
+
+    #[test]
+    fn builds_mysql_table_and_view_rename_sql() {
+        assert_eq!(
+            build_rename_object_sql(RenameObjectSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                object_type: DatabaseObjectType::Table,
+                schema: None,
+                old_name: "users".to_string(),
+                new_name: "app users".to_string(),
+            })
+            .unwrap(),
+            "RENAME TABLE `users` TO `app users`;"
+        );
+        assert_eq!(
+            build_rename_object_sql(RenameObjectSqlOptions {
+                database_type: Some(DatabaseType::Goldendb),
+                object_type: DatabaseObjectType::View,
+                schema: None,
+                old_name: "active_users".to_string(),
+                new_name: "enabled_users".to_string(),
+            })
+            .unwrap(),
+            "RENAME TABLE `active_users` TO `enabled_users`;"
+        );
+    }
+
+    #[test]
+    fn builds_postgres_table_and_view_rename_sql() {
+        assert_eq!(
+            build_rename_object_sql(RenameObjectSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                object_type: DatabaseObjectType::Table,
+                schema: Some("public".to_string()),
+                old_name: "orders".to_string(),
+                new_name: "archived orders".to_string(),
+            })
+            .unwrap(),
+            "ALTER TABLE \"public\".\"orders\" RENAME TO \"archived orders\";"
+        );
+        assert_eq!(
+            build_rename_object_sql(RenameObjectSqlOptions {
+                database_type: Some(DatabaseType::Postgres),
+                object_type: DatabaseObjectType::View,
+                schema: Some("public".to_string()),
+                old_name: "active_users".to_string(),
+                new_name: "enabled_users".to_string(),
+            })
+            .unwrap(),
+            "ALTER VIEW \"public\".\"active_users\" RENAME TO \"enabled_users\";"
+        );
+    }
+
+    #[test]
+    fn builds_sqlserver_routine_rename_sql() {
+        assert_eq!(
+            build_rename_object_sql(RenameObjectSqlOptions {
+                database_type: Some(DatabaseType::SqlServer),
+                object_type: DatabaseObjectType::Function,
+                schema: Some("dbo".to_string()),
+                old_name: "fn_total".to_string(),
+                new_name: "fn_order_total".to_string(),
+            })
+            .unwrap(),
+            "EXEC sp_rename N'dbo.fn_total', N'fn_order_total', N'OBJECT';"
+        );
+        assert!(supports_object_rename(Some(DatabaseType::SqlServer), DatabaseObjectType::Procedure));
+    }
+
+    #[test]
+    fn builds_oracle_family_table_and_view_rename_sql() {
+        assert_eq!(
+            build_rename_object_sql(RenameObjectSqlOptions {
+                database_type: Some(DatabaseType::Oracle),
+                object_type: DatabaseObjectType::Table,
+                schema: Some("HR".to_string()),
+                old_name: "EMPLOYEES".to_string(),
+                new_name: "STAFF".to_string(),
+            })
+            .unwrap(),
+            "ALTER TABLE \"HR\".\"EMPLOYEES\" RENAME TO \"STAFF\";"
+        );
+        assert_eq!(
+            build_rename_object_sql(RenameObjectSqlOptions {
+                database_type: Some(DatabaseType::Dameng),
+                object_type: DatabaseObjectType::View,
+                schema: Some("SYSDBA".to_string()),
+                old_name: "ACTIVE_USERS".to_string(),
+                new_name: "ENABLED_USERS".to_string(),
+            })
+            .unwrap(),
+            "ALTER VIEW \"SYSDBA\".\"ACTIVE_USERS\" RENAME TO \"ENABLED_USERS\";"
+        );
+    }
+
+    #[test]
+    fn rejects_unsupported_direct_routine_renames() {
+        assert!(!supports_object_rename(Some(DatabaseType::Oracle), DatabaseObjectType::Function));
+        assert!(!supports_object_rename(Some(DatabaseType::Dameng), DatabaseObjectType::Procedure));
+        assert!(build_rename_object_sql(RenameObjectSqlOptions {
+            database_type: Some(DatabaseType::Dameng),
+            object_type: DatabaseObjectType::Procedure,
+            schema: Some("SYSDBA".to_string()),
+            old_name: "REFRESH_CACHE".to_string(),
+            new_name: "REFRESH_CACHE_V2".to_string(),
+        })
+        .unwrap_err()
+        .contains("Renaming PROCEDURE is not supported"));
+        assert!(build_rename_object_sql(RenameObjectSqlOptions {
+            database_type: Some(DatabaseType::Mysql),
+            object_type: DatabaseObjectType::Procedure,
+            schema: None,
+            old_name: "refresh_cache".to_string(),
+            new_name: "refresh_cache_v2".to_string(),
+        })
+        .unwrap_err()
+        .contains("Renaming PROCEDURE is not supported"));
+    }
+}
diff --git a/crates/dbx-core/src/document_ops.rs b/crates/dbx-core/src/document_ops.rs
new file mode 100644
index 0000000..427ab58
--- /dev/null
+++ b/crates/dbx-core/src/document_ops.rs
@@ -0,0 +1,592 @@
+use crate::connection::{AppState, PoolKind};
+use crate::db::agent_driver::mongo_document_id_params;
+use crate::db::mongo_driver::MongoDocumentResult;
+use crate::db::{elasticsearch_driver, mongo_driver, vector_driver};
+
+pub use crate::db::vector_driver::CollectionInfo;
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoGridFsFileInfo {
+    pub id: String,
+    pub filename: Option<String>,
+    pub length: i64,
+    pub chunk_size: i32,
+    pub upload_date: Option<String>,
+    pub metadata: Option<serde_json::Value>,
+    pub md5: Option<String>,
+    pub content_type: Option<String>,
+    pub aliases: Option<Vec<String>>,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoGridFsBucketInfo {
+    pub name: String,
+    pub file_count: u64,
+    pub total_bytes: i64,
+}
+
+fn sort_names(mut names: Vec<String>) -> Vec<String> {
+    names.sort_by(|left, right| {
+        let left_lower = left.to_lowercase();
+        let right_lower = right.to_lowercase();
+        left_lower.cmp(&right_lower).then_with(|| left.cmp(right))
+    });
+    names
+}
+
+async fn ensure_document_pool(state: &AppState, connection_id: &str) -> Result<(), String> {
+    state.get_or_create_pool(connection_id, None).await.map(|_| ())
+}
+
+pub async fn list_databases_core(state: &AppState, connection_id: &str) -> Result<Vec<String>, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let fallback_database = configured_mongo_database(state, connection_id).await;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => match mongo_driver::list_databases(client).await {
+            Ok(databases) => Ok(sort_names(databases)),
+            Err(error) if mongo_list_databases_unauthorized(&error) => {
+                fallback_mongo_database(&error, fallback_database)
+            }
+            Err(error) => Err(error),
+        },
+        PoolKind::Elasticsearch(_) => Ok(vec!["default".to_string()]),
+        PoolKind::VectorDb(client) => vector_driver::list_databases(&client).await,
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            match client.mongo_list_databases::<Vec<serde_json::Value>>().await {
+                Ok(result) => {
+                    Ok(sort_names(result.iter().filter_map(|v| v.get("name")?.as_str().map(String::from)).collect()))
+                }
+                Err(error) if mongo_list_databases_unauthorized(&error) => {
+                    fallback_mongo_database(&error, fallback_database)
+                }
+                Err(error) => Err(error),
+            }
+        }
+        _ => Err("Not a MongoDB/Elasticsearch/vector connection".to_string()),
+    }
+}
+
+async fn configured_mongo_database(state: &AppState, connection_id: &str) -> Option<String> {
+    let configs = state.configs.read().await;
+    configs.get(connection_id).and_then(|config| config.effective_database().map(str::to_string))
+}
+
+fn fallback_mongo_database(error: &str, fallback_database: Option<String>) -> Result<Vec<String>, String> {
+    fallback_database.map(|database| vec![database]).ok_or_else(|| error.to_string())
+}
+
+fn mongo_list_databases_unauthorized(error: &str) -> bool {
+    let lower = error.to_lowercase();
+    lower.contains("not authorized") && lower.contains("listdatabases")
+}
+
+fn mongo_collection_info(name: String) -> CollectionInfo {
+    CollectionInfo {
+        name: name.clone(),
+        id: name,
+        dimension: None,
+        kind: Some("collection".to_string()),
+        bucket_name: None,
+    }
+}
+
+pub(crate) fn mongo_gridfs_bucket_names(names: &[String]) -> Vec<String> {
+    use std::collections::BTreeSet;
+
+    let name_set: BTreeSet<&str> = names.iter().map(String::as_str).collect();
+    let bucket_names: Vec<String> = names
+        .iter()
+        .filter_map(|name| name.strip_suffix(".files"))
+        .filter(|prefix| name_set.contains(format!("{prefix}.chunks").as_str()))
+        .map(str::to_string)
+        .collect::<BTreeSet<_>>()
+        .into_iter()
+        .collect();
+
+    sort_names(bucket_names)
+}
+
+fn mongo_bucket_infos(names: &[String]) -> Vec<CollectionInfo> {
+    mongo_gridfs_bucket_names(names)
+        .into_iter()
+        .map(|bucket_name| CollectionInfo {
+            name: bucket_name.clone(),
+            id: format!("bucket:{bucket_name}"),
+            dimension: None,
+            kind: Some("bucket".to_string()),
+            bucket_name: Some(bucket_name),
+        })
+        .collect()
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum GridFsBucketSortField {
+    Name,
+    FileCount,
+    TotalBytes,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct GridFsBucketSort {
+    field: GridFsBucketSortField,
+    descending: bool,
+}
+
+fn parse_gridfs_bucket_sort(sort: Option<&str>) -> Result<GridFsBucketSort, String> {
+    let Some(raw) = sort.map(str::trim).filter(|value| !value.is_empty()) else {
+        return Ok(GridFsBucketSort { field: GridFsBucketSortField::Name, descending: false });
+    };
+
+    let value: serde_json::Value =
+        serde_json::from_str(raw).map_err(|e| format!("Invalid GridFS bucket sort JSON: {e}"))?;
+    let object = value.as_object().ok_or_else(|| "GridFS bucket sort must be a JSON object".to_string())?;
+    if object.len() != 1 {
+        return Err("GridFS bucket sort must contain exactly one field".to_string());
+    }
+
+    let (field_name, direction) = object.iter().next().expect("checked len");
+    let field = match field_name.as_str() {
+        "name" => GridFsBucketSortField::Name,
+        "fileCount" => GridFsBucketSortField::FileCount,
+        "totalBytes" => GridFsBucketSortField::TotalBytes,
+        _ => return Err(format!("Unsupported GridFS bucket sort field: {field_name}")),
+    };
+    let descending = match direction {
+        serde_json::Value::Number(value) if value.as_i64() == Some(-1) => true,
+        serde_json::Value::Number(value) if value.as_i64() == Some(1) => false,
+        serde_json::Value::String(value) if value.eq_ignore_ascii_case("desc") || value == "-1" => true,
+        serde_json::Value::String(value) if value.eq_ignore_ascii_case("asc") || value == "1" => false,
+        _ => return Err("GridFS bucket sort direction must be 1, -1, 'asc', or 'desc'".to_string()),
+    };
+
+    Ok(GridFsBucketSort { field, descending })
+}
+
+fn filter_and_sort_gridfs_bucket_infos(
+    mut buckets: Vec<MongoGridFsBucketInfo>,
+    filter: Option<&str>,
+    sort: Option<&str>,
+) -> Result<Vec<MongoGridFsBucketInfo>, String> {
+    if let Some(filter_text) = filter.map(str::trim).filter(|value| !value.is_empty()) {
+        let needle = filter_text.to_lowercase();
+        buckets.retain(|bucket| bucket.name.to_lowercase().contains(&needle));
+    }
+
+    let sort = parse_gridfs_bucket_sort(sort)?;
+    buckets.sort_by(|left, right| {
+        let name_cmp =
+            left.name.to_lowercase().cmp(&right.name.to_lowercase()).then_with(|| left.name.cmp(&right.name));
+        let ordering = match sort.field {
+            GridFsBucketSortField::Name => name_cmp,
+            GridFsBucketSortField::FileCount => left.file_count.cmp(&right.file_count).then_with(|| name_cmp),
+            GridFsBucketSortField::TotalBytes => left.total_bytes.cmp(&right.total_bytes).then_with(|| name_cmp),
+        };
+        if sort.descending {
+            ordering.reverse()
+        } else {
+            ordering
+        }
+    });
+
+    Ok(buckets)
+}
+
+pub async fn list_collections_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+) -> Result<Vec<CollectionInfo>, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => {
+            let names = sort_names(mongo_driver::list_collections(client, database).await?);
+            let mut infos = mongo_bucket_infos(&names);
+            infos.extend(names.into_iter().map(mongo_collection_info));
+            Ok(infos)
+        }
+        PoolKind::Elasticsearch(client) => {
+            let names = sort_names(elasticsearch_driver::list_indices(client).await?);
+            Ok(names
+                .into_iter()
+                .map(|n| CollectionInfo { name: n.clone(), id: n, dimension: None, kind: None, bucket_name: None })
+                .collect())
+        }
+        PoolKind::VectorDb(client) => vector_driver::list_collections_with_db(&client, database).await,
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            let names = sort_names(client.mongo_list_collections(database).await?);
+            let mut infos = mongo_bucket_infos(&names);
+            infos.extend(names.into_iter().map(mongo_collection_info));
+            Ok(infos)
+        }
+        _ => Err("Not a MongoDB/Elasticsearch/vector connection".to_string()),
+    }
+}
+
+pub async fn list_gridfs_files_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    bucket: &str,
+    filter: Option<&str>,
+    sort: Option<&str>,
+) -> Result<Vec<MongoGridFsFileInfo>, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::list_gridfs_files(client, database, bucket, filter, sort).await,
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support GridFS file browsing".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn list_gridfs_buckets_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    filter: Option<&str>,
+    sort: Option<&str>,
+) -> Result<Vec<MongoGridFsBucketInfo>, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => {
+            let names = sort_names(mongo_driver::list_collections(client, database).await?);
+            let bucket_names = mongo_gridfs_bucket_names(&names);
+            let mut buckets = Vec::with_capacity(bucket_names.len());
+            for bucket_name in bucket_names {
+                buckets.push(mongo_driver::gridfs_bucket_summary(client, database, &bucket_name).await?);
+            }
+            filter_and_sort_gridfs_bucket_infos(buckets, filter, sort)
+        }
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support GridFS bucket browsing".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn create_gridfs_bucket_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    bucket: &str,
+) -> Result<(), String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::create_gridfs_bucket(client, database, bucket).await,
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support GridFS bucket creation".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn delete_gridfs_bucket_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    bucket: &str,
+) -> Result<(), String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::delete_gridfs_bucket(client, database, bucket).await,
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support GridFS bucket deletion".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn download_gridfs_file_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    bucket: &str,
+    file_id: &str,
+) -> Result<Vec<u8>, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::download_gridfs_file(client, database, bucket, file_id).await,
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support GridFS download".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn upload_gridfs_file_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    bucket: &str,
+    file_name: &str,
+    data: &[u8],
+    content_type: Option<&str>,
+) -> Result<String, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => {
+            mongo_driver::upload_gridfs_file(client, database, bucket, file_name, data, content_type).await
+        }
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support GridFS uploads".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn delete_gridfs_file_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    bucket: &str,
+    file_id: &str,
+) -> Result<(), String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::delete_gridfs_file(client, database, bucket, file_id).await,
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support GridFS file deletion".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub async fn find_documents_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    skip: u64,
+    limit: i64,
+    filter: Option<&str>,
+    projection: Option<&str>,
+    sort: Option<&str>,
+) -> Result<MongoDocumentResult, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => {
+            mongo_driver::find_documents(client, database, collection, skip, limit, filter, projection, sort).await
+        }
+        PoolKind::Elasticsearch(client) => {
+            let client = client.clone();
+            drop(connections);
+            elasticsearch_driver::find_documents(&client, collection, skip, limit, filter, sort).await
+        }
+        PoolKind::VectorDb(client) => {
+            let client = client.clone();
+            drop(connections);
+            let _ = (filter, sort);
+            vector_driver::find_documents(&client, database, collection, skip, limit).await
+        }
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            let mut params = serde_json::json!({
+                "database": database,
+                "collection": collection,
+                "skip": skip,
+                "limit": limit,
+                "filter": filter,
+                "sort": sort,
+            });
+            if let Some(projection) = projection {
+                params["projection"] = serde_json::json!(projection);
+            }
+            client.mongo_find_documents(params).await
+        }
+        _ => Err("Not a MongoDB/Elasticsearch/vector connection".to_string()),
+    }
+}
+
+pub async fn insert_document_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    doc_json: &str,
+) -> Result<String, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::insert_document(client, database, collection, doc_json).await,
+        PoolKind::Elasticsearch(client) => {
+            let client = client.clone();
+            drop(connections);
+            elasticsearch_driver::insert_document(&client, collection, doc_json).await
+        }
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            let result: serde_json::Value = client
+                .mongo_insert_document(serde_json::json!({
+                    "database": database,
+                    "collection": collection,
+                    "doc_json": doc_json,
+                }))
+                .await?;
+            Ok(result.get("inserted_id").and_then(|v| v.as_str()).unwrap_or("").to_string())
+        }
+        _ => Err("Not a MongoDB/Elasticsearch connection".to_string()),
+    }
+}
+
+pub async fn update_document_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    id: &str,
+    doc_json: &str,
+    routing: Option<&str>,
+) -> Result<u64, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::update_document(client, database, collection, id, doc_json).await,
+        PoolKind::Elasticsearch(client) => {
+            let client = client.clone();
+            drop(connections);
+            // Elasticsearch requires the same custom routing value for writes
+            // as was used to index the document.
+            elasticsearch_driver::update_document(&client, collection, id, doc_json, routing).await
+        }
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            let result: serde_json::Value = client
+                .mongo_update_document(serde_json::json!({
+                    "database": database,
+                    "collection": collection,
+                    "id": id,
+                    "doc_json": doc_json,
+                }))
+                .await?;
+            Ok(result.get("modified_count").and_then(|v| v.as_u64()).unwrap_or(0))
+        }
+        _ => Err("Not a MongoDB/Elasticsearch connection".to_string()),
+    }
+}
+
+pub async fn delete_document_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    id: &str,
+    routing: Option<&str>,
+) -> Result<u64, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::delete_document(client, database, collection, id).await,
+        PoolKind::Elasticsearch(client) => {
+            let client = client.clone();
+            drop(connections);
+            // Elasticsearch requires the same custom routing value for writes
+            // as was used to index the document.
+            elasticsearch_driver::delete_document(&client, collection, id, routing).await
+        }
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            let result: serde_json::Value =
+                client.mongo_delete_document(mongo_document_id_params(database, collection, id)).await?;
+            Ok(result.get("deleted_count").and_then(|v| v.as_u64()).unwrap_or(0))
+        }
+        _ => Err("Not a MongoDB/Elasticsearch connection".to_string()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        fallback_mongo_database, filter_and_sort_gridfs_bucket_infos, mongo_gridfs_bucket_names,
+        mongo_list_databases_unauthorized, parse_gridfs_bucket_sort, sort_names, MongoGridFsBucketInfo,
+    };
+
+    #[test]
+    fn sorts_names_case_insensitively() {
+        let sorted = sort_names(vec![
+            "movies".to_string(),
+            "Comments".to_string(),
+            "users".to_string(),
+            "embedded_movies".to_string(),
+        ]);
+
+        assert_eq!(sorted, vec!["Comments", "embedded_movies", "movies", "users"]);
+    }
+
+    #[test]
+    fn detects_mongo_list_databases_unauthorized_errors() {
+        assert!(mongo_list_databases_unauthorized(
+            "Command failed with error 13 (Unauthorized): not authorized on admin to execute command { listDatabases: 1 }",
+        ));
+        assert!(!mongo_list_databases_unauthorized("not authorized to execute command { find: \"orders\" }"));
+    }
+
+    #[test]
+    fn falls_back_to_configured_mongo_database() {
+        assert_eq!(
+            fallback_mongo_database("not authorized", Some("app".to_string())).unwrap(),
+            vec!["app".to_string()],
+        );
+        assert_eq!(fallback_mongo_database("not authorized", None).unwrap_err(), "not authorized");
+    }
+
+    #[test]
+    fn extracts_gridfs_bucket_names_from_matching_files_and_chunks_collections() {
+        let buckets = mongo_gridfs_bucket_names(&[
+            "orders.files".to_string(),
+            "orders.chunks".to_string(),
+            "reports.files".to_string(),
+            "reports.chunks".to_string(),
+            "reports.files".to_string(),
+            "loose.files".to_string(),
+        ]);
+
+        assert_eq!(buckets, vec!["orders".to_string(), "reports".to_string()]);
+    }
+
+    #[test]
+    fn filters_gridfs_buckets_by_case_insensitive_name_match() {
+        let buckets = filter_and_sort_gridfs_bucket_infos(
+            vec![
+                MongoGridFsBucketInfo { name: "images".to_string(), file_count: 4, total_bytes: 512 },
+                MongoGridFsBucketInfo { name: "nightly-reports".to_string(), file_count: 9, total_bytes: 4096 },
+                MongoGridFsBucketInfo { name: "videos".to_string(), file_count: 2, total_bytes: 8192 },
+            ],
+            Some("REPORT"),
+            None,
+        )
+        .unwrap();
+
+        assert_eq!(
+            buckets.into_iter().map(|bucket| bucket.name).collect::<Vec<_>>(),
+            vec!["nightly-reports".to_string()]
+        );
+    }
+
+    #[test]
+    fn sorts_gridfs_buckets_by_total_bytes_descending() {
+        let buckets = filter_and_sort_gridfs_bucket_infos(
+            vec![
+                MongoGridFsBucketInfo { name: "images".to_string(), file_count: 4, total_bytes: 512 },
+                MongoGridFsBucketInfo { name: "nightly-reports".to_string(), file_count: 9, total_bytes: 4096 },
+                MongoGridFsBucketInfo { name: "videos".to_string(), file_count: 2, total_bytes: 8192 },
+            ],
+            None,
+            Some(r#"{"totalBytes":-1}"#),
+        )
+        .unwrap();
+
+        assert_eq!(
+            buckets.into_iter().map(|bucket| bucket.name).collect::<Vec<_>>(),
+            vec!["videos".to_string(), "nightly-reports".to_string(), "images".to_string()]
+        );
+    }
+
+    #[test]
+    fn gridfs_bucket_sort_rejects_unknown_fields() {
+        let error = parse_gridfs_bucket_sort(Some(r#"{"createdAt":-1}"#)).unwrap_err();
+
+        assert!(error.contains("Unsupported GridFS bucket sort field"));
+    }
+}
diff --git a/crates/dbx-core/src/driver_runtime.rs b/crates/dbx-core/src/driver_runtime.rs
new file mode 100644
index 0000000..58a2bc5
--- /dev/null
+++ b/crates/dbx-core/src/driver_runtime.rs
@@ -0,0 +1,309 @@
+use std::collections::{HashMap, HashSet};
+
+use serde::{Deserialize, Serialize};
+use sysinfo::{Pid, ProcessRefreshKind, ProcessesToUpdate, RefreshKind, System};
+
+use crate::agent_catalog;
+use crate::connection::{config_for_pool_key, AppState, PoolKind};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct DriverRuntimeInfo {
+    pub id: String,
+    pub driver_key: String,
+    pub label: String,
+    pub kind: String,
+    pub source: String,
+    pub status: String,
+    pub pid: Option<u32>,
+    pub memory_bytes: Option<u64>,
+    pub cpu_percent: Option<f32>,
+    pub uptime_seconds: Option<u64>,
+    pub version: Option<String>,
+    pub last_error: Option<String>,
+    pub can_stop: bool,
+    pub can_restart: bool,
+    pub control_unavailable_reason: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
+pub struct DriverRuntimeSummary {
+    pub running_count: usize,
+    pub total_memory_bytes: u64,
+    pub last_error: Option<String>,
+    pub health: String,
+    pub runtimes: Vec<DriverRuntimeInfo>,
+}
+
+#[derive(Debug, Clone)]
+struct RuntimeSeed {
+    id: String,
+    driver_key: String,
+    label: String,
+    kind: String,
+    source: String,
+    status: String,
+    pid: Option<u32>,
+    version: Option<String>,
+    last_error: Option<String>,
+    can_stop: bool,
+    can_restart: bool,
+    control_unavailable_reason: Option<String>,
+}
+
+#[derive(Debug, Clone, Default)]
+struct ProcessStats {
+    memory_bytes: u64,
+    cpu_percent: f32,
+    uptime_seconds: u64,
+}
+
+pub async fn collect_driver_runtime_summary(state: &AppState) -> DriverRuntimeSummary {
+    let seeds = collect_runtime_seeds(state).await;
+    let pids = seeds.iter().filter_map(|seed| seed.pid).collect::<HashSet<_>>();
+    let stats = collect_process_stats(pids).await;
+    build_summary(seeds, &stats)
+}
+
+pub async fn stop_driver_runtime(state: &AppState, runtime_id: &str) -> Result<(), String> {
+    let agent_key =
+        runtime_id.strip_prefix("agent:").ok_or_else(|| "Only agent daemon runtimes can be stopped".to_string())?;
+    state.agent_manager.stop_daemon_by_key(agent_key).await;
+    Ok(())
+}
+
+pub async fn restart_driver_runtime(state: &AppState, runtime_id: &str) -> Result<(), String> {
+    let agent_key =
+        runtime_id.strip_prefix("agent:").ok_or_else(|| "Only agent daemon runtimes can be restarted".to_string())?;
+    state.agent_manager.restart_daemon_by_key(agent_key).await
+}
+
+async fn collect_runtime_seeds(state: &AppState) -> Vec<RuntimeSeed> {
+    let agent_state = state.agent_manager.load_state();
+    let mut seeds = HashMap::<String, RuntimeSeed>::new();
+
+    for (key, installed) in &agent_state.installed_drivers {
+        seeds.insert(
+            format!("agent:{key}"),
+            RuntimeSeed {
+                id: format!("agent:{key}"),
+                driver_key: key.clone(),
+                label: agent_catalog::label_for_key(key).unwrap_or(key).to_string(),
+                kind: "agent".to_string(),
+                source: "daemon".to_string(),
+                status: "stopped".to_string(),
+                pid: None,
+                version: Some(installed.version.clone()),
+                last_error: None,
+                can_stop: false,
+                can_restart: state.agent_manager.is_driver_installed(key),
+                control_unavailable_reason: None,
+            },
+        );
+    }
+
+    {
+        let daemons = state.agent_manager.daemons.lock().await;
+        for (key, client) in daemons.iter() {
+            let last_error = non_empty(client.stderr_tail_snapshot());
+            seeds.insert(
+                format!("agent:{key}"),
+                RuntimeSeed {
+                    id: format!("agent:{key}"),
+                    driver_key: key.clone(),
+                    label: agent_catalog::label_for_key(key).unwrap_or(key).to_string(),
+                    kind: "agent".to_string(),
+                    source: "daemon".to_string(),
+                    status: "running".to_string(),
+                    pid: Some(client.pid()),
+                    version: agent_state.installed_drivers.get(key).map(|driver| driver.version.clone()),
+                    last_error,
+                    can_stop: true,
+                    can_restart: true,
+                    control_unavailable_reason: None,
+                },
+            );
+        }
+    }
+
+    let configs = state.configs.read().await;
+    let connections = state.connections.read().await;
+    for (pool_key, pool) in connections.iter() {
+        match pool {
+            PoolKind::Agent(client) => {
+                let Some(config) = config_for_pool_key(pool_key, &configs) else {
+                    continue;
+                };
+                let key = crate::agent_manager::AgentManager::db_type_to_agent_key(
+                    &config.db_type,
+                    config.driver_profile.as_deref(),
+                )
+                .unwrap_or("agent");
+                let client = client.lock().await;
+                let last_error = non_empty(client.stderr_tail_snapshot());
+                seeds.insert(
+                    format!("agent-connection:{pool_key}"),
+                    RuntimeSeed {
+                        id: format!("agent-connection:{pool_key}"),
+                        driver_key: key.to_string(),
+                        label: agent_catalog::label_for_key(key).unwrap_or(key).to_string(),
+                        kind: "agent".to_string(),
+                        source: "connection".to_string(),
+                        status: "running".to_string(),
+                        pid: Some(client.pid()),
+                        version: agent_state.installed_drivers.get(key).map(|driver| driver.version.clone()),
+                        last_error,
+                        can_stop: false,
+                        can_restart: false,
+                        control_unavailable_reason: Some("connection-owned".to_string()),
+                    },
+                );
+            }
+            PoolKind::ExternalDriver { driver_id, session, .. } => {
+                seeds.insert(
+                    format!("plugin-connection:{pool_key}"),
+                    RuntimeSeed {
+                        id: format!("plugin-connection:{pool_key}"),
+                        driver_key: driver_id.clone(),
+                        label: driver_id.clone(),
+                        kind: "plugin".to_string(),
+                        source: "connection".to_string(),
+                        status: "running".to_string(),
+                        pid: session.pid().await,
+                        version: None,
+                        last_error: None,
+                        can_stop: false,
+                        can_restart: false,
+                        control_unavailable_reason: Some("connection-owned".to_string()),
+                    },
+                );
+            }
+            _ => {}
+        }
+    }
+
+    let mut output = seeds.into_values().collect::<Vec<_>>();
+    output.sort_by(|left, right| {
+        left.kind
+            .cmp(&right.kind)
+            .then(left.label.cmp(&right.label))
+            .then(left.source.cmp(&right.source))
+            .then(left.id.cmp(&right.id))
+    });
+    output
+}
+
+async fn collect_process_stats(pids: HashSet<u32>) -> HashMap<u32, ProcessStats> {
+    if pids.is_empty() {
+        return HashMap::new();
+    }
+
+    tokio::task::spawn_blocking(move || {
+        let mut system = System::new_with_specifics(
+            RefreshKind::new().with_processes(ProcessRefreshKind::new().with_cpu().with_memory().with_disk_usage()),
+        );
+        system.refresh_processes_specifics(
+            ProcessesToUpdate::All,
+            true,
+            ProcessRefreshKind::new().with_cpu().with_memory().with_disk_usage(),
+        );
+
+        let mut stats = HashMap::new();
+        for pid in pids {
+            let Some(process) = system.process(Pid::from(pid as usize)) else {
+                continue;
+            };
+            stats.insert(
+                pid,
+                ProcessStats {
+                    memory_bytes: process.memory(),
+                    cpu_percent: process.cpu_usage(),
+                    uptime_seconds: process.run_time(),
+                },
+            );
+        }
+        stats
+    })
+    .await
+    .unwrap_or_default()
+}
+
+fn build_summary(seeds: Vec<RuntimeSeed>, stats: &HashMap<u32, ProcessStats>) -> DriverRuntimeSummary {
+    let runtimes = seeds
+        .into_iter()
+        .map(|seed| {
+            let stat = seed.pid.and_then(|pid| stats.get(&pid));
+            DriverRuntimeInfo {
+                id: seed.id,
+                driver_key: seed.driver_key,
+                label: seed.label,
+                kind: seed.kind,
+                source: seed.source,
+                status: seed.status,
+                pid: seed.pid,
+                memory_bytes: stat.map(|value| value.memory_bytes),
+                cpu_percent: stat.map(|value| value.cpu_percent),
+                uptime_seconds: stat.map(|value| value.uptime_seconds),
+                version: seed.version,
+                last_error: seed.last_error,
+                can_stop: seed.can_stop,
+                can_restart: seed.can_restart,
+                control_unavailable_reason: seed.control_unavailable_reason,
+            }
+        })
+        .collect::<Vec<_>>();
+
+    let running_count = runtimes.iter().filter(|runtime| runtime.status == "running").count();
+    let total_memory_bytes = runtimes.iter().filter_map(|runtime| runtime.memory_bytes).sum();
+    let last_error = runtimes.iter().rev().find_map(|runtime| runtime.last_error.clone());
+    let health = if runtimes.iter().any(|runtime| runtime.status == "error") {
+        "error"
+    } else if last_error.is_some() {
+        "warning"
+    } else {
+        "healthy"
+    }
+    .to_string();
+
+    DriverRuntimeSummary { running_count, total_memory_bytes, last_error, health, runtimes }
+}
+
+fn non_empty(value: String) -> Option<String> {
+    let trimmed = value.trim();
+    (!trimmed.is_empty()).then(|| trimmed.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{build_summary, ProcessStats, RuntimeSeed};
+    use std::collections::HashMap;
+
+    fn seed(id: &str, status: &str, pid: Option<u32>) -> RuntimeSeed {
+        RuntimeSeed {
+            id: id.to_string(),
+            driver_key: id.to_string(),
+            label: id.to_string(),
+            kind: "agent".to_string(),
+            source: "daemon".to_string(),
+            status: status.to_string(),
+            pid,
+            version: None,
+            last_error: None,
+            can_stop: true,
+            can_restart: true,
+            control_unavailable_reason: None,
+        }
+    }
+
+    #[test]
+    fn summary_counts_running_runtimes_and_memory() {
+        let mut stats = HashMap::new();
+        stats.insert(42, ProcessStats { memory_bytes: 1024, cpu_percent: 0.5, uptime_seconds: 7 });
+
+        let summary = build_summary(vec![seed("oracle", "running", Some(42)), seed("h2", "stopped", None)], &stats);
+
+        assert_eq!(summary.running_count, 1);
+        assert_eq!(summary.total_memory_bytes, 1024);
+        assert_eq!(summary.health, "healthy");
+        assert_eq!(summary.runtimes[0].memory_bytes, Some(1024));
+    }
+}
diff --git a/crates/dbx-core/src/external/duckdb_cache.rs b/crates/dbx-core/src/external/duckdb_cache.rs
new file mode 100644
index 0000000..d5c9366
--- /dev/null
+++ b/crates/dbx-core/src/external/duckdb_cache.rs
@@ -0,0 +1,173 @@
+#![cfg(feature = "duckdb-bundled")]
+
+use std::sync::Arc;
+
+use super::types::{CacheState, ExternalTableRef, ExternalTableSnapshot};
+
+/// Loads an external table snapshot into an in-memory DuckDB connection.
+pub fn load_snapshot_to_duckdb(con: &duckdb::Connection, snapshot: &ExternalTableSnapshot) -> Result<(), String> {
+    let table_name = sanitize_table_name(&snapshot.table_ref.table_name);
+
+    con.execute(&format!("DROP TABLE IF EXISTS \"{}\"", table_name), [])
+        .map_err(|e| format!("Failed to drop table: {e}"))?;
+
+    let col_defs: Vec<String> = snapshot
+        .columns
+        .iter()
+        .map(|c| {
+            format!(
+                "\"{}\" {}{}",
+                c.name.replace('"', "\"\""),
+                c.duckdb_type,
+                if c.is_nullable { "" } else { " NOT NULL" }
+            )
+        })
+        .collect();
+
+    let pk_cols: Vec<&str> = snapshot.columns.iter().filter(|c| c.is_primary_key).map(|c| c.name.as_str()).collect();
+
+    let mut create_sql = format!("CREATE TABLE \"{}\" ({}", table_name, col_defs.join(", "));
+    if !pk_cols.is_empty() {
+        create_sql.push_str(&format!(
+            ", PRIMARY KEY ({})",
+            pk_cols.iter().map(|c| format!("\"{}\"", c.replace('"', "\"\""))).collect::<Vec<_>>().join(", ")
+        ));
+    }
+    create_sql.push(')');
+
+    con.execute(&create_sql, []).map_err(|e| format!("Failed to create table: {e}"))?;
+
+    if snapshot.rows.is_empty() {
+        return Ok(());
+    }
+
+    let placeholders: Vec<&str> = (0..snapshot.columns.len()).map(|_| "?").collect();
+    let insert_sql = format!("INSERT INTO \"{}\" VALUES ({})", table_name, placeholders.join(", "));
+    let mut stmt = con.prepare(&insert_sql).map_err(|e| format!("Failed to prepare insert: {e}"))?;
+
+    for row in &snapshot.rows {
+        let params: Vec<Box<dyn duckdb::ToSql>> = row
+            .iter()
+            .enumerate()
+            .map(|(i, val)| {
+                let col_type = snapshot.columns.get(i).map(|c| c.duckdb_type.as_str()).unwrap_or("VARCHAR");
+                json_to_duckdb_param(val, col_type)
+            })
+            .collect();
+
+        let param_refs: Vec<&dyn duckdb::ToSql> = params.iter().map(|p| p.as_ref()).collect();
+        stmt.execute(param_refs.as_slice()).map_err(|e| format!("Failed to insert row: {e}"))?;
+    }
+
+    Ok(())
+}
+
+fn json_to_duckdb_param(val: &serde_json::Value, col_type: &str) -> Box<dyn duckdb::ToSql> {
+    match val {
+        serde_json::Value::Null => Box::new(None::<String>),
+        serde_json::Value::Bool(b) => Box::new(*b),
+        serde_json::Value::Number(n) => {
+            if col_type.contains("INT") {
+                Box::new(n.as_i64().unwrap_or(0))
+            } else if col_type.contains("DOUBLE") || col_type.contains("FLOAT") || col_type.contains("DECIMAL") {
+                Box::new(n.as_f64().unwrap_or(0.0))
+            } else {
+                Box::new(n.to_string())
+            }
+        }
+        serde_json::Value::String(s) => Box::new(s.clone()),
+        _ => Box::new(val.to_string()),
+    }
+}
+
+/// Sanitize a source table name into a stable DuckDB table identifier.
+pub fn sanitize_table_name(name: &str) -> String {
+    let sanitized: String = name.chars().map(|c| if c.is_alphanumeric() || c == '_' { c } else { '_' }).collect();
+
+    if sanitized.is_empty() {
+        "_unnamed_".to_string()
+    } else if sanitized.chars().next().is_some_and(|c| c.is_ascii_digit()) {
+        format!("_{sanitized}")
+    } else {
+        sanitized
+    }
+}
+
+/// Manages a DuckDB cache for one external source.
+pub struct ExternalPool {
+    pub source: Arc<dyn super::traits::ExternalTabularSource>,
+    pub cache: Arc<std::sync::Mutex<duckdb::Connection>>,
+    pub cache_state: std::sync::Mutex<CacheState>,
+    pub table_map: std::sync::Mutex<std::collections::HashMap<String, ExternalTableRef>>,
+}
+
+impl ExternalPool {
+    pub fn new(
+        source: Arc<dyn super::traits::ExternalTabularSource>,
+        cache: Arc<std::sync::Mutex<duckdb::Connection>>,
+    ) -> Self {
+        Self {
+            source,
+            cache,
+            cache_state: std::sync::Mutex::new(CacheState::Empty),
+            table_map: std::sync::Mutex::new(std::collections::HashMap::new()),
+        }
+    }
+
+    pub async fn refresh_cache(&self) -> Result<(), String> {
+        {
+            let mut state = self.cache_state.lock().map_err(|e| e.to_string())?;
+            *state = CacheState::Loading;
+        }
+
+        let tables = self.source.list_tables().await?;
+        let mut new_table_map = std::collections::HashMap::new();
+
+        for table_ref in &tables {
+            let snapshot = self.source.load_table(table_ref).await?;
+            let mut sanitized_name = sanitize_table_name(&table_ref.table_name);
+
+            if new_table_map.contains_key(&sanitized_name) {
+                let base = sanitized_name.clone();
+                let mut suffix = 2;
+                loop {
+                    sanitized_name = format!("{base}_{suffix}");
+                    if !new_table_map.contains_key(&sanitized_name) {
+                        break;
+                    }
+                    suffix += 1;
+                }
+            }
+
+            let cache = self.cache.clone();
+            tokio::task::spawn_blocking(move || {
+                let con = cache.lock().map_err(|e| e.to_string())?;
+                load_snapshot_to_duckdb(&con, &snapshot)
+            })
+            .await
+            .map_err(|e| e.to_string())??;
+
+            new_table_map.insert(sanitized_name, table_ref.clone());
+        }
+
+        {
+            let mut map = self.table_map.lock().map_err(|e| e.to_string())?;
+            *map = new_table_map;
+        }
+        {
+            let mut state = self.cache_state.lock().map_err(|e| e.to_string())?;
+            *state = CacheState::Fresh;
+        }
+
+        Ok(())
+    }
+}
+
+impl std::fmt::Debug for ExternalPool {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ExternalPool")
+            .field("source", &self.source.display_name())
+            .field("cache_state", &self.cache_state)
+            .finish()
+    }
+}
diff --git a/crates/dbx-core/src/external/mod.rs b/crates/dbx-core/src/external/mod.rs
new file mode 100644
index 0000000..9f41a0e
--- /dev/null
+++ b/crates/dbx-core/src/external/mod.rs
@@ -0,0 +1,8 @@
+pub mod duckdb_cache;
+pub mod traits;
+pub mod types;
+
+#[cfg(feature = "duckdb-bundled")]
+pub use duckdb_cache::ExternalPool;
+pub use traits::ExternalTabularSource;
+pub use types::*;
diff --git a/crates/dbx-core/src/external/traits.rs b/crates/dbx-core/src/external/traits.rs
new file mode 100644
index 0000000..6fdafa3
--- /dev/null
+++ b/crates/dbx-core/src/external/traits.rs
@@ -0,0 +1,21 @@
+use async_trait::async_trait;
+
+use super::types::{ExternalCapabilities, ExternalColumnDef, ExternalTableRef, ExternalTableSnapshot};
+
+/// Trait for external tabular data sources.
+#[async_trait]
+pub trait ExternalTabularSource: Send + Sync + std::fmt::Debug {
+    fn capabilities(&self) -> ExternalCapabilities;
+
+    async fn list_tables(&self) -> Result<Vec<ExternalTableRef>, String>;
+
+    async fn get_columns(&self, table: &ExternalTableRef) -> Result<Vec<ExternalColumnDef>, String>;
+
+    async fn load_table(&self, table: &ExternalTableRef) -> Result<ExternalTableSnapshot, String>;
+
+    async fn source_version(&self, table: &ExternalTableRef) -> Result<String, String>;
+
+    async fn test_connection(&self) -> Result<String, String>;
+
+    fn display_name(&self) -> String;
+}
diff --git a/crates/dbx-core/src/external/types.rs b/crates/dbx-core/src/external/types.rs
new file mode 100644
index 0000000..a90c4f6
--- /dev/null
+++ b/crates/dbx-core/src/external/types.rs
@@ -0,0 +1,52 @@
+use serde::{Deserialize, Serialize};
+
+/// Reference to a specific table within an external source.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct ExternalTableRef {
+    pub source_id: String,
+    pub table_name: String,
+    pub display_name: String,
+}
+
+/// Column definition for an external table snapshot.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExternalColumnDef {
+    pub name: String,
+    pub duckdb_type: String,
+    pub is_nullable: bool,
+    pub is_primary_key: bool,
+    pub comment: Option<String>,
+}
+
+/// A full table snapshot loaded from an external source.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExternalTableSnapshot {
+    pub table_ref: ExternalTableRef,
+    pub columns: Vec<ExternalColumnDef>,
+    pub rows: Vec<Vec<serde_json::Value>>,
+    pub source_version: String,
+}
+
+/// Capability flags for an external data source.
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ExternalCapabilities {
+    pub can_read: bool,
+    pub can_write: bool,
+    pub can_append: bool,
+    pub can_delete_rows: bool,
+    pub supports_multiple_tables: bool,
+    pub supports_refresh: bool,
+    pub supports_file_watch: bool,
+    pub supports_schema_detection: bool,
+}
+
+/// Cache state tracking for external source snapshots.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub enum CacheState {
+    #[default]
+    Empty,
+    Fresh,
+    Stale,
+    Loading,
+    Error(String),
+}
diff --git a/crates/dbx-core/src/history.rs b/crates/dbx-core/src/history.rs
new file mode 100644
index 0000000..673849e
--- /dev/null
+++ b/crates/dbx-core/src/history.rs
@@ -0,0 +1,68 @@
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HistoryEntry {
+    pub id: String,
+    #[serde(default)]
+    pub connection_id: String,
+    pub connection_name: String,
+    pub database: String,
+    pub sql: String,
+    pub executed_at: String,
+    pub execution_time_ms: u128,
+    pub success: bool,
+    pub error: Option<String>,
+    #[serde(default = "default_activity_kind")]
+    pub activity_kind: String,
+    #[serde(default)]
+    pub operation: String,
+    #[serde(default)]
+    pub target: String,
+    #[serde(default)]
+    pub affected_rows: Option<i64>,
+    #[serde(default)]
+    pub rollback_sql: Option<String>,
+    #[serde(default)]
+    pub details_json: Option<String>,
+}
+
+pub const MAX_HISTORY: usize = 1000;
+
+fn default_activity_kind() -> String {
+    "query".to_string()
+}
+
+pub fn read_all(path: &Path) -> Result<Vec<HistoryEntry>, String> {
+    if !path.exists() {
+        return Ok(vec![]);
+    }
+    let json = std::fs::read_to_string(path).map_err(|e| e.to_string())?;
+    serde_json::from_str(&json).map_err(|e| e.to_string())
+}
+
+pub fn write_all(path: &Path, entries: &[HistoryEntry]) -> Result<(), String> {
+    let json = serde_json::to_string(entries).map_err(|e| e.to_string())?;
+    std::fs::write(path, json).map_err(|e| e.to_string())
+}
+
+pub fn save_history_entry(path: &Path, entry: HistoryEntry) -> Result<(), String> {
+    let mut entries = read_all(path)?;
+    entries.insert(0, entry);
+    entries.truncate(MAX_HISTORY);
+    write_all(path, &entries)
+}
+
+pub fn load_history_entries(path: &Path, limit: usize, offset: usize) -> Result<Vec<HistoryEntry>, String> {
+    let entries = read_all(path)?;
+    Ok(entries.into_iter().skip(offset).take(limit).collect())
+}
+
+pub fn clear_history_entries(path: &Path) -> Result<(), String> {
+    write_all(path, &[])
+}
+
+pub fn delete_history_entry_by_id(path: &Path, id: &str) -> Result<(), String> {
+    let entries: Vec<HistoryEntry> = read_all(path)?.into_iter().filter(|e| e.id != id).collect();
+    write_all(path, &entries)
+}
diff --git a/crates/dbx-core/src/jdbc.rs b/crates/dbx-core/src/jdbc.rs
new file mode 100644
index 0000000..a5778c0
--- /dev/null
+++ b/crates/dbx-core/src/jdbc.rs
@@ -0,0 +1,1083 @@
+use crate::agent_service::AgentProgressEvent;
+use crate::plugins::PluginRuntimeEnv;
+use crate::plugins::{PluginManifest, SUPPORTED_PLUGIN_PROTOCOL_VERSION};
+use crate::update::{fetch_latest_release, is_newer_version, JdbcPluginLatest};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use std::path::{Path, PathBuf};
+
+const JDBC_PLUGIN_DOWNLOAD_URL: &str =
+    "https://github.com/t8y2/dbx/releases/latest/download/dbx-jdbc-plugin-latest.zip";
+const JDBC_PLUGIN_R2_PATH: &str = "releases/latest/dbx-jdbc-plugin-latest.zip";
+pub const PRESTOSQL_JDBC_DRIVER_VERSION: &str = "350";
+pub const PRESTOSQL_JDBC_DRIVER_COORDINATE: &str = "io.prestosql:presto-jdbc:350";
+pub const PRESTOSQL_JDBC_DRIVER_REPOSITORY: &str = "https://repo.maven.apache.org/maven2/";
+const PRESTOSQL_JDBC_DRIVER_URL: &str =
+    "https://repo.maven.apache.org/maven2/io/prestosql/presto-jdbc/350/presto-jdbc-350.jar";
+
+#[derive(Debug, Clone, Serialize)]
+pub struct JdbcDriverInfo {
+    pub name: String,
+    pub path: String,
+    pub size: u64,
+    pub bundle_id: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct JdbcMavenInstallRequest {
+    pub coordinate: String,
+    #[serde(default)]
+    pub repositories: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JdbcMavenBundleInfo {
+    pub id: String,
+    pub coordinate: String,
+    pub scope: String,
+    pub repositories: Vec<String>,
+    pub installed_at: String,
+    pub path: String,
+    pub artifacts: Vec<JdbcMavenArtifactInfo>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JdbcMavenArtifactInfo {
+    pub group_id: String,
+    pub artifact_id: String,
+    pub version: String,
+    pub classifier: String,
+    pub extension: String,
+    pub file_name: String,
+    pub path: String,
+    pub size: u64,
+    pub sha256: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JdbcLocalBundleInfo {
+    pub id: String,
+    pub name: String,
+    pub installed_at: String,
+    pub path: String,
+    pub artifacts: Vec<JdbcLocalArtifactInfo>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct JdbcLocalArtifactInfo {
+    pub file_name: String,
+    pub path: String,
+    pub size: u64,
+    pub sha256: String,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct JdbcPluginStatus {
+    pub installed: bool,
+    pub version: Option<String>,
+    pub protocol_version: Option<u32>,
+    pub compatible: bool,
+    pub latest_version: Option<String>,
+    pub latest_protocol_version: Option<u32>,
+    pub update_available: bool,
+    pub path: String,
+}
+
+// ---- JDBC Drivers ----
+
+pub fn list_jdbc_drivers(plugins_root: &Path) -> Result<Vec<JdbcDriverInfo>, String> {
+    list_jdbc_drivers_from_dir(&jdbc_drivers_dir(plugins_root))
+}
+
+pub fn list_jdbc_maven_bundles(plugins_root: &Path) -> Result<Vec<JdbcMavenBundleInfo>, String> {
+    list_jdbc_maven_bundles_from_dir(&jdbc_maven_drivers_dir(plugins_root))
+}
+
+pub fn list_jdbc_local_bundles(plugins_root: &Path) -> Result<Vec<JdbcLocalBundleInfo>, String> {
+    list_jdbc_local_bundles_from_dir(&jdbc_local_drivers_dir(plugins_root))
+}
+
+pub fn import_jdbc_drivers(plugins_root: &Path, paths: &[String]) -> Result<Vec<JdbcDriverInfo>, String> {
+    if paths.len() > 1 {
+        install_jdbc_local_bundle(plugins_root, paths)?;
+        return list_jdbc_drivers(plugins_root);
+    }
+    let drivers_dir = jdbc_drivers_dir(plugins_root);
+    std::fs::create_dir_all(&drivers_dir).map_err(|err| err.to_string())?;
+
+    for path in paths {
+        let source = PathBuf::from(path);
+        if !source.exists() {
+            return Err(format!("Driver JAR does not exist: {}", source.display()));
+        }
+        if source.extension().and_then(|ext| ext.to_str()).map(|ext| ext.eq_ignore_ascii_case("jar")) != Some(true) {
+            return Err(format!("Only .jar files can be imported: {}", source.display()));
+        }
+        let file_name = source
+            .file_name()
+            .and_then(|name| name.to_str())
+            .ok_or_else(|| format!("Invalid driver file path: {}", source.display()))?;
+        let target = unique_target_path(&drivers_dir, file_name);
+        if source == target {
+            continue;
+        }
+        std::fs::copy(&source, &target)
+            .map_err(|err| format!("Failed to import {} to {}: {err}", source.display(), target.display()))?;
+    }
+
+    list_jdbc_drivers_from_dir(&drivers_dir)
+}
+
+pub fn delete_jdbc_driver(plugins_root: &Path, path: &str) -> Result<Vec<JdbcDriverInfo>, String> {
+    let drivers_dir = jdbc_drivers_dir(plugins_root);
+    let drivers_dir = drivers_dir.canonicalize().map_err(|err| err.to_string())?;
+    let target = PathBuf::from(path).canonicalize().map_err(|err| err.to_string())?;
+    if !target.starts_with(&drivers_dir) {
+        return Err("Driver file is outside the JDBC drivers directory".to_string());
+    }
+    std::fs::remove_file(&target).map_err(|err| err.to_string())?;
+    list_jdbc_drivers_from_dir(&drivers_dir)
+}
+
+pub fn delete_jdbc_maven_bundle(plugins_root: &Path, bundle_id: &str) -> Result<Vec<JdbcDriverInfo>, String> {
+    if !is_safe_bundle_id(bundle_id) {
+        return Err("Invalid JDBC Maven bundle id".to_string());
+    }
+    let bundles_dir = jdbc_maven_drivers_dir(plugins_root);
+    let target = bundles_dir.join(bundle_id);
+    if target.exists() {
+        std::fs::remove_dir_all(&target).map_err(|err| err.to_string())?;
+    }
+    list_jdbc_drivers(plugins_root)
+}
+
+pub fn delete_jdbc_local_bundle(plugins_root: &Path, bundle_id: &str) -> Result<Vec<JdbcDriverInfo>, String> {
+    if !is_safe_bundle_id(bundle_id) {
+        return Err("Invalid JDBC local bundle id".to_string());
+    }
+    let target = jdbc_local_drivers_dir(plugins_root).join(bundle_id);
+    if target.exists() {
+        std::fs::remove_dir_all(&target).map_err(|err| err.to_string())?;
+    }
+    list_jdbc_drivers(plugins_root)
+}
+
+pub async fn install_jdbc_driver_from_maven(
+    plugins_root: &Path,
+    request: JdbcMavenInstallRequest,
+    env: PluginRuntimeEnv,
+) -> Result<Vec<JdbcDriverInfo>, String> {
+    let coordinate = request.coordinate.trim().to_string();
+    if coordinate.is_empty() {
+        return Err("Maven coordinate is required".to_string());
+    }
+    let plugin_dir = plugins_root.join("jdbc");
+    let resolver = jdbc_maven_resolver_executable(&plugin_dir);
+    if !resolver.exists() {
+        return Err("JDBC Maven resolver is not installed. Update or reinstall the JDBC plugin.".to_string());
+    }
+
+    let mut repositories = if request.repositories.is_empty() {
+        vec!["https://repo.maven.apache.org/maven2/".to_string()]
+    } else {
+        request.repositories.into_iter().map(|repo| repo.trim().to_string()).filter(|repo| !repo.is_empty()).collect()
+    };
+    if repositories.is_empty() {
+        repositories.push("https://repo.maven.apache.org/maven2/".to_string());
+    }
+    let local_repo = plugin_dir.join("maven-cache");
+    std::fs::create_dir_all(&local_repo).map_err(|err| err.to_string())?;
+
+    let mut command = crate::process::new_tokio_command(&resolver);
+    env.apply_to(&mut command);
+    command.arg("resolve").arg("--coordinate").arg(&coordinate).arg("--local-repo").arg(&local_repo);
+    for repo in &repositories {
+        command.arg("--repo").arg(repo);
+    }
+    let output = command.output().await.map_err(|err| format!("Failed to run JDBC Maven resolver: {err}"))?;
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
+        return Err(if stderr.is_empty() { "JDBC Maven resolver failed".to_string() } else { stderr });
+    }
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let resolved: MavenResolveOutput =
+        serde_json::from_str(&stdout).map_err(|err| format!("Failed to parse JDBC Maven resolver output: {err}"))?;
+    let root = plugins_root.to_path_buf();
+    tokio::task::spawn_blocking(move || install_jdbc_maven_bundle(&root, &coordinate, &resolved))
+        .await
+        .map_err(|err| err.to_string())??;
+    list_jdbc_drivers(plugins_root)
+}
+
+pub async fn install_prestosql_jdbc_driver(plugins_root: &Path) -> Result<Vec<JdbcDriverInfo>, String> {
+    let plugin_dir = plugins_root.join("jdbc");
+    let temp_dir = plugin_dir.join("downloads");
+    std::fs::create_dir_all(&temp_dir).map_err(|err| err.to_string())?;
+    let temp_file = temp_dir.join("presto-jdbc-350.jar.tmp");
+
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(300))
+        .build()
+        .map_err(|err| err.to_string())?;
+    let mut resp = client
+        .get(PRESTOSQL_JDBC_DRIVER_URL)
+        .header(reqwest::header::USER_AGENT, "dbx-prestosql-driver-installer")
+        .send()
+        .await
+        .and_then(|resp| resp.error_for_status())
+        .map_err(|err| format!("Failed to download PrestoSQL JDBC driver: {err}"))?;
+    let mut file = std::fs::File::create(&temp_file)
+        .map_err(|err| format!("Failed to create PrestoSQL JDBC driver temp file: {err}"))?;
+    while let Some(chunk) = resp.chunk().await.map_err(|err| format!("Download stream error: {err}"))? {
+        std::io::Write::write_all(&mut file, &chunk).map_err(|err| format!("Failed to write chunk: {err}"))?;
+    }
+    std::io::Write::flush(&mut file).map_err(|err| format!("Failed to flush temp file: {err}"))?;
+    drop(file);
+
+    let root = plugins_root.to_path_buf();
+    let repositories = vec![PRESTOSQL_JDBC_DRIVER_REPOSITORY.to_string()];
+    tokio::task::spawn_blocking(move || {
+        install_single_jdbc_maven_artifact(
+            &root,
+            PRESTOSQL_JDBC_DRIVER_COORDINATE,
+            "io.prestosql",
+            "presto-jdbc",
+            PRESTOSQL_JDBC_DRIVER_VERSION,
+            &temp_file,
+            &repositories,
+        )?;
+        let _ = std::fs::remove_file(&temp_file);
+        Ok::<(), String>(())
+    })
+    .await
+    .map_err(|err| err.to_string())??;
+    list_jdbc_drivers(plugins_root)
+}
+
+// ---- JDBC Plugin ----
+
+pub async fn get_jdbc_plugin_status(plugins_root: &Path) -> Result<JdbcPluginStatus, String> {
+    jdbc_plugin_status_from_dir(&plugins_root.join("jdbc")).await
+}
+
+pub async fn install_jdbc_plugin(plugins_root: &Path) -> Result<JdbcPluginStatus, String> {
+    install_jdbc_plugin_with_progress(plugins_root, |_| {}).await
+}
+
+pub async fn install_jdbc_plugin_with_progress(
+    plugins_root: &Path,
+    progress: impl Fn(AgentProgressEvent),
+) -> Result<JdbcPluginStatus, String> {
+    let bytes = download_jdbc_plugin_zip_with_progress(&progress).await?;
+    let plugin_dir = plugins_root.join("jdbc");
+    let status_dir = plugin_dir.clone();
+    progress(AgentProgressEvent::transfer("jdbc-plugin-extract", 0, 0));
+    tokio::task::spawn_blocking(move || install_jdbc_plugin_zip(&bytes, &plugin_dir))
+        .await
+        .map_err(|err| err.to_string())??;
+    let status = jdbc_plugin_status_from_dir(&status_dir).await;
+    progress(AgentProgressEvent::step("done"));
+    status
+}
+
+pub async fn install_jdbc_plugin_from_file(plugins_root: &Path, file_path: &str) -> Result<JdbcPluginStatus, String> {
+    let plugin_dir = plugins_root.join("jdbc");
+    let status_dir = plugin_dir.clone();
+    let file_path = file_path.to_string();
+    tokio::task::spawn_blocking(move || {
+        let bytes = std::fs::read(file_path).map_err(|e| format!("Failed to read file: {e}"))?;
+        install_jdbc_plugin_zip(&bytes, &plugin_dir)
+    })
+    .await
+    .map_err(|err| err.to_string())??;
+    jdbc_plugin_status_from_dir(&status_dir).await
+}
+
+pub fn uninstall_jdbc_plugin(plugins_root: &Path) -> Result<JdbcPluginStatus, String> {
+    let plugin_dir = plugins_root.join("jdbc");
+    for entry in ["manifest.json", "bin", "lib"] {
+        let path = plugin_dir.join(entry);
+        if !path.exists() {
+            continue;
+        }
+        if path.is_dir() {
+            std::fs::remove_dir_all(path).map_err(|err| err.to_string())?;
+        } else {
+            std::fs::remove_file(path).map_err(|err| err.to_string())?;
+        }
+    }
+    // synchronous version: check local manifest only, no network call
+    let manifest_path = plugin_dir.join("manifest.json");
+    let manifest = match std::fs::read_to_string(&manifest_path) {
+        Ok(raw) => Some(serde_json::from_str::<PluginManifest>(&raw).map_err(|err| err.to_string())?),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => None,
+        Err(err) => return Err(err.to_string()),
+    };
+    Ok(build_plugin_status(&manifest, None, &plugin_dir))
+}
+
+// ---- System Fonts ----
+
+pub fn list_system_fonts() -> Vec<String> {
+    let source = font_kit::source::SystemSource::new();
+    match source.all_families() {
+        Ok(families) => {
+            use std::collections::BTreeSet;
+            families
+                .into_iter()
+                .map(|family| family.trim().to_string())
+                .filter(|family| !family.is_empty())
+                .collect::<BTreeSet<_>>()
+                .into_iter()
+                .collect()
+        }
+        Err(_) => vec![],
+    }
+}
+
+// ---- Internal helpers ----
+
+fn jdbc_drivers_dir(plugins_root: &Path) -> PathBuf {
+    plugins_root.join("jdbc").join("drivers")
+}
+
+fn jdbc_maven_drivers_dir(plugins_root: &Path) -> PathBuf {
+    jdbc_drivers_dir(plugins_root).join("maven")
+}
+
+fn jdbc_local_drivers_dir(plugins_root: &Path) -> PathBuf {
+    jdbc_drivers_dir(plugins_root).join("local")
+}
+
+fn jdbc_maven_resolver_executable(plugin_dir: &Path) -> PathBuf {
+    #[cfg(windows)]
+    {
+        plugin_dir.join("bin").join("dbx-maven-resolver.bat")
+    }
+    #[cfg(not(windows))]
+    {
+        plugin_dir.join("bin").join("dbx-maven-resolver")
+    }
+}
+
+async fn jdbc_plugin_status_from_dir(plugin_dir: &Path) -> Result<JdbcPluginStatus, String> {
+    let manifest_path = plugin_dir.join("manifest.json");
+    let manifest = match std::fs::read_to_string(&manifest_path) {
+        Ok(raw) => Some(serde_json::from_str::<PluginManifest>(&raw).map_err(|err| err.to_string())?),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => None,
+        Err(err) => return Err(err.to_string()),
+    };
+    let latest = latest_jdbc_plugin().await;
+    Ok(build_plugin_status(&manifest, latest.as_ref(), plugin_dir))
+}
+
+fn build_plugin_status(
+    manifest: &Option<PluginManifest>,
+    latest: Option<&JdbcPluginLatest>,
+    plugin_dir: &Path,
+) -> JdbcPluginStatus {
+    let version = manifest.as_ref().and_then(|m| (!m.version.is_empty()).then_some(m.version.clone()));
+    let protocol_version = manifest.as_ref().map(|m| m.protocol_version);
+    let compatible = match manifest.as_ref() {
+        Some(m) => m.protocol_version == SUPPORTED_PLUGIN_PROTOCOL_VERSION,
+        None => true,
+    };
+    let latest_version = latest.map(|plugin| plugin.version.clone());
+    let latest_protocol_version = latest.map(|plugin| plugin.protocol_version);
+    let update_available = match (version.as_deref(), latest) {
+        (Some(current), Some(latest)) if manifest.is_some() => is_newer_version(&latest.version, current),
+        (None, Some(_)) if manifest.is_some() => true,
+        _ => false,
+    };
+    JdbcPluginStatus {
+        installed: manifest.is_some(),
+        version,
+        protocol_version,
+        compatible,
+        latest_version,
+        latest_protocol_version,
+        update_available,
+        path: plugin_dir.to_string_lossy().to_string(),
+    }
+}
+
+async fn latest_jdbc_plugin() -> Option<JdbcPluginLatest> {
+    // 只需 jdbc_plugin，不关心 release notes；传中文 locale 跳过英文 notes 拉取
+    fetch_latest_release("zh-CN").await.ok().and_then(|release| release.jdbc_plugin)
+}
+
+async fn download_jdbc_plugin_zip_with_progress(progress: &impl Fn(AgentProgressEvent)) -> Result<Vec<u8>, String> {
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(60))
+        .build()
+        .map_err(|err| err.to_string())?;
+
+    let mut resp =
+        crate::race_download(&client, JDBC_PLUGIN_DOWNLOAD_URL, JDBC_PLUGIN_R2_PATH, "dbx-jdbc-plugin-installer")
+            .await
+            .map_err(|err| format!("Failed to download JDBC plugin: {err}"))?;
+
+    let total = resp.content_length().unwrap_or(0);
+    progress(AgentProgressEvent::transfer("jdbc-plugin", 0, total));
+    let mut downloaded = 0;
+    let mut bytes = Vec::with_capacity(total.try_into().unwrap_or(0));
+    while let Some(chunk) = resp.chunk().await.map_err(|err| err.to_string())? {
+        downloaded += chunk.len() as u64;
+        bytes.extend_from_slice(&chunk);
+        progress(AgentProgressEvent::transfer("jdbc-plugin", downloaded, total));
+    }
+    if total == 0 {
+        progress(AgentProgressEvent::transfer("jdbc-plugin", downloaded, downloaded));
+    }
+    Ok(bytes)
+}
+
+fn install_jdbc_plugin_zip(bytes: &[u8], plugin_dir: &Path) -> Result<(), String> {
+    let cursor = std::io::Cursor::new(bytes);
+    let mut archive = zip::ZipArchive::new(cursor).map_err(|err| err.to_string())?;
+    let temp_dir = plugin_dir.with_extension("tmp");
+    if temp_dir.exists() {
+        std::fs::remove_dir_all(&temp_dir).map_err(|err| err.to_string())?;
+    }
+    std::fs::create_dir_all(&temp_dir).map_err(|err| err.to_string())?;
+
+    for index in 0..archive.len() {
+        let mut file = archive.by_index(index).map_err(|err| err.to_string())?;
+        if file.is_dir() {
+            continue;
+        }
+        let Some(enclosed) = file.enclosed_name().map(|path| path.to_path_buf()) else {
+            continue;
+        };
+        let relative = strip_zip_root(&enclosed);
+        if relative.as_os_str().is_empty() {
+            continue;
+        }
+        let output = temp_dir.join(relative);
+        if let Some(parent) = output.parent() {
+            std::fs::create_dir_all(parent).map_err(|err| err.to_string())?;
+        }
+        let mut target = std::fs::File::create(&output).map_err(|err| err.to_string())?;
+        std::io::copy(&mut file, &mut target).map_err(|err| err.to_string())?;
+    }
+
+    if !temp_dir.join("manifest.json").exists() {
+        let _ = std::fs::remove_dir_all(&temp_dir);
+        return Err("Downloaded JDBC plugin package is missing manifest.json".to_string());
+    }
+    let manifest_path = temp_dir.join("manifest.json");
+    let manifest = std::fs::read_to_string(&manifest_path)
+        .map_err(|err| format!("Failed to read downloaded JDBC plugin manifest: {err}"))?;
+    let manifest: PluginManifest = serde_json::from_str(&manifest)
+        .map_err(|err| format!("Failed to parse downloaded JDBC plugin manifest: {err}"))?;
+    if manifest.id != "jdbc" {
+        let _ = std::fs::remove_dir_all(&temp_dir);
+        return Err(format!("Downloaded plugin has unexpected id '{}'", manifest.id));
+    }
+    if manifest.protocol_version != SUPPORTED_PLUGIN_PROTOCOL_VERSION {
+        let _ = std::fs::remove_dir_all(&temp_dir);
+        return Err(format!(
+            "Downloaded JDBC plugin uses protocol version {}, but this DBX build supports protocol version {}",
+            manifest.protocol_version, SUPPORTED_PLUGIN_PROTOCOL_VERSION
+        ));
+    }
+
+    let drivers_dir = plugin_dir.join("drivers");
+    let temp_drivers_dir = temp_dir.join("drivers");
+    if drivers_dir.exists() && !temp_drivers_dir.exists() {
+        copy_dir_all(&drivers_dir, &temp_drivers_dir)?;
+    }
+    if plugin_dir.exists() {
+        std::fs::remove_dir_all(plugin_dir).map_err(|err| err.to_string())?;
+    }
+    std::fs::rename(&temp_dir, plugin_dir).map_err(|err| err.to_string())?;
+
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        for executable in ["dbx-jdbc-plugin", "dbx-maven-resolver"] {
+            let executable = plugin_dir.join("bin").join(executable);
+            if executable.exists() {
+                let mut permissions = std::fs::metadata(&executable).map_err(|err| err.to_string())?.permissions();
+                permissions.set_mode(0o755);
+                std::fs::set_permissions(executable, permissions).map_err(|err| err.to_string())?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn strip_zip_root(path: &Path) -> PathBuf {
+    let mut components = path.components();
+    let first = components.next();
+    if let (Some(std::path::Component::Normal(_)), Some(_)) = (first, components.clone().next()) {
+        components.collect()
+    } else {
+        path.to_path_buf()
+    }
+}
+
+fn copy_dir_all(source: &Path, target: &Path) -> Result<(), String> {
+    std::fs::create_dir_all(target).map_err(|err| err.to_string())?;
+    for entry in std::fs::read_dir(source).map_err(|err| err.to_string())? {
+        let entry = entry.map_err(|err| err.to_string())?;
+        let file_type = entry.file_type().map_err(|err| err.to_string())?;
+        let dest = target.join(entry.file_name());
+        if file_type.is_dir() {
+            copy_dir_all(&entry.path(), &dest)?;
+        } else {
+            std::fs::copy(entry.path(), dest).map_err(|err| err.to_string())?;
+        }
+    }
+    Ok(())
+}
+
+fn list_jdbc_drivers_from_dir(drivers_dir: &Path) -> Result<Vec<JdbcDriverInfo>, String> {
+    let entries = match std::fs::read_dir(drivers_dir) {
+        Ok(entries) => entries,
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(vec![]),
+        Err(err) => return Err(err.to_string()),
+    };
+
+    let mut drivers = Vec::new();
+    for entry in entries {
+        let entry = entry.map_err(|err| err.to_string())?;
+        let path = entry.path();
+        if path.is_dir() {
+            match path.file_name().and_then(|name| name.to_str()) {
+                Some("maven") | Some("local") => {
+                    append_jdbc_bundle_jars(&mut drivers, &path)?;
+                    continue;
+                }
+                _ => {}
+            }
+        }
+        if path.extension().and_then(|ext| ext.to_str()).map(|ext| ext.eq_ignore_ascii_case("jar")) != Some(true) {
+            continue;
+        }
+        let metadata = entry.metadata().map_err(|err| err.to_string())?;
+        drivers.push(JdbcDriverInfo {
+            name: path.file_name().and_then(|name| name.to_str()).unwrap_or("driver.jar").to_string(),
+            path: path.to_string_lossy().to_string(),
+            size: metadata.len(),
+            bundle_id: None,
+        });
+    }
+    drivers.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(drivers)
+}
+
+fn append_jdbc_bundle_jars(drivers: &mut Vec<JdbcDriverInfo>, bundles_dir: &Path) -> Result<(), String> {
+    let entries = match std::fs::read_dir(bundles_dir) {
+        Ok(entries) => entries,
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(()),
+        Err(err) => return Err(err.to_string()),
+    };
+    for entry in entries {
+        let entry = entry.map_err(|err| err.to_string())?;
+        let bundle_dir = entry.path();
+        if !bundle_dir.is_dir() {
+            continue;
+        }
+        let bundle_id = entry.file_name().to_string_lossy().to_string();
+        let jars_dir = bundle_dir.join("jars");
+        let jars = match std::fs::read_dir(&jars_dir) {
+            Ok(jars) => jars,
+            Err(err) if err.kind() == std::io::ErrorKind::NotFound => continue,
+            Err(err) => return Err(err.to_string()),
+        };
+        for jar in jars {
+            let jar = jar.map_err(|err| err.to_string())?;
+            let path = jar.path();
+            if path.extension().and_then(|ext| ext.to_str()).map(|ext| ext.eq_ignore_ascii_case("jar")) != Some(true) {
+                continue;
+            }
+            let metadata = jar.metadata().map_err(|err| err.to_string())?;
+            drivers.push(JdbcDriverInfo {
+                name: path.file_name().and_then(|name| name.to_str()).unwrap_or("driver.jar").to_string(),
+                path: path.to_string_lossy().to_string(),
+                size: metadata.len(),
+                bundle_id: Some(bundle_id.clone()),
+            });
+        }
+    }
+    Ok(())
+}
+
+fn list_jdbc_local_bundles_from_dir(local_dir: &Path) -> Result<Vec<JdbcLocalBundleInfo>, String> {
+    let entries = match std::fs::read_dir(local_dir) {
+        Ok(entries) => entries,
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(vec![]),
+        Err(err) => return Err(err.to_string()),
+    };
+    let mut bundles = Vec::new();
+    for entry in entries {
+        let entry = entry.map_err(|err| err.to_string())?;
+        let manifest_path = entry.path().join("manifest.json");
+        if !manifest_path.exists() {
+            continue;
+        }
+        let raw = std::fs::read_to_string(&manifest_path).map_err(|err| err.to_string())?;
+        bundles.push(serde_json::from_str::<JdbcLocalBundleInfo>(&raw).map_err(|err| err.to_string())?);
+    }
+    bundles.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(bundles)
+}
+
+fn install_jdbc_local_bundle(plugins_root: &Path, paths: &[String]) -> Result<(), String> {
+    let sources = paths
+        .iter()
+        .map(PathBuf::from)
+        .map(|source| {
+            if !source.exists() {
+                return Err(format!("Driver JAR does not exist: {}", source.display()));
+            }
+            if source.extension().and_then(|ext| ext.to_str()).map(|ext| ext.eq_ignore_ascii_case("jar")) != Some(true)
+            {
+                return Err(format!("Only .jar files can be imported: {}", source.display()));
+            }
+            Ok(source)
+        })
+        .collect::<Result<Vec<_>, String>>()?;
+    let name = sources
+        .first()
+        .and_then(|path| path.file_stem())
+        .and_then(|name| name.to_str())
+        .filter(|name| !name.is_empty())
+        .unwrap_or("JDBC driver")
+        .to_string();
+    let bundle_id = format!("local-{}", uuid::Uuid::new_v4().simple());
+    let bundle_dir = jdbc_local_drivers_dir(plugins_root).join(&bundle_id);
+    let temp_dir = bundle_dir.with_extension("tmp");
+    std::fs::create_dir_all(temp_dir.join("jars")).map_err(|err| err.to_string())?;
+
+    let mut artifacts = Vec::with_capacity(sources.len());
+    for source in sources {
+        let file_name = source
+            .file_name()
+            .and_then(|name| name.to_str())
+            .ok_or_else(|| format!("Invalid driver file path: {}", source.display()))?;
+        let target = unique_target_path(&temp_dir.join("jars"), file_name);
+        std::fs::copy(&source, &target)
+            .map_err(|err| format!("Failed to import {} to {}: {err}", source.display(), target.display()))?;
+        let metadata = std::fs::metadata(&target).map_err(|err| err.to_string())?;
+        let final_path = bundle_dir.join("jars").join(target.file_name().unwrap_or_default());
+        artifacts.push(JdbcLocalArtifactInfo {
+            file_name: target.file_name().and_then(|value| value.to_str()).unwrap_or(file_name).to_string(),
+            path: final_path.to_string_lossy().to_string(),
+            size: metadata.len(),
+            sha256: file_sha256(&target)?,
+        });
+    }
+    let manifest = JdbcLocalBundleInfo {
+        id: bundle_id,
+        name,
+        installed_at: chrono::Utc::now().to_rfc3339(),
+        path: bundle_dir.to_string_lossy().to_string(),
+        artifacts,
+    };
+    std::fs::write(
+        temp_dir.join("manifest.json"),
+        serde_json::to_string_pretty(&manifest).map_err(|err| err.to_string())?,
+    )
+    .map_err(|err| err.to_string())?;
+    std::fs::rename(&temp_dir, &bundle_dir).map_err(|err| err.to_string())
+}
+
+fn list_jdbc_maven_bundles_from_dir(maven_dir: &Path) -> Result<Vec<JdbcMavenBundleInfo>, String> {
+    let entries = match std::fs::read_dir(maven_dir) {
+        Ok(entries) => entries,
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(vec![]),
+        Err(err) => return Err(err.to_string()),
+    };
+    let mut bundles = Vec::new();
+    for entry in entries {
+        let entry = entry.map_err(|err| err.to_string())?;
+        let manifest_path = entry.path().join("manifest.json");
+        if !manifest_path.exists() {
+            continue;
+        }
+        let raw = std::fs::read_to_string(&manifest_path).map_err(|err| err.to_string())?;
+        bundles.push(serde_json::from_str::<JdbcMavenBundleInfo>(&raw).map_err(|err| err.to_string())?);
+    }
+    bundles.sort_by(|a, b| a.coordinate.cmp(&b.coordinate));
+    Ok(bundles)
+}
+
+fn install_jdbc_maven_bundle(
+    plugins_root: &Path,
+    coordinate: &str,
+    resolved: &MavenResolveOutput,
+) -> Result<(), String> {
+    if resolved.artifacts.is_empty() {
+        return Err("Maven resolver did not return any JAR artifacts".to_string());
+    }
+    let bundle_id = maven_bundle_id(coordinate);
+    let bundle_dir = jdbc_maven_drivers_dir(plugins_root).join(&bundle_id);
+    let temp_dir = bundle_dir.with_extension("tmp");
+    if temp_dir.exists() {
+        std::fs::remove_dir_all(&temp_dir).map_err(|err| err.to_string())?;
+    }
+    std::fs::create_dir_all(temp_dir.join("jars")).map_err(|err| err.to_string())?;
+
+    let mut artifacts = Vec::new();
+    for artifact in &resolved.artifacts {
+        if !artifact.extension.eq_ignore_ascii_case("jar") {
+            continue;
+        }
+        let source = PathBuf::from(&artifact.file);
+        if !source.exists() {
+            return Err(format!("Resolved artifact file does not exist: {}", source.display()));
+        }
+        let file_name = source
+            .file_name()
+            .and_then(|name| name.to_str())
+            .ok_or_else(|| format!("Invalid resolved artifact path: {}", source.display()))?;
+        let target = unique_target_path(&temp_dir.join("jars"), file_name);
+        std::fs::copy(&source, &target)
+            .map_err(|err| format!("Failed to copy {} to {}: {err}", source.display(), target.display()))?;
+        let metadata = std::fs::metadata(&target).map_err(|err| err.to_string())?;
+        let sha256 = file_sha256(&target)?;
+        let final_path = bundle_dir.join("jars").join(target.file_name().unwrap_or_default());
+        artifacts.push(JdbcMavenArtifactInfo {
+            group_id: artifact.group_id.clone(),
+            artifact_id: artifact.artifact_id.clone(),
+            version: artifact.version.clone(),
+            classifier: artifact.classifier.clone(),
+            extension: artifact.extension.clone(),
+            file_name: target.file_name().and_then(|name| name.to_str()).unwrap_or(file_name).to_string(),
+            path: final_path.to_string_lossy().to_string(),
+            size: metadata.len(),
+            sha256,
+        });
+    }
+    if artifacts.is_empty() {
+        return Err("Maven resolver did not return any JAR artifacts".to_string());
+    }
+    let manifest = JdbcMavenBundleInfo {
+        id: bundle_id.clone(),
+        coordinate: resolved.coordinate.clone(),
+        scope: resolved.scope.clone(),
+        repositories: resolved.repositories.clone(),
+        installed_at: chrono::Utc::now().to_rfc3339(),
+        path: bundle_dir.to_string_lossy().to_string(),
+        artifacts,
+    };
+    let manifest_json = serde_json::to_string_pretty(&manifest).map_err(|err| err.to_string())?;
+    std::fs::write(temp_dir.join("manifest.json"), manifest_json).map_err(|err| err.to_string())?;
+    if bundle_dir.exists() {
+        std::fs::remove_dir_all(&bundle_dir).map_err(|err| err.to_string())?;
+    }
+    std::fs::rename(&temp_dir, &bundle_dir).map_err(|err| err.to_string())?;
+    Ok(())
+}
+
+fn install_single_jdbc_maven_artifact(
+    plugins_root: &Path,
+    coordinate: &str,
+    group_id: &str,
+    artifact_id: &str,
+    version: &str,
+    source: &Path,
+    repositories: &[String],
+) -> Result<(), String> {
+    if !source.exists() {
+        return Err(format!("Driver JAR does not exist: {}", source.display()));
+    }
+    let bundle_id = maven_bundle_id(coordinate);
+    let bundle_dir = jdbc_maven_drivers_dir(plugins_root).join(&bundle_id);
+    let temp_dir = bundle_dir.with_extension("tmp");
+    if temp_dir.exists() {
+        std::fs::remove_dir_all(&temp_dir).map_err(|err| err.to_string())?;
+    }
+    std::fs::create_dir_all(temp_dir.join("jars")).map_err(|err| err.to_string())?;
+
+    let file_name = source
+        .file_name()
+        .and_then(|name| name.to_str())
+        .ok_or_else(|| format!("Invalid driver file path: {}", source.display()))?;
+    let target = temp_dir.join("jars").join(file_name);
+    std::fs::copy(source, &target)
+        .map_err(|err| format!("Failed to copy {} to {}: {err}", source.display(), target.display()))?;
+    let metadata = std::fs::metadata(&target).map_err(|err| err.to_string())?;
+    let final_path = bundle_dir.join("jars").join(file_name);
+    let manifest = JdbcMavenBundleInfo {
+        id: bundle_id.clone(),
+        coordinate: coordinate.to_string(),
+        scope: "runtime".to_string(),
+        repositories: repositories.to_vec(),
+        installed_at: chrono::Utc::now().to_rfc3339(),
+        path: bundle_dir.to_string_lossy().to_string(),
+        artifacts: vec![JdbcMavenArtifactInfo {
+            group_id: group_id.to_string(),
+            artifact_id: artifact_id.to_string(),
+            version: version.to_string(),
+            classifier: String::new(),
+            extension: "jar".to_string(),
+            file_name: file_name.to_string(),
+            path: final_path.to_string_lossy().to_string(),
+            size: metadata.len(),
+            sha256: file_sha256(&target)?,
+        }],
+    };
+    let manifest_json = serde_json::to_string_pretty(&manifest).map_err(|err| err.to_string())?;
+    std::fs::write(temp_dir.join("manifest.json"), manifest_json).map_err(|err| err.to_string())?;
+    if bundle_dir.exists() {
+        std::fs::remove_dir_all(&bundle_dir).map_err(|err| err.to_string())?;
+    }
+    std::fs::rename(&temp_dir, &bundle_dir).map_err(|err| err.to_string())?;
+    Ok(())
+}
+
+fn maven_bundle_id(coordinate: &str) -> String {
+    let mut id = String::with_capacity(coordinate.len());
+    for ch in coordinate.trim().chars() {
+        if ch.is_ascii_alphanumeric() || matches!(ch, '.' | '-') {
+            id.push(ch);
+        } else {
+            id.push('_');
+        }
+    }
+    if id.is_empty() {
+        "maven-driver".to_string()
+    } else {
+        id
+    }
+}
+
+fn is_safe_bundle_id(bundle_id: &str) -> bool {
+    !bundle_id.is_empty() && bundle_id.chars().all(|ch| ch.is_ascii_alphanumeric() || matches!(ch, '.' | '-' | '_'))
+}
+
+fn file_sha256(path: &Path) -> Result<String, String> {
+    let bytes = std::fs::read(path).map_err(|err| err.to_string())?;
+    let hash = Sha256::digest(bytes);
+    Ok(format!("{hash:x}"))
+}
+
+#[derive(Debug, Deserialize)]
+struct MavenResolveOutput {
+    coordinate: String,
+    scope: String,
+    repositories: Vec<String>,
+    artifacts: Vec<MavenResolvedArtifact>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct MavenResolvedArtifact {
+    group_id: String,
+    artifact_id: String,
+    version: String,
+    classifier: String,
+    extension: String,
+    file: String,
+}
+
+pub fn unique_target_path(dir: &Path, file_name: &str) -> PathBuf {
+    let target = dir.join(file_name);
+    if !target.exists() {
+        return target;
+    }
+
+    let path = Path::new(file_name);
+    let stem = path.file_stem().and_then(|value| value.to_str()).unwrap_or("driver");
+    let ext = path.extension().and_then(|value| value.to_str()).unwrap_or("jar");
+    for index in 1.. {
+        let candidate = dir.join(format!("{stem}-{index}.{ext}"));
+        if !candidate.exists() {
+            return candidate;
+        }
+    }
+    unreachable!()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::plugins::PluginRuntimeEnv;
+
+    #[test]
+    fn maven_bundle_install_lists_nested_jars() {
+        let root = std::env::temp_dir().join(format!("dbx-jdbc-maven-test-{}", uuid::Uuid::new_v4()));
+        let source_dir = root.join("source");
+        std::fs::create_dir_all(&source_dir).unwrap();
+        let source = source_dir.join("demo-driver.jar");
+        std::fs::write(&source, b"jar").unwrap();
+
+        let resolved = MavenResolveOutput {
+            coordinate: "com.example:demo-driver:1.0.0".to_string(),
+            scope: "runtime".to_string(),
+            repositories: vec!["https://repo.maven.apache.org/maven2/".to_string()],
+            artifacts: vec![MavenResolvedArtifact {
+                group_id: "com.example".to_string(),
+                artifact_id: "demo-driver".to_string(),
+                version: "1.0.0".to_string(),
+                classifier: String::new(),
+                extension: "jar".to_string(),
+                file: source.to_string_lossy().to_string(),
+            }],
+        };
+
+        install_jdbc_maven_bundle(&root, "com.example:demo-driver:1.0.0", &resolved).unwrap();
+        let drivers = list_jdbc_drivers(&root).unwrap();
+        assert_eq!(drivers.len(), 1);
+        assert_eq!(drivers[0].name, "demo-driver.jar");
+        assert_eq!(drivers[0].bundle_id.as_deref(), Some("com.example_demo-driver_1.0.0"));
+
+        let bundles = list_jdbc_maven_bundles(&root).unwrap();
+        assert_eq!(bundles.len(), 1);
+        assert_eq!(bundles[0].artifacts.len(), 1);
+
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn maven_bundle_ids_are_path_safe() {
+        assert_eq!(
+            maven_bundle_id("org.apache.hive:hive-jdbc:4.0.1:standalone"),
+            "org.apache.hive_hive-jdbc_4.0.1_standalone"
+        );
+        assert!(is_safe_bundle_id("org.apache.hive_hive-jdbc_4.0.1_standalone"));
+        assert!(!is_safe_bundle_id("../hive"));
+    }
+
+    #[test]
+    fn multiple_local_jars_are_imported_as_one_bundle() {
+        let root = std::env::temp_dir().join(format!("dbx-jdbc-local-bundle-test-{}", uuid::Uuid::new_v4()));
+        let source_dir = root.join("source");
+        std::fs::create_dir_all(&source_dir).unwrap();
+        let driver = source_dir.join("vendor-driver.jar");
+        let dependency = source_dir.join("vendor-codec.jar");
+        std::fs::write(&driver, b"driver").unwrap();
+        std::fs::write(&dependency, b"dependency").unwrap();
+
+        let paths = vec![driver.to_string_lossy().to_string(), dependency.to_string_lossy().to_string()];
+        let drivers = import_jdbc_drivers(&root, &paths).unwrap();
+        let bundles = list_jdbc_local_bundles(&root).unwrap();
+
+        assert_eq!(bundles.len(), 1);
+        assert_eq!(bundles[0].name, "vendor-driver");
+        assert_eq!(bundles[0].artifacts.len(), 2);
+        assert_eq!(drivers.len(), 2);
+        assert!(drivers.iter().all(|item| item.bundle_id.as_deref() == Some(bundles[0].id.as_str())));
+
+        let remaining = delete_jdbc_local_bundle(&root, &bundles[0].id).unwrap();
+        assert!(remaining.is_empty());
+        assert!(list_jdbc_local_bundles(&root).unwrap().is_empty());
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn single_local_jar_keeps_legacy_standalone_behavior() {
+        let root = std::env::temp_dir().join(format!("dbx-jdbc-single-jar-test-{}", uuid::Uuid::new_v4()));
+        let source = root.join("source").join("standalone.jar");
+        std::fs::create_dir_all(source.parent().unwrap()).unwrap();
+        std::fs::write(&source, b"driver").unwrap();
+
+        let drivers = import_jdbc_drivers(&root, &[source.to_string_lossy().to_string()]).unwrap();
+
+        assert_eq!(drivers.len(), 1);
+        assert_eq!(drivers[0].name, "standalone.jar");
+        assert_eq!(drivers[0].bundle_id, None);
+        assert!(list_jdbc_local_bundles(&root).unwrap().is_empty());
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[test]
+    fn installs_prestosql_direct_driver_as_builtin_bundle() {
+        let root = std::env::temp_dir().join(format!("dbx-prestosql-direct-driver-test-{}", uuid::Uuid::new_v4()));
+        let source_dir = root.join("source");
+        std::fs::create_dir_all(&source_dir).unwrap();
+        let source = source_dir.join("presto-jdbc-350.jar");
+        std::fs::write(&source, b"presto").unwrap();
+
+        install_single_jdbc_maven_artifact(
+            &root,
+            PRESTOSQL_JDBC_DRIVER_COORDINATE,
+            "io.prestosql",
+            "presto-jdbc",
+            PRESTOSQL_JDBC_DRIVER_VERSION,
+            &source,
+            &[PRESTOSQL_JDBC_DRIVER_REPOSITORY.to_string()],
+        )
+        .unwrap();
+
+        let bundles = list_jdbc_maven_bundles(&root).unwrap();
+        assert_eq!(bundles.len(), 1);
+        assert_eq!(bundles[0].id, "io.prestosql_presto-jdbc_350");
+        assert_eq!(bundles[0].coordinate, PRESTOSQL_JDBC_DRIVER_COORDINATE);
+        assert_eq!(bundles[0].artifacts[0].file_name, "presto-jdbc-350.jar");
+
+        let drivers = list_jdbc_drivers(&root).unwrap();
+        assert_eq!(drivers.len(), 1);
+        assert_eq!(drivers[0].bundle_id.as_deref(), Some("io.prestosql_presto-jdbc_350"));
+
+        let _ = std::fs::remove_dir_all(root);
+    }
+
+    #[tokio::test]
+    async fn maven_resolver_receives_runtime_env() {
+        let root = std::env::temp_dir().join(format!("dbx-jdbc-maven-env-test-{}", uuid::Uuid::new_v4()));
+        let plugin_dir = root.join("jdbc");
+        let bin_dir = plugin_dir.join("bin");
+        let source_dir = root.join("source");
+        std::fs::create_dir_all(&bin_dir).unwrap();
+        std::fs::create_dir_all(&source_dir).unwrap();
+        let source = source_dir.join("env-driver.jar");
+        std::fs::write(&source, b"jar").unwrap();
+
+        let output = serde_json::json!({
+            "coordinate": "com.example:env-driver:1.0.0",
+            "scope": "runtime",
+            "repositories": ["https://repo.maven.apache.org/maven2/"],
+            "artifacts": [{
+                "groupId": "com.example",
+                "artifactId": "env-driver",
+                "version": "1.0.0",
+                "classifier": "",
+                "extension": "jar",
+                "file": source.to_string_lossy(),
+            }],
+        })
+        .to_string();
+        let resolver = jdbc_maven_resolver_executable(&plugin_dir);
+        if cfg!(windows) {
+            std::fs::write(
+                &resolver,
+                format!(
+                    "@echo off\r\nif \"%DBX_JAVA_BIN%\"==\"\" (\r\n  echo missing DBX_JAVA_BIN 1>&2\r\n  exit /b 2\r\n)\r\necho {output}\r\n"
+                ),
+            )
+            .unwrap();
+        } else {
+            std::fs::write(
+                &resolver,
+                format!(
+                    "#!/usr/bin/env sh\nif [ -z \"${{DBX_JAVA_BIN:-}}\" ]; then\n  echo missing DBX_JAVA_BIN >&2\n  exit 2\nfi\necho '{}'\n",
+                    output.replace('\'', "'\\''")
+                ),
+            )
+            .unwrap();
+            #[cfg(unix)]
+            {
+                use std::os::unix::fs::PermissionsExt;
+                std::fs::set_permissions(&resolver, std::fs::Permissions::from_mode(0o755)).unwrap();
+            }
+        }
+
+        let drivers = install_jdbc_driver_from_maven(
+            &root,
+            JdbcMavenInstallRequest { coordinate: "com.example:env-driver:1.0.0".to_string(), repositories: vec![] },
+            PluginRuntimeEnv::default().with_var("DBX_JAVA_BIN", "java-from-managed-jre"),
+        )
+        .await
+        .unwrap();
+
+        assert_eq!(drivers.len(), 1);
+        assert_eq!(drivers[0].name, "env-driver.jar");
+
+        let _ = std::fs::remove_dir_all(root);
+    }
+}
diff --git a/crates/dbx-core/src/lib.rs b/crates/dbx-core/src/lib.rs
new file mode 100644
index 0000000..407143b
--- /dev/null
+++ b/crates/dbx-core/src/lib.rs
@@ -0,0 +1,186 @@
+pub mod agent_catalog;
+pub mod agent_connection;
+pub mod agent_events;
+pub mod agent_explain;
+pub mod agent_kv;
+pub mod agent_loop;
+pub mod agent_manager;
+pub mod agent_runtime;
+pub mod agent_service;
+pub mod agent_tools;
+pub mod ai;
+pub mod ai_cli_agent;
+pub mod ai_codex_cli;
+pub mod cloud_sync;
+pub mod connection;
+pub mod connection_secrets;
+pub mod csv_export;
+pub mod data_compare;
+pub mod data_grid_sql;
+pub mod database_capabilities;
+pub mod database_export;
+pub mod database_search_sql;
+pub mod db;
+pub mod db_admin_sql;
+pub mod document_ops;
+pub mod driver_runtime;
+pub mod external;
+pub mod history;
+pub mod jdbc;
+pub mod models;
+pub mod mongo_ops;
+#[cfg(feature = "mq-admin")]
+pub mod mq;
+pub mod nacos;
+pub mod object_source_sql;
+pub mod path_utils;
+pub mod plugins;
+pub mod process;
+pub mod production_safety;
+pub mod query;
+pub mod query_cancel;
+pub mod query_execution_sql;
+pub mod query_result_export;
+pub mod query_result_sql;
+pub mod redis_ops;
+pub mod saved_sql;
+pub mod schema;
+pub mod schema_diff;
+pub mod sql;
+pub mod sql_analysis;
+pub mod sql_dialect;
+pub mod sql_editability;
+pub mod sql_file_import;
+pub mod sql_risk;
+pub mod sqlite_backup;
+pub(crate) mod sqlserver_temporal;
+pub mod ssh_config;
+pub mod storage;
+pub mod table_export;
+pub mod table_import;
+pub mod table_structure_sql;
+pub mod text_export;
+pub mod token_usage;
+pub mod transfer;
+pub mod types;
+pub mod update;
+pub mod xlsx_export;
+
+pub const R2_CDN_BASE: &str = "https://dl.dbxio.com/";
+pub const GITHUB_RELEASE_DOWNLOAD_PREFIX: &str = "https://github.com/t8y2/dbx/releases/download/";
+pub const CNB_RELEASE_DOWNLOAD_PREFIX: &str = "https://cnb.cool/dbxio.com/dbx/-/releases/download/";
+pub const ATOMGIT_RELEASE_DOWNLOAD_PREFIX: &str = "https://atomgit.com/t8y2/dbx/releases/download/";
+
+#[derive(Clone, Copy, Debug, Default, serde::Deserialize, PartialEq, Eq, Hash)]
+#[serde(rename_all = "lowercase")]
+pub enum DownloadSource {
+    #[default]
+    Official,
+    Cnb,
+    Atomgit,
+}
+
+impl DownloadSource {
+    pub fn download_candidate_urls(self, github_url: &str, r2_path: &str) -> Result<Vec<String>, String> {
+        match self {
+            Self::Official => Ok(download_candidate_urls(github_url, r2_path)),
+            Self::Cnb => Ok(vec![
+                rewrite_github_release_url(github_url, CNB_RELEASE_DOWNLOAD_PREFIX)?,
+                format!("{R2_CDN_BASE}{r2_path}"),
+            ]),
+            Self::Atomgit => Ok(vec![
+                rewrite_github_release_url(github_url, ATOMGIT_RELEASE_DOWNLOAD_PREFIX)?,
+                format!("{R2_CDN_BASE}{r2_path}"),
+            ]),
+        }
+    }
+}
+
+fn rewrite_github_release_url(url: &str, target_prefix: &str) -> Result<String, String> {
+    if url.starts_with(target_prefix) {
+        return Ok(url.to_string());
+    }
+    url.strip_prefix(GITHUB_RELEASE_DOWNLOAD_PREFIX)
+        .map(|path| format!("{target_prefix}{path}"))
+        .ok_or_else(|| format!("Unsupported DBX release download URL: {url}"))
+}
+
+pub fn download_candidate_urls(github_url: &str, r2_path: &str) -> Vec<String> {
+    vec![format!("{R2_CDN_BASE}{r2_path}"), github_url.to_string()]
+}
+
+use std::pin::Pin;
+
+type ResponseFuture = Pin<Box<dyn std::future::Future<Output = Result<reqwest::Response, String>> + Send>>;
+
+pub async fn race_download(
+    client: &reqwest::Client,
+    github_url: &str,
+    r2_path: &str,
+    user_agent: &str,
+) -> Result<reqwest::Response, String> {
+    use futures::future::select_ok;
+
+    let urls = download_candidate_urls(github_url, r2_path);
+    let mut futs: Vec<ResponseFuture> = Vec::with_capacity(urls.len());
+
+    for url in urls {
+        let client = client.clone();
+        let ua = user_agent.to_string();
+        futs.push(Box::pin(async move {
+            client
+                .get(&url)
+                .header(reqwest::header::USER_AGENT, ua)
+                .header(reqwest::header::ACCEPT_ENCODING, "identity")
+                .send()
+                .await
+                .and_then(|r| r.error_for_status())
+                .map_err(|e| format!("{e}"))
+        }) as ResponseFuture);
+    }
+
+    match select_ok(futs).await {
+        Ok((resp, _)) => Ok(resp),
+        Err(last_err) => Err(last_err),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{download_candidate_urls, DownloadSource};
+
+    #[test]
+    fn download_candidates_exclude_third_party_github_proxy() {
+        let urls = download_candidate_urls(
+            "https://github.com/t8y2/dbx/releases/latest/download/latest.json",
+            "releases/latest/latest.json",
+        );
+
+        assert_eq!(
+            urls,
+            vec![
+                "https://dl.dbxio.com/releases/latest/latest.json",
+                "https://github.com/t8y2/dbx/releases/latest/download/latest.json",
+            ]
+        );
+    }
+
+    #[test]
+    fn mirror_download_candidates_rewrite_release_urls() {
+        let github_url = "https://github.com/t8y2/dbx/releases/download/agents-latest/agent-registry.json";
+        assert_eq!(
+            DownloadSource::Cnb.download_candidate_urls(github_url, "agents/agent-registry.json").unwrap(),
+            vec![
+                "https://cnb.cool/dbxio.com/dbx/-/releases/download/agents-latest/agent-registry.json",
+                "https://dl.dbxio.com/agents/agent-registry.json",
+            ]
+        );
+        assert_eq!(
+            DownloadSource::Atomgit.download_candidate_urls(github_url, "agents/agent-registry.json").unwrap(),
+            vec![
+                "https://atomgit.com/t8y2/dbx/releases/download/agents-latest/agent-registry.json",
+                "https://dl.dbxio.com/agents/agent-registry.json",
+            ]
+        );
+    }
+}
diff --git a/crates/dbx-core/src/models/connection.rs b/crates/dbx-core/src/models/connection.rs
new file mode 100644
index 0000000..cb4c104
--- /dev/null
+++ b/crates/dbx-core/src/models/connection.rs
@@ -0,0 +1,3055 @@
+use percent_encoding::{percent_decode_str, utf8_percent_encode, NON_ALPHANUMERIC};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Serialize, PartialEq)]
+pub struct ConnectionConfig {
+    pub id: String,
+    pub name: String,
+    pub db_type: DatabaseType,
+    #[serde(default)]
+    pub driver_profile: Option<String>,
+    #[serde(default)]
+    pub driver_label: Option<String>,
+    #[serde(default)]
+    pub url_params: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub agent_java_options: Vec<String>,
+    pub host: String,
+    pub port: u16,
+    pub username: String,
+    pub password: String,
+    pub database: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub visible_databases: Option<Vec<String>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub visible_schemas: Option<HashMap<String, Vec<String>>>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub attached_databases: Vec<AttachedDatabaseConfig>,
+    #[serde(default)]
+    pub color: Option<String>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub transport_layers: Vec<TransportLayerConfig>,
+    #[serde(default = "default_connect_timeout_secs")]
+    pub connect_timeout_secs: u64,
+    #[serde(default = "default_query_timeout_secs")]
+    pub query_timeout_secs: u64,
+    #[serde(default = "default_idle_timeout_secs")]
+    pub idle_timeout_secs: u64,
+    #[serde(default = "default_keepalive_interval_secs")]
+    pub keepalive_interval_secs: u64,
+    #[serde(default)]
+    pub ssl: bool,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub ca_cert_path: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub client_cert_path: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub client_key_path: String,
+    #[serde(default)]
+    pub sysdba: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub oracle_connection_type: Option<String>,
+    #[serde(default)]
+    pub connection_string: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub redis_connection_mode: Option<String>,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub redis_sentinel_master: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub redis_sentinel_nodes: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub redis_sentinel_username: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub redis_sentinel_password: String,
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub redis_sentinel_tls: bool,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub redis_cluster_nodes: String,
+    #[serde(default = "default_redis_key_separator", skip_serializing_if = "is_default_redis_separator")]
+    pub redis_key_separator: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub redis_scan_page_size: Option<u64>,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub etcd_endpoints: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub gbase_server: String,
+    /// Informix server name (INFORMIXSERVER). When empty, the agent
+    /// derives it from the hostname.
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub informix_server: String,
+    /// Typed configuration for external tabular sources.
+    #[serde(default)]
+    pub external_config: Option<serde_json::Value>,
+    #[serde(default)]
+    pub jdbc_driver_class: Option<String>,
+    #[serde(default)]
+    pub jdbc_driver_paths: Vec<String>,
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub one_time: bool,
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub read_only: bool,
+    /// Explicitly marks every database reachable through this connection as production.
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub is_production: bool,
+    /// Database-level production markers for multi-database connections.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub production_databases: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(tag = "type", rename_all = "lowercase")]
+pub enum TransportLayerConfig {
+    Ssh(SshTunnelConfig),
+    Proxy(ProxyTunnelConfig),
+    #[serde(rename = "http_tunnel")]
+    HttpTunnel(HttpTunnelConfig),
+}
+
+impl TransportLayerConfig {
+    pub fn same_type_as(&self, other: &TransportLayerConfig) -> bool {
+        matches!(
+            (self, other),
+            (TransportLayerConfig::Ssh(_), TransportLayerConfig::Ssh(_))
+                | (TransportLayerConfig::Proxy(_), TransportLayerConfig::Proxy(_))
+                | (TransportLayerConfig::HttpTunnel(_), TransportLayerConfig::HttpTunnel(_))
+        )
+    }
+
+    pub fn id(&self) -> &str {
+        match self {
+            TransportLayerConfig::Ssh(layer) => &layer.id,
+            TransportLayerConfig::Proxy(layer) => &layer.id,
+            TransportLayerConfig::HttpTunnel(layer) => &layer.id,
+        }
+    }
+
+    pub fn profile_id(&self) -> &str {
+        match self {
+            TransportLayerConfig::Ssh(layer) => &layer.profile_id,
+            TransportLayerConfig::Proxy(layer) => &layer.profile_id,
+            TransportLayerConfig::HttpTunnel(layer) => &layer.profile_id,
+        }
+    }
+
+    /// Builds the concrete layer used at connect time for a layer that
+    /// references a shared tunnel profile: the profile supplies the whole
+    /// configuration while the referencing layer keeps its own identity,
+    /// enabled flag, and profile reference.
+    pub fn resolved_from_profile(&self, profile: &TransportLayerConfig) -> TransportLayerConfig {
+        let mut resolved = profile.clone();
+        let (id, enabled, profile_id) = (self.id().to_string(), self.enabled(), self.profile_id().to_string());
+        match &mut resolved {
+            TransportLayerConfig::Ssh(layer) => {
+                layer.id = id;
+                layer.enabled = enabled;
+                layer.profile_id = profile_id;
+            }
+            TransportLayerConfig::Proxy(layer) => {
+                layer.id = id;
+                layer.enabled = enabled;
+                layer.profile_id = profile_id;
+            }
+            TransportLayerConfig::HttpTunnel(layer) => {
+                layer.id = id;
+                layer.enabled = enabled;
+                layer.profile_id = profile_id;
+            }
+        }
+        resolved
+    }
+
+    pub fn scrub_secrets(&mut self) {
+        match self {
+            TransportLayerConfig::Ssh(layer) => {
+                layer.password = String::new();
+                layer.key_passphrase = String::new();
+            }
+            TransportLayerConfig::Proxy(layer) => {
+                layer.password = String::new();
+            }
+            TransportLayerConfig::HttpTunnel(layer) => {
+                layer.token = String::new();
+            }
+        }
+    }
+
+    pub fn name(&self) -> &str {
+        match self {
+            TransportLayerConfig::Ssh(layer) => &layer.name,
+            TransportLayerConfig::Proxy(layer) => &layer.name,
+            TransportLayerConfig::HttpTunnel(layer) => &layer.name,
+        }
+    }
+
+    pub fn enabled(&self) -> bool {
+        match self {
+            TransportLayerConfig::Ssh(layer) => layer.enabled,
+            TransportLayerConfig::Proxy(layer) => layer.enabled,
+            TransportLayerConfig::HttpTunnel(layer) => layer.enabled,
+        }
+    }
+
+    pub fn endpoint(&self) -> (&str, u16) {
+        match self {
+            TransportLayerConfig::Ssh(layer) => (&layer.host, layer.port),
+            TransportLayerConfig::Proxy(layer) => (&layer.host, layer.port),
+            // HTTP script tunnel layers dial a PHP script URL instead of a host:port
+            // endpoint, and are validated as the outermost transport layer.
+            TransportLayerConfig::HttpTunnel(_) => ("", 0),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct SshTunnelConfig {
+    #[serde(default)]
+    pub id: String,
+    #[serde(default)]
+    pub name: String,
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+    #[serde(default)]
+    pub host: String,
+    #[serde(default = "default_ssh_port")]
+    pub port: u16,
+    #[serde(default)]
+    pub user: String,
+    #[serde(default)]
+    pub password: String,
+    #[serde(default)]
+    pub key_path: String,
+    #[serde(default)]
+    pub key_passphrase: String,
+    #[serde(default = "default_ssh_connect_timeout_secs")]
+    pub connect_timeout_secs: u64,
+    #[serde(default)]
+    pub expose_lan: bool,
+    #[serde(default)]
+    pub use_ssh_agent: bool,
+    /// Custom SSH agent socket path (e.g. `~/.ssh/agent.sock`).
+    /// When set and `use_ssh_agent` is true, this path is used instead of
+    /// the `SSH_AUTH_SOCK` environment variable.
+    #[serde(default)]
+    pub ssh_agent_sock_path: String,
+    /// Login method: `"password"`, `"key"`, `"agent"`, or `"none"`.
+    /// Empty string means an older saved connection predating this field —
+    /// the backend falls back to probing key > password > agent based on
+    /// which fields are non-empty. When set to a specific method the backend
+    /// only tries that method (after the standard `none` probe).
+    #[serde(default)]
+    pub auth_method: String,
+    /// When non-empty, this layer references a shared tunnel profile
+    /// (Settings > Tunnels). The profile's configuration replaces this
+    /// layer's own fields at connect time; only `id` and `enabled` are
+    /// kept from the referencing layer.
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub profile_id: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ProxyTunnelConfig {
+    #[serde(default)]
+    pub id: String,
+    #[serde(default)]
+    pub name: String,
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+    #[serde(default)]
+    pub proxy_type: ProxyType,
+    #[serde(default)]
+    pub host: String,
+    #[serde(default = "default_proxy_port")]
+    pub port: u16,
+    #[serde(default)]
+    pub username: String,
+    #[serde(default)]
+    pub password: String,
+    /// See [`SshTunnelConfig::profile_id`].
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub profile_id: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct HttpTunnelConfig {
+    #[serde(default)]
+    pub id: String,
+    #[serde(default)]
+    pub name: String,
+    #[serde(default = "default_true")]
+    pub enabled: bool,
+    #[serde(default)]
+    pub url: String,
+    #[serde(default)]
+    pub token: String,
+    #[serde(default = "default_http_tunnel_connect_timeout_secs")]
+    pub connect_timeout_secs: u64,
+    /// See [`SshTunnelConfig::profile_id`].
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub profile_id: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct AttachedDatabaseConfig {
+    pub name: String,
+    pub path: String,
+}
+
+fn default_true() -> bool {
+    true
+}
+
+fn default_ssh_port() -> u16 {
+    22
+}
+
+pub fn default_ssh_connect_timeout_secs() -> u64 {
+    5
+}
+
+pub fn default_http_tunnel_connect_timeout_secs() -> u64 {
+    10
+}
+
+pub fn default_connect_timeout_secs() -> u64 {
+    10
+}
+
+pub fn default_query_timeout_secs() -> u64 {
+    60
+}
+
+pub fn default_idle_timeout_secs() -> u64 {
+    60
+}
+
+pub fn default_keepalive_interval_secs() -> u64 {
+    30
+}
+
+fn default_proxy_port() -> u16 {
+    1080
+}
+
+fn is_false(value: &bool) -> bool {
+    !*value
+}
+
+pub fn default_redis_key_separator() -> String {
+    ":".to_string()
+}
+
+fn is_default_redis_separator(value: &str) -> bool {
+    value == ":"
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "lowercase")]
+#[derive(Default)]
+pub enum ProxyType {
+    #[default]
+    Socks5,
+    Http,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "lowercase")]
+pub enum DatabaseType {
+    Mysql,
+    Postgres,
+    Sqlite,
+    Rqlite,
+    Redis,
+    #[serde(rename = "duckdb")]
+    DuckDb,
+    #[serde(rename = "clickhouse")]
+    ClickHouse,
+    #[serde(rename = "sqlserver")]
+    SqlServer,
+    #[serde(rename = "mongodb")]
+    MongoDb,
+    #[serde(rename = "oracle")]
+    Oracle,
+    #[serde(rename = "elasticsearch")]
+    Elasticsearch,
+    #[serde(rename = "qdrant")]
+    Qdrant,
+    #[serde(rename = "milvus")]
+    Milvus,
+    #[serde(rename = "weaviate")]
+    Weaviate,
+    #[serde(rename = "chromadb")]
+    ChromaDb,
+    Doris,
+    #[serde(rename = "starrocks")]
+    StarRocks,
+    #[serde(rename = "manticoresearch")]
+    ManticoreSearch,
+    Databend,
+    Redshift,
+    Dameng,
+    Kingbase,
+    Highgo,
+    Vastbase,
+    Goldendb,
+    Gaussdb,
+    Kwdb,
+    Yashandb,
+    Databricks,
+    #[serde(rename = "saphana")]
+    SapHana,
+    Teradata,
+    Vertica,
+    Firebird,
+    Exasol,
+    #[serde(rename = "opengauss")]
+    OpenGauss,
+    #[serde(rename = "oceanbase-oracle")]
+    OceanbaseOracle,
+    Gbase,
+    Access,
+    #[serde(rename = "h2")]
+    H2,
+    Snowflake,
+    Trino,
+    #[serde(rename = "prestosql")]
+    PrestoSql,
+    Hive,
+    Spark,
+    #[serde(rename = "db2")]
+    Db2,
+    Informix,
+    #[serde(rename = "neo4j")]
+    Neo4j,
+    Cassandra,
+    #[serde(rename = "bigquery")]
+    Bigquery,
+    Kylin,
+    Sundb,
+    Oscar,
+    Tdengine,
+    Xugu,
+    Iotdb,
+    Etcd,
+    #[serde(rename = "zookeeper")]
+    ZooKeeper,
+    Nacos,
+    #[serde(rename = "iris")]
+    Iris,
+    #[serde(rename = "turso")]
+    Turso,
+    #[serde(rename = "cloudflare-d1")]
+    CloudflareD1,
+    #[serde(rename = "influxdb")]
+    InfluxDb,
+    #[serde(rename = "questdb")]
+    Questdb,
+    Jdbc,
+    /// Message queue admin connection (Pulsar / Kafka / RocketMQ). The specific
+    /// system is determined by `external_config.systemKind`.
+    #[serde(rename = "mq")]
+    MessageQueue,
+}
+
+#[derive(Deserialize)]
+struct ConnectionConfigData {
+    pub id: String,
+    pub name: String,
+    pub db_type: DatabaseType,
+    #[serde(default)]
+    pub driver_profile: Option<String>,
+    #[serde(default)]
+    pub driver_label: Option<String>,
+    #[serde(default)]
+    pub url_params: Option<String>,
+    #[serde(default)]
+    pub agent_java_options: Vec<String>,
+    pub host: String,
+    pub port: u16,
+    pub username: String,
+    pub password: String,
+    pub database: Option<String>,
+    #[serde(default)]
+    pub visible_databases: Option<Vec<String>>,
+    #[serde(default)]
+    pub visible_schemas: Option<HashMap<String, Vec<String>>>,
+    #[serde(default)]
+    pub attached_databases: Vec<AttachedDatabaseConfig>,
+    #[serde(default)]
+    pub color: Option<String>,
+    #[serde(default)]
+    pub transport_layers: Vec<TransportLayerConfig>,
+    #[serde(default = "default_connect_timeout_secs")]
+    pub connect_timeout_secs: u64,
+    #[serde(default = "default_query_timeout_secs")]
+    pub query_timeout_secs: u64,
+    #[serde(default = "default_idle_timeout_secs")]
+    pub idle_timeout_secs: u64,
+    #[serde(default = "default_keepalive_interval_secs")]
+    pub keepalive_interval_secs: u64,
+    #[serde(default)]
+    pub ssl: bool,
+    #[serde(default)]
+    pub ca_cert_path: String,
+    #[serde(default)]
+    pub client_cert_path: String,
+    #[serde(default)]
+    pub client_key_path: String,
+    #[serde(default)]
+    pub sysdba: bool,
+    #[serde(default)]
+    pub oracle_connection_type: Option<String>,
+    #[serde(default)]
+    pub connection_string: Option<String>,
+    #[serde(default)]
+    pub redis_connection_mode: Option<String>,
+    #[serde(default)]
+    pub redis_sentinel_master: String,
+    #[serde(default)]
+    pub redis_sentinel_nodes: String,
+    #[serde(default)]
+    pub redis_sentinel_username: String,
+    #[serde(default)]
+    pub redis_sentinel_password: String,
+    #[serde(default)]
+    pub redis_sentinel_tls: bool,
+    #[serde(default)]
+    pub redis_cluster_nodes: String,
+    #[serde(default = "default_redis_key_separator")]
+    pub redis_key_separator: String,
+    #[serde(default)]
+    pub redis_scan_page_size: Option<u64>,
+    #[serde(default)]
+    pub etcd_endpoints: String,
+    #[serde(default)]
+    pub gbase_server: String,
+    #[serde(default)]
+    pub informix_server: String,
+    #[serde(default)]
+    pub external_config: Option<serde_json::Value>,
+    #[serde(default)]
+    pub jdbc_driver_class: Option<String>,
+    #[serde(default)]
+    pub jdbc_driver_paths: Vec<String>,
+    #[serde(default)]
+    pub one_time: bool,
+    #[serde(default)]
+    pub read_only: bool,
+    #[serde(default)]
+    pub is_production: bool,
+    #[serde(default)]
+    pub production_databases: Vec<String>,
+}
+
+impl From<ConnectionConfigData> for ConnectionConfig {
+    fn from(data: ConnectionConfigData) -> Self {
+        Self {
+            id: data.id,
+            name: data.name,
+            db_type: data.db_type,
+            driver_profile: data.driver_profile,
+            driver_label: data.driver_label,
+            url_params: data.url_params,
+            agent_java_options: data.agent_java_options,
+            host: data.host,
+            port: data.port,
+            username: data.username,
+            password: data.password,
+            database: data.database,
+            visible_databases: data.visible_databases,
+            visible_schemas: data.visible_schemas,
+            attached_databases: data.attached_databases,
+            color: data.color,
+            transport_layers: data.transport_layers,
+            connect_timeout_secs: data.connect_timeout_secs,
+            query_timeout_secs: data.query_timeout_secs,
+            idle_timeout_secs: data.idle_timeout_secs,
+            keepalive_interval_secs: data.keepalive_interval_secs,
+            ssl: data.ssl,
+            ca_cert_path: data.ca_cert_path,
+            client_cert_path: data.client_cert_path,
+            client_key_path: data.client_key_path,
+            sysdba: data.sysdba,
+            oracle_connection_type: data.oracle_connection_type,
+            connection_string: data.connection_string,
+            redis_connection_mode: data.redis_connection_mode,
+            redis_sentinel_master: data.redis_sentinel_master,
+            redis_sentinel_nodes: data.redis_sentinel_nodes,
+            redis_sentinel_username: data.redis_sentinel_username,
+            redis_sentinel_password: data.redis_sentinel_password,
+            redis_sentinel_tls: data.redis_sentinel_tls,
+            redis_cluster_nodes: data.redis_cluster_nodes,
+            redis_key_separator: data.redis_key_separator,
+            redis_scan_page_size: data.redis_scan_page_size,
+            etcd_endpoints: data.etcd_endpoints,
+            gbase_server: data.gbase_server,
+            informix_server: data.informix_server,
+            external_config: data.external_config,
+            jdbc_driver_class: data.jdbc_driver_class,
+            jdbc_driver_paths: data.jdbc_driver_paths,
+            one_time: data.one_time,
+            read_only: data.read_only,
+            is_production: data.is_production,
+            production_databases: data.production_databases,
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for ConnectionConfig {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let mut value = Value::deserialize(deserializer)?;
+        migrate_legacy_transport_layers(&mut value);
+        let data = ConnectionConfigData::deserialize(value).map_err(serde::de::Error::custom)?;
+        Ok(data.into())
+    }
+}
+
+fn migrate_legacy_transport_layers(value: &mut Value) {
+    let Some(object) = value.as_object_mut() else {
+        return;
+    };
+    if object.get("transport_layers").and_then(Value::as_array).is_some_and(|layers| !layers.is_empty()) {
+        return;
+    }
+
+    let mut layers = Vec::new();
+    let ssh_enabled = object.get("ssh_enabled").and_then(Value::as_bool).unwrap_or(false);
+    if ssh_enabled {
+        if let Some(ssh_tunnels) = object.get("ssh_tunnels").and_then(Value::as_array) {
+            for hop in ssh_tunnels {
+                let mut layer = hop.clone();
+                if let Some(layer_object) = layer.as_object_mut() {
+                    layer_object.insert("type".to_string(), Value::String("ssh".to_string()));
+                }
+                layers.push(layer);
+            }
+        }
+
+        if layers.is_empty() && string_field(object, "ssh_host").is_some() {
+            let mut layer = serde_json::Map::new();
+            layer.insert("type".to_string(), Value::String("ssh".to_string()));
+            layer.insert("id".to_string(), Value::String("legacy".to_string()));
+            layer.insert("enabled".to_string(), Value::Bool(true));
+            copy_string(object, &mut layer, "ssh_host", "host");
+            copy_u64(object, &mut layer, "ssh_port", "port", default_ssh_port() as u64);
+            copy_string(object, &mut layer, "ssh_user", "user");
+            copy_string(object, &mut layer, "ssh_password", "password");
+            copy_string(object, &mut layer, "ssh_key_path", "key_path");
+            copy_string(object, &mut layer, "ssh_key_passphrase", "key_passphrase");
+            copy_u64(
+                object,
+                &mut layer,
+                "ssh_connect_timeout_secs",
+                "connect_timeout_secs",
+                default_ssh_connect_timeout_secs(),
+            );
+            copy_bool(object, &mut layer, "ssh_expose_lan", "expose_lan");
+            layers.push(Value::Object(layer));
+        }
+    }
+
+    let proxy_enabled = object.get("proxy_enabled").and_then(Value::as_bool).unwrap_or(false);
+    if proxy_enabled && string_field(object, "proxy_host").is_some() {
+        let mut layer = serde_json::Map::new();
+        layer.insert("type".to_string(), Value::String("proxy".to_string()));
+        layer.insert("id".to_string(), Value::String("legacy-proxy".to_string()));
+        layer.insert("enabled".to_string(), Value::Bool(true));
+        copy_string(object, &mut layer, "proxy_type", "proxy_type");
+        copy_string(object, &mut layer, "proxy_host", "host");
+        copy_u64(object, &mut layer, "proxy_port", "port", default_proxy_port() as u64);
+        copy_string(object, &mut layer, "proxy_username", "username");
+        copy_string(object, &mut layer, "proxy_password", "password");
+        layers.push(Value::Object(layer));
+    }
+
+    if !layers.is_empty() {
+        object.insert("transport_layers".to_string(), Value::Array(layers));
+    }
+}
+
+fn string_field(object: &serde_json::Map<String, Value>, key: &str) -> Option<String> {
+    object.get(key).and_then(Value::as_str).map(str::trim).filter(|value| !value.is_empty()).map(str::to_string)
+}
+
+fn copy_string(
+    object: &serde_json::Map<String, Value>,
+    target: &mut serde_json::Map<String, Value>,
+    from: &str,
+    to: &str,
+) {
+    if let Some(value) = object.get(from).and_then(Value::as_str) {
+        target.insert(to.to_string(), Value::String(value.to_string()));
+    }
+}
+
+fn copy_bool(
+    object: &serde_json::Map<String, Value>,
+    target: &mut serde_json::Map<String, Value>,
+    from: &str,
+    to: &str,
+) {
+    if let Some(value) = object.get(from).and_then(Value::as_bool) {
+        target.insert(to.to_string(), Value::Bool(value));
+    }
+}
+
+fn copy_u64(
+    object: &serde_json::Map<String, Value>,
+    target: &mut serde_json::Map<String, Value>,
+    from: &str,
+    to: &str,
+    default: u64,
+) {
+    let value = object.get(from).and_then(Value::as_u64).filter(|value| *value > 0).unwrap_or(default);
+    target.insert(to.to_string(), Value::Number(value.into()));
+}
+
+impl ConnectionConfig {
+    pub fn effective_transport_layers(&self) -> Vec<TransportLayerConfig> {
+        self.transport_layers.iter().filter(|layer| layer.enabled()).cloned().collect()
+    }
+
+    pub fn effective_ssh_tunnels(&self) -> Vec<SshTunnelConfig> {
+        self.effective_transport_layers()
+            .into_iter()
+            .filter_map(|layer| match layer {
+                TransportLayerConfig::Ssh(ssh) => Some(ssh),
+                TransportLayerConfig::Proxy(_) | TransportLayerConfig::HttpTunnel(_) => None,
+            })
+            .collect()
+    }
+
+    pub fn has_effective_transport_layers(&self) -> bool {
+        !self.effective_transport_layers().is_empty()
+    }
+
+    pub fn has_effective_ssh_tunnels(&self) -> bool {
+        self.effective_transport_layers().iter().any(|layer| matches!(layer, TransportLayerConfig::Ssh(_)))
+    }
+
+    pub fn effective_connect_timeout_secs(&self) -> u64 {
+        if self.connect_timeout_secs == 0 {
+            default_connect_timeout_secs()
+        } else {
+            self.connect_timeout_secs.clamp(1, 300)
+        }
+    }
+
+    pub fn effective_query_timeout_secs(&self) -> u64 {
+        if self.query_timeout_secs == 0 {
+            0
+        } else {
+            self.query_timeout_secs.max(1)
+        }
+    }
+
+    pub fn effective_database(&self) -> Option<&str> {
+        self.database
+            .as_deref()
+            .map(str::trim)
+            .filter(|database| !database.is_empty())
+            .or_else(|| self.default_database())
+    }
+
+    fn default_database(&self) -> Option<&'static str> {
+        match self.db_type {
+            DatabaseType::Postgres => match self.driver_profile.as_deref() {
+                Some("cockroachdb") => Some("defaultdb"),
+                _ => Some("postgres"),
+            },
+            DatabaseType::Redshift => Some("dev"),
+            DatabaseType::ClickHouse => Some("default"),
+            DatabaseType::Rqlite | DatabaseType::Turso | DatabaseType::CloudflareD1 => Some("main"),
+            DatabaseType::Gaussdb | DatabaseType::OpenGauss => Some("postgres"),
+            DatabaseType::Kwdb => Some("defaultdb"),
+            DatabaseType::Vastbase => Some("postgres"),
+            DatabaseType::Highgo => Some("highgo"),
+            DatabaseType::Yashandb => Some("yasdb"),
+            DatabaseType::Oscar => Some("osrdb"),
+            DatabaseType::Firebird => Some("employee"),
+            DatabaseType::H2 => Some("test"),
+            DatabaseType::Informix => Some("sysmaster"),
+            DatabaseType::Neo4j => Some("neo4j"),
+            _ => None,
+        }
+    }
+
+    pub fn needs_bare_mysql(&self) -> bool {
+        matches!(self.db_type, DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::ManticoreSearch)
+            || self.driver_profile.as_deref().map(|p| p.to_lowercase()).is_some_and(|p| {
+                matches!(p.as_str(), "doris" | "starrocks" | "manticoresearch" | "selectdb" | "oceanbase")
+            })
+    }
+
+    pub fn is_starrocks(&self) -> bool {
+        self.db_type == DatabaseType::StarRocks
+            || self.driver_profile.as_deref().is_some_and(|profile| profile.eq_ignore_ascii_case("starrocks"))
+    }
+
+    pub fn bare_mysql_supports_tls(&self) -> bool {
+        self.is_starrocks()
+    }
+
+    pub fn bare_mysql_uses_tls(&self) -> bool {
+        if !self.bare_mysql_supports_tls() {
+            return false;
+        }
+        if mysql_url_params_tls_disabled(self.url_params.as_deref()) {
+            return false;
+        }
+        self.mysql_uses_tls()
+    }
+
+    pub fn canonicalized(&self) -> Self {
+        let mut config = self.clone();
+        if config.db_type == DatabaseType::Mysql
+            && config.driver_profile.as_deref().is_some_and(|profile| profile.eq_ignore_ascii_case("tdengine"))
+        {
+            config.db_type = DatabaseType::Tdengine;
+            if config.port == 0 || config.port == 6030 {
+                config.port = 6041;
+            }
+            config.driver_profile = Some("tdengine".to_string());
+            if config.driver_label.as_deref().unwrap_or("").trim().is_empty() {
+                config.driver_label = Some("TDengine".to_string());
+            }
+        }
+        config
+    }
+
+    pub fn uses_redis_sentinel(&self) -> bool {
+        self.db_type == DatabaseType::Redis
+            && self.redis_connection_mode.as_deref().is_some_and(|mode| mode.eq_ignore_ascii_case("sentinel"))
+    }
+
+    pub fn uses_redis_cluster(&self) -> bool {
+        self.db_type == DatabaseType::Redis
+            && self.redis_connection_mode.as_deref().is_some_and(|mode| mode.eq_ignore_ascii_case("cluster"))
+    }
+
+    pub fn redis_tls_insecure(&self) -> bool {
+        self.db_type == DatabaseType::Redis && redis_url_params_enable_insecure(self.url_params.as_deref())
+    }
+
+    pub fn connection_url(&self) -> String {
+        self.connection_url_with_host(&self.host, self.port)
+    }
+
+    pub fn redacted_connection_url(&self) -> String {
+        self.redacted_connection_url_with_host(&self.host, self.port)
+    }
+
+    pub fn redacted_connection_url_with_host(&self, host: &str, port: u16) -> String {
+        let raw_host = host;
+        let host = bracket_ipv6(host);
+        let db_part = self.effective_database().map(|d| format!("/{}", encode_url_part(d))).unwrap_or_default();
+        let params = self.normalized_url_params();
+
+        match self.db_type {
+            DatabaseType::Sqlite | DatabaseType::DuckDb => {
+                format!("{}?mode=rwc", self.host)
+            }
+            DatabaseType::Access => self.host.clone(),
+            DatabaseType::Redis => {
+                let scheme = if self.ssl { "rediss" } else { "redis" };
+                let fragment = self.redis_tls_insecure_fragment();
+                format!("{scheme}://{host}:{port}/{fragment}")
+            }
+            DatabaseType::Mysql
+            | DatabaseType::Doris
+            | DatabaseType::StarRocks
+            | DatabaseType::ManticoreSearch
+            | DatabaseType::Databend => {
+                let suffix = if params.is_empty() { String::new() } else { format!("?{params}") };
+                format!("mysql://{host}:{port}{db_part}{suffix}")
+            }
+            DatabaseType::Postgres | DatabaseType::Redshift => {
+                let suffix = if params.is_empty() { String::new() } else { format!("?{params}") };
+                format!("postgres://{host}:{port}{db_part}{suffix}")
+            }
+            DatabaseType::ClickHouse => clickhouse_http_url(self, raw_host, port),
+            DatabaseType::Rqlite => rqlite_http_url(self, raw_host, port),
+            DatabaseType::Turso => turso_http_url(self, raw_host, port),
+            DatabaseType::CloudflareD1 => cloudflare_d1_api_url(self),
+            DatabaseType::SqlServer => {
+                format!("server=tcp:{host},{port};database={}", self.database.as_deref().unwrap_or("master"))
+            }
+            DatabaseType::MongoDb => {
+                let is_tunneled = host != self.host.as_str() || port != self.port;
+                if let Some(cs) = self.connection_string.as_deref().filter(|s| !s.is_empty()) {
+                    let cs = normalize_mongo_uri_direct_connection(cs);
+                    if is_tunneled {
+                        return rewrite_mongo_uri_host(&cs, &host, port);
+                    }
+                    return cs;
+                }
+                let mut suffix = if params.is_empty() { String::new() } else { format!("?{params}") };
+                if is_tunneled && !suffix.contains("directConnection=") {
+                    if suffix.is_empty() {
+                        suffix = "?directConnection=true".to_string();
+                    } else {
+                        suffix.push_str("&directConnection=true");
+                    }
+                }
+                let db_part = mongo_uri_db_part_for_suffix(&db_part, &suffix);
+                format!("mongodb://{host}:{port}{db_part}{suffix}")
+            }
+            DatabaseType::Oracle => format!("oracle://{host}:{port}{db_part}"),
+            DatabaseType::Elasticsearch
+            | DatabaseType::Qdrant
+            | DatabaseType::Milvus
+            | DatabaseType::Weaviate
+            | DatabaseType::ChromaDb => {
+                let scheme = if self.ssl { "https" } else { "http" };
+                format!("{scheme}://{host}:{port}")
+            }
+            DatabaseType::Dameng => format!("dm://{host}:{port}{db_part}"),
+            DatabaseType::Kingbase => format!("kingbase://{host}:{port}{db_part}"),
+            DatabaseType::Highgo => format!("highgo://{host}:{port}{db_part}"),
+            DatabaseType::Vastbase => format!("vastbase://{host}:{port}{db_part}"),
+            DatabaseType::Goldendb => format!("goldendb://{host}:{port}{db_part}"),
+            DatabaseType::Gaussdb => format!("gaussdb://{host}:{port}{db_part}"),
+            DatabaseType::Kwdb => format!("kwdb://{host}:{port}{db_part}"),
+            DatabaseType::Yashandb => format!("yashandb://{host}:{port}{db_part}"),
+            DatabaseType::Databricks => format!("databricks://{host}:{port}{db_part}"),
+            DatabaseType::SapHana => format!("saphana://{host}:{port}{db_part}"),
+            DatabaseType::Teradata => format!("teradata://{host}:{port}{db_part}"),
+            DatabaseType::Vertica => format!("vertica://{host}:{port}{db_part}"),
+            DatabaseType::Firebird => format!("firebird://{host}:{port}{db_part}"),
+            DatabaseType::Exasol => format!("exasol://{host}:{port}{db_part}"),
+            DatabaseType::OpenGauss => format!("opengauss://{host}:{port}{db_part}"),
+            DatabaseType::OceanbaseOracle => {
+                let base = format!("oceanbase-oracle://{host}:{port}{db_part}");
+                if params.is_empty() {
+                    base
+                } else {
+                    format!("{base}?{params}")
+                }
+            }
+            DatabaseType::Questdb => format!("questdb://{host}:{port}{db_part}"),
+            DatabaseType::Gbase => format!("gbase://{host}:{port}{db_part}"),
+            DatabaseType::H2 => format!("h2://{host}:{port}{db_part}"),
+            DatabaseType::Snowflake => format!("snowflake://{host}/{db_part}"),
+            DatabaseType::Trino => format!("trino://{host}:{port}{db_part}"),
+            DatabaseType::PrestoSql => format!("prestosql://{host}:{port}{db_part}"),
+            DatabaseType::Hive => format!("hive://{host}:{port}{db_part}"),
+            DatabaseType::Spark => format!("spark://{host}:{port}{db_part}"),
+            DatabaseType::Db2 => format!("db2://{host}:{port}{db_part}"),
+            DatabaseType::Informix => format!("informix://{host}:{port}{db_part}"),
+            DatabaseType::Neo4j => format!("neo4j://{host}:{port}{db_part}"),
+            DatabaseType::Cassandra => format!("cassandra://{host}:{port}{db_part}"),
+            DatabaseType::Bigquery => format!("bigquery://{host}/{db_part}"),
+            DatabaseType::Kylin => format!("kylin://{host}:{port}{db_part}"),
+            DatabaseType::Sundb => format!("sundb://{host}:{port}{db_part}"),
+            DatabaseType::Oscar => format!("oscar://{host}:{port}{db_part}"),
+            DatabaseType::Tdengine => format!("tdengine://{host}:{port}{db_part}"),
+            DatabaseType::Xugu => format!("xugu://{host}:{port}{db_part}"),
+            DatabaseType::Iotdb => {
+                let base = format!("iotdb://{host}:{port}{db_part}");
+                if params.is_empty() {
+                    base
+                } else {
+                    format!("{base}?{params}")
+                }
+            }
+            DatabaseType::Etcd => {
+                format!("etcd://{host}:{port}")
+            }
+            DatabaseType::ZooKeeper => {
+                format!("zookeeper://{host}:{port}")
+            }
+            DatabaseType::Iris => format!("iris://{host}:{port}{db_part}"),
+            DatabaseType::InfluxDb => {
+                let scheme = if self.ssl { "https" } else { "http" };
+                format!("{scheme}://{host}:{port}")
+            }
+            DatabaseType::Jdbc => "jdbc:<redacted>".to_string(),
+            DatabaseType::MessageQueue => self.message_queue_admin_url(),
+            DatabaseType::Nacos => self.nacos_admin_url(),
+        }
+    }
+
+    pub fn connection_url_with_host(&self, host: &str, port: u16) -> String {
+        let raw_host = host;
+        let host = bracket_ipv6(host);
+        let db_part = self.effective_database().map(|d| format!("/{}", encode_url_part(d))).unwrap_or_default();
+        let username = encode_url_part(&self.username);
+        let password = encode_url_part(&self.password);
+        let params = self.normalized_url_params();
+
+        match self.db_type {
+            DatabaseType::Sqlite | DatabaseType::DuckDb => {
+                format!("{}?mode=rwc", self.host)
+            }
+            DatabaseType::Access => self.host.clone(),
+            DatabaseType::Redis => {
+                let scheme = if self.ssl { "rediss" } else { "redis" };
+                let fragment = self.redis_tls_insecure_fragment();
+                if self.username.is_empty() && self.password.is_empty() {
+                    format!("{scheme}://{host}:{port}/{fragment}")
+                } else if self.username.is_empty() {
+                    format!("{scheme}://:{password}@{host}:{port}/{fragment}")
+                } else {
+                    format!("{scheme}://{username}:{password}@{host}:{port}/{fragment}")
+                }
+            }
+            DatabaseType::Mysql
+            | DatabaseType::Doris
+            | DatabaseType::StarRocks
+            | DatabaseType::ManticoreSearch
+            | DatabaseType::Databend => {
+                let suffix = if params.is_empty() { String::new() } else { format!("?{params}") };
+                format!("mysql://{}:{}@{host}:{port}{db_part}{suffix}", username, password)
+            }
+            DatabaseType::Postgres | DatabaseType::Redshift => {
+                let suffix = if params.is_empty() { String::new() } else { format!("?{params}") };
+                format!("postgres://{}:{}@{host}:{port}{db_part}{suffix}", username, password)
+            }
+            DatabaseType::ClickHouse => clickhouse_http_url(self, raw_host, port),
+            DatabaseType::Rqlite => rqlite_http_url(self, raw_host, port),
+            DatabaseType::Turso => turso_http_url(self, raw_host, port),
+            DatabaseType::CloudflareD1 => cloudflare_d1_api_url(self),
+            DatabaseType::SqlServer => format!(
+                "server=tcp:{host},{port};user={};password={};database={}",
+                self.username,
+                self.password,
+                self.database.as_deref().unwrap_or("master")
+            ),
+            DatabaseType::MongoDb => {
+                let is_tunneled = host != self.host.as_str() || port != self.port;
+                if let Some(cs) = self.connection_string.as_deref().filter(|s| !s.is_empty()) {
+                    let cs = normalize_mongo_uri_direct_connection(cs);
+                    if is_tunneled {
+                        return rewrite_mongo_uri_host(&cs, &host, port);
+                    }
+                    return cs;
+                }
+                let mut suffix = if params.is_empty() { String::new() } else { format!("?{params}") };
+                if is_tunneled && !suffix.contains("directConnection=") {
+                    if suffix.is_empty() {
+                        suffix = "?directConnection=true".to_string();
+                    } else {
+                        suffix.push_str("&directConnection=true");
+                    }
+                }
+                let db_part = mongo_uri_db_part_for_suffix(&db_part, &suffix);
+                if self.username.is_empty() {
+                    format!("mongodb://{host}:{port}{db_part}{suffix}")
+                } else {
+                    format!("mongodb://{username}:{password}@{host}:{port}{db_part}{suffix}")
+                }
+            }
+            DatabaseType::Oracle => {
+                format!("oracle://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Elasticsearch
+            | DatabaseType::Qdrant
+            | DatabaseType::Milvus
+            | DatabaseType::Weaviate
+            | DatabaseType::ChromaDb => {
+                let scheme = if self.ssl { "https" } else { "http" };
+                format!("{scheme}://{host}:{port}")
+            }
+            DatabaseType::Dameng => {
+                format!("dm://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Kingbase => {
+                format!("kingbase://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Highgo => {
+                format!("highgo://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Vastbase => {
+                format!("vastbase://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Goldendb => {
+                format!("goldendb://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Gaussdb => {
+                format!("gaussdb://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Kwdb => {
+                format!("kwdb://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Yashandb => {
+                format!("yashandb://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Databricks => {
+                format!("databricks://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::SapHana => {
+                format!("saphana://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Teradata => {
+                format!("teradata://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Vertica => {
+                format!("vertica://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Firebird => {
+                format!("firebird://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Exasol => {
+                format!("exasol://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::OpenGauss => {
+                format!("opengauss://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::OceanbaseOracle => {
+                let base = format!("oceanbase-oracle://{}:{}@{host}:{port}{db_part}", username, password);
+                if params.is_empty() {
+                    base
+                } else {
+                    format!("{base}?{params}")
+                }
+            }
+            DatabaseType::Questdb => {
+                format!("questdb://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Gbase => {
+                format!("gbase://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::H2 => {
+                format!("h2://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Snowflake => {
+                format!("snowflake://{}:{}@{host}/{db_part}", username, password)
+            }
+            DatabaseType::Trino => {
+                format!("trino://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::PrestoSql => {
+                format!("prestosql://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Hive => {
+                format!("hive://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Spark => {
+                format!("spark://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Db2 => {
+                format!("db2://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Informix => {
+                format!("informix://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Neo4j => {
+                format!("neo4j://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Cassandra => {
+                format!("cassandra://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Bigquery => {
+                format!("bigquery://{}:{}@{host}/{db_part}", username, password)
+            }
+            DatabaseType::Kylin => {
+                format!("kylin://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Sundb => {
+                format!("sundb://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Oscar => {
+                format!("oscar://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Tdengine => {
+                format!("tdengine://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Xugu => {
+                format!("xugu://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::Iotdb => {
+                let base = format!("iotdb://{}:{}@{host}:{port}{db_part}", username, password);
+                if params.is_empty() {
+                    base
+                } else {
+                    format!("{base}?{params}")
+                }
+            }
+            DatabaseType::Etcd => {
+                if self.username.is_empty() {
+                    format!("etcd://{host}:{port}")
+                } else {
+                    format!("etcd://{}:{}@{host}:{port}", username, password)
+                }
+            }
+            DatabaseType::ZooKeeper => {
+                if self.username.is_empty() {
+                    format!("zookeeper://{host}:{port}")
+                } else {
+                    format!("zookeeper://{}:{}@{host}:{port}", username, password)
+                }
+            }
+            DatabaseType::Iris => {
+                format!("iris://{}:{}@{host}:{port}{db_part}", username, password)
+            }
+            DatabaseType::InfluxDb => {
+                let scheme = if self.ssl { "https" } else { "http" };
+                format!("{scheme}://{host}:{port}")
+            }
+            DatabaseType::Jdbc => {
+                self.connection_string.as_deref().filter(|value| !value.is_empty()).unwrap_or("jdbc:").to_string()
+            }
+            DatabaseType::MessageQueue => self.message_queue_admin_url(),
+            DatabaseType::Nacos => self.nacos_admin_url(),
+        }
+    }
+
+    fn message_queue_admin_url(&self) -> String {
+        self.external_config
+            .as_ref()
+            .and_then(|value| value.get("adminUrl").or_else(|| value.get("admin_url")))
+            .and_then(|value| value.as_str())
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .unwrap_or("mq://")
+            .to_string()
+    }
+
+    fn nacos_admin_url(&self) -> String {
+        self.external_config
+            .as_ref()
+            .and_then(|value| value.get("serverAddr").or_else(|| value.get("server_addr")))
+            .and_then(|value| value.as_str())
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .unwrap_or("nacos://")
+            .to_string()
+    }
+
+    fn normalized_url_params(&self) -> String {
+        let value = self.url_params.as_deref().unwrap_or("").trim();
+        if self.needs_bare_mysql() {
+            if self.bare_mysql_uses_tls() {
+                return normalize_mysql_url_params(value, true, self.ca_cert_path.trim().is_empty());
+            }
+            return normalize_bare_mysql_url_params(value);
+        }
+        match self.db_type {
+            DatabaseType::Mysql => {
+                normalize_mysql_url_params(value, self.mysql_uses_tls(), self.ca_cert_path.trim().is_empty())
+            }
+            DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::ManticoreSearch => {
+                let params = normalize_bare_mysql_url_params(value);
+                if params.is_empty() {
+                    "enable_cleartext_plugin=true".to_string()
+                } else {
+                    format!("{params}&enable_cleartext_plugin=true")
+                }
+            }
+            DatabaseType::Databend => normalize_bare_mysql_url_params(value),
+            DatabaseType::Postgres | DatabaseType::Redshift => normalize_postgres_url_params(value, self.ssl),
+            DatabaseType::MongoDb => {
+                normalize_mongo_url_params(value, self.ssl, !self.username.trim().is_empty(), self.ca_cert_path.trim())
+            }
+            _ => value.trim_start_matches('?').to_string(),
+        }
+    }
+
+    pub fn clickhouse_uses_tls(&self) -> bool {
+        self.ssl || url_params_contains_flag(self.url_params.as_deref(), "secure", "true")
+    }
+
+    pub fn mysql_uses_tls(&self) -> bool {
+        self.ssl
+            || self.host.to_ascii_lowercase().ends_with(".tidbcloud.com")
+            || mysql_url_params_require_tls(self.url_params.as_deref())
+    }
+
+    fn redis_tls_insecure_fragment(&self) -> &'static str {
+        if self.ssl && self.redis_tls_insecure() {
+            "#insecure"
+        } else {
+            ""
+        }
+    }
+}
+
+fn redis_url_params_enable_insecure(params: Option<&str>) -> bool {
+    params.unwrap_or("").trim().trim_start_matches('?').split(['&', ';']).any(|part| {
+        let part = part.trim();
+        if part.is_empty() {
+            return false;
+        }
+        let Some((key, value)) = part.split_once('=') else {
+            return part.eq_ignore_ascii_case("insecure");
+        };
+        let key = key.trim();
+        matches!(key.to_ascii_lowercase().as_str(), "insecure" | "tls_insecure" | "accept_invalid_certs")
+            && matches!(value.trim().to_ascii_lowercase().as_str(), "true" | "1" | "yes" | "insecure")
+    })
+}
+
+fn url_params_contains_flag(params: Option<&str>, key: &str, expected: &str) -> bool {
+    params.unwrap_or("").trim().trim_start_matches('?').split(['&', ';']).filter_map(|part| part.split_once('=')).any(
+        |(part_key, value)| part_key.trim().eq_ignore_ascii_case(key) && value.trim().eq_ignore_ascii_case(expected),
+    )
+}
+
+fn mysql_tls_file_param_is(key: &str, target: &str) -> bool {
+    let normalized = key.to_ascii_lowercase().replace(['-', '_'], "");
+    normalized == format!("ssl{target}")
+}
+
+fn mysql_url_params_tls_disabled(params: Option<&str>) -> bool {
+    params.unwrap_or("").trim().trim_start_matches('?').split('&').any(|part| {
+        let part = part.trim();
+        if part.is_empty() {
+            return false;
+        }
+        let Some((key, value)) = part.split_once('=') else {
+            return false;
+        };
+        let key = key.trim();
+        let value = value.trim();
+        (key.eq_ignore_ascii_case("require_ssl") && value.eq_ignore_ascii_case("false"))
+            || ((key.eq_ignore_ascii_case("ssl-mode") || key.eq_ignore_ascii_case("sslmode"))
+                && matches!(value.to_ascii_lowercase().replace('-', "_").as_str(), "disabled" | "disable"))
+    })
+}
+
+fn mysql_url_params_require_tls(params: Option<&str>) -> bool {
+    params.unwrap_or("").trim().trim_start_matches('?').split('&').any(|part| {
+        let part = part.trim();
+        if part.is_empty() {
+            return false;
+        }
+        let Some((key, value)) = part.split_once('=') else {
+            return mysql_tls_file_param_is(part, "cert") || mysql_tls_file_param_is(part, "key");
+        };
+        let key = key.trim();
+        let value = value.trim();
+        (key.eq_ignore_ascii_case("require_ssl") && value.eq_ignore_ascii_case("true"))
+            || mysql_tls_file_param_is(key, "cert")
+            || mysql_tls_file_param_is(key, "key")
+            || ((key.eq_ignore_ascii_case("ssl-mode") || key.eq_ignore_ascii_case("sslmode"))
+                && matches!(
+                    value.to_ascii_lowercase().replace('-', "_").as_str(),
+                    "required" | "require" | "verify_ca" | "verify_identity"
+                ))
+    })
+}
+
+fn normalize_bare_mysql_url_params(value: &str) -> String {
+    value
+        .trim_start_matches('?')
+        .split('&')
+        .filter(|part| {
+            !part.is_empty()
+                && !url_param_key_is(part, "charset")
+                && !url_param_key_is(part, "ssl-mode")
+                && !url_param_key_is(part, "sslmode")
+                && !url_param_key_is(part, "require_ssl")
+                && !url_param_key_is(part, "verify_ca")
+                && !url_param_key_is(part, "verify_identity")
+        })
+        .collect::<Vec<_>>()
+        .join("&")
+}
+
+fn is_mysql_cleartext_password_param(key: &str) -> bool {
+    matches!(key.to_ascii_lowercase().as_str(), "allowcleartextpasswords" | "enable_cleartext_plugin")
+}
+
+fn mysql_url_param_value_is_true(value: &str) -> bool {
+    matches!(value.trim().to_ascii_lowercase().as_str(), "true" | "1" | "yes" | "on")
+}
+
+fn normalize_mysql_url_params(value: &str, force_tls: bool, accept_invalid_certs: bool) -> String {
+    let value = value.trim_start_matches('?');
+    let mut parts: Vec<String> = value.split('&').filter(|part| !part.is_empty()).map(str::to_string).collect();
+    let enable_cleartext_plugin = parts.iter().any(|part| {
+        let Some((key, value)) = part.split_once('=') else {
+            return false;
+        };
+        is_mysql_cleartext_password_param(key.trim()) && mysql_url_param_value_is_true(value)
+    });
+
+    parts.retain(|part| {
+        let Some((key, _)) = part.split_once('=') else {
+            return true;
+        };
+        !is_mysql_cleartext_password_param(key.trim())
+    });
+
+    if force_tls {
+        parts.retain(|part| {
+            !url_param_key_is(part, "ssl-mode")
+                && !url_param_key_is(part, "sslmode")
+                && !url_param_key_is(part, "require_ssl")
+        });
+        parts.insert(0, "require_ssl=true".to_string());
+        if accept_invalid_certs && !parts.iter().any(|part| url_param_key_is(part, "verify_ca")) {
+            parts.push("verify_ca=false".to_string());
+        }
+        if !parts.iter().any(|part| url_param_key_is(part, "verify_identity")) {
+            parts.push("verify_identity=false".to_string());
+        }
+    } else if !parts.iter().any(|part| {
+        url_param_key_is(part, "ssl-mode") || url_param_key_is(part, "sslmode") || url_param_key_is(part, "require_ssl")
+    }) {
+        // Default MySQL connections keep TLS off unless the user explicitly
+        // enables a TLS mode.
+        parts.insert(0, "ssl-mode=disabled".to_string());
+    }
+
+    if !parts.iter().any(|part| url_param_key_is(part, "charset")) {
+        parts.push("charset=utf8mb4".to_string());
+    }
+    if enable_cleartext_plugin {
+        parts.push("enable_cleartext_plugin=true".to_string());
+    }
+
+    parts.join("&")
+}
+
+fn normalize_mongo_url_params(value: &str, force_tls: bool, default_auth_source: bool, ca_cert_path: &str) -> String {
+    let value = value.trim_start_matches('?');
+    let mut parts: Vec<String> = value.split('&').filter(|part| !part.is_empty()).map(str::to_string).collect();
+
+    if force_tls {
+        parts.retain(|part| !url_param_key_is(part, "tls") && !url_param_key_is(part, "ssl"));
+        parts.insert(0, "tls=true".to_string());
+    }
+
+    normalize_mongo_tls_compat_params(&mut parts);
+
+    if !force_tls {
+        parts.retain(|part| {
+            !url_param_key_is(part, "tlsAllowInvalidCertificates") && !url_param_key_is(part, "tlsCAFile")
+        });
+    }
+
+    let existing_tls_ca_file = if ca_cert_path.is_empty() {
+        parts.iter().find(|part| url_param_key_is(part, "tlsCAFile")).cloned()
+    } else {
+        None
+    };
+    parts.retain(|part| !url_param_key_is(part, "tlsCAFile"));
+
+    if force_tls {
+        if !ca_cert_path.is_empty() {
+            parts.push(format!("tlsCAFile={}", encode_mongo_tls_file_path(ca_cert_path)));
+        } else if let Some(part) = existing_tls_ca_file {
+            parts.push(part);
+        }
+    }
+
+    if default_auth_source && !parts.iter().any(|part| url_param_key_is(part, "authSource")) {
+        parts.push("authSource=admin".to_string());
+    }
+
+    parts.join("&")
+}
+
+/// The Rust MongoDB driver uses rustls by default, which does not accept
+/// `tlsAllowInvalidHostnames` in the connection string. Map it to the
+/// supported `tlsAllowInvalidCertificates` option instead.
+fn normalize_mongo_tls_compat_params(parts: &mut Vec<String>) {
+    let allow_invalid_hostnames =
+        parts.iter().any(|part| url_param_key_is(part, "tlsAllowInvalidHostnames") && mongo_url_param_is_truthy(part));
+    parts.retain(|part| !url_param_key_is(part, "tlsAllowInvalidHostnames"));
+    if allow_invalid_hostnames && !parts.iter().any(|part| url_param_key_is(part, "tlsAllowInvalidCertificates")) {
+        parts.push("tlsAllowInvalidCertificates=true".to_string());
+    }
+}
+
+fn mongo_url_param_is_truthy(part: &str) -> bool {
+    let Some((_, value)) = part.split_once('=') else {
+        return true;
+    };
+    matches!(percent_decode_str(value).decode_utf8_lossy().trim().to_ascii_lowercase().as_str(), "true" | "1" | "yes")
+}
+
+fn encode_mongo_tls_file_path(path: &str) -> String {
+    utf8_percent_encode(path, NON_ALPHANUMERIC).to_string()
+}
+
+fn mongo_uri_db_part_for_suffix<'a>(db_part: &'a str, suffix: &str) -> &'a str {
+    if db_part.is_empty() && !suffix.is_empty() {
+        "/"
+    } else {
+        db_part
+    }
+}
+
+fn normalize_mongo_uri_direct_connection(uri: &str) -> String {
+    let uri = normalize_mongo_uri_query_path(uri);
+    if !mongo_uri_has_multiple_seeds(&uri) || !mongo_uri_has_direct_connection_true(&uri) {
+        return uri;
+    }
+
+    let (before_fragment, fragment) =
+        uri.split_once('#').map(|(base, fragment)| (base, Some(fragment))).unwrap_or((uri.as_str(), None));
+    let Some((base, query)) = before_fragment.split_once('?') else {
+        return uri;
+    };
+    let params =
+        query.split('&').filter(|part| !mongo_url_param_is_direct_connection_true(part)).collect::<Vec<_>>().join("&");
+
+    let mut normalized = if params.is_empty() { base.to_string() } else { format!("{base}?{params}") };
+    if let Some(fragment) = fragment {
+        normalized.push('#');
+        normalized.push_str(fragment);
+    }
+    normalized
+}
+
+fn normalize_mongo_uri_query_path(uri: &str) -> String {
+    let Some(rest_start) = uri.find("://").map(|idx| idx + "://".len()) else {
+        return uri.to_string();
+    };
+    if !uri[..rest_start].eq_ignore_ascii_case("mongodb://")
+        && !uri[..rest_start].eq_ignore_ascii_case("mongodb+srv://")
+    {
+        return uri.to_string();
+    }
+    let rest = &uri[rest_start..];
+    let Some(first_path_or_query) = rest.find(['/', '?', '#']) else {
+        return uri.to_string();
+    };
+    if rest.as_bytes()[first_path_or_query] != b'?' {
+        return uri.to_string();
+    }
+    let insert_at = rest_start + first_path_or_query;
+    format!("{}/{}", &uri[..insert_at], &uri[insert_at..])
+}
+
+fn mongo_uri_has_multiple_seeds(uri: &str) -> bool {
+    if mongo_uri_is_srv(uri) {
+        // The Rust MongoDB driver resolves SRV records into a seed list, so an
+        // SRV URL must not keep directConnection=true even with one hostname.
+        return true;
+    }
+    mongo_uri_host_section(uri)
+        .map(|hosts| hosts.split(',').filter(|host| !host.trim().is_empty()).count() > 1)
+        .unwrap_or(false)
+}
+
+fn mongo_uri_is_srv(uri: &str) -> bool {
+    uri.get(..14).is_some_and(|scheme| scheme.eq_ignore_ascii_case("mongodb+srv://"))
+}
+
+fn mongo_uri_host_section(uri: &str) -> Option<&str> {
+    let rest = uri.strip_prefix("mongodb://").or_else(|| uri.strip_prefix("mongodb+srv://"))?;
+    let authority = rest.split('/').next()?.split('?').next().unwrap_or(rest);
+    Some(match authority.rfind('@') {
+        Some(idx) => &authority[idx + 1..],
+        None => authority,
+    })
+}
+
+fn mongo_uri_has_direct_connection_true(uri: &str) -> bool {
+    uri.split_once('?')
+        .map(|(_, query)| {
+            query.split('#').next().unwrap_or("").split('&').any(mongo_url_param_is_direct_connection_true)
+        })
+        .unwrap_or(false)
+}
+
+fn mongo_url_param_is_direct_connection_true(part: &str) -> bool {
+    let Some((key, value)) = part.split_once('=') else {
+        return false;
+    };
+    percent_decode_str(key).decode_utf8_lossy().eq_ignore_ascii_case("directConnection")
+        && percent_decode_str(value).decode_utf8_lossy().eq_ignore_ascii_case("true")
+}
+
+fn normalize_postgres_url_params(value: &str, force_tls: bool) -> String {
+    let value = value.trim_start_matches('?');
+
+    let mut timezone: Option<String> = None;
+    let mut search_path: Option<String> = None;
+    let mut parts: Vec<String> = Vec::new();
+
+    for part in value.split('&').filter(|part| !part.is_empty()) {
+        let (raw_key, raw_value) = part.split_once('=').unwrap_or((part, ""));
+        let key = percent_decode_str(raw_key).decode_utf8_lossy();
+        if key.eq_ignore_ascii_case("timezone") || key.eq_ignore_ascii_case("time_zone") {
+            let decoded_value = percent_decode_str(raw_value).decode_utf8_lossy().trim().to_string();
+            if !decoded_value.is_empty() {
+                timezone = Some(decoded_value);
+            }
+        } else if key.eq_ignore_ascii_case("schema") || key.eq_ignore_ascii_case("currentSchema") {
+            let decoded_value = percent_decode_str(raw_value).decode_utf8_lossy().trim().to_string();
+            if !decoded_value.is_empty() {
+                search_path = Some(decoded_value);
+            }
+        } else if key.eq_ignore_ascii_case("ssl-mode") {
+            let decoded_value = percent_decode_str(raw_value).decode_utf8_lossy();
+            match decoded_value.to_ascii_lowercase().replace('_', "-").as_str() {
+                "require" | "required" => parts.push("sslmode=require".to_string()),
+                "prefer" | "preferred" => parts.push("sslmode=prefer".to_string()),
+                "disable" | "disabled" => parts.push("sslmode=disable".to_string()),
+                "verify-ca" => parts.push("sslmode=verify-ca".to_string()),
+                "verify-full" | "verify-identity" => parts.push("sslmode=verify-full".to_string()),
+                _ => {}
+            }
+        } else if key.eq_ignore_ascii_case("charset")
+            || key.eq_ignore_ascii_case("require_ssl")
+            || key.eq_ignore_ascii_case("verify_ca")
+            || key.eq_ignore_ascii_case("verify_identity")
+        {
+            // These MySQL-style parameters may be present in older/imported
+            // saved connections. tokio-postgres rejects unknown URL keys.
+        } else {
+            parts.push(part.to_string());
+        }
+    }
+
+    let mut connection_options: Vec<(&str, String)> = Vec::new();
+    if let Some(search_path) = search_path {
+        connection_options.push(("search_path=", format!("-c search_path={search_path}")));
+    }
+    if let Some(timezone) = timezone {
+        connection_options.push(("timezone=", format!("-c TimeZone={timezone}")));
+    }
+
+    if connection_options.is_empty() {
+        if force_tls && !parts.iter().any(|part| url_param_key_is(part, "sslmode")) {
+            parts.insert(0, "sslmode=require".to_string());
+        }
+        return parts.join("&");
+    }
+
+    if let Some(options_index) = parts.iter().position(|part| {
+        part.split_once('=')
+            .map(|(raw_key, _)| percent_decode_str(raw_key).decode_utf8_lossy().eq_ignore_ascii_case("options"))
+            .unwrap_or(false)
+    }) {
+        let (raw_key, raw_value) = parts[options_index].split_once('=').unwrap_or(("options", ""));
+        let options_value = percent_decode_str(raw_value).decode_utf8_lossy();
+        let lower_options = options_value.to_ascii_lowercase();
+        let appended_options = connection_options
+            .into_iter()
+            .filter_map(|(needle, option)| (!lower_options.contains(needle)).then_some(option))
+            .collect::<Vec<_>>()
+            .join(" ");
+        if !appended_options.is_empty() {
+            let combined = format!("{} {}", options_value.trim(), appended_options).trim().to_string();
+            parts[options_index] = format!("{raw_key}={}", encode_url_part(&combined));
+        }
+    } else {
+        let combined = connection_options.into_iter().map(|(_, option)| option).collect::<Vec<_>>().join(" ");
+        parts.push(format!("options={}", encode_url_part(&combined)));
+    }
+
+    if force_tls && !parts.iter().any(|part| url_param_key_is(part, "sslmode")) {
+        parts.insert(0, "sslmode=require".to_string());
+    }
+
+    parts.join("&")
+}
+
+fn url_param_key_is(part: &str, expected: &str) -> bool {
+    let key = part.split_once('=').map(|(key, _)| key).unwrap_or(part);
+    percent_decode_str(key).decode_utf8_lossy().eq_ignore_ascii_case(expected)
+}
+
+fn clickhouse_http_url(config: &ConnectionConfig, host: &str, port: u16) -> String {
+    let trimmed = host.trim();
+    if let Some(rest) = trimmed.strip_prefix("https://") {
+        return format!("https://{}", trim_clickhouse_host_port(rest, port));
+    }
+    if let Some(rest) = trimmed.strip_prefix("http://") {
+        let scheme = if config.clickhouse_uses_tls() { "https" } else { "http" };
+        return format!("{scheme}://{}", trim_clickhouse_host_port(rest, port));
+    }
+    let scheme = if config.clickhouse_uses_tls() { "https" } else { "http" };
+    format!("{scheme}://{}:{port}", bracket_ipv6(trimmed))
+}
+
+fn rqlite_http_url(config: &ConnectionConfig, host: &str, port: u16) -> String {
+    let trimmed = host.trim();
+    if let Some(rest) = trimmed.strip_prefix("https://") {
+        return format!("https://{}", trim_http_host_port(rest, port));
+    }
+    if let Some(rest) = trimmed.strip_prefix("http://") {
+        let scheme = if config.ssl { "https" } else { "http" };
+        return format!("{scheme}://{}", trim_http_host_port(rest, port));
+    }
+    let scheme = if config.ssl { "https" } else { "http" };
+    format!("{scheme}://{}:{port}", bracket_ipv6(trimmed))
+}
+
+fn turso_http_url(config: &ConnectionConfig, host: &str, port: u16) -> String {
+    let trimmed = host.trim();
+
+    // Handle libsql:// protocol (Turso native)
+    if let Some(rest) = trimmed.strip_prefix("libsql://") {
+        return format!("https://{}", trim_http_host_port(rest, port));
+    }
+
+    // Handle explicit https://
+    if let Some(rest) = trimmed.strip_prefix("https://") {
+        return format!("https://{}", trim_http_host_port(rest, port));
+    }
+
+    // Handle explicit http:// (respect ssl config)
+    if let Some(rest) = trimmed.strip_prefix("http://") {
+        let scheme = if config.ssl { "https" } else { "http" };
+        return format!("{scheme}://{}", trim_http_host_port(rest, port));
+    }
+
+    // Default: bare hostname -> prefer HTTPS for Turso (default port 443)
+    let scheme = if port == 443 || config.ssl { "https" } else { "http" };
+    format!("{scheme}://{}:{port}", bracket_ipv6(trimmed))
+}
+
+fn cloudflare_d1_api_url(config: &ConnectionConfig) -> String {
+    let account_id = config.host.trim();
+    let database_id = config.database.as_deref().unwrap_or_default().trim();
+    format!("https://api.cloudflare.com/client/v4/accounts/{account_id}/d1/database/{database_id}")
+}
+
+fn trim_http_host_port(value: &str, default_port: u16) -> String {
+    let authority = value.trim_end_matches('/').split('/').next().unwrap_or(value).split('?').next().unwrap_or(value);
+    if authority.starts_with('[') && !authority.contains("]:") {
+        return format!("{authority}:{default_port}");
+    }
+    if authority.rsplit_once(':').is_some() {
+        authority.to_string()
+    } else {
+        format!("{authority}:{default_port}")
+    }
+}
+
+fn trim_clickhouse_host_port(value: &str, default_port: u16) -> String {
+    let authority = value.trim_end_matches('/').split('/').next().unwrap_or(value).split('?').next().unwrap_or(value);
+    if authority.starts_with('[') && !authority.contains("]:") {
+        return format!("{authority}:{default_port}");
+    }
+    if authority.rsplit_once(':').is_some() {
+        authority.to_string()
+    } else {
+        format!("{authority}:{default_port}")
+    }
+}
+
+pub fn parse_mongo_first_host(uri: &str) -> Option<(String, u16)> {
+    let rest = uri.strip_prefix("mongodb://").or_else(|| uri.strip_prefix("mongodb+srv://"))?;
+    let authority = rest.split('/').next()?;
+    let host_section = match authority.rfind('@') {
+        Some(idx) => &authority[idx + 1..],
+        None => authority,
+    };
+    let first = host_section.split(',').next()?;
+    match first.rsplit_once(':') {
+        Some((h, p)) => Some((h.to_string(), p.parse().unwrap_or(27017))),
+        None => Some((first.to_string(), 27017)),
+    }
+}
+
+fn rewrite_mongo_uri_host(uri: &str, new_host: &str, new_port: u16) -> String {
+    let (_scheme, rest) = if let Some(r) = uri.strip_prefix("mongodb+srv://") {
+        ("mongodb://", r)
+    } else if let Some(r) = uri.strip_prefix("mongodb://") {
+        ("mongodb://", r)
+    } else {
+        return uri.to_string();
+    };
+
+    let (creds_prefix, after_creds) = match rest.find('@') {
+        Some(idx) => (&rest[..=idx], &rest[idx + 1..]),
+        None => ("", rest),
+    };
+
+    let after_hosts = match after_creds.find('/') {
+        Some(idx) => &after_creds[idx..],
+        None => "",
+    };
+
+    let mut result = format!("mongodb://{creds_prefix}{new_host}:{new_port}{after_hosts}");
+
+    if !result.contains("directConnection=") {
+        if result.contains('?') {
+            result.push_str("&directConnection=true");
+        } else {
+            result.push_str("?directConnection=true");
+        }
+    }
+
+    result
+}
+
+pub fn parse_jdbc_host_port(url: &str) -> Option<(String, u16)> {
+    let rest = url.strip_prefix("jdbc:")?;
+
+    // jdbc:oracle:thin:@host:port:SID  or  jdbc:oracle:thin:@//host:port/service
+    if let Some(after) = rest.strip_prefix("oracle:") {
+        let at_pos = after.find('@')?;
+        let after_at = &after[at_pos + 1..];
+        if after_at.trim_start().starts_with('(') {
+            let host = oracle_descriptor_value(after_at, "HOST")?;
+            let port = oracle_descriptor_value(after_at, "PORT")?;
+            return Some((host, port.parse().ok()?));
+        }
+        let after_at = after_at.strip_prefix("//").unwrap_or(after_at);
+        let host_port = after_at.split(&['/', ':', '?'][..]).next()?;
+        let port_str = after_at.strip_prefix(host_port)?.strip_prefix(':')?.split(&[':', '/', ';', '?'][..]).next()?;
+        return Some((host_port.to_string(), port_str.parse().ok()?));
+    }
+
+    // jdbc:sqlserver://host:port;prop=val  or  jdbc:sqlserver://host\instance:port;...
+    if let Some(after) = rest.strip_prefix("sqlserver://") {
+        let authority = after.split(';').next().unwrap_or(after);
+        let authority = authority.split('\\').next().unwrap_or(authority);
+        return match authority.rsplit_once(':') {
+            Some((h, p)) => Some((h.to_string(), p.parse().ok()?)),
+            None => Some((authority.to_string(), 1433)),
+        };
+    }
+
+    // Generic: jdbc:subprotocol://[user:pass@]host:port[/path][?query]
+    let scheme_end = rest.find("://")?;
+    let after_scheme = &rest[scheme_end + 3..];
+    let authority = after_scheme.split('/').next().unwrap_or(after_scheme);
+    let authority = authority.split('?').next().unwrap_or(authority);
+    let host_port = match authority.rfind('@') {
+        Some(idx) => &authority[idx + 1..],
+        None => authority,
+    };
+    match host_port.rsplit_once(':') {
+        Some((h, p)) => Some((h.to_string(), p.parse().ok()?)),
+        None => None,
+    }
+}
+
+pub fn rewrite_jdbc_url_host(url: &str, new_host: &str, new_port: u16) -> String {
+    let normalized_url = url.to_ascii_uppercase();
+    if normalized_url.starts_with("JDBC:ORACLE:")
+        && normalized_url.contains("(HOST=")
+        && normalized_url.contains("(PORT=")
+    {
+        return rewrite_oracle_descriptor_host(url, new_host, new_port);
+    }
+
+    let Some((old_host, old_port)) = parse_jdbc_host_port(url) else {
+        return url.to_string();
+    };
+    let old_authority = format!("{old_host}:{old_port}");
+    let new_authority = format!("{new_host}:{new_port}");
+    url.replacen(&old_authority, &new_authority, 1)
+}
+
+fn oracle_descriptor_value(descriptor: &str, key: &str) -> Option<String> {
+    let key = format!("({key}=");
+    let start = descriptor.to_ascii_uppercase().find(&key)?;
+    let value_start = start + key.len();
+    let value_end = descriptor[value_start..].find(')')? + value_start;
+    Some(descriptor[value_start..value_end].trim().to_string())
+}
+
+fn rewrite_oracle_descriptor_host(url: &str, new_host: &str, new_port: u16) -> String {
+    let rewritten_host = replace_oracle_descriptor_value(url, "HOST", new_host);
+    replace_oracle_descriptor_value(&rewritten_host, "PORT", &new_port.to_string())
+}
+
+fn replace_oracle_descriptor_value(input: &str, key: &str, value: &str) -> String {
+    let token = format!("({key}=");
+    let Some(start) = input.to_ascii_uppercase().find(&token) else {
+        return input.to_string();
+    };
+    let value_start = start + token.len();
+    let Some(value_end) = input[value_start..].find(')').map(|offset| value_start + offset) else {
+        return input.to_string();
+    };
+    format!("{}{}{}", &input[..value_start], value, &input[value_end..])
+}
+
+fn encode_url_part(value: &str) -> String {
+    utf8_percent_encode(value, NON_ALPHANUMERIC).to_string()
+}
+
+fn bracket_ipv6(host: &str) -> String {
+    if host.contains(':') && !host.starts_with('[') {
+        format!("[{host}]")
+    } else {
+        host.to_string()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        default_query_timeout_secs, default_redis_key_separator, default_ssh_connect_timeout_secs, ConnectionConfig,
+        DatabaseType, ProxyTunnelConfig, ProxyType, TransportLayerConfig,
+    };
+    use std::str::FromStr;
+
+    #[test]
+    fn default_query_timeout_is_sixty_seconds() {
+        assert_eq!(default_query_timeout_secs(), 60);
+    }
+
+    fn mysql_config(username: &str, password: &str, database: Option<&str>) -> ConnectionConfig {
+        ConnectionConfig {
+            id: "id".to_string(),
+            name: "name".to_string(),
+            db_type: DatabaseType::Mysql,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "10.1.2.3".to_string(),
+            port: 2883,
+            username: username.to_string(),
+            password: password.to_string(),
+            database: database.map(str::to_string),
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: super::default_connect_timeout_secs(),
+            query_timeout_secs: default_query_timeout_secs(),
+            idle_timeout_secs: super::default_idle_timeout_secs(),
+            keepalive_interval_secs: super::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    fn mongodb_config(username: &str, password: &str, database: Option<&str>) -> ConnectionConfig {
+        let mut config = mysql_config(username, password, database);
+        config.db_type = DatabaseType::MongoDb;
+        config.port = 17000;
+        config
+    }
+
+    #[test]
+    fn zookeeper_database_type_uses_stable_wire_name() {
+        assert_eq!(serde_json::to_string(&DatabaseType::ZooKeeper).unwrap(), "\"zookeeper\"");
+        assert_eq!(serde_json::from_str::<DatabaseType>("\"zookeeper\"").unwrap(), DatabaseType::ZooKeeper);
+    }
+
+    #[test]
+    fn cloudflare_d1_database_type_and_api_url_are_stable() {
+        assert_eq!(serde_json::to_string(&DatabaseType::CloudflareD1).unwrap(), "\"cloudflare-d1\"");
+        assert_eq!(serde_json::from_str::<DatabaseType>("\"cloudflare-d1\"").unwrap(), DatabaseType::CloudflareD1);
+
+        let mut config = mysql_config("", "secret-token", Some("database-id"));
+        config.db_type = DatabaseType::CloudflareD1;
+        config.host = "account-id".to_string();
+        config.port = 443;
+        assert_eq!(
+            config.connection_url(),
+            "https://api.cloudflare.com/client/v4/accounts/account-id/d1/database/database-id"
+        );
+        assert!(!config.connection_url().contains("secret-token"));
+    }
+
+    #[test]
+    fn connection_config_defaults_missing_agent_java_options_to_empty() {
+        let config: ConnectionConfig = serde_json::from_value(serde_json::json!({
+            "id": "id",
+            "name": "Hive",
+            "db_type": "hive",
+            "host": "hive.local",
+            "port": 10000,
+            "username": "",
+            "password": "",
+            "database": "default"
+        }))
+        .unwrap();
+
+        assert!(config.agent_java_options.is_empty());
+    }
+
+    #[test]
+    fn zookeeper_connection_url_uses_zookeeper_scheme() {
+        let mut config = mysql_config("", "", None);
+        config.db_type = DatabaseType::ZooKeeper;
+        config.host = "zk.local".to_string();
+        config.port = 2181;
+
+        assert_eq!(config.connection_url_with_host("zk.local", 2181), "zookeeper://zk.local:2181");
+
+        config.username = "digest".to_string();
+        config.password = "secret".to_string();
+
+        assert_eq!(config.connection_url_with_host("zk.local", 2181), "zookeeper://digest:secret@zk.local:2181");
+    }
+
+    #[test]
+    fn legacy_single_ssh_config_migrates_to_transport_layer() {
+        let config: ConnectionConfig = serde_json::from_value(serde_json::json!({
+            "id": "id",
+            "name": "name",
+            "db_type": "mysql",
+            "host": "10.1.2.3",
+            "port": 3306,
+            "username": "root",
+            "password": "",
+            "database": null,
+            "ssh_enabled": true,
+            "ssh_host": "bastion.example.com",
+            "ssh_port": 2200,
+            "ssh_user": "deploy",
+            "ssh_password": "secret",
+            "ssh_connect_timeout_secs": 0,
+            "ssh_expose_lan": true
+        }))
+        .unwrap();
+
+        let hops = config.effective_ssh_tunnels();
+        assert_eq!(hops.len(), 1);
+        assert_eq!(hops[0].id, "legacy");
+        assert_eq!(hops[0].host, "bastion.example.com");
+        assert_eq!(hops[0].port, 2200);
+        assert_eq!(hops[0].user, "deploy");
+        assert_eq!(hops[0].password, "secret");
+        assert_eq!(hops[0].connect_timeout_secs, default_ssh_connect_timeout_secs());
+        assert!(hops[0].expose_lan);
+    }
+
+    #[test]
+    fn missing_connection_timeout_defaults_to_ten_seconds() {
+        let config: ConnectionConfig = serde_json::from_value(serde_json::json!({
+            "id": "id",
+            "name": "name",
+            "db_type": "mysql",
+            "host": "10.1.2.3",
+            "port": 3306,
+            "username": "root",
+            "password": "",
+            "database": null
+        }))
+        .unwrap();
+
+        assert_eq!(config.connect_timeout_secs, 10);
+        assert_eq!(config.effective_connect_timeout_secs(), 10);
+    }
+
+    #[test]
+    fn legacy_ssh_tunnels_migrate_to_ordered_transport_layers() {
+        let config: ConnectionConfig = serde_json::from_value(serde_json::json!({
+            "id": "id",
+            "name": "name",
+            "db_type": "mysql",
+            "host": "10.1.2.3",
+            "port": 3306,
+            "username": "root",
+            "password": "",
+            "database": null,
+            "ssh_enabled": true,
+            "ssh_tunnels": [
+                { "id": "first", "host": "a", "port": 22, "user": "u" },
+                { "id": "second", "host": "b", "port": 2200, "user": "u" }
+            ]
+        }))
+        .unwrap();
+
+        let hops = config.effective_ssh_tunnels();
+        assert_eq!(hops.iter().map(|hop| hop.id.as_str()).collect::<Vec<_>>(), vec!["first", "second"]);
+    }
+
+    #[test]
+    fn legacy_proxy_config_migrates_to_transport_layer() {
+        let config: ConnectionConfig = serde_json::from_value(serde_json::json!({
+            "id": "id",
+            "name": "name",
+            "db_type": "mysql",
+            "host": "10.1.2.3",
+            "port": 3306,
+            "username": "root",
+            "password": "",
+            "database": null,
+            "proxy_enabled": true,
+            "proxy_type": "http",
+            "proxy_host": "proxy.example.com",
+            "proxy_port": 8080,
+            "proxy_username": "alice",
+            "proxy_password": "secret"
+        }))
+        .unwrap();
+
+        assert_eq!(config.transport_layers.len(), 1);
+        match &config.transport_layers[0] {
+            TransportLayerConfig::Proxy(proxy) => {
+                assert_eq!(proxy.id, "legacy-proxy");
+                assert_eq!(proxy.proxy_type, ProxyType::Http);
+                assert_eq!(proxy.host, "proxy.example.com");
+                assert_eq!(proxy.port, 8080);
+                assert_eq!(proxy.username, "alice");
+                assert_eq!(proxy.password, "secret");
+            }
+            _ => panic!("expected proxy layer"),
+        }
+    }
+
+    #[test]
+    fn existing_transport_layers_take_precedence_over_legacy_fields() {
+        let config: ConnectionConfig = serde_json::from_value(serde_json::json!({
+            "id": "id",
+            "name": "name",
+            "db_type": "mysql",
+            "host": "10.1.2.3",
+            "port": 3306,
+            "username": "root",
+            "password": "",
+            "database": null,
+            "ssh_enabled": true,
+            "ssh_host": "legacy.example.com",
+            "transport_layers": [{ "type": "proxy", "id": "proxy", "host": "proxy", "port": 1080 }]
+        }))
+        .unwrap();
+
+        assert_eq!(config.transport_layers.len(), 1);
+        assert!(matches!(&config.transport_layers[0], TransportLayerConfig::Proxy(proxy) if proxy.id == "proxy"));
+    }
+
+    #[test]
+    fn serialized_connection_config_omits_legacy_transport_fields() {
+        let mut config = mysql_config("root", "", None);
+        config.transport_layers = vec![TransportLayerConfig::Proxy(ProxyTunnelConfig {
+            profile_id: String::new(),
+            id: "proxy".to_string(),
+            name: String::new(),
+            enabled: true,
+            proxy_type: ProxyType::Socks5,
+            host: "proxy".to_string(),
+            port: 1080,
+            username: String::new(),
+            password: String::new(),
+        })];
+
+        let saved = serde_json::to_value(config).unwrap();
+
+        assert!(saved.get("transport_layers").is_some());
+        for key in ["ssh_tunnels", "ssh_host", "ssh_password", "proxy_host", "proxy_password", "proxy_enabled"] {
+            assert!(saved.get(key).is_none(), "legacy key {key} should not serialize");
+        }
+    }
+
+    #[test]
+    fn query_timeout_zero_disables_timeout() {
+        let mut config = mysql_config("root", "", None);
+        config.query_timeout_secs = 0;
+
+        assert_eq!(config.effective_query_timeout_secs(), 0);
+    }
+
+    #[test]
+    fn query_timeout_preserves_long_running_exports() {
+        let mut config = mysql_config("root", "", None);
+        config.query_timeout_secs = 3600;
+
+        assert_eq!(config.effective_query_timeout_secs(), 3600);
+    }
+
+    #[test]
+    fn mysql_url_encodes_oceanbase_username() {
+        let config = mysql_config("user@tenant#cluster", "secret", None);
+
+        assert_eq!(
+            config.connection_url(),
+            "mysql://user%40tenant%23cluster:secret@10.1.2.3:2883?ssl-mode=disabled&charset=utf8mb4"
+        );
+    }
+
+    #[test]
+    fn oceanbase_profile_uses_bare_mysql_connection_options() {
+        let mut config = mysql_config("user@tenant#cluster", "secret", None);
+        config.driver_profile = Some("oceanbase".to_string());
+
+        assert!(config.needs_bare_mysql());
+        assert_eq!(config.connection_url(), "mysql://user%40tenant%23cluster:secret@10.1.2.3:2883");
+    }
+
+    #[test]
+    fn starrocks_profile_omits_mysql_ssl_mode_param_when_tls_disabled() {
+        let mut config = mysql_config("root", "secret", Some("analytics"));
+        config.driver_profile = Some("starrocks".to_string());
+        config.url_params = Some(
+            "ssl-mode=disabled&sslmode=required&require_ssl=true&verify_ca=false&verify_identity=false&charset=utf8mb4"
+                .to_string(),
+        );
+
+        assert!(config.needs_bare_mysql());
+        assert!(!config.bare_mysql_uses_tls());
+        assert_eq!(config.connection_url(), "mysql://root:secret@10.1.2.3:2883/analytics");
+    }
+
+    #[test]
+    fn starrocks_profile_preserves_mysql_tls_params_when_enabled() {
+        let mut config = mysql_config("root", "secret", Some("analytics"));
+        config.driver_profile = Some("starrocks".to_string());
+        config.ssl = true;
+        config.url_params = Some("verify_ca=true&verify_identity=false".to_string());
+
+        assert!(config.bare_mysql_uses_tls());
+        assert_eq!(
+            config.connection_url(),
+            "mysql://root:secret@10.1.2.3:2883/analytics?require_ssl=true&verify_ca=true&verify_identity=false&charset=utf8mb4"
+        );
+    }
+
+    #[test]
+    fn starrocks_database_type_preserves_mysql_tls_params_when_enabled() {
+        let mut config = mysql_config("root", "secret", Some("analytics"));
+        config.db_type = DatabaseType::StarRocks;
+        config.ssl = true;
+        config.ca_cert_path = "/tmp/starrocks-ca.pem".to_string();
+
+        assert!(config.bare_mysql_uses_tls());
+        assert_eq!(
+            config.connection_url(),
+            "mysql://root:secret@10.1.2.3:2883/analytics?require_ssl=true&verify_identity=false&charset=utf8mb4"
+        );
+    }
+
+    #[test]
+    fn starrocks_profile_keeps_non_mysql_tls_params() {
+        let mut config = mysql_config("root", "secret", Some("analytics"));
+        config.driver_profile = Some("starrocks".to_string());
+        config.url_params = Some("connect_timeout=10&sessionVariables=query_timeout=60".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "mysql://root:secret@10.1.2.3:2883/analytics?connect_timeout=10&sessionVariables=query_timeout=60"
+        );
+    }
+
+    #[test]
+    fn tdengine_profile_is_canonicalized_to_agent_database_type() {
+        let mut config = mysql_config("root", "taosdata", Some("power"));
+        config.driver_profile = Some("tdengine".to_string());
+        config.driver_label = None;
+        config.port = 6030;
+
+        let canonical = config.canonicalized();
+
+        assert_eq!(canonical.db_type, DatabaseType::Tdengine);
+        assert_eq!(canonical.port, 6041);
+        assert_eq!(canonical.driver_profile.as_deref(), Some("tdengine"));
+        assert_eq!(canonical.driver_label.as_deref(), Some("TDengine"));
+        assert!(!canonical.needs_bare_mysql());
+    }
+
+    #[test]
+    fn informix_empty_database_uses_sysmaster_for_connection() {
+        let mut config = mysql_config("informix", "in4mix", None);
+        config.db_type = DatabaseType::Informix;
+        config.port = 9088;
+
+        assert_eq!(config.effective_database(), Some("sysmaster"));
+        assert_eq!(config.connection_url(), "informix://informix:in4mix@10.1.2.3:9088/sysmaster");
+    }
+
+    #[test]
+    fn h2_empty_database_uses_test_for_connection() {
+        let mut config = mysql_config("sa", "", None);
+        config.db_type = DatabaseType::H2;
+        config.port = 9092;
+
+        assert_eq!(config.effective_database(), Some("test"));
+        assert_eq!(config.connection_url(), "h2://sa:@10.1.2.3:9092/test");
+    }
+
+    #[test]
+    fn neo4j_empty_database_uses_neo4j_for_connection() {
+        let mut config = mysql_config("neo4j", "secret", None);
+        config.db_type = DatabaseType::Neo4j;
+        config.port = 7687;
+
+        assert_eq!(config.effective_database(), Some("neo4j"));
+        assert_eq!(config.connection_url(), "neo4j://neo4j:secret@10.1.2.3:7687/neo4j");
+    }
+
+    #[test]
+    fn clickhouse_empty_database_uses_default() {
+        let mut config = mysql_config("default", "", None);
+        config.db_type = DatabaseType::ClickHouse;
+        config.port = 8123;
+
+        assert_eq!(config.effective_database(), Some("default"));
+    }
+
+    #[test]
+    fn kingbase_empty_database_has_no_default() {
+        let mut config = mysql_config("SYSTEM", "secret", None);
+        config.db_type = DatabaseType::Kingbase;
+        config.port = 54321;
+
+        assert_eq!(config.effective_database(), None);
+        assert_eq!(config.connection_url(), "kingbase://SYSTEM:secret@10.1.2.3:54321");
+    }
+
+    #[test]
+    fn vastbase_empty_database_uses_postgres_for_connection() {
+        let mut config = mysql_config("vastbase", "secret", None);
+        config.db_type = DatabaseType::Vastbase;
+        config.port = 5432;
+
+        assert_eq!(config.effective_database(), Some("postgres"));
+        assert_eq!(config.connection_url(), "vastbase://vastbase:secret@10.1.2.3:5432/postgres");
+    }
+
+    #[test]
+    fn clickhouse_tls_uses_https_from_ssl_or_secure_param() {
+        let mut config = mysql_config("default", "", None);
+        config.db_type = DatabaseType::ClickHouse;
+        config.port = 8443;
+
+        assert_eq!(config.connection_url(), "http://10.1.2.3:8443");
+
+        config.ssl = true;
+        assert_eq!(config.connection_url(), "https://10.1.2.3:8443");
+
+        config.ssl = false;
+        config.url_params = Some("secure=true".to_string());
+        assert_eq!(config.connection_url(), "https://10.1.2.3:8443");
+    }
+
+    #[test]
+    fn clickhouse_host_may_include_http_scheme() {
+        let mut config = mysql_config("default", "", None);
+        config.db_type = DatabaseType::ClickHouse;
+        config.host = "https://clickhouse.example.com".to_string();
+        config.port = 8443;
+
+        assert_eq!(config.connection_url(), "https://clickhouse.example.com:8443");
+    }
+
+    #[test]
+    fn mysql_url_encodes_password_and_database() {
+        let config = mysql_config("root", "p@ss:word#1", Some("db/name"));
+
+        assert_eq!(
+            config.connection_url(),
+            "mysql://root:p%40ss%3Aword%231@10.1.2.3:2883/db%2Fname?ssl-mode=disabled&charset=utf8mb4"
+        );
+    }
+
+    #[test]
+    fn mysql_url_appends_custom_params() {
+        let mut config = mysql_config("root", "secret", Some("test"));
+        config.url_params = Some("charset=utf8mb4".to_string());
+
+        assert_eq!(config.connection_url(), "mysql://root:secret@10.1.2.3:2883/test?ssl-mode=disabled&charset=utf8mb4");
+    }
+
+    #[test]
+    fn mysql_cleartext_password_auth_alias_normalizes_to_driver_param() {
+        let mut config = mysql_config("root", "secret", Some("test"));
+        config.url_params = Some("allowCleartextPasswords=true".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "mysql://root:secret@10.1.2.3:2883/test?ssl-mode=disabled&charset=utf8mb4&enable_cleartext_plugin=true"
+        );
+    }
+
+    #[test]
+    fn mysql_cleartext_password_auth_keeps_canonical_driver_param() {
+        let mut config = mysql_config("root", "secret", Some("test"));
+        config.url_params = Some("enable_cleartext_plugin=true".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "mysql://root:secret@10.1.2.3:2883/test?ssl-mode=disabled&charset=utf8mb4&enable_cleartext_plugin=true"
+        );
+    }
+
+    #[test]
+    fn mysql_cleartext_password_auth_deduplicates_aliases() {
+        let mut config = mysql_config("root", "secret", Some("test"));
+        config.url_params =
+            Some("allowCleartextPasswords=true&enable_cleartext_plugin=true&charset=utf8mb4".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "mysql://root:secret@10.1.2.3:2883/test?ssl-mode=disabled&charset=utf8mb4&enable_cleartext_plugin=true"
+        );
+    }
+
+    #[test]
+    fn mysql_cleartext_password_auth_omits_disabled_values() {
+        let mut config = mysql_config("root", "secret", Some("test"));
+        config.url_params = Some("allowCleartextPasswords=false&enable_cleartext_plugin=&charset=utf8mb4".to_string());
+
+        assert_eq!(config.connection_url(), "mysql://root:secret@10.1.2.3:2883/test?ssl-mode=disabled&charset=utf8mb4");
+    }
+
+    #[test]
+    fn mysql_tls_switch_requires_ssl_without_strict_certificate_checks_by_default() {
+        let mut config = mysql_config("root", "secret", Some("test"));
+        config.ssl = true;
+
+        assert_eq!(
+            config.connection_url(),
+            "mysql://root:secret@10.1.2.3:2883/test?require_ssl=true&verify_ca=false&verify_identity=false&charset=utf8mb4"
+        );
+    }
+
+    #[test]
+    fn mysql_explicit_preferred_tls_mode_is_preserved() {
+        let mut config = mysql_config("root", "secret", Some("test"));
+        config.url_params = Some("ssl-mode=preferred".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "mysql://root:secret@10.1.2.3:2883/test?ssl-mode=preferred&charset=utf8mb4"
+        );
+    }
+
+    #[test]
+    fn mysql_tls_switch_uses_ca_cert_for_ca_validation() {
+        let mut config = mysql_config("root", "secret", Some("test"));
+        config.ssl = true;
+        config.ca_cert_path = "/tmp/tidb-ca.pem".to_string();
+
+        assert_eq!(
+            config.connection_url(),
+            "mysql://root:secret@10.1.2.3:2883/test?require_ssl=true&verify_identity=false&charset=utf8mb4"
+        );
+    }
+
+    #[test]
+    fn tidb_cloud_mysql_url_requires_tls() {
+        let mut config = mysql_config("root", "secret", Some("test"));
+        config.host = "gateway01.us-west-2.prod.aws.tidbcloud.com".to_string();
+        config.port = 4000;
+        config.url_params = Some("require_ssl=false&charset=utf8mb4".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "mysql://root:secret@gateway01.us-west-2.prod.aws.tidbcloud.com:4000/test?require_ssl=true&charset=utf8mb4&verify_ca=false&verify_identity=false"
+        );
+    }
+
+    #[test]
+    fn postgres_url_appends_custom_params() {
+        let mut config = mysql_config("postgres", "secret", Some("test"));
+        config.db_type = DatabaseType::Postgres;
+        config.url_params = Some("sslmode=disable".to_string());
+
+        assert_eq!(config.connection_url(), "postgres://postgres:secret@10.1.2.3:2883/test?sslmode=disable");
+    }
+
+    #[test]
+    fn postgres_tls_switch_adds_require_sslmode() {
+        let mut config = mysql_config("postgres", "secret", Some("test"));
+        config.db_type = DatabaseType::Postgres;
+        config.ssl = true;
+
+        assert_eq!(config.connection_url(), "postgres://postgres:secret@10.1.2.3:2883/test?sslmode=require");
+    }
+
+    #[test]
+    fn postgres_url_normalizes_timezone_param_into_options() {
+        let mut config = mysql_config("postgres", "secret", Some("test"));
+        config.db_type = DatabaseType::Postgres;
+        config.url_params = Some("sslmode=require&timezone=Asia/Shanghai".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "postgres://postgres:secret@10.1.2.3:2883/test?sslmode=require&options=%2Dc%20TimeZone%3DAsia%2FShanghai"
+        );
+        let pg_config = tokio_postgres::Config::from_str(&config.connection_url()).unwrap();
+        assert_eq!(pg_config.get_options(), Some("-c TimeZone=Asia/Shanghai"));
+    }
+
+    #[test]
+    fn postgres_url_maps_schema_param_into_search_path_options() {
+        let mut config = mysql_config("postgres", "secret", Some("test"));
+        config.db_type = DatabaseType::Postgres;
+        config.url_params = Some("schema=public".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "postgres://postgres:secret@10.1.2.3:2883/test?options=%2Dc%20search%5Fpath%3Dpublic"
+        );
+        let pg_config = tokio_postgres::Config::from_str(&config.connection_url()).unwrap();
+        assert_eq!(pg_config.get_options(), Some("-c search_path=public"));
+    }
+
+    #[test]
+    fn postgres_url_maps_current_schema_param_into_search_path_options() {
+        let mut config = mysql_config("postgres", "secret", Some("test"));
+        config.db_type = DatabaseType::Postgres;
+        config.url_params = Some("currentSchema=app".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "postgres://postgres:secret@10.1.2.3:2883/test?options=%2Dc%20search%5Fpath%3Dapp"
+        );
+        let pg_config = tokio_postgres::Config::from_str(&config.connection_url()).unwrap();
+        assert_eq!(pg_config.get_options(), Some("-c search_path=app"));
+    }
+
+    #[test]
+    fn postgres_url_ignores_mysql_only_params_from_saved_connections() {
+        let mut config = mysql_config("postgres", "secret", Some("test"));
+        config.db_type = DatabaseType::Postgres;
+        config.url_params = Some("ssl-mode=preferred&charset=utf8mb4".to_string());
+
+        assert_eq!(config.connection_url(), "postgres://postgres:secret@10.1.2.3:2883/test?sslmode=prefer");
+        tokio_postgres::Config::from_str(&config.connection_url()).unwrap();
+    }
+
+    #[test]
+    fn postgres_url_maps_mysql_ssl_mode_require_to_sslmode() {
+        let mut config = mysql_config("postgres", "secret", Some("test"));
+        config.db_type = DatabaseType::Postgres;
+        config.url_params = Some("ssl-mode=required&verify_ca=false&verify_identity=false".to_string());
+
+        assert_eq!(config.connection_url(), "postgres://postgres:secret@10.1.2.3:2883/test?sslmode=require");
+        tokio_postgres::Config::from_str(&config.connection_url()).unwrap();
+    }
+
+    #[test]
+    fn postgres_url_appends_timezone_to_existing_options() {
+        let mut config = mysql_config("postgres", "secret", Some("test"));
+        config.db_type = DatabaseType::Postgres;
+        config.url_params = Some("options=-c%20statement_timeout%3D5000&TimeZone=UTC".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "postgres://postgres:secret@10.1.2.3:2883/test?options=%2Dc%20statement%5Ftimeout%3D5000%20%2Dc%20TimeZone%3DUTC"
+        );
+    }
+
+    #[test]
+    fn postgres_url_keeps_existing_options_timezone() {
+        let mut config = mysql_config("postgres", "secret", Some("test"));
+        config.db_type = DatabaseType::Postgres;
+        config.url_params = Some("options=-c%20TimeZone%3DUTC&timezone=Asia/Shanghai".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "postgres://postgres:secret@10.1.2.3:2883/test?options=-c%20TimeZone%3DUTC"
+        );
+    }
+
+    #[test]
+    fn postgres_url_defaults_to_postgres_database_when_omitted() {
+        let mut config = mysql_config("root", "secret", None);
+        config.db_type = DatabaseType::Postgres;
+
+        assert_eq!(config.connection_url(), "postgres://root:secret@10.1.2.3:2883/postgres");
+    }
+
+    #[test]
+    fn postgres_url_defaults_to_postgres_database_when_empty() {
+        let mut config = mysql_config("root", "secret", Some(""));
+        config.db_type = DatabaseType::Postgres;
+
+        assert_eq!(config.connection_url(), "postgres://root:secret@10.1.2.3:2883/postgres");
+    }
+
+    #[test]
+    fn redshift_url_defaults_to_dev_database_when_empty() {
+        let mut config = mysql_config("awsuser", "secret", Some(""));
+        config.db_type = DatabaseType::Redshift;
+
+        assert_eq!(config.connection_url(), "postgres://awsuser:secret@10.1.2.3:2883/dev");
+    }
+
+    #[test]
+    fn cockroachdb_url_defaults_to_defaultdb_database() {
+        let mut config = mysql_config("root", "secret", None);
+        config.db_type = DatabaseType::Postgres;
+        config.driver_profile = Some("cockroachdb".to_string());
+
+        assert_eq!(config.connection_url(), "postgres://root:secret@10.1.2.3:2883/defaultdb");
+    }
+
+    #[test]
+    fn gaussdb_url_defaults_to_postgres_database() {
+        let mut config = mysql_config("gaussdb", "secret", None);
+        config.db_type = DatabaseType::Gaussdb;
+
+        assert_eq!(config.connection_url(), "gaussdb://gaussdb:secret@10.1.2.3:2883/postgres");
+    }
+
+    #[test]
+    fn kwdb_url_defaults_to_defaultdb_database() {
+        let mut config = mysql_config("root", "secret", None);
+        config.db_type = DatabaseType::Kwdb;
+
+        assert_eq!(config.connection_url(), "kwdb://root:secret@10.1.2.3:2883/defaultdb");
+    }
+
+    #[test]
+    fn yashandb_url_defaults_to_yasdb_database() {
+        let mut config = mysql_config("sys", "secret", None);
+        config.db_type = DatabaseType::Yashandb;
+
+        assert_eq!(config.connection_url(), "yashandb://sys:secret@10.1.2.3:2883/yasdb");
+    }
+
+    #[test]
+    fn oscar_url_defaults_to_osrdb_database() {
+        let mut config = mysql_config("SYSDBA", "secret", None);
+        config.db_type = DatabaseType::Oscar;
+
+        assert_eq!(config.connection_url(), "oscar://SYSDBA:secret@10.1.2.3:2883/osrdb");
+    }
+
+    #[test]
+    fn mongodb_form_url_without_params_defaults_auth_source_to_admin() {
+        let config = mongodb_config("root", "secret", Some("admin"));
+
+        assert_eq!(config.connection_url(), "mongodb://root:secret@10.1.2.3:17000/admin?authSource=admin");
+    }
+
+    #[test]
+    fn mongodb_form_url_default_database_does_not_change_auth_source() {
+        let config = mongodb_config("root", "secret", Some("app"));
+
+        assert_eq!(config.connection_url(), "mongodb://root:secret@10.1.2.3:17000/app?authSource=admin");
+    }
+
+    #[test]
+    fn mongodb_form_url_without_database_keeps_slash_before_params() {
+        let config = mongodb_config("root", "secret", None);
+
+        assert_eq!(config.connection_url(), "mongodb://root:secret@10.1.2.3:17000/?authSource=admin");
+        assert_eq!(config.redacted_connection_url(), "mongodb://10.1.2.3:17000/?authSource=admin");
+    }
+
+    #[test]
+    fn mongodb_form_url_without_username_does_not_default_auth_source() {
+        let config = mongodb_config("", "", Some("app"));
+
+        assert_eq!(config.connection_url(), "mongodb://10.1.2.3:17000/app");
+    }
+
+    #[test]
+    fn mongodb_form_url_preserves_explicit_auth_source() {
+        let mut config = mongodb_config("root", "secret", Some("app"));
+        config.url_params = Some("authSource=app".to_string());
+
+        assert_eq!(config.connection_url(), "mongodb://root:secret@10.1.2.3:17000/app?authSource=app");
+    }
+
+    #[test]
+    fn mongodb_form_url_appends_custom_params() {
+        let mut config = mongodb_config("root", "secret", Some("app"));
+        config.url_params = Some("?authSource=admin&authMechanism=SCRAM-SHA-1&directConnection=true".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "mongodb://root:secret@10.1.2.3:17000/app?authSource=admin&authMechanism=SCRAM-SHA-1&directConnection=true"
+        );
+    }
+
+    #[test]
+    fn redacted_mysql_url_omits_credentials() {
+        let config = mysql_config("user@tenant#cluster", "p@ss:word#1", Some("db/name"));
+
+        let url = config.redacted_connection_url();
+
+        assert_eq!(url, "mysql://10.1.2.3:2883/db%2Fname?ssl-mode=disabled&charset=utf8mb4");
+        assert!(!url.contains("user"));
+        assert!(!url.contains("p%40ss"));
+        assert!(!url.contains("p@ss"));
+    }
+
+    #[test]
+    fn redacted_sqlserver_url_omits_credentials() {
+        let mut config = mysql_config("sa", "super-secret", Some("master"));
+        config.db_type = DatabaseType::SqlServer;
+
+        let url = config.redacted_connection_url();
+
+        assert_eq!(url, "server=tcp:10.1.2.3,2883;database=master");
+        assert!(!url.contains("sa"));
+        assert!(!url.contains("super-secret"));
+    }
+
+    #[test]
+    fn redacted_redis_url_omits_credentials_and_keeps_tls_scheme() {
+        let mut config = mysql_config("default", "redis-secret", None);
+        config.db_type = DatabaseType::Redis;
+        config.ssl = true;
+
+        let url = config.redacted_connection_url();
+
+        assert_eq!(url, "rediss://10.1.2.3:2883/");
+        assert!(!url.contains("default"));
+        assert!(!url.contains("redis-secret"));
+    }
+
+    #[test]
+    fn redis_tls_insecure_url_params_append_insecure_fragment() {
+        let mut config = mysql_config("default", "secret", Some("0"));
+        config.db_type = DatabaseType::Redis;
+        config.ssl = true;
+        config.url_params = Some("insecure=true".to_string());
+
+        assert_eq!(config.connection_url(), "rediss://default:secret@10.1.2.3:2883/#insecure");
+        assert_eq!(config.redacted_connection_url(), "rediss://10.1.2.3:2883/#insecure");
+    }
+
+    #[test]
+    fn redis_insecure_url_params_do_not_affect_plain_tcp() {
+        let mut config = mysql_config("default", "secret", Some("0"));
+        config.db_type = DatabaseType::Redis;
+        config.url_params = Some("insecure=true".to_string());
+
+        assert_eq!(config.connection_url(), "redis://default:secret@10.1.2.3:2883/");
+    }
+
+    #[test]
+    fn redacted_mongodb_url_keeps_custom_params_without_credentials() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.url_params = Some("authSource=admin&authMechanism=SCRAM-SHA-1".to_string());
+
+        let url = config.redacted_connection_url();
+
+        assert_eq!(url, "mongodb://10.1.2.3:17000/admin?authSource=admin&authMechanism=SCRAM-SHA-1");
+        assert!(!url.contains("root"));
+        assert!(!url.contains("secret"));
+    }
+
+    #[test]
+    fn mongodb_form_tls_uses_standard_scheme_and_tls_param() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.ssl = true;
+
+        assert_eq!(config.connection_url(), "mongodb://root:secret@10.1.2.3:17000/admin?tls=true&authSource=admin");
+        assert_eq!(config.redacted_connection_url(), "mongodb://10.1.2.3:17000/admin?tls=true&authSource=admin");
+    }
+
+    #[test]
+    fn mongodb_form_tls_replaces_existing_tls_params() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.ssl = true;
+        config.url_params = Some("authSource=admin&ssl=false&tls=false".to_string());
+
+        assert_eq!(config.connection_url(), "mongodb://root:secret@10.1.2.3:17000/admin?tls=true&authSource=admin");
+    }
+
+    #[test]
+    fn mongodb_form_tls_ca_cert_adds_tls_ca_file_param() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.ssl = true;
+        config.ca_cert_path = "/tmp/mongo-ca.pem".to_string();
+
+        assert_eq!(
+            config.connection_url(),
+            "mongodb://root:secret@10.1.2.3:17000/admin?tls=true&tlsCAFile=%2Ftmp%2Fmongo%2Dca%2Epem&authSource=admin"
+        );
+    }
+
+    #[test]
+    fn mongodb_form_tls_cert_params_replace_existing_url_values() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.ssl = true;
+        config.ca_cert_path = "/tmp/new-ca.pem".to_string();
+        config.url_params = Some("tlsCAFile=%2Fold-ca.pem&authSource=admin".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "mongodb://root:secret@10.1.2.3:17000/admin?tls=true&authSource=admin&tlsCAFile=%2Ftmp%2Fnew%2Dca%2Epem"
+        );
+    }
+
+    #[test]
+    fn mongodb_form_tls_preserves_legacy_tls_ca_file_in_url_params() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.ssl = true;
+        config.url_params = Some("tlsCAFile=%2Ftmp%2Flegacy-ca.pem&authSource=admin".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "mongodb://root:secret@10.1.2.3:17000/admin?tls=true&authSource=admin&tlsCAFile=%2Ftmp%2Flegacy-ca.pem"
+        );
+    }
+
+    #[test]
+    fn mongodb_form_tls_allow_invalid_hostnames_maps_to_allow_invalid_certificates() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.ssl = true;
+        config.url_params = Some("replicaSet=rs0&tlsAllowInvalidHostnames=true".to_string());
+
+        assert_eq!(
+            config.connection_url(),
+            "mongodb://root:secret@10.1.2.3:17000/admin?tls=true&replicaSet=rs0&tlsAllowInvalidCertificates=true&authSource=admin"
+        );
+        assert!(!config.connection_url().contains("tlsAllowInvalidHostnames"));
+    }
+
+    #[test]
+    fn parse_mongo_first_host_replica_set() {
+        let uri = "mongodb://user:pass@host1:27017,host2:27017,host3:27017/admin?replicaSet=rs0";
+        let (host, port) = super::parse_mongo_first_host(uri).unwrap();
+        assert_eq!(host, "host1");
+        assert_eq!(port, 27017);
+    }
+
+    #[test]
+    fn parse_mongo_first_host_single() {
+        let uri = "mongodb://user:pass@myhost:30000/db";
+        let (host, port) = super::parse_mongo_first_host(uri).unwrap();
+        assert_eq!(host, "myhost");
+        assert_eq!(port, 30000);
+    }
+
+    #[test]
+    fn parse_mongo_first_host_no_creds() {
+        let uri = "mongodb://host1:27017,host2:27017/admin";
+        let (host, port) = super::parse_mongo_first_host(uri).unwrap();
+        assert_eq!(host, "host1");
+        assert_eq!(port, 27017);
+    }
+
+    #[test]
+    fn parse_mongo_first_host_srv() {
+        let uri = "mongodb+srv://user:pass@cluster0.example.net/db";
+        let (host, port) = super::parse_mongo_first_host(uri).unwrap();
+        assert_eq!(host, "cluster0.example.net");
+        assert_eq!(port, 27017);
+    }
+
+    #[test]
+    fn mongodb_connection_string_rewritten_when_tunneled() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.connection_string =
+            Some("mongodb://read:pass@host1:27017,host2:27017/admin?replicaSet=rs0&authSource=admin".to_string());
+
+        let url = config.connection_url_with_host("127.0.0.1", 54321);
+
+        assert_eq!(
+            url,
+            "mongodb://read:pass@127.0.0.1:54321/admin?replicaSet=rs0&authSource=admin&directConnection=true"
+        );
+    }
+
+    #[test]
+    fn mongodb_connection_string_unchanged_when_not_tunneled() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.connection_string = Some("mongodb://read:pass@host1:27017,host2:27017/admin?replicaSet=rs0".to_string());
+
+        let url = config.connection_url();
+
+        assert_eq!(url, "mongodb://read:pass@host1:27017,host2:27017/admin?replicaSet=rs0");
+    }
+
+    #[test]
+    fn mongodb_connection_string_without_database_keeps_slash_before_params() {
+        let mut config = mongodb_config("root", "secret", None);
+        config.connection_string = Some("mongodb://read:pass@host1:27017?authSource=admin".to_string());
+
+        let url = config.connection_url();
+
+        assert_eq!(url, "mongodb://read:pass@host1:27017/?authSource=admin");
+    }
+
+    #[test]
+    fn mongodb_connection_string_without_database_keeps_slash_when_tunneled() {
+        let mut config = mongodb_config("root", "secret", None);
+        config.connection_string = Some("mongodb://read:pass@host1:27017?authSource=admin".to_string());
+
+        let url = config.connection_url_with_host("127.0.0.1", 54321);
+
+        assert_eq!(url, "mongodb://read:pass@127.0.0.1:54321/?authSource=admin&directConnection=true");
+    }
+
+    #[test]
+    fn mongodb_multi_seed_connection_string_removes_direct_connection_true() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.connection_string = Some(
+            "mongodb://read:pass@host1:27017,host2:27017/admin?directConnection=true&replicaSet=rs0&authSource=admin"
+                .to_string(),
+        );
+
+        let url = config.connection_url();
+
+        assert_eq!(url, "mongodb://read:pass@host1:27017,host2:27017/admin?replicaSet=rs0&authSource=admin");
+    }
+
+    #[test]
+    fn mongodb_srv_connection_string_removes_direct_connection_true() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.connection_string = Some(
+            "mongodb+srv://read:pass@cluster.example.net/admin?tls=true&authSource=admin&directConnection=true&replicaSet=rs0"
+                .to_string(),
+        );
+
+        let url = config.connection_url();
+
+        assert_eq!(url, "mongodb+srv://read:pass@cluster.example.net/admin?tls=true&authSource=admin&replicaSet=rs0");
+    }
+
+    #[test]
+    fn mongodb_single_seed_connection_string_keeps_direct_connection_true() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.connection_string =
+            Some("mongodb://read:pass@host1:27017/admin?directConnection=true&authSource=admin".to_string());
+
+        let url = config.connection_url();
+
+        assert_eq!(url, "mongodb://read:pass@host1:27017/admin?directConnection=true&authSource=admin");
+    }
+
+    #[test]
+    fn mongodb_form_url_adds_direct_connection_when_tunneled() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.url_params = Some("replicaSet=rs0&authSource=admin".to_string());
+
+        let url = config.connection_url_with_host("127.0.0.1", 54321);
+
+        assert_eq!(
+            url,
+            "mongodb://root:secret@127.0.0.1:54321/admin?replicaSet=rs0&authSource=admin&directConnection=true"
+        );
+    }
+
+    #[test]
+    fn mongodb_form_url_without_database_keeps_slash_before_tunneled_params() {
+        let config = mongodb_config("root", "secret", None);
+
+        let url = config.connection_url_with_host("127.0.0.1", 54321);
+
+        assert_eq!(url, "mongodb://root:secret@127.0.0.1:54321/?authSource=admin&directConnection=true");
+    }
+
+    #[test]
+    fn mongodb_form_url_no_duplicate_direct_connection() {
+        let mut config = mongodb_config("root", "secret", Some("admin"));
+        config.url_params = Some("directConnection=true&authSource=admin".to_string());
+
+        let url = config.connection_url_with_host("127.0.0.1", 54321);
+
+        assert!(url.matches("directConnection").count() == 1);
+    }
+
+    #[test]
+    fn parse_jdbc_host_port_postgresql() {
+        let (h, p) = super::parse_jdbc_host_port("jdbc:postgresql://myhost:5432/mydb").unwrap();
+        assert_eq!(h, "myhost");
+        assert_eq!(p, 5432);
+    }
+
+    #[test]
+    fn parse_jdbc_host_port_mysql() {
+        let (h, p) = super::parse_jdbc_host_port("jdbc:mysql://db.example.com:3306/app?useSSL=false").unwrap();
+        assert_eq!(h, "db.example.com");
+        assert_eq!(p, 3306);
+    }
+
+    #[test]
+    fn parse_jdbc_host_port_with_userinfo() {
+        let (h, p) = super::parse_jdbc_host_port("jdbc:postgresql://user:pass@pghost:5433/db").unwrap();
+        assert_eq!(h, "pghost");
+        assert_eq!(p, 5433);
+    }
+
+    #[test]
+    fn parse_jdbc_host_port_oracle_thin() {
+        let (h, p) = super::parse_jdbc_host_port("jdbc:oracle:thin:@orahost:1521:ORCL").unwrap();
+        assert_eq!(h, "orahost");
+        assert_eq!(p, 1521);
+    }
+
+    #[test]
+    fn parse_jdbc_host_port_oracle_service() {
+        let (h, p) = super::parse_jdbc_host_port("jdbc:oracle:thin:@//orahost:1521/service").unwrap();
+        assert_eq!(h, "orahost");
+        assert_eq!(p, 1521);
+    }
+
+    #[test]
+    fn parse_jdbc_host_port_oracle_descriptor() {
+        let (h, p) = super::parse_jdbc_host_port(
+            "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=orahost)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=orcl)))",
+        )
+        .unwrap();
+        assert_eq!(h, "orahost");
+        assert_eq!(p, 1521);
+    }
+
+    #[test]
+    fn rewrite_jdbc_url_host_oracle_descriptor() {
+        let url =
+            "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=orahost)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=orcl)))";
+
+        assert_eq!(
+            super::rewrite_jdbc_url_host(url, "127.0.0.1", 11521),
+            "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=127.0.0.1)(PORT=11521))(CONNECT_DATA=(SERVICE_NAME=orcl)))"
+        );
+    }
+
+    #[test]
+    fn parse_jdbc_host_port_sqlserver() {
+        let (h, p) = super::parse_jdbc_host_port("jdbc:sqlserver://mshost:1433;databaseName=master").unwrap();
+        assert_eq!(h, "mshost");
+        assert_eq!(p, 1433);
+    }
+
+    #[test]
+    fn parse_jdbc_host_port_sqlserver_no_port() {
+        let (h, p) = super::parse_jdbc_host_port("jdbc:sqlserver://mshost;databaseName=master").unwrap();
+        assert_eq!(h, "mshost");
+        assert_eq!(p, 1433);
+    }
+
+    #[test]
+    fn parse_jdbc_host_port_no_port_returns_none() {
+        assert!(super::parse_jdbc_host_port("jdbc:postgresql://myhost/mydb").is_none());
+    }
+
+    #[test]
+    fn parse_jdbc_host_port_invalid_returns_none() {
+        assert!(super::parse_jdbc_host_port("not-a-jdbc-url").is_none());
+    }
+
+    #[test]
+    fn rewrite_jdbc_url_postgresql() {
+        let url = "jdbc:postgresql://myhost:5432/mydb";
+        let rewritten = super::rewrite_jdbc_url_host(url, "127.0.0.1", 54321);
+        assert_eq!(rewritten, "jdbc:postgresql://127.0.0.1:54321/mydb");
+    }
+
+    #[test]
+    fn rewrite_jdbc_url_oracle() {
+        let url = "jdbc:oracle:thin:@orahost:1521:ORCL";
+        let rewritten = super::rewrite_jdbc_url_host(url, "127.0.0.1", 54321);
+        assert_eq!(rewritten, "jdbc:oracle:thin:@127.0.0.1:54321:ORCL");
+    }
+
+    #[test]
+    fn rewrite_jdbc_url_sqlserver() {
+        let url = "jdbc:sqlserver://mshost:1433;databaseName=master";
+        let rewritten = super::rewrite_jdbc_url_host(url, "127.0.0.1", 54321);
+        assert_eq!(rewritten, "jdbc:sqlserver://127.0.0.1:54321;databaseName=master");
+    }
+
+    #[test]
+    fn rewrite_jdbc_url_unparseable_returns_original() {
+        let url = "jdbc:custom:some-opaque-string";
+        let rewritten = super::rewrite_jdbc_url_host(url, "127.0.0.1", 54321);
+        assert_eq!(rewritten, url);
+    }
+}
diff --git a/crates/dbx-core/src/models/mod.rs b/crates/dbx-core/src/models/mod.rs
new file mode 100644
index 0000000..b3b606b
--- /dev/null
+++ b/crates/dbx-core/src/models/mod.rs
@@ -0,0 +1 @@
+pub mod connection;
diff --git a/crates/dbx-core/src/mongo_ops.rs b/crates/dbx-core/src/mongo_ops.rs
new file mode 100644
index 0000000..28c3643
--- /dev/null
+++ b/crates/dbx-core/src/mongo_ops.rs
@@ -0,0 +1,384 @@
+use crate::connection::{AppState, PoolKind};
+use crate::db::mongo_driver::{self, MongoCollectionStatsResult, MongoDocumentResult, MongoDropIndexesResult};
+use crate::document_ops::CollectionInfo;
+
+async fn ensure_document_pool(state: &AppState, connection_id: &str) -> Result<(), String> {
+    state.get_or_create_pool(connection_id, None).await.map(|_| ())
+}
+
+pub async fn mongo_list_databases_core(state: &AppState, connection_id: &str) -> Result<Vec<String>, String> {
+    crate::document_ops::list_databases_core(state, connection_id).await
+}
+
+pub async fn mongo_list_collections_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+) -> Result<Vec<CollectionInfo>, String> {
+    crate::document_ops::list_collections_core(state, connection_id, database).await
+}
+
+pub async fn mongo_create_database_core(state: &AppState, connection_id: &str, database: &str) -> Result<(), String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::create_database(client, database).await,
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support create database".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn mongo_drop_database_core(state: &AppState, connection_id: &str, database: &str) -> Result<(), String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::drop_database(client, database).await,
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support drop database".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn mongo_drop_collection_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+) -> Result<(), String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::drop_collection(client, database, collection).await,
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            let _: serde_json::Value = client
+                .mongo_drop_collection(serde_json::json!({
+                    "database": database,
+                    "collection": collection,
+                }))
+                .await?;
+            Ok(())
+        }
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn mongo_server_version_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+) -> Result<String, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::server_version(client, database).await,
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            client.mongo_server_version(database).await
+        }
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn mongo_collection_stats_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    scale: Option<serde_json::Number>,
+) -> Result<MongoCollectionStatsResult, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::collection_stats(client, database, collection, scale).await,
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support collection stats helpers".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub async fn mongo_find_documents_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    skip: u64,
+    limit: i64,
+    filter: Option<&str>,
+    projection: Option<&str>,
+    sort: Option<&str>,
+) -> Result<MongoDocumentResult, String> {
+    crate::document_ops::find_documents_core(
+        state,
+        connection_id,
+        database,
+        collection,
+        skip,
+        limit,
+        filter,
+        projection,
+        sort,
+    )
+    .await
+}
+
+/// Read MongoDB documents as relaxed Extended JSON for MongoDB transfer paths.
+#[allow(clippy::too_many_arguments)]
+pub async fn mongo_find_documents_extended_json_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    skip: u64,
+    limit: i64,
+    filter: Option<&str>,
+    projection: Option<&str>,
+    sort: Option<&str>,
+) -> Result<MongoDocumentResult, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => {
+            mongo_driver::find_documents_extended_json(
+                client, database, collection, skip, limit, filter, projection, sort,
+            )
+            .await
+        }
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            let mut params = serde_json::json!({
+                "database": database,
+                "collection": collection,
+                "skip": skip,
+                "limit": limit,
+                "filter": filter,
+                "sort": sort,
+            });
+            if let Some(projection) = projection {
+                params["projection"] = serde_json::json!(projection);
+            }
+            match client.mongo_find_documents_extended_json(params.clone()).await {
+                Ok(result) => Ok(result),
+                Err(error) if is_unknown_agent_method_error(&error, "find_documents_extended_json") => {
+                    client.mongo_find_documents(params).await
+                }
+                Err(error) => Err(error),
+            }
+        }
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+fn is_unknown_agent_method_error(error: &str, method: &str) -> bool {
+    let lower = error.to_ascii_lowercase();
+    lower.contains(method) && (lower.contains("unknown method") || lower.contains("method not found"))
+}
+
+pub async fn mongo_aggregate_documents_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    pipeline_json: &str,
+    max_rows: Option<usize>,
+) -> Result<MongoDocumentResult, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => {
+            mongo_driver::aggregate_documents(client, database, collection, pipeline_json, max_rows).await
+        }
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support aggregate".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn mongo_create_index_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    keys_json: &str,
+    options_json: Option<&str>,
+) -> Result<String, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => {
+            mongo_driver::create_index(client, database, collection, keys_json, options_json).await
+        }
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            let result: serde_json::Value = client
+                .mongo_create_index(serde_json::json!({
+                    "database": database,
+                    "collection": collection,
+                    "keys_json": keys_json,
+                    "options_json": options_json,
+                }))
+                .await?;
+            Ok(result.get("name").and_then(|value| value.as_str()).unwrap_or("").to_string())
+        }
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn mongo_drop_indexes_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    indexes_json: Option<&str>,
+    single: bool,
+) -> Result<MongoDropIndexesResult, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => {
+            mongo_driver::drop_indexes(client, database, collection, indexes_json, single).await
+        }
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            client
+                .mongo_drop_indexes(serde_json::json!({
+                    "database": database,
+                    "collection": collection,
+                    "indexes_json": indexes_json,
+                    "single": single,
+                }))
+                .await
+        }
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn mongo_insert_document_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    doc_json: &str,
+) -> Result<String, String> {
+    crate::document_ops::insert_document_core(state, connection_id, database, collection, doc_json).await
+}
+
+pub async fn mongo_insert_documents_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    docs_json: &str,
+) -> Result<u64, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => mongo_driver::insert_documents(client, database, collection, docs_json).await,
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support bulk insertMany/insertOne writes".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn mongo_insert_documents_extended_json_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    docs_json: &str,
+) -> Result<u64, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => {
+            mongo_driver::insert_documents_extended_json(client, database, collection, docs_json).await
+        }
+        PoolKind::Agent(_) => Err("MongoDB legacy agent does not support bulk insertMany/insertOne writes".to_string()),
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn mongo_update_document_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    id: &str,
+    doc_json: &str,
+    routing: Option<&str>,
+) -> Result<u64, String> {
+    crate::document_ops::update_document_core(state, connection_id, database, collection, id, doc_json, routing).await
+}
+
+pub async fn mongo_update_documents_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    filter_json: &str,
+    update_json: &str,
+    many: bool,
+    options_json: Option<&str>,
+) -> Result<u64, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => {
+            mongo_driver::update_documents(client, database, collection, filter_json, update_json, many, options_json)
+                .await
+        }
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            let result: serde_json::Value = client
+                .mongo_update_documents(serde_json::json!({
+                    "database": database,
+                    "collection": collection,
+                    "filter_json": filter_json,
+                    "update_json": update_json,
+                    "many": many,
+                    "options_json": options_json,
+                }))
+                .await?;
+            Ok(result.get("modified_count").and_then(|v| v.as_u64()).unwrap_or(0))
+        }
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
+
+pub async fn mongo_delete_document_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    id: &str,
+    routing: Option<&str>,
+) -> Result<u64, String> {
+    crate::document_ops::delete_document_core(state, connection_id, database, collection, id, routing).await
+}
+
+pub async fn mongo_delete_documents_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    filter_json: &str,
+    many: bool,
+) -> Result<u64, String> {
+    ensure_document_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::MongoDb(client) => {
+            mongo_driver::delete_documents(client, database, collection, filter_json, many).await
+        }
+        PoolKind::Agent(client) => {
+            let mut client = client.lock().await;
+            let result: serde_json::Value = client
+                .mongo_delete_documents(serde_json::json!({
+                    "database": database,
+                    "collection": collection,
+                    "filter_json": filter_json,
+                    "many": many,
+                }))
+                .await?;
+            Ok(result.get("deleted_count").and_then(|v| v.as_u64()).unwrap_or(0))
+        }
+        _ => Err("Not a MongoDB connection".to_string()),
+    }
+}
diff --git a/crates/dbx-core/src/mq/README.md b/crates/dbx-core/src/mq/README.md
new file mode 100644
index 0000000..b596f35
--- /dev/null
+++ b/crates/dbx-core/src/mq/README.md
@@ -0,0 +1,54 @@
+# Message Queue Admin Module
+
+Apache Pulsar 管理 API 的 Rust 实现。
+
+## 模块结构
+
+```
+mq/
+├── mod.rs              - MqAdminRegistry 注册表
+├── types.rs            - 类型定义
+├── auth.rs             - 认证机制 (OAuth2 缓存)
+├── config.rs           - 配置解析
+├── port.rs             - MessageQueueAdmin trait
+├── service.rs          - 服务层函数
+└── adapters/
+    ├── pulsar.rs       - Pulsar 实现
+    └── pulsar_version.rs - 版本探测
+```
+
+## 核心 Trait
+
+```rust
+#[async_trait]
+pub trait MessageQueueAdmin: Send + Sync {
+    async fn list_tenants(&self) -> Result<Vec<TenantInfo>, String>;
+    async fn list_namespaces(&self, tenant: &str) -> Result<Vec<NamespaceInfo>, String>;
+    async fn list_topics(&self, ns: &NamespaceRef, opts: ListTopicsOpts) -> Result<Vec<TopicInfo>, String>;
+    // ... 45 more methods
+}
+```
+
+## 使用示例
+
+```rust
+// AppState 会在存在 SSH/Proxy transport layer 时，把 Admin URL 改写到本地转发端点。
+let config = state.mq_admin_config_for_connection(&connection.id, &connection).await?;
+
+let adapter = state.mq_registry.get_or_build_config(&connection.id, config).await?;
+let tenants = adapter.list_tenants().await?;
+```
+
+通常业务代码优先复用 `service.rs` 中的 `mq_*_core` 函数；只有需要直接组合底层能力时才访问 `MqAdminRegistry`。
+
+## Feature Flag
+
+```toml
+[features]
+default = ["mq-admin"]
+mq-admin = []
+```
+
+## 文档
+
+完整文档请参考：`docs/mq-index.md`
diff --git a/crates/dbx-core/src/mq/adapters/kafka.rs b/crates/dbx-core/src/mq/adapters/kafka.rs
new file mode 100644
index 0000000..9dabbe6
--- /dev/null
+++ b/crates/dbx-core/src/mq/adapters/kafka.rs
@@ -0,0 +1,915 @@
+//! Apache Kafka admin adapter. Communicates with a Java agent process
+//! (`KafkaAgent.java`) via JSON-RPC over stdin/stdout. The Java agent uses
+//! `kafka-clients` AdminClient for admin operations and KafkaProducer for
+//! message production.
+//!
+//! This adapter follows the same pattern as the ZooKeeper/Etcd agents:
+//! 1. Spawn a Java agent process via `AgentDriverClient`
+//! 2. Perform JSON-RPC handshake + connect
+//! 3. Delegate all `MessageQueueAdmin` trait methods to JSON-RPC calls
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use serde::de::DeserializeOwned;
+use tokio::sync::Mutex;
+
+use crate::db::agent_driver::{AgentDriverClient, AgentLaunchSpec};
+use crate::mq::auth::MqAuth;
+use crate::mq::config::MqAdminConfig;
+use crate::mq::port::MessageQueueAdmin;
+use crate::mq::types::*;
+
+/// Kafka capabilities — no tenants/namespaces, supports topics, consumer groups,
+/// ACLs, retention, and message production.
+const KAFKA_CAPABILITIES: MqCapabilities = MqCapabilities {
+    supports_tenants: false,
+    supports_namespaces: false,
+    supports_partitioned_topics: true,
+    supports_subscriptions: true,
+    supports_create_subscription: false,
+    supports_reset_cursor: true,
+    supports_skip_messages: false,
+    supports_clear_backlog: true,
+    supports_peek_messages: true,
+    supports_expire_messages: false,
+    supports_rate_limits: false,
+    supports_backlog_quota: false,
+    supports_retention: true,
+    supports_permissions: true,
+    supports_geo_replication: false,
+    supports_token_management: false,
+    supports_raw_admin_api: false,
+    supports_send_message: true,
+};
+
+pub struct KafkaAdmin {
+    client: Arc<Mutex<AgentDriverClient>>,
+    config: MqAdminConfig,
+}
+
+impl KafkaAdmin {
+    /// Spawn the Kafka Java agent, perform handshake, and connect.
+    pub async fn new(cfg: MqAdminConfig, launch: AgentLaunchSpec) -> Result<Self, String> {
+        let mut client = AgentDriverClient::spawn(launch).await?;
+
+        // Handshake
+        let _: serde_json::Value = client.call("handshake", serde_json::json!({})).await?;
+
+        // Build the connection params from MqAdminConfig
+        let conn_params = build_connection_params(&cfg);
+        let connect_params = serde_json::json!({ "connection": conn_params });
+        let _: serde_json::Value = client.call("connect", connect_params).await?;
+
+        log::info!("Kafka admin connected via agent (bootstrap servers: {})", bootstrap_servers(&cfg));
+
+        Ok(Self { client: Arc::new(Mutex::new(client)), config: cfg })
+    }
+
+    /// Send a JSON-RPC call to the Kafka agent and deserialize the result.
+    async fn call<T: DeserializeOwned + Send + 'static>(
+        &self,
+        method: &str,
+        params: serde_json::Value,
+    ) -> Result<T, String> {
+        let mut client = self.client.lock().await;
+        client.call(method, params).await
+    }
+
+    /// Send a JSON-RPC call that returns `{ok: true}` on success.
+    async fn call_ok(&self, method: &str, params: serde_json::Value) -> Result<(), String> {
+        let _: serde_json::Value = self.call(method, params).await?;
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl MessageQueueAdmin for KafkaAdmin {
+    fn capabilities(&self) -> MqCapabilities {
+        KAFKA_CAPABILITIES
+    }
+
+    fn system_kind(&self) -> MqSystemKind {
+        MqSystemKind::Kafka
+    }
+
+    async fn test_connection(&self) -> Result<MqClusterInfo, String> {
+        let conn_params = build_connection_params(&self.config);
+        let result: serde_json::Value =
+            self.call("test_connection", serde_json::json!({ "connection": conn_params })).await?;
+
+        let cluster_id = result.get("clusterId").and_then(|v| v.as_str()).map(String::from);
+        let brokers = result.get("brokers").cloned().unwrap_or(serde_json::json!([]));
+
+        // When the broker has no authorizer configured, disable permissions in the UI
+        // so the frontend hides the tab instead of showing raw errors.
+        let acl_enabled = result.get("aclEnabled").and_then(|v| v.as_bool()).unwrap_or(true);
+        let mut caps = KAFKA_CAPABILITIES;
+        if !acl_enabled {
+            caps.supports_permissions = false;
+        }
+
+        Ok(MqClusterInfo {
+            system_kind: MqSystemKind::Kafka,
+            server_version: None,
+            resolved_profile: "kafka-agent".to_string(),
+            version_detection: "agent".to_string(),
+            capabilities: caps,
+            extra: serde_json::json!({
+                "clusterId": cluster_id,
+                "brokers": brokers,
+            }),
+        })
+    }
+
+    // ---- Tenants (not supported by Kafka) ----
+
+    async fn list_tenants(&self) -> Result<Vec<TenantInfo>, String> {
+        Ok(Vec::new())
+    }
+
+    async fn get_tenant(&self, _name: &str) -> Result<TenantInfo, String> {
+        Err("Kafka does not support tenants".to_string())
+    }
+
+    async fn create_tenant(&self, _name: &str, _cfg: TenantConfig) -> Result<(), String> {
+        Err("Kafka does not support tenants".to_string())
+    }
+
+    async fn update_tenant(&self, _name: &str, _cfg: TenantConfig) -> Result<(), String> {
+        Err("Kafka does not support tenants".to_string())
+    }
+
+    async fn delete_tenant(&self, _name: &str, _force: bool) -> Result<(), String> {
+        Err("Kafka does not support tenants".to_string())
+    }
+
+    // ---- Namespaces (not supported by Kafka) ----
+
+    async fn list_namespaces(&self, _tenant: &str) -> Result<Vec<NamespaceInfo>, String> {
+        Ok(Vec::new())
+    }
+
+    async fn create_namespace(&self, _ns: &NamespaceRef, _cfg: NamespaceConfig) -> Result<(), String> {
+        Err("Kafka does not support namespaces".to_string())
+    }
+
+    async fn delete_namespace(&self, _ns: &NamespaceRef, _force: bool) -> Result<(), String> {
+        Err("Kafka does not support namespaces".to_string())
+    }
+
+    async fn get_namespace_policies(&self, _ns: &NamespaceRef) -> Result<serde_json::Value, String> {
+        Err("Kafka does not support namespaces".to_string())
+    }
+
+    // ---- Topics ----
+
+    async fn list_topics(&self, _ns: &NamespaceRef, _opts: ListTopicsOpts) -> Result<Vec<TopicInfo>, String> {
+        let result: serde_json::Value = self.call("mq_list_topics", serde_json::json!({})).await?;
+        let topics = result.get("topics").and_then(|v| v.as_array()).cloned().unwrap_or_default();
+
+        Ok(topics
+            .into_iter()
+            .map(|t| {
+                let name = t.get("name").and_then(|v| v.as_str()).unwrap_or_default().to_string();
+                let partitions = t.get("partitions").and_then(|v| v.as_u64()).map(|v| v as u32);
+                TopicInfo {
+                    name: name.clone(),
+                    short_name: name,
+                    partitioned: partitions.map(|p| p > 1).unwrap_or(false),
+                    partitions,
+                    persistent: true,
+                }
+            })
+            .collect())
+    }
+
+    async fn create_topic(&self, topic: &TopicRef, partitions: Option<u32>) -> Result<(), String> {
+        let params = serde_json::json!({
+            "name": topic.topic,
+            "partitions": partitions.unwrap_or(1),
+            "replicationFactor": 1,
+        });
+        self.call_ok("mq_create_topic", params).await
+    }
+
+    async fn delete_topic(&self, topic: &TopicRef, _force: bool) -> Result<(), String> {
+        self.call_ok("mq_delete_topic", serde_json::json!({ "name": topic.topic })).await
+    }
+
+    async fn update_partitions(&self, topic: &TopicRef, partitions: u32) -> Result<(), String> {
+        self.call_ok(
+            "mq_update_partitions",
+            serde_json::json!({
+                "name": topic.topic,
+                "totalPartitions": partitions,
+            }),
+        )
+        .await
+    }
+
+    async fn get_topic_stats(&self, topic: &TopicRef) -> Result<TopicStats, String> {
+        let result: serde_json::Value =
+            self.call("mq_get_topic_stats", serde_json::json!({ "name": topic.topic })).await?;
+
+        let total_messages = result.get("totalMessages").and_then(|v| v.as_i64()).unwrap_or(0);
+        let _partitions = result.get("partitions").and_then(|v| v.as_u64()).unwrap_or(0) as u32;
+
+        Ok(TopicStats {
+            msg_rate_in: 0.0,
+            msg_rate_out: 0.0,
+            msg_throughput_in: 0.0,
+            msg_throughput_out: 0.0,
+            storage_size: 0,
+            backlog_size: 0,
+            msg_in_counter: total_messages,
+            msg_out_counter: 0,
+            subscription_count: 0,
+            producer_count: 0,
+            raw: result,
+        })
+    }
+
+    async fn get_topic_internal_stats(&self, topic: &TopicRef) -> Result<serde_json::Value, String> {
+        self.call("mq_get_topic_config", serde_json::json!({ "name": topic.topic })).await
+    }
+
+    // ---- Subscriptions (mapped to consumer groups) ----
+
+    async fn list_subscriptions(&self, topic: &TopicRef) -> Result<Vec<SubscriptionInfo>, String> {
+        // List consumer groups and filter those subscribed to this topic
+        let result: serde_json::Value = self.call("mq_list_consumer_groups", serde_json::json!({})).await?;
+        let groups = result.get("groups").and_then(|v| v.as_array()).cloned().unwrap_or_default();
+
+        // For each group, check both active assignments and committed offsets.
+        let mut subs = Vec::new();
+        for group in groups {
+            let group_id = group.get("groupId").and_then(|v| v.as_str()).unwrap_or_default();
+            let desc = match self
+                .call::<serde_json::Value>("mq_describe_consumer_group", serde_json::json!({ "groupId": group_id }))
+                .await
+            {
+                Ok(desc) => desc,
+                Err(_) => continue, // Skip groups we can't describe
+            };
+            let lag = self
+                .call::<serde_json::Value>(
+                    "mq_get_consumer_lag",
+                    serde_json::json!({
+                        "groupId": group_id,
+                        "topic": topic.topic,
+                    }),
+                )
+                .await
+                .ok();
+            if let Some(sub) = kafka_subscription_for_topic(group_id, &topic.topic, &desc, lag.as_ref()) {
+                subs.push(sub);
+            }
+        }
+        Ok(subs)
+    }
+
+    async fn create_subscription(&self, _topic: &TopicRef, _sub: &str, _pos: ResetPosition) -> Result<(), String> {
+        Err("Kafka consumer groups are created automatically when consumers join".to_string())
+    }
+
+    async fn delete_subscription(&self, _topic: &TopicRef, sub: &str, _force: bool) -> Result<(), String> {
+        self.call_ok("mq_delete_consumer_group", serde_json::json!({ "groupId": sub })).await
+    }
+
+    async fn skip_messages(&self, _topic: &TopicRef, _sub: &str, _count: SkipCount) -> Result<(), String> {
+        Err("Kafka does not support skipping messages directly".to_string())
+    }
+
+    async fn reset_cursor(&self, topic: &TopicRef, sub: &str, pos: ResetPosition) -> Result<(), String> {
+        let params = reset_cursor_params(topic, sub, pos)?;
+        self.call_ok("mq_reset_consumer_group_offsets", params).await
+    }
+
+    async fn clear_backlog(&self, topic: &TopicRef, sub: &str) -> Result<(), String> {
+        // Clearing backlog = resetting offsets to latest
+        self.call_ok(
+            "mq_reset_consumer_group_offsets",
+            serde_json::json!({
+                "groupId": sub,
+                "topic": topic.topic,
+                "position": "latest",
+            }),
+        )
+        .await
+    }
+
+    async fn peek_messages(
+        &self,
+        topic: &TopicRef,
+        _sub: &str,
+        count: u32,
+        options: PeekMessagesOptions,
+    ) -> Result<Vec<PeekedMessage>, String> {
+        let conn_params = build_connection_params(&self.config);
+        let result: serde_json::Value = self
+            .call(
+                "mq_peek_messages",
+                serde_json::json!({
+                    "topic": topic.topic,
+                    "partition": options.partition.unwrap_or(0),
+                    "offset": options.offset.unwrap_or(0),
+                    "count": count,
+                    "connection": conn_params,
+                }),
+            )
+            .await?;
+
+        let messages = result.get("messages").and_then(|v| v.as_array()).cloned().unwrap_or_default();
+        Ok(messages
+            .into_iter()
+            .enumerate()
+            .map(|(idx, m)| PeekedMessage {
+                position: (idx + 1) as u32,
+                message_id: m.get("offset").and_then(|v| v.as_i64()).map(|v| v.to_string()),
+                key: m.get("key").and_then(|v| v.as_str()).map(String::from),
+                publish_time: m.get("timestamp").and_then(|v| v.as_i64()).map(|v| v.to_string()),
+                event_time: None,
+                properties: HashMap::new(),
+                headers: m
+                    .get("headers")
+                    .and_then(|v| v.as_object())
+                    .map(|obj| {
+                        obj.iter().map(|(k, v)| (k.clone(), v.as_str().unwrap_or_default().to_string())).collect()
+                    })
+                    .unwrap_or_default(),
+                payload_base64: m.get("payloadBase64").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                payload_text: m.get("payloadText").and_then(|v| v.as_str()).map(String::from),
+            })
+            .collect())
+    }
+
+    async fn expire_messages(&self, _topic: &TopicRef, _sub: &str, _expire_seconds: i64) -> Result<(), String> {
+        Err("Kafka does not support expiring messages on a subscription".to_string())
+    }
+
+    // ---- Producers / consumers ----
+
+    async fn list_producers(&self, topic: &TopicRef) -> Result<Vec<ProducerInfo>, String> {
+        let result: serde_json::Value =
+            match self.call("mq_list_producers", serde_json::json!({ "topic": topic.topic })).await {
+                Ok(result) => result,
+                Err(err) if is_describe_producers_unsupported(&err) => {
+                    log::info!("Kafka broker does not support DESCRIBE_PRODUCERS; active producers are unavailable");
+                    return Ok(Vec::new());
+                }
+                Err(err) => return Err(err),
+            };
+        let producers = result.get("producers").and_then(|v| v.as_array()).cloned().unwrap_or_default();
+        Ok(producers
+            .into_iter()
+            .map(|p| ProducerInfo {
+                producer_id: p.get("producerId").and_then(|v| v.as_i64()).unwrap_or(0),
+                producer_name: p.get("producerName").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                msg_rate_in: p.get("msgRateIn").and_then(|v| v.as_f64()).unwrap_or(0.0),
+                msg_throughput_in: p.get("msgThroughputIn").and_then(|v| v.as_f64()).unwrap_or(0.0),
+                address: p.get("address").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                client_version: p.get("clientVersion").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+            })
+            .collect())
+    }
+
+    async fn list_consumers(&self, _topic: &TopicRef, sub: &str) -> Result<Vec<ConsumerInfo>, String> {
+        let result: serde_json::Value =
+            self.call("mq_describe_consumer_group", serde_json::json!({ "groupId": sub })).await?;
+
+        let members = result.get("members").and_then(|v| v.as_array()).cloned().unwrap_or_default();
+        Ok(members
+            .into_iter()
+            .map(|m| ConsumerInfo {
+                consumer_name: m.get("memberId").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                msg_rate_out: 0.0,
+                msg_throughput_out: 0.0,
+                available_permits: 0,
+                address: m.get("host").and_then(|v| v.as_str()).unwrap_or_default().to_string(),
+                client_version: String::new(),
+            })
+            .collect())
+    }
+
+    async fn unload_topic(&self, _topic: &TopicRef) -> Result<(), String> {
+        Err("Kafka 不支持卸载主题".to_string())
+    }
+
+    // ---- Rate limits / quotas / retention ----
+
+    async fn set_publish_rate(&self, _scope: &PolicyScope, _rate: PublishRate) -> Result<(), String> {
+        Err("Kafka does not support publish rate limits via AdminClient".to_string())
+    }
+
+    async fn set_dispatch_rate(&self, _scope: &PolicyScope, _rate: DispatchRate) -> Result<(), String> {
+        Err("Kafka does not support dispatch rate limits via AdminClient".to_string())
+    }
+
+    async fn set_subscribe_rate(&self, _scope: &PolicyScope, _rate: SubscribeRate) -> Result<(), String> {
+        Err("Kafka does not support subscribe rate limits via AdminClient".to_string())
+    }
+
+    async fn set_backlog_quota(&self, _scope: &PolicyScope, _quota: BacklogQuota) -> Result<(), String> {
+        Err("Kafka does not support backlog quotas via AdminClient".to_string())
+    }
+
+    async fn set_retention(&self, scope: &PolicyScope, retention: RetentionPolicy) -> Result<(), String> {
+        let topic_name = match scope {
+            PolicyScope::Topic { topic, .. } => topic.clone(),
+            PolicyScope::Namespace { .. } => return Err("Kafka retention can only be set on topics".to_string()),
+        };
+
+        let retention_ms = if retention.retention_time_in_minutes < 0 {
+            "-1".to_string()
+        } else {
+            (retention.retention_time_in_minutes as i64 * 60 * 1000).to_string()
+        };
+
+        let mut configs = vec![serde_json::json!({ "key": "retention.ms", "value": retention_ms })];
+        if retention.retention_size_in_mb >= 0 {
+            let retention_bytes = (retention.retention_size_in_mb as i64 * 1024 * 1024).to_string();
+            configs.push(serde_json::json!({ "key": "retention.bytes", "value": retention_bytes }));
+        }
+
+        self.call_ok(
+            "mq_alter_topic_config",
+            serde_json::json!({
+                "name": topic_name,
+                "configs": configs,
+            }),
+        )
+        .await
+    }
+
+    async fn get_effective_policies(&self, scope: &PolicyScope) -> Result<serde_json::Value, String> {
+        let topic_name = match scope {
+            PolicyScope::Topic { topic, .. } => topic.clone(),
+            PolicyScope::Namespace { .. } => return Err("Kafka does not support namespace policies".to_string()),
+        };
+        self.call("mq_get_topic_config", serde_json::json!({ "name": topic_name })).await
+    }
+
+    // ---- Permissions (mapped to Kafka ACLs) ----
+
+    async fn grant_permission(&self, scope: &PolicyScope, role: &str, actions: Vec<AuthAction>) -> Result<(), String> {
+        let (resource_type, resource_name) = match scope {
+            PolicyScope::Topic { topic, .. } => ("TOPIC", topic.clone()),
+            PolicyScope::Namespace { .. } => ("TOPIC", "*".to_string()),
+        };
+
+        let acls: Vec<serde_json::Value> = actions
+            .into_iter()
+            .map(|action| {
+                let operation = match action {
+                    AuthAction::Produce => "WRITE",
+                    AuthAction::Consume => "READ",
+                    _ => "ALL",
+                };
+                serde_json::json!({
+                    "resourceType": resource_type,
+                    "resourceName": resource_name,
+                    "patternType": "LITERAL",
+                    "principal": format!("User:{}", role),
+                    "host": "*",
+                    "operation": operation,
+                    "permissionType": "ALLOW",
+                })
+            })
+            .collect();
+
+        self.call_ok("mq_create_acls", serde_json::json!({ "acls": acls })).await
+    }
+
+    async fn revoke_permission(&self, scope: &PolicyScope, role: &str) -> Result<(), String> {
+        let (resource_type, resource_name) = match scope {
+            PolicyScope::Topic { topic, .. } => ("TOPIC", topic.clone()),
+            PolicyScope::Namespace { .. } => ("TOPIC", "*".to_string()),
+        };
+
+        self.call_ok(
+            "mq_delete_acls",
+            serde_json::json!({
+                "filters": [{
+                    "resourceType": resource_type,
+                    "resourceName": resource_name,
+                    "principal": format!("User:{}", role),
+                }]
+            }),
+        )
+        .await
+    }
+
+    async fn list_permissions(&self, scope: &PolicyScope) -> Result<PermissionMap, String> {
+        let (resource_type, resource_name) = match scope {
+            PolicyScope::Topic { topic, .. } => ("TOPIC", topic.clone()),
+            PolicyScope::Namespace { .. } => ("TOPIC", "*".to_string()),
+        };
+
+        let result: serde_json::Value = self
+            .call(
+                "mq_list_acls",
+                serde_json::json!({
+                    "resourceType": resource_type,
+                    "resourceName": resource_name,
+                }),
+            )
+            .await?;
+
+        let acls = result.get("acls").and_then(|v| v.as_array()).cloned().unwrap_or_default();
+        let mut permissions: PermissionMap = HashMap::new();
+
+        for acl in acls {
+            let principal = acl.get("principal").and_then(|v| v.as_str()).unwrap_or_default();
+            let role = principal.strip_prefix("User:").unwrap_or(principal).to_string();
+            let operation = acl.get("operation").and_then(|v| v.as_str()).unwrap_or_default();
+            let action = match operation {
+                "WRITE" => AuthAction::Produce,
+                "READ" => AuthAction::Consume,
+                _ => continue,
+            };
+            permissions.entry(role).or_default().push(action);
+        }
+        Ok(permissions)
+    }
+
+    // ---- Monitoring ----
+
+    async fn get_backlog(&self, topic: &TopicRef, sub: Option<&str>) -> Result<BacklogStats, String> {
+        let group_id = sub.ok_or("Consumer group name (subscription) is required for Kafka backlog")?;
+        let result: serde_json::Value = self
+            .call(
+                "mq_get_consumer_lag",
+                serde_json::json!({
+                    "groupId": group_id,
+                    "topic": topic.topic,
+                }),
+            )
+            .await?;
+
+        let total_lag = result.get("totalLag").and_then(|v| v.as_i64()).unwrap_or(0);
+        Ok(BacklogStats { msg_backlog: total_lag, backlog_size: 0 })
+    }
+
+    async fn get_cluster_info(&self) -> Result<ClusterInfo, String> {
+        let result: serde_json::Value = self.call("mq_describe_cluster", serde_json::json!({})).await?;
+
+        let cluster_id = result.get("clusterId").and_then(|v| v.as_str()).map(String::from);
+        let broker_count = result.get("nodeCount").and_then(|v| v.as_u64()).unwrap_or(0) as u32;
+
+        let controller = result.get("controller").filter(|v| !v.is_null());
+        let controller_id = controller.and_then(|v| v.get("id")).and_then(|v| v.as_i64()).map(|v| v as i32);
+        let controller_host = controller.and_then(|v| v.get("host")).and_then(|v| v.as_str()).map(|host| {
+            let port = controller.and_then(|v| v.get("port")).and_then(|v| v.as_i64()).unwrap_or(0);
+            format!("{}:{}", host, port)
+        });
+
+        let brokers = result
+            .get("brokers")
+            .and_then(|v| v.as_array())
+            .map(|arr| {
+                arr.iter()
+                    .filter_map(|node| {
+                        Some(BrokerNode {
+                            id: node.get("id")?.as_i64()? as i32,
+                            host: node.get("host")?.as_str()?.to_string(),
+                            port: node.get("port")?.as_i64()? as i32,
+                            rack: node.get("rack").and_then(|v| v.as_str()).map(String::from),
+                        })
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+
+        Ok(ClusterInfo { cluster_id, broker_count, controller_id, controller_host, brokers, raw: result })
+    }
+
+    // ---- Raw request (not supported for Kafka) ----
+
+    async fn raw_request(&self, _req: MqRawRequest) -> Result<MqRawResponse, String> {
+        Err("Kafka does not have a REST admin API; raw requests are not supported".to_string())
+    }
+
+    // ---- Message production ----
+
+    async fn send_message(&self, req: SendMessageRequest) -> Result<SendMessageResponse, String> {
+        let params = serde_json::json!({
+            "topic": req.topic,
+            "key": req.key,
+            "payloadBase64": req.payload_base64,
+            "headers": req.headers,
+            "partition": req.partition,
+        });
+        let result: serde_json::Value = self.call("mq_send_message", params).await?;
+
+        Ok(SendMessageResponse {
+            topic: result.get("topic").and_then(|v| v.as_str()).unwrap_or(&req.topic).to_string(),
+            partition: result.get("partition").and_then(|v| v.as_i64()).unwrap_or(0) as i32,
+            offset: result.get("offset").and_then(|v| v.as_i64()).unwrap_or(0),
+            timestamp: result.get("timestamp").and_then(|v| v.as_i64()).map(|v| v.to_string()),
+        })
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/// Extract Kafka bootstrap servers from MqAdminConfig.extra.
+fn bootstrap_servers(cfg: &MqAdminConfig) -> String {
+    cfg.extra.get("bootstrapServers").and_then(|v| v.as_str()).unwrap_or("").to_string()
+}
+
+fn extra_str<'a>(extra: &'a serde_json::Value, key: &str) -> Option<&'a str> {
+    extra.get(key).and_then(|v| v.as_str()).filter(|v| !v.trim().is_empty())
+}
+
+fn is_describe_producers_unsupported(message: &str) -> bool {
+    let normalized = message.to_ascii_lowercase();
+    (normalized.contains("unsupportedversionexception") && normalized.contains("describe_producers"))
+        || normalized.contains("the node does not support describe_producers")
+}
+
+/// Build the connection params JSON from MqAdminConfig for the Java agent.
+fn build_connection_params(cfg: &MqAdminConfig) -> serde_json::Value {
+    let extra = &cfg.extra;
+    let basic_auth = match &cfg.auth {
+        MqAuth::Basic { username, password } => Some((username.as_str(), password.as_str())),
+        _ => None,
+    };
+    let sasl_username =
+        extra_str(extra, "saslUsername").or_else(|| basic_auth.map(|(username, _)| username)).unwrap_or("");
+    let sasl_password =
+        extra_str(extra, "saslPassword").or_else(|| basic_auth.map(|(_, password)| password)).unwrap_or("");
+    let sasl_mechanism = extra_str(extra, "saslMechanism").unwrap_or(if basic_auth.is_some() { "PLAIN" } else { "" });
+    let security_protocol = extra_str(extra, "securityProtocol").unwrap_or(if !sasl_mechanism.is_empty() {
+        "SASL_PLAINTEXT"
+    } else {
+        "PLAINTEXT"
+    });
+    let properties =
+        extra.get("properties").filter(|value| value.is_object()).cloned().unwrap_or_else(|| serde_json::json!({}));
+
+    serde_json::json!({
+        "bootstrap_servers": bootstrap_servers(cfg),
+        "security_protocol": security_protocol,
+        "sasl_mechanism": sasl_mechanism,
+        "sasl_username": sasl_username,
+        "sasl_password": sasl_password,
+        "tls_skip_verify": cfg.tls_skip_verify,
+        "tls": {
+            "skip_verify": cfg.tls_skip_verify,
+        },
+        "properties": properties,
+    })
+}
+
+fn reset_cursor_params(topic: &TopicRef, sub: &str, pos: ResetPosition) -> Result<serde_json::Value, String> {
+    match pos {
+        ResetPosition::Earliest => Ok(serde_json::json!({
+            "groupId": sub,
+            "topic": topic.topic,
+            "position": "earliest",
+        })),
+        ResetPosition::Latest => Ok(serde_json::json!({
+            "groupId": sub,
+            "topic": topic.topic,
+            "position": "latest",
+        })),
+        ResetPosition::Timestamp { timestamp_ms } => Ok(serde_json::json!({
+            "groupId": sub,
+            "topic": topic.topic,
+            "position": "timestamp",
+            "timestampMs": timestamp_ms,
+        })),
+        ResetPosition::MessageId { .. } => Err("Kafka does not support cursor reset by Pulsar message id".to_string()),
+    }
+}
+
+fn kafka_subscription_for_topic(
+    group_id: &str,
+    topic: &str,
+    desc: &serde_json::Value,
+    lag: Option<&serde_json::Value>,
+) -> Option<SubscriptionInfo> {
+    let has_active_assignment = desc
+        .get("members")
+        .and_then(|v| v.as_array())
+        .map(|members| {
+            members.iter().any(|member| {
+                member
+                    .get("assignments")
+                    .and_then(|v| v.as_array())
+                    .map(|assignments| {
+                        assignments.iter().any(|a| a.get("topic").and_then(|v| v.as_str()) == Some(topic))
+                    })
+                    .unwrap_or(false)
+            })
+        })
+        .unwrap_or(false);
+    let has_committed_offsets = lag
+        .and_then(|v| v.get("partitions"))
+        .and_then(|v| v.as_array())
+        .map(|partitions| !partitions.is_empty())
+        .unwrap_or(false);
+
+    if !has_active_assignment && !has_committed_offsets {
+        return None;
+    }
+
+    Some(SubscriptionInfo {
+        name: group_id.to_string(),
+        sub_type: "consumer-group".to_string(),
+        msg_backlog: lag.and_then(|v| v.get("totalLag")).and_then(|v| v.as_i64()).unwrap_or(0),
+        msg_rate_out: 0.0,
+        msg_throughput_out: 0.0,
+        consumers: Vec::new(),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::mq::auth::MqAuth;
+    use crate::mq::types::MqSystemKind;
+
+    fn kafka_config(extra: serde_json::Value, auth: MqAuth, tls_skip_verify: bool) -> MqAdminConfig {
+        MqAdminConfig {
+            system_kind: MqSystemKind::Kafka,
+            admin_url: String::new(),
+            auth,
+            tls_skip_verify,
+            pinned_version: None,
+            token_signing: None,
+            connect_override: None,
+            extra,
+        }
+    }
+
+    #[test]
+    fn connection_params_map_basic_auth_to_kafka_sasl_without_plaintext_password_extra() {
+        let cfg = kafka_config(
+            serde_json::json!({
+                "bootstrapServers": "localhost:9092"
+            }),
+            MqAuth::Basic { username: "alice".to_string(), password: "secret".to_string() },
+            false,
+        );
+
+        let params = build_connection_params(&cfg);
+
+        assert_eq!(params.get("bootstrap_servers").and_then(|v| v.as_str()), Some("localhost:9092"));
+        assert_eq!(params.get("security_protocol").and_then(|v| v.as_str()), Some("SASL_PLAINTEXT"));
+        assert_eq!(params.get("sasl_mechanism").and_then(|v| v.as_str()), Some("PLAIN"));
+        assert_eq!(params.get("sasl_username").and_then(|v| v.as_str()), Some("alice"));
+        assert_eq!(params.get("sasl_password").and_then(|v| v.as_str()), Some("secret"));
+    }
+
+    #[test]
+    fn connection_params_preserve_kafka_security_extra_and_nested_tls() {
+        let cfg = kafka_config(
+            serde_json::json!({
+                "bootstrapServers": "broker:9093",
+                "securityProtocol": "SASL_SSL",
+                "saslMechanism": "SCRAM-SHA-512",
+                "properties": {
+                    "client.id": "dbx"
+                }
+            }),
+            MqAuth::Basic { username: "bob".to_string(), password: "pw".to_string() },
+            true,
+        );
+
+        let params = build_connection_params(&cfg);
+
+        assert_eq!(params.get("security_protocol").and_then(|v| v.as_str()), Some("SASL_SSL"));
+        assert_eq!(params.get("sasl_mechanism").and_then(|v| v.as_str()), Some("SCRAM-SHA-512"));
+        assert_eq!(params.pointer("/tls/skip_verify").and_then(|v| v.as_bool()), Some(true));
+        assert_eq!(params.pointer("/properties/client.id").and_then(|v| v.as_str()), Some("dbx"));
+    }
+
+    #[test]
+    fn connection_params_preserve_kafka_gssapi_properties() {
+        let cfg = kafka_config(
+            serde_json::json!({
+                "bootstrapServers": "broker:9093",
+                "securityProtocol": "SASL_SSL",
+                "saslMechanism": "GSSAPI",
+                "properties": {
+                    "sasl.jaas.config": "com.sun.security.auth.module.Krb5LoginModule required useKeyTab=true keyTab=\"/tmp/user.keytab\" principal=\"user@EXAMPLE.COM\";",
+                    "sasl.kerberos.service.name": "kafka",
+                    "java.security.krb5.conf": "/tmp/krb5.conf"
+                }
+            }),
+            MqAuth::None,
+            false,
+        );
+
+        let params = build_connection_params(&cfg);
+
+        assert_eq!(params.get("security_protocol").and_then(|v| v.as_str()), Some("SASL_SSL"));
+        assert_eq!(params.get("sasl_mechanism").and_then(|v| v.as_str()), Some("GSSAPI"));
+        assert_eq!(params.pointer("/properties/sasl.kerberos.service.name").and_then(|v| v.as_str()), Some("kafka"));
+        assert_eq!(
+            params.pointer("/properties/java.security.krb5.conf").and_then(|v| v.as_str()),
+            Some("/tmp/krb5.conf")
+        );
+    }
+
+    #[test]
+    fn reset_cursor_params_preserve_timestamp_position() {
+        let topic = TopicRef {
+            tenant: "_kafka".to_string(),
+            namespace: "_kafka".to_string(),
+            topic: "events".to_string(),
+            persistent: true,
+            partitioned: None,
+        };
+
+        let params = reset_cursor_params(&topic, "group-a", ResetPosition::Timestamp { timestamp_ms: 1710000000000 })
+            .expect("timestamp reset should be supported");
+
+        assert_eq!(params.get("groupId").and_then(|v| v.as_str()), Some("group-a"));
+        assert_eq!(params.get("topic").and_then(|v| v.as_str()), Some("events"));
+        assert_eq!(params.get("position").and_then(|v| v.as_str()), Some("timestamp"));
+        assert_eq!(params.get("timestampMs").and_then(|v| v.as_i64()), Some(1710000000000));
+    }
+
+    #[test]
+    fn reset_cursor_params_reject_message_id_position() {
+        let topic = TopicRef {
+            tenant: "_kafka".to_string(),
+            namespace: "_kafka".to_string(),
+            topic: "events".to_string(),
+            persistent: true,
+            partitioned: None,
+        };
+
+        let err = reset_cursor_params(&topic, "group-a", ResetPosition::MessageId { ledger_id: 1, entry_id: 2 })
+            .expect_err("Kafka should not accept Pulsar message ids");
+
+        assert!(err.contains("message id"));
+    }
+
+    #[test]
+    fn kafka_subscription_for_topic_includes_offline_group_with_committed_offsets() {
+        let desc = serde_json::json!({
+            "groupId": "orders-service",
+            "members": []
+        });
+        let lag = serde_json::json!({
+            "totalLag": 7,
+            "partitions": [
+                { "partition": 0, "currentOffset": 3, "endOffset": 10, "lag": 7 }
+            ]
+        });
+
+        let sub = kafka_subscription_for_topic("orders-service", "orders", &desc, Some(&lag))
+            .expect("committed offsets should make an inactive group visible");
+
+        assert_eq!(sub.name, "orders-service");
+        assert_eq!(sub.sub_type, "consumer-group");
+        assert_eq!(sub.msg_backlog, 7);
+    }
+
+    #[test]
+    fn kafka_subscription_for_topic_includes_active_assignment_without_committed_offsets() {
+        let desc = serde_json::json!({
+            "groupId": "live-service",
+            "members": [{
+                "assignments": [
+                    { "topic": "events", "partition": 0 }
+                ]
+            }]
+        });
+        let lag = serde_json::json!({
+            "totalLag": 0,
+            "partitions": []
+        });
+
+        let sub = kafka_subscription_for_topic("live-service", "events", &desc, Some(&lag))
+            .expect("active assignments should make the group visible");
+
+        assert_eq!(sub.name, "live-service");
+        assert_eq!(sub.msg_backlog, 0);
+    }
+
+    #[test]
+    fn kafka_subscription_for_topic_ignores_unrelated_group() {
+        let desc = serde_json::json!({
+            "groupId": "billing-service",
+            "members": [{
+                "assignments": [
+                    { "topic": "billing", "partition": 0 }
+                ]
+            }]
+        });
+        let lag = serde_json::json!({
+            "totalLag": 0,
+            "partitions": []
+        });
+
+        assert!(kafka_subscription_for_topic("billing-service", "orders", &desc, Some(&lag)).is_none());
+    }
+}
diff --git a/crates/dbx-core/src/mq/adapters/mod.rs b/crates/dbx-core/src/mq/adapters/mod.rs
new file mode 100644
index 0000000..4d7203c
--- /dev/null
+++ b/crates/dbx-core/src/mq/adapters/mod.rs
@@ -0,0 +1,5 @@
+//! Concrete message queue admin adapters.
+
+pub mod kafka;
+pub mod pulsar;
+pub mod pulsar_version;
diff --git a/crates/dbx-core/src/mq/adapters/pulsar.rs b/crates/dbx-core/src/mq/adapters/pulsar.rs
new file mode 100644
index 0000000..5cc0fda
--- /dev/null
+++ b/crates/dbx-core/src/mq/adapters/pulsar.rs
@@ -0,0 +1,1632 @@
+//! Apache Pulsar admin adapter. Talks to the Pulsar Admin REST API directly via
+//! `reqwest` (no heavyweight Pulsar client dependency). All version-specific
+//! endpoint construction and response parsing is delegated to
+//! [`PulsarApiProfile`], so the adapter body stays version-agnostic.
+
+use async_trait::async_trait;
+use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
+use futures::{stream, StreamExt};
+use std::collections::HashMap;
+use std::net::{IpAddr, SocketAddr};
+
+use super::pulsar_version::{DetectedVersion, PulsarApiProfile, PulsarVersion, VersionDetection};
+use crate::mq::auth::{MqAuth, TokenCache};
+use crate::mq::config::{MqAdminConfig, MqConnectOverride};
+use crate::mq::port::MessageQueueAdmin;
+use crate::mq::types::*;
+use crate::mq::util::truncate;
+
+/// How long to wait for a single admin REST call.
+const REQUEST_TIMEOUT_SECS: u64 = 30;
+/// How long to wait for the initial version-probe during construction.
+const PROBE_TIMEOUT_SECS: u64 = 8;
+const DETAIL_REQUEST_CONCURRENCY: usize = 8;
+const PARTITION_METADATA_CONCURRENCY: usize = 8;
+const PEEK_REQUEST_CONCURRENCY: usize = 4;
+/// Maximum response body size for raw requests (10 MB).
+const MAX_RAW_RESPONSE_BYTES: usize = 10 * 1024 * 1024;
+
+pub struct PulsarAdmin {
+    base: String,
+    http: reqwest::Client,
+    auth: MqAuth,
+    token_cache: TokenCache,
+    profile: PulsarApiProfile,
+}
+
+impl PulsarAdmin {
+    /// Build an adapter, probing the broker version (unless pinned) to resolve
+    /// the API profile. Probe failure degrades gracefully to the 3.1.x baseline.
+    pub async fn new(cfg: MqAdminConfig) -> Result<Self, String> {
+        let base = normalize_base(&cfg.admin_url);
+        let http = build_http_client(cfg.tls_skip_verify, cfg.connect_override.as_ref(), &cfg.admin_url)?;
+        let auth = cfg.auth.clone();
+        let token_cache = TokenCache::default();
+
+        let detected = detect_version(&http, &base, &auth, &token_cache, cfg.pinned_version.as_deref()).await;
+        let profile = PulsarApiProfile::resolve(detected);
+
+        log::info!(
+            "Pulsar admin connected to {} (version profile {}, detection {})",
+            redact_base(&base),
+            profile.label(),
+            profile.detection().as_str()
+        );
+
+        Ok(Self { base, http, auth, token_cache, profile })
+    }
+
+    fn url(&self, path: &str) -> String {
+        format!("{}{}", self.base, path)
+    }
+
+    /// Issue a request, applying auth, and return the raw response.
+    async fn send(
+        &self,
+        method: reqwest::Method,
+        path: &str,
+        body: Option<&serde_json::Value>,
+        query: Option<&[(String, String)]>,
+    ) -> Result<reqwest::Response, String> {
+        let mut req = self.http.request(method.clone(), self.url(path));
+        if let Some(q) = query {
+            req = req.query(q);
+        }
+        if let Some(body) = body {
+            req = req.json(body);
+        }
+        req = self.auth.apply(req, &self.http, &self.token_cache).await?;
+        req.send().await.map_err(|e| format!("Pulsar admin request to {path} failed: {e}"))
+    }
+
+    /// GET a path and deserialize the JSON body into `T`.
+    async fn get_json<T: serde::de::DeserializeOwned>(&self, path: &str) -> Result<T, String> {
+        let resp = self.send(reqwest::Method::GET, path, None, None).await?;
+        let resp = error_for_status(resp, path).await?;
+        resp.json::<T>().await.map_err(|e| format!("Failed to parse response from {path}: {e}"))
+    }
+
+    /// GET a path and return the parsed JSON value.
+    async fn get_value(&self, path: &str) -> Result<serde_json::Value, String> {
+        self.get_json::<serde_json::Value>(path).await
+    }
+
+    /// GET an optional policy endpoint. Pulsar returns 404/405/204 or an empty
+    /// body for some unset or unsupported scoped policies; those should not make
+    /// the whole policy panel fail.
+    async fn get_optional_value(&self, path: &str) -> Result<Option<serde_json::Value>, String> {
+        let resp = self.send(reqwest::Method::GET, path, None, None).await?;
+        let status = resp.status();
+        if matches!(
+            status,
+            reqwest::StatusCode::NOT_FOUND | reqwest::StatusCode::METHOD_NOT_ALLOWED | reqwest::StatusCode::NO_CONTENT
+        ) {
+            return Ok(None);
+        }
+        let resp = error_for_status(resp, path).await?;
+        let body = resp.text().await.map_err(|e| format!("Failed to read response from {path}: {e}"))?;
+        let body = body.trim();
+        if body.is_empty() {
+            return Ok(None);
+        }
+        serde_json::from_str(body).map(Some).map_err(|e| format!("Failed to parse response from {path}: {e}"))
+    }
+
+    /// Send a mutating request that returns no meaningful body.
+    async fn send_empty(
+        &self,
+        method: reqwest::Method,
+        path: &str,
+        body: Option<&serde_json::Value>,
+        query: Option<&[(String, String)]>,
+    ) -> Result<(), String> {
+        let resp = self.send(method, path, body, query).await?;
+        error_for_status(resp, path).await?;
+        Ok(())
+    }
+
+    async fn namespace_admin_roles(&self, tenant: &str, namespace: &str) -> Result<Vec<String>, String> {
+        let path = self.profile.namespace_permissions_path(tenant, namespace);
+        let raw: serde_json::Value = self.get_value(&path).await?;
+        let mut roles = raw.as_object().map(|obj| obj.keys().cloned().collect::<Vec<_>>()).unwrap_or_default();
+        roles.sort();
+        Ok(roles)
+    }
+}
+
+#[async_trait]
+impl MessageQueueAdmin for PulsarAdmin {
+    fn capabilities(&self) -> MqCapabilities {
+        self.profile.capabilities()
+    }
+
+    fn system_kind(&self) -> MqSystemKind {
+        MqSystemKind::Pulsar
+    }
+
+    async fn test_connection(&self) -> Result<MqClusterInfo, String> {
+        // Verify reachability and authorization by listing clusters.
+        let clusters = self.get_value(&self.profile.clusters_path()).await?;
+        Ok(MqClusterInfo {
+            system_kind: MqSystemKind::Pulsar,
+            server_version: self.profile.raw_version().map(str::to_string),
+            resolved_profile: self.profile.label().to_string(),
+            version_detection: self.profile.detection().as_str().to_string(),
+            capabilities: self.profile.capabilities(),
+            extra: serde_json::json!({ "clusters": clusters }),
+        })
+    }
+
+    // ---- Tenants ----
+
+    async fn list_tenants(&self) -> Result<Vec<TenantInfo>, String> {
+        let names: Vec<String> = self.get_json(&self.profile.tenants_path()).await?;
+        stream::iter(names.into_iter())
+            .map(|name| async move {
+                match self.get_tenant(&name).await {
+                    Ok(tenant) => Ok(tenant),
+                    Err(err) if is_unsupported_endpoint_error(&err) => {
+                        log::debug!("Pulsar tenant detail unavailable for '{}': {}", name, err);
+                        Ok(TenantInfo { name, ..Default::default() })
+                    }
+                    Err(err) => Err(err),
+                }
+            })
+            .buffered(DETAIL_REQUEST_CONCURRENCY)
+            .collect::<Vec<_>>()
+            .await
+            .into_iter()
+            .collect()
+    }
+
+    async fn get_tenant(&self, name: &str) -> Result<TenantInfo, String> {
+        let raw = self.get_value(&self.profile.tenant_path(name)).await?;
+        Ok(TenantInfo {
+            name: name.to_string(),
+            admin_roles: string_array(&raw, "adminRoles"),
+            allowed_clusters: string_array(&raw, "allowedClusters"),
+        })
+    }
+
+    async fn create_tenant(&self, name: &str, cfg: TenantConfig) -> Result<(), String> {
+        let body = serde_json::json!({
+            "adminRoles": cfg.admin_roles,
+            "allowedClusters": cfg.allowed_clusters,
+        });
+        self.send_empty(reqwest::Method::PUT, &self.profile.tenant_path(name), Some(&body), None).await
+    }
+
+    async fn update_tenant(&self, name: &str, cfg: TenantConfig) -> Result<(), String> {
+        let body = serde_json::json!({
+            "adminRoles": cfg.admin_roles,
+            "allowedClusters": cfg.allowed_clusters,
+        });
+        self.send_empty(reqwest::Method::POST, &self.profile.tenant_path(name), Some(&body), None).await
+    }
+
+    async fn delete_tenant(&self, name: &str, force: bool) -> Result<(), String> {
+        let query = force_query(force);
+        self.send_empty(reqwest::Method::DELETE, &self.profile.tenant_path(name), None, query.as_deref()).await
+    }
+
+    // ---- Namespaces ----
+
+    async fn list_namespaces(&self, tenant: &str) -> Result<Vec<NamespaceInfo>, String> {
+        // Returns fully-qualified `tenant/namespace` strings.
+        let names: Vec<String> = self.get_json(&self.profile.namespaces_path(tenant)).await?;
+        stream::iter(names.into_iter())
+            .map(|full| async move {
+                let namespace = full.rsplit('/').next().unwrap_or(&full).to_string();
+                let admin_roles = match self.namespace_admin_roles(tenant, &namespace).await {
+                    Ok(roles) => roles,
+                    Err(err) if is_unsupported_endpoint_error(&err) => {
+                        log::debug!("Pulsar namespace roles unavailable for '{}': {}", full, err);
+                        Vec::new()
+                    }
+                    Err(err) => return Err(err),
+                };
+                Ok(NamespaceInfo { tenant: tenant.to_string(), namespace, admin_roles })
+            })
+            .buffered(DETAIL_REQUEST_CONCURRENCY)
+            .collect::<Vec<_>>()
+            .await
+            .into_iter()
+            .collect()
+    }
+
+    async fn create_namespace(&self, ns: &NamespaceRef, cfg: NamespaceConfig) -> Result<(), String> {
+        let path = self.profile.namespace_path(&ns.tenant, &ns.namespace);
+        // An empty body creates a namespace with defaults; provide a policies
+        // object when clusters/bundles are specified.
+        let body = if cfg.clusters.is_empty() && cfg.bundles.is_none() {
+            None
+        } else {
+            let mut obj = serde_json::Map::new();
+            if !cfg.clusters.is_empty() {
+                obj.insert("replication_clusters".to_string(), serde_json::json!(cfg.clusters));
+            }
+            if let Some(bundles) = cfg.bundles {
+                obj.insert("bundles".to_string(), serde_json::json!({ "numBundles": bundles }));
+            }
+            Some(serde_json::Value::Object(obj))
+        };
+        self.send_empty(reqwest::Method::PUT, &path, body.as_ref(), None).await
+    }
+
+    async fn delete_namespace(&self, ns: &NamespaceRef, force: bool) -> Result<(), String> {
+        let path = self.profile.namespace_path(&ns.tenant, &ns.namespace);
+        let query = force_query(force);
+        self.send_empty(reqwest::Method::DELETE, &path, None, query.as_deref()).await
+    }
+
+    async fn get_namespace_policies(&self, ns: &NamespaceRef) -> Result<serde_json::Value, String> {
+        self.get_value(&self.profile.namespace_policies_path(&ns.tenant, &ns.namespace)).await
+    }
+
+    // ---- Topics ----
+
+    async fn list_topics(&self, ns: &NamespaceRef, opts: ListTopicsOpts) -> Result<Vec<TopicInfo>, String> {
+        let mut topics: Vec<TopicInfo> = Vec::new();
+        let mut domains = vec![true];
+        if opts.include_non_persistent {
+            domains.push(false);
+        }
+
+        for persistent in domains {
+            // Partitioned topics first, so we can mark them and avoid double-listing.
+            let partitioned_path = self.profile.partitioned_topics_path(&ns.tenant, &ns.namespace, persistent);
+            let partitioned: Vec<String> = match self.get_json(&partitioned_path).await {
+                Ok(partitioned) => partitioned,
+                Err(err) if is_unsupported_endpoint_error(&err) => Vec::new(),
+                Err(err) => return Err(err),
+            };
+            let partitioned_set: std::collections::HashSet<String> = partitioned.iter().cloned().collect();
+            let domain = if persistent { "persistent" } else { "non-persistent" };
+            let partitioned_topics = stream::iter(partitioned.into_iter())
+                .map(|full| async move {
+                    let partitions = self.partition_count_for_topic(domain, &full).await?;
+                    Ok::<_, String>(TopicInfo {
+                        short_name: short_topic_name(&full),
+                        name: full,
+                        partitioned: true,
+                        partitions,
+                        persistent,
+                    })
+                })
+                .buffered(PARTITION_METADATA_CONCURRENCY)
+                .collect::<Vec<_>>()
+                .await
+                .into_iter()
+                .collect::<Result<Vec<_>, _>>()?;
+            topics.extend(partitioned_topics);
+
+            let plain: Vec<String> =
+                self.get_json(&self.profile.topics_path(&ns.tenant, &ns.namespace, persistent)).await?;
+            for full in plain {
+                // Skip the per-partition entries of partitioned topics
+                // (`...-partition-0`) and the partitioned base names already added.
+                if partitioned_set.contains(&full) || is_partition_member(&full, &partitioned_set) {
+                    continue;
+                }
+                topics.push(TopicInfo {
+                    short_name: short_topic_name(&full),
+                    name: full,
+                    partitioned: false,
+                    partitions: None,
+                    persistent,
+                });
+            }
+        }
+
+        Ok(topics)
+    }
+
+    async fn create_topic(&self, topic: &TopicRef, partitions: Option<u32>) -> Result<(), String> {
+        match partitions {
+            Some(count) if count >= 1 => {
+                let path = self.profile.topic_partitions_path(topic.domain(), &topic.path());
+                let body = serde_json::json!(count);
+                self.send_empty(reqwest::Method::PUT, &path, Some(&body), None).await
+            }
+            _ => {
+                let path = self.profile.topic_base_path(topic.domain(), &topic.path());
+                self.send_empty(reqwest::Method::PUT, &path, None, None).await
+            }
+        }
+    }
+
+    async fn delete_topic(&self, topic: &TopicRef, force: bool) -> Result<(), String> {
+        // Try the partitioned-topic delete first; if the topic is not
+        // partitioned the broker returns 404, so fall back to a plain delete.
+        let partitions_path = self.profile.topic_partitions_path(topic.domain(), &topic.path());
+        let query = force_query(force);
+        let resp = self.send(reqwest::Method::DELETE, &partitions_path, None, query.as_deref()).await?;
+        if resp.status().is_success() {
+            return Ok(());
+        }
+        if resp.status().as_u16() != 404 {
+            return Err(status_error(resp, &partitions_path).await);
+        }
+        let base_path = self.profile.topic_base_path(topic.domain(), &topic.path());
+        self.send_empty(reqwest::Method::DELETE, &base_path, None, query.as_deref()).await
+    }
+
+    async fn update_partitions(&self, topic: &TopicRef, partitions: u32) -> Result<(), String> {
+        let path = self.profile.topic_partitions_path(topic.domain(), &topic.path());
+        let body = serde_json::json!(partitions);
+        self.send_empty(reqwest::Method::POST, &path, Some(&body), None).await
+    }
+
+    async fn get_topic_stats(&self, topic: &TopicRef) -> Result<TopicStats, String> {
+        let raw = self.topic_stats_value(topic).await?;
+        Ok(self.profile.parse_topic_stats(&raw))
+    }
+
+    async fn get_topic_internal_stats(&self, topic: &TopicRef) -> Result<serde_json::Value, String> {
+        let path = self.profile.topic_internal_stats_path(topic.domain(), &topic.path());
+        self.get_value(&path).await
+    }
+
+    // ---- Subscriptions ----
+
+    async fn list_subscriptions(&self, topic: &TopicRef) -> Result<Vec<SubscriptionInfo>, String> {
+        // The stats payload carries richer per-subscription data than the bare
+        // subscriptions list endpoint, so prefer it and parse from there.
+        match self.topic_stats_value(topic).await {
+            Ok(raw) => {
+                let parsed = self.profile.parse_subscriptions(&raw);
+                if !parsed.is_empty() {
+                    return Ok(parsed);
+                }
+                // Fall through to the names-only endpoint when stats has no subs
+                // (e.g. for partitioned topics, stats may be partition-scoped).
+            }
+            Err(err) => {
+                log::debug!("topic stats unavailable for subscription listing, falling back to names: {err}");
+            }
+        }
+
+        let names: Vec<String> = self.get_json(&self.profile.subscriptions_path(topic.domain(), &topic.path())).await?;
+        Ok(names.into_iter().map(|name| SubscriptionInfo { name, ..Default::default() }).collect())
+    }
+
+    async fn create_subscription(&self, topic: &TopicRef, sub: &str, pos: ResetPosition) -> Result<(), String> {
+        // PUT .../subscription/{sub} with the desired message id in the body.
+        let path = self.profile.subscription_path(topic.domain(), &topic.path(), sub);
+        let body = reset_position_message_id(&pos);
+        self.send_empty(reqwest::Method::PUT, &path, Some(&body), None).await
+    }
+
+    async fn delete_subscription(&self, topic: &TopicRef, sub: &str, force: bool) -> Result<(), String> {
+        let path = self.profile.subscription_path(topic.domain(), &topic.path(), sub);
+        let query = force_query(force);
+        self.send_empty(reqwest::Method::DELETE, &path, None, query.as_deref()).await
+    }
+
+    async fn skip_messages(&self, topic: &TopicRef, sub: &str, count: SkipCount) -> Result<(), String> {
+        let path = match count {
+            SkipCount::All => self.profile.subscription_skip_all_path(topic.domain(), &topic.path(), sub),
+            SkipCount::Count { count } => {
+                self.profile.subscription_skip_path(topic.domain(), &topic.path(), sub, count)
+            }
+        };
+        self.send_empty(reqwest::Method::POST, &path, None, None).await
+    }
+
+    async fn reset_cursor(&self, topic: &TopicRef, sub: &str, pos: ResetPosition) -> Result<(), String> {
+        match pos {
+            ResetPosition::Timestamp { timestamp_ms } => {
+                // POST .../resetcursor/{timestamp}
+                let path = format!(
+                    "{}/{}",
+                    self.profile.subscription_reset_cursor_path(topic.domain(), &topic.path(), sub),
+                    timestamp_ms
+                );
+                self.send_empty(reqwest::Method::POST, &path, None, None).await
+            }
+            ResetPosition::MessageId { .. } | ResetPosition::Earliest | ResetPosition::Latest => {
+                // POST .../resetcursor with a message id body.
+                let path = self.profile.subscription_reset_cursor_path(topic.domain(), &topic.path(), sub);
+                let body = reset_position_message_id(&pos);
+                self.send_empty(reqwest::Method::POST, &path, Some(&body), None).await
+            }
+        }
+    }
+
+    async fn clear_backlog(&self, topic: &TopicRef, sub: &str) -> Result<(), String> {
+        // Clearing backlog == skipping all messages on the subscription.
+        let path = self.profile.subscription_skip_all_path(topic.domain(), &topic.path(), sub);
+        self.send_empty(reqwest::Method::POST, &path, None, None).await
+    }
+
+    async fn peek_messages(
+        &self,
+        topic: &TopicRef,
+        sub: &str,
+        count: u32,
+        _options: PeekMessagesOptions,
+    ) -> Result<Vec<PeekedMessage>, String> {
+        if count == 0 {
+            return Ok(Vec::new());
+        }
+
+        let messages: Vec<PeekedMessage> = stream::iter(1..=count)
+            .map(|position| async move {
+                let path = self.profile.subscription_peek_path(topic.domain(), &topic.path(), sub, position);
+                let resp = self.send(reqwest::Method::GET, &path, None, None).await?;
+                if resp.status().as_u16() == 404 && position > 1 {
+                    return Ok::<Option<PeekedMessage>, String>(None);
+                }
+                let resp = error_for_status(resp, &path).await?;
+                let headers = response_headers(resp.headers());
+                let payload = resp.bytes().await.map_err(|e| format!("Failed to read peeked message body: {e}"))?;
+                Ok(Some(peeked_message_from_response(position, headers, payload.as_ref())))
+            })
+            .buffered(PEEK_REQUEST_CONCURRENCY)
+            .collect::<Vec<_>>()
+            .await
+            .into_iter()
+            .collect::<Result<Vec<_>, String>>()?
+            .into_iter()
+            .flatten()
+            .collect();
+
+        Ok(messages)
+    }
+
+    async fn expire_messages(&self, topic: &TopicRef, sub: &str, expire_seconds: i64) -> Result<(), String> {
+        let path = self.profile.subscription_expire_path(topic.domain(), &topic.path(), sub, expire_seconds);
+        self.send_empty(reqwest::Method::POST, &path, None, None).await
+    }
+
+    // ---- Producers / consumers ----
+
+    async fn list_producers(&self, topic: &TopicRef) -> Result<Vec<ProducerInfo>, String> {
+        let raw = self.topic_stats_value(topic).await?;
+        Ok(producers_from_stats_payload(&raw))
+    }
+
+    async fn list_consumers(&self, topic: &TopicRef, sub: &str) -> Result<Vec<ConsumerInfo>, String> {
+        let subs = self.list_subscriptions(topic).await?;
+        Ok(subs.into_iter().find(|s| s.name == sub).map(|s| s.consumers).unwrap_or_default())
+    }
+
+    async fn unload_topic(&self, topic: &TopicRef) -> Result<(), String> {
+        let path = format!("{}/unload", self.profile.topic_base_path(topic.domain(), &topic.path()));
+        self.send_empty(reqwest::Method::PUT, &path, None, None).await
+    }
+
+    // ---- Rate limits / quotas / retention ----
+
+    async fn set_publish_rate(&self, scope: &PolicyScope, rate: PublishRate) -> Result<(), String> {
+        let path = match scope {
+            PolicyScope::Namespace { tenant, namespace } => self.profile.namespace_publish_rate_path(tenant, namespace),
+            PolicyScope::Topic { tenant, namespace, topic, persistent } => {
+                let topic_ref = TopicRef {
+                    tenant: tenant.clone(),
+                    namespace: namespace.clone(),
+                    topic: topic.clone(),
+                    persistent: *persistent,
+                    partitioned: None,
+                };
+                self.profile.topic_publish_rate_path(topic_ref.domain(), &topic_ref.path())
+            }
+        };
+        let body = serde_json::to_value(rate).map_err(|e| e.to_string())?;
+        self.send_empty(reqwest::Method::POST, &path, Some(&body), None).await
+    }
+
+    async fn set_dispatch_rate(&self, scope: &PolicyScope, rate: DispatchRate) -> Result<(), String> {
+        let path = match scope {
+            PolicyScope::Namespace { tenant, namespace } => {
+                self.profile.namespace_dispatch_rate_path(tenant, namespace)
+            }
+            PolicyScope::Topic { tenant, namespace, topic, persistent } => {
+                let topic_ref = TopicRef {
+                    tenant: tenant.clone(),
+                    namespace: namespace.clone(),
+                    topic: topic.clone(),
+                    persistent: *persistent,
+                    partitioned: None,
+                };
+                self.profile.topic_dispatch_rate_path(topic_ref.domain(), &topic_ref.path())
+            }
+        };
+        let body = serde_json::to_value(rate).map_err(|e| e.to_string())?;
+        self.send_empty(reqwest::Method::POST, &path, Some(&body), None).await
+    }
+
+    async fn set_subscribe_rate(&self, scope: &PolicyScope, rate: SubscribeRate) -> Result<(), String> {
+        let path = match scope {
+            PolicyScope::Namespace { tenant, namespace } => {
+                self.profile.namespace_subscribe_rate_path(tenant, namespace)
+            }
+            PolicyScope::Topic { .. } => {
+                return Err("subscribe rate is only configurable at the namespace level".to_string());
+            }
+        };
+        let body = serde_json::to_value(rate).map_err(|e| e.to_string())?;
+        self.send_empty(reqwest::Method::POST, &path, Some(&body), None).await
+    }
+
+    async fn set_backlog_quota(&self, scope: &PolicyScope, quota: BacklogQuota) -> Result<(), String> {
+        let path = match scope {
+            PolicyScope::Namespace { tenant, namespace } => {
+                self.profile.namespace_backlog_quota_path(tenant, namespace)
+            }
+            PolicyScope::Topic { tenant, namespace, topic, persistent } => {
+                let topic_ref = TopicRef {
+                    tenant: tenant.clone(),
+                    namespace: namespace.clone(),
+                    topic: topic.clone(),
+                    persistent: *persistent,
+                    partitioned: None,
+                };
+                self.profile.topic_backlog_quota_path(topic_ref.domain(), &topic_ref.path())
+            }
+        };
+        // `backlogQuotaType` goes in the query string; the limit object in the body.
+        let query = vec![("backlogQuotaType".to_string(), quota.quota_type.clone())];
+        let body = serde_json::json!({
+            "limit": quota.limit_size,
+            "limitSize": quota.limit_size,
+            "limitTime": quota.limit_time,
+            "policy": quota.policy,
+        });
+        self.send_empty(reqwest::Method::POST, &path, Some(&body), Some(&query)).await
+    }
+
+    async fn set_retention(&self, scope: &PolicyScope, retention: RetentionPolicy) -> Result<(), String> {
+        let path = match scope {
+            PolicyScope::Namespace { tenant, namespace } => self.profile.namespace_retention_path(tenant, namespace),
+            PolicyScope::Topic { tenant, namespace, topic, persistent } => {
+                let topic_ref = TopicRef {
+                    tenant: tenant.clone(),
+                    namespace: namespace.clone(),
+                    topic: topic.clone(),
+                    persistent: *persistent,
+                    partitioned: None,
+                };
+                self.profile.topic_retention_path(topic_ref.domain(), &topic_ref.path())
+            }
+        };
+        let body = serde_json::json!({
+            "retentionTimeInMinutes": retention.retention_time_in_minutes,
+            "retentionSizeInMB": retention.retention_size_in_mb,
+        });
+        self.send_empty(reqwest::Method::POST, &path, Some(&body), None).await
+    }
+
+    async fn get_effective_policies(&self, scope: &PolicyScope) -> Result<serde_json::Value, String> {
+        match scope {
+            PolicyScope::Namespace { tenant, namespace } => {
+                self.get_value(&self.profile.namespace_policies_path(tenant, namespace)).await
+            }
+            PolicyScope::Topic { tenant, namespace, topic, persistent } => {
+                let topic_ref = TopicRef {
+                    tenant: tenant.clone(),
+                    namespace: namespace.clone(),
+                    topic: topic.clone(),
+                    persistent: *persistent,
+                    partitioned: None,
+                };
+                let namespace_policies = self
+                    .get_value(&self.profile.namespace_policies_path(&topic_ref.tenant, &topic_ref.namespace))
+                    .await?;
+                let topic_path = topic_ref.path();
+                let publish_rate = self
+                    .get_optional_value(&self.profile.topic_publish_rate_path(topic_ref.domain(), &topic_path))
+                    .await?;
+                let dispatch_rate = self
+                    .get_optional_value(&self.profile.topic_dispatch_rate_path(topic_ref.domain(), &topic_path))
+                    .await?;
+                let backlog_quota = self
+                    .get_optional_value(&self.profile.topic_backlog_quota_path(topic_ref.domain(), &topic_path))
+                    .await?;
+                let retention = self
+                    .get_optional_value(&self.profile.topic_retention_path(topic_ref.domain(), &topic_path))
+                    .await?;
+
+                Ok(serde_json::json!({
+                    "level": "topic",
+                    "namespacePolicies": namespace_policies,
+                    "topicPolicies": {
+                        "publishRate": publish_rate,
+                        "dispatchRate": dispatch_rate,
+                        "backlogQuota": backlog_quota,
+                        "retention": retention,
+                    }
+                }))
+            }
+        }
+    }
+
+    // ---- Permissions ----
+
+    async fn grant_permission(&self, scope: &PolicyScope, role: &str, actions: Vec<AuthAction>) -> Result<(), String> {
+        let path = match scope {
+            PolicyScope::Namespace { tenant, namespace } => {
+                self.profile.namespace_permission_role_path(tenant, namespace, role)
+            }
+            PolicyScope::Topic { tenant, namespace, topic, persistent } => {
+                let topic_ref = TopicRef {
+                    tenant: tenant.clone(),
+                    namespace: namespace.clone(),
+                    topic: topic.clone(),
+                    persistent: *persistent,
+                    partitioned: None,
+                };
+                self.profile.topic_permission_role_path(topic_ref.domain(), &topic_ref.path(), role)
+            }
+        };
+        let body = serde_json::to_value(&actions).map_err(|e| e.to_string())?;
+        self.send_empty(reqwest::Method::POST, &path, Some(&body), None).await
+    }
+
+    async fn revoke_permission(&self, scope: &PolicyScope, role: &str) -> Result<(), String> {
+        let path = match scope {
+            PolicyScope::Namespace { tenant, namespace } => {
+                self.profile.namespace_permission_role_path(tenant, namespace, role)
+            }
+            PolicyScope::Topic { tenant, namespace, topic, persistent } => {
+                let topic_ref = TopicRef {
+                    tenant: tenant.clone(),
+                    namespace: namespace.clone(),
+                    topic: topic.clone(),
+                    persistent: *persistent,
+                    partitioned: None,
+                };
+                self.profile.topic_permission_role_path(topic_ref.domain(), &topic_ref.path(), role)
+            }
+        };
+        self.send_empty(reqwest::Method::DELETE, &path, None, None).await
+    }
+
+    async fn list_permissions(&self, scope: &PolicyScope) -> Result<PermissionMap, String> {
+        let path = match scope {
+            PolicyScope::Namespace { tenant, namespace } => self.profile.namespace_permissions_path(tenant, namespace),
+            PolicyScope::Topic { tenant, namespace, topic, persistent } => {
+                let topic_ref = TopicRef {
+                    tenant: tenant.clone(),
+                    namespace: namespace.clone(),
+                    topic: topic.clone(),
+                    persistent: *persistent,
+                    partitioned: None,
+                };
+                self.profile.topic_permissions_path(topic_ref.domain(), &topic_ref.path())
+            }
+        };
+        let raw: serde_json::Value = self.get_value(&path).await?;
+        let mut map = PermissionMap::new();
+        if let Some(obj) = raw.as_object() {
+            for (role, actions) in obj {
+                let parsed: Vec<AuthAction> = actions
+                    .as_array()
+                    .map(|arr| arr.iter().filter_map(|a| serde_json::from_value(a.clone()).ok()).collect())
+                    .unwrap_or_default();
+                map.insert(role.clone(), parsed);
+            }
+        }
+        Ok(map)
+    }
+
+    // ---- Monitoring ----
+
+    async fn get_backlog(&self, topic: &TopicRef, sub: Option<&str>) -> Result<BacklogStats, String> {
+        let stats = self.get_topic_stats(topic).await?;
+        Ok(backlog_stats_from_topic_stats(&self.profile, &stats, sub))
+    }
+
+    // ---- Escape hatch ----
+
+    async fn raw_request(&self, req: MqRawRequest) -> Result<MqRawResponse, String> {
+        let method = reqwest::Method::from_bytes(req.method.to_ascii_uppercase().as_bytes())
+            .map_err(|_| format!("Invalid HTTP method: {}", req.method))?;
+        // SSRF guard: only a relative path is allowed; it is appended to the
+        // connection's admin base. Reject absolute URLs and parent traversal.
+        let path = sanitize_raw_path(&req.path)?;
+        let query: Option<Vec<(String, String)>> = req.query.map(|m| m.into_iter().collect::<Vec<(String, String)>>());
+        let resp = self.send(method, &path, req.body.as_ref(), query.as_deref()).await?;
+        let status = resp.status().as_u16();
+        // Enforce a response size limit to prevent unbounded memory consumption.
+        let content_length = resp.content_length().unwrap_or(0) as usize;
+        if content_length > MAX_RAW_RESPONSE_BYTES {
+            return Err(format!(
+                "Raw response body exceeds the {MAX_RAW_RESPONSE_BYTES}-byte limit ({content_length} bytes reported)"
+            ));
+        }
+        let bytes = resp.bytes().await.map_err(|e| format!("Failed to read response body: {e}"))?;
+        if bytes.len() > MAX_RAW_RESPONSE_BYTES {
+            return Err(format!(
+                "Raw response body exceeds the {MAX_RAW_RESPONSE_BYTES}-byte limit ({} bytes received)",
+                bytes.len()
+            ));
+        }
+        let text = String::from_utf8_lossy(&bytes).to_string();
+        match serde_json::from_str::<serde_json::Value>(&text) {
+            Ok(body) => Ok(MqRawResponse { status, body, text: None }),
+            Err(_) => Ok(MqRawResponse { status, body: serde_json::Value::Null, text: Some(text) }),
+        }
+    }
+}
+
+impl PulsarAdmin {
+    async fn topic_stats_value(&self, topic: &TopicRef) -> Result<serde_json::Value, String> {
+        if topic.partitioned == Some(true) {
+            let partitioned_path = self.profile.topic_partitioned_stats_path(topic.domain(), &topic.path(), true);
+            return match self.get_value(&partitioned_path).await {
+                Ok(raw) => Ok(raw),
+                Err(partitioned_err) => {
+                    let stats_path = self.profile.topic_stats_path(topic.domain(), &topic.path());
+                    self.get_value(&stats_path).await.map_err(|stats_err| {
+                        format!(
+                            "partitioned stats {partitioned_path} failed: {partitioned_err}; stats fallback {stats_path} failed: {stats_err}"
+                        )
+                    })
+                }
+            };
+        }
+
+        let stats_path = self.profile.topic_stats_path(topic.domain(), &topic.path());
+        match self.get_value(&stats_path).await {
+            Ok(raw) => Ok(raw),
+            Err(err) if is_not_found_error(&err) => {
+                let partitioned_path = self.profile.topic_partitioned_stats_path(topic.domain(), &topic.path(), true);
+                self.get_value(&partitioned_path).await.map_err(|partitioned_err| {
+                    format!("{err}; partitioned stats fallback {partitioned_path} failed: {partitioned_err}")
+                })
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    async fn partition_count_for_topic(&self, domain: &str, full_topic_name: &str) -> Result<Option<u32>, String> {
+        let path = self.profile.topic_partitions_path(domain, topic_path_from_full_name(full_topic_name));
+        match self.get_value(&path).await {
+            Ok(raw) => Ok(partition_count_from_metadata(&raw)),
+            Err(err) if is_unsupported_endpoint_error(&err) => {
+                log::debug!("partition metadata unavailable for {full_topic_name}: {err}");
+                Ok(None)
+            }
+            Err(err) => Err(err),
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+fn build_http_client(
+    tls_skip_verify: bool,
+    connect_override: Option<&MqConnectOverride>,
+    admin_url: &str,
+) -> Result<reqwest::Client, String> {
+    let mut builder = crate::db::http_client_builder(std::time::Duration::from_secs(REQUEST_TIMEOUT_SECS))
+        .timeout(std::time::Duration::from_secs(REQUEST_TIMEOUT_SECS));
+    if tls_skip_verify {
+        builder = builder.danger_accept_invalid_certs(true);
+    }
+    if let Some(connect_override) = connect_override {
+        let url = reqwest::Url::parse(admin_url).map_err(|e| format!("MQ Admin URL is invalid: {e}"))?;
+        let original_host = url.host_str().ok_or("MQ Admin URL host is empty")?;
+        let override_ip = connect_override
+            .host
+            .parse::<IpAddr>()
+            .map_err(|e| format!("MQ transport endpoint host must be an IP address: {e}"))?;
+        builder = builder.resolve(original_host, SocketAddr::new(override_ip, connect_override.port));
+    }
+    builder.build().map_err(|e| format!("Failed to build HTTP client: {e}"))
+}
+
+fn normalize_base(url: &str) -> String {
+    url.trim().trim_end_matches('/').to_string()
+}
+
+/// Redact any userinfo in the base URL for logging.
+fn redact_base(base: &str) -> String {
+    match base.split_once("://") {
+        Some((scheme, rest)) => match rest.split_once('@') {
+            Some((_, host)) => format!("{scheme}://***@{host}"),
+            None => base.to_string(),
+        },
+        None => base.to_string(),
+    }
+}
+
+/// Detect the broker version: honour a pinned version first, otherwise probe
+/// `brokers/version`, otherwise fall back to the baseline profile.
+async fn detect_version(
+    http: &reqwest::Client,
+    base: &str,
+    auth: &MqAuth,
+    cache: &TokenCache,
+    pinned: Option<&str>,
+) -> DetectedVersion {
+    if let Some(pinned) = pinned.map(str::trim).filter(|s| !s.is_empty()) {
+        if let Some(version) = PulsarApiProfile::parse_version(pinned) {
+            return DetectedVersion { version, detection: VersionDetection::Pinned, raw: Some(pinned.to_string()) };
+        }
+        log::warn!("Pinned Pulsar version '{pinned}' is not recognised; probing instead");
+    }
+
+    let url = format!("{base}/admin/v2/brokers/version");
+    let req = http.get(&url).timeout(std::time::Duration::from_secs(PROBE_TIMEOUT_SECS));
+    let probed = match auth.apply(req, http, cache).await {
+        Ok(req) => req.send().await,
+        Err(err) => {
+            log::warn!("Pulsar version probe auth failed: {err}; using baseline profile");
+            return fallback_detection();
+        }
+    };
+
+    match probed {
+        Ok(resp) if resp.status().is_success() => {
+            let raw = resp.text().await.unwrap_or_default();
+            match PulsarApiProfile::parse_version(&raw) {
+                Some(version) => {
+                    DetectedVersion { version, detection: VersionDetection::Probed, raw: Some(raw.trim().to_string()) }
+                }
+                None => {
+                    log::info!("Pulsar broker reported version '{}', not first-party; using baseline", raw.trim());
+                    DetectedVersion {
+                        version: PulsarVersion::V3_1,
+                        detection: VersionDetection::Fallback,
+                        raw: Some(raw.trim().to_string()),
+                    }
+                }
+            }
+        }
+        Ok(resp) => {
+            log::warn!("Pulsar version probe returned {}; using baseline profile", resp.status());
+            fallback_detection()
+        }
+        Err(err) => {
+            log::warn!("Pulsar version probe failed: {err}; using baseline profile");
+            fallback_detection()
+        }
+    }
+}
+
+fn fallback_detection() -> DetectedVersion {
+    DetectedVersion { version: PulsarVersion::V3_1, detection: VersionDetection::Fallback, raw: None }
+}
+
+/// Return a `["force","true"]`-style query parameter list when `force` is set.
+fn force_query(force: bool) -> Option<Vec<(String, String)>> {
+    force.then(|| vec![("force".to_string(), "true".to_string())])
+}
+
+async fn error_for_status(resp: reqwest::Response, path: &str) -> Result<reqwest::Response, String> {
+    if resp.status().is_success() {
+        Ok(resp)
+    } else {
+        Err(status_error(resp, path).await)
+    }
+}
+
+async fn status_error(resp: reqwest::Response, path: &str) -> String {
+    let status = resp.status();
+    let body = resp.text().await.unwrap_or_default();
+    let detail = if body.trim().is_empty() { String::new() } else { format!(": {}", truncate(&body, 400)) };
+    format!("Pulsar admin {path} returned {status}{detail}")
+}
+
+fn string_array(value: &serde_json::Value, key: &str) -> Vec<String> {
+    value
+        .get(key)
+        .and_then(serde_json::Value::as_array)
+        .map(|arr| arr.iter().filter_map(|v| v.as_str().map(str::to_string)).collect())
+        .unwrap_or_default()
+}
+
+/// The short topic name from a full name like
+/// `persistent://public/default/orders` -> `orders`.
+fn short_topic_name(full: &str) -> String {
+    let path = topic_path_from_full_name(full);
+    let mut parts = path.splitn(3, '/');
+    let fallback = path.rsplit('/').next().unwrap_or(path);
+    match (parts.next(), parts.next(), parts.next()) {
+        (Some(_tenant), Some(_namespace), Some(topic)) => topic.to_string(),
+        _ => fallback.to_string(),
+    }
+}
+
+fn topic_path_from_full_name(full: &str) -> &str {
+    full.split_once("://").map(|(_, path)| path).unwrap_or(full)
+}
+
+fn partition_count_from_metadata(raw: &serde_json::Value) -> Option<u32> {
+    let count = raw.get("partitions").and_then(serde_json::Value::as_u64).or_else(|| raw.as_u64())?;
+    u32::try_from(count).ok().filter(|count| *count > 0)
+}
+
+fn is_not_found_error(err: &str) -> bool {
+    err.contains(" returned 404 ") || err.contains("404 Not Found")
+}
+
+fn is_method_not_allowed_error(err: &str) -> bool {
+    err.contains(" returned 405 ") || err.contains("405 Method Not Allowed")
+}
+
+fn is_unsupported_endpoint_error(err: &str) -> bool {
+    is_not_found_error(err) || is_method_not_allowed_error(err)
+}
+
+fn producers_from_stats_payload(raw: &serde_json::Value) -> Vec<ProducerInfo> {
+    let mut producers = Vec::new();
+    append_producers_from_stats(raw, &mut producers);
+    if let Some(partitions) = raw.get("partitions").and_then(serde_json::Value::as_object) {
+        for partition_stats in partitions.values() {
+            append_producers_from_stats(partition_stats, &mut producers);
+        }
+    }
+    producers
+}
+
+fn append_producers_from_stats(raw: &serde_json::Value, producers: &mut Vec<ProducerInfo>) {
+    if let Some(items) = raw.get("publishers").and_then(serde_json::Value::as_array) {
+        producers.extend(items.iter().map(parse_producer));
+    }
+}
+
+/// Whether `full` is a per-partition member (`...-partition-N`) of one of the
+/// partitioned base topics.
+fn is_partition_member(full: &str, partitioned: &std::collections::HashSet<String>) -> bool {
+    if let Some(idx) = full.rfind("-partition-") {
+        let (base, suffix) = full.split_at(idx);
+        let n = &suffix["-partition-".len()..];
+        if !n.is_empty() && n.chars().all(|c| c.is_ascii_digit()) {
+            return partitioned.contains(base);
+        }
+    }
+    false
+}
+
+/// Build a message-id body for reset-cursor / create-subscription based on the
+/// requested position. Earliest/latest use the sentinel ledger/entry ids Pulsar
+/// recognises.
+fn reset_position_message_id(pos: &ResetPosition) -> serde_json::Value {
+    match pos {
+        ResetPosition::Earliest => serde_json::json!({ "ledgerId": -1, "entryId": -1 }),
+        ResetPosition::Latest => serde_json::json!({ "ledgerId": i64::MAX, "entryId": i64::MAX }),
+        ResetPosition::MessageId { ledger_id, entry_id } => {
+            serde_json::json!({ "ledgerId": ledger_id, "entryId": entry_id })
+        }
+        // Timestamp is handled by a dedicated path; default to latest here.
+        ResetPosition::Timestamp { .. } => serde_json::json!({ "ledgerId": i64::MAX, "entryId": i64::MAX }),
+    }
+}
+
+fn parse_producer(v: &serde_json::Value) -> ProducerInfo {
+    ProducerInfo {
+        producer_id: v.get("producerId").and_then(serde_json::Value::as_i64).unwrap_or(0),
+        producer_name: v.get("producerName").and_then(serde_json::Value::as_str).unwrap_or("").to_string(),
+        msg_rate_in: v.get("msgRateIn").and_then(serde_json::Value::as_f64).unwrap_or(0.0),
+        msg_throughput_in: v.get("msgThroughputIn").and_then(serde_json::Value::as_f64).unwrap_or(0.0),
+        address: v.get("address").and_then(serde_json::Value::as_str).unwrap_or("").to_string(),
+        client_version: v.get("clientVersion").and_then(serde_json::Value::as_str).unwrap_or("").to_string(),
+    }
+}
+
+fn response_headers(headers: &reqwest::header::HeaderMap) -> HashMap<String, String> {
+    headers
+        .iter()
+        .filter_map(|(name, value)| {
+            value.to_str().ok().map(|value| (name.as_str().to_ascii_lowercase(), value.to_string()))
+        })
+        .collect()
+}
+
+fn peeked_message_from_response(position: u32, headers: HashMap<String, String>, payload: &[u8]) -> PeekedMessage {
+    let properties = headers
+        .iter()
+        .filter_map(|(name, value)| {
+            name.strip_prefix("x-pulsar-property-").map(|property| (property.to_string(), value.clone()))
+        })
+        .collect();
+    PeekedMessage {
+        position,
+        message_id: header_value(&headers, &["x-pulsar-message-id", "x-pulsar-messageid"]),
+        key: header_value(&headers, &["x-pulsar-key", "x-pulsar-message-key"]),
+        publish_time: header_value(&headers, &["x-pulsar-publish-time", "x-pulsar-publish-time-ms"]),
+        event_time: header_value(&headers, &["x-pulsar-event-time", "x-pulsar-event-time-ms"]),
+        properties,
+        headers,
+        payload_base64: BASE64.encode(payload),
+        payload_text: std::str::from_utf8(payload).ok().map(str::to_string),
+    }
+}
+
+fn header_value(headers: &HashMap<String, String>, names: &[&str]) -> Option<String> {
+    names.iter().find_map(|name| headers.get(*name).cloned())
+}
+
+/// Validate a raw request path: must be a relative path beginning with `/`, no
+/// scheme/host, no `..` traversal.
+fn sanitize_raw_path(path: &str) -> Result<String, String> {
+    let trimmed = path.trim();
+    if trimmed.is_empty() {
+        return Err("Raw request path is empty".to_string());
+    }
+    if trimmed.contains("://") || trimmed.starts_with("//") {
+        return Err("Raw request path must be relative to the admin base (no scheme/host allowed)".to_string());
+    }
+    if !trimmed.starts_with('/') {
+        return Err("Raw request path must start with '/'".to_string());
+    }
+    if trimmed.split('/').any(|seg| seg == "..") {
+        return Err("Raw request path must not contain '..'".to_string());
+    }
+    Ok(trimmed.to_string())
+}
+
+fn backlog_stats_from_topic_stats(profile: &PulsarApiProfile, stats: &TopicStats, sub: Option<&str>) -> BacklogStats {
+    let subs = profile.parse_subscriptions(&stats.raw);
+    let msg_backlog = match sub {
+        Some(name) => subs.into_iter().find(|s| s.name == name).map(|s| s.msg_backlog).unwrap_or(0),
+        None => subs.into_iter().fold(0_i64, |total, sub| total.saturating_add(sub.msg_backlog)),
+    };
+
+    BacklogStats { msg_backlog, backlog_size: stats.backlog_size }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+    use tokio::net::{TcpListener, TcpStream};
+    use tokio::sync::Mutex;
+
+    #[derive(Clone)]
+    struct MockRoute {
+        method: &'static str,
+        path: &'static str,
+        status: u16,
+        body: &'static str,
+    }
+
+    #[derive(Clone, Debug)]
+    struct ObservedRequest {
+        method: String,
+        path: String,
+        body: String,
+    }
+
+    struct MockPulsarServer {
+        base_url: String,
+        observed: std::sync::Arc<Mutex<Vec<ObservedRequest>>>,
+    }
+
+    impl MockPulsarServer {
+        async fn spawn(routes: Vec<MockRoute>) -> Self {
+            let listener = TcpListener::bind("127.0.0.1:0").await.expect("failed to bind test server socket");
+            let addr = listener.local_addr().expect("failed to get test server local address");
+            let routes = std::sync::Arc::new(routes);
+            let observed = std::sync::Arc::new(Mutex::new(Vec::new()));
+            let server_observed = observed.clone();
+            tokio::spawn(async move {
+                loop {
+                    let Ok((mut stream, _)) = listener.accept().await else {
+                        break;
+                    };
+                    let routes = routes.clone();
+                    let observed = server_observed.clone();
+                    tokio::spawn(async move {
+                        let Some(request) = read_mock_request(&mut stream).await else {
+                            return;
+                        };
+                        let response = routes
+                            .iter()
+                            .find(|route| route.method == request.method && route.path == request.path)
+                            .cloned()
+                            .unwrap_or(MockRoute {
+                                method: "GET",
+                                path: "",
+                                status: 500,
+                                body: r#"{"reason":"unexpected request"}"#,
+                            });
+                        observed.lock().await.push(request);
+                        write_mock_response(&mut stream, response.status, response.body).await;
+                    });
+                }
+            });
+
+            Self { base_url: format!("http://{addr}"), observed }
+        }
+
+        async fn admin(&self) -> PulsarAdmin {
+            PulsarAdmin::new(MqAdminConfig {
+                system_kind: MqSystemKind::Pulsar,
+                admin_url: self.base_url.clone(),
+                auth: MqAuth::None,
+                tls_skip_verify: false,
+                pinned_version: Some("3.1".to_string()),
+                token_signing: None,
+                connect_override: None,
+                extra: serde_json::Value::Null,
+            })
+            .await
+            .expect("failed to create test Pulsar admin client")
+        }
+
+        async fn observed(&self) -> Vec<ObservedRequest> {
+            self.observed.lock().await.clone()
+        }
+    }
+
+    async fn read_mock_request(stream: &mut TcpStream) -> Option<ObservedRequest> {
+        let mut buf = Vec::new();
+        let mut tmp = [0_u8; 1024];
+        let header_end = loop {
+            let n = stream.read(&mut tmp).await.ok()?;
+            if n == 0 {
+                return None;
+            }
+            buf.extend_from_slice(&tmp[..n]);
+            if let Some(index) = find_header_end(&buf) {
+                break index;
+            }
+        };
+
+        let header = String::from_utf8_lossy(&buf[..header_end]);
+        let mut lines = header.lines();
+        let first = lines.next()?;
+        let mut parts = first.split_whitespace();
+        let method = parts.next()?.to_string();
+        let path = parts.next()?.to_string();
+        let content_length = lines
+            .filter_map(|line| line.split_once(':'))
+            .find_map(|(name, value)| {
+                name.eq_ignore_ascii_case("content-length").then(|| value.trim().parse::<usize>().ok()).flatten()
+            })
+            .unwrap_or(0);
+
+        let body_start = header_end + 4;
+        let mut body = buf.get(body_start..).unwrap_or_default().to_vec();
+        while body.len() < content_length {
+            let n = stream.read(&mut tmp).await.ok()?;
+            if n == 0 {
+                break;
+            }
+            body.extend_from_slice(&tmp[..n]);
+        }
+        body.truncate(content_length);
+
+        Some(ObservedRequest { method, path, body: String::from_utf8_lossy(&body).to_string() })
+    }
+
+    fn find_header_end(buf: &[u8]) -> Option<usize> {
+        buf.windows(4).position(|window| window == b"\r\n\r\n")
+    }
+
+    async fn write_mock_response(stream: &mut TcpStream, status: u16, body: &str) {
+        let reason = match status {
+            200 => "OK",
+            204 => "No Content",
+            400 => "Bad Request",
+            401 => "Unauthorized",
+            403 => "Forbidden",
+            404 => "Not Found",
+            405 => "Method Not Allowed",
+            500 => "Internal Server Error",
+            _ => "OK",
+        };
+        let response = format!(
+            "HTTP/1.1 {status} {reason}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+            body.len()
+        );
+        let _ = stream.write_all(response.as_bytes()).await;
+    }
+
+    fn assert_json_body(request: &ObservedRequest, expected: serde_json::Value) {
+        let actual: serde_json::Value =
+            serde_json::from_str(&request.body).expect("test request body should be valid JSON");
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn normalizes_base_url() {
+        assert_eq!(normalize_base("http://x:8080/"), "http://x:8080");
+        assert_eq!(normalize_base("  http://x:8080  "), "http://x:8080");
+    }
+
+    #[test]
+    fn redacts_userinfo() {
+        assert_eq!(redact_base("http://user:pw@host:8080"), "http://***@host:8080");
+        assert_eq!(redact_base("http://host:8080"), "http://host:8080");
+    }
+
+    #[test]
+    fn short_topic_name_extracts_last_segment() {
+        assert_eq!(short_topic_name("persistent://public/default/orders"), "orders");
+        assert_eq!(short_topic_name("persistent://public/default/orders/a"), "orders/a");
+        assert_eq!(short_topic_name("non-persistent://tenant/ns/topic/with/slash"), "topic/with/slash");
+    }
+
+    #[test]
+    fn partition_count_from_metadata_reads_pulsar_shapes() {
+        assert_eq!(partition_count_from_metadata(&serde_json::json!({ "partitions": 4 })), Some(4));
+        assert_eq!(partition_count_from_metadata(&serde_json::json!(8)), Some(8));
+        assert_eq!(partition_count_from_metadata(&serde_json::json!({ "partitions": 0 })), None);
+    }
+
+    #[tokio::test]
+    async fn list_tenants_returns_detail_server_errors() {
+        let server = MockPulsarServer::spawn(vec![
+            MockRoute { method: "GET", path: "/admin/v2/tenants", status: 200, body: r#"["acme"]"# },
+            MockRoute { method: "GET", path: "/admin/v2/tenants/acme", status: 500, body: r#"{"reason":"boom"}"# },
+        ])
+        .await;
+        let admin = server.admin().await;
+
+        let err = admin.list_tenants().await.unwrap_err();
+
+        assert!(err.contains("/admin/v2/tenants/acme"));
+        assert!(err.contains("500 Internal Server Error"));
+    }
+
+    #[tokio::test]
+    async fn list_namespaces_returns_permission_server_errors() {
+        let server = MockPulsarServer::spawn(vec![
+            MockRoute { method: "GET", path: "/admin/v2/namespaces/acme", status: 200, body: r#"["acme/events"]"# },
+            MockRoute {
+                method: "GET",
+                path: "/admin/v2/namespaces/acme/events/permissions",
+                status: 403,
+                body: r#"{"reason":"denied"}"#,
+            },
+        ])
+        .await;
+        let admin = server.admin().await;
+
+        let err = admin.list_namespaces("acme").await.unwrap_err();
+
+        assert!(err.contains("/admin/v2/namespaces/acme/events/permissions"));
+        assert!(err.contains("403 Forbidden"));
+    }
+
+    #[tokio::test]
+    async fn list_topics_returns_partitioned_topic_list_server_errors() {
+        let server = MockPulsarServer::spawn(vec![
+            MockRoute {
+                method: "GET",
+                path: "/admin/v2/persistent/public/default/partitioned",
+                status: 500,
+                body: r#"{"reason":"boom"}"#,
+            },
+            MockRoute { method: "GET", path: "/admin/v2/persistent/public/default", status: 200, body: "[]" },
+        ])
+        .await;
+        let admin = server.admin().await;
+
+        let err = admin
+            .list_topics(
+                &NamespaceRef { tenant: "public".to_string(), namespace: "default".to_string() },
+                ListTopicsOpts { include_non_persistent: false },
+            )
+            .await
+            .unwrap_err();
+
+        assert!(err.contains("/admin/v2/persistent/public/default/partitioned"));
+        assert!(err.contains("500 Internal Server Error"));
+    }
+
+    #[tokio::test]
+    async fn list_topics_allows_unsupported_partitioned_topic_endpoint() {
+        let server = MockPulsarServer::spawn(vec![
+            MockRoute {
+                method: "GET",
+                path: "/admin/v2/persistent/public/default/partitioned",
+                status: 404,
+                body: r#"{"reason":"not enabled"}"#,
+            },
+            MockRoute {
+                method: "GET",
+                path: "/admin/v2/persistent/public/default",
+                status: 200,
+                body: r#"["persistent://public/default/plain"]"#,
+            },
+        ])
+        .await;
+        let admin = server.admin().await;
+
+        let topics = admin
+            .list_topics(
+                &NamespaceRef { tenant: "public".to_string(), namespace: "default".to_string() },
+                ListTopicsOpts { include_non_persistent: false },
+            )
+            .await
+            .expect("list_topics should succeed");
+
+        assert_eq!(topics.len(), 1);
+        assert_eq!(topics[0].name, "persistent://public/default/plain");
+        assert!(!topics[0].partitioned);
+    }
+
+    #[tokio::test]
+    async fn list_topics_returns_partition_metadata_errors() {
+        let server = MockPulsarServer::spawn(vec![
+            MockRoute {
+                method: "GET",
+                path: "/admin/v2/persistent/public/default/partitioned",
+                status: 200,
+                body: r#"["persistent://public/default/orders"]"#,
+            },
+            MockRoute {
+                method: "GET",
+                path: "/admin/v2/persistent/public/default/orders/partitions",
+                status: 403,
+                body: r#"{"reason":"denied"}"#,
+            },
+            MockRoute { method: "GET", path: "/admin/v2/persistent/public/default", status: 200, body: "[]" },
+        ])
+        .await;
+        let admin = server.admin().await;
+
+        let err = admin
+            .list_topics(
+                &NamespaceRef { tenant: "public".to_string(), namespace: "default".to_string() },
+                ListTopicsOpts { include_non_persistent: false },
+            )
+            .await
+            .unwrap_err();
+
+        assert!(err.contains("/admin/v2/persistent/public/default/orders/partitions"));
+        assert!(err.contains("403 Forbidden"));
+    }
+
+    #[tokio::test]
+    async fn mutating_methods_use_expected_http_contracts() {
+        let server = MockPulsarServer::spawn(vec![
+            MockRoute { method: "PUT", path: "/admin/v2/tenants/acme", status: 204, body: "" },
+            MockRoute { method: "PUT", path: "/admin/v2/namespaces/acme/events", status: 204, body: "" },
+            MockRoute {
+                method: "PUT",
+                path: "/admin/v2/persistent/acme/events/orders/partitions",
+                status: 204,
+                body: "",
+            },
+            MockRoute {
+                method: "PUT",
+                path: "/admin/v2/persistent/acme/events/orders/subscription/sub%2Frole%20%231",
+                status: 204,
+                body: "",
+            },
+            MockRoute { method: "POST", path: "/admin/v2/namespaces/acme/events/publishRate", status: 204, body: "" },
+            MockRoute { method: "GET", path: "/admin/v2/clusters", status: 200, body: r#"["ec-pulsar"]"# },
+        ])
+        .await;
+        let admin = server.admin().await;
+
+        admin
+            .create_tenant(
+                "acme",
+                TenantConfig {
+                    admin_roles: vec!["admin".to_string()],
+                    allowed_clusters: vec!["ec-pulsar".to_string()],
+                },
+            )
+            .await
+            .expect("create_tenant should succeed");
+        admin
+            .create_namespace(
+                &NamespaceRef { tenant: "acme".to_string(), namespace: "events".to_string() },
+                NamespaceConfig { clusters: vec!["ec-pulsar".to_string()], bundles: Some(16) },
+            )
+            .await
+            .expect("create_namespace should succeed");
+        let topic = TopicRef {
+            tenant: "acme".to_string(),
+            namespace: "events".to_string(),
+            topic: "orders".to_string(),
+            persistent: true,
+            partitioned: Some(true),
+        };
+        admin.create_topic(&topic, Some(3)).await.expect("create_topic should succeed");
+        admin
+            .create_subscription(&topic, "sub/role #1", ResetPosition::Latest)
+            .await
+            .expect("create_subscription should succeed");
+        admin
+            .set_publish_rate(
+                &PolicyScope::Namespace { tenant: "acme".to_string(), namespace: "events".to_string() },
+                PublishRate { publish_throttling_rate_in_msg: 10, publish_throttling_rate_in_byte: 2048 },
+            )
+            .await
+            .expect("set_publish_rate should succeed");
+        let raw = admin
+            .raw_request(MqRawRequest {
+                method: "GET".to_string(),
+                path: "/admin/v2/clusters".to_string(),
+                query: None,
+                body: None,
+            })
+            .await
+            .expect("raw_admin_request should succeed");
+        assert_eq!(raw.status, 200);
+        assert_eq!(raw.body, serde_json::json!(["ec-pulsar"]));
+
+        let observed = server.observed().await;
+        let method_paths = observed.iter().map(|req| (req.method.as_str(), req.path.as_str())).collect::<Vec<_>>();
+        assert_eq!(
+            method_paths,
+            vec![
+                ("PUT", "/admin/v2/tenants/acme"),
+                ("PUT", "/admin/v2/namespaces/acme/events"),
+                ("PUT", "/admin/v2/persistent/acme/events/orders/partitions"),
+                ("PUT", "/admin/v2/persistent/acme/events/orders/subscription/sub%2Frole%20%231"),
+                ("POST", "/admin/v2/namespaces/acme/events/publishRate"),
+                ("GET", "/admin/v2/clusters"),
+            ]
+        );
+        assert_json_body(
+            &observed[0],
+            serde_json::json!({ "adminRoles": ["admin"], "allowedClusters": ["ec-pulsar"] }),
+        );
+        assert_json_body(
+            &observed[1],
+            serde_json::json!({ "replication_clusters": ["ec-pulsar"], "bundles": { "numBundles": 16 } }),
+        );
+        assert_json_body(&observed[2], serde_json::json!(3));
+        assert_json_body(&observed[3], serde_json::json!({ "ledgerId": i64::MAX, "entryId": i64::MAX }));
+        assert_json_body(
+            &observed[4],
+            serde_json::json!({ "publishThrottlingRateInMsg": 10, "publishThrottlingRateInByte": 2048 }),
+        );
+        assert!(observed[5].body.is_empty());
+    }
+
+    #[tokio::test]
+    async fn status_errors_include_path_status_and_body() {
+        let server = MockPulsarServer::spawn(vec![
+            MockRoute { method: "GET", path: "/admin/v2/tenants", status: 401, body: r#"{"reason":"missing token"}"# },
+            MockRoute {
+                method: "GET",
+                path: "/admin/v2/tenants/forbidden",
+                status: 403,
+                body: r#"{"reason":"denied"}"#,
+            },
+            MockRoute {
+                method: "GET",
+                path: "/admin/v2/namespaces/public/missing",
+                status: 404,
+                body: r#"{"reason":"missing"}"#,
+            },
+            MockRoute { method: "GET", path: "/admin/v2/clusters", status: 500, body: r#"{"reason":"broker down"}"# },
+        ])
+        .await;
+        let admin = server.admin().await;
+
+        let unauthorized = admin.list_tenants().await.unwrap_err();
+        assert!(unauthorized.contains("/admin/v2/tenants"));
+        assert!(unauthorized.contains("401 Unauthorized"));
+        assert!(unauthorized.contains("missing token"));
+
+        let forbidden = admin.get_tenant("forbidden").await.unwrap_err();
+        assert!(forbidden.contains("/admin/v2/tenants/forbidden"));
+        assert!(forbidden.contains("403 Forbidden"));
+        assert!(forbidden.contains("denied"));
+
+        let missing = admin
+            .get_namespace_policies(&NamespaceRef { tenant: "public".to_string(), namespace: "missing".to_string() })
+            .await
+            .unwrap_err();
+        assert!(missing.contains("/admin/v2/namespaces/public/missing"));
+        assert!(missing.contains("404 Not Found"));
+        assert!(missing.contains("missing"));
+
+        let server_error = admin.test_connection().await.unwrap_err();
+        assert!(server_error.contains("/admin/v2/clusters"));
+        assert!(server_error.contains("500 Internal Server Error"));
+        assert!(server_error.contains("broker down"));
+    }
+
+    #[test]
+    fn producers_from_stats_payload_reads_partitioned_stats() {
+        let raw = serde_json::json!({
+            "publishers": [{ "producerId": 10, "producerName": "aggregate" }],
+            "partitions": {
+                "persistent://b2b/ec-product-service/goods_status_change-partition-0": {
+                    "publishers": [{ "producerId": 1, "producerName": "p0" }]
+                },
+                "persistent://b2b/ec-product-service/goods_status_change-partition-1": {
+                    "publishers": [{ "producerId": 2, "producerName": "p1" }]
+                }
+            }
+        });
+
+        let producers = producers_from_stats_payload(&raw);
+
+        assert_eq!(
+            producers.iter().map(|producer| producer.producer_name.as_str()).collect::<Vec<_>>(),
+            vec!["aggregate", "p0", "p1"]
+        );
+    }
+
+    #[test]
+    fn detects_partition_members() {
+        let mut set = std::collections::HashSet::new();
+        set.insert("persistent://public/default/orders".to_string());
+        assert!(is_partition_member("persistent://public/default/orders-partition-0", &set));
+        assert!(!is_partition_member("persistent://public/default/orders-partition-x", &set));
+        assert!(!is_partition_member("persistent://public/default/other", &set));
+    }
+
+    #[test]
+    fn sanitizes_raw_paths() {
+        assert!(sanitize_raw_path("/admin/v2/tenants").is_ok());
+        assert!(sanitize_raw_path("http://evil/x").is_err());
+        assert!(sanitize_raw_path("//evil/x").is_err());
+        assert!(sanitize_raw_path("admin/v2").is_err());
+        assert!(sanitize_raw_path("/admin/../../etc").is_err());
+        assert!(sanitize_raw_path("   ").is_err());
+    }
+
+    #[test]
+    fn topic_backlog_sums_subscription_backlogs() {
+        let profile = PulsarApiProfile::default_baseline();
+        let stats = TopicStats {
+            msg_rate_in: 0.0,
+            msg_rate_out: 0.0,
+            msg_throughput_in: 0.0,
+            msg_throughput_out: 0.0,
+            storage_size: 0,
+            backlog_size: 4096,
+            msg_in_counter: 0,
+            msg_out_counter: 0,
+            subscription_count: 2,
+            producer_count: 0,
+            raw: serde_json::json!({
+                "subscriptions": {
+                    "sub-a": { "msgBacklog": 7 },
+                    "sub-b": { "msgBacklog": 11 }
+                }
+            }),
+        };
+
+        let backlog = backlog_stats_from_topic_stats(&profile, &stats, None);
+
+        assert_eq!(backlog.msg_backlog, 18);
+        assert_eq!(backlog.backlog_size, 4096);
+    }
+
+    #[test]
+    fn reset_position_message_ids() {
+        assert_eq!(
+            reset_position_message_id(&ResetPosition::Earliest),
+            serde_json::json!({"ledgerId": -1, "entryId": -1})
+        );
+        let mid = reset_position_message_id(&ResetPosition::MessageId { ledger_id: 5, entry_id: 9 });
+        assert_eq!(mid, serde_json::json!({"ledgerId": 5, "entryId": 9}));
+    }
+
+    #[test]
+    fn force_query_only_when_true() {
+        assert!(force_query(false).is_none());
+        assert_eq!(
+            force_query(true).expect("force=true should produce query params"),
+            vec![("force".to_string(), "true".to_string())]
+        );
+    }
+
+    #[test]
+    fn builds_peeked_message_from_headers_and_payload() {
+        let message = peeked_message_from_response(
+            2,
+            HashMap::from([
+                ("x-pulsar-message-id".to_string(), "1:2:3".to_string()),
+                ("x-pulsar-key".to_string(), "order-1".to_string()),
+                ("x-pulsar-property-source".to_string(), "api".to_string()),
+            ]),
+            b"hello",
+        );
+
+        assert_eq!(message.position, 2);
+        assert_eq!(message.message_id.as_deref(), Some("1:2:3"));
+        assert_eq!(message.key.as_deref(), Some("order-1"));
+        assert_eq!(message.properties.get("source").map(String::as_str), Some("api"));
+        assert_eq!(message.payload_base64, "aGVsbG8=");
+        assert_eq!(message.payload_text.as_deref(), Some("hello"));
+    }
+}
diff --git a/crates/dbx-core/src/mq/adapters/pulsar_version.rs b/crates/dbx-core/src/mq/adapters/pulsar_version.rs
new file mode 100644
index 0000000..f36d4e6
--- /dev/null
+++ b/crates/dbx-core/src/mq/adapters/pulsar_version.rs
@@ -0,0 +1,585 @@
+//! Pulsar version detection and the version "profile" that isolates all
+//! version-specific behaviour (endpoint paths + response parsing + capability
+//! flags) behind one object. Adapter methods express *what* to do; the profile
+//! decides *how*, per the resolved version.
+//!
+//! First-party scope is **Pulsar 3.1.x** (REST-contract compatible with the
+//! 3.0.x LTS line). Newer versions are handled additively: add a `PulsarVersion`
+//! variant, add the differing path/parse branches here, and the adapter, service
+//! layer, commands, routes, and frontend stay untouched. See
+//! `docs/message-queue-admin-design.zh-CN.md` chapter 10.
+
+use percent_encoding::{utf8_percent_encode, NON_ALPHANUMERIC};
+use serde::{Deserialize, Serialize};
+
+use super::super::types::{MqCapabilities, SubscriptionInfo, TopicStats};
+
+/// A recognised Pulsar major/minor line. Unknown versions fall back to the
+/// nearest known profile in conservative mode.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum PulsarVersion {
+    /// Pulsar 3.0.x / 3.1.x — the first-party baseline.
+    V3_1,
+}
+
+impl PulsarVersion {
+    pub fn label(self) -> &'static str {
+        match self {
+            PulsarVersion::V3_1 => "3.1.x",
+        }
+    }
+}
+
+/// How the version was determined. Surfaced to the UI so users understand
+/// whether the adapter is running on a confirmed version.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum VersionDetection {
+    /// Probed from `brokers/version`.
+    Probed,
+    /// Pinned by the user in connection config.
+    Pinned,
+    /// Could not determine; using the default baseline profile.
+    Fallback,
+}
+
+impl VersionDetection {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            VersionDetection::Probed => "probed",
+            VersionDetection::Pinned => "pinned",
+            VersionDetection::Fallback => "fallback",
+        }
+    }
+}
+
+/// Resolved version picture: which version, how we found it, and the raw string.
+#[derive(Debug, Clone)]
+pub struct DetectedVersion {
+    pub version: PulsarVersion,
+    pub detection: VersionDetection,
+    pub raw: Option<String>,
+}
+
+/// The version profile: a single object that answers every version-dependent
+/// question. Adapter methods route all path construction and response parsing
+/// through here.
+#[derive(Debug, Clone)]
+pub struct PulsarApiProfile {
+    version: PulsarVersion,
+    detection: VersionDetection,
+    raw_version: Option<String>,
+}
+
+impl PulsarApiProfile {
+    /// Resolve a profile from a detected version.
+    pub fn resolve(detected: DetectedVersion) -> Self {
+        Self { version: detected.version, detection: detected.detection, raw_version: detected.raw }
+    }
+
+    /// The default baseline profile (3.1.x), used when detection fails.
+    pub fn default_baseline() -> Self {
+        Self { version: PulsarVersion::V3_1, detection: VersionDetection::Fallback, raw_version: None }
+    }
+
+    pub fn version(&self) -> PulsarVersion {
+        self.version
+    }
+
+    pub fn detection(&self) -> VersionDetection {
+        self.detection
+    }
+
+    pub fn raw_version(&self) -> Option<&str> {
+        self.raw_version.as_deref()
+    }
+
+    pub fn label(&self) -> &'static str {
+        self.version.label()
+    }
+
+    /// Parse a raw broker version string (e.g. `3.1.2`, `3.0.7`, or
+    /// `Pulsar version 3.1.2 ...`) into a known [`PulsarVersion`].
+    pub fn parse_version(raw: &str) -> Option<PulsarVersion> {
+        let trimmed = raw.trim();
+        // Find the first dotted numeric token.
+        let token = trimmed.split_whitespace().find(|part| part.chars().next().is_some_and(|c| c.is_ascii_digit()));
+        let token = token.unwrap_or(trimmed);
+        let mut nums = token.split('.');
+        let major: u32 = nums.next()?.trim().parse().ok()?;
+        let _minor: u32 = nums.next().and_then(|m| m.trim().parse().ok()).unwrap_or(0);
+        // 3.x (and the 3.0/3.1 LTS family) map onto the V3_1 baseline.
+        match major {
+            3 => Some(PulsarVersion::V3_1),
+            // Newer majors are not yet first-party; caller decides fallback.
+            _ => None,
+        }
+    }
+
+    /// Capability flags for this version. Older versions missing endpoints would
+    /// turn the corresponding flag off here so the UI hides them.
+    pub fn capabilities(&self) -> MqCapabilities {
+        match self.version {
+            PulsarVersion::V3_1 => MqCapabilities {
+                supports_tenants: true,
+                supports_namespaces: true,
+                supports_partitioned_topics: true,
+                supports_subscriptions: true,
+                supports_create_subscription: true,
+                supports_reset_cursor: true,
+                supports_skip_messages: true,
+                supports_clear_backlog: true,
+                supports_peek_messages: true,
+                supports_expire_messages: true,
+                supports_rate_limits: true,
+                supports_backlog_quota: true,
+                supports_retention: true,
+                supports_permissions: true,
+                supports_geo_replication: true,
+                // Token signing is NOT a broker REST capability — see chapter 11.
+                supports_token_management: false,
+                supports_raw_admin_api: true,
+                supports_send_message: false,
+            },
+        }
+    }
+
+    // ---- Path construction (all relative to the admin base) ----
+
+    pub fn broker_version_path(&self) -> String {
+        "/admin/v2/brokers/version".to_string()
+    }
+
+    pub fn clusters_path(&self) -> String {
+        "/admin/v2/clusters".to_string()
+    }
+
+    pub fn tenants_path(&self) -> String {
+        "/admin/v2/tenants".to_string()
+    }
+
+    pub fn tenant_path(&self, tenant: &str) -> String {
+        format!("/admin/v2/tenants/{}", encode_segment(tenant))
+    }
+
+    pub fn namespaces_path(&self, tenant: &str) -> String {
+        format!("/admin/v2/namespaces/{}", encode_segment(tenant))
+    }
+
+    pub fn namespace_path(&self, tenant: &str, namespace: &str) -> String {
+        format!("/admin/v2/namespaces/{}/{}", encode_segment(tenant), encode_segment(namespace))
+    }
+
+    pub fn namespace_policies_path(&self, tenant: &str, namespace: &str) -> String {
+        // GET on the namespace itself returns its policies.
+        self.namespace_path(tenant, namespace)
+    }
+
+    pub fn topics_path(&self, tenant: &str, namespace: &str, persistent: bool) -> String {
+        let domain = if persistent { "persistent" } else { "non-persistent" };
+        format!("/admin/v2/{domain}/{}/{}", encode_segment(tenant), encode_segment(namespace))
+    }
+
+    pub fn partitioned_topics_path(&self, tenant: &str, namespace: &str, persistent: bool) -> String {
+        let domain = if persistent { "persistent" } else { "non-persistent" };
+        format!("/admin/v2/{domain}/{}/{}/partitioned", encode_segment(tenant), encode_segment(namespace))
+    }
+
+    /// Base path for a single topic: `/admin/v2/{domain}/{tenant}/{ns}/{topic}`.
+    pub fn topic_base_path(&self, domain: &str, topic_path: &str) -> String {
+        format!("/admin/v2/{domain}/{}", encode_topic_path(topic_path))
+    }
+
+    pub fn topic_partitions_path(&self, domain: &str, topic_path: &str) -> String {
+        format!("/admin/v2/{domain}/{}/partitions", encode_topic_path(topic_path))
+    }
+
+    pub fn topic_stats_path(&self, domain: &str, topic_path: &str) -> String {
+        format!("/admin/v2/{domain}/{}/stats", encode_topic_path(topic_path))
+    }
+
+    pub fn topic_partitioned_stats_path(&self, domain: &str, topic_path: &str, per_partition: bool) -> String {
+        let path = format!("/admin/v2/{domain}/{}/partitioned-stats", encode_topic_path(topic_path));
+        if per_partition {
+            format!("{path}?perPartition=true")
+        } else {
+            path
+        }
+    }
+
+    pub fn topic_internal_stats_path(&self, domain: &str, topic_path: &str) -> String {
+        format!("/admin/v2/{domain}/{}/internalStats", encode_topic_path(topic_path))
+    }
+
+    pub fn subscriptions_path(&self, domain: &str, topic_path: &str) -> String {
+        format!("/admin/v2/{domain}/{}/subscriptions", encode_topic_path(topic_path))
+    }
+
+    pub fn subscription_path(&self, domain: &str, topic_path: &str, sub: &str) -> String {
+        format!("/admin/v2/{domain}/{}/subscription/{}", encode_topic_path(topic_path), encode_segment(sub))
+    }
+
+    pub fn subscription_reset_cursor_path(&self, domain: &str, topic_path: &str, sub: &str) -> String {
+        format!("/admin/v2/{domain}/{}/subscription/{}/resetcursor", encode_topic_path(topic_path), encode_segment(sub))
+    }
+
+    pub fn subscription_skip_path(&self, domain: &str, topic_path: &str, sub: &str, count: u32) -> String {
+        format!(
+            "/admin/v2/{domain}/{}/subscription/{}/skip/{count}",
+            encode_topic_path(topic_path),
+            encode_segment(sub)
+        )
+    }
+
+    pub fn subscription_skip_all_path(&self, domain: &str, topic_path: &str, sub: &str) -> String {
+        format!("/admin/v2/{domain}/{}/subscription/{}/skip_all", encode_topic_path(topic_path), encode_segment(sub))
+    }
+
+    pub fn subscription_peek_path(&self, domain: &str, topic_path: &str, sub: &str, position: u32) -> String {
+        format!(
+            "/admin/v2/{domain}/{}/subscription/{}/position/{position}",
+            encode_topic_path(topic_path),
+            encode_segment(sub)
+        )
+    }
+
+    pub fn subscription_expire_path(&self, domain: &str, topic_path: &str, sub: &str, expire_seconds: i64) -> String {
+        format!(
+            "/admin/v2/{domain}/{}/subscription/{}/expireMessages/{expire_seconds}",
+            encode_topic_path(topic_path),
+            encode_segment(sub)
+        )
+    }
+
+    pub fn topic_permissions_path(&self, domain: &str, topic_path: &str) -> String {
+        format!("/admin/v2/{domain}/{}/permissions", encode_topic_path(topic_path))
+    }
+
+    pub fn topic_permission_role_path(&self, domain: &str, topic_path: &str, role: &str) -> String {
+        format!("/admin/v2/{domain}/{}/permissions/{}", encode_topic_path(topic_path), encode_segment(role))
+    }
+
+    pub fn namespace_permissions_path(&self, tenant: &str, namespace: &str) -> String {
+        format!("/admin/v2/namespaces/{}/{}/permissions", encode_segment(tenant), encode_segment(namespace))
+    }
+
+    pub fn namespace_permission_role_path(&self, tenant: &str, namespace: &str, role: &str) -> String {
+        format!(
+            "/admin/v2/namespaces/{}/{}/permissions/{}",
+            encode_segment(tenant),
+            encode_segment(namespace),
+            encode_segment(role)
+        )
+    }
+
+    pub fn namespace_publish_rate_path(&self, tenant: &str, namespace: &str) -> String {
+        format!("/admin/v2/namespaces/{}/{}/publishRate", encode_segment(tenant), encode_segment(namespace))
+    }
+
+    pub fn namespace_dispatch_rate_path(&self, tenant: &str, namespace: &str) -> String {
+        format!("/admin/v2/namespaces/{}/{}/dispatchRate", encode_segment(tenant), encode_segment(namespace))
+    }
+
+    pub fn namespace_subscribe_rate_path(&self, tenant: &str, namespace: &str) -> String {
+        format!("/admin/v2/namespaces/{}/{}/subscribeRate", encode_segment(tenant), encode_segment(namespace))
+    }
+
+    pub fn namespace_backlog_quota_path(&self, tenant: &str, namespace: &str) -> String {
+        format!("/admin/v2/namespaces/{}/{}/backlogQuota", encode_segment(tenant), encode_segment(namespace))
+    }
+
+    pub fn namespace_retention_path(&self, tenant: &str, namespace: &str) -> String {
+        format!("/admin/v2/namespaces/{}/{}/retention", encode_segment(tenant), encode_segment(namespace))
+    }
+
+    pub fn topic_publish_rate_path(&self, domain: &str, topic_path: &str) -> String {
+        format!("/admin/v2/{domain}/{}/publishRate", encode_topic_path(topic_path))
+    }
+
+    pub fn topic_dispatch_rate_path(&self, domain: &str, topic_path: &str) -> String {
+        format!("/admin/v2/{domain}/{}/dispatchRate", encode_topic_path(topic_path))
+    }
+
+    pub fn topic_backlog_quota_path(&self, domain: &str, topic_path: &str) -> String {
+        format!("/admin/v2/{domain}/{}/backlogQuota", encode_topic_path(topic_path))
+    }
+
+    pub fn topic_retention_path(&self, domain: &str, topic_path: &str) -> String {
+        format!("/admin/v2/{domain}/{}/retention", encode_topic_path(topic_path))
+    }
+
+    // ---- Response parsing (version-tolerant) ----
+
+    /// Parse the aggregated topic stats payload. Field names are read
+    /// defensively so minor cross-version renames don't break parsing.
+    pub fn parse_topic_stats(&self, raw: &serde_json::Value) -> TopicStats {
+        let f64_of = |key: &str| raw.get(key).and_then(serde_json::Value::as_f64).unwrap_or(0.0);
+        let i64_of = |key: &str| raw.get(key).and_then(serde_json::Value::as_i64).unwrap_or(0);
+
+        // Backlog appears as `backlogSize` (bytes) in newer stats; some payloads
+        // expose `msgBacklog` per subscription only. Read both tolerantly.
+        let backlog_size = raw
+            .get("backlogSize")
+            .and_then(serde_json::Value::as_i64)
+            .or_else(|| raw.get("backlog").and_then(serde_json::Value::as_i64))
+            .unwrap_or(0);
+
+        let subscription_count =
+            raw.get("subscriptions").and_then(serde_json::Value::as_object).map(|m| m.len() as u32).unwrap_or(0);
+
+        let producer_count = raw
+            .get("publishers")
+            .and_then(serde_json::Value::as_array)
+            .map(|a| a.len() as u32)
+            .or_else(|| raw.get("producerCount").and_then(serde_json::Value::as_u64).map(|v| v as u32))
+            .unwrap_or(0);
+
+        TopicStats {
+            msg_rate_in: f64_of("msgRateIn"),
+            msg_rate_out: f64_of("msgRateOut"),
+            msg_throughput_in: f64_of("msgThroughputIn"),
+            msg_throughput_out: f64_of("msgThroughputOut"),
+            storage_size: i64_of("storageSize"),
+            backlog_size,
+            msg_in_counter: i64_of("msgInCounter"),
+            msg_out_counter: i64_of("msgOutCounter"),
+            subscription_count,
+            producer_count,
+            raw: raw.clone(),
+        }
+    }
+
+    /// Parse the `subscriptions` map from a topic stats payload into a typed list.
+    pub fn parse_subscriptions(&self, stats_raw: &serde_json::Value) -> Vec<SubscriptionInfo> {
+        let mut by_name = std::collections::BTreeMap::new();
+        let has_root_subscriptions = append_subscriptions_from_stats(stats_raw, &mut by_name, false);
+
+        if let Some(partitions) = stats_raw.get("partitions").and_then(serde_json::Value::as_object) {
+            for partition in partitions.values() {
+                append_subscriptions_from_stats(partition, &mut by_name, has_root_subscriptions);
+            }
+        }
+
+        by_name.into_values().collect()
+    }
+}
+
+fn append_subscriptions_from_stats(
+    stats_raw: &serde_json::Value,
+    by_name: &mut std::collections::BTreeMap<String, SubscriptionInfo>,
+    keep_existing_metrics: bool,
+) -> bool {
+    let Some(subs) = stats_raw.get("subscriptions").and_then(serde_json::Value::as_object) else {
+        return false;
+    };
+    for (name, body) in subs {
+        merge_subscription(by_name, subscription_from_stats(name, body), keep_existing_metrics);
+    }
+    !subs.is_empty()
+}
+
+fn merge_subscription(
+    by_name: &mut std::collections::BTreeMap<String, SubscriptionInfo>,
+    mut incoming: SubscriptionInfo,
+    keep_existing_metrics: bool,
+) {
+    let Some(existing) = by_name.get_mut(&incoming.name) else {
+        by_name.insert(incoming.name.clone(), incoming);
+        return;
+    };
+
+    if existing.sub_type.is_empty() && !incoming.sub_type.is_empty() {
+        existing.sub_type = incoming.sub_type;
+    }
+    if keep_existing_metrics {
+        existing.msg_backlog = existing.msg_backlog.max(incoming.msg_backlog);
+        existing.msg_rate_out = existing.msg_rate_out.max(incoming.msg_rate_out);
+        existing.msg_throughput_out = existing.msg_throughput_out.max(incoming.msg_throughput_out);
+    } else {
+        existing.msg_backlog = existing.msg_backlog.saturating_add(incoming.msg_backlog);
+        existing.msg_rate_out += incoming.msg_rate_out;
+        existing.msg_throughput_out += incoming.msg_throughput_out;
+    }
+    existing.consumers.append(&mut incoming.consumers);
+}
+
+fn subscription_from_stats(name: &str, body: &serde_json::Value) -> SubscriptionInfo {
+    let consumers = body
+        .get("consumers")
+        .and_then(serde_json::Value::as_array)
+        .map(|arr| arr.iter().map(parse_consumer).collect())
+        .unwrap_or_default();
+    SubscriptionInfo {
+        name: name.to_string(),
+        sub_type: body.get("type").and_then(serde_json::Value::as_str).unwrap_or("").to_string(),
+        msg_backlog: body.get("msgBacklog").and_then(serde_json::Value::as_i64).unwrap_or(0),
+        msg_rate_out: body.get("msgRateOut").and_then(serde_json::Value::as_f64).unwrap_or(0.0),
+        msg_throughput_out: body.get("msgThroughputOut").and_then(serde_json::Value::as_f64).unwrap_or(0.0),
+        consumers,
+    }
+}
+
+fn parse_consumer(v: &serde_json::Value) -> super::super::types::ConsumerInfo {
+    super::super::types::ConsumerInfo {
+        consumer_name: v.get("consumerName").and_then(serde_json::Value::as_str).unwrap_or("").to_string(),
+        msg_rate_out: v.get("msgRateOut").and_then(serde_json::Value::as_f64).unwrap_or(0.0),
+        msg_throughput_out: v.get("msgThroughputOut").and_then(serde_json::Value::as_f64).unwrap_or(0.0),
+        available_permits: v.get("availablePermits").and_then(serde_json::Value::as_i64).unwrap_or(0),
+        address: v.get("address").and_then(serde_json::Value::as_str).unwrap_or("").to_string(),
+        client_version: v.get("clientVersion").and_then(serde_json::Value::as_str).unwrap_or("").to_string(),
+    }
+}
+
+fn encode_segment(segment: &str) -> String {
+    utf8_percent_encode(segment, NON_ALPHANUMERIC).to_string()
+}
+
+fn encode_topic_path(topic_path: &str) -> String {
+    let mut parts = topic_path.splitn(3, '/');
+    let tenant = parts.next();
+    let namespace = parts.next();
+    let topic = parts.next();
+    match (tenant, namespace, topic) {
+        (Some(tenant), Some(namespace), Some(topic)) => {
+            format!("{}/{}/{}", encode_segment(tenant), encode_segment(namespace), encode_segment(topic))
+        }
+        _ => topic_path.split('/').map(encode_segment).collect::<Vec<_>>().join("/"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_plain_version_strings() {
+        assert_eq!(PulsarApiProfile::parse_version("3.1.2"), Some(PulsarVersion::V3_1));
+        assert_eq!(PulsarApiProfile::parse_version("3.0.7"), Some(PulsarVersion::V3_1));
+        assert_eq!(PulsarApiProfile::parse_version("  3.1.0  "), Some(PulsarVersion::V3_1));
+    }
+
+    #[test]
+    fn parses_verbose_version_strings() {
+        assert_eq!(PulsarApiProfile::parse_version("Pulsar version 3.1.2 (rev abc)"), Some(PulsarVersion::V3_1));
+    }
+
+    #[test]
+    fn unknown_major_returns_none() {
+        assert_eq!(PulsarApiProfile::parse_version("4.0.1"), None);
+        assert_eq!(PulsarApiProfile::parse_version("not-a-version"), None);
+    }
+
+    #[test]
+    fn baseline_profile_is_fallback_3_1() {
+        let p = PulsarApiProfile::default_baseline();
+        assert_eq!(p.version(), PulsarVersion::V3_1);
+        assert_eq!(p.detection(), VersionDetection::Fallback);
+        assert!(p.capabilities().supports_tenants);
+        assert!(!p.capabilities().supports_token_management);
+    }
+
+    #[test]
+    fn parses_topic_stats_fields() {
+        let raw = serde_json::json!({
+            "msgRateIn": 12.5,
+            "msgRateOut": 7.0,
+            "storageSize": 4096,
+            "backlogSize": 128,
+            "publishers": [{"producerName": "p1"}],
+            "subscriptions": {
+                "sub-a": {"msgBacklog": 10, "msgRateOut": 1.0, "type": "Shared", "consumers": []},
+                "sub-b": {"msgBacklog": 0, "type": "Exclusive", "consumers": []}
+            }
+        });
+        let profile = PulsarApiProfile::default_baseline();
+        let stats = profile.parse_topic_stats(&raw);
+        assert_eq!(stats.msg_rate_in, 12.5);
+        assert_eq!(stats.storage_size, 4096);
+        assert_eq!(stats.backlog_size, 128);
+        assert_eq!(stats.subscription_count, 2);
+        assert_eq!(stats.producer_count, 1);
+
+        let subs = profile.parse_subscriptions(&raw);
+        assert_eq!(subs.len(), 2);
+    }
+
+    #[test]
+    fn parses_partitioned_stats_subscriptions() {
+        let raw = serde_json::json!({
+            "partitions": {
+                "persistent://public/default/orders-partition-0": {
+                    "subscriptions": {
+                        "sub-a": {
+                            "msgBacklog": 3,
+                            "msgRateOut": 1.5,
+                            "msgThroughputOut": 128.0,
+                            "type": "Shared",
+                            "consumers": [{ "consumerName": "c0", "address": "/127.0.0.1:1000" }]
+                        }
+                    }
+                },
+                "persistent://public/default/orders-partition-1": {
+                    "subscriptions": {
+                        "sub-a": {
+                            "msgBacklog": 5,
+                            "msgRateOut": 2.0,
+                            "msgThroughputOut": 256.0,
+                            "type": "Shared",
+                            "consumers": [{ "consumerName": "c1", "address": "/127.0.0.1:1001" }]
+                        }
+                    }
+                }
+            }
+        });
+        let profile = PulsarApiProfile::default_baseline();
+        let subs = profile.parse_subscriptions(&raw);
+        assert_eq!(subs.len(), 1);
+        assert_eq!(subs[0].name, "sub-a");
+        assert_eq!(subs[0].sub_type, "Shared");
+        assert_eq!(subs[0].msg_backlog, 8);
+        assert_eq!(subs[0].msg_rate_out, 3.5);
+        assert_eq!(subs[0].msg_throughput_out, 384.0);
+        assert_eq!(subs[0].consumers.len(), 2);
+    }
+
+    #[test]
+    fn encodes_each_admin_path_segment() {
+        let profile = PulsarApiProfile::default_baseline();
+        assert_eq!(profile.tenant_path("tenant with/slash?x"), "/admin/v2/tenants/tenant%20with%2Fslash%3Fx");
+        assert_eq!(profile.namespace_path("public", "default space"), "/admin/v2/namespaces/public/default%20space");
+        assert_eq!(
+            profile.topic_base_path("persistent", "public/default/orders/a?b"),
+            "/admin/v2/persistent/public/default/orders%2Fa%3Fb"
+        );
+        assert_eq!(
+            profile.subscription_path("persistent", "public/default/orders/a?b", "sub/role #1"),
+            "/admin/v2/persistent/public/default/orders%2Fa%3Fb/subscription/sub%2Frole%20%231"
+        );
+        assert_eq!(
+            profile.topic_permission_role_path("persistent", "public/default/orders", "role/a?b"),
+            "/admin/v2/persistent/public/default/orders/permissions/role%2Fa%3Fb"
+        );
+    }
+
+    #[test]
+    fn partitioned_stats_path_encodes_topic_and_requests_partition_detail() {
+        let profile = PulsarApiProfile::default_baseline();
+        assert_eq!(
+            profile.topic_partitioned_stats_path("persistent", "b2b/ec-product-service/goods_status_change", true),
+            "/admin/v2/persistent/b2b/ec%2Dproduct%2Dservice/goods%5Fstatus%5Fchange/partitioned-stats?perPartition=true"
+        );
+        assert_eq!(
+            profile.topic_partitioned_stats_path("persistent", "public/default/orders/a?b", true),
+            "/admin/v2/persistent/public/default/orders%2Fa%3Fb/partitioned-stats?perPartition=true"
+        );
+    }
+
+    #[test]
+    fn peek_path_encodes_topic_and_subscription_segments() {
+        let profile = PulsarApiProfile::default_baseline();
+        assert_eq!(
+            profile.subscription_peek_path("persistent", "public/default/orders/a?b", "sub/role #1", 3),
+            "/admin/v2/persistent/public/default/orders%2Fa%3Fb/subscription/sub%2Frole%20%231/position/3"
+        );
+    }
+}
diff --git a/crates/dbx-core/src/mq/auth.rs b/crates/dbx-core/src/mq/auth.rs
new file mode 100644
index 0000000..1240417
--- /dev/null
+++ b/crates/dbx-core/src/mq/auth.rs
@@ -0,0 +1,259 @@
+//! Authentication for message queue admin connections. Injects credentials
+//! into outgoing `reqwest` requests, with token caching for OAuth2
+//! client-credentials so we don't exchange a token on every call.
+
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+use serde::{Deserialize, Serialize};
+use tokio::sync::Mutex;
+
+use super::util::truncate;
+
+/// Authentication method for an MQ admin connection.
+///
+/// Sensitive fields (token / password / secret) are stored through the
+/// project's encrypted connection-secrets / keychain path and are never logged.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "camelCase")]
+pub enum MqAuth {
+    None,
+    /// Pulsar JWT bearer token.
+    Token {
+        token: String,
+    },
+    /// HTTP Basic auth.
+    Basic {
+        username: String,
+        password: String,
+    },
+    /// Arbitrary API key header, e.g. `Authorization: <value>` or a custom header.
+    ApiKey {
+        header: String,
+        value: String,
+    },
+    /// OAuth2 client-credentials flow (Pulsar's `oauth2` auth plugin).
+    OAuth2 {
+        issuer_url: String,
+        client_id: String,
+        client_secret: String,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        audience: Option<String>,
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        scope: Option<String>,
+    },
+}
+
+impl Default for MqAuth {
+    fn default() -> Self {
+        MqAuth::None
+    }
+}
+
+/// Caches an OAuth2 access token with its expiry so repeated requests reuse it.
+/// Also tracks in-flight token requests to prevent concurrent fetches.
+#[derive(Debug, Default, Clone)]
+pub struct TokenCache {
+    inner: Arc<Mutex<TokenCacheState>>,
+}
+
+#[derive(Debug, Default)]
+struct TokenCacheState {
+    cached: Option<CachedToken>,
+    /// Tracks whether a token fetch is currently in progress. Subsequent requests
+    /// will wait on this shared future instead of issuing duplicate OAuth2 requests.
+    #[allow(clippy::type_complexity)]
+    in_flight: Option<Arc<tokio::sync::Notify>>,
+}
+
+#[derive(Debug, Clone)]
+struct CachedToken {
+    token: String,
+    expires_at: Instant,
+}
+
+/// Refresh the cached token slightly before it actually expires.
+const TOKEN_EXPIRY_SKEW: Duration = Duration::from_secs(30);
+
+#[derive(Deserialize)]
+struct OAuth2TokenResponse {
+    access_token: String,
+    #[serde(default)]
+    expires_in: Option<u64>,
+}
+
+impl MqAuth {
+    /// Apply this auth method to a request builder, fetching/refreshing an
+    /// OAuth2 token through `http`/`cache` if necessary.
+    pub async fn apply(
+        &self,
+        req: reqwest::RequestBuilder,
+        http: &reqwest::Client,
+        cache: &TokenCache,
+    ) -> Result<reqwest::RequestBuilder, String> {
+        match self {
+            MqAuth::None => Ok(req),
+            MqAuth::Token { token } => Ok(req.bearer_auth(token)),
+            MqAuth::Basic { username, password } => Ok(req.basic_auth(username, Some(password))),
+            MqAuth::ApiKey { header, value } => Ok(req.header(header.as_str(), value.as_str())),
+            MqAuth::OAuth2 { .. } => {
+                let token = self.fetch_oauth2_token(http, cache).await?;
+                Ok(req.bearer_auth(token))
+            }
+        }
+    }
+
+    async fn fetch_oauth2_token(&self, http: &reqwest::Client, cache: &TokenCache) -> Result<String, String> {
+        let MqAuth::OAuth2 { issuer_url, client_id, client_secret, audience, scope } = self else {
+            return Err("not an OAuth2 auth method".to_string());
+        };
+
+        // Fast path: reuse a still-valid cached token.
+        let notify = {
+            let mut guard = cache.inner.lock().await;
+            if let Some(cached) = &guard.cached {
+                if cached.expires_at > Instant::now() {
+                    return Ok(cached.token.clone());
+                }
+            }
+
+            // Check if another task is already fetching a token
+            if let Some(existing_notify) = &guard.in_flight {
+                let notify = existing_notify.clone();
+                drop(guard);
+                // Wait for the in-flight request to complete
+                notify.notified().await;
+                // Re-check the cache after waiting
+                let guard = cache.inner.lock().await;
+                if let Some(cached) = &guard.cached {
+                    if cached.expires_at > Instant::now() {
+                        return Ok(cached.token.clone());
+                    }
+                }
+                // Token still expired after waiting, we'll fetch ourselves
+                return Err("Token fetch by another task failed or token still expired".to_string());
+            }
+
+            // Mark that we're now fetching
+            let notify = Arc::new(tokio::sync::Notify::new());
+            guard.in_flight = Some(notify.clone());
+            notify
+        };
+
+        // Fetch the token (without holding the lock)
+        let result = self.do_oauth2_token_fetch(http, issuer_url, client_id, client_secret, audience, scope).await;
+
+        // Update cache and clear in-flight flag
+        {
+            let mut guard = cache.inner.lock().await;
+            guard.in_flight = None;
+
+            match result {
+                Ok((token, ttl)) => {
+                    let expires_at = Instant::now() + Duration::from_secs(ttl).saturating_sub(TOKEN_EXPIRY_SKEW);
+                    guard.cached = Some(CachedToken { token: token.clone(), expires_at });
+                    notify.notify_waiters();
+                    Ok(token)
+                }
+                Err(e) => {
+                    notify.notify_waiters();
+                    Err(e)
+                }
+            }
+        }
+    }
+
+    async fn do_oauth2_token_fetch(
+        &self,
+        http: &reqwest::Client,
+        issuer_url: &str,
+        client_id: &str,
+        client_secret: &str,
+        audience: &Option<String>,
+        scope: &Option<String>,
+    ) -> Result<(String, u64), String> {
+        let mut form = vec![
+            ("grant_type", "client_credentials".to_string()),
+            ("client_id", client_id.to_string()),
+            ("client_secret", client_secret.to_string()),
+        ];
+        if let Some(audience) = audience {
+            form.push(("audience", audience.clone()));
+        }
+        if let Some(scope) = scope {
+            form.push(("scope", scope.clone()));
+        }
+
+        let resp =
+            http.post(issuer_url).form(&form).send().await.map_err(|e| format!("OAuth2 token request failed: {e}"))?;
+
+        let status = resp.status();
+        if !status.is_success() {
+            let body = resp.text().await.unwrap_or_default();
+            let detail = oauth2_error_detail(&body).unwrap_or_else(|| truncate(&body, 300));
+            return Err(format!("OAuth2 token endpoint returned {status}: {detail}"));
+        }
+
+        let parsed: OAuth2TokenResponse =
+            resp.json().await.map_err(|e| format!("Failed to parse OAuth2 token response: {e}"))?;
+
+        let ttl = parsed.expires_in.unwrap_or(3600);
+        Ok((parsed.access_token, ttl))
+    }
+}
+
+/// Extract a human-readable OAuth2 error detail from a JSON error response.
+/// Returns `None` when the body is not a valid OAuth2 error payload.
+fn oauth2_error_detail(body: &str) -> Option<String> {
+    let value: serde_json::Value = serde_json::from_str(body).ok()?;
+    let error = value.get("error")?.as_str()?;
+    let description = value.get("error_description").and_then(serde_json::Value::as_str);
+    Some(match description {
+        Some(desc) => format!("{error}: {desc}"),
+        None => error.to_string(),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn auth_default_is_none() {
+        assert!(matches!(MqAuth::default(), MqAuth::None));
+    }
+
+    #[test]
+    fn token_auth_serde_roundtrip() {
+        let auth = MqAuth::Token { token: "abc".to_string() };
+        let json = serde_json::to_string(&auth).expect("should serialize MqAuth");
+        assert!(json.contains("\"kind\":\"token\""));
+        let back: MqAuth = serde_json::from_str(&json).expect("should deserialize MqAuth");
+        assert!(matches!(back, MqAuth::Token { token } if token == "abc"));
+    }
+
+    #[test]
+    fn oauth2_optional_fields_skipped_when_absent() {
+        let auth = MqAuth::OAuth2 {
+            issuer_url: "https://issuer/token".to_string(),
+            client_id: "id".to_string(),
+            client_secret: "secret".to_string(),
+            audience: None,
+            scope: None,
+        };
+        let json = serde_json::to_string(&auth).expect("should serialize OAuth2 auth");
+        assert!(!json.contains("audience"));
+        assert!(!json.contains("scope"));
+    }
+
+    #[test]
+    fn oauth2_error_detail_parses_standard_error() {
+        let body = r#"{"error":"invalid_client","error_description":"Client authentication failed"}"#;
+        assert_eq!(oauth2_error_detail(body).as_deref(), Some("invalid_client: Client authentication failed"));
+    }
+
+    #[test]
+    fn oauth2_error_detail_returns_none_for_non_json() {
+        assert!(oauth2_error_detail("not json").is_none());
+    }
+}
diff --git a/crates/dbx-core/src/mq/config.rs b/crates/dbx-core/src/mq/config.rs
new file mode 100644
index 0000000..fe3ea32
--- /dev/null
+++ b/crates/dbx-core/src/mq/config.rs
@@ -0,0 +1,207 @@
+//! Parses the message queue admin configuration out of a `ConnectionConfig`.
+//!
+//! MQ admin connections reuse the generic `external_config` extension slot on
+//! `ConnectionConfig` rather than adding top-level fields, keeping the 50+
+//! database-type connection model untouched.
+
+use serde::{Deserialize, Serialize};
+
+use crate::models::connection::ConnectionConfig;
+use crate::mq::auth::MqAuth;
+use crate::mq::types::{MqSystemKind, MqTokenSigningConfig};
+
+/// Runtime TCP endpoint override for MQ admin requests.
+///
+/// The public admin URL remains unchanged so TLS hostname verification, SNI and
+/// the HTTP Host header continue to target the broker name. The HTTP client uses
+/// this endpoint only for the underlying TCP connection, e.g. after an SSH/proxy
+/// tunnel has mapped the broker to a local port.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MqConnectOverride {
+    pub host: String,
+    pub port: u16,
+}
+
+/// Configuration for an MQ admin connection, decoded from
+/// `ConnectionConfig.external_config`.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MqAdminConfig {
+    pub system_kind: MqSystemKind,
+    /// Admin REST base URL, e.g. `http://broker:8080`.
+    pub admin_url: String,
+    #[serde(default)]
+    pub auth: MqAuth,
+    /// Skip TLS certificate verification (self-signed clusters only).
+    #[serde(default)]
+    pub tls_skip_verify: bool,
+    /// Manually pin a server version (e.g. `3.1`), skipping auto-detection for
+    /// environments where the version endpoint is blocked by a gateway.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub pinned_version: Option<String>,
+    /// Optional local JWT signing configuration. This is used only by dbx to
+    /// issue Pulsar client tokens; the signing key itself is stored through the
+    /// connection secret path, not in plain connection JSON.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub token_signing: Option<MqTokenSigningConfig>,
+    /// Runtime-only TCP endpoint override used by transport layers.
+    #[serde(skip)]
+    pub connect_override: Option<MqConnectOverride>,
+    /// System-specific extension fields (e.g. Kafka bootstrap servers).
+    #[serde(default, skip_serializing_if = "serde_json::Value::is_null")]
+    pub extra: serde_json::Value,
+}
+
+impl MqAdminConfig {
+    /// Decode the MQ admin config from a connection's `external_config` slot.
+    pub fn from_connection(cfg: &ConnectionConfig) -> Result<Self, String> {
+        let raw = cfg
+            .external_config
+            .as_ref()
+            .ok_or("This connection has no message queue admin configuration (external_config is empty)")?;
+        let mut parsed: MqAdminConfig = serde_json::from_value(raw.clone())
+            .map_err(|e| format!("Failed to parse message queue admin config: {e}"))?;
+        parsed.admin_url = parsed.admin_url.trim().to_string();
+        // Kafka uses bootstrap servers from `extra` instead of an admin URL,
+        // so allow an empty admin_url for Kafka connections.
+        if parsed.admin_url.is_empty() && parsed.system_kind != MqSystemKind::Kafka {
+            return Err("Message queue admin URL is empty".to_string());
+        }
+        Ok(parsed)
+    }
+
+    pub fn token_signing_configured(&self) -> bool {
+        self.token_signing.as_ref().is_some_and(MqTokenSigningConfig::is_configured)
+    }
+
+    pub fn with_admin_endpoint(mut self, host: &str, port: u16) -> Result<Self, String> {
+        self.admin_url = admin_url_with_endpoint(&self.admin_url, host, port)?;
+        Ok(self)
+    }
+
+    pub fn with_connect_override(mut self, host: &str, port: u16) -> Self {
+        self.connect_override = Some(MqConnectOverride { host: host.to_string(), port });
+        self
+    }
+}
+
+pub fn admin_url_with_endpoint(admin_url: &str, host: &str, port: u16) -> Result<String, String> {
+    let mut url = reqwest::Url::parse(admin_url).map_err(|e| format!("MQ Admin URL is invalid: {e}"))?;
+    url.set_host(Some(host)).map_err(|_| format!("MQ Admin URL host is invalid: {host}"))?;
+    url.set_port(Some(port)).map_err(|_| format!("MQ Admin URL port is invalid: {port}"))?;
+    Ok(url.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn connection_with_external(value: serde_json::Value) -> ConnectionConfig {
+        let mut cfg = ConnectionConfig {
+            id: "c1".to_string(),
+            name: "mq".to_string(),
+            db_type: crate::models::connection::DatabaseType::MessageQueue,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: String::new(),
+            port: 0,
+            username: String::new(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: String::new(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: Some(value),
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        };
+        cfg.redis_key_separator = ":".to_string();
+        cfg
+    }
+
+    #[test]
+    fn parses_pulsar_config() {
+        let cfg = connection_with_external(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "http://localhost:8080",
+            "auth": { "kind": "none" }
+        }));
+        let mqc = MqAdminConfig::from_connection(&cfg).expect("should parse valid Pulsar config");
+        assert_eq!(mqc.system_kind, MqSystemKind::Pulsar);
+        assert_eq!(mqc.admin_url, "http://localhost:8080");
+        assert!(matches!(mqc.auth, MqAuth::None));
+    }
+
+    #[test]
+    fn errors_when_external_config_missing() {
+        let mut cfg = connection_with_external(serde_json::Value::Null);
+        cfg.external_config = None;
+        assert!(MqAdminConfig::from_connection(&cfg).is_err());
+    }
+
+    #[test]
+    fn errors_on_empty_admin_url() {
+        let cfg = connection_with_external(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "   "
+        }));
+        assert!(MqAdminConfig::from_connection(&cfg).is_err());
+    }
+
+    #[test]
+    fn parses_kafka_config_with_empty_admin_url() {
+        let cfg = connection_with_external(serde_json::json!({
+            "systemKind": "kafka",
+            "adminUrl": "",
+            "auth": { "kind": "none" },
+            "extra": {
+                "bootstrapServers": "broker1:9092,broker2:9092"
+            }
+        }));
+        let mqc = MqAdminConfig::from_connection(&cfg).expect("should parse valid Kafka config");
+        assert_eq!(mqc.system_kind, MqSystemKind::Kafka);
+        assert_eq!(mqc.admin_url, "");
+        assert_eq!(mqc.extra.get("bootstrapServers").and_then(|v| v.as_str()), Some("broker1:9092,broker2:9092"));
+    }
+
+    #[test]
+    fn admin_url_with_endpoint_preserves_scheme_path_and_query() {
+        let rewritten =
+            admin_url_with_endpoint("https://broker.internal:8443/pulsar-admin?tenant=public", "127.0.0.1", 49152)
+                .expect("should rewrite admin URL with endpoint");
+
+        assert_eq!(rewritten, "https://127.0.0.1:49152/pulsar-admin?tenant=public");
+    }
+}
diff --git a/crates/dbx-core/src/mq/mod.rs b/crates/dbx-core/src/mq/mod.rs
new file mode 100644
index 0000000..e58b438
--- /dev/null
+++ b/crates/dbx-core/src/mq/mod.rs
@@ -0,0 +1,153 @@
+//! Message queue admin console support.
+//!
+//! Provides a pluggable, port-adapter abstraction for managing message queue
+//! systems (Apache Pulsar today; Kafka / RocketMQ are reserved). The module is
+//! gated behind the `mq-admin` Cargo feature so builds that don't need it pay
+//! nothing.
+//!
+//! Architecture mirrors the existing `agent_kv` pattern: business logic lives in
+//! `service::*_core` functions shared by the desktop command layer and the web
+//! route layer; this module owns the trait, the typed model, and the registry
+//! that caches one adapter per connection.
+
+pub mod adapters;
+pub mod auth;
+pub mod config;
+pub mod port;
+pub mod service;
+pub mod token;
+pub mod types;
+pub(crate) mod util;
+
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+use std::sync::Arc;
+
+use tokio::sync::{Mutex, RwLock};
+
+use crate::db::agent_driver::AgentLaunchSpec;
+use crate::models::connection::ConnectionConfig;
+use crate::mq::adapters::kafka::KafkaAdmin;
+use crate::mq::adapters::pulsar::PulsarAdmin;
+use crate::mq::config::MqAdminConfig;
+use crate::mq::port::MessageQueueAdmin;
+use crate::mq::types::MqSystemKind as MqSystemKindInternal;
+
+pub use crate::mq::auth::MqAuth;
+pub use crate::mq::config::MqAdminConfig as MqConfig;
+pub use crate::mq::types::*;
+
+/// Caches one live admin adapter per connection id. Adapters are built lazily on
+/// first use and dropped when the connection is closed.
+///
+/// Each connection has its own build-lock so concurrent first-use requests for
+/// the same connection block until the first builder finishes, rather than both
+/// racing to construct an adapter.
+#[derive(Default)]
+pub struct MqAdminRegistry {
+    instances: RwLock<HashMap<String, CachedMqAdmin>>,
+    build_locks: RwLock<HashMap<String, Arc<Mutex<()>>>>,
+}
+
+struct CachedMqAdmin {
+    fingerprint: u64,
+    adapter: Arc<dyn MessageQueueAdmin>,
+}
+
+impl MqAdminRegistry {
+    pub fn new() -> Self {
+        Self { instances: RwLock::new(HashMap::new()), build_locks: RwLock::new(HashMap::new()) }
+    }
+
+    /// Return the cached adapter for this connection, building it from the
+    /// connection's `external_config` if not already present.
+    pub async fn get_or_build(&self, cfg: &ConnectionConfig) -> Result<Arc<dyn MessageQueueAdmin>, String> {
+        let mqc = MqAdminConfig::from_connection(cfg)?;
+        self.get_or_build_config(&cfg.id, mqc, None).await
+    }
+
+    pub async fn get_or_build_config(
+        &self,
+        connection_id: &str,
+        mqc: MqAdminConfig,
+        kafka_launch: Option<AgentLaunchSpec>,
+    ) -> Result<Arc<dyn MessageQueueAdmin>, String> {
+        let fingerprint = adapter_fingerprint(&mqc, kafka_launch.as_ref());
+
+        // Fast path: return the cached adapter.
+        if let Some(entry) = self.instances.read().await.get(connection_id) {
+            if entry.fingerprint == fingerprint {
+                return Ok(entry.adapter.clone());
+            }
+        }
+
+        // Slow path: acquire a per-connection build lock so only one task
+        // constructs the adapter at a time.
+        let lock = {
+            let mut locks = self.build_locks.write().await;
+            locks.entry(connection_id.to_string()).or_insert_with(|| Arc::new(Mutex::new(()))).clone()
+        };
+        let _guard = lock.lock().await;
+
+        // Another task may have built it while we were waiting for the lock.
+        if let Some(entry) = self.instances.read().await.get(connection_id) {
+            if entry.fingerprint == fingerprint {
+                return Ok(entry.adapter.clone());
+            }
+        }
+
+        let adapter = build_adapter(mqc, kafka_launch).await?;
+        self.instances
+            .write()
+            .await
+            .insert(connection_id.to_string(), CachedMqAdmin { fingerprint, adapter: adapter.clone() });
+        Ok(adapter)
+    }
+
+    /// Drop the cached adapter for a connection (called on disconnect).
+    pub async fn drop_connection(&self, connection_id: &str) {
+        self.instances.write().await.remove(connection_id);
+        self.build_locks.write().await.remove(connection_id);
+    }
+
+    /// Build a fresh adapter without caching it — used for connection tests
+    /// where we don't want to retain state.
+    pub async fn build_transient(&self, cfg: &ConnectionConfig) -> Result<Arc<dyn MessageQueueAdmin>, String> {
+        let mqc = MqAdminConfig::from_connection(cfg)?;
+        self.build_transient_config(mqc, None).await
+    }
+
+    pub async fn build_transient_config(
+        &self,
+        mqc: MqAdminConfig,
+        kafka_launch: Option<AgentLaunchSpec>,
+    ) -> Result<Arc<dyn MessageQueueAdmin>, String> {
+        build_adapter(mqc, kafka_launch).await
+    }
+}
+
+fn adapter_fingerprint(mqc: &MqAdminConfig, kafka_launch: Option<&AgentLaunchSpec>) -> u64 {
+    let mut hasher = std::collections::hash_map::DefaultHasher::new();
+    format!("{mqc:?}").hash(&mut hasher);
+    format!("{kafka_launch:?}").hash(&mut hasher);
+    hasher.finish()
+}
+
+async fn build_adapter(
+    mqc: MqAdminConfig,
+    kafka_launch: Option<AgentLaunchSpec>,
+) -> Result<Arc<dyn MessageQueueAdmin>, String> {
+    match mqc.system_kind {
+        MqSystemKindInternal::Pulsar => {
+            let adapter = PulsarAdmin::new(mqc).await?;
+            Ok(Arc::new(adapter))
+        }
+        MqSystemKindInternal::Kafka => {
+            let launch = kafka_launch
+                .ok_or("Kafka adapter requires an agent launch spec. The Kafka agent driver is not installed or not configured.")?;
+            let adapter = KafkaAdmin::new(mqc, launch).await?;
+            Ok(Arc::new(adapter))
+        }
+        MqSystemKindInternal::RocketMq => Err("RocketMQ admin is not yet implemented".to_string()),
+    }
+}
diff --git a/crates/dbx-core/src/mq/port.rs b/crates/dbx-core/src/mq/port.rs
new file mode 100644
index 0000000..697d193
--- /dev/null
+++ b/crates/dbx-core/src/mq/port.rs
@@ -0,0 +1,96 @@
+//! The message queue admin port — the abstraction all MQ systems implement.
+//!
+//! Commands and routes program against this trait only; concrete systems
+//! (Pulsar today, Kafka / RocketMQ later) live in `adapters/`.
+
+use async_trait::async_trait;
+
+use crate::mq::types::*;
+
+/// Unified management interface for message queue systems.
+#[async_trait]
+pub trait MessageQueueAdmin: Send + Sync {
+    /// Capability flags so the frontend can show/hide functionality.
+    fn capabilities(&self) -> MqCapabilities;
+
+    fn system_kind(&self) -> MqSystemKind;
+
+    /// Connectivity test; returns cluster/version info.
+    async fn test_connection(&self) -> Result<MqClusterInfo, String>;
+
+    // ---- Tenants ----
+    async fn list_tenants(&self) -> Result<Vec<TenantInfo>, String>;
+    async fn get_tenant(&self, name: &str) -> Result<TenantInfo, String>;
+    async fn create_tenant(&self, name: &str, cfg: TenantConfig) -> Result<(), String>;
+    async fn update_tenant(&self, name: &str, cfg: TenantConfig) -> Result<(), String>;
+    async fn delete_tenant(&self, name: &str, force: bool) -> Result<(), String>;
+
+    // ---- Namespaces ----
+    async fn list_namespaces(&self, tenant: &str) -> Result<Vec<NamespaceInfo>, String>;
+    async fn create_namespace(&self, ns: &NamespaceRef, cfg: NamespaceConfig) -> Result<(), String>;
+    async fn delete_namespace(&self, ns: &NamespaceRef, force: bool) -> Result<(), String>;
+    async fn get_namespace_policies(&self, ns: &NamespaceRef) -> Result<serde_json::Value, String>;
+
+    // ---- Topics ----
+    async fn list_topics(&self, ns: &NamespaceRef, opts: ListTopicsOpts) -> Result<Vec<TopicInfo>, String>;
+    async fn create_topic(&self, topic: &TopicRef, partitions: Option<u32>) -> Result<(), String>;
+    async fn delete_topic(&self, topic: &TopicRef, force: bool) -> Result<(), String>;
+    async fn update_partitions(&self, topic: &TopicRef, partitions: u32) -> Result<(), String>;
+    async fn get_topic_stats(&self, topic: &TopicRef) -> Result<TopicStats, String>;
+    async fn get_topic_internal_stats(&self, topic: &TopicRef) -> Result<serde_json::Value, String>;
+
+    // ---- Subscriptions ----
+    async fn list_subscriptions(&self, topic: &TopicRef) -> Result<Vec<SubscriptionInfo>, String>;
+    async fn create_subscription(&self, topic: &TopicRef, sub: &str, pos: ResetPosition) -> Result<(), String>;
+    async fn delete_subscription(&self, topic: &TopicRef, sub: &str, force: bool) -> Result<(), String>;
+    async fn skip_messages(&self, topic: &TopicRef, sub: &str, count: SkipCount) -> Result<(), String>;
+    async fn reset_cursor(&self, topic: &TopicRef, sub: &str, pos: ResetPosition) -> Result<(), String>;
+    async fn clear_backlog(&self, topic: &TopicRef, sub: &str) -> Result<(), String>;
+    async fn peek_messages(
+        &self,
+        topic: &TopicRef,
+        sub: &str,
+        count: u32,
+        options: PeekMessagesOptions,
+    ) -> Result<Vec<PeekedMessage>, String>;
+    async fn expire_messages(&self, topic: &TopicRef, sub: &str, expire_seconds: i64) -> Result<(), String>;
+
+    // ---- Producers / consumers (runtime, read from stats) ----
+    async fn list_producers(&self, topic: &TopicRef) -> Result<Vec<ProducerInfo>, String>;
+    async fn list_consumers(&self, topic: &TopicRef, sub: &str) -> Result<Vec<ConsumerInfo>, String>;
+    /// Unload a topic (Pulsar has no per-connection kill; unload is the closest).
+    async fn unload_topic(&self, topic: &TopicRef) -> Result<(), String>;
+
+    // ---- Rate limits / quotas / retention ----
+    async fn set_publish_rate(&self, scope: &PolicyScope, rate: PublishRate) -> Result<(), String>;
+    async fn set_dispatch_rate(&self, scope: &PolicyScope, rate: DispatchRate) -> Result<(), String>;
+    async fn set_subscribe_rate(&self, scope: &PolicyScope, rate: SubscribeRate) -> Result<(), String>;
+    async fn set_backlog_quota(&self, scope: &PolicyScope, quota: BacklogQuota) -> Result<(), String>;
+    async fn set_retention(&self, scope: &PolicyScope, retention: RetentionPolicy) -> Result<(), String>;
+    async fn get_effective_policies(&self, scope: &PolicyScope) -> Result<serde_json::Value, String>;
+
+    // ---- Permissions (who can produce / consume) ----
+    async fn grant_permission(&self, scope: &PolicyScope, role: &str, actions: Vec<AuthAction>) -> Result<(), String>;
+    async fn revoke_permission(&self, scope: &PolicyScope, role: &str) -> Result<(), String>;
+    async fn list_permissions(&self, scope: &PolicyScope) -> Result<PermissionMap, String>;
+
+    // ---- Monitoring ----
+    async fn get_backlog(&self, topic: &TopicRef, sub: Option<&str>) -> Result<BacklogStats, String>;
+
+    /// Cluster-level info for the Broker monitoring panel.
+    async fn get_cluster_info(&self) -> Result<ClusterInfo, String> {
+        Err("Cluster info is not supported by this MQ system".to_string())
+    }
+
+    /// Escape hatch: proxy an arbitrary admin REST call. Covers any endpoint the
+    /// typed methods do not.
+    async fn raw_request(&self, req: MqRawRequest) -> Result<MqRawResponse, String>;
+
+    // ---- Message production ----
+
+    /// Produce a message to a topic. Adapters that do not support message
+    /// production (e.g. admin-only systems) return an error by default.
+    async fn send_message(&self, _req: SendMessageRequest) -> Result<SendMessageResponse, String> {
+        Err("Message production is not supported by this MQ system".to_string())
+    }
+}
diff --git a/crates/dbx-core/src/mq/service.rs b/crates/dbx-core/src/mq/service.rs
new file mode 100644
index 0000000..98af915
--- /dev/null
+++ b/crates/dbx-core/src/mq/service.rs
@@ -0,0 +1,724 @@
+//! Service-layer functions for message queue admin operations. These `*_core`
+//! functions are shared by both the desktop command layer
+//! (`src-tauri/src/commands/mq_cmd.rs`) and the web route layer
+//! (`crates/dbx-web/src/routes/mq.rs`), keeping the business logic unified.
+//!
+//! Mirrors the pattern used by `agent_kv::*_core`.
+
+use crate::connection::AppState;
+use crate::db::agent_driver::AgentLaunchSpec;
+use crate::mq::config::MqAdminConfig;
+use crate::mq::token::sign_pulsar_token;
+use crate::mq::types::*;
+use chrono::{TimeZone, Utc};
+use uuid::Uuid;
+
+const MAX_PEEK_MESSAGES: u32 = 100;
+
+/// Test connectivity to the message queue admin endpoint. Successful MQ
+/// adapters are cached so agent-backed systems do not cold-start on every
+/// repeated test. Failed builds are not cached by the registry.
+pub async fn mq_test_connection_core(state: &AppState, conn_id: &str) -> Result<MqClusterInfo, String> {
+    let cfg = state.configs.read().await.get(conn_id).cloned().ok_or("Connection not found")?;
+    let mqc = state.mq_admin_config_for_connection(conn_id, &cfg).await?;
+    let kafka_launch = resolve_kafka_launch_spec(&mqc, state);
+    let adapter = match state.mq_registry.get_or_build_config(conn_id, mqc, kafka_launch).await {
+        Ok(adapter) => adapter,
+        Err(err) => {
+            state.mq_registry.drop_connection(conn_id).await;
+            return Err(err);
+        }
+    };
+    match adapter.test_connection().await {
+        Ok(info) => Ok(info),
+        Err(err) => {
+            state.mq_registry.drop_connection(conn_id).await;
+            Err(err)
+        }
+    }
+}
+
+// ---- Tenants ----
+
+pub async fn mq_list_tenants_core(state: &AppState, conn_id: &str) -> Result<Vec<TenantInfo>, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.list_tenants().await
+}
+
+pub async fn mq_get_tenant_core(state: &AppState, conn_id: &str, name: &str) -> Result<TenantInfo, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.get_tenant(name).await
+}
+
+pub async fn mq_create_tenant_core(
+    state: &AppState,
+    conn_id: &str,
+    name: &str,
+    cfg: TenantConfig,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Create tenant").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.create_tenant(name, cfg).await
+}
+
+pub async fn mq_update_tenant_core(
+    state: &AppState,
+    conn_id: &str,
+    name: &str,
+    cfg: TenantConfig,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Update tenant").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.update_tenant(name, cfg).await
+}
+
+pub async fn mq_delete_tenant_core(state: &AppState, conn_id: &str, name: &str, force: bool) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Delete tenant").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.delete_tenant(name, force).await
+}
+
+// ---- Namespaces ----
+
+pub async fn mq_list_namespaces_core(
+    state: &AppState,
+    conn_id: &str,
+    tenant: &str,
+) -> Result<Vec<NamespaceInfo>, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.list_namespaces(tenant).await
+}
+
+pub async fn mq_create_namespace_core(
+    state: &AppState,
+    conn_id: &str,
+    ns: NamespaceRef,
+    cfg: NamespaceConfig,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Create namespace").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.create_namespace(&ns, cfg).await
+}
+
+pub async fn mq_delete_namespace_core(
+    state: &AppState,
+    conn_id: &str,
+    ns: NamespaceRef,
+    force: bool,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Delete namespace").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.delete_namespace(&ns, force).await
+}
+
+pub async fn mq_get_namespace_policies_core(
+    state: &AppState,
+    conn_id: &str,
+    ns: NamespaceRef,
+) -> Result<serde_json::Value, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.get_namespace_policies(&ns).await
+}
+
+// ---- Topics ----
+
+pub async fn mq_list_topics_core(
+    state: &AppState,
+    conn_id: &str,
+    ns: NamespaceRef,
+    opts: ListTopicsOpts,
+) -> Result<Vec<TopicInfo>, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.list_topics(&ns, opts).await
+}
+
+pub async fn mq_create_topic_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+    partitions: Option<u32>,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Create topic").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.create_topic(&topic, partitions).await
+}
+
+pub async fn mq_delete_topic_core(state: &AppState, conn_id: &str, topic: TopicRef, force: bool) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Delete topic").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.delete_topic(&topic, force).await
+}
+
+pub async fn mq_update_partitions_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+    partitions: u32,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Update partitions").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.update_partitions(&topic, partitions).await
+}
+
+pub async fn mq_get_topic_stats_core(state: &AppState, conn_id: &str, topic: TopicRef) -> Result<TopicStats, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.get_topic_stats(&topic).await
+}
+
+pub async fn mq_get_topic_internal_stats_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+) -> Result<serde_json::Value, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.get_topic_internal_stats(&topic).await
+}
+
+// ---- Subscriptions ----
+
+pub async fn mq_list_subscriptions_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+) -> Result<Vec<SubscriptionInfo>, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.list_subscriptions(&topic).await
+}
+
+pub async fn mq_create_subscription_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+    sub: String,
+    pos: ResetPosition,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Create subscription").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.create_subscription(&topic, &sub, pos).await
+}
+
+pub async fn mq_delete_subscription_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+    sub: String,
+    force: bool,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Delete subscription").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.delete_subscription(&topic, &sub, force).await
+}
+
+pub async fn mq_skip_messages_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+    sub: String,
+    count: SkipCount,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Skip messages").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.skip_messages(&topic, &sub, count).await
+}
+
+pub async fn mq_reset_cursor_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+    sub: String,
+    pos: ResetPosition,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Reset cursor").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.reset_cursor(&topic, &sub, pos).await
+}
+
+pub async fn mq_clear_backlog_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+    sub: String,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Clear backlog").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.clear_backlog(&topic, &sub).await
+}
+
+pub async fn mq_peek_messages_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+    sub: String,
+    count: u32,
+    options: Option<PeekMessagesOptions>,
+) -> Result<Vec<PeekedMessage>, String> {
+    if count == 0 {
+        return Ok(Vec::new());
+    }
+    if count > MAX_PEEK_MESSAGES {
+        return Err(format!("Peek message count must be between 1 and {MAX_PEEK_MESSAGES}"));
+    }
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.peek_messages(&topic, &sub, count, options.unwrap_or_default()).await
+}
+
+pub async fn mq_expire_messages_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+    sub: String,
+    expire_seconds: i64,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Expire messages").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.expire_messages(&topic, &sub, expire_seconds).await
+}
+
+// ---- Producers / consumers ----
+
+pub async fn mq_list_producers_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+) -> Result<Vec<ProducerInfo>, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.list_producers(&topic).await
+}
+
+pub async fn mq_list_consumers_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+    sub: String,
+) -> Result<Vec<ConsumerInfo>, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.list_consumers(&topic, &sub).await
+}
+
+pub async fn mq_unload_topic_core(state: &AppState, conn_id: &str, topic: TopicRef) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Unload topic").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.unload_topic(&topic).await
+}
+
+// ---- Rate limits / quotas / retention ----
+
+pub async fn mq_set_publish_rate_core(
+    state: &AppState,
+    conn_id: &str,
+    scope: PolicyScope,
+    rate: PublishRate,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Set publish rate").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.set_publish_rate(&scope, rate).await
+}
+
+pub async fn mq_set_dispatch_rate_core(
+    state: &AppState,
+    conn_id: &str,
+    scope: PolicyScope,
+    rate: DispatchRate,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Set dispatch rate").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.set_dispatch_rate(&scope, rate).await
+}
+
+pub async fn mq_set_subscribe_rate_core(
+    state: &AppState,
+    conn_id: &str,
+    scope: PolicyScope,
+    rate: SubscribeRate,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Set subscribe rate").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.set_subscribe_rate(&scope, rate).await
+}
+
+pub async fn mq_set_backlog_quota_core(
+    state: &AppState,
+    conn_id: &str,
+    scope: PolicyScope,
+    quota: BacklogQuota,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Set backlog quota").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.set_backlog_quota(&scope, quota).await
+}
+
+pub async fn mq_set_retention_core(
+    state: &AppState,
+    conn_id: &str,
+    scope: PolicyScope,
+    retention: RetentionPolicy,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Set retention").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.set_retention(&scope, retention).await
+}
+
+pub async fn mq_get_effective_policies_core(
+    state: &AppState,
+    conn_id: &str,
+    scope: PolicyScope,
+) -> Result<serde_json::Value, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.get_effective_policies(&scope).await
+}
+
+// ---- Permissions ----
+
+pub async fn mq_grant_permission_core(
+    state: &AppState,
+    conn_id: &str,
+    scope: PolicyScope,
+    role: String,
+    actions: Vec<AuthAction>,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Grant permission").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.grant_permission(&scope, &role, actions).await
+}
+
+pub async fn mq_revoke_permission_core(
+    state: &AppState,
+    conn_id: &str,
+    scope: PolicyScope,
+    role: String,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Revoke permission").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.revoke_permission(&scope, &role).await
+}
+
+pub async fn mq_list_permissions_core(
+    state: &AppState,
+    conn_id: &str,
+    scope: PolicyScope,
+) -> Result<PermissionMap, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.list_permissions(&scope).await
+}
+
+// ---- Client tokens ----
+
+pub async fn mq_issue_token_core(
+    state: &AppState,
+    conn_id: &str,
+    req: MqTokenIssueRequest,
+) -> Result<MqIssuedToken, String> {
+    ensure_connection_writable(state, conn_id, "Issue MQ token").await?;
+    let cfg = state.configs.read().await.get(conn_id).cloned().ok_or("Connection not found")?;
+    let mqc = MqAdminConfig::from_connection(&cfg)?;
+    let signing_config = mqc
+        .token_signing
+        .as_ref()
+        .filter(|config| config.is_configured())
+        .ok_or("Token signing is not configured for this MQ connection. Edit the connection and configure Broker Token signing with an HS256 secret or RS256 private key.")?;
+
+    let now = Utc::now();
+    let signed = sign_pulsar_token(signing_config, &req, now.timestamp())?;
+    let expires_at =
+        signed.expires_at_unix.and_then(|value| Utc.timestamp_opt(value, 0).single()).map(|value| value.to_rfc3339());
+    let record = MqTokenRecord {
+        id: Uuid::new_v4().to_string(),
+        connection_id: conn_id.to_string(),
+        subject: req.subject.trim().to_string(),
+        algorithm: signing_config.algorithm,
+        token_fingerprint: signed.fingerprint,
+        scope: req.scope.clone(),
+        actions: req.actions.clone(),
+        expires_at,
+        created_at: now.to_rfc3339(),
+        note: req.note.as_deref().unwrap_or_default().trim().to_string(),
+    };
+
+    state.storage.save_mq_token_record(&record).await?;
+    Ok(MqIssuedToken { token: signed.token, record })
+}
+
+pub async fn mq_list_token_records_core(
+    state: &AppState,
+    conn_id: &str,
+    subject: Option<String>,
+) -> Result<Vec<MqTokenRecord>, String> {
+    if !state.configs.read().await.contains_key(conn_id) {
+        return Err("Connection not found".to_string());
+    }
+    let subject = subject.as_deref().map(str::trim).filter(|value| !value.is_empty());
+    state.storage.load_mq_token_records(conn_id, subject).await
+}
+
+// ---- Monitoring ----
+
+pub async fn mq_get_backlog_core(
+    state: &AppState,
+    conn_id: &str,
+    topic: TopicRef,
+    sub: Option<String>,
+) -> Result<BacklogStats, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.get_backlog(&topic, sub.as_deref()).await
+}
+
+pub async fn mq_get_cluster_info_core(state: &AppState, conn_id: &str) -> Result<ClusterInfo, String> {
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.get_cluster_info().await
+}
+
+// ---- Raw request (escape hatch) ----
+
+pub async fn mq_raw_request_core(state: &AppState, conn_id: &str, req: MqRawRequest) -> Result<MqRawResponse, String> {
+    if req.is_mutating() {
+        ensure_connection_writable(state, conn_id, "MQ admin write").await?;
+    }
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.raw_request(req).await
+}
+
+// ---- Message production ----
+
+/// Produce a message to a topic through the MQ adapter.
+pub async fn mq_send_message_core(
+    state: &AppState,
+    conn_id: &str,
+    req: SendMessageRequest,
+) -> Result<SendMessageResponse, String> {
+    ensure_connection_writable(state, conn_id, "Send message").await?;
+    let adapter = get_adapter(state, conn_id).await?;
+    adapter.send_message(req).await
+}
+
+// ---------------------------------------------------------------------------
+// Helper
+// ---------------------------------------------------------------------------
+
+async fn get_adapter(
+    state: &AppState,
+    conn_id: &str,
+) -> Result<std::sync::Arc<dyn crate::mq::port::MessageQueueAdmin>, String> {
+    let cfg = state.configs.read().await.get(conn_id).cloned().ok_or("Connection not found")?;
+    let mqc = state.mq_admin_config_for_connection(conn_id, &cfg).await?;
+    let kafka_launch = resolve_kafka_launch_spec(&mqc, state);
+    state.mq_registry.get_or_build_config(conn_id, mqc, kafka_launch).await
+}
+
+/// Resolve the Kafka agent launch spec if the config targets Kafka.
+/// Returns `None` for non-Kafka systems so the registry skips agent resolution.
+pub fn resolve_kafka_launch_spec(mqc: &MqAdminConfig, state: &AppState) -> Option<AgentLaunchSpec> {
+    if mqc.system_kind != MqSystemKind::Kafka {
+        return None;
+    }
+    let agent_state = state.agent_manager.load_state();
+    let jre_key = agent_state
+        .installed_drivers
+        .get("kafka")
+        .map(|driver| driver.jre.as_str())
+        .unwrap_or(crate::agent_manager::DEFAULT_JRE_KEY);
+    match state.agent_manager.resolve_agent_launch_spec(&agent_state, "kafka", jre_key) {
+        Ok(launch) => Some(launch),
+        Err(err) => {
+            log::warn!("Failed to resolve Kafka agent launch spec: {err}");
+            None
+        }
+    }
+}
+
+async fn ensure_connection_writable(state: &AppState, conn_id: &str, operation: &str) -> Result<(), String> {
+    let configs = state.configs.read().await;
+    if let Some(config) = configs.get(conn_id) {
+        if config.read_only {
+            return Err(format!(
+                "Read-only mode: connection '{}' has read-only protection enabled. {} blocked.",
+                config.name, operation
+            ));
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::models::connection::{ConnectionConfig, DatabaseType};
+    use crate::storage::Storage;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    fn mq_connection(read_only: bool) -> ConnectionConfig {
+        ConnectionConfig {
+            id: "readonly-mq".to_string(),
+            name: "Read only MQ".to_string(),
+            db_type: DatabaseType::MessageQueue,
+            driver_profile: Some("pulsar".to_string()),
+            driver_label: Some("Apache Pulsar".to_string()),
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 8080,
+            username: String::new(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: ":".to_string(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: Some(serde_json::json!({
+                "systemKind": "pulsar",
+                "adminUrl": "http://127.0.0.1:8080",
+                "auth": { "kind": "none" }
+            })),
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only,
+            is_production: false,
+            production_databases: Vec::new(),
+        }
+    }
+
+    fn mq_connection_with_token_signing() -> ConnectionConfig {
+        let mut config = mq_connection(false);
+        config.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "http://127.0.0.1:8080",
+            "auth": { "kind": "none" },
+            "tokenSigning": {
+                "algorithm": "hs256",
+                "key": "broker-signing-secret"
+            }
+        }));
+        config
+    }
+
+    async fn test_state_with(config: ConnectionConfig) -> (AppState, std::path::PathBuf) {
+        let stamp =
+            SystemTime::now().duration_since(UNIX_EPOCH).expect("system time should be after UNIX epoch").as_nanos();
+        let dir = std::env::temp_dir().join(format!("dbx-mq-service-test-{stamp}"));
+        std::fs::create_dir_all(&dir).expect("failed to create test directory");
+        let storage = Storage::open(&dir.join("storage.db")).await.expect("failed to open test storage");
+        let state = AppState::new_with_plugin_dir(storage, dir.join("plugins"));
+        state.configs.write().await.insert(config.id.clone(), config);
+        (state, dir)
+    }
+
+    #[tokio::test]
+    async fn mutating_service_calls_block_read_only_connections_before_adapter_build() {
+        let (state, dir) = test_state_with(mq_connection(true)).await;
+        let err = mq_create_topic_core(
+            &state,
+            "readonly-mq",
+            TopicRef {
+                tenant: "public".to_string(),
+                namespace: "default".to_string(),
+                topic: "orders".to_string(),
+                persistent: true,
+                partitioned: None,
+            },
+            None,
+        )
+        .await
+        .expect_err("read-only write should fail");
+
+        assert!(err.contains("Read-only mode"));
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn mutating_raw_requests_block_read_only_connections_before_adapter_build() {
+        let (state, dir) = test_state_with(mq_connection(true)).await;
+        let err = mq_raw_request_core(
+            &state,
+            "readonly-mq",
+            MqRawRequest {
+                method: "POST".to_string(),
+                path: "/admin/v2/tenants".to_string(),
+                query: None,
+                body: Some(serde_json::json!({ "adminRoles": [] })),
+            },
+        )
+        .await
+        .expect_err("read-only raw write should fail");
+
+        assert!(err.contains("Read-only mode"));
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn peek_messages_rejects_counts_above_service_limit_before_adapter_call() {
+        let (state, dir) = test_state_with(mq_connection(false)).await;
+        let err = mq_peek_messages_core(
+            &state,
+            "readonly-mq",
+            TopicRef {
+                tenant: "public".to_string(),
+                namespace: "default".to_string(),
+                topic: "orders".to_string(),
+                persistent: true,
+                partitioned: None,
+            },
+            "sub-a".to_string(),
+            101,
+            None,
+        )
+        .await
+        .expect_err("peek count above the service limit should fail");
+
+        assert!(err.contains("between 1 and 100"));
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn issue_token_saves_record_without_plaintext() {
+        let (state, dir) = test_state_with(mq_connection_with_token_signing()).await;
+
+        let issued = mq_issue_token_core(
+            &state,
+            "readonly-mq",
+            MqTokenIssueRequest {
+                subject: "rt-erp-server".to_string(),
+                expires_in_seconds: Some(3600),
+                scope: None,
+                actions: vec![AuthAction::Consume],
+                note: Some("integration test".to_string()),
+            },
+        )
+        .await
+        .expect("token issuance should succeed");
+
+        assert!(!issued.token.is_empty());
+        assert_eq!(issued.record.subject, "rt-erp-server");
+        let records = mq_list_token_records_core(&state, "readonly-mq", Some("rt-erp-server".to_string()))
+            .await
+            .expect("listing token records should succeed");
+        assert_eq!(records.len(), 1);
+        assert_eq!(records[0], issued.record);
+        let record_json = serde_json::to_value(&records[0]).expect("record should serialize to JSON");
+        assert!(record_json.get("token").is_none());
+        let _ = std::fs::remove_dir_all(dir);
+    }
+}
diff --git a/crates/dbx-core/src/mq/token.rs b/crates/dbx-core/src/mq/token.rs
new file mode 100644
index 0000000..c0813f0
--- /dev/null
+++ b/crates/dbx-core/src/mq/token.rs
@@ -0,0 +1,121 @@
+use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
+use jsonwebtoken::{encode, Algorithm, EncodingKey, Header};
+use serde::Serialize;
+use sha2::{Digest, Sha256};
+
+use crate::mq::types::{MqTokenIssueRequest, MqTokenSigningAlgorithm, MqTokenSigningConfig};
+
+#[derive(Debug, Clone)]
+pub struct SignedPulsarToken {
+    pub token: String,
+    pub fingerprint: String,
+    pub expires_at_unix: Option<i64>,
+}
+
+#[derive(Debug, Serialize)]
+struct PulsarTokenClaims<'a> {
+    sub: &'a str,
+    iat: i64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    exp: Option<i64>,
+}
+
+pub fn sign_pulsar_token(
+    config: &MqTokenSigningConfig,
+    req: &MqTokenIssueRequest,
+    now_unix: i64,
+) -> Result<SignedPulsarToken, String> {
+    let subject = req.subject.trim();
+    if subject.is_empty() {
+        return Err("Token subject is required".to_string());
+    }
+
+    // Validate subject format
+    if subject.len() > 256 {
+        return Err("Token subject exceeds maximum length of 256 characters".to_string());
+    }
+
+    // Pulsar typically accepts alphanumeric characters plus common separators
+    // Allow: letters, digits, hyphen, underscore, dot, @
+    if !subject.chars().all(|c| c.is_alphanumeric() || matches!(c, '-' | '_' | '.' | '@')) {
+        return Err(format!(
+            "Token subject contains invalid characters. Only alphanumeric, '-', '_', '.', and '@' are allowed. Got: {}",
+            subject
+        ));
+    }
+
+    let key = config.key.trim();
+    if key.is_empty() {
+        return Err("Token signing key is required".to_string());
+    }
+
+    let expires_at_unix = match req.expires_in_seconds {
+        Some(seconds) if seconds <= 0 => return Err("Token expiry must be greater than zero seconds".to_string()),
+        Some(seconds) => Some(now_unix.saturating_add(seconds)),
+        None => None,
+    };
+    let claims = PulsarTokenClaims { sub: subject, iat: now_unix, exp: expires_at_unix };
+    let algorithm = jwt_algorithm(config.algorithm);
+    let header = Header::new(algorithm);
+    let encoding_key = encoding_key(config.algorithm, key)?;
+    let token = encode(&header, &claims, &encoding_key).map_err(|err| format!("Failed to sign Pulsar token: {err}"))?;
+    let fingerprint = token_fingerprint(&token);
+
+    Ok(SignedPulsarToken { token, fingerprint, expires_at_unix })
+}
+
+pub fn token_fingerprint(token: &str) -> String {
+    let digest = Sha256::digest(token.as_bytes());
+    format!("sha256:{}", hex_lower(&digest))
+}
+
+fn jwt_algorithm(algorithm: MqTokenSigningAlgorithm) -> Algorithm {
+    match algorithm {
+        MqTokenSigningAlgorithm::Hs256 => Algorithm::HS256,
+        MqTokenSigningAlgorithm::Rs256 => Algorithm::RS256,
+    }
+}
+
+fn encoding_key(algorithm: MqTokenSigningAlgorithm, key: &str) -> Result<EncodingKey, String> {
+    match algorithm {
+        MqTokenSigningAlgorithm::Hs256 => Ok(EncodingKey::from_secret(key.as_bytes())),
+        MqTokenSigningAlgorithm::Rs256 => {
+            let normalized = normalize_rsa_key_material(key)?;
+            EncodingKey::from_rsa_pem(normalized.as_bytes()).map_err(|err| format!("Invalid RS256 private key: {err}"))
+        }
+    }
+}
+
+fn normalize_rsa_key_material(key: &str) -> Result<String, String> {
+    // If already in PEM format, return as-is
+    if key.contains("-----BEGIN") {
+        return Ok(key.to_string());
+    }
+
+    // Try to decode as base64
+    match BASE64.decode(key.as_bytes()) {
+        Ok(bytes) => String::from_utf8(bytes).map_err(|e| {
+            format!(
+                "RSA key appears to be base64-encoded but decodes to invalid UTF-8: {}. \
+                 Please provide the key in PEM format (with -----BEGIN/END headers) or as valid base64.",
+                e
+            )
+        }),
+        Err(e) => Err(format!(
+            "RSA key is not in PEM format and failed to decode as base64: {}. \
+             Please provide the key in PEM format (with -----BEGIN RSA PRIVATE KEY----- headers) \
+             or as valid base64-encoded data.",
+            e
+        )),
+    }
+}
+
+fn hex_lower(bytes: &[u8]) -> String {
+    const HEX: &[u8; 16] = b"0123456789abcdef";
+    let mut out = String::with_capacity(bytes.len() * 2);
+    for byte in bytes {
+        out.push(HEX[(byte >> 4) as usize] as char);
+        out.push(HEX[(byte & 0x0f) as usize] as char);
+    }
+    out
+}
diff --git a/crates/dbx-core/src/mq/types.rs b/crates/dbx-core/src/mq/types.rs
new file mode 100644
index 0000000..a504ad9
--- /dev/null
+++ b/crates/dbx-core/src/mq/types.rs
@@ -0,0 +1,647 @@
+//! Shared resource, statistics, and configuration types for the message queue
+//! admin console. All types are `serde`-serializable in `camelCase` so they map
+//! 1:1 to the frontend TypeScript definitions in `apps/desktop/src/types/mq.ts`.
+
+use std::collections::HashMap;
+
+use serde::{Deserialize, Serialize};
+
+/// Which message queue system an admin connection targets.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum MqSystemKind {
+    Pulsar,
+    Kafka,
+    #[serde(rename = "rocketmq")]
+    RocketMq,
+}
+
+impl MqSystemKind {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            MqSystemKind::Pulsar => "pulsar",
+            MqSystemKind::Kafka => "kafka",
+            MqSystemKind::RocketMq => "rocketmq",
+        }
+    }
+}
+
+/// Capability flags. The frontend reads these to show/hide functionality, and
+/// the adapter computes them from the detected server version so unsupported
+/// features are hidden rather than failing at call time.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MqCapabilities {
+    pub supports_tenants: bool,
+    pub supports_namespaces: bool,
+    pub supports_partitioned_topics: bool,
+    pub supports_subscriptions: bool,
+    pub supports_create_subscription: bool,
+    pub supports_reset_cursor: bool,
+    pub supports_skip_messages: bool,
+    pub supports_clear_backlog: bool,
+    pub supports_peek_messages: bool,
+    pub supports_expire_messages: bool,
+    pub supports_rate_limits: bool,
+    pub supports_backlog_quota: bool,
+    pub supports_retention: bool,
+    pub supports_permissions: bool,
+    pub supports_geo_replication: bool,
+    pub supports_token_management: bool,
+    pub supports_raw_admin_api: bool,
+    /// Whether the adapter supports producing messages to topics.
+    #[serde(default)]
+    pub supports_send_message: bool,
+}
+
+impl Default for MqCapabilities {
+    fn default() -> Self {
+        Self {
+            supports_tenants: false,
+            supports_namespaces: false,
+            supports_partitioned_topics: false,
+            supports_subscriptions: false,
+            supports_create_subscription: false,
+            supports_reset_cursor: false,
+            supports_skip_messages: false,
+            supports_clear_backlog: false,
+            supports_peek_messages: false,
+            supports_expire_messages: false,
+            supports_rate_limits: false,
+            supports_backlog_quota: false,
+            supports_retention: false,
+            supports_permissions: false,
+            supports_geo_replication: false,
+            supports_token_management: false,
+            supports_raw_admin_api: false,
+            supports_send_message: false,
+        }
+    }
+}
+
+/// Result of a connectivity test, including the detected server version and how
+/// it was determined (probe vs. fallback) so the UI can warn appropriately.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MqClusterInfo {
+    pub system_kind: MqSystemKind,
+    /// Raw version string reported by the broker (e.g. `3.1.2`), if available.
+    pub server_version: Option<String>,
+    /// Version profile the adapter resolved to (e.g. `3.1.x`).
+    pub resolved_profile: String,
+    /// How the version was determined: `probed` | `pinned` | `fallback`.
+    pub version_detection: String,
+    pub capabilities: MqCapabilities,
+    /// Optional free-form extra fields (cluster list, broker count, ...).
+    #[serde(default, skip_serializing_if = "serde_json::Value::is_null")]
+    pub extra: serde_json::Value,
+}
+
+// ---------------------------------------------------------------------------
+// Token signing
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum MqTokenSigningAlgorithm {
+    Hs256,
+    Rs256,
+}
+
+impl MqTokenSigningAlgorithm {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Hs256 => "hs256",
+            Self::Rs256 => "rs256",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MqTokenSigningConfig {
+    pub algorithm: MqTokenSigningAlgorithm,
+    #[serde(default)]
+    pub key: String,
+}
+
+impl MqTokenSigningConfig {
+    pub fn is_configured(&self) -> bool {
+        !self.key.trim().is_empty()
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MqTokenIssueRequest {
+    pub subject: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_in_seconds: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub scope: Option<PolicyScope>,
+    #[serde(default)]
+    pub actions: Vec<AuthAction>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub note: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MqTokenRecord {
+    pub id: String,
+    pub connection_id: String,
+    pub subject: String,
+    pub algorithm: MqTokenSigningAlgorithm,
+    pub token_fingerprint: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub scope: Option<PolicyScope>,
+    #[serde(default)]
+    pub actions: Vec<AuthAction>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub expires_at: Option<String>,
+    pub created_at: String,
+    #[serde(default)]
+    pub note: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MqIssuedToken {
+    pub token: String,
+    pub record: MqTokenRecord,
+}
+
+// ---------------------------------------------------------------------------
+// Tenant
+// ---------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TenantInfo {
+    pub name: String,
+    #[serde(default)]
+    pub admin_roles: Vec<String>,
+    #[serde(default)]
+    pub allowed_clusters: Vec<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TenantConfig {
+    #[serde(default)]
+    pub admin_roles: Vec<String>,
+    #[serde(default)]
+    pub allowed_clusters: Vec<String>,
+}
+
+// ---------------------------------------------------------------------------
+// Namespace
+// ---------------------------------------------------------------------------
+
+/// A fully-qualified namespace reference (`tenant/namespace`).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NamespaceRef {
+    pub tenant: String,
+    pub namespace: String,
+}
+
+impl NamespaceRef {
+    /// `tenant/namespace`
+    pub fn path(&self) -> String {
+        format!("{}/{}", self.tenant, self.namespace)
+    }
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NamespaceInfo {
+    pub tenant: String,
+    pub namespace: String,
+    #[serde(default)]
+    pub admin_roles: Vec<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NamespaceConfig {
+    /// Replication clusters to bootstrap the namespace with. Pulsar requires at
+    /// least one when the cluster runs with geo-replication.
+    #[serde(default)]
+    pub clusters: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub bundles: Option<u32>,
+}
+
+// ---------------------------------------------------------------------------
+// Topic
+// ---------------------------------------------------------------------------
+
+/// A fully-qualified topic reference.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TopicRef {
+    pub tenant: String,
+    pub namespace: String,
+    pub topic: String,
+    /// Whether the topic is persistent (`persistent://`) or not
+    /// (`non-persistent://`). Defaults to persistent.
+    #[serde(default = "default_true")]
+    pub persistent: bool,
+    /// Optional UI hint used to prefer partitioned stats when the topic came
+    /// from the partitioned topic list.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub partitioned: Option<bool>,
+}
+
+fn default_true() -> bool {
+    true
+}
+
+impl TopicRef {
+    /// The URL domain segment: `persistent` or `non-persistent`.
+    pub fn domain(&self) -> &'static str {
+        if self.persistent {
+            "persistent"
+        } else {
+            "non-persistent"
+        }
+    }
+
+    /// `{tenant}/{namespace}/{topic}` — the path used by most Pulsar endpoints.
+    pub fn path(&self) -> String {
+        format!("{}/{}/{}", self.tenant, self.namespace, self.topic)
+    }
+
+    /// Full topic name, e.g. `persistent://public/default/orders`.
+    pub fn full_name(&self) -> String {
+        format!("{}://{}", self.domain(), self.path())
+    }
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TopicInfo {
+    /// Full topic name, e.g. `persistent://public/default/orders`.
+    pub name: String,
+    /// Short topic name without the namespace prefix.
+    pub short_name: String,
+    pub partitioned: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub partitions: Option<u32>,
+    pub persistent: bool,
+}
+
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ListTopicsOpts {
+    /// Include non-persistent topics in the listing.
+    #[serde(default)]
+    pub include_non_persistent: bool,
+}
+
+/// Aggregated, UI-friendly topic statistics. Parsed from the version-specific
+/// raw stats payload by the adapter's version profile.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TopicStats {
+    pub msg_rate_in: f64,
+    pub msg_rate_out: f64,
+    pub msg_throughput_in: f64,
+    pub msg_throughput_out: f64,
+    pub storage_size: i64,
+    pub backlog_size: i64,
+    pub msg_in_counter: i64,
+    pub msg_out_counter: i64,
+    pub subscription_count: u32,
+    pub producer_count: u32,
+    /// Original raw stats JSON, for the detail view / advanced inspection.
+    #[serde(default, skip_serializing_if = "serde_json::Value::is_null")]
+    pub raw: serde_json::Value,
+}
+
+// ---------------------------------------------------------------------------
+// Subscription / consumers / producers
+// ---------------------------------------------------------------------------
+
+/// Cluster-level information for the Broker monitoring panel.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClusterInfo {
+    pub cluster_id: Option<String>,
+    pub broker_count: u32,
+    pub controller_id: Option<i32>,
+    pub controller_host: Option<String>,
+    pub brokers: Vec<BrokerNode>,
+    /// Free-form extra fields from the adapter.
+    #[serde(default, skip_serializing_if = "serde_json::Value::is_null")]
+    pub raw: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BrokerNode {
+    pub id: i32,
+    pub host: String,
+    pub port: i32,
+    pub rack: Option<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SubscriptionInfo {
+    pub name: String,
+    #[serde(default)]
+    pub sub_type: String,
+    pub msg_backlog: i64,
+    pub msg_rate_out: f64,
+    pub msg_throughput_out: f64,
+    #[serde(default)]
+    pub consumers: Vec<ConsumerInfo>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ConsumerInfo {
+    pub consumer_name: String,
+    pub msg_rate_out: f64,
+    pub msg_throughput_out: f64,
+    pub available_permits: i64,
+    #[serde(default)]
+    pub address: String,
+    #[serde(default)]
+    pub client_version: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProducerInfo {
+    pub producer_id: i64,
+    pub producer_name: String,
+    pub msg_rate_in: f64,
+    pub msg_throughput_in: f64,
+    #[serde(default)]
+    pub address: String,
+    #[serde(default)]
+    pub client_version: String,
+}
+
+/// Where to position a cursor when creating a subscription or resetting it.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "camelCase")]
+pub enum ResetPosition {
+    /// Earliest available message.
+    Earliest,
+    /// Latest message (skip the existing backlog).
+    Latest,
+    /// A specific point in time (milliseconds since epoch).
+    Timestamp { timestamp_ms: i64 },
+    /// A specific message id.
+    MessageId { ledger_id: i64, entry_id: i64 },
+}
+
+/// How many messages to skip on a subscription.
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+#[serde(tag = "kind", rename_all = "camelCase")]
+pub enum SkipCount {
+    All,
+    Count { count: u32 },
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BacklogStats {
+    pub msg_backlog: i64,
+    pub backlog_size: i64,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PeekedMessage {
+    /// 1-based subscription position passed to the Pulsar Admin API.
+    pub position: u32,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub message_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub publish_time: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub event_time: Option<String>,
+    #[serde(default)]
+    pub properties: HashMap<String, String>,
+    #[serde(default)]
+    pub headers: HashMap<String, String>,
+    /// Message payload encoded as base64 so binary messages are preserved.
+    pub payload_base64: String,
+    /// UTF-8 preview when the payload can be decoded losslessly.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub payload_text: Option<String>,
+}
+
+/// Optional hints for reading messages. Pulsar ignores these today; Kafka uses
+/// them to select a partition and starting offset for a non-committing peek.
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PeekMessagesOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub partition: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offset: Option<i64>,
+}
+
+// ---------------------------------------------------------------------------
+// Policy scope (rate limits / quotas / permissions)
+// ---------------------------------------------------------------------------
+
+/// Whether a policy applies at the namespace or topic level. Lets the rate
+/// limit / quota / permission methods avoid duplicating namespace vs. topic
+/// variants.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "level", rename_all = "camelCase")]
+pub enum PolicyScope {
+    Namespace { tenant: String, namespace: String },
+    Topic { tenant: String, namespace: String, topic: String, persistent: bool },
+}
+
+impl PolicyScope {
+    pub fn as_namespace_ref(&self) -> Option<NamespaceRef> {
+        match self {
+            PolicyScope::Namespace { tenant, namespace } => {
+                Some(NamespaceRef { tenant: tenant.clone(), namespace: namespace.clone() })
+            }
+            _ => None,
+        }
+    }
+
+    pub fn as_topic_ref(&self) -> Option<TopicRef> {
+        match self {
+            PolicyScope::Topic { tenant, namespace, topic, persistent } => Some(TopicRef {
+                tenant: tenant.clone(),
+                namespace: namespace.clone(),
+                topic: topic.clone(),
+                persistent: *persistent,
+                partitioned: None,
+            }),
+            _ => None,
+        }
+    }
+
+    pub fn is_topic(&self) -> bool {
+        matches!(self, PolicyScope::Topic { .. })
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PublishRate {
+    pub publish_throttling_rate_in_msg: i32,
+    pub publish_throttling_rate_in_byte: i64,
+}
+
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DispatchRate {
+    pub dispatch_throttling_rate_in_msg: i32,
+    pub dispatch_throttling_rate_in_byte: i64,
+    #[serde(default = "default_rate_period")]
+    pub rate_period_in_second: i32,
+}
+
+fn default_rate_period() -> i32 {
+    1
+}
+
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SubscribeRate {
+    pub subscribe_throttling_rate_per_consumer: i32,
+    #[serde(default = "default_rate_period")]
+    pub rate_period_in_second: i32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BacklogQuota {
+    /// Limit in bytes. `-1` means no size limit.
+    pub limit_size: i64,
+    /// Limit in seconds. `-1` means no time limit.
+    #[serde(default)]
+    pub limit_time: i32,
+    /// `producer_request_hold` | `producer_exception` | `consumer_backlog_eviction`.
+    pub policy: String,
+    /// `destination_storage` (size) or `message_age` (time).
+    #[serde(default = "default_backlog_quota_type")]
+    pub quota_type: String,
+}
+
+fn default_backlog_quota_type() -> String {
+    "destination_storage".to_string()
+}
+
+#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RetentionPolicy {
+    /// Retention time in minutes. `-1` = infinite.
+    pub retention_time_in_minutes: i32,
+    /// Retention size in MB. `-1` = infinite.
+    pub retention_size_in_mb: i32,
+}
+
+/// Authorization actions that can be granted to a role on a namespace/topic.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum AuthAction {
+    Produce,
+    Consume,
+    Functions,
+    Sources,
+    Sinks,
+    #[serde(rename = "packages")]
+    Packages,
+}
+
+pub type PermissionMap = HashMap<String, Vec<AuthAction>>;
+
+// ---------------------------------------------------------------------------
+// Raw request (escape hatch)
+// ---------------------------------------------------------------------------
+
+/// A raw admin REST request, proxied through the adapter to cover any endpoint
+/// the typed methods do not. The path is appended to the connection's
+/// `admin_url` base — arbitrary hosts are not allowed (SSRF guard).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MqRawRequest {
+    /// HTTP method: GET / PUT / POST / DELETE.
+    pub method: String,
+    /// Path relative to the admin base, e.g. `/admin/v2/tenants`.
+    pub path: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub query: Option<HashMap<String, String>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub body: Option<serde_json::Value>,
+}
+
+impl MqRawRequest {
+    /// Whether this request mutates server state and therefore must pass the
+    /// read-only protection check.
+    pub fn is_mutating(&self) -> bool {
+        !matches!(self.method.to_ascii_uppercase().as_str(), "GET" | "HEAD" | "OPTIONS")
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MqRawResponse {
+    pub status: u16,
+    pub body: serde_json::Value,
+    /// Set when the response body was not valid JSON; carries the raw text.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub text: Option<String>,
+}
+
+// ---------------------------------------------------------------------------
+// Send message (produce)
+// ---------------------------------------------------------------------------
+
+/// Request to produce a message to a topic.
+///
+/// The payload is always base64-encoded so binary messages are preserved.
+/// An optional `payload_text` field provides a UTF-8 preview for the UI.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SendMessageRequest {
+    /// Target topic name.
+    pub topic: String,
+    /// Optional message key (used for partitioning in Kafka).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub key: Option<String>,
+    /// Message payload encoded as base64.
+    pub payload_base64: String,
+    /// Optional UTF-8 text preview of the payload.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub payload_text: Option<String>,
+    /// Optional message headers.
+    #[serde(default)]
+    pub headers: HashMap<String, String>,
+    /// Optional target partition (Kafka). When `None`, the key-based partitioner
+    /// is used.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub partition: Option<i32>,
+}
+
+/// Result of a successful message production.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SendMessageResponse {
+    /// Topic the message was written to.
+    pub topic: String,
+    /// Partition the message was written to.
+    pub partition: i32,
+    /// Offset of the produced message.
+    pub offset: i64,
+    /// Broker-assigned timestamp, if available.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timestamp: Option<String>,
+}
diff --git a/crates/dbx-core/src/mq/util.rs b/crates/dbx-core/src/mq/util.rs
new file mode 100644
index 0000000..0620c77
--- /dev/null
+++ b/crates/dbx-core/src/mq/util.rs
@@ -0,0 +1,39 @@
+//! Shared utilities for the message queue admin module.
+
+/// Truncate a string to `max` bytes, respecting UTF-8 char boundaries, and
+/// append an ellipsis when truncation occurs.
+pub(crate) fn truncate(s: &str, max: usize) -> String {
+    if s.len() <= max {
+        s.to_string()
+    } else {
+        let mut end = max;
+        while !s.is_char_boundary(end) {
+            end -= 1;
+        }
+        format!("{}…", &s[..end])
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn truncate_short_string_unchanged() {
+        assert_eq!(truncate("hello", 10), "hello");
+    }
+
+    #[test]
+    fn truncate_long_string_adds_ellipsis() {
+        let result = truncate("abcdefghij", 5);
+        assert_eq!(result, "abcde…");
+    }
+
+    #[test]
+    fn truncate_handles_multibyte_utf8_boundary() {
+        let body = format!("a{}", "错".repeat(100));
+        let truncated = truncate(&body, 10);
+        assert!(truncated.ends_with('…'));
+        assert!(truncated.len() <= 10 + "…".len());
+    }
+}
diff --git a/crates/dbx-core/src/nacos/config.rs b/crates/dbx-core/src/nacos/config.rs
new file mode 100644
index 0000000..bec2a90
--- /dev/null
+++ b/crates/dbx-core/src/nacos/config.rs
@@ -0,0 +1,232 @@
+use serde::{Deserialize, Serialize};
+
+use crate::models::connection::ConnectionConfig;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(tag = "kind", rename_all = "camelCase")]
+pub enum NacosAuthConfig {
+    None,
+    UsernamePassword { username: String, password: String },
+}
+
+impl Default for NacosAuthConfig {
+    fn default() -> Self {
+        Self::None
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosAdminConfig {
+    pub server_addr: String,
+    #[serde(default, skip_serializing_if = "String::is_empty")]
+    pub display_server_addr: String,
+    #[serde(default)]
+    pub namespace: String,
+    #[serde(default)]
+    pub context_path: String,
+    #[serde(default)]
+    pub auth: NacosAuthConfig,
+    #[serde(default)]
+    pub tls_skip_verify: bool,
+    #[serde(default = "default_page_size")]
+    pub page_size: u32,
+    #[serde(skip)]
+    pub connect_override: Option<NacosConnectOverride>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConnectOverride {
+    pub host: String,
+    pub port: u16,
+}
+
+pub fn default_page_size() -> u32 {
+    20
+}
+
+impl NacosAdminConfig {
+    pub fn from_connection(cfg: &ConnectionConfig) -> Result<Self, String> {
+        let parsed = if let Some(raw) = cfg.external_config.as_ref() {
+            serde_json::from_value::<NacosAdminConfig>(raw.clone())
+                .map_err(|e| format!("Failed to parse Nacos admin config: {e}"))?
+        } else {
+            let scheme = if cfg.ssl { "https" } else { "http" };
+            NacosAdminConfig {
+                server_addr: format!("{scheme}://{}:{}", cfg.host.trim(), cfg.port),
+                display_server_addr: String::new(),
+                namespace: cfg.database.clone().unwrap_or_default(),
+                context_path: String::new(),
+                auth: if cfg.username.trim().is_empty() {
+                    NacosAuthConfig::None
+                } else {
+                    NacosAuthConfig::UsernamePassword { username: cfg.username.clone(), password: cfg.password.clone() }
+                },
+                tls_skip_verify: false,
+                page_size: default_page_size(),
+                connect_override: None,
+            }
+        };
+        parsed.validate()
+    }
+
+    pub fn validate(mut self) -> Result<Self, String> {
+        self.server_addr = self.server_addr.trim().trim_end_matches('/').to_string();
+        if self.server_addr.is_empty() {
+            return Err("Nacos server address is empty".to_string());
+        }
+        if self.display_server_addr.trim().is_empty() {
+            self.display_server_addr = self.server_addr.clone();
+        } else {
+            self.display_server_addr = self.display_server_addr.trim().trim_end_matches('/').to_string();
+        }
+        self.context_path = normalize_context_path(&self.context_path);
+        if self.page_size == 0 {
+            self.page_size = default_page_size();
+        }
+        self.page_size = self.page_size.clamp(1, 500);
+        Ok(self)
+    }
+
+    pub fn with_connect_override(mut self, host: &str, port: u16) -> Self {
+        self.connect_override = Some(NacosConnectOverride { host: host.to_string(), port });
+        self
+    }
+
+    pub fn with_server_endpoint(mut self, host: &str, port: u16) -> Result<Self, String> {
+        let mut url =
+            reqwest::Url::parse(&self.server_addr).map_err(|e| format!("Nacos server address is invalid: {e}"))?;
+        url.set_host(Some(host)).map_err(|_| format!("Nacos server address host is invalid: {host}"))?;
+        url.set_port(Some(port)).map_err(|_| format!("Nacos server address port is invalid: {port}"))?;
+        self.server_addr = url.to_string().trim_end_matches('/').to_string();
+        self.connect_override = None;
+        Ok(self)
+    }
+}
+
+pub fn normalize_context_path(path: &str) -> String {
+    let trimmed = path.trim().trim_end_matches('/');
+    if trimmed.is_empty() {
+        return String::new();
+    }
+    if trimmed.starts_with('/') {
+        trimmed.to_string()
+    } else {
+        format!("/{trimmed}")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::models::connection::{default_keepalive_interval_secs, DatabaseType};
+
+    fn connection_with_external(value: serde_json::Value) -> ConnectionConfig {
+        ConnectionConfig {
+            id: "nacos-1".to_string(),
+            name: "Nacos".to_string(),
+            db_type: DatabaseType::Nacos,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 8848,
+            username: String::new(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: ":".to_string(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: Some(value),
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    #[test]
+    fn parses_external_config() {
+        let cfg = connection_with_external(serde_json::json!({
+            "serverAddr": " http://127.0.0.1:8848/ ",
+            "namespace": "public",
+            "contextPath": "nacos",
+            "pageSize": 100,
+            "auth": { "kind": "usernamePassword", "username": "nacos", "password": "pw" }
+        }));
+
+        let parsed = NacosAdminConfig::from_connection(&cfg).unwrap();
+        assert_eq!(parsed.server_addr, "http://127.0.0.1:8848");
+        assert_eq!(parsed.context_path, "/nacos");
+        assert_eq!(parsed.page_size, 100);
+        assert_eq!(parsed.namespace, "public");
+    }
+
+    #[test]
+    fn missing_external_context_path_defaults_to_root() {
+        let cfg = connection_with_external(serde_json::json!({
+            "serverAddr": "http://127.0.0.1:8848",
+            "auth": { "kind": "none" }
+        }));
+
+        let parsed = NacosAdminConfig::from_connection(&cfg).unwrap();
+        assert_eq!(parsed.context_path, "");
+    }
+
+    #[test]
+    fn falls_back_to_connection_fields() {
+        let mut cfg = connection_with_external(serde_json::Value::Null);
+        cfg.external_config = None;
+        cfg.username = "nacos".to_string();
+        cfg.password = "pw".to_string();
+        let parsed = NacosAdminConfig::from_connection(&cfg).unwrap();
+        assert_eq!(parsed.server_addr, "http://127.0.0.1:8848");
+        assert_eq!(parsed.context_path, "");
+        assert!(matches!(parsed.auth, NacosAuthConfig::UsernamePassword { .. }));
+    }
+
+    #[test]
+    fn with_server_endpoint_rewrites_only_host_and_port() {
+        let cfg = connection_with_external(serde_json::json!({
+            "serverAddr": "https://192.168.2.51:10840/nacos",
+            "namespace": "public",
+            "contextPath": "/console",
+            "auth": { "kind": "none" }
+        }));
+
+        let parsed = NacosAdminConfig::from_connection(&cfg).unwrap().with_server_endpoint("127.0.0.1", 49152).unwrap();
+
+        assert_eq!(parsed.server_addr, "https://127.0.0.1:49152/nacos");
+        assert_eq!(parsed.context_path, "/console");
+        assert!(parsed.connect_override.is_none());
+    }
+}
diff --git a/crates/dbx-core/src/nacos/http.rs b/crates/dbx-core/src/nacos/http.rs
new file mode 100644
index 0000000..3069272
--- /dev/null
+++ b/crates/dbx-core/src/nacos/http.rs
@@ -0,0 +1,1776 @@
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+use async_trait::async_trait;
+use reqwest::header::{HeaderMap, HeaderValue};
+use serde_json::Value;
+use tokio::sync::Mutex;
+
+use crate::nacos::config::{NacosAdminConfig, NacosAuthConfig};
+use crate::nacos::port::NacosAdmin;
+use crate::nacos::types::*;
+
+const REQUEST_TIMEOUT_SECS: u64 = 30;
+const MAX_RAW_RESPONSE_BYTES: usize = 10 * 1024 * 1024;
+const NACOS_ERROR_PREFIX: &str = "NACOS_ERROR";
+
+#[derive(Debug, Clone)]
+struct AccessToken {
+    token: String,
+    expires_at: Instant,
+}
+
+pub struct NacosOpenApiAdmin {
+    cfg: NacosAdminConfig,
+    http: reqwest::Client,
+    token: Mutex<Option<AccessToken>>,
+}
+
+impl NacosOpenApiAdmin {
+    pub fn new(cfg: NacosAdminConfig) -> Result<Self, String> {
+        let mut builder = reqwest::Client::builder().timeout(Duration::from_secs(REQUEST_TIMEOUT_SECS));
+        if cfg.tls_skip_verify {
+            builder = builder.danger_accept_invalid_certs(true);
+        }
+        let http = builder.build().map_err(|e| format!("Failed to build Nacos HTTP client: {e}"))?;
+        Ok(Self { cfg, http, token: Mutex::new(None) })
+    }
+
+    fn endpoint_with_context(&self, path: &str, context_path: &str) -> Result<String, String> {
+        let path = normalize_api_path(path);
+        let context_path = normalize_api_path(context_path).trim_end_matches('/').to_string();
+        let base = format!("{}{}", self.cfg.server_addr, context_path);
+        let base = base.trim_end_matches('/');
+        let full = if path.starts_with("/nacos/") && context_path == "/nacos" {
+            format!("{}{}", self.cfg.server_addr, path)
+        } else {
+            format!("{base}{path}")
+        };
+        reqwest::Url::parse(&full).map(|url| url.to_string()).map_err(|e| format!("Nacos API URL is invalid: {e}"))
+    }
+
+    async fn send_with_context_fallback(
+        &self,
+        method: reqwest::Method,
+        path: &str,
+        query: &[(String, String)],
+        form: Option<&[(String, String)]>,
+        body: Option<&Value>,
+    ) -> Result<reqwest::Response, String> {
+        let resp = self.send_once(method.clone(), path, &self.cfg.context_path, query, form, body).await?;
+        if !self.should_retry_without_context(resp.status()) {
+            return Ok(resp);
+        }
+
+        let status = resp.status();
+        let detail = resp.text().await.unwrap_or_default();
+        if self.cfg.context_path.trim().is_empty() || !looks_like_wrong_context_path(&detail, &self.cfg.context_path) {
+            return Err(format!("Nacos admin {path} returned {status}: {}", detail.trim()));
+        }
+        self.send_once(method, path, "", query, form, body).await
+    }
+
+    async fn send_once(
+        &self,
+        method: reqwest::Method,
+        path: &str,
+        context_path: &str,
+        query: &[(String, String)],
+        form: Option<&[(String, String)]>,
+        body: Option<&Value>,
+    ) -> Result<reqwest::Response, String> {
+        let mut req = self.http.request(method, self.endpoint_with_context(path, context_path)?).query(query);
+        if let Some(form) = form {
+            req = req.form(form);
+        }
+        if let Some(body) = body {
+            req = req.json(body);
+        }
+        req.send().await.map_err(|e| format!("Nacos request to {path} failed: {e}"))
+    }
+
+    fn should_retry_without_context(&self, status: reqwest::StatusCode) -> bool {
+        !self.cfg.context_path.trim().is_empty()
+            && (status == reqwest::StatusCode::NOT_FOUND || status == reqwest::StatusCode::INTERNAL_SERVER_ERROR)
+    }
+
+    async fn access_token(&self) -> Result<Option<String>, String> {
+        let NacosAuthConfig::UsernamePassword { username, password } = &self.cfg.auth else {
+            return Ok(None);
+        };
+        if username.trim().is_empty() {
+            return Ok(None);
+        }
+        {
+            let guard = self.token.lock().await;
+            if let Some(token) = guard.as_ref() {
+                if token.expires_at > Instant::now() + Duration::from_secs(30) {
+                    return Ok(Some(token.token.clone()));
+                }
+            }
+        }
+
+        let form = vec![("username".to_string(), username.to_string()), ("password".to_string(), password.to_string())];
+        let mut last_err = None;
+        let mut resp = None;
+        for path in ["/v1/auth/login", "/v3/auth/user/login"] {
+            match self.send_with_context_fallback(reqwest::Method::POST, path, &[], Some(&form), None).await {
+                Ok(value) if value.status().is_success() => {
+                    resp = Some(value);
+                    break;
+                }
+                Ok(value) => match error_for_status(value, path).await {
+                    Ok(value) => {
+                        resp = Some(value);
+                        break;
+                    }
+                    Err(err) => last_err = Some(err),
+                },
+                Err(err) => last_err = Some(err),
+            }
+        }
+        let resp = resp.ok_or_else(|| last_err.unwrap_or_else(|| "Nacos auth request failed".to_string()))?;
+        let value: Value = resp.json().await.map_err(|e| format!("Failed to parse Nacos auth response: {e}"))?;
+        let token_source = value.get("data").filter(|value| value.is_object()).unwrap_or(&value);
+        let token = token_source
+            .get("accessToken")
+            .or_else(|| token_source.get("access_token"))
+            .or_else(|| token_source.get("token"))
+            .and_then(Value::as_str)
+            .ok_or_else(|| format!("Nacos auth response did not include an access token: {value}"))?
+            .to_string();
+        let ttl = token_source
+            .get("tokenTtl")
+            .or_else(|| token_source.get("expiresIn"))
+            .or_else(|| token_source.get("expireSeconds"))
+            .and_then(Value::as_u64)
+            .unwrap_or(18_000);
+        *self.token.lock().await = Some(AccessToken {
+            token: token.clone(),
+            expires_at: Instant::now() + Duration::from_secs(ttl.saturating_sub(30).max(60)),
+        });
+        Ok(Some(token))
+    }
+
+    async fn request(
+        &self,
+        method: reqwest::Method,
+        path: &str,
+        mut query: Vec<(String, String)>,
+        form: Option<Vec<(String, String)>>,
+        body: Option<Value>,
+    ) -> Result<reqwest::Response, String> {
+        if let Some(token) = self.access_token().await? {
+            query.push(("accessToken".to_string(), token));
+        }
+        self.send_with_context_fallback(method, path, &query, form.as_deref(), body.as_ref()).await
+    }
+
+    async fn get_json(&self, path: &str, query: Vec<(String, String)>) -> Result<Value, String> {
+        let resp = self.request(reqwest::Method::GET, path, query, None, None).await?;
+        let resp = error_for_status(resp, path).await?;
+        response_json_or_text(resp).await
+    }
+
+    async fn get_json_without_auth(&self, path: &str, query: Vec<(String, String)>) -> Result<Value, String> {
+        let resp = self.send_with_context_fallback(reqwest::Method::GET, path, &query, None, None).await?;
+        let resp = error_for_status(resp, path).await?;
+        response_json_or_text(resp).await
+    }
+
+    async fn get_server_state(&self) -> Result<Value, String> {
+        let mut errors = Vec::new();
+        for path in ["/v3/console/server/state", "/v1/ns/operator/servers", "/v1/console/server/state"] {
+            match self.get_json_without_auth(path, Vec::new()).await {
+                Ok(value) => return Ok(value),
+                Err(err) => errors.push(err),
+            }
+        }
+        Err(admin_endpoint_error(&self.cfg.server_addr, &errors))
+    }
+
+    fn namespace(&self, override_ns: Option<&str>) -> String {
+        override_ns.unwrap_or(&self.cfg.namespace).trim().to_string()
+    }
+
+    async fn get_config_list_value(
+        &self,
+        namespace: &str,
+        search: &str,
+        group: &str,
+        app_name: &str,
+        page_no: u32,
+        page_size: u32,
+    ) -> Result<Value, String> {
+        let mut v3_params = vec![
+            ("search".to_string(), "blur".to_string()),
+            ("dataId".to_string(), search.to_string()),
+            ("groupName".to_string(), group.to_string()),
+            ("namespaceId".to_string(), namespace.to_string()),
+            ("pageNo".to_string(), page_no.to_string()),
+            ("pageSize".to_string(), page_size.to_string()),
+        ];
+        push_optional(&mut v3_params, "appName", Some(app_name.to_string()));
+        match self.get_json("/v3/console/cs/config/list", v3_params).await {
+            Ok(value) => Ok(value),
+            Err(v3_err) => {
+                let mut v1_params = vec![
+                    ("search".to_string(), "blur".to_string()),
+                    ("dataId".to_string(), search.to_string()),
+                    ("group".to_string(), group.to_string()),
+                    ("tenant".to_string(), namespace.to_string()),
+                    ("pageNo".to_string(), page_no.to_string()),
+                    ("pageSize".to_string(), page_size.to_string()),
+                ];
+                push_optional(&mut v1_params, "appName", Some(app_name.to_string()));
+                self.get_json("/v1/cs/configs", v1_params).await.map_err(|v1_err| {
+                    format!("Failed to list Nacos configs with v3 and v1 APIs. v3: {v3_err}; v1: {v1_err}")
+                })
+            }
+        }
+    }
+
+    async fn get_json_from_candidates(
+        &self,
+        operation: &str,
+        attempts: Vec<(&str, Vec<(String, String)>)>,
+    ) -> Result<Value, String> {
+        let mut errors = Vec::new();
+        for (path, query) in attempts {
+            match self.get_json(path, query).await {
+                Ok(value) => return Ok(value),
+                Err(err) => errors.push(err),
+            }
+        }
+        Err(format!("Failed to {operation}: {}", errors.join("; ")))
+    }
+
+    async fn submit_form_candidates(
+        &self,
+        operation: &str,
+        method: reqwest::Method,
+        attempts: Vec<(&str, Vec<(String, String)>)>,
+    ) -> Result<(), String> {
+        let mut errors = Vec::new();
+        for (path, form) in attempts {
+            match self.request(method.clone(), path, Vec::new(), Some(form), None).await {
+                Ok(resp) => match error_for_status(resp, path).await {
+                    Ok(_) => return Ok(()),
+                    Err(err) => errors.push(err),
+                },
+                Err(err) => errors.push(err),
+            }
+        }
+        Err(format!("Failed to {operation}: {}", errors.join("; ")))
+    }
+
+    async fn submit_query_candidates(
+        &self,
+        operation: &str,
+        method: reqwest::Method,
+        attempts: Vec<(&str, Vec<(String, String)>)>,
+    ) -> Result<(), String> {
+        let mut errors = Vec::new();
+        for (path, query) in attempts {
+            match self.request(method.clone(), path, query, None, None).await {
+                Ok(resp) => match error_for_status(resp, path).await {
+                    Ok(_) => return Ok(()),
+                    Err(err) => errors.push(err),
+                },
+                Err(err) => errors.push(err),
+            }
+        }
+        Err(format!("Failed to {operation}: {}", errors.join("; ")))
+    }
+
+    async fn list_configs_by_client_filter(
+        &self,
+        namespace: String,
+        group: Option<String>,
+        data_id_filter: Option<String>,
+        app_name_filter: Option<String>,
+        page_no: u32,
+        page_size: u32,
+    ) -> Result<NacosConfigList, String> {
+        let Some(filter) = data_id_filter.map(|value| value.to_lowercase()).filter(|value| !value.is_empty()) else {
+            return Ok(NacosConfigList { page_no, page_size, total_count: 0, items: Vec::new() });
+        };
+        let group = group.unwrap_or_default();
+        let app_name = app_name_filter.unwrap_or_default();
+        let scan_page_size = page_size.max(self.cfg.page_size).clamp(100, 500);
+        let max_scan_pages = 10;
+        let mut matched = Vec::new();
+        let mut current_page = 1;
+
+        while current_page <= max_scan_pages {
+            let value =
+                self.get_config_list_value(&namespace, "", &group, &app_name, current_page, scan_page_size).await?;
+            let list = parse_config_list(value, namespace.clone(), current_page, scan_page_size);
+            matched.extend(list.items.into_iter().filter(|item| item.data_id.to_lowercase().contains(&filter)));
+
+            let scanned = u64::from(current_page) * u64::from(scan_page_size);
+            if scanned >= list.total_count || list.total_count == 0 {
+                break;
+            }
+            current_page += 1;
+        }
+
+        let total_count = matched.len() as u64;
+        let start = ((page_no.saturating_sub(1)) * page_size) as usize;
+        let end = start.saturating_add(page_size as usize).min(matched.len());
+        let items = if start < matched.len() { matched[start..end].to_vec() } else { Vec::new() };
+        Ok(self.enrich_missing_config_formats(NacosConfigList { page_no, page_size, total_count, items }).await)
+    }
+
+    async fn enrich_missing_config_formats(&self, mut list: NacosConfigList) -> NacosConfigList {
+        for item in list.items.iter_mut() {
+            if item.config_type.is_some() {
+                continue;
+            }
+            let detail = self
+                .get_config(NacosConfigKey {
+                    namespace: Some(item.namespace.clone()),
+                    data_id: item.data_id.clone(),
+                    group: item.group.clone(),
+                })
+                .await;
+            if let Ok(detail) = detail {
+                item.config_type = detail.config_type;
+            }
+        }
+        list
+    }
+}
+
+#[async_trait]
+impl NacosAdmin for NacosOpenApiAdmin {
+    async fn test_connection(&self) -> Result<NacosConnectionInfo, String> {
+        let raw = self.get_server_state().await?;
+        let _ = self.access_token().await?;
+        let _ = self.list_namespaces().await?;
+        Ok(NacosConnectionInfo {
+            server_addr: self.cfg.server_addr.clone(),
+            display_server_addr: self.cfg.display_server_addr.clone(),
+            namespace: self.cfg.namespace.clone(),
+            server_version: extract_server_version(&raw),
+            auth: match self.cfg.auth {
+                NacosAuthConfig::None => "none".to_string(),
+                NacosAuthConfig::UsernamePassword { .. } => "usernamePassword".to_string(),
+            },
+            capabilities: NacosCapabilities::default(),
+            raw: Some(raw),
+        })
+    }
+
+    async fn list_namespaces(&self) -> Result<Vec<NacosNamespaceInfo>, String> {
+        let value = match self.get_json("/v3/console/core/namespace/list", Vec::new()).await {
+            Ok(value) => value,
+            Err(v3_err) => self
+                .get_json("/v1/console/namespaces", Vec::new())
+                .await
+                .map_err(|v1_err| namespace_list_error(&v3_err, &v1_err))?,
+        };
+        Ok(parse_namespaces(value))
+    }
+
+    async fn create_namespace(&self, req: NacosNamespaceCreate) -> Result<(), String> {
+        let namespace_id = req.namespace_id.map(|value| value.trim().to_string()).filter(|value| !value.is_empty());
+        let namespace_name = req.namespace_name.trim().to_string();
+        if namespace_name.is_empty() {
+            return Err(classified_error("invalidNamespace", "Nacos namespace name is required"));
+        }
+        let namespace_desc = req
+            .namespace_desc
+            .map(|value| value.trim().to_string())
+            .filter(|value| !value.is_empty())
+            .unwrap_or_else(|| namespace_name.clone());
+
+        let mut v3_form = vec![
+            ("namespaceName".to_string(), namespace_name.clone()),
+            ("namespaceDesc".to_string(), namespace_desc.clone()),
+        ];
+        let mut v1_form =
+            vec![("namespaceName".to_string(), namespace_name), ("namespaceDesc".to_string(), namespace_desc)];
+        if let Some(namespace_id) = namespace_id {
+            v3_form.push(("namespaceId".to_string(), namespace_id.clone()));
+            v1_form.push(("customNamespaceId".to_string(), namespace_id.clone()));
+            v1_form.push(("namespaceId".to_string(), namespace_id));
+        }
+
+        self.submit_form_candidates(
+            "create Nacos namespace",
+            reqwest::Method::POST,
+            vec![
+                ("/v3/console/core/namespace", v3_form.clone()),
+                ("/v3/console/core/namespace/create", v3_form),
+                ("/v1/console/namespaces", v1_form.clone()),
+                ("/v1/console/namespaces/create", v1_form),
+            ],
+        )
+        .await
+    }
+
+    async fn update_namespace(&self, req: NacosNamespaceUpdate) -> Result<(), String> {
+        let namespace_id = req.namespace_id.trim().to_string();
+        if namespace_id.is_empty() {
+            return Err(classified_error("invalidNamespace", "Nacos namespace ID is required"));
+        }
+        let namespace_name = req.namespace_name.trim().to_string();
+        if namespace_name.is_empty() {
+            return Err(classified_error("invalidNamespace", "Nacos namespace name is required"));
+        }
+        let namespace_desc = req
+            .namespace_desc
+            .map(|value| value.trim().to_string())
+            .filter(|value| !value.is_empty())
+            .unwrap_or_else(|| namespace_name.clone());
+
+        let v3_form = vec![
+            ("namespaceId".to_string(), namespace_id.clone()),
+            ("namespaceName".to_string(), namespace_name.clone()),
+            ("namespaceDesc".to_string(), namespace_desc.clone()),
+        ];
+        let v1_form = vec![
+            ("namespace".to_string(), namespace_id.clone()),
+            ("namespaceId".to_string(), namespace_id.clone()),
+            ("customNamespaceId".to_string(), namespace_id),
+            ("namespaceShowName".to_string(), namespace_name.clone()),
+            ("namespaceName".to_string(), namespace_name),
+            ("namespaceDesc".to_string(), namespace_desc),
+        ];
+
+        self.submit_form_candidates(
+            "update Nacos namespace",
+            reqwest::Method::PUT,
+            vec![
+                ("/v3/console/core/namespace", v3_form.clone()),
+                ("/v3/console/core/namespace/update", v3_form),
+                ("/v1/console/namespaces", v1_form.clone()),
+                ("/v1/console/namespaces/update", v1_form),
+            ],
+        )
+        .await
+    }
+
+    async fn list_configs(&self, query: NacosConfigQuery) -> Result<NacosConfigList, String> {
+        let page_no = query.page_no.unwrap_or(1).max(1);
+        let page_size = query.page_size.unwrap_or(self.cfg.page_size).clamp(1, 500);
+        let namespace = self.namespace(query.namespace.as_deref());
+        let data_id_filter = query
+            .data_id
+            .clone()
+            .or(query.search.clone())
+            .map(|value| value.trim().to_string())
+            .filter(|value| !value.is_empty());
+        let search = data_id_filter.clone().unwrap_or_default();
+        let group_filter = query.group.clone();
+        let group = group_filter.clone().unwrap_or_default();
+        let app_name_filter = query.app_name.map(|value| value.trim().to_string()).filter(|value| !value.is_empty());
+        let app_name = app_name_filter.clone().unwrap_or_default();
+        let value = self.get_config_list_value(&namespace, &search, &group, &app_name, page_no, page_size).await?;
+        let parsed =
+            self.enrich_missing_config_formats(parse_config_list(value, namespace.clone(), page_no, page_size)).await;
+        if data_id_filter.is_some() && parsed.items.is_empty() {
+            let fallback = self
+                .list_configs_by_client_filter(
+                    namespace,
+                    group_filter,
+                    data_id_filter,
+                    app_name_filter,
+                    page_no,
+                    page_size,
+                )
+                .await?;
+            if !fallback.items.is_empty() {
+                return Ok(fallback);
+            }
+        }
+        Ok(parsed)
+    }
+
+    async fn get_config(&self, key: NacosConfigKey) -> Result<NacosConfigItem, String> {
+        let namespace = self.namespace(key.namespace.as_deref());
+        let v3_params = vec![
+            ("dataId".to_string(), key.data_id.clone()),
+            ("groupName".to_string(), key.group.clone()),
+            ("namespaceId".to_string(), namespace.clone()),
+        ];
+        let v1_params = vec![
+            ("dataId".to_string(), key.data_id.clone()),
+            ("group".to_string(), key.group.clone()),
+            ("tenant".to_string(), namespace.clone()),
+        ];
+        let mut v1_detail_params = v1_params.clone();
+        v1_detail_params.push(("show".to_string(), "all".to_string()));
+        let mut errors = Vec::new();
+        for (path, query) in [
+            ("/v3/console/cs/config", v3_params.clone()),
+            ("/v3/console/cs/config/detail", v3_params),
+            ("/v1/cs/configs", v1_detail_params),
+            ("/v1/cs/configs", v1_params),
+        ] {
+            match self.request(reqwest::Method::GET, path, query, None, None).await {
+                Ok(resp) => match error_for_status(resp, path).await {
+                    Ok(resp) if path == "/v1/cs/configs" => {
+                        let text =
+                            resp.text().await.map_err(|e| format!("Failed to read Nacos config response: {e}"))?;
+                        if let Ok(value) = serde_json::from_str::<Value>(&text) {
+                            return Ok(parse_config_detail(value, key.data_id, key.group, namespace));
+                        }
+                        return Ok(NacosConfigItem {
+                            data_id: key.data_id,
+                            group: key.group,
+                            namespace,
+                            app_name: None,
+                            desc: None,
+                            tags: None,
+                            config_type: None,
+                            md5: None,
+                            encrypted_data_key: None,
+                            content: Some(text),
+                        });
+                    }
+                    Ok(resp) => {
+                        let value = response_json_or_text(resp).await?;
+                        return Ok(parse_config_detail(value, key.data_id, key.group, namespace));
+                    }
+                    Err(err) => errors.push(err),
+                },
+                Err(err) => errors.push(err),
+            }
+        }
+        Err(format!("Failed to get Nacos config: {}", errors.join("; ")))
+    }
+
+    async fn publish_config(&self, req: NacosConfigUpsert) -> Result<(), String> {
+        let namespace = self.namespace(req.namespace.as_deref());
+        let (v3_form, v1_form) = build_publish_forms(req, namespace);
+
+        let mut errors = Vec::new();
+        for (path, form) in [
+            ("/v3/console/cs/config", v3_form.clone()),
+            ("/v3/console/cs/config/publish", v3_form.clone()),
+            ("/v3/console/cs/config/update", v3_form),
+        ] {
+            match self.request(reqwest::Method::POST, path, Vec::new(), Some(form), None).await {
+                Ok(resp) => match error_for_status(resp, path).await {
+                    Ok(_) => return Ok(()),
+                    Err(err) => errors.push(err),
+                },
+                Err(err) => errors.push(err),
+            }
+        }
+        match self.request(reqwest::Method::POST, "/v1/cs/configs", Vec::new(), Some(v1_form), None).await {
+            Ok(resp) => match error_for_status(resp, "/v1/cs/configs").await {
+                Ok(_) => Ok(()),
+                Err(err) => {
+                    errors.push(err);
+                    Err(format!("Failed to publish Nacos config: {}", errors.join("; ")))
+                }
+            },
+            Err(err) => {
+                errors.push(err);
+                Err(format!("Failed to publish Nacos config: {}", errors.join("; ")))
+            }
+        }
+    }
+
+    async fn delete_config(&self, key: NacosConfigKey) -> Result<(), String> {
+        let namespace = self.namespace(key.namespace.as_deref());
+        let v3_query = vec![
+            ("dataId".to_string(), key.data_id.clone()),
+            ("groupName".to_string(), key.group.clone()),
+            ("namespaceId".to_string(), namespace.clone()),
+        ];
+        let v1_query = vec![
+            ("dataId".to_string(), key.data_id),
+            ("group".to_string(), key.group),
+            ("tenant".to_string(), namespace),
+        ];
+        self.submit_query_candidates(
+            "delete Nacos config",
+            reqwest::Method::DELETE,
+            vec![
+                ("/v3/console/cs/config", v3_query.clone()),
+                ("/v3/console/cs/config/delete", v3_query.clone()),
+                ("/v3/console/cs/config/remove", v3_query),
+                ("/v1/cs/configs", v1_query),
+            ],
+        )
+        .await
+    }
+
+    async fn list_config_history(&self, query: NacosConfigHistoryQuery) -> Result<NacosConfigHistoryList, String> {
+        let page_no = query.page_no.unwrap_or(1).max(1);
+        let page_size = query.page_size.unwrap_or(self.cfg.page_size).clamp(1, 500);
+        let namespace = self.namespace(query.namespace.as_deref());
+        let v3_params = vec![
+            ("search".to_string(), "accurate".to_string()),
+            ("dataId".to_string(), query.data_id.clone()),
+            ("groupName".to_string(), query.group.clone()),
+            ("namespaceId".to_string(), namespace.clone()),
+            ("pageNo".to_string(), page_no.to_string()),
+            ("pageSize".to_string(), page_size.to_string()),
+        ];
+        let v1_params = vec![
+            ("search".to_string(), "accurate".to_string()),
+            ("dataId".to_string(), query.data_id.clone()),
+            ("group".to_string(), query.group.clone()),
+            ("tenant".to_string(), namespace.clone()),
+            ("pageNo".to_string(), page_no.to_string()),
+            ("pageSize".to_string(), page_size.to_string()),
+        ];
+        let value = self
+            .get_json_from_candidates(
+                "list Nacos config history",
+                vec![
+                    ("/v3/console/cs/history/list", v3_params.clone()),
+                    ("/v3/console/cs/history", v3_params.clone()),
+                    ("/v1/cs/history/list", v1_params.clone()),
+                    ("/v1/cs/history", v1_params.clone()),
+                    ("/v1/cs/history/configs", v1_params),
+                ],
+            )
+            .await
+            .map_err(|err| classified_error("unsupportedConfigHistory", &err))?;
+        Ok(parse_config_history_list(value, namespace, page_no, page_size, &query.data_id, &query.group))
+    }
+
+    async fn get_config_history(&self, key: NacosConfigHistoryKey) -> Result<NacosConfigItem, String> {
+        let namespace = self.namespace(key.namespace.as_deref());
+        let nid = key.nid.or_else(|| key.history_id.parse::<i64>().ok());
+        let mut v3_params = vec![
+            ("dataId".to_string(), key.data_id.clone()),
+            ("groupName".to_string(), key.group.clone()),
+            ("namespaceId".to_string(), namespace.clone()),
+            ("id".to_string(), key.history_id.clone()),
+        ];
+        if let Some(nid) = nid {
+            v3_params.push(("nid".to_string(), nid.to_string()));
+        }
+        let mut v1_params = vec![
+            ("dataId".to_string(), key.data_id.clone()),
+            ("group".to_string(), key.group.clone()),
+            ("tenant".to_string(), namespace.clone()),
+        ];
+        if let Some(nid) = nid {
+            v1_params.push(("nid".to_string(), nid.to_string()));
+        } else {
+            v1_params.push(("id".to_string(), key.history_id.clone()));
+        }
+        let value = self
+            .get_json_from_candidates(
+                "get Nacos config history",
+                vec![
+                    ("/v3/console/cs/history/detail", v3_params.clone()),
+                    ("/v3/console/cs/history", v3_params.clone()),
+                    ("/v1/cs/history", v1_params.clone()),
+                    ("/v1/cs/history/config", v1_params),
+                ],
+            )
+            .await
+            .map_err(|err| classified_error("unsupportedConfigHistory", &err))?;
+        Ok(parse_config_history_detail(value, key.data_id, key.group, namespace))
+    }
+
+    async fn rollback_config(&self, req: NacosConfigRollbackRequest) -> Result<(), String> {
+        let namespace = self.namespace(req.namespace.as_deref());
+        let nid = req.nid.or_else(|| req.history_id.parse::<i64>().ok());
+        let data_id = req.data_id.clone();
+        let group = req.group.clone();
+        let history_id = req.history_id.clone();
+        let mut v3_query = vec![
+            ("dataId".to_string(), req.data_id.clone()),
+            ("groupName".to_string(), req.group.clone()),
+            ("namespaceId".to_string(), namespace.clone()),
+            ("id".to_string(), req.history_id.clone()),
+        ];
+        if let Some(nid) = nid {
+            v3_query.push(("nid".to_string(), nid.to_string()));
+        }
+        let mut v1_query = vec![
+            ("dataId".to_string(), req.data_id),
+            ("group".to_string(), req.group),
+            ("tenant".to_string(), namespace.clone()),
+        ];
+        if let Some(nid) = nid {
+            v1_query.push(("nid".to_string(), nid.to_string()));
+        } else {
+            v1_query.push(("id".to_string(), req.history_id));
+        }
+        let endpoint_result = self
+            .submit_query_candidates(
+                "rollback Nacos config",
+                reqwest::Method::POST,
+                vec![
+                    ("/v3/console/cs/history/rollback", v3_query.clone()),
+                    ("/v3/console/cs/config/history/rollback", v3_query),
+                    ("/v1/cs/history/rollback", v1_query.clone()),
+                    ("/v1/cs/history/config/rollback", v1_query),
+                ],
+            )
+            .await;
+        if endpoint_result.is_ok() {
+            return Ok(());
+        }
+        let endpoint_err = endpoint_result.unwrap_err();
+        let history = self
+            .get_config_history(NacosConfigHistoryKey {
+                namespace: Some(namespace.clone()),
+                data_id: data_id.clone(),
+                group: group.clone(),
+                history_id,
+                nid,
+            })
+            .await
+            .map_err(|history_err| {
+                classified_error(
+                    "unsupportedConfigHistory",
+                    &format!("{endpoint_err}; failed to load history content for publish fallback: {history_err}"),
+                )
+            })?;
+        let content = history.content.clone().ok_or_else(|| {
+            classified_error(
+                "unsupportedConfigHistory",
+                &format!("{endpoint_err}; history version did not include content for rollback"),
+            )
+        })?;
+        self.publish_config(NacosConfigUpsert {
+            namespace: Some(namespace),
+            data_id,
+            group,
+            content,
+            config_type: history.config_type,
+            app_name: history.app_name,
+            desc: history.desc,
+            tags: history.tags,
+        })
+        .await
+        .map_err(|publish_err| {
+            classified_error(
+                "unsupportedConfigHistory",
+                &format!("{endpoint_err}; failed to publish history content for rollback: {publish_err}"),
+            )
+        })
+    }
+
+    async fn list_services(&self, query: NacosServiceQuery) -> Result<NacosServiceList, String> {
+        let page_no = query.page_no.unwrap_or(1).max(1);
+        let page_size = query.page_size.unwrap_or(self.cfg.page_size).clamp(1, 500);
+        let namespace = self.namespace(query.namespace.as_deref());
+        let mut v3_params = vec![
+            ("namespaceId".to_string(), namespace.clone()),
+            ("pageNo".to_string(), page_no.to_string()),
+            ("pageSize".to_string(), page_size.to_string()),
+        ];
+        push_optional(&mut v3_params, "groupNameParam", query.group_name.clone());
+        push_optional(&mut v3_params, "serviceNameParam", query.service_name.clone());
+        let mut v1_catalog_params = vec![
+            ("namespaceId".to_string(), namespace.clone()),
+            ("pageNo".to_string(), page_no.to_string()),
+            ("pageSize".to_string(), page_size.to_string()),
+        ];
+        push_optional(&mut v1_catalog_params, "groupNameParam", query.group_name.clone());
+        push_optional(&mut v1_catalog_params, "serviceNameParam", query.service_name.clone());
+        let mut v1_legacy_params = vec![
+            ("namespaceId".to_string(), namespace),
+            ("pageNo".to_string(), page_no.to_string()),
+            ("pageSize".to_string(), page_size.to_string()),
+        ];
+        push_optional(&mut v1_legacy_params, "groupName", query.group_name);
+        push_optional(&mut v1_legacy_params, "serviceName", query.service_name);
+        let value = self
+            .get_json_from_candidates(
+                "list Nacos services",
+                vec![
+                    ("/v3/console/ns/service/list", v3_params.clone()),
+                    ("/v1/ns/catalog/services", v1_catalog_params.clone()),
+                    ("/v3/console/ns/service", v3_params),
+                    ("/v1/ns/service/list", v1_legacy_params),
+                ],
+            )
+            .await?;
+        Ok(parse_service_list(value, page_no, page_size))
+    }
+
+    async fn list_instances(&self, query: NacosInstanceQuery) -> Result<Vec<NacosInstanceInfo>, String> {
+        let namespace = self.namespace(query.namespace.as_deref());
+        let mut params = vec![("serviceName".to_string(), query.service_name), ("namespaceId".to_string(), namespace)];
+        push_optional(&mut params, "groupName", query.group_name);
+        push_optional(&mut params, "clusters", query.clusters);
+        let value = self
+            .get_json_from_candidates(
+                "list Nacos instances",
+                vec![
+                    ("/v3/console/ns/instance/list", params.clone()),
+                    ("/v3/console/ns/instance", params.clone()),
+                    ("/v1/ns/instance/list", params),
+                ],
+            )
+            .await?;
+        Ok(parse_instances(value))
+    }
+
+    async fn update_instance(&self, req: NacosInstanceUpdate) -> Result<(), String> {
+        let namespace = self.namespace(req.namespace.as_deref());
+        let mut form = vec![
+            ("serviceName".to_string(), req.service_name),
+            ("ip".to_string(), req.ip),
+            ("port".to_string(), req.port.to_string()),
+            ("namespaceId".to_string(), namespace),
+        ];
+        push_optional(&mut form, "groupName", req.group_name);
+        push_optional(&mut form, "clusterName", req.cluster_name);
+        if let Some(value) = req.healthy {
+            form.push(("healthy".to_string(), value.to_string()));
+        }
+        if let Some(value) = req.enabled {
+            form.push(("enabled".to_string(), value.to_string()));
+        }
+        if let Some(value) = req.ephemeral {
+            form.push(("ephemeral".to_string(), value.to_string()));
+        }
+        if let Some(value) = req.weight {
+            form.push(("weight".to_string(), value.to_string()));
+        }
+        if let Some(value) = req.metadata {
+            form.push(("metadata".to_string(), value.to_string()));
+        }
+        self.submit_form_candidates(
+            "update Nacos instance",
+            reqwest::Method::PUT,
+            vec![
+                ("/v3/console/ns/instance", form.clone()),
+                ("/v3/console/ns/instance/update", form.clone()),
+                ("/v1/ns/instance", form),
+            ],
+        )
+        .await
+    }
+
+    async fn raw_request(&self, req: NacosRawRequest) -> Result<NacosRawResponse, String> {
+        validate_raw_api_path(&req.path)?;
+        let method = reqwest::Method::from_bytes(req.method.to_ascii_uppercase().as_bytes())
+            .map_err(|e| format!("Invalid Nacos raw request method: {e}"))?;
+        let mut query = req.query.unwrap_or_default().into_iter().collect::<Vec<_>>();
+        query.sort_by(|a, b| a.0.cmp(&b.0));
+        let resp = self.request(method, &req.path, query, None, req.body).await?;
+        let status = resp.status().as_u16();
+        let headers = response_headers(resp.headers());
+        let bytes = resp.bytes().await.map_err(|e| format!("Failed to read Nacos raw response: {e}"))?;
+        if bytes.len() > MAX_RAW_RESPONSE_BYTES {
+            return Err(format!("Nacos raw response exceeds {} bytes", MAX_RAW_RESPONSE_BYTES));
+        }
+        let text = String::from_utf8_lossy(&bytes).to_string();
+        let body = serde_json::from_slice::<Value>(&bytes).unwrap_or_else(|_| Value::String(text.clone()));
+        Ok(NacosRawResponse { status, body: serde_json::json!({ "headers": headers, "body": body }), text: Some(text) })
+    }
+}
+
+pub fn validate_raw_api_path(path: &str) -> Result<(), String> {
+    let trimmed = path.trim();
+    if trimmed.is_empty() {
+        return Err(classified_error("invalidRawPath", "Nacos raw API path is empty"));
+    }
+    if trimmed.contains("://") || trimmed.starts_with("//") {
+        return Err(classified_error(
+            "invalidRawPath",
+            "Nacos raw API path must be a relative API path, not a full URL",
+        ));
+    }
+    if !trimmed.starts_with('/') {
+        return Err(classified_error("invalidRawPath", "Nacos raw API path must start with /v1, /v2, or /v3"));
+    }
+    if trimmed.contains('\\') || trimmed.split('/').any(|segment| segment == ".." || segment == ".") {
+        return Err(classified_error("invalidRawPath", "Nacos raw API path must not contain path traversal segments"));
+    }
+    if !matches!(trimmed.split('/').nth(1), Some("v1" | "v2" | "v3")) {
+        return Err(classified_error("invalidRawPath", "Nacos raw API path must start with /v1, /v2, or /v3"));
+    }
+    Ok(())
+}
+
+fn parse_namespaces(value: Value) -> Vec<NacosNamespaceInfo> {
+    let data = value.get("data").unwrap_or(&value);
+    let items = data
+        .as_array()
+        .cloned()
+        .or_else(|| data.get("namespaces").and_then(Value::as_array).cloned())
+        .or_else(|| data.get("pageItems").and_then(Value::as_array).cloned())
+        .or_else(|| data.get("items").and_then(Value::as_array).cloned())
+        .or_else(|| value.get("namespaces").and_then(Value::as_array).cloned())
+        .unwrap_or_default();
+    let mut namespaces: Vec<NacosNamespaceInfo> = items
+        .into_iter()
+        .map(|item| {
+            let namespace =
+                optional_string_field(&item, &["namespace", "namespaceId", "namespace_id", "tenant", "tenantId"])
+                    .unwrap_or_default();
+            let show_name = optional_string_field(&item, &["namespaceShowName", "namespaceName", "name", "showName"])
+                .filter(|value| !value.trim().is_empty())
+                .unwrap_or_else(|| if namespace.is_empty() { "public".to_string() } else { namespace.clone() });
+            NacosNamespaceInfo {
+                namespace,
+                namespace_show_name: show_name,
+                namespace_desc: optional_string_field(
+                    &item,
+                    &["namespaceDesc", "namespace_desc", "description", "desc"],
+                ),
+                config_count: optional_u64_field(&item, &["configCount"]),
+                quota: optional_u64_field(&item, &["quota"]),
+                namespace_type: optional_u64_field(&item, &["type", "namespaceType"]),
+            }
+        })
+        .collect();
+    if !namespaces.iter().any(|item| item.namespace.is_empty()) {
+        namespaces.insert(
+            0,
+            NacosNamespaceInfo {
+                namespace: String::new(),
+                namespace_show_name: "public".to_string(),
+                namespace_desc: None,
+                config_count: None,
+                quota: None,
+                namespace_type: None,
+            },
+        );
+    }
+    namespaces
+}
+
+fn normalize_api_path(path: &str) -> String {
+    let trimmed = path.trim();
+    if trimmed.starts_with('/') {
+        trimmed.to_string()
+    } else {
+        format!("/{trimmed}")
+    }
+}
+
+fn looks_like_wrong_context_path(detail: &str, context_path: &str) -> bool {
+    let context = context_path.trim().trim_matches('/');
+    if context.is_empty() {
+        return false;
+    }
+    let detail = detail.to_ascii_lowercase();
+    let context = context.to_ascii_lowercase();
+    detail.contains(&format!("no static resource {context}/"))
+        || detail.contains(&format!("path\":\"/{context}/"))
+        || detail.contains(&format!("path=/{context}/"))
+}
+
+fn admin_endpoint_error(server_addr: &str, errors: &[String]) -> String {
+    let joined = errors.join("\n");
+    let lower = joined.to_ascii_lowercase();
+    if lower.contains("404 not found") && (lower.contains("<!doctype html>") || lower.contains("<html")) {
+        return classified_error(
+            "endpointNotFound",
+            &format!(
+                "Nacos admin endpoint was not found at {server_addr}. This looks like a Nacos client/server port, not the console/admin API address. Use the console URL, for example http://127.0.0.1:8085 in Nacos 3 Docker deployments, and leave Context Path empty unless the console is actually mounted under /nacos."
+            ),
+        );
+    }
+    if lower.contains("410 gone") && lower.contains("/v3/console/server/state") {
+        return classified_error(
+            "apiVersionMismatch",
+            "Nacos v1 console API is disabled on this server. DBX already tried the v3 console state API first; please check that Server points to the Nacos console/admin URL and Context Path matches the console mount path.",
+        );
+    }
+    classified_error(
+        classify_nacos_error(&joined),
+        &format!("Failed to detect Nacos admin endpoint at {server_addr}: {}", joined.trim()),
+    )
+}
+
+fn push_optional(params: &mut Vec<(String, String)>, key: &str, value: Option<String>) {
+    if let Some(value) = value.map(|v| v.trim().to_string()).filter(|v| !v.is_empty()) {
+        params.push((key.to_string(), value));
+    }
+}
+
+fn build_publish_forms(req: NacosConfigUpsert, namespace: String) -> (Vec<(String, String)>, Vec<(String, String)>) {
+    let mut v3_form = vec![
+        ("dataId".to_string(), req.data_id.clone()),
+        ("groupName".to_string(), req.group.clone()),
+        ("content".to_string(), req.content.clone()),
+        ("namespaceId".to_string(), namespace.clone()),
+    ];
+    push_optional(&mut v3_form, "type", req.config_type.clone());
+    push_optional(&mut v3_form, "appName", req.app_name.clone());
+    push_optional(&mut v3_form, "desc", req.desc.clone());
+    push_optional(&mut v3_form, "configTags", req.tags.clone());
+    push_optional(&mut v3_form, "config_tags", req.tags.clone());
+
+    let mut v1_form = vec![
+        ("dataId".to_string(), req.data_id),
+        ("group".to_string(), req.group),
+        ("content".to_string(), req.content),
+        ("tenant".to_string(), namespace),
+    ];
+    push_optional(&mut v1_form, "type", req.config_type);
+    push_optional(&mut v1_form, "appName", req.app_name);
+    push_optional(&mut v1_form, "desc", req.desc);
+    push_optional(&mut v1_form, "config_tags", req.tags);
+
+    (v3_form, v1_form)
+}
+
+fn namespace_list_error(v3_err: &str, v1_err: &str) -> String {
+    let message = format!("Failed to list Nacos namespaces with v3 and v1 APIs. v3: {v3_err}; v1: {v1_err}");
+    classified_error(classify_nacos_error(&message), &message)
+}
+
+async fn response_json_or_text(resp: reqwest::Response) -> Result<Value, String> {
+    let bytes = resp.bytes().await.map_err(|e| format!("Failed to read Nacos response: {e}"))?;
+    if bytes.is_empty() {
+        return Ok(Value::Null);
+    }
+    Ok(serde_json::from_slice(&bytes).unwrap_or_else(|_| Value::String(String::from_utf8_lossy(&bytes).to_string())))
+}
+
+async fn error_for_status(resp: reqwest::Response, path: &str) -> Result<reqwest::Response, String> {
+    let status = resp.status();
+    if status.is_success() {
+        return Ok(resp);
+    }
+    let detail = resp.text().await.unwrap_or_default();
+    let message = format!("Nacos admin {path} returned {status}: {}", detail.trim());
+    Err(classified_error(classify_nacos_error(&message), &message))
+}
+
+fn classified_error(kind: &str, message: &str) -> String {
+    format!("{NACOS_ERROR_PREFIX}[{kind}]: {message}")
+}
+
+fn classify_nacos_error(message: &str) -> &'static str {
+    let lower = message.to_ascii_lowercase();
+    if lower.contains("unauthorized")
+        || lower.contains("forbidden")
+        || lower.contains("403")
+        || lower.contains("401")
+        || lower.contains("invalid username")
+        || lower.contains("invalid password")
+        || lower.contains("access token")
+        || lower.contains("authentication")
+    {
+        return "authFailed";
+    }
+    if lower.contains("no static resource") || lower.contains("context path") {
+        return "contextPathMismatch";
+    }
+    if lower.contains("history")
+        && (lower.contains("unsupportedconfighistory") || lower.contains("not found") || lower.contains("404"))
+    {
+        return "unsupportedConfigHistory";
+    }
+    if lower.contains("410 gone") || lower.contains("not found") || lower.contains("404") {
+        return "apiVersionMismatch";
+    }
+    if lower.contains("connection refused")
+        || lower.contains("failed to connect")
+        || lower.contains("timed out")
+        || lower.contains("dns error")
+        || lower.contains("nodename nor servname")
+    {
+        return "connectionFailed";
+    }
+    "requestFailed"
+}
+
+fn extract_server_version(raw: &Value) -> Option<String> {
+    raw.get("version")
+        .or_else(|| raw.get("serverVersion"))
+        .or_else(|| raw.pointer("/servers/0/version"))
+        .and_then(Value::as_str)
+        .map(str::to_string)
+}
+
+fn parse_config_list(value: Value, namespace: String, page_no: u32, page_size: u32) -> NacosConfigList {
+    let data = value.get("data").unwrap_or(&value);
+    let total_count = data
+        .get("totalCount")
+        .or_else(|| data.get("total"))
+        .or_else(|| data.get("count"))
+        .or_else(|| value.get("totalCount"))
+        .or_else(|| value.get("total"))
+        .and_then(Value::as_u64)
+        .unwrap_or(0);
+    let items: Vec<NacosConfigItem> = data
+        .get("pageItems")
+        .or_else(|| data.get("items"))
+        .or_else(|| data.get("list"))
+        .or_else(|| value.get("pageItems"))
+        .or_else(|| value.get("items"))
+        .and_then(Value::as_array)
+        .cloned()
+        .unwrap_or_default()
+        .into_iter()
+        .map(|item| NacosConfigItem {
+            data_id: string_field(&item, &["dataId", "data_id"]),
+            group: string_field(&item, &["group", "groupName"]),
+            namespace: string_field(&item, &["tenant", "namespaceId"]).if_empty(&namespace),
+            app_name: optional_string_field(&item, &["appName", "app_name"]),
+            desc: optional_string_field(&item, &["desc", "description"]),
+            tags: optional_string_field(&item, &["tags", "configTags", "config_tags"]),
+            config_type: config_format_for_item(&item),
+            md5: optional_string_field(&item, &["md5"]),
+            encrypted_data_key: optional_string_field(&item, &["encryptedDataKey"]),
+            content: optional_string_field(&item, &["content"]),
+        })
+        .collect();
+    NacosConfigList { page_no, page_size, total_count, items }
+}
+
+fn parse_config_detail(value: Value, data_id: String, group: String, namespace: String) -> NacosConfigItem {
+    let data = value.get("data").filter(|value| value.is_object()).unwrap_or(&value);
+    NacosConfigItem {
+        data_id: string_field(data, &["dataId", "data_id"]).if_empty(&data_id),
+        group: string_field(data, &["group", "groupName"]).if_empty(&group),
+        namespace: string_field(data, &["tenant", "namespaceId"]).if_empty(&namespace),
+        app_name: optional_string_field(data, &["appName", "app_name"]),
+        desc: optional_string_field(data, &["desc", "description"]),
+        tags: optional_string_field(data, &["tags", "configTags", "config_tags"]),
+        config_type: config_format_for_item(data).or_else(|| infer_config_format(&data_id)),
+        md5: optional_string_field(data, &["md5"]),
+        encrypted_data_key: optional_string_field(data, &["encryptedDataKey"]),
+        content: optional_string_field(data, &["content"]).or_else(|| value.as_str().map(str::to_string)),
+    }
+}
+
+fn parse_config_history_list(
+    value: Value,
+    namespace: String,
+    page_no: u32,
+    page_size: u32,
+    data_id: &str,
+    group: &str,
+) -> NacosConfigHistoryList {
+    let data = value.get("data").unwrap_or(&value);
+    let direct_items = if data.is_array() { data.as_array() } else { value.as_array() };
+    let total_count = data
+        .get("totalCount")
+        .or_else(|| data.get("total"))
+        .or_else(|| data.get("count"))
+        .or_else(|| value.get("totalCount"))
+        .or_else(|| value.get("total"))
+        .and_then(Value::as_u64)
+        .unwrap_or(0);
+    let items: Vec<NacosConfigHistoryItem> = data
+        .get("pageItems")
+        .or_else(|| data.get("items"))
+        .or_else(|| data.get("list"))
+        .or_else(|| value.get("pageItems"))
+        .or_else(|| value.get("items"))
+        .and_then(Value::as_array)
+        .or(direct_items)
+        .cloned()
+        .unwrap_or_default()
+        .into_iter()
+        .map(|item| parse_config_history_item(item, &namespace, data_id, group))
+        .collect();
+    let total_count = if total_count == 0 { items.len() as u64 } else { total_count };
+    NacosConfigHistoryList { page_no, page_size, total_count, items }
+}
+
+fn parse_config_history_item(
+    item: Value,
+    namespace: &str,
+    fallback_data_id: &str,
+    fallback_group: &str,
+) -> NacosConfigHistoryItem {
+    let history_id = optional_string_field(&item, &["id", "historyId", "nid"])
+        .or_else(|| optional_i64_field(&item, &["id", "historyId", "nid"]).map(|value| value.to_string()))
+        .unwrap_or_default();
+    NacosConfigHistoryItem {
+        history_id,
+        nid: optional_i64_field(&item, &["nid"]).or_else(|| optional_i64_field(&item, &["id", "historyId"])),
+        data_id: string_field(&item, &["dataId", "data_id"]).if_empty(fallback_data_id),
+        group: string_field(&item, &["group", "groupName"]).if_empty(fallback_group),
+        namespace: string_field(&item, &["tenant", "namespaceId"]).if_empty(namespace),
+        app_name: optional_string_field(&item, &["appName", "app_name"]),
+        operation: optional_string_field(&item, &["opType", "operation", "operateType", "type"]),
+        operator: optional_string_field(&item, &["operator", "srcUser", "createUser", "modifyUser", "user"]),
+        last_modified_time: optional_string_field(
+            &item,
+            &["lastModifiedTime", "lastModifiedTs", "gmtModified", "modifiedTime", "opTime", "createdTime"],
+        )
+        .or_else(|| {
+            optional_u64_field(
+                &item,
+                &["lastModifiedTime", "lastModifiedTs", "gmtModified", "modifiedTime", "opTime", "createdTime"],
+            )
+            .map(|value| value.to_string())
+        }),
+        config_type: config_format_for_item(&item),
+        tags: optional_string_field(&item, &["tags", "configTags", "config_tags"]),
+        md5: optional_string_field(&item, &["md5"]),
+    }
+}
+
+fn parse_config_history_detail(value: Value, data_id: String, group: String, namespace: String) -> NacosConfigItem {
+    parse_config_detail(value, data_id, group, namespace)
+}
+
+fn parse_service_list(value: Value, page_no: u32, page_size: u32) -> NacosServiceList {
+    let data = value.get("data").unwrap_or(&value);
+    let total_count = data
+        .get("count")
+        .or_else(|| data.get("totalCount"))
+        .or_else(|| data.get("total"))
+        .or_else(|| value.get("count"))
+        .or_else(|| value.get("totalCount"))
+        .and_then(Value::as_u64)
+        .unwrap_or(0);
+    let items_value = data
+        .get("doms")
+        .or_else(|| data.get("serviceList"))
+        .or_else(|| data.get("services"))
+        .or_else(|| data.get("list"))
+        .or_else(|| data.get("pageItems"))
+        .or_else(|| data.get("items"))
+        .or_else(|| value.get("doms"))
+        .or_else(|| value.get("serviceList"))
+        .or_else(|| value.get("services"))
+        .or_else(|| value.get("list"))
+        .or_else(|| value.get("pageItems"));
+    let items: Vec<NacosServiceInfo> = items_value
+        .and_then(Value::as_array)
+        .cloned()
+        .unwrap_or_default()
+        .into_iter()
+        .map(|item| {
+            if let Some(name) = item.as_str() {
+                let (group_name, service_name) = split_nacos_service_name(name);
+                NacosServiceInfo {
+                    service_name,
+                    group_name,
+                    cluster_count: None,
+                    ip_count: None,
+                    healthy_instance_count: None,
+                    trigger_flag: None,
+                }
+            } else {
+                let raw_name = string_field(&item, &["name", "serviceName"]);
+                let (embedded_group_name, service_name) = split_nacos_service_name(&raw_name);
+                NacosServiceInfo {
+                    service_name,
+                    group_name: optional_string_field(&item, &["groupName"]).or(embedded_group_name),
+                    cluster_count: optional_u64_field(&item, &["clusterCount"]),
+                    ip_count: optional_u64_field(&item, &["ipCount"]),
+                    healthy_instance_count: optional_u64_field(&item, &["healthyInstanceCount"]),
+                    trigger_flag: optional_string_field(&item, &["triggerFlag"]),
+                }
+            }
+        })
+        .collect();
+    let total_count = if total_count == 0 { items.len() as u64 } else { total_count };
+    NacosServiceList { page_no, page_size, total_count, items }
+}
+
+fn split_nacos_service_name(value: &str) -> (Option<String>, String) {
+    let trimmed = value.trim();
+    if let Some((group, name)) = trimmed.split_once("@@") {
+        let group = group.trim();
+        let name = name.trim();
+        if !group.is_empty() && !name.is_empty() {
+            return (Some(group.to_string()), name.to_string());
+        }
+    }
+    (None, trimmed.to_string())
+}
+
+fn parse_instances(value: Value) -> Vec<NacosInstanceInfo> {
+    let data = value.get("data").unwrap_or(&value);
+    data.get("hosts")
+        .or_else(|| data.get("instances"))
+        .or_else(|| data.get("pageItems"))
+        .or_else(|| data.get("items"))
+        .or_else(|| value.get("hosts"))
+        .or_else(|| value.get("instances"))
+        .and_then(Value::as_array)
+        .cloned()
+        .unwrap_or_default()
+        .into_iter()
+        .map(|item| NacosInstanceInfo {
+            ip: string_field(&item, &["ip"]),
+            port: item.get("port").and_then(Value::as_u64).unwrap_or(0) as u16,
+            service_name: optional_string_field(&item, &["serviceName"]),
+            cluster_name: optional_string_field(&item, &["clusterName"]),
+            group_name: optional_string_field(&item, &["groupName"]),
+            healthy: item.get("healthy").and_then(Value::as_bool),
+            enabled: item.get("enabled").and_then(Value::as_bool),
+            ephemeral: item.get("ephemeral").and_then(Value::as_bool),
+            weight: item.get("weight").and_then(Value::as_f64),
+            metadata: item.get("metadata").cloned().unwrap_or(Value::Null),
+        })
+        .collect()
+}
+
+fn string_field(value: &Value, keys: &[&str]) -> String {
+    optional_string_field(value, keys).unwrap_or_default()
+}
+
+fn optional_string_field(value: &Value, keys: &[&str]) -> Option<String> {
+    keys.iter()
+        .find_map(|key| value.get(*key))
+        .and_then(|value| {
+            value
+                .as_str()
+                .map(str::to_string)
+                .or_else(|| value.as_i64().map(|v| v.to_string()))
+                .or_else(|| value.as_u64().map(|v| v.to_string()))
+        })
+        .filter(|value| !value.is_empty())
+}
+
+fn config_format_for_item(item: &Value) -> Option<String> {
+    optional_string_field(
+        item,
+        &[
+            "type",
+            "configType",
+            "config_type",
+            "configFormat",
+            "config_format",
+            "configTypeName",
+            "config_type_name",
+            "format",
+            "contentType",
+            "content_type",
+            "fileType",
+            "file_type",
+        ],
+    )
+    .or_else(|| optional_string_field(item, &["dataId", "data_id"]).and_then(|data_id| infer_config_format(&data_id)))
+    .map(normalize_config_format)
+}
+
+fn infer_config_format(data_id: &str) -> Option<String> {
+    let name = data_id.trim().to_ascii_lowercase();
+    let ext = name.rsplit_once('.').map(|(_, ext)| ext)?;
+    match ext {
+        "yaml" | "yml" => Some("yaml".to_string()),
+        "json" => Some("json".to_string()),
+        "xml" => Some("xml".to_string()),
+        "html" | "htm" => Some("html".to_string()),
+        "properties" | "props" => Some("properties".to_string()),
+        "txt" | "text" => Some("text".to_string()),
+        _ => None,
+    }
+}
+
+fn normalize_config_format(value: String) -> String {
+    match value.trim().to_ascii_lowercase().as_str() {
+        "txt" => "text".to_string(),
+        "yml" => "yaml".to_string(),
+        "props" => "properties".to_string(),
+        other if !other.is_empty() => other.to_string(),
+        _ => value,
+    }
+}
+
+fn optional_u64_field(value: &Value, keys: &[&str]) -> Option<u64> {
+    keys.iter().find_map(|key| value.get(*key)).and_then(Value::as_u64)
+}
+
+fn optional_i64_field(value: &Value, keys: &[&str]) -> Option<i64> {
+    keys.iter()
+        .find_map(|key| value.get(*key))
+        .and_then(|value| value.as_i64().or_else(|| value.as_u64().and_then(|value| i64::try_from(value).ok())))
+}
+
+fn response_headers(headers: &HeaderMap) -> HashMap<String, String> {
+    headers
+        .iter()
+        .filter_map(|(name, value): (&reqwest::header::HeaderName, &HeaderValue)| {
+            value.to_str().ok().map(|value| (name.as_str().to_string(), value.to_string()))
+        })
+        .collect()
+}
+
+trait EmptyFallback {
+    fn if_empty(self, fallback: &str) -> String;
+}
+
+impl EmptyFallback for String {
+    fn if_empty(self, fallback: &str) -> String {
+        if self.trim().is_empty() {
+            fallback.to_string()
+        } else {
+            self
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_config_list_shapes() {
+        let parsed = parse_config_list(
+            serde_json::json!({
+                "totalCount": 1,
+                "pageItems": [{ "dataId": "app.yaml", "group": "DEFAULT_GROUP", "type": "yaml", "appName": "portal" }]
+            }),
+            "public".to_string(),
+            1,
+            20,
+        );
+        assert_eq!(parsed.total_count, 1);
+        assert_eq!(parsed.items[0].data_id, "app.yaml");
+        assert_eq!(parsed.items[0].namespace, "public");
+        assert_eq!(parsed.items[0].app_name.as_deref(), Some("portal"));
+        assert_eq!(parsed.items[0].config_type.as_deref(), Some("yaml"));
+    }
+
+    #[test]
+    fn infers_config_format_when_list_shape_omits_type() {
+        let parsed = parse_config_list(
+            serde_json::json!({
+                "totalCount": 2,
+                "pageItems": [
+                    { "dataId": "application-dev.yml", "group": "DEFAULT_GROUP" },
+                    { "dataId": "feature.properties", "group": "DEFAULT_GROUP", "configType": "" }
+                ]
+            }),
+            "public".to_string(),
+            1,
+            20,
+        );
+        assert_eq!(parsed.items[0].config_type.as_deref(), Some("yaml"));
+        assert_eq!(parsed.items[1].config_type.as_deref(), Some("properties"));
+    }
+
+    #[test]
+    fn normalizes_txt_config_format_from_list_shape() {
+        let parsed = parse_config_list(
+            serde_json::json!({
+                "totalCount": 2,
+                "pageItems": [
+                    { "dataId": "qilong-test1", "group": "qilong-test", "type": "txt" },
+                    { "dataId": "qilong-test2", "group": "qilong-test", "configTypeName": "TXT" }
+                ]
+            }),
+            "public".to_string(),
+            1,
+            20,
+        );
+        assert_eq!(parsed.items[0].config_type.as_deref(), Some("text"));
+        assert_eq!(parsed.items[1].config_type.as_deref(), Some("text"));
+    }
+
+    #[test]
+    fn parses_v3_config_list_data_shape() {
+        let parsed = parse_config_list(
+            serde_json::json!({
+                "code": 0,
+                "data": {
+                    "totalCount": 1,
+                    "pageItems": [
+                        { "dataId": "app.json", "groupName": "DEFAULT_GROUP", "namespaceId": "public", "appName": "console" }
+                    ]
+                }
+            }),
+            "public".to_string(),
+            1,
+            20,
+        );
+        assert_eq!(parsed.total_count, 1);
+        assert_eq!(parsed.items[0].group, "DEFAULT_GROUP");
+        assert_eq!(parsed.items[0].app_name.as_deref(), Some("console"));
+        assert_eq!(parsed.items[0].config_type.as_deref(), Some("json"));
+    }
+
+    #[test]
+    fn parses_v3_config_detail_data_shape() {
+        let parsed = parse_config_detail(
+            serde_json::json!({
+                "code": 0,
+                "data": {
+                    "dataId": "ttt",
+                    "groupName": "test",
+                    "namespaceId": "ops",
+                    "type": "text",
+                    "content": "hello"
+                }
+            }),
+            "fallback".to_string(),
+            "DEFAULT_GROUP".to_string(),
+            "public".to_string(),
+        );
+        assert_eq!(parsed.data_id, "ttt");
+        assert_eq!(parsed.group, "test");
+        assert_eq!(parsed.namespace, "ops");
+        assert_eq!(parsed.config_type.as_deref(), Some("text"));
+        assert_eq!(parsed.content.as_deref(), Some("hello"));
+    }
+
+    #[test]
+    fn builds_v3_publish_form_fields() {
+        let (v3_form, v1_form) = build_publish_forms(
+            NacosConfigUpsert {
+                namespace: Some("ops".to_string()),
+                data_id: "app.yaml".to_string(),
+                group: "DEFAULT_GROUP".to_string(),
+                content: "server:\n  port: 8080".to_string(),
+                config_type: Some("yaml".to_string()),
+                app_name: Some("portal".to_string()),
+                desc: Some("main config".to_string()),
+                tags: Some("prod,gray".to_string()),
+            },
+            "ops".to_string(),
+        );
+
+        assert!(v3_form.contains(&("dataId".to_string(), "app.yaml".to_string())));
+        assert!(v3_form.contains(&("groupName".to_string(), "DEFAULT_GROUP".to_string())));
+        assert!(v3_form.contains(&("namespaceId".to_string(), "ops".to_string())));
+        assert!(v3_form.contains(&("content".to_string(), "server:\n  port: 8080".to_string())));
+        assert!(v3_form.contains(&("type".to_string(), "yaml".to_string())));
+        assert!(v3_form.contains(&("configTags".to_string(), "prod,gray".to_string())));
+        assert!(v3_form.contains(&("config_tags".to_string(), "prod,gray".to_string())));
+        assert!(v1_form.contains(&("group".to_string(), "DEFAULT_GROUP".to_string())));
+        assert!(v1_form.contains(&("tenant".to_string(), "ops".to_string())));
+    }
+
+    #[test]
+    fn namespace_list_error_keeps_v3_and_v1_details() {
+        let err = namespace_list_error(
+            "NACOS_ERROR[authFailed]: Nacos admin /v3/console/core/namespace/list returned 403 Forbidden",
+            "NACOS_ERROR[apiVersionMismatch]: Nacos admin /v1/console/namespaces returned 410 Gone",
+        );
+        assert!(err.starts_with("NACOS_ERROR[authFailed]:"));
+        assert!(err.contains("/v3/console/core/namespace/list returned 403 Forbidden"));
+        assert!(err.contains("/v1/console/namespaces returned 410 Gone"));
+    }
+
+    #[test]
+    fn parses_v1_show_all_config_detail_metadata() {
+        let parsed = parse_config_detail(
+            serde_json::json!({
+                "dataId": "qilong-test1",
+                "group": "qilong-test",
+                "tenant": "opsmanage",
+                "type": "yaml",
+                "config_tags": "prod,gray",
+                "content": "cloud_providers:\n  aliyun: {}\n"
+            }),
+            "fallback".to_string(),
+            "DEFAULT_GROUP".to_string(),
+            "public".to_string(),
+        );
+        assert_eq!(parsed.data_id, "qilong-test1");
+        assert_eq!(parsed.group, "qilong-test");
+        assert_eq!(parsed.namespace, "opsmanage");
+        assert_eq!(parsed.config_type.as_deref(), Some("yaml"));
+        assert_eq!(parsed.tags.as_deref(), Some("prod,gray"));
+        assert_eq!(parsed.content.as_deref(), Some("cloud_providers:\n  aliyun: {}\n"));
+    }
+
+    #[test]
+    fn parses_config_history_list_shapes() {
+        let parsed = parse_config_history_list(
+            serde_json::json!({
+                "data": {
+                    "totalCount": 1,
+                    "pageItems": [{
+                        "id": "42",
+                        "nid": 1001,
+                        "dataId": "app.yaml",
+                        "groupName": "DEFAULT_GROUP",
+                        "namespaceId": "ops",
+                        "appName": "portal",
+                        "opType": "U",
+                        "srcUser": "nacos",
+                        "lastModifiedTime": 1710000000000i64,
+                        "type": "yaml",
+                        "config_tags": "gray"
+                    }]
+                }
+            }),
+            "public".to_string(),
+            1,
+            20,
+            "fallback.yaml",
+            "DEFAULT_GROUP",
+        );
+        assert_eq!(parsed.total_count, 1);
+        assert_eq!(parsed.items[0].history_id, "42");
+        assert_eq!(parsed.items[0].nid, Some(1001));
+        assert_eq!(parsed.items[0].data_id, "app.yaml");
+        assert_eq!(parsed.items[0].group, "DEFAULT_GROUP");
+        assert_eq!(parsed.items[0].namespace, "ops");
+        assert_eq!(parsed.items[0].operator.as_deref(), Some("nacos"));
+        assert_eq!(parsed.items[0].last_modified_time.as_deref(), Some("1710000000000"));
+        assert_eq!(parsed.items[0].config_type.as_deref(), Some("yaml"));
+    }
+
+    #[test]
+    fn parses_config_history_list_array_shape() {
+        let parsed = parse_config_history_list(
+            serde_json::json!({
+                "data": [
+                    { "id": 7, "dataId": "app.yaml", "group": "DEFAULT_GROUP", "tenant": "ops", "opType": "publish" }
+                ]
+            }),
+            "public".to_string(),
+            1,
+            20,
+            "fallback.yaml",
+            "DEFAULT_GROUP",
+        );
+        assert_eq!(parsed.total_count, 1);
+        assert_eq!(parsed.items[0].history_id, "7");
+        assert_eq!(parsed.items[0].nid, Some(7));
+        assert_eq!(parsed.items[0].namespace, "ops");
+        assert_eq!(parsed.items[0].operation.as_deref(), Some("publish"));
+    }
+
+    #[test]
+    fn parses_config_history_detail_shape() {
+        let parsed = parse_config_history_detail(
+            serde_json::json!({
+                "data": {
+                    "dataId": "app.properties",
+                    "group": "DEFAULT_GROUP",
+                    "tenant": "ops",
+                    "content": "server.port=8080",
+                    "config_tags": "prod"
+                }
+            }),
+            "fallback".to_string(),
+            "group".to_string(),
+            "public".to_string(),
+        );
+        assert_eq!(parsed.data_id, "app.properties");
+        assert_eq!(parsed.namespace, "ops");
+        assert_eq!(parsed.content.as_deref(), Some("server.port=8080"));
+        assert_eq!(parsed.config_type.as_deref(), Some("properties"));
+        assert_eq!(parsed.tags.as_deref(), Some("prod"));
+    }
+
+    #[test]
+    fn parses_service_list_string_shape() {
+        let parsed = parse_service_list(serde_json::json!({ "count": 1, "doms": ["DEFAULT_GROUP@@svc"] }), 1, 20);
+        assert_eq!(parsed.items[0].service_name, "svc");
+        assert_eq!(parsed.items[0].group_name.as_deref(), Some("DEFAULT_GROUP"));
+    }
+
+    #[test]
+    fn parses_v3_service_list_data_shape() {
+        let parsed = parse_service_list(
+            serde_json::json!({
+                "code": 0,
+                "data": {
+                    "totalCount": 1,
+                    "pageItems": [
+                        { "serviceName": "svc", "groupName": "DEFAULT_GROUP", "ipCount": 2 }
+                    ]
+                }
+            }),
+            1,
+            20,
+        );
+        assert_eq!(parsed.total_count, 1);
+        assert_eq!(parsed.items[0].service_name, "svc");
+        assert_eq!(parsed.items[0].group_name.as_deref(), Some("DEFAULT_GROUP"));
+    }
+
+    #[test]
+    fn parses_catalog_service_list_shape() {
+        let parsed = parse_service_list(
+            serde_json::json!({
+                "count": 2,
+                "serviceList": [
+                    { "name": "dev@@rokid-device-service", "ipCount": 3 },
+                    { "serviceName": "DEFAULT_GROUP@@coze_plugin_service", "groupName": "DEFAULT_GROUP" }
+                ]
+            }),
+            1,
+            20,
+        );
+        assert_eq!(parsed.total_count, 2);
+        assert_eq!(parsed.items[0].service_name, "rokid-device-service");
+        assert_eq!(parsed.items[0].group_name.as_deref(), Some("dev"));
+        assert_eq!(parsed.items[1].service_name, "coze_plugin_service");
+        assert_eq!(parsed.items[1].group_name.as_deref(), Some("DEFAULT_GROUP"));
+    }
+
+    #[test]
+    fn parses_v3_instance_list_data_shape() {
+        let parsed = parse_instances(serde_json::json!({
+            "code": 0,
+            "data": {
+                "hosts": [
+                    { "ip": "127.0.0.1", "port": 8848, "healthy": true }
+                ]
+            }
+        }));
+        assert_eq!(parsed[0].ip, "127.0.0.1");
+        assert_eq!(parsed[0].port, 8848);
+        assert_eq!(parsed[0].healthy, Some(true));
+    }
+
+    #[test]
+    fn parses_namespace_list_shape() {
+        let parsed = parse_namespaces(serde_json::json!({
+            "code": 200,
+            "data": [
+                { "namespace": "", "namespaceShowName": "public", "configCount": 2 },
+                { "namespace": "dev", "namespaceShowName": "Development", "namespaceDesc": "dev ns" }
+            ]
+        }));
+        assert_eq!(parsed[0].namespace_show_name, "public");
+        assert_eq!(parsed[1].namespace, "dev");
+        assert_eq!(parsed[1].namespace_desc.as_deref(), Some("dev ns"));
+    }
+
+    #[test]
+    fn parses_v3_namespace_page_shape() {
+        let parsed = parse_namespaces(serde_json::json!({
+            "code": 0,
+            "data": {
+                "pageItems": [
+                    { "namespaceId": "dev", "namespaceName": "Development", "namespaceDesc": "dev ns" }
+                ]
+            }
+        }));
+        assert_eq!(parsed[0].namespace, "");
+        assert_eq!(parsed[1].namespace, "dev");
+        assert_eq!(parsed[1].namespace_show_name, "Development");
+    }
+
+    #[test]
+    fn validates_raw_api_paths() {
+        for path in ["/v1/cs/configs", "/v2/console/example", "/v3/console/server/state"] {
+            validate_raw_api_path(path).unwrap();
+        }
+
+        for path in [
+            "",
+            "v1/cs/configs",
+            "https://nacos.example.com/v1/cs/configs",
+            "//nacos.example.com/v1/cs/configs",
+            "/api/v1/cs/configs",
+            "/v1/../operator",
+            "/v3\\console\\server",
+        ] {
+            let err = validate_raw_api_path(path).unwrap_err();
+            assert!(err.contains("NACOS_ERROR[invalidRawPath]"), "{path}: {err}");
+        }
+    }
+
+    #[test]
+    fn classifies_common_nacos_errors() {
+        assert_eq!(classify_nacos_error("401 Unauthorized invalid access token"), "authFailed");
+        assert_eq!(classify_nacos_error("No static resource nacos/v3/console/server/state"), "contextPathMismatch");
+        assert_eq!(
+            classify_nacos_error(
+                r#"410 Gone {"message":"Current API will be deprecated","path":"/v1/console/namespaces"}"#
+            ),
+            "apiVersionMismatch"
+        );
+        assert_eq!(classify_nacos_error("404 Not Found"), "apiVersionMismatch");
+        assert_eq!(classify_nacos_error("connection refused"), "connectionFailed");
+    }
+}
diff --git a/crates/dbx-core/src/nacos/mod.rs b/crates/dbx-core/src/nacos/mod.rs
new file mode 100644
index 0000000..9d60c39
--- /dev/null
+++ b/crates/dbx-core/src/nacos/mod.rs
@@ -0,0 +1,89 @@
+//! Nacos admin console support.
+//!
+//! The public API is intentionally owned by dbx (`NacosAdmin`) instead of
+//! exposing SDK/OpenAPI types. The current adapter uses Nacos OpenAPI because
+//! the current nacos-sdk-rust releases require Rust edition 2024, while dbx
+//! still supports an older Rust toolchain. A future SDK adapter can implement
+//! the same port without changing commands, routes, or frontend contracts.
+
+pub mod config;
+pub mod http;
+pub mod port;
+pub mod service;
+pub mod types;
+
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use tokio::sync::{Mutex, RwLock};
+
+use crate::models::connection::ConnectionConfig;
+use crate::nacos::config::NacosAdminConfig;
+use crate::nacos::http::NacosOpenApiAdmin;
+use crate::nacos::port::NacosAdmin;
+
+pub use crate::nacos::config::{NacosAdminConfig as NacosConfig, NacosAuthConfig};
+pub use crate::nacos::types::*;
+
+#[derive(Default)]
+pub struct NacosAdminRegistry {
+    instances: RwLock<HashMap<String, (NacosAdminConfig, Arc<dyn NacosAdmin>)>>,
+    build_locks: RwLock<HashMap<String, Arc<Mutex<()>>>>,
+}
+
+impl NacosAdminRegistry {
+    pub fn new() -> Self {
+        Self { instances: RwLock::new(HashMap::new()), build_locks: RwLock::new(HashMap::new()) }
+    }
+
+    pub async fn get_or_build(&self, cfg: &ConnectionConfig) -> Result<Arc<dyn NacosAdmin>, String> {
+        let admin_config = NacosAdminConfig::from_connection(cfg)?;
+        self.get_or_build_config(&cfg.id, admin_config).await
+    }
+
+    pub async fn get_or_build_config(
+        &self,
+        connection_id: &str,
+        cfg: NacosAdminConfig,
+    ) -> Result<Arc<dyn NacosAdmin>, String> {
+        if let Some((existing_cfg, admin)) = self.instances.read().await.get(connection_id) {
+            if existing_cfg == &cfg {
+                return Ok(admin.clone());
+            }
+        }
+
+        let lock = {
+            let mut locks = self.build_locks.write().await;
+            locks.entry(connection_id.to_string()).or_insert_with(|| Arc::new(Mutex::new(()))).clone()
+        };
+        let _guard = lock.lock().await;
+
+        if let Some((existing_cfg, admin)) = self.instances.read().await.get(connection_id) {
+            if existing_cfg == &cfg {
+                return Ok(admin.clone());
+            }
+        }
+
+        let admin = build_admin(cfg.clone())?;
+        self.instances.write().await.insert(connection_id.to_string(), (cfg, admin.clone()));
+        Ok(admin)
+    }
+
+    pub async fn build_transient(&self, cfg: &ConnectionConfig) -> Result<Arc<dyn NacosAdmin>, String> {
+        let admin_config = NacosAdminConfig::from_connection(cfg)?;
+        self.build_transient_config(admin_config).await
+    }
+
+    pub async fn build_transient_config(&self, cfg: NacosAdminConfig) -> Result<Arc<dyn NacosAdmin>, String> {
+        build_admin(cfg)
+    }
+
+    pub async fn drop_connection(&self, connection_id: &str) {
+        self.instances.write().await.remove(connection_id);
+        self.build_locks.write().await.remove(connection_id);
+    }
+}
+
+fn build_admin(cfg: NacosAdminConfig) -> Result<Arc<dyn NacosAdmin>, String> {
+    Ok(Arc::new(NacosOpenApiAdmin::new(cfg)?))
+}
diff --git a/crates/dbx-core/src/nacos/port.rs b/crates/dbx-core/src/nacos/port.rs
new file mode 100644
index 0000000..abf3ab7
--- /dev/null
+++ b/crates/dbx-core/src/nacos/port.rs
@@ -0,0 +1,22 @@
+use async_trait::async_trait;
+
+use crate::nacos::types::*;
+
+#[async_trait]
+pub trait NacosAdmin: Send + Sync {
+    async fn test_connection(&self) -> Result<NacosConnectionInfo, String>;
+    async fn list_namespaces(&self) -> Result<Vec<NacosNamespaceInfo>, String>;
+    async fn create_namespace(&self, req: NacosNamespaceCreate) -> Result<(), String>;
+    async fn update_namespace(&self, req: NacosNamespaceUpdate) -> Result<(), String>;
+    async fn list_configs(&self, query: NacosConfigQuery) -> Result<NacosConfigList, String>;
+    async fn get_config(&self, key: NacosConfigKey) -> Result<NacosConfigItem, String>;
+    async fn publish_config(&self, req: NacosConfigUpsert) -> Result<(), String>;
+    async fn delete_config(&self, key: NacosConfigKey) -> Result<(), String>;
+    async fn list_config_history(&self, query: NacosConfigHistoryQuery) -> Result<NacosConfigHistoryList, String>;
+    async fn get_config_history(&self, key: NacosConfigHistoryKey) -> Result<NacosConfigItem, String>;
+    async fn rollback_config(&self, req: NacosConfigRollbackRequest) -> Result<(), String>;
+    async fn list_services(&self, query: NacosServiceQuery) -> Result<NacosServiceList, String>;
+    async fn list_instances(&self, query: NacosInstanceQuery) -> Result<Vec<NacosInstanceInfo>, String>;
+    async fn update_instance(&self, req: NacosInstanceUpdate) -> Result<(), String>;
+    async fn raw_request(&self, req: NacosRawRequest) -> Result<NacosRawResponse, String>;
+}
diff --git a/crates/dbx-core/src/nacos/service.rs b/crates/dbx-core/src/nacos/service.rs
new file mode 100644
index 0000000..1ff15ba
--- /dev/null
+++ b/crates/dbx-core/src/nacos/service.rs
@@ -0,0 +1,302 @@
+use crate::connection::AppState;
+use crate::models::connection::DatabaseType;
+use crate::nacos::types::*;
+
+pub async fn nacos_test_connection_core(state: &AppState, conn_id: &str) -> Result<NacosConnectionInfo, String> {
+    let cfg = state.configs.read().await.get(conn_id).cloned().ok_or("Connection not found")?;
+    if cfg.db_type != DatabaseType::Nacos {
+        return Err("Connection is not a Nacos admin connection".to_string());
+    }
+    let admin_config = state.nacos_admin_config_for_connection(conn_id, &cfg).await?;
+    let admin = state.nacos_registry.build_transient_config(admin_config).await?;
+    admin.test_connection().await
+}
+
+pub async fn nacos_list_namespaces_core(state: &AppState, conn_id: &str) -> Result<Vec<NacosNamespaceInfo>, String> {
+    let admin = get_admin(state, conn_id).await?;
+    admin.list_namespaces().await
+}
+
+pub async fn nacos_create_namespace_core(
+    state: &AppState,
+    conn_id: &str,
+    req: NacosNamespaceCreate,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Create Nacos namespace").await?;
+    let admin = get_admin(state, conn_id).await?;
+    admin.create_namespace(req).await
+}
+
+pub async fn nacos_update_namespace_core(
+    state: &AppState,
+    conn_id: &str,
+    req: NacosNamespaceUpdate,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Update Nacos namespace").await?;
+    let admin = get_admin(state, conn_id).await?;
+    admin.update_namespace(req).await
+}
+
+pub async fn nacos_list_configs_core(
+    state: &AppState,
+    conn_id: &str,
+    query: NacosConfigQuery,
+) -> Result<NacosConfigList, String> {
+    let admin = get_admin(state, conn_id).await?;
+    admin.list_configs(query).await
+}
+
+pub async fn nacos_get_config_core(
+    state: &AppState,
+    conn_id: &str,
+    key: NacosConfigKey,
+) -> Result<NacosConfigItem, String> {
+    let admin = get_admin(state, conn_id).await?;
+    admin.get_config(key).await
+}
+
+pub async fn nacos_publish_config_core(state: &AppState, conn_id: &str, req: NacosConfigUpsert) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Publish Nacos config").await?;
+    let admin = get_admin(state, conn_id).await?;
+    admin.publish_config(req).await
+}
+
+pub async fn nacos_delete_config_core(state: &AppState, conn_id: &str, key: NacosConfigKey) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Delete Nacos config").await?;
+    let admin = get_admin(state, conn_id).await?;
+    admin.delete_config(key).await
+}
+
+pub async fn nacos_list_config_history_core(
+    state: &AppState,
+    conn_id: &str,
+    query: NacosConfigHistoryQuery,
+) -> Result<NacosConfigHistoryList, String> {
+    let admin = get_admin(state, conn_id).await?;
+    admin.list_config_history(query).await
+}
+
+pub async fn nacos_get_config_history_core(
+    state: &AppState,
+    conn_id: &str,
+    key: NacosConfigHistoryKey,
+) -> Result<NacosConfigItem, String> {
+    let admin = get_admin(state, conn_id).await?;
+    admin.get_config_history(key).await
+}
+
+pub async fn nacos_rollback_config_core(
+    state: &AppState,
+    conn_id: &str,
+    req: NacosConfigRollbackRequest,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Rollback Nacos config").await?;
+    let admin = get_admin(state, conn_id).await?;
+    admin.rollback_config(req).await
+}
+
+pub async fn nacos_list_services_core(
+    state: &AppState,
+    conn_id: &str,
+    query: NacosServiceQuery,
+) -> Result<NacosServiceList, String> {
+    let admin = get_admin(state, conn_id).await?;
+    admin.list_services(query).await
+}
+
+pub async fn nacos_list_instances_core(
+    state: &AppState,
+    conn_id: &str,
+    query: NacosInstanceQuery,
+) -> Result<Vec<NacosInstanceInfo>, String> {
+    let admin = get_admin(state, conn_id).await?;
+    admin.list_instances(query).await
+}
+
+pub async fn nacos_update_instance_core(
+    state: &AppState,
+    conn_id: &str,
+    req: NacosInstanceUpdate,
+) -> Result<(), String> {
+    ensure_connection_writable(state, conn_id, "Update Nacos instance").await?;
+    let admin = get_admin(state, conn_id).await?;
+    admin.update_instance(req).await
+}
+
+pub async fn nacos_raw_request_core(
+    state: &AppState,
+    conn_id: &str,
+    req: NacosRawRequest,
+) -> Result<NacosRawResponse, String> {
+    crate::nacos::http::validate_raw_api_path(&req.path)?;
+    if req.method.to_ascii_uppercase() != "GET" {
+        ensure_connection_writable(state, conn_id, "Run mutating Nacos raw request").await?;
+    }
+    let admin = get_admin(state, conn_id).await?;
+    admin.raw_request(req).await
+}
+
+async fn get_admin(
+    state: &AppState,
+    conn_id: &str,
+) -> Result<std::sync::Arc<dyn crate::nacos::port::NacosAdmin>, String> {
+    let cfg = state.configs.read().await.get(conn_id).cloned().ok_or("Connection not found")?;
+    if cfg.db_type != DatabaseType::Nacos {
+        return Err("Connection is not a Nacos admin connection".to_string());
+    }
+    let admin_config = state.nacos_admin_config_for_connection(conn_id, &cfg).await?;
+    state.nacos_registry.get_or_build_config(conn_id, admin_config).await
+}
+
+async fn ensure_connection_writable(state: &AppState, conn_id: &str, action: &str) -> Result<(), String> {
+    let cfg = state.configs.read().await.get(conn_id).cloned().ok_or("Connection not found")?;
+    if cfg.read_only {
+        Err(format!("{action} is blocked because this connection is read-only"))
+    } else {
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn raw_mutation_requires_writable_connection_before_adapter_build() {
+        let dir = std::env::temp_dir().join(format!("dbx-nacos-service-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = crate::storage::Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new(storage);
+        let mut cfg = crate::models::connection::ConnectionConfig {
+            id: "nacos-1".to_string(),
+            name: "Nacos".to_string(),
+            db_type: DatabaseType::Nacos,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 8848,
+            username: String::new(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: ":".to_string(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: Some(serde_json::json!({ "serverAddr": "http://127.0.0.1:9" })),
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: true,
+            is_production: false,
+            production_databases: Vec::new(),
+        };
+        cfg.read_only = true;
+        state.configs.write().await.insert(cfg.id.clone(), cfg);
+        let err = nacos_raw_request_core(
+            &state,
+            "nacos-1",
+            NacosRawRequest { method: "POST".to_string(), path: "/v1/cs/configs".to_string(), query: None, body: None },
+        )
+        .await
+        .unwrap_err();
+        assert!(err.contains("read-only"));
+    }
+
+    #[tokio::test]
+    async fn config_rollback_requires_writable_connection_before_adapter_build() {
+        let dir = std::env::temp_dir().join(format!("dbx-nacos-service-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = crate::storage::Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new(storage);
+        let cfg = crate::models::connection::ConnectionConfig {
+            id: "nacos-rollback".to_string(),
+            name: "Nacos".to_string(),
+            db_type: DatabaseType::Nacos,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 8848,
+            username: String::new(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: ":".to_string(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: Some(serde_json::json!({ "serverAddr": "http://127.0.0.1:9" })),
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: true,
+            is_production: false,
+            production_databases: Vec::new(),
+        };
+        state.configs.write().await.insert(cfg.id.clone(), cfg);
+        let err = nacos_rollback_config_core(
+            &state,
+            "nacos-rollback",
+            NacosConfigRollbackRequest {
+                namespace: None,
+                data_id: "app.yaml".to_string(),
+                group: "DEFAULT_GROUP".to_string(),
+                history_id: "1".to_string(),
+                nid: None,
+            },
+        )
+        .await
+        .unwrap_err();
+        assert!(err.contains("read-only"));
+    }
+}
diff --git a/crates/dbx-core/src/nacos/types.rs b/crates/dbx-core/src/nacos/types.rs
new file mode 100644
index 0000000..f7942d9
--- /dev/null
+++ b/crates/dbx-core/src/nacos/types.rs
@@ -0,0 +1,337 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosCapabilities {
+    pub supports_config_management: bool,
+    pub supports_config_history: bool,
+    pub supports_service_management: bool,
+    pub supports_instance_update: bool,
+    pub supports_raw_api: bool,
+}
+
+impl Default for NacosCapabilities {
+    fn default() -> Self {
+        Self {
+            supports_config_management: true,
+            supports_config_history: true,
+            supports_service_management: true,
+            supports_instance_update: true,
+            supports_raw_api: true,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConnectionInfo {
+    pub server_addr: String,
+    pub display_server_addr: String,
+    pub namespace: String,
+    pub server_version: Option<String>,
+    pub auth: String,
+    pub capabilities: NacosCapabilities,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub raw: Option<serde_json::Value>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosNamespaceInfo {
+    pub namespace: String,
+    pub namespace_show_name: String,
+    #[serde(default)]
+    pub namespace_desc: Option<String>,
+    #[serde(default)]
+    pub config_count: Option<u64>,
+    #[serde(default)]
+    pub quota: Option<u64>,
+    #[serde(default)]
+    pub namespace_type: Option<u64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosNamespaceCreate {
+    #[serde(default)]
+    pub namespace_id: Option<String>,
+    pub namespace_name: String,
+    #[serde(default)]
+    pub namespace_desc: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosNamespaceUpdate {
+    pub namespace_id: String,
+    pub namespace_name: String,
+    #[serde(default)]
+    pub namespace_desc: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConfigQuery {
+    #[serde(default)]
+    pub namespace: Option<String>,
+    #[serde(default)]
+    pub group: Option<String>,
+    #[serde(default)]
+    pub data_id: Option<String>,
+    #[serde(default)]
+    pub app_name: Option<String>,
+    #[serde(default)]
+    pub search: Option<String>,
+    #[serde(default)]
+    pub page_no: Option<u32>,
+    #[serde(default)]
+    pub page_size: Option<u32>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConfigItem {
+    pub data_id: String,
+    pub group: String,
+    pub namespace: String,
+    #[serde(default)]
+    pub app_name: Option<String>,
+    #[serde(default)]
+    pub desc: Option<String>,
+    #[serde(default)]
+    pub tags: Option<String>,
+    #[serde(default)]
+    pub config_type: Option<String>,
+    #[serde(default)]
+    pub md5: Option<String>,
+    #[serde(default)]
+    pub encrypted_data_key: Option<String>,
+    #[serde(default)]
+    pub content: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConfigList {
+    pub page_no: u32,
+    pub page_size: u32,
+    pub total_count: u64,
+    pub items: Vec<NacosConfigItem>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConfigUpsert {
+    #[serde(default)]
+    pub namespace: Option<String>,
+    pub data_id: String,
+    pub group: String,
+    pub content: String,
+    #[serde(default)]
+    pub config_type: Option<String>,
+    #[serde(default)]
+    pub app_name: Option<String>,
+    #[serde(default)]
+    pub desc: Option<String>,
+    #[serde(default)]
+    pub tags: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConfigKey {
+    #[serde(default)]
+    pub namespace: Option<String>,
+    pub data_id: String,
+    pub group: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConfigHistoryQuery {
+    #[serde(default)]
+    pub namespace: Option<String>,
+    pub data_id: String,
+    pub group: String,
+    #[serde(default)]
+    pub page_no: Option<u32>,
+    #[serde(default)]
+    pub page_size: Option<u32>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConfigHistoryItem {
+    pub history_id: String,
+    #[serde(default)]
+    pub nid: Option<i64>,
+    pub data_id: String,
+    pub group: String,
+    pub namespace: String,
+    #[serde(default)]
+    pub app_name: Option<String>,
+    #[serde(default)]
+    pub operation: Option<String>,
+    #[serde(default)]
+    pub operator: Option<String>,
+    #[serde(default)]
+    pub last_modified_time: Option<String>,
+    #[serde(default)]
+    pub config_type: Option<String>,
+    #[serde(default)]
+    pub tags: Option<String>,
+    #[serde(default)]
+    pub md5: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConfigHistoryList {
+    pub page_no: u32,
+    pub page_size: u32,
+    pub total_count: u64,
+    pub items: Vec<NacosConfigHistoryItem>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConfigHistoryKey {
+    #[serde(default)]
+    pub namespace: Option<String>,
+    pub data_id: String,
+    pub group: String,
+    pub history_id: String,
+    #[serde(default)]
+    pub nid: Option<i64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosConfigRollbackRequest {
+    #[serde(default)]
+    pub namespace: Option<String>,
+    pub data_id: String,
+    pub group: String,
+    pub history_id: String,
+    #[serde(default)]
+    pub nid: Option<i64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosServiceQuery {
+    #[serde(default)]
+    pub namespace: Option<String>,
+    #[serde(default)]
+    pub group_name: Option<String>,
+    #[serde(default)]
+    pub service_name: Option<String>,
+    #[serde(default)]
+    pub page_no: Option<u32>,
+    #[serde(default)]
+    pub page_size: Option<u32>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosServiceInfo {
+    pub service_name: String,
+    #[serde(default)]
+    pub group_name: Option<String>,
+    #[serde(default)]
+    pub cluster_count: Option<u64>,
+    #[serde(default)]
+    pub ip_count: Option<u64>,
+    #[serde(default)]
+    pub healthy_instance_count: Option<u64>,
+    #[serde(default)]
+    pub trigger_flag: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosServiceList {
+    pub page_no: u32,
+    pub page_size: u32,
+    pub total_count: u64,
+    pub items: Vec<NacosServiceInfo>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosInstanceInfo {
+    pub ip: String,
+    pub port: u16,
+    #[serde(default)]
+    pub service_name: Option<String>,
+    #[serde(default)]
+    pub cluster_name: Option<String>,
+    #[serde(default)]
+    pub group_name: Option<String>,
+    #[serde(default)]
+    pub healthy: Option<bool>,
+    #[serde(default)]
+    pub enabled: Option<bool>,
+    #[serde(default)]
+    pub ephemeral: Option<bool>,
+    #[serde(default)]
+    pub weight: Option<f64>,
+    #[serde(default)]
+    pub metadata: serde_json::Value,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosInstanceQuery {
+    #[serde(default)]
+    pub namespace: Option<String>,
+    pub service_name: String,
+    #[serde(default)]
+    pub group_name: Option<String>,
+    #[serde(default)]
+    pub clusters: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosInstanceUpdate {
+    #[serde(default)]
+    pub namespace: Option<String>,
+    pub service_name: String,
+    pub ip: String,
+    pub port: u16,
+    #[serde(default)]
+    pub group_name: Option<String>,
+    #[serde(default)]
+    pub cluster_name: Option<String>,
+    #[serde(default)]
+    pub healthy: Option<bool>,
+    #[serde(default)]
+    pub enabled: Option<bool>,
+    #[serde(default)]
+    pub ephemeral: Option<bool>,
+    #[serde(default)]
+    pub weight: Option<f64>,
+    #[serde(default)]
+    pub metadata: Option<serde_json::Value>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosRawRequest {
+    pub method: String,
+    pub path: String,
+    #[serde(default)]
+    pub query: Option<std::collections::HashMap<String, String>>,
+    #[serde(default)]
+    pub body: Option<serde_json::Value>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct NacosRawResponse {
+    pub status: u16,
+    pub body: serde_json::Value,
+    #[serde(default)]
+    pub text: Option<String>,
+}
diff --git a/crates/dbx-core/src/object_source_sql.rs b/crates/dbx-core/src/object_source_sql.rs
new file mode 100644
index 0000000..c41af54
--- /dev/null
+++ b/crates/dbx-core/src/object_source_sql.rs
@@ -0,0 +1,1451 @@
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+
+use crate::models::connection::DatabaseType;
+use crate::types::ObjectSourceKind;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditableObjectSourceSqlInput {
+    pub database_type: DatabaseType,
+    pub object_type: ObjectSourceKind,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub name: String,
+    pub source: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RoutineRenameObjectSourceInput {
+    pub database_type: DatabaseType,
+    pub object_type: ObjectSourceKind,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub name: String,
+    pub new_name: String,
+    pub source: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildViewDdlInput {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub name: String,
+    pub source: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ObjectSourceSaveExecutionMode {
+    #[serde(rename = "single")]
+    Single,
+    #[serde(rename = "script")]
+    Script,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct RoutineDeclaration {
+    kind: ObjectSourceKind,
+    name: String,
+    signature: String,
+}
+
+pub fn supports_source_backed_routine_rename(
+    database_type: Option<DatabaseType>,
+    object_type: ObjectSourceKind,
+) -> bool {
+    if !matches!(object_type, ObjectSourceKind::Function | ObjectSourceKind::Procedure) {
+        return false;
+    }
+    let Some(database_type) = database_type else {
+        return false;
+    };
+    database_type != DatabaseType::SqlServer
+        && (is_mysql_like(database_type) || is_postgres_like(database_type) || is_oracle_like(database_type))
+}
+
+pub fn build_routine_rename_object_source_statements(
+    input: RoutineRenameObjectSourceInput,
+) -> Result<Vec<String>, String> {
+    if !supports_source_backed_routine_rename(Some(input.database_type), input.object_type.clone()) {
+        return Err(format!(
+            "Renaming {:?} from source is not supported for {:?}.",
+            input.object_type, input.database_type
+        ));
+    }
+
+    let source = input.source.trim();
+    let declaration = if is_mysql_like(input.database_type) {
+        mysql_routine_declaration(source)
+    } else {
+        routine_declaration(source)
+    };
+    let Some(declaration) = declaration else {
+        return Err(format!("Cannot find a CREATE {:?} declaration in the object source.", input.object_type));
+    };
+    if declaration.kind != input.object_type {
+        return Err(format!("Cannot find a CREATE {:?} declaration in the object source.", input.object_type));
+    }
+
+    let renamed_source = if is_mysql_like(input.database_type) {
+        replace_mysql_routine_declaration_name(source, &input.new_name)
+    } else {
+        replace_sql_routine_declaration_name(source, input.schema.as_deref(), &input.new_name)
+    };
+    let Some(renamed_source) = renamed_source else {
+        return Err(format!("Cannot rewrite the {:?} name in the object source.", input.object_type));
+    };
+
+    if is_oracle_like(input.database_type) {
+        return Ok(vec![
+            ensure_semicolon(&renamed_source),
+            format!(
+                "DROP {} {};",
+                object_type_keyword(&input.object_type),
+                postgres_qualified_name(input.schema.as_deref(), &input.name)
+            ),
+        ]);
+    }
+
+    build_executable_object_source_statements(EditableObjectSourceSqlInput {
+        database_type: input.database_type,
+        object_type: input.object_type,
+        schema: input.schema,
+        name: input.name,
+        source: renamed_source,
+    })
+}
+
+pub fn build_executable_object_source_statements(input: EditableObjectSourceSqlInput) -> Result<Vec<String>, String> {
+    let source = input.source.trim();
+    if input.database_type == DatabaseType::SqlServer {
+        if input.object_type == ObjectSourceKind::View {
+            return Ok(vec![build_sqlserver_alter_view_sql(input.schema.as_deref(), &input.name, source)]);
+        }
+        // CREATE OR ALTER requires SQL Server 2016 SP1+, while ALTER keeps existing routines executable on older servers.
+        return Ok(vec![replace_sqlserver_create_with_alter(source)]);
+    }
+
+    if matches!(
+        input.database_type,
+        DatabaseType::Postgres
+            | DatabaseType::Gaussdb
+            | DatabaseType::Kwdb
+            | DatabaseType::OpenGauss
+            | DatabaseType::Questdb
+    ) && input.object_type == ObjectSourceKind::View
+    {
+        if let Some(sql) = executable_postgres_view_ddl(source) {
+            return Ok(vec![sql]);
+        }
+        if source_starts_with_alter(source) {
+            // ALTER VIEW is already executable DDL, but it is not a view body.
+            return Ok(vec![ensure_semicolon(source)]);
+        }
+        return Ok(vec![format!(
+            "CREATE OR REPLACE VIEW {} AS\n{}",
+            postgres_qualified_name(input.schema.as_deref(), &input.name),
+            ensure_semicolon(source)
+        )]);
+    }
+
+    if is_oracle_like(input.database_type) && input.object_type == ObjectSourceKind::View {
+        return Ok(vec![executable_oracle_view_ddl(input.schema.as_deref(), &input.name, source)]);
+    }
+
+    if input.database_type == DatabaseType::Informix && input.object_type == ObjectSourceKind::View {
+        return Ok(executable_informix_view_statements(input.schema.as_deref(), &input.name, source));
+    }
+
+    if is_mysql_like(input.database_type)
+        && matches!(input.object_type, ObjectSourceKind::Function | ObjectSourceKind::Procedure)
+    {
+        return Ok(executable_mysql_routine_statements(&input, source));
+    }
+
+    let create_statement = ensure_semicolon(source);
+    let cleanup = build_routine_rename_cleanup(&input, source);
+    Ok(if let Some(cleanup) = cleanup { vec![create_statement, cleanup] } else { vec![create_statement] })
+}
+
+pub fn build_executable_object_source_sql(input: EditableObjectSourceSqlInput) -> Result<String, String> {
+    Ok(build_executable_object_source_statements(input)?.join("\n"))
+}
+
+/// Convert a raw database object source into a form suitable for the source editor.
+///
+/// This is the *editable* presentation shown to the user when they open a view,
+/// procedure, or function for editing. For SQL Server the raw `CREATE VIEW` /
+/// `CREATE PROCEDURE` is rewritten to `ALTER` so the user doesn't see a
+/// mismatched CREATE statement for an already-existing object. Callers that
+/// only need the first statement should use this instead of calling
+/// `build_executable_object_source_statements` and discarding rename-cleanup
+/// statements.
+pub fn build_editable_object_source(input: EditableObjectSourceSqlInput) -> String {
+    let source = input.source.clone();
+    if matches!(
+        input.database_type,
+        DatabaseType::Postgres
+            | DatabaseType::Gaussdb
+            | DatabaseType::Kwdb
+            | DatabaseType::OpenGauss
+            | DatabaseType::Questdb
+    ) && input.object_type == ObjectSourceKind::View
+        && source_starts_with_create_or_alter(&source)
+    {
+        // Some providers return full view DDL instead of a bare SELECT body.
+        return ensure_semicolon(source.trim());
+    }
+    if input.database_type == DatabaseType::Informix && input.object_type == ObjectSourceKind::View {
+        return editable_informix_view_ddl(input.schema.as_deref(), &input.name, &source);
+    }
+    if is_mysql_like(input.database_type)
+        && matches!(input.object_type, ObjectSourceKind::Function | ObjectSourceKind::Procedure)
+    {
+        return ensure_semicolon(source.trim());
+    }
+    match build_executable_object_source_statements(input) {
+        Ok(statements) => statements.into_iter().next().unwrap_or_default(),
+        Err(_) => ensure_semicolon(source.trim()),
+    }
+}
+
+pub fn build_view_ddl_sql(input: BuildViewDdlInput) -> String {
+    let source = input.source.trim();
+    if Regex::new(r"(?i)^(?:CREATE|ALTER)\s+").unwrap().is_match(source) {
+        return ensure_semicolon(source);
+    }
+
+    let qualified_name = if matches!(input.database_type, Some(DatabaseType::Mysql | DatabaseType::Goldendb)) {
+        mysql_qualified_name(input.schema.as_deref(), &input.name)
+    } else {
+        postgres_qualified_name(input.schema.as_deref(), &input.name)
+    };
+
+    if input.database_type.is_none()
+        || input.database_type.is_some_and(|database_type| {
+            is_postgres_like(database_type)
+                || database_type == DatabaseType::OpenGauss
+                || database_type == DatabaseType::Questdb
+        })
+    {
+        return format!("CREATE OR REPLACE VIEW {qualified_name} AS\n{}", ensure_semicolon(source));
+    }
+
+    format!("CREATE VIEW {qualified_name} AS\n{}", ensure_semicolon(source))
+}
+
+pub fn build_export_object_source_sql(
+    database_type: DatabaseType,
+    object_type: ObjectSourceKind,
+    source: &str,
+) -> String {
+    let source = source.trim();
+    if source.is_empty() {
+        return String::new();
+    }
+    if is_mysql_like(database_type) && matches!(object_type, ObjectSourceKind::Procedure | ObjectSourceKind::Function) {
+        return mysql_delimited_routine_source(source);
+    }
+    ensure_semicolon(source)
+}
+
+pub fn object_source_save_execution_mode(_database_type: DatabaseType) -> ObjectSourceSaveExecutionMode {
+    ObjectSourceSaveExecutionMode::Single
+}
+
+fn build_routine_rename_cleanup(input: &EditableObjectSourceSqlInput, source: &str) -> Option<String> {
+    if !matches!(input.object_type, ObjectSourceKind::Function | ObjectSourceKind::Procedure) {
+        return None;
+    }
+
+    if is_mysql_like(input.database_type) {
+        let declaration = mysql_routine_declaration(source)?;
+        if declaration.kind != input.object_type || !routine_name_changed(&declaration.name, &input.name) {
+            return None;
+        }
+        return Some(format!(
+            "DROP {} IF EXISTS {};",
+            object_type_keyword(&input.object_type),
+            mysql_qualified_name(input.schema.as_deref(), &input.name)
+        ));
+    }
+
+    if !is_postgres_like(input.database_type) {
+        return None;
+    }
+
+    let declaration = routine_declaration(source)?;
+    if declaration.kind != input.object_type || !routine_name_changed(&declaration.name, &input.name) {
+        return None;
+    }
+
+    Some(format!(
+        "DROP {} IF EXISTS {}{};",
+        object_type_keyword(&input.object_type),
+        postgres_qualified_name(input.schema.as_deref(), &input.name),
+        declaration.signature
+    ))
+}
+
+fn is_postgres_like(database_type: DatabaseType) -> bool {
+    matches!(
+        database_type,
+        DatabaseType::Postgres
+            | DatabaseType::Redshift
+            | DatabaseType::Gaussdb
+            | DatabaseType::Kwdb
+            | DatabaseType::OpenGauss
+            | DatabaseType::Questdb
+            | DatabaseType::Kingbase
+            | DatabaseType::Highgo
+            | DatabaseType::Vastbase
+    )
+}
+
+fn is_mysql_like(database_type: DatabaseType) -> bool {
+    matches!(database_type, DatabaseType::Mysql | DatabaseType::Goldendb)
+}
+
+fn is_oracle_like(database_type: DatabaseType) -> bool {
+    matches!(database_type, DatabaseType::Oracle | DatabaseType::Dameng)
+}
+
+fn object_type_keyword(object_type: &ObjectSourceKind) -> &'static str {
+    match object_type {
+        ObjectSourceKind::View => "VIEW",
+        ObjectSourceKind::MaterializedView => "MATERIALIZED_VIEW",
+        ObjectSourceKind::Procedure => "PROCEDURE",
+        ObjectSourceKind::Function => "FUNCTION",
+        ObjectSourceKind::Sequence => "SEQUENCE",
+        ObjectSourceKind::Package => "PACKAGE",
+        ObjectSourceKind::PackageBody => "PACKAGE BODY",
+    }
+}
+
+fn quote_postgres_identifier(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+fn quote_mysql_identifier(value: &str) -> String {
+    format!("`{}`", value.replace('`', "``"))
+}
+
+fn ensure_semicolon(sql: &str) -> String {
+    let trimmed = sql.trim();
+    if trimmed.ends_with(';') {
+        trimmed.to_string()
+    } else {
+        format!("{trimmed};")
+    }
+}
+
+fn mysql_delimited_routine_source(source: &str) -> String {
+    let trimmed = source.trim();
+    if Regex::new(r"(?i)^\s*DELIMITER\b").unwrap().is_match(trimmed) {
+        return trimmed.to_string();
+    }
+    let body = trimmed.trim_end_matches(';').trim_end();
+    let delimiter = mysql_routine_script_delimiter(body);
+    format!("DELIMITER {delimiter}\n{body}{delimiter}\nDELIMITER ;")
+}
+
+fn mysql_routine_script_delimiter(source: &str) -> &'static str {
+    ["//", "$$", ";;", "__DBX_DELIMITER__"]
+        .into_iter()
+        .find(|delimiter| !source.contains(delimiter))
+        .unwrap_or("__DBX_DELIMITER__")
+}
+
+fn source_starts_with_create_or_alter(source: &str) -> bool {
+    Regex::new(r"(?i)^\s*(?:CREATE|ALTER)\s+").unwrap().is_match(source)
+}
+
+fn source_starts_with_alter(source: &str) -> bool {
+    Regex::new(r"(?i)^\s*ALTER\s+").unwrap().is_match(source)
+}
+
+fn executable_postgres_view_ddl(source: &str) -> Option<String> {
+    let trimmed = source.trim();
+    if Regex::new(r"(?i)^CREATE\s+OR\s+REPLACE\s+").unwrap().is_match(trimmed) {
+        return Some(ensure_semicolon(trimmed));
+    }
+
+    let create_view = Regex::new(r"(?i)^CREATE\s+((?:(?:TEMP|TEMPORARY)\s+)?(?:RECURSIVE\s+)?VIEW\s+)").unwrap();
+    if create_view.is_match(trimmed) {
+        let replaced = create_view.replace(trimmed, "CREATE OR REPLACE $1");
+        return Some(ensure_semicolon(replaced.as_ref()));
+    }
+
+    None
+}
+
+fn executable_oracle_view_ddl(schema: Option<&str>, name: &str, source: &str) -> String {
+    let trimmed = source.trim();
+    if Regex::new(r"(?i)^CREATE\s+OR\s+REPLACE\s+").unwrap().is_match(trimmed) || source_starts_with_alter(trimmed) {
+        return ensure_semicolon(trimmed);
+    }
+
+    let create_view = Regex::new(r"(?i)^CREATE\s+((?:(?:NO)?FORCE\s+)?(?:(?:NON)?EDITIONABLE\s+)?VIEW\s+)").unwrap();
+    if create_view.is_match(trimmed) {
+        let replaced = create_view.replace(trimmed, "CREATE OR REPLACE $1");
+        return ensure_semicolon(replaced.as_ref());
+    }
+
+    format!("CREATE OR REPLACE VIEW {} AS\n{}", postgres_qualified_name(schema, name), ensure_semicolon(trimmed))
+}
+
+fn executable_informix_view_statements(schema: Option<&str>, name: &str, source: &str) -> Vec<String> {
+    let (target_name, create_tail) = informix_view_definition(schema, name, source);
+    if source_starts_with_alter(source.trim()) {
+        return vec![ensure_semicolon(source.trim())];
+    }
+
+    let validation_name = informix_validation_view_name(&target_name);
+    let mut statements = vec![
+        drop_informix_view_if_exists(&validation_name),
+        create_informix_view(&validation_name, &create_tail),
+        drop_informix_view_if_exists(&validation_name),
+    ];
+
+    let original_name = informix_identifier(name);
+    if !target_name.eq_ignore_ascii_case(&original_name) {
+        statements.push(drop_informix_view_if_exists(&original_name));
+    }
+    statements.push(drop_informix_view_if_exists(&target_name));
+    statements.push(create_informix_view(&target_name, &create_tail));
+    statements
+}
+
+fn editable_informix_view_ddl(schema: Option<&str>, name: &str, source: &str) -> String {
+    if source_starts_with_alter(source.trim()) {
+        return ensure_semicolon(source.trim());
+    }
+    let (target_name, create_tail) = informix_view_definition(schema, name, source);
+    create_informix_view(&target_name, &create_tail)
+}
+
+fn informix_view_definition(schema: Option<&str>, name: &str, source: &str) -> (String, String) {
+    let trimmed = source.trim();
+    let create_view = Regex::new(
+        r#"(?is)^\s*CREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+((?:"(?:""|[^"])+"|[A-Za-z_][\w$]*)(?:\s*\.\s*(?:"(?:""|[^"])+"|[A-Za-z_][\w$]*))?)"#,
+    )
+    .unwrap();
+    if let Some(captures) = create_view.captures(trimmed) {
+        let view_name = captures.get(1).unwrap();
+        let target_name = strip_informix_owner_qualifiers(view_name.as_str(), schema);
+        let body = strip_informix_owner_qualifiers(&trimmed[view_name.end()..], schema);
+        return (target_name.trim().to_string(), body);
+    } else {
+        let body = strip_informix_owner_qualifiers(trimmed, schema);
+        (informix_identifier(name), format!(" AS\n{body}"))
+    }
+}
+
+fn postgres_qualified_name(schema: Option<&str>, name: &str) -> String {
+    schema
+        .into_iter()
+        .chain(std::iter::once(name))
+        .filter(|part| !part.is_empty())
+        .map(quote_postgres_identifier)
+        .collect::<Vec<_>>()
+        .join(".")
+}
+
+fn informix_identifier(name: &str) -> String {
+    if is_simple_informix_identifier(name) {
+        name.to_string()
+    } else {
+        quote_postgres_identifier(name)
+    }
+}
+
+fn create_informix_view(name: &str, create_tail: &str) -> String {
+    ensure_semicolon(&format!("CREATE VIEW {}{}", name.trim(), create_tail))
+}
+
+fn drop_informix_view_if_exists(name: &str) -> String {
+    format!("DROP VIEW IF EXISTS {};", name.trim())
+}
+
+fn executable_mysql_routine_statements(input: &EditableObjectSourceSqlInput, source: &str) -> Vec<String> {
+    if !mysql_source_starts_with_create_routine(source) {
+        return vec![ensure_semicolon(source)];
+    }
+
+    let declaration = mysql_routine_declaration(source).filter(|declaration| declaration.kind == input.object_type);
+    let create_name = declaration.as_ref().map(|declaration| declaration.name.as_str()).unwrap_or(&input.name);
+    let mut statements = Vec::with_capacity(3);
+
+    // MySQL has no cross-version CREATE OR REPLACE for stored routines; DBeaver also
+    // replaces them by dropping the target routine before executing the CREATE body.
+    statements.push(mysql_drop_routine_if_exists(input.object_type.clone(), input.schema.as_deref(), create_name));
+    statements.push(ensure_semicolon(source));
+
+    if declaration.as_ref().is_some_and(|declaration| routine_name_changed(&declaration.name, &input.name)) {
+        statements.push(mysql_drop_routine_if_exists(input.object_type.clone(), input.schema.as_deref(), &input.name));
+    }
+
+    statements
+}
+
+fn mysql_drop_routine_if_exists(object_type: ObjectSourceKind, schema: Option<&str>, name: &str) -> String {
+    format!("DROP {} IF EXISTS {};", object_type_keyword(&object_type), mysql_qualified_name(schema, name))
+}
+
+fn mysql_source_starts_with_create_routine(source: &str) -> bool {
+    Regex::new(r"(?is)^\s*CREATE\s+(?:DEFINER\s*=.+?\s+)?(?:FUNCTION|PROCEDURE)\b").unwrap().is_match(source)
+}
+
+fn informix_validation_view_name(target_name: &str) -> String {
+    let mut hash = 0x811c9dc5u32;
+    for byte in target_name.bytes() {
+        hash ^= byte as u32;
+        hash = hash.wrapping_mul(0x01000193);
+    }
+    format!("dbx_view_check_{hash:08x}")
+}
+
+fn strip_informix_owner_qualifiers(source: &str, schema: Option<&str>) -> String {
+    let Some(schema) = schema.map(str::trim).filter(|schema| !schema.is_empty()) else {
+        return source.to_string();
+    };
+
+    let mut result = String::with_capacity(source.len());
+    let mut index = 0;
+    while index < source.len() {
+        if let Some(end) = sql_single_quoted_literal_end(source, index) {
+            result.push_str(&source[index..end]);
+            index = end;
+            continue;
+        }
+        if let Some(end) = sql_line_comment_end(source, index) {
+            result.push_str(&source[index..end]);
+            index = end;
+            continue;
+        }
+        if let Some(end) = sql_block_comment_end(source, index) {
+            result.push_str(&source[index..end]);
+            index = end;
+            continue;
+        }
+        if let Some((end, replacement)) = informix_owner_qualifier_replacement(source, index, schema) {
+            result.push_str(replacement);
+            index = end;
+            continue;
+        }
+        let ch = source[index..].chars().next().unwrap();
+        result.push(ch);
+        index += ch.len_utf8();
+    }
+    result
+}
+
+fn informix_owner_qualifier_replacement<'a>(source: &'a str, start: usize, schema: &str) -> Option<(usize, &'a str)> {
+    if let Some((owner_end, owner)) = read_quoted_sql_identifier(source, start) {
+        if owner.eq_ignore_ascii_case(schema) {
+            let dot = skip_sql_whitespace(source, owner_end);
+            if source[dot..].starts_with('.') {
+                let ident_start = skip_sql_whitespace(source, dot + 1);
+                if let Some((ident_end, ident_text)) = read_informix_identifier_text(source, ident_start) {
+                    return Some((ident_end, ident_text));
+                }
+            }
+        }
+    }
+
+    if !is_simple_informix_identifier(schema) || !starts_with_ignore_ascii_case_at(source, start, schema) {
+        return None;
+    }
+    if source[..start].chars().next_back().is_some_and(is_informix_identifier_part) {
+        return None;
+    }
+    let owner_end = start + schema.len();
+    if source[owner_end..].chars().next().is_some_and(is_informix_identifier_part) {
+        return None;
+    }
+    let dot = skip_sql_whitespace(source, owner_end);
+    if !source[dot..].starts_with('.') {
+        return None;
+    }
+    let ident_start = skip_sql_whitespace(source, dot + 1);
+    read_informix_identifier_text(source, ident_start).map(|(ident_end, ident_text)| (ident_end, ident_text))
+}
+
+fn sql_single_quoted_literal_end(source: &str, start: usize) -> Option<usize> {
+    if !source[start..].starts_with('\'') {
+        return None;
+    }
+    let mut index = start + 1;
+    while index < source.len() {
+        let ch = source[index..].chars().next().unwrap();
+        index += ch.len_utf8();
+        if ch == '\'' {
+            if source[index..].starts_with('\'') {
+                index += 1;
+            } else {
+                return Some(index);
+            }
+        }
+    }
+    Some(source.len())
+}
+
+fn sql_line_comment_end(source: &str, start: usize) -> Option<usize> {
+    if !source[start..].starts_with("--") {
+        return None;
+    }
+    let rest = &source[start..];
+    Some(start + rest.find('\n').map(|index| index + 1).unwrap_or(rest.len()))
+}
+
+fn sql_block_comment_end(source: &str, start: usize) -> Option<usize> {
+    if !source[start..].starts_with("/*") {
+        return None;
+    }
+    let rest = &source[start + 2..];
+    Some(start + 2 + rest.find("*/").map(|index| index + 2).unwrap_or(rest.len()))
+}
+
+fn read_quoted_sql_identifier(source: &str, start: usize) -> Option<(usize, String)> {
+    if !source[start..].starts_with('"') {
+        return None;
+    }
+    let mut value = String::new();
+    let mut index = start + 1;
+    while index < source.len() {
+        let ch = source[index..].chars().next().unwrap();
+        index += ch.len_utf8();
+        if ch == '"' {
+            if source[index..].starts_with('"') {
+                value.push('"');
+                index += 1;
+            } else {
+                return Some((index, value));
+            }
+        } else {
+            value.push(ch);
+        }
+    }
+    None
+}
+
+fn read_informix_identifier_text(source: &str, start: usize) -> Option<(usize, &str)> {
+    if let Some((end, _)) = read_quoted_sql_identifier(source, start) {
+        return Some((end, &source[start..end]));
+    }
+    let first = source[start..].chars().next()?;
+    if !is_informix_identifier_start(first) {
+        return None;
+    }
+    let mut end = start + first.len_utf8();
+    while end < source.len() {
+        let ch = source[end..].chars().next().unwrap();
+        if !is_informix_identifier_part(ch) {
+            break;
+        }
+        end += ch.len_utf8();
+    }
+    Some((end, &source[start..end]))
+}
+
+fn skip_sql_whitespace(source: &str, mut index: usize) -> usize {
+    while index < source.len() {
+        let ch = source[index..].chars().next().unwrap();
+        if !ch.is_whitespace() {
+            break;
+        }
+        index += ch.len_utf8();
+    }
+    index
+}
+
+fn starts_with_ignore_ascii_case_at(source: &str, start: usize, needle: &str) -> bool {
+    source.get(start..start + needle.len()).is_some_and(|value| value.eq_ignore_ascii_case(needle))
+}
+
+fn is_informix_identifier_start(ch: char) -> bool {
+    ch == '_' || ch.is_ascii_alphabetic()
+}
+
+fn is_informix_identifier_part(ch: char) -> bool {
+    ch == '_' || ch == '$' || ch.is_ascii_alphanumeric()
+}
+
+fn is_simple_informix_identifier(name: &str) -> bool {
+    Regex::new(r"^[A-Za-z_][A-Za-z0-9_$]*$").unwrap().is_match(name)
+}
+
+fn mysql_qualified_name(schema: Option<&str>, name: &str) -> String {
+    schema
+        .into_iter()
+        .chain(std::iter::once(name))
+        .filter(|part| !part.is_empty())
+        .map(quote_mysql_identifier)
+        .collect::<Vec<_>>()
+        .join(".")
+}
+
+fn quote_sqlserver_identifier(value: &str) -> String {
+    format!("[{}]", value.replace(']', "]]"))
+}
+
+fn sqlserver_qualified_name(schema: Option<&str>, name: &str) -> String {
+    schema
+        .into_iter()
+        .chain(std::iter::once(name))
+        .filter(|part| !part.is_empty())
+        .map(quote_sqlserver_identifier)
+        .collect::<Vec<_>>()
+        .join(".")
+}
+
+fn unquote_postgres_identifier(value: &str) -> String {
+    let trimmed = value.trim();
+    if trimmed.starts_with('"') && trimmed.ends_with('"') && trimmed.len() >= 2 {
+        trimmed[1..trimmed.len() - 1].replace("\"\"", "\"")
+    } else {
+        trimmed.to_string()
+    }
+}
+
+fn split_qualified_routine_name(value: &str) -> Vec<String> {
+    Regex::new(r#""(?:""|[^"])+"|[A-Za-z_][\w$]*"#)
+        .unwrap()
+        .find_iter(value)
+        .map(|part| unquote_postgres_identifier(part.as_str()))
+        .collect()
+}
+
+fn unquote_mysql_identifier(value: &str) -> String {
+    let trimmed = value.trim();
+    if trimmed.starts_with('`') && trimmed.ends_with('`') && trimmed.len() >= 2 {
+        trimmed[1..trimmed.len() - 1].replace("``", "`")
+    } else {
+        trimmed.to_string()
+    }
+}
+
+fn split_mysql_qualified_routine_name(value: &str) -> Vec<String> {
+    Regex::new(r"`(?:``|[^`])+`|[A-Za-z_][\w$]*")
+        .unwrap()
+        .find_iter(value)
+        .map(|part| unquote_mysql_identifier(part.as_str()))
+        .collect()
+}
+
+fn routine_declaration(source: &str) -> Option<RoutineDeclaration> {
+    let re = Regex::new(
+        r#"(?is)^\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:(?:NON)?EDITIONABLE\s+)?(FUNCTION|PROCEDURE)\s+((?:"(?:""|[^"])+"|[A-Za-z_][\w$]*)(?:\s*\.\s*(?:"(?:""|[^"])+"|[A-Za-z_][\w$]*))?)\s*(\(.*?\))?"#,
+    )
+    .unwrap();
+    let captures = re.captures(source)?;
+    let kind = parse_object_source_kind(captures.get(1)?.as_str())?;
+    let name_parts = split_qualified_routine_name(captures.get(2)?.as_str());
+    let name = name_parts.last()?.clone();
+    let signature = captures.get(3).map(|value| value.as_str().trim().to_string()).unwrap_or_default();
+    Some(RoutineDeclaration { kind, name, signature })
+}
+
+fn replace_sql_routine_declaration_name(source: &str, schema: Option<&str>, new_name: &str) -> Option<String> {
+    let re = Regex::new(
+        r#"(?is)^(\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:(?:NON)?EDITIONABLE\s+)?(?:FUNCTION|PROCEDURE)\s+)((?:"(?:""|[^"])+"|[A-Za-z_][\w$]*)(?:\s*\.\s*(?:"(?:""|[^"])+"|[A-Za-z_][\w$]*))?)"#,
+    )
+    .unwrap();
+    let captures = re.captures(source)?;
+    let full = captures.get(0)?;
+    let prefix = captures.get(1)?.as_str();
+    let existing_name = captures.get(2)?.as_str();
+    let existing_parts = split_qualified_routine_name(existing_name);
+    let schema_name =
+        schema.or_else(|| existing_parts.first().filter(|_| existing_parts.len() > 1).map(String::as_str));
+    let replacement = if let Some(schema_name) = schema_name {
+        format!("{}.{}", quote_postgres_identifier(schema_name), quote_postgres_identifier(new_name))
+    } else {
+        quote_postgres_identifier(new_name)
+    };
+    Some(format!("{}{}{}{}", &source[..full.start()], prefix, replacement, &source[full.end()..]))
+}
+
+fn mysql_routine_declaration(source: &str) -> Option<RoutineDeclaration> {
+    let re = Regex::new(
+        r"(?is)^\s*CREATE\s+(?:DEFINER\s*=\s*(?:(?:`(?:``|[^`])+`|'(?:''|[^'])+'|[^\s]+)\s*@\s*(?:`(?:``|[^`])+`|'(?:''|[^'])+'|[^\s]+)|CURRENT_USER(?:\(\))?)\s+)?(FUNCTION|PROCEDURE)\s+(?:IF\s+NOT\s+EXISTS\s+)?((?:`(?:``|[^`])+`|[A-Za-z_][\w$]*)(?:\s*\.\s*(?:`(?:``|[^`])+`|[A-Za-z_][\w$]*))?)",
+    )
+    .unwrap();
+    let captures = re.captures(source)?;
+    let kind = parse_object_source_kind(captures.get(1)?.as_str())?;
+    let name_parts = split_mysql_qualified_routine_name(captures.get(2)?.as_str());
+    let name = name_parts.last()?.clone();
+    Some(RoutineDeclaration { kind, name, signature: String::new() })
+}
+
+fn replace_mysql_routine_declaration_name(source: &str, new_name: &str) -> Option<String> {
+    let re = Regex::new(
+        r"(?is)^(\s*CREATE\s+(?:DEFINER\s*=\s*(?:(?:`(?:``|[^`])+`|'(?:''|[^'])+'|[^\s]+)\s*@\s*(?:`(?:``|[^`])+`|'(?:''|[^'])+'|[^\s]+)|CURRENT_USER(?:\(\))?)\s+)?(?:FUNCTION|PROCEDURE)\s+(?:IF\s+NOT\s+EXISTS\s+)?)((?:`(?:``|[^`])+`|[A-Za-z_][\w$]*)(?:\s*\.\s*(?:`(?:``|[^`])+`|[A-Za-z_][\w$]*))?)",
+    )
+    .unwrap();
+    let captures = re.captures(source)?;
+    let full = captures.get(0)?;
+    let prefix = captures.get(1)?.as_str();
+    Some(format!("{}{}{}{}", &source[..full.start()], prefix, quote_mysql_identifier(new_name), &source[full.end()..]))
+}
+
+fn routine_name_changed(source_name: &str, saved_name: &str) -> bool {
+    !source_name.eq_ignore_ascii_case(saved_name)
+}
+
+fn replace_sqlserver_create_with_alter(source: &str) -> String {
+    Regex::new(r"(?i)^(?:CREATE\s+(?:OR\s+ALTER\s+)?|ALTER\s+)").unwrap().replace(source, "ALTER ").to_string()
+}
+
+fn build_sqlserver_alter_view_sql(schema: Option<&str>, name: &str, source: &str) -> String {
+    let existing_view_statement = Regex::new(r"(?i)^CREATE\s+(?:OR\s+ALTER\s+)?VIEW\s+|^ALTER\s+VIEW\s+").unwrap();
+    if existing_view_statement.is_match(source) {
+        return ensure_semicolon(&existing_view_statement.replace(source, "ALTER VIEW "));
+    }
+
+    format!("ALTER VIEW {} AS\n{}", sqlserver_qualified_name(schema, name), ensure_semicolon(source))
+}
+
+fn parse_object_source_kind(value: &str) -> Option<ObjectSourceKind> {
+    if value.eq_ignore_ascii_case("VIEW") {
+        Some(ObjectSourceKind::View)
+    } else if value.eq_ignore_ascii_case("MATERIALIZED VIEW") || value.eq_ignore_ascii_case("MATERIALIZED_VIEW") {
+        Some(ObjectSourceKind::MaterializedView)
+    } else if value.eq_ignore_ascii_case("PROCEDURE") {
+        Some(ObjectSourceKind::Procedure)
+    } else if value.eq_ignore_ascii_case("FUNCTION") {
+        Some(ObjectSourceKind::Function)
+    } else if value.eq_ignore_ascii_case("SEQUENCE") {
+        Some(ObjectSourceKind::Sequence)
+    } else if value.eq_ignore_ascii_case("PACKAGE") {
+        Some(ObjectSourceKind::Package)
+    } else if value.eq_ignore_ascii_case("PACKAGE BODY") || value.eq_ignore_ascii_case("PACKAGE_BODY") {
+        Some(ObjectSourceKind::PackageBody)
+    } else {
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn input(database_type: DatabaseType, object_type: ObjectSourceKind, source: &str) -> EditableObjectSourceSqlInput {
+        EditableObjectSourceSqlInput {
+            database_type,
+            object_type,
+            schema: Some("public".to_string()),
+            name: "refresh_cache".to_string(),
+            source: source.to_string(),
+        }
+    }
+
+    fn informix_view_statements(name: &str, source: &str) -> Vec<String> {
+        build_executable_object_source_statements(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Informix,
+            object_type: ObjectSourceKind::View,
+            schema: Some("gbasedbt".to_string()),
+            name: name.to_string(),
+            source: source.to_string(),
+        })
+        .unwrap()
+    }
+
+    fn expected_informix_view_replace_statements(
+        original_name: &str,
+        target_name: &str,
+        create_tail: &str,
+    ) -> Vec<String> {
+        let validation_name = informix_validation_view_name(target_name);
+        let mut statements = vec![
+            drop_informix_view_if_exists(&validation_name),
+            create_informix_view(&validation_name, create_tail),
+            drop_informix_view_if_exists(&validation_name),
+        ];
+        if !target_name.eq_ignore_ascii_case(original_name) {
+            statements.push(drop_informix_view_if_exists(original_name));
+        }
+        statements.push(drop_informix_view_if_exists(target_name));
+        statements.push(create_informix_view(target_name, create_tail));
+        statements
+    }
+
+    #[test]
+    fn sqlserver_edited_source_saves_as_alter() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::SqlServer,
+            object_type: ObjectSourceKind::Procedure,
+            schema: Some("dbo".to_string()),
+            name: "usp_demo".to_string(),
+            source: "CREATE PROCEDURE dbo.usp_demo AS SELECT 1;".to_string(),
+        })
+        .unwrap();
+        assert_eq!(sql, "ALTER PROCEDURE dbo.usp_demo AS SELECT 1;");
+    }
+
+    #[test]
+    fn sqlserver_alter_source_saves_as_alter() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::SqlServer,
+            object_type: ObjectSourceKind::Procedure,
+            schema: Some("dbo".to_string()),
+            name: "usp_demo".to_string(),
+            source: "ALTER PROCEDURE dbo.usp_demo AS SELECT 1;".to_string(),
+        })
+        .unwrap();
+        assert_eq!(sql, "ALTER PROCEDURE dbo.usp_demo AS SELECT 1;");
+    }
+
+    #[test]
+    fn sqlserver_create_function_source_saves_as_alter() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::SqlServer,
+            object_type: ObjectSourceKind::Function,
+            schema: Some("dbo".to_string()),
+            name: "fn_demo".to_string(),
+            source: "CREATE FUNCTION dbo.fn_demo() RETURNS INT AS BEGIN RETURN 1 END;".to_string(),
+        })
+        .unwrap();
+        assert_eq!(sql, "ALTER FUNCTION dbo.fn_demo() RETURNS INT AS BEGIN RETURN 1 END;");
+    }
+
+    #[test]
+    fn sqlserver_create_or_alter_function_source_saves_as_alter() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::SqlServer,
+            object_type: ObjectSourceKind::Function,
+            schema: Some("dbo".to_string()),
+            name: "fn_demo".to_string(),
+            source: "CREATE OR ALTER FUNCTION dbo.fn_demo() RETURNS INT AS BEGIN RETURN 1 END;".to_string(),
+        })
+        .unwrap();
+        assert_eq!(sql, "ALTER FUNCTION dbo.fn_demo() RETURNS INT AS BEGIN RETURN 1 END;");
+    }
+
+    #[test]
+    fn sqlserver_view_save_rewrites_create_to_alter_view() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::SqlServer,
+            object_type: ObjectSourceKind::View,
+            schema: Some("dbo".to_string()),
+            name: "new_view".to_string(),
+            source: "CREATE VIEW dbo.new_view AS SELECT * FROM AppInfo".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(sql, "ALTER VIEW dbo.new_view AS SELECT * FROM AppInfo;");
+    }
+
+    #[test]
+    fn sqlserver_view_save_rewrites_create_or_alter_to_alter_view() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::SqlServer,
+            object_type: ObjectSourceKind::View,
+            schema: Some("dbo".to_string()),
+            name: "new_view".to_string(),
+            source: "CREATE OR ALTER VIEW dbo.new_view AS SELECT * FROM AppInfo;".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(sql, "ALTER VIEW dbo.new_view AS SELECT * FROM AppInfo;");
+    }
+
+    #[test]
+    fn sqlserver_view_body_saves_as_alter_view() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::SqlServer,
+            object_type: ObjectSourceKind::View,
+            schema: Some("dbo".to_string()),
+            name: "new_view".to_string(),
+            source: "SELECT\n  *\nFROM AppInfo".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(sql, "ALTER VIEW [dbo].[new_view] AS\nSELECT\n  *\nFROM AppInfo;");
+    }
+
+    #[test]
+    fn postgres_view_body_opens_as_create_or_replace_view() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Postgres,
+            object_type: ObjectSourceKind::View,
+            schema: Some("public".to_string()),
+            name: "active users".to_string(),
+            source: " SELECT id, name FROM users WHERE active ".to_string(),
+        })
+        .unwrap();
+        assert_eq!(
+            sql,
+            "CREATE OR REPLACE VIEW \"public\".\"active users\" AS\nSELECT id, name FROM users WHERE active;"
+        );
+    }
+
+    #[test]
+    fn postgres_view_create_source_opens_without_rewrapping_or_reformatting() {
+        let source = "CREATE OR REPLACE VIEW public.active_users AS SELECT id, name FROM users WHERE active = true";
+        let sql = build_editable_object_source(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Postgres,
+            object_type: ObjectSourceKind::View,
+            schema: Some("public".to_string()),
+            name: "active_users".to_string(),
+            source: source.to_string(),
+        });
+
+        assert_eq!(sql, format!("{source};"));
+    }
+
+    #[test]
+    fn postgres_view_create_source_saves_as_create_or_replace_view() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Postgres,
+            object_type: ObjectSourceKind::View,
+            schema: Some("public".to_string()),
+            name: "active_users".to_string(),
+            source: "CREATE VIEW public.active_users AS SELECT id, name FROM users WHERE active = true".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(
+            sql,
+            "CREATE OR REPLACE VIEW public.active_users AS SELECT id, name FROM users WHERE active = true;"
+        );
+    }
+
+    #[test]
+    fn postgres_view_create_or_replace_source_saves_without_rewrapping() {
+        let source = "CREATE OR REPLACE VIEW public.active_users AS SELECT id, name FROM users WHERE active = true";
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Postgres,
+            object_type: ObjectSourceKind::View,
+            schema: Some("public".to_string()),
+            name: "active_users".to_string(),
+            source: source.to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(sql, format!("{source};"));
+    }
+
+    #[test]
+    fn postgres_view_alter_source_saves_without_body_wrapping() {
+        let source = "ALTER VIEW public.active_users SET (security_barrier = true)";
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Postgres,
+            object_type: ObjectSourceKind::View,
+            schema: Some("public".to_string()),
+            name: "active_users".to_string(),
+            source: source.to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(sql, format!("{source};"));
+    }
+
+    #[test]
+    fn postgres_compatible_view_body_opens_as_create_or_replace_view() {
+        for database_type in [DatabaseType::OpenGauss, DatabaseType::Kwdb] {
+            let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+                database_type,
+                object_type: ObjectSourceKind::View,
+                schema: Some("public".to_string()),
+                name: "active users".to_string(),
+                source: " SELECT id, name FROM users WHERE active ".to_string(),
+            })
+            .unwrap();
+            assert_eq!(
+                sql,
+                "CREATE OR REPLACE VIEW \"public\".\"active users\" AS\nSELECT id, name FROM users WHERE active;"
+            );
+        }
+    }
+
+    #[test]
+    fn oracle_view_body_saves_as_create_or_replace_view() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Oracle,
+            object_type: ObjectSourceKind::View,
+            schema: Some("DBX_TEST".to_string()),
+            name: "V_ACTIVE_USERS".to_string(),
+            source: "SELECT id, name FROM users WHERE active = 1".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(
+            sql,
+            "CREATE OR REPLACE VIEW \"DBX_TEST\".\"V_ACTIVE_USERS\" AS\nSELECT id, name FROM users WHERE active = 1;"
+        );
+    }
+
+    #[test]
+    fn oracle_view_create_source_saves_as_create_or_replace_view() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Oracle,
+            object_type: ObjectSourceKind::View,
+            schema: Some("DBX_TEST".to_string()),
+            name: "V_ACTIVE_USERS".to_string(),
+            source: "CREATE FORCE EDITIONABLE VIEW DBX_TEST.V_ACTIVE_USERS AS SELECT id FROM users".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(sql, "CREATE OR REPLACE FORCE EDITIONABLE VIEW DBX_TEST.V_ACTIVE_USERS AS SELECT id FROM users;");
+    }
+
+    #[test]
+    fn oracle_view_source_opened_for_editing_shows_create_or_replace_view() {
+        let sql = build_editable_object_source(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Oracle,
+            object_type: ObjectSourceKind::View,
+            schema: Some("DBX_TEST".to_string()),
+            name: "V_ACTIVE_USERS".to_string(),
+            source: "SELECT id, name FROM users WHERE active = 1".to_string(),
+        });
+
+        assert_eq!(
+            sql,
+            "CREATE OR REPLACE VIEW \"DBX_TEST\".\"V_ACTIVE_USERS\" AS\nSELECT id, name FROM users WHERE active = 1;"
+        );
+    }
+
+    #[test]
+    fn informix_view_body_saves_with_validate_drop_create() {
+        let statements = informix_view_statements("demo_view", "SELECT id, name FROM users");
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements("demo_view", "demo_view", " AS\nSELECT id, name FROM users")
+        );
+    }
+
+    #[test]
+    fn informix_view_create_source_strips_owner_qualifier_before_save() {
+        let statements =
+            informix_view_statements("demo_view", "create view \"gbasedbt\".demo_view (id) as select id from users");
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements("demo_view", "demo_view", " (id) as select id from users")
+        );
+    }
+
+    #[test]
+    fn informix_view_create_source_preserves_sql_target_name() {
+        let statements = informix_view_statements("new_view", "create view codex_created_view as select id from users");
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements("new_view", "codex_created_view", " as select id from users")
+        );
+    }
+
+    #[test]
+    fn informix_view_create_source_strips_same_owner_table_references() {
+        let statements = informix_view_statements(
+            "dba_db_links",
+            "create view \"gbasedbt\".dba_db_links as select x0.db_link from \"gbasedbt\".user_db_links x0",
+        );
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements(
+                "dba_db_links",
+                "dba_db_links",
+                " as select x0.db_link from user_db_links x0",
+            )
+        );
+    }
+
+    #[test]
+    fn informix_view_body_strips_same_owner_table_references() {
+        let statements = informix_view_statements("demo_view", "SELECT id FROM gbasedbt.users");
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements("demo_view", "demo_view", " AS\nSELECT id FROM users")
+        );
+    }
+
+    #[test]
+    fn informix_owner_qualifier_rewrite_skips_strings_and_comments() {
+        let statements = informix_view_statements(
+            "demo_view",
+            "SELECT 'gbasedbt.users' AS literal, id FROM gbasedbt.users -- gbasedbt.audit\n/* gbasedbt.logs */",
+        );
+
+        assert_eq!(
+            statements,
+            expected_informix_view_replace_statements(
+                "demo_view",
+                "demo_view",
+                " AS\nSELECT 'gbasedbt.users' AS literal, id FROM users -- gbasedbt.audit\n/* gbasedbt.logs */",
+            )
+        );
+    }
+
+    #[test]
+    fn informix_view_source_opened_for_editing_shows_unqualified_create_view() {
+        let sql = build_editable_object_source(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Informix,
+            object_type: ObjectSourceKind::View,
+            schema: Some("gbasedbt".to_string()),
+            name: "demo_view".to_string(),
+            source: "create view \"gbasedbt\".demo_view as select id from users".to_string(),
+        });
+
+        assert_eq!(sql, "CREATE VIEW demo_view as select id from users;");
+    }
+
+    #[test]
+    fn view_ddl_wraps_postgres_body_as_create_or_replace_view() {
+        let sql = build_view_ddl_sql(BuildViewDdlInput {
+            database_type: Some(DatabaseType::Postgres),
+            schema: Some("public".to_string()),
+            name: "active users".to_string(),
+            source: " SELECT id, name FROM users WHERE active ".to_string(),
+        });
+
+        assert_eq!(
+            sql,
+            "CREATE OR REPLACE VIEW \"public\".\"active users\" AS\nSELECT id, name FROM users WHERE active;"
+        );
+    }
+
+    #[test]
+    fn view_ddl_keeps_existing_create_view_statement() {
+        let sql = build_view_ddl_sql(BuildViewDdlInput {
+            database_type: Some(DatabaseType::Mysql),
+            schema: Some("reporting".to_string()),
+            name: "active_users".to_string(),
+            source: "CREATE ALGORITHM=UNDEFINED VIEW `active_users` AS SELECT `id` FROM `users`".to_string(),
+        });
+
+        assert_eq!(sql, "CREATE ALGORITHM=UNDEFINED VIEW `active_users` AS SELECT `id` FROM `users`;");
+    }
+
+    #[test]
+    fn view_ddl_uses_create_view_for_non_postgres_like_databases() {
+        let sql = build_view_ddl_sql(BuildViewDdlInput {
+            database_type: Some(DatabaseType::Mysql),
+            schema: Some("reporting".to_string()),
+            name: "active_users".to_string(),
+            source: "SELECT id FROM users".to_string(),
+        });
+
+        assert_eq!(sql, "CREATE VIEW `reporting`.`active_users` AS\nSELECT id FROM users;");
+    }
+
+    #[test]
+    fn oracle_package_source_saves_as_single_create_or_replace_statement() {
+        let sql = build_executable_object_source_sql(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Oracle,
+            object_type: ObjectSourceKind::PackageBody,
+            schema: Some("HR".to_string()),
+            name: "PAYROLL".to_string(),
+            source: "CREATE OR REPLACE PACKAGE BODY PAYROLL AS\nEND PAYROLL;".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(sql, "CREATE OR REPLACE PACKAGE BODY PAYROLL AS\nEND PAYROLL;");
+    }
+
+    #[test]
+    fn postgres_procedure_rename_adds_drop_cleanup() {
+        let statements = build_executable_object_source_statements(input(
+            DatabaseType::Postgres,
+            ObjectSourceKind::Procedure,
+            "CREATE OR REPLACE PROCEDURE \"public\".\"refresh_cache_v2\"(mode text)\nLANGUAGE SQL\nAS $$ SELECT 1 $$;",
+        ))
+        .unwrap();
+        assert_eq!(
+            statements,
+            vec![
+                "CREATE OR REPLACE PROCEDURE \"public\".\"refresh_cache_v2\"(mode text)\nLANGUAGE SQL\nAS $$ SELECT 1 $$;",
+                "DROP PROCEDURE IF EXISTS \"public\".\"refresh_cache\"(mode text);",
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_routine_rename_adds_drop_cleanup() {
+        let statements = build_executable_object_source_statements(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Mysql,
+            object_type: ObjectSourceKind::Procedure,
+            schema: Some("app".to_string()),
+            name: "refresh_cache".to_string(),
+            source:
+                "CREATE DEFINER=`root`@`%` PROCEDURE `refresh_cache_v2`(IN mode_name varchar(20)) BEGIN SELECT 1; END"
+                    .to_string(),
+        })
+        .unwrap();
+        assert_eq!(
+            statements,
+            vec![
+                "DROP PROCEDURE IF EXISTS `app`.`refresh_cache_v2`;",
+                "CREATE DEFINER=`root`@`%` PROCEDURE `refresh_cache_v2`(IN mode_name varchar(20)) BEGIN SELECT 1; END;",
+                "DROP PROCEDURE IF EXISTS `app`.`refresh_cache`;",
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_procedure_save_replaces_existing_routine() {
+        let statements = build_executable_object_source_statements(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Mysql,
+            object_type: ObjectSourceKind::Procedure,
+            schema: Some("app".to_string()),
+            name: "refresh_cache".to_string(),
+            source: "CREATE DEFINER=`root`@`%` PROCEDURE `refresh_cache`() BEGIN SELECT 1; END".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                "DROP PROCEDURE IF EXISTS `app`.`refresh_cache`;",
+                "CREATE DEFINER=`root`@`%` PROCEDURE `refresh_cache`() BEGIN SELECT 1; END;",
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_function_save_replaces_existing_routine() {
+        let statements = build_executable_object_source_statements(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Mysql,
+            object_type: ObjectSourceKind::Function,
+            schema: Some("app".to_string()),
+            name: "active_count".to_string(),
+            source: "CREATE DEFINER=CURRENT_USER FUNCTION `active_count`() RETURNS INT RETURN 1".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(
+            statements,
+            vec![
+                "DROP FUNCTION IF EXISTS `app`.`active_count`;",
+                "CREATE DEFINER=CURRENT_USER FUNCTION `active_count`() RETURNS INT RETURN 1;",
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_alter_routine_source_saves_without_dropping() {
+        let statements = build_executable_object_source_statements(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Mysql,
+            object_type: ObjectSourceKind::Procedure,
+            schema: Some("app".to_string()),
+            name: "refresh_cache".to_string(),
+            source: "ALTER PROCEDURE `refresh_cache` COMMENT 'refreshes cache'".to_string(),
+        })
+        .unwrap();
+
+        assert_eq!(statements, vec!["ALTER PROCEDURE `refresh_cache` COMMENT 'refreshes cache';"]);
+    }
+
+    #[test]
+    fn mysql_routine_source_opened_for_editing_keeps_create_statement() {
+        let sql = build_editable_object_source(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Mysql,
+            object_type: ObjectSourceKind::Procedure,
+            schema: Some("app".to_string()),
+            name: "refresh_cache".to_string(),
+            source: "CREATE PROCEDURE `refresh_cache`() BEGIN SELECT 1; END".to_string(),
+        });
+
+        assert_eq!(sql, "CREATE PROCEDURE `refresh_cache`() BEGIN SELECT 1; END;");
+    }
+
+    #[test]
+    fn mysql_routine_export_uses_delimiter_script() {
+        let sql = build_export_object_source_sql(
+            DatabaseType::Mysql,
+            ObjectSourceKind::Procedure,
+            "CREATE DEFINER=`root`@`%` PROCEDURE `refresh_cache`()\nBEGIN\n  SELECT 1;\nEND",
+        );
+
+        assert_eq!(
+            sql,
+            "DELIMITER //\nCREATE DEFINER=`root`@`%` PROCEDURE `refresh_cache`()\nBEGIN\n  SELECT 1;\nEND//\nDELIMITER ;"
+        );
+    }
+
+    #[test]
+    fn mysql_routine_export_does_not_double_wrap_delimiter_script() {
+        let source = "DELIMITER //\nCREATE PROCEDURE `refresh_cache`()\nBEGIN\n  SELECT 1;\nEND//\nDELIMITER ;";
+
+        let sql = build_export_object_source_sql(DatabaseType::Mysql, ObjectSourceKind::Procedure, source);
+
+        assert_eq!(sql, source);
+    }
+
+    #[test]
+    fn mysql_view_export_keeps_regular_statement_terminator() {
+        let sql = build_export_object_source_sql(
+            DatabaseType::Mysql,
+            ObjectSourceKind::View,
+            "CREATE VIEW `active_users` AS SELECT `id` FROM `users`",
+        );
+
+        assert_eq!(sql, "CREATE VIEW `active_users` AS SELECT `id` FROM `users`;");
+    }
+
+    #[test]
+    fn sqlserver_view_source_opened_for_editing_shows_alter_view() {
+        let sql = build_editable_object_source(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::SqlServer,
+            object_type: ObjectSourceKind::View,
+            schema: Some("dbo".to_string()),
+            name: "v_active_users".to_string(),
+            source: "CREATE VIEW dbo.v_active_users AS SELECT id, name FROM users WHERE active = 1;".to_string(),
+        });
+        assert_eq!(sql, "ALTER VIEW dbo.v_active_users AS SELECT id, name FROM users WHERE active = 1;");
+    }
+
+    #[test]
+    fn sqlserver_view_body_opened_for_editing_shows_alter_view() {
+        let sql = build_editable_object_source(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::SqlServer,
+            object_type: ObjectSourceKind::View,
+            schema: Some("dbo".to_string()),
+            name: "new_view".to_string(),
+            source: "SELECT\n  *\nFROM AppInfo".to_string(),
+        });
+        assert_eq!(sql, "ALTER VIEW [dbo].[new_view] AS\nSELECT\n  *\nFROM AppInfo;");
+    }
+
+    #[test]
+    fn sqlserver_procedure_source_opened_for_editing_shows_alter() {
+        let sql = build_editable_object_source(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::SqlServer,
+            object_type: ObjectSourceKind::Procedure,
+            schema: Some("dbo".to_string()),
+            name: "usp_demo".to_string(),
+            source: "CREATE PROCEDURE dbo.usp_demo AS SELECT 1;".to_string(),
+        });
+        assert_eq!(sql, "ALTER PROCEDURE dbo.usp_demo AS SELECT 1;");
+    }
+
+    #[test]
+    fn oracle_family_routine_rename_rewrites_source_and_drops_original() {
+        let statements = build_routine_rename_object_source_statements(RoutineRenameObjectSourceInput {
+            database_type: DatabaseType::Dameng,
+            object_type: ObjectSourceKind::Procedure,
+            schema: Some("SYSDBA".to_string()),
+            name: "SP_TAB_BAKSET_REMOVE_BATCH".to_string(),
+            new_name: "SP_TAB_BAKSET_REMOVE_BATCH_2".to_string(),
+            source:
+                "CREATE OR REPLACE PROCEDURE \"SYSDBA\".\"SP_TAB_BAKSET_REMOVE_BATCH\" AS\nBEGIN\n  SELECT 1;\nEND;"
+                    .to_string(),
+        })
+        .unwrap();
+        assert_eq!(
+            statements,
+            vec![
+                "CREATE OR REPLACE PROCEDURE \"SYSDBA\".\"SP_TAB_BAKSET_REMOVE_BATCH_2\" AS\nBEGIN\n  SELECT 1;\nEND;",
+                "DROP PROCEDURE \"SYSDBA\".\"SP_TAB_BAKSET_REMOVE_BATCH\";",
+            ]
+        );
+    }
+}
diff --git a/crates/dbx-core/src/path_utils.rs b/crates/dbx-core/src/path_utils.rs
new file mode 100644
index 0000000..f5e5f9b
--- /dev/null
+++ b/crates/dbx-core/src/path_utils.rs
@@ -0,0 +1,19 @@
+pub fn expand_tilde(path: &str) -> String {
+    if !path.starts_with('~') {
+        return path.to_string();
+    }
+    if path.len() == 1 {
+        return home_dir().unwrap_or_else(|| path.to_string());
+    }
+    if path.as_bytes().get(1) == Some(&b'/') {
+        return match home_dir() {
+            Some(home) => home + &path[1..],
+            None => path.to_string(),
+        };
+    }
+    path.to_string()
+}
+
+fn home_dir() -> Option<String> {
+    std::env::var("HOME").or_else(|_| std::env::var("USERPROFILE")).ok()
+}
diff --git a/crates/dbx-core/src/plugins.rs b/crates/dbx-core/src/plugins.rs
new file mode 100644
index 0000000..70f5d59
--- /dev/null
+++ b/crates/dbx-core/src/plugins.rs
@@ -0,0 +1,612 @@
+use std::path::{Path, PathBuf};
+use std::process::Stdio;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+
+use serde::de::DeserializeOwned;
+use serde::{Deserialize, Serialize};
+use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt, BufReader};
+use tokio::process::{Child, ChildStdin, ChildStdout, Command};
+use tokio::sync::Mutex;
+use tokio::time::timeout;
+
+const PLUGIN_REQUEST_TIMEOUT: Duration = Duration::from_secs(30);
+pub const SUPPORTED_PLUGIN_PROTOCOL_VERSION: u32 = 1;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PluginManifest {
+    pub id: String,
+    pub name: String,
+    #[serde(default)]
+    pub version: String,
+    #[serde(default = "default_plugin_protocol_version")]
+    pub protocol_version: u32,
+    #[serde(default)]
+    pub description: String,
+    #[serde(default)]
+    pub executable: Option<String>,
+    #[serde(default)]
+    pub drivers: Vec<PluginDriverManifest>,
+}
+
+fn default_plugin_protocol_version() -> u32 {
+    1
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PluginDriverManifest {
+    pub id: String,
+    pub label: String,
+    pub kind: String,
+    #[serde(default)]
+    pub database_type: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct InstalledPlugin {
+    pub manifest: PluginManifest,
+    pub path: PathBuf,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct PluginRuntimeEnv {
+    vars: Vec<(String, String)>,
+}
+
+impl PluginRuntimeEnv {
+    pub fn with_var(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        self.vars.push((key.into(), value.into()));
+        self
+    }
+
+    pub fn get(&self, key: &str) -> Option<&str> {
+        self.vars.iter().find_map(|(name, value)| (name == key).then_some(value.as_str()))
+    }
+
+    pub fn apply_to(&self, command: &mut Command) {
+        for (key, value) in &self.vars {
+            command.env(key, value);
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct PluginRegistry {
+    root_dir: PathBuf,
+}
+
+impl PluginRegistry {
+    pub fn new(root_dir: PathBuf) -> Self {
+        Self { root_dir }
+    }
+
+    pub fn root_dir(&self) -> &Path {
+        &self.root_dir
+    }
+
+    pub fn list_installed(&self) -> Result<Vec<InstalledPlugin>, String> {
+        let entries = match std::fs::read_dir(&self.root_dir) {
+            Ok(entries) => entries,
+            Err(err) if err.kind() == std::io::ErrorKind::NotFound => return Ok(vec![]),
+            Err(err) => return Err(err.to_string()),
+        };
+
+        let mut plugins = Vec::new();
+        for entry in entries {
+            let entry = entry.map_err(|err| err.to_string())?;
+            let path = entry.path();
+            if !path.is_dir() {
+                continue;
+            }
+            let manifest_path = path.join("manifest.json");
+            if !manifest_path.exists() {
+                continue;
+            }
+            let raw = std::fs::read_to_string(&manifest_path).map_err(|err| err.to_string())?;
+            let manifest: PluginManifest = serde_json::from_str(&raw)
+                .map_err(|err| format!("Failed to parse plugin manifest {}: {err}", manifest_path.display()))?;
+            plugins.push(InstalledPlugin { manifest, path });
+        }
+        plugins.sort_by(|a, b| a.manifest.id.cmp(&b.manifest.id));
+        Ok(plugins)
+    }
+
+    pub fn find_driver(&self, driver_id: &str) -> Result<Option<InstalledPlugin>, String> {
+        Ok(self.list_installed()?.into_iter().find(|plugin| {
+            plugin
+                .manifest
+                .drivers
+                .iter()
+                .any(|driver| driver.id == driver_id || driver.database_type.as_deref() == Some(driver_id))
+        }))
+    }
+
+    pub async fn invoke_driver<T>(&self, driver_id: &str, method: &str, params: serde_json::Value) -> Result<T, String>
+    where
+        T: DeserializeOwned,
+    {
+        self.invoke_driver_with_env(driver_id, method, params, PluginRuntimeEnv::default()).await
+    }
+
+    pub async fn invoke_driver_with_env<T>(
+        &self,
+        driver_id: &str,
+        method: &str,
+        params: serde_json::Value,
+        env: PluginRuntimeEnv,
+    ) -> Result<T, String>
+    where
+        T: DeserializeOwned,
+    {
+        self.invoke_driver_with_env_and_timeout(driver_id, method, params, env, Some(PLUGIN_REQUEST_TIMEOUT)).await
+    }
+
+    pub async fn invoke_driver_with_env_and_timeout<T>(
+        &self,
+        driver_id: &str,
+        method: &str,
+        params: serde_json::Value,
+        env: PluginRuntimeEnv,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String>
+    where
+        T: DeserializeOwned,
+    {
+        let plugin =
+            self.find_driver(driver_id)?.ok_or_else(|| format!("Plugin driver '{driver_id}' is not installed"))?;
+        ensure_plugin_protocol_compatible(&plugin.manifest)?;
+        let invoke = invoke_plugin(&plugin, driver_id, method, params, &env);
+        match timeout_duration {
+            Some(duration) => timeout(duration, invoke).await.map_err(|_| {
+                format!("Plugin '{}' timed out after {} seconds", plugin.manifest.id, duration.as_secs())
+            })?,
+            None => invoke.await,
+        }
+    }
+
+    pub async fn start_driver_session(&self, driver_id: &str) -> Result<Arc<PluginDriverSession>, String> {
+        self.start_driver_session_with_env(driver_id, PluginRuntimeEnv::default()).await
+    }
+
+    pub async fn start_driver_session_with_env(
+        &self,
+        driver_id: &str,
+        env: PluginRuntimeEnv,
+    ) -> Result<Arc<PluginDriverSession>, String> {
+        let plugin =
+            self.find_driver(driver_id)?.ok_or_else(|| format!("Plugin driver '{driver_id}' is not installed"))?;
+        ensure_plugin_protocol_compatible(&plugin.manifest)?;
+        PluginDriverSession::start(plugin, driver_id.to_string(), env).await.map(Arc::new)
+    }
+}
+
+fn ensure_plugin_protocol_compatible(manifest: &PluginManifest) -> Result<(), String> {
+    if manifest.protocol_version == SUPPORTED_PLUGIN_PROTOCOL_VERSION {
+        return Ok(());
+    }
+    Err(format!(
+        "Plugin '{}' uses protocol version {}, but this DBX build supports protocol version {}",
+        manifest.id, manifest.protocol_version, SUPPORTED_PLUGIN_PROTOCOL_VERSION
+    ))
+}
+
+#[derive(Debug, Serialize)]
+struct PluginRequest {
+    jsonrpc: &'static str,
+    id: u64,
+    driver: String,
+    method: String,
+    params: serde_json::Value,
+}
+
+#[derive(Debug, Deserialize)]
+struct PluginResponse {
+    id: u64,
+    #[serde(default)]
+    result: Option<serde_json::Value>,
+    #[serde(default)]
+    error: Option<PluginError>,
+}
+
+#[derive(Debug, Deserialize)]
+struct PluginError {
+    message: String,
+}
+
+pub struct PluginDriverSession {
+    plugin: InstalledPlugin,
+    driver_id: String,
+    process: Mutex<PluginProcess>,
+    next_request_id: AtomicU64,
+}
+
+struct PluginProcess {
+    child: Child,
+    stdin: ChildStdin,
+    stdout: BufReader<ChildStdout>,
+}
+
+impl PluginDriverSession {
+    async fn start(plugin: InstalledPlugin, driver_id: String, env: PluginRuntimeEnv) -> Result<Self, String> {
+        let mut child = spawn_plugin_child(&plugin, &env)?;
+        let stdin = child.stdin.take().ok_or("Plugin stdin unavailable")?;
+        let stdout = child.stdout.take().ok_or("Plugin stdout unavailable")?;
+        if let Some(stderr) = child.stderr.take() {
+            let plugin_id = plugin.manifest.id.clone();
+            tokio::spawn(async move {
+                let mut stderr = BufReader::new(stderr);
+                loop {
+                    match read_plugin_line(&mut stderr, "stderr").await {
+                        Ok(line) => log::warn!("[plugin:{plugin_id}] {}", line.trim_end()),
+                        Err(err) if err.contains("end of stream") => break,
+                        Err(err) => {
+                            log::warn!("[plugin:{plugin_id}] failed to read stderr: {err}");
+                            break;
+                        }
+                    }
+                }
+            });
+        }
+
+        Ok(Self {
+            plugin,
+            driver_id,
+            process: Mutex::new(PluginProcess { child, stdin, stdout: BufReader::new(stdout) }),
+            next_request_id: AtomicU64::new(1),
+        })
+    }
+
+    pub async fn invoke<T>(&self, method: &str, params: serde_json::Value) -> Result<T, String>
+    where
+        T: DeserializeOwned,
+    {
+        self.invoke_with_timeout(method, params, Some(PLUGIN_REQUEST_TIMEOUT)).await
+    }
+
+    pub async fn invoke_with_timeout<T>(
+        &self,
+        method: &str,
+        params: serde_json::Value,
+        timeout_duration: Option<Duration>,
+    ) -> Result<T, String>
+    where
+        T: DeserializeOwned,
+    {
+        let request_id = self.next_request_id.fetch_add(1, Ordering::Relaxed);
+        let invoke = async {
+            let mut process = self.process.lock().await;
+            self.invoke_locked(&mut process, request_id, method, params).await
+        };
+        match timeout_duration {
+            Some(duration) => match timeout(duration, invoke).await {
+                Ok(result) => result,
+                Err(_) => {
+                    self.kill().await;
+                    Err(format!("Plugin '{}' timed out after {} seconds", self.plugin.manifest.id, duration.as_secs()))
+                }
+            },
+            None => invoke.await,
+        }
+    }
+
+    async fn invoke_locked<T>(
+        &self,
+        process: &mut PluginProcess,
+        request_id: u64,
+        method: &str,
+        params: serde_json::Value,
+    ) -> Result<T, String>
+    where
+        T: DeserializeOwned,
+    {
+        let request = PluginRequest {
+            jsonrpc: "2.0",
+            id: request_id,
+            driver: self.driver_id.clone(),
+            method: method.to_string(),
+            params,
+        };
+        let line = encode_plugin_request_line(&request)?;
+        process.stdin.write_all(&line).await.map_err(|err| err.to_string())?;
+        process.stdin.flush().await.map_err(|err| err.to_string())?;
+
+        let stdout = &mut process.stdout;
+        let child = &mut process.child;
+        read_decoded_plugin_response(&self.plugin, request_id, stdout, || {
+            let status = child.try_wait().map_err(|err| err.to_string())?;
+            Ok(match status {
+                Some(status) => format!("Plugin '{}' exited with status {}", self.plugin.manifest.id, status),
+                None => format!("Plugin '{}' closed stdout without a response", self.plugin.manifest.id),
+            })
+        })
+        .await
+    }
+
+    async fn kill(&self) {
+        let mut process = self.process.lock().await;
+        let _ = process.child.kill().await;
+    }
+
+    pub async fn shutdown(&self) {
+        self.kill().await;
+    }
+
+    pub async fn pid(&self) -> Option<u32> {
+        let process = self.process.lock().await;
+        process.child.id()
+    }
+
+    #[cfg(test)]
+    pub(crate) async fn start_for_test(
+        plugin: InstalledPlugin,
+        driver_id: String,
+        env: PluginRuntimeEnv,
+    ) -> Result<Self, String> {
+        Self::start(plugin, driver_id, env).await
+    }
+}
+
+async fn invoke_plugin<T>(
+    plugin: &InstalledPlugin,
+    driver_id: &str,
+    method: &str,
+    params: serde_json::Value,
+    env: &PluginRuntimeEnv,
+) -> Result<T, String>
+where
+    T: DeserializeOwned,
+{
+    let mut child = spawn_plugin_child(plugin, env)?;
+
+    let request =
+        PluginRequest { jsonrpc: "2.0", id: 1, driver: driver_id.to_string(), method: method.to_string(), params };
+    let line = encode_plugin_request_line(&request)?;
+
+    let mut stdin = child.stdin.take().ok_or("Plugin stdin unavailable")?;
+    stdin.write_all(&line).await.map_err(|err| err.to_string())?;
+    drop(stdin);
+
+    let stdout = child.stdout.take().ok_or("Plugin stdout unavailable")?;
+    let mut stderr = child.stderr.take().ok_or("Plugin stderr unavailable")?;
+    let mut reader = BufReader::new(stdout);
+    let response_result = read_decoded_plugin_response(plugin, request.id, &mut reader, || {
+        Ok(format!("Plugin '{}' exited without a response", plugin.manifest.id))
+    })
+    .await;
+    let mut stderr_bytes = Vec::new();
+    stderr.read_to_end(&mut stderr_bytes).await.map_err(|err| err.to_string())?;
+    let stderr_text = String::from_utf8_lossy(&stderr_bytes).into_owned();
+    let status = child.wait().await.map_err(|err| err.to_string())?;
+
+    let response = match response_result {
+        Ok(response) => response,
+        Err(err) if err.contains("end of stream") => {
+            let stderr = stderr_text.trim().to_string();
+            return Err(if stderr.is_empty() {
+                format!("Plugin '{}' exited without a response", plugin.manifest.id)
+            } else {
+                format!("Plugin '{}' exited without a response: {stderr}", plugin.manifest.id)
+            });
+        }
+        Err(err) => return Err(err),
+    };
+    if !status.success() {
+        let stderr = stderr_text.trim().to_string();
+        return Err(if stderr.is_empty() {
+            format!("Plugin '{}' exited with status {}", plugin.manifest.id, status)
+        } else {
+            format!("Plugin '{}' failed: {stderr}", plugin.manifest.id)
+        });
+    }
+
+    Ok(response)
+}
+
+fn encode_plugin_request_line(request: &PluginRequest) -> Result<Vec<u8>, String> {
+    let mut bytes = Vec::new();
+    serde_json::to_writer(&mut bytes, request).map_err(|err| err.to_string())?;
+    bytes.push(b'\n');
+    Ok(bytes)
+}
+
+fn spawn_plugin_child(plugin: &InstalledPlugin, env: &PluginRuntimeEnv) -> Result<Child, String> {
+    let executable = plugin
+        .manifest
+        .executable
+        .as_deref()
+        .filter(|value| !value.is_empty())
+        .ok_or_else(|| format!("Plugin '{}' does not declare an executable", plugin.manifest.id))?;
+    let executable_path = resolve_plugin_executable(&plugin.path, executable);
+
+    let mut command = crate::process::new_tokio_command(&executable_path);
+    command
+        .current_dir(&plugin.path)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .kill_on_drop(true);
+    env.apply_to(&mut command);
+
+    command.spawn().map_err(|err| format!("Failed to start plugin '{}': {err}", plugin.manifest.id))
+}
+
+async fn read_plugin_line<R>(reader: &mut R, context: &str) -> Result<String, String>
+where
+    R: tokio::io::AsyncBufRead + Unpin,
+{
+    let mut bytes = Vec::new();
+    reader.read_until(b'\n', &mut bytes).await.map_err(|err| format!("Failed to read plugin {context}: {err}"))?;
+    if bytes.is_empty() {
+        return Err(format!("Failed to read plugin {context}: end of stream"));
+    }
+    Ok(String::from_utf8_lossy(&bytes).into_owned())
+}
+
+async fn read_decoded_plugin_response<T, R, F>(
+    plugin: &InstalledPlugin,
+    request_id: u64,
+    reader: &mut R,
+    end_of_stream_message: F,
+) -> Result<T, String>
+where
+    T: DeserializeOwned,
+    R: tokio::io::AsyncBufRead + Unpin,
+    F: FnMut() -> Result<String, String>,
+{
+    let mut end_of_stream_message = end_of_stream_message;
+    const MAX_NOISY_LINES: usize = 20;
+    for _ in 0..MAX_NOISY_LINES {
+        let line = match read_plugin_line(reader, "response").await {
+            Ok(line) => line,
+            Err(err) if err.contains("end of stream") => return Err(end_of_stream_message()?),
+            Err(err) => return Err(err),
+        };
+        match decode_plugin_response(plugin, request_id, &line) {
+            Ok(response) => return Ok(response),
+            Err(err) if err.starts_with(&format!("Failed to parse plugin '{}' response:", plugin.manifest.id)) => {
+                log::warn!("[plugin:{}] ignored non-protocol stdout: {}", plugin.manifest.id, line.trim_end());
+            }
+            Err(err) => return Err(err),
+        }
+    }
+    match read_plugin_line(reader, "response").await {
+        Ok(_) => {
+            Err(format!("Plugin '{}' wrote too many non-protocol stdout lines before its response", plugin.manifest.id))
+        }
+        Err(err) if err.contains("end of stream") => Err(end_of_stream_message()?),
+        Err(err) => Err(err),
+    }
+}
+
+fn decode_plugin_response<T>(plugin: &InstalledPlugin, request_id: u64, response_line: &str) -> Result<T, String>
+where
+    T: DeserializeOwned,
+{
+    let response: PluginResponse = serde_json::from_str(response_line)
+        .map_err(|err| format!("Failed to parse plugin '{}' response: {err}", plugin.manifest.id))?;
+    if response.id != request_id {
+        return Err(format!("Plugin '{}' returned mismatched response id", plugin.manifest.id));
+    }
+    if let Some(error) = response.error {
+        return Err(error.message);
+    }
+    let result = response.result.unwrap_or(serde_json::Value::Null);
+    serde_json::from_value(result)
+        .map_err(|err| format!("Failed to decode plugin '{}' result: {err}", plugin.manifest.id))
+}
+
+fn resolve_plugin_executable(plugin_dir: &Path, executable: &str) -> PathBuf {
+    let path = PathBuf::from(executable);
+    let resolved = if path.is_absolute() { path } else { plugin_dir.join(path) };
+
+    #[cfg(windows)]
+    {
+        let bat = resolved.with_extension("bat");
+        if bat.exists() {
+            return bat;
+        }
+    }
+
+    resolved
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        read_decoded_plugin_response, read_plugin_line, InstalledPlugin, PluginDriverManifest, PluginDriverSession,
+        PluginManifest, PluginRuntimeEnv,
+    };
+    use std::path::PathBuf;
+    use tokio::io::BufReader;
+
+    #[tokio::test]
+    async fn reads_non_utf8_plugin_lines_lossily() {
+        let bytes = vec![b'{', b'"', b'e', b'r', b'r', b'o', b'r', b'"', b':', 0xB2, 0xE2, b'}', b'\n'];
+        let mut reader = BufReader::new(std::io::Cursor::new(bytes));
+
+        let line = read_plugin_line(&mut reader, "response").await.expect("line should be readable");
+
+        assert_eq!(line, format!("{{\"error\":{}}}\n", "\u{fffd}\u{fffd}"));
+    }
+
+    #[tokio::test]
+    async fn skips_noisy_plugin_stdout_before_json_response() {
+        let plugin = InstalledPlugin {
+            manifest: PluginManifest {
+                id: "jdbc".to_string(),
+                name: "JDBC".to_string(),
+                version: "test".to_string(),
+                protocol_version: 1,
+                description: String::new(),
+                executable: None,
+                drivers: Vec::new(),
+            },
+            path: PathBuf::new(),
+        };
+        let bytes = b"driver banner\n{\"id\":1,\"result\":{\"ok\":true}}\n";
+        let mut reader = BufReader::new(std::io::Cursor::new(bytes));
+
+        let result: serde_json::Value =
+            read_decoded_plugin_response(&plugin, 1, &mut reader, || Ok("closed".to_string()))
+                .await
+                .expect("response should decode after noisy line");
+
+        assert_eq!(result["ok"], true);
+    }
+
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn shutdown_kills_plugin_child_process() {
+        let dir = std::env::temp_dir().join(format!("dbx-plugin-shutdown-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let executable = dir.join("plugin.sh");
+        std::fs::write(&executable, "#!/bin/sh\nsleep 30\n").unwrap();
+        {
+            use std::os::unix::fs::PermissionsExt;
+
+            let mut permissions = std::fs::metadata(&executable).unwrap().permissions();
+            permissions.set_mode(0o755);
+            std::fs::set_permissions(&executable, permissions).unwrap();
+        }
+        let plugin = InstalledPlugin {
+            manifest: PluginManifest {
+                id: "jdbc".to_string(),
+                name: "JDBC".to_string(),
+                version: "test".to_string(),
+                protocol_version: 1,
+                description: String::new(),
+                executable: Some("plugin.sh".to_string()),
+                drivers: vec![PluginDriverManifest {
+                    id: "jdbc".to_string(),
+                    label: "JDBC".to_string(),
+                    kind: "external".to_string(),
+                    database_type: Some("jdbc".to_string()),
+                }],
+            },
+            path: dir.clone(),
+        };
+
+        let session = PluginDriverSession::start(plugin, "jdbc".to_string(), PluginRuntimeEnv::default())
+            .await
+            .expect("session should start");
+        let pid = session.pid().await.expect("child should have a pid");
+
+        session.shutdown().await;
+        tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+
+        assert!(!process_exists(pid));
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(unix)]
+    fn process_exists(pid: u32) -> bool {
+        std::process::Command::new("kill")
+            .arg("-0")
+            .arg(pid.to_string())
+            .stderr(std::process::Stdio::null())
+            .status()
+            .map(|status| status.success())
+            .unwrap_or(false)
+    }
+}
diff --git a/crates/dbx-core/src/process.rs b/crates/dbx-core/src/process.rs
new file mode 100644
index 0000000..6df6cf7
--- /dev/null
+++ b/crates/dbx-core/src/process.rs
@@ -0,0 +1,37 @@
+use std::ffi::OsStr;
+
+#[cfg(windows)]
+const CREATE_NO_WINDOW: u32 = 0x08000000;
+
+pub fn new_std_command(program: impl AsRef<OsStr>) -> std::process::Command {
+    let mut command = std::process::Command::new(program);
+    hide_std_console_window(&mut command);
+    command
+}
+
+pub fn hide_std_console_window(command: &mut std::process::Command) {
+    #[cfg(not(windows))]
+    let _ = command;
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        // DBX is a GUI app; console subprocesses should not flash a window.
+        command.creation_flags(CREATE_NO_WINDOW);
+    }
+}
+
+pub fn new_tokio_command(program: impl AsRef<OsStr>) -> tokio::process::Command {
+    let mut command = tokio::process::Command::new(program);
+    hide_tokio_console_window(&mut command);
+    command
+}
+
+pub fn hide_tokio_console_window(command: &mut tokio::process::Command) {
+    #[cfg(not(windows))]
+    let _ = command;
+    #[cfg(windows)]
+    {
+        // Keep async child processes consistent with std::process::Command.
+        command.creation_flags(CREATE_NO_WINDOW);
+    }
+}
diff --git a/crates/dbx-core/src/production_safety.rs b/crates/dbx-core/src/production_safety.rs
new file mode 100644
index 0000000..e21f91c
--- /dev/null
+++ b/crates/dbx-core/src/production_safety.rs
@@ -0,0 +1,687 @@
+use crate::models::connection::{ConnectionConfig, DatabaseType};
+use regex::Regex;
+use std::collections::{HashMap, HashSet};
+use std::sync::LazyLock;
+
+const IDENTIFIER_PATTERN: &str = r"[A-Za-z0-9_@$#-]*[A-Za-z_@$#][A-Za-z0-9_@$#-]*";
+const TARGET_NAME_PATTERN: &str = r"[A-Za-z0-9_@$#-]*[A-Za-z_@$#][A-Za-z0-9_@$#-]*(?:\s*\.\s*(?:\*|[A-Za-z0-9_@$#-]*[A-Za-z_@$#][A-Za-z0-9_@$#-]*)){0,2}";
+const QUALIFIED_NAME_PATTERN: &str = r"[A-Za-z0-9_@$#-]*[A-Za-z_@$#][A-Za-z0-9_@$#-]*\s*\.\s*(?:\*|[A-Za-z0-9_@$#-]*[A-Za-z_@$#][A-Za-z0-9_@$#-]*)(?:\s*\.\s*(?:\*|[A-Za-z0-9_@$#-]*[A-Za-z_@$#][A-Za-z0-9_@$#-]*))?";
+
+static DML_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(r"(?is)\b(?:FROM|JOIN|UPDATE|INTO|REFERENCES)\s+({TARGET_NAME_PATTERN})"))
+        .expect("valid DML target regex")
+});
+static DDL_OBJECT_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(
+        r"(?is)\b(?:CREATE|ALTER|DROP)\s+(?:OR\s+REPLACE\s+)?(?:TABLE|VIEW|MATERIALIZED\s+VIEW|INDEX|SEQUENCE|FUNCTION|PROCEDURE|ROUTINE|TRIGGER|EVENT|TYPE|SYNONYM)\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?(?:ONLY\s+)?({TARGET_NAME_PATTERN})"
+    ))
+    .expect("valid DDL object target regex")
+});
+static INDEX_ON_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(r"(?is)\b(?:CREATE|ALTER|DROP)\s+(?:UNIQUE\s+)?INDEX\b.*?\bON\s+({TARGET_NAME_PATTERN})"))
+        .expect("valid index target regex")
+});
+static DATABASE_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(
+        r"(?is)\b(?:CREATE|ALTER|DROP)\s+(DATABASE|SCHEMA|CATALOG)\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?({IDENTIFIER_PATTERN})"
+    ))
+    .expect("valid database target regex")
+});
+static USE_RE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(&format!(r"(?is)^\s*USE\s+({IDENTIFIER_PATTERN})")).expect("valid USE regex"));
+static COPY_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(r"(?is)^\s*COPY\s+({TARGET_NAME_PATTERN})\s+FROM\b")).expect("valid COPY target regex")
+});
+static TRUNCATE_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(r"(?is)\bTRUNCATE\s+(?:TABLE\s+)?({TARGET_NAME_PATTERN})"))
+        .expect("valid truncate target regex")
+});
+static RENAME_TABLE_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(r"(?is)\bRENAME\s+TABLE\s+({TARGET_NAME_PATTERN})\s+TO\s+({TARGET_NAME_PATTERN})"))
+        .expect("valid rename table target regex")
+});
+static MAINTENANCE_TABLE_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(
+        r"(?is)\b(?:ANALYZE|OPTIMIZE|REPAIR|CHECK)\s+(?:NO_WRITE_TO_BINLOG\s+|LOCAL\s+)?TABLE\s+({TARGET_NAME_PATTERN})"
+    ))
+    .expect("valid maintenance table target regex")
+});
+static COMMENT_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(
+        r"(?is)\bCOMMENT\s+ON\s+(?:TABLE|VIEW|COLUMN|INDEX|SEQUENCE|FUNCTION|PROCEDURE|TYPE)\s+({TARGET_NAME_PATTERN})"
+    ))
+    .expect("valid comment target regex")
+});
+static ROUTINE_CALL_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(r"(?is)\b(?:CALL|EXEC|EXECUTE)\s+({QUALIFIED_NAME_PATTERN})"))
+        .expect("valid routine call target regex")
+});
+static PRIVILEGE_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(
+        r"(?is)\b(?:GRANT|REVOKE|DENY)\b.*?\bON\s+(?:(?:TABLE|SEQUENCE|FUNCTION|PROCEDURE|ROUTINE|OBJECT)\s+|OBJECT\s*::\s*)?({QUALIFIED_NAME_PATTERN})"
+    ))
+    .expect("valid privilege target regex")
+});
+static PRIVILEGE_DATABASE_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(&format!(
+        r"(?is)\b(?:GRANT|REVOKE|DENY)\b.*?\bON\s+(?:DATABASE|CATALOG)(?:::|\s+)\s*({IDENTIFIER_PATTERN})"
+    ))
+    .expect("valid privilege database target regex")
+});
+static GLOBAL_PRIVILEGE_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"(?is)\b(?:GRANT|REVOKE|DENY)\b.*?\bON\s+\*\s*\.\s*\*").expect("valid global privilege target regex")
+});
+static GLOBAL_DDL_TARGET_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"(?is)^\s*(?:CREATE|ALTER|DROP)\s+(?:USER|ROLE|LOGIN|SERVER|TABLESPACE|RESOURCE|PROFILE|ACCOUNT)\b")
+        .expect("valid global DDL target regex")
+});
+static MULTI_TARGET_MUTATION_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"(?is)^\s*(?:DROP\s+(?:TEMPORARY\s+)?TABLE\b.*,|RENAME\s+TABLE\b.*,)")
+        .expect("valid multi-target mutation regex")
+});
+static FIRST_KEYWORD_RE: LazyLock<Regex> =
+    LazyLock::new(|| Regex::new(IDENTIFIER_PATTERN).expect("valid first keyword regex"));
+
+#[derive(Default)]
+struct ReferencedDatabaseAssessment {
+    databases: HashSet<String>,
+    uncertain: bool,
+}
+
+#[derive(Default)]
+struct SqlTargetSafetyText {
+    text: String,
+    quoted_identifiers: HashMap<String, String>,
+}
+
+/// Returns whether the selected database inherits an explicit production marker.
+pub fn is_production_database(config: &ConnectionConfig, database: &str) -> bool {
+    config.is_production
+        || (!database.trim().is_empty()
+            && config
+                .production_databases
+                .iter()
+                .any(|name| normalize_database_name(name) == normalize_database_name(database)))
+}
+
+/// Returns whether a non-read SQL statement targets production scope.
+///
+/// Agent execution already classifies SQL risk with `sql_risk`; this function
+/// focuses only on production scope, including qualified cross-database writes
+/// such as `DELETE FROM prod_app.users` while the selected database is staging.
+pub fn targets_production_database(config: &ConnectionConfig, active_database: &str, sql: &str) -> bool {
+    if is_production_database(config, active_database) {
+        return true;
+    }
+
+    let marked: HashSet<String> =
+        config.production_databases.iter().map(|name| normalize_database_name(name)).collect();
+    if marked.is_empty() {
+        return false;
+    }
+
+    let assessment = referenced_databases(sql, &config.db_type, active_database);
+    assessment.databases.into_iter().any(|database| marked.contains(&database)) || assessment.uncertain
+}
+
+fn normalize_database_name(value: &str) -> String {
+    value.trim().trim_matches(|ch| matches!(ch, '`' | '"' | '[' | ']')).to_ascii_lowercase()
+}
+
+fn referenced_databases(sql: &str, db_type: &DatabaseType, active_database: &str) -> ReferencedDatabaseAssessment {
+    let mut assessment = ReferencedDatabaseAssessment::default();
+    let cleaned = sql_target_safety_text(sql);
+    let mut use_database = String::new();
+    let normalized_active_database = normalize_database_name(active_database);
+
+    for statement in cleaned.text.split(';').map(str::trim).filter(|statement| !statement.is_empty()) {
+        let mut statement_databases = HashSet::new();
+        let statement_is_mutation = crate::query_execution_sql::is_write_sql(statement);
+        if let Some(database) = USE_RE
+            .captures(statement)
+            .and_then(|capture| capture.get(1))
+            .map(|value| normalize_target_database_name(value.as_str(), &cleaned.quoted_identifiers))
+            .filter(|value| !value.is_empty())
+        {
+            use_database = database;
+            continue;
+        }
+
+        if !statement_is_mutation {
+            continue;
+        }
+
+        let current_database =
+            if use_database.is_empty() { normalized_active_database.as_str() } else { use_database.as_str() };
+
+        collect_qualified_target_databases(
+            statement,
+            db_type,
+            &cleaned.quoted_identifiers,
+            current_database,
+            &mut statement_databases,
+            &[
+                &DML_TARGET_RE,
+                &DDL_OBJECT_TARGET_RE,
+                &INDEX_ON_TARGET_RE,
+                &TRUNCATE_TARGET_RE,
+                &MAINTENANCE_TABLE_TARGET_RE,
+                &COMMENT_TARGET_RE,
+                &ROUTINE_CALL_TARGET_RE,
+                &PRIVILEGE_TARGET_RE,
+            ],
+        );
+        collect_qualified_target_database_groups(
+            statement,
+            db_type,
+            &cleaned.quoted_identifiers,
+            current_database,
+            &mut statement_databases,
+            &RENAME_TABLE_TARGET_RE,
+            &[1, 2],
+        );
+        for capture in DATABASE_TARGET_RE.captures_iter(statement) {
+            if let Some(database) = capture
+                .get(1)
+                .filter(|kind| database_target_kind_means_database(kind.as_str(), db_type))
+                .and_then(|_| capture.get(2))
+                .map(|value| normalize_target_database_name(value.as_str(), &cleaned.quoted_identifiers))
+                .filter(|value| !value.is_empty())
+            {
+                statement_databases.insert(database);
+            }
+        }
+        for capture in PRIVILEGE_DATABASE_TARGET_RE.captures_iter(statement) {
+            if let Some(database) = capture
+                .get(1)
+                .map(|value| normalize_target_database_name(value.as_str(), &cleaned.quoted_identifiers))
+                .filter(|value| !value.is_empty())
+            {
+                statement_databases.insert(database);
+            }
+        }
+        if let Some(database) = COPY_TARGET_RE
+            .captures(statement)
+            .and_then(|capture| capture.get(1))
+            .and_then(|target| {
+                database_from_qualified_name(target.as_str(), db_type, &cleaned.quoted_identifiers, current_database)
+            })
+            .filter(|value| !value.is_empty())
+        {
+            statement_databases.insert(database);
+        }
+        let has_resolved_target = !statement_databases.is_empty();
+        assessment.databases.extend(statement_databases);
+        // The target regexes intentionally extract one object at a time. Until all
+        // list forms are parsed, never let a resolved first target disable fallback.
+        assessment.uncertain = assessment.uncertain
+            || GLOBAL_PRIVILEGE_TARGET_RE.is_match(statement)
+            || MULTI_TARGET_MUTATION_RE.is_match(statement)
+            || is_ambiguous_production_target_statement(statement, has_resolved_target);
+    }
+    assessment
+}
+
+fn collect_qualified_target_databases(
+    statement: &str,
+    db_type: &DatabaseType,
+    quoted_identifiers: &HashMap<String, String>,
+    current_database: &str,
+    databases: &mut HashSet<String>,
+    patterns: &[&LazyLock<Regex>],
+) {
+    for pattern in patterns {
+        collect_qualified_target_database_groups(
+            statement,
+            db_type,
+            quoted_identifiers,
+            current_database,
+            databases,
+            pattern,
+            &[1],
+        );
+    }
+}
+
+fn collect_qualified_target_database_groups(
+    statement: &str,
+    db_type: &DatabaseType,
+    quoted_identifiers: &HashMap<String, String>,
+    current_database: &str,
+    databases: &mut HashSet<String>,
+    pattern: &LazyLock<Regex>,
+    capture_indexes: &[usize],
+) {
+    for capture in pattern.captures_iter(statement) {
+        for capture_index in capture_indexes {
+            if let Some(database) = capture
+                .get(*capture_index)
+                .and_then(|target| {
+                    database_from_qualified_name(target.as_str(), db_type, quoted_identifiers, current_database)
+                })
+                .filter(|value| !value.is_empty())
+            {
+                databases.insert(database);
+            }
+        }
+    }
+}
+
+fn database_from_qualified_name(
+    qualified_name: &str,
+    db_type: &DatabaseType,
+    quoted_identifiers: &HashMap<String, String>,
+    current_database: &str,
+) -> Option<String> {
+    let parts: Vec<String> = qualified_name
+        .split('.')
+        .map(|part| normalize_target_database_name(part, quoted_identifiers))
+        .filter(|part| !part.is_empty())
+        .collect();
+    if parts.len() < 2 {
+        return (!current_database.is_empty()).then(|| current_database.to_string());
+    }
+    if qualified_first_part_is_database(db_type, parts.len()) {
+        return parts.first().cloned();
+    }
+    (!current_database.is_empty()).then(|| current_database.to_string())
+}
+
+fn normalize_target_database_name(value: &str, quoted_identifiers: &HashMap<String, String>) -> String {
+    let normalized = normalize_database_name(value);
+    quoted_identifiers.get(&normalized).map(|quoted| normalize_database_name(quoted)).unwrap_or(normalized)
+}
+
+fn qualified_first_part_is_database(db_type: &DatabaseType, part_count: usize) -> bool {
+    if part_count >= 3
+        && matches!(
+            db_type,
+            DatabaseType::SqlServer
+                | DatabaseType::Snowflake
+                | DatabaseType::Trino
+                | DatabaseType::PrestoSql
+                | DatabaseType::Databricks
+                | DatabaseType::Bigquery
+        )
+    {
+        return true;
+    }
+    if schema_first_qualifier_type(db_type) {
+        return false;
+    }
+    part_count >= 2
+}
+
+fn database_target_kind_means_database(kind: &str, db_type: &DatabaseType) -> bool {
+    if kind.eq_ignore_ascii_case("database") || kind.eq_ignore_ascii_case("catalog") {
+        return true;
+    }
+    kind.eq_ignore_ascii_case("schema") && !schema_first_qualifier_type(db_type)
+}
+
+fn schema_first_qualifier_type(db_type: &DatabaseType) -> bool {
+    matches!(
+        db_type,
+        DatabaseType::Postgres
+            | DatabaseType::Redshift
+            | DatabaseType::Gaussdb
+            | DatabaseType::Kwdb
+            | DatabaseType::OpenGauss
+            | DatabaseType::Kingbase
+            | DatabaseType::Highgo
+            | DatabaseType::Vastbase
+            | DatabaseType::Yashandb
+            | DatabaseType::Oracle
+            | DatabaseType::OceanbaseOracle
+            | DatabaseType::Dameng
+            | DatabaseType::Firebird
+            | DatabaseType::Exasol
+            | DatabaseType::Teradata
+            | DatabaseType::Vertica
+            | DatabaseType::Db2
+            | DatabaseType::Informix
+            | DatabaseType::H2
+            | DatabaseType::Iris
+            | DatabaseType::Xugu
+            | DatabaseType::Oscar
+            | DatabaseType::Gbase
+            | DatabaseType::SapHana
+            | DatabaseType::SqlServer
+            | DatabaseType::Snowflake
+            | DatabaseType::Trino
+            | DatabaseType::PrestoSql
+            | DatabaseType::Databricks
+            | DatabaseType::Bigquery
+    )
+}
+
+fn is_ambiguous_production_target_statement(statement: &str, has_resolved_target: bool) -> bool {
+    if !crate::query_execution_sql::is_write_sql(statement) {
+        return false;
+    }
+    let Some(first_keyword) = first_keyword(statement) else {
+        return true;
+    };
+    if is_transaction_keyword(&first_keyword) {
+        return false;
+    }
+    GLOBAL_DDL_TARGET_RE.is_match(statement) || !has_resolved_target
+}
+
+fn first_keyword(statement: &str) -> Option<String> {
+    FIRST_KEYWORD_RE.find(statement).map(|value| value.as_str().to_ascii_lowercase())
+}
+
+fn is_transaction_keyword(keyword: &str) -> bool {
+    matches!(keyword, "begin" | "start" | "commit" | "rollback" | "abort" | "savepoint" | "release")
+}
+
+fn sql_target_safety_text(sql: &str) -> SqlTargetSafetyText {
+    let chars: Vec<char> = sql.chars().collect();
+    let mut result = SqlTargetSafetyText { text: String::with_capacity(sql.len()), quoted_identifiers: HashMap::new() };
+    append_sql_target_safety_text(&chars, &mut result);
+    result
+}
+
+fn append_sql_target_safety_text(chars: &[char], result: &mut SqlTargetSafetyText) {
+    let mut index = 0usize;
+
+    while index < chars.len() {
+        let ch = chars[index];
+        let next = chars.get(index + 1).copied();
+
+        if ch == '-' && next == Some('-') {
+            index += 2;
+            while index < chars.len() && chars[index] != '\n' && chars[index] != '\r' {
+                index += 1;
+            }
+            result.text.push(' ');
+            continue;
+        }
+        if ch == '#' {
+            index += 1;
+            while index < chars.len() && chars[index] != '\n' && chars[index] != '\r' {
+                index += 1;
+            }
+            result.text.push(' ');
+            continue;
+        }
+        if ch == '/' && next == Some('*') {
+            if let Some((body, close_index)) = mysql_executable_comment_body(&chars, index) {
+                result.text.push(' ');
+                let body_chars: Vec<char> = body.chars().collect();
+                append_sql_target_safety_text(&body_chars, result);
+                result.text.push(' ');
+                index = close_index;
+            } else {
+                index += 2;
+                while index + 1 < chars.len() && !(chars[index] == '*' && chars[index + 1] == '/') {
+                    index += 1;
+                }
+                index = (index + 2).min(chars.len());
+                result.text.push(' ');
+            }
+            continue;
+        }
+        if let Some((tag, tag_len)) = dollar_quote_tag_at(&chars, index) {
+            index += tag_len;
+            while index + tag_len <= chars.len() && !chars[index..index + tag_len].iter().collect::<String>().eq(&tag) {
+                index += 1;
+            }
+            index = (index + tag_len).min(chars.len());
+            result.text.push(' ');
+            continue;
+        }
+        if ch == '\'' {
+            index = skip_string_literal(&chars, index, '\'', '\'');
+            result.text.push(' ');
+            continue;
+        }
+        if ch == '"' || ch == '`' || ch == '[' {
+            let close = if ch == '[' { ']' } else { ch };
+            index = append_quoted_identifier_token(chars, index, close, result);
+            continue;
+        }
+
+        result.text.push(ch);
+        index += 1;
+    }
+}
+
+fn mysql_executable_comment_body(chars: &[char], start: usize) -> Option<(String, usize)> {
+    if chars.get(start) != Some(&'/') || chars.get(start + 1) != Some(&'*') {
+        return None;
+    }
+    let mut index = start + 2;
+    match chars.get(index).copied() {
+        Some('!') => index += 1,
+        Some('M') if chars.get(index + 1) == Some(&'!') => index += 2,
+        _ => return None,
+    }
+    while matches!(chars.get(index), Some(ch) if ch.is_ascii_digit() || ch.is_whitespace()) {
+        index += 1;
+    }
+    let body_start = index;
+    while index + 1 < chars.len() {
+        if chars[index] == '*' && chars[index + 1] == '/' {
+            return Some((chars[body_start..index].iter().collect(), index + 2));
+        }
+        index += 1;
+    }
+    Some((chars[body_start..].iter().collect(), chars.len()))
+}
+
+fn dollar_quote_tag_at(chars: &[char], start: usize) -> Option<(String, usize)> {
+    if chars.get(start) != Some(&'$') {
+        return None;
+    }
+    let mut index = start + 1;
+    if chars.get(index) == Some(&'$') {
+        return Some(("$$".to_string(), 2));
+    }
+    if !matches!(chars.get(index), Some(ch) if ch.is_ascii_alphabetic() || *ch == '_') {
+        return None;
+    }
+    index += 1;
+    while matches!(chars.get(index), Some(ch) if ch.is_ascii_alphanumeric() || *ch == '_') {
+        index += 1;
+    }
+    if chars.get(index) != Some(&'$') {
+        return None;
+    }
+    let tag: String = chars[start..=index].iter().collect();
+    Some((tag, index - start + 1))
+}
+
+fn skip_string_literal(chars: &[char], start: usize, open: char, close: char) -> usize {
+    let mut index = start + 1;
+    while index < chars.len() {
+        if chars[index] == '\\' && matches!(open, '\'' | '"') {
+            index += 2;
+            continue;
+        }
+        if chars[index] == close {
+            if chars.get(index + 1) == Some(&close) {
+                index += 2;
+                continue;
+            }
+            return index + 1;
+        }
+        index += 1;
+    }
+    chars.len()
+}
+
+fn append_quoted_identifier_token(
+    chars: &[char],
+    start: usize,
+    close: char,
+    result: &mut SqlTargetSafetyText,
+) -> usize {
+    let mut index = start + 1;
+    let mut identifier = String::new();
+    while index < chars.len() {
+        if chars[index] == close {
+            if chars.get(index + 1) == Some(&close) {
+                identifier.push(close);
+                index += 2;
+                continue;
+            }
+            let token = format!("__dbxq{}__", result.quoted_identifiers.len());
+            result.quoted_identifiers.insert(token.to_ascii_lowercase(), identifier);
+            result.text.push(' ');
+            result.text.push_str(&token);
+            result.text.push(' ');
+            return index + 1;
+        }
+        identifier.push(if chars[index] == ';' { ' ' } else { chars[index] });
+        index += 1;
+    }
+    let token = format!("__dbxq{}__", result.quoted_identifiers.len());
+    result.quoted_identifiers.insert(token.to_ascii_lowercase(), identifier);
+    result.text.push(' ');
+    result.text.push_str(&token);
+    result.text.push(' ');
+    chars.len()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{is_production_database, targets_production_database};
+    use crate::models::connection::{ConnectionConfig, DatabaseType};
+    use serde::Deserialize;
+
+    #[derive(Deserialize)]
+    #[serde(rename_all = "camelCase")]
+    struct ProductionSafetyCorpusCase {
+        name: String,
+        dialect: DatabaseType,
+        production_databases: Vec<String>,
+        active_database: String,
+        sql: String,
+        active: bool,
+    }
+
+    fn config() -> ConnectionConfig {
+        ConnectionConfig {
+            id: "conn".to_string(),
+            name: "test".to_string(),
+            db_type: DatabaseType::Mysql,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: vec![],
+            host: "localhost".to_string(),
+            port: 3306,
+            username: "root".to_string(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: vec![],
+            color: None,
+            transport_layers: vec![],
+            connect_timeout_secs: 10,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: 30,
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: vec![],
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: ":".to_string(),
+            redis_scan_page_size: Some(1000),
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec!["prod_app".to_string()],
+        }
+    }
+
+    #[test]
+    fn matches_marked_database_case_insensitively() {
+        assert!(is_production_database(&config(), "`PROD_APP`"));
+        assert!(!is_production_database(&config(), "staging"));
+    }
+
+    #[test]
+    fn detects_cross_database_production_targets() {
+        assert!(targets_production_database(&config(), "staging", "DELETE FROM prod_app.users WHERE id = 1"));
+        assert!(targets_production_database(&config(), "staging", "USE prod_app; DELETE FROM users WHERE id = 1"));
+        assert!(targets_production_database(&config(), "staging", "COPY prod_app.users FROM '/tmp/users.csv'"));
+        assert!(targets_production_database(&config(), "staging", "DROP DATABASE IF EXISTS `prod_app`"));
+        assert!(targets_production_database(&config(), "staging", "CALL prod_app.purge_users()"));
+        assert!(targets_production_database(&config(), "staging", "CALL `prod_app`.`purge_users`()"));
+        assert!(targets_production_database(&config(), "staging", "GRANT ALL ON prod_app.* TO 'u'@'%'"));
+        assert!(targets_production_database(
+            &config(),
+            "staging",
+            "GRANT EXECUTE ON PROCEDURE prod_app.purge_users TO 'u'@'%'"
+        ));
+        assert!(!targets_production_database(&config(), "staging", "DELETE FROM staging.users WHERE id = 1"));
+        assert!(!targets_production_database(&config(), "staging", "CALL staging.purge_users()"));
+        assert!(!targets_production_database(&config(), "staging", "GRANT ALL ON staging.* TO 'u'@'%'"));
+        assert!(!targets_production_database(
+            &config(),
+            "staging",
+            "DELETE FROM staging.users WHERE note = 'FROM prod_app.users'"
+        ));
+        assert!(!targets_production_database(
+            &config(),
+            "staging",
+            "SELECT * FROM prod_app.users; DELETE FROM staging.users WHERE id = 1"
+        ));
+    }
+
+    #[test]
+    fn matches_shared_sql_target_safety_corpus() {
+        let corpus: Vec<ProductionSafetyCorpusCase> =
+            serde_json::from_str(include_str!("../../../tests/fixtures/production-safety-corpus.json"))
+                .expect("production safety corpus is valid JSON");
+
+        for corpus_case in corpus {
+            let mut config = config();
+            config.db_type = corpus_case.dialect;
+            config.production_databases = corpus_case.production_databases;
+            assert_eq!(
+                targets_production_database(&config, &corpus_case.active_database, &corpus_case.sql),
+                corpus_case.active,
+                "{}",
+                corpus_case.name
+            );
+        }
+    }
+
+    #[test]
+    fn conservatively_blocks_ambiguous_production_targets() {
+        assert!(targets_production_database(&config(), "staging", "CALL purge_users()"));
+        assert!(targets_production_database(&config(), "staging", "GRANT PROCESS ON *.* TO 'u'@'%'"));
+        assert!(targets_production_database(&config(), "staging", "GRANT ALL ON users TO 'u'@'%'"));
+        assert!(targets_production_database(&config(), "staging", "CREATE USER 'u'@'%'"));
+    }
+
+    #[test]
+    fn resolves_sqlserver_database_qualifiers_dialect_aware() {
+        let mut sqlserver = config();
+        sqlserver.db_type = DatabaseType::SqlServer;
+
+        assert!(targets_production_database(&sqlserver, "staging", "DELETE FROM prod_app.dbo.users WHERE id = 1"));
+        assert!(!targets_production_database(&sqlserver, "staging", "DELETE FROM prod_app.users WHERE id = 1"));
+    }
+}
diff --git a/crates/dbx-core/src/query.rs b/crates/dbx-core/src/query.rs
new file mode 100644
index 0000000..f33c0db
--- /dev/null
+++ b/crates/dbx-core/src/query.rs
@@ -0,0 +1,4317 @@
+#[cfg(feature = "duckdb-bundled")]
+use chrono::{DateTime, Duration as ChronoDuration, NaiveDate, NaiveDateTime, NaiveTime, Utc};
+#[cfg(feature = "duckdb-bundled")]
+use duckdb::types::{TimeUnit, Value, ValueRef};
+use futures::StreamExt;
+use mysql_async::prelude::Queryable;
+use serde::Serialize;
+use sqlparser::ast::{visit_relations_mut, Ident, ObjectName, ObjectNamePart, ObjectType, Statement};
+use sqlparser::dialect::{GenericDialect, PostgreSqlDialect};
+use sqlparser::parser::Parser;
+use std::collections::HashSet;
+use std::future::Future;
+use std::ops::ControlFlow;
+use std::sync::Arc;
+use std::time::Duration;
+#[cfg(feature = "duckdb-bundled")]
+use tokio::task::JoinHandle;
+#[cfg(feature = "duckdb-bundled")]
+use tokio::time::sleep;
+use tokio::time::timeout;
+use tokio_util::sync::CancellationToken;
+
+use crate::connection::{AppState, PoolKind, TransactionSession, TxnConnection};
+use crate::database_capabilities;
+use crate::db;
+use crate::models::connection::{ConnectionConfig, DatabaseType};
+use crate::query_execution_sql::is_write_sql;
+#[cfg(feature = "duckdb-bundled")]
+use crate::sql::starts_with_duckdb_result_sql_keyword;
+use crate::sql::{split_sql_batches, split_sql_statements, starts_with_executable_sql_keyword};
+
+pub const QUERY_TIMEOUT: Duration = Duration::from_secs(30);
+pub const MAX_ROWS: usize = 10000;
+pub const QUERY_CANCELED: &str = "Query canceled";
+#[cfg(feature = "duckdb-bundled")]
+const DUCKDB_INTERRUPT_DRAIN_TIMEOUT: Duration = Duration::from_secs(2);
+#[cfg(feature = "duckdb-bundled")]
+const DUCKDB_DRAINING_MESSAGE: &str = "上一条 DuckDB 查询仍在停止，请稍后重试。";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PoolErrorAction {
+    Keep,
+    Discard,
+    ReconnectAndRetry,
+}
+
+/// A multi-statement result with metadata intended for query clients.
+///
+/// `execution_error` is emitted only for synthesized MySQL-protocol errors so
+/// clients can distinguish them from a successful result column named `Error`.
+#[derive(Debug, Clone, Serialize)]
+pub struct ExecuteMultiResult {
+    #[serde(flatten)]
+    pub result: db::QueryResult,
+    #[serde(skip_serializing_if = "is_false")]
+    pub execution_error: bool,
+}
+
+impl ExecuteMultiResult {
+    fn execution_error(result: db::QueryResult) -> Self {
+        Self { result, execution_error: true }
+    }
+
+    fn into_query_result(self) -> db::QueryResult {
+        self.result
+    }
+}
+
+impl From<db::QueryResult> for ExecuteMultiResult {
+    fn from(result: db::QueryResult) -> Self {
+        Self { result, execution_error: false }
+    }
+}
+
+fn is_false(value: &bool) -> bool {
+    !*value
+}
+
+/// Unified database operation execution budget.
+/// query_timeout = None only means SQL execution has no upper limit;
+/// checkout/connect/recycle/cancel/cleanup always have hard upper limits and cannot be disabled.
+#[derive(Debug, Clone)]
+pub struct DbOperationBudget {
+    pub checkout_timeout: Duration,
+    pub connect_timeout: Duration,
+    pub recycle_timeout: Duration,
+    pub query_timeout: Option<Duration>,
+    pub cancel_timeout: Duration,
+    pub cleanup_timeout: Duration,
+}
+
+impl DbOperationBudget {
+    /// Build an execution budget from connection config.
+    /// checkout/connect/recycle use connect_timeout_secs (clamped to 1s minimum, 300s maximum).
+    /// query_timeout follows resolve_query_timeout semantics (Some(0) -> None).
+    /// cancel/cleanup are fixed values and cannot be disabled.
+    pub fn from_config(connect_timeout_secs: u64, query_timeout_secs: Option<u64>) -> Self {
+        let infra_timeout = Duration::from_secs(connect_timeout_secs.clamp(1, 300));
+        Self {
+            checkout_timeout: infra_timeout,
+            connect_timeout: infra_timeout,
+            recycle_timeout: infra_timeout,
+            query_timeout: resolve_query_timeout(query_timeout_secs),
+            cancel_timeout: Duration::from_secs(5),
+            cleanup_timeout: Duration::from_secs(3),
+        }
+    }
+
+    pub fn from_connection_config(config: &ConnectionConfig) -> Self {
+        Self::from_config(config.effective_connect_timeout_secs(), Some(config.query_timeout_secs))
+    }
+
+    /// Use global default values (when no connection config is available).
+    pub fn with_defaults() -> Self {
+        let default_infra = db::connection_timeout();
+        Self {
+            checkout_timeout: default_infra,
+            connect_timeout: default_infra,
+            recycle_timeout: default_infra,
+            query_timeout: Some(QUERY_TIMEOUT),
+            cancel_timeout: Duration::from_secs(5),
+            cleanup_timeout: Duration::from_secs(3),
+        }
+    }
+}
+
+/// Check read-only protection for a connection, blocking write SQL statements.
+/// Only clones the connection name when read-only mode is active, avoiding
+/// unnecessary allocations otherwise.
+/// Uses config_for_pool_key to correctly resolve configs when pool_key includes
+/// a database suffix (e.g., "prod:app" → config stored under "prod").
+pub async fn check_read_only_for_connection(state: &AppState, pool_key: &str, sql: &str) -> Result<(), String> {
+    let connection = {
+        let configs = state.configs.read().await;
+        crate::connection::config_for_pool_key(pool_key, &configs)
+            .filter(|config| config.read_only)
+            .map(|config| (config.name.clone(), config.db_type))
+    };
+    if let Some((name, database_type)) = connection {
+        crate::query_execution_sql::check_read_only(sql, &name, database_type)?;
+    }
+    Ok(())
+}
+
+/// Check read-only protection for a connection across multiple SQL statements.
+pub async fn check_read_only_for_connection_multi(
+    state: &AppState,
+    pool_key: &str,
+    statements: &[impl AsRef<str>],
+) -> Result<(), String> {
+    let connection = {
+        let configs = state.configs.read().await;
+        crate::connection::config_for_pool_key(pool_key, &configs)
+            .filter(|config| config.read_only)
+            .map(|config| (config.name.clone(), config.db_type))
+    };
+    if let Some((name, database_type)) = connection {
+        for sql in statements {
+            crate::query_execution_sql::check_read_only(sql.as_ref(), &name, database_type)?;
+        }
+    }
+    Ok(())
+}
+
+/// Check whether a connection has read-only mode enabled, returning the connection name if so.
+/// This uses connection_id directly (not pool_key), so it is safe to call at command entry points
+/// before any pool key is constructed.
+pub async fn connection_readonly_name(state: &AppState, connection_id: &str) -> Option<String> {
+    state.configs.read().await.get(connection_id).filter(|c| c.read_only).map(|c| c.name.clone())
+}
+
+async fn connection_is_mongodb(state: &AppState, connection_id: &str) -> bool {
+    let configs = state.configs.read().await;
+    configs.get(connection_id).is_some_and(|config| config.db_type == DatabaseType::MongoDb)
+}
+
+async fn connection_database_type(state: &AppState, connection_id: &str) -> Option<DatabaseType> {
+    let configs = state.configs.read().await;
+    configs.get(connection_id).map(|config| config.db_type)
+}
+
+async fn connection_mysql_query_dialect(state: &AppState, connection_id: &str) -> db::mysql::MySqlQueryDialect {
+    let configs = state.configs.read().await;
+    configs
+        .get(connection_id)
+        .map(|config| db::mysql::MySqlQueryDialect::for_connection(config.db_type, config.driver_profile.as_deref()))
+        .unwrap_or_default()
+}
+
+async fn connection_database_type_for_pool_key(state: &AppState, pool_key: &str) -> Option<DatabaseType> {
+    let configs = state.configs.read().await;
+    configs
+        .iter()
+        .filter(|(connection_id, _)| {
+            pool_key.strip_prefix(connection_id.as_str()).is_some_and(|rest| rest.is_empty() || rest.starts_with(':'))
+        })
+        .max_by_key(|(connection_id, _)| connection_id.len())
+        .map(|(_, config)| config.db_type)
+}
+
+fn schema_for_execution_context(db_type: Option<DatabaseType>, schema: Option<&str>) -> Option<&str> {
+    if matches!(db_type, Some(DatabaseType::Iris)) {
+        None
+    } else {
+        schema
+    }
+}
+
+fn sql_for_execution_context(db_type: Option<DatabaseType>, sql: &str, schema: Option<&str>) -> String {
+    if matches!(db_type, Some(DatabaseType::Iris)) {
+        if let Some(schema) = schema.map(str::trim).filter(|schema| !schema.is_empty()) {
+            return qualify_iris_unqualified_dml(sql, schema).unwrap_or_else(|| sql.to_string());
+        }
+    }
+    sql.to_string()
+}
+
+fn qualify_iris_unqualified_dml(sql: &str, schema: &str) -> Option<String> {
+    let dialect = GenericDialect {};
+    let mut statements = Parser::parse_sql(&dialect, sql).ok()?;
+    if statements.is_empty() {
+        return None;
+    }
+
+    let mut changed = false;
+    for statement in &mut statements {
+        if !iris_statement_uses_schema_search_path(statement) {
+            continue;
+        }
+        let cte_names = iris_statement_cte_names(statement);
+        let _ = visit_relations_mut(statement, |name| {
+            if qualify_iris_relation_name(name, schema, &cte_names) {
+                changed = true;
+            }
+            ControlFlow::<()>::Continue(())
+        });
+    }
+
+    changed.then(|| statements.iter().map(ToString::to_string).collect::<Vec<_>>().join("; "))
+}
+
+fn iris_statement_uses_schema_search_path(statement: &Statement) -> bool {
+    matches!(
+        statement,
+        Statement::Query(_)
+            | Statement::Insert(_)
+            | Statement::Update(_)
+            | Statement::Delete(_)
+            | Statement::Truncate(_)
+    )
+}
+
+fn qualify_iris_relation_name(name: &mut ObjectName, schema: &str, cte_names: &HashSet<String>) -> bool {
+    let [ObjectNamePart::Identifier(table)] = name.0.as_slice() else {
+        return false;
+    };
+    if cte_names.contains(&table.value.to_ascii_uppercase()) {
+        return false;
+    }
+
+    let table = table.clone();
+    name.0 = vec![ObjectNamePart::Identifier(Ident::with_quote('"', schema)), ObjectNamePart::Identifier(table)];
+    true
+}
+
+fn iris_statement_cte_names(statement: &Statement) -> HashSet<String> {
+    let mut names = HashSet::new();
+    collect_iris_statement_cte_names(statement, &mut names);
+    names
+}
+
+fn collect_iris_statement_cte_names(statement: &Statement, names: &mut HashSet<String>) {
+    match statement {
+        Statement::Query(query) => collect_iris_query_cte_names(query, names),
+        Statement::Insert(insert) => {
+            if let Some(source) = &insert.source {
+                collect_iris_query_cte_names(source, names);
+            }
+        }
+        _ => {}
+    }
+}
+
+fn collect_iris_query_cte_names(query: &sqlparser::ast::Query, names: &mut HashSet<String>) {
+    if let Some(with) = &query.with {
+        for cte in &with.cte_tables {
+            names.insert(cte.alias.name.value.to_ascii_uppercase());
+            collect_iris_query_cte_names(&cte.query, names);
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct QueryExecutionOptions {
+    pub max_rows: Option<usize>,
+    pub fetch_size: Option<usize>,
+    pub page_size: Option<usize>,
+    pub result_session_id: Option<String>,
+    pub client_session_id: Option<String>,
+    /// Query timeout in seconds. `None` uses the default (30s).
+    /// `Some(0)` disables the timeout entirely.
+    pub timeout_secs: Option<u64>,
+    pub execution_id: Option<String>,
+    /// When `Some(true)`, multiple statements are executed within a single transaction
+    /// (BEGIN … COMMIT) instead of auto-commit mode. `None` and `Some(false)` behave
+    /// identically — auto-commit for each statement.
+    pub use_transaction: Option<bool>,
+}
+
+fn query_result_row_limit(max_rows: Option<usize>) -> usize {
+    max_rows.unwrap_or(MAX_ROWS).max(1)
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_execute(con: &duckdb::Connection, sql: &str) -> Result<db::QueryResult, String> {
+    duckdb_execute_with_max_rows(con, sql, None)
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_value_to_json(row: &duckdb::Row<'_>, idx: usize) -> serde_json::Value {
+    let Ok(value_ref) = row.get_ref(idx) else {
+        return serde_json::Value::Null;
+    };
+    match value_ref {
+        ValueRef::Null => serde_json::Value::Null,
+        ValueRef::Boolean(b) => serde_json::Value::Bool(b),
+        ValueRef::TinyInt(i) => serde_json::Value::Number((i as i64).into()),
+        ValueRef::SmallInt(i) => serde_json::Value::Number((i as i64).into()),
+        ValueRef::Int(i) => serde_json::Value::Number((i as i64).into()),
+        ValueRef::BigInt(i) => serde_json::Value::Number(i.into()),
+        ValueRef::HugeInt(i) => serde_json::Value::String(i.to_string()),
+        ValueRef::UTinyInt(i) => serde_json::Value::Number((i as u64).into()),
+        ValueRef::USmallInt(i) => serde_json::Value::Number((i as u64).into()),
+        ValueRef::UInt(i) => serde_json::Value::Number((i as u64).into()),
+        ValueRef::UBigInt(i) => serde_json::Value::Number(i.into()),
+        ValueRef::Float(f) => {
+            serde_json::Number::from_f64(f as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null)
+        }
+        ValueRef::Double(f) => {
+            serde_json::Number::from_f64(f).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null)
+        }
+        ValueRef::Decimal(d) => serde_json::Value::String(d.to_string()),
+        ValueRef::Date32(days) => {
+            duckdb_date32_to_string(days).map(serde_json::Value::String).unwrap_or(serde_json::Value::Null)
+        }
+        ValueRef::Time64(unit, value) => {
+            duckdb_time64_to_string(unit, value).map(serde_json::Value::String).unwrap_or(serde_json::Value::Null)
+        }
+        ValueRef::Timestamp(unit, value) => {
+            duckdb_timestamp_to_string(unit, value).map(serde_json::Value::String).unwrap_or(serde_json::Value::Null)
+        }
+        ValueRef::Text(bytes) => std::str::from_utf8(bytes)
+            .map(|s| serde_json::Value::String(s.to_string()))
+            .unwrap_or(serde_json::Value::Null),
+        ValueRef::Blob(bytes) => {
+            let hex: String = bytes.iter().map(|b| format!("{:02x}", b)).collect();
+            serde_json::Value::String(format!("\\x{hex}"))
+        }
+        ValueRef::Interval { months, days, nanos } => {
+            serde_json::Value::String(duckdb_interval_to_string(months, days, nanos))
+        }
+        ValueRef::List(..)
+        | ValueRef::Array(..)
+        | ValueRef::Struct(..)
+        | ValueRef::Map(..)
+        | ValueRef::Enum(..)
+        | ValueRef::Union(..) => duckdb_owned_value_to_json(&value_ref.to_owned()),
+    }
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_owned_value_to_json(value: &Value) -> serde_json::Value {
+    match value {
+        Value::Null => serde_json::Value::Null,
+        Value::Boolean(b) => serde_json::Value::Bool(*b),
+        Value::TinyInt(i) => serde_json::Value::Number((*i as i64).into()),
+        Value::SmallInt(i) => serde_json::Value::Number((*i as i64).into()),
+        Value::Int(i) => serde_json::Value::Number((*i as i64).into()),
+        Value::BigInt(i) => serde_json::Value::Number((*i).into()),
+        Value::HugeInt(i) => serde_json::Value::String(i.to_string()),
+        Value::UTinyInt(i) => serde_json::Value::Number((*i as u64).into()),
+        Value::USmallInt(i) => serde_json::Value::Number((*i as u64).into()),
+        Value::UInt(i) => serde_json::Value::Number((*i as u64).into()),
+        Value::UBigInt(i) => serde_json::Value::Number((*i).into()),
+        Value::Float(f) => {
+            serde_json::Number::from_f64(*f as f64).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null)
+        }
+        Value::Double(f) => {
+            serde_json::Number::from_f64(*f).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null)
+        }
+        Value::Decimal(d) => serde_json::Value::String(d.to_string()),
+        Value::Timestamp(unit, value) => {
+            duckdb_timestamp_to_string(*unit, *value).map(serde_json::Value::String).unwrap_or(serde_json::Value::Null)
+        }
+        Value::Text(text) | Value::Enum(text) => serde_json::Value::String(text.clone()),
+        Value::Blob(bytes) => {
+            let hex: String = bytes.iter().map(|b| format!("{:02x}", b)).collect();
+            serde_json::Value::String(format!("\\x{hex}"))
+        }
+        Value::Date32(days) => {
+            duckdb_date32_to_string(*days).map(serde_json::Value::String).unwrap_or(serde_json::Value::Null)
+        }
+        Value::Time64(unit, value) => {
+            duckdb_time64_to_string(*unit, *value).map(serde_json::Value::String).unwrap_or(serde_json::Value::Null)
+        }
+        Value::Interval { months, days, nanos } => {
+            serde_json::Value::String(duckdb_interval_to_string(*months, *days, *nanos))
+        }
+        Value::List(values) | Value::Array(values) => {
+            serde_json::Value::Array(values.iter().map(duckdb_owned_value_to_json).collect())
+        }
+        Value::Struct(entries) => serde_json::Value::Object(
+            entries.iter().map(|(key, value)| (key.clone(), duckdb_owned_value_to_json(value))).collect(),
+        ),
+        Value::Map(entries) => serde_json::Value::Array(
+            entries
+                .iter()
+                .map(|(key, value)| {
+                    serde_json::json!({
+                        "key": duckdb_owned_value_to_json(key),
+                        "value": duckdb_owned_value_to_json(value),
+                    })
+                })
+                .collect(),
+        ),
+        Value::Union(value) => duckdb_owned_value_to_json(value),
+    }
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_interval_to_string(months: i32, days: i32, nanos: i64) -> String {
+    let mut parts = Vec::new();
+    if months != 0 {
+        let years = months / 12;
+        let rem = months % 12;
+        if years != 0 {
+            parts.push(format!("{} year{}", years, if years.abs() != 1 { "s" } else { "" }));
+        }
+        if rem != 0 {
+            parts.push(format!("{} mon{}", rem, if rem.abs() != 1 { "s" } else { "" }));
+        }
+    }
+    if days != 0 {
+        parts.push(format!("{} day{}", days, if days.abs() != 1 { "s" } else { "" }));
+    }
+    if nanos != 0 {
+        let total_secs = nanos / 1_000_000_000;
+        let hours = total_secs / 3600;
+        let mins = (total_secs % 3600) / 60;
+        let secs = total_secs % 60;
+        let sub_nanos = (nanos % 1_000_000_000).unsigned_abs();
+        if sub_nanos > 0 {
+            parts.push(format!(
+                "{:02}:{:02}:{:02}.{}",
+                hours,
+                mins,
+                secs,
+                format_temporal_without_empty_fraction(format!("0.{:09}", sub_nanos)).trim_start_matches("0.")
+            ));
+        } else {
+            parts.push(format!("{:02}:{:02}:{:02}", hours, mins, secs));
+        }
+    }
+    if parts.is_empty() {
+        "00:00:00".to_string()
+    } else {
+        parts.join(" ")
+    }
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_date32_to_string(days: i32) -> Option<String> {
+    let epoch = NaiveDate::from_ymd_opt(1970, 1, 1)?;
+    epoch.checked_add_signed(ChronoDuration::days(i64::from(days))).map(|date| date.to_string())
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_time64_to_string(unit: TimeUnit, value: i64) -> Option<String> {
+    let nanos = duckdb_time_unit_to_nanos(unit, value)?;
+    let seconds = nanos.div_euclid(1_000_000_000);
+    let nanos_remainder = nanos.rem_euclid(1_000_000_000) as u32;
+    if !(0..86_400).contains(&seconds) {
+        return None;
+    }
+    let time = NaiveTime::from_num_seconds_from_midnight_opt(seconds as u32, nanos_remainder)?;
+    Some(format_temporal_without_empty_fraction(time.to_string()))
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_timestamp_to_string(unit: TimeUnit, value: i64) -> Option<String> {
+    let nanos = duckdb_time_unit_to_nanos(unit, value)?;
+    let seconds = nanos.div_euclid(1_000_000_000);
+    let nanos_remainder = nanos.rem_euclid(1_000_000_000) as u32;
+    let dt: DateTime<Utc> = DateTime::from_timestamp(seconds, nanos_remainder)?;
+    Some(format_naive_datetime(dt.naive_utc()))
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_time_unit_to_nanos(unit: TimeUnit, value: i64) -> Option<i64> {
+    match unit {
+        TimeUnit::Second => value.checked_mul(1_000_000_000),
+        TimeUnit::Millisecond => value.checked_mul(1_000_000),
+        TimeUnit::Microsecond => value.checked_mul(1_000),
+        TimeUnit::Nanosecond => Some(value),
+    }
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn format_naive_datetime(value: NaiveDateTime) -> String {
+    if value.and_utc().timestamp_subsec_nanos() == 0 {
+        value.format("%Y-%m-%d %H:%M:%S").to_string()
+    } else {
+        format_temporal_without_empty_fraction(value.to_string())
+    }
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn format_temporal_without_empty_fraction(value: String) -> String {
+    if !value.contains('.') {
+        return value;
+    }
+    let trimmed = value.trim_end_matches('0').trim_end_matches('.');
+    trimmed.to_string()
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_execute_with_max_rows(
+    con: &duckdb::Connection,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<db::QueryResult, String> {
+    let start = std::time::Instant::now();
+    let row_limit = query_result_row_limit(max_rows);
+
+    if starts_with_duckdb_result_sql_keyword(sql) {
+        let mut stmt = con.prepare(sql).map_err(|e| e.to_string())?;
+        let mut rows = stmt.query([]).map_err(|e| e.to_string())?;
+        let stmt_ref = rows.as_ref().ok_or("DuckDB statement unavailable")?;
+        let col_count = stmt_ref.column_count();
+        let columns: Vec<String> = (0..col_count)
+            .map(|i| stmt_ref.column_name(i).map(|s| s.to_string()).unwrap_or_else(|_| "?".to_string()))
+            .collect();
+
+        let mut result_rows = Vec::new();
+        while let Some(row) = rows.next().map_err(|e| e.to_string())? {
+            let vals: Vec<serde_json::Value> = (0..col_count).map(|i| duckdb_value_to_json(row, i)).collect();
+            result_rows.push(vals);
+            if result_rows.len() > row_limit {
+                break;
+            }
+        }
+
+        let truncated = result_rows.len() > row_limit;
+        if truncated {
+            result_rows.truncate(row_limit);
+        }
+        Ok(db::QueryResult {
+            columns,
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: result_rows,
+            affected_rows: 0,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated,
+            session_id: None,
+            has_more: false,
+        })
+    } else {
+        let affected = con.execute(sql, []).map_err(|e| e.to_string())?;
+        Ok(db::QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: affected as u64,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    }
+}
+
+#[cfg(feature = "duckdb-bundled")]
+enum DuckDbTaskWait {
+    Finished(Result<db::QueryResult, String>),
+    Draining { error: String, task: JoinHandle<Result<db::QueryResult, String>> },
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_join_result(
+    result: Result<Result<db::QueryResult, String>, tokio::task::JoinError>,
+) -> Result<db::QueryResult, String> {
+    result.map_err(|e| e.to_string())?
+}
+
+#[cfg(feature = "duckdb-bundled")]
+async fn interrupt_and_drain_duckdb_task(
+    interrupt_handle: std::sync::Arc<duckdb::InterruptHandle>,
+    mut task: JoinHandle<Result<db::QueryResult, String>>,
+    error: String,
+) -> DuckDbTaskWait {
+    interrupt_handle.interrupt();
+    match timeout(DUCKDB_INTERRUPT_DRAIN_TIMEOUT, &mut task).await {
+        Ok(result) => {
+            let _ = result;
+            DuckDbTaskWait::Finished(Err(error))
+        }
+        Err(_) => DuckDbTaskWait::Draining { error, task },
+    }
+}
+
+#[cfg(feature = "duckdb-bundled")]
+async fn wait_for_duckdb_task_with_interrupt_outcome(
+    cancel_token: Option<CancellationToken>,
+    timeout_duration: Option<Duration>,
+    interrupt_handle: std::sync::Arc<duckdb::InterruptHandle>,
+    mut task: JoinHandle<Result<db::QueryResult, String>>,
+) -> DuckDbTaskWait {
+    match (cancel_token, timeout_duration) {
+        (Some(token), Some(duration)) => {
+            tokio::select! {
+                biased;
+                _ = token.cancelled() => {
+                    interrupt_and_drain_duckdb_task(interrupt_handle, task, canceled_error()).await
+                }
+                result = &mut task => DuckDbTaskWait::Finished(duckdb_join_result(result)),
+                _ = sleep(duration) => {
+                    interrupt_and_drain_duckdb_task(interrupt_handle, task, timeout_error()).await
+                }
+            }
+        }
+        (Some(token), None) => {
+            tokio::select! {
+                biased;
+                _ = token.cancelled() => {
+                    interrupt_and_drain_duckdb_task(interrupt_handle, task, canceled_error()).await
+                }
+                result = &mut task => DuckDbTaskWait::Finished(duckdb_join_result(result)),
+            }
+        }
+        (None, Some(duration)) => {
+            tokio::select! {
+                result = &mut task => DuckDbTaskWait::Finished(duckdb_join_result(result)),
+                _ = sleep(duration) => {
+                    interrupt_and_drain_duckdb_task(interrupt_handle, task, timeout_error()).await
+                }
+            }
+        }
+        (None, None) => DuckDbTaskWait::Finished(duckdb_join_result(task.await)),
+    }
+}
+
+#[cfg(feature = "duckdb-bundled")]
+async fn wait_for_duckdb_task_with_interrupt(
+    cancel_token: Option<CancellationToken>,
+    timeout_duration: Option<Duration>,
+    interrupt_handle: std::sync::Arc<duckdb::InterruptHandle>,
+    task: JoinHandle<Result<db::QueryResult, String>>,
+) -> Result<db::QueryResult, String> {
+    match wait_for_duckdb_task_with_interrupt_outcome(cancel_token, timeout_duration, interrupt_handle, task).await {
+        DuckDbTaskWait::Finished(result) => result,
+        DuckDbTaskWait::Draining { error, .. } => Err(error),
+    }
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub(crate) fn duckdb_execute_for_database(
+    con: &duckdb::Connection,
+    attached_names: &[String],
+    database: Option<&str>,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<db::QueryResult, String> {
+    if let Some(database) = database.map(str::trim).filter(|database| !database.is_empty()) {
+        let catalog = if database == "main" {
+            crate::schema::duckdb_primary_catalog(con, attached_names)?
+        } else {
+            database.to_string()
+        };
+        con.execute_batch(&format!("USE {}", duckdb_quote_ident(&catalog))).map_err(|e| e.to_string())?;
+    }
+    duckdb_execute_with_max_rows(con, sql, max_rows)
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_quote_ident(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+pub fn truncate_result(result: db::QueryResult) -> db::QueryResult {
+    truncate_result_with_max_rows(result, None)
+}
+
+pub fn truncate_result_with_max_rows(mut result: db::QueryResult, max_rows: Option<usize>) -> db::QueryResult {
+    let row_limit = query_result_row_limit(max_rows);
+    if result.rows.len() > row_limit {
+        result.rows.truncate(row_limit);
+        result.truncated = true;
+    }
+    result
+}
+
+fn normalize_query_result_for_js(mut result: db::QueryResult) -> db::QueryResult {
+    result.rows = result.rows.into_iter().map(|row| row.into_iter().map(db::json_value_for_js).collect()).collect();
+    result
+}
+
+pub fn agent_execute_query_params(
+    sql: &str,
+    database: Option<&str>,
+    schema: Option<&str>,
+    options: QueryExecutionOptions,
+) -> serde_json::Value {
+    let mut params = serde_json::json!({
+        "sql": sql,
+        "maxRows": options.max_rows.unwrap_or(MAX_ROWS),
+    });
+    if let Some(database) = database.map(str::trim).filter(|database| !database.is_empty()) {
+        params["database"] = serde_json::json!(database);
+    }
+    if let Some(schema) = schema {
+        params["schema"] = serde_json::json!(schema);
+    }
+    if let Some(fetch_size) = options.fetch_size {
+        params["fetchSize"] = serde_json::json!(fetch_size);
+    }
+    if let Some(timeout_secs) = options.timeout_secs {
+        params["timeoutSecs"] = serde_json::json!(timeout_secs);
+    }
+    params
+}
+
+pub fn agent_execute_query_page_params(
+    sql: &str,
+    database: Option<&str>,
+    schema: Option<&str>,
+    options: QueryExecutionOptions,
+) -> serde_json::Value {
+    let mut params = serde_json::json!({
+        "sql": sql,
+        "pageSize": options.page_size.unwrap_or(MAX_ROWS),
+        "maxRows": options.max_rows.unwrap_or(MAX_ROWS),
+    });
+    if let Some(database) = database.map(str::trim).filter(|database| !database.is_empty()) {
+        params["database"] = serde_json::json!(database);
+    }
+    if let Some(schema) = schema {
+        params["schema"] = serde_json::json!(schema);
+    }
+    if let Some(fetch_size) = options.fetch_size {
+        params["fetchSize"] = serde_json::json!(fetch_size);
+    }
+    if let Some(timeout_secs) = options.timeout_secs {
+        params["timeoutSecs"] = serde_json::json!(timeout_secs);
+    }
+    params
+}
+
+pub fn agent_fetch_query_page_params(session_id: &str, page_size: usize) -> serde_json::Value {
+    serde_json::json!({
+        "sessionId": session_id,
+        "pageSize": page_size,
+    })
+}
+
+pub fn agent_close_query_session_params(session_id: &str) -> serde_json::Value {
+    serde_json::json!({
+        "sessionId": session_id,
+    })
+}
+
+pub fn is_connection_error(err: &str) -> bool {
+    let lower = err.to_lowercase();
+    if is_dbx_query_timeout_error(&lower) || is_agent_rpc_timeout_error(&lower) {
+        return false;
+    }
+    lower.contains("connection")
+        || lower.contains("broken pipe")
+        || lower.contains("reset by peer")
+        || lower.contains("timed out")
+        || (lower.contains("pool") && lower.contains("timeout"))
+        || lower.contains("closed")
+        || lower.contains("关闭的连接")
+        || lower.contains("连接已关闭")
+        || lower.contains("网络通信异常")
+        || lower.contains("通信异常")
+        || lower.contains("communications link failure")
+        || lower.contains("sqlrecoverableexception")
+        || lower.contains("sqlnontransientconnectionexception")
+        || lower.contains("sqltransientconnectionexception")
+        || lower.contains("eof")
+        || lower.contains("i/o error")
+        || lower.contains("input/output error")
+        || lower.contains("not connected")
+        || lower.contains("end-of-file")
+        || lower.contains("idle")
+        || lower.contains("agent stdin not available")
+        || lower.contains("agent stdout not available")
+        || lower.contains("failed to write to agent stdin")
+        || lower.contains("failed to flush agent stdin")
+        || lower.contains("communicating with the server")
+        || is_os_connection_error(&lower)
+}
+
+fn is_dbx_query_timeout_error(lower: &str) -> bool {
+    lower.starts_with("query timed out after ")
+}
+
+fn is_agent_rpc_timeout_error(lower: &str) -> bool {
+    lower.starts_with("agent rpc call timed out ")
+}
+
+fn is_schema_reset_cleanup_error(lower: &str) -> bool {
+    lower.contains("schema.reset cleanup failed")
+}
+
+fn should_discard_agent_pool_after_error(err: &str) -> bool {
+    let lower = err.to_lowercase();
+    is_dbx_query_timeout_error(&lower)
+        || is_agent_rpc_timeout_error(&lower)
+        || lower.contains("agent stdin not available")
+        || lower.contains("agent stdout not available")
+        || lower.contains("failed to write to agent stdin")
+        || lower.contains("failed to flush agent stdin")
+        || lower.contains("agent rpc task failed")
+}
+
+pub fn pool_error_action(db_type: Option<DatabaseType>, err: &str) -> PoolErrorAction {
+    let lower = err.to_lowercase();
+    if db::sqlserver::is_driver_panic_error(err)
+        || (is_dbx_query_timeout_error(&lower) && should_discard_pool_after_query_timeout(db_type))
+        || is_schema_reset_cleanup_error(&lower)
+        || (db_type.is_some_and(|db_type| database_capabilities::is_agent_type(&db_type))
+            && should_discard_agent_pool_after_error(err)
+            && !is_connection_error(err))
+    {
+        return PoolErrorAction::Discard;
+    }
+
+    if is_connection_error(err) {
+        PoolErrorAction::ReconnectAndRetry
+    } else {
+        PoolErrorAction::Keep
+    }
+}
+
+fn should_discard_pool_after_query_timeout(db_type: Option<DatabaseType>) -> bool {
+    let Some(db_type) = db_type else {
+        return false;
+    };
+    database_capabilities::is_agent_type(&db_type)
+        || matches!(
+            db_type,
+            DatabaseType::Mysql
+                | DatabaseType::Postgres
+                | DatabaseType::Redshift
+                | DatabaseType::Gaussdb
+                | DatabaseType::Kwdb
+                | DatabaseType::OpenGauss
+                | DatabaseType::Questdb
+                | DatabaseType::Doris
+                | DatabaseType::StarRocks
+                | DatabaseType::ManticoreSearch
+                | DatabaseType::ClickHouse
+                | DatabaseType::SqlServer
+                | DatabaseType::Rqlite
+                | DatabaseType::Turso
+                | DatabaseType::CloudflareD1
+                | DatabaseType::Elasticsearch
+                | DatabaseType::Qdrant
+                | DatabaseType::Milvus
+                | DatabaseType::Weaviate
+                | DatabaseType::ChromaDb
+                | DatabaseType::InfluxDb
+        )
+}
+
+pub fn should_discard_pool_after_error(db_type: Option<DatabaseType>, err: &str) -> bool {
+    matches!(pool_error_action(db_type, err), PoolErrorAction::Discard | PoolErrorAction::ReconnectAndRetry)
+}
+
+fn query_pool_error_action(db_type: Option<DatabaseType>, sql: &str, err: &str) -> PoolErrorAction {
+    match pool_error_action(db_type, err) {
+        // A connection error does not prove that the database did not receive
+        // a write. Only replay statements already accepted by the read-only
+        // protection classifier; writes discard the stale pool without retry.
+        PoolErrorAction::ReconnectAndRetry if is_write_sql(sql) => PoolErrorAction::Discard,
+        action => action,
+    }
+}
+
+fn is_os_connection_error(lower: &str) -> bool {
+    let os_error_codes = ["10053", "10054", "10057", "10058", "10060", "10061"];
+    if let Some(pos) = lower.find("os error ") {
+        let after = &lower[pos + 9..];
+        let code: String = after.chars().take_while(|c| c.is_ascii_digit()).collect();
+        return os_error_codes.contains(&code.as_str());
+    }
+    false
+}
+
+pub fn timeout_error() -> String {
+    timeout_error_for(QUERY_TIMEOUT)
+}
+
+fn timeout_error_for(timeout_duration: Duration) -> String {
+    let seconds = timeout_duration.as_secs().max(1);
+    format!("Query timed out after {seconds} seconds")
+}
+
+pub fn canceled_error() -> String {
+    QUERY_CANCELED.to_string()
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_draining_error() -> String {
+    DUCKDB_DRAINING_MESSAGE.to_string()
+}
+
+pub fn is_canceled(cancel_token: &Option<CancellationToken>) -> bool {
+    cancel_token.as_ref().map(|token| token.is_cancelled()).unwrap_or(false)
+}
+
+pub async fn wait_for_query<F>(cancel_token: Option<CancellationToken>, future: F) -> Result<db::QueryResult, String>
+where
+    F: Future<Output = Result<db::QueryResult, String>>,
+{
+    wait_for_query_with_timeout(cancel_token, QUERY_TIMEOUT, future).await
+}
+
+pub async fn wait_for_query_with_timeout<F>(
+    cancel_token: Option<CancellationToken>,
+    timeout_duration: Duration,
+    future: F,
+) -> Result<db::QueryResult, String>
+where
+    F: Future<Output = Result<db::QueryResult, String>>,
+{
+    wait_for_result_with_timeout(cancel_token, timeout_duration, future).await
+}
+
+async fn wait_for_result_with_timeout<T, F>(
+    cancel_token: Option<CancellationToken>,
+    timeout_duration: Duration,
+    future: F,
+) -> Result<T, String>
+where
+    F: Future<Output = Result<T, String>>,
+{
+    if let Some(token) = cancel_token {
+        tokio::select! {
+            biased;
+            _ = token.cancelled() => Err(canceled_error()),
+            result = timeout(timeout_duration, future) => result.map_err(|_| timeout_error_for(timeout_duration))?,
+        }
+    } else {
+        timeout(timeout_duration, future).await.map_err(|_| timeout_error_for(timeout_duration))?
+    }
+}
+
+/// Like `wait_for_query_with_timeout` but with an optional timeout.
+/// `None` means no timeout (only cancellation can stop the query).
+pub async fn wait_for_query_opt<F>(
+    cancel_token: Option<CancellationToken>,
+    timeout_duration: Option<Duration>,
+    future: F,
+) -> Result<db::QueryResult, String>
+where
+    F: Future<Output = Result<db::QueryResult, String>>,
+{
+    wait_for_result_opt(cancel_token, timeout_duration, future).await
+}
+
+async fn wait_for_result_opt<T, F>(
+    cancel_token: Option<CancellationToken>,
+    timeout_duration: Option<Duration>,
+    future: F,
+) -> Result<T, String>
+where
+    F: Future<Output = Result<T, String>>,
+{
+    match timeout_duration {
+        Some(d) => wait_for_result_with_timeout(cancel_token, d, future).await,
+        None => match cancel_token {
+            Some(token) => {
+                tokio::select! {
+                    biased;
+                    _ = token.cancelled() => Err(canceled_error()),
+                    result = future => result,
+                }
+            }
+            None => future.await,
+        },
+    }
+}
+
+async fn wait_for_value_opt<T, F>(
+    cancel_token: Option<CancellationToken>,
+    timeout_duration: Option<Duration>,
+    future: F,
+) -> Result<T, String>
+where
+    F: Future<Output = T>,
+{
+    match timeout_duration {
+        Some(timeout_duration) => {
+            if let Some(token) = cancel_token {
+                tokio::select! {
+                    biased;
+                    _ = token.cancelled() => Err(canceled_error()),
+                    result = timeout(timeout_duration, future) => result.map_err(|_| timeout_error_for(timeout_duration)),
+                }
+            } else {
+                timeout(timeout_duration, future).await.map_err(|_| timeout_error_for(timeout_duration))
+            }
+        }
+        None => match cancel_token {
+            Some(token) => {
+                tokio::select! {
+                    biased;
+                    _ = token.cancelled() => Err(canceled_error()),
+                    result = future => Ok(result),
+                }
+            }
+            None => Ok(future.await),
+        },
+    }
+}
+
+async fn sqlserver_pool_is_current(
+    state: &AppState,
+    pool_key: &str,
+    client: &Arc<tokio::sync::Mutex<db::sqlserver::SqlServerClient>>,
+) -> bool {
+    let connections = state.connections.read().await;
+    matches!(connections.get(pool_key), Some(PoolKind::SqlServer(current)) if Arc::ptr_eq(current, client))
+}
+
+fn resolve_query_timeout(timeout_secs: Option<u64>) -> Option<Duration> {
+    match timeout_secs {
+        Some(0) => None,
+        Some(n) => Some(Duration::from_secs(n)),
+        None => Some(QUERY_TIMEOUT),
+    }
+}
+
+pub async fn operation_budget_for_pool_key(
+    state: &AppState,
+    pool_key: &str,
+    query_timeout: Option<Duration>,
+) -> DbOperationBudget {
+    let mut budget = configured_operation_budget_for_pool_key(state, pool_key).await;
+    budget.query_timeout = query_timeout;
+    budget
+}
+
+async fn configured_operation_budget_for_pool_key(state: &AppState, pool_key: &str) -> DbOperationBudget {
+    let configs = state.configs.read().await;
+    crate::connection::config_for_pool_key(pool_key, &configs)
+        .map(DbOperationBudget::from_connection_config)
+        .unwrap_or_else(DbOperationBudget::with_defaults)
+}
+
+fn oceanbase_mysql_session_timeout_sql(config: Option<&ConnectionConfig>, timeout_secs: Option<u64>) -> Option<String> {
+    let config = config?;
+    let timeout_secs = timeout_secs.unwrap_or(config.query_timeout_secs);
+    crate::connection::oceanbase_mysql_query_timeout_sql(config, timeout_secs)
+}
+
+async fn apply_oceanbase_mysql_session_timeout(
+    state: &AppState,
+    pool_key: &str,
+    conn: &mut mysql_async::Conn,
+    timeout_secs: Option<u64>,
+) -> Result<(), String> {
+    let sql = {
+        let configs = state.configs.read().await;
+        oceanbase_mysql_session_timeout_sql(crate::connection::config_for_pool_key(pool_key, &configs), timeout_secs)
+    };
+    if let Some(sql) = sql {
+        // OceanBase enforces query timeouts through a session variable; set it
+        // on the checked-out connection in case the pooled session was reset.
+        conn.query_drop(&sql).await.map_err(|err| format!("Failed to apply OceanBase query timeout: {err}"))?;
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+pub async fn do_execute(
+    state: &AppState,
+    pool_key: &str,
+    mysql_dialect: db::mysql::MySqlQueryDialect,
+    database: Option<&str>,
+    sql: &str,
+    schema: Option<&str>,
+    cancel_token: Option<CancellationToken>,
+    options: QueryExecutionOptions,
+) -> Result<db::QueryResult, String> {
+    if let Some(execution_id) = options.execution_id.as_deref() {
+        state.running_queries.set_pool_key(execution_id, pool_key.to_string());
+    }
+    state.touch_pool_activity(pool_key).await;
+    let _activity_touch = state.pool_activity_touch(pool_key);
+
+    let query_timeout = resolve_query_timeout(options.timeout_secs);
+    let (_duckdb_attached_names, read_only_connection) = {
+        let configs = state.configs.read().await;
+        let config = crate::connection::config_for_pool_key(pool_key, &configs);
+        let attached = config
+            .map(|c| c.attached_databases.iter().map(|db| db.name.clone()).collect::<Vec<_>>())
+            .unwrap_or_default();
+        let connection = config.filter(|config| config.read_only).map(|config| (config.name.clone(), config.db_type));
+        (attached, connection)
+    };
+    let operation_budget = operation_budget_for_pool_key(state, pool_key, query_timeout).await;
+    if let Some((name, database_type)) = read_only_connection {
+        crate::query_execution_sql::check_read_only(sql, &name, database_type)?;
+    }
+    let pool_db_type = connection_database_type_for_pool_key(state, pool_key).await;
+    let connections = state.connections.read().await;
+    let pool = connections.get(pool_key).ok_or("Connection not found")?;
+
+    let result = match pool {
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::DuckDb(con) => {
+            let con = con.clone();
+            if con.is_draining() {
+                drop(connections);
+                return Err(duckdb_draining_error());
+            }
+            let interrupt_handle = con.interrupt_handle();
+            if let Some(ref execution_id) = options.execution_id {
+                let cancel_interrupt_handle = interrupt_handle.clone();
+                state.running_queries.register_interrupt(execution_id, move || {
+                    cancel_interrupt_handle.interrupt();
+                });
+            }
+            let sql = sql.to_string();
+            let database = database.map(str::to_string);
+            let attached_names = _duckdb_attached_names;
+            let max_rows = options.max_rows;
+            drop(connections);
+            let task_con = con.clone();
+            let task = tokio::task::spawn_blocking(move || {
+                let con = task_con.lock().map_err(|e| e.to_string())?;
+                duckdb_execute_for_database(&con, &attached_names, database.as_deref(), &sql, max_rows)
+            });
+            let result =
+                wait_for_duckdb_task_with_interrupt_outcome(cancel_token, query_timeout, interrupt_handle, task).await;
+            match result {
+                DuckDbTaskWait::Finished(result) => {
+                    if matches!(result.as_ref(), Err(err) if err == QUERY_CANCELED || is_dbx_query_timeout_error(&err.to_lowercase()))
+                    {
+                        con.mark_draining();
+                        state.spawn_duckdb_pool_cleanup(pool_key.to_string(), con);
+                    }
+                    result
+                }
+                DuckDbTaskWait::Draining { error, task } => {
+                    con.mark_draining();
+                    state.spawn_duckdb_draining_cleanup(pool_key.to_string(), con, task);
+                    Err(error)
+                }
+            }
+        }
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::DuckDbWorker(client) => {
+            let client = client.clone();
+            if let Some(ref execution_id) = options.execution_id {
+                let cancel_client = client.clone();
+                state.running_queries.register_interrupt(execution_id, move || {
+                    let cancel_client = cancel_client.clone();
+                    tokio::spawn(async move {
+                        if let Err(error) = cancel_client.cancel().await {
+                            log::warn!("Failed to cancel DuckDB worker query: {error}");
+                        }
+                    });
+                });
+            }
+            let sql = sql.to_string();
+            let database = database.map(str::to_string);
+            let max_rows = options.max_rows;
+            drop(connections);
+            client.execute(database, sql, max_rows, cancel_token, query_timeout).await
+        }
+        #[cfg(not(feature = "duckdb-bundled"))]
+        PoolKind::DuckDb(_) => {
+            return Err("DuckDB support is not compiled in this build".to_string());
+        }
+        #[cfg(not(feature = "duckdb-bundled"))]
+        PoolKind::DuckDbWorker(_) => {
+            return Err("DuckDB worker support is not compiled in this build".to_string());
+        }
+        PoolKind::Mysql(p, mode) => {
+            let p = p.clone();
+            let bare = *mode == crate::connection::MysqlMode::Bare;
+            let max_rows = options.max_rows;
+            drop(connections);
+            let mut conn = match db::mysql::get_conn_with_health_check_with_cancel(
+                &p,
+                operation_budget.checkout_timeout,
+                operation_budget.cleanup_timeout,
+                cancel_token.as_ref(),
+            )
+            .await
+            {
+                Ok(conn) => conn,
+                Err(err) if err == QUERY_CANCELED => {
+                    state.remove_pool_by_key(pool_key).await;
+                    return Err(err);
+                }
+                Err(err) => return Err(err),
+            };
+            let connection_id = conn.id();
+            if let Some(ref execution_id) = options.execution_id {
+                let kill_opts = conn.opts().clone();
+                state.running_queries.register_interrupt(execution_id, move || {
+                    let kill_opts = kill_opts.clone();
+                    tokio::spawn(async move {
+                        if let Err(error) = db::mysql::kill_query_with_opts(kill_opts, connection_id).await {
+                            log::warn!("Failed to cancel MySQL query {connection_id}: {error}");
+                        }
+                    });
+                });
+            }
+            apply_oceanbase_mysql_session_timeout(state, pool_key, &mut conn, options.timeout_secs).await?;
+            wait_for_query_opt(
+                cancel_token,
+                query_timeout,
+                db::mysql::execute_query_on_conn_with_max_rows(&mut conn, sql, bare, max_rows, mysql_dialect),
+            )
+            .await
+        }
+        PoolKind::Postgres(p) => {
+            let p = p.clone();
+            let schema = schema.map(|s| s.to_string());
+            let max_rows = options.max_rows;
+            let cancel_context = state.get_postgres_cancel_context(pool_key).await;
+            drop(connections);
+            if let Some(schema) = schema {
+                db::postgres::execute_query_with_schema_and_max_rows_and_cancel(
+                    &p,
+                    &schema,
+                    sql,
+                    max_rows,
+                    cancel_token,
+                    operation_budget.clone(),
+                    cancel_context,
+                )
+                .await
+            } else {
+                db::postgres::execute_query_with_max_rows_and_cancel(
+                    &p,
+                    sql,
+                    max_rows,
+                    cancel_token,
+                    operation_budget.clone(),
+                    cancel_context,
+                )
+                .await
+            }
+        }
+        PoolKind::Sqlite(p) => {
+            let p = p.clone();
+            let max_rows = options.max_rows;
+            drop(connections);
+            wait_for_query_opt(cancel_token, query_timeout, db::sqlite::execute_query_with_max_rows(&p, sql, max_rows))
+                .await
+        }
+        PoolKind::Rqlite(client) => {
+            let client = client.clone();
+            let max_rows = options.max_rows;
+            drop(connections);
+            wait_for_query_opt(
+                cancel_token,
+                query_timeout,
+                db::rqlite_driver::execute_query_with_max_rows(&client, sql, max_rows),
+            )
+            .await
+        }
+        PoolKind::Turso(client) => {
+            let client = client.clone();
+            let max_rows = options.max_rows;
+            drop(connections);
+            wait_for_query_opt(
+                cancel_token,
+                query_timeout,
+                db::turso_driver::execute_query_with_max_rows(&client, sql, max_rows),
+            )
+            .await
+        }
+        PoolKind::CloudflareD1(client) => {
+            let client = client.clone();
+            let max_rows = options.max_rows;
+            drop(connections);
+            wait_for_query_opt(
+                cancel_token,
+                query_timeout,
+                db::cloudflare_d1_driver::execute_query_with_max_rows(&client, sql, max_rows),
+            )
+            .await
+        }
+        PoolKind::ClickHouse(client) => {
+            let client = client.clone();
+            let database = pool_key.split(':').nth(1).unwrap_or("default").to_string();
+            let max_rows = options.max_rows;
+            drop(connections);
+            let result = wait_for_query_opt(
+                cancel_token,
+                query_timeout,
+                db::clickhouse_driver::execute_query_with_max_rows(&client, &database, sql, max_rows),
+            )
+            .await
+            .map(|result| truncate_result_with_max_rows(result, max_rows));
+            if matches!(result.as_ref(), Err(err) if should_discard_pool_after_error(pool_db_type, err)) {
+                state.remove_pool_by_key(pool_key).await;
+            }
+            result
+        }
+        PoolKind::SqlServer(client) => {
+            let client = client.clone();
+            let max_rows = options.max_rows;
+            drop(connections);
+            let mut client = match cancel_token.as_ref() {
+                Some(token) => tokio::select! {
+                    biased;
+                    _ = token.cancelled() => return Err(canceled_error()),
+                    guard = client.lock() => guard,
+                },
+                None => client.lock().await,
+            };
+            let result = wait_for_query_opt(
+                cancel_token,
+                query_timeout,
+                db::sqlserver::execute_query_with_max_rows(&mut client, sql, max_rows),
+            )
+            .await
+            .map(|result| truncate_result_with_max_rows(result, max_rows));
+            drop(client);
+            if matches!(result.as_ref(), Err(err) if should_discard_pool_after_error(pool_db_type, err)) {
+                state.remove_pool_by_key(pool_key).await;
+            }
+            result
+        }
+        PoolKind::Elasticsearch(client) => {
+            let client = client.clone();
+            let sql = sql.to_string();
+            let max_rows = options.max_rows;
+            drop(connections);
+            let result = wait_for_query_opt(
+                cancel_token,
+                query_timeout,
+                db::elasticsearch_driver::execute_rest_query(&client, &sql),
+            )
+            .await
+            .map(|result| truncate_result_with_max_rows(result, max_rows));
+            if matches!(result.as_ref(), Err(err) if should_discard_pool_after_error(pool_db_type, err)) {
+                state.remove_pool_by_key(pool_key).await;
+            }
+            result
+        }
+        PoolKind::VectorDb(client) => {
+            let client = client.clone();
+            let sql = sql.to_string();
+            let max_rows = options.max_rows;
+            drop(connections);
+            let result =
+                wait_for_query_opt(cancel_token, query_timeout, db::vector_driver::execute_rest_query(&client, &sql))
+                    .await
+                    .map(|result| truncate_result_with_max_rows(result, max_rows));
+            if matches!(result.as_ref(), Err(err) if should_discard_pool_after_error(pool_db_type, err)) {
+                state.remove_pool_by_key(pool_key).await;
+            }
+            result
+        }
+        PoolKind::Redis(_) => Err("Use Redis-specific commands".to_string()),
+        PoolKind::MongoDb(_) => Err("Use MongoDB-specific commands".to_string()),
+        PoolKind::MessageQueue => Err("Use Message Queue-specific commands".to_string()),
+        PoolKind::Nacos => Err("Use Nacos-specific commands".to_string()),
+        PoolKind::InfluxDb(client) => {
+            let client = client.clone();
+            let database = pool_key.split(':').nth(1).unwrap_or("default").to_string();
+            let max_rows = options.max_rows;
+            drop(connections);
+            let result = wait_for_query_opt(
+                cancel_token,
+                query_timeout,
+                db::influxdb_driver::execute_query(&client, &database, sql),
+            )
+            .await
+            .map(|result| truncate_result_with_max_rows(result, max_rows));
+            if matches!(result.as_ref(), Err(err) if should_discard_pool_after_error(pool_db_type, err)) {
+                state.remove_pool_by_key(pool_key).await;
+            }
+            result
+        }
+        PoolKind::Agent(client) => {
+            let client = client.clone();
+            let sql = sql_for_execution_context(pool_db_type, sql, schema);
+            let database = database.map(|s| s.to_string());
+            let schema = schema_for_execution_context(pool_db_type, schema).map(|s| s.to_string());
+            let max_rows = options.max_rows;
+            let rpc_timeout = query_timeout;
+            drop(connections);
+            if is_canceled(&cancel_token) {
+                return Err(canceled_error());
+            }
+            let cancel_for_agent = cancel_token.clone();
+            let result = async move {
+                let mut client = match cancel_for_agent.as_ref() {
+                    Some(token) => {
+                        tokio::select! {
+                            biased;
+                            _ = token.cancelled() => return Err(canceled_error()),
+                            guard = client.lock() => guard,
+                        }
+                    }
+                    None => client.lock().await,
+                };
+                if let Some(session_id) = options.result_session_id.as_deref() {
+                    let params = agent_fetch_query_page_params(session_id, options.page_size.unwrap_or(MAX_ROWS));
+                    client.fetch_query_page_with_timeout_and_cancel(params, rpc_timeout, cancel_for_agent.clone()).await
+                } else if options.page_size.is_some() {
+                    let params = agent_execute_query_page_params(&sql, database.as_deref(), schema.as_deref(), options);
+                    client
+                        .execute_query_page_with_timeout_and_cancel(params, rpc_timeout, cancel_for_agent.clone())
+                        .await
+                } else {
+                    let params = agent_execute_query_params(&sql, database.as_deref(), schema.as_deref(), options);
+                    client.execute_query_with_timeout_and_cancel(params, rpc_timeout, cancel_for_agent.clone()).await
+                }
+            }
+            .await
+            .map(|result| truncate_result_with_max_rows(result, max_rows));
+            if matches!(result.as_ref(), Err(err) if err == QUERY_CANCELED) {
+                state.remove_pool_by_key(pool_key).await;
+            }
+            if matches!(result.as_ref(), Err(err) if should_discard_pool_after_error(pool_db_type, err)) {
+                state.remove_pool_by_key(pool_key).await;
+            }
+            result
+        }
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::ExternalTabular(ext_pool) => {
+            if !starts_with_duckdb_result_sql_keyword(sql) {
+                return Err("External data sources are read-only. Only SELECT queries are supported.".to_string());
+            }
+            let con = ext_pool.cache.clone();
+            let interrupt_handle = con.lock().map_err(|e| e.to_string())?.interrupt_handle();
+            if let Some(ref execution_id) = options.execution_id {
+                let cancel_interrupt_handle = interrupt_handle.clone();
+                state.running_queries.register_interrupt(execution_id, move || {
+                    cancel_interrupt_handle.interrupt();
+                });
+            }
+            let sql = sql.to_string();
+            let max_rows = options.max_rows;
+            drop(connections);
+            let task = tokio::task::spawn_blocking(move || {
+                let con = con.lock().map_err(|e| e.to_string())?;
+                duckdb_execute_with_max_rows(&con, &sql, max_rows)
+            });
+            wait_for_duckdb_task_with_interrupt(cancel_token, query_timeout, interrupt_handle, task).await
+        }
+        #[cfg(not(feature = "duckdb-bundled"))]
+        PoolKind::ExternalTabular(_) => {
+            Err("External data sources require DuckDB support. Rebuild with default features.".to_string())
+        }
+        PoolKind::ExternalDriver { config, session, .. } => {
+            let config = config.clone();
+            let session = session.clone();
+            let sql = sql.to_string();
+            let schema = schema.map(str::to_string);
+            let database = database.unwrap_or_else(|| config.effective_database().unwrap_or("")).to_string();
+            let max_rows = options.max_rows;
+            let plugin_timeout = query_timeout;
+            drop(connections);
+            wait_for_query_opt(cancel_token, query_timeout, async move {
+                if let Some(session_id) = options.result_session_id.as_deref() {
+                    let params = external_driver_fetch_query_page_params(
+                        config.as_ref(),
+                        session_id,
+                        options.page_size.unwrap_or(MAX_ROWS),
+                    );
+                    session.invoke_with_timeout::<db::QueryResult>("fetchQueryPage", params, plugin_timeout).await
+                } else if options.page_size.is_some() {
+                    let params =
+                        external_driver_query_params(config.as_ref(), &sql, &database, schema.as_deref(), &options);
+                    invoke_external_driver_query_page(session.as_ref(), params, plugin_timeout).await
+                } else {
+                    let params =
+                        external_driver_query_params(config.as_ref(), &sql, &database, schema.as_deref(), &options);
+                    session.invoke_with_timeout::<db::QueryResult>("executeQuery", params, plugin_timeout).await
+                }
+            })
+            .await
+            .map(|result| truncate_result_with_max_rows(result, max_rows))
+        }
+    };
+    result.map(normalize_query_result_for_js)
+}
+
+async fn invoke_external_driver_query_page(
+    session: &crate::plugins::PluginDriverSession,
+    params: serde_json::Value,
+    plugin_timeout: Option<Duration>,
+) -> Result<db::QueryResult, String> {
+    match session.invoke_with_timeout::<db::QueryResult>("executeQueryPage", params.clone(), plugin_timeout).await {
+        Ok(result) => Ok(result),
+        Err(error) if is_external_driver_method_unsupported(&error, "executeQueryPage") => {
+            // Plugins installed by older DBX releases predate cursor pagination. Keep
+            // basic queries usable until the user updates the plugin, without retrying
+            // actual JDBC/SQL failures that may have side effects.
+            log::warn!("[query][external-driver] executeQueryPage unsupported; falling back to executeQuery");
+            session.invoke_with_timeout::<db::QueryResult>("executeQuery", params, plugin_timeout).await
+        }
+        Err(error) => Err(error),
+    }
+}
+
+fn is_external_driver_method_unsupported(error: &str, method: &str) -> bool {
+    let normalized = error.to_ascii_lowercase();
+    let method = method.to_ascii_lowercase();
+    normalized.contains(&method)
+        && (normalized.contains("unsupported jdbc plugin method")
+            || normalized.contains("unknown method")
+            || normalized.contains("method not found"))
+}
+
+fn external_driver_query_params(
+    config: &crate::models::connection::ConnectionConfig,
+    sql: &str,
+    database: &str,
+    schema: Option<&str>,
+    options: &QueryExecutionOptions,
+) -> serde_json::Value {
+    let mut params = serde_json::json!({
+        "connection": config,
+        "sql": sql,
+        "database": database,
+        "schema": schema,
+        "maxRows": options.max_rows.unwrap_or(MAX_ROWS),
+    });
+    if let Some(fetch_size) = options.fetch_size {
+        params["fetchSize"] = serde_json::json!(fetch_size);
+    }
+    if let Some(timeout_secs) = options.timeout_secs {
+        params["timeoutSecs"] = serde_json::json!(timeout_secs);
+    }
+    if let Some(page_size) = options.page_size {
+        params["pageSize"] = serde_json::json!(page_size);
+    }
+    params
+}
+
+fn external_driver_fetch_query_page_params(
+    config: &crate::models::connection::ConnectionConfig,
+    session_id: &str,
+    page_size: usize,
+) -> serde_json::Value {
+    serde_json::json!({
+        "connection": config,
+        "sessionId": session_id,
+        "pageSize": page_size,
+    })
+}
+
+pub async fn execute_sql_statement(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    sql: &str,
+    schema: Option<&str>,
+    cancel_token: Option<CancellationToken>,
+) -> Result<db::QueryResult, String> {
+    execute_sql_statement_with_options(
+        state,
+        connection_id,
+        database,
+        sql,
+        schema,
+        cancel_token,
+        QueryExecutionOptions::default(),
+    )
+    .await
+}
+
+pub async fn execute_sql_statement_with_options(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    sql: &str,
+    schema: Option<&str>,
+    cancel_token: Option<CancellationToken>,
+    options: QueryExecutionOptions,
+) -> Result<db::QueryResult, String> {
+    // MongoDB connections use shell-style commands dispatched through the
+    // frontend parser. Queries that fall through to the generic SQL executor
+    // (e.g. typos) must be rejected before any pool/key creation so that
+    // session-scoped pools do not leak MongoDB Clients and SSH tunnels.
+    if connection_is_mongodb(state, connection_id).await {
+        return Err("Use MongoDB-specific commands".to_string());
+    }
+
+    let db_type = connection_database_type(state, connection_id).await;
+    let has_executable_sql = db_type.map_or_else(
+        || crate::sql::has_executable_sql(sql),
+        |db_type| crate::sql::has_executable_sql_for_database(sql, db_type),
+    );
+    if !has_executable_sql {
+        return Ok(empty_query_result(0));
+    }
+
+    if let Some(target_database) = postgres_drop_database_target(db_type, sql) {
+        return execute_postgres_drop_database(state, connection_id, &target_database, sql, cancel_token, options)
+            .await;
+    }
+
+    // When a query tab has a client session, keep even database-less execution
+    // on that tab-scoped pool so connection-level state (for example MySQL @vars)
+    // survives across runs.
+    let pool_key = if database.is_empty() {
+        state.get_or_create_pool_for_session(connection_id, None, options.client_session_id.as_deref()).await?
+    } else {
+        state
+            .get_or_create_pool_for_session(connection_id, Some(database), options.client_session_id.as_deref())
+            .await?
+    };
+
+    if is_canceled(&cancel_token) {
+        return Err(canceled_error());
+    }
+
+    let mysql_dialect = connection_mysql_query_dialect(state, connection_id).await;
+    let result =
+        do_execute(state, &pool_key, mysql_dialect, Some(database), sql, schema, cancel_token.clone(), options.clone())
+            .await;
+
+    let action = result.as_ref().err().map(|e| query_pool_error_action(db_type, sql, e));
+    match action {
+        Some(PoolErrorAction::ReconnectAndRetry) if !is_canceled(&cancel_token) => {
+            let db_opt = if database.is_empty() { None } else { Some(database) };
+            let new_key =
+                state.reconnect_pool_for_session(connection_id, db_opt, options.client_session_id.as_deref()).await?;
+            do_execute(state, &new_key, mysql_dialect, Some(database), sql, schema, cancel_token, options).await
+        }
+        Some(PoolErrorAction::Discard) => {
+            state.remove_pool_by_key(&pool_key).await;
+            result
+        }
+        _ => result,
+    }
+}
+
+async fn execute_postgres_drop_database(
+    state: &AppState,
+    connection_id: &str,
+    target_database: &str,
+    sql: &str,
+    cancel_token: Option<CancellationToken>,
+    options: QueryExecutionOptions,
+) -> Result<db::QueryResult, String> {
+    state.close_database_pool(connection_id, Some(target_database)).await?;
+
+    let admin_database = postgres_drop_database_admin_database(target_database);
+    let pool_key = state
+        .get_or_create_pool_for_session(connection_id, Some(admin_database), options.client_session_id.as_deref())
+        .await?;
+    if let Some(execution_id) = options.execution_id.as_deref() {
+        state.running_queries.set_pool_key(execution_id, pool_key.clone());
+    }
+    state.touch_pool_activity(&pool_key).await;
+    let _activity_touch = state.pool_activity_touch(pool_key.as_str());
+
+    if is_canceled(&cancel_token) {
+        return Err(canceled_error());
+    }
+
+    check_read_only_for_connection(state, &pool_key, sql).await?;
+    let pool = {
+        let connections = state.connections.read().await;
+        match connections.get(&pool_key) {
+            Some(PoolKind::Postgres(pool)) => pool.clone(),
+            Some(_) => return Err("DROP DATABASE reconnect did not create a PostgreSQL connection".to_string()),
+            None => return Err("Connection not found".to_string()),
+        }
+    };
+
+    let query_timeout = resolve_query_timeout(options.timeout_secs);
+    let max_rows = options.max_rows;
+    wait_for_query_opt(cancel_token, query_timeout, async {
+        db::postgres::terminate_current_user_database_backends(&pool, target_database).await?;
+        db::postgres::execute_query_with_max_rows(&pool, sql, max_rows).await
+    })
+    .await
+}
+
+fn postgres_drop_database_target(db_type: Option<DatabaseType>, sql: &str) -> Option<String> {
+    if db_type != Some(DatabaseType::Postgres) {
+        return None;
+    }
+    parse_drop_database_target(sql)
+}
+
+fn postgres_drop_database_admin_database(target_database: &str) -> &'static str {
+    if target_database.eq_ignore_ascii_case("postgres") {
+        "template1"
+    } else {
+        "postgres"
+    }
+}
+
+fn parse_drop_database_target(sql: &str) -> Option<String> {
+    let dialect = PostgreSqlDialect {};
+    let statements = Parser::parse_sql(&dialect, sql).ok()?;
+    let [Statement::Drop { object_type, names, .. }] = statements.as_slice() else {
+        return None;
+    };
+    if *object_type != ObjectType::Database || names.len() != 1 {
+        return None;
+    }
+
+    let parts = &names[0].0;
+    if parts.len() != 1 {
+        return None;
+    }
+    parts[0].as_ident().map(|ident| ident.value.clone())
+}
+
+pub async fn close_query_session(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    session_id: &str,
+    client_session_id: Option<&str>,
+) -> Result<bool, String> {
+    let pool_key = if database.is_empty() {
+        state.get_or_create_pool_for_session(connection_id, None, client_session_id).await?
+    } else {
+        state.get_or_create_pool_for_session(connection_id, Some(database), client_session_id).await?
+    };
+
+    let connections = state.connections.read().await;
+    let pool = connections.get(&pool_key).ok_or("Connection not found")?;
+    match pool {
+        PoolKind::Agent(client) => {
+            let client = client.clone();
+            drop(connections);
+            let mut client = client.lock().await;
+            client.close_query_session(session_id).await
+        }
+        PoolKind::ExternalDriver { config, session, .. } => {
+            let config = config.clone();
+            let session = session.clone();
+            drop(connections);
+            let params = external_driver_fetch_query_page_params(config.as_ref(), session_id, 1);
+            session
+                .invoke::<serde_json::Value>("closeQuerySession", params)
+                .await
+                .map(|value| value.get("ok").and_then(|ok| ok.as_bool()).unwrap_or(false))
+        }
+        _ => Ok(false),
+    }
+}
+
+pub async fn execute_multi_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    sql: &str,
+    schema: Option<&str>,
+    cancel_token: Option<CancellationToken>,
+) -> Result<Vec<db::QueryResult>, String> {
+    execute_multi_core_with_options(
+        state,
+        connection_id,
+        database,
+        sql,
+        schema,
+        cancel_token,
+        QueryExecutionOptions::default(),
+    )
+    .await
+}
+
+pub async fn execute_multi_core_with_options(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    sql: &str,
+    schema: Option<&str>,
+    cancel_token: Option<CancellationToken>,
+    options: QueryExecutionOptions,
+) -> Result<Vec<db::QueryResult>, String> {
+    execute_multi_core_with_options_for_client(state, connection_id, database, sql, schema, cancel_token, options)
+        .await
+        .map(|results| results.into_iter().map(ExecuteMultiResult::into_query_result).collect())
+}
+
+/// Execute a SQL batch and retain client-facing metadata for synthesized errors.
+pub async fn execute_multi_core_with_options_for_client(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    sql: &str,
+    schema: Option<&str>,
+    cancel_token: Option<CancellationToken>,
+    options: QueryExecutionOptions,
+) -> Result<Vec<ExecuteMultiResult>, String> {
+    // Reject MongoDB queries that fall through to the generic executor.
+    if connection_is_mongodb(state, connection_id).await {
+        return Err("Use MongoDB-specific commands".to_string());
+    }
+
+    let pool_key = if database.is_empty() {
+        state.get_or_create_pool_for_session(connection_id, None, options.client_session_id.as_deref()).await?
+    } else {
+        state
+            .get_or_create_pool_for_session(connection_id, Some(database), options.client_session_id.as_deref())
+            .await?
+    };
+    if let Some(execution_id) = options.execution_id.as_deref() {
+        state.running_queries.set_pool_key(execution_id, pool_key.clone());
+    }
+    state.touch_pool_activity(&pool_key).await;
+    let _activity_touch = state.pool_activity_touch(pool_key.as_str());
+
+    let is_sqlserver = {
+        let connections = state.connections.read().await;
+        matches!(connections.get(&pool_key), Some(PoolKind::SqlServer(_)))
+    };
+
+    if is_sqlserver {
+        return execute_multi_sqlserver(state, &pool_key, sql, cancel_token, options)
+            .await
+            .map(|results| results.into_iter().map(Into::into).collect());
+    }
+
+    let is_http_sqlite = {
+        let configs = state.configs.read().await;
+        configs
+            .get(connection_id)
+            .is_some_and(|c| matches!(c.db_type, DatabaseType::Turso | DatabaseType::CloudflareD1))
+    };
+
+    // HTTP SQLite providers send all statements in one request so the provider
+    // can preserve batch ordering and atomicity.
+    if is_http_sqlite {
+        let result =
+            execute_sql_statement_with_options(state, connection_id, database, sql, schema, cancel_token, options)
+                .await?;
+        return Ok(vec![result.into()]);
+    }
+
+    let db_type = connection_database_type(state, connection_id).await;
+    let statements = db_type.map_or_else(
+        || split_sql_statements(sql),
+        |db_type| crate::sql::split_sql_statements_for_database(sql, db_type),
+    );
+    if statements.is_empty() {
+        return Ok(vec![empty_query_result(0).into()]);
+    }
+
+    // When use_transaction is explicitly true and we have multiple statements,
+    // route through the transaction wrapper instead of the sequential auto-commit loop.
+    if options.use_transaction == Some(true) && statements.len() > 1 {
+        let result = execute_statements_in_transaction(state, connection_id, database, &statements, schema).await?;
+        return Ok(vec![result.into()]);
+    }
+
+    let mysql_pool = {
+        let connections = state.connections.read().await;
+        match connections.get(&pool_key) {
+            Some(PoolKind::Mysql(pool, mode)) => Some((pool.clone(), *mode)),
+            _ => None,
+        }
+    };
+
+    if statements.len() <= 1 {
+        let single_sql = statements.into_iter().next().unwrap_or_default();
+        let result = execute_sql_statement_with_options(
+            state,
+            connection_id,
+            database,
+            &single_sql,
+            schema,
+            cancel_token,
+            options,
+        )
+        .await?;
+        return Ok(vec![result.into()]);
+    }
+
+    if let Some((pool, mode)) = mysql_pool {
+        // Read-only check for MySQL batch path
+        check_read_only_for_connection_multi(state, &pool_key, &statements).await?;
+        let mysql_dialect = connection_mysql_query_dialect(state, connection_id).await;
+        return execute_multi_mysql(
+            state,
+            &pool_key,
+            db_type,
+            &pool,
+            mode,
+            mysql_dialect,
+            &statements,
+            cancel_token,
+            options,
+        )
+        .await;
+    }
+
+    let mut results = Vec::with_capacity(statements.len());
+    for stmt in &statements {
+        if is_canceled(&cancel_token) {
+            results.push(error_query_result(canceled_error()));
+            break;
+        }
+        match execute_sql_statement_with_options(
+            state,
+            connection_id,
+            database,
+            stmt,
+            schema,
+            cancel_token.clone(),
+            options.clone(),
+        )
+        .await
+        {
+            Ok(r) => results.push(r),
+            Err(e) => {
+                results.push(error_query_result(e));
+            }
+        }
+    }
+
+    Ok(results.into_iter().map(Into::into).collect())
+}
+
+trait MysqlBatchStatementExecutor {
+    async fn execute_statement(&mut self, statement: &str) -> Result<db::QueryResult, String>;
+}
+
+struct MysqlBatchConnection<'a> {
+    conn: &'a mut mysql_async::Conn,
+    cancel_token: Option<CancellationToken>,
+    query_timeout: Option<Duration>,
+    bare: bool,
+    max_rows: Option<usize>,
+    dialect: db::mysql::MySqlQueryDialect,
+}
+
+impl MysqlBatchStatementExecutor for MysqlBatchConnection<'_> {
+    async fn execute_statement(&mut self, statement: &str) -> Result<db::QueryResult, String> {
+        wait_for_query_opt(
+            self.cancel_token.clone(),
+            self.query_timeout,
+            db::mysql::execute_query_on_conn_with_max_rows(
+                &mut *self.conn,
+                statement,
+                self.bare,
+                self.max_rows,
+                self.dialect,
+            ),
+        )
+        .await
+    }
+}
+
+async fn execute_mysql_batch_statements<E>(
+    executor: &mut E,
+    statements: &[String],
+    db_type: Option<DatabaseType>,
+    cancel_token: Option<CancellationToken>,
+) -> (Vec<ExecuteMultiResult>, Option<PoolErrorAction>)
+where
+    E: MysqlBatchStatementExecutor,
+{
+    let mut results = Vec::with_capacity(statements.len());
+    for statement in statements {
+        if is_canceled(&cancel_token) {
+            results.push(ExecuteMultiResult::execution_error(error_query_result(canceled_error())));
+            return (results, None);
+        }
+
+        match executor.execute_statement(statement).await {
+            Ok(result) => results.push(result.into()),
+            Err(err) => {
+                let action = pool_error_action(db_type, &err);
+                results.push(ExecuteMultiResult::execution_error(error_query_result(err)));
+                // Do not run dependent statements after any MySQL-protocol statement fails.
+                return (results, Some(action));
+            }
+        }
+    }
+
+    (results, None)
+}
+
+async fn execute_multi_mysql(
+    state: &AppState,
+    pool_key: &str,
+    db_type: Option<DatabaseType>,
+    pool: &db::mysql::MySqlPool,
+    mode: crate::connection::MysqlMode,
+    dialect: db::mysql::MySqlQueryDialect,
+    statements: &[String],
+    cancel_token: Option<CancellationToken>,
+    options: QueryExecutionOptions,
+) -> Result<Vec<ExecuteMultiResult>, String> {
+    let query_timeout = resolve_query_timeout(options.timeout_secs);
+    let operation_budget = operation_budget_for_pool_key(state, pool_key, query_timeout).await;
+    let bare = mode == crate::connection::MysqlMode::Bare;
+    let max_rows = options.max_rows;
+    let mut conn = match db::mysql::get_conn_with_health_check_with_cancel(
+        pool,
+        operation_budget.checkout_timeout,
+        operation_budget.cleanup_timeout,
+        cancel_token.as_ref(),
+    )
+    .await
+    {
+        Ok(conn) => conn,
+        Err(err) => {
+            if matches!(pool_error_action(db_type, &err), PoolErrorAction::Discard | PoolErrorAction::ReconnectAndRetry)
+                || err == QUERY_CANCELED
+            {
+                state.remove_pool_by_key(pool_key).await;
+            }
+            return Ok(vec![ExecuteMultiResult::execution_error(error_query_result(err))]);
+        }
+    };
+    apply_oceanbase_mysql_session_timeout(state, pool_key, &mut conn, options.timeout_secs).await?;
+
+    let mut executor = MysqlBatchConnection {
+        conn: &mut conn,
+        cancel_token: cancel_token.clone(),
+        query_timeout,
+        bare,
+        max_rows,
+        dialect,
+    };
+    let (results, error_action) =
+        execute_mysql_batch_statements(&mut executor, statements, db_type, cancel_token).await;
+    drop(executor);
+
+    if matches!(error_action, Some(PoolErrorAction::Discard | PoolErrorAction::ReconnectAndRetry)) {
+        state.remove_pool_by_key(pool_key).await;
+    }
+
+    Ok(results)
+}
+
+fn error_query_result(message: String) -> db::QueryResult {
+    db::QueryResult {
+        columns: vec!["Error".to_string()],
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: vec![vec![serde_json::Value::String(message)]],
+        affected_rows: 0,
+        execution_time_ms: 0,
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    }
+}
+
+fn empty_query_result(execution_time_ms: u128) -> db::QueryResult {
+    db::QueryResult {
+        columns: vec![],
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: vec![],
+        affected_rows: 0,
+        execution_time_ms,
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    }
+}
+
+async fn execute_multi_sqlserver(
+    state: &AppState,
+    pool_key: &str,
+    sql: &str,
+    cancel_token: Option<CancellationToken>,
+    options: QueryExecutionOptions,
+) -> Result<Vec<db::QueryResult>, String> {
+    let batches = split_sql_batches(sql);
+
+    // Read-only check for SQL Server batch path
+    check_read_only_for_connection_multi(state, pool_key, &batches).await?;
+    let mut all_results = Vec::new();
+    let max_rows = options.max_rows;
+    let query_timeout = resolve_query_timeout(options.timeout_secs);
+
+    for batch in &batches {
+        if is_canceled(&cancel_token) {
+            all_results.push(db::QueryResult {
+                columns: vec!["Error".to_string()],
+                column_types: Vec::new(),
+                column_sortables: vec![],
+                rows: vec![vec![serde_json::Value::String(canceled_error())]],
+                affected_rows: 0,
+                execution_time_ms: 0,
+                truncated: false,
+                session_id: None,
+                has_more: false,
+            });
+            break;
+        }
+
+        let connections = state.connections.read().await;
+        let pool = connections.get(pool_key).ok_or("Connection not found")?;
+        let client = match pool {
+            PoolKind::SqlServer(c) => c.clone(),
+            _ => return Err("Expected SQL Server connection".to_string()),
+        };
+        drop(connections);
+
+        let mut client_guard = match wait_for_value_opt(cancel_token.clone(), query_timeout, client.lock()).await {
+            Ok(guard) => guard,
+            Err(err) => {
+                all_results.push(error_query_result(err));
+                break;
+            }
+        };
+
+        if !sqlserver_pool_is_current(state, pool_key, &client).await {
+            all_results.push(error_query_result(
+                "SQL Server connection was reset while waiting for the query lock; please retry.".to_string(),
+            ));
+            break;
+        }
+
+        let result = wait_for_result_opt(
+            cancel_token.clone(),
+            query_timeout,
+            db::sqlserver::execute_batch_with_max_rows(&mut client_guard, batch, max_rows),
+        )
+        .await;
+        drop(client_guard);
+
+        match result {
+            Ok(results) => all_results.extend(results),
+            Err(e) => {
+                let action = pool_error_action(Some(DatabaseType::SqlServer), &e);
+                all_results.push(db::QueryResult {
+                    columns: vec!["Error".to_string()],
+                    column_types: Vec::new(),
+                    column_sortables: vec![],
+                    rows: vec![vec![serde_json::Value::String(e)]],
+                    affected_rows: 0,
+                    execution_time_ms: 0,
+                    truncated: false,
+                    session_id: None,
+                    has_more: false,
+                });
+                if matches!(action, PoolErrorAction::Discard | PoolErrorAction::ReconnectAndRetry) {
+                    state.remove_pool_by_key(pool_key).await;
+                    break;
+                }
+            }
+        }
+    }
+
+    if all_results.is_empty() {
+        all_results.push(db::QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: 0,
+            execution_time_ms: 0,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        });
+    }
+
+    Ok(all_results)
+}
+
+pub async fn execute_statements(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    statements: &[String],
+    schema: Option<&str>,
+    timeout_secs: Option<u64>,
+) -> Result<db::QueryResult, String> {
+    let pool_key = if database.is_empty() {
+        connection_id.to_string()
+    } else {
+        state.get_or_create_pool(connection_id, Some(database)).await?
+    };
+
+    let mut total_affected: u64 = 0;
+    let start = std::time::Instant::now();
+    let mysql_dialect = connection_mysql_query_dialect(state, connection_id).await;
+
+    let agent_client = {
+        let conns = state.connections.read().await;
+        match conns.get(&pool_key) {
+            Some(PoolKind::Agent(client)) => Some(client.clone()),
+            _ => None,
+        }
+    };
+    if let Some(client) = agent_client {
+        check_read_only_for_connection_multi(state, &pool_key, statements).await?;
+        let db_type = connection_database_type_for_pool_key(state, &pool_key).await;
+        let execution_schema = schema_for_execution_context(db_type, schema);
+        let rewritten_statements;
+        let statements = if matches!(db_type, Some(DatabaseType::Iris)) {
+            rewritten_statements =
+                statements.iter().map(|sql| sql_for_execution_context(db_type, sql, schema)).collect::<Vec<_>>();
+            rewritten_statements.as_slice()
+        } else {
+            statements
+        };
+        let mut client = client.lock().await;
+        let database = if database.trim().is_empty() { None } else { Some(database) };
+        let timeout_duration = timeout_secs.map(Duration::from_secs);
+        let result: Result<db::QueryResult, String> =
+            client.execute_batch(database, statements, execution_schema, timeout_duration).await;
+        match result {
+            Ok(result) => return Ok(db::QueryResult { execution_time_ms: start.elapsed().as_millis(), ..result }),
+            Err(err) => {
+                if is_agent_execute_batch_unsupported(&err) {
+                    log::warn!(
+                        "Agent does not support execute_batch; falling back to statement-by-statement execution"
+                    );
+                } else {
+                    match pool_error_action(connection_database_type(state, connection_id).await, &err) {
+                        PoolErrorAction::ReconnectAndRetry | PoolErrorAction::Discard => {
+                            let _ = state.remove_pool_by_key(&pool_key).await;
+                        }
+                        PoolErrorAction::Keep => {}
+                    }
+                    return Err(err);
+                }
+            }
+        }
+    }
+
+    for (i, sql) in statements.iter().enumerate() {
+        match do_execute(
+            state,
+            &pool_key,
+            mysql_dialect,
+            Some(database),
+            sql,
+            schema,
+            None,
+            QueryExecutionOptions { timeout_secs, ..Default::default() },
+        )
+        .await
+        {
+            Ok(result) => {
+                total_affected += result.affected_rows;
+            }
+            Err(e) => {
+                match pool_error_action(connection_database_type(state, connection_id).await, &e) {
+                    PoolErrorAction::ReconnectAndRetry => {
+                        let db_opt = if database.is_empty() { None } else { Some(database) };
+                        let _ = state.reconnect_pool(connection_id, db_opt).await;
+                    }
+                    PoolErrorAction::Discard => {
+                        let _ = state.remove_pool_by_key(&pool_key).await;
+                    }
+                    PoolErrorAction::Keep => {}
+                }
+                return Err(format!(
+                    "Statement {} failed: {}. Previous {} statement(s) may have been committed.",
+                    i + 1,
+                    e,
+                    i
+                ));
+            }
+        }
+    }
+
+    Ok(db::QueryResult {
+        columns: vec![],
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: vec![],
+        affected_rows: total_affected,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+fn is_agent_execute_batch_unsupported(error: &str) -> bool {
+    let lower = error.to_lowercase();
+    lower.contains("execute_batch") && (lower.contains("unknown method") || lower.contains("method not found"))
+}
+
+/// Execute multiple SQL statements within a single transaction.
+/// For pooled drivers (Postgres/MySQL), uses the driver transaction API.
+/// For SQLite and already-single-connection drivers (ClickHouse/SqlServer/Agent),
+/// uses explicit BEGIN/COMMIT/ROLLBACK on the shared connection.
+/// For databases that don't support explicit transactions (Redis, MongoDB, Oracle),
+/// executes statements sequentially without transaction.
+/// If BEGIN fails, returns an error instead of silently falling back to auto-commit.
+pub async fn execute_statements_in_transaction(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    statements: &[String],
+    schema: Option<&str>,
+) -> Result<db::QueryResult, String> {
+    let pool_key = if database.is_empty() {
+        connection_id.to_string()
+    } else {
+        state.get_or_create_pool(connection_id, Some(database)).await?
+    };
+
+    // Read-only check: intercept all transaction paths before dispatching
+    check_read_only_for_connection_multi(state, &pool_key, statements).await?;
+
+    let start = std::time::Instant::now();
+    let db_type = connection_database_type(state, connection_id).await;
+    let operation_budget = configured_operation_budget_for_pool_key(state, &pool_key).await;
+
+    // Clone the pool handle within the lock, then drop it before any async work.
+    let path = {
+        let conns = state.connections.read().await;
+        conns.get(&pool_key).map(|p| match p {
+            PoolKind::Postgres(pg) => TxPath::Pg(pg.clone()),
+            PoolKind::Mysql(mp, _mode) => TxPath::Mysql(mp.clone(), false),
+            PoolKind::Sqlite(sq) => TxPath::Sqlite(sq.clone()),
+            PoolKind::CloudflareD1(client) => TxPath::CloudflareD1(client.clone()),
+            PoolKind::ClickHouse(_)
+            | PoolKind::Rqlite(_)
+            | PoolKind::Turso(_)
+            | PoolKind::SqlServer(_)
+            | PoolKind::Agent(_) => TxPath::Explicit,
+            PoolKind::MessageQueue | PoolKind::Nacos => TxPath::None,
+            #[cfg(feature = "duckdb-bundled")]
+            PoolKind::DuckDb(_)
+            | PoolKind::DuckDbWorker(_)
+            | PoolKind::Redis(_)
+            | PoolKind::MongoDb(_)
+            | PoolKind::Elasticsearch(_)
+            | PoolKind::VectorDb(_)
+            | PoolKind::InfluxDb(_)
+            | PoolKind::ExternalTabular(_)
+            | PoolKind::ExternalDriver { .. } => TxPath::None,
+            #[cfg(not(feature = "duckdb-bundled"))]
+            PoolKind::DuckDb(_)
+            | PoolKind::DuckDbWorker(_)
+            | PoolKind::Redis(_)
+            | PoolKind::MongoDb(_)
+            | PoolKind::Elasticsearch(_)
+            | PoolKind::VectorDb(_)
+            | PoolKind::InfluxDb(_)
+            | PoolKind::ExternalTabular(_)
+            | PoolKind::ExternalDriver { .. } => TxPath::None,
+        })
+    };
+
+    let result = match path {
+        Some(TxPath::Pg(pool)) => {
+            let cancel_context = state.get_postgres_cancel_context(&pool_key).await;
+            exec_tx_pg_inner(pool, statements, schema, start, operation_budget.clone(), cancel_context).await
+        }
+        Some(TxPath::Mysql(pool, _bare)) => {
+            exec_tx_mysql_inner(state, &pool_key, pool, statements, start, operation_budget.clone()).await
+        }
+        Some(TxPath::Sqlite(pool)) => exec_tx_sqlite_inner(pool, statements, start).await,
+        Some(TxPath::CloudflareD1(client)) => {
+            let sql = statements.join(";\n");
+            wait_for_query_opt(
+                None,
+                operation_budget.query_timeout,
+                db::cloudflare_d1_driver::execute_query_with_max_rows(&client, &sql, None),
+            )
+            .await
+        }
+        Some(TxPath::Explicit) => {
+            let mysql_dialect = connection_mysql_query_dialect(state, connection_id).await;
+            exec_tx_explicit_inner(state, &pool_key, mysql_dialect, Some(database), statements, schema, start).await
+        }
+        Some(TxPath::None) => {
+            let mysql_dialect = connection_mysql_query_dialect(state, connection_id).await;
+            exec_tx_none_inner(state, &pool_key, mysql_dialect, Some(database), statements, schema, start).await
+        }
+        None => Err("Connection not found for transaction".to_string()),
+    };
+
+    if let Err(err) = result.as_ref() {
+        if matches!(pool_error_action(db_type, err), PoolErrorAction::Discard | PoolErrorAction::ReconnectAndRetry) {
+            state.remove_pool_by_key(&pool_key).await;
+        }
+    }
+
+    result
+}
+
+/// Owned pool variants for safe dispatch across async boundaries.
+enum TxPath {
+    Pg(deadpool_postgres::Pool),
+    Mysql(mysql_async::Pool, bool),
+    Sqlite(db::sqlite::SqliteHandle),
+    CloudflareD1(db::cloudflare_d1_driver::CloudflareD1Client),
+    Explicit,
+    None,
+}
+
+// Each of these acquires a dedicated connection and runs all statements within
+// BEGIN ... COMMIT/ROLLBACK, guaranteeing a single physical connection.
+
+async fn exec_tx_pg_inner(
+    pool: deadpool_postgres::Pool,
+    statements: &[String],
+    schema: Option<&str>,
+    start: std::time::Instant,
+    budget: DbOperationBudget,
+    cancel_context: Option<db::postgres::PostgresCancelContext>,
+) -> Result<db::QueryResult, String> {
+    let mut client = db::postgres::checkout_postgres_client(&pool, None, budget.checkout_timeout)
+        .await
+        .map_err(|e| format!("Failed to acquire connection: {}", e))?;
+    let had_schema = schema.is_some();
+    if let Some(s) = schema {
+        db::postgres::execute_postgres_infra_statement(
+            &client,
+            &format!("SET search_path TO {}", db::postgres::pg_quote_ident(s)),
+            budget.recycle_timeout,
+            "schema.set",
+        )
+        .await
+        .map_err(|e| format!("SET search_path failed: {}", e))?;
+    }
+    let tx_result = exec_tx_pg_statements(&mut client, statements, &budget, cancel_context).await;
+
+    // Always reset search_path so the connection is clean when returned to the pool
+    let reset_result = if had_schema {
+        db::postgres::execute_postgres_infra_statement(
+            &client,
+            "RESET search_path",
+            budget.cleanup_timeout,
+            "schema.reset",
+        )
+        .await
+        .map_err(|err| format!("PostgreSQL schema.reset cleanup failed: {err}"))
+    } else {
+        Ok(0)
+    };
+
+    match (tx_result, reset_result) {
+        (Ok(total_affected), Ok(_)) => Ok(db::QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: total_affected,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        }),
+        (Err(e), Ok(_)) => Err(e),
+        (Ok(_), Err(reset_err)) => Err(reset_err),
+        (Err(e), Err(reset_err)) => Err(format!("{e}; {reset_err}")),
+    }
+}
+
+async fn exec_tx_pg_statements(
+    client: &mut deadpool_postgres::Client,
+    statements: &[String],
+    budget: &DbOperationBudget,
+    cancel_context: Option<db::postgres::PostgresCancelContext>,
+) -> Result<u64, String> {
+    let tx = tokio::time::timeout(budget.recycle_timeout, client.transaction())
+        .await
+        .map_err(|_| {
+            format!("Failed to begin transaction: timed out after {} seconds", budget.recycle_timeout.as_secs())
+        })?
+        .map_err(|e| format!("Failed to begin transaction: {}", e))?;
+    let mut total_affected: u64 = 0;
+    for (i, sql) in statements.iter().enumerate() {
+        let pg_cancel_token = tx.client().cancel_token();
+        let affected = db::postgres::wait_postgres_operation(
+            pg_cancel_token,
+            cancel_context.clone(),
+            budget.query_timeout,
+            budget.cancel_timeout,
+            async { tx.execute(sql, &[]).await.map_err(|e| e.to_string()) },
+        )
+        .await
+        .map_err(|e| format!("Statement {} failed: {}", i + 1, e))?;
+        total_affected += affected;
+    }
+    tokio::time::timeout(budget.cleanup_timeout, tx.commit())
+        .await
+        .map_err(|_| format!("COMMIT timed out after {} seconds", budget.cleanup_timeout.as_secs()))?
+        .map_err(|e| format!("COMMIT failed: {}", e))?;
+    Ok(total_affected)
+}
+
+async fn exec_tx_mysql_inner(
+    state: &AppState,
+    pool_key: &str,
+    pool: mysql_async::Pool,
+    statements: &[String],
+    start: std::time::Instant,
+    budget: DbOperationBudget,
+) -> Result<db::QueryResult, String> {
+    let mut conn = db::mysql::get_conn_with_health_check_with_timeout(&pool, budget.checkout_timeout).await?;
+    apply_oceanbase_mysql_session_timeout(state, pool_key, &mut conn, None).await?;
+    mysql_query_drop_with_timeout(
+        &mut conn,
+        "START TRANSACTION",
+        budget.recycle_timeout,
+        "Failed to begin transaction",
+    )
+    .await?;
+    let mut total_affected: u64 = 0;
+    for (i, sql) in statements.iter().enumerate() {
+        match mysql_query_iter_with_timeout(&mut conn, sql, budget.query_timeout).await {
+            Ok(affected) => total_affected += affected,
+            Err(e) => {
+                let _ = mysql_query_drop_with_timeout(&mut conn, "ROLLBACK", budget.cleanup_timeout, "ROLLBACK failed")
+                    .await;
+                return Err(format!("Statement {} failed: {}", i + 1, e));
+            }
+        }
+    }
+    mysql_query_drop_with_timeout(&mut conn, "COMMIT", budget.cleanup_timeout, "COMMIT failed").await?;
+    Ok(db::QueryResult {
+        columns: vec![],
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: vec![],
+        affected_rows: total_affected,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+async fn mysql_query_drop_with_timeout(
+    conn: &mut mysql_async::Conn,
+    sql: &str,
+    timeout_duration: Duration,
+    context: &str,
+) -> Result<(), String> {
+    tokio::time::timeout(timeout_duration, conn.query_drop(sql))
+        .await
+        .map_err(|_| format!("{context}: timed out after {} seconds", timeout_duration.as_secs()))?
+        .map_err(|e| format!("{context}: {e}"))
+}
+
+async fn mysql_query_iter_with_timeout(
+    conn: &mut mysql_async::Conn,
+    sql: &str,
+    timeout_duration: Option<Duration>,
+) -> Result<u64, String> {
+    match timeout_duration {
+        Some(timeout_duration) => tokio::time::timeout(timeout_duration, conn.query_iter(sql))
+            .await
+            .map_err(|_| format!("Query timed out after {} seconds", timeout_duration.as_secs()))?
+            .map(|result| result.affected_rows())
+            .map_err(|e| e.to_string()),
+        None => conn.query_iter(sql).await.map(|result| result.affected_rows()).map_err(|e| e.to_string()),
+    }
+}
+
+async fn exec_tx_sqlite_inner(
+    pool: db::sqlite::SqliteHandle,
+    statements: &[String],
+    start: std::time::Instant,
+) -> Result<db::QueryResult, String> {
+    let statements = statements.to_vec();
+    tokio::task::spawn_blocking(move || {
+        pool.with_connection(|conn| {
+            conn.execute_batch("BEGIN").map_err(|e| format!("Failed to begin transaction: {}", e))?;
+            let mut total_affected: u64 = 0;
+            for (i, sql) in statements.iter().enumerate() {
+                match conn.execute_batch(sql) {
+                    Ok(_) => total_affected += conn.changes(),
+                    Err(e) => {
+                        let _ = conn.execute_batch("ROLLBACK");
+                        return Err(format!("Statement {} failed: {}", i + 1, e));
+                    }
+                }
+            }
+            conn.execute_batch("COMMIT").map_err(|e| format!("COMMIT failed: {}", e))?;
+            Ok(db::QueryResult {
+                columns: vec![],
+                column_types: Vec::new(),
+                column_sortables: vec![],
+                rows: vec![],
+                affected_rows: total_affected,
+                execution_time_ms: start.elapsed().as_millis(),
+                truncated: false,
+                session_id: None,
+                has_more: false,
+            })
+        })
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+async fn exec_tx_explicit_inner(
+    state: &AppState,
+    pool_key: &str,
+    mysql_dialect: db::mysql::MySqlQueryDialect,
+    database: Option<&str>,
+    statements: &[String],
+    schema: Option<&str>,
+    start: std::time::Instant,
+) -> Result<db::QueryResult, String> {
+    let conns = state.connections.read().await;
+    if let Some(crate::connection::PoolKind::Agent(client)) = conns.get(pool_key) {
+        let db_type = connection_database_type_for_pool_key(state, pool_key).await;
+        let execution_schema = schema_for_execution_context(db_type, schema);
+        let rewritten_statements;
+        let statements = if matches!(db_type, Some(DatabaseType::Iris)) {
+            rewritten_statements =
+                statements.iter().map(|sql| sql_for_execution_context(db_type, sql, schema)).collect::<Vec<_>>();
+            rewritten_statements.as_slice()
+        } else {
+            statements
+        };
+        let mut client = client.lock().await;
+        let result: db::QueryResult = client.execute_transaction(database, statements, execution_schema).await?;
+        return Ok(db::QueryResult { execution_time_ms: start.elapsed().as_millis(), ..result });
+    }
+    drop(conns);
+
+    do_execute(
+        state,
+        pool_key,
+        mysql_dialect,
+        database,
+        "BEGIN TRANSACTION",
+        schema,
+        None,
+        QueryExecutionOptions::default(),
+    )
+    .await
+    .map_err(|e| format!("Failed to begin transaction: {}", e))?;
+
+    let mut total_affected: u64 = 0;
+    for (i, sql) in statements.iter().enumerate() {
+        match do_execute(state, pool_key, mysql_dialect, database, sql, schema, None, QueryExecutionOptions::default())
+            .await
+        {
+            Ok(result) => {
+                total_affected += result.affected_rows;
+            }
+            Err(e) => {
+                if let Err(rb_err) = do_execute(
+                    state,
+                    pool_key,
+                    mysql_dialect,
+                    database,
+                    "ROLLBACK",
+                    schema,
+                    None,
+                    QueryExecutionOptions::default(),
+                )
+                .await
+                {
+                    log::error!("ROLLBACK failed after statement {} error: {}", i + 1, rb_err);
+                }
+                return Err(format!("Statement {} failed: {}", i + 1, e));
+            }
+        }
+    }
+
+    do_execute(state, pool_key, mysql_dialect, database, "COMMIT", schema, None, QueryExecutionOptions::default())
+        .await
+        .map_err(|e| format!("COMMIT failed: {}", e))?;
+
+    Ok(db::QueryResult {
+        columns: vec![],
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: vec![],
+        affected_rows: total_affected,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+async fn exec_tx_none_inner(
+    state: &AppState,
+    pool_key: &str,
+    mysql_dialect: db::mysql::MySqlQueryDialect,
+    database: Option<&str>,
+    statements: &[String],
+    schema: Option<&str>,
+    start: std::time::Instant,
+) -> Result<db::QueryResult, String> {
+    let mut total_affected: u64 = 0;
+    for (i, sql) in statements.iter().enumerate() {
+        log::info!("[query][tx-none:statement:start] index={} sql={}", i + 1, sql);
+        match do_execute(state, pool_key, mysql_dialect, database, sql, schema, None, QueryExecutionOptions::default())
+            .await
+        {
+            Ok(result) => {
+                total_affected += result.affected_rows;
+                log::info!("[query][tx-none:statement:done] index={} affected_rows={}", i + 1, result.affected_rows);
+            }
+            Err(e) => {
+                log::warn!("Statement {} failed (no transaction support): {}", i + 1, e);
+                return Err(format!(
+                    "Statement {} failed: {}. No transaction support for this database type.",
+                    i + 1,
+                    e
+                ));
+            }
+        }
+    }
+
+    Ok(db::QueryResult {
+        columns: vec![],
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: vec![],
+        affected_rows: total_affected,
+        execution_time_ms: start.elapsed().as_millis(),
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+/// Start a manual transaction session, holding a connection from the pool.
+/// Returns a transaction session ID that must be passed to subsequent calls.
+pub async fn begin_manual_transaction(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: Option<&str>,
+) -> Result<String, String> {
+    let pool_key = if database.is_empty() {
+        connection_id.to_string()
+    } else {
+        state.get_or_create_pool(connection_id, Some(database)).await?
+    };
+
+    // Clone the pool handle under a brief read lock, then drop the lock before
+    // any async I/O — same pattern as do_execute throughout this file.
+    enum TxnPoolHandle {
+        Postgres(deadpool_postgres::Pool),
+        Mysql(db::mysql::MySqlPool),
+    }
+    let pool_handle = {
+        let connections = state.connections.read().await;
+        match connections.get(&pool_key).ok_or("Connection not found")? {
+            PoolKind::Postgres(pg) => TxnPoolHandle::Postgres(pg.clone()),
+            PoolKind::Mysql(mp, _) => TxnPoolHandle::Mysql(mp.clone()),
+            _ => return Err("Manual transaction is not supported for this database type".to_string()),
+        }
+    }; // connections lock released here
+
+    let txn_conn = match pool_handle {
+        TxnPoolHandle::Postgres(pg_pool) => {
+            let conn = pg_pool.get().await.map_err(|e| format!("Failed to get Postgres connection: {e}"))?;
+            conn.execute("BEGIN", &[]).await.map_err(|e| format!("BEGIN failed: {e}"))?;
+            if let Some(schema) = schema {
+                conn.execute(&format!("SET LOCAL search_path TO {}", db::postgres::pg_quote_ident(schema)), &[])
+                    .await
+                    .map_err(|e| format!("SET search_path failed: {e}"))?;
+            }
+            TxnConnection::Postgres(Box::new(conn))
+        }
+        TxnPoolHandle::Mysql(mysql_pool) => {
+            let mut conn = mysql_pool.get_conn().await.map_err(|e| format!("Failed to get MySQL connection: {e}"))?;
+            conn.query_drop("START TRANSACTION").await.map_err(|e| format!("START TRANSACTION failed: {e}"))?;
+            TxnConnection::Mysql(conn)
+        }
+    };
+
+    let txn_session_id = uuid::Uuid::new_v4().to_string();
+    let session = TransactionSession {
+        connection: Arc::new(tokio::sync::Mutex::new(txn_conn)),
+        pool_key: pool_key.clone(),
+        last_activity: std::time::Instant::now(),
+        busy: false,
+        connection_id: connection_id.to_string(),
+        database: database.to_string(),
+        schema: schema.map(|s| s.to_string()),
+    };
+
+    {
+        let mut sessions = state.transaction_sessions.write().await;
+        sessions.insert(txn_session_id.clone(), session);
+    }
+
+    // Schedule idle timeout watcher
+    spawn_txn_idle_watcher(state, txn_session_id.clone());
+
+    log::info!("[query][manual_txn:begin] session_id={}", txn_session_id);
+    Ok(txn_session_id)
+}
+
+/// Execute SQL within an existing manual transaction session.
+pub async fn execute_in_manual_transaction(
+    state: &AppState,
+    txn_session_id: &str,
+    sql: &str,
+    _database: &str,
+    _schema: Option<&str>,
+    max_rows: Option<usize>,
+) -> Result<Vec<db::QueryResult>, String> {
+    const TXN_IDLE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(300);
+
+    // Resolve statements and validate before taking the per-session connection
+    // lock. The session stays visible in the map so close/disconnect cleanup can
+    // remove it and roll back once the current DB operation releases the lock.
+    let (pool_key, connection_id) = {
+        let sessions = state.transaction_sessions.read().await;
+        let session = sessions
+            .get(txn_session_id)
+            .ok_or("Transaction session not found or expired; it may have been auto-rolled back due to inactivity")?;
+        (session.pool_key.clone(), session.connection_id.clone())
+    };
+
+    let db_type = connection_database_type(state, &connection_id).await;
+    let statements = db_type.map_or_else(
+        || split_sql_statements(sql),
+        |db_type| crate::sql::split_sql_statements_for_database(sql, db_type),
+    );
+    if statements.is_empty() {
+        return Ok(vec![empty_query_result(0)]);
+    }
+
+    // Read-only check while the session is still in the map. If this fails the
+    // session remains intact.
+    check_read_only_for_connection_multi(state, &pool_key, &statements).await?;
+
+    let connection = {
+        let mut sessions = state.transaction_sessions.write().await;
+        let Some(session) = sessions.get_mut(txn_session_id) else {
+            return Err(
+                "Transaction session not found or expired; it may have been auto-rolled back due to inactivity"
+                    .to_string(),
+            );
+        };
+        if session.busy {
+            return Err("Transaction session is already executing".to_string());
+        }
+        if session.last_activity.elapsed() > TXN_IDLE_TIMEOUT {
+            let session = sessions.remove(txn_session_id).expect("session exists");
+            Some(session.connection)
+        } else {
+            session.busy = true;
+            session.last_activity = std::time::Instant::now();
+            None
+        }
+    };
+    if let Some(connection) = connection {
+        let mut conn = connection.lock().await;
+        let _ = rollback_manual_txn_connection(&mut conn).await;
+        return Err("Transaction was auto-rolled back due to 5 minutes of inactivity".to_string());
+    }
+
+    let connection = {
+        let sessions = state.transaction_sessions.read().await;
+        sessions
+            .get(txn_session_id)
+            .map(|session| Arc::clone(&session.connection))
+            .ok_or("Transaction session not found or expired; it may have been auto-rolled back due to inactivity")?
+    };
+    let row_limit = max_rows.unwrap_or(MAX_ROWS).max(1);
+    let mut results = Vec::with_capacity(statements.len());
+
+    let mut conn = connection.lock().await;
+    for (i, statement) in statements.iter().enumerate() {
+        let result = match &mut *conn {
+            TxnConnection::Postgres(conn) => {
+                execute_manual_txn_postgres_statement(conn.as_ref(), statement, row_limit).await
+            }
+            TxnConnection::Mysql(conn) => execute_manual_txn_mysql_statement(conn, statement, row_limit).await,
+        };
+        match result {
+            Ok(query_result) => results.push(query_result),
+            Err(e) => {
+                // Statement failure ends the transaction. If another cleanup path
+                // already removed the session, it owns the final rollback.
+                let should_rollback = {
+                    let mut sessions = state.transaction_sessions.write().await;
+                    sessions.remove(txn_session_id).is_some()
+                };
+                if should_rollback {
+                    let _ = rollback_manual_txn_connection(&mut conn).await;
+                }
+                return Err(format!("Statement {} failed: {}. Transaction was auto-rolled back.", i + 1, e));
+            }
+        }
+    }
+    drop(conn);
+
+    let should_watch = {
+        let mut sessions = state.transaction_sessions.write().await;
+        if let Some(session) = sessions.get_mut(txn_session_id) {
+            session.busy = false;
+            session.last_activity = std::time::Instant::now();
+            true
+        } else {
+            false
+        }
+    };
+    if should_watch {
+        spawn_txn_idle_watcher(state, txn_session_id.to_string());
+    }
+
+    Ok(results)
+}
+
+async fn rollback_manual_txn_connection(conn: &mut TxnConnection) -> Result<(), String> {
+    match conn {
+        TxnConnection::Postgres(conn) => {
+            conn.execute("ROLLBACK", &[]).await.map_err(|e| format!("ROLLBACK failed: {e}"))?;
+        }
+        TxnConnection::Mysql(conn) => {
+            conn.query_drop("ROLLBACK").await.map_err(|e| format!("ROLLBACK failed: {e}"))?;
+        }
+    }
+    Ok(())
+}
+
+/// Spawn a background task that removes and rolls back a transaction session
+/// after 5 minutes of inactivity. The task does not hold the global lock across
+/// I/O: it briefly checks the map, and if the session exists and is expired,
+/// removes it, drops the lock, then rolls back the held connection.
+///
+/// Safety: if multiple watchers exist for the same session ID (e.g. due to
+/// a race), only the one that actually finds the session in the map and
+/// observes an elapsed time >= timeout will remove and roll back. Others
+/// will see a missing session or a non-expired one and exit harmlessly.
+fn spawn_txn_idle_watcher(state: &AppState, txn_session_id: String) {
+    let sessions = Arc::clone(&state.transaction_sessions);
+    tokio::spawn(async move {
+        const TXN_IDLE_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(300);
+        tokio::time::sleep(TXN_IDLE_TIMEOUT).await;
+
+        let removed: Option<TransactionSession> = {
+            let mut guard = sessions.write().await;
+            match guard.get(&txn_session_id) {
+                Some(session) if !session.busy && session.last_activity.elapsed() >= TXN_IDLE_TIMEOUT => {
+                    guard.remove(&txn_session_id)
+                }
+                _ => None,
+            }
+        };
+
+        if let Some(session) = removed {
+            let mut conn = session.connection.lock().await;
+            let _ = rollback_manual_txn_connection(&mut conn).await;
+            log::info!(
+                "[query][manual_txn:idle_timeout] session_id={} auto-rolled back after 5 minutes of inactivity",
+                txn_session_id
+            );
+        }
+    });
+}
+
+async fn execute_manual_txn_postgres_statement(
+    conn: &deadpool_postgres::Object,
+    sql: &str,
+    row_limit: usize,
+) -> Result<db::QueryResult, String> {
+    if starts_with_executable_sql_keyword(sql, &["SELECT", "SHOW", "EXPLAIN", "WITH", "TABLE"]) {
+        let start = std::time::Instant::now();
+        let stmt = conn.prepare_cached(sql).await.map_err(|e| format!("Prepare failed: {e}"))?;
+        let columns: Vec<String> = stmt.columns().iter().map(|c| c.name().to_string()).collect();
+        let column_types: Vec<String> = stmt.columns().iter().map(|c| c.type_().name().to_string()).collect();
+        let params: Vec<&(dyn tokio_postgres::types::ToSql + Sync)> = Vec::new();
+        let stream = conn.query_raw(&stmt, params).await.map_err(|e| format!("Query failed: {e}"))?;
+        tokio::pin!(stream);
+        let mut data: Vec<Vec<serde_json::Value>> = Vec::with_capacity(row_limit.min(1024));
+        let mut truncated = false;
+        while let Some(row_result) = stream.next().await {
+            if data.len() >= row_limit {
+                truncated = true;
+                break;
+            }
+            let row = row_result.map_err(|e| format!("Query failed: {e}"))?;
+            let values: Vec<serde_json::Value> = (0..row.columns().len())
+                .map(|i| db::postgres::pg_value_to_json(&row, i, column_types.get(i).map(String::as_str).unwrap_or("")))
+                .collect();
+            data.push(values);
+        }
+        Ok(db::QueryResult {
+            columns,
+            column_types,
+            column_sortables: vec![],
+            rows: data,
+            affected_rows: 0,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated,
+            session_id: None,
+            has_more: false,
+        })
+    } else {
+        let affected = conn.execute(sql, &[]).await.map_err(|e| format!("Query failed: {e}"))?;
+        Ok(db::QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows: affected,
+            execution_time_ms: 0,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    }
+}
+
+async fn execute_manual_txn_mysql_statement(
+    conn: &mut mysql_async::Conn,
+    sql: &str,
+    row_limit: usize,
+) -> Result<db::QueryResult, String> {
+    if starts_with_executable_sql_keyword(sql, &["SELECT", "SHOW", "DESCRIBE", "EXPLAIN", "WITH"]) {
+        let start = std::time::Instant::now();
+        let mut result = conn.query_iter(sql).await.map_err(|e| format!("Query failed: {e}"))?;
+        let columns: Vec<String> = result.columns_ref().iter().map(|c| c.name_str().to_string()).collect();
+        let column_types: Vec<String> =
+            result.columns_ref().iter().map(|c| db::mysql::mysql_column_type_name(c.column_type())).collect();
+        let mut data: Vec<Vec<serde_json::Value>> = Vec::with_capacity(row_limit.min(1024));
+        let mut stream = result
+            .stream::<mysql_async::Row>()
+            .await
+            .map_err(|e| format!("Query failed: {e}"))?
+            .ok_or_else(|| "Empty result set stream".to_string())?;
+        let mut truncated = false;
+        while let Some(row) = stream.next().await {
+            if data.len() >= row_limit {
+                truncated = true;
+                break;
+            }
+            let row = row.map_err(|e| format!("Query failed: {e}"))?;
+            data.push((0..row.len()).map(|i| db::mysql::mysql_value_to_json(&row, i)).collect());
+        }
+        Ok(db::QueryResult {
+            columns,
+            column_types,
+            column_sortables: vec![],
+            rows: data,
+            affected_rows: 0,
+            execution_time_ms: start.elapsed().as_millis(),
+            truncated,
+            session_id: None,
+            has_more: false,
+        })
+    } else {
+        let result = conn.query_iter(sql).await.map_err(|e| format!("Query failed: {e}"))?;
+        let affected_rows = result.affected_rows();
+        result.drop_result().await.map_err(|e| format!("Query failed: {e}"))?;
+        Ok(db::QueryResult {
+            columns: vec![],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![],
+            affected_rows,
+            execution_time_ms: 0,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        })
+    }
+}
+
+/// Commit an existing manual transaction session.
+pub async fn commit_manual_transaction(state: &AppState, txn_session_id: &str) -> Result<db::QueryResult, String> {
+    let session = {
+        let mut sessions = state.transaction_sessions.write().await;
+        sessions.remove(txn_session_id).ok_or("Transaction session not found")?
+    };
+
+    let mut conn = session.connection.lock().await;
+    match &mut *conn {
+        TxnConnection::Postgres(conn) => {
+            conn.execute("COMMIT", &[]).await.map_err(|e| format!("COMMIT failed: {e}"))?;
+        }
+        TxnConnection::Mysql(conn) => {
+            conn.query_drop("COMMIT").await.map_err(|e| format!("COMMIT failed: {e}"))?;
+        }
+    }
+
+    log::info!("[query][manual_txn:commit] session_id={}", txn_session_id);
+    Ok(db::QueryResult {
+        columns: vec![],
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: vec![],
+        affected_rows: 0,
+        execution_time_ms: 0,
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+/// Rollback an existing manual transaction session.
+pub async fn rollback_manual_transaction(state: &AppState, txn_session_id: &str) -> Result<db::QueryResult, String> {
+    let session = {
+        let mut sessions = state.transaction_sessions.write().await;
+        sessions.remove(txn_session_id).ok_or("Transaction session not found")?
+    };
+
+    let mut conn = session.connection.lock().await;
+    rollback_manual_txn_connection(&mut conn).await?;
+
+    log::info!("[query][manual_txn:rollback] session_id={}", txn_session_id);
+    Ok(db::QueryResult {
+        columns: vec![],
+        column_types: Vec::new(),
+        column_sortables: vec![],
+        rows: vec![],
+        affected_rows: 0,
+        execution_time_ms: 0,
+        truncated: false,
+        session_id: None,
+        has_more: false,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::models::connection::{default_redis_key_separator, ConnectionConfig, DatabaseType};
+    #[cfg(unix)]
+    use crate::plugins::{
+        InstalledPlugin, PluginDriverManifest, PluginDriverSession, PluginManifest, PluginRuntimeEnv,
+    };
+    #[cfg(feature = "duckdb-bundled")]
+    use crate::storage::Storage;
+
+    fn test_connection_config(db_type: DatabaseType) -> ConnectionConfig {
+        ConnectionConfig {
+            id: "conn-1".to_string(),
+            name: "Connection".to_string(),
+            db_type,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "localhost".to_string(),
+            port: 0,
+            username: String::new(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 10,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: 30,
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    struct FakeMysqlBatchExecutor {
+        outcomes: std::collections::VecDeque<Result<db::QueryResult, String>>,
+        executed: Vec<String>,
+    }
+
+    impl MysqlBatchStatementExecutor for FakeMysqlBatchExecutor {
+        async fn execute_statement(&mut self, statement: &str) -> Result<db::QueryResult, String> {
+            self.executed.push(statement.to_string());
+            self.outcomes.pop_front().expect("test outcome for statement")
+        }
+    }
+
+    #[test]
+    fn agent_execute_batch_unsupported_detects_case_insensitive_method_errors() {
+        assert!(is_agent_execute_batch_unsupported("Agent RPC error (-1): unknown method: execute_batch"));
+        assert!(is_agent_execute_batch_unsupported("Agent RPC error (-1): Unknown method: execute_batch"));
+        assert!(is_agent_execute_batch_unsupported("Agent RPC error (-32601): Method not found: execute_batch"));
+    }
+
+    #[test]
+    fn agent_execute_batch_unsupported_ignores_unrelated_errors() {
+        assert!(!is_agent_execute_batch_unsupported("ORA-00955: name is already used by an existing object"));
+        assert!(!is_agent_execute_batch_unsupported("Agent RPC error (-1): unknown method: execute_query"));
+    }
+
+    #[test]
+    fn query_pool_error_policy_retries_reads_but_not_writes() {
+        assert_eq!(
+            query_pool_error_action(Some(DatabaseType::Postgres), "SELECT * FROM users", "connection reset by peer"),
+            PoolErrorAction::ReconnectAndRetry
+        );
+        assert_eq!(
+            query_pool_error_action(
+                Some(DatabaseType::Postgres),
+                "UPDATE users SET active = true",
+                "connection reset by peer"
+            ),
+            PoolErrorAction::Discard
+        );
+    }
+
+    #[tokio::test]
+    async fn mysql_batch_stops_after_the_first_statement_error() {
+        let statements = vec!["first".to_string(), "fails".to_string(), "must-not-run".to_string()];
+        let mut executor = FakeMysqlBatchExecutor {
+            outcomes: std::collections::VecDeque::from([
+                Ok(empty_query_result(0)),
+                Err("Duplicate entry".to_string()),
+                Ok(empty_query_result(0)),
+            ]),
+            executed: Vec::new(),
+        };
+
+        let (results, error_action) =
+            execute_mysql_batch_statements(&mut executor, &statements, Some(DatabaseType::Mysql), None).await;
+
+        assert_eq!(executor.executed, vec!["first", "fails"]);
+        assert_eq!(results.len(), 2);
+        assert!(results[1].execution_error);
+        assert_eq!(error_action, Some(PoolErrorAction::Keep));
+    }
+
+    #[test]
+    fn execute_multi_result_serializes_error_marker_only_for_synthesized_errors() {
+        let success = serde_json::to_value(ExecuteMultiResult::from(empty_query_result(0))).unwrap();
+        assert!(success.get("execution_error").is_none());
+
+        let failure =
+            serde_json::to_value(ExecuteMultiResult::execution_error(error_query_result("failed".to_string())))
+                .unwrap();
+        assert_eq!(failure.get("execution_error"), Some(&serde_json::Value::Bool(true)));
+        assert_eq!(failure.get("columns"), Some(&serde_json::json!(["Error"])));
+    }
+
+    #[test]
+    fn external_driver_method_unsupported_detects_legacy_plugin_errors() {
+        assert!(is_external_driver_method_unsupported(
+            "Unsupported JDBC plugin method: executeQueryPage",
+            "executeQueryPage"
+        ));
+        assert!(is_external_driver_method_unsupported(
+            "Plugin RPC error (-32601): Method not found: executeQueryPage",
+            "executeQueryPage"
+        ));
+        assert!(is_external_driver_method_unsupported("Unknown method executeQueryPage", "executeQueryPage"));
+    }
+
+    #[test]
+    fn external_driver_method_unsupported_ignores_query_and_other_method_errors() {
+        assert!(!is_external_driver_method_unsupported(
+            "The JDBC driver does not support this SQL operation",
+            "executeQueryPage"
+        ));
+        assert!(!is_external_driver_method_unsupported(
+            "Unsupported JDBC plugin method: listTables",
+            "executeQueryPage"
+        ));
+        assert!(!is_external_driver_method_unsupported(
+            "Unknown column executeQueryPage in field list",
+            "executeQueryPage"
+        ));
+    }
+
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn external_driver_query_page_falls_back_to_legacy_execute_query() {
+        use std::os::unix::fs::PermissionsExt;
+
+        let dir = std::env::temp_dir().join(format!("dbx-legacy-jdbc-plugin-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let executable = dir.join("plugin.sh");
+        let calls = dir.join("calls.log");
+        std::fs::write(
+            &executable,
+            format!(
+                "#!/bin/sh\nwhile IFS= read -r line; do\n  id=$(printf '%s' \"$line\" | sed -E 's/.*\"id\":([0-9]+).*/\\1/')\n  case \"$line\" in\n    *'\"method\":\"executeQueryPage\"'*)\n      echo executeQueryPage >> '{}'\n      printf '{{\"id\":%s,\"error\":{{\"message\":\"Unsupported JDBC plugin method: executeQueryPage\"}}}}\\n' \"$id\"\n      ;;\n    *'\"method\":\"executeQuery\"'*)\n      echo executeQuery >> '{}'\n      printf '{{\"id\":%s,\"result\":{{\"columns\":[\"value\"],\"rows\":[[42]],\"affected_rows\":0,\"execution_time_ms\":1,\"truncated\":false}}}}\\n' \"$id\"\n      ;;\n  esac\ndone\n",
+                calls.display(),
+                calls.display()
+            ),
+        )
+        .unwrap();
+        let mut permissions = std::fs::metadata(&executable).unwrap().permissions();
+        permissions.set_mode(0o755);
+        std::fs::set_permissions(&executable, permissions).unwrap();
+
+        let plugin = InstalledPlugin {
+            manifest: PluginManifest {
+                id: "jdbc".to_string(),
+                name: "JDBC".to_string(),
+                version: "legacy".to_string(),
+                protocol_version: 1,
+                description: String::new(),
+                executable: Some("plugin.sh".to_string()),
+                drivers: vec![PluginDriverManifest {
+                    id: "jdbc".to_string(),
+                    label: "JDBC".to_string(),
+                    kind: "external".to_string(),
+                    database_type: Some("jdbc".to_string()),
+                }],
+            },
+            path: dir.clone(),
+        };
+        let session = PluginDriverSession::start_for_test(plugin, "jdbc".to_string(), PluginRuntimeEnv::default())
+            .await
+            .expect("legacy plugin should start");
+
+        let result = invoke_external_driver_query_page(
+            &session,
+            serde_json::json!({ "sql": "SELECT 42", "pageSize": 100 }),
+            Some(Duration::from_secs(5)),
+        )
+        .await
+        .expect("legacy executeQuery fallback should succeed");
+
+        assert_eq!(result.columns, vec!["value"]);
+        assert_eq!(result.rows, vec![vec![serde_json::json!(42)]]);
+        assert_eq!(std::fs::read_to_string(&calls).unwrap(), "executeQueryPage\nexecuteQuery\n");
+
+        session.shutdown().await;
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn external_driver_query_page_does_not_retry_jdbc_errors() {
+        use std::os::unix::fs::PermissionsExt;
+
+        let dir = std::env::temp_dir().join(format!("dbx-jdbc-query-error-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let executable = dir.join("plugin.sh");
+        let calls = dir.join("calls.log");
+        std::fs::write(
+            &executable,
+            format!(
+                "#!/bin/sh\nwhile IFS= read -r line; do\n  id=$(printf '%s' \"$line\" | sed -E 's/.*\"id\":([0-9]+).*/\\1/')\n  echo request >> '{}'\n  printf '{{\"id\":%s,\"error\":{{\"message\":\"Incorrect syntax near SELECT\"}}}}\\n' \"$id\"\ndone\n",
+                calls.display()
+            ),
+        )
+        .unwrap();
+        let mut permissions = std::fs::metadata(&executable).unwrap().permissions();
+        permissions.set_mode(0o755);
+        std::fs::set_permissions(&executable, permissions).unwrap();
+
+        let plugin = InstalledPlugin {
+            manifest: PluginManifest {
+                id: "jdbc".to_string(),
+                name: "JDBC".to_string(),
+                version: "current".to_string(),
+                protocol_version: 1,
+                description: String::new(),
+                executable: Some("plugin.sh".to_string()),
+                drivers: vec![PluginDriverManifest {
+                    id: "jdbc".to_string(),
+                    label: "JDBC".to_string(),
+                    kind: "external".to_string(),
+                    database_type: Some("jdbc".to_string()),
+                }],
+            },
+            path: dir.clone(),
+        };
+        let session = PluginDriverSession::start_for_test(plugin, "jdbc".to_string(), PluginRuntimeEnv::default())
+            .await
+            .expect("plugin should start");
+
+        let error = invoke_external_driver_query_page(
+            &session,
+            serde_json::json!({ "sql": "SELECT broken", "pageSize": 100 }),
+            Some(Duration::from_secs(5)),
+        )
+        .await
+        .expect_err("JDBC query errors must be returned without retrying");
+
+        assert_eq!(error, "Incorrect syntax near SELECT");
+        assert_eq!(std::fs::read_to_string(&calls).unwrap(), "request\n");
+
+        session.shutdown().await;
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[test]
+    fn oceanbase_mysql_session_timeout_sql_uses_connection_timeout_by_default() {
+        let mut config = test_connection_config(DatabaseType::Mysql);
+        config.driver_profile = Some("oceanbase".to_string());
+        config.query_timeout_secs = 300_000;
+
+        assert_eq!(
+            oceanbase_mysql_session_timeout_sql(Some(&config), None),
+            Some("SET ob_query_timeout = 300000000000".to_string())
+        );
+    }
+
+    #[test]
+    fn oceanbase_mysql_session_timeout_sql_prefers_execution_timeout_override() {
+        let mut config = test_connection_config(DatabaseType::Mysql);
+        config.driver_profile = Some("oceanbase".to_string());
+        config.query_timeout_secs = 30;
+
+        assert_eq!(
+            oceanbase_mysql_session_timeout_sql(Some(&config), Some(600)),
+            Some("SET ob_query_timeout = 600000000".to_string())
+        );
+    }
+
+    #[test]
+    fn oceanbase_mysql_session_timeout_sql_skips_plain_mysql() {
+        let config = test_connection_config(DatabaseType::Mysql);
+
+        assert_eq!(oceanbase_mysql_session_timeout_sql(Some(&config), Some(600)), None);
+    }
+
+    #[tokio::test]
+    async fn wait_for_query_returns_cancelled_when_token_is_cancelled() {
+        let token = CancellationToken::new();
+        token.cancel();
+
+        let result = wait_for_query(Some(token), async {
+            tokio::time::sleep(Duration::from_secs(30)).await;
+            Ok(db::QueryResult {
+                columns: vec![],
+                column_types: Vec::new(),
+                column_sortables: vec![],
+                rows: vec![],
+                affected_rows: 0,
+                execution_time_ms: 0,
+                truncated: false,
+                session_id: None,
+                has_more: false,
+            })
+        })
+        .await;
+
+        assert_eq!(result.unwrap_err(), QUERY_CANCELED);
+    }
+
+    #[tokio::test]
+    async fn wait_for_query_without_token_still_times_out() {
+        let result = wait_for_query_with_timeout(None, Duration::from_millis(10), async {
+            tokio::time::sleep(Duration::from_secs(1)).await;
+            Ok(db::QueryResult {
+                columns: vec![],
+                column_types: Vec::new(),
+                column_sortables: vec![],
+                rows: vec![],
+                affected_rows: 0,
+                execution_time_ms: 0,
+                truncated: false,
+                session_id: None,
+                has_more: false,
+            })
+        })
+        .await;
+
+        assert_eq!(result.unwrap_err(), timeout_error_for(Duration::from_millis(10)));
+    }
+
+    #[tokio::test]
+    async fn wait_for_value_opt_times_out_while_waiting_for_lock() {
+        let lock = tokio::sync::Mutex::new(());
+        let _guard = lock.lock().await;
+
+        let result = wait_for_value_opt(None, Some(Duration::from_millis(10)), lock.lock()).await;
+
+        assert_eq!(result.unwrap_err(), timeout_error_for(Duration::from_millis(10)));
+    }
+
+    #[tokio::test]
+    async fn wait_for_value_opt_can_cancel_while_waiting_for_lock() {
+        let lock = tokio::sync::Mutex::new(());
+        let _guard = lock.lock().await;
+        let token = CancellationToken::new();
+        token.cancel();
+
+        let result = wait_for_value_opt(Some(token), Some(Duration::from_secs(30)), lock.lock()).await;
+
+        assert_eq!(result.unwrap_err(), QUERY_CANCELED);
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn duckdb_timeout_interrupts_running_task_without_waiting_for_it_to_finish() {
+        let con = std::sync::Arc::new(crate::db::duckdb_driver::DuckDbConnection::new(
+            duckdb::Connection::open_in_memory().unwrap(),
+        ));
+        let interrupt_handle = con.interrupt_handle();
+        let running_con = con.clone();
+        let task = tokio::task::spawn_blocking(move || {
+            let con = running_con.lock().map_err(|e| e.to_string())?;
+            duckdb_execute_with_max_rows(&con, "SELECT sum(sin(i::DOUBLE)) FROM range(10000000000) tbl(i)", None)
+        });
+
+        let started = std::time::Instant::now();
+        let result =
+            wait_for_duckdb_task_with_interrupt(None, Some(Duration::from_millis(10)), interrupt_handle, task).await;
+
+        assert_eq!(result.unwrap_err(), timeout_error());
+        assert!(started.elapsed() < Duration::from_secs(5));
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn duckdb_cancel_keeps_pool_draining_until_references_drop() {
+        let dir = std::env::temp_dir().join(format!("dbx-query-duckdb-cancel-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new(storage);
+        let pool_key = "duckdb-1";
+        let con = std::sync::Arc::new(crate::db::duckdb_driver::DuckDbConnection::new(
+            duckdb::Connection::open_in_memory().unwrap(),
+        ));
+        let extra_reference = con.clone();
+        state.connections.write().await.insert(pool_key.to_string(), PoolKind::DuckDb(con));
+        state.configs.write().await.insert(pool_key.to_string(), test_connection_config(DatabaseType::DuckDb));
+
+        let token = CancellationToken::new();
+        let cancel_token = token.clone();
+        tokio::spawn(async move {
+            tokio::time::sleep(Duration::from_millis(10)).await;
+            cancel_token.cancel();
+        });
+
+        let result = do_execute(
+            &state,
+            pool_key,
+            db::mysql::MySqlQueryDialect::default(),
+            Some("main"),
+            "SELECT sum(sin(i::DOUBLE)) FROM range(10000000000) tbl(i)",
+            None,
+            Some(token),
+            QueryExecutionOptions::default(),
+        )
+        .await;
+
+        assert_eq!(result.unwrap_err(), QUERY_CANCELED);
+        let still_present = {
+            let conns = state.connections.read().await;
+            matches!(conns.get(pool_key), Some(PoolKind::DuckDb(current)) if current.is_draining())
+        };
+        assert!(still_present);
+
+        drop(extra_reference);
+        timeout(Duration::from_secs(5), async {
+            loop {
+                if !state.connections.read().await.contains_key(pool_key) {
+                    break;
+                }
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+        })
+        .await
+        .expect("draining DuckDB pool should be removed after references drop");
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn duckdb_draining_pool_rejects_follow_up_query() {
+        let dir = std::env::temp_dir().join(format!("dbx-query-duckdb-draining-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new(storage);
+        let pool_key = "duckdb-1";
+        let con = std::sync::Arc::new(crate::db::duckdb_driver::DuckDbConnection::new(
+            duckdb::Connection::open_in_memory().unwrap(),
+        ));
+        con.mark_draining();
+        state.connections.write().await.insert(pool_key.to_string(), PoolKind::DuckDb(con));
+        state.configs.write().await.insert(pool_key.to_string(), test_connection_config(DatabaseType::DuckDb));
+
+        let result = do_execute(
+            &state,
+            pool_key,
+            db::mysql::MySqlQueryDialect::default(),
+            Some("main"),
+            "SELECT 1",
+            None,
+            None,
+            QueryExecutionOptions::default(),
+        )
+        .await;
+
+        assert_eq!(result.unwrap_err(), duckdb_draining_error());
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn duckdb_draining_cleanup_removes_pool_after_task_finishes() {
+        let dir = std::env::temp_dir().join(format!("dbx-query-duckdb-cleanup-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new(storage);
+        let pool_key = "duckdb-1";
+        let con = std::sync::Arc::new(crate::db::duckdb_driver::DuckDbConnection::new(
+            duckdb::Connection::open_in_memory().unwrap(),
+        ));
+        con.mark_draining();
+        state.connections.write().await.insert(pool_key.to_string(), PoolKind::DuckDb(con.clone()));
+
+        let task_con = con.clone();
+        let task = tokio::task::spawn_blocking(move || {
+            let _locked = task_con.lock().map_err(|e| e.to_string())?;
+            std::thread::sleep(Duration::from_millis(100));
+            Ok(empty_query_result(0))
+        });
+        state.spawn_duckdb_draining_cleanup(pool_key.to_string(), con.clone(), task);
+
+        assert!(state.connections.read().await.contains_key(pool_key));
+        drop(con);
+        timeout(Duration::from_secs(5), async {
+            loop {
+                if !state.connections.read().await.contains_key(pool_key) {
+                    break;
+                }
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+        })
+        .await
+        .expect("draining cleanup should remove the DuckDB pool");
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+    async fn duckdb_cleanup_keeps_draining_pool_while_extra_reference_exists() {
+        let dir = std::env::temp_dir().join(format!("dbx-query-duckdb-cleanup-ref-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new(storage);
+        let pool_key = "duckdb-1";
+        let con = std::sync::Arc::new(crate::db::duckdb_driver::DuckDbConnection::new(
+            duckdb::Connection::open_in_memory().unwrap(),
+        ));
+        con.mark_draining();
+        state.connections.write().await.insert(pool_key.to_string(), PoolKind::DuckDb(con.clone()));
+
+        let extra_reference = con.clone();
+        let task = tokio::task::spawn_blocking(|| Ok(empty_query_result(0)));
+        state.spawn_duckdb_draining_cleanup(pool_key.to_string(), con.clone(), task);
+        tokio::time::sleep(Duration::from_millis(100)).await;
+
+        let still_present = {
+            let conns = state.connections.read().await;
+            matches!(conns.get(pool_key), Some(PoolKind::DuckDb(current)) if current.is_draining())
+        };
+        assert!(still_present);
+
+        drop(extra_reference);
+        drop(con);
+        timeout(Duration::from_secs(5), async {
+            loop {
+                if !state.connections.read().await.contains_key(pool_key) {
+                    break;
+                }
+                tokio::time::sleep(Duration::from_millis(10)).await;
+            }
+        })
+        .await
+        .expect("draining cleanup should remove the DuckDB pool after extra refs drop");
+    }
+
+    #[test]
+    fn db_operation_budget_from_config() {
+        let budget = DbOperationBudget::from_config(10, Some(30));
+        assert_eq!(budget.checkout_timeout, Duration::from_secs(10));
+        assert_eq!(budget.connect_timeout, Duration::from_secs(10));
+        assert_eq!(budget.recycle_timeout, Duration::from_secs(10));
+        assert_eq!(budget.query_timeout, Some(Duration::from_secs(30)));
+        assert_eq!(budget.cancel_timeout, Duration::from_secs(5));
+        assert_eq!(budget.cleanup_timeout, Duration::from_secs(3));
+    }
+
+    #[test]
+    fn db_operation_budget_from_connection_config_uses_connection_settings() {
+        let mut config = test_connection_config(DatabaseType::Postgres);
+        config.connect_timeout_secs = 12;
+        config.query_timeout_secs = 0;
+
+        let budget = DbOperationBudget::from_connection_config(&config);
+
+        assert_eq!(budget.checkout_timeout, Duration::from_secs(12));
+        assert_eq!(budget.connect_timeout, Duration::from_secs(12));
+        assert_eq!(budget.recycle_timeout, Duration::from_secs(12));
+        assert_eq!(budget.query_timeout, None);
+        assert_eq!(budget.cancel_timeout, Duration::from_secs(5));
+        assert_eq!(budget.cleanup_timeout, Duration::from_secs(3));
+    }
+
+    #[test]
+    fn db_operation_budget_query_timeout_zero_means_no_limit() {
+        let budget = DbOperationBudget::from_config(10, Some(0));
+        assert_eq!(budget.query_timeout, None);
+        // Infrastructure timeouts still have hard limits
+        assert_eq!(budget.checkout_timeout, Duration::from_secs(10));
+        assert_eq!(budget.cancel_timeout, Duration::from_secs(5));
+    }
+
+    #[test]
+    fn db_operation_budget_query_timeout_zero_keeps_transaction_infra_limits() {
+        let mut config = test_connection_config(DatabaseType::Mysql);
+        config.connect_timeout_secs = 7;
+        config.query_timeout_secs = 0;
+
+        let budget = DbOperationBudget::from_connection_config(&config);
+
+        assert_eq!(budget.query_timeout, None);
+        assert_eq!(budget.checkout_timeout, Duration::from_secs(7));
+        assert_eq!(budget.recycle_timeout, Duration::from_secs(7));
+        assert_eq!(budget.cleanup_timeout, Duration::from_secs(3));
+    }
+
+    #[test]
+    fn db_operation_budget_clamps_infra_timeout() {
+        let budget = DbOperationBudget::from_config(0, Some(30));
+        assert_eq!(budget.checkout_timeout, Duration::from_secs(1)); // clamped to min 1s
+        let budget = DbOperationBudget::from_config(600, Some(30));
+        assert_eq!(budget.checkout_timeout, Duration::from_secs(300)); // clamped to max 300s
+    }
+
+    #[test]
+    fn db_operation_budget_with_defaults() {
+        let budget = DbOperationBudget::with_defaults();
+        assert_eq!(budget.checkout_timeout, db::connection_timeout());
+        assert_eq!(budget.query_timeout, Some(QUERY_TIMEOUT));
+    }
+
+    #[test]
+    fn is_connection_error_detects_english_messages() {
+        assert!(is_connection_error("connection reset"));
+        assert!(is_connection_error("broken pipe"));
+        assert!(is_connection_error("reset by peer"));
+        assert!(is_connection_error("Connection timed out"));
+        assert!(is_connection_error("socket closed"));
+        assert!(is_connection_error("unexpected eof"));
+        assert!(is_connection_error("Error occurred while creating a new object: error communicating with the server"));
+    }
+
+    #[test]
+    fn is_connection_error_detects_oracle_idle_timeout() {
+        assert!(is_connection_error("ORA-02396: exceeded maximum idle time, please connect again"));
+        assert!(is_connection_error(
+            "Agent RPC error (-32603): ORA-02396: exceeded maximum idle time, please connect again"
+        ));
+        assert!(is_connection_error("ORA-03113: end-of-file on communication channel"));
+        assert!(is_connection_error("ORA-03114: not connected to Oracle"));
+        assert!(is_connection_error("ORA-03135: connection lost contact"));
+        assert!(is_connection_error("Agent RPC error (-1): java.sql.SQLRecoverableException: 关闭的连接"));
+        assert!(is_connection_error("java.sql.SQLRecoverableException: 连接已关闭"));
+    }
+
+    #[test]
+    fn is_connection_error_detects_localized_io_errors() {
+        assert!(is_connection_error("I/O error: 远程主机强迫关闭了一个现有的连接。 (os error 10054)"));
+        assert!(is_connection_error(
+            "I/O error: 由于连接方在一段时间后没有正确答复或连接的主机没有反应，连接尝试失败。 (os error 10060)"
+        ));
+        assert!(is_connection_error("Agent RPC error (-1): dm.jdbc.driver.DMException: 网络通信异常"));
+        assert!(is_connection_error(
+            "Agent RPC error (-1): java.sql.SQLRecoverableException: IO 错误: Got minus one from a read call"
+        ));
+        assert!(is_connection_error(
+            "Agent RPC error (-1): com.mysql.cj.jdbc.exceptions.CommunicationsException: Communications link failure"
+        ));
+    }
+
+    #[test]
+    fn is_connection_error_detects_os_error_codes() {
+        assert!(is_connection_error("os error 10053"));
+        assert!(is_connection_error("os error 10054"));
+        assert!(is_connection_error("os error 10060"));
+        assert!(is_connection_error("os error 10061"));
+    }
+
+    #[test]
+    fn is_connection_error_rejects_non_connection_errors() {
+        assert!(!is_connection_error("Query timed out after 30 seconds"));
+        assert!(!is_connection_error("ORA-00942: table or view does not exist"));
+        assert!(!is_connection_error("syntax error at position 5"));
+        assert!(!is_connection_error("os error 13"));
+    }
+
+    #[test]
+    fn is_connection_error_detects_deadpool_pool_timeouts() {
+        // deadpool-postgres PoolError::Timeout messages (contain "pool" + "timeout" but not "timed out")
+        assert!(is_connection_error("pool wait timeout"));
+        assert!(is_connection_error("pool create timeout"));
+        assert!(is_connection_error("pool recycle timeout"));
+        // checkout helper timeout messages
+        assert!(is_connection_error("PostgreSQL connection pool checkout timed out (5s)"));
+        assert!(is_connection_error("MySQL get connection timed out"));
+        assert!(is_connection_error("MySQL ping timed out"));
+        assert!(is_connection_error("MySQL kill connection checkout timed out"));
+        assert!(is_connection_error("MySQL KILL QUERY timed out"));
+    }
+
+    #[test]
+    fn pool_error_action_discards_sqlserver_driver_panic_without_retry() {
+        let err = format!("{} the current client will be rebuilt.", db::sqlserver::SQLSERVER_DRIVER_PANIC_ERROR_PREFIX);
+
+        assert_eq!(pool_error_action(Some(DatabaseType::SqlServer), &err), PoolErrorAction::Discard);
+        assert!(should_discard_pool_after_error(Some(DatabaseType::SqlServer), &err));
+        assert!(!is_connection_error(&err));
+    }
+
+    #[test]
+    fn pool_error_action_discards_sqlserver_timeout_without_retry() {
+        let err = "Query timed out after 30 seconds";
+
+        assert_eq!(pool_error_action(Some(DatabaseType::SqlServer), err), PoolErrorAction::Discard);
+        assert_eq!(pool_error_action(Some(DatabaseType::Mysql), err), PoolErrorAction::Discard);
+        assert_eq!(pool_error_action(Some(DatabaseType::Postgres), err), PoolErrorAction::Discard);
+        assert_eq!(pool_error_action(Some(DatabaseType::ClickHouse), err), PoolErrorAction::Discard);
+        assert_eq!(pool_error_action(Some(DatabaseType::Oracle), err), PoolErrorAction::Discard);
+        assert_eq!(pool_error_action(Some(DatabaseType::Sqlite), err), PoolErrorAction::Keep);
+        assert_eq!(pool_error_action(Some(DatabaseType::DuckDb), err), PoolErrorAction::Keep);
+    }
+
+    #[test]
+    fn pool_error_action_discards_schema_reset_cleanup_without_retry() {
+        let err = "PostgreSQL schema.reset cleanup failed: PostgreSQL schema.reset timed out after 3 seconds";
+
+        assert_eq!(pool_error_action(Some(DatabaseType::Postgres), err), PoolErrorAction::Discard);
+        assert_eq!(pool_error_action(Some(DatabaseType::OpenGauss), err), PoolErrorAction::Discard);
+        assert!(should_discard_pool_after_error(Some(DatabaseType::Postgres), err));
+    }
+
+    #[test]
+    fn pool_error_action_reconnects_connection_errors() {
+        let err = "connection reset by peer";
+
+        assert_eq!(pool_error_action(Some(DatabaseType::SqlServer), err), PoolErrorAction::ReconnectAndRetry);
+        assert_eq!(pool_error_action(Some(DatabaseType::Postgres), err), PoolErrorAction::ReconnectAndRetry);
+
+        let dameng_err = "Agent RPC error (-1): dm.jdbc.driver.DMException: 网络通信异常";
+        assert_eq!(pool_error_action(Some(DatabaseType::Dameng), dameng_err), PoolErrorAction::ReconnectAndRetry);
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_execute_preserves_double_precision() {
+        let con = duckdb::Connection::open_in_memory().expect("connect in-memory DuckDB");
+        let result = duckdb_execute(
+            &con,
+            "SELECT 12.34567::DOUBLE AS sample, 0.5::DOUBLE AS half, 99.99::DOUBLE AS price, 1.0::DOUBLE AS one",
+        )
+        .expect("execute double query");
+
+        assert_eq!(result.columns, vec!["sample", "half", "price", "one"]);
+        let row = &result.rows[0];
+        assert_eq!(row[0], serde_json::json!(12.34567));
+        assert_eq!(row[1], serde_json::json!(0.5));
+        assert_eq!(row[2], serde_json::json!(99.99));
+        assert_eq!(row[3], serde_json::json!(1.0));
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_execute_create_insert_select_double() {
+        let con = duckdb::Connection::open_in_memory().expect("connect in-memory DuckDB");
+        con.execute_batch("CREATE TABLE tmp1 (tmp_double DOUBLE)").expect("create table");
+        con.execute_batch("INSERT INTO tmp1 VALUES (45.678), (12.345), (99.999)").expect("insert");
+
+        let result = duckdb_execute(&con, "SELECT tmp_double FROM tmp1 ORDER BY tmp_double").expect("select doubles");
+
+        assert_eq!(result.rows.len(), 3);
+        assert_eq!(result.rows[0][0], serde_json::json!(12.345));
+        assert_eq!(result.rows[1][0], serde_json::json!(45.678));
+        assert_eq!(result.rows[2][0], serde_json::json!(99.999));
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_execute_returns_rows_for_from_first_query() {
+        let con = duckdb::Connection::open_in_memory().expect("connect in-memory DuckDB");
+        con.execute_batch("CREATE TABLE users (id INTEGER, name VARCHAR)").expect("create table");
+        con.execute_batch("INSERT INTO users VALUES (2, 'Grace'), (1, 'Ada')").expect("insert");
+
+        let result = duckdb_execute(&con, "FROM users ORDER BY id").expect("execute from-first query");
+
+        assert_eq!(result.columns, vec!["id", "name"]);
+        assert_eq!(result.rows.len(), 2);
+        assert_eq!(result.rows[0], vec![serde_json::json!(1), serde_json::json!("Ada")]);
+        assert_eq!(result.rows[1], vec![serde_json::json!(2), serde_json::json!("Grace")]);
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_execute_returns_rows_for_summarize_query() {
+        let con = duckdb::Connection::open_in_memory().expect("connect in-memory DuckDB");
+        con.execute_batch("CREATE TABLE metrics (value INTEGER)").expect("create table");
+        con.execute_batch("INSERT INTO metrics VALUES (1), (2), (NULL)").expect("insert");
+
+        let result = duckdb_execute(&con, "SUMMARIZE metrics").expect("execute summarize query");
+
+        assert!(!result.columns.is_empty());
+        assert!(!result.rows.is_empty());
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_execute_handles_various_types() {
+        let con = duckdb::Connection::open_in_memory().expect("connect in-memory DuckDB");
+        let result = duckdb_execute(
+            &con,
+            "SELECT 42 AS int_val, true AS bool_val, 'hello' AS text_val, 3.14::FLOAT AS float_val, 123456789012345::BIGINT AS big_val",
+        )
+        .expect("execute mixed types query");
+
+        let row = &result.rows[0];
+        assert_eq!(row[0], serde_json::json!(42));
+        assert_eq!(row[1], serde_json::json!(true));
+        assert_eq!(row[2], serde_json::Value::String("hello".to_string()));
+        assert!(row[3].is_number());
+        assert_eq!(row[4], serde_json::json!(123456789012345_i64));
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_execute_returns_list_values_as_json_arrays() {
+        let con = duckdb::Connection::open_in_memory().expect("connect in-memory DuckDB");
+        let result = duckdb_execute(&con, "SELECT ['a','b','c','d'];").expect("execute list query");
+
+        assert_eq!(result.rows, vec![vec![serde_json::json!(["a", "b", "c", "d"])]]);
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_execute_preserves_nulls_inside_list_values() {
+        let con = duckdb::Connection::open_in_memory().expect("connect in-memory DuckDB");
+        let result = duckdb_execute(&con, "SELECT [1, NULL, 3] AS items;").expect("execute nullable list query");
+
+        assert_eq!(result.columns, vec!["items"]);
+        assert_eq!(result.rows, vec![vec![serde_json::json!([1, null, 3])]]);
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_execute_returns_nested_complex_values_as_json() {
+        let con = duckdb::Connection::open_in_memory().expect("connect in-memory DuckDB");
+        let result = duckdb_execute(
+            &con,
+            "SELECT {'name': 'Ada', 'scores': [10, 20]} AS profile, MAP(['x', 'y'], [1, 2]) AS lookup, [1, 2, 3]::INTEGER[3] AS fixed_items",
+        )
+        .expect("execute complex values query");
+
+        assert_eq!(result.columns, vec!["profile", "lookup", "fixed_items"]);
+        assert_eq!(
+            result.rows,
+            vec![vec![
+                serde_json::json!({ "name": "Ada", "scores": [10, 20] }),
+                serde_json::json!([
+                    { "key": "x", "value": 1 },
+                    { "key": "y", "value": 2 },
+                ]),
+                serde_json::json!([1, 2, 3]),
+            ]]
+        );
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_execute_formats_temporal_values_by_column_type() {
+        let con = duckdb::Connection::open_in_memory().expect("connect in-memory DuckDB");
+        let result = duckdb_execute(
+            &con,
+            "SELECT DATE '2026-05-14' AS d, TIME '16:58:15' AS t, TIMESTAMP '2026-05-14 16:58:15.0' AS ts, NULL::TIMESTAMP AS nts",
+        )
+        .expect("execute temporal query");
+
+        assert_eq!(result.columns, vec!["d", "t", "ts", "nts"]);
+        assert_eq!(
+            result.rows,
+            vec![vec![
+                serde_json::Value::String("2026-05-14".to_string()),
+                serde_json::Value::String("16:58:15".to_string()),
+                serde_json::Value::String("2026-05-14 16:58:15".to_string()),
+                serde_json::Value::Null,
+            ]]
+        );
+    }
+
+    #[test]
+    fn external_driver_query_params_include_database_and_schema_context() {
+        let config = ConnectionConfig {
+            id: "jdbc-1".to_string(),
+            name: "JDBC".to_string(),
+            db_type: DatabaseType::Jdbc,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "localhost".to_string(),
+            port: 0,
+            username: String::new(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: 0,
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: Some("jdbc:h2:mem:test".to_string()),
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        };
+
+        let params = external_driver_query_params(
+            &config,
+            "SELECT * FROM events",
+            "analytics",
+            Some("app"),
+            &QueryExecutionOptions {
+                max_rows: Some(500),
+                fetch_size: Some(250),
+                timeout_secs: Some(600),
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(params["connection"]["id"], "jdbc-1");
+        assert_eq!(params["sql"], "SELECT * FROM events");
+        assert_eq!(params["database"], "analytics");
+        assert_eq!(params["schema"], "app");
+        assert_eq!(params["maxRows"], 500);
+        assert_eq!(params["fetchSize"], 250);
+        assert_eq!(params["timeoutSecs"], 600);
+    }
+
+    #[test]
+    fn agent_execute_query_params_include_row_and_fetch_limits() {
+        let params = agent_execute_query_params(
+            "SELECT * FROM events",
+            Some("analytics"),
+            Some("app"),
+            QueryExecutionOptions {
+                max_rows: Some(500),
+                fetch_size: Some(250),
+                timeout_secs: Some(600),
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(params["sql"], "SELECT * FROM events");
+        assert_eq!(params["database"], "analytics");
+        assert_eq!(params["schema"], "app");
+        assert_eq!(params["maxRows"], 500);
+        assert_eq!(params["fetchSize"], 250);
+        assert_eq!(params["timeoutSecs"], 600);
+    }
+
+    #[test]
+    fn iris_execution_context_omits_schema() {
+        assert_eq!(schema_for_execution_context(Some(DatabaseType::Iris), Some("SQLUser")), None);
+        assert_eq!(schema_for_execution_context(Some(DatabaseType::Oracle), Some("APP")), Some("APP"));
+        assert_eq!(schema_for_execution_context(None, Some("APP")), Some("APP"));
+    }
+
+    #[test]
+    fn iris_execution_context_qualifies_unqualified_dml_tables() {
+        assert_eq!(
+            sql_for_execution_context(Some(DatabaseType::Iris), "SELECT * FROM TABLES", Some("INFORMATION_SCHEMA")),
+            "SELECT * FROM \"INFORMATION_SCHEMA\".TABLES"
+        );
+        let qualified_join = sql_for_execution_context(
+            Some(DatabaseType::Iris),
+            "SELECT * FROM orders o JOIN customers c ON c.id = o.customer_id",
+            Some("Sales"),
+        );
+        assert!(qualified_join.contains("FROM \"Sales\".orders"));
+        assert!(qualified_join.contains("JOIN \"Sales\".customers"));
+        assert!(qualified_join.contains("c.id = o.customer_id"));
+        assert_eq!(
+            sql_for_execution_context(Some(DatabaseType::Iris), "SELECT * FROM INFORMATION_SCHEMA.TABLES", Some("APP")),
+            "SELECT * FROM INFORMATION_SCHEMA.TABLES"
+        );
+    }
+
+    #[test]
+    fn iris_execution_context_qualifies_nested_dml_tables_but_not_ctes() {
+        assert_eq!(
+            sql_for_execution_context(
+                Some(DatabaseType::Iris),
+                "WITH recent AS (SELECT * FROM events) SELECT * FROM recent WHERE EXISTS (SELECT 1 FROM audits)",
+                Some("APP")
+            ),
+            "WITH recent AS (SELECT * FROM \"APP\".events) SELECT * FROM recent WHERE EXISTS (SELECT 1 FROM \"APP\".audits)"
+        );
+        assert_eq!(
+            sql_for_execution_context(
+                Some(DatabaseType::Iris),
+                "INSERT INTO events SELECT * FROM staging_events",
+                Some("APP")
+            ),
+            "INSERT INTO \"APP\".events SELECT * FROM \"APP\".staging_events"
+        );
+        assert_eq!(
+            sql_for_execution_context(
+                Some(DatabaseType::Iris),
+                "UPDATE events SET status = 'done' WHERE id IN (SELECT event_id FROM audit_events)",
+                Some("APP")
+            ),
+            "UPDATE \"APP\".events SET status = 'done' WHERE id IN (SELECT event_id FROM \"APP\".audit_events)"
+        );
+    }
+
+    #[test]
+    fn iris_execution_context_leaves_ddl_and_unparseable_sql_unchanged() {
+        assert_eq!(
+            sql_for_execution_context(Some(DatabaseType::Iris), "CREATE TABLE events (id INT)", Some("APP")),
+            "CREATE TABLE events (id INT)"
+        );
+        assert_eq!(
+            sql_for_execution_context(Some(DatabaseType::Iris), "SELECT %ID FROM", Some("APP")),
+            "SELECT %ID FROM"
+        );
+        assert_eq!(
+            sql_for_execution_context(Some(DatabaseType::Postgres), "SELECT * FROM events", Some("APP")),
+            "SELECT * FROM events"
+        );
+    }
+
+    #[test]
+    fn parses_postgres_drop_database_target() {
+        assert_eq!(parse_drop_database_target("DROP DATABASE vaultwarden;"), Some("vaultwarden".to_string()));
+        assert_eq!(parse_drop_database_target("drop database if exists \"app db\";"), Some("app db".to_string()));
+        assert_eq!(
+            parse_drop_database_target("/*x*/ DROP DATABASE \"app\"\"db\" -- trailing\n;"),
+            Some("app\"db".to_string())
+        );
+    }
+
+    #[test]
+    fn ignores_non_single_drop_database_statements() {
+        assert_eq!(parse_drop_database_target("DROP TABLE vaultwarden;"), None);
+        assert_eq!(parse_drop_database_target("DROP DATABASE vaultwarden; SELECT 1;"), None);
+        assert_eq!(parse_drop_database_target("DROP DATABASE 123bad;"), None);
+    }
+
+    #[test]
+    fn chooses_safe_postgres_drop_database_admin_database() {
+        assert_eq!(postgres_drop_database_admin_database("vaultwarden"), "postgres");
+        assert_eq!(postgres_drop_database_admin_database("postgres"), "template1");
+    }
+
+    #[test]
+    fn agent_execute_query_params_default_to_safety_row_limit() {
+        let params = agent_execute_query_params("SELECT * FROM events", None, None, QueryExecutionOptions::default());
+
+        assert_eq!(params["sql"], "SELECT * FROM events");
+        assert!(params.get("database").is_none());
+        assert!(params.get("schema").is_none());
+        assert_eq!(params["maxRows"], MAX_ROWS);
+        assert!(params.get("fetchSize").is_none());
+        assert!(params.get("timeoutSecs").is_none());
+    }
+
+    #[test]
+    fn agent_execute_query_page_params_include_page_fetch_and_safety_limits() {
+        let params = agent_execute_query_page_params(
+            "SELECT * FROM events",
+            Some("analytics"),
+            Some("app"),
+            QueryExecutionOptions {
+                page_size: Some(500),
+                fetch_size: Some(250),
+                timeout_secs: Some(600),
+                ..Default::default()
+            },
+        );
+
+        assert_eq!(params["sql"], "SELECT * FROM events");
+        assert_eq!(params["database"], "analytics");
+        assert_eq!(params["schema"], "app");
+        assert_eq!(params["pageSize"], 500);
+        assert_eq!(params["fetchSize"], 250);
+        assert_eq!(params["timeoutSecs"], 600);
+        assert_eq!(params["maxRows"], MAX_ROWS);
+    }
+
+    #[test]
+    fn agent_fetch_query_page_params_include_session_and_page_size() {
+        let params = agent_fetch_query_page_params("session-1", 500);
+
+        assert_eq!(params["sessionId"], "session-1");
+        assert_eq!(params["pageSize"], 500);
+    }
+
+    #[test]
+    fn agent_close_query_session_params_include_session() {
+        let params = agent_close_query_session_params("session-1");
+
+        assert_eq!(params["sessionId"], "session-1");
+    }
+
+    #[test]
+    fn agent_timeout_discards_pool_but_does_not_retry_same_query() {
+        assert!(should_discard_agent_pool_after_error("Query timed out after 30 seconds"));
+        assert!(should_discard_agent_pool_after_error("Agent RPC call timed out (30s)"));
+        assert!(!is_connection_error("Agent RPC call timed out (30s)"));
+        assert_eq!(
+            pool_error_action(Some(DatabaseType::Oracle), "Agent RPC call timed out (30s)"),
+            PoolErrorAction::Discard
+        );
+    }
+
+    #[test]
+    fn unavailable_agent_pipes_are_reconnectable_errors() {
+        assert!(should_discard_agent_pool_after_error("Agent stdin not available"));
+        assert!(should_discard_agent_pool_after_error("Agent stdout not available"));
+        assert!(is_connection_error("Agent stdin not available"));
+        assert!(is_connection_error("Agent stdout not available"));
+        assert_eq!(
+            pool_error_action(Some(DatabaseType::Oracle), "Agent stdin not available"),
+            PoolErrorAction::ReconnectAndRetry
+        );
+    }
+
+    #[test]
+    fn query_results_convert_unsafe_json_integers_to_strings_for_js() {
+        let result = db::QueryResult {
+            columns: vec!["id".to_string(), "nested".to_string()],
+            column_types: Vec::new(),
+            column_sortables: vec![],
+            rows: vec![vec![
+                serde_json::json!(2_041_797_190_226_354_178_i64),
+                serde_json::json!([1, 2_041_797_190_226_354_178_i64]),
+            ]],
+            affected_rows: 0,
+            execution_time_ms: 0,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        };
+
+        let normalized = normalize_query_result_for_js(result);
+
+        assert_eq!(normalized.rows[0][0], serde_json::json!("2041797190226354178"));
+        assert_eq!(normalized.rows[0][1], serde_json::json!([1, "2041797190226354178"]));
+    }
+
+    #[test]
+    fn query_execution_options_default_use_transaction_is_none() {
+        let opts = QueryExecutionOptions::default();
+        assert_eq!(opts.use_transaction, None);
+    }
+
+    #[test]
+    fn query_execution_options_use_transaction_some_true_is_preserved() {
+        let opts = QueryExecutionOptions { use_transaction: Some(true), ..Default::default() };
+        assert_eq!(opts.use_transaction, Some(true));
+    }
+
+    #[test]
+    fn query_execution_options_use_transaction_some_false_is_preserved() {
+        let opts = QueryExecutionOptions { use_transaction: Some(false), ..Default::default() };
+        assert_eq!(opts.use_transaction, Some(false));
+    }
+}
diff --git a/crates/dbx-core/src/query_cancel.rs b/crates/dbx-core/src/query_cancel.rs
new file mode 100644
index 0000000..e985b41
--- /dev/null
+++ b/crates/dbx-core/src/query_cancel.rs
@@ -0,0 +1,205 @@
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+use tokio_util::sync::CancellationToken;
+
+type InterruptFn = Box<dyn Fn() + Send + 'static>;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum RunningTaskKind {
+    Query,
+    Count,
+    Explain,
+    Export,
+    Unknown,
+}
+
+impl Default for RunningTaskKind {
+    fn default() -> Self {
+        Self::Unknown
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct RunningTaskMetadata {
+    pub kind: RunningTaskKind,
+    pub connection_id: Option<String>,
+    pub database: Option<String>,
+    pub client_session_id: Option<String>,
+}
+
+impl RunningTaskMetadata {
+    pub fn query(
+        connection_id: impl Into<String>,
+        database: impl Into<String>,
+        client_session_id: Option<String>,
+    ) -> Self {
+        let kind = task_kind_from_client_session_id(client_session_id.as_deref());
+        Self { kind, connection_id: Some(connection_id.into()), database: Some(database.into()), client_session_id }
+    }
+}
+
+#[derive(Clone)]
+struct RunningTask {
+    token: CancellationToken,
+    metadata: RunningTaskMetadata,
+    pool_key: Option<String>,
+}
+
+#[derive(Clone, Default)]
+pub struct RunningQueries {
+    inner: Arc<Mutex<HashMap<String, RunningTask>>>,
+    interrupts: Arc<Mutex<HashMap<String, InterruptFn>>>,
+}
+
+impl RunningQueries {
+    pub fn register(&self, execution_id: String) -> RegisteredQuery {
+        self.register_task(execution_id, RunningTaskMetadata::default())
+    }
+
+    pub fn register_task(&self, execution_id: String, metadata: RunningTaskMetadata) -> RegisteredQuery {
+        let token = CancellationToken::new();
+        self.inner
+            .lock()
+            .unwrap_or_else(|e| e.into_inner())
+            .insert(execution_id.clone(), RunningTask { token: token.clone(), metadata, pool_key: None });
+
+        RegisteredQuery { execution_id, token, running_queries: self.clone() }
+    }
+
+    pub fn register_interrupt(&self, execution_id: &str, interrupt: impl Fn() + Send + 'static) {
+        self.interrupts.lock().unwrap_or_else(|e| e.into_inner()).insert(execution_id.to_string(), Box::new(interrupt));
+    }
+
+    pub fn cancel(&self, execution_id: &str) -> bool {
+        let token =
+            self.inner.lock().unwrap_or_else(|e| e.into_inner()).get(execution_id).map(|task| task.token.clone());
+        let interrupt = self.interrupts.lock().unwrap_or_else(|e| e.into_inner()).remove(execution_id);
+
+        if let Some(interrupt) = interrupt {
+            interrupt();
+        }
+        if let Some(token) = token {
+            token.cancel();
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn set_pool_key(&self, execution_id: &str, pool_key: impl Into<String>) {
+        if let Some(task) = self.inner.lock().unwrap_or_else(|e| e.into_inner()).get_mut(execution_id) {
+            task.pool_key = Some(pool_key.into());
+        }
+    }
+
+    pub fn is_pool_active(&self, pool_key: &str) -> bool {
+        self.inner.lock().unwrap_or_else(|e| e.into_inner()).values().any(|task| {
+            let _kind = task.metadata.kind;
+            task.pool_key.as_deref() == Some(pool_key)
+        })
+    }
+
+    #[cfg(test)]
+    pub fn has(&self, execution_id: &str) -> bool {
+        self.inner.lock().unwrap_or_else(|e| e.into_inner()).contains_key(execution_id)
+    }
+
+    #[cfg(test)]
+    pub fn task_kind(&self, execution_id: &str) -> Option<RunningTaskKind> {
+        self.inner.lock().unwrap_or_else(|e| e.into_inner()).get(execution_id).map(|task| task.metadata.kind)
+    }
+
+    fn remove(&self, execution_id: &str) {
+        self.inner.lock().unwrap_or_else(|e| e.into_inner()).remove(execution_id);
+        self.interrupts.lock().unwrap_or_else(|e| e.into_inner()).remove(execution_id);
+    }
+}
+
+fn task_kind_from_client_session_id(client_session_id: Option<&str>) -> RunningTaskKind {
+    let Some(session_id) = client_session_id else {
+        return RunningTaskKind::Query;
+    };
+    let session_id = session_id.trim().to_ascii_lowercase();
+    if session_id.ends_with(":count") {
+        RunningTaskKind::Count
+    } else if session_id.ends_with(":explain") {
+        RunningTaskKind::Explain
+    } else if session_id.ends_with(":export") {
+        RunningTaskKind::Export
+    } else {
+        RunningTaskKind::Query
+    }
+}
+
+pub struct RegisteredQuery {
+    execution_id: String,
+    token: CancellationToken,
+    running_queries: RunningQueries,
+}
+
+impl RegisteredQuery {
+    pub fn token(&self) -> CancellationToken {
+        self.token.clone()
+    }
+}
+
+impl Drop for RegisteredQuery {
+    fn drop(&mut self) {
+        self.running_queries.remove(&self.execution_id);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{RunningQueries, RunningTaskKind, RunningTaskMetadata};
+
+    #[test]
+    fn cancel_marks_registered_query_as_cancelled() {
+        let running = RunningQueries::default();
+        let registered = running.register("exec-1".to_string());
+
+        assert!(running.cancel("exec-1"));
+        assert!(registered.token().is_cancelled());
+    }
+
+    #[test]
+    fn cancel_invokes_registered_interrupt() {
+        let running = RunningQueries::default();
+        let interrupted = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
+        let flag = interrupted.clone();
+        let _registered = running.register("exec-1".to_string());
+        running.register_interrupt("exec-1", move || {
+            flag.store(true, std::sync::atomic::Ordering::SeqCst);
+        });
+
+        assert!(running.cancel("exec-1"));
+        assert!(interrupted.load(std::sync::atomic::Ordering::SeqCst));
+    }
+
+    #[test]
+    fn dropping_registration_removes_running_query() {
+        let running = RunningQueries::default();
+        let registered = running.register("exec-1".to_string());
+
+        assert!(running.has("exec-1"));
+        drop(registered);
+
+        assert!(!running.has("exec-1"));
+    }
+
+    #[test]
+    fn register_task_tracks_kind_and_pool_activity() {
+        let running = RunningQueries::default();
+        let registered = running.register_task(
+            "exec-1".to_string(),
+            RunningTaskMetadata::query("conn-1", "main", Some("tab-1:export".to_string())),
+        );
+
+        running.set_pool_key("exec-1", "conn-1:main:session:tab-1_export");
+
+        assert_eq!(running.task_kind("exec-1"), Some(RunningTaskKind::Export));
+        assert!(running.is_pool_active("conn-1:main:session:tab-1_export"));
+        drop(registered);
+        assert!(!running.is_pool_active("conn-1:main:session:tab-1_export"));
+    }
+}
diff --git a/crates/dbx-core/src/query_execution_sql.rs b/crates/dbx-core/src/query_execution_sql.rs
new file mode 100644
index 0000000..5a3350f
--- /dev/null
+++ b/crates/dbx-core/src/query_execution_sql.rs
@@ -0,0 +1,1194 @@
+use serde::{Deserialize, Serialize};
+use sqlparser::dialect::{MsSqlDialect, PostgreSqlDialect};
+use sqlparser::tokenizer::{Token, Tokenizer};
+
+use crate::models::connection::DatabaseType;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ExplainFormat {
+    Json,
+    Standard,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExplainSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    /// MySQL supports both a structured JSON plan and the traditional tabular plan.
+    /// Omitted formats retain the existing JSON behavior.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub format: Option<ExplainFormat>,
+    pub sql: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExplainSqlBuildResult {
+    pub ok: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sql: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reason: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DroppedFilePreviewSqlOptions {
+    pub path: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit: Option<usize>,
+}
+
+pub fn build_explain_sql(options: ExplainSqlOptions) -> ExplainSqlBuildResult {
+    if !supports_explain_plan(options.database_type) {
+        return explain_err("unsupported");
+    }
+
+    let source = strip_trailing_semicolons(options.sql.trim());
+    if source.is_empty() {
+        return explain_err("empty");
+    }
+    if !is_safe_explain_sql(&source) {
+        return explain_err("unsafe");
+    }
+
+    let sql = match options.database_type {
+        Some(DatabaseType::Postgres | DatabaseType::MongoDb) => {
+            format!("EXPLAIN (FORMAT JSON) {source}")
+        }
+        Some(DatabaseType::Dameng | DatabaseType::Questdb) => {
+            format!("EXPLAIN {source}")
+        }
+        Some(DatabaseType::Oracle) => format!("EXPLAIN PLAN FOR {source}"),
+        Some(DatabaseType::Mysql) if options.format == Some(ExplainFormat::Standard) => {
+            // MySQL 8.0.32+ may otherwise inherit TREE or JSON from the session-level explain_format.
+            format!("EXPLAIN FORMAT=TRADITIONAL {source}")
+        }
+        _ => format!("EXPLAIN FORMAT=JSON {source}"),
+    };
+    ExplainSqlBuildResult { ok: true, sql: Some(sql), reason: None }
+}
+
+pub fn build_dropped_file_preview_sql(options: DroppedFilePreviewSqlOptions) -> Option<String> {
+    let lower = options.path.to_lowercase();
+    let escaped = options.path.replace('\'', "''");
+    let limit = options.limit.unwrap_or(1000).max(1);
+    if lower.ends_with(".parquet") {
+        return Some(format!("SELECT * FROM read_parquet('{escaped}') LIMIT {limit}"));
+    }
+    if lower.ends_with(".csv") {
+        return Some(format!("SELECT * FROM read_csv('{escaped}') LIMIT {limit}"));
+    }
+    if lower.ends_with(".tsv") {
+        return Some(format!("SELECT * FROM read_csv('{escaped}', delim='\\t') LIMIT {limit}"));
+    }
+    if lower.ends_with(".json") {
+        return Some(format!("SELECT * FROM read_json('{escaped}') LIMIT {limit}"));
+    }
+    None
+}
+
+pub fn supports_explain_plan(database_type: Option<DatabaseType>) -> bool {
+    matches!(
+        database_type,
+        Some(
+            DatabaseType::Mysql
+                | DatabaseType::Postgres
+                | DatabaseType::Questdb
+                | DatabaseType::Dameng
+                | DatabaseType::Oracle
+        )
+    )
+}
+
+pub fn is_safe_explain_sql(sql: &str) -> bool {
+    let source = strip_trailing_semicolons(sql.trim());
+    !source.is_empty()
+        && !has_extra_statement_after_semicolon(&source)
+        && is_safe_explain_source(&source)
+        && !contains_dangerous_sql_keyword(&source)
+}
+
+/// Returns true for databases that support SQL query execution (execute_query / get_sample_data).
+/// Non-SQL databases (Redis, MongoDB, Elasticsearch, InfluxDB, Neo4j, etcd) are excluded.
+pub fn supports_sql_query(database_type: DatabaseType) -> bool {
+    !matches!(
+        database_type,
+        DatabaseType::Redis
+            | DatabaseType::MongoDb
+            | DatabaseType::Elasticsearch
+            | DatabaseType::Qdrant
+            | DatabaseType::Milvus
+            | DatabaseType::Weaviate
+            | DatabaseType::ChromaDb
+            | DatabaseType::InfluxDb
+            | DatabaseType::Neo4j
+            | DatabaseType::Etcd
+    )
+}
+
+pub fn is_safe_dameng_autotrace_sql(sql: &str) -> bool {
+    let source = strip_trailing_semicolons(sql.trim());
+    if source.is_empty() || has_extra_statement_after_semicolon(&source) {
+        return false;
+    }
+    is_safe_explain_source(&source) && !contains_dangerous_sql_keyword(&source)
+}
+
+fn explain_err(reason: &str) -> ExplainSqlBuildResult {
+    ExplainSqlBuildResult { ok: false, sql: None, reason: Some(reason.to_string()) }
+}
+
+fn strip_trailing_semicolons(sql: &str) -> String {
+    sql.trim_end().trim_end_matches(';').trim_end().to_string()
+}
+
+fn is_safe_explain_source(sql: &str) -> bool {
+    let source = strip_sql_comments(sql).trim_start().to_lowercase();
+    ["select", "with", "table", "values"].iter().any(|keyword| {
+        source == *keyword || source.starts_with(&format!("{keyword} ")) || source.starts_with(&format!("{keyword}\n"))
+    })
+}
+
+pub fn contains_dangerous_sql_keyword(sql: &str) -> bool {
+    let source = strip_sql_comments_and_literals(sql).to_lowercase();
+    ["drop", "delete", "truncate", "alter", "update", "merge", "replace", "insert", "create"]
+        .iter()
+        .any(|keyword| contains_word(&source, keyword))
+}
+
+/// Keywords that start a read-only SQL statement.
+/// Note: FROM is a DuckDB-specific read keyword supporting SELECT-less FROM syntax
+/// (e.g. `FROM table SELECT *`). In other databases, a statement starting with FROM
+/// is invalid and would be rejected by the database itself, so allowing it poses no risk.
+///
+/// PRAGMA is intentionally NOT in this list because some PRAGMA statements modify
+/// database or session state (e.g. SQLite `PRAGMA journal_mode=WAL`). Instead,
+/// read-only PRAGMA forms are handled separately in `is_safe_read_pragma`.
+const READ_SQL_KEYWORDS: &[&str] = &["SELECT", "WITH", "SHOW", "DESCRIBE", "DESC", "EXPLAIN", "FROM"];
+
+/// PRAGMA names that are known to be safe read-only queries in SQLite/DuckDB.
+/// Only the function-call form `PRAGMA name(args)` matching these names is allowed.
+/// Any PRAGMA with assignment (`PRAGMA name = value`) or not in this list is blocked.
+const SAFE_READ_PRAGMA_NAMES: &[&str] = &[
+    "TABLE_INFO",
+    "TABLE_XINFO",
+    "INDEX_LIST",
+    "INDEX_INFO",
+    "FOREIGN_KEY_LIST",
+    "DATABASE_LIST",
+    "COMPILE_OPTIONS",
+    "DATA_VERSION",
+];
+
+/// Returns true if the SQL statement is a write operation (not a pure read).
+///
+/// Callers that know the connection database type should use
+/// [`is_write_sql_for_database`] so executable comments are interpreted using
+/// the correct dialect. This untyped helper deliberately remains conservative
+/// for executable comments.
+pub fn is_write_sql(sql: &str) -> bool {
+    is_write_sql_with_database_type(sql, None)
+}
+
+/// Returns true if the SQL statement is a write operation for a database
+/// dialect. In addition to ordinary write statements, this recognizes MySQL
+/// executable comments and file exports, plus PostgreSQL-family/SQL Server
+/// `SELECT ... INTO` table creation.
+pub fn is_write_sql_for_database(sql: &str, database_type: DatabaseType) -> bool {
+    is_write_sql_with_database_type(sql, Some(database_type))
+}
+
+fn is_write_sql_with_database_type(sql: &str, database_type: Option<DatabaseType>) -> bool {
+    if database_type.is_some_and(|database_type| has_dialect_specific_write(sql, database_type)) {
+        return true;
+    }
+
+    // The untyped helper remains conservative for MySQL executable comments.
+    // Typed callers handle those comments in has_dialect_specific_write above.
+    let detect_mysql_executable_comments = database_type.is_none();
+    let detect_select_into = database_type.is_none();
+    let statements = match database_type {
+        Some(database_type) => crate::sql::split_sql_statements_for_database(sql, database_type),
+        None => crate::sql::split_sql_statements(sql),
+    };
+
+    statements
+        .iter()
+        .any(|statement| is_write_sql_statement(statement, detect_mysql_executable_comments, detect_select_into))
+}
+
+fn is_mysql_compatible_database(database_type: DatabaseType) -> bool {
+    matches!(
+        database_type,
+        DatabaseType::Mysql
+            | DatabaseType::Doris
+            | DatabaseType::StarRocks
+            | DatabaseType::ManticoreSearch
+            | DatabaseType::Goldendb
+    )
+}
+
+fn is_postgresql_family_database(database_type: DatabaseType) -> bool {
+    matches!(
+        database_type,
+        DatabaseType::Postgres
+            | DatabaseType::Redshift
+            | DatabaseType::Gaussdb
+            | DatabaseType::OpenGauss
+            | DatabaseType::Kingbase
+            | DatabaseType::Highgo
+            | DatabaseType::Vastbase
+            | DatabaseType::Kwdb
+    )
+}
+
+/// Detects write-capable syntax that otherwise looks like a read query and is
+/// interpreted differently depending on the database dialect.
+pub(crate) fn has_dialect_specific_write(sql: &str, database_type: DatabaseType) -> bool {
+    let statements = crate::sql::split_sql_statements_for_database(sql, database_type);
+    statements.iter().any(|statement| has_dialect_specific_write_statement(statement, database_type))
+}
+
+fn has_dialect_specific_write_statement(sql: &str, database_type: DatabaseType) -> bool {
+    if is_mysql_compatible_database(database_type) {
+        let (cleaned, has_executable_comment) = strip_sql_comments_and_literals_with_metadata(sql, true);
+        return has_executable_comment
+            || contains_keyword_sequence(&cleaned, "INTO", "OUTFILE")
+            || contains_keyword_sequence(&cleaned, "INTO", "DUMPFILE");
+    }
+
+    if is_postgresql_family_database(database_type) {
+        contains_unquoted_keyword(sql, &PostgreSqlDialect {}, "INTO")
+    } else {
+        match database_type {
+            DatabaseType::SqlServer => contains_unquoted_keyword(sql, &MsSqlDialect {}, "INTO"),
+            _ => false,
+        }
+    }
+}
+
+fn contains_keyword_sequence(sql: &str, first: &str, second: &str) -> bool {
+    let words = sql.split(|ch: char| !ch.is_ascii_alphanumeric() && ch != '_').filter(|word| !word.is_empty());
+
+    let mut previous_matches = false;
+    for word in words {
+        if previous_matches && word.eq_ignore_ascii_case(second) {
+            return true;
+        }
+        previous_matches = word.eq_ignore_ascii_case(first);
+    }
+    false
+}
+
+fn contains_unquoted_keyword(sql: &str, dialect: &dyn sqlparser::dialect::Dialect, keyword: &str) -> bool {
+    Tokenizer::new(dialect, sql).tokenize().is_ok_and(|tokens| {
+        tokens.into_iter().any(|token| {
+            matches!(token, Token::Word(word) if word.quote_style.is_none() && word.value.eq_ignore_ascii_case(keyword))
+        })
+    })
+}
+
+fn is_write_sql_statement(sql: &str, detect_mysql_executable_comments: bool, detect_select_into: bool) -> bool {
+    // 1. Strip comments and string literals
+    let (cleaned, has_mysql_executable_comment) =
+        strip_sql_comments_and_literals_with_metadata(sql, detect_mysql_executable_comments);
+    // MySQL/MariaDB executable comments may contain arbitrary SQL, including
+    // writes that are not represented by the outer statement (for example,
+    // INTO OUTFILE inside a SELECT). Treat them as writes rather than
+    // attempting to parse every supported MySQL dialect extension here.
+    if has_mysql_executable_comment {
+        return true;
+    }
+    let trimmed = cleaned.trim_start();
+    if trimmed.is_empty() {
+        return false;
+    }
+    let upper = trimmed.to_uppercase();
+
+    // 2. Check if first keyword is a read keyword
+    let starts_with_read = READ_SQL_KEYWORDS.iter().any(|kw| {
+        upper.starts_with(kw) && (upper.len() == kw.len() || !upper.as_bytes()[kw.len()].is_ascii_alphanumeric())
+    });
+
+    // 3. Special handling for PRAGMA: only allow safe read-only forms
+    if !starts_with_read && starts_with_keyword(&upper, "PRAGMA") {
+        return !is_safe_read_pragma(&upper);
+    }
+
+    // SHOW CREATE returns object metadata; CREATE is part of its read-only syntax.
+    if starts_with_show_create(&upper) {
+        return false;
+    }
+
+    // Untyped callers stay conservative. Typed callers handle SELECT ... INTO
+    // only for database families where the syntax performs a write.
+    if detect_select_into && starts_with_keyword(&upper, "SELECT") && select_contains_top_level_into(&upper) {
+        return true;
+    }
+
+    // A statement is a write if it doesn't start with a read keyword,
+    // or if it contains embedded dangerous keywords (e.g. CTE-wrapped writes like WITH ... AS (DELETE FROM ...))
+    !starts_with_read || contains_dangerous_sql_keyword(sql)
+}
+
+fn starts_with_show_create(upper: &str) -> bool {
+    let Some(after_show) = upper.strip_prefix("SHOW") else {
+        return false;
+    };
+    if !after_show.is_empty() && after_show.as_bytes()[0].is_ascii_alphanumeric() {
+        return false;
+    }
+    starts_with_keyword(after_show.trim_start(), "CREATE")
+}
+
+fn select_contains_top_level_into(upper: &str) -> bool {
+    let mut token = String::new();
+    let mut depth = 0usize;
+    let mut saw_select = false;
+
+    for ch in upper.chars().chain(std::iter::once(' ')) {
+        if ch.is_ascii_alphanumeric() || ch == '_' {
+            token.push(ch);
+            continue;
+        }
+
+        if !token.is_empty() {
+            if depth == 0 {
+                if token == "SELECT" {
+                    saw_select = true;
+                } else if saw_select && token == "INTO" {
+                    return true;
+                }
+            }
+            token.clear();
+        }
+
+        if ch == '(' {
+            depth += 1;
+        } else if ch == ')' {
+            depth = depth.saturating_sub(1);
+        }
+    }
+
+    false
+}
+
+/// Check if a PRAGMA statement is a safe read-only form.
+/// Allows: PRAGMA table_info(...), PRAGMA index_list(...), etc.
+/// Blocks: PRAGMA name = value, PRAGMA name(value), or unknown PRAGMA names.
+fn is_safe_read_pragma(upper_stripped: &str) -> bool {
+    // Skip "PRAGMA" keyword to get the rest
+    let rest = upper_stripped.strip_prefix("PRAGMA").unwrap_or("").trim_start();
+
+    if rest.is_empty() {
+        return false;
+    }
+
+    // Extract the pragma name (first word)
+    let name_end = rest.find(|c: char| !c.is_ascii_alphanumeric() && c != '_').unwrap_or(rest.len());
+    let pragma_name = &rest[..name_end];
+
+    // Check if it's in the safe list
+    if !SAFE_READ_PRAGMA_NAMES.contains(&pragma_name) {
+        return false;
+    }
+
+    // Check the form after the name: must be function-call style "(...)" or end of statement
+    let after_name = rest[name_end..].trim_start();
+    if after_name.is_empty() {
+        // PRAGMA table_info (no args) — safe
+        return true;
+    }
+    if after_name.starts_with('(') {
+        // PRAGMA table_info(users) — safe read form
+        return true;
+    }
+    // PRAGMA table_info = something or other unsafe form — blocked
+    false
+}
+
+fn starts_with_keyword(upper: &str, keyword: &str) -> bool {
+    upper.starts_with(keyword)
+        && (upper.len() == keyword.len() || !upper.as_bytes()[keyword.len()].is_ascii_alphanumeric())
+}
+
+/// Check whether a SQL statement is allowed under read-only mode.
+/// Returns Err with a descriptive message if the statement is a write operation.
+pub fn check_read_only(sql: &str, connection_name: &str, database_type: DatabaseType) -> Result<(), String> {
+    if is_write_sql_for_database(sql, database_type) {
+        return Err(format!(
+            "Read-only mode: connection '{}' has read-only protection enabled. Write operation (including stored procedure calls) blocked.",
+            connection_name
+        ));
+    }
+    Ok(())
+}
+
+fn contains_word(source: &str, word: &str) -> bool {
+    let bytes = source.as_bytes();
+    let word_bytes = word.as_bytes();
+    if word_bytes.is_empty() || bytes.len() < word_bytes.len() {
+        return false;
+    }
+
+    for idx in 0..=bytes.len() - word_bytes.len() {
+        if &bytes[idx..idx + word_bytes.len()] != word_bytes {
+            continue;
+        }
+        let before = idx.checked_sub(1).and_then(|i| bytes.get(i)).copied();
+        let after = bytes.get(idx + word_bytes.len()).copied();
+        if !is_identifier_byte(before) && !is_identifier_byte(after) {
+            return true;
+        }
+    }
+    false
+}
+
+fn is_identifier_byte(byte: Option<u8>) -> bool {
+    byte.is_some_and(|b| b.is_ascii_alphanumeric() || b == b'_')
+}
+
+fn has_extra_statement_after_semicolon(sql: &str) -> bool {
+    let stripped = strip_sql_comments_and_literals(sql);
+    stripped.split(';').skip(1).any(|part| !part.trim().is_empty())
+}
+
+fn strip_sql_comments(sql: &str) -> String {
+    let mut output = String::with_capacity(sql.len());
+    let mut chars = sql.chars().peekable();
+    let mut in_line_comment = false;
+    let mut in_block_comment = false;
+
+    while let Some(ch) = chars.next() {
+        if in_line_comment {
+            if ch == '\n' {
+                in_line_comment = false;
+                output.push(' ');
+            }
+            continue;
+        }
+
+        if in_block_comment {
+            if ch == '*' && chars.peek() == Some(&'/') {
+                chars.next();
+                in_block_comment = false;
+                output.push(' ');
+            }
+            continue;
+        }
+
+        if ch == '-' && chars.peek() == Some(&'-') {
+            chars.next();
+            in_line_comment = true;
+            continue;
+        }
+        if ch == '#' {
+            in_line_comment = true;
+            continue;
+        }
+        if ch == '/' && chars.peek() == Some(&'*') {
+            chars.next();
+            if let Some(body) = read_mysql_executable_comment_body(&mut chars) {
+                output.push(' ');
+                output.push_str(&strip_sql_comments(&body));
+                output.push(' ');
+            } else {
+                in_block_comment = true;
+            }
+            continue;
+        }
+
+        output.push(ch);
+    }
+
+    output
+}
+
+pub fn strip_sql_comments_and_literals(sql: &str) -> String {
+    strip_sql_comments_and_literals_with_metadata(sql, false).0
+}
+
+fn strip_sql_comments_and_literals_with_metadata(sql: &str, detect_mysql_executable_comments: bool) -> (String, bool) {
+    let mut output = String::with_capacity(sql.len());
+    let mut chars = sql.chars().peekable();
+    let mut in_line_comment = false;
+    let mut in_block_comment = false;
+    let mut in_single_quote = false;
+    let mut in_double_quote = false;
+    let mut in_backtick_quote = false;
+    let mut has_mysql_executable_comment = false;
+
+    while let Some(ch) = chars.next() {
+        if in_line_comment {
+            if ch == '\n' {
+                in_line_comment = false;
+                output.push(' ');
+            }
+            continue;
+        }
+
+        if in_block_comment {
+            if ch == '*' && chars.peek() == Some(&'/') {
+                chars.next();
+                in_block_comment = false;
+                output.push(' ');
+            }
+            continue;
+        }
+
+        if in_single_quote {
+            if ch == '\'' {
+                if chars.peek() == Some(&'\'') {
+                    chars.next();
+                } else {
+                    in_single_quote = false;
+                }
+            }
+            output.push(' ');
+            continue;
+        }
+
+        if in_double_quote {
+            if ch == '"' {
+                if chars.peek() == Some(&'"') {
+                    chars.next();
+                } else {
+                    in_double_quote = false;
+                }
+            }
+            output.push(' ');
+            continue;
+        }
+
+        if in_backtick_quote {
+            if ch == '`' {
+                if chars.peek() == Some(&'`') {
+                    chars.next();
+                } else {
+                    in_backtick_quote = false;
+                }
+            }
+            output.push(' ');
+            continue;
+        }
+
+        if ch == '-' && chars.peek() == Some(&'-') {
+            chars.next();
+            in_line_comment = true;
+            continue;
+        }
+        if ch == '#' {
+            in_line_comment = true;
+            continue;
+        }
+        if ch == '/' && chars.peek() == Some(&'*') {
+            chars.next();
+            if detect_mysql_executable_comments && is_mysql_executable_comment_start(&chars) {
+                has_mysql_executable_comment = true;
+            }
+            in_block_comment = true;
+            continue;
+        }
+        if ch == '\'' {
+            in_single_quote = true;
+            output.push(' ');
+            continue;
+        }
+        if ch == '"' {
+            in_double_quote = true;
+            output.push(' ');
+            continue;
+        }
+        if ch == '`' {
+            in_backtick_quote = true;
+            output.push(' ');
+            continue;
+        }
+
+        output.push(ch);
+    }
+
+    (output, has_mysql_executable_comment)
+}
+
+/// `/*! ... */` is executable in MySQL, while `/*M! ... */` (optionally
+/// followed by a version number) is executable in MariaDB.
+fn is_mysql_executable_comment_start(chars: &std::iter::Peekable<std::str::Chars<'_>>) -> bool {
+    let mut marker = chars.clone();
+    match marker.next() {
+        Some('!') => true,
+        Some('M') => marker.next() == Some('!'),
+        _ => false,
+    }
+}
+
+fn read_mysql_executable_comment_body<I>(chars: &mut std::iter::Peekable<I>) -> Option<String>
+where
+    I: Iterator<Item = char>,
+{
+    let marker = chars.peek().copied()?;
+    if marker == '!' {
+        chars.next();
+    } else if marker == 'M' {
+        chars.next();
+        if chars.peek() != Some(&'!') {
+            return None;
+        }
+        chars.next();
+    } else {
+        return None;
+    }
+
+    let mut body = String::new();
+    let mut skipping_version = true;
+    while let Some(ch) = chars.next() {
+        if ch == '*' && chars.peek() == Some(&'/') {
+            chars.next();
+            return Some(body);
+        }
+        if skipping_version && (ch.is_ascii_digit() || ch.is_whitespace()) {
+            continue;
+        }
+        skipping_version = false;
+        body.push(ch);
+    }
+    Some(body)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn builds_postgres_json_explain_sql() {
+        let result = build_explain_sql(ExplainSqlOptions {
+            database_type: Some(DatabaseType::Postgres),
+            format: None,
+            sql: " select * from users where id = 1; ".to_string(),
+        });
+
+        assert_eq!(
+            result,
+            ExplainSqlBuildResult {
+                ok: true,
+                sql: Some("EXPLAIN (FORMAT JSON) select * from users where id = 1".to_string()),
+                reason: None,
+            }
+        );
+    }
+
+    #[test]
+    fn builds_dameng_explain_sql() {
+        let result = build_explain_sql(ExplainSqlOptions {
+            database_type: Some(DatabaseType::Dameng),
+            format: None,
+            sql: "SELECT * FROM t1 WHERE id = 1".to_string(),
+        });
+
+        assert_eq!(
+            result,
+            ExplainSqlBuildResult {
+                ok: true,
+                sql: Some("EXPLAIN SELECT * FROM t1 WHERE id = 1".to_string()),
+                reason: None,
+            }
+        );
+    }
+
+    #[test]
+    fn builds_oracle_explain_plan_sql() {
+        let result = build_explain_sql(ExplainSqlOptions {
+            database_type: Some(DatabaseType::Oracle),
+            format: None,
+            sql: "WITH rows AS (SELECT 1 AS id FROM dual) SELECT * FROM rows;".to_string(),
+        });
+
+        assert_eq!(
+            result,
+            ExplainSqlBuildResult {
+                ok: true,
+                sql: Some("EXPLAIN PLAN FOR WITH rows AS (SELECT 1 AS id FROM dual) SELECT * FROM rows".to_string()),
+                reason: None,
+            }
+        );
+    }
+
+    #[test]
+    fn validates_dameng_autotrace_sql_safety() {
+        assert!(is_safe_dameng_autotrace_sql("SELECT * FROM t WHERE name = 'delete';"));
+        assert!(is_safe_dameng_autotrace_sql("/* comment */ WITH q AS (SELECT 1) SELECT * FROM q"));
+        assert!(!is_safe_dameng_autotrace_sql("SELECT * FROM t; DELETE FROM t"));
+        assert!(!is_safe_dameng_autotrace_sql("UPDATE t SET name = 'x'"));
+        assert!(!is_safe_dameng_autotrace_sql("SELECT * FROM t; /* hidden */ DROP TABLE t"));
+        assert!(!is_safe_dameng_autotrace_sql(""));
+    }
+
+    #[test]
+    fn builds_mysql_json_explain_and_rejects_unsafe_sql() {
+        assert_eq!(
+            build_explain_sql(ExplainSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                format: None,
+                sql: "SELECT * FROM users;".to_string(),
+            }),
+            ExplainSqlBuildResult {
+                ok: true,
+                sql: Some("EXPLAIN FORMAT=JSON SELECT * FROM users".to_string()),
+                reason: None,
+            }
+        );
+
+        assert_eq!(
+            build_explain_sql(ExplainSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                format: None,
+                sql: "delete from users".to_string(),
+            }),
+            ExplainSqlBuildResult { ok: false, sql: None, reason: Some("unsafe".to_string()) }
+        );
+
+        assert_eq!(
+            build_explain_sql(ExplainSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                format: None,
+                sql: "SELECT * FROM users; DELETE FROM users".to_string(),
+            }),
+            ExplainSqlBuildResult { ok: false, sql: None, reason: Some("unsafe".to_string()) }
+        );
+
+        assert_eq!(
+            build_explain_sql(ExplainSqlOptions {
+                database_type: Some(DatabaseType::Mysql),
+                format: Some(ExplainFormat::Standard),
+                sql: "SELECT * FROM users;".to_string(),
+            }),
+            ExplainSqlBuildResult {
+                ok: true,
+                sql: Some("EXPLAIN FORMAT=TRADITIONAL SELECT * FROM users".to_string()),
+                reason: None,
+            }
+        );
+    }
+
+    #[test]
+    fn builds_dropped_file_preview_sql() {
+        assert_eq!(
+            build_dropped_file_preview_sql(DroppedFilePreviewSqlOptions {
+                path: "/tmp/O'Hara.csv".to_string(),
+                limit: Some(25),
+            }),
+            Some("SELECT * FROM read_csv('/tmp/O''Hara.csv') LIMIT 25".to_string())
+        );
+        assert_eq!(
+            build_dropped_file_preview_sql(DroppedFilePreviewSqlOptions {
+                path: "/tmp/data.tsv".to_string(),
+                limit: None,
+            }),
+            Some("SELECT * FROM read_csv('/tmp/data.tsv', delim='\\t') LIMIT 1000".to_string())
+        );
+        assert_eq!(
+            build_dropped_file_preview_sql(DroppedFilePreviewSqlOptions {
+                path: "/tmp/data.txt".to_string(),
+                limit: None,
+            }),
+            None
+        );
+    }
+
+    #[test]
+    fn strip_sql_comments_and_literals_basic() {
+        assert_eq!(strip_sql_comments_and_literals("SELECT 1"), "SELECT 1");
+        assert_eq!(strip_sql_comments_and_literals("SELECT 'hello'"), "SELECT        ");
+        assert_eq!(strip_sql_comments_and_literals("SELECT \"hello\""), "SELECT        ");
+        assert_eq!(strip_sql_comments_and_literals("-- comment\nSELECT 1"), " SELECT 1");
+        assert_eq!(strip_sql_comments_and_literals("/* block */ SELECT 1"), "  SELECT 1");
+        assert_eq!(strip_sql_comments_and_literals("# comment\nSELECT 1"), " SELECT 1");
+    }
+
+    #[test]
+    fn strip_sql_comments_and_literals_nested() {
+        // String literals containing comments should be stripped
+        assert_eq!(strip_sql_comments_and_literals("SELECT '/* not a comment */'"), "SELECT                      ");
+        // Comments containing string delimiters should be stripped
+        assert_eq!(strip_sql_comments_and_literals("/* 'not a string' */ SELECT 1"), "  SELECT 1");
+    }
+
+    #[test]
+    fn contains_dangerous_sql_keyword_detects_writes() {
+        assert!(contains_dangerous_sql_keyword("DROP TABLE users"));
+        assert!(contains_dangerous_sql_keyword("DELETE FROM users"));
+        assert!(contains_dangerous_sql_keyword("TRUNCATE TABLE users"));
+        assert!(contains_dangerous_sql_keyword("ALTER TABLE users ADD COLUMN age INT"));
+        assert!(contains_dangerous_sql_keyword("UPDATE users SET name = 'x'"));
+        assert!(contains_dangerous_sql_keyword("MERGE INTO target USING source"));
+        assert!(contains_dangerous_sql_keyword("REPLACE INTO users VALUES (1)"));
+        assert!(contains_dangerous_sql_keyword("INSERT INTO users VALUES (1)"));
+        assert!(contains_dangerous_sql_keyword("CREATE TABLE users (id INT)"));
+    }
+
+    #[test]
+    fn contains_dangerous_sql_keyword_ignores_substrings() {
+        // "updateable" contains "update" as substring but is a different word
+        assert!(!contains_dangerous_sql_keyword("SELECT * FROM updateable_view"));
+        // "dropped" contains "drop" as substring
+        assert!(!contains_dangerous_sql_keyword("SELECT dropped FROM t"));
+        // "inserted" contains "insert"
+        assert!(!contains_dangerous_sql_keyword("SELECT inserted FROM t"));
+    }
+
+    #[test]
+    fn contains_dangerous_sql_keyword_ignores_in_string_literals() {
+        assert!(!contains_dangerous_sql_keyword("SELECT 'DROP TABLE users' FROM t"));
+        assert!(!contains_dangerous_sql_keyword("SELECT 'delete' FROM t"));
+        assert!(!contains_dangerous_sql_keyword("SELECT \"CREATE TABLE\" FROM t"));
+    }
+
+    #[test]
+    fn contains_dangerous_sql_keyword_ignores_backtick_identifiers() {
+        for keyword in ["drop", "delete", "truncate", "alter", "update", "merge", "replace", "insert", "create"] {
+            let sql = format!("SELECT 1 AS `{keyword}`");
+            assert!(!contains_dangerous_sql_keyword(&sql), "expected safe SQL: {sql}");
+        }
+        assert!(!contains_dangerous_sql_keyword("SELECT 1 AS `before``delete`"));
+    }
+
+    #[test]
+    fn is_write_sql_detects_simple_writes() {
+        assert!(is_write_sql("INSERT INTO users VALUES (1)"));
+        assert!(is_write_sql("UPDATE users SET name = 'x'"));
+        assert!(is_write_sql("DELETE FROM users"));
+        assert!(is_write_sql("DROP TABLE users"));
+        assert!(is_write_sql("CREATE TABLE users (id INT)"));
+        assert!(is_write_sql("ALTER TABLE users ADD COLUMN age INT"));
+        assert!(is_write_sql("TRUNCATE TABLE users"));
+        assert!(is_write_sql("EXPLAIN ANALYZE DELETE FROM users"));
+        assert!(is_write_sql("SELECT * INTO backup_users FROM users"));
+        assert!(is_write_sql("SELECT * FROM users INTO OUTFILE '/tmp/users.csv'"));
+        assert!(is_write_sql("COPY users FROM '/tmp/users.csv'"));
+        assert!(is_write_sql("/*! DELETE FROM users */"));
+        assert!(is_write_sql(
+            "MERGE INTO target USING source ON t.id = s.id WHEN MATCHED THEN UPDATE SET t.name = s.name"
+        ));
+        assert!(is_write_sql("REPLACE INTO users VALUES (1)"));
+    }
+
+    #[test]
+    fn is_write_sql_allows_reads() {
+        assert!(!is_write_sql("SELECT * FROM users"));
+        assert!(!is_write_sql("SELECT id, name FROM users WHERE active = true"));
+        assert!(!is_write_sql("WITH cte AS (SELECT 1) SELECT * FROM cte"));
+        assert!(!is_write_sql("SHOW TABLES"));
+        assert!(!is_write_sql("DESCRIBE users"));
+        assert!(!is_write_sql("DESC users"));
+        assert!(!is_write_sql("EXPLAIN SELECT * FROM users"));
+        assert!(!is_write_sql("PRAGMA table_info(users)"));
+        assert!(!is_write_sql("FROM users SELECT *"));
+    }
+
+    #[test]
+    fn is_write_sql_allows_backtick_identifiers_with_dangerous_keywords() {
+        for keyword in ["drop", "delete", "truncate", "alter", "update", "merge", "replace", "insert", "create"] {
+            let sql = format!("SELECT 1 AS `{keyword}`");
+            assert!(!is_write_sql(&sql), "expected read-only SQL: {sql}");
+        }
+        assert!(!is_write_sql("SHOW COLUMNS FROM `delete`"));
+        assert!(!is_write_sql("DESC `delete`"));
+        assert!(!is_write_sql("SELECT 1 AS `before``delete`"));
+        assert!(!is_write_sql("SELECT 1 AS `semi;delete`; SELECT 2"));
+    }
+
+    #[test]
+    fn is_write_sql_still_blocks_writes_with_backtick_identifiers() {
+        assert!(is_write_sql("DELETE FROM `users`"));
+        assert!(is_write_sql("DROP TABLE `users`"));
+        assert!(is_write_sql("UPDATE `users` SET name = 'Ada'"));
+    }
+
+    #[test]
+    fn is_write_sql_allows_show_create_statements() {
+        for sql in [
+            "SHOW CREATE TABLE users",
+            "show create view active_users",
+            "SHOW CREATE PROCEDURE refresh_users",
+            "SHOW CREATE FUNCTION user_count",
+            "  /* metadata */\nSHOW\nCREATE TABLE users;",
+            "SHOW CREATE TABLE users; SELECT ';' AS separator",
+            "SHOW CREATE TABLE users /* ; DELETE FROM users */",
+        ] {
+            assert!(!is_write_sql(sql), "expected read-only SQL: {sql}");
+        }
+    }
+
+    #[test]
+    fn is_write_sql_blocks_writes_after_show_create() {
+        for write_sql in [
+            "DROP TABLE users",
+            "DELETE FROM users",
+            "TRUNCATE TABLE users",
+            "ALTER TABLE users ADD COLUMN active BOOLEAN",
+            "UPDATE users SET active = true",
+            "MERGE INTO users USING source ON users.id = source.id WHEN MATCHED THEN UPDATE SET active = true",
+            "REPLACE INTO users VALUES (1)",
+            "INSERT INTO users VALUES (1)",
+            "CREATE TABLE audit (id INT)",
+        ] {
+            let sql = format!("SHOW CREATE TABLE users; {write_sql}");
+            assert!(is_write_sql(&sql), "expected write SQL: {sql}");
+        }
+    }
+
+    #[test]
+    fn is_write_sql_ignores_leading_whitespace_and_comments() {
+        assert!(!is_write_sql("   /* comment */ SELECT * FROM users"));
+        assert!(!is_write_sql("-- comment\nSELECT * FROM users"));
+        assert!(is_write_sql("   /* comment */ INSERT INTO users VALUES (1)"));
+    }
+
+    #[test]
+    fn is_write_sql_blocks_mysql_and_mariadb_executable_comments() {
+        for sql in [
+            "SELECT 3156 /*! INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt' */",
+            "SELECT 3156 /*!50000 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt' */",
+            "SELECT 3156 /*M! INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt' */",
+            "SELECT 3156 /*M!100100 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt' */",
+        ] {
+            assert!(is_write_sql_for_database(sql, DatabaseType::Mysql), "expected write SQL: {sql}");
+        }
+
+        assert!(!is_write_sql_for_database(
+            "SELECT 3156 /* INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt' */",
+            DatabaseType::Mysql
+        ));
+        assert!(!is_write_sql_for_database(
+            "SELECT '/*!50000 INTO OUTFILE \'/tmp/probe\' */' AS note",
+            DatabaseType::Mysql
+        ));
+    }
+
+    #[test]
+    fn is_write_sql_treats_mysql_executable_comment_syntax_as_plain_for_other_dialects() {
+        for database_type in [DatabaseType::Postgres, DatabaseType::Sqlite] {
+            for sql in [
+                "SELECT 3156 /*!50000 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt' */",
+                "SELECT 3156 /*M!100100 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt' */",
+                "SELECT 3156 /* ordinary block comment */",
+            ] {
+                assert!(
+                    !is_write_sql_for_database(sql, database_type),
+                    "expected read-only SQL for {database_type:?}: {sql}"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn is_write_sql_blocks_dialect_specific_select_into_writes() {
+        for sql in [
+            "SELECT 3156 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt'",
+            "SELECT 3156 INTO DUMPFILE '/var/lib/mysql-files/dbx_ro_probe.bin'",
+            "WITH probe AS (SELECT 3156) SELECT * FROM probe INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt'",
+        ] {
+            assert!(is_write_sql_for_database(sql, DatabaseType::Mysql), "expected write SQL: {sql}");
+        }
+
+        for database_type in [
+            DatabaseType::Postgres,
+            DatabaseType::Redshift,
+            DatabaseType::Gaussdb,
+            DatabaseType::OpenGauss,
+            DatabaseType::Kingbase,
+            DatabaseType::Highgo,
+            DatabaseType::Vastbase,
+            DatabaseType::Kwdb,
+        ] {
+            for sql in [
+                "SELECT * INTO copied_users FROM users",
+                "WITH active AS (SELECT * FROM users WHERE active) SELECT * INTO active_users FROM active",
+            ] {
+                assert!(
+                    is_write_sql_for_database(sql, database_type),
+                    "expected write SQL for {database_type:?}: {sql}"
+                );
+            }
+        }
+
+        for sql in [
+            "SELECT * INTO dbo.copied_users FROM dbo.users",
+            "WITH active AS (SELECT * FROM users WHERE active = 1) SELECT * INTO #active_users FROM active",
+        ] {
+            assert!(is_write_sql_for_database(sql, DatabaseType::SqlServer), "expected write SQL: {sql}");
+        }
+    }
+
+    #[test]
+    fn is_write_sql_does_not_globally_block_into() {
+        for sql in [
+            "SELECT 3156 INTO @probe",
+            "SELECT 'INTO OUTFILE /tmp/probe' AS note",
+            "SELECT 3156 /* INTO OUTFILE '/tmp/probe' */",
+            "SELECT 1 AS `into`, 2 AS `outfile`",
+        ] {
+            assert!(!is_write_sql_for_database(sql, DatabaseType::Mysql), "expected read-only SQL: {sql}");
+        }
+
+        for sql in
+            ["SELECT 'INTO copied_users' AS note", "SELECT $$INTO copied_users$$ AS note", "SELECT 1 AS \"into\""]
+        {
+            assert!(!is_write_sql_for_database(sql, DatabaseType::Postgres), "expected read-only SQL: {sql}");
+        }
+
+        assert!(!is_write_sql_for_database("SELECT 1 AS [into]", DatabaseType::SqlServer));
+        assert!(!is_write_sql_for_database("SELECT 1 INTO unsupported", DatabaseType::Sqlite));
+    }
+
+    #[test]
+    fn is_write_sql_cte_with_nested_write() {
+        // CTE starting with WITH but containing a write operation inside
+        assert!(is_write_sql("WITH deleted AS (DELETE FROM users RETURNING id) SELECT * FROM deleted"));
+        assert!(is_write_sql("WITH updated AS (UPDATE users SET name = 'x' RETURNING id) SELECT * FROM updated"));
+        assert!(is_write_sql("WITH inserted AS (INSERT INTO users VALUES (1) RETURNING id) SELECT * FROM inserted"));
+        // Pure read CTE should be allowed
+        assert!(!is_write_sql("WITH cte AS (SELECT * FROM users) SELECT * FROM cte"));
+    }
+
+    #[test]
+    fn is_write_sql_case_insensitive() {
+        assert!(!is_write_sql("select * from users"));
+        assert!(!is_write_sql("Select * From users"));
+        assert!(is_write_sql("insert into users values (1)"));
+        assert!(is_write_sql("Insert Into users Values (1)"));
+        assert!(is_write_sql("update users set name = 'x'"));
+    }
+
+    #[test]
+    fn is_write_sql_edge_cases() {
+        assert!(!is_write_sql("")); // empty string -> not a write
+        assert!(!is_write_sql("   ")); // whitespace only -> not a write
+        assert!(is_write_sql("COMMIT")); // not a recognized read keyword
+        assert!(is_write_sql("ROLLBACK")); // not a recognized read keyword
+        assert!(is_write_sql("BEGIN")); // not a recognized read keyword
+        assert!(is_write_sql("GRANT SELECT ON users TO admin"));
+        assert!(is_write_sql("REVOKE SELECT ON users FROM admin"));
+    }
+
+    #[test]
+    fn is_write_sql_blocks_stored_procedure_calls() {
+        // CALL and EXEC don't start with a read keyword, so they are treated as writes
+        assert!(is_write_sql("CALL my_procedure(1, 2)"));
+        assert!(is_write_sql("call my_procedure()"));
+        assert!(is_write_sql("EXEC sp_update_stats"));
+        assert!(is_write_sql("EXECUTE sp_rename 'old', 'new'"));
+        assert!(is_write_sql("execute my_func()"));
+    }
+
+    #[test]
+    fn is_write_sql_allows_safe_read_pragmas() {
+        // Read-only PRAGMA forms (function-call style with known safe names) are allowed
+        assert!(!is_write_sql("PRAGMA table_info(users)"));
+        assert!(!is_write_sql("PRAGMA table_xinfo(users)"));
+        assert!(!is_write_sql("PRAGMA index_list(users)"));
+        assert!(!is_write_sql("PRAGMA index_info(idx_name)"));
+        assert!(!is_write_sql("PRAGMA foreign_key_list(users)"));
+        assert!(!is_write_sql("PRAGMA database_list"));
+        assert!(!is_write_sql("PRAGMA compile_options"));
+        assert!(!is_write_sql("PRAGMA data_version"));
+        assert!(!is_write_sql("pragma table_info(users)"));
+    }
+
+    #[test]
+    fn is_write_sql_blocks_unsafe_pragmas() {
+        // Assignment forms are always blocked
+        assert!(is_write_sql("PRAGMA journal_mode = WAL"));
+        assert!(is_write_sql("PRAGMA synchronous = OFF"));
+        assert!(is_write_sql("PRAGMA foreign_keys = ON"));
+        assert!(is_write_sql("PRAGMA cache_size = -2000"));
+        assert!(is_write_sql("PRAGMA user_version = 123"));
+        // Unknown PRAGMA names are blocked
+        assert!(is_write_sql("PRAGMA writable_schema = ON"));
+        assert!(is_write_sql("PRAGMA locking_mode = EXCLUSIVE"));
+        assert!(is_write_sql("PRAGMA temp_store = MEMORY"));
+        assert!(is_write_sql("PRAGMA some_unknown_pragma"));
+    }
+
+    #[test]
+    fn is_write_sql_string_literal_hides_keywords() {
+        // The dangerous keyword is inside a string literal, so it should NOT be detected
+        assert!(!is_write_sql("SELECT 'DROP TABLE users' AS hint FROM t"));
+        assert!(!is_write_sql("SELECT * FROM t WHERE name = 'delete'"));
+    }
+
+    #[test]
+    fn check_read_only_success_and_error() {
+        assert_eq!(check_read_only("SELECT * FROM users", "prod-db", DatabaseType::Mysql), Ok(()));
+        assert_eq!(check_read_only("WITH cte AS (SELECT 1) SELECT * FROM cte", "prod-db", DatabaseType::Mysql), Ok(()));
+        assert_eq!(check_read_only("SHOW CREATE TABLE users", "prod-db", DatabaseType::Mysql), Ok(()));
+        assert_eq!(check_read_only("SELECT 1 AS `delete`", "prod-db", DatabaseType::Mysql), Ok(()));
+
+        let err = check_read_only("DELETE FROM users", "prod-db", DatabaseType::Mysql);
+        assert!(err.is_err());
+        assert_eq!(
+            err.unwrap_err(),
+            "Read-only mode: connection 'prod-db' has read-only protection enabled. Write operation (including stored procedure calls) blocked."
+        );
+
+        let err2 = check_read_only("UPDATE users SET name = 'x'", "reporting-db", DatabaseType::Mysql);
+        assert!(err2.is_err());
+        assert!(err2.unwrap_err().contains("reporting-db"));
+
+        let show_create_err =
+            check_read_only("SHOW CREATE TABLE users; DELETE FROM users", "prod-db", DatabaseType::Mysql);
+        assert!(show_create_err.is_err());
+        assert!(show_create_err.unwrap_err().contains("Write operation"));
+    }
+
+    #[test]
+    fn check_read_only_only_treats_executable_comments_as_writes_for_mysql_compatible_connections() {
+        let mysql_executable_comment = "SELECT 3156 /*!50000 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt' */";
+        let mariadb_executable_comment =
+            "SELECT 3156 /*M!100100 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt' */";
+
+        assert!(check_read_only(mysql_executable_comment, "mysql", DatabaseType::Mysql).is_err());
+        assert!(check_read_only(mariadb_executable_comment, "mariadb", DatabaseType::Mysql).is_err());
+
+        for database_type in [DatabaseType::Postgres, DatabaseType::Sqlite] {
+            assert_eq!(check_read_only(mysql_executable_comment, "readonly", database_type), Ok(()));
+            assert_eq!(check_read_only(mariadb_executable_comment, "readonly", database_type), Ok(()));
+        }
+    }
+
+    #[test]
+    fn check_read_only_blocks_dialect_specific_select_into_writes() {
+        for (sql, database_type) in [
+            ("SELECT 3156 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt'", DatabaseType::Mysql),
+            ("SELECT * INTO copied_users FROM users", DatabaseType::Postgres),
+            ("SELECT * INTO copied_users FROM users", DatabaseType::Redshift),
+            ("SELECT * INTO copied_users FROM users", DatabaseType::Gaussdb),
+            ("SELECT * INTO copied_users FROM users", DatabaseType::OpenGauss),
+            ("SELECT * INTO copied_users FROM users", DatabaseType::Kingbase),
+            ("SELECT * INTO copied_users FROM users", DatabaseType::Highgo),
+            ("SELECT * INTO copied_users FROM users", DatabaseType::Vastbase),
+            ("SELECT * INTO copied_users FROM users", DatabaseType::Kwdb),
+            ("SELECT * INTO #copied_users FROM users", DatabaseType::SqlServer),
+        ] {
+            assert!(check_read_only(sql, "readonly", database_type).is_err(), "expected blocked SQL: {sql}");
+        }
+    }
+
+    #[test]
+    fn strip_sql_comments_basic() {
+        assert_eq!(strip_sql_comments("SELECT 1"), "SELECT 1");
+        assert_eq!(strip_sql_comments("-- comment\nSELECT 1"), " SELECT 1");
+        assert_eq!(strip_sql_comments("/* block */ SELECT 1"), "  SELECT 1");
+        assert_eq!(strip_sql_comments("# comment\nSELECT 1"), " SELECT 1");
+    }
+
+    #[test]
+    fn strip_sql_comments_preserves_strings() {
+        // strip_sql_comments does NOT handle string delimiters, so it strips
+        // comments even inside string literals
+        assert_eq!(strip_sql_comments("SELECT 'hello /* not a comment */'"), "SELECT 'hello  '");
+    }
+}
diff --git a/crates/dbx-core/src/query_result_export.rs b/crates/dbx-core/src/query_result_export.rs
new file mode 100644
index 0000000..d9d510b
--- /dev/null
+++ b/crates/dbx-core/src/query_result_export.rs
@@ -0,0 +1,1468 @@
+use serde::{Deserialize, Serialize};
+use std::fs::File;
+use std::io::{BufWriter, Write};
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+use std::time::{Duration, Instant};
+
+use crate::connection::{AppState, PoolKind};
+use crate::csv_export::{format_query_result_csv, format_query_result_csv_rows};
+use crate::database_export::is_export_cancelled;
+pub use crate::database_export::ExportStatus;
+use crate::models::connection::DatabaseType;
+use crate::query::{
+    canceled_error, close_query_session, execute_sql_statement_with_options, operation_budget_for_pool_key,
+    QueryExecutionOptions, QUERY_CANCELED,
+};
+use crate::query_result_sql::{
+    build_query_pagination_execution_plan, QueryPagination, QueryPaginationExecutionPlanOptions,
+};
+use crate::table_export::TableExportProgress;
+use crate::transfer::keyset_pagination_sql;
+use crate::xlsx_export::{finish_streaming_xlsx_workbook, start_streaming_xlsx_workbook};
+use serde_json::Value;
+use sqlparser::ast::{GroupByExpr, ObjectNamePart, OrderByKind, SelectItem, SetExpr, Statement, TableFactor};
+use sqlparser::dialect::GenericDialect;
+use sqlparser::parser::Parser;
+use tokio_util::sync::CancellationToken;
+
+const AGENT_UNBOUNDED_ROW_LIMIT: usize = i32::MAX as usize;
+pub const XLSX_MAX_DATA_ROWS: usize = 1_048_575;
+const XLSX_ROW_LIMIT_ERROR: &str = "XLSX 最多支持 1,048,575 行数据，请改用 CSV 导出完整结果。";
+const STREAMING_PAGINATION_UNSUPPORTED_ERROR: &str = "当前查询暂不支持流式导出，请简化查询或使用受支持的驱动。";
+const AGENT_SESSION_MISSING_ERROR: &str = "查询结果流式导出需要驱动返回结果集会话，但当前驱动未返回 session_id。";
+const STREAM_PROGRESS_TIME_INTERVAL: Duration = Duration::from_secs(1);
+
+async fn disconnect_with_timeout<C, F, Fut>(
+    connection: C,
+    cleanup_timeout: Duration,
+    disconnect: F,
+) -> Result<Result<(), String>, tokio::time::error::Elapsed>
+where
+    F: FnOnce(C) -> Fut,
+    Fut: std::future::Future<Output = Result<(), String>>,
+{
+    tokio::time::timeout(cleanup_timeout, disconnect(connection)).await
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryResultExportRequest {
+    pub export_id: String,
+    pub connection_id: String,
+    pub database: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub sql: String,
+    pub query_base_sql: String,
+    pub database_type: DatabaseType,
+    #[serde(default)]
+    pub use_agent_cursor: bool,
+    pub file_path: String,
+    pub format: String,
+    pub page_size: usize,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub row_limit: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub total_rows: Option<u64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub timeout_secs: Option<u64>,
+    #[serde(default)]
+    pub keyset_optimization_enabled: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub client_session_id: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub execution_id: Option<String>,
+}
+
+fn progress(
+    request: &QueryResultExportRequest,
+    rows_exported: u64,
+    status: ExportStatus,
+    error_message: Option<String>,
+) -> TableExportProgress {
+    let total_rows = request.total_rows.map(|total| {
+        let format = request.format.to_lowercase();
+        let limit = effective_row_limit(&format, request);
+        limit.map_or(total, |limit| total.min(limit as u64))
+    });
+    TableExportProgress {
+        export_id: request.export_id.clone(),
+        table_name: String::new(),
+        rows_exported,
+        total_rows,
+        status,
+        error_message,
+    }
+}
+
+fn effective_row_limit(format: &str, request: &QueryResultExportRequest) -> Option<usize> {
+    if format == "xlsx" {
+        Some(request.row_limit.map_or(XLSX_MAX_DATA_ROWS, |limit| limit.min(XLSX_MAX_DATA_ROWS)))
+    } else {
+        request.row_limit
+    }
+}
+
+fn xlsx_hard_limit_active(format: &str, request: &QueryResultExportRequest) -> bool {
+    format == "xlsx" && request.row_limit.map_or(true, |limit| limit > XLSX_MAX_DATA_ROWS)
+}
+
+fn should_emit_stream_progress(
+    rows_exported: u64,
+    last_progress_rows: u64,
+    row_interval: u64,
+    elapsed_since_last_progress: Duration,
+) -> bool {
+    rows_exported > last_progress_rows
+        && (rows_exported.saturating_sub(last_progress_rows) >= row_interval.max(1)
+            || elapsed_since_last_progress >= STREAM_PROGRESS_TIME_INTERVAL)
+}
+
+fn query_export_timeout(timeout_secs: Option<u64>) -> Option<Duration> {
+    match timeout_secs {
+        Some(0) => None,
+        Some(seconds) => Some(Duration::from_secs(seconds)),
+        None => Some(Duration::from_secs(30)),
+    }
+}
+
+fn should_fetch_next_page(
+    use_agent_result_session: bool,
+    has_more: bool,
+    fetched_row_count: usize,
+    written_row_count: usize,
+    requested_page_size: usize,
+) -> bool {
+    if use_agent_result_session {
+        has_more
+    } else {
+        fetched_row_count > written_row_count || written_row_count >= requested_page_size
+    }
+}
+
+fn supports_streaming_offset_pagination(request: &QueryResultExportRequest, page_size: usize) -> bool {
+    let first_page = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {
+        sql: request.sql.clone(),
+        query_base_sql: request.query_base_sql.clone(),
+        database_type: Some(request.database_type),
+        pagination: QueryPagination { limit: page_size, offset: 0, session_id: None },
+        use_agent_cursor: false,
+        first_page_uses_actual_sql: true,
+    });
+    let second_page = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {
+        sql: request.sql.clone(),
+        query_base_sql: request.query_base_sql.clone(),
+        database_type: Some(request.database_type),
+        pagination: QueryPagination { limit: page_size, offset: page_size, session_id: None },
+        use_agent_cursor: false,
+        first_page_uses_actual_sql: true,
+    });
+
+    let (Some(first_sql), Some(second_sql)) = (first_page.page_sql.as_deref(), second_page.page_sql.as_deref()) else {
+        return false;
+    };
+    first_page.page_limit.is_some()
+        && second_page.page_limit.is_some()
+        && !first_sql.trim().eq_ignore_ascii_case(second_sql.trim())
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct SafeKeysetCandidate {
+    schema: Option<String>,
+    table: String,
+}
+
+struct KeysetPlan {
+    columns: Vec<String>,
+    primary_keys: Vec<String>,
+    pk_indices: Vec<usize>,
+    schema: String,
+    table: String,
+    last_pk_values: Vec<Value>,
+}
+
+fn object_name_parts(name: &sqlparser::ast::ObjectName) -> Option<Vec<String>> {
+    name.0
+        .iter()
+        .map(|part| match part {
+            ObjectNamePart::Identifier(ident) => Some(ident.value.clone()),
+            _ => None,
+        })
+        .collect()
+}
+
+fn safe_keyset_candidate(sql: &str) -> Option<SafeKeysetCandidate> {
+    let dialect = GenericDialect {};
+    let statements = Parser::parse_sql(&dialect, sql).ok()?;
+    let [Statement::Query(query)] = statements.as_slice() else {
+        return None;
+    };
+    if query.with.is_some()
+        || query.limit_clause.is_some()
+        || query.fetch.is_some()
+        || !query.locks.is_empty()
+        || query.for_clause.is_some()
+        || query.settings.is_some()
+        || query.format_clause.is_some()
+        || !query.pipe_operators.is_empty()
+        || query
+            .order_by
+            .as_ref()
+            .is_some_and(|order_by| !matches!(&order_by.kind, OrderByKind::Expressions(exprs) if exprs.is_empty()))
+    {
+        return None;
+    }
+    let SetExpr::Select(select) = query.body.as_ref() else {
+        return None;
+    };
+    if select.distinct.is_some()
+        || !matches!(&select.group_by, GroupByExpr::Expressions(exprs, _) if exprs.is_empty())
+        || select.having.is_some()
+        || select.selection.is_some()
+        || select.from.len() != 1
+        || !(select.projection.len() == 1 && matches!(select.projection.first(), Some(SelectItem::Wildcard(_))))
+    {
+        return None;
+    }
+    let source = &select.from[0];
+    if !source.joins.is_empty() {
+        return None;
+    }
+    let TableFactor::Table { name, .. } = &source.relation else {
+        return None;
+    };
+    let parts = object_name_parts(name)?;
+    match parts.as_slice() {
+        [table] => Some(SafeKeysetCandidate { schema: None, table: table.clone() }),
+        [schema, table] => Some(SafeKeysetCandidate { schema: Some(schema.clone()), table: table.clone() }),
+        _ => None,
+    }
+}
+
+async fn build_keyset_plan(state: &AppState, request: &QueryResultExportRequest) -> Option<KeysetPlan> {
+    if !request.keyset_optimization_enabled || request.use_agent_cursor {
+        return None;
+    }
+    let candidate = safe_keyset_candidate(&request.sql)?;
+    let schema = candidate.schema.or_else(|| request.schema.clone()).unwrap_or_default();
+    let columns =
+        crate::schema::get_columns_core(state, &request.connection_id, &request.database, &schema, &candidate.table)
+            .await
+            .ok()?;
+    let col_names: Vec<String> = columns.iter().map(|column| column.name.clone()).collect();
+    let primary_keys: Vec<String> =
+        columns.iter().filter(|column| column.is_primary_key).map(|column| column.name.clone()).collect();
+    if col_names.is_empty() || primary_keys.is_empty() {
+        return None;
+    }
+    let pk_indices: Vec<usize> = primary_keys
+        .iter()
+        .filter_map(|pk| col_names.iter().position(|column| column.eq_ignore_ascii_case(pk)))
+        .collect();
+    if pk_indices.len() != primary_keys.len() {
+        return None;
+    }
+    Some(KeysetPlan {
+        columns: col_names,
+        primary_keys,
+        pk_indices,
+        schema,
+        table: candidate.table,
+        last_pk_values: Vec::new(),
+    })
+}
+
+pub async fn export_query_result_core(
+    state: &AppState,
+    request: &QueryResultExportRequest,
+    cancel_token: Option<CancellationToken>,
+    on_progress: impl Fn(TableExportProgress),
+) -> Result<(), String> {
+    let mut session_id: Option<String> = None;
+    let result = export_query_result_core_inner(state, request, cancel_token, &on_progress, &mut session_id).await;
+
+    if let Some(session_id) = session_id {
+        let _ = close_query_session(
+            state,
+            &request.connection_id,
+            &request.database,
+            &session_id,
+            request.client_session_id.as_deref(),
+        )
+        .await;
+    }
+    if let Some(client_session_id) = request.client_session_id.as_deref() {
+        let database = request.database.trim();
+        let database = if database.is_empty() { None } else { Some(database) };
+        let _ = state.close_client_session_pool(&request.connection_id, database, client_session_id).await;
+    }
+
+    result
+}
+
+async fn export_query_result_core_inner(
+    state: &AppState,
+    request: &QueryResultExportRequest,
+    cancel_token: Option<CancellationToken>,
+    on_progress: &impl Fn(TableExportProgress),
+    session_id: &mut Option<String>,
+) -> Result<(), String> {
+    let format = request.format.to_lowercase();
+    if format != "csv" && format != "xlsx" {
+        return Err(format!("Unsupported streaming query-result export format: {format}"));
+    }
+
+    let page_size = request.page_size.max(1);
+    let effective_row_limit = effective_row_limit(&format, request);
+    let xlsx_hard_limit_active = xlsx_hard_limit_active(&format, request);
+    if xlsx_hard_limit_active && request.total_rows.is_some_and(|total| total > XLSX_MAX_DATA_ROWS as u64) {
+        return Err(XLSX_ROW_LIMIT_ERROR.to_string());
+    }
+
+    let agent_max_rows = if xlsx_hard_limit_active {
+        XLSX_MAX_DATA_ROWS + 1
+    } else {
+        effective_row_limit.unwrap_or(AGENT_UNBOUNDED_ROW_LIMIT)
+    }
+    .max(1);
+
+    on_progress(progress(request, 0, ExportStatus::Running, None));
+
+    if try_export_postgres_query_result_stream(state, request, &format, cancel_token.clone(), on_progress).await? {
+        return Ok(());
+    }
+
+    if try_export_sqlserver_query_result_stream(state, request, &format, cancel_token.clone(), on_progress).await? {
+        return Ok(());
+    }
+
+    // MySQL does not guarantee a stable row order for independent LIMIT/OFFSET
+    // executions without ORDER BY, so query-result export must stream one run.
+    if try_export_mysql_query_result_stream(state, request, &format, cancel_token.clone(), on_progress).await? {
+        return Ok(());
+    }
+
+    // ClickHouse HTTP pagination is unsafe for unsorted result sets; stream one
+    // response so large exports preserve the server's single execution order.
+    if try_export_clickhouse_query_result_stream(state, request, &format, cancel_token.clone(), on_progress).await? {
+        return Ok(());
+    }
+
+    let mut csv_file = if format == "csv" {
+        Some(BufWriter::new(File::create(&request.file_path).map_err(|e| format!("Failed to create file: {e}"))?))
+    } else {
+        None
+    };
+    if let Some(file) = csv_file.as_mut() {
+        file.write_all(b"\xEF\xBB\xBF").map_err(|e| format!("Failed to write BOM: {e}"))?;
+    }
+
+    let mut xlsx = None;
+    let mut columns: Vec<String> = Vec::new();
+    let mut column_types: Vec<String> = Vec::new();
+    let mut rows_exported: u64 = 0;
+    let mut offset: usize = 0;
+    let mut wrote_csv_header = false;
+    let mut keyset_plan = build_keyset_plan(state, request).await;
+    if keyset_plan.is_none() && !request.use_agent_cursor && !supports_streaming_offset_pagination(request, page_size) {
+        return Err(STREAMING_PAGINATION_UNSUPPORTED_ERROR.to_string());
+    }
+
+    loop {
+        if cancel_token.as_ref().is_some_and(|token| token.is_cancelled())
+            || is_export_cancelled(&request.export_id).await
+        {
+            on_progress(progress(
+                request,
+                rows_exported,
+                ExportStatus::Cancelled,
+                Some("Export cancelled".to_string()),
+            ));
+            return Ok(());
+        }
+
+        let remaining = effective_row_limit.map(|limit| limit.saturating_sub(rows_exported as usize));
+        if matches!(remaining, Some(0)) {
+            break;
+        }
+        let this_page = remaining.map_or(page_size, |rem| rem.min(page_size)).max(1);
+        let fetch_limit = if xlsx_hard_limit_active && remaining.is_some_and(|rem| rem <= page_size) {
+            this_page.saturating_add(1)
+        } else {
+            this_page
+        };
+
+        let (sql_to_execute, plan_limit, use_agent_result_session) = if let Some(plan) = keyset_plan.as_ref() {
+            (
+                keyset_pagination_sql(
+                    &plan.columns,
+                    &plan.table,
+                    &plan.schema,
+                    &request.database_type,
+                    &plan.primary_keys,
+                    &plan.last_pk_values,
+                    fetch_limit,
+                ),
+                fetch_limit,
+                false,
+            )
+        } else {
+            let plan = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {
+                sql: request.sql.clone(),
+                query_base_sql: request.query_base_sql.clone(),
+                database_type: Some(request.database_type),
+                pagination: QueryPagination { limit: fetch_limit, offset, session_id: session_id.clone() },
+                use_agent_cursor: request.use_agent_cursor,
+                first_page_uses_actual_sql: true,
+            });
+            let Some(plan_limit) = plan.page_limit else {
+                return Err("Failed to build query pagination plan for export".to_string());
+            };
+            (plan.sql_to_execute, plan_limit, plan.use_agent_result_session)
+        };
+
+        let options = if use_agent_result_session {
+            QueryExecutionOptions {
+                page_size: Some(plan_limit),
+                fetch_size: Some(plan_limit),
+                result_session_id: session_id.clone(),
+                max_rows: Some(agent_max_rows),
+                timeout_secs: request.timeout_secs,
+                client_session_id: request.client_session_id.clone(),
+                execution_id: request.execution_id.clone(),
+                ..Default::default()
+            }
+        } else {
+            QueryExecutionOptions {
+                max_rows: Some(plan_limit),
+                fetch_size: Some(plan_limit),
+                timeout_secs: request.timeout_secs,
+                client_session_id: request.client_session_id.clone(),
+                execution_id: request.execution_id.clone(),
+                ..Default::default()
+            }
+        };
+
+        let mut result = match execute_sql_statement_with_options(
+            state,
+            &request.connection_id,
+            &request.database,
+            &sql_to_execute,
+            request.schema.as_deref(),
+            cancel_token.clone(),
+            options,
+        )
+        .await
+        {
+            Ok(result) => result,
+            Err(error) => {
+                if error == QUERY_CANCELED
+                    || cancel_token.as_ref().is_some_and(|token| token.is_cancelled())
+                    || is_export_cancelled(&request.export_id).await
+                {
+                    on_progress(progress(
+                        request,
+                        rows_exported,
+                        ExportStatus::Cancelled,
+                        Some("Export cancelled".to_string()),
+                    ));
+                    return Ok(());
+                }
+                return Err(error);
+            }
+        };
+
+        if cancel_token.as_ref().is_some_and(|token| token.is_cancelled())
+            || is_export_cancelled(&request.export_id).await
+        {
+            on_progress(progress(
+                request,
+                rows_exported,
+                ExportStatus::Cancelled,
+                Some("Export cancelled".to_string()),
+            ));
+            return Ok(());
+        }
+
+        if columns.is_empty() {
+            columns = result.columns.clone();
+            column_types = result.column_types.clone();
+        }
+        let fetched_row_count = result.rows.len();
+        if xlsx_hard_limit_active {
+            let remaining_rows = XLSX_MAX_DATA_ROWS.saturating_sub(rows_exported as usize);
+            if fetched_row_count > remaining_rows {
+                return Err(XLSX_ROW_LIMIT_ERROR.to_string());
+            }
+        }
+        if result.rows.len() > this_page {
+            result.rows.truncate(this_page);
+        }
+        let row_count = result.rows.len();
+
+        if format == "csv" {
+            if let Some(file) = csv_file.as_mut() {
+                if !wrote_csv_header {
+                    let csv = format_query_result_csv(&columns, &result.rows);
+                    file.write_all(csv.as_bytes()).map_err(|e| format!("Failed to write CSV: {e}"))?;
+                    wrote_csv_header = true;
+                } else if row_count > 0 {
+                    let rows_csv = format_query_result_csv_rows(&result.rows);
+                    write!(file, "\n{rows_csv}").map_err(|e| format!("Failed to write CSV rows: {e}"))?;
+                }
+            }
+        } else {
+            if xlsx.is_none() {
+                let xlsx_file =
+                    File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+                xlsx = Some(start_streaming_xlsx_workbook(
+                    BufWriter::new(xlsx_file),
+                    Some("Result"),
+                    &columns,
+                    &column_types,
+                )?);
+            }
+            if let Some(writer) = xlsx.as_mut() {
+                for row in &result.rows {
+                    writer.write_row(row).map_err(|e| format!("Failed to write XLSX row: {e}"))?;
+                }
+            }
+        }
+
+        rows_exported += row_count as u64;
+        on_progress(progress(request, rows_exported, ExportStatus::Running, None));
+
+        if result.session_id.is_some() {
+            *session_id = result.session_id.clone();
+        }
+        if use_agent_result_session && result.has_more && session_id.is_none() {
+            return Err(AGENT_SESSION_MISSING_ERROR.to_string());
+        }
+        if let Some(plan) = keyset_plan.as_mut() {
+            if let Some(last_row) = result.rows.last() {
+                plan.last_pk_values =
+                    plan.pk_indices.iter().map(|&index| last_row.get(index).cloned().unwrap_or(Value::Null)).collect();
+            }
+        }
+        let should_continue =
+            should_fetch_next_page(use_agent_result_session, result.has_more, fetched_row_count, row_count, plan_limit);
+        if cancel_token.as_ref().is_some_and(|token| token.is_cancelled())
+            || is_export_cancelled(&request.export_id).await
+        {
+            on_progress(progress(
+                request,
+                rows_exported,
+                ExportStatus::Cancelled,
+                Some("Export cancelled".to_string()),
+            ));
+            return Ok(());
+        }
+        if !should_continue || row_count == 0 {
+            break;
+        }
+        offset += row_count;
+    }
+
+    on_progress(progress(request, rows_exported, ExportStatus::Writing, None));
+
+    if format == "csv" {
+        if !wrote_csv_header {
+            let csv = format_query_result_csv(&columns, &[]);
+            if let Some(file) = csv_file.as_mut() {
+                file.write_all(csv.as_bytes()).map_err(|e| format!("Failed to write CSV: {e}"))?;
+            }
+        }
+        if let Some(file) = csv_file.as_mut() {
+            file.flush().map_err(|e| format!("Failed to flush CSV file: {e}"))?;
+        }
+    } else if let Some(writer) = xlsx {
+        let mut buf =
+            finish_streaming_xlsx_workbook(writer).map_err(|e| format!("Failed to finalize XLSX file: {e}"))?;
+        buf.flush().map_err(|e| format!("Failed to flush XLSX file: {e}"))?;
+    } else {
+        let xlsx_file = File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+        let writer = start_streaming_xlsx_workbook(BufWriter::new(xlsx_file), Some("Result"), &columns, &column_types)?;
+        let mut buf =
+            finish_streaming_xlsx_workbook(writer).map_err(|e| format!("Failed to finalize XLSX file: {e}"))?;
+        buf.flush().map_err(|e| format!("Failed to flush XLSX file: {e}"))?;
+    }
+
+    on_progress(progress(request, rows_exported, ExportStatus::Done, None));
+    Ok(())
+}
+
+async fn try_export_postgres_query_result_stream(
+    state: &AppState,
+    request: &QueryResultExportRequest,
+    format: &str,
+    cancel_token: Option<CancellationToken>,
+    on_progress: &impl Fn(TableExportProgress),
+) -> Result<bool, String> {
+    if request.use_agent_cursor
+        || !crate::sql::starts_with_executable_sql_keyword(
+            &request.sql,
+            &["SELECT", "SHOW", "EXPLAIN", "WITH", "TABLE"],
+        )
+    {
+        return Ok(false);
+    }
+
+    let database = request.database.trim();
+    let pool_key = if database.is_empty() {
+        state.get_or_create_pool_for_session(&request.connection_id, None, request.client_session_id.as_deref()).await?
+    } else {
+        state
+            .get_or_create_pool_for_session(
+                &request.connection_id,
+                Some(database),
+                request.client_session_id.as_deref(),
+            )
+            .await?
+    };
+    let connections = state.connections.read().await;
+    let Some(pool) = connections.get(&pool_key).and_then(|pool| match pool {
+        PoolKind::Postgres(pool) => Some(pool.clone()),
+        _ => None,
+    }) else {
+        return Ok(false);
+    };
+    drop(connections);
+
+    if let Some(execution_id) = request.execution_id.as_deref() {
+        state.running_queries.set_pool_key(execution_id, pool_key.clone());
+    }
+    state.touch_pool_activity(&pool_key).await;
+    let _activity_touch = state.pool_activity_touch(&pool_key);
+
+    let xlsx_hard_limit_active = xlsx_hard_limit_active(format, request);
+    let row_limit = effective_row_limit(format, request);
+    let stream_row_limit =
+        if xlsx_hard_limit_active { row_limit.map(|limit| limit.saturating_add(1)) } else { row_limit };
+    let progress_row_interval = request.page_size.max(1) as u64;
+    let mut columns: Vec<String> = Vec::new();
+    let mut rows_exported = 0_u64;
+    let mut last_progress_rows = 0_u64;
+    let mut last_progress_at = Instant::now();
+    let mut csv_file = if format == "csv" {
+        let mut file =
+            BufWriter::new(File::create(&request.file_path).map_err(|e| format!("Failed to create file: {e}"))?);
+        file.write_all(b"\xEF\xBB\xBF").map_err(|e| format!("Failed to write BOM: {e}"))?;
+        Some(file)
+    } else {
+        None
+    };
+    let mut xlsx = None;
+    let budget = operation_budget_for_pool_key(state, &pool_key, query_export_timeout(request.timeout_secs)).await;
+    let cancel_context = state.get_postgres_cancel_context(&pool_key).await;
+
+    crate::db::postgres::stream_select_query_with_cancel(
+        &pool,
+        request.schema.as_deref(),
+        &request.sql,
+        stream_row_limit,
+        cancel_token,
+        budget,
+        cancel_context,
+        |item| {
+            match item {
+                crate::db::postgres::PostgresQueryStreamItem::Columns { columns: stream_columns, column_types } => {
+                    columns = stream_columns;
+                    if let Some(file) = csv_file.as_mut() {
+                        let csv = format_query_result_csv(&columns, &[]);
+                        let header = csv.strip_suffix('\n').unwrap_or(&csv);
+                        file.write_all(header.as_bytes()).map_err(|e| format!("Failed to write CSV: {e}"))?;
+                    } else {
+                        let xlsx_file =
+                            File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+                        xlsx = Some(start_streaming_xlsx_workbook(
+                            BufWriter::new(xlsx_file),
+                            Some("Result"),
+                            &columns,
+                            &column_types,
+                        )?);
+                    }
+                }
+                crate::db::postgres::PostgresQueryStreamItem::Row(row) => {
+                    if xlsx_hard_limit_active && rows_exported as usize >= XLSX_MAX_DATA_ROWS {
+                        return Err(XLSX_ROW_LIMIT_ERROR.to_string());
+                    }
+                    if let Some(file) = csv_file.as_mut() {
+                        let rows_csv = format_query_result_csv_rows(std::slice::from_ref(&row));
+                        write!(file, "\n{rows_csv}").map_err(|e| format!("Failed to write CSV rows: {e}"))?;
+                    } else if let Some(writer) = xlsx.as_mut() {
+                        writer.write_row(&row).map_err(|e| format!("Failed to write XLSX row: {e}"))?;
+                    } else {
+                        let xlsx_file =
+                            File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+                        xlsx = Some(start_streaming_xlsx_workbook(
+                            BufWriter::new(xlsx_file),
+                            Some("Result"),
+                            &columns,
+                            &[],
+                        )?);
+                        if let Some(writer) = xlsx.as_mut() {
+                            writer.write_row(&row).map_err(|e| format!("Failed to write XLSX row: {e}"))?;
+                        }
+                    }
+                    rows_exported += 1;
+                    let now = Instant::now();
+                    if should_emit_stream_progress(
+                        rows_exported,
+                        last_progress_rows,
+                        progress_row_interval,
+                        now.duration_since(last_progress_at),
+                    ) {
+                        on_progress(progress(request, rows_exported, ExportStatus::Running, None));
+                        last_progress_rows = rows_exported;
+                        last_progress_at = now;
+                    }
+                }
+            }
+            Ok(())
+        },
+    )
+    .await?;
+
+    if rows_exported != last_progress_rows {
+        on_progress(progress(request, rows_exported, ExportStatus::Running, None));
+    }
+    on_progress(progress(request, rows_exported, ExportStatus::Writing, None));
+    if let Some(file) = csv_file.as_mut() {
+        file.flush().map_err(|e| format!("Failed to flush CSV file: {e}"))?;
+    }
+    if let Some(writer) = xlsx {
+        let mut buf =
+            finish_streaming_xlsx_workbook(writer).map_err(|e| format!("Failed to finalize XLSX file: {e}"))?;
+        buf.flush().map_err(|e| format!("Failed to flush XLSX file: {e}"))?;
+    } else if format == "xlsx" {
+        let xlsx_file = File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+        let writer = start_streaming_xlsx_workbook(BufWriter::new(xlsx_file), Some("Result"), &columns, &[])?;
+        let mut buf =
+            finish_streaming_xlsx_workbook(writer).map_err(|e| format!("Failed to finalize XLSX file: {e}"))?;
+        buf.flush().map_err(|e| format!("Failed to flush XLSX file: {e}"))?;
+    }
+    on_progress(progress(request, rows_exported, ExportStatus::Done, None));
+    Ok(true)
+}
+
+async fn try_export_mysql_query_result_stream(
+    state: &AppState,
+    request: &QueryResultExportRequest,
+    format: &str,
+    cancel_token: Option<CancellationToken>,
+    on_progress: &impl Fn(TableExportProgress),
+) -> Result<bool, String> {
+    if request.use_agent_cursor {
+        return Ok(false);
+    }
+
+    let pool_key = if request.database.trim().is_empty() {
+        state.get_or_create_pool_for_session(&request.connection_id, None, request.client_session_id.as_deref()).await?
+    } else {
+        state
+            .get_or_create_pool_for_session(
+                &request.connection_id,
+                Some(request.database.as_str()),
+                request.client_session_id.as_deref(),
+            )
+            .await?
+    };
+    let connections = state.connections.read().await;
+    let Some((pool, bare)) = connections.get(&pool_key).and_then(|pool| match pool {
+        PoolKind::Mysql(pool, mode) => Some((pool.clone(), *mode == crate::connection::MysqlMode::Bare)),
+        _ => None,
+    }) else {
+        return Ok(false);
+    };
+    drop(connections);
+
+    if let Some(execution_id) = request.execution_id.as_deref() {
+        state.running_queries.set_pool_key(execution_id, pool_key.clone());
+    }
+    state.touch_pool_activity(&pool_key).await;
+    let _activity_touch = state.pool_activity_touch(&pool_key);
+
+    let (mysql_dialect, read_only_connection) = {
+        let configs = state.configs.read().await;
+        let config = configs.get(&request.connection_id);
+        (
+            config
+                .map(|config| {
+                    crate::db::mysql::MySqlQueryDialect::for_connection(
+                        config.db_type,
+                        config.driver_profile.as_deref(),
+                    )
+                })
+                .unwrap_or_default(),
+            config.filter(|config| config.read_only).map(|config| (config.name.clone(), config.db_type)),
+        )
+    };
+    if let Some((name, database_type)) = read_only_connection {
+        crate::query_execution_sql::check_read_only(&request.sql, &name, database_type)?;
+    }
+
+    let xlsx_hard_limit_active = xlsx_hard_limit_active(format, request);
+    let row_limit = effective_row_limit(format, request);
+    let stream_row_limit =
+        if xlsx_hard_limit_active { row_limit.map(|limit| limit.saturating_add(1)) } else { row_limit };
+    let progress_row_interval = request.page_size.max(1) as u64;
+    let mut columns: Vec<String> = Vec::new();
+    let mut rows_exported = 0_u64;
+    let mut last_progress_rows = 0_u64;
+    let mut last_progress_at = Instant::now();
+    let mut csv_file = if format == "csv" {
+        let mut file =
+            BufWriter::new(File::create(&request.file_path).map_err(|e| format!("Failed to create file: {e}"))?);
+        file.write_all(b"\xEF\xBB\xBF").map_err(|e| format!("Failed to write BOM: {e}"))?;
+        Some(file)
+    } else {
+        None
+    };
+    let mut xlsx = None;
+    let query_timeout = query_export_timeout(request.timeout_secs);
+    let operation_budget = operation_budget_for_pool_key(state, &pool_key, query_timeout).await;
+    let mut conn = crate::db::mysql::get_conn_with_health_check_with_cancel(
+        &pool,
+        operation_budget.checkout_timeout,
+        operation_budget.cleanup_timeout,
+        cancel_token.as_ref(),
+    )
+    .await?;
+    let mysql_connection_id = conn.id();
+    let kill_opts = conn.opts().clone();
+    if let Some(execution_id) = request.execution_id.clone() {
+        let interrupt_kill_opts = kill_opts.clone();
+        state.running_queries.register_interrupt(&execution_id, move || {
+            let kill_opts = interrupt_kill_opts.clone();
+            tokio::spawn(async move {
+                if let Err(error) = crate::db::mysql::kill_query_with_opts(kill_opts, mysql_connection_id).await {
+                    log::warn!("Failed to cancel MySQL export query {mysql_connection_id}: {error}");
+                }
+            });
+        });
+    }
+
+    let export_cancelled = Arc::new(AtomicBool::new(false));
+    let watcher_done = CancellationToken::new();
+    let watcher_done_task = watcher_done.clone();
+    let export_cancelled_task = export_cancelled.clone();
+    let export_id = request.export_id.clone();
+    let cancel_for_watcher = cancel_token.clone();
+    // Normal UI cancellation uses running query cancellation and KILL QUERY.
+    // This covers callers that only set the export-cancelled flag.
+    tokio::spawn(async move {
+        loop {
+            tokio::select! {
+                biased;
+                _ = watcher_done_task.cancelled() => break,
+                _ = tokio::time::sleep(Duration::from_millis(100)) => {}
+            }
+            if is_export_cancelled(&export_id).await {
+                export_cancelled_task.store(true, Ordering::SeqCst);
+                if let Some(token) = cancel_for_watcher.as_ref() {
+                    token.cancel();
+                }
+                break;
+            }
+        }
+    });
+
+    let stream_future = crate::db::mysql::stream_query_result_on_conn(
+        &mut conn,
+        &request.sql,
+        bare,
+        stream_row_limit,
+        mysql_dialect,
+        &export_cancelled,
+        |item| {
+            if export_cancelled.load(Ordering::SeqCst)
+                || cancel_token.as_ref().is_some_and(|token| token.is_cancelled())
+            {
+                return Err(canceled_error());
+            }
+            match item {
+                crate::db::mysql::MySqlQueryStreamItem::Columns { columns: stream_columns, column_types } => {
+                    columns = stream_columns;
+                    if let Some(file) = csv_file.as_mut() {
+                        let csv = format_query_result_csv(&columns, &[]);
+                        let header = csv.strip_suffix('\n').unwrap_or(&csv);
+                        file.write_all(header.as_bytes()).map_err(|e| format!("Failed to write CSV: {e}"))?;
+                    } else {
+                        let xlsx_file =
+                            File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+                        xlsx = Some(start_streaming_xlsx_workbook(
+                            BufWriter::new(xlsx_file),
+                            Some("Result"),
+                            &columns,
+                            &column_types,
+                        )?);
+                    }
+                }
+                crate::db::mysql::MySqlQueryStreamItem::Row(row) => {
+                    if xlsx_hard_limit_active && rows_exported as usize >= XLSX_MAX_DATA_ROWS {
+                        return Err(XLSX_ROW_LIMIT_ERROR.to_string());
+                    }
+                    if let Some(file) = csv_file.as_mut() {
+                        let rows_csv = format_query_result_csv_rows(std::slice::from_ref(&row));
+                        write!(file, "\n{rows_csv}").map_err(|e| format!("Failed to write CSV rows: {e}"))?;
+                    } else if let Some(writer) = xlsx.as_mut() {
+                        writer.write_row(&row).map_err(|e| format!("Failed to write XLSX row: {e}"))?;
+                    } else {
+                        let xlsx_file =
+                            File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+                        xlsx = Some(start_streaming_xlsx_workbook(
+                            BufWriter::new(xlsx_file),
+                            Some("Result"),
+                            &columns,
+                            &[],
+                        )?);
+                        if let Some(writer) = xlsx.as_mut() {
+                            writer.write_row(&row).map_err(|e| format!("Failed to write XLSX row: {e}"))?;
+                        }
+                    }
+                    rows_exported += 1;
+                    let now = Instant::now();
+                    if should_emit_stream_progress(
+                        rows_exported,
+                        last_progress_rows,
+                        progress_row_interval,
+                        now.duration_since(last_progress_at),
+                    ) {
+                        on_progress(progress(request, rows_exported, ExportStatus::Running, None));
+                        last_progress_rows = rows_exported;
+                        last_progress_at = now;
+                    }
+                }
+            }
+            Ok(())
+        },
+    );
+    let stream_result = match query_timeout {
+        Some(timeout) => match tokio::time::timeout(timeout, stream_future).await {
+            Ok(result) => result,
+            Err(_) => {
+                let _ = crate::db::mysql::kill_query_with_opts(kill_opts, mysql_connection_id).await;
+                Err(format!("Query timed out after {} seconds", timeout.as_secs()))
+            }
+        },
+        None => stream_future.await,
+    };
+    watcher_done.cancel();
+
+    if let Err(error) = stream_result {
+        // A timed-out, cancelled, or failed MySQL result stream may leave an
+        // incomplete protocol packet on the connection. Explicitly disconnect
+        // it so mysql_async cannot recycle the poisoned connection into the pool.
+        match disconnect_with_timeout(conn, operation_budget.cleanup_timeout, |conn| async move {
+            conn.disconnect().await.map_err(|error| error.to_string())
+        })
+        .await
+        {
+            Ok(Ok(())) => {}
+            Ok(Err(disconnect_error)) => {
+                log::warn!(
+                    "Failed to disconnect MySQL export connection {mysql_connection_id} after stream error: {disconnect_error}"
+                );
+            }
+            Err(_) => {
+                log::warn!("Timed out disconnecting MySQL export connection {mysql_connection_id} after stream error");
+            }
+        }
+
+        if error == QUERY_CANCELED
+            || export_cancelled.load(Ordering::SeqCst)
+            || cancel_token.as_ref().is_some_and(|token| token.is_cancelled())
+            || is_export_cancelled(&request.export_id).await
+        {
+            on_progress(progress(
+                request,
+                rows_exported,
+                ExportStatus::Cancelled,
+                Some("Export cancelled".to_string()),
+            ));
+            return Ok(true);
+        }
+        return Err(error);
+    }
+
+    if rows_exported != last_progress_rows {
+        on_progress(progress(request, rows_exported, ExportStatus::Running, None));
+    }
+    on_progress(progress(request, rows_exported, ExportStatus::Writing, None));
+    if let Some(file) = csv_file.as_mut() {
+        file.flush().map_err(|e| format!("Failed to flush CSV file: {e}"))?;
+    }
+    if let Some(writer) = xlsx {
+        let mut buf =
+            finish_streaming_xlsx_workbook(writer).map_err(|e| format!("Failed to finalize XLSX file: {e}"))?;
+        buf.flush().map_err(|e| format!("Failed to flush XLSX file: {e}"))?;
+    } else if format == "xlsx" {
+        let xlsx_file = File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+        let writer = start_streaming_xlsx_workbook(BufWriter::new(xlsx_file), Some("Result"), &columns, &[])?;
+        let mut buf =
+            finish_streaming_xlsx_workbook(writer).map_err(|e| format!("Failed to finalize XLSX file: {e}"))?;
+        buf.flush().map_err(|e| format!("Failed to flush XLSX file: {e}"))?;
+    }
+    on_progress(progress(request, rows_exported, ExportStatus::Done, None));
+    Ok(true)
+}
+
+async fn try_export_clickhouse_query_result_stream(
+    state: &AppState,
+    request: &QueryResultExportRequest,
+    format: &str,
+    cancel_token: Option<CancellationToken>,
+    on_progress: &impl Fn(TableExportProgress),
+) -> Result<bool, String> {
+    if request.database_type != DatabaseType::ClickHouse
+        || request.use_agent_cursor
+        || !crate::sql::starts_with_executable_sql_keyword(
+            &request.sql,
+            &["SELECT", "SHOW", "DESCRIBE", "EXPLAIN", "WITH"],
+        )
+    {
+        return Ok(false);
+    }
+
+    let database = request.database.trim();
+    let pool_key = if database.is_empty() {
+        state.get_or_create_pool_for_session(&request.connection_id, None, request.client_session_id.as_deref()).await?
+    } else {
+        state
+            .get_or_create_pool_for_session(
+                &request.connection_id,
+                Some(database),
+                request.client_session_id.as_deref(),
+            )
+            .await?
+    };
+    let connections = state.connections.read().await;
+    let Some(client) = connections.get(&pool_key).and_then(|pool| match pool {
+        PoolKind::ClickHouse(client) => Some(client.clone()),
+        _ => None,
+    }) else {
+        return Ok(false);
+    };
+    drop(connections);
+
+    if let Some(execution_id) = request.execution_id.as_deref() {
+        state.running_queries.set_pool_key(execution_id, pool_key.clone());
+    }
+    state.touch_pool_activity(&pool_key).await;
+    let _activity_touch = state.pool_activity_touch(&pool_key);
+
+    let xlsx_hard_limit_active = xlsx_hard_limit_active(format, request);
+    let row_limit = effective_row_limit(format, request);
+    let stream_row_limit =
+        if xlsx_hard_limit_active { row_limit.map(|limit| limit.saturating_add(1)) } else { row_limit };
+    let progress_row_interval = request.page_size.max(1) as u64;
+    let mut columns: Vec<String> = Vec::new();
+    let mut rows_exported = 0_u64;
+    let mut last_progress_rows = 0_u64;
+    let mut last_progress_at = Instant::now();
+    let mut csv_file = if format == "csv" {
+        let mut file =
+            BufWriter::new(File::create(&request.file_path).map_err(|e| format!("Failed to create file: {e}"))?);
+        file.write_all(b"\xEF\xBB\xBF").map_err(|e| format!("Failed to write BOM: {e}"))?;
+        Some(file)
+    } else {
+        None
+    };
+    let mut xlsx = None;
+    let clickhouse_database = if database.is_empty() { "default" } else { database };
+
+    let stream_future = crate::db::clickhouse_driver::stream_query_with_max_rows(
+        &client,
+        clickhouse_database,
+        &request.sql,
+        stream_row_limit,
+        cancel_token.clone(),
+        |item| {
+            match item {
+                crate::db::clickhouse_driver::ClickHouseQueryStreamItem::Columns {
+                    columns: stream_columns,
+                    column_types,
+                } => {
+                    columns = stream_columns;
+                    if let Some(file) = csv_file.as_mut() {
+                        let csv = format_query_result_csv(&columns, &[]);
+                        let header = csv.strip_suffix('\n').unwrap_or(&csv);
+                        file.write_all(header.as_bytes()).map_err(|e| format!("Failed to write CSV: {e}"))?;
+                    } else {
+                        let xlsx_file =
+                            File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+                        xlsx = Some(start_streaming_xlsx_workbook(
+                            BufWriter::new(xlsx_file),
+                            Some("Result"),
+                            &columns,
+                            &column_types,
+                        )?);
+                    }
+                }
+                crate::db::clickhouse_driver::ClickHouseQueryStreamItem::Row(row) => {
+                    if xlsx_hard_limit_active && rows_exported as usize >= XLSX_MAX_DATA_ROWS {
+                        return Err(XLSX_ROW_LIMIT_ERROR.to_string());
+                    }
+                    if let Some(file) = csv_file.as_mut() {
+                        let rows_csv = format_query_result_csv_rows(std::slice::from_ref(&row));
+                        write!(file, "\n{rows_csv}").map_err(|e| format!("Failed to write CSV rows: {e}"))?;
+                    } else if let Some(writer) = xlsx.as_mut() {
+                        writer.write_row(&row).map_err(|e| format!("Failed to write XLSX row: {e}"))?;
+                    } else {
+                        let xlsx_file =
+                            File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+                        xlsx = Some(start_streaming_xlsx_workbook(
+                            BufWriter::new(xlsx_file),
+                            Some("Result"),
+                            &columns,
+                            &[],
+                        )?);
+                        if let Some(writer) = xlsx.as_mut() {
+                            writer.write_row(&row).map_err(|e| format!("Failed to write XLSX row: {e}"))?;
+                        }
+                    }
+                    rows_exported += 1;
+                    let now = Instant::now();
+                    if should_emit_stream_progress(
+                        rows_exported,
+                        last_progress_rows,
+                        progress_row_interval,
+                        now.duration_since(last_progress_at),
+                    ) {
+                        on_progress(progress(request, rows_exported, ExportStatus::Running, None));
+                        last_progress_rows = rows_exported;
+                        last_progress_at = now;
+                    }
+                }
+            }
+            Ok(())
+        },
+    );
+    let stream_result = match query_export_timeout(request.timeout_secs) {
+        Some(timeout) => match tokio::time::timeout(timeout, stream_future).await {
+            Ok(result) => result,
+            Err(_) => Err(format!("Query timed out after {} seconds", timeout.as_secs())),
+        },
+        None => stream_future.await,
+    };
+
+    if let Err(error) = stream_result {
+        if error == QUERY_CANCELED
+            || cancel_token.as_ref().is_some_and(|token| token.is_cancelled())
+            || is_export_cancelled(&request.export_id).await
+        {
+            on_progress(progress(
+                request,
+                rows_exported,
+                ExportStatus::Cancelled,
+                Some("Export cancelled".to_string()),
+            ));
+            return Ok(true);
+        }
+        return Err(error);
+    }
+
+    if rows_exported != last_progress_rows {
+        on_progress(progress(request, rows_exported, ExportStatus::Running, None));
+    }
+    on_progress(progress(request, rows_exported, ExportStatus::Writing, None));
+    if let Some(file) = csv_file.as_mut() {
+        file.flush().map_err(|e| format!("Failed to flush CSV file: {e}"))?;
+    }
+    if let Some(writer) = xlsx {
+        let mut buf =
+            finish_streaming_xlsx_workbook(writer).map_err(|e| format!("Failed to finalize XLSX file: {e}"))?;
+        buf.flush().map_err(|e| format!("Failed to flush XLSX file: {e}"))?;
+    } else if format == "xlsx" {
+        let xlsx_file = File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+        let writer = start_streaming_xlsx_workbook(BufWriter::new(xlsx_file), Some("Result"), &columns, &[])?;
+        let mut buf =
+            finish_streaming_xlsx_workbook(writer).map_err(|e| format!("Failed to finalize XLSX file: {e}"))?;
+        buf.flush().map_err(|e| format!("Failed to flush XLSX file: {e}"))?;
+    }
+    on_progress(progress(request, rows_exported, ExportStatus::Done, None));
+    Ok(true)
+}
+
+async fn try_export_sqlserver_query_result_stream(
+    state: &AppState,
+    request: &QueryResultExportRequest,
+    format: &str,
+    cancel_token: Option<CancellationToken>,
+    on_progress: &impl Fn(TableExportProgress),
+) -> Result<bool, String> {
+    if request.database_type != DatabaseType::SqlServer || request.use_agent_cursor {
+        return Ok(false);
+    }
+
+    let pool_key = state.get_or_create_pool(&request.connection_id, Some(&request.database)).await?;
+    let connections = state.connections.read().await;
+    let Some(client) = connections.get(&pool_key).and_then(|pool| match pool {
+        PoolKind::SqlServer(client) => Some(client.clone()),
+        _ => None,
+    }) else {
+        return Ok(false);
+    };
+    drop(connections);
+
+    if let Some(execution_id) = request.execution_id.as_deref() {
+        state.running_queries.set_pool_key(execution_id, pool_key);
+    }
+
+    let xlsx_hard_limit_active = xlsx_hard_limit_active(format, request);
+    let row_limit = effective_row_limit(format, request);
+    let stream_row_limit =
+        if xlsx_hard_limit_active { row_limit.map(|limit| limit.saturating_add(1)) } else { row_limit };
+    let mut columns: Vec<String> = Vec::new();
+    let mut rows_exported = 0_u64;
+    let mut last_progress_rows = 0_u64;
+    let mut last_progress_at = Instant::now();
+    let progress_row_interval = request.page_size.max(1) as u64;
+    let mut csv_file = if format == "csv" {
+        let mut file =
+            BufWriter::new(File::create(&request.file_path).map_err(|e| format!("Failed to create file: {e}"))?);
+        file.write_all(b"\xEF\xBB\xBF").map_err(|e| format!("Failed to write BOM: {e}"))?;
+        Some(file)
+    } else {
+        None
+    };
+    let mut xlsx = None;
+
+    let mut client = match cancel_token.as_ref() {
+        Some(token) => {
+            tokio::select! {
+                biased;
+                _ = token.cancelled() => return Err(canceled_error()),
+                guard = client.lock() => guard,
+            }
+        }
+        None => client.lock().await,
+    };
+
+    let stream_future = crate::db::sqlserver::stream_first_result_set(
+        &mut client,
+        &request.sql,
+        stream_row_limit,
+        cancel_token.clone(),
+        |item| {
+            match item {
+                crate::db::sqlserver::SqlServerStreamItem::Columns(stream_columns) => {
+                    columns = stream_columns.to_vec();
+                    if let Some(file) = csv_file.as_mut() {
+                        let csv = format_query_result_csv(&columns, &[]);
+                        let header = csv.strip_suffix('\n').unwrap_or(&csv);
+                        file.write_all(header.as_bytes()).map_err(|e| format!("Failed to write CSV: {e}"))?;
+                    } else {
+                        let xlsx_file =
+                            File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+                        xlsx = Some(start_streaming_xlsx_workbook(
+                            BufWriter::new(xlsx_file),
+                            Some("Result"),
+                            &columns,
+                            &[],
+                        )?);
+                    }
+                }
+                crate::db::sqlserver::SqlServerStreamItem::Row(row) => {
+                    if xlsx_hard_limit_active && rows_exported as usize >= XLSX_MAX_DATA_ROWS {
+                        return Err(XLSX_ROW_LIMIT_ERROR.to_string());
+                    }
+                    if let Some(file) = csv_file.as_mut() {
+                        let rows_csv = format_query_result_csv_rows(&[row.to_vec()]);
+                        write!(file, "\n{rows_csv}").map_err(|e| format!("Failed to write CSV rows: {e}"))?;
+                    } else if let Some(writer) = xlsx.as_mut() {
+                        writer.write_row(row).map_err(|e| format!("Failed to write XLSX row: {e}"))?;
+                    } else {
+                        let xlsx_file =
+                            File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+                        xlsx = Some(start_streaming_xlsx_workbook(
+                            BufWriter::new(xlsx_file),
+                            Some("Result"),
+                            &columns,
+                            &[],
+                        )?);
+                        if let Some(writer) = xlsx.as_mut() {
+                            writer.write_row(row).map_err(|e| format!("Failed to write XLSX row: {e}"))?;
+                        }
+                    }
+                    rows_exported += 1;
+                    let now = Instant::now();
+                    if should_emit_stream_progress(
+                        rows_exported,
+                        last_progress_rows,
+                        progress_row_interval,
+                        now.duration_since(last_progress_at),
+                    ) {
+                        on_progress(progress(request, rows_exported, ExportStatus::Running, None));
+                        last_progress_rows = rows_exported;
+                        last_progress_at = now;
+                    }
+                }
+            }
+            Ok(())
+        },
+    );
+    match query_export_timeout(request.timeout_secs) {
+        Some(timeout) => tokio::time::timeout(timeout, stream_future)
+            .await
+            .map_err(|_| format!("Query timed out after {} seconds", timeout.as_secs()))??,
+        None => stream_future.await?,
+    };
+    drop(client);
+
+    if rows_exported != last_progress_rows {
+        on_progress(progress(request, rows_exported, ExportStatus::Running, None));
+    }
+    on_progress(progress(request, rows_exported, ExportStatus::Writing, None));
+    if let Some(file) = csv_file.as_mut() {
+        file.flush().map_err(|e| format!("Failed to flush CSV file: {e}"))?;
+    }
+    if let Some(writer) = xlsx {
+        let mut buf =
+            finish_streaming_xlsx_workbook(writer).map_err(|e| format!("Failed to finalize XLSX file: {e}"))?;
+        buf.flush().map_err(|e| format!("Failed to flush XLSX file: {e}"))?;
+    }
+    on_progress(progress(request, rows_exported, ExportStatus::Done, None));
+    Ok(true)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn request(format: &str, row_limit: Option<usize>, total_rows: Option<u64>) -> QueryResultExportRequest {
+        QueryResultExportRequest {
+            export_id: "export-1".to_string(),
+            connection_id: "conn-1".to_string(),
+            database: "db".to_string(),
+            schema: None,
+            sql: "SELECT * FROM users".to_string(),
+            query_base_sql: "SELECT * FROM users".to_string(),
+            database_type: DatabaseType::Postgres,
+            use_agent_cursor: false,
+            file_path: "out.csv".to_string(),
+            format: format.to_string(),
+            page_size: 1000,
+            row_limit,
+            total_rows,
+            timeout_secs: None,
+            keyset_optimization_enabled: true,
+            client_session_id: None,
+            execution_id: None,
+        }
+    }
+
+    #[test]
+    fn csv_unlimited_export_has_no_effective_row_limit() {
+        assert_eq!(effective_row_limit("csv", &request("csv", None, None)), None);
+    }
+
+    #[test]
+    fn xlsx_unlimited_export_uses_excel_hard_limit() {
+        assert_eq!(effective_row_limit("xlsx", &request("xlsx", None, None)), Some(XLSX_MAX_DATA_ROWS));
+    }
+
+    #[test]
+    fn xlsx_row_limit_caps_to_excel_hard_limit() {
+        assert_eq!(
+            effective_row_limit("xlsx", &request("xlsx", Some(XLSX_MAX_DATA_ROWS + 10), None)),
+            Some(XLSX_MAX_DATA_ROWS)
+        );
+    }
+
+    #[test]
+    fn xlsx_known_total_above_hard_limit_errors_before_export() {
+        let req = request("xlsx", None, Some(XLSX_MAX_DATA_ROWS as u64 + 1));
+        assert!(xlsx_hard_limit_active("xlsx", &req));
+        assert!(req.total_rows.is_some_and(|total| total > XLSX_MAX_DATA_ROWS as u64));
+    }
+
+    #[test]
+    fn sqlserver_stream_progress_is_throttled() {
+        assert!(!should_emit_stream_progress(19_999, 0, 20_000, Duration::from_millis(100)));
+        assert!(should_emit_stream_progress(20_000, 0, 20_000, Duration::from_millis(100)));
+        assert!(should_emit_stream_progress(10, 0, 20_000, STREAM_PROGRESS_TIME_INTERVAL));
+        assert!(!should_emit_stream_progress(20_000, 20_000, 20_000, STREAM_PROGRESS_TIME_INTERVAL));
+    }
+
+    #[test]
+    fn non_agent_pages_continue_after_trimming_probe_row() {
+        assert!(should_fetch_next_page(false, false, 101, 100, 100));
+        assert!(should_fetch_next_page(false, false, 100, 100, 100));
+        assert!(!should_fetch_next_page(false, false, 42, 42, 100));
+    }
+
+    #[test]
+    fn agent_pages_follow_has_more_flag() {
+        assert!(should_fetch_next_page(true, true, 42, 42, 100));
+        assert!(!should_fetch_next_page(true, false, 100, 100, 100));
+    }
+
+    #[test]
+    fn streaming_offset_pagination_requires_distinct_followup_page_sql() {
+        let req = request("csv", Some(1000), None);
+        assert!(supports_streaming_offset_pagination(&req, 100));
+
+        let oracle_req =
+            QueryResultExportRequest { database_type: DatabaseType::Oracle, ..request("csv", Some(1000), None) };
+        assert!(!supports_streaming_offset_pagination(&oracle_req, 100));
+    }
+
+    #[test]
+    fn clickhouse_scalar_with_query_supports_streaming_pagination() {
+        let sql = "WITH 1 AS min_id SELECT dept, COUNT(*) FROM employees WHERE id >= min_id GROUP BY dept";
+        let req = QueryResultExportRequest {
+            sql: sql.to_string(),
+            query_base_sql: sql.to_string(),
+            database_type: DatabaseType::ClickHouse,
+            ..request("csv", Some(1000), None)
+        };
+
+        assert!(supports_streaming_offset_pagination(&req, 100));
+    }
+
+    #[test]
+    fn keyset_candidate_accepts_simple_single_table_wildcard_query() {
+        let candidate = safe_keyset_candidate("SELECT * FROM public.users").expect("safe keyset candidate");
+        assert_eq!(candidate.schema.as_deref(), Some("public"));
+        assert_eq!(candidate.table, "users");
+    }
+
+    #[test]
+    fn keyset_candidate_rejects_join_and_sorted_queries() {
+        assert!(safe_keyset_candidate("SELECT * FROM users u JOIN orders o ON o.user_id = u.id").is_none());
+        assert!(safe_keyset_candidate("SELECT * FROM users ORDER BY name").is_none());
+    }
+
+    #[test]
+    fn keyset_candidate_rejects_filters_and_projection_changes() {
+        assert!(safe_keyset_candidate("SELECT * FROM users WHERE active = true").is_none());
+        assert!(safe_keyset_candidate("SELECT id, name FROM users").is_none());
+    }
+
+    #[tokio::test]
+    async fn failed_mysql_stream_disconnects_connection_without_database_or_xlsx() {
+        let disconnected = Arc::new(AtomicBool::new(false));
+        let disconnected_for_call = disconnected.clone();
+        let result = disconnect_with_timeout((), Duration::from_secs(1), move |_| async move {
+            disconnected_for_call.store(true, Ordering::SeqCst);
+            Ok(())
+        })
+        .await;
+        assert!(matches!(result, Ok(Ok(()))));
+        assert!(disconnected.load(Ordering::SeqCst));
+    }
+
+    #[tokio::test]
+    async fn failed_mysql_stream_disconnect_is_bounded_by_cleanup_timeout() {
+        let result = disconnect_with_timeout((), Duration::from_millis(1), |_| async {
+            tokio::time::sleep(Duration::from_secs(30)).await;
+            Ok(())
+        })
+        .await;
+        assert!(result.is_err());
+    }
+}
diff --git a/crates/dbx-core/src/query_result_sql.rs b/crates/dbx-core/src/query_result_sql.rs
new file mode 100644
index 0000000..51ffdec
--- /dev/null
+++ b/crates/dbx-core/src/query_result_sql.rs
@@ -0,0 +1,2582 @@
+use std::collections::HashSet;
+
+use serde::{Deserialize, Serialize};
+
+use crate::models::connection::DatabaseType;
+use crate::sql::find_statement_at_cursor;
+use crate::sql_dialect::{
+    firebird_rows_clause, pagination_strategy, quote_table_identifier, PaginationContext, TablePaginationStrategy,
+};
+use sqlparser::ast::{Expr, GroupByExpr, SelectItem, SetExpr, Statement};
+use sqlparser::dialect::{GenericDialect, MsSqlDialect};
+use sqlparser::parser::Parser;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QuerySqlBuildResult {
+    pub ok: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub sql: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reason: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryPagination {
+    pub limit: usize,
+    pub offset: usize,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub session_id: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryPaginationExecutionPlanOptions {
+    pub sql: String,
+    pub query_base_sql: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub pagination: QueryPagination,
+    pub use_agent_cursor: bool,
+    #[serde(default)]
+    pub first_page_uses_actual_sql: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryPaginationExecutionPlan {
+    pub sql_to_execute: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub page_sql: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub page_limit: Option<usize>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub page_offset: Option<usize>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub count_sql: Option<String>,
+    pub use_agent_result_session: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PaginatedQuerySqlOptions {
+    pub original_sql: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    pub limit: usize,
+    pub offset: usize,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CountQuerySqlOptions {
+    pub original_sql: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum QuerySortDirection {
+    Asc,
+    Desc,
+}
+
+impl QuerySortDirection {
+    fn as_sql(self) -> &'static str {
+        match self {
+            Self::Asc => "ASC",
+            Self::Desc => "DESC",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SortedQuerySqlOptions {
+    pub original_sql: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default)]
+    pub result_columns: Vec<String>,
+    pub column_index: usize,
+    pub column: String,
+    pub direction: QuerySortDirection,
+}
+
+pub fn build_query_pagination_execution_plan(
+    options: QueryPaginationExecutionPlanOptions,
+) -> QueryPaginationExecutionPlan {
+    let mut plan = QueryPaginationExecutionPlan {
+        sql_to_execute: options.sql.clone(),
+        page_sql: None,
+        page_limit: None,
+        page_offset: None,
+        count_sql: None,
+        use_agent_result_session: false,
+    };
+
+    let counted = build_count_query_sql(CountQuerySqlOptions {
+        original_sql: options.query_base_sql.clone(),
+        database_type: options.database_type,
+    });
+    if counted.ok {
+        plan.count_sql = counted.sql;
+    }
+
+    if options.pagination.session_id.is_some() {
+        plan.page_limit = Some(options.pagination.limit);
+        plan.page_offset = Some(options.pagination.offset);
+        plan.use_agent_result_session = true;
+        return plan;
+    }
+
+    if options.database_type == Some(DatabaseType::SqlServer) && starts_with_cte(&options.query_base_sql) {
+        return plan;
+    }
+
+    if options.use_agent_cursor && options.pagination.offset == 0 {
+        if !options.first_page_uses_actual_sql {
+            plan.sql_to_execute = options.query_base_sql;
+        }
+        plan.page_limit = Some(options.pagination.limit);
+        plan.page_offset = Some(options.pagination.offset);
+        plan.use_agent_result_session = true;
+        return plan;
+    }
+
+    let paginated = build_paginated_query_sql(PaginatedQuerySqlOptions {
+        original_sql: options.sql,
+        database_type: options.database_type,
+        limit: options.pagination.limit,
+        offset: options.pagination.offset,
+    });
+    if paginated.ok {
+        plan.sql_to_execute = paginated.sql.clone().unwrap_or_default();
+        plan.page_sql = paginated.sql;
+        plan.page_limit = Some(options.pagination.limit);
+        plan.page_offset = Some(options.pagination.offset);
+    }
+    plan
+}
+
+pub fn build_paginated_query_sql(options: PaginatedQuerySqlOptions) -> QuerySqlBuildResult {
+    let Ok(statement) = single_selectable_statement(&options.original_sql) else {
+        return err(single_statement_error_reason(&options.original_sql));
+    };
+    if unsupported_pagination_type(options.database_type) {
+        return err("unsupported");
+    }
+    let safe_limit = options.limit.max(1);
+    let safe_offset = options.offset;
+
+    if options.database_type == Some(DatabaseType::Elasticsearch) {
+        // If the user wrote their own LIMIT, leave the SQL alone — they
+        // explicitly bounded the result set and the front-end will paginate
+        // client-side. Otherwise wrap with an explicit OFFSET (even when
+        // 0) so the ES driver can tell a plan-wrapped query from one the
+        // user wrote, which decides whether affected_rows should reflect
+        // the index total or the row count we actually returned.
+        if has_top_level_limit(&statement) {
+            return err("unsupported");
+        }
+        return ok(format!("{statement} LIMIT {safe_limit} OFFSET {safe_offset};"));
+    }
+
+    match pagination_strategy(options.database_type, PaginationContext::UserQuery) {
+        TablePaginationStrategy::SqlServerTop => add_sql_server_offset_fetch(&statement, safe_limit, safe_offset)
+            .map(ok)
+            .unwrap_or_else(|| err("unsupported")),
+        TablePaginationStrategy::QuestDbLimit => ok(add_questdb_limit(&statement, safe_limit, safe_offset)),
+        TablePaginationStrategy::InformixFirst => ok(add_informix_first_limit(&statement, safe_limit, safe_offset)),
+        TablePaginationStrategy::FirebirdRows => ok(add_firebird_rows_limit(&statement, safe_limit, safe_offset)),
+        TablePaginationStrategy::Db2FetchFirst | TablePaginationStrategy::FetchFirst => {
+            ok(add_fetch_first_limit(&statement, safe_limit, safe_offset))
+        }
+        TablePaginationStrategy::Rownum => ok(add_rownum_limit(&statement, safe_limit, safe_offset)),
+        TablePaginationStrategy::AgentMaxRows | TablePaginationStrategy::Unbounded => ok(format!("{statement};")),
+        TablePaginationStrategy::IrisTop => ok(add_iris_top_limit(&statement, safe_limit)),
+        TablePaginationStrategy::LimitOffset => {
+            let dedup_count = dedup_projection_count_without_order_by(&options.original_sql);
+            ok(add_standard_limit(&statement, options.database_type, safe_limit, safe_offset, dedup_count))
+        }
+    }
+}
+
+pub fn build_count_query_sql(options: CountQuerySqlOptions) -> QuerySqlBuildResult {
+    let Ok(statement) = single_selectable_statement(&options.original_sql) else {
+        return err(single_statement_error_reason(&options.original_sql));
+    };
+    if unsupported_pagination_type(options.database_type) {
+        return err("unsupported");
+    }
+    // ES SQL can't wrap a SELECT in `SELECT COUNT(*) FROM (...)` — the
+    // driver already reports the true match count via affected_rows.
+    if options.database_type == Some(DatabaseType::Elasticsearch) {
+        return err("unsupported");
+    }
+    if options.database_type == Some(DatabaseType::SqlServer) && !sql_server_derived_table_projection_safe(&statement) {
+        return err("unsupported");
+    }
+
+    let alias = quote_table_identifier(options.database_type, "dbx_count");
+    let wrapped_sql = if options.database_type == Some(DatabaseType::SqlServer) {
+        sql_server_statement_for_derived_table(&statement)
+    } else {
+        statement
+    };
+    ok(derived_table_sql("SELECT COUNT(*) AS dbx_total_rows FROM", &wrapped_sql, &format!("{alias};")))
+}
+
+pub fn build_sorted_query_sql(options: SortedQuerySqlOptions) -> QuerySqlBuildResult {
+    let base_sql = options.original_sql.trim();
+    if base_sql.is_empty() {
+        return err("empty");
+    }
+
+    let statement = find_statement_at_cursor(base_sql, 0).trim().trim_end_matches(';').trim().to_string();
+    if statement.is_empty() {
+        return err("empty");
+    }
+    if statement.len() != base_sql.trim_end_matches(';').trim().len() {
+        return err("multi");
+    }
+    if statement.trim_start().to_ascii_uppercase().starts_with("WITH") {
+        return err("with");
+    }
+    if !statement.trim_start().to_ascii_uppercase().starts_with("SELECT") {
+        return err("not_select");
+    }
+
+    let aliases = build_derived_column_aliases(&options.result_columns);
+    let use_derived_column_aliases = options.database_type != Some(DatabaseType::Mysql)
+        && options.database_type != Some(DatabaseType::ClickHouse)
+        && options.database_type != Some(DatabaseType::Sqlite)
+        && options.database_type != Some(DatabaseType::DuckDb);
+    let sort_alias = if use_derived_column_aliases {
+        aliases
+            .get(options.column_index)
+            .or_else(|| {
+                options
+                    .result_columns
+                    .iter()
+                    .position(|column| column == &options.column)
+                    .and_then(|index| aliases.get(index))
+            })
+            .cloned()
+            .unwrap_or_else(|| fallback_alias(options.column_index))
+    } else {
+        options.result_columns.get(options.column_index).cloned().unwrap_or_else(|| options.column.clone())
+    };
+    let quoted_column = quote_table_identifier(options.database_type, &sort_alias);
+    let wrapped_statement = if options.database_type == Some(DatabaseType::SqlServer) {
+        sql_server_statement_for_derived_table(&statement)
+    } else {
+        statement
+    };
+
+    if use_derived_column_aliases {
+        let alias_list = aliases
+            .iter()
+            .map(|alias| quote_table_identifier(options.database_type, alias))
+            .collect::<Vec<_>>()
+            .join(", ");
+        ok(format!(
+            "SELECT * FROM ({wrapped_statement}) t({alias_list}) ORDER BY {quoted_column} {};",
+            options.direction.as_sql()
+        ))
+    } else {
+        ok(format!("SELECT * FROM ({wrapped_statement}) t ORDER BY {quoted_column} {};", options.direction.as_sql()))
+    }
+}
+
+fn ok(sql: String) -> QuerySqlBuildResult {
+    QuerySqlBuildResult { ok: true, sql: Some(sql), reason: None }
+}
+
+fn err(reason: &str) -> QuerySqlBuildResult {
+    QuerySqlBuildResult { ok: false, sql: None, reason: Some(reason.to_string()) }
+}
+
+fn unsupported_pagination_type(database_type: Option<DatabaseType>) -> bool {
+    matches!(database_type, Some(DatabaseType::Neo4j | DatabaseType::MongoDb | DatabaseType::Redis))
+}
+
+fn single_selectable_statement(original_sql: &str) -> Result<String, ()> {
+    let base_sql = original_sql.trim();
+    if base_sql.is_empty() {
+        return Err(());
+    }
+
+    let statement = find_statement_at_cursor(base_sql, 0).trim().trim_end_matches(';').trim().to_string();
+    if statement.is_empty() {
+        return Err(());
+    }
+    if !single_statement_matches_base_sql(&statement, base_sql) {
+        return Err(());
+    }
+    let statement_without_leading_comments =
+        strip_leading_statement_comments(statement.trim_start_matches(';').trim_start());
+    let upper = statement_without_leading_comments.to_ascii_uppercase();
+    if upper.starts_with("WITH") {
+        if !cte_main_statement_is_select(&statement) {
+            return Err(());
+        }
+    } else if !upper.starts_with("SELECT") {
+        return Err(());
+    }
+    if has_top_level_select_into(&statement) {
+        return Err(());
+    }
+
+    Ok(statement)
+}
+
+fn single_statement_matches_base_sql(statement: &str, base_sql: &str) -> bool {
+    let normalized_statement = statement.trim().trim_end_matches(';').trim();
+    let normalized_base = base_sql.trim().trim_end_matches(';').trim();
+    if normalized_statement.len() == normalized_base.len() {
+        return true;
+    }
+    let base_without_leading_comments =
+        strip_leading_statement_comments(normalized_base).trim().trim_end_matches(';').trim();
+    normalized_statement == base_without_leading_comments
+}
+
+fn starts_with_cte(sql: &str) -> bool {
+    sql.trim_start().trim_start_matches(';').trim_start().to_ascii_uppercase().starts_with("WITH")
+}
+
+fn cte_main_statement_is_select(sql: &str) -> bool {
+    let tokens = top_level_sql_tokens(sql);
+    let mut index = match tokens.iter().position(|token| token.text == "WITH") {
+        Some(index) => index + 1,
+        None => return false,
+    };
+
+    if tokens.get(index).is_some_and(|token| token.text == "RECURSIVE") {
+        index += 1;
+    }
+
+    while let Some(token) = tokens.get(index) {
+        if is_with_main_statement_keyword(&token.text) {
+            return token.text == "SELECT";
+        }
+        index += 1;
+    }
+    false
+}
+
+fn is_with_main_statement_keyword(token: &str) -> bool {
+    matches!(token, "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "MERGE")
+}
+
+fn single_statement_error_reason(original_sql: &str) -> &'static str {
+    let base_sql = original_sql.trim();
+    if base_sql.is_empty() {
+        return "empty";
+    }
+    let statement = find_statement_at_cursor(base_sql, 0).trim().trim_end_matches(';').trim().to_string();
+    if statement.is_empty() {
+        return "empty";
+    }
+    if statement.len() != base_sql.trim_end_matches(';').trim().len() {
+        return "multi";
+    }
+    "not_select"
+}
+
+fn has_top_level_select_into(sql: &str) -> bool {
+    let mut saw_select = false;
+    for token in top_level_sql_tokens(sql) {
+        if !saw_select {
+            saw_select = token.text == "SELECT";
+            continue;
+        }
+        if token.text == "INTO" {
+            return true;
+        }
+    }
+    false
+}
+
+fn add_sql_server_offset_fetch(statement: &str, limit: usize, offset: usize) -> Option<String> {
+    if has_top_level_offset_fetch_next(statement) {
+        return (offset == 0).then(|| statement.to_string());
+    }
+    if has_top_level_select_top(statement) {
+        return sql_server_derived_table_projection_safe(statement)
+            .then(|| add_sql_server_existing_top_pagination(statement, limit, offset));
+    }
+
+    let order_by_index = find_top_level_trailing_order_by(statement);
+    if order_by_index.is_none() && has_top_level_select_distinct(statement) {
+        return (offset == 0).then(|| add_sql_server_top(statement, limit));
+    }
+
+    if offset == 0 {
+        return Some(add_sql_server_top(statement, limit));
+    }
+
+    let statement_without_order = order_by_index.map(|index| statement[..index].trim_end()).unwrap_or(statement);
+    if !sql_server_derived_table_projection_safe(statement_without_order) {
+        return None;
+    }
+
+    let row_number_order = order_by_index
+        .map(|index| statement[index..].trim().to_string())
+        .unwrap_or_else(|| "ORDER BY (SELECT NULL)".to_string());
+    let end = offset + limit;
+    Some(format!(
+        "SELECT * FROM (SELECT dbx_page_source.*, ROW_NUMBER() OVER ({row_number_order}) AS [__dbx_row_num] FROM ({statement_without_order}) dbx_page_source) dbx_page WHERE [__dbx_row_num] > {offset} AND [__dbx_row_num] <= {end} ORDER BY [__dbx_row_num];"
+    ))
+}
+
+fn add_sql_server_existing_top_pagination(statement: &str, limit: usize, offset: usize) -> String {
+    let row_number_order = format!("ORDER BY {}", sql_server_default_pagination_order(statement));
+    if offset == 0 {
+        return format!("SELECT TOP ({limit}) * FROM ({statement}) [dbx_page] {row_number_order};");
+    }
+
+    let end = offset + limit;
+    format!(
+        "SELECT * FROM (SELECT dbx_page_source.*, ROW_NUMBER() OVER ({row_number_order}) AS [__dbx_row_num] FROM ({statement}) dbx_page_source) dbx_page WHERE [__dbx_row_num] > {offset} AND [__dbx_row_num] <= {end} ORDER BY [__dbx_row_num];"
+    )
+}
+
+fn sql_server_default_pagination_order(statement: &str) -> String {
+    first_simple_sqlserver_projection_order_column(statement).unwrap_or_else(|| "(SELECT NULL)".to_string())
+}
+
+fn first_simple_sqlserver_projection_order_column(statement: &str) -> Option<String> {
+    let sql = statement.trim();
+    let sql = &sql[skip_leading_sql_comments(sql, 0)..];
+    if sql.len() < 6 || !sql[..6].eq_ignore_ascii_case("SELECT") {
+        return None;
+    }
+
+    let mut index = 6;
+    index = skip_sql_whitespace(sql, index);
+    if let Some(next) = skip_sql_keyword(sql, index, "DISTINCT").or_else(|| skip_sql_keyword(sql, index, "ALL")) {
+        index = skip_sql_whitespace(sql, next);
+    }
+    if let Some(next) = skip_sql_keyword(sql, index, "TOP") {
+        index = skip_sqlserver_top_clause(sql, next);
+    }
+
+    let projection_start = skip_sql_whitespace(sql, index);
+    let projection_end = find_first_projection_end(sql, projection_start)?;
+    let projection = sql[projection_start..projection_end].trim();
+    sql_server_derived_order_column_from_projection(projection)
+}
+
+fn skip_leading_sql_comments(sql: &str, mut index: usize) -> usize {
+    loop {
+        index = skip_sql_whitespace(sql, index);
+        if sql[index..].starts_with("--") {
+            index += 2;
+            while index < sql.len() && next_char(sql, index) != '\n' {
+                index += next_char(sql, index).len_utf8();
+            }
+            continue;
+        }
+        if sql[index..].starts_with("/*") {
+            index += 2;
+            while index < sql.len() {
+                let ch = next_char(sql, index);
+                let next = next_char_at(sql, index + ch.len_utf8());
+                index += ch.len_utf8();
+                if ch == '*' && next == Some('/') {
+                    index += 1;
+                    break;
+                }
+            }
+            continue;
+        }
+        return index;
+    }
+}
+
+fn strip_leading_statement_comments(sql: &str) -> &str {
+    &sql[skip_leading_sql_comments(sql, 0)..]
+}
+
+fn skip_sqlserver_top_clause(sql: &str, index: usize) -> usize {
+    let mut cursor = skip_sql_whitespace(sql, index);
+    if next_char_at(sql, cursor) == Some('(') {
+        cursor = skip_sql_parenthesized(sql, cursor);
+    } else {
+        while cursor < sql.len() && !next_char(sql, cursor).is_whitespace() && next_char(sql, cursor) != ',' {
+            cursor += next_char(sql, cursor).len_utf8();
+        }
+    }
+    cursor = skip_sql_whitespace(sql, cursor);
+    if let Some(next) = skip_sql_keyword(sql, cursor, "PERCENT") {
+        cursor = skip_sql_whitespace(sql, next);
+    }
+    if let Some(next) = skip_sql_keyword(sql, cursor, "WITH") {
+        let after_with = skip_sql_whitespace(sql, next);
+        if let Some(after_ties) = skip_sql_keyword(sql, after_with, "TIES") {
+            cursor = skip_sql_whitespace(sql, after_ties);
+        }
+    }
+    cursor
+}
+
+fn find_first_projection_end(sql: &str, start: usize) -> Option<usize> {
+    let mut index = start;
+    let mut depth = 0usize;
+    while index < sql.len() {
+        let ch = next_char(sql, index);
+        if matches!(ch, '\'' | '"' | '`') {
+            index = skip_sql_quoted(sql, index, ch);
+            continue;
+        }
+        if ch == '[' {
+            index = skip_sql_bracket_identifier(sql, index);
+            continue;
+        }
+        if ch == '(' {
+            depth += 1;
+            index += ch.len_utf8();
+            continue;
+        }
+        if ch == ')' {
+            depth = depth.saturating_sub(1);
+            index += ch.len_utf8();
+            continue;
+        }
+        if depth == 0 && ch == ',' {
+            return Some(index);
+        }
+        if depth == 0 && sql_keyword_at(sql, index, "FROM") {
+            return Some(index);
+        }
+        index += ch.len_utf8();
+    }
+    None
+}
+
+fn is_simple_sqlserver_order_projection(projection: &str) -> bool {
+    if projection.is_empty() || projection == "*" {
+        return false;
+    }
+    let mut expect_part = true;
+    let mut saw_part = false;
+    let mut index = 0;
+    while index < projection.len() {
+        let ch = next_char(projection, index);
+        if ch.is_whitespace() {
+            return false;
+        }
+        if ch == '.' {
+            if expect_part {
+                return false;
+            }
+            expect_part = true;
+            index += 1;
+            continue;
+        }
+        if ch == '[' {
+            if !expect_part {
+                return false;
+            }
+            let next = skip_sql_bracket_identifier(projection, index);
+            if next <= index + 1 || next > projection.len() {
+                return false;
+            }
+            saw_part = true;
+            expect_part = false;
+            index = next;
+            continue;
+        }
+        if is_sql_token_start(ch) {
+            if !expect_part {
+                return false;
+            }
+            index += ch.len_utf8();
+            while index < projection.len() && is_sql_token_part(next_char(projection, index)) {
+                index += next_char(projection, index).len_utf8();
+            }
+            saw_part = true;
+            expect_part = false;
+            continue;
+        }
+        return false;
+    }
+    saw_part && !expect_part
+}
+
+fn sql_server_derived_order_column_from_projection(projection: &str) -> Option<String> {
+    if !is_simple_sqlserver_order_projection(projection) {
+        return None;
+    }
+
+    let last_part = last_sqlserver_identifier_part(projection);
+    if last_part.starts_with('[') {
+        return Some(last_part.to_string());
+    }
+    Some(quote_table_identifier(Some(DatabaseType::SqlServer), last_part))
+}
+
+fn last_sqlserver_identifier_part(projection: &str) -> &str {
+    let mut last_start = 0;
+    let mut index = 0;
+    while index < projection.len() {
+        let ch = next_char(projection, index);
+        if ch == '[' {
+            index = skip_sql_bracket_identifier(projection, index);
+            continue;
+        }
+        if ch == '.' {
+            last_start = index + 1;
+            index += 1;
+            continue;
+        }
+        index += ch.len_utf8();
+    }
+    projection[last_start..].trim()
+}
+
+fn skip_sql_whitespace(sql: &str, mut index: usize) -> usize {
+    while index < sql.len() && next_char(sql, index).is_whitespace() {
+        index += next_char(sql, index).len_utf8();
+    }
+    index
+}
+
+fn skip_sql_keyword(sql: &str, index: usize, keyword: &str) -> Option<usize> {
+    sql_keyword_at(sql, index, keyword).then_some(index + keyword.len())
+}
+
+fn sql_keyword_at(sql: &str, index: usize, keyword: &str) -> bool {
+    let Some(candidate) = sql.get(index..index + keyword.len()) else {
+        return false;
+    };
+    if !candidate.eq_ignore_ascii_case(keyword) {
+        return false;
+    }
+    let before_ok = index == 0 || !is_sql_token_part(next_char_before(sql, index));
+    let after = index + keyword.len();
+    let after_ok = after >= sql.len() || !is_sql_token_part(next_char(sql, after));
+    before_ok && after_ok
+}
+
+fn skip_sql_parenthesized(sql: &str, index: usize) -> usize {
+    let mut cursor = index;
+    let mut depth = 0usize;
+    while cursor < sql.len() {
+        let ch = next_char(sql, cursor);
+        if matches!(ch, '\'' | '"' | '`') {
+            cursor = skip_sql_quoted(sql, cursor, ch);
+            continue;
+        }
+        if ch == '[' {
+            cursor = skip_sql_bracket_identifier(sql, cursor);
+            continue;
+        }
+        if ch == '(' {
+            depth += 1;
+        } else if ch == ')' {
+            depth = depth.saturating_sub(1);
+            cursor += ch.len_utf8();
+            if depth == 0 {
+                return cursor;
+            }
+            continue;
+        }
+        cursor += ch.len_utf8();
+    }
+    sql.len()
+}
+
+fn sql_server_derived_table_projection_safe(statement: &str) -> bool {
+    let dialect = MsSqlDialect {};
+    let Ok(statements) = Parser::parse_sql(&dialect, statement) else {
+        return false;
+    };
+    let [Statement::Query(query)] = statements.as_slice() else {
+        return false;
+    };
+    let SetExpr::Select(select) = query.body.as_ref() else {
+        return false;
+    };
+
+    if matches!(select.projection.as_slice(), [SelectItem::Wildcard(_)]) {
+        return select.from.len() == 1 && select.from[0].joins.is_empty();
+    }
+
+    let mut column_names = HashSet::with_capacity(select.projection.len());
+    select.projection.iter().all(|item| {
+        let Some(name) = sql_server_derived_projection_name(item) else {
+            return false;
+        };
+        column_names.insert(name.to_lowercase())
+    })
+}
+
+fn sql_server_derived_projection_name(item: &SelectItem) -> Option<&str> {
+    match item {
+        SelectItem::ExprWithAlias { alias, .. } => Some(&alias.value),
+        SelectItem::UnnamedExpr(Expr::Identifier(identifier)) if !identifier.value.starts_with('@') => {
+            Some(&identifier.value)
+        }
+        SelectItem::UnnamedExpr(Expr::CompoundIdentifier(identifiers)) => {
+            identifiers.last().map(|identifier| identifier.value.as_str())
+        }
+        SelectItem::UnnamedExpr(_)
+        | SelectItem::ExprWithAliases { .. }
+        | SelectItem::QualifiedWildcard(_, _)
+        | SelectItem::Wildcard(_) => None,
+    }
+}
+
+fn add_sql_server_top(sql: &str, limit: usize) -> String {
+    if has_top_level_select_top(sql) || has_top_level_offset_fetch_next(sql) {
+        return sql.to_string();
+    }
+    if sql.len() >= 6 && sql[..6].eq_ignore_ascii_case("SELECT") {
+        let rest = &sql[6..];
+        if let Some((leading, after_modifier)) = strip_sql_server_select_modifier(rest, "DISTINCT") {
+            return format!("SELECT{leading}DISTINCT TOP ({limit}){after_modifier}");
+        }
+        if let Some((leading, after_modifier)) = strip_sql_server_select_modifier(rest, "ALL") {
+            return format!("SELECT{leading}ALL TOP ({limit}){after_modifier}");
+        }
+        format!("SELECT TOP ({limit}){rest}")
+    } else {
+        format!("SELECT TOP ({limit}) * FROM ({sql}) [dbx_page]")
+    }
+}
+
+fn strip_sql_server_select_modifier<'a>(rest: &'a str, modifier: &str) -> Option<(&'a str, &'a str)> {
+    let trimmed = rest.trim_start();
+    let leading_ws_len = rest.len() - trimmed.len();
+    let candidate = trimmed.get(..modifier.len())?;
+    let after_modifier = trimmed.get(modifier.len()..)?;
+    if !candidate.eq_ignore_ascii_case(modifier) {
+        return None;
+    }
+    if after_modifier.chars().next().is_some_and(is_sql_token_part) {
+        return None;
+    }
+    Some((&rest[..leading_ws_len], after_modifier))
+}
+
+fn sql_server_statement_for_derived_table(statement: &str) -> String {
+    let Some(order_by) = find_top_level_trailing_order_by(statement) else {
+        return statement.to_string();
+    };
+    if has_top_level_select_top(statement) || has_top_level_for_xml(statement) {
+        return statement.to_string();
+    }
+    statement[..order_by].trim_end().to_string()
+}
+
+fn add_informix_first_limit(statement: &str, limit: usize, offset: usize) -> String {
+    if has_top_level_informix_row_limit(statement) {
+        return format!("{statement};");
+    }
+    let row_limit = if offset > 0 { format!("SKIP {offset} FIRST {limit}") } else { format!("FIRST {limit}") };
+    if statement.len() >= 6 && statement[..6].eq_ignore_ascii_case("SELECT") {
+        let rest = &statement[6..];
+        if let Some((leading, after_modifier)) = strip_sql_server_select_modifier(rest, "DISTINCT") {
+            return format!("SELECT{leading}DISTINCT {row_limit}{after_modifier};");
+        }
+        if let Some((leading, after_modifier)) = strip_sql_server_select_modifier(rest, "UNIQUE") {
+            return format!("SELECT{leading}UNIQUE {row_limit}{after_modifier};");
+        }
+        if let Some((leading, after_modifier)) = strip_sql_server_select_modifier(rest, "ALL") {
+            return format!("SELECT{leading}ALL {row_limit}{after_modifier};");
+        }
+        return format!("SELECT {row_limit}{rest};");
+    }
+    format!("SELECT {row_limit} * FROM ({statement}) dbx_page;")
+}
+
+fn add_iris_top_limit(statement: &str, limit: usize) -> String {
+    if has_top_level_select_top(statement) {
+        return format!("{statement};");
+    }
+    if statement.len() >= 6 && statement[..6].eq_ignore_ascii_case("SELECT") {
+        let rest = &statement[6..];
+        format!("SELECT TOP {limit}{rest};")
+    } else {
+        format!("SELECT TOP {limit} * FROM ({statement}) dbx_page;")
+    }
+}
+
+fn add_questdb_limit(statement: &str, limit: usize, offset: usize) -> String {
+    if has_top_level_limit(statement) {
+        if offset > 0 {
+            return add_outer_standard_limit(statement, Some(DatabaseType::Questdb), limit, offset, "");
+        }
+        return format!("{statement};");
+    }
+    if offset > 0 {
+        let upper_bound = offset + limit;
+        append_sql_suffix(statement, &format!("LIMIT {offset}, {upper_bound};"))
+    } else {
+        append_sql_suffix(statement, &format!("LIMIT {limit};"))
+    }
+}
+
+fn has_top_level_limit(sql: &str) -> bool {
+    top_level_sql_tokens(sql).iter().any(|token| token.text == "LIMIT")
+}
+
+fn top_level_limit_row_count(sql: &str) -> Option<usize> {
+    let token = top_level_sql_tokens(sql).into_iter().find(|token| token.text == "LIMIT")?;
+    parse_standard_limit_row_count(sql, token.start + token.text.len())
+}
+
+fn parse_standard_limit_row_count(sql: &str, start: usize) -> Option<usize> {
+    let mut cursor = skip_sql_whitespace(sql, start);
+    let first = parse_usize_literal(sql, &mut cursor)?;
+    cursor = skip_sql_whitespace(sql, cursor);
+    if sql.get(cursor..)?.starts_with(',') {
+        cursor = skip_sql_whitespace(sql, cursor + 1);
+        return parse_usize_literal(sql, &mut cursor);
+    }
+    Some(first)
+}
+
+fn parse_usize_literal(sql: &str, cursor: &mut usize) -> Option<usize> {
+    let start = *cursor;
+    while *cursor < sql.len() && sql.as_bytes()[*cursor].is_ascii_digit() {
+        *cursor += 1;
+    }
+    if *cursor == start {
+        return None;
+    }
+    sql[start..*cursor].parse().ok()
+}
+
+fn has_top_level_informix_row_limit(sql: &str) -> bool {
+    if has_top_level_limit(sql) {
+        return true;
+    }
+    let tokens = top_level_sql_tokens(sql);
+    let Some(select_index) = tokens.iter().position(|token| token.text == "SELECT") else {
+        return false;
+    };
+    let from_index = tokens
+        .iter()
+        .enumerate()
+        .find(|(index, token)| *index > select_index && token.text == "FROM")
+        .map(|(index, _)| index)
+        .unwrap_or(tokens.len());
+    tokens[select_index + 1..from_index].iter().any(|token| token.text == "FIRST" || token.text == "SKIP")
+}
+
+fn has_top_level_firebird_row_limit(sql: &str) -> bool {
+    if has_top_level_fetch_first(sql) {
+        return true;
+    }
+    let tokens = top_level_sql_tokens(sql);
+    if tokens.iter().any(|token| token.text == "ROWS") {
+        return true;
+    }
+    let Some(select_index) = tokens.iter().position(|token| token.text == "SELECT") else {
+        return false;
+    };
+    let from_index = tokens
+        .iter()
+        .enumerate()
+        .find(|(index, token)| *index > select_index && token.text == "FROM")
+        .map(|(index, _)| index)
+        .unwrap_or(tokens.len());
+    tokens[select_index + 1..from_index].iter().any(|token| token.text == "FIRST" || token.text == "SKIP")
+}
+
+fn has_top_level_fetch_first(sql: &str) -> bool {
+    let tokens = top_level_sql_tokens(sql);
+    tokens.windows(2).any(|w| w[0].text == "FETCH" && w[1].text == "FIRST")
+}
+
+fn has_top_level_rownum(sql: &str) -> bool {
+    top_level_sql_tokens(sql).iter().any(|token| token.text == "ROWNUM")
+}
+
+fn has_top_level_offset_fetch_next(sql: &str) -> bool {
+    let tokens = top_level_sql_tokens(sql);
+    let has_offset = tokens.iter().any(|token| token.text == "OFFSET");
+    let has_fetch_next = tokens.windows(2).any(|w| w[0].text == "FETCH" && w[1].text == "NEXT");
+    has_offset && has_fetch_next
+}
+
+fn add_fetch_first_limit(statement: &str, limit: usize, offset: usize) -> String {
+    if has_top_level_fetch_first(statement) {
+        if offset > 0 {
+            let alias = quote_table_identifier(None, "dbx_page");
+            return derived_table_sql(
+                "SELECT * FROM",
+                statement,
+                &format!("{alias} OFFSET {offset} ROWS FETCH FIRST {limit} ROWS ONLY;"),
+            );
+        }
+        return format!("{statement};");
+    }
+    let offset_sql = if offset > 0 { format!(" OFFSET {offset} ROWS") } else { String::new() };
+    append_sql_suffix(statement, &format!("{offset_sql} FETCH FIRST {limit} ROWS ONLY;"))
+}
+
+fn add_firebird_rows_limit(statement: &str, limit: usize, offset: usize) -> String {
+    if has_top_level_firebird_row_limit(statement) {
+        return format!("{statement};");
+    }
+    let rows = firebird_rows_clause(limit, offset);
+    append_sql_suffix(statement, &format!("{rows};"))
+}
+
+fn add_rownum_limit(statement: &str, limit: usize, offset: usize) -> String {
+    if has_top_level_rownum(statement) {
+        return format!("{statement};");
+    }
+    if offset == 0 {
+        return derived_table_sql("SELECT * FROM", statement, &format!("WHERE ROWNUM <= {limit};"));
+    }
+    let end = offset + limit;
+    let inner = derived_table_sql(
+        "SELECT dbx_inner.*, ROWNUM AS \"__dbx_row_num\" FROM",
+        statement,
+        &format!("dbx_inner WHERE ROWNUM <= {end}"),
+    );
+    format!("SELECT * FROM ({inner}) WHERE \"__dbx_row_num\" > {offset};")
+}
+
+fn add_standard_limit(
+    statement: &str,
+    database_type: Option<DatabaseType>,
+    limit: usize,
+    offset: usize,
+    dedup_projection_count: Option<usize>,
+) -> String {
+    let order_sql = dedup_projection_count.map_or(String::new(), |count| format_positional_order_by(count));
+
+    if has_top_level_limit(statement) {
+        if !order_sql.is_empty() {
+            // For dedup queries (DISTINCT / GROUP BY) without user ORDER BY,
+            // wrap the query to guarantee deterministic LIMIT/OFFSET pagination.
+            // The inner query preserves DISTINCT semantics; the outer query
+            // adds ORDER BY on positional columns to ensure consistent row
+            // ordering across pages in distributed databases like Doris.
+            return add_outer_standard_limit(statement, database_type, limit, offset, &order_sql);
+        }
+        // A user/top-level LIMIT can still be wider than the selected grid page size.
+        // Wrap it so the first page respects the UI page limit while preserving the user's cap.
+        if offset > 0 || top_level_limit_row_count(statement).is_some_and(|row_count| row_count > limit) {
+            return add_outer_standard_limit(statement, database_type, limit, offset, "");
+        }
+        return format!("{statement};");
+    }
+    let offset_sql = if offset > 0 { format!(" OFFSET {offset}") } else { String::new() };
+    let limit_sql = format!("{order_sql} LIMIT {limit}{offset_sql}");
+    if database_type == Some(DatabaseType::ClickHouse) {
+        return add_clickhouse_limit(statement, &limit_sql);
+    }
+    append_sql_suffix(statement, &format!("{limit_sql};"))
+}
+
+fn add_outer_standard_limit(
+    statement: &str,
+    database_type: Option<DatabaseType>,
+    limit: usize,
+    offset: usize,
+    order_sql: &str,
+) -> String {
+    let alias = quote_table_identifier(database_type, "dbx_page");
+    derived_table_sql("SELECT * FROM", statement, &format!("{alias}{order_sql} LIMIT {limit} OFFSET {offset};"))
+}
+
+fn add_clickhouse_limit(statement: &str, limit_sql: &str) -> String {
+    let limit_sql = limit_sql.trim();
+    let settings_index =
+        top_level_sql_tokens(statement).iter().find(|token| token.text == "SETTINGS").map(|token| token.start);
+
+    if let Some(index) = settings_index {
+        let statement_before_settings = statement[..index].trim_end();
+        let settings_clause = statement[index..].trim_start();
+        return format!("{statement_before_settings} {limit_sql} {settings_clause};");
+    }
+
+    append_sql_suffix(statement, &format!("{limit_sql};"))
+}
+
+fn derived_table_sql(prefix: &str, statement: &str, suffix: &str) -> String {
+    format!("{prefix} ({}) {suffix}", statement_for_sql_suffix(statement))
+}
+
+fn append_sql_suffix(statement: &str, suffix: &str) -> String {
+    let separator = if sql_suffix_needs_newline(statement) { "\n" } else { " " };
+    format!("{}{separator}{}", statement.trim_end(), suffix.trim_start())
+}
+
+fn statement_for_sql_suffix(statement: &str) -> String {
+    let trimmed = statement.trim_end();
+    if sql_suffix_needs_newline(trimmed) {
+        format!("{trimmed}\n")
+    } else {
+        trimmed.to_string()
+    }
+}
+
+fn sql_suffix_needs_newline(sql: &str) -> bool {
+    let Some(last_line_start) = sql.rfind(['\n', '\r']).map(|index| index + 1) else {
+        return line_has_open_line_comment(sql);
+    };
+    line_has_open_line_comment(&sql[last_line_start..])
+}
+
+fn line_has_open_line_comment(line: &str) -> bool {
+    let mut index = 0;
+    while index < line.len() {
+        let ch = next_char(line, index);
+        let next = next_char_at(line, index + ch.len_utf8());
+        if matches!(ch, '\'' | '"' | '`') {
+            index = skip_sql_quoted(line, index, ch);
+            continue;
+        }
+        if ch == '[' {
+            index = skip_sql_bracket_identifier(line, index);
+            continue;
+        }
+        if ch == '/' && next == Some('*') {
+            index += 2;
+            while index < line.len() {
+                let current = next_char(line, index);
+                let following = next_char_at(line, index + current.len_utf8());
+                index += current.len_utf8();
+                if current == '*' && following == Some('/') {
+                    index += 1;
+                    break;
+                }
+            }
+            continue;
+        }
+        if ch == '-' && next == Some('-') {
+            return true;
+        }
+        if ch == '#' {
+            return true;
+        }
+        index += ch.len_utf8();
+    }
+    false
+}
+
+/// For dedup queries (DISTINCT / GROUP BY) without an ORDER BY clause, generate
+/// a positional `ORDER BY 1, 2, ..., N` clause so that LIMIT/OFFSET pagination
+/// returns deterministic results across pages.  This is especially important for
+/// distributed databases (e.g. Doris, StarRocks) where tablet scan order varies
+/// between independent query executions.
+fn format_positional_order_by(column_count: usize) -> String {
+    if column_count == 0 {
+        return String::new();
+    }
+    let cols: Vec<String> = (1..=column_count).map(|i| i.to_string()).collect();
+    format!(" ORDER BY {}", cols.join(", "))
+}
+
+/// Detect dedup queries (SELECT DISTINCT, GROUP BY, HAVING) that lack a
+/// top-level ORDER BY clause.  Returns the number of projection items so that
+/// a positional ORDER BY can be injected for deterministic pagination.
+///
+/// Returns `None` for:
+///   - Non-SELECT queries
+///   - Queries without dedup semantics
+///   - Queries that already specify ORDER BY
+///   - Wildcard projections (`SELECT *`)
+///   - Parse failures
+fn dedup_projection_count_without_order_by(sql: &str) -> Option<usize> {
+    let dialect = GenericDialect {};
+    let statements = Parser::parse_sql(&dialect, sql).ok()?;
+    let [Statement::Query(query)] = statements.as_slice() else {
+        return None;
+    };
+    // Reject if the query already has an ORDER BY clause.
+    if query.order_by.is_some() {
+        return None;
+    }
+    let SetExpr::Select(select) = query.body.as_ref() else {
+        return None;
+    };
+    let has_distinct = select.distinct.is_some();
+    let has_group_by = !matches!(&select.group_by, GroupByExpr::Expressions(exprs, _) if exprs.is_empty());
+    let has_having = select.having.is_some();
+    if !has_distinct && !has_group_by && !has_having {
+        return None;
+    }
+    // Wildcard projections cannot be used with positional ORDER BY.
+    if select.projection.len() == 1 && matches!(select.projection.first(), Some(SelectItem::Wildcard(_))) {
+        return None;
+    }
+    Some(select.projection.len())
+}
+
+fn find_top_level_trailing_order_by(sql: &str) -> Option<usize> {
+    let tokens = top_level_sql_tokens(sql);
+    for index in (0..tokens.len().saturating_sub(1)).rev() {
+        if tokens[index].text == "ORDER" && tokens.get(index + 1).is_some_and(|token| token.text == "BY") {
+            return Some(tokens[index].start);
+        }
+    }
+    None
+}
+
+fn has_top_level_select_top(sql: &str) -> bool {
+    top_level_select_tokens_before_from(sql).iter().any(|token| token.text == "TOP")
+}
+
+fn has_top_level_select_distinct(sql: &str) -> bool {
+    top_level_select_tokens_before_from(sql).iter().any(|token| token.text == "DISTINCT")
+}
+
+fn top_level_select_tokens_before_from(sql: &str) -> Vec<SqlToken> {
+    let tokens = top_level_sql_tokens(sql);
+    let Some(select_index) = tokens.iter().position(|token| token.text == "SELECT") else {
+        return Vec::new();
+    };
+    let from_index = tokens
+        .iter()
+        .enumerate()
+        .find(|(index, token)| *index > select_index && token.text == "FROM")
+        .map(|(index, _)| index)
+        .unwrap_or(tokens.len());
+    tokens[select_index + 1..from_index].to_vec()
+}
+
+fn has_top_level_for_xml(sql: &str) -> bool {
+    let tokens = top_level_sql_tokens(sql);
+    tokens
+        .iter()
+        .enumerate()
+        .any(|(index, token)| token.text == "FOR" && tokens.get(index + 1).is_some_and(|next| next.text == "XML"))
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct SqlToken {
+    text: String,
+    start: usize,
+}
+
+fn top_level_sql_tokens(sql: &str) -> Vec<SqlToken> {
+    let mut tokens = Vec::new();
+    let mut i = 0;
+    let mut depth = 0usize;
+
+    while i < sql.len() {
+        let ch = next_char(sql, i);
+        let next = next_char_at(sql, i + ch.len_utf8());
+
+        if ch == '-' && next == Some('-') {
+            i += 2;
+            while i < sql.len() && next_char(sql, i) != '\n' {
+                i += next_char(sql, i).len_utf8();
+            }
+            continue;
+        }
+
+        if ch == '/' && next == Some('*') {
+            i += 2;
+            while i < sql.len() {
+                let current = next_char(sql, i);
+                let following = next_char_at(sql, i + current.len_utf8());
+                if current == '*' && following == Some('/') {
+                    i += 2;
+                    break;
+                }
+                i += current.len_utf8();
+            }
+            continue;
+        }
+
+        if matches!(ch, '\'' | '"' | '`') {
+            i = skip_sql_quoted(sql, i, ch);
+            continue;
+        }
+
+        if ch == '[' {
+            i = skip_sql_bracket_identifier(sql, i);
+            continue;
+        }
+
+        if ch == '(' {
+            depth += 1;
+            i += ch.len_utf8();
+            continue;
+        }
+
+        if ch == ')' {
+            depth = depth.saturating_sub(1);
+            i += ch.len_utf8();
+            continue;
+        }
+
+        if depth == 0 && is_sql_token_start(ch) {
+            let start = i;
+            i += ch.len_utf8();
+            while i < sql.len() && is_sql_token_part(next_char(sql, i)) {
+                i += next_char(sql, i).len_utf8();
+            }
+            tokens.push(SqlToken { text: sql[start..i].to_ascii_uppercase(), start });
+            continue;
+        }
+
+        i += ch.len_utf8();
+    }
+
+    tokens
+}
+
+fn skip_sql_quoted(sql: &str, pos: usize, quote: char) -> usize {
+    let mut i = pos + quote.len_utf8();
+    while i < sql.len() {
+        let ch = next_char(sql, i);
+        let next = next_char_at(sql, i + ch.len_utf8());
+        if ch == quote {
+            if next == Some(quote) {
+                i += ch.len_utf8() + quote.len_utf8();
+                continue;
+            }
+            return i + ch.len_utf8();
+        }
+        if quote == '\'' && ch == '\\' {
+            i += ch.len_utf8();
+            if i < sql.len() {
+                i += next_char(sql, i).len_utf8();
+            }
+            continue;
+        }
+        i += ch.len_utf8();
+    }
+    sql.len()
+}
+
+fn skip_sql_bracket_identifier(sql: &str, pos: usize) -> usize {
+    let mut i = pos + 1;
+    while i < sql.len() {
+        let ch = next_char(sql, i);
+        let next = next_char_at(sql, i + ch.len_utf8());
+        if ch == ']' {
+            if next == Some(']') {
+                i += 2;
+                continue;
+            }
+            return i + 1;
+        }
+        i += ch.len_utf8();
+    }
+    sql.len()
+}
+
+fn is_sql_token_start(ch: char) -> bool {
+    ch.is_ascii_alphabetic() || ch == '_'
+}
+
+fn is_sql_token_part(ch: char) -> bool {
+    ch.is_ascii_alphanumeric() || matches!(ch, '_' | '$' | '#')
+}
+
+fn next_char(sql: &str, index: usize) -> char {
+    sql[index..].chars().next().unwrap_or('\0')
+}
+
+fn next_char_before(sql: &str, index: usize) -> char {
+    sql[..index].chars().next_back().unwrap_or('\0')
+}
+
+fn next_char_at(sql: &str, index: usize) -> Option<char> {
+    if index >= sql.len() {
+        None
+    } else {
+        sql[index..].chars().next()
+    }
+}
+
+fn build_derived_column_aliases(result_columns: &[String]) -> Vec<String> {
+    let mut seen: std::collections::HashMap<String, usize> = std::collections::HashMap::new();
+    result_columns
+        .iter()
+        .enumerate()
+        .map(|(index, column)| {
+            let base = normalize_alias_base(column, index);
+            let count = seen.entry(base.clone()).and_modify(|value| *value += 1).or_insert(1);
+            if *count == 1 {
+                base
+            } else {
+                format!("{base}_{count}")
+            }
+        })
+        .collect()
+}
+
+fn normalize_alias_base(column: &str, index: usize) -> String {
+    let compact = column.split_whitespace().collect::<Vec<_>>().join("_");
+    let safe = compact
+        .chars()
+        .map(|ch| if ch.is_alphanumeric() || matches!(ch, '_' | '$') { ch } else { '_' })
+        .collect::<String>()
+        .trim_matches('_')
+        .to_string();
+    if safe.is_empty() {
+        fallback_alias(index)
+    } else {
+        safe
+    }
+}
+
+fn fallback_alias(index: usize) -> String {
+    format!("column_{}", index + 1)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn wraps_single_select_query_with_limit_and_offset() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id, name FROM users;".to_string(),
+            database_type: Some(DatabaseType::Postgres),
+            limit: 100,
+            offset: 200,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT id, name FROM users LIMIT 100 OFFSET 200;");
+    }
+
+    #[test]
+    fn uses_sqlserver_top_pagination_for_first_page() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users ORDER BY id DESC".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT TOP (100) id FROM users ORDER BY id DESC");
+    }
+
+    #[test]
+    fn uses_sqlserver_top_for_count_queries_without_derived_table() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT COUNT(*) FROM TicketInfo".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT TOP (100) COUNT(*) FROM TicketInfo");
+    }
+
+    #[test]
+    fn uses_sqlserver_top_for_unnamed_expression_on_first_page() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id + 1 FROM TicketInfo".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT TOP (100) id + 1 FROM TicketInfo");
+    }
+
+    #[test]
+    fn rejects_sqlserver_unnamed_expression_for_later_pages() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id + 1 FROM TicketInfo".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 100,
+        });
+
+        assert_eq!(result, err("unsupported"));
+    }
+
+    #[test]
+    fn uses_sqlserver_top_for_distinct_queries_without_order_by() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT DISTINCT ProjectType FROM JDDR_sys_BasicConfig_ProjectInfo_Data".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT DISTINCT TOP (100) ProjectType FROM JDDR_sys_BasicConfig_ProjectInfo_Data"
+        );
+    }
+
+    #[test]
+    fn rejects_sqlserver_distinct_later_pages_without_order_by() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT DISTINCT ProjectType FROM JDDR_sys_BasicConfig_ProjectInfo_Data".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 100,
+        });
+
+        assert_eq!(result, err("unsupported"));
+    }
+
+    #[test]
+    fn paginates_sqlserver_all_queries_with_top() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT ALL ProjectType FROM JDDR_sys_BasicConfig_ProjectInfo_Data".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT ALL TOP (100) ProjectType FROM JDDR_sys_BasicConfig_ProjectInfo_Data");
+    }
+
+    #[test]
+    fn paginates_sqlserver_select_prefix_like_all_modifier() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT AllProjectType FROM JDDR_sys_BasicConfig_ProjectInfo_Data".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT TOP (100) AllProjectType FROM JDDR_sys_BasicConfig_ProjectInfo_Data");
+    }
+
+    #[test]
+    fn paginates_existing_sqlserver_top_clause_on_first_page() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT TOP 1000 * FROM TicketInfo".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT TOP (100) * FROM (SELECT TOP 1000 * FROM TicketInfo) [dbx_page] ORDER BY (SELECT NULL);"
+        );
+    }
+
+    #[test]
+    fn paginates_existing_sqlserver_top_clause_for_later_pages() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT TOP 1000 * FROM TicketInfo".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 100,
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT dbx_page_source.*, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS [__dbx_row_num] FROM (SELECT TOP 1000 * FROM TicketInfo) dbx_page_source) dbx_page WHERE [__dbx_row_num] > 100 AND [__dbx_row_num] <= 200 ORDER BY [__dbx_row_num];"
+        );
+    }
+
+    #[test]
+    fn sqlserver_top_query_later_page_keeps_page_metadata() {
+        let sql = "SELECT TOP 1000 * FROM TicketInfo".to_string();
+        let plan = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {
+            sql: sql.clone(),
+            query_base_sql: sql,
+            database_type: Some(DatabaseType::SqlServer),
+            pagination: QueryPagination { limit: 100, offset: 100, session_id: None },
+            use_agent_cursor: false,
+            first_page_uses_actual_sql: false,
+        });
+
+        assert_eq!(
+            plan.sql_to_execute,
+            "SELECT * FROM (SELECT dbx_page_source.*, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS [__dbx_row_num] FROM (SELECT TOP 1000 * FROM TicketInfo) dbx_page_source) dbx_page WHERE [__dbx_row_num] > 100 AND [__dbx_row_num] <= 200 ORDER BY [__dbx_row_num];"
+        );
+        assert_eq!(plan.page_sql, Some(plan.sql_to_execute.clone()));
+        assert_eq!(plan.page_limit, Some(100));
+        assert_eq!(plan.page_offset, Some(100));
+    }
+
+    #[test]
+    fn sqlserver_unsafe_projections_execute_original_sql_without_wrappers() {
+        let queries = [
+            "SELECT TOP 100 AAA, * FROM BBB",
+            "SELECT TOP 100 AAA, bbb AS aaa FROM BBB",
+            "SELECT TOP 100 a.id, b.id FROM AAA a JOIN BBB b ON a.id = b.id",
+            "SELECT TOP 100 a.*, b.* FROM AAA a JOIN BBB b ON a.id = b.id",
+            "SELECT TOP 100 a.*, * FROM AAA a",
+            "SELECT TOP 100 AAA + 1 FROM BBB",
+        ];
+
+        for sql in queries {
+            for offset in [0, 100] {
+                let plan = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {
+                    sql: sql.to_string(),
+                    query_base_sql: sql.to_string(),
+                    database_type: Some(DatabaseType::SqlServer),
+                    pagination: QueryPagination { limit: 100, offset, session_id: None },
+                    use_agent_cursor: false,
+                    first_page_uses_actual_sql: false,
+                });
+
+                assert_eq!(plan.sql_to_execute, sql);
+                assert!(plan.page_sql.is_none());
+                assert!(plan.count_sql.is_none());
+                assert_eq!(plan.page_limit, None);
+                assert_eq!(plan.page_offset, None);
+            }
+        }
+    }
+
+    #[test]
+    fn sqlserver_unsafe_projection_is_not_wrapped_for_count() {
+        let result = build_count_query_sql(CountQuerySqlOptions {
+            original_sql: "SELECT TOP 100 AAA, * FROM BBB".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+        });
+
+        assert_eq!(result, err("unsupported"));
+    }
+
+    #[test]
+    fn sqlserver_unsafe_projection_is_not_paginated_directly() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT TOP 100 AAA, * FROM BBB".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 100,
+        });
+
+        assert_eq!(result, err("unsupported"));
+    }
+
+    #[test]
+    fn sqlserver_unique_top_projection_keeps_server_pagination() {
+        let sql = "SELECT TOP 500 [id], [order_no] FROM [sales].[orders_10k]".to_string();
+        let plan = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {
+            sql: sql.clone(),
+            query_base_sql: sql,
+            database_type: Some(DatabaseType::SqlServer),
+            pagination: QueryPagination { limit: 100, offset: 100, session_id: None },
+            use_agent_cursor: false,
+            first_page_uses_actual_sql: false,
+        });
+
+        assert!(plan.sql_to_execute.contains("ROW_NUMBER()"));
+        assert_eq!(plan.page_sql, Some(plan.sql_to_execute.clone()));
+        assert_eq!(plan.page_limit, Some(100));
+        assert_eq!(plan.page_offset, Some(100));
+        assert!(plan.count_sql.is_some());
+    }
+
+    #[test]
+    fn paginates_sqlserver_top_parenthesized_projection_query_by_first_column() {
+        let sql = "SELECT TOP (500) [id], [order_no], [store_id], [product_id], [customer_name], [quantity], [amount], [order_status], [created_at] FROM [sales].[orders_10k]";
+        let first_page = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: sql.to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+        let second_page = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: sql.to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 100,
+        });
+
+        assert!(first_page.ok);
+        assert!(second_page.ok);
+        assert_eq!(
+            first_page.sql.unwrap(),
+            "SELECT TOP (100) * FROM (SELECT TOP (500) [id], [order_no], [store_id], [product_id], [customer_name], [quantity], [amount], [order_status], [created_at] FROM [sales].[orders_10k]) [dbx_page] ORDER BY [id];"
+        );
+        assert_eq!(
+            second_page.sql.unwrap(),
+            "SELECT * FROM (SELECT dbx_page_source.*, ROW_NUMBER() OVER (ORDER BY [id]) AS [__dbx_row_num] FROM (SELECT TOP (500) [id], [order_no], [store_id], [product_id], [customer_name], [quantity], [amount], [order_status], [created_at] FROM [sales].[orders_10k]) dbx_page_source) dbx_page WHERE [__dbx_row_num] > 100 AND [__dbx_row_num] <= 200 ORDER BY [__dbx_row_num];"
+        );
+    }
+
+    #[test]
+    fn paginates_sqlserver_top_query_with_qualified_first_projection_by_exposed_column() {
+        let sql = "select top 1  t1.FSUPPLIERID,  kh.FNAME gysnm   from  GDWORKOUT t1 join  SUPPLIER kh on t1.FSUPPLIERID=kh.FITEMID join GDWORKOUTS t2 on t1.fid=t2.fid";
+        let first_page = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: sql.to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+        let second_page = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: sql.to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 100,
+        });
+
+        assert!(first_page.ok);
+        assert!(second_page.ok);
+        assert_eq!(
+            first_page.sql.unwrap(),
+            "SELECT TOP (100) * FROM (select top 1  t1.FSUPPLIERID,  kh.FNAME gysnm   from  GDWORKOUT t1 join  SUPPLIER kh on t1.FSUPPLIERID=kh.FITEMID join GDWORKOUTS t2 on t1.fid=t2.fid) [dbx_page] ORDER BY [FSUPPLIERID];"
+        );
+        assert_eq!(
+            second_page.sql.unwrap(),
+            "SELECT * FROM (SELECT dbx_page_source.*, ROW_NUMBER() OVER (ORDER BY [FSUPPLIERID]) AS [__dbx_row_num] FROM (select top 1  t1.FSUPPLIERID,  kh.FNAME gysnm   from  GDWORKOUT t1 join  SUPPLIER kh on t1.FSUPPLIERID=kh.FITEMID join GDWORKOUTS t2 on t1.fid=t2.fid) dbx_page_source) dbx_page WHERE [__dbx_row_num] > 100 AND [__dbx_row_num] <= 200 ORDER BY [__dbx_row_num];"
+        );
+    }
+
+    #[test]
+    fn paginates_sqlserver_top_query_with_dotted_bracket_identifier() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT TOP 1000 [order.id] FROM TicketInfo".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT TOP (100) * FROM (SELECT TOP 1000 [order.id] FROM TicketInfo) [dbx_page] ORDER BY [order.id];"
+        );
+    }
+
+    #[test]
+    fn paginates_sqlserver_top_query_after_leading_comment_by_first_column() {
+        let sql = "-- 测试\nSELECT TOP (500) [id], [order_no], [store_id], [product_id], [customer_name], [quantity], [amount], [order_status], [created_at] FROM [sales].[orders_10k]";
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: sql.to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 100,
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT dbx_page_source.*, ROW_NUMBER() OVER (ORDER BY [id]) AS [__dbx_row_num] FROM (SELECT TOP (500) [id], [order_no], [store_id], [product_id], [customer_name], [quantity], [amount], [order_status], [created_at] FROM [sales].[orders_10k]) dbx_page_source) dbx_page WHERE [__dbx_row_num] > 100 AND [__dbx_row_num] <= 200 ORDER BY [__dbx_row_num];"
+        );
+    }
+
+    #[test]
+    fn sqlserver_cte_pagination_plan_executes_original_sql() {
+        let sql = ";WITH ranked AS (SELECT id FROM dbo.users) SELECT * FROM ranked".to_string();
+        let plan = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {
+            sql: sql.clone(),
+            query_base_sql: sql.clone(),
+            database_type: Some(DatabaseType::SqlServer),
+            pagination: QueryPagination { limit: 100, offset: 0, session_id: None },
+            use_agent_cursor: false,
+            first_page_uses_actual_sql: false,
+        });
+
+        assert_eq!(plan.sql_to_execute, sql);
+        assert!(plan.page_sql.is_none());
+        assert!(plan.count_sql.is_none());
+        assert_eq!(plan.page_limit, None);
+        assert_eq!(plan.page_offset, None);
+    }
+
+    #[test]
+    fn sqlserver_cte_count_query_is_not_wrapped_as_derived_table() {
+        let result = build_count_query_sql(CountQuerySqlOptions {
+            original_sql: ";WITH cte AS (SELECT 1 AS id) SELECT * FROM cte".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+        });
+
+        assert!(!result.ok);
+        assert!(result.sql.is_none());
+    }
+
+    #[test]
+    fn postgres_cte_update_is_not_paginated() {
+        let sql = r#"
+WITH available AS (
+    SELECT id
+    FROM app_users
+    WHERE deleted_at IS NULL
+),
+picked AS (
+    SELECT id
+    FROM available
+    ORDER BY random()
+    LIMIT 10
+)
+UPDATE app_users AS u
+SET subscription_type = 1
+FROM picked
+WHERE u.id = picked.id;
+"#;
+
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: sql.to_string(),
+            database_type: Some(DatabaseType::Postgres),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert_eq!(result, err("not_select"));
+    }
+
+    #[test]
+    fn postgres_cte_update_pagination_plan_executes_original_sql() {
+        let sql = "WITH picked AS (SELECT id FROM app_users LIMIT 10) UPDATE app_users SET subscription_type = 1 FROM picked WHERE app_users.id = picked.id".to_string();
+        let plan = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {
+            sql: sql.clone(),
+            query_base_sql: sql.clone(),
+            database_type: Some(DatabaseType::Postgres),
+            pagination: QueryPagination { limit: 100, offset: 0, session_id: None },
+            use_agent_cursor: false,
+            first_page_uses_actual_sql: false,
+        });
+
+        assert_eq!(plan.sql_to_execute, sql);
+        assert!(plan.page_sql.is_none());
+        assert!(plan.count_sql.is_none());
+        assert_eq!(plan.page_limit, None);
+        assert_eq!(plan.page_offset, None);
+    }
+
+    #[test]
+    fn postgres_cte_select_still_paginates() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "WITH picked AS (SELECT id FROM app_users LIMIT 10) SELECT * FROM picked".to_string(),
+            database_type: Some(DatabaseType::Postgres),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "WITH picked AS (SELECT id FROM app_users LIMIT 10) SELECT * FROM picked LIMIT 100;"
+        );
+    }
+
+    #[test]
+    fn clickhouse_scalar_with_select_is_paginated() {
+        let sql = "WITH 1 AS min_id SELECT dept, COUNT(*) FROM employees WHERE id >= min_id GROUP BY dept";
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: sql.to_string(),
+            database_type: Some(DatabaseType::ClickHouse),
+            limit: 50,
+            offset: 100,
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "WITH 1 AS min_id SELECT dept, COUNT(*) FROM employees WHERE id >= min_id GROUP BY dept LIMIT 50 OFFSET 100;"
+        );
+    }
+
+    #[test]
+    fn clickhouse_settings_clause_is_paginated_before_settings() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT * FROM system.clusters SETTINGS max_execution_time = 0".to_string(),
+            database_type: Some(DatabaseType::ClickHouse),
+            limit: 50,
+            offset: 100,
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM system.clusters LIMIT 50 OFFSET 100 SETTINGS max_execution_time = 0;"
+        );
+    }
+
+    #[test]
+    fn clickhouse_query_plan_places_limit_before_settings() {
+        let sql = "SELECT * FROM system.clusters SETTINGS max_execution_time = 0";
+        let plan = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {
+            sql: sql.to_string(),
+            query_base_sql: sql.to_string(),
+            database_type: Some(DatabaseType::ClickHouse),
+            pagination: QueryPagination { limit: 100, offset: 0, session_id: None },
+            use_agent_cursor: false,
+            first_page_uses_actual_sql: false,
+        });
+
+        assert_eq!(plan.sql_to_execute, "SELECT * FROM system.clusters LIMIT 100 SETTINGS max_execution_time = 0;");
+        assert_eq!(
+            plan.page_sql,
+            Some("SELECT * FROM system.clusters LIMIT 100 SETTINGS max_execution_time = 0;".to_string())
+        );
+        assert_eq!(plan.page_limit, Some(100));
+        assert_eq!(plan.page_offset, Some(0));
+    }
+
+    #[test]
+    fn clickhouse_scalar_with_select_can_be_counted() {
+        let result = build_count_query_sql(CountQuerySqlOptions {
+            original_sql: "WITH 1 AS min_id SELECT dept, COUNT(*) FROM employees WHERE id >= min_id GROUP BY dept"
+                .to_string(),
+            database_type: Some(DatabaseType::ClickHouse),
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT COUNT(*) AS dbx_total_rows FROM (WITH 1 AS min_id SELECT dept, COUNT(*) FROM employees WHERE id >= min_id GROUP BY dept) `dbx_count`;"
+        );
+    }
+
+    #[test]
+    fn clickhouse_scalar_with_update_is_not_paginated() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "WITH 1 AS min_id UPDATE employees SET dept = 'sales' WHERE id = min_id".to_string(),
+            database_type: Some(DatabaseType::ClickHouse),
+            limit: 50,
+            offset: 0,
+        });
+
+        assert_eq!(result, err("not_select"));
+    }
+
+    #[test]
+    fn wraps_sqlserver_select_with_unnamed_column() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT @@version".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT TOP (100) @@version");
+    }
+
+    #[test]
+    fn uses_sqlserver_row_number_pagination_for_later_pages() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 300,
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT dbx_page_source.*, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS [__dbx_row_num] FROM (SELECT id FROM users) dbx_page_source) dbx_page WHERE [__dbx_row_num] > 300 AND [__dbx_row_num] <= 400 ORDER BY [__dbx_row_num];"
+        );
+    }
+
+    #[test]
+    fn rejects_sqlserver_wildcard_later_pages_to_avoid_duplicate_columns() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql:
+                "SELECT b.ProjectType,* FROM VesselBusinessOpportunity a LEFT JOIN JDDR_sys_BasicConfig_ProjectInfo_Data b ON a.ProjectID = b.ID"
+                    .to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 100,
+        });
+
+        assert_eq!(result, err("unsupported"));
+    }
+
+    #[test]
+    fn keeps_sqlserver_offset_fetch_next_when_offset_is_zero() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT * FROM TABLE_NAME ORDER BY id OFFSET 1 ROWS FETCH NEXT 10 ROWS ONLY".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT * FROM TABLE_NAME ORDER BY id OFFSET 1 ROWS FETCH NEXT 10 ROWS ONLY");
+    }
+
+    #[test]
+    fn oracle_pagination_skips_sql_clause() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users".to_string(),
+            database_type: Some(DatabaseType::Oracle),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT id FROM users;");
+    }
+
+    #[test]
+    fn oceanbase_oracle_pagination_wraps_with_rownum() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users ORDER BY id".to_string(),
+            database_type: Some(DatabaseType::OceanbaseOracle),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT * FROM (SELECT id FROM users ORDER BY id) WHERE ROWNUM <= 100;");
+    }
+
+    #[test]
+    fn oceanbase_oracle_pagination_wraps_offset_with_rownum_bounds() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users ORDER BY id".to_string(),
+            database_type: Some(DatabaseType::OceanbaseOracle),
+            limit: 100,
+            offset: 200,
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT dbx_inner.*, ROWNUM AS \"__dbx_row_num\" FROM (SELECT id FROM users ORDER BY id) dbx_inner WHERE ROWNUM <= 300) WHERE \"__dbx_row_num\" > 200;"
+        );
+    }
+
+    #[test]
+    fn uses_fetch_first_pagination_for_db2() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users".to_string(),
+            database_type: Some(DatabaseType::Db2),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT id FROM users FETCH FIRST 100 ROWS ONLY;");
+    }
+
+    #[test]
+    fn uses_skip_first_pagination_for_informix() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users WHERE active = 1".to_string(),
+            database_type: Some(DatabaseType::Informix),
+            limit: 50,
+            offset: 100,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT SKIP 100 FIRST 50 id FROM users WHERE active = 1;");
+    }
+
+    #[test]
+    fn informix_pagination_keeps_existing_first() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT FIRST 20 id FROM users".to_string(),
+            database_type: Some(DatabaseType::Informix),
+            limit: 50,
+            offset: 0,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT FIRST 20 id FROM users;");
+    }
+
+    #[test]
+    fn uses_rows_pagination_for_firebird() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users WHERE active = 1 ORDER BY id".to_string(),
+            database_type: Some(DatabaseType::Firebird),
+            limit: 50,
+            offset: 100,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT id FROM users WHERE active = 1 ORDER BY id ROWS 101 TO 150;");
+    }
+
+    #[test]
+    fn firebird_pagination_keeps_existing_rows_clause() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users ROWS 20".to_string(),
+            database_type: Some(DatabaseType::Firebird),
+            limit: 50,
+            offset: 0,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT id FROM users ROWS 20;");
+    }
+
+    #[test]
+    fn uses_mysql_style_alias_for_pagination() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users WHERE active = 1".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+            limit: 50,
+            offset: 0,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT id FROM users WHERE active = 1 LIMIT 50;");
+    }
+
+    #[test]
+    fn mysql_pagination_does_not_wrap_duplicate_result_columns() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT p.id, t.id FROM table1 p LEFT JOIN table2 t ON p.f = t.f".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+            limit: 50,
+            offset: 100,
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT p.id, t.id FROM table1 p LEFT JOIN table2 t ON p.f = t.f LIMIT 50 OFFSET 100;"
+        );
+    }
+
+    #[test]
+    fn mysql_pagination_keeps_limit_outside_trailing_line_comment() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT 1 AS id\n-- tail comment".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+            limit: 50,
+            offset: 0,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT 1 AS id\n-- tail comment\nLIMIT 50;");
+    }
+
+    #[test]
+    fn mysql_pagination_keeps_limit_outside_trailing_hash_comment() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT 1 AS id\n# tail comment".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+            limit: 50,
+            offset: 0,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT 1 AS id\n# tail comment\nLIMIT 50;");
+    }
+
+    #[test]
+    fn mysql_pagination_keeps_existing_top_level_limit() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users LIMIT 20;".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+            limit: 50,
+            offset: 0,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT id FROM users LIMIT 20;");
+    }
+
+    #[test]
+    fn mysql_pagination_wraps_wide_existing_limit_on_first_page() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT * FROM dy_promotion_item WHERE create_time < '2026-06-01' LIMIT 10000;".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+            limit: 500,
+            offset: 0,
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT * FROM dy_promotion_item WHERE create_time < '2026-06-01' LIMIT 10000) `dbx_page` LIMIT 500 OFFSET 0;"
+        );
+    }
+
+    #[test]
+    fn mysql_pagination_wraps_comma_limit_row_count_on_first_page() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT * FROM users LIMIT 20, 10000;".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+            limit: 500,
+            offset: 0,
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT * FROM users LIMIT 20, 10000) `dbx_page` LIMIT 500 OFFSET 0;"
+        );
+    }
+
+    #[test]
+    fn mysql_pagination_wraps_existing_limit_for_later_pages() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT * FROM dy_promotion_item WHERE create_time < '2026-06-01' LIMIT 10000;".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+            limit: 1000,
+            offset: 1000,
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT * FROM dy_promotion_item WHERE create_time < '2026-06-01' LIMIT 10000) `dbx_page` LIMIT 1000 OFFSET 1000;"
+        );
+    }
+
+    #[test]
+    fn standard_pagination_wraps_existing_limit_for_later_pages() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id FROM users LIMIT 20;".to_string(),
+            database_type: Some(DatabaseType::Postgres),
+            limit: 5,
+            offset: 10,
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT id FROM users LIMIT 20) \"dbx_page\" LIMIT 5 OFFSET 10;"
+        );
+    }
+
+    #[test]
+    fn rejects_multiple_statements_for_pagination() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT 1; SELECT 2;".to_string(),
+            database_type: Some(DatabaseType::Postgres),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert_eq!(result, err("multi"));
+    }
+
+    #[test]
+    fn rejects_select_into_for_pagination() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT * INTO copy_users FROM users WHERE active = 1".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert_eq!(result, err("not_select"));
+    }
+
+    #[test]
+    fn builds_count_query() {
+        let result = build_count_query_sql(CountQuerySqlOptions {
+            original_sql: "WITH cte AS (SELECT 1 AS id) SELECT * FROM cte".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT COUNT(*) AS dbx_total_rows FROM (WITH cte AS (SELECT 1 AS id) SELECT * FROM cte) `dbx_count`;"
+        );
+    }
+
+    #[test]
+    fn count_query_keeps_wrapper_outside_trailing_line_comment() {
+        let result = build_count_query_sql(CountQuerySqlOptions {
+            original_sql: "SELECT 1 AS id\n-- tail comment".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT COUNT(*) AS dbx_total_rows FROM (SELECT 1 AS id\n-- tail comment\n) `dbx_count`;"
+        );
+    }
+
+    #[test]
+    fn count_query_keeps_wrapper_outside_trailing_hash_comment() {
+        let result = build_count_query_sql(CountQuerySqlOptions {
+            original_sql: "SELECT 1 AS id\n# tail comment".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT COUNT(*) AS dbx_total_rows FROM (SELECT 1 AS id\n# tail comment\n) `dbx_count`;"
+        );
+    }
+
+    #[test]
+    fn count_query_preserves_user_limit() {
+        let result = build_count_query_sql(CountQuerySqlOptions {
+            original_sql: "SELECT * FROM dy_promotion_item WHERE create_time < '2026-06-01' LIMIT 10000".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT COUNT(*) AS dbx_total_rows FROM (SELECT * FROM dy_promotion_item WHERE create_time < '2026-06-01' LIMIT 10000) `dbx_count`;"
+        );
+    }
+
+    #[test]
+    fn count_query_preserves_user_limit_offset() {
+        let result = build_count_query_sql(CountQuerySqlOptions {
+            original_sql: "SELECT * FROM users WHERE active = 1 LIMIT 100 OFFSET 50".to_string(),
+            database_type: Some(DatabaseType::Postgres),
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT COUNT(*) AS dbx_total_rows FROM (SELECT * FROM users WHERE active = 1 LIMIT 100 OFFSET 50) \"dbx_count\";"
+        );
+    }
+
+    #[test]
+    fn builds_agent_cursor_pagination_plan() {
+        let plan = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {
+            sql: "SELECT * FROM events".to_string(),
+            query_base_sql: "SELECT * FROM events".to_string(),
+            database_type: Some(DatabaseType::Oracle),
+            pagination: QueryPagination { limit: 500, offset: 0, session_id: None },
+            use_agent_cursor: true,
+            first_page_uses_actual_sql: false,
+        });
+
+        assert_eq!(plan.sql_to_execute, "SELECT * FROM events");
+        assert_eq!(plan.page_limit, Some(500));
+        assert_eq!(plan.page_offset, Some(0));
+        assert!(plan.page_sql.is_none());
+        assert!(plan.use_agent_result_session);
+    }
+
+    #[test]
+    fn export_agent_cursor_first_page_keeps_actual_sorted_sql() {
+        let plan = build_query_pagination_execution_plan(QueryPaginationExecutionPlanOptions {
+            sql: "SELECT * FROM (SELECT * FROM events) t ORDER BY created_at DESC".to_string(),
+            query_base_sql: "SELECT * FROM events".to_string(),
+            database_type: Some(DatabaseType::Oracle),
+            pagination: QueryPagination { limit: 500, offset: 0, session_id: None },
+            use_agent_cursor: true,
+            first_page_uses_actual_sql: true,
+        });
+
+        assert_eq!(plan.sql_to_execute, "SELECT * FROM (SELECT * FROM events) t ORDER BY created_at DESC");
+        assert_eq!(plan.page_limit, Some(500));
+        assert_eq!(plan.page_offset, Some(0));
+        assert!(plan.page_sql.is_none());
+        assert!(plan.use_agent_result_session);
+    }
+
+    #[test]
+    fn builds_sorted_query_sql() {
+        let result = build_sorted_query_sql(SortedQuerySqlOptions {
+            original_sql: "SELECT c.id, m.id FROM t_campaign c LEFT JOIN t_campaign_mdf m ON m.campaign_id = c.id"
+                .to_string(),
+            database_type: Some(DatabaseType::Postgres),
+            result_columns: vec!["id".to_string(), "id".to_string()],
+            column_index: 1,
+            column: "id".to_string(),
+            direction: QuerySortDirection::Asc,
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT c.id, m.id FROM t_campaign c LEFT JOIN t_campaign_mdf m ON m.campaign_id = c.id) t(\"id\", \"id_2\") ORDER BY \"id_2\" ASC;"
+        );
+    }
+
+    #[test]
+    fn builds_sorted_query_sql_for_first_result_column() {
+        let result = build_sorted_query_sql(SortedQuerySqlOptions {
+            original_sql: "SELECT iso3, year, gdp_pc FROM country_gdp".to_string(),
+            database_type: Some(DatabaseType::Postgres),
+            result_columns: vec!["iso3".to_string(), "year".to_string(), "gdp_pc".to_string()],
+            column_index: 0,
+            column: "iso3".to_string(),
+            direction: QuerySortDirection::Asc,
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT iso3, year, gdp_pc FROM country_gdp) t(\"iso3\", \"year\", \"gdp_pc\") ORDER BY \"iso3\" ASC;"
+        );
+    }
+
+    #[test]
+    fn builds_mysql_sorted_query_without_alias_list() {
+        let result = build_sorted_query_sql(SortedQuerySqlOptions {
+            original_sql: "SELECT * FROM admin LIMIT 100;".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+            result_columns: vec![
+                "id".to_string(),
+                "guid".to_string(),
+                "role_guid".to_string(),
+                "login_name".to_string(),
+                "password".to_string(),
+            ],
+            column_index: 3,
+            column: "login_name".to_string(),
+            direction: QuerySortDirection::Asc,
+        });
+
+        assert_eq!(result.sql.unwrap(), "SELECT * FROM (SELECT * FROM admin LIMIT 100) t ORDER BY `login_name` ASC;");
+    }
+
+    #[test]
+    fn builds_clickhouse_sorted_query_without_alias_list() {
+        let result = build_sorted_query_sql(SortedQuerySqlOptions {
+            original_sql: "SELECT id, part_day, hid FROM events LIMIT 100".to_string(),
+            database_type: Some(DatabaseType::ClickHouse),
+            result_columns: vec!["id".to_string(), "part_day".to_string(), "hid".to_string()],
+            column_index: 0,
+            column: "id".to_string(),
+            direction: QuerySortDirection::Desc,
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT id, part_day, hid FROM events LIMIT 100) t ORDER BY `id` DESC;"
+        );
+    }
+
+    #[test]
+    fn strips_sqlserver_order_by_for_sorted_query() {
+        let result = build_sorted_query_sql(SortedQuerySqlOptions {
+            original_sql: "SELECT id, name FROM users ORDER BY id DESC".to_string(),
+            database_type: Some(DatabaseType::SqlServer),
+            result_columns: vec!["id".to_string(), "name".to_string()],
+            column_index: 1,
+            column: "name".to_string(),
+            direction: QuerySortDirection::Asc,
+        });
+
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT id, name FROM users) t([id], [name]) ORDER BY [name] ASC;"
+        );
+    }
+
+    #[test]
+    fn rejects_with_query_sorting() {
+        let result = build_sorted_query_sql(SortedQuerySqlOptions {
+            original_sql: "WITH cte AS (SELECT 1) SELECT * FROM cte".to_string(),
+            database_type: Some(DatabaseType::Postgres),
+            result_columns: vec!["id".to_string()],
+            column_index: 0,
+            column: "id".to_string(),
+            direction: QuerySortDirection::Asc,
+        });
+
+        assert_eq!(result, err("with"));
+    }
+
+    // -----------------------------------------------------------------------
+    // Dedup query ORDER BY injection (DISTINCT / GROUP BY)
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn dedup_count_detects_distinct_query_without_order_by() {
+        assert_eq!(dedup_projection_count_without_order_by("SELECT DISTINCT a, b, c FROM t"), Some(3));
+    }
+
+    #[test]
+    fn dedup_count_detects_group_by_query() {
+        assert_eq!(dedup_projection_count_without_order_by("SELECT city, COUNT(*) FROM users GROUP BY city"), Some(2));
+    }
+
+    #[test]
+    fn dedup_count_returns_none_for_plain_select() {
+        assert_eq!(dedup_projection_count_without_order_by("SELECT a, b FROM t"), None);
+    }
+
+    #[test]
+    fn dedup_count_returns_none_when_order_by_exists() {
+        assert_eq!(dedup_projection_count_without_order_by("SELECT DISTINCT a, b FROM t ORDER BY a"), None);
+    }
+
+    #[test]
+    fn dedup_count_returns_none_for_wildcard() {
+        assert_eq!(dedup_projection_count_without_order_by("SELECT DISTINCT * FROM t"), None);
+    }
+
+    #[test]
+    fn doris_distinct_query_first_page_gets_order_by() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT DISTINCT city, name FROM users".to_string(),
+            database_type: Some(DatabaseType::Doris),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT DISTINCT city, name FROM users ORDER BY 1, 2 LIMIT 100;");
+    }
+
+    #[test]
+    fn doris_distinct_query_second_page_wraps_with_order_by() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT DISTINCT city, name FROM users".to_string(),
+            database_type: Some(DatabaseType::Doris),
+            limit: 100,
+            offset: 100,
+        });
+
+        assert!(result.ok);
+        // No top-level LIMIT in the original query, so ORDER BY + LIMIT + OFFSET
+        // are appended directly to the statement (no wrapping needed).
+        assert_eq!(result.sql.unwrap(), "SELECT DISTINCT city, name FROM users ORDER BY 1, 2 LIMIT 100 OFFSET 100;");
+    }
+
+    #[test]
+    fn doris_group_by_query_first_page_gets_order_by() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT dept, SUM(salary) FROM employees GROUP BY dept".to_string(),
+            database_type: Some(DatabaseType::Doris),
+            limit: 50,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT dept, SUM(salary) FROM employees GROUP BY dept ORDER BY 1, 2 LIMIT 50;"
+        );
+    }
+
+    #[test]
+    fn doris_plain_query_without_distinct_is_unaffected() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT id, name FROM users".to_string(),
+            database_type: Some(DatabaseType::Doris),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT id, name FROM users LIMIT 100;");
+    }
+
+    #[test]
+    fn doris_distinct_with_existing_limit_first_page_keeps_order_by() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT DISTINCT a, b, c FROM t LIMIT 500".to_string(),
+            database_type: Some(DatabaseType::Doris),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        // The dedup query has a LIMIT, so it must be wrapped.
+        // `add_outer_standard_limit` always includes OFFSET clause.
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT * FROM (SELECT DISTINCT a, b, c FROM t LIMIT 500) `dbx_page` ORDER BY 1, 2, 3 LIMIT 100 OFFSET 0;"
+        );
+    }
+
+    #[test]
+    fn mysql_distinct_query_first_page_gets_order_by() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT DISTINCT city FROM users".to_string(),
+            database_type: Some(DatabaseType::Mysql),
+            limit: 200,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT DISTINCT city FROM users ORDER BY 1 LIMIT 200;");
+    }
+
+    #[test]
+    fn postgres_distinct_query_first_page_gets_order_by() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT DISTINCT city, name FROM users".to_string(),
+            database_type: Some(DatabaseType::Postgres),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(result.sql.unwrap(), "SELECT DISTINCT city, name FROM users ORDER BY 1, 2 LIMIT 100;");
+    }
+
+    #[test]
+    fn distinct_query_with_existing_order_by_is_not_modified() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT DISTINCT a, b FROM t ORDER BY a".to_string(),
+            database_type: Some(DatabaseType::Doris),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        // Already has ORDER BY, so only LIMIT is appended.
+        assert_eq!(result.sql.unwrap(), "SELECT DISTINCT a, b FROM t ORDER BY a LIMIT 100;");
+    }
+
+    // -----------------------------------------------------------------------
+    // Complex queries with aliases, expressions, subqueries
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn dedup_count_handles_aliases() {
+        assert_eq!(dedup_projection_count_without_order_by("SELECT DISTINCT a AS x, b AS y, c AS z FROM t"), Some(3));
+    }
+
+    #[test]
+    fn dedup_count_handles_expressions() {
+        assert_eq!(
+            dedup_projection_count_without_order_by(
+                "SELECT DISTINCT a + b AS sum_col, CASE WHEN c > 0 THEN 'Y' ELSE 'N' END AS flag FROM t"
+            ),
+            Some(2)
+        );
+    }
+
+    #[test]
+    fn dedup_count_handles_aggregate_with_alias() {
+        assert_eq!(
+            dedup_projection_count_without_order_by(
+                "SELECT city, COUNT(*) AS cnt, AVG(salary) AS avg_sal FROM users GROUP BY city"
+            ),
+            Some(3)
+        );
+    }
+
+    #[test]
+    fn doris_distinct_with_alias_and_expression_gets_positional_order_by() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql:
+                "SELECT DISTINCT a AS col1, b + c AS col2, CASE WHEN d > 0 THEN 'Y' ELSE 'N' END AS col3 FROM t"
+                    .to_string(),
+            database_type: Some(DatabaseType::Doris),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        // Positional ORDER BY 1, 2, 3 works regardless of aliases or expressions.
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT DISTINCT a AS col1, b + c AS col2, CASE WHEN d > 0 THEN 'Y' ELSE 'N' END AS col3 FROM t ORDER BY 1, 2, 3 LIMIT 100;"
+        );
+    }
+
+    #[test]
+    fn doris_group_by_with_aggregate_alias_gets_positional_order_by() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql: "SELECT dept, SUM(salary) AS total, COUNT(*) AS head_count FROM emp GROUP BY dept"
+                .to_string(),
+            database_type: Some(DatabaseType::Doris),
+            limit: 50,
+            offset: 100,
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT dept, SUM(salary) AS total, COUNT(*) AS head_count FROM emp GROUP BY dept ORDER BY 1, 2, 3 LIMIT 50 OFFSET 100;"
+        );
+    }
+
+    #[test]
+    fn doris_distinct_with_subquery_column_gets_positional_order_by() {
+        let result = build_paginated_query_sql(PaginatedQuerySqlOptions {
+            original_sql:
+                "SELECT DISTINCT name, (SELECT MAX(score) FROM scores s WHERE s.uid = u.id) AS max_score FROM users u"
+                    .to_string(),
+            database_type: Some(DatabaseType::Doris),
+            limit: 100,
+            offset: 0,
+        });
+
+        assert!(result.ok);
+        assert_eq!(
+            result.sql.unwrap(),
+            "SELECT DISTINCT name, (SELECT MAX(score) FROM scores s WHERE s.uid = u.id) AS max_score FROM users u ORDER BY 1, 2 LIMIT 100;"
+        );
+    }
+
+    #[test]
+    fn union_query_is_not_treated_as_dedup() {
+        assert_eq!(dedup_projection_count_without_order_by("SELECT a FROM t1 UNION SELECT b FROM t2"), None);
+    }
+}
diff --git a/crates/dbx-core/src/redis_ops.rs b/crates/dbx-core/src/redis_ops.rs
new file mode 100644
index 0000000..5c2bb8f
--- /dev/null
+++ b/crates/dbx-core/src/redis_ops.rs
@@ -0,0 +1,901 @@
+use crate::connection::{AppState, PoolKind};
+use crate::db::redis_driver::{
+    self, RedisCollectionPage, RedisCommandResult, RedisConnection, RedisDatabaseInfo, RedisKeyInfo, RedisScanResult,
+    RedisValue,
+};
+
+async fn ensure_redis_pool(state: &AppState, connection_id: &str) -> Result<(), String> {
+    state.get_or_create_pool(connection_id, None).await.map(|_| ())
+}
+
+pub async fn redis_list_databases_core(
+    state: &AppState,
+    connection_id: &str,
+) -> Result<Vec<RedisDatabaseInfo>, String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    let pool = connections.get(connection_id).ok_or("Connection not found")?;
+    match pool {
+        PoolKind::Redis(redis) => match redis {
+            RedisConnection::Direct(con) => {
+                let mut con = con.lock().await;
+                redis_driver::list_databases(&mut *con).await
+            }
+            RedisConnection::Cluster(cluster) => redis_driver::list_cluster_databases(cluster).await,
+        },
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_scan_keys_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    cursor: u64,
+    pattern: &str,
+    count: usize,
+) -> Result<RedisScanResult, String> {
+    redis_scan_keys_batch_core(state, connection_id, db, cursor, pattern, count, 1, true).await
+}
+
+/// Batch-scan keys with server-side multi-SCAN support.
+///
+/// Performs up to `max_iterations` SCAN cycles server-side in a single API
+/// call, dramatically reducing frontend↔backend roundtrips when fetching many
+/// keys (e.g. "fetch all" in the key browser). TYPE metadata is optional.
+pub async fn redis_scan_keys_batch_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    cursor: u64,
+    pattern: &str,
+    count: usize,
+    max_iterations: usize,
+    include_types: bool,
+) -> Result<RedisScanResult, String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    let pool = connections.get(connection_id).ok_or("Connection not found")?;
+    match pool {
+        PoolKind::Redis(redis) => match redis {
+            RedisConnection::Direct(con) => {
+                let mut con = con.lock().await;
+                redis_driver::select_db(&mut *con, db).await?;
+                redis_driver::scan_keys_batch(&mut *con, cursor, pattern, count, max_iterations, include_types).await
+            }
+            RedisConnection::Cluster(cluster) => {
+                redis_driver::ensure_cluster_db(db)?;
+                // Cluster scan already iterates across nodes; for batch mode we
+                // loop the cluster-level scan to accumulate keys server-side.
+                if max_iterations <= 1 {
+                    return redis_driver::scan_cluster_keys_page_with_options(
+                        cluster,
+                        cursor,
+                        pattern,
+                        count,
+                        include_types,
+                    )
+                    .await;
+                }
+                let mut all_keys: Vec<RedisKeyInfo> = Vec::new();
+                let mut current_cursor = cursor;
+                let mut total_keys: u64 = 0;
+                for i in 0..max_iterations {
+                    let page = redis_driver::scan_cluster_keys_page_with_options(
+                        cluster,
+                        current_cursor,
+                        pattern,
+                        count,
+                        include_types,
+                    )
+                    .await?;
+                    if i == 0 {
+                        total_keys = page.total_keys;
+                    }
+                    all_keys.extend(page.keys);
+                    if page.cursor == 0 {
+                        return Ok(RedisScanResult { cursor: 0, keys: all_keys, total_keys });
+                    }
+                    current_cursor = page.cursor;
+                }
+                Ok(RedisScanResult { cursor: current_cursor, keys: all_keys, total_keys })
+            }
+        },
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub async fn redis_scan_values_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    cursor: u64,
+    pattern: &str,
+    query: &str,
+    include_key_matches: bool,
+    count: usize,
+) -> Result<RedisScanResult, String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    let pool = connections.get(connection_id).ok_or("Connection not found")?;
+    match pool {
+        PoolKind::Redis(redis) => match redis {
+            RedisConnection::Direct(con) => {
+                let mut con = con.lock().await;
+                redis_driver::select_db(&mut *con, db).await?;
+                redis_driver::scan_values_page(&mut *con, cursor, pattern, query, include_key_matches, count).await
+            }
+            RedisConnection::Cluster(cluster) => {
+                redis_driver::ensure_cluster_db(db)?;
+                redis_driver::scan_cluster_values_page(cluster, cursor, pattern, query, include_key_matches, count)
+                    .await
+            }
+        },
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_get_value_core(state: &AppState, connection_id: &str, key: &str) -> Result<RedisValue, String> {
+    redis_get_value_in_db_core(state, connection_id, 0, key).await
+}
+
+pub async fn redis_get_value_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+) -> Result<RedisValue, String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    let pool = connections.get(connection_id).ok_or("Connection not found")?;
+    match pool {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::get_value(&mut *con, &key).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::get_value(&mut con, &key).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_set_string_core(
+    state: &AppState,
+    connection_id: &str,
+    key: &str,
+    value: &str,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    redis_set_string_in_db_core(state, connection_id, 0, key, value, ttl).await
+}
+
+pub async fn redis_set_string_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    value: &str,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    let pool = connections.get(connection_id).ok_or("Connection not found")?;
+    match pool {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::set_string(&mut *con, &key, value, ttl).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::set_string(&mut con, &key, value, ttl).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_delete_key_core(state: &AppState, connection_id: &str, key: &str) -> Result<(), String> {
+    redis_delete_key_in_db_core(state, connection_id, 0, key).await
+}
+
+pub async fn redis_delete_key_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    let pool = connections.get(connection_id).ok_or("Connection not found")?;
+    match pool {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::delete_key(&mut *con, &key).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::delete_key(&mut con, &key).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_hash_set_core(
+    state: &AppState,
+    connection_id: &str,
+    key: &str,
+    field: &str,
+    value: &str,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    redis_hash_set_in_db_core(state, connection_id, 0, key, field, value, ttl).await
+}
+
+pub async fn redis_hash_set_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    field: &str,
+    value: &str,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::hash_set(&mut *con, &key, field, value, ttl).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::hash_set(&mut con, &key, field, value, ttl).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_hash_del_core(state: &AppState, connection_id: &str, key: &str, field: &str) -> Result<(), String> {
+    redis_hash_del_in_db_core(state, connection_id, 0, key, field).await
+}
+
+pub async fn redis_hash_del_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    field: &str,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::hash_del(&mut *con, &key, field).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::hash_del(&mut con, &key, field).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_list_push_core(
+    state: &AppState,
+    connection_id: &str,
+    key: &str,
+    value: &str,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    redis_list_push_in_db_core(state, connection_id, 0, key, value, ttl).await
+}
+
+pub async fn redis_list_push_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    value: &str,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::list_push(&mut *con, &key, value, ttl).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::list_push(&mut con, &key, value, ttl).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_list_set_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    index: i64,
+    value: &str,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::list_set(&mut *con, &key, index, value).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::list_set(&mut con, &key, index, value).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_list_remove_core(
+    state: &AppState,
+    connection_id: &str,
+    key: &str,
+    index: i64,
+) -> Result<(), String> {
+    redis_list_remove_in_db_core(state, connection_id, 0, key, index).await
+}
+
+pub async fn redis_list_remove_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    index: i64,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::list_remove(&mut *con, &key, index).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::list_remove(&mut con, &key, index).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_set_add_core(
+    state: &AppState,
+    connection_id: &str,
+    key: &str,
+    member: &str,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    redis_set_add_in_db_core(state, connection_id, 0, key, member, ttl).await
+}
+
+pub async fn redis_set_add_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    member: &str,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::set_add(&mut *con, &key, member, ttl).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::set_add(&mut con, &key, member, ttl).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_set_remove_core(
+    state: &AppState,
+    connection_id: &str,
+    key: &str,
+    member: &str,
+) -> Result<(), String> {
+    redis_set_remove_in_db_core(state, connection_id, 0, key, member).await
+}
+
+pub async fn redis_set_remove_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    member: &str,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::set_remove(&mut *con, &key, member).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::set_remove(&mut con, &key, member).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_zadd_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    member: &str,
+    score: f64,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::zadd(&mut *con, &key, member, score, ttl).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::zadd(&mut con, &key, member, score, ttl).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_zrem_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    member: &str,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::zrem(&mut *con, &key, member).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::zrem(&mut con, &key, member).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_stream_add_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    entry_id: &str,
+    fields: Vec<(String, String)>,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::stream_add(&mut *con, &key, entry_id, &fields, ttl).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::stream_add(&mut con, &key, entry_id, &fields, ttl).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_json_set_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    value: &str,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::json_set(&mut *con, &key, value, ttl).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::json_set(&mut con, &key, value, ttl).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_check_json_module_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+) -> Result<bool, String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => match redis {
+            RedisConnection::Direct(con) => {
+                let mut con = con.lock().await;
+                redis_driver::select_db(&mut *con, db).await?;
+                redis_driver::check_json_module(&mut *con).await
+            }
+            RedisConnection::Cluster(cluster) => {
+                redis_driver::ensure_cluster_db(db)?;
+                let mut con = redis_driver::cluster_any_connection(cluster).await?;
+                redis_driver::check_json_module(&mut con).await
+            }
+        },
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_set_ttl_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    ttl: i64,
+) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::set_ttl(&mut *con, &key, ttl).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::set_ttl(&mut con, &key, ttl).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_delete_keys_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raws: &[String],
+) -> Result<u64, String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let keys: Result<Vec<Vec<u8>>, String> =
+                key_raws.iter().map(|k| redis_driver::redis_key_raw_to_bytes(k)).collect();
+            let keys = keys?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::delete_keys(&mut *con, &keys).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut deleted = 0;
+                    for key in &keys {
+                        let mut con = redis_driver::cluster_key_connection(cluster, key).await?;
+                        deleted += redis_driver::delete_keys(&mut con, std::slice::from_ref(key)).await?;
+                    }
+                    Ok(deleted)
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_flush_db_core(state: &AppState, connection_id: &str, db: u32) -> Result<(), String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => match redis {
+            RedisConnection::Direct(con) => {
+                let mut con = con.lock().await;
+                redis_driver::select_db(&mut *con, db).await?;
+                redis_driver::flush_db(&mut *con).await
+            }
+            RedisConnection::Cluster(cluster) => {
+                redis_driver::ensure_cluster_db(db)?;
+                redis_driver::flush_cluster(cluster).await
+            }
+        },
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_execute_command_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    command: &str,
+    skip_safety_check: bool,
+) -> Result<RedisCommandResult, String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => match redis {
+            RedisConnection::Direct(con) => {
+                let mut con = con.lock().await;
+                redis_driver::select_db(&mut *con, db).await?;
+                redis_driver::execute_command(&mut *con, command, skip_safety_check).await
+            }
+            RedisConnection::Cluster(cluster) => {
+                redis_driver::ensure_cluster_db(db)?;
+                let mut con = if let Ok(argv) = redis_driver::parse_command_argv(command) {
+                    if let Some(command_name) = argv.first() {
+                        if command_name.eq_ignore_ascii_case("SELECT") {
+                            return Err("Redis Cluster only supports db0; SELECT is not available".to_string());
+                        }
+                    }
+                    if command_may_target_first_key(&argv) {
+                        redis_driver::cluster_key_connection(cluster, argv[1].as_bytes()).await?
+                    } else {
+                        redis_driver::cluster_any_connection(cluster).await?
+                    }
+                } else {
+                    redis_driver::cluster_any_connection(cluster).await?
+                };
+                redis_driver::execute_command(&mut con, command, skip_safety_check).await
+            }
+        },
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+fn command_may_target_first_key(argv: &[String]) -> bool {
+    if argv.len() < 2 {
+        return false;
+    }
+    match argv[0].to_ascii_uppercase().as_str() {
+        "PING" | "INFO" | "DBSIZE" | "TIME" | "ROLE" | "CLUSTER" | "CLIENT" | "COMMAND" | "HELLO" | "AUTH" | "QUIT" => {
+            false
+        }
+        _ => true,
+    }
+}
+
+pub async fn redis_load_more_in_db_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    key_raw: &str,
+    key_type: &str,
+    cursor: u64,
+    count: usize,
+    filter: Option<&str>,
+) -> Result<RedisCollectionPage, String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => {
+            let key = redis_driver::redis_key_raw_to_bytes(key_raw)?;
+            match redis {
+                RedisConnection::Direct(con) => {
+                    let mut con = con.lock().await;
+                    redis_driver::select_db(&mut *con, db).await?;
+                    redis_driver::load_more_collection(&mut *con, &key, key_type, cursor, count, filter).await
+                }
+                RedisConnection::Cluster(cluster) => {
+                    redis_driver::ensure_cluster_db(db)?;
+                    let mut con = redis_driver::cluster_key_connection(cluster, &key).await?;
+                    redis_driver::load_more_collection(&mut con, &key, key_type, cursor, count, filter).await
+                }
+            }
+        }
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_publish_core(
+    state: &AppState,
+    connection_id: &str,
+    db: u32,
+    channel: &str,
+    message: &str,
+) -> Result<u64, String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => match redis {
+            RedisConnection::Direct(con) => {
+                let mut con = con.lock().await;
+                redis_driver::select_db(&mut *con, db).await?;
+                redis_driver::publish_message(&mut *con, channel, message).await
+            }
+            RedisConnection::Cluster(cluster) => {
+                redis_driver::ensure_cluster_db(db)?;
+                let mut con = redis_driver::cluster_any_connection(cluster).await?;
+                redis_driver::publish_message(&mut con, channel, message).await
+            }
+        },
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_create_pubsub_core(state: &AppState, connection_id: &str) -> Result<redis::aio::PubSub, String> {
+    let configs = state.configs.read().await;
+    let config = configs.get(connection_id).ok_or("Connection config not found")?.clone();
+    drop(configs);
+
+    if config.db_type != crate::models::connection::DatabaseType::Redis {
+        return Err("Not a Redis connection".to_string());
+    }
+
+    let (host, port) = state.connection_host_port(connection_id, &config).await?;
+    let timeout = std::time::Duration::from_secs(config.effective_connect_timeout_secs());
+    redis_driver::connect_pubsub(&config, &host, port, timeout).await
+}
+
+pub async fn redis_slowlog_get_core(
+    state: &AppState,
+    connection_id: &str,
+    count: usize,
+    node_host: Option<String>,
+    node_port: Option<u16>,
+) -> Result<Vec<redis_driver::RedisSlowlogEntry>, String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => match redis {
+            RedisConnection::Direct(con) => {
+                let mut con = con.lock().await;
+                // SLOWLOG is a server-level command, no select_db needed
+                redis_driver::get_slowlog(&mut *con, count).await
+            }
+            RedisConnection::Cluster(cluster) => {
+                if let (Some(host), Some(port)) = (node_host.as_ref(), node_port) {
+                    let endpoint = redis_driver::RedisNodeEndpoint { host: host.clone(), port };
+                    let mut con = redis_driver::connect_cluster_node(cluster, &endpoint).await?;
+                    redis_driver::get_slowlog(&mut con, count).await
+                } else {
+                    // No node specified — return empty (frontend enforces selection)
+                    Ok(Vec::new())
+                }
+            }
+        },
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
+
+pub async fn redis_cluster_master_nodes_core(
+    state: &AppState,
+    connection_id: &str,
+) -> Result<Vec<redis_driver::RedisNodeEndpoint>, String> {
+    ensure_redis_pool(state, connection_id).await?;
+    let connections = state.connections.read().await;
+    match connections.get(connection_id).ok_or("Not found")? {
+        PoolKind::Redis(redis) => match redis {
+            RedisConnection::Cluster(cluster) => redis_driver::cluster_master_nodes(cluster).await,
+            _ => Ok(Vec::new()),
+        },
+        _ => Err("Not a Redis connection".to_string()),
+    }
+}
diff --git a/crates/dbx-core/src/saved_sql.rs b/crates/dbx-core/src/saved_sql.rs
new file mode 100644
index 0000000..55bac4b
--- /dev/null
+++ b/crates/dbx-core/src/saved_sql.rs
@@ -0,0 +1,46 @@
+use serde::{Deserialize, Serialize};
+
+fn default_sql_loaded() -> bool {
+    true
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SavedSqlFolder {
+    pub id: String,
+    pub connection_id: String,
+    pub parent_folder_id: Option<String>,
+    pub name: String,
+    #[serde(default)]
+    pub order_index: i64,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SavedSqlFile {
+    pub id: String,
+    pub connection_id: String,
+    pub folder_id: Option<String>,
+    pub name: String,
+    pub database: String,
+    pub schema: Option<String>,
+    pub sql: String,
+    #[serde(default = "default_sql_loaded")]
+    pub sql_loaded: bool,
+    #[serde(default)]
+    pub order_index: i64,
+    #[serde(default)]
+    pub open_count: i64,
+    pub opened_at: Option<String>,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SavedSqlLibrary {
+    pub folders: Vec<SavedSqlFolder>,
+    pub files: Vec<SavedSqlFile>,
+}
diff --git a/crates/dbx-core/src/schema.rs b/crates/dbx-core/src/schema.rs
new file mode 100644
index 0000000..de2a821
--- /dev/null
+++ b/crates/dbx-core/src/schema.rs
@@ -0,0 +1,6090 @@
+use crate::connection::{connection_url_for_endpoint, database_connection_config, AppState, MysqlMode, PoolKind};
+use crate::db;
+use crate::models::connection::{ConnectionConfig, DatabaseType};
+use crate::query::{agent_execute_query_params, should_discard_pool_after_error, QueryExecutionOptions};
+use std::collections::HashMap;
+use std::future::Future;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+macro_rules! extract_pool {
+    ($connections:expr, $key:expr, $variant:ident) => {
+        $connections.get($key).and_then(|v| match v {
+            PoolKind::$variant(val) => Some(val.clone()),
+            _ => None,
+        })
+    };
+}
+
+macro_rules! dispatch_mysql {
+    ($p:expr, $mode:expr, $mysql:path, $ob:path $(, $arg:expr)*) => {
+        if *$mode == MysqlMode::OceanBaseOracle {
+            $ob($p $(, $arg)*).await
+        } else {
+            $mysql($p $(, $arg)*).await
+        }
+    };
+}
+
+macro_rules! try_sqlserver {
+    ($connections:expr, $pool_key:expr, $method:ident $(, $arg:expr)*) => {
+        if let Some(client) = extract_pool!(&$connections, $pool_key, SqlServer) {
+            drop($connections);
+            let mut client = client.lock().await;
+            return db::sqlserver::$method(&mut client $(, $arg)*).await;
+        }
+    };
+}
+
+const ORACLE_TABLE_COMMENT_BATCH_SIZE: usize = 500;
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_query_tables(con: &duckdb::Connection) -> Result<Vec<db::TableInfo>, String> {
+    duckdb_query_tables_in_database(con, "main", "main")
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_query_tables_in_database(
+    con: &duckdb::Connection,
+    database: &str,
+    schema: &str,
+) -> Result<Vec<db::TableInfo>, String> {
+    duckdb_query_tables_in_database_with_attached(con, database, schema, &[])
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_query_tables_in_database_with_attached(
+    con: &duckdb::Connection,
+    database: &str,
+    schema: &str,
+    attached_names: &[String],
+) -> Result<Vec<db::TableInfo>, String> {
+    let database = duckdb_catalog_name(con, database, attached_names)?;
+    let mut stmt = con.prepare(
+        "SELECT table_name, table_type FROM information_schema.tables WHERE table_catalog = ? AND table_schema = ? ORDER BY table_name"
+    ).map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map((database.as_str(), schema), |row| {
+            Ok(db::TableInfo {
+                name: row.get::<_, String>(0)?,
+                table_type: row.get::<_, String>(1)?,
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            })
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(rows.filter_map(|r| r.ok()).collect())
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_attach_database(con: &duckdb::Connection, name: &str, path: &str) -> Result<(), String> {
+    let name = name.trim();
+    let path = path.trim();
+    if name.is_empty() || path.is_empty() {
+        return Err("DuckDB attached database name and path are required".to_string());
+    }
+    let sql = format!("ATTACH {} AS {}", duckdb_quote_string(path), duckdb_quote_ident(name));
+    con.execute_batch(&sql).map_err(|e| e.to_string())
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_list_databases(con: &duckdb::Connection) -> Result<Vec<db::DatabaseInfo>, String> {
+    duckdb_list_databases_with_attached(con, &[])
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_list_databases_with_attached(
+    con: &duckdb::Connection,
+    attached_names: &[String],
+) -> Result<Vec<db::DatabaseInfo>, String> {
+    let primary = duckdb_primary_catalog(con, attached_names)?;
+    let mut stmt = con.prepare("SHOW DATABASES").map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map([], |row| {
+            let name = row.get::<_, String>(0)?;
+            Ok(db::DatabaseInfo { name: if name == primary { "main".to_string() } else { name } })
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(rows.filter_map(|row| row.ok()).collect())
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_list_schemas(con: &duckdb::Connection, database: &str) -> Result<Vec<String>, String> {
+    duckdb_list_schemas_with_attached(con, database, &[])
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_list_schemas_with_attached(
+    con: &duckdb::Connection,
+    database: &str,
+    attached_names: &[String],
+) -> Result<Vec<String>, String> {
+    let database = duckdb_catalog_name(con, database, attached_names)?;
+    let mut stmt = con
+        .prepare(
+            "SELECT schema_name FROM information_schema.schemata WHERE catalog_name = ? AND schema_name NOT IN ('information_schema', 'pg_catalog') ORDER BY schema_name",
+        )
+        .map_err(|e| e.to_string())?;
+    let rows = stmt.query_map([database.as_str()], |row| row.get::<_, String>(0)).map_err(|e| e.to_string())?;
+    Ok(rows.filter_map(|r| r.ok()).collect())
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_catalog_name(con: &duckdb::Connection, database: &str, attached_names: &[String]) -> Result<String, String> {
+    if database.trim().is_empty() || database == "main" {
+        return duckdb_primary_catalog(con, attached_names);
+    }
+    Ok(database.to_string())
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_primary_catalog(con: &duckdb::Connection, attached_names: &[String]) -> Result<String, String> {
+    if attached_names.is_empty() {
+        return duckdb_current_database(con);
+    }
+    let attached: std::collections::HashSet<String> = attached_names.iter().map(|name| name.to_lowercase()).collect();
+    let mut stmt = con.prepare("SHOW DATABASES").map_err(|e| e.to_string())?;
+    let rows = stmt.query_map([], |row| row.get::<_, String>(0)).map_err(|e| e.to_string())?;
+    for row in rows {
+        let name = row.map_err(|e| e.to_string())?;
+        if !attached.contains(&name.to_lowercase()) {
+            return Ok(name);
+        }
+    }
+    duckdb_current_database(con)
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_current_database(con: &duckdb::Connection) -> Result<String, String> {
+    con.query_row("SELECT current_database()", [], |row| row.get::<_, String>(0)).map_err(|e| e.to_string())
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_quote_ident(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_quote_string(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_query_columns(con: &duckdb::Connection, table: &str) -> Result<Vec<db::ColumnInfo>, String> {
+    duckdb_query_columns_in_database(con, "main", "main", table)
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_query_columns_in_database(
+    con: &duckdb::Connection,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::ColumnInfo>, String> {
+    duckdb_query_columns_in_database_with_attached(con, database, schema, table, &[])
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_query_columns_in_database_with_attached(
+    con: &duckdb::Connection,
+    database: &str,
+    schema: &str,
+    table: &str,
+    attached_names: &[String],
+) -> Result<Vec<db::ColumnInfo>, String> {
+    let database = duckdb_catalog_name(con, database, attached_names)?;
+    let mut pk_stmt = con
+        .prepare(
+            "SELECT kcu.column_name
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+          AND tc.table_name = kcu.table_name
+         WHERE tc.constraint_type = 'PRIMARY KEY'
+           AND tc.table_catalog = ?
+           AND tc.table_schema = ?
+           AND tc.table_name = ?
+         ORDER BY kcu.ordinal_position",
+        )
+        .map_err(|e| e.to_string())?;
+    let pk_rows = pk_stmt
+        .query_map((database.as_str(), schema, table), |row| row.get::<_, String>(0))
+        .map_err(|e| e.to_string())?;
+    let primary_keys: std::collections::HashSet<String> = pk_rows.filter_map(|r| r.ok()).collect();
+    let column_comments = duckdb_column_comments(con, &database, schema, table);
+
+    let mut stmt = con
+        .prepare(
+            "SELECT column_name, data_type, is_nullable, column_default
+         FROM information_schema.columns
+         WHERE table_catalog = ? AND table_schema = ? AND table_name = ?
+         ORDER BY ordinal_position",
+        )
+        .map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map((database.as_str(), schema, table), |row| {
+            let name = row.get::<_, String>(0)?;
+            let comment = column_comments.get(&name).cloned().flatten();
+            Ok(db::ColumnInfo {
+                is_primary_key: primary_keys.contains(&name),
+                name,
+                data_type: row.get::<_, String>(1)?,
+                is_nullable: row.get::<_, String>(2).unwrap_or_default() == "YES",
+                column_default: row.get::<_, Option<String>>(3)?,
+                extra: None,
+                comment,
+                numeric_precision: None,
+                numeric_scale: None,
+                character_maximum_length: None,
+                enum_values: None,
+                ..Default::default()
+            })
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(rows.filter_map(|r| r.ok()).collect())
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_column_comments(
+    con: &duckdb::Connection,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> HashMap<String, Option<String>> {
+    let Ok(mut stmt) = con.prepare(
+        "SELECT column_name, comment FROM duckdb_columns() \
+         WHERE database_name = ? AND schema_name = ? AND table_name = ?",
+    ) else {
+        // Older DuckDB versions may not expose the comment column; keep metadata browsing functional.
+        return HashMap::new();
+    };
+    let Ok(rows) = stmt
+        .query_map((database, schema, table), |row| Ok((row.get::<_, String>(0)?, row.get::<_, Option<String>>(1)?)))
+    else {
+        return HashMap::new();
+    };
+    rows.filter_map(Result::ok).collect()
+}
+
+#[cfg(feature = "duckdb-bundled")]
+pub fn duckdb_completion_assistant_search(
+    con: &duckdb::Connection,
+    request: &db::CompletionAssistantRequest,
+    attached_names: &[String],
+) -> Result<db::CompletionAssistantResponse, String> {
+    let limit = request.max_results.unwrap_or(100).clamp(1, 1000);
+    let kinds = if request.object_kinds.is_empty() {
+        vec![db::CompletionAssistantObjectKind::Table, db::CompletionAssistantObjectKind::View]
+    } else {
+        request.object_kinds.clone()
+    };
+    let mut candidates = Vec::new();
+
+    if kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::Schema)) {
+        candidates.extend(duckdb_completion_schemas(con, request, attached_names, limit)?);
+        if candidates.len() >= limit {
+            return Ok(db::CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
+        }
+    }
+
+    if kinds.iter().any(db::CompletionAssistantObjectKind::is_table_like) {
+        candidates.extend(duckdb_completion_tables(con, request, &kinds, attached_names, limit - candidates.len())?);
+        if candidates.len() >= limit {
+            return Ok(db::CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
+        }
+    }
+
+    if kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::Column)) {
+        candidates.extend(duckdb_completion_columns(con, request, attached_names, limit - candidates.len())?);
+        if candidates.len() >= limit {
+            return Ok(db::CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
+        }
+    }
+
+    Ok(db::CompletionAssistantResponse { candidates, incomplete: false, fallback_used: false })
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_completion_schemas(
+    con: &duckdb::Connection,
+    request: &db::CompletionAssistantRequest,
+    attached_names: &[String],
+    limit: usize,
+) -> Result<Vec<db::CompletionAssistantCandidate>, String> {
+    if limit == 0 {
+        return Ok(Vec::new());
+    }
+    let database = duckdb_catalog_name(con, &request.database, attached_names)?;
+    let pattern = duckdb_completion_like_pattern(request);
+    let mut stmt = con
+        .prepare(
+            "SELECT schema_name
+             FROM information_schema.schemata
+             WHERE catalog_name = ?
+               AND schema_name NOT IN ('information_schema', 'pg_catalog')
+               AND lower(schema_name) LIKE lower(?) ESCAPE '\\'
+             ORDER BY schema_name
+             LIMIT ?",
+        )
+        .map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map((database.as_str(), pattern.as_str(), limit as i64), |row| {
+            let schema = row.get::<_, String>(0)?;
+            Ok(db::CompletionAssistantCandidate {
+                name: schema.clone(),
+                kind: db::CompletionAssistantCandidateKind::Schema,
+                database: Some(request.database.clone()),
+                schema: Some(schema),
+                parent_schema: None,
+                parent_name: None,
+                comment: None,
+                data_type: None,
+            })
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(rows.filter_map(|row| row.ok()).collect())
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_completion_tables(
+    con: &duckdb::Connection,
+    request: &db::CompletionAssistantRequest,
+    kinds: &[db::CompletionAssistantObjectKind],
+    attached_names: &[String],
+    limit: usize,
+) -> Result<Vec<db::CompletionAssistantCandidate>, String> {
+    if limit == 0 {
+        return Ok(Vec::new());
+    }
+    let database = duckdb_catalog_name(con, &request.database, attached_names)?;
+    let schema = request.parent_schema.as_deref().or(request.schema.as_deref()).unwrap_or("main");
+    let include_tables = kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::Table));
+    let include_views = kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::View));
+    let pattern = duckdb_completion_like_pattern(request);
+    let mut stmt = con
+        .prepare(
+            "SELECT table_name, table_type
+             FROM information_schema.tables
+             WHERE table_catalog = ?
+               AND table_schema = ?
+               AND ((? AND table_type = 'BASE TABLE') OR (? AND table_type = 'VIEW'))
+               AND lower(table_name) LIKE lower(?) ESCAPE '\\'
+             ORDER BY table_name
+             LIMIT ?",
+        )
+        .map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map((database.as_str(), schema, include_tables, include_views, pattern.as_str(), limit as i64), |row| {
+            let table_type = row.get::<_, String>(1)?;
+            Ok(db::CompletionAssistantCandidate {
+                name: row.get(0)?,
+                kind: if table_type.eq_ignore_ascii_case("VIEW") {
+                    db::CompletionAssistantCandidateKind::View
+                } else {
+                    db::CompletionAssistantCandidateKind::Table
+                },
+                database: Some(request.database.clone()),
+                schema: Some(schema.to_string()),
+                parent_schema: None,
+                parent_name: None,
+                comment: None,
+                data_type: None,
+            })
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(rows.filter_map(|row| row.ok()).collect())
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_completion_columns(
+    con: &duckdb::Connection,
+    request: &db::CompletionAssistantRequest,
+    attached_names: &[String],
+    limit: usize,
+) -> Result<Vec<db::CompletionAssistantCandidate>, String> {
+    if limit == 0 {
+        return Ok(Vec::new());
+    }
+    let Some(table) = request.parent_name.as_deref().filter(|table| !table.trim().is_empty()) else {
+        return Ok(Vec::new());
+    };
+    let database = duckdb_catalog_name(con, &request.database, attached_names)?;
+    let schema = request.parent_schema.as_deref().or(request.schema.as_deref()).unwrap_or("main");
+    let pattern = duckdb_completion_like_pattern(request);
+    let mut stmt = con
+        .prepare(
+            "SELECT column_name, data_type
+             FROM information_schema.columns
+             WHERE table_catalog = ?
+               AND table_schema = ?
+               AND table_name = ?
+               AND lower(column_name) LIKE lower(?) ESCAPE '\\'
+             ORDER BY ordinal_position
+             LIMIT ?",
+        )
+        .map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map((database.as_str(), schema, table, pattern.as_str(), limit as i64), |row| {
+            Ok(db::CompletionAssistantCandidate {
+                name: row.get(0)?,
+                kind: db::CompletionAssistantCandidateKind::Column,
+                database: Some(request.database.clone()),
+                schema: Some(schema.to_string()),
+                parent_schema: Some(schema.to_string()),
+                parent_name: Some(table.to_string()),
+                comment: None,
+                data_type: Some(row.get(1)?),
+            })
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(rows.filter_map(|row| row.ok()).collect())
+}
+
+#[cfg(feature = "duckdb-bundled")]
+fn duckdb_completion_like_pattern(request: &db::CompletionAssistantRequest) -> String {
+    let mask = request.mask.trim().trim_matches('%');
+    let escaped = mask.replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_");
+    match request.match_mode.as_ref().unwrap_or(&db::CompletionAssistantMatchMode::Prefix) {
+        db::CompletionAssistantMatchMode::Prefix => format!("{escaped}%"),
+        db::CompletionAssistantMatchMode::Contains => format!("%{escaped}%"),
+    }
+}
+
+#[cfg(feature = "duckdb-bundled")]
+async fn duckdb_attached_database_names(state: &AppState, connection_id: &str) -> Vec<String> {
+    state
+        .configs
+        .read()
+        .await
+        .get(connection_id)
+        .map(|config| config.attached_databases.iter().map(|database| database.name.clone()).collect())
+        .unwrap_or_default()
+}
+
+fn clickhouse_metadata_database<'a>(database: &'a str, schema: &'a str) -> &'a str {
+    if database.is_empty() {
+        schema
+    } else {
+        database
+    }
+}
+
+fn agent_metadata_timeout(config: Option<&ConnectionConfig>) -> Option<Duration> {
+    let Some(config) = config else {
+        return Some(Duration::from_secs(60));
+    };
+    match config.effective_query_timeout_secs() {
+        0 => None,
+        seconds => Some(Duration::from_secs(seconds.max(60))),
+    }
+}
+
+pub async fn list_databases_core(state: &AppState, connection_id: &str) -> Result<Vec<db::DatabaseInfo>, String> {
+    retry_metadata_connection(state, connection_id, None, || list_databases_once(state, connection_id)).await
+}
+
+pub async fn list_sqlserver_linked_servers_core(
+    state: &AppState,
+    connection_id: &str,
+) -> Result<Vec<db::LinkedServerInfo>, String> {
+    let connections = state.connections.read().await;
+    if let Some(client) = extract_pool!(&connections, connection_id, SqlServer) {
+        drop(connections);
+        let mut client = client.lock().await;
+        return db::sqlserver::list_linked_servers(&mut client).await;
+    }
+    Ok(vec![])
+}
+
+pub async fn list_sqlserver_linked_server_catalogs_core(
+    state: &AppState,
+    connection_id: &str,
+    server: &str,
+) -> Result<Vec<db::DatabaseInfo>, String> {
+    let connections = state.connections.read().await;
+    if let Some(client) = extract_pool!(&connections, connection_id, SqlServer) {
+        drop(connections);
+        let mut client = client.lock().await;
+        return db::sqlserver::list_linked_server_catalogs(&mut client, server).await;
+    }
+    Ok(vec![])
+}
+
+pub async fn list_sqlserver_linked_server_schemas_core(
+    state: &AppState,
+    connection_id: &str,
+    server: &str,
+    catalog: &str,
+) -> Result<Vec<String>, String> {
+    let connections = state.connections.read().await;
+    if let Some(client) = extract_pool!(&connections, connection_id, SqlServer) {
+        drop(connections);
+        let mut client = client.lock().await;
+        return db::sqlserver::list_linked_server_schemas(&mut client, server, catalog).await;
+    }
+    Ok(vec![])
+}
+
+pub async fn list_sqlserver_linked_server_tables_core(
+    state: &AppState,
+    connection_id: &str,
+    server: &str,
+    catalog: &str,
+    schema: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+) -> Result<Vec<db::TableInfo>, String> {
+    let connections = state.connections.read().await;
+    if let Some(client) = extract_pool!(&connections, connection_id, SqlServer) {
+        drop(connections);
+        let mut client = client.lock().await;
+        return db::sqlserver::list_linked_server_tables(&mut client, server, catalog, schema, filter, limit, offset)
+            .await;
+    }
+    Ok(vec![])
+}
+
+// ---------------------------------------------------------------------------
+// Doris / StarRocks multi-catalog federation.
+//
+// These engines expose external catalogs (iceberg, hive, jdbc, ...) alongside
+// the native `internal` catalog via `SHOW CATALOGS`. The functions below browse
+// a specific catalog's databases/tables and read table metadata using 3-part
+// qualified names (`<catalog>.<database>.<table>`), which the engines accept
+// directly. The native `internal` catalog continues to use the existing
+// `list_databases_core` / `list_tables_core` paths.
+// ---------------------------------------------------------------------------
+
+/// `SHOW CATALOGS` → catalogs visible to the current user. Returns an empty
+/// list when the connection pool is not a MySQL pool (Doris/StarRocks always
+/// use the MySQL protocol, so this is a defensive no-op); the caller's
+/// flat-sidebar fallback then renders the standard database list.
+pub async fn list_doris_catalogs_core(state: &AppState, connection_id: &str) -> Result<Vec<db::CatalogInfo>, String> {
+    let pool_key = state.get_or_create_pool(connection_id, None).await?;
+    let connections = state.connections.read().await;
+    if let Some(PoolKind::Mysql(p, _)) = connections.get(&pool_key) {
+        return db::mysql::list_doris_catalogs(p).await;
+    }
+    Ok(vec![])
+}
+
+/// `SHOW DATABASES FROM <catalog>` → databases in the given catalog.
+///
+/// For `internal`, system databases are filtered (mirroring `list_databases_core`).
+/// For external catalogs, permission errors degrade to an empty list (the user
+/// asked that inaccessible catalogs simply not be shown).
+pub async fn list_doris_catalog_databases_core(
+    state: &AppState,
+    connection_id: &str,
+    catalog: &str,
+) -> Result<Vec<db::DatabaseInfo>, String> {
+    let pool_key = state.get_or_create_pool(connection_id, None).await?;
+    let db_config = connection_config(state, connection_id).await;
+    let connections = state.connections.read().await;
+    let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+    let PoolKind::Mysql(p, _) = pool else {
+        return Ok(vec![]);
+    };
+    let databases = db::mysql::list_databases_show_from(p, catalog).await;
+    // External catalogs may reject `SHOW DATABASES FROM <catalog>` when the user
+    // lacks permission — surface as an empty list rather than an error.
+    let databases = match databases {
+        Ok(databases) => databases,
+        Err(error) => {
+            log::warn!(
+                "[schema][doris:list_catalog_databases] connection_id={} catalog={} error={}",
+                connection_id,
+                catalog,
+                error
+            );
+            return Ok(vec![]);
+        }
+    };
+    if catalog == "internal" {
+        return Ok(filter_mysql_system_databases_for_config(databases, db_config.as_ref()));
+    }
+    Ok(databases)
+}
+
+/// `SHOW TABLES FROM <catalog>.<database>` → tables in an external catalog.
+pub async fn list_doris_catalog_tables_core(
+    state: &AppState,
+    connection_id: &str,
+    catalog: &str,
+    database: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<&[String]>,
+) -> Result<Vec<db::TableInfo>, String> {
+    let pool_key = state.get_or_create_pool(connection_id, None).await?;
+    let connections = state.connections.read().await;
+    let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+    let PoolKind::Mysql(p, _) = pool else {
+        return Ok(vec![]);
+    };
+    db::mysql::list_tables_show_from(p, catalog, database)
+        .await
+        .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types))
+}
+
+/// Columns of an external catalog table via `SHOW COLUMNS FROM <catalog>.<db>.<table>`.
+pub async fn get_doris_catalog_columns_core(
+    state: &AppState,
+    connection_id: &str,
+    catalog: &str,
+    database: &str,
+    table: &str,
+) -> Result<Vec<db::ColumnInfo>, String> {
+    let pool_key = state.get_or_create_pool(connection_id, None).await?;
+    let connections = state.connections.read().await;
+    let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+    let PoolKind::Mysql(p, _) = pool else {
+        return Ok(vec![]);
+    };
+    db::mysql::get_columns_show_from(p, catalog, database, table).await.map(deduplicate_column_infos)
+}
+
+/// DDL for an external catalog table via `SHOW CREATE TABLE <catalog>.<db>.<table>`.
+pub async fn get_doris_catalog_table_ddl_core(
+    state: &AppState,
+    connection_id: &str,
+    catalog: &str,
+    database: &str,
+    table: &str,
+) -> Result<String, String> {
+    let pool_key = state.get_or_create_pool(connection_id, None).await?;
+    let connections = state.connections.read().await;
+    let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+    let PoolKind::Mysql(p, _) = pool else {
+        return Err("DDL not supported for this connection".to_string());
+    };
+    db::mysql::show_create_table_ddl_from(p, catalog, database, table).await
+}
+
+/// Best-effort index listing for an external catalog table (derived from DDL).
+pub async fn list_doris_catalog_indexes_core(
+    state: &AppState,
+    connection_id: &str,
+    catalog: &str,
+    database: &str,
+    table: &str,
+) -> Result<Vec<db::IndexInfo>, String> {
+    let pool_key = state.get_or_create_pool(connection_id, None).await?;
+    let connections = state.connections.read().await;
+    let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+    let PoolKind::Mysql(p, _) = pool else {
+        return Ok(vec![]);
+    };
+    db::mysql::list_doris_catalog_indexes(p, catalog, database, table).await
+}
+
+/// Table comment for an external catalog table. Doris does not reliably expose
+/// comments for external catalog tables, so this returns `None`.
+pub async fn get_doris_catalog_table_comment_core(
+    _state: &AppState,
+    _connection_id: &str,
+    _catalog: &str,
+    _database: &str,
+    _table: &str,
+) -> Result<Option<String>, String> {
+    Ok(None)
+}
+
+/// Foreign keys are not applicable to external catalog tables.
+pub async fn list_doris_catalog_foreign_keys_core(
+    _state: &AppState,
+    _connection_id: &str,
+    _catalog: &str,
+    _database: &str,
+    _table: &str,
+) -> Result<Vec<db::ForeignKeyInfo>, String> {
+    Ok(vec![])
+}
+
+/// Triggers are not applicable to external catalog tables.
+pub async fn list_doris_catalog_triggers_core(
+    _state: &AppState,
+    _connection_id: &str,
+    _catalog: &str,
+    _database: &str,
+    _table: &str,
+) -> Result<Vec<db::TriggerInfo>, String> {
+    Ok(vec![])
+}
+
+/// Resolve a non-internal catalog for dispatch to the Doris multi-catalog path.
+/// Returns `Some(catalog)` only when `catalog` is a non-empty, non-`internal`
+/// name and the connection is a Doris-family engine that supports
+/// `SHOW CATALOGS`. Otherwise `None` (caller uses the default metadata path).
+pub async fn resolve_external_doris_catalog(
+    state: &AppState,
+    connection_id: &str,
+    catalog: Option<&str>,
+) -> Option<String> {
+    let catalog = catalog?.trim();
+    if catalog.is_empty() || catalog == "internal" {
+        return None;
+    }
+    let config = connection_config(state, connection_id).await?;
+    if is_doris_family_catalog_capable_config(&config) {
+        Some(catalog.to_string())
+    } else {
+        None
+    }
+}
+
+async fn list_databases_once(state: &AppState, connection_id: &str) -> Result<Vec<db::DatabaseInfo>, String> {
+    log::info!("[list_databases] connection_id={connection_id}");
+    let db_config = connection_config(state, connection_id).await;
+    {
+        let connections = state.connections.read().await;
+        #[cfg(feature = "duckdb-bundled")]
+        if extract_pool!(&connections, connection_id, ExternalTabular).is_some() {
+            return Ok(vec![db::DatabaseInfo { name: "main".to_string() }]);
+        }
+        if let Some(PoolKind::ExternalDriver { config, session, .. }) = connections.get(connection_id) {
+            let config = config.clone();
+            let session = session.clone();
+            drop(connections);
+            return session
+                .invoke_with_timeout::<Vec<db::DatabaseInfo>>(
+                    "listDatabases",
+                    serde_json::json!({ "connection": config.as_ref() }),
+                    agent_metadata_timeout(Some(config.as_ref())),
+                )
+                .await;
+        }
+        if let Some(client) = extract_pool!(&connections, connection_id, ClickHouse) {
+            drop(connections);
+            return db::clickhouse_driver::list_databases(&client).await;
+        }
+        if let Some(client) = extract_pool!(&connections, connection_id, InfluxDb) {
+            drop(connections);
+            return db::influxdb_driver::list_databases(&client).await;
+        }
+        try_sqlserver!(connections, connection_id, list_databases);
+        if let Some(client) = extract_pool!(&connections, connection_id, Agent) {
+            let is_mongo =
+                state.configs.read().await.get(connection_id).is_some_and(|c| c.db_type == DatabaseType::MongoDb);
+            if is_mongo {
+                drop(connections);
+                let dbs = crate::mongo_ops::mongo_list_databases_core(state, connection_id).await?;
+                return Ok(dbs.into_iter().map(|name| db::DatabaseInfo { name }).collect());
+            }
+            drop(connections);
+            let mut client = client.lock().await;
+            return client.list_databases(agent_metadata_timeout(db_config.as_ref())).await;
+        }
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    let duckdb_attached_names = duckdb_attached_database_names(state, connection_id).await;
+    let db_config = connection_config(state, connection_id).await;
+    let connections = state.connections.read().await;
+    let pool = connections.get(connection_id).ok_or("Connection not found")?;
+
+    match pool {
+        PoolKind::Mysql(p, _) if db_config.as_ref().is_some_and(is_doris_family_config) => {
+            db::mysql::list_databases_show(p)
+                .await
+                .map(|databases| filter_mysql_system_databases_for_config(databases, db_config.as_ref()))
+        }
+        PoolKind::Mysql(p, mode) => dispatch_mysql!(p, mode, db::mysql::list_databases, db::ob_oracle::list_databases),
+        PoolKind::Postgres(p) => db::postgres::list_databases(p).await,
+        PoolKind::Sqlite(p) => db::sqlite::list_databases(p).await,
+        PoolKind::Rqlite(client) => db::rqlite_driver::list_databases(client).await,
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::DuckDb(con) => {
+            let con = con.lock().map_err(|e| e.to_string())?;
+            duckdb_list_databases_with_attached(&con, &duckdb_attached_names)
+        }
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::DuckDbWorker(client) => {
+            let client = client.clone();
+            drop(connections);
+            client.list_databases().await
+        }
+        PoolKind::CloudflareD1(client) => db::cloudflare_d1_driver::list_databases(client).await,
+        _ => Ok(vec![]),
+    }
+}
+
+pub async fn list_schemas_core(state: &AppState, connection_id: &str, database: &str) -> Result<Vec<String>, String> {
+    list_schemas_core_with_visible_filter(state, connection_id, database, false).await
+}
+
+pub async fn list_schemas_core_with_visible_filter(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    apply_visible_filter: bool,
+) -> Result<Vec<String>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || {
+        list_schemas_once(state, connection_id, database, apply_visible_filter)
+    })
+    .await
+}
+
+pub async fn list_schema_infos_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+) -> Result<Vec<db::SchemaInfo>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || {
+        list_schema_infos_once(state, connection_id, database)
+    })
+    .await
+}
+
+async fn list_schema_infos_once(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+) -> Result<Vec<db::SchemaInfo>, String> {
+    let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+    {
+        let connections = state.connections.read().await;
+        if let Some(PoolKind::Postgres(pool)) = connections.get(&pool_key) {
+            return db::postgres::list_schema_infos(pool).await;
+        }
+    }
+
+    let schemas = list_schemas_once(state, connection_id, database, false).await?;
+    Ok(schemas.into_iter().map(|name| db::SchemaInfo { name, comment: None }).collect())
+}
+
+pub async fn list_data_types_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+) -> Result<Vec<String>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        let db_config = connection_config(state, connection_id).await;
+        let connections = state.connections.read().await;
+        if let Some(PoolKind::ExternalDriver { config, session, .. }) = connections.get(&pool_key) {
+            let config = config.clone();
+            let session = session.clone();
+            drop(connections);
+            return session
+                .invoke_with_timeout::<Vec<String>>(
+                    "listDataTypes",
+                    serde_json::json!({ "connection": config.as_ref(), "database": database }),
+                    agent_metadata_timeout(Some(config.as_ref())),
+                )
+                .await
+                .map(deduplicate_data_type_names);
+        }
+        if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+            drop(connections);
+            let mut client = client.lock().await;
+            return client
+                .list_data_types::<Vec<String>>(database, agent_metadata_timeout(db_config.as_ref()))
+                .await
+                .map(deduplicate_data_type_names);
+        }
+        Ok(Vec::new())
+    })
+    .await
+}
+
+fn deduplicate_data_type_names(names: Vec<String>) -> Vec<String> {
+    let mut seen = std::collections::HashSet::new();
+    let mut result = Vec::new();
+    for name in names {
+        let trimmed = name.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        let key = trimmed.to_ascii_lowercase();
+        if seen.insert(key) {
+            result.push(trimmed.to_string());
+        }
+    }
+    result
+}
+
+async fn list_schemas_once(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    apply_visible_filter: bool,
+) -> Result<Vec<String>, String> {
+    let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+    let db_config = connection_config(state, connection_id).await;
+    let visible_schema_filter = visible_schema_filter(db_config.as_ref(), database, apply_visible_filter);
+
+    {
+        let connections = state.connections.read().await;
+        if let Some(PoolKind::ExternalDriver { config, session, .. }) = connections.get(&pool_key) {
+            let config = config.clone();
+            let session = session.clone();
+            drop(connections);
+            return session
+                .invoke_with_timeout::<Vec<String>>(
+                    "listSchemas",
+                    serde_json::json!({ "connection": config.as_ref(), "database": database }),
+                    agent_metadata_timeout(Some(config.as_ref())),
+                )
+                .await;
+        }
+        try_sqlserver!(connections, &pool_key, list_schemas);
+        if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+            let fallback_config = db_config.clone();
+            drop(connections);
+            let mut client = client.lock().await;
+            match client
+                .list_schemas_filtered::<Vec<String>>(
+                    database,
+                    visible_schema_filter.as_deref(),
+                    agent_metadata_timeout(db_config.as_ref()),
+                )
+                .await
+            {
+                Ok(schemas) if !schemas.is_empty() => {
+                    return Ok(filter_visible_schema_names(schemas, visible_schema_filter.as_deref()))
+                }
+                Ok(schemas) => {
+                    if let Some(config) = fallback_config.as_ref() {
+                        match native_postgres_metadata_pool(state, connection_id, database, config).await {
+                            Ok(Some(pool)) => {
+                                return db::postgres::list_schemas(&pool).await.map(|schemas| {
+                                    filter_visible_schema_names(schemas, visible_schema_filter.as_deref())
+                                })
+                            }
+                            Ok(None) => {
+                                return Ok(filter_visible_schema_names(schemas, visible_schema_filter.as_deref()))
+                            }
+                            Err(error) => {
+                                log::warn!(
+                                    "[schema][agent:list_schemas:fallback-failed] connection_id={} database={} error={}",
+                                    connection_id,
+                                    database,
+                                    error
+                                );
+                            }
+                        }
+                    }
+                    return Ok(filter_visible_schema_names(schemas, visible_schema_filter.as_deref()));
+                }
+                Err(agent_error) => {
+                    if let Some(config) = fallback_config.as_ref() {
+                        if let Some(pool) =
+                            native_postgres_metadata_pool(state, connection_id, database, config).await?
+                        {
+                            return db::postgres::list_schemas(&pool)
+                                .await
+                                .map(|schemas| filter_visible_schema_names(schemas, visible_schema_filter.as_deref()))
+                                .map_err(|fallback_error| {
+                                    format!(
+                                        "{agent_error}\n\nNative PostgreSQL metadata fallback failed: {fallback_error}"
+                                    )
+                                });
+                        }
+                    }
+                    return Err(agent_error);
+                }
+            }
+        }
+    }
+
+    let connections = state.connections.read().await;
+    let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+    match pool {
+        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => db::ob_oracle::list_schemas(p)
+            .await
+            .map(|schemas| filter_visible_schema_names(schemas, visible_schema_filter.as_deref())),
+        PoolKind::Postgres(p) => db::postgres::list_schemas(p)
+            .await
+            .map(|schemas| filter_visible_schema_names(schemas, visible_schema_filter.as_deref())),
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::DuckDb(con) => {
+            let duckdb_attached_names = duckdb_attached_database_names(state, connection_id).await;
+            let con = con.lock().map_err(|e| e.to_string())?;
+            duckdb_list_schemas_with_attached(&con, database, &duckdb_attached_names)
+                .map(|schemas| filter_visible_schema_names(schemas, visible_schema_filter.as_deref()))
+        }
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::DuckDbWorker(client) => {
+            let client = client.clone();
+            let database = database.to_string();
+            drop(connections);
+            client
+                .list_schemas(database)
+                .await
+                .map(|schemas| filter_visible_schema_names(schemas, visible_schema_filter.as_deref()))
+        }
+        _ => Ok(vec![]),
+    }
+}
+
+fn visible_schema_filter(
+    config: Option<&ConnectionConfig>,
+    database: &str,
+    apply_visible_filter: bool,
+) -> Option<Vec<String>> {
+    if !apply_visible_filter {
+        return None;
+    }
+    config?.visible_schemas.as_ref()?.get(database).cloned()
+}
+
+fn filter_visible_schema_names(schemas: Vec<String>, visible: Option<&[String]>) -> Vec<String> {
+    let Some(visible) = visible else {
+        return schemas;
+    };
+    let visible: std::collections::HashSet<&str> = visible.iter().map(String::as_str).collect();
+    schemas.into_iter().filter(|schema| visible.contains(schema.as_str())).collect()
+}
+
+pub async fn list_tables_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<&[String]>,
+) -> Result<Vec<db::TableInfo>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || {
+        list_tables_once(state, connection_id, database, schema, filter, limit, offset, object_types)
+    })
+    .await
+}
+
+/// List vector database collections, returning structured info (name, id, dimension).
+/// Only works for PoolKind::VectorDb connections; returns an error for other types.
+pub async fn list_vector_collections_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+) -> Result<Vec<db::vector_driver::CollectionInfo>, String> {
+    let pool_key =
+        state.get_or_create_pool(connection_id, if database.is_empty() { None } else { Some(database) }).await?;
+    let client = {
+        let connections = state.connections.read().await;
+        match connections.get(&pool_key) {
+            Some(PoolKind::VectorDb(client)) => client.clone(),
+            _ => return Err("Not a vector database connection".to_string()),
+        }
+    };
+    db::vector_driver::list_collections_with_db(&client, database).await
+}
+
+/// Get detailed metadata for a single vector collection (dimension, config, etc).
+pub async fn get_vector_collection_detail_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+) -> Result<db::vector_driver::CollectionInfo, String> {
+    let pool_key =
+        state.get_or_create_pool(connection_id, if database.is_empty() { None } else { Some(database) }).await?;
+    let client = {
+        let connections = state.connections.read().await;
+        match connections.get(&pool_key) {
+            Some(PoolKind::VectorDb(client)) => client.clone(),
+            _ => return Err("Not a vector database connection".to_string()),
+        }
+    };
+    db::vector_driver::get_collection_detail(&client, database, collection).await
+}
+
+pub async fn get_table_comment_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Option<String>, String> {
+    if crate::sql_dialect::parse_sqlserver_linked_schema_ref(schema).is_some() {
+        return Err("Table comments are not available for linked server tables".to_string());
+    }
+
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        let db_config = connection_config(state, connection_id).await;
+
+        {
+            let connections = state.connections.read().await;
+            try_sqlserver!(connections, &pool_key, get_table_comment, schema, table);
+            if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+                if db_config.as_ref().is_some_and(|config| {
+                    matches!(config.db_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle)
+                }) {
+                    let sql = oracle_table_comment_sql(schema, table);
+                    let timeout = agent_metadata_timeout(db_config.as_ref());
+                    drop(connections);
+                    let mut client = client.lock().await;
+                    let result = client
+                        .execute_query_with_timeout::<db::QueryResult>(
+                            agent_execute_query_params(
+                                &sql,
+                                Some(database),
+                                Some(schema),
+                                QueryExecutionOptions { max_rows: Some(1), ..Default::default() },
+                            ),
+                            timeout,
+                        )
+                        .await?;
+                    return oracle_table_comment_from_query_result(result);
+                }
+            }
+        }
+
+        let connections = state.connections.read().await;
+        let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+        match pool {
+            PoolKind::Mysql(p, mode)
+                if *mode != MysqlMode::OceanBaseOracle
+                    && !db_config.as_ref().is_some_and(is_doris_family_config)
+                    && !db_config.as_ref().is_some_and(is_manticoresearch_config) =>
+            {
+                db::mysql::get_table_comment(p, schema, table).await
+            }
+            PoolKind::Postgres(p) if !db_config.as_ref().is_some_and(is_questdb_config) => {
+                db::postgres::get_table_comment(p, schema, table).await
+            }
+            _ => Err("Table comment lookup is not supported for this connection".to_string()),
+        }
+    })
+    .await
+}
+
+fn oracle_table_comment_sql(schema: &str, table: &str) -> String {
+    format!(
+        "SELECT COMMENTS FROM ALL_TAB_COMMENTS WHERE OWNER = {} AND TABLE_NAME = {} AND TABLE_TYPE IN ('TABLE', 'VIEW')",
+        sql_string(schema),
+        sql_string(table),
+    )
+}
+
+fn oracle_table_comment_from_query_result(result: db::QueryResult) -> Result<Option<String>, String> {
+    Ok(result
+        .rows
+        .first()
+        .and_then(|row| row.iter().find_map(|value| value.as_str().map(str::to_string)))
+        .filter(|value| !value.trim().is_empty()))
+}
+
+fn oracle_table_comments_sql(schema: &str, table_names: &[String]) -> Option<String> {
+    if table_names.is_empty() {
+        return None;
+    }
+    let names = table_names.iter().map(|name| sql_string(name)).collect::<Vec<_>>().join(", ");
+    Some(format!(
+        "SELECT TABLE_NAME, COMMENTS FROM ALL_TAB_COMMENTS WHERE OWNER = {} AND TABLE_NAME IN ({}) AND TABLE_TYPE IN ('TABLE', 'VIEW') AND COMMENTS IS NOT NULL",
+        oracle_owner_filter(schema),
+        names,
+    ))
+}
+
+fn oracle_table_comments_from_query_result(result: db::QueryResult) -> HashMap<String, String> {
+    result
+        .rows
+        .into_iter()
+        .filter_map(|row| {
+            let name = row.first()?.as_str()?.to_string();
+            let comment = row.get(1)?.as_str()?.trim().to_string();
+            (!name.is_empty() && !comment.is_empty()).then_some((name, comment))
+        })
+        .collect()
+}
+
+fn oracle_columns_sql(schema: &str, table: &str) -> String {
+    format!(
+        "SELECT c.COLUMN_NAME, c.DATA_TYPE, c.NULLABLE, c.DATA_DEFAULT, \
+         c.DATA_LENGTH, c.DATA_PRECISION, c.DATA_SCALE, c.COLUMN_ID, \
+         CASE WHEN cc.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END AS IS_PK, \
+         cm.COMMENTS \
+         FROM ALL_TAB_COLUMNS c \
+         LEFT JOIN ( \
+           SELECT cols.OWNER, cols.TABLE_NAME, cols.COLUMN_NAME \
+           FROM ALL_CONS_COLUMNS cols \
+           JOIN ALL_CONSTRAINTS con \
+             ON con.CONSTRAINT_NAME = cols.CONSTRAINT_NAME \
+            AND con.OWNER = cols.OWNER \
+            AND con.CONSTRAINT_TYPE = 'P' \
+         ) cc ON cc.OWNER = c.OWNER AND cc.TABLE_NAME = c.TABLE_NAME AND cc.COLUMN_NAME = c.COLUMN_NAME \
+         LEFT JOIN ALL_COL_COMMENTS cm \
+           ON cm.OWNER = c.OWNER AND cm.TABLE_NAME = c.TABLE_NAME AND cm.COLUMN_NAME = c.COLUMN_NAME \
+         WHERE c.OWNER = {} AND c.TABLE_NAME = {} \
+         ORDER BY c.COLUMN_ID",
+        oracle_owner_filter(schema),
+        sql_string(table),
+    )
+}
+
+fn oracle_column_type(data_type: &str, precision: Option<i32>, scale: Option<i32>, length: Option<i32>) -> String {
+    match data_type.to_ascii_uppercase().as_str() {
+        "NUMBER" => match (precision, scale) {
+            (Some(precision), Some(scale)) if scale > 0 => format!("NUMBER({precision},{scale})"),
+            (Some(precision), _) => format!("NUMBER({precision})"),
+            _ => "NUMBER".to_string(),
+        },
+        "VARCHAR2" | "NVARCHAR2" | "CHAR" | "NCHAR" | "RAW" => match length {
+            Some(length) => format!("{data_type}({length})"),
+            None => data_type.to_string(),
+        },
+        _ => data_type.to_string(),
+    }
+}
+
+fn oracle_columns_from_query_result(result: db::QueryResult) -> Vec<db::ColumnInfo> {
+    result
+        .rows
+        .into_iter()
+        .filter_map(|row| {
+            let name = query_result_cell_string(&row, 0)?;
+            let data_type = query_result_cell_string(&row, 1).unwrap_or_default();
+            let nullable = query_result_cell_string(&row, 2).unwrap_or_default();
+            let default_value = query_result_cell_string(&row, 3)
+                .map(|value| value.trim().to_string())
+                .filter(|value| !value.is_empty());
+            let length = query_result_cell_i64(&row, 4).and_then(|value| i32::try_from(value).ok());
+            let precision = query_result_cell_i64(&row, 5).and_then(|value| i32::try_from(value).ok());
+            let scale = query_result_cell_i64(&row, 6).and_then(|value| i32::try_from(value).ok());
+            let is_primary_key = query_result_cell_i64(&row, 8).unwrap_or(0) == 1;
+            let comment = query_result_cell_string(&row, 9).filter(|value| !value.trim().is_empty());
+            Some(db::ColumnInfo {
+                name,
+                data_type: oracle_column_type(&data_type, precision, scale, length),
+                is_nullable: nullable == "Y",
+                column_default: default_value,
+                is_primary_key,
+                extra: None,
+                comment,
+                numeric_precision: precision,
+                numeric_scale: scale,
+                character_maximum_length: length,
+                enum_values: None,
+                ..Default::default()
+            })
+        })
+        .collect()
+}
+
+async fn oracle_columns_via_sql(
+    database: &str,
+    schema: &str,
+    table: &str,
+    client: &mut db::agent_driver::AgentDriverClient,
+    timeout_duration: Option<Duration>,
+) -> Result<Vec<db::ColumnInfo>, String> {
+    let sql = oracle_columns_sql(schema, table);
+    let result = client
+        .execute_query_with_timeout::<db::QueryResult>(
+            agent_execute_query_params(
+                &sql,
+                if database.is_empty() { None } else { Some(database) },
+                if schema.is_empty() { None } else { Some(schema) },
+                QueryExecutionOptions { max_rows: Some(10_000), ..Default::default() },
+            ),
+            timeout_duration,
+        )
+        .await?;
+    Ok(deduplicate_column_infos(oracle_columns_from_query_result(result)))
+}
+
+async fn external_driver_oracle_columns_via_sql(
+    session: Arc<crate::plugins::PluginDriverSession>,
+    config: &ConnectionConfig,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::ColumnInfo>, String> {
+    let result: db::QueryResult = session
+        .invoke_with_timeout(
+            "executeQuery",
+            serde_json::json!({
+                "connection": config,
+                "database": database,
+                "schema": schema,
+                "sql": oracle_columns_sql(schema, table),
+                "maxRows": 10_000
+            }),
+            agent_metadata_timeout(Some(config)),
+        )
+        .await?;
+    Ok(deduplicate_column_infos(oracle_columns_from_query_result(result)))
+}
+
+fn oracle_object_statistics_sql(schema: &str) -> String {
+    oracle_object_statistics_owner_segments_sql(schema, "ALL_SEGMENTS")
+}
+
+fn oracle_object_statistics_dba_segments_sql(schema: &str) -> String {
+    oracle_object_statistics_owner_segments_sql(schema, "DBA_SEGMENTS")
+}
+
+fn oracle_object_statistics_owner_segments_sql(schema: &str, segment_view: &str) -> String {
+    format!(
+        "SELECT t.TABLE_NAME, t.OWNER, t.NUM_ROWS, NVL(s.BYTES, 0) AS TOTAL_BYTES \
+         FROM ALL_TABLES t \
+         LEFT JOIN ( \
+           SELECT owner, table_name, SUM(bytes) AS BYTES \
+           FROM ( \
+             SELECT s.OWNER, s.SEGMENT_NAME AS TABLE_NAME, s.BYTES \
+             FROM {segment_view} s \
+             WHERE s.OWNER = {} AND s.SEGMENT_TYPE IN ('TABLE','TABLE PARTITION','TABLE SUBPARTITION') \
+             UNION ALL \
+             SELECT i.TABLE_OWNER AS OWNER, i.TABLE_NAME, s.BYTES \
+             FROM ALL_INDEXES i \
+             JOIN {segment_view} s ON s.OWNER = i.OWNER AND s.SEGMENT_NAME = i.INDEX_NAME \
+             WHERE i.TABLE_OWNER = {} AND s.SEGMENT_TYPE IN ('INDEX','INDEX PARTITION','INDEX SUBPARTITION') \
+             UNION ALL \
+             SELECT l.OWNER, l.TABLE_NAME, s.BYTES \
+             FROM ALL_LOBS l \
+             JOIN {segment_view} s ON s.OWNER = l.OWNER AND s.SEGMENT_NAME IN (l.SEGMENT_NAME, l.INDEX_NAME) \
+             WHERE l.OWNER = {} AND s.SEGMENT_TYPE IN ('LOBSEGMENT','LOB PARTITION','LOB SUBPARTITION','LOBINDEX') \
+           ) \
+           GROUP BY owner, table_name \
+         ) s ON s.OWNER = t.OWNER AND s.TABLE_NAME = t.TABLE_NAME \
+         WHERE t.OWNER = {} AND t.NESTED = 'NO' \
+         ORDER BY t.TABLE_NAME",
+        oracle_owner_filter(schema),
+        oracle_owner_filter(schema),
+        oracle_owner_filter(schema),
+        oracle_owner_filter(schema),
+    )
+}
+
+fn oracle_object_statistics_user_segments_sql(schema: &str) -> String {
+    // USER_SEGMENTS exposes objects owned by the login/current user, while DBX
+    // may switch CURRENT_SCHEMA before metadata queries for cross-schema browsing.
+    format!(
+        "SELECT t.TABLE_NAME, t.OWNER, t.NUM_ROWS, NVL(s.BYTES, 0) AS TOTAL_BYTES \
+         FROM ALL_TABLES t \
+         LEFT JOIN ( \
+           SELECT table_name, SUM(bytes) AS BYTES \
+           FROM ( \
+             SELECT s.SEGMENT_NAME AS TABLE_NAME, s.BYTES \
+             FROM USER_SEGMENTS s \
+             WHERE s.SEGMENT_TYPE IN ('TABLE','TABLE PARTITION','TABLE SUBPARTITION') \
+             UNION ALL \
+             SELECT i.TABLE_NAME, s.BYTES \
+             FROM ALL_INDEXES i \
+             JOIN USER_SEGMENTS s ON s.SEGMENT_NAME = i.INDEX_NAME \
+             WHERE i.TABLE_OWNER = {} AND s.SEGMENT_TYPE IN ('INDEX','INDEX PARTITION','INDEX SUBPARTITION') \
+             UNION ALL \
+             SELECT l.TABLE_NAME, s.BYTES \
+             FROM ALL_LOBS l \
+             JOIN USER_SEGMENTS s ON s.SEGMENT_NAME IN (l.SEGMENT_NAME, l.INDEX_NAME) \
+             WHERE l.OWNER = {} AND s.SEGMENT_TYPE IN ('LOBSEGMENT','LOB PARTITION','LOB SUBPARTITION','LOBINDEX') \
+           ) \
+           GROUP BY table_name \
+         ) s ON s.TABLE_NAME = t.TABLE_NAME \
+         WHERE t.OWNER = {} AND t.OWNER = USER AND t.NESTED = 'NO' \
+         ORDER BY t.TABLE_NAME",
+        oracle_owner_filter(schema),
+        oracle_owner_filter(schema),
+        oracle_owner_filter(schema),
+    )
+}
+
+fn oracle_object_statistics_rows_only_sql(schema: &str) -> String {
+    format!(
+        "SELECT t.TABLE_NAME, t.OWNER, t.NUM_ROWS, CAST(NULL AS NUMBER) AS TOTAL_BYTES \
+         FROM ALL_TABLES t \
+         WHERE t.OWNER = {} AND t.NESTED = 'NO' \
+         ORDER BY t.TABLE_NAME",
+        oracle_owner_filter(schema),
+    )
+}
+
+fn query_result_cell_i64(row: &[serde_json::Value], index: usize) -> Option<i64> {
+    let value = row.get(index)?;
+    if value.is_null() {
+        return None;
+    }
+    value
+        .as_i64()
+        .or_else(|| value.as_u64().and_then(|value| i64::try_from(value).ok()))
+        .or_else(|| value.as_f64().map(|value| value as i64))
+        .or_else(|| value.as_str()?.trim().parse::<i64>().ok())
+}
+
+fn oracle_object_statistics_from_query_result(result: db::QueryResult) -> Vec<db::ObjectStatistics> {
+    result
+        .rows
+        .into_iter()
+        .filter_map(|row| {
+            let name = query_result_cell_string(&row, 0)?;
+            if name.trim().is_empty() {
+                return None;
+            }
+            Some(db::ObjectStatistics {
+                name,
+                schema: query_result_cell_string(&row, 1),
+                estimated_rows: query_result_cell_i64(&row, 2),
+                total_bytes: query_result_cell_i64(&row, 3),
+            })
+        })
+        .collect()
+}
+
+fn comment_is_blank(comment: &Option<String>) -> bool {
+    comment.as_deref().map(str::trim).unwrap_or("").is_empty()
+}
+
+fn oracle_table_info_can_have_comment(table: &db::TableInfo) -> bool {
+    oracle_type_is_table_or_view(&table.table_type)
+}
+
+fn oracle_object_info_can_have_table_comment(object: &db::ObjectInfo) -> bool {
+    oracle_type_is_table_or_view(&object.object_type)
+}
+
+fn oracle_type_is_table_or_view(value: &str) -> bool {
+    let normalized = value.to_ascii_uppercase().replace(' ', "_").replace('-', "_");
+    matches!(normalized.as_str(), "TABLE" | "BASE_TABLE" | "VIEW")
+}
+
+fn oracle_missing_table_comment_names(tables: &[db::TableInfo]) -> Vec<String> {
+    unique_oracle_comment_names(
+        tables
+            .iter()
+            .filter(|table| oracle_table_info_can_have_comment(table) && comment_is_blank(&table.comment))
+            .map(|table| table.name.as_str()),
+    )
+}
+
+fn oracle_missing_object_table_comment_names(objects: &[db::ObjectInfo]) -> Vec<String> {
+    unique_oracle_comment_names(
+        objects
+            .iter()
+            .filter(|object| oracle_object_info_can_have_table_comment(object) && comment_is_blank(&object.comment))
+            .map(|object| object.name.as_str()),
+    )
+}
+
+fn unique_oracle_comment_names<'a>(names: impl Iterator<Item = &'a str>) -> Vec<String> {
+    let mut seen = std::collections::HashSet::new();
+    let mut unique = Vec::new();
+    for name in names {
+        let name = name.trim();
+        if name.is_empty() || !seen.insert(name.to_string()) {
+            continue;
+        }
+        unique.push(name.to_string());
+    }
+    unique
+}
+
+fn apply_oracle_table_comments(tables: &mut [db::TableInfo], comments: &HashMap<String, String>) {
+    for table in tables {
+        if !comment_is_blank(&table.comment) {
+            continue;
+        }
+        if let Some(comment) = oracle_comment_for_name(comments, &table.name) {
+            table.comment = Some(comment.clone());
+        }
+    }
+}
+
+fn apply_oracle_object_table_comments(objects: &mut [db::ObjectInfo], comments: &HashMap<String, String>) {
+    for object in objects {
+        if !comment_is_blank(&object.comment) {
+            continue;
+        }
+        if let Some(comment) = oracle_comment_for_name(comments, &object.name) {
+            object.comment = Some(comment.clone());
+        }
+    }
+}
+
+fn oracle_comment_for_name<'a>(comments: &'a HashMap<String, String>, name: &str) -> Option<&'a String> {
+    comments
+        .get(name)
+        .or_else(|| comments.iter().find(|(key, _)| key.eq_ignore_ascii_case(name)).map(|(_, value)| value))
+}
+
+async fn oracle_table_comments_for_names(
+    client: &mut db::agent_driver::AgentDriverClient,
+    database: &str,
+    schema: &str,
+    table_names: &[String],
+    timeout_duration: Option<Duration>,
+) -> Result<HashMap<String, String>, String> {
+    let mut comments = HashMap::new();
+    for chunk in table_names.chunks(ORACLE_TABLE_COMMENT_BATCH_SIZE) {
+        let Some(sql) = oracle_table_comments_sql(schema, chunk) else {
+            continue;
+        };
+        let result = client
+            .execute_query_with_timeout::<db::QueryResult>(
+                agent_execute_query_params(
+                    &sql,
+                    if database.is_empty() { None } else { Some(database) },
+                    if schema.is_empty() { None } else { Some(schema) },
+                    QueryExecutionOptions { max_rows: Some(chunk.len()), ..Default::default() },
+                ),
+                timeout_duration,
+            )
+            .await?;
+        comments.extend(oracle_table_comments_from_query_result(result));
+    }
+    Ok(comments)
+}
+
+async fn load_oracle_table_comments_for_tables(
+    client: &mut db::agent_driver::AgentDriverClient,
+    database: &str,
+    schema: &str,
+    tables: &mut [db::TableInfo],
+    timeout_duration: Option<Duration>,
+) -> Result<(), String> {
+    let table_names = oracle_missing_table_comment_names(tables);
+    if table_names.is_empty() {
+        return Ok(());
+    }
+    let comments = oracle_table_comments_for_names(client, database, schema, &table_names, timeout_duration).await?;
+    apply_oracle_table_comments(tables, &comments);
+    Ok(())
+}
+
+async fn load_oracle_table_comments_for_objects(
+    client: &mut db::agent_driver::AgentDriverClient,
+    database: &str,
+    schema: &str,
+    objects: &mut [db::ObjectInfo],
+    timeout_duration: Option<Duration>,
+) -> Result<(), String> {
+    let table_names = oracle_missing_object_table_comment_names(objects);
+    if table_names.is_empty() {
+        return Ok(());
+    }
+    let comments = oracle_table_comments_for_names(client, database, schema, &table_names, timeout_duration).await?;
+    apply_oracle_object_table_comments(objects, &comments);
+    Ok(())
+}
+
+async fn oracle_agent_list_object_statistics(
+    client: Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>,
+    database: &str,
+    schema: &str,
+    timeout_duration: Option<Duration>,
+) -> Result<Vec<db::ObjectStatistics>, String> {
+    let mut client = client.lock().await;
+    let queries = [
+        ("all-segments", oracle_object_statistics_sql(schema), true),
+        ("dba-segments", oracle_object_statistics_dba_segments_sql(schema), true),
+        ("user-segments", oracle_object_statistics_user_segments_sql(schema), false),
+        ("rows-only", oracle_object_statistics_rows_only_sql(schema), true),
+    ];
+    let mut last_error = None;
+    for (source, sql, accept_empty) in queries {
+        match oracle_agent_object_statistics_query(&mut client, database, schema, &sql, timeout_duration).await {
+            Ok(result) if accept_empty || !result.rows.is_empty() => {
+                return Ok(oracle_object_statistics_from_query_result(result));
+            }
+            Ok(_) => {
+                log::debug!(
+                    "[schema][oracle:list_object_statistics:empty-fallback] schema={} source={}",
+                    schema,
+                    source
+                );
+            }
+            Err(error) => {
+                log::debug!(
+                    "[schema][oracle:list_object_statistics:fallback-failed] schema={} source={} error={}",
+                    schema,
+                    source,
+                    error
+                );
+                last_error = Some(error);
+            }
+        }
+    }
+    Err(last_error.unwrap_or_else(|| "Oracle object statistics are unavailable".to_string()))
+}
+
+async fn oracle_agent_object_statistics_query(
+    client: &mut db::agent_driver::AgentDriverClient,
+    database: &str,
+    schema: &str,
+    sql: &str,
+    timeout_duration: Option<Duration>,
+) -> Result<db::QueryResult, String> {
+    client
+        .execute_query_with_timeout(
+            agent_execute_query_params(
+                sql,
+                if database.is_empty() { None } else { Some(database) },
+                if schema.is_empty() { None } else { Some(schema) },
+                QueryExecutionOptions { max_rows: Some(10_000), ..Default::default() },
+            ),
+            timeout_duration,
+        )
+        .await
+}
+
+async fn list_tables_once(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<&[String]>,
+) -> Result<Vec<db::TableInfo>, String> {
+    let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+    #[cfg(feature = "duckdb-bundled")]
+    let duckdb_attached_names = duckdb_attached_database_names(state, connection_id).await;
+    let db_config = connection_config(state, connection_id).await;
+
+    {
+        let connections = state.connections.read().await;
+        #[cfg(feature = "duckdb-bundled")]
+        if let Some(ext_pool) = extract_pool!(&connections, &pool_key, ExternalTabular) {
+            drop(connections);
+            let cache = ext_pool.cache.clone();
+            return tokio::task::spawn_blocking(move || {
+                let con = cache.lock().map_err(|e| e.to_string())?;
+                duckdb_query_tables(&con)
+            })
+            .await
+            .map_err(|e| e.to_string())?
+            .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types));
+        }
+        if let Some(PoolKind::ExternalDriver { config, session, .. }) = connections.get(&pool_key) {
+            let config = config.clone();
+            let session = session.clone();
+            drop(connections);
+            if uses_presto_like_information_schema_tables(&config.db_type) {
+                return external_driver_presto_like_tables(
+                    session,
+                    config.as_ref(),
+                    database,
+                    schema,
+                    filter,
+                    limit,
+                    offset,
+                )
+                .await
+                .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types));
+            }
+            let mut params =
+                serde_json::json!({ "connection": config.as_ref(), "database": database, "schema": schema });
+            if let Some(filter) = filter.map(str::trim).filter(|value| !value.is_empty()) {
+                params["filter"] = serde_json::json!(filter);
+            }
+            if let Some(object_types) = object_types {
+                params["object_types"] = serde_json::json!(object_types);
+            }
+            return session
+                .invoke_with_timeout::<Vec<db::TableInfo>>(
+                    "listTables",
+                    params,
+                    agent_metadata_timeout(Some(config.as_ref())),
+                )
+                .await
+                .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types));
+        }
+        #[cfg(feature = "duckdb-bundled")]
+        if let Some(con) = extract_pool!(&connections, &pool_key, DuckDb) {
+            drop(connections);
+            let con = con.lock().map_err(|e| e.to_string())?;
+            return duckdb_query_tables_in_database_with_attached(&con, database, schema, &duckdb_attached_names)
+                .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types));
+        }
+        #[cfg(feature = "duckdb-bundled")]
+        if let Some(client) = extract_pool!(&connections, &pool_key, DuckDbWorker) {
+            let database = database.to_string();
+            let schema = schema.to_string();
+            drop(connections);
+            return client
+                .list_tables(database, schema)
+                .await
+                .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types));
+        }
+        if let Some(client) = extract_pool!(&connections, &pool_key, ClickHouse) {
+            drop(connections);
+            return db::clickhouse_driver::list_tables(&client, clickhouse_metadata_database(database, schema))
+                .await
+                .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types));
+        }
+        if let Some(client) = extract_pool!(&connections, &pool_key, InfluxDb) {
+            drop(connections);
+            return db::influxdb_driver::list_tables(&client, database)
+                .await
+                .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types));
+        }
+        if let Some(linked) = crate::sql_dialect::parse_sqlserver_linked_schema_ref(schema) {
+            if let Some(client) = extract_pool!(&connections, &pool_key, SqlServer) {
+                drop(connections);
+                let mut client = client.lock().await;
+                return db::sqlserver::list_linked_server_tables(
+                    &mut client,
+                    &linked.server,
+                    &linked.catalog,
+                    &linked.schema,
+                    filter,
+                    None,
+                    None,
+                )
+                .await
+                .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types));
+            }
+        }
+        if object_types.is_some() {
+            if let Some(client) = extract_pool!(&connections, &pool_key, SqlServer) {
+                drop(connections);
+                let mut client = client.lock().await;
+                return db::sqlserver::list_tables(&mut client, schema, filter, None, None)
+                    .await
+                    .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types));
+            }
+        }
+        try_sqlserver!(connections, &pool_key, list_tables, schema, filter, limit, offset);
+        if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+            let is_oracle = db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::Oracle);
+            let use_oracle_agent_paging = db_config.as_ref().is_some_and(is_default_oracle_agent_config);
+            let filter_locally_after_oracle_comments =
+                is_oracle && filter.is_some_and(|filter| !filter.trim().is_empty());
+            let timeout_duration = agent_metadata_timeout(db_config.as_ref());
+            let fallback_config = db_config.clone();
+            drop(connections);
+            let mut client = client.lock().await;
+            let agent_filter = if filter_locally_after_oracle_comments { None } else { filter };
+            let agent_limit = if filter_locally_after_oracle_comments {
+                None
+            } else if use_oracle_agent_paging {
+                limit
+            } else {
+                None
+            };
+            let agent_offset = if filter_locally_after_oracle_comments {
+                None
+            } else if use_oracle_agent_paging {
+                offset
+            } else {
+                None
+            };
+            match client
+                .list_tables_constrained::<Vec<db::TableInfo>>(
+                    database,
+                    schema,
+                    agent_filter,
+                    agent_limit,
+                    agent_offset,
+                    object_types,
+                    timeout_duration,
+                )
+                .await
+            {
+                Ok(mut tables) if !tables.is_empty() => {
+                    if is_oracle {
+                        load_oracle_table_comments_for_tables(
+                            &mut client,
+                            database,
+                            schema,
+                            &mut tables,
+                            timeout_duration,
+                        )
+                        .await?;
+                    }
+                    let final_offset = if filter_locally_after_oracle_comments {
+                        offset
+                    } else if oracle_agent_paging_likely_applied(use_oracle_agent_paging, limit, tables.len()) {
+                        Some(0)
+                    } else {
+                        offset
+                    };
+                    let tables = filter_table_infos(tables, filter, limit, final_offset, object_types);
+                    return Ok(tables);
+                }
+                Ok(tables) => {
+                    if let Some(config) = fallback_config.as_ref() {
+                        match native_postgres_metadata_pool(state, connection_id, database, config).await {
+                            Ok(Some(pool)) => {
+                                return if object_types.is_some() {
+                                    db::postgres::list_tables_filtered(&pool, schema, filter, None, None)
+                                        .await
+                                        .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types))
+                                } else {
+                                    db::postgres::list_tables_filtered(&pool, schema, filter, limit, offset).await
+                                };
+                            }
+                            Ok(None) => return Ok(filter_table_infos(tables, filter, limit, offset, object_types)),
+                            Err(error) => {
+                                log::warn!(
+                                    "[schema][agent:list_tables:fallback-failed] connection_id={} database={} schema={} error={}",
+                                    connection_id,
+                                    database,
+                                    schema,
+                                    error
+                                );
+                            }
+                        }
+                    }
+                    return Ok(filter_table_infos(tables, filter, limit, offset, object_types));
+                }
+                Err(agent_error) => {
+                    if let Some(config) = fallback_config.as_ref() {
+                        if let Some(pool) =
+                            native_postgres_metadata_pool(state, connection_id, database, config).await?
+                        {
+                            let result = if object_types.is_some() {
+                                db::postgres::list_tables_filtered(&pool, schema, filter, None, None)
+                                    .await
+                                    .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types))
+                            } else {
+                                db::postgres::list_tables_filtered(&pool, schema, filter, limit, offset).await
+                            };
+                            return result.map_err(|fallback_error| {
+                                format!("{agent_error}\n\nNative PostgreSQL metadata fallback failed: {fallback_error}")
+                            });
+                        }
+                    }
+                    return Err(agent_error);
+                }
+            }
+        }
+    }
+
+    let connections = state.connections.read().await;
+    let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+    match pool {
+        PoolKind::Mysql(p, _) if db_config.as_ref().is_some_and(is_doris_family_config) => {
+            db::mysql::list_tables_show(p, database)
+                .await
+                .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types))
+        }
+        PoolKind::Mysql(p, mode) => {
+            if *mode == MysqlMode::OceanBaseOracle {
+                let tables = db::ob_oracle::list_tables(p, schema).await?;
+                Ok(filter_table_infos(tables, filter, limit, offset, object_types))
+            } else {
+                db::mysql::list_tables_filtered(
+                    p,
+                    mysql_table_metadata_catalog(database, schema),
+                    filter,
+                    limit,
+                    offset,
+                    object_types,
+                )
+                .await
+                .map(|tables| filter_table_infos(tables, None, None, None, object_types))
+            }
+        }
+        PoolKind::Postgres(p) if db_config.as_ref().is_some_and(is_questdb_config) => {
+            db::questdb::list_tables(p, schema)
+                .await
+                .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types))
+        }
+        PoolKind::Postgres(p) => {
+            if object_types.is_some() {
+                db::postgres::list_tables_filtered(p, schema, filter, None, None)
+                    .await
+                    .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types))
+            } else {
+                db::postgres::list_tables_filtered(p, schema, filter, limit, offset).await
+            }
+        }
+        PoolKind::Sqlite(p) => db::sqlite::list_tables(p, schema)
+            .await
+            .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types)),
+        PoolKind::Rqlite(client) => db::rqlite_driver::list_tables(client, schema)
+            .await
+            .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types)),
+        PoolKind::MongoDb(client) => db::mongo_driver::list_collections(client, database)
+            .await
+            .map(|names| collection_names_to_tables(names, "COLLECTION"))
+            .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types)),
+        PoolKind::Elasticsearch(client) => db::elasticsearch_driver::list_indices(client)
+            .await
+            .map(|names| collection_names_to_tables(names, "INDEX"))
+            .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types)),
+        PoolKind::VectorDb(client) => db::vector_driver::list_collections(client)
+            .await
+            .map(|infos| collection_names_to_tables(infos.into_iter().map(|i| i.name).collect(), "COLLECTION"))
+            .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types)),
+        PoolKind::CloudflareD1(client) => db::cloudflare_d1_driver::list_tables(client, schema)
+            .await
+            .map(|tables| filter_table_infos(tables, filter, limit, offset, object_types)),
+        _ => Ok(vec![]),
+    }
+}
+
+fn collection_names_to_tables(names: Vec<String>, table_type: &str) -> Vec<db::TableInfo> {
+    names
+        .into_iter()
+        .map(|name| db::TableInfo {
+            name,
+            table_type: table_type.to_string(),
+            comment: None,
+            parent_schema: None,
+            parent_name: None,
+        })
+        .collect()
+}
+
+fn filter_table_infos(
+    tables: Vec<db::TableInfo>,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<&[String]>,
+) -> Vec<db::TableInfo> {
+    let filter = filter.unwrap_or("");
+    let limit = limit.unwrap_or(usize::MAX);
+    let offset = offset.unwrap_or(0);
+    tables
+        .into_iter()
+        .filter(|table| metadata_name_or_comment_matches(&table.name, table.comment.as_deref(), filter))
+        .filter(|table| table_info_matches_object_types(table, object_types))
+        .skip(offset)
+        .take(limit)
+        .collect()
+}
+
+fn filter_object_infos(
+    objects: Vec<db::ObjectInfo>,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<&[String]>,
+) -> Vec<db::ObjectInfo> {
+    let filter = filter.unwrap_or("");
+    let limit = limit.unwrap_or(usize::MAX);
+    let offset = offset.unwrap_or(0);
+    objects
+        .into_iter()
+        .filter(|object| metadata_name_or_comment_matches(&object.name, object.comment.as_deref(), filter))
+        .filter(|object| object_info_matches_object_types(object, object_types))
+        .skip(offset)
+        .take(limit)
+        .collect()
+}
+
+fn metadata_name_or_comment_matches(name: &str, comment: Option<&str>, filter: &str) -> bool {
+    if filter.trim().is_empty() {
+        return true;
+    }
+    crate::sql::contains_or_fuzzy_match(name, filter)
+        || comment.is_some_and(|comment| crate::sql::contains_or_fuzzy_match(comment, filter))
+}
+
+fn object_info_matches_object_types(object: &db::ObjectInfo, object_types: Option<&[String]>) -> bool {
+    let Some(object_types) = object_types else {
+        return true;
+    };
+    if object_types.is_empty() {
+        return true;
+    }
+    let object_type = normalize_object_info_object_type(&object.object_type);
+    object_types.iter().any(|expected| normalize_object_info_object_type(expected) == object_type)
+}
+
+fn normalize_object_info_object_type(value: &str) -> String {
+    let upper = value.to_ascii_uppercase().replace(' ', "_");
+    if upper.contains("MATERIALIZED") && upper.contains("VIEW") {
+        return "MATERIALIZED_VIEW".to_string();
+    }
+    if upper == "BASE_TABLE" || upper.contains("TABLE") {
+        return "TABLE".to_string();
+    }
+    if upper.contains("VIEW") {
+        return "VIEW".to_string();
+    }
+    upper
+}
+
+fn table_info_matches_object_types(table: &db::TableInfo, object_types: Option<&[String]>) -> bool {
+    let Some(object_types) = object_types else {
+        return true;
+    };
+    if object_types.is_empty() {
+        return true;
+    }
+    let table_type = normalize_table_info_object_type(&table.table_type);
+    object_types.iter().any(|object_type| normalize_table_info_object_type(object_type) == table_type)
+}
+
+fn normalize_table_info_object_type(value: &str) -> String {
+    let upper = value.to_ascii_uppercase().replace(' ', "_");
+    if upper.contains("MATERIALIZED") && upper.contains("VIEW") {
+        return "MATERIALIZED_VIEW".to_string();
+    }
+    if upper.contains("VIEW") {
+        return "VIEW".to_string();
+    }
+    if upper.contains("COLLECTION") {
+        return "COLLECTION".to_string();
+    }
+    if upper.contains("INDEX") {
+        return "INDEX".to_string();
+    }
+    "TABLE".to_string()
+}
+
+fn uses_presto_like_information_schema_tables(db_type: &DatabaseType) -> bool {
+    matches!(db_type, DatabaseType::PrestoSql | DatabaseType::Trino)
+}
+
+async fn external_driver_presto_like_tables(
+    session: Arc<crate::plugins::PluginDriverSession>,
+    config: &ConnectionConfig,
+    database: &str,
+    schema: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+) -> Result<Vec<db::TableInfo>, String> {
+    let query_limit = limit.map(|limit| limit.saturating_add(offset.unwrap_or(0)).max(1)).unwrap_or(100000);
+    let result: db::QueryResult = session
+        .invoke_with_timeout(
+            "executeQuery",
+            serde_json::json!({
+                "connection": config,
+                "database": database,
+                "schema": schema,
+                "sql": presto_like_information_schema_tables_sql(database, schema, filter, Some(query_limit)),
+                "maxRows": query_limit,
+                "fetchSize": 1000,
+                "timeoutSecs": 60
+            }),
+            agent_metadata_timeout(Some(config)),
+        )
+        .await?;
+    Ok(presto_like_tables_from_query_result(&result))
+}
+
+async fn external_driver_presto_like_objects(
+    session: Arc<crate::plugins::PluginDriverSession>,
+    config: &ConnectionConfig,
+    database: &str,
+    schema: &str,
+    filter: Option<&str>,
+    object_types: Option<&[String]>,
+) -> Result<Vec<db::ObjectInfo>, String> {
+    let tables = external_driver_presto_like_tables(session, config, database, schema, filter, None, None)
+        .await
+        .map(|tables| filter_table_infos(tables, filter, None, None, object_types))?;
+    Ok(tables
+        .into_iter()
+        .map(|table| db::ObjectInfo {
+            name: table.name,
+            object_type: table.table_type,
+            schema: Some(schema.to_string()),
+            signature: None,
+            comment: table.comment,
+            created_at: None,
+            updated_at: None,
+            parent_schema: table.parent_schema,
+            parent_name: table.parent_name,
+        })
+        .collect())
+}
+
+async fn external_driver_presto_like_columns(
+    session: Arc<crate::plugins::PluginDriverSession>,
+    config: &ConnectionConfig,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::ColumnInfo>, String> {
+    let result: db::QueryResult = session
+        .invoke(
+            "executeQuery",
+            serde_json::json!({
+                "connection": config,
+                "database": database,
+                "schema": schema,
+                "sql": presto_like_information_schema_columns_sql(database, schema, table),
+                "maxRows": 10000,
+                "fetchSize": 1000,
+                "timeoutSecs": 60
+            }),
+        )
+        .await?;
+    Ok(presto_like_columns_from_query_result(&result))
+}
+
+fn presto_like_information_schema_tables_sql(
+    database: &str,
+    schema: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+) -> String {
+    let source = if database.trim().is_empty() {
+        "information_schema.tables".to_string()
+    } else {
+        format!("{}.information_schema.tables", quote_presto_like_identifier(database))
+    };
+    let mut sql = format!(
+        "SELECT table_name, CASE table_type WHEN 'BASE TABLE' THEN 'TABLE' ELSE table_type END AS table_type \
+         FROM {source} \
+         WHERE table_schema = {} AND table_type IN ('BASE TABLE', 'VIEW')",
+        sql_string_literal(schema)
+    );
+    if let Some(filter) = filter.map(str::trim).filter(|value| !value.is_empty()) {
+        sql.push_str(" AND lower(table_name) LIKE ");
+        sql.push_str(&sql_string_literal(&format!("{}%", escape_presto_like_pattern(&filter.to_lowercase()))));
+        sql.push_str(" ESCAPE '\\'");
+    }
+    sql.push_str(" ORDER BY table_type, table_name");
+    if let Some(limit) = limit {
+        sql.push_str(&format!(" LIMIT {}", limit.max(1)));
+    }
+    sql
+}
+
+fn presto_like_information_schema_columns_sql(database: &str, schema: &str, table: &str) -> String {
+    let source = if database.trim().is_empty() {
+        "information_schema.columns".to_string()
+    } else {
+        format!("{}.information_schema.columns", quote_presto_like_identifier(database))
+    };
+    format!(
+        "SELECT column_name, data_type, is_nullable, column_default, comment \
+         FROM {source} \
+         WHERE table_schema = {} AND table_name = {} \
+         ORDER BY ordinal_position",
+        sql_string_literal(schema),
+        sql_string_literal(table)
+    )
+}
+
+fn presto_like_tables_from_query_result(result: &db::QueryResult) -> Vec<db::TableInfo> {
+    result
+        .rows
+        .iter()
+        .filter_map(|row| {
+            let name = query_result_cell_string(row, 0)?;
+            if name.trim().is_empty() {
+                return None;
+            }
+            Some(db::TableInfo {
+                name,
+                table_type: normalize_information_schema_table_type(
+                    query_result_cell_string(row, 1).as_deref().unwrap_or("TABLE"),
+                ),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            })
+        })
+        .collect()
+}
+
+fn presto_like_columns_from_query_result(result: &db::QueryResult) -> Vec<db::ColumnInfo> {
+    result
+        .rows
+        .iter()
+        .filter_map(|row| {
+            let name = query_result_cell_string(row, 0)?;
+            if name.trim().is_empty() {
+                return None;
+            }
+            let data_type = query_result_cell_string(row, 1).unwrap_or_default();
+            Some(db::ColumnInfo {
+                name,
+                // Presto/Trino do not expose precision/length columns in information_schema.columns.
+                data_type: data_type.clone(),
+                is_nullable: query_result_cell_string(row, 2)
+                    .map(|value| value.eq_ignore_ascii_case("YES"))
+                    .unwrap_or(true),
+                column_default: query_result_cell_string(row, 3),
+                is_primary_key: false,
+                extra: None,
+                comment: query_result_cell_string(row, 4),
+                numeric_precision: presto_like_numeric_precision(&data_type),
+                numeric_scale: presto_like_numeric_scale(&data_type),
+                character_maximum_length: presto_like_character_maximum_length(&data_type),
+                enum_values: None,
+                ..Default::default()
+            })
+        })
+        .collect()
+}
+
+fn query_result_cell_string(row: &[serde_json::Value], index: usize) -> Option<String> {
+    let value = row.get(index)?;
+    if value.is_null() {
+        return None;
+    }
+    value.as_str().map(ToString::to_string).or_else(|| Some(value.to_string()))
+}
+
+fn presto_like_numeric_precision(data_type: &str) -> Option<i32> {
+    presto_like_type_argument(data_type, &["decimal", "numeric"], 0)
+}
+
+fn presto_like_numeric_scale(data_type: &str) -> Option<i32> {
+    presto_like_type_argument(data_type, &["decimal", "numeric"], 1)
+}
+
+fn presto_like_character_maximum_length(data_type: &str) -> Option<i32> {
+    presto_like_type_argument(data_type, &["char", "varchar"], 0)
+}
+
+fn presto_like_type_argument(data_type: &str, type_names: &[&str], index: usize) -> Option<i32> {
+    let value = data_type.trim();
+    let open = value.find('(')?;
+    let close = value[open + 1..].find(')')? + open + 1;
+    let name = value[..open].trim().to_ascii_lowercase();
+    if !type_names.iter().any(|type_name| *type_name == name) {
+        return None;
+    }
+    value[open + 1..close].split(',').nth(index)?.trim().parse::<i32>().ok()
+}
+
+fn normalize_information_schema_table_type(table_type: &str) -> String {
+    match table_type.trim().to_ascii_uppercase().replace(' ', "_").as_str() {
+        "BASE_TABLE" => "TABLE".to_string(),
+        "VIEW" => "VIEW".to_string(),
+        "MATERIALIZED_VIEW" => "MATERIALIZED_VIEW".to_string(),
+        _ => table_type.to_string(),
+    }
+}
+
+fn mysql_table_metadata_catalog<'a>(database: &'a str, schema: &'a str) -> &'a str {
+    if schema.trim().is_empty() {
+        database
+    } else {
+        schema
+    }
+}
+
+fn quote_presto_like_identifier(identifier: &str) -> String {
+    format!("\"{}\"", identifier.replace('"', "\"\""))
+}
+
+fn sql_string_literal(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+fn escape_presto_like_pattern(value: &str) -> String {
+    value.replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::db;
+    use super::{
+        clickhouse_metadata_database, deduplicate_column_infos, filter_mysql_system_databases_for_config,
+        filter_object_infos, filter_table_infos, filter_visible_schema_names,
+        is_agent_postgres_metadata_fallback_config, is_retryable_metadata_error, mysql_object_source_sql,
+        mysql_table_metadata_catalog, normalize_information_schema_table_type, oracle_columns_from_query_result,
+        oracle_columns_sql, oracle_object_statistics_dba_segments_sql, oracle_object_statistics_from_query_result,
+        oracle_object_statistics_rows_only_sql, oracle_object_statistics_sql,
+        oracle_object_statistics_user_segments_sql, oracle_table_comment_from_query_result, oracle_table_comment_sql,
+        oracle_table_comments_from_query_result, oracle_table_comments_sql, presto_like_columns_from_query_result,
+        presto_like_information_schema_columns_sql, presto_like_information_schema_tables_sql,
+        presto_like_tables_from_query_result, visible_schema_filter,
+    };
+    #[cfg(feature = "duckdb-bundled")]
+    use super::{
+        duckdb_attach_database, duckdb_completion_assistant_search, duckdb_list_databases,
+        duckdb_query_tables_in_database,
+    };
+    use crate::models::connection::{ConnectionConfig, DatabaseType};
+    use std::collections::HashMap;
+
+    fn test_column(name: &str, comment: Option<&str>, is_primary_key: bool) -> super::db::ColumnInfo {
+        super::db::ColumnInfo {
+            name: name.to_string(),
+            data_type: "VARCHAR".to_string(),
+            is_nullable: true,
+            column_default: None,
+            is_primary_key,
+            extra: None,
+            comment: comment.map(|value| value.to_string()),
+            numeric_precision: None,
+            numeric_scale: None,
+            character_maximum_length: None,
+            enum_values: None,
+            ..Default::default()
+        }
+    }
+
+    fn test_connection_config(db_type: DatabaseType) -> ConnectionConfig {
+        ConnectionConfig {
+            id: "test".to_string(),
+            name: "test".to_string(),
+            db_type,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 5432,
+            username: "user".to_string(),
+            password: "secret".to_string(),
+            database: Some("demo".to_string()),
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: 0,
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: crate::models::connection::default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    #[test]
+    fn mysql_table_child_metadata_prefers_schema_when_present() {
+        assert_eq!(mysql_table_metadata_catalog("app_db", ""), "app_db");
+        assert_eq!(mysql_table_metadata_catalog("app_db", "tenant_db"), "tenant_db");
+    }
+
+    #[test]
+    fn mysql_object_source_sql_qualifies_cross_database_objects() {
+        assert_eq!(
+            mysql_object_source_sql("tenant_db", "users_view", &db::ObjectSourceKind::View),
+            "SHOW CREATE VIEW `tenant_db`.`users_view`"
+        );
+        assert_eq!(
+            mysql_object_source_sql("tenant_db", "sync_users", &db::ObjectSourceKind::Procedure),
+            "SHOW CREATE PROCEDURE `tenant_db`.`sync_users`"
+        );
+        assert_eq!(
+            mysql_object_source_sql("tenant_db", "calc_score", &db::ObjectSourceKind::Function),
+            "SHOW CREATE FUNCTION `tenant_db`.`calc_score`"
+        );
+        assert_eq!(
+            mysql_object_source_sql("", "users_view", &db::ObjectSourceKind::View),
+            "SHOW CREATE VIEW `users_view`"
+        );
+    }
+
+    #[test]
+    fn metadata_retry_recovers_missing_pool_only_as_transient_state() {
+        assert!(is_retryable_metadata_error("Pool not found"));
+        assert!(is_retryable_metadata_error("connection reset by peer"));
+        assert!(is_retryable_metadata_error("Agent RPC error (-1): dm.jdbc.driver.DMException: 网络通信异常"));
+        assert!(!is_retryable_metadata_error("Unknown column 'email' in 'field list'"));
+        assert!(!is_retryable_metadata_error("Access denied for user"));
+    }
+
+    #[test]
+    fn visible_schema_filter_only_applies_when_requested() {
+        let mut config = test_connection_config(DatabaseType::Oracle);
+        config.visible_schemas =
+            Some(HashMap::from([("ORCLPDB1".to_string(), vec!["APP".to_string(), "REPORTING".to_string()])]));
+
+        assert_eq!(visible_schema_filter(Some(&config), "ORCLPDB1", false), None);
+        assert_eq!(
+            visible_schema_filter(Some(&config), "ORCLPDB1", true),
+            Some(vec!["APP".to_string(), "REPORTING".to_string()])
+        );
+        assert_eq!(visible_schema_filter(Some(&config), "OTHER", true), None);
+    }
+
+    #[test]
+    fn default_oracle_agent_config_excludes_legacy_profiles() {
+        let mut config = test_connection_config(DatabaseType::Oracle);
+        assert!(super::is_default_oracle_agent_config(&config));
+
+        config.driver_profile = Some("oracle".to_string());
+        assert!(super::is_default_oracle_agent_config(&config));
+
+        config.driver_profile = Some("oracle-legacy".to_string());
+        assert!(!super::is_default_oracle_agent_config(&config));
+
+        config.driver_profile = Some("oracle-10g".to_string());
+        assert!(!super::is_default_oracle_agent_config(&config));
+    }
+
+    #[test]
+    fn oracle_agent_paging_detection_avoids_double_offset_only_when_page_sized() {
+        assert!(super::oracle_agent_paging_likely_applied(true, Some(500), 500));
+        assert!(super::oracle_agent_paging_likely_applied(true, Some(500), 120));
+        assert!(!super::oracle_agent_paging_likely_applied(true, Some(500), 501));
+        assert!(!super::oracle_agent_paging_likely_applied(false, Some(500), 120));
+        assert!(!super::oracle_agent_paging_likely_applied(true, None, 120));
+    }
+
+    #[test]
+    fn filter_visible_schema_names_preserves_database_order() {
+        let schemas = vec!["APP".to_string(), "SYS".to_string(), "REPORTING".to_string()];
+        let visible = vec!["REPORTING".to_string(), "APP".to_string()];
+
+        assert_eq!(filter_visible_schema_names(schemas, Some(&visible)), vec!["APP", "REPORTING"]);
+    }
+
+    fn test_table_info(name: &str) -> super::db::TableInfo {
+        super::db::TableInfo {
+            name: name.to_string(),
+            table_type: "BASE TABLE".to_string(),
+            comment: None,
+            parent_schema: None,
+            parent_name: None,
+        }
+    }
+
+    fn test_object_info(name: &str, object_type: &str) -> super::db::ObjectInfo {
+        super::db::ObjectInfo {
+            name: name.to_string(),
+            object_type: object_type.to_string(),
+            schema: Some("app".to_string()),
+            signature: None,
+            comment: None,
+            created_at: None,
+            updated_at: None,
+            parent_schema: None,
+            parent_name: None,
+        }
+    }
+
+    fn test_database_info(name: &str) -> super::db::DatabaseInfo {
+        super::db::DatabaseInfo { name: name.to_string() }
+    }
+
+    #[test]
+    fn manticoresearch_database_list_filters_mysql_system_databases() {
+        let databases = vec![
+            test_database_info("Manticore"),
+            test_database_info("information_schema"),
+            test_database_info("mysql"),
+            test_database_info("performance_schema"),
+            test_database_info("sys"),
+        ];
+        let config = test_connection_config(DatabaseType::ManticoreSearch);
+
+        let filtered = filter_mysql_system_databases_for_config(databases, Some(&config));
+
+        assert_eq!(filtered.into_iter().map(|database| database.name).collect::<Vec<_>>(), vec!["Manticore"]);
+    }
+
+    #[test]
+    fn manticoresearch_show_metadata_uses_unqualified_table_names() {
+        let config = test_connection_config(DatabaseType::ManticoreSearch);
+
+        assert_eq!(super::mysql_show_metadata_database_for_config(Some(&config), "Manticore"), "");
+    }
+
+    #[test]
+    fn doris_show_metadata_keeps_database_qualifier() {
+        let config = test_connection_config(DatabaseType::Doris);
+
+        assert_eq!(super::mysql_show_metadata_database_for_config(Some(&config), "analytics"), "analytics");
+    }
+
+    #[test]
+    fn doris_database_list_keeps_system_databases() {
+        let databases = vec![test_database_info("information_schema"), test_database_info("analytics")];
+        let config = test_connection_config(DatabaseType::Doris);
+
+        let filtered = filter_mysql_system_databases_for_config(databases, Some(&config));
+
+        assert_eq!(
+            filtered.into_iter().map(|database| database.name).collect::<Vec<_>>(),
+            vec!["information_schema", "analytics"]
+        );
+    }
+
+    #[test]
+    fn filter_table_infos_applies_filter_offset_and_limit() {
+        let tables = vec![
+            test_table_info("alpha"),
+            test_table_info("audit_log"),
+            test_table_info("audit_record"),
+            test_table_info("users"),
+        ];
+
+        let filtered = filter_table_infos(tables, Some("audit"), Some(1), Some(1), None);
+
+        assert_eq!(filtered.len(), 1);
+        assert_eq!(filtered[0].name, "audit_record");
+    }
+
+    #[test]
+    fn filter_table_infos_matches_fuzzy_subsequences() {
+        let tables = vec![test_table_info("system_user"), test_table_info("user_order"), test_table_info("alpha")];
+
+        let system_user = filter_table_infos(tables.clone(), Some("sysu"), None, None, None);
+        assert_eq!(system_user.into_iter().map(|table| table.name).collect::<Vec<_>>(), vec!["system_user"]);
+
+        let user_order = filter_table_infos(tables, Some("uo"), None, None, None);
+        assert_eq!(user_order.into_iter().map(|table| table.name).collect::<Vec<_>>(), vec!["user_order"]);
+    }
+
+    #[test]
+    fn filter_table_infos_matches_comments() {
+        let mut orders = test_table_info("orders");
+        orders.comment = Some("sales archive".to_string());
+        let mut profile = test_table_info("profile");
+        profile.comment = Some("customer account data".to_string());
+        let tables = vec![orders, profile, test_table_info("logs")];
+
+        let filtered = filter_table_infos(tables, Some("account"), None, None, None);
+
+        assert_eq!(filtered.into_iter().map(|table| table.name).collect::<Vec<_>>(), vec!["profile"]);
+    }
+
+    #[test]
+    fn filter_table_infos_skips_fuzzy_for_single_character_filters() {
+        let tables = vec![test_table_info("orders"), test_table_info("user_order")];
+
+        let filtered = filter_table_infos(tables, Some("u"), None, None, None);
+
+        assert_eq!(filtered.into_iter().map(|table| table.name).collect::<Vec<_>>(), vec!["user_order"]);
+    }
+
+    #[test]
+    fn filter_table_infos_keeps_special_filter_characters_literal() {
+        let tables = vec![test_table_info("user_%"), test_table_info("user_account"), test_table_info("userXpercent")];
+
+        let filtered = filter_table_infos(tables, Some("user_%"), None, None, None);
+
+        assert_eq!(filtered.into_iter().map(|table| table.name).collect::<Vec<_>>(), vec!["user_%"]);
+    }
+
+    #[test]
+    fn filter_table_infos_filters_object_type_before_offset_and_limit() {
+        let tables = vec![
+            test_table_info("orders"),
+            super::db::TableInfo {
+                name: "active_orders".to_string(),
+                table_type: "VIEW".to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+            test_table_info("users"),
+            super::db::TableInfo {
+                name: "active_users".to_string(),
+                table_type: "VIEW".to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+        ];
+        let object_types = vec!["VIEW".to_string()];
+
+        let filtered = filter_table_infos(tables, None, Some(1), Some(1), Some(&object_types));
+
+        assert_eq!(filtered.len(), 1);
+        assert_eq!(filtered[0].name, "active_users");
+    }
+
+    #[test]
+    fn filter_object_infos_filters_object_type_before_offset_and_limit() {
+        let objects = vec![
+            test_object_info("sync_user", "PROCEDURE"),
+            test_object_info("find_user", "FUNCTION"),
+            test_object_info("fetch_name", "FUNCTION"),
+            test_object_info("orders", "TABLE"),
+        ];
+        let object_types = vec!["FUNCTION".to_string()];
+
+        let filtered = filter_object_infos(objects, Some("fn"), Some(1), Some(1), Some(&object_types));
+
+        assert_eq!(filtered.len(), 1);
+        assert_eq!(filtered[0].name, "fetch_name");
+    }
+
+    #[test]
+    fn filter_object_infos_matches_comments() {
+        let mut order_view = test_object_info("order_view", "VIEW");
+        order_view.comment = Some("monthly revenue summary".to_string());
+        let mut sync_user = test_object_info("sync_user", "PROCEDURE");
+        sync_user.comment = Some("sync account records".to_string());
+        let objects = vec![order_view, sync_user, test_object_info("audit_log", "TABLE")];
+
+        let object_types = vec!["VIEW".to_string()];
+        let filtered = filter_object_infos(objects, Some("revenue"), None, None, Some(&object_types));
+
+        assert_eq!(filtered.into_iter().map(|object| object.name).collect::<Vec<_>>(), vec!["order_view"]);
+    }
+
+    #[test]
+    fn presto_like_information_schema_sql_uses_catalog_and_schema_without_system_jdbc() {
+        let sql = presto_like_information_schema_tables_sql("hive", "sales_analytics", None, None);
+
+        assert_eq!(
+            sql,
+            "SELECT table_name, CASE table_type WHEN 'BASE TABLE' THEN 'TABLE' ELSE table_type END AS table_type FROM \"hive\".information_schema.tables WHERE table_schema = 'sales_analytics' AND table_type IN ('BASE TABLE', 'VIEW') ORDER BY table_type, table_name"
+        );
+        assert!(!sql.contains("system.jdbc.tables"));
+    }
+
+    #[test]
+    fn presto_like_information_schema_sql_escapes_identifiers_and_literals() {
+        let sql = presto_like_information_schema_tables_sql("hi\"ve", "sales'analytics", None, None);
+
+        assert!(sql.contains("\"hi\"\"ve\".information_schema.tables"));
+        assert!(sql.contains("table_schema = 'sales''analytics'"));
+    }
+
+    #[test]
+    fn presto_like_information_schema_sql_pushes_table_filter_and_limit() {
+        let sql = presto_like_information_schema_tables_sql("hive", "sales_analytics", Some("Daily_%\\"), Some(20));
+
+        assert!(sql.contains("AND lower(table_name) LIKE 'daily\\_\\%\\\\%' ESCAPE '\\'"));
+        assert!(sql.ends_with("ORDER BY table_type, table_name LIMIT 20"));
+    }
+
+    #[test]
+    fn presto_like_information_schema_columns_sql_uses_catalog_information_schema() {
+        let sql = presto_like_information_schema_columns_sql("hive", "sales_analytics", "daily_revenue");
+
+        assert_eq!(
+            sql,
+            "SELECT column_name, data_type, is_nullable, column_default, comment FROM \"hive\".information_schema.columns WHERE table_schema = 'sales_analytics' AND table_name = 'daily_revenue' ORDER BY ordinal_position"
+        );
+        assert!(!sql.contains("system.jdbc.columns"));
+    }
+
+    #[test]
+    fn presto_like_information_schema_columns_sql_escapes_identifiers_and_literals() {
+        let sql = presto_like_information_schema_columns_sql("hi\"ve", "sales'analytics", "daily'revenue");
+
+        assert!(sql.contains("\"hi\"\"ve\".information_schema.columns"));
+        assert!(sql.contains("table_schema = 'sales''analytics'"));
+        assert!(sql.contains("table_name = 'daily''revenue'"));
+    }
+
+    #[test]
+    fn presto_like_tables_from_query_result_normalizes_base_table_type() {
+        let result = super::db::QueryResult {
+            columns: vec!["table_name".to_string(), "table_type".to_string()],
+            column_types: vec![],
+            column_sortables: vec![],
+            rows: vec![
+                vec![serde_json::json!("daily_revenue"), serde_json::json!("BASE TABLE")],
+                vec![serde_json::json!("revenue_view"), serde_json::json!("VIEW")],
+            ],
+            affected_rows: 0,
+            execution_time_ms: 1,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        };
+
+        let tables = presto_like_tables_from_query_result(&result);
+
+        assert_eq!(tables[0].name, "daily_revenue");
+        assert_eq!(tables[0].table_type, "TABLE");
+        assert_eq!(tables[1].name, "revenue_view");
+        assert_eq!(tables[1].table_type, "VIEW");
+        assert_eq!(normalize_information_schema_table_type("MATERIALIZED VIEW"), "MATERIALIZED_VIEW");
+    }
+
+    #[test]
+    fn presto_like_columns_from_query_result_maps_column_metadata() {
+        let result = super::db::QueryResult {
+            columns: vec![
+                "column_name".to_string(),
+                "data_type".to_string(),
+                "is_nullable".to_string(),
+                "column_default".to_string(),
+                "comment".to_string(),
+            ],
+            column_types: vec![],
+            column_sortables: vec![],
+            rows: vec![
+                vec![
+                    serde_json::json!("amount"),
+                    serde_json::json!("decimal(12,2)"),
+                    serde_json::json!("NO"),
+                    serde_json::Value::Null,
+                    serde_json::json!("daily amount"),
+                ],
+                vec![
+                    serde_json::json!("code"),
+                    serde_json::json!("varchar(64)"),
+                    serde_json::json!("YES"),
+                    serde_json::Value::Null,
+                    serde_json::Value::Null,
+                ],
+            ],
+            affected_rows: 0,
+            execution_time_ms: 1,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        };
+
+        let columns = presto_like_columns_from_query_result(&result);
+
+        assert_eq!(columns[0].name, "amount");
+        assert_eq!(columns[0].data_type, "decimal(12,2)");
+        assert!(!columns[0].is_nullable);
+        assert_eq!(columns[0].comment.as_deref(), Some("daily amount"));
+        assert_eq!(columns[0].numeric_precision, Some(12));
+        assert_eq!(columns[0].numeric_scale, Some(2));
+        assert_eq!(columns[0].character_maximum_length, None);
+        assert!(!columns[0].is_primary_key);
+        assert_eq!(columns[1].name, "code");
+        assert!(columns[1].is_nullable);
+        assert_eq!(columns[1].numeric_precision, None);
+        assert_eq!(columns[1].numeric_scale, None);
+        assert_eq!(columns[1].character_maximum_length, Some(64));
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_list_databases_includes_attached_database() {
+        let unique = uuid::Uuid::new_v4();
+        let path = std::env::temp_dir().join(format!("dbx-attached-{unique}.duckdb"));
+        let _ = std::fs::remove_file(&path);
+        let con = duckdb::Connection::open_in_memory().unwrap();
+
+        duckdb_attach_database(&con, "analytics", path.to_str().unwrap()).unwrap();
+        let databases = duckdb_list_databases(&con).unwrap();
+
+        assert!(databases.iter().any(|database| database.name == "main"));
+        assert!(databases.iter().any(|database| database.name == "analytics"));
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_query_tables_filters_by_attached_database() {
+        let unique = uuid::Uuid::new_v4();
+        let path = std::env::temp_dir().join(format!("dbx-attached-tables-{unique}.duckdb"));
+        let _ = std::fs::remove_file(&path);
+        let con = duckdb::Connection::open_in_memory().unwrap();
+
+        con.execute_batch("CREATE TABLE main_table(id INTEGER);").unwrap();
+        duckdb_attach_database(&con, "analytics", path.to_str().unwrap()).unwrap();
+        con.execute_batch("CREATE TABLE analytics.attached_table(id INTEGER);").unwrap();
+
+        let main_tables = duckdb_query_tables_in_database(&con, "main", "main").unwrap();
+        let attached_tables = duckdb_query_tables_in_database(&con, "analytics", "main").unwrap();
+
+        assert!(main_tables.iter().any(|table| table.name == "main_table"));
+        assert!(!main_tables.iter().any(|table| table.name == "attached_table"));
+        assert!(attached_tables.iter().any(|table| table.name == "attached_table"));
+        assert!(!attached_tables.iter().any(|table| table.name == "main_table"));
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_query_columns_includes_column_comments() {
+        let con = duckdb::Connection::open_in_memory().unwrap();
+        con.execute_batch(
+            "CREATE TABLE users (id INTEGER, name VARCHAR); \
+             COMMENT ON COLUMN users.name IS 'Display name';",
+        )
+        .unwrap();
+
+        let columns = super::duckdb_query_columns(&con, "users").unwrap();
+        let name = columns.iter().find(|column| column.name == "name").unwrap();
+
+        assert_eq!(name.comment.as_deref(), Some("Display name"));
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[test]
+    fn duckdb_completion_assistant_searches_catalog_metadata_with_limit() {
+        let con = duckdb::Connection::open_in_memory().unwrap();
+        con.execute_batch(
+            "CREATE TABLE account(id INTEGER, display_name VARCHAR); CREATE VIEW account_view AS SELECT id FROM account;",
+        )
+        .unwrap();
+
+        let request = db::CompletionAssistantRequest {
+            connection_id: "c1".to_string(),
+            database: "main".to_string(),
+            schema: Some("main".to_string()),
+            object_kinds: vec![db::CompletionAssistantObjectKind::Table, db::CompletionAssistantObjectKind::View],
+            mask: "account".to_string(),
+            case_sensitive: false,
+            global_search: false,
+            max_results: Some(1),
+            search_in_comments: false,
+            search_in_definitions: false,
+            parent_schema: Some("main".to_string()),
+            parent_name: None,
+            match_mode: Some(db::CompletionAssistantMatchMode::Prefix),
+        };
+
+        let tables = duckdb_completion_assistant_search(&con, &request, &[]).unwrap();
+        assert_eq!(tables.candidates.len(), 1);
+        assert!(tables.incomplete);
+        assert!(!tables.fallback_used);
+        assert_eq!(tables.candidates[0].name, "account");
+
+        let columns = duckdb_completion_assistant_search(
+            &con,
+            &db::CompletionAssistantRequest {
+                object_kinds: vec![db::CompletionAssistantObjectKind::Column],
+                mask: "name".to_string(),
+                max_results: Some(10),
+                parent_name: Some("account".to_string()),
+                match_mode: Some(db::CompletionAssistantMatchMode::Contains),
+                ..request
+            },
+            &[],
+        )
+        .unwrap();
+        assert_eq!(columns.candidates.len(), 1);
+        assert_eq!(columns.candidates[0].name, "display_name");
+    }
+
+    #[test]
+    fn detects_unsupported_agent_completion_assistant_errors() {
+        assert!(super::is_agent_completion_assistant_unsupported(
+            "Agent RPC error (-1): Unknown method: completion_assistant_search_v1"
+        ));
+        assert!(super::is_agent_completion_assistant_unsupported(
+            "Agent RPC error (-1): unknown method: completion_assistant_search_v1"
+        ));
+        assert!(super::is_agent_completion_assistant_unsupported(
+            "Agent RPC error (-1): Completion assistant search is not supported by this agent"
+        ));
+        assert!(!super::is_agent_completion_assistant_unsupported("Agent RPC error (-1): Connection failed"));
+    }
+
+    #[test]
+    fn clickhouse_metadata_uses_schema_when_database_is_empty() {
+        assert_eq!(clickhouse_metadata_database("", "testdb"), "testdb");
+        assert_eq!(clickhouse_metadata_database("testdb", ""), "testdb");
+        assert_eq!(clickhouse_metadata_database("default", "testdb"), "default");
+    }
+
+    #[test]
+    fn deduplicates_columns_and_preserves_later_comment() {
+        let columns = deduplicate_column_infos(vec![
+            test_column("ID", None, false),
+            test_column("ID", Some("源主键"), true),
+            test_column("TFBH", Some(""), false),
+            test_column("TFBH", Some("台账编号"), false),
+        ]);
+
+        assert_eq!(columns.len(), 2);
+        assert_eq!(columns[0].name, "ID");
+        assert_eq!(columns[0].comment.as_deref(), Some("源主键"));
+        assert!(columns[0].is_primary_key);
+        assert_eq!(columns[1].name, "TFBH");
+        assert_eq!(columns[1].comment.as_deref(), Some("台账编号"));
+    }
+
+    #[test]
+    fn postgres_like_agent_metadata_fallback_targets_pg_compatible_agents() {
+        assert!(!is_agent_postgres_metadata_fallback_config(&test_connection_config(DatabaseType::Kingbase)));
+        assert!(is_agent_postgres_metadata_fallback_config(&test_connection_config(DatabaseType::Highgo)));
+        assert!(is_agent_postgres_metadata_fallback_config(&test_connection_config(DatabaseType::Vastbase)));
+        assert!(!is_agent_postgres_metadata_fallback_config(&test_connection_config(DatabaseType::Postgres)));
+        assert!(!is_agent_postgres_metadata_fallback_config(&test_connection_config(DatabaseType::Mysql)));
+    }
+
+    #[test]
+    fn agent_metadata_timeout_defaults_to_sixty_seconds_and_honors_longer_config() {
+        assert_eq!(super::agent_metadata_timeout(None), Some(std::time::Duration::from_secs(60)));
+
+        let mut config = test_connection_config(DatabaseType::Oracle);
+        assert_eq!(super::agent_metadata_timeout(Some(&config)), Some(std::time::Duration::from_secs(60)));
+
+        config.query_timeout_secs = 120;
+        assert_eq!(super::agent_metadata_timeout(Some(&config)), Some(std::time::Duration::from_secs(120)));
+
+        config.query_timeout_secs = 0;
+        assert_eq!(super::agent_metadata_timeout(Some(&config)), None);
+    }
+
+    #[test]
+    fn oracle_table_comment_sql_targets_single_table_and_escapes_literals() {
+        let sql = oracle_table_comment_sql("APP'S", "USER'S");
+
+        assert!(sql.contains("ALL_TAB_COMMENTS"));
+        assert!(sql.contains("OWNER = 'APP''S'"));
+        assert!(sql.contains("TABLE_NAME = 'USER''S'"));
+        assert!(sql.contains("TABLE_TYPE IN ('TABLE', 'VIEW')"));
+        assert!(!sql.contains("ALL_OBJECTS"));
+    }
+
+    #[test]
+    fn oracle_table_comment_from_query_result_returns_optional_non_blank_comment() {
+        let result = db::QueryResult {
+            columns: vec!["COMMENTS".to_string()],
+            column_types: Vec::new(),
+            column_sortables: Vec::new(),
+            rows: vec![vec![serde_json::json!("Customer table")]],
+            affected_rows: 0,
+            execution_time_ms: 0,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        };
+
+        assert_eq!(oracle_table_comment_from_query_result(result).unwrap().as_deref(), Some("Customer table"));
+
+        let empty = db::QueryResult {
+            columns: vec!["COMMENTS".to_string()],
+            column_types: Vec::new(),
+            column_sortables: Vec::new(),
+            rows: vec![vec![serde_json::json!("  ")]],
+            affected_rows: 0,
+            execution_time_ms: 0,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        };
+
+        assert_eq!(oracle_table_comment_from_query_result(empty).unwrap(), None);
+    }
+
+    #[test]
+    fn oracle_table_comments_sql_targets_current_page_tables() {
+        let sql = oracle_table_comments_sql("dbx_test", &["ORDERS".to_string(), "USER'S".to_string()]).unwrap();
+
+        assert!(sql.contains("ALL_TAB_COMMENTS"));
+        assert!(sql.contains("OWNER = 'DBX_TEST'"));
+        assert!(sql.contains("TABLE_NAME IN ('ORDERS', 'USER''S')"));
+        assert!(sql.contains("TABLE_TYPE IN ('TABLE', 'VIEW')"));
+        assert!(sql.contains("COMMENTS IS NOT NULL"));
+        assert_eq!(oracle_table_comments_sql("DBX_TEST", &[]), None);
+    }
+
+    #[test]
+    fn oracle_table_comments_from_query_result_maps_non_blank_comments() {
+        let result = db::QueryResult {
+            columns: vec!["TABLE_NAME".to_string(), "COMMENTS".to_string()],
+            column_types: Vec::new(),
+            column_sortables: Vec::new(),
+            rows: vec![
+                vec![serde_json::json!("ORDERS"), serde_json::json!("Orders table")],
+                vec![serde_json::json!("PRODUCTS"), serde_json::json!(" ")],
+            ],
+            affected_rows: 0,
+            execution_time_ms: 0,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        };
+
+        let comments = oracle_table_comments_from_query_result(result);
+        assert_eq!(comments.get("ORDERS").map(String::as_str), Some("Orders table"));
+        assert!(!comments.contains_key("PRODUCTS"));
+    }
+
+    #[test]
+    fn oracle_columns_sql_uses_exact_table_name_for_quoted_lowercase_tables() {
+        let sql = oracle_columns_sql("DBX_TEST", "test");
+
+        assert!(sql.contains("ALL_TAB_COLUMNS"));
+        assert!(sql.contains("ALL_COL_COMMENTS"));
+        assert!(sql.contains("c.OWNER = 'DBX_TEST'"));
+        assert!(sql.contains("c.TABLE_NAME = 'test'"));
+    }
+
+    #[test]
+    fn oracle_columns_from_query_result_maps_types_comments_and_primary_key() {
+        let result = db::QueryResult {
+            columns: vec![
+                "COLUMN_NAME".to_string(),
+                "DATA_TYPE".to_string(),
+                "NULLABLE".to_string(),
+                "DATA_DEFAULT".to_string(),
+                "DATA_LENGTH".to_string(),
+                "DATA_PRECISION".to_string(),
+                "DATA_SCALE".to_string(),
+                "COLUMN_ID".to_string(),
+                "IS_PK".to_string(),
+                "COMMENTS".to_string(),
+            ],
+            column_types: Vec::new(),
+            column_sortables: Vec::new(),
+            rows: vec![
+                vec![
+                    serde_json::json!("id"),
+                    serde_json::json!("VARCHAR2"),
+                    serde_json::json!("N"),
+                    serde_json::Value::Null,
+                    serde_json::json!("255"),
+                    serde_json::Value::Null,
+                    serde_json::Value::Null,
+                    serde_json::json!("1"),
+                    serde_json::json!("1"),
+                    serde_json::json!("identifier"),
+                ],
+                vec![
+                    serde_json::json!("data"),
+                    serde_json::json!("TIMESTAMP"),
+                    serde_json::json!("Y"),
+                    serde_json::Value::Null,
+                    serde_json::Value::Null,
+                    serde_json::Value::Null,
+                    serde_json::Value::Null,
+                    serde_json::json!("2"),
+                    serde_json::json!("0"),
+                    serde_json::Value::Null,
+                ],
+            ],
+            affected_rows: 0,
+            execution_time_ms: 0,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        };
+
+        let columns = oracle_columns_from_query_result(result);
+
+        assert_eq!(columns.len(), 2);
+        assert_eq!(columns[0].name, "id");
+        assert_eq!(columns[0].data_type, "VARCHAR2(255)");
+        assert!(!columns[0].is_nullable);
+        assert!(columns[0].is_primary_key);
+        assert_eq!(columns[0].comment.as_deref(), Some("identifier"));
+        assert_eq!(columns[1].name, "data");
+        assert_eq!(columns[1].data_type, "TIMESTAMP");
+        assert!(columns[1].is_nullable);
+    }
+
+    #[test]
+    fn oracle_object_statistics_sql_reads_rows_and_segment_bytes() {
+        let sql = oracle_object_statistics_sql("app's");
+
+        assert!(sql.contains("ALL_TABLES"));
+        assert!(sql.contains("ALL_SEGMENTS"));
+        assert!(sql.contains("ALL_INDEXES"));
+        assert!(sql.contains("ALL_LOBS"));
+        assert!(sql.contains("t.NUM_ROWS"));
+        assert!(sql.contains("OWNER = 'APP''S'"));
+        assert!(sql.contains("t.NESTED = 'NO'"));
+
+        let dba_sql = oracle_object_statistics_dba_segments_sql("app's");
+        assert!(dba_sql.contains("DBA_SEGMENTS"));
+        assert!(!dba_sql.contains("ALL_SEGMENTS"));
+
+        let user_sql = oracle_object_statistics_user_segments_sql("app's");
+        assert!(user_sql.contains("USER_SEGMENTS"));
+        assert!(user_sql.contains("OWNER = 'APP''S'"));
+        assert!(user_sql.contains("t.OWNER = USER"));
+        assert!(!user_sql.contains("CURRENT_SCHEMA"));
+
+        let rows_only_sql = oracle_object_statistics_rows_only_sql("app's");
+        assert!(rows_only_sql.contains("ALL_TABLES"));
+        assert!(rows_only_sql.contains("CAST(NULL AS NUMBER) AS TOTAL_BYTES"));
+        assert!(!rows_only_sql.contains("ALL_SEGMENTS"));
+    }
+
+    #[test]
+    fn oracle_object_statistics_from_query_result_maps_numbers() {
+        let result = db::QueryResult {
+            columns: vec![
+                "TABLE_NAME".to_string(),
+                "OWNER".to_string(),
+                "NUM_ROWS".to_string(),
+                "TOTAL_BYTES".to_string(),
+            ],
+            column_types: Vec::new(),
+            column_sortables: Vec::new(),
+            rows: vec![
+                vec![
+                    serde_json::json!("ORDERS"),
+                    serde_json::json!("APP"),
+                    serde_json::json!("1200"),
+                    serde_json::json!(65536),
+                ],
+                vec![
+                    serde_json::json!("AUDIT_LOG"),
+                    serde_json::json!("APP"),
+                    serde_json::Value::Null,
+                    serde_json::json!("8192"),
+                ],
+            ],
+            affected_rows: 0,
+            execution_time_ms: 0,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        };
+
+        let stats = oracle_object_statistics_from_query_result(result);
+
+        assert_eq!(stats.len(), 2);
+        assert_eq!(stats[0].name, "ORDERS");
+        assert_eq!(stats[0].schema.as_deref(), Some("APP"));
+        assert_eq!(stats[0].estimated_rows, Some(1200));
+        assert_eq!(stats[0].total_bytes, Some(65536));
+        assert_eq!(stats[1].estimated_rows, None);
+        assert_eq!(stats[1].total_bytes, Some(8192));
+    }
+
+    #[test]
+    fn apply_oracle_table_comments_only_fills_missing_table_comments() {
+        let mut tables = vec![
+            super::db::TableInfo {
+                name: "ORDERS".to_string(),
+                table_type: "TABLE".to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+            super::db::TableInfo {
+                name: "PRODUCTS".to_string(),
+                table_type: "TABLE".to_string(),
+                comment: Some("Existing".to_string()),
+                parent_schema: None,
+                parent_name: None,
+            },
+        ];
+        let comments = HashMap::from([
+            ("ORDERS".to_string(), "Orders table".to_string()),
+            ("PRODUCTS".to_string(), "Products table".to_string()),
+        ]);
+
+        super::apply_oracle_table_comments(&mut tables, &comments);
+
+        assert_eq!(tables[0].comment.as_deref(), Some("Orders table"));
+        assert_eq!(tables[1].comment.as_deref(), Some("Existing"));
+    }
+
+    #[test]
+    fn oracle_missing_object_table_comment_names_only_includes_tables_and_views() {
+        let objects = vec![
+            super::db::ObjectInfo {
+                name: "ORDERS".to_string(),
+                object_type: "TABLE".to_string(),
+                schema: Some("DBX_TEST".to_string()),
+                signature: None,
+                comment: None,
+                created_at: None,
+                updated_at: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+            super::db::ObjectInfo {
+                name: "ORDERS_VIEW".to_string(),
+                object_type: "VIEW".to_string(),
+                schema: Some("DBX_TEST".to_string()),
+                signature: None,
+                comment: None,
+                created_at: None,
+                updated_at: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+            super::db::ObjectInfo {
+                name: "REFRESH_ORDERS".to_string(),
+                object_type: "PROCEDURE".to_string(),
+                schema: Some("DBX_TEST".to_string()),
+                signature: None,
+                comment: None,
+                created_at: None,
+                updated_at: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+        ];
+
+        assert_eq!(
+            super::oracle_missing_object_table_comment_names(&objects),
+            vec!["ORDERS".to_string(), "ORDERS_VIEW".to_string()]
+        );
+    }
+
+    #[test]
+    fn doris_family_catalog_capable_matches_doris_and_starrocks_only() {
+        // Doris and StarRocks expose multi-catalog federation.
+        assert!(super::is_doris_family_catalog_capable_config(&test_connection_config(DatabaseType::Doris)));
+        assert!(super::is_doris_family_catalog_capable_config(&test_connection_config(DatabaseType::StarRocks)));
+
+        // Driver profiles for Doris/SelectDB/StarRocks also qualify.
+        let mut doris = test_connection_config(DatabaseType::Mysql);
+        doris.driver_profile = Some("doris".to_string());
+        assert!(super::is_doris_family_catalog_capable_config(&doris));
+
+        let mut selectdb = test_connection_config(DatabaseType::Mysql);
+        selectdb.driver_profile = Some("selectdb".to_string());
+        assert!(super::is_doris_family_catalog_capable_config(&selectdb));
+
+        let mut starrocks = test_connection_config(DatabaseType::Mysql);
+        starrocks.driver_profile = Some("starrocks".to_string());
+        assert!(super::is_doris_family_catalog_capable_config(&starrocks));
+
+        // ManticoreSearch shares the MySQL code path but has no catalog concept.
+        assert!(!super::is_doris_family_catalog_capable_config(&test_connection_config(DatabaseType::ManticoreSearch)));
+
+        let mut manticore = test_connection_config(DatabaseType::Mysql);
+        manticore.driver_profile = Some("manticoresearch".to_string());
+        assert!(!super::is_doris_family_catalog_capable_config(&manticore));
+
+        // Plain MySQL / Postgres are not catalog-capable.
+        assert!(!super::is_doris_family_catalog_capable_config(&test_connection_config(DatabaseType::Mysql)));
+        assert!(!super::is_doris_family_catalog_capable_config(&test_connection_config(DatabaseType::Postgres)));
+    }
+}
+
+pub async fn list_objects_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<&[String]>,
+) -> Result<Vec<db::ObjectInfo>, String> {
+    let db_config = connection_config(state, connection_id).await;
+    let filter_locally_after_oracle_comments = db_config.as_ref().is_some_and(|config| {
+        config.db_type == DatabaseType::Oracle && filter.is_some_and(|filter| !filter.trim().is_empty())
+    });
+    let use_oracle_agent_paging =
+        db_config.as_ref().is_some_and(is_default_oracle_agent_config) && !filter_locally_after_oracle_comments;
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let objects = list_objects_once(state, connection_id, database, schema, filter, limit, offset, object_types)
+            .await
+            .map(|outcome| {
+                let final_offset = if outcome.paging_applied
+                    || oracle_agent_paging_likely_applied(use_oracle_agent_paging, limit, outcome.objects.len())
+                {
+                    Some(0)
+                } else {
+                    offset
+                };
+                filter_object_infos(outcome.objects, filter, limit, final_offset, object_types)
+            })?;
+        Ok(objects)
+    })
+    .await
+}
+
+pub async fn list_object_statistics_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+) -> Result<Vec<db::ObjectStatistics>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || {
+        list_object_statistics_once(state, connection_id, database, schema)
+    })
+    .await
+}
+
+pub async fn list_completion_objects_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+) -> Result<Vec<db::ObjectInfo>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || {
+        list_completion_objects_once(state, connection_id, database, schema)
+    })
+    .await
+}
+
+pub async fn completion_assistant_search_core(
+    state: &AppState,
+    request: db::CompletionAssistantRequest,
+) -> Result<db::CompletionAssistantResponse, String> {
+    let started_at = Instant::now();
+    let request_summary = format!(
+        "connection_id={} database={} schema={:?} kinds={:?} mask={} limit={:?}",
+        request.connection_id,
+        request.database,
+        request.schema,
+        request.object_kinds,
+        request.mask,
+        request.max_results
+    );
+    retry_metadata_connection(state, &request.connection_id, Some(&request.database), || async {
+        let pool_key = state.get_or_create_pool(&request.connection_id, Some(&request.database)).await?;
+        log::debug!("[schema][completion_assistant:start] {request_summary}");
+        {
+            let connections = state.connections.read().await;
+            try_sqlserver!(connections, &pool_key, completion_assistant_search, &request);
+        }
+
+        {
+            let connections = state.connections.read().await;
+            if let Some(pool) = connections.get(&pool_key).and_then(|pool| match pool {
+                PoolKind::Sqlite(pool) => Some(pool.clone()),
+                _ => None,
+            }) {
+                drop(connections);
+                return db::sqlite::completion_assistant_search(&pool, &request).await;
+            }
+        }
+
+        #[cfg(feature = "duckdb-bundled")]
+        {
+            let duckdb_attached_names = duckdb_attached_database_names(state, &request.connection_id).await;
+            let connections = state.connections.read().await;
+            if let Some(con) = extract_pool!(&connections, &pool_key, DuckDb) {
+                drop(connections);
+                let con = con.lock().map_err(|e| e.to_string())?;
+                return duckdb_completion_assistant_search(&con, &request, &duckdb_attached_names);
+            }
+        }
+
+        {
+            let connections = state.connections.read().await;
+            if let Some(pool) = connections.get(&pool_key).and_then(|pool| match pool {
+                PoolKind::Postgres(pool) => Some(pool.clone()),
+                _ => None,
+            }) {
+                drop(connections);
+                return db::postgres::completion_assistant_search(&pool, &request).await;
+            }
+        }
+
+        {
+            let connections = state.connections.read().await;
+            if let Some(pool) = connections.get(&pool_key).and_then(|pool| match pool {
+                PoolKind::Mysql(pool, mode) if *mode != MysqlMode::OceanBaseOracle => Some(pool.clone()),
+                _ => None,
+            }) {
+                drop(connections);
+                return db::mysql::completion_assistant_search(&pool, &request).await;
+            }
+        }
+
+        {
+            let connections = state.connections.read().await;
+            if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+                let db_config = connection_config(state, &request.connection_id).await;
+                drop(connections);
+                let mut client = client.lock().await;
+                match client
+                    .completion_assistant_search::<db::CompletionAssistantResponse>(
+                        &request,
+                        agent_metadata_timeout(db_config.as_ref()),
+                    )
+                    .await
+                {
+                    Ok(mut response) => {
+                        response.fallback_used = false;
+                        return Ok(response);
+                    }
+                    Err(error) if is_agent_completion_assistant_unsupported(&error) => {
+                        log::debug!(
+                            "[schema][completion_assistant:agent-fallback] {} reason={}",
+                            request_summary,
+                            error
+                        );
+                    }
+                    Err(error) => return Err(error),
+                }
+            }
+        }
+
+        let response = completion_assistant_fallback_core(state, &request).await;
+        if let Ok(response) = &response {
+            log::debug!(
+                "[schema][completion_assistant:done] {} elapsed_ms={} candidates={} fallback_used={}",
+                request_summary,
+                started_at.elapsed().as_millis(),
+                response.candidates.len(),
+                response.fallback_used
+            );
+        }
+        response
+    })
+    .await
+}
+
+fn is_agent_completion_assistant_unsupported(error: &str) -> bool {
+    let error = error.to_ascii_lowercase();
+    error.contains("unknown method: completion_assistant_search_v1")
+        || error.contains("method not found: completion_assistant_search_v1")
+        || error.contains("completion assistant search is not supported")
+}
+
+async fn completion_assistant_fallback_core(
+    state: &AppState,
+    request: &db::CompletionAssistantRequest,
+) -> Result<db::CompletionAssistantResponse, String> {
+    let limit = request.max_results.unwrap_or(100).clamp(1, 1000);
+    let kinds = if request.object_kinds.is_empty() {
+        vec![db::CompletionAssistantObjectKind::Table, db::CompletionAssistantObjectKind::View]
+    } else {
+        request.object_kinds.clone()
+    };
+    let mut candidates = Vec::new();
+    let schema = request.parent_schema.as_deref().or(request.schema.as_deref()).unwrap_or("");
+    let filter = request.mask.trim().trim_matches('%');
+
+    if kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::Schema)) {
+        let schemas = list_schemas_core(state, &request.connection_id, &request.database).await?;
+        for schema_name in schemas {
+            if completion_name_matches(&schema_name, filter, request.match_mode.as_ref()) {
+                candidates.push(db::CompletionAssistantCandidate {
+                    name: schema_name.clone(),
+                    kind: db::CompletionAssistantCandidateKind::Schema,
+                    database: Some(request.database.clone()),
+                    schema: Some(schema_name),
+                    parent_schema: None,
+                    parent_name: None,
+                    comment: None,
+                    data_type: None,
+                });
+            }
+            if candidates.len() >= limit {
+                return Ok(db::CompletionAssistantResponse { candidates, incomplete: true, fallback_used: true });
+            }
+        }
+    }
+
+    if kinds.iter().any(db::CompletionAssistantObjectKind::is_table_like) {
+        let object_types = completion_table_object_types(&kinds);
+        let tables = list_tables_core(
+            state,
+            &request.connection_id,
+            &request.database,
+            schema,
+            if filter.is_empty() { None } else { Some(filter) },
+            Some(limit),
+            None,
+            object_types.as_deref(),
+        )
+        .await?;
+        for table in tables {
+            let kind = if table.table_type.to_uppercase().contains("VIEW") {
+                db::CompletionAssistantCandidateKind::View
+            } else {
+                db::CompletionAssistantCandidateKind::Table
+            };
+            candidates.push(db::CompletionAssistantCandidate {
+                name: table.name,
+                kind,
+                database: Some(request.database.clone()),
+                schema: if schema.is_empty() { None } else { Some(schema.to_string()) },
+                parent_schema: table.parent_schema,
+                parent_name: table.parent_name,
+                comment: table.comment,
+                data_type: None,
+            });
+            if candidates.len() >= limit {
+                return Ok(db::CompletionAssistantResponse { candidates, incomplete: true, fallback_used: true });
+            }
+        }
+    }
+
+    if kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::Column)) {
+        if let Some(table) = request.parent_name.as_deref().filter(|table| !table.trim().is_empty()) {
+            let columns = get_columns_core(state, &request.connection_id, &request.database, schema, table).await?;
+            for column in columns {
+                if completion_name_matches(&column.name, filter, request.match_mode.as_ref()) {
+                    candidates.push(db::CompletionAssistantCandidate {
+                        name: column.name,
+                        kind: db::CompletionAssistantCandidateKind::Column,
+                        database: Some(request.database.clone()),
+                        schema: if schema.is_empty() { None } else { Some(schema.to_string()) },
+                        parent_schema: if schema.is_empty() { None } else { Some(schema.to_string()) },
+                        parent_name: Some(table.to_string()),
+                        comment: column.comment,
+                        data_type: Some(column.data_type),
+                    });
+                }
+                if candidates.len() >= limit {
+                    return Ok(db::CompletionAssistantResponse { candidates, incomplete: true, fallback_used: true });
+                }
+            }
+        }
+    }
+
+    Ok(db::CompletionAssistantResponse { candidates, incomplete: false, fallback_used: true })
+}
+
+fn completion_table_object_types(kinds: &[db::CompletionAssistantObjectKind]) -> Option<Vec<String>> {
+    let mut object_types = Vec::new();
+    if kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::Table)) {
+        object_types.push("table".to_string());
+    }
+    if kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::View)) {
+        object_types.push("view".to_string());
+    }
+    if object_types.is_empty() {
+        None
+    } else {
+        Some(object_types)
+    }
+}
+
+fn completion_name_matches(name: &str, filter: &str, mode: Option<&db::CompletionAssistantMatchMode>) -> bool {
+    if filter.is_empty() {
+        return true;
+    }
+    let name = name.to_lowercase();
+    let filter = filter.to_lowercase();
+    match mode.unwrap_or(&db::CompletionAssistantMatchMode::Prefix) {
+        db::CompletionAssistantMatchMode::Prefix => name.starts_with(&filter),
+        db::CompletionAssistantMatchMode::Contains => name.contains(&filter),
+    }
+}
+
+async fn list_object_statistics_once(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+) -> Result<Vec<db::ObjectStatistics>, String> {
+    let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+    let db_config = connection_config(state, connection_id).await;
+    let connections = state.connections.read().await;
+    try_sqlserver!(connections, &pool_key, list_object_statistics, schema);
+    if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+        if db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::Oracle) {
+            drop(connections);
+            return oracle_agent_list_object_statistics(
+                client,
+                database,
+                schema,
+                agent_metadata_timeout(db_config.as_ref()),
+            )
+            .await;
+        }
+    }
+    let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+    match pool {
+        PoolKind::Mysql(p, mode) => {
+            if *mode == MysqlMode::OceanBaseOracle || db_config.as_ref().is_some_and(is_manticoresearch_config) {
+                Ok(vec![])
+            } else {
+                db::mysql::list_object_statistics(p, database).await
+            }
+        }
+        PoolKind::Postgres(p) if db_config.as_ref().is_some_and(is_questdb_config) => Ok(vec![]),
+        PoolKind::Postgres(p) => db::postgres::list_object_statistics(p, schema).await,
+        PoolKind::ClickHouse(client) => {
+            db::clickhouse_driver::list_object_statistics(client, clickhouse_metadata_database(database, schema)).await
+        }
+        _ => Ok(vec![]),
+    }
+}
+
+struct ObjectListOutcome {
+    objects: Vec<db::ObjectInfo>,
+    paging_applied: bool,
+}
+
+fn unpaged_object_list(objects: Vec<db::ObjectInfo>) -> ObjectListOutcome {
+    ObjectListOutcome { objects, paging_applied: false }
+}
+
+async fn list_objects_once(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<&[String]>,
+) -> Result<ObjectListOutcome, String> {
+    let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+    let db_config = connection_config(state, connection_id).await;
+    let (mysql_limit, mysql_offset) =
+        if filter.is_none_or(|value| value.trim().is_empty()) { (limit, offset) } else { (None, None) };
+
+    {
+        let connections = state.connections.read().await;
+        #[cfg(feature = "duckdb-bundled")]
+        if let Some(ext_pool) = extract_pool!(&connections, &pool_key, ExternalTabular) {
+            drop(connections);
+            let cache = ext_pool.cache.clone();
+            let objects = tokio::task::spawn_blocking(move || {
+                let con = cache.lock().map_err(|e| e.to_string())?;
+                Ok(duckdb_query_tables(&con)?
+                    .into_iter()
+                    .map(|table| db::ObjectInfo {
+                        name: table.name,
+                        object_type: table.table_type,
+                        schema: None,
+                        signature: None,
+                        comment: table.comment,
+                        created_at: None,
+                        updated_at: None,
+                        parent_schema: table.parent_schema,
+                        parent_name: table.parent_name,
+                    })
+                    .collect())
+            })
+            .await
+            .map_err(|e| e.to_string())?;
+            return objects.map(unpaged_object_list);
+        }
+        if let Some(PoolKind::ExternalDriver { config, session, .. }) = connections.get(&pool_key) {
+            let config = config.clone();
+            let session = session.clone();
+            drop(connections);
+            if uses_presto_like_information_schema_tables(&config.db_type) {
+                return external_driver_presto_like_objects(
+                    session,
+                    config.as_ref(),
+                    database,
+                    schema,
+                    filter,
+                    object_types,
+                )
+                .await
+                .map(unpaged_object_list);
+            }
+            let mut params =
+                serde_json::json!({ "connection": config.as_ref(), "database": database, "schema": schema });
+            if let Some(filter) = filter.map(str::trim).filter(|value| !value.is_empty()) {
+                params["filter"] = serde_json::json!(filter);
+            }
+            if let Some(object_types) = object_types {
+                params["object_types"] = serde_json::json!(object_types);
+            }
+            return session
+                .invoke_with_timeout::<Vec<db::ObjectInfo>>(
+                    "listObjects",
+                    params,
+                    agent_metadata_timeout(Some(config.as_ref())),
+                )
+                .await
+                .map(unpaged_object_list);
+        }
+        if let Some(client) = extract_pool!(&connections, &pool_key, SqlServer) {
+            drop(connections);
+            let mut client = client.lock().await;
+            return db::sqlserver::list_objects(&mut client, schema).await.map(unpaged_object_list);
+        }
+        if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+            let is_oracle = db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::Oracle);
+            let use_oracle_agent_paging = db_config.as_ref().is_some_and(is_default_oracle_agent_config);
+            let filter_locally_after_oracle_comments =
+                is_oracle && filter.is_some_and(|filter| !filter.trim().is_empty());
+            let timeout_duration = agent_metadata_timeout(db_config.as_ref());
+            let fallback_config = db_config.clone();
+            drop(connections);
+            if is_oracle && !use_oracle_agent_paging {
+                return oracle_agent_list_objects(client, database, schema, timeout_duration)
+                    .await
+                    .map(unpaged_object_list);
+            }
+            let mut client = client.lock().await;
+            let agent_filter = if filter_locally_after_oracle_comments { None } else { filter };
+            let agent_limit = if filter_locally_after_oracle_comments {
+                None
+            } else if use_oracle_agent_paging {
+                limit
+            } else {
+                None
+            };
+            let agent_offset = if filter_locally_after_oracle_comments {
+                None
+            } else if use_oracle_agent_paging {
+                offset
+            } else {
+                None
+            };
+            match client
+                .list_objects_constrained::<Vec<db::ObjectInfo>>(
+                    database,
+                    schema,
+                    agent_filter,
+                    agent_limit,
+                    agent_offset,
+                    object_types,
+                    timeout_duration,
+                )
+                .await
+            {
+                Ok(mut objects) if !objects.is_empty() => {
+                    if is_oracle {
+                        load_oracle_table_comments_for_objects(
+                            &mut client,
+                            database,
+                            schema,
+                            &mut objects,
+                            timeout_duration,
+                        )
+                        .await?;
+                    }
+                    return Ok(unpaged_object_list(objects));
+                }
+                Ok(objects) => {
+                    if let Some(config) = fallback_config.as_ref() {
+                        match native_postgres_metadata_pool(state, connection_id, database, config).await {
+                            Ok(Some(pool)) => {
+                                return db::postgres::list_objects(&pool, schema).await.map(unpaged_object_list)
+                            }
+                            Ok(None) => return Ok(unpaged_object_list(objects)),
+                            Err(error) => {
+                                log::warn!(
+                                    "[schema][agent:list_objects:fallback-failed] connection_id={} database={} schema={} error={}",
+                                    connection_id,
+                                    database,
+                                    schema,
+                                    error
+                                );
+                            }
+                        }
+                    }
+                    return Ok(unpaged_object_list(objects));
+                }
+                Err(agent_error) => {
+                    if let Some(config) = fallback_config.as_ref() {
+                        if let Some(pool) =
+                            native_postgres_metadata_pool(state, connection_id, database, config).await?
+                        {
+                            return db::postgres::list_objects(&pool, schema).await.map(unpaged_object_list).map_err(
+                                |fallback_error| {
+                                    format!(
+                                        "{agent_error}\n\nNative PostgreSQL metadata fallback failed: {fallback_error}"
+                                    )
+                                },
+                            );
+                        }
+                    }
+                    return Err(agent_error);
+                }
+            }
+        }
+    }
+
+    let connections = state.connections.read().await;
+    let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+    match pool {
+        PoolKind::Mysql(p, mode) => {
+            // Note: mysql and ob_oracle take different second args (database vs schema)
+            if *mode == MysqlMode::OceanBaseOracle {
+                db::ob_oracle::list_objects(p, schema).await.map(unpaged_object_list)
+            } else if db_config.as_ref().is_some_and(is_manticoresearch_config) {
+                db::manticoresearch::list_objects(p, database).await.map(unpaged_object_list)
+            } else if db_config.as_ref().is_some_and(is_doris_family_config) {
+                db::mysql::list_table_objects_show(p, database).await.map(unpaged_object_list)
+            } else {
+                db::mysql::list_objects(p, database, object_types, mysql_limit, mysql_offset)
+                    .await
+                    .map(|result| ObjectListOutcome { objects: result.objects, paging_applied: result.paging_applied })
+            }
+        }
+        PoolKind::Postgres(p) if db_config.as_ref().is_some_and(is_questdb_config) => {
+            db::questdb::list_objects(p, schema).await.map(unpaged_object_list)
+        }
+        PoolKind::Postgres(p) => db::postgres::list_objects(p, schema).await.map(unpaged_object_list),
+        _ => {
+            drop(connections);
+            Ok(unpaged_object_list(
+                list_tables_core(state, connection_id, database, schema, None, None, None, None)
+                    .await?
+                    .into_iter()
+                    .map(|table| db::ObjectInfo {
+                        name: table.name,
+                        object_type: table.table_type,
+                        schema: if schema.is_empty() { None } else { Some(schema.to_string()) },
+                        signature: None,
+                        comment: table.comment,
+                        created_at: None,
+                        updated_at: None,
+                        parent_schema: table.parent_schema,
+                        parent_name: table.parent_name,
+                    })
+                    .collect(),
+            ))
+        }
+    }
+}
+
+async fn list_completion_objects_once(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+) -> Result<Vec<db::ObjectInfo>, String> {
+    let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+    let db_config = connection_config(state, connection_id).await;
+
+    let connections = state.connections.read().await;
+    if let Some(PoolKind::ExternalDriver { config, session, .. }) = connections.get(&pool_key) {
+        let config = config.clone();
+        let session = session.clone();
+        drop(connections);
+        return session
+            .invoke_with_timeout::<Vec<db::ObjectInfo>>(
+                "listObjects",
+                serde_json::json!({ "connection": config.as_ref(), "database": database, "schema": schema }),
+                agent_metadata_timeout(Some(config.as_ref())),
+            )
+            .await
+            .map(filter_completion_objects);
+    }
+    if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+        let is_oracle = db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::Oracle);
+        let fallback_config = db_config.clone();
+        drop(connections);
+        let objects = if is_oracle {
+            oracle_agent_list_objects(client, database, schema, agent_metadata_timeout(db_config.as_ref())).await?
+        } else {
+            let mut client = client.lock().await;
+            match client
+                .list_objects::<Vec<db::ObjectInfo>>(database, schema, agent_metadata_timeout(db_config.as_ref()))
+                .await
+            {
+                Ok(objects) if !objects.is_empty() => objects,
+                Ok(objects) => {
+                    if let Some(config) = fallback_config.as_ref() {
+                        match native_postgres_metadata_pool(state, connection_id, database, config).await {
+                            Ok(Some(pool)) => {
+                                return db::postgres::list_objects(&pool, schema).await.map(filter_completion_objects)
+                            }
+                            Ok(None) => objects,
+                            Err(error) => {
+                                log::warn!(
+                                    "[schema][agent:list_completion_objects:fallback-failed] connection_id={} database={} schema={} error={}",
+                                    connection_id,
+                                    database,
+                                    schema,
+                                    error
+                                );
+                                objects
+                            }
+                        }
+                    } else {
+                        objects
+                    }
+                }
+                Err(agent_error) => {
+                    if let Some(config) = fallback_config.as_ref() {
+                        if let Some(pool) =
+                            native_postgres_metadata_pool(state, connection_id, database, config).await?
+                        {
+                            return db::postgres::list_objects(&pool, schema)
+                                .await
+                                .map(filter_completion_objects)
+                                .map_err(|fallback_error| {
+                                    format!(
+                                        "{agent_error}\n\nNative PostgreSQL metadata fallback failed: {fallback_error}"
+                                    )
+                                });
+                        }
+                    }
+                    return Err(agent_error);
+                }
+            }
+        };
+        return Ok(filter_completion_objects(objects));
+    }
+
+    let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+    match pool {
+        PoolKind::Mysql(p, mode) if *mode != MysqlMode::OceanBaseOracle => {
+            db::mysql::list_completion_objects(p, database).await
+        }
+        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
+            db::ob_oracle::list_objects(p, schema).await.map(filter_completion_objects)
+        }
+        PoolKind::Postgres(p) if db_config.as_ref().is_some_and(is_questdb_config) => {
+            db::questdb::list_objects(p, schema).await.map(filter_completion_objects)
+        }
+        PoolKind::Postgres(p) => db::postgres::list_objects(p, schema).await.map(filter_completion_objects),
+        PoolKind::SqlServer(_) => {
+            drop(connections);
+            let outcome = list_objects_once(state, connection_id, database, schema, None, None, None, None).await?;
+            Ok(filter_completion_objects(outcome.objects))
+        }
+        _ => Ok(Vec::new()),
+    }
+}
+
+fn filter_completion_objects(objects: Vec<db::ObjectInfo>) -> Vec<db::ObjectInfo> {
+    objects
+        .into_iter()
+        .filter(|object| {
+            let object_type = object.object_type.to_ascii_uppercase();
+            object_type.contains("PROCEDURE") || object_type.contains("FUNCTION") || object_type.contains("TRIGGER")
+        })
+        .collect()
+}
+
+fn is_agent_postgres_metadata_fallback_config(config: &ConnectionConfig) -> bool {
+    // Kingbase has dedicated agent metadata SQL and may carry JDBC-specific URL
+    // parameters that the native PostgreSQL driver cannot parse.
+    matches!(config.db_type, DatabaseType::Highgo | DatabaseType::Vastbase)
+}
+
+async fn native_postgres_metadata_pool(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    config: &ConnectionConfig,
+) -> Result<Option<deadpool_postgres::Pool>, String> {
+    if !is_agent_postgres_metadata_fallback_config(config) {
+        return Ok(None);
+    }
+
+    let mut postgres_config = database_connection_config(config, Some(database));
+    postgres_config.db_type = DatabaseType::Postgres;
+    let (host, port) = state.connection_host_port(connection_id, &postgres_config).await?;
+    let url = connection_url_for_endpoint(&postgres_config, &host, port);
+    let connect_timeout = Duration::from_secs(postgres_config.effective_connect_timeout_secs());
+    db::postgres::connect(&url, connect_timeout).await.map(Some)
+}
+
+async fn retry_metadata_connection<T, F, Fut>(
+    state: &AppState,
+    connection_id: &str,
+    database: Option<&str>,
+    mut operation: F,
+) -> Result<T, String>
+where
+    F: FnMut() -> Fut,
+    Fut: Future<Output = Result<T, String>>,
+{
+    let result = operation().await;
+    match result {
+        Err(error) if is_retryable_metadata_error(&error) => {
+            state.reconnect_pool(connection_id, database).await?;
+            operation().await
+        }
+        _ => result,
+    }
+}
+
+fn is_retryable_metadata_error(error: &str) -> bool {
+    error == "Pool not found" || crate::query::is_connection_error(error)
+}
+
+pub async fn get_columns_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::ColumnInfo>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        #[cfg(feature = "duckdb-bundled")]
+        let duckdb_attached_names = duckdb_attached_database_names(state, connection_id).await;
+        let db_config = connection_config(state, connection_id).await;
+
+        {
+            let connections = state.connections.read().await;
+            #[cfg(feature = "duckdb-bundled")]
+            if let Some(ext_pool) = extract_pool!(&connections, &pool_key, ExternalTabular) {
+                drop(connections);
+                let cache = ext_pool.cache.clone();
+                let table = table.to_string();
+                return tokio::task::spawn_blocking(move || {
+                    let con = cache.lock().map_err(|e| e.to_string())?;
+                    duckdb_query_columns(&con, &table)
+                })
+                .await
+                .map_err(|e| e.to_string())?;
+            }
+            if let Some(PoolKind::ExternalDriver { config, session, .. }) = connections.get(&pool_key) {
+                let config = config.clone();
+                let session = session.clone();
+                drop(connections);
+                if uses_presto_like_information_schema_tables(&config.db_type) {
+                    return external_driver_presto_like_columns(session, config.as_ref(), database, schema, table).await;
+                }
+                let columns = session
+                    .invoke_with_timeout::<Vec<db::ColumnInfo>>(
+                        "getColumns",
+                        serde_json::json!({
+                            "connection": config.as_ref(),
+                            "database": database,
+                            "schema": schema,
+                            "table": table,
+                        }),
+                        agent_metadata_timeout(Some(config.as_ref())),
+                    )
+                    .await?;
+                if columns.is_empty() && config.db_type == DatabaseType::Oracle {
+                    match external_driver_oracle_columns_via_sql(
+                        session.clone(),
+                        config.as_ref(),
+                        database,
+                        schema,
+                        table,
+                    )
+                    .await
+                    {
+                        Ok(fallback_columns) if !fallback_columns.is_empty() => return Ok(fallback_columns),
+                        Ok(_) => {}
+                        Err(error) => {
+                            log::warn!(
+                                "[schema][external-driver:get_columns:oracle-fallback-failed] connection_id={} database={} schema={} table={} error={}",
+                                connection_id,
+                                database,
+                                schema,
+                                table,
+                                error
+                            );
+                        }
+                    }
+                }
+                return Ok(deduplicate_column_infos(columns));
+            }
+            #[cfg(feature = "duckdb-bundled")]
+            if let Some(con) = extract_pool!(&connections, &pool_key, DuckDb) {
+                drop(connections);
+                let con = con.lock().map_err(|e| e.to_string())?;
+                return duckdb_query_columns_in_database_with_attached(
+                    &con,
+                    database,
+                    schema,
+                    table,
+                    &duckdb_attached_names,
+                );
+            }
+            #[cfg(feature = "duckdb-bundled")]
+            if let Some(client) = extract_pool!(&connections, &pool_key, DuckDbWorker) {
+                let database = database.to_string();
+                let schema = schema.to_string();
+                let table = table.to_string();
+                drop(connections);
+                return client.list_columns(database, schema, table).await;
+            }
+            if let Some(client) = extract_pool!(&connections, &pool_key, ClickHouse) {
+                drop(connections);
+                return db::clickhouse_driver::get_columns(&client, clickhouse_metadata_database(database, schema), table)
+                    .await
+                    .map(deduplicate_column_infos);
+            }
+            if let Some(client) = extract_pool!(&connections, &pool_key, InfluxDb) {
+                drop(connections);
+                return db::influxdb_driver::get_columns(&client, database, table).await.map(deduplicate_column_infos);
+            }
+            if let Some(linked) = crate::sql_dialect::parse_sqlserver_linked_schema_ref(schema) {
+                if let Some(client) = extract_pool!(&connections, &pool_key, SqlServer) {
+                    drop(connections);
+                    let mut client = client.lock().await;
+                    return db::sqlserver::get_linked_server_columns(
+                        &mut client,
+                        &linked.server,
+                        &linked.catalog,
+                        &linked.schema,
+                        table,
+                    )
+                    .await
+                    .map(deduplicate_column_infos);
+                }
+            }
+            try_sqlserver!(connections, &pool_key, get_columns, schema, table);
+            if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+                let fallback_config = db_config.clone();
+                drop(connections);
+                let mut client = client.lock().await;
+                match client
+                    .get_columns::<Vec<db::ColumnInfo>>(
+                        database,
+                        schema,
+                        table,
+                        agent_metadata_timeout(db_config.as_ref()),
+                    )
+                    .await
+                {
+                    Ok(columns) if !columns.is_empty() => return Ok(deduplicate_column_infos(columns)),
+                    Ok(columns) => {
+                        if let Some(config) = fallback_config.as_ref() {
+                            if config.db_type == DatabaseType::Oracle {
+                                match oracle_columns_via_sql(
+                                    database,
+                                    schema,
+                                    table,
+                                    &mut client,
+                                    agent_metadata_timeout(Some(config)),
+                                )
+                                .await
+                                {
+                                    Ok(fallback_columns) if !fallback_columns.is_empty() => return Ok(fallback_columns),
+                                    Ok(_) => {}
+                                    Err(error) => {
+                                        log::warn!(
+                                            "[schema][agent:get_columns:oracle-fallback-failed] connection_id={} database={} schema={} table={} error={}",
+                                            connection_id,
+                                            database,
+                                            schema,
+                                            table,
+                                            error
+                                        );
+                                    }
+                                }
+                            }
+                            match native_postgres_metadata_pool(state, connection_id, database, config).await {
+                                Ok(Some(pool)) => {
+                                    return db::postgres::get_columns(&pool, schema, table)
+                                        .await
+                                        .map(deduplicate_column_infos);
+                                }
+                                Ok(None) => return Ok(deduplicate_column_infos(columns)),
+                                Err(error) => {
+                                    log::warn!(
+                                        "[schema][agent:get_columns:fallback-failed] connection_id={} database={} schema={} table={} error={}",
+                                        connection_id,
+                                        database,
+                                        schema,
+                                        table,
+                                        error
+                                    );
+                                }
+                            }
+                        }
+                        return Ok(deduplicate_column_infos(columns));
+                    }
+                    Err(agent_error) => {
+                        if let Some(config) = fallback_config.as_ref() {
+                            if let Some(pool) =
+                                native_postgres_metadata_pool(state, connection_id, database, config).await?
+                            {
+                                return db::postgres::get_columns(&pool, schema, table)
+                                    .await
+                                    .map(deduplicate_column_infos)
+                                    .map_err(|fallback_error| {
+                                        format!(
+                                            "{agent_error}\n\nNative PostgreSQL metadata fallback failed: {fallback_error}"
+                                        )
+                                    });
+                            }
+                        }
+                        return Err(agent_error);
+                    }
+                }
+            }
+        }
+
+        let connections = state.connections.read().await;
+        let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+        match pool {
+            PoolKind::Mysql(p, _) if db_config.as_ref().is_some_and(is_manticoresearch_config) => {
+                let metadata_database = mysql_show_metadata_database_for_config(db_config.as_ref(), database);
+                db::manticoresearch::get_columns(p, metadata_database, table).await.map(deduplicate_column_infos)
+            }
+            PoolKind::Mysql(p, _) if db_config.as_ref().is_some_and(is_doris_family_config) => {
+                let metadata_database = mysql_show_metadata_database_for_config(db_config.as_ref(), database);
+                // Doris/StarRocks previously went straight to `SHOW COLUMNS` for
+                // speed (see perf(doris) commit), but `SHOW COLUMNS` reports the
+                // `Key` column as `YES`/`NO` rather than MySQL's `PRI`, so primary
+                // keys were never detected. `get_columns` queries
+                // information_schema.COLUMNS first — where `COLUMN_KEY = 'PRI'`
+                // correctly identifies primary keys (and only real primary keys,
+                // not duplicate-key sort columns) — and falls back to `SHOW COLUMNS`
+                // automatically when information_schema is unavailable.
+                db::mysql::get_columns(p, metadata_database, table).await.map(deduplicate_column_infos)
+            }
+            PoolKind::Mysql(p, mode) => {
+                let effective_db = mysql_table_metadata_catalog(database, schema);
+                dispatch_mysql!(p, mode, db::mysql::get_columns, db::ob_oracle::get_columns, effective_db, table)
+                    .map(deduplicate_column_infos)
+            }
+            PoolKind::Postgres(p) if db_config.as_ref().is_some_and(is_questdb_config) => {
+                db::questdb::get_columns(p, schema, table).await.map(deduplicate_column_infos)
+            }
+            PoolKind::Postgres(p) => db::postgres::get_columns(p, schema, table).await.map(deduplicate_column_infos),
+            PoolKind::Sqlite(p) => db::sqlite::get_columns(p, schema, table).await.map(deduplicate_column_infos),
+            PoolKind::Rqlite(client) => {
+                db::rqlite_driver::get_columns(client, schema, table).await.map(deduplicate_column_infos)
+            }
+            PoolKind::CloudflareD1(client) => db::cloudflare_d1_driver::get_columns(client, schema, table)
+                .await
+                .map(deduplicate_column_infos),
+            _ => Ok(vec![]),
+        }
+    })
+    .await
+}
+
+fn deduplicate_column_infos(columns: Vec<db::ColumnInfo>) -> Vec<db::ColumnInfo> {
+    let mut result: Vec<db::ColumnInfo> = Vec::with_capacity(columns.len());
+    for column in columns {
+        if let Some(existing) = result.iter_mut().find(|existing| existing.name == column.name) {
+            existing.is_primary_key |= column.is_primary_key;
+            existing.is_nullable &= column.is_nullable;
+            merge_optional_string(&mut existing.column_default, column.column_default);
+            merge_optional_string(&mut existing.extra, column.extra);
+            merge_optional_string(&mut existing.comment, column.comment);
+            if existing.numeric_precision.is_none() {
+                existing.numeric_precision = column.numeric_precision;
+            }
+            if existing.numeric_scale.is_none() {
+                existing.numeric_scale = column.numeric_scale;
+            }
+            if existing.character_maximum_length.is_none() {
+                existing.character_maximum_length = column.character_maximum_length;
+            }
+            if existing.data_type.trim().is_empty() && !column.data_type.trim().is_empty() {
+                existing.data_type = column.data_type;
+            }
+        } else {
+            result.push(column);
+        }
+    }
+    result
+}
+
+fn merge_optional_string(target: &mut Option<String>, candidate: Option<String>) {
+    let Some(candidate) = candidate else {
+        return;
+    };
+    if candidate.trim().is_empty() {
+        if target.is_none() {
+            *target = Some(candidate);
+        }
+        return;
+    }
+    if target.as_ref().is_none_or(|value| value.trim().is_empty()) {
+        *target = Some(candidate);
+    }
+}
+
+pub async fn list_indexes_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::IndexInfo>, String> {
+    if crate::sql_dialect::parse_sqlserver_linked_schema_ref(schema).is_some() {
+        return Ok(vec![]);
+    }
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        let db_config = connection_config(state, connection_id).await;
+
+        {
+            let connections = state.connections.read().await;
+            try_sqlserver!(connections, &pool_key, list_indexes, schema, table);
+            if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+                drop(connections);
+                let mut client = client.lock().await;
+                return client.list_indexes(database, schema, table, agent_metadata_timeout(db_config.as_ref())).await;
+            }
+        }
+
+        let connections = state.connections.read().await;
+        let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+        match pool {
+            PoolKind::Mysql(p, mode) => {
+                if db_config.as_ref().is_some_and(is_manticoresearch_config) {
+                    return db::manticoresearch::list_indexes(p, table).await;
+                }
+                if *mode == MysqlMode::OceanBaseOracle {
+                    db::ob_oracle::list_indexes(p, schema, table).await
+                } else if db_config.as_ref().is_some_and(is_doris_family_config) {
+                    db::mysql::list_doris_family_indexes(p, mysql_table_metadata_catalog(database, schema), table).await
+                } else {
+                    db::mysql::list_indexes(p, mysql_table_metadata_catalog(database, schema), table).await
+                }
+            }
+            PoolKind::Postgres(p) if db_config.as_ref().is_some_and(is_questdb_config) => {
+                db::questdb::list_indexes(p, schema, table).await
+            }
+            PoolKind::Postgres(p) => db::postgres::list_indexes(p, schema, table).await,
+            PoolKind::Sqlite(p) => db::sqlite::list_indexes(p, schema, table).await,
+            PoolKind::Rqlite(client) => db::rqlite_driver::list_indexes(client, schema, table).await,
+            PoolKind::MongoDb(client) => db::mongo_driver::list_indexes(client, database, table).await,
+            PoolKind::CloudflareD1(client) => db::cloudflare_d1_driver::list_indexes(client, schema, table).await,
+            _ => Ok(vec![]),
+        }
+    })
+    .await
+}
+
+pub async fn list_foreign_keys_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::ForeignKeyInfo>, String> {
+    if crate::sql_dialect::parse_sqlserver_linked_schema_ref(schema).is_some() {
+        return Ok(vec![]);
+    }
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        let db_config = connection_config(state, connection_id).await;
+
+        {
+            let connections = state.connections.read().await;
+            try_sqlserver!(connections, &pool_key, list_foreign_keys, schema, table);
+            if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+                drop(connections);
+                let mut client = client.lock().await;
+                return client
+                    .list_foreign_keys(database, schema, table, agent_metadata_timeout(db_config.as_ref()))
+                    .await;
+            }
+        }
+
+        let connections = state.connections.read().await;
+        let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+        match pool {
+            PoolKind::Mysql(p, mode) => {
+                if *mode == MysqlMode::OceanBaseOracle {
+                    db::ob_oracle::list_foreign_keys(p, schema, table).await
+                } else {
+                    db::mysql::list_foreign_keys(p, mysql_table_metadata_catalog(database, schema), table).await
+                }
+            }
+            PoolKind::Postgres(p) => db::postgres::list_foreign_keys(p, schema, table).await,
+            PoolKind::Sqlite(p) => db::sqlite::list_foreign_keys(p, schema, table).await,
+            PoolKind::Rqlite(client) => db::rqlite_driver::list_foreign_keys(client, schema, table).await,
+            PoolKind::CloudflareD1(client) => db::cloudflare_d1_driver::list_foreign_keys(client, schema, table).await,
+            _ => Ok(vec![]),
+        }
+    })
+    .await
+}
+
+pub async fn list_triggers_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::TriggerInfo>, String> {
+    if crate::sql_dialect::parse_sqlserver_linked_schema_ref(schema).is_some() {
+        return Ok(vec![]);
+    }
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        let db_config = connection_config(state, connection_id).await;
+
+        {
+            let connections = state.connections.read().await;
+            try_sqlserver!(connections, &pool_key, list_triggers, schema, table);
+            if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+                drop(connections);
+                let mut client = client.lock().await;
+                return client.list_triggers(database, schema, table, agent_metadata_timeout(db_config.as_ref())).await;
+            }
+        }
+
+        let connections = state.connections.read().await;
+        let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+        match pool {
+            PoolKind::Mysql(p, mode) => {
+                if *mode == MysqlMode::OceanBaseOracle {
+                    db::ob_oracle::list_triggers(p, schema, table).await
+                } else {
+                    db::mysql::list_triggers(p, mysql_table_metadata_catalog(database, schema), table).await
+                }
+            }
+            PoolKind::Postgres(p) => db::postgres::list_triggers(p, schema, table).await,
+            PoolKind::Sqlite(p) => db::sqlite::list_triggers(p, schema, table).await,
+            PoolKind::Rqlite(client) => db::rqlite_driver::list_triggers(client, schema, table).await,
+            PoolKind::CloudflareD1(client) => db::cloudflare_d1_driver::list_triggers(client, schema, table).await,
+            _ => Ok(vec![]),
+        }
+    })
+    .await
+}
+
+pub async fn list_functions_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+) -> Result<Vec<db::FunctionInfo>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        let connections = state.connections.read().await;
+        let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+        match pool {
+            PoolKind::Postgres(p) => db::postgres::list_functions(p, schema).await,
+            _ => Ok(vec![]),
+        }
+    })
+    .await
+}
+
+pub async fn list_sequences_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    with_last_values: bool,
+) -> Result<Vec<db::SequenceInfo>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        let connections = state.connections.read().await;
+        let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+        match pool {
+            PoolKind::Postgres(p) => db::postgres::list_sequences(p, schema, with_last_values).await,
+            _ => Ok(vec![]),
+        }
+    })
+    .await
+}
+
+pub async fn list_rules_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+) -> Result<Vec<db::RuleInfo>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        let connections = state.connections.read().await;
+        let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+        match pool {
+            PoolKind::Postgres(p) => db::postgres::list_rules(p, schema).await,
+            _ => Ok(vec![]),
+        }
+    })
+    .await
+}
+
+pub async fn list_extensions_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+) -> Result<Vec<db::ExtensionInfo>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        let connections = state.connections.read().await;
+        let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+        match pool {
+            PoolKind::Postgres(p) => db::postgres::list_extensions(p, schema).await,
+            _ => Ok(vec![]),
+        }
+    })
+    .await
+}
+
+pub async fn list_available_extensions_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+) -> Result<Vec<db::ExtensionInfo>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        let connections = state.connections.read().await;
+        let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+        match pool {
+            PoolKind::Postgres(p) => db::postgres::list_available_extensions(p).await,
+            _ => Ok(vec![]),
+        }
+    })
+    .await
+}
+
+pub async fn list_owners_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+) -> Result<Vec<db::OwnerInfo>, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || async {
+        let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+        let connections = state.connections.read().await;
+        let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+        match pool {
+            PoolKind::Postgres(p) => db::postgres::list_owners(p, schema).await,
+            _ => Ok(vec![]),
+        }
+    })
+    .await
+}
+
+pub async fn get_table_ddl_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    table: &str,
+    object_type: Option<db::ObjectSourceKind>,
+) -> Result<String, String> {
+    if crate::sql_dialect::parse_sqlserver_linked_schema_ref(schema).is_some() {
+        return Err("DDL is not supported for SQL Server linked server tables".to_string());
+    }
+    if matches!(object_type, Some(db::ObjectSourceKind::View)) {
+        let source =
+            get_object_source_core(state, connection_id, database, schema, table, db::ObjectSourceKind::View, None)
+                .await?;
+        let database_type = connection_config(state, connection_id).await.map(|config| config.db_type);
+        return Ok(crate::object_source_sql::build_view_ddl_sql(crate::object_source_sql::BuildViewDdlInput {
+            database_type,
+            schema: if schema.trim().is_empty() { None } else { Some(schema.to_string()) },
+            name: table.to_string(),
+            source: source.source,
+        }));
+    }
+    if matches!(object_type, Some(db::ObjectSourceKind::MaterializedView)) {
+        let source = get_object_source_core(
+            state,
+            connection_id,
+            database,
+            schema,
+            table,
+            db::ObjectSourceKind::MaterializedView,
+            None,
+        )
+        .await?;
+        return Ok(source.source);
+    }
+
+    let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+    let db_config = connection_config(state, connection_id).await;
+
+    {
+        let connections = state.connections.read().await;
+        #[cfg(feature = "duckdb-bundled")]
+        if let Some(con) = extract_pool!(&connections, &pool_key, DuckDb) {
+            drop(connections);
+            let tbl = table.replace('\'', "''");
+            let con = con.lock().map_err(|e| e.to_string())?;
+            let mut stmt = con
+                .prepare(&format!("SELECT sql FROM duckdb_tables() WHERE table_name = '{tbl}'"))
+                .map_err(|e| e.to_string())?;
+            let mut rows = stmt.query([]).map_err(|e| e.to_string())?;
+            if let Some(row) = rows.next().map_err(|e| e.to_string())? {
+                return row.get::<_, String>(0).map_err(|e| e.to_string());
+            }
+            return Err("Table not found".to_string());
+        }
+        if let Some(client) = extract_pool!(&connections, &pool_key, ClickHouse) {
+            drop(connections);
+            let clickhouse_database = clickhouse_metadata_database(database, schema);
+            let result = db::clickhouse_driver::execute_query(
+                &client,
+                clickhouse_database,
+                &format!("SHOW CREATE TABLE `{table}`"),
+            )
+            .await?;
+            return result
+                .rows
+                .first()
+                .and_then(|r| r.first())
+                .and_then(|v| v.as_str())
+                .map(|s| s.to_string())
+                .ok_or_else(|| "Table not found".to_string());
+        }
+        if let Some(client) = extract_pool!(&connections, &pool_key, SqlServer) {
+            drop(connections);
+            let mut client = client.lock().await;
+            return build_sqlserver_ddl(&mut client, schema, table).await;
+        }
+        if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+            drop(connections);
+            if let Some(config) = db_config.as_ref().filter(|config| is_agent_postgres_metadata_fallback_config(config))
+            {
+                match native_postgres_metadata_pool(state, connection_id, database, config).await {
+                    Ok(Some(pool)) => match pg_ddl(&pool, schema, table).await {
+                        Ok(ddl) => return Ok(ddl),
+                        Err(error) => {
+                            log::warn!(
+                                "[schema][agent:get_table_ddl:postgres-compatible-native-fallback-failed] connection_id={} database={} schema={} table={} error={}",
+                                connection_id,
+                                database,
+                                schema,
+                                table,
+                                error
+                            );
+                        }
+                    },
+                    Ok(None) => {}
+                    Err(error) => {
+                        log::warn!(
+                            "[schema][agent:get_table_ddl:postgres-compatible-native-pool-failed] connection_id={} database={} schema={} table={} error={}",
+                            connection_id,
+                            database,
+                            schema,
+                            table,
+                            error
+                        );
+                    }
+                }
+            }
+            if db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::Oracle) {
+                return oracle_agent_table_ddl(
+                    client,
+                    database,
+                    schema,
+                    table,
+                    agent_metadata_timeout(db_config.as_ref()),
+                )
+                .await;
+            }
+            if db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::Db2) {
+                return db2_agent_table_ddl(
+                    client,
+                    database,
+                    schema,
+                    table,
+                    agent_metadata_timeout(db_config.as_ref()),
+                )
+                .await;
+            }
+            let mut client = client.lock().await;
+            return client.get_table_ddl(database, schema, table, agent_metadata_timeout(db_config.as_ref())).await;
+        }
+    }
+
+    let connections = state.connections.read().await;
+    let pool = connections.get(&pool_key).ok_or("Pool not found")?;
+
+    match pool {
+        PoolKind::Mysql(p, _) => mysql_ddl(p, mysql_table_metadata_catalog(database, schema), table).await,
+        PoolKind::Postgres(p) if db_config.as_ref().is_some_and(is_opengauss_family_config) => {
+            match opengauss_table_ddl(p, schema, table).await {
+                Ok(ddl) => Ok(ddl),
+                Err(_) => pg_ddl(p, schema, table).await,
+            }
+        }
+        PoolKind::Postgres(p) if db_config.as_ref().is_some_and(is_questdb_config) => {
+            match db::questdb::questdb_table_or_view_ddl(p, table).await {
+                Ok(ddl) => Ok(ddl),
+                Err(_) => pg_ddl(p, schema, table).await,
+            }
+        }
+        PoolKind::Postgres(p) => pg_ddl(p, schema, table).await,
+        PoolKind::Sqlite(p) => sqlite_ddl(p, table).await,
+        PoolKind::Rqlite(client) => db::rqlite_driver::table_ddl(client, table).await,
+        PoolKind::CloudflareD1(client) => db::cloudflare_d1_driver::table_ddl(client, table).await,
+        _ => Err("DDL not supported for this database type".to_string()),
+    }
+}
+
+async fn connection_config(state: &AppState, connection_id: &str) -> Option<ConnectionConfig> {
+    state.configs.read().await.get(connection_id).cloned()
+}
+
+fn is_opengauss_family_config(config: &ConnectionConfig) -> bool {
+    matches!(config.db_type, DatabaseType::OpenGauss | DatabaseType::Gaussdb)
+        || matches!(config.driver_profile.as_deref(), Some("opengauss" | "gaussdb"))
+}
+
+fn is_default_oracle_agent_config(config: &ConnectionConfig) -> bool {
+    // Only the default go-oracle agent handles filtered/paged metadata; legacy profiles keep Rust fallback paging.
+    matches!(config.db_type, DatabaseType::Oracle)
+        && !matches!(config.driver_profile.as_deref(), Some("oracle-legacy" | "oracle-10g"))
+}
+
+fn oracle_agent_paging_likely_applied(enabled: bool, limit: Option<usize>, returned_len: usize) -> bool {
+    enabled && limit.is_some_and(|limit| returned_len <= limit)
+}
+
+fn is_doris_family_config(config: &ConnectionConfig) -> bool {
+    matches!(config.db_type, DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::ManticoreSearch)
+        || matches!(config.driver_profile.as_deref(), Some("doris" | "selectdb" | "starrocks" | "manticoresearch"))
+}
+
+/// Doris-family engines that support multi-catalog federation (`SHOW CATALOGS`).
+/// Manticore Search is excluded — it shares the MySQL code path but has no
+/// catalog concept.
+pub fn is_doris_family_catalog_capable_config(config: &ConnectionConfig) -> bool {
+    matches!(config.db_type, DatabaseType::Doris | DatabaseType::StarRocks)
+        || matches!(config.driver_profile.as_deref(), Some("doris" | "selectdb" | "starrocks"))
+}
+
+fn is_manticoresearch_config(config: &ConnectionConfig) -> bool {
+    matches!(config.db_type, DatabaseType::ManticoreSearch)
+        || matches!(config.driver_profile.as_deref(), Some("manticoresearch"))
+}
+
+fn mysql_show_metadata_database_for_config<'a>(config: Option<&ConnectionConfig>, database: &'a str) -> &'a str {
+    if config.is_some_and(is_manticoresearch_config) {
+        ""
+    } else {
+        database
+    }
+}
+
+fn filter_mysql_system_databases_for_config(
+    databases: Vec<db::DatabaseInfo>,
+    config: Option<&ConnectionConfig>,
+) -> Vec<db::DatabaseInfo> {
+    if !config.is_some_and(is_manticoresearch_config) {
+        return databases;
+    }
+
+    databases.into_iter().filter(|database| !is_mysql_system_database(&database.name)).collect()
+}
+
+fn is_mysql_system_database(name: &str) -> bool {
+    matches!(name.to_ascii_lowercase().as_str(), "information_schema" | "mysql" | "performance_schema" | "sys")
+}
+
+fn is_questdb_config(config: &ConnectionConfig) -> bool {
+    matches!(config.db_type, DatabaseType::Questdb) || matches!(config.driver_profile.as_deref(), Some("questdb"))
+}
+
+fn sql_string(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+fn pg_ident(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+fn sqlserver_ident(value: &str) -> String {
+    format!("[{}]", value.replace(']', "]]"))
+}
+
+fn sqlserver_n_string(value: &str) -> String {
+    format!("N'{}'", value.replace('\'', "''"))
+}
+
+fn oracle_ident(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+fn mysql_ident(value: &str) -> String {
+    format!("`{}`", value.replace('`', "``"))
+}
+
+fn mysql_qualified_name(database: &str, name: &str) -> String {
+    if database.trim().is_empty() {
+        mysql_ident(name)
+    } else {
+        format!("{}.{}", mysql_ident(database), mysql_ident(name))
+    }
+}
+
+fn sqlite_object_type(kind: &db::ObjectSourceKind) -> &'static str {
+    match kind {
+        db::ObjectSourceKind::View | db::ObjectSourceKind::MaterializedView => "view",
+        db::ObjectSourceKind::Procedure
+        | db::ObjectSourceKind::Function
+        | db::ObjectSourceKind::Sequence
+        | db::ObjectSourceKind::Package
+        | db::ObjectSourceKind::PackageBody => "routine",
+    }
+}
+
+fn sqlserver_object_type_filter(kind: &db::ObjectSourceKind) -> &'static str {
+    match kind {
+        db::ObjectSourceKind::View => "'V'",
+        db::ObjectSourceKind::Procedure => "'P'",
+        db::ObjectSourceKind::Function => "'FN','IF','TF','FS','FT'",
+        db::ObjectSourceKind::Sequence
+        | db::ObjectSourceKind::Package
+        | db::ObjectSourceKind::PackageBody
+        | db::ObjectSourceKind::MaterializedView => "''",
+    }
+}
+
+pub fn sqlserver_object_source_sql(schema: &str, name: &str, kind: &db::ObjectSourceKind) -> String {
+    format!(
+        "SELECT m.definition FROM sys.sql_modules m \
+         JOIN sys.objects o ON o.object_id = m.object_id \
+         JOIN sys.schemas s ON s.schema_id = o.schema_id \
+         WHERE s.name = {} AND o.name = {} AND o.type IN ({})",
+        sql_string(schema),
+        sql_string(name),
+        sqlserver_object_type_filter(kind)
+    )
+}
+
+pub fn postgres_object_source_sql(
+    schema: &str,
+    name: &str,
+    kind: &db::ObjectSourceKind,
+    signature: Option<&str>,
+) -> String {
+    postgres_object_source_sql_inner(schema, name, kind, signature, true)
+}
+
+fn postgres_object_source_sql_without_relispopulated(
+    schema: &str,
+    name: &str,
+    kind: &db::ObjectSourceKind,
+    signature: Option<&str>,
+) -> String {
+    postgres_object_source_sql_inner(schema, name, kind, signature, false)
+}
+
+fn postgres_function_object_source_sql_without_prokind(schema: &str, name: &str) -> String {
+    format!(
+        "SELECT pg_get_functiondef(p.oid) \
+         FROM pg_proc p \
+         JOIN pg_namespace n ON n.oid = p.pronamespace \
+         WHERE n.nspname = {} AND p.proname = {} AND NOT p.proisagg AND NOT p.proiswindow \
+         ORDER BY p.oid LIMIT 1",
+        sql_string(schema),
+        sql_string(name)
+    )
+}
+
+fn postgres_object_source_sql_inner(
+    schema: &str,
+    name: &str,
+    kind: &db::ObjectSourceKind,
+    signature: Option<&str>,
+    include_relispopulated: bool,
+) -> String {
+    match kind {
+        db::ObjectSourceKind::View | db::ObjectSourceKind::MaterializedView => {
+            let materialized_populated_clause = if include_relispopulated {
+                " || CASE WHEN c.relispopulated THEN ' WITH DATA' ELSE ' WITH NO DATA' END"
+            } else {
+                ""
+            };
+            let materialized_viewdef = "regexp_replace(pg_get_viewdef(c.oid, 0), ';[[:space:]]*$', '')";
+            let materialized_source_expr = format!(
+                "CASE WHEN {materialized_viewdef} ~* '^[[:space:]]*CREATE[[:space:]]+(OR[[:space:]]+REPLACE[[:space:]]+)?MATERIALIZED[[:space:]]+VIEW[[:space:]]+' \
+                 THEN {materialized_viewdef} \
+                 ELSE format('CREATE MATERIALIZED VIEW %I.%I AS ', n.nspname, c.relname) || {materialized_viewdef}{materialized_populated_clause} \
+                 END"
+            );
+            format!(
+                "SELECT CASE WHEN c.relkind = 'm' THEN {} \
+                 ELSE format('CREATE OR REPLACE VIEW %I.%I AS ', n.nspname, c.relname) || pg_get_viewdef(c.oid, 0) \
+                 END \
+                 FROM pg_catalog.pg_class c \
+                 JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+                 WHERE n.nspname = {} AND c.relname = {} AND c.relkind IN ('v','m') \
+                 ORDER BY c.oid LIMIT 1",
+                materialized_source_expr,
+                sql_string(schema),
+                sql_string(name)
+            )
+        }
+        db::ObjectSourceKind::Procedure | db::ObjectSourceKind::Function => {
+            let prokind = if matches!(kind, db::ObjectSourceKind::Procedure) { "p" } else { "f" };
+            let signature_filter = signature
+                .map(|value| format!(" AND pg_get_function_identity_arguments(p.oid) = {}", sql_string(value)))
+                .unwrap_or_default();
+            format!(
+                "SELECT pg_get_functiondef(p.oid) \
+                 FROM pg_proc p \
+                 JOIN pg_namespace n ON n.oid = p.pronamespace \
+                 WHERE n.nspname = {} AND p.proname = {} AND p.prokind = '{}'{} \
+                 ORDER BY p.oid LIMIT 1",
+                sql_string(schema),
+                sql_string(name),
+                prokind,
+                signature_filter
+            )
+        }
+        db::ObjectSourceKind::Sequence => {
+            format!(
+                "SELECT concat_ws(E'\\n\\n', \
+                   '-- auto-generated definition' || E'\\n' || \
+                   'create sequence ' || quote_ident(c.relname) || E'\\n' || \
+                   '    as ' || pg_catalog.format_type(s.seqtypid, NULL) || ';', \
+                   'alter sequence ' || quote_ident(c.relname) || ' owner to ' || quote_ident(pg_get_userbyid(c.relowner)) || ';', \
+                   CASE WHEN owned.relname IS NOT NULL AND a.attname IS NOT NULL \
+                     THEN 'alter sequence ' || quote_ident(c.relname) || ' owned by ' || quote_ident(owned.relname) || '.' || quote_ident(a.attname) || ';' \
+                   END \
+                 ) \
+                 FROM pg_catalog.pg_class c \
+                 JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+                 JOIN pg_catalog.pg_sequence s ON s.seqrelid = c.oid \
+                 LEFT JOIN pg_catalog.pg_depend d \
+                   ON d.classid = 'pg_class'::regclass AND d.objid = c.oid AND d.deptype = 'a' \
+                 LEFT JOIN pg_catalog.pg_class owned ON owned.oid = d.refobjid \
+                 LEFT JOIN pg_catalog.pg_attribute a ON a.attrelid = d.refobjid AND a.attnum = d.refobjsubid \
+                 WHERE n.nspname = {} AND c.relname = {} AND c.relkind = 'S' \
+                 ORDER BY c.oid LIMIT 1",
+                sql_string(schema),
+                sql_string(name)
+            )
+        }
+        db::ObjectSourceKind::Package | db::ObjectSourceKind::PackageBody => "SELECT NULL WHERE FALSE".to_string(),
+    }
+}
+
+pub fn oracle_object_source_sql(schema: &str, name: &str, kind: &db::ObjectSourceKind) -> String {
+    let object_type = match kind {
+        db::ObjectSourceKind::View => "VIEW",
+        db::ObjectSourceKind::MaterializedView => "MATERIALIZED_VIEW",
+        db::ObjectSourceKind::Procedure => "PROCEDURE",
+        db::ObjectSourceKind::Function => "FUNCTION",
+        db::ObjectSourceKind::Sequence => "SEQUENCE",
+        db::ObjectSourceKind::Package => "PACKAGE",
+        db::ObjectSourceKind::PackageBody => "PACKAGE_BODY",
+    };
+    if schema.trim().is_empty() {
+        format!("SELECT DBMS_METADATA.GET_DDL({}, {}) FROM DUAL", sql_string(object_type), sql_string(name))
+    } else {
+        format!(
+            "SELECT DBMS_METADATA.GET_DDL({}, {}, {}) FROM DUAL",
+            sql_string(object_type),
+            sql_string(name),
+            sql_string(schema)
+        )
+    }
+}
+
+pub fn sqlite_object_source_sql(name: &str, kind: &db::ObjectSourceKind) -> String {
+    format!(
+        "SELECT sql FROM sqlite_master WHERE type = {} AND name = {}",
+        sql_string(sqlite_object_type(kind)),
+        sql_string(name)
+    )
+}
+
+pub fn mysql_object_source_sql(database: &str, name: &str, kind: &db::ObjectSourceKind) -> String {
+    let qualified_name = mysql_qualified_name(database, name);
+    match kind {
+        db::ObjectSourceKind::View => format!("SHOW CREATE VIEW {qualified_name}"),
+        db::ObjectSourceKind::Procedure => format!("SHOW CREATE PROCEDURE {qualified_name}"),
+        db::ObjectSourceKind::Function => format!("SHOW CREATE FUNCTION {qualified_name}"),
+        db::ObjectSourceKind::Sequence
+        | db::ObjectSourceKind::Package
+        | db::ObjectSourceKind::PackageBody
+        | db::ObjectSourceKind::MaterializedView => String::new(),
+    }
+}
+
+pub fn postgres_view_source_fallback_sql(schema: &str, name: &str) -> String {
+    format!(
+        "SELECT definition \
+         FROM pg_catalog.pg_views \
+         WHERE schemaname = {} AND viewname = {} \
+         LIMIT 1",
+        sql_string(schema),
+        sql_string(name)
+    )
+}
+
+fn first_string_cell(result: db::QueryResult) -> Result<String, String> {
+    result
+        .rows
+        .first()
+        .and_then(|row| row.iter().find_map(|value| value.as_str().map(str::to_string)))
+        .filter(|value| !value.trim().is_empty())
+        .ok_or_else(|| "Object source not found".to_string())
+}
+
+async fn mysql_object_source(
+    pool: &db::mysql::MySqlPool,
+    database: &str,
+    name: &str,
+    kind: &db::ObjectSourceKind,
+) -> Result<String, String> {
+    use mysql_async::prelude::*;
+    let sql = mysql_object_source_sql(database, name, kind);
+    let mut conn = db::mysql::get_conn_with_timeout(pool, db::connection_timeout()).await?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    let row = rows.first().ok_or("Object source not found")?;
+    let index = if matches!(kind, db::ObjectSourceKind::View) { 1 } else { 2 };
+    row.get_opt::<String, usize>(index)
+        .and_then(|result| result.ok())
+        .or_else(|| {
+            row.get_opt::<Vec<u8>, usize>(index)
+                .and_then(|result| result.ok())
+                .map(|b| String::from_utf8_lossy(&b).to_string())
+        })
+        .ok_or_else(|| "Failed to read object source".to_string())
+}
+
+pub async fn get_object_source_core(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    name: &str,
+    object_type: db::ObjectSourceKind,
+    signature: Option<&str>,
+) -> Result<db::ObjectSource, String> {
+    retry_metadata_connection(state, connection_id, Some(database), || {
+        get_object_source_once(state, connection_id, database, schema, name, object_type.clone(), signature)
+    })
+    .await
+}
+
+async fn get_object_source_once(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    name: &str,
+    object_type: db::ObjectSourceKind,
+    signature: Option<&str>,
+) -> Result<db::ObjectSource, String> {
+    let pool_key = state.get_or_create_pool(connection_id, Some(database)).await?;
+    let db_config = connection_config(state, connection_id).await;
+    let source = {
+        let connections = state.connections.read().await;
+        if let Some(PoolKind::ExternalDriver { config, session, .. }) = connections.get(&pool_key) {
+            let config = config.clone();
+            let session = session.clone();
+            drop(connections);
+            let result: db::ObjectSource = session
+                .invoke_with_timeout(
+                    "getObjectSource",
+                    serde_json::json!({
+                        "connection": config.as_ref(),
+                        "database": database,
+                        "schema": schema,
+                        "name": name,
+                        "object_type": &object_type,
+                    }),
+                    agent_metadata_timeout(Some(config.as_ref())),
+                )
+                .await?;
+            return Ok(result);
+        }
+        if let Some(client) = extract_pool!(&connections, &pool_key, SqlServer) {
+            drop(connections);
+            let mut client = client.lock().await;
+            let result =
+                db::sqlserver::execute_query(&mut client, &sqlserver_object_source_sql(schema, name, &object_type))
+                    .await;
+            drop(client);
+            if matches!(result.as_ref(), Err(err) if should_discard_pool_after_error(Some(DatabaseType::SqlServer), err))
+            {
+                state.remove_pool_by_key(&pool_key).await;
+            }
+            first_string_cell(result?)?
+        } else if let Some(client) = extract_pool!(&connections, &pool_key, Agent) {
+            drop(connections);
+            if db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::Oracle)
+                && matches!(object_type, db::ObjectSourceKind::Package | db::ObjectSourceKind::PackageBody)
+            {
+                oracle_agent_object_source(
+                    client,
+                    database,
+                    schema,
+                    name,
+                    &object_type,
+                    agent_metadata_timeout(db_config.as_ref()),
+                )
+                .await?
+            } else {
+                let mut client = client.lock().await;
+                let result: db::ObjectSource = client
+                    .get_object_source(database, schema, name, &object_type, agent_metadata_timeout(db_config.as_ref()))
+                    .await?;
+                return Ok(result);
+            }
+        } else {
+            match connections.get(&pool_key).ok_or("Pool not found")? {
+                PoolKind::Mysql(pool, _) => {
+                    mysql_object_source(pool, mysql_table_metadata_catalog(database, schema), name, &object_type)
+                        .await?
+                }
+                PoolKind::Postgres(pool) if db_config.as_ref().is_some_and(is_questdb_config) => {
+                    // only view
+                    db::questdb::questdb_object_source(pool, name).await?
+                }
+                PoolKind::Postgres(pool) => postgres_object_source(pool, schema, name, &object_type, signature).await?,
+                PoolKind::Sqlite(pool) => first_string_cell(
+                    db::sqlite::execute_query(pool, &sqlite_object_source_sql(name, &object_type)).await?,
+                )?,
+                PoolKind::Rqlite(client) => {
+                    return db::rqlite_driver::object_source(client, name, &object_type).await;
+                }
+                PoolKind::ClickHouse(client) if matches!(object_type, db::ObjectSourceKind::View) => {
+                    let result = db::clickhouse_driver::execute_query(
+                        client,
+                        database,
+                        &format!("SHOW CREATE TABLE {}", mysql_ident(name)),
+                    )
+                    .await?;
+                    first_string_cell(result)?
+                }
+                PoolKind::CloudflareD1(client) => {
+                    return db::cloudflare_d1_driver::object_source(client, name, &object_type).await;
+                }
+                _ => return Err("Object source is not supported for this database type".to_string()),
+            }
+        }
+    };
+
+    Ok(db::ObjectSource {
+        name: name.to_string(),
+        object_type,
+        schema: if schema.is_empty() { None } else { Some(schema.to_string()) },
+        source,
+        editable: None,
+    })
+}
+
+fn oracle_owner_filter(schema: &str) -> String {
+    let schema = schema.trim();
+    if schema.is_empty() {
+        "USER".to_string()
+    } else {
+        sql_string(&schema.to_uppercase())
+    }
+}
+
+pub fn oracle_list_objects_sql(schema: &str) -> String {
+    format!(
+        "SELECT object_name, CASE object_type WHEN 'PACKAGE BODY' THEN 'PACKAGE_BODY' ELSE object_type END AS object_type, owner \
+         FROM all_objects \
+         WHERE owner = {} AND object_type IN ('TABLE', 'VIEW', 'PROCEDURE', 'FUNCTION', 'PACKAGE', 'PACKAGE BODY') \
+         ORDER BY CASE object_type WHEN 'TABLE' THEN 0 WHEN 'VIEW' THEN 1 WHEN 'PROCEDURE' THEN 2 WHEN 'FUNCTION' THEN 3 WHEN 'PACKAGE' THEN 4 ELSE 5 END, object_name",
+        oracle_owner_filter(schema)
+    )
+}
+
+async fn oracle_agent_list_objects(
+    client: Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>,
+    database: &str,
+    schema: &str,
+    timeout_duration: Option<Duration>,
+) -> Result<Vec<db::ObjectInfo>, String> {
+    let sql = oracle_list_objects_sql(schema);
+    let params = agent_execute_query_params(
+        &sql,
+        if database.is_empty() { None } else { Some(database) },
+        if schema.is_empty() { None } else { Some(schema) },
+        QueryExecutionOptions { max_rows: Some(10_000), ..Default::default() },
+    );
+    let mut client = client.lock().await;
+    let result: db::QueryResult = client.execute_query_with_timeout(params, timeout_duration).await?;
+    let mut objects: Vec<db::ObjectInfo> = result
+        .rows
+        .into_iter()
+        .filter_map(|row| {
+            let name = row.first()?.as_str()?.to_string();
+            let object_type = row.get(1)?.as_str()?.to_string();
+            let schema = row.get(2).and_then(|value| value.as_str()).map(str::to_string);
+            Some(db::ObjectInfo {
+                name,
+                object_type,
+                schema,
+                signature: None,
+                comment: None,
+                created_at: None,
+                updated_at: None,
+                parent_schema: None,
+                parent_name: None,
+            })
+        })
+        .collect();
+    load_oracle_table_comments_for_objects(&mut client, database, schema, &mut objects, timeout_duration).await?;
+    Ok(objects)
+}
+
+async fn oracle_agent_object_source(
+    client: Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>,
+    database: &str,
+    schema: &str,
+    name: &str,
+    object_type: &db::ObjectSourceKind,
+    timeout_duration: Option<Duration>,
+) -> Result<String, String> {
+    let sql = oracle_object_source_sql(schema, name, object_type);
+    let params = agent_execute_query_params(
+        &sql,
+        if database.is_empty() { None } else { Some(database) },
+        if schema.is_empty() { None } else { Some(schema) },
+        QueryExecutionOptions { max_rows: Some(1), ..Default::default() },
+    );
+    let mut client = client.lock().await;
+    let result: db::QueryResult = client.execute_query_with_timeout(params, timeout_duration).await?;
+    first_string_cell(result)
+}
+
+async fn oracle_agent_table_ddl(
+    client: Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>,
+    database: &str,
+    schema: &str,
+    table: &str,
+    timeout_duration: Option<Duration>,
+) -> Result<String, String> {
+    let mut client = client.lock().await;
+    let ddl = client.get_table_ddl::<String>(database, schema, table, timeout_duration).await?;
+    match append_oracle_table_comment_ddl(&mut client, database, schema, table, &ddl, timeout_duration).await {
+        Ok(ddl) => Ok(ddl),
+        Err(error) => {
+            log::debug!(
+                "[schema][oracle:get_table_ddl:comments-fallback-failed] schema={} table={} error={}",
+                schema,
+                table,
+                error
+            );
+            Ok(ddl)
+        }
+    }
+}
+
+async fn append_oracle_table_comment_ddl(
+    client: &mut db::agent_driver::AgentDriverClient,
+    database: &str,
+    schema: &str,
+    table: &str,
+    ddl: &str,
+    timeout_duration: Option<Duration>,
+) -> Result<String, String> {
+    let table_comment =
+        oracle_table_comments_for_names(client, database, schema, &[table.to_string()], timeout_duration)
+            .await?
+            .into_iter()
+            .find(|(name, _)| name.eq_ignore_ascii_case(table))
+            .map(|(_, comment)| comment);
+    let columns =
+        client.get_columns::<Vec<db::ColumnInfo>>(database, schema, table, timeout_duration).await.unwrap_or_default();
+    Ok(append_oracle_comments_to_ddl(ddl, schema, table, table_comment.as_deref(), &columns))
+}
+
+fn append_oracle_comments_to_ddl(
+    ddl: &str,
+    schema: &str,
+    table: &str,
+    table_comment: Option<&str>,
+    columns: &[db::ColumnInfo],
+) -> String {
+    let mut result = ddl.trim_end().trim_end_matches(';').to_string();
+    if result.trim().is_empty() {
+        return result;
+    }
+    result.push(';');
+    let existing_ddl_upper = ddl.to_ascii_uppercase();
+
+    let table_ref = if schema.trim().is_empty() {
+        oracle_ident(table)
+    } else {
+        format!("{}.{}", oracle_ident(schema), oracle_ident(table))
+    };
+
+    if !existing_ddl_upper.contains("COMMENT ON TABLE") {
+        if let Some(comment) = table_comment.map(str::trim).filter(|comment| !comment.is_empty()) {
+            result.push_str(&format!("\nCOMMENT ON TABLE {table_ref} IS {};", sql_string(comment)));
+        }
+    }
+    if !existing_ddl_upper.contains("COMMENT ON COLUMN") {
+        for column in columns {
+            if let Some(comment) = column.comment.as_deref().map(str::trim).filter(|comment| !comment.is_empty()) {
+                result.push_str(&format!(
+                    "\nCOMMENT ON COLUMN {table_ref}.{} IS {};",
+                    oracle_ident(&column.name),
+                    sql_string(comment)
+                ));
+            }
+        }
+    }
+    result
+}
+
+async fn db2_agent_table_ddl(
+    client: Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>,
+    database: &str,
+    schema: &str,
+    table: &str,
+    timeout_duration: Option<Duration>,
+) -> Result<String, String> {
+    let mut client = client.lock().await;
+    let ddl = client.get_table_ddl::<String>(database, schema, table, timeout_duration).await?;
+    match append_db2_comments_to_ddl(&mut client, database, schema, table, &ddl, timeout_duration).await {
+        Ok(ddl) => Ok(ddl),
+        Err(error) => {
+            log::debug!(
+                "[schema][db2:get_table_ddl:comments-fallback-failed] schema={} table={} error={}",
+                schema,
+                table,
+                error
+            );
+            Ok(ddl)
+        }
+    }
+}
+
+async fn append_db2_comments_to_ddl(
+    client: &mut db::agent_driver::AgentDriverClient,
+    database: &str,
+    schema: &str,
+    table: &str,
+    ddl: &str,
+    timeout_duration: Option<Duration>,
+) -> Result<String, String> {
+    let table_comment = db2_table_comment(client, database, schema, table, timeout_duration).await;
+    let column_comments = db2_column_comments(client, database, schema, table, timeout_duration).await;
+    let mut columns =
+        client.get_columns::<Vec<db::ColumnInfo>>(database, schema, table, timeout_duration).await.unwrap_or_default();
+    if !column_comments.is_empty() {
+        for column in &mut columns {
+            if column.comment.as_deref().is_none_or(|c| c.trim().is_empty() || c.trim().eq_ignore_ascii_case("null")) {
+                if let Some(remark) = column_comments.get(&column.name.to_uppercase()) {
+                    column.comment = Some(remark.clone());
+                }
+            }
+        }
+    }
+    Ok(append_oracle_comments_to_ddl(ddl, schema, table, table_comment.as_deref(), &columns))
+}
+
+async fn db2_table_comment(
+    client: &mut db::agent_driver::AgentDriverClient,
+    database: &str,
+    schema: &str,
+    table: &str,
+    timeout_duration: Option<Duration>,
+) -> Option<String> {
+    // 优先使用原始值查询，支持 quoted/mixed-case 对象；如果查不到再 fallback 到大写
+    for (schema_name, table_name) in
+        [(schema.trim(), table.trim()), (&schema.trim().to_uppercase(), &table.trim().to_uppercase())]
+    {
+        let schema_filter = if schema_name.is_empty() { "CURRENT SCHEMA".to_string() } else { sql_string(schema_name) };
+        let sql = format!(
+            "SELECT REMARKS FROM SYSCAT.TABLES WHERE TABSCHEMA = {} AND TABNAME = {} AND REMARKS IS NOT NULL",
+            schema_filter,
+            sql_string(table_name),
+        );
+        if let Ok(result) = client
+            .execute_query_with_timeout::<db::QueryResult>(
+                agent_execute_query_params(
+                    &sql,
+                    if database.is_empty() { None } else { Some(database) },
+                    if schema.is_empty() { None } else { Some(schema) },
+                    QueryExecutionOptions { max_rows: Some(1), ..Default::default() },
+                ),
+                timeout_duration,
+            )
+            .await
+        {
+            if let Some(comment) =
+                result.rows.first().and_then(|row| row.first()).and_then(|v| v.as_str()).map(|s| s.to_string())
+            {
+                return Some(comment);
+            }
+        }
+    }
+    None
+}
+
+async fn db2_column_comments(
+    client: &mut db::agent_driver::AgentDriverClient,
+    database: &str,
+    schema: &str,
+    table: &str,
+    timeout_duration: Option<Duration>,
+) -> HashMap<String, String> {
+    // 优先使用原始值查询，支持 quoted/mixed-case 对象；如果查不到再 fallback 到大写
+    let mut comments = HashMap::new();
+    for (schema_name, table_name) in
+        [(schema.trim(), table.trim()), (&schema.trim().to_uppercase(), &table.trim().to_uppercase())]
+    {
+        let schema_filter = if schema_name.is_empty() { "CURRENT SCHEMA".to_string() } else { sql_string(schema_name) };
+        let sql = format!(
+            "SELECT COLNAME, REMARKS FROM SYSCAT.COLUMNS WHERE TABSCHEMA = {} AND TABNAME = {} AND REMARKS IS NOT NULL",
+            schema_filter,
+            sql_string(table_name),
+        );
+        let result = match client
+            .execute_query_with_timeout::<db::QueryResult>(
+                agent_execute_query_params(
+                    &sql,
+                    if database.is_empty() { None } else { Some(database) },
+                    if schema.is_empty() { None } else { Some(schema) },
+                    QueryExecutionOptions { ..Default::default() },
+                ),
+                timeout_duration,
+            )
+            .await
+        {
+            Ok(result) => result,
+            Err(_) => continue,
+        };
+        for row in &result.rows {
+            let col_name = row.first().and_then(|v| v.as_str()).unwrap_or("").trim();
+            let remark = row.get(1).and_then(|v| v.as_str()).unwrap_or("").trim();
+            if !col_name.is_empty() && !remark.is_empty() {
+                comments.entry(col_name.to_uppercase()).or_insert_with(|| remark.to_string());
+            }
+        }
+        if !comments.is_empty() {
+            break;
+        }
+    }
+    comments
+}
+
+async fn postgres_object_source(
+    pool: &deadpool_postgres::Pool,
+    schema: &str,
+    name: &str,
+    object_type: &db::ObjectSourceKind,
+    signature: Option<&str>,
+) -> Result<String, String> {
+    let sql = postgres_object_source_sql(schema, name, object_type, signature);
+    match db::postgres::execute_query(pool, &sql).await.and_then(first_string_cell) {
+        Ok(source) => Ok(source),
+        Err(primary_err)
+            if postgres_missing_relispopulated_error(&primary_err)
+                && matches!(object_type, db::ObjectSourceKind::View | db::ObjectSourceKind::MaterializedView) =>
+        {
+            let fallback_sql = postgres_object_source_sql_without_relispopulated(schema, name, object_type, signature);
+            db::postgres::execute_query(pool, &fallback_sql)
+                .await
+                .and_then(first_string_cell)
+                .map_err(|fallback_err| format!("{primary_err}; relispopulated fallback failed: {fallback_err}"))
+        }
+        Err(primary_err)
+            if postgres_missing_prokind_error(&primary_err)
+                && matches!(object_type, db::ObjectSourceKind::Function) =>
+        {
+            let fallback_sql = postgres_function_object_source_sql_without_prokind(schema, name);
+            db::postgres::execute_query(pool, &fallback_sql)
+                .await
+                .and_then(first_string_cell)
+                .map_err(|fallback_err| format!("{primary_err}; prokind fallback failed: {fallback_err}"))
+        }
+        Err(primary_err) if matches!(object_type, db::ObjectSourceKind::View) => {
+            let fallback_sql = postgres_view_source_fallback_sql(schema, name);
+            db::postgres::execute_query(pool, &fallback_sql)
+                .await
+                .and_then(first_string_cell)
+                .map_err(|fallback_err| format!("{primary_err}; fallback failed: {fallback_err}"))
+        }
+        Err(err) => Err(err),
+    }
+}
+
+fn postgres_missing_prokind_error(err: &str) -> bool {
+    let lower = err.to_ascii_lowercase();
+    lower.contains("does not exist")
+        && (lower.contains("column p.prokind")
+            || lower.contains("column \"p\".\"prokind\"")
+            || lower.contains("column \"prokind\""))
+}
+
+fn postgres_missing_relispopulated_error(err: &str) -> bool {
+    let lower = err.to_ascii_lowercase();
+    lower.contains("does not exist")
+        && (lower.contains("column c.relispopulated")
+            || lower.contains("column \"c\".\"relispopulated\"")
+            || lower.contains("column \"relispopulated\""))
+}
+
+#[cfg(test)]
+mod object_source_tests {
+    use super::*;
+    use crate::types::ObjectSourceKind;
+
+    #[test]
+    fn builds_sqlserver_object_source_sql_for_schema_scoped_routines() {
+        assert_eq!(
+            sqlserver_object_source_sql("dbo", "refresh_cache", &ObjectSourceKind::Procedure),
+            "SELECT m.definition FROM sys.sql_modules m JOIN sys.objects o ON o.object_id = m.object_id JOIN sys.schemas s ON s.schema_id = o.schema_id WHERE s.name = 'dbo' AND o.name = 'refresh_cache' AND o.type IN ('P')"
+        );
+    }
+
+    #[test]
+    fn builds_postgres_object_source_sql_for_views_and_functions() {
+        let view_sql = postgres_object_source_sql("public", "active_users", &ObjectSourceKind::View, None);
+
+        assert!(view_sql.contains("CREATE MATERIALIZED VIEW"));
+        assert!(view_sql.contains("CREATE OR REPLACE VIEW"));
+        assert!(view_sql.contains("CASE WHEN c.relispopulated THEN ' WITH DATA' ELSE ' WITH NO DATA' END"));
+        assert!(view_sql.contains("n.nspname = 'public'"));
+        assert!(view_sql.contains("c.relname = 'active_users'"));
+
+        assert_eq!(
+            postgres_object_source_sql("public", "recalc_score", &ObjectSourceKind::Function, None),
+            "SELECT pg_get_functiondef(p.oid) FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = 'public' AND p.proname = 'recalc_score' AND p.prokind = 'f' ORDER BY p.oid LIMIT 1"
+        );
+
+        assert_eq!(
+            postgres_object_source_sql("public", "recalc_score", &ObjectSourceKind::Function, Some("integer, integer")),
+            "SELECT pg_get_functiondef(p.oid) FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = 'public' AND p.proname = 'recalc_score' AND p.prokind = 'f' AND pg_get_function_identity_arguments(p.oid) = 'integer, integer' ORDER BY p.oid LIMIT 1"
+        );
+    }
+
+    #[test]
+    fn builds_postgres_object_source_sql_without_relispopulated_for_legacy_catalogs() {
+        let sql = postgres_object_source_sql_without_relispopulated(
+            "public",
+            "active_users",
+            &ObjectSourceKind::MaterializedView,
+            None,
+        );
+
+        assert!(sql.contains("CREATE MATERIALIZED VIEW"));
+        assert!(sql.contains("pg_get_viewdef(c.oid, 0)"));
+        assert!(!sql.contains("relispopulated"));
+    }
+
+    #[test]
+    fn builds_postgres_function_source_sql_without_prokind_for_legacy_catalogs() {
+        let sql = postgres_function_object_source_sql_without_prokind("public", "recalc_score");
+
+        assert_eq!(
+            sql,
+            "SELECT pg_get_functiondef(p.oid) FROM pg_proc p JOIN pg_namespace n ON n.oid = p.pronamespace WHERE n.nspname = 'public' AND p.proname = 'recalc_score' AND NOT p.proisagg AND NOT p.proiswindow ORDER BY p.oid LIMIT 1"
+        );
+    }
+
+    #[test]
+    fn keeps_legacy_materialized_viewdef_when_it_already_contains_create_statement() {
+        let sql = postgres_object_source_sql("public", "active_users", &ObjectSourceKind::MaterializedView, None);
+
+        assert!(
+            sql.contains(
+                "~* '^[[:space:]]*CREATE[[:space:]]+(OR[[:space:]]+REPLACE[[:space:]]+)?MATERIALIZED[[:space:]]+VIEW[[:space:]]+'"
+            )
+        );
+        assert!(sql.contains(
+            "THEN regexp_replace(pg_get_viewdef(c.oid, 0), ';[[:space:]]*$', '') ELSE format('CREATE MATERIALIZED VIEW"
+        ));
+    }
+
+    #[test]
+    fn detects_legacy_postgres_relispopulated_errors() {
+        assert!(postgres_missing_relispopulated_error("ERROR: column c.relispopulated does not exist"));
+        assert!(!postgres_missing_relispopulated_error("ERROR: relation public.relispopulated does not exist"));
+    }
+
+    #[test]
+    fn detects_legacy_postgres_prokind_errors() {
+        assert!(postgres_missing_prokind_error("ERROR: column p.prokind does not exist"));
+        assert!(postgres_missing_prokind_error("ERROR: column \"p\".\"prokind\" does not exist"));
+        assert!(!postgres_missing_prokind_error("ERROR: relation public.prokind does not exist"));
+    }
+
+    #[test]
+    fn builds_postgres_view_source_sql_without_regclass_cast() {
+        let sql = postgres_object_source_sql("tenant's schema", "active users", &ObjectSourceKind::View, None);
+
+        assert!(!sql.contains("::regclass"));
+        assert!(sql.contains("pg_get_viewdef(c.oid, 0)"));
+        assert!(sql.contains("format('CREATE OR REPLACE VIEW %I.%I AS ', n.nspname, c.relname)"));
+        assert!(sql.contains("n.nspname = 'tenant''s schema'"));
+        assert!(sql.contains("c.relname = 'active users'"));
+        assert!(sql.contains("c.relkind IN ('v','m')"));
+    }
+
+    #[test]
+    fn builds_postgres_view_source_fallback_sql_from_pg_views() {
+        assert_eq!(
+            postgres_view_source_fallback_sql("tenant's schema", "active users"),
+            "SELECT definition FROM pg_catalog.pg_views WHERE schemaname = 'tenant''s schema' AND viewname = 'active users' LIMIT 1"
+        );
+    }
+
+    #[test]
+    fn builds_oracle_object_source_sql_using_metadata_api() {
+        assert_eq!(
+            oracle_object_source_sql("HR", "ACTIVE_USERS", &ObjectSourceKind::View),
+            "SELECT DBMS_METADATA.GET_DDL('VIEW', 'ACTIVE_USERS', 'HR') FROM DUAL"
+        );
+        assert_eq!(
+            oracle_object_source_sql("HR", "PAYROLL", &ObjectSourceKind::PackageBody),
+            "SELECT DBMS_METADATA.GET_DDL('PACKAGE_BODY', 'PAYROLL', 'HR') FROM DUAL"
+        );
+        assert_eq!(
+            oracle_object_source_sql("", "PAYROLL", &ObjectSourceKind::Package),
+            "SELECT DBMS_METADATA.GET_DDL('PACKAGE', 'PAYROLL') FROM DUAL"
+        );
+    }
+
+    #[test]
+    fn builds_oracle_list_objects_sql_with_packages() {
+        let sql = oracle_list_objects_sql("hr");
+
+        assert!(sql.contains("'PACKAGE'"));
+        assert!(sql.contains("'PACKAGE BODY'"));
+        assert!(sql.contains("CASE object_type WHEN 'PACKAGE BODY' THEN 'PACKAGE_BODY'"));
+        assert!(sql.contains("owner = 'HR'"));
+    }
+
+    #[test]
+    fn appends_oracle_table_and_column_comments_to_ddl() {
+        let column = db::ColumnInfo {
+            name: "DISPLAY\"NAME".to_string(),
+            data_type: "VARCHAR2(100)".to_string(),
+            is_nullable: true,
+            column_default: None,
+            is_primary_key: false,
+            extra: None,
+            comment: Some("User's display name".to_string()),
+            numeric_precision: None,
+            numeric_scale: None,
+            character_maximum_length: None,
+            enum_values: None,
+            ..Default::default()
+        };
+        let mut ignored = column.clone();
+        ignored.name = "EMPTY_COMMENT".to_string();
+        ignored.comment = Some(" ".to_string());
+
+        let ddl = append_oracle_comments_to_ddl(
+            "CREATE TABLE \"HR\".\"USERS\" (\n  \"ID\" NUMBER\n);\n",
+            "HR",
+            "USERS",
+            Some("User table"),
+            &[column, ignored],
+        );
+
+        assert!(ddl.contains("CREATE TABLE \"HR\".\"USERS\""));
+        assert!(ddl.contains("COMMENT ON TABLE \"HR\".\"USERS\" IS 'User table';"));
+        assert!(ddl.contains("COMMENT ON COLUMN \"HR\".\"USERS\".\"DISPLAY\"\"NAME\" IS 'User''s display name';"));
+        assert!(!ddl.contains("EMPTY_COMMENT\" IS"));
+    }
+
+    #[test]
+    fn does_not_duplicate_existing_oracle_comment_ddl() {
+        let column = db::ColumnInfo {
+            name: "DISPLAY_NAME".to_string(),
+            data_type: "VARCHAR2(100)".to_string(),
+            is_nullable: true,
+            column_default: None,
+            is_primary_key: false,
+            extra: None,
+            comment: Some("New column comment".to_string()),
+            numeric_precision: None,
+            numeric_scale: None,
+            character_maximum_length: None,
+            enum_values: None,
+            ..Default::default()
+        };
+
+        let ddl = append_oracle_comments_to_ddl(
+            "CREATE TABLE \"HR\".\"USERS\" (\"ID\" NUMBER);\nCOMMENT ON TABLE \"HR\".\"USERS\" IS 'Existing';\nCOMMENT ON COLUMN \"HR\".\"USERS\".\"ID\" IS 'Existing';",
+            "HR",
+            "USERS",
+            Some("New table comment"),
+            &[column],
+        );
+
+        assert_eq!(ddl.matches("COMMENT ON TABLE").count(), 1);
+        assert_eq!(ddl.matches("COMMENT ON COLUMN").count(), 1);
+        assert!(!ddl.contains("New table comment"));
+        assert!(!ddl.contains("New column comment"));
+    }
+}
+
+#[cfg(test)]
+mod ddl_tests {
+    use super::*;
+
+    fn column(name: &str, data_type: &str) -> db::ColumnInfo {
+        db::ColumnInfo {
+            name: name.to_string(),
+            data_type: data_type.to_string(),
+            is_nullable: true,
+            column_default: None,
+            is_primary_key: false,
+            extra: None,
+            comment: None,
+            numeric_precision: None,
+            numeric_scale: None,
+            character_maximum_length: None,
+            enum_values: None,
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn postgres_table_ddl_includes_column_comments() {
+        let mut display_name = column("display_name", "text");
+        display_name.comment = Some("User's display name".to_string());
+        let columns = vec![display_name];
+
+        let ddl = render_postgres_table_ddl("public", "users", &columns, &[], &[]);
+
+        assert!(ddl.contains("COMMENT ON COLUMN \"public\".\"users\".\"display_name\" IS 'User''s display name';"));
+    }
+
+    #[test]
+    fn postgres_table_ddl_includes_generated_identity() {
+        let mut id = column("id", "integer");
+        id.is_nullable = false;
+        id.is_primary_key = true;
+        id.extra = Some("generated by default as identity".to_string());
+
+        let ddl = render_postgres_table_ddl("public", "users", &[id], &[], &[]);
+
+        assert!(ddl.contains("\"id\" integer generated by default as identity NOT NULL"), "ddl: {ddl}");
+    }
+
+    #[test]
+    fn postgres_table_ddl_keeps_composite_foreign_key_together() {
+        let columns = vec![column("a", "integer"), column("b", "integer"), column("c", "integer")];
+        let foreign_keys = vec![
+            db::ForeignKeyInfo {
+                name: "aaa_1".to_string(),
+                column: "a".to_string(),
+                ref_schema: Some("public".to_string()),
+                ref_table: "aaa_2".to_string(),
+                ref_column: "a".to_string(),
+                on_update: None,
+                on_delete: None,
+            },
+            db::ForeignKeyInfo {
+                name: "aaa_1".to_string(),
+                column: "b".to_string(),
+                ref_schema: Some("public".to_string()),
+                ref_table: "aaa_2".to_string(),
+                ref_column: "b".to_string(),
+                on_update: None,
+                on_delete: None,
+            },
+            db::ForeignKeyInfo {
+                name: "aaa_1".to_string(),
+                column: "c".to_string(),
+                ref_schema: Some("public".to_string()),
+                ref_table: "aaa_2".to_string(),
+                ref_column: "c".to_string(),
+                on_update: None,
+                on_delete: None,
+            },
+        ];
+
+        let ddl = render_postgres_table_ddl("public", "aaa_1", &columns, &[], &foreign_keys);
+
+        assert!(ddl.contains(
+            "CONSTRAINT \"aaa_1\" FOREIGN KEY (\"a\", \"b\", \"c\") REFERENCES \"aaa_2\"(\"a\", \"b\", \"c\")"
+        ));
+        assert_eq!(ddl.matches("CONSTRAINT \"aaa_1\" FOREIGN KEY").count(), 1);
+    }
+
+    #[test]
+    fn sqlserver_table_ddl_includes_column_comments() {
+        let mut display_name = column("display]name", "nvarchar(100)");
+        display_name.comment = Some("User's display name".to_string());
+        let columns = vec![display_name];
+
+        let ddl = render_sqlserver_table_ddl("dbo", "users", &columns, &[], &[]);
+
+        assert!(ddl.contains("CREATE TABLE [dbo].[users] (\n  [display]]name] nvarchar(100)\n);"));
+        assert!(ddl.contains(
+            "EXEC sys.sp_addextendedproperty @name=N'MS_Description', @value=N'User''s display name', @level0type=N'SCHEMA', @level0name=N'dbo', @level1type=N'TABLE', @level1name=N'users', @level2type=N'COLUMN', @level2name=N'display]name';"
+        ));
+    }
+
+    #[test]
+    fn sqlserver_table_ddl_includes_identity_clause() {
+        let mut id = column("FIDS", "int");
+        id.is_nullable = false;
+        id.is_primary_key = true;
+        id.extra = Some("identity(1,1)".to_string());
+
+        let ddl = render_sqlserver_table_ddl("dbo", "ZHLSBS", &[id], &[], &[]);
+
+        assert!(ddl.contains("[FIDS] int IDENTITY(1,1) NOT NULL"), "ddl: {ddl}");
+    }
+
+    #[test]
+    fn opengauss_table_ddl_uses_native_tabledef_function() {
+        assert_eq!(
+            opengauss_table_ddl_sql("tenant's schema", "active users"),
+            "SELECT pg_get_tabledef('\"tenant''s schema\".\"active users\"')"
+        );
+    }
+
+    #[test]
+    fn mysql_display_ddl_gets_statement_terminator() {
+        let ddl = "CREATE TABLE `users` (\n  `id` int NOT NULL\n) ENGINE=InnoDB";
+
+        assert_eq!(
+            ensure_display_ddl_terminated(ddl.to_string()),
+            "CREATE TABLE `users` (\n  `id` int NOT NULL\n) ENGINE=InnoDB;"
+        );
+    }
+
+    #[test]
+    fn mysql_display_ddl_does_not_duplicate_existing_terminator() {
+        let ddl = "CREATE TABLE `users` (`id` int);\n";
+
+        assert_eq!(ensure_display_ddl_terminated(ddl.to_string()), ddl);
+    }
+}
+
+pub async fn mysql_ddl(pool: &db::mysql::MySqlPool, database: &str, table: &str) -> Result<String, String> {
+    use mysql_async::prelude::*;
+    let sql = format!("SHOW CREATE TABLE {}", mysql_qualified_name(database, table));
+    // Use the health-checked getter so a stale pooled connection (server closed
+    // it after an idle timeout, NAT/firewall dropped the TCP state, etc.) is
+    // detected and replaced before issuing the query. Without this, the first
+    // DDL request after a period of inactivity could surface a low-level
+    // connection error that a manual refresh would have masked.
+    let mut conn = db::mysql::get_conn_with_health_check(pool).await?;
+    let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
+    let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
+    let row = rows.first().ok_or("DDL not found")?;
+    let ddl = row
+        .get_opt::<String, usize>(1)
+        .and_then(|result| result.ok())
+        .or_else(|| {
+            row.get_opt::<Vec<u8>, usize>(1)
+                .and_then(|result| result.ok())
+                .map(|b| String::from_utf8_lossy(&b).to_string())
+        })
+        .ok_or_else(|| "Failed to read DDL".to_string())?;
+    Ok(ensure_display_ddl_terminated(ddl))
+}
+
+fn ensure_display_ddl_terminated(sql: String) -> String {
+    let trimmed = sql.trim_end();
+    // SHOW CREATE TABLE returns a table definition, not a runnable script; DBX
+    // displays/copies it as SQL, so include the default statement terminator.
+    if trimmed.ends_with(';') {
+        sql
+    } else {
+        format!("{trimmed};")
+    }
+}
+
+pub async fn sqlite_ddl(pool: &db::sqlite::SqliteHandle, table: &str) -> Result<String, String> {
+    let pool = pool.clone();
+    let table = table.to_string();
+    tokio::task::spawn_blocking(move || {
+        pool.with_connection(|conn| {
+            conn.query_row("SELECT sql FROM sqlite_master WHERE type='table' AND name=?1", [table], |row| {
+                row.get::<_, String>(0)
+            })
+            .map_err(|e| e.to_string())
+        })
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+pub async fn opengauss_table_ddl(pool: &deadpool_postgres::Pool, schema: &str, table: &str) -> Result<String, String> {
+    first_string_cell(db::postgres::execute_query(pool, &opengauss_table_ddl_sql(schema, table)).await?)
+}
+
+pub fn opengauss_table_ddl_sql(schema: &str, table: &str) -> String {
+    let qualified_name = format!("{}.{}", pg_ident(schema), pg_ident(table));
+    format!("SELECT pg_get_tabledef({})", sql_string(&qualified_name))
+}
+
+pub async fn pg_ddl(pool: &deadpool_postgres::Pool, schema: &str, table: &str) -> Result<String, String> {
+    let (columns, indexes, fkeys) = tokio::try_join!(
+        db::postgres::get_columns(pool, schema, table),
+        db::postgres::list_indexes(pool, schema, table),
+        db::postgres::list_foreign_keys(pool, schema, table),
+    )?;
+
+    Ok(render_postgres_table_ddl(schema, table, &columns, &indexes, &fkeys))
+}
+
+pub fn render_postgres_table_ddl(
+    schema: &str,
+    table: &str,
+    columns: &[db::ColumnInfo],
+    indexes: &[db::IndexInfo],
+    fkeys: &[db::ForeignKeyInfo],
+) -> String {
+    let table_name = format!("{}.{}", pg_ident(schema), pg_ident(table));
+    let mut ddl = format!("CREATE TABLE {table_name} (\n");
+    let col_lines: Vec<String> = columns
+        .iter()
+        .map(|c| {
+            let mut line = format!("  {} {}", pg_ident(&c.name), c.data_type);
+            let generated_clause = c
+                .extra
+                .as_deref()
+                .map(str::trim)
+                .filter(|value| !value.is_empty() && value.to_ascii_lowercase().starts_with("generated "));
+            if let Some(extra) = generated_clause {
+                line.push_str(&format!(" {extra}"));
+            }
+            if !c.is_nullable {
+                line.push_str(" NOT NULL");
+            }
+            if generated_clause.is_none() {
+                if let Some(ref def) = c.column_default {
+                    line.push_str(&format!(" DEFAULT {def}"));
+                }
+            }
+            line
+        })
+        .collect();
+    ddl.push_str(&col_lines.join(",\n"));
+
+    let pks: Vec<&str> = columns.iter().filter(|c| c.is_primary_key).map(|c| c.name.as_str()).collect();
+    if !pks.is_empty() {
+        ddl.push_str(&format!(",\n  PRIMARY KEY ({})", pks.iter().map(|k| pg_ident(k)).collect::<Vec<_>>().join(", ")));
+    }
+    for fk_group in group_foreign_keys_by_name(fkeys) {
+        let Some(first_fk) = fk_group.first() else {
+            continue;
+        };
+        let columns = fk_group.iter().map(|fk| pg_ident(&fk.column)).collect::<Vec<_>>().join(", ");
+        let ref_columns = fk_group.iter().map(|fk| pg_ident(&fk.ref_column)).collect::<Vec<_>>().join(", ");
+        ddl.push_str(&format!(
+            ",\n  CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {}({})",
+            pg_ident(&first_fk.name),
+            columns,
+            pg_ident(&first_fk.ref_table),
+            ref_columns
+        ));
+    }
+    ddl.push_str("\n);\n");
+
+    for col in columns {
+        if let Some(comment) = col.comment.as_deref().filter(|comment| !comment.is_empty()) {
+            ddl.push_str(&format!(
+                "\nCOMMENT ON COLUMN {table_name}.{} IS {};",
+                pg_ident(&col.name),
+                sql_string(comment)
+            ));
+        }
+    }
+
+    for idx in indexes {
+        if idx.is_primary {
+            continue;
+        }
+        let unique = if idx.is_unique { "UNIQUE " } else { "" };
+        let cols = idx.columns.iter().map(|c| pg_ident(c)).collect::<Vec<_>>().join(", ");
+        let using = idx.index_type.as_deref().map(|t| format!(" USING {t}")).unwrap_or_default();
+        let include = idx
+            .included_columns
+            .as_deref()
+            .filter(|c| !c.is_empty())
+            .map(|cols| format!(" INCLUDE ({})", cols.iter().map(|c| pg_ident(c)).collect::<Vec<_>>().join(", ")))
+            .unwrap_or_default();
+        let filter = idx.filter.as_deref().map(|f| format!(" WHERE {f}")).unwrap_or_default();
+        ddl.push_str(&format!(
+            "\nCREATE {unique}INDEX {} ON {table_name}{using} ({cols}){include}{filter};",
+            pg_ident(&idx.name)
+        ));
+        if let Some(ref c) = idx.comment {
+            ddl.push_str(&format!(
+                "\nCOMMENT ON INDEX {}.{} IS {};",
+                pg_ident(schema),
+                pg_ident(&idx.name),
+                sql_string(c)
+            ));
+        }
+    }
+    ddl
+}
+
+fn sqlserver_identity_clause(extra: Option<&str>) -> Option<String> {
+    let extra = extra?.trim();
+    let lower = extra.to_ascii_lowercase();
+    if !lower.starts_with("identity") {
+        return None;
+    }
+
+    let rest = extra["identity".len()..].trim_start();
+    if rest.is_empty() {
+        return Some("IDENTITY".to_string());
+    }
+
+    let args = rest.strip_prefix('(')?;
+    let end = args.find(')')?;
+    Some(format!("IDENTITY({})", args[..end].trim()))
+}
+
+fn group_foreign_keys_by_name(fkeys: &[db::ForeignKeyInfo]) -> Vec<Vec<&db::ForeignKeyInfo>> {
+    let mut groups: Vec<Vec<&db::ForeignKeyInfo>> = Vec::new();
+    for fk in fkeys {
+        if let Some(group) = groups.iter_mut().find(|group| group.first().is_some_and(|first| first.name == fk.name)) {
+            group.push(fk);
+        } else {
+            groups.push(vec![fk]);
+        }
+    }
+    groups
+}
+
+pub async fn build_sqlserver_ddl(
+    client: &mut db::sqlserver::SqlServerClient,
+    schema: &str,
+    table: &str,
+) -> Result<String, String> {
+    let columns = db::sqlserver::get_columns(client, schema, table).await?;
+    let indexes = db::sqlserver::list_indexes(client, schema, table).await?;
+    let fkeys = db::sqlserver::list_foreign_keys(client, schema, table).await?;
+
+    Ok(render_sqlserver_table_ddl(schema, table, &columns, &indexes, &fkeys))
+}
+
+pub fn render_sqlserver_table_ddl(
+    schema: &str,
+    table: &str,
+    columns: &[db::ColumnInfo],
+    indexes: &[db::IndexInfo],
+    fkeys: &[db::ForeignKeyInfo],
+) -> String {
+    let table_name = format!("{}.{}", sqlserver_ident(schema), sqlserver_ident(table));
+    let mut ddl = format!("CREATE TABLE {table_name} (\n");
+    let col_lines: Vec<String> = columns
+        .iter()
+        .map(|c| {
+            let mut line = format!("  {} {}", sqlserver_ident(&c.name), c.data_type);
+            if let Some(identity) = sqlserver_identity_clause(c.extra.as_deref()) {
+                line.push_str(&format!(" {identity}"));
+            }
+            if !c.is_nullable {
+                line.push_str(" NOT NULL");
+            }
+            if let Some(ref def) = c.column_default {
+                line.push_str(&format!(" DEFAULT {def}"));
+            }
+            line
+        })
+        .collect();
+    ddl.push_str(&col_lines.join(",\n"));
+
+    let pks: Vec<&str> = columns.iter().filter(|c| c.is_primary_key).map(|c| c.name.as_str()).collect();
+    if !pks.is_empty() {
+        ddl.push_str(&format!(
+            ",\n  PRIMARY KEY ({})",
+            pks.iter().map(|k| sqlserver_ident(k)).collect::<Vec<_>>().join(", ")
+        ));
+    }
+    for fk in fkeys {
+        ddl.push_str(&format!(
+            ",\n  CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {}({})",
+            sqlserver_ident(&fk.name),
+            sqlserver_ident(&fk.column),
+            sqlserver_ident(&fk.ref_table),
+            sqlserver_ident(&fk.ref_column)
+        ));
+    }
+    ddl.push_str("\n);\n");
+
+    for column in columns {
+        if let Some(comment) = column.comment.as_deref().map(str::trim).filter(|comment| !comment.is_empty()) {
+            ddl.push_str(&format!(
+                "\nEXEC sys.sp_addextendedproperty @name=N'MS_Description', @value={}, @level0type=N'SCHEMA', @level0name={}, @level1type=N'TABLE', @level1name={}, @level2type=N'COLUMN', @level2name={};",
+                sqlserver_n_string(comment),
+                sqlserver_n_string(schema),
+                sqlserver_n_string(table),
+                sqlserver_n_string(&column.name)
+            ));
+        }
+    }
+
+    for idx in indexes {
+        if idx.is_primary {
+            continue;
+        }
+        let unique = if idx.is_unique { "UNIQUE " } else { "" };
+        let idx_type = idx.index_type.as_deref().map(|t| format!("{t} ")).unwrap_or_default();
+        let cols = idx.columns.iter().map(|c| sqlserver_ident(c)).collect::<Vec<_>>().join(", ");
+        let include = idx
+            .included_columns
+            .as_deref()
+            .filter(|c| !c.is_empty())
+            .map(|cols| {
+                format!(" INCLUDE ({})", cols.iter().map(|c| sqlserver_ident(c)).collect::<Vec<_>>().join(", "))
+            })
+            .unwrap_or_default();
+        let filter = idx.filter.as_deref().map(|f| format!(" WHERE {f}")).unwrap_or_default();
+        ddl.push_str(&format!(
+            "\nCREATE {unique}{idx_type}INDEX {} ON {table_name} ({cols}){include}{filter};",
+            sqlserver_ident(&idx.name)
+        ));
+    }
+    ddl
+}
diff --git a/crates/dbx-core/src/schema/duckdb_metadata.rs b/crates/dbx-core/src/schema/duckdb_metadata.rs
new file mode 100644
index 0000000..f51bbcf
--- /dev/null
+++ b/crates/dbx-core/src/schema/duckdb_metadata.rs
@@ -0,0 +1,203 @@
+use crate::connection::AppState;
+use crate::db;
+
+pub fn duckdb_query_tables(con: &duckdb::Connection) -> Result<Vec<db::TableInfo>, String> {
+    duckdb_query_tables_in_database(con, "main", "main")
+}
+
+pub fn duckdb_query_tables_in_database(
+    con: &duckdb::Connection,
+    database: &str,
+    schema: &str,
+) -> Result<Vec<db::TableInfo>, String> {
+    duckdb_query_tables_in_database_with_attached(con, database, schema, &[])
+}
+
+pub fn duckdb_query_tables_in_database_with_attached(
+    con: &duckdb::Connection,
+    database: &str,
+    schema: &str,
+    attached_names: &[String],
+) -> Result<Vec<db::TableInfo>, String> {
+    let database = duckdb_catalog_name(con, database, attached_names)?;
+    let mut stmt = con
+        .prepare(
+            "SELECT table_name, table_type FROM information_schema.tables WHERE table_catalog = ? AND table_schema = ? ORDER BY table_name",
+        )
+        .map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map((database.as_str(), schema), |row| {
+            Ok(db::TableInfo {
+                name: row.get::<_, String>(0)?,
+                table_type: row.get::<_, String>(1)?,
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            })
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(rows.filter_map(|r| r.ok()).collect())
+}
+
+pub fn duckdb_attach_database(con: &duckdb::Connection, name: &str, path: &str) -> Result<(), String> {
+    let name = name.trim();
+    let path = path.trim();
+    if name.is_empty() || path.is_empty() {
+        return Err("DuckDB attached database name and path are required".to_string());
+    }
+    let sql = format!("ATTACH {} AS {}", duckdb_quote_string(path), duckdb_quote_ident(name));
+    con.execute_batch(&sql).map_err(|e| e.to_string())
+}
+
+pub fn duckdb_list_databases(con: &duckdb::Connection) -> Result<Vec<db::DatabaseInfo>, String> {
+    duckdb_list_databases_with_attached(con, &[])
+}
+
+pub fn duckdb_list_databases_with_attached(
+    con: &duckdb::Connection,
+    attached_names: &[String],
+) -> Result<Vec<db::DatabaseInfo>, String> {
+    let primary = duckdb_primary_catalog(con, attached_names)?;
+    let mut stmt = con.prepare("SHOW DATABASES").map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map([], |row| {
+            let name = row.get::<_, String>(0)?;
+            Ok(db::DatabaseInfo { name: if name == primary { "main".to_string() } else { name } })
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(rows.filter_map(|row| row.ok()).collect())
+}
+
+pub fn duckdb_list_schemas(con: &duckdb::Connection, database: &str) -> Result<Vec<String>, String> {
+    duckdb_list_schemas_with_attached(con, database, &[])
+}
+
+pub fn duckdb_list_schemas_with_attached(
+    con: &duckdb::Connection,
+    database: &str,
+    attached_names: &[String],
+) -> Result<Vec<String>, String> {
+    let database = duckdb_catalog_name(con, database, attached_names)?;
+    let mut stmt = con
+        .prepare(
+            "SELECT schema_name FROM information_schema.schemata WHERE catalog_name = ? AND schema_name NOT IN ('information_schema', 'pg_catalog') ORDER BY schema_name",
+        )
+        .map_err(|e| e.to_string())?;
+    let rows = stmt.query_map([database.as_str()], |row| row.get::<_, String>(0)).map_err(|e| e.to_string())?;
+    Ok(rows.filter_map(|r| r.ok()).collect())
+}
+
+fn duckdb_catalog_name(con: &duckdb::Connection, database: &str, attached_names: &[String]) -> Result<String, String> {
+    if database.trim().is_empty() || database == "main" {
+        return duckdb_primary_catalog(con, attached_names);
+    }
+    Ok(database.to_string())
+}
+
+pub fn duckdb_primary_catalog(con: &duckdb::Connection, attached_names: &[String]) -> Result<String, String> {
+    if attached_names.is_empty() {
+        return duckdb_current_database(con);
+    }
+    let attached: std::collections::HashSet<String> = attached_names.iter().map(|name| name.to_lowercase()).collect();
+    let mut stmt = con.prepare("SHOW DATABASES").map_err(|e| e.to_string())?;
+    let rows = stmt.query_map([], |row| row.get::<_, String>(0)).map_err(|e| e.to_string())?;
+    for row in rows {
+        let name = row.map_err(|e| e.to_string())?;
+        if !attached.contains(&name.to_lowercase()) {
+            return Ok(name);
+        }
+    }
+    duckdb_current_database(con)
+}
+
+fn duckdb_current_database(con: &duckdb::Connection) -> Result<String, String> {
+    con.query_row("SELECT current_database()", [], |row| row.get::<_, String>(0)).map_err(|e| e.to_string())
+}
+
+fn duckdb_quote_ident(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+fn duckdb_quote_string(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+pub fn duckdb_query_columns(con: &duckdb::Connection, table: &str) -> Result<Vec<db::ColumnInfo>, String> {
+    duckdb_query_columns_in_database(con, "main", "main", table)
+}
+
+pub fn duckdb_query_columns_in_database(
+    con: &duckdb::Connection,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::ColumnInfo>, String> {
+    duckdb_query_columns_in_database_with_attached(con, database, schema, table, &[])
+}
+
+pub fn duckdb_query_columns_in_database_with_attached(
+    con: &duckdb::Connection,
+    database: &str,
+    schema: &str,
+    table: &str,
+    attached_names: &[String],
+) -> Result<Vec<db::ColumnInfo>, String> {
+    let database = duckdb_catalog_name(con, database, attached_names)?;
+    let mut pk_stmt = con
+        .prepare(
+            "SELECT kcu.column_name
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+          AND tc.table_schema = kcu.table_schema
+          AND tc.table_name = kcu.table_name
+         WHERE tc.constraint_type = 'PRIMARY KEY'
+           AND tc.table_catalog = ?
+           AND tc.table_schema = ?
+           AND tc.table_name = ?
+         ORDER BY kcu.ordinal_position",
+        )
+        .map_err(|e| e.to_string())?;
+    let pk_rows = pk_stmt
+        .query_map((database.as_str(), schema, table), |row| row.get::<_, String>(0))
+        .map_err(|e| e.to_string())?;
+    let primary_keys: std::collections::HashSet<String> = pk_rows.filter_map(|r| r.ok()).collect();
+
+    let mut stmt = con
+        .prepare(
+            "SELECT column_name, data_type, is_nullable, column_default
+         FROM information_schema.columns
+         WHERE table_catalog = ? AND table_schema = ? AND table_name = ?
+         ORDER BY ordinal_position",
+        )
+        .map_err(|e| e.to_string())?;
+    let rows = stmt
+        .query_map((database.as_str(), schema, table), |row| {
+            let name = row.get::<_, String>(0)?;
+            Ok(db::ColumnInfo {
+                is_primary_key: primary_keys.contains(&name),
+                name,
+                data_type: row.get::<_, String>(1)?,
+                is_nullable: row.get::<_, String>(2).unwrap_or_default() == "YES",
+                column_default: row.get::<_, Option<String>>(3)?,
+                extra: None,
+                comment: None,
+                numeric_precision: None,
+                numeric_scale: None,
+                character_maximum_length: None,
+            ..Default::default()
+            })
+        })
+        .map_err(|e| e.to_string())?;
+    Ok(rows.filter_map(|r| r.ok()).collect())
+}
+
+pub(super) async fn duckdb_attached_database_names(state: &AppState, connection_id: &str) -> Vec<String> {
+    state
+        .configs
+        .read()
+        .await
+        .get(connection_id)
+        .map(|config| config.attached_databases.iter().map(|database| database.name.clone()).collect())
+        .unwrap_or_default()
+}
diff --git a/crates/dbx-core/src/schema/normalization.rs b/crates/dbx-core/src/schema/normalization.rs
new file mode 100644
index 0000000..f687d2c
--- /dev/null
+++ b/crates/dbx-core/src/schema/normalization.rs
@@ -0,0 +1,334 @@
+use crate::db;
+use crate::models::connection::{ConnectionConfig, DatabaseType};
+use std::collections::HashSet;
+
+pub(super) fn filter_table_infos(
+    tables: Vec<db::TableInfo>,
+    filter: Option<&str>,
+    limit: Option<usize>,
+) -> Vec<db::TableInfo> {
+    let filter = filter.unwrap_or("").to_lowercase();
+    let limit = limit.unwrap_or(usize::MAX);
+    tables
+        .into_iter()
+        .filter(|table| filter.is_empty() || table.name.to_lowercase().contains(&filter))
+        .take(limit)
+        .collect()
+}
+
+pub(super) fn filter_table_infos_for_config(
+    tables: Vec<db::TableInfo>,
+    filter: Option<&str>,
+    limit: Option<usize>,
+    config: Option<&ConnectionConfig>,
+) -> Vec<db::TableInfo> {
+    filter_table_infos(filter_yashandb_recyclebin_tables(tables, config), filter, limit)
+}
+
+pub(super) fn filter_yashandb_recyclebin_tables(
+    tables: Vec<db::TableInfo>,
+    config: Option<&ConnectionConfig>,
+) -> Vec<db::TableInfo> {
+    if !is_yashandb_config(config) {
+        return tables;
+    }
+    tables.into_iter().filter(|table| !is_recyclebin_object_name(&table.name)).collect()
+}
+
+pub(super) fn filter_yashandb_recyclebin_objects(
+    objects: Vec<db::ObjectInfo>,
+    config: Option<&ConnectionConfig>,
+) -> Vec<db::ObjectInfo> {
+    if !is_yashandb_config(config) {
+        return objects;
+    }
+    objects.into_iter().filter(|object| !is_recyclebin_object_name(&object.name)).collect()
+}
+
+fn is_yashandb_config(config: Option<&ConnectionConfig>) -> bool {
+    config.is_some_and(|config| config.db_type == DatabaseType::Yashandb)
+}
+
+fn is_recyclebin_object_name(name: &str) -> bool {
+    name.to_ascii_uppercase().starts_with("BIN$")
+}
+
+pub(super) fn filter_objects_by_types(
+    objects: Vec<db::ObjectInfo>,
+    object_types: Option<&[String]>,
+) -> Vec<db::ObjectInfo> {
+    let Some(object_types) = object_types else {
+        return objects;
+    };
+    if object_types.is_empty() {
+        return objects;
+    }
+    let wanted: HashSet<String> =
+        object_types.iter().map(|object_type| normalize_object_info_type(object_type)).collect();
+    objects.into_iter().filter(|object| wanted.contains(&normalize_object_info_type(&object.object_type))).collect()
+}
+
+fn normalize_object_info_type(object_type: &str) -> String {
+    let value = object_type.to_ascii_uppercase().replace(' ', "_");
+    if value.contains("PACKAGE_BODY") {
+        "PACKAGE_BODY".to_string()
+    } else if value.contains("PACKAGE") {
+        "PACKAGE".to_string()
+    } else if value.contains("VIEW") {
+        "VIEW".to_string()
+    } else if value.contains("PROC") {
+        "PROCEDURE".to_string()
+    } else if value.contains("FUNC") {
+        "FUNCTION".to_string()
+    } else {
+        "TABLE".to_string()
+    }
+}
+
+pub(super) fn filter_completion_objects(objects: Vec<db::ObjectInfo>) -> Vec<db::ObjectInfo> {
+    objects
+        .into_iter()
+        .filter(|object| {
+            let object_type = object.object_type.to_ascii_uppercase();
+            object_type.contains("PROCEDURE") || object_type.contains("FUNCTION") || object_type.contains("TRIGGER")
+        })
+        .collect()
+}
+
+pub(super) fn deduplicate_column_infos(columns: Vec<db::ColumnInfo>) -> Vec<db::ColumnInfo> {
+    let mut result: Vec<db::ColumnInfo> = Vec::with_capacity(columns.len());
+    for column in columns {
+        if let Some(existing) = result.iter_mut().find(|existing| existing.name == column.name) {
+            existing.is_primary_key |= column.is_primary_key;
+            existing.is_nullable &= column.is_nullable;
+            merge_optional_string(&mut existing.column_default, column.column_default);
+            merge_optional_string(&mut existing.extra, column.extra);
+            merge_optional_string(&mut existing.comment, column.comment);
+            if existing.numeric_precision.is_none() {
+                existing.numeric_precision = column.numeric_precision;
+            }
+            if existing.numeric_scale.is_none() {
+                existing.numeric_scale = column.numeric_scale;
+            }
+            if existing.character_maximum_length.is_none() {
+                existing.character_maximum_length = column.character_maximum_length;
+            }
+            if existing.data_type.trim().is_empty() && !column.data_type.trim().is_empty() {
+                existing.data_type = column.data_type;
+            }
+        } else {
+            result.push(column);
+        }
+    }
+    result
+}
+
+fn merge_optional_string(target: &mut Option<String>, candidate: Option<String>) {
+    let Some(candidate) = candidate else {
+        return;
+    };
+    if candidate.trim().is_empty() {
+        if target.is_none() {
+            *target = Some(candidate);
+        }
+        return;
+    }
+    if target.as_ref().is_none_or(|value| value.trim().is_empty()) {
+        *target = Some(candidate);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::models::connection::{default_redis_key_separator, ConnectionConfig};
+
+    fn test_connection_config(db_type: DatabaseType) -> ConnectionConfig {
+        ConnectionConfig {
+            id: "test".to_string(),
+            name: "test".to_string(),
+            db_type,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 5432,
+            username: "user".to_string(),
+            password: "secret".to_string(),
+            database: Some("demo".to_string()),
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: 0,
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: default_redis_key_separator(),
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    fn test_column(name: &str, comment: Option<&str>, is_primary_key: bool) -> db::ColumnInfo {
+        db::ColumnInfo {
+            name: name.to_string(),
+            data_type: "VARCHAR".to_string(),
+            is_nullable: true,
+            column_default: None,
+            is_primary_key,
+            extra: None,
+            comment: comment.map(|value| value.to_string()),
+            numeric_precision: None,
+            numeric_scale: None,
+            character_maximum_length: None,
+        ..Default::default()
+        }
+    }
+
+    #[test]
+    fn deduplicates_columns_and_preserves_later_comment() {
+        let columns = deduplicate_column_infos(vec![
+            test_column("ID", None, false),
+            test_column("ID", Some("source primary key"), true),
+            test_column("TFBH", Some(""), false),
+            test_column("TFBH", Some("ledger number"), false),
+        ]);
+
+        assert_eq!(columns.len(), 2);
+        assert_eq!(columns[0].name, "ID");
+        assert_eq!(columns[0].comment.as_deref(), Some("source primary key"));
+        assert!(columns[0].is_primary_key);
+        assert_eq!(columns[1].name, "TFBH");
+        assert_eq!(columns[1].comment.as_deref(), Some("ledger number"));
+    }
+
+    #[test]
+    fn filters_list_objects_by_normalized_object_types() {
+        let objects = vec![
+            db::ObjectInfo {
+                name: "orders".to_string(),
+                object_type: "BASE TABLE".to_string(),
+                schema: None,
+                signature: None,
+                comment: None,
+                created_at: None,
+                updated_at: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+            db::ObjectInfo {
+                name: "active_orders".to_string(),
+                object_type: "MATERIALIZED_VIEW".to_string(),
+                schema: None,
+                signature: None,
+                comment: None,
+                created_at: None,
+                updated_at: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+            db::ObjectInfo {
+                name: "payroll".to_string(),
+                object_type: "PACKAGE BODY".to_string(),
+                schema: None,
+                signature: None,
+                comment: None,
+                created_at: None,
+                updated_at: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+        ];
+
+        let filtered = filter_objects_by_types(objects, Some(&["VIEW".to_string(), "PACKAGE_BODY".to_string()]));
+
+        assert_eq!(
+            filtered.iter().map(|object| object.name.as_str()).collect::<Vec<_>>(),
+            ["active_orders", "payroll"]
+        );
+    }
+
+    #[test]
+    fn filters_yashandb_recyclebin_tables() {
+        let tables = vec![
+            db::TableInfo {
+                name: "USERS".to_string(),
+                table_type: "TABLE".to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+            db::TableInfo {
+                name: "BIN$abc123==$0".to_string(),
+                table_type: "TABLE".to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+        ];
+
+        let filtered =
+            filter_yashandb_recyclebin_tables(tables.clone(), Some(&test_connection_config(DatabaseType::Yashandb)));
+        let oracle = filter_yashandb_recyclebin_tables(tables, Some(&test_connection_config(DatabaseType::Oracle)));
+
+        assert_eq!(filtered.iter().map(|table| table.name.as_str()).collect::<Vec<_>>(), ["USERS"]);
+        assert_eq!(oracle.len(), 2);
+    }
+
+    #[test]
+    fn filters_yashandb_recyclebin_objects() {
+        let objects = vec![
+            db::ObjectInfo {
+                name: "ORDERS".to_string(),
+                object_type: "TABLE".to_string(),
+                schema: Some("HR".to_string()),
+                signature: None,
+                comment: None,
+                created_at: None,
+                updated_at: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+            db::ObjectInfo {
+                name: "bin$deleted".to_string(),
+                object_type: "TABLE".to_string(),
+                schema: Some("HR".to_string()),
+                signature: None,
+                comment: None,
+                created_at: None,
+                updated_at: None,
+                parent_schema: None,
+                parent_name: None,
+            },
+        ];
+
+        let filtered =
+            filter_yashandb_recyclebin_objects(objects, Some(&test_connection_config(DatabaseType::Yashandb)));
+
+        assert_eq!(filtered.iter().map(|object| object.name.as_str()).collect::<Vec<_>>(), ["ORDERS"]);
+    }
+}
diff --git a/crates/dbx-core/src/schema/providers/mod.rs b/crates/dbx-core/src/schema/providers/mod.rs
new file mode 100644
index 0000000..c08432d
--- /dev/null
+++ b/crates/dbx-core/src/schema/providers/mod.rs
@@ -0,0 +1 @@
+pub(super) mod native;
diff --git a/crates/dbx-core/src/schema/providers/native.rs b/crates/dbx-core/src/schema/providers/native.rs
new file mode 100644
index 0000000..b407c87
--- /dev/null
+++ b/crates/dbx-core/src/schema/providers/native.rs
@@ -0,0 +1,353 @@
+use crate::connection::{MysqlMode, PoolKind};
+use crate::db;
+use crate::models::connection::{ConnectionConfig, DatabaseType};
+
+pub(in crate::schema) async fn list_databases(
+    pool: &PoolKind,
+    config: Option<&ConnectionConfig>,
+) -> Result<Vec<db::DatabaseInfo>, String> {
+    match pool {
+        PoolKind::Mysql(p, _) if config.is_some_and(is_doris_family_config) => db::mysql::list_databases_show(p)
+            .await
+            .map(|databases| filter_mysql_system_databases_for_config(databases, config)),
+        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => db::ob_oracle::list_databases(p).await,
+        PoolKind::Mysql(p, _) => db::mysql::list_databases(p).await,
+        PoolKind::Postgres(p) => db::postgres::list_databases(p).await,
+        PoolKind::Sqlite(p) => db::sqlite::list_databases(p).await,
+        PoolKind::Rqlite(client) => db::rqlite_driver::list_databases(client).await,
+        PoolKind::Turso(client) => db::turso_driver::list_databases(client).await,
+        _ => Ok(vec![]),
+    }
+}
+
+pub(in crate::schema) async fn list_schemas(pool: &PoolKind) -> Result<Vec<String>, String> {
+    match pool {
+        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => db::ob_oracle::list_schemas(p).await,
+        PoolKind::Postgres(p) => db::postgres::list_schemas(p).await,
+        _ => Ok(vec![]),
+    }
+}
+
+pub(in crate::schema) async fn list_tables(
+    pool: &PoolKind,
+    config: Option<&ConnectionConfig>,
+    database: &str,
+    schema: &str,
+) -> Result<Vec<db::TableInfo>, String> {
+    match pool {
+        PoolKind::Mysql(p, _) if config.is_some_and(is_doris_family_config) => {
+            db::mysql::list_tables_show(p, database).await
+        }
+        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
+            let s = if schema.is_empty() { database } else { schema };
+            db::ob_oracle::list_tables(p, s).await
+        }
+        PoolKind::Mysql(p, _) => {
+            let db = if schema.is_empty() { database } else { schema };
+            db::mysql::list_tables(p, db).await
+        }
+        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => {
+            db::questdb::list_tables(p, schema).await
+        }
+        PoolKind::Postgres(p) => db::postgres::list_tables(p, schema).await,
+        PoolKind::Sqlite(p) => db::sqlite::list_tables(p, schema).await,
+        PoolKind::Rqlite(client) => db::rqlite_driver::list_tables(client, schema).await,
+        PoolKind::Turso(client) => db::turso_driver::list_tables(client, schema).await,
+        PoolKind::MongoDb(client) => db::mongo_driver::list_collections(client, database)
+            .await
+            .map(|names| collection_names_to_tables(names, "COLLECTION")),
+        PoolKind::Elasticsearch(client) => {
+            db::elasticsearch_driver::list_indices(client).await.map(|names| collection_names_to_tables(names, "INDEX"))
+        }
+        PoolKind::VectorDb(client) => {
+            db::vector_driver::list_collections(client).await.map(|infos| collection_names_to_tables(infos.into_iter().map(|i| i.name).collect(), "COLLECTION"))
+        }
+        _ => Ok(vec![]),
+    }
+}
+
+pub(in crate::schema) async fn list_objects(
+    pool: &PoolKind,
+    config: Option<&ConnectionConfig>,
+    database: &str,
+    schema: &str,
+) -> Result<Option<Vec<db::ObjectInfo>>, String> {
+    match pool {
+        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
+            db::ob_oracle::list_objects(p, schema).await.map(Some)
+        }
+        PoolKind::Mysql(p, _) if config.is_some_and(is_manticoresearch_config) => {
+            db::manticoresearch::list_objects(p, database).await.map(Some)
+        }
+        PoolKind::Mysql(p, _) if config.is_some_and(is_doris_family_config) => {
+            db::mysql::list_table_objects_show(p, database).await.map(Some)
+        }
+        PoolKind::Mysql(p, _) => db::mysql::list_objects(p, database, None, None, None)
+            .await
+            .map(|result| Some(result.objects)),
+        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => {
+            db::questdb::list_objects(p, schema).await.map(Some)
+        }
+        PoolKind::Postgres(p) => db::postgres::list_objects(p, schema).await.map(Some),
+        _ => Ok(None),
+    }
+}
+
+pub(in crate::schema) async fn list_completion_objects(
+    pool: &PoolKind,
+    config: Option<&ConnectionConfig>,
+    database: &str,
+    schema: &str,
+) -> Result<Option<Vec<db::ObjectInfo>>, String> {
+    match pool {
+        PoolKind::Mysql(p, mode) if *mode != MysqlMode::OceanBaseOracle => {
+            db::mysql::list_completion_objects(p, database).await.map(Some)
+        }
+        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
+            db::ob_oracle::list_objects(p, schema).await.map(Some)
+        }
+        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => {
+            db::questdb::list_objects(p, schema).await.map(Some)
+        }
+        PoolKind::Postgres(p) => db::postgres::list_objects(p, schema).await.map(Some),
+        _ => Ok(None),
+    }
+}
+
+pub(in crate::schema) async fn get_columns(
+    pool: &PoolKind,
+    config: Option<&ConnectionConfig>,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::ColumnInfo>, String> {
+    match pool {
+        PoolKind::Mysql(p, _) if config.is_some_and(is_manticoresearch_config) => {
+            let metadata_database = mysql_show_metadata_database_for_config(config, database);
+            db::manticoresearch::get_columns(p, metadata_database, table).await
+        }
+        PoolKind::Mysql(p, _) if config.is_some_and(is_doris_family_config) => {
+            let metadata_database = mysql_show_metadata_database_for_config(config, database);
+            db::mysql::get_columns(p, metadata_database, table).await
+        }
+        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
+            db::ob_oracle::get_columns(p, database, table).await
+        }
+        PoolKind::Mysql(p, _) => db::mysql::get_columns(p, database, table).await,
+        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => {
+            db::questdb::get_columns(p, schema, table).await
+        }
+        PoolKind::Postgres(p) => db::postgres::get_columns(p, schema, table).await,
+        PoolKind::Sqlite(p) => db::sqlite::get_columns(p, schema, table).await,
+        PoolKind::Rqlite(client) => db::rqlite_driver::get_columns(client, schema, table).await,
+        PoolKind::Turso(client) => db::turso_driver::get_columns(client, schema, table).await,
+        PoolKind::Elasticsearch(client) => db::elasticsearch_driver::get_columns(client, table).await,
+        PoolKind::VectorDb(_) => Ok(vec![]),
+        _ => Ok(vec![]),
+    }
+}
+
+pub(in crate::schema) async fn list_indexes(
+    pool: &PoolKind,
+    config: Option<&ConnectionConfig>,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::IndexInfo>, String> {
+    match pool {
+        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
+            db::ob_oracle::list_indexes(p, schema, table).await
+        }
+        PoolKind::Mysql(p, _) if config.is_some_and(is_doris_family_config) => {
+            db::mysql::list_doris_family_indexes(p, database, table).await
+        }
+        PoolKind::Mysql(p, _) => db::mysql::list_indexes(p, schema, table).await,
+        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => {
+            db::questdb::list_indexes(p, schema, table).await
+        }
+        PoolKind::Postgres(p) => db::postgres::list_indexes(p, schema, table).await,
+        PoolKind::Sqlite(p) => db::sqlite::list_indexes(p, schema, table).await,
+        PoolKind::Rqlite(client) => db::rqlite_driver::list_indexes(client, schema, table).await,
+        PoolKind::Turso(client) => db::turso_driver::list_indexes(client, schema, table).await,
+        PoolKind::MongoDb(client) => db::mongo_driver::list_indexes(client, database, table).await,
+        PoolKind::ClickHouse(client) => {
+            db::clickhouse_driver::list_indexes(client, clickhouse_metadata_database(database, schema), table).await
+        }
+        _ => Ok(vec![]),
+    }
+}
+
+pub(in crate::schema) async fn list_foreign_keys(
+    pool: &PoolKind,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::ForeignKeyInfo>, String> {
+    match pool {
+        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
+            db::ob_oracle::list_foreign_keys(p, schema, table).await
+        }
+        PoolKind::Mysql(p, _) => db::mysql::list_foreign_keys(p, schema, table).await,
+        PoolKind::Postgres(p) => db::postgres::list_foreign_keys(p, schema, table).await,
+        PoolKind::Sqlite(p) => db::sqlite::list_foreign_keys(p, schema, table).await,
+        PoolKind::Rqlite(client) => db::rqlite_driver::list_foreign_keys(client, schema, table).await,
+        PoolKind::Turso(client) => db::turso_driver::list_foreign_keys(client, schema, table).await,
+        _ => Ok(vec![]),
+    }
+}
+
+pub(in crate::schema) async fn list_triggers(
+    pool: &PoolKind,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::TriggerInfo>, String> {
+    match pool {
+        PoolKind::Mysql(p, mode) if *mode == MysqlMode::OceanBaseOracle => {
+            db::ob_oracle::list_triggers(p, schema, table).await
+        }
+        PoolKind::Mysql(p, _) => db::mysql::list_triggers(p, schema, table).await,
+        PoolKind::Postgres(p) => db::postgres::list_triggers(p, schema, table).await,
+        PoolKind::Sqlite(p) => db::sqlite::list_triggers(p, schema, table).await,
+        PoolKind::Rqlite(client) => db::rqlite_driver::list_triggers(client, schema, table).await,
+        PoolKind::Turso(client) => db::turso_driver::list_triggers(client, schema, table).await,
+        _ => Ok(vec![]),
+    }
+}
+
+pub(in crate::schema) async fn table_ddl(
+    pool: &PoolKind,
+    config: Option<&ConnectionConfig>,
+    schema: &str,
+    table: &str,
+) -> Result<String, String> {
+    match pool {
+        PoolKind::Mysql(p, _) => super::super::mysql_ddl(p, schema, table).await,
+        PoolKind::Postgres(p) if config.is_some_and(is_opengauss_family_config) => {
+            match super::super::opengauss_table_ddl(p, schema, table).await {
+                Ok(ddl) => Ok(ddl),
+                Err(_) => super::super::pg_ddl(p, schema, table).await,
+            }
+        }
+        PoolKind::Postgres(p) if config.is_some_and(is_questdb_config) => {
+            match db::questdb::questdb_table_or_view_ddl(p, table).await {
+                Ok(ddl) => Ok(ddl),
+                Err(_) => super::super::pg_ddl(p, schema, table).await,
+            }
+        }
+        PoolKind::Postgres(p) => super::super::pg_ddl(p, schema, table).await,
+        PoolKind::Sqlite(p) => super::super::sqlite_ddl(p, table).await,
+        PoolKind::Rqlite(client) => db::rqlite_driver::table_ddl(client, table).await,
+        PoolKind::Turso(client) => db::turso_driver::table_ddl(client, table).await,
+        _ => Err("DDL not supported for this database type".to_string()),
+    }
+}
+
+pub(in crate::schema) async fn object_source(
+    pool: &PoolKind,
+    database: &str,
+    schema: &str,
+    name: &str,
+    object_type: &db::ObjectSourceKind,
+) -> Result<Option<String>, String> {
+    match pool {
+        PoolKind::Mysql(pool, _) => super::super::mysql_object_source(
+            pool,
+            super::super::mysql_table_metadata_catalog(database, schema),
+            name,
+            object_type,
+        )
+        .await
+        .map(Some),
+        PoolKind::Postgres(pool) => {
+            super::super::postgres_object_source(pool, schema, name, object_type).await.map(Some)
+        }
+        PoolKind::Sqlite(pool) => {
+            let source = super::super::first_string_cell(
+                db::sqlite::execute_query(pool, &super::super::sqlite_object_source_sql(name, object_type)).await?,
+            )?;
+            Ok(Some(source))
+        }
+        PoolKind::Rqlite(client) => {
+            db::rqlite_driver::object_source(client, name, object_type).await.map(|source| Some(source.source))
+        }
+        PoolKind::Turso(client) => {
+            db::turso_driver::object_source(client, name, object_type).await.map(|source| Some(source.source))
+        }
+        PoolKind::ClickHouse(client) if matches!(object_type, db::ObjectSourceKind::View) => {
+            let result = db::clickhouse_driver::execute_query(
+                client,
+                database,
+                &format!("SHOW CREATE TABLE {}", super::super::mysql_ident(name)),
+            )
+            .await?;
+            super::super::first_string_cell(result).map(Some)
+        }
+        _ => Ok(None),
+    }
+}
+
+fn collection_names_to_tables(names: Vec<String>, table_type: &str) -> Vec<db::TableInfo> {
+    names
+        .into_iter()
+        .map(|name| db::TableInfo {
+            name,
+            table_type: table_type.to_string(),
+            comment: None,
+            parent_schema: None,
+            parent_name: None,
+        })
+        .collect()
+}
+
+fn clickhouse_metadata_database<'a>(database: &'a str, schema: &'a str) -> &'a str {
+    if database.is_empty() {
+        schema
+    } else {
+        database
+    }
+}
+
+fn is_opengauss_family_config(config: &ConnectionConfig) -> bool {
+    matches!(config.db_type, DatabaseType::OpenGauss | DatabaseType::Gaussdb)
+        || matches!(config.driver_profile.as_deref(), Some("opengauss" | "gaussdb"))
+}
+
+fn is_doris_family_config(config: &ConnectionConfig) -> bool {
+    matches!(config.db_type, DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::ManticoreSearch)
+        || matches!(config.driver_profile.as_deref(), Some("doris" | "selectdb" | "starrocks" | "manticoresearch"))
+}
+
+fn is_manticoresearch_config(config: &ConnectionConfig) -> bool {
+    matches!(config.db_type, DatabaseType::ManticoreSearch)
+        || matches!(config.driver_profile.as_deref(), Some("manticoresearch"))
+}
+
+fn mysql_show_metadata_database_for_config<'a>(
+    config: Option<&ConnectionConfig>,
+    database: &'a str,
+) -> &'a str {
+    if config.is_some_and(is_manticoresearch_config) {
+        ""
+    } else {
+        database
+    }
+}
+
+fn filter_mysql_system_databases_for_config(
+    databases: Vec<db::DatabaseInfo>,
+    config: Option<&ConnectionConfig>,
+) -> Vec<db::DatabaseInfo> {
+    if !config.is_some_and(is_manticoresearch_config) {
+        return databases;
+    }
+
+    databases.into_iter().filter(|database| !is_mysql_system_database(&database.name)).collect()
+}
+
+fn is_mysql_system_database(name: &str) -> bool {
+    matches!(name.to_ascii_lowercase().as_str(), "information_schema" | "mysql" | "performance_schema" | "sys")
+}
+
+fn is_questdb_config(config: &ConnectionConfig) -> bool {
+    matches!(config.db_type, DatabaseType::Questdb)
+        || matches!(config.driver_profile.as_deref(), Some("questdb"))
+}
diff --git a/crates/dbx-core/src/schema_diff.rs b/crates/dbx-core/src/schema_diff.rs
new file mode 100644
index 0000000..71795dd
--- /dev/null
+++ b/crates/dbx-core/src/schema_diff.rs
@@ -0,0 +1,2140 @@
+use std::collections::{HashMap, HashSet};
+
+use serde::{Deserialize, Serialize};
+
+use crate::models::connection::DatabaseType;
+use crate::types::{
+    ColumnInfo, ForeignKeyInfo, FunctionInfo, IndexInfo, OwnerInfo, RuleInfo, SequenceInfo, TableInfo, TriggerInfo,
+};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ColumnDiff {
+    #[serde(rename = "type")]
+    pub diff_type: String,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<ColumnInfo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target: Option<ColumnInfo>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub changes: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IndexDiff {
+    #[serde(rename = "type")]
+    pub diff_type: String,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<IndexInfo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target: Option<IndexInfo>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub changes: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ForeignKeyDiff {
+    #[serde(rename = "type")]
+    pub diff_type: String,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<ForeignKeyInfo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target: Option<ForeignKeyInfo>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub changes: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TriggerDiff {
+    #[serde(rename = "type")]
+    pub diff_type: String,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<TriggerInfo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target: Option<TriggerInfo>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub changes: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FunctionDiff {
+    #[serde(rename = "type")]
+    pub diff_type: String,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<FunctionInfo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target: Option<FunctionInfo>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub changes: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SequenceDiff {
+    #[serde(rename = "type")]
+    pub diff_type: String,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<SequenceInfo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target: Option<SequenceInfo>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub changes: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RuleDiff {
+    #[serde(rename = "type")]
+    pub diff_type: String,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<RuleInfo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target: Option<RuleInfo>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub changes: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OwnerDiff {
+    #[serde(rename = "type")]
+    pub diff_type: String,
+    pub object_name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source: Option<OwnerInfo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target: Option<OwnerInfo>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub changes: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableDiff {
+    #[serde(rename = "type")]
+    pub diff_type: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub object_type: Option<String>,
+    pub name: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub columns: Option<Vec<ColumnDiff>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub indexes: Option<Vec<IndexDiff>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub foreign_keys: Option<Vec<ForeignKeyDiff>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub triggers: Option<Vec<TriggerDiff>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ddl: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target_ddl: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source_table_comment: Option<Option<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub target_table_comment: Option<Option<String>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sync_sql: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableSchemaDetail {
+    pub name: String,
+    #[serde(default)]
+    pub columns: Vec<ColumnInfo>,
+    #[serde(default)]
+    pub indexes: Vec<IndexInfo>,
+    #[serde(default)]
+    pub foreign_keys: Vec<ForeignKeyInfo>,
+    #[serde(default)]
+    pub triggers: Vec<TriggerInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ddl: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SchemaDiffPreparationOptions {
+    #[serde(default)]
+    pub source_tables: Vec<TableInfo>,
+    #[serde(default)]
+    pub target_tables: Vec<TableInfo>,
+    #[serde(default)]
+    pub source_details: Vec<TableSchemaDetail>,
+    #[serde(default)]
+    pub target_details: Vec<TableSchemaDetail>,
+    #[serde(default)]
+    pub source_functions: Vec<FunctionInfo>,
+    #[serde(default)]
+    pub target_functions: Vec<FunctionInfo>,
+    #[serde(default)]
+    pub source_sequences: Vec<SequenceInfo>,
+    #[serde(default)]
+    pub target_sequences: Vec<SequenceInfo>,
+    #[serde(default)]
+    pub source_rules: Vec<RuleInfo>,
+    #[serde(default)]
+    pub target_rules: Vec<RuleInfo>,
+    #[serde(default)]
+    pub source_owners: Vec<OwnerInfo>,
+    #[serde(default)]
+    pub target_owners: Vec<OwnerInfo>,
+    pub database_type: DatabaseType,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub target_schema: Option<String>,
+    #[serde(default)]
+    pub ignore_comments: bool,
+    #[serde(default)]
+    pub cascade_delete: bool,
+    #[serde(default)]
+    pub compare_column_order: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SchemaDiffPreparation {
+    pub diffs: Vec<TableDiff>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub function_diffs: Vec<FunctionDiff>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub sequence_diffs: Vec<SequenceDiff>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub rule_diffs: Vec<RuleDiff>,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub owner_diffs: Vec<OwnerDiff>,
+    pub sync_sql: String,
+}
+
+pub fn prepare_schema_diff(options: SchemaDiffPreparationOptions) -> SchemaDiffPreparation {
+    let mut diffs = diff_schema(&options);
+    let function_diffs = diff_functions(&options.source_functions, &options.target_functions);
+    let sequence_diffs = diff_sequences(&options.source_sequences, &options.target_sequences);
+    let rule_diffs = diff_rules(&options.source_rules, &options.target_rules);
+    let owner_diffs = diff_owners(&options.source_owners, &options.target_owners);
+    for diff in &mut diffs {
+        let sync_sql = generate_schema_sync_sql(
+            std::slice::from_ref(diff),
+            &[],
+            &[],
+            &[],
+            &[],
+            options.database_type,
+            options.target_schema.as_deref(),
+            options.cascade_delete,
+        );
+        if !sync_sql.is_empty() {
+            diff.sync_sql = Some(sync_sql);
+        }
+    }
+    let sync_sql = generate_schema_sync_sql(
+        &diffs,
+        &function_diffs,
+        &sequence_diffs,
+        &rule_diffs,
+        &owner_diffs,
+        options.database_type,
+        options.target_schema.as_deref(),
+        options.cascade_delete,
+    );
+    SchemaDiffPreparation { diffs, function_diffs, sequence_diffs, rule_diffs, owner_diffs, sync_sql }
+}
+
+fn diff_schema(options: &SchemaDiffPreparationOptions) -> Vec<TableDiff> {
+    let source_details: HashMap<&str, &TableSchemaDetail> =
+        options.source_details.iter().map(|detail| (detail.name.as_str(), detail)).collect();
+    let target_details: HashMap<&str, &TableSchemaDetail> =
+        options.target_details.iter().map(|detail| (detail.name.as_str(), detail)).collect();
+    let source_table_comments: HashMap<&str, Option<String>> =
+        options.source_tables.iter().map(|table| (table.name.as_str(), table.comment.clone())).collect();
+    let target_table_comments: HashMap<&str, Option<String>> =
+        options.target_tables.iter().map(|table| (table.name.as_str(), table.comment.clone())).collect();
+
+    let source_table_names: Vec<String> = options
+        .source_tables
+        .iter()
+        .filter(|table| !table.table_type.contains("VIEW"))
+        .map(|table| table.name.clone())
+        .collect();
+    let target_table_names: Vec<String> = options
+        .target_tables
+        .iter()
+        .filter(|table| !table.table_type.contains("VIEW"))
+        .map(|table| table.name.clone())
+        .collect();
+    let source_view_names: Vec<String> = options
+        .source_tables
+        .iter()
+        .filter(|table| table.table_type.contains("VIEW"))
+        .map(|table| table.name.clone())
+        .collect();
+    let target_view_names: Vec<String> = options
+        .target_tables
+        .iter()
+        .filter(|table| table.table_type.contains("VIEW"))
+        .map(|table| table.name.clone())
+        .collect();
+
+    let (added, removed, common) = diff_names(&source_table_names, &target_table_names);
+    let (added_views, removed_views, _) = diff_names(&source_view_names, &target_view_names);
+    let mut result = Vec::new();
+
+    for name in added {
+        result.push(TableDiff {
+            diff_type: "added".to_string(),
+            object_type: Some("table".to_string()),
+            ddl: source_details.get(name.as_str()).and_then(|detail| detail.ddl.clone()),
+            target_ddl: None,
+            name,
+            columns: None,
+            indexes: None,
+            foreign_keys: None,
+            triggers: None,
+            source_table_comment: None,
+            target_table_comment: None,
+            sync_sql: None,
+        });
+    }
+
+    for name in removed {
+        let name_clone = name.clone();
+        result.push(TableDiff {
+            diff_type: "removed".to_string(),
+            object_type: Some("table".to_string()),
+            name,
+            columns: None,
+            indexes: None,
+            foreign_keys: None,
+            triggers: None,
+            ddl: None,
+            target_ddl: target_details.get(name_clone.as_str()).and_then(|detail| detail.ddl.clone()),
+            source_table_comment: None,
+            target_table_comment: None,
+            sync_sql: None,
+        });
+    }
+
+    for name in added_views {
+        let name_clone = name.clone();
+        result.push(TableDiff {
+            diff_type: "added".to_string(),
+            object_type: Some("view".to_string()),
+            name,
+            columns: None,
+            indexes: None,
+            foreign_keys: None,
+            triggers: None,
+            ddl: source_details.get(name_clone.as_str()).and_then(|detail| detail.ddl.clone()),
+            target_ddl: None,
+            source_table_comment: None,
+            target_table_comment: None,
+            sync_sql: None,
+        });
+    }
+
+    for name in removed_views {
+        let name_clone = name.clone();
+        result.push(TableDiff {
+            diff_type: "removed".to_string(),
+            object_type: Some("view".to_string()),
+            name,
+            columns: None,
+            indexes: None,
+            foreign_keys: None,
+            triggers: None,
+            ddl: None,
+            target_ddl: target_details.get(name_clone.as_str()).and_then(|detail| detail.ddl.clone()),
+            source_table_comment: None,
+            target_table_comment: None,
+            sync_sql: None,
+        });
+    }
+
+    for name in common {
+        let Some(source) = source_details.get(name.as_str()) else { continue };
+        let Some(target) = target_details.get(name.as_str()) else { continue };
+        let column_diffs = diff_columns_with_options(
+            &source.columns,
+            &target.columns,
+            ColumnDiffOptions {
+                ignore_comments: options.ignore_comments,
+                compare_column_order: options.compare_column_order,
+                case_insensitive_names: column_names_are_case_insensitive(options.database_type),
+            },
+        );
+        let index_diffs = diff_indexes(&source.indexes, &target.indexes);
+        let foreign_key_diffs = diff_foreign_keys(&source.foreign_keys, &target.foreign_keys);
+        let trigger_diffs = diff_triggers(&source.triggers, &target.triggers);
+        let source_comment = source_table_comments.get(name.as_str()).cloned().unwrap_or(None);
+        let target_comment = target_table_comments.get(name.as_str()).cloned().unwrap_or(None);
+        let comment_changed = !options.ignore_comments
+            && source_comment.clone().unwrap_or_default() != target_comment.clone().unwrap_or_default();
+
+        let has_diff = !column_diffs.is_empty()
+            || !index_diffs.is_empty()
+            || !foreign_key_diffs.is_empty()
+            || !trigger_diffs.is_empty()
+            || comment_changed;
+
+        let name_clone = name.clone();
+        result.push(TableDiff {
+            diff_type: if has_diff { "modified".to_string() } else { "none".to_string() },
+            object_type: Some("table".to_string()),
+            name,
+            columns: if has_diff { (!column_diffs.is_empty()).then_some(column_diffs) } else { None },
+            indexes: if has_diff { (!index_diffs.is_empty()).then_some(index_diffs) } else { None },
+            foreign_keys: if has_diff { (!foreign_key_diffs.is_empty()).then_some(foreign_key_diffs) } else { None },
+            triggers: if has_diff { (!trigger_diffs.is_empty()).then_some(trigger_diffs) } else { None },
+            ddl: source_details.get(name_clone.as_str()).and_then(|detail| detail.ddl.clone()),
+            target_ddl: target_details.get(name_clone.as_str()).and_then(|detail| detail.ddl.clone()),
+            source_table_comment: if has_diff { comment_changed.then_some(source_comment) } else { None },
+            target_table_comment: if has_diff { comment_changed.then_some(target_comment) } else { None },
+            sync_sql: None,
+        });
+    }
+
+    result.retain(|diff| diff.diff_type != "none");
+    result
+}
+
+fn diff_names(source: &[String], target: &[String]) -> (Vec<String>, Vec<String>, Vec<String>) {
+    let source_set: HashSet<&str> = source.iter().map(String::as_str).collect();
+    let target_set: HashSet<&str> = target.iter().map(String::as_str).collect();
+    (
+        source.iter().filter(|name| !target_set.contains(name.as_str())).cloned().collect(),
+        target.iter().filter(|name| !source_set.contains(name.as_str())).cloned().collect(),
+        source.iter().filter(|name| target_set.contains(name.as_str())).cloned().collect(),
+    )
+}
+
+pub fn diff_columns(source: &[ColumnInfo], target: &[ColumnInfo]) -> Vec<ColumnDiff> {
+    diff_columns_with_options(source, target, ColumnDiffOptions::default())
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+struct ColumnDiffOptions {
+    ignore_comments: bool,
+    compare_column_order: bool,
+    case_insensitive_names: bool,
+}
+
+fn diff_columns_with_options(
+    source: &[ColumnInfo],
+    target: &[ColumnInfo],
+    options: ColumnDiffOptions,
+) -> Vec<ColumnDiff> {
+    let mut diffs = Vec::new();
+    let target_map: HashMap<String, &ColumnInfo> = target
+        .iter()
+        .map(|column| (column_name_match_key(&column.name, options.case_insensitive_names), column))
+        .collect();
+    let source_map: HashMap<String, &ColumnInfo> = source
+        .iter()
+        .map(|column| (column_name_match_key(&column.name, options.case_insensitive_names), column))
+        .collect();
+    let target_position_map: HashMap<&str, usize> =
+        target.iter().enumerate().map(|(index, column)| (column.name.as_str(), index)).collect();
+    let target_normalized_position_map: HashMap<String, usize> = target
+        .iter()
+        .enumerate()
+        .map(|(index, column)| (column_name_match_key(&column.name, options.case_insensitive_names), index))
+        .collect();
+    let can_compare_order = options.compare_column_order
+        && source.len() == target.len()
+        && source.iter().all(|column| {
+            target_map.contains_key(&column_name_match_key(&column.name, options.case_insensitive_names))
+        });
+
+    for (source_index, source_column) in source.iter().enumerate() {
+        let source_name_key = column_name_match_key(&source_column.name, options.case_insensitive_names);
+        if let Some(target_column) = target_map.get(&source_name_key) {
+            let mut changes = Vec::new();
+            if options.case_insensitive_names && source_column.name != target_column.name {
+                changes.push(format!("name: {} → {}", target_column.name, source_column.name));
+            }
+            if source_column.data_type.to_lowercase() != target_column.data_type.to_lowercase() {
+                changes.push(format!("type: {} → {}", target_column.data_type, source_column.data_type));
+            }
+            if source_column.is_nullable != target_column.is_nullable {
+                changes.push(format!(
+                    "nullable: {} → {}",
+                    if target_column.is_nullable { "YES" } else { "NO" },
+                    if source_column.is_nullable { "YES" } else { "NO" }
+                ));
+            }
+            if source_column.column_default.as_deref().unwrap_or_default()
+                != target_column.column_default.as_deref().unwrap_or_default()
+            {
+                changes.push(format!(
+                    "default: {} → {}",
+                    target_column.column_default.as_deref().unwrap_or("NULL"),
+                    source_column.column_default.as_deref().unwrap_or("NULL")
+                ));
+            }
+            if !options.ignore_comments
+                && source_column.comment.as_deref().unwrap_or_default()
+                    != target_column.comment.as_deref().unwrap_or_default()
+            {
+                changes.push(format!(
+                    "comment: {} → {}",
+                    target_column.comment.as_deref().unwrap_or_default(),
+                    source_column.comment.as_deref().unwrap_or_default()
+                ));
+            }
+            if can_compare_order {
+                let target_index = if options.case_insensitive_names {
+                    target_normalized_position_map.get(&source_name_key)
+                } else {
+                    target_position_map.get(source_column.name.as_str())
+                };
+                if let Some(target_index) = target_index {
+                    if source_index != *target_index {
+                        changes.push(format!("order: {} → {}", *target_index + 1, source_index + 1));
+                    }
+                }
+            }
+            if !changes.is_empty() {
+                diffs.push(ColumnDiff {
+                    diff_type: "modified".to_string(),
+                    name: source_column.name.clone(),
+                    source: Some(source_column.clone()),
+                    target: Some((*target_column).clone()),
+                    changes,
+                });
+            }
+        } else {
+            diffs.push(ColumnDiff {
+                diff_type: "added".to_string(),
+                name: source_column.name.clone(),
+                source: Some(source_column.clone()),
+                target: None,
+                changes: Vec::new(),
+            });
+        }
+    }
+
+    for target_column in target {
+        if !source_map.contains_key(&column_name_match_key(&target_column.name, options.case_insensitive_names)) {
+            diffs.push(ColumnDiff {
+                diff_type: "removed".to_string(),
+                name: target_column.name.clone(),
+                source: None,
+                target: Some(target_column.clone()),
+                changes: Vec::new(),
+            });
+        }
+    }
+
+    diffs
+}
+
+fn column_name_match_key(name: &str, case_insensitive: bool) -> String {
+    if case_insensitive {
+        name.to_ascii_lowercase()
+    } else {
+        name.to_string()
+    }
+}
+
+fn column_names_are_case_insensitive(db_type: DatabaseType) -> bool {
+    // MySQL documents column identifiers as case-insensitive on every platform; exact matching would turn
+    // a case-only rename into a destructive add/drop plan.
+    matches!(db_type, DatabaseType::Mysql)
+}
+
+pub fn diff_indexes(source: &[IndexInfo], target: &[IndexInfo]) -> Vec<IndexDiff> {
+    let mut diffs = Vec::new();
+    let target_map: HashMap<&str, &IndexInfo> = target.iter().map(|index| (index.name.as_str(), index)).collect();
+    let source_map: HashMap<&str, &IndexInfo> = source.iter().map(|index| (index.name.as_str(), index)).collect();
+
+    for source_index in source {
+        if source_index.is_primary {
+            continue;
+        }
+        let Some(target_index) = target_map.get(source_index.name.as_str()) else {
+            diffs.push(IndexDiff {
+                diff_type: "added".to_string(),
+                name: source_index.name.clone(),
+                source: Some(source_index.clone()),
+                target: None,
+                changes: Vec::new(),
+            });
+            continue;
+        };
+
+        let mut changes = Vec::new();
+        if source_index.is_unique != target_index.is_unique {
+            changes.push(format!(
+                "unique: {} → {}",
+                if target_index.is_unique { "YES" } else { "NO" },
+                if source_index.is_unique { "YES" } else { "NO" }
+            ));
+        }
+        if source_index.columns.join(",") != target_index.columns.join(",") {
+            changes.push(format!("columns: {} → {}", target_index.columns.join(", "), source_index.columns.join(", ")));
+        }
+        if source_index.index_type.as_deref().unwrap_or_default()
+            != target_index.index_type.as_deref().unwrap_or_default()
+        {
+            changes.push(format!(
+                "type: {} → {}",
+                target_index.index_type.as_deref().unwrap_or("default"),
+                source_index.index_type.as_deref().unwrap_or("default")
+            ));
+        }
+        if source_index.filter.as_deref().unwrap_or_default() != target_index.filter.as_deref().unwrap_or_default() {
+            changes.push(format!(
+                "filter: {} → {}",
+                target_index.filter.as_deref().unwrap_or("none"),
+                source_index.filter.as_deref().unwrap_or("none")
+            ));
+        }
+        let source_included = source_index.included_columns.clone().unwrap_or_default();
+        let target_included = target_index.included_columns.clone().unwrap_or_default();
+        if source_included.join(",") != target_included.join(",") {
+            changes.push(format!(
+                "include: {} → {}",
+                if target_included.is_empty() { "none".to_string() } else { target_included.join(", ") },
+                if source_included.is_empty() { "none".to_string() } else { source_included.join(", ") }
+            ));
+        }
+        if !changes.is_empty() {
+            diffs.push(IndexDiff {
+                diff_type: "modified".to_string(),
+                name: source_index.name.clone(),
+                source: Some(source_index.clone()),
+                target: Some((*target_index).clone()),
+                changes,
+            });
+        }
+    }
+
+    for target_index in target {
+        if target_index.is_primary {
+            continue;
+        }
+        if !source_map.contains_key(target_index.name.as_str()) {
+            diffs.push(IndexDiff {
+                diff_type: "removed".to_string(),
+                name: target_index.name.clone(),
+                source: None,
+                target: Some(target_index.clone()),
+                changes: Vec::new(),
+            });
+        }
+    }
+
+    diffs
+}
+
+pub fn diff_foreign_keys(source: &[ForeignKeyInfo], target: &[ForeignKeyInfo]) -> Vec<ForeignKeyDiff> {
+    let mut diffs = Vec::new();
+    let target_map: HashMap<&str, &ForeignKeyInfo> = target.iter().map(|fk| (fk.name.as_str(), fk)).collect();
+    let source_map: HashMap<&str, &ForeignKeyInfo> = source.iter().map(|fk| (fk.name.as_str(), fk)).collect();
+
+    for source_fk in source {
+        let Some(target_fk) = target_map.get(source_fk.name.as_str()) else {
+            diffs.push(ForeignKeyDiff {
+                diff_type: "added".to_string(),
+                name: source_fk.name.clone(),
+                source: Some(source_fk.clone()),
+                target: None,
+                changes: Vec::new(),
+            });
+            continue;
+        };
+
+        let mut changes = Vec::new();
+        if source_fk.column != target_fk.column {
+            changes.push(format!("column: {} → {}", target_fk.column, source_fk.column));
+        }
+        if source_fk.ref_table != target_fk.ref_table {
+            changes.push(format!("ref table: {} → {}", target_fk.ref_table, source_fk.ref_table));
+        }
+        if source_fk.ref_schema != target_fk.ref_schema {
+            changes.push(format!(
+                "ref schema: {} → {}",
+                target_fk.ref_schema.as_deref().unwrap_or(""),
+                source_fk.ref_schema.as_deref().unwrap_or("")
+            ));
+        }
+        if source_fk.ref_column != target_fk.ref_column {
+            changes.push(format!("ref column: {} → {}", target_fk.ref_column, source_fk.ref_column));
+        }
+        if !changes.is_empty() {
+            diffs.push(ForeignKeyDiff {
+                diff_type: "modified".to_string(),
+                name: source_fk.name.clone(),
+                source: Some(source_fk.clone()),
+                target: Some((*target_fk).clone()),
+                changes,
+            });
+        }
+    }
+
+    for target_fk in target {
+        if !source_map.contains_key(target_fk.name.as_str()) {
+            diffs.push(ForeignKeyDiff {
+                diff_type: "removed".to_string(),
+                name: target_fk.name.clone(),
+                source: None,
+                target: Some(target_fk.clone()),
+                changes: Vec::new(),
+            });
+        }
+    }
+
+    diffs
+}
+
+pub fn diff_triggers(source: &[TriggerInfo], target: &[TriggerInfo]) -> Vec<TriggerDiff> {
+    let mut diffs = Vec::new();
+    let target_map: HashMap<&str, &TriggerInfo> =
+        target.iter().map(|trigger| (trigger.name.as_str(), trigger)).collect();
+    let source_map: HashMap<&str, &TriggerInfo> =
+        source.iter().map(|trigger| (trigger.name.as_str(), trigger)).collect();
+
+    for source_trigger in source {
+        let Some(target_trigger) = target_map.get(source_trigger.name.as_str()) else {
+            diffs.push(TriggerDiff {
+                diff_type: "added".to_string(),
+                name: source_trigger.name.clone(),
+                source: Some(source_trigger.clone()),
+                target: None,
+                changes: Vec::new(),
+            });
+            continue;
+        };
+
+        let mut changes = Vec::new();
+        if source_trigger.event != target_trigger.event {
+            changes.push(format!("event: {} → {}", target_trigger.event, source_trigger.event));
+        }
+        if source_trigger.timing != target_trigger.timing {
+            changes.push(format!("timing: {} → {}", target_trigger.timing, source_trigger.timing));
+        }
+        if !changes.is_empty() {
+            diffs.push(TriggerDiff {
+                diff_type: "modified".to_string(),
+                name: source_trigger.name.clone(),
+                source: Some(source_trigger.clone()),
+                target: Some((*target_trigger).clone()),
+                changes,
+            });
+        }
+    }
+
+    for target_trigger in target {
+        if !source_map.contains_key(target_trigger.name.as_str()) {
+            diffs.push(TriggerDiff {
+                diff_type: "removed".to_string(),
+                name: target_trigger.name.clone(),
+                source: None,
+                target: Some(target_trigger.clone()),
+                changes: Vec::new(),
+            });
+        }
+    }
+
+    diffs
+}
+
+fn is_mysql_like(db_type: DatabaseType) -> bool {
+    matches!(
+        db_type,
+        DatabaseType::Mysql
+            | DatabaseType::Doris
+            | DatabaseType::StarRocks
+            | DatabaseType::Goldendb
+            | DatabaseType::Sundb
+            | DatabaseType::Databend
+            | DatabaseType::Gbase
+    )
+}
+
+/// Normalize a function definition for comparison by:
+/// - Converting CRLF to LF
+/// - Collapsing all whitespace (tabs, multiple spaces) to single spaces
+/// - Trimming each line and rejoining
+fn normalize_definition(def: &str) -> String {
+    def.replace("\r\n", "\n")
+        .split('\n')
+        .map(|line| line.split_whitespace().collect::<Vec<_>>().join(" "))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+pub fn diff_functions(source: &[FunctionInfo], target: &[FunctionInfo]) -> Vec<FunctionDiff> {
+    let mut diffs = Vec::new();
+    // Use (name, arguments) as key to support PostgreSQL function overloading
+    let target_map: HashMap<(&str, &str), &FunctionInfo> =
+        target.iter().map(|f| ((f.name.as_str(), f.arguments.as_str()), f)).collect();
+    let source_map: HashMap<(&str, &str), &FunctionInfo> =
+        source.iter().map(|f| ((f.name.as_str(), f.arguments.as_str()), f)).collect();
+
+    for source_fn in source {
+        let key = (source_fn.name.as_str(), source_fn.arguments.as_str());
+        let Some(target_fn) = target_map.get(&key) else {
+            diffs.push(FunctionDiff {
+                diff_type: "added".to_string(),
+                name: source_fn.name.clone(),
+                source: Some(source_fn.clone()),
+                target: None,
+                changes: Vec::new(),
+            });
+            continue;
+        };
+
+        let mut changes = Vec::new();
+        if source_fn.function_type != target_fn.function_type {
+            changes.push(format!("type: {} → {}", target_fn.function_type, source_fn.function_type));
+        }
+        if source_fn.data_type != target_fn.data_type {
+            changes.push(format!("return type: {} → {}", target_fn.data_type, source_fn.data_type));
+        }
+        if normalize_definition(&source_fn.definition) != normalize_definition(&target_fn.definition) {
+            changes.push("definition changed".to_string());
+        }
+        if !changes.is_empty() {
+            diffs.push(FunctionDiff {
+                diff_type: "modified".to_string(),
+                name: source_fn.name.clone(),
+                source: Some(source_fn.clone()),
+                target: Some((*target_fn).clone()),
+                changes,
+            });
+        }
+    }
+
+    for target_fn in target {
+        let key = (target_fn.name.as_str(), target_fn.arguments.as_str());
+        if !source_map.contains_key(&key) {
+            diffs.push(FunctionDiff {
+                diff_type: "removed".to_string(),
+                name: target_fn.name.clone(),
+                source: None,
+                target: Some(target_fn.clone()),
+                changes: Vec::new(),
+            });
+        }
+    }
+
+    diffs
+}
+
+pub fn diff_sequences(source: &[SequenceInfo], target: &[SequenceInfo]) -> Vec<SequenceDiff> {
+    let mut diffs = Vec::new();
+    let target_map: HashMap<&str, &SequenceInfo> = target.iter().map(|s| (s.name.as_str(), s)).collect();
+    let source_map: HashMap<&str, &SequenceInfo> = source.iter().map(|s| (s.name.as_str(), s)).collect();
+
+    for source_seq in source {
+        let Some(target_seq) = target_map.get(source_seq.name.as_str()) else {
+            diffs.push(SequenceDiff {
+                diff_type: "added".to_string(),
+                name: source_seq.name.clone(),
+                source: Some(source_seq.clone()),
+                target: None,
+                changes: Vec::new(),
+            });
+            continue;
+        };
+
+        let mut changes = Vec::new();
+        if source_seq.data_type != target_seq.data_type {
+            changes.push(format!("data_type: {} → {}", target_seq.data_type, source_seq.data_type));
+        }
+        if source_seq.start_value != target_seq.start_value {
+            changes.push(format!("start: {} → {}", target_seq.start_value, source_seq.start_value));
+        }
+        if source_seq.min_value != target_seq.min_value {
+            changes.push(format!("min: {} → {}", target_seq.min_value, source_seq.min_value));
+        }
+        if source_seq.max_value != target_seq.max_value {
+            changes.push(format!("max: {} → {}", target_seq.max_value, source_seq.max_value));
+        }
+        if source_seq.increment != target_seq.increment {
+            changes.push(format!("increment: {} → {}", target_seq.increment, source_seq.increment));
+        }
+        if source_seq.cycle != target_seq.cycle {
+            changes.push(format!("cycle: {} → {}", target_seq.cycle, source_seq.cycle));
+        }
+        // Only compare last_value when both sides successfully retrieved it.
+        // Avoid false positives when one side lacks permission (returns None).
+        if let (Some(s), Some(t)) = (&source_seq.last_value, &target_seq.last_value) {
+            if s != t {
+                changes.push(format!("last_value: {} → {}", t, s));
+            }
+        }
+        if !changes.is_empty() {
+            diffs.push(SequenceDiff {
+                diff_type: "modified".to_string(),
+                name: source_seq.name.clone(),
+                source: Some(source_seq.clone()),
+                target: Some((*target_seq).clone()),
+                changes,
+            });
+        }
+    }
+
+    for target_seq in target {
+        if !source_map.contains_key(target_seq.name.as_str()) {
+            diffs.push(SequenceDiff {
+                diff_type: "removed".to_string(),
+                name: target_seq.name.clone(),
+                source: None,
+                target: Some(target_seq.clone()),
+                changes: Vec::new(),
+            });
+        }
+    }
+
+    diffs
+}
+
+pub fn diff_rules(source: &[RuleInfo], target: &[RuleInfo]) -> Vec<RuleDiff> {
+    let mut diffs = Vec::new();
+    let target_map: HashMap<&str, &RuleInfo> = target.iter().map(|r| (r.name.as_str(), r)).collect();
+    let source_map: HashMap<&str, &RuleInfo> = source.iter().map(|r| (r.name.as_str(), r)).collect();
+
+    for source_rule in source {
+        let Some(target_rule) = target_map.get(source_rule.name.as_str()) else {
+            diffs.push(RuleDiff {
+                diff_type: "added".to_string(),
+                name: source_rule.name.clone(),
+                source: Some(source_rule.clone()),
+                target: None,
+                changes: Vec::new(),
+            });
+            continue;
+        };
+
+        let mut changes = Vec::new();
+        if source_rule.definition != target_rule.definition {
+            changes.push("definition changed".to_string());
+        }
+        if !changes.is_empty() {
+            diffs.push(RuleDiff {
+                diff_type: "modified".to_string(),
+                name: source_rule.name.clone(),
+                source: Some(source_rule.clone()),
+                target: Some((*target_rule).clone()),
+                changes,
+            });
+        }
+    }
+
+    for target_rule in target {
+        if !source_map.contains_key(target_rule.name.as_str()) {
+            diffs.push(RuleDiff {
+                diff_type: "removed".to_string(),
+                name: target_rule.name.clone(),
+                source: None,
+                target: Some(target_rule.clone()),
+                changes: Vec::new(),
+            });
+        }
+    }
+
+    diffs
+}
+
+pub fn diff_owners(source: &[OwnerInfo], target: &[OwnerInfo]) -> Vec<OwnerDiff> {
+    let mut diffs = Vec::new();
+    let target_map: HashMap<&str, &OwnerInfo> = target.iter().map(|o| (o.object_name.as_str(), o)).collect();
+    let _source_map: HashMap<&str, &OwnerInfo> = source.iter().map(|o| (o.object_name.as_str(), o)).collect();
+
+    for source_owner in source {
+        let Some(target_owner) = target_map.get(source_owner.object_name.as_str()) else {
+            continue; // skip added/removed objects, only compare owners for common objects
+        };
+
+        let mut changes = Vec::new();
+        if source_owner.owner != target_owner.owner {
+            changes.push(format!("owner: {} → {}", target_owner.owner, source_owner.owner));
+        }
+        if !changes.is_empty() {
+            diffs.push(OwnerDiff {
+                diff_type: "modified".to_string(),
+                object_name: source_owner.object_name.clone(),
+                source: Some(source_owner.clone()),
+                target: Some((*target_owner).clone()),
+                changes,
+            });
+        }
+    }
+
+    diffs
+}
+
+fn quote_id(name: &str, db_type: DatabaseType) -> String {
+    if is_mysql_like(db_type) {
+        format!("`{}`", name.replace('`', "``"))
+    } else {
+        format!("\"{}\"", name.replace('"', "\"\""))
+    }
+}
+
+fn mysql_default_value(default: &str, data_type: &str) -> String {
+    let trimmed = default.trim();
+    if is_mysql_default_expression(trimmed) || !is_mysql_string_literal_type(data_type) {
+        return default.to_string();
+    }
+
+    // MySQL metadata returns string defaults as values rather than reusable DDL tokens.
+    let literal = format!("'{}'", default.replace('\'', "''"));
+    if mysql_default_requires_expression(data_type) {
+        format!("({literal})")
+    } else {
+        literal
+    }
+}
+
+fn is_mysql_default_expression(default: &str) -> bool {
+    let upper = default.to_ascii_uppercase();
+    (default.starts_with('(') && default.ends_with(')'))
+        || (default.starts_with('\'') && default.ends_with('\''))
+        || (default.starts_with('"') && default.ends_with('"'))
+        || upper == "NULL"
+        || upper == "CURRENT_TIMESTAMP"
+        || upper.strip_prefix("CURRENT_TIMESTAMP(").is_some_and(|precision| {
+            precision.ends_with(')') && precision[..precision.len() - 1].chars().all(|c| c.is_ascii_digit())
+        })
+        || matches!(upper.as_bytes(), [b'B' | b'X', b'\'', .., b'\''])
+}
+
+fn is_mysql_string_literal_type(data_type: &str) -> bool {
+    let base_type = mysql_base_type(data_type);
+    matches!(
+        base_type.as_str(),
+        "char"
+            | "varchar"
+            | "tinytext"
+            | "text"
+            | "mediumtext"
+            | "longtext"
+            | "tinyblob"
+            | "blob"
+            | "mediumblob"
+            | "longblob"
+            | "binary"
+            | "varbinary"
+            | "enum"
+            | "set"
+            | "date"
+            | "datetime"
+            | "timestamp"
+            | "time"
+            | "year"
+            | "json"
+            | "geometry"
+            | "point"
+            | "linestring"
+            | "polygon"
+            | "multipoint"
+            | "multilinestring"
+            | "multipolygon"
+            | "geometrycollection"
+    )
+}
+
+fn mysql_default_requires_expression(data_type: &str) -> bool {
+    let base_type = mysql_base_type(data_type);
+    matches!(
+        base_type.as_str(),
+        "tinytext"
+            | "text"
+            | "mediumtext"
+            | "longtext"
+            | "tinyblob"
+            | "blob"
+            | "mediumblob"
+            | "longblob"
+            | "json"
+            | "geometry"
+            | "point"
+            | "linestring"
+            | "polygon"
+            | "multipoint"
+            | "multilinestring"
+            | "multipolygon"
+            | "geometrycollection"
+    )
+}
+
+fn mysql_base_type(data_type: &str) -> String {
+    data_type
+        .trim_start()
+        .split(|c: char| c == '(' || c.is_ascii_whitespace())
+        .next()
+        .unwrap_or_default()
+        .to_ascii_lowercase()
+}
+
+fn column_def(col: &ColumnInfo, db_type: DatabaseType) -> String {
+    let mut definition = format!("{} {}", quote_id(&col.name, db_type), col.data_type);
+    if !col.is_nullable {
+        definition.push_str(" NOT NULL");
+    }
+    if let Some(default) = &col.column_default {
+        let default =
+            if db_type == DatabaseType::Mysql { mysql_default_value(default, &col.data_type) } else { default.clone() };
+        definition.push_str(&format!(" DEFAULT {default}"));
+    }
+    if is_mysql_like(db_type) {
+        if let Some(comment) = &col.comment {
+            definition.push_str(&format!(" COMMENT {}", comment_literal(comment)));
+        }
+    }
+    definition
+}
+
+fn qualified_name(name: &str, db_type: DatabaseType, schema: Option<&str>) -> String {
+    schema
+        .map(str::trim)
+        .filter(|schema| !schema.is_empty())
+        .map(|schema| format!("{}.{}", quote_id(schema, db_type), quote_id(name, db_type)))
+        .unwrap_or_else(|| quote_id(name, db_type))
+}
+
+fn drop_index_sql(table_name: &str, index_name: &str, db_type: DatabaseType, schema: Option<&str>) -> String {
+    let table = qualified_name(table_name, db_type, schema);
+    let index = qualified_name(index_name, db_type, schema);
+    if is_mysql_like(db_type) {
+        format!("DROP INDEX {} ON {table};", quote_id(index_name, db_type))
+    } else {
+        format!("DROP INDEX IF EXISTS {index};")
+    }
+}
+
+fn create_index_sql(table_name: &str, index: &IndexInfo, db_type: DatabaseType, schema: Option<&str>) -> String {
+    let table = qualified_name(table_name, db_type, schema);
+    let columns = index.columns.iter().map(|column| quote_id(column, db_type)).collect::<Vec<_>>().join(", ");
+    let unique = if index.is_unique { "UNIQUE " } else { "" };
+    let index_type = index.index_type.as_deref().unwrap_or_default();
+    let using_clause = if !index_type.is_empty() && db_type == DatabaseType::Postgres {
+        format!(" USING {index_type}")
+    } else {
+        String::new()
+    };
+    let type_prefix = if !index_type.is_empty() && db_type == DatabaseType::SqlServer {
+        format!("{index_type} ")
+    } else {
+        String::new()
+    };
+    let mysql_using =
+        if !index_type.is_empty() && is_mysql_like(db_type) { format!(" USING {index_type}") } else { String::new() };
+    let included_columns = index.included_columns.clone().unwrap_or_default();
+    let include_clause =
+        if !included_columns.is_empty() && matches!(db_type, DatabaseType::Postgres | DatabaseType::SqlServer) {
+            format!(
+                " INCLUDE ({})",
+                included_columns.iter().map(|column| quote_id(column, db_type)).collect::<Vec<_>>().join(", ")
+            )
+        } else {
+            String::new()
+        };
+    let supports_where = matches!(db_type, DatabaseType::Postgres | DatabaseType::SqlServer | DatabaseType::Sqlite);
+    let filter = if supports_where { index.filter.as_deref().unwrap_or_default() } else { "" };
+    let filter_clause = if filter.is_empty() { String::new() } else { format!(" WHERE {filter}") };
+    let comment = index.comment.as_deref().unwrap_or("");
+    let comment_clause = if !comment.trim().is_empty() && is_mysql_like(db_type) {
+        format!(" COMMENT {}", comment_literal(comment))
+    } else {
+        String::new()
+    };
+    if is_mysql_like(db_type) {
+        format!(
+            "CREATE {unique}{type_prefix}INDEX {}{mysql_using} ON {table} ({columns}){comment_clause};",
+            quote_id(&index.name, db_type)
+        )
+    } else {
+        format!(
+            "CREATE {unique}{type_prefix}INDEX {} ON {table}{using_clause} ({columns}){include_clause}{filter_clause};",
+            quote_id(&index.name, db_type)
+        )
+    }
+}
+
+fn drop_foreign_key_sql(table_name: &str, fk_name: &str, db_type: DatabaseType, schema: Option<&str>) -> String {
+    let table = qualified_name(table_name, db_type, schema);
+    let fk = quote_id(fk_name, db_type);
+    if is_mysql_like(db_type) {
+        format!("ALTER TABLE {table} DROP FOREIGN KEY {fk};")
+    } else {
+        format!("ALTER TABLE {table} DROP CONSTRAINT {fk};")
+    }
+}
+
+fn add_foreign_key_sql(table_name: &str, fk: &ForeignKeyInfo, db_type: DatabaseType, schema: Option<&str>) -> String {
+    let table = qualified_name(table_name, db_type, schema);
+    format!(
+        "ALTER TABLE {table} ADD CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {} ({});",
+        quote_id(&fk.name, db_type),
+        quote_id(&fk.column, db_type),
+        quote_id(&fk.ref_table, db_type),
+        quote_id(&fk.ref_column, db_type)
+    )
+}
+
+fn drop_object_sql(diff: &TableDiff, db_type: DatabaseType, schema: Option<&str>, cascade: &str) -> String {
+    let object_type = if diff.object_type.as_deref() == Some("view") { "VIEW" } else { "TABLE" };
+    format!("DROP {object_type} IF EXISTS {}{cascade};", qualified_name(&diff.name, db_type, schema))
+}
+
+fn comment_literal(comment: &str) -> String {
+    format!("'{}'", comment.replace('\'', "''"))
+}
+
+fn column_comment_sql(
+    table_name: &str,
+    column_name: &str,
+    comment: &str,
+    db_type: DatabaseType,
+    schema: Option<&str>,
+) -> String {
+    if is_mysql_like(db_type) {
+        return format!(
+            "-- Column comment for {column_name}: use ALTER TABLE ... MODIFY COLUMN to set comment in MySQL"
+        );
+    }
+    let table = qualified_name(table_name, db_type, schema);
+    format!("COMMENT ON COLUMN {table}.{} IS {};", quote_id(column_name, db_type), comment_literal(comment))
+}
+
+fn table_comment_sql(table_name: &str, comment: &str, db_type: DatabaseType, schema: Option<&str>) -> String {
+    let table = qualified_name(table_name, db_type, schema);
+    if is_mysql_like(db_type) {
+        format!("ALTER TABLE {table} COMMENT = {};", comment_literal(comment))
+    } else {
+        format!("COMMENT ON TABLE {table} IS {};", comment_literal(comment))
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn generate_schema_sync_sql(
+    diffs: &[TableDiff],
+    function_diffs: &[FunctionDiff],
+    sequence_diffs: &[SequenceDiff],
+    rule_diffs: &[RuleDiff],
+    owner_diffs: &[OwnerDiff],
+    db_type: DatabaseType,
+    schema: Option<&str>,
+    cascade_delete: bool,
+) -> String {
+    let mut lines = Vec::new();
+    let is_mysql = is_mysql_like(db_type);
+    let cascade = if cascade_delete { " CASCADE" } else { "" };
+
+    for diff in diffs {
+        let table = qualified_name(&diff.name, db_type, schema);
+
+        if diff.diff_type == "added" && diff.ddl.is_some() {
+            lines.push(format!("-- Create {}: {}", diff.object_type.as_deref().unwrap_or("table"), diff.name));
+            lines.push(format!("{};", diff.ddl.as_deref().unwrap_or_default()));
+            lines.push(String::new());
+            continue;
+        }
+
+        if diff.diff_type == "added" && diff.object_type.as_deref() == Some("view") {
+            lines.push(format!("-- View exists only in source: {}", diff.name));
+            lines.push("-- Source view definition is not available from this driver yet.".to_string());
+            lines.push(String::new());
+            continue;
+        }
+
+        if diff.diff_type == "removed" {
+            lines.push(format!("-- Drop {}: {}", diff.object_type.as_deref().unwrap_or("table"), diff.name));
+            lines.push(drop_object_sql(diff, db_type, schema, cascade));
+            lines.push(String::new());
+            continue;
+        }
+
+        if diff.diff_type != "modified" {
+            continue;
+        }
+
+        let mut parts = Vec::new();
+        if let Some(foreign_keys) = &diff.foreign_keys {
+            for fk in foreign_keys {
+                if fk.diff_type == "removed" || fk.diff_type == "modified" {
+                    lines.push(drop_foreign_key_sql(&diff.name, &fk.name, db_type, schema));
+                }
+            }
+        }
+
+        if let Some(columns) = &diff.columns {
+            for column in columns {
+                match column.diff_type.as_str() {
+                    "added" => {
+                        if let Some(source) = &column.source {
+                            parts.push(format!("  ADD COLUMN {}", column_def(source, db_type)));
+                        }
+                    }
+                    "removed" => {
+                        parts.push(format!("  DROP COLUMN {}", quote_id(&column.name, db_type)));
+                    }
+                    "modified" => {
+                        if let Some(source) = &column.source {
+                            if is_mysql {
+                                let renames_column = column.changes.iter().any(|change| change.starts_with("name:"));
+                                if renames_column {
+                                    if let Some(target) = &column.target {
+                                        parts.push(format!(
+                                            "  CHANGE COLUMN {} {}",
+                                            quote_id(&target.name, db_type),
+                                            column_def(source, db_type)
+                                        ));
+                                    }
+                                } else if column.changes.iter().any(|change| !change.starts_with("order:")) {
+                                    parts.push(format!("  MODIFY COLUMN {}", column_def(source, db_type)));
+                                }
+                            } else {
+                                let name = quote_id(&column.name, db_type);
+                                if column.changes.iter().any(|change| change.starts_with("type:")) {
+                                    parts.push(format!("  ALTER COLUMN {name} TYPE {}", source.data_type));
+                                }
+                                if column.changes.iter().any(|change| change.starts_with("nullable:")) {
+                                    parts.push(if source.is_nullable {
+                                        format!("  ALTER COLUMN {name} DROP NOT NULL")
+                                    } else {
+                                        format!("  ALTER COLUMN {name} SET NOT NULL")
+                                    });
+                                }
+                                if column.changes.iter().any(|change| change.starts_with("default:")) {
+                                    parts.push(if let Some(default) = &source.column_default {
+                                        format!("  ALTER COLUMN {name} SET DEFAULT {default}")
+                                    } else {
+                                        format!("  ALTER COLUMN {name} DROP DEFAULT")
+                                    });
+                                }
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        if !parts.is_empty() {
+            lines.push(format!("-- Alter table: {}", diff.name));
+            if is_mysql {
+                lines.push(format!("ALTER TABLE {table}"));
+                lines.push(format!("{};", parts.join(",\n")));
+            } else {
+                for part in parts {
+                    lines.push(format!("ALTER TABLE {table}{part};"));
+                }
+            }
+            lines.push(String::new());
+        }
+
+        if !is_mysql {
+            if let Some(columns) = &diff.columns {
+                for column in columns {
+                    if let Some(source) = &column.source {
+                        if column.changes.iter().any(|change| change.starts_with("comment:")) {
+                            lines.push(column_comment_sql(
+                                &diff.name,
+                                &column.name,
+                                source.comment.as_deref().unwrap_or_default(),
+                                db_type,
+                                schema,
+                            ));
+                        }
+                        if column.diff_type == "added" {
+                            if let Some(comment) = &source.comment {
+                                lines.push(column_comment_sql(&diff.name, &column.name, comment, db_type, schema));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if diff.source_table_comment.is_some() && diff.source_table_comment != diff.target_table_comment {
+            let comment = diff.source_table_comment.as_ref().and_then(|comment| comment.as_deref()).unwrap_or_default();
+            lines.push(table_comment_sql(&diff.name, comment, db_type, schema));
+        }
+
+        if let Some(indexes) = &diff.indexes {
+            for index in indexes {
+                match index.diff_type.as_str() {
+                    "added" => {
+                        if let Some(source) = &index.source {
+                            lines.push(create_index_sql(&diff.name, source, db_type, schema));
+                        }
+                    }
+                    "removed" => lines.push(drop_index_sql(&diff.name, &index.name, db_type, schema)),
+                    "modified" => {
+                        if let Some(source) = &index.source {
+                            lines.push(drop_index_sql(&diff.name, &index.name, db_type, schema));
+                            lines.push(create_index_sql(&diff.name, source, db_type, schema));
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        if let Some(foreign_keys) = &diff.foreign_keys {
+            for fk in foreign_keys {
+                if fk.diff_type == "added" || fk.diff_type == "modified" {
+                    if let Some(source) = &fk.source {
+                        lines.push(add_foreign_key_sql(&diff.name, source, db_type, schema));
+                    }
+                }
+            }
+        }
+
+        if let Some(triggers) = &diff.triggers {
+            for trigger in triggers {
+                lines.push(format!(
+                    "-- Trigger {}: {} on {}; review trigger definition manually.",
+                    trigger.diff_type, trigger.name, diff.name
+                ));
+            }
+        }
+
+        if diff.indexes.as_ref().is_some_and(|indexes| !indexes.is_empty())
+            || diff.foreign_keys.as_ref().is_some_and(|foreign_keys| !foreign_keys.is_empty())
+            || diff.triggers.as_ref().is_some_and(|triggers| !triggers.is_empty())
+        {
+            lines.push(String::new());
+        }
+
+        if db_type == DatabaseType::Sqlite
+            && diff.foreign_keys.as_ref().is_some_and(|foreign_keys| !foreign_keys.is_empty())
+        {
+            lines.push(format!("-- SQLite foreign key synchronization may require table rebuild for: {}", diff.name));
+            lines.push(String::new());
+        }
+    }
+
+    // Function diffs
+    if !function_diffs.is_empty() {
+        lines.push(String::new());
+        lines.push("-- Functions".to_string());
+        for diff in function_diffs {
+            match diff.diff_type.as_str() {
+                "added" => {
+                    if let Some(source) = &diff.source {
+                        lines.push(format!("-- Create function: {}", diff.name));
+                        lines.push(format!(
+                            "CREATE OR REPLACE FUNCTION {} {};",
+                            qualified_name(&diff.name, db_type, schema),
+                            source.definition
+                        ));
+                    }
+                }
+                "removed" => {
+                    lines.push(format!("-- Drop function: {}", diff.name));
+                    lines.push(format!(
+                        "DROP FUNCTION IF EXISTS {}{cascade};",
+                        qualified_name(&diff.name, db_type, schema)
+                    ));
+                }
+                "modified" => {
+                    if let Some(source) = &diff.source {
+                        lines.push(format!("-- Alter function: {}", diff.name));
+                        lines.push(format!(
+                            "CREATE OR REPLACE FUNCTION {} {};",
+                            qualified_name(&diff.name, db_type, schema),
+                            source.definition
+                        ));
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // Sequence diffs
+    if !sequence_diffs.is_empty() {
+        lines.push(String::new());
+        lines.push("-- Sequences".to_string());
+        for diff in sequence_diffs {
+            match diff.diff_type.as_str() {
+                "added" => {
+                    if let Some(source) = &diff.source {
+                        lines.push(format!("-- Create sequence: {}", diff.name));
+                        lines.push(format!(
+                            "CREATE SEQUENCE {} AS {} START WITH {} INCREMENT BY {} MINVALUE {} MAXVALUE {} {};",
+                            qualified_name(&diff.name, db_type, schema),
+                            source.data_type,
+                            source.start_value,
+                            source.increment,
+                            source.min_value,
+                            source.max_value,
+                            if source.cycle { "CYCLE" } else { "NO CYCLE" }
+                        ));
+                    }
+                }
+                "removed" => {
+                    lines.push(format!("-- Drop sequence: {}", diff.name));
+                    lines.push(format!("DROP SEQUENCE {}{cascade};", qualified_name(&diff.name, db_type, schema)));
+                }
+                "modified" => {
+                    if let Some(source) = &diff.source {
+                        lines.push(format!("-- Alter sequence: {}", diff.name));
+                        lines.push(format!(
+                            "ALTER SEQUENCE {} AS {} START WITH {} INCREMENT BY {} MINVALUE {} MAXVALUE {} {};",
+                            qualified_name(&diff.name, db_type, schema),
+                            source.data_type,
+                            source.start_value,
+                            source.increment,
+                            source.min_value,
+                            source.max_value,
+                            if source.cycle { "CYCLE" } else { "NO CYCLE" }
+                        ));
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // Rule diffs
+    if !rule_diffs.is_empty() {
+        lines.push(String::new());
+        lines.push("-- Rules".to_string());
+        for diff in rule_diffs {
+            match diff.diff_type.as_str() {
+                "added" => {
+                    if let Some(source) = &diff.source {
+                        lines.push(format!("-- Create rule: {}", diff.name));
+                        lines.push(source.definition.clone());
+                    }
+                }
+                "removed" => {
+                    lines.push(format!("-- Drop rule: {}", diff.name));
+                    if let Some(source) = &diff.source {
+                        lines.push(format!(
+                            "DROP RULE IF EXISTS {} ON {};",
+                            diff.name,
+                            qualified_name(&source.table_name, db_type, schema)
+                        ));
+                    }
+                }
+                "modified" => {
+                    if let Some(source) = &diff.source {
+                        lines.push(format!("-- Alter rule: {}", diff.name));
+                        lines.push(format!(
+                            "DROP RULE IF EXISTS {} ON {};",
+                            diff.name,
+                            qualified_name(&source.table_name, db_type, schema)
+                        ));
+                        lines.push(source.definition.clone());
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    // Owner diffs
+    if !owner_diffs.is_empty() {
+        lines.push(String::new());
+        lines.push("-- Owners".to_string());
+        for diff in owner_diffs {
+            if let (Some(source), Some(_target)) = (&diff.source, &diff.target) {
+                let object_type = match source.object_type.as_str() {
+                    "TABLE" => "TABLE",
+                    "VIEW" => "VIEW",
+                    "SEQUENCE" => "SEQUENCE",
+                    _ => "TABLE",
+                };
+                lines.push(format!(
+                    "ALTER {object_type} {} OWNER TO {};",
+                    qualified_name(&diff.object_name, db_type, schema),
+                    source.owner
+                ));
+            }
+        }
+    }
+
+    lines.join("\n").trim().to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn index(overrides: IndexInfo) -> IndexInfo {
+        IndexInfo {
+            name: if overrides.name.is_empty() { "idx_users_email".to_string() } else { overrides.name },
+            columns: if overrides.columns.is_empty() { vec!["email".to_string()] } else { overrides.columns },
+            is_unique: overrides.is_unique,
+            is_primary: overrides.is_primary,
+            filter: overrides.filter,
+            index_type: overrides.index_type,
+            included_columns: overrides.included_columns,
+            comment: overrides.comment,
+        }
+    }
+
+    fn foreign_key(overrides: ForeignKeyInfo) -> ForeignKeyInfo {
+        ForeignKeyInfo {
+            name: if overrides.name.is_empty() { "orders_user_id_fk".to_string() } else { overrides.name },
+            column: if overrides.column.is_empty() { "user_id".to_string() } else { overrides.column },
+            ref_schema: overrides.ref_schema,
+            ref_table: if overrides.ref_table.is_empty() { "users".to_string() } else { overrides.ref_table },
+            ref_column: if overrides.ref_column.is_empty() { "id".to_string() } else { overrides.ref_column },
+            on_update: overrides.on_update,
+            on_delete: overrides.on_delete,
+        }
+    }
+
+    fn column(name: &str, data_type: &str, comment: Option<&str>) -> ColumnInfo {
+        ColumnInfo {
+            name: name.to_string(),
+            data_type: data_type.to_string(),
+            is_nullable: false,
+            column_default: None,
+            is_primary_key: false,
+            extra: None,
+            comment: comment.map(str::to_string),
+            numeric_precision: None,
+            numeric_scale: None,
+            character_maximum_length: None,
+            enum_values: None,
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn formats_mysql_metadata_defaults_as_valid_column_definitions() {
+        let cases = [
+            ("varchar(50)", "外籍一般件", "DEFAULT '外籍一般件'"),
+            ("VARCHAR(50)", "uppercase type", "DEFAULT 'uppercase type'"),
+            ("varchar(50)", "", "DEFAULT ''"),
+            ("varchar(50)", "O'Reilly\\docs", "DEFAULT 'O''Reilly\\docs'"),
+            ("int", "7", "DEFAULT 7"),
+            ("decimal(10,2)", "1.00", "DEFAULT 1.00"),
+            ("timestamp", "CURRENT_TIMESTAMP", "DEFAULT CURRENT_TIMESTAMP"),
+            ("timestamp(3)", "CURRENT_TIMESTAMP(3)", "DEFAULT CURRENT_TIMESTAMP(3)"),
+            ("varchar(36)", "(UUID())", "DEFAULT (UUID())"),
+            ("json", "(JSON_ARRAY())", "DEFAULT (JSON_ARRAY())"),
+            ("text", "plain text", "DEFAULT ('plain text')"),
+            ("json", "{}", "DEFAULT ('{}')"),
+            ("varchar(50)", "'already quoted'", "DEFAULT 'already quoted'"),
+        ];
+
+        for (data_type, default, expected) in cases {
+            let mut source = column("value", data_type, None);
+            source.column_default = Some(default.to_string());
+            assert!(column_def(&source, DatabaseType::Mysql).contains(expected), "{data_type}: {default}");
+        }
+    }
+
+    #[test]
+    fn leaves_non_mysql_defaults_unchanged() {
+        let mut source = column("value", "varchar(50)", None);
+        source.column_default = Some("unquoted_metadata_value".to_string());
+
+        assert!(column_def(&source, DatabaseType::Postgres).contains("DEFAULT unquoted_metadata_value"));
+        assert!(column_def(&source, DatabaseType::Doris).contains("DEFAULT unquoted_metadata_value"));
+    }
+
+    #[test]
+    fn ignores_column_order_when_option_is_disabled() {
+        let diffs = diff_columns_with_options(
+            &[column("id", "int", None), column("name", "varchar(64)", None), column("status", "varchar(16)", None)],
+            &[column("status", "varchar(16)", None), column("id", "int", None), column("name", "varchar(64)", None)],
+            ColumnDiffOptions::default(),
+        );
+
+        assert!(diffs.is_empty());
+    }
+
+    #[test]
+    fn detects_column_order_when_option_is_enabled() {
+        let diffs = diff_columns_with_options(
+            &[column("id", "int", None), column("name", "varchar(64)", None), column("status", "varchar(16)", None)],
+            &[column("status", "varchar(16)", None), column("id", "int", None), column("name", "varchar(64)", None)],
+            ColumnDiffOptions { compare_column_order: true, ..ColumnDiffOptions::default() },
+        );
+
+        assert_eq!(diffs.len(), 3);
+        assert_eq!(diffs[0].changes, vec!["order: 2 → 1"]);
+    }
+
+    #[test]
+    fn keeps_case_sensitive_column_names_distinct_by_default() {
+        let diffs = diff_columns_with_options(
+            &[column("FREEDATE", "datetime", None)],
+            &[column("freedate", "datetime", None)],
+            ColumnDiffOptions::default(),
+        );
+
+        assert_eq!(diffs.len(), 2);
+        assert_eq!(diffs[0].diff_type, "added");
+        assert_eq!(diffs[1].diff_type, "removed");
+    }
+
+    #[test]
+    fn matches_mysql_column_names_case_insensitively() {
+        let diffs = diff_columns_with_options(
+            &[column("FREEDATE", "datetime", None), column("DATETYPE", "char(6)", Some("holiday type"))],
+            &[column("freedate", "datetime", None), column("datetype", "char(6)", Some("holiday type"))],
+            ColumnDiffOptions { case_insensitive_names: true, ..ColumnDiffOptions::default() },
+        );
+
+        assert_eq!(diffs.len(), 2);
+        assert!(diffs.iter().all(|diff| diff.diff_type == "modified"));
+        assert_eq!(diffs[0].changes, vec!["name: freedate → FREEDATE"]);
+        assert_eq!(diffs[1].changes, vec!["name: datetype → DATETYPE"]);
+
+        let sql = generate_schema_sync_sql(
+            &[TableDiff {
+                diff_type: "modified".to_string(),
+                object_type: Some("table".to_string()),
+                name: "c_freedate".to_string(),
+                columns: Some(diffs),
+                indexes: None,
+                foreign_keys: None,
+                triggers: None,
+                ddl: None,
+                target_ddl: None,
+                source_table_comment: None,
+                target_table_comment: None,
+                sync_sql: None,
+            }],
+            &[],
+            &[],
+            &[],
+            &[],
+            DatabaseType::Mysql,
+            None,
+            false,
+        );
+
+        assert!(sql.contains("CHANGE COLUMN `freedate` `FREEDATE` datetime NOT NULL"));
+        assert!(sql.contains("CHANGE COLUMN `datetype` `DATETYPE` char(6) NOT NULL COMMENT 'holiday type'"));
+        assert!(!sql.contains("ADD COLUMN"));
+        assert!(!sql.contains("DROP COLUMN"));
+    }
+
+    #[test]
+    fn detects_modified_indexes_not_only_added_or_removed_indexes() {
+        let diffs = diff_indexes(
+            &[index(IndexInfo {
+                name: "idx_orders_status".to_string(),
+                columns: vec!["status".to_string(), "created_at".to_string()],
+                is_unique: false,
+                is_primary: false,
+                filter: None,
+                index_type: None,
+                included_columns: None,
+                comment: None,
+            })],
+            &[index(IndexInfo {
+                name: "idx_orders_status".to_string(),
+                columns: vec!["status".to_string()],
+                is_unique: true,
+                is_primary: false,
+                filter: None,
+                index_type: None,
+                included_columns: None,
+                comment: None,
+            })],
+        );
+
+        assert_eq!(diffs.len(), 1);
+        assert_eq!(diffs[0].diff_type, "modified");
+        assert_eq!(diffs[0].changes, vec!["unique: YES → NO", "columns: status → status, created_at"]);
+    }
+
+    #[test]
+    fn detects_foreign_key_additions_removals_and_target_changes() {
+        let diffs = diff_foreign_keys(
+            &[
+                foreign_key(ForeignKeyInfo {
+                    name: "orders_user_id_fk".to_string(),
+                    column: String::new(),
+                    ref_schema: None,
+                    ref_table: String::new(),
+                    ref_column: String::new(),
+                    on_update: None,
+                    on_delete: None,
+                }),
+                foreign_key(ForeignKeyInfo {
+                    name: "orders_account_id_fk".to_string(),
+                    column: "account_id".to_string(),
+                    ref_schema: None,
+                    ref_table: "accounts".to_string(),
+                    ref_column: String::new(),
+                    on_update: None,
+                    on_delete: None,
+                }),
+            ],
+            &[
+                foreign_key(ForeignKeyInfo {
+                    name: "orders_user_id_fk".to_string(),
+                    column: String::new(),
+                    ref_schema: None,
+                    ref_table: "members".to_string(),
+                    ref_column: String::new(),
+                    on_update: None,
+                    on_delete: None,
+                }),
+                foreign_key(ForeignKeyInfo {
+                    name: "orders_region_id_fk".to_string(),
+                    column: "region_id".to_string(),
+                    ref_schema: None,
+                    ref_table: "regions".to_string(),
+                    ref_column: String::new(),
+                    on_update: None,
+                    on_delete: None,
+                }),
+            ],
+        );
+
+        let summary: Vec<_> = diffs.iter().map(|diff| (diff.diff_type.as_str(), diff.name.as_str())).collect();
+        assert_eq!(
+            summary,
+            vec![
+                ("modified", "orders_user_id_fk"),
+                ("added", "orders_account_id_fk"),
+                ("removed", "orders_region_id_fk"),
+            ]
+        );
+    }
+
+    #[test]
+    fn generates_sync_sql_for_index_and_foreign_key_changes() {
+        let diffs = vec![TableDiff {
+            diff_type: "modified".to_string(),
+            object_type: None,
+            name: "orders".to_string(),
+            columns: None,
+            indexes: Some(vec![IndexDiff {
+                diff_type: "modified".to_string(),
+                name: "idx_orders_status".to_string(),
+                source: Some(index(IndexInfo {
+                    name: "idx_orders_status".to_string(),
+                    columns: vec!["status".to_string(), "created_at".to_string()],
+                    is_unique: true,
+                    is_primary: false,
+                    filter: None,
+                    index_type: None,
+                    included_columns: None,
+                    comment: None,
+                })),
+                target: None,
+                changes: Vec::new(),
+            }]),
+            foreign_keys: Some(vec![ForeignKeyDiff {
+                diff_type: "modified".to_string(),
+                name: "orders_user_id_fk".to_string(),
+                source: Some(foreign_key(ForeignKeyInfo {
+                    name: "orders_user_id_fk".to_string(),
+                    column: String::new(),
+                    ref_schema: None,
+                    ref_table: "users".to_string(),
+                    ref_column: String::new(),
+                    on_update: None,
+                    on_delete: None,
+                })),
+                target: None,
+                changes: Vec::new(),
+            }]),
+            triggers: None,
+            ddl: None,
+            target_ddl: None,
+            source_table_comment: None,
+            target_table_comment: None,
+            sync_sql: None,
+        }];
+
+        assert_eq!(
+            generate_schema_sync_sql(&diffs, &[], &[], &[], &[], DatabaseType::Postgres, None, false),
+            [
+                "ALTER TABLE \"orders\" DROP CONSTRAINT \"orders_user_id_fk\";",
+                "DROP INDEX IF EXISTS \"idx_orders_status\";",
+                "CREATE UNIQUE INDEX \"idx_orders_status\" ON \"orders\" (\"status\", \"created_at\");",
+                "ALTER TABLE \"orders\" ADD CONSTRAINT \"orders_user_id_fk\" FOREIGN KEY (\"user_id\") REFERENCES \"users\" (\"id\");",
+            ]
+            .join("\n")
+        );
+    }
+
+    #[test]
+    fn mysql_column_comment_changes_generate_modify_column_sql() {
+        let diffs = vec![TableDiff {
+            diff_type: "modified".to_string(),
+            object_type: None,
+            name: "users".to_string(),
+            columns: Some(vec![ColumnDiff {
+                diff_type: "modified".to_string(),
+                name: "name".to_string(),
+                source: Some(column("name", "varchar(64)", Some("用户姓名"))),
+                target: Some(column("name", "varchar(64)", Some("Name"))),
+                changes: vec!["comment: Name → 用户姓名".to_string()],
+            }]),
+            indexes: None,
+            foreign_keys: None,
+            triggers: None,
+            ddl: None,
+            target_ddl: None,
+            source_table_comment: Some(Some("用户表".to_string())),
+            target_table_comment: Some(Some("Users".to_string())),
+            sync_sql: None,
+        }];
+
+        assert_eq!(
+            generate_schema_sync_sql(&diffs, &[], &[], &[], &[], DatabaseType::Mysql, None, false),
+            [
+                "-- Alter table: users",
+                "ALTER TABLE `users`",
+                "  MODIFY COLUMN `name` varchar(64) NOT NULL COMMENT '用户姓名';",
+                "",
+                "ALTER TABLE `users` COMMENT = '用户表';",
+            ]
+            .join("\n")
+        );
+    }
+
+    #[test]
+    fn mysql_schema_sync_sql_qualifies_tables_with_target_database() {
+        let diffs = vec![TableDiff {
+            diff_type: "modified".to_string(),
+            object_type: None,
+            name: "notify_channel_config".to_string(),
+            columns: Some(vec![ColumnDiff {
+                diff_type: "modified".to_string(),
+                name: "config_json".to_string(),
+                source: Some(column("config_json", "json", Some("渠道配置"))),
+                target: Some(column("config_json", "json", Some("Config"))),
+                changes: vec!["comment: Config → 渠道配置".to_string()],
+            }]),
+            indexes: None,
+            foreign_keys: None,
+            triggers: None,
+            ddl: None,
+            target_ddl: None,
+            source_table_comment: None,
+            target_table_comment: None,
+            sync_sql: None,
+        }];
+
+        assert_eq!(
+            generate_schema_sync_sql(&diffs, &[], &[], &[], &[], DatabaseType::Mysql, Some("target_db"), false),
+            [
+                "-- Alter table: notify_channel_config",
+                "ALTER TABLE `target_db`.`notify_channel_config`",
+                "  MODIFY COLUMN `config_json` json NOT NULL COMMENT '渠道配置';",
+            ]
+            .join("\n")
+        );
+    }
+
+    #[test]
+    fn blank_target_schema_does_not_generate_empty_qualifier() {
+        let diffs = vec![TableDiff {
+            diff_type: "modified".to_string(),
+            object_type: None,
+            name: "notify_channel_config".to_string(),
+            columns: Some(vec![ColumnDiff {
+                diff_type: "modified".to_string(),
+                name: "config_json".to_string(),
+                source: Some(column("config_json", "json", Some("渠道配置"))),
+                target: Some(column("config_json", "json", Some("Config"))),
+                changes: vec!["comment: Config → 渠道配置".to_string()],
+            }]),
+            indexes: None,
+            foreign_keys: None,
+            triggers: None,
+            ddl: None,
+            target_ddl: None,
+            source_table_comment: None,
+            target_table_comment: None,
+            sync_sql: None,
+        }];
+
+        let sql = generate_schema_sync_sql(&diffs, &[], &[], &[], &[], DatabaseType::Mysql, Some("  "), false);
+
+        assert!(sql.contains("ALTER TABLE `notify_channel_config`"));
+        assert!(!sql.contains("``."));
+    }
+
+    #[test]
+    fn ignore_comments_skips_column_and_table_comment_diffs() {
+        let options = SchemaDiffPreparationOptions {
+            source_tables: vec![TableInfo {
+                name: "users".to_string(),
+                table_type: "BASE TABLE".to_string(),
+                comment: Some("用户表".to_string()),
+                parent_schema: None,
+                parent_name: None,
+            }],
+            target_tables: vec![TableInfo {
+                name: "users".to_string(),
+                table_type: "BASE TABLE".to_string(),
+                comment: Some("Users".to_string()),
+                parent_schema: None,
+                parent_name: None,
+            }],
+            source_details: vec![TableSchemaDetail {
+                name: "users".to_string(),
+                columns: vec![column("name", "varchar(64)", Some("用户姓名"))],
+                indexes: Vec::new(),
+                foreign_keys: Vec::new(),
+                triggers: Vec::new(),
+                ddl: None,
+            }],
+            target_details: vec![TableSchemaDetail {
+                name: "users".to_string(),
+                columns: vec![column("name", "varchar(64)", Some("Name"))],
+                indexes: Vec::new(),
+                foreign_keys: Vec::new(),
+                triggers: Vec::new(),
+                ddl: None,
+            }],
+            source_functions: Vec::new(),
+            target_functions: Vec::new(),
+            source_sequences: Vec::new(),
+            target_sequences: Vec::new(),
+            source_rules: Vec::new(),
+            target_rules: Vec::new(),
+            source_owners: Vec::new(),
+            target_owners: Vec::new(),
+            database_type: DatabaseType::Mysql,
+            target_schema: None,
+            ignore_comments: true,
+            cascade_delete: false,
+            compare_column_order: false,
+        };
+
+        let result = prepare_schema_diff(options);
+        assert!(result.diffs.is_empty());
+        assert!(result.sync_sql.is_empty());
+    }
+
+    #[test]
+    fn prepare_schema_diff_attaches_per_table_sync_sql() {
+        let options = SchemaDiffPreparationOptions {
+            source_tables: vec![TableInfo {
+                name: "users".to_string(),
+                table_type: "BASE TABLE".to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            }],
+            target_tables: vec![TableInfo {
+                name: "users".to_string(),
+                table_type: "BASE TABLE".to_string(),
+                comment: None,
+                parent_schema: None,
+                parent_name: None,
+            }],
+            source_details: vec![TableSchemaDetail {
+                name: "users".to_string(),
+                columns: vec![column("name", "varchar(128)", None)],
+                indexes: Vec::new(),
+                foreign_keys: Vec::new(),
+                triggers: Vec::new(),
+                ddl: Some("CREATE TABLE `users` (`name` varchar(128));".to_string()),
+            }],
+            target_details: vec![TableSchemaDetail {
+                name: "users".to_string(),
+                columns: vec![column("name", "varchar(64)", None)],
+                indexes: Vec::new(),
+                foreign_keys: Vec::new(),
+                triggers: Vec::new(),
+                ddl: Some("CREATE TABLE `users` (`name` varchar(64));".to_string()),
+            }],
+            source_functions: Vec::new(),
+            target_functions: Vec::new(),
+            source_sequences: Vec::new(),
+            target_sequences: Vec::new(),
+            source_rules: Vec::new(),
+            target_rules: Vec::new(),
+            source_owners: Vec::new(),
+            target_owners: Vec::new(),
+            database_type: DatabaseType::Mysql,
+            target_schema: None,
+            ignore_comments: false,
+            cascade_delete: false,
+            compare_column_order: false,
+        };
+
+        let result = prepare_schema_diff(options);
+        let table_sync_sql = result.diffs[0].sync_sql.as_deref().unwrap_or_default();
+
+        assert!(table_sync_sql.contains("ALTER TABLE `users`"));
+        assert!(!table_sync_sql.contains("CREATE TABLE"));
+    }
+
+    #[test]
+    fn qualifies_generated_schema_sync_sql_with_target_schema() {
+        let diffs = vec![TableDiff {
+            diff_type: "modified".to_string(),
+            object_type: None,
+            name: "orders".to_string(),
+            columns: Some(vec![ColumnDiff {
+                diff_type: "added".to_string(),
+                name: "status".to_string(),
+                source: Some(ColumnInfo {
+                    name: "status".to_string(),
+                    data_type: "text".to_string(),
+                    is_nullable: true,
+                    column_default: None,
+                    is_primary_key: false,
+                    extra: None,
+                    comment: None,
+                    numeric_precision: None,
+                    numeric_scale: None,
+                    character_maximum_length: None,
+                    enum_values: None,
+                    ..Default::default()
+                }),
+                target: None,
+                changes: Vec::new(),
+            }]),
+            indexes: Some(vec![IndexDiff {
+                diff_type: "added".to_string(),
+                name: "idx_orders_status".to_string(),
+                source: Some(index(IndexInfo {
+                    name: "idx_orders_status".to_string(),
+                    columns: vec!["status".to_string()],
+                    is_unique: false,
+                    is_primary: false,
+                    filter: None,
+                    index_type: None,
+                    included_columns: None,
+                    comment: None,
+                })),
+                target: None,
+                changes: Vec::new(),
+            }]),
+            foreign_keys: None,
+            triggers: None,
+            ddl: None,
+            target_ddl: None,
+            source_table_comment: None,
+            target_table_comment: None,
+            sync_sql: None,
+        }];
+
+        assert_eq!(
+            generate_schema_sync_sql(&diffs, &[], &[], &[], &[], DatabaseType::Postgres, Some("sales"), false),
+            [
+                "-- Alter table: orders",
+                "ALTER TABLE \"sales\".\"orders\"  ADD COLUMN \"status\" text;",
+                "",
+                "CREATE INDEX \"idx_orders_status\" ON \"sales\".\"orders\" (\"status\");",
+            ]
+            .join("\n")
+        );
+    }
+}
diff --git a/crates/dbx-core/src/sql.rs b/crates/dbx-core/src/sql.rs
new file mode 100644
index 0000000..acd18f7
--- /dev/null
+++ b/crates/dbx-core/src/sql.rs
@@ -0,0 +1,3549 @@
+use serde::{Deserialize, Serialize};
+use sqlparser::dialect::OracleDialect;
+use sqlparser::tokenizer::{Token, Tokenizer};
+
+use crate::models::connection::DatabaseType;
+
+pub const MIN_FUZZY_FILTER_CHARS: usize = 2;
+
+pub fn fuzzy_filter_enabled(filter: &str) -> bool {
+    filter.trim().chars().count() >= MIN_FUZZY_FILTER_CHARS
+}
+
+pub fn fuzzy_subsequence_match(text: &str, filter: &str) -> bool {
+    let filter = filter.trim().to_lowercase();
+    if filter.is_empty() {
+        return true;
+    }
+
+    let text = text.to_lowercase();
+    let mut chars = text.chars();
+    for needle in filter.chars() {
+        if !chars.any(|candidate| candidate == needle) {
+            return false;
+        }
+    }
+    true
+}
+
+pub fn contains_or_fuzzy_match(text: &str, filter: &str) -> bool {
+    let filter = filter.trim().to_lowercase();
+    if filter.is_empty() {
+        return true;
+    }
+
+    let text = text.to_lowercase();
+    text.contains(&filter) || (fuzzy_filter_enabled(&filter) && fuzzy_subsequence_match(&text, &filter))
+}
+
+pub fn fuzzy_like_pattern_with_escape(value: &str, mut escape: impl FnMut(&str) -> String) -> String {
+    let value = value.trim();
+    if value.is_empty() {
+        return "%%".to_string();
+    }
+
+    let mut pattern = String::with_capacity(value.len() * 2 + 2);
+    pattern.push('%');
+    for ch in value.chars() {
+        pattern.push_str(&escape(&ch.to_string()));
+        pattern.push('%');
+    }
+    pattern
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SqlFileRequest {
+    pub execution_id: String,
+    pub connection_id: String,
+    pub database: String,
+    pub file_path: String,
+    pub continue_on_error: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SqlFilePreview {
+    pub file_name: String,
+    pub file_path: String,
+    pub size_bytes: u64,
+    pub preview: String,
+    pub can_execute_without_selected_database: bool,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum SqlFileStatus {
+    Started,
+    Running,
+    StatementDone,
+    StatementFailed,
+    Done,
+    Error,
+    Cancelled,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SqlFileStatementAction {
+    Execute(String),
+    Skip,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SqlFileImportStatementKind {
+    Execute,
+    Skip,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SqlFileImportStatement {
+    pub kind: SqlFileImportStatementKind,
+    pub sql: String,
+    pub source_sqls: Vec<String>,
+    pub source_statement_count: usize,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct SqlDialectProfile {
+    supports_hash_line_comments: bool,
+    supports_oracle_plsql_blocks: bool,
+    supports_slash_line_block_delimiter: bool,
+    supports_custom_delimiter_commands: bool,
+    supports_mysql_routine_blocks: bool,
+    supports_dollar_quoted_strings: bool,
+    supports_hana_do_blocks: bool,
+    supports_go_batch_separator: bool,
+    keeps_sqlserver_module_batch_at_cursor: bool,
+}
+
+impl Default for SqlDialectProfile {
+    fn default() -> Self {
+        Self {
+            supports_hash_line_comments: false,
+            supports_oracle_plsql_blocks: false,
+            supports_slash_line_block_delimiter: false,
+            supports_custom_delimiter_commands: true,
+            supports_mysql_routine_blocks: false,
+            supports_dollar_quoted_strings: true,
+            supports_hana_do_blocks: false,
+            supports_go_batch_separator: false,
+            keeps_sqlserver_module_batch_at_cursor: false,
+        }
+    }
+}
+
+impl SqlDialectProfile {
+    fn for_database_type(db_type: DatabaseType) -> Self {
+        if Self::is_oracle_like_database(db_type) {
+            return Self::oracle_like();
+        }
+
+        if matches!(db_type, DatabaseType::SqlServer) {
+            return Self::sql_server();
+        }
+
+        if Self::is_mysql_compatible_database(db_type) {
+            return Self::mysql_compatible();
+        }
+
+        if matches!(db_type, DatabaseType::SapHana) {
+            return Self::sap_hana();
+        }
+
+        Self::default()
+    }
+
+    fn mysql_compatible() -> Self {
+        Self { supports_hash_line_comments: true, supports_mysql_routine_blocks: true, ..Self::default() }
+    }
+
+    fn oracle_like() -> Self {
+        Self { supports_oracle_plsql_blocks: true, supports_slash_line_block_delimiter: true, ..Self::default() }
+    }
+
+    fn sql_server() -> Self {
+        Self { supports_go_batch_separator: true, keeps_sqlserver_module_batch_at_cursor: true, ..Self::default() }
+    }
+
+    fn sap_hana() -> Self {
+        Self { supports_hana_do_blocks: true, ..Self::default() }
+    }
+
+    fn is_mysql_compatible_database(db_type: DatabaseType) -> bool {
+        matches!(
+            db_type,
+            DatabaseType::Mysql
+                | DatabaseType::Doris
+                | DatabaseType::StarRocks
+                | DatabaseType::ManticoreSearch
+                | DatabaseType::Goldendb
+        )
+    }
+
+    fn is_oracle_like_database(db_type: DatabaseType) -> bool {
+        matches!(
+            db_type,
+            DatabaseType::Oracle
+                | DatabaseType::Dameng
+                | DatabaseType::Gaussdb
+                | DatabaseType::Yashandb
+                | DatabaseType::Oscar
+                | DatabaseType::OceanbaseOracle
+        )
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct SqlParsingOptions {
+    profile: SqlDialectProfile,
+}
+
+impl SqlParsingOptions {
+    pub fn for_database_type(db_type: DatabaseType) -> Self {
+        Self::from_profile(SqlDialectProfile::for_database_type(db_type))
+    }
+
+    pub fn mysql_compatible() -> Self {
+        Self::from_profile(SqlDialectProfile::mysql_compatible())
+    }
+
+    fn from_profile(profile: SqlDialectProfile) -> Self {
+        Self { profile }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SqlFileProgress {
+    pub execution_id: String,
+    pub status: SqlFileStatus,
+    pub statement_index: usize,
+    pub success_count: usize,
+    pub failure_count: usize,
+    pub affected_rows: u64,
+    pub elapsed_ms: u128,
+    pub statement_summary: String,
+    pub error: Option<String>,
+}
+
+pub fn decode_sql_file_bytes(bytes: &[u8]) -> Result<String, String> {
+    if bytes.starts_with(&[0xEF, 0xBB, 0xBF]) {
+        return std::str::from_utf8(&bytes[3..]).map(|text| text.to_string()).map_err(|_| sql_file_encoding_error());
+    }
+
+    if bytes.starts_with(&[0xFF, 0xFE]) {
+        return decode_sql_file_with_encoding(&bytes[2..], encoding_rs::UTF_16LE);
+    }
+
+    if bytes.starts_with(&[0xFE, 0xFF]) {
+        return decode_sql_file_with_encoding(&bytes[2..], encoding_rs::UTF_16BE);
+    }
+
+    if let Ok(text) = std::str::from_utf8(bytes) {
+        return Ok(text.strip_prefix('\u{feff}').unwrap_or(text).to_string());
+    }
+
+    decode_sql_file_with_encoding(bytes, encoding_rs::GBK)
+}
+
+fn decode_sql_file_with_encoding(bytes: &[u8], encoding: &'static encoding_rs::Encoding) -> Result<String, String> {
+    let (text, had_errors) = encoding.decode_without_bom_handling(bytes);
+    if had_errors {
+        return Err(sql_file_encoding_error());
+    }
+    Ok(text.into_owned())
+}
+
+fn sql_file_encoding_error() -> String {
+    "Unsupported SQL file encoding. Save the file as UTF-8, UTF-8 with BOM, UTF-16 with BOM, or GBK, then try again."
+        .to_string()
+}
+
+#[derive(Default)]
+pub struct SqlStatementSplitter {
+    buffer: String,
+    in_single_quote: bool,
+    in_double_quote: bool,
+    in_backtick: bool,
+    in_line_comment: bool,
+    in_block_comment: bool,
+    dollar_quote_tag: Option<String>,
+    previous: Option<char>,
+    custom_delimiter: Option<String>,
+    options: SqlParsingOptions,
+}
+
+impl SqlStatementSplitter {
+    pub fn with_options(options: SqlParsingOptions) -> Self {
+        Self { options, ..Self::default() }
+    }
+
+    pub fn push_chunk(&mut self, chunk: &str) -> Vec<String> {
+        let mut statements = Vec::new();
+        let chars = chunk.chars().collect::<Vec<_>>();
+        let mut i = 0;
+
+        while i < chars.len() {
+            if let Some(tag) = &self.dollar_quote_tag {
+                let tag_chars = tag.chars().collect::<Vec<_>>();
+                if starts_with_chars(&chars, i, &tag_chars) {
+                    for tag_ch in &tag_chars {
+                        self.buffer.push(*tag_ch);
+                        self.previous = Some(*tag_ch);
+                    }
+                    i += tag_chars.len();
+                    self.dollar_quote_tag = None;
+                    continue;
+                }
+
+                let ch = chars[i];
+                self.buffer.push(ch);
+                self.previous = Some(ch);
+                i += 1;
+                continue;
+            }
+
+            let ch = chars[i];
+            let next = chars.get(i + 1).copied();
+
+            if self.in_line_comment {
+                self.buffer.push(ch);
+                if ch == '\n' {
+                    self.in_line_comment = false;
+                }
+                self.previous = Some(ch);
+                i += 1;
+                continue;
+            }
+
+            if self.in_block_comment {
+                self.buffer.push(ch);
+                if self.previous == Some('*') && ch == '/' {
+                    self.in_block_comment = false;
+                }
+                self.previous = Some(ch);
+                i += 1;
+                continue;
+            }
+
+            if !self.in_single_quote && !self.in_double_quote && !self.in_backtick {
+                if self.previous == Some('-') && ch == '-' {
+                    self.in_line_comment = true;
+                    self.buffer.push(ch);
+                    self.previous = Some(ch);
+                    i += 1;
+                    continue;
+                }
+                if self.previous == Some('/') && ch == '*' {
+                    self.in_block_comment = true;
+                    self.buffer.push(ch);
+                    self.previous = Some(ch);
+                    i += 1;
+                    continue;
+                }
+                if ch == '-' && next == Some('-') {
+                    self.in_line_comment = true;
+                    self.buffer.push(ch);
+                    self.previous = Some(ch);
+                    i += 1;
+                    continue;
+                }
+                if self.options.profile.supports_hash_line_comments && ch == '#' {
+                    self.in_line_comment = true;
+                    self.buffer.push(ch);
+                    self.previous = Some(ch);
+                    i += 1;
+                    continue;
+                }
+                if ch == '/' && next == Some('*') {
+                    self.in_block_comment = true;
+                    self.buffer.push(ch);
+                    self.previous = Some(ch);
+                    i += 1;
+                    continue;
+                }
+                if let Some(tag) = self
+                    .options
+                    .profile
+                    .supports_dollar_quoted_strings
+                    .then(|| dollar_quote_tag_at(&chars, i))
+                    .flatten()
+                {
+                    if self.custom_delimiter.is_none() && !self.on_delimiter_line() {
+                        for tag_ch in tag.chars() {
+                            self.buffer.push(tag_ch);
+                            self.previous = Some(tag_ch);
+                        }
+                        i += tag.chars().count();
+                        self.dollar_quote_tag = Some(tag);
+                        continue;
+                    }
+                }
+            }
+
+            match ch {
+                '\'' if !self.in_double_quote && !self.in_backtick && self.previous != Some('\\') => {
+                    self.in_single_quote = !self.in_single_quote;
+                    self.buffer.push(ch);
+                }
+                '"' if !self.in_single_quote && !self.in_backtick && self.previous != Some('\\') => {
+                    self.in_double_quote = !self.in_double_quote;
+                    self.buffer.push(ch);
+                }
+                '`' if !self.in_single_quote && !self.in_double_quote => {
+                    self.in_backtick = !self.in_backtick;
+                    self.buffer.push(ch);
+                }
+                ';' if !self.in_single_quote && !self.in_double_quote && !self.in_backtick => {
+                    if self.options.profile.supports_custom_delimiter_commands && self.on_delimiter_line() {
+                        self.buffer.push(ch);
+                    } else if self.custom_delimiter.is_some() {
+                        self.buffer.push(ch);
+                    } else if self.options.profile.supports_mysql_routine_blocks
+                        && starts_with_mysql_routine_block(&self.buffer)
+                    {
+                        let mut candidate = self.buffer.clone();
+                        candidate.push(ch);
+                        if mysql_routine_block_is_complete(&candidate) {
+                            // The final semicolon is the client-side statement delimiter.
+                            // Keep semicolons inside BEGIN...END, but do not send the
+                            // delimiter after END to the MySQL server.
+                            self.push_current_statement(&mut statements);
+                        } else {
+                            self.buffer.push(ch);
+                        }
+                    } else if self.options.profile.supports_oracle_plsql_blocks
+                        && starts_with_oracle_plsql_block(&self.buffer)
+                    {
+                        self.buffer.push(ch);
+                        if oracle_plsql_block_is_complete(&self.buffer) {
+                            self.push_current_statement(&mut statements);
+                        }
+                    } else if self.options.profile.supports_hana_do_blocks && starts_with_hana_do_block(&self.buffer) {
+                        self.buffer.push(ch);
+                        if hana_do_block_is_complete(&self.buffer) {
+                            self.push_current_statement(&mut statements);
+                        }
+                    } else {
+                        self.push_current_statement(&mut statements);
+                    }
+                }
+                _ => self.buffer.push(ch),
+            }
+
+            if !self.in_single_quote && !self.in_double_quote && !self.in_backtick && self.dollar_quote_tag.is_none() {
+                if ch == '\n' {
+                    let buf_end = self.buffer.len() - 1;
+                    let last_line_start = self.buffer[..buf_end].rfind('\n').map_or(0, |p| p + 1);
+                    let last_line = self.buffer[last_line_start..buf_end].trim();
+                    if self.options.profile.supports_slash_line_block_delimiter && last_line == "/" {
+                        let before = self.buffer[..last_line_start].trim();
+                        if has_executable_sql_with_options(before, self.options) {
+                            statements.push(before.to_string());
+                        }
+                        self.buffer.clear();
+                        self.previous = None;
+                        i += 1;
+                        continue;
+                    }
+                    if let Some(new_delim) = self
+                        .options
+                        .profile
+                        .supports_custom_delimiter_commands
+                        .then(|| parse_delimiter_command(last_line))
+                        .flatten()
+                    {
+                        self.custom_delimiter = if new_delim == ";" { None } else { Some(new_delim.to_string()) };
+                        if last_line_start > 0 {
+                            let before = self.buffer[..last_line_start].trim();
+                            if has_executable_sql_with_options(before, self.options) {
+                                statements.push(before.to_string());
+                            }
+                        }
+                        self.buffer.clear();
+                        self.previous = None;
+                        i += 1;
+                        continue;
+                    }
+                }
+                if let Some(delim) = self.custom_delimiter.clone() {
+                    if self.buffer.ends_with(delim.as_str()) {
+                        self.buffer.truncate(self.buffer.len() - delim.len());
+                        self.push_current_statement(&mut statements);
+                    }
+                }
+            }
+
+            self.previous = Some(ch);
+            i += 1;
+        }
+
+        statements
+    }
+
+    pub fn finish(mut self) -> Vec<String> {
+        let mut statements = Vec::new();
+        let trimmed = self.buffer.trim();
+        let last_line = trimmed.rsplit('\n').next().unwrap_or(trimmed).trim();
+        if self.options.profile.supports_custom_delimiter_commands && parse_delimiter_command(last_line).is_some() {
+            let before = trimmed.rsplit_once('\n').map(|x| x.0).unwrap_or("").trim();
+            if has_executable_sql_with_options(before, self.options) {
+                statements.push(before.to_string());
+            }
+            self.buffer.clear();
+        } else if self.options.profile.supports_slash_line_block_delimiter && last_line == "/" {
+            let before = trimmed.rsplit_once('\n').map(|x| x.0).unwrap_or("").trim();
+            if has_executable_sql_with_options(before, self.options) {
+                statements.push(before.to_string());
+            }
+            self.buffer.clear();
+        } else if let Some(ref delim) = self.custom_delimiter {
+            if self.buffer.ends_with(delim.as_str()) {
+                self.buffer.truncate(self.buffer.len() - delim.len());
+            }
+        }
+        self.push_current_statement(&mut statements);
+        statements
+    }
+
+    fn push_current_statement(&mut self, statements: &mut Vec<String>) {
+        let statement = self.buffer.trim();
+        if has_executable_sql_with_options(statement, self.options) {
+            statements.push(statement.to_string());
+        }
+        self.buffer.clear();
+        self.previous = None;
+    }
+
+    fn on_delimiter_line(&self) -> bool {
+        let start = self.buffer.rfind('\n').map_or(0, |p| p + 1);
+        let line = self.buffer[start..].trim_start().as_bytes();
+        line.len() >= 9 && line[..9].eq_ignore_ascii_case(b"delimiter")
+    }
+}
+
+pub fn split_sql_statements(sql: &str) -> Vec<String> {
+    split_sql_statements_with_options(sql, SqlParsingOptions::default())
+}
+
+pub fn split_sql_statements_for_database(sql: &str, db_type: DatabaseType) -> Vec<String> {
+    split_sql_statements_with_options(sql, SqlParsingOptions::for_database_type(db_type))
+}
+
+pub fn split_sql_statements_with_options(sql: &str, options: SqlParsingOptions) -> Vec<String> {
+    let mut splitter = SqlStatementSplitter::with_options(options);
+    let mut statements = splitter.push_chunk(sql);
+    statements.extend(splitter.finish());
+    statements
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SqlStatementRange {
+    pub text: String,
+    pub start: usize,
+    pub end: usize,
+}
+
+pub fn find_statement_at_cursor(sql: &str, cursor_pos: usize) -> String {
+    find_statement_at_cursor_with_options(sql, cursor_pos, SqlParsingOptions::default())
+}
+
+pub fn find_statement_at_cursor_for_database(sql: &str, cursor_pos: usize, db_type: DatabaseType) -> String {
+    if db_type == DatabaseType::SqlServer {
+        return find_sqlserver_statement_at_cursor(sql, cursor_pos);
+    }
+    find_statement_at_cursor_with_options(sql, cursor_pos, SqlParsingOptions::for_database_type(db_type))
+}
+
+pub fn find_statement_at_cursor_with_options(sql: &str, cursor_pos: usize, options: SqlParsingOptions) -> String {
+    let statements = split_sql_statement_ranges_with_options(sql, options);
+    let cursor = utf16_offset_to_byte_index(sql, cursor_pos);
+
+    for (idx, statement) in statements.iter().enumerate() {
+        if cursor > statement.start && cursor < statement.end {
+            return statement_text_at_cursor(sql, statement, cursor, options);
+        }
+
+        if cursor == statement.start {
+            if cursor_has_sql_after_cursor_on_line(sql, cursor) {
+                return statement_text_at_cursor(sql, statement, cursor, options);
+            }
+            if let Some(prev) = idx.checked_sub(1).and_then(|prev_idx| statements.get(prev_idx)) {
+                return statement_text_at_cursor(sql, prev, cursor, options);
+            }
+            return statement_text_at_cursor(sql, statement, cursor, options);
+        }
+
+        if cursor < statement.start {
+            if let Some(prev) = idx.checked_sub(1).and_then(|prev_idx| statements.get(prev_idx)) {
+                return statement_text_at_cursor(sql, prev, cursor, options);
+            }
+            return statement_text_at_cursor(sql, statement, cursor, options);
+        }
+    }
+
+    statements
+        .last()
+        .map(|statement| statement_text_at_cursor(sql, statement, cursor, options))
+        .unwrap_or_else(|| sql.trim().to_string())
+}
+
+fn cursor_has_sql_after_cursor_on_line(sql: &str, cursor: usize) -> bool {
+    let line_end = sql[cursor..].find('\n').map_or(sql.len(), |offset| cursor + offset);
+    sql[cursor..line_end].chars().any(|ch| !ch.is_whitespace())
+}
+
+fn statement_text_at_cursor(
+    sql: &str,
+    statement: &SqlStatementRange,
+    cursor: usize,
+    options: SqlParsingOptions,
+) -> String {
+    let soft_ranges = split_statement_range_at_blank_lines(sql, statement, options);
+    find_statement_text_in_ranges(sql, &soft_ranges, cursor).unwrap_or_else(|| statement.text.clone())
+}
+
+fn find_statement_text_in_ranges(sql: &str, ranges: &[SqlStatementRange], cursor: usize) -> Option<String> {
+    for (idx, range) in ranges.iter().enumerate() {
+        if cursor > range.start && cursor < range.end {
+            return Some(range.text.clone());
+        }
+
+        if cursor == range.start {
+            if cursor_has_sql_after_cursor_on_line(sql, cursor) {
+                return Some(range.text.clone());
+            }
+            if let Some(prev) = idx.checked_sub(1).and_then(|prev_idx| ranges.get(prev_idx)) {
+                return Some(prev.text.clone());
+            }
+            return Some(range.text.clone());
+        }
+
+        if cursor < range.start {
+            if let Some(prev) = idx.checked_sub(1).and_then(|prev_idx| ranges.get(prev_idx)) {
+                return Some(prev.text.clone());
+            }
+            return Some(range.text.clone());
+        }
+    }
+
+    ranges.last().map(|range| range.text.clone())
+}
+
+fn split_statement_range_at_blank_lines(
+    sql: &str,
+    statement: &SqlStatementRange,
+    options: SqlParsingOptions,
+) -> Vec<SqlStatementRange> {
+    if options.profile.supports_oracle_plsql_blocks && starts_with_oracle_plsql_block(&statement.text) {
+        return vec![statement.clone()];
+    }
+    if options.profile.supports_hana_do_blocks && starts_with_hana_do_block(&statement.text) {
+        return vec![statement.clone()];
+    }
+
+    let mut ranges = Vec::new();
+    let mut scanner = SqlScanner::with_profile(options.profile);
+    let mut current_start = statement.start;
+    let mut line_start = statement.start;
+    let mut line_has_non_whitespace = false;
+    let mut blank_line_run = 0usize;
+
+    for (relative_idx, ch) in sql[statement.start..statement.end].char_indices() {
+        let idx = statement.start + relative_idx;
+        if ch == '\n' {
+            if !line_has_non_whitespace && !scanner.is_masked() {
+                blank_line_run += 1;
+            } else {
+                blank_line_run = 0;
+            }
+            scanner.step(sql, idx, ch);
+            line_start = idx + ch.len_utf8();
+            line_has_non_whitespace = false;
+            continue;
+        }
+
+        if !line_has_non_whitespace && !ch.is_whitespace() {
+            if blank_line_run >= 2
+                && !scanner.is_masked()
+                && has_executable_sql_with_options(&sql[current_start..line_start], options)
+                && starts_with_soft_statement_keyword(&sql[line_start..statement.end], options)
+            {
+                push_statement_range(&mut ranges, sql, current_start, line_start, options);
+                current_start = line_start;
+            }
+            blank_line_run = 0;
+            line_has_non_whitespace = true;
+        }
+
+        scanner.step(sql, idx, ch);
+    }
+
+    push_statement_range(&mut ranges, sql, current_start, statement.end, options);
+    if ranges.is_empty() {
+        vec![statement.clone()]
+    } else {
+        ranges
+    }
+}
+
+fn starts_with_soft_statement_keyword(sql: &str, options: SqlParsingOptions) -> bool {
+    if options.profile.supports_hana_do_blocks && starts_with_executable_sql_keyword_with_options(sql, &["DO"], options)
+    {
+        return true;
+    }
+    starts_with_executable_sql_keyword_with_options(
+        sql,
+        &[
+            "CREATE", "ALTER", "DROP", "INSERT", "UPDATE", "DELETE", "MERGE", "REPLACE", "TRUNCATE", "GRANT", "REVOKE",
+            "COMMENT", "EXPLAIN", "SHOW", "DESCRIBE", "USE", "SET", "CALL", "EXEC", "EXECUTE", "BEGIN", "COMMIT",
+            "ROLLBACK", "DECLARE", "ANALYZE", "VACUUM", "PRAGMA", "REFRESH", "COPY",
+        ],
+        options,
+    )
+}
+
+#[allow(dead_code)]
+fn split_sql_statement_ranges(sql: &str) -> Vec<SqlStatementRange> {
+    split_sql_statement_ranges_with_options(sql, SqlParsingOptions::default())
+}
+
+fn split_sql_statement_ranges_with_options(sql: &str, options: SqlParsingOptions) -> Vec<SqlStatementRange> {
+    let mut ranges = Vec::new();
+    let mut start = 0;
+    let mut i = 0;
+    let mut in_single_quote = false;
+    let mut in_double_quote = false;
+    let mut in_backtick = false;
+    let mut in_line_comment = false;
+    let mut in_block_comment = false;
+    let mut dollar_quote_tag: Option<String> = None;
+    let mut custom_delimiter: Option<String> = None;
+
+    while i < sql.len() {
+        if let Some(tag) = &dollar_quote_tag {
+            if sql[i..].starts_with(tag) {
+                i += tag.len();
+                dollar_quote_tag = None;
+                continue;
+            }
+            i += next_char_len(sql, i);
+            continue;
+        }
+
+        let ch = next_char(sql, i);
+        let next = next_char_at(sql, i + ch.len_utf8());
+
+        if in_line_comment {
+            i += ch.len_utf8();
+            if ch == '\n' {
+                in_line_comment = false;
+            }
+            continue;
+        }
+
+        if in_block_comment {
+            if ch == '*' && next == Some('/') {
+                i += 2;
+                in_block_comment = false;
+            } else {
+                i += ch.len_utf8();
+            }
+            continue;
+        }
+
+        if !in_single_quote && !in_double_quote && !in_backtick {
+            if ch == '-' && next == Some('-') {
+                in_line_comment = true;
+                i += 2;
+                continue;
+            }
+            if options.profile.supports_hash_line_comments && ch == '#' {
+                in_line_comment = true;
+                i += ch.len_utf8();
+                continue;
+            }
+            if ch == '/' && next == Some('*') {
+                in_block_comment = true;
+                i += 2;
+                continue;
+            }
+            if let Some(tag) =
+                options.profile.supports_dollar_quoted_strings.then(|| dollar_quote_tag_at_str(sql, i)).flatten()
+            {
+                if custom_delimiter.is_none() && !is_on_delimiter_line(sql, start, i) {
+                    i += tag.len();
+                    dollar_quote_tag = Some(tag);
+                    continue;
+                }
+            }
+            if ch == '\n' {
+                let line_start = sql[..i].rfind('\n').map_or(0, |pos| pos + 1);
+                let line = sql[line_start..i].trim();
+                if options.profile.supports_slash_line_block_delimiter && line == "/" {
+                    push_statement_range(&mut ranges, sql, start, line_start, options);
+                    start = i + ch.len_utf8();
+                    i = start;
+                    continue;
+                }
+                if let Some(new_delimiter) =
+                    options.profile.supports_custom_delimiter_commands.then(|| parse_delimiter_command(line)).flatten()
+                {
+                    let before = sql[start..line_start].trim();
+                    if has_executable_sql_with_options(before, options) {
+                        push_statement_range(&mut ranges, sql, start, line_start, options);
+                    }
+                    custom_delimiter = if new_delimiter == ";" { None } else { Some(new_delimiter.to_string()) };
+                    start = i + ch.len_utf8();
+                    i = start;
+                    continue;
+                }
+            }
+        }
+
+        match ch {
+            '\'' if !in_double_quote && !in_backtick && !is_escaped_single_quote(sql, i) => {
+                in_single_quote = !in_single_quote;
+                i += ch.len_utf8();
+            }
+            '"' if !in_single_quote && !in_backtick => {
+                in_double_quote = !in_double_quote;
+                i += ch.len_utf8();
+            }
+            '`' if !in_single_quote && !in_double_quote => {
+                in_backtick = !in_backtick;
+                i += ch.len_utf8();
+            }
+            ';' if !in_single_quote
+                && !in_double_quote
+                && !in_backtick
+                && custom_delimiter.is_none()
+                && !(options.profile.supports_custom_delimiter_commands && is_on_delimiter_line(sql, start, i)) =>
+            {
+                let is_mysql_routine =
+                    options.profile.supports_mysql_routine_blocks && starts_with_mysql_routine_block(&sql[start..i]);
+                if is_mysql_routine {
+                    if !mysql_routine_block_is_complete(&sql[start..i + ch.len_utf8()]) {
+                        i += ch.len_utf8();
+                        continue;
+                    }
+                    push_statement_range(&mut ranges, sql, start, i, options);
+                } else {
+                    let is_oracle_plsql =
+                        options.profile.supports_oracle_plsql_blocks && starts_with_oracle_plsql_block(&sql[start..i]);
+                    if is_oracle_plsql {
+                        if !oracle_plsql_block_is_complete(&sql[start..i + ch.len_utf8()]) {
+                            i += ch.len_utf8();
+                            continue;
+                        }
+                        push_statement_range(&mut ranges, sql, start, i + ch.len_utf8(), options);
+                    } else if options.profile.supports_hana_do_blocks && starts_with_hana_do_block(&sql[start..i]) {
+                        if !hana_do_block_is_complete(&sql[start..i + ch.len_utf8()]) {
+                            i += ch.len_utf8();
+                            continue;
+                        }
+                        push_statement_range(&mut ranges, sql, start, i + ch.len_utf8(), options);
+                    } else {
+                        push_statement_range(&mut ranges, sql, start, i, options);
+                    }
+                }
+                i += ch.len_utf8();
+                start = i;
+            }
+            _ => {
+                i += ch.len_utf8();
+                if !in_single_quote && !in_double_quote && !in_backtick {
+                    if let Some(delimiter) = &custom_delimiter {
+                        if sql[start..i].ends_with(delimiter) {
+                            let end = i - delimiter.len();
+                            push_statement_range(&mut ranges, sql, start, end, options);
+                            start = i;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let trimmed = sql[start..].trim();
+    let last_line = trimmed.rsplit('\n').next().unwrap_or(trimmed).trim();
+    if options.profile.supports_custom_delimiter_commands && parse_delimiter_command(last_line).is_some() {
+        if let Some(line_start) = sql[start..].rfind('\n').map(|pos| start + pos + 1) {
+            push_statement_range(&mut ranges, sql, start, line_start, options);
+        }
+    } else if options.profile.supports_slash_line_block_delimiter && last_line == "/" {
+        if let Some(line_start) = sql[start..].rfind('\n').map(|pos| start + pos + 1) {
+            push_statement_range(&mut ranges, sql, start, line_start, options);
+        }
+    } else {
+        push_statement_range(&mut ranges, sql, start, sql.len(), options);
+    }
+
+    ranges
+}
+
+fn push_statement_range(
+    ranges: &mut Vec<SqlStatementRange>,
+    sql: &str,
+    start: usize,
+    end: usize,
+    options: SqlParsingOptions,
+) {
+    let Some((relative_start, relative_end)) = executable_sql_bounds(&sql[start..end], options) else {
+        return;
+    };
+    let statement_start = start + relative_start;
+    let statement_end = start + relative_end;
+    let text = sql[statement_start..statement_end].to_string();
+    if !text.is_empty() {
+        ranges.push(SqlStatementRange { text, start: statement_start, end: statement_end });
+    }
+}
+
+fn utf16_offset_to_byte_index(sql: &str, offset: usize) -> usize {
+    let mut utf16_seen = 0;
+    for (byte_index, ch) in sql.char_indices() {
+        if utf16_seen >= offset {
+            return byte_index;
+        }
+        utf16_seen += ch.len_utf16();
+        if utf16_seen > offset {
+            return byte_index + ch.len_utf8();
+        }
+    }
+    sql.len()
+}
+
+fn next_char(sql: &str, index: usize) -> char {
+    sql[index..].chars().next().unwrap_or('\0')
+}
+
+fn next_char_at(sql: &str, index: usize) -> Option<char> {
+    if index >= sql.len() {
+        None
+    } else {
+        sql[index..].chars().next()
+    }
+}
+
+fn next_char_len(sql: &str, index: usize) -> usize {
+    next_char(sql, index).len_utf8()
+}
+
+fn is_escaped_single_quote(sql: &str, index: usize) -> bool {
+    index > 0 && sql.as_bytes().get(index - 1) == Some(&b'\\')
+}
+
+fn is_on_delimiter_line(sql: &str, range_start: usize, index: usize) -> bool {
+    let line_start = sql[range_start..index].rfind('\n').map_or(range_start, |pos| range_start + pos + 1);
+    sql[line_start..index]
+        .trim_start()
+        .as_bytes()
+        .get(..9)
+        .is_some_and(|prefix| prefix.eq_ignore_ascii_case(b"delimiter"))
+}
+
+fn dollar_quote_tag_at_str(sql: &str, index: usize) -> Option<String> {
+    let rest = &sql[index..];
+    if !rest.starts_with('$') {
+        return None;
+    }
+    let end = rest[1..].find('$')? + 1;
+    let tag = &rest[..=end];
+    if tag.len() == 2 {
+        return Some(tag.to_string());
+    }
+    let name = &tag[1..tag.len() - 1];
+    if !name.chars().all(|ch| ch == '_' || ch.is_ascii_alphanumeric()) {
+        return None;
+    }
+    Some(tag.to_string())
+}
+
+pub fn split_sql_batches(sql: &str) -> Vec<String> {
+    let ranges = split_sql_batch_ranges(sql, SqlDialectProfile::sql_server());
+    if ranges.is_empty() {
+        let trimmed = sql.trim();
+        return if trimmed.is_empty() { Vec::new() } else { vec![trimmed.to_string()] };
+    }
+    ranges.into_iter().map(|range| range.text).collect()
+}
+
+fn split_sql_batch_ranges(sql: &str, profile: SqlDialectProfile) -> Vec<SqlStatementRange> {
+    let mut batches = Vec::new();
+    let mut current_start = 0;
+    let lines: Vec<&str> = sql.split('\n').collect();
+    let mut offset = 0;
+    let mut scanner = SqlScanner::with_profile(profile);
+
+    for line in &lines {
+        let line_start = offset;
+        let line_end = offset + line.len();
+        offset = line_end + 1; // +1 for the '\n'
+
+        let trimmed = line.trim();
+        let is_batch_separator = profile.supports_go_batch_separator
+            && !scanner.is_masked()
+            && (trimmed.eq_ignore_ascii_case("go")
+                || trimmed.to_ascii_lowercase().starts_with("go ") && trimmed[2..].trim().is_empty());
+        if is_batch_separator {
+            push_batch_range(&mut batches, sql, current_start, line_start);
+            current_start = line_end.min(sql.len());
+            if current_start < sql.len() && sql.as_bytes()[current_start] == b'\n' {
+                current_start += 1;
+            }
+        } else {
+            for (relative_idx, ch) in line.char_indices() {
+                scanner.step(sql, line_start + relative_idx, ch);
+            }
+        }
+        if line_end < sql.len() {
+            scanner.step(sql, line_end, '\n');
+        }
+    }
+
+    push_batch_range(&mut batches, sql, current_start, sql.len());
+    batches
+}
+
+fn push_batch_range(ranges: &mut Vec<SqlStatementRange>, sql: &str, start: usize, end: usize) {
+    let Some((relative_start, relative_end)) = executable_sql_bounds(&sql[start..end], SqlParsingOptions::default())
+    else {
+        return;
+    };
+    let statement_start = start + relative_start;
+    let statement_end = start + relative_end;
+    let text = sql[statement_start..statement_end].to_string();
+    if !text.is_empty() {
+        ranges.push(SqlStatementRange { text, start: statement_start, end: statement_end });
+    }
+}
+
+fn find_sqlserver_statement_at_cursor(sql: &str, cursor_pos: usize) -> String {
+    let profile = SqlDialectProfile::sql_server();
+    let cursor = utf16_offset_to_byte_index(sql, cursor_pos);
+    let batches = split_sql_batch_ranges(sql, profile);
+
+    for (idx, batch) in batches.iter().enumerate() {
+        if cursor >= batch.start && cursor <= batch.end {
+            if profile.keeps_sqlserver_module_batch_at_cursor && starts_with_sqlserver_module_ddl(&batch.text) {
+                return batch.text.clone();
+            }
+            let relative_cursor = sql[..cursor].encode_utf16().count() - sql[..batch.start].encode_utf16().count();
+            return find_statement_at_cursor_with_options(&batch.text, relative_cursor, SqlParsingOptions::default());
+        }
+
+        if cursor < batch.start {
+            if let Some(prev) = idx.checked_sub(1).and_then(|prev_idx| batches.get(prev_idx)) {
+                if profile.keeps_sqlserver_module_batch_at_cursor && starts_with_sqlserver_module_ddl(&prev.text) {
+                    return prev.text.clone();
+                }
+                let relative_cursor = prev.text.encode_utf16().count();
+                return find_statement_at_cursor_with_options(
+                    &prev.text,
+                    relative_cursor,
+                    SqlParsingOptions::default(),
+                );
+            }
+            return batch.text.clone();
+        }
+    }
+
+    batches.last().map(|batch| batch.text.clone()).unwrap_or_else(|| sql.trim().to_string())
+}
+
+fn starts_with_sqlserver_module_ddl(sql: &str) -> bool {
+    let tokens = first_sql_tokens(sql, 4);
+    if tokens.len() >= 4
+        && tokens[0].eq_ignore_ascii_case("CREATE")
+        && tokens[1].eq_ignore_ascii_case("OR")
+        && tokens[2].eq_ignore_ascii_case("ALTER")
+    {
+        return is_sqlserver_module_keyword(&tokens[3]);
+    }
+
+    tokens.len() >= 2
+        && (tokens[0].eq_ignore_ascii_case("CREATE") || tokens[0].eq_ignore_ascii_case("ALTER"))
+        && is_sqlserver_module_keyword(&tokens[1])
+}
+
+fn is_sqlserver_module_keyword(token: &str) -> bool {
+    ["FUNCTION", "PROC", "PROCEDURE", "TRIGGER", "VIEW"].iter().any(|keyword| token.eq_ignore_ascii_case(keyword))
+}
+
+fn starts_with_mysql_routine_block(sql: &str) -> bool {
+    is_mysql_routine_ddl_start(sql) && mysql_routine_tokens(sql).iter().any(|token| token.eq_ignore_ascii_case("BEGIN"))
+}
+
+fn is_mysql_routine_ddl_start(sql: &str) -> bool {
+    let executable = leading_executable_sql_with_options(sql, SqlParsingOptions::mysql_compatible());
+    let tokens = first_sql_tokens(executable, 16);
+    if tokens.first().is_none_or(|token| !token.eq_ignore_ascii_case("CREATE")) {
+        return false;
+    }
+
+    for token in tokens.iter().skip(1) {
+        if ["PROCEDURE", "FUNCTION", "TRIGGER", "EVENT"].iter().any(|keyword| token.eq_ignore_ascii_case(keyword)) {
+            return true;
+        }
+        if [
+            "DATABASE",
+            "INDEX",
+            "LOGFILE",
+            "ROLE",
+            "SCHEMA",
+            "SERVER",
+            "SPATIAL",
+            "TABLE",
+            "TEMPORARY",
+            "UNIQUE",
+            "USER",
+            "VIEW",
+        ]
+        .iter()
+        .any(|keyword| token.eq_ignore_ascii_case(keyword))
+        {
+            return false;
+        }
+    }
+
+    false
+}
+
+fn mysql_routine_block_is_complete(sql: &str) -> bool {
+    if !starts_with_mysql_routine_block(sql) {
+        return false;
+    }
+
+    let tokens = mysql_routine_tokens(sql);
+    let mut begin_depth = 0usize;
+    let mut saw_begin = false;
+
+    for (index, token) in tokens.iter().enumerate() {
+        if token == ";" {
+            continue;
+        }
+        if token.eq_ignore_ascii_case("BEGIN") {
+            if previous_mysql_routine_word(&tokens, index).is_some_and(|previous| previous.eq_ignore_ascii_case("END"))
+            {
+                continue;
+            }
+            saw_begin = true;
+            begin_depth += 1;
+            continue;
+        }
+        if token.eq_ignore_ascii_case("END") && saw_begin {
+            if next_mysql_routine_word(&tokens, index).is_some_and(is_mysql_control_block_suffix) {
+                continue;
+            }
+            begin_depth = begin_depth.saturating_sub(1);
+        }
+    }
+
+    saw_begin && begin_depth == 0 && tokens.last().is_some_and(|token| token == ";")
+}
+
+fn is_mysql_control_block_suffix(token: &str) -> bool {
+    ["IF", "LOOP", "CASE", "REPEAT", "WHILE"].iter().any(|keyword| token.eq_ignore_ascii_case(keyword))
+}
+
+fn previous_mysql_routine_word(tokens: &[String], index: usize) -> Option<&str> {
+    tokens[..index].iter().rev().find(|token| token.as_str() != ";").map(String::as_str)
+}
+
+fn next_mysql_routine_word(tokens: &[String], index: usize) -> Option<&str> {
+    tokens.get(index + 1..)?.iter().find(|token| token.as_str() != ";").map(String::as_str)
+}
+
+fn mysql_routine_tokens(sql: &str) -> Vec<String> {
+    let chars = sql.chars().collect::<Vec<_>>();
+    let mut tokens = Vec::new();
+    let mut in_line_comment = false;
+    let mut in_block_comment = false;
+    let mut in_single_quote = false;
+    let mut in_double_quote = false;
+    let mut in_backtick = false;
+    let mut i = 0;
+
+    while i < chars.len() {
+        let ch = chars[i];
+        let next = chars.get(i + 1).copied();
+
+        if in_line_comment {
+            if ch == '\n' {
+                in_line_comment = false;
+            }
+            i += 1;
+            continue;
+        }
+
+        if in_block_comment {
+            if ch == '*' && next == Some('/') {
+                in_block_comment = false;
+                i += 2;
+            } else {
+                i += 1;
+            }
+            continue;
+        }
+
+        if in_single_quote {
+            if ch == '\\' && next.is_some() {
+                i += 2;
+                continue;
+            }
+            if ch == '\'' {
+                if next == Some('\'') {
+                    i += 2;
+                    continue;
+                }
+                in_single_quote = false;
+            }
+            i += 1;
+            continue;
+        }
+
+        if in_double_quote {
+            if ch == '\\' && next.is_some() {
+                i += 2;
+                continue;
+            }
+            if ch == '"' {
+                if next == Some('"') {
+                    i += 2;
+                    continue;
+                }
+                in_double_quote = false;
+            }
+            i += 1;
+            continue;
+        }
+
+        if in_backtick {
+            if ch == '`' {
+                if next == Some('`') {
+                    i += 2;
+                    continue;
+                }
+                in_backtick = false;
+            }
+            i += 1;
+            continue;
+        }
+
+        if ch == '-' && next == Some('-') {
+            in_line_comment = true;
+            i += 2;
+            continue;
+        }
+        if ch == '#' {
+            in_line_comment = true;
+            i += 1;
+            continue;
+        }
+        if ch == '/' && next == Some('*') {
+            in_block_comment = true;
+            i += 2;
+            continue;
+        }
+        if ch == '\'' {
+            in_single_quote = true;
+            i += 1;
+            continue;
+        }
+        if ch == '"' {
+            in_double_quote = true;
+            i += 1;
+            continue;
+        }
+        if ch == '`' {
+            in_backtick = true;
+            i += 1;
+            continue;
+        }
+        if ch == ';' {
+            tokens.push(";".to_string());
+            i += 1;
+            continue;
+        }
+        if ch == '_' || ch.is_ascii_alphabetic() {
+            let start = i;
+            i += 1;
+            while i < chars.len() && is_sql_ident_char(chars[i]) {
+                i += 1;
+            }
+            tokens.push(chars[start..i].iter().collect::<String>().to_ascii_uppercase());
+            continue;
+        }
+
+        i += 1;
+    }
+
+    tokens
+}
+
+fn first_sql_tokens(sql: &str, limit: usize) -> Vec<String> {
+    let mut tokens = Vec::new();
+    for token in sql.split(|ch: char| !ch.is_ascii_alphanumeric() && ch != '_') {
+        if token.is_empty() {
+            continue;
+        }
+        tokens.push(token.to_string());
+        if tokens.len() >= limit {
+            break;
+        }
+    }
+    tokens
+}
+
+fn parse_delimiter_command(line: &str) -> Option<&str> {
+    let bytes = line.as_bytes();
+    let rest = if bytes.len() > 10
+        && (bytes[..10].eq_ignore_ascii_case(b"delimiter ") || bytes[..10].eq_ignore_ascii_case(b"delimiter\t"))
+    {
+        Some(&line[10..])
+    } else {
+        None
+    };
+    rest.map(|r| r.trim()).filter(|r| !r.is_empty())
+}
+
+pub fn statement_summary(statement: &str) -> String {
+    const MAX_LEN: usize = 120;
+
+    let collapsed = statement.split_whitespace().collect::<Vec<_>>().join(" ");
+    if collapsed.chars().count() <= MAX_LEN {
+        return collapsed;
+    }
+
+    collapsed.chars().take(MAX_LEN).collect()
+}
+
+pub fn prepare_sql_file_statement(
+    statement: &str,
+    db_type: &DatabaseType,
+    driver_profile: Option<&str>,
+) -> SqlFileStatementAction {
+    let statement = statement.trim();
+    let is_mysql_compatible_target = is_mysql_compatible_import_target(db_type, driver_profile);
+    if is_mysql_compatible_target && is_mysql_lock_table_statement(statement) {
+        return SqlFileStatementAction::Skip;
+    }
+
+    let Some(body) = mysql_executable_comment_body(statement) else {
+        if is_mysql_compatible_target && is_mysql_session_restore_statement(statement) {
+            return SqlFileStatementAction::Skip;
+        }
+        return SqlFileStatementAction::Execute(statement.to_string());
+    };
+
+    if !is_mysql_compatible_target {
+        return SqlFileStatementAction::Skip;
+    }
+
+    let body = body.trim();
+    if body.is_empty() || is_mysql_key_toggle_statement(body) || is_mysql_session_restore_statement(body) {
+        return SqlFileStatementAction::Skip;
+    }
+
+    SqlFileStatementAction::Execute(body.to_string())
+}
+
+pub fn optimize_sql_file_import_statements(
+    statements: &[String],
+    db_type: Option<DatabaseType>,
+    driver_profile: Option<&str>,
+) -> Vec<SqlFileImportStatement> {
+    let mut optimized = Vec::new();
+    let mut pending_insert: Option<PendingInsertBatch> = None;
+
+    for statement in statements {
+        let action = db_type
+            .as_ref()
+            .map(|db_type| prepare_sql_file_statement(statement, db_type, driver_profile))
+            .unwrap_or_else(|| SqlFileStatementAction::Execute(statement.trim().to_string()));
+
+        match action {
+            SqlFileStatementAction::Skip => {
+                flush_pending_insert(&mut optimized, &mut pending_insert);
+                optimized.push(SqlFileImportStatement {
+                    kind: SqlFileImportStatementKind::Skip,
+                    sql: statement.trim().to_string(),
+                    source_sqls: vec![statement.trim().to_string()],
+                    source_statement_count: 1,
+                });
+            }
+            SqlFileStatementAction::Execute(sql) => {
+                let options = db_type.map(SqlParsingOptions::for_database_type).unwrap_or_default();
+                if let Some(insert) = parse_mergeable_insert(&sql, options) {
+                    match pending_insert.as_mut() {
+                        Some(batch) if batch.can_accept(&insert) => batch.push(insert),
+                        Some(_) => {
+                            flush_pending_insert(&mut optimized, &mut pending_insert);
+                            pending_insert = Some(PendingInsertBatch::new(insert));
+                        }
+                        None => {
+                            pending_insert = Some(PendingInsertBatch::new(insert));
+                        }
+                    }
+                } else {
+                    flush_pending_insert(&mut optimized, &mut pending_insert);
+                    optimized.push(SqlFileImportStatement {
+                        kind: SqlFileImportStatementKind::Execute,
+                        sql: sql.clone(),
+                        source_sqls: vec![sql],
+                        source_statement_count: 1,
+                    });
+                }
+            }
+        }
+    }
+
+    flush_pending_insert(&mut optimized, &mut pending_insert);
+    optimized
+}
+
+fn flush_pending_insert(optimized: &mut Vec<SqlFileImportStatement>, pending_insert: &mut Option<PendingInsertBatch>) {
+    if let Some(batch) = pending_insert.take() {
+        optimized.push(SqlFileImportStatement {
+            kind: SqlFileImportStatementKind::Execute,
+            sql: batch.to_sql(),
+            source_sqls: batch.source_sqls,
+            source_statement_count: batch.source_statement_count,
+        });
+    }
+}
+
+const SQL_FILE_INSERT_BATCH_MAX_STATEMENTS: usize = 500;
+const SQL_FILE_INSERT_BATCH_MAX_BYTES: usize = 4 * 1024 * 1024;
+
+#[derive(Debug, Clone)]
+struct MergeableInsert {
+    prefix: String,
+    prefix_key: String,
+    values: String,
+    sql: String,
+}
+
+#[derive(Debug, Clone)]
+struct PendingInsertBatch {
+    prefix: String,
+    prefix_key: String,
+    values: Vec<String>,
+    source_sqls: Vec<String>,
+    source_statement_count: usize,
+    byte_len: usize,
+}
+
+impl PendingInsertBatch {
+    fn new(insert: MergeableInsert) -> Self {
+        let byte_len = insert.prefix.len() + insert.values.len() + 16;
+        Self {
+            prefix: insert.prefix,
+            prefix_key: insert.prefix_key,
+            values: vec![insert.values],
+            source_sqls: vec![insert.sql],
+            source_statement_count: 1,
+            byte_len,
+        }
+    }
+
+    fn can_accept(&self, insert: &MergeableInsert) -> bool {
+        self.prefix_key == insert.prefix_key
+            && self.source_statement_count < SQL_FILE_INSERT_BATCH_MAX_STATEMENTS
+            && self.byte_len + insert.values.len() + 3 <= SQL_FILE_INSERT_BATCH_MAX_BYTES
+    }
+
+    fn push(&mut self, insert: MergeableInsert) {
+        self.byte_len += insert.values.len() + 3;
+        self.values.push(insert.values);
+        self.source_sqls.push(insert.sql);
+        self.source_statement_count += 1;
+    }
+
+    fn to_sql(&self) -> String {
+        if self.source_statement_count == 1 {
+            return self.source_sqls.first().cloned().unwrap_or_default();
+        }
+        format!("{} VALUES\n{}", self.prefix, self.values.join(",\n"))
+    }
+}
+
+fn parse_mergeable_insert(sql: &str, options: SqlParsingOptions) -> Option<MergeableInsert> {
+    let executable = leading_executable_sql_with_options(sql, options).trim().trim_end_matches(';').trim();
+    if !starts_with_keyword(executable, "insert") {
+        return None;
+    }
+
+    let (values_start, values_end) = find_top_level_values_keyword(executable)?;
+    let prefix_without_values = executable[..values_start].trim_end();
+    let values = executable[values_end..].trim();
+    let values = parse_insert_values_tail(values)?;
+
+    let prefix = prefix_without_values.to_string();
+    Some(MergeableInsert {
+        prefix_key: normalize_insert_prefix_key(&prefix),
+        prefix,
+        values,
+        sql: executable.to_string(),
+    })
+}
+
+fn find_top_level_values_keyword(sql: &str) -> Option<(usize, usize)> {
+    let mut scanner = SqlScanner::default();
+    let mut depth = 0usize;
+
+    for (idx, ch) in sql.char_indices() {
+        scanner.step(sql, idx, ch);
+        if scanner.is_masked() {
+            continue;
+        }
+
+        match ch {
+            '(' => depth += 1,
+            ')' => depth = depth.saturating_sub(1),
+            _ if depth == 0 => {
+                for keyword in ["values", "value"] {
+                    if keyword_at(sql, idx, keyword) {
+                        return Some((idx, idx + keyword.len()));
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    None
+}
+
+fn parse_insert_values_tail(tail: &str) -> Option<String> {
+    let tail = tail.trim().trim_end_matches(';').trim();
+    if tail.is_empty() {
+        return None;
+    }
+
+    let mut scanner = SqlScanner::default();
+    let mut depth = 0usize;
+    let mut saw_tuple = false;
+    let mut expecting_tuple = true;
+
+    for (idx, ch) in tail.char_indices() {
+        scanner.step(tail, idx, ch);
+        if scanner.is_masked() {
+            continue;
+        }
+
+        if expecting_tuple {
+            if ch.is_whitespace() || (saw_tuple && ch == ',') {
+                continue;
+            }
+            if ch != '(' {
+                return None;
+            }
+            expecting_tuple = false;
+            saw_tuple = true;
+            depth = 1;
+            continue;
+        }
+
+        match ch {
+            '(' => depth += 1,
+            ')' => {
+                depth = depth.checked_sub(1)?;
+                if depth == 0 {
+                    expecting_tuple = true;
+                }
+            }
+            ',' if depth == 0 => {}
+            _ if depth == 0 && !ch.is_whitespace() => return None,
+            _ => {}
+        }
+    }
+
+    if saw_tuple && depth == 0 {
+        Some(tail.to_string())
+    } else {
+        None
+    }
+}
+
+struct SqlScanner {
+    profile: SqlDialectProfile,
+    in_single_quote: bool,
+    in_double_quote: bool,
+    in_backtick: bool,
+    in_line_comment: bool,
+    in_block_comment: bool,
+    dollar_quote_tag: Option<String>,
+    previous: Option<char>,
+}
+
+impl SqlScanner {
+    fn with_profile(profile: SqlDialectProfile) -> Self {
+        Self { profile, ..Self::default() }
+    }
+
+    fn step(&mut self, sql: &str, idx: usize, ch: char) {
+        if let Some(tag) = self.dollar_quote_tag.clone() {
+            if sql[idx..].starts_with(&tag) {
+                self.dollar_quote_tag = None;
+            }
+            self.previous = Some(ch);
+            return;
+        }
+
+        let next = next_char_at(sql, idx + ch.len_utf8());
+        if self.in_line_comment {
+            if ch == '\n' {
+                self.in_line_comment = false;
+            }
+            self.previous = Some(ch);
+            return;
+        }
+        if self.in_block_comment {
+            if self.previous == Some('*') && ch == '/' {
+                self.in_block_comment = false;
+            }
+            self.previous = Some(ch);
+            return;
+        }
+
+        if !self.in_single_quote && !self.in_double_quote && !self.in_backtick {
+            if ch == '-' && next == Some('-') {
+                self.in_line_comment = true;
+            } else if self.profile.supports_hash_line_comments && ch == '#' {
+                self.in_line_comment = true;
+            } else if ch == '/' && next == Some('*') {
+                self.in_block_comment = true;
+            } else if let Some(tag) =
+                self.profile.supports_dollar_quoted_strings.then(|| dollar_quote_tag_at_str(sql, idx)).flatten()
+            {
+                self.dollar_quote_tag = Some(tag);
+            }
+        }
+
+        match ch {
+            '\'' if !self.in_double_quote && !self.in_backtick && self.previous != Some('\\') => {
+                self.in_single_quote = !self.in_single_quote;
+            }
+            '"' if !self.in_single_quote && !self.in_backtick && self.previous != Some('\\') => {
+                self.in_double_quote = !self.in_double_quote;
+            }
+            '`' if !self.in_single_quote && !self.in_double_quote => {
+                self.in_backtick = !self.in_backtick;
+            }
+            _ => {}
+        }
+        self.previous = Some(ch);
+    }
+
+    fn is_masked(&self) -> bool {
+        self.in_single_quote
+            || self.in_double_quote
+            || self.in_backtick
+            || self.in_line_comment
+            || self.in_block_comment
+            || self.dollar_quote_tag.is_some()
+    }
+}
+
+impl Default for SqlScanner {
+    fn default() -> Self {
+        Self {
+            profile: SqlDialectProfile::default(),
+            in_single_quote: false,
+            in_double_quote: false,
+            in_backtick: false,
+            in_line_comment: false,
+            in_block_comment: false,
+            dollar_quote_tag: None,
+            previous: None,
+        }
+    }
+}
+
+fn keyword_at(sql: &str, idx: usize, keyword: &str) -> bool {
+    let end = idx + keyword.len();
+    sql.get(idx..end).is_some_and(|candidate| candidate.eq_ignore_ascii_case(keyword))
+        && sql[..idx].chars().next_back().is_none_or(|ch| !is_sql_ident_char(ch))
+        && sql.get(end..).and_then(|tail| tail.chars().next()).is_none_or(|ch| !is_sql_ident_char(ch))
+}
+
+fn starts_with_keyword(sql: &str, keyword: &str) -> bool {
+    sql.get(..keyword.len()).is_some_and(|candidate| candidate.eq_ignore_ascii_case(keyword))
+        && sql.get(keyword.len()..).and_then(|tail| tail.chars().next()).is_none_or(|ch| !is_sql_ident_char(ch))
+}
+
+fn is_sql_ident_char(ch: char) -> bool {
+    ch == '_' || ch == '$' || ch.is_ascii_alphanumeric()
+}
+
+fn normalize_insert_prefix_key(prefix: &str) -> String {
+    let mut scanner = SqlScanner::default();
+    let mut key = String::with_capacity(prefix.len());
+    let mut previous_space = false;
+
+    for (idx, ch) in prefix.char_indices() {
+        scanner.step(prefix, idx, ch);
+        if scanner.in_single_quote
+            || scanner.in_double_quote
+            || scanner.in_backtick
+            || scanner.dollar_quote_tag.is_some()
+        {
+            key.push(ch);
+            previous_space = false;
+            continue;
+        }
+
+        if ch.is_whitespace() {
+            if !previous_space {
+                key.push(' ');
+            }
+            previous_space = true;
+        } else {
+            key.push(ch.to_ascii_lowercase());
+            previous_space = false;
+        }
+    }
+
+    key.trim().to_string()
+}
+
+pub fn starts_with_executable_sql_keyword(sql: &str, keywords: &[&str]) -> bool {
+    starts_with_executable_sql_keyword_with_options(sql, keywords, SqlParsingOptions::default())
+}
+
+pub fn starts_with_executable_sql_keyword_for_database(sql: &str, keywords: &[&str], db_type: DatabaseType) -> bool {
+    starts_with_executable_sql_keyword_with_options(sql, keywords, SqlParsingOptions::for_database_type(db_type))
+}
+
+pub fn starts_with_duckdb_result_sql_keyword(sql: &str) -> bool {
+    starts_with_executable_sql_keyword(
+        sql,
+        &[
+            "SELECT",
+            "SHOW",
+            "DESCRIBE",
+            "EXPLAIN",
+            "WITH",
+            "PRAGMA",
+            "FROM",
+            "SUMMARIZE",
+            "SUMMARISE",
+            "PIVOT",
+            "UNPIVOT",
+        ],
+    )
+}
+
+pub fn starts_with_executable_sql_keyword_with_options(
+    sql: &str,
+    keywords: &[&str],
+    options: SqlParsingOptions,
+) -> bool {
+    let Some(token) = first_executable_sql_token_with_options(sql, options) else {
+        return false;
+    };
+    keywords.iter().any(|keyword| executable_sql_keyword_matches(token, keyword))
+}
+
+fn executable_sql_keyword_matches(token: &str, keyword: &str) -> bool {
+    token.eq_ignore_ascii_case(keyword)
+        || (keyword.eq_ignore_ascii_case("DESCRIBE") && token.eq_ignore_ascii_case("DESC"))
+}
+
+fn is_mysql_compatible_import_profile(profile: &str) -> bool {
+    matches!(
+        profile,
+        "mariadb"
+            | "tidb"
+            | "oceanbase"
+            | "custom_mysql"
+            | "doris"
+            | "starrocks"
+            | "manticoresearch"
+            | "selectdb"
+            | "goldendb"
+    )
+}
+
+pub(crate) fn supports_connection_level_database_bootstrap_target(
+    db_type: &DatabaseType,
+    driver_profile: Option<&str>,
+) -> bool {
+    matches!(db_type, DatabaseType::Mysql | DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::Goldendb)
+        || driver_profile
+            .map(|profile| profile.to_ascii_lowercase())
+            .is_some_and(|profile| is_mysql_compatible_import_profile(&profile) && profile != "manticoresearch")
+}
+
+fn is_mysql_compatible_import_target(db_type: &DatabaseType, driver_profile: Option<&str>) -> bool {
+    matches!(
+        db_type,
+        DatabaseType::Mysql
+            | DatabaseType::Doris
+            | DatabaseType::StarRocks
+            | DatabaseType::ManticoreSearch
+            | DatabaseType::Goldendb
+    ) || driver_profile
+        .map(|profile| profile.to_ascii_lowercase())
+        .is_some_and(|profile| is_mysql_compatible_import_profile(&profile))
+}
+
+fn mysql_executable_comment_body(statement: &str) -> Option<&str> {
+    let bytes = statement.as_bytes();
+    let start = leading_mysql_executable_comment_start(statement)?;
+    let body_start = if bytes.get(start + 2) == Some(&b'!') { start + 3 } else { start + 4 };
+    let mut body_start = body_start;
+    while body_start < bytes.len() && (bytes[body_start].is_ascii_digit() || bytes[body_start].is_ascii_whitespace()) {
+        body_start += 1;
+    }
+
+    let close = find_block_comment_close(bytes, body_start)?;
+    if has_executable_sql(&statement[close + 2..]) {
+        return None;
+    }
+
+    Some(&statement[body_start..close])
+}
+
+fn leading_mysql_executable_comment_start(statement: &str) -> Option<usize> {
+    let bytes = statement.as_bytes();
+    let mut i = 0;
+
+    while i < bytes.len() {
+        while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+            i += 1;
+        }
+
+        if i + 1 < bytes.len() && bytes[i] == b'-' && bytes[i + 1] == b'-' {
+            i += 2;
+            while i < bytes.len() && bytes[i] != b'\n' {
+                i += 1;
+            }
+            continue;
+        }
+
+        if bytes[i] == b'#' {
+            i += 1;
+            while i < bytes.len() && bytes[i] != b'\n' {
+                i += 1;
+            }
+            continue;
+        }
+
+        if i + 1 < bytes.len() && bytes[i] == b'/' && bytes[i + 1] == b'*' {
+            if i + 2 < bytes.len() && (bytes[i + 2] == b'!' || (i + 3 < bytes.len() && &bytes[i + 2..i + 4] == b"M!")) {
+                return Some(i);
+            }
+
+            let close = find_block_comment_close(bytes, i + 2)?;
+            i = close + 2;
+            continue;
+        }
+
+        return None;
+    }
+
+    None
+}
+
+fn find_block_comment_close(bytes: &[u8], mut start: usize) -> Option<usize> {
+    while start + 1 < bytes.len() {
+        if bytes[start] == b'*' && bytes[start + 1] == b'/' {
+            return Some(start);
+        }
+        start += 1;
+    }
+    None
+}
+
+fn is_mysql_key_toggle_statement(statement: &str) -> bool {
+    let upper = statement.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_uppercase();
+    upper.starts_with("ALTER TABLE ") && (upper.ends_with(" ENABLE KEYS") || upper.ends_with(" DISABLE KEYS"))
+}
+
+fn is_mysql_lock_table_statement(statement: &str) -> bool {
+    let executable = leading_executable_sql(statement);
+    let upper = executable.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_uppercase();
+    upper == "UNLOCK TABLES" || (upper.starts_with("LOCK TABLES ") && upper.ends_with(" WRITE"))
+}
+
+fn is_mysql_session_restore_statement(statement: &str) -> bool {
+    let executable = leading_executable_sql_with_options(statement, SqlParsingOptions::mysql_compatible());
+    let upper = executable.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_uppercase();
+    if !upper.starts_with("SET ") {
+        return false;
+    }
+
+    let assignment = upper.trim_start_matches("SET ").trim();
+    if assignment.starts_with('@') {
+        return false;
+    }
+
+    assignment.contains("= @OLD_")
+        || assignment.contains("=@OLD_")
+        || assignment.contains("= @SAVED_")
+        || assignment.contains("=@SAVED_")
+}
+
+fn leading_executable_sql(sql: &str) -> &str {
+    leading_executable_sql_with_options(sql, SqlParsingOptions::default())
+}
+
+fn leading_executable_sql_with_options(sql: &str, options: SqlParsingOptions) -> &str {
+    let bytes = sql.as_bytes();
+    let mut i = 0;
+
+    while i < bytes.len() {
+        while i < bytes.len() && bytes[i].is_ascii_whitespace() {
+            i += 1;
+        }
+
+        if i + 1 < bytes.len() && bytes[i] == b'-' && bytes[i + 1] == b'-' {
+            i += 2;
+            while i < bytes.len() && bytes[i] != b'\n' {
+                i += 1;
+            }
+            continue;
+        }
+
+        if options.profile.supports_hash_line_comments && bytes[i] == b'#' {
+            i += 1;
+            while i < bytes.len() && bytes[i] != b'\n' {
+                i += 1;
+            }
+            continue;
+        }
+
+        if i + 1 < bytes.len() && bytes[i] == b'/' && bytes[i + 1] == b'*' {
+            if i + 2 < bytes.len() && (bytes[i + 2] == b'!' || (i + 3 < bytes.len() && &bytes[i + 2..i + 4] == b"M!")) {
+                break;
+            }
+
+            let Some(close) = find_block_comment_close(bytes, i + 2) else {
+                return &sql[sql.len()..];
+            };
+            i = close + 2;
+            continue;
+        }
+
+        break;
+    }
+
+    &sql[i..]
+}
+
+fn first_executable_sql_token_with_options(sql: &str, options: SqlParsingOptions) -> Option<&str> {
+    let bytes = sql.as_bytes();
+    let mut i = 0;
+
+    while i < bytes.len() {
+        while i < bytes.len() && (bytes[i].is_ascii_whitespace() || bytes[i] == b'(') {
+            i += 1;
+        }
+
+        if i + 1 < bytes.len() && bytes[i] == b'-' && bytes[i + 1] == b'-' {
+            i += 2;
+            while i < bytes.len() && bytes[i] != b'\n' {
+                i += 1;
+            }
+            continue;
+        }
+
+        if options.profile.supports_hash_line_comments && bytes[i] == b'#' {
+            i += 1;
+            while i < bytes.len() && bytes[i] != b'\n' {
+                i += 1;
+            }
+            continue;
+        }
+
+        if i + 1 < bytes.len() && bytes[i] == b'/' && bytes[i + 1] == b'*' {
+            if i + 2 < bytes.len() && (bytes[i + 2] == b'!' || (i + 3 < bytes.len() && &bytes[i + 2..i + 4] == b"M!")) {
+                i += if bytes[i + 2] == b'!' { 3 } else { 4 };
+                while i < bytes.len() && (bytes[i].is_ascii_digit() || bytes[i].is_ascii_whitespace()) {
+                    i += 1;
+                }
+                break;
+            }
+
+            i += 2;
+            while i + 1 < bytes.len() && !(bytes[i] == b'*' && bytes[i + 1] == b'/') {
+                i += 1;
+            }
+            i = (i + 2).min(bytes.len());
+            continue;
+        }
+
+        break;
+    }
+
+    let start = i;
+    while i < bytes.len() && (bytes[i].is_ascii_alphabetic() || bytes[i] == b'_') {
+        i += 1;
+    }
+
+    (i > start).then_some(&sql[start..i])
+}
+
+fn starts_with_oracle_plsql_block(sql: &str) -> bool {
+    OraclePlSqlBlock::parse(sql).starts_block()
+}
+
+fn oracle_plsql_block_is_complete(sql: &str) -> bool {
+    OraclePlSqlBlock::parse(sql).is_complete()
+}
+
+fn starts_with_hana_do_block(sql: &str) -> bool {
+    HanaDoBlock::parse(sql).starts_block()
+}
+
+fn hana_do_block_is_complete(sql: &str) -> bool {
+    HanaDoBlock::parse(sql).is_complete()
+}
+
+struct HanaDoBlock {
+    tokens: Vec<OraclePlSqlToken>,
+}
+
+impl HanaDoBlock {
+    fn parse(sql: &str) -> Self {
+        Self { tokens: oracle_plsql_tokens(sql) }
+    }
+
+    fn starts_block(&self) -> bool {
+        self.tokens.first().is_some_and(|token| token.is_word("DO"))
+    }
+
+    fn is_complete(&self) -> bool {
+        if !self.starts_block() {
+            return false;
+        }
+
+        let mut stack: Vec<String> = Vec::new();
+        let mut saw_begin = false;
+
+        for (index, token) in self.tokens.iter().enumerate() {
+            if token.is_word("BEGIN") {
+                if previous_word_token(&self.tokens, index).is_some_and(|previous| previous == "END") {
+                    continue;
+                }
+                stack.push("BLOCK".to_string());
+                saw_begin = true;
+                continue;
+            }
+            if token.is_any_word(&["IF", "FOR", "WHILE", "CASE"]) {
+                if previous_word_token(&self.tokens, index).is_none_or(|previous| previous != "END") {
+                    stack.push(token.as_word().unwrap_or("BLOCK").to_string());
+                }
+                continue;
+            }
+            if token.is_word("END") {
+                let next = next_word_token(&self.tokens, index);
+                let top = stack.last().map(|value| value.as_str());
+                let target = match next {
+                    Some(keyword @ ("IF" | "FOR" | "WHILE")) => keyword,
+                    _ if top == Some("CASE") => "CASE",
+                    _ => "BLOCK",
+                };
+                if top == Some(target) {
+                    stack.pop();
+                }
+            }
+        }
+
+        saw_begin && stack.is_empty() && self.tokens.last().is_some_and(OraclePlSqlToken::is_semicolon)
+    }
+}
+
+struct OraclePlSqlBlock {
+    tokens: Vec<OraclePlSqlToken>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum OraclePlSqlToken {
+    Word(String),
+    Semicolon,
+}
+
+impl OraclePlSqlBlock {
+    fn parse(sql: &str) -> Self {
+        Self { tokens: oracle_plsql_tokens(sql) }
+    }
+
+    fn starts_block(&self) -> bool {
+        match self.tokens.as_slice() {
+            [first, ..] if first.is_word("DECLARE") => true,
+            [first, second, ..] if first.is_word("BEGIN") && !Self::is_transaction_begin_tail(second) => true,
+            [first, rest @ ..] if first.is_word("CREATE") => Self::starts_create_plsql_object(rest),
+            _ => false,
+        }
+    }
+
+    fn is_complete(&self) -> bool {
+        if !self.starts_block() {
+            return false;
+        }
+
+        let mut depth = 0usize;
+        let mut saw_begin = false;
+        let mut complete = false;
+        let mut pending_end: Option<bool> = None;
+
+        for token in &self.tokens {
+            if token.is_semicolon() {
+                if let Some(is_block_end) = pending_end.take() {
+                    if is_block_end && depth > 0 {
+                        depth -= 1;
+                        complete = depth == 0;
+                    }
+                }
+                continue;
+            }
+
+            if let Some(is_block_end) = pending_end.as_mut() {
+                if token.is_any_word(&["IF", "LOOP", "CASE"]) {
+                    *is_block_end = false;
+                }
+                continue;
+            }
+
+            if token.is_word("BEGIN") {
+                depth += 1;
+                saw_begin = true;
+                complete = false;
+            } else if token.is_word("END") {
+                pending_end = Some(true);
+            }
+        }
+
+        saw_begin && complete
+    }
+
+    fn starts_create_plsql_object(tokens: &[OraclePlSqlToken]) -> bool {
+        let tokens = Self::skip_or_replace(tokens);
+        tokens.first().is_some_and(|token| token.is_any_word(&["FUNCTION", "PROCEDURE", "TRIGGER", "PACKAGE", "TYPE"]))
+    }
+
+    fn skip_or_replace(tokens: &[OraclePlSqlToken]) -> &[OraclePlSqlToken] {
+        match tokens {
+            [or, replace, rest @ ..] if or.is_word("OR") && replace.is_word("REPLACE") => rest,
+            _ => tokens,
+        }
+    }
+
+    fn is_transaction_begin_tail(token: &OraclePlSqlToken) -> bool {
+        token.is_semicolon() || token.is_any_word(&["TRANSACTION", "WORK"])
+    }
+}
+
+impl OraclePlSqlToken {
+    fn word(value: String) -> Self {
+        Self::Word(value)
+    }
+
+    fn from_sqlparser_token(token: Token) -> Option<Self> {
+        match token {
+            Token::Word(word) if word.quote_style.is_none() => Some(Self::Word(word.value.to_ascii_uppercase())),
+            Token::SemiColon => Some(Self::Semicolon),
+            _ => None,
+        }
+    }
+
+    fn is_word(&self, expected: &str) -> bool {
+        matches!(self, Self::Word(value) if value == expected)
+    }
+
+    fn as_word(&self) -> Option<&str> {
+        match self {
+            Self::Word(value) => Some(value),
+            Self::Semicolon => None,
+        }
+    }
+
+    fn is_any_word(&self, expected: &[&str]) -> bool {
+        expected.iter().any(|word| self.is_word(word))
+    }
+
+    fn is_semicolon(&self) -> bool {
+        matches!(self, Self::Semicolon)
+    }
+}
+
+fn previous_word_token(tokens: &[OraclePlSqlToken], index: usize) -> Option<&str> {
+    tokens[..index].iter().rev().find_map(OraclePlSqlToken::as_word)
+}
+
+fn next_word_token(tokens: &[OraclePlSqlToken], index: usize) -> Option<&str> {
+    tokens[index + 1..].iter().find_map(OraclePlSqlToken::as_word)
+}
+
+fn oracle_plsql_tokens(sql: &str) -> Vec<OraclePlSqlToken> {
+    let dialect = OracleDialect {};
+    if let Ok(tokens) = Tokenizer::new(&dialect, sql).tokenize() {
+        return tokens.into_iter().filter_map(OraclePlSqlToken::from_sqlparser_token).collect();
+    }
+
+    oracle_plsql_tokens_fallback(sql)
+}
+
+fn oracle_plsql_tokens_fallback(sql: &str) -> Vec<OraclePlSqlToken> {
+    let mut tokens = Vec::new();
+    let mut iter = sql.char_indices().peekable();
+
+    while let Some((_, ch)) = iter.next() {
+        if ch.is_whitespace() {
+            continue;
+        }
+
+        if ch == '-' && iter.peek().is_some_and(|(_, next)| *next == '-') {
+            iter.next();
+            for (_, comment_ch) in iter.by_ref() {
+                if comment_ch == '\n' {
+                    break;
+                }
+            }
+            continue;
+        }
+
+        if ch == '/' && iter.peek().is_some_and(|(_, next)| *next == '*') {
+            iter.next();
+            let mut previous = '\0';
+            for (_, comment_ch) in iter.by_ref() {
+                if previous == '*' && comment_ch == '/' {
+                    break;
+                }
+                previous = comment_ch;
+            }
+            continue;
+        }
+
+        if ch == '\'' {
+            while let Some((_, quote_ch)) = iter.next() {
+                if quote_ch == '\'' {
+                    if iter.peek().is_some_and(|(_, next)| *next == '\'') {
+                        iter.next();
+                    } else {
+                        break;
+                    }
+                }
+            }
+            continue;
+        }
+
+        if ch == '"' {
+            for (_, ident_ch) in iter.by_ref() {
+                if ident_ch == '"' {
+                    break;
+                }
+            }
+            continue;
+        }
+
+        if ch == ';' {
+            tokens.push(OraclePlSqlToken::Semicolon);
+            continue;
+        }
+
+        if ch.is_ascii_alphabetic() || ch == '_' {
+            let mut token = String::new();
+            token.push(ch.to_ascii_uppercase());
+            while let Some((_, next)) = iter.peek().copied() {
+                if next.is_ascii_alphanumeric() || next == '_' || next == '$' || next == '#' {
+                    token.push(next.to_ascii_uppercase());
+                    iter.next();
+                } else {
+                    break;
+                }
+            }
+            tokens.push(OraclePlSqlToken::word(token));
+        }
+    }
+
+    tokens
+}
+
+fn starts_with_chars(chars: &[char], start: usize, needle: &[char]) -> bool {
+    start + needle.len() <= chars.len() && chars[start..start + needle.len()] == *needle
+}
+
+fn dollar_quote_tag_at(chars: &[char], start: usize) -> Option<String> {
+    if chars.get(start) != Some(&'$') {
+        return None;
+    }
+
+    match chars.get(start + 1) {
+        Some('$') => return Some("$$".to_string()),
+        Some(ch) if ch.is_ascii_alphabetic() || *ch == '_' => {}
+        _ => return None,
+    }
+
+    let mut end = start + 2;
+    while let Some(ch) = chars.get(end) {
+        if *ch == '$' {
+            return Some(chars[start..=end].iter().collect());
+        }
+        if !ch.is_ascii_alphanumeric() && *ch != '_' {
+            return None;
+        }
+        end += 1;
+    }
+
+    None
+}
+
+pub fn has_executable_sql(statement: &str) -> bool {
+    has_executable_sql_with_options(statement, SqlParsingOptions::default())
+}
+
+pub fn has_executable_sql_for_database(statement: &str, db_type: DatabaseType) -> bool {
+    has_executable_sql_with_options(statement, SqlParsingOptions::for_database_type(db_type))
+}
+
+fn executable_sql_bounds(statement: &str, options: SqlParsingOptions) -> Option<(usize, usize)> {
+    let trimmed_end = statement.trim_end().len();
+    let trimmed = &statement[..trimmed_end];
+    let executable = leading_executable_sql_with_options(trimmed, options);
+    if executable.is_empty() {
+        return None;
+    }
+    let start = trimmed.len() - executable.len();
+    Some((start, trimmed_end))
+}
+
+fn has_executable_sql_with_options(statement: &str, options: SqlParsingOptions) -> bool {
+    let chars = statement.chars().collect::<Vec<_>>();
+    let mut in_line_comment = false;
+    let mut in_block_comment = false;
+    let mut previous = None;
+    let mut i = 0;
+
+    while i < chars.len() {
+        let ch = chars[i];
+        let next = chars.get(i + 1).copied();
+
+        if in_line_comment {
+            if ch == '\n' {
+                in_line_comment = false;
+            }
+            previous = Some(ch);
+            i += 1;
+            continue;
+        }
+
+        if in_block_comment {
+            if previous == Some('*') && ch == '/' {
+                in_block_comment = false;
+            }
+            previous = Some(ch);
+            i += 1;
+            continue;
+        }
+
+        if ch == '-' && next == Some('-') {
+            in_line_comment = true;
+            previous = Some(ch);
+            i += 1;
+            continue;
+        }
+
+        if options.profile.supports_hash_line_comments && ch == '#' {
+            in_line_comment = true;
+            previous = Some(ch);
+            i += 1;
+            continue;
+        }
+
+        if ch == '/' && next == Some('*') {
+            if is_mysql_executable_comment_start(&chars, i) {
+                return true;
+            }
+            in_block_comment = true;
+            previous = Some(ch);
+            i += 1;
+            continue;
+        }
+
+        if !ch.is_whitespace() {
+            return true;
+        }
+
+        previous = Some(ch);
+        i += 1;
+    }
+
+    false
+}
+
+fn is_mysql_executable_comment_start(chars: &[char], start: usize) -> bool {
+    chars.get(start) == Some(&'/')
+        && chars.get(start + 1) == Some(&'*')
+        && (chars.get(start + 2) == Some(&'!')
+            || (chars.get(start + 2) == Some(&'M') && chars.get(start + 3) == Some(&'!')))
+}
+
+#[cfg(test)]
+fn split_sql_script(sql: &str) -> Result<Vec<String>, String> {
+    Ok(split_sql_statements(sql))
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::models::connection::DatabaseType;
+
+    use super::{
+        contains_or_fuzzy_match, decode_sql_file_bytes, find_statement_at_cursor_for_database, fuzzy_filter_enabled,
+        fuzzy_like_pattern_with_escape, fuzzy_subsequence_match, optimize_sql_file_import_statements,
+        prepare_sql_file_statement, split_sql_script, split_sql_statement_ranges_with_options,
+        split_sql_statements_for_database, starts_with_executable_sql_keyword,
+        starts_with_executable_sql_keyword_for_database, SqlDialectProfile, SqlFileStatementAction, SqlParsingOptions,
+        SqlStatementSplitter,
+    };
+
+    #[test]
+    fn fuzzy_subsequence_match_matches_ordered_characters() {
+        assert!(fuzzy_subsequence_match("system_user", "sysu"));
+        assert!(contains_or_fuzzy_match("user_order", "uo"));
+        assert!(!contains_or_fuzzy_match("alpha", "uo"));
+    }
+
+    #[test]
+    fn contains_or_fuzzy_match_skips_fuzzy_for_single_character_filters() {
+        assert!(fuzzy_filter_enabled("uo"));
+        assert!(!fuzzy_filter_enabled("u"));
+        assert!(contains_or_fuzzy_match("user_order", "u"));
+        assert!(!contains_or_fuzzy_match("orders", "u"));
+    }
+
+    #[test]
+    fn fuzzy_like_pattern_with_escape_keeps_wildcards_literal() {
+        let pattern = fuzzy_like_pattern_with_escape("user_%", |value| value.replace('%', "\\%").replace('_', "\\_"));
+
+        assert_eq!(pattern, "%u%s%e%r%\\_%\\%%");
+    }
+
+    #[test]
+    fn splits_semicolon_delimited_statements() {
+        assert_eq!(
+            split_sql_script("CREATE TABLE a(id int); INSERT INTO a VALUES (1);").unwrap(),
+            vec!["CREATE TABLE a(id int)", "INSERT INTO a VALUES (1)"]
+        );
+    }
+
+    #[test]
+    fn decodes_utf8_bom_sql_file_bytes_without_bom_statement_prefix() {
+        let sql = decode_sql_file_bytes(b"\xEF\xBB\xBFCREATE TABLE t(id int);").unwrap();
+
+        assert_eq!(sql, "CREATE TABLE t(id int);");
+    }
+
+    #[test]
+    fn decodes_gbk_sql_file_bytes_before_execution() {
+        let bytes = b"INSERT INTO t VALUES ('\xD6\xD0\xCE\xC4');";
+        let sql = decode_sql_file_bytes(bytes).unwrap();
+
+        assert_eq!(sql, "INSERT INTO t VALUES ('中文');");
+    }
+
+    #[test]
+    fn decodes_utf16le_bom_sql_file_bytes() {
+        let bytes = [
+            0xFF, 0xFE, b'S', 0x00, b'E', 0x00, b'L', 0x00, b'E', 0x00, b'C', 0x00, b'T', 0x00, b' ', 0x00, b'1', 0x00,
+            b';', 0x00,
+        ];
+        let sql = decode_sql_file_bytes(&bytes).unwrap();
+
+        assert_eq!(sql, "SELECT 1;");
+    }
+
+    #[test]
+    fn ignores_semicolons_inside_quotes_and_comments() {
+        let sql = "\
+            INSERT INTO logs VALUES ('a;b', \"c;d\", `weird;name`);\n\
+            -- comment ; ignored\n\
+            /* block ; ignored */\n\
+            SELECT 1;";
+        assert_eq!(
+            split_sql_script(sql).unwrap(),
+            vec![
+                "INSERT INTO logs VALUES ('a;b', \"c;d\", `weird;name`)",
+                "-- comment ; ignored\n/* block ; ignored */\nSELECT 1",
+            ]
+        );
+    }
+
+    #[test]
+    fn emits_trailing_statement_without_semicolon() {
+        assert_eq!(
+            split_sql_script("CREATE TABLE a(id int);\nINSERT INTO a VALUES (1)").unwrap(),
+            vec!["CREATE TABLE a(id int)", "INSERT INTO a VALUES (1)"]
+        );
+    }
+
+    #[test]
+    fn line_comment_openers_can_span_chunks() {
+        let mut splitter = SqlStatementSplitter::default();
+
+        assert_eq!(splitter.push_chunk("SELECT 1; -"), vec!["SELECT 1"]);
+        assert_eq!(splitter.push_chunk("- comment ; ignored\nSELECT 2;"), vec!["-- comment ; ignored\nSELECT 2"]);
+        assert_eq!(splitter.finish(), Vec::<String>::new());
+    }
+
+    #[test]
+    fn block_comment_openers_can_span_chunks() {
+        let mut splitter = SqlStatementSplitter::default();
+
+        assert_eq!(splitter.push_chunk("SELECT 1; /"), vec!["SELECT 1"]);
+        assert_eq!(splitter.push_chunk("* comment ; ignored */\nSELECT 2;"), vec!["/* comment ; ignored */\nSELECT 2"]);
+        assert_eq!(splitter.finish(), Vec::<String>::new());
+    }
+
+    #[test]
+    fn skips_comment_only_tail_after_statement() {
+        assert_eq!(
+            split_sql_script("CREATE TABLE a(id int); -- done\n/* no more sql */").unwrap(),
+            vec!["CREATE TABLE a(id int)"]
+        );
+    }
+
+    #[test]
+    fn skips_comment_only_statement_with_semicolon() {
+        assert_eq!(
+            split_sql_script("-- insert sqluser.tb_a values (6,'006','测试6','无');").unwrap(),
+            Vec::<String>::new()
+        );
+        assert!(!super::has_executable_sql("-- insert sqluser.tb_a values (6,'006','测试6','无');"));
+    }
+
+    #[test]
+    fn keeps_postgres_dollar_quoted_function_body_together() {
+        let sql = "\
+            CREATE FUNCTION bump_counter()\n\
+            RETURNS trigger AS $$\n\
+            BEGIN\n\
+              PERFORM 1;\n\
+              RETURN NEW;\n\
+            END;\n\
+            $$ LANGUAGE plpgsql;\n\
+            SELECT 1;";
+
+        assert_eq!(
+            split_sql_script(sql).unwrap(),
+            vec![
+                "CREATE FUNCTION bump_counter()\nRETURNS trigger AS $$\nBEGIN\nPERFORM 1;\nRETURN NEW;\nEND;\n$$ LANGUAGE plpgsql",
+                "SELECT 1",
+            ]
+        );
+    }
+
+    #[test]
+    fn keeps_mysql_executable_comments_as_statements() {
+        assert_eq!(
+            split_sql_script("/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;\nSELECT 1;",).unwrap(),
+            vec!["/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */", "SELECT 1",]
+        );
+    }
+
+    #[test]
+    fn detects_result_set_keyword_after_comments() {
+        assert!(starts_with_executable_sql_keyword("-- comment\nselect * from users;", &["SELECT"]));
+        assert!(starts_with_executable_sql_keyword(
+            "/* comment */\nWITH rows AS (SELECT 1) SELECT * FROM rows;",
+            &["WITH"]
+        ));
+        assert!(!starts_with_executable_sql_keyword("-- comment only\n", &["SELECT"]));
+    }
+
+    #[test]
+    fn detects_mysql_executable_comment_keyword() {
+        assert!(starts_with_executable_sql_keyword("/*!40101 SELECT 1 */", &["SELECT"]));
+        assert!(starts_with_executable_sql_keyword("/*M! SELECT 1 */", &["SELECT"]));
+    }
+
+    #[test]
+    fn describe_keyword_detection_accepts_desc_shorthand() {
+        assert!(starts_with_executable_sql_keyword("DESC users", &["DESCRIBE"]));
+        assert!(starts_with_executable_sql_keyword("-- comment\nDESC users", &["DESCRIBE"]));
+    }
+
+    #[test]
+    fn detects_keyword_after_parentheses() {
+        assert!(starts_with_executable_sql_keyword("(SELECT 1)", &["SELECT"]));
+        assert!(starts_with_executable_sql_keyword("  (  SELECT 1  )", &["SELECT"]));
+        assert!(starts_with_executable_sql_keyword("((SELECT 1))", &["SELECT"]));
+        assert!(starts_with_executable_sql_keyword("(SELECT * FROM users)", &["SELECT"]));
+        assert!(starts_with_executable_sql_keyword("(INSERT INTO users VALUES (1))", &["INSERT"]));
+        assert!(starts_with_executable_sql_keyword("/* comment */(UPDATE users SET name = 'test')", &["UPDATE"]));
+    }
+
+    #[test]
+    fn mysql_hash_comments_are_ignored_for_keyword_detection() {
+        assert!(starts_with_executable_sql_keyword_for_database(
+            "# comment only for mysql\nSELECT 1",
+            &["SELECT"],
+            DatabaseType::Mysql
+        ));
+        assert!(!starts_with_executable_sql_keyword("# comment only for mysql\nSELECT 1", &["SELECT"]));
+    }
+
+    #[test]
+    fn prepares_mysql_executable_comments_for_mysql_compatible_imports() {
+        assert_eq!(
+            prepare_sql_file_statement("/*!40101 SET NAMES utf8mb4 */", &DatabaseType::Mysql, None),
+            SqlFileStatementAction::Execute("SET NAMES utf8mb4".to_string())
+        );
+    }
+
+    #[test]
+    fn skips_mysql_key_toggle_comments_for_mysql_compatible_imports() {
+        assert_eq!(
+            prepare_sql_file_statement(" /*!40000 ALTER TABLE `dd_admin` ENABLE KEYS */", &DatabaseType::Mysql, None),
+            SqlFileStatementAction::Skip
+        );
+        assert_eq!(
+            prepare_sql_file_statement("/*!40000 ALTER TABLE `dd_admin` DISABLE KEYS */", &DatabaseType::Mysql, None),
+            SqlFileStatementAction::Skip
+        );
+    }
+
+    #[test]
+    fn skips_mysql_lock_table_statements_for_mysql_compatible_imports() {
+        assert_eq!(
+            prepare_sql_file_statement("LOCK TABLES `dd_geo_json` WRITE", &DatabaseType::Mysql, None),
+            SqlFileStatementAction::Skip
+        );
+        assert_eq!(
+            prepare_sql_file_statement("UNLOCK TABLES", &DatabaseType::Mysql, None),
+            SqlFileStatementAction::Skip
+        );
+        assert_eq!(
+            prepare_sql_file_statement(
+                "-- Dumping data for table `dd_geo_json`\nLOCK TABLES `dd_geo_json` WRITE",
+                &DatabaseType::Mysql,
+                None
+            ),
+            SqlFileStatementAction::Skip
+        );
+    }
+
+    #[test]
+    fn skips_mysql_session_restore_statements_for_mysql_compatible_imports() {
+        assert_eq!(
+            prepare_sql_file_statement(
+                "/*!40101 SET character_set_client = @saved_cs_client */",
+                &DatabaseType::Mysql,
+                None
+            ),
+            SqlFileStatementAction::Skip
+        );
+        assert_eq!(
+            prepare_sql_file_statement("/*!40103 SET TIME_ZONE=@OLD_TIME_ZONE */", &DatabaseType::Mysql, None),
+            SqlFileStatementAction::Skip
+        );
+        assert_eq!(
+            prepare_sql_file_statement("SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS", &DatabaseType::Mysql, None),
+            SqlFileStatementAction::Skip
+        );
+        assert_eq!(
+            prepare_sql_file_statement(
+                "/*!40101 SET @saved_cs_client = @@character_set_client */",
+                &DatabaseType::Mysql,
+                None
+            ),
+            SqlFileStatementAction::Execute("SET @saved_cs_client = @@character_set_client".to_string())
+        );
+    }
+
+    #[test]
+    fn skips_mysql_executable_comments_for_non_mysql_imports() {
+        assert_eq!(
+            prepare_sql_file_statement(
+                "/*!40101 SET character_set_client = @saved_cs_client */",
+                &DatabaseType::Postgres,
+                None
+            ),
+            SqlFileStatementAction::Skip
+        );
+    }
+
+    #[test]
+    fn optimizes_adjacent_single_row_inserts_into_multi_row_insert() {
+        let statements = vec![
+            "INSERT INTO users (id, name) VALUES (1, 'Ada')".to_string(),
+            "insert into users (id, name) values (2, 'Linus')".to_string(),
+            "SELECT 1".to_string(),
+        ];
+
+        let optimized = optimize_sql_file_import_statements(&statements, Some(DatabaseType::Mysql), None);
+
+        assert_eq!(optimized.len(), 2);
+        assert_eq!(optimized[0].source_statement_count, 2);
+        assert_eq!(optimized[0].sql, "INSERT INTO users (id, name) VALUES\n(1, 'Ada'),\n(2, 'Linus')");
+        assert_eq!(optimized[1].sql, "SELECT 1");
+    }
+
+    #[test]
+    fn keeps_insert_batches_separate_for_different_targets_or_suffixes() {
+        let statements = vec![
+            "INSERT INTO users (id) VALUES (1)".to_string(),
+            "INSERT INTO teams (id) VALUES (1)".to_string(),
+            "INSERT INTO users (id) VALUES (2) RETURNING id".to_string(),
+        ];
+
+        let optimized = optimize_sql_file_import_statements(&statements, Some(DatabaseType::Postgres), None);
+
+        assert_eq!(optimized.len(), 3);
+        assert!(optimized.iter().all(|statement| statement.source_statement_count == 1));
+    }
+
+    #[test]
+    fn optimized_sql_file_import_keeps_skipped_mysql_dump_statements() {
+        let statements = vec![
+            "LOCK TABLES `users` WRITE".to_string(),
+            "INSERT INTO `users` VALUES (1)".to_string(),
+            "INSERT INTO `users` VALUES (2)".to_string(),
+            "UNLOCK TABLES".to_string(),
+        ];
+
+        let optimized = optimize_sql_file_import_statements(&statements, Some(DatabaseType::Mysql), None);
+
+        assert_eq!(optimized.len(), 3);
+        assert_eq!(optimized[0].kind, super::SqlFileImportStatementKind::Skip);
+        assert_eq!(optimized[1].source_statement_count, 2);
+        assert_eq!(optimized[2].kind, super::SqlFileImportStatementKind::Skip);
+    }
+
+    #[test]
+    fn split_batches_by_go() {
+        assert_eq!(super::split_sql_batches("SELECT 1\nGO\nSELECT 2"), vec!["SELECT 1", "SELECT 2"]);
+    }
+
+    #[test]
+    fn split_batches_go_case_insensitive() {
+        assert_eq!(
+            super::split_sql_batches("SELECT 1\ngo\nSELECT 2\nGo\nSELECT 3"),
+            vec!["SELECT 1", "SELECT 2", "SELECT 3"]
+        );
+    }
+
+    #[test]
+    fn split_batches_go_with_surrounding_whitespace() {
+        assert_eq!(super::split_sql_batches("SELECT 1\n  GO  \nSELECT 2"), vec!["SELECT 1", "SELECT 2"]);
+    }
+
+    #[test]
+    fn split_batches_no_go_returns_whole() {
+        assert_eq!(
+            super::split_sql_batches("DECLARE @x INT = 1;\nSELECT @x;"),
+            vec!["DECLARE @x INT = 1;\nSELECT @x;"]
+        );
+    }
+
+    #[test]
+    fn split_batches_skips_empty_batches() {
+        assert_eq!(super::split_sql_batches("SELECT 1\nGO\n\nGO\nSELECT 2"), vec!["SELECT 1", "SELECT 2"]);
+    }
+
+    #[test]
+    fn split_batches_trailing_go() {
+        assert_eq!(super::split_sql_batches("SELECT 1\nGO"), vec!["SELECT 1"]);
+    }
+
+    #[test]
+    fn split_batches_keeps_go_inside_multiline_string() {
+        assert_eq!(
+            super::split_sql_batches("SELECT 'first line\nGO\nlast line';\nGO\nSELECT 2"),
+            vec!["SELECT 'first line\nGO\nlast line';", "SELECT 2"]
+        );
+    }
+
+    #[test]
+    fn split_batches_keeps_go_inside_block_comment() {
+        assert_eq!(
+            super::split_sql_batches("SELECT 1;\n/*\nGO\n*/\nSELECT 2;\nGO\nSELECT 3;"),
+            vec!["SELECT 1;\n/*\nGO\n*/\nSELECT 2;", "SELECT 3;"]
+        );
+    }
+
+    // --- DELIMITER support ---
+
+    #[test]
+    fn delimiter_basic_procedure() {
+        let sql = "\
+DELIMITER //
+CREATE PROCEDURE foo()
+BEGIN
+  SELECT 1;
+  SELECT 2;
+END //
+DELIMITER ;
+SELECT 3;";
+        assert_eq!(
+            super::split_sql_statements(sql),
+            vec!["CREATE PROCEDURE foo()\nBEGIN\n  SELECT 1;\n  SELECT 2;\nEND", "SELECT 3",]
+        );
+    }
+
+    #[test]
+    fn delimiter_no_trailing_newline() {
+        let sql = "DELIMITER //\nSELECT 1//";
+        assert_eq!(super::split_sql_statements(sql), vec!["SELECT 1"]);
+    }
+
+    #[test]
+    fn delimiter_no_space_before_delim() {
+        let sql = "DELIMITER //\nCREATE PROCEDURE foo() BEGIN SELECT 1; END//\nDELIMITER ;";
+        assert_eq!(super::split_sql_statements(sql), vec!["CREATE PROCEDURE foo() BEGIN SELECT 1; END"]);
+    }
+
+    #[test]
+    fn delimiter_case_insensitive() {
+        let sql = "delimiter //\nSELECT 1//\ndelimiter ;\nSELECT 2;";
+        assert_eq!(super::split_sql_statements(sql), vec!["SELECT 1", "SELECT 2"]);
+    }
+
+    #[test]
+    fn delimiter_double_dollar() {
+        let sql = "DELIMITER $$\nCREATE FUNCTION f() RETURNS INT BEGIN RETURN 1; END $$\nDELIMITER ;";
+        assert_eq!(super::split_sql_statements(sql), vec!["CREATE FUNCTION f() RETURNS INT BEGIN RETURN 1; END"]);
+    }
+
+    #[test]
+    fn delimiter_semicolons_preserved_inside_body() {
+        let sql = "\
+DELIMITER //
+CREATE TRIGGER t BEFORE INSERT ON tbl FOR EACH ROW
+BEGIN
+  SET NEW.a = 1;
+  SET NEW.b = 2;
+END //
+DELIMITER ;";
+        let stmts = super::split_sql_statements(sql);
+        assert_eq!(stmts.len(), 1);
+        assert!(stmts[0].contains("SET NEW.a = 1;\n  SET NEW.b = 2;"));
+    }
+
+    #[test]
+    fn delimiter_multiple_statements() {
+        let sql = "\
+DELIMITER //
+CREATE PROCEDURE p1() BEGIN SELECT 1; END //
+CREATE PROCEDURE p2() BEGIN SELECT 2; END //
+DELIMITER ;";
+        assert_eq!(
+            super::split_sql_statements(sql),
+            vec!["CREATE PROCEDURE p1() BEGIN SELECT 1; END", "CREATE PROCEDURE p2() BEGIN SELECT 2; END",]
+        );
+    }
+
+    #[test]
+    fn delimiter_after_comment_with_chinese() {
+        let sql = "\
+-- 判断字段是否存在
+DELIMITER $$
+DROP FUNCTION IF EXISTS isFieldExisting $$
+CREATE FUNCTION isFieldExisting(s VARCHAR(100), t VARCHAR(100), f VARCHAR(100))
+    RETURNS INT
+    RETURN (SELECT COUNT(COLUMN_NAME)
+            FROM INFORMATION_SCHEMA.columns
+            WHERE TABLE_SCHEMA = s
+              AND TABLE_NAME = t
+              AND COLUMN_NAME = f)$$
+DELIMITER ;";
+        let stmts = super::split_sql_statements(sql);
+        assert_eq!(stmts.len(), 2);
+        assert!(stmts[0].starts_with("DROP FUNCTION"));
+        assert!(stmts[1].starts_with("CREATE FUNCTION"));
+    }
+
+    #[test]
+    fn delimiter_after_ascii_comment() {
+        let sql = "\
+-- check field existence
+DELIMITER $$
+SELECT 1 $$
+DELIMITER ;";
+        assert_eq!(super::split_sql_statements(sql), vec!["SELECT 1"]);
+    }
+
+    #[test]
+    fn delimiter_after_statement() {
+        let sql = "\
+SELECT 1;
+DELIMITER $$
+SELECT 2 $$
+DELIMITER ;";
+        assert_eq!(super::split_sql_statements(sql), vec!["SELECT 1", "SELECT 2"]);
+    }
+
+    #[test]
+    fn mysql_routine_without_delimiter_keeps_body_together() {
+        let sql = "\
+CREATE PROCEDURE p()
+BEGIN
+  SELECT 1;
+  SELECT 2;
+END;
+SELECT 3;";
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Mysql),
+            vec!["CREATE PROCEDURE p()\nBEGIN\n  SELECT 1;\n  SELECT 2;\nEND", "SELECT 3"]
+        );
+    }
+
+    #[test]
+    fn mysql_routine_without_delimiter_handles_nested_end_suffixes() {
+        let sql = "\
+CREATE PROCEDURE p()
+BEGIN
+  IF 1 = 1 THEN
+    SELECT 'ok';
+  END IF;
+END;
+SELECT 2;";
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Mysql),
+            vec!["CREATE PROCEDURE p()\nBEGIN\n  IF 1 = 1 THEN\n    SELECT 'ok';\n  END IF;\nEND", "SELECT 2"]
+        );
+    }
+
+    #[test]
+    fn mysql_routine_without_delimiter_handles_loop_end_suffixes() {
+        let sql = "\
+CREATE PROCEDURE p_loop()
+BEGIN
+  WHILE 1 = 0 DO
+    SELECT 'while; still body';
+  END WHILE;
+  REPEAT
+    SELECT 'repeat; still body';
+  UNTIL 1 = 1 END REPEAT;
+END;
+SELECT 2;";
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Mysql),
+            vec![
+                "CREATE PROCEDURE p_loop()\nBEGIN\n  WHILE 1 = 0 DO\n    SELECT 'while; still body';\n  END WHILE;\n  REPEAT\n    SELECT 'repeat; still body';\n  UNTIL 1 = 1 END REPEAT;\nEND",
+                "SELECT 2",
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_regular_begin_transaction_still_splits_without_delimiter() {
+        assert_eq!(
+            split_sql_statements_for_database("BEGIN; INSERT INTO t VALUES (1); COMMIT;", DatabaseType::Mysql),
+            vec!["BEGIN", "INSERT INTO t VALUES (1)", "COMMIT"]
+        );
+    }
+
+    #[test]
+    fn sql_dialect_profiles_map_database_types_to_parser_capabilities() {
+        let default = SqlDialectProfile::for_database_type(DatabaseType::Postgres);
+        assert_eq!(default, SqlDialectProfile::default());
+        assert!(default.supports_custom_delimiter_commands);
+        assert!(default.supports_dollar_quoted_strings);
+        assert!(!default.supports_hash_line_comments);
+        assert!(!default.supports_mysql_routine_blocks);
+        assert!(!default.supports_oracle_plsql_blocks);
+        assert!(!default.supports_hana_do_blocks);
+        assert!(!default.supports_slash_line_block_delimiter);
+        assert!(!default.supports_go_batch_separator);
+        assert!(!default.keeps_sqlserver_module_batch_at_cursor);
+
+        let mysql = SqlDialectProfile::for_database_type(DatabaseType::Mysql);
+        assert_eq!(mysql, SqlDialectProfile::mysql_compatible());
+        assert!(mysql.supports_hash_line_comments);
+        assert!(mysql.supports_mysql_routine_blocks);
+        assert!(SqlDialectProfile::for_database_type(DatabaseType::Doris).supports_hash_line_comments);
+        assert!(SqlDialectProfile::for_database_type(DatabaseType::StarRocks).supports_hash_line_comments);
+        assert!(SqlDialectProfile::for_database_type(DatabaseType::ManticoreSearch).supports_hash_line_comments);
+        assert!(SqlDialectProfile::for_database_type(DatabaseType::Goldendb).supports_hash_line_comments);
+
+        for db_type in [
+            DatabaseType::Oracle,
+            DatabaseType::Dameng,
+            DatabaseType::Gaussdb,
+            DatabaseType::Yashandb,
+            DatabaseType::Oscar,
+            DatabaseType::OceanbaseOracle,
+        ] {
+            let profile = SqlDialectProfile::for_database_type(db_type);
+            assert_eq!(profile, SqlDialectProfile::oracle_like());
+            assert!(profile.supports_oracle_plsql_blocks);
+            assert!(profile.supports_slash_line_block_delimiter);
+        }
+
+        let sql_server = SqlDialectProfile::for_database_type(DatabaseType::SqlServer);
+        assert_eq!(sql_server, SqlDialectProfile::sql_server());
+        assert!(sql_server.supports_go_batch_separator);
+        assert!(sql_server.keeps_sqlserver_module_batch_at_cursor);
+
+        let sap_hana = SqlDialectProfile::for_database_type(DatabaseType::SapHana);
+        assert_eq!(sap_hana, SqlDialectProfile::sap_hana());
+        assert!(sap_hana.supports_hana_do_blocks);
+    }
+
+    #[test]
+    fn sap_hana_split_keeps_do_block_together() {
+        let sql = "\
+DO
+BEGIN
+  SELECT 1 AS \"Result\" FROM DUMMY;
+END;
+SELECT 2 FROM DUMMY;";
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::SapHana),
+            vec!["DO\nBEGIN\n  SELECT 1 AS \"Result\" FROM DUMMY;\nEND;", "SELECT 2 FROM DUMMY"]
+        );
+    }
+
+    #[test]
+    fn sap_hana_cursor_statement_keeps_nested_do_block_together() {
+        let sql = "\
+DO
+BEGIN
+  IF 1 = 1 THEN
+    SELECT CASE WHEN 1 = 1 THEN 1 ELSE 0 END AS \"Result\" FROM DUMMY;
+  END IF;
+END;
+SELECT 2 FROM DUMMY;";
+        let cursor = sql.find("Result").unwrap();
+
+        assert_eq!(
+            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::SapHana),
+            "DO\nBEGIN\n  IF 1 = 1 THEN\n    SELECT CASE WHEN 1 = 1 THEN 1 ELSE 0 END AS \"Result\" FROM DUMMY;\n  END IF;\nEND;"
+        );
+    }
+
+    #[test]
+    fn oracle_like_split_keeps_anonymous_plsql_block_together() {
+        let sql = "\
+DECLARE
+V_EXISTS_FLAG NUMBER;
+BEGIN
+SELECT COUNT(1)
+INTO V_EXISTS_FLAG
+FROM SCHEMA_NAME.TABLE_NAME
+WHERE UNIQUE_KEY_COLUMN = 'BUSINESS_UNIQUE_VALUE';
+IF V_EXISTS_FLAG = 0 THEN
+INSERT INTO SCHEMA_NAME.TABLE_NAME (UNIQUE_KEY_COLUMN, COLUMN_NAME_1)
+VALUES ('BUSINESS_UNIQUE_VALUE', 'BUSINESS_VALUE_1');
+END IF;
+END;";
+
+        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Oracle), vec![sql.to_string()]);
+        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Dameng), vec![sql.to_string()]);
+        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Gaussdb), vec![sql.to_string()]);
+    }
+
+    #[test]
+    fn oracle_like_split_keeps_issue_2405_anonymous_plsql_block_together() {
+        let sql = "\
+DECLARE
+   PRE_TRD_DATE   INTEGER ;
+BEGIN
+   SELECT 1 + 2 INTO PRE_TRD_DATE FROM DUAL;
+END;";
+
+        assert_eq!(split_sql_statements_for_database(sql, DatabaseType::Oracle), vec![sql.to_string()]);
+    }
+
+    #[test]
+    fn oracle_like_current_statement_keeps_issue_2405_anonymous_plsql_block_together() {
+        let sql = "\
+DECLARE
+   PRE_TRD_DATE   INTEGER ;
+BEGIN
+   SELECT 1 + 2 INTO PRE_TRD_DATE FROM DUAL;
+END;";
+        let cursors = [
+            sql[..sql.find("PRE_TRD_DATE").unwrap()].encode_utf16().count(),
+            sql[..sql.find("SELECT 1 + 2").unwrap()].encode_utf16().count(),
+            sql[..sql.find("END;").unwrap()].encode_utf16().count(),
+        ];
+
+        for cursor in cursors {
+            assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Oracle), sql);
+        }
+    }
+
+    #[test]
+    fn oracle_like_split_treats_slash_line_as_plsql_delimiter() {
+        let sql = "\
+BEGIN
+  NULL;
+END;
+/
+SELECT 1;";
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Oracle),
+            vec!["BEGIN\n  NULL;\nEND;", "SELECT 1"]
+        );
+    }
+
+    #[test]
+    fn oracle_like_current_statement_keeps_plsql_block_together() {
+        let sql = "\
+DECLARE
+  v_exists_flag NUMBER;
+BEGIN
+  IF v_exists_flag = 0 THEN
+    NULL;
+  END IF;
+END;
+/
+SELECT 1;";
+        let cursor = sql[..sql.find("NULL").unwrap()].encode_utf16().count();
+        let next_cursor = sql[..sql.find("SELECT 1").unwrap()].encode_utf16().count();
+
+        assert_eq!(
+            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Oracle),
+            "DECLARE\n  v_exists_flag NUMBER;\nBEGIN\n  IF v_exists_flag = 0 THEN\n    NULL;\n  END IF;\nEND;"
+        );
+        assert_eq!(find_statement_at_cursor_for_database(sql, next_cursor, DatabaseType::Oracle), "SELECT 1");
+    }
+
+    #[test]
+    fn oracle_like_current_statement_keeps_nested_dml_plsql_block_together() {
+        let sql = "\
+DECLARE
+  v_order_count NUMBER;
+BEGIN
+  SELECT COUNT(*) INTO v_order_count
+  FROM \"DBX_TEST\".\"ORDERS_10K\";
+
+  IF v_order_count = 0 THEN
+    INSERT INTO \"DBX_TEST\".\"STORES\"
+      (\"ID\", \"STORE_CODE\", \"STORE_NAME\", \"CITY\", \"OPENED_AT\")
+    SELECT 10001, 'TEST_STORE_001', '测试门店', '上海', SYSDATE
+    FROM DUAL
+    WHERE NOT EXISTS (
+      SELECT 1 FROM \"DBX_TEST\".\"STORES\" WHERE \"ID\" = 10001
+    );
+
+    INSERT INTO \"DBX_TEST\".\"PRODUCTS\"
+      (\"ID\", \"SKU\", \"PRODUCT_NAME\", \"CATEGORY\", \"PRICE\")
+    SELECT 10001, 'TEST_SKU_001', '测试商品', '测试分类', 99.90
+    FROM DUAL
+    WHERE NOT EXISTS (
+      SELECT 1 FROM \"DBX_TEST\".\"PRODUCTS\" WHERE \"ID\" = 10001
+    );
+
+    INSERT INTO \"DBX_TEST\".\"ORDERS_10K\"
+      (\"ID\", \"ORDER_NO\", \"STORE_ID\", \"PRODUCT_ID\", \"CUSTOMER_NAME\", \"QUANTITY\", \"AMOUNT\", \"ORDER_STATUS\", \"CREATED_AT\")
+    SELECT 10001, 'TEST_ORDER_001', 10001, 10001, '测试客户', 2, 199.80, 'PAID', SYSDATE
+    FROM DUAL
+    WHERE NOT EXISTS (
+      SELECT 1 FROM \"DBX_TEST\".\"ORDERS_10K\" WHERE \"ORDER_NO\" = 'TEST_ORDER_001'
+    );
+
+    COMMIT;
+  END IF;
+END;
+/
+SELECT 1;";
+        let expected = sql.split("\n/").next().unwrap();
+        let cursor = sql[..sql.find("ORDERS_10K").unwrap()].encode_utf16().count();
+        let next_cursor = sql[..sql.find("SELECT 1;").unwrap()].encode_utf16().count();
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Oracle),
+            vec![expected.to_string(), "SELECT 1".to_string()]
+        );
+        assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Oracle), expected);
+        assert_eq!(find_statement_at_cursor_for_database(sql, next_cursor, DatabaseType::Oracle), "SELECT 1");
+    }
+
+    #[test]
+    fn oracle_like_split_keeps_transaction_begin_as_statement() {
+        assert_eq!(
+            split_sql_statements_for_database("BEGIN; INSERT INTO t VALUES (1); COMMIT;", DatabaseType::Gaussdb),
+            vec!["BEGIN", "INSERT INTO t VALUES (1)", "COMMIT"]
+        );
+    }
+
+    #[test]
+    fn oracle_like_split_keeps_create_function_together() {
+        let sql = "\
+CREATE OR REPLACE FUNCTION number_tochar(nums VARCHAR(20))
+RETURN VARCHAR(20)
+AS
+    res VARCHAR(20);
+BEGIN
+    RETURN '一';
+END;
+/
+SELECT 1;";
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Oracle),
+            vec!["CREATE OR REPLACE FUNCTION number_tochar(nums VARCHAR(20))\nRETURN VARCHAR(20)\nAS\n    res VARCHAR(20);\nBEGIN\n    RETURN '一';\nEND;", "SELECT 1"]
+        );
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Dameng),
+            vec!["CREATE OR REPLACE FUNCTION number_tochar(nums VARCHAR(20))\nRETURN VARCHAR(20)\nAS\n    res VARCHAR(20);\nBEGIN\n    RETURN '一';\nEND;", "SELECT 1"]
+        );
+    }
+
+    #[test]
+    fn oracle_like_split_keeps_create_procedure_together() {
+        let sql = "\
+CREATE OR REPLACE PROCEDURE update_salary(p_id NUMBER, p_amount NUMBER)
+AS
+BEGIN
+    UPDATE employees SET salary = salary + p_amount WHERE id = p_id;
+    COMMIT;
+END;
+/
+SELECT 1;";
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Oracle),
+            vec![
+                "CREATE OR REPLACE PROCEDURE update_salary(p_id NUMBER, p_amount NUMBER)\nAS\nBEGIN\n    UPDATE employees SET salary = salary + p_amount WHERE id = p_id;\n    COMMIT;\nEND;",
+                "SELECT 1"
+            ]
+        );
+    }
+
+    #[test]
+    fn oracle_like_split_keeps_create_trigger_together() {
+        let sql = "\
+CREATE TRIGGER trg_audit
+BEFORE INSERT ON employees
+FOR EACH ROW
+BEGIN
+    INSERT INTO audit_log VALUES (:NEW.id, 'INSERT');
+END;
+/
+SELECT 1;";
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Oracle),
+            vec![
+                "CREATE TRIGGER trg_audit\nBEFORE INSERT ON employees\nFOR EACH ROW\nBEGIN\n    INSERT INTO audit_log VALUES (:NEW.id, 'INSERT');\nEND;",
+                "SELECT 1"
+            ]
+        );
+    }
+
+    #[test]
+    fn yashandb_split_keeps_create_trigger_with_slash_delimiter_together() {
+        let sql = "\
+CREATE TRIGGER \"TB_SC_UPDATE_TIME_TRI\"
+BEFORE UPDATE ON \"TB_SC\"
+FOR EACH ROW
+ BEGIN
+   IF NOT UPDATING('UPDATE_TIME')  THEN
+   \t\t:NEW.\"UPDATE_TIME\" := CURRENT_TIMESTAMP;
+   END IF;
+END;
+/
+SELECT 1;";
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Yashandb),
+            vec![
+                "CREATE TRIGGER \"TB_SC_UPDATE_TIME_TRI\"\nBEFORE UPDATE ON \"TB_SC\"\nFOR EACH ROW\n BEGIN\n   IF NOT UPDATING('UPDATE_TIME')  THEN\n   \t\t:NEW.\"UPDATE_TIME\" := CURRENT_TIMESTAMP;\n   END IF;\nEND;",
+                "SELECT 1"
+            ]
+        );
+    }
+
+    #[test]
+    fn oracle_like_split_keeps_create_package_together() {
+        let sql = "\
+CREATE OR REPLACE PACKAGE pkg_utils AS
+    FUNCTION get_version RETURN VARCHAR2;
+    PROCEDURE log_message(msg VARCHAR2);
+END pkg_utils;
+/
+SELECT 1;";
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Oracle),
+            vec![
+                "CREATE OR REPLACE PACKAGE pkg_utils AS\n    FUNCTION get_version RETURN VARCHAR2;\n    PROCEDURE log_message(msg VARCHAR2);\nEND pkg_utils;",
+                "SELECT 1"
+            ]
+        );
+    }
+
+    #[test]
+    fn oracle_like_split_ignores_end_tokens_inside_q_quoted_strings() {
+        let sql = "\
+BEGIN
+    v_text := q'[not really END;]';
+    NULL;
+END;
+SELECT 1;";
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Oracle),
+            vec!["BEGIN\n    v_text := q'[not really END;]';\n    NULL;\nEND;", "SELECT 1"]
+        );
+    }
+
+    #[test]
+    fn oracle_plsql_tokenizer_falls_back_when_sqlparser_rejects_partial_literals() {
+        let sql = "\
+BEGIN
+    NULL;
+    v_text := 'partial";
+        let tokens = super::oracle_plsql_tokens(sql);
+
+        assert!(tokens.iter().any(|token| token.is_word("BEGIN")));
+        assert!(tokens.iter().any(super::OraclePlSqlToken::is_semicolon));
+    }
+
+    #[test]
+    fn oracle_like_split_does_not_affect_create_table() {
+        let sql = "\
+CREATE TABLE users (id NUMBER PRIMARY KEY, name VARCHAR2(100));
+CREATE OR REPLACE VIEW v_users AS SELECT id, name FROM users;";
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Oracle),
+            vec![
+                "CREATE TABLE users (id NUMBER PRIMARY KEY, name VARCHAR2(100))",
+                "CREATE OR REPLACE VIEW v_users AS SELECT id, name FROM users"
+            ]
+        );
+    }
+
+    #[test]
+    fn finds_statement_at_cursor() {
+        let sql = "SELECT 1; SELECT 2";
+
+        assert_eq!(super::find_statement_at_cursor(sql, 3), "SELECT 1");
+        assert_eq!(super::find_statement_at_cursor(sql, 12), "SELECT 2");
+        assert_eq!(super::find_statement_at_cursor(sql, 18), "SELECT 2");
+    }
+
+    #[test]
+    fn finds_statement_at_cursor_after_unicode_comment() {
+        let sql = "-- 判断字段是否存在\nSELECT 1; SELECT 2";
+        let cursor_byte = sql.find("SELECT 2").unwrap();
+        let cursor = sql[..cursor_byte].encode_utf16().count();
+
+        assert_eq!(super::find_statement_at_cursor(sql, cursor), "SELECT 2");
+    }
+
+    #[test]
+    fn finds_statement_at_cursor_after_semicolon_with_blank_line_stays_on_previous_statement() {
+        let sql = "SELECT 1;\n\nSELECT 2;";
+        let cursor = sql[..sql.find(';').unwrap() + 1].encode_utf16().count();
+        assert_eq!(super::find_statement_at_cursor(sql, cursor), "SELECT 1");
+    }
+
+    #[test]
+    fn finds_statement_at_cursor_after_semicolon_same_line_moves_to_next_statement() {
+        let sql = "SELECT 1; SELECT 2;";
+        let cursor = sql[..sql.find("SELECT 2").unwrap()].encode_utf16().count();
+
+        assert_eq!(super::find_statement_at_cursor(sql, cursor), "SELECT 2");
+    }
+
+    #[test]
+    fn finds_statement_at_cursor_after_double_blank_line_without_semicolon() {
+        let sql = "SELECT * FROM old_table\n\n\nCREATE VIEW v AS SELECT 1";
+        let cursor = sql[..sql.find("CREATE VIEW").unwrap()].encode_utf16().count();
+
+        assert_eq!(super::find_statement_at_cursor(sql, cursor), "CREATE VIEW v AS SELECT 1");
+    }
+
+    #[test]
+    fn keeps_create_view_statement_together_across_double_blank_line() {
+        let sql = "CREATE VIEW v AS\n\n\nSELECT 1";
+        let cursor = sql[..sql.find("SELECT 1").unwrap()].encode_utf16().count();
+
+        assert_eq!(super::find_statement_at_cursor(sql, cursor), "CREATE VIEW v AS\n\n\nSELECT 1");
+    }
+
+    #[test]
+    fn finds_statement_with_dollar_quote() {
+        let sql = "SELECT $$a;b$$; SELECT 2";
+
+        assert_eq!(super::find_statement_at_cursor(sql, 3), "SELECT $$a;b$$");
+        assert_eq!(super::find_statement_at_cursor(sql, 17), "SELECT 2");
+    }
+
+    #[test]
+    fn finds_statement_with_custom_delimiter() {
+        let sql = "\
+DELIMITER //
+CREATE PROCEDURE foo()
+BEGIN
+  SELECT 1;
+END //
+DELIMITER ;
+SELECT 2;";
+        let cursor = sql.find("SELECT 1").unwrap();
+        let next_cursor = sql.rfind("SELECT 2").unwrap();
+
+        assert_eq!(super::find_statement_at_cursor(sql, cursor), "CREATE PROCEDURE foo()\nBEGIN\n  SELECT 1;\nEND");
+        assert_eq!(super::find_statement_at_cursor(sql, next_cursor), "SELECT 2");
+    }
+
+    #[test]
+    fn sqlserver_current_statement_keeps_procedure_batch_with_inner_semicolons() {
+        let sql = "\
+CREATE OR ALTER PROCEDURE dbo.usp_demo
+AS
+BEGIN
+  SELECT 1;
+  SELECT 2;
+END
+GO
+SELECT 3;";
+        let cursor = sql[..sql.find("SELECT 2").unwrap()].encode_utf16().count();
+        let next_cursor = sql[..sql.rfind("SELECT 3").unwrap()].encode_utf16().count();
+
+        assert_eq!(
+            super::find_statement_at_cursor_for_database(sql, cursor, DatabaseType::SqlServer),
+            "CREATE OR ALTER PROCEDURE dbo.usp_demo\nAS\nBEGIN\n  SELECT 1;\n  SELECT 2;\nEND"
+        );
+        assert_eq!(super::find_statement_at_cursor_for_database(sql, next_cursor, DatabaseType::SqlServer), "SELECT 3");
+    }
+
+    #[test]
+    fn sqlserver_current_statement_keeps_alter_procedure_batch() {
+        let sql = "\
+ALTER PROC dbo.usp_demo
+AS
+BEGIN
+  UPDATE dbo.users SET name = name;
+END";
+        let cursor = sql[..sql.find("UPDATE").unwrap()].encode_utf16().count();
+
+        assert_eq!(
+            super::find_statement_at_cursor_for_database(sql, cursor, DatabaseType::SqlServer),
+            "ALTER PROC dbo.usp_demo\nAS\nBEGIN\n  UPDATE dbo.users SET name = name;\nEND"
+        );
+    }
+
+    #[test]
+    fn mysql_hash_comments_split_statements_per_issue_428() {
+        let sql = "SELECT 1; # mysql comment\n\nSELECT 2 # trailing comment";
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Mysql),
+            vec!["SELECT 1", "# mysql comment\n\nSELECT 2 # trailing comment"]
+        );
+    }
+
+    #[test]
+    fn mysql_delimiter_command_keeps_procedure_body_together_per_issue_1978() {
+        let sql = "\
+-- ----------------------------
+-- Procedure structure for fix_collation
+-- ----------------------------
+DROP PROCEDURE IF EXISTS `fix_collation`;
+delimiter ;;
+CREATE PROCEDURE `fix_collation`()
+BEGIN
+DECLARE done INT DEFAULT FALSE;
+DECLARE tbl_name VARCHAR(255);
+DECLARE cur CURSOR FOR
+SELECT TABLE_NAME FROM information_schema.TABLES
+WHERE TABLE_SCHEMA = DATABASE() AND TABLE_COLLATION = 'utf8mb4_0900_ai_ci';
+DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
+
+    OPEN cur;
+    read_loop: LOOP
+        FETCH cur INTO tbl_name;
+        IF done THEN LEAVE read_loop; END IF;
+        SET @sql = CONCAT('ALTER TABLE `', tbl_name, '` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci');
+        PREPARE stmt FROM @sql;
+        EXECUTE stmt;
+        DEALLOCATE PREPARE stmt;
+    END LOOP;
+    CLOSE cur;
+END
+;;
+delimiter ;";
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Mysql),
+            vec![
+                "-- ----------------------------\n-- Procedure structure for fix_collation\n-- ----------------------------\nDROP PROCEDURE IF EXISTS `fix_collation`",
+                "CREATE PROCEDURE `fix_collation`()\nBEGIN\nDECLARE done INT DEFAULT FALSE;\nDECLARE tbl_name VARCHAR(255);\nDECLARE cur CURSOR FOR\nSELECT TABLE_NAME FROM information_schema.TABLES\nWHERE TABLE_SCHEMA = DATABASE() AND TABLE_COLLATION = 'utf8mb4_0900_ai_ci';\nDECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;\n\n    OPEN cur;\n    read_loop: LOOP\n        FETCH cur INTO tbl_name;\n        IF done THEN LEAVE read_loop; END IF;\n        SET @sql = CONCAT('ALTER TABLE `', tbl_name, '` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci');\n        PREPARE stmt FROM @sql;\n        EXECUTE stmt;\n        DEALLOCATE PREPARE stmt;\n    END LOOP;\n    CLOSE cur;\nEND",
+            ]
+        );
+    }
+
+    #[test]
+    fn mysql_current_statement_ignores_delimiter_command_semicolon_per_issue_1978() {
+        let sql = "\
+delimiter ;;
+CREATE PROCEDURE `fix_collation`()
+BEGIN
+    SET @sql = CONCAT('ALTER TABLE `', 't', '` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci');
+    PREPARE stmt FROM @sql;
+    EXECUTE stmt;
+END
+;;
+delimiter ;";
+        let cursor = sql[..sql.find("PREPARE").unwrap()].encode_utf16().count();
+
+        assert_eq!(
+            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Mysql),
+            "CREATE PROCEDURE `fix_collation`()\nBEGIN\n    SET @sql = CONCAT('ALTER TABLE `', 't', '` CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci');\n    PREPARE stmt FROM @sql;\n    EXECUTE stmt;\nEND"
+        );
+    }
+
+    #[test]
+    fn mysql_delimiter_command_skips_empty_custom_delimiter_statement_per_issue_1988() {
+        let sql = "\
+select COUNT(1) FROM your_table;
+delimiter ;;
+select COUNT(1) FROM your_table;
+
+;;
+delimiter ;";
+
+        assert_eq!(
+            split_sql_statements_for_database(sql, DatabaseType::Mysql),
+            vec!["select COUNT(1) FROM your_table", "select COUNT(1) FROM your_table;"]
+        );
+    }
+
+    #[test]
+    fn mysql_delimiter_command_ranges_skip_empty_custom_delimiter_statement_per_issue_1988() {
+        let sql = "\
+select COUNT(1) FROM your_table;
+delimiter ;;
+select COUNT(1) FROM your_table;
+
+;;
+delimiter ;";
+
+        let ranges =
+            split_sql_statement_ranges_with_options(sql, SqlParsingOptions::for_database_type(DatabaseType::Mysql));
+
+        assert_eq!(
+            ranges.iter().map(|range| range.text.as_str()).collect::<Vec<_>>(),
+            vec!["select COUNT(1) FROM your_table", "select COUNT(1) FROM your_table;"]
+        );
+    }
+
+    #[test]
+    fn mysql_current_statement_keeps_inline_hash_comment_per_issue_428() {
+        let sql = "SELECT 1; # mysql comment\n\nSELECT 2 # trailing comment";
+        let cursor = sql[..sql.find("SELECT 2").unwrap()].encode_utf16().count();
+        assert_eq!(
+            find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Mysql),
+            "SELECT 2 # trailing comment"
+        );
+    }
+
+    #[test]
+    fn mysql_single_statement_with_inline_comment_stays_executable_per_issue_428() {
+        let sql = "SELECT 1 # mysql comment";
+        let cursor = sql.encode_utf16().count();
+        assert_eq!(find_statement_at_cursor_for_database(sql, cursor, DatabaseType::Mysql), "SELECT 1 # mysql comment");
+    }
+}
diff --git a/crates/dbx-core/src/sql_analysis.rs b/crates/dbx-core/src/sql_analysis.rs
new file mode 100644
index 0000000..4a1067a
--- /dev/null
+++ b/crates/dbx-core/src/sql_analysis.rs
@@ -0,0 +1,488 @@
+use serde::{Deserialize, Serialize};
+use std::sync::LazyLock;
+
+use regex::Regex;
+use sqlparser::ast::{
+    Expr, FunctionArg, FunctionArgExpr, FunctionArguments, GroupByExpr, Ident, JoinConstraint, JoinOperator,
+    ObjectName, ObjectNamePart, OrderByKind, Query, Select, SelectItem, SetExpr, Statement, TableFactor,
+    TableWithJoins,
+};
+use sqlparser::dialect::{
+    ClickHouseDialect, DuckDbDialect, GenericDialect, MsSqlDialect, MySqlDialect, PostgreSqlDialect, SQLiteDialect,
+};
+use sqlparser::parser::Parser;
+use sqlparser::tokenizer::Span;
+
+use crate::sql::{starts_with_duckdb_result_sql_keyword, starts_with_executable_sql_keyword};
+
+static CLICKHOUSE_STRICTNESS_FIRST_JOIN_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"(?i)\b(ANY|ALL|SEMI|ANTI|ASOF)\s+(LEFT|RIGHT|FULL|INNER|CROSS)(\s+OUTER)?\s+JOIN\b")
+        .expect("valid ClickHouse join strictness regex")
+});
+static POSTGRES_DEFAULT_PRIVILEGES_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r"(?i)^\s*ALTER\s+DEFAULT\s+PRIVILEGES\b").expect("valid PostgreSQL default privileges regex")
+});
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SqlReferenceAnalysis {
+    pub tables: Vec<SqlTableReference>,
+    pub columns: Vec<SqlColumnReference>,
+    pub scopes: Vec<SqlReferenceScope>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SqlTableReference {
+    pub name: String,
+    pub schema: Option<String>,
+    pub alias: Option<String>,
+    pub span: SqlTextSpan,
+    pub scope_id: usize,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SqlColumnReference {
+    pub name: String,
+    pub qualifier: Option<String>,
+    pub span: SqlTextSpan,
+    pub scope_id: usize,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SqlReferenceScope {
+    pub id: usize,
+    pub parent_id: Option<usize>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SqlTextSpan {
+    pub start_line: usize,
+    pub start_column: usize,
+    pub end_line: usize,
+    pub end_column: usize,
+}
+
+impl From<Span> for SqlTextSpan {
+    fn from(span: Span) -> Self {
+        Self {
+            start_line: span.start.line as usize,
+            start_column: span.start.column as usize,
+            end_line: span.end.line as usize,
+            end_column: span.end.column as usize,
+        }
+    }
+}
+
+#[derive(Default)]
+struct Analyzer {
+    tables: Vec<SqlTableReference>,
+    columns: Vec<SqlColumnReference>,
+    scopes: Vec<SqlReferenceScope>,
+    scope_stack: Vec<usize>,
+    next_scope_id: usize,
+}
+
+pub fn analyze_sql_references(sql: &str, dialect: Option<&str>) -> Result<SqlReferenceAnalysis, String> {
+    let normalized_dialect = normalize_dialect(dialect);
+    if normalized_dialect == "duckdb" && starts_with_duckdb_parser_gap_sql(sql) {
+        return Ok(SqlReferenceAnalysis { tables: vec![], columns: vec![], scopes: vec![] });
+    }
+    if normalized_dialect == "postgres" && starts_with_postgres_parser_gap_sql(sql) {
+        return Ok(SqlReferenceAnalysis { tables: vec![], columns: vec![], scopes: vec![] });
+    }
+    let parser_sql = if normalized_dialect == "clickhouse" {
+        normalize_clickhouse_join_order_for_parser(sql)
+    } else {
+        sql.to_string()
+    };
+
+    let statements = match normalized_dialect.as_str() {
+        "postgres" => Parser::parse_sql(&PostgreSqlDialect {}, &parser_sql),
+        "mysql" => Parser::parse_sql(&MySqlDialect {}, &parser_sql),
+        "sqlite" => Parser::parse_sql(&SQLiteDialect {}, &parser_sql),
+        "sqlserver" => Parser::parse_sql(&MsSqlDialect {}, &parser_sql),
+        "clickhouse" => Parser::parse_sql(&ClickHouseDialect {}, &parser_sql),
+        "duckdb" => Parser::parse_sql(&DuckDbDialect {}, &parser_sql),
+        _ => Parser::parse_sql(&GenericDialect {}, &parser_sql),
+    }
+    .map_err(|err| err.to_string())?;
+
+    let mut analyzer = Analyzer::default();
+    for statement in statements {
+        analyzer.visit_statement(&statement);
+    }
+
+    Ok(SqlReferenceAnalysis { tables: analyzer.tables, columns: analyzer.columns, scopes: analyzer.scopes })
+}
+
+fn starts_with_duckdb_parser_gap_sql(sql: &str) -> bool {
+    starts_with_duckdb_result_sql_keyword(sql)
+        && starts_with_executable_sql_keyword(sql, &["FROM", "SUMMARIZE", "SUMMARISE", "PIVOT", "UNPIVOT"])
+}
+
+fn starts_with_postgres_parser_gap_sql(sql: &str) -> bool {
+    POSTGRES_DEFAULT_PRIVILEGES_RE.is_match(sql)
+}
+
+fn normalize_clickhouse_join_order_for_parser(sql: &str) -> String {
+    CLICKHOUSE_STRICTNESS_FIRST_JOIN_RE
+        .replace_all(sql, |captures: &regex::Captures<'_>| {
+            let matched_len = captures.get(0).map(|value| value.as_str().len()).unwrap_or(0);
+            let strictness = captures.get(1).map(|value| value.as_str()).unwrap_or("");
+            let join_type = captures.get(2).map(|value| value.as_str()).unwrap_or("");
+            let outer = captures.get(3).map(|value| value.as_str()).unwrap_or("");
+            let mut normalized = match strictness.to_ascii_uppercase().as_str() {
+                "SEMI" | "ANTI" => format!("{join_type}{outer} {strictness} JOIN"),
+                _ => format!("{join_type}{outer} JOIN"),
+            };
+            if normalized.len() < matched_len {
+                normalized.push_str(&" ".repeat(matched_len - normalized.len()));
+            }
+            normalized
+        })
+        .into_owned()
+}
+
+fn normalize_dialect(dialect: Option<&str>) -> String {
+    match dialect.unwrap_or("generic").to_ascii_lowercase().as_str() {
+        "postgres" | "postgresql" | "redshift" | "opengauss" | "gaussdb" | "highgo" | "questdb" => {
+            "postgres".to_string()
+        }
+        "mysql" | "mariadb" | "doris" | "starrocks" | "manticoresearch" | "oceanbase" => "mysql".to_string(),
+        "sqlite" => "sqlite".to_string(),
+        "sqlserver" | "mssql" => "sqlserver".to_string(),
+        "clickhouse" => "clickhouse".to_string(),
+        "duckdb" => "duckdb".to_string(),
+        _ => "generic".to_string(),
+    }
+}
+
+impl Analyzer {
+    fn visit_statement(&mut self, statement: &Statement) {
+        if let Statement::Query(query) = statement {
+            self.visit_query_in_new_scope(query, None);
+        }
+    }
+
+    fn visit_query_in_new_scope(&mut self, query: &Query, parent_id: Option<usize>) {
+        let scope_id = self.next_scope_id;
+        self.next_scope_id += 1;
+        self.scopes.push(SqlReferenceScope { id: scope_id, parent_id });
+        self.scope_stack.push(scope_id);
+        self.visit_query(query);
+        self.scope_stack.pop();
+    }
+
+    fn visit_child_query(&mut self, query: &Query) {
+        self.visit_query_in_new_scope(query, self.current_scope_id());
+    }
+
+    fn current_scope_id(&self) -> Option<usize> {
+        self.scope_stack.last().copied()
+    }
+
+    fn visit_query(&mut self, query: &Query) {
+        if let Some(with) = &query.with {
+            for cte in &with.cte_tables {
+                self.visit_child_query(&cte.query);
+            }
+        }
+        self.visit_set_expr(&query.body);
+        if let Some(order_by) = &query.order_by {
+            if let OrderByKind::Expressions(exprs) = &order_by.kind {
+                for expr in exprs {
+                    self.visit_expr(&expr.expr);
+                }
+            }
+        }
+    }
+
+    fn visit_set_expr(&mut self, set_expr: &SetExpr) {
+        match set_expr {
+            SetExpr::Select(select) => self.visit_select(select),
+            SetExpr::Query(query) => self.visit_child_query(query),
+            SetExpr::SetOperation { left, right, .. } => {
+                self.visit_set_expr_in_child_scope(left);
+                self.visit_set_expr_in_child_scope(right);
+            }
+            _ => {}
+        }
+    }
+
+    fn visit_set_expr_in_child_scope(&mut self, set_expr: &SetExpr) {
+        let scope_id = self.next_scope_id;
+        self.next_scope_id += 1;
+        self.scopes.push(SqlReferenceScope { id: scope_id, parent_id: self.current_scope_id() });
+        self.scope_stack.push(scope_id);
+        self.visit_set_expr(set_expr);
+        self.scope_stack.pop();
+    }
+
+    fn visit_select(&mut self, select: &Select) {
+        for table in &select.from {
+            self.visit_table_with_joins(table);
+        }
+
+        for item in &select.projection {
+            match item {
+                SelectItem::UnnamedExpr(expr)
+                | SelectItem::ExprWithAlias { expr, .. }
+                | SelectItem::ExprWithAliases { expr, .. } => self.visit_expr(expr),
+                _ => {}
+            }
+        }
+
+        if let Some(expr) = &select.prewhere {
+            self.visit_expr(expr);
+        }
+        if let Some(expr) = &select.selection {
+            self.visit_expr(expr);
+        }
+        if let GroupByExpr::Expressions(exprs, _) = &select.group_by {
+            for expr in exprs {
+                self.visit_expr(expr);
+            }
+        }
+        for expr in &select.cluster_by {
+            self.visit_expr(expr);
+        }
+        for expr in &select.distribute_by {
+            self.visit_expr(expr);
+        }
+        for expr in &select.sort_by {
+            self.visit_expr(&expr.expr);
+        }
+        if let Some(expr) = &select.having {
+            self.visit_expr(expr);
+        }
+        if let Some(expr) = &select.qualify {
+            self.visit_expr(expr);
+        }
+    }
+
+    fn visit_table_with_joins(&mut self, table: &TableWithJoins) {
+        self.visit_table_factor(&table.relation);
+        for join in &table.joins {
+            self.visit_table_factor(&join.relation);
+            self.visit_join_operator(&join.join_operator);
+        }
+    }
+
+    fn visit_join_operator(&mut self, operator: &JoinOperator) {
+        match operator {
+            JoinOperator::Join(constraint)
+            | JoinOperator::Inner(constraint)
+            | JoinOperator::Left(constraint)
+            | JoinOperator::LeftOuter(constraint)
+            | JoinOperator::Right(constraint)
+            | JoinOperator::RightOuter(constraint)
+            | JoinOperator::FullOuter(constraint)
+            | JoinOperator::CrossJoin(constraint)
+            | JoinOperator::Semi(constraint)
+            | JoinOperator::LeftSemi(constraint)
+            | JoinOperator::RightSemi(constraint)
+            | JoinOperator::Anti(constraint)
+            | JoinOperator::LeftAnti(constraint)
+            | JoinOperator::RightAnti(constraint)
+            | JoinOperator::StraightJoin(constraint) => self.visit_join_constraint(constraint),
+            JoinOperator::AsOf { match_condition, constraint } => {
+                self.visit_expr(match_condition);
+                self.visit_join_constraint(constraint);
+            }
+            _ => {}
+        }
+    }
+
+    fn visit_join_constraint(&mut self, constraint: &JoinConstraint) {
+        match constraint {
+            JoinConstraint::On(expr) => self.visit_expr(expr),
+            JoinConstraint::Using(names) => {
+                for name in names {
+                    if let Some(ident) = object_name_last_ident(name) {
+                        self.push_column(None, ident);
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn visit_table_factor(&mut self, factor: &TableFactor) {
+        match factor {
+            TableFactor::Table { name, alias, args, .. } => {
+                if args.is_none() {
+                    if let Some(table) = table_reference_from_name(
+                        name,
+                        alias.as_ref().map(|a| a.name.value.clone()),
+                        self.current_scope_id(),
+                    ) {
+                        self.tables.push(table);
+                    }
+                }
+            }
+            TableFactor::Derived { subquery, .. } => self.visit_child_query(subquery),
+            TableFactor::NestedJoin { table_with_joins, .. } => self.visit_table_with_joins(table_with_joins),
+            TableFactor::TableFunction { expr, .. } => self.visit_expr(expr),
+            TableFactor::Function { args, .. } => {
+                for arg in args {
+                    self.visit_function_arg(arg);
+                }
+            }
+            TableFactor::UNNEST { array_exprs, .. } => {
+                for expr in array_exprs {
+                    self.visit_expr(expr);
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn visit_expr(&mut self, expr: &Expr) {
+        match expr {
+            Expr::Identifier(ident) => self.push_column(None, ident),
+            Expr::CompoundIdentifier(idents) => {
+                if idents.len() >= 2 {
+                    let column = idents.last().expect("checked length");
+                    let qualifier = idents.get(idents.len() - 2).map(|ident| ident.value.clone());
+                    self.push_column(qualifier, column);
+                }
+            }
+            Expr::CompoundFieldAccess { root, .. } | Expr::JsonAccess { value: root, .. } => self.visit_expr(root),
+            Expr::IsFalse(expr)
+            | Expr::IsNotFalse(expr)
+            | Expr::IsTrue(expr)
+            | Expr::IsNotTrue(expr)
+            | Expr::IsNull(expr)
+            | Expr::IsNotNull(expr)
+            | Expr::IsUnknown(expr)
+            | Expr::IsNotUnknown(expr)
+            | Expr::UnaryOp { expr, .. }
+            | Expr::Nested(expr) => self.visit_expr(expr),
+            Expr::IsDistinctFrom(left, right)
+            | Expr::IsNotDistinctFrom(left, right)
+            | Expr::BinaryOp { left, right, .. }
+            | Expr::AnyOp { left, right, .. }
+            | Expr::AllOp { left, right, .. } => {
+                self.visit_expr(left);
+                self.visit_expr(right);
+            }
+            Expr::InList { expr, list, .. } => {
+                self.visit_expr(expr);
+                for item in list {
+                    self.visit_expr(item);
+                }
+            }
+            Expr::InSubquery { expr, subquery, .. } => {
+                self.visit_expr(expr);
+                self.visit_query(subquery);
+            }
+            Expr::InUnnest { expr, array_expr, .. } => {
+                self.visit_expr(expr);
+                self.visit_expr(array_expr);
+            }
+            Expr::Between { expr, low, high, .. } => {
+                self.visit_expr(expr);
+                self.visit_expr(low);
+                self.visit_expr(high);
+            }
+            Expr::Like { expr, pattern, .. }
+            | Expr::ILike { expr, pattern, .. }
+            | Expr::SimilarTo { expr, pattern, .. }
+            | Expr::RLike { expr, pattern, .. } => {
+                self.visit_expr(expr);
+                self.visit_expr(pattern);
+            }
+            Expr::Cast { expr, .. }
+            | Expr::Extract { expr, .. }
+            | Expr::Ceil { expr, .. }
+            | Expr::Floor { expr, .. } => self.visit_expr(expr),
+            Expr::AtTimeZone { timestamp, time_zone } => {
+                self.visit_expr(timestamp);
+                self.visit_expr(time_zone);
+            }
+            Expr::Position { expr, r#in } => {
+                self.visit_expr(expr);
+                self.visit_expr(r#in);
+            }
+            Expr::Function(function) => {
+                self.visit_function_args(&function.parameters);
+                self.visit_function_args(&function.args);
+                if let Some(filter) = &function.filter {
+                    self.visit_expr(filter);
+                }
+                for order in &function.within_group {
+                    self.visit_expr(&order.expr);
+                }
+            }
+            Expr::Case { operand, conditions, else_result, .. } => {
+                if let Some(operand) = operand {
+                    self.visit_expr(operand);
+                }
+                for condition in conditions {
+                    self.visit_expr(&condition.condition);
+                    self.visit_expr(&condition.result);
+                }
+                if let Some(else_result) = else_result {
+                    self.visit_expr(else_result);
+                }
+            }
+            Expr::Subquery(query) | Expr::Exists { subquery: query, .. } => self.visit_child_query(query),
+            _ => {}
+        }
+    }
+
+    fn visit_function_args(&mut self, args: &FunctionArguments) {
+        match args {
+            FunctionArguments::Subquery(query) => self.visit_child_query(query),
+            FunctionArguments::List(list) => {
+                for arg in &list.args {
+                    self.visit_function_arg(arg);
+                }
+                for clause in &list.clauses {
+                    if let sqlparser::ast::FunctionArgumentClause::OrderBy(items) = clause {
+                        for item in items {
+                            self.visit_expr(&item.expr);
+                        }
+                    }
+                }
+            }
+            FunctionArguments::None => {}
+        }
+    }
+
+    fn visit_function_arg(&mut self, arg: &FunctionArg) {
+        match arg {
+            FunctionArg::Named { arg, .. } | FunctionArg::ExprNamed { arg, .. } | FunctionArg::Unnamed(arg) => {
+                if let FunctionArgExpr::Expr(expr) = arg {
+                    self.visit_expr(expr);
+                }
+            }
+        }
+    }
+
+    fn push_column(&mut self, qualifier: Option<String>, ident: &Ident) {
+        if let Some(scope_id) = self.current_scope_id() {
+            self.columns.push(SqlColumnReference {
+                name: ident.value.clone(),
+                qualifier,
+                span: ident.span.into(),
+                scope_id,
+            });
+        }
+    }
+}
+
+fn table_reference_from_name(
+    name: &ObjectName,
+    alias: Option<String>,
+    scope_id: Option<usize>,
+) -> Option<SqlTableReference> {
+    let parts: Vec<&Ident> = name.0.iter().filter_map(ObjectNamePart::as_ident).collect();
+    let table = parts.last()?;
+    let schema = if parts.len() >= 2 { parts.get(parts.len() - 2).map(|ident| ident.value.clone()) } else { None };
+
+    Some(SqlTableReference { name: table.value.clone(), schema, alias, span: table.span.into(), scope_id: scope_id? })
+}
+
+fn object_name_last_ident(name: &ObjectName) -> Option<&Ident> {
+    name.0.iter().rev().find_map(ObjectNamePart::as_ident)
+}
diff --git a/crates/dbx-core/src/sql_dialect.rs b/crates/dbx-core/src/sql_dialect.rs
new file mode 100644
index 0000000..b013050
--- /dev/null
+++ b/crates/dbx-core/src/sql_dialect.rs
@@ -0,0 +1,18 @@
+mod capabilities;
+mod identifiers;
+mod table_select;
+mod types;
+
+#[cfg(test)]
+mod tests;
+
+pub use capabilities::{
+    firebird_rows_clause, is_schema_aware, pagination_strategy, table_pagination_strategy, uses_fetch_first,
+    uses_single_row_insert_statements, PaginationContext, TablePaginationStrategy,
+};
+pub use identifiers::{
+    normalize_where_input, qualified_table_name, qualified_table_name_with_catalog, quote_table_identifier,
+};
+pub(crate) use identifiers::{parse_sqlserver_linked_schema_ref, qualified_transfer_table, quote_transfer_identifier};
+pub use table_select::{build_count_table_sql, build_table_data_select_sql, build_table_select_sql};
+pub use types::*;
diff --git a/crates/dbx-core/src/sql_dialect/capabilities.rs b/crates/dbx-core/src/sql_dialect/capabilities.rs
new file mode 100644
index 0000000..cf4bd26
--- /dev/null
+++ b/crates/dbx-core/src/sql_dialect/capabilities.rs
@@ -0,0 +1,123 @@
+use crate::models::connection::DatabaseType;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TablePaginationStrategy {
+    LimitOffset,
+    FetchFirst,
+    Db2FetchFirst,
+    SqlServerTop,
+    IrisTop,
+    InformixFirst,
+    FirebirdRows,
+    Rownum,
+    QuestDbLimit,
+    Unbounded,
+    AgentMaxRows,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PaginationContext {
+    TablePreview,
+    BoundedRead,
+    UserQuery,
+}
+
+pub fn is_schema_aware(database_type: DatabaseType) -> bool {
+    matches!(
+        database_type,
+        DatabaseType::Postgres
+            | DatabaseType::SqlServer
+            | DatabaseType::Oracle
+            | DatabaseType::Redshift
+            | DatabaseType::Dameng
+            | DatabaseType::Gaussdb
+            | DatabaseType::Kwdb
+            | DatabaseType::Kingbase
+            | DatabaseType::Highgo
+            | DatabaseType::Vastbase
+            | DatabaseType::Yashandb
+            | DatabaseType::Oscar
+            | DatabaseType::Databricks
+            | DatabaseType::SapHana
+            | DatabaseType::Teradata
+            | DatabaseType::Vertica
+            | DatabaseType::Exasol
+            | DatabaseType::OpenGauss
+            | DatabaseType::OceanbaseOracle
+            | DatabaseType::Gbase
+            | DatabaseType::Databend
+            | DatabaseType::Jdbc
+            | DatabaseType::H2
+            | DatabaseType::Snowflake
+            | DatabaseType::Trino
+            | DatabaseType::PrestoSql
+            | DatabaseType::Hive
+            | DatabaseType::Spark
+            | DatabaseType::Db2
+            | DatabaseType::Tdengine
+            | DatabaseType::Xugu
+            | DatabaseType::DuckDb
+            | DatabaseType::Iris
+    )
+}
+
+pub fn uses_fetch_first(database_type: DatabaseType) -> bool {
+    matches!(database_type, DatabaseType::Oracle | DatabaseType::Dameng | DatabaseType::Db2)
+}
+
+/// Oracle 系方言不支持 `INSERT ... VALUES (...), (...)` 多行语法，
+/// 复制为 INSERT 与导出 INSERT 都需按行生成单条语句。
+pub fn uses_single_row_insert_statements(database_type: DatabaseType) -> bool {
+    matches!(database_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle)
+}
+
+pub fn pagination_strategy(database_type: Option<DatabaseType>, context: PaginationContext) -> TablePaginationStrategy {
+    match database_type {
+        Some(DatabaseType::Jdbc) => TablePaginationStrategy::AgentMaxRows,
+        Some(DatabaseType::Oracle) if matches!(context, PaginationContext::TablePreview) => {
+            TablePaginationStrategy::Rownum
+        }
+        Some(DatabaseType::Oracle) if matches!(context, PaginationContext::BoundedRead) => {
+            TablePaginationStrategy::FetchFirst
+        }
+        Some(DatabaseType::Oracle) => TablePaginationStrategy::Unbounded,
+        Some(DatabaseType::Oscar)
+            if matches!(context, PaginationContext::TablePreview | PaginationContext::BoundedRead) =>
+        {
+            TablePaginationStrategy::Rownum
+        }
+        Some(DatabaseType::Oscar) => TablePaginationStrategy::Unbounded,
+        Some(DatabaseType::Dameng) => TablePaginationStrategy::FetchFirst,
+        Some(DatabaseType::Db2) => TablePaginationStrategy::Db2FetchFirst,
+        Some(DatabaseType::SqlServer) => TablePaginationStrategy::SqlServerTop,
+        Some(DatabaseType::Iris) => TablePaginationStrategy::IrisTop,
+        Some(DatabaseType::Informix) => TablePaginationStrategy::InformixFirst,
+        Some(DatabaseType::Firebird) => TablePaginationStrategy::FirebirdRows,
+        Some(DatabaseType::OceanbaseOracle) => TablePaginationStrategy::Rownum,
+        Some(DatabaseType::Questdb) => TablePaginationStrategy::QuestDbLimit,
+        _ => TablePaginationStrategy::LimitOffset,
+    }
+}
+
+pub fn table_pagination_strategy(database_type: Option<DatabaseType>) -> TablePaginationStrategy {
+    pagination_strategy(database_type, PaginationContext::TablePreview)
+}
+
+pub(super) fn is_simple_informix_identifier(name: &str) -> bool {
+    let mut chars = name.chars();
+    let Some(first) = chars.next() else {
+        return false;
+    };
+    (first.is_ascii_alphabetic() || first == '_')
+        && chars.all(|ch| ch.is_ascii_alphanumeric() || ch == '_' || ch == '$')
+}
+
+pub fn firebird_rows_clause(limit: usize, offset: usize) -> String {
+    if offset > 0 {
+        let start = offset + 1;
+        let end = offset + limit;
+        format!("ROWS {start} TO {end}")
+    } else {
+        format!("ROWS {limit}")
+    }
+}
diff --git a/crates/dbx-core/src/sql_dialect/identifiers.rs b/crates/dbx-core/src/sql_dialect/identifiers.rs
new file mode 100644
index 0000000..e4fef2e
--- /dev/null
+++ b/crates/dbx-core/src/sql_dialect/identifiers.rs
@@ -0,0 +1,161 @@
+use crate::models::connection::DatabaseType;
+use percent_encoding::percent_decode_str;
+
+use super::capabilities::{is_schema_aware, is_simple_informix_identifier};
+
+pub const SQLSERVER_LINKED_SCHEMA_PREFIX: &str = "__dbx_sqlserver_linked__:";
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SqlServerLinkedSchemaRef {
+    pub server: String,
+    pub catalog: String,
+    pub schema: String,
+}
+
+pub fn parse_sqlserver_linked_schema_ref(schema: &str) -> Option<SqlServerLinkedSchemaRef> {
+    let payload = schema.strip_prefix(SQLSERVER_LINKED_SCHEMA_PREFIX)?;
+    let mut parts = payload.split('|');
+    let server = decode_linked_schema_part(parts.next()?)?;
+    let catalog = decode_linked_schema_part(parts.next()?)?;
+    let schema = decode_linked_schema_part(parts.next()?)?;
+    if parts.next().is_some() || server.trim().is_empty() || catalog.trim().is_empty() || schema.trim().is_empty() {
+        return None;
+    }
+    Some(SqlServerLinkedSchemaRef { server, catalog, schema })
+}
+
+pub fn sqlserver_linked_table_name(linked: &SqlServerLinkedSchemaRef, table_name: &str) -> String {
+    [linked.server.as_str(), linked.catalog.as_str(), linked.schema.as_str(), table_name]
+        .into_iter()
+        .map(|part| quote_table_identifier(Some(DatabaseType::SqlServer), part))
+        .collect::<Vec<_>>()
+        .join(".")
+}
+
+fn decode_linked_schema_part(value: &str) -> Option<String> {
+    percent_decode_str(value).decode_utf8().ok().map(|value| value.into_owned())
+}
+
+pub fn qualified_table_name(database_type: Option<DatabaseType>, schema: Option<&str>, table_name: &str) -> String {
+    if database_type == Some(DatabaseType::Iotdb) {
+        let table_name = quote_table_identifier(database_type, table_name);
+        let schema = schema.map(str::trim).filter(|schema| !schema.is_empty());
+        if let Some(schema) = schema {
+            if table_name == schema || table_name.starts_with(&format!("{schema}.")) {
+                return table_name;
+            }
+            return format!("{}.{}", quote_table_identifier(database_type, schema), table_name);
+        }
+        return table_name;
+    }
+    let supports_qualifier = database_type.is_some_and(is_schema_aware)
+        || matches!(
+            database_type,
+            Some(DatabaseType::Mysql | DatabaseType::Goldendb | DatabaseType::StarRocks | DatabaseType::Doris)
+        );
+    if supports_qualifier
+        && database_type != Some(DatabaseType::Jdbc)
+        && schema.is_some_and(|schema| !schema.trim().is_empty())
+    {
+        if database_type == Some(DatabaseType::SqlServer) {
+            if let Some(linked) = schema.and_then(parse_sqlserver_linked_schema_ref) {
+                return sqlserver_linked_table_name(&linked, table_name);
+            }
+        }
+        return format!(
+            "{}.{}",
+            quote_table_identifier(database_type, schema.unwrap()),
+            quote_table_identifier(database_type, table_name)
+        );
+    }
+    quote_table_identifier(database_type, table_name)
+}
+
+/// Like `qualified_table_name`, but prefixes a Doris/StarRocks external
+/// catalog (`<catalog>.<schema>.<table>`) when `catalog` is present, non-empty,
+/// and not the engine's `internal` catalog. The `internal` guard is defensive —
+/// built-in-catalog tables never carry a catalog in the first place (the
+/// sidebar routes them through the standard path), so this only ever prefixes
+/// genuine external catalogs. Other engines ignore `catalog` (they have no
+/// 3-part catalog naming).
+pub fn qualified_table_name_with_catalog(
+    database_type: Option<DatabaseType>,
+    catalog: Option<&str>,
+    schema: Option<&str>,
+    table_name: &str,
+) -> String {
+    let table = qualified_table_name(database_type, schema, table_name);
+    let catalog = catalog.map(str::trim).filter(|catalog| !catalog.is_empty() && *catalog != "internal");
+    match (catalog, database_type) {
+        (Some(catalog), Some(DatabaseType::Doris | DatabaseType::StarRocks)) => {
+            format!("{}.{}", quote_table_identifier(database_type, catalog), table)
+        }
+        _ => table,
+    }
+}
+
+pub fn quote_table_identifier(database_type: Option<DatabaseType>, name: &str) -> String {
+    match database_type {
+        Some(DatabaseType::Iotdb) => name.to_string(),
+        // JDBC connections use the driver-reported identifier quote string
+        // (DatabaseMetaData.getIdentifierQuoteString()) inside the JDBC agent,
+        // so the Rust layer passes identifiers through unquoted.
+        Some(DatabaseType::Jdbc) => name.to_string(),
+        Some(
+            DatabaseType::Mysql
+            | DatabaseType::ClickHouse
+            | DatabaseType::Doris
+            | DatabaseType::Goldendb
+            | DatabaseType::StarRocks
+            | DatabaseType::ManticoreSearch
+            | DatabaseType::Hive
+            | DatabaseType::Spark
+            | DatabaseType::Databend
+            | DatabaseType::Tdengine
+            | DatabaseType::Access
+            | DatabaseType::Bigquery
+            | DatabaseType::Questdb,
+        ) => {
+            format!("`{}`", name.replace('`', "``"))
+        }
+        Some(DatabaseType::Informix) if is_simple_informix_identifier(name) => name.to_string(),
+        Some(DatabaseType::Neo4j) => format!("`{}`", name.replace('`', "``")),
+        Some(DatabaseType::SqlServer) => format!("[{}]", name.replace(']', "]]")),
+        _ => format!("\"{}\"", name.replace('"', "\"\"")),
+    }
+}
+
+pub fn normalize_where_input(where_input: Option<&str>) -> String {
+    let trimmed = where_input.unwrap_or("").trim().trim_end_matches(';').trim();
+    let mut chars = trimmed.chars();
+    let prefix = chars.by_ref().take(5).collect::<String>();
+    if prefix.eq_ignore_ascii_case("where") {
+        chars.as_str().trim().to_string()
+    } else {
+        trimmed.to_string()
+    }
+}
+
+pub(crate) fn quote_transfer_identifier(name: &str, database_type: &DatabaseType) -> String {
+    match database_type {
+        DatabaseType::Mysql
+        | DatabaseType::ClickHouse
+        | DatabaseType::Doris
+        | DatabaseType::StarRocks
+        | DatabaseType::Hive
+        | DatabaseType::Spark
+        | DatabaseType::Questdb => format!("`{}`", name.replace('`', "``")),
+        DatabaseType::SqlServer => format!("[{}]", name.replace(']', "]]")),
+        _ => format!("\"{}\"", name.replace('\"', "\"\"")),
+    }
+}
+
+pub(crate) fn qualified_transfer_table(table_name: &str, schema: &str, database_type: &DatabaseType) -> String {
+    let table = quote_transfer_identifier(table_name, database_type);
+    if schema.is_empty() || matches!(database_type, DatabaseType::Mysql | DatabaseType::MongoDb | DatabaseType::Questdb)
+    {
+        table
+    } else {
+        format!("{}.{}", quote_transfer_identifier(schema, database_type), table)
+    }
+}
diff --git a/crates/dbx-core/src/sql_dialect/table_select.rs b/crates/dbx-core/src/sql_dialect/table_select.rs
new file mode 100644
index 0000000..b749edb
--- /dev/null
+++ b/crates/dbx-core/src/sql_dialect/table_select.rs
@@ -0,0 +1,475 @@
+use crate::models::connection::DatabaseType;
+
+use super::capabilities::{firebird_rows_clause, table_pagination_strategy, uses_fetch_first, TablePaginationStrategy};
+use super::identifiers::{
+    normalize_where_input, qualified_table_name, qualified_table_name_with_catalog, quote_table_identifier,
+};
+use super::types::{
+    TableDataSelectSqlOptions, TableSelectSqlOptions, DBX_NEO4J_ELEMENT_ID_COLUMN, DBX_ROWID_COLUMN,
+    DBX_TDENGINE_TBNAME_COLUMN,
+};
+
+pub fn build_count_table_sql(database_type: Option<DatabaseType>, schema: Option<&str>, table_name: &str) -> String {
+    format!("SELECT COUNT(*) AS row_count FROM {}", qualified_table_name(database_type, schema, table_name))
+}
+
+pub fn build_table_data_select_sql(options: TableDataSelectSqlOptions) -> String {
+    let database_type = options.database_type;
+    let limit = options.limit.unwrap_or(100);
+    if database_type == Some(DatabaseType::Neo4j) {
+        return build_neo4j_table_select_sql(&options, limit);
+    }
+
+    // Doris / StarRocks multi-catalog: prefix the catalog for external-catalog tables.
+    let table = qualified_table_name_with_catalog(
+        database_type,
+        options.catalog.as_deref(),
+        options.schema.as_deref(),
+        &options.table_name,
+    );
+    let predicate = normalize_where_input(options.where_input.as_deref());
+    let where_clause = if predicate.is_empty() { String::new() } else { format!(" WHERE ({predicate})") };
+    let default_order_by = if database_type == Some(DatabaseType::InfluxDb) {
+        // InfluxQL only allows sorting of timestamp column
+        Some("time DESC".to_string())
+    } else {
+        None
+    };
+    let order_by = options.order_by.as_deref().filter(|order| !order.trim().is_empty()).or(default_order_by.as_deref());
+    let order = order_by.map(|order_by| format!(" ORDER BY {order_by}")).unwrap_or_default();
+    // Oracle join views can raise ORA-01445 when ROWID is selected; keep the
+    // synthetic ROWID fallback scoped to base-table reads.
+    let include_oracle_row_id = options.include_row_id
+        && database_type == Some(DatabaseType::Oracle)
+        && !is_view_table_type(options.table_type.as_deref());
+
+    let select_columns = if include_oracle_row_id {
+        format!("ROWIDTOCHAR(t.ROWID) AS \"{DBX_ROWID_COLUMN}\", t.*")
+    } else {
+        build_select_columns(
+            database_type,
+            &options.columns,
+            tdengine_should_include_tbname(database_type, options.table_type.as_deref()),
+        )
+    };
+    let rownum_select_columns = quoted_table_columns_or_star(database_type, &options.columns);
+    let page_select_columns = if include_oracle_row_id {
+        if options.columns.is_empty() {
+            "*".to_string()
+        } else {
+            format!("\"{DBX_ROWID_COLUMN}\", {rownum_select_columns}")
+        }
+    } else {
+        rownum_select_columns.clone()
+    };
+    let table_alias =
+        if include_oracle_row_id && database_type.is_some_and(uses_fetch_first) { format!("{table} t") } else { table };
+
+    match table_pagination_strategy(database_type) {
+        TablePaginationStrategy::IrisTop => {
+            format!("SELECT TOP {limit} {select_columns} FROM {table_alias}{where_clause}{order}")
+        }
+        TablePaginationStrategy::InformixFirst => {
+            let row_limit = informix_row_limit_clause(limit, options.offset.unwrap_or(0));
+            format!("SELECT {row_limit} {select_columns} FROM {table_alias}{where_clause}{order}")
+        }
+        TablePaginationStrategy::FirebirdRows => {
+            let rows = firebird_rows_clause(limit, options.offset.unwrap_or(0));
+            format!("SELECT {select_columns} FROM {table_alias}{where_clause}{order} {rows}")
+        }
+        TablePaginationStrategy::Db2FetchFirst if options.offset.is_some_and(|offset| offset > 0) => {
+            build_db2_table_select_page_sql(
+                &table_alias,
+                &where_clause,
+                order_by,
+                &options.columns,
+                limit,
+                options.offset.unwrap_or(0),
+            )
+        }
+        TablePaginationStrategy::Db2FetchFirst | TablePaginationStrategy::FetchFirst => {
+            let offset = options
+                .offset
+                .filter(|offset| *offset > 0)
+                .map(|offset| format!(" OFFSET {offset} ROWS"))
+                .unwrap_or_default();
+            format!(
+                "SELECT {select_columns} FROM {table_alias}{where_clause}{order}{offset} FETCH FIRST {limit} ROWS ONLY"
+            )
+        }
+        TablePaginationStrategy::Rownum => {
+            let rownum_inner_select_columns =
+                if include_oracle_row_id { &select_columns } else { &rownum_select_columns };
+            build_rownum_table_select_sql(
+                &table_alias,
+                &where_clause,
+                &order,
+                rownum_inner_select_columns,
+                &page_select_columns,
+                limit,
+                options.offset.unwrap_or(0),
+            )
+        }
+        TablePaginationStrategy::Unbounded => {
+            format!("SELECT {select_columns} FROM {table_alias}{where_clause}{order}")
+        }
+        TablePaginationStrategy::SqlServerTop => build_sqlserver_table_select_sql(
+            &table_alias,
+            &where_clause,
+            order_by.unwrap_or("(SELECT NULL)"),
+            &options.columns,
+            limit,
+            options.offset.unwrap_or(0),
+        ),
+        TablePaginationStrategy::QuestDbLimit => build_questdb_table_select_sql(
+            &table_alias,
+            &where_clause,
+            &order,
+            &options.columns,
+            limit,
+            options.offset.unwrap_or(0),
+        ),
+        TablePaginationStrategy::AgentMaxRows => {
+            format!("SELECT {select_columns} FROM {table_alias}{where_clause}{order};")
+        }
+        TablePaginationStrategy::LimitOffset => {
+            let offset = options
+                .offset
+                .filter(|offset| *offset > 0)
+                .map(|offset| format!(" OFFSET {offset}"))
+                .unwrap_or_default();
+            format!("SELECT {select_columns} FROM {table_alias}{where_clause}{order} LIMIT {limit}{offset};")
+        }
+    }
+}
+
+fn is_view_table_type(table_type: Option<&str>) -> bool {
+    table_type.is_some_and(|value| value.to_ascii_uppercase().contains("VIEW"))
+}
+
+pub fn build_table_select_sql(options: TableSelectSqlOptions<'_>) -> String {
+    let database_type = options.database_type;
+    let table = qualified_table_name(database_type, options.schema, options.table_name);
+    let select_columns = quoted_table_columns_or_star(database_type, options.columns);
+    let order_by = if options.order_columns.is_empty() {
+        String::new()
+    } else {
+        format!(
+            " ORDER BY {}",
+            options
+                .order_columns
+                .iter()
+                .map(|column| format!("{} ASC", quote_table_identifier(database_type, column)))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+    let limit = options.limit;
+
+    match table_pagination_strategy(database_type) {
+        TablePaginationStrategy::IrisTop => format!("SELECT TOP {limit} {select_columns} FROM {table}{order_by}"),
+        TablePaginationStrategy::InformixFirst => {
+            format!("SELECT FIRST {limit} {select_columns} FROM {table}{order_by}")
+        }
+        TablePaginationStrategy::FirebirdRows => {
+            let rows = firebird_rows_clause(limit, 0);
+            format!("SELECT {select_columns} FROM {table}{order_by} {rows}")
+        }
+        TablePaginationStrategy::Rownum => {
+            build_rownum_table_select_sql(&table, "", &order_by, &select_columns, &select_columns, limit, 0)
+        }
+        TablePaginationStrategy::Db2FetchFirst | TablePaginationStrategy::FetchFirst => {
+            format!("SELECT {select_columns} FROM {table}{order_by} FETCH FIRST {limit} ROWS ONLY")
+        }
+        TablePaginationStrategy::SqlServerTop => {
+            format!("SELECT TOP ({limit}) {select_columns} FROM {table}{order_by}")
+        }
+        TablePaginationStrategy::AgentMaxRows => format!("SELECT {select_columns} FROM {table}{order_by};"),
+        TablePaginationStrategy::Unbounded => format!("SELECT {select_columns} FROM {table}{order_by}"),
+        TablePaginationStrategy::QuestDbLimit | TablePaginationStrategy::LimitOffset => {
+            format!("SELECT {select_columns} FROM {table}{order_by} LIMIT {limit};")
+        }
+    }
+}
+
+fn informix_row_limit_clause(limit: usize, offset: usize) -> String {
+    if offset > 0 {
+        format!("SKIP {offset} FIRST {limit}")
+    } else {
+        format!("FIRST {limit}")
+    }
+}
+
+fn quoted_table_columns_or_star(database_type: Option<DatabaseType>, columns: &[String]) -> String {
+    if columns.is_empty() {
+        return "*".to_string();
+    }
+    columns.iter().map(|column| quote_table_identifier(database_type, column)).collect::<Vec<_>>().join(", ")
+}
+
+fn build_rownum_table_select_sql(
+    table: &str,
+    where_clause: &str,
+    order: &str,
+    inner_select_columns: &str,
+    outer_select_columns: &str,
+    limit: usize,
+    offset: usize,
+) -> String {
+    let inner_select = format!("SELECT {inner_select_columns} FROM {table}{where_clause}{order}");
+    if offset == 0 {
+        return format!("SELECT {outer_select_columns} FROM ({inner_select}) WHERE ROWNUM <= {limit}");
+    }
+
+    let row_number_alias = quote_table_identifier(Some(DatabaseType::Oracle), "__dbx_row_num");
+    let end = offset + limit;
+    format!(
+        "SELECT {outer_select_columns} FROM (SELECT dbx_inner.*, ROWNUM AS {row_number_alias} FROM ({inner_select}) dbx_inner WHERE ROWNUM <= {end}) WHERE {row_number_alias} > {offset}"
+    )
+}
+
+pub(super) fn is_tdengine_tbname(database_type: Option<DatabaseType>, name: &str) -> bool {
+    database_type == Some(DatabaseType::Tdengine) && name.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN)
+}
+
+fn tdengine_should_include_tbname(database_type: Option<DatabaseType>, table_type: Option<&str>) -> bool {
+    if database_type != Some(DatabaseType::Tdengine) {
+        return false;
+    }
+    matches!(
+        table_type.map(|value| value.trim().to_ascii_uppercase()),
+        Some(value) if value == "STABLE" || value == "SUPER TABLE" || value == "SUPERTABLE"
+    )
+}
+
+pub(super) fn build_select_columns(
+    database_type: Option<DatabaseType>,
+    columns: &[String],
+    include_tdengine_tbname: bool,
+) -> String {
+    if columns.is_empty() {
+        if database_type == Some(DatabaseType::Tdengine) && include_tdengine_tbname {
+            return format!("{DBX_TDENGINE_TBNAME_COLUMN}, *");
+        }
+        return "*".to_string();
+    }
+    if database_type == Some(DatabaseType::Tdengine) {
+        let mut tdengine_columns = Vec::new();
+        if include_tdengine_tbname
+            && !columns.iter().any(|column| column.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN))
+        {
+            tdengine_columns.push(DBX_TDENGINE_TBNAME_COLUMN.to_string());
+        }
+        tdengine_columns.extend(
+            columns
+                .iter()
+                .filter(|column| include_tdengine_tbname || !column.eq_ignore_ascii_case(DBX_TDENGINE_TBNAME_COLUMN))
+                .cloned(),
+        );
+        if tdengine_columns.is_empty() {
+            return "*".to_string();
+        }
+        return tdengine_columns
+            .iter()
+            .map(|column| {
+                if is_tdengine_tbname(database_type, column) {
+                    DBX_TDENGINE_TBNAME_COLUMN.to_string()
+                } else {
+                    let ident = quote_table_identifier(database_type, column);
+                    format!("{ident} AS {ident}")
+                }
+            })
+            .collect::<Vec<_>>()
+            .join(", ");
+    }
+    if database_type != Some(DatabaseType::Hive) {
+        return "*".to_string();
+    }
+    columns
+        .iter()
+        .map(|column| {
+            let ident = quote_table_identifier(database_type, column);
+            format!("{ident} AS {ident}")
+        })
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+pub(super) fn build_sqlserver_table_select_sql(
+    table: &str,
+    where_clause: &str,
+    order_by: &str,
+    columns: &[String],
+    limit: usize,
+    offset: usize,
+) -> String {
+    let columns_sql = if columns.is_empty() {
+        "*".to_string()
+    } else {
+        columns
+            .iter()
+            .map(|column| quote_table_identifier(Some(DatabaseType::SqlServer), column))
+            .collect::<Vec<_>>()
+            .join(", ")
+    };
+    let order = if order_by == "(SELECT NULL)" { String::new() } else { format!(" ORDER BY {order_by}") };
+    if offset == 0 {
+        return format!("SELECT TOP ({limit}) {columns_sql} FROM {table}{where_clause}{order}");
+    }
+
+    let page_alias = quote_table_identifier(Some(DatabaseType::SqlServer), "dbx_page");
+    let row_number_alias = quote_table_identifier(Some(DatabaseType::SqlServer), "__dbx_row_num");
+    let end = offset + limit;
+    format!(
+        "WITH {page_alias} AS (SELECT {columns_sql}, ROW_NUMBER() OVER (ORDER BY {order_by}) AS {row_number_alias} FROM {table}{where_clause}) SELECT {columns_sql} FROM {page_alias} WHERE {row_number_alias} > {offset} AND {row_number_alias} <= {end} ORDER BY {row_number_alias}"
+    )
+}
+
+pub(super) fn build_db2_table_select_page_sql(
+    table: &str,
+    where_clause: &str,
+    order_by: Option<&str>,
+    columns: &[String],
+    limit: usize,
+    offset: usize,
+) -> String {
+    let columns_sql = if columns.is_empty() {
+        "*".to_string()
+    } else {
+        columns
+            .iter()
+            .map(|column| quote_table_identifier(Some(DatabaseType::Db2), column))
+            .collect::<Vec<_>>()
+            .join(", ")
+    };
+    let inner_columns = if columns.is_empty() {
+        "dbx_t.*".to_string()
+    } else {
+        columns
+            .iter()
+            .map(|column| format!("dbx_t.{}", quote_table_identifier(Some(DatabaseType::Db2), column)))
+            .collect::<Vec<_>>()
+            .join(", ")
+    };
+    let order = order_by.map(|order_by| format!("ORDER BY {order_by}")).unwrap_or_default();
+    let row_number = quote_table_identifier(Some(DatabaseType::Db2), "__dbx_row_num");
+    let end = offset + limit;
+
+    format!(
+        "SELECT {columns_sql} FROM (SELECT {inner_columns}, ROW_NUMBER() OVER ({order}) AS {row_number} FROM {table} dbx_t{where_clause}) dbx_page WHERE {row_number} > {offset} AND {row_number} <= {end} ORDER BY {row_number}"
+    )
+}
+
+pub(super) fn build_neo4j_table_select_sql(options: &TableDataSelectSqlOptions, limit: usize) -> String {
+    let label = quote_table_identifier(Some(DatabaseType::Neo4j), &options.table_name);
+    let predicate = normalize_where_input(options.where_input.as_deref());
+    let where_clause = if predicate.is_empty() { String::new() } else { format!(" WHERE {predicate}") };
+    let returned_columns = if options.columns.is_empty() {
+        "n".to_string()
+    } else {
+        options
+            .columns
+            .iter()
+            .map(|column| {
+                let ident = quote_table_identifier(Some(DatabaseType::Neo4j), column);
+                format!("n.{ident} AS {ident}")
+            })
+            .collect::<Vec<_>>()
+            .join(", ")
+    };
+    let returns = format!(
+        "elementId(n) AS {}, {returned_columns}",
+        quote_table_identifier(Some(DatabaseType::Neo4j), DBX_NEO4J_ELEMENT_ID_COLUMN)
+    );
+    let order_by = options.order_by.as_deref().filter(|order| !order.trim().is_empty());
+    let order = order_by.map(|order_by| format!(" ORDER BY {order_by}")).unwrap_or_default();
+    let skip = options.offset.filter(|offset| *offset > 0).map(|offset| format!(" SKIP {offset}")).unwrap_or_default();
+    format!("MATCH (n:{label}){where_clause} RETURN {returns}{order}{skip} LIMIT {limit};")
+}
+
+pub(super) fn build_questdb_table_select_sql(
+    table: &str,
+    where_clause: &str,
+    order_by: &str,
+    columns: &[String],
+    limit: usize,
+    offset: usize,
+) -> String {
+    let columns_sql = if columns.is_empty() {
+        "*".to_string()
+    } else {
+        columns
+            .iter()
+            .map(|column| quote_table_identifier(Some(DatabaseType::Questdb), column))
+            .collect::<Vec<_>>()
+            .join(", ")
+    };
+    if offset == 0 {
+        return format!("SELECT {columns_sql} FROM {table}{where_clause}{order_by} LIMIT {limit}");
+    }
+    let upper_bound = offset + limit;
+    format!("SELECT {columns_sql} FROM {table}{where_clause}{order_by} LIMIT {offset}, {upper_bound}")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn opts(database_type: DatabaseType, catalog: Option<&str>, table: &str) -> TableDataSelectSqlOptions {
+        TableDataSelectSqlOptions {
+            database_type: Some(database_type),
+            schema: None,
+            table_name: table.to_string(),
+            catalog: catalog.map(|c| c.to_string()),
+            table_type: None,
+            primary_keys: Vec::new(),
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(10),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+        }
+    }
+
+    #[test]
+    fn doris_external_catalog_prefixes_from_clause() {
+        let sql = build_table_data_select_sql(opts(DatabaseType::Doris, Some("iceberg_catalog"), "orders"));
+        assert!(sql.contains("FROM `iceberg_catalog`.`orders`"), "sql was: {sql}");
+    }
+
+    #[test]
+    fn starrocks_external_catalog_prefixes_from_clause() {
+        let sql = build_table_data_select_sql(opts(DatabaseType::StarRocks, Some("hive_catalog"), "orders"));
+        assert!(sql.contains("FROM `hive_catalog`.`orders`"), "sql was: {sql}");
+    }
+
+    #[test]
+    fn doris_internal_catalog_is_not_prefixed() {
+        let sql = build_table_data_select_sql(opts(DatabaseType::Doris, Some("internal"), "orders"));
+        assert!(!sql.contains("internal"), "sql was: {sql}");
+        assert!(sql.contains("FROM `orders`"), "sql was: {sql}");
+    }
+
+    #[test]
+    fn doris_empty_catalog_is_not_prefixed() {
+        let sql = build_table_data_select_sql(opts(DatabaseType::Doris, Some("   "), "orders"));
+        assert!(sql.contains("FROM `orders`"), "sql was: {sql}");
+    }
+
+    #[test]
+    fn doris_no_catalog_is_not_prefixed() {
+        let sql = build_table_data_select_sql(opts(DatabaseType::Doris, None, "orders"));
+        assert!(sql.contains("FROM `orders`"), "sql was: {sql}");
+    }
+
+    #[test]
+    fn external_catalog_is_ignored_for_non_doris_engines() {
+        // Postgres does not support the 3-part catalog naming; the catalog
+        // must be ignored to avoid emitting an invalid qualified name.
+        let sql = build_table_data_select_sql(opts(DatabaseType::Postgres, Some("iceberg_catalog"), "orders"));
+        assert!(!sql.contains("iceberg_catalog"), "sql was: {sql}");
+        assert!(sql.contains("orders"), "sql was: {sql}");
+    }
+}
diff --git a/crates/dbx-core/src/sql_dialect/tests.rs b/crates/dbx-core/src/sql_dialect/tests.rs
new file mode 100644
index 0000000..c25cc95
--- /dev/null
+++ b/crates/dbx-core/src/sql_dialect/tests.rs
@@ -0,0 +1,786 @@
+use super::*;
+use crate::models::connection::DatabaseType;
+
+#[test]
+fn transfer_identifier_policy_preserves_legacy_output() {
+    assert_eq!(quote_transfer_identifier("user`events", &DatabaseType::Hive), "`user``events`");
+    assert_eq!(quote_transfer_identifier("user`events", &DatabaseType::ClickHouse), "`user``events`");
+    assert_eq!(quote_transfer_identifier("user`events", &DatabaseType::Doris), "`user``events`");
+    assert_eq!(quote_transfer_identifier("user]events", &DatabaseType::SqlServer), "[user]]events]");
+    assert_eq!(quote_transfer_identifier("user\"events", &DatabaseType::Postgres), "\"user\"\"events\"");
+    assert_eq!(qualified_transfer_table("events", "warehouse", &DatabaseType::Hive), "`warehouse`.`events`");
+    assert_eq!(qualified_transfer_table("events", "warehouse", &DatabaseType::Mysql), "`events`");
+}
+
+#[test]
+fn quotes_identifiers_by_database_type() {
+    assert_eq!(quote_table_identifier(Some(DatabaseType::Mysql), "user`name"), "`user``name`");
+    assert_eq!(quote_table_identifier(Some(DatabaseType::ClickHouse), "user`name"), "`user``name`");
+    assert_eq!(quote_table_identifier(Some(DatabaseType::Doris), "user`name"), "`user``name`");
+    assert_eq!(quote_table_identifier(Some(DatabaseType::Goldendb), "user`name"), "`user``name`");
+    assert_eq!(quote_table_identifier(Some(DatabaseType::StarRocks), "user`name"), "`user``name`");
+    assert_eq!(quote_table_identifier(Some(DatabaseType::SqlServer), "user]name"), "[user]]name]");
+    assert_eq!(quote_table_identifier(Some(DatabaseType::Postgres), "user\"name"), "\"user\"\"name\"");
+    assert_eq!(quote_table_identifier(Some(DatabaseType::Informix), "users_1"), "users_1");
+    assert_eq!(quote_table_identifier(Some(DatabaseType::Jdbc), "users_1"), "users_1");
+    assert_eq!(quote_table_identifier(Some(DatabaseType::Jdbc), "user name"), "user name");
+    assert_eq!(quote_table_identifier(Some(DatabaseType::Iotdb), "root.test.device2"), "root.test.device2");
+}
+
+#[test]
+fn qualifies_schema_only_for_schema_aware_databases() {
+    assert_eq!(qualified_table_name(Some(DatabaseType::Postgres), Some("public"), "users"), "\"public\".\"users\"");
+    assert_eq!(qualified_table_name(Some(DatabaseType::Kwdb), Some("public"), "users"), "\"public\".\"users\"");
+    assert_eq!(qualified_table_name(Some(DatabaseType::Mysql), Some("public"), "users"), "`public`.`users`");
+    assert_eq!(qualified_table_name(Some(DatabaseType::Goldendb), Some("public"), "users"), "`public`.`users`");
+    assert_eq!(qualified_table_name(Some(DatabaseType::StarRocks), Some("warehouse"), "users"), "`warehouse`.`users`");
+    assert_eq!(qualified_table_name(Some(DatabaseType::Doris), Some("warehouse"), "users"), "`warehouse`.`users`");
+    assert_eq!(qualified_table_name(Some(DatabaseType::Databend), Some("dbx_test"), "users"), "`dbx_test`.`users`");
+    assert_eq!(
+        qualified_table_name(Some(DatabaseType::Xugu), Some("DBX_TEST"), "PRODUCTS"),
+        "\"DBX_TEST\".\"PRODUCTS\""
+    );
+    assert_eq!(qualified_table_name(Some(DatabaseType::Oscar), Some("SYSDBA"), "EMPLOYEE"), "\"SYSDBA\".\"EMPLOYEE\"");
+    assert_eq!(qualified_table_name(Some(DatabaseType::Jdbc), Some("cbsdw_dwd"), "dwd_test_df"), "dwd_test_df");
+    assert_eq!(qualified_table_name(Some(DatabaseType::Iotdb), Some("root.test"), "device2"), "root.test.device2");
+    assert_eq!(
+        qualified_table_name(Some(DatabaseType::Iotdb), Some("root.test"), "root.test.device2"),
+        "root.test.device2"
+    );
+    assert_eq!(
+        qualified_table_name(
+            Some(DatabaseType::SqlServer),
+            Some("__dbx_sqlserver_linked__:ERP%5D01|Finance%20DB|dbo"),
+            "Orders]2026"
+        ),
+        "[ERP]]01].[Finance DB].[dbo].[Orders]]2026]"
+    );
+}
+
+#[test]
+fn maps_table_pagination_strategy_by_database_type() {
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::Mysql)), TablePaginationStrategy::LimitOffset);
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::Dameng)), TablePaginationStrategy::FetchFirst);
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::Db2)), TablePaginationStrategy::Db2FetchFirst);
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::SqlServer)), TablePaginationStrategy::SqlServerTop);
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::Iris)), TablePaginationStrategy::IrisTop);
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::Informix)), TablePaginationStrategy::InformixFirst);
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::Firebird)), TablePaginationStrategy::FirebirdRows);
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::OceanbaseOracle)), TablePaginationStrategy::Rownum);
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::Questdb)), TablePaginationStrategy::QuestDbLimit);
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::Oracle)), TablePaginationStrategy::Rownum);
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::Oscar)), TablePaginationStrategy::Rownum);
+    assert_eq!(
+        pagination_strategy(Some(DatabaseType::Oracle), PaginationContext::BoundedRead),
+        TablePaginationStrategy::FetchFirst
+    );
+    assert_eq!(
+        pagination_strategy(Some(DatabaseType::Oscar), PaginationContext::BoundedRead),
+        TablePaginationStrategy::Rownum
+    );
+    assert_eq!(
+        pagination_strategy(Some(DatabaseType::Oscar), PaginationContext::UserQuery),
+        TablePaginationStrategy::Unbounded
+    );
+    assert_eq!(
+        pagination_strategy(Some(DatabaseType::Oracle), PaginationContext::UserQuery),
+        TablePaginationStrategy::Unbounded
+    );
+    assert_eq!(table_pagination_strategy(Some(DatabaseType::Jdbc)), TablePaginationStrategy::AgentMaxRows);
+    assert_eq!(table_pagination_strategy(None), TablePaginationStrategy::LimitOffset);
+}
+
+#[test]
+fn builds_select_sql_with_limit_syntax_for_database_type() {
+    let columns = vec!["id".to_string(), "name".to_string()];
+    let keys = vec!["id".to_string()];
+
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::Postgres),
+            schema: Some("public"),
+            table_name: "users",
+            columns: &columns,
+            order_columns: &keys,
+            limit: 100,
+        }),
+        "SELECT \"id\", \"name\" FROM \"public\".\"users\" ORDER BY \"id\" ASC LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::SqlServer),
+            schema: Some("dbo"),
+            table_name: "users",
+            columns: &columns,
+            order_columns: &keys,
+            limit: 100,
+        }),
+        "SELECT TOP (100) [id], [name] FROM [dbo].[users] ORDER BY [id] ASC"
+    );
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::Db2),
+            schema: Some("DB2INST1"),
+            table_name: "USERS",
+            columns: &columns,
+            order_columns: &keys,
+            limit: 100,
+        }),
+        "SELECT \"id\", \"name\" FROM \"DB2INST1\".\"USERS\" ORDER BY \"id\" ASC FETCH FIRST 100 ROWS ONLY"
+    );
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::Firebird),
+            schema: None,
+            table_name: "USERS",
+            columns: &columns,
+            order_columns: &keys,
+            limit: 100,
+        }),
+        "SELECT \"id\", \"name\" FROM \"USERS\" ORDER BY \"id\" ASC ROWS 100"
+    );
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::Oracle),
+            schema: Some("DBXTEST"),
+            table_name: "USERS",
+            columns: &columns,
+            order_columns: &keys,
+            limit: 100,
+        }),
+        "SELECT \"id\", \"name\" FROM (SELECT \"id\", \"name\" FROM \"DBXTEST\".\"USERS\" ORDER BY \"id\" ASC) WHERE ROWNUM <= 100"
+    );
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::OceanbaseOracle),
+            schema: Some("DBXTEST"),
+            table_name: "USERS",
+            columns: &columns,
+            order_columns: &keys,
+            limit: 100,
+        }),
+        "SELECT \"id\", \"name\" FROM (SELECT \"id\", \"name\" FROM \"DBXTEST\".\"USERS\" ORDER BY \"id\" ASC) WHERE ROWNUM <= 100"
+    );
+    // JDBC connections skip SQL-level row limiting — the JDBC agent handles
+    // it via Statement.setMaxRows() which is universally supported.
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::Jdbc),
+            schema: Some("cbsdw_dwd"),
+            table_name: "dwd_test_df",
+            columns: &[],
+            order_columns: &[],
+            limit: 100,
+        }),
+        "SELECT * FROM dwd_test_df;"
+    );
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::Databend),
+            schema: Some("dbx_test"),
+            table_name: "jdbc_probe",
+            columns: &[],
+            order_columns: &[],
+            limit: 500,
+        }),
+        "SELECT * FROM `dbx_test`.`jdbc_probe` LIMIT 500;"
+    );
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::Xugu),
+            schema: Some("DBX_TEST"),
+            table_name: "PRODUCTS",
+            columns: &[],
+            order_columns: &[],
+            limit: 100,
+        }),
+        "SELECT * FROM \"DBX_TEST\".\"PRODUCTS\" LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::Hive),
+            schema: Some("test"),
+            table_name: "dws_event_analyse",
+            columns: &[],
+            order_columns: &[],
+            limit: 100,
+        }),
+        "SELECT * FROM `test`.`dws_event_analyse` LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::StarRocks),
+            schema: None,
+            table_name: "sales_report",
+            columns: &["customer_name".to_string()],
+            order_columns: &[],
+            limit: 100,
+        }),
+        "SELECT `customer_name` FROM `sales_report` LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::Iris),
+            schema: Some("Ens"),
+            table_name: "AlarmResponse",
+            columns: &[],
+            order_columns: &[],
+            limit: 100,
+        }),
+        "SELECT TOP 100 * FROM \"Ens\".\"AlarmResponse\""
+    );
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::Iotdb),
+            schema: Some("root.test"),
+            table_name: "device2",
+            columns: &[],
+            order_columns: &[],
+            limit: 100,
+        }),
+        "SELECT * FROM root.test.device2 LIMIT 100;"
+    );
+}
+
+#[test]
+fn builds_table_data_where_and_schema_queries() {
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Mysql),
+            schema: None,
+            table_name: "users".to_string(),
+            table_type: None,
+            primary_keys: vec!["id".to_string()],
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: Some("where status = 'active'".to_string()),
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT * FROM `users` WHERE (status = 'active') LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Goldendb),
+            schema: None,
+            table_name: "sys_dic".to_string(),
+            table_type: None,
+            primary_keys: Vec::new(),
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT * FROM `sys_dic` LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Postgres),
+            schema: Some("public".to_string()),
+            table_name: "orders".to_string(),
+            table_type: None,
+            primary_keys: Vec::new(),
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(50),
+            offset: Some(100),
+            where_input: Some("WHERE amount > 10".to_string()),
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT * FROM \"public\".\"orders\" WHERE (amount > 10) LIMIT 50 OFFSET 100;"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Xugu),
+            schema: Some("DBX_TEST".to_string()),
+            table_name: "PRODUCTS".to_string(),
+            table_type: None,
+            primary_keys: Vec::new(),
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT * FROM \"DBX_TEST\".\"PRODUCTS\" LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::StarRocks),
+            schema: None,
+            table_name: "sales_report".to_string(),
+            table_type: None,
+            primary_keys: Vec::new(),
+            columns: vec!["customer_name".to_string(), "amount".to_string()],
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: Some("`customer_name` = 'Acme'".to_string()),
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT * FROM `sales_report` WHERE (`customer_name` = 'Acme') LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Db2),
+            schema: Some("DB2INST1".to_string()),
+            table_name: "ORDERS".to_string(),
+            table_type: None,
+            primary_keys: Vec::new(),
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(50),
+            offset: None,
+            where_input: Some("WHERE amount > 10".to_string()),
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT * FROM \"DB2INST1\".\"ORDERS\" WHERE (amount > 10) FETCH FIRST 50 ROWS ONLY"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Firebird),
+            schema: None,
+            table_name: "ORDERS".to_string(),
+            table_type: None,
+            primary_keys: vec!["ID".to_string()],
+            columns: vec!["ID".to_string(), "AMOUNT".to_string()],
+            fallback_order_columns: Vec::new(),
+            order_by: Some("\"ID\" ASC".to_string()),
+            limit: Some(50),
+            offset: Some(100),
+            where_input: Some("WHERE amount > 10".to_string()),
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT * FROM \"ORDERS\" WHERE (amount > 10) ORDER BY \"ID\" ASC ROWS 101 TO 150"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Oracle),
+            schema: Some("DBXTEST".to_string()),
+            table_name: "ORDERS".to_string(),
+            table_type: None,
+            primary_keys: vec!["ID".to_string()],
+            columns: vec!["ID".to_string(), "AMOUNT".to_string()],
+            fallback_order_columns: Vec::new(),
+            order_by: Some("\"ID\" ASC".to_string()),
+            limit: Some(50),
+            offset: Some(100),
+            where_input: Some("WHERE amount > 10".to_string()),
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT \"ID\", \"AMOUNT\" FROM (SELECT dbx_inner.*, ROWNUM AS \"__dbx_row_num\" FROM (SELECT \"ID\", \"AMOUNT\" FROM \"DBXTEST\".\"ORDERS\" WHERE (amount > 10) ORDER BY \"ID\" ASC) dbx_inner WHERE ROWNUM <= 150) WHERE \"__dbx_row_num\" > 100"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::OceanbaseOracle),
+            schema: Some("DBXTEST".to_string()),
+            table_name: "ORDERS".to_string(),
+            table_type: None,
+            primary_keys: Vec::new(),
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT * FROM (SELECT * FROM \"DBXTEST\".\"ORDERS\") WHERE ROWNUM <= 100"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::OceanbaseOracle),
+            schema: Some("DBXTEST".to_string()),
+            table_name: "ORDERS".to_string(),
+            table_type: None,
+            primary_keys: vec!["ID".to_string()],
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(50),
+            offset: None,
+            where_input: Some("WHERE amount > 10".to_string()),
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT * FROM (SELECT * FROM \"DBXTEST\".\"ORDERS\" WHERE (amount > 10)) WHERE ROWNUM <= 50"
+    );
+    assert_eq!(
+            build_table_data_select_sql(TableDataSelectSqlOptions {
+                database_type: Some(DatabaseType::Db2),
+                schema: Some("DB2INST1".to_string()),
+                table_name: "ORDERS".to_string(),
+                table_type: None,
+                primary_keys: vec!["ID".to_string()],
+                columns: vec!["ID".to_string(), "AMOUNT".to_string()],
+                fallback_order_columns: Vec::new(),
+                order_by: None,
+                limit: Some(50),
+                offset: Some(100),
+                where_input: Some("WHERE amount > 10".to_string()),
+                include_row_id: false,
+                ..Default::default()
+            }),
+            "SELECT \"ID\", \"AMOUNT\" FROM (SELECT dbx_t.\"ID\", dbx_t.\"AMOUNT\", ROW_NUMBER() OVER () AS \"__dbx_row_num\" FROM \"DB2INST1\".\"ORDERS\" dbx_t WHERE (amount > 10)) dbx_page WHERE \"__dbx_row_num\" > 100 AND \"__dbx_row_num\" <= 150 ORDER BY \"__dbx_row_num\""
+        );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Iris),
+            schema: Some("Ens".to_string()),
+            table_name: "AlarmResponse".to_string(),
+            table_type: None,
+            primary_keys: Vec::new(),
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT TOP 100 * FROM \"Ens\".\"AlarmResponse\""
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Iotdb),
+            schema: Some("root.test".to_string()),
+            table_name: "device2".to_string(),
+            table_type: None,
+            primary_keys: Vec::new(),
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT * FROM root.test.device2 LIMIT 100;"
+    );
+}
+
+#[test]
+fn builds_informix_table_data_with_skip_first_pagination() {
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Informix),
+            schema: Some("ignored".to_string()),
+            table_name: "users".to_string(),
+            table_type: None,
+            primary_keys: vec!["id".to_string()],
+            columns: vec!["id".to_string(), "name".to_string()],
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(50),
+            offset: Some(100),
+            where_input: Some("WHERE active = 1".to_string()),
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT SKIP 100 FIRST 50 * FROM users WHERE (active = 1)"
+    );
+
+    assert_eq!(
+        build_table_select_sql(TableSelectSqlOptions {
+            database_type: Some(DatabaseType::Informix),
+            schema: None,
+            table_name: "systables",
+            columns: &["tabname".to_string()],
+            order_columns: &[],
+            limit: 1,
+        }),
+        "SELECT FIRST 1 tabname FROM systables"
+    );
+}
+
+#[test]
+fn explicit_table_data_order_is_preserved() {
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Postgres),
+            schema: Some("public".to_string()),
+            table_name: "country_gdp".to_string(),
+            table_type: None,
+            primary_keys: vec!["year".to_string()],
+            columns: vec!["iso3".to_string(), "year".to_string(), "gdp_pc".to_string()],
+            fallback_order_columns: Vec::new(),
+            order_by: Some("\"iso3\" ASC".to_string()),
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT * FROM \"public\".\"country_gdp\" ORDER BY \"iso3\" ASC LIMIT 100;"
+    );
+}
+
+#[test]
+fn builds_iris_table_data_sql_with_literal_top_and_quoted_object() {
+    let sql = build_table_data_select_sql(TableDataSelectSqlOptions {
+        database_type: Some(DatabaseType::Iris),
+        schema: Some("Ens".to_string()),
+        table_name: "AlarmResponse".to_string(),
+        table_type: None,
+        primary_keys: vec!["ID".to_string()],
+        columns: vec!["ID".to_string(), "Status".to_string()],
+        fallback_order_columns: Vec::new(),
+        order_by: Some("\"Status\" DESC".to_string()),
+        limit: Some(25),
+        offset: None,
+        where_input: Some("WHERE \"Status\" = 'Open'".to_string()),
+        include_row_id: false,
+        ..Default::default()
+    });
+
+    assert_eq!(
+        sql,
+        "SELECT TOP 25 * FROM \"Ens\".\"AlarmResponse\" WHERE (\"Status\" = 'Open') ORDER BY \"Status\" DESC"
+    );
+    assert!(!sql.contains("?"));
+    assert!(!sql.contains(":%qpar"));
+    assert!(!sql.contains(" LIMIT "));
+}
+
+#[test]
+fn builds_table_data_special_column_queries() {
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            schema: Some("test_db".to_string()),
+            table_name: "meters".to_string(),
+            table_type: Some("STABLE".to_string()),
+            primary_keys: Vec::new(),
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT tbname, * FROM `test_db`.`meters` LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            schema: Some("test_db".to_string()),
+            table_name: "meters".to_string(),
+            table_type: Some("STABLE".to_string()),
+            primary_keys: vec!["ts".to_string()],
+            columns: vec![
+                "ts".to_string(),
+                "current".to_string(),
+                "voltage".to_string(),
+                "location".to_string(),
+                "groupid".to_string(),
+            ],
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT tbname, `ts` AS `ts`, `current` AS `current`, `voltage` AS `voltage`, `location` AS `location`, `groupid` AS `groupid` FROM `test_db`.`meters` LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            schema: Some("test_db".to_string()),
+            table_name: "d1001".to_string(),
+            table_type: Some("TABLE".to_string()),
+            primary_keys: vec!["ts".to_string()],
+            columns: vec!["ts".to_string(), "current".to_string()],
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT `ts` AS `ts`, `current` AS `current` FROM `test_db`.`d1001` LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Tdengine),
+            schema: Some("test_db".to_string()),
+            table_name: "d1001".to_string(),
+            table_type: Some("TABLE".to_string()),
+            primary_keys: vec!["ts".to_string()],
+            columns: vec!["tbname".to_string(), "ts".to_string(), "current".to_string()],
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT `ts` AS `ts`, `current` AS `current` FROM `test_db`.`d1001` LIMIT 100;"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Hive),
+            schema: None,
+            table_name: "departments".to_string(),
+            table_type: None,
+            primary_keys: Vec::new(),
+            columns: vec!["id".to_string(), "name".to_string()],
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT `id` AS `id`, `name` AS `name` FROM `departments` LIMIT 100;"
+    );
+}
+
+#[test]
+fn builds_sqlserver_table_data_pages() {
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::SqlServer),
+            schema: Some("dbo".to_string()),
+            table_name: "accounts".to_string(),
+            table_type: None,
+            primary_keys: vec!["id".to_string()],
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(25),
+            offset: None,
+            where_input: Some("where id = 1".to_string()),
+            include_row_id: false,
+            ..Default::default()
+        }),
+        "SELECT TOP (25) * FROM [dbo].[accounts] WHERE (id = 1)"
+    );
+    assert_eq!(
+            build_table_data_select_sql(TableDataSelectSqlOptions {
+                database_type: Some(DatabaseType::SqlServer),
+                schema: Some("sales".to_string()),
+                table_name: "orders".to_string(),
+                table_type: None,
+                primary_keys: vec!["order_id".to_string()],
+                columns: vec!["order_id".to_string(), "customer".to_string()],
+                fallback_order_columns: Vec::new(),
+                order_by: None,
+                limit: Some(50),
+                offset: Some(100),
+                where_input: None,
+                include_row_id: false,
+                ..Default::default()
+            }),
+            "WITH [dbx_page] AS (SELECT [order_id], [customer], ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) AS [__dbx_row_num] FROM [sales].[orders]) SELECT [order_id], [customer] FROM [dbx_page] WHERE [__dbx_row_num] > 100 AND [__dbx_row_num] <= 150 ORDER BY [__dbx_row_num]"
+        );
+}
+
+#[test]
+fn builds_oracle_and_neo4j_table_data_queries() {
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Oracle),
+            schema: Some("DBXTEST".to_string()),
+            table_name: "DBX_LOAD_TABLE_006".to_string(),
+            table_type: None,
+            primary_keys: vec![DBX_ROWID_COLUMN.to_string()],
+            columns: Vec::new(),
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: true,
+            ..Default::default()
+        }),
+        "SELECT * FROM (SELECT ROWIDTOCHAR(t.ROWID) AS \"__DBX_ROWID\", t.* FROM \"DBXTEST\".\"DBX_LOAD_TABLE_006\" t) WHERE ROWNUM <= 100"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Oracle),
+            schema: Some("DBXTEST".to_string()),
+            table_name: "DBX_LOAD_TABLE_006".to_string(),
+            table_type: None,
+            primary_keys: vec![DBX_ROWID_COLUMN.to_string()],
+            columns: vec!["ID".to_string(), "NAME".to_string()],
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: true,
+            ..Default::default()
+        }),
+        "SELECT \"__DBX_ROWID\", \"ID\", \"NAME\" FROM (SELECT ROWIDTOCHAR(t.ROWID) AS \"__DBX_ROWID\", t.* FROM \"DBXTEST\".\"DBX_LOAD_TABLE_006\" t) WHERE ROWNUM <= 100"
+    );
+    assert_eq!(
+        build_table_data_select_sql(TableDataSelectSqlOptions {
+            database_type: Some(DatabaseType::Oracle),
+            schema: Some("DBXTEST".to_string()),
+            table_name: "DBX_JOIN_VIEW".to_string(),
+            table_type: Some("VIEW".to_string()),
+            primary_keys: vec![DBX_ROWID_COLUMN.to_string()],
+            columns: vec!["ID".to_string(), "NAME".to_string()],
+            fallback_order_columns: Vec::new(),
+            order_by: None,
+            limit: Some(100),
+            offset: None,
+            where_input: None,
+            include_row_id: true,
+            ..Default::default()
+        }),
+        "SELECT \"ID\", \"NAME\" FROM (SELECT \"ID\", \"NAME\" FROM \"DBXTEST\".\"DBX_JOIN_VIEW\") WHERE ROWNUM <= 100"
+    );
+    assert_eq!(
+            build_table_data_select_sql(TableDataSelectSqlOptions {
+                database_type: Some(DatabaseType::Neo4j),
+                schema: None,
+                table_name: "Employee".to_string(),
+                table_type: None,
+                primary_keys: vec!["id".to_string()],
+                columns: vec!["id".to_string(), "first name".to_string(), "role".to_string()],
+                fallback_order_columns: Vec::new(),
+                order_by: None,
+                limit: Some(100),
+                offset: None,
+                where_input: None,
+                include_row_id: false,
+                ..Default::default()
+            }),
+            "MATCH (n:`Employee`) RETURN elementId(n) AS `__DBX_ELEMENT_ID`, n.`id` AS `id`, n.`first name` AS `first name`, n.`role` AS `role` LIMIT 100;"
+        );
+}
+
+#[test]
+fn normalizes_where_input_with_multibyte_identifier_prefix() {
+    assert_eq!(normalize_where_input(Some("`客户名称` = '示例客户'")), "`客户名称` = '示例客户'");
+    assert_eq!(normalize_where_input(Some("WHERE `客户名称` = '示例客户';")), "`客户名称` = '示例客户'");
+}
diff --git a/crates/dbx-core/src/sql_dialect/types.rs b/crates/dbx-core/src/sql_dialect/types.rs
new file mode 100644
index 0000000..2f3b523
--- /dev/null
+++ b/crates/dbx-core/src/sql_dialect/types.rs
@@ -0,0 +1,50 @@
+use serde::{Deserialize, Serialize};
+
+use crate::models::connection::DatabaseType;
+
+pub const DBX_ROWID_COLUMN: &str = "__DBX_ROWID";
+pub const DBX_NEO4J_ELEMENT_ID_COLUMN: &str = "__DBX_ELEMENT_ID";
+pub const DBX_TDENGINE_TBNAME_COLUMN: &str = "tbname";
+
+#[derive(Debug, Clone, Copy)]
+pub struct TableSelectSqlOptions<'a> {
+    pub database_type: Option<DatabaseType>,
+    pub schema: Option<&'a str>,
+    pub table_name: &'a str,
+    pub columns: &'a [String],
+    pub order_columns: &'a [String],
+    pub limit: usize,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableDataSelectSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub table_name: String,
+    /// Doris / StarRocks multi-catalog: when set to a non-`internal` catalog,
+    /// the FROM clause is prefixed with the catalog
+    /// (`<catalog>.<schema>.<table>`).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub catalog: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table_type: Option<String>,
+    #[serde(default)]
+    pub primary_keys: Vec<String>,
+    #[serde(default)]
+    pub columns: Vec<String>,
+    #[serde(default)]
+    pub fallback_order_columns: Vec<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub order_by: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub limit: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub offset: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub where_input: Option<String>,
+    #[serde(default)]
+    pub include_row_id: bool,
+}
diff --git a/crates/dbx-core/src/sql_editability.rs b/crates/dbx-core/src/sql_editability.rs
new file mode 100644
index 0000000..b984bf5
--- /dev/null
+++ b/crates/dbx-core/src/sql_editability.rs
@@ -0,0 +1,1056 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditableQueryInfo {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub catalog: Option<String>,
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub catalog_quoted: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub schema_quoted: bool,
+    pub table_name: String,
+    pub table_name_quoted: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub table_alias: Option<String>,
+    pub select_star: bool,
+    pub columns: Vec<EditableQueryColumn>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub sources: Option<Vec<EditableQuerySource>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub editable_source_key: Option<String>,
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub multi_source: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub allow_insert_delete: Option<bool>,
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub distinct: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditableQueryColumn {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source_name: Option<String>,
+    pub source_name_quoted: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source_qualifier: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source_key: Option<String>,
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub star: bool,
+    pub result_name: String,
+    pub expression: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditableQuerySource {
+    pub key: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub catalog: Option<String>,
+    #[serde(default, skip_serializing_if = "is_false")]
+    pub catalog_quoted: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub schema_quoted: bool,
+    pub table_name: String,
+    pub table_name_quoted: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub alias: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum QueryEditabilityReason {
+    NotSelect,
+    Cte,
+    SetOperation,
+    Aggregation,
+    ExternalSource,
+    ComplexSource,
+    ComputedColumns,
+    NoTable,
+    NoPrimaryKey,
+    PrimaryKeyNotReturned,
+    AliasedColumns,
+    MetadataUnavailable,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryEditability {
+    pub editable: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub analysis: Option<EditableQueryInfo>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reason: Option<QueryEditabilityReason>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct FromSource {
+    key: String,
+    catalog: Option<String>,
+    catalog_quoted: bool,
+    schema: Option<String>,
+    schema_quoted: bool,
+    table_name: String,
+    table_name_quoted: bool,
+    alias: Option<String>,
+}
+
+fn is_false(value: &bool) -> bool {
+    !*value
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct QualifiedIdentifier {
+    parts: Vec<Identifier>,
+    end: usize,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct Identifier {
+    value: String,
+    quoted: bool,
+    end: usize,
+}
+
+pub fn analyze_editable_query(sql: &str) -> Option<EditableQueryInfo> {
+    let result = analyze_editable_query_editability(sql);
+    if result.editable {
+        result.analysis
+    } else {
+        None
+    }
+}
+
+pub fn analyze_editable_query_editability(sql: &str) -> QueryEditability {
+    let normalized = strip_sql_comments(sql).trim_end_matches(';').trim().to_string();
+    if normalized.is_empty() {
+        return not_editable(QueryEditabilityReason::NotSelect);
+    }
+    if starts_with_keyword(&normalized, "WITH") {
+        return not_editable(QueryEditabilityReason::Cte);
+    }
+    if !starts_with_keyword(&normalized, "SELECT") {
+        return not_editable(QueryEditabilityReason::NotSelect);
+    }
+    if has_top_level_keyword(&normalized, &["UNION", "INTERSECT", "EXCEPT"]) {
+        return not_editable(QueryEditabilityReason::SetOperation);
+    }
+    if normalized.contains(';') {
+        return not_editable(QueryEditabilityReason::ComplexSource);
+    }
+
+    let Some(from_index) = find_top_level_keyword(&normalized, "FROM", 0) else {
+        return not_editable(QueryEditabilityReason::NoTable);
+    };
+
+    let raw_select_body = normalized["SELECT".len()..from_index].trim();
+    let (select_body, distinct) = if starts_with_keyword(raw_select_body, "DISTINCT") {
+        let body = raw_select_body["DISTINCT".len()..].trim_start();
+        // DISTINCT ON has database-specific row-selection semantics and cannot be
+        // treated as a plain projection whose rows map directly to base records.
+        if starts_with_keyword(body, "ON") {
+            return not_editable(QueryEditabilityReason::Aggregation);
+        }
+        (body, true)
+    } else {
+        (raw_select_body, false)
+    };
+    let select_body = strip_sql_server_top_clause(select_body);
+
+    let group_index = find_top_level_keyword(&normalized, "GROUP", from_index + "FROM".len());
+    let having_index = find_top_level_keyword(&normalized, "HAVING", from_index + "FROM".len());
+    if group_index.is_some() || having_index.is_some() {
+        return not_editable(QueryEditabilityReason::Aggregation);
+    }
+
+    let from_body_start = from_index + "FROM".len();
+    let from_end =
+        first_top_level_keyword_index(&normalized, &["WHERE", "ORDER", "LIMIT", "OFFSET", "FETCH"], from_body_start)
+            .unwrap_or(normalized.len());
+    let from_body = normalized[from_body_start..from_end].trim();
+    if is_external_from_source(from_body) {
+        return not_editable(QueryEditabilityReason::ExternalSource);
+    }
+    let sources = parse_from_sources(from_body);
+    if sources.is_empty() {
+        return not_editable(QueryEditabilityReason::ComplexSource);
+    }
+    let source = sources[0].clone();
+
+    let select_star = sources.len() == 1 && is_select_star(select_body, source.alias.as_deref());
+    let columns = if select_star { Vec::new() } else { parse_select_columns(select_body, &sources) };
+    if !select_star && columns.is_empty() {
+        return not_editable(QueryEditabilityReason::ComputedColumns);
+    }
+    if sources.len() > 1 && columns.iter().any(|column| column.star && column.source_key.is_none()) {
+        return not_editable(QueryEditabilityReason::ComplexSource);
+    }
+
+    let mut analysis = EditableQueryInfo {
+        catalog: source.catalog,
+        catalog_quoted: source.catalog_quoted,
+        schema: source.schema,
+        schema_quoted: source.schema_quoted,
+        table_name: source.table_name,
+        table_name_quoted: source.table_name_quoted,
+        table_alias: source.alias,
+        select_star,
+        columns,
+        sources: None,
+        editable_source_key: None,
+        multi_source: false,
+        // Updating an identified base row is safe, but insert/delete semantics are
+        // ambiguous when the displayed set is de-duplicated by the query.
+        allow_insert_delete: distinct.then_some(false),
+        distinct,
+    };
+    if sources.len() > 1 {
+        analysis.sources = Some(sources.into_iter().map(EditableQuerySource::from).collect());
+        analysis.multi_source = true;
+        analysis.allow_insert_delete = Some(false);
+    }
+
+    QueryEditability { editable: true, analysis: Some(analysis), reason: None }
+}
+
+fn not_editable(reason: QueryEditabilityReason) -> QueryEditability {
+    QueryEditability { editable: false, analysis: None, reason: Some(reason) }
+}
+
+fn parse_select_columns(body: &str, sources: &[FromSource]) -> Vec<EditableQueryColumn> {
+    let mut columns = Vec::new();
+    let mut depth = 0i32;
+    let mut current = String::new();
+    let mut quote: Option<char> = None;
+
+    for ch in body.chars() {
+        if let Some(close) = quote {
+            current.push(ch);
+            if ch == close {
+                quote = None;
+            }
+            continue;
+        }
+
+        match ch {
+            '\'' | '"' | '`' => quote = Some(ch),
+            '[' => quote = Some(']'),
+            '(' => depth += 1,
+            ')' => depth -= 1,
+            ',' if depth == 0 => {
+                let Some(column) = parse_select_column(current.trim(), sources) else {
+                    return Vec::new();
+                };
+                columns.push(column);
+                current.clear();
+                continue;
+            }
+            _ => {}
+        }
+        current.push(ch);
+    }
+
+    if !current.trim().is_empty() {
+        let Some(column) = parse_select_column(current.trim(), sources) else {
+            return Vec::new();
+        };
+        columns.push(column);
+    }
+
+    columns
+}
+
+fn parse_select_column(column: &str, sources: &[FromSource]) -> Option<EditableQueryColumn> {
+    if let Some(star) = parse_star_select_column(column, sources) {
+        return Some(star);
+    }
+    let Some(source) = parse_qualified_identifier(column) else {
+        return parse_computed_select_column(column);
+    };
+    let rest = &column[source.end..];
+    let Some(alias) = parse_column_alias(rest) else {
+        return parse_computed_select_column(column);
+    };
+    let source_name_part = source.parts.last()?;
+    let source_name = source_name_part.value.clone();
+    let qualifier = if source.parts.len() >= 2 {
+        source.parts.get(source.parts.len() - 2).map(|part| part.value.clone())
+    } else {
+        None
+    };
+    let source_key = qualifier.as_deref().and_then(|qualifier| source_key_for_qualifier(sources, qualifier));
+    Some(EditableQueryColumn {
+        source_name: Some(source_name.clone()),
+        source_name_quoted: source_name_part.quoted,
+        source_qualifier: qualifier,
+        source_key,
+        star: false,
+        result_name: alias.unwrap_or(source_name),
+        expression: column[..source.end].trim().to_string(),
+    })
+}
+
+fn parse_star_select_column(column: &str, sources: &[FromSource]) -> Option<EditableQueryColumn> {
+    let trimmed = column.trim();
+    if trimmed == "*" {
+        return Some(EditableQueryColumn {
+            source_name: None,
+            source_name_quoted: false,
+            source_qualifier: None,
+            source_key: None,
+            star: true,
+            result_name: "*".to_string(),
+            expression: trimmed.to_string(),
+        });
+    }
+    let qualifier = read_identifier(trimmed, 0)?;
+    let mut pos = skip_whitespace(trimmed, qualifier.end);
+    if !trimmed[pos..].starts_with('.') {
+        return None;
+    }
+    pos = skip_whitespace(trimmed, pos + 1);
+    if trimmed[pos..].trim() != "*" {
+        return None;
+    }
+    let source_key = source_key_for_qualifier(sources, &qualifier.value);
+    Some(EditableQueryColumn {
+        source_name: None,
+        source_name_quoted: false,
+        source_qualifier: Some(qualifier.value),
+        source_key,
+        star: true,
+        result_name: "*".to_string(),
+        expression: trimmed.to_string(),
+    })
+}
+
+fn parse_computed_select_column(column: &str) -> Option<EditableQueryColumn> {
+    let alias = parse_expression_alias(column)?;
+    Some(EditableQueryColumn {
+        source_name: None,
+        source_name_quoted: false,
+        source_qualifier: None,
+        source_key: None,
+        star: false,
+        result_name: alias.result_name,
+        expression: alias.expression,
+    })
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct ExpressionAlias {
+    expression: String,
+    result_name: String,
+}
+
+fn parse_expression_alias(column: &str) -> Option<ExpressionAlias> {
+    let trimmed_end = column.trim_end();
+    for (index, _) in trimmed_end.match_indices(['A', 'a']) {
+        let candidate = &trimmed_end[index..];
+        if !candidate.get(..2).is_some_and(|prefix| prefix.eq_ignore_ascii_case("AS")) {
+            continue;
+        }
+        let before = if index == 0 { "" } else { &trimmed_end[..index] };
+        if before.chars().last().is_some_and(is_identifier_char) {
+            continue;
+        }
+        let after_as = &candidate[2..];
+        if !after_as.chars().next().is_some_and(char::is_whitespace) {
+            continue;
+        }
+        let alias_text = after_as.trim();
+        let alias = read_identifier(alias_text, 0)?;
+        if alias.end != alias_text.len() {
+            continue;
+        }
+        let expression = trimmed_end[..index].trim().to_string();
+        if expression.is_empty() {
+            return None;
+        }
+        return Some(ExpressionAlias { expression, result_name: alias.value });
+    }
+    None
+}
+
+fn parse_column_alias(rest: &str) -> Option<Option<String>> {
+    let trimmed = rest.trim();
+    if trimmed.is_empty() {
+        return Some(None);
+    }
+    let alias_text = strip_leading_as(trimmed).unwrap_or(trimmed).trim();
+    let alias = read_identifier(alias_text, 0)?;
+    if alias.end != alias_text.len() {
+        return None;
+    }
+    Some(Some(alias.value))
+}
+
+fn strip_leading_as(text: &str) -> Option<&str> {
+    let prefix = text.get(..2)?;
+    if !prefix.eq_ignore_ascii_case("AS") {
+        return None;
+    }
+    let rest = &text[2..];
+    if rest.chars().next().is_some_and(char::is_whitespace) {
+        Some(rest)
+    } else {
+        None
+    }
+}
+
+fn strip_sql_server_top_clause(body: &str) -> &str {
+    let trimmed = body.trim_start();
+    if !starts_with_keyword(trimmed, "TOP") {
+        return trimmed;
+    }
+
+    let mut pos = skip_whitespace(trimmed, "TOP".len());
+    if trimmed[pos..].starts_with('(') {
+        let mut depth = 0i32;
+        let mut quote: Option<char> = None;
+        let mut end = None;
+        for (offset, ch) in trimmed[pos..].char_indices() {
+            if let Some(close) = quote {
+                if ch == close {
+                    quote = None;
+                }
+                continue;
+            }
+            match ch {
+                '\'' | '"' | '`' => quote = Some(ch),
+                '[' => quote = Some(']'),
+                '(' => depth += 1,
+                ')' => {
+                    depth -= 1;
+                    if depth == 0 {
+                        end = Some(pos + offset + ch.len_utf8());
+                        break;
+                    }
+                }
+                _ => {}
+            }
+        }
+        let Some(end) = end else {
+            return trimmed;
+        };
+        pos = end;
+    } else {
+        let number_end = trimmed[pos..]
+            .char_indices()
+            .take_while(|(_, ch)| ch.is_ascii_digit())
+            .last()
+            .map(|(offset, ch)| pos + offset + ch.len_utf8());
+        let Some(end) = number_end else {
+            return trimmed;
+        };
+        pos = end;
+    }
+
+    pos = skip_whitespace(trimmed, pos);
+    if starts_with_keyword_at(trimmed, pos, "PERCENT") {
+        pos = skip_whitespace(trimmed, pos + "PERCENT".len());
+    }
+    if starts_with_keyword_at(trimmed, pos, "WITH") {
+        let ties_pos = skip_whitespace(trimmed, pos + "WITH".len());
+        if starts_with_keyword_at(trimmed, ties_pos, "TIES") {
+            pos = skip_whitespace(trimmed, ties_pos + "TIES".len());
+        }
+    }
+    let remaining = trimmed[pos..].trim_start();
+    if remaining.is_empty() {
+        trimmed
+    } else {
+        remaining
+    }
+}
+
+fn is_select_star(body: &str, alias: Option<&str>) -> bool {
+    let trimmed = body.trim();
+    if trimmed == "*" {
+        return true;
+    }
+    let Some(alias) = alias else {
+        return false;
+    };
+    let Some((prefix, suffix)) = trimmed.split_once('.') else {
+        return false;
+    };
+    prefix.trim().eq_ignore_ascii_case(alias) && suffix.trim() == "*"
+}
+
+fn parse_from_sources(body: &str) -> Vec<FromSource> {
+    if body.is_empty() || body.contains('(') || body.contains(')') {
+        return Vec::new();
+    }
+
+    let mut sources = Vec::new();
+    let Some(first) = parse_table_source_at(body, 0, sources.len()) else {
+        return Vec::new();
+    };
+    sources.push(first.0);
+    let mut pos = first.1;
+
+    while pos < body.len() {
+        pos = skip_whitespace(body, pos);
+        if pos >= body.len() {
+            break;
+        }
+        if body[pos..].starts_with(',') {
+            let Some(next) = parse_table_source_at(body, pos + 1, sources.len()) else {
+                return Vec::new();
+            };
+            sources.push(next.0);
+            pos = next.1;
+            continue;
+        }
+        let Some(join_index) = find_top_level_keyword(body, "JOIN", pos) else {
+            break;
+        };
+        let Some(next) = parse_table_source_at(body, join_index + "JOIN".len(), sources.len()) else {
+            return Vec::new();
+        };
+        sources.push(next.0);
+        pos = next.1;
+    }
+
+    sources
+}
+
+fn parse_table_source_at(text: &str, start: usize, index: usize) -> Option<(FromSource, usize)> {
+    let pos = skip_whitespace(text, start);
+    if text[pos..].starts_with('\'') || text[pos..].starts_with('(') {
+        return None;
+    }
+    let ident = parse_qualified_identifier(&text[pos..])?;
+    if ident.parts.is_empty() || ident.parts.len() > 3 {
+        return None;
+    }
+    let mut end = pos + ident.end;
+    let tail_pos = skip_whitespace(text, end);
+    let alias = if starts_with_keyword_at(text, tail_pos, "AS") {
+        let alias_ident = read_identifier(text, tail_pos + 2)?;
+        end = alias_ident.end;
+        Some(alias_ident.value)
+    } else if table_source_terminator_at(text, tail_pos) {
+        None
+    } else {
+        let alias_ident = read_identifier(text, tail_pos)?;
+        end = alias_ident.end;
+        Some(alias_ident.value)
+    };
+
+    let table = ident.parts.last()?;
+    let table_name = table.value.clone();
+    let table_name_quoted = table.quoted;
+    let (schema, schema_quoted) = if ident.parts.len() >= 2 {
+        let schema = &ident.parts[ident.parts.len() - 2];
+        (Some(schema.value.clone()), schema.quoted)
+    } else {
+        (None, false)
+    };
+    let (catalog, catalog_quoted) = if ident.parts.len() == 3 {
+        let catalog = &ident.parts[0];
+        (Some(catalog.value.clone()), catalog.quoted)
+    } else {
+        (None, false)
+    };
+    let key = format!("{}:{}", alias.as_deref().unwrap_or(&table_name), index);
+    Some((
+        FromSource { key, catalog, catalog_quoted, schema, schema_quoted, table_name, table_name_quoted, alias },
+        end,
+    ))
+}
+
+fn is_external_from_source(body: &str) -> bool {
+    let trimmed = body.trim();
+    is_single_quoted_source_with_optional_alias(trimmed) || starts_with_table_function(trimmed)
+}
+
+fn table_source_terminator_at(text: &str, pos: usize) -> bool {
+    let pos = skip_whitespace(text, pos);
+    if pos >= text.len() || text[pos..].starts_with(',') {
+        return true;
+    }
+    ["ON", "USING", "JOIN", "LEFT", "RIGHT", "INNER", "FULL", "CROSS", "OUTER", "NATURAL"]
+        .iter()
+        .any(|keyword| starts_with_keyword_at(text, pos, keyword))
+}
+
+fn starts_with_keyword_at(text: &str, pos: usize, keyword: &str) -> bool {
+    let start = skip_whitespace(text, pos);
+    let Some(candidate) = text.get(start..start + keyword.len()) else {
+        return false;
+    };
+    if !candidate.eq_ignore_ascii_case(keyword) {
+        return false;
+    }
+    let before = previous_char(text, start);
+    let after = text[start + keyword.len()..].chars().next();
+    !before.is_some_and(is_identifier_char) && !after.is_some_and(is_identifier_char)
+}
+
+fn source_key_for_qualifier(sources: &[FromSource], qualifier: &str) -> Option<String> {
+    let matches = sources
+        .iter()
+        .filter(|source| {
+            source.alias.as_deref().is_some_and(|alias| alias.eq_ignore_ascii_case(qualifier))
+                || source.table_name.eq_ignore_ascii_case(qualifier)
+        })
+        .collect::<Vec<_>>();
+    if matches.len() == 1 {
+        Some(matches[0].key.clone())
+    } else {
+        None
+    }
+}
+
+impl From<FromSource> for EditableQuerySource {
+    fn from(source: FromSource) -> Self {
+        Self {
+            key: source.key,
+            catalog: source.catalog,
+            catalog_quoted: source.catalog_quoted,
+            schema: source.schema,
+            schema_quoted: source.schema_quoted,
+            table_name: source.table_name,
+            table_name_quoted: source.table_name_quoted,
+            alias: source.alias,
+        }
+    }
+}
+
+fn is_single_quoted_source_with_optional_alias(text: &str) -> bool {
+    let mut chars = text.char_indices().peekable();
+    if chars.next().map(|(_, ch)| ch) != Some('\'') {
+        return false;
+    }
+    while let Some((idx, ch)) = chars.next() {
+        if ch == '\'' {
+            if chars.peek().is_some_and(|(_, next)| *next == '\'') {
+                chars.next();
+                continue;
+            }
+            let tail = text[idx + ch.len_utf8()..].trim();
+            if tail.is_empty() {
+                return true;
+            }
+            let alias_text = strip_leading_as(tail).unwrap_or(tail).trim();
+            return read_identifier(alias_text, 0).is_some_and(|alias| alias.end == alias_text.len());
+        }
+    }
+    false
+}
+
+fn starts_with_table_function(text: &str) -> bool {
+    let Some(ident) = read_identifier(text, 0) else {
+        return false;
+    };
+    text[ident.end..].trim_start().starts_with('(')
+}
+
+fn parse_qualified_identifier(text: &str) -> Option<QualifiedIdentifier> {
+    let mut parts = Vec::new();
+    let mut pos = 0usize;
+    while pos < text.len() {
+        pos = skip_whitespace(text, pos);
+        let Some(ident) = read_identifier(text, pos) else {
+            break;
+        };
+        let ident_end = ident.end;
+        parts.push(ident);
+        pos = skip_whitespace(text, ident_end);
+        if !text[pos..].starts_with('.') {
+            break;
+        }
+        pos += 1;
+    }
+    if parts.is_empty() {
+        return None;
+    }
+    Some(QualifiedIdentifier { parts, end: pos })
+}
+
+fn read_identifier(text: &str, start: usize) -> Option<Identifier> {
+    let pos = skip_whitespace(text, start);
+    let mut chars = text[pos..].char_indices();
+    let (_, first) = chars.next()?;
+    if matches!(first, '"' | '`' | '[') {
+        let close = if first == '[' { ']' } else { first };
+        let mut value = String::new();
+        for (offset, ch) in chars {
+            if ch == close {
+                return Some(Identifier { value, quoted: true, end: pos + offset + ch.len_utf8() });
+            }
+            value.push(ch);
+        }
+        return None;
+    }
+
+    if !(first.is_ascii_alphabetic() || first == '_') {
+        return None;
+    }
+    let mut end = pos + first.len_utf8();
+    for (offset, ch) in text[end..].char_indices() {
+        if !(ch.is_ascii_alphanumeric() || ch == '_' || ch == '$') {
+            return Some(Identifier { value: text[pos..end + offset].to_string(), quoted: false, end: end + offset });
+        }
+    }
+    end = text.len();
+    Some(Identifier { value: text[pos..end].to_string(), quoted: false, end })
+}
+
+fn skip_whitespace(text: &str, pos: usize) -> usize {
+    let mut current = pos;
+    for (offset, ch) in text[pos..].char_indices() {
+        if !ch.is_whitespace() {
+            return pos + offset;
+        }
+        current = pos + offset + ch.len_utf8();
+    }
+    current
+}
+
+fn strip_sql_comments(sql: &str) -> String {
+    let mut result = String::new();
+    let mut chars = sql.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if ch == '-' && chars.peek() == Some(&'-') {
+            chars.next();
+            for next in chars.by_ref() {
+                if next == '\n' {
+                    result.push('\n');
+                    break;
+                }
+            }
+            continue;
+        }
+        if ch == '/' && chars.peek() == Some(&'*') {
+            chars.next();
+            let mut previous = '\0';
+            for next in chars.by_ref() {
+                if previous == '*' && next == '/' {
+                    break;
+                }
+                previous = next;
+            }
+            continue;
+        }
+        result.push(ch);
+    }
+    result
+}
+
+fn has_top_level_keyword(sql: &str, keywords: &[&str]) -> bool {
+    keywords.iter().any(|keyword| find_top_level_keyword(sql, keyword, 0).is_some())
+}
+
+fn first_top_level_keyword_index(sql: &str, keywords: &[&str], start: usize) -> Option<usize> {
+    keywords.iter().filter_map(|keyword| find_top_level_keyword(sql, keyword, start)).min()
+}
+
+fn find_top_level_keyword(sql: &str, keyword: &str, start: usize) -> Option<usize> {
+    let mut depth = 0i32;
+    let mut quote: Option<char> = None;
+    let upper_keyword = keyword.to_ascii_uppercase();
+
+    for (index, ch) in sql.char_indices().filter(|(index, _)| *index >= start) {
+        if let Some(close) = quote {
+            if ch == close {
+                quote = None;
+            }
+            continue;
+        }
+        match ch {
+            '\'' | '"' | '`' => {
+                quote = Some(ch);
+                continue;
+            }
+            '[' => {
+                quote = Some(']');
+                continue;
+            }
+            '(' => {
+                depth += 1;
+                continue;
+            }
+            ')' => {
+                depth = 0.max(depth - 1);
+                continue;
+            }
+            _ => {}
+        }
+        if depth != 0 {
+            continue;
+        }
+        let Some(candidate) = sql.get(index..index + keyword.len()) else {
+            continue;
+        };
+        if candidate.to_ascii_uppercase() != upper_keyword {
+            continue;
+        }
+        let before = previous_char(sql, index);
+        let after = sql[index + keyword.len()..].chars().next();
+        if !before.is_some_and(is_identifier_char) && !after.is_some_and(is_identifier_char) {
+            return Some(index);
+        }
+    }
+    None
+}
+
+fn starts_with_keyword(sql: &str, keyword: &str) -> bool {
+    let trimmed = sql.trim_start();
+    let Some(candidate) = trimmed.get(..keyword.len()) else {
+        return false;
+    };
+    if !candidate.eq_ignore_ascii_case(keyword) {
+        return false;
+    }
+    !trimmed[keyword.len()..].chars().next().is_some_and(is_identifier_char)
+}
+
+fn previous_char(text: &str, index: usize) -> Option<char> {
+    text[..index].chars().next_back()
+}
+
+fn is_identifier_char(ch: char) -> bool {
+    ch.is_ascii_alphanumeric() || ch == '_' || ch == '$'
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn recognizes_simple_single_table_select_as_editable() {
+        let result =
+            analyze_editable_query_editability("select id, name from public.users where active = true order by id");
+
+        assert!(result.editable);
+        assert_eq!(result.reason, None);
+        let analysis = result.analysis.unwrap();
+        assert_eq!(analysis.schema.as_deref(), Some("public"));
+        assert_eq!(analysis.table_name, "users");
+        assert_eq!(
+            analysis.columns,
+            vec![
+                column(Some("id"), false, None, None, "id", "id"),
+                column(Some("name"), false, None, None, "name", "name"),
+            ]
+        );
+    }
+
+    #[test]
+    fn recognizes_sql_server_top_selects_as_editable() {
+        for sql in [
+            "SELECT TOP 2 name, note FROM dbo.users ORDER BY name",
+            "SELECT TOP(2) name, note FROM dbo.users ORDER BY name",
+            "SELECT TOP (2) name, note FROM dbo.users ORDER BY name",
+            "SELECT TOP 10 PERCENT name, note FROM dbo.users ORDER BY name",
+            "SELECT TOP (2) WITH TIES name, note FROM dbo.users ORDER BY name",
+        ] {
+            let result = analyze_editable_query_editability(sql);
+            assert!(result.editable, "{sql}: {:?}", result.reason);
+            let analysis = result.analysis.unwrap();
+            assert_eq!(analysis.table_name, "users");
+            assert_eq!(analysis.columns[0].source_name.as_deref(), Some("name"));
+            assert_eq!(analysis.columns[1].source_name.as_deref(), Some("note"));
+        }
+    }
+
+    #[test]
+    fn recognizes_quoted_table_names_and_aliases() {
+        let result =
+            analyze_editable_query_editability(r#"SELECT u."id", u."full name" FROM "app schema"."user table" AS u"#);
+
+        let analysis = result.analysis.unwrap();
+        assert_eq!(analysis.schema.as_deref(), Some("app schema"));
+        assert_eq!(analysis.table_name, "user table");
+        assert_eq!(analysis.table_alias.as_deref(), Some("u"));
+        assert_eq!(
+            analysis.columns,
+            vec![
+                column(Some("id"), true, Some("u"), Some("u:0"), "id", r#"u."id""#),
+                column(Some("full name"), true, Some("u"), Some("u:0"), "full name", r#"u."full name""#),
+            ]
+        );
+    }
+
+    #[test]
+    fn keeps_select_star_empty_columns() {
+        let analysis = analyze_editable_query("select * from users").unwrap();
+        assert_eq!(analysis.table_name, "users");
+        assert!(analysis.select_star);
+        assert!(analysis.columns.is_empty());
+    }
+
+    #[test]
+    fn maps_single_table_explicit_column_with_alias_star() {
+        let result = analyze_editable_query_editability(
+            "select t.create_date, t.* from tt_kd_material_container_sap t where t.order_no = 'KD2607071336' order by t.create_date desc",
+        );
+
+        assert!(result.editable);
+        let analysis = result.analysis.unwrap();
+        assert_eq!(analysis.table_name, "tt_kd_material_container_sap");
+        assert_eq!(analysis.table_alias.as_deref(), Some("t"));
+        assert_eq!(
+            analysis.columns,
+            vec![
+                column(Some("create_date"), false, Some("t"), Some("t:0"), "create_date", "t.create_date"),
+                star_column(Some("t"), Some("t:0"), "t.*"),
+            ]
+        );
+    }
+
+    #[test]
+    fn recognizes_distinct_single_table_projection_as_update_only() {
+        let result = analyze_editable_query_editability("select distinct id, name from users");
+
+        assert!(result.editable);
+        let analysis = result.analysis.unwrap();
+        assert!(analysis.distinct);
+        assert_eq!(analysis.allow_insert_delete, Some(false));
+        assert_eq!(analysis.columns.len(), 2);
+    }
+
+    #[test]
+    fn recognizes_distinct_qualified_star_from_join() {
+        let result = analyze_editable_query_editability(
+            "select distinct u.* from users u left join orders o on o.user_id = u.id",
+        );
+
+        assert!(result.editable);
+        let analysis = result.analysis.unwrap();
+        assert!(analysis.distinct);
+        assert!(analysis.multi_source);
+        assert_eq!(analysis.allow_insert_delete, Some(false));
+        assert_eq!(analysis.columns, vec![star_column(Some("u"), Some("u:0"), "u.*")]);
+    }
+
+    #[test]
+    fn rejects_unqualified_star_from_join() {
+        let result =
+            analyze_editable_query_editability("select distinct * from users u join orders o on o.user_id = u.id");
+
+        assert!(!result.editable);
+        assert_eq!(result.reason, Some(QueryEditabilityReason::ComplexSource));
+    }
+
+    #[test]
+    fn rejects_distinct_on_projection() {
+        let result = analyze_editable_query_editability(
+            "select distinct on (user_id) id, user_id from orders order by user_id, id desc",
+        );
+
+        assert!(!result.editable);
+        assert_eq!(result.reason, Some(QueryEditabilityReason::Aggregation));
+    }
+
+    #[test]
+    fn maps_joined_query_source_columns() {
+        let result = analyze_editable_query_editability(
+            "select u.id as user_id, u.name, o.total from users u join orders o on o.user_id = u.id",
+        );
+
+        assert!(result.editable);
+        let analysis = result.analysis.unwrap();
+        assert!(analysis.multi_source);
+        assert_eq!(analysis.allow_insert_delete, Some(false));
+        assert_eq!(
+            analysis
+                .sources
+                .unwrap()
+                .iter()
+                .map(|source| (&source.key, &source.table_name, source.alias.as_deref()))
+                .collect::<Vec<_>>(),
+            vec![
+                (&"u:0".to_string(), &"users".to_string(), Some("u")),
+                (&"o:1".to_string(), &"orders".to_string(), Some("o")),
+            ]
+        );
+        assert_eq!(
+            analysis.columns,
+            vec![
+                column(Some("id"), false, Some("u"), Some("u:0"), "user_id", "u.id"),
+                column(Some("name"), false, Some("u"), Some("u:0"), "name", "u.name"),
+                column(Some("total"), false, Some("o"), Some("o:1"), "total", "o.total"),
+            ]
+        );
+    }
+
+    #[test]
+    fn reports_external_file_scan_as_external_source() {
+        let result = analyze_editable_query_editability("SELECT * FROM '/tmp/duckdb_excel_extension_test.xlsx'");
+
+        assert!(!result.editable);
+        assert_eq!(result.reason, Some(QueryEditabilityReason::ExternalSource));
+    }
+
+    #[test]
+    fn reports_grouped_query_as_aggregation() {
+        let result = analyze_editable_query_editability("select id, count(*) as total from users group by id");
+
+        assert!(!result.editable);
+        assert_eq!(result.reason, Some(QueryEditabilityReason::Aggregation));
+    }
+
+    #[test]
+    fn keeps_single_table_expression_columns() {
+        let result = analyze_editable_query_editability(
+            "select iso3, year, country_name, ihli / gdp_pc as score from ihli_data",
+        );
+
+        assert_eq!(
+            result.analysis.unwrap().columns,
+            vec![
+                column(Some("iso3"), false, None, None, "iso3", "iso3"),
+                column(Some("year"), false, None, None, "year", "year"),
+                column(Some("country_name"), false, None, None, "country_name", "country_name"),
+                column(None, false, None, None, "score", "ihli / gdp_pc"),
+            ]
+        );
+    }
+
+    #[test]
+    fn serializes_reason_values_like_frontend_union() {
+        let json = serde_json::to_value(not_editable(QueryEditabilityReason::SetOperation)).unwrap();
+
+        assert_eq!(json, serde_json::json!({ "editable": false, "reason": "set-operation" }));
+    }
+
+    fn column(
+        source_name: Option<&str>,
+        source_name_quoted: bool,
+        source_qualifier: Option<&str>,
+        source_key: Option<&str>,
+        result_name: &str,
+        expression: &str,
+    ) -> EditableQueryColumn {
+        EditableQueryColumn {
+            source_name: source_name.map(str::to_string),
+            source_name_quoted,
+            source_qualifier: source_qualifier.map(str::to_string),
+            source_key: source_key.map(str::to_string),
+            star: false,
+            result_name: result_name.to_string(),
+            expression: expression.to_string(),
+        }
+    }
+
+    fn star_column(source_qualifier: Option<&str>, source_key: Option<&str>, expression: &str) -> EditableQueryColumn {
+        EditableQueryColumn {
+            source_name: None,
+            source_name_quoted: false,
+            source_qualifier: source_qualifier.map(str::to_string),
+            source_key: source_key.map(str::to_string),
+            star: true,
+            result_name: "*".to_string(),
+            expression: expression.to_string(),
+        }
+    }
+}
diff --git a/crates/dbx-core/src/sql_file_import.rs b/crates/dbx-core/src/sql_file_import.rs
new file mode 100644
index 0000000..a8c48dc
--- /dev/null
+++ b/crates/dbx-core/src/sql_file_import.rs
@@ -0,0 +1,1458 @@
+use std::path::Path;
+use std::time::Instant;
+
+use tokio::io::{AsyncReadExt, BufReader};
+use tokio_util::sync::CancellationToken;
+
+use crate::connection::{AppState, PoolKind};
+use crate::db;
+use crate::models::connection::DatabaseType;
+use crate::query::{
+    execute_sql_statement_with_options, pool_error_action, wait_for_query_opt, DbOperationBudget, PoolErrorAction,
+    QueryExecutionOptions,
+};
+use crate::sql::{
+    optimize_sql_file_import_statements, prepare_sql_file_statement, split_sql_batches, statement_summary,
+    SqlFileImportStatement, SqlFileImportStatementKind, SqlFileProgress, SqlFileRequest, SqlFileStatementAction,
+    SqlFileStatus, SqlParsingOptions, SqlStatementSplitter,
+};
+use crate::types::QueryResult;
+
+#[derive(Debug, Clone)]
+struct SqlFileImportTarget {
+    db_type: DatabaseType,
+    driver_profile: Option<String>,
+}
+
+#[derive(Debug)]
+struct StatementErrorDecision {
+    progress: Vec<SqlFileProgress>,
+    failure_count: usize,
+    result: Result<bool, String>,
+}
+
+const SQL_FILE_READ_CHUNK_BYTES: usize = 256 * 1024;
+const SQL_FILE_STATEMENT_BATCH_SIZE: usize = 256;
+const SQL_FILE_PREVIEW_ENCODING_SAMPLE_BYTES: usize = 1024 * 1024;
+
+struct SqlFileExecutionProgress {
+    statement_index: usize,
+    success_count: usize,
+    failure_count: usize,
+    affected_rows: u64,
+}
+
+impl SqlFileExecutionProgress {
+    fn new() -> Self {
+        Self { statement_index: 0, success_count: 0, failure_count: 0, affected_rows: 0 }
+    }
+}
+
+struct MySqlSqlFileExecutor {
+    connection_id: String,
+    database: String,
+    pool_key: String,
+    db_type: Option<DatabaseType>,
+    bare: bool,
+    dialect: db::mysql::MySqlQueryDialect,
+    budget: DbOperationBudget,
+    conn: Option<mysql_async::Conn>,
+}
+
+impl MySqlSqlFileExecutor {
+    async fn build(
+        state: &AppState,
+        request: &SqlFileRequest,
+        import_target: Option<&SqlFileImportTarget>,
+    ) -> Result<Option<Self>, String> {
+        let Some(target) = import_target else {
+            return Ok(None);
+        };
+        if !crate::sql::supports_connection_level_database_bootstrap_target(
+            &target.db_type,
+            target.driver_profile.as_deref(),
+        ) {
+            return Ok(None);
+        }
+
+        let database = request.database.trim();
+        let database = (!database.is_empty()).then_some(database);
+        let pool_key = state.get_or_create_pool_for_session(&request.connection_id, database, None).await?;
+        let (db_type, driver_profile, bare) = {
+            let connections = state.connections.read().await;
+            let Some(PoolKind::Mysql(_, mode)) = connections.get(&pool_key) else {
+                return Ok(None);
+            };
+            (Some(target.db_type), target.driver_profile.as_deref(), *mode == crate::connection::MysqlMode::Bare)
+        };
+        let budget = {
+            let configs = state.configs.read().await;
+            let config = configs.get(&request.connection_id).ok_or("Connection config not found")?;
+            DbOperationBudget::from_connection_config(config)
+        };
+
+        Ok(Some(Self {
+            connection_id: request.connection_id.clone(),
+            database: request.database.clone(),
+            pool_key,
+            db_type,
+            bare,
+            dialect: db::mysql::MySqlQueryDialect::for_connection(
+                db_type.unwrap_or(DatabaseType::Mysql),
+                driver_profile,
+            ),
+            budget,
+            conn: None,
+        }))
+    }
+
+    async fn execute_statement(
+        &mut self,
+        state: &AppState,
+        request: &SqlFileRequest,
+        sql: &str,
+        token: &CancellationToken,
+        statement_index: usize,
+    ) -> Result<QueryResult, String> {
+        let execution_id = sql_file_statement_execution_id(&request.execution_id, statement_index);
+        let registered = state.running_queries.register(execution_id.clone());
+        let child_token = registered.token();
+        let cancel_task = {
+            let parent_token = token.clone();
+            let running_queries = state.running_queries.clone();
+            let execution_id = execution_id.clone();
+            tokio::spawn(async move {
+                parent_token.cancelled().await;
+                running_queries.cancel(&execution_id);
+            })
+        };
+
+        let result = self.execute_statement_inner(state, sql, &child_token, &execution_id).await;
+
+        cancel_task.abort();
+        result
+    }
+
+    async fn execute_statement_inner(
+        &mut self,
+        state: &AppState,
+        sql: &str,
+        child_token: &CancellationToken,
+        execution_id: &str,
+    ) -> Result<QueryResult, String> {
+        // Mirror `execute_sql_statement_with_options`: on a transient
+        // connection error the pool is reconnected and the statement is
+        // retried once instead of failing the whole import. The pinned
+        // connection is re-acquired from the fresh pool by `ensure_conn` on
+        // each attempt, so `USE`/session state is re-established via the
+        // tracked `self.database` before the retry runs.
+        for attempt in 0..2 {
+            self.ensure_conn(state, child_token).await?;
+            state.running_queries.set_pool_key(execution_id, self.pool_key.clone());
+            state.touch_pool_activity(&self.pool_key).await;
+            let _activity_touch = state.pool_activity_touch(&self.pool_key);
+
+            let conn = self.conn.as_mut().ok_or("MySQL SQL file executor is missing a connection".to_string())?;
+            let connection_id = conn.id();
+            let kill_opts = conn.opts().clone();
+            state.running_queries.register_interrupt(execution_id, move || {
+                let kill_opts = kill_opts.clone();
+                tokio::spawn(async move {
+                    if let Err(error) = db::mysql::kill_query_with_opts(kill_opts, connection_id).await {
+                        log::warn!("Failed to cancel MySQL SQL file import query {connection_id}: {error}");
+                    }
+                });
+            });
+
+            let result = wait_for_query_opt(
+                Some(child_token.clone()),
+                self.budget.query_timeout,
+                db::mysql::execute_query_on_conn_with_max_rows(conn, sql, self.bare, None, self.dialect),
+            )
+            .await;
+
+            if result.is_ok() {
+                // Reconnects should reopen the most recent `USE` target rather than
+                // the request's initial database value.
+                if let Some(database) = mysql_use_database_target(sql) {
+                    self.database = database;
+                }
+                return result;
+            }
+
+            let action = pool_error_action(self.db_type, result.as_ref().unwrap_err());
+            match action {
+                PoolErrorAction::Keep => return result,
+                PoolErrorAction::Discard => {
+                    self.conn.take();
+                    state.remove_pool_by_key(&self.pool_key).await;
+                    return result;
+                }
+                PoolErrorAction::ReconnectAndRetry => {
+                    self.conn.take();
+                    if attempt == 0 && !child_token.is_cancelled() {
+                        let database = self.database.trim();
+                        let database = (!database.is_empty()).then_some(database);
+                        self.pool_key = state.reconnect_pool_for_session(&self.connection_id, database, None).await?;
+                        continue;
+                    }
+                    // Cancelled, or the retry itself failed with another
+                    // reconnectable error: refresh the pool so the next
+                    // statement starts from a clean connection, then surface
+                    // the original error.
+                    if !child_token.is_cancelled() {
+                        let database = self.database.trim();
+                        let database = (!database.is_empty()).then_some(database);
+                        let _ = state.reconnect_pool_for_session(&self.connection_id, database, None).await;
+                    }
+                    return result;
+                }
+            }
+        }
+        unreachable!("MySQL SQL file executor retry loop runs at most twice")
+    }
+
+    async fn ensure_conn(&mut self, state: &AppState, token: &CancellationToken) -> Result<(), String> {
+        if self.conn.is_some() {
+            return Ok(());
+        }
+
+        let database = self.database.trim();
+        let database = (!database.is_empty()).then_some(database);
+        self.pool_key = state.get_or_create_pool_for_session(&self.connection_id, database, None).await?;
+        let pool = {
+            let connections = state.connections.read().await;
+            match connections.get(&self.pool_key) {
+                Some(PoolKind::Mysql(pool, _)) => pool.clone(),
+                Some(_) => return Err("SQL file import expected a MySQL-compatible pooled connection".to_string()),
+                None => return Err("Connection not found".to_string()),
+            }
+        };
+
+        self.conn = Some(
+            db::mysql::get_conn_with_health_check_with_cancel(
+                &pool,
+                self.budget.checkout_timeout,
+                self.budget.cleanup_timeout,
+                Some(token),
+            )
+            .await?,
+        );
+        Ok(())
+    }
+}
+
+pub async fn execute_sql_file_content(
+    state: &AppState,
+    request: &SqlFileRequest,
+    file_content: &str,
+    token: CancellationToken,
+    started_at: Instant,
+    mut emit: impl FnMut(SqlFileProgress),
+) -> Result<(), String> {
+    let import_target = sql_file_import_target(state, &request.connection_id).await;
+    let statements =
+        split_sql_file_import_statements(file_content, import_target.as_ref().map(|target| target.db_type));
+
+    let planned_statements = optimize_sql_file_import_statements(
+        &statements,
+        import_target.as_ref().map(|target| target.db_type),
+        import_target.as_ref().and_then(|target| target.driver_profile.as_deref()),
+    );
+    // MySQL-family imports need one pinned connection so `USE` and session
+    // state survive across the whole file.
+    let mut mysql_executor = MySqlSqlFileExecutor::build(state, request, import_target.as_ref()).await?;
+    let mut progress = SqlFileExecutionProgress::new();
+    execute_planned_statements_with_progress(
+        state,
+        request,
+        &token,
+        started_at,
+        &planned_statements,
+        mysql_executor.as_mut(),
+        &mut progress,
+        &mut emit,
+    )
+    .await?;
+    emit_sql_file_terminal_progress(request, &token, started_at, &progress, &mut emit);
+    Ok(())
+}
+
+pub async fn execute_sql_file_path(
+    state: &AppState,
+    request: &SqlFileRequest,
+    file_path: &Path,
+    token: CancellationToken,
+    started_at: Instant,
+    mut emit: impl FnMut(SqlFileProgress),
+) -> Result<(), String> {
+    let import_target = sql_file_import_target(state, &request.connection_id).await;
+    let options =
+        import_target.as_ref().map(|target| SqlParsingOptions::for_database_type(target.db_type)).unwrap_or_default();
+    let mut splitter = StreamingSqlFileSplitter::new(import_target.as_ref().map(|target| target.db_type), options);
+    let mut mysql_executor = MySqlSqlFileExecutor::build(state, request, import_target.as_ref()).await?;
+    let mut progress = SqlFileExecutionProgress::new();
+    let mut pending_statements = Vec::with_capacity(SQL_FILE_STATEMENT_BATCH_SIZE);
+    let mut decoder = match SqlFileStreamDecoder::open(file_path).await {
+        Ok(decoder) => decoder,
+        Err(error) => {
+            emit(sql_file_error_progress(&request.execution_id, started_at, error.clone()));
+            return Err(error);
+        }
+    };
+
+    loop {
+        let chunk = match decoder.next_chunk().await {
+            Ok(chunk) => chunk,
+            Err(error) => {
+                emit(sql_file_progress(
+                    &request.execution_id,
+                    SqlFileStatus::Error,
+                    progress.statement_index,
+                    progress.success_count,
+                    progress.failure_count,
+                    progress.affected_rows,
+                    started_at,
+                    "",
+                    Some(error.clone()),
+                ));
+                return Err(error);
+            }
+        };
+        let Some(chunk) = chunk else {
+            break;
+        };
+        if token.is_cancelled() {
+            emit_sql_file_terminal_progress(request, &token, started_at, &progress, &mut emit);
+            return Ok(());
+        }
+        pending_statements.extend(splitter.push_chunk(&chunk));
+        if pending_statements.len() >= SQL_FILE_STATEMENT_BATCH_SIZE {
+            execute_sql_file_statement_batch(
+                state,
+                request,
+                &token,
+                started_at,
+                &mut pending_statements,
+                import_target.as_ref(),
+                mysql_executor.as_mut(),
+                &mut progress,
+                &mut emit,
+            )
+            .await?;
+        }
+    }
+
+    pending_statements.extend(splitter.finish());
+    execute_sql_file_statement_batch(
+        state,
+        request,
+        &token,
+        started_at,
+        &mut pending_statements,
+        import_target.as_ref(),
+        mysql_executor.as_mut(),
+        &mut progress,
+        &mut emit,
+    )
+    .await?;
+    emit_sql_file_terminal_progress(request, &token, started_at, &progress, &mut emit);
+    Ok(())
+}
+
+pub async fn read_sql_file_preview(file_path: &Path, max_chars: usize) -> Result<String, String> {
+    let mut decoder =
+        SqlFileStreamDecoder::open_with_detection_limit(file_path, Some(SQL_FILE_PREVIEW_ENCODING_SAMPLE_BYTES))
+            .await?;
+    let mut preview = String::new();
+    while preview.chars().count() < max_chars {
+        let Some(chunk) = decoder.next_chunk().await? else {
+            break;
+        };
+        preview.push_str(&chunk);
+    }
+    Ok(preview.chars().take(max_chars).collect())
+}
+
+struct SqlFileStreamDecoder {
+    reader: BufReader<tokio::fs::File>,
+    decoder: encoding_rs::Decoder,
+    pending_bytes: Vec<u8>,
+    reached_eof: bool,
+}
+
+impl SqlFileStreamDecoder {
+    async fn open(file_path: &Path) -> Result<Self, String> {
+        Self::open_with_detection_limit(file_path, None).await
+    }
+
+    async fn open_with_detection_limit(file_path: &Path, detection_limit: Option<usize>) -> Result<Self, String> {
+        let (encoding, bom_len) = detect_sql_file_encoding(file_path, detection_limit).await?;
+        let mut file = tokio::fs::File::open(file_path).await.map_err(|error| error.to_string())?;
+        let mut prefix = [0u8; 3];
+        let prefix_len = file.read(&mut prefix).await.map_err(|error| error.to_string())?;
+        let prefix = &prefix[..prefix_len];
+        let mut pending_bytes = prefix[bom_len..].to_vec();
+        pending_bytes.reserve(SQL_FILE_READ_CHUNK_BYTES);
+        Ok(Self {
+            reader: BufReader::with_capacity(SQL_FILE_READ_CHUNK_BYTES, file),
+            decoder: encoding.new_decoder_without_bom_handling(),
+            pending_bytes,
+            reached_eof: false,
+        })
+    }
+
+    async fn next_chunk(&mut self) -> Result<Option<String>, String> {
+        if self.reached_eof && self.pending_bytes.is_empty() {
+            return Ok(None);
+        }
+        while !self.reached_eof && self.pending_bytes.len() < SQL_FILE_READ_CHUNK_BYTES {
+            let mut buffer = vec![0u8; SQL_FILE_READ_CHUNK_BYTES - self.pending_bytes.len()];
+            let read = self.reader.read(&mut buffer).await.map_err(|error| error.to_string())?;
+            if read == 0 {
+                self.reached_eof = true;
+                break;
+            }
+            self.pending_bytes.extend_from_slice(&buffer[..read]);
+        }
+
+        let mut output = String::with_capacity(
+            self.decoder
+                .max_utf8_buffer_length_without_replacement(self.pending_bytes.len())
+                .unwrap_or(self.pending_bytes.len()),
+        );
+        let (result, read) =
+            self.decoder.decode_to_string_without_replacement(&self.pending_bytes, &mut output, self.reached_eof);
+        self.pending_bytes.drain(..read);
+        match result {
+            encoding_rs::DecoderResult::InputEmpty => Ok((!output.is_empty()).then_some(output)),
+            encoding_rs::DecoderResult::OutputFull => Ok(Some(output)),
+            encoding_rs::DecoderResult::Malformed(_, _) => Err("Unsupported or invalid SQL file encoding".to_string()),
+        }
+    }
+}
+
+async fn detect_sql_file_encoding(
+    file_path: &Path,
+    detection_limit: Option<usize>,
+) -> Result<(&'static encoding_rs::Encoding, usize), String> {
+    let mut file = tokio::fs::File::open(file_path).await.map_err(|error| error.to_string())?;
+    let mut prefix = [0u8; 3];
+    let prefix_len = file.read(&mut prefix).await.map_err(|error| error.to_string())?;
+    let prefix = &prefix[..prefix_len];
+    if prefix.starts_with(&[0xEF, 0xBB, 0xBF]) {
+        return Ok((encoding_rs::UTF_8, 3));
+    }
+    if prefix.starts_with(&[0xFF, 0xFE]) {
+        return Ok((encoding_rs::UTF_16LE, 2));
+    }
+    if prefix.starts_with(&[0xFE, 0xFF]) {
+        return Ok((encoding_rs::UTF_16BE, 2));
+    }
+
+    // SQL dumps often begin with ASCII comments even when the remaining file
+    // is GBK. Validate the entire stream as UTF-8 with bounded buffers before
+    // falling back to the legacy GBK behavior.
+    let mut decoder = encoding_rs::UTF_8.new_decoder_without_bom_handling();
+    let mut input = prefix.to_vec();
+    let mut inspected_bytes = prefix.len();
+    let mut reached_eof = false;
+    loop {
+        let reached_detection_limit = detection_limit.is_some_and(|limit| inspected_bytes >= limit);
+        if !reached_eof && !reached_detection_limit {
+            let remaining =
+                detection_limit.map(|limit| limit.saturating_sub(inspected_bytes)).unwrap_or(SQL_FILE_READ_CHUNK_BYTES);
+            let mut buffer = vec![0u8; SQL_FILE_READ_CHUNK_BYTES.min(remaining.max(1))];
+            let read = file.read(&mut buffer).await.map_err(|error| error.to_string())?;
+            if read == 0 {
+                reached_eof = true;
+            } else {
+                inspected_bytes += read;
+                input.extend_from_slice(&buffer[..read]);
+            }
+        }
+        let mut output = String::with_capacity(
+            decoder.max_utf8_buffer_length_without_replacement(input.len()).unwrap_or(input.len()),
+        );
+        let (result, read) = decoder.decode_to_string_without_replacement(&input, &mut output, reached_eof);
+        input.drain(..read);
+        match result {
+            encoding_rs::DecoderResult::Malformed(_, _) => return Ok((encoding_rs::GBK, 0)),
+            encoding_rs::DecoderResult::InputEmpty if reached_eof || reached_detection_limit => {
+                return Ok((encoding_rs::UTF_8, 0));
+            }
+            encoding_rs::DecoderResult::InputEmpty | encoding_rs::DecoderResult::OutputFull => {}
+        }
+    }
+}
+
+enum StreamingSqlFileSplitter {
+    Statements(SqlStatementSplitter),
+    SqlServerBatches(SqlServerBatchSplitter),
+}
+
+impl StreamingSqlFileSplitter {
+    fn new(db_type: Option<DatabaseType>, options: SqlParsingOptions) -> Self {
+        if db_type == Some(DatabaseType::SqlServer) {
+            Self::SqlServerBatches(SqlServerBatchSplitter::default())
+        } else {
+            Self::Statements(SqlStatementSplitter::with_options(options))
+        }
+    }
+
+    fn push_chunk(&mut self, chunk: &str) -> Vec<String> {
+        match self {
+            Self::Statements(splitter) => splitter.push_chunk(chunk),
+            Self::SqlServerBatches(splitter) => splitter.push_chunk(chunk),
+        }
+    }
+
+    fn finish(self) -> Vec<String> {
+        match self {
+            Self::Statements(splitter) => splitter.finish(),
+            Self::SqlServerBatches(splitter) => splitter.finish(),
+        }
+    }
+}
+
+#[derive(Default)]
+struct SqlServerBatchSplitter {
+    batch: String,
+    partial_line: String,
+}
+
+impl SqlServerBatchSplitter {
+    fn push_chunk(&mut self, chunk: &str) -> Vec<String> {
+        self.partial_line.push_str(chunk);
+        let mut batches = Vec::new();
+        while let Some(newline) = self.partial_line.find('\n') {
+            let line = self.partial_line[..newline].trim_end_matches('\r').to_string();
+            self.partial_line.drain(..=newline);
+            self.push_line(&line, &mut batches);
+        }
+        batches
+    }
+
+    fn finish(mut self) -> Vec<String> {
+        let mut batches = Vec::new();
+        if !self.partial_line.is_empty() {
+            let line = std::mem::take(&mut self.partial_line);
+            self.push_line(line.trim_end_matches('\r'), &mut batches);
+        }
+        self.push_batch(&mut batches);
+        batches
+    }
+
+    fn push_line(&mut self, line: &str, batches: &mut Vec<String>) {
+        if line.trim().eq_ignore_ascii_case("go") {
+            self.push_batch(batches);
+        } else {
+            self.batch.push_str(line);
+            self.batch.push('\n');
+        }
+    }
+
+    fn push_batch(&mut self, batches: &mut Vec<String>) {
+        let batch = self.batch.trim();
+        if !batch.is_empty() {
+            batches.push(batch.to_string());
+        }
+        self.batch.clear();
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn execute_sql_file_statement_batch(
+    state: &AppState,
+    request: &SqlFileRequest,
+    token: &CancellationToken,
+    started_at: Instant,
+    statements: &mut Vec<String>,
+    import_target: Option<&SqlFileImportTarget>,
+    mysql_executor: Option<&mut MySqlSqlFileExecutor>,
+    progress: &mut SqlFileExecutionProgress,
+    emit: &mut impl FnMut(SqlFileProgress),
+) -> Result<(), String> {
+    if statements.is_empty() {
+        return Ok(());
+    }
+    let statements = std::mem::take(statements);
+    let planned_statements = optimize_sql_file_import_statements(
+        &statements,
+        import_target.map(|target| target.db_type),
+        import_target.and_then(|target| target.driver_profile.as_deref()),
+    );
+    execute_planned_statements_with_progress(
+        state,
+        request,
+        token,
+        started_at,
+        &planned_statements,
+        mysql_executor,
+        progress,
+        emit,
+    )
+    .await
+}
+
+fn emit_sql_file_terminal_progress(
+    request: &SqlFileRequest,
+    token: &CancellationToken,
+    started_at: Instant,
+    progress: &SqlFileExecutionProgress,
+    emit: &mut impl FnMut(SqlFileProgress),
+) {
+    emit(sql_file_progress(
+        &request.execution_id,
+        if token.is_cancelled() { SqlFileStatus::Cancelled } else { SqlFileStatus::Done },
+        progress.statement_index,
+        progress.success_count,
+        progress.failure_count,
+        progress.affected_rows,
+        started_at,
+        "",
+        None,
+    ));
+}
+
+fn split_sql_file_import_statements(file_content: &str, db_type: Option<DatabaseType>) -> Vec<String> {
+    if db_type == Some(DatabaseType::SqlServer) {
+        // GO is a client-side batch delimiter, not T-SQL. SQL Server module DDL
+        // must also remain a complete batch because procedure bodies contain semicolons.
+        return split_sql_batches(file_content);
+    }
+
+    let options = db_type.map(SqlParsingOptions::for_database_type).unwrap_or_default();
+    let mut splitter = SqlStatementSplitter::with_options(options);
+    let mut statements = splitter.push_chunk(file_content);
+    statements.extend(splitter.finish());
+    statements
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn sql_file_progress(
+    execution_id: &str,
+    status: SqlFileStatus,
+    statement_index: usize,
+    success_count: usize,
+    failure_count: usize,
+    affected_rows: u64,
+    started_at: Instant,
+    statement_summary: &str,
+    error: Option<String>,
+) -> SqlFileProgress {
+    SqlFileProgress {
+        execution_id: execution_id.to_string(),
+        status,
+        statement_index,
+        success_count,
+        failure_count,
+        affected_rows,
+        elapsed_ms: started_at.elapsed().as_millis(),
+        statement_summary: statement_summary.to_string(),
+        error,
+    }
+}
+
+pub fn sql_file_error_progress(execution_id: &str, started_at: Instant, error: String) -> SqlFileProgress {
+    sql_file_progress(execution_id, SqlFileStatus::Error, 0, 0, 0, 0, started_at, "", Some(error))
+}
+
+async fn sql_file_import_target(state: &AppState, connection_id: &str) -> Option<SqlFileImportTarget> {
+    let configs = state.configs.read().await;
+    configs
+        .get(connection_id)
+        .map(|config| SqlFileImportTarget { db_type: config.db_type, driver_profile: config.driver_profile.clone() })
+}
+
+pub fn mysql_like_sql_file_can_execute_without_selected_database(file_content: &str) -> bool {
+    let options = SqlParsingOptions::mysql_compatible();
+    let mut splitter = SqlStatementSplitter::with_options(options);
+    let mut statements = splitter.push_chunk(file_content);
+    statements.extend(splitter.finish());
+
+    let mut saw_statement = false;
+    let mut has_database_context = false;
+
+    for statement in statements {
+        let prepared = match prepare_sql_file_statement(&statement, &DatabaseType::Mysql, None) {
+            SqlFileStatementAction::Skip => continue,
+            SqlFileStatementAction::Execute(sql) => sql,
+        };
+        let statement = strip_leading_sql_comments(&prepared, true).trim_start();
+        if statement.is_empty() {
+            continue;
+        }
+
+        // Keep preview gating aligned with the executor: setup statements may
+        // run before the script establishes its own database context.
+        saw_statement = true;
+        let Some((keyword, remainder)) = leading_sql_keyword(statement) else {
+            return false;
+        };
+
+        if keyword.eq_ignore_ascii_case("SET") {
+            continue;
+        }
+
+        if mysql_use_database_target(statement).is_some() {
+            has_database_context = true;
+            continue;
+        }
+
+        if (keyword.eq_ignore_ascii_case("DROP") || keyword.eq_ignore_ascii_case("CREATE"))
+            && leading_sql_keyword(remainder)
+                .is_some_and(|(next, _)| next.eq_ignore_ascii_case("DATABASE") || next.eq_ignore_ascii_case("SCHEMA"))
+        {
+            continue;
+        }
+
+        if !has_database_context {
+            return false;
+        }
+    }
+
+    saw_statement
+}
+
+fn mysql_use_database_target(sql: &str) -> Option<String> {
+    let sql = strip_leading_sql_comments(sql, true).trim_start();
+    let rest = sql.get(..3).filter(|prefix| prefix.eq_ignore_ascii_case("USE")).and_then(|_| sql.get(3..))?;
+    if rest.is_empty() || !rest.as_bytes()[0].is_ascii_whitespace() {
+        return None;
+    }
+
+    let (database, remainder) = parse_mysql_identifier(rest.trim_start())?;
+    sql_remainder_is_comment_only(remainder).then_some(database)
+}
+
+fn strip_leading_sql_comments(mut sql: &str, supports_hash_line_comments: bool) -> &str {
+    loop {
+        sql = sql.trim_start();
+        if sql.is_empty() {
+            return sql;
+        }
+
+        if let Some(rest) = sql.strip_prefix("--") {
+            if let Some(idx) = rest.find('\n') {
+                sql = &rest[idx + 1..];
+                continue;
+            }
+            return "";
+        }
+
+        if supports_hash_line_comments {
+            if let Some(rest) = sql.strip_prefix('#') {
+                if let Some(idx) = rest.find('\n') {
+                    sql = &rest[idx + 1..];
+                    continue;
+                }
+                return "";
+            }
+        }
+
+        if let Some(rest) = sql.strip_prefix("/*") {
+            let Some(close) = rest.find("*/") else {
+                return "";
+            };
+            sql = &rest[close + 2..];
+            continue;
+        }
+
+        return sql;
+    }
+}
+
+fn leading_sql_keyword(input: &str) -> Option<(&str, &str)> {
+    let input = input.trim_start();
+    let end = input.find(|ch: char| !(ch.is_ascii_alphanumeric() || ch == '_')).unwrap_or(input.len());
+    (end > 0).then_some((&input[..end], &input[end..]))
+}
+
+fn parse_mysql_identifier(input: &str) -> Option<(String, &str)> {
+    let first = *input.as_bytes().first()?;
+    match first {
+        b'`' | b'"' => parse_mysql_doubled_delimited_identifier(input, first),
+        b'[' => parse_mysql_bracket_identifier(input),
+        _ => {
+            let end = input.find(|c: char| c.is_whitespace() || c == ';').unwrap_or(input.len());
+            let identifier = input[..end].trim();
+            (!identifier.is_empty()).then_some((identifier.to_string(), &input[end..]))
+        }
+    }
+}
+
+fn parse_mysql_doubled_delimited_identifier(input: &str, quote: u8) -> Option<(String, &str)> {
+    let bytes = input.as_bytes();
+    let mut index = 1;
+    let mut segment_start = 1;
+    let mut identifier = String::new();
+
+    while index < bytes.len() {
+        if bytes[index] == quote {
+            identifier.push_str(&input[segment_start..index]);
+            if bytes.get(index + 1) == Some(&quote) {
+                identifier.push(quote as char);
+                index += 2;
+                segment_start = index;
+                continue;
+            }
+            return Some((identifier, &input[index + 1..]));
+        }
+        index += 1;
+    }
+
+    None
+}
+
+fn parse_mysql_bracket_identifier(input: &str) -> Option<(String, &str)> {
+    let bytes = input.as_bytes();
+    let mut index = 1;
+    let mut segment_start = 1;
+    let mut identifier = String::new();
+
+    while index < bytes.len() {
+        if bytes[index] == b']' {
+            identifier.push_str(&input[segment_start..index]);
+            if bytes.get(index + 1) == Some(&b']') {
+                identifier.push(']');
+                index += 2;
+                segment_start = index;
+                continue;
+            }
+            return Some((identifier, &input[index + 1..]));
+        }
+        index += 1;
+    }
+
+    None
+}
+
+fn sql_remainder_is_comment_only(mut remainder: &str) -> bool {
+    loop {
+        remainder = remainder.trim_start();
+        if remainder.is_empty() {
+            return true;
+        }
+        if let Some(rest) = remainder.strip_prefix(';') {
+            remainder = rest;
+            continue;
+        }
+        if remainder.starts_with("--") || remainder.starts_with('#') {
+            return true;
+        }
+        if let Some(rest) = remainder.strip_prefix("/*") {
+            let Some(close) = rest.find("*/") else {
+                return false;
+            };
+            remainder = &rest[close + 2..];
+            continue;
+        }
+        return false;
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn execute_planned_statements_with_progress(
+    state: &AppState,
+    request: &SqlFileRequest,
+    token: &CancellationToken,
+    started_at: Instant,
+    planned_statements: &[SqlFileImportStatement],
+    mut mysql_executor: Option<&mut MySqlSqlFileExecutor>,
+    progress: &mut SqlFileExecutionProgress,
+    emit: &mut impl FnMut(SqlFileProgress),
+) -> Result<(), String> {
+    for planned_statement in planned_statements {
+        if token.is_cancelled() {
+            return Ok(());
+        }
+
+        let next_statement_index = progress.statement_index + planned_statement.source_statement_count;
+        if execute_statement_with_progress(
+            state,
+            request,
+            token,
+            started_at,
+            next_statement_index,
+            planned_statement,
+            &mut progress.success_count,
+            &mut progress.failure_count,
+            &mut progress.affected_rows,
+            mysql_executor.as_deref_mut(),
+            emit,
+        )
+        .await?
+        {
+            return Ok(());
+        }
+        progress.statement_index = next_statement_index;
+    }
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn execute_statement_with_progress(
+    state: &AppState,
+    request: &SqlFileRequest,
+    token: &CancellationToken,
+    started_at: Instant,
+    statement_index: usize,
+    statement: &SqlFileImportStatement,
+    success_count: &mut usize,
+    failure_count: &mut usize,
+    affected_rows: &mut u64,
+    mut mysql_executor: Option<&mut MySqlSqlFileExecutor>,
+    emit: &mut impl FnMut(SqlFileProgress),
+) -> Result<bool, String> {
+    if token.is_cancelled() {
+        let summary = statement_summary(&statement.sql);
+        emit(sql_file_progress(
+            &request.execution_id,
+            SqlFileStatus::Cancelled,
+            statement_index,
+            *success_count,
+            *failure_count,
+            *affected_rows,
+            started_at,
+            &summary,
+            None,
+        ));
+        return Ok(true);
+    }
+
+    if statement.kind == SqlFileImportStatementKind::Skip {
+        let summary = statement_summary(&statement.sql);
+        emit(sql_file_progress(
+            &request.execution_id,
+            SqlFileStatus::Running,
+            statement_index,
+            *success_count,
+            *failure_count,
+            *affected_rows,
+            started_at,
+            &summary,
+            None,
+        ));
+        *success_count += statement.source_statement_count;
+        emit(sql_file_progress(
+            &request.execution_id,
+            SqlFileStatus::StatementDone,
+            statement_index,
+            *success_count,
+            *failure_count,
+            *affected_rows,
+            started_at,
+            &summary,
+            None,
+        ));
+        return Ok(false);
+    }
+
+    let summary = statement_summary(&statement.sql);
+    emit(sql_file_progress(
+        &request.execution_id,
+        SqlFileStatus::Running,
+        statement_index,
+        *success_count,
+        *failure_count,
+        *affected_rows,
+        started_at,
+        &summary,
+        None,
+    ));
+
+    let result = {
+        let mysql_executor = mysql_executor.as_deref_mut();
+        execute_sql_file_statement_with_executor(state, request, &statement.sql, token, statement_index, mysql_executor)
+            .await
+    };
+
+    match result {
+        Ok(result) => {
+            *success_count += statement.source_statement_count;
+            *affected_rows += result.affected_rows;
+            emit(sql_file_progress(
+                &request.execution_id,
+                SqlFileStatus::StatementDone,
+                statement_index,
+                *success_count,
+                *failure_count,
+                *affected_rows,
+                started_at,
+                &summary,
+                None,
+            ));
+            Ok(false)
+        }
+        Err(error) => {
+            if statement.source_statement_count > 1 && !token.is_cancelled() {
+                return execute_merged_statement_fallback_with_progress(
+                    state,
+                    request,
+                    token,
+                    started_at,
+                    statement_index + 1 - statement.source_statement_count,
+                    statement,
+                    success_count,
+                    failure_count,
+                    affected_rows,
+                    mysql_executor,
+                    emit,
+                )
+                .await;
+            }
+
+            let decision = statement_error_decision(
+                &request.execution_id,
+                token,
+                request.continue_on_error,
+                started_at,
+                statement_index,
+                *success_count,
+                *failure_count,
+                *affected_rows,
+                &summary,
+                error,
+            );
+
+            *failure_count = decision.failure_count;
+            for progress in decision.progress {
+                emit(progress);
+            }
+            decision.result
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn execute_merged_statement_fallback_with_progress(
+    state: &AppState,
+    request: &SqlFileRequest,
+    token: &CancellationToken,
+    started_at: Instant,
+    first_statement_index: usize,
+    statement: &SqlFileImportStatement,
+    success_count: &mut usize,
+    failure_count: &mut usize,
+    affected_rows: &mut u64,
+    mut mysql_executor: Option<&mut MySqlSqlFileExecutor>,
+    emit: &mut impl FnMut(SqlFileProgress),
+) -> Result<bool, String> {
+    for (offset, source_sql) in statement.source_sqls.iter().enumerate() {
+        let statement_index = first_statement_index + offset;
+        if token.is_cancelled() {
+            emit(sql_file_progress(
+                &request.execution_id,
+                SqlFileStatus::Cancelled,
+                statement_index,
+                *success_count,
+                *failure_count,
+                *affected_rows,
+                started_at,
+                &statement_summary(source_sql),
+                None,
+            ));
+            return Ok(true);
+        }
+
+        let summary = statement_summary(source_sql);
+        emit(sql_file_progress(
+            &request.execution_id,
+            SqlFileStatus::Running,
+            statement_index,
+            *success_count,
+            *failure_count,
+            *affected_rows,
+            started_at,
+            &summary,
+            None,
+        ));
+
+        match execute_sql_file_statement_with_executor(
+            state,
+            request,
+            source_sql,
+            token,
+            statement_index,
+            mysql_executor.as_deref_mut(),
+        )
+        .await
+        {
+            Ok(result) => {
+                *success_count += 1;
+                *affected_rows += result.affected_rows;
+                emit(sql_file_progress(
+                    &request.execution_id,
+                    SqlFileStatus::StatementDone,
+                    statement_index,
+                    *success_count,
+                    *failure_count,
+                    *affected_rows,
+                    started_at,
+                    &summary,
+                    None,
+                ));
+            }
+            Err(error) => {
+                let decision = statement_error_decision(
+                    &request.execution_id,
+                    token,
+                    request.continue_on_error,
+                    started_at,
+                    statement_index,
+                    *success_count,
+                    *failure_count,
+                    *affected_rows,
+                    &summary,
+                    error,
+                );
+
+                *failure_count = decision.failure_count;
+                for progress in decision.progress {
+                    emit(progress);
+                }
+                if decision.result? {
+                    return Ok(true);
+                }
+            }
+        }
+    }
+
+    Ok(false)
+}
+
+async fn execute_sql_file_statement_with_executor(
+    state: &AppState,
+    request: &SqlFileRequest,
+    sql: &str,
+    token: &CancellationToken,
+    statement_index: usize,
+    mysql_executor: Option<&mut MySqlSqlFileExecutor>,
+) -> Result<QueryResult, String> {
+    if let Some(mysql_executor) = mysql_executor {
+        mysql_executor.execute_statement(state, request, sql, token, statement_index).await
+    } else {
+        execute_sql_file_statement(state, request, sql, token, statement_index).await
+    }
+}
+
+async fn execute_sql_file_statement(
+    state: &AppState,
+    request: &SqlFileRequest,
+    sql: &str,
+    token: &CancellationToken,
+    statement_index: usize,
+) -> Result<QueryResult, String> {
+    let execution_id = sql_file_statement_execution_id(&request.execution_id, statement_index);
+    let registered = state.running_queries.register(execution_id.clone());
+    let child_token = registered.token();
+    let cancel_task = {
+        let parent_token = token.clone();
+        let running_queries = state.running_queries.clone();
+        let execution_id = execution_id.clone();
+        tokio::spawn(async move {
+            parent_token.cancelled().await;
+            running_queries.cancel(&execution_id);
+        })
+    };
+
+    let result = execute_sql_statement_with_options(
+        state,
+        &request.connection_id,
+        &request.database,
+        sql,
+        None,
+        Some(child_token),
+        QueryExecutionOptions { execution_id: Some(execution_id), ..Default::default() },
+    )
+    .await;
+
+    cancel_task.abort();
+    result
+}
+
+fn sql_file_statement_execution_id(parent_execution_id: &str, statement_index: usize) -> String {
+    format!("{parent_execution_id}:statement:{statement_index}")
+}
+
+#[allow(clippy::too_many_arguments)]
+fn statement_error_decision(
+    execution_id: &str,
+    token: &CancellationToken,
+    continue_on_error: bool,
+    started_at: Instant,
+    statement_index: usize,
+    success_count: usize,
+    failure_count: usize,
+    affected_rows: u64,
+    summary: &str,
+    error: String,
+) -> StatementErrorDecision {
+    if token.is_cancelled() {
+        return StatementErrorDecision {
+            progress: vec![sql_file_progress(
+                execution_id,
+                SqlFileStatus::Cancelled,
+                statement_index,
+                success_count,
+                failure_count,
+                affected_rows,
+                started_at,
+                summary,
+                None,
+            )],
+            failure_count,
+            result: Ok(true),
+        };
+    }
+
+    let failure_count = failure_count + 1;
+    let statement_failed = sql_file_progress(
+        execution_id,
+        SqlFileStatus::StatementFailed,
+        statement_index,
+        success_count,
+        failure_count,
+        affected_rows,
+        started_at,
+        summary,
+        Some(error.clone()),
+    );
+
+    if continue_on_error {
+        return StatementErrorDecision { progress: vec![statement_failed], failure_count, result: Ok(false) };
+    }
+
+    let terminal_error = sql_file_progress(
+        execution_id,
+        SqlFileStatus::Error,
+        statement_index,
+        success_count,
+        failure_count,
+        affected_rows,
+        started_at,
+        summary,
+        Some(error.clone()),
+    );
+
+    StatementErrorDecision { progress: vec![statement_failed, terminal_error], failure_count, result: Err(error) }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::models::connection::DatabaseType;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    static TEMP_SQL_FILE_SEQUENCE: AtomicU64 = AtomicU64::new(0);
+
+    async fn temporary_sql_file(bytes: &[u8]) -> std::path::PathBuf {
+        let path = std::env::temp_dir().join(format!(
+            "dbx-sql-file-{}-{}.sql",
+            std::process::id(),
+            TEMP_SQL_FILE_SEQUENCE.fetch_add(1, Ordering::Relaxed)
+        ));
+        tokio::fs::write(&path, bytes).await.unwrap();
+        path
+    }
+
+    #[test]
+    fn sqlserver_sql_file_splits_go_batches_without_sending_delimiters() {
+        let statements = split_sql_file_import_statements(
+            "CREATE TABLE dbo.items (id INT);\nGO\nINSERT INTO dbo.items VALUES (1);\nGO\nSELECT * FROM dbo.items;",
+            Some(DatabaseType::SqlServer),
+        );
+
+        assert_eq!(
+            statements,
+            vec!["CREATE TABLE dbo.items (id INT);", "INSERT INTO dbo.items VALUES (1);", "SELECT * FROM dbo.items;"]
+        );
+        assert!(statements
+            .iter()
+            .all(|statement| !statement.lines().any(|line| line.trim().eq_ignore_ascii_case("go"))));
+    }
+
+    #[test]
+    fn sqlserver_sql_file_keeps_module_body_in_one_batch() {
+        let statements = split_sql_file_import_statements(
+            "CREATE PROCEDURE dbo.demo AS\nBEGIN\n  SELECT 1;\n  SELECT 2;\nEND\nGO\nSELECT 3;",
+            Some(DatabaseType::SqlServer),
+        );
+
+        assert_eq!(statements.len(), 2);
+        assert_eq!(statements[0], "CREATE PROCEDURE dbo.demo AS\nBEGIN\n  SELECT 1;\n  SELECT 2;\nEND");
+        assert_eq!(statements[1], "SELECT 3;");
+    }
+
+    #[test]
+    fn streaming_sqlserver_splitter_handles_go_across_chunks() {
+        let mut splitter = SqlServerBatchSplitter::default();
+        let mut batches = splitter.push_chunk("CREATE PROCEDURE dbo.demo AS\nBEGIN\nSELECT 1;\nEND\nG");
+        batches.extend(splitter.push_chunk("O\r\nSELECT 2;\nGO\n"));
+        batches.extend(splitter.finish());
+
+        assert_eq!(batches, vec!["CREATE PROCEDURE dbo.demo AS\nBEGIN\nSELECT 1;\nEND", "SELECT 2;"]);
+    }
+
+    #[tokio::test]
+    async fn streaming_decoder_detects_gbk_after_ascii_prefix() {
+        let (encoded, _, _) = encoding_rs::GBK.encode("-- Navicat dump\nINSERT INTO t VALUES ('中文');");
+        let path = temporary_sql_file(encoded.as_ref()).await;
+        let mut decoder = SqlFileStreamDecoder::open(&path).await.unwrap();
+        let mut decoded = String::new();
+        while let Some(chunk) = decoder.next_chunk().await.unwrap() {
+            decoded.push_str(&chunk);
+        }
+        tokio::fs::remove_file(path).await.unwrap();
+
+        assert_eq!(decoded, "-- Navicat dump\nINSERT INTO t VALUES ('中文');");
+    }
+
+    #[tokio::test]
+    async fn streaming_decoder_preserves_utf16le_bom_files() {
+        let mut bytes = vec![0xFF, 0xFE];
+        for unit in "SELECT '中文';".encode_utf16() {
+            bytes.extend_from_slice(&unit.to_le_bytes());
+        }
+        let path = temporary_sql_file(&bytes).await;
+        let mut decoder = SqlFileStreamDecoder::open(&path).await.unwrap();
+        let mut decoded = String::new();
+        while let Some(chunk) = decoder.next_chunk().await.unwrap() {
+            decoded.push_str(&chunk);
+        }
+        tokio::fs::remove_file(path).await.unwrap();
+
+        assert_eq!(decoded, "SELECT '中文';");
+    }
+
+    #[test]
+    fn non_sqlserver_sql_file_keeps_statement_splitting_behavior() {
+        assert_eq!(
+            split_sql_file_import_statements("SELECT 1; SELECT 2;", Some(DatabaseType::Postgres)),
+            vec!["SELECT 1", "SELECT 2"]
+        );
+    }
+
+    #[test]
+    fn stop_on_error_returns_err_with_terminal_error_progress() {
+        let decision = statement_error_decision(
+            "exec-1",
+            &CancellationToken::new(),
+            false,
+            Instant::now(),
+            3,
+            1,
+            0,
+            5,
+            "bad statement",
+            "syntax error".to_string(),
+        );
+
+        assert_eq!(decision.failure_count, 1);
+        assert_eq!(decision.result, Err("syntax error".to_string()));
+        assert_eq!(decision.progress.len(), 2);
+        assert_eq!(decision.progress[0].status, SqlFileStatus::StatementFailed);
+        assert_eq!(decision.progress[1].status, SqlFileStatus::Error);
+        assert_eq!(decision.progress[1].error, Some("syntax error".to_string()));
+    }
+
+    #[test]
+    fn cancelled_in_flight_error_does_not_increment_failure_count() {
+        let token = CancellationToken::new();
+        token.cancel();
+
+        let decision = statement_error_decision(
+            "exec-1",
+            &token,
+            false,
+            Instant::now(),
+            2,
+            1,
+            4,
+            9,
+            "slow statement",
+            "Query canceled".to_string(),
+        );
+
+        assert_eq!(decision.failure_count, 4);
+        assert_eq!(decision.result, Ok(true));
+        assert_eq!(decision.progress.len(), 1);
+        assert_eq!(decision.progress[0].status, SqlFileStatus::Cancelled);
+        assert_eq!(decision.progress[0].failure_count, 4);
+        assert_eq!(decision.progress[0].error, None);
+    }
+
+    #[test]
+    fn progress_payload_serializes_camel_case_status() {
+        let progress =
+            sql_file_progress("exec-1", SqlFileStatus::StatementDone, 1, 1, 0, 3, Instant::now(), "select 1", None);
+
+        let value = serde_json::to_value(progress).unwrap();
+
+        assert_eq!(value["executionId"], "exec-1");
+        assert_eq!(value["statementIndex"], 1);
+        assert_eq!(value["successCount"], 1);
+        assert_eq!(value["failureCount"], 0);
+        assert_eq!(value["affectedRows"], 3);
+        assert_eq!(value["statementSummary"], "select 1");
+        assert_eq!(value["status"], "statementDone");
+        assert!(value.get("execution_id").is_none());
+    }
+
+    #[test]
+    fn supports_connection_level_database_bootstrap_for_mysql_like_targets() {
+        assert!(crate::sql::supports_connection_level_database_bootstrap_target(&DatabaseType::Mysql, None));
+        assert!(crate::sql::supports_connection_level_database_bootstrap_target(&DatabaseType::Doris, None));
+        assert!(crate::sql::supports_connection_level_database_bootstrap_target(&DatabaseType::Goldendb, None));
+        assert!(crate::sql::supports_connection_level_database_bootstrap_target(
+            &DatabaseType::Mysql,
+            Some("selectdb")
+        ));
+        assert!(crate::sql::supports_connection_level_database_bootstrap_target(
+            &DatabaseType::Mysql,
+            Some("oceanbase")
+        ));
+    }
+
+    #[test]
+    fn excludes_non_mysql_bootstrap_targets() {
+        assert!(!crate::sql::supports_connection_level_database_bootstrap_target(&DatabaseType::Postgres, None));
+        assert!(
+            !crate::sql::supports_connection_level_database_bootstrap_target(&DatabaseType::ManticoreSearch, None,)
+        );
+        assert!(
+            !crate::sql::supports_connection_level_database_bootstrap_target(&DatabaseType::OceanbaseOracle, None,)
+        );
+    }
+
+    #[test]
+    fn mysql_like_sql_file_without_selected_database_requires_bootstrap_context() {
+        assert!(mysql_like_sql_file_can_execute_without_selected_database(
+            "SET NAMES utf8mb4;\nCREATE DATABASE app_db;\n-- switch tenant\nUSE app_db;\nCREATE TABLE users(id INT)"
+        ));
+        assert!(!mysql_like_sql_file_can_execute_without_selected_database(
+            "CREATE DATABASE app_db;\nCREATE TABLE users(id INT)"
+        ));
+        assert!(!mysql_like_sql_file_can_execute_without_selected_database(
+            "CREATE DATABASE app_db;\nUSE app_db SELECT 1;\nCREATE TABLE users(id INT)"
+        ));
+    }
+
+    #[test]
+    fn parses_mysql_use_database_targets() {
+        assert_eq!(mysql_use_database_target("USE app_db"), Some("app_db".to_string()));
+        assert_eq!(mysql_use_database_target(" use `app-db` ; "), Some("app-db".to_string()));
+        assert_eq!(mysql_use_database_target(r#"USE "tenant""01""#), Some(r#"tenant"01"#.to_string()));
+        assert_eq!(mysql_use_database_target("USE [tenant]]01]"), Some("tenant]01".to_string()));
+        assert_eq!(mysql_use_database_target("USE app_db; -- switch tenant"), Some("app_db".to_string()));
+        assert_eq!(mysql_use_database_target("-- switch tenant\nUSE app_db"), Some("app_db".to_string()));
+    }
+
+    #[test]
+    fn ignores_non_terminal_use_statements() {
+        assert_eq!(mysql_use_database_target("SELECT 1"), None);
+        assert_eq!(mysql_use_database_target("USE"), None);
+        assert_eq!(mysql_use_database_target("USE app_db SELECT 1"), None);
+    }
+}
diff --git a/crates/dbx-core/src/sql_risk.rs b/crates/dbx-core/src/sql_risk.rs
new file mode 100644
index 0000000..629f37c
--- /dev/null
+++ b/crates/dbx-core/src/sql_risk.rs
@@ -0,0 +1,331 @@
+use serde::{Deserialize, Serialize};
+use sqlparser::ast::{Query, SetExpr, Statement};
+use sqlparser::dialect::{
+    ClickHouseDialect, DuckDbDialect, GenericDialect, MsSqlDialect, MySqlDialect, PostgreSqlDialect, SQLiteDialect,
+};
+use sqlparser::parser::Parser;
+
+use crate::models::connection::DatabaseType;
+
+/// SQL risk level for agent tool safety classification.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum SqlRisk {
+    /// SELECT, SHOW, DESCRIBE, EXPLAIN, WITH (pure read CTE)
+    ReadOnly,
+    /// INSERT, UPDATE, DELETE, MERGE, REPLACE, CALL/EXEC
+    Write,
+    /// CREATE, ALTER, DROP, TRUNCATE, GRANT, REVOKE
+    Ddl,
+    /// BEGIN, COMMIT, ROLLBACK should not be issued by agent
+    Transaction,
+}
+
+impl std::fmt::Display for SqlRisk {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SqlRisk::ReadOnly => write!(f, "read-only"),
+            SqlRisk::Write => write!(f, "write"),
+            SqlRisk::Ddl => write!(f, "DDL"),
+            SqlRisk::Transaction => write!(f, "transaction"),
+        }
+    }
+}
+
+/// Normalize database dialect string to a canonical form for sqlparser.
+/// Mirrors the logic in `sql_analysis::normalize_dialect`.
+fn normalize_dialect(dialect: &str) -> &'static str {
+    match dialect.to_ascii_lowercase().as_str() {
+        "postgres" | "postgresql" | "redshift" | "opengauss" | "gaussdb" | "kingbase" | "highgo" | "vastbase"
+        | "kwdb" => "postgres",
+        "mysql" | "mariadb" | "doris" | "starrocks" | "manticoresearch" | "oceanbase" => "mysql",
+        "sqlite" => "sqlite",
+        "sqlserver" | "mssql" => "sqlserver",
+        "clickhouse" => "clickhouse",
+        "duckdb" => "duckdb",
+        _ => "generic",
+    }
+}
+
+/// Resolve dialect string to a sqlparser Dialect trait object.
+fn resolve_dialect(dialect: &str) -> Box<dyn sqlparser::dialect::Dialect> {
+    match dialect {
+        "postgres" => Box::new(PostgreSqlDialect {}),
+        "mysql" => Box::new(MySqlDialect {}),
+        "sqlite" => Box::new(SQLiteDialect {}),
+        "sqlserver" => Box::new(MsSqlDialect {}),
+        "clickhouse" => Box::new(ClickHouseDialect {}),
+        "duckdb" => Box::new(DuckDbDialect {}),
+        _ => Box::new(GenericDialect {}),
+    }
+}
+
+/// Classify a single SQL statement into a risk level using AST analysis.
+fn classify_statement(stmt: &Statement, detect_select_into: bool) -> SqlRisk {
+    match stmt {
+        // Pure reads
+        Statement::Query(query) => {
+            if detect_select_into && query_contains_select_into(query) {
+                SqlRisk::Write
+            } else {
+                SqlRisk::ReadOnly
+            }
+        }
+        Statement::Explain { analyze, statement, .. } => {
+            if *analyze {
+                classify_statement(statement, detect_select_into)
+            } else {
+                SqlRisk::ReadOnly
+            }
+        }
+        Statement::ExplainTable { .. } => SqlRisk::ReadOnly,
+
+        // Show/Describe variants
+        Statement::ShowTables { .. }
+        | Statement::ShowColumns { .. }
+        | Statement::ShowDatabases { .. }
+        | Statement::ShowSchemas { .. }
+        | Statement::ShowCreate { .. }
+        | Statement::ShowVariables { .. }
+        | Statement::ShowStatus { .. }
+        | Statement::ShowProcessList { .. } => SqlRisk::ReadOnly,
+
+        // Write operations
+        Statement::Insert { .. } | Statement::Update { .. } | Statement::Delete { .. } | Statement::Merge { .. } => {
+            SqlRisk::Write
+        }
+
+        // DDL operations
+        Statement::CreateTable { .. }
+        | Statement::CreateView { .. }
+        | Statement::CreateIndex { .. }
+        | Statement::CreateSchema { .. }
+        | Statement::CreateSequence { .. }
+        | Statement::CreateRole { .. }
+        | Statement::CreateType { .. }
+        | Statement::AlterTable { .. }
+        | Statement::AlterIndex { .. }
+        | Statement::AlterView { .. }
+        | Statement::Drop { .. }
+        | Statement::Truncate { .. } => SqlRisk::Ddl,
+
+        // Grant/Revoke
+        Statement::Grant { .. } | Statement::Revoke { .. } => SqlRisk::Ddl,
+
+        // Transaction control
+        Statement::StartTransaction { .. } | Statement::Commit { .. } | Statement::Rollback { .. } => {
+            SqlRisk::Transaction
+        }
+
+        // COPY FROM mutates data; keep COPY conservative because sqlparser does
+        // not expose enough dialect-specific direction detail here.
+        Statement::Copy { .. } => SqlRisk::Write,
+
+        // SQLite/DuckDB PRAGMA statements can mutate database/session state.
+        Statement::Pragma { .. } => SqlRisk::Write,
+
+        // Catch-all: conservative write classification
+        _ => SqlRisk::Write,
+    }
+}
+
+fn query_contains_select_into(query: &Query) -> bool {
+    set_expr_contains_select_into(&query.body)
+}
+
+fn set_expr_contains_select_into(expr: &SetExpr) -> bool {
+    match expr {
+        SetExpr::Select(select) => select.into.is_some(),
+        SetExpr::Query(query) => query_contains_select_into(query),
+        SetExpr::SetOperation { left, right, .. } => {
+            set_expr_contains_select_into(left) || set_expr_contains_select_into(right)
+        }
+        _ => false,
+    }
+}
+
+/// Classify SQL risk using sqlparser AST analysis.
+///
+/// If parsing fails (non-standard SQL, non-SQL databases), falls back to
+/// keyword-based `query_execution_sql::is_write_sql()`.
+///
+/// Multi-statement input: returns the highest risk level across all statements.
+pub fn classify_sql_risk(sql: &str, dialect: &str) -> Result<SqlRisk, String> {
+    let normalized = normalize_dialect(dialect);
+    classify_sql_risk_with_database(sql, normalized, None)
+}
+
+/// Classify SQL risk using both the parser dialect and the concrete database
+/// type so dialect-specific write forms cannot be mistaken for read queries.
+pub fn classify_sql_risk_for_database(sql: &str, database_type: DatabaseType) -> Result<SqlRisk, String> {
+    let database_type_name = format!("{database_type:?}");
+    let normalized = normalize_dialect(&database_type_name);
+    classify_sql_risk_with_database(sql, normalized, Some(database_type))
+}
+
+fn classify_sql_risk_with_database(
+    sql: &str,
+    normalized_dialect: &str,
+    database_type: Option<DatabaseType>,
+) -> Result<SqlRisk, String> {
+    let parser_dialect = resolve_dialect(normalized_dialect);
+    let detect_select_into = database_type.is_none();
+    let has_dialect_specific_write = database_type
+        .is_some_and(|database_type| crate::query_execution_sql::has_dialect_specific_write(sql, database_type));
+
+    match Parser::parse_sql(parser_dialect.as_ref(), sql) {
+        Ok(stmts) if !stmts.is_empty() => {
+            let mut max_risk = SqlRisk::ReadOnly;
+            for stmt in &stmts {
+                let risk = classify_statement(stmt, detect_select_into);
+                if risk as u8 > max_risk as u8 {
+                    max_risk = risk;
+                }
+            }
+            if max_risk == SqlRisk::ReadOnly && has_dialect_specific_write {
+                Ok(SqlRisk::Write)
+            } else {
+                Ok(max_risk)
+            }
+        }
+        _ => {
+            // Fallback: keyword-based classification
+            let is_write = database_type.map_or_else(
+                || crate::query_execution_sql::is_write_sql(sql),
+                |database_type| crate::query_execution_sql::is_write_sql_for_database(sql, database_type),
+            );
+            if is_write {
+                Ok(SqlRisk::Write)
+            } else {
+                Ok(SqlRisk::ReadOnly)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn classify_select_statements() {
+        assert_eq!(classify_sql_risk("SELECT * FROM users", "postgres").unwrap(), SqlRisk::ReadOnly);
+        assert_eq!(
+            classify_sql_risk("SELECT id, name FROM users WHERE active = true", "mysql").unwrap(),
+            SqlRisk::ReadOnly
+        );
+        assert_eq!(classify_sql_risk("SHOW TABLES", "mysql").unwrap(), SqlRisk::ReadOnly);
+        assert_eq!(classify_sql_risk("DESCRIBE users", "mysql").unwrap(), SqlRisk::ReadOnly);
+        assert_eq!(classify_sql_risk("EXPLAIN SELECT * FROM users", "postgres").unwrap(), SqlRisk::ReadOnly);
+    }
+
+    #[test]
+    fn classify_cte_read() {
+        assert_eq!(
+            classify_sql_risk("WITH cte AS (SELECT 1) SELECT * FROM cte", "postgres").unwrap(),
+            SqlRisk::ReadOnly
+        );
+    }
+
+    #[test]
+    fn classify_write_statements() {
+        assert_eq!(classify_sql_risk("INSERT INTO users VALUES (1)", "postgres").unwrap(), SqlRisk::Write);
+        assert_eq!(classify_sql_risk("UPDATE users SET name = 'x'", "postgres").unwrap(), SqlRisk::Write);
+        assert_eq!(classify_sql_risk("DELETE FROM users", "postgres").unwrap(), SqlRisk::Write);
+        assert_eq!(classify_sql_risk("EXPLAIN ANALYZE DELETE FROM users", "postgres").unwrap(), SqlRisk::Write);
+        assert_eq!(classify_sql_risk("SELECT * INTO backup_users FROM users", "postgres").unwrap(), SqlRisk::Write);
+        assert_eq!(
+            classify_sql_risk("SELECT * FROM users INTO OUTFILE '/tmp/users.csv'", "mysql").unwrap(),
+            SqlRisk::Write
+        );
+        assert_eq!(classify_sql_risk("/*! DELETE FROM users */", "mysql").unwrap(), SqlRisk::Write);
+    }
+
+    #[test]
+    fn classify_dialect_specific_select_into_as_write() {
+        for sql in [
+            "SELECT 3156 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt'",
+            "SELECT 3156 INTO DUMPFILE '/var/lib/mysql-files/dbx_ro_probe.bin'",
+        ] {
+            assert_eq!(classify_sql_risk_for_database(sql, DatabaseType::Mysql).unwrap(), SqlRisk::Write);
+        }
+
+        for database_type in [
+            DatabaseType::Postgres,
+            DatabaseType::Redshift,
+            DatabaseType::Gaussdb,
+            DatabaseType::OpenGauss,
+            DatabaseType::Kingbase,
+            DatabaseType::Highgo,
+            DatabaseType::Vastbase,
+            DatabaseType::Kwdb,
+        ] {
+            assert_eq!(
+                classify_sql_risk_for_database("SELECT * INTO copied_users FROM users", database_type).unwrap(),
+                SqlRisk::Write,
+                "expected PostgreSQL-family SELECT INTO to be a write for {database_type:?}"
+            );
+        }
+        assert_eq!(
+            classify_sql_risk_for_database("SELECT * INTO #copied_users FROM users", DatabaseType::SqlServer).unwrap(),
+            SqlRisk::Write
+        );
+        assert_eq!(
+            classify_sql_risk_for_database(
+                "SELECT 3156 /*!50000 INTO OUTFILE '/var/lib/mysql-files/dbx_ro_probe.txt' */",
+                DatabaseType::Mysql,
+            )
+            .unwrap(),
+            SqlRisk::Write
+        );
+    }
+
+    #[test]
+    fn typed_classification_preserves_existing_risk_levels() {
+        assert_eq!(
+            classify_sql_risk_for_database("SELECT * FROM users", DatabaseType::Postgres).unwrap(),
+            SqlRisk::ReadOnly
+        );
+        assert_eq!(
+            classify_sql_risk_for_database("CREATE TABLE users (id INT)", DatabaseType::Postgres).unwrap(),
+            SqlRisk::Ddl
+        );
+        assert_eq!(
+            classify_sql_risk_for_database("SELECT 1 INTO unsupported", DatabaseType::Sqlite).unwrap(),
+            SqlRisk::ReadOnly
+        );
+    }
+
+    #[test]
+    fn classify_ddl_statements() {
+        assert_eq!(classify_sql_risk("CREATE TABLE users (id INT)", "postgres").unwrap(), SqlRisk::Ddl);
+        assert_eq!(classify_sql_risk("DROP TABLE users", "postgres").unwrap(), SqlRisk::Ddl);
+        assert_eq!(classify_sql_risk("ALTER TABLE users ADD COLUMN age INT", "postgres").unwrap(), SqlRisk::Ddl);
+        assert_eq!(classify_sql_risk("TRUNCATE TABLE users", "postgres").unwrap(), SqlRisk::Ddl);
+    }
+
+    #[test]
+    fn classify_transaction_statements() {
+        assert_eq!(classify_sql_risk("BEGIN", "postgres").unwrap(), SqlRisk::Transaction);
+        assert_eq!(classify_sql_risk("COMMIT", "postgres").unwrap(), SqlRisk::Transaction);
+        assert_eq!(classify_sql_risk("ROLLBACK", "postgres").unwrap(), SqlRisk::Transaction);
+    }
+
+    #[test]
+    fn classify_multi_statement_returns_highest_risk() {
+        // SELECT + INSERT = Write
+        assert_eq!(classify_sql_risk("SELECT 1; INSERT INTO users VALUES (1)", "postgres").unwrap(), SqlRisk::Write);
+    }
+
+    #[test]
+    fn classify_fallback_on_parse_error() {
+        // Non-standard SQL should fall back to keyword matching
+        assert_eq!(classify_sql_risk("SELECT * FROM users", "generic").unwrap(), SqlRisk::ReadOnly);
+    }
+
+    #[test]
+    fn classify_unknown_statement_is_write() {
+        // Statements not explicitly handled should be conservative (Write)
+        // This depends on sqlparser's coverage, but we can test the catch-all
+        assert_eq!(classify_sql_risk("GRANT SELECT ON users TO admin", "postgres").unwrap(), SqlRisk::Ddl);
+    }
+}
diff --git a/crates/dbx-core/src/sqlite_backup.rs b/crates/dbx-core/src/sqlite_backup.rs
new file mode 100644
index 0000000..5d5bedb
--- /dev/null
+++ b/crates/dbx-core/src/sqlite_backup.rs
@@ -0,0 +1,188 @@
+use std::path::{Path, PathBuf};
+
+use rusqlite::DatabaseName;
+
+use crate::db::sqlite::{is_memory_database_path, SqliteHandle};
+use crate::path_utils::expand_tilde;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SqliteBackupOptions {
+    pub source_path: String,
+    pub destination_path: String,
+}
+
+pub async fn backup_sqlite_database(pool: SqliteHandle, options: SqliteBackupOptions) -> Result<(), String> {
+    let destination = prepare_destination_path(&options)?;
+    let temp = backup_temp_path(&destination);
+    tokio::task::spawn_blocking(move || {
+        pool.with_connection(|conn| {
+            conn.backup(DatabaseName::Main, &temp, None).map_err(|e| format!("SQLite backup failed: {e}"))
+        })?;
+        replace_backup_file(&temp, &destination)
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+fn prepare_destination_path(options: &SqliteBackupOptions) -> Result<PathBuf, String> {
+    let destination = normalize_user_path(&options.destination_path, "Destination path is empty")?;
+    ensure_no_nul(&options.destination_path)?;
+
+    if let Some(parent) = destination.parent() {
+        if !parent.as_os_str().is_empty() {
+            std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+        }
+    }
+    if destination.is_dir() {
+        return Err("Backup destination must be a file".to_string());
+    }
+
+    let source = options.source_path.trim();
+    if !is_memory_database_path(source) && !source.is_empty() {
+        ensure_no_nul(source)?;
+        let source = normalize_user_path(source, "Source path is empty")?;
+        if paths_match(&source, &destination)? {
+            return Err("Backup destination must be different from the source database file".to_string());
+        }
+    }
+
+    Ok(destination)
+}
+
+fn backup_temp_path(destination: &Path) -> PathBuf {
+    let file_name = destination.file_name().and_then(|name| name.to_str()).unwrap_or("backup.db");
+    destination.with_file_name(format!("{file_name}.tmp-{}", uuid::Uuid::new_v4()))
+}
+
+fn replace_backup_file(temp: &Path, destination: &Path) -> Result<(), String> {
+    if destination.exists() {
+        let backup = existing_backup_path(destination);
+        std::fs::rename(destination, &backup)
+            .map_err(|e| format!("Failed to back up existing destination file: {e}"))?;
+        match std::fs::rename(temp, destination) {
+            Ok(()) => {
+                std::fs::remove_file(&backup).ok();
+                Ok(())
+            }
+            Err(err) => {
+                let _ = std::fs::rename(&backup, destination);
+                Err(format!("Failed to replace backup destination: {err}"))
+            }
+        }
+    } else {
+        std::fs::rename(temp, destination).map_err(|e| format!("Failed to move backup into place: {e}"))
+    }
+}
+
+fn existing_backup_path(destination: &Path) -> PathBuf {
+    let file_name = destination.file_name().and_then(|name| name.to_str()).unwrap_or("backup.db");
+    destination.with_file_name(format!("{file_name}.backup-{}", uuid::Uuid::new_v4()))
+}
+
+fn normalize_user_path(path: &str, empty_message: &str) -> Result<PathBuf, String> {
+    let trimmed = path.trim();
+    if trimmed.is_empty() {
+        return Err(empty_message.to_string());
+    }
+    Ok(PathBuf::from(expand_tilde(trimmed)))
+}
+
+fn ensure_no_nul(path: &str) -> Result<(), String> {
+    if path.contains('\0') {
+        Err("Path contains an invalid NUL byte".to_string())
+    } else {
+        Ok(())
+    }
+}
+
+fn paths_match(a: &Path, b: &Path) -> Result<bool, String> {
+    Ok(canonicalize_existing_or_parent(a)? == canonicalize_existing_or_parent(b)?)
+}
+
+fn canonicalize_existing_or_parent(path: &Path) -> Result<PathBuf, String> {
+    if let Ok(canonical) = std::fs::canonicalize(path) {
+        return Ok(canonical);
+    }
+    let parent = path.parent().filter(|parent| !parent.as_os_str().is_empty()).unwrap_or_else(|| Path::new("."));
+    let parent = std::fs::canonicalize(parent).map_err(|e| e.to_string())?;
+    Ok(parent.join(path.file_name().ok_or_else(|| "Path is missing a file name".to_string())?))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::db::sqlite::{connect_path, execute_query};
+
+    #[tokio::test]
+    async fn backup_sqlite_database_copies_memory_database() {
+        let dir = std::env::temp_dir().join(format!("dbx-sqlite-backup-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        let destination = dir.join("backup.db");
+        let pool = connect_path(":memory:").await.expect("connect memory sqlite");
+        execute_query(&pool, "CREATE TABLE users (name TEXT); INSERT INTO users VALUES ('Ada');")
+            .await
+            .expect("seed memory database");
+
+        backup_sqlite_database(
+            pool,
+            SqliteBackupOptions {
+                source_path: ":memory:".to_string(),
+                destination_path: destination.to_string_lossy().to_string(),
+            },
+        )
+        .await
+        .expect("backup memory database");
+
+        let backup = connect_path(destination.to_string_lossy().as_ref()).await.expect("open backup");
+        let result = execute_query(&backup, "SELECT name FROM users").await.expect("query backup");
+        assert_eq!(result.rows[0][0], serde_json::json!("Ada"));
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn prepare_destination_rejects_same_file() {
+        let dir = std::env::temp_dir().join(format!("dbx-sqlite-backup-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        let source = dir.join("source.db");
+        std::fs::write(&source, "").expect("create source");
+
+        let result = prepare_destination_path(&SqliteBackupOptions {
+            source_path: source.to_string_lossy().to_string(),
+            destination_path: source.to_string_lossy().to_string(),
+        });
+
+        assert!(result.expect_err("same file should be rejected").contains("different"));
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn prepare_destination_creates_missing_parent_dir() {
+        let dir = std::env::temp_dir().join(format!("dbx-sqlite-backup-{}", uuid::Uuid::new_v4()));
+        let destination = dir.join("nested").join("backup.db");
+
+        let result = prepare_destination_path(&SqliteBackupOptions {
+            source_path: ":memory:".to_string(),
+            destination_path: destination.to_string_lossy().to_string(),
+        })
+        .expect("prepare destination");
+
+        assert_eq!(result, destination);
+        assert!(destination.parent().expect("parent").is_dir());
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn replace_backup_file_restores_existing_destination_when_replace_fails() {
+        let dir = std::env::temp_dir().join(format!("dbx-sqlite-backup-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        let destination = dir.join("backup.db");
+        let missing_temp = dir.join("missing.db");
+        std::fs::write(&destination, "existing").expect("create destination");
+
+        let result = replace_backup_file(&missing_temp, &destination);
+
+        assert!(result.expect_err("replace should fail").contains("replace"));
+        assert_eq!(std::fs::read_to_string(&destination).expect("read destination"), "existing");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}
diff --git a/crates/dbx-core/src/sqlserver_temporal.rs b/crates/dbx-core/src/sqlserver_temporal.rs
new file mode 100644
index 0000000..a562c56
--- /dev/null
+++ b/crates/dbx-core/src/sqlserver_temporal.rs
@@ -0,0 +1,223 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SqlServerTemporalKind {
+    Date,
+    Time { scale: u8 },
+    SmallDateTime,
+    DateTime,
+    DateTime2 { scale: u8 },
+    DateTimeOffset { scale: u8 },
+}
+
+pub fn format_sqlserver_datetime_display(value: &chrono::NaiveDateTime) -> String {
+    let rounded = value.checked_add_signed(chrono::Duration::microseconds(500)).unwrap_or(*value);
+    let base = rounded.format("%Y-%m-%d %H:%M:%S").to_string();
+    let millis = rounded.and_utc().timestamp_subsec_millis();
+    if millis == 0 {
+        base
+    } else {
+        format!("{base}.{millis:03}")
+    }
+}
+
+pub fn normalize_sqlserver_temporal_literal(value: &str, column_type: Option<&str>) -> Option<String> {
+    let kind = sqlserver_temporal_kind(column_type?)?;
+    let parts = parse_sqlserver_temporal(value)?;
+    match kind {
+        SqlServerTemporalKind::Date => Some(parts.date),
+        SqlServerTemporalKind::Time { scale } => Some(format_sqlserver_time_text(&parts.time, scale)),
+        SqlServerTemporalKind::SmallDateTime => {
+            Some(format!("{} {}", parts.date, format_sqlserver_time_text(&parts.time, 0)))
+        }
+        SqlServerTemporalKind::DateTime => Some(format_sqlserver_datetime_parts(&parts.date, &parts.time)),
+        SqlServerTemporalKind::DateTime2 { scale } => {
+            Some(format!("{} {}", parts.date, format_sqlserver_time_text(&parts.time, scale)))
+        }
+        SqlServerTemporalKind::DateTimeOffset { scale } => {
+            let offset = parts.offset?;
+            Some(format!("{} {}{}", parts.date, format_sqlserver_time_text(&parts.time, scale), offset))
+        }
+    }
+}
+
+fn sqlserver_temporal_kind(column_type: &str) -> Option<SqlServerTemporalKind> {
+    let lower = column_type.trim().to_ascii_lowercase();
+    let base = lower.split(['(', ' ', '\t', '\n']).next().unwrap_or("");
+    match base {
+        "date" | "daten" => Some(SqlServerTemporalKind::Date),
+        "smalldatetime" => Some(SqlServerTemporalKind::SmallDateTime),
+        "datetime" | "datetimen" => Some(SqlServerTemporalKind::DateTime),
+        "datetime4" => Some(SqlServerTemporalKind::SmallDateTime),
+        "datetime2" => Some(SqlServerTemporalKind::DateTime2 { scale: temporal_scale(&lower).unwrap_or(7) }),
+        "time" | "timen" => Some(SqlServerTemporalKind::Time { scale: temporal_scale(&lower).unwrap_or(7) }),
+        "datetimeoffset" | "datetimeoffsetn" => {
+            Some(SqlServerTemporalKind::DateTimeOffset { scale: temporal_scale(&lower).unwrap_or(7) })
+        }
+        _ => None,
+    }
+}
+
+fn temporal_scale(column_type: &str) -> Option<u8> {
+    let start = column_type.find('(')?;
+    let end = column_type[start + 1..].find(')')? + start + 1;
+    let scale = column_type[start + 1..end].trim().parse::<u8>().ok()?;
+    Some(scale.min(7))
+}
+
+struct SqlServerTemporalParts {
+    date: String,
+    time: String,
+    offset: Option<String>,
+}
+
+fn parse_sqlserver_temporal(value: &str) -> Option<SqlServerTemporalParts> {
+    let trimmed = value.trim();
+    let bytes = trimmed.as_bytes();
+    if bytes.len() >= 10 && is_date_prefix(bytes) {
+        let date = trimmed[..10].to_string();
+        let mut rest = trimmed[10..].trim_start();
+        if rest.starts_with('T') || rest.starts_with('t') {
+            rest = rest[1..].trim_start();
+        }
+        if rest.is_empty() {
+            return Some(SqlServerTemporalParts { date, time: "00:00:00".to_string(), offset: None });
+        }
+        let (time, offset) = split_time_and_offset(rest)?;
+        return Some(SqlServerTemporalParts { date, time, offset });
+    }
+
+    let (time, offset) = split_time_and_offset(trimmed)?;
+    Some(SqlServerTemporalParts { date: "1900-01-01".to_string(), time, offset })
+}
+
+fn is_date_prefix(bytes: &[u8]) -> bool {
+    bytes.len() >= 10
+        && bytes[4] == b'-'
+        && bytes[7] == b'-'
+        && bytes[0..4].iter().all(u8::is_ascii_digit)
+        && bytes[5..7].iter().all(u8::is_ascii_digit)
+        && bytes[8..10].iter().all(u8::is_ascii_digit)
+}
+
+fn split_time_and_offset(value: &str) -> Option<(String, Option<String>)> {
+    if value.len() < 8 {
+        return None;
+    }
+    let bytes = value.as_bytes();
+    if bytes.get(2) != Some(&b':') || bytes.get(5) != Some(&b':') {
+        return None;
+    }
+    if !bytes[0..2].iter().all(u8::is_ascii_digit)
+        || !bytes[3..5].iter().all(u8::is_ascii_digit)
+        || !bytes[6..8].iter().all(u8::is_ascii_digit)
+    {
+        return None;
+    }
+
+    let mut end = 8;
+    if bytes.get(end) == Some(&b'.') {
+        end += 1;
+        let fraction_start = end;
+        while end < bytes.len() && bytes[end].is_ascii_digit() {
+            end += 1;
+        }
+        if end == fraction_start {
+            return None;
+        }
+    }
+
+    let time = value[..end].to_string();
+    let suffix = value[end..].trim();
+    if suffix.is_empty() {
+        return Some((time, None));
+    }
+    if suffix.eq_ignore_ascii_case("z") {
+        return Some((time, Some("+00:00".to_string())));
+    }
+    if is_timezone_offset(suffix) {
+        return Some((time, Some(suffix.to_string())));
+    }
+    None
+}
+
+fn is_timezone_offset(value: &str) -> bool {
+    let bytes = value.as_bytes();
+    bytes.len() == 6
+        && matches!(bytes[0], b'+' | b'-')
+        && bytes[3] == b':'
+        && bytes[1].is_ascii_digit()
+        && bytes[2].is_ascii_digit()
+        && bytes[4].is_ascii_digit()
+        && bytes[5].is_ascii_digit()
+}
+
+fn format_sqlserver_time_text(value: &str, scale: u8) -> String {
+    let (base, fraction) = value.split_once('.').unwrap_or((value, ""));
+    if scale == 0 {
+        return base.to_string();
+    }
+    let mut digits = fraction.chars().take_while(|ch| ch.is_ascii_digit()).take(scale as usize).collect::<String>();
+    while digits.len() < scale as usize {
+        digits.push('0');
+    }
+    if digits.chars().all(|ch| ch == '0') {
+        base.to_string()
+    } else {
+        format!("{base}.{digits}")
+    }
+}
+
+fn format_sqlserver_datetime_parts(date: &str, time: &str) -> String {
+    let value = format!("{date} {time}");
+    chrono::NaiveDateTime::parse_from_str(&value, "%Y-%m-%d %H:%M:%S%.f")
+        .map(|value| format_sqlserver_datetime_display(&value))
+        .unwrap_or_else(|_| format!("{date} {}", format_sqlserver_time_text(time, 3)))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn formats_sqlserver_datetime_display_with_millisecond_precision() {
+        let value =
+            chrono::NaiveDate::from_ymd_opt(2026, 6, 29).unwrap().and_hms_nano_opt(10, 11, 12, 896_666_666).unwrap();
+
+        assert_eq!(format_sqlserver_datetime_display(&value), "2026-06-29 10:11:12.897");
+
+        let boundary =
+            chrono::NaiveDate::from_ymd_opt(2026, 6, 29).unwrap().and_hms_nano_opt(23, 59, 59, 999_600_000).unwrap();
+        assert_eq!(format_sqlserver_datetime_display(&boundary), "2026-06-30 00:00:00");
+    }
+
+    #[test]
+    fn normalizes_sqlserver_datetime_literals_by_column_type() {
+        assert_eq!(
+            normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.896666666", Some("datetime")),
+            Some("2026-06-29 10:11:12.897".to_string())
+        );
+        assert_eq!(
+            normalize_sqlserver_temporal_literal("2026-06-29T10:11:12.8966666Z", Some("datetime2(7)")),
+            Some("2026-06-29 10:11:12.8966666".to_string())
+        );
+        assert_eq!(
+            normalize_sqlserver_temporal_literal("2026-06-29T10:11:12.8966666Z", Some("datetime2(3)")),
+            Some("2026-06-29 10:11:12.896".to_string())
+        );
+        assert_eq!(
+            normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.8966666+08:00", Some("datetimeoffset(4)")),
+            Some("2026-06-29 10:11:12.8966+08:00".to_string())
+        );
+        assert_eq!(
+            normalize_sqlserver_temporal_literal("10:11:12.8966666", Some("time(2)")),
+            Some("10:11:12.89".to_string())
+        );
+        assert_eq!(
+            normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.8966666", Some("date")),
+            Some("2026-06-29".to_string())
+        );
+        assert_eq!(
+            normalize_sqlserver_temporal_literal("2026-06-29 10:11:12.8966666", Some("smalldatetime")),
+            Some("2026-06-29 10:11:12".to_string())
+        );
+    }
+}
diff --git a/crates/dbx-core/src/ssh_config.rs b/crates/dbx-core/src/ssh_config.rs
new file mode 100644
index 0000000..2429e5c
--- /dev/null
+++ b/crates/dbx-core/src/ssh_config.rs
@@ -0,0 +1,289 @@
+use serde::Serialize;
+
+use crate::models::connection::SshTunnelConfig;
+use crate::path_utils::expand_tilde;
+
+/// Sentinel values the frontend fills in when the user leaves a field blank
+/// (see `normalizeSshTunnel` / `defaultSshTunnel` in ConnectionDialog.vue).
+/// There is no way to distinguish "user explicitly typed 22" from "field was
+/// left empty and defaulted to 22", so we treat these as "unset" for the
+/// purpose of filling in values from `~/.ssh/config`.
+const DEFAULT_USER_SENTINEL: &str = "root";
+const DEFAULT_PORT_SENTINEL: u16 = 22;
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+pub struct SshConfigHostEntry {
+    pub alias: String,
+    pub host_name: Option<String>,
+    pub port: Option<u16>,
+    pub user: Option<String>,
+    pub identity_file: Option<String>,
+}
+
+/// Reads and parses `~/.ssh/config`. Returns an empty list (not an error) if
+/// the file does not exist, since that's a normal state for users without
+/// an SSH config.
+pub fn list_hosts() -> Result<Vec<SshConfigHostEntry>, String> {
+    let path = expand_tilde("~/.ssh/config");
+    match std::fs::read_to_string(&path) {
+        Ok(content) => Ok(parse_ssh_config(&content)),
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => Ok(Vec::new()),
+        Err(err) => Err(format!("Failed to read {path}: {err}")),
+    }
+}
+
+pub fn find_host(alias: &str) -> Option<SshConfigHostEntry> {
+    list_hosts().ok()?.into_iter().find(|entry| entry.alias == alias)
+}
+
+/// Fills in `host`, `user`, `port`, and `key_path` from a matching `~/.ssh/config`
+/// `Host` block, without overwriting values the user has explicitly set.
+///
+/// Only `ssh.host` is matched against config aliases; `user`/`port`/`key_path`
+/// are filled in from that same matched entry. Values already present on
+/// `ssh` win, except for `user`/`port` which use the sentinel defaults above
+/// to detect "not actually set by the user".
+pub fn resolve_ssh_tunnel_config(ssh: &SshTunnelConfig) -> SshTunnelConfig {
+    match find_host(&ssh.host) {
+        Some(entry) => apply_host_entry(ssh, entry),
+        None => ssh.clone(),
+    }
+}
+
+/// Applies a resolved `~/.ssh/config` entry onto `ssh`, without overwriting
+/// values the user has explicitly set. `user`/`port` use the sentinel
+/// defaults above to detect "not actually set by the user".
+fn apply_host_entry(ssh: &SshTunnelConfig, entry: SshConfigHostEntry) -> SshTunnelConfig {
+    let mut resolved = ssh.clone();
+
+    if let Some(host_name) = entry.host_name {
+        resolved.host = host_name;
+    }
+    if resolved.user == DEFAULT_USER_SENTINEL {
+        if let Some(user) = entry.user {
+            resolved.user = user;
+        }
+    }
+    if resolved.port == DEFAULT_PORT_SENTINEL {
+        if let Some(port) = entry.port {
+            resolved.port = port;
+        }
+    }
+    if resolved.key_path.is_empty() {
+        if let Some(identity_file) = entry.identity_file {
+            resolved.key_path = identity_file;
+            // If the SSH config supplied the only usable credential, make the
+            // backend use it even when an older/default UI payload still says
+            // "password" with an empty password.
+            if resolved.auth_method.is_empty() || (resolved.auth_method == "password" && resolved.password.is_empty()) {
+                resolved.auth_method = "key".to_string();
+            }
+        }
+    }
+
+    resolved
+}
+
+/// Parses a minimal subset of OpenSSH client config syntax: `Host`, `HostName`,
+/// `Port`, `User`, `IdentityFile`. Wildcard host patterns (containing `*` or
+/// `?`) are skipped since they aren't usable as a literal alias in the host
+/// field. `Include` and other directives are not supported.
+fn parse_ssh_config(content: &str) -> Vec<SshConfigHostEntry> {
+    let mut entries: Vec<SshConfigHostEntry> = Vec::new();
+    let mut current_aliases: Vec<String> = Vec::new();
+
+    for raw_line in content.lines() {
+        let line = strip_comment(raw_line).trim();
+        if line.is_empty() {
+            continue;
+        }
+        let Some((keyword, value)) = split_directive(line) else {
+            continue;
+        };
+
+        match keyword.to_ascii_lowercase().as_str() {
+            "host" => {
+                current_aliases = value
+                    .split_whitespace()
+                    .filter(|alias| !alias.contains('*') && !alias.contains('?'))
+                    .map(str::to_string)
+                    .collect();
+                for alias in &current_aliases {
+                    entries.push(SshConfigHostEntry {
+                        alias: alias.clone(),
+                        host_name: None,
+                        port: None,
+                        user: None,
+                        identity_file: None,
+                    });
+                }
+            }
+            "hostname" => set_current_field(&mut entries, &current_aliases, |entry| {
+                entry.host_name = Some(value.to_string());
+            }),
+            "port" => {
+                if let Ok(port) = value.parse::<u16>() {
+                    set_current_field(&mut entries, &current_aliases, |entry| {
+                        entry.port = Some(port);
+                    });
+                }
+            }
+            "user" => set_current_field(&mut entries, &current_aliases, |entry| {
+                entry.user = Some(value.to_string());
+            }),
+            "identityfile" => set_current_field(&mut entries, &current_aliases, |entry| {
+                entry.identity_file = Some(value.to_string());
+            }),
+            _ => {}
+        }
+    }
+
+    entries
+}
+
+fn set_current_field(
+    entries: &mut [SshConfigHostEntry],
+    current_aliases: &[String],
+    apply: impl Fn(&mut SshConfigHostEntry),
+) {
+    for entry in entries.iter_mut() {
+        if current_aliases.contains(&entry.alias) {
+            apply(entry);
+        }
+    }
+}
+
+fn strip_comment(line: &str) -> &str {
+    match line.find('#') {
+        Some(index) => &line[..index],
+        None => line,
+    }
+}
+
+/// Splits a config line into `(keyword, value)`. OpenSSH allows the keyword
+/// and value to be separated by whitespace or a single `=`.
+fn split_directive(line: &str) -> Option<(&str, &str)> {
+    let line = line.trim();
+    let split_index = line.find(|c: char| c.is_whitespace() || c == '=')?;
+    let keyword = &line[..split_index];
+    let value = line[split_index..].trim_start_matches(|c: char| c.is_whitespace() || c == '=').trim();
+    if keyword.is_empty() || value.is_empty() {
+        return None;
+    }
+    Some((keyword, value))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn config(host: &str) -> SshTunnelConfig {
+        SshTunnelConfig {
+            profile_id: String::new(),
+            id: "1".to_string(),
+            name: String::new(),
+            enabled: true,
+            host: host.to_string(),
+            port: DEFAULT_PORT_SENTINEL,
+            user: DEFAULT_USER_SENTINEL.to_string(),
+            password: String::new(),
+            key_path: String::new(),
+            key_passphrase: String::new(),
+            connect_timeout_secs: 5,
+            expose_lan: false,
+            use_ssh_agent: false,
+            ssh_agent_sock_path: String::new(),
+            auth_method: "password".to_string(),
+        }
+    }
+
+    #[test]
+    fn parses_basic_host_block() {
+        let entries = parse_ssh_config(
+            "Host myserver\n  HostName 10.0.0.5\n  Port 2222\n  User deploy\n  IdentityFile ~/.ssh/id_ed25519\n",
+        );
+        assert_eq!(entries.len(), 1);
+        let entry = &entries[0];
+        assert_eq!(entry.alias, "myserver");
+        assert_eq!(entry.host_name, Some("10.0.0.5".to_string()));
+        assert_eq!(entry.port, Some(2222));
+        assert_eq!(entry.user, Some("deploy".to_string()));
+        assert_eq!(entry.identity_file, Some("~/.ssh/id_ed25519".to_string()));
+    }
+
+    #[test]
+    fn one_line_can_declare_multiple_aliases() {
+        let entries = parse_ssh_config("Host prod prod-alias\n  HostName 10.0.0.9\n");
+        assert_eq!(entries.len(), 2);
+        assert!(entries.iter().all(|entry| entry.host_name == Some("10.0.0.9".to_string())));
+        assert_eq!(entries[0].alias, "prod");
+        assert_eq!(entries[1].alias, "prod-alias");
+    }
+
+    #[test]
+    fn skips_wildcard_host_patterns() {
+        let entries = parse_ssh_config("Host *.example.com\n  User git\nHost real\n  User deploy\n");
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].alias, "real");
+    }
+
+    #[test]
+    fn ignores_comments_and_blank_lines() {
+        let entries = parse_ssh_config("# a comment\n\nHost myserver # inline comment\n  User deploy\n");
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].user, Some("deploy".to_string()));
+    }
+
+    fn entry(alias: &str) -> SshConfigHostEntry {
+        SshConfigHostEntry {
+            alias: alias.to_string(),
+            host_name: Some("10.0.0.5".to_string()),
+            port: Some(2222),
+            user: Some("deploy".to_string()),
+            identity_file: Some("~/.ssh/id_ed25519".to_string()),
+        }
+    }
+
+    #[test]
+    fn resolve_fills_unset_fields_from_matching_alias() {
+        let ssh = config("myserver");
+        let resolved = apply_host_entry(&ssh, entry("myserver"));
+        assert_eq!(resolved.host, "10.0.0.5");
+        assert_eq!(resolved.port, 2222);
+        assert_eq!(resolved.user, "deploy");
+        assert_eq!(resolved.key_path, "~/.ssh/id_ed25519");
+        assert_eq!(resolved.auth_method, "key");
+    }
+
+    #[test]
+    fn resolve_keeps_password_auth_when_password_is_present() {
+        let mut ssh = config("myserver");
+        ssh.password = "secret".to_string();
+        let resolved = apply_host_entry(&ssh, entry("myserver"));
+        assert_eq!(resolved.key_path, "~/.ssh/id_ed25519");
+        assert_eq!(resolved.auth_method, "password");
+    }
+
+    #[test]
+    fn resolve_does_not_override_explicit_values() {
+        let mut ssh = config("myserver");
+        ssh.user = "alice".to_string();
+        ssh.port = 9999;
+        ssh.key_path = "/explicit/key".to_string();
+        let resolved = apply_host_entry(&ssh, entry("myserver"));
+        assert_eq!(resolved.host, "10.0.0.5");
+        assert_eq!(resolved.user, "alice");
+        assert_eq!(resolved.port, 9999);
+        assert_eq!(resolved.key_path, "/explicit/key");
+    }
+
+    #[test]
+    fn resolve_is_noop_when_host_does_not_match_any_alias() {
+        // `resolve_ssh_tunnel_config` looks up the real `~/.ssh/config`; an
+        // alias this unlikely to exist on a test machine exercises the
+        // "no match found" branch without needing to mock the filesystem.
+        let ssh = config("dbx-test-alias-that-should-never-exist-anywhere");
+        let resolved = resolve_ssh_tunnel_config(&ssh);
+        assert_eq!(resolved, ssh);
+    }
+}
diff --git a/crates/dbx-core/src/storage.rs b/crates/dbx-core/src/storage.rs
new file mode 100644
index 0000000..3e363d7
--- /dev/null
+++ b/crates/dbx-core/src/storage.rs
@@ -0,0 +1,3262 @@
+use std::collections::{HashMap, HashSet};
+use std::path::Path;
+
+use log::warn;
+use rusqlite::{params, params_from_iter, Connection, DatabaseName, OpenFlags, OptionalExtension, ToSql};
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+use crate::ai::{AiChatMessage, AiConfig, AiConversation, AiProvider};
+use crate::connection_secrets::{
+    MQ_AUTH_API_KEY_VALUE_KEY, MQ_AUTH_CLIENT_SECRET_KEY, MQ_AUTH_PASSWORD_KEY, MQ_AUTH_SECRET_PREFIX,
+    MQ_AUTH_TOKEN_KEY, MQ_TOKEN_SIGNING_KEY, MQ_TOKEN_SIGNING_SECRET_PREFIX, NACOS_AUTH_PASSWORD_KEY,
+    NACOS_AUTH_SECRET_PREFIX,
+};
+use crate::db::sqlite::{connect_path_create_if_missing, SqliteHandle};
+use crate::history::{HistoryEntry, MAX_HISTORY};
+use crate::models::connection::{ConnectionConfig, DatabaseType, TransportLayerConfig};
+use crate::saved_sql::{SavedSqlFile, SavedSqlFolder, SavedSqlLibrary};
+
+const SSH_TUNNEL_SECRET_PREFIX: &str = "ssh_tunnels.";
+const TRANSPORT_LAYER_SECRET_PREFIX: &str = "transport_layers.";
+const STORAGE_DB_FILE_NAME: &str = "dbx.db";
+const APP_STATE_EDITOR_SETTINGS_KEY: &str = "editor_settings";
+const APP_STATE_OPEN_TABS_KEY: &str = "open_tabs";
+const APP_STATE_SAVED_SQL_EDITOR_POSITIONS_KEY: &str = "saved_sql_editor_positions";
+const USER_DATA_TABLES: &[&str] = &[
+    "connections",
+    "connection_secrets",
+    "history",
+    "ai_conversations",
+    "mq_token_records",
+    "saved_sql_folders",
+    "saved_sql_files",
+];
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DataDbImportResult {
+    Imported,
+    SkippedNoSource,
+    SkippedInvalidSource,
+    SkippedInvalidTarget,
+    SkippedSourceEmpty,
+    SkippedTargetHasData,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SqliteDbFileState {
+    Missing,
+    Empty,
+    Valid,
+    Invalid,
+}
+
+pub fn maybe_import_user_data_db(
+    target_data_dir: &Path,
+    source_data_dir: Option<&Path>,
+) -> Result<DataDbImportResult, String> {
+    let Some(source_data_dir) = source_data_dir else {
+        return Ok(DataDbImportResult::SkippedNoSource);
+    };
+
+    let source_db_path = source_data_dir.join(STORAGE_DB_FILE_NAME);
+    if !source_db_path.is_file() {
+        return Ok(DataDbImportResult::SkippedNoSource);
+    }
+    if inspect_sqlite_db_file(&source_db_path)? != SqliteDbFileState::Valid {
+        return Ok(DataDbImportResult::SkippedInvalidSource);
+    }
+
+    let source_conn = open_read_only_sqlite(&source_db_path)?;
+    if !sqlite_db_has_user_data(&source_conn)? {
+        return Ok(DataDbImportResult::SkippedSourceEmpty);
+    }
+
+    let target_db_path = target_data_dir.join(STORAGE_DB_FILE_NAME);
+    match inspect_sqlite_db_file(&target_db_path)? {
+        SqliteDbFileState::Missing => {}
+        SqliteDbFileState::Empty => {
+            remove_sqlite_db_files(&target_db_path)?;
+        }
+        SqliteDbFileState::Valid => {
+            let target_conn = open_read_only_sqlite(&target_db_path)?;
+            if sqlite_db_has_user_data(&target_conn)? {
+                return Ok(DataDbImportResult::SkippedTargetHasData);
+            }
+            drop(target_conn);
+            remove_sqlite_db_files(&target_db_path)?;
+        }
+        SqliteDbFileState::Invalid => return Ok(DataDbImportResult::SkippedInvalidTarget),
+    }
+
+    std::fs::create_dir_all(target_data_dir).map_err(|e| format!("Failed to create data dir: {e}"))?;
+    source_conn
+        .backup(DatabaseName::Main, &target_db_path, None)
+        .map_err(|e| format!("Failed to import user data db: {e}"))?;
+
+    Ok(DataDbImportResult::Imported)
+}
+
+pub struct Storage {
+    db: SqliteHandle,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct TabRuntimeCacheEntry {
+    pub key: String,
+    pub payload: Vec<u8>,
+    pub row_count: i64,
+    pub column_count: i64,
+    pub byte_size: i64,
+    pub updated_at: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct DesktopSettings {
+    pub show_tray_icon: bool,
+    pub icon_theme: DesktopIconTheme,
+    #[serde(default)]
+    pub quit_on_close: bool,
+    #[serde(default)]
+    pub close_action_prompted: bool,
+    #[serde(default)]
+    pub debug_logging_enabled: bool,
+    #[serde(default)]
+    pub duckdb_worker_process_isolation: bool,
+    #[serde(default = "default_duckdb_worker_max_processes")]
+    pub duckdb_worker_max_processes: usize,
+    #[serde(default)]
+    pub saved_sql_sync_dir: Option<String>,
+    #[serde(default)]
+    pub driver_store_dir: Option<String>,
+    #[serde(default)]
+    pub plugin_store_dir: Option<String>,
+    #[serde(default)]
+    pub agent_store_dir: Option<String>,
+    #[serde(default = "default_sidebar_table_page_size")]
+    pub sidebar_table_page_size: usize,
+}
+
+fn default_sidebar_table_page_size() -> usize {
+    1000
+}
+
+pub const DUCKDB_WORKER_MAX_PROCESSES_MIN: usize = 1;
+pub const DUCKDB_WORKER_MAX_PROCESSES_MAX: usize = 16;
+pub const DUCKDB_WORKER_MAX_PROCESSES_DEFAULT: usize = 4;
+
+pub fn default_duckdb_worker_max_processes() -> usize {
+    DUCKDB_WORKER_MAX_PROCESSES_DEFAULT
+}
+
+pub fn normalize_duckdb_worker_max_processes(value: usize) -> usize {
+    value.clamp(DUCKDB_WORKER_MAX_PROCESSES_MIN, DUCKDB_WORKER_MAX_PROCESSES_MAX)
+}
+
+impl Default for DesktopSettings {
+    fn default() -> Self {
+        Self {
+            show_tray_icon: true,
+            icon_theme: DesktopIconTheme::Default,
+            quit_on_close: false,
+            close_action_prompted: false,
+            debug_logging_enabled: false,
+            duckdb_worker_process_isolation: false,
+            duckdb_worker_max_processes: default_duckdb_worker_max_processes(),
+            saved_sql_sync_dir: None,
+            driver_store_dir: None,
+            plugin_store_dir: None,
+            agent_store_dir: None,
+            sidebar_table_page_size: default_sidebar_table_page_size(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum DesktopIconTheme {
+    Default,
+    Black,
+}
+
+impl DesktopIconTheme {
+    fn from_settings_value(value: Option<&serde_json::Value>) -> Self {
+        match value.and_then(|value| value.as_str()) {
+            Some("black") => Self::Black,
+            _ => Self::Default,
+        }
+    }
+}
+
+const SCHEMA_STATEMENTS: &[&str] = &[
+    "CREATE TABLE IF NOT EXISTS connections (
+        id TEXT PRIMARY KEY,
+        config_json TEXT NOT NULL
+    )",
+    "CREATE TABLE IF NOT EXISTS connection_secrets (
+        connection_id TEXT NOT NULL,
+        key TEXT NOT NULL,
+        secret TEXT NOT NULL,
+        PRIMARY KEY (connection_id, key)
+    )",
+    "CREATE TABLE IF NOT EXISTS history (
+        id TEXT PRIMARY KEY,
+        connection_id TEXT NOT NULL DEFAULT '',
+        connection_name TEXT NOT NULL DEFAULT '',
+        database TEXT NOT NULL DEFAULT '',
+        sql_text TEXT NOT NULL DEFAULT '',
+        executed_at TEXT NOT NULL DEFAULT '',
+        execution_time_ms INTEGER NOT NULL DEFAULT 0,
+        success INTEGER NOT NULL DEFAULT 1,
+        error TEXT,
+        activity_kind TEXT NOT NULL DEFAULT 'query',
+        operation TEXT NOT NULL DEFAULT '',
+        target TEXT NOT NULL DEFAULT '',
+        affected_rows INTEGER,
+        rollback_sql TEXT,
+        details_json TEXT
+    )",
+    "CREATE TABLE IF NOT EXISTS ai_config (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        config_json TEXT NOT NULL
+    )",
+    "CREATE TABLE IF NOT EXISTS ai_provider_configs (
+        provider TEXT PRIMARY KEY,
+        config_json TEXT NOT NULL
+    )",
+    "CREATE TABLE IF NOT EXISTS tunnel_profiles (
+        id TEXT PRIMARY KEY,
+        config_json TEXT NOT NULL
+    )",
+    "CREATE TABLE IF NOT EXISTS ai_conversations (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL DEFAULT '',
+        connection_name TEXT NOT NULL DEFAULT '',
+        database TEXT NOT NULL DEFAULT '',
+        messages_json TEXT NOT NULL DEFAULT '[]',
+        created_at TEXT NOT NULL DEFAULT '',
+        updated_at TEXT NOT NULL DEFAULT ''
+    )",
+    "CREATE TABLE IF NOT EXISTS sidebar_layout (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        layout_json TEXT NOT NULL
+    )",
+    "CREATE TABLE IF NOT EXISTS app_settings (
+        id INTEGER PRIMARY KEY CHECK (id = 1),
+        settings_json TEXT NOT NULL
+    )",
+    "CREATE TABLE IF NOT EXISTS app_state (
+        key TEXT PRIMARY KEY,
+        value_json TEXT NOT NULL
+    )",
+    "CREATE TABLE IF NOT EXISTS schema_cache (
+        cache_key TEXT PRIMARY KEY,
+        payload_json TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+    )",
+    "CREATE TABLE IF NOT EXISTS tab_runtime_cache (
+        cache_key TEXT PRIMARY KEY,
+        payload BLOB NOT NULL,
+        row_count INTEGER NOT NULL DEFAULT 0,
+        column_count INTEGER NOT NULL DEFAULT 0,
+        byte_size INTEGER NOT NULL DEFAULT 0,
+        updated_at TEXT NOT NULL
+    )",
+    "CREATE TABLE IF NOT EXISTS mq_token_records (
+        id TEXT PRIMARY KEY,
+        connection_id TEXT NOT NULL,
+        subject TEXT NOT NULL,
+        algorithm TEXT NOT NULL,
+        token_fingerprint TEXT NOT NULL,
+        scope_json TEXT,
+        actions_json TEXT NOT NULL DEFAULT '[]',
+        expires_at TEXT,
+        created_at TEXT NOT NULL,
+        note TEXT NOT NULL DEFAULT ''
+    )",
+    "CREATE INDEX IF NOT EXISTS idx_mq_token_records_connection_subject
+        ON mq_token_records (connection_id, subject, created_at DESC)",
+    "CREATE INDEX IF NOT EXISTS idx_mq_token_records_fingerprint
+        ON mq_token_records (token_fingerprint)",
+    "CREATE TABLE IF NOT EXISTS saved_sql_folders (
+        id TEXT PRIMARY KEY,
+        connection_id TEXT NOT NULL,
+        parent_folder_id TEXT,
+        name TEXT NOT NULL DEFAULT '',
+        order_index INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL DEFAULT '',
+        updated_at TEXT NOT NULL DEFAULT ''
+    )",
+    "CREATE TABLE IF NOT EXISTS saved_sql_files (
+        id TEXT PRIMARY KEY,
+        connection_id TEXT NOT NULL,
+        folder_id TEXT,
+        name TEXT NOT NULL DEFAULT '',
+        database_name TEXT NOT NULL DEFAULT '',
+        schema_name TEXT,
+        sql_text TEXT NOT NULL DEFAULT '',
+        order_index INTEGER NOT NULL DEFAULT 0,
+        open_count INTEGER NOT NULL DEFAULT 0,
+        opened_at TEXT,
+        created_at TEXT NOT NULL DEFAULT '',
+        updated_at TEXT NOT NULL DEFAULT ''
+    )",
+];
+
+impl Storage {
+    pub async fn open(db_path: &Path) -> Result<Self, String> {
+        let db_path = db_path.to_string_lossy().to_string();
+        let db = connect_path_create_if_missing(&db_path).await?;
+        let storage = Self { db };
+        storage.init_schema().await?;
+        Ok(storage)
+    }
+
+    async fn init_schema(&self) -> Result<(), String> {
+        self.db.with_connection(|conn| {
+            for statement in SCHEMA_STATEMENTS {
+                conn.execute(statement, []).map_err(|e| e.to_string())?;
+            }
+            ensure_history_columns_sync(conn)?;
+            ensure_saved_sql_columns_sync(conn)?;
+            Ok(())
+        })
+    }
+
+    async fn with_conn<T, F>(&self, f: F) -> Result<T, String>
+    where
+        T: Send + 'static,
+        F: FnOnce(&mut Connection) -> Result<T, String> + Send + 'static,
+    {
+        let db = self.db.clone();
+        tokio::task::spawn_blocking(move || db.with_connection(f)).await.map_err(|e| e.to_string())?
+    }
+}
+
+fn inspect_sqlite_db_file(path: &Path) -> Result<SqliteDbFileState, String> {
+    if !path.exists() {
+        return Ok(SqliteDbFileState::Missing);
+    }
+
+    let metadata = path.metadata().map_err(|e| format!("Failed to inspect db file: {e}"))?;
+    if metadata.len() == 0 {
+        return Ok(SqliteDbFileState::Empty);
+    }
+
+    if crate::db::sqlite::path_has_sqlite_header(path)? {
+        Ok(SqliteDbFileState::Valid)
+    } else {
+        Ok(SqliteDbFileState::Invalid)
+    }
+}
+
+fn open_read_only_sqlite(path: &Path) -> Result<Connection, String> {
+    Connection::open_with_flags(path, OpenFlags::SQLITE_OPEN_READ_ONLY)
+        .map_err(|e| format!("Failed to open db read-only: {e}"))
+}
+
+fn sqlite_db_has_user_data(conn: &Connection) -> Result<bool, String> {
+    for table_name in USER_DATA_TABLES {
+        if sqlite_table_has_rows(conn, table_name)? {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
+fn sqlite_table_has_rows(conn: &Connection, table_name: &str) -> Result<bool, String> {
+    let exists: bool = conn
+        .query_row(
+            "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?1)",
+            [table_name],
+            |row| row.get(0),
+        )
+        .map_err(|e| e.to_string())?;
+    if !exists {
+        return Ok(false);
+    }
+
+    let sql = format!("SELECT EXISTS(SELECT 1 FROM {table_name} LIMIT 1)");
+    conn.query_row(&sql, [], |row| row.get(0)).map_err(|e| e.to_string())
+}
+
+fn remove_sqlite_db_files(db_path: &Path) -> Result<(), String> {
+    for path in [db_path.to_path_buf(), db_path.with_extension("db-wal"), db_path.with_extension("db-shm")] {
+        match std::fs::remove_file(&path) {
+            Ok(()) => {}
+            Err(err) if err.kind() == std::io::ErrorKind::NotFound => {}
+            Err(err) => return Err(format!("Failed to remove empty target db file {}: {err}", path.display())),
+        }
+    }
+    Ok(())
+}
+
+fn ensure_history_columns_sync(conn: &Connection) -> Result<(), String> {
+    const COLUMNS: &[(&str, &str)] = &[
+        ("activity_kind", "TEXT NOT NULL DEFAULT 'query'"),
+        ("connection_id", "TEXT NOT NULL DEFAULT ''"),
+        ("operation", "TEXT NOT NULL DEFAULT ''"),
+        ("target", "TEXT NOT NULL DEFAULT ''"),
+        ("affected_rows", "INTEGER"),
+        ("rollback_sql", "TEXT"),
+        ("details_json", "TEXT"),
+    ];
+
+    let mut stmt = conn.prepare("SELECT name FROM pragma_table_info('history')").map_err(|e| e.to_string())?;
+    let existing = stmt
+        .query_map([], |row| row.get::<_, String>(0))
+        .map_err(|e| e.to_string())?
+        .collect::<Result<HashSet<_>, _>>()
+        .map_err(|e| e.to_string())?;
+
+    for (name, definition) in COLUMNS {
+        if existing.contains(*name) {
+            continue;
+        }
+        conn.execute(&format!("ALTER TABLE history ADD COLUMN {name} {definition}"), []).map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}
+
+fn ensure_saved_sql_columns_sync(conn: &Connection) -> Result<(), String> {
+    const FOLDER_COLUMNS: &[(&str, &str)] =
+        &[("parent_folder_id", "TEXT"), ("order_index", "INTEGER NOT NULL DEFAULT 0")];
+    const FILE_COLUMNS: &[(&str, &str)] = &[
+        ("order_index", "INTEGER NOT NULL DEFAULT 0"),
+        ("open_count", "INTEGER NOT NULL DEFAULT 0"),
+        ("opened_at", "TEXT"),
+    ];
+
+    ensure_table_columns(conn, "saved_sql_folders", FOLDER_COLUMNS)?;
+    ensure_table_columns(conn, "saved_sql_files", FILE_COLUMNS)?;
+    Ok(())
+}
+
+fn ensure_table_columns(conn: &Connection, table_name: &str, columns: &[(&str, &str)]) -> Result<(), String> {
+    let mut stmt =
+        conn.prepare(&format!("SELECT name FROM pragma_table_info('{table_name}')")).map_err(|e| e.to_string())?;
+    let existing = stmt
+        .query_map([], |row| row.get::<_, String>(0))
+        .map_err(|e| e.to_string())?
+        .collect::<Result<HashSet<_>, _>>()
+        .map_err(|e| e.to_string())?;
+
+    for (name, definition) in columns {
+        if existing.contains(*name) {
+            continue;
+        }
+        conn.execute(&format!("ALTER TABLE {table_name} ADD COLUMN {name} {definition}"), [])
+            .map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}
+
+fn ssh_tunnel_secret_segment(index: usize, hop: &crate::models::connection::SshTunnelConfig) -> String {
+    if hop.id.trim().is_empty() {
+        index.to_string()
+    } else {
+        hop.id.clone()
+    }
+}
+
+fn ssh_tunnel_password_key(index: usize, hop: &crate::models::connection::SshTunnelConfig) -> String {
+    format!("{}{}.password", SSH_TUNNEL_SECRET_PREFIX, ssh_tunnel_secret_segment(index, hop))
+}
+
+fn ssh_tunnel_key_passphrase_key(index: usize, hop: &crate::models::connection::SshTunnelConfig) -> String {
+    format!("{}{}.key_passphrase", SSH_TUNNEL_SECRET_PREFIX, ssh_tunnel_secret_segment(index, hop))
+}
+
+fn transport_layer_secret_segment(index: usize, layer: &TransportLayerConfig) -> String {
+    let id = layer.id().trim();
+    if id.is_empty() {
+        index.to_string()
+    } else {
+        id.to_string()
+    }
+}
+
+fn transport_layer_ssh_password_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.ssh_password", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn transport_layer_ssh_key_passphrase_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.ssh_key_passphrase", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn transport_layer_proxy_password_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.proxy_password", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn transport_layer_http_tunnel_token_key(index: usize, layer: &TransportLayerConfig) -> String {
+    format!("{}{}.http_tunnel_token", TRANSPORT_LAYER_SECRET_PREFIX, transport_layer_secret_segment(index, layer))
+}
+
+fn scrub_transport_layer_secrets(config: &mut ConnectionConfig) {
+    for layer in &mut config.transport_layers {
+        match layer {
+            TransportLayerConfig::Ssh(ssh) => {
+                ssh.password.clear();
+                ssh.key_passphrase.clear();
+            }
+            TransportLayerConfig::Proxy(proxy) => {
+                proxy.password.clear();
+            }
+            TransportLayerConfig::HttpTunnel(http) => {
+                http.token.clear();
+            }
+        }
+    }
+}
+
+fn scrub_mq_auth_secrets(config: &mut ConnectionConfig) {
+    if config.db_type != DatabaseType::MessageQueue {
+        return;
+    }
+    let Some(auth) = mq_auth_object_mut(config.external_config.as_mut()) else {
+        return;
+    };
+    match mq_auth_kind(auth) {
+        Some("token") => scrub_json_secret(auth, "token"),
+        Some("basic") => scrub_json_secret(auth, "password"),
+        Some(kind) if is_api_key_auth_kind(kind) => scrub_json_secret(auth, "value"),
+        Some("oauth2") => scrub_json_secret(auth, "clientSecret"),
+        _ => {}
+    }
+}
+
+fn scrub_mq_token_signing_secret(config: &mut ConnectionConfig) {
+    if config.db_type != DatabaseType::MessageQueue {
+        return;
+    }
+    let Some(signing) = mq_token_signing_object_mut(config.external_config.as_mut()) else {
+        return;
+    };
+    scrub_json_secret(signing, "key");
+}
+
+fn scrub_nacos_auth_secrets(config: &mut ConnectionConfig) {
+    if config.db_type != DatabaseType::Nacos {
+        return;
+    }
+    let Some(auth) = nacos_auth_object_mut(config.external_config.as_mut()) else {
+        return;
+    };
+    if auth.get("kind").and_then(serde_json::Value::as_str) == Some("usernamePassword") {
+        scrub_json_secret(auth, "password");
+    }
+}
+
+fn delete_secret_prefix_in_tx(
+    tx: &rusqlite::Transaction<'_>,
+    connection_id: &str,
+    key_prefix: &str,
+) -> Result<(), String> {
+    let like = format!("{key_prefix}%");
+    tx.execute("DELETE FROM connection_secrets WHERE connection_id = ?1 AND key LIKE ?2", params![connection_id, like])
+        .map(|_| ())
+        .map_err(|e| e.to_string())
+}
+
+// History
+
+impl Storage {
+    pub async fn save_history_entry(&self, entry: &HistoryEntry) -> Result<(), String> {
+        let entry = entry.clone();
+        self.with_conn(move |conn| {
+            conn.execute(
+                "INSERT OR REPLACE INTO history \
+                 (id, connection_name, database, sql_text, executed_at, execution_time_ms, success, error, \
+                  activity_kind, connection_id, operation, target, affected_rows, rollback_sql, details_json) \
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                params![
+                    entry.id,
+                    entry.connection_name,
+                    entry.database,
+                    entry.sql,
+                    entry.executed_at,
+                    entry.execution_time_ms as i64,
+                    entry.success,
+                    entry.error,
+                    entry.activity_kind,
+                    entry.connection_id,
+                    entry.operation,
+                    entry.target,
+                    entry.affected_rows,
+                    entry.rollback_sql,
+                    entry.details_json
+                ],
+            )
+            .map_err(|e| e.to_string())?;
+
+            conn.execute(
+                "DELETE FROM history WHERE id NOT IN \
+                 (SELECT id FROM history ORDER BY executed_at DESC LIMIT ?1)",
+                [MAX_HISTORY as i64],
+            )
+            .map_err(|e| e.to_string())?;
+            Ok(())
+        })
+        .await
+    }
+
+    pub async fn load_history_entries(
+        &self,
+        limit: usize,
+        offset: usize,
+        activity_kind: Option<String>,
+    ) -> Result<Vec<HistoryEntry>, String> {
+        self.with_conn(move |conn| {
+            let map_row = |row: &rusqlite::Row<'_>| -> rusqlite::Result<HistoryEntry> {
+                Ok(HistoryEntry {
+                    id: row.get(0)?,
+                    connection_name: row.get(1)?,
+                    database: row.get(2)?,
+                    sql: row.get(3)?,
+                    executed_at: row.get(4)?,
+                    execution_time_ms: row.get::<_, i64>(5)? as u128,
+                    success: row.get(6)?,
+                    error: row.get(7)?,
+                    activity_kind: {
+                        let value: String = row.get(8)?;
+                        if value.is_empty() { "query".to_string() } else { value }
+                    },
+                    connection_id: row.get(9)?,
+                    operation: row.get(10)?,
+                    target: row.get(11)?,
+                    affected_rows: row.get(12)?,
+                    rollback_sql: row.get(13)?,
+                    details_json: row.get(14)?,
+                })
+            };
+
+            if let Some(kind) = activity_kind {
+                let mut stmt = conn
+                    .prepare(
+                        "SELECT id, connection_name, database, sql_text, executed_at, execution_time_ms, success, \
+                         error, activity_kind, connection_id, operation, target, affected_rows, rollback_sql, details_json \
+                         FROM history WHERE activity_kind = ?1 ORDER BY executed_at DESC LIMIT ?2 OFFSET ?3",
+                    )
+                    .map_err(|e| e.to_string())?;
+                let rows = stmt
+                    .query_map(params![kind, limit as i64, offset as i64], map_row)
+                    .map_err(|e| e.to_string())?;
+                rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
+            } else {
+                let mut stmt = conn
+                    .prepare(
+                        "SELECT id, connection_name, database, sql_text, executed_at, execution_time_ms, success, \
+                         error, activity_kind, connection_id, operation, target, affected_rows, rollback_sql, details_json \
+                         FROM history ORDER BY executed_at DESC LIMIT ?1 OFFSET ?2",
+                    )
+                    .map_err(|e| e.to_string())?;
+                let rows = stmt
+                    .query_map(params![limit as i64, offset as i64], map_row)
+                    .map_err(|e| e.to_string())?;
+                rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
+            }
+        })
+        .await
+    }
+
+    pub async fn clear_history(&self) -> Result<(), String> {
+        self.with_conn(|conn| conn.execute("DELETE FROM history", []).map(|_| ()).map_err(|e| e.to_string())).await
+    }
+
+    pub async fn delete_history_entry(&self, id: &str) -> Result<(), String> {
+        let id = id.to_string();
+        self.with_conn(move |conn| {
+            conn.execute("DELETE FROM history WHERE id = ?1", [id]).map(|_| ()).map_err(|e| e.to_string())
+        })
+        .await
+    }
+}
+
+// AI Config
+
+fn ai_provider_key(provider: &AiProvider) -> String {
+    serde_json::to_value(provider).ok().and_then(|value| value.as_str().map(ToOwned::to_owned)).unwrap_or_default()
+}
+
+fn ai_provider_from_key(provider: &str) -> Result<AiProvider, String> {
+    serde_json::from_value(serde_json::Value::String(provider.to_string()))
+        .map_err(|_| format!("Invalid AI provider: {provider}"))
+}
+
+impl Storage {
+    pub async fn save_ai_config(&self, config: &AiConfig) -> Result<(), String> {
+        let json = serde_json::to_string(config).map_err(|e| e.to_string())?;
+        self.with_conn(move |conn| {
+            conn.execute("INSERT OR REPLACE INTO ai_config (id, config_json) VALUES (1, ?1)", [json])
+                .map(|_| ())
+                .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn load_ai_config(&self) -> Result<Option<AiConfig>, String> {
+        let json: Option<String> = self
+            .with_conn(|conn| {
+                conn.query_row("SELECT config_json FROM ai_config WHERE id = 1", [], |row| row.get(0))
+                    .optional()
+                    .map_err(|e| e.to_string())
+            })
+            .await?;
+        json.map(|value| serde_json::from_str(&value).map_err(|e| e.to_string())).transpose()
+    }
+
+    pub async fn save_ai_provider_config(&self, provider: &str, config: &AiConfig) -> Result<(), String> {
+        let parsed_provider = ai_provider_from_key(provider)?;
+        let mut config = config.clone();
+        let config_provider = ai_provider_key(&config.provider);
+        if config_provider != provider {
+            warn!(
+                "save_ai_provider_config: config.provider ({}) does not match provider key ({}), normalizing",
+                config_provider, provider
+            );
+            config.provider = parsed_provider;
+        }
+        let provider = provider.to_string();
+        let json = serde_json::to_string(&config).map_err(|e| e.to_string())?;
+        self.with_conn(move |conn| {
+            conn.execute(
+                "INSERT OR REPLACE INTO ai_provider_configs (provider, config_json) VALUES (?1, ?2)",
+                params![provider, json],
+            )
+            .map(|_| ())
+            .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn load_ai_provider_configs(&self) -> Result<HashMap<String, AiConfig>, String> {
+        self.with_conn(|conn| {
+            let mut stmt = conn
+                .prepare("SELECT provider, config_json FROM ai_provider_configs")
+                .map_err(|e| e.to_string())?;
+            let rows = stmt
+                .query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))
+                .map_err(|e| e.to_string())?;
+            let mut map = HashMap::new();
+            for row in rows {
+                let (provider, json) = row.map_err(|e| e.to_string())?;
+                match serde_json::from_str::<AiConfig>(&json) {
+                    Ok(mut config) => {
+                        if let Ok(parsed_provider) = ai_provider_from_key(&provider) {
+                            let config_provider = ai_provider_key(&config.provider);
+                            if config_provider != provider {
+                                warn!(
+                                    "load_ai_provider_configs: stored config.provider ({}) does not match provider key ({}), normalizing",
+                                    config_provider, provider
+                                );
+                                config.provider = parsed_provider;
+                            }
+                            map.insert(provider, config);
+                        }
+                    }
+                    Err(e) => {
+                        warn!("Failed to deserialize AI config for provider '{}': {}", provider, e);
+                    }
+                }
+            }
+            Ok(map)
+        })
+        .await
+    }
+}
+
+// Tunnel profiles — shared transport-layer configurations managed in
+// Settings and referenced from connections via `profile_id`. Secrets stay
+// inline in `config_json`; that matches the plaintext-at-rest posture of
+// `connection_secrets` in the same database file.
+
+impl Storage {
+    pub async fn load_tunnel_profiles(&self) -> Result<Vec<TransportLayerConfig>, String> {
+        let rows: Vec<String> = self
+            .with_conn(|conn| {
+                let mut stmt = conn
+                    .prepare("SELECT config_json FROM tunnel_profiles ORDER BY rowid")
+                    .map_err(|e| e.to_string())?;
+                let rows = stmt.query_map([], |row| row.get::<_, String>(0)).map_err(|e| e.to_string())?;
+                rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
+            })
+            .await?;
+
+        let mut profiles = Vec::new();
+        for json in rows {
+            match serde_json::from_str::<TransportLayerConfig>(&json) {
+                Ok(profile) => profiles.push(profile),
+                Err(e) => warn!("Failed to deserialize tunnel profile: {}", e),
+            }
+        }
+        Ok(profiles)
+    }
+
+    pub async fn save_tunnel_profiles(&self, profiles: &[TransportLayerConfig]) -> Result<(), String> {
+        for profile in profiles {
+            if profile.id().trim().is_empty() {
+                return Err("Tunnel profile id must not be empty".to_string());
+            }
+        }
+        let profiles = profiles.to_vec();
+        self.with_conn(move |conn| {
+            let tx = conn.transaction().map_err(|e| e.to_string())?;
+            tx.execute("DELETE FROM tunnel_profiles", []).map_err(|e| e.to_string())?;
+            for profile in &profiles {
+                let json = serde_json::to_string(profile).map_err(|e| e.to_string())?;
+                tx.execute(
+                    "INSERT INTO tunnel_profiles (id, config_json) VALUES (?1, ?2)",
+                    params![profile.id(), json],
+                )
+                .map_err(|e| e.to_string())?;
+            }
+            tx.commit().map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    /// Replaces the profile catalog while keeping the secrets already stored
+    /// for a profile when the incoming copy has them scrubbed. Used when
+    /// applying sync snapshots, whose plain (non-encrypted) part strips
+    /// tunnel secrets.
+    pub async fn save_tunnel_profiles_preserving_secrets(
+        &self,
+        profiles: &[TransportLayerConfig],
+    ) -> Result<(), String> {
+        let existing: HashMap<String, TransportLayerConfig> =
+            self.load_tunnel_profiles().await?.into_iter().map(|p| (p.id().to_string(), p)).collect();
+        let merged: Vec<TransportLayerConfig> = profiles
+            .iter()
+            .map(|profile| {
+                let mut profile = profile.clone();
+                if let Some(previous) = existing.get(profile.id()) {
+                    merge_missing_tunnel_profile_secrets(&mut profile, previous);
+                }
+                profile
+            })
+            .collect();
+        self.save_tunnel_profiles(&merged).await
+    }
+}
+
+fn merge_missing_tunnel_profile_secrets(profile: &mut TransportLayerConfig, previous: &TransportLayerConfig) {
+    match (profile, previous) {
+        (TransportLayerConfig::Ssh(current), TransportLayerConfig::Ssh(previous)) => {
+            if current.password.is_empty() {
+                current.password = previous.password.clone();
+            }
+            if current.key_passphrase.is_empty() {
+                current.key_passphrase = previous.key_passphrase.clone();
+            }
+        }
+        (TransportLayerConfig::Proxy(current), TransportLayerConfig::Proxy(previous)) => {
+            if current.password.is_empty() {
+                current.password = previous.password.clone();
+            }
+        }
+        (TransportLayerConfig::HttpTunnel(current), TransportLayerConfig::HttpTunnel(previous)) => {
+            if current.token.is_empty() {
+                current.token = previous.token.clone();
+            }
+        }
+        _ => {}
+    }
+}
+
+// App Settings
+
+impl Storage {
+    async fn load_app_settings_json(&self) -> Result<serde_json::Map<String, serde_json::Value>, String> {
+        let json: Option<String> = self
+            .with_conn(|conn| {
+                conn.query_row("SELECT settings_json FROM app_settings WHERE id = 1", [], |row| row.get(0))
+                    .optional()
+                    .map_err(|e| e.to_string())
+            })
+            .await?;
+        let Some(json) = json else {
+            return Ok(serde_json::Map::new());
+        };
+        match serde_json::from_str::<serde_json::Value>(&json).map_err(|e| e.to_string())? {
+            serde_json::Value::Object(map) => Ok(map),
+            _ => Ok(serde_json::Map::new()),
+        }
+    }
+
+    async fn save_app_settings_json(
+        &self,
+        settings: &serde_json::Map<String, serde_json::Value>,
+    ) -> Result<(), String> {
+        let json = serde_json::Value::Object(settings.clone()).to_string();
+        self.with_conn(move |conn| {
+            conn.execute("INSERT OR REPLACE INTO app_settings (id, settings_json) VALUES (1, ?1)", [json])
+                .map(|_| ())
+                .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn save_password_hash(&self, hash: &str) -> Result<(), String> {
+        let mut settings = self.load_app_settings_json().await?;
+        settings.insert("password_hash".to_string(), serde_json::Value::String(hash.to_string()));
+        self.save_app_settings_json(&settings).await
+    }
+
+    pub async fn load_password_hash(&self) -> Result<Option<String>, String> {
+        let settings = self.load_app_settings_json().await?;
+        Ok(settings.get("password_hash").and_then(|v| v.as_str()).map(|s| s.to_string()))
+    }
+
+    pub async fn save_desktop_settings(&self, desktop_settings: &DesktopSettings) -> Result<(), String> {
+        let mut settings = self.load_app_settings_json().await?;
+        settings.remove("run_in_background");
+        settings.insert("show_tray_icon".to_string(), serde_json::Value::Bool(desktop_settings.show_tray_icon));
+        settings.insert(
+            "icon_theme".to_string(),
+            serde_json::to_value(desktop_settings.icon_theme).map_err(|e| e.to_string())?,
+        );
+        settings.insert("quit_on_close".to_string(), serde_json::Value::Bool(desktop_settings.quit_on_close));
+        settings.insert(
+            "close_action_prompted".to_string(),
+            serde_json::Value::Bool(desktop_settings.close_action_prompted),
+        );
+        settings.insert(
+            "debug_logging_enabled".to_string(),
+            serde_json::Value::Bool(desktop_settings.debug_logging_enabled),
+        );
+        settings.insert(
+            "duckdb_worker_process_isolation".to_string(),
+            serde_json::Value::Bool(desktop_settings.duckdb_worker_process_isolation),
+        );
+        settings.insert(
+            "duckdb_worker_max_processes".to_string(),
+            serde_json::Value::Number(serde_json::Number::from(normalize_duckdb_worker_max_processes(
+                desktop_settings.duckdb_worker_max_processes,
+            ))),
+        );
+        match desktop_settings.saved_sql_sync_dir.as_ref().filter(|path| !path.trim().is_empty()) {
+            Some(path) => {
+                settings.insert("saved_sql_sync_dir".to_string(), serde_json::Value::String(path.clone()));
+            }
+            None => {
+                settings.remove("saved_sql_sync_dir");
+            }
+        }
+        match desktop_settings.driver_store_dir.as_ref().filter(|path| !path.trim().is_empty()) {
+            Some(path) => {
+                settings.insert("driver_store_dir".to_string(), serde_json::Value::String(path.clone()));
+            }
+            None => {
+                settings.remove("driver_store_dir");
+            }
+        }
+        match desktop_settings.plugin_store_dir.as_ref().filter(|path| !path.trim().is_empty()) {
+            Some(path) => {
+                settings.insert("plugin_store_dir".to_string(), serde_json::Value::String(path.clone()));
+            }
+            None => {
+                settings.remove("plugin_store_dir");
+            }
+        }
+        match desktop_settings.agent_store_dir.as_ref().filter(|path| !path.trim().is_empty()) {
+            Some(path) => {
+                settings.insert("agent_store_dir".to_string(), serde_json::Value::String(path.clone()));
+            }
+            None => {
+                settings.remove("agent_store_dir");
+            }
+        }
+        settings.insert(
+            "sidebar_table_page_size".to_string(),
+            serde_json::Value::Number(serde_json::Number::from(desktop_settings.sidebar_table_page_size)),
+        );
+        self.save_app_settings_json(&settings).await
+    }
+
+    pub async fn load_desktop_settings(&self) -> Result<DesktopSettings, String> {
+        let settings = self.load_app_settings_json().await?;
+        Ok(DesktopSettings {
+            show_tray_icon: settings
+                .get("show_tray_icon")
+                .and_then(|value| value.as_bool())
+                .or_else(|| settings.get("run_in_background").and_then(|value| value.as_bool()))
+                .unwrap_or_else(|| DesktopSettings::default().show_tray_icon),
+            icon_theme: DesktopIconTheme::from_settings_value(settings.get("icon_theme")),
+            quit_on_close: settings
+                .get("quit_on_close")
+                .and_then(|value| value.as_bool())
+                .unwrap_or_else(|| DesktopSettings::default().quit_on_close),
+            close_action_prompted: settings
+                .get("close_action_prompted")
+                .and_then(|value| value.as_bool())
+                .unwrap_or_else(|| DesktopSettings::default().close_action_prompted),
+            debug_logging_enabled: settings
+                .get("debug_logging_enabled")
+                .and_then(|value| value.as_bool())
+                .unwrap_or_else(|| DesktopSettings::default().debug_logging_enabled),
+            duckdb_worker_process_isolation: settings
+                .get("duckdb_worker_process_isolation")
+                .and_then(|value| value.as_bool())
+                .unwrap_or_else(|| DesktopSettings::default().duckdb_worker_process_isolation),
+            duckdb_worker_max_processes: settings
+                .get("duckdb_worker_max_processes")
+                .and_then(|value| value.as_u64())
+                .and_then(|value| usize::try_from(value).ok())
+                .map(normalize_duckdb_worker_max_processes)
+                .unwrap_or_else(|| DesktopSettings::default().duckdb_worker_max_processes),
+            saved_sql_sync_dir: settings
+                .get("saved_sql_sync_dir")
+                .and_then(|value| value.as_str())
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .map(ToString::to_string),
+            driver_store_dir: settings
+                .get("driver_store_dir")
+                .and_then(|value| value.as_str())
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .map(ToString::to_string),
+            plugin_store_dir: settings
+                .get("plugin_store_dir")
+                .and_then(|value| value.as_str())
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .map(ToString::to_string),
+            agent_store_dir: settings
+                .get("agent_store_dir")
+                .and_then(|value| value.as_str())
+                .map(str::trim)
+                .filter(|value| !value.is_empty())
+                .map(ToString::to_string),
+            sidebar_table_page_size: settings
+                .get("sidebar_table_page_size")
+                .and_then(|value| value.as_u64())
+                .map(|value| value as usize)
+                .unwrap_or_else(|| DesktopSettings::default().sidebar_table_page_size),
+        })
+    }
+
+    pub async fn save_pinned_tree_node_ids(&self, ids: &[String]) -> Result<(), String> {
+        let mut settings = self.load_app_settings_json().await?;
+        let values = ids.iter().map(|id| serde_json::Value::String(id.clone())).collect::<Vec<_>>();
+        settings.insert("pinned_tree_node_ids".to_string(), serde_json::Value::Array(values));
+        self.save_app_settings_json(&settings).await
+    }
+
+    pub async fn load_pinned_tree_node_ids(&self) -> Result<Vec<String>, String> {
+        let settings = self.load_app_settings_json().await?;
+        let Some(value) = settings.get("pinned_tree_node_ids") else {
+            return Ok(Vec::new());
+        };
+        let Some(array) = value.as_array() else {
+            return Ok(Vec::new());
+        };
+        Ok(array.iter().filter_map(|item| item.as_str().map(|value| value.to_string())).collect())
+    }
+
+    async fn save_app_state_value(&self, key: &str, value: &serde_json::Value) -> Result<(), String> {
+        let key = key.to_string();
+        let value_json = serde_json::to_string(value).map_err(|e| e.to_string())?;
+        self.with_conn(move |conn| {
+            conn.execute("INSERT OR REPLACE INTO app_state (key, value_json) VALUES (?1, ?2)", params![key, value_json])
+                .map(|_| ())
+                .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    async fn load_app_state_value(&self, key: &str) -> Result<Option<serde_json::Value>, String> {
+        let key = key.to_string();
+        let json: Option<String> = self
+            .with_conn(move |conn| {
+                conn.query_row("SELECT value_json FROM app_state WHERE key = ?1", [key], |row| row.get(0))
+                    .optional()
+                    .map_err(|e| e.to_string())
+            })
+            .await?;
+        json.map(|value| serde_json::from_str(&value).map_err(|e| e.to_string())).transpose()
+    }
+
+    pub async fn save_editor_settings(&self, settings: &serde_json::Value) -> Result<(), String> {
+        self.save_app_state_value(APP_STATE_EDITOR_SETTINGS_KEY, settings).await
+    }
+
+    pub async fn load_editor_settings(&self) -> Result<Option<serde_json::Value>, String> {
+        self.load_app_state_value(APP_STATE_EDITOR_SETTINGS_KEY).await
+    }
+
+    pub async fn save_open_tabs_state(&self, state: &serde_json::Value) -> Result<(), String> {
+        self.save_app_state_value(APP_STATE_OPEN_TABS_KEY, state).await
+    }
+
+    pub async fn load_open_tabs_state(&self) -> Result<Option<serde_json::Value>, String> {
+        self.load_app_state_value(APP_STATE_OPEN_TABS_KEY).await
+    }
+
+    pub async fn save_saved_sql_editor_positions(&self, positions: &serde_json::Value) -> Result<(), String> {
+        self.save_app_state_value(APP_STATE_SAVED_SQL_EDITOR_POSITIONS_KEY, positions).await
+    }
+
+    pub async fn load_saved_sql_editor_positions(&self) -> Result<Option<serde_json::Value>, String> {
+        self.load_app_state_value(APP_STATE_SAVED_SQL_EDITOR_POSITIONS_KEY).await
+    }
+
+    pub async fn load_or_create_local_device_secret(&self) -> Result<String, String> {
+        let mut settings = self.load_app_settings_json().await?;
+        if let Some(secret) = settings.get("local_device_secret").and_then(|value| value.as_str()) {
+            if !secret.is_empty() {
+                return Ok(secret.to_string());
+            }
+        }
+        let secret = Uuid::new_v4().to_string();
+        settings.insert("local_device_secret".to_string(), serde_json::Value::String(secret.clone()));
+        self.save_app_settings_json(&settings).await?;
+        Ok(secret)
+    }
+
+    pub async fn save_webdav_password_blob(&self, account: &str, blob: &serde_json::Value) -> Result<(), String> {
+        let mut settings = self.load_app_settings_json().await?;
+        let mut credentials =
+            settings.remove("webdav_passwords").and_then(|value| value.as_object().cloned()).unwrap_or_default();
+        credentials.insert(account.to_string(), blob.clone());
+        settings.insert("webdav_passwords".to_string(), serde_json::Value::Object(credentials));
+        self.save_app_settings_json(&settings).await
+    }
+
+    pub async fn load_webdav_password_blob(&self, account: &str) -> Result<Option<serde_json::Value>, String> {
+        let settings = self.load_app_settings_json().await?;
+        Ok(settings
+            .get("webdav_passwords")
+            .and_then(|value| value.as_object())
+            .and_then(|credentials| credentials.get(account))
+            .cloned())
+    }
+
+    pub async fn delete_webdav_password_blob(&self, account: &str) -> Result<(), String> {
+        let mut settings = self.load_app_settings_json().await?;
+        let Some(mut credentials) = settings.remove("webdav_passwords").and_then(|value| value.as_object().cloned())
+        else {
+            return Ok(());
+        };
+        credentials.remove(account);
+        settings.insert("webdav_passwords".to_string(), serde_json::Value::Object(credentials));
+        self.save_app_settings_json(&settings).await
+    }
+
+    pub async fn save_webdav_sync_secrets_preference(
+        &self,
+        enabled: bool,
+        blob: Option<&serde_json::Value>,
+    ) -> Result<(), String> {
+        let mut settings = self.load_app_settings_json().await?;
+        settings.insert("webdav_sync_secrets_enabled".to_string(), serde_json::Value::Bool(enabled));
+        if let Some(blob) = blob {
+            settings.insert("webdav_sync_secrets_passphrase".to_string(), blob.clone());
+        }
+        self.save_app_settings_json(&settings).await
+    }
+
+    pub async fn load_webdav_sync_secrets_enabled(&self) -> Result<bool, String> {
+        let settings = self.load_app_settings_json().await?;
+        Ok(settings.get("webdav_sync_secrets_enabled").and_then(serde_json::Value::as_bool).unwrap_or(false))
+    }
+
+    pub async fn load_webdav_sync_secrets_passphrase_blob(&self) -> Result<Option<serde_json::Value>, String> {
+        let settings = self.load_app_settings_json().await?;
+        Ok(settings.get("webdav_sync_secrets_passphrase").cloned())
+    }
+
+    pub async fn delete_webdav_sync_secrets_passphrase_blob(&self) -> Result<(), String> {
+        let mut settings = self.load_app_settings_json().await?;
+        settings.remove("webdav_sync_secrets_passphrase");
+        self.save_app_settings_json(&settings).await
+    }
+}
+
+// AI Conversations
+
+impl Storage {
+    pub async fn save_ai_conversation(&self, conv: &AiConversation) -> Result<(), String> {
+        let conv = conv.clone();
+        let messages_json = serde_json::to_string(&conv.messages).map_err(|e| e.to_string())?;
+        self.with_conn(move |conn| {
+            conn.execute(
+                "INSERT OR REPLACE INTO ai_conversations \
+                 (id, title, connection_name, database, messages_json, created_at, updated_at) \
+                 VALUES (?, ?, ?, ?, ?, ?, ?)",
+                params![
+                    conv.id,
+                    conv.title,
+                    conv.connection_name,
+                    conv.database,
+                    messages_json,
+                    conv.created_at,
+                    conv.updated_at
+                ],
+            )
+            .map_err(|e| e.to_string())?;
+
+            conn.execute(
+                "DELETE FROM ai_conversations WHERE id NOT IN \
+                 (SELECT id FROM ai_conversations ORDER BY updated_at DESC LIMIT 50)",
+                [],
+            )
+            .map_err(|e| e.to_string())?;
+            Ok(())
+        })
+        .await
+    }
+
+    pub async fn load_ai_conversations(&self) -> Result<Vec<AiConversation>, String> {
+        self.with_conn(|conn| {
+            let mut stmt = conn
+                .prepare(
+                    "SELECT id, title, connection_name, database, messages_json, created_at, updated_at \
+                     FROM ai_conversations ORDER BY updated_at DESC",
+                )
+                .map_err(|e| e.to_string())?;
+            let rows = stmt
+                .query_map([], |row| {
+                    let messages_json: String = row.get(4)?;
+                    let messages: Vec<AiChatMessage> =
+                        serde_json::from_str(&messages_json).map_err(map_from_sql_err)?;
+                    Ok(AiConversation {
+                        id: row.get(0)?,
+                        title: row.get(1)?,
+                        connection_name: row.get(2)?,
+                        database: row.get(3)?,
+                        messages,
+                        created_at: row.get(5)?,
+                        updated_at: row.get(6)?,
+                    })
+                })
+                .map_err(|e| e.to_string())?;
+            rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn delete_ai_conversation(&self, id: &str) -> Result<(), String> {
+        let id = id.to_string();
+        self.with_conn(move |conn| {
+            conn.execute("DELETE FROM ai_conversations WHERE id = ?1", [id]).map(|_| ()).map_err(|e| e.to_string())
+        })
+        .await
+    }
+}
+
+// Connections
+
+impl Storage {
+    pub async fn save_connection_metadata_preserving_secrets(
+        &self,
+        configs: &[ConnectionConfig],
+    ) -> Result<(), String> {
+        let configs = configs.to_vec();
+        self.with_conn(move |conn| {
+            let tx = conn.transaction().map_err(|e| e.to_string())?;
+            tx.execute("DELETE FROM connections", []).map_err(|e| e.to_string())?;
+
+            for config in &configs {
+                let config = config.canonicalized();
+                let config_id = config.id.clone();
+                let mut sanitized = config;
+                sanitized.password = String::new();
+                scrub_transport_layer_secrets(&mut sanitized);
+                sanitized.redis_sentinel_password = String::new();
+                sanitized.connection_string = None;
+                scrub_mq_auth_secrets(&mut sanitized);
+                scrub_mq_token_signing_secret(&mut sanitized);
+                scrub_nacos_auth_secrets(&mut sanitized);
+                let json = serde_json::to_string(&sanitized).map_err(|e| e.to_string())?;
+
+                tx.execute("INSERT INTO connections (id, config_json) VALUES (?1, ?2)", params![config_id, json])
+                    .map_err(|e| e.to_string())?;
+            }
+
+            if configs.is_empty() {
+                tx.execute("DELETE FROM connection_secrets", []).map_err(|e| e.to_string())?;
+            } else {
+                let placeholders = vec!["?"; configs.len()].join(",");
+                let sql = format!("DELETE FROM connection_secrets WHERE connection_id NOT IN ({placeholders})");
+                let ids = configs.iter().map(|config| &config.id as &dyn ToSql);
+                tx.execute(&sql, params_from_iter(ids)).map_err(|e| e.to_string())?;
+            }
+
+            tx.commit().map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn save_connections(&self, configs: &[ConnectionConfig]) -> Result<(), String> {
+        let configs = configs.to_vec();
+        self.with_conn(move |conn| {
+            let tx = conn.transaction().map_err(|e| e.to_string())?;
+            tx.execute("DELETE FROM connections", []).map_err(|e| e.to_string())?;
+
+            for config in &configs {
+                let config = config.canonicalized();
+                let config_id = config.id.clone();
+                let mut sanitized = config.clone();
+                sanitized.password = String::new();
+                scrub_transport_layer_secrets(&mut sanitized);
+                sanitized.redis_sentinel_password = String::new();
+                sanitized.connection_string = None;
+                scrub_mq_auth_secrets(&mut sanitized);
+                scrub_mq_token_signing_secret(&mut sanitized);
+                scrub_nacos_auth_secrets(&mut sanitized);
+                let json = serde_json::to_string(&sanitized).map_err(|e| e.to_string())?;
+
+                tx.execute("INSERT INTO connections (id, config_json) VALUES (?1, ?2)", params![config_id, json])
+                    .map_err(|e| e.to_string())?;
+
+                persist_secret_in_tx(&tx, &config.id, "password", &config.password)?;
+                delete_secret_prefix_in_tx(&tx, &config.id, TRANSPORT_LAYER_SECRET_PREFIX)?;
+                for (index, layer) in config.transport_layers.iter().enumerate() {
+                    match layer {
+                        TransportLayerConfig::Ssh(ssh) => {
+                            persist_secret_in_tx(
+                                &tx,
+                                &config.id,
+                                &transport_layer_ssh_password_key(index, layer),
+                                &ssh.password,
+                            )?;
+                            persist_secret_in_tx(
+                                &tx,
+                                &config.id,
+                                &transport_layer_ssh_key_passphrase_key(index, layer),
+                                &ssh.key_passphrase,
+                            )?;
+                        }
+                        TransportLayerConfig::Proxy(proxy) => {
+                            persist_secret_in_tx(
+                                &tx,
+                                &config.id,
+                                &transport_layer_proxy_password_key(index, layer),
+                                &proxy.password,
+                            )?;
+                        }
+                        TransportLayerConfig::HttpTunnel(http) => {
+                            persist_secret_in_tx(
+                                &tx,
+                                &config.id,
+                                &transport_layer_http_tunnel_token_key(index, layer),
+                                &http.token,
+                            )?;
+                        }
+                    }
+                }
+                persist_secret_in_tx(&tx, &config.id, "redis_sentinel_password", &config.redis_sentinel_password)?;
+                persist_secret_in_tx(&tx, &config.id, "ssh_password", "")?;
+                persist_secret_in_tx(&tx, &config.id, "ssh_key_passphrase", "")?;
+                persist_secret_in_tx(&tx, &config.id, "proxy_password", "")?;
+                delete_secret_prefix_in_tx(&tx, &config.id, SSH_TUNNEL_SECRET_PREFIX)?;
+                if let Some(cs) = &config.connection_string {
+                    persist_secret_in_tx(&tx, &config.id, "connection_string", cs)?;
+                } else {
+                    tx.execute(
+                        "DELETE FROM connection_secrets WHERE connection_id = ?1 AND key = ?2",
+                        params![config.id, "connection_string"],
+                    )
+                    .map_err(|e| e.to_string())?;
+                }
+                persist_mq_auth_secrets_in_tx(&tx, &config)?;
+                persist_mq_token_signing_secret_in_tx(&tx, &config)?;
+                persist_nacos_auth_secrets_in_tx(&tx, &config)?;
+            }
+
+            if configs.is_empty() {
+                tx.execute("DELETE FROM connection_secrets", []).map_err(|e| e.to_string())?;
+            } else {
+                let placeholders = vec!["?"; configs.len()].join(",");
+                let sql = format!("DELETE FROM connection_secrets WHERE connection_id NOT IN ({placeholders})");
+                let ids = configs.iter().map(|config| &config.id as &dyn ToSql);
+                tx.execute(&sql, params_from_iter(ids)).map_err(|e| e.to_string())?;
+            }
+
+            tx.commit().map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn load_connections(&self) -> Result<Vec<ConnectionConfig>, String> {
+        let rows: Vec<(String, String)> = self
+            .with_conn(|conn| {
+                let mut stmt = conn.prepare("SELECT id, config_json FROM connections").map_err(|e| e.to_string())?;
+                let rows = stmt
+                    .query_map([], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?)))
+                    .map_err(|e| e.to_string())?;
+                rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
+            })
+            .await?;
+
+        let mut configs = Vec::new();
+        for (id, json) in rows {
+            let mut config: ConnectionConfig = serde_json::from_str(&json).map_err(|e| e.to_string())?;
+            config.password = self.get_secret(&id, "password").await?.unwrap_or_default();
+            for index in 0..config.transport_layers.len() {
+                let layer_for_key = config.transport_layers[index].clone();
+                match &mut config.transport_layers[index] {
+                    TransportLayerConfig::Ssh(ssh) => {
+                        ssh.password = self
+                            .get_secret(&id, &transport_layer_ssh_password_key(index, &layer_for_key))
+                            .await?
+                            .or(match &layer_for_key {
+                                TransportLayerConfig::Ssh(layer) if layer.id == "legacy" => {
+                                    self.get_secret(&id, "ssh_password").await?
+                                }
+                                TransportLayerConfig::Ssh(layer) => {
+                                    self.get_secret(&id, &ssh_tunnel_password_key(index, layer)).await?
+                                }
+                                TransportLayerConfig::Proxy(_) | TransportLayerConfig::HttpTunnel(_) => None,
+                            })
+                            .unwrap_or_default();
+                        ssh.key_passphrase = self
+                            .get_secret(&id, &transport_layer_ssh_key_passphrase_key(index, &layer_for_key))
+                            .await?
+                            .or(match &layer_for_key {
+                                TransportLayerConfig::Ssh(layer) if layer.id == "legacy" => {
+                                    self.get_secret(&id, "ssh_key_passphrase").await?
+                                }
+                                TransportLayerConfig::Ssh(layer) => {
+                                    self.get_secret(&id, &ssh_tunnel_key_passphrase_key(index, layer)).await?
+                                }
+                                TransportLayerConfig::Proxy(_) | TransportLayerConfig::HttpTunnel(_) => None,
+                            })
+                            .unwrap_or_default();
+                    }
+                    TransportLayerConfig::Proxy(proxy) => {
+                        proxy.password = self
+                            .get_secret(&id, &transport_layer_proxy_password_key(index, &layer_for_key))
+                            .await?
+                            .or(match &layer_for_key {
+                                TransportLayerConfig::Proxy(layer) if layer.id == "legacy-proxy" => {
+                                    self.get_secret(&id, "proxy_password").await?
+                                }
+                                _ => None,
+                            })
+                            .unwrap_or_default();
+                    }
+                    TransportLayerConfig::HttpTunnel(http) => {
+                        http.token = self
+                            .get_secret(&id, &transport_layer_http_tunnel_token_key(index, &layer_for_key))
+                            .await?
+                            .unwrap_or_default();
+                    }
+                }
+            }
+            config.redis_sentinel_password = self.get_secret(&id, "redis_sentinel_password").await?.unwrap_or_default();
+            config.connection_string = self.get_secret(&id, "connection_string").await?;
+            let needs_mq_auth_rewrite = self.hydrate_mq_auth_secrets(&id, &mut config).await?;
+            let needs_mq_token_signing_rewrite = self.hydrate_mq_token_signing_secret(&id, &mut config).await?;
+            let needs_nacos_auth_rewrite = self.hydrate_nacos_auth_secret(&id, &mut config).await?;
+            let needs_external_secret_rewrite =
+                needs_mq_auth_rewrite || needs_mq_token_signing_rewrite || needs_nacos_auth_rewrite;
+            if needs_external_secret_rewrite {
+                let mut sanitized = config.clone().canonicalized();
+                scrub_mq_auth_secrets(&mut sanitized);
+                scrub_mq_token_signing_secret(&mut sanitized);
+                scrub_nacos_auth_secrets(&mut sanitized);
+                let sanitized_json = serde_json::to_string(&sanitized).map_err(|e| e.to_string())?;
+                let update_id = id.clone();
+                self.with_conn(move |conn| {
+                    conn.execute(
+                        "UPDATE connections SET config_json = ?1 WHERE id = ?2",
+                        params![sanitized_json, update_id],
+                    )
+                    .map(|_| ())
+                    .map_err(|e| e.to_string())
+                })
+                .await?;
+            }
+            configs.push(config.canonicalized());
+        }
+        Ok(configs)
+    }
+
+    async fn hydrate_mq_auth_secrets(
+        &self,
+        connection_id: &str,
+        config: &mut ConnectionConfig,
+    ) -> Result<bool, String> {
+        if config.db_type != DatabaseType::MessageQueue {
+            return Ok(false);
+        }
+        let Some(auth) = mq_auth_object_mut(config.external_config.as_mut()) else {
+            return Ok(false);
+        };
+
+        let needs_rewrite = match mq_auth_kind(auth) {
+            Some("token") => hydrate_mq_json_secret(self, connection_id, MQ_AUTH_TOKEN_KEY, auth, "token").await?,
+            Some("basic") => {
+                hydrate_mq_json_secret(self, connection_id, MQ_AUTH_PASSWORD_KEY, auth, "password").await?
+            }
+            Some(kind) if is_api_key_auth_kind(kind) => {
+                hydrate_mq_json_secret(self, connection_id, MQ_AUTH_API_KEY_VALUE_KEY, auth, "value").await?
+            }
+            Some("oauth2") => {
+                hydrate_mq_json_secret(self, connection_id, MQ_AUTH_CLIENT_SECRET_KEY, auth, "clientSecret").await?
+            }
+            _ => false,
+        };
+
+        Ok(needs_rewrite)
+    }
+
+    async fn hydrate_mq_token_signing_secret(
+        &self,
+        connection_id: &str,
+        config: &mut ConnectionConfig,
+    ) -> Result<bool, String> {
+        if config.db_type != DatabaseType::MessageQueue {
+            return Ok(false);
+        }
+        let Some(signing) = mq_token_signing_object_mut(config.external_config.as_mut()) else {
+            return Ok(false);
+        };
+
+        hydrate_mq_json_secret(self, connection_id, MQ_TOKEN_SIGNING_KEY, signing, "key").await
+    }
+
+    async fn hydrate_nacos_auth_secret(
+        &self,
+        connection_id: &str,
+        config: &mut ConnectionConfig,
+    ) -> Result<bool, String> {
+        if config.db_type != DatabaseType::Nacos {
+            return Ok(false);
+        }
+        let Some(auth) = nacos_auth_object_mut(config.external_config.as_mut()) else {
+            return Ok(false);
+        };
+        if auth.get("kind").and_then(serde_json::Value::as_str) != Some("usernamePassword") {
+            return Ok(false);
+        }
+
+        hydrate_mq_json_secret(self, connection_id, NACOS_AUTH_PASSWORD_KEY, auth, "password").await
+    }
+}
+
+// Saved SQL
+
+impl Storage {
+    pub async fn replace_saved_sql_library(&self, library: &SavedSqlLibrary) -> Result<(), String> {
+        let library = library.clone();
+        self.with_conn(move |conn| {
+            let tx = conn.transaction().map_err(|e| e.to_string())?;
+            tx.execute("DELETE FROM saved_sql_files", []).map_err(|e| e.to_string())?;
+            tx.execute("DELETE FROM saved_sql_folders", []).map_err(|e| e.to_string())?;
+
+            for folder in &library.folders {
+                tx.execute(
+                    "INSERT INTO saved_sql_folders (id, connection_id, parent_folder_id, name, order_index, created_at, updated_at) \
+                     VALUES (?, ?, ?, ?, ?, ?, ?)",
+                    params![
+                        folder.id,
+                        folder.connection_id,
+                        folder.parent_folder_id,
+                        folder.name,
+                        folder.order_index,
+                        folder.created_at,
+                        folder.updated_at
+                    ],
+                )
+                .map_err(|e| e.to_string())?;
+            }
+
+            for file in &library.files {
+                tx.execute(
+                    "INSERT INTO saved_sql_files \
+                     (id, connection_id, folder_id, name, database_name, schema_name, sql_text, order_index, open_count, opened_at, created_at, updated_at) \
+                     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                    params![
+                        file.id,
+                        file.connection_id,
+                        file.folder_id,
+                        file.name,
+                        file.database,
+                        file.schema,
+                        file.sql,
+                        file.order_index,
+                        file.open_count,
+                        file.opened_at,
+                        file.created_at,
+                        file.updated_at
+                    ],
+                )
+                .map_err(|e| e.to_string())?;
+            }
+
+            tx.commit().map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn load_saved_sql_library(&self) -> Result<SavedSqlLibrary, String> {
+        self.with_conn(|conn| {
+            let mut folder_stmt = conn
+                .prepare(
+                    "SELECT id, connection_id, parent_folder_id, name, order_index, created_at, updated_at \
+                     FROM saved_sql_folders ORDER BY COALESCE(parent_folder_id, ''), order_index, connection_id, name COLLATE NOCASE",
+                )
+                .map_err(|e| e.to_string())?;
+            let folders = folder_stmt
+                .query_map([], |row| {
+                    Ok(SavedSqlFolder {
+                        id: row.get(0)?,
+                        connection_id: row.get(1)?,
+                        parent_folder_id: row.get(2)?,
+                        name: row.get(3)?,
+                        order_index: row.get(4)?,
+                        created_at: row.get(5)?,
+                        updated_at: row.get(6)?,
+                    })
+                })
+                .map_err(|e| e.to_string())?
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|e| e.to_string())?;
+
+            let mut file_stmt = conn
+                .prepare(
+                    "SELECT id, connection_id, folder_id, name, database_name, schema_name, sql_text, order_index, open_count, opened_at, created_at, updated_at \
+                     FROM saved_sql_files ORDER BY COALESCE(folder_id, ''), order_index, connection_id, name COLLATE NOCASE",
+                )
+                .map_err(|e| e.to_string())?;
+            let files = file_stmt
+                .query_map([], |row| {
+                    Ok(SavedSqlFile {
+                        id: row.get(0)?,
+                        connection_id: row.get(1)?,
+                        folder_id: row.get(2)?,
+                        name: row.get(3)?,
+                        database: row.get(4)?,
+                        schema: row.get(5)?,
+                        sql: row.get(6)?,
+                        sql_loaded: true,
+                        order_index: row.get(7)?,
+                        open_count: row.get(8)?,
+                        opened_at: row.get(9)?,
+                        created_at: row.get(10)?,
+                        updated_at: row.get(11)?,
+                    })
+                })
+                .map_err(|e| e.to_string())?
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|e| e.to_string())?;
+
+            Ok(SavedSqlLibrary { folders, files })
+        })
+        .await
+    }
+
+    pub async fn load_saved_sql_library_summary(&self) -> Result<SavedSqlLibrary, String> {
+        self.with_conn(|conn| {
+            let mut folder_stmt = conn
+                .prepare(
+                    "SELECT id, connection_id, parent_folder_id, name, order_index, created_at, updated_at \
+                     FROM saved_sql_folders ORDER BY COALESCE(parent_folder_id, ''), order_index, connection_id, name COLLATE NOCASE",
+                )
+                .map_err(|e| e.to_string())?;
+            let folders = folder_stmt
+                .query_map([], |row| {
+                    Ok(SavedSqlFolder {
+                        id: row.get(0)?,
+                        connection_id: row.get(1)?,
+                        parent_folder_id: row.get(2)?,
+                        name: row.get(3)?,
+                        order_index: row.get(4)?,
+                        created_at: row.get(5)?,
+                        updated_at: row.get(6)?,
+                    })
+                })
+                .map_err(|e| e.to_string())?
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|e| e.to_string())?;
+
+            let mut file_stmt = conn
+                .prepare(
+                    "SELECT id, connection_id, folder_id, name, database_name, schema_name, order_index, open_count, opened_at, created_at, updated_at \
+                     FROM saved_sql_files ORDER BY COALESCE(folder_id, ''), order_index, connection_id, name COLLATE NOCASE",
+                )
+                .map_err(|e| e.to_string())?;
+            let files = file_stmt
+                .query_map([], |row| {
+                    Ok(SavedSqlFile {
+                        id: row.get(0)?,
+                        connection_id: row.get(1)?,
+                        folder_id: row.get(2)?,
+                        name: row.get(3)?,
+                        database: row.get(4)?,
+                        schema: row.get(5)?,
+                        sql: String::new(),
+                        sql_loaded: false,
+                        order_index: row.get(6)?,
+                        open_count: row.get(7)?,
+                        opened_at: row.get(8)?,
+                        created_at: row.get(9)?,
+                        updated_at: row.get(10)?,
+                    })
+                })
+                .map_err(|e| e.to_string())?
+                .collect::<Result<Vec<_>, _>>()
+                .map_err(|e| e.to_string())?;
+
+            Ok(SavedSqlLibrary { folders, files })
+        })
+        .await
+    }
+
+    pub async fn load_saved_sql_file(&self, id: &str) -> Result<Option<SavedSqlFile>, String> {
+        let id = id.to_string();
+        self.with_conn(move |conn| {
+            let mut stmt = conn
+                .prepare(
+                    "SELECT id, connection_id, folder_id, name, database_name, schema_name, sql_text, order_index, open_count, opened_at, created_at, updated_at \
+                     FROM saved_sql_files WHERE id = ?1",
+                )
+                .map_err(|e| e.to_string())?;
+            match stmt.query_row([id], |row| {
+                Ok(SavedSqlFile {
+                    id: row.get(0)?,
+                    connection_id: row.get(1)?,
+                    folder_id: row.get(2)?,
+                    name: row.get(3)?,
+                    database: row.get(4)?,
+                    schema: row.get(5)?,
+                    sql: row.get(6)?,
+                    sql_loaded: true,
+                    order_index: row.get(7)?,
+                    open_count: row.get(8)?,
+                    opened_at: row.get(9)?,
+                    created_at: row.get(10)?,
+                    updated_at: row.get(11)?,
+                })
+            }) {
+                Ok(file) => Ok(Some(file)),
+                Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None),
+                Err(err) => Err(err.to_string()),
+            }
+        })
+        .await
+    }
+
+    pub async fn save_saved_sql_folder(&self, folder: &SavedSqlFolder) -> Result<(), String> {
+        let folder = folder.clone();
+        self.with_conn(move |conn| {
+            conn.execute(
+                "INSERT INTO saved_sql_folders (id, connection_id, parent_folder_id, name, order_index, created_at, updated_at) \
+                 VALUES (?, ?, ?, ?, ?, ?, ?) \
+                 ON CONFLICT(id) DO UPDATE SET \
+                 connection_id = excluded.connection_id, \
+                 parent_folder_id = excluded.parent_folder_id, \
+                 name = excluded.name, \
+                 order_index = excluded.order_index, \
+                 updated_at = excluded.updated_at",
+                params![
+                    folder.id,
+                    folder.connection_id,
+                    folder.parent_folder_id,
+                    folder.name,
+                    folder.order_index,
+                    folder.created_at,
+                    folder.updated_at
+                ],
+            )
+            .map(|_| ())
+            .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn delete_saved_sql_folder(&self, id: &str) -> Result<(), String> {
+        let id = id.to_string();
+        self.with_conn(move |conn| {
+            let tx = conn.transaction().map_err(|e| e.to_string())?;
+            let mut folder_ids = vec![id.clone()];
+            let mut index = 0;
+            while index < folder_ids.len() {
+                let parent_id = folder_ids[index].clone();
+                let mut stmt = tx
+                    .prepare("SELECT id FROM saved_sql_folders WHERE parent_folder_id = ?1")
+                    .map_err(|e| e.to_string())?;
+                let child_ids = stmt
+                    .query_map([parent_id.as_str()], |row| row.get::<_, String>(0))
+                    .map_err(|e| e.to_string())?
+                    .collect::<Result<Vec<_>, _>>()
+                    .map_err(|e| e.to_string())?;
+                folder_ids.extend(child_ids);
+                index += 1;
+            }
+            for folder_id in folder_ids.iter().rev() {
+                tx.execute("DELETE FROM saved_sql_files WHERE folder_id = ?1", [folder_id.as_str()])
+                    .map_err(|e| e.to_string())?;
+                tx.execute("DELETE FROM saved_sql_folders WHERE id = ?1", [folder_id.as_str()])
+                    .map_err(|e| e.to_string())?;
+            }
+            tx.commit().map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn save_saved_sql_file(&self, file: &SavedSqlFile) -> Result<(), String> {
+        let file = file.clone();
+        self.with_conn(move |conn| {
+            conn.execute(
+                "INSERT INTO saved_sql_files \
+                 (id, connection_id, folder_id, name, database_name, schema_name, sql_text, order_index, open_count, opened_at, created_at, updated_at) \
+                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) \
+                 ON CONFLICT(id) DO UPDATE SET \
+                 connection_id = excluded.connection_id, \
+                 folder_id = excluded.folder_id, \
+                 name = excluded.name, \
+                 database_name = excluded.database_name, \
+                 schema_name = excluded.schema_name, \
+                 sql_text = CASE WHEN ?13 THEN excluded.sql_text ELSE saved_sql_files.sql_text END, \
+                 order_index = excluded.order_index, \
+                 open_count = excluded.open_count, \
+                 opened_at = excluded.opened_at, \
+                 updated_at = excluded.updated_at",
+                params![
+                    file.id,
+                    file.connection_id,
+                    file.folder_id,
+                    file.name,
+                    file.database,
+                    file.schema,
+                    file.sql,
+                    file.order_index,
+                    file.open_count,
+                    file.opened_at,
+                    file.created_at,
+                    file.updated_at,
+                    file.sql_loaded
+                ],
+            )
+            .map(|_| ())
+            .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn delete_saved_sql_file(&self, id: &str) -> Result<(), String> {
+        let id = id.to_string();
+        self.with_conn(move |conn| {
+            conn.execute("DELETE FROM saved_sql_files WHERE id = ?1", [id]).map(|_| ()).map_err(|e| e.to_string())
+        })
+        .await
+    }
+}
+
+// Secrets
+
+impl Storage {
+    pub async fn get_secret(&self, connection_id: &str, key: &str) -> Result<Option<String>, String> {
+        let connection_id = connection_id.to_string();
+        let key = key.to_string();
+        self.with_conn(move |conn| {
+            conn.query_row(
+                "SELECT secret FROM connection_secrets WHERE connection_id = ?1 AND key = ?2",
+                params![connection_id, key],
+                |row| row.get(0),
+            )
+            .optional()
+            .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn set_secret(&self, connection_id: &str, key: &str, secret: &str) -> Result<(), String> {
+        let connection_id = connection_id.to_string();
+        let key = key.to_string();
+        let secret = secret.to_string();
+        self.with_conn(move |conn| {
+            conn.execute(
+                "INSERT OR REPLACE INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)",
+                params![connection_id, key, secret],
+            )
+            .map(|_| ())
+            .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn delete_secret(&self, connection_id: &str, key: &str) -> Result<(), String> {
+        let connection_id = connection_id.to_string();
+        let key = key.to_string();
+        self.with_conn(move |conn| {
+            conn.execute(
+                "DELETE FROM connection_secrets WHERE connection_id = ?1 AND key = ?2",
+                params![connection_id, key],
+            )
+            .map(|_| ())
+            .map_err(|e| e.to_string())
+        })
+        .await
+    }
+}
+
+// MQ token records
+
+#[cfg(feature = "mq-admin")]
+impl Storage {
+    pub async fn save_mq_token_record(&self, record: &crate::mq::MqTokenRecord) -> Result<(), String> {
+        let record = record.clone();
+        self.with_conn(move |conn| {
+            let scope_json = record
+                .scope
+                .as_ref()
+                .map(serde_json::to_string)
+                .transpose()
+                .map_err(|e| e.to_string())?;
+            let actions_json = serde_json::to_string(&record.actions).map_err(|e| e.to_string())?;
+            conn.execute(
+                "INSERT OR REPLACE INTO mq_token_records \
+                 (id, connection_id, subject, algorithm, token_fingerprint, scope_json, actions_json, expires_at, created_at, note) \
+                 VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)",
+                params![
+                    record.id,
+                    record.connection_id,
+                    record.subject,
+                    record.algorithm.as_str(),
+                    record.token_fingerprint,
+                    scope_json,
+                    actions_json,
+                    record.expires_at,
+                    record.created_at,
+                    record.note
+                ],
+            )
+            .map(|_| ())
+            .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn load_mq_token_records(
+        &self,
+        connection_id: &str,
+        subject: Option<&str>,
+    ) -> Result<Vec<crate::mq::MqTokenRecord>, String> {
+        let connection_id = connection_id.to_string();
+        let subject = subject.map(str::to_string);
+        self.with_conn(move |conn| {
+            let sql = if subject.is_some() {
+                "SELECT id, connection_id, subject, algorithm, token_fingerprint, scope_json, actions_json, expires_at, created_at, note \
+                 FROM mq_token_records WHERE connection_id = ?1 AND subject = ?2 ORDER BY created_at DESC"
+            } else {
+                "SELECT id, connection_id, subject, algorithm, token_fingerprint, scope_json, actions_json, expires_at, created_at, note \
+                 FROM mq_token_records WHERE connection_id = ?1 ORDER BY created_at DESC"
+            };
+            let mut stmt = conn.prepare(sql).map_err(|e| e.to_string())?;
+            let rows = if let Some(subject) = subject {
+                stmt.query_map(params![connection_id, subject], mq_token_record_from_row)
+                    .map_err(|e| e.to_string())?
+                    .collect::<Result<Vec<_>, _>>()
+                    .map_err(|e| e.to_string())?
+            } else {
+                stmt.query_map(params![connection_id], mq_token_record_from_row)
+                    .map_err(|e| e.to_string())?
+                    .collect::<Result<Vec<_>, _>>()
+                    .map_err(|e| e.to_string())?
+            };
+            Ok(rows)
+        })
+        .await
+    }
+}
+
+// Layout
+
+impl Storage {
+    pub async fn save_sidebar_layout(&self, layout: &serde_json::Value) -> Result<(), String> {
+        let json = serde_json::to_string(layout).map_err(|e| e.to_string())?;
+        self.with_conn(move |conn| {
+            conn.execute("INSERT OR REPLACE INTO sidebar_layout (id, layout_json) VALUES (1, ?1)", [json])
+                .map(|_| ())
+                .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn load_sidebar_layout(&self) -> Result<Option<serde_json::Value>, String> {
+        let json: Option<String> = self
+            .with_conn(|conn| {
+                conn.query_row("SELECT layout_json FROM sidebar_layout WHERE id = 1", [], |row| row.get(0))
+                    .optional()
+                    .map_err(|e| e.to_string())
+            })
+            .await?;
+        json.map(|value| serde_json::from_str(&value).map_err(|e| e.to_string())).transpose()
+    }
+}
+
+// Schema cache
+
+impl Storage {
+    pub async fn save_schema_cache(&self, cache_key: &str, payload: &serde_json::Value) -> Result<(), String> {
+        let cache_key = cache_key.to_string();
+        let json = serde_json::to_string(payload).map_err(|e| e.to_string())?;
+        self.with_conn(move |conn| {
+            conn.execute(
+                "INSERT OR REPLACE INTO schema_cache (cache_key, payload_json, updated_at) \
+                 VALUES (?1, ?2, datetime('now'))",
+                params![cache_key, json],
+            )
+            .map(|_| ())
+            .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn load_schema_cache(&self, cache_key: &str) -> Result<Option<serde_json::Value>, String> {
+        let cache_key = cache_key.to_string();
+        let json: Option<String> = self
+            .with_conn(move |conn| {
+                conn.query_row("SELECT payload_json FROM schema_cache WHERE cache_key = ?1", [cache_key], |row| {
+                    row.get(0)
+                })
+                .optional()
+                .map_err(|e| e.to_string())
+            })
+            .await?;
+        json.map(|value| serde_json::from_str(&value).map_err(|e| e.to_string())).transpose()
+    }
+
+    pub async fn delete_schema_cache_prefix(&self, prefix: &str) -> Result<(), String> {
+        let prefix = prefix.to_string();
+        let prefix_len = prefix.len() as i64;
+        self.with_conn(move |conn| {
+            conn.execute(
+                "DELETE FROM schema_cache WHERE cache_key = ?1 OR substr(cache_key, 1, ?2) = ?3",
+                params![prefix.clone(), prefix_len, prefix],
+            )
+            .map(|_| ())
+            .map_err(|e| e.to_string())
+        })
+        .await
+    }
+}
+
+// Tab runtime cache
+
+impl Storage {
+    pub async fn save_tab_runtime_cache(
+        &self,
+        key: &str,
+        payload: Vec<u8>,
+        row_count: i64,
+        column_count: i64,
+    ) -> Result<(), String> {
+        let key = key.to_string();
+        let byte_size = payload.len() as i64;
+        self.with_conn(move |conn| {
+            conn.execute(
+                "INSERT INTO tab_runtime_cache \
+                 (cache_key, payload, row_count, column_count, byte_size, updated_at) \
+                 VALUES (?1, ?2, ?3, ?4, ?5, datetime('now')) \
+                 ON CONFLICT(cache_key) DO UPDATE SET \
+                 payload = excluded.payload, row_count = excluded.row_count, column_count = excluded.column_count, \
+                 byte_size = excluded.byte_size, updated_at = excluded.updated_at",
+                params![key, payload, row_count, column_count, byte_size],
+            )
+            .map(|_| ())
+            .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn load_tab_runtime_cache(&self, key: &str) -> Result<Option<TabRuntimeCacheEntry>, String> {
+        let key = key.to_string();
+        self.with_conn(move |conn| {
+            conn.query_row(
+                "SELECT cache_key, payload, row_count, column_count, byte_size, updated_at \
+                 FROM tab_runtime_cache WHERE cache_key = ?1",
+                [key],
+                |row| {
+                    Ok(TabRuntimeCacheEntry {
+                        key: row.get(0)?,
+                        payload: row.get(1)?,
+                        row_count: row.get(2)?,
+                        column_count: row.get(3)?,
+                        byte_size: row.get(4)?,
+                        updated_at: row.get(5)?,
+                    })
+                },
+            )
+            .optional()
+            .map_err(|e| e.to_string())
+        })
+        .await
+    }
+
+    pub async fn delete_tab_runtime_cache(&self, key: &str) -> Result<(), String> {
+        let key = key.to_string();
+        self.with_conn(move |conn| {
+            conn.execute("DELETE FROM tab_runtime_cache WHERE cache_key = ?1", [key])
+                .map(|_| ())
+                .map_err(|e| e.to_string())
+        })
+        .await
+    }
+}
+
+// JSON migration
+
+impl Storage {
+    pub async fn migrate_from_json(&self, data_dir: &Path) -> Result<(), String> {
+        self.migrate_connections_json(data_dir).await?;
+        self.migrate_secrets_json(data_dir).await?;
+        self.migrate_history_json(data_dir).await?;
+        self.migrate_ai_config_json(data_dir).await?;
+        self.migrate_ai_conversations_json(data_dir).await?;
+        self.migrate_sidebar_layout_json(data_dir).await?;
+        Ok(())
+    }
+
+    async fn migrate_connections_json(&self, data_dir: &Path) -> Result<(), String> {
+        let path = data_dir.join("connections.json");
+        if tokio::fs::metadata(&path).await.is_err() {
+            return Ok(());
+        }
+        let json = tokio::fs::read_to_string(&path).await.map_err(|e| e.to_string())?;
+        let configs: Vec<ConnectionConfig> = serde_json::from_str(&json).unwrap_or_default();
+        for config in &configs {
+            let config_json = serde_json::to_string(config).map_err(|e| e.to_string())?;
+            let id = config.id.clone();
+            self.with_conn(move |conn| {
+                conn.execute(
+                    "INSERT OR IGNORE INTO connections (id, config_json) VALUES (?1, ?2)",
+                    params![id, config_json],
+                )
+                .map(|_| ())
+                .map_err(|e| e.to_string())
+            })
+            .await?;
+        }
+        let _ = tokio::fs::rename(&path, data_dir.join("connections.json.bak")).await;
+        Ok(())
+    }
+
+    async fn migrate_secrets_json(&self, data_dir: &Path) -> Result<(), String> {
+        let path = data_dir.join("secrets.json");
+        if tokio::fs::metadata(&path).await.is_err() {
+            return Ok(());
+        }
+        let json = tokio::fs::read_to_string(&path).await.map_err(|e| e.to_string())?;
+        let secrets: HashMap<String, String> = serde_json::from_str(&json).unwrap_or_default();
+        for (key, secret) in &secrets {
+            let parts: Vec<&str> = key.splitn(3, ':').collect();
+            if parts.len() == 3 && parts[0] == "connection" {
+                let connection_id = parts[1].to_string();
+                let field = parts[2].to_string();
+                let secret = secret.clone();
+                self.with_conn(move |conn| {
+                    conn.execute(
+                        "INSERT OR IGNORE INTO connection_secrets (connection_id, key, secret) VALUES (?1, ?2, ?3)",
+                        params![connection_id, field, secret],
+                    )
+                    .map(|_| ())
+                    .map_err(|e| e.to_string())
+                })
+                .await?;
+            }
+        }
+        let _ = tokio::fs::rename(&path, data_dir.join("secrets.json.bak")).await;
+        Ok(())
+    }
+
+    async fn migrate_history_json(&self, data_dir: &Path) -> Result<(), String> {
+        let path = data_dir.join("query_history.json");
+        if tokio::fs::metadata(&path).await.is_err() {
+            return Ok(());
+        }
+        let json = tokio::fs::read_to_string(&path).await.map_err(|e| e.to_string())?;
+        let entries: Vec<HistoryEntry> = serde_json::from_str(&json).unwrap_or_default();
+        for entry in &entries {
+            self.save_history_entry(entry).await?;
+        }
+        let _ = tokio::fs::rename(&path, data_dir.join("query_history.json.bak")).await;
+        Ok(())
+    }
+
+    async fn migrate_ai_config_json(&self, data_dir: &Path) -> Result<(), String> {
+        let path = data_dir.join("ai_config.json");
+        if tokio::fs::metadata(&path).await.is_err() {
+            return Ok(());
+        }
+        let json = tokio::fs::read_to_string(&path).await.map_err(|e| e.to_string())?;
+        let count: i64 = self
+            .with_conn(|conn| {
+                conn.query_row("SELECT COUNT(*) FROM ai_config", [], |row| row.get(0)).map_err(|e| e.to_string())
+            })
+            .await?;
+        if count == 0 {
+            self.with_conn(move |conn| {
+                conn.execute("INSERT OR IGNORE INTO ai_config (id, config_json) VALUES (1, ?1)", [json])
+                    .map(|_| ())
+                    .map_err(|e| e.to_string())
+            })
+            .await?;
+        }
+        let _ = tokio::fs::rename(&path, data_dir.join("ai_config.json.bak")).await;
+        Ok(())
+    }
+
+    async fn migrate_ai_conversations_json(&self, data_dir: &Path) -> Result<(), String> {
+        let path = data_dir.join("ai_conversations.json");
+        if tokio::fs::metadata(&path).await.is_err() {
+            return Ok(());
+        }
+        let json = tokio::fs::read_to_string(&path).await.map_err(|e| e.to_string())?;
+        let conversations: Vec<AiConversation> = serde_json::from_str(&json).unwrap_or_default();
+        for conv in &conversations {
+            let conv = conv.clone();
+            let messages_json = serde_json::to_string(&conv.messages).map_err(|e| e.to_string())?;
+            self.with_conn(move |conn| {
+                conn.execute(
+                    "INSERT OR IGNORE INTO ai_conversations \
+                     (id, title, connection_name, database, messages_json, created_at, updated_at) \
+                     VALUES (?, ?, ?, ?, ?, ?, ?)",
+                    params![
+                        conv.id,
+                        conv.title,
+                        conv.connection_name,
+                        conv.database,
+                        messages_json,
+                        conv.created_at,
+                        conv.updated_at
+                    ],
+                )
+                .map(|_| ())
+                .map_err(|e| e.to_string())
+            })
+            .await?;
+        }
+        let _ = tokio::fs::rename(&path, data_dir.join("ai_conversations.json.bak")).await;
+        Ok(())
+    }
+
+    async fn migrate_sidebar_layout_json(&self, data_dir: &Path) -> Result<(), String> {
+        let path = data_dir.join("sidebar_layout.json");
+        if tokio::fs::metadata(&path).await.is_err() {
+            return Ok(());
+        }
+        let json = tokio::fs::read_to_string(&path).await.map_err(|e| e.to_string())?;
+        let count: i64 = self
+            .with_conn(|conn| {
+                conn.query_row("SELECT COUNT(*) FROM sidebar_layout", [], |row| row.get(0)).map_err(|e| e.to_string())
+            })
+            .await?;
+        if count == 0 {
+            self.with_conn(move |conn| {
+                conn.execute("INSERT OR IGNORE INTO sidebar_layout (id, layout_json) VALUES (1, ?1)", [json])
+                    .map(|_| ())
+                    .map_err(|e| e.to_string())
+            })
+            .await?;
+        }
+        let _ = tokio::fs::rename(&path, data_dir.join("sidebar_layout.json.bak")).await;
+        Ok(())
+    }
+}
+
+fn persist_secret_in_tx(
+    tx: &rusqlite::Transaction<'_>,
+    connection_id: &str,
+    key: &str,
+    secret: &str,
+) -> Result<(), String> {
+    if secret.is_empty() {
+        tx.execute("DELETE FROM connection_secrets WHERE connection_id = ?1 AND key = ?2", params![connection_id, key])
+            .map_err(|e| e.to_string())?;
+    } else {
+        tx.execute(
+            "INSERT OR REPLACE INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)",
+            params![connection_id, key, secret],
+        )
+        .map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}
+
+fn persist_mq_auth_secrets_in_tx(tx: &rusqlite::Transaction<'_>, config: &ConnectionConfig) -> Result<(), String> {
+    if config.db_type != DatabaseType::MessageQueue {
+        delete_secret_prefix_in_tx(tx, &config.id, MQ_AUTH_SECRET_PREFIX)?;
+        return Ok(());
+    }
+
+    let Some(auth) = mq_auth_object(config.external_config.as_ref()) else {
+        delete_secret_prefix_in_tx(tx, &config.id, MQ_AUTH_SECRET_PREFIX)?;
+        return Ok(());
+    };
+
+    match mq_auth_kind(auth) {
+        Some("none") => delete_secret_prefix_in_tx(tx, &config.id, MQ_AUTH_SECRET_PREFIX)?,
+        Some("token") => replace_mq_auth_secret_in_tx(tx, &config.id, MQ_AUTH_TOKEN_KEY, auth, "token")?,
+        Some("basic") => replace_mq_auth_secret_in_tx(tx, &config.id, MQ_AUTH_PASSWORD_KEY, auth, "password")?,
+        Some(kind) if is_api_key_auth_kind(kind) => {
+            replace_mq_auth_secret_in_tx(tx, &config.id, MQ_AUTH_API_KEY_VALUE_KEY, auth, "value")?
+        }
+        Some("oauth2") => {
+            replace_mq_auth_secret_in_tx(tx, &config.id, MQ_AUTH_CLIENT_SECRET_KEY, auth, "clientSecret")?
+        }
+        _ => delete_secret_prefix_in_tx(tx, &config.id, MQ_AUTH_SECRET_PREFIX)?,
+    }
+
+    Ok(())
+}
+
+fn replace_mq_auth_secret_in_tx(
+    tx: &rusqlite::Transaction<'_>,
+    connection_id: &str,
+    key: &str,
+    auth: &serde_json::Map<String, serde_json::Value>,
+    field: &str,
+) -> Result<(), String> {
+    let current = auth.get(field).and_then(serde_json::Value::as_str).filter(|secret| !secret.is_empty());
+    let existing = if current.is_none() { get_secret_in_tx(tx, connection_id, key)? } else { None };
+    delete_secret_prefix_in_tx(tx, connection_id, MQ_AUTH_SECRET_PREFIX)?;
+    match current {
+        Some(secret) => persist_secret_in_tx(tx, connection_id, key, secret),
+        None => match existing {
+            Some(secret) => persist_secret_in_tx(tx, connection_id, key, &secret),
+            None => Ok(()),
+        },
+    }
+}
+
+fn get_secret_in_tx(tx: &rusqlite::Transaction<'_>, connection_id: &str, key: &str) -> Result<Option<String>, String> {
+    tx.query_row(
+        "SELECT secret FROM connection_secrets WHERE connection_id = ?1 AND key = ?2",
+        params![connection_id, key],
+        |row| row.get(0),
+    )
+    .optional()
+    .map_err(|e| e.to_string())
+}
+
+fn persist_mq_token_signing_secret_in_tx(
+    tx: &rusqlite::Transaction<'_>,
+    config: &ConnectionConfig,
+) -> Result<(), String> {
+    if config.db_type != DatabaseType::MessageQueue {
+        delete_secret_prefix_in_tx(tx, &config.id, MQ_TOKEN_SIGNING_SECRET_PREFIX)?;
+        return Ok(());
+    }
+
+    let Some(signing) = mq_token_signing_object(config.external_config.as_ref()) else {
+        delete_secret_prefix_in_tx(tx, &config.id, MQ_TOKEN_SIGNING_SECRET_PREFIX)?;
+        return Ok(());
+    };
+
+    persist_json_secret_if_present_in_tx(tx, &config.id, MQ_TOKEN_SIGNING_KEY, signing, "key")
+}
+
+fn persist_nacos_auth_secrets_in_tx(tx: &rusqlite::Transaction<'_>, config: &ConnectionConfig) -> Result<(), String> {
+    if config.db_type != DatabaseType::Nacos {
+        delete_secret_prefix_in_tx(tx, &config.id, NACOS_AUTH_SECRET_PREFIX)?;
+        return Ok(());
+    }
+
+    let Some(auth) = nacos_auth_object(config.external_config.as_ref()) else {
+        delete_secret_prefix_in_tx(tx, &config.id, NACOS_AUTH_SECRET_PREFIX)?;
+        return Ok(());
+    };
+
+    if auth.get("kind").and_then(serde_json::Value::as_str) == Some("usernamePassword") {
+        replace_nacos_auth_secret_in_tx(tx, &config.id, NACOS_AUTH_PASSWORD_KEY, auth, "password")?;
+    } else {
+        delete_secret_prefix_in_tx(tx, &config.id, NACOS_AUTH_SECRET_PREFIX)?;
+    }
+
+    Ok(())
+}
+
+fn replace_nacos_auth_secret_in_tx(
+    tx: &rusqlite::Transaction<'_>,
+    connection_id: &str,
+    key: &str,
+    auth: &serde_json::Map<String, serde_json::Value>,
+    field: &str,
+) -> Result<(), String> {
+    let current = auth.get(field).and_then(serde_json::Value::as_str).filter(|secret| !secret.is_empty());
+    let existing = if current.is_none() { get_secret_in_tx(tx, connection_id, key)? } else { None };
+    delete_secret_prefix_in_tx(tx, connection_id, NACOS_AUTH_SECRET_PREFIX)?;
+    match current {
+        Some(secret) => persist_secret_in_tx(tx, connection_id, key, secret),
+        None => match existing {
+            Some(secret) => persist_secret_in_tx(tx, connection_id, key, &secret),
+            None => Ok(()),
+        },
+    }
+}
+
+fn persist_json_secret_if_present_in_tx(
+    tx: &rusqlite::Transaction<'_>,
+    connection_id: &str,
+    key: &str,
+    auth: &serde_json::Map<String, serde_json::Value>,
+    field: &str,
+) -> Result<(), String> {
+    if let Some(secret) = auth.get(field).and_then(serde_json::Value::as_str).filter(|secret| !secret.is_empty()) {
+        persist_secret_in_tx(tx, connection_id, key, secret)?;
+    }
+    Ok(())
+}
+
+async fn hydrate_mq_json_secret(
+    storage: &Storage,
+    connection_id: &str,
+    key: &str,
+    auth: &mut serde_json::Map<String, serde_json::Value>,
+    field: &str,
+) -> Result<bool, String> {
+    if let Some(secret) = auth.get(field).and_then(serde_json::Value::as_str).filter(|secret| !secret.is_empty()) {
+        storage.set_secret(connection_id, key, secret).await?;
+        Ok(true)
+    } else if let Some(secret) = storage.get_secret(connection_id, key).await? {
+        auth.insert(field.to_string(), serde_json::Value::String(secret));
+        Ok(false)
+    } else {
+        Ok(false)
+    }
+}
+
+fn scrub_json_secret(auth: &mut serde_json::Map<String, serde_json::Value>, field: &str) {
+    if auth.contains_key(field) {
+        auth.insert(field.to_string(), serde_json::Value::String(String::new()));
+    }
+}
+
+fn mq_auth_kind(auth: &serde_json::Map<String, serde_json::Value>) -> Option<&str> {
+    auth.get("kind").and_then(serde_json::Value::as_str)
+}
+
+fn mq_auth_object(value: Option<&serde_json::Value>) -> Option<&serde_json::Map<String, serde_json::Value>> {
+    value?.get("auth")?.as_object()
+}
+
+fn mq_auth_object_mut(
+    value: Option<&mut serde_json::Value>,
+) -> Option<&mut serde_json::Map<String, serde_json::Value>> {
+    value?.get_mut("auth")?.as_object_mut()
+}
+
+fn mq_token_signing_object(value: Option<&serde_json::Value>) -> Option<&serde_json::Map<String, serde_json::Value>> {
+    value?.get("tokenSigning")?.as_object()
+}
+
+fn mq_token_signing_object_mut(
+    value: Option<&mut serde_json::Value>,
+) -> Option<&mut serde_json::Map<String, serde_json::Value>> {
+    value?.get_mut("tokenSigning")?.as_object_mut()
+}
+
+fn nacos_auth_object(value: Option<&serde_json::Value>) -> Option<&serde_json::Map<String, serde_json::Value>> {
+    value?.get("auth")?.as_object()
+}
+
+fn nacos_auth_object_mut(
+    value: Option<&mut serde_json::Value>,
+) -> Option<&mut serde_json::Map<String, serde_json::Value>> {
+    value?.get_mut("auth")?.as_object_mut()
+}
+
+fn is_api_key_auth_kind(kind: &str) -> bool {
+    matches!(kind, "apiKey" | "api_key" | "apikey")
+}
+
+#[cfg(feature = "mq-admin")]
+fn mq_token_record_from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result<crate::mq::MqTokenRecord> {
+    let algorithm: String = row.get(3)?;
+    let scope_json: Option<String> = row.get(5)?;
+    let actions_json: String = row.get(6)?;
+    Ok(crate::mq::MqTokenRecord {
+        id: row.get(0)?,
+        connection_id: row.get(1)?,
+        subject: row.get(2)?,
+        algorithm: serde_json::from_value(serde_json::Value::String(algorithm)).map_err(map_from_sql_err)?,
+        token_fingerprint: row.get(4)?,
+        scope: scope_json.as_deref().map(serde_json::from_str).transpose().map_err(map_from_sql_err)?,
+        actions: serde_json::from_str(&actions_json).map_err(map_from_sql_err)?,
+        expires_at: row.get(7)?,
+        created_at: row.get(8)?,
+        note: row.get(9)?,
+    })
+}
+
+fn map_from_sql_err(err: serde_json::Error) -> rusqlite::Error {
+    rusqlite::Error::FromSqlConversionFailure(0, rusqlite::types::Type::Text, Box::new(err))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{maybe_import_user_data_db, DataDbImportResult, DesktopIconTheme, DesktopSettings, Storage};
+    use crate::connection_secrets::{
+        MQ_AUTH_PASSWORD_KEY, MQ_AUTH_TOKEN_KEY, MQ_TOKEN_SIGNING_KEY, NACOS_AUTH_PASSWORD_KEY,
+    };
+    use crate::models::connection::{ConnectionConfig, DatabaseType, SshTunnelConfig, TransportLayerConfig};
+    use crate::saved_sql::SavedSqlFile;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    fn temp_db_path(name: &str) -> std::path::PathBuf {
+        let stamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
+        std::env::temp_dir().join(format!("dbx-storage-{name}-{}-{stamp}.db", std::process::id()))
+    }
+
+    fn temp_data_dir(name: &str) -> std::path::PathBuf {
+        let stamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
+        std::env::temp_dir().join(format!("dbx-storage-{name}-{}-{stamp}", std::process::id()))
+    }
+
+    fn ssh_profile(id: &str, password: &str) -> TransportLayerConfig {
+        TransportLayerConfig::Ssh(SshTunnelConfig {
+            id: id.to_string(),
+            name: "Bastion".to_string(),
+            enabled: true,
+            host: "bastion.example.com".to_string(),
+            port: 22,
+            user: "deploy".to_string(),
+            password: password.to_string(),
+            key_path: String::new(),
+            key_passphrase: String::new(),
+            connect_timeout_secs: 5,
+            expose_lan: false,
+            use_ssh_agent: false,
+            ssh_agent_sock_path: String::new(),
+            auth_method: "password".to_string(),
+            profile_id: String::new(),
+        })
+    }
+
+    #[tokio::test]
+    async fn tunnel_profiles_roundtrip_and_preserve_secrets() {
+        let path = temp_db_path("tunnel-profiles");
+        let storage = Storage::open(&path).await.unwrap();
+
+        let profile = ssh_profile("profile-1", "s3cret");
+        storage.save_tunnel_profiles(std::slice::from_ref(&profile)).await.unwrap();
+        assert_eq!(storage.load_tunnel_profiles().await.unwrap(), vec![profile.clone()]);
+
+        // Applying a scrubbed copy (e.g. from a sync snapshot) keeps stored secrets.
+        let mut scrubbed = profile.clone();
+        scrubbed.scrub_secrets();
+        storage.save_tunnel_profiles_preserving_secrets(&[scrubbed.clone()]).await.unwrap();
+        match &storage.load_tunnel_profiles().await.unwrap()[0] {
+            TransportLayerConfig::Ssh(ssh) => assert_eq!(ssh.password, "s3cret"),
+            other => panic!("expected ssh profile, got {other:?}"),
+        }
+
+        // A plain save is exact: clearing a secret really clears it.
+        storage.save_tunnel_profiles(&[scrubbed.clone()]).await.unwrap();
+        assert_eq!(storage.load_tunnel_profiles().await.unwrap(), vec![scrubbed]);
+
+        storage.save_tunnel_profiles(&[]).await.unwrap();
+        assert!(storage.load_tunnel_profiles().await.unwrap().is_empty());
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[tokio::test]
+    async fn tunnel_profiles_reject_empty_ids() {
+        let path = temp_db_path("tunnel-profiles-empty-id");
+        let storage = Storage::open(&path).await.unwrap();
+
+        let profile = ssh_profile("", "secret");
+        assert!(storage.save_tunnel_profiles(&[profile]).await.is_err());
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    fn mq_connection(id: &str, token: &str) -> ConnectionConfig {
+        ConnectionConfig {
+            id: id.to_string(),
+            name: "Pulsar".to_string(),
+            db_type: DatabaseType::MessageQueue,
+            driver_profile: Some("pulsar".to_string()),
+            driver_label: Some("Apache Pulsar".to_string()),
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 8080,
+            username: String::new(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 30,
+            query_timeout_secs: 300,
+            idle_timeout_secs: 600,
+            keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: ":".to_string(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: Some(serde_json::json!({
+                "systemKind": "pulsar",
+                "adminUrl": "http://127.0.0.1:8080",
+                "auth": {
+                    "kind": "token",
+                    "token": token
+                }
+            })),
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    fn nacos_connection(id: &str, password: &str) -> ConnectionConfig {
+        ConnectionConfig {
+            id: id.to_string(),
+            name: "Nacos".to_string(),
+            db_type: DatabaseType::Nacos,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: "127.0.0.1".to_string(),
+            port: 8848,
+            username: "nacos".to_string(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 30,
+            query_timeout_secs: 300,
+            idle_timeout_secs: 600,
+            keepalive_interval_secs: crate::models::connection::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: ":".to_string(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: Some(serde_json::json!({
+                "namespace": "public",
+                "group": "DEFAULT_GROUP",
+                "auth": {
+                    "kind": "usernamePassword",
+                    "username": "nacos",
+                    "password": password
+                }
+            })),
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    async fn raw_connection_json(storage: &Storage, id: &str) -> String {
+        let id = id.to_string();
+        storage
+            .with_conn(move |conn| {
+                conn.query_row("SELECT config_json FROM connections WHERE id = ?1", [id], |row| row.get::<_, String>(0))
+                    .map_err(|e| e.to_string())
+            })
+            .await
+            .unwrap()
+    }
+
+    async fn insert_raw_connection(storage: &Storage, config: &ConnectionConfig) {
+        let id = config.id.clone();
+        let json = serde_json::to_string(config).unwrap();
+        storage
+            .with_conn(move |conn| {
+                conn.execute("INSERT INTO connections (id, config_json) VALUES (?1, ?2)", rusqlite::params![id, json])
+                    .map(|_| ())
+                    .map_err(|e| e.to_string())
+            })
+            .await
+            .unwrap();
+    }
+
+    fn mq_token(config: &ConnectionConfig) -> Option<&str> {
+        config.external_config.as_ref()?.get("auth")?.get("token")?.as_str()
+    }
+
+    fn mq_token_signing_key(config: &ConnectionConfig) -> Option<&str> {
+        config.external_config.as_ref()?.get("tokenSigning")?.get("key")?.as_str()
+    }
+
+    fn nacos_auth_password(config: &ConnectionConfig) -> Option<&str> {
+        config.external_config.as_ref()?.get("auth")?.get("password")?.as_str()
+    }
+
+    async fn create_data_dir_with_connection(name: &str, connection_id: &str, token: &str) -> std::path::PathBuf {
+        let data_dir = temp_data_dir(name);
+        let storage = Storage::open(&data_dir.join("dbx.db")).await.unwrap();
+        storage.save_connections(&[mq_connection(connection_id, token)]).await.unwrap();
+        drop(storage);
+        data_dir
+    }
+
+    #[tokio::test]
+    async fn import_user_data_db_copies_source_when_target_is_missing() {
+        let source_dir = create_data_dir_with_connection("import-source", "source-connection", "source-token").await;
+        let target_dir = temp_data_dir("import-target");
+
+        let result = maybe_import_user_data_db(&target_dir, Some(&source_dir)).unwrap();
+
+        assert_eq!(result, DataDbImportResult::Imported);
+        let storage = Storage::open(&target_dir.join("dbx.db")).await.unwrap();
+        let connections = storage.load_connections().await.unwrap();
+        assert_eq!(connections.len(), 1);
+        assert_eq!(connections[0].id, "source-connection");
+        assert_eq!(mq_token(&connections[0]), Some("source-token"));
+    }
+
+    #[tokio::test]
+    async fn import_user_data_db_does_not_overwrite_target_with_user_data() {
+        let source_dir =
+            create_data_dir_with_connection("import-source-existing", "source-connection", "source-token").await;
+        let target_dir =
+            create_data_dir_with_connection("import-target-existing", "target-connection", "target-token").await;
+
+        let result = maybe_import_user_data_db(&target_dir, Some(&source_dir)).unwrap();
+
+        assert_eq!(result, DataDbImportResult::SkippedTargetHasData);
+        let storage = Storage::open(&target_dir.join("dbx.db")).await.unwrap();
+        let connections = storage.load_connections().await.unwrap();
+        assert_eq!(connections.len(), 1);
+        assert_eq!(connections[0].id, "target-connection");
+        assert_eq!(mq_token(&connections[0]), Some("target-token"));
+    }
+
+    #[tokio::test]
+    async fn import_user_data_db_replaces_empty_target_schema() {
+        let source_dir =
+            create_data_dir_with_connection("import-source-empty-target", "source-connection", "source-token").await;
+        let target_dir = temp_data_dir("import-empty-target");
+        let target_storage = Storage::open(&target_dir.join("dbx.db")).await.unwrap();
+        target_storage
+            .save_desktop_settings(&DesktopSettings { debug_logging_enabled: true, ..DesktopSettings::default() })
+            .await
+            .unwrap();
+        drop(target_storage);
+
+        let result = maybe_import_user_data_db(&target_dir, Some(&source_dir)).unwrap();
+
+        assert_eq!(result, DataDbImportResult::Imported);
+        let storage = Storage::open(&target_dir.join("dbx.db")).await.unwrap();
+        let connections = storage.load_connections().await.unwrap();
+        assert_eq!(connections.len(), 1);
+        assert_eq!(connections[0].id, "source-connection");
+    }
+
+    #[tokio::test]
+    async fn import_user_data_db_skips_empty_source_schema() {
+        let source_dir = temp_data_dir("import-empty-source");
+        let source_storage = Storage::open(&source_dir.join("dbx.db")).await.unwrap();
+        drop(source_storage);
+        let target_dir = temp_data_dir("import-empty-source-target");
+
+        let result = maybe_import_user_data_db(&target_dir, Some(&source_dir)).unwrap();
+
+        assert_eq!(result, DataDbImportResult::SkippedSourceEmpty);
+        assert!(!target_dir.join("dbx.db").exists());
+    }
+
+    #[test]
+    fn import_user_data_db_skips_invalid_source_file() {
+        let source_dir = temp_data_dir("import-invalid-source");
+        std::fs::create_dir_all(&source_dir).unwrap();
+        std::fs::write(source_dir.join("dbx.db"), b"not sqlite").unwrap();
+        let target_dir = temp_data_dir("import-invalid-source-target");
+
+        let result = maybe_import_user_data_db(&target_dir, Some(&source_dir)).unwrap();
+
+        assert_eq!(result, DataDbImportResult::SkippedInvalidSource);
+        assert!(!target_dir.join("dbx.db").exists());
+    }
+
+    #[tokio::test]
+    async fn save_connections_moves_mq_auth_token_to_secret_table_and_restores_it() {
+        let path = temp_db_path("mq-token-secrets");
+        let storage = Storage::open(&path).await.unwrap();
+
+        storage.save_connections(&[mq_connection("pulsar", "mq-token-secret")]).await.unwrap();
+
+        let raw_json = raw_connection_json(&storage, "pulsar").await;
+        assert!(!raw_json.contains("mq-token-secret"));
+        let persisted: ConnectionConfig = serde_json::from_str(&raw_json).unwrap();
+        assert_eq!(mq_token(&persisted), Some(""));
+        assert_eq!(storage.get_secret("pulsar", MQ_AUTH_TOKEN_KEY).await.unwrap().as_deref(), Some("mq-token-secret"));
+
+        let loaded = storage.load_connections().await.unwrap();
+        assert_eq!(loaded.len(), 1);
+        assert_eq!(mq_token(&loaded[0]), Some("mq-token-secret"));
+    }
+
+    #[tokio::test]
+    async fn metadata_save_scrubs_mq_auth_token_and_preserves_existing_secret() {
+        let path = temp_db_path("mq-token-metadata");
+        let storage = Storage::open(&path).await.unwrap();
+
+        let original = mq_connection("pulsar", "existing-token");
+        storage.save_connections(&[original.clone()]).await.unwrap();
+
+        let mut metadata = original;
+        metadata.name = "Pulsar renamed".to_string();
+        if let Some(auth) = metadata.external_config.as_mut().and_then(|value| value.get_mut("auth")) {
+            auth["token"] = serde_json::Value::String("new-token-that-should-not-persist".to_string());
+        }
+
+        storage.save_connection_metadata_preserving_secrets(&[metadata]).await.unwrap();
+
+        let raw_json = raw_connection_json(&storage, "pulsar").await;
+        assert!(!raw_json.contains("existing-token"));
+        assert!(!raw_json.contains("new-token-that-should-not-persist"));
+        assert_eq!(storage.get_secret("pulsar", MQ_AUTH_TOKEN_KEY).await.unwrap().as_deref(), Some("existing-token"));
+
+        let loaded = storage.load_connections().await.unwrap();
+        assert_eq!(loaded[0].name, "Pulsar renamed");
+        assert_eq!(mq_token(&loaded[0]), Some("existing-token"));
+    }
+
+    #[tokio::test]
+    async fn load_connections_migrates_legacy_mq_auth_token_out_of_config_json() {
+        let path = temp_db_path("mq-token-legacy-migration");
+        let storage = Storage::open(&path).await.unwrap();
+        insert_raw_connection(&storage, &mq_connection("pulsar", "legacy-token")).await;
+
+        let loaded = storage.load_connections().await.unwrap();
+
+        assert_eq!(mq_token(&loaded[0]), Some("legacy-token"));
+        assert_eq!(storage.get_secret("pulsar", MQ_AUTH_TOKEN_KEY).await.unwrap().as_deref(), Some("legacy-token"));
+        let raw_json = raw_connection_json(&storage, "pulsar").await;
+        assert!(!raw_json.contains("legacy-token"));
+        let persisted: ConnectionConfig = serde_json::from_str(&raw_json).unwrap();
+        assert_eq!(mq_token(&persisted), Some(""));
+    }
+
+    #[tokio::test]
+    async fn save_connections_deletes_stale_mq_auth_secrets_when_kind_changes() {
+        let path = temp_db_path("mq-auth-kind-change");
+        let storage = Storage::open(&path).await.unwrap();
+        storage.save_connections(&[mq_connection("pulsar", "old-token")]).await.unwrap();
+        let mut config = mq_connection("pulsar", "");
+        config.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "http://127.0.0.1:8080",
+            "auth": {
+                "kind": "basic",
+                "username": "admin",
+                "password": "basic-secret"
+            }
+        }));
+
+        storage.save_connections(&[config]).await.unwrap();
+
+        assert_eq!(storage.get_secret("pulsar", MQ_AUTH_TOKEN_KEY).await.unwrap(), None);
+        assert_eq!(storage.get_secret("pulsar", MQ_AUTH_PASSWORD_KEY).await.unwrap().as_deref(), Some("basic-secret"));
+    }
+
+    #[tokio::test]
+    async fn save_connections_moves_mq_token_signing_key_to_secret_table_and_restores_it() {
+        let path = temp_db_path("mq-token-signing-secret");
+        let storage = Storage::open(&path).await.unwrap();
+        let mut config = mq_connection("pulsar", "");
+        config.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": "http://127.0.0.1:8080",
+            "auth": { "kind": "none" },
+            "tokenSigning": {
+                "algorithm": "hs256",
+                "key": "broker-signing-secret"
+            }
+        }));
+
+        storage.save_connections(&[config]).await.unwrap();
+
+        let raw_json = raw_connection_json(&storage, "pulsar").await;
+        assert!(!raw_json.contains("broker-signing-secret"));
+        let persisted: ConnectionConfig = serde_json::from_str(&raw_json).unwrap();
+        assert_eq!(mq_token_signing_key(&persisted), Some(""));
+        assert_eq!(
+            storage.get_secret("pulsar", MQ_TOKEN_SIGNING_KEY).await.unwrap().as_deref(),
+            Some("broker-signing-secret")
+        );
+
+        let loaded = storage.load_connections().await.unwrap();
+        assert_eq!(mq_token_signing_key(&loaded[0]), Some("broker-signing-secret"));
+    }
+
+    #[tokio::test]
+    async fn save_connections_moves_nacos_auth_password_to_secret_table_and_restores_it() {
+        let path = temp_db_path("nacos-auth-secret");
+        let storage = Storage::open(&path).await.unwrap();
+
+        storage.save_connections(&[nacos_connection("nacos", "nacos-secret")]).await.unwrap();
+
+        let raw_json = raw_connection_json(&storage, "nacos").await;
+        assert!(!raw_json.contains("nacos-secret"));
+        let persisted: ConnectionConfig = serde_json::from_str(&raw_json).unwrap();
+        assert_eq!(nacos_auth_password(&persisted), Some(""));
+        assert_eq!(
+            storage.get_secret("nacos", NACOS_AUTH_PASSWORD_KEY).await.unwrap().as_deref(),
+            Some("nacos-secret")
+        );
+
+        let loaded = storage.load_connections().await.unwrap();
+        assert_eq!(loaded.len(), 1);
+        assert_eq!(nacos_auth_password(&loaded[0]), Some("nacos-secret"));
+    }
+
+    #[tokio::test]
+    async fn load_connections_migrates_legacy_nacos_auth_password_out_of_config_json() {
+        let path = temp_db_path("nacos-auth-legacy-migration");
+        let storage = Storage::open(&path).await.unwrap();
+        insert_raw_connection(&storage, &nacos_connection("nacos", "legacy-nacos-secret")).await;
+
+        let loaded = storage.load_connections().await.unwrap();
+
+        assert_eq!(nacos_auth_password(&loaded[0]), Some("legacy-nacos-secret"));
+        assert_eq!(
+            storage.get_secret("nacos", NACOS_AUTH_PASSWORD_KEY).await.unwrap().as_deref(),
+            Some("legacy-nacos-secret")
+        );
+        let raw_json = raw_connection_json(&storage, "nacos").await;
+        assert!(!raw_json.contains("legacy-nacos-secret"));
+        let persisted: ConnectionConfig = serde_json::from_str(&raw_json).unwrap();
+        assert_eq!(nacos_auth_password(&persisted), Some(""));
+    }
+
+    #[tokio::test]
+    async fn desktop_settings_default_to_background_enabled() {
+        let path = temp_db_path("desktop-settings-default");
+        let storage = Storage::open(&path).await.unwrap();
+
+        assert_eq!(storage.load_desktop_settings().await.unwrap(), DesktopSettings::default());
+    }
+
+    #[tokio::test]
+    async fn desktop_settings_fall_back_to_legacy_background_preference() {
+        let path = temp_db_path("desktop-settings-legacy-background");
+        let storage = Storage::open(&path).await.unwrap();
+        let mut settings = serde_json::Map::new();
+        settings.insert("run_in_background".to_string(), serde_json::Value::Bool(false));
+        storage.save_app_settings_json(&settings).await.unwrap();
+
+        assert_eq!(
+            storage.load_desktop_settings().await.unwrap(),
+            DesktopSettings { show_tray_icon: false, ..DesktopSettings::default() }
+        );
+    }
+
+    #[tokio::test]
+    async fn desktop_settings_preserve_existing_password_hash() {
+        let path = temp_db_path("desktop-settings-preserve-password");
+        let storage = Storage::open(&path).await.unwrap();
+
+        storage.save_password_hash("hash-1").await.unwrap();
+        storage
+            .save_desktop_settings(&DesktopSettings {
+                show_tray_icon: false,
+                icon_theme: DesktopIconTheme::Black,
+                quit_on_close: true,
+                close_action_prompted: false,
+                debug_logging_enabled: true,
+                duckdb_worker_process_isolation: false,
+                duckdb_worker_max_processes: DesktopSettings::default().duckdb_worker_max_processes,
+                saved_sql_sync_dir: None,
+                driver_store_dir: Some("/tmp/dbx-drivers".to_string()),
+                plugin_store_dir: Some("/tmp/dbx-plugins".to_string()),
+                agent_store_dir: Some("/tmp/dbx-agents".to_string()),
+                sidebar_table_page_size: DesktopSettings::default().sidebar_table_page_size,
+            })
+            .await
+            .unwrap();
+
+        assert_eq!(storage.load_password_hash().await.unwrap(), Some("hash-1".to_string()));
+        assert_eq!(
+            storage.load_desktop_settings().await.unwrap(),
+            DesktopSettings {
+                show_tray_icon: false,
+                icon_theme: DesktopIconTheme::Black,
+                quit_on_close: true,
+                close_action_prompted: false,
+                debug_logging_enabled: true,
+                duckdb_worker_process_isolation: false,
+                duckdb_worker_max_processes: DesktopSettings::default().duckdb_worker_max_processes,
+                saved_sql_sync_dir: None,
+                driver_store_dir: Some("/tmp/dbx-drivers".to_string()),
+                plugin_store_dir: Some("/tmp/dbx-plugins".to_string()),
+                agent_store_dir: Some("/tmp/dbx-agents".to_string()),
+                sidebar_table_page_size: DesktopSettings::default().sidebar_table_page_size,
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn desktop_settings_save_removes_legacy_background_preference() {
+        let path = temp_db_path("desktop-settings-remove-legacy-background");
+        let storage = Storage::open(&path).await.unwrap();
+        let mut settings = serde_json::Map::new();
+        settings.insert("run_in_background".to_string(), serde_json::Value::Bool(false));
+        storage.save_app_settings_json(&settings).await.unwrap();
+
+        storage
+            .save_desktop_settings(&DesktopSettings {
+                icon_theme: DesktopIconTheme::Black,
+                ..DesktopSettings::default()
+            })
+            .await
+            .unwrap();
+
+        let settings = storage.load_app_settings_json().await.unwrap();
+        assert_eq!(settings.get("run_in_background"), None);
+        assert_eq!(settings.get("show_tray_icon").and_then(|value| value.as_bool()), Some(true));
+        assert_eq!(settings.get("icon_theme").and_then(|value| value.as_str()), Some("black"));
+        assert_eq!(settings.get("debug_logging_enabled").and_then(|value| value.as_bool()), Some(false));
+        assert_eq!(
+            settings.get("sidebar_table_page_size").and_then(|value| value.as_u64()),
+            Some(DesktopSettings::default().sidebar_table_page_size as u64)
+        );
+    }
+
+    #[tokio::test]
+    async fn desktop_settings_persist_sidebar_table_page_size() {
+        let path = temp_db_path("desktop-settings-sidebar-page-size");
+        let storage = Storage::open(&path).await.unwrap();
+
+        storage
+            .save_desktop_settings(&DesktopSettings { sidebar_table_page_size: 1234, ..DesktopSettings::default() })
+            .await
+            .unwrap();
+
+        assert_eq!(storage.load_desktop_settings().await.unwrap().sidebar_table_page_size, 1234);
+    }
+
+    #[tokio::test]
+    async fn desktop_settings_persist_duckdb_worker_max_processes() {
+        let path = temp_db_path("desktop-settings-duckdb-worker-max-processes");
+        let storage = Storage::open(&path).await.unwrap();
+
+        storage
+            .save_desktop_settings(&DesktopSettings { duckdb_worker_max_processes: 8, ..DesktopSettings::default() })
+            .await
+            .unwrap();
+
+        assert_eq!(storage.load_desktop_settings().await.unwrap().duckdb_worker_max_processes, 8);
+    }
+
+    #[tokio::test]
+    async fn password_hash_preserves_existing_desktop_settings() {
+        let path = temp_db_path("password-preserve-desktop-settings");
+        let storage = Storage::open(&path).await.unwrap();
+
+        storage
+            .save_desktop_settings(&DesktopSettings {
+                show_tray_icon: false,
+                icon_theme: DesktopIconTheme::Black,
+                ..DesktopSettings::default()
+            })
+            .await
+            .unwrap();
+        storage.save_password_hash("hash-2").await.unwrap();
+
+        assert_eq!(storage.load_password_hash().await.unwrap(), Some("hash-2".to_string()));
+        assert_eq!(
+            storage.load_desktop_settings().await.unwrap(),
+            DesktopSettings {
+                show_tray_icon: false,
+                icon_theme: DesktopIconTheme::Black,
+                ..DesktopSettings::default()
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn pinned_tree_node_ids_default_to_empty() {
+        let path = temp_db_path("pinned-tree-default");
+        let storage = Storage::open(&path).await.unwrap();
+
+        assert_eq!(storage.load_pinned_tree_node_ids().await.unwrap(), Vec::<String>::new());
+    }
+
+    #[tokio::test]
+    async fn pinned_tree_node_ids_roundtrip_and_preserve_password_hash() {
+        let path = temp_db_path("pinned-tree-roundtrip");
+        let storage = Storage::open(&path).await.unwrap();
+
+        storage.save_password_hash("hash-3").await.unwrap();
+        storage.save_pinned_tree_node_ids(&["conn-1".to_string(), "conn-1:db:main".to_string()]).await.unwrap();
+
+        assert_eq!(
+            storage.load_pinned_tree_node_ids().await.unwrap(),
+            vec!["conn-1".to_string(), "conn-1:db:main".to_string()]
+        );
+        assert_eq!(storage.load_password_hash().await.unwrap(), Some("hash-3".to_string()));
+    }
+
+    #[tokio::test]
+    async fn app_state_roundtrips_without_polluting_app_settings() {
+        let path = temp_db_path("app-state-roundtrip");
+        let storage = Storage::open(&path).await.unwrap();
+
+        storage.save_password_hash("hash-4").await.unwrap();
+        storage
+            .save_desktop_settings(&DesktopSettings {
+                icon_theme: DesktopIconTheme::Black,
+                ..DesktopSettings::default()
+            })
+            .await
+            .unwrap();
+
+        storage.save_editor_settings(&serde_json::json!({ "openTabsRestoreMode": "pinned" })).await.unwrap();
+        storage
+            .save_open_tabs_state(&serde_json::json!({
+                "tabs": [{ "id": "tab-1", "title": "Pinned", "connectionId": "pg", "database": "app", "sql": "select 1", "pinned": true }],
+                "activeTabId": "tab-1"
+            }))
+            .await
+            .unwrap();
+        storage
+            .save_saved_sql_editor_positions(&serde_json::json!([{ "savedSqlId": "file-1", "updatedAt": 1 }]))
+            .await
+            .unwrap();
+
+        assert_eq!(
+            storage.load_editor_settings().await.unwrap(),
+            Some(serde_json::json!({ "openTabsRestoreMode": "pinned" }))
+        );
+        assert_eq!(
+            storage.load_open_tabs_state().await.unwrap().and_then(|value| value.get("activeTabId").cloned()),
+            Some(serde_json::json!("tab-1"))
+        );
+        assert_eq!(
+            storage.load_saved_sql_editor_positions().await.unwrap(),
+            Some(serde_json::json!([{ "savedSqlId": "file-1", "updatedAt": 1 }]))
+        );
+        assert_eq!(storage.load_password_hash().await.unwrap(), Some("hash-4".to_string()));
+        assert_eq!(
+            storage.load_desktop_settings().await.unwrap(),
+            DesktopSettings { icon_theme: DesktopIconTheme::Black, ..DesktopSettings::default() }
+        );
+        assert_eq!(storage.load_app_settings_json().await.unwrap().get("open_tabs"), None);
+    }
+
+    #[tokio::test]
+    async fn tab_runtime_cache_roundtrips_binary_payloads() {
+        let path = temp_db_path("tab-runtime-cache");
+        let storage = Storage::open(&path).await.unwrap();
+
+        storage.save_tab_runtime_cache("tab:1:result", vec![1, 2, 3, 4], 10, 3).await.unwrap();
+        let entry = storage.load_tab_runtime_cache("tab:1:result").await.unwrap().unwrap();
+
+        assert_eq!(entry.key, "tab:1:result");
+        assert_eq!(entry.payload, vec![1, 2, 3, 4]);
+        assert_eq!(entry.row_count, 10);
+        assert_eq!(entry.column_count, 3);
+        assert_eq!(entry.byte_size, 4);
+
+        storage.delete_tab_runtime_cache("tab:1:result").await.unwrap();
+        assert_eq!(storage.load_tab_runtime_cache("tab:1:result").await.unwrap(), None);
+    }
+
+    #[tokio::test]
+    async fn saved_sql_summary_omits_sql_text_and_loads_file_on_demand() {
+        let path = temp_db_path("saved-sql-summary");
+        let storage = Storage::open(&path).await.unwrap();
+        let file = SavedSqlFile {
+            id: "sql-1".to_string(),
+            connection_id: "conn-1".to_string(),
+            folder_id: None,
+            name: "large.sql".to_string(),
+            database: "main".to_string(),
+            schema: None,
+            sql: "SELECT * FROM very_large_table;".repeat(100),
+            sql_loaded: true,
+            order_index: 0,
+            open_count: 0,
+            opened_at: None,
+            created_at: "2026-06-27T00:00:00Z".to_string(),
+            updated_at: "2026-06-27T00:00:00Z".to_string(),
+        };
+
+        storage.save_saved_sql_file(&file).await.unwrap();
+
+        let summary = storage.load_saved_sql_library_summary().await.unwrap();
+        assert_eq!(summary.files.len(), 1);
+        assert_eq!(summary.files[0].sql, "");
+        assert!(!summary.files[0].sql_loaded);
+
+        let loaded = storage.load_saved_sql_file("sql-1").await.unwrap().unwrap();
+        assert_eq!(loaded.sql, file.sql);
+        assert!(loaded.sql_loaded);
+    }
+
+    #[tokio::test]
+    async fn saved_sql_metadata_update_preserves_unloaded_sql_text() {
+        let path = temp_db_path("saved-sql-preserve-unloaded-text");
+        let storage = Storage::open(&path).await.unwrap();
+        let mut file = SavedSqlFile {
+            id: "sql-1".to_string(),
+            connection_id: "conn-1".to_string(),
+            folder_id: None,
+            name: "query.sql".to_string(),
+            database: "main".to_string(),
+            schema: None,
+            sql: "SELECT 1;".to_string(),
+            sql_loaded: true,
+            order_index: 0,
+            open_count: 0,
+            opened_at: None,
+            created_at: "2026-06-27T00:00:00Z".to_string(),
+            updated_at: "2026-06-27T00:00:00Z".to_string(),
+        };
+        storage.save_saved_sql_file(&file).await.unwrap();
+
+        file.name = "renamed.sql".to_string();
+        file.sql.clear();
+        file.sql_loaded = false;
+        file.open_count = 1;
+        storage.save_saved_sql_file(&file).await.unwrap();
+
+        let loaded = storage.load_saved_sql_file("sql-1").await.unwrap().unwrap();
+        assert_eq!(loaded.name, "renamed.sql");
+        assert_eq!(loaded.open_count, 1);
+        assert_eq!(loaded.sql, "SELECT 1;");
+    }
+}
diff --git a/crates/dbx-core/src/table_export.rs b/crates/dbx-core/src/table_export.rs
new file mode 100644
index 0000000..15919bd
--- /dev/null
+++ b/crates/dbx-core/src/table_export.rs
@@ -0,0 +1,1568 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::io::{BufWriter, Write};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+use tokio_util::sync::CancellationToken;
+
+use crate::connection::MysqlMode;
+use crate::connection::{task_client_session_id, AppState, PoolKind};
+use crate::csv_export::{escape_csv, format_csv, value_to_csv_text};
+pub use crate::database_export::ExportStatus;
+use crate::database_export::{build_export_insert_statements, is_export_cancelled, BuildExportInsertStatementsOptions};
+use crate::db::agent_driver::AgentTableReadStartParams;
+use crate::models::connection::DatabaseType;
+use crate::transfer::{
+    count_sql_with_where, execute_read_on_pool, execute_read_on_pool_with_max_rows, keyset_pagination_sql,
+    pagination_sql_with_filter_order, qualified_table, quote_identifier,
+};
+use crate::types::QueryResult;
+use crate::xlsx_export::{finish_streaming_xlsx_workbook, start_streaming_xlsx_workbook};
+
+const DEFAULT_BATCH_SIZE: usize = 10_000;
+const SQL_INSERT_BATCH_SIZE: usize = 100;
+
+pub fn table_export_client_session_id(export_id: &str) -> String {
+    task_client_session_id("table-export", export_id)
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableExportRequest {
+    pub export_id: String,
+    pub connection_id: String,
+    pub database: String,
+    pub schema: Option<String>,
+    pub table_name: String,
+    pub file_path: String,
+    /// "csv", "xlsx", "json", "markdown", or "sql"
+    pub format: String,
+    #[serde(default)]
+    pub columns: Option<Vec<String>>,
+    #[serde(default)]
+    pub column_types: Option<Vec<Option<String>>>,
+    #[serde(default)]
+    pub primary_keys: Option<Vec<String>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub where_input: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub order_by: Option<String>,
+    #[serde(default)]
+    pub skip_count: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub batch_size: Option<usize>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub row_limit: Option<usize>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableExportProgress {
+    pub export_id: String,
+    pub table_name: String,
+    pub rows_exported: u64,
+    pub total_rows: Option<u64>,
+    pub status: ExportStatus,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub error_message: Option<String>,
+}
+
+/// Format rows as CSV text without a header row.
+/// Used for streaming subsequent pagination batches.
+fn format_csv_rows(rows: &[Vec<Value>]) -> String {
+    rows.iter()
+        .map(|row| row.iter().map(|cell| escape_csv(&value_to_csv_text(cell))).collect::<Vec<_>>().join(","))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn export_column_types(request: &TableExportRequest) -> Vec<String> {
+    request
+        .column_types
+        .as_deref()
+        .unwrap_or_default()
+        .iter()
+        .map(|column_type| column_type.clone().unwrap_or_default())
+        .collect()
+}
+
+fn write_json_row_object<W: Write>(writer: &mut W, columns: &[String], row: &[Value]) -> Result<(), String> {
+    writer.write_all(b"{\n").map_err(|e| format!("Failed to write JSON: {e}"))?;
+    let mut first = true;
+    for (index, column) in columns.iter().enumerate() {
+        let Some(value) = row.get(index) else {
+            continue;
+        };
+        if !first {
+            writer.write_all(b",\n").map_err(|e| format!("Failed to write JSON: {e}"))?;
+        }
+        writer.write_all(b"  ").map_err(|e| format!("Failed to write JSON: {e}"))?;
+        serde_json::to_writer(&mut *writer, column).map_err(|e| format!("Failed to write JSON: {e}"))?;
+        writer.write_all(b": ").map_err(|e| format!("Failed to write JSON: {e}"))?;
+        serde_json::to_writer(&mut *writer, value).map_err(|e| format!("Failed to write JSON: {e}"))?;
+        first = false;
+    }
+    writer.write_all(b"\n}").map_err(|e| format!("Failed to write JSON: {e}"))
+}
+
+fn display_cell(value: &Value) -> String {
+    match value {
+        Value::Null => "NULL".to_string(),
+        Value::Bool(value) => value.to_string(),
+        Value::Number(value) => value.to_string(),
+        Value::String(value) => value.clone(),
+        other => other.to_string(),
+    }
+}
+
+fn markdown_cell(value: &str) -> String {
+    value.replace('|', "\\|").replace("\r\n", "<br>").replace('\n', "<br>")
+}
+
+fn format_markdown_header(columns: &[String]) -> String {
+    let header = columns.iter().map(|column| markdown_cell(column)).collect::<Vec<_>>().join(" | ");
+    let separator = columns.iter().map(|_| "---").collect::<Vec<_>>().join(" | ");
+    format!("| {header} |\n| {separator} |\n")
+}
+
+fn format_markdown_rows(rows: &[Vec<Value>]) -> String {
+    rows.iter()
+        .map(|row| {
+            let cells = row.iter().map(|cell| markdown_cell(&display_cell(cell))).collect::<Vec<_>>().join(" | ");
+            format!("| {cells} |")
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+#[allow(clippy::too_many_arguments)]
+fn table_page_sql(
+    request: &TableExportRequest,
+    db_type: &DatabaseType,
+    col_names: &[String],
+    primary_keys: &[String],
+    use_keyset: bool,
+    last_pk_values: &[Value],
+    offset: u64,
+    batch_size: usize,
+) -> String {
+    if use_keyset {
+        keyset_pagination_sql(
+            col_names,
+            &request.table_name,
+            request.schema.as_deref().unwrap_or(""),
+            db_type,
+            primary_keys,
+            last_pk_values,
+            batch_size,
+        )
+    } else {
+        pagination_sql_with_filter_order(
+            col_names,
+            &request.table_name,
+            request.schema.as_deref().unwrap_or(""),
+            db_type,
+            offset,
+            batch_size,
+            request.where_input.as_deref(),
+            request.order_by.as_deref(),
+            primary_keys,
+        )
+    }
+}
+
+fn table_cursor_sql(
+    request: &TableExportRequest,
+    db_type: &DatabaseType,
+    col_names: &[String],
+    primary_keys: &[String],
+) -> String {
+    let full_table = qualified_table(&request.table_name, request.schema.as_deref().unwrap_or(""), db_type);
+    let col_list = col_names.iter().map(|column| quote_identifier(column, db_type)).collect::<Vec<_>>().join(", ");
+    let predicate = crate::sql_dialect::normalize_where_input(request.where_input.as_deref());
+    let where_clause = if predicate.is_empty() { String::new() } else { format!(" WHERE ({predicate})") };
+    let order_by = request
+        .order_by
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string)
+        .or_else(|| {
+            if primary_keys.is_empty() {
+                None
+            } else {
+                Some(
+                    primary_keys
+                        .iter()
+                        .map(|column| format!("{} ASC", quote_identifier(column, db_type)))
+                        .collect::<Vec<_>>()
+                        .join(", "),
+                )
+            }
+        })
+        .map(|value| format!(" ORDER BY {value}"))
+        .unwrap_or_default();
+
+    format!("SELECT {col_list} FROM {full_table}{where_clause}{order_by}")
+}
+
+fn is_agent_table_read_unsupported(error: &str) -> bool {
+    let lower = error.to_ascii_lowercase();
+    lower.contains("unknown method") || lower.contains("method not found")
+}
+
+async fn pool_is_agent(state: &AppState, pool_key: &str) -> bool {
+    let connections = state.connections.read().await;
+    matches!(connections.get(pool_key), Some(PoolKind::Agent(_)))
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn fetch_table_export_batch(
+    state: &AppState,
+    pool_key: &str,
+    request: &TableExportRequest,
+    db_type: &DatabaseType,
+    col_names: &[String],
+    primary_keys: &[String],
+    use_keyset: bool,
+    last_pk_values: &[Value],
+    offset: u64,
+    active_batch_size: usize,
+    table_read_session_id: &mut Option<String>,
+    table_read_attempted: &mut bool,
+    table_read_completed: &mut bool,
+) -> Result<QueryResult, String> {
+    if *table_read_completed {
+        return Ok(QueryResult {
+            columns: col_names.to_vec(),
+            column_types: Vec::new(),
+            column_sortables: Vec::new(),
+            rows: Vec::new(),
+            affected_rows: 0,
+            execution_time_ms: 0,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        });
+    }
+
+    if !*table_read_attempted && pool_is_agent(state, pool_key).await {
+        *table_read_attempted = true;
+        let sql = table_cursor_sql(request, db_type, col_names, primary_keys);
+        let max_rows = request.row_limit.unwrap_or(i32::MAX as usize);
+        let params = AgentTableReadStartParams {
+            sql,
+            database: Some(request.database.clone()),
+            schema: request.schema.clone(),
+            page_size: active_batch_size,
+            max_rows,
+            fetch_size: Some(active_batch_size),
+        };
+        let connections = state.connections.read().await;
+        let Some(PoolKind::Agent(client)) = connections.get(pool_key) else {
+            drop(connections);
+            return fetch_paginated_table_export_batch(
+                state,
+                pool_key,
+                request,
+                db_type,
+                col_names,
+                primary_keys,
+                use_keyset,
+                last_pk_values,
+                offset,
+                active_batch_size,
+            )
+            .await;
+        };
+        let client = client.clone();
+        drop(connections);
+        let mut client = client.lock().await;
+        match client.start_table_read::<QueryResult>(params).await {
+            Ok(result) => {
+                *table_read_session_id = result.session_id.clone();
+                if result.session_id.is_none() && !result.has_more {
+                    *table_read_completed = true;
+                }
+                return Ok(result);
+            }
+            Err(error) if is_agent_table_read_unsupported(&error) => {
+                log::debug!("Agent table-read cursor unsupported, falling back to paginated export: {error}");
+            }
+            Err(error) => return Err(error),
+        }
+    }
+
+    if let Some(session_id) = table_read_session_id.as_deref() {
+        let connections = state.connections.read().await;
+        let Some(PoolKind::Agent(client)) = connections.get(pool_key) else {
+            return Err("Table read session requires an agent connection".to_string());
+        };
+        let client = client.clone();
+        drop(connections);
+        let mut client = client.lock().await;
+        return match client.fetch_table_read_page::<QueryResult>(session_id, active_batch_size).await {
+            Ok(result) => {
+                *table_read_session_id = result.session_id.clone().or_else(|| Some(session_id.to_string()));
+                if !result.has_more {
+                    *table_read_session_id = None;
+                    *table_read_completed = true;
+                }
+                Ok(result)
+            }
+            Err(error) => {
+                let _ = client.close_table_read_session::<bool>(session_id).await;
+                *table_read_session_id = None;
+                Err(error)
+            }
+        };
+    }
+
+    fetch_paginated_table_export_batch(
+        state,
+        pool_key,
+        request,
+        db_type,
+        col_names,
+        primary_keys,
+        use_keyset,
+        last_pk_values,
+        offset,
+        active_batch_size,
+    )
+    .await
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn fetch_paginated_table_export_batch(
+    state: &AppState,
+    pool_key: &str,
+    request: &TableExportRequest,
+    db_type: &DatabaseType,
+    col_names: &[String],
+    primary_keys: &[String],
+    use_keyset: bool,
+    last_pk_values: &[Value],
+    offset: u64,
+    active_batch_size: usize,
+) -> Result<QueryResult, String> {
+    let sql = table_page_sql(
+        request,
+        db_type,
+        col_names,
+        primary_keys,
+        use_keyset,
+        last_pk_values,
+        offset,
+        active_batch_size,
+    );
+    execute_read_on_pool_with_max_rows(state, pool_key, &sql, Some(active_batch_size)).await
+}
+
+async fn close_table_read_session_if_open(
+    state: &AppState,
+    pool_key: &str,
+    table_read_session_id: &mut Option<String>,
+) {
+    let Some(session_id) = table_read_session_id.take() else {
+        return;
+    };
+    let connections = state.connections.read().await;
+    let Some(PoolKind::Agent(client)) = connections.get(pool_key) else {
+        return;
+    };
+    let client = client.clone();
+    drop(connections);
+    let mut client = client.lock().await;
+    let _ = client.close_table_read_session::<bool>(&session_id).await;
+}
+
+async fn start_export_cancel_watcher(export_id: String, cancelled: Arc<AtomicBool>, token: CancellationToken) {
+    loop {
+        if is_export_cancelled(&export_id).await {
+            cancelled.store(true, Ordering::SeqCst);
+            token.cancel();
+            break;
+        }
+        tokio::time::sleep(Duration::from_millis(100)).await;
+    }
+}
+
+async fn stream_native_table_rows(
+    state: &AppState,
+    pool_key: &str,
+    db_type: &DatabaseType,
+    sql: &str,
+    row_limit: Option<usize>,
+    cancelled: &AtomicBool,
+    cancel_token: CancellationToken,
+    on_row: impl FnMut(&[Value]) -> Result<(), String>,
+) -> Result<bool, String> {
+    let connections = state.connections.read().await;
+    match connections.get(pool_key) {
+        Some(PoolKind::Mysql(pool, mode)) => {
+            let pool = pool.clone();
+            let bare = *mode == MysqlMode::Bare;
+            drop(connections);
+            crate::db::mysql::stream_query_rows(
+                &pool,
+                sql,
+                bare,
+                row_limit,
+                crate::db::mysql::MySqlQueryDialect::for_connection(*db_type, None),
+                cancelled,
+                on_row,
+            )
+            .await?;
+            Ok(true)
+        }
+        Some(PoolKind::Postgres(pool)) => {
+            let pool = pool.clone();
+            drop(connections);
+            crate::db::postgres::stream_query_rows(&pool, sql, row_limit, cancelled, on_row).await?;
+            Ok(true)
+        }
+        Some(PoolKind::SqlServer(client)) => {
+            let client = client.clone();
+            drop(connections);
+            let mut on_row = on_row;
+            let mut client = client.lock().await;
+            crate::db::sqlserver::stream_first_result_set(&mut client, sql, row_limit, Some(cancel_token), |item| {
+                if let crate::db::sqlserver::SqlServerStreamItem::Row(row) = item {
+                    on_row(row)?;
+                }
+                Ok(())
+            })
+            .await?;
+            Ok(true)
+        }
+        _ => Ok(false),
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn try_export_native_table_stream(
+    state: &AppState,
+    pool_key: &str,
+    request: &TableExportRequest,
+    db_type: &DatabaseType,
+    col_names: &[String],
+    column_types: &[Option<String>],
+    column_extras: &[Option<String>],
+    primary_keys: &[String],
+    total_rows: Option<u64>,
+    row_limit: Option<usize>,
+    batch_size: usize,
+    on_progress: &impl Fn(TableExportProgress),
+) -> Result<bool, String> {
+    let sql = table_cursor_sql(request, db_type, col_names, primary_keys);
+    let cancelled = Arc::new(AtomicBool::new(false));
+    let cancel_token = CancellationToken::new();
+    let cancel_watcher =
+        tokio::spawn(start_export_cancel_watcher(request.export_id.clone(), cancelled.clone(), cancel_token.clone()));
+    let mut rows_exported = 0_u64;
+    let progress_interval = batch_size.max(1) as u64;
+
+    let stream_result = match request.format.to_lowercase().as_str() {
+        "csv" => {
+            let mut file = BufWriter::new(
+                std::fs::File::create(&request.file_path).map_err(|e| format!("Failed to create file: {e}"))?,
+            );
+            file.write_all(b"\xEF\xBB\xBF").map_err(|e| format!("Failed to write BOM: {e}"))?;
+            let header = format_csv(col_names, &[]);
+            let header = header.strip_suffix('\n').unwrap_or(&header);
+            file.write_all(header.as_bytes()).map_err(|e| format!("Failed to write CSV: {e}"))?;
+
+            let result = stream_native_table_rows(
+                state,
+                pool_key,
+                db_type,
+                &sql,
+                row_limit,
+                &cancelled,
+                cancel_token.clone(),
+                |row| {
+                    let row_csv = format_csv_rows(&[row.to_vec()]);
+                    write!(file, "\n{row_csv}").map_err(|e| format!("Failed to write CSV rows: {e}"))?;
+                    rows_exported += 1;
+                    if rows_exported % progress_interval == 0 {
+                        on_progress(TableExportProgress {
+                            export_id: request.export_id.clone(),
+                            table_name: request.table_name.clone(),
+                            rows_exported,
+                            total_rows,
+                            status: ExportStatus::Running,
+                            error_message: None,
+                        });
+                    }
+                    Ok(())
+                },
+            )
+            .await;
+            if result.is_ok() {
+                file.flush().map_err(|e| format!("Failed to flush export file: {e}"))?;
+            }
+            result
+        }
+        "xlsx" => {
+            let column_types = export_column_types(request);
+            let xlsx_file =
+                std::fs::File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+            let mut writer = start_streaming_xlsx_workbook(
+                BufWriter::new(xlsx_file),
+                Some(&request.table_name),
+                col_names,
+                &column_types,
+            )?;
+            let result = stream_native_table_rows(
+                state,
+                pool_key,
+                db_type,
+                &sql,
+                row_limit,
+                &cancelled,
+                cancel_token.clone(),
+                |row| {
+                    writer.write_row(row).map_err(|e| format!("Failed to write XLSX row: {e}"))?;
+                    rows_exported += 1;
+                    if rows_exported % progress_interval == 0 {
+                        on_progress(TableExportProgress {
+                            export_id: request.export_id.clone(),
+                            table_name: request.table_name.clone(),
+                            rows_exported,
+                            total_rows,
+                            status: ExportStatus::Running,
+                            error_message: None,
+                        });
+                    }
+                    Ok(())
+                },
+            )
+            .await;
+            if result.is_ok() {
+                on_progress(TableExportProgress {
+                    export_id: request.export_id.clone(),
+                    table_name: request.table_name.clone(),
+                    rows_exported,
+                    total_rows,
+                    status: ExportStatus::Writing,
+                    error_message: None,
+                });
+                let mut xlsx_buf =
+                    finish_streaming_xlsx_workbook(writer).map_err(|e| format!("Failed to finalize XLSX file: {e}"))?;
+                xlsx_buf.flush().map_err(|e| format!("Failed to flush XLSX file: {e}"))?;
+            }
+            result
+        }
+        "json" => {
+            let mut file = BufWriter::new(
+                std::fs::File::create(&request.file_path).map_err(|e| format!("Failed to create file: {e}"))?,
+            );
+            file.write_all(b"[\n").map_err(|e| format!("Failed to write JSON: {e}"))?;
+            let mut is_first_row = true;
+            let result = stream_native_table_rows(
+                state,
+                pool_key,
+                db_type,
+                &sql,
+                row_limit,
+                &cancelled,
+                cancel_token.clone(),
+                |row| {
+                    if !is_first_row {
+                        file.write_all(b",\n").map_err(|e| format!("Failed to write JSON: {e}"))?;
+                    }
+                    write_json_row_object(&mut file, col_names, row)?;
+                    is_first_row = false;
+                    rows_exported += 1;
+                    if rows_exported % progress_interval == 0 {
+                        on_progress(TableExportProgress {
+                            export_id: request.export_id.clone(),
+                            table_name: request.table_name.clone(),
+                            rows_exported,
+                            total_rows,
+                            status: ExportStatus::Running,
+                            error_message: None,
+                        });
+                    }
+                    Ok(())
+                },
+            )
+            .await;
+            if result.is_ok() {
+                file.write_all(b"\n]\n").map_err(|e| format!("Failed to write JSON: {e}"))?;
+                file.flush().map_err(|e| format!("Failed to flush export file: {e}"))?;
+            }
+            result
+        }
+        "markdown" | "md" => {
+            let mut file = BufWriter::new(
+                std::fs::File::create(&request.file_path).map_err(|e| format!("Failed to create file: {e}"))?,
+            );
+            file.write_all(format_markdown_header(col_names).as_bytes())
+                .map_err(|e| format!("Failed to write Markdown: {e}"))?;
+            let mut wrote_rows = false;
+            let result = stream_native_table_rows(
+                state,
+                pool_key,
+                db_type,
+                &sql,
+                row_limit,
+                &cancelled,
+                cancel_token.clone(),
+                |row| {
+                    let rows_markdown = format_markdown_rows(&[row.to_vec()]);
+                    if !rows_markdown.is_empty() {
+                        if wrote_rows {
+                            file.write_all(b"\n").map_err(|e| format!("Failed to write Markdown: {e}"))?;
+                        }
+                        file.write_all(rows_markdown.as_bytes())
+                            .map_err(|e| format!("Failed to write Markdown: {e}"))?;
+                        wrote_rows = true;
+                    }
+                    rows_exported += 1;
+                    if rows_exported % progress_interval == 0 {
+                        on_progress(TableExportProgress {
+                            export_id: request.export_id.clone(),
+                            table_name: request.table_name.clone(),
+                            rows_exported,
+                            total_rows,
+                            status: ExportStatus::Running,
+                            error_message: None,
+                        });
+                    }
+                    Ok(())
+                },
+            )
+            .await;
+            if result.is_ok() {
+                file.write_all(b"\n").map_err(|e| format!("Failed to write Markdown: {e}"))?;
+                file.flush().map_err(|e| format!("Failed to flush export file: {e}"))?;
+            }
+            result
+        }
+        "sql" => {
+            let mut file = BufWriter::new(
+                std::fs::File::create(&request.file_path).map_err(|e| format!("Failed to create file: {e}"))?,
+            );
+            let mut pending_rows: Vec<Vec<Value>> = Vec::new();
+            let mut wrote_statements = false;
+            let mut flush_pending =
+                |file: &mut BufWriter<std::fs::File>, pending_rows: &mut Vec<Vec<Value>>| -> Result<(), String> {
+                    if pending_rows.is_empty() {
+                        return Ok(());
+                    }
+                    let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+                        database_type: Some(*db_type),
+                        schema: request.schema.clone(),
+                        table_name: Some(request.table_name.clone()),
+                        qualified_table_name: None,
+                        columns: col_names.to_vec(),
+                        column_types: column_types.to_vec(),
+                        column_extras: column_extras.to_vec(),
+                        rows: std::mem::take(pending_rows),
+                        batch_size: Some(SQL_INSERT_BATCH_SIZE),
+                    })?;
+                    if !statements.is_empty() {
+                        if wrote_statements {
+                            file.write_all(b"\n").map_err(|e| format!("Failed to write SQL: {e}"))?;
+                        }
+                        file.write_all(statements.join("\n").as_bytes())
+                            .map_err(|e| format!("Failed to write SQL: {e}"))?;
+                        wrote_statements = true;
+                    }
+                    Ok(())
+                };
+            let result = stream_native_table_rows(
+                state,
+                pool_key,
+                db_type,
+                &sql,
+                row_limit,
+                &cancelled,
+                cancel_token.clone(),
+                |row| {
+                    pending_rows.push(row.to_vec());
+                    if pending_rows.len() >= SQL_INSERT_BATCH_SIZE {
+                        flush_pending(&mut file, &mut pending_rows)?;
+                    }
+                    rows_exported += 1;
+                    if rows_exported % progress_interval == 0 {
+                        on_progress(TableExportProgress {
+                            export_id: request.export_id.clone(),
+                            table_name: request.table_name.clone(),
+                            rows_exported,
+                            total_rows,
+                            status: ExportStatus::Running,
+                            error_message: None,
+                        });
+                    }
+                    Ok(())
+                },
+            )
+            .await;
+            if result.is_ok() {
+                flush_pending(&mut file, &mut pending_rows)?;
+                if wrote_statements {
+                    file.write_all(b"\n").map_err(|e| format!("Failed to write SQL: {e}"))?;
+                }
+                file.flush().map_err(|e| format!("Failed to flush export file: {e}"))?;
+            }
+            result
+        }
+        _ => Ok(false),
+    };
+
+    cancel_watcher.abort();
+
+    match stream_result {
+        Ok(false) => Ok(false),
+        Ok(true) => {
+            if rows_exported % progress_interval != 0 {
+                on_progress(TableExportProgress {
+                    export_id: request.export_id.clone(),
+                    table_name: request.table_name.clone(),
+                    rows_exported,
+                    total_rows,
+                    status: ExportStatus::Running,
+                    error_message: None,
+                });
+            }
+            on_progress(TableExportProgress {
+                export_id: request.export_id.clone(),
+                table_name: request.table_name.clone(),
+                rows_exported,
+                total_rows,
+                status: ExportStatus::Done,
+                error_message: None,
+            });
+            Ok(true)
+        }
+        Err(error) if cancelled.load(Ordering::SeqCst) || error == crate::query::canceled_error() => {
+            on_progress(TableExportProgress {
+                export_id: request.export_id.clone(),
+                table_name: request.table_name.clone(),
+                rows_exported,
+                total_rows,
+                status: ExportStatus::Cancelled,
+                error_message: Some("Export cancelled".to_string()),
+            });
+            Ok(true)
+        }
+        Err(error) => Err(error),
+    }
+}
+
+fn next_export_batch_size(row_limit: Option<usize>, rows_exported: u64, batch_size: usize) -> Option<usize> {
+    let remaining = row_limit.map(|limit| limit.saturating_sub(rows_exported as usize));
+    if matches!(remaining, Some(0)) {
+        return None;
+    }
+    Some(remaining.map_or(batch_size, |value| value.min(batch_size)).max(1))
+}
+
+pub async fn export_table_data_core(
+    state: &AppState,
+    request: &TableExportRequest,
+    on_progress: impl Fn(TableExportProgress),
+) -> Result<(), String> {
+    // 1. Get database type
+    let db_type = state
+        .configs
+        .read()
+        .await
+        .get(&request.connection_id)
+        .map(|c| c.db_type)
+        .ok_or_else(|| format!("Connection config not found: {}", request.connection_id))?;
+
+    // 2. Get pool
+    let client_session_id = table_export_client_session_id(&request.export_id);
+    let pool_key = state
+        .get_or_create_pool_for_session(&request.connection_id, Some(&request.database), Some(&client_session_id))
+        .await?;
+
+    // 3. Resolve columns. Data grid exports can provide columns/primary keys
+    // directly, which avoids expensive metadata round-trips on JDBC drivers.
+    let requested_columns = request.columns.as_ref().filter(|columns| !columns.is_empty());
+    let (col_names, column_types, column_extras, primary_keys) = if let Some(requested_columns) = requested_columns {
+        let primary_keys = request.primary_keys.clone().unwrap_or_default();
+        let column_types = request.column_types.clone().unwrap_or_default();
+        (requested_columns.clone(), column_types, Vec::new(), primary_keys)
+    } else {
+        let columns = crate::schema::get_columns_core(
+            state,
+            &request.connection_id,
+            &request.database,
+            request.schema.as_deref().unwrap_or(""),
+            &request.table_name,
+        )
+        .await?;
+        let col_names: Vec<String> = columns.iter().map(|c| c.name.clone()).collect();
+        let column_types: Vec<Option<String>> = columns.iter().map(|c| Some(c.data_type.clone())).collect();
+        let column_extras: Vec<Option<String>> = columns.iter().map(|c| c.extra.clone()).collect();
+        let primary_keys: Vec<String> = columns.iter().filter(|c| c.is_primary_key).map(|c| c.name.clone()).collect();
+        (col_names, column_types, column_extras, primary_keys)
+    };
+
+    if col_names.is_empty() {
+        return Err("No columns found for table".to_string());
+    }
+
+    // Use keyset pagination when all PKs are in the selected (filtered) columns.
+    // This avoids the OFFSET performance penalty for large tables.
+    // When no PK is available, falls back to offset-based pagination.
+    let has_custom_filter_or_order = request.where_input.as_ref().is_some_and(|value| !value.trim().is_empty())
+        || request.order_by.as_ref().is_some_and(|value| !value.trim().is_empty());
+    let use_keyset =
+        !has_custom_filter_or_order && !primary_keys.is_empty() && primary_keys.iter().all(|pk| col_names.contains(pk));
+
+    // PK column indices within result rows (for extracting last-row values)
+    let pk_indices: Vec<usize> = if use_keyset {
+        primary_keys.iter().map(|pk| col_names.iter().position(|c| c == pk).unwrap()).collect()
+    } else {
+        Vec::new()
+    };
+
+    // 6. Get total row count for progress estimation when requested. Data
+    // grid exports skip this by default because COUNT can be the slowest query
+    // on large HANA/JDBC tables, especially with filters.
+    let row_limit = request.row_limit;
+    let total_rows = if request.skip_count {
+        None
+    } else {
+        let count_query = count_sql_with_where(
+            &request.table_name,
+            request.schema.as_deref().unwrap_or(""),
+            &db_type,
+            request.where_input.as_deref(),
+        );
+        match execute_read_on_pool(state, &pool_key, &count_query).await {
+            Ok(result) => result
+                .rows
+                .first()
+                .and_then(|r| r.first())
+                .and_then(|v| match v {
+                    Value::Number(n) => n.as_u64(),
+                    Value::String(s) => s.parse::<u64>().ok(),
+                    _ => None,
+                })
+                .map(|total| row_limit.map_or(total, |limit| total.min(limit as u64))),
+            Err(_) => None,
+        }
+    };
+
+    // 7. Emit initial Running progress
+    on_progress(TableExportProgress {
+        export_id: request.export_id.clone(),
+        table_name: request.table_name.clone(),
+        rows_exported: 0,
+        total_rows,
+        status: ExportStatus::Running,
+        error_message: None,
+    });
+
+    if try_export_native_table_stream(
+        state,
+        &pool_key,
+        request,
+        &db_type,
+        &col_names,
+        &column_types,
+        &column_extras,
+        &primary_keys,
+        total_rows,
+        row_limit,
+        request.batch_size.unwrap_or(DEFAULT_BATCH_SIZE).max(1),
+        &on_progress,
+    )
+    .await?
+    {
+        return Ok(());
+    }
+
+    // 8. Create output file
+    let file = std::fs::File::create(&request.file_path).map_err(|e| format!("Failed to create file: {e}"))?;
+    let mut file = BufWriter::new(file);
+
+    let mut rows_exported: u64 = 0;
+    let batch_size = request.batch_size.unwrap_or(DEFAULT_BATCH_SIZE).max(1);
+    let mut offset: u64 = 0;
+    let mut table_read_session_id: Option<String> = None;
+    let mut table_read_attempted = false;
+    let mut table_read_completed = false;
+
+    // Track last primary key values for keyset pagination
+    let mut last_pk_values: Vec<Value> = Vec::new();
+
+    match request.format.to_lowercase().as_str() {
+        "csv" => {
+            // Write UTF-8 BOM
+            file.write_all(b"\xEF\xBB\xBF").map_err(|e| format!("Failed to write BOM: {e}"))?;
+
+            let mut is_first_batch = true;
+
+            loop {
+                // Check cancellation between batches
+                if is_export_cancelled(&request.export_id).await {
+                    on_progress(TableExportProgress {
+                        export_id: request.export_id.clone(),
+                        table_name: request.table_name.clone(),
+                        rows_exported,
+                        total_rows,
+                        status: ExportStatus::Cancelled,
+                        error_message: Some("Export cancelled".to_string()),
+                    });
+                    close_table_read_session_if_open(state, &pool_key, &mut table_read_session_id).await;
+                    return Ok(());
+                }
+
+                let Some(active_batch_size) = next_export_batch_size(row_limit, rows_exported, batch_size) else {
+                    break;
+                };
+                let result = fetch_table_export_batch(
+                    state,
+                    &pool_key,
+                    request,
+                    &db_type,
+                    &col_names,
+                    &primary_keys,
+                    use_keyset,
+                    &last_pk_values,
+                    offset,
+                    active_batch_size,
+                    &mut table_read_session_id,
+                    &mut table_read_attempted,
+                    &mut table_read_completed,
+                )
+                .await?;
+                let row_count = result.rows.len();
+                if row_count == 0 {
+                    break;
+                }
+
+                if is_first_batch {
+                    // First batch: write header + rows via format_csv
+                    let csv_content = format_csv(&col_names, &result.rows);
+                    file.write_all(csv_content.as_bytes()).map_err(|e| format!("Failed to write CSV: {e}"))?;
+                    is_first_batch = false;
+                } else {
+                    // Subsequent batches: write rows only (prepend newline for separation)
+                    let rows_csv = format_csv_rows(&result.rows);
+                    if !rows_csv.is_empty() {
+                        write!(file, "\n{rows_csv}").map_err(|e| format!("Failed to write CSV rows: {e}"))?;
+                    }
+                }
+
+                rows_exported += row_count as u64;
+
+                if use_keyset {
+                    // Keyset pagination: track last PK values for next batch
+                    if let Some(last_row) = result.rows.last() {
+                        last_pk_values = pk_indices.iter().map(|&i| last_row[i].clone()).collect();
+                    }
+                } else {
+                    offset += row_count as u64;
+                }
+
+                on_progress(TableExportProgress {
+                    export_id: request.export_id.clone(),
+                    table_name: request.table_name.clone(),
+                    rows_exported,
+                    total_rows,
+                    status: ExportStatus::Running,
+                    error_message: None,
+                });
+
+                if row_count < active_batch_size {
+                    break;
+                }
+            }
+        }
+        "xlsx" => {
+            let column_types = export_column_types(request);
+            // Create a dedicated file handle for the streaming XLSX writer
+            // instead of cloning the outer BufWriter's handle.  This avoids
+            // sharing a file descriptor between two independent buffers.
+            let xlsx_file =
+                std::fs::File::create(&request.file_path).map_err(|e| format!("Failed to create XLSX file: {e}"))?;
+            let mut writer = start_streaming_xlsx_workbook(
+                BufWriter::new(xlsx_file),
+                Some(&request.table_name),
+                &col_names,
+                &column_types,
+            )?;
+
+            loop {
+                // Check cancellation between batches
+                if is_export_cancelled(&request.export_id).await {
+                    on_progress(TableExportProgress {
+                        export_id: request.export_id.clone(),
+                        table_name: request.table_name.clone(),
+                        rows_exported,
+                        total_rows,
+                        status: ExportStatus::Cancelled,
+                        error_message: Some("Export cancelled".to_string()),
+                    });
+                    close_table_read_session_if_open(state, &pool_key, &mut table_read_session_id).await;
+                    return Ok(());
+                }
+
+                let Some(active_batch_size) = next_export_batch_size(row_limit, rows_exported, batch_size) else {
+                    break;
+                };
+                let result = fetch_table_export_batch(
+                    state,
+                    &pool_key,
+                    request,
+                    &db_type,
+                    &col_names,
+                    &primary_keys,
+                    use_keyset,
+                    &last_pk_values,
+                    offset,
+                    active_batch_size,
+                    &mut table_read_session_id,
+                    &mut table_read_attempted,
+                    &mut table_read_completed,
+                )
+                .await?;
+                let row_count = result.rows.len();
+                if row_count == 0 {
+                    break;
+                }
+
+                for row in &result.rows {
+                    writer.write_row(row).map_err(|e| format!("Failed to write XLSX row: {e}"))?;
+                }
+                rows_exported += row_count as u64;
+
+                if use_keyset {
+                    // Keyset pagination: track last PK values for next batch
+                    if let Some(last_row) = result.rows.last() {
+                        last_pk_values = pk_indices.iter().map(|&i| last_row[i].clone()).collect();
+                    }
+                } else {
+                    offset += row_count as u64;
+                }
+
+                on_progress(TableExportProgress {
+                    export_id: request.export_id.clone(),
+                    table_name: request.table_name.clone(),
+                    rows_exported,
+                    total_rows,
+                    status: ExportStatus::Running,
+                    error_message: None,
+                });
+
+                if row_count < active_batch_size {
+                    break;
+                }
+            }
+
+            // Emit Writing progress before building XLSX
+            on_progress(TableExportProgress {
+                export_id: request.export_id.clone(),
+                table_name: request.table_name.clone(),
+                rows_exported,
+                total_rows,
+                status: ExportStatus::Writing,
+                error_message: None,
+            });
+
+            // Explicitly flush the XLSX writer's BufWriter so IO errors
+            // (e.g. disk-full) are surfaced rather than silently swallowed
+            // by Drop.
+            let mut xlsx_buf =
+                finish_streaming_xlsx_workbook(writer).map_err(|e| format!("Failed to finalize XLSX file: {e}"))?;
+            xlsx_buf.flush().map_err(|e| format!("Failed to flush XLSX file: {e}"))?;
+        }
+        "json" => {
+            file.write_all(b"[\n").map_err(|e| format!("Failed to write JSON: {e}"))?;
+            let mut is_first_row = true;
+
+            loop {
+                if is_export_cancelled(&request.export_id).await {
+                    on_progress(TableExportProgress {
+                        export_id: request.export_id.clone(),
+                        table_name: request.table_name.clone(),
+                        rows_exported,
+                        total_rows,
+                        status: ExportStatus::Cancelled,
+                        error_message: Some("Export cancelled".to_string()),
+                    });
+                    close_table_read_session_if_open(state, &pool_key, &mut table_read_session_id).await;
+                    return Ok(());
+                }
+
+                let Some(active_batch_size) = next_export_batch_size(row_limit, rows_exported, batch_size) else {
+                    break;
+                };
+                let result = fetch_table_export_batch(
+                    state,
+                    &pool_key,
+                    request,
+                    &db_type,
+                    &col_names,
+                    &primary_keys,
+                    use_keyset,
+                    &last_pk_values,
+                    offset,
+                    active_batch_size,
+                    &mut table_read_session_id,
+                    &mut table_read_attempted,
+                    &mut table_read_completed,
+                )
+                .await?;
+                let row_count = result.rows.len();
+                if row_count == 0 {
+                    break;
+                }
+
+                for row in &result.rows {
+                    if !is_first_row {
+                        file.write_all(b",\n").map_err(|e| format!("Failed to write JSON: {e}"))?;
+                    }
+                    write_json_row_object(&mut file, &col_names, row)?;
+                    is_first_row = false;
+                }
+
+                rows_exported += row_count as u64;
+                if use_keyset {
+                    if let Some(last_row) = result.rows.last() {
+                        last_pk_values = pk_indices.iter().map(|&i| last_row[i].clone()).collect();
+                    }
+                } else {
+                    offset += row_count as u64;
+                }
+
+                on_progress(TableExportProgress {
+                    export_id: request.export_id.clone(),
+                    table_name: request.table_name.clone(),
+                    rows_exported,
+                    total_rows,
+                    status: ExportStatus::Running,
+                    error_message: None,
+                });
+
+                if row_count < active_batch_size {
+                    break;
+                }
+            }
+
+            file.write_all(b"\n]\n").map_err(|e| format!("Failed to write JSON: {e}"))?;
+        }
+        "markdown" | "md" => {
+            file.write_all(format_markdown_header(&col_names).as_bytes())
+                .map_err(|e| format!("Failed to write Markdown: {e}"))?;
+            let mut wrote_rows = false;
+
+            loop {
+                if is_export_cancelled(&request.export_id).await {
+                    on_progress(TableExportProgress {
+                        export_id: request.export_id.clone(),
+                        table_name: request.table_name.clone(),
+                        rows_exported,
+                        total_rows,
+                        status: ExportStatus::Cancelled,
+                        error_message: Some("Export cancelled".to_string()),
+                    });
+                    close_table_read_session_if_open(state, &pool_key, &mut table_read_session_id).await;
+                    return Ok(());
+                }
+
+                let Some(active_batch_size) = next_export_batch_size(row_limit, rows_exported, batch_size) else {
+                    break;
+                };
+                let result = fetch_table_export_batch(
+                    state,
+                    &pool_key,
+                    request,
+                    &db_type,
+                    &col_names,
+                    &primary_keys,
+                    use_keyset,
+                    &last_pk_values,
+                    offset,
+                    active_batch_size,
+                    &mut table_read_session_id,
+                    &mut table_read_attempted,
+                    &mut table_read_completed,
+                )
+                .await?;
+                let row_count = result.rows.len();
+                if row_count == 0 {
+                    break;
+                }
+
+                let rows_markdown = format_markdown_rows(&result.rows);
+                if !rows_markdown.is_empty() {
+                    if wrote_rows {
+                        file.write_all(b"\n").map_err(|e| format!("Failed to write Markdown: {e}"))?;
+                    }
+                    file.write_all(rows_markdown.as_bytes()).map_err(|e| format!("Failed to write Markdown: {e}"))?;
+                    wrote_rows = true;
+                }
+
+                rows_exported += row_count as u64;
+                if use_keyset {
+                    if let Some(last_row) = result.rows.last() {
+                        last_pk_values = pk_indices.iter().map(|&i| last_row[i].clone()).collect();
+                    }
+                } else {
+                    offset += row_count as u64;
+                }
+
+                on_progress(TableExportProgress {
+                    export_id: request.export_id.clone(),
+                    table_name: request.table_name.clone(),
+                    rows_exported,
+                    total_rows,
+                    status: ExportStatus::Running,
+                    error_message: None,
+                });
+
+                if row_count < active_batch_size {
+                    break;
+                }
+            }
+
+            file.write_all(b"\n").map_err(|e| format!("Failed to write Markdown: {e}"))?;
+        }
+        "sql" => {
+            let mut wrote_statements = false;
+
+            loop {
+                if is_export_cancelled(&request.export_id).await {
+                    on_progress(TableExportProgress {
+                        export_id: request.export_id.clone(),
+                        table_name: request.table_name.clone(),
+                        rows_exported,
+                        total_rows,
+                        status: ExportStatus::Cancelled,
+                        error_message: Some("Export cancelled".to_string()),
+                    });
+                    close_table_read_session_if_open(state, &pool_key, &mut table_read_session_id).await;
+                    return Ok(());
+                }
+
+                let Some(active_batch_size) = next_export_batch_size(row_limit, rows_exported, batch_size) else {
+                    break;
+                };
+                let result = fetch_table_export_batch(
+                    state,
+                    &pool_key,
+                    request,
+                    &db_type,
+                    &col_names,
+                    &primary_keys,
+                    use_keyset,
+                    &last_pk_values,
+                    offset,
+                    active_batch_size,
+                    &mut table_read_session_id,
+                    &mut table_read_attempted,
+                    &mut table_read_completed,
+                )
+                .await?;
+                let row_count = result.rows.len();
+                if row_count == 0 {
+                    break;
+                }
+
+                let statements = build_export_insert_statements(BuildExportInsertStatementsOptions {
+                    database_type: Some(db_type),
+                    schema: request.schema.clone(),
+                    table_name: Some(request.table_name.clone()),
+                    qualified_table_name: None,
+                    columns: col_names.clone(),
+                    column_types: column_types.clone(),
+                    column_extras: column_extras.clone(),
+                    rows: result.rows.clone(),
+                    batch_size: Some(100),
+                })?;
+                if !statements.is_empty() {
+                    if wrote_statements {
+                        file.write_all(b"\n").map_err(|e| format!("Failed to write SQL: {e}"))?;
+                    }
+                    file.write_all(statements.join("\n").as_bytes())
+                        .map_err(|e| format!("Failed to write SQL: {e}"))?;
+                    wrote_statements = true;
+                }
+
+                rows_exported += row_count as u64;
+                if use_keyset {
+                    if let Some(last_row) = result.rows.last() {
+                        last_pk_values = pk_indices.iter().map(|&i| last_row[i].clone()).collect();
+                    }
+                } else {
+                    offset += row_count as u64;
+                }
+
+                on_progress(TableExportProgress {
+                    export_id: request.export_id.clone(),
+                    table_name: request.table_name.clone(),
+                    rows_exported,
+                    total_rows,
+                    status: ExportStatus::Running,
+                    error_message: None,
+                });
+
+                if row_count < active_batch_size {
+                    break;
+                }
+            }
+
+            if wrote_statements {
+                file.write_all(b"\n").map_err(|e| format!("Failed to write SQL: {e}"))?;
+            }
+        }
+        other => {
+            return Err(format!("Unsupported export format: {other}"));
+        }
+    }
+
+    close_table_read_session_if_open(state, &pool_key, &mut table_read_session_id).await;
+    file.flush().map_err(|e| format!("Failed to flush export file: {e}"))?;
+
+    // 8. Emit Done progress
+    on_progress(TableExportProgress {
+        export_id: request.export_id.clone(),
+        table_name: request.table_name.clone(),
+        rows_exported,
+        total_rows,
+        status: ExportStatus::Done,
+        error_message: None,
+    });
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::database_export::{clear_export_cancelled, set_export_cancelled};
+    use crate::xlsx_export::{build_xlsx_workbook, XlsxWorksheetData};
+    use serde_json::json;
+    use std::io::Read;
+
+    /// Read and decompress a single entry from an in-memory XLSX (ZIP) buffer.
+    fn read_zip_entry(bytes: &[u8], path: &str) -> String {
+        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes.to_vec())).expect("open xlsx as zip archive");
+        let mut entry = archive.by_name(path).unwrap_or_else(|_| panic!("missing zip entry: {path}"));
+        let mut content = String::new();
+        entry.read_to_string(&mut content).expect("read zip entry");
+        content
+    }
+
+    // -----------------------------------------------------------------------
+    // Helper: check that two CSV strings are equivalent by splitting lines
+    // -----------------------------------------------------------------------
+    fn csv_lines_equal(actual: &str, expected: &str) -> bool {
+        let actual_lines: Vec<&str> = actual.lines().collect();
+        let expected_lines: Vec<&str> = expected.lines().collect();
+        actual_lines == expected_lines
+    }
+
+    // -----------------------------------------------------------------------
+    // format_csv_rows
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn formats_csv_rows_with_multiple_columns() {
+        let rows = vec![vec![json!(1), json!("Alice")], vec![json!(2), json!("Bob \"Builder\"")]];
+        let out = format_csv_rows(&rows);
+        assert!(csv_lines_equal(&out, "\"1\",\"Alice\"\n\"2\",\"Bob \"\"Builder\"\"\""));
+    }
+
+    #[test]
+    fn formats_csv_rows_with_null_values() {
+        let rows = vec![vec![json!(1), Value::Null, json!("active")], vec![json!(2), json!("some notes"), Value::Null]];
+        let out = format_csv_rows(&rows);
+        assert!(csv_lines_equal(&out, "\"1\",\"\",\"active\"\n\"2\",\"some notes\",\"\""));
+    }
+
+    #[test]
+    fn formats_csv_rows_with_boolean_and_number_values() {
+        let rows = vec![vec![json!(true), json!(2.75)], vec![json!(false), json!(-42)]];
+        let out = format_csv_rows(&rows);
+        assert!(csv_lines_equal(&out, "\"true\",\"2.75\"\n\"false\",\"-42\""));
+    }
+
+    #[test]
+    fn formats_csv_rows_returns_empty_string_for_empty_rows() {
+        let rows: Vec<Vec<Value>> = vec![];
+        let out = format_csv_rows(&rows);
+        assert_eq!(out, "");
+    }
+
+    #[test]
+    fn formats_csv_rows_single_row() {
+        let rows = vec![vec![json!("just"), json!("one")]];
+        let out = format_csv_rows(&rows);
+        assert_eq!(out, "\"just\",\"one\"");
+    }
+
+    #[test]
+    fn export_batch_size_respects_row_limit_remaining_rows() {
+        assert_eq!(next_export_batch_size(None, 12_000, 10_000), Some(10_000));
+        assert_eq!(next_export_batch_size(Some(15_000), 0, 10_000), Some(10_000));
+        assert_eq!(next_export_batch_size(Some(15_000), 10_000, 10_000), Some(5_000));
+        assert_eq!(next_export_batch_size(Some(15_000), 15_000, 10_000), None);
+    }
+
+    #[test]
+    fn oracle_table_cursor_sql_builds_single_ordered_select() {
+        let request = TableExportRequest {
+            export_id: "export-1".to_string(),
+            connection_id: "conn-1".to_string(),
+            database: "ORCL".to_string(),
+            schema: Some("APP".to_string()),
+            table_name: "events".to_string(),
+            file_path: "events.csv".to_string(),
+            format: "csv".to_string(),
+            columns: None,
+            column_types: None,
+            primary_keys: None,
+            where_input: Some("WHERE status = 'active'".to_string()),
+            order_by: None,
+            skip_count: false,
+            batch_size: Some(500),
+            row_limit: Some(1000),
+        };
+
+        let sql = table_cursor_sql(
+            &request,
+            &DatabaseType::Oracle,
+            &[String::from("id"), String::from("status")],
+            &[String::from("id")],
+        );
+
+        assert_eq!(
+            sql,
+            "SELECT \"id\", \"status\" FROM \"APP\".\"events\" WHERE (status = 'active') ORDER BY \"id\" ASC"
+        );
+        assert!(!sql.contains("OFFSET"));
+        assert!(!sql.contains("FETCH NEXT"));
+        assert!(!sql.contains("ROWNUM"));
+    }
+
+    #[test]
+    fn agent_table_read_unsupported_detects_old_agent_errors() {
+        assert!(is_agent_table_read_unsupported("Agent RPC error (-1): unknown method: start_table_read"));
+        assert!(is_agent_table_read_unsupported("Agent RPC error (-32601): Method not found"));
+        assert!(!is_agent_table_read_unsupported("ORA-00933: SQL command not properly ended"));
+    }
+
+    #[test]
+    fn writes_json_row_without_allocating_object_map() {
+        let mut out = Vec::new();
+        write_json_row_object(
+            &mut out,
+            &["id".to_string(), "name".to_string(), "missing".to_string()],
+            &[json!(1), json!("Ada")],
+        )
+        .unwrap();
+
+        assert_eq!(String::from_utf8(out).unwrap(), "{\n  \"id\": 1,\n  \"name\": \"Ada\"\n}");
+    }
+
+    #[test]
+    fn formats_csv_rows_escapes_embedded_commas_and_newlines() {
+        let rows = vec![vec![json!("hello,world"), json!("line1\nline2")]];
+        let out = format_csv_rows(&rows);
+        assert!(out.contains("\"hello,world\""));
+        assert!(out.contains("\"line1\nline2\""));
+        let records: Vec<Vec<String>> = csv::ReaderBuilder::new()
+            .has_headers(false)
+            .from_reader(out.as_bytes())
+            .records()
+            .map(|record| record.unwrap().iter().map(str::to_string).collect())
+            .collect();
+        assert_eq!(records, vec![vec!["hello,world".to_string(), "line1\nline2".to_string()]]);
+    }
+
+    // -----------------------------------------------------------------------
+    // Cancellation flow
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn cancellation_set_and_cleared_correctly() {
+        let export_id = "test-cancel-1";
+
+        assert!(!poll_is_cancelled(export_id));
+        block_on(set_export_cancelled(export_id));
+        assert!(poll_is_cancelled(export_id));
+        block_on(clear_export_cancelled(export_id));
+        assert!(!poll_is_cancelled(export_id));
+    }
+
+    #[test]
+    fn cancellation_is_id_scoped() {
+        let id_a = "cancel-scope-a";
+        let id_b = "cancel-scope-b";
+
+        block_on(set_export_cancelled(id_a));
+        assert!(poll_is_cancelled(id_a));
+        assert!(!poll_is_cancelled(id_b));
+        block_on(clear_export_cancelled(id_a));
+    }
+
+    // -----------------------------------------------------------------------
+    // XLSX workbook integration
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn builds_xlsx_workbook_with_table_export_data() {
+        let data = XlsxWorksheetData {
+            sheet_name: Some("employees".to_string()),
+            columns: vec!["id".to_string(), "name".to_string(), "salary".to_string()],
+            column_types: vec![],
+            rows: vec![
+                vec![json!(1), json!("Alice"), json!(75000.50)],
+                vec![json!(2), json!("Bob"), json!(82000)],
+                vec![json!(3), Value::Null, json!(0)],
+            ],
+        };
+        let workbook = build_xlsx_workbook(&data).expect("XLSX build should succeed");
+
+        assert_eq!(workbook[0], 0x50, "Should be a ZIP (PK) archive");
+        assert_eq!(workbook[1], 0x4b);
+
+        // Entries are Deflate-compressed; assert on their decompressed contents.
+        let workbook_xml = read_zip_entry(&workbook, "xl/workbook.xml");
+        let sheet = read_zip_entry(&workbook, "xl/worksheets/sheet1.xml");
+        assert!(workbook_xml.contains("name=\"employees\""));
+        assert!(sheet.contains("<v>75000.5</v>"));
+        assert!(sheet.contains("Alice"));
+    }
+
+    // -----------------------------------------------------------------------
+    // CSV header + rows (format_csv) — basic integration check
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn format_csv_produces_header_and_rows() {
+        let out = format_csv(
+            &["col1".to_string(), "col2".to_string()],
+            &[vec![json!("a"), json!("b")], vec![json!("c"), json!("d")]],
+        );
+        let lines: Vec<&str> = out.lines().collect();
+        assert_eq!(lines.len(), 3, "header + 2 data rows = 3 lines");
+        assert_eq!(lines[0], "\"col1\",\"col2\"");
+        assert_eq!(lines[1], "\"a\",\"b\"");
+        assert_eq!(lines[2], "\"c\",\"d\"");
+    }
+
+    // -----------------------------------------------------------------------
+    // Helpers for async cancellation in tests
+    // -----------------------------------------------------------------------
+
+    fn poll_is_cancelled(export_id: &str) -> bool {
+        block_on(is_export_cancelled(export_id))
+    }
+
+    fn block_on<F: std::future::Future>(future: F) -> F::Output {
+        tokio::runtime::Runtime::new().expect("create tokio runtime").block_on(future)
+    }
+}
diff --git a/crates/dbx-core/src/table_import.rs b/crates/dbx-core/src/table_import.rs
new file mode 100644
index 0000000..3619e6f
--- /dev/null
+++ b/crates/dbx-core/src/table_import.rs
@@ -0,0 +1,2224 @@
+use std::collections::HashSet;
+use std::fs::File;
+use std::path::Path;
+
+use calamine::{open_workbook_auto, Data, Reader};
+use chrono::{DateTime, NaiveDate, NaiveDateTime};
+use serde::{Deserialize, Serialize};
+
+use crate::connection::{task_client_session_id, AppState};
+use crate::models::connection::DatabaseType;
+use crate::transfer::{
+    execute_on_pool, generate_insert_typed, get_columns_for_transfer, qualified_table, quote_identifier,
+};
+
+pub const DEFAULT_PREVIEW_LIMIT: usize = 50;
+pub const DEFAULT_BATCH_SIZE: usize = 500;
+pub const CREATE_TABLE_INFERENCE_ROWS: usize = 100;
+pub const MAX_NON_STREAMING_IMPORT_BYTES: u64 = 100 * 1024 * 1024;
+
+pub fn table_import_client_session_id(import_id: &str) -> String {
+    task_client_session_id("table-import", import_id)
+}
+
+#[derive(Debug, Clone)]
+pub struct ParsedImportFile {
+    pub columns: Vec<String>,
+    pub rows: Vec<Vec<serde_json::Value>>,
+    pub total_rows: usize,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImportSqlBatch {
+    pub sql: String,
+    pub row_count: usize,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImportCreateTableColumn {
+    pub name: String,
+    pub data_type: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ImportCreateTablePlan {
+    pub sql: String,
+    pub columns: Vec<ImportCreateTableColumn>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableImportColumnMapping {
+    pub source_column: String,
+    pub target_column: String,
+    #[serde(default)]
+    pub target_data_type: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum TableImportMode {
+    Append,
+    Truncate,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum TableImportSourceFormat {
+    Csv,
+    Tsv,
+    Delimited,
+    Json,
+    Excel,
+}
+
+impl TableImportSourceFormat {
+    pub fn label(self) -> &'static str {
+        match self {
+            TableImportSourceFormat::Csv => "csv",
+            TableImportSourceFormat::Tsv => "tsv",
+            TableImportSourceFormat::Delimited => "txt",
+            TableImportSourceFormat::Json => "json",
+            TableImportSourceFormat::Excel => "excel",
+        }
+    }
+
+    pub fn is_delimited(self) -> bool {
+        matches!(self, TableImportSourceFormat::Csv | TableImportSourceFormat::Tsv | TableImportSourceFormat::Delimited)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum TableImportJsonShape {
+    Auto,
+    Objects,
+    Arrays,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableImportParseOptions {
+    pub delimiter: Option<String>,
+    pub has_header: Option<bool>,
+    pub title_row: Option<usize>,
+    pub data_start_row: Option<usize>,
+    pub last_data_row: Option<usize>,
+    pub trim_values: Option<bool>,
+    pub empty_string_as_null: Option<bool>,
+    pub sheet_name: Option<String>,
+    pub sheet_index: Option<usize>,
+    pub json_shape: Option<TableImportJsonShape>,
+}
+
+impl Default for TableImportParseOptions {
+    fn default() -> Self {
+        Self {
+            delimiter: None,
+            has_header: None,
+            title_row: None,
+            data_start_row: None,
+            last_data_row: None,
+            trim_values: Some(false),
+            empty_string_as_null: Some(true),
+            sheet_name: None,
+            sheet_index: None,
+            json_shape: Some(TableImportJsonShape::Auto),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableImportPreviewRequest {
+    pub file_path: String,
+    #[serde(default)]
+    pub source_ref: Option<String>,
+    #[serde(default)]
+    pub source_format: Option<TableImportSourceFormat>,
+    #[serde(default)]
+    pub parse_options: TableImportParseOptions,
+    #[serde(default)]
+    pub preview_limit: Option<usize>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableImportRequest {
+    pub import_id: String,
+    pub connection_id: String,
+    pub database: String,
+    pub schema: String,
+    pub table: String,
+    pub file_path: String,
+    #[serde(default)]
+    pub source_ref: Option<String>,
+    #[serde(default)]
+    pub source_format: Option<TableImportSourceFormat>,
+    #[serde(default)]
+    pub parse_options: TableImportParseOptions,
+    pub mappings: Vec<TableImportColumnMapping>,
+    pub mode: TableImportMode,
+    #[serde(default)]
+    pub create_table: bool,
+    pub batch_size: usize,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableImportPreview {
+    pub file_name: String,
+    pub file_path: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub source_ref: Option<String>,
+    pub file_type: String,
+    pub size_bytes: u64,
+    pub columns: Vec<String>,
+    pub rows: Vec<Vec<serde_json::Value>>,
+    pub total_rows: usize,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub sheets: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableImportSummary {
+    pub import_id: String,
+    pub rows_imported: usize,
+    pub total_rows: usize,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableImportProgress {
+    pub import_id: String,
+    pub status: TableImportStatus,
+    pub rows_imported: usize,
+    pub total_rows: usize,
+    pub error: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum TableImportStatus {
+    Running,
+    Done,
+    Error,
+    Cancelled,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ImportFileKind {
+    Csv,
+    Tsv,
+    Txt,
+    Json,
+    Xlsx,
+}
+
+impl ImportFileKind {
+    pub fn label(self) -> &'static str {
+        match self {
+            ImportFileKind::Csv => "csv",
+            ImportFileKind::Tsv => "tsv",
+            ImportFileKind::Txt => "txt",
+            ImportFileKind::Json => "json",
+            ImportFileKind::Xlsx => "xlsx",
+        }
+    }
+}
+
+pub fn import_file_kind(path: &str) -> Result<ImportFileKind, String> {
+    let lower = path.to_lowercase();
+    if lower.ends_with(".csv") {
+        Ok(ImportFileKind::Csv)
+    } else if lower.ends_with(".tsv") {
+        Ok(ImportFileKind::Tsv)
+    } else if lower.ends_with(".txt") {
+        Ok(ImportFileKind::Txt)
+    } else if lower.ends_with(".json") {
+        Ok(ImportFileKind::Json)
+    } else if lower.ends_with(".xlsx") || lower.ends_with(".xlsm") || lower.ends_with(".xls") {
+        Ok(ImportFileKind::Xlsx)
+    } else {
+        Err("Unsupported import file type".to_string())
+    }
+}
+
+pub fn source_format_for_path(path: &str) -> Result<TableImportSourceFormat, String> {
+    Ok(match import_file_kind(path)? {
+        ImportFileKind::Csv => TableImportSourceFormat::Csv,
+        ImportFileKind::Tsv => TableImportSourceFormat::Tsv,
+        ImportFileKind::Txt => TableImportSourceFormat::Delimited,
+        ImportFileKind::Json => TableImportSourceFormat::Json,
+        ImportFileKind::Xlsx => TableImportSourceFormat::Excel,
+    })
+}
+
+pub fn effective_source_format(
+    path: &str,
+    source_format: Option<TableImportSourceFormat>,
+) -> Result<TableImportSourceFormat, String> {
+    source_format
+        .or_else(|| source_format_for_path(path).ok())
+        .ok_or_else(|| "Unsupported import file type".to_string())
+}
+
+pub fn normalize_header(value: &str, index: usize) -> String {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        format!("column_{}", index + 1)
+    } else {
+        trimmed.to_string()
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct DelimitedParseConfig {
+    pub delimiter: u8,
+    pub trim_values: bool,
+    pub empty_string_as_null: bool,
+    pub row_range: ImportRowRange,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ImportRowRange {
+    pub title_row: Option<usize>,
+    pub data_start_row: usize,
+    pub last_data_row: Option<usize>,
+}
+
+pub fn effective_import_row_range(options: &TableImportParseOptions) -> Result<ImportRowRange, String> {
+    let title_row = match options.title_row {
+        Some(0) => None,
+        Some(row) => Some(row),
+        None if options.has_header.unwrap_or(true) => Some(1),
+        None => None,
+    };
+    let data_start_row = options.data_start_row.unwrap_or_else(|| title_row.map_or(1, |row| row + 1));
+    let last_data_row = options.last_data_row.filter(|row| *row > 0);
+    if data_start_row == 0 {
+        return Err("Data start row must be at least 1".to_string());
+    }
+    if title_row.is_some_and(|row| row >= data_start_row) {
+        return Err("Title row must be before the data start row".to_string());
+    }
+    if last_data_row.is_some_and(|last| last < data_start_row) {
+        return Err("Last data row must be 0 or not less than the data start row".to_string());
+    }
+    Ok(ImportRowRange { title_row, data_start_row, last_data_row })
+}
+
+pub fn effective_delimited_config(
+    source_format: TableImportSourceFormat,
+    options: &TableImportParseOptions,
+) -> Result<DelimitedParseConfig, String> {
+    let default_delimiter = match source_format {
+        TableImportSourceFormat::Tsv => b'\t',
+        _ => b',',
+    };
+    let delimiter = match options.delimiter.as_deref() {
+        None | Some("") => default_delimiter,
+        Some("\\t") | Some("tab") | Some("TAB") => b'\t',
+        Some(value) => {
+            let bytes = value.as_bytes();
+            if bytes.len() != 1 {
+                return Err("Delimiter must be a single-byte character".to_string());
+            }
+            bytes[0]
+        }
+    };
+
+    Ok(DelimitedParseConfig {
+        delimiter,
+        trim_values: options.trim_values.unwrap_or(false),
+        empty_string_as_null: options.empty_string_as_null.unwrap_or(true),
+        row_range: effective_import_row_range(options)?,
+    })
+}
+
+pub fn csv_value_with_config(value: &str, config: DelimitedParseConfig) -> serde_json::Value {
+    let value = if config.trim_values { value.trim() } else { value };
+    if config.empty_string_as_null && value.is_empty() {
+        serde_json::Value::Null
+    } else {
+        serde_json::Value::String(value.to_string())
+    }
+}
+
+pub fn csv_value(value: &str) -> serde_json::Value {
+    csv_value_with_config(
+        value,
+        DelimitedParseConfig {
+            delimiter: b',',
+            trim_values: false,
+            empty_string_as_null: true,
+            row_range: ImportRowRange { title_row: Some(1), data_start_row: 2, last_data_row: None },
+        },
+    )
+}
+
+pub fn parse_delimited_reader<R: std::io::Read>(
+    reader: R,
+    config: DelimitedParseConfig,
+    preview_limit: usize,
+) -> Result<ParsedImportFile, String> {
+    let mut reader =
+        csv::ReaderBuilder::new().delimiter(config.delimiter).has_headers(false).flexible(true).from_reader(reader);
+
+    let mut rows = Vec::new();
+    let mut total_rows = 0;
+    let mut columns = Vec::new();
+    for (index, record) in reader.records().enumerate() {
+        let record = record.map_err(|e| e.to_string())?;
+        let row_number = index + 1;
+        if config.row_range.title_row == Some(row_number) {
+            columns = record
+                .iter()
+                .enumerate()
+                .map(|(index, header)| normalize_header(header.trim_start_matches('\u{feff}'), index))
+                .collect();
+            continue;
+        }
+        if row_number < config.row_range.data_start_row {
+            continue;
+        }
+        if config.row_range.last_data_row.is_some_and(|last| row_number > last) {
+            break;
+        }
+        if columns.is_empty() {
+            columns = (0..record.len()).map(|index| format!("column_{}", index + 1)).collect();
+        }
+        total_rows += 1;
+        if rows.len() >= preview_limit {
+            continue;
+        }
+        let mut row = Vec::with_capacity(columns.len());
+        for index in 0..columns.len() {
+            row.push(
+                record.get(index).map(|value| csv_value_with_config(value, config)).unwrap_or(serde_json::Value::Null),
+            );
+        }
+        rows.push(row);
+    }
+    if columns.is_empty() {
+        return Err("Import file has no columns in the selected row range".to_string());
+    }
+    if total_rows == 0 {
+        return Err("Import file has no data rows in the selected row range".to_string());
+    }
+    Ok(ParsedImportFile { columns, rows, total_rows })
+}
+
+pub fn parse_delimited_bytes_with_options(
+    bytes: &[u8],
+    source_format: TableImportSourceFormat,
+    options: &TableImportParseOptions,
+    preview_limit: usize,
+) -> Result<ParsedImportFile, String> {
+    parse_delimited_reader(
+        bytes.strip_prefix(b"\xEF\xBB\xBF").unwrap_or(bytes),
+        effective_delimited_config(source_format, options)?,
+        preview_limit,
+    )
+}
+
+pub fn parse_delimited_file_with_options(
+    path: &str,
+    source_format: TableImportSourceFormat,
+    options: &TableImportParseOptions,
+    preview_limit: usize,
+) -> Result<ParsedImportFile, String> {
+    let file = File::open(path).map_err(|e| e.to_string())?;
+    parse_delimited_reader(file, effective_delimited_config(source_format, options)?, preview_limit)
+}
+
+pub fn parse_csv_bytes(bytes: &[u8], preview_limit: usize) -> Result<ParsedImportFile, String> {
+    parse_delimited_bytes_with_options(
+        bytes,
+        TableImportSourceFormat::Csv,
+        &TableImportParseOptions::default(),
+        preview_limit,
+    )
+}
+
+pub fn parse_delimited_bytes(bytes: &[u8], delimiter: u8, preview_limit: usize) -> Result<ParsedImportFile, String> {
+    let options = TableImportParseOptions {
+        delimiter: Some(if delimiter == b'\t' { "\\t".to_string() } else { (delimiter as char).to_string() }),
+        ..TableImportParseOptions::default()
+    };
+    parse_delimited_bytes_with_options(bytes, TableImportSourceFormat::Delimited, &options, preview_limit)
+}
+
+pub fn parse_json_bytes_with_options(
+    bytes: &[u8],
+    options: &TableImportParseOptions,
+    preview_limit: usize,
+) -> Result<ParsedImportFile, String> {
+    let bytes = bytes.strip_prefix(b"\xEF\xBB\xBF").unwrap_or(bytes);
+    let value: serde_json::Value = serde_json::from_slice(bytes).map_err(|e| e.to_string())?;
+    let items = match value {
+        serde_json::Value::Array(items) => items,
+        serde_json::Value::Object(_) => vec![value],
+        _ => return Err("JSON import must be an object or an array".to_string()),
+    };
+    if items.is_empty() {
+        return Err("Import file has no rows".to_string());
+    }
+
+    let shape = options.json_shape.unwrap_or(TableImportJsonShape::Auto);
+    let all_objects = items.iter().all(|item| item.is_object());
+    let all_arrays = items.iter().all(|item| item.is_array());
+
+    if shape == TableImportJsonShape::Objects && !all_objects {
+        return Err("JSON import is configured for object rows, but at least one row is not an object".to_string());
+    }
+    if shape == TableImportJsonShape::Arrays && !all_arrays {
+        return Err("JSON import is configured for array rows, but at least one row is not an array".to_string());
+    }
+
+    if all_objects {
+        let mut columns = Vec::new();
+        for item in &items {
+            if let Some(obj) = item.as_object() {
+                for key in obj.keys() {
+                    if !columns.contains(key) {
+                        columns.push(key.clone());
+                    }
+                }
+            }
+        }
+        if columns.is_empty() {
+            return Err("Import file has no columns".to_string());
+        }
+        let rows = items
+            .iter()
+            .take(preview_limit)
+            .map(|item| {
+                let obj = item.as_object().expect("checked object JSON row");
+                columns
+                    .iter()
+                    .map(|column| obj.get(column).cloned().unwrap_or(serde_json::Value::Null))
+                    .collect::<Vec<_>>()
+            })
+            .collect::<Vec<_>>();
+        return Ok(ParsedImportFile { columns, rows, total_rows: items.len() });
+    }
+
+    if all_arrays {
+        let max_cols = items.iter().filter_map(|item| item.as_array().map(|row| row.len())).max().unwrap_or(0);
+        if max_cols == 0 {
+            return Err("Import file has no columns".to_string());
+        }
+        let columns = (0..max_cols).map(|index| format!("column_{}", index + 1)).collect::<Vec<_>>();
+        let rows = items
+            .iter()
+            .take(preview_limit)
+            .map(|item| {
+                let arr = item.as_array().expect("checked array JSON row");
+                (0..max_cols)
+                    .map(|index| arr.get(index).cloned().unwrap_or(serde_json::Value::Null))
+                    .collect::<Vec<_>>()
+            })
+            .collect::<Vec<_>>();
+        return Ok(ParsedImportFile { columns, rows, total_rows: items.len() });
+    }
+
+    Err("JSON rows must all be objects or all be arrays; mixed row shapes are not supported".to_string())
+}
+
+pub fn parse_json_bytes(bytes: &[u8], preview_limit: usize) -> Result<ParsedImportFile, String> {
+    parse_json_bytes_with_options(bytes, &TableImportParseOptions::default(), preview_limit)
+}
+
+pub fn xlsx_cell_value(cell: &Data) -> serde_json::Value {
+    match cell {
+        Data::Empty => serde_json::Value::Null,
+        Data::String(s) => csv_value(s),
+        Data::Float(n) => {
+            serde_json::Number::from_f64(*n).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null)
+        }
+        Data::Int(n) => serde_json::Value::Number((*n).into()),
+        Data::Bool(v) => serde_json::Value::Bool(*v),
+        Data::DateTime(v) => serde_json::Value::String(v.to_string()),
+        Data::DateTimeIso(v) => serde_json::Value::String(v.clone()),
+        Data::DurationIso(v) => serde_json::Value::String(v.clone()),
+        Data::Error(v) => serde_json::Value::String(v.to_string()),
+    }
+}
+
+pub fn xlsx_cell_label(cell: &Data) -> String {
+    match cell {
+        Data::Empty => String::new(),
+        Data::String(s) => s.clone(),
+        Data::Float(n) => n.to_string(),
+        Data::Int(n) => n.to_string(),
+        Data::Bool(v) => v.to_string(),
+        Data::DateTime(v) => v.to_string(),
+        Data::DateTimeIso(v) => v.clone(),
+        Data::DurationIso(v) => v.clone(),
+        Data::Error(v) => v.to_string(),
+    }
+}
+
+pub fn xlsx_sheet_names(path: &str) -> Result<Vec<String>, String> {
+    let workbook = open_workbook_auto(path).map_err(|e| e.to_string())?;
+    Ok(workbook.sheet_names().to_vec())
+}
+
+pub fn parse_xlsx_file_with_options(
+    path: &str,
+    options: &TableImportParseOptions,
+    preview_limit: usize,
+) -> Result<ParsedImportFile, String> {
+    let mut workbook = open_workbook_auto(path).map_err(|e| e.to_string())?;
+    let sheet_names = workbook.sheet_names().to_vec();
+    let sheet_name = if let Some(name) = options.sheet_name.as_ref().filter(|name| !name.trim().is_empty()) {
+        if !sheet_names.iter().any(|sheet| sheet == name) {
+            return Err(format!("Workbook sheet not found: {name}"));
+        }
+        name.clone()
+    } else if let Some(index) = options.sheet_index {
+        sheet_names.get(index).cloned().ok_or_else(|| format!("Workbook sheet index out of range: {index}"))?
+    } else {
+        sheet_names.first().cloned().ok_or_else(|| "Workbook has no sheets".to_string())?
+    };
+    let range = workbook.worksheet_range(&sheet_name).map_err(|e| e.to_string())?;
+    let row_range = effective_import_row_range(options)?;
+    let mut columns = Vec::new();
+    let mut rows = Vec::new();
+    let mut total_rows = 0;
+    for (index, source_row) in range.rows().enumerate() {
+        let row_number = index + 1;
+        if row_range.title_row == Some(row_number) {
+            columns = source_row
+                .iter()
+                .enumerate()
+                .map(|(index, cell)| normalize_header(&xlsx_cell_label(cell), index))
+                .collect();
+            continue;
+        }
+        if row_number < row_range.data_start_row {
+            continue;
+        }
+        if row_range.last_data_row.is_some_and(|last| row_number > last) {
+            break;
+        }
+        if columns.is_empty() {
+            columns = (0..source_row.len()).map(|index| format!("column_{}", index + 1)).collect();
+        }
+        total_rows += 1;
+        if rows.len() >= preview_limit {
+            continue;
+        }
+        let mut row = Vec::with_capacity(columns.len());
+        for index in 0..columns.len() {
+            row.push(source_row.get(index).map(xlsx_cell_value).unwrap_or(serde_json::Value::Null));
+        }
+        rows.push(row);
+    }
+    if columns.is_empty() {
+        return Err("Import file has no columns in the selected row range".to_string());
+    }
+    if total_rows == 0 {
+        return Err("Import file has no data rows in the selected row range".to_string());
+    }
+    Ok(ParsedImportFile { columns, rows, total_rows })
+}
+
+pub fn parse_xlsx_file(path: &str, preview_limit: usize) -> Result<ParsedImportFile, String> {
+    parse_xlsx_file_with_options(path, &TableImportParseOptions::default(), preview_limit)
+}
+
+fn ensure_non_streaming_file_size(path: &str, format: TableImportSourceFormat) -> Result<(), String> {
+    if format.is_delimited() {
+        return Ok(());
+    }
+    let metadata = std::fs::metadata(path).map_err(|e| e.to_string())?;
+    if metadata.len() > MAX_NON_STREAMING_IMPORT_BYTES {
+        return Err(format!(
+            "File too large for {} import: {} bytes (max {} bytes)",
+            format.label(),
+            metadata.len(),
+            MAX_NON_STREAMING_IMPORT_BYTES
+        ));
+    }
+    Ok(())
+}
+
+pub async fn parse_import_file_with_options(
+    path: &str,
+    source_format: Option<TableImportSourceFormat>,
+    options: &TableImportParseOptions,
+    preview_limit: usize,
+) -> Result<ParsedImportFile, String> {
+    let format = effective_source_format(path, source_format)?;
+    ensure_non_streaming_file_size(path, format)?;
+    match format {
+        TableImportSourceFormat::Csv | TableImportSourceFormat::Tsv | TableImportSourceFormat::Delimited => {
+            let path = path.to_string();
+            let options = options.clone();
+            tokio::task::spawn_blocking(move || {
+                parse_delimited_file_with_options(&path, format, &options, preview_limit)
+            })
+            .await
+            .map_err(|e| e.to_string())?
+        }
+        TableImportSourceFormat::Json => {
+            let bytes = tokio::fs::read(path).await.map_err(|e| e.to_string())?;
+            parse_json_bytes_with_options(&bytes, options, preview_limit)
+        }
+        TableImportSourceFormat::Excel => {
+            let path = path.to_string();
+            let options = options.clone();
+            tokio::task::spawn_blocking(move || parse_xlsx_file_with_options(&path, &options, preview_limit))
+                .await
+                .map_err(|e| e.to_string())?
+        }
+    }
+}
+
+pub async fn parse_import_file(path: &str, preview_limit: usize) -> Result<ParsedImportFile, String> {
+    parse_import_file_with_options(path, None, &TableImportParseOptions::default(), preview_limit).await
+}
+
+pub fn mapping_indexes(
+    data: &ParsedImportFile,
+    mappings: &[TableImportColumnMapping],
+) -> Result<Vec<(usize, String)>, String> {
+    mapping_indexes_for_columns(&data.columns, mappings)
+}
+
+pub fn mapping_indexes_for_columns(
+    columns: &[String],
+    mappings: &[TableImportColumnMapping],
+) -> Result<Vec<(usize, String)>, String> {
+    mapping_indexes_with_mappings(columns, mappings).map(|mapped| {
+        mapped.into_iter().map(|(source_index, mapping)| (source_index, mapping.target_column.clone())).collect()
+    })
+}
+
+fn mapping_indexes_with_mappings<'a>(
+    columns: &[String],
+    mappings: &'a [TableImportColumnMapping],
+) -> Result<Vec<(usize, &'a TableImportColumnMapping)>, String> {
+    if mappings.is_empty() {
+        return Err("No columns mapped for import".to_string());
+    }
+    let mut mapped = Vec::new();
+    let mut target_seen = HashSet::new();
+    for mapping in mappings {
+        let source_index = columns
+            .iter()
+            .position(|column| column == &mapping.source_column)
+            .ok_or_else(|| format!("Source column not found: {}", mapping.source_column))?;
+        if mapping.target_column.trim().is_empty() {
+            return Err("Target column cannot be empty".to_string());
+        }
+        if !target_seen.insert(mapping.target_column.clone()) {
+            return Err(format!("Target column mapped more than once: {}", mapping.target_column));
+        }
+        mapped.push((source_index, mapping));
+    }
+    Ok(mapped)
+}
+
+pub fn build_import_insert_batch_from_rows(
+    rows: &[Vec<serde_json::Value>],
+    columns: &[String],
+    mappings: &[TableImportColumnMapping],
+    target_column_types: &[(String, String)],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+) -> Result<Option<ImportSqlBatch>, String> {
+    if rows.is_empty() {
+        return Ok(None);
+    }
+    if *db_type == DatabaseType::CloudflareD1 {
+        return crate::db::cloudflare_d1::build_streaming_import_insert_batch(
+            rows,
+            columns,
+            mappings,
+            target_column_types,
+            table,
+            schema,
+            rows.len(),
+        );
+    }
+    let mapped = mapping_indexes_for_columns(columns, mappings)?;
+    let target_columns = mapped.iter().map(|(_, target)| target.clone()).collect::<Vec<_>>();
+    let column_types = target_columns
+        .iter()
+        .map(|column| {
+            target_column_types
+                .iter()
+                .find(|(name, _)| name.eq_ignore_ascii_case(column))
+                .map(|(_, data_type)| data_type.clone())
+        })
+        .collect::<Vec<_>>();
+    let mapped_rows = rows
+        .iter()
+        .map(|row| {
+            mapped
+                .iter()
+                .map(|(source_index, _)| row.get(*source_index).cloned().unwrap_or(serde_json::Value::Null))
+                .collect::<Vec<_>>()
+        })
+        .collect::<Vec<_>>();
+    let sql = generate_insert_typed(&target_columns, &column_types, &mapped_rows, table, schema, db_type);
+    Ok((!sql.trim().is_empty()).then_some(ImportSqlBatch { sql, row_count: rows.len() }))
+}
+
+fn supports_multi_row_insert_values(db_type: &DatabaseType) -> bool {
+    !matches!(db_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Iris)
+}
+
+pub fn build_import_insert_batches(
+    data: &ParsedImportFile,
+    mappings: &[TableImportColumnMapping],
+    target_column_types: &[(String, String)],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    batch_size: usize,
+) -> Result<Vec<ImportSqlBatch>, String> {
+    if *db_type == DatabaseType::CloudflareD1 {
+        return crate::db::cloudflare_d1::build_import_insert_batches(
+            &data.rows,
+            &data.columns,
+            mappings,
+            target_column_types,
+            table,
+            schema,
+            batch_size.clamp(1, 100),
+        );
+    }
+    let mapped = mapping_indexes(data, mappings)?;
+    let columns = mapped.iter().map(|(_, target)| target.clone()).collect::<Vec<_>>();
+    let column_types = columns
+        .iter()
+        .map(|column| {
+            target_column_types
+                .iter()
+                .find(|(name, _)| name.eq_ignore_ascii_case(column))
+                .map(|(_, data_type)| data_type.clone())
+        })
+        .collect::<Vec<_>>();
+    // Drivers without multi-row VALUES support still benefit from the agent
+    // batching the generated single-row statements during execution.
+    let batch_size = if supports_multi_row_insert_values(db_type) { batch_size.max(1) } else { 1 };
+    let mut batches = Vec::new();
+
+    for chunk in data.rows.chunks(batch_size) {
+        let rows = chunk
+            .iter()
+            .map(|row| {
+                mapped
+                    .iter()
+                    .map(|(source_index, _)| row.get(*source_index).cloned().unwrap_or(serde_json::Value::Null))
+                    .collect::<Vec<_>>()
+            })
+            .collect::<Vec<_>>();
+        let sql = generate_insert_typed(&columns, &column_types, &rows, table, schema, db_type);
+        if !sql.trim().is_empty() {
+            batches.push(ImportSqlBatch { sql, row_count: chunk.len() });
+        }
+    }
+
+    Ok(batches)
+}
+
+pub fn truncate_sql(table: &str, schema: &str, db_type: &DatabaseType) -> String {
+    let full_table = qualified_table(table, schema, db_type);
+    match db_type {
+        DatabaseType::Sqlite | DatabaseType::CloudflareD1 => format!("DELETE FROM {full_table}"),
+        _ => format!("TRUNCATE TABLE {full_table}"),
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ImportInferredType {
+    Boolean,
+    Integer,
+    Decimal,
+    Date,
+    Timestamp,
+    Json,
+    Text,
+}
+
+fn merge_inferred_type(current: Option<ImportInferredType>, next: ImportInferredType) -> ImportInferredType {
+    let Some(current) = current else {
+        return next;
+    };
+    if current == next {
+        return current;
+    }
+    match (current, next) {
+        (ImportInferredType::Text, _) | (_, ImportInferredType::Text) => ImportInferredType::Text,
+        (ImportInferredType::Integer, ImportInferredType::Decimal)
+        | (ImportInferredType::Decimal, ImportInferredType::Integer) => ImportInferredType::Decimal,
+        (ImportInferredType::Date, ImportInferredType::Timestamp)
+        | (ImportInferredType::Timestamp, ImportInferredType::Date) => ImportInferredType::Timestamp,
+        _ => ImportInferredType::Text,
+    }
+}
+
+fn has_numeric_leading_zero(value: &str) -> bool {
+    let unsigned = value.trim_start_matches(['+', '-']);
+    let bytes = unsigned.as_bytes();
+    bytes.len() > 1 && bytes[0] == b'0' && bytes[1].is_ascii_digit()
+}
+
+fn is_likely_date(value: &str) -> bool {
+    ["%Y-%m-%d", "%Y/%m/%d"].iter().any(|format| NaiveDate::parse_from_str(value, format).is_ok())
+}
+
+fn is_likely_timestamp(value: &str) -> bool {
+    if DateTime::parse_from_rfc3339(value).is_ok() {
+        return true;
+    }
+    ["%Y-%m-%d %H:%M:%S%.f", "%Y-%m-%dT%H:%M:%S%.f", "%Y/%m/%d %H:%M:%S%.f", "%Y/%m/%dT%H:%M:%S%.f"]
+        .iter()
+        .any(|format| NaiveDateTime::parse_from_str(value, format).is_ok())
+}
+
+fn infer_string_type(value: &str) -> ImportInferredType {
+    let value = value.trim();
+    if value.is_empty() {
+        return ImportInferredType::Text;
+    }
+    if is_likely_timestamp(value) {
+        return ImportInferredType::Timestamp;
+    }
+    if is_likely_date(value) {
+        return ImportInferredType::Date;
+    }
+    if !has_numeric_leading_zero(value) {
+        if value.parse::<i64>().is_ok() || value.parse::<u64>().is_ok() {
+            return ImportInferredType::Integer;
+        }
+        if (value.contains('.') || value.contains('e') || value.contains('E'))
+            && value.parse::<f64>().is_ok_and(|number| number.is_finite())
+        {
+            return ImportInferredType::Decimal;
+        }
+    }
+    ImportInferredType::Text
+}
+
+fn infer_value_type(value: &serde_json::Value) -> Option<ImportInferredType> {
+    match value {
+        serde_json::Value::Null => None,
+        serde_json::Value::Bool(_) => Some(ImportInferredType::Boolean),
+        serde_json::Value::Number(number) => {
+            if number.is_i64() || number.is_u64() {
+                Some(ImportInferredType::Integer)
+            } else {
+                Some(ImportInferredType::Decimal)
+            }
+        }
+        serde_json::Value::String(value) => Some(infer_string_type(value)),
+        serde_json::Value::Array(_) | serde_json::Value::Object(_) => Some(ImportInferredType::Json),
+    }
+}
+
+fn infer_column_type(rows: &[Vec<serde_json::Value>], source_index: usize) -> ImportInferredType {
+    let mut inferred = None;
+    for row in rows {
+        let Some(value_type) = row.get(source_index).and_then(infer_value_type) else {
+            continue;
+        };
+        inferred = Some(merge_inferred_type(inferred, value_type));
+        if inferred == Some(ImportInferredType::Text) {
+            break;
+        }
+    }
+    inferred.unwrap_or(ImportInferredType::Text)
+}
+
+fn text_data_type(db_type: &DatabaseType) -> &'static str {
+    match db_type {
+        DatabaseType::SqlServer => "NVARCHAR(MAX)",
+        DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng => "CLOB",
+        DatabaseType::ClickHouse => "String",
+        DatabaseType::Hive | DatabaseType::Trino | DatabaseType::PrestoSql | DatabaseType::Databricks => "STRING",
+        _ => "TEXT",
+    }
+}
+
+fn integer_data_type(db_type: &DatabaseType) -> &'static str {
+    match db_type {
+        DatabaseType::Sqlite | DatabaseType::Rqlite | DatabaseType::Turso | DatabaseType::CloudflareD1 => "INTEGER",
+        DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng => "NUMBER(19)",
+        DatabaseType::ClickHouse => "Int64",
+        _ => "BIGINT",
+    }
+}
+
+fn decimal_data_type(db_type: &DatabaseType) -> &'static str {
+    match db_type {
+        DatabaseType::Postgres
+        | DatabaseType::Gaussdb
+        | DatabaseType::OpenGauss
+        | DatabaseType::Redshift
+        | DatabaseType::Kingbase
+        | DatabaseType::Highgo
+        | DatabaseType::Kwdb
+        | DatabaseType::Vastbase => "DOUBLE PRECISION",
+        DatabaseType::Sqlite | DatabaseType::Rqlite | DatabaseType::Turso | DatabaseType::CloudflareD1 => "REAL",
+        DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng => "BINARY_DOUBLE",
+        DatabaseType::ClickHouse => "Float64",
+        _ => "DOUBLE",
+    }
+}
+
+fn boolean_data_type(db_type: &DatabaseType) -> &'static str {
+    match db_type {
+        DatabaseType::Mysql
+        | DatabaseType::Doris
+        | DatabaseType::StarRocks
+        | DatabaseType::Goldendb
+        | DatabaseType::Sundb
+        | DatabaseType::Databend => "TINYINT(1)",
+        DatabaseType::SqlServer => "BIT",
+        DatabaseType::Sqlite | DatabaseType::Rqlite | DatabaseType::Turso | DatabaseType::CloudflareD1 => "INTEGER",
+        DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng => "NUMBER(1)",
+        DatabaseType::ClickHouse => "UInt8",
+        _ => "BOOLEAN",
+    }
+}
+
+fn date_data_type(db_type: &DatabaseType) -> &'static str {
+    match db_type {
+        DatabaseType::Sqlite | DatabaseType::Rqlite | DatabaseType::Turso | DatabaseType::CloudflareD1 => "TEXT",
+        DatabaseType::ClickHouse => "Date",
+        _ => "DATE",
+    }
+}
+
+fn timestamp_data_type(db_type: &DatabaseType) -> &'static str {
+    match db_type {
+        DatabaseType::Mysql
+        | DatabaseType::Doris
+        | DatabaseType::StarRocks
+        | DatabaseType::Goldendb
+        | DatabaseType::Sundb
+        | DatabaseType::Databend => "DATETIME",
+        DatabaseType::SqlServer => "DATETIME2",
+        DatabaseType::Sqlite | DatabaseType::Rqlite | DatabaseType::Turso | DatabaseType::CloudflareD1 => "TEXT",
+        DatabaseType::ClickHouse => "DateTime64",
+        _ => "TIMESTAMP",
+    }
+}
+
+fn json_data_type(db_type: &DatabaseType) -> &'static str {
+    match db_type {
+        DatabaseType::Postgres
+        | DatabaseType::Gaussdb
+        | DatabaseType::OpenGauss
+        | DatabaseType::Kingbase
+        | DatabaseType::Highgo
+        | DatabaseType::Kwdb
+        | DatabaseType::Vastbase => "JSONB",
+        DatabaseType::Mysql | DatabaseType::Databend => "JSON",
+        _ => text_data_type(db_type),
+    }
+}
+
+fn import_data_type(inferred_type: ImportInferredType, db_type: &DatabaseType) -> String {
+    match inferred_type {
+        ImportInferredType::Boolean => boolean_data_type(db_type),
+        ImportInferredType::Integer => integer_data_type(db_type),
+        ImportInferredType::Decimal => decimal_data_type(db_type),
+        ImportInferredType::Date => date_data_type(db_type),
+        ImportInferredType::Timestamp => timestamp_data_type(db_type),
+        ImportInferredType::Json => json_data_type(db_type),
+        ImportInferredType::Text => text_data_type(db_type),
+    }
+    .to_string()
+}
+
+fn normalize_import_target_data_type(mapping: &TableImportColumnMapping) -> Result<Option<String>, String> {
+    let Some(raw_data_type) = mapping.target_data_type.as_deref() else {
+        return Ok(None);
+    };
+    let data_type = raw_data_type.trim();
+    if data_type.is_empty() {
+        return Err(format!("Target data type cannot be empty: {}", mapping.target_column));
+    }
+    validate_import_target_data_type(data_type)?;
+    Ok(Some(data_type.to_string()))
+}
+
+fn validate_import_target_data_type(data_type: &str) -> Result<(), String> {
+    let lowered = data_type.to_ascii_lowercase();
+    if data_type.contains(';')
+        || lowered.contains("--")
+        || lowered.contains("/*")
+        || lowered.contains("*/")
+        || data_type.chars().any(char::is_control)
+    {
+        return Err(format!("Unsupported target data type syntax: {data_type}"));
+    }
+
+    // A user-entered type is a DDL fragment, so keep it constrained to one type
+    // expression and reject separators that could add another column or clause.
+    let mut paren_depth = 0usize;
+    for ch in data_type.chars() {
+        match ch {
+            '(' => paren_depth += 1,
+            ')' => {
+                paren_depth = paren_depth
+                    .checked_sub(1)
+                    .ok_or_else(|| format!("Unsupported target data type syntax: {data_type}"))?;
+            }
+            ',' if paren_depth == 0 => {
+                return Err(format!("Unsupported target data type syntax: {data_type}"));
+            }
+            _ => {}
+        }
+    }
+    if paren_depth != 0 {
+        return Err(format!("Unsupported target data type syntax: {data_type}"));
+    }
+    Ok(())
+}
+
+pub fn build_import_create_table_plan(
+    data: &ParsedImportFile,
+    mappings: &[TableImportColumnMapping],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+) -> Result<ImportCreateTablePlan, String> {
+    if table.trim().is_empty() {
+        return Err("Target table name is required".to_string());
+    }
+    let mapped = mapping_indexes_with_mappings(&data.columns, mappings)?;
+    let mut columns = Vec::with_capacity(mapped.len());
+    for (source_index, mapping) in mapped {
+        let data_type = match normalize_import_target_data_type(mapping)? {
+            Some(data_type) => data_type,
+            None => {
+                let inferred_type = infer_column_type(&data.rows, source_index);
+                import_data_type(inferred_type, db_type)
+            }
+        };
+        columns.push(ImportCreateTableColumn { name: mapping.target_column.clone(), data_type });
+    }
+    if columns.is_empty() {
+        return Err("No columns mapped for import".to_string());
+    }
+
+    let full_table = qualified_table(table.trim(), schema, db_type);
+    let column_sql = columns
+        .iter()
+        .map(|column| format!("{} {}", quote_identifier(&column.name, db_type), column.data_type))
+        .collect::<Vec<_>>()
+        .join(",\n  ");
+    let engine_clause =
+        if matches!(db_type, DatabaseType::ClickHouse) { " ENGINE = MergeTree() ORDER BY tuple()" } else { "" };
+    Ok(ImportCreateTablePlan { sql: format!("CREATE TABLE {full_table} (\n  {column_sql}\n){engine_clause}"), columns })
+}
+
+fn import_error_message(request: &TableImportRequest, rows_imported: usize, error: impl AsRef<str>) -> String {
+    format!("Import into table '{}' failed after {} imported rows: {}", request.table, rows_imported, error.as_ref())
+}
+
+fn emit_import_error<F>(
+    progress_callback: &mut F,
+    request: &TableImportRequest,
+    rows_imported: usize,
+    total_rows: usize,
+    error: impl AsRef<str>,
+) -> String
+where
+    F: FnMut(TableImportProgress),
+{
+    let message = import_error_message(request, rows_imported, error);
+    progress_callback(TableImportProgress {
+        import_id: request.import_id.clone(),
+        status: TableImportStatus::Error,
+        rows_imported,
+        total_rows,
+        error: Some(message.clone()),
+    });
+    message
+}
+
+fn delimited_record_to_row(
+    record: &csv::StringRecord,
+    columns_len: usize,
+    config: DelimitedParseConfig,
+) -> Vec<serde_json::Value> {
+    (0..columns_len)
+        .map(|index| {
+            record.get(index).map(|value| csv_value_with_config(value, config)).unwrap_or(serde_json::Value::Null)
+        })
+        .collect()
+}
+
+fn delimited_columns_and_first_record<R: std::io::Read>(
+    reader: &mut csv::Reader<R>,
+    config: DelimitedParseConfig,
+) -> Result<(Vec<String>, Option<csv::StringRecord>), String> {
+    let mut columns = Vec::new();
+    for (index, record) in reader.records().enumerate() {
+        let record = record.map_err(|e| e.to_string())?;
+        let row_number = index + 1;
+        if config.row_range.title_row == Some(row_number) {
+            columns = record
+                .iter()
+                .enumerate()
+                .map(|(index, header)| normalize_header(header.trim_start_matches('\u{feff}'), index))
+                .collect();
+            continue;
+        }
+        if row_number < config.row_range.data_start_row {
+            continue;
+        }
+        if config.row_range.last_data_row.is_some_and(|last| row_number > last) {
+            break;
+        }
+        if columns.is_empty() {
+            columns = (0..record.len()).map(|index| format!("column_{}", index + 1)).collect();
+        }
+        if columns.is_empty() {
+            return Err("Import file has no columns".to_string());
+        }
+        return Ok((columns, Some(record)));
+    }
+    Err("Import file has no data rows in the selected row range".to_string())
+}
+
+pub async fn preview_table_import_file_with_request(
+    request: TableImportPreviewRequest,
+) -> Result<TableImportPreview, String> {
+    let format = effective_source_format(&request.file_path, request.source_format)?;
+    let parsed = parse_import_file_with_options(
+        &request.file_path,
+        Some(format),
+        &request.parse_options,
+        request.preview_limit.unwrap_or(DEFAULT_PREVIEW_LIMIT),
+    )
+    .await?;
+    let metadata = tokio::fs::metadata(&request.file_path).await.map_err(|e| e.to_string())?;
+    let file_name = Path::new(&request.file_path)
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or(&request.file_path)
+        .to_string();
+    let sheets = if matches!(format, TableImportSourceFormat::Excel) {
+        let file_path = request.file_path.clone();
+        tokio::task::spawn_blocking(move || xlsx_sheet_names(&file_path))
+            .await
+            .map_err(|e| e.to_string())?
+            .unwrap_or_default()
+    } else {
+        Vec::new()
+    };
+
+    Ok(TableImportPreview {
+        file_name,
+        file_path: request.file_path,
+        source_ref: request.source_ref,
+        file_type: format.label().to_string(),
+        size_bytes: metadata.len(),
+        columns: parsed.columns,
+        rows: parsed.rows,
+        total_rows: parsed.total_rows,
+        sheets,
+    })
+}
+
+pub async fn preview_table_import_file_core(file_path: &str) -> Result<TableImportPreview, String> {
+    preview_table_import_file_with_request(TableImportPreviewRequest {
+        file_path: file_path.to_string(),
+        source_ref: None,
+        source_format: None,
+        parse_options: TableImportParseOptions::default(),
+        preview_limit: Some(DEFAULT_PREVIEW_LIMIT),
+    })
+    .await
+}
+
+/// Core import logic. Returns (rows_imported, total_rows).
+/// `progress_callback` is invoked for progress updates.
+pub async fn import_table_file_core<F>(
+    state: &AppState,
+    request: &TableImportRequest,
+    db_type: &DatabaseType,
+    pool_key: &str,
+    is_cancelled: impl Fn(&str) -> std::pin::Pin<Box<dyn std::future::Future<Output = bool> + Send + '_>>,
+    mut progress_callback: F,
+) -> Result<TableImportSummary, String>
+where
+    F: FnMut(TableImportProgress),
+{
+    let batch_size = if request.batch_size == 0 { DEFAULT_BATCH_SIZE } else { request.batch_size };
+    let source_format = match effective_source_format(&request.file_path, request.source_format) {
+        Ok(format) => format,
+        Err(error) => {
+            return Err(emit_import_error(&mut progress_callback, request, 0, 0, error));
+        }
+    };
+
+    if let Err(error) = tokio::fs::metadata(&request.file_path).await {
+        return Err(emit_import_error(
+            &mut progress_callback,
+            request,
+            0,
+            0,
+            format!("Import source is no longer available: {error}"),
+        ));
+    }
+
+    let mut create_table_sample: Option<ParsedImportFile> = None;
+    let mut created_column_types: Option<Vec<(String, String)>> = None;
+    if request.create_table {
+        if matches!(request.mode, TableImportMode::Truncate) {
+            return Err(emit_import_error(
+                &mut progress_callback,
+                request,
+                0,
+                0,
+                "Cannot truncate a table that is being created by the import",
+            ));
+        }
+        let parsed = match parse_import_file_with_options(
+            &request.file_path,
+            Some(source_format),
+            &request.parse_options,
+            CREATE_TABLE_INFERENCE_ROWS,
+        )
+        .await
+        {
+            Ok(parsed) => parsed,
+            Err(error) => {
+                return Err(emit_import_error(&mut progress_callback, request, 0, 0, error));
+            }
+        };
+        let total_rows = parsed.total_rows;
+        let plan = match build_import_create_table_plan(
+            &parsed,
+            &request.mappings,
+            &request.table,
+            &request.schema,
+            db_type,
+        ) {
+            Ok(plan) => plan,
+            Err(error) => {
+                return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+            }
+        };
+        // The table must be created before streaming rows so existing import batching
+        // can reuse the same INSERT path and database-specific value escaping.
+        if let Err(error) = execute_on_pool(state, pool_key, &plan.sql).await {
+            return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+        }
+        created_column_types =
+            Some(plan.columns.iter().map(|column| (column.name.clone(), column.data_type.clone())).collect());
+        create_table_sample = Some(parsed);
+    }
+
+    if source_format.is_delimited() {
+        let parsed = if let Some(parsed) = create_table_sample.clone() {
+            parsed
+        } else {
+            match parse_import_file_with_options(&request.file_path, Some(source_format), &request.parse_options, 0)
+                .await
+            {
+                Ok(parsed) => parsed,
+                Err(error) => {
+                    return Err(emit_import_error(&mut progress_callback, request, 0, 0, error));
+                }
+            }
+        };
+        let total_rows = parsed.total_rows;
+        if let Err(error) = mapping_indexes_for_columns(&parsed.columns, &request.mappings) {
+            return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+        }
+
+        progress_callback(TableImportProgress {
+            import_id: request.import_id.clone(),
+            status: TableImportStatus::Running,
+            rows_imported: 0,
+            total_rows,
+            error: None,
+        });
+
+        let mut target_column_types = get_columns_for_transfer(
+            state,
+            pool_key,
+            &request.connection_id,
+            &request.database,
+            &request.schema,
+            &request.table,
+        )
+        .await
+        .unwrap_or_default()
+        .into_iter()
+        .map(|column| (column.name, column.data_type))
+        .collect::<Vec<_>>();
+        if target_column_types.is_empty() {
+            target_column_types = created_column_types.clone().unwrap_or_default();
+        }
+
+        if matches!(request.mode, TableImportMode::Truncate) {
+            let sql = truncate_sql(&request.table, &request.schema, db_type);
+            if let Err(error) = execute_on_pool(state, pool_key, &sql).await {
+                return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+            }
+        }
+
+        let config = match effective_delimited_config(source_format, &request.parse_options) {
+            Ok(config) => config,
+            Err(error) => return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error)),
+        };
+        let file = match File::open(&request.file_path) {
+            Ok(file) => file,
+            Err(error) => {
+                return Err(emit_import_error(
+                    &mut progress_callback,
+                    request,
+                    0,
+                    total_rows,
+                    format!("Import source is no longer available: {error}"),
+                ));
+            }
+        };
+        let mut reader =
+            csv::ReaderBuilder::new().delimiter(config.delimiter).has_headers(false).flexible(true).from_reader(file);
+        let (columns, first_record) = match delimited_columns_and_first_record(&mut reader, config) {
+            Ok(result) => result,
+            Err(error) => return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error)),
+        };
+        let effective_batch_size = match db_type {
+            DatabaseType::Oracle | DatabaseType::OceanbaseOracle => 1,
+            DatabaseType::CloudflareD1 => batch_size.clamp(1, 100),
+            _ => batch_size.max(1),
+        };
+        let mut rows_imported = 0;
+        let mut pending_rows: Vec<Vec<serde_json::Value>> = Vec::with_capacity(effective_batch_size);
+
+        if let Some(record) = first_record {
+            pending_rows.push(delimited_record_to_row(&record, columns.len(), config));
+        }
+
+        let mut source_row_number = config.row_range.data_start_row;
+        for record in reader.records() {
+            source_row_number += 1;
+            if config.row_range.last_data_row.is_some_and(|last| source_row_number > last) {
+                break;
+            }
+            if is_cancelled(&request.import_id).await {
+                progress_callback(TableImportProgress {
+                    import_id: request.import_id.clone(),
+                    status: TableImportStatus::Cancelled,
+                    rows_imported,
+                    total_rows,
+                    error: None,
+                });
+                return Err("Import cancelled".to_string());
+            }
+
+            let record = match record {
+                Ok(record) => record,
+                Err(error) => {
+                    return Err(emit_import_error(
+                        &mut progress_callback,
+                        request,
+                        rows_imported,
+                        total_rows,
+                        error.to_string(),
+                    ))
+                }
+            };
+            pending_rows.push(delimited_record_to_row(&record, columns.len(), config));
+
+            if pending_rows.len() >= effective_batch_size {
+                let batch = match build_import_insert_batch_from_rows(
+                    &pending_rows,
+                    &columns,
+                    &request.mappings,
+                    &target_column_types,
+                    &request.table,
+                    &request.schema,
+                    db_type,
+                ) {
+                    Ok(Some(batch)) => batch,
+                    Ok(None) => {
+                        pending_rows.clear();
+                        continue;
+                    }
+                    Err(error) => {
+                        return Err(emit_import_error(
+                            &mut progress_callback,
+                            request,
+                            rows_imported,
+                            total_rows,
+                            error,
+                        ))
+                    }
+                };
+                if let Err(error) = execute_on_pool(state, pool_key, &batch.sql).await {
+                    return Err(emit_import_error(&mut progress_callback, request, rows_imported, total_rows, error));
+                }
+                rows_imported = (rows_imported + batch.row_count).min(total_rows);
+                pending_rows.clear();
+                progress_callback(TableImportProgress {
+                    import_id: request.import_id.clone(),
+                    status: TableImportStatus::Running,
+                    rows_imported,
+                    total_rows,
+                    error: None,
+                });
+            }
+        }
+
+        if !pending_rows.is_empty() {
+            if is_cancelled(&request.import_id).await {
+                progress_callback(TableImportProgress {
+                    import_id: request.import_id.clone(),
+                    status: TableImportStatus::Cancelled,
+                    rows_imported,
+                    total_rows,
+                    error: None,
+                });
+                return Err("Import cancelled".to_string());
+            }
+            let batch = match build_import_insert_batch_from_rows(
+                &pending_rows,
+                &columns,
+                &request.mappings,
+                &target_column_types,
+                &request.table,
+                &request.schema,
+                db_type,
+            ) {
+                Ok(Some(batch)) => batch,
+                Ok(None) => ImportSqlBatch { sql: String::new(), row_count: 0 },
+                Err(error) => {
+                    return Err(emit_import_error(&mut progress_callback, request, rows_imported, total_rows, error))
+                }
+            };
+            if !batch.sql.is_empty() {
+                if let Err(error) = execute_on_pool(state, pool_key, &batch.sql).await {
+                    return Err(emit_import_error(&mut progress_callback, request, rows_imported, total_rows, error));
+                }
+                rows_imported = (rows_imported + batch.row_count).min(total_rows);
+            }
+        }
+
+        progress_callback(TableImportProgress {
+            import_id: request.import_id.clone(),
+            status: TableImportStatus::Done,
+            rows_imported,
+            total_rows,
+            error: None,
+        });
+
+        return Ok(TableImportSummary { import_id: request.import_id.clone(), rows_imported, total_rows });
+    }
+
+    let parsed = match parse_import_file_with_options(
+        &request.file_path,
+        Some(source_format),
+        &request.parse_options,
+        usize::MAX,
+    )
+    .await
+    {
+        Ok(parsed) => parsed,
+        Err(error) => {
+            return Err(emit_import_error(&mut progress_callback, request, 0, 0, error));
+        }
+    };
+
+    let total_rows = parsed.total_rows;
+    if let Err(error) = mapping_indexes(&parsed, &request.mappings) {
+        return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+    }
+    progress_callback(TableImportProgress {
+        import_id: request.import_id.clone(),
+        status: TableImportStatus::Running,
+        rows_imported: 0,
+        total_rows,
+        error: None,
+    });
+
+    let mut target_column_types = get_columns_for_transfer(
+        state,
+        pool_key,
+        &request.connection_id,
+        &request.database,
+        &request.schema,
+        &request.table,
+    )
+    .await
+    .unwrap_or_default()
+    .into_iter()
+    .map(|column| (column.name, column.data_type))
+    .collect::<Vec<_>>();
+    if target_column_types.is_empty() {
+        target_column_types = created_column_types.clone().unwrap_or_default();
+    }
+
+    let batches = match build_import_insert_batches(
+        &parsed,
+        &request.mappings,
+        &target_column_types,
+        &request.table,
+        &request.schema,
+        db_type,
+        batch_size,
+    ) {
+        Ok(batches) => batches,
+        Err(error) => {
+            return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+        }
+    };
+
+    if matches!(request.mode, TableImportMode::Truncate) {
+        let sql = truncate_sql(&request.table, &request.schema, db_type);
+        if let Err(error) = execute_on_pool(state, pool_key, &sql).await {
+            return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+        }
+    }
+
+    let mut rows_imported = 0;
+    for batch in batches {
+        if is_cancelled(&request.import_id).await {
+            progress_callback(TableImportProgress {
+                import_id: request.import_id.clone(),
+                status: TableImportStatus::Cancelled,
+                rows_imported,
+                total_rows,
+                error: None,
+            });
+            return Err("Import cancelled".to_string());
+        }
+
+        if let Err(error) = execute_on_pool(state, pool_key, &batch.sql).await {
+            return Err(emit_import_error(&mut progress_callback, request, rows_imported, total_rows, error));
+        }
+        rows_imported = (rows_imported + batch.row_count).min(total_rows);
+        progress_callback(TableImportProgress {
+            import_id: request.import_id.clone(),
+            status: TableImportStatus::Running,
+            rows_imported,
+            total_rows,
+            error: None,
+        });
+    }
+
+    progress_callback(TableImportProgress {
+        import_id: request.import_id.clone(),
+        status: TableImportStatus::Done,
+        rows_imported,
+        total_rows,
+        error: None,
+    });
+
+    Ok(TableImportSummary { import_id: request.import_id.clone(), rows_imported, total_rows })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::models::connection::DatabaseType;
+    use crate::xlsx_export::{build_xlsx_workbook_multi, XlsxWorksheetData};
+
+    #[test]
+    fn parses_csv_headers_and_preview_rows() {
+        let parsed = parse_csv_bytes(b"id,name,active\n1,Ada,true\n2,,false\n", 10).unwrap();
+
+        assert_eq!(parsed.columns, vec!["id", "name", "active"]);
+        assert_eq!(parsed.total_rows, 2);
+        assert_eq!(
+            parsed.rows[0],
+            vec![
+                serde_json::Value::String("1".to_string()),
+                serde_json::Value::String("Ada".to_string()),
+                serde_json::Value::String("true".to_string()),
+            ]
+        );
+        assert_eq!(
+            parsed.rows[1],
+            vec![
+                serde_json::Value::String("2".to_string()),
+                serde_json::Value::Null,
+                serde_json::Value::String("false".to_string()),
+            ]
+        );
+    }
+
+    #[test]
+    fn parses_tsv_with_tab_delimiter() {
+        let parsed = parse_delimited_bytes(b"id\tname\n1\tAda\n", b'\t', 10).unwrap();
+
+        assert_eq!(parsed.columns, vec!["id", "name"]);
+        assert_eq!(parsed.total_rows, 1);
+        assert_eq!(
+            parsed.rows[0],
+            vec![serde_json::Value::String("1".to_string()), serde_json::Value::String("Ada".to_string()),]
+        );
+    }
+
+    #[test]
+    fn parses_delimited_text_without_header_and_trims_values() {
+        let options = TableImportParseOptions {
+            delimiter: Some("|".to_string()),
+            has_header: Some(false),
+            trim_values: Some(true),
+            empty_string_as_null: Some(true),
+            ..TableImportParseOptions::default()
+        };
+        let parsed = parse_delimited_bytes_with_options(
+            b" 1 | Ada \n 2 |   \n",
+            TableImportSourceFormat::Delimited,
+            &options,
+            10,
+        )
+        .unwrap();
+
+        assert_eq!(parsed.columns, vec!["column_1", "column_2"]);
+        assert_eq!(parsed.total_rows, 2);
+        assert_eq!(parsed.rows[0], vec![serde_json::json!("1"), serde_json::json!("Ada")]);
+        assert_eq!(parsed.rows[1], vec![serde_json::json!("2"), serde_json::Value::Null]);
+    }
+
+    #[test]
+    fn parses_delimited_text_with_custom_title_and_data_rows() {
+        let options = TableImportParseOptions {
+            title_row: Some(2),
+            data_start_row: Some(4),
+            last_data_row: Some(5),
+            ..TableImportParseOptions::default()
+        };
+        let parsed = parse_delimited_bytes_with_options(
+            b"report,ignored\nid,name\nnotes,ignored\n1,Ada\n2,Grace\nsummary,2\n",
+            TableImportSourceFormat::Csv,
+            &options,
+            10,
+        )
+        .unwrap();
+
+        assert_eq!(parsed.columns, vec!["id", "name"]);
+        assert_eq!(parsed.total_rows, 2);
+        assert_eq!(parsed.rows[0], vec![serde_json::json!("1"), serde_json::json!("Ada")]);
+        assert_eq!(parsed.rows[1], vec![serde_json::json!("2"), serde_json::json!("Grace")]);
+    }
+
+    #[test]
+    fn rejects_title_row_inside_data_range() {
+        let options = TableImportParseOptions {
+            title_row: Some(2),
+            data_start_row: Some(1),
+            last_data_row: Some(3),
+            ..TableImportParseOptions::default()
+        };
+
+        assert!(effective_import_row_range(&options).unwrap_err().contains("before the data start row"));
+    }
+
+    #[test]
+    fn parses_json_array_objects_with_union_columns() {
+        let parsed = parse_json_bytes(br#"[{"id":1,"name":"Ada"},{"id":2,"active":true}]"#, 10).unwrap();
+
+        assert_eq!(parsed.columns, vec!["id", "name", "active"]);
+        assert_eq!(parsed.total_rows, 2);
+        assert_eq!(parsed.rows[0], vec![serde_json::json!(1), serde_json::json!("Ada"), serde_json::Value::Null,]);
+        assert_eq!(parsed.rows[1], vec![serde_json::json!(2), serde_json::Value::Null, serde_json::json!(true),]);
+    }
+
+    #[test]
+    fn parses_json_with_utf8_bom() {
+        let parsed = parse_json_bytes(b"\xEF\xBB\xBF[{\"id\":1,\"name\":\"Ada\"}]", 10).unwrap();
+
+        assert_eq!(parsed.columns, vec!["id", "name"]);
+        assert_eq!(parsed.total_rows, 1);
+        assert_eq!(parsed.rows[0], vec![serde_json::json!(1), serde_json::json!("Ada")]);
+    }
+
+    #[test]
+    fn json_shape_option_rejects_wrong_row_shape() {
+        let options = TableImportParseOptions {
+            json_shape: Some(TableImportJsonShape::Objects),
+            ..TableImportParseOptions::default()
+        };
+        let error = parse_json_bytes_with_options(br#"[["id","name"],[1,"Ada"]]"#, &options, 10).unwrap_err();
+
+        assert!(error.contains("configured for object rows"));
+    }
+
+    #[test]
+    fn parses_selected_excel_sheet() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-{}.xlsx", uuid::Uuid::new_v4()));
+        let workbook = build_xlsx_workbook_multi(&[
+            XlsxWorksheetData {
+                sheet_name: Some("First".to_string()),
+                columns: vec!["id".to_string()],
+                column_types: vec![],
+                rows: vec![vec![serde_json::json!(1)]],
+            },
+            XlsxWorksheetData {
+                sheet_name: Some("Second".to_string()),
+                columns: vec!["name".to_string()],
+                column_types: vec![],
+                rows: vec![vec![serde_json::json!("Ada")]],
+            },
+        ])
+        .unwrap();
+        std::fs::write(&path, workbook).unwrap();
+
+        let options =
+            TableImportParseOptions { sheet_name: Some("Second".to_string()), ..TableImportParseOptions::default() };
+        let parsed = parse_xlsx_file_with_options(&path.to_string_lossy(), &options, 10).unwrap();
+
+        assert_eq!(xlsx_sheet_names(&path.to_string_lossy()).unwrap(), vec!["First", "Second"]);
+        assert_eq!(parsed.columns, vec!["name"]);
+        assert_eq!(parsed.rows, vec![vec![serde_json::json!("Ada")]]);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn parses_excel_with_custom_title_and_data_rows() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-rows-{}.xlsx", uuid::Uuid::new_v4()));
+        let workbook = build_xlsx_workbook_multi(&[XlsxWorksheetData {
+            sheet_name: Some("Rows".to_string()),
+            columns: vec!["report".to_string(), "ignored".to_string()],
+            column_types: vec![],
+            rows: vec![
+                vec![serde_json::json!("id"), serde_json::json!("name")],
+                vec![serde_json::json!(1), serde_json::json!("Ada")],
+                vec![serde_json::json!(2), serde_json::json!("Grace")],
+                vec![serde_json::json!("summary"), serde_json::json!(2)],
+            ],
+        }])
+        .unwrap();
+        std::fs::write(&path, workbook).unwrap();
+        let options = TableImportParseOptions {
+            title_row: Some(2),
+            data_start_row: Some(3),
+            last_data_row: Some(4),
+            ..TableImportParseOptions::default()
+        };
+        let parsed = parse_xlsx_file_with_options(&path.to_string_lossy(), &options, 10).unwrap();
+
+        assert_eq!(parsed.columns, vec!["id", "name"]);
+        assert_eq!(parsed.total_rows, 2);
+        assert_eq!(parsed.rows[0], vec![serde_json::json!(1.0), serde_json::json!("Ada")]);
+        assert_eq!(parsed.rows[1], vec![serde_json::json!(2.0), serde_json::json!("Grace")]);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn builds_create_table_plan_from_import_sample() {
+        let data = ParsedImportFile {
+            columns: vec![
+                "id".to_string(),
+                "code".to_string(),
+                "amount".to_string(),
+                "created_at".to_string(),
+                "active".to_string(),
+                "payload".to_string(),
+            ],
+            rows: vec![
+                vec![
+                    serde_json::json!("1"),
+                    serde_json::json!("00123"),
+                    serde_json::json!("12.5"),
+                    serde_json::json!("2026-07-06 12:30:45"),
+                    serde_json::json!("true"),
+                    serde_json::json!({ "source": "csv" }),
+                ],
+                vec![
+                    serde_json::json!("2"),
+                    serde_json::json!("00456"),
+                    serde_json::json!("13.75"),
+                    serde_json::json!("2026-07-07 08:15:00"),
+                    serde_json::json!("false"),
+                    serde_json::json!({ "source": "json" }),
+                ],
+            ],
+            total_rows: 2,
+        };
+        let mappings = data
+            .columns
+            .iter()
+            .map(|column| TableImportColumnMapping {
+                source_column: column.clone(),
+                target_column: column.clone(),
+                target_data_type: None,
+            })
+            .collect::<Vec<_>>();
+
+        let plan =
+            build_import_create_table_plan(&data, &mappings, "orders", "public", &DatabaseType::Postgres).unwrap();
+
+        assert_eq!(
+            plan.sql,
+            "CREATE TABLE \"public\".\"orders\" (\n  \"id\" BIGINT,\n  \"code\" TEXT,\n  \"amount\" DOUBLE PRECISION,\n  \"created_at\" TIMESTAMP,\n  \"active\" TEXT,\n  \"payload\" JSONB\n)"
+        );
+        assert_eq!(
+            plan.columns,
+            vec![
+                ImportCreateTableColumn { name: "id".to_string(), data_type: "BIGINT".to_string() },
+                ImportCreateTableColumn { name: "code".to_string(), data_type: "TEXT".to_string() },
+                ImportCreateTableColumn { name: "amount".to_string(), data_type: "DOUBLE PRECISION".to_string() },
+                ImportCreateTableColumn { name: "created_at".to_string(), data_type: "TIMESTAMP".to_string() },
+                ImportCreateTableColumn { name: "active".to_string(), data_type: "TEXT".to_string() },
+                ImportCreateTableColumn { name: "payload".to_string(), data_type: "JSONB".to_string() },
+            ]
+        );
+    }
+
+    #[test]
+    fn create_table_plan_requires_target_table_name() {
+        let data =
+            ParsedImportFile { columns: vec!["id".to_string()], rows: vec![vec![serde_json::json!(1)]], total_rows: 1 };
+        let mappings = vec![TableImportColumnMapping {
+            source_column: "id".to_string(),
+            target_column: "id".to_string(),
+            target_data_type: None,
+        }];
+
+        let error = build_import_create_table_plan(&data, &mappings, " ", "", &DatabaseType::Mysql).unwrap_err();
+
+        assert_eq!(error, "Target table name is required");
+    }
+
+    #[test]
+    fn create_table_plan_uses_database_specific_text_type() {
+        let data = ParsedImportFile {
+            columns: vec!["notes".to_string()],
+            rows: vec![vec![serde_json::json!("long text")]],
+            total_rows: 1,
+        };
+        let mappings = vec![TableImportColumnMapping {
+            source_column: "notes".to_string(),
+            target_column: "notes".to_string(),
+            target_data_type: None,
+        }];
+
+        let plan = build_import_create_table_plan(&data, &mappings, "events", "dbo", &DatabaseType::SqlServer).unwrap();
+
+        assert_eq!(plan.sql, "CREATE TABLE [dbo].[events] (\n  [notes] NVARCHAR(MAX)\n)");
+    }
+
+    #[test]
+    fn create_table_plan_uses_user_defined_column_type() {
+        let data = ParsedImportFile {
+            columns: vec!["code".to_string(), "amount".to_string()],
+            rows: vec![vec![serde_json::json!("1001"), serde_json::json!("12.5")]],
+            total_rows: 1,
+        };
+        let mappings = vec![
+            TableImportColumnMapping {
+                source_column: "code".to_string(),
+                target_column: "code".to_string(),
+                target_data_type: Some("VARCHAR(32)".to_string()),
+            },
+            TableImportColumnMapping {
+                source_column: "amount".to_string(),
+                target_column: "amount".to_string(),
+                target_data_type: Some("DECIMAL(10,2)".to_string()),
+            },
+        ];
+
+        let plan = build_import_create_table_plan(&data, &mappings, "invoice", "", &DatabaseType::Mysql).unwrap();
+
+        assert_eq!(plan.sql, "CREATE TABLE `invoice` (\n  `code` VARCHAR(32),\n  `amount` DECIMAL(10,2)\n)");
+        assert_eq!(
+            plan.columns,
+            vec![
+                ImportCreateTableColumn { name: "code".to_string(), data_type: "VARCHAR(32)".to_string() },
+                ImportCreateTableColumn { name: "amount".to_string(), data_type: "DECIMAL(10,2)".to_string() },
+            ]
+        );
+    }
+
+    #[test]
+    fn create_table_plan_rejects_unsafe_user_defined_column_type() {
+        let data = ParsedImportFile {
+            columns: vec!["name".to_string()],
+            rows: vec![vec![serde_json::json!("Ada")]],
+            total_rows: 1,
+        };
+        let mappings = vec![TableImportColumnMapping {
+            source_column: "name".to_string(),
+            target_column: "name".to_string(),
+            target_data_type: Some("TEXT, injected INT".to_string()),
+        }];
+
+        let error = build_import_create_table_plan(&data, &mappings, "users", "", &DatabaseType::Mysql).unwrap_err();
+
+        assert!(error.contains("Unsupported target data type syntax"));
+    }
+
+    #[test]
+    fn builds_import_insert_batches_from_mapped_columns() {
+        let mappings = vec![
+            TableImportColumnMapping {
+                source_column: "id".to_string(),
+                target_column: "user_id".to_string(),
+                target_data_type: None,
+            },
+            TableImportColumnMapping {
+                source_column: "name".to_string(),
+                target_column: "display_name".to_string(),
+                target_data_type: None,
+            },
+        ];
+        let data = ParsedImportFile {
+            columns: vec!["id".to_string(), "name".to_string(), "ignored".to_string()],
+            rows: vec![
+                vec![serde_json::json!(1), serde_json::json!("Ada"), serde_json::json!("x")],
+                vec![serde_json::json!(2), serde_json::json!("O'Hara"), serde_json::json!("y")],
+                vec![serde_json::json!(3), serde_json::Value::Null, serde_json::json!("z")],
+            ],
+            total_rows: 3,
+        };
+
+        let batches =
+            build_import_insert_batches(&data, &mappings, &[], "users", "public", &DatabaseType::Postgres, 2).unwrap();
+
+        assert_eq!(batches, vec![
+            ImportSqlBatch {
+                sql: "INSERT INTO \"public\".\"users\" (\"user_id\", \"display_name\") VALUES\n(1, 'Ada'),\n(2, 'O''Hara')".to_string(),
+                row_count: 2,
+            },
+            ImportSqlBatch {
+                sql: "INSERT INTO \"public\".\"users\" (\"user_id\", \"display_name\") VALUES\n(3, NULL)".to_string(),
+                row_count: 1,
+            },
+        ]);
+    }
+
+    #[test]
+    fn iris_import_uses_single_row_values_statements() {
+        let mappings = vec![TableImportColumnMapping {
+            source_column: "id".to_string(),
+            target_column: "id".to_string(),
+            target_data_type: None,
+        }];
+        let data = ParsedImportFile {
+            columns: vec!["id".to_string()],
+            rows: vec![vec![serde_json::json!(1)], vec![serde_json::json!(2)]],
+            total_rows: 2,
+        };
+
+        let batches =
+            build_import_insert_batches(&data, &mappings, &[], "items", "SQLUSER", &DatabaseType::Iris, 100).unwrap();
+
+        assert_eq!(batches.len(), 2);
+        assert_eq!(batches[0].sql, "INSERT INTO \"SQLUSER\".\"items\" (\"id\") VALUES\n(1)");
+        assert_eq!(batches[0].row_count, 1);
+        assert_eq!(batches[1].sql, "INSERT INTO \"SQLUSER\".\"items\" (\"id\") VALUES\n(2)");
+        assert_eq!(batches[1].row_count, 1);
+    }
+
+    #[test]
+    fn multi_row_insert_values_support_matches_database_dialects() {
+        assert!(!supports_multi_row_insert_values(&DatabaseType::Oracle));
+        assert!(!supports_multi_row_insert_values(&DatabaseType::OceanbaseOracle));
+        assert!(!supports_multi_row_insert_values(&DatabaseType::Iris));
+        assert!(supports_multi_row_insert_values(&DatabaseType::Postgres));
+        assert!(supports_multi_row_insert_values(&DatabaseType::Mysql));
+    }
+
+    #[test]
+    fn duplicate_mapping_is_rejected_before_sql_generation() {
+        let columns = vec!["id".to_string(), "name".to_string()];
+        let mappings = vec![
+            TableImportColumnMapping {
+                source_column: "id".to_string(),
+                target_column: "target".to_string(),
+                target_data_type: None,
+            },
+            TableImportColumnMapping {
+                source_column: "name".to_string(),
+                target_column: "target".to_string(),
+                target_data_type: None,
+            },
+        ];
+
+        let error = mapping_indexes_for_columns(&columns, &mappings).unwrap_err();
+
+        assert!(error.contains("mapped more than once"));
+    }
+
+    #[test]
+    fn builds_single_streaming_import_batch_from_rows() {
+        let columns = vec!["id".to_string(), "name".to_string()];
+        let mappings = vec![
+            TableImportColumnMapping {
+                source_column: "id".to_string(),
+                target_column: "id".to_string(),
+                target_data_type: None,
+            },
+            TableImportColumnMapping {
+                source_column: "name".to_string(),
+                target_column: "name".to_string(),
+                target_data_type: None,
+            },
+        ];
+        let rows = vec![vec![serde_json::json!(1), serde_json::json!("Ada")]];
+
+        let batch = build_import_insert_batch_from_rows(
+            &rows,
+            &columns,
+            &mappings,
+            &[],
+            "users",
+            "public",
+            &DatabaseType::Postgres,
+        )
+        .unwrap()
+        .unwrap();
+
+        assert_eq!(batch.sql, "INSERT INTO \"public\".\"users\" (\"id\", \"name\") VALUES\n(1, 'Ada')");
+        assert_eq!(batch.row_count, 1);
+    }
+
+    #[tokio::test]
+    async fn preview_missing_source_fails_before_parsing() {
+        let path = std::env::temp_dir().join(format!("dbx-missing-import-{}.csv", uuid::Uuid::new_v4()));
+        let error = preview_table_import_file_with_request(TableImportPreviewRequest {
+            file_path: path.to_string_lossy().to_string(),
+            source_ref: Some("missing".to_string()),
+            source_format: Some(TableImportSourceFormat::Csv),
+            parse_options: TableImportParseOptions::default(),
+            preview_limit: Some(10),
+        })
+        .await
+        .unwrap_err();
+
+        assert!(error.contains("No such file") || error.contains("os error"));
+    }
+
+    #[test]
+    fn oracle_import_insert_batches_use_single_row_statements() {
+        let mappings = vec![
+            TableImportColumnMapping {
+                source_column: "id".to_string(),
+                target_column: "id".to_string(),
+                target_data_type: None,
+            },
+            TableImportColumnMapping {
+                source_column: "name".to_string(),
+                target_column: "name".to_string(),
+                target_data_type: None,
+            },
+        ];
+        let data = ParsedImportFile {
+            columns: vec!["id".to_string(), "name".to_string()],
+            rows: vec![
+                vec![serde_json::json!(1), serde_json::json!("Ada")],
+                vec![serde_json::json!(2), serde_json::json!("Grace")],
+                vec![serde_json::json!(3), serde_json::Value::Null],
+            ],
+            total_rows: 3,
+        };
+
+        let batches =
+            build_import_insert_batches(&data, &mappings, &[], "users", "HR", &DatabaseType::Oracle, 500).unwrap();
+
+        assert_eq!(
+            batches,
+            vec![
+                ImportSqlBatch {
+                    sql: "INSERT INTO \"HR\".\"users\" (\"id\", \"name\") VALUES\n(1, 'Ada')".to_string(),
+                    row_count: 1,
+                },
+                ImportSqlBatch {
+                    sql: "INSERT INTO \"HR\".\"users\" (\"id\", \"name\") VALUES\n(2, 'Grace')".to_string(),
+                    row_count: 1,
+                },
+                ImportSqlBatch {
+                    sql: "INSERT INTO \"HR\".\"users\" (\"id\", \"name\") VALUES\n(3, NULL)".to_string(),
+                    row_count: 1,
+                },
+            ]
+        );
+    }
+
+    #[test]
+    fn import_insert_batches_use_target_column_types_for_mysql_temporal_values() {
+        let mappings = vec![
+            TableImportColumnMapping {
+                source_column: "start".to_string(),
+                target_column: "insurance_start_time".to_string(),
+                target_data_type: None,
+            },
+            TableImportColumnMapping {
+                source_column: "raw".to_string(),
+                target_column: "raw_text".to_string(),
+                target_data_type: None,
+            },
+        ];
+        let data = ParsedImportFile {
+            columns: vec!["start".to_string(), "raw".to_string()],
+            rows: vec![vec![
+                serde_json::json!("2026-05-12T00:00:00+00:00"),
+                serde_json::json!("2026-05-12T00:00:00+00:00"),
+            ]],
+            total_rows: 1,
+        };
+
+        let batches = build_import_insert_batches(
+            &data,
+            &mappings,
+            &[
+                ("insurance_start_time".to_string(), "datetime".to_string()),
+                ("raw_text".to_string(), "varchar(64)".to_string()),
+            ],
+            "policies",
+            "",
+            &DatabaseType::Mysql,
+            500,
+        )
+        .unwrap();
+
+        assert_eq!(batches, vec![ImportSqlBatch {
+            sql: "INSERT INTO `policies` (`insurance_start_time`, `raw_text`) VALUES\n('2026-05-12 00:00:00', '2026-05-12T00:00:00+00:00')".to_string(),
+            row_count: 1,
+        }]);
+    }
+
+    #[test]
+    fn import_insert_batches_preserve_sqlserver_unicode_text() {
+        let mappings = vec![TableImportColumnMapping {
+            source_column: "name".to_string(),
+            target_column: "name".to_string(),
+            target_data_type: None,
+        }];
+        let data = ParsedImportFile {
+            columns: vec!["name".to_string()],
+            rows: vec![vec![serde_json::json!("Tiếng Việt")]],
+            total_rows: 1,
+        };
+
+        let batches = build_import_insert_batches(
+            &data,
+            &mappings,
+            &[("name".to_string(), "nvarchar(100)".to_string())],
+            "customers",
+            "dbo",
+            &DatabaseType::SqlServer,
+            500,
+        )
+        .unwrap();
+
+        assert_eq!(
+            batches,
+            vec![ImportSqlBatch {
+                sql: "INSERT INTO [dbo].[customers] ([name]) VALUES\n(N'Tiếng Việt')".to_string(),
+                row_count: 1,
+            }]
+        );
+    }
+}
diff --git a/crates/dbx-core/src/table_structure_sql.rs b/crates/dbx-core/src/table_structure_sql.rs
new file mode 100644
index 0000000..661bc2b
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql.rs
@@ -0,0 +1,38 @@
+mod column_alter;
+mod column_format;
+mod columns;
+mod comments;
+mod create_table;
+mod dialect;
+mod foreign_keys;
+mod indexes;
+mod sqlite_rebuild;
+mod triggers;
+mod types;
+mod util;
+mod validation;
+
+#[cfg(test)]
+mod tests;
+
+pub use column_alter::build_single_column_alter_sql;
+pub use create_table::build_create_table_sql;
+pub use sqlite_rebuild::{apply_sqlite_table_structure_change, preview_sqlite_table_structure_change};
+pub use types::*;
+
+use columns::build_column_sql;
+use comments::build_table_comment_sql;
+use foreign_keys::build_foreign_key_sql;
+use indexes::build_index_sql;
+use triggers::build_trigger_sql;
+use validation::validate_draft;
+
+pub fn build_table_structure_change_sql(options: TableStructureSqlOptions) -> TableStructureSqlResult {
+    let mut warnings = validate_draft(&options);
+    let mut statements = build_column_sql(&options, &mut warnings);
+    statements.extend(build_index_sql(&options, &mut warnings));
+    statements.extend(build_foreign_key_sql(&options, &mut warnings));
+    statements.extend(build_trigger_sql(&options, &mut warnings));
+    statements.extend(build_table_comment_sql(&options, &mut warnings));
+    TableStructureSqlResult { statements, warnings }
+}
diff --git a/crates/dbx-core/src/table_structure_sql/column_alter.rs b/crates/dbx-core/src/table_structure_sql/column_alter.rs
new file mode 100644
index 0000000..09d6958
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/column_alter.rs
@@ -0,0 +1,736 @@
+use super::column_format::{clickhouse_column_type, column_data_type, column_definition, is_mysql_character_data_type};
+use super::columns::build_drop_column_sql;
+use super::comments::build_sqlserver_column_comment_sql;
+use super::dialect::{capabilities_for, database_label, StructureDialect};
+use super::types::{EditableStructureColumn, SingleColumnAlterSqlOptions, TableStructureSqlResult};
+use super::util::{
+    clean, format_default_for_sql, is_protected_manticore_id_column, normalize_default, original_comment,
+    original_default, qualified_table, quote_ident, quote_string,
+};
+use crate::table_structure_sql::ColumnExtra;
+
+pub fn build_single_column_alter_sql(options: SingleColumnAlterSqlOptions) -> TableStructureSqlResult {
+    let capabilities = capabilities_for(options.database_type);
+    let dialect = capabilities.dialect;
+    let table = qualified_table(dialect, options.schema.as_deref(), &options.table_name);
+    let database_label = database_label(options.database_type);
+    let mut warnings = Vec::new();
+    let mut statements = Vec::new();
+
+    if options.column.marked_for_drop {
+        let Some(original) = &options.column.original else {
+            warnings.push("No original column info available.".to_string());
+            return TableStructureSqlResult { statements, warnings };
+        };
+        if !capabilities.drop_column {
+            warnings.push(format!("Dropping columns is not supported for {database_label} from this editor."));
+            return TableStructureSqlResult { statements, warnings };
+        }
+        if original.is_primary_key {
+            warnings.push(format!("Primary key column \"{}\" cannot be dropped from this editor.", original.name));
+            return TableStructureSqlResult { statements, warnings };
+        }
+        if is_protected_manticore_id_column(dialect, &original.name) {
+            warnings.push("Manticore Search id column cannot be dropped from this editor.".to_string());
+            return TableStructureSqlResult { statements, warnings };
+        }
+        statements.push(build_drop_column_sql(dialect, &table, &original.name));
+        return TableStructureSqlResult { statements, warnings };
+    }
+
+    let Some(original) = &options.column.original else {
+        warnings.push(
+            "This column has no original state — ALTER statements are only available for existing columns.".to_string(),
+        );
+        return TableStructureSqlResult { statements, warnings };
+    };
+
+    if !has_existing_column_attribute_change(&options.column) && !has_column_extra_change(&options.column) {
+        warnings.push("No changes detected for this column.".to_string());
+        return TableStructureSqlResult { statements, warnings };
+    }
+
+    let has_rename = options.column.name != original.name;
+    let has_attribute_change = options.column.data_type.trim() != original.data_type.trim()
+        || options.column.is_nullable != original.is_nullable
+        || normalize_default(Some(&options.column.default_value)) != original_default(&options.column)
+        || clean(&options.column.comment) != original_comment(&options.column)
+        || (is_mysql_character_data_type(&options.column.data_type)
+            && (options.column.character_set.trim() != original.character_set.as_deref().unwrap_or("")
+                || options.column.collation.trim() != original.collation.as_deref().unwrap_or("")));
+
+    if has_rename && !capabilities.rename_column {
+        warnings.push(format!("Renaming columns is not supported for {database_label} from this editor."));
+    }
+    if has_attribute_change && !capabilities.alter_existing_column && dialect != StructureDialect::Sqlite {
+        warnings.push(format!("Editing existing columns is not supported for {database_label} yet."));
+    }
+
+    if (has_rename && !capabilities.rename_column)
+        || (has_attribute_change && !capabilities.alter_existing_column && dialect != StructureDialect::Sqlite)
+    {
+        return TableStructureSqlResult { statements, warnings };
+    }
+
+    match dialect {
+        StructureDialect::Mysql => statements.extend(build_mysql_existing_column_sql(&table, &options.column, "")),
+        StructureDialect::Doris => statements.extend(build_doris_existing_column_sql(&table, &options.column, "")),
+        StructureDialect::Postgres => statements.extend(build_postgres_existing_column_sql(&table, &options.column)),
+        StructureDialect::Oracle | StructureDialect::Dameng => {
+            statements.extend(build_oracle_like_existing_column_sql(dialect, &table, &options.column))
+        }
+        StructureDialect::H2 => statements.extend(build_h2_existing_column_sql(&table, &options.column)),
+        StructureDialect::ClickHouse => {
+            statements.extend(build_clickhouse_existing_column_sql(&table, &options.column, ""))
+        }
+        StructureDialect::Informix => statements.extend(build_informix_existing_column_sql(&table, &options.column)),
+        StructureDialect::SqlServer => statements.extend(build_sqlserver_existing_column_sql(
+            &table,
+            &options.column,
+            options.schema.as_deref(),
+            &options.table_name,
+            &mut warnings,
+        )),
+        StructureDialect::Sqlite => {
+            statements.extend(build_sqlite_existing_column_sql(&table, &options.column, &mut warnings))
+        }
+        _ => warnings.push(format!("Editing existing columns is not supported for {database_label} yet.")),
+    }
+
+    TableStructureSqlResult { statements, warnings }
+}
+
+fn is_column_extra_empty(extra: &ColumnExtra) -> bool {
+    !extra.auto_increment.unwrap_or(false)
+        && !extra.on_update_current_timestamp.unwrap_or(false)
+        && extra.identity.is_none()
+        && !extra.manticore_indexed.unwrap_or(false)
+        && !extra.manticore_stored.unwrap_or(false)
+        && !extra.manticore_attribute.unwrap_or(false)
+        && !extra.manticore_secondary_index.unwrap_or(false)
+}
+
+fn original_manticore_extra_flags(extra: &str) -> (bool, bool, bool, bool) {
+    let lower = extra.to_lowercase();
+    (
+        lower.split_whitespace().any(|token| token == "indexed"),
+        lower.split_whitespace().any(|token| token == "stored"),
+        lower.split_whitespace().any(|token| token == "attribute"),
+        lower.contains("secondary_index='1'")
+            || lower.contains("secondary_index=\"1\"")
+            || lower.contains("secondary_index=1"),
+    )
+}
+
+fn original_has_auto_increment(extra: &str) -> bool {
+    let lower = extra.to_lowercase();
+    lower.contains("auto_increment") || lower.contains("autoincrement")
+}
+
+fn original_has_identity(extra: &str) -> bool {
+    extra.to_lowercase().contains("identity")
+}
+
+fn sqlserver_identity_values(extra: &str) -> Option<(Option<i64>, Option<i64>)> {
+    let lower = extra.to_lowercase();
+    let identity_index = lower.find("identity")?;
+    let after_identity = extra.get(identity_index + "identity".len()..)?.trim_start();
+    if !after_identity.starts_with('(') {
+        return Some((None, None));
+    }
+    let close_index = after_identity.find(')')?;
+    let args = &after_identity[1..close_index];
+    let mut parts = args.split(',').map(|part| part.trim().parse::<i64>().ok());
+    Some((parts.next().flatten(), parts.next().flatten()))
+}
+
+fn sqlserver_identity_matches_original(identity: &super::types::ColumnIdentity, original_extra: &str) -> bool {
+    let Some((original_seed, original_increment)) = sqlserver_identity_values(original_extra) else {
+        return false;
+    };
+    identity.seed.unwrap_or(1) == original_seed.unwrap_or(1)
+        && identity.increment.unwrap_or(1) == original_increment.unwrap_or(1)
+}
+
+fn parse_i64_after_phrase(value: &str, lower: &str, phrase: &str) -> Option<i64> {
+    let start = lower.find(phrase)? + phrase.len();
+    let rest = value.get(start..)?.trim_start();
+    let token = rest.split(|ch: char| ch.is_whitespace() || ch == ')' || ch == ',').find(|part| !part.is_empty())?;
+    token.parse::<i64>().ok()
+}
+
+fn postgres_identity_values(extra: &str) -> Option<(String, Option<i64>, Option<i64>)> {
+    let lower = extra.to_lowercase();
+    let generation = if lower.contains("generated always as identity") {
+        "ALWAYS".to_string()
+    } else if lower.contains("generated by default as identity") {
+        "BY DEFAULT".to_string()
+    } else {
+        return None;
+    };
+    let seed = parse_i64_after_phrase(extra, &lower, "start with");
+    let increment = parse_i64_after_phrase(extra, &lower, "increment by");
+    Some((generation, seed, increment))
+}
+
+fn identity_matches_original(identity: &super::types::ColumnIdentity, original_extra: &str) -> bool {
+    if let Some((generation, original_seed, original_increment)) = postgres_identity_values(original_extra) {
+        return identity.generation.as_deref().unwrap_or("BY DEFAULT").eq_ignore_ascii_case(&generation)
+            && identity.seed.unwrap_or(1) == original_seed.unwrap_or(1)
+            && identity.increment.unwrap_or(1) == original_increment.unwrap_or(1);
+    }
+    sqlserver_identity_matches_original(identity, original_extra)
+}
+
+pub(super) fn has_column_extra_change(column: &EditableStructureColumn) -> bool {
+    let Some(original) = &column.original else { return false };
+    let current_extra = column.extra.as_ref();
+    match (current_extra, original.extra.as_deref()) {
+        // Neither has extra → no change
+        (None, None | Some("")) => false,
+        // Current extra is empty (all None) → changed only if the original had effective extra
+        (Some(curr), None | Some("")) if is_column_extra_empty(curr) => false,
+        (Some(curr), Some(orig)) if is_column_extra_empty(curr) => {
+            let (indexed, stored, attribute, secondary_index) = original_manticore_extra_flags(orig);
+            let orig_lower = orig.to_lowercase();
+            original_has_auto_increment(orig)
+                || orig_lower.contains("on update")
+                || original_has_identity(orig)
+                || indexed
+                || stored
+                || attribute
+                || secondary_index
+        }
+        // Extra added or removed
+        (Some(_), None | Some("")) => true,
+        (None, Some(_)) => true,
+        // Both have extra → check auto_increment and on_update_current_timestamp flags
+        (Some(curr), Some(orig)) => {
+            let orig_lower = orig.to_lowercase();
+            let curr_has_ai = curr.auto_increment.unwrap_or(false);
+            let orig_has_identity = original_has_identity(orig);
+            let orig_has_ai = original_has_auto_increment(orig) || (orig_has_identity && curr_has_ai);
+            let curr_has_on_update = curr.on_update_current_timestamp.unwrap_or(false);
+            let orig_has_on_update = orig_lower.contains("on update");
+            let identity_changed = match (&curr.identity, orig_has_identity) {
+                (Some(identity), true) => !identity_matches_original(identity, orig),
+                (Some(_), false) => true,
+                (None, true) => !curr_has_ai,
+                (None, false) => false,
+            };
+            let curr_manticore = (
+                curr.manticore_indexed.unwrap_or(false),
+                curr.manticore_stored.unwrap_or(false),
+                curr.manticore_attribute.unwrap_or(false),
+                curr.manticore_secondary_index.unwrap_or(false),
+            );
+            let orig_manticore = original_manticore_extra_flags(orig);
+            curr_has_ai != orig_has_ai
+                || curr_has_on_update != orig_has_on_update
+                || identity_changed
+                || curr_manticore != orig_manticore
+        }
+    }
+}
+
+pub(super) fn build_mysql_existing_column_sql(
+    table: &str,
+    column: &EditableStructureColumn,
+    position_clause: &str,
+) -> Vec<String> {
+    let original_name = column.original.as_ref().map(|original| original.name.as_str()).unwrap_or(&column.name);
+    let operation = if column.name == original_name {
+        format!("MODIFY COLUMN {}", column_definition(StructureDialect::Mysql, column))
+    } else {
+        format!(
+            "CHANGE COLUMN {} {}",
+            quote_ident(StructureDialect::Mysql, original_name),
+            column_definition(StructureDialect::Mysql, column)
+        )
+    };
+    vec![format!("ALTER TABLE {table} {operation}{position_clause};")]
+}
+
+pub(super) fn build_doris_existing_column_sql(
+    table: &str,
+    column: &EditableStructureColumn,
+    position_clause: &str,
+) -> Vec<String> {
+    let Some(original) = &column.original else {
+        return Vec::new();
+    };
+    let mut statements = Vec::new();
+    let mut current_column = column.clone();
+
+    if column.name != original.name {
+        // Doris follows its own lightweight schema-change grammar: no MySQL CHANGE and no TO keyword.
+        statements.push(format!(
+            "ALTER TABLE {table} RENAME COLUMN {} {};",
+            quote_ident(StructureDialect::Doris, &original.name),
+            quote_ident(StructureDialect::Doris, &column.name)
+        ));
+        current_column.name = column.name.clone();
+    }
+
+    let type_changed = column.data_type.trim() != original.data_type.trim();
+    let nullable_changed = column.is_nullable != original.is_nullable;
+    let default_changed = normalize_default(Some(&column.default_value)) != original_default(column);
+    let comment_changed = clean(&column.comment) != original_comment(column);
+    if type_changed || nullable_changed || default_changed || comment_changed || !position_clause.is_empty() {
+        statements.push(format!(
+            "ALTER TABLE {table} MODIFY COLUMN {}{position_clause};",
+            column_definition(StructureDialect::Doris, &current_column)
+        ));
+    }
+
+    statements
+}
+
+pub(super) fn build_postgres_existing_column_sql(table: &str, column: &EditableStructureColumn) -> Vec<String> {
+    let Some(original) = &column.original else {
+        return Vec::new();
+    };
+    let mut statements = Vec::new();
+    let current_name = &column.name;
+    if column.name != original.name {
+        statements.push(format!(
+            "ALTER TABLE {table} RENAME COLUMN {} TO {};",
+            quote_ident(StructureDialect::Postgres, &original.name),
+            quote_ident(StructureDialect::Postgres, &column.name)
+        ));
+    }
+    if column.data_type.trim() != original.data_type.trim() {
+        statements.push(format!(
+            "ALTER TABLE {table} ALTER COLUMN {} TYPE {};",
+            quote_ident(StructureDialect::Postgres, current_name),
+            column_data_type(StructureDialect::Postgres, column)
+        ));
+    }
+    if column.is_nullable != original.is_nullable {
+        let action = if column.is_nullable { "DROP NOT NULL" } else { "SET NOT NULL" };
+        statements.push(format!(
+            "ALTER TABLE {table} ALTER COLUMN {} {action};",
+            quote_ident(StructureDialect::Postgres, current_name)
+        ));
+    }
+    if normalize_default(Some(&column.default_value)) != original_default(column) {
+        let default_value = normalize_default(Some(&column.default_value));
+        let action = if default_value.is_empty() {
+            "DROP DEFAULT".to_string()
+        } else {
+            format!(
+                "SET DEFAULT {}",
+                format_default_for_sql(StructureDialect::Postgres, &column.data_type, &default_value)
+            )
+        };
+        statements.push(format!(
+            "ALTER TABLE {table} ALTER COLUMN {} {action};",
+            quote_ident(StructureDialect::Postgres, current_name)
+        ));
+    }
+    if clean(&column.comment) != original_comment(column) {
+        let comment_value =
+            if clean(&column.comment).is_empty() { "NULL".to_string() } else { quote_string(&clean(&column.comment)) };
+        statements.push(format!(
+            "COMMENT ON COLUMN {table}.{} IS {comment_value};",
+            quote_ident(StructureDialect::Postgres, current_name)
+        ));
+    }
+    statements
+}
+
+pub(super) fn build_informix_existing_column_sql(table: &str, column: &EditableStructureColumn) -> Vec<String> {
+    let Some(original) = &column.original else {
+        return Vec::new();
+    };
+    let dialect = StructureDialect::Informix;
+    let mut statements = Vec::new();
+    let mut current_name = original.name.clone();
+    if column.name != original.name {
+        statements.push(format!(
+            "RENAME COLUMN {table}.{} TO {};",
+            quote_ident(dialect, &original.name),
+            quote_ident(dialect, &column.name)
+        ));
+        current_name = column.name.clone();
+    }
+    let type_changed = column.data_type.trim() != original.data_type.trim();
+    let nullable_changed = column.is_nullable != original.is_nullable;
+    let default_changed = normalize_default(Some(&column.default_value)) != original_default(column);
+    if type_changed || nullable_changed || default_changed {
+        let mut parts = vec![quote_ident(dialect, &current_name), column_data_type(dialect, column)];
+        if column.is_nullable {
+            parts.push("NULL".to_string());
+        } else {
+            parts.push("NOT NULL".to_string());
+        }
+        let default_value = normalize_default(Some(&column.default_value));
+        if !default_value.is_empty() {
+            parts.push(format!("DEFAULT {}", format_default_for_sql(dialect, &column.data_type, &default_value)));
+        } else if default_changed {
+            parts.push("DEFAULT NULL".to_string());
+        }
+        statements.push(format!("ALTER TABLE {table} MODIFY ({});", parts.join(" ")));
+    }
+    statements
+}
+
+pub(super) fn build_oracle_like_existing_column_sql(
+    dialect: StructureDialect,
+    table: &str,
+    column: &EditableStructureColumn,
+) -> Vec<String> {
+    let Some(original) = &column.original else {
+        return Vec::new();
+    };
+    let mut statements = Vec::new();
+    let mut current_name = original.name.clone();
+    if column.name != original.name {
+        statements.push(format!(
+            "ALTER TABLE {table} RENAME COLUMN {} TO {};",
+            quote_ident(dialect, &original.name),
+            quote_ident(dialect, &column.name)
+        ));
+        current_name = column.name.clone();
+    }
+    let type_changed = column.data_type.trim() != original.data_type.trim();
+    let nullable_changed = column.is_nullable != original.is_nullable;
+    let default_changed = normalize_default(Some(&column.default_value)) != original_default(column);
+    if type_changed || nullable_changed || default_changed {
+        let data_type = column_data_type(dialect, column);
+        let mut parts = vec![quote_ident(dialect, &current_name), data_type];
+        let default_value = normalize_default(Some(&column.default_value));
+        if !default_value.is_empty() {
+            parts.push(format!("DEFAULT {}", format_default_for_sql(dialect, &column.data_type, &default_value)));
+        } else if default_changed {
+            // User cleared the default — explicitly drop it.
+            parts.push("DEFAULT NULL".to_string());
+        }
+        if nullable_changed {
+            if column.is_nullable {
+                parts.push("NULL".to_string());
+            } else {
+                parts.push("NOT NULL".to_string());
+            }
+        }
+        statements.push(format!("ALTER TABLE {table} MODIFY ({});", parts.join(" ")));
+    }
+    if clean(&column.comment) != original_comment(column) {
+        let comment_value =
+            if clean(&column.comment).is_empty() { "NULL".to_string() } else { quote_string(&clean(&column.comment)) };
+        statements
+            .push(format!("COMMENT ON COLUMN {table}.{} IS {comment_value};", quote_ident(dialect, &current_name)));
+    }
+    statements
+}
+
+pub(super) fn build_sqlserver_existing_column_sql(
+    table: &str,
+    column: &EditableStructureColumn,
+    schema: Option<&str>,
+    table_name: &str,
+    warnings: &mut Vec<String>,
+) -> Vec<String> {
+    let Some(original) = &column.original else {
+        return Vec::new();
+    };
+    let dialect = StructureDialect::SqlServer;
+    let mut statements = Vec::new();
+    let mut current_name = original.name.clone();
+
+    if has_sqlserver_identity_change(column) {
+        warnings.push(format!(
+            "Changing SQL Server IDENTITY for existing column \"{}\" is not supported from this editor.",
+            original.name
+        ));
+    }
+
+    // Rename column via sp_rename
+    if column.name != original.name {
+        let full_obj_path = format!("{table}.{}", quote_ident(dialect, &original.name));
+        statements.push(format!(
+            "EXEC sp_rename '{full_obj_path}', '{new_name}', 'COLUMN';",
+            full_obj_path = full_obj_path.replace('\'', "''"),
+            new_name = column.name.replace('\'', "''")
+        ));
+        current_name = column.name.clone();
+    }
+
+    // Build the ALTER COLUMN clause for type + nullability changes
+    if column.data_type.trim() != original.data_type.trim() || column.is_nullable != original.is_nullable {
+        let null_clause = if column.is_nullable { "NULL" } else { "NOT NULL" };
+        statements.push(format!(
+            "ALTER TABLE {table} ALTER COLUMN {} {} {null_clause};",
+            quote_ident(dialect, &current_name),
+            column_data_type(dialect, column)
+        ));
+    }
+
+    // Default value changes via ADD/DROP CONSTRAINT
+    if normalize_default(Some(&column.default_value)) != original_default(column) {
+        let default_value = normalize_default(Some(&column.default_value));
+        let has_old_default = !column
+            .original
+            .as_ref()
+            .and_then(|o| o.column_default.as_ref())
+            .unwrap_or(&String::new())
+            .trim()
+            .is_empty()
+            && !column
+                .original
+                .as_ref()
+                .and_then(|o| o.column_default.as_ref())
+                .map(|d| d.trim().eq_ignore_ascii_case("null"))
+                .unwrap_or(false);
+
+        if has_old_default {
+            let sql_var = sqlserver_default_constraint_sql_var(table, &current_name);
+            statements.push(format!(
+                "DECLARE {sql_var} NVARCHAR(MAX); \
+                 SELECT TOP (1) {sql_var} = N'ALTER TABLE {table} DROP CONSTRAINT ' + QUOTENAME(dc.name) \
+                 FROM sys.default_constraints AS dc \
+                 WHERE dc.parent_object_id = OBJECT_ID(N'{table}') AND dc.parent_column_id = COLUMNPROPERTY(OBJECT_ID(N'{table}'), N'{col_name}', 'ColumnId'); \
+                 IF {sql_var} IS NOT NULL EXEC sp_executesql {sql_var};",
+                table = table.replace('\'', "''"),
+                col_name = current_name.replace('\'', "''")
+            ));
+        }
+        if !default_value.is_empty() {
+            let short_table =
+                table.split('.').next_back().unwrap_or(table).trim_matches(|c: char| c == '[' || c == ']');
+            let constraint_name = format!(
+                "DF_{short_table}_{col_name}",
+                short_table = short_table,
+                col_name = current_name.trim_matches(|c: char| c == '[' || c == ']')
+            );
+            statements.push(format!(
+                "ALTER TABLE {table} ADD CONSTRAINT [{constraint_name}] DEFAULT {} FOR {};",
+                format_default_for_sql(StructureDialect::SqlServer, &column.data_type, &default_value),
+                quote_ident(dialect, &current_name)
+            ));
+        }
+    }
+
+    // Column comment changes via extended properties
+    if clean(&column.comment) != original_comment(column) {
+        statements.extend(build_sqlserver_column_comment_sql(
+            table,
+            schema,
+            table_name,
+            &current_name,
+            &column.comment,
+        ));
+    }
+
+    statements
+}
+
+fn sqlserver_default_constraint_sql_var(table: &str, column_name: &str) -> String {
+    let mut hash = 0x811c_9dc5u32;
+    for byte in table.bytes().chain([0]).chain(column_name.bytes()) {
+        hash ^= u32::from(byte);
+        hash = hash.wrapping_mul(0x0100_0193);
+    }
+    format!("@dbx_default_sql_{hash:08x}")
+}
+
+fn has_sqlserver_identity_change(column: &EditableStructureColumn) -> bool {
+    let Some(original) = &column.original else {
+        return false;
+    };
+    let original_extra = original.extra.as_deref().unwrap_or("");
+    let original_identity = original_has_identity(original_extra);
+    let current_extra = column.extra.as_ref();
+    let current_identity =
+        current_extra.is_some_and(|extra| extra.auto_increment.unwrap_or(false) || extra.identity.is_some());
+
+    if current_identity != original_identity {
+        return true;
+    }
+    if !current_identity {
+        return false;
+    }
+
+    current_extra
+        .and_then(|extra| extra.identity.as_ref())
+        .is_some_and(|identity| !sqlserver_identity_matches_original(identity, original_extra))
+}
+
+pub(super) fn build_h2_existing_column_sql(table: &str, column: &EditableStructureColumn) -> Vec<String> {
+    let Some(original) = &column.original else {
+        return Vec::new();
+    };
+    let mut statements = Vec::new();
+    let mut current_name = original.name.clone();
+    if column.name != original.name {
+        statements.push(format!(
+            "ALTER TABLE {table} ALTER COLUMN {} RENAME TO {};",
+            quote_ident(StructureDialect::H2, &original.name),
+            quote_ident(StructureDialect::H2, &column.name)
+        ));
+        current_name = column.name.clone();
+    }
+    if column.data_type.trim() != original.data_type.trim() {
+        statements.push(format!(
+            "ALTER TABLE {table} ALTER COLUMN {} SET DATA TYPE {};",
+            quote_ident(StructureDialect::H2, &current_name),
+            column_data_type(StructureDialect::H2, column)
+        ));
+    }
+    if column.is_nullable != original.is_nullable {
+        let action = if column.is_nullable { "DROP NOT NULL" } else { "SET NOT NULL" };
+        statements.push(format!(
+            "ALTER TABLE {table} ALTER COLUMN {} {action};",
+            quote_ident(StructureDialect::H2, &current_name)
+        ));
+    }
+    if normalize_default(Some(&column.default_value)) != original_default(column) {
+        let default_value = normalize_default(Some(&column.default_value));
+        let action = if default_value.is_empty() {
+            "DROP DEFAULT".to_string()
+        } else {
+            format!("SET DEFAULT {}", format_default_for_sql(StructureDialect::H2, &column.data_type, &default_value))
+        };
+        statements.push(format!(
+            "ALTER TABLE {table} ALTER COLUMN {} {action};",
+            quote_ident(StructureDialect::H2, &current_name)
+        ));
+    }
+    if clean(&column.comment) != original_comment(column) {
+        let comment_value =
+            if clean(&column.comment).is_empty() { "NULL".to_string() } else { quote_string(&clean(&column.comment)) };
+        statements.push(format!(
+            "COMMENT ON COLUMN {table}.{} IS {comment_value};",
+            quote_ident(StructureDialect::H2, &current_name)
+        ));
+    }
+    statements
+}
+
+pub(super) fn build_clickhouse_existing_column_sql(
+    table: &str,
+    column: &EditableStructureColumn,
+    position_clause: &str,
+) -> Vec<String> {
+    let Some(original) = &column.original else {
+        return Vec::new();
+    };
+    let mut statements = Vec::new();
+    let mut current_name = original.name.clone();
+    if column.name != original.name {
+        statements.push(format!(
+            "ALTER TABLE {table} RENAME COLUMN {} TO {};",
+            quote_ident(StructureDialect::ClickHouse, &original.name),
+            quote_ident(StructureDialect::ClickHouse, &column.name)
+        ));
+        current_name = column.name.clone();
+    }
+    let next_type = clickhouse_column_type(column);
+    if next_type != original.data_type.trim()
+        || normalize_default(Some(&column.default_value)) != original_default(column)
+    {
+        let default_value = normalize_default(Some(&column.default_value));
+        if !default_value.is_empty() {
+            let default_sql = format_default_for_sql(StructureDialect::ClickHouse, &column.data_type, &default_value);
+            statements.push(format!(
+                "ALTER TABLE {table} MODIFY COLUMN {} {next_type} DEFAULT {default_sql}{position_clause};",
+                quote_ident(StructureDialect::ClickHouse, &current_name)
+            ));
+        } else if !original_default(column).is_empty() {
+            statements.push(format!(
+                "ALTER TABLE {table} MODIFY COLUMN {} REMOVE DEFAULT;",
+                quote_ident(StructureDialect::ClickHouse, &current_name)
+            ));
+            if next_type != original.data_type.trim() || !position_clause.is_empty() {
+                statements.push(format!(
+                    "ALTER TABLE {table} MODIFY COLUMN {} {next_type}{position_clause};",
+                    quote_ident(StructureDialect::ClickHouse, &current_name)
+                ));
+            }
+        } else {
+            statements.push(format!(
+                "ALTER TABLE {table} MODIFY COLUMN {} {next_type}{position_clause};",
+                quote_ident(StructureDialect::ClickHouse, &current_name)
+            ));
+        }
+    } else if !position_clause.is_empty() {
+        statements.push(format!(
+            "ALTER TABLE {table} MODIFY COLUMN {} {next_type}{position_clause};",
+            quote_ident(StructureDialect::ClickHouse, &current_name)
+        ));
+    }
+    if clean(&column.comment) != original_comment(column) {
+        statements.push(format!(
+            "ALTER TABLE {table} COMMENT COLUMN {} {};",
+            quote_ident(StructureDialect::ClickHouse, &current_name),
+            quote_string(&clean(&column.comment))
+        ));
+    }
+    statements
+}
+
+pub(super) fn build_sqlite_existing_column_sql(
+    table: &str,
+    column: &EditableStructureColumn,
+    warnings: &mut Vec<String>,
+) -> Vec<String> {
+    let Some(original) = &column.original else {
+        return Vec::new();
+    };
+    let mut statements = Vec::new();
+    let unsupported_change = column.data_type.trim() != original.data_type.trim()
+        || column.is_nullable != original.is_nullable
+        || normalize_default(Some(&column.default_value)) != original_default(column)
+        || clean(&column.comment) != original_comment(column);
+    if column.name != original.name {
+        statements.push(format!(
+            "ALTER TABLE {table} RENAME COLUMN {} TO {};",
+            quote_ident(StructureDialect::Sqlite, &original.name),
+            quote_ident(StructureDialect::Sqlite, &column.name)
+        ));
+    }
+    if unsupported_change {
+        warnings.push(format!(
+            "SQLite cannot safely alter existing column \"{}\" without rebuilding the table.",
+            original.name
+        ));
+    }
+    statements
+}
+
+pub(super) fn build_questdb_existing_column_sql(table: &str, column: &EditableStructureColumn) -> Vec<String> {
+    let Some(original) = &column.original else {
+        return Vec::new();
+    };
+    let mut statements = Vec::new();
+    let current_name = &column.name;
+    if column.name != original.name {
+        statements.push(format!(
+            "ALTER TABLE {table} RENAME COLUMN {} TO {};",
+            quote_ident(StructureDialect::Questdb, &original.name),
+            quote_ident(StructureDialect::Questdb, &column.name)
+        ));
+    }
+    if column.data_type.trim() != original.data_type.trim() {
+        statements.push(format!(
+            "ALTER TABLE {table} ALTER COLUMN {} TYPE {};",
+            quote_ident(StructureDialect::Questdb, current_name),
+            column_data_type(StructureDialect::Questdb, column)
+        ));
+    }
+    statements
+}
+
+pub(super) fn has_existing_column_attribute_change(column: &EditableStructureColumn) -> bool {
+    let Some(original) = &column.original else {
+        return false;
+    };
+    column.name != original.name
+        || column.data_type.trim() != original.data_type.trim()
+        || column.is_nullable != original.is_nullable
+        || normalize_default(Some(&column.default_value)) != original_default(column)
+        || clean(&column.comment) != original_comment(column)
+        || (is_mysql_character_data_type(&column.data_type)
+            && (column.character_set.trim() != original.character_set.as_deref().unwrap_or("")
+                || column.collation.trim() != original.collation.as_deref().unwrap_or("")))
+}
diff --git a/crates/dbx-core/src/table_structure_sql/column_format.rs b/crates/dbx-core/src/table_structure_sql/column_format.rs
new file mode 100644
index 0000000..3d7c791
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/column_format.rs
@@ -0,0 +1,398 @@
+use super::dialect::{is_oracle_like, StructureDialect};
+use super::types::EditableStructureColumn;
+use super::util::{clean, format_default_for_sql, normalize_default, quote_ident, quote_string};
+
+pub(super) fn column_definition(dialect: StructureDialect, column: &EditableStructureColumn) -> String {
+    let data_type = column_data_type(dialect, column);
+    let mut parts = vec![quote_ident(dialect, &column.name), data_type];
+    // QuestDB SQL Syntax: ```ALTER TABLE tableName ADD COLUMN [IF NOT EXISTS] columnName typeDef```
+    if dialect == StructureDialect::Questdb {
+        parts.insert(0, "IF NOT EXISTS".to_string());
+        return parts.join(" ");
+    }
+    // CHARACTER SET / COLLATE — MySQL character data types only
+    if dialect == StructureDialect::Mysql && is_mysql_character_data_type(&column.data_type) {
+        if !column.character_set.trim().is_empty() {
+            parts.push(format!("CHARACTER SET {}", quote_ident(dialect, &column.character_set)));
+        }
+        if !column.collation.trim().is_empty() {
+            parts.push(format!("COLLATE {}", quote_ident(dialect, &column.collation)));
+        }
+    }
+    if !column.is_nullable && !is_oracle_like(dialect) && dialect != StructureDialect::ClickHouse {
+        parts.push("NOT NULL".to_string());
+    }
+    if let Some(extra_clause) = column_extra_clause(dialect, column) {
+        parts.push(extra_clause);
+    }
+    let default_value = normalize_default(Some(&column.default_value));
+    if !default_value.is_empty() {
+        parts.push(format!("DEFAULT {}", format_default_for_sql(dialect, &column.data_type, &default_value)));
+    }
+    if let Some(on_update) = column.extra.as_ref().and_then(|e| e.on_update_current_timestamp).filter(|v| *v) {
+        if on_update && dialect == StructureDialect::Mysql {
+            parts.push("ON UPDATE CURRENT_TIMESTAMP".to_string());
+        }
+    }
+    if matches!(dialect, StructureDialect::Mysql | StructureDialect::Doris) && !clean(&column.comment).is_empty() {
+        parts.push(format!("COMMENT {}", quote_string(&clean(&column.comment))));
+    }
+    parts.join(" ")
+}
+
+pub(super) fn column_extra_clause(dialect: StructureDialect, column: &EditableStructureColumn) -> Option<String> {
+    let extra = column.extra.as_ref()?;
+    match dialect {
+        StructureDialect::Mysql => {
+            let mut clauses = Vec::new();
+            if extra.auto_increment.unwrap_or(false) {
+                clauses.push("AUTO_INCREMENT".to_string());
+            }
+            if clauses.is_empty() {
+                None
+            } else {
+                Some(clauses.join(" "))
+            }
+        }
+        StructureDialect::Postgres | StructureDialect::H2 => {
+            if let Some(identity) = &extra.identity {
+                let generation = identity.generation.as_deref().unwrap_or("BY DEFAULT");
+                let mut clause = format!("GENERATED {generation} AS IDENTITY");
+                if identity.seed.is_some() || identity.increment.is_some() {
+                    let start = identity.seed.unwrap_or(1);
+                    let inc = identity.increment.unwrap_or(1);
+                    clause.push_str(&format!(" (START WITH {start} INCREMENT BY {inc})"));
+                }
+                Some(clause)
+            } else {
+                None
+            }
+        }
+        StructureDialect::SqlServer => {
+            if extra.auto_increment.unwrap_or(false) || extra.identity.is_some() {
+                let seed = extra.identity.as_ref().and_then(|i| i.seed).unwrap_or(1);
+                let increment = extra.identity.as_ref().and_then(|i| i.increment).unwrap_or(1);
+                Some(format!("IDENTITY({seed}, {increment})"))
+            } else {
+                None
+            }
+        }
+        StructureDialect::Dameng => {
+            if extra.auto_increment.unwrap_or(false) || extra.identity.is_some() {
+                let seed = extra.identity.as_ref().and_then(|i| i.seed).unwrap_or(1);
+                let increment = extra.identity.as_ref().and_then(|i| i.increment).unwrap_or(1);
+                Some(format!("IDENTITY({seed}, {increment})"))
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+pub(super) fn has_dameng_identity(column: &EditableStructureColumn) -> bool {
+    column.extra.as_ref().is_some_and(|extra| extra.auto_increment.unwrap_or(false) || extra.identity.is_some())
+}
+
+pub(super) fn is_dameng_identity_compatible_type(data_type: &str) -> bool {
+    let trimmed = data_type.trim();
+    let (base_type, params) = match trimmed.find('(') {
+        Some(open_index) => {
+            let close_index = trimmed.rfind(')').unwrap_or(trimmed.len());
+            (&trimmed[..open_index], trimmed.get(open_index + 1..close_index).unwrap_or(""))
+        }
+        None => (trimmed, ""),
+    };
+    let normalized = base_type.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    if matches!(normalized.as_str(), "tinyint" | "smallint" | "int" | "integer" | "bigint") {
+        return true;
+    }
+    if !matches!(normalized.as_str(), "number" | "numeric" | "decimal" | "dec") {
+        return false;
+    }
+    let normalized_params = params.split_whitespace().collect::<String>();
+    if normalized_params.is_empty() {
+        return true;
+    }
+    let parts = normalized_params.split(',').collect::<Vec<_>>();
+    match parts.as_slice() {
+        [precision] => precision.parse::<u32>().is_ok(),
+        [precision, scale] => precision.parse::<u32>().is_ok() && *scale == "0",
+        _ => false,
+    }
+}
+
+pub(super) fn column_data_type(dialect: StructureDialect, column: &EditableStructureColumn) -> String {
+    if dialect == StructureDialect::ClickHouse {
+        return clickhouse_column_type(column);
+    }
+    if dialect == StructureDialect::ManticoreSearch {
+        return manticore_column_type(column);
+    }
+    if dialect == StructureDialect::Questdb {
+        return questdb_column_type(column);
+    }
+    normalize_column_data_type(dialect, &column.data_type)
+}
+
+fn manticore_column_type(column: &EditableStructureColumn) -> String {
+    let data_type = normalize_column_data_type(StructureDialect::ManticoreSearch, &column.data_type);
+    let normalized = data_type.trim().to_ascii_lowercase();
+    if normalized == "json" {
+        let Some(extra) = column.extra.as_ref() else {
+            return data_type;
+        };
+        if extra.manticore_secondary_index.unwrap_or(false) {
+            return format!("{data_type} secondary_index='1'");
+        }
+        return data_type;
+    }
+    if !matches!(normalized.as_str(), "text" | "string") {
+        return data_type;
+    }
+
+    let Some(extra) = column.extra.as_ref() else {
+        return data_type;
+    };
+    let mut parts = vec![data_type];
+    if extra.manticore_stored.unwrap_or(false) {
+        parts.push("stored".to_string());
+    }
+    if extra.manticore_attribute.unwrap_or(false) {
+        parts.push("attribute".to_string());
+    }
+    if extra.manticore_indexed.unwrap_or(false) {
+        parts.push("indexed".to_string());
+    }
+    parts.join(" ")
+}
+
+pub(super) fn normalize_column_data_type(dialect: StructureDialect, data_type: &str) -> String {
+    let trimmed = data_type.trim();
+    let Some(open_index) = trimmed.find('(') else {
+        return trimmed.to_string();
+    };
+    if !trimmed.ends_with(')') {
+        return trimmed.to_string();
+    }
+
+    let base_type = trimmed[..open_index].trim();
+    let params = trimmed[open_index + 1..trimmed.len() - 1].trim();
+    if base_type.is_empty() || params.is_empty() {
+        return trimmed.to_string();
+    }
+
+    if dialect == StructureDialect::Mysql {
+        if let Some(normalized) = normalize_mysql_numeric_attribute_type(base_type, params) {
+            return normalized;
+        }
+    }
+
+    if is_oracle_like(dialect) && is_oracle_lengthless_type(base_type) {
+        // Dameng/Oracle integer aliases do not accept MySQL-style display widths like INTEGER(11).
+        return base_type.to_string();
+    }
+
+    if dialect == StructureDialect::SqlServer && is_sqlserver_lengthless_type(base_type) {
+        // SQL Server exact integer and legacy LOB types do not accept MySQL-style display widths.
+        return base_type.to_string();
+    }
+
+    if dialect == StructureDialect::SqlServer && is_sqlserver_float_with_scale(base_type, params) {
+        // SQL Server float only accepts a single integer mantissa bit count (1–53),
+        // not comma-separated precision/scale like float(10,2).
+        return base_type.to_string();
+    }
+
+    if is_temporal_precision_type(dialect, base_type) {
+        return if is_valid_temporal_precision(params, dialect) {
+            format!("{base_type}({params})")
+        } else {
+            base_type.to_string()
+        };
+    }
+
+    trimmed.to_string()
+}
+
+fn is_oracle_lengthless_type(base_type: &str) -> bool {
+    let normalized = base_type.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    matches!(
+        normalized.as_str(),
+        "binary_double"
+            | "binary_float"
+            | "bigint"
+            | "boolean"
+            | "bool"
+            | "byte"
+            | "date"
+            | "double"
+            | "double precision"
+            | "float"
+            | "integer"
+            | "int"
+            | "long"
+            | "long raw"
+            | "nclob"
+            | "real"
+            | "smallint"
+            | "text"
+            | "tinyint"
+    )
+}
+
+fn is_sqlserver_lengthless_type(base_type: &str) -> bool {
+    let normalized = base_type.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    matches!(
+        normalized.as_str(),
+        "bigint"
+            | "bit"
+            | "date"
+            | "datetime"
+            | "image"
+            | "int"
+            | "integer"
+            | "money"
+            | "ntext"
+            | "real"
+            | "smalldatetime"
+            | "smallint"
+            | "smallmoney"
+            | "sql_variant"
+            | "text"
+            | "timestamp"
+            | "tinyint"
+            | "uniqueidentifier"
+            | "xml"
+    )
+}
+
+/// SQL Server `float` accepts a single integer mantissa bit count (1–53)
+/// but rejects comma-separated precision/scale like `float(10,2)`.
+fn is_sqlserver_float_with_scale(base_type: &str, params: &str) -> bool {
+    let normalized = base_type.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    normalized == "float" && params.contains(',')
+}
+
+fn normalize_mysql_numeric_attribute_type(base_type: &str, params: &str) -> Option<String> {
+    let mut parts: Vec<&str> = base_type.split_whitespace().collect();
+    let type_name = parts.first().copied()?.to_ascii_lowercase();
+    if !matches!(
+        type_name.as_str(),
+        "tinyint"
+            | "smallint"
+            | "mediumint"
+            | "int"
+            | "integer"
+            | "bigint"
+            | "real"
+            | "double"
+            | "float"
+            | "decimal"
+            | "numeric"
+    ) {
+        return None;
+    }
+    let split_index = parts.iter().position(|part| {
+        let normalized = part.to_ascii_lowercase();
+        matches!(normalized.as_str(), "signed" | "unsigned" | "zerofill")
+    })?;
+    if !parts[split_index..].iter().all(|part| {
+        let normalized = part.to_ascii_lowercase();
+        matches!(normalized.as_str(), "signed" | "unsigned" | "zerofill")
+    }) {
+        return None;
+    }
+
+    let attrs = parts.split_off(split_index).join(" ");
+    let base = parts.join(" ");
+    Some(format!("{base}({params}) {attrs}"))
+}
+
+pub(super) fn is_temporal_precision_type(dialect: StructureDialect, base_type: &str) -> bool {
+    let normalized = base_type.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    match dialect {
+        StructureDialect::Mysql => matches!(normalized.as_str(), "time" | "datetime" | "timestamp"),
+        StructureDialect::Postgres => matches!(
+            normalized.as_str(),
+            "time"
+                | "time without time zone"
+                | "time with time zone"
+                | "timestamp"
+                | "timestamp without time zone"
+                | "timestamp with time zone"
+        ),
+        StructureDialect::SqlServer => matches!(normalized.as_str(), "time" | "datetime2" | "datetimeoffset"),
+        StructureDialect::Oracle | StructureDialect::Dameng => {
+            matches!(normalized.as_str(), "timestamp" | "timestamp with time zone" | "timestamp with local time zone")
+        }
+        _ => false,
+    }
+}
+
+pub(super) fn is_valid_temporal_precision(params: &str, dialect: StructureDialect) -> bool {
+    let Ok(value) = params.parse::<u8>() else {
+        return false;
+    };
+    let max = if matches!(dialect, StructureDialect::Oracle | StructureDialect::Dameng) { 9 } else { 6 };
+    value <= max && params == value.to_string()
+}
+
+pub(super) fn clickhouse_column_type(column: &EditableStructureColumn) -> String {
+    let data_type = column.data_type.trim();
+    if column.is_nullable {
+        if data_type.to_ascii_lowercase().starts_with("nullable") {
+            data_type.to_string()
+        } else {
+            format!("Nullable({data_type})")
+        }
+    } else {
+        unwrap_clickhouse_nullable_type(data_type)
+    }
+}
+
+pub(super) fn unwrap_clickhouse_nullable_type(data_type: &str) -> String {
+    let trimmed = data_type.trim();
+    let lower = trimmed.to_ascii_lowercase();
+    if lower.starts_with("nullable(") && trimmed.ends_with(')') {
+        trimmed[trimmed.find('(').unwrap_or(0) + 1..trimmed.len() - 1].trim().to_string()
+    } else {
+        trimmed.to_string()
+    }
+}
+
+/// QuestDB 类型处理
+/// geohash, decimal 这2种类型才能带()
+pub(super) fn questdb_column_type(column: &EditableStructureColumn) -> String {
+    let data_type = column.data_type.trim().to_ascii_lowercase();
+    let length_types: [&str; 2] = ["geohash", "decimal"];
+    match data_type.find('(') {
+        Some(pos) => {
+            let base_type = &data_type[..pos];
+            let params = &data_type[pos..];
+            if length_types.contains(&base_type) {
+                format!("{}{}", base_type, params)
+            } else {
+                base_type.to_string()
+            }
+        }
+        None => data_type,
+    }
+}
+
+/// Returns `true` when the data type is a MySQL character/string type that accepts
+/// `CHARACTER SET` and `COLLATE` clauses in column definitions.
+///
+/// Character types that support per-column charset/collation:
+///   `char`, `varchar`, `tinytext`, `text`, `mediumtext`, `longtext`, `enum`, `set`
+///
+/// Numeric, temporal, spatial, binary/blob, and JSON types do NOT support these clauses.
+pub(super) fn is_mysql_character_data_type(data_type: &str) -> bool {
+    let trimmed = data_type.trim();
+    let base_type = match trimmed.find('(') {
+        Some(open_index) => trimmed[..open_index].trim(),
+        None => trimmed,
+    };
+    let normalized = base_type.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    matches!(normalized.as_str(), "char" | "varchar" | "tinytext" | "text" | "mediumtext" | "longtext" | "enum" | "set")
+}
diff --git a/crates/dbx-core/src/table_structure_sql/columns.rs b/crates/dbx-core/src/table_structure_sql/columns.rs
new file mode 100644
index 0000000..fa10bf6
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/columns.rs
@@ -0,0 +1,460 @@
+use super::column_alter::{
+    build_clickhouse_existing_column_sql, build_doris_existing_column_sql, build_h2_existing_column_sql,
+    build_informix_existing_column_sql, build_mysql_existing_column_sql, build_oracle_like_existing_column_sql,
+    build_postgres_existing_column_sql, build_questdb_existing_column_sql, build_sqlite_existing_column_sql,
+    build_sqlserver_existing_column_sql, has_column_extra_change, has_existing_column_attribute_change,
+};
+use super::column_format::{
+    column_definition, has_dameng_identity, is_dameng_identity_compatible_type, is_mysql_character_data_type,
+};
+use super::comments::build_sqlserver_column_comment_sql;
+use super::dialect::{capabilities_for, database_label, is_oracle_like, StructureDialect};
+use super::types::{EditableStructureColumn, TableStructureSqlOptions};
+use super::util::{
+    clean, is_protected_manticore_id_column, normalize_default, original_comment, original_default, qualified_table,
+    quote_ident, quote_string,
+};
+use std::collections::HashSet;
+
+pub(super) fn build_column_sql(options: &TableStructureSqlOptions, warnings: &mut Vec<String>) -> Vec<String> {
+    let capabilities = capabilities_for(options.database_type);
+    let dialect = capabilities.dialect;
+    let table = qualified_table(dialect, options.schema.as_deref(), &options.table_name);
+    let database_label = database_label(options.database_type);
+    let active_columns: Vec<_> = options.columns.iter().filter(|column| !column.marked_for_drop).collect();
+    if is_oracle_like(dialect)
+        && active_columns.is_empty()
+        && options.columns.iter().any(|column| column.marked_for_drop)
+    {
+        warnings.push("Oracle does not allow dropping all columns from a table. Keep at least one column or drop the table instead.".to_string());
+        return Vec::new();
+    }
+    let has_original_column_positions = active_columns.iter().any(|column| column.original_position.is_some());
+    let mut simulated_column_order =
+        if has_original_column_positions { original_active_column_order(&active_columns) } else { Vec::new() };
+    // Pre-compute the minimal set of existing columns that really need an explicit move.
+    // For MySQL/ClickHouse we keep the largest already-ordered subset in place and only
+    // emit FIRST/AFTER SQL for columns outside that subset.
+    let reordered_existing_column_ids =
+        if has_original_column_positions && matches!(dialect, StructureDialect::Mysql | StructureDialect::ClickHouse) {
+            planned_existing_column_move_ids(&active_columns)
+        } else {
+            HashSet::new()
+        };
+    let mut statements = Vec::new();
+
+    for column in &options.columns {
+        if column.marked_for_drop {
+            let Some(original) = &column.original else {
+                continue;
+            };
+            if !capabilities.drop_column {
+                warnings.push(format!("Dropping columns is not supported for {database_label} from this editor."));
+                continue;
+            }
+            if original.is_primary_key {
+                warnings.push(format!("Primary key column \"{}\" cannot be dropped from this editor.", original.name));
+                continue;
+            }
+            if is_protected_manticore_id_column(dialect, &original.name) {
+                warnings.push("Manticore Search id column cannot be dropped from this editor.".to_string());
+                continue;
+            }
+            statements.push(build_drop_column_sql(dialect, &table, &original.name));
+            continue;
+        }
+
+        let active_index = active_columns.iter().position(|active| active.id == column.id).unwrap_or(0);
+        let position_clause = if has_original_column_positions {
+            column_position_clause(dialect, &active_columns, active_index)
+        } else {
+            String::new()
+        };
+        let desired_previous_column_id = active_previous_column_id(&active_columns, active_index);
+        // A position change only matters when this column is part of the planned move set
+        // and its predecessor still differs in the simulated order.
+        let has_position_change = has_original_column_positions
+            && matches!(dialect, StructureDialect::Mysql | StructureDialect::ClickHouse)
+            && reordered_existing_column_ids.contains(&column.id)
+            && column.original.is_some()
+            && column.original_position.is_some()
+            && simulated_column_position_changed(&simulated_column_order, &column.id, desired_previous_column_id);
+
+        if column.original.is_none() {
+            if !capabilities.add_column {
+                warnings.push(format!("Adding columns is not supported for {database_label} from this editor."));
+                continue;
+            }
+            if dialect == StructureDialect::SqlServer
+                && has_sqlserver_identity(column)
+                && !is_sqlserver_identity_compatible_type(&column.data_type)
+            {
+                warnings.push(format!(
+                    "SQL Server identity column \"{}\" must use tinyint, smallint, int, bigint, or decimal/numeric with scale 0.",
+                    column.name
+                ));
+                continue;
+            }
+            if dialect == StructureDialect::Dameng
+                && has_dameng_identity(column)
+                && !is_dameng_identity_compatible_type(&column.data_type)
+            {
+                warnings.push(format!(
+                    "Dameng identity column \"{}\" must use tinyint, smallint, int, integer, bigint, number, numeric, or decimal/dec with scale 0.",
+                    column.name
+                ));
+                continue;
+            }
+            statements.extend(build_add_column_sql(
+                dialect,
+                options.database_type,
+                &table,
+                column,
+                &position_clause,
+                options.schema.as_deref(),
+                &options.table_name,
+            ));
+            if has_original_column_positions
+                && matches!(dialect, StructureDialect::Mysql | StructureDialect::ClickHouse)
+            {
+                apply_simulated_column_position(&mut simulated_column_order, &column.id, desired_previous_column_id);
+            }
+            continue;
+        }
+
+        if !has_existing_column_attribute_change(column) && !has_column_extra_change(column) && !has_position_change {
+            continue;
+        }
+        let original = column.original.as_ref().unwrap();
+        let has_rename = column.name != original.name;
+        let has_attribute_change = column.data_type.trim() != original.data_type.trim()
+            || column.is_nullable != original.is_nullable
+            || normalize_default(Some(&column.default_value)) != original_default(column)
+            || clean(&column.comment) != original_comment(column)
+            || (is_mysql_character_data_type(&column.data_type)
+                && (column.character_set.trim() != original.character_set.as_deref().unwrap_or("")
+                    || column.collation.trim() != original.collation.as_deref().unwrap_or("")))
+            || has_column_extra_change(column);
+        if has_position_change && !capabilities.reorder_column {
+            warnings.push(format!("Reordering columns is not supported for {database_label} from this editor."));
+        }
+        if has_rename && !capabilities.rename_column {
+            warnings.push(format!("Renaming columns is not supported for {database_label} from this editor."));
+        }
+        if has_attribute_change && !capabilities.alter_existing_column && dialect != StructureDialect::Sqlite {
+            warnings.push(format!("Editing existing columns is not supported for {database_label} yet."));
+        }
+        if (has_position_change && !capabilities.reorder_column)
+            || (has_rename && !capabilities.rename_column)
+            || (has_attribute_change && !capabilities.alter_existing_column && dialect != StructureDialect::Sqlite)
+        {
+            continue;
+        }
+
+        match dialect {
+            StructureDialect::Mysql => statements.extend(build_mysql_existing_column_sql(
+                &table,
+                column,
+                if has_position_change { &position_clause } else { "" },
+            )),
+            StructureDialect::Doris => statements.extend(build_doris_existing_column_sql(&table, column, "")),
+            StructureDialect::Postgres => statements.extend(build_postgres_existing_column_sql(&table, column)),
+            StructureDialect::Oracle | StructureDialect::Dameng => {
+                statements.extend(build_oracle_like_existing_column_sql(dialect, &table, column))
+            }
+            StructureDialect::H2 => statements.extend(build_h2_existing_column_sql(&table, column)),
+            StructureDialect::ClickHouse => statements.extend(build_clickhouse_existing_column_sql(
+                &table,
+                column,
+                if has_position_change { &position_clause } else { "" },
+            )),
+            StructureDialect::Informix => statements.extend(build_informix_existing_column_sql(&table, column)),
+            StructureDialect::SqlServer => statements.extend(build_sqlserver_existing_column_sql(
+                &table,
+                column,
+                options.schema.as_deref(),
+                &options.table_name,
+                warnings,
+            )),
+            StructureDialect::Sqlite => statements.extend(build_sqlite_existing_column_sql(&table, column, warnings)),
+            StructureDialect::Questdb => statements.extend(build_questdb_existing_column_sql(&table, column)),
+            _ => warnings.push(format!("Editing existing columns is not supported for {database_label} yet.")),
+        }
+        if has_position_change {
+            apply_simulated_column_position(&mut simulated_column_order, &column.id, desired_previous_column_id);
+        }
+    }
+
+    // Emit primary key constraint changes after individual column changes
+    statements.extend(build_primary_key_sql(options, dialect, &table, warnings));
+
+    statements
+}
+
+pub(super) fn build_primary_key_sql(
+    options: &TableStructureSqlOptions,
+    dialect: StructureDialect,
+    table: &str,
+    warnings: &mut Vec<String>,
+) -> Vec<String> {
+    let capabilities = capabilities_for(options.database_type);
+
+    let old_pk_names: Vec<&str> = options
+        .columns
+        .iter()
+        .filter(|c| c.original.as_ref().is_some_and(|o| o.is_primary_key))
+        .map(|c| c.name.as_str())
+        .collect();
+
+    let new_pk_names: Vec<&str> =
+        options.columns.iter().filter(|c| !c.marked_for_drop && c.is_primary_key).map(|c| c.name.as_str()).collect();
+
+    if old_pk_names == new_pk_names {
+        return Vec::new();
+    }
+
+    if !capabilities.alter_primary_key {
+        warnings.push(format!(
+            "Changing primary keys is not supported for {} from this editor.",
+            database_label(options.database_type)
+        ));
+        return Vec::new();
+    }
+
+    let mut statements = Vec::new();
+
+    if !old_pk_names.is_empty() {
+        match dialect {
+            StructureDialect::Postgres => {
+                let raw_table = options.table_name.split('.').next_back().unwrap_or(&options.table_name);
+                let pk_name = format!("{}_pkey", clean(raw_table));
+                statements.push(format!("ALTER TABLE {table} DROP CONSTRAINT {};", quote_ident(dialect, &pk_name)));
+            }
+            StructureDialect::Mysql => {
+                statements.push(format!("ALTER TABLE {table} DROP PRIMARY KEY;"));
+            }
+            _ => {}
+        }
+    }
+
+    if !new_pk_names.is_empty() {
+        let pk_list = new_pk_names.iter().map(|n| quote_ident(dialect, n)).collect::<Vec<_>>().join(", ");
+        statements.push(format!("ALTER TABLE {table} ADD PRIMARY KEY ({pk_list});"));
+    }
+
+    statements
+}
+
+fn has_sqlserver_identity(column: &EditableStructureColumn) -> bool {
+    column.extra.as_ref().is_some_and(|extra| extra.auto_increment.unwrap_or(false) || extra.identity.is_some())
+}
+
+fn is_sqlserver_identity_compatible_type(data_type: &str) -> bool {
+    let trimmed = data_type.trim();
+    let (base_type, params) = match trimmed.find('(') {
+        Some(open_index) => {
+            let close_index = trimmed.rfind(')').unwrap_or(trimmed.len());
+            (&trimmed[..open_index], trimmed.get(open_index + 1..close_index).unwrap_or(""))
+        }
+        None => (trimmed, ""),
+    };
+    let normalized = base_type.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    if matches!(normalized.as_str(), "tinyint" | "smallint" | "int" | "integer" | "bigint") {
+        return true;
+    }
+    if !matches!(normalized.as_str(), "decimal" | "numeric") {
+        return false;
+    }
+    let normalized_params = params.split_whitespace().collect::<String>();
+    if normalized_params.is_empty() {
+        return true;
+    }
+    let parts = normalized_params.split(',').collect::<Vec<_>>();
+    match parts.as_slice() {
+        [precision] => precision.parse::<u32>().is_ok(),
+        [precision, scale] => precision.parse::<u32>().is_ok() && *scale == "0",
+        _ => false,
+    }
+}
+
+pub(super) fn build_add_column_sql(
+    dialect: StructureDialect,
+    database_type: Option<crate::models::connection::DatabaseType>,
+    table: &str,
+    column: &EditableStructureColumn,
+    position_clause: &str,
+    schema: Option<&str>,
+    table_name: &str,
+) -> Vec<String> {
+    let definition = column_definition(dialect, column);
+    let mut statements = if is_oracle_like(dialect) || dialect == StructureDialect::Informix {
+        vec![format!("ALTER TABLE {table} ADD ({definition});")]
+    } else {
+        let add_keyword = if dialect == StructureDialect::SqlServer
+            || database_type == Some(crate::models::connection::DatabaseType::Kingbase)
+        {
+            "ADD"
+        } else {
+            "ADD COLUMN"
+        };
+        vec![format!("ALTER TABLE {table} {add_keyword} {definition}{position_clause};")]
+    };
+    if matches!(dialect, StructureDialect::Postgres | StructureDialect::Oracle | StructureDialect::Dameng)
+        && !clean(&column.comment).is_empty()
+    {
+        statements.push(format!(
+            "COMMENT ON COLUMN {table}.{} IS {};",
+            quote_ident(dialect, &column.name),
+            quote_string(&clean(&column.comment))
+        ));
+    }
+    if dialect == StructureDialect::ClickHouse && !clean(&column.comment).is_empty() {
+        statements.push(format!(
+            "ALTER TABLE {table} COMMENT COLUMN {} {};",
+            quote_ident(dialect, &column.name),
+            quote_string(&clean(&column.comment))
+        ));
+    }
+    if dialect == StructureDialect::SqlServer && !clean(&column.comment).is_empty() {
+        statements.extend(build_sqlserver_column_comment_sql(table, schema, table_name, &column.name, &column.comment));
+    }
+    statements
+}
+
+pub(super) fn build_drop_column_sql(dialect: StructureDialect, table: &str, column_name: &str) -> String {
+    if dialect == StructureDialect::Informix {
+        return format!("ALTER TABLE {table} DROP ({});", quote_ident(dialect, column_name));
+    }
+    format!("ALTER TABLE {table} DROP COLUMN {};", quote_ident(dialect, column_name))
+}
+
+pub(super) fn column_position_clause(
+    dialect: StructureDialect,
+    columns: &[&EditableStructureColumn],
+    index: usize,
+) -> String {
+    if !matches!(dialect, StructureDialect::Mysql | StructureDialect::ClickHouse) {
+        return String::new();
+    }
+    if index == 0 {
+        return " FIRST".to_string();
+    }
+    format!(" AFTER {}", quote_ident(dialect, columns.get(index - 1).map(|column| column.name.as_str()).unwrap_or("")))
+}
+
+pub(super) fn original_active_column_order(columns: &[&EditableStructureColumn]) -> Vec<String> {
+    let mut original_columns: Vec<_> = columns
+        .iter()
+        .filter(|column| column.original.is_some() && column.original_position.is_some())
+        .copied()
+        .collect();
+    original_columns.sort_by_key(|column| column.original_position.unwrap_or(0));
+    original_columns.into_iter().map(|column| column.id.clone()).collect()
+}
+
+/// Returns the ids of existing columns that must be explicitly moved to reach the target order.
+///
+/// The function keeps the longest subsequence of existing columns whose relative order is already
+/// correct, and marks only the remaining columns for FIRST/AFTER reordering SQL.
+pub(super) fn planned_existing_column_move_ids(columns: &[&EditableStructureColumn]) -> HashSet<String> {
+    // Only existing columns with an original position participate in move planning.
+    // Newly added columns are positioned directly from the target order.
+    let reorderable_columns: Vec<_> = columns
+        .iter()
+        .filter_map(|column| {
+            column
+                .original
+                .as_ref()
+                .zip(column.original_position)
+                .map(|_| (column.id.as_str(), column.original_position.unwrap_or(0)))
+        })
+        .collect();
+    if reorderable_columns.len() < 2 {
+        return HashSet::new();
+    }
+
+    // Map the target order back to original positions, then keep the largest increasing subsequence.
+    let original_positions: Vec<_> = reorderable_columns.iter().map(|(_, position)| *position).collect();
+    // Columns inside the LIS can stay where they are; everything else needs an explicit move.
+    let kept_indices: HashSet<_> = longest_increasing_subsequence_indices(&original_positions).into_iter().collect();
+
+    reorderable_columns
+        .into_iter()
+        .enumerate()
+        .filter(|(index, _)| !kept_indices.contains(index))
+        .map(|(_, (column_id, _))| column_id.to_string())
+        .collect()
+}
+
+/// Returns the indices of one longest increasing subsequence within `values`.
+///
+/// In the reorder planner, an increasing subsequence represents existing columns whose relative
+/// order still matches the original table layout, so they can remain untouched.
+fn longest_increasing_subsequence_indices(values: &[usize]) -> Vec<usize> {
+    if values.is_empty() {
+        return Vec::new();
+    }
+
+    // O(n^2) is sufficient here because table editors deal with relatively small column counts
+    // and the simpler implementation is easier to maintain.
+    let mut lengths = vec![1; values.len()];
+    let mut previous = vec![None; values.len()];
+    let mut best_end_index = 0;
+
+    for current_index in 0..values.len() {
+        for previous_index in 0..current_index {
+            if values[previous_index] < values[current_index] && lengths[previous_index] + 1 > lengths[current_index] {
+                lengths[current_index] = lengths[previous_index] + 1;
+                previous[current_index] = Some(previous_index);
+            }
+        }
+
+        if lengths[current_index] > lengths[best_end_index] {
+            best_end_index = current_index;
+        }
+    }
+
+    // Reconstruct the subsequence by following the predecessor chain backwards.
+    let mut indices = Vec::new();
+    let mut cursor = Some(best_end_index);
+    while let Some(index) = cursor {
+        indices.push(index);
+        cursor = previous[index];
+    }
+    indices.reverse();
+    indices
+}
+
+pub(super) fn active_previous_column_id<'a>(columns: &[&'a EditableStructureColumn], index: usize) -> Option<&'a str> {
+    if index == 0 {
+        None
+    } else {
+        columns.get(index - 1).map(|column| column.id.as_str())
+    }
+}
+
+pub(super) fn simulated_column_position_changed(
+    simulated_column_order: &[String],
+    column_id: &str,
+    desired_previous_column_id: Option<&str>,
+) -> bool {
+    let Some(index) = simulated_column_order.iter().position(|id| id == column_id) else {
+        return false;
+    };
+    let current_previous_column_id = if index == 0 { None } else { Some(simulated_column_order[index - 1].as_str()) };
+    current_previous_column_id != desired_previous_column_id
+}
+
+pub(super) fn apply_simulated_column_position(
+    simulated_column_order: &mut Vec<String>,
+    column_id: &str,
+    desired_previous_column_id: Option<&str>,
+) {
+    if let Some(index) = simulated_column_order.iter().position(|id| id == column_id) {
+        simulated_column_order.remove(index);
+    }
+    let index = desired_previous_column_id
+        .and_then(|previous_id| simulated_column_order.iter().position(|id| id == previous_id).map(|index| index + 1))
+        .unwrap_or(0);
+    simulated_column_order.insert(index, column_id.to_string());
+}
diff --git a/crates/dbx-core/src/table_structure_sql/comments.rs b/crates/dbx-core/src/table_structure_sql/comments.rs
new file mode 100644
index 0000000..dfd3727
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/comments.rs
@@ -0,0 +1,125 @@
+use super::dialect::{capabilities_for, dialect_label, StructureDialect};
+use super::types::TableStructureSqlOptions;
+use super::util::{clean, qualified_table, quote_string};
+
+pub(super) fn build_table_comment_sql(options: &TableStructureSqlOptions, warnings: &mut Vec<String>) -> Vec<String> {
+    let capabilities = capabilities_for(options.database_type);
+    if !capabilities.comment {
+        return Vec::new();
+    }
+    let new_comment = options.table_comment.as_deref().unwrap_or("");
+    let original_comment = options.original_table_comment.as_deref().unwrap_or("");
+    if clean(new_comment) == clean(original_comment) {
+        return Vec::new();
+    }
+    let dialect = capabilities.dialect;
+    let table = qualified_table(dialect, options.schema.as_deref(), &options.table_name);
+    let quoted = quote_string(&clean(new_comment));
+    match dialect {
+        StructureDialect::Mysql => {
+            vec![format!("ALTER TABLE {table} COMMENT = {quoted};")]
+        }
+        StructureDialect::Postgres | StructureDialect::Oracle | StructureDialect::Dameng | StructureDialect::H2 => {
+            vec![format!("COMMENT ON TABLE {table} IS {quoted};")]
+        }
+        StructureDialect::ClickHouse => {
+            vec![format!("ALTER TABLE {table} MODIFY COMMENT {quoted};")]
+        }
+        StructureDialect::SqlServer => {
+            build_sqlserver_table_comment_sql(&table, options.schema.as_deref(), &options.table_name, new_comment)
+        }
+        _ => {
+            if !clean(new_comment).is_empty() {
+                warnings
+                    .push(format!("Table comments are not supported for {} from this editor.", dialect_label(dialect)));
+            }
+            Vec::new()
+        }
+    }
+}
+
+pub(super) fn sqlserver_schema_name(schema: Option<&str>) -> String {
+    schema.filter(|s| !s.trim().is_empty()).map(|s| s.trim().to_string()).unwrap_or_else(|| "dbo".to_string())
+}
+
+pub(super) fn build_sqlserver_table_comment_sql(
+    qualified_table: &str,
+    schema: Option<&str>,
+    table_name: &str,
+    new_comment: &str,
+) -> Vec<String> {
+    let mut statements = Vec::new();
+    let schema_name = sqlserver_schema_name(schema);
+    let escaped_qualified = qualified_table.replace('\'', "''");
+    let escaped_schema = schema_name.replace('\'', "''");
+    let escaped_table = table_name.replace('\'', "''");
+
+    statements.push(format!(
+        "IF EXISTS (SELECT 1 FROM sys.extended_properties WHERE major_id = OBJECT_ID(N'{escaped_qualified}') AND minor_id = 0 AND name = N'MS_Description') EXEC sys.sp_dropextendedproperty @name=N'MS_Description', @level0type=N'SCHEMA', @level0name=N'{escaped_schema}', @level1type=N'TABLE', @level1name=N'{escaped_table}';"
+    ));
+
+    if !clean(new_comment).is_empty() {
+        let quoted_comment = clean(new_comment).replace('\'', "''");
+        statements.push(format!(
+            "EXEC sys.sp_addextendedproperty @name=N'MS_Description', @value=N'{quoted_comment}', @level0type=N'SCHEMA', @level0name=N'{escaped_schema}', @level1type=N'TABLE', @level1name=N'{escaped_table}';"
+        ));
+    }
+
+    statements
+}
+
+pub(super) fn build_sqlserver_index_comment_sql(
+    qualified_table: &str,
+    schema: Option<&str>,
+    table_name: &str,
+    index_name: &str,
+    new_comment: &str,
+) -> Vec<String> {
+    let mut statements = Vec::new();
+    let schema_name = sqlserver_schema_name(schema);
+    let escaped_qualified = qualified_table.replace('\'', "''");
+    let escaped_schema = schema_name.replace('\'', "''");
+    let escaped_table = table_name.replace('\'', "''");
+    let escaped_idx = index_name.replace('\'', "''");
+
+    statements.push(format!(
+        "IF EXISTS (SELECT 1 FROM sys.extended_properties WHERE major_id = OBJECT_ID(N'{escaped_qualified}') AND minor_id = 0 AND name = N'MS_Description' AND class_desc = 'INDEX') EXEC sys.sp_dropextendedproperty @name=N'MS_Description', @level0type=N'SCHEMA', @level0name=N'{escaped_schema}', @level1type=N'TABLE', @level1name=N'{escaped_table}', @level2type=N'INDEX', @level2name=N'{escaped_idx}';"
+    ));
+
+    if !clean(new_comment).is_empty() {
+        let quoted_comment = clean(new_comment).replace('\'', "''");
+        statements.push(format!(
+            "EXEC sys.sp_addextendedproperty @name=N'MS_Description', @value=N'{quoted_comment}', @level0type=N'SCHEMA', @level0name=N'{escaped_schema}', @level1type=N'TABLE', @level1name=N'{escaped_table}', @level2type=N'INDEX', @level2name=N'{escaped_idx}';"
+        ));
+    }
+
+    statements
+}
+
+pub(super) fn build_sqlserver_column_comment_sql(
+    qualified_table: &str,
+    schema: Option<&str>,
+    table_name: &str,
+    column_name: &str,
+    new_comment: &str,
+) -> Vec<String> {
+    let mut statements = Vec::new();
+    let schema_name = sqlserver_schema_name(schema);
+    let escaped_qualified = qualified_table.replace('\'', "''");
+    let escaped_schema = schema_name.replace('\'', "''");
+    let escaped_table = table_name.replace('\'', "''");
+    let escaped_col = column_name.replace('\'', "''");
+
+    statements.push(format!(
+        "IF EXISTS (SELECT 1 FROM sys.extended_properties WHERE major_id = OBJECT_ID(N'{escaped_qualified}') AND minor_id = COLUMNPROPERTY(OBJECT_ID(N'{escaped_qualified}'), N'{escaped_col}', 'ColumnId') AND name = N'MS_Description') EXEC sys.sp_dropextendedproperty @name=N'MS_Description', @level0type=N'SCHEMA', @level0name=N'{escaped_schema}', @level1type=N'TABLE', @level1name=N'{escaped_table}', @level2type=N'COLUMN', @level2name=N'{escaped_col}';"
+    ));
+
+    if !clean(new_comment).is_empty() {
+        let quoted_comment = clean(new_comment).replace('\'', "''");
+        statements.push(format!(
+            "EXEC sys.sp_addextendedproperty @name=N'MS_Description', @value=N'{quoted_comment}', @level0type=N'SCHEMA', @level0name=N'{escaped_schema}', @level1type=N'TABLE', @level1name=N'{escaped_table}', @level2type=N'COLUMN', @level2name=N'{escaped_col}';"
+        ));
+    }
+
+    statements
+}
diff --git a/crates/dbx-core/src/table_structure_sql/create_table.rs b/crates/dbx-core/src/table_structure_sql/create_table.rs
new file mode 100644
index 0000000..f1e0fab
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/create_table.rs
@@ -0,0 +1,173 @@
+use super::column_format::{
+    column_data_type, column_extra_clause, has_dameng_identity, is_dameng_identity_compatible_type,
+};
+use super::comments::{build_sqlserver_column_comment_sql, build_sqlserver_table_comment_sql};
+use super::dialect::{capabilities_for, database_label, StructureDialect};
+use super::foreign_keys::build_foreign_key_sql;
+use super::indexes::build_create_index_statements;
+use super::triggers::build_trigger_sql;
+use super::types::{TableStructureSqlOptions, TableStructureSqlResult};
+use super::util::{clean, format_default_for_sql, normalize_default, qualified_table, quote_ident, quote_string};
+use super::validation::{validate_columns, validate_dameng_identity};
+
+pub fn build_create_table_sql(options: TableStructureSqlOptions) -> TableStructureSqlResult {
+    let mut warnings = Vec::new();
+    if clean(&options.table_name).is_empty() {
+        warnings.push("Table name is required.".to_string());
+    }
+    let active_columns: Vec<_> = options.columns.iter().filter(|column| !column.marked_for_drop).collect();
+    if active_columns.is_empty() {
+        warnings.push("At least one column is required.".to_string());
+    }
+    validate_columns(&active_columns, &mut warnings);
+    validate_dameng_identity(&options, &active_columns, &mut warnings);
+    if !warnings.is_empty() {
+        return TableStructureSqlResult { statements: Vec::new(), warnings };
+    }
+
+    let capabilities = capabilities_for(options.database_type);
+    let dialect = capabilities.dialect;
+    let table = qualified_table(dialect, options.schema.as_deref(), &options.table_name);
+    if dialect == StructureDialect::Dameng {
+        for column in &active_columns {
+            if has_dameng_identity(column) && !is_dameng_identity_compatible_type(&column.data_type) {
+                warnings.push(format!(
+                    "Dameng identity column \"{}\" must use tinyint, smallint, int, integer, bigint, number, numeric, or decimal/dec with scale 0.",
+                    column.name
+                ));
+            }
+        }
+        if !warnings.is_empty() {
+            return TableStructureSqlResult { statements: Vec::new(), warnings };
+        }
+    }
+    let mut statements = Vec::new();
+    let mut column_definitions = Vec::new();
+
+    for column in &active_columns {
+        let data_type = column_data_type(dialect, column);
+        let mut parts = vec![quote_ident(dialect, &column.name), data_type];
+        if !column.is_nullable
+            && !column.is_primary_key
+            && !matches!(dialect, StructureDialect::ClickHouse | StructureDialect::ManticoreSearch)
+        {
+            parts.push("NOT NULL".to_string());
+        }
+        if let Some(extra_clause) = column_extra_clause(dialect, column) {
+            parts.push(extra_clause);
+        }
+        let default_value = normalize_default(Some(&column.default_value));
+        if !default_value.is_empty() && dialect != StructureDialect::ManticoreSearch {
+            parts.push(format!("DEFAULT {}", format_default_for_sql(dialect, &column.data_type, &default_value)));
+        }
+        if let Some(on_update) = column.extra.as_ref().and_then(|e| e.on_update_current_timestamp).filter(|v| *v) {
+            if on_update && dialect == StructureDialect::Mysql {
+                parts.push("ON UPDATE CURRENT_TIMESTAMP".to_string());
+            }
+        }
+        if dialect == StructureDialect::Mysql && capabilities.comment && !clean(&column.comment).is_empty() {
+            parts.push(format!("COMMENT {}", quote_string(&clean(&column.comment))));
+        }
+        column_definitions.push(parts.join(" "));
+    }
+
+    let pk_columns: Vec<_> = active_columns
+        .iter()
+        .filter(|column| column.is_primary_key && dialect != StructureDialect::ManticoreSearch)
+        .collect();
+    if !pk_columns.is_empty() {
+        let pk_list = pk_columns.iter().map(|column| quote_ident(dialect, &column.name)).collect::<Vec<_>>().join(", ");
+        column_definitions.push(format!("PRIMARY KEY ({pk_list})"));
+    }
+
+    statements.push(format!("CREATE TABLE {table} (\n  {}\n);", column_definitions.join(",\n  ")));
+
+    if capabilities.comment {
+        let table_comment = clean(options.table_comment.as_deref().unwrap_or(""));
+        if !table_comment.is_empty() {
+            if dialect == StructureDialect::Mysql {
+                if let Some(last) = statements.last_mut() {
+                    *last = last.replace(");", &format!(") COMMENT = {};", quote_string(&table_comment)));
+                }
+            } else if matches!(
+                dialect,
+                StructureDialect::Postgres | StructureDialect::Oracle | StructureDialect::Dameng | StructureDialect::H2
+            ) {
+                statements.push(format!("COMMENT ON TABLE {table} IS {};", quote_string(&table_comment)));
+            } else if dialect == StructureDialect::ClickHouse {
+                statements.push(format!("ALTER TABLE {table} MODIFY COMMENT {};", quote_string(&table_comment)));
+            } else if dialect == StructureDialect::SqlServer {
+                statements.extend(build_sqlserver_table_comment_sql(
+                    &table,
+                    options.schema.as_deref(),
+                    &options.table_name,
+                    &table_comment,
+                ));
+            }
+        }
+    }
+
+    if capabilities.comment
+        && matches!(
+            dialect,
+            StructureDialect::Postgres | StructureDialect::Oracle | StructureDialect::Dameng | StructureDialect::H2
+        )
+    {
+        for column in &active_columns {
+            if !clean(&column.comment).is_empty() {
+                statements.push(format!(
+                    "COMMENT ON COLUMN {table}.{} IS {};",
+                    quote_ident(dialect, &column.name),
+                    quote_string(&clean(&column.comment))
+                ));
+            }
+        }
+    }
+    if capabilities.comment && dialect == StructureDialect::ClickHouse {
+        for column in &active_columns {
+            if !clean(&column.comment).is_empty() {
+                statements.push(format!(
+                    "ALTER TABLE {table} COMMENT COLUMN {} {};",
+                    quote_ident(dialect, &column.name),
+                    quote_string(&clean(&column.comment))
+                ));
+            }
+        }
+    }
+    if capabilities.comment && dialect == StructureDialect::SqlServer {
+        for column in &active_columns {
+            if !clean(&column.comment).is_empty() {
+                statements.extend(build_sqlserver_column_comment_sql(
+                    &table,
+                    options.schema.as_deref(),
+                    &options.table_name,
+                    &column.name,
+                    &column.comment,
+                ));
+            }
+        }
+    }
+
+    for index in options.indexes.iter().filter(|index| !index.marked_for_drop && !index.is_primary) {
+        if !capabilities.create_index {
+            warnings.push(format!(
+                "Creating indexes is not supported for {} from this editor.",
+                database_label(options.database_type)
+            ));
+            continue;
+        }
+        statements.extend(build_create_index_statements(
+            dialect,
+            &table,
+            index,
+            &mut warnings,
+            options.schema.as_deref(),
+            &options.table_name,
+        ));
+    }
+
+    statements.extend(build_foreign_key_sql(&options, &mut warnings));
+    statements.extend(build_trigger_sql(&options, &mut warnings));
+
+    TableStructureSqlResult { statements, warnings }
+}
diff --git a/crates/dbx-core/src/table_structure_sql/dialect.rs b/crates/dbx-core/src/table_structure_sql/dialect.rs
new file mode 100644
index 0000000..0b46190
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/dialect.rs
@@ -0,0 +1,329 @@
+use crate::models::connection::DatabaseType;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) enum StructureDialect {
+    Mysql,
+    Doris,
+    Postgres,
+    Sqlite,
+    #[cfg(feature = "duckdb-bundled")]
+    DuckDb,
+    SqlServer,
+    Oracle,
+    Dameng,
+    H2,
+    ClickHouse,
+    ManticoreSearch,
+    Informix,
+    Questdb,
+    Unsupported,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(super) struct TableStructureCapabilities {
+    pub(super) dialect: StructureDialect,
+    pub(super) add_column: bool,
+    pub(super) drop_column: bool,
+    pub(super) rename_column: bool,
+    pub(super) alter_existing_column: bool,
+    pub(super) reorder_column: bool,
+    pub(super) comment: bool,
+    pub(super) create_index: bool,
+    pub(super) drop_index: bool,
+    pub(super) rebuild_index: bool,
+    pub(super) index_type: bool,
+    pub(super) index_include: bool,
+    pub(super) index_filter: bool,
+    pub(super) index_comment: bool,
+    pub(super) alter_primary_key: bool,
+    pub(super) foreign_key: bool,
+}
+
+impl Default for TableStructureCapabilities {
+    fn default() -> Self {
+        Self {
+            dialect: StructureDialect::Unsupported,
+            add_column: false,
+            drop_column: false,
+            rename_column: false,
+            alter_existing_column: false,
+            reorder_column: false,
+            comment: false,
+            create_index: false,
+            drop_index: false,
+            rebuild_index: false,
+            index_type: false,
+            index_include: false,
+            index_filter: false,
+            index_comment: false,
+            alter_primary_key: false,
+            foreign_key: false,
+        }
+    }
+}
+
+pub(super) fn capabilities_for(database_type: Option<DatabaseType>) -> TableStructureCapabilities {
+    let base = TableStructureCapabilities::default();
+    match database_type {
+        Some(
+            DatabaseType::Mysql
+            | DatabaseType::StarRocks
+            | DatabaseType::Goldendb
+            | DatabaseType::Sundb
+            | DatabaseType::Databend,
+        ) => TableStructureCapabilities {
+            dialect: StructureDialect::Mysql,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            alter_existing_column: true,
+            reorder_column: true,
+            comment: true,
+            create_index: true,
+            drop_index: true,
+            rebuild_index: true,
+            index_type: true,
+            index_comment: true,
+            alter_primary_key: true,
+            foreign_key: true,
+            ..base
+        },
+        Some(DatabaseType::Doris) => TableStructureCapabilities {
+            dialect: StructureDialect::Doris,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            alter_existing_column: true,
+            comment: true,
+            ..base
+        },
+        Some(DatabaseType::Gbase) => TableStructureCapabilities {
+            dialect: StructureDialect::Mysql,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            reorder_column: true,
+            ..base
+        },
+        Some(
+            DatabaseType::Postgres
+            | DatabaseType::Gaussdb
+            | DatabaseType::Kwdb
+            | DatabaseType::OpenGauss
+            | DatabaseType::Highgo
+            | DatabaseType::Vastbase
+            | DatabaseType::Kingbase
+            | DatabaseType::Firebird,
+        ) => TableStructureCapabilities {
+            dialect: StructureDialect::Postgres,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            alter_existing_column: true,
+            comment: true,
+            create_index: true,
+            drop_index: true,
+            rebuild_index: true,
+            index_type: true,
+            index_include: true,
+            index_filter: true,
+            index_comment: true,
+            alter_primary_key: true,
+            foreign_key: true,
+            ..base
+        },
+        Some(DatabaseType::Questdb) => TableStructureCapabilities {
+            dialect: StructureDialect::Questdb,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            alter_existing_column: true,
+            reorder_column: false,
+            comment: false,
+            create_index: false,
+            drop_index: false,
+            rebuild_index: false,
+            index_type: false,
+            index_include: false,
+            index_filter: false,
+            index_comment: false,
+            alter_primary_key: false,
+            foreign_key: false,
+        },
+        Some(DatabaseType::Redshift | DatabaseType::Vertica) => TableStructureCapabilities {
+            dialect: StructureDialect::Postgres,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            alter_existing_column: true,
+            comment: true,
+            ..base
+        },
+        Some(DatabaseType::Sqlite | DatabaseType::Rqlite) => TableStructureCapabilities {
+            dialect: StructureDialect::Sqlite,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            create_index: true,
+            drop_index: true,
+            rebuild_index: true,
+            index_filter: true,
+            ..base
+        },
+        #[cfg(feature = "duckdb-bundled")]
+        Some(DatabaseType::DuckDb) => TableStructureCapabilities {
+            dialect: StructureDialect::DuckDb,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            create_index: true,
+            drop_index: true,
+            rebuild_index: true,
+            ..base
+        },
+        Some(DatabaseType::SqlServer) => TableStructureCapabilities {
+            dialect: StructureDialect::SqlServer,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            alter_existing_column: true,
+            comment: true,
+            create_index: true,
+            drop_index: true,
+            rebuild_index: true,
+            index_type: true,
+            index_include: true,
+            index_filter: true,
+            index_comment: true,
+            ..base
+        },
+        Some(DatabaseType::Dameng) => TableStructureCapabilities {
+            dialect: StructureDialect::Dameng,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            alter_existing_column: true,
+            comment: true,
+            create_index: true,
+            drop_index: true,
+            rebuild_index: true,
+            index_type: true,
+            ..base
+        },
+        Some(
+            DatabaseType::Oracle
+            | DatabaseType::OceanbaseOracle
+            | DatabaseType::Iris
+            | DatabaseType::Yashandb
+            | DatabaseType::Xugu,
+        ) => TableStructureCapabilities {
+            dialect: StructureDialect::Oracle,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            alter_existing_column: true,
+            comment: true,
+            create_index: true,
+            drop_index: true,
+            rebuild_index: true,
+            index_type: true,
+            ..base
+        },
+        Some(DatabaseType::H2) => TableStructureCapabilities {
+            dialect: StructureDialect::H2,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            alter_existing_column: true,
+            comment: true,
+            create_index: true,
+            drop_index: true,
+            rebuild_index: true,
+            ..base
+        },
+        Some(DatabaseType::ClickHouse) => TableStructureCapabilities {
+            dialect: StructureDialect::ClickHouse,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            alter_existing_column: true,
+            reorder_column: true,
+            comment: true,
+            ..base
+        },
+        Some(DatabaseType::ManticoreSearch) => TableStructureCapabilities {
+            dialect: StructureDialect::ManticoreSearch,
+            add_column: true,
+            drop_column: true,
+            ..base
+        },
+        Some(DatabaseType::Informix) => TableStructureCapabilities {
+            dialect: StructureDialect::Informix,
+            add_column: true,
+            drop_column: true,
+            rename_column: true,
+            alter_existing_column: true,
+            create_index: true,
+            drop_index: true,
+            rebuild_index: true,
+            ..base
+        },
+        _ => base,
+    }
+}
+
+pub(super) fn is_oracle_like(dialect: StructureDialect) -> bool {
+    matches!(dialect, StructureDialect::Oracle | StructureDialect::Dameng)
+}
+
+pub(super) fn database_label(database_type: Option<DatabaseType>) -> String {
+    database_type
+        .map(|database_type| {
+            serde_json::to_value(database_type)
+                .ok()
+                .and_then(|value| value.as_str().map(str::to_string))
+                .unwrap_or_else(|| "this database".to_string())
+        })
+        .unwrap_or_else(|| "this database".to_string())
+}
+
+pub(super) fn dialect_label(dialect: StructureDialect) -> String {
+    match dialect {
+        StructureDialect::Mysql => "mysql",
+        StructureDialect::Doris => "doris",
+        StructureDialect::Postgres => "postgres",
+        StructureDialect::Sqlite => "sqlite",
+        #[cfg(feature = "duckdb-bundled")]
+        StructureDialect::DuckDb => "duckdb",
+        StructureDialect::SqlServer => "sqlserver",
+        StructureDialect::Oracle => "oracle",
+        StructureDialect::Dameng => "dameng",
+        StructureDialect::H2 => "h2",
+        StructureDialect::ClickHouse => "clickhouse",
+        StructureDialect::ManticoreSearch => "manticoresearch",
+        StructureDialect::Informix => "informix",
+        StructureDialect::Questdb => "questdb",
+        StructureDialect::Unsupported => "this database",
+    }
+    .to_string()
+}
+
+pub(super) fn database_type_for_dialect(dialect: StructureDialect) -> Option<DatabaseType> {
+    match dialect {
+        StructureDialect::Mysql => Some(DatabaseType::Mysql),
+        StructureDialect::Doris => Some(DatabaseType::Doris),
+        StructureDialect::Postgres => Some(DatabaseType::Postgres),
+        StructureDialect::Sqlite => Some(DatabaseType::Sqlite),
+        #[cfg(feature = "duckdb-bundled")]
+        StructureDialect::DuckDb => Some(DatabaseType::DuckDb),
+        StructureDialect::SqlServer => Some(DatabaseType::SqlServer),
+        StructureDialect::Oracle => Some(DatabaseType::Oracle),
+        StructureDialect::Dameng => Some(DatabaseType::Dameng),
+        StructureDialect::H2 => Some(DatabaseType::H2),
+        StructureDialect::ClickHouse => Some(DatabaseType::ClickHouse),
+        StructureDialect::ManticoreSearch => Some(DatabaseType::ManticoreSearch),
+        StructureDialect::Informix => Some(DatabaseType::Informix),
+        StructureDialect::Questdb => Some(DatabaseType::Questdb),
+        StructureDialect::Unsupported => None,
+    }
+}
diff --git a/crates/dbx-core/src/table_structure_sql/foreign_keys.rs b/crates/dbx-core/src/table_structure_sql/foreign_keys.rs
new file mode 100644
index 0000000..ade00f7
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/foreign_keys.rs
@@ -0,0 +1,152 @@
+use super::dialect::{database_label, StructureDialect};
+use super::types::{EditableStructureForeignKey, ForeignKeyInfo, TableStructureSqlOptions};
+use super::util::{clean, qualified_table, quote_ident};
+
+pub(super) fn build_foreign_key_sql(options: &TableStructureSqlOptions, warnings: &mut Vec<String>) -> Vec<String> {
+    if options.foreign_keys.is_empty() {
+        return Vec::new();
+    }
+
+    let database_label = database_label(options.database_type);
+    let capabilities = super::dialect::capabilities_for(options.database_type);
+    let dialect = capabilities.dialect;
+    if !capabilities.foreign_key {
+        if has_foreign_key_edits(&options.foreign_keys) {
+            warnings.push(format!("Editing foreign keys is not supported for {database_label} from this editor."));
+        }
+        return Vec::new();
+    }
+
+    let table = qualified_table(dialect, options.schema.as_deref(), &options.table_name);
+    let mut statements = Vec::new();
+
+    for foreign_key in &options.foreign_keys {
+        if foreign_key.marked_for_drop {
+            if let Some(original) = &foreign_key.original {
+                statements.push(drop_foreign_key_sql(dialect, &table, &original.name));
+            }
+            continue;
+        }
+
+        if let Some(original) = &foreign_key.original {
+            if !has_foreign_key_change(foreign_key, original) {
+                continue;
+            }
+            statements.push(drop_foreign_key_sql(dialect, &table, &original.name));
+        }
+
+        if let Some(sql) = create_foreign_key_sql(dialect, &table, foreign_key, warnings) {
+            statements.push(sql);
+        }
+    }
+
+    statements
+}
+
+fn has_foreign_key_edits(foreign_keys: &[EditableStructureForeignKey]) -> bool {
+    foreign_keys.iter().any(|foreign_key| {
+        if foreign_key.marked_for_drop {
+            return foreign_key.original.is_some();
+        }
+
+        match &foreign_key.original {
+            Some(original) => has_foreign_key_change(foreign_key, original),
+            None => has_foreign_key_definition(foreign_key),
+        }
+    })
+}
+
+fn has_foreign_key_definition(foreign_key: &EditableStructureForeignKey) -> bool {
+    !clean(&foreign_key.name).is_empty()
+        || !clean(&foreign_key.column).is_empty()
+        || !clean(&foreign_key.ref_schema).is_empty()
+        || !clean(&foreign_key.ref_table).is_empty()
+        || !clean(&foreign_key.ref_column).is_empty()
+        || !clean(&foreign_key.on_update).is_empty()
+        || !clean(&foreign_key.on_delete).is_empty()
+}
+
+fn has_foreign_key_change(foreign_key: &EditableStructureForeignKey, original: &ForeignKeyInfo) -> bool {
+    clean(&foreign_key.name) != clean(&original.name)
+        || clean(&foreign_key.column) != clean(&original.column)
+        || clean(&foreign_key.ref_schema) != clean(original.ref_schema.as_deref().unwrap_or(""))
+        || clean(&foreign_key.ref_table) != clean(&original.ref_table)
+        || clean(&foreign_key.ref_column) != clean(&original.ref_column)
+        || normalize_action(&foreign_key.on_update) != normalize_action(original.on_update.as_deref().unwrap_or(""))
+        || normalize_action(&foreign_key.on_delete) != normalize_action(original.on_delete.as_deref().unwrap_or(""))
+}
+
+fn drop_foreign_key_sql(dialect: StructureDialect, table: &str, name: &str) -> String {
+    match dialect {
+        StructureDialect::Mysql => format!("ALTER TABLE {table} DROP FOREIGN KEY {};", quote_ident(dialect, name)),
+        StructureDialect::Postgres => format!("ALTER TABLE {table} DROP CONSTRAINT {};", quote_ident(dialect, name)),
+        _ => unreachable!("foreign key SQL requested for unsupported dialect"),
+    }
+}
+
+fn create_foreign_key_sql(
+    dialect: StructureDialect,
+    table: &str,
+    foreign_key: &EditableStructureForeignKey,
+    warnings: &mut Vec<String>,
+) -> Option<String> {
+    let name = clean(&foreign_key.name);
+    let columns = identifier_list(&foreign_key.column);
+    let ref_table = clean(&foreign_key.ref_table);
+    let ref_columns = identifier_list(&foreign_key.ref_column);
+    if name.is_empty() || columns.is_empty() || ref_table.is_empty() || ref_columns.is_empty() {
+        warnings.push("Foreign key name, column, referenced table, and referenced column are required.".to_string());
+        return None;
+    }
+    if columns.len() != ref_columns.len() {
+        warnings.push(format!("Foreign key \"{name}\" must have the same number of local and referenced columns."));
+        return None;
+    }
+
+    let ref_target = if clean(&foreign_key.ref_schema).is_empty() {
+        quote_ident(dialect, &ref_table)
+    } else {
+        format!("{}.{}", quote_ident(dialect, &foreign_key.ref_schema), quote_ident(dialect, &ref_table))
+    };
+
+    let mut sql = format!(
+        "ALTER TABLE {table} ADD CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {ref_target} ({}",
+        quote_ident(dialect, &name),
+        columns.iter().map(|column| quote_ident(dialect, column)).collect::<Vec<_>>().join(", "),
+        ref_columns.iter().map(|column| quote_ident(dialect, column)).collect::<Vec<_>>().join(", ")
+    );
+    sql.push(')');
+
+    if let Some(action) = action_clause("ON DELETE", &foreign_key.on_delete, warnings) {
+        sql.push(' ');
+        sql.push_str(&action);
+    }
+    if let Some(action) = action_clause("ON UPDATE", &foreign_key.on_update, warnings) {
+        sql.push(' ');
+        sql.push_str(&action);
+    }
+    sql.push(';');
+    Some(sql)
+}
+
+fn action_clause(prefix: &str, value: &str, warnings: &mut Vec<String>) -> Option<String> {
+    let action = normalize_action(value);
+    if action.is_empty() {
+        return None;
+    }
+    match action.as_str() {
+        "CASCADE" | "SET NULL" | "RESTRICT" | "NO ACTION" => Some(format!("{prefix} {action}")),
+        _ => {
+            warnings.push(format!("Unsupported foreign key action \"{}\".", clean(value)));
+            None
+        }
+    }
+}
+
+fn normalize_action(value: &str) -> String {
+    clean(value).split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_uppercase()
+}
+
+fn identifier_list(value: &str) -> Vec<String> {
+    value.split(',').map(clean).filter(|value| !value.is_empty()).collect()
+}
diff --git a/crates/dbx-core/src/table_structure_sql/indexes.rs b/crates/dbx-core/src/table_structure_sql/indexes.rs
new file mode 100644
index 0000000..da183eb
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/indexes.rs
@@ -0,0 +1,226 @@
+use super::comments::build_sqlserver_index_comment_sql;
+use super::dialect::{capabilities_for, database_label, database_type_for_dialect, dialect_label, StructureDialect};
+use super::types::{EditableStructureIndex, TableStructureSqlOptions};
+use super::util::{clean, qualified_table, quote_ident, quote_string};
+use crate::models::connection::DatabaseType;
+
+pub(super) fn build_index_sql(options: &TableStructureSqlOptions, warnings: &mut Vec<String>) -> Vec<String> {
+    let capabilities = capabilities_for(options.database_type);
+    let dialect = capabilities.dialect;
+    let table = qualified_table(dialect, options.schema.as_deref(), &options.table_name);
+    let database_label = database_label(options.database_type);
+    let mut statements = Vec::new();
+
+    for index in &options.indexes {
+        if index.marked_for_drop {
+            let Some(original) = &index.original else {
+                continue;
+            };
+            if !capabilities.drop_index {
+                warnings.push(format!("Dropping indexes is not supported for {database_label} from this editor."));
+                continue;
+            }
+            if original.is_primary {
+                warnings.push(format!("Primary index \"{}\" cannot be dropped from this editor.", original.name));
+                continue;
+            }
+            statements.push(build_drop_index_sql(
+                options.database_type,
+                dialect,
+                &table,
+                options.schema.as_deref(),
+                &original.name,
+            ));
+            continue;
+        }
+
+        if let Some(original) = &index.original {
+            if !has_existing_index_change(index) {
+                continue;
+            }
+            if !capabilities.rebuild_index || !capabilities.drop_index || !capabilities.create_index {
+                warnings
+                    .push(format!("Editing existing indexes is not supported for {database_label} from this editor."));
+                continue;
+            }
+            if original.is_primary {
+                warnings.push(format!("Primary index \"{}\" cannot be edited from this editor.", original.name));
+                continue;
+            }
+            statements.push(build_drop_index_sql(
+                options.database_type,
+                dialect,
+                &table,
+                options.schema.as_deref(),
+                &original.name,
+            ));
+            statements.extend(build_create_index_statements(
+                dialect,
+                &table,
+                index,
+                warnings,
+                options.schema.as_deref(),
+                &options.table_name,
+            ));
+            continue;
+        }
+
+        if !capabilities.create_index {
+            warnings.push(format!("Creating indexes is not supported for {database_label} from this editor."));
+            continue;
+        }
+        statements.extend(build_create_index_statements(
+            dialect,
+            &table,
+            index,
+            warnings,
+            options.schema.as_deref(),
+            &options.table_name,
+        ));
+    }
+
+    statements
+}
+
+pub(super) fn has_existing_index_change(index: &EditableStructureIndex) -> bool {
+    let Some(original) = &index.original else {
+        return false;
+    };
+    clean(&index.name) != clean(&original.name)
+        || index_list_changed(&index.columns, Some(&original.columns))
+        || index.is_unique != original.is_unique
+        || normalized_index_type(index) != clean(original.index_type.as_deref().unwrap_or("")).to_ascii_uppercase()
+        || index_list_changed(&index.included_columns, original.included_columns.as_ref())
+        || clean(&index.filter) != clean(original.filter.as_deref().unwrap_or(""))
+        || clean(&index.comment) != clean(original.comment.as_deref().unwrap_or(""))
+}
+
+pub(super) fn index_list_changed(next: &[String], previous: Option<&Vec<String>>) -> bool {
+    let next_clean: Vec<_> = next.iter().map(|value| clean(value)).filter(|value| !value.is_empty()).collect();
+    let previous_clean: Vec<_> =
+        previous.unwrap_or(&Vec::new()).iter().map(|value| clean(value)).filter(|value| !value.is_empty()).collect();
+    next_clean.len() != previous_clean.len()
+        || next_clean.iter().enumerate().any(|(index, value)| previous_clean.get(index) != Some(value))
+}
+
+pub(super) fn normalized_index_type(index: &EditableStructureIndex) -> String {
+    clean(&index.index_type).to_ascii_uppercase()
+}
+
+pub(super) fn mysql_index_parts(index_type: &str) -> (String, String) {
+    match index_type.to_ascii_uppercase().as_str() {
+        "FULLTEXT" | "SPATIAL" => (format!("{} ", index_type.to_ascii_uppercase()), String::new()),
+        "RTREE" => ("SPATIAL ".to_string(), String::new()),
+        "BTREE" | "HASH" => (String::new(), format!(" USING {}", index_type.to_ascii_uppercase())),
+        _ => (String::new(), String::new()),
+    }
+}
+
+pub(super) fn build_drop_index_sql(
+    database_type: Option<DatabaseType>,
+    dialect: StructureDialect,
+    table: &str,
+    schema: Option<&str>,
+    index_name: &str,
+) -> String {
+    if database_type == Some(DatabaseType::Iris) {
+        return format!("DROP INDEX {} ON TABLE {table};", quote_ident(dialect, index_name));
+    }
+    if matches!(dialect, StructureDialect::Mysql | StructureDialect::SqlServer) {
+        return format!("DROP INDEX {} ON {table};", quote_ident(dialect, index_name));
+    }
+    if matches!(
+        dialect,
+        StructureDialect::Postgres | StructureDialect::Oracle | StructureDialect::Dameng | StructureDialect::Informix
+    ) && schema.is_some_and(|schema| !schema.trim().is_empty())
+    {
+        return format!("DROP INDEX {}.{};", quote_ident(dialect, schema.unwrap()), quote_ident(dialect, index_name));
+    }
+    format!("DROP INDEX {};", quote_ident(dialect, index_name))
+}
+
+pub(super) fn build_create_index_statements(
+    dialect: StructureDialect,
+    table: &str,
+    index: &EditableStructureIndex,
+    warnings: &mut Vec<String>,
+    schema: Option<&str>,
+    table_name: &str,
+) -> Vec<String> {
+    let capabilities = capabilities_for(database_type_for_dialect(dialect));
+    let name = clean(&index.name);
+    let columns: Vec<String> =
+        index.columns.iter().map(|column| clean(column)).filter(|column| !column.is_empty()).collect();
+    if name.is_empty() || columns.is_empty() {
+        return Vec::new();
+    }
+
+    let unique = if index.is_unique { "UNIQUE " } else { "" };
+    let cols = columns.iter().map(|column| quote_ident(dialect, column)).collect::<Vec<_>>().join(", ");
+    let idx_type = normalized_index_type(index);
+    let mut type_prefix = String::new();
+    let mut using_clause = String::new();
+
+    if !idx_type.is_empty() && capabilities.index_type {
+        match dialect {
+            StructureDialect::Postgres => using_clause = format!(" USING {idx_type}"),
+            StructureDialect::SqlServer => type_prefix = format!("{idx_type} "),
+            StructureDialect::Mysql => {
+                let (prefix, using) = mysql_index_parts(&idx_type);
+                type_prefix = prefix;
+                using_clause = using;
+            }
+            StructureDialect::Oracle | StructureDialect::Dameng if idx_type == "BITMAP" => {
+                type_prefix = "BITMAP ".to_string()
+            }
+            _ => {}
+        }
+    }
+
+    let included_columns: Vec<String> =
+        index.included_columns.iter().map(|column| clean(column)).filter(|column| !column.is_empty()).collect();
+    let include_clause = if !included_columns.is_empty()
+        && capabilities.index_include
+        && matches!(dialect, StructureDialect::Postgres | StructureDialect::SqlServer)
+    {
+        format!(
+            " INCLUDE ({})",
+            included_columns.iter().map(|column| quote_ident(dialect, column)).collect::<Vec<_>>().join(", ")
+        )
+    } else {
+        String::new()
+    };
+    let comment = clean(&index.comment);
+    let comment_clause = if !comment.is_empty() && capabilities.index_comment && dialect == StructureDialect::Mysql {
+        format!(" COMMENT {}", quote_string(&comment))
+    } else {
+        String::new()
+    };
+    let filter = clean(&index.filter);
+    let supports_where = capabilities.index_filter
+        && matches!(dialect, StructureDialect::Postgres | StructureDialect::SqlServer | StructureDialect::Sqlite);
+    let where_clause = if !filter.is_empty() && supports_where { format!(" WHERE {filter}") } else { String::new() };
+    let create_sql = if dialect == StructureDialect::Postgres {
+        format!(
+            "CREATE {unique}{type_prefix}INDEX {} ON {table}{using_clause} ({cols}){include_clause}{where_clause};",
+            quote_ident(dialect, &name)
+        )
+    } else {
+        format!(
+            "CREATE {unique}{type_prefix}INDEX {}{using_clause} ON {table} ({cols}){include_clause}{where_clause}{comment_clause};",
+            quote_ident(dialect, &name)
+        )
+    };
+    let mut statements = vec![create_sql];
+
+    if !comment.is_empty() && capabilities.index_comment && dialect == StructureDialect::Postgres {
+        statements.push(format!("COMMENT ON INDEX {} IS {};", quote_ident(dialect, &name), quote_string(&comment)));
+    } else if !comment.is_empty() && capabilities.index_comment && dialect == StructureDialect::SqlServer {
+        statements.extend(build_sqlserver_index_comment_sql(table, schema, table_name, &name, &comment));
+    } else if !comment.is_empty() && capabilities.index_comment && dialect == StructureDialect::Mysql {
+        // MySQL comment is embedded inline in the CREATE INDEX statement above
+    } else if !comment.is_empty() && capabilities.index_comment {
+        warnings.push(format!("Index comments are not supported for {} from this editor.", dialect_label(dialect)));
+    }
+    statements
+}
diff --git a/crates/dbx-core/src/table_structure_sql/sqlite_rebuild.rs b/crates/dbx-core/src/table_structure_sql/sqlite_rebuild.rs
new file mode 100644
index 0000000..6d89044
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/sqlite_rebuild.rs
@@ -0,0 +1,2004 @@
+use std::collections::{BTreeMap, HashSet};
+use std::time::Instant;
+
+use rusqlite::{Connection, OptionalExtension};
+use sha2::{Digest, Sha256};
+
+use super::indexes::has_existing_index_change;
+use super::types::{SqliteTableStructurePreview, TableStructureSqlOptions};
+use super::util::{clean, normalize_default, original_comment, original_default};
+use crate::connection::{AppState, PoolKind};
+use crate::db;
+use crate::models::connection::DatabaseType;
+
+#[derive(Debug, Clone)]
+struct SqliteColumnSnapshot {
+    cid: i64,
+    name: String,
+    data_type: String,
+    not_null: bool,
+    default_value: Option<String>,
+    primary_key_order: i64,
+    hidden: i64,
+}
+
+#[derive(Debug, Clone)]
+struct SqliteDependency {
+    kind: String,
+    name: String,
+    sql: String,
+}
+
+#[derive(Debug, Clone)]
+struct SqliteSchemaSnapshot {
+    schema: String,
+    table_name: String,
+    table_sql: String,
+    table_kind: String,
+    columns: Vec<SqliteColumnSnapshot>,
+    dependencies: Vec<SqliteDependency>,
+    schema_version: i64,
+    autoincrement_sequence: Option<i64>,
+    revision: String,
+}
+
+struct SqliteChangePlan {
+    preview: SqliteTableStructurePreview,
+    executable_statements: Vec<String>,
+    schema: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+struct SqliteForeignKeyViolation {
+    table: String,
+    rowid: Option<i64>,
+    parent: String,
+    foreign_key_id: i64,
+}
+
+pub async fn preview_sqlite_table_structure_change(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    options: TableStructureSqlOptions,
+) -> Result<SqliteTableStructurePreview, String> {
+    let (_, pool) = native_sqlite_pool(state, connection_id, database).await?;
+    preview_sqlite_table_structure_change_with_pool(pool, options).await
+}
+
+pub async fn apply_sqlite_table_structure_change(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    options: TableStructureSqlOptions,
+    schema_revision: &str,
+) -> Result<db::QueryResult, String> {
+    let (pool_key, pool) = native_sqlite_pool(state, connection_id, database).await?;
+    crate::query::check_read_only_for_connection(state, &pool_key, "ALTER TABLE").await?;
+    apply_sqlite_table_structure_change_with_pool(pool, options, schema_revision).await
+}
+
+async fn native_sqlite_pool(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+) -> Result<(String, db::sqlite::SqliteHandle), String> {
+    let database = (!database.trim().is_empty()).then_some(database);
+    let pool_key = state.get_or_create_pool(connection_id, database).await?;
+    let connections = state.connections.read().await;
+    match connections.get(&pool_key) {
+        Some(PoolKind::Sqlite(pool)) => Ok((pool_key, pool.clone())),
+        Some(_) => Err("SQLite table rebuild is only available for native SQLite connections.".to_string()),
+        None => Err("SQLite connection pool not found.".to_string()),
+    }
+}
+
+async fn preview_sqlite_table_structure_change_with_pool(
+    pool: db::sqlite::SqliteHandle,
+    options: TableStructureSqlOptions,
+) -> Result<SqliteTableStructurePreview, String> {
+    tokio::task::spawn_blocking(move || {
+        pool.with_connection(|conn| build_change_plan(conn, &options).map(|p| p.preview))
+    })
+    .await
+    .map_err(|error| error.to_string())?
+}
+
+async fn apply_sqlite_table_structure_change_with_pool(
+    pool: db::sqlite::SqliteHandle,
+    options: TableStructureSqlOptions,
+    expected_revision: &str,
+) -> Result<db::QueryResult, String> {
+    let expected_revision = expected_revision.to_string();
+    tokio::task::spawn_blocking(move || {
+        pool.with_connection(|conn| {
+            if !conn.is_autocommit() {
+                return Err("SQLite already has an active transaction; finish it before applying structure changes."
+                    .to_string());
+            }
+
+            execute_change_transaction(conn, &options, &expected_revision)
+        })
+    })
+    .await
+    .map_err(|error| error.to_string())?
+}
+
+fn build_change_plan(conn: &mut Connection, options: &TableStructureSqlOptions) -> Result<SqliteChangePlan, String> {
+    if options.database_type.is_some_and(|database_type| database_type != DatabaseType::Sqlite) {
+        return Err("SQLite table rebuild requires databaseType=sqlite.".to_string());
+    }
+    let schema = options.schema.as_deref().map(str::trim).filter(|schema| !schema.is_empty()).unwrap_or("main");
+    if !schema.eq_ignore_ascii_case("main") {
+        return Err("SQLite table rebuild currently supports the native main schema only.".to_string());
+    }
+    if options.table_name.trim().is_empty() {
+        return Err("SQLite table name cannot be empty.".to_string());
+    }
+
+    let snapshot = load_schema_snapshot(conn, schema, &options.table_name)?;
+    let mut warnings = super::validation::validate_draft(options);
+    let mut type_changes = BTreeMap::new();
+    let live_columns =
+        snapshot.columns.iter().map(|column| (column.name.to_ascii_lowercase(), column)).collect::<BTreeMap<_, _>>();
+
+    for column in options.columns.iter().filter(|column| !column.marked_for_drop) {
+        let Some(original) = &column.original else {
+            validate_declared_type(&column.data_type)
+                .map_err(|error| format!("Column \"{}\": {error}", column.name))?;
+            continue;
+        };
+        let Some(live) = live_columns.get(&original.name.to_ascii_lowercase()) else {
+            warnings.push(format!(
+                "Column \"{}\" no longer exists in the live SQLite table. Refresh the structure before applying changes.",
+                original.name
+            ));
+            continue;
+        };
+        if normalize_type_name(&live.data_type) != normalize_type_name(&original.data_type) {
+            warnings.push(format!(
+                "Column \"{}\" changed in SQLite after this editor was opened. Refresh the structure before applying changes.",
+                original.name
+            ));
+            continue;
+        }
+
+        let has_type_change = normalize_type_name(&column.data_type) != normalize_type_name(&original.data_type);
+        if has_type_change {
+            validate_declared_type(&column.data_type)
+                .map_err(|error| format!("Column \"{}\": {error}", column.name))?;
+            let primary_key_columns = snapshot.columns.iter().filter(|column| column.primary_key_order > 0).count();
+            let changes_integer_primary_key_alias = live.primary_key_order > 0
+                && primary_key_columns == 1
+                && !snapshot_is_without_rowid(&snapshot)?
+                && (normalize_type_name(&live.data_type) == "integer"
+                    || normalize_type_name(&column.data_type) == "integer");
+            if changes_integer_primary_key_alias {
+                warnings.push(format!(
+                    "Changing the declared type of primary key column \"{}\" to or from INTEGER can change SQLite rowid alias semantics and is blocked.",
+                    original.name
+                ));
+            }
+            if type_changes.insert(original.name.to_ascii_lowercase(), column.data_type.trim().to_string()).is_some() {
+                warnings.push(format!("Column \"{}\" appears more than once in the structure draft.", original.name));
+            }
+        }
+
+        let has_non_type_attribute_change = column.is_nullable != original.is_nullable
+            || normalize_default(Some(&column.default_value)) != original_default(column)
+            || clean(&column.comment) != original_comment(column);
+        if has_non_type_attribute_change {
+            warnings.push(format!(
+                "SQLite rebuild currently supports changing the declared type of existing column \"{}\", but not its nullability, default, or comment.",
+                original.name
+            ));
+        }
+    }
+
+    if has_trigger_edits(options) {
+        warnings.push("Editing SQLite triggers is not supported by this structure workflow.".to_string());
+    }
+    if type_changes.is_empty() {
+        warnings.push(
+            "No existing SQLite column type change was detected; use the standard table structure path for other edits."
+                .to_string(),
+        );
+    }
+
+    let replaced_index_names = options
+        .indexes
+        .iter()
+        .filter_map(|index| {
+            let original = index.original.as_ref()?;
+            (index.marked_for_drop || has_existing_index_change(index)).then(|| original.name.to_ascii_lowercase())
+        })
+        .collect::<HashSet<_>>();
+
+    let mut generic_options = options.clone();
+    generic_options.database_type = Some(DatabaseType::Sqlite);
+    generic_options.schema = None;
+    generic_options.triggers.clear();
+    for column in &mut generic_options.columns {
+        if let Some(original) = &column.original {
+            if normalize_type_name(&column.data_type) != normalize_type_name(&original.data_type) {
+                column.data_type = original.data_type.clone();
+            }
+        }
+    }
+    // The rebuild drops every named index from the migration source. Unchanged indexes are
+    // restored from sqlite_schema; edited indexes are recreated directly in their final form;
+    // dropped indexes need no follow-up DROP statement.
+    generic_options.indexes = options
+        .indexes
+        .iter()
+        .filter_map(|index| {
+            if index.marked_for_drop {
+                return None;
+            }
+            match &index.original {
+                Some(_) if has_existing_index_change(index) => {
+                    let mut replacement = index.clone();
+                    replacement.original = None;
+                    Some(replacement)
+                }
+                Some(_) => None,
+                None => Some(index.clone()),
+            }
+        })
+        .collect();
+    let generic_result = super::build_table_structure_change_sql(generic_options);
+    warnings.extend(generic_result.warnings);
+    deduplicate_warnings(&mut warnings);
+
+    let mut executable_statements = Vec::new();
+    if !type_changes.is_empty() {
+        if snapshot.table_sql.trim_start().to_ascii_uppercase().starts_with("CREATE VIRTUAL TABLE") {
+            warnings.push("SQLite virtual tables cannot be rebuilt by the table structure editor.".to_string());
+        } else {
+            if hidden_rowid_is_shadowed(&snapshot)? {
+                warnings.push(
+                    "SQLite cannot preserve the hidden rowid because columns named rowid, _rowid_, and oid all exist."
+                        .to_string(),
+                );
+            }
+            if !snapshot.dependencies.is_empty()
+                && options.columns.iter().any(|column| column.marked_for_drop && column.original.is_some())
+            {
+                warnings.push(
+                    "Drop dependent indexes or triggers separately before combining a SQLite column drop with a type rebuild."
+                        .to_string(),
+                );
+            }
+            executable_statements.extend(build_rebuild_statements(
+                conn,
+                &snapshot,
+                &type_changes,
+                &replaced_index_names,
+            )?);
+        }
+    }
+    executable_statements.extend(generic_result.statements);
+
+    let foreign_keys_enabled: i64 = conn
+        .pragma_query_value(None, "foreign_keys", |row| row.get(0))
+        .map_err(|error| format!("Failed to read SQLite foreign_keys state: {error}"))?;
+    let legacy_alter_table_enabled: i64 = conn
+        .pragma_query_value(None, "legacy_alter_table", |row| row.get(0))
+        .map_err(|error| format!("Failed to read SQLite legacy_alter_table state: {error}"))?;
+    let mut preview_statements = Vec::new();
+    if !executable_statements.is_empty() {
+        preview_statements.push("PRAGMA foreign_keys = OFF;".to_string());
+        preview_statements.push("PRAGMA legacy_alter_table = ON;".to_string());
+        preview_statements.push("BEGIN IMMEDIATE;".to_string());
+        preview_statements.push(
+            "-- Record this baseline before the rebuild; existing rows do not block the change unless their count increases."
+                .to_string(),
+        );
+        preview_statements.push(format!("PRAGMA {}.foreign_key_check;", quote_ident(&snapshot.schema)));
+        preview_statements.extend(executable_statements.iter().cloned());
+        preview_statements.push(
+            "-- Compare this result with the baseline and ROLLBACK only for new or additional violations.".to_string(),
+        );
+        preview_statements.push(format!("PRAGMA {}.foreign_key_check;", quote_ident(&snapshot.schema)));
+        preview_statements.push("COMMIT;".to_string());
+        preview_statements.push(format!(
+            "PRAGMA legacy_alter_table = {};",
+            if legacy_alter_table_enabled != 0 { "ON" } else { "OFF" }
+        ));
+        preview_statements
+            .push(format!("PRAGMA foreign_keys = {};", if foreign_keys_enabled != 0 { "ON" } else { "OFF" }));
+    }
+
+    let plan_revision = plan_revision(&snapshot.revision, options, &executable_statements)?;
+    Ok(SqliteChangePlan {
+        preview: SqliteTableStructurePreview {
+            statements: preview_statements,
+            warnings,
+            schema_revision: plan_revision,
+        },
+        executable_statements,
+        schema: snapshot.schema,
+    })
+}
+
+fn load_schema_snapshot(conn: &Connection, schema: &str, table_name: &str) -> Result<SqliteSchemaSnapshot, String> {
+    let schema_ident = quote_ident(schema);
+    let mut table_list_statement = conn
+        .prepare(&format!("PRAGMA {schema_ident}.table_list"))
+        .map_err(|error| format!("Failed to inspect SQLite table kind: {error}"))?;
+    let table_kind = table_list_statement
+        .query_map([], |row| Ok((row.get::<_, String>("name")?, row.get::<_, String>("type")?)))
+        .map_err(|error| format!("Failed to inspect SQLite table kind: {error}"))?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|error| format!("Failed to inspect SQLite table kind: {error}"))?
+        .into_iter()
+        .find(|(name, _)| name == table_name)
+        .map(|(_, kind)| kind)
+        .ok_or_else(|| format!("SQLite table \"{table_name}\" was not found."))?;
+    drop(table_list_statement);
+    if table_kind != "table" {
+        return Err(format!(
+            "SQLite object \"{table_name}\" has table_list type \"{table_kind}\" and cannot be rebuilt safely."
+        ));
+    }
+    let table_record = conn
+        .query_row(
+            &format!("SELECT type, sql FROM {schema_ident}.sqlite_schema WHERE name = ?1"),
+            [table_name],
+            |row| Ok((row.get::<_, String>(0)?, row.get::<_, Option<String>>(1)?)),
+        )
+        .optional()
+        .map_err(|error| format!("Failed to read SQLite table definition: {error}"))?
+        .ok_or_else(|| format!("SQLite table \"{table_name}\" was not found."))?;
+    if table_record.0 != "table" {
+        return Err(format!("SQLite object \"{table_name}\" is not a table."));
+    }
+    let table_sql = table_record
+        .1
+        .ok_or_else(|| format!("SQLite table \"{table_name}\" has no reusable CREATE TABLE statement."))?;
+
+    let mut column_stmt = conn
+        .prepare(&format!("PRAGMA {schema_ident}.table_xinfo({})", quote_string(table_name)))
+        .map_err(|error| format!("Failed to inspect SQLite columns: {error}"))?;
+    let columns = column_stmt
+        .query_map([], |row| {
+            Ok(SqliteColumnSnapshot {
+                cid: row.get("cid")?,
+                name: row.get("name")?,
+                data_type: row.get("type")?,
+                not_null: row.get::<_, i64>("notnull")? != 0,
+                default_value: row.get("dflt_value")?,
+                primary_key_order: row.get("pk")?,
+                hidden: row.get("hidden")?,
+            })
+        })
+        .map_err(|error| format!("Failed to inspect SQLite columns: {error}"))?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|error| format!("Failed to inspect SQLite columns: {error}"))?;
+    drop(column_stmt);
+    if columns.is_empty() {
+        return Err(format!("SQLite table \"{table_name}\" has no inspectable columns."));
+    }
+
+    let mut dependency_stmt = conn
+        .prepare(&format!(
+            "SELECT type, name, sql FROM {schema_ident}.sqlite_schema \
+             WHERE tbl_name = ?1 AND type IN ('index', 'trigger') AND sql IS NOT NULL \
+             ORDER BY type, name"
+        ))
+        .map_err(|error| format!("Failed to inspect SQLite table dependencies: {error}"))?;
+    let dependencies = dependency_stmt
+        .query_map([table_name], |row| Ok(SqliteDependency { kind: row.get(0)?, name: row.get(1)?, sql: row.get(2)? }))
+        .map_err(|error| format!("Failed to inspect SQLite table dependencies: {error}"))?
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|error| format!("Failed to inspect SQLite table dependencies: {error}"))?;
+    drop(dependency_stmt);
+
+    let schema_version: i64 = conn
+        .pragma_query_value(Some(rusqlite::DatabaseName::Main), "schema_version", |row| row.get(0))
+        .map_err(|error| format!("Failed to read SQLite schema version: {error}"))?;
+    let autoincrement_sequence = if contains_sql_keyword(&table_sql, "autoincrement") {
+        conn.query_row(
+            &format!("SELECT seq FROM {schema_ident}.sqlite_sequence WHERE name = ?1"),
+            [table_name],
+            |row| row.get(0),
+        )
+        .optional()
+        .map_err(|error| format!("Failed to read SQLite AUTOINCREMENT sequence: {error}"))?
+    } else {
+        None
+    };
+    let mut snapshot = SqliteSchemaSnapshot {
+        schema: schema.to_string(),
+        table_name: table_name.to_string(),
+        table_sql,
+        table_kind,
+        columns,
+        dependencies,
+        schema_version,
+        autoincrement_sequence,
+        revision: String::new(),
+    };
+    snapshot.revision = schema_revision(&snapshot);
+    Ok(snapshot)
+}
+
+fn schema_revision(snapshot: &SqliteSchemaSnapshot) -> String {
+    let mut hasher = Sha256::new();
+    hash_field(&mut hasher, &snapshot.schema);
+    hash_field(&mut hasher, &snapshot.table_name);
+    hash_field(&mut hasher, &snapshot.table_sql);
+    hash_field(&mut hasher, &snapshot.table_kind);
+    hash_field(&mut hasher, &snapshot.schema_version.to_string());
+    hash_field(
+        &mut hasher,
+        &snapshot.autoincrement_sequence.map_or_else(|| "<null>".to_string(), |sequence| sequence.to_string()),
+    );
+    for column in &snapshot.columns {
+        hash_field(&mut hasher, &column.cid.to_string());
+        hash_field(&mut hasher, &column.name);
+        hash_field(&mut hasher, &column.data_type);
+        hash_field(&mut hasher, if column.not_null { "1" } else { "0" });
+        hash_field(&mut hasher, column.default_value.as_deref().unwrap_or("<null>"));
+        hash_field(&mut hasher, &column.primary_key_order.to_string());
+        hash_field(&mut hasher, &column.hidden.to_string());
+    }
+    for dependency in &snapshot.dependencies {
+        hash_field(&mut hasher, &dependency.kind);
+        hash_field(&mut hasher, &dependency.name);
+        hash_field(&mut hasher, &dependency.sql);
+    }
+    format!("{:x}", hasher.finalize())
+}
+
+fn hash_field(hasher: &mut Sha256, value: &str) {
+    hasher.update(value.len().to_le_bytes());
+    hasher.update(value.as_bytes());
+}
+
+fn plan_revision(
+    schema_revision: &str,
+    options: &TableStructureSqlOptions,
+    executable_statements: &[String],
+) -> Result<String, String> {
+    let mut hasher = Sha256::new();
+    hash_field(&mut hasher, schema_revision);
+    hash_field(
+        &mut hasher,
+        &serde_json::to_string(options)
+            .map_err(|error| format!("Failed to fingerprint SQLite structure draft: {error}"))?,
+    );
+    for statement in executable_statements {
+        hash_field(&mut hasher, statement);
+    }
+    Ok(format!("{:x}", hasher.finalize()))
+}
+
+fn build_rebuild_statements(
+    conn: &Connection,
+    snapshot: &SqliteSchemaSnapshot,
+    type_changes: &BTreeMap<String, String>,
+    replaced_index_names: &HashSet<String>,
+) -> Result<Vec<String>, String> {
+    let mut create_replacement = rewrite_declared_column_types(&snapshot.table_sql, type_changes)?;
+    let (_, body_end) = find_create_table_body_span(&create_replacement)
+        .ok_or_else(|| "SQLite CREATE TABLE statement could not be parsed safely.".to_string())?;
+    ensure_statement_terminated(&mut create_replacement);
+    let backup_seed = u64::from_str_radix(&snapshot.revision[..15], 16)
+        .map_err(|error| format!("Failed to derive SQLite backup table suffix: {error}"))?;
+    let backup_name = format!("{}_{:012}", snapshot.table_name, backup_seed % 1_000_000_000_000);
+    let source_name = format!("__dbx_source_{}", &snapshot.revision[..12]);
+    let schema_ident = quote_ident(&snapshot.schema);
+    for reserved_name in [&backup_name, &source_name] {
+        let collision: bool = conn
+            .query_row(
+                &format!("SELECT EXISTS(SELECT 1 FROM {schema_ident}.sqlite_schema WHERE name = ?1)"),
+                [reserved_name],
+                |row| row.get(0),
+            )
+            .map_err(|error| format!("Failed to reserve SQLite rebuild table name: {error}"))?;
+        if collision {
+            return Err(format!(
+                "SQLite rebuild table \"{reserved_name}\" already exists; remove it or refresh the schema."
+            ));
+        }
+    }
+
+    let qualified_table = qualified_name(&snapshot.schema, &snapshot.table_name);
+    let qualified_backup = qualified_name(&snapshot.schema, &backup_name);
+    let qualified_source = qualified_name(&snapshot.schema, &source_name);
+
+    let without_rowid = has_without_rowid_clause(&create_replacement[body_end + 1..]);
+    let visible_columns = snapshot.columns.iter().filter(|column| column.hidden == 0).collect::<Vec<_>>();
+    let live_names = snapshot.columns.iter().map(|column| column.name.to_ascii_lowercase()).collect::<HashSet<_>>();
+    let rowid_alias = if without_rowid {
+        None
+    } else {
+        ["rowid", "_rowid_", "oid"].into_iter().find(|name| !live_names.contains(*name))
+    };
+    let source_alias = quote_ident("__dbx_source");
+    let mut copy_targets = Vec::with_capacity(visible_columns.len() + usize::from(rowid_alias.is_some()));
+    let mut copy_expressions = Vec::with_capacity(copy_targets.capacity());
+    if let Some(rowid_alias) = rowid_alias {
+        copy_targets.push(quote_ident(rowid_alias));
+        copy_expressions.push(format!("{source_alias}.{}", quote_ident(rowid_alias)));
+    }
+    for column in visible_columns {
+        let quoted_column = quote_ident(&column.name);
+        copy_targets.push(quoted_column.clone());
+        let source = format!("{source_alias}.{quoted_column}");
+        copy_expressions.push(
+            type_changes
+                .get(&column.name.to_ascii_lowercase())
+                .map_or(source.clone(), |target_type| format!("CAST({source} AS {target_type})")),
+        );
+    }
+
+    let backup_source_alias = quote_ident("__dbx_backup_source");
+    let mut backup_targets = Vec::with_capacity(snapshot.columns.len() + usize::from(rowid_alias.is_some()));
+    let mut backup_expressions = Vec::with_capacity(backup_targets.capacity());
+    if let Some(rowid_alias) = rowid_alias {
+        backup_targets.push(quote_ident(rowid_alias));
+        backup_expressions.push(format!("{backup_source_alias}.{}", quote_ident(rowid_alias)));
+    }
+    for column in &snapshot.columns {
+        let quoted_column = quote_ident(&column.name);
+        backup_targets.push(quoted_column.clone());
+        backup_expressions.push(format!("{backup_source_alias}.{quoted_column}"));
+    }
+
+    let mut statements = vec![
+        format!("CREATE TABLE {qualified_backup} AS SELECT * FROM {qualified_table} WHERE 0;"),
+        format!(
+            "INSERT INTO {qualified_backup} ({}) SELECT {} FROM {qualified_table} AS {backup_source_alias};",
+            backup_targets.join(", "),
+            backup_expressions.join(", ")
+        ),
+        format!("ALTER TABLE {qualified_table} RENAME TO {};", quote_ident(&source_name)),
+    ];
+    // Index and trigger names are unique within a SQLite schema. The renamed source table is
+    // intentionally retained as the backup, so release its dependency names before recreating
+    // those dependencies on the replacement table.
+    statements.extend(snapshot.dependencies.iter().map(|dependency| {
+        format!("DROP {} {};", dependency.kind.to_ascii_uppercase(), qualified_name(&snapshot.schema, &dependency.name))
+    }));
+    statements.extend([
+        create_replacement,
+        format!(
+            "INSERT INTO {qualified_table} ({}) SELECT {} FROM {qualified_source} AS {source_alias};",
+            copy_targets.join(", "),
+            copy_expressions.join(", ")
+        ),
+    ]);
+    if let Some(sequence) = snapshot.autoincrement_sequence {
+        let sequence_table = qualified_name(&snapshot.schema, "sqlite_sequence");
+        let table_literal = quote_string(&snapshot.table_name);
+        statements.push(format!(
+            "UPDATE {sequence_table} SET seq = CASE WHEN seq < {sequence} THEN {sequence} ELSE seq END WHERE name = {table_literal};"
+        ));
+        statements.push(format!(
+            "INSERT INTO {sequence_table} (name, seq) SELECT {table_literal}, {sequence} WHERE NOT EXISTS (SELECT 1 FROM {sequence_table} WHERE name = {table_literal});"
+        ));
+    }
+    statements.push(format!("DROP TABLE {qualified_source};"));
+    statements.extend(
+        snapshot
+            .dependencies
+            .iter()
+            .filter(|dependency| {
+                dependency.kind != "index" || !replaced_index_names.contains(&dependency.name.to_ascii_lowercase())
+            })
+            .map(|dependency| {
+                let mut sql = dependency.sql.clone();
+                ensure_statement_terminated(&mut sql);
+                sql
+            }),
+    );
+    Ok(statements)
+}
+
+fn execute_change_transaction(
+    conn: &mut Connection,
+    options: &TableStructureSqlOptions,
+    expected_revision: &str,
+) -> Result<db::QueryResult, String> {
+    let started_at = Instant::now();
+    let foreign_keys_enabled: i64 = conn
+        .pragma_query_value(None, "foreign_keys", |row| row.get(0))
+        .map_err(|error| format!("Failed to read SQLite foreign_keys state: {error}"))?;
+    let legacy_alter_table_enabled: i64 = conn
+        .pragma_query_value(None, "legacy_alter_table", |row| row.get(0))
+        .map_err(|error| format!("Failed to read SQLite legacy_alter_table state: {error}"))?;
+    conn.pragma_update(None, "foreign_keys", false)
+        .map_err(|error| format!("Failed to disable SQLite foreign key enforcement: {error}"))?;
+    if let Err(error) = conn.pragma_update(None, "legacy_alter_table", true) {
+        let restore_error = conn.pragma_update(None, "foreign_keys", foreign_keys_enabled != 0).err();
+        return Err(match restore_error {
+            Some(restore_error) => format!(
+                "Failed to enable SQLite legacy_alter_table for the backup rename: {error}; failed to restore foreign_keys state: {restore_error}"
+            ),
+            None => format!("Failed to enable SQLite legacy_alter_table for the backup rename: {error}"),
+        });
+    }
+
+    let operation_result = (|| {
+        conn.execute_batch("BEGIN IMMEDIATE")
+            .map_err(|error| format!("Failed to begin SQLite table rebuild transaction: {error}"))?;
+        let plan = build_change_plan(conn, options)?;
+        if plan.preview.schema_revision != expected_revision {
+            return Err(
+                "SQLite schema changed or the structure draft differs from the preview. Refresh the table structure and preview the change again."
+                    .to_string(),
+            );
+        }
+        if !plan.preview.warnings.is_empty() {
+            return Err(format!("SQLite structure change cannot be applied: {}", plan.preview.warnings.join(" ")));
+        }
+        // Compare the complete schema so inbound references are covered while unrelated historical violations remain tolerated.
+        let foreign_key_baseline = foreign_key_violations(conn, &plan.schema)?;
+        for (index, statement) in plan.executable_statements.iter().enumerate() {
+            if let Err(error) = conn.execute_batch(statement) {
+                return Err(format!("SQLite structure statement {} failed: {error}", index + 1));
+            }
+        }
+        let foreign_key_after = foreign_key_violations(conn, &plan.schema)?;
+        if let Some(violation) = first_added_foreign_key_violation(&foreign_key_baseline, &foreign_key_after) {
+            return Err(format!(
+                "SQLite foreign key check found a new violation after rebuilding the table: {}",
+                format_foreign_key_violation(violation)
+            ));
+        }
+        conn.execute_batch("COMMIT").map_err(|error| format!("SQLite table rebuild COMMIT failed: {error}"))?;
+        Ok(())
+    })();
+
+    if operation_result.is_err() && !conn.is_autocommit() {
+        let _ = conn.execute_batch("ROLLBACK");
+    }
+
+    let mut cleanup_errors = Vec::new();
+    if let Err(error) = conn.pragma_update(None, "legacy_alter_table", legacy_alter_table_enabled != 0) {
+        cleanup_errors.push(format!("Failed to restore SQLite legacy_alter_table state: {error}"));
+    }
+    if let Err(error) = conn.pragma_update(None, "foreign_keys", foreign_keys_enabled != 0) {
+        cleanup_errors.push(format!("Failed to restore SQLite foreign_keys state: {error}"));
+    }
+    match operation_result {
+        Err(operation_error) if cleanup_errors.is_empty() => Err(operation_error),
+        Err(operation_error) => Err(format!("{operation_error}; {}", cleanup_errors.join("; "))),
+        Ok(()) if !cleanup_errors.is_empty() => Err(cleanup_errors.join("; ")),
+        Ok(()) => Ok(db::QueryResult {
+            columns: Vec::new(),
+            column_types: Vec::new(),
+            column_sortables: Vec::new(),
+            rows: Vec::new(),
+            affected_rows: 0,
+            execution_time_ms: started_at.elapsed().as_millis(),
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        }),
+    }
+}
+
+fn foreign_key_violations(conn: &Connection, schema: &str) -> Result<Vec<SqliteForeignKeyViolation>, String> {
+    let mut statement = conn
+        .prepare(&format!("PRAGMA {}.foreign_key_check", quote_ident(schema)))
+        .map_err(|error| format!("Failed to prepare SQLite foreign_key_check: {error}"))?;
+    let mut rows = statement.query([]).map_err(|error| format!("Failed to run SQLite foreign_key_check: {error}"))?;
+    let mut violations = Vec::new();
+    while let Some(row) = rows.next().map_err(|error| format!("Failed to read SQLite foreign_key_check: {error}"))? {
+        violations.push(SqliteForeignKeyViolation {
+            table: row.get(0).unwrap_or_else(|_| "<unknown>".to_string()),
+            rowid: row.get(1).unwrap_or(None),
+            parent: row.get(2).unwrap_or_else(|_| "<unknown>".to_string()),
+            foreign_key_id: row.get(3).unwrap_or(-1),
+        });
+    }
+    Ok(violations)
+}
+
+fn first_added_foreign_key_violation<'a>(
+    baseline: &[SqliteForeignKeyViolation],
+    after: &'a [SqliteForeignKeyViolation],
+) -> Option<&'a SqliteForeignKeyViolation> {
+    let mut remaining = baseline.iter().cloned().fold(BTreeMap::new(), |mut counts, violation| {
+        *counts.entry(violation).or_insert(0usize) += 1;
+        counts
+    });
+    after.iter().find(|violation| match remaining.get_mut(*violation) {
+        Some(count) if *count > 0 => {
+            *count -= 1;
+            false
+        }
+        _ => true,
+    })
+}
+
+fn format_foreign_key_violation(violation: &SqliteForeignKeyViolation) -> String {
+    format!(
+        "table={table}, rowid={}, parent={parent}, foreignKeyId={foreign_key_id}",
+        violation.rowid.map_or_else(|| "null".to_string(), |rowid| rowid.to_string()),
+        table = violation.table,
+        parent = violation.parent,
+        foreign_key_id = violation.foreign_key_id,
+    )
+}
+
+fn rewrite_declared_column_types(create_sql: &str, type_changes: &BTreeMap<String, String>) -> Result<String, String> {
+    let (body_start, body_end) = find_create_table_body_span(create_sql)
+        .ok_or_else(|| "SQLite CREATE TABLE statement could not be parsed safely.".to_string())?;
+    let body = &create_sql[body_start + 1..body_end];
+    let mut replacements = Vec::new();
+    let mut found = HashSet::new();
+
+    for (entry_start, entry_end) in split_entry_ranges(body) {
+        let entry = &body[entry_start..entry_end];
+        let Some((name, type_start, type_end)) = parse_column_type_span(entry) else {
+            continue;
+        };
+        let key = name.to_ascii_lowercase();
+        let Some(next_type) = type_changes.get(&key) else {
+            continue;
+        };
+        if !found.insert(key.clone()) {
+            return Err(format!("SQLite CREATE TABLE contains duplicate column definition \"{name}\"."));
+        }
+        let replacement = if type_start == type_end { format!("{next_type} ") } else { next_type.clone() };
+        replacements.push((
+            body_start + 1 + entry_start + type_start,
+            body_start + 1 + entry_start + type_end,
+            replacement,
+        ));
+    }
+
+    for name in type_changes.keys() {
+        if !found.contains(name) {
+            return Err(format!(
+                "Column \"{name}\" could not be located unambiguously in the SQLite CREATE TABLE statement."
+            ));
+        }
+    }
+
+    let mut rewritten = create_sql.to_string();
+    for (start, end, replacement) in replacements.into_iter().rev() {
+        rewritten.replace_range(start..end, &replacement);
+    }
+    Ok(rewritten)
+}
+
+fn find_create_table_body_span(sql: &str) -> Option<(usize, usize)> {
+    let mut mode = ScanMode::Normal;
+    let mut depth = 0_usize;
+    let mut start = None;
+    let bytes = sql.as_bytes();
+    let mut index = 0_usize;
+    while index < bytes.len() {
+        let byte = bytes[index];
+        match mode {
+            ScanMode::Normal => match byte {
+                b'\'' => mode = ScanMode::SingleQuote,
+                b'"' => mode = ScanMode::DoubleQuote,
+                b'`' => mode = ScanMode::Backtick,
+                b'[' => mode = ScanMode::Bracket,
+                b'-' if bytes.get(index + 1) == Some(&b'-') => {
+                    mode = ScanMode::LineComment;
+                    index += 1;
+                }
+                b'/' if bytes.get(index + 1) == Some(&b'*') => {
+                    mode = ScanMode::BlockComment;
+                    index += 1;
+                }
+                b'(' => {
+                    if start.is_none() {
+                        start = Some(index);
+                    }
+                    depth += 1;
+                }
+                b')' if depth > 0 => {
+                    depth -= 1;
+                    if depth == 0 {
+                        return Some((start?, index));
+                    }
+                }
+                _ => {}
+            },
+            ScanMode::SingleQuote => {
+                if byte == b'\'' {
+                    if bytes.get(index + 1) == Some(&b'\'') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::DoubleQuote => {
+                if byte == b'"' {
+                    if bytes.get(index + 1) == Some(&b'"') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::Backtick => {
+                if byte == b'`' {
+                    if bytes.get(index + 1) == Some(&b'`') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::Bracket => {
+                if byte == b']' {
+                    mode = ScanMode::Normal;
+                }
+            }
+            ScanMode::LineComment => {
+                if byte == b'\n' {
+                    mode = ScanMode::Normal;
+                }
+            }
+            ScanMode::BlockComment => {
+                if byte == b'*' && bytes.get(index + 1) == Some(&b'/') {
+                    mode = ScanMode::Normal;
+                    index += 1;
+                }
+            }
+        }
+        index += 1;
+    }
+    None
+}
+
+fn split_entry_ranges(body: &str) -> Vec<(usize, usize)> {
+    let bytes = body.as_bytes();
+    let mut ranges = Vec::new();
+    let mut mode = ScanMode::Normal;
+    let mut depth = 0_usize;
+    let mut entry_start = 0_usize;
+    let mut index = 0_usize;
+    while index < bytes.len() {
+        let byte = bytes[index];
+        match mode {
+            ScanMode::Normal => match byte {
+                b'\'' => mode = ScanMode::SingleQuote,
+                b'"' => mode = ScanMode::DoubleQuote,
+                b'`' => mode = ScanMode::Backtick,
+                b'[' => mode = ScanMode::Bracket,
+                b'-' if bytes.get(index + 1) == Some(&b'-') => {
+                    mode = ScanMode::LineComment;
+                    index += 1;
+                }
+                b'/' if bytes.get(index + 1) == Some(&b'*') => {
+                    mode = ScanMode::BlockComment;
+                    index += 1;
+                }
+                b'(' => depth += 1,
+                b')' => depth = depth.saturating_sub(1),
+                b',' if depth == 0 => {
+                    ranges.push(trimmed_range(body, entry_start, index));
+                    entry_start = index + 1;
+                }
+                _ => {}
+            },
+            ScanMode::SingleQuote => {
+                if byte == b'\'' {
+                    if bytes.get(index + 1) == Some(&b'\'') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::DoubleQuote => {
+                if byte == b'"' {
+                    if bytes.get(index + 1) == Some(&b'"') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::Backtick => {
+                if byte == b'`' {
+                    if bytes.get(index + 1) == Some(&b'`') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::Bracket => {
+                if byte == b']' {
+                    mode = ScanMode::Normal;
+                }
+            }
+            ScanMode::LineComment => {
+                if byte == b'\n' {
+                    mode = ScanMode::Normal;
+                }
+            }
+            ScanMode::BlockComment => {
+                if byte == b'*' && bytes.get(index + 1) == Some(&b'/') {
+                    mode = ScanMode::Normal;
+                    index += 1;
+                }
+            }
+        }
+        index += 1;
+    }
+    ranges.push(trimmed_range(body, entry_start, body.len()));
+    ranges.into_iter().filter(|(start, end)| start < end).collect()
+}
+
+fn trimmed_range(value: &str, mut start: usize, mut end: usize) -> (usize, usize) {
+    while start < end && value.as_bytes()[start].is_ascii_whitespace() {
+        start += 1;
+    }
+    while end > start && value.as_bytes()[end - 1].is_ascii_whitespace() {
+        end -= 1;
+    }
+    (start, end)
+}
+
+fn parse_column_type_span(entry: &str) -> Option<(String, usize, usize)> {
+    let name_start = skip_space_and_comments(entry, 0)?;
+    let (name, name_end, quoted) = parse_identifier(entry, name_start)?;
+    if !quoted
+        && matches!(name.to_ascii_lowercase().as_str(), "constraint" | "primary" | "unique" | "check" | "foreign")
+    {
+        return None;
+    }
+    let type_start = skip_space_and_comments(entry, name_end).unwrap_or(entry.len());
+    let constraint_start = find_column_constraint_start(entry, type_start).unwrap_or(entry.len());
+    let mut type_end = constraint_start;
+    while type_end > type_start && entry.as_bytes()[type_end - 1].is_ascii_whitespace() {
+        type_end -= 1;
+    }
+    Some((name, type_start, type_end))
+}
+
+fn parse_identifier(value: &str, start: usize) -> Option<(String, usize, bool)> {
+    let bytes = value.as_bytes();
+    let first = *bytes.get(start)?;
+    if matches!(first, b'"' | b'`' | b'[') {
+        let close = if first == b'[' { b']' } else { first };
+        let mut decoded = String::new();
+        let mut index = start + 1;
+        while index < bytes.len() {
+            if bytes[index] == close {
+                if close != b']' && bytes.get(index + 1) == Some(&close) {
+                    decoded.push(close as char);
+                    index += 2;
+                    continue;
+                }
+                return Some((decoded, index + 1, true));
+            }
+            let ch = value[index..].chars().next()?;
+            decoded.push(ch);
+            index += ch.len_utf8();
+        }
+        return None;
+    }
+
+    let mut end = start;
+    while end < bytes.len() {
+        let ch = value[end..].chars().next()?;
+        if ch.is_whitespace() || matches!(ch, '(' | ')' | ',' | ';') {
+            break;
+        }
+        end += ch.len_utf8();
+    }
+    (end > start).then(|| (value[start..end].to_string(), end, false))
+}
+
+fn skip_space_and_comments(value: &str, mut index: usize) -> Option<usize> {
+    let bytes = value.as_bytes();
+    loop {
+        while index < bytes.len() && bytes[index].is_ascii_whitespace() {
+            index += 1;
+        }
+        if bytes.get(index) == Some(&b'-') && bytes.get(index + 1) == Some(&b'-') {
+            index += 2;
+            while index < bytes.len() && bytes[index] != b'\n' {
+                index += 1;
+            }
+            continue;
+        }
+        if bytes.get(index) == Some(&b'/') && bytes.get(index + 1) == Some(&b'*') {
+            let tail = value.get(index + 2..)?;
+            let end = tail.find("*/")?;
+            index += end + 4;
+            continue;
+        }
+        return Some(index);
+    }
+}
+
+fn find_column_constraint_start(value: &str, start: usize) -> Option<usize> {
+    let bytes = value.as_bytes();
+    let mut mode = ScanMode::Normal;
+    let mut depth = 0_usize;
+    let mut index = start;
+    while index < bytes.len() {
+        let byte = bytes[index];
+        match mode {
+            ScanMode::Normal => match byte {
+                b'\'' => mode = ScanMode::SingleQuote,
+                b'"' => mode = ScanMode::DoubleQuote,
+                b'`' => mode = ScanMode::Backtick,
+                b'[' => mode = ScanMode::Bracket,
+                b'-' if bytes.get(index + 1) == Some(&b'-') => {
+                    mode = ScanMode::LineComment;
+                    index += 1;
+                }
+                b'/' if bytes.get(index + 1) == Some(&b'*') => {
+                    mode = ScanMode::BlockComment;
+                    index += 1;
+                }
+                b'(' => depth += 1,
+                b')' => depth = depth.saturating_sub(1),
+                _ if depth == 0 && (byte.is_ascii_alphabetic() || byte == b'_') => {
+                    let word_start = index;
+                    index += 1;
+                    while index < bytes.len() && (bytes[index].is_ascii_alphanumeric() || bytes[index] == b'_') {
+                        index += 1;
+                    }
+                    if is_column_constraint_keyword(&value[word_start..index]) {
+                        return Some(word_start);
+                    }
+                    continue;
+                }
+                _ => {}
+            },
+            ScanMode::SingleQuote => {
+                if byte == b'\'' {
+                    if bytes.get(index + 1) == Some(&b'\'') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::DoubleQuote => {
+                if byte == b'"' {
+                    if bytes.get(index + 1) == Some(&b'"') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::Backtick => {
+                if byte == b'`' {
+                    if bytes.get(index + 1) == Some(&b'`') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::Bracket => {
+                if byte == b']' {
+                    mode = ScanMode::Normal;
+                }
+            }
+            ScanMode::LineComment => {
+                if byte == b'\n' {
+                    mode = ScanMode::Normal;
+                }
+            }
+            ScanMode::BlockComment => {
+                if byte == b'*' && bytes.get(index + 1) == Some(&b'/') {
+                    mode = ScanMode::Normal;
+                    index += 1;
+                }
+            }
+        }
+        index += 1;
+    }
+    None
+}
+
+fn is_column_constraint_keyword(value: &str) -> bool {
+    matches!(
+        value.to_ascii_lowercase().as_str(),
+        "primary" | "not" | "unique" | "check" | "default" | "collate" | "references" | "generated"
+    )
+}
+
+fn validate_declared_type(data_type: &str) -> Result<(), String> {
+    let data_type = data_type.trim();
+    if data_type.is_empty() {
+        return Err("declared type cannot be empty.".to_string());
+    }
+    if data_type.contains(';')
+        || data_type.contains("--")
+        || data_type.contains("/*")
+        || data_type.contains("*/")
+        || data_type.chars().any(|ch| matches!(ch, '\'' | '"' | '`' | '[' | ']'))
+    {
+        return Err("declared type contains SQL syntax that is not allowed in a type name.".to_string());
+    }
+    let mut depth = 0_i32;
+    for ch in data_type.chars() {
+        match ch {
+            '(' => depth += 1,
+            ')' => {
+                depth -= 1;
+                if depth < 0 {
+                    return Err("declared type has unbalanced parentheses.".to_string());
+                }
+            }
+            ',' if depth == 0 => return Err("declared type contains a top-level comma.".to_string()),
+            _ if ch.is_ascii_alphanumeric()
+                || ch == '_'
+                || ch.is_ascii_whitespace()
+                || matches!(ch, '(' | ')' | ',') => {}
+            _ => return Err(format!("declared type contains unsupported character \"{ch}\".")),
+        }
+    }
+    if depth != 0 {
+        return Err("declared type has unbalanced parentheses.".to_string());
+    }
+    if data_type
+        .split(|ch: char| !ch.is_ascii_alphanumeric() && ch != '_')
+        .filter(|word| !word.is_empty())
+        .any(is_column_constraint_keyword)
+    {
+        return Err("declared type cannot include column constraints.".to_string());
+    }
+    Ok(())
+}
+
+fn has_trigger_edits(options: &TableStructureSqlOptions) -> bool {
+    options.triggers.iter().any(|trigger| {
+        if trigger.marked_for_drop || trigger.original.is_none() {
+            return true;
+        }
+        let original = trigger.original.as_ref().unwrap();
+        clean(&trigger.name) != clean(&original.name)
+            || !clean(&trigger.timing).eq_ignore_ascii_case(&clean(&original.timing))
+            || !clean(&trigger.event).eq_ignore_ascii_case(&clean(&original.event))
+            || clean(&trigger.statement).trim_end_matches(';').trim()
+                != clean(original.statement.as_deref().unwrap_or("")).trim_end_matches(';').trim()
+    })
+}
+
+fn normalize_type_name(value: &str) -> String {
+    value.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase()
+}
+
+fn has_without_rowid_clause(tail: &str) -> bool {
+    sql_words_outside_comments_and_quotes(tail)
+        .windows(2)
+        .any(|words| words[0].eq_ignore_ascii_case("without") && words[1].eq_ignore_ascii_case("rowid"))
+}
+
+fn hidden_rowid_is_shadowed(snapshot: &SqliteSchemaSnapshot) -> Result<bool, String> {
+    if snapshot_is_without_rowid(snapshot)? {
+        return Ok(false);
+    }
+    let names = snapshot.columns.iter().map(|column| column.name.to_ascii_lowercase()).collect::<HashSet<_>>();
+    Ok(["rowid", "_rowid_", "oid"].into_iter().all(|alias| names.contains(alias)))
+}
+
+fn snapshot_is_without_rowid(snapshot: &SqliteSchemaSnapshot) -> Result<bool, String> {
+    let (_, body_end) = find_create_table_body_span(&snapshot.table_sql)
+        .ok_or_else(|| "SQLite CREATE TABLE statement could not be parsed safely.".to_string())?;
+    Ok(has_without_rowid_clause(&snapshot.table_sql[body_end + 1..]))
+}
+
+fn contains_sql_keyword(sql: &str, keyword: &str) -> bool {
+    sql_words_outside_comments_and_quotes(sql).iter().any(|word| word.eq_ignore_ascii_case(keyword))
+}
+
+fn sql_words_outside_comments_and_quotes(sql: &str) -> Vec<String> {
+    let bytes = sql.as_bytes();
+    let mut words = Vec::new();
+    let mut mode = ScanMode::Normal;
+    let mut index = 0_usize;
+    while index < bytes.len() {
+        let byte = bytes[index];
+        match mode {
+            ScanMode::Normal => match byte {
+                b'\'' => mode = ScanMode::SingleQuote,
+                b'"' => mode = ScanMode::DoubleQuote,
+                b'`' => mode = ScanMode::Backtick,
+                b'[' => mode = ScanMode::Bracket,
+                b'-' if bytes.get(index + 1) == Some(&b'-') => {
+                    mode = ScanMode::LineComment;
+                    index += 1;
+                }
+                b'/' if bytes.get(index + 1) == Some(&b'*') => {
+                    mode = ScanMode::BlockComment;
+                    index += 1;
+                }
+                _ if byte.is_ascii_alphabetic() || byte == b'_' => {
+                    let start = index;
+                    index += 1;
+                    while index < bytes.len() && (bytes[index].is_ascii_alphanumeric() || bytes[index] == b'_') {
+                        index += 1;
+                    }
+                    words.push(sql[start..index].to_string());
+                    continue;
+                }
+                _ => {}
+            },
+            ScanMode::SingleQuote => {
+                if byte == b'\'' {
+                    if bytes.get(index + 1) == Some(&b'\'') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::DoubleQuote => {
+                if byte == b'"' {
+                    if bytes.get(index + 1) == Some(&b'"') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::Backtick => {
+                if byte == b'`' {
+                    if bytes.get(index + 1) == Some(&b'`') {
+                        index += 1;
+                    } else {
+                        mode = ScanMode::Normal;
+                    }
+                }
+            }
+            ScanMode::Bracket => {
+                if byte == b']' {
+                    mode = ScanMode::Normal;
+                }
+            }
+            ScanMode::LineComment => {
+                if byte == b'\n' {
+                    mode = ScanMode::Normal;
+                }
+            }
+            ScanMode::BlockComment => {
+                if byte == b'*' && bytes.get(index + 1) == Some(&b'/') {
+                    mode = ScanMode::Normal;
+                    index += 1;
+                }
+            }
+        }
+        index += 1;
+    }
+    words
+}
+
+fn quote_ident(value: &str) -> String {
+    format!("\"{}\"", value.replace('"', "\"\""))
+}
+
+fn quote_string(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+fn qualified_name(schema: &str, name: &str) -> String {
+    format!("{}.{}", quote_ident(schema), quote_ident(name))
+}
+
+fn ensure_statement_terminated(statement: &mut String) {
+    if !statement.trim_end().ends_with(';') {
+        statement.push(';');
+    }
+}
+
+fn deduplicate_warnings(warnings: &mut Vec<String>) {
+    let mut seen = HashSet::new();
+    warnings.retain(|warning| seen.insert(warning.clone()));
+}
+
+#[derive(Debug, Clone, Copy)]
+enum ScanMode {
+    Normal,
+    SingleQuote,
+    DoubleQuote,
+    Backtick,
+    Bracket,
+    LineComment,
+    BlockComment,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::table_structure_sql::{
+        ColumnExtra, ColumnInfo, EditableStructureColumn, EditableStructureIndex, IndexInfo,
+    };
+
+    fn type_change_options(
+        table_name: &str,
+        column_name: &str,
+        old_type: &str,
+        new_type: &str,
+    ) -> TableStructureSqlOptions {
+        TableStructureSqlOptions {
+            database_type: Some(DatabaseType::Sqlite),
+            schema: None,
+            table_name: table_name.to_string(),
+            columns: vec![EditableStructureColumn {
+                id: column_name.to_string(),
+                name: column_name.to_string(),
+                data_type: new_type.to_string(),
+                is_nullable: false,
+                default_value: String::new(),
+                comment: String::new(),
+                is_primary_key: false,
+                extra: None,
+                original: Some(ColumnInfo {
+                    name: column_name.to_string(),
+                    data_type: old_type.to_string(),
+                    is_nullable: false,
+                    column_default: None,
+                    is_primary_key: false,
+                    extra: None,
+                    comment: None,
+                    character_set: None,
+                    collation: None,
+                }),
+                original_position: Some(1),
+                marked_for_drop: false,
+                character_set: String::new(),
+                collation: String::new(),
+            }],
+            indexes: Vec::new(),
+            foreign_keys: Vec::new(),
+            triggers: Vec::new(),
+            table_comment: None,
+            original_table_comment: None,
+        }
+    }
+
+    #[test]
+    fn rewrites_only_target_column_type_and_preserves_table_tail() {
+        let sql = r#"CREATE TABLE "items" (
+  "id" INTEGER PRIMARY KEY,
+  [value] VARCHAR(20) NOT NULL DEFAULT (printf('%s,%s', 'a', 'b')),
+  note DOUBLE PRECISION CHECK (note > 0),
+  CONSTRAINT "uq_value" UNIQUE ([value])
+) STRICT, WITHOUT ROWID"#;
+        let changes = BTreeMap::from([
+            ("value".to_string(), "TEXT".to_string()),
+            ("note".to_string(), "DECIMAL(12, 4)".to_string()),
+        ]);
+
+        let rewritten = rewrite_declared_column_types(sql, &changes).unwrap();
+
+        assert!(rewritten.contains("[value] TEXT NOT NULL DEFAULT (printf('%s,%s', 'a', 'b'))"));
+        assert!(rewritten.contains("note DECIMAL(12, 4) CHECK (note > 0)"));
+        assert!(rewritten.contains("CONSTRAINT \"uq_value\" UNIQUE ([value])"));
+        assert!(rewritten.ends_with("STRICT, WITHOUT ROWID"));
+        assert!(!has_without_rowid_clause("/* WITHOUT ROWID */ STRICT"));
+        assert!(has_without_rowid_clause("STRICT, WITHOUT /* keep */ ROWID"));
+    }
+
+    #[tokio::test]
+    async fn rebuild_preserves_data_generated_columns_indexes_triggers_and_foreign_key_state() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        pool.with_connection(|conn| {
+            conn.execute_batch(
+                "PRAGMA foreign_keys=ON;
+                 CREATE TABLE parent(id INTEGER PRIMARY KEY);
+                 INSERT INTO parent VALUES (1);
+                 CREATE TABLE audit(message TEXT);
+                 CREATE TABLE items(
+                   id INTEGER PRIMARY KEY,
+                   value TEXT NOT NULL,
+                   doubled TEXT GENERATED ALWAYS AS (value || value) STORED,
+                   parent_id INTEGER REFERENCES parent(id)
+                 ) STRICT;
+                 CREATE INDEX idx_items_value ON items(value) WHERE value IS NOT NULL;
+                 CREATE TRIGGER trg_items_ai AFTER INSERT ON items BEGIN INSERT INTO audit VALUES (NEW.value); END;
+                 INSERT INTO items(id, value, parent_id) VALUES (7, '42', 1);
+                 CREATE TABLE item_refs(item_id INTEGER REFERENCES items(id));
+                 INSERT INTO item_refs VALUES (7);",
+            )
+            .map_err(|error| error.to_string())
+        })
+        .unwrap();
+        let options = type_change_options("items", "value", "TEXT", "INTEGER");
+
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+        assert!(preview.warnings.is_empty(), "{:?}", preview.warnings);
+        assert!(preview.statements.iter().any(|sql| sql.contains("BEGIN IMMEDIATE")));
+        assert!(preview.statements.iter().any(|sql| sql.contains("legacy_alter_table = ON")));
+        let foreign_key_checks = preview
+            .statements
+            .iter()
+            .enumerate()
+            .filter(|(_, sql)| sql.starts_with("PRAGMA") && sql.contains("foreign_key_check"))
+            .map(|(index, _)| index)
+            .collect::<Vec<_>>();
+        let rename_position = preview.statements.iter().position(|sql| sql.starts_with("ALTER TABLE")).unwrap();
+        let create_position = preview
+            .statements
+            .iter()
+            .enumerate()
+            .filter(|(_, sql)| sql.starts_with("CREATE TABLE"))
+            .nth(1)
+            .map(|(index, _)| index)
+            .unwrap();
+        let copy_position = preview.statements.iter().position(|sql| sql.contains("CAST(")).unwrap();
+        assert_eq!(foreign_key_checks.len(), 2);
+        assert!(foreign_key_checks[0] < rename_position);
+        assert!(foreign_key_checks[1] > copy_position);
+        assert!(rename_position < create_position && create_position < copy_position);
+        assert!(preview.statements.iter().any(|sql| sql.starts_with("DROP TABLE") && sql.contains("__dbx_source_")));
+        assert!(!preview.statements.iter().any(|sql| sql.starts_with("DROP TABLE") && sql.contains("\"items_")));
+        assert!(preview.statements[copy_position].contains("CAST("));
+        assert!(preview.statements[copy_position].contains(" AS INTEGER)"));
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision).await.unwrap();
+
+        let result = db::sqlite::execute_query(&pool, "SELECT typeof(value), value, doubled, rowid, id FROM items;")
+            .await
+            .unwrap();
+        assert_eq!(result.rows[0], serde_json::json!(["integer", 42, "4242", 7, 7]).as_array().unwrap().clone());
+        let schema = db::sqlite::execute_query(
+            &pool,
+            "SELECT type, name FROM sqlite_schema WHERE name IN ('idx_items_value', 'trg_items_ai') ORDER BY type;",
+        )
+        .await
+        .unwrap();
+        assert_eq!(schema.rows.len(), 2);
+        let foreign_keys = db::sqlite::execute_query(&pool, "PRAGMA foreign_keys;").await.unwrap();
+        assert_eq!(foreign_keys.rows[0][0], serde_json::json!(1));
+        let legacy_alter_table = db::sqlite::execute_query(&pool, "PRAGMA legacy_alter_table;").await.unwrap();
+        assert_eq!(legacy_alter_table.rows[0][0], serde_json::json!(0));
+        let child_reference = db::sqlite::execute_query(&pool, "PRAGMA foreign_key_list(item_refs);").await.unwrap();
+        assert_eq!(child_reference.rows[0][2], serde_json::json!("items"));
+        let violations = db::sqlite::execute_query(&pool, "PRAGMA foreign_key_check;").await.unwrap();
+        assert!(violations.rows.is_empty());
+        let backups = db::sqlite::execute_query(
+            &pool,
+            "SELECT name FROM sqlite_schema WHERE type='table' AND name GLOB 'items_[0-9]*';",
+        )
+        .await
+        .unwrap();
+        assert_eq!(backups.rows.len(), 1);
+        let backup_name = backups.rows[0][0].as_str().unwrap();
+        let backup_suffix = backup_name.strip_prefix("items_").unwrap();
+        assert_eq!(backup_suffix.len(), 12);
+        assert!(backup_suffix.chars().all(|ch| ch.is_ascii_digit()));
+        let backup_data = db::sqlite::execute_query(
+            &pool,
+            &format!("SELECT typeof(value), value FROM {};", quote_ident(backup_name)),
+        )
+        .await
+        .unwrap();
+        assert_eq!(backup_data.rows[0], serde_json::json!(["text", "42"]).as_array().unwrap().clone());
+    }
+
+    #[tokio::test]
+    async fn unrelated_existing_foreign_key_violation_does_not_block_rebuild() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        pool.with_connection(|conn| {
+            conn.execute_batch(
+                "PRAGMA foreign_keys=OFF;
+                 CREATE TABLE unrelated_parent(id INTEGER PRIMARY KEY);
+                 CREATE TABLE unrelated_child(parent_id INTEGER REFERENCES unrelated_parent(id));
+                 INSERT INTO unrelated_child VALUES (999);
+                 CREATE TABLE healthy(id INTEGER PRIMARY KEY, value TEXT NOT NULL);
+                 INSERT INTO healthy VALUES (1, '42');
+                 PRAGMA foreign_keys=ON;",
+            )
+            .map_err(|error| error.to_string())
+        })
+        .unwrap();
+        let options = type_change_options("healthy", "value", "TEXT", "INTEGER");
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision).await.unwrap();
+
+        let value = db::sqlite::execute_query(&pool, "SELECT typeof(value), value FROM healthy;").await.unwrap();
+        assert_eq!(value.rows[0], serde_json::json!(["integer", 42]).as_array().unwrap().clone());
+        let violations = db::sqlite::execute_query(&pool, "PRAGMA foreign_key_check;").await.unwrap();
+        assert_eq!(violations.rows.len(), 1);
+        assert_eq!(violations.rows[0][0], serde_json::json!("unrelated_child"));
+    }
+
+    #[tokio::test]
+    async fn newly_introduced_inbound_foreign_key_violation_rolls_back_rebuild() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        pool.with_connection(|conn| {
+            conn.execute_batch(
+                "PRAGMA foreign_keys=ON;
+                 CREATE TABLE parent(value TEXT NOT NULL UNIQUE);
+                 CREATE TABLE child(parent_value TEXT REFERENCES parent(value));
+                 INSERT INTO parent VALUES ('abc');
+                 INSERT INTO child VALUES ('abc');",
+            )
+            .map_err(|error| error.to_string())
+        })
+        .unwrap();
+        let options = type_change_options("parent", "value", "TEXT", "INTEGER");
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+
+        let error = apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision)
+            .await
+            .unwrap_err();
+
+        assert!(error.contains("new violation") && error.contains("table=child"), "{error}");
+        let parent = db::sqlite::execute_query(&pool, "SELECT typeof(value), value FROM parent;").await.unwrap();
+        assert_eq!(parent.rows[0], serde_json::json!(["text", "abc"]).as_array().unwrap().clone());
+        let violations = db::sqlite::execute_query(&pool, "PRAGMA foreign_key_check;").await.unwrap();
+        assert!(violations.rows.is_empty());
+    }
+
+    #[tokio::test]
+    async fn retained_backup_is_inert_and_does_not_participate_in_foreign_key_actions() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        pool.with_connection(|conn| {
+            conn.execute_batch(
+                "PRAGMA foreign_keys=ON;
+                 CREATE TABLE parent(id INTEGER PRIMARY KEY);
+                 CREATE TABLE items(
+                   id INTEGER PRIMARY KEY,
+                   parent_id INTEGER REFERENCES parent(id) ON DELETE CASCADE,
+                   value TEXT NOT NULL
+                 );
+                 INSERT INTO parent VALUES (1);
+                 INSERT INTO items VALUES (7, 1, '42');",
+            )
+            .map_err(|error| error.to_string())
+        })
+        .unwrap();
+        let options = type_change_options("items", "value", "TEXT", "INTEGER");
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision).await.unwrap();
+
+        let backups = db::sqlite::execute_query(
+            &pool,
+            "SELECT name FROM sqlite_schema WHERE type='table' AND name GLOB 'items_[0-9]*';",
+        )
+        .await
+        .unwrap();
+        let backup_name = backups.rows[0][0].as_str().unwrap();
+        let backup_foreign_keys =
+            db::sqlite::execute_query(&pool, &format!("PRAGMA foreign_key_list({});", quote_string(backup_name)))
+                .await
+                .unwrap();
+        assert!(backup_foreign_keys.rows.is_empty());
+
+        db::sqlite::execute_query(&pool, "DELETE FROM parent WHERE id = 1;").await.unwrap();
+        let current_rows = db::sqlite::execute_query(&pool, "SELECT count(*) FROM items;").await.unwrap();
+        assert_eq!(current_rows.rows[0][0], serde_json::json!(0));
+        let backup_rows = db::sqlite::execute_query(
+            &pool,
+            &format!("SELECT count(*) FROM {} WHERE parent_id = 1;", quote_ident(backup_name)),
+        )
+        .await
+        .unwrap();
+        assert_eq!(backup_rows.rows[0][0], serde_json::json!(1));
+    }
+
+    #[tokio::test]
+    async fn successive_rebuilds_keep_distinct_backup_tables() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(&pool, "CREATE TABLE items(value TEXT NOT NULL); INSERT INTO items VALUES ('42');")
+            .await
+            .unwrap();
+
+        let first = type_change_options("items", "value", "TEXT", "INTEGER");
+        let first_preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), first.clone()).await.unwrap();
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), first, &first_preview.schema_revision)
+            .await
+            .unwrap();
+
+        let second = type_change_options("items", "value", "INTEGER", "REAL");
+        let second_preview =
+            preview_sqlite_table_structure_change_with_pool(pool.clone(), second.clone()).await.unwrap();
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), second, &second_preview.schema_revision)
+            .await
+            .unwrap();
+
+        let backups = db::sqlite::execute_query(
+            &pool,
+            "SELECT name FROM sqlite_schema WHERE type='table' AND name GLOB 'items_[0-9]*' ORDER BY name;",
+        )
+        .await
+        .unwrap();
+        assert_eq!(backups.rows.len(), 2);
+        assert_ne!(backups.rows[0][0], backups.rows[1][0]);
+    }
+
+    #[tokio::test]
+    async fn type_change_can_drop_an_explicit_unique_index_before_casting() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(
+            &pool,
+            "CREATE TABLE items(value TEXT NOT NULL);
+             CREATE UNIQUE INDEX uq_items_value ON items(value);
+             INSERT INTO items VALUES ('01'), ('1');",
+        )
+        .await
+        .unwrap();
+        let mut options = type_change_options("items", "value", "TEXT", "INTEGER");
+        options.indexes.push(EditableStructureIndex {
+            id: "uq_items_value".to_string(),
+            name: "uq_items_value".to_string(),
+            columns: vec!["value".to_string()],
+            is_unique: true,
+            is_primary: false,
+            filter: String::new(),
+            index_type: String::new(),
+            included_columns: Vec::new(),
+            comment: String::new(),
+            original: Some(IndexInfo {
+                name: "uq_items_value".to_string(),
+                columns: vec!["value".to_string()],
+                is_unique: true,
+                is_primary: false,
+                filter: None,
+                index_type: None,
+                included_columns: None,
+                comment: None,
+            }),
+            marked_for_drop: true,
+        });
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+        assert!(preview.warnings.is_empty(), "{:?}", preview.warnings);
+
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision).await.unwrap();
+
+        let values = db::sqlite::execute_query(&pool, "SELECT value FROM items ORDER BY rowid;").await.unwrap();
+        assert_eq!(values.rows, vec![vec![serde_json::json!(1)], vec![serde_json::json!(1)]]);
+        let indexes = db::sqlite::execute_query(
+            &pool,
+            "SELECT count(*) FROM sqlite_schema WHERE type='index' AND name='uq_items_value';",
+        )
+        .await
+        .unwrap();
+        assert_eq!(indexes.rows[0][0], serde_json::json!(0));
+    }
+
+    #[tokio::test]
+    async fn stale_revision_is_rejected_before_mutation() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(&pool, "CREATE TABLE items(id INTEGER PRIMARY KEY, value TEXT NOT NULL);")
+            .await
+            .unwrap();
+        let options = type_change_options("items", "value", "TEXT", "INTEGER");
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+        db::sqlite::execute_query(&pool, "ALTER TABLE items ADD COLUMN note TEXT;").await.unwrap();
+
+        let error = apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision)
+            .await
+            .unwrap_err();
+
+        assert!(error.contains("schema changed"));
+        let result = db::sqlite::execute_query(&pool, "PRAGMA table_info(items);").await.unwrap();
+        assert_eq!(result.rows.len(), 3);
+    }
+
+    #[tokio::test]
+    async fn cast_constraint_failure_rolls_back_backup_and_restores_pragmas() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        pool.with_connection(|conn| {
+            conn.execute_batch(
+                "PRAGMA foreign_keys=ON;
+                 CREATE TABLE items(id INTEGER PRIMARY KEY, value TEXT NOT NULL UNIQUE) STRICT;
+                 CREATE INDEX idx_items_value ON items(value);
+                 INSERT INTO items(id, value) VALUES (1, '01'), (2, '1');",
+            )
+            .map_err(|error| error.to_string())
+        })
+        .unwrap();
+        let options = type_change_options("items", "value", "TEXT", "INTEGER");
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+
+        let error = apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision)
+            .await
+            .unwrap_err();
+
+        assert!(error.contains("structure statement") && error.contains("failed"), "{error}");
+        let result =
+            db::sqlite::execute_query(&pool, "SELECT type FROM pragma_table_info('items') WHERE name='value';")
+                .await
+                .unwrap();
+        assert_eq!(result.rows[0][0], serde_json::json!("TEXT"));
+        let data = db::sqlite::execute_query(&pool, "SELECT value FROM items;").await.unwrap();
+        assert_eq!(data.rows.len(), 2);
+        assert_eq!(data.rows[0][0], serde_json::json!("01"));
+        assert_eq!(data.rows[1][0], serde_json::json!("1"));
+        let index = db::sqlite::execute_query(
+            &pool,
+            "SELECT count(*) FROM sqlite_schema WHERE type='index' AND name='idx_items_value';",
+        )
+        .await
+        .unwrap();
+        assert_eq!(index.rows[0][0], serde_json::json!(1));
+        let foreign_keys = db::sqlite::execute_query(&pool, "PRAGMA foreign_keys;").await.unwrap();
+        assert_eq!(foreign_keys.rows[0][0], serde_json::json!(1));
+        let legacy_alter_table = db::sqlite::execute_query(&pool, "PRAGMA legacy_alter_table;").await.unwrap();
+        assert_eq!(legacy_alter_table.rows[0][0], serde_json::json!(0));
+        let backup =
+            db::sqlite::execute_query(&pool, "SELECT count(*) FROM sqlite_schema WHERE name GLOB 'items_[0-9]*';")
+                .await
+                .unwrap();
+        assert_eq!(backup.rows[0][0], serde_json::json!(0));
+    }
+
+    #[tokio::test]
+    async fn rebuild_preserves_autoincrement_high_water_mark() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(
+            &pool,
+            "CREATE TABLE items(id INTEGER PRIMARY KEY AUTOINCREMENT, value TEXT NOT NULL);\
+             INSERT INTO items(id, value) VALUES (100, '42');\
+             DELETE FROM items;\
+             INSERT INTO items(id, value) VALUES (1, '7');",
+        )
+        .await
+        .unwrap();
+        let mut options = type_change_options("items", "value", "TEXT", "INTEGER");
+        options.columns.insert(
+            0,
+            EditableStructureColumn {
+                id: "id".to_string(),
+                name: "id".to_string(),
+                data_type: "INTEGER".to_string(),
+                is_nullable: true,
+                default_value: String::new(),
+                comment: String::new(),
+                is_primary_key: true,
+                extra: Some(ColumnExtra::default()),
+                original: Some(ColumnInfo {
+                    name: "id".to_string(),
+                    data_type: "INTEGER".to_string(),
+                    is_nullable: true,
+                    column_default: None,
+                    is_primary_key: true,
+                    extra: Some("autoincrement".to_string()),
+                    comment: None,
+                    character_set: None,
+                    collation: None,
+                }),
+                original_position: Some(0),
+                marked_for_drop: false,
+                character_set: String::new(),
+                collation: String::new(),
+            },
+        );
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+        assert!(preview.warnings.is_empty(), "{:?}", preview.warnings);
+
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision).await.unwrap();
+        db::sqlite::execute_query(&pool, "INSERT INTO items(value) VALUES (8);").await.unwrap();
+
+        let result = db::sqlite::execute_query(&pool, "SELECT max(id) FROM items;").await.unwrap();
+        assert_eq!(result.rows[0][0], serde_json::json!(101));
+    }
+
+    #[tokio::test]
+    async fn revision_is_bound_to_the_structure_draft() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(&pool, "CREATE TABLE items(value TEXT NOT NULL);").await.unwrap();
+        let integer_options = type_change_options("items", "value", "TEXT", "INTEGER");
+        let preview =
+            preview_sqlite_table_structure_change_with_pool(pool.clone(), integer_options.clone()).await.unwrap();
+        let real_options = type_change_options("items", "value", "TEXT", "REAL");
+
+        let error = apply_sqlite_table_structure_change_with_pool(pool.clone(), real_options, &preview.schema_revision)
+            .await
+            .unwrap_err();
+
+        assert!(error.contains("structure draft differs"));
+        let result =
+            db::sqlite::execute_query(&pool, "SELECT type FROM pragma_table_info('items') WHERE name='value';")
+                .await
+                .unwrap();
+        assert_eq!(result.rows[0][0], serde_json::json!("TEXT"));
+    }
+
+    #[tokio::test]
+    async fn rebuild_preserves_hidden_rowid_for_ordinary_tables() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(
+            &pool,
+            "CREATE TABLE items(value TEXT NOT NULL) /* WITHOUT ROWID */ STRICT;\
+             INSERT INTO items(rowid, value) VALUES (17, '42');",
+        )
+        .await
+        .unwrap();
+        let options = type_change_options("items", "value", "TEXT", "INTEGER");
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision).await.unwrap();
+
+        let result = db::sqlite::execute_query(&pool, "SELECT rowid, typeof(value), value FROM items;").await.unwrap();
+        assert_eq!(result.rows[0][0], serde_json::json!(17));
+        assert_eq!(result.rows[0][1], serde_json::json!("integer"));
+        assert_eq!(result.rows[0][2], serde_json::json!(42));
+    }
+
+    #[tokio::test]
+    async fn cast_copy_preserves_null_and_does_not_cast_unchanged_columns() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(
+            &pool,
+            "CREATE TABLE items(value TEXT, note TEXT NOT NULL);\
+             INSERT INTO items(value, note) VALUES (NULL, 'first'), ('12', 'second');",
+        )
+        .await
+        .unwrap();
+        let mut options = type_change_options("items", "value", "TEXT", "INTEGER");
+        options.columns[0].is_nullable = true;
+        options.columns[0].original.as_mut().unwrap().is_nullable = true;
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+        let copy = preview.statements.iter().find(|sql| sql.contains("CAST(")).unwrap();
+        assert!(copy.contains("CAST(\"__dbx_source\".\"value\" AS INTEGER)"));
+        assert!(!copy.contains("CAST(\"__dbx_source\".\"note\""));
+
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision).await.unwrap();
+
+        let result = db::sqlite::execute_query(&pool, "SELECT value, typeof(value), note FROM items ORDER BY rowid;")
+            .await
+            .unwrap();
+        assert_eq!(result.rows[0], serde_json::json!([null, "null", "first"]).as_array().unwrap().clone());
+        assert_eq!(result.rows[1], serde_json::json!([12, "integer", "second"]).as_array().unwrap().clone());
+    }
+
+    #[tokio::test]
+    async fn strict_table_uses_sqlite_cast_semantics_for_incompatible_text() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(
+            &pool,
+            "CREATE TABLE items(value TEXT NOT NULL) STRICT; INSERT INTO items VALUES ('not-a-number');",
+        )
+        .await
+        .unwrap();
+        let options = type_change_options("items", "value", "TEXT", "INTEGER");
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision).await.unwrap();
+
+        let result = db::sqlite::execute_query(&pool, "SELECT typeof(value), value FROM items;").await.unwrap();
+        assert_eq!(result.rows[0][0], serde_json::json!("integer"));
+        assert_eq!(result.rows[0][1], serde_json::json!(0));
+    }
+
+    #[tokio::test]
+    async fn text_email_to_float4_uses_explicit_real_cast() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(
+            &pool,
+            "CREATE TABLE users(email TEXT NOT NULL); INSERT INTO users VALUES ('alice@example.com');",
+        )
+        .await
+        .unwrap();
+        let options = type_change_options("users", "email", "TEXT", "float4");
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+        let copy = preview.statements.iter().find(|sql| sql.contains("CAST(")).unwrap();
+        assert!(copy.contains("CAST(\"__dbx_source\".\"email\" AS float4)"));
+
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision).await.unwrap();
+
+        let result = db::sqlite::execute_query(&pool, "SELECT typeof(email), email FROM users;").await.unwrap();
+        assert_eq!(result.rows[0][0], serde_json::json!("real"));
+        assert_eq!(result.rows[0][1], serde_json::json!(0.0));
+    }
+
+    #[tokio::test]
+    async fn combined_column_rename_and_type_change_casts_source_then_updates_dependencies() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(
+            &pool,
+            "CREATE TABLE audit(message TEXT);
+             CREATE TABLE items(old_value TEXT NOT NULL);
+             CREATE INDEX idx_items_old_value ON items(old_value);
+             CREATE TRIGGER trg_items_update AFTER UPDATE OF old_value ON items
+             BEGIN INSERT INTO audit VALUES (NEW.old_value); END;
+             INSERT INTO items VALUES ('7');",
+        )
+        .await
+        .unwrap();
+        let mut options = type_change_options("items", "old_value", "TEXT", "INTEGER");
+        options.columns[0].name = "new_value".to_string();
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+        let copy = preview.statements.iter().find(|sql| sql.contains("CAST(")).unwrap();
+        assert!(copy.contains("CAST(\"__dbx_source\".\"old_value\" AS INTEGER)"));
+
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision).await.unwrap();
+
+        let result = db::sqlite::execute_query(&pool, "SELECT typeof(new_value), new_value FROM items;").await.unwrap();
+        assert_eq!(result.rows[0][0], serde_json::json!("integer"));
+        assert_eq!(result.rows[0][1], serde_json::json!(7));
+        let dependencies = db::sqlite::execute_query(
+            &pool,
+            "SELECT sql FROM sqlite_schema WHERE name IN ('idx_items_old_value', 'trg_items_update') ORDER BY type;",
+        )
+        .await
+        .unwrap();
+        assert_eq!(dependencies.rows.len(), 2);
+        assert!(dependencies.rows.iter().all(|row| row[0].as_str().unwrap().contains("new_value")));
+        db::sqlite::execute_query(&pool, "UPDATE items SET new_value = 8;").await.unwrap();
+        let audit = db::sqlite::execute_query(&pool, "SELECT message FROM audit;").await.unwrap();
+        assert_eq!(audit.rows[0][0], serde_json::json!("8"));
+    }
+
+    #[tokio::test]
+    async fn rebuild_blocks_shadowed_hidden_rowid_and_integer_primary_key_alias_changes() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(
+            &pool,
+            "CREATE TABLE shadowed(rowid TEXT, _rowid_ TEXT, oid TEXT, value TEXT NOT NULL);",
+        )
+        .await
+        .unwrap();
+        let shadowed = type_change_options("shadowed", "value", "TEXT", "INTEGER");
+        let shadowed_preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), shadowed).await.unwrap();
+        assert!(shadowed_preview.warnings.iter().any(|warning| warning.contains("hidden rowid")));
+
+        db::sqlite::execute_query(&pool, "CREATE TABLE keyed(id TEXT PRIMARY KEY);").await.unwrap();
+        let mut keyed = type_change_options("keyed", "id", "TEXT", "INTEGER");
+        keyed.columns[0].is_nullable = true;
+        keyed.columns[0].is_primary_key = true;
+        keyed.columns[0].original.as_mut().unwrap().is_nullable = true;
+        keyed.columns[0].original.as_mut().unwrap().is_primary_key = true;
+        let keyed_preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), keyed).await.unwrap();
+        assert!(keyed_preview.warnings.iter().any(|warning| warning.contains("rowid alias semantics")));
+    }
+
+    #[tokio::test]
+    async fn virtual_tables_are_rejected_using_table_list_kind() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(&pool, "CREATE VIRTUAL TABLE docs USING fts5(content);").await.unwrap();
+        let options = type_change_options("docs", "content", "", "TEXT");
+
+        let error = preview_sqlite_table_structure_change_with_pool(pool, options).await.unwrap_err();
+
+        assert!(error.contains("table_list type \"virtual\""), "{error}");
+    }
+
+    #[tokio::test]
+    async fn fts_shadow_tables_are_rejected_using_table_list_kind() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(&pool, "CREATE VIRTUAL TABLE docs USING fts5(content);").await.unwrap();
+        let options = type_change_options("docs_data", "id", "INTEGER", "TEXT");
+
+        let error = preview_sqlite_table_structure_change_with_pool(pool, options).await.unwrap_err();
+
+        assert!(error.contains("table_list type \"shadow\""), "{error}");
+    }
+
+    #[tokio::test]
+    async fn without_rowid_composite_primary_key_type_change_preserves_data() {
+        let pool = db::sqlite::connect_path(":memory:").await.unwrap();
+        db::sqlite::execute_query(
+            &pool,
+            "CREATE TABLE items(\
+               part TEXT NOT NULL,\
+               seq INTEGER NOT NULL,\
+               value TEXT,\
+               PRIMARY KEY(part, seq)\
+             ) WITHOUT ROWID;\
+             INSERT INTO items(part, seq, value) VALUES ('a', 7, 'kept');",
+        )
+        .await
+        .unwrap();
+        let options = type_change_options("items", "seq", "INTEGER", "TEXT");
+        let preview = preview_sqlite_table_structure_change_with_pool(pool.clone(), options.clone()).await.unwrap();
+        assert!(preview.warnings.is_empty(), "{:?}", preview.warnings);
+
+        apply_sqlite_table_structure_change_with_pool(pool.clone(), options, &preview.schema_revision).await.unwrap();
+
+        let result =
+            db::sqlite::execute_query(&pool, "SELECT part, typeof(seq), seq, value FROM items;").await.unwrap();
+        assert_eq!(result.rows[0][0], serde_json::json!("a"));
+        assert_eq!(result.rows[0][1], serde_json::json!("text"));
+        assert_eq!(result.rows[0][2], serde_json::json!("7"));
+        assert_eq!(result.rows[0][3], serde_json::json!("kept"));
+    }
+}
diff --git a/crates/dbx-core/src/table_structure_sql/tests.rs b/crates/dbx-core/src/table_structure_sql/tests.rs
new file mode 100644
index 0000000..45ae016
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/tests.rs
@@ -0,0 +1,3035 @@
+use super::*;
+use crate::models::connection::DatabaseType;
+
+fn column(name: &str) -> EditableStructureColumn {
+    EditableStructureColumn {
+        id: name.to_string(),
+        name: name.to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        default_value: String::new(),
+        comment: String::new(),
+        is_primary_key: false,
+        extra: None,
+        original: None,
+        original_position: None,
+        marked_for_drop: false,
+        character_set: String::new(),
+        collation: String::new(),
+    }
+}
+
+fn index(name: &str, columns: &[&str]) -> EditableStructureIndex {
+    EditableStructureIndex {
+        id: name.to_string(),
+        name: name.to_string(),
+        columns: columns.iter().map(|column| column.to_string()).collect(),
+        is_unique: false,
+        is_primary: false,
+        filter: String::new(),
+        index_type: String::new(),
+        included_columns: Vec::new(),
+        comment: String::new(),
+        original: None,
+        marked_for_drop: false,
+    }
+}
+
+fn foreign_key(name: &str, column: &str, ref_table: &str, ref_column: &str) -> EditableStructureForeignKey {
+    EditableStructureForeignKey {
+        id: name.to_string(),
+        name: name.to_string(),
+        column: column.to_string(),
+        ref_schema: String::new(),
+        ref_table: ref_table.to_string(),
+        ref_column: ref_column.to_string(),
+        on_update: String::new(),
+        on_delete: String::new(),
+        original: None,
+        marked_for_drop: false,
+    }
+}
+
+fn trigger(name: &str, timing: &str, event: &str, statement: &str) -> EditableStructureTrigger {
+    EditableStructureTrigger {
+        id: name.to_string(),
+        name: name.to_string(),
+        timing: timing.to_string(),
+        event: event.to_string(),
+        statement: statement.to_string(),
+        original: None,
+        marked_for_drop: false,
+    }
+}
+
+#[test]
+fn builds_mysql_column_and_index_changes() {
+    let mut renamed = column("display_name");
+    renamed.data_type = "varchar(120)".to_string();
+    renamed.is_nullable = false;
+    renamed.default_value = "guest".to_string();
+    renamed.comment = "Shown name".to_string();
+    renamed.original = Some(ColumnInfo {
+        name: "name".to_string(),
+        data_type: "varchar(80)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some(String::new()),
+        ..Default::default()
+    });
+    let mut email = column("email");
+    email.is_nullable = false;
+    let mut old_index = index("idx_old", &["name"]);
+    old_index.marked_for_drop = true;
+    old_index.original = Some(IndexInfo {
+        name: "idx_old".to_string(),
+        columns: vec!["name".to_string()],
+        is_unique: false,
+        is_primary: false,
+        filter: None,
+        index_type: None,
+        included_columns: None,
+        comment: None,
+    });
+    let mut email_index = index("uniq_users_email", &["email"]);
+    email_index.is_unique = true;
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![renamed, email],
+        indexes: vec![old_index, email_index],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE `users` CHANGE COLUMN `name` `display_name` varchar(120) NOT NULL DEFAULT 'guest' COMMENT 'Shown name';",
+            "ALTER TABLE `users` ADD COLUMN `email` varchar(255) NOT NULL;",
+            "DROP INDEX `idx_old` ON `users`;",
+            "CREATE UNIQUE INDEX `uniq_users_email` ON `users` (`email`);",
+        ]
+    );
+}
+
+#[test]
+fn builds_mysql_unsigned_integer_column_with_length_before_attribute() {
+    let mut score = column("score");
+    score.data_type = "int unsigned(11)".to_string();
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![score],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE `users` ADD COLUMN `score` int(11) unsigned;"]);
+}
+
+#[test]
+fn doris_table_editor_renames_column_without_mysql_change_syntax() {
+    let mut renamed = column("dtp_flag_jt");
+    renamed.data_type = "int".to_string();
+    renamed.comment = "Group DTP".to_string();
+    renamed.original = Some(ColumnInfo {
+        name: "dtp_flag".to_string(),
+        data_type: "int".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some("Group DTP".to_string()),
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Doris),
+        schema: Some("qybiprod".to_string()),
+        table_name: "dim_prod_sp_vkorg".to_string(),
+        columns: vec![renamed],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE `dim_prod_sp_vkorg` RENAME COLUMN `dtp_flag` `dtp_flag_jt`;"]);
+}
+
+#[test]
+fn doris_single_column_alter_renames_then_modifies_column_definition() {
+    let mut renamed = column("dtp_flag_jt");
+    renamed.data_type = "int".to_string();
+    renamed.comment = "Group DTP".to_string();
+    renamed.original = Some(ColumnInfo {
+        name: "dtp_flag".to_string(),
+        data_type: "int".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some("Division DTP".to_string()),
+        ..Default::default()
+    });
+
+    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
+        database_type: Some(DatabaseType::Doris),
+        schema: Some("qybiprod".to_string()),
+        table_name: "dim_prod_sp_vkorg".to_string(),
+        column: renamed,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE `dim_prod_sp_vkorg` RENAME COLUMN `dtp_flag` `dtp_flag_jt`;",
+            "ALTER TABLE `dim_prod_sp_vkorg` MODIFY COLUMN `dtp_flag_jt` int COMMENT 'Group DTP';",
+        ]
+    );
+}
+
+#[test]
+fn dameng_integer_column_omits_mysql_display_width() {
+    let mut age = column("age");
+    age.data_type = "integer(11)".to_string();
+    let mut amount = column("amount");
+    amount.data_type = "number(10,0)".to_string();
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Dameng),
+        schema: Some("SYSDBA".to_string()),
+        table_name: "users".to_string(),
+        columns: vec![age, amount],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE \"SYSDBA\".\"users\" ADD (\"age\" integer);",
+            "ALTER TABLE \"SYSDBA\".\"users\" ADD (\"amount\" number(10,0));",
+        ]
+    );
+}
+
+#[test]
+fn builds_highgo_foreign_key_changes_with_postgres_syntax() {
+    let mut old_fk = foreign_key("orders_user_id_fkey", "user_id", "users", "id");
+    old_fk.marked_for_drop = true;
+    old_fk.original = Some(ForeignKeyInfo {
+        name: "orders_user_id_fkey".to_string(),
+        column: "user_id".to_string(),
+        ref_schema: Some("public".to_string()),
+        ref_table: "users".to_string(),
+        ref_column: "id".to_string(),
+        on_update: None,
+        on_delete: None,
+    });
+    let mut new_fk = foreign_key("orders_account_id_fkey", "account_id", "accounts", "id");
+    new_fk.ref_schema = "crm".to_string();
+    new_fk.on_delete = "CASCADE".to_string();
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Highgo),
+        schema: Some("public".to_string()),
+        table_name: "orders".to_string(),
+        columns: Vec::new(),
+        indexes: Vec::new(),
+        foreign_keys: vec![old_fk, new_fk],
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE \"public\".\"orders\" DROP CONSTRAINT \"orders_user_id_fkey\";",
+            "ALTER TABLE \"public\".\"orders\" ADD CONSTRAINT \"orders_account_id_fkey\" FOREIGN KEY (\"account_id\") REFERENCES \"crm\".\"accounts\" (\"id\") ON DELETE CASCADE;",
+        ]
+    );
+}
+
+#[test]
+fn builds_informix_column_and_index_changes() {
+    let mut renamed = column("display_name");
+    renamed.data_type = "varchar(120)".to_string();
+    renamed.is_nullable = false;
+    renamed.default_value = "guest".to_string();
+    renamed.original = Some(ColumnInfo {
+        name: "name".to_string(),
+        data_type: "varchar(80)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some(String::new()),
+        ..Default::default()
+    });
+    let mut email = column("email");
+    email.is_nullable = false;
+    let mut old_col = column("old_col");
+    old_col.marked_for_drop = true;
+    old_col.original = Some(ColumnInfo {
+        name: "old_col".to_string(),
+        data_type: "varchar(20)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+    let mut old_index = index("idx_old", &["name"]);
+    old_index.marked_for_drop = true;
+    old_index.original = Some(IndexInfo {
+        name: "idx_old".to_string(),
+        columns: vec!["name".to_string()],
+        is_unique: false,
+        is_primary: false,
+        filter: None,
+        index_type: None,
+        included_columns: None,
+        comment: None,
+    });
+    let mut email_index = index("uniq_users_email", &["email"]);
+    email_index.is_unique = true;
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Informix),
+        schema: Some("gbasedbt".to_string()),
+        table_name: "users".to_string(),
+        columns: vec![renamed, email, old_col],
+        indexes: vec![old_index, email_index],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "RENAME COLUMN gbasedbt.users.name TO display_name;",
+            "ALTER TABLE gbasedbt.users MODIFY (display_name varchar(120) NOT NULL DEFAULT 'guest');",
+            "ALTER TABLE gbasedbt.users ADD (email varchar(255) NOT NULL);",
+            "ALTER TABLE gbasedbt.users DROP (old_col);",
+            "DROP INDEX gbasedbt.idx_old;",
+            "CREATE UNIQUE INDEX uniq_users_email ON gbasedbt.users (email);",
+        ]
+    );
+}
+
+#[test]
+fn oracle_does_not_generate_drop_sql_for_all_columns() {
+    let mut id = column("id");
+    id.marked_for_drop = true;
+    id.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "varchar2(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+    let mut name = column("name");
+    name.marked_for_drop = true;
+    name.original = Some(ColumnInfo {
+        name: "name".to_string(),
+        data_type: "varchar2(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Oracle),
+        schema: Some("DBX_TEST".to_string()),
+        table_name: "test".to_string(),
+        columns: vec![id, name],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.statements, Vec::<String>::new());
+    assert_eq!(
+        result.warnings,
+        vec![
+            "Oracle does not allow dropping all columns from a table. Keep at least one column or drop the table instead."
+        ]
+    );
+}
+
+#[test]
+fn oracle_timestamp_default_precedes_nullability_in_modify_sql() {
+    let mut col = column("time");
+    col.data_type = "TIMESTAMP(6)".to_string();
+    col.default_value = "CURRENT_TIMESTAMP".to_string();
+    col.original = Some(ColumnInfo {
+        name: "time".to_string(),
+        data_type: "TIMESTAMP(6)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some(String::new()),
+        ..Default::default()
+    });
+
+    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
+        database_type: Some(DatabaseType::Oracle),
+        schema: Some("DBX_TEST".to_string()),
+        table_name: "test".to_string(),
+        column: col,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec!["ALTER TABLE \"DBX_TEST\".\"test\" MODIFY (\"time\" TIMESTAMP(6) DEFAULT CURRENT_TIMESTAMP);"]
+    );
+}
+
+#[test]
+fn oracle_timestamp_precision_change_does_not_repeat_unchanged_nullability() {
+    let mut col = column("time");
+    col.data_type = "TIMESTAMP(9)".to_string();
+    col.original = Some(ColumnInfo {
+        name: "time".to_string(),
+        data_type: "TIMESTAMP(6)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some(String::new()),
+        ..Default::default()
+    });
+
+    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
+        database_type: Some(DatabaseType::Oracle),
+        schema: Some("DBX_TEST".to_string()),
+        table_name: "test".to_string(),
+        column: col,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE \"DBX_TEST\".\"test\" MODIFY (\"time\" TIMESTAMP(9));"]);
+}
+
+#[test]
+fn iris_drop_index_includes_table_name() {
+    let mut old_index = index("index_id", &["ID"]);
+    old_index.marked_for_drop = true;
+    old_index.original = Some(IndexInfo {
+        name: "index_id".to_string(),
+        columns: vec!["ID".to_string()],
+        is_unique: false,
+        is_primary: false,
+        filter: None,
+        index_type: None,
+        included_columns: None,
+        comment: None,
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Iris),
+        schema: Some("SQLUSER".to_string()),
+        table_name: "tb_a".to_string(),
+        columns: Vec::new(),
+        indexes: vec![old_index],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["DROP INDEX \"index_id\" ON TABLE \"SQLUSER\".\"tb_a\";"]);
+}
+
+#[test]
+fn mysql_create_index_with_comment() {
+    let mut col = column("name");
+    col.data_type = "varchar(120)".to_string();
+    let mut idx = index("idx_users_name", &["name"]);
+    idx.comment = "Search index".to_string();
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: vec![idx],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE `users` ADD COLUMN `name` varchar(120);",
+            "CREATE INDEX `idx_users_name` ON `users` (`name`) COMMENT 'Search index';",
+        ]
+    );
+}
+
+#[test]
+fn manticoresearch_builds_create_table_sql_only() {
+    let mut title = column("title");
+    title.data_type = "text".to_string();
+    title.is_nullable = false;
+    let mut views = column("views");
+    views.data_type = "int".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::ManticoreSearch),
+        schema: None,
+        table_name: "materials".to_string(),
+        columns: vec![title, views],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["CREATE TABLE `materials` (\n  `title` text,\n  `views` int\n);"]);
+}
+
+#[test]
+fn manticoresearch_builds_add_and_drop_column_sql() {
+    let mut old_code = column("code");
+    old_code.data_type = "string".to_string();
+    old_code.marked_for_drop = true;
+    old_code.original = Some(ColumnInfo {
+        name: "code".to_string(),
+        data_type: "string".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut name = column("name");
+    name.data_type = "string".to_string();
+    name.extra =
+        Some(ColumnExtra { manticore_attribute: Some(true), manticore_indexed: Some(true), ..Default::default() });
+    let mut resource = column("resource");
+    resource.data_type = "json".to_string();
+    resource.extra = Some(ColumnExtra { manticore_secondary_index: Some(true), ..Default::default() });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::ManticoreSearch),
+        schema: None,
+        table_name: "materials".to_string(),
+        columns: vec![old_code, name, resource],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE `materials` DROP COLUMN `code`;",
+            "ALTER TABLE `materials` ADD COLUMN `name` string attribute indexed;",
+            "ALTER TABLE `materials` ADD COLUMN `resource` json secondary_index='1';",
+        ]
+    );
+}
+
+#[test]
+fn gbase8a_uses_limited_mysql_ddl() {
+    let mut renamed = column("display_email");
+    renamed.data_type = "varchar(255)".to_string();
+    renamed.original = Some(ColumnInfo {
+        name: "email".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+    let new_col = column("nickname");
+    let mut old_col = column("old_col");
+    old_col.marked_for_drop = true;
+    old_col.original = Some(ColumnInfo {
+        name: "old_col".to_string(),
+        data_type: "varchar(20)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+    let mut index = index("idx_users_email", &["display_email"]);
+    index.original = Some(IndexInfo {
+        name: "idx_users_email".to_string(),
+        columns: vec!["email".to_string()],
+        is_unique: false,
+        is_primary: false,
+        filter: None,
+        index_type: None,
+        included_columns: None,
+        comment: None,
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Gbase),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![renamed, new_col, old_col],
+        indexes: vec![index],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE `users` CHANGE COLUMN `email` `display_email` varchar(255);",
+            "ALTER TABLE `users` ADD COLUMN `nickname` varchar(255);",
+            "ALTER TABLE `users` DROP COLUMN `old_col`;",
+        ]
+    );
+    assert_eq!(
+        result.warnings,
+        vec!["Editing existing indexes is not supported for gbase from this editor.".to_string()]
+    );
+}
+
+#[test]
+fn gbase8a_allows_mysql_style_column_reorder() {
+    let mut id = column("id");
+    id.original_position = Some(0);
+    id.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut name = column("name");
+    name.original_position = Some(1);
+    name.original = Some(ColumnInfo {
+        name: "name".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut email = column("email");
+    email.original_position = Some(2);
+    email.original = Some(ColumnInfo {
+        name: "email".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Gbase),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![id, email, name],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE `users` MODIFY COLUMN `name` varchar(255) AFTER `email`;"]);
+}
+
+#[test]
+fn manticoresearch_does_not_drop_id_column() {
+    let mut id = column("id");
+    id.data_type = "bigint".to_string();
+    id.marked_for_drop = true;
+    id.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "bigint".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::ManticoreSearch),
+        schema: None,
+        table_name: "materials".to_string(),
+        columns: vec![id],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.statements, Vec::<String>::new());
+    assert_eq!(result.warnings, vec!["Manticore Search id column cannot be dropped from this editor."]);
+}
+
+#[test]
+fn manticoresearch_warns_when_existing_column_properties_change() {
+    let mut name = column("name");
+    name.data_type = "string".to_string();
+    name.extra = Some(ColumnExtra {
+        manticore_indexed: Some(true),
+        manticore_stored: Some(true),
+        manticore_attribute: Some(true),
+        ..Default::default()
+    });
+    name.original = Some(ColumnInfo {
+        name: "name".to_string(),
+        data_type: "string".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut resource = column("resource");
+    resource.data_type = "json".to_string();
+    resource.extra = Some(ColumnExtra { manticore_secondary_index: Some(true), ..Default::default() });
+    resource.original = Some(ColumnInfo {
+        name: "resource".to_string(),
+        data_type: "json".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut old_resource = column("old_resource");
+    old_resource.data_type = "json".to_string();
+    old_resource.extra = Some(ColumnExtra::default());
+    old_resource.original = Some(ColumnInfo {
+        name: "old_resource".to_string(),
+        data_type: "json".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: Some("secondary_index='1'".to_string()),
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::ManticoreSearch),
+        schema: None,
+        table_name: "materials".to_string(),
+        columns: vec![name, resource, old_resource],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.statements, Vec::<String>::new());
+    assert_eq!(
+        result.warnings,
+        vec![
+            "Editing existing columns is not supported for manticoresearch yet.",
+            "Editing existing columns is not supported for manticoresearch yet.",
+            "Editing existing columns is not supported for manticoresearch yet.",
+        ]
+    );
+}
+
+#[test]
+fn manticoresearch_ignores_mysql_column_options() {
+    let mut title = column("title");
+    title.data_type = "text".to_string();
+    title.is_nullable = false;
+    title.is_primary_key = true;
+    title.default_value = "'untitled'".to_string();
+    title.comment = "Title text".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::ManticoreSearch),
+        schema: None,
+        table_name: "materials".to_string(),
+        columns: vec![title],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["CREATE TABLE `materials` (\n  `title` text\n);"]);
+}
+
+#[test]
+fn manticoresearch_builds_text_column_properties() {
+    let mut title = column("title");
+    title.data_type = "text".to_string();
+    title.extra =
+        Some(ColumnExtra { manticore_indexed: Some(true), manticore_stored: Some(true), ..Default::default() });
+    let mut sku = column("sku");
+    sku.data_type = "string".to_string();
+    sku.extra =
+        Some(ColumnExtra { manticore_indexed: Some(true), manticore_attribute: Some(true), ..Default::default() });
+    let mut name = column("name");
+    name.data_type = "string".to_string();
+    name.extra = Some(ColumnExtra {
+        manticore_indexed: Some(true),
+        manticore_stored: Some(true),
+        manticore_attribute: Some(true),
+        ..Default::default()
+    });
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::ManticoreSearch),
+        schema: None,
+        table_name: "materials".to_string(),
+        columns: vec![title, sku, name],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "CREATE TABLE `materials` (\n  `title` text stored indexed,\n  `sku` string attribute indexed,\n  `name` string stored attribute indexed\n);"
+        ]
+    );
+}
+
+#[test]
+fn manticoresearch_builds_json_secondary_index_property() {
+    let mut metadata = column("metadata");
+    metadata.data_type = "json".to_string();
+    metadata.extra = Some(ColumnExtra { manticore_secondary_index: Some(true), ..Default::default() });
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::ManticoreSearch),
+        schema: None,
+        table_name: "materials".to_string(),
+        columns: vec![metadata],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["CREATE TABLE `materials` (\n  `metadata` json secondary_index='1'\n);"]);
+}
+
+#[test]
+fn mysql_create_unique_index_with_comment_and_btree() {
+    let mut idx = index("uniq_users_email", &["email"]);
+    idx.is_unique = true;
+    idx.index_type = "BTREE".to_string();
+    idx.comment = "Unique email index".to_string();
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: Vec::new(),
+        indexes: vec![idx],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec!["CREATE UNIQUE INDEX `uniq_users_email` USING BTREE ON `users` (`email`) COMMENT 'Unique email index';",]
+    );
+}
+
+#[test]
+fn mysql_add_timestamp_column_drops_invalid_precision() {
+    let mut created_at = column("created_at");
+    created_at.data_type = "timestamp(255)".to_string();
+    created_at.default_value = "CURRENT_TIMESTAMP".to_string();
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![created_at],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec!["ALTER TABLE `users` ADD COLUMN `created_at` timestamp DEFAULT CURRENT_TIMESTAMP;"]
+    );
+}
+
+#[test]
+fn mysql_add_timestamp_column_preserves_valid_precision() {
+    let mut created_at = column("created_at");
+    created_at.data_type = "timestamp(3)".to_string();
+    created_at.default_value = "CURRENT_TIMESTAMP(3)".to_string();
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![created_at],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec!["ALTER TABLE `users` ADD COLUMN `created_at` timestamp(3) DEFAULT CURRENT_TIMESTAMP(3);"]
+    );
+}
+
+#[test]
+fn builds_postgres_create_table_with_comments_and_index() {
+    let mut id = column("id");
+    id.data_type = "integer".to_string();
+    id.is_nullable = false;
+    id.is_primary_key = true;
+    let mut name = column("name");
+    name.data_type = "text".to_string();
+    name.comment = "Display name".to_string();
+    let mut idx = index("idx_users_name", &["name"]);
+    idx.index_type = "gin".to_string();
+    idx.comment = "search".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some("public".to_string()),
+        table_name: "users".to_string(),
+        columns: vec![id, name],
+        indexes: vec![idx],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "CREATE TABLE \"public\".\"users\" (\n  \"id\" integer,\n  \"name\" text,\n  PRIMARY KEY (\"id\")\n);",
+            "COMMENT ON COLUMN \"public\".\"users\".\"name\" IS 'Display name';",
+            "CREATE INDEX \"idx_users_name\" ON \"public\".\"users\" USING GIN (\"name\");",
+            "COMMENT ON INDEX \"idx_users_name\" IS 'search';",
+        ]
+    );
+}
+
+#[test]
+fn warns_for_sqlite_unsafe_column_changes() {
+    let mut col = column("name");
+    col.data_type = "text".to_string();
+    col.original = Some(ColumnInfo {
+        name: "name".to_string(),
+        data_type: "varchar(80)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Sqlite),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.statements, Vec::<String>::new());
+    assert_eq!(
+        result.warnings,
+        vec!["SQLite cannot safely alter existing column \"name\" without rebuilding the table."]
+    );
+}
+
+#[test]
+fn builds_rqlite_changes_with_sqlite_dialect() {
+    let mut email = column("email");
+    email.data_type = "text".to_string();
+    email.is_nullable = false;
+    let mut email_index = index("idx_users_email", &["email"]);
+    email_index.filter = "email IS NOT NULL".to_string();
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Rqlite),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![email],
+        indexes: vec![email_index],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE \"users\" ADD COLUMN \"email\" text NOT NULL;",
+            "CREATE INDEX \"idx_users_email\" ON \"users\" (\"email\") WHERE email IS NOT NULL;",
+        ]
+    );
+}
+
+#[test]
+fn builds_kingbase_add_column_without_column_keyword() {
+    let mut flag = column("flag");
+    flag.data_type = "varchar(100)".to_string();
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Kingbase),
+        schema: Some("dbo".to_string()),
+        table_name: "dw_bill_info_copy".to_string(),
+        columns: vec![flag],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE \"dbo\".\"dw_bill_info_copy\" ADD \"flag\" varchar(100);"]);
+}
+
+#[test]
+fn builds_mysql_column_reorder_statements() {
+    let mut id = column("id");
+    id.data_type = "int".to_string();
+    id.is_nullable = false;
+    id.is_primary_key = true;
+    id.original_position = Some(0);
+    id.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "int".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: true,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut email = column("email");
+    email.original_position = Some(2);
+    email.original = Some(ColumnInfo {
+        name: "email".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut name = column("display_name");
+    name.id = "name".to_string();
+    name.data_type = "varchar(120)".to_string();
+    name.original_position = Some(1);
+    name.original = Some(ColumnInfo {
+        name: "name".to_string(),
+        data_type: "varchar(80)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![id, email, name],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec!["ALTER TABLE `users` CHANGE COLUMN `name` `display_name` varchar(120) AFTER `email`;"]
+    );
+}
+
+#[test]
+fn mysql_add_column_before_existing_column_does_not_reorder_shifted_column() {
+    let mut deleted = column("deleted");
+    deleted.original_position = Some(0);
+    deleted.original = Some(ColumnInfo {
+        name: "deleted".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let new_column = column("sss");
+
+    let mut tenant_id = column("tenant_id");
+    tenant_id.data_type = "bigint".to_string();
+    tenant_id.is_nullable = false;
+    tenant_id.default_value = "0".to_string();
+    tenant_id.comment = "tenant id".to_string();
+    tenant_id.original_position = Some(1);
+    tenant_id.original = Some(ColumnInfo {
+        name: "tenant_id".to_string(),
+        data_type: "bigint".to_string(),
+        is_nullable: false,
+        column_default: Some("0".to_string()),
+        is_primary_key: false,
+        extra: None,
+        comment: Some("tenant id".to_string()),
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "infra_api_error_log".to_string(),
+        columns: vec![deleted, new_column, tenant_id],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec!["ALTER TABLE `infra_api_error_log` ADD COLUMN `sss` varchar(255) AFTER `deleted`;"]
+    );
+}
+
+#[test]
+fn mysql_existing_column_reorder_does_not_reorder_columns_shifted_by_prior_move() {
+    let mut id = column("id");
+    id.original_position = Some(0);
+    id.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut name = column("name");
+    name.original_position = Some(1);
+    name.original = Some(ColumnInfo {
+        name: "name".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut email = column("email");
+    email.original_position = Some(2);
+    email.original = Some(ColumnInfo {
+        name: "email".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![id, email, name],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE `users` MODIFY COLUMN `name` varchar(255) AFTER `email`;"]);
+}
+
+#[test]
+fn mysql_moving_first_column_to_end_uses_single_reorder_statement() {
+    let mut col_0 = column("col_0");
+    col_0.data_type = "int(11)".to_string();
+    col_0.is_nullable = false;
+    col_0.original_position = Some(0);
+    col_0.original = Some(ColumnInfo {
+        name: "col_0".to_string(),
+        data_type: "int(11)".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut col_1 = column("col_1");
+    col_1.original_position = Some(1);
+    col_1.original = Some(ColumnInfo {
+        name: "col_1".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut col_2 = column("col_2");
+    col_2.original_position = Some(2);
+    col_2.original = Some(ColumnInfo {
+        name: "col_2".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut col_3 = column("col_3");
+    col_3.original_position = Some(3);
+    col_3.original = Some(ColumnInfo {
+        name: "col_3".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col_1, col_2, col_3, col_0],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE `users` MODIFY COLUMN `col_0` int(11) NOT NULL AFTER `col_3`;"]);
+}
+
+#[test]
+fn builds_sql_server_quoted_column_and_index_statements() {
+    let mut email = column("email");
+    email.data_type = "nvarchar(255)".to_string();
+    email.is_nullable = false;
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some("dbo".to_string()),
+        table_name: "users".to_string(),
+        columns: vec![email],
+        indexes: vec![index("idx_users_email", &["email"])],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE [dbo].[users] ADD [email] nvarchar(255) NOT NULL;",
+            "CREATE INDEX [idx_users_email] ON [dbo].[users] ([email]);",
+        ]
+    );
+}
+
+#[test]
+fn sqlserver_strips_mysql_display_width_from_fixed_integer_types() {
+    let mut id = column("id");
+    id.data_type = "int(11)".to_string();
+    id.is_nullable = false;
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some("dbo".to_string()),
+        table_name: "users".to_string(),
+        columns: vec![id],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[users] ADD [id] int NOT NULL;"]);
+}
+
+#[test]
+fn sqlserver_strips_scale_from_float() {
+    let mut amount = column("amount");
+    amount.data_type = "float(10,2)".to_string();
+    amount.is_nullable = true;
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some("dbo".to_string()),
+        table_name: "orders".to_string(),
+        columns: vec![amount],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[orders] ADD [amount] float;"]);
+}
+
+#[test]
+fn sqlserver_preserves_float_mantissa_bits() {
+    let mut value = column("value");
+    value.data_type = "float(53)".to_string();
+    value.is_nullable = false;
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some("dbo".to_string()),
+        table_name: "measurements".to_string(),
+        columns: vec![value],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[measurements] ADD [value] float(53) NOT NULL;"]);
+}
+
+#[test]
+fn sqlserver_default_changes_drop_old_constraints_with_isolated_batches() {
+    let mut sku = column("sku");
+    sku.data_type = "nvarchar(64)".to_string();
+    sku.default_value = "new sku".to_string();
+    sku.original = Some(ColumnInfo {
+        name: "sku".to_string(),
+        data_type: "nvarchar(64)".to_string(),
+        is_nullable: true,
+        column_default: Some("'old sku'".to_string()),
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut active = column("active");
+    active.data_type = "bit".to_string();
+    active.is_nullable = false;
+    active.default_value = "1".to_string();
+    active.original = Some(ColumnInfo {
+        name: "active".to_string(),
+        data_type: "bit".to_string(),
+        is_nullable: false,
+        column_default: Some("0".to_string()),
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some("core".to_string()),
+        table_name: "products".to_string(),
+        columns: vec![sku, active],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements.len(), 4);
+
+    let sku_drop = &result.statements[0];
+    let active_drop = &result.statements[2];
+    let sku_var = sku_drop.strip_prefix("DECLARE ").unwrap().split_once(" NVARCHAR(MAX);").unwrap().0;
+    let active_var = active_drop.strip_prefix("DECLARE ").unwrap().split_once(" NVARCHAR(MAX);").unwrap().0;
+    assert_ne!(sku_var, "@sql");
+    assert_ne!(active_var, "@sql");
+    assert_ne!(sku_var, active_var);
+
+    for (sql, column_name) in [(sku_drop, "sku"), (active_drop, "active")] {
+        assert!(sql.contains("SELECT TOP (1)"));
+        assert!(sql.contains(" + QUOTENAME(dc.name) FROM sys.default_constraints AS dc WHERE "));
+        assert!(sql.contains("OBJECT_ID(N'[core].[products]')"));
+        assert!(sql.contains(&format!("N'{column_name}', 'ColumnId'")));
+        assert!(sql.contains(" IF "));
+        assert!(!sql.contains("]'FROM"));
+        assert!(!sql.contains("constraintsWHERE"));
+    }
+
+    assert_eq!(
+        result.statements[1],
+        "ALTER TABLE [core].[products] ADD CONSTRAINT [DF_products_sku] DEFAULT 'new sku' FOR [sku];"
+    );
+    assert_eq!(
+        result.statements[3],
+        "ALTER TABLE [core].[products] ADD CONSTRAINT [DF_products_active] DEFAULT 1 FOR [active];"
+    );
+}
+
+#[test]
+fn sqlserver_unchanged_foreign_key_does_not_warn_when_saving_other_changes() {
+    let mut email = column("email");
+    email.data_type = "nvarchar(255)".to_string();
+    email.is_nullable = false;
+
+    let mut user_fk = foreign_key("fk_orders_user_id", "user_id", "users", "id");
+    user_fk.ref_schema = "dbo".to_string();
+    user_fk.original = Some(ForeignKeyInfo {
+        name: "fk_orders_user_id".to_string(),
+        column: "user_id".to_string(),
+        ref_schema: Some("dbo".to_string()),
+        ref_table: "users".to_string(),
+        ref_column: "id".to_string(),
+        on_update: None,
+        on_delete: None,
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some("dbo".to_string()),
+        table_name: "orders".to_string(),
+        columns: vec![email],
+        indexes: Vec::new(),
+        foreign_keys: vec![user_fk],
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[orders] ADD [email] nvarchar(255) NOT NULL;"]);
+}
+
+#[test]
+fn sqlserver_add_column_with_identity() {
+    let mut id = column("id");
+    id.data_type = "int".to_string();
+    id.is_nullable = false;
+    id.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(10), increment: Some(2) }),
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some("dbo".to_string()),
+        table_name: "orders".to_string(),
+        columns: vec![id],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE [dbo].[orders] ADD [id] int NOT NULL IDENTITY(10, 2);"]);
+}
+
+#[test]
+fn dameng_add_column_with_identity() {
+    let mut id = column("ID");
+    id.data_type = "INT".to_string();
+    id.is_nullable = false;
+    id.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(10), increment: Some(2) }),
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Dameng),
+        schema: Some("SYSDBA".to_string()),
+        table_name: "TEST".to_string(),
+        columns: vec![id],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE \"SYSDBA\".\"TEST\" ADD (\"ID\" INT IDENTITY(10, 2));"]);
+}
+
+#[test]
+fn dameng_rejects_identity_on_incompatible_type() {
+    let mut column = column("CODE");
+    column.data_type = "VARCHAR(255)".to_string();
+    column.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Dameng),
+        schema: Some("SYSDBA".to_string()),
+        table_name: "TEST".to_string(),
+        columns: vec![column],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.statements, Vec::<String>::new());
+    assert_eq!(
+        result.warnings,
+        vec!["Dameng identity column \"CODE\" must use tinyint, smallint, int, integer, bigint, number, numeric, or decimal/dec with scale 0."]
+    );
+}
+
+#[test]
+fn sqlserver_rejects_identity_on_incompatible_type() {
+    let mut column = column("test");
+    column.data_type = "varchar(255)".to_string();
+    column.is_nullable = false;
+    column.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some("core".to_string()),
+        table_name: "products".to_string(),
+        columns: vec![column],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.statements, Vec::<String>::new());
+    assert_eq!(
+        result.warnings,
+        vec!["SQL Server identity column \"test\" must use tinyint, smallint, int, bigint, or decimal/numeric with scale 0."]
+    );
+}
+
+#[test]
+fn sqlserver_changed_foreign_key_still_warns_as_unsupported() {
+    let mut user_fk = foreign_key("fk_orders_user_id", "user_id", "accounts", "id");
+    user_fk.ref_schema = "dbo".to_string();
+    user_fk.original = Some(ForeignKeyInfo {
+        name: "fk_orders_user_id".to_string(),
+        column: "user_id".to_string(),
+        ref_schema: Some("dbo".to_string()),
+        ref_table: "users".to_string(),
+        ref_column: "id".to_string(),
+        on_update: None,
+        on_delete: None,
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some("dbo".to_string()),
+        table_name: "orders".to_string(),
+        columns: Vec::new(),
+        indexes: Vec::new(),
+        foreign_keys: vec![user_fk],
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.statements, Vec::<String>::new());
+    assert_eq!(result.warnings, vec!["Editing foreign keys is not supported for sqlserver from this editor."]);
+}
+
+#[test]
+fn sqlserver_unchanged_identity_extra_does_not_mark_existing_column_changed() {
+    let mut id = column("id");
+    id.data_type = "int".to_string();
+    id.is_nullable = false;
+    id.is_primary_key = true;
+    id.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
+        ..Default::default()
+    });
+    id.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "int".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: true,
+        extra: Some("IDENTITY(1,1)".to_string()),
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some("dbo".to_string()),
+        table_name: "orders".to_string(),
+        columns: vec![id],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, Vec::<String>::new());
+}
+
+#[test]
+fn dameng_unchanged_identity_extra_does_not_mark_existing_column_changed() {
+    let mut id = column("ID");
+    id.data_type = "INT".to_string();
+    id.is_nullable = false;
+    id.is_primary_key = true;
+    id.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
+        ..Default::default()
+    });
+    id.original = Some(ColumnInfo {
+        name: "ID".to_string(),
+        data_type: "INT".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: true,
+        extra: Some("identity".to_string()),
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Dameng),
+        schema: Some("SYSDBA".to_string()),
+        table_name: "TEST".to_string(),
+        columns: vec![id],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, Vec::<String>::new());
+}
+
+#[test]
+fn dameng_rejects_adding_second_identity_column() {
+    let mut existing = column("ID");
+    existing.data_type = "INT".to_string();
+    existing.is_nullable = false;
+    existing.is_primary_key = true;
+    existing.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
+        ..Default::default()
+    });
+    existing.original = Some(ColumnInfo {
+        name: "ID".to_string(),
+        data_type: "INT".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: true,
+        extra: Some("identity".to_string()),
+        comment: None,
+        ..Default::default()
+    });
+    let mut added = column("SEQ");
+    added.data_type = "BIGINT".to_string();
+    added.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Dameng),
+        schema: Some("SYSDBA".to_string()),
+        table_name: "TEST".to_string(),
+        columns: vec![existing, added],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, vec!["Dameng tables can have only one identity column."]);
+}
+
+#[test]
+fn sqlserver_existing_column_identity_change_warns_without_unchanged_foreign_key_warning() {
+    let mut id = column("id");
+    id.data_type = "int".to_string();
+    id.is_nullable = false;
+    id.is_primary_key = true;
+    id.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
+        ..Default::default()
+    });
+    id.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "int".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: true,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut user_fk = foreign_key("fk_orders_user_id", "user_id", "users", "id");
+    user_fk.ref_schema = "dbo".to_string();
+    user_fk.original = Some(ForeignKeyInfo {
+        name: "fk_orders_user_id".to_string(),
+        column: "user_id".to_string(),
+        ref_schema: Some("dbo".to_string()),
+        ref_table: "users".to_string(),
+        ref_column: "id".to_string(),
+        on_update: None,
+        on_delete: None,
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some("dbo".to_string()),
+        table_name: "orders".to_string(),
+        columns: vec![id],
+        indexes: Vec::new(),
+        foreign_keys: vec![user_fk],
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.statements, Vec::<String>::new());
+    assert_eq!(
+        result.warnings,
+        vec!["Changing SQL Server IDENTITY for existing column \"id\" is not supported from this editor."]
+    );
+}
+
+#[cfg(feature = "duckdb-bundled")]
+#[test]
+fn builds_duckdb_create_table_statements() {
+    let mut name = column("name");
+    name.data_type = "VARCHAR".to_string();
+    name.is_nullable = false;
+    let mut created_at = column("created_at");
+    created_at.data_type = "TIMESTAMP".to_string();
+    created_at.default_value = "current_timestamp".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::DuckDb),
+        schema: None,
+        table_name: "events".to_string(),
+        columns: vec![name, created_at],
+        indexes: vec![index("idx_events_name", &["name"])],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "CREATE TABLE \"events\" (\n  \"name\" VARCHAR NOT NULL,\n  \"created_at\" TIMESTAMP DEFAULT current_timestamp\n);",
+            "CREATE INDEX \"idx_events_name\" ON \"events\" (\"name\");",
+        ]
+    );
+}
+
+#[test]
+fn builds_clickhouse_nullable_comment_and_reorder_statements() {
+    let mut source = column("source");
+    source.data_type = "String".to_string();
+    source.is_nullable = true;
+    source.comment = "traffic source".to_string();
+    let mut status = column("status");
+    status.data_type = "Nullable(String)".to_string();
+    status.is_nullable = false;
+    status.comment = "current status".to_string();
+    status.original = Some(ColumnInfo {
+        name: "status".to_string(),
+        data_type: "Nullable(String)".to_string(),
+        is_nullable: true,
+        column_default: Some("'pending'".to_string()),
+        is_primary_key: false,
+        extra: None,
+        comment: Some("old status".to_string()),
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::ClickHouse),
+        schema: None,
+        table_name: "events".to_string(),
+        columns: vec![source, status],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE \"events\" ADD COLUMN \"source\" Nullable(String);",
+            "ALTER TABLE \"events\" COMMENT COLUMN \"source\" 'traffic source';",
+            "ALTER TABLE \"events\" MODIFY COLUMN \"status\" REMOVE DEFAULT;",
+            "ALTER TABLE \"events\" MODIFY COLUMN \"status\" String;",
+            "ALTER TABLE \"events\" COMMENT COLUMN \"status\" 'current status';",
+        ]
+    );
+}
+
+#[test]
+fn builds_h2_schema_qualified_existing_column_statements() {
+    let mut name = column("DISPLAY_NAME");
+    name.id = "name".to_string();
+    name.data_type = "VARCHAR(120)".to_string();
+    name.is_nullable = false;
+    name.default_value = "guest".to_string();
+    name.comment = "Display name".to_string();
+    name.original = Some(ColumnInfo {
+        name: "NAME".to_string(),
+        data_type: "VARCHAR(80)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some(String::new()),
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::H2),
+        schema: Some("PUBLIC".to_string()),
+        table_name: "USERS".to_string(),
+        columns: vec![name],
+        indexes: vec![index("IDX_USERS_DISPLAY_NAME", &["DISPLAY_NAME"])],
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE \"PUBLIC\".\"USERS\" ALTER COLUMN \"NAME\" RENAME TO \"DISPLAY_NAME\";",
+            "ALTER TABLE \"PUBLIC\".\"USERS\" ALTER COLUMN \"DISPLAY_NAME\" SET DATA TYPE VARCHAR(120);",
+            "ALTER TABLE \"PUBLIC\".\"USERS\" ALTER COLUMN \"DISPLAY_NAME\" SET NOT NULL;",
+            "ALTER TABLE \"PUBLIC\".\"USERS\" ALTER COLUMN \"DISPLAY_NAME\" SET DEFAULT 'guest';",
+            "COMMENT ON COLUMN \"PUBLIC\".\"USERS\".\"DISPLAY_NAME\" IS 'Display name';",
+            "CREATE INDEX \"IDX_USERS_DISPLAY_NAME\" ON \"PUBLIC\".\"USERS\" (\"DISPLAY_NAME\");",
+        ]
+    );
+}
+
+#[test]
+fn builds_postgres_alter_table_add_primary_key() {
+    let mut id = column("id");
+    id.data_type = "integer".to_string();
+    id.is_nullable = false;
+    id.is_primary_key = true;
+    id.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "integer".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some("public".to_string()),
+        table_name: "users".to_string(),
+        columns: vec![id],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE \"public\".\"users\" ADD PRIMARY KEY (\"id\");"]);
+}
+
+#[test]
+fn builds_postgres_alter_table_drop_primary_key() {
+    let mut id = column("id");
+    id.data_type = "integer".to_string();
+    id.is_nullable = false;
+    id.is_primary_key = false;
+    id.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "integer".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: true,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some("public".to_string()),
+        table_name: "users".to_string(),
+        columns: vec![id],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, vec!["ALTER TABLE \"public\".\"users\" DROP CONSTRAINT \"users_pkey\";"]);
+}
+
+#[test]
+fn builds_mysql_alter_table_change_primary_key() {
+    let mut old_pk = column("id");
+    old_pk.id = "old_id".to_string();
+    old_pk.data_type = "int".to_string();
+    old_pk.is_nullable = false;
+    old_pk.is_primary_key = false;
+    old_pk.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "int".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: true,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let mut new_pk = column("uuid");
+    new_pk.id = "new_uuid".to_string();
+    new_pk.data_type = "varchar(36)".to_string();
+    new_pk.is_nullable = false;
+    new_pk.is_primary_key = true;
+    new_pk.original = Some(ColumnInfo {
+        name: "uuid".to_string(),
+        data_type: "varchar(36)".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![old_pk, new_pk],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec!["ALTER TABLE `users` DROP PRIMARY KEY;", "ALTER TABLE `users` ADD PRIMARY KEY (`uuid`);",]
+    );
+}
+
+#[test]
+fn builds_no_statements_when_primary_key_unchanged() {
+    let mut id = column("id");
+    id.data_type = "integer".to_string();
+    id.is_nullable = false;
+    id.is_primary_key = true;
+    id.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "integer".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: true,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![id],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements.is_empty());
+}
+
+#[test]
+fn warns_sqlite_cannot_alter_primary_key() {
+    let mut id = column("id");
+    id.data_type = "integer".to_string();
+    id.is_nullable = false;
+    id.is_primary_key = true;
+    id.original = Some(ColumnInfo {
+        name: "id".to_string(),
+        data_type: "integer".to_string(),
+        is_nullable: false,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Sqlite),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![id],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.statements, Vec::<String>::new());
+    assert_eq!(result.warnings.len(), 1);
+    assert!(result.warnings[0].contains("primary key"));
+}
+
+#[test]
+fn mysql_create_table_with_auto_increment() {
+    let mut col = column("id");
+    col.data_type = "int".to_string();
+    col.is_nullable = false;
+    col.is_primary_key = true;
+    col.extra = Some(ColumnExtra { auto_increment: Some(true), ..Default::default() });
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements.len(), 1);
+    assert!(result.statements[0].contains("AUTO_INCREMENT"));
+}
+
+#[test]
+fn mysql_create_table_with_on_update_current_timestamp() {
+    let mut col = column("updated_at");
+    col.data_type = "timestamp".to_string();
+    col.is_nullable = false;
+    col.default_value = "CURRENT_TIMESTAMP".to_string();
+    col.extra = Some(ColumnExtra { on_update_current_timestamp: Some(true), ..Default::default() });
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("ON UPDATE CURRENT_TIMESTAMP"));
+}
+
+#[test]
+fn postgres_create_table_with_identity() {
+    let mut col = column("id");
+    col.data_type = "integer".to_string();
+    col.is_nullable = false;
+    col.extra = Some(ColumnExtra {
+        identity: Some(ColumnIdentity { generation: Some("BY DEFAULT".to_string()), seed: None, increment: None }),
+        ..Default::default()
+    });
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("GENERATED BY DEFAULT AS IDENTITY"));
+}
+
+#[test]
+fn dameng_create_table_with_identity() {
+    let mut col = column("ID");
+    col.data_type = "INT".to_string();
+    col.is_nullable = false;
+    col.is_primary_key = true;
+    col.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(100), increment: Some(5) }),
+        ..Default::default()
+    });
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Dameng),
+        schema: Some("SYSDBA".to_string()),
+        table_name: "USERS".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("\"ID\" INT IDENTITY(100, 5)"), "ddl: {}", result.statements[0]);
+    assert!(result.statements[0].contains("PRIMARY KEY (\"ID\")"), "ddl: {}", result.statements[0]);
+}
+
+#[test]
+fn dameng_rejects_multiple_identity_columns() {
+    let mut first = column("ID");
+    first.data_type = "INT".to_string();
+    first.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
+        ..Default::default()
+    });
+    let mut second = column("SEQ");
+    second.data_type = "BIGINT".to_string();
+    second.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(1) }),
+        ..Default::default()
+    });
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Dameng),
+        schema: Some("SYSDBA".to_string()),
+        table_name: "USERS".to_string(),
+        columns: vec![first, second],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert!(result.statements.is_empty());
+    assert_eq!(result.warnings, vec!["Dameng tables can have only one identity column."]);
+}
+
+#[test]
+fn dameng_rejects_zero_identity_increment() {
+    let mut col = column("ID");
+    col.data_type = "INT".to_string();
+    col.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(1), increment: Some(0) }),
+        ..Default::default()
+    });
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Dameng),
+        schema: Some("SYSDBA".to_string()),
+        table_name: "USERS".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert!(result.statements.is_empty());
+    assert_eq!(result.warnings, vec!["Dameng identity column \"ID\" increment cannot be 0."]);
+}
+
+#[test]
+fn sqlserver_create_table_with_identity() {
+    let mut col = column("id");
+    col.data_type = "int".to_string();
+    col.is_nullable = false;
+    col.extra = Some(ColumnExtra {
+        auto_increment: Some(true),
+        identity: Some(ColumnIdentity { generation: None, seed: Some(100), increment: Some(5) }),
+        ..Default::default()
+    });
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("IDENTITY(100, 5)"));
+}
+
+#[test]
+fn mysql_quotes_datetime_literal_default() {
+    let mut col = column("created_at");
+    col.data_type = "datetime".to_string();
+    col.default_value = "2024-01-01 00:00:00".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "events".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("DEFAULT '2024-01-01 00:00:00'"));
+}
+
+#[test]
+fn mysql_does_not_quote_current_timestamp() {
+    let mut col = column("updated_at");
+    col.data_type = "timestamp".to_string();
+    col.default_value = "CURRENT_TIMESTAMP".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "events".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("DEFAULT CURRENT_TIMESTAMP"));
+    assert!(!result.statements[0].contains("DEFAULT 'CURRENT_TIMESTAMP'"));
+}
+
+#[test]
+fn mysql_does_not_quote_temporal_function_with_parens() {
+    let mut col = column("created_at");
+    col.data_type = "datetime".to_string();
+    col.default_value = "NOW()".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "events".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("DEFAULT NOW()"));
+}
+
+#[test]
+fn mysql_date_literal_default_is_quoted() {
+    let mut col = column("birth_date");
+    col.data_type = "date".to_string();
+    col.default_value = "2000-01-01".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("DEFAULT '2000-01-01'"));
+}
+
+#[test]
+fn mysql_time_literal_default_is_quoted() {
+    let mut col = column("start_time");
+    col.data_type = "time".to_string();
+    col.default_value = "09:00:00".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "shifts".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("DEFAULT '09:00:00'"));
+}
+
+#[test]
+fn non_temporal_types_are_not_quoted() {
+    let mut col = column("score");
+    col.data_type = "int".to_string();
+    col.default_value = "0".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "games".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("DEFAULT 0"));
+    assert!(!result.statements[0].contains("DEFAULT '0'"));
+}
+
+#[test]
+fn postgres_timestamp_literal_is_quoted() {
+    let mut col = column("logged_at");
+    col.data_type = "timestamp".to_string();
+    col.default_value = "2024-06-01 12:00:00".to_string();
+    col.original = Some(ColumnInfo {
+        name: "logged_at".to_string(),
+        data_type: "timestamp".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some(String::new()),
+        ..Default::default()
+    });
+
+    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some("public".to_string()),
+        table_name: "events".to_string(),
+        column: col,
+    });
+
+    assert!(result.statements.iter().any(|s| s.contains("SET DEFAULT '2024-06-01 12:00:00'")));
+}
+
+#[test]
+fn mysql_single_column_alter_quotes_datetime_literal() {
+    let mut col = column("created_at");
+    col.data_type = "datetime".to_string();
+    col.default_value = "2024-01-01 00:00:00".to_string();
+    col.original = Some(ColumnInfo {
+        name: "created_at".to_string(),
+        data_type: "datetime".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some(String::new()),
+        ..Default::default()
+    });
+
+    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "events".to_string(),
+        column: col,
+    });
+
+    assert!(result.statements.iter().any(|s| s.contains("DEFAULT '2024-01-01 00:00:00'")));
+}
+
+#[test]
+fn builds_mysql_foreign_key_changes() {
+    let mut existing = foreign_key("fk_orders_users", "user_id", "users", "id");
+    existing.on_delete = "CASCADE".to_string();
+    existing.original = Some(ForeignKeyInfo {
+        name: "fk_orders_users_old".to_string(),
+        column: "customer_id".to_string(),
+        ref_schema: None,
+        ref_table: "customers".to_string(),
+        ref_column: "id".to_string(),
+        on_update: None,
+        on_delete: Some("RESTRICT".to_string()),
+    });
+
+    let mut dropped = foreign_key("fk_orders_accounts", "account_id", "accounts", "id");
+    dropped.marked_for_drop = true;
+    dropped.original = Some(ForeignKeyInfo {
+        name: "fk_orders_accounts".to_string(),
+        column: "account_id".to_string(),
+        ref_schema: None,
+        ref_table: "accounts".to_string(),
+        ref_column: "id".to_string(),
+        on_update: None,
+        on_delete: None,
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "orders".to_string(),
+        columns: Vec::new(),
+        indexes: Vec::new(),
+        foreign_keys: vec![existing, dropped],
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE `orders` DROP FOREIGN KEY `fk_orders_users_old`;",
+            "ALTER TABLE `orders` ADD CONSTRAINT `fk_orders_users` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE;",
+            "ALTER TABLE `orders` DROP FOREIGN KEY `fk_orders_accounts`;",
+        ]
+    );
+}
+
+#[test]
+fn builds_mysql_composite_foreign_key() {
+    let composite = foreign_key("fk_order_items_product", "tenant_id, product_id", "products", "tenant_id, id");
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "order_items".to_string(),
+        columns: Vec::new(),
+        indexes: Vec::new(),
+        foreign_keys: vec![composite],
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE `order_items` ADD CONSTRAINT `fk_order_items_product` FOREIGN KEY (`tenant_id`, `product_id`) REFERENCES `products` (`tenant_id`, `id`);",
+        ]
+    );
+}
+
+#[test]
+fn builds_mysql_trigger_changes() {
+    let mut existing = trigger("orders_bu", "BEFORE", "UPDATE", "BEGIN\n  SET NEW.updated_at = NOW();\nEND");
+    existing.original = Some(TriggerInfo {
+        name: "orders_bu".to_string(),
+        event: "UPDATE".to_string(),
+        timing: "BEFORE".to_string(),
+        statement: Some("SET NEW.updated_at = CURRENT_TIMESTAMP".to_string()),
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "orders".to_string(),
+        columns: Vec::new(),
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: vec![existing],
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "DROP TRIGGER `orders_bu`;",
+            "CREATE TRIGGER `orders_bu` BEFORE UPDATE ON `orders` FOR EACH ROW\nBEGIN\n  SET NEW.updated_at = NOW();\nEND;",
+        ]
+    );
+}
+
+#[test]
+fn mysql_varchar_default_is_quoted() {
+    let mut col = column("name");
+    col.data_type = "varchar(255)".to_string();
+    col.default_value = "hello".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("DEFAULT 'hello'"));
+    assert!(!result.statements[0].contains("DEFAULT hello "));
+}
+
+#[test]
+fn mysql_char_default_is_quoted() {
+    let mut col = column("code");
+    col.data_type = "char(10)".to_string();
+    col.default_value = "abc".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "items".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("DEFAULT 'abc'"));
+}
+
+#[test]
+fn mysql_text_default_is_quoted() {
+    let mut col = column("description");
+    col.data_type = "text".to_string();
+    col.default_value = "default value".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "products".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("DEFAULT 'default value'"));
+}
+
+#[test]
+fn mysql_enum_default_is_quoted() {
+    let mut col = column("status");
+    col.data_type = "enum('active','inactive')".to_string();
+    col.default_value = "active".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("DEFAULT 'active'"));
+}
+
+#[test]
+fn mysql_int_default_is_not_quoted() {
+    let mut col = column("score");
+    col.data_type = "int".to_string();
+    col.default_value = "100".to_string();
+
+    let result = build_create_table_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "games".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements[0].contains("DEFAULT 100"));
+    assert!(!result.statements[0].contains("DEFAULT '100'"));
+}
+
+#[test]
+fn postgres_varchar_default_is_quoted() {
+    let mut col = column("label");
+    col.data_type = "varchar(100)".to_string();
+    col.default_value = "test label".to_string();
+    col.original = Some(ColumnInfo {
+        name: "label".to_string(),
+        data_type: "varchar(100)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some(String::new()),
+        ..Default::default()
+    });
+
+    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: None,
+        table_name: "items".to_string(),
+        column: col,
+    });
+
+    assert!(result.statements.iter().any(|s| s.contains("SET DEFAULT 'test label'")));
+}
+
+#[test]
+fn postgres_empty_string_default_is_not_quoted_again() {
+    let mut col = column("sku");
+    col.data_type = "character varying".to_string();
+    col.default_value = "''".to_string();
+    col.original = Some(ColumnInfo {
+        name: "sku".to_string(),
+        data_type: "character varying".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some(String::new()),
+        ..Default::default()
+    });
+
+    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some("core".to_string()),
+        table_name: "products".to_string(),
+        column: col,
+    });
+
+    assert_eq!(result.statements, vec!["ALTER TABLE \"core\".\"products\" ALTER COLUMN \"sku\" SET DEFAULT '';"]);
+}
+
+#[test]
+fn postgres_string_default_cast_matches_plain_literal() {
+    let mut col = column("category");
+    col.data_type = "character varying".to_string();
+    col.default_value = "''".to_string();
+    col.original = Some(ColumnInfo {
+        name: "category".to_string(),
+        data_type: "character varying".to_string(),
+        is_nullable: true,
+        column_default: Some("''::character varying".to_string()),
+        is_primary_key: false,
+        extra: None,
+        comment: Some(String::new()),
+        ..Default::default()
+    });
+
+    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some("core".to_string()),
+        table_name: "products".to_string(),
+        column: col,
+    });
+
+    assert_eq!(result.statements, Vec::<String>::new());
+}
+
+#[test]
+fn postgres_integer_default_is_not_quoted() {
+    let mut col = column("stock");
+    col.data_type = "integer".to_string();
+    col.default_value = "0".to_string();
+    col.original = Some(ColumnInfo {
+        name: "stock".to_string(),
+        data_type: "integer".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: Some(String::new()),
+        ..Default::default()
+    });
+
+    let result = build_single_column_alter_sql(SingleColumnAlterSqlOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some("core".to_string()),
+        table_name: "products".to_string(),
+        column: col,
+    });
+
+    assert_eq!(result.statements, vec!["ALTER TABLE \"core\".\"products\" ALTER COLUMN \"stock\" SET DEFAULT 0;"]);
+}
+
+#[test]
+fn mysql_character_column_add_with_charset_collation() {
+    let mut col = column("name");
+    col.data_type = "varchar(255)".to_string();
+    col.character_set = "utf8mb4".to_string();
+    col.collation = "utf8mb4_unicode_ci".to_string();
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec![
+            "ALTER TABLE `users` ADD COLUMN `name` varchar(255) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_unicode_ci`;"
+        ]
+    );
+}
+
+#[test]
+fn mysql_numeric_column_omits_charset_collation_in_column_definition() {
+    let mut col = column("score");
+    col.data_type = "int".to_string();
+    // Even if charset/collation are set on the editable column, they must NOT
+    // appear in the DDL because int does not accept CHARACTER SET or COLLATE.
+    col.character_set = "utf8mb4".to_string();
+    col.collation = "utf8mb4_unicode_ci".to_string();
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "games".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert!(result.statements.len() == 1);
+    let sql = &result.statements[0];
+    assert!(!sql.contains("CHARACTER SET"));
+    assert!(!sql.contains("COLLATE"));
+    assert!(sql.contains("int"));
+}
+
+#[test]
+fn mysql_numeric_column_ignores_charset_collation_in_change_detection() {
+    // When an existing INT column has no original character_set / collation but
+    // the editable draft carries stale values, the column should NOT be flagged
+    // as having an attribute change.
+    let mut col = column("score");
+    col.data_type = "int".to_string();
+    col.character_set = "utf8mb4".to_string();
+    col.collation = "utf8mb4_unicode_ci".to_string();
+    col.original = Some(ColumnInfo {
+        name: "score".to_string(),
+        data_type: "int".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "games".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    // No ALTER should be emitted — charset/collation changes on
+    // non-character columns are no-ops.
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements, Vec::<String>::new());
+}
+
+#[test]
+fn mysql_character_column_detects_charset_collation_change() {
+    let mut col = column("name");
+    col.data_type = "varchar(255)".to_string();
+    col.character_set = "utf8mb4".to_string();
+    col.collation = "utf8mb4_unicode_ci".to_string();
+    col.original = Some(ColumnInfo {
+        name: "name".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        ..Default::default()
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec!["ALTER TABLE `users` MODIFY COLUMN `name` varchar(255) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_unicode_ci`;"]
+    );
+}
+
+#[test]
+fn mysql_character_column_preserves_charset_collation_on_other_change() {
+    // Changing the default value on a character column should still
+    // re-emit the charset/collation clauses so they are not lost.
+    let mut col = column("name");
+    col.data_type = "varchar(255)".to_string();
+    col.character_set = "utf8mb4".to_string();
+    col.collation = "utf8mb4_unicode_ci".to_string();
+    col.default_value = "guest".to_string();
+    col.original = Some(ColumnInfo {
+        name: "name".to_string(),
+        data_type: "varchar(255)".to_string(),
+        is_nullable: true,
+        column_default: None,
+        is_primary_key: false,
+        extra: None,
+        comment: None,
+        character_set: Some("utf8mb4".to_string()),
+        collation: Some("utf8mb4_unicode_ci".to_string()),
+    });
+
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: None,
+        table_name: "users".to_string(),
+        columns: vec![col],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(
+        result.statements,
+        vec!["ALTER TABLE `users` MODIFY COLUMN `name` varchar(255) CHARACTER SET `utf8mb4` COLLATE `utf8mb4_unicode_ci` DEFAULT 'guest';"]
+    );
+}
diff --git a/crates/dbx-core/src/table_structure_sql/triggers.rs b/crates/dbx-core/src/table_structure_sql/triggers.rs
new file mode 100644
index 0000000..13f86ad
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/triggers.rs
@@ -0,0 +1,94 @@
+use super::dialect::{database_label, StructureDialect};
+use super::types::{EditableStructureTrigger, TableStructureSqlOptions, TriggerInfo};
+use super::util::{clean, qualified_table, quote_ident};
+
+pub(super) fn build_trigger_sql(options: &TableStructureSqlOptions, warnings: &mut Vec<String>) -> Vec<String> {
+    if options.triggers.is_empty() {
+        return Vec::new();
+    }
+
+    let database_label = database_label(options.database_type);
+    if super::dialect::capabilities_for(options.database_type).dialect != StructureDialect::Mysql {
+        warnings.push(format!("Editing triggers is not supported for {database_label} from this editor."));
+        return Vec::new();
+    }
+
+    let table = qualified_table(StructureDialect::Mysql, options.schema.as_deref(), &options.table_name);
+    let mut statements = Vec::new();
+
+    for trigger in &options.triggers {
+        if trigger.marked_for_drop {
+            if let Some(original) = &trigger.original {
+                statements.push(drop_trigger_sql(options.schema.as_deref(), &original.name));
+            }
+            continue;
+        }
+
+        if let Some(original) = &trigger.original {
+            if !has_trigger_change(trigger, original) {
+                continue;
+            }
+            statements.push(drop_trigger_sql(options.schema.as_deref(), &original.name));
+        }
+
+        if let Some(sql) = create_trigger_sql(&table, trigger, warnings) {
+            statements.push(sql);
+        }
+    }
+
+    statements
+}
+
+fn has_trigger_change(trigger: &EditableStructureTrigger, original: &TriggerInfo) -> bool {
+    clean(&trigger.name) != clean(&original.name)
+        || normalize_keyword(&trigger.timing) != normalize_keyword(&original.timing)
+        || normalize_keyword(&trigger.event) != normalize_keyword(&original.event)
+        || normalize_statement(&trigger.statement) != normalize_statement(original.statement.as_deref().unwrap_or(""))
+}
+
+fn drop_trigger_sql(schema: Option<&str>, name: &str) -> String {
+    let qualified_name = if schema.is_some_and(|schema| !schema.trim().is_empty()) {
+        format!(
+            "{}.{}",
+            quote_ident(StructureDialect::Mysql, schema.unwrap()),
+            quote_ident(StructureDialect::Mysql, name)
+        )
+    } else {
+        quote_ident(StructureDialect::Mysql, name)
+    };
+    format!("DROP TRIGGER {qualified_name};")
+}
+
+fn create_trigger_sql(table: &str, trigger: &EditableStructureTrigger, warnings: &mut Vec<String>) -> Option<String> {
+    let name = clean(&trigger.name);
+    let timing = normalize_keyword(&trigger.timing);
+    let event = normalize_keyword(&trigger.event);
+    let statement = clean(&trigger.statement);
+
+    if name.is_empty() || timing.is_empty() || event.is_empty() || statement.is_empty() {
+        warnings.push("Trigger name, timing, event, and statement are required.".to_string());
+        return None;
+    }
+    if !matches!(timing.as_str(), "BEFORE" | "AFTER") {
+        warnings.push(format!("Unsupported trigger timing \"{}\".", clean(&trigger.timing)));
+        return None;
+    }
+    if !matches!(event.as_str(), "INSERT" | "UPDATE" | "DELETE") {
+        warnings.push(format!("Unsupported trigger event \"{}\".", clean(&trigger.event)));
+        return None;
+    }
+
+    Some(format!(
+        "CREATE TRIGGER {} {timing} {event} ON {table} FOR EACH ROW\n{};",
+        quote_ident(StructureDialect::Mysql, &name),
+        statement.trim_end_matches(';').trim_end()
+    ))
+}
+
+fn normalize_keyword(value: &str) -> String {
+    clean(value).to_ascii_uppercase()
+}
+
+fn normalize_statement(value: &str) -> String {
+    clean(value).trim_end_matches(';').trim().to_string()
+}
diff --git a/crates/dbx-core/src/table_structure_sql/types.rs b/crates/dbx-core/src/table_structure_sql/types.rs
new file mode 100644
index 0000000..74e0534
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/types.rs
@@ -0,0 +1,233 @@
+use serde::{Deserialize, Serialize};
+
+use crate::models::connection::DatabaseType;
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditableStructureColumn {
+    pub id: String,
+    pub name: String,
+    pub data_type: String,
+    pub is_nullable: bool,
+    #[serde(default)]
+    pub default_value: String,
+    #[serde(default)]
+    pub comment: String,
+    #[serde(default)]
+    pub is_primary_key: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub extra: Option<ColumnExtra>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub original: Option<ColumnInfo>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub original_position: Option<usize>,
+    #[serde(default)]
+    pub marked_for_drop: bool,
+    #[serde(default)]
+    pub character_set: String,
+    #[serde(default)]
+    pub collation: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ColumnExtra {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub auto_increment: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub on_update_current_timestamp: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub identity: Option<ColumnIdentity>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub manticore_indexed: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub manticore_stored: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub manticore_attribute: Option<bool>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub manticore_secondary_index: Option<bool>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ColumnIdentity {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub generation: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub seed: Option<i64>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub increment: Option<i64>,
+}
+
+#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
+pub struct ColumnInfo {
+    pub name: String,
+    pub data_type: String,
+    pub is_nullable: bool,
+    pub column_default: Option<String>,
+    #[serde(default)]
+    pub is_primary_key: bool,
+    #[serde(default)]
+    pub extra: Option<String>,
+    #[serde(default)]
+    pub comment: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub character_set: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collation: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditableStructureIndex {
+    pub id: String,
+    pub name: String,
+    #[serde(default)]
+    pub columns: Vec<String>,
+    #[serde(default)]
+    pub is_unique: bool,
+    #[serde(default)]
+    pub is_primary: bool,
+    #[serde(default)]
+    pub filter: String,
+    #[serde(default)]
+    pub index_type: String,
+    #[serde(default)]
+    pub included_columns: Vec<String>,
+    #[serde(default)]
+    pub comment: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub original: Option<IndexInfo>,
+    #[serde(default)]
+    pub marked_for_drop: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct IndexInfo {
+    pub name: String,
+    #[serde(default)]
+    pub columns: Vec<String>,
+    #[serde(default)]
+    pub is_unique: bool,
+    #[serde(default)]
+    pub is_primary: bool,
+    #[serde(default)]
+    pub filter: Option<String>,
+    #[serde(default)]
+    pub index_type: Option<String>,
+    #[serde(default)]
+    pub included_columns: Option<Vec<String>>,
+    #[serde(default)]
+    pub comment: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditableStructureForeignKey {
+    pub id: String,
+    pub name: String,
+    #[serde(default)]
+    pub column: String,
+    #[serde(default)]
+    pub ref_schema: String,
+    #[serde(default)]
+    pub ref_table: String,
+    #[serde(default)]
+    pub ref_column: String,
+    #[serde(default)]
+    pub on_update: String,
+    #[serde(default)]
+    pub on_delete: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub original: Option<ForeignKeyInfo>,
+    #[serde(default)]
+    pub marked_for_drop: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct ForeignKeyInfo {
+    pub name: String,
+    pub column: String,
+    #[serde(default)]
+    pub ref_schema: Option<String>,
+    pub ref_table: String,
+    pub ref_column: String,
+    #[serde(default)]
+    pub on_update: Option<String>,
+    #[serde(default)]
+    pub on_delete: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EditableStructureTrigger {
+    pub id: String,
+    pub name: String,
+    #[serde(default)]
+    pub timing: String,
+    #[serde(default)]
+    pub event: String,
+    #[serde(default)]
+    pub statement: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub original: Option<TriggerInfo>,
+    #[serde(default)]
+    pub marked_for_drop: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct TriggerInfo {
+    pub name: String,
+    pub event: String,
+    pub timing: String,
+    #[serde(default)]
+    pub statement: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableStructureSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub table_name: String,
+    #[serde(default)]
+    pub columns: Vec<EditableStructureColumn>,
+    #[serde(default)]
+    pub indexes: Vec<EditableStructureIndex>,
+    #[serde(default)]
+    pub foreign_keys: Vec<EditableStructureForeignKey>,
+    #[serde(default)]
+    pub triggers: Vec<EditableStructureTrigger>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub table_comment: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub original_table_comment: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableStructureSqlResult {
+    pub statements: Vec<String>,
+    pub warnings: Vec<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SqliteTableStructurePreview {
+    pub statements: Vec<String>,
+    pub warnings: Vec<String>,
+    pub schema_revision: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SingleColumnAlterSqlOptions {
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub database_type: Option<DatabaseType>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub schema: Option<String>,
+    pub table_name: String,
+    pub column: EditableStructureColumn,
+}
diff --git a/crates/dbx-core/src/table_structure_sql/util.rs b/crates/dbx-core/src/table_structure_sql/util.rs
new file mode 100644
index 0000000..a858812
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/util.rs
@@ -0,0 +1,315 @@
+use super::dialect::StructureDialect;
+use super::types::EditableStructureColumn;
+
+pub(super) fn qualified_table(dialect: StructureDialect, schema: Option<&str>, table_name: &str) -> String {
+    if matches!(
+        dialect,
+        StructureDialect::Postgres
+            | StructureDialect::Oracle
+            | StructureDialect::Dameng
+            | StructureDialect::SqlServer
+            | StructureDialect::H2
+            | StructureDialect::Informix
+    ) && schema.is_some_and(|schema| !schema.trim().is_empty())
+    {
+        return format!("{}.{}", quote_ident(dialect, schema.unwrap()), quote_ident(dialect, table_name));
+    }
+    quote_ident(dialect, table_name)
+}
+
+pub(super) fn quote_ident(dialect: StructureDialect, name: &str) -> String {
+    match dialect {
+        StructureDialect::Mysql
+        | StructureDialect::Doris
+        | StructureDialect::ManticoreSearch
+        | StructureDialect::Questdb => {
+            format!("`{}`", name.replace('`', "``"))
+        }
+        StructureDialect::SqlServer => format!("[{}]", name.replace(']', "]]")),
+        StructureDialect::Informix if is_simple_informix_identifier(name) => name.to_string(),
+        _ => format!("\"{}\"", name.replace('"', "\"\"")),
+    }
+}
+
+fn is_simple_informix_identifier(name: &str) -> bool {
+    let mut chars = name.chars();
+    let Some(first) = chars.next() else {
+        return false;
+    };
+    (first.is_ascii_alphabetic() || first == '_')
+        && chars.all(|ch| ch.is_ascii_alphanumeric() || ch == '_' || ch == '$')
+}
+
+pub(super) fn quote_string(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+fn is_sql_string_literal(value: &str) -> bool {
+    let trimmed = value.trim();
+    let Some(inner) = trimmed.strip_prefix('\'').and_then(|value| value.strip_suffix('\'')) else {
+        return false;
+    };
+
+    let mut chars = inner.chars().peekable();
+    while let Some(ch) = chars.next() {
+        if ch == '\'' && chars.next_if_eq(&'\'').is_none() {
+            return false;
+        }
+    }
+    true
+}
+
+fn postgres_string_default_literal(value: &str) -> Option<&str> {
+    let trimmed = value.trim();
+    let inner = trimmed.strip_prefix('\'')?;
+    let mut literal_end = 1;
+    let mut chars = inner.char_indices().peekable();
+    while let Some((index, ch)) = chars.next() {
+        if ch == '\'' {
+            if chars.next_if(|(_, next)| *next == '\'').is_some() {
+                continue;
+            }
+            literal_end += index + ch.len_utf8();
+            break;
+        }
+    }
+    if literal_end == 1 {
+        return None;
+    }
+
+    let literal = &trimmed[..literal_end];
+    if !is_sql_string_literal(literal) {
+        return None;
+    }
+    let cast_type = trimmed[literal_end..].trim().strip_prefix("::")?.trim();
+    if is_postgres_textual_cast_type(cast_type) {
+        Some(literal)
+    } else {
+        None
+    }
+}
+
+fn is_postgres_textual_cast_type(value: &str) -> bool {
+    let normalized =
+        value.trim().trim_matches('"').split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    let base_type = normalized.split('(').next().unwrap_or(&normalized).trim();
+    matches!(
+        base_type,
+        "char"
+            | "character"
+            | "varchar"
+            | "character varying"
+            | "text"
+            | "bpchar"
+            | "name"
+            | "json"
+            | "jsonb"
+            | "xml"
+            | "bytea"
+            | "uuid"
+    )
+}
+
+pub(super) fn clean(value: &str) -> String {
+    value.trim().to_string()
+}
+
+pub(super) fn is_protected_manticore_id_column(dialect: StructureDialect, column_name: &str) -> bool {
+    dialect == StructureDialect::ManticoreSearch && column_name.trim().eq_ignore_ascii_case("id")
+}
+
+pub(super) fn is_temporal_type_for_default(dialect: StructureDialect, base_type: &str) -> bool {
+    let normalized = base_type.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    match dialect {
+        StructureDialect::Mysql | StructureDialect::Doris => {
+            matches!(normalized.as_str(), "date" | "datetime" | "timestamp" | "time" | "year")
+        }
+        StructureDialect::Postgres => {
+            matches!(
+                normalized.as_str(),
+                "date"
+                    | "time"
+                    | "time without time zone"
+                    | "time with time zone"
+                    | "timestamp"
+                    | "timestamp without time zone"
+                    | "timestamp with time zone"
+                    | "interval"
+                    | "timetz"
+                    | "timestamptz"
+            ) || normalized.starts_with("interval ")
+        }
+        StructureDialect::SqlServer => matches!(
+            normalized.as_str(),
+            "date" | "time" | "datetime" | "datetime2" | "smalldatetime" | "datetimeoffset"
+        ),
+        StructureDialect::Oracle | StructureDialect::Dameng => matches!(
+            normalized.as_str(),
+            "date"
+                | "timestamp"
+                | "timestamp with time zone"
+                | "timestamp with local time zone"
+                | "interval year to month"
+                | "interval day to second"
+        ),
+        StructureDialect::H2 => {
+            matches!(
+                normalized.as_str(),
+                "date"
+                    | "time"
+                    | "time without time zone"
+                    | "time with time zone"
+                    | "timestamp"
+                    | "timestamp without time zone"
+                    | "timestamp with time zone"
+            ) || normalized.starts_with("interval ")
+        }
+        StructureDialect::ClickHouse => {
+            matches!(normalized.as_str(), "date" | "date32" | "datetime" | "datetime64")
+        }
+        StructureDialect::Sqlite => {
+            matches!(normalized.as_str(), "date" | "datetime" | "timestamp" | "time")
+        }
+        StructureDialect::Informix => matches!(normalized.as_str(), "date" | "datetime"),
+        _ => false,
+    }
+}
+
+pub(super) fn is_temporal_expression(value: &str) -> bool {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        return false;
+    }
+    if trimmed.contains('(') || trimmed.contains(')') {
+        return true;
+    }
+    trimmed.chars().all(|c| c.is_ascii_alphabetic() || c == '_')
+}
+
+pub(super) fn is_string_type_for_default(dialect: StructureDialect, base_type: &str) -> bool {
+    let normalized = base_type.split_whitespace().collect::<Vec<_>>().join(" ").to_ascii_lowercase();
+    match dialect {
+        StructureDialect::Mysql | StructureDialect::Doris => matches!(
+            normalized.as_str(),
+            "char"
+                | "varchar"
+                | "tinytext"
+                | "text"
+                | "mediumtext"
+                | "longtext"
+                | "binary"
+                | "varbinary"
+                | "tinyblob"
+                | "blob"
+                | "mediumblob"
+                | "longblob"
+                | "enum"
+                | "set"
+                | "json"
+                | "nvarchar"
+                | "nchar"
+                | "long"
+        ),
+        StructureDialect::Postgres => matches!(
+            normalized.as_str(),
+            "char"
+                | "character"
+                | "varchar"
+                | "character varying"
+                | "text"
+                | "bpchar"
+                | "name"
+                | "json"
+                | "jsonb"
+                | "xml"
+                | "bytea"
+                | "uuid"
+        ),
+        StructureDialect::SqlServer => matches!(
+            normalized.as_str(),
+            "char" | "varchar" | "nchar" | "nvarchar" | "text" | "ntext" | "xml" | "uniqueidentifier" | "sysname"
+        ),
+        StructureDialect::Oracle | StructureDialect::Dameng => matches!(
+            normalized.as_str(),
+            "char" | "nchar" | "varchar2" | "nvarchar2" | "clob" | "nclob" | "long" | "raw" | "long raw" | "bfile"
+        ),
+        StructureDialect::H2 => matches!(
+            normalized.as_str(),
+            "char"
+                | "character"
+                | "varchar"
+                | "character varying"
+                | "text"
+                | "clob"
+                | "binary"
+                | "varbinary"
+                | "blob"
+                | "uuid"
+                | "json"
+        ),
+        StructureDialect::ClickHouse => matches!(normalized.as_str(), "string" | "fixedstring" | "uuid" | "json"),
+        StructureDialect::Sqlite => {
+            matches!(normalized.as_str(), "text" | "varchar" | "char" | "character" | "clob" | "nvarchar" | "nchar")
+        }
+        StructureDialect::Informix => matches!(
+            normalized.as_str(),
+            "char"
+                | "character"
+                | "varchar"
+                | "character varying"
+                | "nvarchar"
+                | "nchar"
+                | "text"
+                | "clob"
+                | "lvarchar"
+                | "byte"
+                | "blob"
+        ),
+        _ => false,
+    }
+}
+
+pub(super) fn format_default_for_sql(dialect: StructureDialect, data_type: &str, default_value: &str) -> String {
+    if default_value.is_empty() {
+        return String::new();
+    }
+    let base_type = data_type.split('(').next().unwrap_or(data_type).trim();
+    if is_temporal_type_for_default(dialect, base_type) {
+        if is_temporal_expression(default_value) {
+            return default_value.to_string();
+        }
+        return quote_string(default_value);
+    }
+    if is_string_type_for_default(dialect, base_type) {
+        // Only skip quoting for function-call expressions like `gen_random_uuid()`.
+        // Simple identifiers like `CURRENT_TIMESTAMP` are not valid defaults for string columns.
+        if is_sql_string_literal(default_value)
+            || (dialect == StructureDialect::Postgres && postgres_string_default_literal(default_value).is_some())
+            || default_value.contains('(')
+            || default_value.contains(')')
+        {
+            return default_value.to_string();
+        }
+        return quote_string(default_value);
+    }
+    default_value.to_string()
+}
+
+pub(super) fn normalize_default(value: Option<&String>) -> String {
+    let trimmed = value.map(|value| value.trim()).unwrap_or("");
+    if trimmed.eq_ignore_ascii_case("null") {
+        String::new()
+    } else if let Some(literal) = postgres_string_default_literal(trimmed) {
+        literal.to_string()
+    } else {
+        trimmed.to_string()
+    }
+}
+
+pub(super) fn original_default(column: &EditableStructureColumn) -> String {
+    normalize_default(column.original.as_ref().and_then(|original| original.column_default.as_ref()))
+}
+
+pub(super) fn original_comment(column: &EditableStructureColumn) -> String {
+    clean(column.original.as_ref().and_then(|original| original.comment.as_deref()).unwrap_or(""))
+}
diff --git a/crates/dbx-core/src/table_structure_sql/validation.rs b/crates/dbx-core/src/table_structure_sql/validation.rs
new file mode 100644
index 0000000..9a6290b
--- /dev/null
+++ b/crates/dbx-core/src/table_structure_sql/validation.rs
@@ -0,0 +1,69 @@
+use super::column_format::has_dameng_identity;
+use super::dialect::{capabilities_for, StructureDialect};
+use super::indexes::has_existing_index_change;
+use super::types::{EditableStructureColumn, TableStructureSqlOptions};
+use super::util::clean;
+
+pub(super) fn validate_draft(options: &TableStructureSqlOptions) -> Vec<String> {
+    let mut warnings = Vec::new();
+    let active_columns: Vec<_> = options.columns.iter().filter(|column| !column.marked_for_drop).collect();
+    validate_columns(&active_columns, &mut warnings);
+    validate_dameng_identity(options, &active_columns, &mut warnings);
+    for index in options
+        .indexes
+        .iter()
+        .filter(|index| !index.marked_for_drop && (index.original.is_none() || has_existing_index_change(index)))
+    {
+        if clean(&index.name).is_empty() {
+            warnings.push("Index name cannot be empty.".to_string());
+        }
+        if index.columns.iter().map(|column| clean(column)).filter(|column| !column.is_empty()).count() == 0 {
+            warnings.push(format!(
+                "Index \"{}\" needs at least one column.",
+                if index.name.is_empty() { "(new)" } else { &index.name }
+            ));
+        }
+    }
+    warnings
+}
+
+pub(super) fn validate_dameng_identity(
+    options: &TableStructureSqlOptions,
+    columns: &[&EditableStructureColumn],
+    warnings: &mut Vec<String>,
+) {
+    if capabilities_for(options.database_type).dialect != StructureDialect::Dameng {
+        return;
+    }
+
+    let identity_columns: Vec<_> = columns.iter().filter(|column| has_dameng_identity(column)).collect();
+    if identity_columns.len() > 1 {
+        warnings.push("Dameng tables can have only one identity column.".to_string());
+    }
+    for column in identity_columns {
+        if column.extra.as_ref().and_then(|extra| extra.identity.as_ref()).and_then(|identity| identity.increment)
+            == Some(0)
+        {
+            warnings.push(format!("Dameng identity column \"{}\" increment cannot be 0.", column.name));
+        }
+    }
+}
+
+pub(super) fn validate_columns(columns: &[&EditableStructureColumn], warnings: &mut Vec<String>) {
+    let mut names = std::collections::HashSet::new();
+    for column in columns {
+        if clean(&column.name).is_empty() {
+            warnings.push("Column name cannot be empty.".to_string());
+        }
+        if clean(&column.data_type).is_empty() {
+            warnings.push(format!(
+                "Column \"{}\" type cannot be empty.",
+                if column.name.is_empty() { "(new)" } else { &column.name }
+            ));
+        }
+        let key = clean(&column.name).to_lowercase();
+        if !key.is_empty() && !names.insert(key) {
+            warnings.push(format!("Column \"{}\" is duplicated.", column.name));
+        }
+    }
+}
diff --git a/crates/dbx-core/src/text_export.rs b/crates/dbx-core/src/text_export.rs
new file mode 100644
index 0000000..f02e105
--- /dev/null
+++ b/crates/dbx-core/src/text_export.rs
@@ -0,0 +1,143 @@
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryResultTextExportData {
+    pub columns: Vec<String>,
+    pub rows: Vec<Vec<Value>>,
+}
+
+pub fn format_json(data: &QueryResultTextExportData) -> Result<String, String> {
+    let rows = data
+        .rows
+        .iter()
+        .map(|row| {
+            let mut object = Map::new();
+            for (index, column) in data.columns.iter().enumerate() {
+                if let Some(value) = row.get(index) {
+                    object.insert(column.clone(), value.clone());
+                }
+            }
+            Value::Object(object)
+        })
+        .collect::<Vec<_>>();
+    serde_json::to_string_pretty(&rows).map_err(|err| err.to_string())
+}
+
+pub fn format_markdown(data: &QueryResultTextExportData) -> String {
+    let normalized_columns = data.columns.iter().map(|column| markdown_cell(column)).collect::<Vec<_>>();
+    let normalized_rows = data
+        .rows
+        .iter()
+        .map(|row| row.iter().map(|cell| markdown_cell(&display_cell(cell))).collect::<Vec<_>>())
+        .collect::<Vec<_>>();
+    let widths = normalized_columns
+        .iter()
+        .enumerate()
+        .map(|(index, column)| {
+            let row_width = normalized_rows
+                .iter()
+                .map(|row| row.get(index).map(|cell| cell.chars().count()).unwrap_or(0))
+                .max()
+                .unwrap_or(0);
+            column.chars().count().max(row_width).max(3)
+        })
+        .collect::<Vec<_>>();
+
+    let header = format!(
+        "| {} |",
+        normalized_columns
+            .iter()
+            .enumerate()
+            .map(|(index, column)| pad(column, widths[index]))
+            .collect::<Vec<_>>()
+            .join(" | ")
+    );
+    let separator = format!("| {} |", widths.iter().map(|width| "-".repeat(*width)).collect::<Vec<_>>().join(" | "));
+    let body = normalized_rows
+        .iter()
+        .map(|row| {
+            format!(
+                "| {} |",
+                row.iter()
+                    .enumerate()
+                    .map(|(index, cell)| pad(cell, widths.get(index).copied().unwrap_or(3)))
+                    .collect::<Vec<_>>()
+                    .join(" | ")
+            )
+        })
+        .collect::<Vec<_>>()
+        .join("\n");
+    [header, separator, body].into_iter().filter(|part| !part.is_empty()).collect::<Vec<_>>().join("\n") + "\n"
+}
+
+fn display_cell(value: &Value) -> String {
+    match value {
+        Value::Null => "NULL".to_string(),
+        Value::Bool(value) => value.to_string(),
+        Value::Number(value) => value.to_string(),
+        Value::String(value) => value.clone(),
+        other => other.to_string(),
+    }
+}
+
+fn markdown_cell(value: &str) -> String {
+    value.replace('|', "\\|").replace("\r\n", "<br>").replace('\n', "<br>")
+}
+
+fn pad(value: &str, width: usize) -> String {
+    let current = value.chars().count();
+    if current >= width {
+        return value.to_string();
+    }
+    format!("{value}{}", " ".repeat(width - current))
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::{json, Value};
+
+    use super::{format_json, format_markdown, QueryResultTextExportData};
+
+    #[test]
+    fn formats_json_rows_as_objects() {
+        let out = format_json(&QueryResultTextExportData {
+            columns: vec!["id".to_string(), "name".to_string(), "active".to_string(), "note".to_string()],
+            rows: vec![vec![json!(1), json!("Ada"), json!(true), Value::Null]],
+        })
+        .unwrap();
+
+        assert_eq!(
+            out,
+            r#"[
+  {
+    "id": 1,
+    "name": "Ada",
+    "active": true,
+    "note": null
+  }
+]"#
+        );
+    }
+
+    #[test]
+    fn formats_markdown_with_escaped_pipes_and_newlines() {
+        let out = format_markdown(&QueryResultTextExportData {
+            columns: vec!["id".to_string(), "payload|kind".to_string()],
+            rows: vec![vec![json!(1), json!("a|b")], vec![json!(2), json!("line one\nline two")]],
+        });
+
+        assert_eq!(
+            out,
+            [
+                "| id  | payload\\|kind        |",
+                "| --- | -------------------- |",
+                "| 1   | a\\|b                 |",
+                "| 2   | line one<br>line two |",
+                "",
+            ]
+            .join("\n")
+        );
+    }
+}
diff --git a/crates/dbx-core/src/token_usage.rs b/crates/dbx-core/src/token_usage.rs
new file mode 100644
index 0000000..1f1f498
--- /dev/null
+++ b/crates/dbx-core/src/token_usage.rs
@@ -0,0 +1,12 @@
+#[derive(Debug, Clone, Default)]
+pub struct TokenUsage {
+    pub input_tokens: u32,
+    pub output_tokens: u32,
+}
+
+impl TokenUsage {
+    pub fn add(&mut self, other: &TokenUsage) {
+        self.input_tokens += other.input_tokens;
+        self.output_tokens += other.output_tokens;
+    }
+}
diff --git a/crates/dbx-core/src/transfer.rs b/crates/dbx-core/src/transfer.rs
new file mode 100644
index 0000000..c530790
--- /dev/null
+++ b/crates/dbx-core/src/transfer.rs
@@ -0,0 +1,6649 @@
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+use std::collections::{HashMap, HashSet};
+use tokio::sync::RwLock;
+
+use crate::connection::{config_for_pool_key, AppState, PoolKind};
+use crate::db;
+use crate::db::mongo_driver::MongoDocumentResult;
+use crate::models::connection::DatabaseType;
+use crate::object_source_sql::{build_executable_object_source_statements, EditableObjectSourceSqlInput};
+use crate::query::{agent_execute_query_params, pool_error_action, PoolErrorAction, QueryExecutionOptions};
+use crate::sql::split_sql_statements;
+#[cfg(feature = "duckdb-bundled")]
+use crate::sql::starts_with_executable_sql_keyword;
+use crate::sql_dialect::{qualified_transfer_table, quote_transfer_identifier};
+
+static CANCELLED: std::sync::LazyLock<RwLock<HashSet<String>>> =
+    std::sync::LazyLock::new(|| RwLock::new(HashSet::new()));
+
+const MAX_TRANSFER_WRITE_SQL_BYTES: usize = 512 * 1024;
+const MAX_SQLSERVER_INSERT_ROWS: usize = 1000;
+const MAX_ORACLE_INSERT_ALL_ROWS: usize = 500;
+const MAX_ORACLE_MERGE_ROWS: usize = 500;
+const TRANSFER_TARGET_TABLE_LOOKUP_LIMIT: usize = 1000;
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum TransferMode {
+    #[default]
+    Append,
+    Overwrite,
+    Upsert,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum TransferTableNameCase {
+    #[default]
+    Preserve,
+    Lower,
+    Upper,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum TransferOwnershipPolicy {
+    #[default]
+    Preserve,
+    Skip,
+    ReassignMissing,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransferRequest {
+    pub transfer_id: String,
+    pub source_connection_id: String,
+    pub source_database: String,
+    pub source_schema: String,
+    pub target_connection_id: String,
+    pub target_database: String,
+    pub target_schema: String,
+    pub tables: Vec<String>,
+    pub create_table: bool,
+    #[serde(default)]
+    pub mode: TransferMode,
+    #[serde(default)]
+    pub target_table_name_case: TransferTableNameCase,
+    #[serde(default)]
+    pub ownership_policy: TransferOwnershipPolicy,
+    pub batch_size: usize,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransferOwnershipPreview {
+    pub missing_owners: Vec<String>,
+    pub target_owner: String,
+}
+
+impl TransferRequest {
+    pub fn target_table_name(&self, source_table: &str) -> String {
+        match self.target_table_name_case {
+            TransferTableNameCase::Preserve => source_table.to_string(),
+            TransferTableNameCase::Lower => source_table.to_lowercase(),
+            TransferTableNameCase::Upper => source_table.to_uppercase(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TransferProgress {
+    pub transfer_id: String,
+    pub table: String,
+    pub table_index: usize,
+    pub total_tables: usize,
+    pub rows_transferred: u64,
+    pub total_rows: Option<u64>,
+    pub status: TransferStatus,
+    pub error: Option<String>,
+    pub terminal: bool,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum TransferStatus {
+    Running,
+    TableDone,
+    Done,
+    Error,
+    Cancelled,
+}
+
+pub fn quote_identifier(name: &str, db_type: &DatabaseType) -> String {
+    quote_transfer_identifier(name, db_type)
+}
+
+pub fn qualified_table(table: &str, schema: &str, db_type: &DatabaseType) -> String {
+    qualified_transfer_table(table, schema, db_type)
+}
+
+pub fn validate_transfer_target_table_names(request: &TransferRequest) -> Result<(), String> {
+    let mut targets: HashMap<String, String> = HashMap::new();
+    for source_table in &request.tables {
+        let target_table = request.target_table_name(source_table);
+        if let Some(first_source) = targets.insert(target_table.clone(), source_table.clone()) {
+            return Err(format!(
+                "Target table name collision after case conversion: '{first_source}' and '{source_table}' both map to '{target_table}'"
+            ));
+        }
+    }
+    Ok(())
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct ResolvedTransferTargetTable {
+    name: String,
+    preexisting: bool,
+}
+
+fn json_scalar_to_string(value: &serde_json::Value) -> Option<String> {
+    match value {
+        serde_json::Value::String(value) => Some(value.clone()),
+        serde_json::Value::Number(value) => Some(value.to_string()),
+        serde_json::Value::Bool(value) => Some(value.to_string()),
+        _ => None,
+    }
+}
+
+fn mysql_lower_case_table_names_from_result(result: &db::QueryResult) -> Option<u8> {
+    let row = result.rows.first()?;
+    row.get(1).or_else(|| row.first()).and_then(json_scalar_to_string)?.trim().parse::<u8>().ok()
+}
+
+async fn target_table_lookup_is_case_insensitive(
+    state: &AppState,
+    target_pool_key: &str,
+    target_db_type: &DatabaseType,
+) -> bool {
+    if !matches!(target_db_type, DatabaseType::Mysql) {
+        return false;
+    }
+
+    let result = match execute_on_pool(state, target_pool_key, "SHOW VARIABLES LIKE 'lower_case_table_names'").await {
+        Ok(result) => result,
+        Err(error) => {
+            log::debug!("[transfer] failed to read MySQL lower_case_table_names: {error}");
+            return false;
+        }
+    };
+
+    // MySQL lower_case_table_names=1/2 means table lookup is case-insensitive.
+    // Prefer the metadata name so generated INSERT/TRUNCATE SQL keeps the target
+    // table's declared case instead of the source-derived request case.
+    mysql_lower_case_table_names_from_result(&result).is_some_and(|value| value != 0)
+}
+
+fn existing_transfer_target_table_name(
+    requested_name: &str,
+    tables: &[db::TableInfo],
+    allow_case_insensitive_match: bool,
+) -> Option<String> {
+    if let Some(table) = tables.iter().find(|table| table.name == requested_name) {
+        return Some(table.name.clone());
+    }
+    if !allow_case_insensitive_match {
+        return None;
+    }
+    tables.iter().find(|table| table.name.eq_ignore_ascii_case(requested_name)).map(|table| table.name.clone())
+}
+
+async fn resolve_transfer_target_table_name(
+    state: &AppState,
+    request: &TransferRequest,
+    source_table: &str,
+    target_pool_key: &str,
+    target_db_type: &DatabaseType,
+) -> ResolvedTransferTargetTable {
+    let requested_name = request.target_table_name(source_table);
+    if is_mongodb_transfer_type(target_db_type) {
+        return ResolvedTransferTargetTable { name: requested_name, preexisting: false };
+    }
+
+    let allow_case_insensitive_match =
+        target_table_lookup_is_case_insensitive(state, target_pool_key, target_db_type).await;
+    let tables = crate::schema::list_tables_core(
+        state,
+        &request.target_connection_id,
+        &request.target_database,
+        &request.target_schema,
+        Some(&requested_name),
+        Some(TRANSFER_TARGET_TABLE_LOOKUP_LIMIT),
+        None,
+        None,
+    )
+    .await
+    .unwrap_or_else(|error| {
+        log::debug!("[transfer] failed to resolve target table metadata for {requested_name}: {error}");
+        Vec::new()
+    });
+
+    if let Some(existing_name) =
+        existing_transfer_target_table_name(&requested_name, &tables, allow_case_insensitive_match)
+    {
+        ResolvedTransferTargetTable { name: existing_name, preexisting: true }
+    } else {
+        ResolvedTransferTargetTable { name: requested_name, preexisting: false }
+    }
+}
+
+fn quote_string_literal(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+fn postgres_schema_exists_sql(schema: &str) -> String {
+    format!("SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = {} LIMIT 1", quote_string_literal(schema))
+}
+
+fn query_result_has_rows(result: &db::QueryResult) -> bool {
+    !result.rows.is_empty()
+}
+
+fn is_simple_identifier(value: &str) -> bool {
+    let mut chars = value.chars();
+    let Some(first) = chars.next() else {
+        return false;
+    };
+    if !(first == '_' || first.is_ascii_alphabetic()) {
+        return false;
+    }
+    chars.all(|ch| ch == '_' || ch.is_ascii_alphanumeric())
+}
+
+fn is_postgres_compat_transfer(source_db: &DatabaseType, target_db: &DatabaseType) -> bool {
+    is_postgres_transfer_dialect(source_db) && is_postgres_transfer_dialect(target_db)
+}
+
+fn is_postgres_transfer_dialect(db_type: &DatabaseType) -> bool {
+    // KingbaseES supports the PostgreSQL DDL, type, and ON CONFLICT paths used by transfer;
+    // other PG-wire databases stay opt-in until their transfer behavior is verified.
+    matches!(db_type, DatabaseType::Postgres | DatabaseType::Kingbase)
+}
+
+fn is_postgres_integer_like_type(data_type: &str) -> bool {
+    let normalized = data_type.trim().to_ascii_lowercase();
+    matches!(
+        normalized.split(['(', ' ']).next().unwrap_or(""),
+        "smallint" | "integer" | "bigint" | "int2" | "int4" | "int8"
+    )
+}
+
+fn is_postgres_sequence_default(default_value: Option<&str>) -> bool {
+    default_value.is_some_and(|value| value.to_ascii_lowercase().contains("nextval("))
+}
+
+fn is_postgres_generated_extra(extra: Option<&str>) -> bool {
+    extra.is_some_and(|value| value.trim().to_ascii_lowercase().starts_with("generated "))
+}
+
+fn is_postgres_identity_extra(extra: Option<&str>) -> bool {
+    extra.is_some_and(|value| {
+        let normalized = value.trim().to_ascii_lowercase();
+        normalized.starts_with("generated ") && normalized.contains(" identity")
+    })
+}
+
+pub(crate) fn is_identity_column_extra(extra: Option<&str>) -> bool {
+    extra.is_some_and(|value| {
+        let normalized = value.trim().to_ascii_lowercase();
+        normalized.contains("identity") || normalized.contains("auto_increment") || normalized.contains("autoincrement")
+    })
+}
+
+pub(crate) fn selected_columns_include_identity_extras(columns: &[String], column_extras: &[Option<String>]) -> bool {
+    columns
+        .iter()
+        .enumerate()
+        .any(|(index, _)| is_identity_column_extra(column_extras.get(index).and_then(|extra| extra.as_deref())))
+}
+
+fn selected_columns_include_identity_columns(columns: &[String], all_columns: &[db::ColumnInfo]) -> bool {
+    all_columns.iter().any(|column| {
+        is_identity_column_extra(column.extra.as_deref())
+            && columns.iter().any(|name| name.eq_ignore_ascii_case(&column.name))
+    })
+}
+
+fn is_sqlserver_rowversion_type(data_type: &str) -> bool {
+    let normalized = data_type.trim().to_ascii_lowercase();
+    matches!(normalized.split(['(', ' ', '\t', '\n']).next().unwrap_or(""), "timestamp" | "rowversion")
+}
+
+fn is_sqlserver_non_insertable_transfer_column(
+    column: &db::ColumnInfo,
+    source_db_type: &DatabaseType,
+    target_db_type: &DatabaseType,
+) -> bool {
+    matches!((source_db_type, target_db_type), (DatabaseType::SqlServer, DatabaseType::SqlServer))
+        && is_sqlserver_rowversion_type(&column.data_type)
+}
+
+fn writable_transfer_columns(
+    columns: &[db::ColumnInfo],
+    source_db_type: &DatabaseType,
+    target_db_type: &DatabaseType,
+) -> Vec<db::ColumnInfo> {
+    columns
+        .iter()
+        .filter(|column| !is_sqlserver_non_insertable_transfer_column(column, source_db_type, target_db_type))
+        .cloned()
+        .collect()
+}
+
+fn dameng_identity_insert_statement(table: &str, schema: &str, enabled: bool) -> String {
+    let full_table = qualified_table(table, schema, &DatabaseType::Dameng);
+    format!("SET IDENTITY_INSERT {full_table} {}", if enabled { "ON" } else { "OFF" })
+}
+
+pub(crate) fn wrap_dameng_identity_insert_sql(insert_sql: &str, table: &str, schema: &str) -> String {
+    let full_table = qualified_table(table, schema, &DatabaseType::Dameng);
+    wrap_dameng_identity_insert_sql_for_table(insert_sql, &full_table)
+}
+
+pub(crate) fn wrap_dameng_identity_insert_sql_for_table(insert_sql: &str, full_table: &str) -> String {
+    let trimmed = insert_sql.trim().trim_end_matches(';').trim();
+    format!(
+        "{};\n{};\n{};",
+        format!("SET IDENTITY_INSERT {full_table} ON"),
+        trimmed,
+        format!("SET IDENTITY_INSERT {full_table} OFF")
+    )
+}
+
+async fn execute_transfer_write_statement(
+    state: &AppState,
+    target_pool_key: &str,
+    sql: &str,
+    target_db_type: &DatabaseType,
+    table: &str,
+    schema: &str,
+    needs_identity_insert: bool,
+) -> Result<(), String> {
+    if !needs_identity_insert || !matches!(target_db_type, DatabaseType::Dameng) {
+        execute_on_pool(state, target_pool_key, sql).await?;
+        return Ok(());
+    }
+
+    let enable_sql = dameng_identity_insert_statement(table, schema, true);
+    let disable_sql = dameng_identity_insert_statement(table, schema, false);
+    execute_on_pool(state, target_pool_key, &enable_sql)
+        .await
+        .map_err(|e| format!("Failed to enable Dameng IDENTITY_INSERT for {table}: {e}"))?;
+    let write_result = execute_on_pool(state, target_pool_key, sql).await;
+    let disable_result = execute_on_pool(state, target_pool_key, &disable_sql).await;
+
+    match (write_result, disable_result) {
+        (Ok(_), Ok(_)) => Ok(()),
+        (Err(write_error), Ok(_)) => Err(write_error),
+        (Ok(_), Err(disable_error)) => {
+            Err(format!("Failed to disable Dameng IDENTITY_INSERT for {table}: {disable_error}"))
+        }
+        (Err(write_error), Err(disable_error)) => {
+            Err(format!("{write_error}; also failed to disable Dameng IDENTITY_INSERT for {table}: {disable_error}"))
+        }
+    }
+}
+
+fn rewrite_postgres_schema_qualified_references(input: &str, source_schema: &str, target_schema: &str) -> String {
+    if source_schema.trim().is_empty() || source_schema == target_schema {
+        return input.to_string();
+    }
+
+    let quoted_source = format!("{}.", quote_identifier(source_schema, &DatabaseType::Postgres));
+    let quoted_target = format!("{}.", quote_identifier(target_schema, &DatabaseType::Postgres));
+    let rewritten = input.replace(&quoted_source, &quoted_target);
+    let unquoted_pattern =
+        Regex::new(&format!(r#"(^|[^"\w]){}\."#, regex::escape(source_schema))).expect("valid postgres schema regex");
+    unquoted_pattern
+        .replace_all(&rewritten, |captures: &regex::Captures| format!("{}{}", &captures[1], quoted_target))
+        .into_owned()
+}
+
+fn postgres_column_type_sql(
+    column: &db::ColumnInfo,
+    source_schema: &str,
+    target_schema: &str,
+    source_db: &DatabaseType,
+    target_db: &DatabaseType,
+) -> String {
+    if let Some(mapped_type) = clickhouse_temporal_column_type(column, source_db, target_db) {
+        return mapped_type;
+    }
+    if is_postgres_compat_transfer(source_db, target_db) {
+        let trimmed = column.data_type.trim();
+        if !trimmed.is_empty() {
+            return rewrite_postgres_schema_qualified_references(trimmed, source_schema, target_schema);
+        }
+    }
+    map_column_type(&column.data_type, source_db, target_db)
+}
+
+fn clickhouse_temporal_column_type(
+    column: &db::ColumnInfo,
+    source_db: &DatabaseType,
+    target_db: &DatabaseType,
+) -> Option<String> {
+    if !matches!(target_db, DatabaseType::ClickHouse) || source_db == target_db {
+        return None;
+    }
+
+    let source_type = column.data_type.trim();
+    let lower = source_type.to_ascii_lowercase();
+    let base = lower.split(['(', ' ', '\t', '\n']).next().unwrap_or("").trim();
+    if !matches!(base, "datetime" | "timestamp" | "timestamptz") {
+        return None;
+    }
+
+    let scale = clickhouse_datetime64_scale(column);
+    // ClickHouse DateTime stores whole seconds, and older versions reject
+    // fractional timestamp strings such as Dameng's TIMESTAMP(6) output.
+    Some(format!("DateTime64({scale})"))
+}
+
+fn clickhouse_datetime64_scale(column: &db::ColumnInfo) -> u8 {
+    let scale = parse_temporal_type_scale(&column.data_type).or(column.numeric_scale).unwrap_or(6);
+    scale.clamp(0, 9) as u8
+}
+
+fn parse_temporal_type_scale(source_type: &str) -> Option<i32> {
+    let start = source_type.find('(')? + 1;
+    let rest = &source_type[start..];
+    let digits = rest.bytes().take_while(|byte| byte.is_ascii_digit()).collect::<Vec<_>>();
+    if digits.is_empty() {
+        return None;
+    }
+    std::str::from_utf8(&digits).ok()?.parse::<i32>().ok()
+}
+
+fn postgres_default_clause(
+    column: &db::ColumnInfo,
+    source_schema: &str,
+    target_schema: &str,
+    source_db: &DatabaseType,
+    target_db: &DatabaseType,
+) -> Option<String> {
+    if !is_postgres_compat_transfer(source_db, target_db) {
+        return None;
+    }
+    if is_postgres_generated_extra(column.extra.as_deref()) {
+        if let Some(extra) = column.extra.as_deref().map(str::trim).filter(|value| !value.is_empty()) {
+            return Some(extra.to_string());
+        }
+    }
+    let default_value = column.column_default.as_deref()?.trim();
+    if default_value.is_empty() {
+        return None;
+    }
+    if is_postgres_sequence_default(Some(default_value)) && is_postgres_integer_like_type(&column.data_type) {
+        return Some("GENERATED BY DEFAULT AS IDENTITY".to_string());
+    }
+    Some(format!(
+        "DEFAULT {}",
+        rewrite_postgres_schema_qualified_references(default_value, source_schema, target_schema)
+    ))
+}
+
+fn is_mysql_family_target(target_db: &DatabaseType) -> bool {
+    matches!(
+        target_db,
+        DatabaseType::Mysql
+            | DatabaseType::Doris
+            | DatabaseType::StarRocks
+            | DatabaseType::Goldendb
+            | DatabaseType::Sundb
+    )
+}
+
+/// QuestDB is not included. It only uses the PGWire protocol. SQL DDL syntax is not compatible.
+fn is_postgres_family_target(target_db: &DatabaseType) -> bool {
+    matches!(
+        target_db,
+        DatabaseType::Postgres
+            | DatabaseType::Gaussdb
+            | DatabaseType::OpenGauss
+            | DatabaseType::Redshift
+            | DatabaseType::Kingbase
+            | DatabaseType::Highgo
+            | DatabaseType::Kwdb
+            | DatabaseType::Vastbase
+    )
+}
+
+fn is_mysql_numeric_base_type(data_type: &str) -> bool {
+    let normalized = data_type.trim().to_ascii_lowercase();
+    let base = normalized.split(['(', ' ']).next().unwrap_or("");
+    matches!(
+        base,
+        "tinyint"
+            | "smallint"
+            | "mediumint"
+            | "int"
+            | "integer"
+            | "bigint"
+            | "decimal"
+            | "numeric"
+            | "float"
+            | "double"
+            | "real"
+            | "bit"
+            | "year"
+    )
+}
+
+fn is_mysql_function_default(raw: &str) -> bool {
+    let trimmed = raw.trim();
+    if trimmed.eq_ignore_ascii_case("NULL") {
+        return true;
+    }
+    let upper = trimmed.to_ascii_uppercase();
+    if upper == "CURRENT_TIMESTAMP" || upper.starts_with("CURRENT_TIMESTAMP(") {
+        return true;
+    }
+    if upper == "LOCALTIME" || upper.starts_with("LOCALTIME(") {
+        return true;
+    }
+    if upper == "LOCALTIMESTAMP" || upper.starts_with("LOCALTIMESTAMP(") {
+        return true;
+    }
+    matches!(upper.as_str(), "CURRENT_DATE" | "CURRENT_TIME" | "NOW()" | "UTC_TIMESTAMP()" | "UUID()")
+}
+
+fn looks_like_numeric_literal(raw: &str) -> bool {
+    let trimmed = raw.trim();
+    if trimmed.is_empty() {
+        return false;
+    }
+    trimmed.parse::<i64>().is_ok()
+        || trimmed.parse::<u64>().is_ok()
+        || trimmed.parse::<f64>().is_ok_and(|value| value.is_finite())
+}
+
+fn format_mysql_default_literal(raw: &str, data_type: &str) -> String {
+    let trimmed = raw.trim();
+    if trimmed.eq_ignore_ascii_case("NULL") {
+        return "NULL".to_string();
+    }
+    if is_mysql_function_default(trimmed) {
+        return trimmed.to_string();
+    }
+    if trimmed.len() >= 2 && trimmed.starts_with('\'') && trimmed.ends_with('\'') {
+        return trimmed.to_string();
+    }
+    if is_mysql_numeric_base_type(data_type) && looks_like_numeric_literal(trimmed) {
+        return trimmed.to_string();
+    }
+    format!("'{}'", trimmed.replace('\'', "''"))
+}
+
+fn column_default_clause(
+    column: &db::ColumnInfo,
+    source_schema: &str,
+    target_schema: &str,
+    source_db: &DatabaseType,
+    target_db: &DatabaseType,
+) -> Option<String> {
+    if is_postgres_compat_transfer(source_db, target_db) {
+        return postgres_default_clause(column, source_schema, target_schema, source_db, target_db);
+    }
+    if is_mysql_family_target(target_db) {
+        let default_value = column.column_default.as_deref()?.trim();
+        if default_value.is_empty() {
+            return None;
+        }
+        return Some(format!("DEFAULT {}", format_mysql_default_literal(default_value, &column.data_type)));
+    }
+    None
+}
+
+#[derive(Debug, Default, PartialEq, Eq)]
+struct MysqlExtraClauses {
+    auto_increment: bool,
+    on_update: Option<String>,
+}
+
+fn parse_mysql_extra_clauses(extra: Option<&str>) -> MysqlExtraClauses {
+    let mut result = MysqlExtraClauses::default();
+    let Some(raw) = extra else {
+        return result;
+    };
+    let trimmed = raw.trim();
+    if trimmed.is_empty() {
+        return result;
+    }
+
+    let lowered = trimmed.to_ascii_lowercase();
+    if lowered.contains("auto_increment") {
+        result.auto_increment = true;
+    }
+
+    let pattern = Regex::new(r"(?i)\bon\s+update\s+(.+)$").expect("valid mysql on-update regex");
+    if let Some(captures) = pattern.captures(trimmed) {
+        let raw_expr = captures.get(1).map(|m| m.as_str()).unwrap_or("");
+        let cleaned = raw_expr.trim().trim_end_matches([',', ';', ' ']).trim();
+        if !cleaned.is_empty() {
+            result.on_update = Some(cleaned.to_string());
+        }
+    }
+
+    result
+}
+
+fn postgres_order_by_expression(columns: &[String], db_type: &DatabaseType) -> Option<String> {
+    if columns.is_empty() {
+        return None;
+    }
+    Some(columns.iter().map(|column| quote_identifier(column, db_type)).collect::<Vec<_>>().join(", "))
+}
+
+fn oracle_rownum_page_sql(col_list: &str, base_sql: String, offset: u64, limit: usize) -> String {
+    if offset == 0 {
+        return format!("SELECT {col_list} FROM ({base_sql}) WHERE ROWNUM <= {limit}");
+    }
+    let end = offset + limit as u64;
+    format!(
+        "SELECT {col_list} FROM (SELECT dbx_inner.*, ROWNUM AS \"__dbx_row_num\" FROM ({base_sql}) dbx_inner WHERE ROWNUM <= {end}) WHERE \"__dbx_row_num\" > {offset}"
+    )
+}
+
+fn postgres_index_column_sql(column: &str) -> String {
+    if is_simple_identifier(column) {
+        quote_identifier(column, &DatabaseType::Postgres)
+    } else {
+        column.to_string()
+    }
+}
+
+fn generate_postgres_index_ddl(indexes: &[db::IndexInfo], table: &str, schema: &str) -> Vec<String> {
+    let full_table = qualified_table(table, schema, &DatabaseType::Postgres);
+    let mut statements = Vec::new();
+    for index in indexes.iter().filter(|index| !index.is_primary) {
+        if index.name.trim().is_empty() || index.columns.is_empty() {
+            continue;
+        }
+        let unique = if index.is_unique { "UNIQUE " } else { "" };
+        let using_clause = index
+            .index_type
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .map(|value| format!(" USING {value}"))
+            .unwrap_or_default();
+        let columns =
+            index.columns.iter().map(|column| postgres_index_column_sql(column)).collect::<Vec<_>>().join(", ");
+        let include_clause = index
+            .included_columns
+            .as_ref()
+            .filter(|columns| !columns.is_empty())
+            .map(|columns| {
+                format!(
+                    " INCLUDE ({})",
+                    columns
+                        .iter()
+                        .map(|column| quote_identifier(column, &DatabaseType::Postgres))
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            })
+            .unwrap_or_default();
+        let filter_clause = index
+            .filter
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+            .map(|value| format!(" WHERE {value}"))
+            .unwrap_or_default();
+        statements.push(format!(
+            "CREATE {unique}INDEX IF NOT EXISTS {} ON {full_table}{using_clause} ({columns}){include_clause}{filter_clause}",
+            quote_identifier(&index.name, &DatabaseType::Postgres)
+        ));
+        if let Some(comment) = index.comment.as_deref().map(str::trim).filter(|value| !value.is_empty()) {
+            let qualified_index = if schema.is_empty() {
+                quote_identifier(&index.name, &DatabaseType::Postgres)
+            } else {
+                format!(
+                    "{}.{}",
+                    quote_identifier(schema, &DatabaseType::Postgres),
+                    quote_identifier(&index.name, &DatabaseType::Postgres)
+                )
+            };
+            statements.push(format!("COMMENT ON INDEX {qualified_index} IS {}", quote_string_literal(comment)));
+        }
+    }
+    statements
+}
+
+fn generate_postgres_foreign_key_ddl(
+    foreign_keys: &[db::ForeignKeyInfo],
+    table: &str,
+    source_schema: &str,
+    target_schema: &str,
+) -> Vec<String> {
+    let full_table = qualified_table(table, target_schema, &DatabaseType::Postgres);
+    let mut grouped: HashMap<&str, Vec<&db::ForeignKeyInfo>> = HashMap::new();
+    let mut order = Vec::new();
+
+    for foreign_key in foreign_keys {
+        if !grouped.contains_key(foreign_key.name.as_str()) {
+            order.push(foreign_key.name.as_str());
+        }
+        grouped.entry(foreign_key.name.as_str()).or_default().push(foreign_key);
+    }
+
+    let mut statements = Vec::new();
+    for name in order {
+        let Some(group) = grouped.get(name) else {
+            continue;
+        };
+        let columns = group
+            .iter()
+            .map(|foreign_key| quote_identifier(&foreign_key.column, &DatabaseType::Postgres))
+            .collect::<Vec<_>>()
+            .join(", ");
+        let ref_columns = group
+            .iter()
+            .map(|foreign_key| quote_identifier(&foreign_key.ref_column, &DatabaseType::Postgres))
+            .collect::<Vec<_>>()
+            .join(", ");
+        let referenced_schema = match group[0].ref_schema.as_deref() {
+            Some(ref_schema) if ref_schema == source_schema => target_schema,
+            Some(ref_schema) => ref_schema,
+            None => target_schema,
+        };
+        let referenced_table = qualified_table(&group[0].ref_table, referenced_schema, &DatabaseType::Postgres);
+        statements.push(format!(
+            "ALTER TABLE {full_table} ADD CONSTRAINT {} FOREIGN KEY ({columns}) REFERENCES {referenced_table} ({ref_columns})",
+            quote_identifier(name, &DatabaseType::Postgres)
+        ));
+    }
+
+    statements
+}
+
+fn generate_postgres_sequence_sync_sql(columns: &[db::ColumnInfo], table: &str, schema: &str) -> Vec<String> {
+    let full_table = qualified_table(table, schema, &DatabaseType::Postgres);
+    columns
+        .iter()
+        .filter(|column| {
+            is_postgres_sequence_default(column.column_default.as_deref())
+                || is_postgres_identity_extra(column.extra.as_deref())
+        })
+        .map(|column| {
+            let quoted_column = quote_identifier(&column.name, &DatabaseType::Postgres);
+            format!(
+                "SELECT setval(pg_get_serial_sequence({}, {}), GREATEST(COALESCE(MAX({quoted_column}), 0), 1), MAX({quoted_column}) IS NOT NULL) FROM {full_table}",
+                quote_string_literal(&full_table),
+                quote_string_literal(&column.name)
+            )
+        })
+        .collect()
+}
+
+#[derive(Debug, Clone)]
+struct PostgresOwnedSequence {
+    name: String,
+    owner_table: String,
+    owner_column: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct PostgresSequenceSnapshot {
+    name: String,
+    owner_table: Option<String>,
+    owner_column: Option<String>,
+}
+
+fn postgres_sequence_qualified_name(schema: &str, sequence_name: &str) -> String {
+    if schema.trim().is_empty() {
+        quote_identifier(sequence_name, &DatabaseType::Postgres)
+    } else {
+        format!(
+            "{}.{}",
+            quote_identifier(schema, &DatabaseType::Postgres),
+            quote_identifier(sequence_name, &DatabaseType::Postgres)
+        )
+    }
+}
+
+/// Reuse an existing target sequence only when it is already bound to the same
+/// target table column; otherwise the later `OWNED BY` rebind would silently
+/// change unrelated objects.
+fn validate_existing_postgres_sequence(
+    sequence: &PostgresOwnedSequence,
+    existing: Option<&PostgresSequenceSnapshot>,
+    schema: &str,
+) -> Result<bool, String> {
+    let Some(existing) = existing else {
+        return Ok(true);
+    };
+
+    let owner_matches = match (existing.owner_table.as_deref(), existing.owner_column.as_deref()) {
+        (None, None) => true,
+        (Some(owner_table), Some(owner_column)) => {
+            owner_table == sequence.owner_table && owner_column == sequence.owner_column
+        }
+        _ => false,
+    };
+
+    if owner_matches {
+        return Ok(false);
+    }
+
+    Err(format!(
+        "PostgreSQL sequence {} already exists with incompatible ownership",
+        postgres_sequence_qualified_name(schema, &sequence.name)
+    ))
+}
+#[derive(Debug, Clone)]
+struct PostgresTriggerSource {
+    table_name: String,
+    trigger_name: String,
+    source: String,
+}
+
+#[derive(Debug, Clone)]
+struct PostgresExtensionSource {
+    extension_name: String,
+}
+
+#[derive(Debug, Clone)]
+struct PostgresEnumSource {
+    type_name: String,
+    labels: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+struct PostgresDomainSource {
+    domain_name: String,
+    base_type: String,
+    default_value: Option<String>,
+    not_null: bool,
+    checks: Vec<String>,
+}
+
+#[derive(Debug, Clone)]
+struct PostgresMaterializedViewSource {
+    view_name: String,
+    source: String,
+}
+
+#[derive(Debug, Clone)]
+struct PostgresOwnershipStatement {
+    sql_prefix: String,
+    owner: String,
+}
+
+fn json_string_cell(row: &[serde_json::Value], index: usize) -> Option<String> {
+    row.get(index).and_then(|value| value.as_str().map(str::to_string))
+}
+
+fn result_rows_to_string_statements(rows: Vec<Vec<serde_json::Value>>) -> Vec<String> {
+    rows.into_iter().filter_map(|row| json_string_cell(&row, 0)).filter(|stmt| !stmt.trim().is_empty()).collect()
+}
+
+fn result_rows_to_postgres_ownership_statements(rows: Vec<Vec<serde_json::Value>>) -> Vec<PostgresOwnershipStatement> {
+    rows.into_iter()
+        .filter_map(|row| {
+            let sql_prefix = json_string_cell(&row, 0)?;
+            let owner = json_string_cell(&row, 1)?;
+            if sql_prefix.trim().is_empty() || owner.trim().is_empty() {
+                None
+            } else {
+                Some(PostgresOwnershipStatement { sql_prefix, owner })
+            }
+        })
+        .collect()
+}
+
+fn ensure_sql_statement_terminated(sql: &str) -> String {
+    let trimmed = sql.trim();
+    if trimmed.ends_with(';') {
+        trimmed.to_string()
+    } else {
+        format!("{trimmed};")
+    }
+}
+
+fn generate_postgres_extension_ddl(extension: &PostgresExtensionSource, target_schema: &str) -> String {
+    format!(
+        "CREATE EXTENSION IF NOT EXISTS {} WITH SCHEMA {}",
+        quote_identifier(&extension.extension_name, &DatabaseType::Postgres),
+        quote_identifier(target_schema, &DatabaseType::Postgres)
+    )
+}
+
+fn generate_postgres_enum_ddl(enum_type: &PostgresEnumSource, target_schema: &str) -> String {
+    let labels = enum_type.labels.iter().map(|label| quote_string_literal(label)).collect::<Vec<_>>().join(", ");
+    let create_sql = format!(
+        "CREATE TYPE {}.{} AS ENUM ({labels})",
+        quote_identifier(target_schema, &DatabaseType::Postgres),
+        quote_identifier(&enum_type.type_name, &DatabaseType::Postgres)
+    );
+    format!(
+        "DO $$ BEGIN IF NOT EXISTS (SELECT 1 FROM pg_type t JOIN pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = {} AND t.typname = {}) THEN {create_sql}; END IF; END $$",
+        quote_string_literal(target_schema),
+        quote_string_literal(&enum_type.type_name)
+    )
+}
+
+fn generate_postgres_domain_ddl(domain: &PostgresDomainSource, target_schema: &str) -> String {
+    let mut create_sql = format!(
+        "CREATE DOMAIN {}.{} AS {}",
+        quote_identifier(target_schema, &DatabaseType::Postgres),
+        quote_identifier(&domain.domain_name, &DatabaseType::Postgres),
+        domain.base_type
+    );
+    if let Some(default_value) = domain.default_value.as_deref().map(str::trim).filter(|value| !value.is_empty()) {
+        create_sql.push_str(&format!(" DEFAULT {default_value}"));
+    }
+    if domain.not_null {
+        create_sql.push_str(" NOT NULL");
+    }
+    for check in &domain.checks {
+        create_sql.push(' ');
+        create_sql.push_str(check);
+    }
+    format!(
+        "DO $$ BEGIN IF NOT EXISTS (SELECT 1 FROM pg_type t JOIN pg_namespace n ON n.oid = t.typnamespace WHERE n.nspname = {} AND t.typname = {}) THEN {}; END IF; END $$",
+        quote_string_literal(target_schema),
+        quote_string_literal(&domain.domain_name),
+        create_sql
+    )
+}
+
+fn generate_postgres_materialized_view_ddls(view: &PostgresMaterializedViewSource, target_schema: &str) -> Vec<String> {
+    let qualified_name = qualified_table(&view.view_name, target_schema, &DatabaseType::Postgres);
+    vec![
+        format!("DROP MATERIALIZED VIEW IF EXISTS {qualified_name}"),
+        format!("CREATE MATERIALIZED VIEW {qualified_name} AS\n{}", ensure_sql_statement_terminated(&view.source)),
+    ]
+}
+
+fn rewrite_postgres_routine_schema(source: &str, source_schema: &str, target_schema: &str) -> Option<String> {
+    let re = Regex::new(
+        r#"(?is)^(\s*CREATE\s+(?:OR\s+REPLACE\s+)?(?:(?:NON)?EDITIONABLE\s+)?(?:FUNCTION|PROCEDURE)\s+)((?:"(?:""|[^"])+"|[A-Za-z_][\w$]*)(?:\s*\.\s*(?:"(?:""|[^"])+"|[A-Za-z_][\w$]*))?)"#,
+    )
+    .ok()?;
+    let captures = re.captures(source)?;
+    let full = captures.get(0)?;
+    let prefix = captures.get(1)?.as_str();
+    let existing_name = captures.get(2)?.as_str();
+    let name_re = Regex::new(r#""(?:""|[^"])+"|[A-Za-z_][\w$]*"#).ok()?;
+    let parts = name_re
+        .find_iter(existing_name)
+        .map(|part| part.as_str().trim().trim_matches('"').replace("\"\"", "\""))
+        .collect::<Vec<_>>();
+    let name = parts.last()?;
+    let replacement = format!(
+        "{}.{}",
+        quote_identifier(target_schema, &DatabaseType::Postgres),
+        quote_identifier(name, &DatabaseType::Postgres)
+    );
+    let rewritten = format!("{}{}{}{}", &source[..full.start()], prefix, replacement, &source[full.end()..]);
+    Some(rewrite_postgres_schema_qualified_references(&rewritten, source_schema, target_schema))
+}
+
+fn rewrite_postgres_trigger_table_schema(
+    source: &str,
+    source_schema: &str,
+    table_name: &str,
+    target_schema: &str,
+) -> String {
+    let qualified_target_table = qualified_table(table_name, target_schema, &DatabaseType::Postgres);
+    let candidate_patterns = [
+        format!(
+            " ON {}.{} ",
+            quote_identifier(source_schema, &DatabaseType::Postgres),
+            quote_identifier(table_name, &DatabaseType::Postgres)
+        ),
+        format!(" ON {source_schema}.{table_name} "),
+        format!(" ON {} ", quote_identifier(table_name, &DatabaseType::Postgres)),
+        format!(" ON {table_name} "),
+    ];
+    for pattern in candidate_patterns {
+        if source.contains(&pattern) {
+            let rewritten = source.replacen(&pattern, &format!(" ON {qualified_target_table} "), 1);
+            return rewrite_postgres_schema_qualified_references(&rewritten, source_schema, target_schema);
+        }
+    }
+    rewrite_postgres_schema_qualified_references(source, source_schema, target_schema)
+}
+
+pub fn escape_value(val: &serde_json::Value, db_type: &DatabaseType) -> String {
+    escape_value_typed(val, db_type, None)
+}
+
+pub fn escape_value_typed(val: &serde_json::Value, db_type: &DatabaseType, column_type: Option<&str>) -> String {
+    match val {
+        serde_json::Value::Null => "NULL".to_string(),
+        serde_json::Value::Bool(b) => match db_type {
+            DatabaseType::Mysql
+            | DatabaseType::Sqlite
+            | DatabaseType::CloudflareD1
+            | DatabaseType::DuckDb
+            | DatabaseType::Doris
+            | DatabaseType::StarRocks => {
+                if *b {
+                    if column_type.is_some_and(is_mysql_bit_type) {
+                        "b'1'".to_string()
+                    } else {
+                        "1".to_string()
+                    }
+                } else {
+                    if column_type.is_some_and(is_mysql_bit_type) {
+                        "b'0'".to_string()
+                    } else {
+                        "0".to_string()
+                    }
+                }
+            }
+            DatabaseType::SqlServer => {
+                if *b {
+                    "1".to_string()
+                } else {
+                    "0".to_string()
+                }
+            }
+            _ => {
+                if *b {
+                    "TRUE".to_string()
+                } else {
+                    "FALSE".to_string()
+                }
+            }
+        },
+        serde_json::Value::Number(n) => match db_type {
+            DatabaseType::Mysql | DatabaseType::Doris | DatabaseType::StarRocks => {
+                if column_type.is_some_and(is_mysql_bit_type) {
+                    format!("b'{}'", n)
+                } else {
+                    n.to_string()
+                }
+            }
+            _ => n.to_string(),
+        },
+        serde_json::Value::String(s) => {
+            if let Some(binary_literal) = format_postgres_binary_sql_literal(s, db_type, column_type) {
+                return binary_literal;
+            }
+            if let Some(binary_literal) = format_mysql_binary_sql_literal(s, db_type, column_type) {
+                return binary_literal;
+            }
+            if let Some(numeric_literal) = format_mysql_numeric_string_literal(s, db_type, column_type) {
+                return numeric_literal;
+            }
+            if let Some(date_literal) = format_oracle_date_sql_literal(s, db_type, column_type) {
+                return date_literal;
+            }
+
+            let literal = format_literal_string(s, db_type, column_type);
+            let escaped = if is_postgres_family_target(db_type) {
+                literal.replace('\'', "''")
+            } else {
+                literal.replace('\\', "\\\\").replace('\'', "''")
+            };
+            match db_type {
+                DatabaseType::Mysql | DatabaseType::Doris | DatabaseType::StarRocks
+                    if column_type.is_some_and(is_mysql_bit_type) =>
+                {
+                    format!("b'{escaped}'")
+                }
+                DatabaseType::SqlServer => format!("N'{escaped}'"),
+                _ => format!("'{escaped}'"),
+            }
+        }
+        serde_json::Value::Array(arr) => match db_type {
+            DatabaseType::ClickHouse | DatabaseType::Databend => format_ch_array_sql_literal(arr),
+            _ => format_pg_array_sql_literal(arr),
+        },
+        _ => {
+            let s = val.to_string();
+            format!("'{}'", s.replace('\\', "\\\\").replace('\'', "''"))
+        }
+    }
+}
+
+fn is_mysql_bit_type(column_type: &str) -> bool {
+    let trimmed = column_type.trim();
+    let lower = trimmed.to_ascii_lowercase();
+    lower == "bit" || lower.starts_with("bit(") || lower.starts_with("bit ")
+}
+
+fn is_mysql_numeric_string_literal_database(db_type: &DatabaseType) -> bool {
+    matches!(
+        db_type,
+        DatabaseType::Mysql
+            | DatabaseType::Doris
+            | DatabaseType::StarRocks
+            | DatabaseType::Goldendb
+            | DatabaseType::Sundb
+    )
+}
+
+fn is_mysql_non_bit_numeric_type(column_type: &str) -> bool {
+    is_mysql_numeric_base_type(column_type) && !is_mysql_bit_type(column_type)
+}
+
+fn format_mysql_numeric_string_literal(
+    value: &str,
+    db_type: &DatabaseType,
+    column_type: Option<&str>,
+) -> Option<String> {
+    if !is_mysql_numeric_string_literal_database(db_type) || !column_type.is_some_and(is_mysql_non_bit_numeric_type) {
+        return None;
+    }
+    let trimmed = value.trim();
+    if looks_like_numeric_literal(trimmed) {
+        Some(trimmed.to_string())
+    } else {
+        None
+    }
+}
+
+fn is_binary_transfer_column_type(column_type: &str) -> bool {
+    let lower = column_type.trim().to_ascii_lowercase();
+    let base = lower.split(['(', ' ', '\t', '\n']).next().unwrap_or("");
+    matches!(base, "binary" | "varbinary" | "blob" | "tinyblob" | "mediumblob" | "longblob" | "bytea" | "image")
+}
+
+fn format_postgres_binary_sql_literal(
+    value: &str,
+    db_type: &DatabaseType,
+    column_type: Option<&str>,
+) -> Option<String> {
+    if !matches!(db_type, DatabaseType::Postgres) || !column_type.is_some_and(is_binary_transfer_column_type) {
+        return None;
+    }
+
+    let hex = value.strip_prefix("0x").or_else(|| value.strip_prefix("0X"))?;
+    if hex.len() % 2 != 0 || !hex.as_bytes().iter().all(|byte| byte.is_ascii_hexdigit()) {
+        return None;
+    }
+
+    Some(format!("decode('{hex}', 'hex')"))
+}
+
+fn format_mysql_binary_sql_literal(value: &str, db_type: &DatabaseType, column_type: Option<&str>) -> Option<String> {
+    if !matches!(db_type, DatabaseType::Mysql) || !column_type.is_some_and(is_binary_transfer_column_type) {
+        return None;
+    }
+
+    let trimmed = value.trim();
+    let hex = trimmed.strip_prefix("0x").or_else(|| trimmed.strip_prefix("0X"))?;
+    if hex.as_bytes().iter().all(|byte| byte.is_ascii_hexdigit()) {
+        Some(if hex.is_empty() { "X''".to_string() } else { format!("0x{hex}") })
+    } else {
+        None
+    }
+}
+
+fn format_oracle_date_sql_literal(value: &str, db_type: &DatabaseType, column_type: Option<&str>) -> Option<String> {
+    if !matches!(db_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle) {
+        return None;
+    }
+    if temporal_column_kind(column_type) != Some("date") {
+        return None;
+    }
+    let parts = oracle_export_date_parts(value)?;
+    Some(format_oracle_date_sql_literal_parts(&parts))
+}
+
+struct OracleExportDateParts<'a> {
+    date: &'a str,
+    time: &'a str,
+    fraction: Option<&'a str>,
+}
+
+fn format_oracle_date_sql_literal_parts(parts: &OracleExportDateParts<'_>) -> String {
+    if oracle_export_date_parts_are_midnight(parts) {
+        format!("DATE '{}'", parts.date)
+    } else {
+        format!("TO_DATE('{} {}', 'YYYY-MM-DD HH24:MI:SS')", parts.date, parts.time)
+    }
+}
+
+fn oracle_export_date_parts_are_midnight(parts: &OracleExportDateParts<'_>) -> bool {
+    parts.time == "00:00:00"
+        && parts.fraction.map(|fraction| fraction.trim_start_matches('.').chars().all(|ch| ch == '0')).unwrap_or(true)
+}
+
+fn oracle_export_date_parts(value: &str) -> Option<OracleExportDateParts<'_>> {
+    let bytes = value.as_bytes();
+    if bytes.len() < 10 || bytes.get(4) != Some(&b'-') || bytes.get(7) != Some(&b'-') {
+        return None;
+    }
+    let date = &value[..10];
+    if !date.as_bytes().iter().enumerate().all(|(index, byte)| matches!(index, 4 | 7) || byte.is_ascii_digit()) {
+        return None;
+    }
+    if bytes.len() == 10 {
+        return Some(OracleExportDateParts { date, time: "00:00:00", fraction: None });
+    }
+    let separator = *bytes.get(10)?;
+    if separator != b'T' && separator != b' ' {
+        return None;
+    }
+    if bytes.len() < 19 || bytes.get(13) != Some(&b':') || bytes.get(16) != Some(&b':') {
+        return None;
+    }
+    let time = &value[11..19];
+    if !time.as_bytes().iter().enumerate().all(|(index, byte)| matches!(index, 2 | 5) || byte.is_ascii_digit()) {
+        return None;
+    }
+    let rest = &value[19..];
+    if rest.is_empty() || is_timezone_suffix(rest) {
+        return Some(OracleExportDateParts { date, time, fraction: None });
+    }
+    if let Some(after_dot) = rest.strip_prefix('.') {
+        let digit_count = after_dot.bytes().take_while(|byte| byte.is_ascii_digit()).count();
+        if digit_count == 0 {
+            return None;
+        }
+        let zone = &after_dot[digit_count..];
+        if zone.is_empty() || is_timezone_suffix(zone) {
+            return Some(OracleExportDateParts { date, time, fraction: Some(&value[19..19 + 1 + digit_count]) });
+        }
+    }
+    None
+}
+
+pub fn format_pg_array_sql_literal(arr: &[serde_json::Value]) -> String {
+    if arr.is_empty() {
+        return "'{}'".to_string();
+    }
+    let elements: Vec<String> = arr.iter().map(format_pg_array_element).collect();
+    let inner = format!("{{{}}}", elements.join(","));
+    format!("'{}'", inner.replace('\\', "\\\\").replace('\'', "''"))
+}
+
+fn format_pg_array_element(val: &serde_json::Value) -> String {
+    match val {
+        serde_json::Value::Null => "NULL".to_string(),
+        serde_json::Value::Array(arr) => {
+            if arr.is_empty() {
+                return "{}".to_string();
+            }
+            let elements: Vec<String> = arr.iter().map(format_pg_array_element).collect();
+            format!("{{{}}}", elements.join(","))
+        }
+        serde_json::Value::String(s) => {
+            let escaped = s.replace('\\', "\\\\").replace('"', "\\\"");
+            format!("\"{}\"", escaped)
+        }
+        serde_json::Value::Number(n) => n.to_string(),
+        serde_json::Value::Bool(b) => {
+            if *b {
+                "true".to_string()
+            } else {
+                "false".to_string()
+            }
+        }
+        serde_json::Value::Object(o) => {
+            let json = serde_json::to_string(o).unwrap_or_default();
+            let escaped = json.replace('\\', "\\\\").replace('"', "\\\"");
+            format!("\"{}\"", escaped)
+        }
+    }
+}
+
+pub fn format_ch_array_sql_literal(arr: &[serde_json::Value]) -> String {
+    if arr.is_empty() {
+        return "[]".to_string();
+    }
+    let elements: Vec<String> = arr.iter().map(format_ch_array_element).collect();
+    format!("[{}]", elements.join(","))
+}
+
+fn format_ch_array_element(val: &serde_json::Value) -> String {
+    match val {
+        serde_json::Value::Null => "NULL".to_string(),
+        serde_json::Value::Array(arr) => {
+            if arr.is_empty() {
+                return "[]".to_string();
+            }
+            let elements: Vec<String> = arr.iter().map(format_ch_array_element).collect();
+            format!("[{}]", elements.join(","))
+        }
+        serde_json::Value::String(s) => {
+            let escaped = s.replace('\\', "\\\\").replace('\'', "''");
+            format!("'{}'", escaped)
+        }
+        serde_json::Value::Number(n) => n.to_string(),
+        serde_json::Value::Bool(b) => {
+            if *b {
+                "true".to_string()
+            } else {
+                "false".to_string()
+            }
+        }
+        serde_json::Value::Object(o) => {
+            let json = serde_json::to_string(o).unwrap_or_default();
+            format!("'{}'", json.replace('\\', "\\\\").replace('\'', "''"))
+        }
+    }
+}
+
+fn format_literal_string(value: &str, db_type: &DatabaseType, column_type: Option<&str>) -> String {
+    if *db_type == DatabaseType::SqlServer {
+        crate::sqlserver_temporal::normalize_sqlserver_temporal_literal(value, column_type)
+            .unwrap_or_else(|| value.to_string())
+    } else if is_mysql_datetime_literal_database(db_type) && column_type.map(is_temporal_column_type).unwrap_or(true) {
+        normalize_mysql_temporal_literal(value, column_type).unwrap_or_else(|| value.to_string())
+    } else {
+        value.to_string()
+    }
+}
+
+fn is_mysql_datetime_literal_database(db_type: &DatabaseType) -> bool {
+    matches!(
+        db_type,
+        DatabaseType::Mysql
+            | DatabaseType::Doris
+            | DatabaseType::StarRocks
+            | DatabaseType::Goldendb
+            | DatabaseType::Sundb
+    )
+}
+
+fn normalize_mysql_temporal_literal(value: &str, column_type: Option<&str>) -> Option<String> {
+    let bytes = value.as_bytes();
+    if bytes.len() < 20 || !is_mysql_datetime_base(bytes) {
+        return None;
+    }
+
+    let rest = &value[19..];
+    let (fraction, offset) = if let Some(after_dot) = rest.strip_prefix('.') {
+        let digit_count = after_dot.bytes().take_while(|b| b.is_ascii_digit()).count();
+        if digit_count == 0 {
+            return None;
+        }
+        let fraction_len = 1 + digit_count;
+        (&rest[..fraction_len.min(7)], &rest[fraction_len..])
+    } else {
+        ("", rest)
+    };
+
+    if !is_timezone_suffix(offset) {
+        return None;
+    }
+
+    match temporal_column_kind(column_type) {
+        Some("date") => Some(value[..10].to_string()),
+        Some("time") => Some(format!("{}{}", &value[11..19], fraction)),
+        _ => Some(format!("{} {}{}", &value[..10], &value[11..19], fraction)),
+    }
+}
+
+fn is_temporal_column_type(column_type: &str) -> bool {
+    temporal_column_kind(Some(column_type)).is_some()
+}
+
+fn temporal_column_kind(column_type: Option<&str>) -> Option<&'static str> {
+    let base = column_type?.trim().to_ascii_lowercase();
+    let base = base.split(['(', ':', ' ']).next().unwrap_or("");
+    match base {
+        "date" => Some("date"),
+        "time" => Some("time"),
+        "datetime" | "timestamp" => Some("datetime"),
+        _ => None,
+    }
+}
+
+fn is_mysql_datetime_base(bytes: &[u8]) -> bool {
+    matches!(
+        bytes,
+        [
+            y0,
+            y1,
+            y2,
+            y3,
+            b'-',
+            m0,
+            m1,
+            b'-',
+            d0,
+            d1,
+            sep,
+            h0,
+            h1,
+            b':',
+            min0,
+            min1,
+            b':',
+            s0,
+            s1,
+            ..
+        ] if y0.is_ascii_digit()
+            && y1.is_ascii_digit()
+            && y2.is_ascii_digit()
+            && y3.is_ascii_digit()
+            && m0.is_ascii_digit()
+            && m1.is_ascii_digit()
+            && d0.is_ascii_digit()
+            && d1.is_ascii_digit()
+            && (*sep == b'T' || *sep == b' ')
+            && h0.is_ascii_digit()
+            && h1.is_ascii_digit()
+            && min0.is_ascii_digit()
+            && min1.is_ascii_digit()
+            && s0.is_ascii_digit()
+            && s1.is_ascii_digit()
+    )
+}
+
+fn is_timezone_suffix(value: &str) -> bool {
+    if value.eq_ignore_ascii_case("z") {
+        return true;
+    }
+    let bytes = value.as_bytes();
+    matches!(
+        bytes,
+        [sign, h0, h1, b':', m0, m1]
+            if (*sign == b'+' || *sign == b'-')
+                && h0.is_ascii_digit()
+                && h1.is_ascii_digit()
+                && m0.is_ascii_digit()
+                && m1.is_ascii_digit()
+    )
+}
+
+pub fn map_column_type(source_type: &str, _source_db: &DatabaseType, target_db: &DatabaseType) -> String {
+    if _source_db == target_db {
+        return source_type.to_string();
+    }
+    let t = source_type.to_lowercase();
+    let mut base = t.split('(').next().unwrap_or(&t).trim();
+    // Extract basic type, `bigint unsigned` -> `bigint`
+    base = base.split(' ').next().unwrap_or(base).trim();
+
+    if matches!(target_db, DatabaseType::Hive) {
+        return match base {
+            "tinyint" => "TINYINT".into(),
+            "smallint" | "int2" => "SMALLINT".into(),
+            "int" | "integer" | "int4" | "mediumint" | "serial" | "smallserial" => "INT".into(),
+            "bigint" | "int8" | "bigserial" => "BIGINT".into(),
+            "float" | "float4" | "real" => "FLOAT".into(),
+            "double" | "double precision" | "float8" => "DOUBLE".into(),
+            "decimal" | "numeric" | "number" => {
+                if let Some(index) = t.find('(') {
+                    format!("DECIMAL{}", &t[index..])
+                } else {
+                    "DECIMAL".into()
+                }
+            }
+            "bool" | "boolean" | "bit" => "BOOLEAN".into(),
+            "date" => "DATE".into(),
+            "datetime" | "timestamp" | "timestamptz" | "timestamp with time zone" | "timestamp without time zone" => {
+                "TIMESTAMP".into()
+            }
+            "binary" | "varbinary" | "blob" | "tinyblob" | "mediumblob" | "longblob" | "bytea" | "image" => {
+                "BINARY".into()
+            }
+            _ => "STRING".into(),
+        };
+    }
+
+    match base {
+        "int" | "integer" | "int4" | "mediumint" => match target_db {
+            target_db if is_postgres_transfer_dialect(target_db) => "INTEGER".into(),
+            DatabaseType::Mysql => "INT".into(),
+            DatabaseType::SqlServer => "INT".into(),
+            _ => "INTEGER".into(),
+        },
+        "bigint" | "int8" => "BIGINT".into(),
+        "smallint" | "int2" => "SMALLINT".into(),
+        "tinyint" => match target_db {
+            target_db if is_postgres_transfer_dialect(target_db) => "SMALLINT".into(),
+            _ => "TINYINT".into(),
+        },
+        "serial" | "bigserial" | "smallserial" => match target_db {
+            target_db if is_postgres_transfer_dialect(target_db) => source_type.to_uppercase(),
+            DatabaseType::Mysql => "BIGINT AUTO_INCREMENT".into(),
+            _ => "INTEGER".into(),
+        },
+        "float" | "float4" | "real" => match target_db {
+            target_db if is_postgres_transfer_dialect(target_db) => "REAL".into(),
+            _ => "FLOAT".into(),
+        },
+        "double" | "double precision" | "float8" => match target_db {
+            target_db if is_postgres_transfer_dialect(target_db) => "DOUBLE PRECISION".into(),
+            _ => "DOUBLE".into(),
+        },
+        "decimal" | "numeric" | "number" => {
+            if t.contains('(') {
+                match target_db {
+                    DatabaseType::Mysql | DatabaseType::SqlServer | DatabaseType::Oracle => {
+                        format!("DECIMAL{}", &t[t.find('(').unwrap()..])
+                    }
+                    target_db if is_postgres_transfer_dialect(target_db) => {
+                        format!("DECIMAL{}", &t[t.find('(').unwrap()..])
+                    }
+                    _ => "NUMERIC".into(),
+                }
+            } else {
+                "NUMERIC".into()
+            }
+        }
+        "varchar" | "nvarchar" | "character varying" | "varchar2" => {
+            if t.contains('(') {
+                let len_part = &t[t.find('(').unwrap()..];
+                match target_db {
+                    target_db if is_postgres_transfer_dialect(target_db) => format!("VARCHAR{len_part}"),
+                    DatabaseType::Mysql => format!("VARCHAR{len_part}"),
+                    DatabaseType::SqlServer => format!("NVARCHAR{len_part}"),
+                    _ => format!("VARCHAR{len_part}"),
+                }
+            } else {
+                "VARCHAR(255)".into()
+            }
+        }
+        "char" | "nchar" | "character" => {
+            if t.contains('(') {
+                let len_part = &t[t.find('(').unwrap()..];
+                format!("CHAR{len_part}")
+            } else {
+                "CHAR(1)".into()
+            }
+        }
+        "longtext" => match target_db {
+            DatabaseType::Mysql => "LONGTEXT".into(),
+            _ => "TEXT".into(),
+        },
+        "mediumtext" => match target_db {
+            DatabaseType::Mysql => "MEDIUMTEXT".into(),
+            _ => "TEXT".into(),
+        },
+        "text" | "tinytext" | "clob" | "ntext" => "TEXT".into(),
+        "bool" | "boolean" => match target_db {
+            DatabaseType::Mysql => "TINYINT(1)".into(),
+            DatabaseType::SqlServer => "BIT".into(),
+            _ => "BOOLEAN".into(),
+        },
+        "date" => "DATE".into(),
+        "time" => "TIME".into(),
+        "datetime" => match target_db {
+            target_db if is_postgres_transfer_dialect(target_db) => "TIMESTAMP".into(),
+            DatabaseType::ClickHouse => "DateTime64(6)".into(),
+            _ => "DATETIME".into(),
+        },
+        "timestamp" | "timestamptz" | "timestamp with time zone" | "timestamp without time zone" => match target_db {
+            DatabaseType::Mysql => "DATETIME".into(),
+            DatabaseType::SqlServer => "DATETIME2".into(),
+            DatabaseType::ClickHouse => "DateTime64(6)".into(),
+            _ => "TIMESTAMP".into(),
+        },
+        "longblob" => match target_db {
+            DatabaseType::Mysql => "LONGBLOB".into(),
+            target_db if is_postgres_transfer_dialect(target_db) => "BYTEA".into(),
+            DatabaseType::SqlServer => "VARBINARY(MAX)".into(),
+            _ => "BLOB".into(),
+        },
+        "mediumblob" => match target_db {
+            DatabaseType::Mysql => "MEDIUMBLOB".into(),
+            target_db if is_postgres_transfer_dialect(target_db) => "BYTEA".into(),
+            DatabaseType::SqlServer => "VARBINARY(MAX)".into(),
+            _ => "BLOB".into(),
+        },
+        "blob" | "tinyblob" | "binary" | "varbinary" | "image" => match target_db {
+            target_db if is_postgres_transfer_dialect(target_db) => "BYTEA".into(),
+            DatabaseType::Mysql => "BLOB".into(),
+            DatabaseType::SqlServer => "VARBINARY(MAX)".into(),
+            _ => "BLOB".into(),
+        },
+        "bytea" => match target_db {
+            target_db if is_postgres_transfer_dialect(target_db) => "BYTEA".into(),
+            DatabaseType::Mysql => "BLOB".into(),
+            _ => "BLOB".into(),
+        },
+        "json" | "jsonb" => match target_db {
+            target_db if is_postgres_transfer_dialect(target_db) => "JSONB".into(),
+            DatabaseType::Mysql => "JSON".into(),
+            _ => "TEXT".into(),
+        },
+        "uuid" => match target_db {
+            target_db if is_postgres_transfer_dialect(target_db) => "UUID".into(),
+            _ => "VARCHAR(36)".into(),
+        },
+        "bit" => match target_db {
+            target_db if is_postgres_transfer_dialect(target_db) => "BOOLEAN".into(),
+            _ => "BIT".into(),
+        },
+        _ => "TEXT".into(),
+    }
+}
+
+fn mysql_type_needs_key_prefix(mapped_type: &str) -> bool {
+    let base = mapped_type.split('(').next().unwrap_or(mapped_type).trim().to_ascii_lowercase();
+    matches!(
+        base.as_str(),
+        "text" | "tinytext" | "mediumtext" | "longtext" | "blob" | "tinyblob" | "mediumblob" | "longblob"
+    )
+}
+
+fn parse_mysql_row_error(error: &str) -> Option<u64> {
+    let error = error.trim();
+    let at_row = error.rsplit("at row ").next()?;
+    at_row.trim().parse::<u64>().ok()
+}
+
+pub fn generate_create_table_ddl(
+    columns: &[db::ColumnInfo],
+    table: &str,
+    source_schema: &str,
+    schema: &str,
+    target_db: &DatabaseType,
+    source_db: &DatabaseType,
+    table_comment: Option<&str>,
+) -> String {
+    let full_table = qualified_table(table, schema, target_db);
+
+    let is_mysql_family = matches!(
+        target_db,
+        DatabaseType::Mysql
+            | DatabaseType::Doris
+            | DatabaseType::StarRocks
+            | DatabaseType::Goldendb
+            | DatabaseType::Sundb
+    );
+
+    let mut col_lines = Vec::with_capacity(columns.len());
+    for c in columns {
+        col_lines.push({
+            let mapped_type = postgres_column_type_sql(c, source_schema, schema, source_db, target_db);
+            let mut line = format!("  {} {}", quote_identifier(&c.name, target_db), mapped_type);
+            if let Some(default_clause) = column_default_clause(c, source_schema, schema, source_db, target_db) {
+                line.push(' ');
+                line.push_str(&default_clause);
+            }
+            if !c.is_nullable && !matches!(target_db, DatabaseType::Hive) {
+                line.push_str(" NOT NULL");
+            }
+            if is_mysql_family {
+                let extra_clauses = parse_mysql_extra_clauses(c.extra.as_deref());
+                if extra_clauses.auto_increment {
+                    line.push_str(" AUTO_INCREMENT");
+                }
+                if let Some(on_update_expr) = extra_clauses.on_update {
+                    line.push_str(&format!(" ON UPDATE {on_update_expr}"));
+                }
+                if let Some(ref comment) = c.comment {
+                    let trimmed = comment.trim();
+                    if !trimmed.is_empty() {
+                        line.push_str(&format!(" COMMENT '{}'", trimmed.replace('\'', "''")));
+                    }
+                }
+            }
+            line
+        });
+    }
+
+    let mut pks = Vec::with_capacity(columns.iter().filter(|c| c.is_primary_key).count());
+    if !matches!(target_db, DatabaseType::Hive) {
+        for c in columns {
+            if c.is_primary_key {
+                let qname = quote_identifier(&c.name, target_db);
+                if is_mysql_family {
+                    let mapped = map_column_type(&c.data_type, source_db, target_db);
+                    if mysql_type_needs_key_prefix(&mapped) {
+                        pks.push(format!("{qname}(255)"));
+                        continue;
+                    }
+                }
+                pks.push(qname);
+            }
+        }
+    }
+
+    let mut ddl = match target_db {
+        DatabaseType::SqlServer => {
+            format!("IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{table}')\n")
+        }
+        _ => String::new(),
+    };
+
+    let create_prefix = match target_db {
+        DatabaseType::SqlServer => "CREATE TABLE",
+        _ => "CREATE TABLE IF NOT EXISTS",
+    };
+
+    ddl.push_str(&format!("{create_prefix} {full_table} (\n"));
+    ddl.push_str(&col_lines.join(",\n"));
+
+    // ClickHouse: PRIMARY KEY must be a prefix of ORDER BY; skip inline PK
+    // and encode it in the ENGINE clause below instead.
+    if !pks.is_empty() && !matches!(target_db, DatabaseType::ClickHouse) {
+        ddl.push_str(&format!(",\n  PRIMARY KEY ({})", pks.join(", ")));
+    }
+
+    ddl.push_str("\n)");
+
+    if is_mysql_family {
+        if let Some(comment) = table_comment {
+            let trimmed = comment.trim();
+            if !trimmed.is_empty() {
+                ddl.push_str(&format!(" COMMENT='{}'", trimmed.replace('\'', "''")));
+            }
+        }
+    }
+
+    if matches!(target_db, DatabaseType::ClickHouse) {
+        if pks.is_empty() {
+            ddl.push_str(" ENGINE = MergeTree() ORDER BY tuple()");
+        } else {
+            ddl.push_str(&format!(" ENGINE = MergeTree() ORDER BY ({})", pks.join(", ")));
+        }
+    }
+
+    ddl
+}
+
+/// Generate COMMENT ON COLUMN / ALTER TABLE COMMENT COLUMN / COMMENT ON TABLE
+/// statements for databases that don't support inline comments in CREATE TABLE.
+/// MySQL family uses inline syntax (handled in generate_create_table_ddl).
+pub fn generate_comment_ddl(
+    columns: &[db::ColumnInfo],
+    table: &str,
+    schema: &str,
+    target_db: &DatabaseType,
+    table_comment: Option<&str>,
+) -> Vec<String> {
+    if !matches!(target_db, DatabaseType::Postgres | DatabaseType::Oracle | DatabaseType::ClickHouse) {
+        return Vec::new();
+    }
+
+    let full_table = qualified_table(table, schema, target_db);
+    let mut statements = Vec::new();
+
+    // Table-level comment first (PostgreSQL/Oracle only; ClickHouse doesn't support COMMENT ON TABLE)
+    if matches!(target_db, DatabaseType::Postgres | DatabaseType::Oracle) {
+        if let Some(comment) = table_comment {
+            let trimmed = comment.trim();
+            if !trimmed.is_empty() {
+                let escaped = trimmed.replace('\'', "''");
+                statements.push(format!("COMMENT ON TABLE {full_table} IS '{escaped}'"));
+            }
+        }
+    }
+
+    for c in columns {
+        if let Some(ref comment) = c.comment {
+            let trimmed = comment.trim();
+            if trimmed.is_empty() {
+                continue;
+            }
+            let escaped = trimmed.replace('\'', "''");
+            let qcol = quote_identifier(&c.name, target_db);
+
+            match target_db {
+                DatabaseType::Postgres | DatabaseType::Oracle => {
+                    statements.push(format!("COMMENT ON COLUMN {full_table}.{qcol} IS '{escaped}'"));
+                }
+                DatabaseType::ClickHouse => {
+                    statements.push(format!("ALTER TABLE {full_table} COMMENT COLUMN {qcol} '{escaped}'"));
+                }
+                _ => {}
+            }
+        }
+    }
+
+    statements
+}
+
+pub fn generate_insert(
+    columns: &[String],
+    rows: &[Vec<serde_json::Value>],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+) -> String {
+    generate_insert_typed(columns, &vec![None; columns.len()], rows, table, schema, db_type)
+}
+
+pub fn generate_insert_typed(
+    columns: &[String],
+    column_types: &[Option<String>],
+    rows: &[Vec<serde_json::Value>],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+) -> String {
+    if rows.is_empty() {
+        return String::new();
+    }
+
+    let full_table = qualified_table(table, schema, db_type);
+    let col_list = columns.iter().map(|c| quote_identifier(c, db_type)).collect::<Vec<_>>().join(", ");
+
+    let value_rows = value_rows_sql(rows, column_types, db_type);
+    if matches!(db_type, DatabaseType::Oracle) && rows.len() > 1 {
+        // Oracle 11g does not accept comma-separated multi-row VALUES lists.
+        let into_rows = value_rows
+            .iter()
+            .map(|values| format!("INTO {full_table} ({col_list}) VALUES {values}"))
+            .collect::<Vec<_>>()
+            .join("\n");
+        return format!("INSERT ALL\n{into_rows}\nSELECT 1 FROM dual");
+    }
+
+    format!("INSERT INTO {full_table} ({col_list}) VALUES\n{}", value_rows.join(",\n"))
+}
+
+fn value_rows_sql(
+    rows: &[Vec<serde_json::Value>],
+    column_types: &[Option<String>],
+    db_type: &DatabaseType,
+) -> Vec<String> {
+    let mut out = Vec::with_capacity(rows.len());
+    for row in rows {
+        let mut vals = Vec::with_capacity(row.len());
+        for (index, v) in row.iter().enumerate() {
+            vals.push(escape_value_typed(v, db_type, column_types.get(index).and_then(|value| value.as_deref())));
+        }
+        out.push(format!("({})", vals.join(", ")));
+    }
+    out
+}
+
+pub fn generate_upsert(
+    columns: &[String],
+    rows: &[Vec<serde_json::Value>],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    pk_columns: &[String],
+) -> String {
+    generate_upsert_typed(columns, &vec![None; columns.len()], rows, table, schema, db_type, pk_columns)
+}
+
+pub fn generate_upsert_typed(
+    columns: &[String],
+    column_types: &[Option<String>],
+    rows: &[Vec<serde_json::Value>],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    pk_columns: &[String],
+) -> String {
+    if rows.is_empty() || pk_columns.is_empty() {
+        return String::new();
+    }
+
+    let full_table = qualified_table(table, schema, db_type);
+    let col_list = columns.iter().map(|c| quote_identifier(c, db_type)).collect::<Vec<_>>().join(", ");
+
+    let value_rows = value_rows_sql(rows, column_types, db_type);
+
+    let mut non_pk_columns = Vec::with_capacity(columns.len().saturating_sub(pk_columns.len()));
+    for c in columns {
+        if !pk_columns.contains(c) {
+            non_pk_columns.push(c);
+        }
+    }
+
+    match db_type {
+        db_type
+            if is_postgres_transfer_dialect(db_type)
+                || matches!(db_type, DatabaseType::Sqlite | DatabaseType::CloudflareD1 | DatabaseType::DuckDb) =>
+        {
+            let pk_list = pk_columns.iter().map(|c| quote_identifier(c, db_type)).collect::<Vec<_>>().join(", ");
+            let mut sql = format!("INSERT INTO {full_table} ({col_list}) VALUES\n{}", value_rows.join(",\n"));
+            if non_pk_columns.is_empty() {
+                sql.push_str(&format!("\nON CONFLICT ({pk_list}) DO NOTHING"));
+            } else {
+                let update_set = non_pk_columns
+                    .iter()
+                    .map(|c| {
+                        let qc = quote_identifier(c, db_type);
+                        format!("{qc} = EXCLUDED.{qc}")
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                sql.push_str(&format!("\nON CONFLICT ({pk_list}) DO UPDATE SET {update_set}"));
+            }
+            sql
+        }
+        DatabaseType::Mysql | DatabaseType::Doris | DatabaseType::StarRocks => {
+            let mut sql = format!("INSERT INTO {full_table} ({col_list}) VALUES\n{}", value_rows.join(",\n"));
+            if non_pk_columns.is_empty() {
+                sql.push_str("\nON DUPLICATE KEY UPDATE ");
+                let first_pk = quote_identifier(&pk_columns[0], db_type);
+                sql.push_str(&format!("{first_pk} = {first_pk}"));
+            } else {
+                let update_set = non_pk_columns
+                    .iter()
+                    .map(|c| {
+                        let qc = quote_identifier(c, db_type);
+                        format!("{qc} = VALUES({qc})")
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                sql.push_str(&format!("\nON DUPLICATE KEY UPDATE {update_set}"));
+            }
+            sql
+        }
+        DatabaseType::SqlServer => {
+            let src_col_list = columns.iter().map(|c| quote_identifier(c, db_type)).collect::<Vec<_>>().join(", ");
+            let on_clause = pk_columns
+                .iter()
+                .map(|c| {
+                    let qc = quote_identifier(c, db_type);
+                    format!("target.{qc} = src.{qc}")
+                })
+                .collect::<Vec<_>>()
+                .join(" AND ");
+
+            let mut sql = format!(
+                "MERGE INTO {full_table} AS target USING (VALUES\n{}\n) AS src ({src_col_list}) ON {on_clause}",
+                value_rows.join(",\n")
+            );
+
+            if !non_pk_columns.is_empty() {
+                let update_set = non_pk_columns
+                    .iter()
+                    .map(|c| {
+                        let qc = quote_identifier(c, db_type);
+                        format!("target.{qc} = src.{qc}")
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                sql.push_str(&format!("\nWHEN MATCHED THEN UPDATE SET {update_set}"));
+            }
+
+            let insert_cols = columns.iter().map(|c| quote_identifier(c, db_type)).collect::<Vec<_>>().join(", ");
+            let insert_vals =
+                columns.iter().map(|c| format!("src.{}", quote_identifier(c, db_type))).collect::<Vec<_>>().join(", ");
+            sql.push_str(&format!("\nWHEN NOT MATCHED THEN INSERT ({insert_cols}) VALUES ({insert_vals});"));
+            sql
+        }
+        DatabaseType::Oracle => {
+            let mut using_rows = Vec::with_capacity(rows.len());
+            for row in rows {
+                let mut vals = Vec::with_capacity(row.len().min(columns.len()));
+                for (index, (v, c)) in row.iter().zip(columns.iter()).enumerate() {
+                    vals.push(format!(
+                        "{} AS {}",
+                        escape_value_typed(v, db_type, column_types.get(index).and_then(|value| value.as_deref())),
+                        quote_identifier(c, db_type)
+                    ));
+                }
+                using_rows.push(format!("SELECT {} FROM dual", vals.join(", ")));
+            }
+
+            let on_clause = pk_columns
+                .iter()
+                .map(|c| {
+                    let qc = quote_identifier(c, db_type);
+                    format!("t.{qc} = s.{qc}")
+                })
+                .collect::<Vec<_>>()
+                .join(" AND ");
+
+            let mut sql =
+                format!("MERGE INTO {full_table} t USING ({}) s ON ({on_clause})", using_rows.join(" UNION ALL "));
+
+            if !non_pk_columns.is_empty() {
+                let update_set = non_pk_columns
+                    .iter()
+                    .map(|c| {
+                        let qc = quote_identifier(c, db_type);
+                        format!("t.{qc} = s.{qc}")
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                sql.push_str(&format!("\nWHEN MATCHED THEN UPDATE SET {update_set}"));
+            }
+
+            let insert_cols = columns.iter().map(|c| quote_identifier(c, db_type)).collect::<Vec<_>>().join(", ");
+            let insert_vals =
+                columns.iter().map(|c| format!("s.{}", quote_identifier(c, db_type))).collect::<Vec<_>>().join(", ");
+            sql.push_str(&format!("\nWHEN NOT MATCHED THEN INSERT ({insert_cols}) VALUES ({insert_vals})"));
+            sql
+        }
+        _ => generate_insert_typed(columns, column_types, rows, table, schema, db_type),
+    }
+}
+
+fn max_transfer_write_rows(db_type: &DatabaseType, mode: &TransferMode) -> usize {
+    match (db_type, mode) {
+        (DatabaseType::SqlServer, TransferMode::Append | TransferMode::Overwrite) => MAX_SQLSERVER_INSERT_ROWS,
+        (DatabaseType::Hive, _) => 500,
+        (DatabaseType::Oracle, TransferMode::Append | TransferMode::Overwrite) => MAX_ORACLE_INSERT_ALL_ROWS,
+        (DatabaseType::Oracle, TransferMode::Upsert) => MAX_ORACLE_MERGE_ROWS,
+        _ => usize::MAX,
+    }
+}
+
+fn can_reuse_source_table_ddl(
+    source_db_type: &DatabaseType,
+    target_db_type: &DatabaseType,
+    preserves_target_table_name: bool,
+) -> bool {
+    preserves_target_table_name
+        && !matches!(target_db_type, DatabaseType::ClickHouse)
+        && (source_db_type == target_db_type
+            || (is_mysql_family_target(source_db_type) && is_mysql_family_target(target_db_type))
+            || (is_postgres_family_target(source_db_type) && is_postgres_family_target(target_db_type)))
+}
+
+fn rewrite_transfer_source_table_ddl(
+    sql: &str,
+    source_schema: &str,
+    target_schema: &str,
+    source_db_type: &DatabaseType,
+    target_db_type: &DatabaseType,
+) -> String {
+    if is_postgres_family_target(source_db_type) && is_postgres_family_target(target_db_type) {
+        rewrite_postgres_schema_qualified_references(sql, source_schema, target_schema)
+    } else {
+        sql.to_string()
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn generate_transfer_write_sql(
+    mode: &TransferMode,
+    columns: &[String],
+    column_types: &[Option<String>],
+    rows: &[Vec<serde_json::Value>],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    pk_columns: &[String],
+) -> String {
+    match mode {
+        TransferMode::Upsert => generate_upsert_typed(columns, column_types, rows, table, schema, db_type, pk_columns),
+        _ => generate_insert_typed(columns, column_types, rows, table, schema, db_type),
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn generate_transfer_write_sql_batches(
+    mode: &TransferMode,
+    columns: &[String],
+    column_types: &[Option<String>],
+    rows: &[Vec<serde_json::Value>],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    pk_columns: &[String],
+) -> Vec<String> {
+    if rows.is_empty() {
+        return Vec::new();
+    }
+
+    let max_rows = max_transfer_write_rows(db_type, mode);
+    let max_sql_bytes = match db_type {
+        DatabaseType::CloudflareD1 => crate::db::cloudflare_d1::MAX_SQL_STATEMENT_BYTES,
+        _ => MAX_TRANSFER_WRITE_SQL_BYTES,
+    };
+    let mut statements = Vec::new();
+    let mut start = 0;
+
+    while start < rows.len() {
+        let mut end = start + 1;
+        let mut accepted = generate_transfer_write_sql(
+            mode,
+            columns,
+            column_types,
+            &rows[start..end],
+            table,
+            schema,
+            db_type,
+            pk_columns,
+        );
+
+        while end < rows.len() && end - start < max_rows {
+            let candidate = generate_transfer_write_sql(
+                mode,
+                columns,
+                column_types,
+                &rows[start..=end],
+                table,
+                schema,
+                db_type,
+                pk_columns,
+            );
+            if candidate.len() > max_sql_bytes && !accepted.is_empty() {
+                break;
+            }
+            accepted = candidate;
+            end += 1;
+        }
+
+        if !accepted.is_empty() {
+            statements.push(accepted);
+        }
+        start = end;
+    }
+
+    statements
+}
+
+pub fn pagination_sql(
+    columns: &[String],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    offset: u64,
+    limit: usize,
+) -> String {
+    let full_table = qualified_table(table, schema, db_type);
+    let col_list = columns.iter().map(|c| quote_identifier(c, db_type)).collect::<Vec<_>>().join(", ");
+
+    match db_type {
+        DatabaseType::Oracle => {
+            let base_sql = format!("SELECT {col_list} FROM {full_table}");
+            oracle_rownum_page_sql(&col_list, base_sql, offset, limit)
+        }
+        DatabaseType::SqlServer | DatabaseType::Dameng => {
+            format!(
+                "SELECT {col_list} FROM {full_table} ORDER BY (SELECT NULL) OFFSET {offset} ROWS FETCH NEXT {limit} ROWS ONLY"
+            )
+        }
+        DatabaseType::Questdb => {
+            let upper_bound = offset + limit as u64;
+            format!("SELECT {col_list} FROM {full_table} LIMIT {offset}, {upper_bound}")
+        }
+        _ => {
+            format!("SELECT {col_list} FROM {full_table} LIMIT {limit} OFFSET {offset}")
+        }
+    }
+}
+
+pub fn pagination_sql_with_order(
+    columns: &[String],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    offset: u64,
+    limit: usize,
+    order_by_columns: &[String],
+) -> String {
+    let full_table = qualified_table(table, schema, db_type);
+    let col_list = columns.iter().map(|c| quote_identifier(c, db_type)).collect::<Vec<_>>().join(", ");
+    let order_expression = postgres_order_by_expression(order_by_columns, db_type);
+
+    match db_type {
+        DatabaseType::Oracle => {
+            let order_by = order_expression.map(|value| format!(" ORDER BY {value}")).unwrap_or_default();
+            let base_sql = format!("SELECT {col_list} FROM {full_table}{order_by}");
+            oracle_rownum_page_sql(&col_list, base_sql, offset, limit)
+        }
+        DatabaseType::SqlServer | DatabaseType::Dameng => {
+            let order_by = order_expression.unwrap_or_else(|| "(SELECT NULL)".to_string());
+            format!(
+                "SELECT {col_list} FROM {full_table} ORDER BY {order_by} OFFSET {offset} ROWS FETCH NEXT {limit} ROWS ONLY"
+            )
+        }
+        DatabaseType::Questdb => {
+            let upper_bound = offset + limit as u64;
+            let order_by = order_expression.map(|value| format!(" ORDER BY {value}")).unwrap_or_default();
+            format!("SELECT {col_list} FROM {full_table}{order_by} LIMIT {offset}, {upper_bound}")
+        }
+        _ => {
+            let order_by = order_expression.map(|value| format!(" ORDER BY {value}")).unwrap_or_default();
+            format!("SELECT {col_list} FROM {full_table}{order_by} LIMIT {limit} OFFSET {offset}")
+        }
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn pagination_sql_with_filter_order(
+    columns: &[String],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    offset: u64,
+    limit: usize,
+    where_input: Option<&str>,
+    order_by: Option<&str>,
+    default_order_columns: &[String],
+) -> String {
+    let full_table = qualified_table(table, schema, db_type);
+    let col_list = columns.iter().map(|c| quote_identifier(c, db_type)).collect::<Vec<_>>().join(", ");
+    let predicate = crate::sql_dialect::normalize_where_input(where_input);
+    let where_clause = if predicate.is_empty() { String::new() } else { format!(" WHERE ({predicate})") };
+    let order_expression = order_by
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_string)
+        .or_else(|| postgres_order_by_expression(default_order_columns, db_type));
+
+    match db_type {
+        DatabaseType::Oracle => {
+            let order_by = order_expression.map(|value| format!(" ORDER BY {value}")).unwrap_or_default();
+            let base_sql = format!("SELECT {col_list} FROM {full_table}{where_clause}{order_by}");
+            oracle_rownum_page_sql(&col_list, base_sql, offset, limit)
+        }
+        DatabaseType::SqlServer | DatabaseType::Dameng => {
+            let order_by = order_expression.unwrap_or_else(|| "(SELECT NULL)".to_string());
+            format!(
+                "SELECT {col_list} FROM {full_table}{where_clause} ORDER BY {order_by} OFFSET {offset} ROWS FETCH NEXT {limit} ROWS ONLY"
+            )
+        }
+        DatabaseType::Questdb => {
+            let upper_bound = offset + limit as u64;
+            let order_by = order_expression.map(|value| format!(" ORDER BY {value}")).unwrap_or_default();
+            format!("SELECT {col_list} FROM {full_table}{where_clause}{order_by} LIMIT {offset}, {upper_bound}")
+        }
+        _ => {
+            let order_by = order_expression.map(|value| format!(" ORDER BY {value}")).unwrap_or_default();
+            format!("SELECT {col_list} FROM {full_table}{where_clause}{order_by} LIMIT {limit} OFFSET {offset}")
+        }
+    }
+}
+
+pub fn count_sql(table: &str, schema: &str, db_type: &DatabaseType) -> String {
+    count_sql_with_where(table, schema, db_type, None)
+}
+
+pub fn count_sql_with_where(table: &str, schema: &str, db_type: &DatabaseType, where_input: Option<&str>) -> String {
+    let full_table = qualified_table(table, schema, db_type);
+    let predicate = crate::sql_dialect::normalize_where_input(where_input);
+    let where_clause = if predicate.is_empty() { String::new() } else { format!(" WHERE ({predicate})") };
+    format!("SELECT COUNT(*) FROM {full_table}{where_clause}")
+}
+
+pub fn keyset_pagination_sql(
+    columns: &[String],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    primary_keys: &[String],
+    last_pk_values: &[serde_json::Value],
+    limit: usize,
+) -> String {
+    let full_table = qualified_table(table, schema, db_type);
+    let col_list = columns.iter().map(|c| quote_identifier(c, db_type)).collect::<Vec<_>>().join(", ");
+    let order =
+        primary_keys.iter().map(|pk| format!("{} ASC", quote_identifier(pk, db_type))).collect::<Vec<_>>().join(", ");
+
+    let where_clause = keyset_where_clause(primary_keys, last_pk_values, db_type);
+
+    match db_type {
+        DatabaseType::Oracle => {
+            let base_sql = format!("SELECT {col_list} FROM {full_table}{where_clause} ORDER BY {order}");
+            oracle_rownum_page_sql(&col_list, base_sql, 0, limit)
+        }
+        DatabaseType::SqlServer | DatabaseType::Dameng => {
+            format!(
+                "SELECT {col_list} FROM {full_table}{where_clause} ORDER BY {order} OFFSET 0 ROWS FETCH NEXT {limit} ROWS ONLY"
+            )
+        }
+        _ => {
+            format!("SELECT {col_list} FROM {full_table}{where_clause} ORDER BY {order} LIMIT {limit}")
+        }
+    }
+}
+
+fn keyset_where_clause(
+    primary_keys: &[String],
+    last_pk_values: &[serde_json::Value],
+    db_type: &DatabaseType,
+) -> String {
+    if primary_keys.is_empty() || last_pk_values.is_empty() {
+        return String::new();
+    }
+
+    let quoted_keys = primary_keys.iter().map(|pk| quote_identifier(pk, db_type)).collect::<Vec<_>>();
+    let literals = last_pk_values.iter().map(|v| value_to_sql_literal(v, db_type)).collect::<Vec<_>>();
+    let comparison_count = quoted_keys.len().min(literals.len());
+    if comparison_count == 0 {
+        return String::new();
+    }
+
+    let mut clauses = Vec::with_capacity(comparison_count);
+    for index in 0..comparison_count {
+        let mut parts = Vec::with_capacity(index + 1);
+        for prefix_index in 0..index {
+            parts.push(format!("{} = {}", quoted_keys[prefix_index], literals[prefix_index]));
+        }
+        parts.push(format!("{} > {}", quoted_keys[index], literals[index]));
+        if parts.len() == 1 {
+            clauses.push(parts.remove(0));
+        } else {
+            clauses.push(format!("({})", parts.join(" AND ")));
+        }
+    }
+
+    if clauses.len() == 1 {
+        format!(" WHERE {}", clauses[0])
+    } else {
+        format!(" WHERE ({})", clauses.join(" OR "))
+    }
+}
+
+fn value_to_sql_literal(value: &serde_json::Value, _db_type: &DatabaseType) -> String {
+    match value {
+        serde_json::Value::Null => "NULL".to_string(),
+        serde_json::Value::Bool(b) => {
+            if *b {
+                "TRUE".to_string()
+            } else {
+                "FALSE".to_string()
+            }
+        }
+        serde_json::Value::Number(n) => n.to_string(),
+        serde_json::Value::String(s) => quote_string_literal(s),
+        _ => quote_string_literal(&value.to_string()),
+    }
+}
+
+fn is_mongodb_transfer_type(db_type: &DatabaseType) -> bool {
+    matches!(db_type, DatabaseType::MongoDb)
+}
+
+fn mongo_transfer_document_fields(documents: &[serde_json::Value]) -> Vec<String> {
+    let mut fields = Vec::new();
+    let mut seen = HashSet::new();
+    for document in documents {
+        let Some(object) = document.as_object() else {
+            continue;
+        };
+        for key in object.keys() {
+            if seen.insert(key.clone()) {
+                fields.push(key.clone());
+            }
+        }
+    }
+    fields
+}
+
+fn mongo_documents_to_rows(documents: &[serde_json::Value], columns: &[String]) -> Vec<Vec<serde_json::Value>> {
+    documents
+        .iter()
+        .map(|document| {
+            let object = document.as_object();
+            columns
+                .iter()
+                .map(|column| object.and_then(|values| values.get(column)).cloned().unwrap_or(serde_json::Value::Null))
+                .collect()
+        })
+        .collect()
+}
+
+fn sql_rows_to_mongo_documents(columns: &[String], rows: &[Vec<serde_json::Value>]) -> Vec<serde_json::Value> {
+    rows.iter()
+        .map(|row| {
+            let mut document = serde_json::Map::new();
+            for (index, column) in columns.iter().enumerate() {
+                document.insert(column.clone(), row.get(index).cloned().unwrap_or(serde_json::Value::Null));
+            }
+            serde_json::Value::Object(document)
+        })
+        .collect()
+}
+
+async fn find_mongo_documents_extended_json(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    offset: u64,
+    batch_size: usize,
+) -> Result<MongoDocumentResult, String> {
+    crate::mongo_ops::mongo_find_documents_extended_json_core(
+        state,
+        connection_id,
+        database,
+        collection,
+        offset,
+        batch_size as i64,
+        None,
+        None,
+        Some(r#"{"_id":1}"#),
+    )
+    .await
+}
+
+async fn find_mongo_documents_for_rows(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    offset: u64,
+    batch_size: usize,
+) -> Result<MongoDocumentResult, String> {
+    crate::mongo_ops::mongo_find_documents_core(
+        state,
+        connection_id,
+        database,
+        collection,
+        offset,
+        batch_size as i64,
+        None,
+        None,
+        Some(r#"{"_id":1}"#),
+    )
+    .await
+}
+
+async fn insert_mongo_documents_for_transfer(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    documents: &[serde_json::Value],
+) -> Result<u64, String> {
+    if documents.is_empty() {
+        return Ok(0);
+    }
+    let docs_json = serde_json::to_string(documents).map_err(|e| format!("Failed to encode MongoDB documents: {e}"))?;
+    match crate::mongo_ops::mongo_insert_documents_core(state, connection_id, database, collection, &docs_json).await {
+        Ok(count) => Ok(count),
+        Err(error) if error.to_ascii_lowercase().contains("legacy agent") => {
+            let mut inserted = 0;
+            for document in documents {
+                let doc_json =
+                    serde_json::to_string(document).map_err(|e| format!("Failed to encode MongoDB document: {e}"))?;
+                crate::mongo_ops::mongo_insert_document_core(state, connection_id, database, collection, &doc_json)
+                    .await?;
+                inserted += 1;
+            }
+            Ok(inserted)
+        }
+        Err(error) => Err(error),
+    }
+}
+
+async fn insert_mongo_documents_extended_json_for_transfer(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+    documents: &[serde_json::Value],
+) -> Result<u64, String> {
+    if documents.is_empty() {
+        return Ok(0);
+    }
+    let docs_json = serde_json::to_string(documents).map_err(|e| format!("Failed to encode MongoDB documents: {e}"))?;
+    match crate::mongo_ops::mongo_insert_documents_extended_json_core(
+        state,
+        connection_id,
+        database,
+        collection,
+        &docs_json,
+    )
+    .await
+    {
+        Ok(count) => Ok(count),
+        Err(error) if error.to_ascii_lowercase().contains("legacy agent") => {
+            insert_mongo_documents_for_transfer(state, connection_id, database, collection, documents).await
+        }
+        Err(error) => Err(error),
+    }
+}
+
+async fn overwrite_mongo_collection_for_transfer(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    collection: &str,
+) -> Result<(), String> {
+    crate::mongo_ops::mongo_delete_documents_core(state, connection_id, database, collection, "{}", true)
+        .await
+        .map(|_| ())
+}
+
+fn mongo_value_column_type(value: Option<&serde_json::Value>) -> String {
+    match value {
+        Some(serde_json::Value::Bool(_)) => "boolean".to_string(),
+        Some(serde_json::Value::Number(number)) if number.is_i64() || number.is_u64() => "bigint".to_string(),
+        Some(serde_json::Value::Number(_)) => "double".to_string(),
+        Some(serde_json::Value::Array(_) | serde_json::Value::Object(_)) => "json".to_string(),
+        _ => "text".to_string(),
+    }
+}
+
+fn mongo_columns_from_documents(documents: &[serde_json::Value]) -> Vec<db::ColumnInfo> {
+    mongo_transfer_document_fields(documents)
+        .into_iter()
+        .map(|name| {
+            let sample =
+                documents.iter().filter_map(|document| document.as_object()?.get(&name)).find(|value| !value.is_null());
+            db::ColumnInfo {
+                name,
+                data_type: mongo_value_column_type(sample),
+                is_nullable: true,
+                column_default: None,
+                is_primary_key: false,
+                extra: None,
+                comment: None,
+                numeric_precision: None,
+                numeric_scale: None,
+                character_maximum_length: None,
+                enum_values: None,
+                ..Default::default()
+            }
+        })
+        .collect()
+}
+
+pub async fn execute_on_pool(state: &AppState, pool_key: &str, sql: &str) -> Result<db::QueryResult, String> {
+    execute_on_pool_with_options(state, pool_key, sql, None, TransferExecutionSafety::WriteNoReplay).await
+}
+
+pub async fn execute_read_on_pool(state: &AppState, pool_key: &str, sql: &str) -> Result<db::QueryResult, String> {
+    execute_read_on_pool_with_max_rows(state, pool_key, sql, None).await
+}
+
+pub async fn execute_read_on_pool_with_max_rows(
+    state: &AppState,
+    pool_key: &str,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<db::QueryResult, String> {
+    execute_on_pool_with_options(state, pool_key, sql, max_rows, TransferExecutionSafety::ReadOnlyRetryable).await
+}
+
+async fn execute_transfer_ddl_on_pool(
+    state: &AppState,
+    pool_key: &str,
+    sql: &str,
+    db_type: &DatabaseType,
+) -> Result<(), String> {
+    for statement in transfer_ddl_statements(sql, db_type) {
+        execute_on_pool(state, pool_key, &statement).await?;
+    }
+    Ok(())
+}
+
+fn transfer_table_already_exists_error(error: &str) -> bool {
+    let lower = error.to_ascii_lowercase();
+    lower.contains("already exists")
+        || lower.contains("there is already")
+        || lower.contains("duplicate_table")
+        || lower.contains("42p07")
+        || error.contains("已经存在")
+        || error.contains("已存在")
+}
+
+fn transfer_create_table_created(result: Result<(), String>, error_prefix: &str) -> Result<bool, String> {
+    match result {
+        Ok(_) => Ok(true),
+        Err(e) if transfer_table_already_exists_error(&e) => Ok(false),
+        Err(e) => Err(format!("{error_prefix}: {e}")),
+    }
+}
+
+fn transfer_ddl_statements(sql: &str, db_type: &DatabaseType) -> Vec<String> {
+    if is_postgres_transfer_dialect(db_type) {
+        let statements = split_sql_statements(sql);
+        if statements.is_empty() {
+            vec![sql.trim().to_string()]
+        } else {
+            statements
+                .into_iter()
+                .map(|statement| sanitize_postgres_transfer_ddl_statement(&statement))
+                .filter(|statement| !is_postgres_post_table_index_statement(statement))
+                .collect()
+        }
+    } else {
+        vec![sql.to_string()]
+    }
+}
+
+fn sanitize_postgres_transfer_ddl_statement(statement: &str) -> String {
+    if !statement.trim_start().to_ascii_uppercase().starts_with("CREATE TABLE ") {
+        return statement.to_string();
+    }
+
+    let mut lines: Vec<String> = Vec::new();
+    for line in statement.lines() {
+        if line.to_ascii_uppercase().contains(" FOREIGN KEY ") {
+            if let Some(previous) = lines.last_mut() {
+                let trimmed_len = previous.trim_end_matches(char::is_whitespace).len();
+                if previous[..trimmed_len].ends_with(',') {
+                    previous.truncate(trimmed_len - 1);
+                }
+            }
+            continue;
+        }
+        lines.push(line.to_string());
+    }
+    lines.join("\n")
+}
+
+fn is_postgres_post_table_index_statement(statement: &str) -> bool {
+    let normalized = statement.trim_start().to_ascii_uppercase();
+    normalized.starts_with("CREATE INDEX ")
+        || normalized.starts_with("CREATE UNIQUE INDEX ")
+        || normalized.starts_with("COMMENT ON INDEX ")
+}
+
+pub async fn execute_on_pool_with_max_rows(
+    state: &AppState,
+    pool_key: &str,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<db::QueryResult, String> {
+    execute_on_pool_with_options(state, pool_key, sql, max_rows, TransferExecutionSafety::WriteNoReplay).await
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum TransferExecutionSafety {
+    ReadOnlyRetryable,
+    WriteNoReplay,
+}
+
+fn transfer_pool_error_action(
+    safety: TransferExecutionSafety,
+    db_type: Option<DatabaseType>,
+    err: &str,
+) -> PoolErrorAction {
+    match (safety, pool_error_action(db_type, err)) {
+        (TransferExecutionSafety::WriteNoReplay, PoolErrorAction::ReconnectAndRetry) => PoolErrorAction::Discard,
+        (_, action) => action,
+    }
+}
+
+async fn transfer_pool_context(
+    state: &AppState,
+    pool_key: &str,
+) -> (Option<String>, Option<String>, Option<DatabaseType>) {
+    let configs = state.configs.read().await;
+    let config = config_for_pool_key(pool_key, &configs);
+    (
+        config.map(|config| config.id.clone()),
+        database_from_pool_key(pool_key).map(str::to_string),
+        config.map(|config| config.db_type),
+    )
+}
+
+fn client_session_id_from_pool_key(pool_key: &str) -> Option<&str> {
+    pool_key.split_once(":session:").map(|(_, session)| session).filter(|session| !session.is_empty())
+}
+
+async fn execute_on_pool_with_options(
+    state: &AppState,
+    pool_key: &str,
+    sql: &str,
+    max_rows: Option<usize>,
+    safety: TransferExecutionSafety,
+) -> Result<db::QueryResult, String> {
+    let (connection_id, database, db_type) = transfer_pool_context(state, pool_key).await;
+    let client_session_id = client_session_id_from_pool_key(pool_key).map(str::to_string);
+    let mut current_pool_key = pool_key.to_string();
+
+    for attempt in 0..2 {
+        let result = execute_on_pool_once(state, &current_pool_key, sql, max_rows).await;
+        let Some(error) = result.as_ref().err() else {
+            return result;
+        };
+
+        match transfer_pool_error_action(safety, db_type, error) {
+            PoolErrorAction::Keep => return result,
+            PoolErrorAction::Discard => {
+                state.remove_pool_by_key(&current_pool_key).await;
+                return result;
+            }
+            PoolErrorAction::ReconnectAndRetry if attempt == 0 => {
+                let Some(connection_id) = connection_id.as_deref() else {
+                    state.remove_pool_by_key(&current_pool_key).await;
+                    return result;
+                };
+                current_pool_key = state
+                    .reconnect_pool_for_session(connection_id, database.as_deref(), client_session_id.as_deref())
+                    .await?;
+            }
+            PoolErrorAction::ReconnectAndRetry => {
+                state.remove_pool_by_key(&current_pool_key).await;
+                return result;
+            }
+        }
+    }
+
+    unreachable!("transfer pool execution retry loop runs at most twice")
+}
+
+async fn execute_on_pool_once(
+    state: &AppState,
+    pool_key: &str,
+    sql: &str,
+    max_rows: Option<usize>,
+) -> Result<db::QueryResult, String> {
+    // Read-only check: block transfer operations in readonly mode
+    crate::query::check_read_only_for_connection(state, pool_key, sql).await?;
+    let connections = state.connections.read().await;
+    let pool = connections.get(pool_key).ok_or("Connection not found")?;
+
+    match pool {
+        PoolKind::Mysql(p, mode) => {
+            let p = p.clone();
+            let bare = *mode == crate::connection::MysqlMode::Bare;
+            drop(connections);
+            db::mysql::execute_query_with_max_rows(&p, sql, bare, max_rows, Default::default()).await
+        }
+        PoolKind::Postgres(p) => {
+            let p = p.clone();
+            drop(connections);
+            db::postgres::execute_query_with_max_rows(&p, sql, max_rows).await
+        }
+        PoolKind::Sqlite(p) => {
+            let p = p.clone();
+            drop(connections);
+            db::sqlite::execute_query_with_max_rows(&p, sql, max_rows).await
+        }
+        PoolKind::ClickHouse(client) => {
+            let client = client.clone();
+            let database = database_from_pool_key(pool_key).unwrap_or("default").to_string();
+            drop(connections);
+            db::clickhouse_driver::execute_query_with_max_rows(&client, &database, sql, max_rows).await
+        }
+        PoolKind::SqlServer(client) => {
+            let client = client.clone();
+            drop(connections);
+            let mut client = client.lock().await;
+            let result = db::sqlserver::execute_query_with_max_rows(&mut client, sql, max_rows).await;
+            drop(client);
+            result
+        }
+        PoolKind::Agent(client) => {
+            let client = client.clone();
+            let database = database_from_pool_key(pool_key).map(str::to_string);
+            let sql = sql.to_string();
+            drop(connections);
+            let mut client = client.lock().await;
+            let params = agent_execute_query_params(
+                &sql,
+                database.as_deref(),
+                None,
+                QueryExecutionOptions { max_rows, fetch_size: max_rows, ..QueryExecutionOptions::default() },
+            );
+            client.execute_query(params).await
+        }
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::DuckDb(con) => {
+            let con = con.clone();
+            let sql = sql.to_string();
+            drop(connections);
+            tokio::task::spawn_blocking(move || {
+                let con = con.lock().map_err(|e| e.to_string())?;
+                if max_rows.is_some()
+                    && starts_with_executable_sql_keyword(&sql, &["SELECT", "SHOW", "DESCRIBE", "WITH", "PRAGMA"])
+                {
+                    return crate::query::duckdb_execute_with_max_rows(&con, &sql, max_rows);
+                }
+                let start = std::time::Instant::now();
+                if starts_with_executable_sql_keyword(&sql, &["SELECT", "SHOW", "DESCRIBE", "WITH", "PRAGMA"]) {
+                    let mut stmt = con.prepare(&sql).map_err(|e| e.to_string())?;
+                    let mut rows = stmt.query([]).map_err(|e| e.to_string())?;
+                    let stmt_ref = rows.as_ref().ok_or("DuckDB statement unavailable")?;
+                    let col_count = stmt_ref.column_count();
+                    let columns: Vec<String> = (0..col_count)
+                        .map(|i| stmt_ref.column_name(i).map(|s| s.to_string()).unwrap_or_else(|_| "?".to_string()))
+                        .collect();
+                    let mut result_rows = Vec::new();
+                    while let Some(row) = rows.next().map_err(|e| e.to_string())? {
+                        let vals: Vec<serde_json::Value> = (0..col_count)
+                            .map(|i| {
+                                row.get::<_, String>(i)
+                                    .map(serde_json::Value::String)
+                                    .or_else(|_| row.get::<_, i64>(i).map(|v| serde_json::Value::Number(v.into())))
+                                    .or_else(|_| {
+                                        row.get::<_, f64>(i).map(|v| {
+                                            serde_json::Number::from_f64(v)
+                                                .map(serde_json::Value::Number)
+                                                .unwrap_or(serde_json::Value::Null)
+                                        })
+                                    })
+                                    .or_else(|_| row.get::<_, bool>(i).map(serde_json::Value::Bool))
+                                    .unwrap_or(serde_json::Value::Null)
+                            })
+                            .collect();
+                        result_rows.push(vals);
+                    }
+                    Ok(db::QueryResult {
+                        columns,
+                        column_types: Vec::new(),
+                        column_sortables: vec![],
+                        rows: result_rows,
+                        affected_rows: 0,
+                        execution_time_ms: start.elapsed().as_millis(),
+                        truncated: false,
+                        session_id: None,
+                        has_more: false,
+                    })
+                } else {
+                    let affected = con.execute(&sql, []).map_err(|e| e.to_string())?;
+                    Ok(db::QueryResult {
+                        columns: vec![],
+                        column_types: Vec::new(),
+                        column_sortables: vec![],
+                        rows: vec![],
+                        affected_rows: affected as u64,
+                        execution_time_ms: start.elapsed().as_millis(),
+                        truncated: false,
+                        session_id: None,
+                        has_more: false,
+                    })
+                }
+            })
+            .await
+            .map_err(|e| e.to_string())?
+        }
+        #[cfg(feature = "duckdb-bundled")]
+        PoolKind::ExternalTabular(ext_pool) => {
+            let con = ext_pool.cache.clone();
+            let sql = sql.to_string();
+            drop(connections);
+            tokio::task::spawn_blocking(move || {
+                let con = con.lock().map_err(|e| e.to_string())?;
+                crate::query::duckdb_execute_with_max_rows(&con, &sql, max_rows)
+            })
+            .await
+            .map_err(|e| e.to_string())?
+        }
+        _ => Err("Unsupported database type for transfer".to_string()),
+    }
+}
+
+fn database_from_pool_key(pool_key: &str) -> Option<&str> {
+    pool_key
+        .split_once(":session:")
+        .map(|(base, _)| base)
+        .unwrap_or(pool_key)
+        .split_once(':')
+        .map(|(_, database)| database)
+        .filter(|database| !database.is_empty())
+}
+
+pub async fn get_db_type(state: &AppState, connection_id: &str) -> Result<DatabaseType, String> {
+    let configs = state.configs.read().await;
+    configs.get(connection_id).map(|c| c.db_type).ok_or_else(|| format!("Connection config not found: {connection_id}"))
+}
+
+pub async fn get_columns_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    _connection_id: &str,
+    database: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::ColumnInfo>, String> {
+    let connections = state.connections.read().await;
+
+    #[cfg(feature = "duckdb-bundled")]
+    if let Some(PoolKind::DuckDb(con)) = connections.get(pool_key) {
+        let con = con.clone();
+        drop(connections);
+        let table = table.to_string();
+        let schema = schema.to_string();
+        return tokio::task::spawn_blocking(move || {
+            let con = con.lock().map_err(|e| e.to_string())?;
+            crate::schema::duckdb_query_columns_in_database(&con, "main", &schema, &table)
+        })
+        .await
+        .map_err(|e| e.to_string())?;
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    if let Some(PoolKind::ExternalTabular(ext_pool)) = connections.get(pool_key) {
+        let con = ext_pool.cache.clone();
+        drop(connections);
+        let table = table.to_string();
+        let schema = schema.to_string();
+        return tokio::task::spawn_blocking(move || {
+            let con = con.lock().map_err(|e| e.to_string())?;
+            crate::schema::duckdb_query_columns_in_database(&con, "main", &schema, &table)
+        })
+        .await
+        .map_err(|e| e.to_string())?;
+    }
+
+    if let Some(PoolKind::ClickHouse(client)) = connections.get(pool_key) {
+        let client = client.clone();
+        let database = database.to_string();
+        let table = table.to_string();
+        drop(connections);
+        return db::clickhouse_driver::get_columns(&client, &database, &table).await;
+    }
+    if let Some(PoolKind::SqlServer(client)) = connections.get(pool_key) {
+        let client = client.clone();
+        let schema = schema.to_string();
+        let table = table.to_string();
+        drop(connections);
+        let mut client = client.lock().await;
+        return db::sqlserver::get_columns(&mut client, &schema, &table).await;
+    }
+    if let Some(PoolKind::InfluxDb(client)) = connections.get(pool_key) {
+        let client = client.clone();
+        let database = database.to_string();
+        let table = table.to_string();
+        drop(connections);
+        return db::influxdb_driver::get_columns(&client, &database, &table).await;
+    }
+    if let Some(PoolKind::Agent(client)) = connections.get(pool_key) {
+        let client = client.clone();
+        let database = database.to_string();
+        let schema = schema.to_string();
+        let table = table.to_string();
+        drop(connections);
+        let mut client = client.lock().await;
+        return client.get_columns(&database, &schema, &table, None).await;
+    }
+    let pool = connections.get(pool_key).ok_or("Pool not found")?;
+    let schema = schema.to_string();
+    let table = table.to_string();
+    match pool {
+        PoolKind::Mysql(p, _) => {
+            let p = p.clone();
+            drop(connections);
+            db::mysql::get_columns(&p, &schema, &table).await
+        }
+        PoolKind::Postgres(p) => {
+            let p = p.clone();
+            drop(connections);
+            db::postgres::get_columns(&p, &schema, &table).await
+        }
+        PoolKind::Sqlite(p) => {
+            let p = p.clone();
+            drop(connections);
+            db::sqlite::get_columns(&p, &schema, &table).await
+        }
+        _ => Err("Unsupported database type".to_string()),
+    }
+}
+
+async fn get_postgres_indexes_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::IndexInfo>, String> {
+    let connections = state.connections.read().await;
+    let Some(PoolKind::Postgres(pool)) = connections.get(pool_key) else {
+        return Err("PostgreSQL pool not found".to_string());
+    };
+    let pool = pool.clone();
+    drop(connections);
+    db::postgres::list_indexes(&pool, schema, table).await
+}
+
+async fn get_postgres_foreign_keys_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    schema: &str,
+    table: &str,
+) -> Result<Vec<db::ForeignKeyInfo>, String> {
+    let connections = state.connections.read().await;
+    let Some(PoolKind::Postgres(pool)) = connections.get(pool_key) else {
+        return Err("PostgreSQL pool not found".to_string());
+    };
+    let pool = pool.clone();
+    drop(connections);
+    db::postgres::list_foreign_keys(&pool, schema, table).await
+}
+
+async fn get_postgres_owned_sequences_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    schema: &str,
+    tables: &[String],
+) -> Result<Vec<PostgresOwnedSequence>, String> {
+    if tables.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let pool = {
+        let connections = state.connections.read().await;
+        match connections.get(pool_key) {
+            Some(PoolKind::Postgres(pool)) => pool.clone(),
+            _ => return Ok(Vec::new()),
+        }
+    };
+    let client = pool.get().await.map_err(|e| e.to_string())?;
+    let rows = client
+        .query(
+            "SELECT c.relname, \
+              t.relname, \
+              a.attname \
+             FROM pg_class c \
+             JOIN pg_namespace n ON n.oid = c.relnamespace \
+             LEFT JOIN pg_sequence s ON s.seqrelid = c.oid \
+             JOIN pg_depend d ON d.classid = 'pg_class'::regclass \
+               AND d.objid = c.oid \
+               AND d.refclassid = 'pg_class'::regclass \
+               AND d.deptype IN ('a', 'i') \
+             JOIN pg_class t ON t.oid = d.refobjid \
+             JOIN pg_namespace tn ON tn.oid = t.relnamespace AND tn.nspname = n.nspname \
+             JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = d.refobjsubid \
+             WHERE c.relkind = 'S' AND n.nspname = $1 \
+             ORDER BY t.relname, c.relname",
+            &[&schema],
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let selected: HashSet<&str> = tables.iter().map(String::as_str).collect();
+    Ok(rows
+        .iter()
+        .filter_map(|row| {
+            let owner_table = row.get::<_, String>(1);
+            if !selected.contains(owner_table.as_str()) {
+                return None;
+            }
+            Some(PostgresOwnedSequence {
+                name: row.get::<_, String>(0),
+                owner_table,
+                owner_column: row.get::<_, String>(2),
+            })
+        })
+        .collect())
+}
+
+async fn get_postgres_sequence_snapshots_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    schema: &str,
+) -> Result<Vec<PostgresSequenceSnapshot>, String> {
+    let pool = {
+        let connections = state.connections.read().await;
+        match connections.get(pool_key) {
+            Some(PoolKind::Postgres(pool)) => pool.clone(),
+            _ => return Ok(Vec::new()),
+        }
+    };
+    let client = pool.get().await.map_err(|e| e.to_string())?;
+    let rows = client
+        .query(
+            "SELECT c.relname, \
+              t.relname, \
+              a.attname \
+             FROM pg_class c \
+             JOIN pg_namespace n ON n.oid = c.relnamespace \
+             LEFT JOIN pg_sequence s ON s.seqrelid = c.oid \
+             LEFT JOIN pg_depend d ON d.classid = 'pg_class'::regclass \
+               AND d.objid = c.oid \
+               AND d.refclassid = 'pg_class'::regclass \
+               AND d.deptype IN ('a', 'i') \
+             LEFT JOIN pg_class t ON t.oid = d.refobjid \
+             LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = d.refobjsubid \
+             WHERE c.relkind = 'S' AND n.nspname = $1 \
+             ORDER BY c.relname",
+            &[&schema],
+        )
+        .await
+        .map_err(|e| e.to_string())?;
+
+    Ok(rows
+        .iter()
+        .map(|row| PostgresSequenceSnapshot {
+            name: row.get::<_, String>(0),
+            owner_table: row.get::<_, Option<String>>(1),
+            owner_column: row.get::<_, Option<String>>(2),
+        })
+        .collect())
+}
+
+/// Create owned PostgreSQL sequences before executing reused table DDL because
+/// serial defaults still reference `nextval('...')` in `CREATE TABLE`.
+async fn prepare_postgres_owned_sequences_for_transfer(
+    state: &AppState,
+    request: &TransferRequest,
+    table: &str,
+    target_table: &str,
+    source_pool_key: &str,
+    target_pool_key: &str,
+    pg_compat_transfer: bool,
+    preserves_target_table_name: bool,
+    target_table_preexisting: bool,
+) -> Result<Vec<PostgresOwnedSequence>, String> {
+    if !(request.create_table && pg_compat_transfer && preserves_target_table_name && !target_table_preexisting) {
+        return Ok(Vec::new());
+    }
+
+    let owned_sequences =
+        get_postgres_owned_sequences_for_transfer(state, source_pool_key, &request.source_schema, &[table.to_string()])
+            .await?;
+    if owned_sequences.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let existing_sequences =
+        get_postgres_sequence_snapshots_for_transfer(state, target_pool_key, &request.target_schema)
+            .await?
+            .into_iter()
+            .map(|sequence| (sequence.name.clone(), sequence))
+            .collect::<HashMap<_, _>>();
+
+    for sequence in &owned_sequences {
+        let should_create = validate_existing_postgres_sequence(
+            sequence,
+            existing_sequences.get(&sequence.name),
+            &request.target_schema,
+        )?;
+        if should_create {
+            let create_sql = format!(
+                "CREATE SEQUENCE IF NOT EXISTS {}",
+                postgres_sequence_qualified_name(&request.target_schema, &sequence.name)
+            );
+            execute_on_pool(state, target_pool_key, &create_sql)
+                .await
+                .map_err(|e| format!("Failed to create PostgreSQL sequence for {target_table}: {e}"))?;
+        }
+    }
+
+    Ok(owned_sequences)
+}
+
+/// Bind created or reused sequences after the table exists so
+/// `pg_get_serial_sequence(...)` can find them during later sequence sync.
+async fn bind_postgres_owned_sequences_for_transfer(
+    state: &AppState,
+    request: &TransferRequest,
+    target_table: &str,
+    target_pool_key: &str,
+    owned_sequences: &[PostgresOwnedSequence],
+) -> Result<(), String> {
+    for sequence in owned_sequences {
+        let owner_sql = format!(
+            "ALTER SEQUENCE {} OWNED BY {}.{}",
+            postgres_sequence_qualified_name(&request.target_schema, &sequence.name),
+            qualified_table(&sequence.owner_table, &request.target_schema, &DatabaseType::Postgres),
+            quote_identifier(&sequence.owner_column, &DatabaseType::Postgres)
+        );
+        execute_on_pool(state, target_pool_key, &owner_sql)
+            .await
+            .map_err(|e| format!("Failed to bind PostgreSQL sequence for {target_table}: {e}"))?;
+    }
+    Ok(())
+}
+
+async fn get_postgres_schema_object_sources_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    schema: &str,
+) -> Result<Vec<db::ObjectSource>, String> {
+    let views_sql = format!(
+        "SELECT c.relname, pg_get_viewdef(c.oid, true) \
+         FROM pg_catalog.pg_class c \
+         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+         WHERE n.nspname = {} AND c.relkind = 'v' \
+         ORDER BY c.relname",
+        quote_string_literal(schema)
+    );
+    let routines_sql = format!(
+        "SELECT p.proname, CASE p.prokind WHEN 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END, pg_get_functiondef(p.oid) \
+         FROM pg_catalog.pg_proc p \
+         JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+         WHERE n.nspname = {} AND p.prokind IN ('p', 'f') \
+         ORDER BY CASE p.prokind WHEN 'p' THEN 0 ELSE 1 END, p.proname, p.oid",
+        quote_string_literal(schema)
+    );
+
+    let mut sources = Vec::new();
+    for row in execute_on_pool(state, pool_key, &views_sql).await?.rows {
+        let Some(name) = json_string_cell(&row, 0) else {
+            continue;
+        };
+        let Some(source) = json_string_cell(&row, 1) else {
+            continue;
+        };
+        sources.push(db::ObjectSource {
+            name,
+            object_type: db::ObjectSourceKind::View,
+            schema: Some(schema.to_string()),
+            source,
+            editable: None,
+        });
+    }
+    for row in execute_on_pool(state, pool_key, &routines_sql).await?.rows {
+        let Some(name) = json_string_cell(&row, 0) else {
+            continue;
+        };
+        let kind = match json_string_cell(&row, 1).as_deref() {
+            Some("PROCEDURE") => db::ObjectSourceKind::Procedure,
+            _ => db::ObjectSourceKind::Function,
+        };
+        let Some(source) = json_string_cell(&row, 2) else {
+            continue;
+        };
+        sources.push(db::ObjectSource {
+            name,
+            object_type: kind,
+            schema: Some(schema.to_string()),
+            source,
+            editable: None,
+        });
+    }
+
+    Ok(sources)
+}
+
+async fn get_postgres_materialized_view_sources_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    schema: &str,
+) -> Result<Vec<PostgresMaterializedViewSource>, String> {
+    let sql = format!(
+        "SELECT c.relname, pg_get_viewdef(c.oid, true) \
+         FROM pg_catalog.pg_class c \
+         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+         WHERE n.nspname = {} AND c.relkind = 'm' \
+         ORDER BY c.relname",
+        quote_string_literal(schema)
+    );
+    let rows = execute_on_pool(state, pool_key, &sql).await?.rows;
+    Ok(rows
+        .into_iter()
+        .filter_map(|row| {
+            Some(PostgresMaterializedViewSource {
+                view_name: json_string_cell(&row, 0)?,
+                source: json_string_cell(&row, 1)?,
+            })
+        })
+        .collect())
+}
+
+async fn get_postgres_trigger_sources_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    schema: &str,
+    tables: &[String],
+) -> Result<Vec<PostgresTriggerSource>, String> {
+    if tables.is_empty() {
+        return Ok(Vec::new());
+    }
+    let table_list = tables.iter().map(|table| quote_string_literal(table)).collect::<Vec<_>>().join(", ");
+    let sql = format!(
+        "SELECT c.relname, t.tgname, pg_get_triggerdef(t.oid, true) \
+         FROM pg_catalog.pg_trigger t \
+         JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid \
+         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+         WHERE n.nspname = {} AND NOT t.tgisinternal AND c.relname IN ({table_list}) \
+         ORDER BY c.relname, t.tgname",
+        quote_string_literal(schema)
+    );
+    let rows = execute_on_pool(state, pool_key, &sql).await?.rows;
+    Ok(rows
+        .into_iter()
+        .filter_map(|row| {
+            Some(PostgresTriggerSource {
+                table_name: json_string_cell(&row, 0)?,
+                trigger_name: json_string_cell(&row, 1)?,
+                source: json_string_cell(&row, 2)?,
+            })
+        })
+        .collect())
+}
+
+async fn get_postgres_extension_sources_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    schema: &str,
+) -> Result<Vec<PostgresExtensionSource>, String> {
+    let sql = format!(
+        "SELECT e.extname \
+         FROM pg_extension e \
+         JOIN pg_namespace n ON n.oid = e.extnamespace \
+         WHERE n.nspname = {} \
+         ORDER BY e.extname",
+        quote_string_literal(schema)
+    );
+    let rows = execute_on_pool(state, pool_key, &sql).await?.rows;
+    Ok(rows
+        .into_iter()
+        .filter_map(|row| json_string_cell(&row, 0).map(|extension_name| PostgresExtensionSource { extension_name }))
+        .collect())
+}
+
+async fn get_postgres_enum_sources_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    schema: &str,
+) -> Result<Vec<PostgresEnumSource>, String> {
+    let sql = format!(
+        "SELECT t.typname, COALESCE(array_to_json(array_agg(e.enumlabel ORDER BY e.enumsortorder))::text, '[]') \
+         FROM pg_type t \
+         JOIN pg_namespace n ON n.oid = t.typnamespace \
+         LEFT JOIN pg_enum e ON e.enumtypid = t.oid \
+         WHERE n.nspname = {} AND t.typtype = 'e' \
+         GROUP BY t.typname \
+         ORDER BY t.typname",
+        quote_string_literal(schema)
+    );
+    let rows = execute_on_pool(state, pool_key, &sql).await?.rows;
+    Ok(rows
+        .into_iter()
+        .filter_map(|row| {
+            let type_name = json_string_cell(&row, 0)?;
+            let labels_json = json_string_cell(&row, 1)?;
+            let labels = serde_json::from_str::<Vec<String>>(&labels_json).ok()?;
+            Some(PostgresEnumSource { type_name, labels })
+        })
+        .collect())
+}
+
+async fn get_postgres_domain_sources_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    schema: &str,
+) -> Result<Vec<PostgresDomainSource>, String> {
+    let sql = format!(
+        "SELECT t.typname, \
+                pg_catalog.format_type(t.typbasetype, t.typtypmod), \
+                NULLIF(t.typdefault, ''), \
+                t.typnotnull, \
+                COALESCE(( \
+                    SELECT array_to_json(array_agg(pg_get_constraintdef(c.oid, true) ORDER BY c.conname))::text \
+                    FROM pg_constraint c \
+                    WHERE c.contypid = t.oid AND c.contype = 'c' \
+                ), '[]') \
+         FROM pg_type t \
+         JOIN pg_namespace n ON n.oid = t.typnamespace \
+         WHERE n.nspname = {} AND t.typtype = 'd' \
+         ORDER BY t.typname",
+        quote_string_literal(schema)
+    );
+    let rows = execute_on_pool(state, pool_key, &sql).await?.rows;
+    Ok(rows
+        .into_iter()
+        .filter_map(|row| {
+            let domain_name = json_string_cell(&row, 0)?;
+            let base_type = json_string_cell(&row, 1)?;
+            let default_value = json_string_cell(&row, 2);
+            let not_null = row.get(3).and_then(|value| value.as_bool()).unwrap_or(false);
+            let checks = json_string_cell(&row, 4)
+                .and_then(|json| serde_json::from_str::<Vec<String>>(&json).ok())
+                .unwrap_or_default();
+            Some(PostgresDomainSource { domain_name, base_type, default_value, not_null, checks })
+        })
+        .collect())
+}
+
+async fn get_postgres_policy_statements_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    source_schema: &str,
+    target_schema: &str,
+    tables: &[String],
+) -> Result<Vec<String>, String> {
+    if tables.is_empty() {
+        return Ok(Vec::new());
+    }
+    let table_list = tables.iter().map(|table| quote_string_literal(table)).collect::<Vec<_>>().join(", ");
+    let sql = format!(
+        "WITH selected_tables AS ( \
+             SELECT c.oid, c.relname, c.relrowsecurity, c.relforcerowsecurity \
+             FROM pg_catalog.pg_class c \
+             JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+             WHERE n.nspname = {source_schema} AND c.relkind IN ('r','p') AND c.relname IN ({table_list}) \
+         ), \
+         policy_rows AS ( \
+             SELECT t.relname, t.relrowsecurity, t.relforcerowsecurity, p.polname, p.polpermissive, p.polcmd, \
+                    COALESCE((SELECT string_agg(CASE WHEN role_oid = 0 THEN 'PUBLIC' ELSE quote_ident(r.rolname) END, ', ' ORDER BY CASE WHEN role_oid = 0 THEN '' ELSE r.rolname END) \
+                              FROM unnest(p.polroles) AS role_oid LEFT JOIN pg_roles r ON r.oid = role_oid), '') AS role_list, \
+                    pg_get_expr(p.polqual, p.polrelid) AS using_expr, \
+                    pg_get_expr(p.polwithcheck, p.polrelid) AS with_check_expr \
+             FROM selected_tables t \
+             JOIN pg_catalog.pg_policy p ON p.polrelid = t.oid \
+         ) \
+         SELECT stmt FROM ( \
+             SELECT format('ALTER TABLE %I.%I ENABLE ROW LEVEL SECURITY', {target_schema}, relname) AS stmt, relname, 0 AS sort_order \
+             FROM selected_tables WHERE relrowsecurity \
+             UNION ALL \
+             SELECT format('ALTER TABLE %I.%I FORCE ROW LEVEL SECURITY', {target_schema}, relname) AS stmt, relname, 1 AS sort_order \
+             FROM selected_tables WHERE relforcerowsecurity \
+             UNION ALL \
+             SELECT format('DROP POLICY IF EXISTS %I ON %I.%I', polname, {target_schema}, relname) AS stmt, relname, 2 AS sort_order \
+             FROM policy_rows \
+             UNION ALL \
+             SELECT format( \
+                 'CREATE POLICY %I ON %I.%I AS %s FOR %s%s%s%s', \
+                 polname, {target_schema}, relname, \
+                 CASE WHEN polpermissive THEN 'PERMISSIVE' ELSE 'RESTRICTIVE' END, \
+                 CASE polcmd WHEN 'r' THEN 'SELECT' WHEN 'a' THEN 'INSERT' WHEN 'w' THEN 'UPDATE' WHEN 'd' THEN 'DELETE' ELSE 'ALL' END, \
+                 CASE WHEN role_list <> '' THEN ' TO ' || role_list ELSE '' END, \
+                 CASE WHEN using_expr IS NOT NULL THEN ' USING (' || using_expr || ')' ELSE '' END, \
+                 CASE WHEN with_check_expr IS NOT NULL THEN ' WITH CHECK (' || with_check_expr || ')' ELSE '' END \
+             ) AS stmt, relname, 3 AS sort_order \
+             FROM policy_rows \
+         ) statements \
+         ORDER BY relname, sort_order, stmt",
+        source_schema = quote_string_literal(source_schema),
+        target_schema = quote_string_literal(target_schema),
+    );
+    Ok(result_rows_to_string_statements(execute_on_pool(state, pool_key, &sql).await?.rows))
+}
+
+async fn get_postgres_ownership_statements_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    source_schema: &str,
+    target_schema: &str,
+    tables: &[String],
+) -> Result<Vec<PostgresOwnershipStatement>, String> {
+    let table_list = tables.iter().map(|table| quote_string_literal(table)).collect::<Vec<_>>().join(", ");
+    let table_filter = if tables.is_empty() { "FALSE".to_string() } else { format!("c.relname IN ({table_list})") };
+    let sql = format!(
+        "WITH relation_owners AS ( \
+             SELECT CASE c.relkind \
+                      WHEN 'm' THEN format('ALTER MATERIALIZED VIEW %I.%I OWNER TO ', {target_schema}, c.relname) \
+                      WHEN 'v' THEN format('ALTER VIEW %I.%I OWNER TO ', {target_schema}, c.relname) \
+                      WHEN 'f' THEN format('ALTER FOREIGN TABLE %I.%I OWNER TO ', {target_schema}, c.relname) \
+                      WHEN 'S' THEN format('ALTER SEQUENCE %I.%I OWNER TO ', {target_schema}, c.relname) \
+                      ELSE format('ALTER TABLE %I.%I OWNER TO ', {target_schema}, c.relname) \
+                    END AS stmt_prefix, \
+                    pg_get_userbyid(c.relowner) AS owner_name \
+             FROM pg_catalog.pg_class c \
+             JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+             WHERE n.nspname = {source_schema} AND (c.relkind IN ('v','m') OR ({table_filter} AND c.relkind IN ('r','p','f','S'))) \
+         ), \
+         routine_owners AS ( \
+             SELECT format('ALTER %s %I.%I(%s) OWNER TO ', \
+                           CASE p.prokind WHEN 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END, \
+                           {target_schema}, p.proname, pg_get_function_identity_arguments(p.oid)) AS stmt_prefix, \
+                    pg_get_userbyid(p.proowner) AS owner_name \
+             FROM pg_catalog.pg_proc p \
+             JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+             WHERE n.nspname = {source_schema} AND p.prokind IN ('p','f') \
+         ), \
+         type_owners AS ( \
+             SELECT format('ALTER %s %I.%I OWNER TO ', \
+                           CASE t.typtype WHEN 'd' THEN 'DOMAIN' ELSE 'TYPE' END, \
+                           {target_schema}, t.typname) AS stmt_prefix, \
+                    pg_get_userbyid(t.typowner) AS owner_name \
+             FROM pg_catalog.pg_type t \
+             JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace \
+             WHERE n.nspname = {source_schema} AND t.typtype IN ('e','d') \
+         ) \
+         SELECT stmt_prefix, owner_name FROM ( \
+             SELECT format('ALTER SCHEMA %I OWNER TO ', {target_schema}) AS stmt_prefix, \
+                    pg_get_userbyid(n.nspowner) AS owner_name \
+             FROM pg_catalog.pg_namespace n WHERE n.nspname = {source_schema} \
+             UNION ALL SELECT stmt_prefix, owner_name FROM relation_owners \
+             UNION ALL SELECT stmt_prefix, owner_name FROM routine_owners \
+             UNION ALL SELECT stmt_prefix, owner_name FROM type_owners \
+         ) statements \
+         WHERE stmt_prefix IS NOT NULL AND owner_name IS NOT NULL",
+        source_schema = quote_string_literal(source_schema),
+        target_schema = quote_string_literal(target_schema),
+        table_filter = table_filter,
+    );
+    Ok(result_rows_to_postgres_ownership_statements(execute_on_pool(state, pool_key, &sql).await?.rows))
+}
+
+fn distinct_postgres_ownership_roles(statements: &[PostgresOwnershipStatement]) -> Vec<String> {
+    let mut roles = statements.iter().map(|statement| statement.owner.clone()).collect::<Vec<_>>();
+    roles.sort();
+    roles.dedup();
+    roles
+}
+
+async fn get_postgres_current_user(state: &AppState, target_pool_key: &str) -> Result<String, String> {
+    let rows = execute_on_pool(state, target_pool_key, "SELECT current_user").await?.rows;
+    rows.first()
+        .and_then(|row| json_string_cell(row, 0))
+        .filter(|user| !user.trim().is_empty())
+        .ok_or_else(|| "Failed to read target PostgreSQL current user".to_string())
+}
+
+async fn get_existing_postgres_roles(
+    state: &AppState,
+    target_pool_key: &str,
+    roles: &[String],
+) -> Result<HashSet<String>, String> {
+    if roles.is_empty() {
+        return Ok(HashSet::new());
+    }
+    let role_list = roles.iter().map(|role| quote_string_literal(role)).collect::<Vec<_>>().join(", ");
+    let sql = format!("SELECT rolname FROM pg_catalog.pg_roles WHERE rolname IN ({role_list})");
+    let rows = execute_on_pool(state, target_pool_key, &sql).await?.rows;
+    Ok(rows.into_iter().filter_map(|row| json_string_cell(&row, 0)).collect())
+}
+
+fn build_postgres_ownership_statement(statement: &PostgresOwnershipStatement, owner: &str) -> String {
+    format!("{}{}", statement.sql_prefix, quote_identifier(owner, &DatabaseType::Postgres))
+}
+
+pub async fn preview_transfer_ownership(
+    state: &AppState,
+    request: &TransferRequest,
+    source_db_type: &DatabaseType,
+    target_db_type: &DatabaseType,
+    source_pool_key: &str,
+    target_pool_key: &str,
+) -> Result<TransferOwnershipPreview, String> {
+    if !request.create_table || !is_postgres_compat_transfer(source_db_type, target_db_type) {
+        return Ok(TransferOwnershipPreview { missing_owners: Vec::new(), target_owner: String::new() });
+    }
+
+    let statements = get_postgres_ownership_statements_for_transfer(
+        state,
+        source_pool_key,
+        &request.source_schema,
+        &request.target_schema,
+        &request.tables,
+    )
+    .await?;
+    let roles = distinct_postgres_ownership_roles(&statements);
+    let existing_roles = get_existing_postgres_roles(state, target_pool_key, &roles).await?;
+    let missing_owners = roles.into_iter().filter(|role| !existing_roles.contains(role)).collect::<Vec<_>>();
+    let target_owner = if missing_owners.is_empty() {
+        String::new()
+    } else {
+        get_postgres_current_user(state, target_pool_key).await?
+    };
+
+    Ok(TransferOwnershipPreview { missing_owners, target_owner })
+}
+
+async fn get_postgres_grant_statements_for_transfer(
+    state: &AppState,
+    pool_key: &str,
+    source_schema: &str,
+    target_schema: &str,
+    tables: &[String],
+) -> Result<Vec<String>, String> {
+    let table_list = tables.iter().map(|table| quote_string_literal(table)).collect::<Vec<_>>().join(", ");
+    let table_filter = if tables.is_empty() { "FALSE".to_string() } else { format!("c.relname IN ({table_list})") };
+    let sql = format!(
+        "WITH schema_grants AS ( \
+             SELECT format( \
+                 'GRANT %s ON SCHEMA %I TO %s%s', \
+                 string_agg(a.privilege_type, ', ' ORDER BY a.privilege_type), \
+                 {target_schema}, \
+                 CASE WHEN a.grantee = 0 THEN 'PUBLIC' ELSE quote_ident(grantee.rolname) END, \
+                 CASE WHEN bool_or(a.is_grantable) THEN ' WITH GRANT OPTION' ELSE '' END \
+             ) AS stmt \
+             FROM pg_catalog.pg_namespace n \
+             JOIN LATERAL aclexplode(n.nspacl) a ON true \
+             LEFT JOIN pg_roles grantee ON grantee.oid = a.grantee \
+             WHERE n.nspname = {source_schema} \
+             GROUP BY a.grantee, grantee.rolname \
+         ), \
+         relation_grants AS ( \
+             SELECT format( \
+                 'GRANT %s ON %s %I.%I TO %s%s', \
+                 string_agg(privilege_type, ', ' ORDER BY privilege_type), \
+                 CASE WHEN relkind = 'S' THEN 'SEQUENCE' ELSE 'TABLE' END, \
+                 {target_schema}, relname, \
+                 CASE WHEN grantee = 0 THEN 'PUBLIC' ELSE quote_ident(rolname) END, \
+                 CASE WHEN bool_or(is_grantable) THEN ' WITH GRANT OPTION' ELSE '' END \
+             ) AS stmt \
+             FROM ( \
+                 SELECT c.relname, c.relkind, a.grantee, a.privilege_type, a.is_grantable, grantee.rolname \
+                 FROM pg_catalog.pg_class c \
+                 JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+                 JOIN LATERAL aclexplode(c.relacl) a ON true \
+                 LEFT JOIN pg_roles grantee ON grantee.oid = a.grantee \
+                 WHERE n.nspname = {source_schema} AND (c.relkind IN ('v','m') OR ({table_filter} AND c.relkind IN ('r','p','f','S'))) \
+             ) rels \
+             GROUP BY relname, relkind, grantee, rolname \
+         ), \
+         routine_grants AS ( \
+             SELECT format( \
+                 'GRANT %s ON %s %I.%I(%s) TO %s%s', \
+                 string_agg(privilege_type, ', ' ORDER BY privilege_type), \
+                 CASE WHEN prokind = 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END, \
+                 {target_schema}, proname, identity_args, \
+                 CASE WHEN grantee = 0 THEN 'PUBLIC' ELSE quote_ident(rolname) END, \
+                 CASE WHEN bool_or(is_grantable) THEN ' WITH GRANT OPTION' ELSE '' END \
+             ) AS stmt \
+             FROM ( \
+                 SELECT p.proname, p.prokind, pg_get_function_identity_arguments(p.oid) AS identity_args, a.grantee, a.privilege_type, a.is_grantable, grantee.rolname \
+                 FROM pg_catalog.pg_proc p \
+                 JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
+                 JOIN LATERAL aclexplode(p.proacl) a ON true \
+                 LEFT JOIN pg_roles grantee ON grantee.oid = a.grantee \
+                 WHERE n.nspname = {source_schema} AND p.prokind IN ('p','f') \
+             ) routines \
+             GROUP BY proname, prokind, identity_args, grantee, rolname \
+         ) \
+         SELECT stmt FROM ( \
+             SELECT stmt FROM schema_grants \
+             UNION ALL SELECT stmt FROM relation_grants \
+             UNION ALL SELECT stmt FROM routine_grants \
+         ) statements \
+         WHERE stmt IS NOT NULL",
+        source_schema = quote_string_literal(source_schema),
+        target_schema = quote_string_literal(target_schema),
+        table_filter = table_filter,
+    );
+    Ok(result_rows_to_string_statements(execute_on_pool(state, pool_key, &sql).await?.rows))
+}
+
+pub async fn is_cancelled(transfer_id: &str) -> bool {
+    CANCELLED.read().await.contains(transfer_id)
+}
+
+pub async fn set_cancelled(transfer_id: &str) {
+    CANCELLED.write().await.insert(transfer_id.to_string());
+}
+
+pub async fn clear_cancelled(transfer_id: &str) {
+    CANCELLED.write().await.remove(transfer_id);
+}
+
+/// Sort table names by foreign key dependency.
+///
+/// When `parents_first` is true (data transfer / SQL export), referenced (parent)
+/// tables come before referencing (child) tables so inserts don't violate FK
+/// constraints.
+///
+/// When `parents_first` is false (batch drop), referencing (child) tables come
+/// first so they are dropped before the tables they reference.
+///
+/// Uses Kahn's algorithm for topological sort; tables involved in cycles keep
+/// their original relative order after all cycle-free tables.
+pub async fn sort_tables_by_fk_dependency(
+    state: &AppState,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    tables: &[String],
+    parents_first: bool,
+) -> Result<Vec<String>, String> {
+    if tables.len() <= 1 {
+        return Ok(tables.to_vec());
+    }
+
+    let table_set: HashSet<&str> = tables.iter().map(|t| t.as_str()).collect();
+
+    // Gather FK relationships for every table.
+    let mut dependency_map: HashMap<String, Vec<String>> = HashMap::new();
+    for table in tables {
+        let fks = crate::schema::list_foreign_keys_core(state, connection_id, database, schema, table).await?;
+        let deps: Vec<String> = fks
+            .iter()
+            .map(|fk| fk.ref_table.clone())
+            .filter(|ref_table| table_set.contains(ref_table.as_str()))
+            .collect();
+        dependency_map.insert(table.clone(), deps);
+    }
+
+    // Build in-degree and dependents graph.
+    // parents_first=true:  edge ref_table → table     (parent before child)
+    // parents_first=false: edge table → ref_table      (child before parent)
+    let mut in_degree: HashMap<&str, usize> = HashMap::new();
+    let mut dependents: HashMap<&str, Vec<&str>> = HashMap::new();
+
+    for table in tables {
+        in_degree.entry(table.as_str()).or_insert(0);
+    }
+    for table in tables {
+        if let Some(deps) = dependency_map.get(table) {
+            for ref_table in deps {
+                if parents_first {
+                    // FK-bearing table depends on ref_table — parent comes first.
+                    *in_degree.entry(table.as_str()).or_insert(0) += 1;
+                    dependents.entry(ref_table.as_str()).or_default().push(table.as_str());
+                } else {
+                    // ref_table depends on FK-bearing table — child comes first.
+                    *in_degree.entry(ref_table.as_str()).or_insert(0) += 1;
+                    dependents.entry(table.as_str()).or_default().push(ref_table.as_str());
+                }
+            }
+        }
+    }
+
+    // Kahn's algorithm.
+    let mut queue: std::collections::VecDeque<&str> =
+        in_degree.iter().filter(|(_, &deg)| deg == 0).map(|(&table, _)| table).collect();
+
+    let mut sorted: Vec<String> = Vec::new();
+    while let Some(table) = queue.pop_front() {
+        sorted.push(table.to_string());
+        if let Some(deps) = dependents.get(table) {
+            for &dependent in deps {
+                let deg = in_degree.get_mut(dependent).unwrap();
+                *deg -= 1;
+                if *deg == 0 {
+                    queue.push_back(dependent);
+                }
+            }
+        }
+    }
+
+    // Append any tables left behind by cycles in their original order.
+    if sorted.len() < tables.len() {
+        let sorted_set: HashSet<&str> = sorted.iter().map(|s| s.as_str()).collect();
+        let mut remaining: Vec<String> = Vec::new();
+        for table in tables {
+            if !sorted_set.contains(table.as_str()) {
+                remaining.push(table.clone());
+            }
+        }
+        sorted.extend(remaining);
+    }
+
+    Ok(sorted)
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn transfer_mongodb_table<F>(
+    state: &AppState,
+    request: &TransferRequest,
+    table: &str,
+    table_index: usize,
+    source_db_type: &DatabaseType,
+    target_db_type: &DatabaseType,
+    source_pool_key: &str,
+    target_pool_key: &str,
+    mut progress_callback: F,
+) -> Result<u64, String>
+where
+    F: FnMut(TransferProgress),
+{
+    let total_tables = request.tables.len();
+    let ResolvedTransferTargetTable { name: target_table, preexisting: target_table_preexisting } =
+        resolve_transfer_target_table_name(state, request, table, target_pool_key, target_db_type).await;
+    let batch_size = if request.batch_size == 0 { 1000 } else { request.batch_size };
+    let mut offset: u64 = 0;
+    let mut total_transferred: u64 = 0;
+    let mut total_rows = None;
+
+    if request.mode == TransferMode::Upsert {
+        log::warn!("[transfer] MongoDB upsert is not supported yet, falling back to append");
+    }
+
+    if is_mongodb_transfer_type(target_db_type) && request.mode == TransferMode::Overwrite {
+        overwrite_mongo_collection_for_transfer(
+            state,
+            &request.target_connection_id,
+            &request.target_database,
+            &target_table,
+        )
+        .await
+        .map_err(|e| format!("Failed to clear MongoDB collection '{target_table}': {e}"))?;
+    }
+
+    let mut sql_target_column_names: Vec<String> = Vec::new();
+    let mut sql_target_column_types: Vec<Option<String>> = Vec::new();
+    let mut sql_target_prepared = false;
+
+    loop {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+
+        let documents = if is_mongodb_transfer_type(source_db_type) {
+            let result = if is_mongodb_transfer_type(target_db_type) {
+                find_mongo_documents_extended_json(
+                    state,
+                    &request.source_connection_id,
+                    &request.source_database,
+                    table,
+                    offset,
+                    batch_size,
+                )
+                .await?
+            } else {
+                find_mongo_documents_for_rows(
+                    state,
+                    &request.source_connection_id,
+                    &request.source_database,
+                    table,
+                    offset,
+                    batch_size,
+                )
+                .await?
+            };
+            total_rows = Some(result.total);
+            result.documents
+        } else {
+            let columns = get_columns_for_transfer(
+                state,
+                source_pool_key,
+                &request.source_connection_id,
+                &request.source_database,
+                &request.source_schema,
+                table,
+            )
+            .await?;
+            let col_names = columns.iter().map(|column| column.name.clone()).collect::<Vec<_>>();
+            let primary_key_columns = columns
+                .iter()
+                .filter(|column| column.is_primary_key)
+                .map(|column| column.name.clone())
+                .collect::<Vec<_>>();
+            let sql = pagination_sql_with_order(
+                &col_names,
+                table,
+                &request.source_schema,
+                source_db_type,
+                offset,
+                batch_size,
+                &primary_key_columns,
+            );
+            let result = execute_on_pool(state, source_pool_key, &sql).await?;
+            sql_rows_to_mongo_documents(&col_names, &result.rows)
+        };
+
+        let row_count = documents.len();
+        if row_count == 0 {
+            break;
+        }
+
+        if is_mongodb_transfer_type(target_db_type) {
+            if is_mongodb_transfer_type(source_db_type) {
+                insert_mongo_documents_extended_json_for_transfer(
+                    state,
+                    &request.target_connection_id,
+                    &request.target_database,
+                    &target_table,
+                    &documents,
+                )
+                .await
+            } else {
+                insert_mongo_documents_for_transfer(
+                    state,
+                    &request.target_connection_id,
+                    &request.target_database,
+                    &target_table,
+                    &documents,
+                )
+                .await
+            }
+            .map_err(|e| format!("Insert failed for MongoDB collection '{target_table}' at offset {offset}: {e}"))?;
+        } else {
+            if !sql_target_prepared {
+                let mut sql_target_columns = mongo_columns_from_documents(&documents);
+                if sql_target_columns.is_empty() {
+                    sql_target_columns.push(db::ColumnInfo {
+                        name: "document".to_string(),
+                        data_type: "json".to_string(),
+                        is_nullable: true,
+                        column_default: None,
+                        is_primary_key: false,
+                        extra: None,
+                        comment: None,
+                        numeric_precision: None,
+                        numeric_scale: None,
+                        character_maximum_length: None,
+                        enum_values: None,
+                        ..Default::default()
+                    });
+                }
+                sql_target_column_names = sql_target_columns.iter().map(|column| column.name.clone()).collect();
+                sql_target_column_types =
+                    sql_target_columns.iter().map(|column| Some(column.data_type.clone())).collect();
+
+                if request.create_table {
+                    if !target_table_preexisting {
+                        let ddl = generate_create_table_ddl(
+                            &sql_target_columns,
+                            &target_table,
+                            &request.source_schema,
+                            &request.target_schema,
+                            target_db_type,
+                            source_db_type,
+                            None,
+                        );
+                        let target_table_created = transfer_create_table_created(
+                            execute_on_pool(state, target_pool_key, &ddl).await.map(|_| ()),
+                            &format!("Failed to create table from MongoDB collection '{table}'"),
+                        )?;
+                        if target_table_created {
+                            for stmt in generate_comment_ddl(
+                                &sql_target_columns,
+                                &target_table,
+                                &request.target_schema,
+                                target_db_type,
+                                None,
+                            ) {
+                                if let Err(e) = execute_on_pool(state, target_pool_key, &stmt).await {
+                                    log::warn!(
+                                        "[transfer] failed to set MongoDB transfer column comment for {}: {}",
+                                        target_table,
+                                        e
+                                    );
+                                }
+                            }
+                        }
+                    } else {
+                        log::info!(
+                            "[transfer] target table {} already exists, skipping create-table DDL",
+                            target_table
+                        );
+                    }
+                }
+
+                if request.mode == TransferMode::Overwrite {
+                    let full_table = qualified_table(&target_table, &request.target_schema, target_db_type);
+                    let truncate_sql = match target_db_type {
+                        DatabaseType::Sqlite | DatabaseType::CloudflareD1 | DatabaseType::DuckDb => {
+                            format!("DELETE FROM {full_table}")
+                        }
+                        _ => format!("TRUNCATE TABLE {full_table}"),
+                    };
+                    execute_on_pool(state, target_pool_key, &truncate_sql)
+                        .await
+                        .map_err(|e| format!("Failed to truncate MongoDB transfer target table: {e}"))?;
+                }
+
+                sql_target_prepared = true;
+            }
+
+            let rows = if sql_target_column_names.len() == 1 && sql_target_column_names[0] == "document" {
+                documents.iter().map(|document| vec![document.clone()]).collect::<Vec<_>>()
+            } else {
+                mongo_documents_to_rows(&documents, &sql_target_column_names)
+            };
+            let write_statements = generate_transfer_write_sql_batches(
+                &TransferMode::Append,
+                &sql_target_column_names,
+                &sql_target_column_types,
+                &rows,
+                &target_table,
+                &request.target_schema,
+                target_db_type,
+                &[],
+            );
+            for (statement_index, batch_sql) in write_statements.iter().enumerate() {
+                execute_on_pool(state, target_pool_key, batch_sql).await.map_err(|e| {
+                    format!(
+                        "Insert failed for MongoDB collection '{target_table}' at offset {offset}, chunk {} of {}: {e}",
+                        statement_index + 1,
+                        write_statements.len()
+                    )
+                })?;
+            }
+        }
+
+        total_transferred += row_count as u64;
+        offset += row_count as u64;
+
+        progress_callback(TransferProgress {
+            transfer_id: request.transfer_id.clone(),
+            table: table.to_string(),
+            table_index,
+            total_tables,
+            rows_transferred: total_transferred,
+            total_rows,
+            status: TransferStatus::Running,
+            error: None,
+            terminal: false,
+        });
+
+        if row_count < batch_size {
+            break;
+        }
+    }
+
+    Ok(total_transferred)
+}
+
+/// Transfer a single table. Returns rows transferred.
+/// `progress_callback` is invoked for progress updates.
+#[allow(clippy::too_many_arguments)]
+pub async fn transfer_table<F>(
+    state: &AppState,
+    request: &TransferRequest,
+    table: &str,
+    table_index: usize,
+    source_db_type: &DatabaseType,
+    target_db_type: &DatabaseType,
+    source_pool_key: &str,
+    target_pool_key: &str,
+    mut progress_callback: F,
+) -> Result<u64, String>
+where
+    F: FnMut(TransferProgress),
+{
+    if is_mongodb_transfer_type(source_db_type) || is_mongodb_transfer_type(target_db_type) {
+        return transfer_mongodb_table(
+            state,
+            request,
+            table,
+            table_index,
+            source_db_type,
+            target_db_type,
+            source_pool_key,
+            target_pool_key,
+            progress_callback,
+        )
+        .await;
+    }
+
+    let total_tables = request.tables.len();
+    let pg_compat_transfer = is_postgres_compat_transfer(source_db_type, target_db_type);
+    let ResolvedTransferTargetTable { name: target_table, preexisting: mut target_table_preexisting } =
+        resolve_transfer_target_table_name(state, request, table, target_pool_key, target_db_type).await;
+    let preserves_target_table_name = target_table == table;
+
+    // Get source columns (deduplicate by name)
+    let columns = {
+        let raw = get_columns_for_transfer(
+            state,
+            source_pool_key,
+            &request.source_connection_id,
+            &request.source_database,
+            &request.source_schema,
+            table,
+        )
+        .await?;
+        let mut seen = std::collections::HashSet::new();
+        raw.into_iter().filter(|c| seen.insert(c.name.clone())).collect::<Vec<_>>()
+    };
+
+    if columns.is_empty() {
+        return Err(format!("No columns found for table {table}"));
+    }
+
+    let writable_columns = writable_transfer_columns(&columns, source_db_type, target_db_type);
+    if writable_columns.is_empty() {
+        return Err(format!("No writable columns found for table {table}"));
+    }
+
+    let col_names: Vec<String> = writable_columns.iter().map(|c| c.name.clone()).collect();
+    let col_types: Vec<Option<String>> = writable_columns.iter().map(|c| Some(c.data_type.clone())).collect();
+    let primary_key_columns: Vec<String> =
+        writable_columns.iter().filter(|c| c.is_primary_key).map(|c| c.name.clone()).collect();
+    log::info!("[transfer] {} has {} columns, counting rows...", table, columns.len());
+
+    // Fetch source table comment
+    let table_comment: Option<String> = crate::schema::list_tables_core(
+        state,
+        &request.source_connection_id,
+        &request.source_database,
+        &request.source_schema,
+        Some(table),
+        Some(1),
+        None,
+        None,
+    )
+    .await
+    .unwrap_or_default()
+    .into_iter()
+    .next()
+    .and_then(|t| t.comment);
+
+    let source_indexes =
+        if request.create_table && pg_compat_transfer && preserves_target_table_name && !target_table_preexisting {
+            get_postgres_indexes_for_transfer(state, source_pool_key, &request.source_schema, table).await?
+        } else {
+            Vec::new()
+        };
+    let source_foreign_keys =
+        if request.create_table && pg_compat_transfer && preserves_target_table_name && !target_table_preexisting {
+            get_postgres_foreign_keys_for_transfer(state, source_pool_key, &request.source_schema, table).await?
+        } else {
+            Vec::new()
+        };
+
+    // Count source rows
+    let total_rows = {
+        let sql = count_sql(table, &request.source_schema, source_db_type);
+        match execute_on_pool(state, source_pool_key, &sql).await {
+            Ok(result) => result.rows.first().and_then(|r| r.first()).and_then(|v| match v {
+                serde_json::Value::Number(n) => n.as_u64(),
+                serde_json::Value::String(s) => s.parse::<u64>().ok(),
+                _ => None,
+            }),
+            Err(e) => {
+                log::warn!("[transfer] count failed for {}: {}", table, e);
+                None
+            }
+        }
+    };
+    log::info!("[transfer] {} total_rows={:?}", table, total_rows);
+
+    // Create table on target if requested
+    if request.create_table {
+        if is_postgres_transfer_dialect(target_db_type) && !request.target_schema.trim().is_empty() {
+            let create_schema_sql =
+                format!("CREATE SCHEMA IF NOT EXISTS {}", quote_identifier(&request.target_schema, target_db_type));
+            execute_on_pool(state, target_pool_key, &create_schema_sql)
+                .await
+                .map_err(|e| format!("Failed to ensure schema exists: {e}"))?;
+        }
+        if target_table_preexisting {
+            log::info!("[transfer] target table {} already exists, skipping create-table DDL", target_table);
+        } else {
+            let owned_sequences = prepare_postgres_owned_sequences_for_transfer(
+                state,
+                request,
+                table,
+                &target_table,
+                source_pool_key,
+                target_pool_key,
+                pg_compat_transfer,
+                preserves_target_table_name,
+                target_table_preexisting,
+            )
+            .await?;
+            let can_reuse_source_ddl =
+                can_reuse_source_table_ddl(source_db_type, target_db_type, preserves_target_table_name);
+            let ddl = if can_reuse_source_ddl {
+                let source_ddl = crate::schema::get_table_ddl_core(
+                    &state,
+                    &request.source_connection_id,
+                    &request.source_database,
+                    &request.source_schema,
+                    table,
+                    None,
+                )
+                .await
+                .unwrap_or_else(|_| {
+                    generate_create_table_ddl(
+                        &columns,
+                        &target_table,
+                        &request.source_schema,
+                        &request.target_schema,
+                        target_db_type,
+                        source_db_type,
+                        table_comment.as_deref(),
+                    )
+                });
+                rewrite_transfer_source_table_ddl(
+                    &source_ddl,
+                    &request.source_schema,
+                    &request.target_schema,
+                    source_db_type,
+                    target_db_type,
+                )
+            } else {
+                generate_create_table_ddl(
+                    &columns,
+                    &target_table,
+                    &request.source_schema,
+                    &request.target_schema,
+                    target_db_type,
+                    source_db_type,
+                    table_comment.as_deref(),
+                )
+            };
+            log::info!("[transfer] creating target table: {}", ddl.chars().take(200).collect::<String>());
+            let target_table_created = transfer_create_table_created(
+                execute_transfer_ddl_on_pool(state, target_pool_key, &ddl, target_db_type).await,
+                "Failed to create table",
+            )?;
+            if target_table_created {
+                let comment_stmts = generate_comment_ddl(
+                    &columns,
+                    &target_table,
+                    &request.target_schema,
+                    target_db_type,
+                    table_comment.as_deref(),
+                );
+                for stmt in &comment_stmts {
+                    if let Err(e) = execute_on_pool(state, target_pool_key, stmt).await {
+                        log::warn!("[transfer] failed to set column comment for {}: {}", target_table, e);
+                    }
+                }
+                bind_postgres_owned_sequences_for_transfer(
+                    state,
+                    request,
+                    &target_table,
+                    target_pool_key,
+                    &owned_sequences,
+                )
+                .await?;
+            } else {
+                // DDL may report the table already exists even when metadata
+                // lookup missed it (case/schema differences or localized errors).
+                target_table_preexisting = true;
+            }
+        }
+    }
+
+    // Truncate target if overwrite mode
+    if request.mode == TransferMode::Overwrite {
+        let full_table = qualified_table(&target_table, &request.target_schema, target_db_type);
+        let truncate_sql = match target_db_type {
+            DatabaseType::Sqlite | DatabaseType::CloudflareD1 | DatabaseType::DuckDb => {
+                format!("DELETE FROM {full_table}")
+            }
+            _ => format!("TRUNCATE TABLE {full_table}"),
+        };
+        execute_on_pool(state, target_pool_key, &truncate_sql).await.map_err(|e| format!("Failed to truncate: {e}"))?;
+    }
+
+    // Determine effective mode and PK columns for upsert
+    let (effective_mode, pk_columns) = if request.mode == TransferMode::Upsert {
+        if matches!(target_db_type, DatabaseType::ClickHouse | DatabaseType::Hive) {
+            log::warn!("[transfer] upsert not supported for {:?}, falling back to append", target_db_type);
+            (TransferMode::Append, vec![])
+        } else {
+            let target_columns = get_columns_for_transfer(
+                state,
+                target_pool_key,
+                &request.target_connection_id,
+                &request.target_database,
+                &request.target_schema,
+                &target_table,
+            )
+            .await
+            .unwrap_or_default();
+            let pks: Vec<String> = target_columns
+                .iter()
+                .filter(|c| c.is_primary_key && col_names.iter().any(|name| name.eq_ignore_ascii_case(&c.name)))
+                .map(|c| c.name.clone())
+                .collect();
+            if pks.is_empty() {
+                log::warn!("[transfer] table {} has no primary key, falling back to append", table);
+                (TransferMode::Append, vec![])
+            } else {
+                (TransferMode::Upsert, pks)
+            }
+        }
+    } else {
+        (request.mode.clone(), vec![])
+    };
+
+    let writes_dameng_identity_columns = if matches!(target_db_type, DatabaseType::Dameng) {
+        let target_columns = get_columns_for_transfer(
+            state,
+            target_pool_key,
+            &request.target_connection_id,
+            &request.target_database,
+            &request.target_schema,
+            &target_table,
+        )
+        .await
+        .unwrap_or_default();
+        selected_columns_include_identity_columns(&col_names, &target_columns)
+    } else {
+        false
+    };
+
+    // Transfer data in batches
+    let batch_size = if request.batch_size == 0 { 1000 } else { request.batch_size };
+    let mut offset: u64 = 0;
+    let mut total_transferred: u64 = 0;
+
+    loop {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+
+        let sql = pagination_sql_with_order(
+            &col_names,
+            table,
+            &request.source_schema,
+            source_db_type,
+            offset,
+            batch_size,
+            &primary_key_columns,
+        );
+        let result = execute_on_pool(state, source_pool_key, &sql).await?;
+        let row_count = result.rows.len();
+
+        if row_count == 0 {
+            break;
+        }
+
+        let write_statements = generate_transfer_write_sql_batches(
+            &effective_mode,
+            &col_names,
+            &col_types,
+            &result.rows,
+            &target_table,
+            &request.target_schema,
+            target_db_type,
+            &pk_columns,
+        );
+        for (statement_index, batch_sql) in write_statements.iter().enumerate() {
+            execute_transfer_write_statement(
+                state,
+                target_pool_key,
+                batch_sql,
+                target_db_type,
+                &target_table,
+                &request.target_schema,
+                writes_dameng_identity_columns,
+            )
+            .await
+            .map_err(|e| {
+                let absolute_row = parse_mysql_row_error(&e).map(|row| offset + row);
+                match absolute_row {
+                    Some(row) => format!(
+                        "Insert failed for table '{target_table}' at row {row} (chunk {} of {}): {e}",
+                        statement_index + 1,
+                        write_statements.len()
+                    ),
+                    None => format!(
+                        "Insert failed for table '{target_table}' at offset {offset}, chunk {} of {}: {e}",
+                        statement_index + 1,
+                        write_statements.len()
+                    ),
+                }
+            })?;
+        }
+
+        total_transferred += row_count as u64;
+        log::info!("[transfer] {} batch +{} rows (total {})", table, row_count, total_transferred);
+        offset += row_count as u64;
+
+        progress_callback(TransferProgress {
+            transfer_id: request.transfer_id.clone(),
+            table: table.to_string(),
+            table_index,
+            total_tables,
+            rows_transferred: total_transferred,
+            total_rows,
+            status: TransferStatus::Running,
+            error: None,
+            terminal: false,
+        });
+
+        if row_count < batch_size {
+            break;
+        }
+    }
+
+    if pg_compat_transfer {
+        for statement in generate_postgres_sequence_sync_sql(&columns, &target_table, &request.target_schema) {
+            execute_on_pool(state, target_pool_key, &statement)
+                .await
+                .map_err(|e| format!("Failed to sync PostgreSQL sequence for {target_table}: {e}"))?;
+        }
+    }
+
+    if request.create_table && pg_compat_transfer && preserves_target_table_name && !target_table_preexisting {
+        for statement in generate_postgres_index_ddl(&source_indexes, &target_table, &request.target_schema) {
+            execute_on_pool(state, target_pool_key, &statement)
+                .await
+                .map_err(|e| format!("Failed to create PostgreSQL index for {target_table}: {e}"))?;
+        }
+        for statement in generate_postgres_foreign_key_ddl(
+            &source_foreign_keys,
+            &target_table,
+            &request.source_schema,
+            &request.target_schema,
+        ) {
+            execute_on_pool(state, target_pool_key, &statement)
+                .await
+                .map_err(|e| format!("Failed to create PostgreSQL foreign key for {target_table}: {e}"))?;
+        }
+    }
+
+    Ok(total_transferred)
+}
+
+pub async fn transfer_postgres_schema_dependencies<F>(
+    state: &AppState,
+    request: &TransferRequest,
+    source_pool_key: &str,
+    target_pool_key: &str,
+    mut progress_callback: F,
+) -> Result<(), String>
+where
+    F: FnMut(TransferProgress),
+{
+    let source_db_type = get_db_type(state, &request.source_connection_id).await?;
+    let target_db_type = get_db_type(state, &request.target_connection_id).await?;
+    if !request.create_table || !is_postgres_compat_transfer(&source_db_type, &target_db_type) {
+        return Ok(());
+    }
+
+    if !request.target_schema.trim().is_empty() {
+        let schema_exists =
+            execute_on_pool(state, target_pool_key, &postgres_schema_exists_sql(&request.target_schema))
+                .await
+                .map_err(|e| format!("Failed to check PostgreSQL target schema: {e}"))?;
+        if !query_result_has_rows(&schema_exists) {
+            // CREATE SCHEMA requires database-level CREATE privilege even with
+            // IF NOT EXISTS, so only issue it after confirming the schema is absent.
+            let create_schema_sql =
+                format!("CREATE SCHEMA {}", quote_identifier(&request.target_schema, &DatabaseType::Postgres));
+            execute_on_pool(state, target_pool_key, &create_schema_sql)
+                .await
+                .map_err(|e| format!("Failed to create PostgreSQL target schema: {e}"))?;
+        }
+    }
+
+    let extensions =
+        get_postgres_extension_sources_for_transfer(state, source_pool_key, &request.source_schema).await?;
+    let enum_types = get_postgres_enum_sources_for_transfer(state, source_pool_key, &request.source_schema).await?;
+    let domains = get_postgres_domain_sources_for_transfer(state, source_pool_key, &request.source_schema).await?;
+    let total_steps = extensions.len() + enum_types.len() + domains.len();
+    let table_index = 0;
+    let mut completed_steps = 0_u64;
+
+    for extension in extensions {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+        completed_steps += 1;
+        progress_callback(TransferProgress {
+            transfer_id: request.transfer_id.clone(),
+            table: format!("extension: {}", extension.extension_name),
+            table_index,
+            total_tables: request.tables.len(),
+            rows_transferred: completed_steps,
+            total_rows: Some(total_steps as u64),
+            status: TransferStatus::Running,
+            error: None,
+            terminal: false,
+        });
+        execute_on_pool(state, target_pool_key, &generate_postgres_extension_ddl(&extension, &request.target_schema))
+            .await
+            .map_err(|e| format!("Failed to create PostgreSQL extension {}: {e}", extension.extension_name))?;
+    }
+
+    for enum_type in enum_types {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+        completed_steps += 1;
+        progress_callback(TransferProgress {
+            transfer_id: request.transfer_id.clone(),
+            table: format!("enum: {}", enum_type.type_name),
+            table_index,
+            total_tables: request.tables.len(),
+            rows_transferred: completed_steps,
+            total_rows: Some(total_steps as u64),
+            status: TransferStatus::Running,
+            error: None,
+            terminal: false,
+        });
+        execute_on_pool(state, target_pool_key, &generate_postgres_enum_ddl(&enum_type, &request.target_schema))
+            .await
+            .map_err(|e| format!("Failed to create PostgreSQL enum {}: {e}", enum_type.type_name))?;
+    }
+
+    for domain in domains {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+        completed_steps += 1;
+        progress_callback(TransferProgress {
+            transfer_id: request.transfer_id.clone(),
+            table: format!("domain: {}", domain.domain_name),
+            table_index,
+            total_tables: request.tables.len(),
+            rows_transferred: completed_steps,
+            total_rows: Some(total_steps as u64),
+            status: TransferStatus::Running,
+            error: None,
+            terminal: false,
+        });
+        execute_on_pool(state, target_pool_key, &generate_postgres_domain_ddl(&domain, &request.target_schema))
+            .await
+            .map_err(|e| format!("Failed to create PostgreSQL domain {}: {e}", domain.domain_name))?;
+    }
+
+    Ok(())
+}
+
+pub async fn transfer_postgres_schema_objects<F>(
+    state: &AppState,
+    request: &TransferRequest,
+    source_pool_key: &str,
+    target_pool_key: &str,
+    mut progress_callback: F,
+) -> Result<(), String>
+where
+    F: FnMut(TransferProgress),
+{
+    let source_db_type = get_db_type(state, &request.source_connection_id).await?;
+    let target_db_type = get_db_type(state, &request.target_connection_id).await?;
+    if !request.create_table || !is_postgres_compat_transfer(&source_db_type, &target_db_type) {
+        return Ok(());
+    }
+
+    let object_sources =
+        get_postgres_schema_object_sources_for_transfer(state, source_pool_key, &request.source_schema).await?;
+    let materialized_views =
+        get_postgres_materialized_view_sources_for_transfer(state, source_pool_key, &request.source_schema).await?;
+    let trigger_sources =
+        get_postgres_trigger_sources_for_transfer(state, source_pool_key, &request.source_schema, &request.tables)
+            .await?;
+    let policy_statements = get_postgres_policy_statements_for_transfer(
+        state,
+        source_pool_key,
+        &request.source_schema,
+        &request.target_schema,
+        &request.tables,
+    )
+    .await?;
+    let ownership_statements = if matches!(request.ownership_policy, TransferOwnershipPolicy::Skip) {
+        Vec::new()
+    } else {
+        get_postgres_ownership_statements_for_transfer(
+            state,
+            source_pool_key,
+            &request.source_schema,
+            &request.target_schema,
+            &request.tables,
+        )
+        .await?
+    };
+    let ownership_existing_roles = if matches!(request.ownership_policy, TransferOwnershipPolicy::ReassignMissing) {
+        let roles = distinct_postgres_ownership_roles(&ownership_statements);
+        get_existing_postgres_roles(state, target_pool_key, &roles).await?
+    } else {
+        HashSet::new()
+    };
+    let ownership_target_user = if matches!(request.ownership_policy, TransferOwnershipPolicy::ReassignMissing)
+        && !ownership_statements.is_empty()
+    {
+        Some(get_postgres_current_user(state, target_pool_key).await?)
+    } else {
+        None
+    };
+    let grant_statements = get_postgres_grant_statements_for_transfer(
+        state,
+        source_pool_key,
+        &request.source_schema,
+        &request.target_schema,
+        &request.tables,
+    )
+    .await?;
+    let materialized_view_step_count = materialized_views
+        .iter()
+        .map(|view| generate_postgres_materialized_view_ddls(view, &request.target_schema).len())
+        .sum::<usize>();
+    let trigger_step_count = trigger_sources.len() * 2;
+    let total_steps = object_sources.len()
+        + materialized_view_step_count
+        + trigger_step_count
+        + policy_statements.len()
+        + ownership_statements.len()
+        + grant_statements.len();
+    let table_index = request.tables.len();
+    let mut completed_steps = 0_u64;
+
+    for object in object_sources {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+        completed_steps += 1;
+        progress_callback(TransferProgress {
+            transfer_id: request.transfer_id.clone(),
+            table: format!("schema object: {}", object.name),
+            table_index,
+            total_tables: request.tables.len(),
+            rows_transferred: completed_steps,
+            total_rows: Some(total_steps as u64),
+            status: TransferStatus::Running,
+            error: None,
+            terminal: false,
+        });
+
+        let rewritten_source = match object.object_type {
+            db::ObjectSourceKind::View | db::ObjectSourceKind::MaterializedView => object.source.clone(),
+            db::ObjectSourceKind::Procedure | db::ObjectSourceKind::Function => {
+                rewrite_postgres_routine_schema(&object.source, &request.source_schema, &request.target_schema)
+                    .unwrap_or_else(|| object.source.clone())
+            }
+            db::ObjectSourceKind::Sequence | db::ObjectSourceKind::Package | db::ObjectSourceKind::PackageBody => {
+                object.source.clone()
+            }
+        };
+        let statements = build_executable_object_source_statements(EditableObjectSourceSqlInput {
+            database_type: DatabaseType::Postgres,
+            object_type: object.object_type.clone(),
+            schema: Some(request.target_schema.clone()),
+            name: object.name.clone(),
+            source: rewritten_source,
+        })?;
+        for statement in statements {
+            execute_on_pool(state, target_pool_key, &statement)
+                .await
+                .map_err(|e| format!("Failed to create PostgreSQL {:?} {}: {e}", object.object_type, object.name))?;
+        }
+    }
+
+    for view in materialized_views {
+        for statement in generate_postgres_materialized_view_ddls(&view, &request.target_schema) {
+            if is_cancelled(&request.transfer_id).await {
+                return Err("Cancelled".to_string());
+            }
+            completed_steps += 1;
+            progress_callback(TransferProgress {
+                transfer_id: request.transfer_id.clone(),
+                table: format!("materialized view: {}", view.view_name),
+                table_index,
+                total_tables: request.tables.len(),
+                rows_transferred: completed_steps,
+                total_rows: Some(total_steps as u64),
+                status: TransferStatus::Running,
+                error: None,
+                terminal: false,
+            });
+            execute_on_pool(state, target_pool_key, &statement)
+                .await
+                .map_err(|e| format!("Failed to create PostgreSQL materialized view {}: {e}", view.view_name))?;
+        }
+    }
+
+    for trigger in trigger_sources {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+        completed_steps += 1;
+        progress_callback(TransferProgress {
+            transfer_id: request.transfer_id.clone(),
+            table: format!("trigger: {}", trigger.trigger_name),
+            table_index,
+            total_tables: request.tables.len(),
+            rows_transferred: completed_steps,
+            total_rows: Some(total_steps as u64),
+            status: TransferStatus::Running,
+            error: None,
+            terminal: false,
+        });
+        let full_table = qualified_table(&trigger.table_name, &request.target_schema, &DatabaseType::Postgres);
+        let drop_sql = format!(
+            "DROP TRIGGER IF EXISTS {} ON {full_table}",
+            quote_identifier(&trigger.trigger_name, &DatabaseType::Postgres)
+        );
+        execute_on_pool(state, target_pool_key, &drop_sql)
+            .await
+            .map_err(|e| format!("Failed to drop PostgreSQL trigger {}: {e}", trigger.trigger_name))?;
+        completed_steps += 1;
+        progress_callback(TransferProgress {
+            transfer_id: request.transfer_id.clone(),
+            table: format!("trigger: {}", trigger.trigger_name),
+            table_index,
+            total_tables: request.tables.len(),
+            rows_transferred: completed_steps,
+            total_rows: Some(total_steps as u64),
+            status: TransferStatus::Running,
+            error: None,
+            terminal: false,
+        });
+        let create_sql = rewrite_postgres_trigger_table_schema(
+            &ensure_sql_statement_terminated(&trigger.source),
+            &request.source_schema,
+            &trigger.table_name,
+            &request.target_schema,
+        );
+        execute_on_pool(state, target_pool_key, &create_sql)
+            .await
+            .map_err(|e| format!("Failed to create PostgreSQL trigger {}: {e}", trigger.trigger_name))?;
+    }
+
+    for statement in policy_statements {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+        completed_steps += 1;
+        progress_callback(TransferProgress {
+            transfer_id: request.transfer_id.clone(),
+            table: "row security policies".to_string(),
+            table_index,
+            total_tables: request.tables.len(),
+            rows_transferred: completed_steps,
+            total_rows: Some(total_steps as u64),
+            status: TransferStatus::Running,
+            error: None,
+            terminal: false,
+        });
+        execute_on_pool(state, target_pool_key, &statement)
+            .await
+            .map_err(|e| format!("Failed to apply PostgreSQL row security statement: {e}"))?;
+    }
+
+    for statement in ownership_statements {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+        completed_steps += 1;
+        progress_callback(TransferProgress {
+            transfer_id: request.transfer_id.clone(),
+            table: "ownership".to_string(),
+            table_index,
+            total_tables: request.tables.len(),
+            rows_transferred: completed_steps,
+            total_rows: Some(total_steps as u64),
+            status: TransferStatus::Running,
+            error: None,
+            terminal: false,
+        });
+        let ownership_owner = if matches!(request.ownership_policy, TransferOwnershipPolicy::ReassignMissing)
+            && !ownership_existing_roles.contains(&statement.owner)
+        {
+            ownership_target_user
+                .as_deref()
+                .ok_or_else(|| "Failed to read target PostgreSQL current user".to_string())?
+        } else {
+            &statement.owner
+        };
+        let ownership_sql = build_postgres_ownership_statement(&statement, ownership_owner);
+        execute_on_pool(state, target_pool_key, &ownership_sql)
+            .await
+            .map_err(|e| format!("Failed to apply PostgreSQL ownership statement: {e}"))?;
+    }
+
+    for statement in grant_statements {
+        if is_cancelled(&request.transfer_id).await {
+            return Err("Cancelled".to_string());
+        }
+        completed_steps += 1;
+        progress_callback(TransferProgress {
+            transfer_id: request.transfer_id.clone(),
+            table: "grants".to_string(),
+            table_index,
+            total_tables: request.tables.len(),
+            rows_transferred: completed_steps,
+            total_rows: Some(total_steps as u64),
+            status: TransferStatus::Running,
+            error: None,
+            terminal: false,
+        });
+        execute_on_pool(state, target_pool_key, &statement)
+            .await
+            .map_err(|e| format!("Failed to apply PostgreSQL grant statement: {e}"))?;
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[cfg(feature = "duckdb-bundled")]
+    use crate::connection::{AppState, PoolKind};
+    #[cfg(feature = "duckdb-bundled")]
+    use crate::models::connection::default_redis_key_separator;
+    #[cfg(feature = "duckdb-bundled")]
+    use crate::storage::Storage;
+    use serde_json::json;
+    #[cfg(feature = "duckdb-bundled")]
+    use std::sync::Arc;
+
+    #[cfg(feature = "duckdb-bundled")]
+    fn duckdb_test_config(id: &str) -> crate::models::connection::ConnectionConfig {
+        crate::models::connection::ConnectionConfig {
+            id: id.to_string(),
+            name: id.to_string(),
+            db_type: DatabaseType::DuckDb,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: ":memory:".to_string(),
+            port: 0,
+            username: String::new(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: 5,
+            query_timeout_secs: 30,
+            idle_timeout_secs: 60,
+            keepalive_interval_secs: 0,
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    fn test_column(name: &str, data_type: &str) -> db::ColumnInfo {
+        db::ColumnInfo {
+            name: name.to_string(),
+            data_type: data_type.to_string(),
+            is_nullable: true,
+            column_default: None,
+            is_primary_key: false,
+            extra: None,
+            comment: None,
+            numeric_precision: None,
+            numeric_scale: None,
+            character_maximum_length: None,
+            enum_values: None,
+            ..Default::default()
+        }
+    }
+
+    fn test_table(name: &str) -> db::TableInfo {
+        db::TableInfo {
+            name: name.to_string(),
+            table_type: "TABLE".to_string(),
+            comment: None,
+            parent_schema: None,
+            parent_name: None,
+        }
+    }
+
+    fn test_query_result(rows: Vec<Vec<serde_json::Value>>) -> db::QueryResult {
+        db::QueryResult {
+            columns: Vec::new(),
+            column_types: Vec::new(),
+            column_sortables: Vec::new(),
+            rows,
+            affected_rows: 0,
+            execution_time_ms: 0,
+            truncated: false,
+            session_id: None,
+            has_more: false,
+        }
+    }
+
+    #[test]
+    fn postgres_schema_exists_query_escapes_schema_name() {
+        assert_eq!(
+            postgres_schema_exists_sql("team's data"),
+            "SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = 'team''s data' LIMIT 1"
+        );
+    }
+
+    #[test]
+    fn postgres_schema_exists_depends_on_returned_rows() {
+        assert!(!query_result_has_rows(&test_query_result(Vec::new())));
+        assert!(query_result_has_rows(&test_query_result(vec![vec![serde_json::json!(1)]])));
+    }
+
+    fn test_transfer_request(tables: Vec<&str>) -> TransferRequest {
+        TransferRequest {
+            transfer_id: "transfer-1".to_string(),
+            source_connection_id: "source".to_string(),
+            source_database: "source_db".to_string(),
+            source_schema: "source_schema".to_string(),
+            target_connection_id: "target".to_string(),
+            target_database: "target_db".to_string(),
+            target_schema: "target_schema".to_string(),
+            tables: tables.into_iter().map(str::to_string).collect(),
+            create_table: true,
+            mode: TransferMode::Append,
+            target_table_name_case: TransferTableNameCase::Preserve,
+            ownership_policy: TransferOwnershipPolicy::Preserve,
+            batch_size: 1000,
+        }
+    }
+
+    #[test]
+    fn transfer_request_defaults_preserve_table_name_case() {
+        let request: TransferRequest = serde_json::from_value(json!({
+            "transferId": "transfer-1",
+            "sourceConnectionId": "source",
+            "sourceDatabase": "source_db",
+            "sourceSchema": "source_schema",
+            "targetConnectionId": "target",
+            "targetDatabase": "target_db",
+            "targetSchema": "target_schema",
+            "tables": ["ORDERS"],
+            "createTable": true,
+            "mode": "append",
+            "batchSize": 1000
+        }))
+        .unwrap();
+
+        assert_eq!(request.target_table_name_case, TransferTableNameCase::Preserve);
+        assert_eq!(request.target_table_name("ORDERS"), "ORDERS");
+    }
+
+    #[test]
+    fn transfer_existing_target_table_name_prefers_exact_case() {
+        let tables = vec![test_table("orders"), test_table("Orders")];
+
+        assert_eq!(existing_transfer_target_table_name("Orders", &tables, true), Some("Orders".to_string()));
+    }
+
+    #[test]
+    fn transfer_existing_target_table_name_respects_case_sensitive_targets() {
+        let tables = vec![test_table("Orders")];
+
+        assert_eq!(existing_transfer_target_table_name("orders", &tables, false), None);
+        assert_eq!(existing_transfer_target_table_name("orders", &tables, true), Some("Orders".to_string()));
+    }
+
+    #[test]
+    fn transfer_existing_target_table_name_ignores_contains_matches() {
+        let tables = vec![test_table("archived_orders"), test_table("orders_backup")];
+
+        assert_eq!(existing_transfer_target_table_name("orders", &tables, true), None);
+    }
+
+    #[test]
+    fn parses_mysql_lower_case_table_names_values() {
+        let string_result = test_query_result(vec![vec![json!("lower_case_table_names"), json!("2")]]);
+        let numeric_result = test_query_result(vec![vec![json!("lower_case_table_names"), json!(1)]]);
+        let empty_result = test_query_result(Vec::new());
+
+        assert_eq!(mysql_lower_case_table_names_from_result(&string_result), Some(2));
+        assert_eq!(mysql_lower_case_table_names_from_result(&numeric_result), Some(1));
+        assert_eq!(mysql_lower_case_table_names_from_result(&empty_result), None);
+    }
+
+    #[test]
+    fn transfer_table_name_case_transforms_target_names() {
+        let mut request = test_transfer_request(vec!["ORDERS"]);
+        request.target_table_name_case = TransferTableNameCase::Lower;
+        assert_eq!(request.target_table_name("ORDERS"), "orders");
+
+        request.target_table_name_case = TransferTableNameCase::Upper;
+        assert_eq!(request.target_table_name("orders"), "ORDERS");
+    }
+
+    #[test]
+    fn transfer_table_name_case_detects_target_collisions() {
+        let mut request = test_transfer_request(vec!["ORDERS", "orders"]);
+        request.target_table_name_case = TransferTableNameCase::Lower;
+
+        let error = validate_transfer_target_table_names(&request).unwrap_err();
+        assert!(error.contains("both map to 'orders'"));
+    }
+
+    #[test]
+    fn detects_identity_extras_for_selected_columns() {
+        assert!(selected_columns_include_identity_extras(
+            &[String::from("id"), String::from("name")],
+            &[Some(String::from("identity")), None],
+        ));
+        assert!(selected_columns_include_identity_extras(
+            &[String::from("id")],
+            &[Some(String::from("auto_increment"))],
+        ));
+        assert!(!selected_columns_include_identity_extras(
+            &[String::from("name")],
+            &[None, Some(String::from("identity"))],
+        ));
+    }
+
+    #[test]
+    fn detects_selected_identity_columns_from_target_metadata() {
+        let target_columns = vec![
+            db::ColumnInfo { extra: Some("identity".to_string()), ..test_column("ID", "INT") },
+            test_column("NAME", "VARCHAR(20)"),
+        ];
+
+        assert!(selected_columns_include_identity_columns(&[String::from("id")], &target_columns));
+        assert!(!selected_columns_include_identity_columns(&[String::from("name")], &target_columns));
+    }
+
+    #[test]
+    fn sqlserver_writable_transfer_columns_skip_rowversion_types() {
+        let columns = vec![
+            test_column("id", "int"),
+            test_column("TimeSpan", "timestamp"),
+            test_column("rv", "ROWVERSION"),
+            test_column("name", "nvarchar(64)"),
+        ];
+
+        let writable = writable_transfer_columns(&columns, &DatabaseType::SqlServer, &DatabaseType::SqlServer);
+
+        assert_eq!(writable.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(), vec!["id", "name"]);
+    }
+
+    #[test]
+    fn non_sqlserver_target_writable_transfer_columns_keep_timestamp_type() {
+        let columns = vec![test_column("id", "int"), test_column("updated_at", "timestamp")];
+
+        let writable = writable_transfer_columns(&columns, &DatabaseType::Postgres, &DatabaseType::Postgres);
+        assert_eq!(writable.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(), vec!["id", "updated_at"]);
+    }
+
+    #[test]
+    fn sqlserver_target_keeps_timestamp_from_other_source_databases() {
+        let columns = vec![test_column("id", "int"), test_column("updated_at", "timestamp")];
+
+        let writable = writable_transfer_columns(&columns, &DatabaseType::Postgres, &DatabaseType::SqlServer);
+
+        assert_eq!(writable.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(), vec!["id", "updated_at"]);
+    }
+
+    #[test]
+    fn dameng_identity_insert_wrapper_quotes_schema_and_table() {
+        let sql = wrap_dameng_identity_insert_sql(
+            "INSERT INTO \"SYSDBA\".\"USERS\" (\"ID\") VALUES\n(1);",
+            "USERS",
+            "SYSDBA",
+        );
+
+        assert_eq!(
+            sql,
+            "SET IDENTITY_INSERT \"SYSDBA\".\"USERS\" ON;\nINSERT INTO \"SYSDBA\".\"USERS\" (\"ID\") VALUES\n(1);\nSET IDENTITY_INSERT \"SYSDBA\".\"USERS\" OFF;"
+        );
+    }
+
+    #[test]
+    fn mysql_create_table_includes_column_comments() {
+        let cols = vec![
+            db::ColumnInfo { comment: Some("用户ID".to_string()), is_primary_key: true, ..test_column("id", "int") },
+            db::ColumnInfo {
+                comment: Some("用户姓名".to_string()),
+                is_nullable: false,
+                ..test_column("name", "VARCHAR(100)")
+            },
+            db::ColumnInfo { comment: None, ..test_column("age", "int") },
+        ];
+
+        let ddl = generate_create_table_ddl(&cols, "users", "", "", &DatabaseType::Mysql, &DatabaseType::Mysql, None);
+
+        assert!(ddl.contains("COMMENT '用户ID'"));
+        assert!(ddl.contains("COMMENT '用户姓名'"));
+        assert!(!ddl.contains("`age` INT COMMENT")); // no comment for age
+        assert!(ddl.contains("`name` VARCHAR(100) NOT NULL COMMENT '用户姓名'"));
+        assert!(ddl.contains("PRIMARY KEY (`id`)"));
+    }
+
+    #[test]
+    fn postgres_create_table_preserves_defaults_identity_and_exact_types() {
+        let cols = vec![
+            db::ColumnInfo {
+                data_type: "integer".to_string(),
+                column_default: Some("nextval('public.users_id_seq'::regclass)".to_string()),
+                is_primary_key: true,
+                is_nullable: false,
+                ..test_column("id", "integer")
+            },
+            db::ColumnInfo {
+                data_type: "timestamp with time zone".to_string(),
+                column_default: Some("now()".to_string()),
+                is_nullable: false,
+                ..test_column("created_at", "timestamp with time zone")
+            },
+            db::ColumnInfo {
+                data_type: "character varying(120)".to_string(),
+                column_default: Some("'guest'::character varying".to_string()),
+                ..test_column("name", "character varying(120)")
+            },
+        ];
+
+        let ddl = generate_create_table_ddl(
+            &cols,
+            "users",
+            "public",
+            "public",
+            &DatabaseType::Postgres,
+            &DatabaseType::Postgres,
+            None,
+        );
+
+        assert!(ddl.contains("\"id\" integer GENERATED BY DEFAULT AS IDENTITY NOT NULL"));
+        assert!(ddl.contains("\"created_at\" timestamp with time zone DEFAULT now() NOT NULL"));
+        assert!(ddl.contains("\"name\" character varying(120) DEFAULT 'guest'::character varying"));
+        assert!(ddl.contains("PRIMARY KEY (\"id\")"));
+    }
+
+    #[test]
+    fn postgres_create_table_rewrites_schema_qualified_custom_types_and_defaults() {
+        let cols = vec![db::ColumnInfo {
+            data_type: "\"public\".\"user_status\"".to_string(),
+            column_default: Some("'active'::public.user_status".to_string()),
+            is_nullable: false,
+            ..test_column("status", "\"public\".\"user_status\"")
+        }];
+
+        let ddl = generate_create_table_ddl(
+            &cols,
+            "users",
+            "public",
+            "archive",
+            &DatabaseType::Postgres,
+            &DatabaseType::Postgres,
+            None,
+        );
+
+        assert!(
+            ddl.contains("\"status\" \"archive\".\"user_status\" DEFAULT 'active'::\"archive\".user_status NOT NULL")
+        );
+    }
+
+    #[test]
+    fn mysql_create_table_includes_table_comment() {
+        let cols = vec![db::ColumnInfo { is_primary_key: true, ..test_column("id", "int") }];
+
+        let ddl = generate_create_table_ddl(
+            &cols,
+            "users",
+            "",
+            "",
+            &DatabaseType::Mysql,
+            &DatabaseType::Mysql,
+            Some("用户表"),
+        );
+
+        assert!(ddl.contains(") COMMENT='用户表'"));
+    }
+
+    #[test]
+    fn mysql_text_pk_gets_key_prefix() {
+        let cols =
+            vec![db::ColumnInfo { data_type: "text".to_string(), is_primary_key: true, ..test_column("id", "text") }];
+
+        let ddl = generate_create_table_ddl(&cols, "logs", "", "", &DatabaseType::Mysql, &DatabaseType::Sqlite, None);
+
+        assert!(ddl.contains("PRIMARY KEY (`id`(255))"));
+        assert!(ddl.contains("`id` TEXT"));
+    }
+
+    #[test]
+    fn mysql_int_pk_no_prefix() {
+        let cols = vec![db::ColumnInfo { is_primary_key: true, ..test_column("id", "int") }];
+
+        let ddl = generate_create_table_ddl(&cols, "users", "", "", &DatabaseType::Mysql, &DatabaseType::Sqlite, None);
+
+        assert!(ddl.contains("PRIMARY KEY (`id`)"));
+        assert!(!ddl.contains("PRIMARY KEY (`id`(255))"));
+    }
+
+    #[test]
+    fn postgres_comment_ddl_generates_column_and_table_comments() {
+        let cols = vec![
+            db::ColumnInfo { comment: Some("主键".to_string()), ..test_column("id", "int") },
+            db::ColumnInfo { comment: Some("名称".to_string()), ..test_column("name", "varchar(100)") },
+        ];
+
+        let stmts = generate_comment_ddl(&cols, "items", "public", &DatabaseType::Postgres, Some("项目表"));
+
+        assert_eq!(stmts.len(), 3);
+        assert!(stmts[0].contains("COMMENT ON TABLE \"public\".\"items\" IS '项目表'"));
+        assert!(stmts[1].contains("COMMENT ON COLUMN \"public\".\"items\".\"id\" IS '主键'"));
+        assert!(stmts[2].contains("COMMENT ON COLUMN \"public\".\"items\".\"name\" IS '名称'"));
+    }
+
+    #[test]
+    fn postgres_transfer_ddl_splits_reused_multi_statement_table_ddl() {
+        let ddl =
+            "CREATE TABLE \"public\".\"items\" (\"id\" integer);\nCOMMENT ON TABLE \"public\".\"items\" IS 'items';";
+
+        let statements = transfer_ddl_statements(ddl, &DatabaseType::Postgres);
+
+        assert_eq!(
+            statements,
+            vec![
+                "CREATE TABLE \"public\".\"items\" (\"id\" integer)".to_string(),
+                "COMMENT ON TABLE \"public\".\"items\" IS 'items'".to_string(),
+            ]
+        );
+    }
+
+    #[test]
+    fn postgres_transfer_ddl_skips_reused_index_statements() {
+        let ddl = "CREATE TABLE \"public\".\"items\" (\"id\" integer);\n\
+                   CREATE INDEX \"items_lower_idx\" ON \"public\".\"items\" USING btree (\"lower(name)\");\n\
+                   COMMENT ON INDEX \"public\".\"items_lower_idx\" IS 'lookup';";
+
+        let statements = transfer_ddl_statements(ddl, &DatabaseType::Postgres);
+
+        assert_eq!(statements, vec!["CREATE TABLE \"public\".\"items\" (\"id\" integer)".to_string()]);
+    }
+
+    #[test]
+    fn postgres_transfer_ddl_removes_inline_foreign_keys_from_reused_table_ddl() {
+        let ddl = "CREATE TABLE \"public\".\"audit_logs\" (\n  \"id\" integer,\n  \"user_id\" integer,\n  CONSTRAINT \"audit_logs_user_id_fkey\" FOREIGN KEY (\"user_id\") REFERENCES \"users\"(\"id\")\n);";
+
+        let statements = transfer_ddl_statements(ddl, &DatabaseType::Postgres);
+
+        assert_eq!(
+            statements,
+            vec!["CREATE TABLE \"public\".\"audit_logs\" (\n  \"id\" integer,\n  \"user_id\" integer\n)".to_string()]
+        );
+    }
+
+    #[test]
+    fn transfer_create_table_result_treats_existing_table_as_preexisting() {
+        assert_eq!(
+            transfer_create_table_created(
+                Err("ERROR: relation \"items\" already exists (SQLSTATE 42P07)".to_string()),
+                "create"
+            )
+            .unwrap(),
+            false
+        );
+        assert_eq!(
+            transfer_create_table_created(Err("错误: 关系 \"items\" 已经存在".to_string()), "create").unwrap(),
+            false
+        );
+        assert_eq!(transfer_create_table_created(Ok(()), "create").unwrap(), true);
+        assert_eq!(
+            transfer_create_table_created(Err("permission denied for schema public".to_string()), "create")
+                .unwrap_err(),
+            "create: permission denied for schema public"
+        );
+    }
+
+    #[test]
+    fn non_postgres_transfer_ddl_keeps_statement_text_intact() {
+        let ddl = "CREATE TABLE `items` (`id` int);\nALTER TABLE `items` COMMENT = 'items';";
+
+        assert_eq!(transfer_ddl_statements(ddl, &DatabaseType::Mysql), vec![ddl.to_string()]);
+    }
+
+    #[test]
+    fn clickhouse_comment_ddl_uses_alter_table() {
+        let cols = vec![db::ColumnInfo { comment: Some("日志消息".to_string()), ..test_column("message", "text") }];
+
+        let stmts = generate_comment_ddl(&cols, "logs", "", &DatabaseType::ClickHouse, None);
+
+        assert_eq!(stmts.len(), 1);
+        assert!(stmts[0].contains("ALTER TABLE `logs` COMMENT COLUMN `message` '日志消息'"));
+    }
+
+    #[test]
+    fn pg_comment_ddl_skips_empty_comments() {
+        let cols = vec![
+            db::ColumnInfo { comment: None, ..test_column("id", "int") },
+            db::ColumnInfo { comment: Some("  ".to_string()), ..test_column("name", "varchar(100)") },
+        ];
+
+        let stmts = generate_comment_ddl(&cols, "t", "", &DatabaseType::Postgres, None);
+
+        assert!(stmts.is_empty());
+    }
+
+    #[test]
+    fn non_mysql_family_no_inline_comment() {
+        let cols = vec![db::ColumnInfo { comment: Some("test".to_string()), ..test_column("col", "text") }];
+
+        // PostgreSQL target should NOT have inline COMMENT
+        let ddl = generate_create_table_ddl(&cols, "t", "", "", &DatabaseType::Postgres, &DatabaseType::Postgres, None);
+        assert!(!ddl.contains("COMMENT"));
+    }
+
+    #[test]
+    fn clickhouse_create_table_with_pk_uses_order_by_pk() {
+        let cols = vec![
+            db::ColumnInfo { is_primary_key: true, is_nullable: false, ..test_column("id", "UInt64") },
+            db::ColumnInfo { ..test_column("name", "String") },
+        ];
+
+        let ddl = generate_create_table_ddl(
+            &cols,
+            "logs",
+            "",
+            "",
+            &DatabaseType::ClickHouse,
+            &DatabaseType::ClickHouse,
+            None,
+        );
+
+        // Must include ENGINE with ORDER BY using the PK columns
+        assert!(ddl.contains("ENGINE = MergeTree() ORDER BY (`id`)"));
+        // Must NOT have a separate PRIMARY KEY clause (ORDER BY serves that role)
+        assert!(!ddl.contains("PRIMARY KEY"));
+    }
+
+    #[test]
+    fn clickhouse_create_table_without_pk_uses_order_by_tuple() {
+        let cols = vec![db::ColumnInfo { ..test_column("message", "String") }];
+
+        let ddl = generate_create_table_ddl(
+            &cols,
+            "logs",
+            "",
+            "",
+            &DatabaseType::ClickHouse,
+            &DatabaseType::ClickHouse,
+            None,
+        );
+
+        assert!(ddl.contains("ENGINE = MergeTree() ORDER BY tuple()"));
+        assert!(!ddl.contains("PRIMARY KEY"));
+    }
+
+    #[test]
+    fn clickhouse_transfer_maps_fractional_timestamp_to_datetime64() {
+        let cols = vec![db::ColumnInfo { numeric_scale: Some(6), ..test_column("created_at", "TIMESTAMP") }];
+
+        let ddl = generate_create_table_ddl(
+            &cols,
+            "events",
+            "SYSDBA",
+            "",
+            &DatabaseType::ClickHouse,
+            &DatabaseType::Dameng,
+            None,
+        );
+
+        assert!(ddl.contains("`created_at` DateTime64(6)"), "ddl: {ddl}");
+    }
+
+    #[test]
+    fn clickhouse_transfer_uses_datetime64_fallback_for_timestamp_types() {
+        assert_eq!(map_column_type("datetime", &DatabaseType::Dameng, &DatabaseType::ClickHouse), "DateTime64(6)");
+        assert_eq!(map_column_type("timestamp", &DatabaseType::Dameng, &DatabaseType::ClickHouse), "DateTime64(6)");
+    }
+
+    #[test]
+    fn transfer_reuses_source_table_ddl_only_when_target_shape_matches() {
+        assert!(!can_reuse_source_table_ddl(&DatabaseType::ClickHouse, &DatabaseType::ClickHouse, true));
+        assert!(can_reuse_source_table_ddl(&DatabaseType::Postgres, &DatabaseType::Postgres, true));
+        assert!(!can_reuse_source_table_ddl(&DatabaseType::Postgres, &DatabaseType::Postgres, false));
+    }
+
+    #[test]
+    fn postgres_transfer_reused_table_ddl_rewrites_target_schema() {
+        let ddl =
+            "CREATE TABLE \"src\".\"items\" (\"id\" integer);\nCOMMENT ON COLUMN \"src\".\"items\".\"id\" IS 'id';";
+
+        let rewritten =
+            rewrite_transfer_source_table_ddl(ddl, "src", "dst", &DatabaseType::Postgres, &DatabaseType::Postgres);
+
+        assert!(rewritten.contains("CREATE TABLE \"dst\".\"items\""));
+        assert!(rewritten.contains("COMMENT ON COLUMN \"dst\".\"items\".\"id\""));
+        assert!(!rewritten.contains("\"src\".\"items\""));
+    }
+
+    #[test]
+    fn hive_create_table_uses_hive_friendly_columns() {
+        let cols = vec![
+            db::ColumnInfo { is_primary_key: true, is_nullable: false, ..test_column("id", "bigint") },
+            db::ColumnInfo { is_nullable: false, ..test_column("payload", "json") },
+        ];
+
+        let ddl = generate_create_table_ddl(
+            &cols,
+            "events",
+            "public",
+            "warehouse",
+            &DatabaseType::Hive,
+            &DatabaseType::Postgres,
+            None,
+        );
+
+        assert!(ddl.contains("CREATE TABLE IF NOT EXISTS `warehouse`.`events`"));
+        assert!(ddl.contains("`id` BIGINT"));
+        assert!(ddl.contains("`payload` STRING"));
+        assert!(!ddl.contains("PRIMARY KEY"));
+        assert!(!ddl.contains("NOT NULL"));
+    }
+
+    #[test]
+    fn hive_transfer_uses_backticks_and_hive_type_mapping() {
+        assert_eq!(quote_identifier("user`events", &DatabaseType::Hive), "`user``events`");
+        assert_eq!(map_column_type("jsonb", &DatabaseType::Postgres, &DatabaseType::Hive), "STRING");
+        assert_eq!(
+            map_column_type("timestamp with time zone", &DatabaseType::Postgres, &DatabaseType::Hive),
+            "TIMESTAMP"
+        );
+    }
+
+    #[test]
+    fn mongo_transfer_document_fields_preserve_first_seen_order() {
+        let documents = vec![json!({"b": 1}), json!({"a": 2, "c": 3}), json!({"b": 4, "d": 5})];
+
+        assert_eq!(mongo_transfer_document_fields(&documents), vec!["b", "a", "c", "d"]);
+    }
+
+    #[test]
+    fn mongo_transfer_rows_fill_missing_fields_with_null() {
+        let rows = mongo_documents_to_rows(
+            &[json!({"id": 1, "name": "Ada"}), json!({"id": 2})],
+            &[String::from("id"), String::from("name")],
+        );
+
+        assert_eq!(rows, vec![vec![json!(1), json!("Ada")], vec![json!(2), serde_json::Value::Null]]);
+    }
+
+    #[test]
+    fn sql_rows_to_mongo_documents_maps_columns_to_fields() {
+        let documents = sql_rows_to_mongo_documents(
+            &[String::from("id"), String::from("name"), String::from("active")],
+            &[vec![json!(1), json!("Ada")], vec![json!(2), json!("Grace"), json!(true)]],
+        );
+
+        assert_eq!(
+            documents,
+            vec![json!({"id": 1, "name": "Ada", "active": null}), json!({"id": 2, "name": "Grace", "active": true})]
+        );
+    }
+
+    #[test]
+    fn postgres_pagination_uses_stable_primary_key_order() {
+        let sql = pagination_sql_with_order(
+            &[String::from("id"), String::from("name")],
+            "users",
+            "public",
+            &DatabaseType::Postgres,
+            200,
+            100,
+            &[String::from("id")],
+        );
+
+        assert_eq!(sql, "SELECT \"id\", \"name\" FROM \"public\".\"users\" ORDER BY \"id\" LIMIT 100 OFFSET 200");
+    }
+
+    #[test]
+    fn questdb_pagination_uses_stable_primary_key_order() {
+        let sql = pagination_sql_with_order(
+            &[String::from("id"), String::from("name")],
+            "users",
+            "public",
+            &DatabaseType::Questdb,
+            200,
+            100,
+            &[String::from("id")],
+        );
+
+        assert_eq!(sql, "SELECT `id`, `name` FROM `users` ORDER BY `id` LIMIT 200, 300");
+    }
+
+    #[test]
+    fn dameng_export_pagination_uses_offset_fetch() {
+        let sql = pagination_sql(
+            &[String::from("id"), String::from("name")],
+            "users",
+            "SYSDBA",
+            &DatabaseType::Dameng,
+            500,
+            100,
+        );
+
+        assert_eq!(
+            sql,
+            "SELECT \"id\", \"name\" FROM \"SYSDBA\".\"users\" ORDER BY (SELECT NULL) OFFSET 500 ROWS FETCH NEXT 100 ROWS ONLY"
+        );
+        assert!(!sql.contains(" LIMIT "));
+    }
+
+    #[test]
+    fn dameng_ordered_pagination_uses_offset_fetch() {
+        let sql = pagination_sql_with_order(
+            &[String::from("id"), String::from("name")],
+            "users",
+            "SYSDBA",
+            &DatabaseType::Dameng,
+            200,
+            100,
+            &[String::from("id")],
+        );
+
+        assert_eq!(
+            sql,
+            "SELECT \"id\", \"name\" FROM \"SYSDBA\".\"users\" ORDER BY \"id\" OFFSET 200 ROWS FETCH NEXT 100 ROWS ONLY"
+        );
+        assert!(!sql.contains(" LIMIT "));
+    }
+
+    #[test]
+    fn filtered_pagination_preserves_where_and_order() {
+        let sql = pagination_sql_with_filter_order(
+            &[String::from("id"), String::from("status")],
+            "users",
+            "public",
+            &DatabaseType::SapHana,
+            10_000,
+            2_000,
+            Some("WHERE status = 'active'"),
+            Some("\"id\" DESC"),
+            &[String::from("id")],
+        );
+
+        assert_eq!(
+            sql,
+            "SELECT \"id\", \"status\" FROM \"public\".\"users\" WHERE (status = 'active') ORDER BY \"id\" DESC LIMIT 2000 OFFSET 10000"
+        );
+    }
+
+    #[test]
+    fn dameng_filtered_pagination_preserves_where_and_order() {
+        let sql = pagination_sql_with_filter_order(
+            &[String::from("id"), String::from("status")],
+            "users",
+            "SYSDBA",
+            &DatabaseType::Dameng,
+            10_000,
+            2_000,
+            Some("WHERE status = 'active'"),
+            Some("\"id\" DESC"),
+            &[String::from("id")],
+        );
+
+        assert_eq!(
+            sql,
+            "SELECT \"id\", \"status\" FROM \"SYSDBA\".\"users\" WHERE (status = 'active') ORDER BY \"id\" DESC OFFSET 10000 ROWS FETCH NEXT 2000 ROWS ONLY"
+        );
+        assert!(!sql.contains(" LIMIT "));
+    }
+
+    #[test]
+    fn oracle_filtered_pagination_uses_rownum_for_legacy_compatibility() {
+        let sql = pagination_sql_with_filter_order(
+            &[String::from("id"), String::from("status")],
+            "users",
+            "APP",
+            &DatabaseType::Oracle,
+            10_000,
+            2_000,
+            Some("WHERE status = 'active'"),
+            Some("\"id\" DESC"),
+            &[String::from("id")],
+        );
+
+        assert_eq!(
+            sql,
+            "SELECT \"id\", \"status\" FROM (SELECT dbx_inner.*, ROWNUM AS \"__dbx_row_num\" FROM (SELECT \"id\", \"status\" FROM \"APP\".\"users\" WHERE (status = 'active') ORDER BY \"id\" DESC) dbx_inner WHERE ROWNUM <= 12000) WHERE \"__dbx_row_num\" > 10000"
+        );
+        assert!(!sql.contains("OFFSET"));
+        assert!(!sql.contains("FETCH NEXT"));
+    }
+
+    #[test]
+    fn filtered_count_preserves_where() {
+        let sql = count_sql_with_where("users", "public", &DatabaseType::SapHana, Some("WHERE status = 'active'"));
+
+        assert_eq!(sql, "SELECT COUNT(*) FROM \"public\".\"users\" WHERE (status = 'active')");
+    }
+
+    #[test]
+    fn sqlserver_keyset_pagination_includes_offset_fetch() {
+        let sql = keyset_pagination_sql(
+            &[String::from("id"), String::from("name")],
+            "users",
+            "dbo",
+            &DatabaseType::SqlServer,
+            &[String::from("id")],
+            &[],
+            100,
+        );
+
+        assert_eq!(
+            sql,
+            "SELECT [id], [name] FROM [dbo].[users] ORDER BY [id] ASC OFFSET 0 ROWS FETCH NEXT 100 ROWS ONLY"
+        );
+    }
+
+    #[test]
+    fn dameng_keyset_pagination_includes_offset_fetch() {
+        let sql = keyset_pagination_sql(
+            &[String::from("id"), String::from("name")],
+            "users",
+            "SYSDBA",
+            &DatabaseType::Dameng,
+            &[String::from("id")],
+            &[json!(25)],
+            100,
+        );
+
+        assert_eq!(
+            sql,
+            "SELECT \"id\", \"name\" FROM \"SYSDBA\".\"users\" WHERE \"id\" > 25 ORDER BY \"id\" ASC OFFSET 0 ROWS FETCH NEXT 100 ROWS ONLY"
+        );
+        assert!(!sql.contains(" LIMIT "));
+    }
+
+    #[test]
+    fn oracle_keyset_pagination_uses_rownum_for_legacy_compatibility() {
+        let sql = keyset_pagination_sql(
+            &[String::from("id"), String::from("name")],
+            "users",
+            "APP",
+            &DatabaseType::Oracle,
+            &[String::from("id")],
+            &[json!(25)],
+            100,
+        );
+
+        assert_eq!(
+            sql,
+            "SELECT \"id\", \"name\" FROM (SELECT \"id\", \"name\" FROM \"APP\".\"users\" WHERE \"id\" > 25 ORDER BY \"id\" ASC) WHERE ROWNUM <= 100"
+        );
+        assert!(!sql.contains("OFFSET"));
+        assert!(!sql.contains("FETCH NEXT"));
+    }
+
+    #[test]
+    fn composite_keyset_pagination_uses_portable_lexicographic_predicate() {
+        let sql = keyset_pagination_sql(
+            &[String::from("tenant_id"), String::from("id"), String::from("name")],
+            "users",
+            "dbo",
+            &DatabaseType::SqlServer,
+            &[String::from("tenant_id"), String::from("id")],
+            &[json!(10), json!(25)],
+            100,
+        );
+
+        assert_eq!(
+            sql,
+            "SELECT [tenant_id], [id], [name] FROM [dbo].[users] WHERE ([tenant_id] > 10 OR ([tenant_id] = 10 AND [id] > 25)) ORDER BY [tenant_id] ASC, [id] ASC OFFSET 0 ROWS FETCH NEXT 100 ROWS ONLY"
+        );
+    }
+
+    #[test]
+    fn postgres_generates_index_and_foreign_key_sql() {
+        let indexes = vec![db::IndexInfo {
+            name: "users_name_idx".to_string(),
+            columns: vec!["lower(name)".to_string()],
+            is_unique: false,
+            is_primary: false,
+            filter: Some("name IS NOT NULL".to_string()),
+            index_type: Some("btree".to_string()),
+            included_columns: Some(vec!["created_at".to_string()]),
+            comment: Some("lookup index".to_string()),
+        }];
+        let foreign_keys = vec![
+            db::ForeignKeyInfo {
+                name: "orders_user_id_fkey".to_string(),
+                column: "user_id".to_string(),
+                ref_schema: None,
+                ref_table: "users".to_string(),
+                ref_column: "id".to_string(),
+                on_update: None,
+                on_delete: None,
+            },
+            db::ForeignKeyInfo {
+                name: "orders_user_id_fkey".to_string(),
+                column: "tenant_id".to_string(),
+                ref_schema: None,
+                ref_table: "users".to_string(),
+                ref_column: "tenant_id".to_string(),
+                on_update: None,
+                on_delete: None,
+            },
+        ];
+
+        let index_sql = generate_postgres_index_ddl(&indexes, "users", "public");
+        let foreign_key_sql = generate_postgres_foreign_key_ddl(&foreign_keys, "orders", "public", "archive");
+
+        assert_eq!(
+            index_sql,
+            vec![
+                "CREATE INDEX IF NOT EXISTS \"users_name_idx\" ON \"public\".\"users\" USING btree (lower(name)) INCLUDE (\"created_at\") WHERE name IS NOT NULL".to_string(),
+                "COMMENT ON INDEX \"public\".\"users_name_idx\" IS 'lookup index'".to_string(),
+            ]
+        );
+        assert_eq!(
+            foreign_key_sql,
+            vec![
+                "ALTER TABLE \"archive\".\"orders\" ADD CONSTRAINT \"orders_user_id_fkey\" FOREIGN KEY (\"user_id\", \"tenant_id\") REFERENCES \"archive\".\"users\" (\"id\", \"tenant_id\")".to_string()
+            ]
+        );
+    }
+
+    #[test]
+    fn postgres_sequence_sync_sql_uses_table_max_values() {
+        let sql = generate_postgres_sequence_sync_sql(
+            &[
+                db::ColumnInfo {
+                    name: "id".to_string(),
+                    data_type: "integer".to_string(),
+                    is_nullable: false,
+                    column_default: Some("nextval('public.users_id_seq'::regclass)".to_string()),
+                    is_primary_key: true,
+                    extra: None,
+                    comment: None,
+                    numeric_precision: None,
+                    numeric_scale: None,
+                    character_maximum_length: None,
+                    enum_values: None,
+                    ..Default::default()
+                },
+                db::ColumnInfo {
+                    name: "identity_id".to_string(),
+                    data_type: "integer".to_string(),
+                    is_nullable: false,
+                    column_default: None,
+                    is_primary_key: false,
+                    extra: Some("generated by default as identity".to_string()),
+                    comment: None,
+                    numeric_precision: None,
+                    numeric_scale: None,
+                    character_maximum_length: None,
+                    enum_values: None,
+                    ..Default::default()
+                },
+                db::ColumnInfo {
+                    name: "computed_id".to_string(),
+                    data_type: "integer".to_string(),
+                    is_nullable: false,
+                    column_default: None,
+                    is_primary_key: false,
+                    extra: Some("generated always as (identity_id + 1) stored".to_string()),
+                    comment: None,
+                    numeric_precision: None,
+                    numeric_scale: None,
+                    character_maximum_length: None,
+                    enum_values: None,
+                    ..Default::default()
+                },
+            ],
+            "users",
+            "public",
+        );
+
+        assert_eq!(
+            sql,
+            vec![
+                "SELECT setval(pg_get_serial_sequence('\"public\".\"users\"', 'id'), GREATEST(COALESCE(MAX(\"id\"), 0), 1), MAX(\"id\") IS NOT NULL) FROM \"public\".\"users\"".to_string(),
+                "SELECT setval(pg_get_serial_sequence('\"public\".\"users\"', 'identity_id'), GREATEST(COALESCE(MAX(\"identity_id\"), 0), 1), MAX(\"identity_id\") IS NOT NULL) FROM \"public\".\"users\"".to_string()
+            ]
+        );
+    }
+
+    #[test]
+    fn postgres_transfer_owned_sequence_ddl_uses_precreate_and_post_bind_steps() {
+        let sequence = PostgresOwnedSequence {
+            name: "it_quick_entry_id_seq".to_string(),
+            owner_table: "it_quick_entry".to_string(),
+            owner_column: "id".to_string(),
+        };
+        let create_sql =
+            format!("CREATE SEQUENCE IF NOT EXISTS {}", postgres_sequence_qualified_name("public", &sequence.name));
+        let owner_sql = format!(
+            "ALTER SEQUENCE {} OWNED BY {}.{}",
+            postgres_sequence_qualified_name("public", &sequence.name),
+            qualified_table(&sequence.owner_table, "public", &DatabaseType::Postgres),
+            quote_identifier(&sequence.owner_column, &DatabaseType::Postgres)
+        );
+
+        assert_eq!(create_sql, "CREATE SEQUENCE IF NOT EXISTS \"public\".\"it_quick_entry_id_seq\"".to_string());
+        assert_eq!(
+            owner_sql,
+            "ALTER SEQUENCE \"public\".\"it_quick_entry_id_seq\" OWNED BY \"public\".\"it_quick_entry\".\"id\""
+                .to_string()
+        );
+    }
+
+    #[test]
+    fn postgres_owned_sequence_state_detects_conflicting_existing_sequence() {
+        let source = PostgresOwnedSequence {
+            name: "it_quick_entry_id_seq".to_string(),
+            owner_table: "it_quick_entry".to_string(),
+            owner_column: "id".to_string(),
+        };
+
+        let conflicting = PostgresSequenceSnapshot {
+            name: "it_quick_entry_id_seq".to_string(),
+            owner_table: Some("other_table".to_string()),
+            owner_column: Some("id".to_string()),
+        };
+
+        let error = validate_existing_postgres_sequence(&source, Some(&conflicting), "archive").unwrap_err();
+
+        assert!(error.contains("\"archive\".\"it_quick_entry_id_seq\""));
+        assert!(error.contains("already exists with incompatible ownership"));
+    }
+
+    #[test]
+    fn postgres_transfer_reused_table_ddl_preserves_serial_sequence_dependencies() {
+        let columns = vec![
+            db::ColumnInfo {
+                name: "id".to_string(),
+                data_type: "integer".to_string(),
+                is_nullable: false,
+                column_default: Some("nextval('public.it_quick_entry_id_seq'::regclass)".to_string()),
+                is_primary_key: true,
+                extra: None,
+                comment: None,
+                numeric_precision: None,
+                numeric_scale: None,
+                character_maximum_length: None,
+                enum_values: None,
+                ..Default::default()
+            },
+            db::ColumnInfo {
+                name: "name".to_string(),
+                data_type: "text".to_string(),
+                is_nullable: false,
+                column_default: None,
+                is_primary_key: false,
+                extra: None,
+                comment: None,
+                numeric_precision: None,
+                numeric_scale: None,
+                character_maximum_length: None,
+                enum_values: None,
+                ..Default::default()
+            },
+        ];
+        let source_ddl = crate::schema::render_postgres_table_ddl("public", "it_quick_entry", &columns, &[], &[]);
+        let rewritten = rewrite_transfer_source_table_ddl(
+            &source_ddl,
+            "public",
+            "archive",
+            &DatabaseType::Postgres,
+            &DatabaseType::Postgres,
+        );
+        let sequence = PostgresOwnedSequence {
+            name: "it_quick_entry_id_seq".to_string(),
+            owner_table: "it_quick_entry".to_string(),
+            owner_column: "id".to_string(),
+        };
+        let create_sql =
+            format!("CREATE SEQUENCE IF NOT EXISTS {}", postgres_sequence_qualified_name("archive", &sequence.name));
+        let owner_sql = format!(
+            "ALTER SEQUENCE {} OWNED BY {}.{}",
+            postgres_sequence_qualified_name("archive", &sequence.name),
+            qualified_table(&sequence.owner_table, "archive", &DatabaseType::Postgres),
+            quote_identifier(&sequence.owner_column, &DatabaseType::Postgres)
+        );
+        let sequence_sync_sql = generate_postgres_sequence_sync_sql(&columns, "it_quick_entry", "archive");
+
+        assert!(source_ddl.starts_with("CREATE TABLE \"public\".\"it_quick_entry\""));
+        assert!(!source_ddl.contains("CREATE SEQUENCE"));
+        assert!(rewritten.contains("CREATE TABLE \"archive\".\"it_quick_entry\""));
+        assert!(rewritten.contains("nextval('\"archive\".it_quick_entry_id_seq'::regclass)"));
+        assert_eq!(create_sql, "CREATE SEQUENCE IF NOT EXISTS \"archive\".\"it_quick_entry_id_seq\"".to_string());
+        assert_eq!(
+            owner_sql,
+            "ALTER SEQUENCE \"archive\".\"it_quick_entry_id_seq\" OWNED BY \"archive\".\"it_quick_entry\".\"id\""
+                .to_string()
+        );
+        assert_eq!(
+            sequence_sync_sql,
+            vec![
+                "SELECT setval(pg_get_serial_sequence('\"archive\".\"it_quick_entry\"', 'id'), GREATEST(COALESCE(MAX(\"id\"), 0), 1), MAX(\"id\") IS NOT NULL) FROM \"archive\".\"it_quick_entry\"".to_string()
+            ]
+        );
+    }
+
+    #[test]
+    fn postgres_routine_schema_rewrite_targets_destination_schema() {
+        let rewritten = rewrite_postgres_routine_schema(
+            "CREATE OR REPLACE FUNCTION public.bump_counter(id integer)\nRETURNS integer\nLANGUAGE plpgsql\nAS $$ BEGIN INSERT INTO public.audit_logs(user_id) VALUES (id); RETURN id + 1; END; $$",
+            "public",
+            "archive",
+        )
+        .unwrap();
+
+        assert!(rewritten.starts_with("CREATE OR REPLACE FUNCTION \"archive\".\"bump_counter\"("));
+        assert!(rewritten.contains("INSERT INTO \"archive\".audit_logs"));
+    }
+
+    #[test]
+    fn postgres_trigger_schema_rewrite_targets_destination_table() {
+        let rewritten = rewrite_postgres_trigger_table_schema(
+            "CREATE TRIGGER bump BEFORE INSERT ON public.users FOR EACH ROW EXECUTE FUNCTION public.bump_counter()",
+            "public",
+            "users",
+            "archive",
+        );
+
+        assert!(rewritten.contains(" ON \"archive\".\"users\" "));
+        assert!(rewritten.contains("EXECUTE FUNCTION \"archive\".bump_counter()"));
+    }
+
+    #[test]
+    fn postgres_extension_enum_and_domain_ddl_is_repeatable() {
+        let extension_sql = generate_postgres_extension_ddl(
+            &PostgresExtensionSource { extension_name: "pgcrypto".to_string() },
+            "archive",
+        );
+        let enum_sql = generate_postgres_enum_ddl(
+            &PostgresEnumSource {
+                type_name: "status".to_string(),
+                labels: vec!["pending".to_string(), "done".to_string()],
+            },
+            "archive",
+        );
+        let domain_sql = generate_postgres_domain_ddl(
+            &PostgresDomainSource {
+                domain_name: "email".to_string(),
+                base_type: "text".to_string(),
+                default_value: Some("'unknown@example.com'::text".to_string()),
+                not_null: true,
+                checks: vec!["CHECK ((VALUE ~* '^[^@]+@[^@]+$'::text))".to_string()],
+            },
+            "archive",
+        );
+
+        assert_eq!(extension_sql, "CREATE EXTENSION IF NOT EXISTS \"pgcrypto\" WITH SCHEMA \"archive\"");
+        assert!(enum_sql.contains("DO $$ BEGIN IF NOT EXISTS"));
+        assert!(enum_sql.contains("CREATE TYPE \"archive\".\"status\" AS ENUM ('pending', 'done')"));
+        assert!(domain_sql.contains("CREATE DOMAIN \"archive\".\"email\" AS text DEFAULT 'unknown@example.com'::text NOT NULL CHECK ((VALUE ~* '^[^@]+@[^@]+$'::text))"));
+    }
+
+    #[test]
+    fn postgres_materialized_view_ddls_drop_and_recreate_in_target_schema() {
+        let ddls = generate_postgres_materialized_view_ddls(
+            &PostgresMaterializedViewSource {
+                view_name: "active_users".to_string(),
+                source: "SELECT id, name FROM public.users WHERE active".to_string(),
+            },
+            "archive",
+        );
+
+        assert_eq!(ddls.len(), 2);
+        assert_eq!(ddls[0], "DROP MATERIALIZED VIEW IF EXISTS \"archive\".\"active_users\"");
+        assert_eq!(
+            ddls[1],
+            "CREATE MATERIALIZED VIEW \"archive\".\"active_users\" AS\nSELECT id, name FROM public.users WHERE active;"
+        );
+    }
+
+    #[test]
+    fn mysql_insert_normalizes_rfc3339_datetime_strings() {
+        let sql = generate_insert_typed(
+            &[String::from("insurance_start_time")],
+            &[Some(String::from("datetime"))],
+            &[vec![json!("2026-05-12T00:00:00+00:00")]],
+            "policies",
+            "",
+            &DatabaseType::Mysql,
+        );
+
+        assert_eq!(sql, "INSERT INTO `policies` (`insurance_start_time`) VALUES\n('2026-05-12 00:00:00')");
+    }
+
+    #[test]
+    fn mysql_insert_omits_database_qualified_table_name() {
+        let sql = generate_insert_typed(
+            &[String::from("id")],
+            &[Some(String::from("int"))],
+            &[vec![json!(1)]],
+            "users",
+            "app",
+            &DatabaseType::Mysql,
+        );
+
+        assert_eq!(sql, "INSERT INTO `users` (`id`) VALUES\n(1)");
+    }
+
+    #[test]
+    fn mysql_insert_uses_column_types_for_temporal_literals() {
+        let sql = generate_insert_typed(
+            &[String::from("dt"), String::from("raw_text"), String::from("d"), String::from("t")],
+            &[
+                Some(String::from("datetime")),
+                Some(String::from("varchar(64)")),
+                Some(String::from("date")),
+                Some(String::from("time")),
+            ],
+            &[vec![
+                json!("2026-05-12T00:00:00+00:00"),
+                json!("2026-05-12T00:00:00+00:00"),
+                json!("2026-05-12T00:00:00+00:00"),
+                json!("2026-05-12T09:30:45+00:00"),
+            ]],
+            "policies",
+            "",
+            &DatabaseType::Mysql,
+        );
+
+        assert_eq!(
+            sql,
+            "INSERT INTO `policies` (`dt`, `raw_text`, `d`, `t`) VALUES\n('2026-05-12 00:00:00', '2026-05-12T00:00:00+00:00', '2026-05-12', '09:30:45')"
+        );
+    }
+
+    #[test]
+    fn oracle_insert_uses_date_literals_for_date_columns() {
+        let sql = generate_insert_typed(
+            &[String::from("id"), String::from("created_on"), String::from("created_at"), String::from("raw_text")],
+            &[
+                Some(String::from("NUMBER")),
+                Some(String::from("DATE")),
+                Some(String::from("TIMESTAMP(6)")),
+                Some(String::from("VARCHAR2(64)")),
+            ],
+            &[vec![
+                json!(1),
+                json!("2022-08-25T09:58:43Z"),
+                json!("2022-08-25T09:58:43Z"),
+                json!("2022-08-25T09:58:43Z"),
+            ]],
+            "events",
+            "APP",
+            &DatabaseType::Oracle,
+        );
+
+        assert_eq!(
+            sql,
+            "INSERT INTO \"APP\".\"events\" (\"id\", \"created_on\", \"created_at\", \"raw_text\") VALUES\n(1, TO_DATE('2022-08-25 09:58:43', 'YYYY-MM-DD HH24:MI:SS'), '2022-08-25T09:58:43Z', '2022-08-25T09:58:43Z')"
+        );
+        assert_eq!(
+            escape_value_typed(&json!("2022-08-25T00:00:00Z"), &DatabaseType::Oracle, Some("DATE")),
+            "DATE '2022-08-25'"
+        );
+    }
+
+    #[test]
+    fn mysql_insert_formats_numeric_strings_from_numeric_columns_as_numeric_literals() {
+        let sql = generate_insert_typed(
+            &[
+                String::from("id"),
+                String::from("amount"),
+                String::from("quantity"),
+                String::from("text_id"),
+                String::from("bad_number"),
+                String::from("missing"),
+            ],
+            &[
+                Some(String::from("bigint(20)")),
+                Some(String::from("decimal(10,2)")),
+                Some(String::from("int unsigned")),
+                Some(String::from("varchar(64)")),
+                Some(String::from("bigint(20)")),
+                Some(String::from("bigint(20)")),
+            ],
+            &[vec![
+                json!("1234567890123"),
+                json!("12.34"),
+                json!("42"),
+                json!("123"),
+                json!("not-a-number"),
+                serde_json::Value::Null,
+            ]],
+            "orders",
+            "",
+            &DatabaseType::Mysql,
+        );
+
+        assert_eq!(
+            sql,
+            "INSERT INTO `orders` (`id`, `amount`, `quantity`, `text_id`, `bad_number`, `missing`) VALUES\n(1234567890123, 12.34, 42, '123', 'not-a-number', NULL)"
+        );
+    }
+
+    #[test]
+    fn mysql_upsert_formats_numeric_strings_from_numeric_columns_as_numeric_literals() {
+        let sql = generate_upsert_typed(
+            &[String::from("id"), String::from("amount")],
+            &[Some(String::from("bigint(20)")), Some(String::from("decimal(10,2)"))],
+            &[vec![json!("1234567890123"), json!("12.34")]],
+            "orders",
+            "",
+            &DatabaseType::Mysql,
+            &[String::from("id")],
+        );
+
+        assert_eq!(
+            sql,
+            "INSERT INTO `orders` (`id`, `amount`) VALUES\n(1234567890123, 12.34)\nON DUPLICATE KEY UPDATE `amount` = VALUES(`amount`)"
+        );
+    }
+
+    #[test]
+    fn sqlserver_insert_prefixes_string_literals_as_unicode() {
+        let sql = generate_insert_typed(
+            &[String::from("name"), String::from("note")],
+            &[Some(String::from("nvarchar(100)")), Some(String::from("varchar(100)"))],
+            &[vec![json!("Tiếng Việt"), json!("O'Brien")]],
+            "customers",
+            "dbo",
+            &DatabaseType::SqlServer,
+        );
+
+        assert_eq!(sql, "INSERT INTO [dbo].[customers] ([name], [note]) VALUES\n(N'Tiếng Việt', N'O''Brien')");
+    }
+
+    #[test]
+    fn sqlserver_insert_formats_datetime_literals_with_supported_precision() {
+        let sql = generate_insert_typed(
+            &[String::from("id"), String::from("date1"), String::from("date2"), String::from("note")],
+            &[
+                Some(String::from("int")),
+                Some(String::from("datetime")),
+                Some(String::from("datetime2(7)")),
+                Some(String::from("nvarchar(100)")),
+            ],
+            &[vec![
+                json!(1),
+                json!("2026-06-29 10:11:12.896666666"),
+                json!("2026-06-29T10:11:12.8966666Z"),
+                json!("2026-06-29 10:11:12.896666666"),
+            ]],
+            "test",
+            "dbo",
+            &DatabaseType::SqlServer,
+        );
+
+        assert_eq!(
+            sql,
+            "INSERT INTO [dbo].[test] ([id], [date1], [date2], [note]) VALUES\n(1, N'2026-06-29 10:11:12.897', N'2026-06-29 10:11:12.8966666', N'2026-06-29 10:11:12.896666666')"
+        );
+    }
+
+    #[test]
+    fn sqlserver_insert_formats_bit_booleans_as_numeric_literals() {
+        let sql = generate_insert_typed(
+            &[String::from("enabled"), String::from("deleted")],
+            &[Some(String::from("bit")), Some(String::from("BIT"))],
+            &[vec![json!(true), json!(false)]],
+            "flags",
+            "dbo",
+            &DatabaseType::SqlServer,
+        );
+
+        assert_eq!(sql, "INSERT INTO [dbo].[flags] ([enabled], [deleted]) VALUES\n(1, 0)");
+    }
+
+    #[test]
+    fn sqlserver_upsert_formats_bit_booleans_as_numeric_literals() {
+        let sql = generate_upsert_typed(
+            &[String::from("id"), String::from("enabled")],
+            &[Some(String::from("int")), Some(String::from("bit"))],
+            &[vec![json!(1), json!(true)]],
+            "flags",
+            "dbo",
+            &DatabaseType::SqlServer,
+            &[String::from("id")],
+        );
+
+        assert!(sql.contains("USING (VALUES\n(1, 1)\n)"));
+        assert!(!sql.contains("TRUE"));
+        assert!(!sql.contains("FALSE"));
+    }
+
+    #[test]
+    fn postgres_insert_preserves_json_escape_sequences() {
+        let sql = generate_insert_typed(
+            &[String::from("payload")],
+            &[Some(String::from("jsonb"))],
+            &[vec![json!(r#"{"message":"hello\nworld"}"#)]],
+            "events",
+            "public",
+            &DatabaseType::Postgres,
+        );
+
+        assert_eq!(
+            sql,
+            r#"INSERT INTO "public"."events" ("payload") VALUES
+('{"message":"hello\nworld"}')"#
+        );
+    }
+
+    #[test]
+    fn postgres_insert_preserves_text_backslashes() {
+        let sql = generate_insert_typed(
+            &[String::from("path")],
+            &[Some(String::from("text"))],
+            &[vec![json!(r#"C:\tmp\file.txt"#)]],
+            "files",
+            "public",
+            &DatabaseType::Postgres,
+        );
+
+        assert_eq!(
+            sql,
+            r#"INSERT INTO "public"."files" ("path") VALUES
+('C:\tmp\file.txt')"#
+        );
+    }
+
+    #[test]
+    fn postgres_insert_formats_bytea_prefixed_hex_as_binary_literal() {
+        let sql = generate_insert_typed(
+            &[String::from("id"), String::from("payload"), String::from("note")],
+            &[Some(String::from("integer")), Some(String::from("BYTEA")), Some(String::from("text"))],
+            &[vec![json!(1), json!("0x48656c6c6f"), json!("0x48656c6c6f")]],
+            "files",
+            "public",
+            &DatabaseType::Postgres,
+        );
+
+        assert_eq!(
+            sql,
+            r#"INSERT INTO "public"."files" ("id", "payload", "note") VALUES
+(1, decode('48656c6c6f', 'hex'), '0x48656c6c6f')"#
+        );
+    }
+
+    #[test]
+    fn mysql_insert_formats_blob_prefixed_hex_as_binary_literal() {
+        let sql = generate_insert_typed(
+            &[String::from("id"), String::from("payload"), String::from("empty_blob"), String::from("note")],
+            &[
+                Some(String::from("int")),
+                Some(String::from("MEDIUMBLOB")),
+                Some(String::from("blob")),
+                Some(String::from("varchar(64)")),
+            ],
+            &[vec![json!(1), json!("0x0001ABff"), json!("0X"), json!("0x0001ABff")]],
+            "files",
+            "",
+            &DatabaseType::Mysql,
+        );
+
+        assert_eq!(
+            sql,
+            r#"INSERT INTO `files` (`id`, `payload`, `empty_blob`, `note`) VALUES
+(1, 0x0001ABff, X'', '0x0001ABff')"#
+        );
+    }
+
+    #[test]
+    fn mysql_insert_keeps_invalid_blob_hex_as_string_literal() {
+        let sql = generate_insert_typed(
+            &[String::from("id"), String::from("payload")],
+            &[Some(String::from("int")), Some(String::from("mediumblob"))],
+            &[vec![json!(1), json!("0xnothex")]],
+            "files",
+            "",
+            &DatabaseType::Mysql,
+        );
+
+        assert_eq!(
+            sql,
+            r#"INSERT INTO `files` (`id`, `payload`) VALUES
+(1, '0xnothex')"#
+        );
+    }
+
+    #[test]
+    fn mysql_insert_keeps_backslash_escape_style() {
+        let sql = generate_insert_typed(
+            &[String::from("path")],
+            &[Some(String::from("varchar(255)"))],
+            &[vec![json!(r#"C:\tmp\file.txt"#)]],
+            "files",
+            "",
+            &DatabaseType::Mysql,
+        );
+
+        assert_eq!(
+            sql,
+            r#"INSERT INTO `files` (`path`) VALUES
+('C:\\tmp\\file.txt')"#
+        );
+    }
+
+    #[test]
+    fn oracle_single_row_insert_keeps_values_shape() {
+        let sql = generate_insert_typed(
+            &[String::from("id"), String::from("name")],
+            &[Some(String::from("number")), Some(String::from("varchar2(64)"))],
+            &[vec![json!(1), json!("Ada")]],
+            "INSTR_CATEGORY",
+            "APP",
+            &DatabaseType::Oracle,
+        );
+
+        assert_eq!(
+            sql,
+            r#"INSERT INTO "APP"."INSTR_CATEGORY" ("id", "name") VALUES
+(1, 'Ada')"#
+        );
+    }
+
+    #[test]
+    fn oracle_multi_row_insert_uses_insert_all() {
+        let sql = generate_insert_typed(
+            &[String::from("id"), String::from("name")],
+            &[Some(String::from("number")), Some(String::from("varchar2(64)"))],
+            &[vec![json!(1), json!("Ada")], vec![json!(2), json!("O'Brien")]],
+            "INSTR_CATEGORY",
+            "APP",
+            &DatabaseType::Oracle,
+        );
+
+        assert_eq!(
+            sql,
+            r#"INSERT ALL
+INTO "APP"."INSTR_CATEGORY" ("id", "name") VALUES (1, 'Ada')
+INTO "APP"."INSTR_CATEGORY" ("id", "name") VALUES (2, 'O''Brien')
+SELECT 1 FROM dual"#
+        );
+    }
+
+    #[test]
+    fn oracle_transfer_write_batches_limit_insert_all_rows() {
+        let rows = (0..(MAX_ORACLE_INSERT_ALL_ROWS + 1)).map(|index| vec![json!(index)]).collect::<Vec<_>>();
+        let statements = generate_transfer_write_sql_batches(
+            &TransferMode::Append,
+            &[String::from("id")],
+            &[Some(String::from("number"))],
+            &rows,
+            "INSTR_CATEGORY",
+            "APP",
+            &DatabaseType::Oracle,
+            &[],
+        );
+
+        assert_eq!(statements.len(), 2);
+        assert_eq!(statements[0].matches("\nINTO ").count(), MAX_ORACLE_INSERT_ALL_ROWS);
+        assert!(statements[0].starts_with("INSERT ALL\nINTO "));
+        assert!(statements[0].ends_with("SELECT 1 FROM dual"));
+    }
+
+    #[test]
+    fn transfer_write_sql_batches_split_large_insert_statements() {
+        let rows = (0..4).map(|index| vec![json!(index), json!("x".repeat(180 * 1024))]).collect::<Vec<_>>();
+        let statements = generate_transfer_write_sql_batches(
+            &TransferMode::Append,
+            &[String::from("id"), String::from("payload")],
+            &[Some(String::from("int")), Some(String::from("text"))],
+            &rows,
+            "events",
+            "",
+            &DatabaseType::Mysql,
+            &[],
+        );
+
+        assert!(statements.len() > 1);
+        assert!(statements.iter().all(|sql| sql.starts_with("INSERT INTO `events`")));
+    }
+
+    #[test]
+    fn transfer_write_sql_batches_keep_existing_upsert_sql_shape() {
+        let statements = generate_transfer_write_sql_batches(
+            &TransferMode::Upsert,
+            &[String::from("id"), String::from("name")],
+            &[Some(String::from("int")), Some(String::from("varchar(64)"))],
+            &[vec![json!(1), json!("Ada")]],
+            "users",
+            "",
+            &DatabaseType::Mysql,
+            &[String::from("id")],
+        );
+
+        assert_eq!(statements.len(), 1);
+        assert!(statements[0].contains("ON DUPLICATE KEY UPDATE"));
+    }
+
+    #[cfg(feature = "duckdb-bundled")]
+    #[tokio::test]
+    async fn duckdb_transfer_columns_use_requested_schema() {
+        let dir = std::env::temp_dir().join(format!("dbx-transfer-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let con = duckdb::Connection::open_in_memory().unwrap();
+        con.execute_batch("CREATE SCHEMA analytics; CREATE TABLE analytics.items(id INTEGER);").unwrap();
+
+        let state = AppState::new(storage);
+        let con = Arc::new(crate::db::duckdb_driver::DuckDbConnection::new(con));
+        state.connections.write().await.insert("duckdb-1".to_string(), PoolKind::DuckDb(con));
+        state.configs.write().await.insert("duckdb-1".to_string(), duckdb_test_config("duckdb-1"));
+
+        let columns =
+            get_columns_for_transfer(&state, "duckdb-1", "duckdb-1", "main", "analytics", "items").await.unwrap();
+
+        assert_eq!(columns.iter().map(|c| c.name.as_str()).collect::<Vec<_>>(), vec!["id"]);
+    }
+
+    #[test]
+    fn database_from_pool_key_handles_session_scoped_keys() {
+        assert_eq!(database_from_pool_key("conn:analytics"), Some("analytics"));
+        assert_eq!(database_from_pool_key("conn:analytics:session:editor-1"), Some("analytics"));
+        assert_eq!(database_from_pool_key("conn"), None);
+    }
+
+    #[test]
+    fn transfer_read_retry_policy_retries_connection_errors() {
+        assert_eq!(
+            transfer_pool_error_action(
+                TransferExecutionSafety::ReadOnlyRetryable,
+                Some(DatabaseType::Postgres),
+                "connection reset by peer"
+            ),
+            PoolErrorAction::ReconnectAndRetry
+        );
+    }
+
+    #[test]
+    fn transfer_write_retry_policy_discards_without_replaying_batch() {
+        assert_eq!(
+            transfer_pool_error_action(
+                TransferExecutionSafety::WriteNoReplay,
+                Some(DatabaseType::Postgres),
+                "connection reset by peer"
+            ),
+            PoolErrorAction::Discard
+        );
+    }
+
+    #[test]
+    fn map_column_type_preserves_longtext_for_mysql_target() {
+        assert_eq!(map_column_type("longtext", &DatabaseType::Mysql, &DatabaseType::Mysql), "longtext");
+    }
+
+    #[test]
+    fn map_column_type_preserves_mediumtext_for_mysql_target() {
+        assert_eq!(map_column_type("mediumtext", &DatabaseType::Mysql, &DatabaseType::Mysql), "mediumtext");
+    }
+
+    #[test]
+    fn map_column_type_preserves_longblob_for_mysql_target() {
+        assert_eq!(map_column_type("longblob", &DatabaseType::Mysql, &DatabaseType::Mysql), "longblob");
+    }
+
+    #[test]
+    fn map_column_type_preserves_mediumblob_for_mysql_target() {
+        assert_eq!(map_column_type("mediumblob", &DatabaseType::Mysql, &DatabaseType::Mysql), "mediumblob");
+    }
+
+    #[test]
+    fn map_column_type_preserves_same_database_type() {
+        assert_eq!(map_column_type("int unsigned", &DatabaseType::Mysql, &DatabaseType::Mysql), "int unsigned");
+        assert_eq!(
+            map_column_type("int unsigned zerofill", &DatabaseType::Mysql, &DatabaseType::Mysql),
+            "int unsigned zerofill"
+        );
+        assert_eq!(map_column_type("bigint unsigned", &DatabaseType::Mysql, &DatabaseType::Mysql), "bigint unsigned");
+        assert_eq!(
+            map_column_type("bigint unsigned zerofill", &DatabaseType::Mysql, &DatabaseType::Mysql),
+            "bigint unsigned zerofill"
+        );
+    }
+
+    #[test]
+    fn map_column_type_preserves_numeric_type_from_mysql_to_postgres() {
+        assert_eq!(map_column_type("int unsigned", &DatabaseType::Mysql, &DatabaseType::Postgres), "INTEGER");
+        assert_eq!(map_column_type("int unsigned zerofill", &DatabaseType::Mysql, &DatabaseType::Postgres), "INTEGER");
+        assert_eq!(map_column_type("bigint unsigned", &DatabaseType::Mysql, &DatabaseType::Postgres), "BIGINT");
+        assert_eq!(
+            map_column_type("bigint unsigned zerofill", &DatabaseType::Mysql, &DatabaseType::Postgres),
+            "BIGINT"
+        );
+    }
+
+    #[test]
+    fn map_column_type_longtext_falls_back_to_text_for_non_mysql_target() {
+        assert_eq!(map_column_type("longtext", &DatabaseType::Mysql, &DatabaseType::Postgres), "TEXT");
+    }
+
+    #[test]
+    fn map_column_type_longblob_falls_back_for_non_mysql_target() {
+        assert_eq!(map_column_type("longblob", &DatabaseType::Mysql, &DatabaseType::Postgres), "BYTEA");
+    }
+
+    #[test]
+    fn parse_mysql_row_error_extracts_row_number() {
+        let err = "ERROR 22001 (1406): Data too long column 'content' at row 8";
+        assert_eq!(parse_mysql_row_error(err), Some(8));
+    }
+
+    #[test]
+    fn parse_mysql_row_error_returns_none_for_non_mysql_error() {
+        assert_eq!(parse_mysql_row_error("some other error"), None);
+    }
+
+    #[test]
+    fn mysql_create_table_preserves_auto_increment_primary_key() {
+        let cols = vec![
+            db::ColumnInfo {
+                is_primary_key: true,
+                is_nullable: false,
+                extra: Some("auto_increment".to_string()),
+                ..test_column("id", "INT")
+            },
+            db::ColumnInfo { is_nullable: false, ..test_column("name", "varchar(64)") },
+        ];
+
+        let ddl = generate_create_table_ddl(&cols, "users", "", "", &DatabaseType::Mysql, &DatabaseType::Mysql, None);
+
+        assert!(ddl.contains("`id` INT NOT NULL AUTO_INCREMENT"), "ddl: {ddl}");
+        assert!(ddl.contains("PRIMARY KEY (`id`)"), "ddl: {ddl}");
+    }
+
+    #[test]
+    fn mysql_create_table_preserves_numeric_default_zero() {
+        let cols = vec![db::ColumnInfo {
+            is_nullable: false,
+            column_default: Some("0".to_string()),
+            ..test_column("status", "tinyint")
+        }];
+
+        let ddl = generate_create_table_ddl(&cols, "items", "", "", &DatabaseType::Mysql, &DatabaseType::Mysql, None);
+
+        assert!(ddl.contains("DEFAULT 0"), "ddl: {ddl}");
+        assert!(!ddl.contains("'0'"), "ddl should not quote numeric default: {ddl}");
+    }
+
+    #[test]
+    fn mysql_create_table_quotes_string_default_with_escape() {
+        let cols =
+            vec![db::ColumnInfo { column_default: Some("o'clock".to_string()), ..test_column("label", "varchar(32)") }];
+
+        let ddl = generate_create_table_ddl(&cols, "items", "", "", &DatabaseType::Mysql, &DatabaseType::Mysql, None);
+
+        assert!(ddl.contains("DEFAULT 'o''clock'"), "ddl: {ddl}");
+    }
+
+    #[test]
+    fn mysql_create_table_keeps_current_timestamp_default_and_on_update() {
+        let cols = vec![db::ColumnInfo {
+            is_nullable: false,
+            column_default: Some("CURRENT_TIMESTAMP".to_string()),
+            extra: Some("DEFAULT_GENERATED on update CURRENT_TIMESTAMP".to_string()),
+            ..test_column("updated_at", "timestamp")
+        }];
+
+        let ddl = generate_create_table_ddl(&cols, "items", "", "", &DatabaseType::Mysql, &DatabaseType::Mysql, None);
+
+        assert!(ddl.contains("DEFAULT CURRENT_TIMESTAMP"), "ddl: {ddl}");
+        assert!(ddl.contains("ON UPDATE CURRENT_TIMESTAMP"), "ddl: {ddl}");
+        assert!(ddl.contains("NOT NULL"), "ddl: {ddl}");
+        assert!(!ddl.contains("DEFAULT_GENERATED"), "ddl should not leak DEFAULT_GENERATED: {ddl}");
+    }
+
+    #[test]
+    fn mysql_create_table_keeps_current_timestamp_with_fsp() {
+        let cols = vec![db::ColumnInfo {
+            is_nullable: false,
+            column_default: Some("CURRENT_TIMESTAMP(6)".to_string()),
+            ..test_column("created_at", "timestamp(6)")
+        }];
+
+        let ddl = generate_create_table_ddl(&cols, "items", "", "", &DatabaseType::Mysql, &DatabaseType::Mysql, None);
+
+        assert!(ddl.contains("DEFAULT CURRENT_TIMESTAMP(6)"), "ddl: {ddl}");
+    }
+
+    #[test]
+    fn mysql_create_table_emits_on_update_without_default() {
+        let cols = vec![db::ColumnInfo {
+            is_nullable: false,
+            extra: Some("on update CURRENT_TIMESTAMP(3)".to_string()),
+            ..test_column("touched_at", "timestamp(3)")
+        }];
+
+        let ddl = generate_create_table_ddl(&cols, "items", "", "", &DatabaseType::Mysql, &DatabaseType::Mysql, None);
+
+        assert!(ddl.contains("ON UPDATE CURRENT_TIMESTAMP(3)"), "ddl: {ddl}");
+        assert!(!ddl.contains("DEFAULT"), "ddl should not emit DEFAULT when none was set: {ddl}");
+    }
+
+    #[test]
+    fn non_mysql_target_does_not_emit_auto_increment() {
+        let cols = vec![db::ColumnInfo {
+            is_primary_key: true,
+            is_nullable: false,
+            extra: Some("auto_increment".to_string()),
+            ..test_column("id", "int")
+        }];
+
+        let ddl = generate_create_table_ddl(&cols, "users", "", "", &DatabaseType::Sqlite, &DatabaseType::Mysql, None);
+
+        assert!(!ddl.contains("AUTO_INCREMENT"), "non-mysql target should not emit AUTO_INCREMENT: {ddl}");
+    }
+
+    #[test]
+    fn postgres_create_table_default_clause_unchanged() {
+        let cols = vec![db::ColumnInfo {
+            data_type: "integer".to_string(),
+            column_default: Some("nextval('public.t_id_seq'::regclass)".to_string()),
+            is_primary_key: true,
+            is_nullable: false,
+            ..test_column("id", "integer")
+        }];
+
+        let ddl = generate_create_table_ddl(
+            &cols,
+            "t",
+            "public",
+            "public",
+            &DatabaseType::Postgres,
+            &DatabaseType::Postgres,
+            None,
+        );
+
+        assert!(ddl.contains("GENERATED BY DEFAULT AS IDENTITY"), "ddl: {ddl}");
+    }
+
+    #[test]
+    fn postgres_create_table_preserves_identity_from_column_extra() {
+        let cols = vec![db::ColumnInfo {
+            data_type: "integer".to_string(),
+            extra: Some("generated by default as identity".to_string()),
+            is_primary_key: true,
+            is_nullable: false,
+            ..test_column("id", "integer")
+        }];
+
+        let ddl = generate_create_table_ddl(
+            &cols,
+            "t",
+            "public",
+            "public",
+            &DatabaseType::Postgres,
+            &DatabaseType::Postgres,
+            None,
+        );
+
+        assert!(ddl.contains("\"id\" integer generated by default as identity NOT NULL"), "ddl: {ddl}");
+    }
+
+    #[test]
+    fn kingbase_transfer_uses_postgres_compatible_types() {
+        assert_eq!(map_column_type("jsonb", &DatabaseType::Postgres, &DatabaseType::Kingbase), "JSONB");
+        assert_eq!(map_column_type("bytea", &DatabaseType::Postgres, &DatabaseType::Kingbase), "BYTEA");
+        assert_eq!(map_column_type("uuid", &DatabaseType::Postgres, &DatabaseType::Kingbase), "UUID");
+        assert_eq!(map_column_type("serial", &DatabaseType::Postgres, &DatabaseType::Kingbase), "SERIAL");
+    }
+
+    #[test]
+    fn kingbase_create_table_preserves_postgres_defaults() {
+        let cols = vec![db::ColumnInfo {
+            data_type: "integer".to_string(),
+            column_default: Some("nextval('source.items_id_seq'::regclass)".to_string()),
+            is_primary_key: true,
+            is_nullable: false,
+            ..test_column("id", "integer")
+        }];
+
+        let ddl = generate_create_table_ddl(
+            &cols,
+            "items",
+            "source",
+            "target",
+            &DatabaseType::Kingbase,
+            &DatabaseType::Postgres,
+            None,
+        );
+
+        assert!(ddl.contains("GENERATED BY DEFAULT AS IDENTITY"), "ddl: {ddl}");
+    }
+
+    #[test]
+    fn kingbase_upsert_uses_on_conflict() {
+        let sql = generate_upsert_typed(
+            &[String::from("id"), String::from("name")],
+            &[Some(String::from("integer")), Some(String::from("text"))],
+            &[vec![json!(1), json!("updated")]],
+            "items",
+            "public",
+            &DatabaseType::Kingbase,
+            &[String::from("id")],
+        );
+
+        assert!(sql.contains("ON CONFLICT (\"id\") DO UPDATE SET \"name\" = EXCLUDED.\"name\""), "sql: {sql}");
+    }
+
+    #[test]
+    fn kingbase_reused_ddl_uses_postgres_statement_sanitization() {
+        let ddl = r#"CREATE TABLE public.items (id integer PRIMARY KEY);
+CREATE INDEX items_name_idx ON public.items (id);"#;
+
+        let statements = transfer_ddl_statements(ddl, &DatabaseType::Kingbase);
+
+        assert_eq!(statements.len(), 1);
+        assert!(statements[0].starts_with("CREATE TABLE"));
+    }
+}
diff --git a/crates/dbx-core/src/types.rs b/crates/dbx-core/src/types.rs
new file mode 100644
index 0000000..1082774
--- /dev/null
+++ b/crates/dbx-core/src/types.rs
@@ -0,0 +1,312 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DatabaseInfo {
+    pub name: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SchemaInfo {
+    pub name: String,
+    pub comment: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct LinkedServerInfo {
+    pub name: String,
+    pub product: Option<String>,
+    pub provider: Option<String>,
+    pub data_source: Option<String>,
+}
+
+/// A catalog exposed by a multi-catalog engine (e.g. Doris / StarRocks).
+/// `internal` is the engine's native catalog; other entries are external
+/// catalogs (iceberg, hive, jdbc, ...) federated through the same connection.
+///
+/// Note: the built-in catalog is named `internal` in Doris (Type=`internal`)
+/// but `default_catalog` in StarRocks (Type=`Internal`). The `catalog_type`
+/// column is the cross-engine signal, so `is_internal()` matches it
+/// case-insensitively and falls back to the canonical Doris name when the
+/// column is absent (very old / proxied deployments).
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CatalogInfo {
+    pub name: String,
+    pub catalog_type: String,
+    pub is_current: bool,
+    pub comment: Option<String>,
+}
+
+impl CatalogInfo {
+    /// Whether this is the engine's built-in (non-federated) catalog.
+    pub fn is_internal(&self) -> bool {
+        if !self.catalog_type.trim().is_empty() {
+            self.catalog_type.eq_ignore_ascii_case("internal")
+        } else {
+            self.name == "internal"
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TableInfo {
+    pub name: String,
+    pub table_type: String, // "TABLE" or "VIEW"
+    pub comment: Option<String>,
+    pub parent_schema: Option<String>,
+    pub parent_name: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ObjectInfo {
+    pub name: String,
+    pub object_type: String,
+    pub schema: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub signature: Option<String>,
+    pub comment: Option<String>,
+    pub created_at: Option<String>,
+    pub updated_at: Option<String>,
+    pub parent_schema: Option<String>,
+    pub parent_name: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExtensionInfo {
+    pub name: String,
+    pub version: String,
+    pub comment: Option<String>,
+    pub schema: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ObjectStatistics {
+    pub name: String,
+    pub schema: Option<String>,
+    pub estimated_rows: Option<i64>,
+    pub total_bytes: Option<i64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum ObjectSourceKind {
+    View,
+    MaterializedView,
+    Procedure,
+    Function,
+    Sequence,
+    Package,
+    PackageBody,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ObjectSource {
+    pub name: String,
+    pub object_type: ObjectSourceKind,
+    pub schema: Option<String>,
+    pub source: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub editable: Option<bool>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ColumnInfo {
+    pub name: String,
+    pub data_type: String,
+    pub is_nullable: bool,
+    pub column_default: Option<String>,
+    pub is_primary_key: bool,
+    pub extra: Option<String>,
+    pub comment: Option<String>,
+    pub numeric_precision: Option<i32>,
+    pub numeric_scale: Option<i32>,
+    pub character_maximum_length: Option<i32>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub enum_values: Option<Vec<String>>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub character_set: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub collation: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum CompletionAssistantObjectKind {
+    Database,
+    Schema,
+    Table,
+    View,
+    Routine,
+    Procedure,
+    Function,
+    Column,
+}
+
+impl CompletionAssistantObjectKind {
+    pub fn is_table_like(&self) -> bool {
+        matches!(self, Self::Table | Self::View)
+    }
+
+    pub fn is_routine_like(&self) -> bool {
+        matches!(self, Self::Routine | Self::Procedure | Self::Function)
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum CompletionAssistantCandidateKind {
+    Database,
+    Schema,
+    Table,
+    View,
+    Procedure,
+    Function,
+    Column,
+    Object,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum CompletionAssistantMatchMode {
+    Prefix,
+    Contains,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CompletionAssistantRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub schema: Option<String>,
+    #[serde(default)]
+    pub object_kinds: Vec<CompletionAssistantObjectKind>,
+    #[serde(default)]
+    pub mask: String,
+    #[serde(default)]
+    pub case_sensitive: bool,
+    #[serde(default)]
+    pub global_search: bool,
+    pub max_results: Option<usize>,
+    #[serde(default)]
+    pub search_in_comments: bool,
+    #[serde(default)]
+    pub search_in_definitions: bool,
+    pub parent_schema: Option<String>,
+    pub parent_name: Option<String>,
+    pub match_mode: Option<CompletionAssistantMatchMode>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CompletionAssistantCandidate {
+    pub name: String,
+    pub kind: CompletionAssistantCandidateKind,
+    pub database: Option<String>,
+    pub schema: Option<String>,
+    pub parent_schema: Option<String>,
+    pub parent_name: Option<String>,
+    pub comment: Option<String>,
+    pub data_type: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CompletionAssistantResponse {
+    pub candidates: Vec<CompletionAssistantCandidate>,
+    pub incomplete: bool,
+    pub fallback_used: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct QueryResult {
+    pub columns: Vec<String>,
+    /// Database type name for each column, parallel to `columns`. May be empty
+    /// when a driver cannot supply types (e.g. schemaless stores or fallback
+    /// query paths); consumers must tolerate a shorter/empty vector.
+    #[serde(default)]
+    pub column_types: Vec<String>,
+    /// Sortable for each column. Parallel to `columns`. Optional and may
+    /// be shorter/empty when a driver cannot supply sortable information.
+    #[serde(default)]
+    pub column_sortables: Vec<bool>,
+    pub rows: Vec<Vec<serde_json::Value>>,
+    pub affected_rows: u64,
+    pub execution_time_ms: u128,
+    #[serde(default)]
+    pub truncated: bool,
+    #[serde(default)]
+    pub session_id: Option<String>,
+    #[serde(default)]
+    pub has_more: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IndexInfo {
+    pub name: String,
+    pub columns: Vec<String>,
+    pub is_unique: bool,
+    pub is_primary: bool,
+    pub filter: Option<String>,
+    pub index_type: Option<String>,
+    pub included_columns: Option<Vec<String>>,
+    pub comment: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ForeignKeyInfo {
+    pub name: String,
+    pub column: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub ref_schema: Option<String>,
+    pub ref_table: String,
+    pub ref_column: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub on_update: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub on_delete: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct TriggerInfo {
+    pub name: String,
+    pub event: String,
+    pub timing: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub statement: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FunctionInfo {
+    pub name: String,
+    pub function_type: String,
+    pub data_type: String,
+    pub definition: String,
+    pub arguments: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SequenceInfo {
+    pub name: String,
+    pub data_type: String,
+    pub start_value: String,
+    pub min_value: String,
+    pub max_value: String,
+    pub increment: String,
+    pub cycle: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub last_value: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RuleInfo {
+    pub name: String,
+    pub table_name: String,
+    pub definition: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct OwnerInfo {
+    pub object_name: String,
+    pub object_type: String,
+    pub owner: String,
+}
diff --git a/crates/dbx-core/src/update.rs b/crates/dbx-core/src/update.rs
new file mode 100644
index 0000000..7146985
--- /dev/null
+++ b/crates/dbx-core/src/update.rs
@@ -0,0 +1,450 @@
+use serde::{Deserialize, Serialize};
+
+const LATEST_JSON_PATH: &str = "https://github.com/t8y2/dbx/releases/latest/download/latest.json";
+const LATEST_JSON_R2_PATH: &str = "releases/latest/latest.json";
+const LATEST_EN_NOTES_R2_PATH: &str = "changelog/latest-en.json";
+const GITHUB_RELEASE_API_PREFIX: &str = "https://api.github.com/repos/t8y2/dbx/releases/tags/v";
+const RELEASE_URL_PREFIX: &str = "https://github.com/t8y2/dbx/releases/tag/v";
+
+#[derive(Debug, Deserialize)]
+pub struct TauriRelease {
+    pub version: String,
+    #[serde(default)]
+    pub notes: Option<String>,
+    #[serde(default)]
+    pub jdbc_plugin: Option<JdbcPluginLatest>,
+    #[serde(skip)]
+    pub github: Option<GithubReleaseMetadata>,
+    // 英文 release notes，由 R2 latest-en.json 填充（latest.json 不含此字段）。
+    // 仅当用户界面非中文时拉取，build_update_info 优先用它作为 release_notes。
+    #[serde(skip)]
+    pub notes_en: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+pub struct JdbcPluginLatest {
+    pub version: String,
+    pub protocol_version: u32,
+    pub url: String,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GithubReleaseMetadata {
+    pub name: Option<String>,
+    pub html_url: Option<String>,
+    pub body: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct UpdateInfo {
+    pub current_version: String,
+    pub latest_version: String,
+    pub update_available: bool,
+    pub portable_mode: bool,
+    pub release_name: String,
+    pub release_url: String,
+    pub release_notes: String,
+}
+
+pub async fn fetch_latest_release(locale: &str) -> Result<TauriRelease, String> {
+    let client = build_update_http_client()?;
+
+    let resp = crate::race_download(&client, LATEST_JSON_PATH, LATEST_JSON_R2_PATH, "dbx-update-checker")
+        .await
+        .map_err(|e| format!("Failed to check updates: {e}"))?;
+
+    let mut release = resp.json::<TauriRelease>().await.map_err(|e| format!("Failed to parse update response: {e}"))?;
+    if let Ok(github) = fetch_github_release_metadata(&client, &release.version).await {
+        release.github = Some(github);
+    }
+    // 非中文界面用户额外拉取英文 release notes；失败/版本不匹配则保持 None，上层回退中文。
+    if !is_chinese_locale(locale) {
+        if let Ok(notes_en) = fetch_latest_release_notes_en(&client, &release.version).await {
+            release.notes_en = Some(notes_en);
+        }
+    }
+    Ok(release)
+}
+
+// 拉取 R2 上的英文 release notes（仅最新版本）。version 必须与 latest.json 的 version 一致才采用，
+// 防止 sync-changelog 尚未更新时拿到旧版本英文 notes。
+async fn fetch_latest_release_notes_en(client: &reqwest::Client, expected_version: &str) -> Result<String, String> {
+    let url = format!("{}{LATEST_EN_NOTES_R2_PATH}", crate::R2_CDN_BASE);
+    let resp = client
+        .get(&url)
+        .header(reqwest::header::USER_AGENT, "dbx-update-checker")
+        .send()
+        .await
+        .and_then(|r| r.error_for_status())
+        .map_err(|e| format!("Failed to fetch English release notes: {e}"))?;
+    let data: LatestEnNotes = resp.json().await.map_err(|e| format!("Failed to parse English release notes: {e}"))?;
+    if normalize_version(&data.version) == normalize_version(expected_version) {
+        Ok(data.notes)
+    } else {
+        Err(format!("English release notes version {} mismatch expected {}", data.version, expected_version))
+    }
+}
+
+fn is_chinese_locale(locale: &str) -> bool {
+    locale == "zh-CN" || locale == "zh-TW"
+}
+
+#[derive(Debug, Deserialize)]
+struct LatestEnNotes {
+    version: String,
+    notes: String,
+}
+
+fn build_update_http_client() -> Result<reqwest::Client, String> {
+    let mut builder =
+        reqwest::Client::builder().timeout(std::time::Duration::from_secs(10)).user_agent("dbx-update-checker");
+
+    if let Some(proxy_url) = system_proxy_url() {
+        let proxy = reqwest::Proxy::all(&proxy_url).map_err(|e| format!("Invalid system proxy URL: {e}"))?;
+        builder = builder.proxy(proxy);
+    }
+
+    builder.build().map_err(|e| format!("Failed to create HTTP client: {e}"))
+}
+
+pub fn system_proxy_url() -> Option<String> {
+    system_proxy_url_from_platform()
+}
+
+#[cfg(target_os = "macos")]
+fn system_proxy_url_from_platform() -> Option<String> {
+    let output = crate::process::new_std_command("scutil").arg("--proxy").output().ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    let stdout = String::from_utf8(output.stdout).ok()?;
+    system_proxy_url_from_scutil_output(&stdout)
+}
+
+#[cfg(target_os = "windows")]
+fn system_proxy_url_from_platform() -> Option<String> {
+    let key = r"HKCU\Software\Microsoft\Windows\CurrentVersion\Internet Settings";
+    let proxy_enable =
+        crate::process::new_std_command("reg").args(["query", key, "/v", "ProxyEnable"]).output().ok()?;
+    let proxy_server =
+        crate::process::new_std_command("reg").args(["query", key, "/v", "ProxyServer"]).output().ok()?;
+    if !proxy_enable.status.success() || !proxy_server.status.success() {
+        return None;
+    }
+    let proxy_enable = String::from_utf8(proxy_enable.stdout).ok()?;
+    let proxy_server = String::from_utf8(proxy_server.stdout).ok()?;
+    system_proxy_url_from_windows_registry_output(&proxy_enable, &proxy_server)
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "windows")))]
+fn system_proxy_url_from_platform() -> Option<String> {
+    None
+}
+
+#[cfg_attr(not(test), allow(dead_code))]
+fn system_proxy_url_from_scutil_output(output: &str) -> Option<String> {
+    let value = |key: &str| {
+        output.lines().find_map(|line| {
+            let (line_key, line_value) = line.split_once(':')?;
+            (line_key.trim() == key).then(|| line_value.trim())
+        })
+    };
+
+    if value("HTTPSEnable") == Some("1") {
+        if let Some(url) = proxy_url(value("HTTPSProxy")?, value("HTTPSPort")?) {
+            return Some(url);
+        }
+    }
+
+    if value("HTTPEnable") == Some("1") {
+        if let Some(url) = proxy_url(value("HTTPProxy")?, value("HTTPPort")?) {
+            return Some(url);
+        }
+    }
+
+    None
+}
+
+#[cfg_attr(not(test), allow(dead_code))]
+fn system_proxy_url_from_windows_registry_output(proxy_enable: &str, proxy_server: &str) -> Option<String> {
+    let enabled = proxy_enable
+        .lines()
+        .find(|line| line.contains("ProxyEnable"))?
+        .split_whitespace()
+        .last()
+        .is_some_and(|value| value == "0x1" || value == "1");
+    if !enabled {
+        return None;
+    }
+
+    let server = proxy_server.lines().find(|line| line.contains("ProxyServer"))?.split_whitespace().last()?;
+
+    proxy_url_from_windows_proxy_server(server)
+}
+
+fn proxy_url_from_windows_proxy_server(server: &str) -> Option<String> {
+    let entries = server.split(';').map(str::trim).filter(|entry| !entry.is_empty()).collect::<Vec<_>>();
+
+    for key in ["https=", "http="] {
+        if let Some(entry) = entries.iter().find_map(|entry| entry.strip_prefix(key)) {
+            if let Some(url) = proxy_url_from_host_port(entry) {
+                return Some(url);
+            }
+        }
+    }
+
+    entries.iter().find(|entry| !entry.contains('=')).and_then(|entry| proxy_url_from_host_port(entry))
+}
+
+fn proxy_url_from_host_port(value: &str) -> Option<String> {
+    let value = value.trim();
+    if value.starts_with("http://") || value.starts_with("https://") {
+        return Some(value.to_string());
+    }
+    if value.starts_with("socks://") || value.starts_with("socks5://") || value.starts_with("socks5h://") {
+        return None;
+    }
+
+    let (host, port) = if let Some(rest) = value.strip_prefix('[') {
+        let (host, rest) = rest.split_once(']')?;
+        let port = rest.strip_prefix(':')?;
+        (host, port)
+    } else {
+        value.rsplit_once(':')?
+    };
+    proxy_url(host, port)
+}
+
+fn proxy_url(host: &str, port: &str) -> Option<String> {
+    if host.is_empty() || port.parse::<u16>().is_err() {
+        return None;
+    }
+    let host = if host.contains(':') && !host.starts_with('[') { format!("[{host}]") } else { host.to_string() };
+    Some(format!("http://{host}:{port}"))
+}
+
+async fn fetch_github_release_metadata(
+    client: &reqwest::Client,
+    version: &str,
+) -> Result<GithubReleaseMetadata, String> {
+    let url = format!("{GITHUB_RELEASE_API_PREFIX}{}", normalize_version(version));
+    client
+        .get(url)
+        .header(reqwest::header::USER_AGENT, "dbx-update-checker")
+        .send()
+        .await
+        .and_then(|r| r.error_for_status())
+        .map_err(|e| format!("{e}"))?
+        .json::<GithubReleaseMetadata>()
+        .await
+        .map_err(|e| format!("Failed to parse GitHub release response: {e}"))
+}
+
+pub fn build_update_info(release: TauriRelease, current_version: &str) -> UpdateInfo {
+    let latest_version = normalize_version(&release.version);
+    let github = release.github.as_ref();
+    let release_notes = non_empty(release.notes_en.as_deref())
+        .map(ToOwned::to_owned)
+        .or_else(|| github.and_then(|metadata| non_empty(metadata.body.as_deref())).map(ToOwned::to_owned))
+        .or(release.notes)
+        .unwrap_or_default();
+    let release_name = github
+        .and_then(|metadata| non_empty(metadata.name.as_deref()))
+        .map(ToOwned::to_owned)
+        .unwrap_or_else(|| format!("DBX v{latest_version}"));
+    let release_url = github
+        .and_then(|metadata| non_empty(metadata.html_url.as_deref()))
+        .map(ToOwned::to_owned)
+        .unwrap_or_else(|| format!("{RELEASE_URL_PREFIX}{latest_version}"));
+
+    UpdateInfo {
+        update_available: is_newer_version(&latest_version, current_version),
+        portable_mode: false,
+        current_version: current_version.to_string(),
+        release_name,
+        release_url,
+        release_notes,
+        latest_version,
+    }
+}
+
+fn non_empty(value: Option<&str>) -> Option<&str> {
+    value.and_then(|value| {
+        let trimmed = value.trim();
+        if trimmed.is_empty() {
+            None
+        } else {
+            Some(value)
+        }
+    })
+}
+
+pub fn normalize_version(version: &str) -> String {
+    version.trim().trim_start_matches('v').to_string()
+}
+
+pub fn parse_version(version: &str) -> Vec<u64> {
+    normalize_version(version).split(['.', '-', '+']).map(|part| part.parse::<u64>().unwrap_or(0)).collect()
+}
+
+pub fn is_newer_version(latest: &str, current: &str) -> bool {
+    let latest_parts = parse_version(latest);
+    let current_parts = parse_version(current);
+    let max_len = latest_parts.len().max(current_parts.len());
+
+    for i in 0..max_len {
+        let latest_part = *latest_parts.get(i).unwrap_or(&0);
+        let current_part = *current_parts.get(i).unwrap_or(&0);
+        if latest_part > current_part {
+            return true;
+        }
+        if latest_part < current_part {
+            return false;
+        }
+    }
+
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        build_update_info, is_newer_version, normalize_version, system_proxy_url_from_scutil_output,
+        system_proxy_url_from_windows_registry_output, GithubReleaseMetadata, TauriRelease,
+    };
+
+    #[test]
+    fn normalizes_tag_versions() {
+        assert_eq!(normalize_version("v1.2.3"), "1.2.3");
+        assert_eq!(normalize_version(" 0.2.0 "), "0.2.0");
+    }
+
+    #[test]
+    fn compares_semver_like_versions() {
+        assert!(is_newer_version("0.2.1", "0.2.0"));
+        assert!(is_newer_version("1.0.0", "0.9.9"));
+        assert!(!is_newer_version("0.2.0", "0.2.0"));
+        assert!(!is_newer_version("0.1.9", "0.2.0"));
+    }
+
+    #[test]
+    fn parses_macos_https_system_proxy() {
+        let output = r#"<dictionary> {
+  HTTPEnable : 1
+  HTTPPort : 7890
+  HTTPProxy : 127.0.0.1
+  HTTPSEnable : 1
+  HTTPSPort : 7891
+  HTTPSProxy : 127.0.0.1
+}"#;
+
+        assert_eq!(system_proxy_url_from_scutil_output(output), Some("http://127.0.0.1:7891".to_string()));
+    }
+
+    #[test]
+    fn falls_back_to_macos_http_system_proxy() {
+        let output = r#"<dictionary> {
+  HTTPEnable : 1
+  HTTPPort : 7890
+  HTTPProxy : 127.0.0.1
+  HTTPSEnable : 0
+}"#;
+
+        assert_eq!(system_proxy_url_from_scutil_output(output), Some("http://127.0.0.1:7890".to_string()));
+    }
+
+    #[test]
+    fn ignores_disabled_or_incomplete_macos_system_proxy() {
+        assert_eq!(system_proxy_url_from_scutil_output("HTTPEnable : 0\nHTTPProxy : 127.0.0.1\nHTTPPort : 7890"), None);
+        assert_eq!(system_proxy_url_from_scutil_output("HTTPEnable : 1\nHTTPProxy : 127.0.0.1"), None);
+    }
+
+    #[test]
+    fn parses_windows_system_proxy() {
+        let enabled = r#"
+HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings
+    ProxyEnable    REG_DWORD    0x1
+"#;
+        let server = r#"
+HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings
+    ProxyServer    REG_SZ    http=127.0.0.1:7890;https=127.0.0.1:7891
+"#;
+
+        assert_eq!(
+            system_proxy_url_from_windows_registry_output(enabled, server),
+            Some("http://127.0.0.1:7891".to_string())
+        );
+    }
+
+    #[test]
+    fn ignores_disabled_windows_system_proxy() {
+        let disabled = "ProxyEnable    REG_DWORD    0x0";
+        let server = "ProxyServer    REG_SZ    127.0.0.1:7890";
+
+        assert_eq!(system_proxy_url_from_windows_registry_output(disabled, server), None);
+    }
+
+    #[test]
+    fn parses_jdbc_plugin_metadata_from_latest_json() {
+        let release: TauriRelease = serde_json::from_str(
+            r#"{
+              "version": "0.5.12",
+              "jdbc_plugin": {
+                "version": "0.1.3",
+                "protocol_version": 1,
+                "url": "https://github.com/t8y2/dbx/releases/latest/download/dbx-jdbc-plugin-latest.zip"
+              },
+              "platforms": {}
+            }"#,
+        )
+        .unwrap();
+
+        let jdbc = release.jdbc_plugin.unwrap();
+
+        assert_eq!(jdbc.version, "0.1.3");
+        assert_eq!(jdbc.protocol_version, 1);
+        assert_eq!(jdbc.url, "https://github.com/t8y2/dbx/releases/latest/download/dbx-jdbc-plugin-latest.zip");
+    }
+
+    #[test]
+    fn update_info_prefers_github_release_metadata() {
+        let release = TauriRelease {
+            version: "0.5.3".to_string(),
+            notes: Some("See the assets below to download and install.".to_string()),
+            jdbc_plugin: None,
+            github: Some(GithubReleaseMetadata {
+                name: Some("DBX v0.5.3".to_string()),
+                html_url: Some("https://github.com/t8y2/dbx/releases/tag/v0.5.3".to_string()),
+                body: Some("### 新功能\n\n真实发布说明".to_string()),
+            }),
+            notes_en: None,
+        };
+
+        let info = build_update_info(release, "0.5.2");
+
+        assert_eq!(info.release_name, "DBX v0.5.3");
+        assert_eq!(info.release_url, "https://github.com/t8y2/dbx/releases/tag/v0.5.3");
+        assert_eq!(info.release_notes, "### 新功能\n\n真实发布说明");
+        assert!(!info.portable_mode);
+    }
+
+    #[test]
+    fn update_info_prefers_english_notes_when_present() {
+        // 非中文界面用户：notes_en 命中时优先于 GitHub 中文 body，应用内更新提示展示英文
+        let release = TauriRelease {
+            version: "0.5.3".to_string(),
+            notes: Some("See the assets below to download and install.".to_string()),
+            jdbc_plugin: None,
+            github: Some(GithubReleaseMetadata {
+                name: Some("DBX v0.5.3".to_string()),
+                html_url: Some("https://github.com/t8y2/dbx/releases/tag/v0.5.3".to_string()),
+                body: Some("### 新功能\n\n真实发布说明".to_string()),
+            }),
+            notes_en: Some("### New Features\n\nReal release notes".to_string()),
+        };
+
+        let info = build_update_info(release, "0.5.2");
+
+        assert_eq!(info.release_notes, "### New Features\n\nReal release notes");
+    }
+}
diff --git a/crates/dbx-core/src/xlsx_export.rs b/crates/dbx-core/src/xlsx_export.rs
new file mode 100644
index 0000000..51b02d1
--- /dev/null
+++ b/crates/dbx-core/src/xlsx_export.rs
@@ -0,0 +1,689 @@
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use std::io::{Cursor, Seek, Write};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct XlsxWorksheetData {
+    pub sheet_name: Option<String>,
+    pub columns: Vec<String>,
+    #[serde(default)]
+    pub column_types: Vec<String>,
+    pub rows: Vec<Vec<Value>>,
+}
+
+/// Streaming XLSX writer that incrementally writes rows to a ZIP-backed
+/// workbook.  This avoids accumulating all rows in memory before building the
+/// final file, drastically reducing peak memory for large exports.
+pub struct StreamingXlsxWriter<W: Write + Seek> {
+    zip: zip::ZipWriter<W>,
+    columns: Vec<String>,
+    column_types: Vec<String>,
+    next_row_number: usize,
+}
+
+/// Estimate column widths from header names only (used by the streaming path
+/// where full row data is not available up-front).  Each width is clamped to
+/// [10, 60] to stay within reasonable bounds.
+fn estimate_header_widths(columns: &[String]) -> Vec<usize> {
+    columns.iter().map(|col| (col.chars().count() + 2).clamp(10, 60)).collect()
+}
+
+/// Build the `<cols>` XML fragment from a width slice.
+fn cols_xml(widths: &[usize]) -> String {
+    widths
+        .iter()
+        .enumerate()
+        .map(|(index, width)| {
+            format!("<col min=\"{}\" max=\"{}\" width=\"{}\" customWidth=\"1\"/>", index + 1, index + 1, width)
+        })
+        .collect()
+}
+
+/// Build a single `<row>` XML fragment for the header row (row 1).
+pub(crate) fn header_row_xml(columns: &[String]) -> String {
+    format!(
+        "<row r=\"1\">{}</row>",
+        columns
+            .iter()
+            .enumerate()
+            .map(|(index, col)| cell_xml(Some(&Value::String(col.clone())), 0, index, Some(1)))
+            .collect::<String>()
+    )
+}
+
+/// Build a single `<row>` XML fragment for a data row.
+pub(crate) fn data_row_xml(row_number: usize, columns: &[String], column_types: &[String], row: &[Value]) -> String {
+    let cells = columns
+        .iter()
+        .enumerate()
+        .map(|(col_index, _)| {
+            typed_cell_xml(row.get(col_index), column_types.get(col_index), row_number - 1, col_index, None)
+        })
+        .collect::<String>();
+    format!("<row r=\"{row_number}\">{cells}</row>")
+}
+
+/// Shared ZIP entry options for all XLSX parts. XLSX is a ZIP of XML, and the
+/// `inlineStr` cell encoding is highly repetitive, so Deflate typically shrinks
+/// the file several-fold over `Stored` (matching what Excel/Navicat produce).
+fn xlsx_zip_options() -> zip::write::SimpleFileOptions {
+    zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated)
+}
+
+fn write_zip_entry<W: Write + Seek>(zip: &mut zip::ZipWriter<W>, path: &str, content: &str) -> Result<(), String> {
+    zip.start_file(path, xlsx_zip_options()).map_err(|err| err.to_string())?;
+    zip.write_all(content.as_bytes()).map_err(|err| err.to_string())
+}
+
+/// Start a new streaming XLSX workbook.  The ZIP skeleton, worksheet header,
+/// column widths (estimated from header names) and the header row are written
+/// immediately.  Callers then feed data rows via [`StreamingXlsxWriter::write_row`]
+/// and finalize with [`StreamingXlsxWriter::finish`].
+pub(crate) fn start_streaming_xlsx_workbook<W: Write + Seek>(
+    writer: W,
+    sheet_name: Option<&str>,
+    columns: &[String],
+    column_types: &[String],
+) -> Result<StreamingXlsxWriter<W>, String> {
+    let sheet_name = normalize_sheet_name(sheet_name);
+    let widths = estimate_header_widths(columns);
+
+    let mut zip = zip::ZipWriter::new(writer);
+    write_zip_entry(&mut zip, "[Content_Types].xml", &content_types_xml())?;
+    write_zip_entry(&mut zip, "_rels/.rels", root_rels_xml())?;
+    write_zip_entry(&mut zip, "xl/workbook.xml", &workbook_xml(&sheet_name))?;
+    write_zip_entry(&mut zip, "xl/_rels/workbook.xml.rels", &workbook_rels_xml())?;
+    write_zip_entry(&mut zip, "xl/styles.xml", styles_xml())?;
+
+    // Begin the sheet1.xml entry with header, frozen pane, column widths and
+    // the header row.
+    let options = xlsx_zip_options();
+    zip.start_file("xl/worksheets/sheet1.xml", options).map_err(|err| err.to_string())?;
+
+    let sheet_header = format!(
+        concat!(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+            "<worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">",
+            "<sheetViews><sheetView workbookViewId=\"0\">",
+            "<pane ySplit=\"1\" topLeftCell=\"A2\" activePane=\"bottomLeft\" state=\"frozen\"/>",
+            "</sheetView></sheetViews>",
+            "<sheetFormatPr defaultRowHeight=\"15\"/>",
+            "<cols>{cols}</cols>",
+            "<sheetData>"
+        ),
+        cols = cols_xml(&widths),
+    );
+    zip.write_all(sheet_header.as_bytes()).map_err(|err| err.to_string())?;
+    zip.write_all(header_row_xml(columns).as_bytes()).map_err(|err| err.to_string())?;
+
+    Ok(StreamingXlsxWriter { zip, columns: columns.to_vec(), column_types: column_types.to_vec(), next_row_number: 2 })
+}
+
+impl<W: Write + Seek> StreamingXlsxWriter<W> {
+    /// Append a single data row to the worksheet.
+    pub fn write_row(&mut self, row: &[Value]) -> Result<(), String> {
+        self.zip
+            .write_all(data_row_xml(self.next_row_number, &self.columns, &self.column_types, row).as_bytes())
+            .map_err(|err| err.to_string())?;
+        self.next_row_number += 1;
+        Ok(())
+    }
+
+    /// Finalize the worksheet and close the ZIP archive.  Returns the
+    /// underlying writer so callers can flush / close it as needed.
+    pub fn finish(mut self) -> Result<W, String> {
+        let row_count = self.next_row_number.saturating_sub(1);
+        let range = sheet_range(self.columns.len(), row_count);
+        self.zip
+            .write_all(format!("</sheetData><autoFilter ref=\"{range}\"/></worksheet>").as_bytes())
+            .map_err(|err| err.to_string())?;
+        self.zip.finish().map_err(|err| err.to_string())
+    }
+}
+
+/// Convenience wrapper that finalizes a streaming workbook.
+pub(crate) fn finish_streaming_xlsx_workbook<W: Write + Seek>(writer: StreamingXlsxWriter<W>) -> Result<W, String> {
+    writer.finish()
+}
+
+fn escape_xml(value: &str) -> String {
+    let mut result = String::with_capacity(value.len());
+    for ch in value.chars() {
+        let code = ch as u32;
+        if code != 9 && code != 10 && code != 13 && code < 32 {
+            continue;
+        }
+        match ch {
+            '&' => result.push_str("&amp;"),
+            '<' => result.push_str("&lt;"),
+            '>' => result.push_str("&gt;"),
+            '"' => result.push_str("&quot;"),
+            _ => result.push(ch),
+        }
+    }
+    result
+}
+
+fn column_name(index: usize) -> String {
+    let mut out = String::new();
+    let mut n = index + 1;
+    while n > 0 {
+        let rem = (n - 1) % 26;
+        out.push((b'A' + rem as u8) as char);
+        n = (n - 1) / 26;
+    }
+    out.chars().rev().collect()
+}
+
+fn cell_ref(row_index: usize, col_index: usize) -> String {
+    format!("{}{}", column_name(col_index), row_index + 1)
+}
+
+fn sheet_range(column_count: usize, row_count: usize) -> String {
+    if column_count == 0 || row_count == 0 {
+        return "A1".to_string();
+    }
+    format!("A1:{}{}", column_name(column_count - 1), row_count)
+}
+
+fn normalize_sheet_name(input: Option<&str>) -> String {
+    let base = input.unwrap_or("Sheet1");
+    let name: String = base
+        .chars()
+        .map(|ch| match ch {
+            '[' | ']' | ':' | '*' | '?' | '/' | '\\' => ' ',
+            _ => ch,
+        })
+        .collect::<String>()
+        .trim()
+        .to_string();
+    let fallback = if name.is_empty() { "Sheet1" } else { &name };
+    fallback.chars().take(31).collect()
+}
+
+fn value_text(value: Option<&Value>) -> String {
+    match value {
+        Some(Value::Null) | None => String::new(),
+        Some(Value::Bool(v)) => v.to_string(),
+        Some(Value::Number(n)) => n.to_string(),
+        Some(Value::String(s)) => s.clone(),
+        Some(other) => other.to_string(),
+    }
+}
+
+fn estimate_column_widths(columns: &[String], rows: &[Vec<Value>]) -> Vec<usize> {
+    columns
+        .iter()
+        .enumerate()
+        .map(|(col_index, column)| {
+            let max_len = std::iter::once(column.chars().count().min(60))
+                .chain(rows.iter().take(100).map(|row| value_text(row.get(col_index)).chars().count().min(60)))
+                .fold(8usize, usize::max);
+            (max_len + 2).clamp(10, 60)
+        })
+        .collect()
+}
+
+fn cell_xml(value: Option<&Value>, row_index: usize, col_index: usize, style: Option<usize>) -> String {
+    let reference = cell_ref(row_index, col_index);
+    let style_attr = style.map_or(String::new(), |s| format!(" s=\"{s}\""));
+    match value {
+        Some(Value::Null) | None => format!("<c r=\"{reference}\"{style_attr}/>"),
+        Some(Value::Bool(v)) => {
+            let bool_v = if *v { 1 } else { 0 };
+            format!("<c r=\"{reference}\" t=\"b\"{style_attr}><v>{bool_v}</v></c>")
+        }
+        Some(Value::Number(n)) => {
+            if n.as_f64().is_some_and(|f| f.is_finite()) {
+                format!("<c r=\"{reference}\"{style_attr}><v>{}</v></c>", n)
+            } else {
+                format!(
+                    "<c r=\"{reference}\" t=\"inlineStr\"{style_attr}><is><t>{}</t></is></c>",
+                    escape_xml(&n.to_string())
+                )
+            }
+        }
+        Some(Value::String(s)) => {
+            format!("<c r=\"{reference}\" t=\"inlineStr\"{style_attr}><is><t>{}</t></is></c>", escape_xml(s))
+        }
+        Some(other) => format!(
+            "<c r=\"{reference}\" t=\"inlineStr\"{style_attr}><is><t>{}</t></is></c>",
+            escape_xml(&other.to_string())
+        ),
+    }
+}
+
+fn is_numeric_column_type(column_type: Option<&String>) -> bool {
+    let normalized = column_type.map(|value| value.trim().to_ascii_lowercase()).unwrap_or_default();
+    let base = normalized.split(['(', ' ', '[']).next().unwrap_or_default();
+    matches!(
+        base,
+        "bit"
+            | "tinyint"
+            | "smallint"
+            | "mediumint"
+            | "int"
+            | "integer"
+            | "bigint"
+            | "int2"
+            | "int4"
+            | "int8"
+            | "uint8"
+            | "uint16"
+            | "uint32"
+            | "uint64"
+            | "uint128"
+            | "uint256"
+            | "float"
+            | "float4"
+            | "float8"
+            | "float32"
+            | "float64"
+            | "real"
+            | "double"
+            | "decimal"
+            | "numeric"
+            | "number"
+            | "money"
+            | "smallmoney"
+    )
+}
+
+fn safe_excel_number(value: &str) -> Option<&str> {
+    let trimmed = value.trim();
+    if trimmed.is_empty() || trimmed.parse::<f64>().ok().is_none_or(|number| !number.is_finite()) {
+        return None;
+    }
+    // Excel stores numbers with at most 15 significant decimal digits. Keep
+    // higher-precision database values as text rather than silently rounding.
+    let significant_digits = trimmed
+        .split(['e', 'E'])
+        .next()
+        .unwrap_or(trimmed)
+        .chars()
+        .filter(|ch| ch.is_ascii_digit())
+        .skip_while(|ch| *ch == '0')
+        .count();
+    (significant_digits <= 15).then_some(trimmed)
+}
+
+fn typed_cell_xml(
+    value: Option<&Value>,
+    column_type: Option<&String>,
+    row_index: usize,
+    col_index: usize,
+    style: Option<usize>,
+) -> String {
+    if is_numeric_column_type(column_type) {
+        if let Some(Value::String(value)) = value {
+            if let Some(number) = safe_excel_number(value) {
+                let reference = cell_ref(row_index, col_index);
+                let style_attr = style.map_or(String::new(), |style| format!(" s=\"{style}\""));
+                return format!("<c r=\"{reference}\"{style_attr}><v>{number}</v></c>");
+            }
+        }
+    }
+    cell_xml(value, row_index, col_index, style)
+}
+
+fn worksheet_xml(data: &XlsxWorksheetData) -> String {
+    let total_rows = data.rows.len() + 1;
+    let range = sheet_range(data.columns.len(), total_rows);
+    let widths = estimate_column_widths(&data.columns, &data.rows);
+
+    let cols_xml = widths
+        .iter()
+        .enumerate()
+        .map(|(index, width)| {
+            format!("<col min=\"{}\" max=\"{}\" width=\"{}\" customWidth=\"1\"/>", index + 1, index + 1, width)
+        })
+        .collect::<String>();
+
+    let header_xml = format!(
+        "<row r=\"1\">{}</row>",
+        data.columns
+            .iter()
+            .enumerate()
+            .map(|(index, col)| cell_xml(Some(&Value::String(col.clone())), 0, index, Some(1)))
+            .collect::<String>()
+    );
+
+    let body_xml = data
+        .rows
+        .iter()
+        .enumerate()
+        .map(|(row_index, row)| {
+            let excel_row = row_index + 2;
+            let cells = data
+                .columns
+                .iter()
+                .enumerate()
+                .map(|(col_index, _)| {
+                    typed_cell_xml(row.get(col_index), data.column_types.get(col_index), excel_row - 1, col_index, None)
+                })
+                .collect::<String>();
+            format!("<row r=\"{excel_row}\">{cells}</row>")
+        })
+        .collect::<String>();
+
+    format!(
+        concat!(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+            "<worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">",
+            "<dimension ref=\"{range}\"/>",
+            "<sheetViews><sheetView workbookViewId=\"0\"><pane ySplit=\"1\" topLeftCell=\"A2\" activePane=\"bottomLeft\" state=\"frozen\"/></sheetView></sheetViews>",
+            "<sheetFormatPr defaultRowHeight=\"15\"/>",
+            "<cols>{cols_xml}</cols>",
+            "<sheetData>{header_xml}{body_xml}</sheetData>",
+            "<autoFilter ref=\"{range}\"/>",
+            "</worksheet>"
+        ),
+        range = range,
+        cols_xml = cols_xml,
+        header_xml = header_xml,
+        body_xml = body_xml,
+    )
+}
+
+fn content_types_xml() -> String {
+    content_types_xml_for_sheet_count(1)
+}
+
+fn content_types_xml_for_sheet_count(sheet_count: usize) -> String {
+    let worksheet_overrides = (1..=sheet_count)
+        .map(|index| {
+            format!(
+                "<Override PartName=\"/xl/worksheets/sheet{index}.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml\"/>"
+            )
+        })
+        .collect::<String>();
+    format!(
+        concat!(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+            "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">",
+            "<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>",
+            "<Default Extension=\"xml\" ContentType=\"application/xml\"/>",
+            "<Override PartName=\"/xl/workbook.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml\"/>",
+            "{}",
+            "<Override PartName=\"/xl/styles.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml\"/>",
+            "</Types>"
+        ),
+        worksheet_overrides
+    )
+}
+
+fn root_rels_xml() -> &'static str {
+    concat!(
+        "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+        "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">",
+        "<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"xl/workbook.xml\"/>",
+        "</Relationships>"
+    )
+}
+
+fn workbook_xml(sheet_name: &str) -> String {
+    workbook_xml_for_sheets(&[sheet_name.to_string()])
+}
+
+fn workbook_xml_for_sheets(sheet_names: &[String]) -> String {
+    let sheets = sheet_names
+        .iter()
+        .enumerate()
+        .map(|(index, sheet_name)| {
+            let sheet_id = index + 1;
+            format!("<sheet name=\"{}\" sheetId=\"{sheet_id}\" r:id=\"rId{sheet_id}\"/>", escape_xml(sheet_name))
+        })
+        .collect::<String>();
+    format!(
+        concat!(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+            "<workbook xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">",
+            "<sheets>{}</sheets>",
+            "</workbook>"
+        ),
+        sheets
+    )
+}
+
+fn workbook_rels_xml() -> String {
+    workbook_rels_xml_for_sheet_count(1)
+}
+
+fn workbook_rels_xml_for_sheet_count(sheet_count: usize) -> String {
+    let worksheet_rels = (1..=sheet_count)
+        .map(|index| {
+            format!(
+                "<Relationship Id=\"rId{index}\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet\" Target=\"worksheets/sheet{index}.xml\"/>"
+            )
+        })
+        .collect::<String>();
+    let styles_id = sheet_count + 1;
+    format!(
+        concat!(
+            "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+            "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">",
+            "{}",
+            "<Relationship Id=\"rId{}\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles\" Target=\"styles.xml\"/>",
+            "</Relationships>"
+        ),
+        worksheet_rels, styles_id
+    )
+}
+
+fn styles_xml() -> &'static str {
+    concat!(
+        "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>",
+        "<styleSheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">",
+        "<fonts count=\"2\"><font><sz val=\"11\"/><name val=\"Calibri\"/></font><font><b/><sz val=\"11\"/><name val=\"Calibri\"/></font></fonts>",
+        "<fills count=\"2\"><fill><patternFill patternType=\"none\"/></fill><fill><patternFill patternType=\"gray125\"/></fill></fills>",
+        "<borders count=\"1\"><border><left/><right/><top/><bottom/><diagonal/></border></borders>",
+        "<cellStyleXfs count=\"1\"><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\"/></cellStyleXfs>",
+        "<cellXfs count=\"2\"><xf numFmtId=\"0\" fontId=\"0\" fillId=\"0\" borderId=\"0\" xfId=\"0\"/><xf numFmtId=\"0\" fontId=\"1\" fillId=\"0\" borderId=\"0\" xfId=\"0\" applyFont=\"1\"/></cellXfs>",
+        "<cellStyles count=\"1\"><cellStyle name=\"Normal\" xfId=\"0\" builtinId=\"0\"/></cellStyles>",
+        "</styleSheet>"
+    )
+}
+
+fn normalize_unique_sheet_names(sheets: &[XlsxWorksheetData]) -> Vec<String> {
+    let mut names = Vec::with_capacity(sheets.len());
+    for (index, sheet) in sheets.iter().enumerate() {
+        let base = normalize_sheet_name(sheet.sheet_name.as_deref().or(Some(&format!("Sheet{}", index + 1))));
+        let mut candidate = base.clone();
+        let mut suffix = 2;
+        while names.iter().any(|name| name == &candidate) {
+            let suffix_text = format!(" ({suffix})");
+            let max_base_len = 31usize.saturating_sub(suffix_text.chars().count());
+            candidate = format!("{}{}", base.chars().take(max_base_len).collect::<String>(), suffix_text);
+            suffix += 1;
+        }
+        names.push(candidate);
+    }
+    names
+}
+
+pub fn build_xlsx_workbook(data: &XlsxWorksheetData) -> Result<Vec<u8>, String> {
+    build_xlsx_workbook_multi(std::slice::from_ref(data))
+}
+
+pub fn build_xlsx_workbook_multi(sheets: &[XlsxWorksheetData]) -> Result<Vec<u8>, String> {
+    if sheets.is_empty() {
+        return Err("At least one worksheet is required".to_string());
+    }
+    let sheet_names = normalize_unique_sheet_names(sheets);
+    let files = vec![
+        ("[Content_Types].xml", content_types_xml_for_sheet_count(sheets.len())),
+        ("_rels/.rels", root_rels_xml().to_string()),
+        ("xl/workbook.xml", workbook_xml_for_sheets(&sheet_names)),
+        ("xl/_rels/workbook.xml.rels", workbook_rels_xml_for_sheet_count(sheets.len())),
+        ("xl/styles.xml", styles_xml().to_string()),
+    ];
+
+    let cursor = Cursor::new(Vec::<u8>::new());
+    let mut zip = zip::ZipWriter::new(cursor);
+    let options = xlsx_zip_options();
+
+    for (path, content) in files {
+        zip.start_file(path, options).map_err(|err| err.to_string())?;
+        zip.write_all(content.as_bytes()).map_err(|err| err.to_string())?;
+    }
+    for (index, sheet) in sheets.iter().enumerate() {
+        zip.start_file(format!("xl/worksheets/sheet{}.xml", index + 1), options).map_err(|err| err.to_string())?;
+        zip.write_all(worksheet_xml(sheet).as_bytes()).map_err(|err| err.to_string())?;
+    }
+
+    let output = zip.finish().map_err(|err| err.to_string())?;
+    Ok(output.into_inner())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{build_xlsx_workbook, build_xlsx_workbook_multi, start_streaming_xlsx_workbook, XlsxWorksheetData};
+    use calamine::{open_workbook_auto, Reader};
+    use serde_json::json;
+    use std::fs;
+    use std::io::Read;
+
+    /// Read and decompress a single entry from an in-memory XLSX (ZIP) buffer.
+    fn read_zip_entry(bytes: &[u8], path: &str) -> String {
+        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes.to_vec())).expect("open xlsx as zip archive");
+        let mut entry = archive.by_name(path).unwrap_or_else(|_| panic!("missing zip entry: {path}"));
+        let mut content = String::new();
+        entry.read_to_string(&mut content).expect("read zip entry");
+        content
+    }
+
+    /// Assert every entry in the XLSX (ZIP) buffer is Deflate-compressed, which
+    /// is what keeps exported workbooks small (see `xlsx_zip_options`).
+    fn assert_all_entries_deflated(bytes: &[u8]) {
+        let mut archive = zip::ZipArchive::new(std::io::Cursor::new(bytes.to_vec())).expect("open xlsx as zip archive");
+        for index in 0..archive.len() {
+            let entry = archive.by_index(index).expect("zip entry");
+            assert_eq!(
+                entry.compression(),
+                zip::CompressionMethod::Deflated,
+                "entry {} should be Deflate-compressed",
+                entry.name()
+            );
+        }
+    }
+
+    #[test]
+    fn builds_xlsx_zip_with_sheet_data() {
+        let workbook = build_xlsx_workbook(&XlsxWorksheetData {
+            sheet_name: Some("Users".to_string()),
+            columns: vec!["id".to_string(), "name".to_string(), "active".to_string()],
+            column_types: vec![],
+            rows: vec![vec![json!(1), json!("Ada & Bob"), json!(true)], vec![json!(2), json!(null), json!(false)]],
+        })
+        .expect("build workbook");
+
+        // ZIP magic bytes.
+        assert_eq!(workbook[0], 0x50);
+        assert_eq!(workbook[1], 0x4b);
+
+        // Entries are stored compressed; assert on their decompressed contents.
+        let sheet = read_zip_entry(&workbook, "xl/worksheets/sheet1.xml");
+        let workbook_xml = read_zip_entry(&workbook, "xl/workbook.xml");
+        assert!(workbook_xml.contains("name=\"Users\""));
+        assert!(sheet.contains("<c r=\"A2\"><v>1</v></c>"));
+        assert!(sheet.contains("Ada &amp; Bob"));
+        assert!(sheet.contains("<c r=\"C2\" t=\"b\"><v>1</v></c>"));
+        assert_all_entries_deflated(&workbook);
+    }
+
+    #[test]
+    fn writes_safe_numeric_strings_as_numbers_for_numeric_columns() {
+        let workbook = build_xlsx_workbook(&XlsxWorksheetData {
+            sheet_name: Some("Amounts".to_string()),
+            columns: vec!["quantity".to_string(), "amount".to_string(), "code".to_string()],
+            column_types: vec!["decimal(10,5)".to_string(), "numeric".to_string(), "varchar".to_string()],
+            rows: vec![vec![json!("1.00000"), json!("2800.000000"), json!("00123")]],
+        })
+        .expect("build workbook");
+
+        let sheet = read_zip_entry(&workbook, "xl/worksheets/sheet1.xml");
+        assert!(sheet.contains("<c r=\"A2\"><v>1.00000</v></c>"));
+        assert!(sheet.contains("<c r=\"B2\"><v>2800.000000</v></c>"));
+        assert!(sheet.contains("<c r=\"C2\" t=\"inlineStr\"><is><t>00123</t></is></c>"));
+    }
+
+    #[test]
+    fn preserves_high_precision_numeric_strings_as_text() {
+        let workbook = build_xlsx_workbook(&XlsxWorksheetData {
+            sheet_name: Some("Precision".to_string()),
+            columns: vec!["large_id".to_string(), "precise_amount".to_string()],
+            column_types: vec!["bigint".to_string(), "decimal(30,10)".to_string()],
+            rows: vec![vec![json!("9223372036854775807"), json!("123456789012345.6789000000")]],
+        })
+        .expect("build workbook");
+
+        let sheet = read_zip_entry(&workbook, "xl/worksheets/sheet1.xml");
+        assert!(sheet.contains("t=\"inlineStr\"") && sheet.contains("9223372036854775807"));
+        assert!(sheet.contains("123456789012345.6789000000"));
+    }
+
+    #[test]
+    fn sanitizes_invalid_sheet_name() {
+        let workbook = build_xlsx_workbook(&XlsxWorksheetData {
+            sheet_name: Some("bad/name:with*chars?and-a-very-long-tail".to_string()),
+            columns: vec!["value".to_string()],
+            column_types: vec![],
+            rows: vec![vec![json!("ok")]],
+        })
+        .expect("build workbook");
+        let workbook_xml = read_zip_entry(&workbook, "xl/workbook.xml");
+        assert!(workbook_xml.contains("name=\"bad name with chars and-a-very-\""));
+    }
+
+    #[test]
+    fn builds_multi_sheet_xlsx_workbook() {
+        let path = std::env::temp_dir().join(format!("dbx-multi-sheet-test-{}.xlsx", uuid::Uuid::new_v4()));
+        let workbook = build_xlsx_workbook_multi(&[
+            XlsxWorksheetData {
+                sheet_name: Some("Result 1".to_string()),
+                columns: vec!["id".to_string()],
+                column_types: vec![],
+                rows: vec![vec![json!(1)]],
+            },
+            XlsxWorksheetData {
+                sheet_name: Some("Result 2".to_string()),
+                columns: vec!["name".to_string()],
+                column_types: vec![],
+                rows: vec![vec![json!("Ada")]],
+            },
+        ])
+        .expect("build multi-sheet workbook");
+        fs::write(&path, workbook).expect("write temp workbook");
+
+        let mut workbook = open_workbook_auto(&path).expect("open workbook");
+        let names = workbook.sheet_names().to_vec();
+        assert_eq!(names, vec!["Result 1".to_string(), "Result 2".to_string()]);
+        let first = workbook.worksheet_range("Result 1").expect("read first worksheet");
+        let second = workbook.worksheet_range("Result 2").expect("read second worksheet");
+        assert_eq!(first.get_value((1, 0)).expect("first row"), &calamine::Data::Float(1.0));
+        assert_eq!(second.get_value((1, 0)).expect("second row"), &calamine::Data::String("Ada".to_string()));
+        let _ = fs::remove_file(&path);
+    }
+
+    #[test]
+    fn streams_xlsx_rows_to_a_readable_workbook() {
+        let path = std::env::temp_dir().join(format!("dbx-stream-test-{}.xlsx", uuid::Uuid::new_v4()));
+        {
+            let file = fs::File::create(&path).expect("create temp xlsx");
+            let mut writer =
+                start_streaming_xlsx_workbook(file, Some("Streamed"), &["id".to_string(), "name".to_string()], &[])
+                    .expect("start workbook");
+            writer.write_row(&[json!(1), json!("Ada")]).expect("write row");
+            writer.write_row(&[json!(2), json!("Bob")]).expect("write row");
+            drop(writer.finish().expect("finish workbook"));
+        }
+
+        let mut workbook = open_workbook_auto(&path).expect("open workbook");
+        let range = workbook.worksheet_range("Streamed").expect("read worksheet");
+        assert_eq!(range.get_value((0, 0)).expect("header"), &calamine::Data::String("id".to_string()));
+        assert_eq!(range.get_value((1, 0)).expect("row1"), &calamine::Data::Float(1.0));
+        assert_eq!(range.get_value((2, 1)).expect("row2"), &calamine::Data::String("Bob".to_string()));
+        let _ = fs::remove_file(&path);
+    }
+}
diff --git a/crates/dbx-core/tests/agent_service.rs b/crates/dbx-core/tests/agent_service.rs
new file mode 100644
index 0000000..dbec2fd
--- /dev/null
+++ b/crates/dbx-core/tests/agent_service.rs
@@ -0,0 +1,547 @@
+use dbx_core::agent_manager::{
+    AgentManager, AgentRegistry, ArtifactInfo, DriverInfo, InstalledDriver, JavaRuntimeConfig, JavaRuntimeMode,
+    JreInfo, DEFAULT_JRE_KEY,
+};
+use dbx_core::agent_service::{
+    build_agent_list, clear_agent_download_cache, github_url_to_r2_path, import_agent_jar, import_agents_from_zip,
+    is_app_version_compatible, jre_needs_install, local_agent_jar_candidates, replace_download, uninstall_agent_driver,
+    AgentProgressEvent,
+};
+
+fn test_manager(name: &str) -> AgentManager {
+    let dir = std::env::temp_dir().join(format!("dbx-agent-service-{name}-{}", uuid::Uuid::new_v4()));
+    AgentManager::new_with_base_dir(dir)
+}
+
+fn registry_with_driver(db_type: &str, version: &str, jre: &str) -> AgentRegistry {
+    let mut drivers = std::collections::HashMap::new();
+    drivers.insert(
+        db_type.to_string(),
+        DriverInfo {
+            version: version.to_string(),
+            label: db_type.to_string(),
+            min_app_version: "0.1.0".to_string(),
+            jre: jre.to_string(),
+            jar: Some(ArtifactInfo { url: format!("https://example.com/dbx-agent-{db_type}.jar"), size: 42 }),
+            native: std::collections::HashMap::new(),
+        },
+    );
+    AgentRegistry { jre: None, jres: std::collections::HashMap::new(), drivers }
+}
+
+fn registry_with_jre_driver(db_type: &str, driver_version: &str, jre: &str, jre_version: &str) -> AgentRegistry {
+    let mut registry = registry_with_driver(db_type, driver_version, jre);
+    registry.jres.insert(
+        jre.to_string(),
+        JreInfo { version: jre_version.to_string(), platforms: std::collections::HashMap::new() },
+    );
+    registry
+}
+
+fn registry_with_native_driver(db_type: &str, version: &str, jre: &str) -> AgentRegistry {
+    let mut drivers = std::collections::HashMap::new();
+    drivers.insert(
+        db_type.to_string(),
+        DriverInfo {
+            version: version.to_string(),
+            label: db_type.to_string(),
+            min_app_version: "0.1.0".to_string(),
+            jre: jre.to_string(),
+            jar: Some(ArtifactInfo {
+                url: format!("https://example.com/dbx-agent-{db_type}-legacy-placeholder.jar"),
+                size: 0,
+            }),
+            native: [(
+                AgentManager::current_platform().to_string(),
+                ArtifactInfo { url: format!("https://example.com/dbx-agent-{db_type}"), size: 42 },
+            )]
+            .into_iter()
+            .collect(),
+        },
+    );
+    AgentRegistry { jre: None, jres: std::collections::HashMap::new(), drivers }
+}
+
+#[test]
+fn built_in_agent_list_includes_expected_driver_labels() {
+    let manager = test_manager("labels");
+
+    let agents = build_agent_list(&manager, None);
+
+    assert!(agents.iter().any(|agent| agent.db_type == "tdengine" && agent.label == "TDengine"));
+    assert!(agents.iter().any(|agent| agent.db_type == "iotdb" && agent.label == "Apache IoTDB"));
+    assert!(agents.iter().any(|agent| agent.db_type == "yashandb" && agent.label == "崖山 YashanDB"));
+    assert!(agents.iter().any(|agent| agent.db_type == "access" && agent.label == "Microsoft Access"));
+}
+
+#[test]
+fn agent_list_marks_installed_driver_update_when_registry_version_differs() {
+    let manager = test_manager("update");
+    let jar_path = manager.driver_jar_path("h2");
+    std::fs::create_dir_all(jar_path.parent().unwrap()).unwrap();
+    write_test_agent_jar(&jar_path);
+    manager
+        .save_state(&dbx_core::agent_manager::AgentState {
+            installed_drivers: [(
+                "h2".to_string(),
+                InstalledDriver {
+                    version: "0.1.0".to_string(),
+                    installed_at: "2026-05-18T00:00:00Z".to_string(),
+                    jre: DEFAULT_JRE_KEY.to_string(),
+                },
+            )]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        })
+        .unwrap();
+    let registry = registry_with_driver("h2", "0.2.0", "21");
+
+    let agents = build_agent_list(&manager, Some(&registry));
+    let h2 = agents.iter().find(|agent| agent.db_type == "h2").unwrap();
+
+    assert!(h2.installed);
+    assert_eq!(h2.installed_version.as_deref(), Some("0.1.0"));
+    assert_eq!(h2.version, "0.2.0");
+    assert_eq!(h2.size, 42);
+    assert_eq!(h2.jre, "21");
+    assert!(h2.requires_java_runtime);
+    assert!(h2.update_available);
+}
+
+#[test]
+fn agent_list_marks_update_when_installed_managed_jre_version_differs() {
+    let manager = test_manager("jre-update");
+    let jar_path = manager.driver_jar_path("h2");
+    let java_path = manager.jre_java_path(DEFAULT_JRE_KEY);
+    std::fs::create_dir_all(jar_path.parent().unwrap()).unwrap();
+    std::fs::create_dir_all(java_path.parent().unwrap()).unwrap();
+    write_test_agent_jar(&jar_path);
+    std::fs::write(&java_path, b"java").unwrap();
+    manager
+        .save_state(&dbx_core::agent_manager::AgentState {
+            jre_versions: [(DEFAULT_JRE_KEY.to_string(), "21.0.10".to_string())].into_iter().collect(),
+            installed_drivers: [(
+                "h2".to_string(),
+                InstalledDriver {
+                    version: "0.2.0".to_string(),
+                    installed_at: "2026-05-18T00:00:00Z".to_string(),
+                    jre: DEFAULT_JRE_KEY.to_string(),
+                },
+            )]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        })
+        .unwrap();
+    let registry = registry_with_jre_driver("h2", "0.2.0", DEFAULT_JRE_KEY, "21.0.11");
+
+    let agents = build_agent_list(&manager, Some(&registry));
+    let h2 = agents.iter().find(|agent| agent.db_type == "h2").unwrap();
+
+    assert!(h2.update_available);
+}
+
+#[test]
+fn agent_list_does_not_mark_jre_update_for_system_java_runtime() {
+    let manager = test_manager("system-java-no-jre-update");
+    let jar_path = manager.driver_jar_path("dameng");
+    std::fs::create_dir_all(jar_path.parent().unwrap()).unwrap();
+    write_test_agent_jar(&jar_path);
+    manager
+        .save_state(&dbx_core::agent_manager::AgentState {
+            java_runtime: JavaRuntimeConfig { mode: JavaRuntimeMode::System, custom_java_path: None },
+            installed_drivers: [(
+                "dameng".to_string(),
+                InstalledDriver {
+                    version: "0.2.0".to_string(),
+                    installed_at: "2026-05-18T00:00:00Z".to_string(),
+                    jre: DEFAULT_JRE_KEY.to_string(),
+                },
+            )]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        })
+        .unwrap();
+    let registry = registry_with_jre_driver("dameng", "0.2.0", DEFAULT_JRE_KEY, "21.0.11");
+
+    let agents = build_agent_list(&manager, Some(&registry));
+    let dameng = agents.iter().find(|agent| agent.db_type == "dameng").unwrap();
+
+    assert!(dameng.installed);
+    assert!(!dameng.jre_installed);
+    assert!(!dameng.update_available);
+}
+
+#[test]
+fn agent_list_does_not_require_jre_for_native_agent() {
+    let manager = test_manager("native-no-jre");
+    let native_path = manager.driver_native_path("dameng");
+    std::fs::create_dir_all(native_path.parent().unwrap()).unwrap();
+    std::fs::write(&native_path, b"agent").unwrap();
+    manager
+        .save_state(&dbx_core::agent_manager::AgentState {
+            installed_drivers: [(
+                "dameng".to_string(),
+                InstalledDriver {
+                    version: "0.2.0".to_string(),
+                    installed_at: "2026-05-18T00:00:00Z".to_string(),
+                    jre: DEFAULT_JRE_KEY.to_string(),
+                },
+            )]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        })
+        .unwrap();
+
+    let agents = build_agent_list(&manager, None);
+    let dameng = agents.iter().find(|agent| agent.db_type == "dameng").unwrap();
+
+    assert!(dameng.installed);
+    assert!(!dameng.requires_java_runtime);
+    assert!(dameng.jre_installed);
+}
+
+#[test]
+fn agent_list_does_not_require_jre_for_registry_native_agent() {
+    let manager = test_manager("registry-native-no-jre");
+    let registry = registry_with_native_driver("xugu", "0.2.0", DEFAULT_JRE_KEY);
+
+    let agents = build_agent_list(&manager, Some(&registry));
+    let xugu = agents.iter().find(|agent| agent.db_type == "xugu").unwrap();
+
+    assert!(!xugu.installed);
+    assert_eq!(xugu.jre, DEFAULT_JRE_KEY);
+    assert!(!xugu.requires_java_runtime);
+    assert!(xugu.jre_installed);
+}
+
+#[test]
+fn agent_list_keeps_jre_requirement_for_installed_jar_when_registry_has_native() {
+    let manager = test_manager("installed-jar-registry-native");
+    let jar_path = manager.driver_jar_path("xugu");
+    std::fs::create_dir_all(jar_path.parent().unwrap()).unwrap();
+    write_test_agent_jar(&jar_path);
+    manager
+        .save_state(&dbx_core::agent_manager::AgentState {
+            installed_drivers: [(
+                "xugu".to_string(),
+                InstalledDriver {
+                    version: "0.2.0".to_string(),
+                    installed_at: "2026-05-18T00:00:00Z".to_string(),
+                    jre: DEFAULT_JRE_KEY.to_string(),
+                },
+            )]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        })
+        .unwrap();
+    let registry = registry_with_native_driver("xugu", "0.2.0", DEFAULT_JRE_KEY);
+
+    let agents = build_agent_list(&manager, Some(&registry));
+    let xugu = agents.iter().find(|agent| agent.db_type == "xugu").unwrap();
+
+    assert!(xugu.installed);
+    assert!(xugu.requires_java_runtime);
+    assert!(!xugu.jre_installed);
+}
+
+#[test]
+fn agent_list_reports_missing_jre_for_uninstalled_java_drivers() {
+    let manager = test_manager("uninstalled-java-driver-missing-jre");
+    let registry = registry_with_jre_driver("dameng", "0.2.0", DEFAULT_JRE_KEY, "21.0.11");
+
+    let agents = build_agent_list(&manager, Some(&registry));
+    let dameng = agents.iter().find(|agent| agent.db_type == "dameng").unwrap();
+
+    assert!(!dameng.installed);
+    assert!(!dameng.jre_installed);
+}
+
+#[test]
+fn agent_list_uses_legacy_default_jre_version_when_checking_updates() {
+    let manager = test_manager("legacy-jre-version");
+    let jar_path = manager.driver_jar_path("dameng");
+    let java_path = manager.jre_java_path(DEFAULT_JRE_KEY);
+    std::fs::create_dir_all(jar_path.parent().unwrap()).unwrap();
+    std::fs::create_dir_all(java_path.parent().unwrap()).unwrap();
+    write_test_agent_jar(&jar_path);
+    std::fs::write(&java_path, b"java").unwrap();
+    manager
+        .save_state(&dbx_core::agent_manager::AgentState {
+            jre_version: Some("21.0.11".to_string()),
+            installed_drivers: [(
+                "dameng".to_string(),
+                InstalledDriver {
+                    version: "0.2.0".to_string(),
+                    installed_at: "2026-05-18T00:00:00Z".to_string(),
+                    jre: DEFAULT_JRE_KEY.to_string(),
+                },
+            )]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        })
+        .unwrap();
+    let registry = registry_with_jre_driver("dameng", "0.2.0", DEFAULT_JRE_KEY, "21.0.11");
+
+    let agents = build_agent_list(&manager, Some(&registry));
+    let dameng = agents.iter().find(|agent| agent.db_type == "dameng").unwrap();
+
+    assert!(!dameng.update_available);
+}
+
+#[test]
+fn jre_needs_install_when_managed_runtime_version_differs() {
+    let manager = test_manager("jre-needs-install");
+    let java_path = manager.jre_java_path(DEFAULT_JRE_KEY);
+    std::fs::create_dir_all(java_path.parent().unwrap()).unwrap();
+    std::fs::write(&java_path, b"java").unwrap();
+    manager
+        .save_state(&dbx_core::agent_manager::AgentState {
+            jre_versions: [(DEFAULT_JRE_KEY.to_string(), "21.0.10".to_string())].into_iter().collect(),
+            ..Default::default()
+        })
+        .unwrap();
+    let registry = registry_with_jre_driver("h2", "0.2.0", DEFAULT_JRE_KEY, "21.0.11");
+
+    assert!(jre_needs_install(&manager, &registry, DEFAULT_JRE_KEY));
+}
+
+#[test]
+fn local_agent_jar_candidates_include_monorepo_and_legacy_build_output() {
+    let candidates = local_agent_jar_candidates("tdengine");
+
+    assert!(candidates.iter().any(|path| path.ends_with("agents/drivers/tdengine/build/libs/dbx-agent-tdengine.jar")));
+    assert!(candidates.iter().any(|path| path.ends_with("dbx-agents/tdengine/build/libs/dbx-agent-tdengine.jar")));
+}
+
+#[test]
+fn github_agent_asset_urls_map_to_r2_paths_by_category() {
+    assert_eq!(
+        github_url_to_r2_path("https://github.com/t8y2/dbx-agents/releases/download/v1/dbx-jre-21.tar.gz", "jre"),
+        "agents/jre/dbx-jre-21.tar.gz"
+    );
+    assert_eq!(
+        github_url_to_r2_path("https://github.com/t8y2/dbx-agents/releases/download/v1/dbx-agent-h2.jar", "driver"),
+        "agents/drivers/dbx-agent-h2.jar"
+    );
+    assert_eq!(
+        github_url_to_r2_path("https://github.com/t8y2/dbx/releases/download/agents-v0.3.0/dbx-agent-h2.jar", "driver"),
+        "agents/drivers/dbx-agent-h2.jar"
+    );
+}
+
+fn test_path(name: &str) -> std::path::PathBuf {
+    std::env::temp_dir().join(format!("dbx-agent-service-{name}-{}", uuid::Uuid::new_v4()))
+}
+
+#[test]
+fn accepts_current_app_when_min_version_is_not_newer() {
+    assert!(is_app_version_compatible("0.5.13", "0.5.13"));
+    assert!(is_app_version_compatible("0.5.12", "0.5.13"));
+    assert!(!is_app_version_compatible("0.5.14", "0.5.13"));
+}
+
+#[test]
+fn atomic_replace_moves_download_into_place() {
+    let dir = test_path("atomic");
+    std::fs::create_dir_all(&dir).unwrap();
+    let dest = dir.join("agent.jar");
+    let tmp = dir.join("agent.jar.download");
+    std::fs::write(&dest, b"old").unwrap();
+    std::fs::write(&tmp, b"new").unwrap();
+
+    replace_download(&tmp, &dest).unwrap();
+
+    assert_eq!(std::fs::read(&dest).unwrap(), b"new");
+    assert!(!tmp.exists());
+    std::fs::remove_dir_all(dir).ok();
+}
+
+#[test]
+fn agent_progress_event_serializes_backward_compatible_fields() {
+    let event = AgentProgressEvent::transfer("driver", 512, 1024).with_batch(Some("h2"), Some(1), Some(2));
+
+    let value = serde_json::to_value(event).unwrap();
+
+    assert_eq!(value["step"], "driver");
+    assert_eq!(value["downloaded"], 512);
+    assert_eq!(value["total"], 1024);
+    assert_eq!(value["db_type"], "h2");
+    assert_eq!(value["current"], 1);
+    assert_eq!(value["total_drivers"], 2);
+}
+
+#[test]
+fn local_jar_import_updates_driver_state() {
+    let manager = test_manager("local-import");
+    let source = test_path("local-import-source").join("dbx-agent-h2.jar");
+    std::fs::create_dir_all(source.parent().unwrap()).unwrap();
+    write_test_agent_jar(&source);
+
+    import_agent_jar(&manager, "h2", &source).unwrap();
+
+    assert_eq!(std::fs::read(manager.driver_jar_path("h2")).unwrap(), std::fs::read(&source).unwrap());
+    let state = manager.load_state();
+    let installed = state.installed_drivers.get("h2").unwrap();
+    assert_eq!(installed.version, "0.1.0-local");
+    assert_eq!(installed.jre, DEFAULT_JRE_KEY);
+}
+
+#[test]
+fn local_jar_import_rejects_corrupt_jar() {
+    let manager = test_manager("local-import-corrupt");
+    let source = test_path("local-import-corrupt-source").join("dbx-agent-h2.jar");
+    std::fs::create_dir_all(source.parent().unwrap()).unwrap();
+    std::fs::write(&source, b"jar").unwrap();
+
+    let err = import_agent_jar(&manager, "h2", &source).unwrap_err();
+
+    assert!(err.contains("invalid or corrupt"));
+    assert!(!manager.driver_jar_path("h2").exists());
+    assert!(!manager.load_state().installed_drivers.contains_key("h2"));
+}
+
+#[tokio::test]
+async fn uninstall_driver_removes_artifact_and_state() {
+    let manager = test_manager("uninstall");
+    let jar_path = manager.driver_jar_path("h2");
+    std::fs::create_dir_all(jar_path.parent().unwrap()).unwrap();
+    std::fs::write(&jar_path, b"jar").unwrap();
+    let cache_dir = manager.download_cache_dir();
+    std::fs::create_dir_all(&cache_dir).unwrap();
+    let h2_cache = cache_dir.join("driver-h2-0.1.0-abc-agent.jar");
+    let dameng_cache = cache_dir.join("driver-dameng-0.1.0-abc-agent.jar");
+    let jre_cache = cache_dir.join("jre-21-21.0.11-abc-jre-download.tar.gz");
+    std::fs::write(&h2_cache, b"h2").unwrap();
+    std::fs::write(&dameng_cache, b"dameng").unwrap();
+    std::fs::write(&jre_cache, b"jre").unwrap();
+    manager
+        .save_state(&dbx_core::agent_manager::AgentState {
+            installed_drivers: [(
+                "h2".to_string(),
+                InstalledDriver {
+                    version: "0.1.0".to_string(),
+                    installed_at: "2026-05-18T00:00:00Z".to_string(),
+                    jre: DEFAULT_JRE_KEY.to_string(),
+                },
+            )]
+            .into_iter()
+            .collect(),
+            ..Default::default()
+        })
+        .unwrap();
+
+    uninstall_agent_driver(&manager, "h2").await.unwrap();
+
+    assert!(!jar_path.exists());
+    assert!(!h2_cache.exists());
+    assert!(dameng_cache.exists());
+    assert!(jre_cache.exists());
+    assert!(!manager.load_state().installed_drivers.contains_key("h2"));
+}
+
+#[test]
+fn clear_download_cache_removes_only_cache_entries() {
+    let manager = test_manager("clear-download-cache");
+    let cache_dir = manager.download_cache_dir();
+    let driver_dir = manager.driver_dir("h2");
+    std::fs::create_dir_all(&cache_dir).unwrap();
+    std::fs::create_dir_all(&driver_dir).unwrap();
+    let driver_cache = cache_dir.join("driver-h2-0.1.0-abc-agent.jar");
+    let jre_cache = cache_dir.join("jre-21-21.0.11-abc-jre-download.tar.gz");
+    let nested_cache = cache_dir.join("stale-dir");
+    let installed_driver = driver_dir.join("agent.jar");
+    std::fs::write(&driver_cache, b"h2").unwrap();
+    std::fs::write(&jre_cache, b"jre").unwrap();
+    std::fs::create_dir_all(&nested_cache).unwrap();
+    std::fs::write(nested_cache.join("artifact"), b"x").unwrap();
+    std::fs::write(&installed_driver, b"driver").unwrap();
+
+    clear_agent_download_cache(&manager).unwrap();
+
+    assert!(!driver_cache.exists());
+    assert!(!jre_cache.exists());
+    assert!(!nested_cache.exists());
+    assert!(installed_driver.exists());
+}
+
+#[test]
+fn offline_zip_import_emits_progress_and_updates_state() {
+    let manager = test_manager("offline-progress");
+    let zip_path = test_path("offline-progress-zip").join("agents.zip");
+    std::fs::create_dir_all(zip_path.parent().unwrap()).unwrap();
+    write_offline_driver_zip(&zip_path, "h2", "0.2.0");
+    let events = std::sync::Mutex::new(Vec::new());
+
+    let result = import_agents_from_zip(&manager, &zip_path, |event| {
+        events.lock().unwrap().push(event);
+    })
+    .unwrap();
+
+    assert_eq!(result.drivers_installed, vec!["h2"]);
+    let installed_jar = std::fs::read(manager.driver_jar_path("h2")).unwrap();
+    assert!(installed_jar.windows(b"Main-Class:".len()).any(|window| window == b"Main-Class:"));
+    assert_eq!(manager.load_state().installed_drivers.get("h2").unwrap().version, "0.2.0");
+    let events = events.lock().unwrap();
+    assert!(events.iter().any(|event| event.step == "driver" && event.db_type.as_deref() == Some("H2")));
+}
+
+#[test]
+fn offline_zip_import_rejects_corrupt_jar() {
+    let manager = test_manager("offline-corrupt-driver");
+    let zip_path = test_path("offline-corrupt-driver-zip").join("agents.zip");
+    std::fs::create_dir_all(zip_path.parent().unwrap()).unwrap();
+    write_offline_driver_zip_with_jar(&zip_path, "h2", "0.2.0", b"jar".to_vec());
+
+    let err = import_agents_from_zip(&manager, &zip_path, |_| {}).unwrap_err();
+
+    assert!(err.contains("invalid or corrupt"));
+    assert!(!manager.driver_jar_path("h2").exists());
+    assert!(!manager.load_state().installed_drivers.contains_key("h2"));
+}
+
+fn write_offline_driver_zip(path: &std::path::Path, db_type: &str, version: &str) {
+    write_offline_driver_zip_with_jar(path, db_type, version, test_agent_jar_bytes());
+}
+
+fn write_offline_driver_zip_with_jar(path: &std::path::Path, db_type: &str, version: &str, jar: Vec<u8>) {
+    let file = std::fs::File::create(path).unwrap();
+    let mut zip = zip::ZipWriter::new(file);
+    let options = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
+    let registry = serde_json::json!({
+        "drivers": {
+            db_type: {
+                "version": version,
+                "label": db_type,
+                "min_app_version": "0.1.0",
+                "jre": DEFAULT_JRE_KEY,
+                "jar": { "url": format!("https://example.com/dbx-agent-{db_type}.jar"), "size": jar.len() }
+            }
+        }
+    });
+
+    zip.start_file("agent-registry.json", options).unwrap();
+    std::io::Write::write_all(&mut zip, registry.to_string().as_bytes()).unwrap();
+    zip.start_file(format!("drivers/dbx-agent-{db_type}.jar"), options).unwrap();
+    std::io::Write::write_all(&mut zip, &jar).unwrap();
+    zip.finish().unwrap();
+}
+
+fn write_test_agent_jar(path: &std::path::Path) {
+    std::fs::write(path, test_agent_jar_bytes()).unwrap();
+}
+
+fn test_agent_jar_bytes() -> Vec<u8> {
+    let cursor = std::io::Cursor::new(Vec::new());
+    let mut zip = zip::ZipWriter::new(cursor);
+    let options = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
+    // The production validator rejects corrupt driver artifacts by requiring a real JAR manifest.
+    zip.start_file("META-INF/MANIFEST.MF", options).unwrap();
+    std::io::Write::write_all(&mut zip, b"Manifest-Version: 1.0\nMain-Class: com.dbx.agent.TestAgent\n\n").unwrap();
+    zip.finish().unwrap().into_inner()
+}
diff --git a/crates/dbx-core/tests/database_capabilities.rs b/crates/dbx-core/tests/database_capabilities.rs
new file mode 100644
index 0000000..972eeeb
--- /dev/null
+++ b/crates/dbx-core/tests/database_capabilities.rs
@@ -0,0 +1,341 @@
+use dbx_core::agent_catalog;
+use dbx_core::database_capabilities::{
+    agent_key, is_agent_type, is_metadata_connection_scoped, is_single_connection_pool, skips_tcp_probe,
+};
+use dbx_core::models::connection::DatabaseType;
+use serde::Deserialize;
+use std::collections::HashSet;
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DriverManifest {
+    drivers: Vec<DriverManifestEntry>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DriverManifestEntry {
+    db_type: DatabaseType,
+    label: String,
+    runtime_mode: String,
+    support_level: String,
+    capabilities: DriverProductCapabilities,
+    #[serde(default)]
+    agent_key: Option<String>,
+    #[serde(default)]
+    single_connection_pool: bool,
+    #[serde(default)]
+    metadata_connection_scoped: bool,
+    #[serde(default)]
+    skip_tcp_probe: bool,
+    #[serde(default)]
+    driver_profiles: Vec<DriverProfileEntry>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DriverProductCapabilities {
+    query_execution: bool,
+    metadata_browse: bool,
+    object_browser: bool,
+    object_source: bool,
+    schema_search: bool,
+    diagram: bool,
+    table_data_edit: bool,
+    table_structure_edit: bool,
+    table_import: bool,
+    data_transfer: bool,
+    sql_file_execution: bool,
+    database_create: bool,
+    field_lineage: bool,
+    sql_explain: bool,
+    user_admin: bool,
+    driver_management: bool,
+}
+
+impl DriverProductCapabilities {
+    fn any_enabled(&self) -> bool {
+        [
+            self.metadata_browse,
+            self.query_execution,
+            self.object_browser,
+            self.object_source,
+            self.schema_search,
+            self.diagram,
+            self.table_data_edit,
+            self.table_structure_edit,
+            self.table_import,
+            self.data_transfer,
+            self.sql_file_execution,
+            self.database_create,
+            self.field_lineage,
+            self.sql_explain,
+            self.user_admin,
+            self.driver_management,
+        ]
+        .into_iter()
+        .any(|enabled| enabled)
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct DriverProfileEntry {
+    profile: String,
+    agent_key: String,
+}
+
+fn driver_manifest() -> DriverManifest {
+    let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("assets").join("database-drivers.manifest.json");
+    let json = std::fs::read_to_string(&path).unwrap_or_else(|err| {
+        panic!("failed to read driver manifest {}: {err}", path.display());
+    });
+    serde_json::from_str(&json).expect("driver manifest should be valid JSON")
+}
+
+#[test]
+fn maps_agent_database_types_to_driver_keys() {
+    assert_eq!(agent_key(&DatabaseType::Trino, None), Some("trino"));
+    assert_eq!(agent_key(&DatabaseType::Hive, None), Some("hive"));
+    assert_eq!(agent_key(&DatabaseType::Tdengine, None), Some("tdengine"));
+    assert_eq!(agent_key(&DatabaseType::Iotdb, None), Some("iotdb"));
+    assert_eq!(agent_key(&DatabaseType::Yashandb, None), Some("yashandb"));
+    assert_eq!(agent_key(&DatabaseType::Databricks, None), Some("databricks"));
+    assert_eq!(agent_key(&DatabaseType::SapHana, None), Some("saphana"));
+    assert_eq!(agent_key(&DatabaseType::Teradata, None), Some("teradata"));
+    assert_eq!(agent_key(&DatabaseType::Vertica, None), Some("vertica"));
+    assert_eq!(agent_key(&DatabaseType::Firebird, None), Some("firebird"));
+    assert_eq!(agent_key(&DatabaseType::Exasol, None), Some("exasol"));
+    assert_eq!(agent_key(&DatabaseType::OceanbaseOracle, None), Some("oceanbase-oracle"));
+    assert_eq!(agent_key(&DatabaseType::Gbase, None), Some("gbase8a"));
+    assert_eq!(agent_key(&DatabaseType::Access, None), Some("access"));
+    assert_eq!(agent_key(&DatabaseType::Oracle, None), Some("oracle"));
+    assert_eq!(agent_key(&DatabaseType::Databend, None), Some("databend"));
+    assert_eq!(agent_key(&DatabaseType::InfluxDb, None), Some("influxdb"));
+    assert_eq!(agent_key(&DatabaseType::ZooKeeper, None), Some("zookeeper"));
+    assert_eq!(agent_key(&DatabaseType::Oracle, Some("oracle-legacy")), Some("oracle"));
+    assert_eq!(agent_key(&DatabaseType::Oracle, Some("oracle-10g")), Some("oracle"));
+    assert_eq!(agent_key(&DatabaseType::SqlServer, Some("sqlserver-legacy")), Some("sqlserver-legacy"));
+    assert_eq!(agent_key(&DatabaseType::SqlServer, None), None);
+    assert_eq!(agent_key(&DatabaseType::Postgres, None), None);
+}
+
+#[test]
+fn driver_store_entries_do_not_repeat_agent_keys() {
+    let entries: Vec<_> = agent_catalog::driver_store_entries().collect();
+    let mut seen = HashSet::new();
+    let duplicate_keys: Vec<_> = entries.iter().map(|(key, _)| *key).filter(|key| !seen.insert(*key)).collect();
+
+    assert!(duplicate_keys.is_empty(), "driver store agent keys should be unique: {duplicate_keys:?}");
+    assert_eq!(entries.iter().filter(|(key, _)| *key == "gbase8a").count(), 1);
+    assert_eq!(entries.iter().filter(|(key, _)| *key == "gbase8s").count(), 1);
+    assert_eq!(entries.iter().filter(|(key, _)| *key == "sqlserver-legacy").count(), 1);
+    assert_eq!(agent_catalog::label_for_key("sqlserver-legacy"), Some("SQL Server legacy compatibility component"));
+}
+
+#[test]
+fn classifies_agent_database_types() {
+    assert!(is_agent_type(&DatabaseType::Oracle));
+    assert!(is_agent_type(&DatabaseType::Trino));
+    assert!(is_agent_type(&DatabaseType::Hive));
+    assert!(is_agent_type(&DatabaseType::Tdengine));
+    assert!(is_agent_type(&DatabaseType::Iotdb));
+    assert!(is_agent_type(&DatabaseType::Yashandb));
+    assert!(is_agent_type(&DatabaseType::Databricks));
+    assert!(is_agent_type(&DatabaseType::SapHana));
+    assert!(is_agent_type(&DatabaseType::Teradata));
+    assert!(is_agent_type(&DatabaseType::Vertica));
+    assert!(is_agent_type(&DatabaseType::Firebird));
+    assert!(is_agent_type(&DatabaseType::Exasol));
+    assert!(is_agent_type(&DatabaseType::OceanbaseOracle));
+    assert!(is_agent_type(&DatabaseType::Gbase));
+    assert!(is_agent_type(&DatabaseType::Access));
+    assert!(is_agent_type(&DatabaseType::Databend));
+    assert!(is_agent_type(&DatabaseType::InfluxDb));
+    assert!(is_agent_type(&DatabaseType::ZooKeeper));
+    assert!(!is_agent_type(&DatabaseType::Mysql));
+    assert!(!is_agent_type(&DatabaseType::Jdbc));
+    assert!(!is_agent_type(&DatabaseType::Gaussdb));
+    assert!(!is_agent_type(&DatabaseType::Kwdb));
+    assert!(!is_agent_type(&DatabaseType::OpenGauss));
+    assert!(!is_agent_type(&DatabaseType::Questdb));
+}
+
+#[test]
+fn identifies_single_connection_pool_types() {
+    assert!(is_single_connection_pool(&DatabaseType::Sqlite));
+    assert!(is_single_connection_pool(&DatabaseType::DuckDb));
+    assert!(is_single_connection_pool(&DatabaseType::MongoDb));
+    assert!(is_single_connection_pool(&DatabaseType::Oracle));
+    assert!(is_single_connection_pool(&DatabaseType::Dameng));
+    assert!(is_single_connection_pool(&DatabaseType::Access));
+    assert!(is_single_connection_pool(&DatabaseType::Yashandb));
+    assert!(is_single_connection_pool(&DatabaseType::Firebird));
+    assert!(is_single_connection_pool(&DatabaseType::OceanbaseOracle));
+    assert!(is_single_connection_pool(&DatabaseType::Jdbc));
+    assert!(!is_single_connection_pool(&DatabaseType::Trino));
+    assert!(!is_single_connection_pool(&DatabaseType::Postgres));
+    assert!(!is_single_connection_pool(&DatabaseType::Kwdb));
+}
+
+#[test]
+fn identifies_metadata_connections_that_drop_database_scope() {
+    assert!(is_metadata_connection_scoped(&DatabaseType::Mysql));
+    assert!(!is_metadata_connection_scoped(&DatabaseType::Doris));
+    assert!(!is_metadata_connection_scoped(&DatabaseType::StarRocks));
+    assert!(!is_metadata_connection_scoped(&DatabaseType::Postgres));
+    assert!(!is_metadata_connection_scoped(&DatabaseType::Kwdb));
+    assert!(!is_metadata_connection_scoped(&DatabaseType::Oracle));
+}
+
+#[test]
+fn skips_tcp_probe_for_local_file_plugin_and_agent_types() {
+    assert!(skips_tcp_probe(&DatabaseType::Sqlite));
+    assert!(skips_tcp_probe(&DatabaseType::DuckDb));
+    assert!(skips_tcp_probe(&DatabaseType::Jdbc));
+    assert!(skips_tcp_probe(&DatabaseType::Access));
+    assert!(skips_tcp_probe(&DatabaseType::H2));
+    assert!(skips_tcp_probe(&DatabaseType::Trino));
+    assert!(skips_tcp_probe(&DatabaseType::Oracle));
+    assert!(skips_tcp_probe(&DatabaseType::Tdengine));
+    assert!(skips_tcp_probe(&DatabaseType::Iotdb));
+    assert!(skips_tcp_probe(&DatabaseType::Yashandb));
+    assert!(skips_tcp_probe(&DatabaseType::Databricks));
+    assert!(skips_tcp_probe(&DatabaseType::OceanbaseOracle));
+    assert!(skips_tcp_probe(&DatabaseType::Gbase));
+    assert!(skips_tcp_probe(&DatabaseType::Databend));
+    assert!(skips_tcp_probe(&DatabaseType::InfluxDb));
+    assert!(skips_tcp_probe(&DatabaseType::MessageQueue));
+    assert!(skips_tcp_probe(&DatabaseType::ZooKeeper));
+    assert!(!skips_tcp_probe(&DatabaseType::Postgres));
+    assert!(!skips_tcp_probe(&DatabaseType::Mysql));
+    assert!(!skips_tcp_probe(&DatabaseType::Gaussdb));
+    assert!(!skips_tcp_probe(&DatabaseType::Kwdb));
+    assert!(!skips_tcp_probe(&DatabaseType::OpenGauss));
+    assert!(!skips_tcp_probe(&DatabaseType::Questdb));
+}
+
+#[test]
+fn driver_manifest_matches_core_database_capabilities() {
+    let manifest = driver_manifest();
+    let support_levels = ["connect", "browse", "understand", "operate"];
+
+    for driver in &manifest.drivers {
+        // MQ is a message queue, not a database — skip database capability checks
+        if driver.db_type == DatabaseType::MessageQueue {
+            continue;
+        }
+        assert!(
+            support_levels.contains(&driver.support_level.as_str()),
+            "invalid support level for {:?}",
+            driver.db_type
+        );
+        assert!(
+            driver.capabilities.any_enabled(),
+            "database {:?} should declare at least one product capability",
+            driver.db_type
+        );
+        assert_eq!(
+            is_agent_type(&driver.db_type),
+            driver.runtime_mode == "agent",
+            "agent classification mismatch for {:?}",
+            driver.db_type
+        );
+        assert_eq!(
+            agent_key(&driver.db_type, None),
+            driver.agent_key.as_deref(),
+            "agent key mismatch for {:?}",
+            driver.db_type
+        );
+        assert_eq!(
+            is_single_connection_pool(&driver.db_type),
+            driver.single_connection_pool,
+            "single-pool mismatch for {:?}",
+            driver.db_type
+        );
+        assert_eq!(
+            is_metadata_connection_scoped(&driver.db_type),
+            driver.metadata_connection_scoped,
+            "metadata scope mismatch for {:?}",
+            driver.db_type
+        );
+        assert_eq!(
+            skips_tcp_probe(&driver.db_type),
+            driver.skip_tcp_probe,
+            "TCP probe behavior mismatch for {:?}",
+            driver.db_type
+        );
+
+        for profile in &driver.driver_profiles {
+            assert_eq!(
+                agent_key(&driver.db_type, Some(&profile.profile)),
+                Some(profile.agent_key.as_str()),
+                "profile agent key mismatch for {:?}/{}",
+                driver.db_type,
+                profile.profile
+            );
+        }
+    }
+}
+
+#[test]
+fn driver_manifest_declares_expected_product_capabilities() {
+    let manifest = driver_manifest();
+    let find_driver = |db_type: DatabaseType| {
+        manifest
+            .drivers
+            .iter()
+            .find(|driver| driver.db_type == db_type)
+            .unwrap_or_else(|| panic!("{db_type:?} manifest entry"))
+    };
+
+    let mysql = find_driver(DatabaseType::Mysql);
+    assert_eq!(mysql.support_level, "operate");
+    assert!(mysql.capabilities.schema_search);
+    assert!(mysql.capabilities.table_structure_edit);
+    assert!(mysql.capabilities.sql_explain);
+    assert!(!mysql.capabilities.driver_management);
+
+    let jdbc = find_driver(DatabaseType::Jdbc);
+    assert_eq!(jdbc.support_level, "browse");
+    assert!(jdbc.capabilities.metadata_browse);
+    assert!(jdbc.capabilities.object_browser);
+    assert!(jdbc.capabilities.sql_file_execution);
+    assert!(!jdbc.capabilities.table_structure_edit);
+    assert!(!jdbc.capabilities.user_admin);
+
+    let manticore = find_driver(DatabaseType::ManticoreSearch);
+    assert_eq!(manticore.support_level, "operate");
+    assert!(manticore.capabilities.metadata_browse);
+    assert!(manticore.capabilities.sql_file_execution);
+    assert!(manticore.capabilities.table_structure_edit);
+    assert!(!manticore.capabilities.object_browser);
+    assert!(manticore.capabilities.table_data_edit);
+
+    let redis = find_driver(DatabaseType::Redis);
+    assert_eq!(redis.support_level, "connect");
+    assert!(!redis.capabilities.object_browser);
+    assert!(!redis.capabilities.sql_file_execution);
+
+    let zookeeper = find_driver(DatabaseType::ZooKeeper);
+    assert_eq!(zookeeper.label, "Apache ZooKeeper");
+    assert_eq!(zookeeper.runtime_mode, "agent");
+    assert_eq!(zookeeper.agent_key.as_deref(), Some("zookeeper"));
+    assert_eq!(zookeeper.support_level, "connect");
+    assert!(zookeeper.capabilities.query_execution);
+    assert!(zookeeper.capabilities.driver_management);
+    assert!(!zookeeper.capabilities.metadata_browse);
+}
+
+#[test]
+fn kingbase_declares_data_transfer_support() {
+    let manifest = driver_manifest();
+    let kingbase = manifest
+        .drivers
+        .iter()
+        .find(|driver| driver.db_type == DatabaseType::Kingbase)
+        .expect("Kingbase manifest entry");
+
+    assert!(kingbase.capabilities.table_import);
+    assert!(kingbase.capabilities.data_transfer);
+}
diff --git a/crates/dbx-core/tests/duckdb_worker_process.rs b/crates/dbx-core/tests/duckdb_worker_process.rs
new file mode 100644
index 0000000..04b3589
--- /dev/null
+++ b/crates/dbx-core/tests/duckdb_worker_process.rs
@@ -0,0 +1,484 @@
+#![cfg(feature = "duckdb-bundled")]
+
+use std::path::PathBuf;
+use std::process::Stdio;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::OnceLock;
+use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+use dbx_core::db::duckdb_worker_process::DuckDbWorkerClient;
+use dbx_core::db::duckdb_worker_protocol::{
+    DuckDbWorkerConnectParams, DuckDbWorkerExecuteParams, DuckDbWorkerMethod, DuckDbWorkerRequest, DuckDbWorkerResponse,
+};
+use dbx_core::query_cancel::{RunningQueries, RunningTaskMetadata};
+use sysinfo::{Pid, ProcessRefreshKind, ProcessesToUpdate, RefreshKind, System};
+use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+use tokio::process::Command;
+use tokio_util::sync::CancellationToken;
+
+static TEMP_DB_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn worker_process_recovers_immediately_after_cancelled_long_query() {
+    let _guard = duckdb_worker_process_test_guard().await;
+    let executable = PathBuf::from(env!("CARGO_BIN_EXE_duckdb-worker-test-host"));
+    let db_path = temp_duckdb_path();
+    let _ = std::fs::remove_file(&db_path);
+
+    let client =
+        DuckDbWorkerClient::open_with_executable(executable, db_path.to_string_lossy().to_string(), Vec::new())
+            .await
+            .expect("worker process connects");
+
+    let token = CancellationToken::new();
+    let long_query = client.execute(
+        None,
+        "SELECT sum(sin(i::DOUBLE) * cos(i::DOUBLE / 3.0)) FROM range(100000000000) AS t(i)".to_string(),
+        Some(10),
+        Some(token.clone()),
+        Some(Duration::from_secs(30)),
+    );
+    tokio::pin!(long_query);
+
+    tokio::time::sleep(Duration::from_millis(200)).await;
+    token.cancel();
+
+    let cancelled = tokio::time::timeout(Duration::from_secs(5), &mut long_query)
+        .await
+        .expect("cancelled query should return promptly");
+    assert_eq!(cancelled.expect_err("long query should be cancelled"), dbx_core::query::canceled_error());
+
+    let probe = tokio::time::timeout(
+        Duration::from_secs(5),
+        client.execute(
+            None,
+            "SELECT 1 AS after_cancel_probe".to_string(),
+            Some(10),
+            None,
+            Some(Duration::from_secs(5)),
+        ),
+    )
+    .await
+    .expect("probe query should not hang")
+    .expect("probe query should succeed");
+
+    assert_eq!(probe.columns, vec!["after_cancel_probe".to_string()]);
+    assert_eq!(probe.rows, vec![vec![serde_json::json!(1)]]);
+
+    client.shutdown().await;
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn worker_process_recovers_after_registered_cancel_interrupt() {
+    let _guard = duckdb_worker_process_test_guard().await;
+    let executable = PathBuf::from(env!("CARGO_BIN_EXE_duckdb-worker-test-host"));
+    let db_path = temp_duckdb_path();
+    let _ = std::fs::remove_file(&db_path);
+
+    let client =
+        DuckDbWorkerClient::open_with_executable(executable, db_path.to_string_lossy().to_string(), Vec::new())
+            .await
+            .expect("worker process connects");
+
+    let running_queries = RunningQueries::default();
+    let execution_id = "duckdb-worker-cancel-test";
+    let registered = running_queries
+        .register_task(execution_id.to_string(), RunningTaskMetadata::query("duckdb-conn", "main", None));
+    let cancel_client = client.clone();
+    running_queries.register_interrupt(execution_id, move || {
+        let cancel_client = cancel_client.clone();
+        tokio::spawn(async move {
+            let _ = cancel_client.cancel().await;
+        });
+    });
+
+    let long_query = client.execute(
+        None,
+        "SELECT sum(sin(i::DOUBLE) * cos(i::DOUBLE / 3.0)) FROM range(100000000000) AS t(i)".to_string(),
+        Some(10),
+        Some(registered.token()),
+        Some(Duration::from_secs(30)),
+    );
+    tokio::pin!(long_query);
+
+    tokio::time::sleep(Duration::from_millis(200)).await;
+    assert!(running_queries.cancel(execution_id));
+
+    let cancelled = tokio::time::timeout(Duration::from_secs(5), &mut long_query)
+        .await
+        .expect("cancelled query should return promptly");
+    assert_eq!(cancelled.expect_err("long query should be cancelled"), dbx_core::query::canceled_error());
+    drop(registered);
+
+    let probe = tokio::time::timeout(
+        Duration::from_secs(5),
+        client.execute(
+            None,
+            "SELECT 1 AS after_cancel_probe".to_string(),
+            Some(10),
+            None,
+            Some(Duration::from_secs(5)),
+        ),
+    )
+    .await
+    .expect("probe query should not hang")
+    .expect("probe query should succeed");
+
+    assert_eq!(probe.columns, vec!["after_cancel_probe".to_string()]);
+    assert_eq!(probe.rows, vec![vec![serde_json::json!(1)]]);
+
+    client.shutdown().await;
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn worker_process_recovers_after_parser_error() {
+    let _guard = duckdb_worker_process_test_guard().await;
+    let executable = PathBuf::from(env!("CARGO_BIN_EXE_duckdb-worker-test-host"));
+    let db_path = temp_duckdb_path();
+    let _ = std::fs::remove_file(&db_path);
+
+    let client =
+        DuckDbWorkerClient::open_with_executable(executable, db_path.to_string_lossy().to_string(), Vec::new())
+            .await
+            .expect("worker process connects");
+
+    client
+        .execute(
+            None,
+            "CREATE TABLE events (id INTEGER, name VARCHAR); INSERT INTO events VALUES (1, 'login');".to_string(),
+            Some(10),
+            None,
+            Some(Duration::from_secs(5)),
+        )
+        .await
+        .expect("create events table");
+
+    let err = client
+        .execute(None, "select * from table limit 19;".to_string(), Some(10), None, Some(Duration::from_secs(5)))
+        .await
+        .expect_err("reserved word query should fail");
+    assert!(err.contains("Parser Error"), "unexpected error: {err}");
+
+    let probe = tokio::time::timeout(
+        Duration::from_secs(5),
+        client.execute(
+            None,
+            "SELECT * FROM events LIMIT 100;".to_string(),
+            Some(100),
+            None,
+            Some(Duration::from_secs(5)),
+        ),
+    )
+    .await
+    .expect("query after parser error should not hang")
+    .expect("query after parser error should succeed");
+
+    assert_eq!(probe.columns, vec!["id".to_string(), "name".to_string()]);
+    assert_eq!(probe.rows, vec![vec![serde_json::json!(1), serde_json::json!("login")]]);
+
+    client.shutdown().await;
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn worker_process_keeps_session_state_after_benign_error() {
+    let _guard = duckdb_worker_process_test_guard().await;
+    let executable = PathBuf::from(env!("CARGO_BIN_EXE_duckdb-worker-test-host"));
+    let db_path = temp_duckdb_path();
+    let _ = std::fs::remove_file(&db_path);
+
+    let client =
+        DuckDbWorkerClient::open_with_executable(executable, db_path.to_string_lossy().to_string(), Vec::new())
+            .await
+            .expect("worker process connects");
+
+    // Temp tables live only in the worker's session. If a benign error restarted the
+    // worker, this table would be gone after the error.
+    client
+        .execute(
+            None,
+            "CREATE TEMP TABLE scratch (id INTEGER); INSERT INTO scratch VALUES (7);".to_string(),
+            Some(10),
+            None,
+            Some(Duration::from_secs(5)),
+        )
+        .await
+        .expect("create temp table");
+
+    // Catalog error: prepare succeeds, the query fails at bind/exec time. This does not
+    // poison the connection, so the worker must stay alive and keep the temp table.
+    let err = client
+        .execute(None, "SELECT * FROM does_not_exist;".to_string(), Some(10), None, Some(Duration::from_secs(5)))
+        .await
+        .expect_err("missing table query should fail");
+    assert!(err.contains("does_not_exist") || err.contains("Catalog Error"), "unexpected error: {err}");
+
+    let probe = tokio::time::timeout(
+        Duration::from_secs(5),
+        client.execute(None, "SELECT id FROM scratch;".to_string(), Some(10), None, Some(Duration::from_secs(5))),
+    )
+    .await
+    .expect("query after benign error should not hang")
+    .expect("temp table should still exist after a benign error");
+
+    assert_eq!(probe.columns, vec!["id".to_string()]);
+    assert_eq!(probe.rows, vec![vec![serde_json::json!(7)]]);
+
+    client.shutdown().await;
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn worker_process_exits_when_stdin_closes_during_active_query() {
+    let _guard = duckdb_worker_process_test_guard().await;
+    let executable = PathBuf::from(env!("CARGO_BIN_EXE_duckdb-worker-test-host"));
+    let db_path = temp_duckdb_path();
+    let _ = std::fs::remove_file(&db_path);
+    let mut child = Command::new(executable)
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::inherit())
+        .spawn()
+        .expect("spawn worker");
+    let mut stdin = child.stdin.take().expect("worker stdin");
+    let stdout = child.stdout.take().expect("worker stdout");
+    let mut lines = BufReader::new(stdout).lines();
+
+    write_worker_request(
+        &mut stdin,
+        DuckDbWorkerRequest::new(
+            "connect",
+            DuckDbWorkerMethod::Connect,
+            DuckDbWorkerConnectParams { path: db_path.to_string_lossy().to_string(), attached_databases: Vec::new() },
+        )
+        .expect("connect request"),
+    )
+    .await;
+    let connected = read_worker_response(&mut lines).await;
+    assert!(connected.ok, "connect failed: {connected:?}");
+
+    write_worker_request(
+        &mut stdin,
+        DuckDbWorkerRequest::new(
+            "long-query",
+            DuckDbWorkerMethod::Execute,
+            DuckDbWorkerExecuteParams {
+                sql: "SELECT sum(sin(i::DOUBLE) * cos(i::DOUBLE / 3.0)) FROM range(100000000000) AS t(i)".to_string(),
+                database: None,
+                max_rows: Some(10),
+            },
+        )
+        .expect("execute request"),
+    )
+    .await;
+
+    tokio::time::sleep(Duration::from_millis(200)).await;
+    drop(stdin);
+
+    tokio::time::timeout(Duration::from_secs(5), child.wait())
+        .await
+        .expect("worker should exit after stdin closes")
+        .expect("wait for worker");
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn worker_process_is_killed_after_connect_timeout() {
+    let _guard = duckdb_worker_process_test_guard().await;
+    let executable = PathBuf::from(env!("CARGO_BIN_EXE_duckdb-worker-hanging-connect-test-host"));
+    let db_path = temp_duckdb_path();
+    let pid_file = temp_pid_path();
+    let _ = std::fs::remove_file(&pid_file);
+    let _ = std::fs::remove_file(&db_path);
+
+    std::env::set_var("DBX_DUCKDB_HANGING_CONNECT_PID_FILE", &pid_file);
+    let client = DuckDbWorkerClient::new_unconnected_with_timeouts(
+        executable,
+        db_path.to_string_lossy().to_string(),
+        Vec::new(),
+        4,
+        Duration::from_secs(1),
+        Duration::from_secs(5),
+    );
+
+    let err = client
+        .execute(None, "SELECT 1".to_string(), Some(10), None, Some(Duration::from_secs(5)))
+        .await
+        .expect_err("connect should time out");
+    std::env::remove_var("DBX_DUCKDB_HANGING_CONNECT_PID_FILE");
+    assert!(err.contains("timed out"), "unexpected error: {err}");
+
+    let pid = read_pid_file(&pid_file).expect("hanging worker pid");
+    wait_until_process_exits(pid, Duration::from_secs(5)).await;
+
+    let _ = std::fs::remove_file(&pid_file);
+    let _ = std::fs::remove_file(&db_path);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn worker_process_is_killed_after_connect_error() {
+    let _guard = duckdb_worker_process_test_guard().await;
+    let executable = PathBuf::from(env!("CARGO_BIN_EXE_duckdb-worker-pid-test-host"));
+    let missing_dir = temp_duckdb_path();
+    let db_path = missing_dir.join("missing.duckdb");
+    let pid_file = temp_pid_path();
+    let _ = std::fs::remove_file(&pid_file);
+    let _ = std::fs::remove_dir_all(&missing_dir);
+
+    std::env::set_var("DBX_DUCKDB_PID_TEST_HOST_PID_FILE", &pid_file);
+    let client = DuckDbWorkerClient::new_unconnected_with_timeouts(
+        executable,
+        db_path.to_string_lossy().to_string(),
+        Vec::new(),
+        4,
+        Duration::from_secs(5),
+        Duration::from_secs(5),
+    );
+
+    let err = client
+        .execute(None, "SELECT 1".to_string(), Some(10), None, Some(Duration::from_secs(5)))
+        .await
+        .expect_err("connect should fail with an invalid DuckDB path");
+    std::env::remove_var("DBX_DUCKDB_PID_TEST_HOST_PID_FILE");
+    assert!(
+        err.contains("Cannot open file")
+            || err.contains("No such file")
+            || err.contains("Parent directory does not exist")
+            || err.contains("不存在"),
+        "unexpected error: {err}"
+    );
+
+    let pid = read_pid_file(&pid_file).expect("worker pid");
+    wait_until_process_exits(pid, Duration::from_secs(5)).await;
+
+    let _ = std::fs::remove_file(&pid_file);
+    let _ = std::fs::remove_dir_all(&missing_dir);
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn worker_process_retries_connect_after_transient_file_lock() {
+    let _guard = duckdb_worker_process_test_guard().await;
+    let executable = PathBuf::from(env!("CARGO_BIN_EXE_duckdb-worker-test-host"));
+    let lock_owner_executable = PathBuf::from(env!("CARGO_BIN_EXE_duckdb-worker-file-lock-owner"));
+    let db_path = temp_duckdb_path();
+    let _ = std::fs::remove_file(&db_path);
+
+    let mut lock_owner = Command::new(lock_owner_executable)
+        .arg(&db_path)
+        .arg("500")
+        .stdout(Stdio::piped())
+        .stderr(Stdio::inherit())
+        .kill_on_drop(true)
+        .spawn()
+        .expect("spawn lock owner");
+    let lock_owner_stdout = lock_owner.stdout.take().expect("lock owner stdout");
+    let mut lock_owner_lines = BufReader::new(lock_owner_stdout).lines();
+    let ready = tokio::time::timeout(Duration::from_secs(5), lock_owner_lines.next_line())
+        .await
+        .expect("lock owner ready timed out")
+        .expect("read lock owner ready line")
+        .expect("lock owner ready line");
+    assert_eq!(ready, "ready");
+
+    let client = DuckDbWorkerClient::new_unconnected_with_timeouts(
+        executable,
+        db_path.to_string_lossy().to_string(),
+        Vec::new(),
+        4,
+        Duration::from_secs(5),
+        Duration::from_secs(5),
+    );
+    let result = tokio::time::timeout(
+        Duration::from_secs(5),
+        client.execute(None, "SELECT 42 AS retried".to_string(), Some(10), None, Some(Duration::from_secs(5))),
+    )
+    .await;
+
+    tokio::time::timeout(Duration::from_secs(5), lock_owner.wait())
+        .await
+        .expect("lock owner should exit")
+        .expect("wait for lock owner");
+    client.shutdown().await;
+    let _ = std::fs::remove_file(&db_path);
+
+    let result = result
+        .expect("retrying connect should not hang")
+        .expect("connect should retry after a transient DuckDB file lock");
+    assert_eq!(result.columns, vec!["retried".to_string()]);
+    assert_eq!(result.rows, vec![vec![serde_json::json!(42)]]);
+}
+
+async fn write_worker_request(stdin: &mut tokio::process::ChildStdin, request: DuckDbWorkerRequest) {
+    let line = serde_json::to_string(&request).expect("request json");
+    stdin.write_all(line.as_bytes()).await.expect("write request");
+    stdin.write_all(b"\n").await.expect("write newline");
+    stdin.flush().await.expect("flush request");
+}
+
+async fn read_worker_response(
+    lines: &mut tokio::io::Lines<BufReader<tokio::process::ChildStdout>>,
+) -> DuckDbWorkerResponse {
+    let line = tokio::time::timeout(Duration::from_secs(5), lines.next_line())
+        .await
+        .expect("worker response timed out")
+        .expect("read worker response")
+        .expect("worker response line");
+    serde_json::from_str(&line).expect("parse worker response")
+}
+
+fn temp_duckdb_path() -> PathBuf {
+    let suffix = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
+    let pid = std::process::id();
+    // These tests run concurrently; the counter prevents same-tick temp DB paths
+    // from sharing a DuckDB file lock.
+    let counter = TEMP_DB_COUNTER.fetch_add(1, Ordering::Relaxed);
+    std::env::temp_dir().join(format!("dbx-duckdb-worker-process-{pid}-{suffix}-{counter}.duckdb"))
+}
+
+async fn duckdb_worker_process_test_guard() -> tokio::sync::MutexGuard<'static, ()> {
+    static GUARD: OnceLock<tokio::sync::Mutex<()>> = OnceLock::new();
+    GUARD.get_or_init(|| tokio::sync::Mutex::new(())).lock().await
+}
+
+fn temp_pid_path() -> PathBuf {
+    let suffix = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
+    let pid = std::process::id();
+    let counter = TEMP_DB_COUNTER.fetch_add(1, Ordering::Relaxed);
+    std::env::temp_dir().join(format!("dbx-duckdb-worker-process-{pid}-{suffix}-{counter}.pid"))
+}
+
+fn read_pid_file(path: &PathBuf) -> Option<u32> {
+    for _ in 0..20 {
+        if let Ok(contents) = std::fs::read_to_string(path) {
+            if let Ok(pid) = contents.trim().parse::<u32>() {
+                return Some(pid);
+            }
+        }
+        std::thread::sleep(Duration::from_millis(25));
+    }
+    None
+}
+
+async fn wait_until_process_exits(pid: u32, timeout: Duration) {
+    let deadline = tokio::time::Instant::now() + timeout;
+    loop {
+        if !process_exists(pid) {
+            return;
+        }
+        assert!(tokio::time::Instant::now() < deadline, "worker process {pid} should have been killed");
+        tokio::time::sleep(Duration::from_millis(50)).await;
+    }
+}
+
+fn process_exists(pid: u32) -> bool {
+    let mut system =
+        System::new_with_specifics(RefreshKind::new().with_processes(ProcessRefreshKind::new().with_memory()));
+    system.refresh_processes_specifics(
+        ProcessesToUpdate::Some(&[Pid::from(pid as usize)]),
+        true,
+        ProcessRefreshKind::new().with_memory(),
+    );
+    system.process(Pid::from(pid as usize)).is_some()
+}
diff --git a/crates/dbx-core/tests/live_clickhouse_query_result_export.rs b/crates/dbx-core/tests/live_clickhouse_query_result_export.rs
new file mode 100644
index 0000000..beb693a
--- /dev/null
+++ b/crates/dbx-core/tests/live_clickhouse_query_result_export.rs
@@ -0,0 +1,121 @@
+use std::collections::BTreeSet;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use dbx_core::connection::AppState;
+use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
+use dbx_core::query_result_export::{export_query_result_core, ExportStatus, QueryResultExportRequest};
+use dbx_core::storage::Storage;
+use dbx_core::table_import::parse_xlsx_file;
+
+fn live_clickhouse_config(
+    id: &str,
+    host: &str,
+    port: u16,
+    user: &str,
+    password: &str,
+    database: &str,
+) -> ConnectionConfig {
+    serde_json::from_value(serde_json::json!({
+        "id": id,
+        "name": id,
+        "db_type": DatabaseType::ClickHouse,
+        "host": host,
+        "port": port,
+        "username": user,
+        "password": password,
+        "database": database,
+        "connect_timeout_secs": 10,
+        "query_timeout_secs": 30,
+        "idle_timeout_secs": 60,
+        "keepalive_interval_secs": 0
+    }))
+    .expect("live ClickHouse config should deserialize")
+}
+
+fn json_cell_text(value: &serde_json::Value) -> String {
+    match value {
+        serde_json::Value::String(value) => value.clone(),
+        serde_json::Value::Number(value) => value.to_string(),
+        serde_json::Value::Bool(value) => value.to_string(),
+        serde_json::Value::Null => String::new(),
+        other => other.to_string(),
+    }
+}
+
+fn json_cell_i64(value: &serde_json::Value) -> i64 {
+    if let Some(value) = value.as_i64() {
+        return value;
+    }
+    if let Some(value) = value.as_u64() {
+        return i64::try_from(value).expect("u64 id fits in i64");
+    }
+    let text = json_cell_text(value);
+    text.parse::<i64>().or_else(|_| text.parse::<f64>().map(|value| value as i64)).expect("numeric id")
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_CLICKHOUSE_* env vars pointing at a ClickHouse HTTP endpoint"]
+async fn live_clickhouse_query_result_export_xlsx_streams_random_order_query_once() {
+    let host = std::env::var("DBX_LIVE_CLICKHOUSE_HOST").expect("DBX_LIVE_CLICKHOUSE_HOST");
+    let port = std::env::var("DBX_LIVE_CLICKHOUSE_PORT").expect("DBX_LIVE_CLICKHOUSE_PORT").parse::<u16>().unwrap();
+    let user = std::env::var("DBX_LIVE_CLICKHOUSE_USER").expect("DBX_LIVE_CLICKHOUSE_USER");
+    let password = std::env::var("DBX_LIVE_CLICKHOUSE_PASSWORD").expect("DBX_LIVE_CLICKHOUSE_PASSWORD");
+    let database = std::env::var("DBX_LIVE_CLICKHOUSE_DATABASE").expect("DBX_LIVE_CLICKHOUSE_DATABASE");
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let connection_id = format!("live-clickhouse-query-export-{suffix}");
+    let config = live_clickhouse_config(&connection_id, &host, port, &user, &password, &database);
+    let dir = std::env::temp_dir().join(format!("dbx-live-clickhouse-query-export-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = AppState::new(storage);
+    state.configs.write().await.insert(config.id.clone(), config);
+
+    let file_path = dir.join("result.xlsx");
+    let sql = "
+        SELECT
+            number + 1 AS id,
+            concat('row-', toString(number + 1)) AS label
+        FROM numbers(2050)
+        ORDER BY rand()
+    "
+    .to_string();
+    let request = QueryResultExportRequest {
+        export_id: format!("live-clickhouse-query-export-{suffix}"),
+        connection_id: connection_id.clone(),
+        database: database.clone(),
+        schema: None,
+        sql: sql.clone(),
+        query_base_sql: sql,
+        database_type: DatabaseType::ClickHouse,
+        use_agent_cursor: false,
+        file_path: file_path.to_string_lossy().to_string(),
+        format: "xlsx".to_string(),
+        page_size: 100,
+        row_limit: None,
+        total_rows: Some(2050),
+        timeout_secs: Some(30),
+        keyset_optimization_enabled: false,
+        client_session_id: None,
+        execution_id: Some(format!("live-clickhouse-query-export-{suffix}")),
+    };
+    let done_seen = AtomicBool::new(false);
+    let result = export_query_result_core(&state, &request, None, |progress| {
+        if matches!(progress.status, ExportStatus::Done) {
+            done_seen.store(true, Ordering::Relaxed);
+        }
+    })
+    .await;
+
+    result.expect("export ClickHouse query result to XLSX without per-page re-execution");
+    assert!(done_seen.load(Ordering::Relaxed));
+
+    let parsed = parse_xlsx_file(&file_path.to_string_lossy(), 3000).expect("parse exported XLSX");
+    let _ = std::fs::remove_dir_all(&dir);
+    assert_eq!(parsed.columns, vec!["id", "label"]);
+    assert_eq!(parsed.total_rows, 2050);
+    assert_eq!(parsed.rows.len(), 2050);
+
+    let exported_ids = parsed.rows.iter().map(|row| json_cell_i64(&row[0])).collect::<BTreeSet<_>>();
+    let expected_ids = (1..=2050).collect::<BTreeSet<_>>();
+    assert_eq!(exported_ids, expected_ids);
+}
diff --git a/crates/dbx-core/tests/live_manual_transaction.rs b/crates/dbx-core/tests/live_manual_transaction.rs
new file mode 100644
index 0000000..60f9995
--- /dev/null
+++ b/crates/dbx-core/tests/live_manual_transaction.rs
@@ -0,0 +1,105 @@
+use dbx_core::connection::AppState;
+use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
+use dbx_core::query::{
+    begin_manual_transaction, commit_manual_transaction, execute_in_manual_transaction, rollback_manual_transaction,
+};
+use dbx_core::storage::Storage;
+
+fn live_config(prefix: &str, db_type: DatabaseType, default_port: u16) -> ConnectionConfig {
+    let host = std::env::var(format!("{prefix}_HOST")).expect("live DB host env var");
+    let port = std::env::var(format!("{prefix}_PORT"))
+        .ok()
+        .and_then(|value| value.parse::<u16>().ok())
+        .unwrap_or(default_port);
+    let username = std::env::var(format!("{prefix}_USER")).expect("live DB user env var");
+    let password = std::env::var(format!("{prefix}_PASSWORD")).expect("live DB password env var");
+    let database = std::env::var(format!("{prefix}_DATABASE")).expect("live DB database env var");
+
+    serde_json::from_value(serde_json::json!({
+        "id": format!("manual-txn-{prefix}"),
+        "name": format!("Manual transaction {prefix}"),
+        "db_type": db_type,
+        "host": host,
+        "port": port,
+        "username": username,
+        "password": password,
+        "database": database,
+        "connect_timeout_secs": 5,
+        "query_timeout_secs": 30,
+        "idle_timeout_secs": 60,
+        "keepalive_interval_secs": 0
+    }))
+    .expect("live connection config should deserialize")
+}
+
+async fn app_state_with_config(config: ConnectionConfig) -> (AppState, std::path::PathBuf) {
+    let db_path = std::env::temp_dir().join(format!("dbx-live-manual-txn-{}.db", uuid::Uuid::new_v4().simple()));
+    let storage = Storage::open(&db_path).await.expect("open temp storage");
+    let state = AppState::new(storage);
+    state.configs.write().await.insert(config.id.clone(), config);
+    (state, db_path)
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_MANUAL_TXN_POSTGRES_* env vars pointing at writable PostgreSQL"]
+async fn live_manual_transaction_postgres_preserves_typed_selects_and_empty_metadata() {
+    let config = live_config("DBX_LIVE_MANUAL_TXN_POSTGRES", DatabaseType::Postgres, 5432);
+    let database = config.database.clone().expect("database");
+    let (state, db_path) = app_state_with_config(config.clone()).await;
+
+    let txn = begin_manual_transaction(&state, &config.id, &database, None).await.expect("begin");
+    let typed = execute_in_manual_transaction(
+        &state,
+        &txn,
+        "SELECT 1::int4 AS id, 'pg'::text AS label, true AS ok",
+        &database,
+        None,
+        Some(10),
+    )
+    .await
+    .expect("typed select");
+    assert_eq!(typed[0].columns, vec!["id", "label", "ok"]);
+    assert_eq!(typed[0].rows, vec![vec![serde_json::json!(1), serde_json::json!("pg"), serde_json::json!(true)]]);
+
+    let empty = execute_in_manual_transaction(
+        &state,
+        &txn,
+        "SELECT 1::int4 AS id, 'empty'::text AS label WHERE false",
+        &database,
+        None,
+        Some(10),
+    )
+    .await
+    .expect("empty select");
+    assert_eq!(empty[0].columns, vec!["id", "label"]);
+    assert!(empty[0].rows.is_empty());
+
+    commit_manual_transaction(&state, &txn).await.expect("commit");
+    let _ = std::fs::remove_file(db_path);
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_MANUAL_TXN_MYSQL_* env vars pointing at writable MySQL"]
+async fn live_manual_transaction_mysql_streams_with_row_limit() {
+    let config = live_config("DBX_LIVE_MANUAL_TXN_MYSQL", DatabaseType::Mysql, 3306);
+    let database = config.database.clone().expect("database");
+    let (state, db_path) = app_state_with_config(config.clone()).await;
+
+    let txn = begin_manual_transaction(&state, &config.id, &database, None).await.expect("begin");
+    let limited = execute_in_manual_transaction(
+        &state,
+        &txn,
+        "SELECT 1 AS id UNION ALL SELECT 2 UNION ALL SELECT 3",
+        &database,
+        None,
+        Some(2),
+    )
+    .await
+    .expect("limited select");
+    assert_eq!(limited[0].columns, vec!["id"]);
+    assert_eq!(limited[0].rows.len(), 2);
+    assert!(limited[0].truncated);
+
+    rollback_manual_transaction(&state, &txn).await.expect("rollback");
+    let _ = std::fs::remove_file(db_path);
+}
diff --git a/crates/dbx-core/tests/live_mtls.rs b/crates/dbx-core/tests/live_mtls.rs
new file mode 100644
index 0000000..c4352f0
--- /dev/null
+++ b/crates/dbx-core/tests/live_mtls.rs
@@ -0,0 +1,26 @@
+#[tokio::test]
+#[ignore = "requires the remote DBX mTLS smoke-test containers and local client certificates"]
+async fn live_mysql_mtls_connection_succeeds() {
+    let url = std::env::var("DBX_LIVE_MYSQL_MTLS_URL").expect("DBX_LIVE_MYSQL_MTLS_URL");
+    let ca = std::env::var("DBX_LIVE_MYSQL_MTLS_CA").ok();
+
+    let pool = dbx_core::db::mysql::connect_with_ca_cert(&url, ca.as_deref(), std::time::Duration::from_secs(5))
+        .await
+        .unwrap();
+    let result =
+        dbx_core::db::mysql::execute_query(&pool, "SELECT label FROM mtls_smoke WHERE id = 1", false).await.unwrap();
+
+    assert_eq!(result.rows[0][0], serde_json::json!("mysql mtls ok"));
+}
+
+#[tokio::test]
+#[ignore = "requires the remote DBX mTLS smoke-test containers and local client certificates"]
+async fn live_postgres_mtls_connection_succeeds() {
+    let url = std::env::var("DBX_LIVE_POSTGRES_MTLS_URL").expect("DBX_LIVE_POSTGRES_MTLS_URL");
+
+    let pool = dbx_core::db::postgres::connect(&url, std::time::Duration::from_secs(5)).await.unwrap();
+    let result =
+        dbx_core::db::postgres::execute_query(&pool, "SELECT label FROM mtls_smoke WHERE id = 1").await.unwrap();
+
+    assert_eq!(result.rows[0][0], serde_json::json!("postgres mtls ok"));
+}
diff --git a/crates/dbx-core/tests/live_mysql57.rs b/crates/dbx-core/tests/live_mysql57.rs
new file mode 100644
index 0000000..71f073d
--- /dev/null
+++ b/crates/dbx-core/tests/live_mysql57.rs
@@ -0,0 +1,527 @@
+use std::collections::BTreeSet;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use dbx_core::connection::AppState;
+use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
+use dbx_core::query::{execute_multi_core, execute_sql_statement};
+use dbx_core::query_result_export::{export_query_result_core, ExportStatus, QueryResultExportRequest};
+use dbx_core::sql::{split_sql_statements_for_database, SqlFileRequest};
+use dbx_core::sql_file_import::execute_sql_file_path;
+use dbx_core::storage::Storage;
+use dbx_core::table_import::parse_xlsx_file;
+use tokio_util::sync::CancellationToken;
+
+fn live_mysql_sql_file_config(id: &str) -> ConnectionConfig {
+    let host = std::env::var("DBX_LIVE_SQL_FILE_MYSQL_HOST").expect("DBX_LIVE_SQL_FILE_MYSQL_HOST");
+    let port =
+        std::env::var("DBX_LIVE_SQL_FILE_MYSQL_PORT").ok().and_then(|value| value.parse::<u16>().ok()).unwrap_or(3306);
+    let username = std::env::var("DBX_LIVE_SQL_FILE_MYSQL_USER").expect("DBX_LIVE_SQL_FILE_MYSQL_USER");
+    let password = std::env::var("DBX_LIVE_SQL_FILE_MYSQL_PASSWORD").expect("DBX_LIVE_SQL_FILE_MYSQL_PASSWORD");
+
+    serde_json::from_value(serde_json::json!({
+        "id": id,
+        "name": id,
+        "db_type": DatabaseType::Mysql,
+        "host": host,
+        "port": port,
+        "username": username,
+        "password": password,
+        "database": null,
+        "connect_timeout_secs": 5,
+        "query_timeout_secs": 30,
+        "idle_timeout_secs": 60,
+        "keepalive_interval_secs": 0
+    }))
+    .expect("live MySQL SQL file config should deserialize")
+}
+
+async fn app_state_with_config(config: ConnectionConfig) -> (AppState, std::path::PathBuf) {
+    let db_path = std::env::temp_dir().join(format!("dbx-live-sql-file-{}.db", uuid::Uuid::new_v4().simple()));
+    let storage = Storage::open(&db_path).await.expect("open temp storage");
+    let state = AppState::new(storage);
+    state.configs.write().await.insert(config.id.clone(), config);
+    (state, db_path)
+}
+
+fn live_mysql_query_export_config(
+    id: &str,
+    host: &str,
+    port: u16,
+    user: &str,
+    password: &str,
+    database: &str,
+) -> ConnectionConfig {
+    serde_json::from_value(serde_json::json!({
+        "id": id,
+        "name": id,
+        "db_type": DatabaseType::Mysql,
+        "host": host,
+        "port": port,
+        "username": user,
+        "password": password,
+        "database": database,
+        "connect_timeout_secs": 10,
+        "query_timeout_secs": 30,
+        "idle_timeout_secs": 60,
+        "keepalive_interval_secs": 0
+    }))
+    .expect("live MySQL query export config should deserialize")
+}
+
+fn json_cell_text(value: &serde_json::Value) -> String {
+    match value {
+        serde_json::Value::String(value) => value.clone(),
+        serde_json::Value::Number(value) => value.to_string(),
+        serde_json::Value::Bool(value) => value.to_string(),
+        serde_json::Value::Null => String::new(),
+        other => other.to_string(),
+    }
+}
+
+#[tokio::test]
+#[ignore = "requires the remote DBX MySQL 5.7 smoke-test container"]
+async fn live_mysql57_text_protocol_select_succeeds() {
+    let url = std::env::var("DBX_LIVE_MYSQL57_URL").expect("DBX_LIVE_MYSQL57_URL");
+
+    let pool = dbx_core::db::mysql::connect(&url, std::time::Duration::from_secs(5)).await.unwrap();
+    let result = dbx_core::db::mysql::execute_query_with_max_rows(
+        &pool,
+        "SELECT 1 AS id, CAST('mysql57' AS CHAR) AS label",
+        false,
+        Some(10),
+        Default::default(),
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.columns, vec!["id", "label"]);
+    assert_eq!(result.rows, vec![vec![serde_json::json!("1"), serde_json::json!("mysql57")]]);
+}
+
+#[tokio::test]
+#[ignore = "requires a remote MySQL-compatible endpoint with a limited result-set query"]
+async fn live_mysql_compatible_limited_text_protocol_query_succeeds() {
+    let url = std::env::var("DBX_LIVE_MYSQL_COMPAT_URL").expect("DBX_LIVE_MYSQL_COMPAT_URL");
+    let sql = std::env::var("DBX_LIVE_MYSQL_COMPAT_SQL").expect("DBX_LIVE_MYSQL_COMPAT_SQL");
+
+    let pool = dbx_core::db::mysql::connect(&url, std::time::Duration::from_secs(10)).await.unwrap();
+    let result = dbx_core::db::mysql::execute_query_with_max_rows(&pool, &sql, false, Some(100), Default::default())
+        .await
+        .unwrap();
+
+    assert!(!result.columns.is_empty());
+    assert!(!result.rows.is_empty());
+    assert!(result.rows.len() <= 100);
+}
+
+#[tokio::test]
+#[ignore = "requires a writable MySQL endpoint for query-result XLSX export"]
+async fn live_mysql_query_result_export_xlsx_streams_single_query_without_duplicate_batches() {
+    let host = std::env::var("DBX_LIVE_MYSQL_EXPORT_HOST").expect("DBX_LIVE_MYSQL_EXPORT_HOST");
+    let port = std::env::var("DBX_LIVE_MYSQL_EXPORT_PORT").expect("DBX_LIVE_MYSQL_EXPORT_PORT").parse::<u16>().unwrap();
+    let user = std::env::var("DBX_LIVE_MYSQL_EXPORT_USER").expect("DBX_LIVE_MYSQL_EXPORT_USER");
+    let password = std::env::var("DBX_LIVE_MYSQL_EXPORT_PASSWORD").expect("DBX_LIVE_MYSQL_EXPORT_PASSWORD");
+    let database = std::env::var("DBX_LIVE_MYSQL_EXPORT_DATABASE").expect("DBX_LIVE_MYSQL_EXPORT_DATABASE");
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let table = format!("dbx_query_export_{}", &suffix[..8]);
+    let connection_id = format!("live-mysql-query-export-{suffix}");
+    let config = live_mysql_query_export_config(&connection_id, &host, port, &user, &password, &database);
+    let dir = std::env::temp_dir().join(format!("dbx-live-mysql-query-export-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = AppState::new(storage);
+    state.configs.write().await.insert(config.id.clone(), config);
+
+    let values = (1..=250).map(|id| format!("({id}, 'row-{id}')")).collect::<Vec<_>>().join(", ");
+    let cleanup_sql = format!("DROP TABLE IF EXISTS `{table}`");
+    let create_sql = format!("CREATE TABLE `{table}` (id INT PRIMARY KEY, label VARCHAR(32) NOT NULL)");
+    let insert_sql = format!("INSERT INTO `{table}` (id, label) VALUES {values}");
+    let _ = execute_sql_statement(&state, &connection_id, &database, &cleanup_sql, None, None).await;
+    execute_sql_statement(&state, &connection_id, &database, &create_sql, None, None)
+        .await
+        .expect("create live export table");
+    execute_sql_statement(&state, &connection_id, &database, &insert_sql, None, None)
+        .await
+        .expect("insert live export rows");
+
+    let file_path = dir.join("result.xlsx");
+    let sql = format!("SELECT id, label FROM `{table}`");
+    let request = QueryResultExportRequest {
+        export_id: format!("live-mysql-query-export-{suffix}"),
+        connection_id: connection_id.clone(),
+        database: database.clone(),
+        schema: None,
+        sql: sql.clone(),
+        query_base_sql: sql,
+        database_type: DatabaseType::Mysql,
+        use_agent_cursor: false,
+        file_path: file_path.to_string_lossy().to_string(),
+        format: "xlsx".to_string(),
+        page_size: 50,
+        row_limit: None,
+        total_rows: Some(250),
+        timeout_secs: Some(30),
+        keyset_optimization_enabled: false,
+        client_session_id: None,
+        execution_id: Some(format!("live-mysql-query-export-{suffix}")),
+    };
+    let done_seen = AtomicBool::new(false);
+    let result = export_query_result_core(&state, &request, None, |progress| {
+        if matches!(progress.status, ExportStatus::Done) {
+            done_seen.store(true, Ordering::Relaxed);
+        }
+    })
+    .await;
+
+    let cleanup_result = execute_sql_statement(&state, &connection_id, &database, &cleanup_sql, None, None).await;
+    result.expect("export MySQL query result to XLSX");
+    cleanup_result.expect("cleanup live export table");
+    assert!(done_seen.load(Ordering::Relaxed));
+
+    let parsed = parse_xlsx_file(&file_path.to_string_lossy(), 300).expect("parse exported XLSX");
+    let _ = std::fs::remove_dir_all(&dir);
+    assert_eq!(parsed.columns, vec!["id", "label"]);
+    assert_eq!(parsed.total_rows, 250);
+    assert_eq!(parsed.rows.len(), 250);
+
+    let exported_ids = parsed
+        .rows
+        .iter()
+        .map(|row| json_cell_text(&row[0]).parse::<i64>().expect("numeric id"))
+        .collect::<BTreeSet<_>>();
+    let expected_ids = (1..=250).collect::<BTreeSet<_>>();
+    assert_eq!(exported_ids, expected_ids);
+}
+
+#[tokio::test]
+#[ignore = "requires a remote MySQL endpoint"]
+async fn live_mysql_call_procedure_returns_select_result_set() {
+    let url = std::env::var("DBX_LIVE_MYSQL_PROCEDURE_URL").expect("DBX_LIVE_MYSQL_PROCEDURE_URL");
+
+    let pool = dbx_core::db::mysql::connect(&url, std::time::Duration::from_secs(10)).await.unwrap();
+    dbx_core::db::mysql::execute_query_with_max_rows(
+        &pool,
+        "DROP PROCEDURE IF EXISTS proc_test1",
+        false,
+        Some(10),
+        Default::default(),
+    )
+    .await
+    .unwrap();
+    dbx_core::db::mysql::execute_query_with_max_rows(
+        &pool,
+        r#"
+CREATE PROCEDURE proc_test1()
+READS SQL DATA
+BEGIN
+    DROP TEMPORARY TABLE IF EXISTS tb_tmp_001;
+    CREATE TEMPORARY TABLE tb_tmp_001(
+        id INT,
+        NAME VARCHAR(32) DEFAULT ''
+    );
+    INSERT INTO tb_tmp_001(id, NAME) VALUES(1, '测试数据001');
+    SELECT * FROM tb_tmp_001;
+END
+"#,
+        false,
+        Some(10),
+        Default::default(),
+    )
+    .await
+    .unwrap();
+
+    let result = dbx_core::db::mysql::execute_query_with_max_rows(
+        &pool,
+        "CALL proc_test1()",
+        false,
+        Some(10),
+        Default::default(),
+    )
+    .await
+    .unwrap();
+    dbx_core::db::mysql::execute_query_with_max_rows(
+        &pool,
+        "DROP PROCEDURE IF EXISTS proc_test1",
+        false,
+        Some(10),
+        Default::default(),
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.columns, vec!["id", "NAME"]);
+    assert_eq!(result.rows, vec![vec![serde_json::json!("1"), serde_json::json!("测试数据001")]]);
+}
+
+#[tokio::test]
+#[ignore = "requires a remote writable MySQL endpoint"]
+async fn live_mysql_splitter_executes_routine_without_delimiter() {
+    let url = std::env::var("DBX_LIVE_MYSQL_PROCEDURE_URL").expect("DBX_LIVE_MYSQL_PROCEDURE_URL");
+    let pool = dbx_core::db::mysql::connect(&url, std::time::Duration::from_secs(10)).await.unwrap();
+    let procedure = "dbx_issue_2695_proc";
+
+    let sql = format!(
+        "\
+DROP PROCEDURE IF EXISTS {procedure};
+CREATE PROCEDURE {procedure}()
+BEGIN
+    SET @dbx_issue_2695_value = 2695;
+    SELECT @dbx_issue_2695_value AS value;
+END;
+CALL {procedure}();
+DROP PROCEDURE IF EXISTS {procedure};"
+    );
+    let statements = split_sql_statements_for_database(&sql, DatabaseType::Mysql);
+    assert_eq!(statements.len(), 4);
+    assert!(statements[1].contains("SET @dbx_issue_2695_value = 2695;"));
+    assert!(statements[1].contains("SELECT @dbx_issue_2695_value AS value;"));
+    assert!(statements[1].ends_with("END"));
+
+    for statement in statements {
+        dbx_core::db::mysql::execute_query_with_max_rows(&pool, &statement, false, Some(10), Default::default())
+            .await
+            .unwrap();
+    }
+}
+
+#[tokio::test]
+#[ignore = "requires a remote OceanBase MySQL-compatible endpoint"]
+async fn live_oceanbase_mysql_setup_applies_query_timeout() {
+    let url = std::env::var("DBX_LIVE_OCEANBASE_MYSQL_URL").expect("DBX_LIVE_OCEANBASE_MYSQL_URL");
+    let setup = vec!["SET ob_query_timeout = 30000000".to_string()];
+
+    let pool = dbx_core::db::mysql::connect_bare_with_pool_limit_and_setup(
+        &url,
+        std::time::Duration::from_secs(10),
+        1,
+        &setup,
+    )
+    .await
+    .unwrap();
+    let result = dbx_core::db::mysql::execute_query_with_max_rows(
+        &pool,
+        "SELECT @@ob_query_timeout",
+        true,
+        Some(10),
+        Default::default(),
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.rows, vec![vec![serde_json::json!("30000000")]]);
+}
+
+#[tokio::test]
+#[ignore = "requires a remote MySQL endpoint"]
+async fn live_mysql_query_cancel_kills_running_sleep() {
+    let url = std::env::var("DBX_LIVE_MYSQL_CANCEL_URL").expect("DBX_LIVE_MYSQL_CANCEL_URL");
+
+    let opts = mysql_async::OptsBuilder::from_opts(mysql_async::Opts::from_url(&url).unwrap())
+        .pool_opts(mysql_async::PoolOpts::new().with_constraints(mysql_async::PoolConstraints::new(1, 1).unwrap()));
+    let pool = mysql_async::Pool::new(opts);
+    let mut conn = dbx_core::db::mysql::get_conn_with_health_check(&pool).await.unwrap();
+    let connection_id = mysql_async::Conn::id(&conn);
+    let kill_opts = conn.opts().clone();
+
+    let query = tokio::spawn(async move {
+        dbx_core::db::mysql::execute_query_on_conn_with_max_rows(
+            &mut conn,
+            "SELECT SLEEP(30)",
+            false,
+            Some(10),
+            Default::default(),
+        )
+        .await
+    });
+
+    tokio::time::sleep(std::time::Duration::from_millis(500)).await;
+    dbx_core::db::mysql::kill_query_with_opts(kill_opts, connection_id).await.unwrap();
+
+    let started = std::time::Instant::now();
+    let result = query.await.unwrap();
+
+    assert!(started.elapsed() < std::time::Duration::from_secs(5));
+    let result = result.unwrap();
+    assert_eq!(result.rows, vec![vec![serde_json::json!("1")]]);
+}
+
+#[tokio::test]
+#[ignore = "requires a remote MySQL endpoint"]
+async fn live_mysql_recovers_after_server_idle_disconnect() {
+    let url = std::env::var("DBX_LIVE_MYSQL_IDLE_URL").expect("DBX_LIVE_MYSQL_IDLE_URL");
+
+    let pool =
+        dbx_core::db::mysql::connect_with_ca_cert_and_pool_limit(&url, None, std::time::Duration::from_secs(5), 1)
+            .await
+            .unwrap();
+
+    dbx_core::db::mysql::execute_query_with_max_rows(
+        &pool,
+        "SET SESSION wait_timeout = 1",
+        false,
+        Some(10),
+        Default::default(),
+    )
+    .await
+    .unwrap();
+
+    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
+
+    let result = dbx_core::db::mysql::execute_query_with_max_rows(
+        &pool,
+        "SELECT 1 AS recovered",
+        false,
+        Some(10),
+        Default::default(),
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(result.columns, vec!["recovered"]);
+    assert_eq!(result.rows, vec![vec![serde_json::json!("1")]]);
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_SQL_FILE_MYSQL_* env vars pointing at a writable MySQL connection without a required default database"]
+async fn live_mysql_multi_statement_stops_after_first_error() {
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let connection_id = format!("live-mysql-multi-stop-{suffix}");
+    let config = live_mysql_sql_file_config(&connection_id);
+    let (state, db_path) = app_state_with_config(config.clone()).await;
+    let database_name = format!("dbx_issue_2783_{suffix}");
+    let table_name = "statement_order";
+    let script = format!(
+        "INSERT INTO `{table_name}` (id, label) VALUES (1, 'first');\n\
+         INSERT INTO `{table_name}` (id, label) VALUES (1, 'duplicate');\n\
+         INSERT INTO `{table_name}` (id, label) VALUES (2, 'must-not-run');"
+    );
+
+    let result = async {
+        let _ = execute_sql_statement(
+            &state,
+            &config.id,
+            "",
+            &format!("DROP DATABASE IF EXISTS `{database_name}`"),
+            None,
+            None,
+        )
+        .await;
+        execute_sql_statement(&state, &config.id, "", &format!("CREATE DATABASE `{database_name}`"), None, None)
+            .await?;
+        execute_sql_statement(
+            &state,
+            &config.id,
+            &database_name,
+            &format!("CREATE TABLE `{table_name}` (id INT PRIMARY KEY, label VARCHAR(32) NOT NULL)"),
+            None,
+            None,
+        )
+        .await?;
+
+        let results = execute_multi_core(&state, &config.id, &database_name, &script, None, None).await?;
+        let rows = execute_sql_statement(
+            &state,
+            &config.id,
+            &database_name,
+            &format!("SELECT id, label FROM `{table_name}` ORDER BY id"),
+            None,
+            None,
+        )
+        .await?;
+        Ok::<_, String>((results, rows))
+    }
+    .await;
+
+    let _ = execute_sql_statement(
+        &state,
+        &config.id,
+        "",
+        &format!("DROP DATABASE IF EXISTS `{database_name}`"),
+        None,
+        None,
+    )
+    .await;
+    let _ = std::fs::remove_file(db_path);
+
+    let (results, rows) = result.expect("multi-statement execution should return the first failure");
+    assert_eq!(results.len(), 2);
+    assert_eq!(results[0].affected_rows, 1);
+    assert_eq!(results[1].columns, vec!["Error"]);
+    assert_eq!(rows.columns, vec!["id", "label"]);
+    assert_eq!(rows.rows, vec![vec![serde_json::json!("1"), serde_json::json!("first")]]);
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_SQL_FILE_MYSQL_* env vars pointing at a writable MySQL connection without a required default database"]
+async fn live_sql_file_import_creates_database_and_switches_context_without_default_database() {
+    let config = live_mysql_sql_file_config("sql-file-import");
+    let (state, db_path) = app_state_with_config(config.clone()).await;
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let database_name = format!("dbx_issue_2356_{suffix}");
+    let script = format!(
+        r#"
+CREATE DATABASE `{database_name}`;
+USE `{database_name}`;
+CREATE TABLE install_check (
+    id INT PRIMARY KEY
+);
+INSERT INTO install_check (id) VALUES (1), (2);
+"#
+    );
+    let request = SqlFileRequest {
+        execution_id: format!("exec-{suffix}"),
+        connection_id: config.id.clone(),
+        database: String::new(),
+        file_path: std::env::temp_dir()
+            .join(format!("issue-2356-mysql-install-{suffix}.sql"))
+            .to_string_lossy()
+            .into_owned(),
+        continue_on_error: false,
+    };
+
+    let _ = execute_sql_statement(
+        &state,
+        &config.id,
+        "",
+        &format!("DROP DATABASE IF EXISTS `{database_name}`"),
+        None,
+        None,
+    )
+    .await;
+
+    tokio::fs::write(&request.file_path, &script).await.unwrap();
+    let result = execute_sql_file_path(
+        &state,
+        &request,
+        std::path::Path::new(&request.file_path),
+        CancellationToken::new(),
+        std::time::Instant::now(),
+        |_| {},
+    )
+    .await;
+    let verify = execute_sql_statement(
+        &state,
+        &config.id,
+        &database_name,
+        "SELECT COUNT(*) AS count FROM install_check",
+        None,
+        None,
+    )
+    .await;
+    let _ = execute_sql_statement(
+        &state,
+        &config.id,
+        "",
+        &format!("DROP DATABASE IF EXISTS `{database_name}`"),
+        None,
+        None,
+    )
+    .await;
+    let _ = std::fs::remove_file(db_path);
+    let _ = std::fs::remove_file(&request.file_path);
+
+    result.expect("SQL file import should succeed");
+    let verify = verify.expect("verify imported rows");
+    assert_eq!(verify.columns, vec!["count"]);
+    assert_eq!(verify.rows, vec![vec![serde_json::json!("2")]]);
+}
diff --git a/crates/dbx-core/tests/live_postgres_geometry.rs b/crates/dbx-core/tests/live_postgres_geometry.rs
new file mode 100644
index 0000000..e942397
--- /dev/null
+++ b/crates/dbx-core/tests/live_postgres_geometry.rs
@@ -0,0 +1,29 @@
+use std::time::Duration;
+
+#[tokio::test]
+#[ignore = "requires DBX_TEST_POSTGRES_GEOMETRY_URL pointing at a PostGIS database such as local-pg/test_geometry"]
+async fn live_postgres_geometry_values_render_as_text_in_query_results() {
+    let url = std::env::var("DBX_TEST_POSTGRES_GEOMETRY_URL").expect("DBX_TEST_POSTGRES_GEOMETRY_URL");
+    let pool = dbx_core::db::postgres::connect(&url, Duration::from_secs(5)).await.expect("connect");
+    let result = dbx_core::db::postgres::execute_query(
+        &pool,
+        "select id, geom, simple_geom from public.geo_test where id in (1, 7, 8) order by id",
+    )
+    .await
+    .expect("query geometry rows");
+
+    assert_eq!(result.columns, vec!["id", "geom", "simple_geom"]);
+    assert_eq!(result.rows.len(), 3);
+
+    assert_eq!(result.rows[0][0], serde_json::json!(1));
+    assert_eq!(result.rows[0][1], serde_json::json!("POINT(116.397 39.908)"));
+    assert_eq!(result.rows[0][2], serde_json::Value::Null);
+
+    assert_eq!(result.rows[1][0], serde_json::json!(7));
+    assert_eq!(result.rows[1][1], serde_json::Value::Null);
+    assert_eq!(result.rows[1][2], serde_json::Value::Null);
+
+    assert_eq!(result.rows[2][0], serde_json::json!(8));
+    assert_eq!(result.rows[2][1], serde_json::Value::Null);
+    assert_eq!(result.rows[2][2], serde_json::json!("POINT(120 30)"));
+}
diff --git a/crates/dbx-core/tests/live_postgres_query_result_export.rs b/crates/dbx-core/tests/live_postgres_query_result_export.rs
new file mode 100644
index 0000000..9e4af1c
--- /dev/null
+++ b/crates/dbx-core/tests/live_postgres_query_result_export.rs
@@ -0,0 +1,151 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::Duration;
+
+use dbx_core::connection::AppState;
+use dbx_core::db::postgres;
+use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
+use dbx_core::query_result_export::{export_query_result_core, ExportStatus, QueryResultExportRequest};
+use dbx_core::storage::Storage;
+
+fn live_postgres_config(
+    id: &str,
+    host: &str,
+    port: u16,
+    user: &str,
+    password: &str,
+    database: &str,
+) -> ConnectionConfig {
+    ConnectionConfig {
+        id: id.to_string(),
+        name: id.to_string(),
+        db_type: DatabaseType::Postgres,
+        driver_profile: None,
+        driver_label: None,
+        url_params: None,
+        agent_java_options: Vec::new(),
+        host: host.to_string(),
+        port,
+        username: user.to_string(),
+        password: password.to_string(),
+        database: Some(database.to_string()),
+        visible_databases: None,
+        visible_schemas: None,
+        attached_databases: Vec::new(),
+        color: None,
+        transport_layers: Vec::new(),
+        connect_timeout_secs: 10,
+        query_timeout_secs: 30,
+        idle_timeout_secs: 60,
+        keepalive_interval_secs: 0,
+        ssl: false,
+        ca_cert_path: String::new(),
+        client_cert_path: String::new(),
+        client_key_path: String::new(),
+        sysdba: false,
+        oracle_connection_type: None,
+        connection_string: None,
+        redis_connection_mode: None,
+        redis_sentinel_master: String::new(),
+        redis_sentinel_nodes: String::new(),
+        redis_sentinel_username: String::new(),
+        redis_sentinel_password: String::new(),
+        redis_sentinel_tls: false,
+        redis_cluster_nodes: String::new(),
+        redis_key_separator: dbx_core::models::connection::default_redis_key_separator(),
+        redis_scan_page_size: None,
+        etcd_endpoints: String::new(),
+        gbase_server: String::new(),
+        informix_server: String::new(),
+        external_config: None,
+        jdbc_driver_class: None,
+        jdbc_driver_paths: Vec::new(),
+        one_time: false,
+        read_only: false,
+        is_production: false,
+        production_databases: vec![],
+    }
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_POSTGRES_HOST/PORT/USER/PASSWORD/DATABASE pointing at a writable PostgreSQL database"]
+async fn live_postgres_query_result_export_uses_single_streamed_query() {
+    let host = std::env::var("DBX_LIVE_POSTGRES_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
+    let port = std::env::var("DBX_LIVE_POSTGRES_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(5432);
+    let user = std::env::var("DBX_LIVE_POSTGRES_USER").unwrap_or_else(|_| "postgres".to_string());
+    let password = std::env::var("DBX_LIVE_POSTGRES_PASSWORD").unwrap_or_default();
+    let database = std::env::var("DBX_LIVE_POSTGRES_DATABASE").unwrap_or_else(|_| "postgres".to_string());
+    let url = format!("postgresql://{user}:{password}@{host}:{port}/{database}");
+    let setup_pool = postgres::connect(&url, Duration::from_secs(10)).await.expect("connect PostgreSQL");
+
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let schema = format!("dbx_query_export_{}", &suffix[..8]);
+    let setup = vec![
+        format!("CREATE SCHEMA \"{schema}\""),
+        format!(
+            "CREATE OR REPLACE FUNCTION \"{schema}\".assert_no_limit_offset() RETURNS integer LANGUAGE plpgsql AS $$ \
+             DECLARE q text; \
+             BEGIN \
+               SELECT query INTO q FROM pg_stat_activity WHERE pid = pg_backend_pid(); \
+               IF q ~* '\\m(limit|offset)\\M' THEN \
+                 RAISE EXCEPTION 'query was paginated: %', q; \
+               END IF; \
+               RETURN 1; \
+             END; \
+             $$"
+        ),
+    ];
+    let cleanup = vec![format!("DROP SCHEMA IF EXISTS \"{schema}\" CASCADE")];
+    let _ = postgres::execute_batch(&setup_pool, &cleanup).await;
+    postgres::execute_batch(&setup_pool, &setup).await.expect("create live test schema");
+
+    let dir = std::env::temp_dir().join(format!("dbx-live-postgres-query-export-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = AppState::new(storage);
+    let connection_id = "live-postgres-query-export";
+    let config = live_postgres_config(connection_id, &host, port, &user, &password, &database);
+    state.configs.write().await.insert(config.id.clone(), config);
+
+    let file_path = dir.join("result.csv");
+    let sql =
+        format!("SELECT i, \"{schema}\".assert_no_limit_offset() AS marker FROM generate_series(1, 2050) AS s(i)");
+    let request = QueryResultExportRequest {
+        export_id: format!("live-postgres-query-export-{suffix}"),
+        connection_id: connection_id.to_string(),
+        database: database.clone(),
+        schema: Some(schema.clone()),
+        sql: sql.clone(),
+        query_base_sql: sql,
+        database_type: DatabaseType::Postgres,
+        use_agent_cursor: false,
+        file_path: file_path.to_string_lossy().to_string(),
+        format: "csv".to_string(),
+        page_size: 100,
+        row_limit: None,
+        total_rows: None,
+        timeout_secs: Some(30),
+        keyset_optimization_enabled: true,
+        client_session_id: None,
+        execution_id: Some(format!("live-postgres-query-export-{suffix}")),
+    };
+    let done_seen = AtomicBool::new(false);
+    let result = export_query_result_core(&state, &request, None, |progress| {
+        if matches!(progress.status, ExportStatus::Done) {
+            done_seen.store(true, Ordering::Relaxed);
+        }
+    })
+    .await;
+
+    let cleanup_result = postgres::execute_batch(&setup_pool, &cleanup).await;
+    let csv = std::fs::read_to_string(&file_path).unwrap_or_default();
+    let _ = std::fs::remove_dir_all(&dir);
+
+    result.expect("export query result");
+    cleanup_result.expect("cleanup live test schema");
+    assert!(done_seen.load(Ordering::Relaxed));
+    assert!(csv.starts_with('\u{feff}'));
+    assert!(csv.contains("\"i\",\"marker\""), "csv={csv:?}");
+    assert!(csv.contains("\"1\",\"1\""));
+    assert!(csv.contains("\"2050\",\"1\""));
+    assert_eq!(csv.lines().count(), 2051, "unexpected csv row count");
+}
diff --git a/crates/dbx-core/tests/live_postgres_transaction_recovery.rs b/crates/dbx-core/tests/live_postgres_transaction_recovery.rs
new file mode 100644
index 0000000..540f2c7
--- /dev/null
+++ b/crates/dbx-core/tests/live_postgres_transaction_recovery.rs
@@ -0,0 +1,58 @@
+use std::time::Duration;
+
+fn scalar_string(value: &serde_json::Value) -> &str {
+    value.as_str().expect("query result should be a string")
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_TEST_POSTGRES_URL pointing at a writable PostgreSQL database"]
+async fn live_postgres_schema_queries_can_recover_after_transaction_abort() {
+    let url = std::env::var("DBX_TEST_POSTGRES_URL").expect("DBX_TEST_POSTGRES_URL");
+    let pool = dbx_core::db::postgres::connect(&url, Duration::from_secs(5)).await.expect("connect");
+    let schema = format!("dbx_tx_recovery_{}", uuid::Uuid::new_v4().simple());
+
+    dbx_core::db::postgres::execute_batch(
+        &pool,
+        &[
+            format!("DROP SCHEMA IF EXISTS \"{schema}\" CASCADE"),
+            format!("CREATE SCHEMA \"{schema}\""),
+            format!("CREATE TABLE \"{schema}\".\"tx_probe\" (value integer NOT NULL)"),
+            format!("INSERT INTO \"{schema}\".\"tx_probe\" (value) VALUES (1)"),
+        ],
+    )
+    .await
+    .expect("prepare schema");
+
+    dbx_core::db::postgres::execute_query_with_schema(&pool, &schema, "BEGIN").await.expect("begin transaction");
+
+    let failed =
+        dbx_core::db::postgres::execute_query_with_schema(&pool, &schema, "UPDATE missing_tx_probe SET value = 2")
+            .await
+            .expect_err("invalid statement should fail");
+    assert!(failed.contains("missing_tx_probe"));
+
+    let aborted = dbx_core::db::postgres::execute_query_with_schema(&pool, &schema, "SELECT value FROM tx_probe")
+        .await
+        .expect_err("session should remain aborted before rollback");
+    assert!(aborted.contains("current transaction is aborted"));
+
+    dbx_core::db::postgres::execute_query_with_schema(&pool, &schema, "ROLLBACK")
+        .await
+        .expect("rollback should recover the session");
+
+    let recovered = dbx_core::db::postgres::execute_query_with_schema(
+        &pool,
+        &schema,
+        "SELECT current_schema(), value::text FROM tx_probe",
+    )
+    .await
+    .expect("query should succeed after rollback");
+
+    assert_eq!(recovered.rows.len(), 1);
+    assert_eq!(scalar_string(&recovered.rows[0][0]), schema);
+    assert_eq!(scalar_string(&recovered.rows[0][1]), "1");
+
+    dbx_core::db::postgres::execute_batch(&pool, &[format!("DROP SCHEMA IF EXISTS \"{schema}\" CASCADE")])
+        .await
+        .expect("cleanup schema");
+}
diff --git a/crates/dbx-core/tests/live_postgres_transfer.rs b/crates/dbx-core/tests/live_postgres_transfer.rs
new file mode 100644
index 0000000..0d182a4
--- /dev/null
+++ b/crates/dbx-core/tests/live_postgres_transfer.rs
@@ -0,0 +1,527 @@
+use dbx_core::connection::{AppState, PoolKind};
+use dbx_core::db::postgres;
+use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
+use dbx_core::storage::Storage;
+use dbx_core::transfer::{
+    get_db_type, transfer_postgres_schema_dependencies, transfer_postgres_schema_objects, transfer_table, TransferMode,
+    TransferOwnershipPolicy, TransferRequest, TransferTableNameCase,
+};
+use serde_json::json;
+
+fn postgres_test_config(id: &str, database: &str) -> ConnectionConfig {
+    ConnectionConfig {
+        id: id.to_string(),
+        name: id.to_string(),
+        db_type: DatabaseType::Postgres,
+        driver_profile: None,
+        driver_label: None,
+        url_params: None,
+        agent_java_options: Vec::new(),
+        host: "127.0.0.1".to_string(),
+        port: 5432,
+        username: "postgres".to_string(),
+        password: String::new(),
+        database: Some(database.to_string()),
+        visible_databases: None,
+        visible_schemas: None,
+        attached_databases: Vec::new(),
+        color: None,
+        transport_layers: Vec::new(),
+        connect_timeout_secs: 5,
+        query_timeout_secs: 30,
+        idle_timeout_secs: 60,
+        keepalive_interval_secs: 0,
+        ssl: false,
+        ca_cert_path: String::new(),
+        client_cert_path: String::new(),
+        client_key_path: String::new(),
+        sysdba: false,
+        oracle_connection_type: None,
+        connection_string: None,
+        redis_connection_mode: None,
+        redis_sentinel_master: String::new(),
+        redis_sentinel_nodes: String::new(),
+        redis_sentinel_username: String::new(),
+        redis_sentinel_password: String::new(),
+        redis_sentinel_tls: false,
+        redis_cluster_nodes: String::new(),
+        redis_key_separator: dbx_core::models::connection::default_redis_key_separator(),
+        redis_scan_page_size: None,
+        etcd_endpoints: String::new(),
+        gbase_server: String::new(),
+        informix_server: String::new(),
+        external_config: None,
+        jdbc_driver_class: None,
+        jdbc_driver_paths: Vec::new(),
+        one_time: false,
+        read_only: false,
+        is_production: false,
+        production_databases: vec![],
+    }
+}
+
+async fn query_scalar(pool: &deadpool_postgres::Pool, sql: &str) -> serde_json::Value {
+    postgres::execute_query(pool, sql).await.unwrap().rows[0][0].clone()
+}
+
+#[tokio::test]
+#[ignore = "requires source/target PostgreSQL URLs via DBX_LIVE_PG_TRANSFER_SOURCE_URL and DBX_LIVE_PG_TRANSFER_TARGET_URL"]
+async fn live_postgres_transfer_preserves_data_and_schema_objects() {
+    let source_url = std::env::var("DBX_LIVE_PG_TRANSFER_SOURCE_URL").expect("DBX_LIVE_PG_TRANSFER_SOURCE_URL");
+    let target_url = std::env::var("DBX_LIVE_PG_TRANSFER_TARGET_URL").unwrap_or_else(|_| source_url.clone());
+
+    let source_pool = postgres::connect(&source_url, std::time::Duration::from_secs(5)).await.unwrap();
+    let target_pool = postgres::connect(&target_url, std::time::Duration::from_secs(5)).await.unwrap();
+
+    let source_database = query_scalar(&source_pool, "SELECT current_database()").await.as_str().unwrap().to_string();
+    let target_database = query_scalar(&target_pool, "SELECT current_database()").await.as_str().unwrap().to_string();
+
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let source_schema = format!("dbx_src_{}", &suffix[..8]);
+    let target_schema = format!("dbx_dst_{}", &suffix[..8]);
+
+    let cleanup_sql = [
+        format!("DROP SCHEMA IF EXISTS \"{}\" CASCADE", source_schema),
+        format!("DROP SCHEMA IF EXISTS \"{}\" CASCADE", target_schema),
+    ];
+    let _ = postgres::execute_batch(&source_pool, &[cleanup_sql[0].clone()]).await;
+    let _ = postgres::execute_batch(&target_pool, &[cleanup_sql[1].clone()]).await;
+
+    let setup_sql = vec![
+        format!("CREATE SCHEMA \"{}\"", source_schema),
+        format!("CREATE TYPE \"{}\".\"user_status\" AS ENUM ('active', 'disabled')", source_schema),
+        format!(
+            "CREATE DOMAIN \"{}\".\"email_text\" AS text CHECK (position('@' in VALUE) > 1)",
+            source_schema
+        ),
+        format!(
+            "CREATE TABLE \"{}\".\"users\" (\
+                \"id\" integer GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,\
+                \"email\" \"{}\".\"email_text\" NOT NULL,\
+                \"status\" \"{}\".\"user_status\" NOT NULL DEFAULT 'active',\
+                \"created_at\" timestamptz NOT NULL DEFAULT now(),\
+                \"active\" boolean NOT NULL DEFAULT true,\
+                \"display_name\" text NOT NULL\
+            )",
+            source_schema, source_schema, source_schema
+        ),
+        format!(
+            "CREATE TABLE \"{}\".\"audit_logs\" (\
+                \"id\" integer GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,\
+                \"user_id\" integer NOT NULL REFERENCES \"{}\".\"users\"(\"id\"),\
+                \"action\" text NOT NULL,\
+                \"created_at\" timestamptz NOT NULL DEFAULT now()\
+            )",
+            source_schema, source_schema
+        ),
+        format!(
+            "CREATE TABLE \"{}\".\"files\" (\
+                \"id\" integer PRIMARY KEY,\
+                \"payload\" bytea NOT NULL,\
+                \"note\" text NOT NULL\
+            )",
+            source_schema
+        ),
+        format!(
+            "CREATE INDEX \"users_display_name_idx\" ON \"{}\".\"users\" USING btree (lower(display_name))",
+            source_schema
+        ),
+        format!(
+            "COMMENT ON COLUMN \"{}\".\"users\".\"display_name\" IS 'Display name used in transfer test'",
+            source_schema
+        ),
+        format!("COMMENT ON INDEX \"{}\".\"users_display_name_idx\" IS 'lookup index'", source_schema),
+        format!(
+            "CREATE OR REPLACE FUNCTION \"{}\".\"log_user_insert\"() RETURNS trigger LANGUAGE plpgsql AS $$ \
+             BEGIN \
+                 INSERT INTO \"{}\".\"audit_logs\" (\"user_id\", \"action\") VALUES (NEW.\"id\", 'insert'); \
+                 RETURN NEW; \
+             END; \
+             $$",
+            source_schema, source_schema
+        ),
+        format!(
+            "CREATE TRIGGER \"users_insert_audit\" AFTER INSERT ON \"{}\".\"users\" \
+             FOR EACH ROW EXECUTE FUNCTION \"{}\".\"log_user_insert\"()",
+            source_schema, source_schema
+        ),
+        format!(
+            "INSERT INTO \"{}\".\"users\" (\"email\", \"status\", \"active\", \"display_name\") VALUES \
+             ('alpha@example.com', 'active', true, 'Alpha'), \
+             ('beta@example.com', 'disabled', false, 'Beta')",
+            source_schema
+        ),
+        format!(
+            "INSERT INTO \"{}\".\"files\" (\"id\", \"payload\", \"note\") VALUES \
+             (1, decode('48656c6c6f', 'hex'), '0x48656c6c6f')",
+            source_schema
+        ),
+        format!(
+            "CREATE VIEW \"{}\".\"active_users\" AS \
+             SELECT \"id\", \"email\", \"display_name\" FROM \"{}\".\"users\" WHERE \"active\"",
+            source_schema, source_schema
+        ),
+        format!(
+            "CREATE MATERIALIZED VIEW \"{}\".\"user_stats\" AS \
+             SELECT \"status\", count(*)::bigint AS \"total\" FROM \"{}\".\"users\" GROUP BY \"status\"",
+            source_schema, source_schema
+        ),
+        format!("ALTER TABLE \"{}\".\"users\" ENABLE ROW LEVEL SECURITY", source_schema),
+        format!(
+            "CREATE POLICY \"users_public_read\" ON \"{}\".\"users\" AS PERMISSIVE FOR SELECT TO PUBLIC USING (\"active\")",
+            source_schema
+        ),
+        format!("GRANT USAGE ON SCHEMA \"{}\" TO PUBLIC", source_schema),
+        format!("GRANT SELECT ON TABLE \"{}\".\"users\" TO PUBLIC", source_schema),
+        format!("GRANT SELECT ON TABLE \"{}\".\"active_users\" TO PUBLIC", source_schema),
+        format!("GRANT EXECUTE ON FUNCTION \"{}\".\"log_user_insert\"() TO PUBLIC", source_schema),
+    ];
+    postgres::execute_batch(&source_pool, &setup_sql).await.unwrap();
+
+    let dir = std::env::temp_dir().join(format!("dbx-live-transfer-{}", uuid::Uuid::new_v4()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = AppState::new(storage);
+
+    let source_connection_id = "live-source";
+    let target_connection_id = "live-target";
+    let source_pool_key = format!("{source_connection_id}:{source_database}");
+    let target_pool_key = format!("{target_connection_id}:{target_database}");
+
+    state.connections.write().await.insert(source_pool_key.clone(), PoolKind::Postgres(source_pool.clone()));
+    state.connections.write().await.insert(target_pool_key.clone(), PoolKind::Postgres(target_pool.clone()));
+    state
+        .configs
+        .write()
+        .await
+        .insert(source_connection_id.to_string(), postgres_test_config(source_connection_id, &source_database));
+    state
+        .configs
+        .write()
+        .await
+        .insert(target_connection_id.to_string(), postgres_test_config(target_connection_id, &target_database));
+
+    let request = TransferRequest {
+        transfer_id: format!("live-transfer-{suffix}"),
+        source_connection_id: source_connection_id.to_string(),
+        source_database: source_database.clone(),
+        source_schema: source_schema.clone(),
+        target_connection_id: target_connection_id.to_string(),
+        target_database: target_database.clone(),
+        target_schema: target_schema.clone(),
+        tables: vec!["users".to_string(), "audit_logs".to_string(), "files".to_string()],
+        create_table: true,
+        mode: TransferMode::Append,
+        target_table_name_case: TransferTableNameCase::Preserve,
+        ownership_policy: TransferOwnershipPolicy::Preserve,
+        batch_size: 100,
+    };
+
+    transfer_postgres_schema_dependencies(&state, &request, &source_pool_key, &target_pool_key, |_| {}).await.unwrap();
+
+    let source_db_type = get_db_type(&state, source_connection_id).await.unwrap();
+    let target_db_type = get_db_type(&state, target_connection_id).await.unwrap();
+    for (index, table) in request.tables.iter().enumerate() {
+        transfer_table(
+            &state,
+            &request,
+            table,
+            index,
+            &source_db_type,
+            &target_db_type,
+            &source_pool_key,
+            &target_pool_key,
+            |_| {},
+        )
+        .await
+        .unwrap();
+    }
+
+    transfer_postgres_schema_objects(&state, &request, &source_pool_key, &target_pool_key, |_| {}).await.unwrap();
+
+    assert_eq!(
+        query_scalar(&target_pool, &format!("SELECT count(*) FROM \"{}\".\"users\"", target_schema)).await,
+        json!(2)
+    );
+    assert_eq!(
+        query_scalar(&target_pool, &format!("SELECT count(*) FROM \"{}\".\"audit_logs\"", target_schema)).await,
+        json!(2)
+    );
+    assert_eq!(
+        query_scalar(
+            &target_pool,
+            &format!("SELECT octet_length(\"payload\") FROM \"{}\".\"files\" WHERE \"id\" = 1", target_schema)
+        )
+        .await,
+        json!(5)
+    );
+    assert_eq!(
+        query_scalar(
+            &target_pool,
+            &format!("SELECT encode(\"payload\", 'hex') FROM \"{}\".\"files\" WHERE \"id\" = 1", target_schema)
+        )
+        .await,
+        json!("48656c6c6f")
+    );
+    assert_eq!(
+        query_scalar(&target_pool, &format!("SELECT \"note\" FROM \"{}\".\"files\" WHERE \"id\" = 1", target_schema))
+            .await,
+        json!("0x48656c6c6f")
+    );
+    assert_eq!(
+        query_scalar(
+            &target_pool,
+            &format!(
+                "SELECT column_default NOT LIKE '%{}%' AND column_default LIKE '%user_status%' \
+                 FROM information_schema.columns \
+                 WHERE table_schema = '{}' AND table_name = 'users' AND column_name = 'status'",
+                source_schema, target_schema
+            )
+        )
+        .await,
+        json!(true)
+    );
+    assert_eq!(
+        query_scalar(
+            &target_pool,
+            &format!(
+                "SELECT is_identity FROM information_schema.columns \
+                 WHERE table_schema = '{}' AND table_name = 'users' AND column_name = 'id'",
+                target_schema
+            )
+        )
+        .await,
+        json!("YES")
+    );
+    assert_eq!(
+        query_scalar(
+            &target_pool,
+            &format!(
+                "SELECT udt_name FROM information_schema.columns \
+                 WHERE table_schema = '{}' AND table_name = 'users' AND column_name = 'status'",
+                target_schema
+            )
+        )
+        .await,
+        json!("user_status")
+    );
+    assert_eq!(
+        query_scalar(
+            &target_pool,
+            &format!(
+                "SELECT domain_name FROM information_schema.columns \
+                 WHERE table_schema = '{}' AND table_name = 'users' AND column_name = 'email'",
+                target_schema
+            )
+        )
+        .await,
+        json!("email_text")
+    );
+    assert_eq!(
+        query_scalar(
+            &target_pool,
+            &format!(
+                "SELECT col_description(c.oid, a.attnum) \
+                 FROM pg_catalog.pg_class c \
+                 JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+                 JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid \
+                 WHERE n.nspname = '{}' AND c.relname = 'users' AND a.attname = 'display_name'",
+                target_schema
+            )
+        )
+        .await,
+        json!("Display name used in transfer test")
+    );
+    assert_eq!(
+        query_scalar(&target_pool, &format!("SELECT count(*) FROM \"{}\".\"active_users\"", target_schema)).await,
+        json!(1)
+    );
+    assert_eq!(
+        query_scalar(
+            &target_pool,
+            &format!("SELECT count(*) FROM \"{}\".\"user_stats\" WHERE \"status\" = 'active'", target_schema)
+        )
+        .await,
+        json!(1)
+    );
+    assert_eq!(
+        query_scalar(
+            &target_pool,
+            &format!(
+                "SELECT relrowsecurity FROM pg_catalog.pg_class c \
+                 JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+                 WHERE n.nspname = '{}' AND c.relname = 'users'",
+                target_schema
+            )
+        )
+        .await,
+        json!(true)
+    );
+    assert_eq!(
+        query_scalar(
+            &target_pool,
+            &format!(
+                "SELECT count(*) FROM pg_catalog.pg_policy p \
+                 JOIN pg_catalog.pg_class c ON c.oid = p.polrelid \
+                 JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+                 WHERE n.nspname = '{}' AND c.relname = 'users' AND p.polname = 'users_public_read'",
+                target_schema
+            )
+        )
+        .await,
+        json!(1)
+    );
+    assert_eq!(
+        query_scalar(
+            &target_pool,
+            &format!(
+                "SELECT count(*) \
+                 FROM pg_catalog.pg_namespace n \
+                 JOIN LATERAL aclexplode(n.nspacl) a ON true \
+                 WHERE n.nspname = '{}' AND a.grantee = 0 AND a.privilege_type = 'USAGE'",
+                target_schema
+            )
+        )
+        .await,
+        json!(1)
+    );
+
+    postgres::execute_query(
+        &target_pool,
+        &format!(
+            "INSERT INTO \"{}\".\"users\" (\"email\", \"status\", \"active\", \"display_name\") \
+             VALUES ('gamma@example.com', 'active', true, 'Gamma')",
+            target_schema
+        ),
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(
+        query_scalar(&target_pool, &format!("SELECT count(*) FROM \"{}\".\"audit_logs\"", target_schema)).await,
+        json!(3)
+    );
+
+    let _ = postgres::execute_batch(&source_pool, &[cleanup_sql[0].clone()]).await;
+    let _ = postgres::execute_batch(&target_pool, &[cleanup_sql[1].clone()]).await;
+    let _ = std::fs::remove_dir_all(dir);
+}
+
+#[tokio::test]
+#[ignore = "requires PostgreSQL URLs via DBX_LIVE_PG_TRANSFER_SOURCE_URL and DBX_LIVE_PG_TRANSFER_TARGET_URL"]
+async fn live_postgres_transfer_skips_create_ddl_for_existing_target_table() {
+    let source_url = std::env::var("DBX_LIVE_PG_TRANSFER_SOURCE_URL").expect("DBX_LIVE_PG_TRANSFER_SOURCE_URL");
+    let target_url = std::env::var("DBX_LIVE_PG_TRANSFER_TARGET_URL").unwrap_or_else(|_| source_url.clone());
+
+    let source_pool = postgres::connect(&source_url, std::time::Duration::from_secs(5)).await.unwrap();
+    let target_pool = postgres::connect(&target_url, std::time::Duration::from_secs(5)).await.unwrap();
+
+    let source_database = query_scalar(&source_pool, "SELECT current_database()").await.as_str().unwrap().to_string();
+    let target_database = query_scalar(&target_pool, "SELECT current_database()").await.as_str().unwrap().to_string();
+
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let source_schema = format!("dbx_src_existing_{}", &suffix[..8]);
+    let target_schema = format!("dbx_dst_existing_{}", &suffix[..8]);
+
+    let cleanup_sql = [
+        format!("DROP SCHEMA IF EXISTS \"{}\" CASCADE", source_schema),
+        format!("DROP SCHEMA IF EXISTS \"{}\" CASCADE", target_schema),
+    ];
+    let _ = postgres::execute_batch(&source_pool, &[cleanup_sql[0].clone()]).await;
+    let _ = postgres::execute_batch(&target_pool, &[cleanup_sql[1].clone()]).await;
+
+    postgres::execute_batch(
+        &source_pool,
+        &[
+            format!("CREATE SCHEMA \"{}\"", source_schema),
+            format!(
+                "CREATE TABLE \"{}\".\"items\" (\"id\" integer PRIMARY KEY, \"name\" text NOT NULL)",
+                source_schema
+            ),
+            format!(
+                "INSERT INTO \"{}\".\"items\" (\"id\", \"name\") VALUES (1, 'existing-target-transfer')",
+                source_schema
+            ),
+        ],
+    )
+    .await
+    .unwrap();
+    postgres::execute_batch(
+        &target_pool,
+        &[
+            format!("CREATE SCHEMA \"{}\"", target_schema),
+            format!(
+                "CREATE TABLE \"{}\".\"items\" (\"id\" integer PRIMARY KEY, \"name\" text NOT NULL)",
+                target_schema
+            ),
+        ],
+    )
+    .await
+    .unwrap();
+
+    let dir = std::env::temp_dir().join(format!("dbx-live-existing-transfer-{}", uuid::Uuid::new_v4()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = AppState::new(storage);
+
+    let source_connection_id = "live-existing-source";
+    let target_connection_id = "live-existing-target";
+    let source_pool_key = format!("{source_connection_id}:{source_database}");
+    let target_pool_key = format!("{target_connection_id}:{target_database}");
+
+    state.connections.write().await.insert(source_pool_key.clone(), PoolKind::Postgres(source_pool.clone()));
+    state.connections.write().await.insert(target_pool_key.clone(), PoolKind::Postgres(target_pool.clone()));
+    state
+        .configs
+        .write()
+        .await
+        .insert(source_connection_id.to_string(), postgres_test_config(source_connection_id, &source_database));
+    state
+        .configs
+        .write()
+        .await
+        .insert(target_connection_id.to_string(), postgres_test_config(target_connection_id, &target_database));
+
+    let request = TransferRequest {
+        transfer_id: format!("live-existing-transfer-{suffix}"),
+        source_connection_id: source_connection_id.to_string(),
+        source_database: source_database.clone(),
+        source_schema: source_schema.clone(),
+        target_connection_id: target_connection_id.to_string(),
+        target_database: target_database.clone(),
+        target_schema: target_schema.clone(),
+        tables: vec!["items".to_string()],
+        create_table: true,
+        mode: TransferMode::Append,
+        target_table_name_case: TransferTableNameCase::Preserve,
+        ownership_policy: TransferOwnershipPolicy::Preserve,
+        batch_size: 100,
+    };
+
+    let source_db_type = get_db_type(&state, source_connection_id).await.unwrap();
+    let target_db_type = get_db_type(&state, target_connection_id).await.unwrap();
+    let transferred = transfer_table(
+        &state,
+        &request,
+        "items",
+        0,
+        &source_db_type,
+        &target_db_type,
+        &source_pool_key,
+        &target_pool_key,
+        |_| {},
+    )
+    .await
+    .unwrap();
+
+    assert_eq!(transferred, 1);
+    assert_eq!(
+        query_scalar(&target_pool, &format!("SELECT \"name\" FROM \"{}\".\"items\" WHERE \"id\" = 1", target_schema))
+            .await,
+        json!("existing-target-transfer")
+    );
+
+    let _ = postgres::execute_batch(&source_pool, &[cleanup_sql[0].clone()]).await;
+    let _ = postgres::execute_batch(&target_pool, &[cleanup_sql[1].clone()]).await;
+    let _ = std::fs::remove_dir_all(dir);
+}
diff --git a/crates/dbx-core/tests/live_postgres_tsvector.rs b/crates/dbx-core/tests/live_postgres_tsvector.rs
new file mode 100644
index 0000000..d85994e
--- /dev/null
+++ b/crates/dbx-core/tests/live_postgres_tsvector.rs
@@ -0,0 +1,103 @@
+use std::time::Duration;
+
+use dbx_core::data_grid_sql::{
+    build_data_grid_copy_insert_statement, DataGridColumnInfo, DataGridCopyInsertMode,
+    DataGridCopyInsertStatementOptions, DataGridTableMeta,
+};
+use dbx_core::database_export::{build_export_insert_statements, BuildExportInsertStatementsOptions};
+use dbx_core::db::postgres;
+use dbx_core::models::connection::DatabaseType;
+
+fn grid_column(column: &dbx_core::types::ColumnInfo) -> DataGridColumnInfo {
+    DataGridColumnInfo {
+        name: column.name.clone(),
+        data_type: column.data_type.clone(),
+        is_nullable: column.is_nullable,
+        is_primary_key: column.is_primary_key,
+        column_default: column.column_default.clone(),
+        extra: column.extra.clone(),
+    }
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_TEST_POSTGRES_URL pointing at a writable PostgreSQL database"]
+async fn postgres_tsvector_generated_columns_are_readable_and_omitted_from_inserts() {
+    let url = std::env::var("DBX_TEST_POSTGRES_URL").expect("DBX_TEST_POSTGRES_URL");
+    let pool = postgres::connect(&url, Duration::from_secs(5)).await.expect("connect postgres");
+    let schema = format!("dbx_tsvector_{}", std::process::id());
+    let schema_ident = format!("\"{}\"", schema.replace('"', "\"\""));
+    let table = format!("{schema_ident}.articles");
+
+    let _ = postgres::execute_query(&pool, &format!("DROP SCHEMA IF EXISTS {schema_ident} CASCADE")).await;
+    postgres::execute_query(&pool, &format!("CREATE SCHEMA {schema_ident}")).await.expect("create schema");
+    postgres::execute_query(
+        &pool,
+        &format!(
+            "CREATE TABLE {table} (\
+             id integer PRIMARY KEY,\
+             title text NOT NULL,\
+             body text NOT NULL,\
+             search_vector tsvector GENERATED ALWAYS AS \
+             (to_tsvector('simple', coalesce(title, '') || ' ' || coalesce(body, ''))) STORED\
+             )"
+        ),
+    )
+    .await
+    .expect("create table");
+    postgres::execute_query(&pool, &format!("INSERT INTO {table} (id, title, body) VALUES (1, 'Hello', 'World')"))
+        .await
+        .expect("insert row");
+
+    let result =
+        postgres::execute_query(&pool, &format!("SELECT id, title, body, search_vector FROM {table} ORDER BY id"))
+            .await
+            .expect("select row");
+    assert_eq!(result.column_types, vec!["int4", "text", "text", "tsvector"]);
+    assert_eq!(result.rows[0][3].as_str(), Some("'hello':1 'world':2"));
+
+    let columns = postgres::get_columns(&pool, &schema, "articles").await.expect("get columns");
+    let search_vector = columns.iter().find(|column| column.name == "search_vector").expect("search_vector column");
+    assert_eq!(search_vector.column_default, None);
+    assert!(search_vector.extra.as_deref().unwrap_or_default().contains("generated always as"));
+
+    let table_meta = DataGridTableMeta {
+        catalog: None,
+        schema: Some(schema.clone()),
+        table_name: "articles".to_string(),
+        primary_keys: vec!["id".to_string()],
+        columns: Some(columns.iter().map(grid_column).collect()),
+    };
+    let copy_insert = build_data_grid_copy_insert_statement(DataGridCopyInsertStatementOptions {
+        database_type: Some(DatabaseType::Postgres),
+        table_meta: Some(table_meta),
+        columns: result.columns.clone(),
+        column_types: None,
+        source_columns: None,
+        rows: result.rows.clone(),
+        exclude_primary_keys: false,
+        insert_mode: DataGridCopyInsertMode::Merged,
+    })
+    .expect("copy insert");
+    assert!(copy_insert.contains("\"id\", \"title\", \"body\""));
+    assert!(!copy_insert.contains("search_vector"));
+
+    let export_insert = build_export_insert_statements(BuildExportInsertStatementsOptions {
+        database_type: Some(DatabaseType::Postgres),
+        schema: Some(schema.clone()),
+        table_name: Some("articles".to_string()),
+        qualified_table_name: None,
+        columns: result.columns.clone(),
+        column_types: result.column_types.iter().map(|value| Some(value.clone())).collect(),
+        column_extras: Vec::new(),
+        rows: result.rows.clone(),
+        batch_size: Some(10),
+    })
+    .expect("export insert")
+    .join("\n");
+    assert!(export_insert.contains("\"id\", \"title\", \"body\""));
+    assert!(!export_insert.contains("search_vector"));
+
+    postgres::execute_query(&pool, &format!("DROP SCHEMA IF EXISTS {schema_ident} CASCADE"))
+        .await
+        .expect("drop schema");
+}
diff --git a/crates/dbx-core/tests/live_sqlserver_completion.rs b/crates/dbx-core/tests/live_sqlserver_completion.rs
new file mode 100644
index 0000000..884c64c
--- /dev/null
+++ b/crates/dbx-core/tests/live_sqlserver_completion.rs
@@ -0,0 +1,581 @@
+use dbx_core::connection::{AppState, PoolKind};
+use dbx_core::models::connection::DatabaseType;
+use dbx_core::query_result_export::{export_query_result_core, ExportStatus, QueryResultExportRequest};
+use dbx_core::sql::{SqlFileRequest, SqlFileStatus};
+use dbx_core::sql_file_import::execute_sql_file_content;
+use dbx_core::storage::Storage;
+use dbx_core::table_structure_sql::{
+    build_table_structure_change_sql, ColumnInfo, EditableStructureColumn, TableStructureSqlOptions,
+};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::{Duration, Instant};
+use tokio_util::sync::CancellationToken;
+
+fn live_sqlserver_config(id: &str, database: &str) -> dbx_core::models::connection::ConnectionConfig {
+    dbx_core::models::connection::ConnectionConfig {
+        id: id.to_string(),
+        name: id.to_string(),
+        db_type: DatabaseType::SqlServer,
+        driver_profile: None,
+        driver_label: None,
+        url_params: None,
+        agent_java_options: Vec::new(),
+        host: std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string()),
+        port: std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433),
+        username: std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string()),
+        password: std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD"),
+        database: Some(database.to_string()),
+        visible_databases: None,
+        visible_schemas: None,
+        attached_databases: Vec::new(),
+        color: None,
+        transport_layers: Vec::new(),
+        connect_timeout_secs: 10,
+        query_timeout_secs: 30,
+        idle_timeout_secs: 60,
+        keepalive_interval_secs: 0,
+        ssl: false,
+        ca_cert_path: String::new(),
+        client_cert_path: String::new(),
+        client_key_path: String::new(),
+        sysdba: false,
+        oracle_connection_type: None,
+        connection_string: None,
+        redis_connection_mode: None,
+        redis_sentinel_master: String::new(),
+        redis_sentinel_nodes: String::new(),
+        redis_sentinel_username: String::new(),
+        redis_sentinel_password: String::new(),
+        redis_sentinel_tls: false,
+        redis_cluster_nodes: String::new(),
+        redis_key_separator: dbx_core::models::connection::default_redis_key_separator(),
+        redis_scan_page_size: None,
+        etcd_endpoints: String::new(),
+        gbase_server: String::new(),
+        informix_server: String::new(),
+        external_config: None,
+        jdbc_driver_class: None,
+        jdbc_driver_paths: Vec::new(),
+        one_time: false,
+        read_only: false,
+        is_production: false,
+        production_databases: vec![],
+    }
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at a writable SQL Server database"]
+async fn live_sqlserver_execute_query_creates_schema() {
+    let database = std::env::var("DBX_LIVE_SQLSERVER_DATABASE").unwrap_or_else(|_| "tempdb".to_string());
+    let host = std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
+    let port = std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433);
+    let user = std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string());
+    let password = std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD");
+    let mut client =
+        dbx_core::db::sqlserver::connect(&host, port, &user, &password, Some(&database), None, Duration::from_secs(10))
+            .await
+            .expect("connect SQL Server");
+
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let schema = format!("dbx_schema_{suffix}");
+    let create = format!("CREATE SCHEMA [{schema}];");
+    let verify = format!("SELECT SCHEMA_ID(N'{schema}') AS schema_id;");
+    let cleanup = format!("DROP SCHEMA [{schema}];");
+
+    let result = dbx_core::db::sqlserver::execute_query(&mut client, &create).await;
+    let verify_result = dbx_core::db::sqlserver::execute_query(&mut client, &verify).await;
+    let schemas = dbx_core::db::sqlserver::list_schemas(&mut client).await;
+    let _ = dbx_core::db::sqlserver::execute_query(&mut client, &cleanup).await;
+
+    result.expect("create schema through execute_query");
+    let verify_result = verify_result.expect("verify created schema");
+    assert_eq!(verify_result.rows.len(), 1);
+    assert!(verify_result.rows[0][0].as_i64().is_some(), "schema_id row={:?}", verify_result.rows[0]);
+    assert!(schemas.expect("list schemas").contains(&schema));
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at a writable SQL Server database"]
+async fn live_sqlserver_table_structure_default_changes_drop_existing_constraints() {
+    let database = std::env::var("DBX_LIVE_SQLSERVER_DATABASE").unwrap_or_else(|_| "tempdb".to_string());
+    let host = std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
+    let port = std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433);
+    let user = std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string());
+    let password = std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD");
+    let mut client =
+        dbx_core::db::sqlserver::connect(&host, port, &user, &password, Some(&database), None, Duration::from_secs(10))
+            .await
+            .expect("connect SQL Server");
+
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let schema = format!("dbx_default_{suffix}");
+    let table = "products";
+    let create_schema = format!("CREATE SCHEMA [{schema}];");
+    let create_table = format!(
+        "\
+        CREATE TABLE [{schema}].[{table}] (\
+            [sku] NVARCHAR(64) NULL CONSTRAINT [DF_{schema}_{table}_sku_old] DEFAULT N'old sku',\
+            [active] BIT NOT NULL CONSTRAINT [DF_{schema}_{table}_active_old] DEFAULT 0\
+        );"
+    );
+    dbx_core::db::sqlserver::execute_query(&mut client, &create_schema).await.expect("create live test schema");
+    dbx_core::db::sqlserver::execute_query(&mut client, &create_table).await.expect("create table with defaults");
+
+    let mut sku = structure_column("sku", "nvarchar(64)", true, "new sku", Some("'old sku'"));
+    let mut active = structure_column("active", "bit", false, "1", Some("0"));
+    sku.original_position = Some(0);
+    active.original_position = Some(1);
+    let result = build_table_structure_change_sql(TableStructureSqlOptions {
+        database_type: Some(DatabaseType::SqlServer),
+        schema: Some(schema.clone()),
+        table_name: table.to_string(),
+        columns: vec![sku, active],
+        indexes: Vec::new(),
+        foreign_keys: Vec::new(),
+        triggers: Vec::new(),
+        table_comment: None,
+        original_table_comment: None,
+    });
+    assert_eq!(result.warnings, Vec::<String>::new());
+    assert_eq!(result.statements.len(), 4);
+
+    let execution_result = async {
+        for statement in &result.statements {
+            dbx_core::db::sqlserver::execute_query(&mut client, statement).await?;
+        }
+        Ok::<(), String>(())
+    }
+    .await;
+
+    let verify_sql = format!(
+        "\
+        SELECT c.name, dc.definition \
+        FROM sys.default_constraints AS dc \
+        JOIN sys.columns AS c ON c.object_id = dc.parent_object_id AND c.column_id = dc.parent_column_id \
+        WHERE dc.parent_object_id = OBJECT_ID(N'[{schema}].[{table}]') \
+        ORDER BY c.name;"
+    );
+    let verify_result = dbx_core::db::sqlserver::execute_query(&mut client, &verify_sql).await;
+    let cleanup = format!("DROP TABLE IF EXISTS [{schema}].[{table}]; DROP SCHEMA IF EXISTS [{schema}];");
+    let _ = dbx_core::db::sqlserver::execute_batch(&mut client, &cleanup).await;
+
+    execution_result.expect("execute generated default constraint SQL");
+    let verify_result = verify_result.expect("verify changed defaults");
+    assert_eq!(verify_result.rows.len(), 2, "rows={:?}", verify_result.rows);
+    assert_eq!(verify_result.rows[0][0], serde_json::json!("active"));
+    assert_eq!(verify_result.rows[0][1], serde_json::json!("((1))"));
+    assert_eq!(verify_result.rows[1][0], serde_json::json!("sku"));
+    assert_eq!(verify_result.rows[1][1], serde_json::json!("('new sku')"));
+}
+
+fn structure_column(
+    name: &str,
+    data_type: &str,
+    is_nullable: bool,
+    default_value: &str,
+    original_default: Option<&str>,
+) -> EditableStructureColumn {
+    EditableStructureColumn {
+        id: name.to_string(),
+        name: name.to_string(),
+        data_type: data_type.to_string(),
+        is_nullable,
+        default_value: default_value.to_string(),
+        comment: String::new(),
+        is_primary_key: false,
+        extra: None,
+        original: Some(ColumnInfo {
+            name: name.to_string(),
+            data_type: data_type.to_string(),
+            is_nullable,
+            column_default: original_default.map(str::to_string),
+            is_primary_key: false,
+            extra: None,
+            comment: None,
+            ..Default::default()
+        }),
+        original_position: None,
+        marked_for_drop: false,
+        character_set: String::new(),
+        collation: String::new(),
+    }
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at a writable SQL Server database"]
+async fn live_sqlserver_stream_first_result_set_exports_cte_query_rows() {
+    let database = std::env::var("DBX_LIVE_SQLSERVER_DATABASE").unwrap_or_else(|_| "tempdb".to_string());
+    let host = std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
+    let port = std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433);
+    let user = std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string());
+    let password = std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD");
+    let mut client =
+        dbx_core::db::sqlserver::connect(&host, port, &user, &password, Some(&database), None, Duration::from_secs(10))
+            .await
+            .expect("connect SQL Server");
+
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let table = format!("dbx_stream_export_{suffix}");
+    let setup = format!(
+        "\
+        CREATE TABLE [dbo].[{table}] (id INT NOT NULL, name NVARCHAR(64) NULL);\
+        INSERT INTO [dbo].[{table}] (id, name) VALUES (2, N'beta'), (1, N'alpha');"
+    );
+    dbx_core::db::sqlserver::execute_batch(&mut client, &setup).await.expect("create live test rows");
+
+    let sql = format!(
+        "\
+        WITH ranked AS (\
+            SELECT id, name, ROW_NUMBER() OVER (ORDER BY id) AS rn FROM [dbo].[{table}]\
+        )\
+        SELECT id, name FROM ranked WHERE rn <= 2 ORDER BY id"
+    );
+    let mut columns = Vec::new();
+    let mut rows = Vec::new();
+    let result = dbx_core::db::sqlserver::stream_first_result_set(&mut client, &sql, None, None, |item| {
+        match item {
+            dbx_core::db::sqlserver::SqlServerStreamItem::Columns(stream_columns) => {
+                columns = stream_columns.to_vec();
+            }
+            dbx_core::db::sqlserver::SqlServerStreamItem::Row(row) => {
+                rows.push(row.to_vec());
+            }
+        }
+        Ok(())
+    })
+    .await;
+
+    let cleanup = format!("DROP TABLE [dbo].[{table}];");
+    let _ = dbx_core::db::sqlserver::execute_batch(&mut client, &cleanup).await;
+
+    let summary = result.expect("stream first result set");
+    assert_eq!(summary.columns, vec!["id".to_string(), "name".to_string()]);
+    assert_eq!(summary.rows_exported, 2);
+    assert_eq!(columns, summary.columns);
+    assert_eq!(rows.len(), 2);
+    assert_eq!(rows[0][0], serde_json::json!(1));
+    assert_eq!(rows[0][1], serde_json::json!("alpha"));
+    assert_eq!(rows[1][0], serde_json::json!(2));
+    assert_eq!(rows[1][1], serde_json::json!("beta"));
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at a writable SQL Server database"]
+async fn live_sqlserver_query_result_export_streams_cte_query_to_csv() {
+    let database = std::env::var("DBX_LIVE_SQLSERVER_DATABASE").unwrap_or_else(|_| "tempdb".to_string());
+    let host = std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
+    let port = std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433);
+    let user = std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string());
+    let password = std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD");
+    let mut setup_client =
+        dbx_core::db::sqlserver::connect(&host, port, &user, &password, Some(&database), None, Duration::from_secs(10))
+            .await
+            .expect("connect SQL Server");
+    let export_client =
+        dbx_core::db::sqlserver::connect(&host, port, &user, &password, Some(&database), None, Duration::from_secs(10))
+            .await
+            .expect("connect export SQL Server");
+
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let table = format!("dbx_query_export_{suffix}");
+    let setup = format!(
+        "\
+        CREATE TABLE [dbo].[{table}] (id INT NOT NULL, name NVARCHAR(64) NULL);\
+        INSERT INTO [dbo].[{table}] (id, name) VALUES (2, N'beta'), (1, N'alpha');"
+    );
+    dbx_core::db::sqlserver::execute_batch(&mut setup_client, &setup).await.expect("create live test rows");
+
+    let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-export-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = AppState::new(storage);
+    let connection_id = "live-sqlserver-export";
+    let pool_key = format!("{connection_id}:{database}");
+    state
+        .connections
+        .write()
+        .await
+        .insert(pool_key, PoolKind::SqlServer(std::sync::Arc::new(tokio::sync::Mutex::new(export_client))));
+
+    let file_path = dir.join("result.csv");
+    let sql = format!(
+        "\
+        WITH ranked AS (\
+            SELECT id, name, ROW_NUMBER() OVER (ORDER BY id) AS rn FROM [dbo].[{table}]\
+        )\
+        SELECT id, name FROM ranked WHERE rn <= 2 ORDER BY id"
+    );
+    let request = QueryResultExportRequest {
+        export_id: format!("live-sqlserver-export-{suffix}"),
+        connection_id: connection_id.to_string(),
+        database: database.clone(),
+        schema: Some("dbo".to_string()),
+        sql: sql.clone(),
+        query_base_sql: sql,
+        database_type: DatabaseType::SqlServer,
+        use_agent_cursor: false,
+        file_path: file_path.to_string_lossy().to_string(),
+        format: "csv".to_string(),
+        page_size: 1,
+        row_limit: None,
+        total_rows: None,
+        timeout_secs: Some(10),
+        keyset_optimization_enabled: true,
+        client_session_id: None,
+        execution_id: Some(format!("live-sqlserver-export-{suffix}")),
+    };
+    let done_seen = AtomicBool::new(false);
+    let result = export_query_result_core(&state, &request, None, |progress| {
+        if matches!(progress.status, ExportStatus::Done) {
+            done_seen.store(true, Ordering::Relaxed);
+        }
+    })
+    .await;
+
+    let cleanup = format!("DROP TABLE [dbo].[{table}];");
+    let _ = dbx_core::db::sqlserver::execute_batch(&mut setup_client, &cleanup).await;
+    let csv = std::fs::read_to_string(&file_path).unwrap_or_default();
+    let _ = std::fs::remove_dir_all(&dir);
+
+    result.expect("export query result");
+    assert!(done_seen.load(Ordering::Relaxed));
+    assert!(csv.starts_with('\u{feff}'));
+    assert!(csv.contains("\"id\",\"name\""), "csv={csv:?}");
+    assert!(csv.contains("\"1\",\"alpha\""));
+    assert!(csv.contains("\"2\",\"beta\""));
+    assert!(!csv.contains("\n\n"));
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at a writable SQL Server database"]
+async fn live_sqlserver_sql_file_import_executes_go_batches() {
+    let database = std::env::var("DBX_LIVE_SQLSERVER_DATABASE").unwrap_or_else(|_| "tempdb".to_string());
+    let host = std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
+    let port = std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433);
+    let user = std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string());
+    let password = std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD");
+    let client =
+        dbx_core::db::sqlserver::connect(&host, port, &user, &password, Some(&database), None, Duration::from_secs(10))
+            .await
+            .expect("connect SQL Server");
+
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let table = format!("dbx_sql_file_{suffix}");
+    let procedure = format!("dbx_sql_file_proc_{suffix}");
+    let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-file-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = AppState::new(storage);
+    let connection_id = "live-sqlserver-file";
+    let mut config = live_sqlserver_config(connection_id, &database);
+    config.host = host;
+    config.port = port;
+    config.username = user;
+    config.password = password;
+    state.configs.write().await.insert(connection_id.to_string(), config);
+    state.connections.write().await.insert(
+        format!("{connection_id}:{database}"),
+        PoolKind::SqlServer(std::sync::Arc::new(tokio::sync::Mutex::new(client))),
+    );
+
+    let script = format!(
+        "CREATE TABLE [dbo].[{table}] (id INT NOT NULL);\n\
+         GO\n\
+         INSERT INTO [dbo].[{table}] (id) VALUES (1);\n\
+         GO\n\
+         CREATE PROCEDURE [dbo].[{procedure}] AS\n\
+         BEGIN\n\
+             SELECT COUNT(*) AS item_count FROM [dbo].[{table}];\n\
+         END\n\
+         GO"
+    );
+    let request = SqlFileRequest {
+        execution_id: format!("live-sqlserver-file-{suffix}"),
+        connection_id: connection_id.to_string(),
+        database: database.clone(),
+        file_path: "fixture.sql".to_string(),
+        continue_on_error: false,
+    };
+    let done_seen = AtomicBool::new(false);
+
+    execute_sql_file_content(&state, &request, &script, CancellationToken::new(), Instant::now(), |progress| {
+        if progress.status == SqlFileStatus::Done {
+            done_seen.store(true, Ordering::Relaxed);
+        }
+    })
+    .await
+    .expect("execute SQL Server file with GO batches");
+
+    let pool_key = format!("{connection_id}:{database}");
+    let connections = state.connections.read().await;
+    let PoolKind::SqlServer(client) = connections.get(&pool_key).expect("SQL Server pool") else {
+        panic!("expected SQL Server pool");
+    };
+    let mut client = client.lock().await;
+    let rows = dbx_core::db::sqlserver::execute_query(&mut client, &format!("EXEC [dbo].[{procedure}]")).await;
+    let cleanup = format!("DROP PROCEDURE [dbo].[{procedure}]; DROP TABLE [dbo].[{table}];");
+    let _ = dbx_core::db::sqlserver::execute_batch(&mut client, &cleanup).await;
+    drop(client);
+    drop(connections);
+    let _ = std::fs::remove_dir_all(&dir);
+
+    assert!(done_seen.load(Ordering::Relaxed));
+    let rows = rows.expect("execute imported procedure");
+    assert_eq!(rows.rows.first().and_then(|row| row.first()), Some(&serde_json::json!(1)));
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at a writable SQL Server database"]
+async fn live_sqlserver_transfer_table_skips_rowversion_insert_column() {
+    let database = std::env::var("DBX_LIVE_SQLSERVER_DATABASE").unwrap_or_else(|_| "tempdb".to_string());
+    let target_database = std::env::var("DBX_LIVE_SQLSERVER_TARGET_DATABASE").unwrap_or_else(|_| "tempdb".to_string());
+    let host = std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
+    let port = std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433);
+    let user = std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string());
+    let password = std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD");
+    let mut setup_client =
+        dbx_core::db::sqlserver::connect(&host, port, &user, &password, Some(&database), None, Duration::from_secs(10))
+            .await
+            .expect("connect SQL Server");
+    let mut target_client = dbx_core::db::sqlserver::connect(
+        &host,
+        port,
+        &user,
+        &password,
+        Some(&target_database),
+        None,
+        Duration::from_secs(10),
+    )
+    .await
+    .expect("connect target SQL Server database");
+
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let source_table = format!("dbx_rowversion_src_{suffix}");
+    let target_table = source_table.to_uppercase();
+    let cleanup_source = format!("DROP TABLE IF EXISTS [dbo].[{source_table}];");
+    let cleanup_target = format!("DROP TABLE IF EXISTS [dbo].[{target_table}];");
+    let _ = dbx_core::db::sqlserver::execute_batch(&mut setup_client, &cleanup_source).await;
+    let _ = dbx_core::db::sqlserver::execute_batch(&mut target_client, &cleanup_target).await;
+
+    let setup = format!(
+        "CREATE TABLE [dbo].[{source_table}] (id INT NOT NULL PRIMARY KEY, name NVARCHAR(64) NULL, TimeSpan timestamp NOT NULL);\
+         INSERT INTO [dbo].[{source_table}] (id, name) VALUES (1, N'alpha'), (2, N'beta');"
+    );
+    dbx_core::db::sqlserver::execute_batch(&mut setup_client, &setup).await.expect("create rowversion source table");
+
+    let dir = std::env::temp_dir().join(format!("dbx-live-sqlserver-rowversion-{suffix}"));
+    std::fs::create_dir_all(&dir).unwrap();
+    let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+    let state = AppState::new(storage);
+    let config = live_sqlserver_config("live-sqlserver-rowversion", &database);
+    state.configs.write().await.insert(config.id.clone(), config);
+    let source_pool_key =
+        state.get_or_create_pool("live-sqlserver-rowversion", Some(&database)).await.expect("connect transfer pool");
+    let target_pool_key = state
+        .get_or_create_pool("live-sqlserver-rowversion", Some(&target_database))
+        .await
+        .expect("connect target transfer pool");
+    let request = dbx_core::transfer::TransferRequest {
+        transfer_id: format!("live-sqlserver-rowversion-{suffix}"),
+        source_connection_id: "live-sqlserver-rowversion".to_string(),
+        source_database: database.clone(),
+        source_schema: "dbo".to_string(),
+        target_connection_id: "live-sqlserver-rowversion".to_string(),
+        target_database: target_database.clone(),
+        target_schema: "dbo".to_string(),
+        tables: vec![source_table.clone()],
+        create_table: true,
+        mode: dbx_core::transfer::TransferMode::Append,
+        target_table_name_case: dbx_core::transfer::TransferTableNameCase::Upper,
+        ownership_policy: dbx_core::transfer::TransferOwnershipPolicy::Preserve,
+        batch_size: 100,
+    };
+    let result = dbx_core::transfer::transfer_table(
+        &state,
+        &request,
+        &source_table,
+        0,
+        &DatabaseType::SqlServer,
+        &DatabaseType::SqlServer,
+        &source_pool_key,
+        &target_pool_key,
+        |_| {},
+    )
+    .await;
+    let verify_sql =
+        format!("SELECT COUNT(*) AS row_count, COUNT([TimeSpan]) AS rowversion_count FROM [dbo].[{target_table}];");
+    let verify_result = dbx_core::db::sqlserver::execute_query(&mut target_client, &verify_sql).await;
+
+    let _ = dbx_core::db::sqlserver::execute_batch(&mut target_client, &cleanup_target).await;
+    let _ = dbx_core::db::sqlserver::execute_batch(&mut setup_client, &cleanup_source).await;
+    let _ = std::fs::remove_dir_all(&dir);
+
+    assert_eq!(result.expect("transfer rowversion table"), 2);
+    let verify_result = verify_result.expect("verify target rowversion rows");
+    assert_eq!(verify_result.rows[0][0], serde_json::json!(2));
+    assert_eq!(verify_result.rows[0][1], serde_json::json!(2));
+}
+
+#[tokio::test]
+#[ignore = "requires DBX_LIVE_SQLSERVER_URL or DBX_LIVE_SQLSERVER_HOST/PORT/USER/PASSWORD pointing at a writable SQL Server database"]
+async fn live_sqlserver_completion_assistant_searches_metadata_before_limiting() {
+    let database = std::env::var("DBX_LIVE_SQLSERVER_DATABASE").unwrap_or_else(|_| "tempdb".to_string());
+    let host = std::env::var("DBX_LIVE_SQLSERVER_HOST").unwrap_or_else(|_| "127.0.0.1".to_string());
+    let port = std::env::var("DBX_LIVE_SQLSERVER_PORT").ok().and_then(|value| value.parse().ok()).unwrap_or(1433);
+    let user = std::env::var("DBX_LIVE_SQLSERVER_USER").unwrap_or_else(|_| "sa".to_string());
+    let password = std::env::var("DBX_LIVE_SQLSERVER_PASSWORD").expect("DBX_LIVE_SQLSERVER_PASSWORD");
+    let mut client =
+        dbx_core::db::sqlserver::connect(&host, port, &user, &password, Some(&database), None, Duration::from_secs(10))
+            .await
+            .expect("connect SQL Server");
+
+    let suffix = uuid::Uuid::new_v4().simple().to_string();
+    let schema = "dbo".to_string();
+    let prefix = format!("needle_{suffix}");
+    let table = format!("{prefix}_table");
+    let setup = format!("CREATE TABLE [{schema}].[{table}] (id INT NOT NULL, display_name NVARCHAR(64) NULL);");
+    dbx_core::db::sqlserver::execute_batch(&mut client, &setup).await.expect("create live test objects");
+
+    let request = dbx_core::types::CompletionAssistantRequest {
+        connection_id: "live-sqlserver".to_string(),
+        database: database.clone(),
+        schema: Some(schema.clone()),
+        object_kinds: vec![dbx_core::types::CompletionAssistantObjectKind::Table],
+        mask: prefix.clone(),
+        case_sensitive: false,
+        global_search: false,
+        max_results: Some(5),
+        search_in_comments: false,
+        search_in_definitions: false,
+        parent_schema: Some(schema.clone()),
+        parent_name: None,
+        match_mode: Some(dbx_core::types::CompletionAssistantMatchMode::Prefix),
+    };
+
+    let response = dbx_core::db::sqlserver::completion_assistant_search(&mut client, &request)
+        .await
+        .expect("completion assistant tables");
+    assert!(response
+        .candidates
+        .iter()
+        .any(|candidate| candidate.name == table && candidate.schema.as_deref() == Some(schema.as_str())));
+
+    let column_response = dbx_core::db::sqlserver::completion_assistant_search(
+        &mut client,
+        &dbx_core::types::CompletionAssistantRequest {
+            object_kinds: vec![dbx_core::types::CompletionAssistantObjectKind::Column],
+            mask: "display".to_string(),
+            parent_name: Some(table.clone()),
+            ..request
+        },
+    )
+    .await
+    .expect("completion assistant columns");
+    assert!(column_response
+        .candidates
+        .iter()
+        .any(|candidate| candidate.name == "display_name" && candidate.parent_name.as_deref() == Some(table.as_str())));
+
+    let cleanup = format!("DROP TABLE [{schema}].[{table}];");
+    let _ = dbx_core::db::sqlserver::execute_batch(&mut client, &cleanup).await;
+}
diff --git a/crates/dbx-core/tests/mq_token.rs b/crates/dbx-core/tests/mq_token.rs
new file mode 100644
index 0000000..b114fba
--- /dev/null
+++ b/crates/dbx-core/tests/mq_token.rs
@@ -0,0 +1,73 @@
+#![cfg(feature = "mq-admin")]
+
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
+use dbx_core::mq::token::{sign_pulsar_token, token_fingerprint};
+use dbx_core::mq::{MqTokenIssueRequest, MqTokenRecord, MqTokenSigningAlgorithm, MqTokenSigningConfig};
+use dbx_core::storage::Storage;
+
+#[test]
+fn hs256_token_contains_pulsar_subject_and_expiry() {
+    let config = MqTokenSigningConfig { algorithm: MqTokenSigningAlgorithm::Hs256, key: "broker-secret".to_string() };
+    let req = MqTokenIssueRequest {
+        subject: "order-consumer".to_string(),
+        expires_in_seconds: Some(3600),
+        scope: None,
+        actions: vec![],
+        note: None,
+    };
+
+    let issued = sign_pulsar_token(&config, &req, 1_700_000_000).unwrap();
+    let payload = issued.token.split('.').nth(1).unwrap();
+    let payload: serde_json::Value = serde_json::from_slice(&URL_SAFE_NO_PAD.decode(payload).unwrap()).unwrap();
+
+    assert_eq!(payload.get("sub").and_then(serde_json::Value::as_str), Some("order-consumer"));
+    assert_eq!(payload.get("iat").and_then(serde_json::Value::as_i64), Some(1_700_000_000));
+    assert_eq!(payload.get("exp").and_then(serde_json::Value::as_i64), Some(1_700_003_600));
+    assert_eq!(issued.fingerprint, token_fingerprint(&issued.token));
+}
+
+#[test]
+fn token_signing_requires_configured_key() {
+    let config = MqTokenSigningConfig { algorithm: MqTokenSigningAlgorithm::Hs256, key: "   ".to_string() };
+    let req = MqTokenIssueRequest {
+        subject: "order-consumer".to_string(),
+        expires_in_seconds: None,
+        scope: None,
+        actions: vec![],
+        note: None,
+    };
+
+    let err = sign_pulsar_token(&config, &req, 1_700_000_000).unwrap_err();
+    assert!(err.contains("signing key"));
+}
+
+#[tokio::test]
+async fn token_records_are_saved_without_token_plaintext() {
+    let storage = Storage::open(&temp_db_path("mq-token-records")).await.unwrap();
+    let record = MqTokenRecord {
+        id: "rec-1".to_string(),
+        connection_id: "conn-1".to_string(),
+        subject: "order-consumer".to_string(),
+        algorithm: MqTokenSigningAlgorithm::Hs256,
+        token_fingerprint: "sha256:abc".to_string(),
+        scope: None,
+        actions: vec![],
+        expires_at: Some("2026-06-14T12:00:00Z".to_string()),
+        created_at: "2026-06-14T11:00:00Z".to_string(),
+        note: "issued for test".to_string(),
+    };
+
+    storage.save_mq_token_record(&record).await.unwrap();
+    let records = storage.load_mq_token_records("conn-1", Some("order-consumer")).await.unwrap();
+
+    assert_eq!(records, vec![record]);
+    let json = serde_json::to_value(&records[0]).unwrap();
+    assert!(json.get("token").is_none());
+}
+
+fn temp_db_path(name: &str) -> std::path::PathBuf {
+    let stamp = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
+    std::env::temp_dir().join(format!("dbx-{name}-{}-{stamp}.db", std::process::id()))
+}
diff --git a/crates/dbx-core/tests/mysql_cross_database_editing.rs b/crates/dbx-core/tests/mysql_cross_database_editing.rs
new file mode 100644
index 0000000..611f04d
--- /dev/null
+++ b/crates/dbx-core/tests/mysql_cross_database_editing.rs
@@ -0,0 +1,117 @@
+use dbx_core::data_grid_sql::{
+    prepare_data_grid_save, DataGridColumnInfo, DataGridSaveStatementOptions, DataGridTableMeta,
+};
+use dbx_core::db::ObjectSourceKind;
+use dbx_core::models::connection::DatabaseType;
+use dbx_core::schema::mysql_object_source_sql;
+use dbx_core::sql_dialect::{
+    build_count_table_sql, build_table_data_select_sql, build_table_select_sql, TableDataSelectSqlOptions,
+    TableSelectSqlOptions,
+};
+use dbx_core::sql_editability::analyze_editable_query_editability;
+use serde_json::json;
+
+#[test]
+fn mysql_cross_database_query_flow_preserves_target_database() {
+    let analysis = analyze_editable_query_editability("SELECT * FROM db_9.users WHERE active = 1");
+    assert!(analysis.editable, "simple cross-database mysql query should remain editable");
+    let analysis = analysis.analysis.expect("editable query should include parsed analysis");
+    assert_eq!(analysis.schema.as_deref(), Some("db_9"));
+    assert_eq!(analysis.table_name, "users");
+
+    let preview_sql = build_table_data_select_sql(TableDataSelectSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: Some("db_9".to_string()),
+        table_name: "users".to_string(),
+        table_type: Some("TABLE".to_string()),
+        primary_keys: vec!["id".to_string()],
+        columns: vec!["id".to_string(), "name".to_string()],
+        fallback_order_columns: vec![],
+        order_by: Some("`id` ASC".to_string()),
+        limit: Some(100),
+        offset: Some(0),
+        where_input: Some("active = 1".to_string()),
+        include_row_id: false,
+        ..Default::default()
+    });
+    assert!(preview_sql.contains("FROM `db_9`.`users`"), "preview SQL should stay on the referenced database");
+
+    let export_sql = build_table_select_sql(TableSelectSqlOptions {
+        database_type: Some(DatabaseType::Mysql),
+        schema: Some("db_9"),
+        table_name: "users",
+        columns: &["id".to_string(), "name".to_string()],
+        order_columns: &["id".to_string()],
+        limit: 50,
+    });
+    assert!(
+        export_sql.contains("FROM `db_9`.`users`"),
+        "table export/select SQL should stay on the referenced database"
+    );
+
+    let count_sql = build_count_table_sql(Some(DatabaseType::Mysql), Some("db_9"), "users");
+    assert_eq!(count_sql, "SELECT COUNT(*) AS row_count FROM `db_9`.`users`");
+
+    let save = prepare_data_grid_save(DataGridSaveStatementOptions {
+        database_type: Some(DatabaseType::Mysql),
+        table_meta: DataGridTableMeta {
+            catalog: None,
+            schema: Some("db_9".to_string()),
+            table_name: "users".to_string(),
+            primary_keys: vec!["id".to_string()],
+            columns: Some(vec![
+                DataGridColumnInfo {
+                    name: "id".to_string(),
+                    data_type: "INT".to_string(),
+                    is_nullable: false,
+                    is_primary_key: true,
+                    column_default: None,
+                    extra: None,
+                },
+                DataGridColumnInfo {
+                    name: "name".to_string(),
+                    data_type: "VARCHAR".to_string(),
+                    is_nullable: true,
+                    is_primary_key: false,
+                    column_default: None,
+                    extra: None,
+                },
+            ]),
+        },
+        columns: vec!["id".to_string(), "name".to_string()],
+        source_columns: None,
+        rows: vec![vec![json!(1), json!("before")]],
+        dirty_rows: vec![(0, vec![(1, json!("after"))])],
+        deleted_rows: vec![],
+        new_rows: vec![],
+    });
+
+    assert_eq!(save.execution_schema.as_deref(), Some("db_9"));
+    assert_eq!(save.statements.len(), 1);
+    assert!(
+        save.statements[0].contains("UPDATE `db_9`.`users` SET `name` = 'after'"),
+        "save SQL should update the referenced database: {}",
+        save.statements[0]
+    );
+    assert!(
+        save.statements[0].contains("WHERE `id` = 1"),
+        "save SQL should still target the selected row by primary key: {}",
+        save.statements[0]
+    );
+}
+
+#[test]
+fn mysql_cross_database_show_create_and_object_source_are_qualified() {
+    assert_eq!(
+        mysql_object_source_sql("db_9", "users_view", &ObjectSourceKind::View),
+        "SHOW CREATE VIEW `db_9`.`users_view`"
+    );
+    assert_eq!(
+        mysql_object_source_sql("db_9", "sync_users", &ObjectSourceKind::Procedure),
+        "SHOW CREATE PROCEDURE `db_9`.`sync_users`"
+    );
+    assert_eq!(
+        mysql_object_source_sql("db_9", "score_user", &ObjectSourceKind::Function),
+        "SHOW CREATE FUNCTION `db_9`.`score_user`"
+    );
+}
diff --git a/crates/dbx-core/tests/sql_analysis.rs b/crates/dbx-core/tests/sql_analysis.rs
new file mode 100644
index 0000000..f32acfd
--- /dev/null
+++ b/crates/dbx-core/tests/sql_analysis.rs
@@ -0,0 +1,114 @@
+use dbx_core::sql_analysis::analyze_sql_references;
+
+#[test]
+fn extracts_tables_aliases_and_qualified_columns() {
+    let analysis = analyze_sql_references("select u.missing from users u where u.id = 1", Some("postgres")).unwrap();
+
+    assert_eq!(analysis.tables.len(), 1);
+    assert_eq!(analysis.tables[0].name, "users");
+    assert_eq!(analysis.tables[0].alias.as_deref(), Some("u"));
+
+    let columns: Vec<_> =
+        analysis.columns.iter().map(|column| (column.qualifier.as_deref(), column.name.as_str())).collect();
+    assert_eq!(columns, vec![(Some("u"), "missing"), (Some("u"), "id")]);
+}
+
+#[test]
+fn extracts_nested_query_scopes_for_correlated_subqueries() {
+    let sql = "select aa.house_id from mds_base_house aa where exists (select 1 from mds_base_owner where HOUSE_ID = aa.HOUSE_ID)";
+    let analysis = analyze_sql_references(sql, Some("mysql")).unwrap();
+
+    let tables: Vec<_> =
+        analysis.tables.iter().map(|table| (table.name.as_str(), table.alias.as_deref(), table.scope_id)).collect();
+    assert_eq!(tables, vec![("mds_base_house", Some("aa"), 0), ("mds_base_owner", None, 1)]);
+
+    let scopes: Vec<_> = analysis.scopes.iter().map(|scope| (scope.id, scope.parent_id)).collect();
+    assert_eq!(scopes, vec![(0, None), (1, Some(0))]);
+
+    let columns: Vec<_> = analysis
+        .columns
+        .iter()
+        .map(|column| (column.qualifier.as_deref(), column.name.as_str(), column.scope_id))
+        .collect();
+    assert_eq!(columns, vec![(Some("aa"), "house_id", 0), (None, "HOUSE_ID", 1), (Some("aa"), "HOUSE_ID", 1)]);
+}
+
+#[test]
+fn extracts_unqualified_columns_from_single_table_select() {
+    let analysis = analyze_sql_references("select missing, id from users", Some("postgres")).unwrap();
+
+    let columns: Vec<_> =
+        analysis.columns.iter().map(|column| (column.qualifier.as_deref(), column.name.as_str())).collect();
+    assert_eq!(columns, vec![(None, "missing"), (None, "id")]);
+}
+
+#[test]
+fn extracts_mysql_quoted_table_references() {
+    let analysis = analyze_sql_references("SELECT * FROM `t_19991` LIMIT 100", Some("mysql")).unwrap();
+
+    assert_eq!(analysis.tables.len(), 1);
+    assert_eq!(analysis.tables[0].name, "t_19991");
+    assert_eq!(analysis.tables[0].schema, None);
+    assert_eq!(analysis.tables[0].span.start_line, 1);
+    assert_eq!(analysis.tables[0].span.start_column, 15);
+    assert_eq!(analysis.tables[0].span.end_line, 1);
+    assert_eq!(analysis.tables[0].span.end_column, 24);
+}
+
+#[test]
+fn extracts_mysql_single_quoted_table_references() {
+    let analysis = analyze_sql_references("SELECT * FROM 't_10001' LIMIT 100", Some("mysql")).unwrap();
+
+    assert_eq!(analysis.tables.len(), 1);
+    assert_eq!(analysis.tables[0].name, "t_10001");
+    assert_eq!(analysis.tables[0].schema, None);
+}
+
+#[test]
+fn postgres_default_privileges_statements_do_not_raise_syntax_errors() {
+    let sql = "\
+ALTER DEFAULT PRIVILEGES IN SCHEMA public
+GRANT SELECT,INSERT,UPDATE,DELETE,TRUNCATE,REFERENCES,TRIGGER ON TABLES TO app_user;";
+
+    let analysis = analyze_sql_references(sql, Some("postgres"))
+        .unwrap_or_else(|error| panic!("PostgreSQL ALTER DEFAULT PRIVILEGES should analyze: {error}"));
+
+    assert!(analysis.tables.is_empty());
+    assert!(analysis.columns.is_empty());
+}
+
+#[test]
+fn extracts_unqualified_order_by_columns_for_sqlserver_queries() {
+    let analysis =
+        analyze_sql_references("SELECT * FROM Evt_GCM_Qop_Info ORDER BY PDReceiveDatePartInfo DESC", Some("sqlserver"))
+            .unwrap();
+
+    assert_eq!(analysis.tables.len(), 1);
+    assert_eq!(analysis.tables[0].name, "Evt_GCM_Qop_Info");
+
+    let columns: Vec<_> =
+        analysis.columns.iter().map(|column| (column.qualifier.as_deref(), column.name.as_str())).collect();
+    assert_eq!(columns, vec![(None, "PDReceiveDatePartInfo")]);
+}
+
+#[test]
+fn duckdb_parser_gap_queries_do_not_raise_syntax_errors() {
+    for sql in ["FROM users;", "SUMMARIZE users;", "SUMMARISE users;"] {
+        let analysis = analyze_sql_references(sql, Some("duckdb")).expect("duckdb parser gap query should analyze");
+        assert!(analysis.tables.is_empty());
+        assert!(analysis.columns.is_empty());
+    }
+}
+
+#[test]
+fn clickhouse_strictness_first_left_joins_do_not_raise_syntax_errors() {
+    for strictness in ["ANY", "ALL", "SEMI", "ANTI"] {
+        let sql = format!("SELECT a.id FROM events a {strictness} LEFT JOIN wallets b ON a.wallet_id = b.id");
+        let analysis = analyze_sql_references(&sql, Some("clickhouse"))
+            .unwrap_or_else(|error| panic!("ClickHouse {strictness} LEFT JOIN should analyze: {error}"));
+
+        let tables: Vec<_> =
+            analysis.tables.iter().map(|table| (table.name.as_str(), table.alias.as_deref())).collect();
+        assert_eq!(tables, vec![("events", Some("a")), ("wallets", Some("b"))]);
+    }
+}
diff --git a/crates/dbx-core/tests/support/duckdb_worker_file_lock_owner.rs b/crates/dbx-core/tests/support/duckdb_worker_file_lock_owner.rs
new file mode 100644
index 0000000..25ac989
--- /dev/null
+++ b/crates/dbx-core/tests/support/duckdb_worker_file_lock_owner.rs
@@ -0,0 +1,16 @@
+#![cfg(feature = "duckdb-bundled")]
+
+use std::io::Write;
+use std::path::PathBuf;
+use std::time::Duration;
+
+fn main() {
+    let mut args = std::env::args().skip(1);
+    let path = args.next().map(PathBuf::from).expect("DuckDB path argument");
+    let hold_ms = args.next().expect("hold duration argument").parse::<u64>().expect("hold duration ms");
+
+    let _connection = duckdb::Connection::open(&path).expect("open lock owner connection");
+    println!("ready");
+    std::io::stdout().flush().expect("flush ready line");
+    std::thread::sleep(Duration::from_millis(hold_ms));
+}
diff --git a/crates/dbx-core/tests/support/duckdb_worker_hanging_connect_test_host.rs b/crates/dbx-core/tests/support/duckdb_worker_hanging_connect_test_host.rs
new file mode 100644
index 0000000..2919239
--- /dev/null
+++ b/crates/dbx-core/tests/support/duckdb_worker_hanging_connect_test_host.rs
@@ -0,0 +1,20 @@
+#![cfg(feature = "duckdb-bundled")]
+
+use std::io::{self, BufRead};
+use std::time::Duration;
+
+fn main() {
+    if let Ok(path) = std::env::var("DBX_DUCKDB_HANGING_CONNECT_PID_FILE") {
+        let _ = std::fs::write(path, std::process::id().to_string());
+    }
+
+    let stdin = io::stdin();
+    let mut lines = stdin.lock().lines();
+    let Some(Ok(_line)) = lines.next() else {
+        return;
+    };
+
+    loop {
+        std::thread::sleep(Duration::from_secs(60));
+    }
+}
diff --git a/crates/dbx-core/tests/support/duckdb_worker_pid_test_host.rs b/crates/dbx-core/tests/support/duckdb_worker_pid_test_host.rs
new file mode 100644
index 0000000..4ce0fc6
--- /dev/null
+++ b/crates/dbx-core/tests/support/duckdb_worker_pid_test_host.rs
@@ -0,0 +1,13 @@
+#![cfg(feature = "duckdb-bundled")]
+
+fn main() {
+    if let Ok(path) = std::env::var("DBX_DUCKDB_PID_TEST_HOST_PID_FILE") {
+        let _ = std::fs::write(path, std::process::id().to_string());
+    }
+
+    let runtime = tokio::runtime::Runtime::new().expect("Failed to create DuckDB worker test runtime");
+    if let Err(err) = runtime.block_on(dbx_core::db::duckdb_worker_runtime::run_stdio_worker()) {
+        eprintln!("DuckDB worker test host failed: {err}");
+        std::process::exit(1);
+    }
+}
diff --git a/crates/dbx-core/tests/support/duckdb_worker_test_host.rs b/crates/dbx-core/tests/support/duckdb_worker_test_host.rs
new file mode 100644
index 0000000..6f4e392
--- /dev/null
+++ b/crates/dbx-core/tests/support/duckdb_worker_test_host.rs
@@ -0,0 +1,9 @@
+#![cfg(feature = "duckdb-bundled")]
+
+fn main() {
+    let runtime = tokio::runtime::Runtime::new().expect("Failed to create DuckDB worker test runtime");
+    if let Err(err) = runtime.block_on(dbx_core::db::duckdb_worker_runtime::run_stdio_worker()) {
+        eprintln!("DuckDB worker test host failed: {err}");
+        std::process::exit(1);
+    }
+}
diff --git a/crates/dbx-web/Cargo.toml b/crates/dbx-web/Cargo.toml
new file mode 100644
index 0000000..8767c13
--- /dev/null
+++ b/crates/dbx-web/Cargo.toml
@@ -0,0 +1,37 @@
+[package]
+name = "dbx-web"
+version = "0.5.55"
+edition = "2021"
+license = "Apache-2.0"
+
+[[bin]]
+name = "dbx-web"
+path = "src/main.rs"
+
+[features]
+default = ["mq-admin"]
+mq-admin = ["dbx-core/mq-admin"]
+
+[dependencies]
+dbx-core = { path = "../dbx-core" }
+redis = { version = "0.32", features = ["tokio-comp"] }
+axum = { version = "0.8", features = ["multipart", "ws"] }
+tower-http = { version = "0.6", features = ["cors", "fs", "compression-gzip", "trace"] }
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+uuid = { version = "1", features = ["v4"] }
+argon2 = "0.5"
+log = "0.4"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing = "0.1"
+async-stream = "0.3"
+futures = "0.3"
+rustls = { version = "0.23", features = ["aws-lc-rs"] }
+tokio-util = "0.7"
+reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls"] }
+chrono = "0.4"
+aes-gcm = "0.10"
+base64 = "0.22"
+pbkdf2 = "0.12"
+sha2 = "0.10"
diff --git a/crates/dbx-web/src/auth.rs b/crates/dbx-web/src/auth.rs
new file mode 100644
index 0000000..53a1b41
--- /dev/null
+++ b/crates/dbx-web/src/auth.rs
@@ -0,0 +1,277 @@
+use std::sync::Arc;
+
+use argon2::password_hash::rand_core::OsRng;
+use argon2::password_hash::SaltString;
+use argon2::{Argon2, PasswordHash, PasswordHasher, PasswordVerifier};
+use axum::extract::State;
+use axum::http::{Request, StatusCode};
+use axum::middleware::Next;
+use axum::response::{IntoResponse, Response};
+use axum::Json;
+use serde::{Deserialize, Serialize};
+
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+pub struct LoginRequest {
+    pub password: String,
+}
+
+#[derive(Deserialize)]
+pub struct ChangePasswordRequest {
+    pub old_password: String,
+    pub new_password: String,
+}
+
+#[derive(Serialize)]
+pub struct AuthCheckResponse {
+    pub authenticated: bool,
+    pub required: bool,
+    pub setup_required: bool,
+}
+
+const MAX_ATTEMPTS: u32 = 5;
+const LOCKOUT_SECS: u64 = 60;
+
+fn session_cookie_path(state: &WebState) -> &str {
+    state.public_base_path.as_str()
+}
+
+fn api_path_suffix<'a>(path: &'a str, public_base_path: &str) -> Option<&'a str> {
+    if let Some(suffix) = path.strip_prefix("/api/") {
+        return Some(suffix);
+    }
+    let base = public_base_path.trim_end_matches('/');
+    if base.is_empty() || base == "/" {
+        return None;
+    }
+    path.strip_prefix(base)?.strip_prefix("/api/")
+}
+
+fn middleware_api_path_suffix<'a>(path: &'a str, public_base_path: &str) -> Option<&'a str> {
+    if let Some(suffix) = api_path_suffix(path, public_base_path) {
+        return Some(suffix);
+    }
+
+    let base = public_base_path.trim_end_matches('/');
+    if !base.is_empty() && base != "/" && path.strip_prefix(base).is_some() {
+        return None;
+    }
+
+    path.strip_prefix('/').filter(|suffix| !suffix.is_empty())
+}
+
+pub async fn login(State(state): State<Arc<WebState>>, Json(body): Json<LoginRequest>) -> Result<Response, StatusCode> {
+    let hash_guard = state.password_hash.read().await;
+    let hash_str = match hash_guard.as_deref() {
+        Some(h) => h.to_string(),
+        None => {
+            return Ok((StatusCode::OK, Json(serde_json::json!({"ok": true}))).into_response());
+        }
+    };
+    drop(hash_guard);
+
+    // Check rate limit
+    {
+        let rl = state.login_rate_limit.lock().await;
+        if let Some(locked_until) = rl.locked_until {
+            if locked_until > std::time::Instant::now() {
+                let remaining = (locked_until - std::time::Instant::now()).as_secs();
+                return Ok((
+                    StatusCode::TOO_MANY_REQUESTS,
+                    Json(serde_json::json!({"error": format!("请 {remaining} 秒后再试")})),
+                )
+                    .into_response());
+            }
+        }
+    }
+
+    let parsed_hash = PasswordHash::new(&hash_str).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+
+    if Argon2::default().verify_password(body.password.as_bytes(), &parsed_hash).is_err() {
+        let mut rl = state.login_rate_limit.lock().await;
+        rl.fail_count += 1;
+        if rl.fail_count >= MAX_ATTEMPTS {
+            rl.locked_until = Some(std::time::Instant::now() + std::time::Duration::from_secs(LOCKOUT_SECS));
+            rl.fail_count = 0;
+        }
+        return Err(StatusCode::UNAUTHORIZED);
+    }
+
+    // Success — reset rate limit
+    {
+        let mut rl = state.login_rate_limit.lock().await;
+        rl.fail_count = 0;
+        rl.locked_until = None;
+    }
+
+    let token = uuid::Uuid::new_v4().to_string();
+    state.sessions.write().await.insert(token.clone());
+
+    let cookie = format!("dbx_session={token}; Path={}; HttpOnly; SameSite=Lax", session_cookie_path(&state));
+    Ok((StatusCode::OK, [("set-cookie", cookie.as_str())], Json(serde_json::json!({"ok": true}))).into_response())
+}
+
+pub async fn setup(State(state): State<Arc<WebState>>, Json(body): Json<LoginRequest>) -> Result<Response, StatusCode> {
+    if state.password_disabled {
+        return Err(StatusCode::FORBIDDEN);
+    }
+
+    // Only allow setup when no password is configured
+    if state.password_hash.read().await.is_some() {
+        return Err(StatusCode::FORBIDDEN);
+    }
+
+    if body.password.is_empty() {
+        return Err(StatusCode::BAD_REQUEST);
+    }
+
+    let salt = SaltString::generate(&mut OsRng);
+    let hash = Argon2::default()
+        .hash_password(body.password.as_bytes(), &salt)
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
+        .to_string();
+
+    // Save to database
+    state.app.storage.save_password_hash(&hash).await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+
+    // Update in-memory state
+    *state.password_hash.write().await = Some(hash);
+
+    // Auto-login: create session
+    let token = uuid::Uuid::new_v4().to_string();
+    state.sessions.write().await.insert(token.clone());
+
+    let cookie = format!("dbx_session={token}; Path={}; HttpOnly; SameSite=Lax", session_cookie_path(&state));
+    Ok((StatusCode::OK, [("set-cookie", cookie.as_str())], Json(serde_json::json!({"ok": true}))).into_response())
+}
+
+pub async fn check(State(state): State<Arc<WebState>>, req: Request<axum::body::Body>) -> Json<AuthCheckResponse> {
+    if state.password_disabled {
+        return Json(AuthCheckResponse { authenticated: true, required: false, setup_required: false });
+    }
+    let has_password = state.password_hash.read().await.is_some();
+    if !has_password {
+        return Json(AuthCheckResponse { authenticated: false, required: false, setup_required: true });
+    }
+    let authenticated = match extract_session_token(&req) {
+        Some(token) => state.sessions.read().await.contains(&token),
+        None => false,
+    };
+    Json(AuthCheckResponse { authenticated, required: true, setup_required: false })
+}
+
+pub async fn change_password(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<ChangePasswordRequest>,
+) -> Result<Response, StatusCode> {
+    let hash_guard = state.password_hash.read().await;
+    let hash_str = match hash_guard.as_deref() {
+        Some(h) => h.to_string(),
+        None => return Err(StatusCode::BAD_REQUEST),
+    };
+    drop(hash_guard);
+
+    if body.new_password.is_empty() {
+        return Err(StatusCode::BAD_REQUEST);
+    }
+
+    let parsed_hash = PasswordHash::new(&hash_str).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    if Argon2::default().verify_password(body.old_password.as_bytes(), &parsed_hash).is_err() {
+        return Err(StatusCode::UNAUTHORIZED);
+    }
+
+    let salt = SaltString::generate(&mut OsRng);
+    let new_hash = Argon2::default()
+        .hash_password(body.new_password.as_bytes(), &salt)
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
+        .to_string();
+
+    state.app.storage.save_password_hash(&new_hash).await.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    *state.password_hash.write().await = Some(new_hash);
+
+    Ok((StatusCode::OK, Json(serde_json::json!({"ok": true}))).into_response())
+}
+
+pub async fn logout(State(state): State<Arc<WebState>>, req: Request<axum::body::Body>) -> Response {
+    if let Some(token) = extract_session_token(&req) {
+        state.sessions.write().await.remove(&token);
+    }
+    let cookie = format!("dbx_session=; Path={}; HttpOnly; Max-Age=0", session_cookie_path(&state));
+    (StatusCode::OK, [("set-cookie", cookie.as_str())], Json(serde_json::json!({"ok": true}))).into_response()
+}
+
+fn extract_session_token<B>(req: &Request<B>) -> Option<String> {
+    let cookie_header = req.headers().get("cookie")?.to_str().ok()?;
+    for pair in cookie_header.split(';') {
+        let pair = pair.trim();
+        if let Some(value) = pair.strip_prefix("dbx_session=") {
+            if !value.is_empty() {
+                return Some(value.to_string());
+            }
+        }
+    }
+    None
+}
+
+pub async fn auth_middleware(
+    State(state): State<Arc<WebState>>,
+    req: Request<axum::body::Body>,
+    next: Next,
+) -> Response {
+    // Auth endpoints are always accessible.
+    let api_suffix = middleware_api_path_suffix(req.uri().path(), &state.public_base_path);
+    if api_suffix.is_some_and(|suffix| suffix.starts_with("auth/")) {
+        return next.run(req).await;
+    }
+
+    // Non-API requests (static files) are always accessible.
+    if api_suffix.is_none() {
+        return next.run(req).await;
+    }
+
+    if state.password_disabled {
+        return next.run(req).await;
+    }
+
+    if state.password_hash.read().await.is_none() {
+        return StatusCode::UNAUTHORIZED.into_response();
+    }
+
+    // Check session token
+    if let Some(token) = extract_session_token(&req) {
+        if state.sessions.read().await.contains(&token) {
+            return next.run(req).await;
+        }
+    }
+
+    StatusCode::UNAUTHORIZED.into_response()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{api_path_suffix, middleware_api_path_suffix};
+
+    #[test]
+    fn api_path_suffix_handles_root_api_paths() {
+        assert_eq!(api_path_suffix("/api/auth/check", "/"), Some("auth/check"));
+        assert_eq!(api_path_suffix("/api/query/execute", "/"), Some("query/execute"));
+        assert_eq!(api_path_suffix("/dbx/api/auth/check", "/"), None);
+    }
+
+    #[test]
+    fn api_path_suffix_handles_mounted_api_paths() {
+        assert_eq!(api_path_suffix("/dbx/api/auth/check", "/dbx"), Some("auth/check"));
+        assert_eq!(api_path_suffix("/tools/dbx/api/query/execute", "/tools/dbx"), Some("query/execute"));
+        assert_eq!(api_path_suffix("/dbx/login", "/dbx"), None);
+    }
+
+    #[test]
+    fn middleware_api_path_suffix_handles_nested_router_paths() {
+        assert_eq!(middleware_api_path_suffix("/auth/check", "/"), Some("auth/check"));
+        assert_eq!(middleware_api_path_suffix("/connection/list", "/"), Some("connection/list"));
+        assert_eq!(middleware_api_path_suffix("/api/connection/list", "/"), Some("connection/list"));
+        assert_eq!(middleware_api_path_suffix("/dbx/api/connection/list", "/dbx"), Some("connection/list"));
+        assert_eq!(middleware_api_path_suffix("/dbx/login", "/dbx"), None);
+    }
+}
diff --git a/crates/dbx-web/src/error.rs b/crates/dbx-web/src/error.rs
new file mode 100644
index 0000000..d123e22
--- /dev/null
+++ b/crates/dbx-web/src/error.rs
@@ -0,0 +1,32 @@
+use axum::http::StatusCode;
+use axum::response::{IntoResponse, Response};
+
+pub struct AppError(pub String);
+
+impl AppError {
+    pub fn internal(msg: impl Into<String>) -> Self {
+        AppError(msg.into())
+    }
+
+    pub fn bad_request(msg: impl Into<String>) -> Self {
+        AppError(msg.into())
+    }
+}
+
+impl IntoResponse for AppError {
+    fn into_response(self) -> Response {
+        (StatusCode::INTERNAL_SERVER_ERROR, self.0).into_response()
+    }
+}
+
+impl From<String> for AppError {
+    fn from(s: String) -> Self {
+        AppError(s)
+    }
+}
+
+impl From<&str> for AppError {
+    fn from(s: &str) -> Self {
+        AppError(s.to_string())
+    }
+}
diff --git a/crates/dbx-web/src/main.rs b/crates/dbx-web/src/main.rs
new file mode 100644
index 0000000..aad4c55
--- /dev/null
+++ b/crates/dbx-web/src/main.rs
@@ -0,0 +1,625 @@
+mod auth;
+mod error;
+mod routes;
+mod sse;
+mod state;
+
+use std::collections::{HashMap, HashSet};
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+use argon2::password_hash::rand_core::OsRng;
+use argon2::password_hash::SaltString;
+use argon2::{Argon2, PasswordHasher};
+use axum::extract::DefaultBodyLimit;
+use axum::middleware;
+use axum::routing::{delete, get, post};
+use axum::Router;
+use dbx_core::connection::AppState;
+use dbx_core::storage::Storage;
+use state::WebState;
+use tokio::sync::RwLock;
+
+fn web_body_limit_bytes() -> usize {
+    const DEFAULT_MB: usize = 1024;
+    let mb = std::env::var("DBX_MAX_UPLOAD_MB")
+        .ok()
+        .and_then(|value| value.parse::<usize>().ok())
+        .filter(|value| *value > 0)
+        .unwrap_or(DEFAULT_MB);
+    mb.saturating_mul(1024 * 1024)
+}
+
+fn web_agent_dir(data_dir: &std::path::Path) -> std::path::PathBuf {
+    web_agent_dir_from_env(data_dir, std::env::var("DBX_AGENT_DIR").ok())
+}
+
+fn web_agent_dir_from_env(data_dir: &std::path::Path, agent_dir: Option<String>) -> std::path::PathBuf {
+    agent_dir.map(std::path::PathBuf::from).unwrap_or_else(|| data_dir.join("agents"))
+}
+
+fn normalize_public_base_path(value: Option<String>) -> String {
+    let trimmed = value
+        .unwrap_or_else(|| "/".to_string())
+        .split(['?', '#'])
+        .next()
+        .unwrap_or("/")
+        .trim()
+        .trim_matches('/')
+        .to_string();
+    if trimmed.chars().any(|ch| ch.is_ascii_control() || ch.is_ascii_whitespace() || matches!(ch, ';' | ',')) {
+        panic!("DBX_PUBLIC_BASE_PATH contains invalid characters");
+    }
+    if trimmed.is_empty() {
+        "/".to_string()
+    } else {
+        format!("/{trimmed}")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{normalize_public_base_path, web_agent_dir_from_env};
+
+    #[test]
+    fn normalize_public_base_path_defaults_to_root() {
+        assert_eq!(normalize_public_base_path(None), "/");
+        assert_eq!(normalize_public_base_path(Some("".to_string())), "/");
+        assert_eq!(normalize_public_base_path(Some("/".to_string())), "/");
+    }
+
+    #[test]
+    fn normalize_public_base_path_trims_and_preserves_segments() {
+        assert_eq!(normalize_public_base_path(Some("dbx".to_string())), "/dbx");
+        assert_eq!(normalize_public_base_path(Some("/dbx/".to_string())), "/dbx");
+        assert_eq!(normalize_public_base_path(Some("/tools/dbx/?v=1".to_string())), "/tools/dbx");
+    }
+
+    #[test]
+    #[should_panic(expected = "DBX_PUBLIC_BASE_PATH contains invalid characters")]
+    fn normalize_public_base_path_rejects_invalid_characters() {
+        normalize_public_base_path(Some("/dbx admin".to_string()));
+    }
+
+    #[test]
+    fn web_agent_dir_defaults_under_data_dir() {
+        let data_dir = std::path::PathBuf::from("/app/data");
+        assert_eq!(web_agent_dir_from_env(&data_dir, None), data_dir.join("agents"));
+    }
+
+    #[test]
+    fn web_agent_dir_uses_explicit_env_override() {
+        let data_dir = std::path::PathBuf::from("/app/data");
+        assert_eq!(
+            web_agent_dir_from_env(&data_dir, Some("/custom/agents".to_string())),
+            std::path::PathBuf::from("/custom/agents")
+        );
+    }
+}
+
+#[cfg(feature = "mq-admin")]
+fn add_mq_routes(router: Router<Arc<WebState>>) -> Router<Arc<WebState>> {
+    router
+        .route("/mq/test-connection", post(routes::mq::test_connection))
+        .route("/mq/tenants/list", post(routes::mq::list_tenants))
+        .route("/mq/tenants/get", post(routes::mq::get_tenant))
+        .route("/mq/tenants/create", post(routes::mq::create_tenant))
+        .route("/mq/tenants/update", post(routes::mq::update_tenant))
+        .route("/mq/tenants/delete", post(routes::mq::delete_tenant))
+        .route("/mq/namespaces/list", post(routes::mq::list_namespaces))
+        .route("/mq/namespaces/create", post(routes::mq::create_namespace))
+        .route("/mq/namespaces/delete", post(routes::mq::delete_namespace))
+        .route("/mq/namespaces/policies", post(routes::mq::get_namespace_policies))
+        .route("/mq/topics/list", post(routes::mq::list_topics))
+        .route("/mq/topics/create", post(routes::mq::create_topic))
+        .route("/mq/topics/delete", post(routes::mq::delete_topic))
+        .route("/mq/topics/update-partitions", post(routes::mq::update_partitions))
+        .route("/mq/topics/stats", post(routes::mq::get_topic_stats))
+        .route("/mq/topics/internal-stats", post(routes::mq::get_topic_internal_stats))
+        .route("/mq/subscriptions/list", post(routes::mq::list_subscriptions))
+        .route("/mq/subscriptions/create", post(routes::mq::create_subscription))
+        .route("/mq/subscriptions/delete", post(routes::mq::delete_subscription))
+        .route("/mq/subscriptions/skip-messages", post(routes::mq::skip_messages))
+        .route("/mq/subscriptions/reset-cursor", post(routes::mq::reset_cursor))
+        .route("/mq/subscriptions/clear-backlog", post(routes::mq::clear_backlog))
+        .route("/mq/subscriptions/peek-messages", post(routes::mq::peek_messages))
+        .route("/mq/subscriptions/expire-messages", post(routes::mq::expire_messages))
+        .route("/mq/producers/list", post(routes::mq::list_producers))
+        .route("/mq/consumers/list", post(routes::mq::list_consumers))
+        .route("/mq/topics/unload", post(routes::mq::unload_topic))
+        .route("/mq/policies/publish-rate", post(routes::mq::set_publish_rate))
+        .route("/mq/policies/dispatch-rate", post(routes::mq::set_dispatch_rate))
+        .route("/mq/policies/subscribe-rate", post(routes::mq::set_subscribe_rate))
+        .route("/mq/policies/backlog-quota", post(routes::mq::set_backlog_quota))
+        .route("/mq/policies/retention", post(routes::mq::set_retention))
+        .route("/mq/policies/effective", post(routes::mq::get_effective_policies))
+        .route("/mq/permissions/grant", post(routes::mq::grant_permission))
+        .route("/mq/permissions/revoke", post(routes::mq::revoke_permission))
+        .route("/mq/permissions/list", post(routes::mq::list_permissions))
+        .route("/mq/tokens/issue", post(routes::mq::issue_token))
+        .route("/mq/tokens/list", post(routes::mq::list_token_records))
+        .route("/mq/monitoring/backlog", post(routes::mq::get_backlog))
+        .route("/mq/monitoring/cluster-info", post(routes::mq::get_cluster_info))
+        .route("/mq/raw", post(routes::mq::raw_request))
+        .route("/mq/send-message", post(routes::mq::send_message))
+}
+
+#[cfg(not(feature = "mq-admin"))]
+fn add_mq_routes(router: Router<Arc<WebState>>) -> Router<Arc<WebState>> {
+    router
+}
+
+#[tokio::main]
+async fn main() {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "dbx_web=info,tower_http=info".parse().unwrap()),
+        )
+        .init();
+
+    rustls::crypto::aws_lc_rs::default_provider().install_default().expect("Failed to install rustls crypto provider");
+
+    // Data directory
+    let data_dir = std::env::var("DBX_DATA_DIR").map(std::path::PathBuf::from).unwrap_or_else(|_| {
+        let home = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
+        std::path::PathBuf::from(home).join(".dbx-web")
+    });
+    std::fs::create_dir_all(&data_dir).expect("Failed to create data directory");
+
+    let app_state = {
+        let db_path = data_dir.join("dbx.db");
+        let storage = Storage::open(&db_path).await.expect("Failed to open storage");
+        storage.migrate_from_json(&data_dir).await.expect("Failed to migrate JSON data");
+        Arc::new(AppState::new_with_plugin_and_agent_dir_and_app_version(
+            storage,
+            data_dir.join("plugins"),
+            web_agent_dir(&data_dir),
+            env!("CARGO_PKG_VERSION"),
+        ))
+    };
+
+    // Password hash: env var takes priority, then database
+    let password_disabled = std::env::var("DBX_DISABLE_PASSWORD")
+        .map(|v| matches!(v.trim().to_lowercase().as_str(), "1" | "true" | "yes" | "on"))
+        .unwrap_or(false);
+
+    let password_hash = if password_disabled {
+        None
+    } else if let Ok(pw) = std::env::var("DBX_PASSWORD") {
+        let salt = SaltString::generate(&mut OsRng);
+        Some(Argon2::default().hash_password(pw.as_bytes(), &salt).expect("Failed to hash password").to_string())
+    } else {
+        app_state.storage.load_password_hash().await.unwrap_or(None)
+    };
+
+    let public_base_path = normalize_public_base_path(std::env::var("DBX_PUBLIC_BASE_PATH").ok());
+
+    let web_state = Arc::new(WebState {
+        app: app_state,
+        data_dir,
+        public_base_path: public_base_path.clone(),
+        password_disabled,
+        password_hash: RwLock::new(password_hash),
+        sessions: RwLock::new(HashSet::new()),
+        sse_channels: RwLock::new(HashMap::new()),
+        sql_file_executions: RwLock::new(HashMap::new()),
+        login_rate_limit: tokio::sync::Mutex::new(state::LoginRateLimit { fail_count: 0, locked_until: None }),
+        export_files: RwLock::new(HashMap::new()),
+    });
+
+    // API routes
+    let api = Router::new()
+        // Auth
+        .route("/auth/login", post(auth::login))
+        .route("/auth/check", get(auth::check))
+        .route("/auth/setup", post(auth::setup))
+        .route("/auth/change-password", post(auth::change_password))
+        .route("/auth/logout", post(auth::logout))
+        // Connection
+        .route("/connection/test", post(routes::connection::test_connection))
+        .route("/connection/connect", post(routes::connection::connect_db))
+        .route("/connection/final-proxy-port", post(routes::connection::connection_final_proxy_port))
+        .route("/connection/disconnect", post(routes::connection::disconnect_db))
+        .route("/connection/check-health", post(routes::connection::check_connection_health))
+        .route("/connection/close-database", post(routes::connection::close_database_connection))
+        .route("/connection/save", post(routes::connection::save_connections))
+        .route("/connection/list", get(routes::connection::load_connections))
+        .route("/plugins", get(routes::plugins::list_plugins))
+        // JDBC
+        .route("/jdbc/drivers", get(routes::jdbc::list_jdbc_drivers).post(routes::jdbc::import_jdbc_drivers))
+        .route(
+            "/jdbc/drivers/maven",
+            get(routes::jdbc::list_jdbc_maven_bundles).post(routes::jdbc::install_jdbc_driver_from_maven),
+        )
+        .route("/jdbc/drivers/local", get(routes::jdbc::list_jdbc_local_bundles))
+        .route("/jdbc/drivers/prestosql", post(routes::jdbc::install_prestosql_jdbc_driver))
+        .route("/jdbc/drivers/maven/{bundle_id}", delete(routes::jdbc::delete_jdbc_maven_bundle))
+        .route("/jdbc/drivers/local/{bundle_id}", delete(routes::jdbc::delete_jdbc_local_bundle))
+        .route("/jdbc/drivers/{name}", delete(routes::jdbc::delete_jdbc_driver))
+        .route("/jdbc/plugin/status", get(routes::jdbc::get_jdbc_plugin_status))
+        .route("/jdbc/plugin/install", post(routes::jdbc::install_jdbc_plugin))
+        .route("/jdbc/plugin/install-local", post(routes::jdbc::install_jdbc_plugin_local))
+        .route("/jdbc/plugin/uninstall", post(routes::jdbc::uninstall_jdbc_plugin))
+        // System
+        .route("/system/fonts", get(routes::jdbc::list_system_fonts))
+        .route("/ssh/config-hosts", get(routes::ssh_config::list_ssh_config_hosts))
+        // Tunnel profiles
+        .route("/tunnel-profiles/list", get(routes::tunnel_profiles::load_tunnel_profiles))
+        .route("/tunnel-profiles/save", post(routes::tunnel_profiles::save_tunnel_profiles))
+        // Agent drivers
+        .route("/agents/installed-local", get(routes::agents::list_installed_agents_local))
+        .route("/agents/installed", get(routes::agents::list_installed_agents))
+        .route("/agents/installed/{dbType}", get(routes::agents::is_agent_installed))
+        .route("/agents/storage-usage", get(routes::agents::get_driver_store_usage))
+        .route("/agents/download-cache", delete(routes::agents::clear_driver_download_cache))
+        .route("/agents/runtime", get(routes::agents::get_driver_runtime_summary))
+        .route("/agents/runtime/stop", post(routes::agents::stop_driver_runtime))
+        .route("/agents/runtime/restart", post(routes::agents::restart_driver_runtime))
+        .route("/agents/install", post(routes::agents::install_agent))
+        .route("/agents/upgrade-all", post(routes::agents::upgrade_all_agents))
+        .route("/agents/uninstall", post(routes::agents::uninstall_agent))
+        .route("/agents/import-offline", post(routes::agents::import_agents_from_zip))
+        .route("/agents/import-jar", post(routes::agents::import_agent_jar))
+        .route(
+            "/agents/java-runtime",
+            get(routes::agents::get_agent_java_runtime_config).post(routes::agents::set_agent_java_runtime_config),
+        )
+        .route("/agents/invalidate-registry-cache", post(routes::agents::invalidate_agent_registry_cache))
+        .route("/agents/reinstall-jre", post(routes::agents::reinstall_jre))
+        .route("/agents/uninstall-jre", post(routes::agents::uninstall_jre))
+        .route("/agents/progress/{operationId}", get(routes::agents::agent_progress))
+        // Schema
+        .route("/schema/databases", get(routes::schema::list_databases))
+        .route("/schema/doris/catalogs", get(routes::schema::list_doris_catalogs))
+        .route("/schema/doris/catalog-databases", get(routes::schema::list_doris_catalog_databases))
+        .route("/schema/sqlserver/linked-servers", get(routes::schema::list_sqlserver_linked_servers))
+        .route("/schema/sqlserver/linked-server-catalogs", get(routes::schema::list_sqlserver_linked_server_catalogs))
+        .route("/schema/sqlserver/linked-server-schemas", get(routes::schema::list_sqlserver_linked_server_schemas))
+        .route("/schema/sqlserver/linked-server-tables", get(routes::schema::list_sqlserver_linked_server_tables))
+        .route("/schema/schemas", get(routes::schema::list_schemas))
+        .route("/schema/tables", get(routes::schema::list_tables))
+        .route("/schema/objects", get(routes::schema::list_objects))
+        .route("/schema/object-statistics", get(routes::schema::list_object_statistics))
+        .route("/schema/completion-objects", get(routes::schema::list_completion_objects))
+        .route("/schema/completion-assistant", post(routes::schema::completion_assistant_search))
+        .route("/schema/object-source", get(routes::schema::get_object_source))
+        .route("/schema/columns", get(routes::schema::list_columns))
+        .route("/schema/data-types", get(routes::schema::list_data_types))
+        .route("/schema/indexes", get(routes::schema::list_indexes))
+        .route("/schema/foreign-keys", get(routes::schema::list_foreign_keys))
+        .route("/schema/triggers", get(routes::schema::list_triggers))
+        .route("/schema/functions", get(routes::schema::list_functions))
+        .route("/schema/sequences", get(routes::schema::list_sequences))
+        .route("/schema/rules", get(routes::schema::list_rules))
+        .route("/schema/owners", get(routes::schema::list_owners))
+        .route("/schema/extensions", get(routes::schema::list_extensions))
+        .route("/schema/available-extensions", get(routes::schema::list_available_extensions))
+        .route("/schema/ddl", get(routes::schema::get_ddl))
+        .route("/schema-diff/prepare", post(routes::schema_diff::prepare_schema_diff))
+        .route("/schema-diff/generate-sync-sql", post(routes::schema_diff::generate_schema_sync_sql))
+        .route(
+            "/schema/cache",
+            post(routes::schema_cache::save_schema_cache).get(routes::schema_cache::load_schema_cache),
+        )
+        .route("/schema/cache-prefix", delete(routes::schema_cache::delete_schema_cache_prefix))
+        .route(
+            "/tab-runtime-cache",
+            post(routes::tab_runtime_cache::save_tab_runtime_cache)
+                .get(routes::tab_runtime_cache::load_tab_runtime_cache)
+                .delete(routes::tab_runtime_cache::delete_tab_runtime_cache),
+        )
+        // Query
+        .route("/query/execute", post(routes::query::execute_query))
+        .route("/query/execute-multi", post(routes::query::execute_multi))
+        .route("/query/execute-batch", post(routes::query::execute_batch))
+        .route("/query/execute-script", post(routes::query::execute_script))
+        .route("/query/execute-in-transaction", post(routes::query::execute_in_transaction))
+        .route("/query/analyze-sql-references", post(routes::query::analyze_sql_references))
+        .route("/query/find-statement-at-cursor", post(routes::query::find_statement_at_cursor))
+        .route("/query/prepare-pagination-plan", post(routes::query::prepare_query_pagination_execution_plan))
+        .route("/query/build-sorted-sql", post(routes::query::build_sorted_query_sql))
+        .route("/query/build-explain-sql", post(routes::query::build_explain_sql))
+        .route("/query/build-dropped-file-preview-sql", post(routes::query::build_dropped_file_preview_sql))
+        .route("/query/get-explain-info", post(routes::query::get_explain_info))
+        .route("/query/build-create-user-sql", post(routes::query::build_create_user_sql))
+        .route("/query/build-table-select-sql", post(routes::query::build_table_select_sql))
+        .route("/query/build-database-search-sql", post(routes::query::build_database_search_sql))
+        .route("/query/build-search-result-where", post(routes::query::build_search_result_where))
+        .route("/query/build-rename-object-sql", post(routes::query::build_rename_object_sql))
+        .route("/query/build-create-database-sql", post(routes::query::build_create_database_sql))
+        .route("/query/build-duckdb-attach-database-sql", post(routes::query::build_duckdb_attach_database_sql))
+        .route("/query/build-drop-object-sql", post(routes::query::build_drop_object_sql))
+        .route("/query/build-drop-table-sql", post(routes::query::build_drop_table_sql))
+        .route("/query/build-drop-table-child-object-sql", post(routes::query::build_drop_table_child_object_sql))
+        .route("/query/build-empty-table-sql", post(routes::query::build_empty_table_sql))
+        .route("/query/build-truncate-table-sql", post(routes::query::build_truncate_table_sql))
+        .route("/query/build-drop-database-sql", post(routes::query::build_drop_database_sql))
+        .route("/query/build-create-schema-sql", post(routes::query::build_create_schema_sql))
+        .route("/query/build-update-database-properties-sql", post(routes::query::build_update_database_properties_sql))
+        .route("/query/build-drop-schema-sql", post(routes::query::build_drop_schema_sql))
+        .route("/query/build-duplicate-table-structure-sql", post(routes::query::build_duplicate_table_structure_sql))
+        .route("/query/build-copy-table-data-sql", post(routes::query::build_copy_table_data_sql))
+        .route(
+            "/query/build-executable-object-source-statements",
+            post(routes::query::build_executable_object_source_statements),
+        )
+        .route("/query/build-executable-object-source-sql", post(routes::query::build_executable_object_source_sql))
+        .route("/query/build-editable-object-source", post(routes::query::build_editable_object_source))
+        .route(
+            "/query/build-routine-rename-object-source-statements",
+            post(routes::query::build_routine_rename_object_source_statements),
+        )
+        .route("/query/build-view-ddl-sql", post(routes::query::build_view_ddl_sql))
+        .route("/query/build-table-structure-change-sql", post(routes::query::build_table_structure_change_sql))
+        .route(
+            "/query/preview-sqlite-table-structure-change",
+            post(routes::query::preview_sqlite_table_structure_change),
+        )
+        .route("/query/apply-sqlite-table-structure-change", post(routes::query::apply_sqlite_table_structure_change))
+        .route("/query/build-create-table-sql", post(routes::query::build_create_table_sql))
+        .route("/query/build-single-column-alter-sql", post(routes::query::build_single_column_alter_sql))
+        .route("/query/analyze-editability", post(routes::query::analyze_editable_query_editability))
+        .route("/query/prepare-data-grid-save", post(routes::query::prepare_data_grid_save))
+        .route(
+            "/query/build-data-grid-copy-update-statements",
+            post(routes::query::build_data_grid_copy_update_statements),
+        )
+        .route(
+            "/query/build-data-grid-copy-insert-statement",
+            post(routes::query::build_data_grid_copy_insert_statement),
+        )
+        .route(
+            "/query/build-data-grid-context-filter-condition",
+            post(routes::query::build_data_grid_context_filter_condition),
+        )
+        .route(
+            "/query/build-data-grid-column-value-filter-condition",
+            post(routes::query::build_data_grid_column_value_filter_condition),
+        )
+        .route(
+            "/query/build-data-grid-column-values-filter-condition",
+            post(routes::query::build_data_grid_column_values_filter_condition),
+        )
+        .route(
+            "/query/build-data-grid-column-distinct-values-sql",
+            post(routes::query::build_data_grid_column_distinct_values_sql),
+        )
+        .route("/query/build-data-grid-count-sql", post(routes::query::build_data_grid_count_sql))
+        .route("/query/build-hive-table-properties-sql", post(routes::query::build_hive_table_properties_sql))
+        .route("/query/build-export-insert-statements", post(routes::query::build_export_insert_statements))
+        .route("/query/build-export-sql-insert", post(routes::query::build_export_sql_insert))
+        .route("/query/build-database-sql-export", post(routes::query::build_database_sql_export))
+        .route("/data-compare/prepare", post(routes::data_compare::prepare_data_compare))
+        .route("/data-compare/prepare-from-tables", post(routes::data_compare::prepare_data_compare_from_tables))
+        .route("/data-compare/prepare-missing-target", post(routes::data_compare::prepare_data_compare_missing_target))
+        .route("/data-compare/build-sync-plan", post(routes::data_compare::build_data_compare_sync_plan))
+        .route("/query/cancel", post(routes::query::cancel_query))
+        .route("/query/close-session", post(routes::query::close_query_session))
+        .route("/query/close-client-session", post(routes::query::close_client_connection_session))
+        .route("/export/query-result-json", post(routes::text_export::export_query_result_json))
+        .route("/export/query-result-markdown", post(routes::text_export::export_query_result_markdown))
+        // Redis
+        .route("/redis/list-databases", post(routes::redis::list_databases))
+        .route("/redis/scan-keys", post(routes::redis::scan_keys))
+        .route("/redis/scan-keys-batch", post(routes::redis::scan_keys_batch))
+        .route("/redis/scan-values", post(routes::redis::scan_values))
+        .route("/redis/get-value", post(routes::redis::get_value))
+        .route("/redis/load-more", post(routes::redis::load_more))
+        .route("/redis/set-string", post(routes::redis::set_string))
+        .route("/redis/delete-key", post(routes::redis::delete_key))
+        .route("/redis/hash-set", post(routes::redis::hash_set))
+        .route("/redis/hash-del", post(routes::redis::hash_del))
+        .route("/redis/list-push", post(routes::redis::list_push))
+        .route("/redis/list-set", post(routes::redis::list_set))
+        .route("/redis/list-remove", post(routes::redis::list_remove))
+        .route("/redis/set-add", post(routes::redis::set_add))
+        .route("/redis/set-remove", post(routes::redis::set_remove))
+        .route("/redis/zadd", post(routes::redis::zadd))
+        .route("/redis/stream-add", post(routes::redis::stream_add))
+        .route("/redis/json-set", post(routes::redis::json_set))
+        .route("/redis/check-json-module", post(routes::redis::check_json_module))
+        .route("/redis/delete-keys", post(routes::redis::delete_keys))
+        .route("/redis/flush-db", post(routes::redis::flush_db))
+        .route("/redis/execute-command", post(routes::redis::execute_command))
+        .route("/redis/pubsub/publish", post(routes::redis::publish_message))
+        .route("/redis/pubsub/ws", get(routes::redis_pubsub_ws::ws_handler))
+        // Redis Slowlog
+        .route("/redis/slowlog-get", post(routes::redis::slowlog_get))
+        .route("/redis/cluster-master-nodes", post(routes::redis::cluster_master_nodes))
+        // etcd
+        .route("/etcd/list-prefix", post(routes::etcd::list_prefix))
+        .route("/etcd/get", post(routes::etcd::get))
+        .route("/etcd/put", post(routes::etcd::put))
+        .route("/etcd/delete", post(routes::etcd::delete))
+        // ZooKeeper
+        .route("/zookeeper/list-prefix", post(routes::zookeeper::list_prefix))
+        .route("/zookeeper/get", post(routes::zookeeper::get))
+        .route("/zookeeper/put", post(routes::zookeeper::put))
+        .route("/zookeeper/delete", post(routes::zookeeper::delete))
+        // Nacos
+        .route("/nacos/test-connection", post(routes::nacos::test_connection))
+        .route("/nacos/namespaces/list", post(routes::nacos::list_namespaces))
+        .route("/nacos/namespaces/create", post(routes::nacos::create_namespace))
+        .route("/nacos/namespaces/update", post(routes::nacos::update_namespace))
+        .route("/nacos/configs/list", post(routes::nacos::list_configs))
+        .route("/nacos/configs/get", post(routes::nacos::get_config))
+        .route("/nacos/configs/publish", post(routes::nacos::publish_config))
+        .route("/nacos/configs/delete", post(routes::nacos::delete_config))
+        .route("/nacos/configs/history/list", post(routes::nacos::list_config_history))
+        .route("/nacos/configs/history/get", post(routes::nacos::get_config_history))
+        .route("/nacos/configs/history/rollback", post(routes::nacos::rollback_config))
+        .route("/nacos/services/list", post(routes::nacos::list_services))
+        .route("/nacos/instances/list", post(routes::nacos::list_instances))
+        .route("/nacos/instances/update", post(routes::nacos::update_instance))
+        .route("/nacos/raw", post(routes::nacos::raw_request))
+        // MongoDB
+        .route("/mongo/list-databases", post(routes::mongo::list_databases))
+        .route("/mongo/list-collections", post(routes::mongo::list_collections))
+        .route("/mongo/vector-collection-detail", post(routes::mongo::vector_collection_detail))
+        .route("/mongo/create-database", post(routes::mongo::create_database))
+        .route("/mongo/drop-database", post(routes::mongo::drop_database))
+        .route("/mongo/drop-collection", post(routes::mongo::drop_collection))
+        .route("/document-store/list-databases", post(routes::document_store::list_databases))
+        .route("/document-store/list-collections", post(routes::document_store::list_collections))
+        .route("/document-store/find-documents", post(routes::document_store::find_documents))
+        .route("/document-store/list-gridfs-buckets", post(routes::document_store::list_gridfs_buckets))
+        .route("/document-store/create-gridfs-bucket", post(routes::document_store::create_gridfs_bucket))
+        .route("/document-store/delete-gridfs-bucket", post(routes::document_store::delete_gridfs_bucket))
+        .route("/document-store/list-gridfs-files", post(routes::document_store::list_gridfs_files))
+        .route("/document-store/download-gridfs-file", post(routes::document_store::download_gridfs_file))
+        .route("/document-store/upload-gridfs-file", post(routes::document_store::upload_gridfs_file))
+        .route("/document-store/delete-gridfs-file", post(routes::document_store::delete_gridfs_file))
+        .route("/document-store/insert-document", post(routes::document_store::insert_document))
+        .route("/document-store/update-document", post(routes::document_store::update_document))
+        .route("/document-store/delete-document", post(routes::document_store::delete_document))
+        .route("/mongo/find-documents", post(routes::mongo::find_documents))
+        .route("/mongo/server-version", post(routes::mongo::server_version))
+        .route("/mongo/collection-stats", post(routes::mongo::collection_stats))
+        .route("/mongo/aggregate-documents", post(routes::mongo::aggregate_documents))
+        .route("/mongo/create-index", post(routes::mongo::create_index))
+        .route("/mongo/drop-indexes", post(routes::mongo::drop_indexes))
+        .route("/mongo/insert-document", post(routes::mongo::insert_document))
+        .route("/mongo/insert-documents", post(routes::mongo::insert_documents))
+        .route("/mongo/update-document", post(routes::mongo::update_document))
+        .route("/mongo/update-documents", post(routes::mongo::update_documents))
+        .route("/mongo/delete-document", post(routes::mongo::delete_document))
+        .route("/mongo/delete-documents", post(routes::mongo::delete_documents))
+        // History
+        .route("/history", get(routes::history::load_history).delete(routes::history::clear_history))
+        .route("/history/save", post(routes::history::save_history))
+        .route("/history/{id}", delete(routes::history::delete_history_entry))
+        // Saved SQL
+        .route(
+            "/saved-sql",
+            get(routes::saved_sql::load_saved_sql_library).post(routes::saved_sql::save_saved_sql_file),
+        )
+        .route(
+            "/saved-sql/{id}",
+            get(routes::saved_sql::load_saved_sql_file).delete(routes::saved_sql::delete_saved_sql_file),
+        )
+        .route("/saved-sql/folders", post(routes::saved_sql::save_saved_sql_folder))
+        .route("/saved-sql/folders/{id}", delete(routes::saved_sql::delete_saved_sql_folder))
+        // AI
+        .route("/ai/config", post(routes::ai::save_ai_config).get(routes::ai::load_ai_config))
+        .route("/ai/provider-config", post(routes::ai::save_ai_provider_config))
+        .route("/ai/provider-configs", get(routes::ai::load_ai_provider_configs))
+        .route("/ai/conversation", post(routes::ai::save_ai_conversation))
+        .route("/ai/conversations", get(routes::ai::load_ai_conversations))
+        .route("/ai/conversation/{id}", delete(routes::ai::delete_ai_conversation))
+        .route("/ai/complete", post(routes::ai::ai_complete))
+        .route("/ai/stream", post(routes::ai::ai_stream))
+        .route("/ai/agent-stream", post(routes::ai::ai_agent_stream))
+        .route("/ai/cancel-stream", post(routes::ai::ai_cancel_stream))
+        .route("/ai/test-connection", post(routes::ai::ai_test_connection))
+        .route("/ai/models", post(routes::ai::ai_list_models))
+        // Transfer
+        .route("/transfer/start", post(routes::transfer::start_transfer))
+        .route("/transfer/ownership-preview", post(routes::transfer::preview_transfer_ownership))
+        .route("/transfer/progress/{transferId}", get(routes::transfer::transfer_progress))
+        .route("/transfer/cancel", post(routes::transfer::cancel_transfer))
+        .route("/transfer/sort-tables-by-fk", post(routes::transfer::sort_tables_by_fk_dependency))
+        // Database export
+        .route("/export/database", post(routes::database_export::start_database_export))
+        .route("/export/database/progress/{exportId}", get(routes::database_export::database_export_progress))
+        .route("/export/database/cancel", post(routes::database_export::cancel_database_export))
+        .route("/export/database/download/{exportId}", get(routes::database_export::database_export_download))
+        // Table export
+        .route("/export/table", post(routes::table_export::start_table_export))
+        .route("/export/table/progress/{exportId}", get(routes::table_export::table_export_progress))
+        .route("/export/table/download/{exportId}", get(routes::table_export::table_export_download))
+        .route("/export/table/cancel", post(routes::table_export::cancel_table_export))
+        // Query result export
+        .route("/export/query-result", post(routes::query_result_export::start_query_result_export))
+        .route(
+            "/export/query-result/progress/{exportId}",
+            get(routes::query_result_export::query_result_export_progress),
+        )
+        .route(
+            "/export/query-result/download/{exportId}",
+            get(routes::query_result_export::query_result_export_download),
+        )
+        .route("/export/query-result/cancel", post(routes::query_result_export::cancel_query_result_export))
+        // SQL file
+        .route("/sql-file/preview", post(routes::sql_file::preview_sql_file))
+        .route("/sql-file/execute", post(routes::sql_file::execute_sql_file))
+        .route("/sql-file/progress/{executionId}", get(routes::sql_file::sql_file_progress))
+        .route("/sql-file/cancel", post(routes::sql_file::cancel_sql_file))
+        // Table import
+        .route("/import/preview", post(routes::table_import::preview_import))
+        .route("/import/execute", post(routes::table_import::execute_import))
+        .route("/import/progress/{importId}", get(routes::table_import::import_progress))
+        .route("/import/cancel", post(routes::table_import::cancel_import))
+        // Update
+        .route("/version", get(routes::update::get_version))
+        .route("/update/check", get(routes::update::check_for_updates))
+        // Layout
+        .route("/layout/sidebar", post(routes::layout::save_sidebar_layout).get(routes::layout::load_sidebar_layout))
+        // App settings
+        .route(
+            "/app-settings/pinned-tree-node-ids",
+            get(routes::app_settings::load_pinned_tree_node_ids).post(routes::app_settings::save_pinned_tree_node_ids),
+        )
+        .route("/app-settings/config/decrypt", post(routes::app_settings::decrypt_config))
+        // Cloud sync
+        .route("/cloud-sync/webdav/test", post(routes::cloud_sync::webdav_sync_test))
+        .route("/cloud-sync/webdav/password-status", post(routes::cloud_sync::webdav_password_status))
+        .route("/cloud-sync/webdav/save-password", post(routes::cloud_sync::save_webdav_saved_password))
+        .route("/cloud-sync/webdav/forget-password", post(routes::cloud_sync::forget_webdav_saved_password))
+        .route("/cloud-sync/webdav/sync-secrets-status", post(routes::cloud_sync::webdav_sync_secrets_status))
+        .route(
+            "/cloud-sync/webdav/save-sync-secrets-preference",
+            post(routes::cloud_sync::save_webdav_sync_secrets_preference),
+        )
+        .route(
+            "/cloud-sync/webdav/forget-sync-secrets-passphrase",
+            post(routes::cloud_sync::forget_webdav_sync_secrets_passphrase),
+        )
+        .route("/cloud-sync/webdav/upload", post(routes::cloud_sync::webdav_sync_upload))
+        .route("/cloud-sync/webdav/download", post(routes::cloud_sync::webdav_sync_download))
+        .route("/cloud-sync/snippet/test", post(routes::cloud_sync::snippet_sync_test))
+        .route("/cloud-sync/snippet/token-status", post(routes::cloud_sync::snippet_token_status))
+        .route("/cloud-sync/snippet/save-token", post(routes::cloud_sync::save_snippet_saved_token))
+        .route("/cloud-sync/snippet/forget-token", post(routes::cloud_sync::forget_snippet_saved_token))
+        .route("/cloud-sync/snippet/upload", post(routes::cloud_sync::snippet_sync_upload))
+        .route("/cloud-sync/snippet/download", post(routes::cloud_sync::snippet_sync_download));
+
+    let api = add_mq_routes(api)
+        .layer(middleware::from_fn_with_state(web_state.clone(), auth::auth_middleware))
+        .with_state(web_state.clone());
+
+    // Build app
+    let mut app = Router::new()
+        .nest("/api", api)
+        .layer(DefaultBodyLimit::max(web_body_limit_bytes()))
+        .layer(tower_http::trace::TraceLayer::new_for_http());
+
+    // Static file serving
+    if let Ok(static_dir) = std::env::var("DBX_STATIC_DIR") {
+        use tower_http::services::{ServeDir, ServeFile};
+        let index_path = format!("{}/index.html", static_dir);
+        let serve_dir = ServeDir::new(&static_dir).not_found_service(ServeFile::new(&index_path));
+        app = app.fallback_service(serve_dir);
+    }
+
+    if public_base_path != "/" {
+        app = Router::new().nest(&public_base_path, app);
+    }
+
+    // Bind address
+    let port: u16 = std::env::var("DBX_PORT").ok().and_then(|p| p.parse().ok()).unwrap_or(4224);
+    let addr = SocketAddr::from(([0, 0, 0, 0], port));
+
+    tracing::info!("DBX Web server starting on http://{}", addr);
+    if public_base_path != "/" {
+        tracing::info!("Serving DBX Web under context path {}", public_base_path);
+    }
+    if password_disabled {
+        tracing::info!("Password protection is disabled");
+    } else if std::env::var("DBX_PASSWORD").is_ok() {
+        tracing::info!("Password protection is enabled");
+    }
+
+    let listener = tokio::net::TcpListener::bind(addr).await.expect("Failed to bind address");
+    axum::serve(listener, app).await.expect("Server error");
+}
diff --git a/crates/dbx-web/src/routes/agents.rs b/crates/dbx-web/src/routes/agents.rs
new file mode 100644
index 0000000..d110f51
--- /dev/null
+++ b/crates/dbx-web/src/routes/agents.rs
@@ -0,0 +1,304 @@
+use std::sync::Arc;
+
+use axum::extract::{Multipart, Path, State};
+use axum::response::sse::{Event, Sse};
+use axum::Json;
+use dbx_core::agent_manager::{
+    AgentDriverInfo, AgentState, DriverStoreUsage, JavaRuntimeConfig, JavaRuntimeMode, DEFAULT_JRE_KEY,
+};
+use dbx_core::agent_service::{
+    build_agent_list, clear_agent_download_cache, fetch_registry,
+    import_agents_from_zip as import_agents_from_zip_core, install_agent_driver, invalidate_registry_cache,
+    reinstall_agent_jre, uninstall_agent_driver, uninstall_agent_jre, upgrade_all_agent_drivers, AgentProgressEvent,
+};
+use dbx_core::driver_runtime::DriverRuntimeSummary;
+use futures::Stream;
+use serde::Deserialize;
+use tokio::io::AsyncWriteExt;
+use tokio::sync::broadcast;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AgentTypeRequest {
+    pub db_type: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct JreRequest {
+    pub jre_key: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct JavaRuntimeRequest {
+    pub config: JavaRuntimeConfig,
+}
+
+pub async fn list_installed_agents_local(
+    State(state): State<Arc<WebState>>,
+) -> Result<Json<Vec<AgentDriverInfo>>, AppError> {
+    Ok(Json(build_agent_list(&state.app.agent_manager, None)))
+}
+
+pub async fn list_installed_agents(State(state): State<Arc<WebState>>) -> Result<Json<Vec<AgentDriverInfo>>, AppError> {
+    let registry = fetch_registry().await.ok();
+    Ok(Json(build_agent_list(&state.app.agent_manager, registry.as_ref())))
+}
+
+pub async fn is_agent_installed(
+    State(state): State<Arc<WebState>>,
+    Path(db_type): Path<String>,
+) -> Result<Json<bool>, AppError> {
+    Ok(Json(state.app.agent_manager.is_driver_installed(&db_type)))
+}
+
+pub async fn get_driver_store_usage(State(state): State<Arc<WebState>>) -> Result<Json<DriverStoreUsage>, AppError> {
+    Ok(Json(state.app.agent_manager.collect_driver_store_usage(state.app.plugins.root_dir())))
+}
+
+pub async fn clear_driver_download_cache(
+    State(state): State<Arc<WebState>>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    clear_agent_download_cache(&state.app.agent_manager).map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "ok": true })))
+}
+
+pub async fn get_driver_runtime_summary(
+    State(state): State<Arc<WebState>>,
+) -> Result<Json<DriverRuntimeSummary>, AppError> {
+    Ok(Json(dbx_core::driver_runtime::collect_driver_runtime_summary(&state.app).await))
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DriverRuntimeRequest {
+    pub runtime_id: String,
+}
+
+pub async fn stop_driver_runtime(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DriverRuntimeRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    dbx_core::driver_runtime::stop_driver_runtime(&state.app, &req.runtime_id).await.map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "ok": true })))
+}
+
+pub async fn restart_driver_runtime(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DriverRuntimeRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    dbx_core::driver_runtime::restart_driver_runtime(&state.app, &req.runtime_id).await.map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "ok": true })))
+}
+
+pub async fn install_agent(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<AgentTypeRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    ensure_no_agent_update_blockers(&state.app, std::slice::from_ref(&req.db_type)).await.map_err(AppError)?;
+    let tx = progress_sender(&state, "global").await;
+    install_agent_driver(&state.app.agent_manager, &req.db_type, |event| send_progress_event(&tx, event))
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "ok": true })))
+}
+
+pub async fn upgrade_all_agents(State(state): State<Arc<WebState>>) -> Result<Json<serde_json::Value>, AppError> {
+    let registry = fetch_registry().await.map_err(AppError)?;
+    let agents = build_agent_list(&state.app.agent_manager, Some(&registry));
+    let updatable: Vec<String> =
+        agents.iter().filter(|agent| agent.update_available).map(|agent| agent.db_type.clone()).collect();
+    ensure_no_agent_update_blockers(&state.app, &updatable).await.map_err(AppError)?;
+    let tx = progress_sender(&state, "global").await;
+    let result = upgrade_all_agent_drivers(&state.app.agent_manager, |event| send_progress_event(&tx, event))
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|err| AppError(err.to_string()))?))
+}
+
+pub async fn uninstall_agent(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<AgentTypeRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    uninstall_agent_driver(&state.app.agent_manager, &req.db_type).await.map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "ok": true })))
+}
+
+pub async fn get_agent_java_runtime_config(
+    State(state): State<Arc<WebState>>,
+) -> Result<Json<JavaRuntimeConfig>, AppError> {
+    Ok(Json(state.app.agent_manager.load_state().java_runtime))
+}
+
+pub async fn set_agent_java_runtime_config(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<JavaRuntimeRequest>,
+) -> Result<Json<JavaRuntimeConfig>, AppError> {
+    let am = &state.app.agent_manager;
+    let mut config = req.config;
+    if config.mode == JavaRuntimeMode::Custom || config.mode == JavaRuntimeMode::System {
+        let candidate_state = AgentState { java_runtime: config.clone(), ..am.load_state() };
+        let resolved = am.resolve_java_runtime(&candidate_state, DEFAULT_JRE_KEY).map_err(AppError)?;
+        if config.mode == JavaRuntimeMode::Custom {
+            config.custom_java_path = Some(resolved.to_string_lossy().to_string());
+        }
+    }
+    if config.mode != JavaRuntimeMode::Custom {
+        config.custom_java_path = None;
+    }
+
+    let mut local_state = am.load_state();
+    local_state.java_runtime = config.clone();
+    am.save_state(&local_state).map_err(AppError)?;
+    am.stop_daemons().await;
+    Ok(Json(config))
+}
+
+pub async fn invalidate_agent_registry_cache() -> Result<Json<serde_json::Value>, AppError> {
+    invalidate_registry_cache().await;
+    Ok(Json(serde_json::json!({ "ok": true })))
+}
+
+pub async fn import_agents_from_zip(
+    State(state): State<Arc<WebState>>,
+    mut multipart: Multipart,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let tmp_dir = state.data_dir.join("tmp");
+    std::fs::create_dir_all(&tmp_dir).map_err(|err| AppError(err.to_string()))?;
+
+    if let Some(field) = multipart.next_field().await.map_err(|err| AppError(err.to_string()))? {
+        let file_name = field.file_name().unwrap_or("offline-drivers.zip").to_string();
+        if !file_name.to_ascii_lowercase().ends_with(".zip") {
+            return Err(AppError("Offline driver package must be a .zip file".to_string()));
+        }
+
+        let zip_path = tmp_dir.join(format!("agent-offline-{}.zip", uuid::Uuid::new_v4()));
+        let mut upload = tokio::fs::File::create(&zip_path).await.map_err(|err| AppError(err.to_string()))?;
+        let mut field = field;
+        while let Some(chunk) = field.chunk().await.map_err(|err| AppError(err.to_string()))? {
+            upload.write_all(&chunk).await.map_err(|err| AppError(err.to_string()))?;
+        }
+        upload.flush().await.map_err(|err| AppError(err.to_string()))?;
+        drop(upload);
+
+        let tx = progress_sender(&state, "global").await;
+        let result =
+            import_agents_from_zip_core(&state.app.agent_manager, &zip_path, |event| send_progress_event(&tx, event))
+                .map_err(AppError);
+        let _ = std::fs::remove_file(&zip_path);
+
+        let result = result?;
+        send_progress_event(&tx, AgentProgressEvent::step("done"));
+        return Ok(Json(serde_json::json!({ "count": result.drivers_installed.len() as u32 })));
+    }
+
+    Err(AppError("No file uploaded".to_string()))
+}
+
+pub async fn import_agent_jar(
+    State(state): State<Arc<WebState>>,
+    mut multipart: Multipart,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let mut db_type: Option<String> = None;
+    let mut jar_data: Option<Vec<u8>> = None;
+    let mut jar_name = String::new();
+
+    while let Ok(Some(field)) = multipart.next_field().await {
+        let name = field.name().unwrap_or("").to_string();
+        if name == "dbType" {
+            db_type = Some(field.text().await.map_err(|e| AppError(e.to_string()))?);
+        } else if name == "file" {
+            jar_name = field.file_name().unwrap_or("driver.jar").to_string();
+            if !jar_name.to_lowercase().ends_with(".jar") {
+                return Err(AppError("Only .jar files can be imported".to_string()));
+            }
+            jar_data = Some(field.bytes().await.map_err(|e| AppError(e.to_string()))?.to_vec());
+        }
+    }
+
+    let db_type = db_type.ok_or_else(|| AppError("Missing dbType field".to_string()))?;
+    let data = jar_data.ok_or_else(|| AppError("No file uploaded".to_string()))?;
+
+    let temp_dir = state.app.plugins.root_dir().join("jar_upload_tmp");
+    std::fs::create_dir_all(&temp_dir).map_err(|e| AppError(e.to_string()))?;
+    let tmp_path = temp_dir.join(&jar_name);
+    std::fs::write(&tmp_path, &data).map_err(|e| AppError(e.to_string()))?;
+
+    dbx_core::agent_service::import_agent_jar(&state.app.agent_manager, &db_type, &tmp_path).map_err(AppError::from)?;
+    let _ = std::fs::remove_file(&tmp_path);
+    Ok(Json(serde_json::json!({ "success": true })))
+}
+
+pub async fn reinstall_jre(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<JreRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let tx = progress_sender(&state, "global").await;
+    reinstall_agent_jre(&state.app.agent_manager, req.jre_key.as_deref().unwrap_or(DEFAULT_JRE_KEY), |event| {
+        send_progress_event(&tx, event);
+    })
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "ok": true })))
+}
+
+pub async fn uninstall_jre(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<JreRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let key = req.jre_key.as_deref().unwrap_or(DEFAULT_JRE_KEY);
+    uninstall_agent_jre(&state.app.agent_manager, key).await.map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "ok": true })))
+}
+
+pub async fn agent_progress(
+    State(state): State<Arc<WebState>>,
+    Path(operation_id): Path<String>,
+) -> Result<Sse<impl Stream<Item = Result<Event, std::convert::Infallible>>>, AppError> {
+    let tx = progress_sender(&state, &operation_id).await;
+    Ok(crate::sse::sse_from_channel(tx.subscribe()))
+}
+
+async fn progress_sender(state: &WebState, operation_id: &str) -> broadcast::Sender<String> {
+    let mut channels = state.sse_channels.write().await;
+    channels
+        .entry(format!("agent-install-progress:{operation_id}"))
+        .or_insert_with(|| {
+            let (tx, _) = broadcast::channel::<String>(256);
+            tx
+        })
+        .clone()
+}
+
+fn send_progress_event(tx: &broadcast::Sender<String>, event: AgentProgressEvent) {
+    if let Ok(payload) = serde_json::to_string(&event) {
+        let _ = tx.send(payload);
+    }
+}
+
+async fn ensure_no_agent_update_blockers(
+    state: &dbx_core::connection::AppState,
+    db_types: &[String],
+) -> Result<(), String> {
+    let candidate_keys: std::collections::HashSet<&str> = db_types.iter().map(String::as_str).collect();
+    if candidate_keys.is_empty() {
+        return Ok(());
+    }
+    let mut blockers = state
+        .active_agent_driver_keys()
+        .await
+        .into_iter()
+        .filter(|key| candidate_keys.contains(key.as_str()))
+        .map(|key| dbx_core::agent_catalog::label_for_key(&key).unwrap_or(&key).to_string())
+        .collect::<Vec<_>>();
+    blockers.sort();
+    if blockers.is_empty() {
+        Ok(())
+    } else {
+        Err(format!("请先关闭以下数据库连接后再更新驱动: {}", blockers.join(", ")))
+    }
+}
diff --git a/crates/dbx-web/src/routes/ai.rs b/crates/dbx-web/src/routes/ai.rs
new file mode 100644
index 0000000..17b87a5
--- /dev/null
+++ b/crates/dbx-web/src/routes/ai.rs
@@ -0,0 +1,328 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use axum::extract::{Path, State};
+use axum::response::sse::{Event, KeepAlive, Sse};
+use axum::Json;
+use futures::stream::Stream;
+use serde::Deserialize;
+
+use dbx_core::agent_events::AgentEvent;
+use dbx_core::agent_loop::{run_agent_loop, AgentLoopContext};
+use dbx_core::ai::{
+    AiCompletionRequest, AiConfig, AiConversation, AiModelInfo, AiProvider, AiStreamChunk, AiTestConnectionResult,
+};
+use dbx_core::models::connection::DatabaseType;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+// ---------------------------------------------------------------------------
+// Request types
+// ---------------------------------------------------------------------------
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveAiProviderConfigRequest {
+    pub provider: String,
+    pub config: AiConfig,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveAiConfigRequest {
+    pub config: AiConfig,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveAiConversationRequest {
+    pub conversation: AiConversation,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiCompleteRequest {
+    pub request: AiCompletionRequest,
+}
+
+#[derive(Deserialize)]
+pub struct AiStreamRequest {
+    #[serde(alias = "sessionId")]
+    pub session_id: String,
+    pub request: AiCompletionRequest,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiTestConnectionRequest {
+    pub config: AiConfig,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiListModelsRequest {
+    pub config: AiConfig,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiCancelStreamRequest {
+    pub session_id: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AiAgentStreamRequest {
+    pub session_id: String,
+    pub request: AiCompletionRequest,
+    pub connection_id: String,
+    pub database: String,
+    pub db_type: String,
+    /// Agent mode: "ask" (read-only tools) or "agent" (all tools including execute_query).
+    /// Defaults to "ask" if not provided.
+    #[serde(default = "default_agent_mode")]
+    pub mode: String,
+    #[serde(default)]
+    pub allow_write_sql: bool,
+}
+
+fn default_agent_mode() -> String {
+    "ask".to_string()
+}
+
+fn reject_web_unsupported_ai_provider(config: &AiConfig) -> Result<(), AppError> {
+    if matches!(config.provider, AiProvider::CodexCli) {
+        return Err(AppError::bad_request("Codex CLI provider is only supported in DBX Desktop."));
+    }
+    Ok(())
+}
+
+fn ai_provider_from_key(provider: &str) -> Result<AiProvider, AppError> {
+    serde_json::from_value(serde_json::Value::String(provider.to_string()))
+        .map_err(|_| AppError::bad_request(format!("Invalid AI provider: {provider}")))
+}
+
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+
+pub async fn save_ai_config(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<SaveAiConfigRequest>,
+) -> Result<Json<()>, AppError> {
+    reject_web_unsupported_ai_provider(&body.config)?;
+    state.app.storage.save_ai_config(&body.config).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn load_ai_config(State(state): State<Arc<WebState>>) -> Result<Json<Option<AiConfig>>, AppError> {
+    let config = state.app.storage.load_ai_config().await.map_err(AppError)?;
+    Ok(Json(config))
+}
+
+pub async fn save_ai_provider_config(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<SaveAiProviderConfigRequest>,
+) -> Result<Json<()>, AppError> {
+    let parsed_provider = ai_provider_from_key(&body.provider)?;
+    let mut config = body.config;
+    config.provider = parsed_provider;
+    reject_web_unsupported_ai_provider(&config)?;
+    state.app.storage.save_ai_provider_config(&body.provider, &config).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn load_ai_provider_configs(
+    State(state): State<Arc<WebState>>,
+) -> Result<Json<HashMap<String, AiConfig>>, AppError> {
+    let configs = state.app.storage.load_ai_provider_configs().await.map_err(AppError)?;
+    Ok(Json(configs))
+}
+
+// ---------------------------------------------------------------------------
+// Conversations
+// ---------------------------------------------------------------------------
+
+pub async fn save_ai_conversation(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<SaveAiConversationRequest>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.save_ai_conversation(&body.conversation).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn load_ai_conversations(State(state): State<Arc<WebState>>) -> Result<Json<Vec<AiConversation>>, AppError> {
+    let conversations = state.app.storage.load_ai_conversations().await.map_err(AppError)?;
+    Ok(Json(conversations))
+}
+
+pub async fn delete_ai_conversation(
+    State(state): State<Arc<WebState>>,
+    Path(id): Path<String>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.delete_ai_conversation(&id).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+// ---------------------------------------------------------------------------
+// AI complete (non-streaming)
+// ---------------------------------------------------------------------------
+
+pub async fn ai_complete(Json(body): Json<AiCompleteRequest>) -> Result<Json<String>, AppError> {
+    reject_web_unsupported_ai_provider(&body.request.config)?;
+    let result = dbx_core::ai::complete(&body.request).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+// ---------------------------------------------------------------------------
+// AI test connection
+// ---------------------------------------------------------------------------
+
+pub async fn ai_test_connection(
+    Json(body): Json<AiTestConnectionRequest>,
+) -> Result<Json<AiTestConnectionResult>, AppError> {
+    reject_web_unsupported_ai_provider(&body.config)?;
+    let result = dbx_core::ai::test_connection_core(&body.config).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn ai_list_models(Json(body): Json<AiListModelsRequest>) -> Result<Json<Vec<AiModelInfo>>, AppError> {
+    reject_web_unsupported_ai_provider(&body.config)?;
+    let result = dbx_core::ai::list_models_core(&body.config).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+// ---------------------------------------------------------------------------
+// AI cancel stream
+// ---------------------------------------------------------------------------
+
+pub async fn ai_cancel_stream(Json(body): Json<AiCancelStreamRequest>) -> Result<Json<bool>, AppError> {
+    let result = dbx_core::ai::cancel_stream(&body.session_id).await;
+    Ok(Json(result))
+}
+
+// ---------------------------------------------------------------------------
+// AI stream (POST returns SSE directly)
+// ---------------------------------------------------------------------------
+
+pub async fn ai_stream(
+    Json(body): Json<AiStreamRequest>,
+) -> Result<Sse<impl Stream<Item = Result<Event, std::convert::Infallible>>>, AppError> {
+    let session_id = body.session_id;
+    let request = body.request;
+    reject_web_unsupported_ai_provider(&request.config)?;
+
+    let cancelled = dbx_core::ai::register_stream(&session_id).await;
+    let (tx, rx) = tokio::sync::broadcast::channel::<String>(256);
+
+    let sid = session_id.clone();
+    tokio::spawn(async move {
+        let result = dbx_core::ai::stream(&sid, &request, &cancelled, |chunk: AiStreamChunk| {
+            let json = serde_json::to_string(&chunk).unwrap_or_default();
+            let _ = tx.send(json);
+        })
+        .await;
+
+        if let Err(_e) = result {
+            let error_chunk =
+                AiStreamChunk { session_id: sid.clone(), delta: String::new(), reasoning_delta: None, done: true };
+            let _ = tx.send(serde_json::to_string(&error_chunk).unwrap_or_default());
+        }
+
+        dbx_core::ai::unregister_stream(&sid).await;
+    });
+
+    let stream = async_stream::stream! {
+        let mut rx = rx;
+        while let Ok(data) = rx.recv().await {
+            yield Ok(Event::default().data(data));
+        }
+    };
+
+    Ok(Sse::new(stream).keep_alive(KeepAlive::default()))
+}
+
+// ---------------------------------------------------------------------------
+// AI agent stream (POST returns SSE with AgentEvent)
+// ---------------------------------------------------------------------------
+
+pub async fn ai_agent_stream(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<AiAgentStreamRequest>,
+) -> Result<Sse<impl Stream<Item = Result<Event, std::convert::Infallible>>>, AppError> {
+    let session_id = body.session_id;
+    let request = body.request;
+    reject_web_unsupported_ai_provider(&request.config)?;
+
+    let cancelled = dbx_core::ai::register_stream(&session_id).await;
+    let (tx, rx) = tokio::sync::broadcast::channel::<String>(256);
+
+    let parsed_db_type: DatabaseType = serde_json::from_str(&format!("\"{}\"", body.db_type))
+        .map_err(|_| AppError(format!("Unknown database type: {}", body.db_type)))?;
+    let production_database = state
+        .app
+        .configs
+        .read()
+        .await
+        .get(&body.connection_id)
+        .is_some_and(|config| dbx_core::production_safety::is_production_database(config, &body.database));
+
+    let agent_ctx = AgentLoopContext {
+        state: state.app.clone(),
+        connection_id: body.connection_id,
+        database: body.database,
+        db_type: parsed_db_type,
+        cli_mcp_server_command: None,
+        sql_permissions: dbx_core::agent_tools::AgentSqlPermissions {
+            allow_writes: !production_database && body.allow_write_sql,
+            allow_dangerous: !production_database && body.allow_write_sql,
+        },
+    };
+
+    let sid = session_id.clone();
+    let req_config = request.config;
+    let req_system_prompt = request.system_prompt;
+    let req_messages = request.messages;
+    let req_task_contract = request.task_contract;
+    let req_max_tokens = request.max_tokens;
+    let is_agent_mode = body.mode == "agent";
+    let tx2 = tx.clone();
+    tokio::task::spawn_blocking(move || {
+        let rt =
+            tokio::runtime::Builder::new_current_thread().enable_all().build().expect("failed to create agent runtime");
+        rt.block_on(async move {
+            let result = run_agent_loop(
+                &req_config,
+                &req_system_prompt,
+                &req_messages,
+                &agent_ctx,
+                move |event: AgentEvent| {
+                    let json = serde_json::to_string(&event).unwrap_or_default();
+                    let _ = tx2.send(json);
+                },
+                &cancelled,
+                req_max_tokens,
+                req_task_contract.as_ref(),
+                is_agent_mode,
+            )
+            .await;
+
+            if let Err(e) = result {
+                let error_event = AgentEvent::Error { message: e };
+                let _ = tx.send(serde_json::to_string(&error_event).unwrap_or_default());
+            }
+
+            dbx_core::ai::unregister_stream(&sid).await;
+        });
+    });
+
+    let stream = async_stream::stream! {
+        let mut rx = rx;
+        while let Ok(data) = rx.recv().await {
+            yield Ok(Event::default().data(data));
+        }
+    };
+
+    Ok(Sse::new(stream).keep_alive(KeepAlive::default()))
+}
diff --git a/crates/dbx-web/src/routes/app_settings.rs b/crates/dbx-web/src/routes/app_settings.rs
new file mode 100644
index 0000000..2bc2abe
--- /dev/null
+++ b/crates/dbx-web/src/routes/app_settings.rs
@@ -0,0 +1,103 @@
+use std::sync::Arc;
+
+use aes_gcm::aead::Aead;
+use aes_gcm::{Aes256Gcm, KeyInit, Nonce};
+use axum::extract::State;
+use axum::Json;
+use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
+use pbkdf2::pbkdf2_hmac;
+use serde::Deserialize;
+use sha2::Sha256;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+const CONFIG_PBKDF2_ITERATIONS: u32 = 100_000;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SavePinnedTreeNodeIdsRequest {
+    pub ids: Vec<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EncryptedConfigPayload {
+    pub format: String,
+    pub version: u8,
+    pub salt: String,
+    pub iv: String,
+    pub data: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DecryptConfigRequest {
+    pub payload: EncryptedConfigPayload,
+    pub passphrase: String,
+}
+
+pub async fn load_pinned_tree_node_ids(State(state): State<Arc<WebState>>) -> Result<Json<Vec<String>>, AppError> {
+    let ids = state.app.storage.load_pinned_tree_node_ids().await.map_err(AppError)?;
+    Ok(Json(ids))
+}
+
+pub async fn save_pinned_tree_node_ids(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<SavePinnedTreeNodeIdsRequest>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.save_pinned_tree_node_ids(&body.ids).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn decrypt_config(Json(body): Json<DecryptConfigRequest>) -> Result<Json<String>, AppError> {
+    decrypt_config_payload(&body.payload, &body.passphrase).map(Json).map_err(AppError)
+}
+
+fn decrypt_config_payload(payload: &EncryptedConfigPayload, passphrase: &str) -> Result<String, String> {
+    if payload.format != "dbx-encrypted" || payload.version != 1 {
+        return Err("Unsupported encrypted config format".to_string());
+    }
+    let salt = BASE64.decode(&payload.salt).map_err(|_| "wrong_passphrase".to_string())?;
+    let iv = BASE64.decode(&payload.iv).map_err(|_| "wrong_passphrase".to_string())?;
+    let ciphertext = BASE64.decode(&payload.data).map_err(|_| "wrong_passphrase".to_string())?;
+    if iv.len() != 12 {
+        return Err("wrong_passphrase".to_string());
+    }
+
+    let mut key = [0u8; 32];
+    pbkdf2_hmac::<Sha256>(passphrase.as_bytes(), &salt, CONFIG_PBKDF2_ITERATIONS, &mut key);
+    let cipher = Aes256Gcm::new_from_slice(&key).map_err(|_| "wrong_passphrase".to_string())?;
+    let plaintext =
+        cipher.decrypt(Nonce::from_slice(&iv), ciphertext.as_ref()).map_err(|_| "wrong_passphrase".to_string())?;
+    String::from_utf8(plaintext).map_err(|_| "wrong_passphrase".to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{decrypt_config_payload, EncryptedConfigPayload};
+
+    fn exported_browser_payload() -> EncryptedConfigPayload {
+        EncryptedConfigPayload {
+            format: "dbx-encrypted".to_string(),
+            version: 1,
+            salt: "AAECAwQFBgcICQoLDA0ODw==".to_string(),
+            iv: "EBESExQVFhcYGRob".to_string(),
+            data: "sCyBTex9XqcCCH5mOyJcF/UN9kpnMp+t0VeEtGrJBMt+QyR85kYhUWezuC9yEhM5jF0=".to_string(),
+        }
+    }
+
+    #[test]
+    fn decrypts_browser_exported_config_payload() {
+        let plaintext = decrypt_config_payload(&exported_browser_payload(), "passphrase").unwrap();
+
+        assert_eq!(plaintext, r#"{"connections":[{"name":"local"}]}"#);
+    }
+
+    #[test]
+    fn rejects_wrong_config_passphrase() {
+        let error = decrypt_config_payload(&exported_browser_payload(), "wrong").unwrap_err();
+
+        assert_eq!(error, "wrong_passphrase");
+    }
+}
diff --git a/crates/dbx-web/src/routes/cloud_sync.rs b/crates/dbx-web/src/routes/cloud_sync.rs
new file mode 100644
index 0000000..c7b42cc
--- /dev/null
+++ b/crates/dbx-web/src/routes/cloud_sync.rs
@@ -0,0 +1,270 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+use dbx_core::cloud_sync::{
+    apply_sync_snapshot, build_sync_snapshot_with_saved_secrets, forget_snippet_token, forget_webdav_password,
+    forget_webdav_sync_secrets_passphrase as core_forget_webdav_sync_secrets_passphrase, resolve_snippet_token,
+    resolve_webdav_password, resolve_webdav_sync_secrets_passphrase, save_snippet_token, save_webdav_password,
+    save_webdav_sync_secrets_preference as core_save_webdav_sync_secrets_preference, snippet_saved_token_status,
+    webdav_saved_password_status, webdav_sync_secrets_status as core_webdav_sync_secrets_status, ApplySnapshotOptions,
+    ApplySnapshotSummary, SnippetSyncClient, SnippetSyncConfig, SnippetSyncSummary, SnippetTokenStatus, WebDavClient,
+    WebDavConfig, WebDavPasswordStatus, WebDavSyncSecretsStatus, WebDavSyncSummary,
+};
+use dbx_core::storage::DesktopSettings;
+use serde::{Deserialize, Serialize};
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavDownloadResult {
+    pub summary: WebDavSyncSummary,
+    pub editor_settings: Option<serde_json::Value>,
+    pub desktop_settings: DesktopSettings,
+    pub apply_summary: ApplySnapshotSummary,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SnippetDownloadResult {
+    pub summary: SnippetSyncSummary,
+    pub editor_settings: Option<serde_json::Value>,
+    pub desktop_settings: DesktopSettings,
+    pub apply_summary: ApplySnapshotSummary,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavConfigRequest {
+    pub config: WebDavConfig,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveWebDavPasswordRequest {
+    pub config: WebDavConfig,
+    pub password: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavUploadRequest {
+    pub config: WebDavConfig,
+    pub editor_settings: Option<serde_json::Value>,
+    pub secrets_passphrase: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavDownloadRequest {
+    pub config: WebDavConfig,
+    pub secrets_passphrase: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavSyncSecretsPreferenceRequest {
+    pub enabled: bool,
+    pub passphrase: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SnippetConfigRequest {
+    pub config: SnippetSyncConfig,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveSnippetTokenRequest {
+    pub config: SnippetSyncConfig,
+    pub token: String,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SnippetUploadRequest {
+    pub config: SnippetSyncConfig,
+    pub editor_settings: Option<serde_json::Value>,
+    pub secrets_passphrase: Option<String>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SnippetDownloadRequest {
+    pub config: SnippetSyncConfig,
+    pub secrets_passphrase: Option<String>,
+}
+
+pub async fn webdav_sync_test(
+    State(state): State<Arc<WebState>>,
+    Json(mut req): Json<WebDavConfigRequest>,
+) -> Result<Json<()>, AppError> {
+    resolve_webdav_password(&state.app.storage, &mut req.config).await.map_err(AppError)?;
+    WebDavClient::new(req.config).test().await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn webdav_password_status(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<WebDavConfigRequest>,
+) -> Result<Json<WebDavPasswordStatus>, AppError> {
+    webdav_saved_password_status(&state.app.storage, &req.config).await.map(Json).map_err(AppError)
+}
+
+pub async fn save_webdav_saved_password(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SaveWebDavPasswordRequest>,
+) -> Result<Json<()>, AppError> {
+    save_webdav_password(&state.app.storage, &req.config, &req.password).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn forget_webdav_saved_password(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<WebDavConfigRequest>,
+) -> Result<Json<()>, AppError> {
+    forget_webdav_password(&state.app.storage, &req.config).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn webdav_sync_secrets_status(
+    State(state): State<Arc<WebState>>,
+) -> Result<Json<WebDavSyncSecretsStatus>, AppError> {
+    core_webdav_sync_secrets_status(&state.app.storage).await.map(Json).map_err(AppError)
+}
+
+pub async fn save_webdav_sync_secrets_preference(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<WebDavSyncSecretsPreferenceRequest>,
+) -> Result<Json<()>, AppError> {
+    core_save_webdav_sync_secrets_preference(&state.app.storage, req.enabled, req.passphrase.as_deref())
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn forget_webdav_sync_secrets_passphrase(State(state): State<Arc<WebState>>) -> Result<Json<()>, AppError> {
+    core_forget_webdav_sync_secrets_passphrase(&state.app.storage).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn webdav_sync_upload(
+    State(state): State<Arc<WebState>>,
+    Json(mut req): Json<WebDavUploadRequest>,
+) -> Result<Json<WebDavSyncSummary>, AppError> {
+    resolve_webdav_password(&state.app.storage, &mut req.config).await.map_err(AppError)?;
+    let snapshot = build_sync_snapshot_with_saved_secrets(
+        &state.app.storage,
+        env!("CARGO_PKG_VERSION"),
+        req.editor_settings,
+        req.secrets_passphrase.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    WebDavClient::new(req.config).put_snapshot(&snapshot).await.map(Json).map_err(AppError)
+}
+
+pub async fn webdav_sync_download(
+    State(state): State<Arc<WebState>>,
+    Json(mut req): Json<WebDavDownloadRequest>,
+) -> Result<Json<WebDavDownloadResult>, AppError> {
+    resolve_webdav_password(&state.app.storage, &mut req.config).await.map_err(AppError)?;
+    let (snapshot, summary) = WebDavClient::new(req.config).get_snapshot().await.map_err(AppError)?;
+    let explicit_passphrase = req.secrets_passphrase.as_deref().map(str::trim).filter(|value| !value.is_empty());
+    let saved_passphrase = if explicit_passphrase.is_some() {
+        None
+    } else {
+        resolve_webdav_sync_secrets_passphrase(&state.app.storage).await.map_err(AppError)?
+    };
+    let apply_summary = apply_sync_snapshot(
+        &state.app.storage,
+        &snapshot,
+        ApplySnapshotOptions { secrets_passphrase: explicit_passphrase.or(saved_passphrase.as_deref()) },
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(WebDavDownloadResult {
+        summary,
+        editor_settings: snapshot.editor_settings,
+        desktop_settings: snapshot.desktop_settings,
+        apply_summary,
+    }))
+}
+
+pub async fn snippet_sync_test(
+    State(state): State<Arc<WebState>>,
+    Json(mut req): Json<SnippetConfigRequest>,
+) -> Result<Json<()>, AppError> {
+    resolve_snippet_token(&state.app.storage, &mut req.config).await.map_err(AppError)?;
+    SnippetSyncClient::new(req.config).test().await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn snippet_token_status(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SnippetConfigRequest>,
+) -> Result<Json<SnippetTokenStatus>, AppError> {
+    snippet_saved_token_status(&state.app.storage, &req.config).await.map(Json).map_err(AppError)
+}
+
+pub async fn save_snippet_saved_token(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SaveSnippetTokenRequest>,
+) -> Result<Json<()>, AppError> {
+    save_snippet_token(&state.app.storage, &req.config, &req.token).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn forget_snippet_saved_token(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SnippetConfigRequest>,
+) -> Result<Json<()>, AppError> {
+    forget_snippet_token(&state.app.storage, &req.config).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn snippet_sync_upload(
+    State(state): State<Arc<WebState>>,
+    Json(mut req): Json<SnippetUploadRequest>,
+) -> Result<Json<SnippetSyncSummary>, AppError> {
+    resolve_snippet_token(&state.app.storage, &mut req.config).await.map_err(AppError)?;
+    let snapshot = build_sync_snapshot_with_saved_secrets(
+        &state.app.storage,
+        env!("CARGO_PKG_VERSION"),
+        req.editor_settings,
+        req.secrets_passphrase.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    SnippetSyncClient::new(req.config).put_snapshot(&snapshot).await.map(Json).map_err(AppError)
+}
+
+pub async fn snippet_sync_download(
+    State(state): State<Arc<WebState>>,
+    Json(mut req): Json<SnippetDownloadRequest>,
+) -> Result<Json<SnippetDownloadResult>, AppError> {
+    resolve_snippet_token(&state.app.storage, &mut req.config).await.map_err(AppError)?;
+    let (snapshot, summary) = SnippetSyncClient::new(req.config).get_snapshot().await.map_err(AppError)?;
+    let explicit_passphrase = req.secrets_passphrase.as_deref().map(str::trim).filter(|value| !value.is_empty());
+    let saved_passphrase = if explicit_passphrase.is_some() {
+        None
+    } else {
+        resolve_webdav_sync_secrets_passphrase(&state.app.storage).await.map_err(AppError)?
+    };
+    let apply_summary = apply_sync_snapshot(
+        &state.app.storage,
+        &snapshot,
+        ApplySnapshotOptions { secrets_passphrase: explicit_passphrase.or(saved_passphrase.as_deref()) },
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(SnippetDownloadResult {
+        summary,
+        editor_settings: snapshot.editor_settings,
+        desktop_settings: snapshot.desktop_settings,
+        apply_summary,
+    }))
+}
diff --git a/crates/dbx-web/src/routes/connection.rs b/crates/dbx-web/src/routes/connection.rs
new file mode 100644
index 0000000..567f4e0
--- /dev/null
+++ b/crates/dbx-web/src/routes/connection.rs
@@ -0,0 +1,660 @@
+use std::collections::HashSet;
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+use dbx_core::models::connection::ConnectionConfig;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ConnectRequest {
+    pub config: ConnectionConfig,
+    pub client_attempt: Option<u64>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DisconnectRequest {
+    pub connection_id: String,
+    pub client_attempt: Option<u64>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CloseDatabaseConnectionRequest {
+    pub connection_id: String,
+    pub database: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveConnectionsRequest {
+    pub configs: Vec<ConnectionConfig>,
+}
+
+pub async fn test_connection(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<ConnectRequest>,
+) -> Result<Json<String>, AppError> {
+    let config = body.config;
+    let app = &state.app;
+
+    // Store config temporarily
+    let temp_id = format!("__test_{}", uuid::Uuid::new_v4());
+    app.configs.write().await.insert(temp_id.clone(), config.clone());
+
+    // Try to connect
+    let result = app.get_or_create_pool(&temp_id, config.database.as_deref()).await;
+
+    // Clean up any pool keys created for the temporary connection, including
+    // database-scoped keys like "__test_uuid:database".
+    app.remove_connection_pools(&temp_id).await;
+    app.reset_connection_transport_for_config(&temp_id, &config).await;
+    app.configs.write().await.remove(&temp_id);
+
+    match result {
+        Ok(_) => Ok(Json("Connection successful".to_string())),
+        Err(e) => Err(AppError(e)),
+    }
+}
+
+pub async fn connect_db(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<ConnectRequest>,
+) -> Result<Json<String>, AppError> {
+    let config = body.config;
+    let app = &state.app;
+    let connection_id = config.id.clone();
+    let attempt = app.begin_connection_attempt_with_client_attempt(&connection_id, body.client_attempt).await;
+
+    app.remove_connection_pools_detached(&connection_id).await;
+    app.reset_connection_transport_for_config(&connection_id, &config).await;
+    app.configs.write().await.insert(connection_id.clone(), config.clone());
+
+    app.get_or_create_pool_for_connection_attempt(&connection_id, None, attempt).await.map_err(AppError)?;
+
+    Ok(Json(connection_id))
+}
+
+pub async fn connection_final_proxy_port(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<ConnectRequest>,
+) -> Result<Json<u16>, AppError> {
+    let runtime_config = body.config.canonicalized();
+    if !runtime_config.has_effective_transport_layers() {
+        return Err(AppError("Connection has no configured transport layers".to_string()));
+    }
+
+    let app = &state.app;
+    let connection_id = runtime_config.id.clone();
+    let db_config = dbx_core::connection::metadata_connection_config(&runtime_config);
+    app.configs.write().await.insert(connection_id.clone(), runtime_config);
+
+    let (_, port) = app.connection_host_port(&connection_id, &db_config).await.map_err(AppError)?;
+    Ok(Json(port))
+}
+
+pub async fn disconnect_db(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<DisconnectRequest>,
+) -> Result<Json<()>, AppError> {
+    let app = &state.app;
+
+    let should_disconnect = if let Some(client_attempt) = body.client_attempt {
+        app.supersede_connection_attempt_if_client_attempt(&body.connection_id, client_attempt).await
+    } else {
+        app.supersede_connection_attempt(&body.connection_id).await;
+        true
+    };
+    if !should_disconnect {
+        return Ok(Json(()));
+    }
+    app.remove_connection_pools_detached(&body.connection_id).await;
+    app.nacos_registry.drop_connection(&body.connection_id).await;
+    #[cfg(feature = "mq-admin")]
+    app.mq_registry.drop_connection(&body.connection_id).await;
+    app.reset_connection_transport(&body.connection_id).await;
+    if body.connection_id.starts_with("__visible_draft_") || body.connection_id.starts_with("__visible_schema_draft_") {
+        app.configs.write().await.remove(&body.connection_id);
+    }
+
+    Ok(Json(()))
+}
+
+pub async fn check_connection_health(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<DisconnectRequest>,
+) -> Result<Json<()>, AppError> {
+    state.app.check_connection_health(&body.connection_id).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn close_database_connection(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<CloseDatabaseConnectionRequest>,
+) -> Result<Json<bool>, AppError> {
+    let database = body.database.trim();
+    let database = if database.is_empty() { None } else { Some(database) };
+    state.app.close_database_pool(&body.connection_id, database).await.map(Json).map_err(AppError)
+}
+
+pub async fn save_connections(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<SaveConnectionsRequest>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.save_connections(&body.configs).await.map_err(AppError)?;
+    let sync = sync_connection_configs(&state, &body.configs).await;
+    remove_connection_pools_for_connection_ids(&state, &sync.connection_pool_ids_to_drop).await;
+    drop_nacos_adapters_for_connection_ids(&state, &sync.nacos_adapter_ids_to_drop).await;
+    drop_mq_adapters_for_connection_ids(&state, &sync.mq_adapter_ids_to_drop).await;
+    Ok(Json(()))
+}
+
+pub async fn load_connections(State(state): State<Arc<WebState>>) -> Result<Json<Vec<ConnectionConfig>>, AppError> {
+    let configs = state.app.storage.load_connections().await.map_err(AppError)?;
+    let sync = sync_connection_configs(&state, &configs).await;
+    remove_connection_pools_for_connection_ids(&state, &sync.connection_pool_ids_to_drop).await;
+    drop_nacos_adapters_for_connection_ids(&state, &sync.nacos_adapter_ids_to_drop).await;
+    drop_mq_adapters_for_connection_ids(&state, &sync.mq_adapter_ids_to_drop).await;
+    Ok(Json(configs))
+}
+
+struct ConnectionConfigSync {
+    nacos_adapter_ids_to_drop: Vec<String>,
+    mq_adapter_ids_to_drop: Vec<String>,
+    connection_pool_ids_to_drop: Vec<String>,
+}
+
+async fn sync_connection_configs(state: &WebState, configs: &[ConnectionConfig]) -> ConnectionConfigSync {
+    let saved_ids: HashSet<&str> = configs.iter().map(|config| config.id.as_str()).collect();
+    let mut nacos_adapter_ids_to_drop = HashSet::new();
+    let mut mq_adapter_ids_to_drop = HashSet::new();
+    let mut connection_pool_ids_to_drop = HashSet::new();
+    let mut runtime_configs = state.app.configs.write().await;
+    runtime_configs.retain(|id, existing| {
+        if saved_ids.contains(id.as_str()) || is_transient_runtime_config_id(id) {
+            true
+        } else {
+            connection_pool_ids_to_drop.insert(id.clone());
+            if existing.db_type == dbx_core::models::connection::DatabaseType::Nacos {
+                nacos_adapter_ids_to_drop.insert(id.clone());
+            }
+            if existing.db_type == dbx_core::models::connection::DatabaseType::MessageQueue {
+                mq_adapter_ids_to_drop.insert(id.clone());
+            }
+            false
+        }
+    });
+    for config in configs {
+        if config.db_type == dbx_core::models::connection::DatabaseType::Nacos {
+            nacos_adapter_ids_to_drop.insert(config.id.clone());
+        }
+        if config.db_type == dbx_core::models::connection::DatabaseType::MessageQueue {
+            mq_adapter_ids_to_drop.insert(config.id.clone());
+        }
+        if let Some(previous) = runtime_configs.insert(config.id.clone(), config.clone()) {
+            if previous.db_type == dbx_core::models::connection::DatabaseType::Nacos {
+                nacos_adapter_ids_to_drop.insert(config.id.clone());
+            }
+            if previous.db_type == dbx_core::models::connection::DatabaseType::MessageQueue {
+                mq_adapter_ids_to_drop.insert(config.id.clone());
+            }
+            if &previous != config {
+                connection_pool_ids_to_drop.insert(config.id.clone());
+            }
+        }
+    }
+    ConnectionConfigSync {
+        nacos_adapter_ids_to_drop: nacos_adapter_ids_to_drop.into_iter().collect(),
+        mq_adapter_ids_to_drop: mq_adapter_ids_to_drop.into_iter().collect(),
+        connection_pool_ids_to_drop: connection_pool_ids_to_drop.into_iter().collect(),
+    }
+}
+
+fn is_transient_runtime_config_id(id: &str) -> bool {
+    id.starts_with("__test_") || id.starts_with("__visible_draft_") || id.starts_with("__visible_schema_draft_")
+}
+
+async fn drop_nacos_adapters_for_connection_ids(state: &WebState, connection_ids: &[String]) {
+    for connection_id in connection_ids {
+        state.app.nacos_registry.drop_connection(connection_id).await;
+    }
+}
+
+#[cfg(feature = "mq-admin")]
+async fn drop_mq_adapters_for_connection_ids(state: &WebState, connection_ids: &[String]) {
+    for connection_id in connection_ids {
+        state.app.mq_registry.drop_connection(connection_id).await;
+    }
+}
+
+#[cfg(not(feature = "mq-admin"))]
+async fn drop_mq_adapters_for_connection_ids(_state: &WebState, _connection_ids: &[String]) {}
+
+async fn remove_connection_pools_for_connection_ids(state: &WebState, connection_ids: &[String]) {
+    for connection_id in connection_ids {
+        state.app.remove_connection_pools_detached(connection_id).await;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        connect_db, disconnect_db, load_connections, save_connections, ConnectRequest, DisconnectRequest,
+        SaveConnectionsRequest,
+    };
+    use crate::state::{LoginRateLimit, WebState};
+    use axum::extract::State;
+    use axum::Json;
+    use dbx_core::connection::{AppState, PoolKind};
+    use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
+    use dbx_core::storage::Storage;
+    use std::collections::{HashMap, HashSet};
+    use std::sync::Arc;
+    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+    use tokio::net::TcpListener;
+    use tokio::sync::{Mutex, RwLock};
+
+    fn sqlite_config(id: &str, path: &str) -> ConnectionConfig {
+        ConnectionConfig {
+            id: id.to_string(),
+            name: "SQLite".to_string(),
+            db_type: DatabaseType::Sqlite,
+            driver_profile: None,
+            driver_label: None,
+            url_params: None,
+            agent_java_options: Vec::new(),
+            host: path.to_string(),
+            port: 0,
+            username: String::new(),
+            password: String::new(),
+            database: None,
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: dbx_core::models::connection::default_connect_timeout_secs(),
+            query_timeout_secs: dbx_core::models::connection::default_query_timeout_secs(),
+            idle_timeout_secs: dbx_core::models::connection::default_idle_timeout_secs(),
+            keepalive_interval_secs: dbx_core::models::connection::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: None,
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: dbx_core::models::connection::default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    fn mq_config(id: &str, admin_url: &str) -> ConnectionConfig {
+        let mut config = sqlite_config(id, "");
+        config.name = "Pulsar".to_string();
+        config.db_type = DatabaseType::MessageQueue;
+        config.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": admin_url,
+            "auth": { "kind": "none" },
+            "pinnedVersion": "3.1"
+        }));
+        config
+    }
+
+    async fn test_web_state() -> (Arc<WebState>, std::path::PathBuf) {
+        let dir = std::env::temp_dir().join(format!("dbx-web-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let app = Arc::new(AppState::new_with_plugin_dir(storage, dir.join("plugins")));
+        let state = Arc::new(WebState {
+            app,
+            data_dir: dir.clone(),
+            public_base_path: "/".to_string(),
+            password_disabled: false,
+            password_hash: RwLock::new(None),
+            sessions: RwLock::new(HashSet::new()),
+            sse_channels: RwLock::new(HashMap::new()),
+            sql_file_executions: RwLock::new(HashMap::new()),
+            login_rate_limit: Mutex::new(LoginRateLimit { fail_count: 0, locked_until: None }),
+            export_files: RwLock::new(HashMap::new()),
+        });
+        (state, dir)
+    }
+
+    async fn spawn_pulsar_clusters_server() -> String {
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        tokio::spawn(async move {
+            loop {
+                let Ok((mut stream, _)) = listener.accept().await else {
+                    break;
+                };
+                tokio::spawn(async move {
+                    let mut buf = [0_u8; 1024];
+                    let Ok(n) = stream.read(&mut buf).await else {
+                        return;
+                    };
+                    let request = String::from_utf8_lossy(&buf[..n]);
+                    let status =
+                        if request.starts_with("GET /admin/v2/clusters ") { "200 OK" } else { "404 Not Found" };
+                    let body = if status.starts_with("200") { r#"["ec-pulsar"]"# } else { r#"{"reason":"missing"}"# };
+                    let response = format!(
+                        "HTTP/1.1 {status}\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
+                        body.len()
+                    );
+                    let _ = stream.write_all(response.as_bytes()).await;
+                });
+            }
+        });
+        format!("http://{addr}")
+    }
+
+    #[tokio::test]
+    async fn save_connections_updates_runtime_config_cache() {
+        let (state, dir) = test_web_state().await;
+        let db_path = dir.join("app.db");
+        let config = sqlite_config("sqlite-conn", &db_path.to_string_lossy());
+
+        let result =
+            save_connections(State(state.clone()), Json(SaveConnectionsRequest { configs: vec![config.clone()] }))
+                .await;
+        assert!(result.is_ok());
+
+        let configs = state.app.configs.read().await;
+        assert_eq!(configs.get("sqlite-conn").map(|c| c.host.as_str()), Some(config.host.as_str()));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn save_connections_drops_cached_mq_adapter_for_updated_config() {
+        let (state, dir) = test_web_state().await;
+        let initial = mq_config("mq-conn", "http://127.0.0.1:8080");
+        state.app.configs.write().await.insert(initial.id.clone(), initial.clone());
+        state.app.connections.write().await.insert(initial.id.clone(), PoolKind::MessageQueue);
+        let first = state.app.mq_registry.get_or_build(&initial).await.unwrap();
+
+        let updated = mq_config("mq-conn", "http://127.0.0.1:8081");
+        let result =
+            save_connections(State(state.clone()), Json(SaveConnectionsRequest { configs: vec![updated.clone()] }))
+                .await;
+        assert!(result.is_ok());
+
+        let cached_admin_url = state
+            .app
+            .configs
+            .read()
+            .await
+            .get("mq-conn")
+            .and_then(|config| config.external_config.as_ref())
+            .and_then(|external| external.get("adminUrl"))
+            .and_then(serde_json::Value::as_str)
+            .map(str::to_string);
+        assert_eq!(cached_admin_url.as_deref(), Some("http://127.0.0.1:8081"));
+
+        let second = state.app.mq_registry.get_or_build(&updated).await.unwrap();
+        assert!(!Arc::ptr_eq(&first, &second));
+        assert!(!state.app.connections.read().await.contains_key(&initial.id));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(feature = "mq-admin")]
+    #[tokio::test]
+    async fn connect_db_rebuilds_mq_adapter_for_updated_config_with_same_id() {
+        let (state, dir) = test_web_state().await;
+        let initial = mq_config("mq-conn", "http://127.0.0.1:8080");
+        state.app.configs.write().await.insert(initial.id.clone(), initial.clone());
+        state.app.connections.write().await.insert(initial.id.clone(), PoolKind::MessageQueue);
+        let first = state.app.mq_registry.get_or_build(&initial).await.unwrap();
+
+        let updated = mq_config("mq-conn", &spawn_pulsar_clusters_server().await);
+        let result =
+            connect_db(State(state.clone()), Json(ConnectRequest { config: updated.clone(), client_attempt: None }))
+                .await;
+        assert!(result.is_ok());
+
+        let second = state.app.mq_registry.get_or_build(&updated).await.unwrap();
+        assert!(!Arc::ptr_eq(&first, &second));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn load_connections_drops_cached_pool_for_updated_config() {
+        let (state, dir) = test_web_state().await;
+        let initial = mq_config("mq-conn", "http://127.0.0.1:8080");
+        let updated = mq_config("mq-conn", "http://127.0.0.1:8081");
+        state.app.storage.save_connections(&[updated.clone()]).await.unwrap();
+        state.app.configs.write().await.insert(initial.id.clone(), initial.clone());
+        state.app.connections.write().await.insert(initial.id.clone(), PoolKind::MessageQueue);
+
+        let result = load_connections(State(state.clone())).await;
+        assert!(result.is_ok());
+
+        let configs = state.app.configs.read().await;
+        let cached_admin_url = configs
+            .get("mq-conn")
+            .and_then(|config| config.external_config.as_ref())
+            .and_then(|external| external.get("adminUrl"))
+            .and_then(serde_json::Value::as_str);
+        assert_eq!(cached_admin_url, Some("http://127.0.0.1:8081"));
+        drop(configs);
+        assert!(!state.app.connections.read().await.contains_key(&initial.id));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(feature = "mq-admin")]
+    #[tokio::test]
+    async fn save_connections_removes_deleted_runtime_config_and_mq_adapter() {
+        let (state, dir) = test_web_state().await;
+        let kept = sqlite_config("kept", &dir.join("kept.db").to_string_lossy());
+        let removed = mq_config("removed-mq", "http://127.0.0.1:8080");
+        {
+            let mut configs = state.app.configs.write().await;
+            configs.insert(kept.id.clone(), kept.clone());
+            configs.insert(removed.id.clone(), removed.clone());
+        }
+        let stale = state.app.mq_registry.get_or_build(&removed).await.unwrap();
+
+        let result =
+            save_connections(State(state.clone()), Json(SaveConnectionsRequest { configs: vec![kept.clone()] })).await;
+        assert!(result.is_ok());
+
+        let configs = state.app.configs.read().await;
+        assert!(configs.contains_key("kept"));
+        assert!(!configs.contains_key("removed-mq"));
+        drop(configs);
+
+        let rebuilt = state.app.mq_registry.get_or_build(&removed).await.unwrap();
+        assert!(!Arc::ptr_eq(&stale, &rebuilt));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(feature = "mq-admin")]
+    #[tokio::test]
+    async fn save_connections_removes_deleted_connection_pools() {
+        let (state, dir) = test_web_state().await;
+        let kept = sqlite_config("kept", &dir.join("kept.db").to_string_lossy());
+        let removed = mq_config("removed-mq", "http://127.0.0.1:8080");
+        {
+            let mut configs = state.app.configs.write().await;
+            configs.insert(kept.id.clone(), kept.clone());
+            configs.insert(removed.id.clone(), removed.clone());
+        }
+        state.app.connections.write().await.insert(removed.id.clone(), PoolKind::MessageQueue);
+
+        let result =
+            save_connections(State(state.clone()), Json(SaveConnectionsRequest { configs: vec![kept.clone()] })).await;
+        assert!(result.is_ok());
+
+        assert!(!state.app.connections.read().await.contains_key(&removed.id));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn disconnect_db_keeps_connections_with_similar_prefixes() {
+        let (state, dir) = test_web_state().await;
+        let conn_path = dir.join("conn.db");
+        let conn2_path = dir.join("conn2.db");
+        std::fs::File::create(&conn_path).unwrap();
+        std::fs::File::create(&conn2_path).unwrap();
+        let conn_pool = dbx_core::db::sqlite::connect_path(&conn_path.to_string_lossy()).await.unwrap();
+        let conn2_pool = dbx_core::db::sqlite::connect_path(&conn2_path.to_string_lossy()).await.unwrap();
+
+        {
+            let mut connections = state.app.connections.write().await;
+            connections.insert("conn".to_string(), PoolKind::Sqlite(conn_pool));
+            connections.insert("conn2".to_string(), PoolKind::Sqlite(conn2_pool));
+        }
+
+        let result = disconnect_db(
+            State(state.clone()),
+            Json(DisconnectRequest { connection_id: "conn".to_string(), client_attempt: None }),
+        )
+        .await;
+        assert!(result.is_ok());
+
+        let connections = state.app.connections.read().await;
+        assert!(!connections.contains_key("conn"));
+        assert!(connections.contains_key("conn2"));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn disconnect_db_ignores_stale_client_attempt_cancel() {
+        let (state, dir) = test_web_state().await;
+        let conn_path = dir.join("conn.db");
+        std::fs::File::create(&conn_path).unwrap();
+        let conn_pool = dbx_core::db::sqlite::connect_path(&conn_path.to_string_lossy()).await.unwrap();
+        state.app.begin_connection_attempt_with_client_attempt("conn", Some(1)).await;
+        let current_attempt = state.app.begin_connection_attempt_with_client_attempt("conn", Some(2)).await;
+        state.app.connections.write().await.insert("conn".to_string(), PoolKind::Sqlite(conn_pool));
+
+        let result = disconnect_db(
+            State(state.clone()),
+            Json(DisconnectRequest { connection_id: "conn".to_string(), client_attempt: Some(1) }),
+        )
+        .await;
+        assert!(result.is_ok());
+
+        assert!(state.app.connections.read().await.contains_key("conn"));
+        assert!(state.app.ensure_current_connection_attempt("conn", Some(current_attempt)).await.is_ok());
+
+        let result = disconnect_db(
+            State(state.clone()),
+            Json(DisconnectRequest { connection_id: "conn".to_string(), client_attempt: Some(2) }),
+        )
+        .await;
+        assert!(result.is_ok());
+
+        assert!(!state.app.connections.read().await.contains_key("conn"));
+        assert!(state.app.ensure_current_connection_attempt("conn", Some(current_attempt)).await.is_err());
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn disconnect_db_keeps_connection_config_for_reconnect() {
+        let (state, dir) = test_web_state().await;
+        let conn_path = dir.join("conn.db");
+        std::fs::File::create(&conn_path).unwrap();
+        let conn_pool = dbx_core::db::sqlite::connect_path(&conn_path.to_string_lossy()).await.unwrap();
+
+        {
+            let mut connections = state.app.connections.write().await;
+            connections.insert("conn".to_string(), PoolKind::Sqlite(conn_pool));
+        }
+        {
+            let mut configs = state.app.configs.write().await;
+            configs.insert("conn".to_string(), sqlite_config("conn", &conn_path.to_string_lossy()));
+        }
+
+        let result = disconnect_db(
+            State(state.clone()),
+            Json(DisconnectRequest { connection_id: "conn".to_string(), client_attempt: None }),
+        )
+        .await;
+        assert!(result.is_ok());
+
+        let configs = state.app.configs.read().await;
+        assert!(configs.contains_key("conn"));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(feature = "mq-admin")]
+    #[tokio::test]
+    async fn disconnect_db_drops_cached_mq_adapter() {
+        let (state, dir) = test_web_state().await;
+        let config = mq_config("mq-conn", "http://127.0.0.1:8080");
+        state.app.configs.write().await.insert(config.id.clone(), config.clone());
+        state.app.connections.write().await.insert(config.id.clone(), PoolKind::MessageQueue);
+        let first = state.app.mq_registry.get_or_build(&config).await.unwrap();
+
+        let result = disconnect_db(
+            State(state.clone()),
+            Json(DisconnectRequest { connection_id: config.id.clone(), client_attempt: None }),
+        )
+        .await;
+        assert!(result.is_ok());
+
+        assert!(!state.app.connections.read().await.contains_key(&config.id));
+        let second = state.app.mq_registry.get_or_build(&config).await.unwrap();
+        assert!(!Arc::ptr_eq(&first, &second));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[tokio::test]
+    async fn disconnect_db_removes_visible_database_draft_config() {
+        let (state, dir) = test_web_state().await;
+        let conn_path = dir.join("draft.db");
+        let draft_id = "__visible_draft_test";
+        std::fs::File::create(&conn_path).unwrap();
+
+        {
+            let mut configs = state.app.configs.write().await;
+            configs.insert(draft_id.to_string(), sqlite_config(draft_id, &conn_path.to_string_lossy()));
+        }
+
+        let result = disconnect_db(
+            State(state.clone()),
+            Json(DisconnectRequest { connection_id: draft_id.to_string(), client_attempt: None }),
+        )
+        .await;
+        assert!(result.is_ok());
+
+        let configs = state.app.configs.read().await;
+        assert!(!configs.contains_key(draft_id));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+}
diff --git a/crates/dbx-web/src/routes/data_compare.rs b/crates/dbx-web/src/routes/data_compare.rs
new file mode 100644
index 0000000..8d58b6c
--- /dev/null
+++ b/crates/dbx-web/src/routes/data_compare.rs
@@ -0,0 +1,32 @@
+use axum::extract::State;
+use axum::Json;
+use std::sync::Arc;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+pub async fn prepare_data_compare(
+    Json(options): Json<dbx_core::data_compare::DataComparePreparationOptions>,
+) -> Result<Json<dbx_core::data_compare::DataComparePreparation>, AppError> {
+    dbx_core::data_compare::prepare_data_compare(options).map(Json).map_err(AppError)
+}
+
+pub async fn prepare_data_compare_from_tables(
+    State(state): State<Arc<WebState>>,
+    Json(options): Json<dbx_core::data_compare::DataCompareFromTablesOptions>,
+) -> Result<Json<dbx_core::data_compare::DataCompareFromTablesPreparation>, AppError> {
+    dbx_core::data_compare::prepare_data_compare_from_tables(&state.app, options).await.map(Json).map_err(AppError)
+}
+
+pub async fn prepare_data_compare_missing_target(
+    State(state): State<Arc<WebState>>,
+    Json(options): Json<dbx_core::data_compare::DataCompareMissingTargetOptions>,
+) -> Result<Json<dbx_core::data_compare::DataCompareFromTablesPreparation>, AppError> {
+    dbx_core::data_compare::prepare_data_compare_missing_target(&state.app, options).await.map(Json).map_err(AppError)
+}
+
+pub async fn build_data_compare_sync_plan(
+    Json(options): Json<dbx_core::data_compare::DataCompareSyncPlanOptions>,
+) -> Json<dbx_core::data_compare::DataCompareSyncPlan> {
+    Json(dbx_core::data_compare::build_data_compare_sync_plan(options))
+}
diff --git a/crates/dbx-web/src/routes/database_export.rs b/crates/dbx-web/src/routes/database_export.rs
new file mode 100644
index 0000000..58b808d
--- /dev/null
+++ b/crates/dbx-web/src/routes/database_export.rs
@@ -0,0 +1,166 @@
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+
+use axum::body::Body;
+use axum::extract::{Path, State};
+use axum::http::{header, StatusCode};
+use axum::response::sse::{Event, Sse};
+use axum::response::Response;
+use axum::Json;
+use dbx_core::database_export::{self, DatabaseExportRequest, ExportProgress, ExportStatus};
+use futures::stream::Stream;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StartExportRequest {
+    pub request: DatabaseExportRequest,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CancelExportRequest {
+    pub export_id: String,
+}
+
+pub async fn start_database_export(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<StartExportRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let mut req = body.request;
+    let export_id = req.export_id.clone();
+
+    // Web mode: write to a server-side temp file instead of the client-supplied
+    // path (which is a relative placeholder and would land in the server process
+    // CWD, unreachable by the browser). The file is served back via the download
+    // endpoint after the export completes.
+    let tmp_dir = state.data_dir.join("tmp");
+    std::fs::create_dir_all(&tmp_dir).map_err(|e| AppError(e.to_string()))?;
+    let tmp_file = tmp_dir.join(format!("database_export_{export_id}.sql"));
+    let tmp_file_path = tmp_file.to_string_lossy().to_string();
+    req.file_path = tmp_file_path.clone();
+
+    let download_filename = format!("{}.sql", sanitize_export_filename(&req.database));
+
+    // Store export file mapping for download
+    state.export_files.write().await.insert(export_id.clone(), (tmp_file_path.clone(), download_filename));
+
+    let (tx, _) = tokio::sync::broadcast::channel::<String>(256);
+    state.sse_channels.write().await.insert(export_id.clone(), tx.clone());
+
+    let app = state.app.clone();
+    let state_clone = state.clone();
+
+    let cancelled = Arc::new(AtomicBool::new(false));
+    let cancelled_progress = cancelled.clone();
+
+    tokio::spawn(async move {
+        let result = database_export::export_database_sql_core(&app, &req, |progress| {
+            if matches!(progress.status, ExportStatus::Cancelled) {
+                cancelled_progress.store(true, Ordering::SeqCst);
+            }
+            if let Ok(json) = serde_json::to_string(&progress) {
+                let _ = tx.send(json);
+            }
+        })
+        .await;
+
+        // `export_database_sql_core` signals cancellation either by emitting a
+        // Cancelled progress and returning Ok(()), or by returning
+        // Err("Export cancelled"). Treat both as cancellation.
+        let is_cancelled =
+            cancelled.load(Ordering::SeqCst) || result.as_ref().err().map(|e| e.contains("cancelled")).unwrap_or(false);
+
+        match (&result, is_cancelled) {
+            (_, true) => {
+                // Cancelled: drop temp file + mapping, no Error progress.
+                let _ = tokio::fs::remove_file(&req.file_path).await;
+                state_clone.export_files.write().await.remove(&req.export_id);
+            }
+            (Err(e), false) => {
+                let _ = tokio::fs::remove_file(&req.file_path).await;
+                state_clone.export_files.write().await.remove(&req.export_id);
+                let progress = ExportProgress {
+                    export_id: req.export_id.clone(),
+                    current_object: String::new(),
+                    object_index: 0,
+                    total_objects: 0,
+                    rows_exported: 0,
+                    total_rows: None,
+                    status: ExportStatus::Error,
+                    error: Some(e.clone()),
+                };
+                if let Ok(json) = serde_json::to_string(&progress) {
+                    let _ = tx.send(json);
+                }
+            }
+            (Ok(()), false) => {
+                // Done: keep temp file + mapping for the download endpoint.
+            }
+        }
+
+        database_export::clear_export_cancelled(&req.export_id).await;
+        state_clone.remove_sse_channel(&req.export_id).await;
+    });
+
+    Ok(Json(serde_json::json!({ "exportId": export_id })))
+}
+
+/// Sanitize a database name into a safe download filename component, mirroring
+/// the client-side `safeName` logic in DatabaseExportDialog.vue.
+fn sanitize_export_filename(name: &str) -> String {
+    let replaced = name.replace(['\\', '/', ':', '*', '?', '"', '<', '>', '|'], "_");
+    let sanitized = replaced.trim();
+    if sanitized.is_empty() {
+        "database".to_string()
+    } else {
+        sanitized.to_string()
+    }
+}
+
+pub async fn database_export_progress(
+    State(state): State<Arc<WebState>>,
+    Path(export_id): Path<String>,
+) -> Result<Sse<impl Stream<Item = Result<Event, std::convert::Infallible>>>, AppError> {
+    let channels = state.sse_channels.read().await;
+    let tx = channels.get(&export_id).ok_or_else(|| AppError("Export not found".to_string()))?;
+    let rx = tx.subscribe();
+    drop(channels);
+    Ok(crate::sse::sse_from_channel(rx))
+}
+
+pub async fn cancel_database_export(
+    State(_state): State<Arc<WebState>>,
+    Json(req): Json<CancelExportRequest>,
+) -> Json<serde_json::Value> {
+    database_export::set_export_cancelled(&req.export_id).await;
+    Json(serde_json::json!({ "cancelled": true }))
+}
+
+pub async fn database_export_download(
+    State(state): State<Arc<WebState>>,
+    Path(export_id): Path<String>,
+) -> Result<Response, AppError> {
+    let (file_path, download_filename) = state
+        .export_files
+        .write()
+        .await
+        .remove(&export_id)
+        .ok_or_else(|| AppError("Export file not found".to_string()))?;
+
+    let data = tokio::fs::read(&file_path).await.map_err(|e| AppError(e.to_string()))?;
+    // Clean up temp file
+    let _ = tokio::fs::remove_file(&file_path).await;
+
+    Response::builder()
+        .status(StatusCode::OK)
+        .header(header::CONTENT_TYPE, "application/sql; charset=utf-8")
+        .header(header::CONTENT_DISPOSITION, format!("attachment; filename=\"{download_filename}\""))
+        .body(Body::from(data))
+        .map_err(|e| AppError(e.to_string()))
+}
diff --git a/crates/dbx-web/src/routes/document_store.rs b/crates/dbx-web/src/routes/document_store.rs
new file mode 100644
index 0000000..45228e3
--- /dev/null
+++ b/crates/dbx-web/src/routes/document_store.rs
@@ -0,0 +1,383 @@
+use std::future::Future;
+use std::sync::Arc;
+
+use axum::extract::{Multipart, State};
+use axum::Json;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+async fn run_cancellable<T, F>(state: &Arc<WebState>, execution_id: Option<String>, future: F) -> Result<T, AppError>
+where
+    F: Future<Output = Result<T, String>>,
+{
+    let registered = execution_id
+        .as_ref()
+        .filter(|id| !id.trim().is_empty())
+        .map(|id| state.app.running_queries.register(id.clone()));
+    if let Some(query) = registered.as_ref() {
+        let token = query.token();
+        tokio::select! {
+            biased;
+            _ = token.cancelled() => Err(AppError(dbx_core::query::canceled_error())),
+            result = future => result.map_err(AppError),
+        }
+    } else {
+        future.await.map_err(AppError)
+    }
+}
+
+async fn ensure_writable(
+    app: &dbx_core::connection::AppState,
+    connection_id: &str,
+    action: &str,
+) -> Result<(), AppError> {
+    if let Some(name) = dbx_core::query::connection_readonly_name(app, connection_id).await {
+        return Err(AppError(format!(
+            "Read-only mode: connection '{}' has read-only protection enabled. {} blocked.",
+            name, action
+        )));
+    }
+    Ok(())
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DocumentListDatabasesRequest {
+    pub connection_id: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DocumentListCollectionsRequest {
+    pub connection_id: String,
+    pub database: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DocumentFindRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub skip: Option<u64>,
+    pub limit: Option<i64>,
+    pub filter: Option<String>,
+    pub projection: Option<String>,
+    pub sort: Option<String>,
+    pub execution_id: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DocumentInsertRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub doc_json: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DocumentUpdateRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub id: String,
+    pub doc_json: String,
+    pub routing: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct DocumentDeleteRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub id: String,
+    pub routing: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GridFsBucketRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub bucket: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GridFsFileListRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub bucket: String,
+    pub filter: Option<String>,
+    pub sort: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GridFsBucketListRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub filter: Option<String>,
+    pub sort: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GridFsDownloadRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub bucket: String,
+    pub file_id: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GridFsFileDeleteRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub bucket: String,
+    pub file_id: String,
+}
+
+pub async fn list_databases(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DocumentListDatabasesRequest>,
+) -> Result<Json<Vec<String>>, AppError> {
+    let result = dbx_core::document_ops::list_databases_core(&state.app, &req.connection_id).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_collections(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DocumentListCollectionsRequest>,
+) -> Result<Json<Vec<dbx_core::document_ops::CollectionInfo>>, AppError> {
+    let result = dbx_core::document_ops::list_collections_core(&state.app, &req.connection_id, &req.database)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn find_documents(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DocumentFindRequest>,
+) -> Result<Json<dbx_core::db::mongo_driver::MongoDocumentResult>, AppError> {
+    let result = run_cancellable(
+        &state,
+        req.execution_id,
+        dbx_core::document_ops::find_documents_core(
+            &state.app,
+            &req.connection_id,
+            &req.database,
+            &req.collection,
+            req.skip.unwrap_or(0),
+            req.limit.unwrap_or(50),
+            req.filter.as_deref(),
+            req.projection.as_deref(),
+            req.sort.as_deref(),
+        ),
+    )
+    .await?;
+    Ok(Json(result))
+}
+
+pub async fn insert_document(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DocumentInsertRequest>,
+) -> Result<Json<String>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Insert").await?;
+    let result = dbx_core::document_ops::insert_document_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+        &req.doc_json,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn update_document(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DocumentUpdateRequest>,
+) -> Result<Json<u64>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Update").await?;
+    let result = dbx_core::document_ops::update_document_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+        &req.id,
+        &req.doc_json,
+        req.routing.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn delete_document(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DocumentDeleteRequest>,
+) -> Result<Json<u64>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete").await?;
+    let result = dbx_core::document_ops::delete_document_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+        &req.id,
+        req.routing.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_gridfs_files(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<GridFsFileListRequest>,
+) -> Result<Json<Vec<dbx_core::document_ops::MongoGridFsFileInfo>>, AppError> {
+    let result = dbx_core::document_ops::list_gridfs_files_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.bucket,
+        req.filter.as_deref(),
+        req.sort.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_gridfs_buckets(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<GridFsBucketListRequest>,
+) -> Result<Json<Vec<dbx_core::document_ops::MongoGridFsBucketInfo>>, AppError> {
+    let result = dbx_core::document_ops::list_gridfs_buckets_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        req.filter.as_deref(),
+        req.sort.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn create_gridfs_bucket(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<GridFsBucketRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Create GridFS bucket").await?;
+    dbx_core::document_ops::create_gridfs_bucket_core(&state.app, &req.connection_id, &req.database, &req.bucket)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn delete_gridfs_bucket(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<GridFsBucketRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete GridFS bucket").await?;
+    dbx_core::document_ops::delete_gridfs_bucket_core(&state.app, &req.connection_id, &req.database, &req.bucket)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn download_gridfs_file(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<GridFsDownloadRequest>,
+) -> Result<Json<Vec<u8>>, AppError> {
+    let result = dbx_core::document_ops::download_gridfs_file_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.bucket,
+        &req.file_id,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn upload_gridfs_file(
+    State(state): State<Arc<WebState>>,
+    mut multipart: Multipart,
+) -> Result<Json<String>, AppError> {
+    let mut connection_id: Option<String> = None;
+    let mut database: Option<String> = None;
+    let mut bucket: Option<String> = None;
+    let mut file_name: Option<String> = None;
+    let mut content_type: Option<String> = None;
+    let mut file_bytes: Option<Vec<u8>> = None;
+
+    while let Some(field) = multipart.next_field().await.map_err(|e| AppError(e.to_string()))? {
+        let name = field.name().unwrap_or_default().to_string();
+        match name.as_str() {
+            "connectionId" => connection_id = Some(field.text().await.map_err(|e| AppError(e.to_string()))?),
+            "database" => database = Some(field.text().await.map_err(|e| AppError(e.to_string()))?),
+            "bucket" => bucket = Some(field.text().await.map_err(|e| AppError(e.to_string()))?),
+            "fileName" => file_name = Some(field.text().await.map_err(|e| AppError(e.to_string()))?),
+            "contentType" => content_type = Some(field.text().await.map_err(|e| AppError(e.to_string()))?),
+            "file" => {
+                if file_name.is_none() {
+                    file_name = field.file_name().map(str::to_string);
+                }
+                if content_type.is_none() {
+                    content_type = field.content_type().map(str::to_string);
+                }
+                file_bytes = Some(field.bytes().await.map_err(|e| AppError(e.to_string()))?.to_vec());
+            }
+            _ => {
+                let _ = field.bytes().await;
+            }
+        }
+    }
+
+    let connection_id = connection_id.ok_or_else(|| AppError("Missing connectionId".to_string()))?;
+    let database = database.ok_or_else(|| AppError("Missing database".to_string()))?;
+    let bucket = bucket.ok_or_else(|| AppError("Missing bucket".to_string()))?;
+    let file_name = file_name.ok_or_else(|| AppError("Missing fileName".to_string()))?;
+    let file_bytes = file_bytes.ok_or_else(|| AppError("No file uploaded".to_string()))?;
+
+    ensure_writable(&state.app, &connection_id, "Upload GridFS file").await?;
+    let result = dbx_core::document_ops::upload_gridfs_file_core(
+        &state.app,
+        &connection_id,
+        &database,
+        &bucket,
+        &file_name,
+        &file_bytes,
+        content_type.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn delete_gridfs_file(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<GridFsFileDeleteRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete GridFS file").await?;
+    dbx_core::document_ops::delete_gridfs_file_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.bucket,
+        &req.file_id,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(()))
+}
diff --git a/crates/dbx-web/src/routes/etcd.rs b/crates/dbx-web/src/routes/etcd.rs
new file mode 100644
index 0000000..3a19871
--- /dev/null
+++ b/crates/dbx-web/src/routes/etcd.rs
@@ -0,0 +1,93 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+/// Check if a connection is read-only and return an error if so.
+async fn ensure_writable(
+    app: &dbx_core::connection::AppState,
+    connection_id: &str,
+    action: &str,
+) -> Result<(), AppError> {
+    if let Some(name) = dbx_core::query::connection_readonly_name(app, connection_id).await {
+        return Err(AppError(format!(
+            "Read-only mode: connection '{}' has read-only protection enabled. {} blocked.",
+            name, action
+        )));
+    }
+    Ok(())
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EtcdListPrefixRequest {
+    pub connection_id: String,
+    pub prefix: String,
+    pub limit: usize,
+    pub continuation: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EtcdKeyRequest {
+    pub connection_id: String,
+    pub key: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EtcdPutRequest {
+    pub connection_id: String,
+    pub key: String,
+    pub value: dbx_core::agent_kv::KvValue,
+    pub lease: Option<i64>,
+}
+
+pub async fn list_prefix(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<EtcdListPrefixRequest>,
+) -> Result<Json<dbx_core::agent_kv::KvListPrefixResponse>, AppError> {
+    let result = dbx_core::agent_kv::kv_list_prefix_core(
+        &state.app,
+        &req.connection_id,
+        &req.prefix,
+        req.limit,
+        req.continuation.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn get(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<EtcdKeyRequest>,
+) -> Result<Json<dbx_core::agent_kv::KvGetResponse>, AppError> {
+    let result = dbx_core::agent_kv::kv_get_core(&state.app, &req.connection_id, &req.key).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn put(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<EtcdPutRequest>,
+) -> Result<Json<dbx_core::agent_kv::KvPutResponse>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Put").await?;
+    let result = dbx_core::agent_kv::kv_put_core(&state.app, &req.connection_id, &req.key, req.value, req.lease)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn delete(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<EtcdKeyRequest>,
+) -> Result<Json<dbx_core::agent_kv::KvDeleteResponse>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete").await?;
+    let result =
+        dbx_core::agent_kv::kv_delete_core(&state.app, &req.connection_id, &req.key).await.map_err(AppError)?;
+    Ok(Json(result))
+}
diff --git a/crates/dbx-web/src/routes/history.rs b/crates/dbx-web/src/routes/history.rs
new file mode 100644
index 0000000..972b877
--- /dev/null
+++ b/crates/dbx-web/src/routes/history.rs
@@ -0,0 +1,53 @@
+use std::sync::Arc;
+
+use axum::extract::{Path, Query, State};
+use axum::Json;
+use dbx_core::history::HistoryEntry;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+pub struct HistoryQuery {
+    pub limit: Option<usize>,
+    pub offset: Option<usize>,
+    pub activity_kind: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveHistoryRequest {
+    pub entry: HistoryEntry,
+}
+
+pub async fn save_history(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<SaveHistoryRequest>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.save_history_entry(&body.entry).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn load_history(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<HistoryQuery>,
+) -> Result<Json<Vec<HistoryEntry>>, AppError> {
+    let limit = q.limit.unwrap_or(100);
+    let offset = q.offset.unwrap_or(0);
+    let entries = state.app.storage.load_history_entries(limit, offset, q.activity_kind).await.map_err(AppError)?;
+    Ok(Json(entries))
+}
+
+pub async fn clear_history(State(state): State<Arc<WebState>>) -> Result<Json<()>, AppError> {
+    state.app.storage.clear_history().await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn delete_history_entry(
+    State(state): State<Arc<WebState>>,
+    Path(id): Path<String>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.delete_history_entry(&id).await.map_err(AppError)?;
+    Ok(Json(()))
+}
diff --git a/crates/dbx-web/src/routes/jdbc.rs b/crates/dbx-web/src/routes/jdbc.rs
new file mode 100644
index 0000000..db0589f
--- /dev/null
+++ b/crates/dbx-web/src/routes/jdbc.rs
@@ -0,0 +1,210 @@
+use std::path::{Component, Path as FsPath};
+use std::sync::Arc;
+
+use axum::extract::{Multipart, Path, State};
+use axum::Json;
+use dbx_core::agent_service::AgentProgressEvent;
+use dbx_core::jdbc::{
+    self, JdbcDriverInfo, JdbcLocalBundleInfo, JdbcMavenBundleInfo, JdbcMavenInstallRequest, JdbcPluginStatus,
+};
+use dbx_core::plugins::PluginRuntimeEnv;
+use tokio::sync::broadcast;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+fn safe_upload_file_name(file_name: Option<&str>, fallback: &str, extension: &str) -> Result<String, AppError> {
+    let file_name = file_name.unwrap_or(fallback);
+    let mut components = FsPath::new(file_name).components();
+    let is_single_normal_component =
+        matches!(components.next(), Some(Component::Normal(_))) && components.next().is_none();
+    if !is_single_normal_component
+        || file_name.contains(['/', '\\'])
+        || !file_name.to_ascii_lowercase().ends_with(extension)
+    {
+        return Err(AppError::bad_request("Invalid upload file name"));
+    }
+    Ok(file_name.to_string())
+}
+
+// ---- JDBC Drivers ----
+
+pub async fn list_jdbc_drivers(State(state): State<Arc<WebState>>) -> Result<Json<Vec<JdbcDriverInfo>>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::list_jdbc_drivers(root).map_err(AppError::internal)?))
+}
+
+pub async fn list_jdbc_maven_bundles(
+    State(state): State<Arc<WebState>>,
+) -> Result<Json<Vec<JdbcMavenBundleInfo>>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::list_jdbc_maven_bundles(root).map_err(AppError::internal)?))
+}
+
+pub async fn list_jdbc_local_bundles(
+    State(state): State<Arc<WebState>>,
+) -> Result<Json<Vec<JdbcLocalBundleInfo>>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::list_jdbc_local_bundles(root).map_err(AppError::internal)?))
+}
+
+pub async fn install_jdbc_driver_from_maven(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<JdbcMavenInstallRequest>,
+) -> Result<Json<Vec<JdbcDriverInfo>>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(
+        jdbc::install_jdbc_driver_from_maven(root, req, PluginRuntimeEnv::default())
+            .await
+            .map_err(AppError::internal)?,
+    ))
+}
+
+pub async fn install_prestosql_jdbc_driver(
+    State(state): State<Arc<WebState>>,
+) -> Result<Json<Vec<JdbcDriverInfo>>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::install_prestosql_jdbc_driver(root).await.map_err(AppError::internal)?))
+}
+
+pub async fn import_jdbc_drivers(
+    State(state): State<Arc<WebState>>,
+    mut multipart: Multipart,
+) -> Result<Json<Vec<JdbcDriverInfo>>, AppError> {
+    let root = state.app.plugins.root_dir();
+    let upload_dir = root.join("jdbc").join("upload_tmp").join(uuid::Uuid::new_v4().simple().to_string());
+    std::fs::create_dir_all(&upload_dir).map_err(|e| AppError::internal(e.to_string()))?;
+
+    let mut imported = Vec::new();
+    while let Ok(Some(field)) = multipart.next_field().await {
+        let file_name = safe_upload_file_name(field.file_name(), "driver.jar", ".jar")?;
+        let data = field.bytes().await.map_err(|e| AppError::internal(e.to_string()))?;
+        let target = jdbc::unique_target_path(&upload_dir, &file_name);
+        std::fs::write(&target, &data).map_err(|e| AppError::internal(e.to_string()))?;
+        imported.push(target);
+    }
+    if imported.is_empty() {
+        let _ = std::fs::remove_dir_all(&upload_dir);
+        return Err(AppError::bad_request("No file uploaded"));
+    }
+    let paths = imported.iter().map(|path| path.to_string_lossy().to_string()).collect::<Vec<_>>();
+    let result = jdbc::import_jdbc_drivers(root, &paths).map(Json).map_err(AppError::internal);
+    let _ = std::fs::remove_dir_all(&upload_dir);
+    result
+}
+
+pub async fn delete_jdbc_driver(
+    State(state): State<Arc<WebState>>,
+    Path(name): Path<String>,
+) -> Result<Json<Vec<JdbcDriverInfo>>, AppError> {
+    if name.contains("..") || name.contains('/') || name.contains('\\') {
+        return Err(AppError::bad_request("Invalid driver name"));
+    }
+    let root = state.app.plugins.root_dir();
+    let driver_path = root.join("jdbc").join("drivers").join(&name);
+    let path_str = driver_path.to_string_lossy().to_string();
+    Ok(Json(jdbc::delete_jdbc_driver(root, &path_str).map_err(AppError::internal)?))
+}
+
+pub async fn delete_jdbc_maven_bundle(
+    State(state): State<Arc<WebState>>,
+    Path(bundle_id): Path<String>,
+) -> Result<Json<Vec<JdbcDriverInfo>>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::delete_jdbc_maven_bundle(root, &bundle_id).map_err(AppError::internal)?))
+}
+
+pub async fn delete_jdbc_local_bundle(
+    State(state): State<Arc<WebState>>,
+    Path(bundle_id): Path<String>,
+) -> Result<Json<Vec<JdbcDriverInfo>>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::delete_jdbc_local_bundle(root, &bundle_id).map_err(AppError::internal)?))
+}
+
+// ---- JDBC Plugin ----
+
+pub async fn get_jdbc_plugin_status(State(state): State<Arc<WebState>>) -> Result<Json<JdbcPluginStatus>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::get_jdbc_plugin_status(root).await.map_err(AppError::internal)?))
+}
+
+pub async fn install_jdbc_plugin(State(state): State<Arc<WebState>>) -> Result<Json<JdbcPluginStatus>, AppError> {
+    let root = state.app.plugins.root_dir();
+    let tx = progress_sender(&state, "global").await;
+    Ok(Json(
+        jdbc::install_jdbc_plugin_with_progress(root, |event| send_progress_event(&tx, event))
+            .await
+            .map_err(AppError::internal)?,
+    ))
+}
+
+pub async fn install_jdbc_plugin_local(
+    State(state): State<Arc<WebState>>,
+    mut multipart: Multipart,
+) -> Result<Json<JdbcPluginStatus>, AppError> {
+    let root = state.app.plugins.root_dir();
+    let temp_dir = root.join("jdbc").with_extension("upload_tmp");
+    std::fs::create_dir_all(&temp_dir).map_err(|e| AppError::internal(e.to_string()))?;
+
+    if let Ok(Some(field)) = multipart.next_field().await {
+        let file_name = safe_upload_file_name(field.file_name(), "plugin.zip", ".zip")?;
+        let data = field.bytes().await.map_err(|e| AppError::internal(e.to_string()))?;
+        let tmp_path = temp_dir.join(&file_name);
+        std::fs::write(&tmp_path, &data).map_err(|e| AppError::internal(e.to_string()))?;
+        let result =
+            jdbc::install_jdbc_plugin_from_file(root, &tmp_path.to_string_lossy()).await.map_err(AppError::internal)?;
+        let _ = std::fs::remove_dir_all(&temp_dir);
+        return Ok(Json(result));
+    }
+
+    Err(AppError::bad_request("No file uploaded"))
+}
+
+pub async fn uninstall_jdbc_plugin(State(state): State<Arc<WebState>>) -> Result<Json<JdbcPluginStatus>, AppError> {
+    let root = state.app.plugins.root_dir();
+    Ok(Json(jdbc::uninstall_jdbc_plugin(root).map_err(AppError::internal)?))
+}
+
+// ---- System Fonts ----
+
+pub async fn list_system_fonts() -> Result<Json<Vec<String>>, AppError> {
+    Ok(Json(jdbc::list_system_fonts()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::safe_upload_file_name;
+
+    #[test]
+    fn upload_file_name_rejects_path_components() {
+        for value in ["../driver.jar", "sub/driver.jar", r"sub\driver.jar", "/tmp/driver.jar"] {
+            assert!(safe_upload_file_name(Some(value), "driver.jar", ".jar").is_err(), "{value}");
+        }
+    }
+
+    #[test]
+    fn upload_file_name_accepts_plain_expected_extension() {
+        let Ok(file_name) = safe_upload_file_name(Some("postgresql-42.7.jar"), "driver.jar", ".jar") else {
+            panic!("plain JAR filename should be accepted");
+        };
+        assert_eq!(file_name, "postgresql-42.7.jar");
+    }
+}
+
+async fn progress_sender(state: &WebState, operation_id: &str) -> broadcast::Sender<String> {
+    let mut channels = state.sse_channels.write().await;
+    channels
+        .entry(format!("agent-install-progress:{operation_id}"))
+        .or_insert_with(|| {
+            let (tx, _) = broadcast::channel::<String>(256);
+            tx
+        })
+        .clone()
+}
+
+fn send_progress_event(tx: &broadcast::Sender<String>, event: AgentProgressEvent) {
+    if let Ok(payload) = serde_json::to_string(&event) {
+        let _ = tx.send(payload);
+    }
+}
diff --git a/crates/dbx-web/src/routes/layout.rs b/crates/dbx-web/src/routes/layout.rs
new file mode 100644
index 0000000..afc9b0d
--- /dev/null
+++ b/crates/dbx-web/src/routes/layout.rs
@@ -0,0 +1,27 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveLayoutRequest {
+    pub layout: serde_json::Value,
+}
+
+pub async fn save_sidebar_layout(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<SaveLayoutRequest>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.save_sidebar_layout(&body.layout).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn load_sidebar_layout(State(state): State<Arc<WebState>>) -> Result<Json<serde_json::Value>, AppError> {
+    let layout = state.app.storage.load_sidebar_layout().await.map_err(AppError)?;
+    Ok(Json(layout.unwrap_or(serde_json::json!(null))))
+}
diff --git a/crates/dbx-web/src/routes/mod.rs b/crates/dbx-web/src/routes/mod.rs
new file mode 100644
index 0000000..6141209
--- /dev/null
+++ b/crates/dbx-web/src/routes/mod.rs
@@ -0,0 +1,35 @@
+pub mod agents;
+pub mod ai;
+pub mod app_settings;
+pub mod cloud_sync;
+pub mod connection;
+pub mod data_compare;
+pub mod database_export;
+pub mod document_store;
+pub mod etcd;
+pub mod history;
+pub mod jdbc;
+pub mod layout;
+pub mod mongo;
+#[cfg(feature = "mq-admin")]
+pub mod mq;
+pub mod nacos;
+pub mod plugins;
+pub mod query;
+pub mod query_result_export;
+pub mod redis;
+pub mod redis_pubsub_ws;
+pub mod saved_sql;
+pub mod schema;
+pub mod schema_cache;
+pub mod schema_diff;
+pub mod sql_file;
+pub mod ssh_config;
+pub mod tab_runtime_cache;
+pub mod table_export;
+pub mod table_import;
+pub mod text_export;
+pub mod transfer;
+pub mod tunnel_profiles;
+pub mod update;
+pub mod zookeeper;
diff --git a/crates/dbx-web/src/routes/mongo.rs b/crates/dbx-web/src/routes/mongo.rs
new file mode 100644
index 0000000..5dd25c0
--- /dev/null
+++ b/crates/dbx-web/src/routes/mongo.rs
@@ -0,0 +1,484 @@
+use std::future::Future;
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+async fn run_cancellable<T, F>(state: &Arc<WebState>, execution_id: Option<String>, future: F) -> Result<T, AppError>
+where
+    F: Future<Output = Result<T, String>>,
+{
+    let registered = execution_id
+        .as_ref()
+        .filter(|id| !id.trim().is_empty())
+        .map(|id| state.app.running_queries.register(id.clone()));
+    if let Some(query) = registered.as_ref() {
+        let token = query.token();
+        tokio::select! {
+            biased;
+            _ = token.cancelled() => Err(AppError(dbx_core::query::canceled_error())),
+            result = future => result.map_err(AppError),
+        }
+    } else {
+        future.await.map_err(AppError)
+    }
+}
+
+/// Check if a connection is read-only and return an error if so.
+async fn ensure_writable(
+    app: &dbx_core::connection::AppState,
+    connection_id: &str,
+    action: &str,
+) -> Result<(), AppError> {
+    if let Some(name) = dbx_core::query::connection_readonly_name(app, connection_id).await {
+        return Err(AppError(format!(
+            "Read-only mode: connection '{}' has read-only protection enabled. {} blocked.",
+            name, action
+        )));
+    }
+    Ok(())
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoConnectionRequest {
+    pub connection_id: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoCollectionRequest {
+    pub connection_id: String,
+    pub database: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoCollectionNameRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoFindRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub skip: Option<u64>,
+    pub limit: Option<i64>,
+    pub filter: Option<String>,
+    pub projection: Option<String>,
+    pub sort: Option<String>,
+    pub execution_id: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoServerVersionRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub execution_id: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoCollectionStatsRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub scale: Option<serde_json::Number>,
+    pub execution_id: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoAggregateRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub pipeline_json: String,
+    pub max_rows: Option<usize>,
+    pub execution_id: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoCreateIndexRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub keys_json: String,
+    pub options_json: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoDropIndexesRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub indexes_json: Option<String>,
+    pub single: bool,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoInsertRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub doc_json: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoInsertDocumentsRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub docs_json: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoUpdateDocumentsRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub filter_json: String,
+    pub update_json: String,
+    pub many: bool,
+    pub options_json: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoDeleteDocumentsRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub filter_json: String,
+    pub many: bool,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoUpdateRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub id: String,
+    pub doc_json: String,
+    pub routing: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MongoDeleteRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+    pub id: String,
+    pub routing: Option<String>,
+}
+
+pub async fn list_databases(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoConnectionRequest>,
+) -> Result<Json<Vec<String>>, AppError> {
+    let result =
+        dbx_core::mongo_ops::mongo_list_databases_core(&state.app, &req.connection_id).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_collections(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoCollectionRequest>,
+) -> Result<Json<Vec<dbx_core::document_ops::CollectionInfo>>, AppError> {
+    let result = dbx_core::mongo_ops::mongo_list_collections_core(&state.app, &req.connection_id, &req.database)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VectorCollectionDetailRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub collection: String,
+}
+
+pub async fn vector_collection_detail(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<VectorCollectionDetailRequest>,
+) -> Result<Json<dbx_core::db::vector_driver::CollectionInfo>, AppError> {
+    let result = dbx_core::schema::get_vector_collection_detail_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn create_database(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoCollectionRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Create database").await?;
+    dbx_core::mongo_ops::mongo_create_database_core(&state.app, &req.connection_id, &req.database)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "ok": true })))
+}
+
+pub async fn drop_database(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoCollectionRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Drop database").await?;
+    dbx_core::mongo_ops::mongo_drop_database_core(&state.app, &req.connection_id, &req.database)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "ok": true })))
+}
+
+pub async fn drop_collection(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoCollectionNameRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Drop collection").await?;
+    dbx_core::mongo_ops::mongo_drop_collection_core(&state.app, &req.connection_id, &req.database, &req.collection)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "ok": true })))
+}
+
+pub async fn find_documents(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoFindRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = run_cancellable(
+        &state,
+        req.execution_id.clone(),
+        dbx_core::document_ops::find_documents_core(
+            &state.app,
+            &req.connection_id,
+            &req.database,
+            &req.collection,
+            req.skip.unwrap_or(0),
+            req.limit.unwrap_or(50),
+            req.filter.as_deref(),
+            req.projection.as_deref(),
+            req.sort.as_deref(),
+        ),
+    )
+    .await?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn server_version(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoServerVersionRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = run_cancellable(
+        &state,
+        req.execution_id.clone(),
+        dbx_core::mongo_ops::mongo_server_version_core(&state.app, &req.connection_id, &req.database),
+    )
+    .await?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn collection_stats(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoCollectionStatsRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = run_cancellable(
+        &state,
+        req.execution_id.clone(),
+        dbx_core::mongo_ops::mongo_collection_stats_core(
+            &state.app,
+            &req.connection_id,
+            &req.database,
+            &req.collection,
+            req.scale,
+        ),
+    )
+    .await?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn aggregate_documents(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoAggregateRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = run_cancellable(
+        &state,
+        req.execution_id.clone(),
+        dbx_core::mongo_ops::mongo_aggregate_documents_core(
+            &state.app,
+            &req.connection_id,
+            &req.database,
+            &req.collection,
+            &req.pipeline_json,
+            req.max_rows,
+        ),
+    )
+    .await?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn create_index(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoCreateIndexRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Create index").await?;
+    let name = dbx_core::mongo_ops::mongo_create_index_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+        &req.keys_json,
+        req.options_json.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "name": name })))
+}
+
+pub async fn drop_indexes(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoDropIndexesRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Drop indexes").await?;
+    let result = dbx_core::mongo_ops::mongo_drop_indexes_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+        req.indexes_json.as_deref(),
+        req.single,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn insert_document(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoInsertRequest>,
+) -> Result<Json<String>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Insert").await?;
+    let result = dbx_core::document_ops::insert_document_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+        &req.doc_json,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn insert_documents(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoInsertDocumentsRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Insert").await?;
+    let result = dbx_core::mongo_ops::mongo_insert_documents_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+        &req.docs_json,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "affected_rows": result })))
+}
+
+pub async fn update_document(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoUpdateRequest>,
+) -> Result<Json<u64>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Update").await?;
+    let result = dbx_core::document_ops::update_document_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+        &req.id,
+        &req.doc_json,
+        req.routing.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn update_documents(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoUpdateDocumentsRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Update").await?;
+    let result = dbx_core::mongo_ops::mongo_update_documents_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+        &req.filter_json,
+        &req.update_json,
+        req.many,
+        req.options_json.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "affected_rows": result })))
+}
+
+pub async fn delete_document(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoDeleteRequest>,
+) -> Result<Json<u64>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete").await?;
+    let result = dbx_core::document_ops::delete_document_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+        &req.id,
+        req.routing.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn delete_documents(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<MongoDeleteDocumentsRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete").await?;
+    let result = dbx_core::mongo_ops::mongo_delete_documents_core(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.collection,
+        &req.filter_json,
+        req.many,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "affected_rows": result })))
+}
diff --git a/crates/dbx-web/src/routes/mq.rs b/crates/dbx-web/src/routes/mq.rs
new file mode 100644
index 0000000..9be3c27
--- /dev/null
+++ b/crates/dbx-web/src/routes/mq.rs
@@ -0,0 +1,752 @@
+//! Web (Axum) routes for message queue admin operations.
+//!
+//! Mirrors the desktop command layer, sharing the same `dbx_core::mq::service::*_core`
+//! functions, with read-only protection for mutating operations.
+
+use axum::extract::State;
+use axum::Json;
+use std::sync::Arc;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+// Request wrappers for endpoints that need more than just connection_id.
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ConnReq {
+    connection_id: String,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct TenantReq {
+    connection_id: String,
+    name: String,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct CreateTenantReq {
+    connection_id: String,
+    name: String,
+    config: dbx_core::mq::TenantConfig,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct UpdateTenantReq {
+    connection_id: String,
+    name: String,
+    config: dbx_core::mq::TenantConfig,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct DeleteTenantReq {
+    connection_id: String,
+    name: String,
+    #[serde(default)]
+    force: bool,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ListNamespacesReq {
+    connection_id: String,
+    tenant: String,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct CreateNamespaceReq {
+    connection_id: String,
+    ns: dbx_core::mq::NamespaceRef,
+    config: dbx_core::mq::NamespaceConfig,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct DeleteNamespaceReq {
+    connection_id: String,
+    ns: dbx_core::mq::NamespaceRef,
+    #[serde(default)]
+    force: bool,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct NamespacePoliciesReq {
+    connection_id: String,
+    ns: dbx_core::mq::NamespaceRef,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ListTopicsReq {
+    connection_id: String,
+    ns: dbx_core::mq::NamespaceRef,
+    opts: dbx_core::mq::ListTopicsOpts,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct CreateTopicReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    partitions: Option<u32>,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct DeleteTopicReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    #[serde(default)]
+    force: bool,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct UpdatePartitionsReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    partitions: u32,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct TopicReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct CreateSubscriptionReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    pos: dbx_core::mq::ResetPosition,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct DeleteSubscriptionReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    #[serde(default)]
+    force: bool,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct SkipMessagesReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    count: dbx_core::mq::SkipCount,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ResetCursorReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    pos: dbx_core::mq::ResetPosition,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct SubscriptionReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct PeekMessagesReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    count: u32,
+    #[serde(default)]
+    options: Option<dbx_core::mq::PeekMessagesOptions>,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ExpireMessagesReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    expire_seconds: i64,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct SetPublishRateReq {
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    rate: dbx_core::mq::PublishRate,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct SetDispatchRateReq {
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    rate: dbx_core::mq::DispatchRate,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct SetSubscribeRateReq {
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    rate: dbx_core::mq::SubscribeRate,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct SetBacklogQuotaReq {
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    quota: dbx_core::mq::BacklogQuota,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct SetRetentionReq {
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    retention: dbx_core::mq::RetentionPolicy,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct PolicyScopeReq {
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct GrantPermissionReq {
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    role: String,
+    actions: Vec<dbx_core::mq::AuthAction>,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct RevokePermissionReq {
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    role: String,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct IssueTokenReq {
+    connection_id: String,
+    req: dbx_core::mq::MqTokenIssueRequest,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ListTokenRecordsReq {
+    connection_id: String,
+    subject: Option<String>,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct BacklogReq {
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: Option<String>,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct RawRequestReq {
+    connection_id: String,
+    req: dbx_core::mq::MqRawRequest,
+}
+
+// ---- Helper: writable check ----
+
+async fn ensure_writable(app: &dbx_core::connection::AppState, conn_id: &str, action: &str) -> Result<(), AppError> {
+    if let Some(name) = dbx_core::query::connection_readonly_name(app, conn_id).await {
+        return Err(AppError(format!("Read-only connection '{name}'. {action} is blocked.")));
+    }
+    Ok(())
+}
+
+// ---- Handlers ----
+
+pub async fn test_connection(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ConnReq>,
+) -> Result<Json<dbx_core::mq::MqClusterInfo>, AppError> {
+    let result =
+        dbx_core::mq::service::mq_test_connection_core(&state.app, &req.connection_id).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_tenants(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ConnReq>,
+) -> Result<Json<Vec<dbx_core::mq::TenantInfo>>, AppError> {
+    let result = dbx_core::mq::service::mq_list_tenants_core(&state.app, &req.connection_id).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn get_tenant(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<TenantReq>,
+) -> Result<Json<dbx_core::mq::TenantInfo>, AppError> {
+    let result =
+        dbx_core::mq::service::mq_get_tenant_core(&state.app, &req.connection_id, &req.name).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn create_tenant(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<CreateTenantReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Create tenant").await?;
+    dbx_core::mq::service::mq_create_tenant_core(&state.app, &req.connection_id, &req.name, req.config)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn update_tenant(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<UpdateTenantReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Update tenant").await?;
+    dbx_core::mq::service::mq_update_tenant_core(&state.app, &req.connection_id, &req.name, req.config)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn delete_tenant(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DeleteTenantReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete tenant").await?;
+    dbx_core::mq::service::mq_delete_tenant_core(&state.app, &req.connection_id, &req.name, req.force)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn list_namespaces(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ListNamespacesReq>,
+) -> Result<Json<Vec<dbx_core::mq::NamespaceInfo>>, AppError> {
+    let result = dbx_core::mq::service::mq_list_namespaces_core(&state.app, &req.connection_id, &req.tenant)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn create_namespace(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<CreateNamespaceReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Create namespace").await?;
+    dbx_core::mq::service::mq_create_namespace_core(&state.app, &req.connection_id, req.ns, req.config)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn delete_namespace(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DeleteNamespaceReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete namespace").await?;
+    dbx_core::mq::service::mq_delete_namespace_core(&state.app, &req.connection_id, req.ns, req.force)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn get_namespace_policies(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<NamespacePoliciesReq>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = dbx_core::mq::service::mq_get_namespace_policies_core(&state.app, &req.connection_id, req.ns)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_topics(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ListTopicsReq>,
+) -> Result<Json<Vec<dbx_core::mq::TopicInfo>>, AppError> {
+    let result = dbx_core::mq::service::mq_list_topics_core(&state.app, &req.connection_id, req.ns, req.opts)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn create_topic(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<CreateTopicReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Create topic").await?;
+    dbx_core::mq::service::mq_create_topic_core(&state.app, &req.connection_id, req.topic, req.partitions)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn delete_topic(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DeleteTopicReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete topic").await?;
+    dbx_core::mq::service::mq_delete_topic_core(&state.app, &req.connection_id, req.topic, req.force)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn update_partitions(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<UpdatePartitionsReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Update partitions").await?;
+    dbx_core::mq::service::mq_update_partitions_core(&state.app, &req.connection_id, req.topic, req.partitions)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn get_topic_stats(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<TopicReq>,
+) -> Result<Json<dbx_core::mq::TopicStats>, AppError> {
+    let result = dbx_core::mq::service::mq_get_topic_stats_core(&state.app, &req.connection_id, req.topic)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn get_topic_internal_stats(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<TopicReq>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = dbx_core::mq::service::mq_get_topic_internal_stats_core(&state.app, &req.connection_id, req.topic)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_subscriptions(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<TopicReq>,
+) -> Result<Json<Vec<dbx_core::mq::SubscriptionInfo>>, AppError> {
+    let result = dbx_core::mq::service::mq_list_subscriptions_core(&state.app, &req.connection_id, req.topic)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn create_subscription(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<CreateSubscriptionReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Create subscription").await?;
+    dbx_core::mq::service::mq_create_subscription_core(&state.app, &req.connection_id, req.topic, req.sub, req.pos)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn delete_subscription(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<DeleteSubscriptionReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete subscription").await?;
+    dbx_core::mq::service::mq_delete_subscription_core(&state.app, &req.connection_id, req.topic, req.sub, req.force)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn skip_messages(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SkipMessagesReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Skip messages").await?;
+    dbx_core::mq::service::mq_skip_messages_core(&state.app, &req.connection_id, req.topic, req.sub, req.count)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn reset_cursor(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ResetCursorReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Reset cursor").await?;
+    dbx_core::mq::service::mq_reset_cursor_core(&state.app, &req.connection_id, req.topic, req.sub, req.pos)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn clear_backlog(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SubscriptionReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Clear backlog").await?;
+    dbx_core::mq::service::mq_clear_backlog_core(&state.app, &req.connection_id, req.topic, req.sub)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn peek_messages(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<PeekMessagesReq>,
+) -> Result<Json<Vec<dbx_core::mq::PeekedMessage>>, AppError> {
+    let result = dbx_core::mq::service::mq_peek_messages_core(
+        &state.app,
+        &req.connection_id,
+        req.topic,
+        req.sub,
+        req.count,
+        req.options,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn expire_messages(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ExpireMessagesReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Expire messages").await?;
+    dbx_core::mq::service::mq_expire_messages_core(
+        &state.app,
+        &req.connection_id,
+        req.topic,
+        req.sub,
+        req.expire_seconds,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn list_producers(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<TopicReq>,
+) -> Result<Json<Vec<dbx_core::mq::ProducerInfo>>, AppError> {
+    let result = dbx_core::mq::service::mq_list_producers_core(&state.app, &req.connection_id, req.topic)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_consumers(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SubscriptionReq>,
+) -> Result<Json<Vec<dbx_core::mq::ConsumerInfo>>, AppError> {
+    let result = dbx_core::mq::service::mq_list_consumers_core(&state.app, &req.connection_id, req.topic, req.sub)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn unload_topic(State(state): State<Arc<WebState>>, Json(req): Json<TopicReq>) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Unload topic").await?;
+    dbx_core::mq::service::mq_unload_topic_core(&state.app, &req.connection_id, req.topic).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn set_publish_rate(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SetPublishRateReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Set publish rate").await?;
+    dbx_core::mq::service::mq_set_publish_rate_core(&state.app, &req.connection_id, req.scope, req.rate)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn set_dispatch_rate(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SetDispatchRateReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Set dispatch rate").await?;
+    dbx_core::mq::service::mq_set_dispatch_rate_core(&state.app, &req.connection_id, req.scope, req.rate)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn set_subscribe_rate(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SetSubscribeRateReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Set subscribe rate").await?;
+    dbx_core::mq::service::mq_set_subscribe_rate_core(&state.app, &req.connection_id, req.scope, req.rate)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn set_backlog_quota(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SetBacklogQuotaReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Set backlog quota").await?;
+    dbx_core::mq::service::mq_set_backlog_quota_core(&state.app, &req.connection_id, req.scope, req.quota)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn set_retention(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SetRetentionReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Set retention").await?;
+    dbx_core::mq::service::mq_set_retention_core(&state.app, &req.connection_id, req.scope, req.retention)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn get_effective_policies(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<PolicyScopeReq>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = dbx_core::mq::service::mq_get_effective_policies_core(&state.app, &req.connection_id, req.scope)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn grant_permission(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<GrantPermissionReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Grant permission").await?;
+    dbx_core::mq::service::mq_grant_permission_core(&state.app, &req.connection_id, req.scope, req.role, req.actions)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn revoke_permission(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RevokePermissionReq>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Revoke permission").await?;
+    dbx_core::mq::service::mq_revoke_permission_core(&state.app, &req.connection_id, req.scope, req.role)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn list_permissions(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<PolicyScopeReq>,
+) -> Result<Json<dbx_core::mq::PermissionMap>, AppError> {
+    let result = dbx_core::mq::service::mq_list_permissions_core(&state.app, &req.connection_id, req.scope)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn issue_token(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<IssueTokenReq>,
+) -> Result<Json<dbx_core::mq::MqIssuedToken>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Issue MQ token").await?;
+    let result =
+        dbx_core::mq::service::mq_issue_token_core(&state.app, &req.connection_id, req.req).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_token_records(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ListTokenRecordsReq>,
+) -> Result<Json<Vec<dbx_core::mq::MqTokenRecord>>, AppError> {
+    let result = dbx_core::mq::service::mq_list_token_records_core(&state.app, &req.connection_id, req.subject)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn get_backlog(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<BacklogReq>,
+) -> Result<Json<dbx_core::mq::BacklogStats>, AppError> {
+    let result = dbx_core::mq::service::mq_get_backlog_core(&state.app, &req.connection_id, req.topic, req.sub)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ClusterInfoReq {
+    connection_id: String,
+}
+
+pub async fn get_cluster_info(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ClusterInfoReq>,
+) -> Result<Json<dbx_core::mq::ClusterInfo>, AppError> {
+    let result =
+        dbx_core::mq::service::mq_get_cluster_info_core(&state.app, &req.connection_id).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn raw_request(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RawRequestReq>,
+) -> Result<Json<dbx_core::mq::MqRawResponse>, AppError> {
+    if req.req.is_mutating() {
+        ensure_writable(&state.app, &req.connection_id, "MQ admin write").await?;
+    }
+    let result =
+        dbx_core::mq::service::mq_raw_request_core(&state.app, &req.connection_id, req.req).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+// ---- Message production ----
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct SendMessageReq {
+    connection_id: String,
+    req: dbx_core::mq::SendMessageRequest,
+}
+
+pub async fn send_message(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SendMessageReq>,
+) -> Result<Json<dbx_core::mq::SendMessageResponse>, AppError> {
+    let result =
+        dbx_core::mq::service::mq_send_message_core(&state.app, &req.connection_id, req.req).await.map_err(AppError)?;
+    Ok(Json(result))
+}
diff --git a/crates/dbx-web/src/routes/nacos.rs b/crates/dbx-web/src/routes/nacos.rs
new file mode 100644
index 0000000..67a8506
--- /dev/null
+++ b/crates/dbx-web/src/routes/nacos.rs
@@ -0,0 +1,245 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ConnReq {
+    connection_id: String,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct NamespaceCreateReq {
+    connection_id: String,
+    req: dbx_core::nacos::NacosNamespaceCreate,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct NamespaceUpdateReq {
+    connection_id: String,
+    req: dbx_core::nacos::NacosNamespaceUpdate,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ConfigListReq {
+    connection_id: String,
+    query: dbx_core::nacos::NacosConfigQuery,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ConfigKeyReq {
+    connection_id: String,
+    key: dbx_core::nacos::NacosConfigKey,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ConfigPublishReq {
+    connection_id: String,
+    req: dbx_core::nacos::NacosConfigUpsert,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ConfigHistoryListReq {
+    connection_id: String,
+    query: dbx_core::nacos::NacosConfigHistoryQuery,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ConfigHistoryKeyReq {
+    connection_id: String,
+    key: dbx_core::nacos::NacosConfigHistoryKey,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ConfigRollbackReq {
+    connection_id: String,
+    req: dbx_core::nacos::NacosConfigRollbackRequest,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct ServiceListReq {
+    connection_id: String,
+    query: dbx_core::nacos::NacosServiceQuery,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct InstanceListReq {
+    connection_id: String,
+    query: dbx_core::nacos::NacosInstanceQuery,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct InstanceUpdateReq {
+    connection_id: String,
+    req: dbx_core::nacos::NacosInstanceUpdate,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct RawReq {
+    connection_id: String,
+    req: dbx_core::nacos::NacosRawRequest,
+}
+
+pub async fn test_connection(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ConnReq>,
+) -> Result<Json<dbx_core::nacos::NacosConnectionInfo>, AppError> {
+    let result =
+        dbx_core::nacos::service::nacos_test_connection_core(&state.app, &req.connection_id).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_namespaces(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ConnReq>,
+) -> Result<Json<Vec<dbx_core::nacos::NacosNamespaceInfo>>, AppError> {
+    let result =
+        dbx_core::nacos::service::nacos_list_namespaces_core(&state.app, &req.connection_id).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn create_namespace(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<NamespaceCreateReq>,
+) -> Result<Json<()>, AppError> {
+    dbx_core::nacos::service::nacos_create_namespace_core(&state.app, &req.connection_id, req.req)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn update_namespace(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<NamespaceUpdateReq>,
+) -> Result<Json<()>, AppError> {
+    dbx_core::nacos::service::nacos_update_namespace_core(&state.app, &req.connection_id, req.req)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn list_configs(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ConfigListReq>,
+) -> Result<Json<dbx_core::nacos::NacosConfigList>, AppError> {
+    let result = dbx_core::nacos::service::nacos_list_configs_core(&state.app, &req.connection_id, req.query)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn get_config(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ConfigKeyReq>,
+) -> Result<Json<dbx_core::nacos::NacosConfigItem>, AppError> {
+    let result = dbx_core::nacos::service::nacos_get_config_core(&state.app, &req.connection_id, req.key)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn publish_config(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ConfigPublishReq>,
+) -> Result<Json<()>, AppError> {
+    dbx_core::nacos::service::nacos_publish_config_core(&state.app, &req.connection_id, req.req)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn delete_config(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ConfigKeyReq>,
+) -> Result<Json<()>, AppError> {
+    dbx_core::nacos::service::nacos_delete_config_core(&state.app, &req.connection_id, req.key)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn list_config_history(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ConfigHistoryListReq>,
+) -> Result<Json<dbx_core::nacos::NacosConfigHistoryList>, AppError> {
+    let result = dbx_core::nacos::service::nacos_list_config_history_core(&state.app, &req.connection_id, req.query)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn get_config_history(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ConfigHistoryKeyReq>,
+) -> Result<Json<dbx_core::nacos::NacosConfigItem>, AppError> {
+    let result = dbx_core::nacos::service::nacos_get_config_history_core(&state.app, &req.connection_id, req.key)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn rollback_config(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ConfigRollbackReq>,
+) -> Result<Json<()>, AppError> {
+    dbx_core::nacos::service::nacos_rollback_config_core(&state.app, &req.connection_id, req.req)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn list_services(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ServiceListReq>,
+) -> Result<Json<dbx_core::nacos::NacosServiceList>, AppError> {
+    let result = dbx_core::nacos::service::nacos_list_services_core(&state.app, &req.connection_id, req.query)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_instances(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<InstanceListReq>,
+) -> Result<Json<Vec<dbx_core::nacos::NacosInstanceInfo>>, AppError> {
+    let result = dbx_core::nacos::service::nacos_list_instances_core(&state.app, &req.connection_id, req.query)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn update_instance(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<InstanceUpdateReq>,
+) -> Result<Json<()>, AppError> {
+    dbx_core::nacos::service::nacos_update_instance_core(&state.app, &req.connection_id, req.req)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn raw_request(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RawReq>,
+) -> Result<Json<dbx_core::nacos::NacosRawResponse>, AppError> {
+    let result = dbx_core::nacos::service::nacos_raw_request_core(&state.app, &req.connection_id, req.req)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
diff --git a/crates/dbx-web/src/routes/plugins.rs b/crates/dbx-web/src/routes/plugins.rs
new file mode 100644
index 0000000..e7b8c5a
--- /dev/null
+++ b/crates/dbx-web/src/routes/plugins.rs
@@ -0,0 +1,12 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+use dbx_core::plugins::InstalledPlugin;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+pub async fn list_plugins(State(state): State<Arc<WebState>>) -> Result<Json<Vec<InstalledPlugin>>, AppError> {
+    state.app.plugins.list_installed().map(Json).map_err(AppError)
+}
diff --git a/crates/dbx-web/src/routes/query.rs b/crates/dbx-web/src/routes/query.rs
new file mode 100644
index 0000000..e818c9e
--- /dev/null
+++ b/crates/dbx-web/src/routes/query.rs
@@ -0,0 +1,813 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+use dbx_core::query_cancel::RunningTaskMetadata;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExecuteQueryRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub sql: String,
+    pub schema: Option<String>,
+    pub execution_id: Option<String>,
+    pub max_rows: Option<usize>,
+    pub fetch_size: Option<usize>,
+    pub page_size: Option<usize>,
+    pub result_session_id: Option<String>,
+    pub client_session_id: Option<String>,
+    pub timeout_secs: Option<u64>,
+    pub use_transaction: Option<bool>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CancelRequest {
+    pub execution_id: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CloseSessionRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub session_id: String,
+    pub client_session_id: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CloseClientConnectionSessionRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub client_session_id: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExecuteBatchRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub statements: Vec<String>,
+    pub schema: Option<String>,
+    pub timeout_secs: Option<u64>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AnalyzeSqlReferencesRequest {
+    pub sql: String,
+    pub dialect: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AnalyzeEditableQueryRequest {
+    pub sql: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FindStatementAtCursorRequest {
+    pub sql: String,
+    pub cursor_pos: usize,
+    pub database_type: Option<dbx_core::models::connection::DatabaseType>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PrepareQueryPaginationExecutionPlanRequest {
+    pub options: dbx_core::query_result_sql::QueryPaginationExecutionPlanOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildSortedQuerySqlRequest {
+    pub options: dbx_core::query_result_sql::SortedQuerySqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildExplainSqlRequest {
+    pub options: dbx_core::query_execution_sql::ExplainSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDroppedFilePreviewSqlRequest {
+    pub options: dbx_core::query_execution_sql::DroppedFilePreviewSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildTableSelectSqlRequest {
+    pub options: dbx_core::sql_dialect::TableDataSelectSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDatabaseSearchSqlRequest {
+    pub options: dbx_core::database_search_sql::DatabaseSearchSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildSearchResultWhereRequest {
+    pub options: dbx_core::database_search_sql::SearchResultWhereOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildRenameObjectSqlRequest {
+    pub options: dbx_core::db_admin_sql::RenameObjectSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildCreateDatabaseSqlRequest {
+    pub options: dbx_core::db_admin_sql::CreateDatabaseSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDuckDbAttachDatabaseSqlRequest {
+    pub options: dbx_core::db_admin_sql::DuckDbAttachDatabaseSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDropObjectSqlRequest {
+    pub options: dbx_core::db_admin_sql::DropObjectSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildTableAdminSqlRequest {
+    pub options: dbx_core::db_admin_sql::TableAdminSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDropTableChildObjectSqlRequest {
+    pub options: dbx_core::db_admin_sql::DropTableChildObjectSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDatabaseNameSqlRequest {
+    pub options: dbx_core::db_admin_sql::DatabaseNameSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildSchemaNameSqlRequest {
+    pub options: dbx_core::db_admin_sql::SchemaNameSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDatabasePropertyEditSqlRequest {
+    pub options: dbx_core::db_admin_sql::DatabasePropertyEditSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDuplicateTableStructureSqlRequest {
+    pub options: dbx_core::db_admin_sql::DuplicateTableStructureSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildCopyTableDataSqlRequest {
+    pub options: dbx_core::db_admin_sql::CopyTableDataSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildExecutableObjectSourceRequest {
+    pub input: dbx_core::object_source_sql::EditableObjectSourceSqlInput,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildRoutineRenameObjectSourceRequest {
+    pub input: dbx_core::object_source_sql::RoutineRenameObjectSourceInput,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildViewDdlRequest {
+    pub input: dbx_core::object_source_sql::BuildViewDdlInput,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildTableStructureSqlRequest {
+    pub options: dbx_core::table_structure_sql::TableStructureSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PreviewSqliteTableStructureChangeRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub options: dbx_core::table_structure_sql::TableStructureSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ApplySqliteTableStructureChangeRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub options: dbx_core::table_structure_sql::TableStructureSqlOptions,
+    pub schema_revision: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildSingleColumnAlterSqlRequest {
+    pub options: dbx_core::table_structure_sql::SingleColumnAlterSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PrepareDataGridSaveRequest {
+    pub options: dbx_core::data_grid_sql::DataGridSaveStatementOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDataGridCopyUpdateStatementsRequest {
+    pub options: dbx_core::data_grid_sql::DataGridCopyUpdateStatementOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDataGridCopyInsertStatementRequest {
+    pub options: dbx_core::data_grid_sql::DataGridCopyInsertStatementOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDataGridContextFilterConditionRequest {
+    pub options: dbx_core::data_grid_sql::DataGridContextFilterConditionOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDataGridColumnValueFilterConditionRequest {
+    pub options: dbx_core::data_grid_sql::DataGridColumnValueFilterConditionOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDataGridColumnValuesFilterConditionRequest {
+    pub options: dbx_core::data_grid_sql::DataGridColumnValuesFilterConditionOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDataGridColumnDistinctValuesSqlRequest {
+    pub options: dbx_core::data_grid_sql::DataGridColumnDistinctValuesSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDataGridCountSqlRequest {
+    pub options: dbx_core::data_grid_sql::DataGridCountSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildHiveTablePropertiesSqlRequest {
+    pub options: dbx_core::data_grid_sql::HiveTablePropertiesSqlOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildExportInsertStatementsRequest {
+    pub options: dbx_core::database_export::BuildExportInsertStatementsOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildExportSqlInsertRequest {
+    pub options: dbx_core::database_export::BuildExportSqlInsertOptions,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildDatabaseSqlExportRequest {
+    pub options: dbx_core::database_export::BuildDatabaseSqlExportOptions,
+}
+
+pub async fn execute_query(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ExecuteQueryRequest>,
+) -> Result<Json<dbx_core::db::QueryResult>, AppError> {
+    let execution_id = req.execution_id.unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
+
+    let registered = state.app.running_queries.register_task(
+        execution_id.clone(),
+        RunningTaskMetadata::query(req.connection_id.clone(), req.database.clone(), req.client_session_id.clone()),
+    );
+    let cancel_token = registered.token();
+
+    let result = dbx_core::query::execute_sql_statement_with_options(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.sql,
+        req.schema.as_deref(),
+        Some(cancel_token),
+        dbx_core::query::QueryExecutionOptions {
+            max_rows: req.max_rows,
+            fetch_size: req.fetch_size,
+            page_size: req.page_size,
+            result_session_id: req.result_session_id,
+            client_session_id: req.client_session_id,
+            timeout_secs: req.timeout_secs,
+            execution_id: Some(execution_id),
+            use_transaction: req.use_transaction,
+            ..Default::default()
+        },
+    )
+    .await
+    .map_err(AppError)?;
+
+    drop(registered);
+    Ok(Json(result))
+}
+
+pub async fn execute_multi(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ExecuteQueryRequest>,
+) -> Result<Json<Vec<dbx_core::query::ExecuteMultiResult>>, AppError> {
+    let execution_id = req.execution_id.unwrap_or_else(|| uuid::Uuid::new_v4().to_string());
+
+    let registered = state.app.running_queries.register_task(
+        execution_id.clone(),
+        RunningTaskMetadata::query(req.connection_id.clone(), req.database.clone(), req.client_session_id.clone()),
+    );
+    let cancel_token = registered.token();
+
+    let result = dbx_core::query::execute_multi_core_with_options_for_client(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.sql,
+        req.schema.as_deref(),
+        Some(cancel_token),
+        dbx_core::query::QueryExecutionOptions {
+            max_rows: req.max_rows,
+            fetch_size: req.fetch_size,
+            page_size: req.page_size,
+            result_session_id: req.result_session_id,
+            client_session_id: req.client_session_id,
+            timeout_secs: req.timeout_secs,
+            execution_id: Some(execution_id),
+            use_transaction: req.use_transaction,
+            ..Default::default()
+        },
+    )
+    .await
+    .map_err(AppError)?;
+
+    drop(registered);
+    Ok(Json(result))
+}
+
+pub async fn execute_batch(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ExecuteBatchRequest>,
+) -> Result<Json<dbx_core::db::QueryResult>, AppError> {
+    let result = dbx_core::query::execute_statements(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.statements,
+        req.schema.as_deref(),
+        req.timeout_secs,
+    )
+    .await
+    .map_err(AppError)?;
+
+    Ok(Json(result))
+}
+
+pub async fn cancel_query(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<CancelRequest>,
+) -> Json<serde_json::Value> {
+    let cancelled = state.app.running_queries.cancel(&req.execution_id);
+    Json(serde_json::json!({ "cancelled": cancelled }))
+}
+
+pub async fn close_query_session(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<CloseSessionRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let closed = dbx_core::query::close_query_session(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.session_id,
+        req.client_session_id.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+
+    Ok(Json(serde_json::json!(closed)))
+}
+
+pub async fn close_client_connection_session(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<CloseClientConnectionSessionRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = if req.database.trim().is_empty() { None } else { Some(req.database.as_str()) };
+    let closed = state
+        .app
+        .close_client_session_pool(&req.connection_id, database, &req.client_session_id)
+        .await
+        .map_err(AppError)?;
+
+    Ok(Json(serde_json::json!(closed)))
+}
+
+pub async fn execute_script(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ExecuteQueryRequest>,
+) -> Result<Json<dbx_core::db::QueryResult>, AppError> {
+    let db_type = {
+        let configs = state.app.configs.read().await;
+        configs.get(&req.connection_id).map(|config| config.db_type)
+    };
+    let statements = db_type
+        .map(|db_type| dbx_core::sql::split_sql_statements_for_database(&req.sql, db_type))
+        .unwrap_or_else(|| dbx_core::sql::split_sql_statements(&req.sql));
+    let result = dbx_core::query::execute_statements(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &statements,
+        req.schema.as_deref(),
+        None,
+    )
+    .await
+    .map_err(AppError)?;
+
+    Ok(Json(result))
+}
+
+pub async fn execute_in_transaction(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ExecuteBatchRequest>,
+) -> Result<Json<dbx_core::db::QueryResult>, AppError> {
+    let result = dbx_core::query::execute_statements_in_transaction(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.statements,
+        req.schema.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+
+    Ok(Json(result))
+}
+
+pub async fn analyze_sql_references(
+    Json(req): Json<AnalyzeSqlReferencesRequest>,
+) -> Result<Json<dbx_core::sql_analysis::SqlReferenceAnalysis>, AppError> {
+    dbx_core::sql_analysis::analyze_sql_references(&req.sql, req.dialect.as_deref()).map(Json).map_err(AppError)
+}
+
+pub async fn find_statement_at_cursor(Json(req): Json<FindStatementAtCursorRequest>) -> Json<String> {
+    Json(
+        req.database_type
+            .map(|db_type| dbx_core::sql::find_statement_at_cursor_for_database(&req.sql, req.cursor_pos, db_type))
+            .unwrap_or_else(|| dbx_core::sql::find_statement_at_cursor(&req.sql, req.cursor_pos)),
+    )
+}
+
+pub async fn prepare_query_pagination_execution_plan(
+    Json(req): Json<PrepareQueryPaginationExecutionPlanRequest>,
+) -> Json<dbx_core::query_result_sql::QueryPaginationExecutionPlan> {
+    Json(dbx_core::query_result_sql::build_query_pagination_execution_plan(req.options))
+}
+
+pub async fn build_sorted_query_sql(
+    Json(req): Json<BuildSortedQuerySqlRequest>,
+) -> Json<dbx_core::query_result_sql::QuerySqlBuildResult> {
+    Json(dbx_core::query_result_sql::build_sorted_query_sql(req.options))
+}
+
+pub async fn build_explain_sql(
+    Json(req): Json<BuildExplainSqlRequest>,
+) -> Json<dbx_core::query_execution_sql::ExplainSqlBuildResult> {
+    Json(dbx_core::query_execution_sql::build_explain_sql(req.options))
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GetExplainInfoRequest {
+    pub connection_id: String,
+    pub database: Option<String>,
+    pub schema: Option<String>,
+    pub sql: String,
+    pub mode: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildCreateUserSqlRequest {
+    pub username: String,
+    pub password: String,
+    pub tablespace: String,
+}
+
+pub async fn get_explain_info(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<GetExplainInfoRequest>,
+) -> Result<Json<String>, AppError> {
+    let plan = dbx_core::agent_explain::get_agent_explain_info_core(
+        &state.app,
+        &req.connection_id,
+        req.database.as_deref(),
+        req.schema.as_deref(),
+        &req.sql,
+        req.mode.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(plan))
+}
+
+pub async fn build_create_user_sql(Json(req): Json<BuildCreateUserSqlRequest>) -> Result<Json<String>, AppError> {
+    Ok(Json(dbx_core::db_admin_sql::build_create_user_sql(&req.username, &req.password, &req.tablespace)))
+}
+
+pub async fn build_dropped_file_preview_sql(
+    Json(req): Json<BuildDroppedFilePreviewSqlRequest>,
+) -> Json<Option<String>> {
+    Json(dbx_core::query_execution_sql::build_dropped_file_preview_sql(req.options))
+}
+
+pub async fn build_table_select_sql(Json(req): Json<BuildTableSelectSqlRequest>) -> Json<String> {
+    Json(dbx_core::sql_dialect::build_table_data_select_sql(req.options))
+}
+
+pub async fn build_database_search_sql(
+    Json(req): Json<BuildDatabaseSearchSqlRequest>,
+) -> Json<Option<dbx_core::database_search_sql::DatabaseSearchSql>> {
+    Json(dbx_core::database_search_sql::build_database_search_sql(req.options))
+}
+
+pub async fn build_search_result_where(Json(req): Json<BuildSearchResultWhereRequest>) -> Json<String> {
+    Json(dbx_core::database_search_sql::build_search_result_where(req.options))
+}
+
+pub async fn build_rename_object_sql(Json(req): Json<BuildRenameObjectSqlRequest>) -> Result<Json<String>, AppError> {
+    dbx_core::db_admin_sql::build_rename_object_sql(req.options).map(Json).map_err(AppError)
+}
+
+pub async fn build_create_database_sql(
+    Json(req): Json<BuildCreateDatabaseSqlRequest>,
+) -> Result<Json<String>, AppError> {
+    dbx_core::db_admin_sql::build_create_database_sql(req.options).map(Json).map_err(AppError)
+}
+
+pub async fn build_duckdb_attach_database_sql(Json(req): Json<BuildDuckDbAttachDatabaseSqlRequest>) -> Json<String> {
+    Json(dbx_core::db_admin_sql::build_duckdb_attach_database_sql(req.options))
+}
+
+pub async fn build_drop_object_sql(Json(req): Json<BuildDropObjectSqlRequest>) -> Json<String> {
+    Json(dbx_core::db_admin_sql::build_drop_object_sql(req.options))
+}
+
+pub async fn build_drop_table_sql(Json(req): Json<BuildTableAdminSqlRequest>) -> Json<String> {
+    Json(dbx_core::db_admin_sql::build_drop_table_sql(req.options))
+}
+
+pub async fn build_drop_table_child_object_sql(
+    Json(req): Json<BuildDropTableChildObjectSqlRequest>,
+) -> Result<Json<String>, AppError> {
+    dbx_core::db_admin_sql::build_drop_table_child_object_sql(req.options).map(Json).map_err(AppError)
+}
+
+pub async fn build_empty_table_sql(Json(req): Json<BuildTableAdminSqlRequest>) -> Json<String> {
+    Json(dbx_core::db_admin_sql::build_empty_table_sql(req.options))
+}
+
+pub async fn build_truncate_table_sql(Json(req): Json<BuildTableAdminSqlRequest>) -> Json<String> {
+    Json(dbx_core::db_admin_sql::build_truncate_table_sql(req.options))
+}
+
+pub async fn build_drop_database_sql(Json(req): Json<BuildDatabaseNameSqlRequest>) -> Json<String> {
+    Json(dbx_core::db_admin_sql::build_drop_database_sql(req.options))
+}
+
+pub async fn build_create_schema_sql(Json(req): Json<BuildSchemaNameSqlRequest>) -> Result<Json<String>, AppError> {
+    dbx_core::db_admin_sql::build_create_schema_sql(req.options).map(Json).map_err(AppError)
+}
+
+pub async fn build_update_database_properties_sql(
+    Json(req): Json<BuildDatabasePropertyEditSqlRequest>,
+) -> Result<Json<String>, AppError> {
+    dbx_core::db_admin_sql::build_update_database_properties_sql(req.options).map(Json).map_err(AppError)
+}
+
+pub async fn build_drop_schema_sql(Json(req): Json<BuildSchemaNameSqlRequest>) -> Json<String> {
+    Json(dbx_core::db_admin_sql::build_drop_schema_sql(req.options))
+}
+
+pub async fn build_duplicate_table_structure_sql(
+    Json(req): Json<BuildDuplicateTableStructureSqlRequest>,
+) -> Json<String> {
+    Json(dbx_core::db_admin_sql::build_duplicate_table_structure_sql(req.options))
+}
+
+pub async fn build_copy_table_data_sql(Json(req): Json<BuildCopyTableDataSqlRequest>) -> Json<String> {
+    Json(dbx_core::db_admin_sql::build_copy_table_data_sql(req.options))
+}
+
+pub async fn build_executable_object_source_statements(
+    Json(req): Json<BuildExecutableObjectSourceRequest>,
+) -> Result<Json<Vec<String>>, AppError> {
+    dbx_core::object_source_sql::build_executable_object_source_statements(req.input).map(Json).map_err(AppError)
+}
+
+pub async fn build_executable_object_source_sql(
+    Json(req): Json<BuildExecutableObjectSourceRequest>,
+) -> Result<Json<String>, AppError> {
+    dbx_core::object_source_sql::build_executable_object_source_sql(req.input).map(Json).map_err(AppError)
+}
+
+pub async fn build_editable_object_source(Json(req): Json<BuildExecutableObjectSourceRequest>) -> Json<String> {
+    Json(dbx_core::object_source_sql::build_editable_object_source(req.input))
+}
+
+pub async fn build_routine_rename_object_source_statements(
+    Json(req): Json<BuildRoutineRenameObjectSourceRequest>,
+) -> Result<Json<Vec<String>>, AppError> {
+    dbx_core::object_source_sql::build_routine_rename_object_source_statements(req.input).map(Json).map_err(AppError)
+}
+
+pub async fn build_view_ddl_sql(Json(req): Json<BuildViewDdlRequest>) -> Json<String> {
+    Json(dbx_core::object_source_sql::build_view_ddl_sql(req.input))
+}
+
+pub async fn build_table_structure_change_sql(
+    Json(req): Json<BuildTableStructureSqlRequest>,
+) -> Json<dbx_core::table_structure_sql::TableStructureSqlResult> {
+    Json(dbx_core::table_structure_sql::build_table_structure_change_sql(req.options))
+}
+
+pub async fn preview_sqlite_table_structure_change(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<PreviewSqliteTableStructureChangeRequest>,
+) -> Result<Json<dbx_core::table_structure_sql::SqliteTableStructurePreview>, AppError> {
+    dbx_core::table_structure_sql::preview_sqlite_table_structure_change(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        req.options,
+    )
+    .await
+    .map(Json)
+    .map_err(AppError)
+}
+
+pub async fn apply_sqlite_table_structure_change(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ApplySqliteTableStructureChangeRequest>,
+) -> Result<Json<dbx_core::db::QueryResult>, AppError> {
+    dbx_core::table_structure_sql::apply_sqlite_table_structure_change(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        req.options,
+        &req.schema_revision,
+    )
+    .await
+    .map(Json)
+    .map_err(AppError)
+}
+
+pub async fn build_create_table_sql(
+    Json(req): Json<BuildTableStructureSqlRequest>,
+) -> Json<dbx_core::table_structure_sql::TableStructureSqlResult> {
+    Json(dbx_core::table_structure_sql::build_create_table_sql(req.options))
+}
+
+pub async fn build_single_column_alter_sql(
+    Json(req): Json<BuildSingleColumnAlterSqlRequest>,
+) -> Json<dbx_core::table_structure_sql::TableStructureSqlResult> {
+    Json(dbx_core::table_structure_sql::build_single_column_alter_sql(req.options))
+}
+
+pub async fn analyze_editable_query_editability(
+    Json(req): Json<AnalyzeEditableQueryRequest>,
+) -> Json<dbx_core::sql_editability::QueryEditability> {
+    Json(dbx_core::sql_editability::analyze_editable_query_editability(&req.sql))
+}
+
+pub async fn prepare_data_grid_save(
+    Json(req): Json<PrepareDataGridSaveRequest>,
+) -> Json<dbx_core::data_grid_sql::DataGridSavePreparation> {
+    Json(dbx_core::data_grid_sql::prepare_data_grid_save(req.options))
+}
+
+pub async fn build_data_grid_copy_update_statements(
+    Json(req): Json<BuildDataGridCopyUpdateStatementsRequest>,
+) -> Json<Vec<String>> {
+    Json(dbx_core::data_grid_sql::build_data_grid_copy_update_statements(req.options))
+}
+
+pub async fn build_data_grid_copy_insert_statement(
+    Json(req): Json<BuildDataGridCopyInsertStatementRequest>,
+) -> Json<Option<String>> {
+    Json(dbx_core::data_grid_sql::build_data_grid_copy_insert_statement(req.options))
+}
+
+pub async fn build_data_grid_context_filter_condition(
+    Json(req): Json<BuildDataGridContextFilterConditionRequest>,
+) -> Json<Option<String>> {
+    Json(dbx_core::data_grid_sql::build_data_grid_context_filter_condition(req.options))
+}
+
+pub async fn build_data_grid_column_value_filter_condition(
+    Json(req): Json<BuildDataGridColumnValueFilterConditionRequest>,
+) -> Json<Option<String>> {
+    Json(dbx_core::data_grid_sql::build_data_grid_column_value_filter_condition(req.options))
+}
+
+pub async fn build_data_grid_column_values_filter_condition(
+    Json(req): Json<BuildDataGridColumnValuesFilterConditionRequest>,
+) -> Json<Option<String>> {
+    Json(dbx_core::data_grid_sql::build_data_grid_column_values_filter_condition(req.options))
+}
+
+pub async fn build_data_grid_column_distinct_values_sql(
+    Json(req): Json<BuildDataGridColumnDistinctValuesSqlRequest>,
+) -> Json<String> {
+    Json(dbx_core::data_grid_sql::build_data_grid_column_distinct_values_sql(req.options))
+}
+
+pub async fn build_data_grid_count_sql(Json(req): Json<BuildDataGridCountSqlRequest>) -> Json<String> {
+    Json(dbx_core::data_grid_sql::build_data_grid_count_sql(req.options))
+}
+
+pub async fn build_hive_table_properties_sql(Json(req): Json<BuildHiveTablePropertiesSqlRequest>) -> Json<String> {
+    Json(dbx_core::data_grid_sql::build_hive_table_properties_sql(req.options))
+}
+
+pub async fn build_export_insert_statements(
+    Json(req): Json<BuildExportInsertStatementsRequest>,
+) -> Result<Json<Vec<String>>, AppError> {
+    dbx_core::database_export::build_export_insert_statements(req.options).map(Json).map_err(AppError)
+}
+
+pub async fn build_export_sql_insert(Json(req): Json<BuildExportSqlInsertRequest>) -> Result<Json<String>, AppError> {
+    dbx_core::database_export::build_export_sql_insert(req.options).map(Json).map_err(AppError)
+}
+
+pub async fn build_database_sql_export(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<BuildDatabaseSqlExportRequest>,
+) -> Result<Json<String>, AppError> {
+    let mut options = req.options;
+    // Sort tables by FK dependency when connection info is available.
+    if let (Some(ref conn_id), Some(ref database), Some(ref schema)) =
+        (&options.connection_id, &options.database, &options.schema)
+    {
+        if options.tables.len() > 1 {
+            let table_names: Vec<String> = options.tables.iter().filter_map(|t| t.table_name.clone()).collect();
+            if table_names.len() > 1 {
+                if let Ok(sorted_names) = dbx_core::transfer::sort_tables_by_fk_dependency(
+                    &state.app,
+                    conn_id,
+                    database,
+                    schema,
+                    &table_names,
+                    true,
+                )
+                .await
+                {
+                    options.tables.sort_by_key(|t| {
+                        sorted_names
+                            .iter()
+                            .position(|n| Some(n.as_str()) == t.table_name.as_deref())
+                            .unwrap_or(usize::MAX)
+                    });
+                }
+            }
+        }
+    }
+    dbx_core::database_export::build_database_sql_export(options).map(Json).map_err(AppError)
+}
diff --git a/crates/dbx-web/src/routes/query_result_export.rs b/crates/dbx-web/src/routes/query_result_export.rs
new file mode 100644
index 0000000..5579779
--- /dev/null
+++ b/crates/dbx-web/src/routes/query_result_export.rs
@@ -0,0 +1,168 @@
+use std::{
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    time::Duration,
+};
+
+use axum::body::Body;
+use axum::extract::{Path, State};
+use axum::http::{header, StatusCode};
+use axum::response::{Response, Sse};
+use axum::Json;
+use dbx_core::query_cancel::RunningTaskMetadata;
+use dbx_core::query_result_export::{self, QueryResultExportRequest};
+use dbx_core::table_export::{ExportStatus, TableExportProgress};
+use futures::stream::Stream;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StartQueryResultExportRequest {
+    pub request: QueryResultExportRequest,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CancelQueryResultExportRequest {
+    pub export_id: String,
+    pub execution_id: Option<String>,
+}
+
+pub async fn start_query_result_export(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<StartQueryResultExportRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let mut req = body.request;
+    let export_id = req.export_id.clone();
+
+    let ext = match req.format.as_str() {
+        "csv" => "csv",
+        "xlsx" => "xlsx",
+        _ => return Err(AppError(format!("Unsupported query result export format: {}", req.format))),
+    };
+    let tmp_dir = state.data_dir.join("tmp");
+    std::fs::create_dir_all(&tmp_dir).map_err(|e| AppError(e.to_string()))?;
+    let tmp_file = tmp_dir.join(format!("query_result_export_{export_id}.{ext}"));
+    let file_path = tmp_file.to_string_lossy().to_string();
+    req.file_path = file_path.clone();
+
+    state.export_files.write().await.insert(export_id.clone(), (file_path, req.format.clone()));
+
+    let tx = {
+        let mut channels = state.sse_channels.write().await;
+        channels.entry(export_id.clone()).or_insert_with(|| tokio::sync::broadcast::channel::<String>(256).0).clone()
+    };
+
+    let app = state.app.clone();
+    let state_clone = state.clone();
+    let cancelled = Arc::new(AtomicBool::new(false));
+    let cancelled_progress = cancelled.clone();
+
+    tokio::spawn(async move {
+        let execution_id = req.execution_id.clone().filter(|id| !id.trim().is_empty());
+        let registered_query = execution_id.as_ref().map(|id| {
+            app.running_queries.register_task(
+                id.clone(),
+                RunningTaskMetadata::query(
+                    req.connection_id.clone(),
+                    req.database.clone(),
+                    req.client_session_id.clone(),
+                ),
+            )
+        });
+        let cancel_token = registered_query.as_ref().map(|query| query.token());
+        let result = query_result_export::export_query_result_core(&app, &req, cancel_token, |progress| {
+            if matches!(progress.status, ExportStatus::Cancelled) {
+                cancelled_progress.store(true, Ordering::SeqCst);
+            }
+            if let Ok(json) = serde_json::to_string(&progress) {
+                let _ = tx.send(json);
+            }
+        })
+        .await;
+        drop(registered_query);
+
+        if let Err(e) = result {
+            let _ = tokio::fs::remove_file(&req.file_path).await;
+            state_clone.export_files.write().await.remove(&req.export_id);
+            let progress = TableExportProgress {
+                export_id: req.export_id.clone(),
+                table_name: String::new(),
+                rows_exported: 0,
+                total_rows: None,
+                status: ExportStatus::Error,
+                error_message: Some(e),
+            };
+            if let Ok(json) = serde_json::to_string(&progress) {
+                let _ = tx.send(json);
+            }
+        } else if cancelled.load(Ordering::SeqCst) {
+            let _ = tokio::fs::remove_file(&req.file_path).await;
+            state_clone.export_files.write().await.remove(&req.export_id);
+        }
+
+        dbx_core::database_export::clear_export_cancelled(&req.export_id).await;
+        tokio::time::sleep(Duration::from_secs(5)).await;
+        state_clone.remove_sse_channel(&req.export_id).await;
+    });
+
+    Ok(Json(serde_json::json!({ "exportId": export_id })))
+}
+
+pub async fn query_result_export_progress(
+    State(state): State<Arc<WebState>>,
+    Path(export_id): Path<String>,
+) -> Result<Sse<impl Stream<Item = Result<axum::response::sse::Event, std::convert::Infallible>>>, AppError> {
+    let tx = {
+        let mut channels = state.sse_channels.write().await;
+        channels.entry(export_id).or_insert_with(|| tokio::sync::broadcast::channel::<String>(256).0).clone()
+    };
+    let rx = tx.subscribe();
+    Ok(crate::sse::sse_from_channel(rx))
+}
+
+pub async fn cancel_query_result_export(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<CancelQueryResultExportRequest>,
+) -> Json<serde_json::Value> {
+    dbx_core::database_export::set_export_cancelled(&req.export_id).await;
+    if let Some(execution_id) = req.execution_id.filter(|id| !id.trim().is_empty()) {
+        state.app.running_queries.cancel(&execution_id);
+    }
+    Json(serde_json::json!({ "cancelled": true }))
+}
+
+pub async fn query_result_export_download(
+    State(state): State<Arc<WebState>>,
+    Path(export_id): Path<String>,
+) -> Result<Response, AppError> {
+    let (file_path, format) = state
+        .export_files
+        .write()
+        .await
+        .remove(&export_id)
+        .ok_or_else(|| AppError("Export file not found".to_string()))?;
+
+    let data = tokio::fs::read(&file_path).await.map_err(|e| AppError(e.to_string()))?;
+    let _ = tokio::fs::remove_file(&file_path).await;
+
+    let (content_type, file_ext) = match format.as_str() {
+        "csv" => ("text/csv; charset=utf-8", "csv"),
+        "xlsx" => ("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "xlsx"),
+        _ => return Err(AppError(format!("Unknown format: {format}"))),
+    };
+
+    let filename = format!("query_result_export_{export_id}.{file_ext}");
+
+    Response::builder()
+        .status(StatusCode::OK)
+        .header(header::CONTENT_TYPE, content_type)
+        .header(header::CONTENT_DISPOSITION, format!("attachment; filename=\"{filename}\""))
+        .body(Body::from(data))
+        .map_err(|e| AppError(e.to_string()))
+}
diff --git a/crates/dbx-web/src/routes/redis.rs b/crates/dbx-web/src/routes/redis.rs
new file mode 100644
index 0000000..d8d3325
--- /dev/null
+++ b/crates/dbx-web/src/routes/redis.rs
@@ -0,0 +1,582 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+/// Check if a connection is read-only and return an error if so.
+async fn ensure_writable(
+    app: &dbx_core::connection::AppState,
+    connection_id: &str,
+    action: &str,
+) -> Result<(), AppError> {
+    if let Some(name) = dbx_core::query::connection_readonly_name(app, connection_id).await {
+        return Err(AppError(format!(
+            "Read-only mode: connection '{}' has read-only protection enabled. {} blocked.",
+            name, action
+        )));
+    }
+    Ok(())
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisConnectionRequest {
+    pub connection_id: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisScanRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub cursor: u64,
+    pub pattern: String,
+    pub count: usize,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisScanBatchRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub cursor: u64,
+    pub pattern: String,
+    pub count: usize,
+    #[serde(default = "default_max_iterations")]
+    pub max_iterations: usize,
+    pub include_types: Option<bool>,
+}
+
+fn default_max_iterations() -> usize {
+    1
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisValueScanRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub cursor: u64,
+    pub pattern: String,
+    pub query: String,
+    pub include_key_matches: Option<bool>,
+    pub count: usize,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisKeyRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub key_raw: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisLoadMoreRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub key_raw: String,
+    pub key_type: String,
+    pub cursor: u64,
+    pub count: usize,
+    pub filter: Option<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisSetStringRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub key_raw: String,
+    pub value: String,
+    pub ttl: Option<i64>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisHashRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub key_raw: String,
+    pub field: String,
+    pub value: Option<String>,
+    pub ttl: Option<i64>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisZaddRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub key_raw: String,
+    pub member: String,
+    pub score: f64,
+    pub ttl: Option<i64>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisListRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub key_raw: String,
+    pub value: Option<String>,
+    pub index: Option<i64>,
+    pub ttl: Option<i64>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisSetRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub key_raw: String,
+    pub member: String,
+    pub ttl: Option<i64>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisStreamAddRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub key_raw: String,
+    pub entry_id: String,
+    pub fields: Vec<(String, String)>,
+    pub ttl: Option<i64>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisJsonSetRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub key_raw: String,
+    pub value: String,
+    pub ttl: Option<i64>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisKeysRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub key_raws: Vec<String>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisDbRequest {
+    pub connection_id: String,
+    pub db: u32,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisCommandRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub command: String,
+    pub skip_safety_check: Option<bool>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RedisPubSubPublishRequest {
+    pub connection_id: String,
+    pub db: u32,
+    pub channel: String,
+    pub message: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SlowlogGetRequest {
+    pub connection_id: String,
+    pub count: usize,
+    pub node_host: Option<String>,
+    pub node_port: Option<u16>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ClusterNodesRequest {
+    pub connection_id: String,
+}
+
+pub async fn list_databases(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisConnectionRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result =
+        dbx_core::redis_ops::redis_list_databases_core(&state.app, &req.connection_id).await.map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn scan_keys(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisScanRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = dbx_core::redis_ops::redis_scan_keys_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        req.cursor,
+        &req.pattern,
+        req.count,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn scan_keys_batch(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisScanBatchRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = dbx_core::redis_ops::redis_scan_keys_batch_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        req.cursor,
+        &req.pattern,
+        req.count,
+        req.max_iterations,
+        req.include_types.unwrap_or(true),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn scan_values(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisValueScanRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = dbx_core::redis_ops::redis_scan_values_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        req.cursor,
+        &req.pattern,
+        &req.query,
+        req.include_key_matches.unwrap_or(false),
+        req.count,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn get_value(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisKeyRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = dbx_core::redis_ops::redis_get_value_in_db_core(&state.app, &req.connection_id, req.db, &req.key_raw)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn load_more(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisLoadMoreRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = dbx_core::redis_ops::redis_load_more_in_db_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        &req.key_raw,
+        &req.key_type,
+        req.cursor,
+        req.count,
+        req.filter.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn set_string(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisSetStringRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "SET").await?;
+    dbx_core::redis_ops::redis_set_string_in_db_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        &req.key_raw,
+        &req.value,
+        req.ttl,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn delete_key(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisKeyRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete key").await?;
+    dbx_core::redis_ops::redis_delete_key_in_db_core(&state.app, &req.connection_id, req.db, &req.key_raw)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn hash_set(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisHashRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "HSET").await?;
+    let value = req.value.as_deref().unwrap_or("");
+    dbx_core::redis_ops::redis_hash_set_in_db_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        &req.key_raw,
+        &req.field,
+        value,
+        req.ttl,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn hash_del(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisHashRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "HDEL").await?;
+    dbx_core::redis_ops::redis_hash_del_in_db_core(&state.app, &req.connection_id, req.db, &req.key_raw, &req.field)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn list_push(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisListRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "LPUSH").await?;
+    let value = req.value.as_deref().unwrap_or("");
+    dbx_core::redis_ops::redis_list_push_in_db_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        &req.key_raw,
+        value,
+        req.ttl,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn list_set(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisListRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "LSET").await?;
+    let index = req.index.unwrap_or(0);
+    let value = req.value.as_deref().unwrap_or("");
+    dbx_core::redis_ops::redis_list_set_in_db_core(&state.app, &req.connection_id, req.db, &req.key_raw, index, value)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn list_remove(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisListRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "LREM").await?;
+    let index = req.index.unwrap_or(0);
+    dbx_core::redis_ops::redis_list_remove_in_db_core(&state.app, &req.connection_id, req.db, &req.key_raw, index)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn set_add(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisSetRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "SADD").await?;
+    dbx_core::redis_ops::redis_set_add_in_db_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        &req.key_raw,
+        &req.member,
+        req.ttl,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn set_remove(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisSetRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "SREM").await?;
+    dbx_core::redis_ops::redis_set_remove_in_db_core(&state.app, &req.connection_id, req.db, &req.key_raw, &req.member)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn zadd(State(state): State<Arc<WebState>>, Json(req): Json<RedisZaddRequest>) -> Result<Json<()>, AppError> {
+    dbx_core::redis_ops::redis_zadd_in_db_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        &req.key_raw,
+        &req.member,
+        req.score,
+        req.ttl,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn stream_add(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisStreamAddRequest>,
+) -> Result<Json<()>, AppError> {
+    dbx_core::redis_ops::redis_stream_add_in_db_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        &req.key_raw,
+        &req.entry_id,
+        req.fields,
+        req.ttl,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn json_set(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisJsonSetRequest>,
+) -> Result<Json<()>, AppError> {
+    dbx_core::redis_ops::redis_json_set_in_db_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        &req.key_raw,
+        &req.value,
+        req.ttl,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn check_json_module(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisDbRequest>,
+) -> Result<Json<bool>, AppError> {
+    let result = dbx_core::redis_ops::redis_check_json_module_in_db_core(&state.app, &req.connection_id, req.db)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn delete_keys(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisKeysRequest>,
+) -> Result<Json<u64>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete keys").await?;
+    let result =
+        dbx_core::redis_ops::redis_delete_keys_in_db_core(&state.app, &req.connection_id, req.db, &req.key_raws)
+            .await
+            .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn flush_db(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisDbRequest>,
+) -> Result<Json<()>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "FLUSHDB").await?;
+    dbx_core::redis_ops::redis_flush_db_core(&state.app, &req.connection_id, req.db).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn execute_command(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisCommandRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    // In read-only mode, only allow safe read commands
+    if let Some(name) = dbx_core::query::connection_readonly_name(&state.app, &req.connection_id).await {
+        let cmd_name = req.command.split_whitespace().next().unwrap_or("");
+        if dbx_core::db::redis_driver::classify_command(cmd_name)
+            != dbx_core::db::redis_driver::RedisCommandSafety::Allowed
+        {
+            return Err(AppError(format!(
+                "Read-only mode: connection '{}' has read-only protection enabled. Command '{}' blocked.",
+                name, cmd_name
+            )));
+        }
+    }
+    let result = dbx_core::redis_ops::redis_execute_command_core(
+        &state.app,
+        &req.connection_id,
+        req.db,
+        &req.command,
+        req.skip_safety_check.unwrap_or(false),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn publish_message(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<RedisPubSubPublishRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "PUBLISH").await?;
+    let count =
+        dbx_core::redis_ops::redis_publish_core(&state.app, &req.connection_id, req.db, &req.channel, &req.message)
+            .await
+            .map_err(AppError)?;
+    Ok(Json(serde_json::json!({ "subscribers": count })))
+}
+
+pub async fn slowlog_get(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SlowlogGetRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = dbx_core::redis_ops::redis_slowlog_get_core(
+        &state.app,
+        &req.connection_id,
+        req.count,
+        req.node_host,
+        req.node_port,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn cluster_master_nodes(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ClusterNodesRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result =
+        dbx_core::redis_ops::redis_cluster_master_nodes_core(&state.app, &req.connection_id).await.map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
diff --git a/crates/dbx-web/src/routes/redis_pubsub_ws.rs b/crates/dbx-web/src/routes/redis_pubsub_ws.rs
new file mode 100644
index 0000000..22e1326
--- /dev/null
+++ b/crates/dbx-web/src/routes/redis_pubsub_ws.rs
@@ -0,0 +1,127 @@
+use std::sync::Arc;
+
+use axum::extract::ws::{Message, WebSocket};
+use axum::extract::State;
+use axum::extract::{Query, WebSocketUpgrade};
+use axum::response::IntoResponse;
+use futures::{SinkExt, StreamExt};
+use serde::Deserialize;
+
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PubSubWsParams {
+    pub connection_id: String,
+}
+
+pub async fn ws_handler(
+    ws: WebSocketUpgrade,
+    Query(params): Query<PubSubWsParams>,
+    State(state): State<Arc<WebState>>,
+) -> impl IntoResponse {
+    let connection_id = params.connection_id;
+    ws.on_upgrade(move |socket| handle_pubsub_socket(socket, state, connection_id))
+}
+
+async fn handle_pubsub_socket(socket: WebSocket, state: Arc<WebState>, connection_id: String) {
+    // Create PubSub connection
+    let pubsub = match dbx_core::redis_ops::redis_create_pubsub_core(&state.app, &connection_id).await {
+        Ok(p) => p,
+        Err(e) => {
+            let (mut sender, _) = socket.split();
+            let _ = sender.send(Message::Text(format!(r#"{{"error":"{e}"}}"#).into())).await;
+            return;
+        }
+    };
+
+    let (mut sink, mut stream) = pubsub.split();
+    let (mut ws_sender, mut ws_receiver) = socket.split();
+
+    // Channel for WebSocket commands -> PubSub sink
+    let (cmd_tx, mut cmd_rx) = tokio::sync::mpsc::unbounded_channel::<String>();
+
+    // Task: Read WebSocket commands
+    let ws_read = tokio::spawn(async move {
+        while let Some(Ok(msg)) = ws_receiver.next().await {
+            match msg {
+                Message::Text(text) => {
+                    if cmd_tx.send(text.to_string()).is_err() {
+                        break;
+                    }
+                }
+                Message::Close(_) => break,
+                _ => {}
+            }
+        }
+    });
+
+    // Task: Apply commands to PubSub sink
+    let sink_handle = tokio::spawn(async move {
+        while let Some(text) = cmd_rx.recv().await {
+            if let Err(e) = handle_pubsub_command(&mut sink, &text).await {
+                log::warn!("PubSub command error: {e}");
+            }
+        }
+    });
+
+    // Forward Redis messages to WebSocket (uses ws_sender, no mutex)
+    while let Some(msg) = stream.next().await {
+        let payload: String = msg.get_payload().unwrap_or_default();
+        let channel = msg.get_channel_name().to_string();
+        let pattern: Option<String> = msg.get_pattern().ok();
+        let json = serde_json::json!({
+            "channel": channel,
+            "pattern": pattern,
+            "payload": payload,
+        });
+        let text = serde_json::to_string(&json).unwrap_or_default();
+        if ws_sender.send(Message::Text(text.into())).await.is_err() {
+            break;
+        }
+    }
+
+    ws_read.abort();
+    sink_handle.abort();
+}
+
+#[derive(Deserialize)]
+#[serde(tag = "type")]
+enum PubSubCommand {
+    #[serde(rename = "subscribe")]
+    Subscribe { channels: Vec<String> },
+    #[serde(rename = "psubscribe")]
+    Psubscribe { patterns: Vec<String> },
+    #[serde(rename = "unsubscribe")]
+    Unsubscribe { channels: Vec<String> },
+    #[serde(rename = "punsubscribe")]
+    Punsubscribe { patterns: Vec<String> },
+}
+
+async fn handle_pubsub_command(sink: &mut redis::aio::PubSubSink, text: &str) -> Result<(), String> {
+    let cmd: PubSubCommand = serde_json::from_str(text).map_err(|e| format!("Invalid PubSub command: {e}"))?;
+
+    match cmd {
+        PubSubCommand::Subscribe { channels } => {
+            for ch in &channels {
+                sink.subscribe(ch).await.map_err(|e| format!("Subscribe error: {e}"))?;
+            }
+        }
+        PubSubCommand::Psubscribe { patterns } => {
+            for pat in &patterns {
+                sink.psubscribe(pat).await.map_err(|e| format!("PSubscribe error: {e}"))?;
+            }
+        }
+        PubSubCommand::Unsubscribe { channels } => {
+            for ch in &channels {
+                sink.unsubscribe(ch).await.map_err(|e| format!("Unsubscribe error: {e}"))?;
+            }
+        }
+        PubSubCommand::Punsubscribe { patterns } => {
+            for pat in &patterns {
+                sink.punsubscribe(pat).await.map_err(|e| format!("PUnsubscribe error: {e}"))?;
+            }
+        }
+    }
+    Ok(())
+}
diff --git a/crates/dbx-web/src/routes/saved_sql.rs b/crates/dbx-web/src/routes/saved_sql.rs
new file mode 100644
index 0000000..5ebb8a0
--- /dev/null
+++ b/crates/dbx-web/src/routes/saved_sql.rs
@@ -0,0 +1,53 @@
+use std::sync::Arc;
+
+use axum::extract::{Path, State};
+use axum::Json;
+use dbx_core::saved_sql::{SavedSqlFile, SavedSqlFolder, SavedSqlLibrary};
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+pub async fn load_saved_sql_library(State(state): State<Arc<WebState>>) -> Result<Json<SavedSqlLibrary>, AppError> {
+    let library = state.app.storage.load_saved_sql_library_summary().await.map_err(AppError)?;
+    Ok(Json(library))
+}
+
+pub async fn load_saved_sql_file(
+    State(state): State<Arc<WebState>>,
+    Path(id): Path<String>,
+) -> Result<Json<Option<SavedSqlFile>>, AppError> {
+    let file = state.app.storage.load_saved_sql_file(&id).await.map_err(AppError)?;
+    Ok(Json(file))
+}
+
+pub async fn save_saved_sql_folder(
+    State(state): State<Arc<WebState>>,
+    Json(folder): Json<SavedSqlFolder>,
+) -> Result<Json<SavedSqlFolder>, AppError> {
+    state.app.storage.save_saved_sql_folder(&folder).await.map_err(AppError)?;
+    Ok(Json(folder))
+}
+
+pub async fn delete_saved_sql_folder(
+    State(state): State<Arc<WebState>>,
+    Path(id): Path<String>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.delete_saved_sql_folder(&id).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn save_saved_sql_file(
+    State(state): State<Arc<WebState>>,
+    Json(file): Json<SavedSqlFile>,
+) -> Result<Json<SavedSqlFile>, AppError> {
+    state.app.storage.save_saved_sql_file(&file).await.map_err(AppError)?;
+    Ok(Json(file))
+}
+
+pub async fn delete_saved_sql_file(
+    State(state): State<Arc<WebState>>,
+    Path(id): Path<String>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.delete_saved_sql_file(&id).await.map_err(AppError)?;
+    Ok(Json(()))
+}
diff --git a/crates/dbx-web/src/routes/schema.rs b/crates/dbx-web/src/routes/schema.rs
new file mode 100644
index 0000000..39c30a3
--- /dev/null
+++ b/crates/dbx-web/src/routes/schema.rs
@@ -0,0 +1,462 @@
+use std::sync::Arc;
+
+use axum::extract::{Query, State};
+use axum::Json;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+pub struct SchemaQuery {
+    pub connection_id: String,
+    pub database: Option<String>,
+    pub schema: Option<String>,
+    pub table: Option<String>,
+    pub server: Option<String>,
+    pub catalog: Option<String>,
+    pub filter: Option<String>,
+    pub limit: Option<usize>,
+    pub offset: Option<usize>,
+    pub object_type: Option<dbx_core::db::ObjectSourceKind>,
+    pub signature: Option<String>,
+    pub object_types: Option<String>,
+    pub apply_visible_filter: Option<bool>,
+}
+
+pub async fn list_databases(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = dbx_core::schema::list_databases_core(&state.app, &q.connection_id).await.map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+/// Resolve a non-internal catalog for dispatch to the Doris multi-catalog path.
+async fn external_doris_catalog(state: &Arc<WebState>, connection_id: &str, catalog: Option<&str>) -> Option<String> {
+    dbx_core::schema::resolve_external_doris_catalog(&state.app, connection_id, catalog).await
+}
+
+pub async fn list_doris_catalogs(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result = dbx_core::schema::list_doris_catalogs_core(&state.app, &q.connection_id).await.map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_doris_catalog_databases(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let catalog = q.catalog.as_deref().unwrap_or("internal");
+    let result = dbx_core::schema::list_doris_catalog_databases_core(&state.app, &q.connection_id, catalog)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_sqlserver_linked_servers(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let result =
+        dbx_core::schema::list_sqlserver_linked_servers_core(&state.app, &q.connection_id).await.map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_sqlserver_linked_server_catalogs(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let server = q.server.as_deref().unwrap_or("");
+    let result = dbx_core::schema::list_sqlserver_linked_server_catalogs_core(&state.app, &q.connection_id, server)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_sqlserver_linked_server_schemas(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<Vec<String>>, AppError> {
+    let server = q.server.as_deref().unwrap_or("");
+    let catalog = q.catalog.as_deref().unwrap_or("");
+    let result =
+        dbx_core::schema::list_sqlserver_linked_server_schemas_core(&state.app, &q.connection_id, server, catalog)
+            .await
+            .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_sqlserver_linked_server_tables(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let server = q.server.as_deref().unwrap_or("");
+    let catalog = q.catalog.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let result = dbx_core::schema::list_sqlserver_linked_server_tables_core(
+        &state.app,
+        &q.connection_id,
+        server,
+        catalog,
+        schema,
+        q.filter.as_deref(),
+        q.limit,
+        q.offset,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_schemas(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<Vec<String>>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let result = dbx_core::schema::list_schemas_core_with_visible_filter(
+        &state.app,
+        &q.connection_id,
+        database,
+        q.apply_visible_filter.unwrap_or(false),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_tables(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let object_types = q.object_types.as_ref().map(|value| {
+        value.split(',').map(str::trim).filter(|value| !value.is_empty()).map(str::to_string).collect::<Vec<_>>()
+    });
+    let result = if let Some(catalog) = external_doris_catalog(&state, &q.connection_id, q.catalog.as_deref()).await {
+        dbx_core::schema::list_doris_catalog_tables_core(
+            &state.app,
+            &q.connection_id,
+            &catalog,
+            database,
+            q.filter.as_deref(),
+            q.limit,
+            q.offset,
+            object_types.as_deref(),
+        )
+        .await
+        .map_err(AppError)?
+    } else {
+        dbx_core::schema::list_tables_core(
+            &state.app,
+            &q.connection_id,
+            database,
+            schema,
+            q.filter.as_deref(),
+            q.limit,
+            q.offset,
+            object_types.as_deref(),
+        )
+        .await
+        .map_err(AppError)?
+    };
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_objects(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let object_types = q.object_types.as_ref().map(|value| {
+        value.split(',').map(str::trim).filter(|value| !value.is_empty()).map(str::to_string).collect::<Vec<_>>()
+    });
+    let result = if let Some(catalog) = external_doris_catalog(&state, &q.connection_id, q.catalog.as_deref()).await {
+        let tables = dbx_core::schema::list_doris_catalog_tables_core(
+            &state.app,
+            &q.connection_id,
+            &catalog,
+            database,
+            q.filter.as_deref(),
+            q.limit,
+            q.offset,
+            object_types.as_deref(),
+        )
+        .await
+        .map_err(AppError)?;
+        tables
+            .into_iter()
+            .map(|table| dbx_core::db::ObjectInfo {
+                name: table.name,
+                object_type: table.table_type,
+                schema: Some(database.to_string()),
+                signature: None,
+                comment: table.comment,
+                created_at: None,
+                updated_at: None,
+                parent_schema: table.parent_schema,
+                parent_name: table.parent_name,
+            })
+            .collect::<Vec<_>>()
+    } else {
+        dbx_core::schema::list_objects_core(
+            &state.app,
+            &q.connection_id,
+            database,
+            schema,
+            q.filter.as_deref(),
+            q.limit,
+            q.offset,
+            object_types.as_deref(),
+        )
+        .await
+        .map_err(AppError)?
+    };
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_object_statistics(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let result = dbx_core::schema::list_object_statistics_core(&state.app, &q.connection_id, database, schema)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_completion_objects(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let result = dbx_core::schema::list_completion_objects_core(&state.app, &q.connection_id, database, schema)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn completion_assistant_search(
+    State(state): State<Arc<WebState>>,
+    Json(request): Json<dbx_core::db::CompletionAssistantRequest>,
+) -> Result<Json<dbx_core::db::CompletionAssistantResponse>, AppError> {
+    let result = dbx_core::schema::completion_assistant_search_core(&state.app, request).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn get_object_source(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<dbx_core::db::ObjectSource>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let name = q.table.as_deref().unwrap_or("");
+    let object_type = q.object_type.ok_or_else(|| AppError("Missing object_type".to_string()))?;
+    let result = dbx_core::schema::get_object_source_core(
+        &state.app,
+        &q.connection_id,
+        database,
+        schema,
+        name,
+        object_type,
+        q.signature.as_deref(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn list_columns(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let table = q.table.as_deref().unwrap_or("");
+    let result = if let Some(catalog) = external_doris_catalog(&state, &q.connection_id, q.catalog.as_deref()).await {
+        dbx_core::schema::get_doris_catalog_columns_core(&state.app, &q.connection_id, &catalog, database, table)
+            .await
+            .map_err(AppError)?
+    } else {
+        dbx_core::schema::get_columns_core(&state.app, &q.connection_id, database, schema, table)
+            .await
+            .map_err(AppError)?
+    };
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_data_types(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let result =
+        dbx_core::schema::list_data_types_core(&state.app, &q.connection_id, database).await.map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_indexes(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let table = q.table.as_deref().unwrap_or("");
+    let result = if let Some(catalog) = external_doris_catalog(&state, &q.connection_id, q.catalog.as_deref()).await {
+        dbx_core::schema::list_doris_catalog_indexes_core(&state.app, &q.connection_id, &catalog, database, table)
+            .await
+            .map_err(AppError)?
+    } else {
+        dbx_core::schema::list_indexes_core(&state.app, &q.connection_id, database, schema, table)
+            .await
+            .map_err(AppError)?
+    };
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_foreign_keys(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let table = q.table.as_deref().unwrap_or("");
+    let result = if let Some(catalog) = external_doris_catalog(&state, &q.connection_id, q.catalog.as_deref()).await {
+        dbx_core::schema::list_doris_catalog_foreign_keys_core(&state.app, &q.connection_id, &catalog, database, table)
+            .await
+            .map_err(AppError)?
+    } else {
+        dbx_core::schema::list_foreign_keys_core(&state.app, &q.connection_id, database, schema, table)
+            .await
+            .map_err(AppError)?
+    };
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_triggers(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let table = q.table.as_deref().unwrap_or("");
+    let result = if let Some(catalog) = external_doris_catalog(&state, &q.connection_id, q.catalog.as_deref()).await {
+        dbx_core::schema::list_doris_catalog_triggers_core(&state.app, &q.connection_id, &catalog, database, table)
+            .await
+            .map_err(AppError)?
+    } else {
+        dbx_core::schema::list_triggers_core(&state.app, &q.connection_id, database, schema, table)
+            .await
+            .map_err(AppError)?
+    };
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn get_ddl(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<String>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let table = q.table.as_deref().unwrap_or("");
+    let result = if let Some(catalog) = external_doris_catalog(&state, &q.connection_id, q.catalog.as_deref()).await {
+        dbx_core::schema::get_doris_catalog_table_ddl_core(&state.app, &q.connection_id, &catalog, database, table)
+            .await
+            .map_err(AppError)?
+    } else {
+        dbx_core::schema::get_table_ddl_core(&state.app, &q.connection_id, database, schema, table, q.object_type)
+            .await
+            .map_err(AppError)?
+    };
+    Ok(Json(result))
+}
+
+pub async fn list_functions(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let result = dbx_core::schema::list_functions_core(&state.app, &q.connection_id, database, schema)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+#[derive(Deserialize)]
+pub struct SequenceQuery {
+    pub connection_id: String,
+    pub database: Option<String>,
+    pub schema: Option<String>,
+    pub with_last_values: Option<bool>,
+}
+
+pub async fn list_sequences(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SequenceQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let result = dbx_core::schema::list_sequences_core(
+        &state.app,
+        &q.connection_id,
+        database,
+        schema,
+        q.with_last_values.unwrap_or(false),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_rules(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let result =
+        dbx_core::schema::list_rules_core(&state.app, &q.connection_id, database, schema).await.map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_owners(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let result =
+        dbx_core::schema::list_owners_core(&state.app, &q.connection_id, database, schema).await.map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_extensions(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let schema = q.schema.as_deref().unwrap_or("");
+    let result = dbx_core::schema::list_extensions_core(&state.app, &q.connection_id, database, schema)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
+
+pub async fn list_available_extensions(
+    State(state): State<Arc<WebState>>,
+    Query(q): Query<SchemaQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let database = q.database.as_deref().unwrap_or("");
+    let result = dbx_core::schema::list_available_extensions_core(&state.app, &q.connection_id, database)
+        .await
+        .map_err(AppError)?;
+    Ok(Json(serde_json::to_value(result).map_err(|e| AppError(e.to_string()))?))
+}
diff --git a/crates/dbx-web/src/routes/schema_cache.rs b/crates/dbx-web/src/routes/schema_cache.rs
new file mode 100644
index 0000000..829df00
--- /dev/null
+++ b/crates/dbx-web/src/routes/schema_cache.rs
@@ -0,0 +1,49 @@
+use std::sync::Arc;
+
+use axum::extract::{Query, State};
+use axum::Json;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+pub struct SchemaCacheKeyQuery {
+    pub cache_key: String,
+}
+
+#[derive(Deserialize)]
+pub struct SchemaCachePrefixQuery {
+    pub prefix: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveSchemaCacheRequest {
+    pub cache_key: String,
+    pub payload: serde_json::Value,
+}
+
+pub async fn save_schema_cache(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<SaveSchemaCacheRequest>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.save_schema_cache(&body.cache_key, &body.payload).await.map_err(AppError)?;
+    Ok(Json(()))
+}
+
+pub async fn load_schema_cache(
+    State(state): State<Arc<WebState>>,
+    Query(query): Query<SchemaCacheKeyQuery>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let payload = state.app.storage.load_schema_cache(&query.cache_key).await.map_err(AppError)?;
+    Ok(Json(payload.unwrap_or(serde_json::json!(null))))
+}
+
+pub async fn delete_schema_cache_prefix(
+    State(state): State<Arc<WebState>>,
+    Query(query): Query<SchemaCachePrefixQuery>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.delete_schema_cache_prefix(&query.prefix).await.map_err(AppError)?;
+    Ok(Json(()))
+}
diff --git a/crates/dbx-web/src/routes/schema_diff.rs b/crates/dbx-web/src/routes/schema_diff.rs
new file mode 100644
index 0000000..97413e6
--- /dev/null
+++ b/crates/dbx-web/src/routes/schema_diff.rs
@@ -0,0 +1,34 @@
+use axum::Json;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GenerateSchemaSyncSqlRequest {
+    pub diffs: Vec<dbx_core::schema_diff::TableDiff>,
+    pub function_diffs: Option<Vec<dbx_core::schema_diff::FunctionDiff>>,
+    pub sequence_diffs: Option<Vec<dbx_core::schema_diff::SequenceDiff>>,
+    pub rule_diffs: Option<Vec<dbx_core::schema_diff::RuleDiff>>,
+    pub owner_diffs: Option<Vec<dbx_core::schema_diff::OwnerDiff>>,
+    pub database_type: dbx_core::models::connection::DatabaseType,
+    pub target_schema: Option<String>,
+    pub cascade_delete: Option<bool>,
+}
+
+pub async fn prepare_schema_diff(
+    Json(options): Json<dbx_core::schema_diff::SchemaDiffPreparationOptions>,
+) -> Json<dbx_core::schema_diff::SchemaDiffPreparation> {
+    Json(dbx_core::schema_diff::prepare_schema_diff(options))
+}
+
+pub async fn generate_schema_sync_sql(Json(req): Json<GenerateSchemaSyncSqlRequest>) -> Json<String> {
+    Json(dbx_core::schema_diff::generate_schema_sync_sql(
+        &req.diffs,
+        req.function_diffs.as_deref().unwrap_or_default(),
+        req.sequence_diffs.as_deref().unwrap_or_default(),
+        req.rule_diffs.as_deref().unwrap_or_default(),
+        req.owner_diffs.as_deref().unwrap_or_default(),
+        req.database_type,
+        req.target_schema.as_deref(),
+        req.cascade_delete.unwrap_or(false),
+    ))
+}
diff --git a/crates/dbx-web/src/routes/sql_file.rs b/crates/dbx-web/src/routes/sql_file.rs
new file mode 100644
index 0000000..4b416ad
--- /dev/null
+++ b/crates/dbx-web/src/routes/sql_file.rs
@@ -0,0 +1,232 @@
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+use axum::extract::{Multipart, Path as AxumPath, State};
+use axum::response::sse::{Event, Sse};
+use axum::Json;
+use dbx_core::sql;
+use dbx_core::sql::{SqlFileProgress, SqlFileRequest, SqlFileStatus};
+use dbx_core::sql_file_import::{
+    execute_sql_file_content, sql_file_error_progress, sql_file_progress as build_sql_file_progress,
+};
+use futures::stream::Stream;
+use serde::Deserialize;
+use tokio::sync::broadcast;
+use tokio_util::sync::CancellationToken;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SqlFileExecuteWrapper {
+    pub request: SqlFileRequest,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CancelSqlFileRequest {
+    pub execution_id: String,
+}
+
+pub async fn preview_sql_file(
+    State(state): State<Arc<WebState>>,
+    mut multipart: Multipart,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let tmp_dir = state.data_dir.join("tmp");
+    std::fs::create_dir_all(&tmp_dir).map_err(|e| AppError(e.to_string()))?;
+
+    if let Some(field) = multipart.next_field().await.map_err(|e| AppError(e.to_string()))? {
+        let file_name = field.file_name().unwrap_or("upload.sql").to_string();
+        let data = field.bytes().await.map_err(|e| AppError(e.to_string()))?;
+
+        let file_path = safe_uploaded_sql_path(&tmp_dir, &file_name)?;
+        std::fs::write(&file_path, &data).map_err(|e| AppError(e.to_string()))?;
+
+        let size_bytes = data.len() as u64;
+        let content = sql::decode_sql_file_bytes(&data).map_err(AppError)?;
+        let preview: String = content.chars().take(20_000).collect();
+
+        return Ok(Json(serde_json::json!({
+            "fileName": file_name,
+            "filePath": file_path.to_string_lossy(),
+            "sizeBytes": size_bytes,
+            "preview": preview,
+            "canExecuteWithoutSelectedDatabase": dbx_core::sql_file_import::mysql_like_sql_file_can_execute_without_selected_database(&content),
+        })));
+    }
+
+    Err(AppError("No file uploaded".to_string()))
+}
+
+pub async fn execute_sql_file(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<SqlFileExecuteWrapper>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let req = body.request;
+
+    // Fast-fail: reject early if the connection is read-only (individual statements are also checked in do_execute)
+    if let Some(name) = dbx_core::query::connection_readonly_name(&state.app, &req.connection_id).await {
+        return Err(AppError(format!(
+            "Read-only mode: connection '{}' has read-only protection enabled. SQL file execution blocked.",
+            name
+        )));
+    }
+
+    let execution_id = req.execution_id.clone();
+    let file_path = validated_uploaded_sql_path(&state.data_dir, &req.file_path)?;
+    let token = CancellationToken::new();
+
+    {
+        let mut executions = state.sql_file_executions.write().await;
+        if executions.contains_key(&execution_id) {
+            return Err(AppError(format!("SQL file execution '{execution_id}' already exists")));
+        }
+        executions.insert(execution_id.clone(), token.clone());
+    }
+    let (tx, _) = tokio::sync::broadcast::channel::<String>(256);
+    state.sse_channels.write().await.insert(execution_id.clone(), tx.clone());
+
+    let app = state.app.clone();
+    let state_clone = state.clone();
+
+    tokio::spawn(async move {
+        let started_at = std::time::Instant::now();
+        match std::fs::metadata(&file_path) {
+            Ok(meta) if meta.len() > 200 * 1024 * 1024 => {
+                send_sql_file_progress(
+                    &tx,
+                    sql_file_error_progress(
+                        &req.execution_id,
+                        started_at,
+                        format!("File too large: {} bytes (max {} bytes)", meta.len(), 200 * 1024 * 1024),
+                    ),
+                );
+                cleanup_sql_file_execution(&state_clone, &req.execution_id).await;
+                return;
+            }
+            Err(e) => {
+                send_sql_file_progress(&tx, sql_file_error_progress(&req.execution_id, started_at, e.to_string()));
+                cleanup_sql_file_execution(&state_clone, &req.execution_id).await;
+                return;
+            }
+            _ => {}
+        }
+
+        let file_content = match std::fs::read(&file_path).and_then(|bytes| {
+            sql::decode_sql_file_bytes(&bytes)
+                .map_err(|message| std::io::Error::new(std::io::ErrorKind::InvalidData, message))
+        }) {
+            Ok(content) => content,
+            Err(e) => {
+                send_sql_file_progress(&tx, sql_file_error_progress(&req.execution_id, started_at, e.to_string()));
+                cleanup_sql_file_execution(&state_clone, &req.execution_id).await;
+                return;
+            }
+        };
+
+        send_sql_file_progress(
+            &tx,
+            build_sql_file_progress(&req.execution_id, SqlFileStatus::Started, 0, 0, 0, 0, started_at, "", None),
+        );
+
+        let _ = execute_sql_file_content(&app, &req, &file_content, token, started_at, |progress| {
+            send_sql_file_progress(&tx, progress);
+        })
+        .await;
+
+        cleanup_sql_file_execution(&state_clone, &req.execution_id).await;
+    });
+
+    Ok(Json(serde_json::json!({ "executionId": execution_id })))
+}
+
+fn send_sql_file_progress(tx: &broadcast::Sender<String>, progress: SqlFileProgress) {
+    if let Ok(json) = serde_json::to_string(&progress) {
+        let _ = tx.send(json);
+    }
+}
+
+async fn cleanup_sql_file_execution(state: &WebState, execution_id: &str) {
+    state.remove_sse_channel(execution_id).await;
+    state.sql_file_executions.write().await.remove(execution_id);
+}
+
+fn safe_uploaded_sql_path(tmp_dir: &Path, file_name: &str) -> Result<PathBuf, AppError> {
+    let base_name = file_name.rsplit(['/', '\\']).find(|part| !part.is_empty()).unwrap_or("upload.sql").trim();
+    if base_name.is_empty() || base_name == "." || base_name == ".." {
+        return Err(AppError("Invalid SQL file name".to_string()));
+    }
+    Ok(tmp_dir.join(base_name))
+}
+
+fn validated_uploaded_sql_path(data_dir: &Path, file_path: &str) -> Result<PathBuf, AppError> {
+    let path = PathBuf::from(file_path);
+    if !path.is_absolute() {
+        return Err(AppError("File path must be absolute".to_string()));
+    }
+
+    let tmp_dir = data_dir.join("tmp").canonicalize().map_err(|e| AppError(e.to_string()))?;
+    let canonical_path = path.canonicalize().map_err(|e| AppError(e.to_string()))?;
+    if !canonical_path.starts_with(&tmp_dir) {
+        return Err(AppError("File path must be inside the uploaded SQL directory".to_string()));
+    }
+    Ok(canonical_path)
+}
+
+pub async fn sql_file_progress(
+    State(state): State<Arc<WebState>>,
+    AxumPath(execution_id): AxumPath<String>,
+) -> Result<Sse<impl Stream<Item = Result<Event, std::convert::Infallible>>>, AppError> {
+    let channels = state.sse_channels.read().await;
+    let tx = channels.get(&execution_id).ok_or_else(|| AppError("Execution not found".to_string()))?;
+    let rx = tx.subscribe();
+    drop(channels);
+    Ok(crate::sse::sse_from_channel(rx))
+}
+
+pub async fn cancel_sql_file(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<CancelSqlFileRequest>,
+) -> Json<serde_json::Value> {
+    let executions = state.sql_file_executions.read().await;
+    if let Some(token) = executions.get(&req.execution_id) {
+        token.cancel();
+        Json(serde_json::json!({ "cancelled": true }))
+    } else {
+        Json(serde_json::json!({ "cancelled": false }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{safe_uploaded_sql_path, validated_uploaded_sql_path};
+
+    #[test]
+    fn uploaded_sql_path_uses_only_the_file_name() {
+        let data_dir = std::env::temp_dir().join(format!("dbx-web-sql-file-test-{}", uuid::Uuid::new_v4()));
+        let tmp_dir = data_dir.join("tmp");
+
+        let path = match safe_uploaded_sql_path(&tmp_dir, "../outside.sql") {
+            Ok(path) => path,
+            Err(error) => panic!("{}", error.0),
+        };
+
+        assert_eq!(path, tmp_dir.join("outside.sql"));
+        let _ = std::fs::remove_dir_all(data_dir);
+    }
+
+    #[test]
+    fn execution_path_must_stay_inside_uploaded_tmp_dir() {
+        let data_dir = std::env::temp_dir().join(format!("dbx-web-sql-file-test-{}", uuid::Uuid::new_v4()));
+        let tmp_dir = data_dir.join("tmp");
+        std::fs::create_dir_all(&tmp_dir).unwrap();
+        let outside = data_dir.join("outside.sql");
+        std::fs::write(&outside, "select 1;").unwrap();
+
+        let result = validated_uploaded_sql_path(&data_dir, &outside.to_string_lossy());
+
+        assert!(result.is_err());
+        let _ = std::fs::remove_dir_all(data_dir);
+    }
+}
diff --git a/crates/dbx-web/src/routes/ssh_config.rs b/crates/dbx-web/src/routes/ssh_config.rs
new file mode 100644
index 0000000..61cdd81
--- /dev/null
+++ b/crates/dbx-web/src/routes/ssh_config.rs
@@ -0,0 +1,8 @@
+use axum::Json;
+use dbx_core::ssh_config::{self, SshConfigHostEntry};
+
+use crate::error::AppError;
+
+pub async fn list_ssh_config_hosts() -> Result<Json<Vec<SshConfigHostEntry>>, AppError> {
+    Ok(Json(ssh_config::list_hosts().map_err(AppError::internal)?))
+}
diff --git a/crates/dbx-web/src/routes/tab_runtime_cache.rs b/crates/dbx-web/src/routes/tab_runtime_cache.rs
new file mode 100644
index 0000000..49ce8be
--- /dev/null
+++ b/crates/dbx-web/src/routes/tab_runtime_cache.rs
@@ -0,0 +1,71 @@
+use std::sync::Arc;
+
+use axum::extract::{Query, State};
+use axum::Json;
+use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
+use serde::{Deserialize, Serialize};
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveTabRuntimeCacheRequest {
+    pub key: String,
+    pub payload_base64: String,
+    pub row_count: i64,
+    pub column_count: i64,
+}
+
+#[derive(Deserialize)]
+pub struct TabRuntimeCacheKeyQuery {
+    pub key: String,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LoadTabRuntimeCacheResponse {
+    pub key: String,
+    pub payload_base64: String,
+    pub row_count: i64,
+    pub column_count: i64,
+    pub byte_size: i64,
+    pub updated_at: String,
+}
+
+pub async fn save_tab_runtime_cache(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SaveTabRuntimeCacheRequest>,
+) -> Result<Json<()>, AppError> {
+    let payload = BASE64.decode(req.payload_base64).map_err(|e| AppError::bad_request(e.to_string()))?;
+    state
+        .app
+        .storage
+        .save_tab_runtime_cache(&req.key, payload, req.row_count, req.column_count)
+        .await
+        .map_err(AppError::internal)?;
+    Ok(Json(()))
+}
+
+pub async fn load_tab_runtime_cache(
+    State(state): State<Arc<WebState>>,
+    Query(query): Query<TabRuntimeCacheKeyQuery>,
+) -> Result<Json<Option<LoadTabRuntimeCacheResponse>>, AppError> {
+    let entry = state.app.storage.load_tab_runtime_cache(&query.key).await.map_err(AppError::internal)?;
+    Ok(Json(entry.map(|entry| LoadTabRuntimeCacheResponse {
+        key: entry.key,
+        payload_base64: BASE64.encode(entry.payload),
+        row_count: entry.row_count,
+        column_count: entry.column_count,
+        byte_size: entry.byte_size,
+        updated_at: entry.updated_at,
+    })))
+}
+
+pub async fn delete_tab_runtime_cache(
+    State(state): State<Arc<WebState>>,
+    Query(query): Query<TabRuntimeCacheKeyQuery>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.delete_tab_runtime_cache(&query.key).await.map_err(AppError::internal)?;
+    Ok(Json(()))
+}
diff --git a/crates/dbx-web/src/routes/table_export.rs b/crates/dbx-web/src/routes/table_export.rs
new file mode 100644
index 0000000..3949e45
--- /dev/null
+++ b/crates/dbx-web/src/routes/table_export.rs
@@ -0,0 +1,158 @@
+use std::{
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    time::Duration,
+};
+
+use axum::body::Body;
+use axum::extract::{Path, State};
+use axum::http::{header, StatusCode};
+use axum::response::{Response, Sse};
+use axum::Json;
+use dbx_core::table_export::{self, ExportStatus, TableExportProgress, TableExportRequest};
+use futures::stream::Stream;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StartExportRequest {
+    pub request: TableExportRequest,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CancelExportRequest {
+    pub export_id: String,
+}
+
+pub async fn start_table_export(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<StartExportRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let mut req = body.request;
+    let export_id = req.export_id.clone();
+
+    // Generate temp file path for web export output
+    let tmp_dir = state.data_dir.join("tmp");
+    std::fs::create_dir_all(&tmp_dir).map_err(|e| AppError(e.to_string()))?;
+    let ext = match req.format.as_str() {
+        "csv" => "csv",
+        "xlsx" => "xlsx",
+        "json" => "json",
+        "markdown" | "md" => "md",
+        "sql" => "sql",
+        _ => return Err(AppError(format!("Unsupported export format: {}", req.format))),
+    };
+    let tmp_file = tmp_dir.join(format!("table_export_{export_id}.{ext}"));
+    let file_path = tmp_file.to_string_lossy().to_string();
+    req.file_path = file_path.clone();
+
+    // Store export file mapping for download
+    state.export_files.write().await.insert(export_id.clone(), (file_path, req.format.clone()));
+
+    let tx = {
+        let mut channels = state.sse_channels.write().await;
+        channels.entry(export_id.clone()).or_insert_with(|| tokio::sync::broadcast::channel::<String>(256).0).clone()
+    };
+
+    let app = state.app.clone();
+    let state_clone = state.clone();
+    let cancelled = Arc::new(AtomicBool::new(false));
+    let cancelled_progress = cancelled.clone();
+
+    tokio::spawn(async move {
+        let result = table_export::export_table_data_core(&app, &req, |progress| {
+            if matches!(progress.status, ExportStatus::Cancelled) {
+                cancelled_progress.store(true, Ordering::SeqCst);
+            }
+            if let Ok(json) = serde_json::to_string(&progress) {
+                let _ = tx.send(json);
+            }
+        })
+        .await;
+
+        if let Err(e) = result {
+            let _ = tokio::fs::remove_file(&req.file_path).await;
+            state_clone.export_files.write().await.remove(&req.export_id);
+            let progress = TableExportProgress {
+                export_id: req.export_id.clone(),
+                table_name: req.table_name.clone(),
+                rows_exported: 0,
+                total_rows: None,
+                status: ExportStatus::Error,
+                error_message: Some(e),
+            };
+            if let Ok(json) = serde_json::to_string(&progress) {
+                let _ = tx.send(json);
+            }
+        } else if cancelled.load(Ordering::SeqCst) {
+            let _ = tokio::fs::remove_file(&req.file_path).await;
+            state_clone.export_files.write().await.remove(&req.export_id);
+        }
+
+        dbx_core::database_export::clear_export_cancelled(&req.export_id).await;
+        tokio::time::sleep(Duration::from_secs(5)).await;
+        state_clone.remove_sse_channel(&req.export_id).await;
+    });
+
+    Ok(Json(serde_json::json!({ "exportId": export_id })))
+}
+
+pub async fn table_export_progress(
+    State(state): State<Arc<WebState>>,
+    Path(export_id): Path<String>,
+) -> Result<Sse<impl Stream<Item = Result<axum::response::sse::Event, std::convert::Infallible>>>, AppError> {
+    let tx = {
+        let mut channels = state.sse_channels.write().await;
+        channels.entry(export_id).or_insert_with(|| tokio::sync::broadcast::channel::<String>(256).0).clone()
+    };
+    let rx = tx.subscribe();
+    Ok(crate::sse::sse_from_channel(rx))
+}
+
+pub async fn cancel_table_export(
+    State(_state): State<Arc<WebState>>,
+    Json(req): Json<CancelExportRequest>,
+) -> Json<serde_json::Value> {
+    dbx_core::database_export::set_export_cancelled(&req.export_id).await;
+    Json(serde_json::json!({ "cancelled": true }))
+}
+
+pub async fn table_export_download(
+    State(state): State<Arc<WebState>>,
+    Path(export_id): Path<String>,
+) -> Result<Response, AppError> {
+    let (file_path, format) = state
+        .export_files
+        .write()
+        .await
+        .remove(&export_id)
+        .ok_or_else(|| AppError("Export file not found".to_string()))?;
+
+    let data = tokio::fs::read(&file_path).await.map_err(|e| AppError(e.to_string()))?;
+    // Clean up temp file
+    let _ = tokio::fs::remove_file(&file_path).await;
+
+    let (content_type, file_ext) = match format.as_str() {
+        "csv" => ("text/csv; charset=utf-8", "csv"),
+        "xlsx" => ("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "xlsx"),
+        "json" => ("application/json; charset=utf-8", "json"),
+        "markdown" | "md" => ("text/markdown; charset=utf-8", "md"),
+        "sql" => ("application/sql; charset=utf-8", "sql"),
+        _ => return Err(AppError(format!("Unknown format: {format}"))),
+    };
+
+    let filename = format!("table_export_{export_id}.{file_ext}");
+
+    Response::builder()
+        .status(StatusCode::OK)
+        .header(header::CONTENT_TYPE, content_type)
+        .header(header::CONTENT_DISPOSITION, format!("attachment; filename=\"{filename}\""))
+        .body(Body::from(data))
+        .map_err(|e| AppError(e.to_string()))
+}
diff --git a/crates/dbx-web/src/routes/table_import.rs b/crates/dbx-web/src/routes/table_import.rs
new file mode 100644
index 0000000..d7f9d1a
--- /dev/null
+++ b/crates/dbx-web/src/routes/table_import.rs
@@ -0,0 +1,271 @@
+use std::path::{Path as StdPath, PathBuf};
+use std::sync::Arc;
+use std::time::{Duration, SystemTime};
+
+use axum::body::Bytes;
+use axum::extract::{Multipart, Path, State};
+use axum::response::sse::{Event, Sse};
+use axum::Json;
+use dbx_core::table_import::{
+    self, TableImportParseOptions, TableImportPreviewRequest, TableImportRequest, TableImportSourceFormat,
+};
+use dbx_core::transfer;
+use futures::stream::Stream;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExecuteImportWrapper {
+    pub request: TableImportRequest,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CancelImportRequest {
+    pub import_id: String,
+}
+
+pub async fn preview_import(
+    State(state): State<Arc<WebState>>,
+    mut multipart: Multipart,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let tmp_dir = import_upload_dir(&state.data_dir);
+    std::fs::create_dir_all(&tmp_dir).map_err(|e| AppError(e.to_string()))?;
+    cleanup_expired_import_uploads(&tmp_dir, Duration::from_secs(24 * 60 * 60));
+
+    let mut uploaded_file: Option<(String, Bytes)> = None;
+    let mut source_format: Option<TableImportSourceFormat> = None;
+    let mut parse_options = TableImportParseOptions::default();
+    let mut preview_limit: Option<usize> = None;
+
+    while let Some(field) = multipart.next_field().await.map_err(|e| AppError(e.to_string()))? {
+        let name = field.name().unwrap_or_default().to_string();
+        if name == "file" {
+            let file_name = field.file_name().unwrap_or("upload.csv").to_string();
+            let data = field.bytes().await.map_err(|e| AppError(e.to_string()))?;
+            uploaded_file = Some((file_name, data));
+        } else {
+            let value = field.text().await.map_err(|e| AppError(e.to_string()))?;
+            match name.as_str() {
+                "sourceFormat" => {
+                    source_format = Some(
+                        serde_json::from_value(serde_json::Value::String(value))
+                            .map_err(|e| AppError(e.to_string()))?,
+                    );
+                }
+                "parseOptions" => {
+                    parse_options = serde_json::from_str(&value).map_err(|e| AppError(e.to_string()))?;
+                }
+                "previewLimit" => {
+                    preview_limit = value.parse::<usize>().ok();
+                }
+                _ => {}
+            }
+        }
+    }
+
+    if let Some((file_name, data)) = uploaded_file {
+        if data.len() > 100 * 1024 * 1024 {
+            return Err(AppError(format!("File too large: {} bytes (max {} bytes)", data.len(), 100 * 1024 * 1024)));
+        }
+
+        let source_ref = uuid::Uuid::new_v4().to_string();
+        let file_path = safe_uploaded_import_path(&tmp_dir, &file_name, &source_ref)?;
+        std::fs::write(&file_path, &data).map_err(|e| AppError(e.to_string()))?;
+
+        let file_path_str = file_path.to_string_lossy().to_string();
+        let preview = table_import::preview_table_import_file_with_request(TableImportPreviewRequest {
+            file_path: file_path_str,
+            source_ref: Some(source_ref),
+            source_format,
+            parse_options,
+            preview_limit,
+        })
+        .await;
+        let preview = preview.map_err(AppError)?;
+        return Ok(Json(serde_json::to_value(preview).map_err(|e| AppError(e.to_string()))?));
+    }
+
+    Err(AppError("No file uploaded".to_string()))
+}
+
+pub async fn execute_import(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<ExecuteImportWrapper>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let mut req = body.request;
+    let file_path = validated_uploaded_import_path(&state.data_dir, &req.file_path)?;
+    req.file_path = file_path.to_string_lossy().to_string();
+
+    // Reject import early if the connection is read-only
+    if let Some(name) = dbx_core::query::connection_readonly_name(&state.app, &req.connection_id).await {
+        cleanup_uploaded_import_source(&req.file_path).await;
+        return Err(AppError(format!(
+            "Read-only mode: connection '{}' has read-only protection enabled. Import blocked.",
+            name
+        )));
+    }
+
+    let import_id = req.import_id.clone();
+
+    let (tx, _) = tokio::sync::broadcast::channel::<String>(256);
+    state.sse_channels.write().await.insert(import_id.clone(), tx.clone());
+
+    let app = state.app.clone();
+    let state_clone = state.clone();
+
+    tokio::spawn(async move {
+        let db_type = match transfer::get_db_type(&app, &req.connection_id).await {
+            Ok(t) => t,
+            Err(e) => {
+                let _ = tx.send(
+                    serde_json::json!({
+                        "importId": req.import_id.clone(),
+                        "status": "error",
+                        "rowsImported": 0,
+                        "totalRows": 0,
+                        "error": e
+                    })
+                    .to_string(),
+                );
+                cleanup_uploaded_import_source(&req.file_path).await;
+                state_clone.sse_channels.write().await.remove(&req.import_id);
+                return;
+            }
+        };
+
+        let pool_key = match app.get_or_create_pool(&req.connection_id, Some(&req.database)).await {
+            Ok(k) => k,
+            Err(e) => {
+                let _ = tx.send(
+                    serde_json::json!({
+                        "importId": req.import_id.clone(),
+                        "status": "error",
+                        "rowsImported": 0,
+                        "totalRows": 0,
+                        "error": e
+                    })
+                    .to_string(),
+                );
+                cleanup_uploaded_import_source(&req.file_path).await;
+                state_clone.sse_channels.write().await.remove(&req.import_id);
+                return;
+            }
+        };
+
+        let tx_clone = tx.clone();
+        let import_id_for_cancel = req.import_id.clone();
+        let result = table_import::import_table_file_core(
+            &app,
+            &req,
+            &db_type,
+            &pool_key,
+            |id: &str| {
+                let id = id.to_string();
+                Box::pin(async move { transfer::is_cancelled(&id).await })
+            },
+            |progress| {
+                if let Ok(json) = serde_json::to_string(&progress) {
+                    let _ = tx_clone.send(json);
+                }
+            },
+        )
+        .await;
+
+        match result {
+            Ok(summary) => {
+                if let Ok(json) = serde_json::to_string(&summary) {
+                    let _ = tx.send(json);
+                }
+            }
+            Err(e) => {
+                let _ = tx.send(
+                    serde_json::json!({
+                        "importId": import_id_for_cancel,
+                        "status": "error",
+                        "rowsImported": 0,
+                        "totalRows": 0,
+                        "error": e
+                    })
+                    .to_string(),
+                );
+            }
+        }
+
+        cleanup_uploaded_import_source(&req.file_path).await;
+        state_clone.sse_channels.write().await.remove(&req.import_id);
+    });
+
+    Ok(Json(serde_json::json!({ "importId": import_id })))
+}
+
+pub async fn import_progress(
+    State(state): State<Arc<WebState>>,
+    Path(import_id): Path<String>,
+) -> Result<Sse<impl Stream<Item = Result<Event, std::convert::Infallible>>>, AppError> {
+    let channels = state.sse_channels.read().await;
+    let tx = channels.get(&import_id).ok_or_else(|| AppError("Import not found".to_string()))?;
+    let rx = tx.subscribe();
+    drop(channels);
+    Ok(crate::sse::sse_from_channel(rx))
+}
+
+pub async fn cancel_import(
+    State(_state): State<Arc<WebState>>,
+    Json(req): Json<CancelImportRequest>,
+) -> Json<serde_json::Value> {
+    transfer::set_cancelled(&req.import_id).await;
+    Json(serde_json::json!({ "cancelled": true }))
+}
+
+fn import_upload_dir(data_dir: &StdPath) -> PathBuf {
+    data_dir.join("tmp").join("table_import")
+}
+
+fn safe_uploaded_import_path(tmp_dir: &StdPath, file_name: &str, source_ref: &str) -> Result<PathBuf, AppError> {
+    let base_name = file_name.rsplit(['/', '\\']).find(|part| !part.is_empty()).unwrap_or("upload.csv").trim();
+    if base_name.is_empty() || base_name == "." || base_name == ".." {
+        return Err(AppError("Invalid import file name".to_string()));
+    }
+    Ok(tmp_dir.join(format!("{source_ref}-{base_name}")))
+}
+
+fn validated_uploaded_import_path(data_dir: &StdPath, file_path: &str) -> Result<PathBuf, AppError> {
+    let path = PathBuf::from(file_path);
+    if !path.is_absolute() {
+        return Err(AppError("Import source path must be absolute".to_string()));
+    }
+
+    let tmp_dir = import_upload_dir(data_dir).canonicalize().map_err(|e| AppError(e.to_string()))?;
+    let canonical_path =
+        path.canonicalize().map_err(|e| AppError(format!("Import source is no longer available: {e}")))?;
+    if !canonical_path.starts_with(&tmp_dir) {
+        return Err(AppError("Import source must be inside the uploaded import directory".to_string()));
+    }
+    Ok(canonical_path)
+}
+
+fn cleanup_expired_import_uploads(tmp_dir: &StdPath, max_age: Duration) {
+    let Ok(entries) = std::fs::read_dir(tmp_dir) else {
+        return;
+    };
+    let now = SystemTime::now();
+    for entry in entries.flatten() {
+        let Ok(metadata) = entry.metadata() else {
+            continue;
+        };
+        let Ok(modified) = metadata.modified() else {
+            continue;
+        };
+        if now.duration_since(modified).map(|age| age > max_age).unwrap_or(false) {
+            let _ = std::fs::remove_file(entry.path());
+        }
+    }
+}
+
+async fn cleanup_uploaded_import_source(file_path: &str) {
+    let _ = tokio::fs::remove_file(file_path).await;
+}
diff --git a/crates/dbx-web/src/routes/text_export.rs b/crates/dbx-web/src/routes/text_export.rs
new file mode 100644
index 0000000..6ea4366
--- /dev/null
+++ b/crates/dbx-web/src/routes/text_export.rs
@@ -0,0 +1,38 @@
+use axum::Json;
+use dbx_core::text_export::{format_json, format_markdown, QueryResultTextExportData};
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+use crate::error::AppError;
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryResultTextExportRequest {
+    pub columns: Vec<String>,
+    pub rows: Vec<Vec<Value>>,
+}
+
+impl QueryResultTextExportRequest {
+    fn data(self) -> QueryResultTextExportData {
+        QueryResultTextExportData { columns: self.columns, rows: self.rows }
+    }
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryResultTextExportResponse {
+    pub content: String,
+}
+
+pub async fn export_query_result_json(
+    Json(req): Json<QueryResultTextExportRequest>,
+) -> Result<Json<QueryResultTextExportResponse>, AppError> {
+    let content = format_json(&req.data()).map_err(AppError::from)?;
+    Ok(Json(QueryResultTextExportResponse { content }))
+}
+
+pub async fn export_query_result_markdown(
+    Json(req): Json<QueryResultTextExportRequest>,
+) -> Json<QueryResultTextExportResponse> {
+    Json(QueryResultTextExportResponse { content: format_markdown(&req.data()) })
+}
diff --git a/crates/dbx-web/src/routes/transfer.rs b/crates/dbx-web/src/routes/transfer.rs
new file mode 100644
index 0000000..3f73fca
--- /dev/null
+++ b/crates/dbx-web/src/routes/transfer.rs
@@ -0,0 +1,420 @@
+use std::sync::Arc;
+
+use axum::extract::{Path, State};
+use axum::response::sse::{Event, Sse};
+use axum::Json;
+use dbx_core::transfer::{self, TransferRequest, TransferStatus};
+use futures::stream::Stream;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StartTransferRequest {
+    pub request: TransferRequest,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CancelTransferRequest {
+    pub transfer_id: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PreviewTransferOwnershipRequest {
+    pub request: TransferRequest,
+}
+
+pub async fn start_transfer(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<StartTransferRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let req = body.request;
+    transfer::validate_transfer_target_table_names(&req).map_err(AppError)?;
+
+    // Reject transfer early if the target connection is read-only
+    if let Some(name) = dbx_core::query::connection_readonly_name(&state.app, &req.target_connection_id).await {
+        return Err(AppError(format!(
+            "Read-only mode: target connection '{}' has read-only protection enabled. Transfer blocked.",
+            name
+        )));
+    }
+
+    let transfer_id = req.transfer_id.clone();
+
+    // Create a broadcast channel for progress
+    let (tx, _) = tokio::sync::broadcast::channel::<String>(256);
+    state.sse_channels.write().await.insert(transfer_id.clone(), tx.clone());
+
+    let app = state.app.clone();
+    let state_clone = state.clone();
+
+    tokio::spawn(async move {
+        let source_db_type = match transfer::get_db_type(&app, &req.source_connection_id).await {
+            Ok(t) => t,
+            Err(e) => {
+                let _ = tx.send(serde_json::json!({"error": e}).to_string());
+                return;
+            }
+        };
+        let target_db_type = match transfer::get_db_type(&app, &req.target_connection_id).await {
+            Ok(t) => t,
+            Err(e) => {
+                let _ = tx.send(serde_json::json!({"error": e}).to_string());
+                return;
+            }
+        };
+
+        let source_pool_key = match app.get_or_create_pool(&req.source_connection_id, Some(&req.source_database)).await
+        {
+            Ok(k) => k,
+            Err(e) => {
+                let _ = tx.send(serde_json::json!({"error": e}).to_string());
+                return;
+            }
+        };
+        let target_pool_key = match app.get_or_create_pool(&req.target_connection_id, Some(&req.target_database)).await
+        {
+            Ok(k) => k,
+            Err(e) => {
+                let _ = tx.send(serde_json::json!({"error": e}).to_string());
+                return;
+            }
+        };
+
+        let tables = req.tables.clone();
+        // Sort by FK dependency so referenced tables are transferred first.
+        let tables = transfer::sort_tables_by_fk_dependency(
+            &app,
+            &req.source_connection_id,
+            &req.source_database,
+            &req.source_schema,
+            &tables,
+            true,
+        )
+        .await
+        .unwrap_or_else(|e| {
+            log::warn!("[transfer] failed to sort tables by FK dependency, using original order: {e}");
+            tables
+        });
+        let mut failed_tables: Vec<String> = Vec::new();
+
+        if matches!(source_db_type, dbx_core::models::connection::DatabaseType::Postgres)
+            && matches!(target_db_type, dbx_core::models::connection::DatabaseType::Postgres)
+        {
+            let tx_clone = tx.clone();
+            match transfer::transfer_postgres_schema_dependencies(
+                &app,
+                &req,
+                &source_pool_key,
+                &target_pool_key,
+                |progress| {
+                    if let Ok(json) = serde_json::to_string(&progress) {
+                        let _ = tx_clone.send(json);
+                    }
+                },
+            )
+            .await
+            {
+                Ok(()) => {}
+                Err(e) if e == "Cancelled" => {
+                    let progress = transfer::TransferProgress {
+                        transfer_id: req.transfer_id.clone(),
+                        table: "schema dependencies".to_string(),
+                        table_index: 0,
+                        total_tables: tables.len(),
+                        rows_transferred: 0,
+                        total_rows: None,
+                        status: TransferStatus::Cancelled,
+                        error: None,
+                        terminal: true,
+                    };
+                    if let Ok(json) = serde_json::to_string(&progress) {
+                        let _ = tx.send(json);
+                    }
+                    transfer::clear_cancelled(&req.transfer_id).await;
+                    state_clone.remove_sse_channel(&req.transfer_id).await;
+                    return;
+                }
+                Err(e) => {
+                    let progress = transfer::TransferProgress {
+                        transfer_id: req.transfer_id.clone(),
+                        table: "schema dependencies".to_string(),
+                        table_index: 0,
+                        total_tables: tables.len(),
+                        rows_transferred: 0,
+                        total_rows: None,
+                        status: TransferStatus::Error,
+                        error: Some(e),
+                        terminal: true,
+                    };
+                    if let Ok(json) = serde_json::to_string(&progress) {
+                        let _ = tx.send(json);
+                    }
+                    transfer::clear_cancelled(&req.transfer_id).await;
+                    state_clone.remove_sse_channel(&req.transfer_id).await;
+                    return;
+                }
+            }
+        }
+
+        for (i, table) in tables.iter().enumerate() {
+            if transfer::is_cancelled(&req.transfer_id).await {
+                let progress = transfer::TransferProgress {
+                    transfer_id: req.transfer_id.clone(),
+                    table: table.clone(),
+                    table_index: i,
+                    total_tables: tables.len(),
+                    rows_transferred: 0,
+                    total_rows: None,
+                    status: TransferStatus::Cancelled,
+                    error: None,
+                    terminal: true,
+                };
+                if let Ok(json) = serde_json::to_string(&progress) {
+                    let _ = tx.send(json);
+                }
+                transfer::clear_cancelled(&req.transfer_id).await;
+                state_clone.remove_sse_channel(&req.transfer_id).await;
+                return;
+            }
+
+            let tx_clone = tx.clone();
+            let mut last_rows_transferred = 0_u64;
+            let mut last_total_rows = None;
+            let result = transfer::transfer_table(
+                &app,
+                &req,
+                table,
+                i,
+                &source_db_type,
+                &target_db_type,
+                &source_pool_key,
+                &target_pool_key,
+                |progress| {
+                    last_rows_transferred = progress.rows_transferred;
+                    last_total_rows = progress.total_rows;
+                    if let Ok(json) = serde_json::to_string(&progress) {
+                        let _ = tx_clone.send(json);
+                    }
+                },
+            )
+            .await;
+
+            match result {
+                Ok(rows) => {
+                    let progress = transfer::TransferProgress {
+                        transfer_id: req.transfer_id.clone(),
+                        table: table.clone(),
+                        table_index: i,
+                        total_tables: tables.len(),
+                        rows_transferred: rows,
+                        total_rows: last_total_rows.or(Some(rows)),
+                        status: TransferStatus::TableDone,
+                        error: None,
+                        terminal: false,
+                    };
+                    if let Ok(json) = serde_json::to_string(&progress) {
+                        let _ = tx.send(json);
+                    }
+                }
+                Err(e) => {
+                    if e == "Cancelled" {
+                        let progress = transfer::TransferProgress {
+                            transfer_id: req.transfer_id.clone(),
+                            table: table.clone(),
+                            table_index: i,
+                            total_tables: tables.len(),
+                            rows_transferred: 0,
+                            total_rows: None,
+                            status: TransferStatus::Cancelled,
+                            error: None,
+                            terminal: true,
+                        };
+                        if let Ok(json) = serde_json::to_string(&progress) {
+                            let _ = tx.send(json);
+                        }
+                        transfer::clear_cancelled(&req.transfer_id).await;
+                        state_clone.remove_sse_channel(&req.transfer_id).await;
+                        return;
+                    }
+                    failed_tables.push(table.clone());
+                    let progress = transfer::TransferProgress {
+                        transfer_id: req.transfer_id.clone(),
+                        table: table.clone(),
+                        table_index: i,
+                        total_tables: tables.len(),
+                        rows_transferred: last_rows_transferred,
+                        total_rows: last_total_rows,
+                        status: TransferStatus::Error,
+                        error: Some(e),
+                        terminal: false,
+                    };
+                    if let Ok(json) = serde_json::to_string(&progress) {
+                        let _ = tx.send(json);
+                    }
+                }
+            }
+        }
+
+        if matches!(source_db_type, dbx_core::models::connection::DatabaseType::Postgres)
+            && matches!(target_db_type, dbx_core::models::connection::DatabaseType::Postgres)
+        {
+            let tx_clone = tx.clone();
+            match transfer::transfer_postgres_schema_objects(
+                &app,
+                &req,
+                &source_pool_key,
+                &target_pool_key,
+                |progress| {
+                    if let Ok(json) = serde_json::to_string(&progress) {
+                        let _ = tx_clone.send(json);
+                    }
+                },
+            )
+            .await
+            {
+                Ok(()) => {}
+                Err(e) if e == "Cancelled" => {
+                    let progress = transfer::TransferProgress {
+                        transfer_id: req.transfer_id.clone(),
+                        table: "schema objects".to_string(),
+                        table_index: tables.len(),
+                        total_tables: tables.len(),
+                        rows_transferred: 0,
+                        total_rows: None,
+                        status: TransferStatus::Cancelled,
+                        error: None,
+                        terminal: true,
+                    };
+                    if let Ok(json) = serde_json::to_string(&progress) {
+                        let _ = tx.send(json);
+                    }
+                    transfer::clear_cancelled(&req.transfer_id).await;
+                    state_clone.remove_sse_channel(&req.transfer_id).await;
+                    return;
+                }
+                Err(e) => {
+                    failed_tables.push("schema objects".to_string());
+                    let progress = transfer::TransferProgress {
+                        transfer_id: req.transfer_id.clone(),
+                        table: "schema objects".to_string(),
+                        table_index: tables.len(),
+                        total_tables: tables.len(),
+                        rows_transferred: 0,
+                        total_rows: None,
+                        status: TransferStatus::Error,
+                        error: Some(e),
+                        terminal: false,
+                    };
+                    if let Ok(json) = serde_json::to_string(&progress) {
+                        let _ = tx.send(json);
+                    }
+                }
+            }
+        }
+
+        // Send done
+        let done = transfer::TransferProgress {
+            transfer_id: req.transfer_id.clone(),
+            table: String::new(),
+            table_index: tables.len(),
+            total_tables: tables.len(),
+            rows_transferred: 0,
+            total_rows: None,
+            status: if failed_tables.is_empty() { TransferStatus::Done } else { TransferStatus::Error },
+            error: if failed_tables.is_empty() {
+                None
+            } else {
+                Some(format!(
+                    "{} table(s) failed: {}",
+                    failed_tables.len(),
+                    failed_tables.iter().take(5).cloned().collect::<Vec<_>>().join(", ")
+                ))
+            },
+            terminal: true,
+        };
+        if let Ok(json) = serde_json::to_string(&done) {
+            let _ = tx.send(json);
+        }
+
+        transfer::clear_cancelled(&req.transfer_id).await;
+        state_clone.remove_sse_channel(&req.transfer_id).await;
+    });
+
+    Ok(Json(serde_json::json!({ "transferId": transfer_id })))
+}
+
+pub async fn preview_transfer_ownership(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<PreviewTransferOwnershipRequest>,
+) -> Result<Json<dbx_core::transfer::TransferOwnershipPreview>, AppError> {
+    let req = body.request;
+    transfer::validate_transfer_target_table_names(&req).map_err(AppError)?;
+    let source_db_type = transfer::get_db_type(&state.app, &req.source_connection_id).await.map_err(AppError)?;
+    let target_db_type = transfer::get_db_type(&state.app, &req.target_connection_id).await.map_err(AppError)?;
+    let source_pool_key =
+        state.app.get_or_create_pool(&req.source_connection_id, Some(&req.source_database)).await.map_err(AppError)?;
+    let target_pool_key =
+        state.app.get_or_create_pool(&req.target_connection_id, Some(&req.target_database)).await.map_err(AppError)?;
+    let preview = transfer::preview_transfer_ownership(
+        &state.app,
+        &req,
+        &source_db_type,
+        &target_db_type,
+        &source_pool_key,
+        &target_pool_key,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(preview))
+}
+
+pub async fn transfer_progress(
+    State(state): State<Arc<WebState>>,
+    Path(transfer_id): Path<String>,
+) -> Result<Sse<impl Stream<Item = Result<Event, std::convert::Infallible>>>, AppError> {
+    let channels = state.sse_channels.read().await;
+    let tx = channels.get(&transfer_id).ok_or_else(|| AppError("Transfer not found".to_string()))?;
+    let rx = tx.subscribe();
+    drop(channels);
+    Ok(crate::sse::sse_from_channel(rx))
+}
+
+pub async fn cancel_transfer(
+    State(_state): State<Arc<WebState>>,
+    Json(req): Json<CancelTransferRequest>,
+) -> Json<serde_json::Value> {
+    transfer::set_cancelled(&req.transfer_id).await;
+    Json(serde_json::json!({ "cancelled": true }))
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SortTablesByFkRequest {
+    pub connection_id: String,
+    pub database: String,
+    pub schema: String,
+    pub tables: Vec<String>,
+    pub parents_first: bool,
+}
+
+pub async fn sort_tables_by_fk_dependency(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<SortTablesByFkRequest>,
+) -> Result<Json<Vec<String>>, AppError> {
+    transfer::sort_tables_by_fk_dependency(
+        &state.app,
+        &req.connection_id,
+        &req.database,
+        &req.schema,
+        &req.tables,
+        req.parents_first,
+    )
+    .await
+    .map(Json)
+    .map_err(AppError)
+}
diff --git a/crates/dbx-web/src/routes/tunnel_profiles.rs b/crates/dbx-web/src/routes/tunnel_profiles.rs
new file mode 100644
index 0000000..90fc283
--- /dev/null
+++ b/crates/dbx-web/src/routes/tunnel_profiles.rs
@@ -0,0 +1,28 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+use dbx_core::models::connection::TransportLayerConfig;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveTunnelProfilesRequest {
+    pub profiles: Vec<TransportLayerConfig>,
+}
+
+pub async fn load_tunnel_profiles(
+    State(state): State<Arc<WebState>>,
+) -> Result<Json<Vec<TransportLayerConfig>>, AppError> {
+    state.app.storage.load_tunnel_profiles().await.map(Json).map_err(AppError)
+}
+
+pub async fn save_tunnel_profiles(
+    State(state): State<Arc<WebState>>,
+    Json(body): Json<SaveTunnelProfilesRequest>,
+) -> Result<Json<()>, AppError> {
+    state.app.storage.save_tunnel_profiles(&body.profiles).await.map(Json).map_err(AppError)
+}
diff --git a/crates/dbx-web/src/routes/update.rs b/crates/dbx-web/src/routes/update.rs
new file mode 100644
index 0000000..e3ca0bd
--- /dev/null
+++ b/crates/dbx-web/src/routes/update.rs
@@ -0,0 +1,21 @@
+use axum::{extract::Query, Json};
+use dbx_core::update;
+
+use crate::error::AppError;
+
+pub async fn get_version() -> Json<serde_json::Value> {
+    Json(serde_json::json!({ "version": env!("CARGO_PKG_VERSION") }))
+}
+
+#[derive(serde::Deserialize)]
+pub struct UpdateCheckParams {
+    #[serde(default)]
+    pub locale: Option<String>,
+}
+
+pub async fn check_for_updates(Query(params): Query<UpdateCheckParams>) -> Result<Json<serde_json::Value>, AppError> {
+    let locale = params.locale.unwrap_or_else(|| "zh-CN".to_string());
+    let release = update::fetch_latest_release(&locale).await.map_err(AppError)?;
+    let info = update::build_update_info(release, env!("CARGO_PKG_VERSION"));
+    Ok(Json(serde_json::to_value(info).map_err(|e| AppError(e.to_string()))?))
+}
diff --git a/crates/dbx-web/src/routes/zookeeper.rs b/crates/dbx-web/src/routes/zookeeper.rs
new file mode 100644
index 0000000..bfac64d
--- /dev/null
+++ b/crates/dbx-web/src/routes/zookeeper.rs
@@ -0,0 +1,100 @@
+use std::sync::Arc;
+
+use axum::extract::State;
+use axum::Json;
+use serde::Deserialize;
+
+use crate::error::AppError;
+use crate::state::WebState;
+
+async fn ensure_writable(
+    app: &dbx_core::connection::AppState,
+    connection_id: &str,
+    action: &str,
+) -> Result<(), AppError> {
+    if let Some(name) = dbx_core::query::connection_readonly_name(app, connection_id).await {
+        return Err(AppError(format!(
+            "Read-only mode: connection '{}' has read-only protection enabled. {} blocked.",
+            name, action
+        )));
+    }
+    Ok(())
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ZooKeeperListPrefixRequest {
+    pub connection_id: String,
+    pub prefix: String,
+    pub limit: usize,
+    pub continuation: Option<String>,
+    pub recursive: Option<bool>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ZooKeeperKeyRequest {
+    pub connection_id: String,
+    pub key: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ZooKeeperPutRequest {
+    pub connection_id: String,
+    pub key: String,
+    pub value: dbx_core::agent_kv::KvValue,
+    pub options: Option<dbx_core::agent_kv::KvPutOptions>,
+}
+
+pub async fn list_prefix(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ZooKeeperListPrefixRequest>,
+) -> Result<Json<dbx_core::agent_kv::KvListPrefixResponse>, AppError> {
+    let result = dbx_core::agent_kv::kv_list_prefix_core_with_options(
+        &state.app,
+        &req.connection_id,
+        &req.prefix,
+        req.limit,
+        req.continuation.as_deref(),
+        req.recursive,
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn get(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ZooKeeperKeyRequest>,
+) -> Result<Json<dbx_core::agent_kv::KvGetResponse>, AppError> {
+    let result = dbx_core::agent_kv::kv_get_core(&state.app, &req.connection_id, &req.key).await.map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn put(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ZooKeeperPutRequest>,
+) -> Result<Json<dbx_core::agent_kv::KvPutResponse>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Put").await?;
+    let result = dbx_core::agent_kv::kv_put_core_with_options(
+        &state.app,
+        &req.connection_id,
+        &req.key,
+        req.value,
+        req.options.unwrap_or_default(),
+    )
+    .await
+    .map_err(AppError)?;
+    Ok(Json(result))
+}
+
+pub async fn delete(
+    State(state): State<Arc<WebState>>,
+    Json(req): Json<ZooKeeperKeyRequest>,
+) -> Result<Json<dbx_core::agent_kv::KvDeleteResponse>, AppError> {
+    ensure_writable(&state.app, &req.connection_id, "Delete").await?;
+    let result =
+        dbx_core::agent_kv::kv_delete_core(&state.app, &req.connection_id, &req.key).await.map_err(AppError)?;
+    Ok(Json(result))
+}
diff --git a/crates/dbx-web/src/sse.rs b/crates/dbx-web/src/sse.rs
new file mode 100644
index 0000000..ac46d5e
--- /dev/null
+++ b/crates/dbx-web/src/sse.rs
@@ -0,0 +1,14 @@
+use axum::response::sse::{Event, KeepAlive, Sse};
+use futures::stream::Stream;
+use tokio::sync::broadcast;
+
+pub fn sse_from_channel(
+    mut rx: broadcast::Receiver<String>,
+) -> Sse<impl Stream<Item = Result<Event, std::convert::Infallible>>> {
+    let stream = async_stream::stream! {
+        while let Ok(data) = rx.recv().await {
+            yield Ok(Event::default().data(data));
+        }
+    };
+    Sse::new(stream).keep_alive(KeepAlive::default())
+}
diff --git a/crates/dbx-web/src/state.rs b/crates/dbx-web/src/state.rs
new file mode 100644
index 0000000..19b4ffa
--- /dev/null
+++ b/crates/dbx-web/src/state.rs
@@ -0,0 +1,31 @@
+use dbx_core::connection::AppState;
+use std::collections::{HashMap, HashSet};
+use std::path::PathBuf;
+use std::sync::Arc;
+use tokio::sync::{broadcast, Mutex, RwLock};
+use tokio_util::sync::CancellationToken;
+
+pub struct LoginRateLimit {
+    pub fail_count: u32,
+    pub locked_until: Option<std::time::Instant>,
+}
+
+pub struct WebState {
+    pub app: Arc<AppState>,
+    pub data_dir: PathBuf,
+    pub public_base_path: String,
+    pub password_disabled: bool,
+    pub password_hash: RwLock<Option<String>>,
+    pub sessions: RwLock<HashSet<String>>,
+    pub sse_channels: RwLock<HashMap<String, broadcast::Sender<String>>>,
+    pub sql_file_executions: RwLock<HashMap<String, CancellationToken>>,
+    pub login_rate_limit: Mutex<LoginRateLimit>,
+    /// Table export temp files: export_id -> (file_path, format)
+    pub export_files: RwLock<HashMap<String, (String, String)>>,
+}
+
+impl WebState {
+    pub async fn remove_sse_channel(&self, id: &str) {
+        self.sse_channels.write().await.remove(id);
+    }
+}
diff --git a/deploy/1panel/README.md b/deploy/1panel/README.md
new file mode 100644
index 0000000..85b35ec
--- /dev/null
+++ b/deploy/1panel/README.md
@@ -0,0 +1,21 @@
+# DBX
+
+25+ databases in 15 MB. Desktop & Docker self-hosting, with built-in AI assistant.
+
+Supported databases: MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, ClickHouse, SQL Server, Oracle, Elasticsearch, MariaDB, TiDB, OceanBase, openGauss, GaussDB, KingBase, and more.
+
+## Features
+
+- SQL editor with syntax highlighting, autocomplete, and formatting
+- AI SQL assistant (Claude, OpenAI, or any OpenAI-compatible endpoint)
+- Virtual-scrolled data grid with inline editing
+- ER diagram, schema diff, explain plan, field lineage
+- Data import/export (CSV, Excel, JSON, Parquet)
+- Redis key browser and MongoDB document CRUD
+- SSH tunnel, dark mode, i18n (English & 简体中文)
+
+## Links
+
+- GitHub: https://github.com/t8y2/dbx
+- Discord: https://discord.gg/W7NyVDRt6a
+- QQ 群: 1087880322
diff --git a/deploy/1panel/data.yml b/deploy/1panel/data.yml
new file mode 100644
index 0000000..e7ddea8
--- /dev/null
+++ b/deploy/1panel/data.yml
@@ -0,0 +1,24 @@
+name: DBX
+tags:
+  - 工具
+title: 轻量级数据库管理工具
+description: 轻量级数据库管理工具，支持 25+ 种数据库
+additionalProperties:
+  key: dbx
+  name: DBX
+  tags:
+    - Tool
+  shortDescZh: 轻量级数据库管理工具，支持 25+ 种数据库
+  shortDescEn: Lightweight database manager supporting 25+ databases
+  description:
+    en: Lightweight database manager supporting 25+ databases
+    zh: 轻量级数据库管理工具，支持 25+ 种数据库
+  type: tool
+  crossVersionUpdate: true
+  limit: 0
+  recommend: 0
+  website: https://github.com/t8y2/dbx
+  github: https://github.com/t8y2/dbx
+  document: https://github.com/t8y2/dbx#readme
+  architectures:
+    - amd64
diff --git a/deploy/1panel/latest/data.yml b/deploy/1panel/latest/data.yml
new file mode 100644
index 0000000..a8f6eac
--- /dev/null
+++ b/deploy/1panel/latest/data.yml
@@ -0,0 +1,26 @@
+additionalProperties:
+  formFields:
+    - default: 4224
+      edit: true
+      envKey: PANEL_APP_PORT_HTTP
+      labelZh: 端口
+      labelEn: Port
+      label:
+        zh: 端口
+        en: Port
+      required: true
+      rule: paramPort
+      type: number
+
+    - default: dbx_password
+      edit: true
+      envKey: PANEL_DB_PASSWORD
+      labelZh: 访问密码
+      labelEn: Access Password
+      label:
+        zh: 访问密码
+        en: Access Password
+      required: true
+      rule: paramComplexity
+      type: password
+      random: true
diff --git a/deploy/1panel/latest/docker-compose.yml b/deploy/1panel/latest/docker-compose.yml
new file mode 100644
index 0000000..f1b9d7a
--- /dev/null
+++ b/deploy/1panel/latest/docker-compose.yml
@@ -0,0 +1,19 @@
+services:
+  dbx:
+    image: t8y2/dbx:latest
+    container_name: ${CONTAINER_NAME}
+    ports:
+      - "${PANEL_APP_PORT_HTTP}:4224"
+    environment:
+      - DBX_PASSWORD=${PANEL_DB_PASSWORD}
+    volumes:
+      - ./data:/app/data
+    restart: unless-stopped
+    networks:
+      - 1panel-network
+    labels:
+      createdBy: "Apps"
+
+networks:
+  1panel-network:
+    external: true
diff --git a/deploy/1panel/logo.png b/deploy/1panel/logo.png
new file mode 100644
index 0000000..c3b85de
Binary files /dev/null and b/deploy/1panel/logo.png differ
diff --git a/deploy/Dockerfile b/deploy/Dockerfile
new file mode 100644
index 0000000..bf14792
--- /dev/null
+++ b/deploy/Dockerfile
@@ -0,0 +1,87 @@
+# syntax=docker/dockerfile:1
+
+# Stage 1: Build frontend (native, no emulation)
+FROM --platform=$BUILDPLATFORM node:22-slim AS frontend
+WORKDIR /app
+RUN npm i -g pnpm
+COPY package.json pnpm-lock.yaml ./
+RUN --mount=type=cache,target=/root/.local/share/pnpm/store \
+    pnpm install --frozen-lockfile
+COPY apps/desktop/ apps/desktop/
+COPY crates/dbx-core/assets/database-drivers.manifest.json crates/dbx-core/assets/database-drivers.manifest.json
+RUN pnpm build
+
+# Stage 2: Cross-compile Rust backend for the requested platform (native, no emulation)
+FROM --platform=$BUILDPLATFORM rust:1-bookworm AS backend
+ARG TARGETARCH
+WORKDIR /app
+RUN dpkg --add-architecture arm64 \
+    && apt-get update && apt-get install -y --no-install-recommends \
+    build-essential cmake pkg-config perl python3-pip gcc-aarch64-linux-gnu \
+    libfontconfig-dev:arm64 libfreetype-dev:arm64 \
+    && pip3 install --break-system-packages ziglang \
+    && cargo install cargo-zigbuild \
+    && rustup target add x86_64-unknown-linux-gnu aarch64-unknown-linux-gnu \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy dependency manifests only and create dummy sources to pre-compile dependencies.
+# This layer is cached by GHA as long as Cargo.toml/Cargo.lock don't change.
+COPY Cargo.toml Cargo.lock ./
+COPY crates/dbx-core/Cargo.toml crates/dbx-core/
+COPY crates/dbx-web/Cargo.toml crates/dbx-web/
+COPY src-tauri/Cargo.toml src-tauri/
+RUN mkdir -p crates/dbx-core/src && echo '' > crates/dbx-core/src/lib.rs \
+    && mkdir -p crates/dbx-web/src && echo 'fn main() {}' > crates/dbx-web/src/main.rs \
+    && mkdir -p src-tauri/src && echo 'fn main() {}' > src-tauri/src/main.rs && echo 'pub fn run() {}' > src-tauri/src/lib.rs
+
+COPY src-tauri/build.rs src-tauri/
+COPY src-tauri/tauri.conf.json src-tauri/
+
+RUN case "$TARGETARCH" in \
+      amd64) rust_target=x86_64-unknown-linux-gnu; lib_arch=x86_64-linux-gnu ;; \
+      arm64) rust_target=aarch64-unknown-linux-gnu; lib_arch=aarch64-linux-gnu ;; \
+      *) echo "Unsupported TARGETARCH: $TARGETARCH" >&2; exit 1 ;; \
+    esac && \
+    LIBRARY_PATH="/usr/lib/$lib_arch" \
+    PKG_CONFIG_PATH="/usr/lib/$lib_arch/pkgconfig" \
+    PKG_CONFIG_SYSROOT_DIR="/" \
+    RUSTFLAGS="-L native=/usr/lib/$lib_arch" \
+    cargo zigbuild --release -p dbx-web --target "$rust_target" || true
+
+# Copy real sources and rebuild (only application code recompiles)
+COPY crates/ crates/
+
+# Docker COPY preserves original file timestamps, which may be older than the
+# dummy-source binary compiled above. Touch all .rs files so cargo detects the
+# source change and recompiles instead of reusing the dummy binary.
+RUN find crates/ -name '*.rs' -exec touch {} +
+
+RUN case "$TARGETARCH" in \
+      amd64) rust_target=x86_64-unknown-linux-gnu; lib_arch=x86_64-linux-gnu ;; \
+      arm64) rust_target=aarch64-unknown-linux-gnu; lib_arch=aarch64-linux-gnu ;; \
+      *) echo "Unsupported TARGETARCH: $TARGETARCH" >&2; exit 1 ;; \
+    esac && \
+    LIBRARY_PATH="/usr/lib/$lib_arch" \
+    PKG_CONFIG_PATH="/usr/lib/$lib_arch/pkgconfig" \
+    PKG_CONFIG_SYSROOT_DIR="/" \
+    RUSTFLAGS="-L native=/usr/lib/$lib_arch" \
+    cargo zigbuild --release -p dbx-web --target "$rust_target" && \
+    mkdir -p "/out/linux/$TARGETARCH" && \
+    cp "/app/target/$rust_target/release/dbx-web" "/out/linux/$TARGETARCH/"
+
+# Stage 3: Final image
+FROM debian:bookworm-slim
+ARG TARGETPLATFORM
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ca-certificates \
+    fontconfig \
+    fonts-dejavu-core \
+    libfreetype6 \
+    libssl3 \
+    && rm -rf /var/lib/apt/lists/*
+COPY --from=backend /out/${TARGETPLATFORM}/dbx-web /usr/local/bin/
+COPY --from=frontend /app/dist /app/static
+ENV DBX_STATIC_DIR=/app/static
+ENV DBX_DATA_DIR=/app/data
+EXPOSE 4224
+CMD ["dbx-web"]
diff --git a/deploy/Dockerfile.dockerignore b/deploy/Dockerfile.dockerignore
new file mode 100644
index 0000000..5c3370a
--- /dev/null
+++ b/deploy/Dockerfile.dockerignore
@@ -0,0 +1,12 @@
+target/
+node_modules/
+dist/
+src-tauri/target/
+.git/
+.github/
+.claude/
+*.log
+.DS_Store
+.env
+.env.*
+tmp/
diff --git a/deploy/dbx_tunnel.php b/deploy/dbx_tunnel.php
new file mode 100644
index 0000000..8d61924
--- /dev/null
+++ b/deploy/dbx_tunnel.php
@@ -0,0 +1,471 @@
+<?php
+declare(strict_types=1);
+
+/*
+ * DBX HTTP Script Tunnel
+ *
+ * Upload this file to a PHP server that can reach the target database.
+ *
+ * Required configuration:
+ *   DBX_TUNNEL_TOKEN=change-this-to-a-long-random-string
+ *
+ * Optional configuration:
+ *   DBX_TUNNEL_DIR=/tmp/dbx_tunnel
+ *   DBX_TUNNEL_ALLOWED_HOSTS=mysql.internal,postgres.internal
+ *   DBX_TUNNEL_MAX_SESSION_SECONDS=3600
+ *   DBX_TUNNEL_PHP=/usr/bin/php
+ */
+
+$DBX_TUNNEL_TOKEN = getenv('DBX_TUNNEL_TOKEN') ?: '';
+$DBX_TUNNEL_DIR = getenv('DBX_TUNNEL_DIR') ?: sys_get_temp_dir() . DIRECTORY_SEPARATOR . 'dbx_tunnel';
+$DBX_TUNNEL_ALLOWED_HOSTS = array_values(array_filter(array_map('trim', explode(',', getenv('DBX_TUNNEL_ALLOWED_HOSTS') ?: ''))));
+$DBX_TUNNEL_MAX_SESSION_SECONDS = max(30, (int) (getenv('DBX_TUNNEL_MAX_SESSION_SECONDS') ?: '3600'));
+
+if (PHP_SAPI === 'cli' && isset($argv[1]) && $argv[1] === '--dbx-worker') {
+    run_worker($argv[2] ?? '', $argv[3] ?? '', (int) ($argv[4] ?? 0), (int) ($argv[5] ?? 10));
+    exit;
+}
+
+try {
+    require_token();
+    cleanup_old_sessions();
+
+    $action = request_param('dbx_action');
+    switch ($action) {
+        case 'open':
+            handle_open();
+            break;
+        case 'write':
+            handle_write();
+            break;
+        case 'read':
+            handle_read();
+            break;
+        case 'close':
+            handle_close();
+            break;
+        default:
+            respond_error(400, 'Unsupported dbx_action');
+    }
+} catch (Throwable $e) {
+    respond_error(500, $e->getMessage());
+}
+
+function handle_open(): void
+{
+    $session = request_session();
+    $host = request_param('dbx_target_host');
+    $port = (int) request_param('dbx_target_port');
+    $connectTimeout = request_connect_timeout();
+    validate_target($host, $port);
+
+    $dir = session_dir($session);
+    if (!is_dir($dir) && !mkdir($dir, 0700, true) && !is_dir($dir)) {
+        respond_error(500, 'Failed to create tunnel session directory');
+    }
+    file_put_contents($dir . DIRECTORY_SEPARATOR . 'meta.json', json_encode([
+        'target_host' => $host,
+        'target_port' => $port,
+        'created_at' => time(),
+    ]));
+    touch($dir . DIRECTORY_SEPARATOR . 'in.queue');
+    touch($dir . DIRECTORY_SEPARATOR . 'out.queue');
+
+    if (function_exists('fastcgi_finish_request')) {
+        respond_json(['ok' => true], false);
+        fastcgi_finish_request();
+        run_worker($dir, $host, $port, $connectTimeout);
+        exit;
+    }
+
+    if (spawn_worker($dir, $host, $port, $connectTimeout)) {
+        if (wait_for_worker_start($dir, 2000)) {
+            respond_json(['ok' => true]);
+        }
+        respond_error(500, 'PHP tunnel worker did not start');
+    }
+
+    respond_error(500, 'PHP tunnel requires PHP-FPM fastcgi_finish_request or permission to spawn PHP CLI');
+}
+
+function handle_write(): void
+{
+    $dir = existing_session_dir(request_session());
+    ensure_session_alive($dir);
+    $data = file_get_contents('php://input');
+    if ($data !== false && $data !== '') {
+        append_chunk($dir, 'in', $data);
+    }
+    respond_json(['ok' => true]);
+}
+
+function handle_read(): void
+{
+    $dir = existing_session_dir(request_session());
+    $waitMs = max(0, min(5000, (int) (request_param('dbx_wait_ms', '1000'))));
+    $deadline = microtime(true) + ($waitMs / 1000);
+
+    do {
+        $data = drain_chunks($dir, 'out');
+        if ($data !== '') {
+            header('Content-Type: application/octet-stream');
+            header('Cache-Control: no-store');
+            echo $data;
+            return;
+        }
+        if (is_file($dir . DIRECTORY_SEPARATOR . 'error.txt')) {
+            respond_error(502, trim((string) file_get_contents($dir . DIRECTORY_SEPARATOR . 'error.txt')));
+        }
+        if (is_file($dir . DIRECTORY_SEPARATOR . 'closed')) {
+            respond_error(410, 'Tunnel session closed');
+        }
+        usleep(20000);
+    } while (microtime(true) < $deadline);
+
+    http_response_code(204);
+}
+
+function handle_close(): void
+{
+    $dir = existing_session_dir(request_session());
+    touch($dir . DIRECTORY_SEPARATOR . 'close');
+    respond_json(['ok' => true]);
+}
+
+function run_worker(string $dir, string $host, int $port, int $connectTimeout): void
+{
+    global $DBX_TUNNEL_MAX_SESSION_SECONDS;
+
+    if ($dir === '' || $host === '' || $port <= 0) {
+        return;
+    }
+    ignore_user_abort(true);
+    set_time_limit(0);
+    @touch($dir . DIRECTORY_SEPARATOR . 'worker.started');
+
+    $targetHost = strpos($host, ':') !== false && substr($host, 0, 1) !== '[' ? '[' . $host . ']' : $host;
+    $socket = @stream_socket_client(
+        'tcp://' . $targetHost . ':' . $port,
+        $errno,
+        $errstr,
+        max(1, min(300, $connectTimeout)),
+        STREAM_CLIENT_CONNECT
+    );
+    if (!$socket) {
+        write_error($dir, 'Failed to connect target database: ' . $errstr);
+        mark_closed($dir);
+        return;
+    }
+
+    stream_set_blocking($socket, false);
+    $expiresAt = time() + $DBX_TUNNEL_MAX_SESSION_SECONDS;
+    $lastActivity = time();
+
+    try {
+        while (time() < $expiresAt) {
+            if (is_file($dir . DIRECTORY_SEPARATOR . 'close')) {
+                break;
+            }
+
+            $inbound = drain_chunks($dir, 'in');
+            if ($inbound !== '') {
+                write_all($socket, $inbound);
+                $lastActivity = time();
+            }
+
+            $read = [$socket];
+            $write = [];
+            $except = [];
+            $ready = @stream_select($read, $write, $except, 0, 200000);
+            if ($ready === false) {
+                write_error($dir, 'Failed to poll target database socket');
+                break;
+            }
+            if ($ready > 0) {
+                $data = fread($socket, 16384);
+                if ($data === false) {
+                    write_error($dir, 'Failed to read target database socket');
+                    break;
+                }
+                if ($data === '') {
+                    if (feof($socket)) {
+                        break;
+                    }
+                } else {
+                    append_chunk($dir, 'out', $data);
+                    $lastActivity = time();
+                }
+            }
+
+            if (time() - $lastActivity > $DBX_TUNNEL_MAX_SESSION_SECONDS) {
+                break;
+            }
+        }
+    } catch (Throwable $e) {
+        write_error($dir, $e->getMessage());
+    }
+
+    fclose($socket);
+    mark_closed($dir);
+}
+
+function write_all($socket, string $data): void
+{
+    $offset = 0;
+    $length = strlen($data);
+    while ($offset < $length) {
+        $written = fwrite($socket, substr($data, $offset));
+        if ($written === false) {
+            throw new RuntimeException('Failed to write target database socket');
+        }
+        if ($written === 0) {
+            usleep(10000);
+            continue;
+        }
+        $offset += $written;
+    }
+}
+
+function spawn_worker(string $dir, string $host, int $port, int $connectTimeout): bool
+{
+    if (!function_exists('popen')) {
+        return false;
+    }
+    $php = getenv('DBX_TUNNEL_PHP') ?: PHP_BINARY;
+    if ($php === '') {
+        return false;
+    }
+    $cmd = escapeshellarg($php)
+        . ' ' . escapeshellarg(__FILE__)
+        . ' --dbx-worker ' . escapeshellarg($dir)
+        . ' ' . escapeshellarg($host)
+        . ' ' . escapeshellarg((string) $port)
+        . ' ' . escapeshellarg((string) $connectTimeout)
+        . ' > /dev/null 2>&1 &';
+    $handle = @popen($cmd, 'r');
+    if (!is_resource($handle)) {
+        return false;
+    }
+    @pclose($handle);
+    return true;
+}
+
+function wait_for_worker_start(string $dir, int $timeoutMs): bool
+{
+    $deadline = microtime(true) + ($timeoutMs / 1000);
+    do {
+        if (is_file($dir . DIRECTORY_SEPARATOR . 'worker.started')) {
+            return true;
+        }
+        usleep(20000);
+    } while (microtime(true) < $deadline);
+    return false;
+}
+
+function append_chunk(string $dir, string $name, string $data): void
+{
+    if ($data === '') {
+        return;
+    }
+    $lock = fopen($dir . DIRECTORY_SEPARATOR . $name . '.lock', 'c');
+    if (!$lock) {
+        throw new RuntimeException('Failed to open tunnel queue lock');
+    }
+    flock($lock, LOCK_EX);
+    file_put_contents($dir . DIRECTORY_SEPARATOR . $name . '.queue', base64_encode($data) . "\n", FILE_APPEND | LOCK_EX);
+    flock($lock, LOCK_UN);
+    fclose($lock);
+}
+
+function drain_chunks(string $dir, string $name): string
+{
+    $path = $dir . DIRECTORY_SEPARATOR . $name . '.queue';
+    if (!is_file($path)) {
+        return '';
+    }
+    $lock = fopen($dir . DIRECTORY_SEPARATOR . $name . '.lock', 'c');
+    if (!$lock) {
+        throw new RuntimeException('Failed to open tunnel queue lock');
+    }
+    flock($lock, LOCK_EX);
+    $encoded = (string) file_get_contents($path);
+    file_put_contents($path, '');
+    flock($lock, LOCK_UN);
+    fclose($lock);
+
+    $decoded = '';
+    foreach (explode("\n", $encoded) as $line) {
+        if ($line === '') {
+            continue;
+        }
+        $chunk = base64_decode($line, true);
+        if ($chunk !== false) {
+            $decoded .= $chunk;
+        }
+    }
+    return $decoded;
+}
+
+function require_token(): void
+{
+    global $DBX_TUNNEL_TOKEN;
+
+    if ($DBX_TUNNEL_TOKEN === '') {
+        respond_error(503, 'DBX_TUNNEL_TOKEN is not configured');
+    }
+    $provided = request_token();
+    if ($provided === '' || !hash_equals($DBX_TUNNEL_TOKEN, $provided)) {
+        respond_error(401, 'Invalid tunnel token');
+    }
+}
+
+function request_token(): string
+{
+    if (isset($_SERVER['HTTP_X_DBX_TUNNEL_TOKEN'])) {
+        return trim((string) $_SERVER['HTTP_X_DBX_TUNNEL_TOKEN']);
+    }
+    $authorization = $_SERVER['HTTP_AUTHORIZATION'] ?? $_SERVER['REDIRECT_HTTP_AUTHORIZATION'] ?? '';
+    if (stripos($authorization, 'Bearer ') === 0) {
+        return trim(substr($authorization, 7));
+    }
+    return '';
+}
+
+function validate_target(string $host, int $port): void
+{
+    global $DBX_TUNNEL_ALLOWED_HOSTS;
+
+    if ($host === '' || preg_match('/[\x00-\x20]/', $host)) {
+        respond_error(400, 'Invalid target host');
+    }
+    if (
+        !filter_var($host, FILTER_VALIDATE_IP)
+        && !filter_var($host, FILTER_VALIDATE_DOMAIN, FILTER_FLAG_HOSTNAME)
+    ) {
+        respond_error(400, 'Invalid target host');
+    }
+    if ($port < 1 || $port > 65535) {
+        respond_error(400, 'Invalid target port');
+    }
+    // Optional allow-list keeps this script from becoming a general internal TCP relay.
+    if ($DBX_TUNNEL_ALLOWED_HOSTS !== [] && !in_array($host, $DBX_TUNNEL_ALLOWED_HOSTS, true)) {
+        respond_error(403, 'Target host is not allowed');
+    }
+}
+
+function request_session(): string
+{
+    $session = request_param('dbx_session');
+    if (!preg_match('/\A[A-Za-z0-9_-]{8,128}\z/', $session)) {
+        respond_error(400, 'Invalid tunnel session');
+    }
+    return $session;
+}
+
+function request_param(string $name, string $default = ''): string
+{
+    if (isset($_GET[$name])) {
+        return trim((string) $_GET[$name]);
+    }
+    if (isset($_POST[$name])) {
+        return trim((string) $_POST[$name]);
+    }
+    return $default;
+}
+
+function request_connect_timeout(): int
+{
+    $timeout = (int) request_param('dbx_connect_timeout', '10');
+    return max(1, min(300, $timeout));
+}
+
+function session_dir(string $session): string
+{
+    global $DBX_TUNNEL_DIR;
+
+    ensure_base_dir();
+    return rtrim($DBX_TUNNEL_DIR, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . $session;
+}
+
+function existing_session_dir(string $session): string
+{
+    $dir = session_dir($session);
+    if (!is_dir($dir)) {
+        respond_error(404, 'Tunnel session not found');
+    }
+    return $dir;
+}
+
+function ensure_session_alive(string $dir): void
+{
+    if (is_file($dir . DIRECTORY_SEPARATOR . 'error.txt')) {
+        respond_error(502, trim((string) file_get_contents($dir . DIRECTORY_SEPARATOR . 'error.txt')));
+    }
+    if (is_file($dir . DIRECTORY_SEPARATOR . 'closed')) {
+        respond_error(410, 'Tunnel session closed');
+    }
+}
+
+function ensure_base_dir(): void
+{
+    global $DBX_TUNNEL_DIR;
+
+    if (!is_dir($DBX_TUNNEL_DIR) && !mkdir($DBX_TUNNEL_DIR, 0700, true) && !is_dir($DBX_TUNNEL_DIR)) {
+        respond_error(500, 'Failed to create tunnel base directory');
+    }
+}
+
+function cleanup_old_sessions(): void
+{
+    global $DBX_TUNNEL_DIR, $DBX_TUNNEL_MAX_SESSION_SECONDS;
+
+    if (!is_dir($DBX_TUNNEL_DIR)) {
+        return;
+    }
+    foreach (glob(rtrim($DBX_TUNNEL_DIR, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . '*', GLOB_ONLYDIR) ?: [] as $dir) {
+        if (filemtime($dir) !== false && time() - filemtime($dir) > ($DBX_TUNNEL_MAX_SESSION_SECONDS * 2)) {
+            remove_dir($dir);
+        }
+    }
+}
+
+function remove_dir(string $dir): void
+{
+    foreach (glob($dir . DIRECTORY_SEPARATOR . '*') ?: [] as $path) {
+        if (is_dir($path)) {
+            remove_dir($path);
+        } else {
+            @unlink($path);
+        }
+    }
+    @rmdir($dir);
+}
+
+function write_error(string $dir, string $message): void
+{
+    @file_put_contents($dir . DIRECTORY_SEPARATOR . 'error.txt', $message, LOCK_EX);
+}
+
+function mark_closed(string $dir): void
+{
+    @touch($dir . DIRECTORY_SEPARATOR . 'closed');
+}
+
+function respond_json(array $payload, bool $exit = true): void
+{
+    header('Content-Type: application/json');
+    header('Cache-Control: no-store');
+    echo json_encode($payload);
+    if ($exit) {
+        exit;
+    }
+}
+
+function respond_error(int $status, string $message): void
+{
+    http_response_code($status);
+    header('Content-Type: text/plain; charset=utf-8');
+    header('Cache-Control: no-store');
+    echo $message;
+    exit;
+}
diff --git a/deploy/docker-compose.release.yml b/deploy/docker-compose.release.yml
new file mode 100644
index 0000000..1e8430c
--- /dev/null
+++ b/deploy/docker-compose.release.yml
@@ -0,0 +1,14 @@
+services:
+  dbx:
+    image: t8y2/dbx:latest
+    # For faster pulls in China, use the CNB image instead:
+    # image: docker.cnb.cool/dbxio.com/dbx:latest
+    pull_policy: always
+    ports:
+      - "4224:4224"
+    volumes:
+      - dbx-data:/app/data
+    restart: unless-stopped
+
+volumes:
+  dbx-data:
diff --git a/deploy/docker-compose.yml b/deploy/docker-compose.yml
new file mode 100644
index 0000000..6134582
--- /dev/null
+++ b/deploy/docker-compose.yml
@@ -0,0 +1,17 @@
+services:
+  dbx:
+    build:
+      context: ..
+      dockerfile: deploy/Dockerfile
+    ports:
+      - "4224:4224"
+    environment:
+      - DBX_PASSWORD=changeme
+      # Uncomment when publishing DBX under a reverse-proxy subpath, e.g. https://example.com/dbx/
+      # - DBX_PUBLIC_BASE_PATH=/dbx
+    volumes:
+      - dbx-data:/app/data
+    restart: unless-stopped
+
+volumes:
+  dbx-data:
diff --git a/deploy/homebrew/dbx-cli.rb b/deploy/homebrew/dbx-cli.rb
new file mode 100644
index 0000000..ed8b2af
--- /dev/null
+++ b/deploy/homebrew/dbx-cli.rb
@@ -0,0 +1,38 @@
+class DbxCli < Formula
+  desc "Command-line interface for DBX database connections, schema, and safe queries"
+  homepage "https://github.com/t8y2/dbx"
+  url "https://registry.npmjs.org/@dbx-app/cli/-/cli-0.4.7.tgz"
+  sha256 "d507138dc5bd9611ad1e668a14e5a099754e8a1a3994742f2d03dbc22da911d8"
+  license "Apache-2.0"
+
+  depends_on "node"
+
+  on_linux do
+    depends_on "pkgconf" => :build
+    depends_on "libsecret"
+  end
+
+  def install
+    system "npm", "install", *std_npm_args
+    bin.install_symlink libexec.glob("bin/*")
+
+    # Rebuild better-sqlite3 and keytar native bindings for the current platform.
+    # prebuild-install is blocked by the Homebrew sandbox during npm install,
+    # so we must rebuild them explicitly via node-gyp.
+    node_modules = libexec/"lib/node_modules/@dbx-app/cli/node_modules"
+
+    cd node_modules/"better-sqlite3" do
+      system "npm", "run", "build-release"
+    end
+
+    cd node_modules/"keytar" do
+      rm_r "prebuilds" if File.directory?("prebuilds")
+      system "npm", "run", "build"
+    end
+  end
+
+  test do
+    assert_path_exists bin/"dbx"
+    system bin/"dbx", "doctor"
+  end
+end
diff --git a/docs/.gitignore b/docs/.gitignore
new file mode 100644
index 0000000..712d47b
--- /dev/null
+++ b/docs/.gitignore
@@ -0,0 +1,4 @@
+node_modules/
+.vitepress/dist/
+.vitepress/cache/
+*.tsbuildinfo
diff --git a/docs/app/[lang]/api/search/route.ts b/docs/app/[lang]/api/search/route.ts
new file mode 100644
index 0000000..72b9282
--- /dev/null
+++ b/docs/app/[lang]/api/search/route.ts
@@ -0,0 +1,14 @@
+import { createFromSource } from "fumadocs-core/search/server";
+import { createCjkSearchTokenizer } from "@/lib/cjkSearchTokenizer";
+import { source } from "@/lib/source";
+
+export const revalidate = false;
+export const { staticGET: GET } = createFromSource(source, {
+  localeMap: {
+    cn: { components: { tokenizer: createCjkSearchTokenizer() } },
+  },
+});
+
+export function generateStaticParams() {
+  return [{ lang: "en" }, { lang: "cn" }];
+}
diff --git a/docs/app/[lang]/changelog/page.tsx b/docs/app/[lang]/changelog/page.tsx
new file mode 100644
index 0000000..eb1cad4
--- /dev/null
+++ b/docs/app/[lang]/changelog/page.tsx
@@ -0,0 +1,51 @@
+import { LandingNav } from "@/components/landing/LandingNav";
+import { ChangelogRuntime } from "@/components/landing/ChangelogRuntime";
+import { fetchChangelog } from "@/lib/changelog";
+import { buildMetadata } from "@/lib/metadata";
+import type { Metadata } from "next";
+
+const i18n = {
+  en: {
+    title: "Changelog",
+    desc: "Track every release — features, improvements, and fixes.",
+  },
+  cn: {
+    title: "更新日志",
+    desc: "追踪每次发布 — 新功能、改进和修复。",
+  },
+};
+
+export async function generateMetadata({ params }: { params: Promise<{ lang: string }> }): Promise<Metadata> {
+  const { lang } = await params;
+  const l = lang === "cn" ? "cn" : "en";
+  const t = i18n[l];
+
+  return buildMetadata({
+    title: t.title,
+    description: t.desc,
+    path: `/${l}/changelog`,
+    lang: l,
+  });
+}
+
+export default async function ChangelogPage({ params }: { params: Promise<{ lang: string }> }) {
+  const { lang } = await params;
+  const l = lang === "cn" ? "cn" : "en";
+  const t = i18n[l];
+  const initialData = await fetchChangelog(l);
+
+  return (
+    <div className="min-h-screen bg-[#0b1120] text-landing-ink">
+      <LandingNav lang={l} active="changelog" />
+
+      <div className="max-w-[860px] mx-auto px-6 pt-32 pb-4">
+        <h1 className="text-4xl font-[820] tracking-tight">{t.title}</h1>
+        <p className="mt-3 text-landing-muted text-lg">{t.desc}</p>
+      </div>
+
+      <div className="max-w-[860px] mx-auto px-6 pb-24">
+        <ChangelogRuntime lang={l} initialReleases={initialData.releases} />
+      </div>
+    </div>
+  );
+}
diff --git a/docs/app/[lang]/community/page.tsx b/docs/app/[lang]/community/page.tsx
new file mode 100644
index 0000000..5351df5
--- /dev/null
+++ b/docs/app/[lang]/community/page.tsx
@@ -0,0 +1,113 @@
+import { LandingNav } from "@/components/landing/LandingNav";
+import { buildMetadata } from "@/lib/metadata";
+import type { Metadata } from "next";
+
+const channels = [
+  {
+    id: "qq",
+    color: "#EB1923",
+    href: "https://qm.qq.com/cgi-bin/qm/qr?k=&group_code=1087880322",
+    icon: <img src="/icons/community/qq.png" alt="QQ" width={24} height={24} />,
+  },
+  {
+    id: "wechat",
+    color: "#07C160",
+    href: "https://docs.qq.com/doc/DVVhMY0h1ekJqc0tz",
+    icon: (
+      <svg width={24} height={24} viewBox="0 0 24 24" fill="currentColor">
+        <path d="M9.5 4C5.36 4 2 6.69 2 10c0 1.89 1.08 3.56 2.78 4.66l-.7 2.1 2.46-1.23c.87.27 1.8.42 2.78.42.24 0 .48-.01.71-.03A5.93 5.93 0 0110 14c0-3.31 3.13-6 7-6 .34 0 .67.03 1 .07C17.27 5.56 13.72 4 9.5 4zm-3 4.5a1 1 0 110-2 1 1 0 010 2zm5 0a1 1 0 110-2 1 1 0 010 2zM22 14c0-2.76-2.69-5-6-5s-6 2.24-6 5 2.69 5 6 5c.73 0 1.43-.11 2.09-.3l1.72.86-.49-1.46C20.94 17.07 22 15.64 22 14zm-7.5-.5a.75.75 0 110-1.5.75.75 0 010 1.5zm4 0a.75.75 0 110-1.5.75.75 0 010 1.5z" />
+      </svg>
+    ),
+  },
+  {
+    id: "discord",
+    color: "#5865F2",
+    href: "https://discord.gg/W7NyVDRt6a",
+    icon: (
+      <svg width={24} height={24} viewBox="0 0 24 24" fill="currentColor">
+        <path d="M20.317 4.37a19.791 19.791 0 00-4.885-1.515.074.074 0 00-.079.037c-.21.375-.444.864-.608 1.25a18.27 18.27 0 00-5.487 0 12.64 12.64 0 00-.617-1.25.077.077 0 00-.079-.037A19.736 19.736 0 003.677 4.37a.07.07 0 00-.032.027C.533 9.046-.32 13.58.099 18.057a.082.082 0 00.031.057 19.9 19.9 0 005.993 3.03.078.078 0 00.084-.028c.462-.63.874-1.295 1.226-1.994a.076.076 0 00-.041-.106 13.107 13.107 0 01-1.872-.892.077.077 0 01-.008-.128 10.2 10.2 0 00.372-.292.074.074 0 01.077-.01c3.928 1.793 8.18 1.793 12.062 0a.074.074 0 01.078.01c.12.098.246.198.373.292a.077.077 0 01-.006.127 12.299 12.299 0 01-1.873.892.077.077 0 00-.041.107c.36.698.772 1.362 1.225 1.993a.076.076 0 00.084.028 19.839 19.839 0 006.002-3.03.077.077 0 00.032-.054c.5-5.177-.838-9.674-3.549-13.66a.061.061 0 00-.031-.03zM8.02 15.33c-1.183 0-2.157-1.085-2.157-2.419 0-1.333.956-2.419 2.157-2.419 1.21 0 2.176 1.095 2.157 2.42 0 1.333-.956 2.418-2.157 2.418zm7.975 0c-1.183 0-2.157-1.085-2.157-2.419 0-1.333.955-2.419 2.157-2.419 1.21 0 2.176 1.095 2.157 2.42 0 1.333-.946 2.418-2.157 2.418z" />
+      </svg>
+    ),
+  },
+  {
+    id: "github",
+    color: "#f0f0f0",
+    href: "https://github.com/t8y2/dbx/discussions",
+    icon: (
+      <svg width={24} height={24} viewBox="0 0 24 24" fill="currentColor">
+        <path d="M12 0C5.37 0 0 5.37 0 12c0 5.31 3.435 9.795 8.205 11.385.6.105.825-.255.825-.57 0-.285-.015-1.23-.015-2.235-3.015.555-3.795-.735-4.035-1.41-.135-.345-.72-1.41-1.23-1.695-.42-.225-1.02-.78-.015-.795.945-.015 1.62.87 1.845 1.23 1.08 1.815 2.805 1.305 3.495.99.105-.78.42-1.305.765-1.605-2.67-.3-5.46-1.335-5.46-5.925 0-1.305.465-2.385 1.23-3.225-.12-.3-.54-1.53.12-3.18 0 0 1.005-.315 3.3 1.23.96-.27 1.98-.405 3-.405s2.04.135 3 .405c2.295-1.56 3.3-1.23 3.3-1.23.66 1.65.24 2.88.12 3.18.765.84 1.23 1.905 1.23 3.225 0 4.605-2.805 5.625-5.475 5.925.435.375.81 1.095.81 2.22 0 1.605-.015 2.895-.015 3.3 0 .315.225.69.825.57A12.02 12.02 0 0024 12c0-6.63-5.37-12-12-12z" />
+      </svg>
+    ),
+  },
+];
+
+const i18n = {
+  en: {
+    title: "Community",
+    desc: "Join the DBX community — ask questions, share feedback, and connect with other users.",
+    discord: { name: "Discord", desc: "Real-time chat, Q&A, and feature discussions." },
+    qq: { name: "QQ Group", desc: "Group number: 1087880322" },
+    wechat: { name: "WeChat Group", desc: "Join via Tencent Docs invite link." },
+    github: { name: "GitHub Discussions", desc: "Bug reports, feature requests, and long-form discussions." },
+  },
+  cn: {
+    title: "交流群",
+    desc: "加入 DBX 社区 — 提问、反馈、与其他用户交流。",
+    discord: { name: "Discord", desc: "实时聊天、问答和功能讨论。" },
+    qq: { name: "QQ 群", desc: "群号：1087880322" },
+    wechat: { name: "微信群", desc: "通过腾讯文档链接加入。" },
+    github: { name: "GitHub Discussions", desc: "Bug 反馈、功能建议和深度讨论。" },
+  },
+};
+
+export async function generateMetadata({ params }: { params: Promise<{ lang: string }> }): Promise<Metadata> {
+  const { lang } = await params;
+  const l = lang === "cn" ? "cn" : "en";
+  const t = i18n[l];
+
+  return buildMetadata({
+    title: t.title,
+    description: t.desc,
+    path: `/${l}/community`,
+    lang: l,
+  });
+}
+
+export default async function CommunityPage({ params }: { params: Promise<{ lang: string }> }) {
+  const { lang } = await params;
+  const l = lang === "cn" ? "cn" : "en";
+  const t = i18n[l];
+
+  return (
+    <div className="min-h-screen bg-[#0b1120] text-landing-ink">
+      <LandingNav lang={l} active="community" />
+
+      <div className="max-w-[860px] mx-auto px-6 pt-32 pb-4">
+        <h1 className="text-4xl font-[820] tracking-tight">{t.title}</h1>
+        <p className="mt-3 text-landing-muted text-lg">{t.desc}</p>
+      </div>
+
+      <div className="max-w-[860px] mx-auto px-6 pb-24">
+        <div className="grid gap-4 mt-8">
+          {channels.map((ch) => {
+            const meta = t[ch.id as keyof typeof t] as { name: string; desc: string };
+            return (
+              <a key={ch.id} href={ch.href} target="_blank" rel="noopener noreferrer" className="group flex items-center gap-5 rounded-xl border border-landing-line bg-landing-panel px-6 py-5 transition-colors hover:border-[rgba(155,176,205,0.32)]">
+                <span className="grid place-items-center w-11 h-11 rounded-lg shrink-0" style={{ backgroundColor: `${ch.color}18`, color: ch.color }}>
+                  {ch.icon}
+                </span>
+                <span className="grid gap-0.5 min-w-0">
+                  <strong className="text-[15px] font-[700] leading-snug">{meta.name}</strong>
+                  <span className="text-landing-muted text-[13px] leading-relaxed">{meta.desc}</span>
+                </span>
+                <svg className="ml-auto shrink-0 text-landing-muted opacity-0 -translate-x-1 transition-all group-hover:opacity-100 group-hover:translate-x-0" width={16} height={16} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth={2} strokeLinecap="round" strokeLinejoin="round">
+                  <path d="M5 12h14M12 5l7 7-7 7" />
+                </svg>
+              </a>
+            );
+          })}
+        </div>
+      </div>
+    </div>
+  );
+}
diff --git a/docs/app/[lang]/databases/page.tsx b/docs/app/[lang]/databases/page.tsx
new file mode 100644
index 0000000..89d2d7b
--- /dev/null
+++ b/docs/app/[lang]/databases/page.tsx
@@ -0,0 +1,187 @@
+import type { CSSProperties } from "react";
+import type { Metadata } from "next";
+import Link from "next/link";
+import { LandingNav } from "@/components/landing/LandingNav";
+import { Spotlight } from "@/components/aceternity/Spotlight";
+import { RevealSection } from "@/components/landing/RevealSection";
+import { buildMetadata } from "@/lib/metadata";
+
+const databaseSupport = [
+  { name: "MySQL", icon: "/icons/database/mysql.svg", tone: "#4479a1" },
+  { name: "PostgreSQL", icon: "/icons/database/postgres.svg", tone: "#4169e1" },
+  { name: "SQLite", icon: "/icons/database/sqlite.svg", tone: "#5aa6d6" },
+  { name: "Redis", icon: "/icons/database/redis.svg", tone: "#ff4438" },
+  { name: "DuckDB", icon: "/icons/database/duckdb.svg", tone: "#fff000" },
+  { name: "ClickHouse", icon: "/icons/database/clickhouse.svg", tone: "#ffcc01" },
+  { name: "SQL Server", icon: "/icons/database/sqlserver.svg", tone: "#9ca3af" },
+  { name: "MongoDB", icon: "/icons/database/mongodb.svg", tone: "#47a248" },
+  { name: "Oracle", icon: "/icons/database/oracle.svg", tone: "#f80000" },
+  { name: "Elasticsearch", icon: "/icons/database/elasticsearch.svg", tone: "#00bfb3" },
+  { name: "Qdrant", icon: "/icons/database/qdrant.svg", tone: "#dc244c" },
+  { name: "Milvus", icon: "/icons/database/milvus.png", tone: "#00a1ea" },
+  { name: "Weaviate", icon: "/icons/database/weaviate.png", tone: "#00b894" },
+  { name: "MariaDB", icon: "/icons/database/mariadb.svg", tone: "#003545" },
+  { name: "Doris", icon: "/icons/database/doris.svg", tone: "#5b7cfa" },
+  { name: "StarRocks", icon: "/icons/database/starrocks.svg", tone: "#6750ff" },
+  { name: "Manticore", icon: "/icons/database/manticoresearch.png", tone: "#b8e646" },
+  { name: "Redshift", icon: "/icons/database/redshift.svg", tone: "#8c4fff" },
+  { name: "Dameng", icon: "/icons/database/dm.svg", tone: "#3857ff" },
+  { name: "GaussDB", icon: "/icons/database/gaussdb.svg", tone: "#ff5a3d" },
+  { name: "openGauss", icon: "/icons/database/opengauss.svg", tone: "#1488c9" },
+  { name: "KingBase", icon: "/icons/database/kingbase.svg", tone: "#e1212d" },
+  { name: "HighGo", icon: "/icons/database/highgo.png", tone: "#005bac" },
+  { name: "TiDB", icon: "/icons/database/tidb.svg", tone: "#e60012" },
+  { name: "OceanBase", icon: "/icons/database/oceanbase.svg", tone: "#2285ff" },
+  { name: "TDSQL", icon: "/icons/database/tdsql.webp", tone: "#0080ff" },
+  { name: "PolarDB", icon: "/icons/database/polardb.webp", tone: "#1890ff" },
+  { name: "GreatSQL", icon: "/icons/database/greatsql.webp", tone: "#0066b3" },
+  { name: "SelectDB", icon: "/icons/database/selectdb.svg", tone: "#22c1c3" },
+  { name: "TDengine", icon: "/icons/database/tdengine.svg", tone: "#2f6fff" },
+  { name: "CockroachDB", icon: "/icons/database/cockroachdb.svg", tone: "#6933ff" },
+  { name: "RQLite", icon: "/icons/database/rqlite.png", tone: "#5a67d8" },
+  { name: "Turso", icon: "/icons/database/turso.png", tone: "#10b981" },
+  { name: "Databend", icon: "/icons/database/databend.svg", tone: "#f59e0b" },
+  { name: "Databricks", icon: "/icons/database/databricks.webp", tone: "#ff5a1f" },
+  { name: "Snowflake", icon: "/icons/database/snowflake.svg", tone: "#29b5e8" },
+  { name: "BigQuery", icon: "/icons/database/bigquery.svg", tone: "#4285f4" },
+  { name: "Trino", icon: "/icons/database/trino.svg", tone: "#dd00a1" },
+  { name: "PrestoSQL", icon: "/icons/database/presto.svg", tone: "#5890ff" },
+  { name: "Hive", icon: "/icons/database/hive.svg", tone: "#fdcb00" },
+  { name: "DB2", icon: "/icons/database/db2.svg", tone: "#054ada" },
+  { name: "SAP HANA", icon: "/icons/database/saphana.webp", tone: "#008fd3" },
+  { name: "Teradata", icon: "/icons/database/teradata.webp", tone: "#f37440" },
+  { name: "Vertica", icon: "/icons/database/vertica.webp", tone: "#007dc5" },
+  { name: "Exasol", icon: "/icons/database/exasol.webp", tone: "#002b45" },
+  { name: "Firebird", icon: "/icons/database/firebird.webp", tone: "#e17000" },
+  { name: "Informix", icon: "/icons/database/informix.svg", tone: "#0178c8" },
+  { name: "Neo4j", icon: "/icons/database/neo4j.svg", tone: "#018bff" },
+  { name: "Cassandra", icon: "/icons/database/cassandra.svg", tone: "#1287b1" },
+  { name: "Kylin", icon: "/icons/database/apache_kylin.svg", tone: "#fb8c00" },
+  { name: "InfluxDB", icon: "/icons/database/influxdb.svg", tone: "#22adf6" },
+  { name: "QuestDB", icon: "/icons/database/questdb.svg", tone: "#dc2626" },
+  { name: "IoTDB", icon: "/icons/database/iotdb.svg", tone: "#3cb371" },
+  { name: "KWDB", icon: "/icons/database/kwdb.svg", tone: "#6366f1" },
+  { name: "Vastbase", icon: "/icons/database/vastbase.png", tone: "#2563eb" },
+  { name: "GoldenDB", icon: "/icons/database/goldendb.png", tone: "#eab308" },
+  { name: "YashanDB", icon: "/icons/database/yashandb.png", tone: "#dc2626" },
+  { name: "SunDB", icon: "/icons/database/sundb.svg", tone: "#f97316" },
+  { name: "XuguDB", icon: "/icons/database/xugu.png", tone: "#84cc16" },
+  { name: "GBase", icon: "/icons/database/gbase.webp", tone: "#06b6d4" },
+  { name: "Access", icon: "/icons/database/access.png", tone: "#a53346" },
+  { name: "H2", icon: "/icons/database/h2.svg", tone: "#f7a81b" },
+  { name: "Etcd", icon: "/icons/database/etcd.svg", tone: "#419eda" },
+  { name: "ZooKeeper", icon: "/icons/database/zookeeper.svg", tone: "#3b82f6" },
+  { name: "Pulsar", icon: "/icons/database/pulsar.svg", tone: "#188fff" },
+  { name: "Nacos", icon: "/icons/database/nacos.png", tone: "#2f80ed" },
+  { name: "IRIS", icon: "/icons/database/iris.png", tone: "#0085ca" },
+  { name: "JDBC", icon: "/icons/database/jdbc.svg", tone: "#6ea8ff" },
+  { name: "Your DB?", icon: "/icons/database/jdbc.svg", tone: "#6ea8ff", href: "https://github.com/t8y2/dbx/discussions", cta: true },
+];
+
+const i18n = {
+  en: {
+    title: "Supported Databases",
+    desc: "DBX connects to 60+ database engines. Native Rust drivers, MySQL/PostgreSQL-compatible profiles, and JDBC for everything else.",
+    ctaTitle: "Don't see your database?",
+    ctaDesc: "Open a GitHub Discussion to request support for a new database engine.",
+    ctaLink: "Request on GitHub",
+    footer: "Want to learn more about what works with each engine?",
+    footerLink: "Read the feature matrix",
+  },
+  cn: {
+    title: "支持的数据库",
+    desc: "DBX 支持 60+ 种数据库引擎。涵盖 Rust 原生驱动、MySQL/PostgreSQL 兼容类型和 JDBC 扩展。",
+    ctaTitle: "没看到你用的数据库？",
+    ctaDesc: "在 GitHub Discussions 中发起讨论，申请支持新的数据库引擎。厂商和社区用户都可以参与。",
+    ctaLink: "在 GitHub 上申请",
+    footer: "想了解每种引擎具体支持哪些功能？",
+    footerLink: "查看功能矩阵",
+  },
+};
+
+export async function generateMetadata({ params }: { params: Promise<{ lang: string }> }): Promise<Metadata> {
+  const { lang } = await params;
+  const l = lang === "cn" ? "cn" : "en";
+  const t = i18n[l];
+
+  return buildMetadata({
+    title: t.title,
+    description: t.desc,
+    path: `/${l}/databases`,
+    lang: l,
+  });
+}
+
+export default async function DatabasesPage({ params }: { params: Promise<{ lang: string }> }) {
+  const { lang } = await params;
+  const l = lang === "cn" ? "cn" : "en";
+  const t = i18n[l];
+
+  return (
+    <div className="min-h-screen bg-[#0b1120] text-landing-ink">
+      <LandingNav lang={l} active="databases" />
+
+      {/* Hero */}
+      <section className="relative pt-28 pb-6">
+        <Spotlight />
+        <div className="relative z-[1] max-w-[1180px] mx-auto px-7">
+          <h1 className="text-4xl font-[820] tracking-tight">{t.title}</h1>
+          <p className="mt-3 text-landing-muted text-lg max-w-[640px]">{t.desc}</p>
+        </div>
+      </section>
+
+      {/* Database Grid */}
+      <RevealSection className="max-w-[1180px] mx-auto px-7 pb-10">
+        <div className="grid grid-cols-9 gap-3 max-[1240px]:grid-cols-7 max-[960px]:grid-cols-5 max-[640px]:grid-cols-3 max-[440px]:grid-cols-2 max-[760px]:gap-2.5">
+          {databaseSupport.map((db) => {
+            const isCta = "href" in db && db.href;
+            const CardTag = isCta ? "a" : "div";
+            return (
+            <CardTag
+              className={`landing-db-card grid place-items-center aspect-square rounded-[10px] px-2.5 py-[18px] max-[760px]:py-4 ${isCta ? "border-2 border-dashed border-[color-mix(in_srgb,var(--color-landing-blue)_40%,transparent)] hover:border-[color-mix(in_srgb,var(--color-landing-blue)_70%,transparent)] transition-colors cursor-pointer" : ""}`}
+              key={db.name}
+              {...(isCta ? { href: db.href, target: "_blank", rel: "noopener noreferrer" } : {})}
+              style={{ "--db-tone": db.tone } as CSSProperties}
+              data-stagger
+            >
+              <div className="landing-db-icon grid place-items-center w-12 h-12 mb-[15px]">
+                {isCta ? (
+                  <span className="grid place-items-center w-10 h-10 rounded-full border-2 border-dashed text-landing-blue border-landing-blue text-2xl leading-none">+</span>
+                ) : db.icon ? (
+                  <img src={db.icon} alt="" width={38} height={38} className="block w-[38px] h-[38px] object-contain" />
+                ) : (
+                  <span className="grid place-items-center min-w-[46px] h-8 rounded-lg px-2 text-white text-xs font-[780]">{db.name.slice(0, 2).toUpperCase()}</span>
+                )}
+              </div>
+              <strong className={`text-sm font-[650] leading-[1.2] text-center ${isCta ? "text-landing-blue" : "text-[color-mix(in_srgb,var(--color-landing-ink)_92%,var(--color-landing-muted))]"}`}>{db.name}</strong>
+            </CardTag>
+            );
+          })}
+        </div>
+      </RevealSection>
+
+      {/* Vendor CTA */}
+      <RevealSection className="max-w-[1180px] mx-auto px-7 pb-16">
+        <div className="landing-glass-card rounded-[10px] p-8 text-center max-w-[640px] mx-auto">
+          <h2 className="text-[21px] font-[720]">{t.ctaTitle}</h2>
+          <p className="mt-2 text-landing-muted text-sm leading-[1.65]">{t.ctaDesc}</p>
+          <Link
+            href="https://github.com/t8y2/dbx/discussions"
+            target="_blank"
+            className="landing-final-link inline-flex items-center justify-center min-h-[42px] rounded-[7px] px-5 mt-5 text-sm font-[650]"
+          >
+            {t.ctaLink}
+          </Link>
+        </div>
+      </RevealSection>
+
+      {/* Footer link to docs */}
+      <div className="max-w-[1180px] mx-auto px-7 pb-20 text-center">
+        <Link href={`/${l}/docs/databases`} className="landing-inline-link inline-flex items-center gap-[7px] text-sm font-[650]">
+          {t.footerLink}
+          <svg width={15} height={15} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth={2} strokeLinecap="round" strokeLinejoin="round"><path d="M5 12h14M12 5l7 7-7 7"/></svg>
+        </Link>
+      </div>
+    </div>
+  );
+}
diff --git a/docs/app/[lang]/docs/[[...slug]]/page.tsx b/docs/app/[lang]/docs/[[...slug]]/page.tsx
new file mode 100644
index 0000000..671bdbe
--- /dev/null
+++ b/docs/app/[lang]/docs/[[...slug]]/page.tsx
@@ -0,0 +1,108 @@
+import { source } from "@/lib/source";
+import { notFound } from "next/navigation";
+import type { Metadata } from "next";
+import { DocsPage, DocsBody, DocsTitle, DocsDescription } from "fumadocs-ui/page";
+import defaultMdxComponents from "fumadocs-ui/mdx";
+import { Tab, Tabs } from "fumadocs-ui/components/tabs";
+import { Step, Steps } from "fumadocs-ui/components/steps";
+import { Callout } from "fumadocs-ui/components/callout";
+import { Card, Cards } from "fumadocs-ui/components/card";
+import { ImageZoom } from "fumadocs-ui/components/image-zoom";
+import { Accordion, Accordions } from "fumadocs-ui/components/accordion";
+import type { MDXContent } from "mdx/types";
+import type { TOCItemType } from "fumadocs-core/toc";
+import { buildMetadata, SITE_URL } from "@/lib/metadata";
+
+export async function generateMetadata({ params }: { params: Promise<{ lang: string; slug?: string[] }> }): Promise<Metadata> {
+  const { lang, slug } = await params;
+  const page = source.getPage(slug, lang);
+  if (!page) return {};
+
+  const title = page.data.title as string;
+  const description = (page.data.description as string) || undefined;
+
+  return buildMetadata({
+    title,
+    description: description ?? "",
+    path: slug ? `/${lang}/docs/${slug.join("/")}` : `/${lang}/docs`,
+    lang,
+    ogType: "article",
+  });
+}
+
+const mdxComponents = {
+  ...defaultMdxComponents,
+  Tab,
+  Tabs,
+  Step,
+  Steps,
+  Callout,
+  Card,
+  Cards,
+  ImageZoom,
+  Accordion,
+  Accordions,
+};
+
+export default async function Page({ params }: { params: Promise<{ lang: string; slug?: string[] }> }) {
+  const { lang, slug } = await params;
+  const page = source.getPage(slug, lang);
+  if (!page) notFound();
+
+  const { body: MDX, toc } = page.data as unknown as {
+    body: MDXContent;
+    toc: TOCItemType[];
+  };
+
+  const title = page.data.title as string;
+  const description = (page.data.description as string) || "";
+  const docPath = slug ? `/${lang}/docs/${slug.join("/")}` : `/${lang}/docs`;
+
+  const breadcrumbJsonLd = {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: [
+      { "@type": "ListItem", position: 1, name: "Home", item: SITE_URL },
+      { "@type": "ListItem", position: 2, name: "Docs", item: `${SITE_URL}/${lang}/docs` },
+      ...(slug
+        ? slug.map((segment, i) => ({
+            "@type": "ListItem" as const,
+            position: i + 3,
+            name: segment.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+            item: `${SITE_URL}/${lang}/docs/${slug.slice(0, i + 1).join("/")}`,
+          }))
+        : []),
+    ],
+  };
+
+  const articleJsonLd = {
+    "@context": "https://schema.org",
+    "@type": "TechArticle",
+    headline: title,
+    description,
+    inLanguage: lang === "cn" ? "zh-CN" : "en",
+    isPartOf: {
+      "@type": "WebSite",
+      url: SITE_URL,
+    },
+  };
+
+  return (
+    <DocsPage toc={toc}>
+      <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: JSON.stringify(breadcrumbJsonLd) }} />
+      <script type="application/ld+json" dangerouslySetInnerHTML={{ __html: JSON.stringify(articleJsonLd) }} />
+      <DocsTitle>{title}</DocsTitle>
+      <DocsDescription>{description}</DocsDescription>
+      <DocsBody>
+        <MDX components={mdxComponents} />
+      </DocsBody>
+    </DocsPage>
+  );
+}
+
+export function generateStaticParams() {
+  return source.generateParams().map((params) => ({
+    lang: params.lang,
+    slug: params.slug,
+  }));
+}
diff --git a/docs/app/[lang]/docs/layout.tsx b/docs/app/[lang]/docs/layout.tsx
new file mode 100644
index 0000000..82d1d13
--- /dev/null
+++ b/docs/app/[lang]/docs/layout.tsx
@@ -0,0 +1,31 @@
+import type { ReactNode } from "react";
+import { DocsLayout } from "fumadocs-ui/layouts/docs";
+import { DocsSidebarFooter, DocsSidebarLanguageButton } from "@/components/DocsSidebarFooter";
+import { source } from "@/lib/source";
+
+export default async function Layout({ params, children }: { params: Promise<{ lang: string }>; children: ReactNode }) {
+  const { lang } = await params;
+
+  return (
+    <DocsLayout
+      tree={source.getPageTree(lang)}
+      nav={{
+        title: (
+          <div className="flex items-center gap-2">
+            <img src="/logo.png" alt="DBX" width={24} height={24} />
+            <span className="font-semibold">DBX</span>
+          </div>
+        ),
+        children: <DocsSidebarLanguageButton />,
+      }}
+      i18n={false}
+      themeSwitch={{ enabled: false }}
+      sidebar={{
+        defaultOpenLevel: 1,
+        footer: <DocsSidebarFooter />,
+      }}
+    >
+      {children}
+    </DocsLayout>
+  );
+}
diff --git a/docs/app/[lang]/drivers/DriversClient.tsx b/docs/app/[lang]/drivers/DriversClient.tsx
new file mode 100644
index 0000000..222670b
--- /dev/null
+++ b/docs/app/[lang]/drivers/DriversClient.tsx
@@ -0,0 +1,512 @@
+"use client";
+
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { useParams } from "next/navigation";
+import { LandingNav } from "@/components/landing/LandingNav";
+import { fetchAgentDownloadCatalog, formatSize, type AgentDownloadCatalog, type JreDisplayEntry, type NativeAgentDisplayEntry, type OfflineBundleEntry } from "@/lib/agentRegistry";
+import { AlertTriangle, Archive, Cpu, Database, Download, Loader2, Plug, Search, Terminal, X } from "lucide-react";
+
+const i18n = {
+  en: {
+    title: "Offline Driver Downloads",
+    subtitle: "Download database drivers and JRE packages for offline use. Search for the exact resource your air-gapped environment needs.",
+    jdbcPlugin: "JDBC Plugin",
+    jdbcPluginDesc: "Install this optional DBX sidecar before using custom JDBC connections. Database vendor JDBC driver JARs still need to be imported separately.",
+    jdbcPluginFile: "Plugin package",
+    jdbcPluginInstallHint: "Import this ZIP in DBX from Settings > Driver Manager > JDBC Drivers > Local Install.",
+    bundles: "Offline Bundles",
+    bundlesDesc: "Platform-specific ZIP packages that include the agent registry, database drivers, native agents, and the matching JRE.",
+    drivers: "Database Drivers",
+    driversDesc: "JDBC driver JAR files for each supported database type.",
+    nativeAgents: "Native Agents",
+    nativeAgentsDesc: "Go-based native agents for Oracle and XuguDB. Download the executable that matches the offline machine.",
+    jre: "Java Runtime (JRE)",
+    jreDesc: "JRE packages used by agent-based database drivers. Required for Oracle, SQL Server, and other agent-managed connections.",
+    loading: "Loading driver catalog...",
+    error: "Unable to load driver catalog. Please check your network connection.",
+    retry: "Retry",
+    download: "Download",
+    installMethod: "Install",
+    version: "Version",
+    size: "Size",
+    requiresJre: "Requires JRE",
+    platform: "Platform",
+    filename: "File",
+    search: "Search drivers, platforms, versions...",
+    noResults: "No matching downloads.",
+    showing: "Showing",
+    of: "of",
+    clearSearch: "Clear search",
+    downloadHint: "For air-gapped environments: download the bundle for your platform on an internet-connected machine, then transfer it to the offline machine and import it in DBX from Settings > Driver Manager. Use the driver and JRE tabs only when you need individual artifacts.",
+  },
+  cn: {
+    title: "离线驱动下载",
+    subtitle: "下载数据库驱动和 JRE 离线包。搜索内网环境需要的资源，在有网机器下载后传输。",
+    jdbcPlugin: "JDBC 插件",
+    jdbcPluginDesc: "使用自定义 JDBC 连接前先安装这个 DBX 可选插件。数据库厂商的 JDBC Driver JAR 仍需单独导入。",
+    jdbcPluginFile: "插件包",
+    jdbcPluginInstallHint: "在 DBX 的“设置 > 驱动管理 > JDBC 驱动 > 本地安装”中导入这个 ZIP。",
+    bundles: "整包下载",
+    bundlesDesc: "按平台提供的 ZIP 离线包，包含 Agent registry、数据库驱动、原生 Agent 和匹配的 JRE。",
+    drivers: "数据库驱动",
+    driversDesc: "每种支持的数据库类型对应的 JDBC 驱动 JAR 文件。",
+    nativeAgents: "原生 Agent",
+    nativeAgentsDesc: "Oracle 和虚谷使用 Go 原生 Agent，请下载与内网机器平台匹配的可执行文件。",
+    jre: "Java 运行时 (JRE)",
+    jreDesc: "Agent 驱动所需的 JRE 环境，Oracle、SQL Server 等数据库通过 Agent 连接时需要。",
+    loading: "正在加载驱动列表...",
+    error: "加载驱动列表失败，请检查网络连接。",
+    retry: "重试",
+    download: "下载",
+    installMethod: "安装方式",
+    version: "版本",
+    size: "大小",
+    requiresJre: "依赖 JRE",
+    platform: "平台",
+    filename: "文件",
+    search: "搜索驱动、平台、版本...",
+    noResults: "没有匹配的下载项。",
+    showing: "显示",
+    of: "/",
+    clearSearch: "清空搜索",
+    downloadHint: "内网环境使用说明：在有网的电脑上下载对应平台的整包，然后传输到内网机器，在 DBX 的“设置 > 驱动管理”中导入。只有需要单个产物时再使用驱动和 JRE 标签页。",
+  },
+};
+
+type ActiveTab = "bundles" | "drivers" | "native" | "jre" | "jdbcPlugin";
+
+function platformKey(j: JreDisplayEntry): string {
+  return `${j.jreKey}-${j.platformKey}`;
+}
+
+function bundleKey(bundle: OfflineBundleEntry): string {
+  return `${bundle.platformKey}-${bundle.filename}`;
+}
+
+function nativeKey(agent: NativeAgentDisplayEntry): string {
+  return `${agent.key}-${agent.platformKey}`;
+}
+
+type NativeAgentGroup = {
+  key: string;
+  label: string;
+  version: string;
+  options: NativeAgentDisplayEntry[];
+};
+
+function matchesSearch(values: Array<string | number | undefined>, query: string): boolean {
+  if (!query) return true;
+  return values.filter(Boolean).join(" ").toLowerCase().includes(query);
+}
+
+export function DriversClient() {
+  const params = useParams();
+  const rawLang = params?.lang as string | undefined;
+  const lang: "en" | "cn" = rawLang === "cn" ? "cn" : "en";
+  const t = i18n[lang];
+
+  const [catalog, setCatalog] = useState<AgentDownloadCatalog | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [activeTab, setActiveTab] = useState<ActiveTab>("bundles");
+  const [searchQuery, setSearchQuery] = useState("");
+  const [selectedNativePlatforms, setSelectedNativePlatforms] = useState<Record<string, string>>({});
+
+  const loadCatalog = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await fetchAgentDownloadCatalog();
+      if (data) {
+        setCatalog(data);
+      } else {
+        setError("Unable to load driver catalog");
+      }
+    } catch {
+      setError("Unable to load driver catalog");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    loadCatalog();
+  }, [loadCatalog]);
+
+  const bundles = catalog?.bundles ?? [];
+  const drivers = catalog?.drivers ?? [];
+  const nativeAgents = catalog?.nativeAgents ?? [];
+  const jres = catalog?.jres ?? [];
+  const jdbcPlugin = catalog?.jdbcPlugin;
+  const normalizedSearch = searchQuery.trim().toLowerCase();
+
+  const filteredBundles = useMemo(() => bundles.filter((bundle) => matchesSearch([bundle.platformLabel, bundle.platformKey, bundle.filename, formatSize(bundle.size)], normalizedSearch)), [bundles, normalizedSearch]);
+
+  const filteredDrivers = useMemo(() => drivers.filter((d) => matchesSearch([d.label, d.key, d.version, d.jre, formatSize(d.jar.size)], normalizedSearch)), [drivers, normalizedSearch]);
+
+  const nativeGroups = useMemo(() => {
+    const groups = new Map<string, NativeAgentGroup>();
+    for (const agent of nativeAgents) {
+      const group = groups.get(agent.key);
+      if (group) {
+        group.options.push(agent);
+      } else {
+        groups.set(agent.key, { key: agent.key, label: agent.label, version: agent.version, options: [agent] });
+      }
+    }
+    return Array.from(groups.values());
+  }, [nativeAgents]);
+
+  useEffect(() => {
+    if (nativeGroups.length === 0) return;
+    setSelectedNativePlatforms((current) => {
+      const next = { ...current };
+      let changed = false;
+      for (const group of nativeGroups) {
+        if (group.options.length === 0) continue;
+        if (!next[group.key] || !group.options.some((option) => option.platformKey === next[group.key])) {
+          next[group.key] = group.options[0].platformKey;
+          changed = true;
+        }
+      }
+      return changed ? next : current;
+    });
+  }, [nativeGroups]);
+
+  const filteredNativeGroups = useMemo(
+    () =>
+      nativeGroups.filter((group) =>
+        matchesSearch(
+          [
+            group.label,
+            group.key,
+            group.version,
+            ...group.options.flatMap((option) => [option.platformLabel, option.platformKey, option.filename, formatSize(option.info.size)]),
+          ],
+          normalizedSearch,
+        ),
+      ),
+    [nativeGroups, normalizedSearch],
+  );
+
+  const filteredJres = useMemo(() => jres.filter((j) => matchesSearch([j.platformLabel, j.platformKey, j.jreVersion, j.jreKey, formatSize(j.info.size)], normalizedSearch)), [jres, normalizedSearch]);
+  const filteredJdbcPlugin = useMemo(() => (jdbcPlugin && matchesSearch([jdbcPlugin.label, jdbcPlugin.filename, jdbcPlugin.url, t.jdbcPlugin, t.jdbcPluginDesc], normalizedSearch) ? [jdbcPlugin] : []), [jdbcPlugin, normalizedSearch, t.jdbcPlugin, t.jdbcPluginDesc]);
+
+  const activeCount = activeTab === "bundles" ? filteredBundles.length : activeTab === "drivers" ? filteredDrivers.length : activeTab === "native" ? filteredNativeGroups.length : activeTab === "jre" ? filteredJres.length : filteredJdbcPlugin.length;
+  const activeTotal = activeTab === "bundles" ? bundles.length : activeTab === "drivers" ? drivers.length : activeTab === "native" ? nativeGroups.length : activeTab === "jre" ? jres.length : jdbcPlugin ? 1 : 0;
+
+  return (
+    <main className="landing">
+      <LandingNav lang={lang} active="drivers" />
+
+      <section className="pt-[100px] pb-8 max-[760px]:pt-[80px] max-[760px]:pb-6">
+        <div className="max-w-[1180px] mx-auto px-7 max-[760px]:px-[18px]">
+          <div className="grid justify-items-center max-w-[900px] mx-auto text-center">
+            <p className="min-w-0 mx-auto text-[15px] font-[460] leading-[1.7] text-landing-muted max-w-[760px] max-[760px]:text-[13px] max-[760px]:whitespace-normal max-[760px]:max-w-[300px]">{t.subtitle}</p>
+          </div>
+        </div>
+      </section>
+
+      <section className="max-w-[1180px] mx-auto px-7 pb-20 max-[760px]:px-[18px]">
+        {loading && (
+          <div className="flex items-center justify-center gap-3 py-20 text-landing-muted">
+            <Loader2 size={20} className="animate-spin" />
+            <span className="text-sm">{t.loading}</span>
+          </div>
+        )}
+
+        {error && !loading && (
+          <div className="flex flex-col items-center gap-4 py-20">
+            <AlertTriangle size={28} className="text-yellow-500" />
+            <span className="text-landing-muted text-sm">{t.error}</span>
+            <button type="button" onClick={loadCatalog} className="landing-nav-link rounded-[7px] px-4 py-2 text-sm font-medium border border-landing-line">
+              {t.retry}
+            </button>
+          </div>
+        )}
+
+        {catalog && !loading && (
+          <>
+            <div className="landing-glass-card mb-12 overflow-hidden rounded-[10px]">
+              <div className="flex flex-wrap items-center justify-between gap-3 border-b border-landing-line bg-landing-panel/70 p-3">
+                <div className="inline-flex shrink-0 rounded-[8px] border border-landing-line bg-black/10 p-1 max-[760px]:grid max-[760px]:w-full max-[760px]:grid-cols-2">
+                  <button
+                    type="button"
+                    onClick={() => setActiveTab("bundles")}
+                    className={`inline-flex h-8 cursor-pointer items-center justify-center gap-2 rounded-[6px] px-3 text-xs font-[650] transition-colors ${activeTab === "bundles" ? "bg-landing-blue text-white" : "text-landing-muted hover:text-landing-ink"}`}
+                  >
+                    <Archive size={14} />
+                    {t.bundles}
+                  </button>
+                  <button
+                    type="button"
+                    onClick={() => setActiveTab("drivers")}
+                    className={`inline-flex h-8 cursor-pointer items-center justify-center gap-2 rounded-[6px] px-3 text-xs font-[650] transition-colors ${activeTab === "drivers" ? "bg-landing-blue text-white" : "text-landing-muted hover:text-landing-ink"}`}
+                  >
+                    <Database size={14} />
+                    {t.drivers}
+                  </button>
+                  <button type="button" onClick={() => setActiveTab("native")} className={`inline-flex h-8 cursor-pointer items-center justify-center gap-2 rounded-[6px] px-3 text-xs font-[650] transition-colors ${activeTab === "native" ? "bg-landing-blue text-white" : "text-landing-muted hover:text-landing-ink"}`}>
+                    <Terminal size={14} />
+                    {t.nativeAgents}
+                  </button>
+                  <button type="button" onClick={() => setActiveTab("jre")} className={`inline-flex h-8 cursor-pointer items-center justify-center gap-2 rounded-[6px] px-3 text-xs font-[650] transition-colors ${activeTab === "jre" ? "bg-landing-blue text-white" : "text-landing-muted hover:text-landing-ink"}`}>
+                    <Cpu size={14} />
+                    {t.jre}
+                  </button>
+                  <button type="button" onClick={() => setActiveTab("jdbcPlugin")} className={`inline-flex h-8 cursor-pointer items-center justify-center gap-2 rounded-[6px] px-3 text-xs font-[650] transition-colors ${activeTab === "jdbcPlugin" ? "bg-landing-blue text-white" : "text-landing-muted hover:text-landing-ink"}`}>
+                    <Plug size={14} />
+                    {t.jdbcPlugin}
+                  </button>
+                </div>
+
+                <div className="flex min-w-[280px] flex-1 items-center gap-3 max-[760px]:min-w-full">
+                  <div className="relative min-w-0 flex-1">
+                    <Search size={15} className="pointer-events-none absolute left-3 top-1/2 -translate-y-1/2 text-landing-muted" />
+                    <input
+                      value={searchQuery}
+                      onChange={(event) => setSearchQuery(event.target.value)}
+                      placeholder={t.search}
+                      className="h-9 w-full rounded-[8px] border border-landing-line bg-black/10 pl-9 pr-9 text-sm text-landing-ink outline-none transition-colors placeholder:text-landing-muted focus:border-landing-blue"
+                    />
+                    {searchQuery && (
+                      <button type="button" onClick={() => setSearchQuery("")} className="absolute right-2 top-1/2 grid h-6 w-6 -translate-y-1/2 cursor-pointer place-items-center rounded-[6px] text-landing-muted hover:bg-landing-soft hover:text-landing-ink" aria-label={t.clearSearch}>
+                        <X size={14} />
+                      </button>
+                    )}
+                  </div>
+                  <span className="shrink-0 text-xs text-landing-muted">
+                    {t.showing} {activeCount} {t.of} {activeTotal}
+                  </span>
+                </div>
+              </div>
+
+              {activeTab === "jdbcPlugin" && (
+                <>
+                  <p className="border-b border-landing-line px-5 py-3 text-sm text-landing-muted whitespace-nowrap max-[760px]:whitespace-normal max-[760px]:px-4">{t.jdbcPluginDesc}</p>
+                  <table className="w-full table-auto border-collapse text-sm max-[760px]:block">
+                    <thead className="bg-landing-panel text-xs font-medium text-landing-muted max-[760px]:hidden">
+                      <tr className="border-b border-landing-line">
+                        <th className="px-5 py-2.5 text-left font-medium">{t.jdbcPluginFile}</th>
+                        <th className="px-5 py-2.5 text-left font-medium">{t.filename}</th>
+                        <th className="px-5 py-2.5 text-left font-medium">{t.installMethod}</th>
+                        <th className="w-24 px-5 py-2.5" />
+                      </tr>
+                    </thead>
+                    <tbody className="max-[760px]:block">
+                      {filteredJdbcPlugin.map((plugin) => (
+                        <tr key={plugin.filename} className="border-b border-landing-line transition-colors last:border-b-0 hover:bg-landing-panel max-[760px]:grid max-[760px]:grid-cols-[1fr_auto] max-[760px]:items-center max-[760px]:gap-3 max-[760px]:px-4">
+                          <td className="min-w-0 px-5 py-3 font-medium text-landing-ink max-[760px]:px-0">
+                            <div className="flex min-w-0 items-center gap-2">
+                              <span className="min-w-0 truncate">{plugin.label}</span>
+                              <span className="hidden shrink-0 rounded-[5px] border border-landing-blue/35 bg-landing-blue/10 px-1.5 py-0.5 font-mono text-[11px] text-landing-sky max-[760px]:inline">ZIP</span>
+                            </div>
+                            <p className="mt-1 hidden text-xs leading-[1.55] text-landing-muted max-[760px]:block">{t.jdbcPluginInstallHint}</p>
+                          </td>
+                          <td className="px-5 py-3 font-mono text-[11px] text-landing-muted max-[760px]:hidden">{plugin.filename}</td>
+                          <td className="px-5 py-3 text-xs text-landing-muted max-[760px]:hidden">{t.jdbcPluginInstallHint}</td>
+                          <td className="px-5 py-3 text-right max-[760px]:px-0">
+                            <a href={plugin.url} download className="landing-nav-link inline-flex h-8 items-center gap-1 whitespace-nowrap rounded-[6px] border border-landing-line px-2.5 text-xs font-medium transition-colors hover:border-landing-blue">
+                              <Download size={13} />
+                              {t.download}
+                            </a>
+                          </td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                  {filteredJdbcPlugin.length === 0 && <div className="px-5 py-12 text-center text-sm text-landing-muted">{t.noResults}</div>}
+                </>
+              )}
+
+              {activeTab === "bundles" && (
+                <>
+                  <p className="border-b border-landing-line px-5 py-3 text-sm text-landing-muted whitespace-nowrap max-[760px]:whitespace-normal max-[760px]:px-4">{t.bundlesDesc}</p>
+                  <table className="w-full table-auto border-collapse text-sm max-[760px]:block">
+                    <thead className="bg-landing-panel text-xs font-medium text-landing-muted max-[760px]:hidden">
+                      <tr className="border-b border-landing-line">
+                        <th className="px-5 py-2.5 text-left font-medium">{t.platform}</th>
+                        <th className="px-5 py-2.5 text-left font-medium">{t.filename}</th>
+                        <th className="px-5 py-2.5 text-right font-medium">{t.size}</th>
+                        <th className="w-24 px-5 py-2.5" />
+                      </tr>
+                    </thead>
+                    <tbody className="max-[760px]:block">
+                      {filteredBundles.map((bundle) => (
+                        <tr key={bundleKey(bundle)} className="border-b border-landing-line transition-colors last:border-b-0 hover:bg-landing-panel max-[760px]:grid max-[760px]:grid-cols-[1fr_auto] max-[760px]:items-center max-[760px]:gap-3 max-[760px]:px-4">
+                          <td className="min-w-0 px-5 py-3 font-medium text-landing-ink max-[760px]:px-0">
+                            <div className="flex min-w-0 items-center gap-2">
+                              <span className="min-w-0 truncate">{bundle.platformLabel}</span>
+                              <span className="hidden shrink-0 rounded-[5px] border border-landing-blue/35 bg-landing-blue/10 px-1.5 py-0.5 font-mono text-[11px] text-landing-sky max-[760px]:inline">ZIP</span>
+                            </div>
+                          </td>
+                          <td className="px-5 py-3 font-mono text-[11px] text-landing-muted max-[760px]:hidden">{bundle.filename}</td>
+                          <td className="px-5 py-3 text-right text-xs text-landing-muted max-[760px]:hidden">{formatSize(bundle.size)}</td>
+                          <td className="px-5 py-3 text-right max-[760px]:px-0">
+                            <a href={bundle.url} download className="landing-nav-link inline-flex h-8 items-center gap-1 whitespace-nowrap rounded-[6px] border border-landing-line px-2.5 text-xs font-medium transition-colors hover:border-landing-blue">
+                              <Download size={13} />
+                              {t.download}
+                            </a>
+                          </td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                  {filteredBundles.length === 0 && <div className="px-5 py-12 text-center text-sm text-landing-muted">{t.noResults}</div>}
+                </>
+              )}
+
+              {activeTab === "drivers" && (
+                <>
+                  <p className="border-b border-landing-line px-5 py-3 text-sm text-landing-muted whitespace-nowrap max-[760px]:whitespace-normal max-[760px]:px-4">{t.driversDesc}</p>
+                  <table className="w-full table-auto border-collapse text-sm max-[760px]:block">
+                    <thead className="bg-landing-panel text-xs font-medium text-landing-muted max-[760px]:hidden">
+                      <tr className="border-b border-landing-line">
+                        <th className="px-5 py-2.5 text-left font-medium">Driver</th>
+                        <th className="px-5 py-2.5 text-left font-medium">Key</th>
+                        <th className="px-5 py-2.5 text-left font-medium">{t.version}</th>
+                        <th className="px-5 py-2.5 text-left font-medium">{t.requiresJre}</th>
+                        <th className="px-5 py-2.5 text-right font-medium">{t.size}</th>
+                        <th className="w-24 px-5 py-2.5" />
+                      </tr>
+                    </thead>
+                    <tbody className="max-[760px]:block">
+                      {filteredDrivers.map((d) => (
+                        <tr key={d.key} className="border-b border-landing-line transition-colors last:border-b-0 hover:bg-landing-panel max-[760px]:grid max-[760px]:grid-cols-[1fr_auto] max-[760px]:items-center max-[760px]:gap-3 max-[760px]:px-4">
+                          <td className="min-w-0 px-5 py-3 font-medium text-landing-ink max-[760px]:px-0">
+                            <div className="flex min-w-0 items-center gap-2">
+                              <span className="min-w-0 truncate">{d.label}</span>
+                              <span className="hidden shrink-0 rounded-[5px] border border-landing-blue/35 bg-landing-blue/10 px-1.5 py-0.5 font-mono text-[11px] text-landing-sky max-[760px]:inline">{d.key}</span>
+                            </div>
+                          </td>
+                          <td className="px-5 py-3 max-[760px]:hidden">
+                            <span className="inline-flex rounded-[5px] border border-landing-blue/35 bg-landing-blue/10 px-1.5 py-0.5 font-mono text-[11px] text-landing-sky">{d.key}</span>
+                          </td>
+                          <td className="px-5 py-3 text-xs text-landing-muted max-[760px]:hidden">{d.version}</td>
+                          <td className="px-5 py-3 text-xs text-landing-muted max-[760px]:hidden">{d.jre}</td>
+                          <td className="px-5 py-3 text-right text-xs text-landing-muted max-[760px]:hidden">{formatSize(d.jar.size)}</td>
+                          <td className="px-5 py-3 text-right max-[760px]:px-0">
+                            <a href={d.jar.url} download className="landing-nav-link inline-flex h-8 items-center gap-1 whitespace-nowrap rounded-[6px] border border-landing-line px-2.5 text-xs font-medium transition-colors hover:border-landing-blue">
+                              <Download size={13} />
+                              {t.download}
+                            </a>
+                          </td>
+                        </tr>
+                      ))}
+                    </tbody>
+                  </table>
+                  {filteredDrivers.length === 0 && <div className="px-5 py-12 text-center text-sm text-landing-muted">{t.noResults}</div>}
+                </>
+              )}
+
+              {activeTab === "native" && (
+                <>
+                  <p className="border-b border-landing-line px-5 py-3 text-sm text-landing-muted whitespace-nowrap max-[760px]:whitespace-normal max-[760px]:px-4">{t.nativeAgentsDesc}</p>
+                  <table className="w-full table-auto border-collapse text-sm max-[760px]:block">
+                    <thead className="bg-landing-panel text-xs font-medium text-landing-muted max-[760px]:hidden">
+                      <tr className="border-b border-landing-line">
+                        <th className="px-5 py-2.5 text-left font-medium">Agent</th>
+                        <th className="px-5 py-2.5 text-left font-medium">{t.platform}</th>
+                        <th className="px-5 py-2.5 text-left font-medium">{t.version}</th>
+                        <th className="px-5 py-2.5 text-right font-medium">{t.size}</th>
+                        <th className="w-24 px-5 py-2.5" />
+                      </tr>
+                    </thead>
+                    <tbody className="max-[760px]:block">
+                      {filteredNativeGroups.map((group) => {
+                        const selectedPlatform = selectedNativePlatforms[group.key] ?? group.options[0]?.platformKey;
+                        const selectedAgent = group.options.find((option) => option.platformKey === selectedPlatform) ?? group.options[0];
+                        if (!selectedAgent) return null;
+                        return (
+                          <tr key={group.key} className="border-b border-landing-line transition-colors last:border-b-0 hover:bg-landing-panel max-[760px]:grid max-[760px]:grid-cols-[1fr_auto] max-[760px]:items-center max-[760px]:gap-3 max-[760px]:px-4">
+                            <td className="min-w-0 px-5 py-3 font-medium text-landing-ink max-[760px]:px-0">
+                              <div className="flex min-w-0 items-center gap-2">
+                                <span className="min-w-0 truncate">{group.label}</span>
+                                <span className="hidden shrink-0 rounded-[5px] border border-landing-blue/35 bg-landing-blue/10 px-1.5 py-0.5 font-mono text-[11px] text-landing-sky max-[760px]:inline">{selectedAgent.platformKey}</span>
+                              </div>
+                            </td>
+                            <td className="px-5 py-3 max-[760px]:col-span-2 max-[760px]:px-0 max-[760px]:pt-0">
+                              <select
+                                value={selectedAgent.platformKey}
+                                onChange={(event) => setSelectedNativePlatforms((current) => ({ ...current, [group.key]: event.target.value }))}
+                                className="h-8 min-w-[190px] rounded-[6px] border border-landing-line bg-black/10 px-2.5 text-xs text-landing-ink outline-none transition-colors focus:border-landing-blue max-[760px]:w-full"
+                              >
+                                {group.options.map((option) => (
+                                  <option key={nativeKey(option)} value={option.platformKey} className="bg-[#10151d] text-landing-ink">
+                                    {option.platformLabel}
+                                  </option>
+                                ))}
+                              </select>
+                            </td>
+                            <td className="px-5 py-3 text-xs text-landing-muted max-[760px]:hidden">{group.version}</td>
+                            <td className="px-5 py-3 text-right text-xs text-landing-muted max-[760px]:hidden">{formatSize(selectedAgent.info.size)}</td>
+                            <td className="px-5 py-3 text-right max-[760px]:px-0">
+                              <a href={selectedAgent.info.url} download className="landing-nav-link inline-flex h-8 items-center gap-1 whitespace-nowrap rounded-[6px] border border-landing-line px-2.5 text-xs font-medium transition-colors hover:border-landing-blue">
+                                <Download size={13} />
+                                {t.download}
+                              </a>
+                            </td>
+                          </tr>
+                        );
+                      })}
+                    </tbody>
+                  </table>
+                  {filteredNativeGroups.length === 0 && <div className="px-5 py-12 text-center text-sm text-landing-muted">{t.noResults}</div>}
+                </>
+              )}
+
+              {activeTab === "jre" && (
+                <>
+                  <p className="border-b border-landing-line px-5 py-3 text-sm text-landing-muted whitespace-nowrap max-[760px]:whitespace-normal max-[760px]:px-4">{t.jreDesc}</p>
+                  <table className="w-full table-auto border-collapse text-sm max-[760px]:block">
+                    <thead className="bg-landing-panel text-xs font-medium text-landing-muted max-[760px]:hidden">
+                      <tr className="border-b border-landing-line">
+                        <th className="px-5 py-2.5 text-left font-medium">{t.platform}</th>
+                        <th className="px-5 py-2.5 text-left font-medium">JRE</th>
+                        <th className="px-5 py-2.5 text-left font-medium">{t.version}</th>
+                        <th className="px-5 py-2.5 text-right font-medium">{t.size}</th>
+                        <th className="w-24 px-5 py-2.5" />
+                      </tr>
+                    </thead>
+                    <tbody className="max-[760px]:block">
+                      {filteredJres.map((j) => {
+                        const key = platformKey(j);
+                        return (
+                          <tr key={key} className="border-b border-landing-line transition-colors last:border-b-0 hover:bg-landing-panel max-[760px]:grid max-[760px]:grid-cols-[1fr_auto] max-[760px]:items-center max-[760px]:gap-3 max-[760px]:px-4">
+                            <td className="min-w-0 px-5 py-3 font-medium text-landing-ink max-[760px]:px-0">
+                              <div className="flex min-w-0 items-center gap-2">
+                                <span className="min-w-0 truncate">{j.platformLabel}</span>
+                                <span className="hidden shrink-0 rounded-[5px] border border-landing-green/35 bg-landing-green/10 px-1.5 py-0.5 font-mono text-[11px] text-landing-green max-[760px]:inline">JRE {j.jreKey}</span>
+                              </div>
+                            </td>
+                            <td className="px-5 py-3 max-[760px]:hidden">
+                              <span className="inline-flex rounded-[5px] border border-landing-green/35 bg-landing-green/10 px-1.5 py-0.5 font-mono text-[11px] text-landing-green">JRE {j.jreKey}</span>
+                            </td>
+                            <td className="px-5 py-3 text-xs text-landing-muted max-[760px]:hidden">{j.jreVersion}</td>
+                            <td className="px-5 py-3 text-right text-xs text-landing-muted max-[760px]:hidden">{formatSize(j.info.size)}</td>
+                            <td className="px-5 py-3 text-right max-[760px]:px-0">
+                              <a href={j.info.url} download className="landing-nav-link inline-flex h-8 items-center gap-1 whitespace-nowrap rounded-[6px] border border-landing-line px-2.5 text-xs font-medium transition-colors hover:border-landing-blue">
+                                <Download size={13} />
+                                {t.download}
+                              </a>
+                            </td>
+                          </tr>
+                        );
+                      })}
+                    </tbody>
+                  </table>
+                  {filteredJres.length === 0 && <div className="px-5 py-12 text-center text-sm text-landing-muted">{t.noResults}</div>}
+                </>
+              )}
+            </div>
+
+            <div className="landing-glass-card rounded-[10px] p-5 text-sm text-landing-muted leading-[1.65]">
+              <strong className="text-landing-ink">{lang === "cn" ? "离线使用说明" : "Offline Usage"}</strong>
+              <p className="mt-1">{t.downloadHint}</p>
+            </div>
+          </>
+        )}
+      </section>
+    </main>
+  );
+}
diff --git a/docs/app/[lang]/drivers/page.tsx b/docs/app/[lang]/drivers/page.tsx
new file mode 100644
index 0000000..5dc331d
--- /dev/null
+++ b/docs/app/[lang]/drivers/page.tsx
@@ -0,0 +1,32 @@
+import { DriversClient } from "./DriversClient";
+import { buildMetadata } from "@/lib/metadata";
+import type { Metadata } from "next";
+
+const pageMeta = {
+  en: {
+    title: "Offline Driver Downloads",
+    description: "Download DBX offline driver bundles, database drivers, and JRE packages for air-gapped environments across macOS, Linux, and Windows.",
+  },
+  cn: {
+    title: "离线驱动下载",
+    description: "下载 DBX 离线驱动整包、数据库驱动和 JRE 离线包，覆盖 macOS、Linux、Windows 平台。",
+  },
+};
+
+export async function generateMetadata({ params }: { params: Promise<{ lang: string }> }): Promise<Metadata> {
+  const { lang } = await params;
+  const l = lang === "cn" ? "cn" : "en";
+  const meta = pageMeta[l];
+
+  return buildMetadata({
+    title: meta.title,
+    description: meta.description,
+    path: `/${l}/drivers`,
+    lang: l,
+    ogType: "website",
+  });
+}
+
+export default function DriversPage() {
+  return <DriversClient />;
+}
diff --git a/docs/app/[lang]/layout.tsx b/docs/app/[lang]/layout.tsx
new file mode 100644
index 0000000..e5eaa66
--- /dev/null
+++ b/docs/app/[lang]/layout.tsx
@@ -0,0 +1,66 @@
+import type { ReactNode } from "react";
+import type { Metadata } from "next";
+import { RootProvider } from "fumadocs-ui/provider/next";
+import { StaticSearchDialog } from "@/components/StaticSearchDialog";
+import { i18nUI } from "@/lib/i18n";
+import { SITE_URL, SITE_NAME, DEFAULT_DESCRIPTION } from "@/lib/metadata";
+
+const LOCALE_MAP: Record<string, { locale: string; title: string; description: string }> = {
+  en: {
+    locale: "en_US",
+    title: "DBX - 20 MB to manage 60+ databases",
+    description: DEFAULT_DESCRIPTION,
+  },
+  cn: {
+    locale: "zh_CN",
+    title: "DBX - 20MB，管理60+种数据库",
+    description: "60+ 种数据库，仅 20 MB。支持桌面与 Docker 自托管，内置 AI 助手。",
+  },
+};
+
+export async function generateMetadata({ params }: { params: Promise<{ lang: string }> }): Promise<Metadata> {
+  const { lang } = await params;
+  const l = lang === "cn" ? "cn" : "en";
+  const meta = LOCALE_MAP[l];
+
+  return {
+    title: {
+      default: meta.title,
+      template: `%s | ${SITE_NAME}`,
+    },
+    description: meta.description,
+    openGraph: {
+      locale: meta.locale,
+      siteName: SITE_NAME,
+      url: `${SITE_URL}/${l}`,
+    },
+    alternates: {
+      canonical: `${SITE_URL}/${l}`,
+      languages: {
+        en: `${SITE_URL}/en`,
+        zh: `${SITE_URL}/cn`,
+        "x-default": `${SITE_URL}/en`,
+      },
+    },
+  };
+}
+
+export default async function LangLayout({ params, children }: { params: Promise<{ lang: string }>; children: ReactNode }) {
+  const { lang } = await params;
+
+  return (
+    <RootProvider
+      i18n={i18nUI.provider(lang)}
+      search={{
+        SearchDialog: StaticSearchDialog,
+      }}
+      theme={{ defaultTheme: "system", enableSystem: true }}
+    >
+      {children}
+    </RootProvider>
+  );
+}
+
+export function generateStaticParams() {
+  return [{ lang: "en" }, { lang: "cn" }];
+}
diff --git a/docs/app/[lang]/page.tsx b/docs/app/[lang]/page.tsx
new file mode 100644
index 0000000..85073c2
--- /dev/null
+++ b/docs/app/[lang]/page.tsx
@@ -0,0 +1,616 @@
+import Link from "next/link";
+import type { Metadata } from "next";
+import type { CSSProperties } from "react";
+import { HeroProductStage } from "@/components/aceternity/HeroProductStage";
+import { InfiniteMovingCards } from "@/components/aceternity/InfiniteMovingCards";
+import { Spotlight } from "@/components/aceternity/Spotlight";
+import { LandingNav } from "@/components/landing/LandingNav";
+import { LandingFooter } from "@/components/landing/LandingFooter";
+import { InstallTabs } from "@/components/landing/InstallTabs";
+import { LandingLatestUpdates } from "@/components/landing/LandingLatestUpdates";
+import { RevealSection } from "@/components/landing/RevealSection";
+import { ContributorsWallContent } from "@/components/landing/ContributorsWall";
+import { fetchContributors } from "@/lib/contributors";
+import { getAppVersion } from "@/lib/appVersion";
+import { fetchChangelog } from "@/lib/changelog";
+import { fetchLatestReleaseInfo } from "@/lib/latestRelease";
+import { ArrowRight, Bot, Database, FileCode, GitCompare, Network, Search, Shield, Table, Terminal, Zap } from "lucide-react";
+
+const fallbackStarLabel = "1.3k+";
+
+function formatStars(count: number) {
+  if (count >= 1000) {
+    return `${(Math.floor(count / 100) / 10).toFixed(1)}k+`;
+  }
+
+  return `${count}+`;
+}
+
+async function getGitHubStarLabel() {
+  try {
+    const response = await fetch("https://api.github.com/repos/t8y2/dbx", {
+      headers: { Accept: "application/vnd.github+json" },
+      next: { revalidate: 60 * 60 * 6 },
+    });
+
+    if (!response.ok) return fallbackStarLabel;
+
+    const data = (await response.json()) as { stargazers_count?: number };
+    return typeof data.stargazers_count === "number" ? formatStars(data.stargazers_count) : fallbackStarLabel;
+  } catch {
+    return fallbackStarLabel;
+  }
+}
+
+function metrics(starLabel: string) {
+  return {
+    en: [
+      { value: "~20 MB", label: "desktop installer" },
+      { value: "60+", label: "database engines" },
+      { value: "2 modes", label: "desktop and Docker" },
+      { value: starLabel, label: "GitHub stars, fully open-source" },
+    ],
+    cn: [
+      { value: "~20 MB", label: "桌面安装包" },
+      { value: "60+", label: "数据库引擎" },
+      { value: "2 种模式", label: "桌面与 Docker" },
+      { value: starLabel, label: "GitHub Star，完全开源" },
+    ],
+  };
+}
+
+const databaseSupport = [
+  { name: "MySQL", icon: "/icons/database/mysql.svg", tone: "#4479a1" },
+  { name: "PostgreSQL", icon: "/icons/database/postgres.svg", tone: "#4169e1" },
+  { name: "SQLite", icon: "/icons/database/sqlite.svg", tone: "#5aa6d6" },
+  { name: "Redis", icon: "/icons/database/redis.svg", tone: "#ff4438" },
+  { name: "DuckDB", icon: "/icons/database/duckdb.svg", tone: "#fff000" },
+  { name: "ClickHouse", icon: "/icons/database/clickhouse.svg", tone: "#ffcc01" },
+  { name: "SQL Server", icon: "/icons/database/sqlserver.svg", tone: "#9ca3af" },
+  { name: "MongoDB", icon: "/icons/database/mongodb.svg", tone: "#47a248" },
+  { name: "Oracle", icon: "/icons/database/oracle.svg", tone: "#f80000" },
+  { name: "Elasticsearch", icon: "/icons/database/elasticsearch.svg", tone: "#00bfb3" },
+  { name: "Qdrant", icon: "/icons/database/qdrant.svg", tone: "#dc244c" },
+  { name: "Milvus", icon: "/icons/database/milvus.png", tone: "#00a1ea" },
+  { name: "Weaviate", icon: "/icons/database/weaviate.png", tone: "#00b894" },
+  { name: "MariaDB", icon: "/icons/database/mariadb.svg", tone: "#003545" },
+  { name: "Doris", icon: "/icons/database/doris.svg", tone: "#5b7cfa" },
+  { name: "StarRocks", icon: "/icons/database/starrocks.svg", tone: "#6750ff" },
+  { name: "Manticore", icon: "/icons/database/manticoresearch.png", tone: "#b8e646" },
+  { name: "Redshift", icon: "/icons/database/redshift.svg", tone: "#8c4fff" },
+  { name: "Dameng", icon: "/icons/database/dm.svg", tone: "#3857ff" },
+  { name: "GaussDB", icon: "/icons/database/gaussdb.svg", tone: "#ff5a3d" },
+  { name: "openGauss", icon: "/icons/database/opengauss.svg", tone: "#1488c9" },
+  { name: "KingBase", icon: "/icons/database/kingbase.svg", tone: "#e1212d" },
+  { name: "HighGo", icon: "/icons/database/highgo.png", tone: "#005bac" },
+  { name: "TiDB", icon: "/icons/database/tidb.svg", tone: "#e60012" },
+  { name: "OceanBase", icon: "/icons/database/oceanbase.svg", tone: "#2285ff" },
+  { name: "TDSQL", icon: "/icons/database/tdsql.webp", tone: "#0080ff" },
+  { name: "PolarDB", icon: "/icons/database/polardb.webp", tone: "#1890ff" },
+  { name: "GreatSQL", icon: "/icons/database/greatsql.webp", tone: "#0066b3" },
+  { name: "SelectDB", icon: "/icons/database/selectdb.svg", tone: "#22c1c3" },
+  { name: "TDengine", icon: "/icons/database/tdengine.svg", tone: "#2f6fff" },
+  { name: "CockroachDB", icon: "/icons/database/cockroachdb.svg", tone: "#6933ff" },
+  { name: "RQLite", icon: "/icons/database/rqlite.png", tone: "#5a67d8" },
+  { name: "Turso", icon: "/icons/database/turso.png", tone: "#10b981" },
+  { name: "Databend", icon: "/icons/database/databend.svg", tone: "#f59e0b" },
+  { name: "Databricks", icon: "/icons/database/databricks.webp", tone: "#ff5a1f" },
+  { name: "Snowflake", icon: "/icons/database/snowflake.svg", tone: "#29b5e8" },
+  { name: "BigQuery", icon: "/icons/database/bigquery.svg", tone: "#4285f4" },
+  { name: "Trino", icon: "/icons/database/trino.svg", tone: "#dd00a1" },
+  { name: "PrestoSQL", icon: "/icons/database/presto.svg", tone: "#5890ff" },
+  { name: "Hive", icon: "/icons/database/hive.svg", tone: "#fdcb00" },
+  { name: "DB2", icon: "/icons/database/db2.svg", tone: "#054ada" },
+  { name: "SAP HANA", icon: "/icons/database/saphana.webp", tone: "#008fd3" },
+  { name: "Teradata", icon: "/icons/database/teradata.webp", tone: "#f37440" },
+  { name: "Vertica", icon: "/icons/database/vertica.webp", tone: "#007dc5" },
+  { name: "Exasol", icon: "/icons/database/exasol.webp", tone: "#002b45" },
+  { name: "Firebird", icon: "/icons/database/firebird.webp", tone: "#e17000" },
+  { name: "Informix", icon: "/icons/database/informix.svg", tone: "#0178c8" },
+  { name: "Neo4j", icon: "/icons/database/neo4j.svg", tone: "#018bff" },
+  { name: "Cassandra", icon: "/icons/database/cassandra.svg", tone: "#1287b1" },
+  { name: "Kylin", icon: "/icons/database/apache_kylin.svg", tone: "#fb8c00" },
+  { name: "InfluxDB", icon: "/icons/database/influxdb.svg", tone: "#22adf6" },
+  { name: "QuestDB", icon: "/icons/database/questdb.svg", tone: "#dc2626" },
+  { name: "IoTDB", icon: "/icons/database/iotdb.svg", tone: "#3cb371" },
+  { name: "KWDB", icon: "/icons/database/kwdb.svg", tone: "#6366f1" },
+  { name: "Vastbase", icon: "/icons/database/vastbase.png", tone: "#2563eb" },
+  { name: "GoldenDB", icon: "/icons/database/goldendb.png", tone: "#eab308" },
+  { name: "YashanDB", icon: "/icons/database/yashandb.png", tone: "#dc2626" },
+  { name: "SunDB", icon: "/icons/database/sundb.svg", tone: "#f97316" },
+  { name: "XuguDB", icon: "/icons/database/xugu.png", tone: "#84cc16" },
+  { name: "GBase", icon: "/icons/database/gbase.webp", tone: "#06b6d4" },
+  { name: "Access", icon: "/icons/database/access.png", tone: "#a53346" },
+  { name: "H2", icon: "/icons/database/h2.svg", tone: "#f7a81b" },
+  { name: "Etcd", icon: "/icons/database/etcd.svg", tone: "#419eda" },
+  { name: "ZooKeeper", icon: "/icons/database/zookeeper.svg", tone: "#3b82f6" },
+  { name: "Pulsar", icon: "/icons/database/pulsar.svg", tone: "#188fff" },
+  { name: "Nacos", icon: "/icons/database/nacos.png", tone: "#2f80ed" },
+  { name: "IRIS", icon: "/icons/database/iris.png", tone: "#0085ca" },
+  { name: "JDBC", icon: "/icons/database/jdbc.svg", tone: "#6ea8ff" },
+  { name: "Your DB?", icon: "/icons/database/jdbc.svg", tone: "#6ea8ff", href: "https://github.com/t8y2/dbx/discussions", cta: true },
+];
+
+const workflows = {
+  en: [
+    {
+      icon: Terminal,
+      title: "Write and run SQL",
+      desc: "A CodeMirror 6 editor with metadata-aware completion, formatting, history, and selected SQL execution.",
+      href: "/en/docs/query-editor",
+    },
+    {
+      icon: Table,
+      title: "Browse and edit data",
+      desc: "Virtualized grids, inline editing, WHERE/ORDER BY controls, SQL preview, and export tools.",
+      href: "/en/docs/data-grid",
+    },
+    {
+      icon: Search,
+      title: "Explore schemas",
+      desc: "Navigate databases, schemas, tables, columns, indexes, foreign keys, and triggers from a focused sidebar.",
+      href: "/en/docs/schema-browser",
+    },
+    {
+      icon: GitCompare,
+      title: "Compare and migrate",
+      desc: "Schema diff, table import, database export, SQL file execution, and cross-engine data transfer.",
+      href: "/en/docs/schema-diff",
+    },
+  ],
+  cn: [
+    {
+      icon: Terminal,
+      title: "编写与执行 SQL",
+      desc: "CodeMirror 6 编辑器，支持元数据补全、格式化、查询历史和选中 SQL 执行。",
+      href: "/cn/docs/query-editor",
+    },
+    {
+      icon: Table,
+      title: "浏览与编辑数据",
+      desc: "虚拟滚动表格、行内编辑、WHERE/ORDER BY 控制、SQL 预览和导出工具。",
+      href: "/cn/docs/data-grid",
+    },
+    {
+      icon: Search,
+      title: "浏览数据库结构",
+      desc: "在侧边栏中查看数据库、Schema、表、字段、索引、外键和触发器。",
+      href: "/cn/docs/schema-browser",
+    },
+    {
+      icon: GitCompare,
+      title: "对比与迁移",
+      desc: "Schema 对比、表导入、数据库导出、SQL 文件执行和跨引擎数据传输。",
+      href: "/cn/docs/schema-diff",
+    },
+  ],
+};
+
+const capabilities = {
+  en: [
+    { icon: Database, label: "Native Rust drivers, no JDBC runtime" },
+    { icon: Shield, label: "SSH tunnels, encrypted config export, destructive action guards" },
+    { icon: Bot, label: "AI assistant plus MCP server for Claude Code, Cursor, and agents" },
+    { icon: Network, label: "ER diagrams, schema diff, and field lineage for deeper analysis" },
+    { icon: FileCode, label: "CSV, Excel, SQL files, full exports, and cross-engine transfer" },
+    { icon: Zap, label: "Desktop app and self-hosted web deployment from the same project" },
+  ],
+  cn: [
+    { icon: Database, label: "Rust 原生驱动，不依赖 JDBC 运行时" },
+    { icon: Shield, label: "SSH 隧道、加密配置导出、危险操作确认" },
+    { icon: Bot, label: "内置 AI 助手，以及面向 Claude Code、Cursor 的 MCP Server" },
+    { icon: Network, label: "ER 图、Schema 对比、字段血缘，覆盖更深层分析场景" },
+    { icon: FileCode, label: "CSV、Excel、SQL 文件、完整导出和跨引擎传输" },
+    { icon: Zap, label: "桌面应用与自托管 Web 部署来自同一个项目" },
+  ],
+};
+
+const testimonials = {
+  en: [
+    {
+      name: "@cyano",
+      role: "PostgreSQL and Redis workflows",
+      avatar: "/avatars/cyano.jpg",
+      quote: "DBX keeps query work, schema checks, and Redis inspection in one small app. It feels focused instead of overloaded.",
+    },
+    {
+      name: "eryajf",
+      role: "Database management",
+      avatar: "/avatars/eryajf.jpg",
+      quote: "Try it once and you can feel it: DBX is the database management client that ends the competition.",
+    },
+    {
+      name: "@vbvb",
+      role: "Daily reporting",
+      avatar: "/avatars/vbvb.png",
+      quote: "The data grid and export flow are the parts I reach for every day. Filters, previews, and edits stay close to the data.",
+    },
+    {
+      name: "@ar414",
+      role: "Self-hosted tooling",
+      avatar: "/avatars/ar414.jpg",
+      quote: "Desktop mode is light enough for local work, and Docker mode makes it easy to give the team browser access.",
+    },
+    {
+      name: "@ryan",
+      role: "Multi-database projects",
+      avatar: "/avatars/ryan.jpg",
+      quote: "I can jump between SQLite, MySQL, MongoDB, and DuckDB without changing tools or waiting on a heavy runtime.",
+    },
+    {
+      name: "@acane",
+      role: "Schema review",
+      avatar: "/avatars/acane.png",
+      quote: "Schema browsing, ER diagrams, and diff tools make reviews faster because the important context is already connected.",
+    },
+    {
+      name: "@ydwang",
+      role: "Agent workflows",
+      avatar: "/avatars/ydwang.png",
+      quote: "The MCP server is a practical touch. It lets coding agents inspect database context without inventing another bridge.",
+    },
+    {
+      name: "@guangguang",
+      role: "Schema navigation",
+      avatar: "/avatars/guangguang.jpg",
+      quote: "Sidebar search and grouped objects make large schemas manageable. I can find what I need without scrolling through hundreds of tables.",
+    },
+    {
+      name: "@xuyuan",
+      role: "SQL editing",
+      avatar: "/avatars/xuyuan.jpg",
+      quote: "Code completion in the SQL editor picks up column names and table aliases automatically. It saves a lot of tab-switching to check schema.",
+    },
+    {
+      name: "@itkui",
+      role: "Data export",
+      avatar: "/avatars/itkui.jpg",
+      quote: "Export options cover CSV, Excel, and SQL inserts. For daily data pulls, the workflow is quick and doesn't need extra scripting.",
+    },
+    {
+      name: "@mebiuw",
+      role: "Secure connections",
+      avatar: "/avatars/mebiuw.jpg",
+      quote: "SSH tunnel setup is straightforward — fill in the fields and connect. No need to manage port forwarding manually in a terminal.",
+    },
+    {
+      name: "@patrickz",
+      role: "Database design",
+      avatar: "/avatars/patrickz.jpg",
+      quote: "ER diagrams give a clear picture of table relationships. Useful during design reviews when the team needs a shared visual reference.",
+    },
+    {
+      name: "@yanxuecan",
+      role: "AI-assisted queries",
+      avatar: "/avatars/yanxuecan.jpg",
+      quote: "The AI assistant helps draft queries from natural language. It handles routine JOINs and aggregations well enough to speed things up.",
+    },
+  ],
+  cn: [
+    {
+      name: "不剪发的Tony老师",
+      role: "PostgreSQL 与 Redis 工作流",
+      avatar: "/avatars/dongxuyang85.jpg",
+      quote: "DBX 把查询、结构检查和 Redis 查看放在一个轻量工具里，日常数据库工作不会被复杂界面打断。",
+    },
+    {
+      name: "二丫讲梵",
+      role: "数据库管理",
+      avatar: "/avatars/eryajf.jpg",
+      quote: "只需体验一次你就能感受到，DBX是一个杀死数据库管理客户端比赛的软件",
+    },
+    {
+      name: "Husky明夋",
+      role: "报表与数据核对",
+      avatar: "/avatars/husky.jpg",
+      quote: "数据表格、过滤、预览和导出都离数据很近，用起来像是为高频操作专门整理过。",
+    },
+    {
+      name: "孙志岗",
+      role: "团队自托管工具",
+      avatar: "/avatars/sunzhigang.jpg",
+      quote: "本地桌面版足够轻，自托管 Web 版又方便团队共用，同一个项目覆盖了两种场景。",
+    },
+    {
+      name: "zhufeng",
+      role: "多数据库项目",
+      avatar: "/avatars/zhufeng.jpg",
+      quote: "SQLite、MySQL、MongoDB、DuckDB 来回切换不用换工具，也不用拖着很重的运行时。",
+    },
+    {
+      name: "樱桃小财主",
+      role: "结构审查",
+      avatar: "/avatars/yingtao.jpg",
+      quote: "结构浏览、ER 图和 Schema 对比放在一起，做 review 时上下文更完整。",
+    },
+    {
+      name: "momo",
+      role: "Agent 数据库上下文",
+      avatar: "/avatars/momo.jpg",
+      quote: "MCP Server 很实用，能让编码 Agent 读取数据库上下文，不需要再额外搭桥。",
+    },
+    {
+      name: "逛逛GitHub",
+      role: "结构导航",
+      avatar: "/avatars/guangguang.jpg",
+      quote: "侧边栏搜索和分组浏览让大型 Schema 也不会迷路，不用在几百张表里翻来翻去。",
+    },
+    {
+      name: "序员先生",
+      role: "SQL 编辑",
+      avatar: "/avatars/xuyuan.jpg",
+      quote: "SQL 编辑器的补全能自动识别列名和别名，不用反复切到结构面板去确认字段。",
+    },
+    {
+      name: "IT老魁",
+      role: "数据导出",
+      avatar: "/avatars/itkui.jpg",
+      quote: "导出支持 CSV、Excel 和 INSERT 语句，日常取数据很快，不用再额外写脚本。",
+    },
+    {
+      name: "MebiuW",
+      role: "安全连接",
+      avatar: "/avatars/mebiuw.jpg",
+      quote: "SSH 隧道设置很直接，填好参数就能连，不用在终端里手动转发端口。",
+    },
+    {
+      name: "Patrick Zhang",
+      role: "数据库设计",
+      avatar: "/avatars/patrickz.jpg",
+      quote: "ER 图把表关系展示得很清楚，团队做设计评审时有个共同的可视化参考。",
+    },
+    {
+      name: "闫学灿",
+      role: "AI 辅助查询",
+      avatar: "/avatars/yanxuecan.jpg",
+      quote: "AI 助手能从自然语言生成查询，常规的 JOIN 和聚合写得不错，省了不少手敲时间。",
+    },
+  ],
+};
+
+const i18nText = {
+  en: {
+    heroTitle: "20 MB to manage 60+ databases!",
+    heroSubtitle: "DBX brings connections, SQL editing, data grids, schema tools, AI assistance, and self-hosted access into one lightweight product.",
+    download: "Download DBX",
+    downloadName: "Download DBX",
+    readDocs: "Read the docs",
+    docsStart: "Start here",
+    docsStartDesc: "Install DBX, create your first connection, and learn the main workflow.",
+    workflowsTitle: "Core workflows",
+    workflowsDesc: "The docs are organized around what you actually do in a database client.",
+    supportTitle: "Supports many databases",
+    supportDesc: "Connect and manage SQL, NoSQL, embedded databases, and MySQL/PostgreSQL-compatible engines without switching tools.",
+    testimonialsTitle: "What DBX is good at",
+    testimonialsDesc: "A closer look at the everyday database workflows DBX is built to make smoother.",
+    capabilitiesTitle: "Built for real database work",
+    contributorsTitle: "Built by the community",
+    contributorsDesc: "DBX is fully open-source. Every feature, fix, and driver starts with a contributor.",
+    footerTitle: "Ready to try DBX?",
+    footerDesc: "Use the desktop app for local work, or deploy the Docker version for browser-based access.",
+    release: "Latest release",
+    docker: "Docker setup",
+  },
+  cn: {
+    heroTitle: "20MB，管理60+种数据库！",
+    heroSubtitle: "DBX 将连接管理、SQL 编辑、数据表格、结构工具、AI 助手和自托管访问放进一个轻量产品里。",
+    download: "下载 DBX",
+    downloadName: "下载 DBX",
+    readDocs: "查看文档",
+    docsStart: "从这里开始",
+    docsStartDesc: "安装 DBX、创建第一个连接，并了解主要工作流。",
+    workflowsTitle: "核心工作流",
+    workflowsDesc: "文档围绕数据库客户端里的真实任务组织，而不是堆功能清单。",
+    supportTitle: "支持多种数据库",
+    supportDesc: "告别频繁切换工具的烦恼。DBX 可以连接和管理多种数据库类型，让你更专注于查询、分析和数据本身。",
+    testimonialsTitle: "DBX 适合什么样的工作",
+    testimonialsDesc: "从连接管理、数据浏览到 AI 辅助，DBX 围绕高频数据库工作流打磨体验。",
+    capabilitiesTitle: "面向真实数据库工作的能力",
+    contributorsTitle: "社区共建",
+    contributorsDesc: "DBX 因每一位贡献者而生长",
+    footerTitle: "准备试试 DBX？",
+    footerDesc: "本地工作使用桌面版，需要浏览器访问时部署 Docker 版。",
+    release: "最新版本",
+    docker: "Docker 部署",
+  },
+};
+
+import { buildMetadata } from "@/lib/metadata";
+
+const landingMeta = {
+  en: {
+    title: "DBX - 20 MB to manage 60+ databases!",
+    description: "DBX brings connections, SQL editing, data grids, schema tools, AI assistance, and self-hosted access into one lightweight product.",
+  },
+  cn: {
+    title: "DBX - 20MB，管理60+种数据库！",
+    description: "DBX 将连接管理、SQL 编辑、数据表格、结构工具、AI 助手和自托管访问放进一个轻量产品里。",
+  },
+};
+
+export async function generateMetadata({ params }: { params: Promise<{ lang: string }> }): Promise<Metadata> {
+  const { lang } = await params;
+  const l = lang === "cn" ? "cn" : "en";
+  const meta = landingMeta[l];
+
+  return buildMetadata({
+    title: meta.title,
+    description: meta.description,
+    path: `/${l}`,
+    lang: l,
+    ogType: "website",
+  });
+}
+
+export default async function LandingPage({ params }: { params: Promise<{ lang: string }> }) {
+  const { lang } = await params;
+  const l = lang === "cn" ? "cn" : "en";
+  const t = i18nText[l];
+  const workflowItems = workflows[l];
+  const capabilityItems = capabilities[l];
+  const starLabel = await getGitHubStarLabel();
+  const metricItems = metrics(starLabel)[l];
+  const appVersion = getAppVersion();
+  const [initialChangelog, initialLatestRelease] = await Promise.all([fetchChangelog(l), fetchLatestReleaseInfo()]);
+  const contributors = await fetchContributors();
+  const initialDownloadVersion = initialLatestRelease?.version ?? appVersion;
+  const testimonialItems = testimonials[l];
+
+  return (
+    <main className="landing">
+      {/* Nav */}
+      <LandingNav lang={l} active="home" />
+
+      {/* Hero */}
+      <section className="landing-hero">
+        <Spotlight />
+        <div className="relative z-[1] max-w-[1180px] mx-auto px-7 max-[1040px]:max-w-[920px] max-[760px]:px-[18px]">
+          <div className="landing-hero-copy relative z-[6] grid justify-items-center max-w-[900px] mx-auto text-center max-[1040px]:max-w-[760px]">
+            <h1 className="min-w-0 m-0 text-[clamp(36px,4.2vw,56px)] font-[820] leading-[1.06] text-landing-ink whitespace-nowrap max-[760px]:text-[clamp(26px,7vw,38px)]">{t.heroTitle}</h1>
+            <p className="landing-hero-subtitle min-w-0 mt-5 mx-auto text-[17px] font-[460] leading-[1.8] whitespace-nowrap max-[760px]:text-[15px] max-[760px]:leading-[1.68] max-[760px]:whitespace-normal max-[760px]:max-w-[320px]">{t.heroSubtitle}</p>
+            <div className="w-full max-w-[520px] mt-10">
+              <InstallTabs lang={l} version={initialDownloadVersion} />
+            </div>
+          </div>
+          <HeroProductStage />
+        </div>
+      </section>
+
+      {/* Metrics */}
+      <RevealSection className="grid grid-cols-4 gap-3 max-w-[1180px] mx-auto px-7 pt-6 pb-11 [animation:landing-rise_0.72s_ease-out_0.1s_both] max-[760px]:grid-cols-1 max-[760px]:px-[18px] max-[760px]:pb-8">
+        {metricItems.map((item) => (
+          <div key={item.label} data-stagger className="landing-glass-card min-h-[118px] rounded-[10px] p-[22px] max-[760px]:min-h-[96px] max-[760px]:p-[18px]">
+            <strong className="block text-landing-ink text-2xl font-[720]">{item.value}</strong>
+            <span className="block mt-1 text-landing-muted text-[13px]">{item.label}</span>
+          </div>
+        ))}
+      </RevealSection>
+
+      {/* Doc start */}
+      <RevealSection className="landing-glass-card-green flex items-center justify-between gap-[22px] max-w-[calc(1180px-56px)] mx-auto px-7 py-7 rounded-[10px] max-[760px]:block max-[760px]:px-[18px]">
+        <div>
+          <h2 className="m-0 text-[25px] font-[720] text-landing-ink">{t.docsStart}</h2>
+          <p className="mt-2 text-landing-muted text-sm leading-[1.65]">{t.docsStartDesc}</p>
+        </div>
+        <Link href={`/${l}/docs/getting-started`} className="landing-inline-link flex shrink-0 items-center gap-[7px] text-sm font-[650] max-[760px]:mt-4" target="_blank">
+          {t.readDocs}
+          <ArrowRight size={15} />
+        </Link>
+      </RevealSection>
+
+      {/* Workflows */}
+      <RevealSection className="max-w-[1180px] mx-auto px-7 pt-[70px] pb-1 max-[760px]:px-[18px]">
+        <div className="grid grid-cols-[minmax(220px,0.42fr)_minmax(0,0.58fr)] gap-9 items-end mb-[22px] max-[760px]:block">
+          <h2 className="m-0 text-[25px] font-[720] text-landing-ink">{t.workflowsTitle}</h2>
+          <p className="mt-2 max-w-[650px] text-landing-muted text-sm leading-[1.65] justify-self-end text-right max-[760px]:max-w-none max-[760px]:text-left">{t.workflowsDesc}</p>
+        </div>
+        <div className="landing-workflow-grid grid grid-cols-4 rounded-[10px] overflow-hidden max-[1040px]:grid-cols-2 max-[760px]:grid-cols-1">
+          {workflowItems.map((item, i) => (
+            <Link
+              key={item.title}
+              href={item.href}
+              className={`landing-workflow-card min-h-[250px] p-6 border-r border-r-landing-line max-[760px]:min-h-0 max-[760px]:border-r-0 max-[760px]:border-b max-[760px]:border-b-landing-line max-[760px]:last:border-b-0 ${i === workflowItems.length - 1 ? "border-r-0" : ""}`}
+              target="_blank"
+              data-stagger
+            >
+              <item.icon size={20} className="text-landing-blue" />
+              <h3 className="mt-[18px] text-base font-bold">{item.title}</h3>
+              <p className="mt-2.5 text-landing-muted text-[13px] leading-[1.62]">{item.desc}</p>
+              <span className="inline-flex items-center gap-1.5 mt-[18px] text-landing-ink text-[13px] font-[650]">
+                {t.readDocs}
+                <ArrowRight size={14} />
+              </span>
+            </Link>
+          ))}
+        </div>
+      </RevealSection>
+
+      {/* Database support */}
+      <RevealSection className="relative max-w-[1180px] mx-auto px-7 pt-[70px] pb-1 max-[760px]:px-[18px]">
+        <div className="grid grid-cols-[minmax(260px,0.28fr)_minmax(0,0.72fr)] gap-9 items-end mb-[30px] max-[760px]:block">
+          <h2 className="m-0 text-[25px] font-[720] text-landing-ink">{t.supportTitle}</h2>
+          <p className="mt-2 max-w-[760px] text-landing-muted text-sm leading-[1.65] justify-self-end text-right max-[760px]:max-w-none max-[760px]:text-left">{t.supportDesc}</p>
+        </div>
+        <div className="grid grid-cols-9 gap-3 max-[1240px]:grid-cols-7 max-[960px]:grid-cols-5 max-[640px]:grid-cols-3 max-[440px]:grid-cols-2 max-[760px]:gap-2.5">
+          {databaseSupport.map((db) => {
+            const isCta = "href" in db && db.href;
+            const CardTag = isCta ? "a" : "div";
+            return (
+            <CardTag
+              className={`landing-db-card grid place-items-center aspect-square rounded-[10px] px-2.5 py-[18px] max-[760px]:py-4 ${isCta ? "border-2 border-dashed border-[color-mix(in_srgb,var(--color-landing-blue)_40%,transparent)] hover:border-[color-mix(in_srgb,var(--color-landing-blue)_70%,transparent)] transition-colors cursor-pointer" : ""}`}
+              key={db.name}
+              {...(isCta ? { href: db.href, target: "_blank", rel: "noopener noreferrer" } : {})}
+              style={{ "--db-tone": db.tone } as CSSProperties}
+              data-stagger
+            >
+              <div className="landing-db-icon grid place-items-center w-12 h-12 mb-[15px]">
+                {isCta ? (
+                  <span className="grid place-items-center w-10 h-10 rounded-full border-2 border-dashed text-landing-blue border-landing-blue text-2xl leading-none">+</span>
+                ) : db.icon ? (
+                  <img src={db.icon} alt="" width={38} height={38} className="block w-[38px] h-[38px] object-contain" />
+                ) : (
+                  <span className="grid place-items-center min-w-[46px] h-8 rounded-lg px-2 text-white text-xs font-[780]">{db.name.slice(0, 2).toUpperCase()}</span>
+                )}
+              </div>
+              <strong className={`text-sm font-[650] leading-[1.2] text-center ${isCta ? "text-landing-blue" : "text-[color-mix(in_srgb,var(--color-landing-ink)_92%,var(--color-landing-muted))]"}`}>{db.name}</strong>
+            </CardTag>
+            );
+          })}
+        </div>
+      </RevealSection>
+
+      {/* Testimonials */}
+      <RevealSection className="max-w-[1180px] mx-auto px-7 pt-[70px] pb-1 overflow-hidden max-[760px]:px-[18px]">
+        <div className="grid grid-cols-[minmax(220px,0.42fr)_minmax(0,0.58fr)] gap-9 items-end mb-[22px] max-[760px]:block">
+          <h2 className="m-0 text-[25px] font-[720] text-landing-ink">{t.testimonialsTitle}</h2>
+          <p className="mt-2 max-w-[650px] text-landing-muted text-sm leading-[1.65] justify-self-end text-right max-[760px]:max-w-none max-[760px]:text-left">{t.testimonialsDesc}</p>
+        </div>
+        <div className="landing-testimonial-wall relative grid gap-3.5 -mx-7 py-1 max-[760px]:-mx-[18px] max-[760px]:mt-[18px]">
+          <InfiniteMovingCards items={testimonialItems.slice(0, 6)} speed="slow" />
+          <InfiniteMovingCards items={testimonialItems.slice(6)} direction="right" speed="slow" />
+        </div>
+      </RevealSection>
+
+      {/* Capabilities */}
+      <RevealSection className="max-w-[1180px] mx-auto px-7 pt-[70px] pb-1 max-[760px]:px-[18px]">
+        <div className="grid grid-cols-[minmax(220px,0.42fr)_minmax(0,0.58fr)] gap-9 items-end mb-[22px] max-[760px]:block">
+          <h2 className="m-0 text-[25px] font-[720] text-landing-ink">{t.capabilitiesTitle}</h2>
+        </div>
+        <div className="grid grid-cols-3 gap-2.5 max-[1040px]:grid-cols-2 max-[760px]:grid-cols-1 max-[760px]:mt-[18px]">
+          {capabilityItems.map((item) => (
+            <div key={item.label} className="landing-capability flex items-center gap-2.5 min-h-[72px] rounded-lg px-[15px] py-3.5" data-stagger>
+              <item.icon size={18} className="shrink-0 text-landing-blue" />
+              <span className="text-landing-ink text-[13px] font-[560] leading-[1.45]">{item.label}</span>
+            </div>
+          ))}
+        </div>
+      </RevealSection>
+
+      {/* Contributors */}
+      <RevealSection className="max-w-[1180px] mx-auto px-7 pt-[70px] pb-1 max-[760px]:px-[18px]">
+        <ContributorsWallContent contributors={contributors} title={t.contributorsTitle} desc={t.contributorsDesc} />
+      </RevealSection>
+
+      {/* Updates */}
+      <LandingLatestUpdates lang={l} fallbackVersion={appVersion} initialRelease={initialChangelog.releases[0]} initialLatestRelease={initialLatestRelease} />
+
+      {/* Final CTA */}
+      <RevealSection className="flex items-center justify-between gap-6 max-w-[1180px] mx-auto px-7 border border-landing-line rounded-[10px] bg-landing-panel mt-[72px] mb-14 py-[30px] max-[760px]:block max-[760px]:px-[18px]">
+        <div>
+          <h2 className="m-0 text-[25px] font-[720] text-landing-ink">{t.footerTitle}</h2>
+          <p className="mt-2 text-landing-muted text-sm leading-[1.65]">{t.footerDesc}</p>
+        </div>
+        <div className="flex items-center gap-2.5 flex-wrap justify-end max-[760px]:mt-[18px]">
+          <Link href="https://github.com/t8y2/dbx/releases/latest" target="_blank" className="landing-final-link inline-flex items-center justify-center min-h-[42px] rounded-[7px] px-[15px] text-sm font-[650]">
+            {t.release}
+          </Link>
+          <Link href={`/${l}/docs/getting-started#docker`} target="_blank" className="landing-final-link inline-flex items-center justify-center min-h-[42px] rounded-[7px] px-[15px] text-sm font-[650]">
+            {t.docker}
+          </Link>
+        </div>
+      </RevealSection>
+
+      <LandingFooter lang={l} />
+    </main>
+  );
+}
diff --git a/docs/app/global.css b/docs/app/global.css
new file mode 100644
index 0000000..20f25de
--- /dev/null
+++ b/docs/app/global.css
@@ -0,0 +1,1136 @@
+@import "tailwindcss";
+@import "fumadocs-ui/css/ocean.css";
+@import "fumadocs-ui/css/preset.css";
+
+@theme {
+  --color-landing-ink: #f7fbff;
+  --color-landing-muted: #9aa9bc;
+  --color-landing-blue: #6ea8ff;
+  --color-landing-sky: #52d5ff;
+  --color-landing-green: #44d19d;
+  --color-landing-line: rgba(155, 176, 205, 0.18);
+  --color-landing-soft: rgba(148, 163, 184, 0.1);
+  --color-landing-panel: rgba(17, 21, 29, 0.84);
+  --color-landing-panel-strong: rgba(23, 28, 38, 0.94);
+}
+
+:root {
+  --color-fd-background: #fafafa;
+  --color-fd-foreground: #0a0a0a;
+  --color-fd-muted: #f5f5f5;
+  --color-fd-muted-foreground: #737373;
+  --color-fd-popover: #fff;
+  --color-fd-popover-foreground: #272727;
+  --color-fd-card: #fefefe;
+  --color-fd-card-foreground: #0a0a0a;
+  --color-fd-border: #9993;
+  --color-fd-primary: #171717;
+  --color-fd-primary-foreground: #fafafa;
+  --color-fd-secondary: #f5f5f5;
+  --color-fd-secondary-foreground: #171717;
+  --color-fd-accent: #f0f0f0;
+  --color-fd-accent-foreground: #171717;
+  --color-fd-ring: #a3a3a3;
+  --dbx-surface: #fefefe;
+  --dbx-surface-soft: #f7f7f7;
+  --dbx-line: var(--color-fd-border);
+  --dbx-blue: #171717;
+  --dbx-sky: #737373;
+  --dbx-green: #525252;
+}
+
+.dark {
+  --color-fd-background: #050505;
+  --color-fd-foreground: #fafafa;
+  --color-fd-muted: #141414;
+  --color-fd-muted-foreground: #999;
+  --color-fd-popover: #0a0a0a;
+  --color-fd-popover-foreground: #fafafa;
+  --color-fd-card: #0a0a0a;
+  --color-fd-card-foreground: #fafafa;
+  --color-fd-border: #80808033;
+  --color-fd-primary: #fafafa;
+  --color-fd-primary-foreground: #171717;
+  --color-fd-secondary: #212121;
+  --color-fd-secondary-foreground: #fafafa;
+  --color-fd-accent: #262626;
+  --color-fd-accent-foreground: #fff;
+  --color-fd-ring: #595959;
+  --dbx-surface: #0a0a0a;
+  --dbx-surface-soft: #141414;
+  --dbx-line: var(--color-fd-border);
+  --dbx-blue: #fafafa;
+  --dbx-sky: #999;
+  --dbx-green: #d4d4d4;
+}
+
+html {
+  background: var(--color-fd-background);
+  color-scheme: light;
+}
+
+.dark {
+  color-scheme: dark;
+}
+
+body {
+  min-height: 100vh;
+  background: var(--color-fd-background);
+  text-rendering: optimizeLegibility;
+}
+
+.dark body {
+  background: var(--color-fd-background);
+}
+
+::selection {
+  background: color-mix(in srgb, var(--color-fd-primary) 18%, transparent);
+}
+
+article {
+  color: color-mix(in srgb, var(--color-fd-foreground) 92%, var(--color-fd-muted-foreground));
+}
+
+article,
+article :where(h1, h2, h3, h4, h5, h6, p, li, blockquote, table, th, td, pre, code, span, strong, em) {
+  -webkit-user-select: text;
+  user-select: text;
+}
+
+article h1 {
+  letter-spacing: 0;
+  line-height: 1.08;
+}
+
+article h2 {
+  border-top: 1px solid var(--dbx-line);
+  margin-top: 2.35rem;
+  padding-top: 1.35rem;
+  letter-spacing: 0;
+}
+
+article h3 {
+  letter-spacing: 0;
+}
+
+article p,
+article li {
+  line-height: 1.78;
+}
+
+article p {
+  color: color-mix(in srgb, var(--color-fd-foreground) 78%, var(--color-fd-muted-foreground));
+}
+
+article a:not([class]) {
+  color: var(--dbx-blue);
+  font-weight: 560;
+  text-decoration-color: color-mix(in srgb, var(--color-fd-primary) 32%, transparent);
+  text-underline-offset: 3px;
+}
+
+article a:not([class]):hover {
+  text-decoration-color: var(--dbx-blue);
+}
+
+article img {
+  border: 1px solid var(--dbx-line);
+  border-radius: 10px;
+  box-shadow: 0 18px 54px color-mix(in srgb, black 12%, transparent);
+}
+
+article table {
+  width: 100%;
+  overflow: hidden;
+  border: 1px solid var(--dbx-line);
+  border-radius: 9px;
+  border-collapse: separate;
+  border-spacing: 0;
+  background: var(--dbx-surface);
+  font-size: 0.925rem;
+}
+
+article thead {
+  background: var(--dbx-surface-soft);
+}
+
+article th {
+  color: color-mix(in srgb, var(--color-fd-foreground) 86%, var(--color-fd-muted-foreground));
+  font-weight: 680;
+}
+
+article th,
+article td {
+  border-bottom: 1px solid var(--dbx-line);
+  padding: 0.78rem 0.92rem;
+}
+
+article tr:last-child td {
+  border-bottom: 0;
+}
+
+article pre {
+  border: 1px solid color-mix(in srgb, var(--color-fd-border) 70%, transparent);
+  border-radius: 10px;
+  background: #0a0a0a !important;
+  margin: 1rem 0 1.35rem;
+  padding: 0.9rem 0;
+  overflow-x: auto;
+  box-shadow: 0 18px 42px color-mix(in srgb, black 14%, transparent);
+}
+
+article pre code {
+  display: block;
+  min-width: max-content;
+  border: 0;
+  background: transparent !important;
+  color: #e5e5e5;
+  font-size: 0.92rem;
+  line-height: 1.72;
+}
+
+article pre code span {
+  color: var(--shiki-dark, #e5e5e5) !important;
+  font-style: var(--shiki-dark-font-style, inherit);
+}
+
+article pre .line {
+  padding-left: 1.1rem;
+  padding-right: 1.1rem;
+}
+
+article figure.shiki {
+  border-color: color-mix(in srgb, var(--color-fd-border) 74%, transparent);
+  border-radius: 9px;
+  background: #0a0a0a !important;
+  margin: 0.85rem 0 1.05rem;
+  box-shadow: 0 12px 28px color-mix(in srgb, black 12%, transparent);
+}
+
+article figure.shiki [role="region"] {
+  padding-top: 0.7rem;
+  padding-bottom: 0.7rem;
+}
+
+article figure.shiki pre {
+  border: 0;
+  border-radius: 0;
+  background: transparent !important;
+  margin: 0;
+  padding: 0;
+  box-shadow: none;
+}
+
+article figure.shiki pre code {
+  line-height: 1.58;
+}
+
+article figure.shiki button:hover {
+  color: #e5e5e5;
+}
+
+article :not(pre) > code {
+  border: 1px solid var(--dbx-line);
+  border-radius: 6px;
+  padding: 0.12rem 0.34rem;
+  background: color-mix(in srgb, var(--color-fd-muted) 72%, transparent);
+  color: color-mix(in srgb, var(--color-fd-foreground) 88%, var(--dbx-blue));
+  font-size: 0.88em;
+}
+
+article a.block.rounded-xl,
+article a.flex.rounded-lg {
+  border-color: var(--dbx-line);
+  border-radius: 9px;
+  background: var(--dbx-surface);
+  box-shadow: 0 1px 2px color-mix(in srgb, black 4%, transparent);
+}
+
+article a.block.rounded-xl:hover,
+article a.flex.rounded-lg:hover {
+  border-color: color-mix(in srgb, var(--color-fd-primary) 28%, var(--dbx-line));
+  background: color-mix(in srgb, var(--color-fd-accent) 58%, var(--dbx-surface));
+  box-shadow: 0 10px 28px color-mix(in srgb, black 7%, transparent);
+}
+
+article [role="tablist"].not-prose {
+  border: 0;
+  border-bottom: 1px solid var(--dbx-line);
+  border-radius: 0;
+  background: transparent;
+  padding: 0 1rem;
+}
+
+article [role="tablist"].not-prose [role="tab"] {
+  border-radius: 0;
+  font-weight: 620;
+}
+
+article [role="tablist"].not-prose [role="tab"][data-state="active"] {
+  background: transparent;
+  box-shadow: none;
+}
+
+article [role="tabpanel"] {
+  border-color: var(--dbx-line);
+}
+
+article div[class*="border"] {
+  border-color: var(--dbx-line);
+}
+
+aside a[href*="/docs/"][class*="rounded-lg"][data-active="true"],
+aside a[href*="/docs/"][class*="rounded-lg"][aria-current="page"] {
+  background: color-mix(in srgb, var(--color-fd-primary) 5%, var(--color-fd-accent));
+  color: var(--color-fd-primary);
+  font-weight: 650;
+}
+
+.dbx-docs-sidebar-footer {
+  padding-top: 0.5rem;
+}
+
+#nd-sidebar .dbx-docs-sidebar-footer {
+  border-top: 1px solid var(--dbx-line);
+  margin-inline: -1rem;
+  padding: 0.8rem 1rem 0;
+}
+
+.dbx-docs-sidebar-tools {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.75rem;
+}
+
+.dbx-docs-sidebar-tools a,
+.dbx-docs-sidebar-tools button {
+  outline-offset: 2px;
+}
+
+.dbx-docs-theme-switch {
+  border-color: color-mix(in srgb, var(--color-fd-border) 82%, transparent);
+  background: color-mix(in srgb, var(--color-fd-secondary) 72%, transparent);
+  padding: 0.125rem;
+  box-shadow: 0 1px 2px color-mix(in srgb, black 5%, transparent);
+}
+
+.dbx-docs-theme-switch [class*="size-6.5"] {
+  width: 1.55rem;
+  height: 1.55rem;
+  padding: 0.33rem;
+}
+
+.dbx-docs-theme-switch [class*="bg-fd-accent"] {
+  background: var(--color-fd-popover);
+  box-shadow:
+    0 1px 2px color-mix(in srgb, black 8%, transparent),
+    0 0 0 1px color-mix(in srgb, var(--color-fd-border) 64%, transparent);
+}
+
+.dark .dbx-docs-theme-switch [class*="bg-fd-accent"] {
+  background: color-mix(in srgb, var(--color-fd-accent) 72%, var(--color-fd-popover));
+}
+
+button,
+a {
+  -webkit-tap-highlight-color: transparent;
+}
+
+.landing {
+  --landing-max: 1180px;
+  min-height: 100vh;
+  color: var(--color-landing-ink);
+  background: #0b1120;
+  overflow: hidden;
+  position: relative;
+}
+
+.landing::after {
+  content: "";
+  position: fixed;
+  inset: 0;
+  z-index: 0;
+  pointer-events: none;
+  opacity: 0.03;
+  background: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='300' height='300'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='0.75' numOctaves='4' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)'/%3E%3C/svg%3E");
+  mix-blend-mode: overlay;
+}
+
+.landing a {
+  text-decoration: none;
+}
+
+/* Reveal animation */
+
+.landing-reveal {
+  opacity: 1;
+  transform: none;
+  transition:
+    opacity 0.72s ease,
+    transform 0.72s cubic-bezier(0.16, 1, 0.3, 1);
+  transition-delay: var(--reveal-delay, 0ms);
+}
+
+.landing-reveal.is-visible {
+  opacity: 1;
+  transform: none;
+}
+
+.landing-reveal [data-stagger] {
+  opacity: 1;
+  transform: none;
+  transition:
+    opacity 0.58s ease,
+    transform 0.58s cubic-bezier(0.16, 1, 0.3, 1);
+}
+
+.landing-reveal.is-visible [data-stagger] {
+  opacity: 1;
+  transform: translateY(0);
+}
+
+.landing-reveal.is-visible [data-stagger]:nth-child(2) {
+  transition-delay: 70ms;
+}
+.landing-reveal.is-visible [data-stagger]:nth-child(3) {
+  transition-delay: 120ms;
+}
+.landing-reveal.is-visible [data-stagger]:nth-child(4) {
+  transition-delay: 170ms;
+}
+.landing-reveal.is-visible [data-stagger]:nth-child(8n + 5) {
+  transition-delay: 210ms;
+}
+.landing-reveal.is-visible [data-stagger]:nth-child(8n + 6) {
+  transition-delay: 250ms;
+}
+.landing-reveal.is-visible [data-stagger]:nth-child(8n + 7) {
+  transition-delay: 290ms;
+}
+.landing-reveal.is-visible [data-stagger]:nth-child(8n) {
+  transition-delay: 330ms;
+}
+
+/* Nav */
+
+.landing-nav {
+  position: fixed;
+  top: 0;
+  left: 0;
+  right: 0;
+  z-index: 80;
+  border-bottom: 1px solid transparent;
+  background: transparent;
+  transition:
+    background 0.3s ease,
+    border-color 0.3s ease;
+}
+
+.landing-nav::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  backdrop-filter: blur(18px);
+  opacity: 0;
+  transition: opacity 0.3s ease;
+  z-index: -1;
+}
+
+.landing-nav.is-scrolled {
+  border-bottom-color: var(--color-landing-line);
+  background: color-mix(in srgb, #0c1120 44%, transparent);
+}
+
+.landing-nav.is-scrolled::before {
+  opacity: 1;
+}
+
+.landing-nav-link {
+  transition:
+    background 0.16s ease,
+    color 0.16s ease,
+    transform 0.16s ease;
+}
+
+.landing-nav-link:hover {
+  background: var(--color-landing-soft);
+  color: var(--color-landing-ink);
+  transform: translateY(-1px);
+}
+
+/* Hero */
+
+.landing-hero {
+  position: relative;
+  min-height: calc(100vh - 64px);
+  padding-top: 148px;
+  overflow: hidden;
+  isolation: isolate;
+}
+
+.landing-hero::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background:
+    radial-gradient(ellipse at 50% 34%, rgba(44, 88, 174, 0.48), transparent 52%), radial-gradient(ellipse at 18% 16%, rgba(82, 213, 255, 0.13), transparent 34%), radial-gradient(ellipse at 76% 22%, rgba(68, 209, 157, 0.1), transparent 30%),
+    linear-gradient(180deg, #0b1120 0%, #0c1528 48%, #0b1120 82%, #0b1120 100%);
+  z-index: -3;
+}
+
+.landing-hero::after {
+  content: "";
+  position: absolute;
+  inset: 134px -12vw -140px;
+  background-image: linear-gradient(rgba(110, 168, 255, 0.08) 1px, transparent 1px), linear-gradient(90deg, rgba(110, 168, 255, 0.08) 1px, transparent 1px);
+  background-size: 58px 58px;
+  mask-image: radial-gradient(ellipse at 50% 56%, black 0%, transparent 64%);
+  opacity: 0.5;
+  pointer-events: none;
+  transform: perspective(1200px) rotateX(60deg) translateY(84px);
+  transform-origin: center bottom;
+  animation: landing-grid-drift 15s linear infinite;
+  z-index: -2;
+}
+
+.aceternity-spotlight {
+  position: absolute;
+  inset: -210px auto auto 50%;
+  width: min(980px, 82vw);
+  height: 720px;
+  border-radius: 999px;
+  background: radial-gradient(circle at 50% 28%, rgba(255, 255, 255, 0.16), transparent 12%), radial-gradient(circle at 46% 38%, rgba(82, 213, 255, 0.2), transparent 34%), radial-gradient(circle at 58% 52%, rgba(110, 168, 255, 0.16), transparent 60%);
+  filter: blur(52px);
+  mix-blend-mode: screen;
+  pointer-events: none;
+  transform: translateX(-50%);
+  z-index: -1;
+}
+
+.landing-hero-copy {
+  animation: landing-rise 0.72s ease-out both;
+}
+
+.landing-hero-subtitle {
+  color: color-mix(in srgb, var(--color-landing-muted) 86%, white);
+}
+
+.landing-eyebrow {
+  border: 1px solid var(--color-landing-line);
+  background: rgba(255, 255, 255, 0.04);
+  color: color-mix(in srgb, var(--color-landing-sky) 74%, white);
+  box-shadow:
+    0 0 0 1px rgba(82, 213, 255, 0.04) inset,
+    0 0 28px rgba(82, 213, 255, 0.13);
+  animation: landing-pulse 3.8s ease-in-out infinite;
+}
+
+/* Buttons */
+
+.landing-btn-primary {
+  background: #f7fbff;
+  color: #090d13;
+  box-shadow:
+    0 14px 36px rgba(110, 168, 255, 0.18),
+    0 0 0 1px rgba(255, 255, 255, 0.4) inset;
+  transition:
+    opacity 0.16s ease,
+    transform 0.16s ease,
+    box-shadow 0.16s ease;
+  animation: landing-cta-glow 3.4s ease-in-out infinite;
+}
+
+.landing-btn-primary:hover {
+  opacity: 0.88;
+  transform: translateY(-1px);
+  box-shadow: 0 18px 42px rgba(110, 168, 255, 0.25);
+}
+
+.landing-btn-secondary {
+  border: 1px solid var(--color-landing-line);
+  background: var(--color-landing-panel);
+  color: var(--color-landing-ink);
+  transition:
+    border-color 0.16s ease,
+    background 0.16s ease,
+    transform 0.16s ease;
+}
+
+.landing-btn-secondary:hover {
+  border-color: rgba(178, 200, 230, 0.34);
+  background: var(--color-landing-panel-strong);
+  transform: translateY(-1px);
+}
+
+/* Install dropdown */
+
+.landing-install::after {
+  content: "";
+  position: absolute;
+  top: 100%;
+  left: 0;
+  display: block;
+  width: 100%;
+  height: 24px;
+}
+
+.landing-install-trigger {
+  background: linear-gradient(180deg, rgba(255, 255, 255, 0.98), rgba(239, 244, 250, 0.96)), #fff;
+  color: #070b12;
+  box-shadow:
+    0 18px 54px rgba(0, 0, 0, 0.24),
+    0 0 0 1px rgba(255, 255, 255, 0.72) inset;
+  transition: box-shadow 0.16s ease;
+}
+
+.landing-install-trigger:hover,
+.landing-install[data-open="true"] .landing-install-trigger {
+  box-shadow:
+    0 24px 68px rgba(0, 0, 0, 0.3),
+    0 0 0 1px rgba(255, 255, 255, 0.78) inset;
+}
+
+.landing-install-trigger > svg:first-child {
+  fill: currentColor;
+  stroke-width: 0;
+}
+
+.landing-install-trigger > svg:last-child {
+  color: #5f6876;
+  transition: transform 0.16s ease;
+}
+
+.landing-install[data-open="true"] .landing-install-trigger > svg:last-child {
+  transform: rotate(180deg);
+}
+
+.landing-install-menu {
+  background: rgba(4, 5, 8, 0.94);
+  box-shadow:
+    0 26px 64px rgba(0, 0, 0, 0.34),
+    0 0 0 1px rgba(255, 255, 255, 0.035) inset;
+  backdrop-filter: blur(18px);
+  opacity: 0;
+  pointer-events: none;
+  transition:
+    opacity 0.16s ease,
+    transform 0.16s ease,
+    visibility 0.16s ease;
+  visibility: hidden;
+}
+
+.landing-install:hover .landing-install-menu,
+.landing-install[data-open="true"] .landing-install-menu {
+  opacity: 1;
+  pointer-events: auto;
+  visibility: visible;
+}
+
+.landing-install-option {
+  color: color-mix(in srgb, var(--color-landing-ink) 88%, var(--color-landing-muted));
+  transition:
+    background 0.16s ease,
+    color 0.16s ease;
+}
+
+.landing-install-option:hover {
+  background: rgba(255, 255, 255, 0.055);
+  color: var(--color-landing-ink);
+}
+
+.landing-install-option svg {
+  fill: currentColor;
+  stroke-width: 1.8;
+}
+
+/* Product showcase */
+
+.landing-product {
+  border: 1px solid var(--color-landing-line);
+  background: #0d1117;
+  box-shadow:
+    0 38px 110px rgba(0, 0, 0, 0.5),
+    0 0 80px rgba(82, 213, 255, 0.1),
+    0 0 0 1px rgba(255, 255, 255, 0.03) inset;
+  transform-style: preserve-3d;
+  transition:
+    box-shadow 0.24s ease,
+    transform 0.24s ease;
+}
+
+.landing-product::before {
+  content: "";
+  position: absolute;
+  inset: 0;
+  border-radius: inherit;
+  padding: 1px;
+  background: conic-gradient(from 180deg, transparent, rgba(110, 168, 255, 0.04), rgba(82, 213, 255, 0.28), rgba(68, 209, 157, 0.18), rgba(110, 168, 255, 0.04), transparent);
+  -webkit-mask:
+    linear-gradient(#000 0 0) content-box,
+    linear-gradient(#000 0 0);
+  -webkit-mask-composite: xor;
+  mask-composite: exclude;
+  pointer-events: none;
+  z-index: 4;
+}
+
+.landing-product::after {
+  content: "";
+  position: absolute;
+  inset: 34px 0 0;
+  background: radial-gradient(circle at 72% 18%, rgba(82, 213, 255, 0.1), transparent 18%);
+  mix-blend-mode: screen;
+  pointer-events: none;
+  z-index: 3;
+}
+
+.landing-product:hover {
+  transform: translateY(-4px) scale(1.005);
+  box-shadow:
+    0 46px 122px rgba(0, 0, 0, 0.58),
+    0 0 100px rgba(82, 213, 255, 0.13);
+}
+
+.landing-product-slide {
+  opacity: 0;
+  transition: opacity 0.45s ease;
+}
+
+.landing-product-slide[data-active="true"] {
+  opacity: 1;
+}
+
+.landing-product-dots {
+  border: 1px solid rgba(155, 176, 205, 0.16);
+  background: rgba(5, 8, 13, 0.66);
+  backdrop-filter: blur(16px);
+}
+
+.landing-product-dots button {
+  background: rgba(226, 232, 240, 0.38);
+  color: transparent;
+  transition:
+    width 0.2s ease,
+    background 0.2s ease,
+    opacity 0.2s ease;
+}
+
+.landing-product-dots button[aria-current="true"] {
+  width: 28px;
+  background: color-mix(in srgb, var(--color-landing-sky) 84%, white);
+}
+
+.landing-product-dots span {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  overflow: hidden;
+  clip: rect(0 0 0 0);
+  white-space: nowrap;
+}
+
+/* Glass cards */
+
+.landing-glass-card {
+  border: 1px solid rgba(155, 176, 205, 0.14);
+  background: radial-gradient(circle at 78% 12%, rgba(110, 168, 255, 0.12), transparent 44%), linear-gradient(180deg, rgba(255, 255, 255, 0.045), rgba(255, 255, 255, 0.018)), rgba(12, 15, 22, 0.72);
+  box-shadow:
+    0 18px 44px rgba(0, 0, 0, 0.14),
+    0 0 0 1px rgba(255, 255, 255, 0.02) inset;
+}
+
+.landing-glass-card-green {
+  border: 1px solid rgba(155, 176, 205, 0.14);
+  background: radial-gradient(circle at 78% 16%, rgba(68, 209, 157, 0.1), transparent 34%), linear-gradient(180deg, rgba(255, 255, 255, 0.045), rgba(255, 255, 255, 0.018)), rgba(12, 15, 22, 0.72);
+  box-shadow:
+    0 18px 44px rgba(0, 0, 0, 0.14),
+    0 0 0 1px rgba(255, 255, 255, 0.02) inset;
+}
+
+/* Inline link */
+
+.landing-inline-link {
+  color: var(--color-landing-blue);
+  transition:
+    color 0.16s ease,
+    transform 0.16s ease;
+}
+
+.landing-inline-link:hover {
+  color: color-mix(in srgb, var(--color-landing-sky) 70%, white);
+  transform: translateX(2px);
+}
+
+/* Workflow card */
+
+.landing-workflow-grid {
+  border: 1px solid var(--color-landing-line);
+  background: var(--color-landing-panel);
+}
+
+.landing-workflow-card {
+  color: var(--color-landing-ink);
+  transition:
+    border-color 0.16s ease,
+    background 0.16s ease,
+    transform 0.16s ease,
+    box-shadow 0.16s ease;
+}
+
+.landing-workflow-card:hover {
+  background: var(--color-landing-panel-strong);
+  border-color: rgba(110, 168, 255, 0.24);
+  transform: translateY(-3px);
+  box-shadow: 0 24px 50px rgba(0, 0, 0, 0.18);
+}
+
+/* Update version badge */
+
+.landing-update-version {
+  border: 1px solid var(--color-landing-line);
+  background: var(--color-landing-panel);
+  color: var(--color-landing-blue);
+}
+
+/* DB card */
+
+.landing-db-card {
+  border: 1px solid rgba(155, 176, 205, 0.14);
+  background: radial-gradient(circle at 50% 112%, color-mix(in srgb, var(--db-tone) 20%, transparent), transparent 62%), linear-gradient(180deg, rgba(255, 255, 255, 0.045), rgba(255, 255, 255, 0.018)), rgba(12, 15, 22, 0.74);
+  box-shadow:
+    0 18px 44px rgba(0, 0, 0, 0.15),
+    0 0 0 1px rgba(255, 255, 255, 0.02) inset;
+  transition:
+    border-color 0.16s ease,
+    background 0.16s ease,
+    transform 0.16s ease;
+}
+
+.landing-db-card:hover {
+  border-color: color-mix(in srgb, var(--db-tone) 42%, rgba(155, 176, 205, 0.18));
+  background: radial-gradient(circle at 50% 112%, color-mix(in srgb, var(--db-tone) 26%, transparent), transparent 62%), linear-gradient(180deg, rgba(255, 255, 255, 0.06), rgba(255, 255, 255, 0.024)), rgba(14, 18, 27, 0.9);
+  transform: translateY(-3px);
+}
+
+.landing-db-icon img {
+  filter: drop-shadow(0 10px 20px color-mix(in srgb, var(--db-tone) 20%, transparent));
+}
+
+.landing-db-icon span {
+  background: color-mix(in srgb, var(--db-tone) 78%, #10151d);
+  box-shadow: 0 10px 20px color-mix(in srgb, var(--db-tone) 22%, transparent);
+}
+
+/* Testimonials */
+
+.landing-testimonial-wall::before,
+.landing-testimonial-wall::after {
+  content: "";
+  position: absolute;
+  top: 0;
+  bottom: 0;
+  z-index: 2;
+  width: min(180px, 18vw);
+  pointer-events: none;
+}
+
+.landing-testimonial-wall::before {
+  left: 0;
+  background: linear-gradient(90deg, #10151d, rgba(16, 21, 29, 0));
+}
+
+.landing-testimonial-wall::after {
+  right: 0;
+  background: linear-gradient(270deg, #10151d, rgba(16, 21, 29, 0));
+}
+
+.landing-testimonial-marquee[data-speed="slow"] {
+  --testimonial-duration: 58s;
+}
+
+.landing-testimonial-marquee[data-speed="normal"] {
+  --testimonial-duration: 42s;
+}
+
+.landing-testimonial-track {
+  animation: landing-testimonial-scroll var(--testimonial-duration, 48s) linear infinite;
+  animation-play-state: running !important;
+}
+
+.landing-testimonial-marquee[data-direction="right"] .landing-testimonial-track {
+  animation-direction: reverse;
+}
+
+.landing-testimonial-card {
+  border: 1px solid rgba(155, 176, 205, 0.14);
+  background: linear-gradient(180deg, rgba(255, 255, 255, 0.055), rgba(255, 255, 255, 0.025)), rgba(13, 18, 26, 0.78);
+  box-shadow:
+    0 18px 45px rgba(0, 0, 0, 0.18),
+    0 0 0 1px rgba(255, 255, 255, 0.025) inset;
+}
+
+/* Contributors wall */
+
+.landing-contributor-grid {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  justify-content: center;
+  margin-top: 3px;
+}
+
+.landing-contributor-avatar {
+  display: block;
+  position: relative;
+  width: 58px;
+  height: 58px;
+  border-radius: 50%;
+  border: 1.5px solid rgba(155, 176, 205, 0.16);
+  background: linear-gradient(180deg, rgba(255, 255, 255, 0.06), rgba(255, 255, 255, 0.02)), rgba(12, 15, 22, 0.78);
+  box-shadow:
+    0 8px 24px rgba(0, 0, 0, 0.18),
+    0 0 0 1px rgba(255, 255, 255, 0.03) inset;
+  transition:
+    border-color 0.2s ease,
+    transform 0.2s cubic-bezier(0.16, 1, 0.3, 1),
+    box-shadow 0.2s ease;
+}
+
+.landing-contributor-avatar:hover {
+  border-color: rgba(110, 168, 255, 0.42);
+  transform: translateY(-3px) scale(1.08);
+  box-shadow:
+    0 14px 36px rgba(110, 168, 255, 0.22),
+    0 0 0 1px rgba(255, 255, 255, 0.06) inset;
+  z-index: 2;
+  overflow: visible;
+}
+
+.landing-contributor-avatar img {
+  border-radius: 50%;
+}
+
+.landing-contributor-tooltip {
+  position: absolute;
+  bottom: calc(100% + 8px);
+  left: 50%;
+  transform: translateX(-50%) translateY(4px);
+  pointer-events: none;
+  white-space: nowrap;
+  padding: 6px 12px;
+  border-radius: 6px;
+  background: rgba(18, 22, 32, 0.96);
+  border: 1px solid rgba(155, 176, 205, 0.22);
+  box-shadow:
+    0 8px 24px rgba(0, 0, 0, 0.32),
+    0 0 0 1px rgba(255, 255, 255, 0.04) inset;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 2px;
+  opacity: 0;
+  transition:
+    opacity 0.18s ease,
+    transform 0.18s ease;
+}
+
+.landing-contributor-tooltip.is-visible {
+  opacity: 1;
+  transform: translateX(-50%) translateY(0);
+}
+
+.landing-contributor-tooltip-name {
+  font-size: 13px;
+  font-weight: 650;
+  color: var(--color-landing-ink);
+}
+
+.landing-contributor-tooltip-count {
+  font-size: 11px;
+  color: var(--color-landing-muted);
+}
+
+/* Capability card */
+
+.landing-capability {
+  border: 1px solid var(--color-landing-line);
+  background: var(--color-landing-panel);
+  transition:
+    border-color 0.16s ease,
+    background 0.16s ease,
+    transform 0.16s ease;
+}
+
+.landing-capability:hover {
+  border-color: rgba(110, 168, 255, 0.24);
+  background: var(--color-landing-panel-strong);
+  transform: translateY(-2px);
+}
+
+/* Final CTA link */
+
+.landing-final-link {
+  border: 1px solid var(--color-landing-line);
+  background: var(--color-landing-panel);
+  color: var(--color-landing-ink);
+  transition:
+    border-color 0.16s ease,
+    background 0.16s ease,
+    transform 0.16s ease;
+}
+
+.landing-final-link:hover {
+  border-color: rgba(178, 200, 230, 0.34);
+  background: var(--color-landing-panel-strong);
+  transform: translateY(-1px);
+}
+
+/* Responsive */
+
+@media (max-width: 1040px) {
+  .landing-hero {
+    padding-top: 120px;
+  }
+
+  .landing-workflow-card:nth-child(2n) {
+    border-right: 0;
+  }
+
+  .landing-workflow-card:nth-child(-n + 2) {
+    border-bottom: 1px solid var(--color-landing-line);
+  }
+}
+
+@media (max-width: 760px) {
+  .landing-hero {
+    padding-top: 104px;
+    min-height: 0;
+  }
+
+  .landing-hero::before {
+    right: 0;
+    background: radial-gradient(circle at 50% 18%, rgba(82, 213, 255, 0.18), transparent 280px), radial-gradient(circle at 76% 26%, rgba(68, 209, 157, 0.08), transparent 220px), linear-gradient(180deg, #10151d 0%, #0c1528 44%, #10151d 94%);
+  }
+
+  .landing-hero::after {
+    inset: 130px -90px 0;
+    opacity: 0.3;
+  }
+
+  .aceternity-spotlight {
+    inset: -18% auto auto 50%;
+    width: 96vw;
+  }
+
+  .landing-product-dots {
+    right: 12px;
+    bottom: 11px;
+  }
+
+  .landing-workflow-card {
+    border-right: 0;
+    border-bottom: 1px solid var(--color-landing-line);
+  }
+
+  .landing-workflow-card:last-child {
+    border-bottom: 0;
+  }
+
+  .landing-testimonial-wall {
+    margin-right: -18px;
+    margin-left: -18px;
+  }
+
+  .landing-testimonial-wall::before,
+  .landing-testimonial-wall::after {
+    width: 46px;
+  }
+
+  .landing-contributor-grid {
+    gap: 8px;
+  }
+
+  .landing-contributor-avatar {
+    width: 46px;
+    height: 46px;
+  }
+}
+
+/* Keyframes */
+
+@keyframes landing-rise {
+  from {
+    opacity: 0;
+    transform: translateY(18px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes landing-grid-drift {
+  from {
+    background-position: 0 0;
+  }
+  to {
+    background-position: 54px 54px;
+  }
+}
+
+@keyframes landing-pulse {
+  0%,
+  100% {
+    border-color: rgba(155, 176, 205, 0.18);
+    box-shadow:
+      0 0 0 1px rgba(82, 213, 255, 0.04) inset,
+      0 0 28px rgba(82, 213, 255, 0.13);
+  }
+  50% {
+    border-color: rgba(82, 213, 255, 0.34);
+    box-shadow:
+      0 0 0 1px rgba(82, 213, 255, 0.12) inset,
+      0 0 42px rgba(82, 213, 255, 0.22);
+  }
+}
+
+@keyframes landing-cta-glow {
+  0%,
+  100% {
+    box-shadow:
+      0 14px 36px rgba(110, 168, 255, 0.18),
+      0 0 0 1px rgba(255, 255, 255, 0.4) inset;
+  }
+  50% {
+    box-shadow:
+      0 18px 48px rgba(82, 213, 255, 0.32),
+      0 0 0 1px rgba(255, 255, 255, 0.52) inset;
+  }
+}
+
+@keyframes landing-testimonial-scroll {
+  from {
+    transform: translateX(0);
+  }
+  to {
+    transform: translateX(calc(-50% - 7px));
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .landing *,
+  .landing *::before,
+  .landing *::after {
+    animation-duration: 0.01ms !important;
+    animation-iteration-count: 1 !important;
+    scroll-behavior: auto !important;
+    transition-duration: 0.01ms !important;
+  }
+
+  .landing-reveal,
+  .landing-reveal [data-stagger] {
+    opacity: 1 !important;
+    transform: none !important;
+  }
+}
diff --git a/docs/app/layout.tsx b/docs/app/layout.tsx
new file mode 100644
index 0000000..c82f6d8
--- /dev/null
+++ b/docs/app/layout.tsx
@@ -0,0 +1,106 @@
+import "./global.css";
+import type { ReactNode } from "react";
+import type { Metadata } from "next";
+import { SITE_URL, SITE_NAME, DEFAULT_DESCRIPTION, DEFAULT_OG_IMAGE } from "@/lib/metadata";
+
+export const metadata: Metadata = {
+  title: {
+    default: SITE_NAME,
+    template: `%s | ${SITE_NAME}`,
+  },
+  description: DEFAULT_DESCRIPTION,
+  metadataBase: new URL(SITE_URL),
+  icons: {
+    icon: "/favicon.png",
+    shortcut: "/favicon.png",
+    apple: "/logo.png",
+  },
+  openGraph: {
+    siteName: SITE_NAME,
+    images: [{ url: DEFAULT_OG_IMAGE }],
+  },
+  twitter: {
+    card: "summary_large_image",
+  },
+};
+
+const WEBSITE_SCHEMA = {
+  "@context": "https://schema.org",
+  "@type": "WebSite",
+  name: SITE_NAME,
+  url: SITE_URL,
+  description: DEFAULT_DESCRIPTION,
+  potentialAction: {
+    "@type": "SearchAction",
+    target: {
+      "@type": "EntryPoint",
+      urlTemplate: `${SITE_URL}/search?q={search_term_string}`,
+    },
+    "query-input": "required name=search_term_string",
+  },
+} as const;
+
+const SOFTWARE_APP_SCHEMA = {
+  "@context": "https://schema.org",
+  "@type": "SoftwareApplication",
+  name: SITE_NAME,
+  url: SITE_URL,
+  description: DEFAULT_DESCRIPTION,
+  applicationCategory: "Database Management",
+  operatingSystem: ["Windows", "macOS", "Linux", "Docker"],
+  offers: {
+    "@type": "Offer",
+    price: "0",
+    priceCurrency: "USD",
+  },
+  author: {
+    "@type": "Organization",
+    name: SITE_NAME,
+    url: SITE_URL,
+  },
+  releaseNotes: `${SITE_URL}/en/changelog`,
+  screenshot: `${SITE_URL}/screenshot-dark.png`,
+  featureList: [
+    "60+ database engines (MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, ClickHouse, SQL Server, Oracle, and many more)",
+    "AI-powered SQL generation and explanation",
+    "MCP Server integration for AI coding agents",
+    "Schema browser and diff tools",
+    "Data grid with inline editing",
+    "SSH tunnel support",
+    "Docker self-hosting",
+  ],
+} as const;
+
+const ORG_SCHEMA = {
+  "@context": "https://schema.org",
+  "@type": "Organization",
+  name: SITE_NAME,
+  url: SITE_URL,
+  description: DEFAULT_DESCRIPTION,
+  sameAs: [
+    "https://github.com/t8y2/dbx",
+    "https://www.npmjs.com/package/@dbx-app/mcp-server",
+  ],
+} as const;
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html suppressHydrationWarning>
+      <head>
+        <script
+          type="application/ld+json"
+          dangerouslySetInnerHTML={{ __html: JSON.stringify(WEBSITE_SCHEMA) }}
+        />
+        <script
+          type="application/ld+json"
+          dangerouslySetInnerHTML={{ __html: JSON.stringify(SOFTWARE_APP_SCHEMA) }}
+        />
+        <script
+          type="application/ld+json"
+          dangerouslySetInnerHTML={{ __html: JSON.stringify(ORG_SCHEMA) }}
+        />
+      </head>
+      <body className="flex min-h-screen flex-col">{children}</body>
+    </html>
+  );
+}
diff --git a/docs/app/page.tsx b/docs/app/page.tsx
new file mode 100644
index 0000000..b6ec597
--- /dev/null
+++ b/docs/app/page.tsx
@@ -0,0 +1,5 @@
+import { redirect } from "next/navigation";
+
+export default function Page() {
+  redirect("/cn");
+}
diff --git a/docs/assets/pr-2182-sidebar-user-admin-only.png b/docs/assets/pr-2182-sidebar-user-admin-only.png
new file mode 100644
index 0000000..27ad5a9
Binary files /dev/null and b/docs/assets/pr-2182-sidebar-user-admin-only.png differ
diff --git a/docs/components/DocsSidebarFooter.tsx b/docs/components/DocsSidebarFooter.tsx
new file mode 100644
index 0000000..94cdd16
--- /dev/null
+++ b/docs/components/DocsSidebarFooter.tsx
@@ -0,0 +1,78 @@
+"use client";
+
+import { Languages } from "lucide-react";
+import { LanguageSelect } from "fumadocs-ui/layouts/shared/slots/language-select";
+import { ThemeSwitch } from "fumadocs-ui/layouts/shared/slots/theme-switch";
+
+const iconButton = "inline-flex size-8 items-center justify-center rounded-md text-fd-muted-foreground transition-colors hover:bg-fd-accent hover:text-fd-accent-foreground";
+
+function GithubIcon() {
+  return (
+    <svg role="img" viewBox="0 0 24 24" fill="currentColor" className="size-4.5">
+      <path d="M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12" />
+    </svg>
+  );
+}
+
+function DiscordIcon() {
+  return (
+    <svg viewBox="0 0 24 24" fill="currentColor" className="size-4.5">
+      <path d="M20.317 4.37a19.791 19.791 0 0 0-4.885-1.515.074.074 0 0 0-.079.037c-.21.375-.444.864-.608 1.25a18.27 18.27 0 0 0-5.487 0 12.64 12.64 0 0 0-.617-1.25.077.077 0 0 0-.079-.037A19.736 19.736 0 0 0 3.677 4.37a.07.07 0 0 0-.032.027C.533 9.046-.32 13.58.099 18.057a.082.082 0 0 0 .031.057 19.9 19.9 0 0 0 5.993 3.03.078.078 0 0 0 .084-.028c.462-.63.874-1.295 1.226-1.994a.076.076 0 0 0-.041-.106 13.107 13.107 0 0 1-1.872-.892.077.077 0 0 1-.008-.128 10.2 10.2 0 0 0 .372-.292.074.074 0 0 1 .077-.01c3.928 1.793 8.18 1.793 12.062 0a.074.074 0 0 1 .078.01c.12.098.246.198.373.292a.077.077 0 0 1-.006.127 12.299 12.299 0 0 1-1.873.892.077.077 0 0 0-.041.107c.36.698.772 1.362 1.225 1.993a.076.076 0 0 0 .084.028 19.839 19.839 0 0 0 6.002-3.03.077.077 0 0 0 .032-.054c.5-5.177-.838-9.674-3.549-13.66a.061.061 0 0 0-.031-.03zM8.02 15.33c-1.183 0-2.157-1.085-2.157-2.419 0-1.333.956-2.419 2.157-2.419 1.21 0 2.176 1.096 2.157 2.42 0 1.333-.956 2.418-2.157 2.418zm7.975 0c-1.183 0-2.157-1.085-2.157-2.419 0-1.333.955-2.419 2.157-2.419 1.21 0 2.176 1.096 2.157 2.42 0 1.333-.946 2.418-2.157 2.418z" />
+    </svg>
+  );
+}
+
+function QQIcon() {
+  return (
+    <svg viewBox="0 0 120 145" fill="currentColor" className="size-4.5">
+      <path d="M60.503 142.237c-12.533 0-24.038-4.195-31.445-10.46-3.762 1.124-8.574 2.932-11.61 5.175-2.6 1.918-2.275 3.874-1.807 4.663 2.056 3.47 35.273 2.216 44.862 1.136zm0 0c12.535 0 24.039-4.195 31.447-10.46 3.76 1.124 8.573 2.932 11.61 5.175 2.598 1.918 2.274 3.874 1.805 4.663-2.056 3.47-35.272 2.216-44.862 1.136zm0 0" />
+      <path d="M60.576 67.119c20.698-.14 37.286-4.147 42.907-5.683 1.34-.367 2.056-1.024 2.056-1.024.005-.189.085-3.37.085-5.01C105.624 27.768 92.58.001 60.5 0 28.42.001 15.375 27.769 15.375 55.401c0 1.642.08 4.822.086 5.01 0 0 .583.615 1.65.913 5.19 1.444 22.09 5.65 43.312 5.795zm56.245 23.02c-1.283-4.129-3.034-8.944-4.808-13.568 0 0-1.02-.126-1.537.023-15.913 4.623-35.202 7.57-49.9 7.392h-.153c-14.616.175-33.774-2.737-49.634-7.315-.606-.175-1.802-.1-1.802-.1-1.774 4.624-3.525 9.44-4.808 13.568-6.119 19.69-4.136 27.838-2.627 28.02 3.239.392 12.606-14.821 12.606-14.821 0 15.459 13.957 39.195 45.918 39.413h.848c31.96-.218 45.917-23.954 45.917-39.413 0 0 9.368 15.213 12.607 14.822 1.508-.183 3.491-8.332-2.627-28.021" />
+      <path
+        fill="#fff"
+        d="M49.085 40.824c-4.352.197-8.07-4.76-8.304-11.063-.236-6.305 3.098-11.576 7.45-11.773 4.347-.195 8.064 4.76 8.3 11.065.238 6.306-3.097 11.577-7.446 11.771m31.133-11.063c-.233 6.302-3.951 11.26-8.303 11.063-4.35-.195-7.684-5.465-7.446-11.77.236-6.305 3.952-11.26 8.3-11.066 4.352.197 7.686 5.468 7.449 11.773"
+      />
+    </svg>
+  );
+}
+
+function WeChatIcon() {
+  return (
+    <svg viewBox="1.5 3 21 17" fill="currentColor" className="size-4.5">
+      <path d="M9.5 4C5.36 4 2 6.69 2 10c0 1.89 1.08 3.56 2.78 4.66l-.7 2.1 2.46-1.23c.87.27 1.8.42 2.78.42.24 0 .48-.01.71-.03A5.93 5.93 0 0 1 10 14c0-3.31 3.13-6 7-6 .34 0 .67.03 1 .07C17.27 5.56 13.72 4 9.5 4zm-3 4.5a1 1 0 1 1 0-2 1 1 0 0 1 0 2zm5 0a1 1 0 1 1 0-2 1 1 0 0 1 0 2zM22 14c0-2.76-2.69-5-6-5s-6 2.24-6 5 2.69 5 6 5c.73 0 1.43-.11 2.09-.3l1.72.86-.49-1.46C20.94 17.07 22 15.64 22 14zm-7.5-.5a.75.75 0 1 1 0-1.5.75.75 0 0 1 0 1.5zm4 0a.75.75 0 1 1 0-1.5.75.75 0 0 1 0 1.5z" />
+    </svg>
+  );
+}
+
+export function DocsSidebarLanguageButton() {
+  return (
+    <div className="flex justify-end pe-1">
+      <LanguageSelect className={iconButton} variant="ghost">
+        <Languages className="size-4.5" />
+      </LanguageSelect>
+    </div>
+  );
+}
+
+export function DocsSidebarFooter() {
+  return (
+    <div className="dbx-docs-sidebar-footer">
+      <div className="dbx-docs-sidebar-tools">
+        <div className="flex items-center gap-1">
+          <a className={iconButton} href="https://github.com/t8y2/dbx" target="_blank" rel="noreferrer" aria-label="GitHub">
+            <GithubIcon />
+          </a>
+          <a className={iconButton} href="https://discord.gg/W7NyVDRt6a" target="_blank" rel="noreferrer" aria-label="Discord">
+            <DiscordIcon />
+          </a>
+          <a className={iconButton} href="https://qm.qq.com/cgi-bin/qm/qr?k=&group_code=1087880322" target="_blank" rel="noreferrer" aria-label="QQ">
+            <QQIcon />
+          </a>
+          <a className={iconButton} href="https://docs.qq.com/doc/DVVhMY0h1ekJqc0tz" target="_blank" rel="noreferrer" aria-label="WeChat">
+            <WeChatIcon />
+          </a>
+        </div>
+        <ThemeSwitch mode="light-dark" className="dbx-docs-theme-switch" />
+      </div>
+    </div>
+  );
+}
diff --git a/docs/components/StaticSearchDialog.tsx b/docs/components/StaticSearchDialog.tsx
new file mode 100644
index 0000000..307f9e7
--- /dev/null
+++ b/docs/components/StaticSearchDialog.tsx
@@ -0,0 +1,51 @@
+"use client";
+
+import { create } from "@orama/orama";
+import { useDocsSearch } from "fumadocs-core/search/client";
+import { SearchDialog, SearchDialogClose, SearchDialogContent, SearchDialogFooter, SearchDialogHeader, SearchDialogIcon, SearchDialogInput, SearchDialogList, SearchDialogOverlay } from "fumadocs-ui/components/dialog/search";
+import type { SharedProps } from "fumadocs-ui/contexts/search";
+import { useI18n } from "fumadocs-ui/contexts/i18n";
+import { useMemo, useState } from "react";
+import { createCjkSearchTokenizer } from "@/lib/cjkSearchTokenizer";
+
+export function StaticSearchDialog(props: SharedProps) {
+  const { locale } = useI18n();
+  const [tag] = useState<string | undefined>();
+  const api = `/${locale ?? "en"}/api/search`;
+  const { search, setSearch, query } = useDocsSearch({
+    type: "static",
+    from: api,
+    locale,
+    tag,
+    delayMs: 100,
+    initOrama: (dbLocale) => {
+      if (dbLocale === "cn") {
+        return create({
+          schema: { _: "string" },
+          components: { tokenizer: createCjkSearchTokenizer() },
+        });
+      }
+
+      return create({
+        schema: { _: "string" },
+        language: "english",
+      });
+    },
+  });
+  const defaultItems = useMemo(() => null, []);
+
+  return (
+    <SearchDialog search={search} onSearchChange={setSearch} isLoading={query.isLoading} {...props}>
+      <SearchDialogOverlay />
+      <SearchDialogContent>
+        <SearchDialogHeader>
+          <SearchDialogIcon />
+          <SearchDialogInput />
+          <SearchDialogClose />
+        </SearchDialogHeader>
+        <SearchDialogList items={query.data !== "empty" ? query.data : defaultItems} />
+      </SearchDialogContent>
+      <SearchDialogFooter />
+    </SearchDialog>
+  );
+}
diff --git a/docs/components/aceternity/HeroProductStage.tsx b/docs/components/aceternity/HeroProductStage.tsx
new file mode 100644
index 0000000..a1d50d7
--- /dev/null
+++ b/docs/components/aceternity/HeroProductStage.tsx
@@ -0,0 +1,61 @@
+"use client";
+
+import { motion } from "motion/react";
+import { useEffect, useState } from "react";
+
+const productSlides = [
+  {
+    src: "/screenshot-light.png",
+    alt: "DBX main window light theme",
+    label: "Light",
+  },
+  {
+    src: "/screenshot-dark.png",
+    alt: "DBX main window dark theme",
+    label: "Dark",
+  },
+  {
+    src: "/screenshot-er.png",
+    alt: "DBX ER diagram",
+    label: "ER Diagram",
+  },
+  {
+    src: "/screenshot-grid.png",
+    alt: "DBX data grid",
+    label: "Data Grid",
+  },
+];
+
+export function HeroProductStage() {
+  const [activeSlide, setActiveSlide] = useState(0);
+
+  useEffect(() => {
+    const timer = window.setInterval(() => {
+      setActiveSlide((current) => (current + 1) % productSlides.length);
+    }, 4200);
+
+    return () => window.clearInterval(timer);
+  }, []);
+
+  return (
+    <motion.div
+      className="landing-product relative w-full mt-16 mb-12 overflow-hidden rounded-2xl max-[1040px]:max-w-[900px] max-[1040px]:mt-14 max-[760px]:mt-10 max-[760px]:mb-7 max-[760px]:rounded-xl"
+      initial={{ opacity: 0, y: 36, scale: 0.985 }}
+      animate={{ opacity: 1, y: 0, scale: 1 }}
+      transition={{ duration: 0.9, delay: 0.18, ease: [0.16, 1, 0.3, 1] }}
+    >
+      <div className="relative aspect-[16/10] overflow-hidden">
+        {productSlides.map((slide, index) => (
+          <img alt={slide.alt} aria-hidden={index !== activeSlide} className="landing-product-slide absolute inset-0 z-[1] w-full h-full object-cover object-left-top" data-active={index === activeSlide} key={slide.src} src={slide.src} />
+        ))}
+      </div>
+      <div className="landing-product-dots absolute right-[18px] bottom-4 z-[5] flex gap-[7px] items-center rounded-full p-1.5 max-[760px]:right-3 max-[760px]:bottom-[11px]" aria-label="DBX product screenshots">
+        {productSlides.map((slide, index) => (
+          <button aria-current={index === activeSlide} aria-label={`Show ${slide.label} screenshot`} key={slide.src} onClick={() => setActiveSlide(index)} title={slide.label} type="button" className="block w-[9px] h-[9px] border-0 rounded-full p-0 cursor-pointer">
+            <span>{slide.label}</span>
+          </button>
+        ))}
+      </div>
+    </motion.div>
+  );
+}
diff --git a/docs/components/aceternity/InfiniteMovingCards.tsx b/docs/components/aceternity/InfiniteMovingCards.tsx
new file mode 100644
index 0000000..b6f54e4
--- /dev/null
+++ b/docs/components/aceternity/InfiniteMovingCards.tsx
@@ -0,0 +1,37 @@
+"use client";
+
+type Testimonial = {
+  name: string;
+  role: string;
+  quote: string;
+  avatar: string;
+};
+
+type InfiniteMovingCardsProps = {
+  items: Testimonial[];
+  direction?: "left" | "right";
+  speed?: "slow" | "normal";
+};
+
+export function InfiniteMovingCards({ items, direction = "left", speed = "normal" }: InfiniteMovingCardsProps) {
+  const repeatedItems = [...items, ...items];
+
+  return (
+    <div className="landing-testimonial-marquee flex overflow-hidden select-none" data-direction={direction} data-speed={speed} aria-label="Testimonials">
+      <div className="landing-testimonial-track flex w-max min-w-full gap-3.5 px-[7px]">
+        {repeatedItems.map((item, index) => (
+          <figure className="landing-testimonial-card flex-[0_0_340px] min-h-[188px] rounded-[9px] m-0 p-[22px] max-[760px]:flex-[0_0_286px] max-[760px]:min-h-[210px] max-[760px]:p-[18px]" key={`${item.name}-${index}`}>
+            <div className="flex gap-3 items-center">
+              <img className="w-[42px] h-[42px] shrink-0 border border-[rgba(178,200,230,0.18)] rounded-full bg-[rgba(255,255,255,0.04)] object-cover" src={item.avatar} alt="" width={42} height={42} />
+              <figcaption>
+                <strong className="block text-landing-ink text-[15px] font-[740] leading-[1.25]">{item.name}</strong>
+                <span className="block mt-[3px] text-landing-muted text-xs leading-[1.35]">{item.role}</span>
+              </figcaption>
+            </div>
+            <blockquote className="mt-[18px] text-sm font-[560] leading-[1.58] text-[color-mix(in_srgb,var(--color-landing-ink)_88%,var(--color-landing-muted))]">{item.quote}</blockquote>
+          </figure>
+        ))}
+      </div>
+    </div>
+  );
+}
diff --git a/docs/components/aceternity/Spotlight.tsx b/docs/components/aceternity/Spotlight.tsx
new file mode 100644
index 0000000..4eb1f3c
--- /dev/null
+++ b/docs/components/aceternity/Spotlight.tsx
@@ -0,0 +1,11 @@
+"use client";
+
+import { motion } from "motion/react";
+
+type SpotlightProps = {
+  className?: string;
+};
+
+export function Spotlight({ className = "" }: SpotlightProps) {
+  return <motion.div aria-hidden="true" className={`aceternity-spotlight ${className}`} initial={{ opacity: 0, scale: 0.96 }} animate={{ opacity: 1, scale: 1 }} transition={{ duration: 1.1, ease: [0.16, 1, 0.3, 1] }} />;
+}
diff --git a/docs/components/landing/ChangelogList.tsx b/docs/components/landing/ChangelogList.tsx
new file mode 100644
index 0000000..1f6997d
--- /dev/null
+++ b/docs/components/landing/ChangelogList.tsx
@@ -0,0 +1,114 @@
+"use client";
+
+import { useState, useEffect, useRef } from "react";
+import type { ChangelogRelease } from "@/lib/changelog";
+import { ChevronDown, Tag } from "lucide-react";
+
+const PAGE_SIZE = 5;
+
+const sectionLabels: Record<string, Record<string, string>> = {
+  added: { en: "New Features", cn: "新功能" },
+  improved: { en: "Improvements", cn: "改进" },
+  fixed: { en: "Bug Fixes", cn: "问题修复" },
+  changed: { en: "Changes", cn: "变更" },
+  removed: { en: "Removed", cn: "移除" },
+};
+
+function formatDate(dateStr: string, lang: string) {
+  const d = new Date(dateStr);
+  if (lang === "cn") {
+    return `${d.getFullYear()}年${d.getMonth() + 1}月${d.getDate()}日`;
+  }
+  return d.toLocaleDateString("en-US", { year: "numeric", month: "long", day: "numeric" });
+}
+
+function ReleaseCard({ release, lang }: { release: ChangelogRelease; lang: string }) {
+  const t = lang === "cn" ? { publishedOn: "发布于", download: "下载", seeGitHub: "查看 GitHub Release 获取详情" } : { publishedOn: "Published on", download: "Download", seeGitHub: "See GitHub Release for details" };
+
+  return (
+    <div className="py-12 border-t border-[rgba(155,176,205,0.18)]">
+      {/* Header */}
+      <div className="flex items-center justify-between gap-4 mb-8">
+        <div className="flex items-center gap-4">
+          <span className="flex items-center gap-1.5 px-3.5 py-1.5 rounded-full border border-[rgba(155,176,205,0.25)] text-sm font-semibold text-[#e2e8f0]">
+            <Tag size={13} className="text-[#6ea8ff]" />
+            {release.tag.replace("v", "")}
+          </span>
+          <span className="text-[15px] text-[#64748b]">
+            {t.publishedOn} {formatDate(release.date, lang)}
+          </span>
+        </div>
+        <a href={`https://github.com/t8y2/dbx/releases/tag/${release.tag}`} target="_blank" rel="noopener noreferrer" className="flex items-center gap-1.5 px-4 py-2 rounded-full border border-[rgba(155,176,205,0.25)] text-sm text-[#e2e8f0] hover:border-[rgba(155,176,205,0.4)] transition-colors">
+          {t.download}
+          <ChevronDown size={14} />
+        </a>
+      </div>
+
+      {/* Title */}
+      <h2 className="text-[28px] font-[720] text-[#f7fbff] mb-10">Release {release.tag}</h2>
+
+      {/* Sections */}
+      {release.sections.map((section, si) => (
+        <div key={si} className={si > 0 ? "mt-10" : ""}>
+          <h3 className="text-xl font-bold text-[#f7fbff] mb-5">{sectionLabels[section.type]?.[lang] || section.title}</h3>
+          <ul className="space-y-3">
+            {section.items.map((item, ii) => (
+              <li key={ii} className="flex gap-3 text-[15px] leading-relaxed text-[#b8c5d6]">
+                <span className="mt-2 w-1.5 h-1.5 rounded-full bg-[#475569] shrink-0" />
+                <span>
+                  {item.desc ? (
+                    <>
+                      {item.title}，{item.desc}
+                    </>
+                  ) : (
+                    item.title
+                  )}
+                </span>
+              </li>
+            ))}
+          </ul>
+        </div>
+      ))}
+
+      {release.sections.length === 0 && <p className="text-[15px] text-[#64748b] italic">{t.seeGitHub}</p>}
+    </div>
+  );
+}
+
+export function ChangelogList({ releases, lang }: { releases: ChangelogRelease[]; lang: string }) {
+  const [count, setCount] = useState(PAGE_SIZE);
+  const sentinelRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const node = sentinelRef.current;
+    if (!node) return;
+
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        if (entry.isIntersecting) {
+          setCount((c) => Math.min(c + PAGE_SIZE, releases.length));
+        }
+      },
+      { rootMargin: "200px" },
+    );
+
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, [releases.length]);
+
+  const visible = releases.slice(0, count);
+  const hasMore = count < releases.length;
+
+  return (
+    <>
+      {visible.map((release) => (
+        <ReleaseCard key={release.tag} release={release} lang={lang} />
+      ))}
+      {hasMore && (
+        <div ref={sentinelRef} className="flex justify-center py-12 text-[#64748b] text-sm">
+          {lang === "cn" ? "加载更多版本…" : "Loading more versions…"}
+        </div>
+      )}
+    </>
+  );
+}
diff --git a/docs/components/landing/ChangelogRuntime.tsx b/docs/components/landing/ChangelogRuntime.tsx
new file mode 100644
index 0000000..355613d
--- /dev/null
+++ b/docs/components/landing/ChangelogRuntime.tsx
@@ -0,0 +1,49 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { ChangelogList } from "@/components/landing/ChangelogList";
+import { fetchChangelog, type ChangelogRelease } from "@/lib/changelog";
+
+type ChangelogRuntimeProps = {
+  lang: "en" | "cn";
+  initialReleases?: ChangelogRelease[];
+};
+
+const text = {
+  en: {
+    loading: "Loading releases...",
+    empty: "No releases found.",
+  },
+  cn: {
+    loading: "正在加载版本记录...",
+    empty: "暂无版本记录。",
+  },
+};
+
+export function ChangelogRuntime({ lang, initialReleases = [] }: ChangelogRuntimeProps) {
+  const [releases, setReleases] = useState<ChangelogRelease[] | null>(initialReleases);
+
+  useEffect(() => {
+    let active = true;
+
+    fetchChangelog(lang).then((data) => {
+      if (active && data.releases.length > 0) {
+        setReleases(data.releases);
+      }
+    });
+
+    return () => {
+      active = false;
+    };
+  }, [lang]);
+
+  if (releases === null) {
+    return <p className="text-landing-muted py-12">{text[lang].loading}</p>;
+  }
+
+  if (releases.length === 0) {
+    return <p className="text-landing-muted py-12">{text[lang].empty}</p>;
+  }
+
+  return <ChangelogList releases={releases} lang={lang} />;
+}
diff --git a/docs/components/landing/ContributorsWall.tsx b/docs/components/landing/ContributorsWall.tsx
new file mode 100644
index 0000000..525df6d
--- /dev/null
+++ b/docs/components/landing/ContributorsWall.tsx
@@ -0,0 +1,57 @@
+"use client";
+
+import { useState } from "react";
+import Link from "next/link";
+import type { Contributor } from "@/lib/contributors";
+
+function ContributorAvatar({ c }: { c: Contributor }) {
+  const [hovered, setHovered] = useState(false);
+
+  return (
+    <a
+      href={c.html_url}
+      target="_blank"
+      rel="noopener noreferrer"
+      className="landing-contributor-avatar"
+      data-stagger
+      onMouseEnter={() => setHovered(true)}
+      onMouseLeave={() => setHovered(false)}
+    >
+      <img
+        src={c.avatar_url}
+        alt={c.login}
+        width={64}
+        height={64}
+        loading="lazy"
+        className="block w-full h-full object-cover"
+      />
+      <span className={`landing-contributor-tooltip${hovered ? " is-visible" : ""}`}>
+        <span className="landing-contributor-tooltip-name">{c.login}</span>
+        <span className="landing-contributor-tooltip-count">{c.contributions} contributions</span>
+      </span>
+    </a>
+  );
+}
+
+export function ContributorsWallContent({ contributors, title, desc }: { contributors: Contributor[]; title: string; desc: string }) {
+  if (contributors.length === 0) return null;
+
+  return (
+    <>
+      <div className="grid grid-cols-[minmax(220px,0.42fr)_minmax(0,0.58fr)] gap-9 items-end mb-[22px] max-[760px]:block">
+        <h2 className="m-0 text-[25px] font-[720] text-landing-ink">{title}</h2>
+        <p className="mt-2 max-w-[650px] text-landing-muted text-sm leading-[1.65] justify-self-end text-right max-[760px]:max-w-none max-[760px]:text-left">
+          {desc}{" "}
+          <Link href="https://github.com/t8y2/dbx/graphs/contributors" target="_blank" className="landing-inline-link inline-flex items-center gap-[5px]">
+            {contributors.length}+ contributors on GitHub
+          </Link>
+        </p>
+      </div>
+      <div className="landing-contributor-grid">
+        {contributors.map((c) => (
+          <ContributorAvatar key={c.login} c={c} />
+        ))}
+      </div>
+    </>
+  );
+}
diff --git a/docs/components/landing/InstallTabs.tsx b/docs/components/landing/InstallTabs.tsx
new file mode 100644
index 0000000..1f1c851
--- /dev/null
+++ b/docs/components/landing/InstallTabs.tsx
@@ -0,0 +1,117 @@
+"use client";
+
+import { ChevronDown, Download, Server } from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+import { createInstallOptions, type InstallOption } from "@/lib/downloadLinks";
+import { fetchLatestReleaseInfo } from "@/lib/latestRelease";
+
+type InstallTabsProps = {
+  lang: "en" | "cn";
+  version: string;
+};
+
+const downloadLabel = { en: "Download DBX", cn: "下载 DBX" };
+
+const platformIconPaths = {
+  dark: {
+    "linux-arm": "/icons/platform/linux.svg",
+    linux: "/icons/platform/linux.svg",
+    "macos-arm": "/icons/platform/macos.png",
+    "macos-intel": "/icons/platform/macos.png",
+    windows: "/icons/platform/windows.png",
+  },
+  light: {
+    "linux-arm": "/icons/platform/linux.svg",
+    linux: "/icons/platform/linux.svg",
+    "macos-arm": "/icons/platform/macos-white.png",
+    "macos-intel": "/icons/platform/macos-white.png",
+    windows: "/icons/platform/windows.png",
+  },
+};
+
+function detectPlatformId(): string {
+  if (typeof navigator === "undefined") return "macos-arm";
+  const ua = navigator.userAgent.toLowerCase();
+  if (ua.includes("win")) return "windows";
+  if (ua.includes("linux")) return ua.includes("aarch64") || ua.includes("arm") ? "linux-arm" : "linux";
+  return "macos-arm";
+}
+
+function PlatformIcon({ id, size, variant }: { id: string; size: number; variant: "dark" | "light" }) {
+  const src = platformIconPaths[variant][id as keyof (typeof platformIconPaths)["dark"]];
+  if (!src) return <Server size={size} />;
+  return <img alt="" aria-hidden="true" height={size} src={src} width={size} />;
+}
+
+export function InstallTabs({ lang, version }: InstallTabsProps) {
+  const [downloadVersion, setDownloadVersion] = useState(version);
+  const options = useMemo(() => createInstallOptions(lang, downloadVersion), [lang, downloadVersion]);
+  const [open, setOpen] = useState(false);
+  const [platformId, setPlatformId] = useState("macos-arm");
+
+  useEffect(() => {
+    setPlatformId(detectPlatformId());
+  }, []);
+
+  useEffect(() => {
+    let active = true;
+
+    setDownloadVersion(version);
+    fetchLatestReleaseInfo().then((release) => {
+      if (active && release?.version) {
+        setDownloadVersion(release.version);
+      }
+    });
+
+    return () => {
+      active = false;
+    };
+  }, [version]);
+
+  const primary = useMemo(() => options.find((o) => o.id === platformId) ?? options[0], [options, platformId]);
+  const menuOptions = useMemo(() => options.filter((o) => o.id !== platformId), [options, platformId]);
+
+  return (
+    <div
+      className="landing-install relative z-20 block w-fit max-w-full mx-auto"
+      data-open={open}
+      onBlur={(event) => {
+        if (!event.currentTarget.contains(event.relatedTarget)) {
+          setOpen(false);
+        }
+      }}
+      onMouseEnter={() => setOpen(true)}
+      onMouseLeave={() => setOpen(false)}
+    >
+      <a
+        aria-controls="landing-install-menu"
+        aria-expanded={open}
+        aria-haspopup="listbox"
+        className="landing-install-trigger grid grid-cols-[auto_minmax(0,1fr)_auto] gap-4 items-center w-[min(340px,calc(100vw-48px))] min-h-[68px] border-0 rounded-full mx-auto px-6 cursor-pointer"
+        href={primary.href}
+        onFocus={() => setOpen(true)}
+      >
+        <PlatformIcon id={primary.id} size={30} variant="dark" />
+        <span className="grid gap-0.5 min-w-0">
+          <strong className="overflow-hidden text-[15px] font-[780] leading-[1.2] truncate">{downloadLabel[lang]}</strong>
+          <small className="overflow-hidden text-xs font-[520] leading-tight truncate text-[color-mix(in_srgb,#0f172a_48%,#94a3b8)]">{primary.label}</small>
+        </span>
+        <ChevronDown size={18} />
+      </a>
+      <div
+        className="landing-install-menu absolute z-30 top-[calc(100%+12px)] left-1/2 -translate-x-1/2 grid w-[min(300px,calc(100vw-48px))] border border-[rgba(155,176,205,0.17)] rounded-xl py-1.5"
+        id="landing-install-menu"
+        role="listbox"
+        aria-label={lang === "cn" ? "下载选项" : "Download options"}
+      >
+        {menuOptions.map((item) => (
+          <a aria-selected="false" className="landing-install-option grid grid-cols-[24px_minmax(0,1fr)_18px] gap-3 items-center min-w-0 border-0 px-[18px] py-3 bg-transparent text-left cursor-pointer" href={item.href} key={item.id} role="option">
+            <PlatformIcon id={item.id} size={20} variant="light" />
+            <strong className="overflow-hidden text-sm font-[640] leading-[1.2] truncate">{item.label}</strong>
+            <Download size={15} aria-hidden="true" />
+          </a>
+        ))}
+      </div>
+    </div>
+  );
+}
diff --git a/docs/components/landing/LandingFooter.tsx b/docs/components/landing/LandingFooter.tsx
new file mode 100644
index 0000000..b234d25
--- /dev/null
+++ b/docs/components/landing/LandingFooter.tsx
@@ -0,0 +1,57 @@
+import Link from "next/link";
+
+const i18n = {
+  en: {
+    tagline: "20 MB to manage 60+ databases.",
+    copyright: `© ${new Date().getFullYear()} DBX. All rights reserved.`,
+  },
+  cn: {
+    tagline: "20MB，管理60+种数据库。",
+    copyright: `© ${new Date().getFullYear()} DBX.`,
+  },
+};
+
+function GithubIcon() {
+  return (
+    <svg viewBox="0 0 24 24" fill="currentColor" className="size-[18px]">
+      <path d="M12 0C5.37 0 0 5.37 0 12c0 5.31 3.435 9.795 8.205 11.385.6.105.825-.255.825-.57 0-.285-.015-1.23-.015-2.235-3.015.555-3.795-.735-4.035-1.41-.135-.345-.72-1.41-1.23-1.695-.42-.225-1.02-.78-.015-.795.945-.015 1.62.87 1.845 1.23 1.08 1.815 2.805 1.305 3.495.99.105-.78.42-1.305.765-1.605-2.67-.3-5.46-1.335-5.46-5.925 0-1.305.465-2.385 1.23-3.225-.12-.3-.54-1.53.12-3.18 0 0 1.005-.315 3.3 1.23.96-.27 1.98-.405 3-.405s2.04.135 3 .405c2.295-1.56 3.3-1.23 3.3-1.23.66 1.65.24 2.88.12 3.18.765.84 1.23 1.905 1.23 3.225 0 4.605-2.805 5.625-5.475 5.925.435.375.81 1.095.81 2.22 0 1.605-.015 2.895-.015 3.3 0 .315.225.69.825.57A12.02 12.02 0 0024 12c0-6.63-5.37-12-12-12z" />
+    </svg>
+  );
+}
+
+export function LandingFooter({ lang }: { lang: "en" | "cn" }) {
+  const t = i18n[lang];
+
+  return (
+    <footer className="border-t border-[var(--color-landing-line)] bg-[#0b1120]">
+      <div className="max-w-[1180px] mx-auto px-7 py-7 max-[760px]:px-[18px]">
+        <div className="flex items-center justify-between gap-4 max-[760px]:flex-col max-[760px]:gap-3 max-[760px]:text-center">
+          {/* Logo */}
+          <Link href={`/${lang}`} className="flex items-center gap-2.5 text-[var(--color-landing-ink)] text-lg font-[820] shrink-0">
+            <img src="/logo.png" alt="DBX" width={22} height={22} />
+            <span>DBX</span>
+          </Link>
+
+          {/* Tagline */}
+          <span className="text-[13px] text-[var(--color-landing-muted)]">{t.tagline}</span>
+
+          {/* Repo icons */}
+          <div className="flex items-center gap-3 shrink-0">
+            <a href="https://github.com/t8y2/dbx" target="_blank" rel="noopener noreferrer" className="text-[var(--color-landing-muted)] hover:text-[var(--color-landing-ink)] transition-colors" aria-label="GitHub">
+              <GithubIcon />
+            </a>
+            <a href="https://cnb.cool/dbxio.com/dbx" target="_blank" rel="noopener noreferrer" className="opacity-40 hover:opacity-100 transition-opacity" aria-label="CNB">
+              <img src="/icons/cnb.svg" alt="CNB" width={18} height={18} />
+            </a>
+            <a href="https://atomgit.com/t8y2/dbx" target="_blank" rel="noopener noreferrer" className="opacity-40 hover:opacity-100 transition-opacity" aria-label="AtomGit">
+              <img src="/icons/atomgit.png" alt="AtomGit" width={18} height={18} />
+            </a>
+          </div>
+
+          {/* Copyright */}
+          <span className="text-[12px] text-[var(--color-landing-muted)] shrink-0">{t.copyright}</span>
+        </div>
+      </div>
+    </footer>
+  );
+}
diff --git a/docs/components/landing/LandingLatestUpdates.tsx b/docs/components/landing/LandingLatestUpdates.tsx
new file mode 100644
index 0000000..369fe04
--- /dev/null
+++ b/docs/components/landing/LandingLatestUpdates.tsx
@@ -0,0 +1,57 @@
+"use client";
+
+import Link from "next/link";
+import { ArrowRight, CheckCircle2 } from "lucide-react";
+import { useEffect, useState } from "react";
+import { RevealSection } from "@/components/landing/RevealSection";
+import { fetchChangelog, type ChangelogRelease } from "@/lib/changelog";
+import { buildLandingLatestUpdates } from "@/lib/landingLatest";
+import { fetchLatestReleaseInfo, type LatestReleaseInfo } from "@/lib/latestRelease";
+
+type LandingLatestUpdatesProps = {
+  lang: "en" | "cn";
+  fallbackVersion: string;
+  initialRelease?: ChangelogRelease;
+  initialLatestRelease?: LatestReleaseInfo | null;
+};
+
+export function LandingLatestUpdates({ lang, fallbackVersion, initialRelease, initialLatestRelease }: LandingLatestUpdatesProps) {
+  const [latest, setLatest] = useState(() => buildLandingLatestUpdates(lang, initialRelease, fallbackVersion, initialLatestRelease));
+
+  useEffect(() => {
+    let active = true;
+
+    setLatest(buildLandingLatestUpdates(lang, initialRelease, fallbackVersion, initialLatestRelease));
+    Promise.all([fetchLatestReleaseInfo(), fetchChangelog(lang)]).then(([releaseInfo, data]) => {
+      if (!active) return;
+
+      setLatest(buildLandingLatestUpdates(lang, data.releases[0] ?? initialRelease, fallbackVersion, releaseInfo ?? initialLatestRelease));
+    });
+
+    return () => {
+      active = false;
+    };
+  }, [lang, fallbackVersion, initialRelease, initialLatestRelease]);
+
+  return (
+    <RevealSection className="grid grid-cols-[minmax(86px,0.16fr)_minmax(210px,0.32fr)_minmax(0,0.38fr)_max-content] gap-[22px] items-center max-w-[1180px] mx-auto px-7 border-t border-b border-landing-line mt-[62px] py-6 max-[1040px]:grid-cols-[minmax(0,1fr)_max-content] max-[760px]:block max-[760px]:px-[18px]">
+      <div className="landing-update-version w-max rounded-[7px] px-2.5 py-[7px] text-[13px] font-[720]">{latest.version}</div>
+      <div className="max-[1040px]:col-span-full max-[760px]:mt-4">
+        <h2 className="m-0 text-[21px] font-[720] text-landing-ink">{latest.title}</h2>
+        <p className="mt-1.5 text-landing-muted text-[13px] leading-[1.55]">{latest.desc}</p>
+      </div>
+      <ul className="grid gap-2 m-0 p-0 list-none max-[1040px]:col-span-full max-[760px]:mt-4">
+        {latest.items.map((item) => (
+          <li key={item} className="flex gap-2 items-center text-[13px] font-[560] leading-[1.45] text-[color-mix(in_srgb,var(--color-landing-ink)_88%,var(--color-landing-muted))]" data-stagger>
+            <CheckCircle2 size={14} className="shrink-0 text-landing-green" />
+            <span>{item}</span>
+          </li>
+        ))}
+      </ul>
+      <Link href={`/${lang}/changelog`} className="landing-inline-link flex shrink-0 items-center gap-[7px] text-sm font-[650] max-[760px]:mt-4">
+        {latest.link}
+        <ArrowRight size={15} />
+      </Link>
+    </RevealSection>
+  );
+}
diff --git a/docs/components/landing/LandingNav.tsx b/docs/components/landing/LandingNav.tsx
new file mode 100644
index 0000000..74c2755
--- /dev/null
+++ b/docs/components/landing/LandingNav.tsx
@@ -0,0 +1,80 @@
+"use client";
+
+import Link from "next/link";
+import { useEffect, useRef } from "react";
+
+const i18n = {
+  en: {
+    home: "Home",
+    docs: "Docs",
+    databases: "Databases",
+    changelog: "Changelog",
+    community: "Community",
+    drivers: "Offline Drivers",
+    lang: "中文",
+  },
+  cn: { home: "首页", docs: "文档", databases: "数据库", changelog: "更新日志", community: "交流群", drivers: "离线驱动", lang: "English" },
+};
+
+export function LandingNav({ lang, active }: { lang: "en" | "cn"; active?: "home" | "databases" | "changelog" | "community" | "drivers" }) {
+  const ref = useRef<HTMLElement>(null);
+  const t = i18n[lang];
+  const otherLang = lang === "cn" ? "en" : "cn";
+  const langHrefMap: Record<string, string> = {
+    databases: `/${otherLang}/databases`,
+    changelog: `/${otherLang}/changelog`,
+    community: `/${otherLang}/community`,
+    drivers: `/${otherLang}/drivers`,
+  };
+  const langHref = langHrefMap[active ?? ""] ?? `/${otherLang}`;
+
+  useEffect(() => {
+    const node = ref.current;
+    if (!node) return;
+
+    function onScroll() {
+      node!.classList.toggle("is-scrolled", window.scrollY > 60);
+    }
+
+    onScroll();
+    window.addEventListener("scroll", onScroll, { passive: true });
+    return () => window.removeEventListener("scroll", onScroll);
+  }, []);
+
+  return (
+    <nav ref={ref} className="landing-nav">
+      <div className="flex items-center justify-between max-w-[1180px] h-16 mx-auto px-7 max-[760px]:min-h-[58px] max-[760px]:h-auto max-[760px]:px-[18px] max-[760px]:py-2.5">
+        <Link href={`/${lang}`} className="flex items-center gap-2.5 text-landing-ink text-2xl font-[820]">
+          <img src="/logo.png" alt="DBX" width={28} height={28} />
+          <span>DBX</span>
+        </Link>
+        <div className="flex items-center gap-1">
+          <Link href={`/${lang}`} className={`landing-nav-link rounded-[7px] px-[11px] py-2 text-[13px] font-medium max-[760px]:hidden ${active === "home" ? "text-landing-ink" : "text-landing-muted"}`}>
+            {t.home}
+          </Link>
+          <Link href={`/${lang}/docs/what-is-dbx`} className="landing-nav-link rounded-[7px] px-[11px] py-2 text-[13px] font-medium max-[760px]:hidden text-landing-muted">
+            {t.docs}
+          </Link>
+          <Link href={`/${lang}/databases`} className={`landing-nav-link rounded-[7px] px-[11px] py-2 text-[13px] font-medium max-[760px]:hidden ${active === "databases" ? "text-landing-ink" : "text-landing-muted"}`}>
+            {t.databases}
+          </Link>
+          <Link href={`/${lang}/changelog`} className={`landing-nav-link rounded-[7px] px-[11px] py-2 text-[13px] font-medium max-[760px]:hidden ${active === "changelog" ? "text-landing-ink" : "text-landing-muted"}`}>
+            {t.changelog}
+          </Link>
+          <Link href={`/${lang}/community`} className={`landing-nav-link rounded-[7px] px-[11px] py-2 text-[13px] font-medium max-[760px]:hidden ${active === "community" ? "text-landing-ink" : "text-landing-muted"}`}>
+            {t.community}
+          </Link>
+          <Link href={`/${lang}/drivers`} className={`landing-nav-link rounded-[7px] px-[11px] py-2 text-[13px] font-medium max-[760px]:hidden ${active === "drivers" ? "text-landing-ink" : "text-landing-muted"}`}>
+            {t.drivers}
+          </Link>
+          <Link href="https://github.com/t8y2/dbx" target="_blank" className="landing-nav-link rounded-[7px] px-[11px] py-2 text-landing-muted text-[13px] font-medium max-[760px]:hidden">
+            GitHub
+          </Link>
+          <Link href={langHref} className="landing-nav-link rounded-[7px] px-[11px] py-2 text-landing-muted text-[13px] font-medium ml-1.5 border border-landing-line">
+            {t.lang}
+          </Link>
+        </div>
+      </div>
+    </nav>
+  );
+}
diff --git a/docs/components/landing/RevealSection.tsx b/docs/components/landing/RevealSection.tsx
new file mode 100644
index 0000000..d5d6207
--- /dev/null
+++ b/docs/components/landing/RevealSection.tsx
@@ -0,0 +1,39 @@
+"use client";
+
+import type { CSSProperties, ReactNode } from "react";
+import { useEffect, useRef, useState } from "react";
+
+type RevealSectionProps = {
+  children: ReactNode;
+  className?: string;
+  delay?: number;
+};
+
+export function RevealSection({ children, className = "", delay = 0 }: RevealSectionProps) {
+  const ref = useRef<HTMLElement | null>(null);
+  const [visible, setVisible] = useState(false);
+
+  useEffect(() => {
+    const node = ref.current;
+    if (!node) return;
+
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        if (entry.isIntersecting) {
+          setVisible(true);
+          observer.unobserve(entry.target);
+        }
+      },
+      { rootMargin: "0px 0px -14% 0px", threshold: 0.18 },
+    );
+
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, []);
+
+  return (
+    <section ref={ref} className={`${className} landing-reveal${visible ? " is-visible" : ""}`} style={{ "--reveal-delay": `${delay}ms` } as CSSProperties}>
+      {children}
+    </section>
+  );
+}
diff --git a/docs/content/docs/ai-assistant.cn.mdx b/docs/content/docs/ai-assistant.cn.mdx
new file mode 100644
index 0000000..d3daba3
--- /dev/null
+++ b/docs/content/docs/ai-assistant.cn.mdx
@@ -0,0 +1,186 @@
+---
+title: AI 助手
+description: 配置 AI 供应商后，在 DBX 中生成 SQL、解释查询、优化语句并辅助修复错误。
+---
+
+AI 助手用于辅助 SQL 工作。它会结合当前连接的数据库元数据理解表结构和字段，再根据你的描述生成 SQL、解释查询、给出优化建议或帮助修复错误。
+
+<Callout type="warn">AI 生成的 SQL 不会自动执行。请在执行前检查表名、字段名、筛选条件和影响范围，尤其是在生产环境连接上。</Callout>
+
+## 配置
+
+<Steps>
+  <Step>
+    ### 打开设置
+
+    进入 DBX 设置页，找到 AI 相关配置。
+
+  </Step>
+  <Step>
+    ### 选择供应商
+
+    选择 Anthropic、OpenAI 或兼容 OpenAI API 的自定义端点。
+
+  </Step>
+  <Step>
+    ### 填写凭据
+
+    输入 API Key。使用自定义端点时，还需要填写接口地址和模型名称。
+
+  </Step>
+  <Step>
+    ### 保存并测试
+
+    保存配置后回到编辑器，尝试用自然语言生成一条简单查询。
+
+  </Step>
+</Steps>
+
+<Callout type="info">如果没有配置 API Key，AI 功能应向用户提示需要先完成设置，而不是静默失败。</Callout>
+
+## Ask 模式与 Agent 模式
+
+| 模式  | 行为                                             | 执行                                     |
+| ----- | ------------------------------------------------ | ---------------------------------------- |
+| Ask   | 生成 SQL、解释、修复、优化、方言转换或样例数据   | 不暗示已经执行                           |
+| Agent | 当用户明确要求查询数据时，优先生成一条可执行 SQL | DBX 会先评估生成 SQL，再决定是否尝试执行 |
+
+## Thinking 模式
+
+对于支持扩展推理的供应商和模型（如启用了 thinking 的 Claude），DBX 在 AI 设置中提供了 **Thinking** 开关。启用后：
+
+- 模型在生成 SQL 前会花费更多时间推理
+- 复杂查询、多表 JOIN 和优化建议受益最大
+- 响应时间会增加，但对于非简单任务的输出质量会提高
+
+可按任务开关 Thinking。简单查询和解释可关闭；复杂 Schema 推理、优化或调试时可启用。
+
+## 表提及
+
+在提示中使用 `@table` 或 `@schema.table` 告诉 AI 哪些表最重要：
+
+- `@users` — 在上下文中包含 `users` 表结构
+- `@public.orders` — 包含特定 schema 限定的表
+- 多个提及：`@users @orders @products` 同时包含三张表
+
+表提及是控制 Schema 上下文最可靠的方式。即使完整 Schema 太大无法全部包含，它也能正常工作。
+
+## 提示输入历史导航
+
+使用方向键浏览之前的 AI 提示：
+
+- 按 **↑**（上箭头）循环浏览之前的提示
+- 按 **↓**（下箭头）在提示历史中向前移动
+- 在 Ask 和 Agent 模式中都有效
+- 在迭代类似查询或解释时节省时间
+
+提示历史按会话保存，帮助你快速重用或修改之前的 AI 请求而无需重新输入。
+
+## Schema 上下文
+
+AI 提示可以包含当前数据库类型、连接名称、数据库、当前 SQL、最近错误、结果预览和 Schema 上下文。Schema 上下文包含表、字段、索引和外键。
+
+当 Schema 很大时，DBX 会截断上下文。使用表提及来告诉 AI 优先围绕哪些表进行推理。
+
+## SQL 安全策略
+
+| SQL 类型                                                           | DBX 行为                                     |
+| ------------------------------------------------------------------ | -------------------------------------------- |
+| `SELECT`、`WITH`、`SHOW`、`DESCRIBE`、`DESC`、`EXPLAIN` 等只读语句 | 用户明确表达查询意图时，Agent 模式可自动执行 |
+| `INSERT` 或按键限定的 `UPDATE` 等低风险写入                        | 只在明确非生产环境自动执行；其他情况需要确认 |
+| 多语句、`DELETE`、`MERGE`、`REPLACE`、`CREATE` 或未知 SQL          | 执行前需要确认                               |
+| `DROP`、`TRUNCATE`、`ALTER`、`RENAME` 或大范围 `UPDATE` 等危险语句 | 会被 AI 执行策略阻止                         |
+
+连接名、主机或数据库名看起来像生产环境时，DBX 会更保守。AI 生成的 SQL 仍然是模型输出，请像审查代码一样审查它。
+
+## 常见用法
+
+### 生成 SQL
+
+用自然语言描述目标，AI 会结合当前连接的元数据生成查询：
+
+> 查看最近 30 天订单金额最高的 10 个客户
+
+可能生成：
+
+```sql
+SELECT c.name, SUM(o.amount) AS total_amount
+FROM customers c
+JOIN orders o ON c.id = o.customer_id
+WHERE o.created_at >= NOW() - INTERVAL 30 DAY
+GROUP BY c.id, c.name
+ORDER BY total_amount DESC
+LIMIT 10;
+```
+
+生成后建议检查：
+
+- 是否使用了正确的表和字段
+- 时间范围是否符合预期
+- 聚合和排序逻辑是否正确
+- 是否需要限制返回行数
+
+### 解释 SQL
+
+选中一段 SQL 后，可以让 AI 解释它的结构：
+
+- 每个子查询的作用
+- `JOIN` 条件如何关联表
+- `WHERE` 条件过滤了什么
+- 聚合、分组和排序的意义
+
+这适合阅读历史查询、接手报表 SQL 或理解复杂视图。
+
+### 优化 SQL
+
+AI 可以根据 SQL 和表结构给出优化方向，例如：
+
+- 是否可能发生全表扫描
+- 是否缺少合适索引
+- 子查询是否可以改写为 `JOIN`
+- 排序、去重或聚合是否可以减少
+
+<Callout type="info">AI 的优化建议是参考信息。真正的性能判断仍应结合数据库的执行计划、数据量和索引情况。</Callout>
+
+### 修复错误
+
+当 SQL 执行失败时，可以把错误信息和当前 SQL 交给 AI 辅助分析。常见修复包括：
+
+- 语法错误
+- 表名或字段名拼写错误
+- `GROUP BY` 字段缺失
+- 类型不匹配
+- 不同数据库方言之间的语法差异
+
+## 支持的供应商
+
+DBX 提供了改进的**可搜索模型下拉框**，让你可以轻松地在所有支持的供应商中查找并选择可用模型。
+
+<Tabs groupId="ai-provider" items={['Anthropic', 'OpenAI', '自定义端点']}>
+  <Tab value="Anthropic">
+    适合使用 Claude 系列模型。填写 API Key 后，在可搜索的下拉框中选择或填写你要使用的模型。
+  </Tab>
+  <Tab value="OpenAI">
+    适合使用 OpenAI 模型。填写 API Key 后，在模型输入框中选择或填写你要使用的模型。
+  </Tab>
+  <Tab value="自定义端点">
+    适合兼容 OpenAI Chat Completions API 的服务，例如本地模型服务、企业网关或第三方模型平台。
+
+    需要配置：
+
+    - Endpoint URL
+    - API Key
+    - Model
+
+  </Tab>
+</Tabs>
+
+## 隐私与安全
+
+AI 请求通常会包含你的问题、相关 SQL、错误信息，以及必要的表结构上下文。使用前请确认：
+
+- 当前供应商是否允许发送这些信息
+- 是否包含敏感字段名、业务规则或样例数据
+- 团队是否对第三方模型调用有合规要求
+
+如果希望 AI 直接通过工具查询数据库，可以继续阅读 [MCP 集成](/cn/docs/mcp)。
diff --git a/docs/content/docs/ai-assistant.mdx b/docs/content/docs/ai-assistant.mdx
new file mode 100644
index 0000000..5fe287f
--- /dev/null
+++ b/docs/content/docs/ai-assistant.mdx
@@ -0,0 +1,186 @@
+---
+title: AI Assistant
+description: Configure an AI provider to generate SQL, explain queries, suggest optimizations, and help fix errors in DBX.
+---
+
+The AI assistant helps with SQL work. It uses metadata from the active connection to understand tables and columns, then helps generate SQL, explain queries, suggest optimizations, or diagnose errors.
+
+<Callout type="warn">AI-generated SQL is not executed automatically. Review table names, columns, filters, and affected rows before running it, especially on production connections.</Callout>
+
+## Configuration
+
+<Steps>
+  <Step>
+    ### Open Settings
+
+    Open DBX settings and find the AI configuration section.
+
+  </Step>
+  <Step>
+    ### Choose a Provider
+
+    Select Anthropic, OpenAI, or a custom endpoint compatible with the OpenAI API.
+
+  </Step>
+  <Step>
+    ### Enter Credentials
+
+    Enter your API key. For custom endpoints, also enter the endpoint URL and model name.
+
+  </Step>
+  <Step>
+    ### Save and Test
+
+    Save the configuration, return to the editor, and try generating a simple query from natural language.
+
+  </Step>
+</Steps>
+
+<Callout type="info">When no API key is configured, AI features should prompt the user to complete setup instead of failing silently.</Callout>
+
+## Ask Mode And Agent Mode
+
+| Mode  | Behavior                                                                               | Execution                                                   |
+| ----- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
+| Ask   | Generates SQL, explanations, fixes, optimizations, dialect conversions, or sample data | Does not imply anything has run                             |
+| Agent | Prioritizes one executable SQL statement when the user clearly asks DBX to query data  | DBX evaluates the generated SQL before attempting execution |
+
+## Thinking Mode
+
+For providers and models that support extended reasoning (such as Claude with thinking enabled), DBX exposes a **Thinking** toggle in AI settings. When enabled:
+
+- The model spends more time reasoning before generating SQL
+- Complex queries, multi-table joins, and optimization suggestions benefit most
+- Response time increases, but output quality improves for non-trivial tasks
+
+Toggle Thinking on or off per task. Leave it off for simple queries and explanations; enable it for complex schema reasoning, optimization, or debugging.
+
+## Table Mentions
+
+Use `@table` or `@schema.table` mentions in your prompt to tell the AI which tables matter most:
+
+- `@users` — includes the `users` table schema in context
+- `@public.orders` — includes a specific schema-qualified table
+- Multiple mentions: `@users @orders @products` includes all three tables
+
+Table mentions are the most reliable way to control schema context. They work even when the full schema is too large to include entirely.
+
+## Prompt Input History Navigation
+
+Navigate through your previous AI prompts using arrow keys:
+
+- Press **↑** (Up Arrow) to cycle through previous prompts
+- Press **↓** (Down Arrow) to move forward in prompt history
+- Works in both Ask and Agent modes
+- Saves time when iterating on similar queries or explanations
+
+The prompt history is preserved per session and helps you quickly reuse or modify previous AI requests without retyping.
+
+## Schema Context
+
+AI prompts can include the current database type, connection name, database, current SQL, recent error, result preview, and schema context. Schema context contains tables, columns, indexes, and foreign keys.
+
+When a schema is large, DBX truncates context. Use table mentions to prioritize the tables you want AI to reason about.
+
+## SQL Safety Policy
+
+| SQL Category                                                                          | DBX Behavior                                                                |
+| ------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
+| Read-only statements such as `SELECT`, `WITH`, `SHOW`, `DESCRIBE`, `DESC`, `EXPLAIN`  | Can be auto-executed in Agent mode when the user clearly asks to query      |
+| Scoped low-risk writes such as `INSERT` or keyed `UPDATE`                             | Auto-execute only in clearly non-production environments; otherwise confirm |
+| Multiple statements, `DELETE`, `MERGE`, `REPLACE`, `CREATE`, or unknown SQL           | Confirm before execution                                                    |
+| Dangerous statements such as `DROP`, `TRUNCATE`, `ALTER`, `RENAME`, or broad `UPDATE` | Blocked by the AI execution policy                                          |
+
+Production-like connection names, hosts, or database names make DBX more conservative. Generated SQL is still text from an AI model; review it like code before trusting it.
+
+## Common Uses
+
+### Generate SQL
+
+Describe the result you want, and the assistant generates SQL using metadata from the current connection:
+
+> Show the top 10 customers by order amount in the last 30 days
+
+Example output:
+
+```sql
+SELECT c.name, SUM(o.amount) AS total_amount
+FROM customers c
+JOIN orders o ON c.id = o.customer_id
+WHERE o.created_at >= NOW() - INTERVAL 30 DAY
+GROUP BY c.id, c.name
+ORDER BY total_amount DESC
+LIMIT 10;
+```
+
+Before running generated SQL, check:
+
+- Whether the tables and columns are correct
+- Whether the time range matches your intent
+- Whether aggregation and ordering are correct
+- Whether the result should be limited
+
+### Explain SQL
+
+Select SQL and ask the assistant to explain its structure:
+
+- What each subquery does
+- How `JOIN` conditions connect tables
+- What the `WHERE` clause filters
+- How aggregation, grouping, and sorting work
+
+This is useful for reading legacy queries, reports, or complex views.
+
+### Optimize SQL
+
+The assistant can suggest optimization directions, such as:
+
+- Possible full table scans
+- Missing indexes
+- Subqueries that may be rewritten as `JOIN`
+- Sorting, deduplication, or aggregation that could be reduced
+
+<Callout type="info">AI optimization suggestions are advisory. Confirm performance with the database execution plan, data volume, and index design.</Callout>
+
+### Fix Errors
+
+When SQL fails, send the error and query to the assistant for diagnosis. Common fixes include:
+
+- Syntax errors
+- Misspelled table or column names
+- Missing `GROUP BY` columns
+- Type mismatches
+- Dialect differences between database engines
+
+## Supported Providers
+
+DBX features an improved **searchable model dropdown** that makes it easy to find and select from available models across all supported providers.
+
+<Tabs groupId="ai-provider" items={['Anthropic', 'OpenAI', 'Custom Endpoint']}>
+  <Tab value="Anthropic">
+    Use this for Claude models. Enter your API key, then choose or type the model you want to use from the searchable dropdown.
+  </Tab>
+  <Tab value="OpenAI">
+    Use this for OpenAI models. Enter your API key, then choose or type the model you want to use.
+  </Tab>
+  <Tab value="Custom Endpoint">
+    Use this for services compatible with the OpenAI Chat Completions API, such as local model servers, enterprise gateways, or third-party model platforms.
+
+    Configure:
+
+    - Endpoint URL
+    - API key
+    - Model
+
+  </Tab>
+</Tabs>
+
+## Privacy and Security
+
+AI requests may include your prompt, SQL, error messages, and the schema context needed to answer. Before using an external provider, confirm:
+
+- Whether sending this information is allowed
+- Whether it includes sensitive field names, business logic, or sample data
+- Whether your team has compliance rules for third-party model calls
+
+If you want AI agents to query databases through tools, continue with [MCP Integration](/en/docs/mcp).
diff --git a/docs/content/docs/changelog.cn.mdx b/docs/content/docs/changelog.cn.mdx
new file mode 100644
index 0000000..a4d6f32
--- /dev/null
+++ b/docs/content/docs/changelog.cn.mdx
@@ -0,0 +1,8 @@
+---
+title: 更新日志
+description: 按版本查看 DBX 的新增功能、体验改进和问题修复，内容同步自 GitHub Releases。
+---
+
+更新日志会直接读取 R2 上的最新 Release 数据，因此发布后无需重新构建文档站也能刷新。
+
+[打开实时更新日志](/cn/changelog)
diff --git a/docs/content/docs/changelog.mdx b/docs/content/docs/changelog.mdx
new file mode 100644
index 0000000..94e328e
--- /dev/null
+++ b/docs/content/docs/changelog.mdx
@@ -0,0 +1,8 @@
+---
+title: Changelog
+description: Track DBX release notes by version, mirrored from GitHub Releases.
+---
+
+The changelog is loaded from the latest release data on R2, so it can refresh after a release without rebuilding the docs site.
+
+[Open the live changelog](/en/changelog)
diff --git a/docs/content/docs/cli.cn.mdx b/docs/content/docs/cli.cn.mdx
new file mode 100644
index 0000000..a26901a
--- /dev/null
+++ b/docs/content/docs/cli.cn.mdx
@@ -0,0 +1,185 @@
+---
+title: DBX CLI
+description: 在终端、脚本、CI 和 Codex 中使用 DBX 连接。
+---
+
+<Callout type="info">DBX CLI 是独立命令行包，适合终端、脚本和 AI 编程助手工作流。它与 MCP Server 共享 DBX 连接存储和 SQL 安全规则。</Callout>
+
+## 安装
+
+```bash
+npm install -g @dbx-app/cli
+```
+
+### Homebrew
+
+```bash
+brew tap t8y2/dbx
+brew install dbx-cli
+```
+
+需要 Node.js 22.13.0 或更高版本。
+
+查看版本：
+
+```bash
+dbx --version
+```
+
+## 常用命令
+
+```bash
+dbx doctor
+dbx capabilities
+dbx connections list --json
+dbx connections list --format csv
+dbx schema list local --json
+dbx schema describe local users --json
+dbx query local "select count(*) as total from users" --json
+dbx query local "select id, name from users" --format csv
+dbx query local "select * from users" --limit 50 --timeout 10s --json
+dbx query local --file ./query.sql --json
+dbx context local --tables users,orders
+dbx open local users
+```
+
+## 诊断
+
+使用 `dbx doctor` 查看本地 DBX 路径、连接存储健康状态，以及桌面端 bridge 是否可用：
+
+```bash
+dbx doctor
+dbx doctor --json
+```
+
+如果切换 Node.js 版本后，`dbx doctor` 报 `NODE_MODULE_VERSION` 不匹配，请用运行 `dbx` 的同一个 Node.js 版本重建 native 依赖：
+
+```bash
+pnpm rebuild better-sqlite3 keytar --pending
+```
+
+如果是全局 npm 安装，使用同一个 Node.js 版本重新安装 CLI：
+
+```bash
+npm uninstall -g @dbx-app/cli
+npm install -g @dbx-app/cli
+```
+
+使用 `dbx capabilities` 查看哪些数据库类型可以直接查询，哪些当前需要 DBX 桌面端：
+
+```bash
+dbx capabilities
+dbx capabilities --json
+```
+
+当前直接执行支持 PostgreSQL/Redshift、MySQL 兼容数据库（MySQL、Doris、StarRocks）和 SQLite。其它数据库类型在对应驱动加入 `@dbx-app/node-core` 前，会使用 DBX 桌面端 bridge。
+
+## 默认连接
+
+设置 `DBX_CONNECTION` 后，`query` 和 `context` 命令可以省略连接名：
+
+```bash
+DBX_CONNECTION=local dbx query "select 1" --json
+DBX_CONNECTION=local dbx context --tables users,orders
+```
+
+## 输出格式
+
+使用 `--json` 或 `--format json` 可以获得稳定的机器可读输出。`--format csv` 适合把查询、连接、Schema 数据传给其它命令行工具。
+
+```bash
+dbx query local "select id, name from users" --format csv
+```
+
+错误会写入 stderr，并返回非零退出码。
+
+## 查询控制
+
+`dbx query` 执行单条 SQL，默认只读。
+
+```bash
+dbx query local "select * from users" --limit 50 --timeout 10s --json
+```
+
+时间支持 `ms`、`s`、`m`，例如 `500ms`、`10s`、`1m`。
+
+非危险写操作需要显式使用 `--allow-writes`：
+
+```bash
+dbx query local "update users set name = 'Ada' where id = 1" --allow-writes
+```
+
+`DROP`、`TRUNCATE`、`ALTER` 等危险 SQL 需要同时显式使用 `--allow-writes` 和 `--allow-dangerous-sql`。
+
+## 以短横线开头的 SQL
+
+如果 SQL 以短横线开头，在 SQL 前加 `--`：
+
+```bash
+dbx query local --json -- "-- comment
+select 1"
+```
+
+## 错误码
+
+CLI JSON 错误使用稳定错误码：
+
+| 错误码                   | 含义                         |
+| ------------------------ | ---------------------------- |
+| `UNKNOWN_OPTION`         | 使用了不支持的参数           |
+| `INVALID_OPTION`         | 参数缺少值或值不合法         |
+| `INVALID_ARGUMENT`       | 位置参数缺失或冲突           |
+| `CONNECTION_STORE_ERROR` | DBX 连接存储存在，但无法读取 |
+| `CONNECTION_NOT_FOUND`   | 找不到指定的 DBX 连接        |
+| `SQL_BLOCKED`            | SQL 被安全规则拦截           |
+| `DBX_NOT_RUNNING`        | DBX 桌面端 bridge 不可用     |
+| `ERROR`                  | 未预期的运行时错误           |
+
+## 桌面端 Deep Link
+
+DBX 桌面端支持通过 `dbx://connection/new` 从浏览器、堡垒机或脚本打开新建连接窗口并预填连接信息。
+
+DSN 模式：
+
+```bash
+open 'dbx://connection/new?url=postgres%3A%2F%2Fapp%3Asecret%40db.internal%3A5432%2Forders'
+```
+
+字段模式：
+
+```bash
+open 'dbx://connection/new?type=mysql&host=127.0.0.1&port=3306&user=root&password=secret&database=test'
+```
+
+支持的字段：
+
+| 字段         | 含义                                                           |
+| ------------ | -------------------------------------------------------------- |
+| `type`       | 数据库类型，例如 `mysql`、`postgres`、`redis`、`mongodb`       |
+| `url`        | 数据库 DSN，建议 URL encode                                    |
+| `name`       | DBX 中显示的连接名；未传时优先使用 `database`，其次使用 `host` |
+| `host`       | 主机地址                                                       |
+| `port`       | 端口                                                           |
+| `user`       | 用户名                                                         |
+| `password`   | 密码                                                           |
+| `database`   | 数据库名；Redis 可传 DB index，例如 `0`                        |
+| `url_params` | 额外连接参数，例如 `sslmode=require`                           |
+| `ssl`        | 是否启用 SSL，`true` 表示启用                                  |
+| `one_time`   | `true` 时自动连接，断开后自动删除连接信息                      |
+
+一次性连接示例：
+
+```bash
+open 'dbx://connection/new?type=redis&host=127.0.0.1&port=6379&user=default&password=secret&database=0&one_time=true'
+```
+
+<Callout type="info">测试系统级 `dbx://` 唤起前，请先安装并启动一次 DBX 桌面端，让系统注册 URL 协议。macOS 可使用 `open 'dbx://connection/new?...'` 测试。</Callout>
+
+## Codex
+
+Codex 可以直接通过 shell 调用 CLI：
+
+```bash
+dbx schema describe local users --json
+dbx context local --tables users,orders | codex exec "Write a retention query"
+```
diff --git a/docs/content/docs/cli.mdx b/docs/content/docs/cli.mdx
new file mode 100644
index 0000000..990b027
--- /dev/null
+++ b/docs/content/docs/cli.mdx
@@ -0,0 +1,187 @@
+---
+title: DBX CLI
+description: Use DBX connections from terminals, scripts, CI, and Codex.
+---
+
+<Callout type="info">DBX CLI is a dedicated command line package for terminal, script, and coding-agent workflows. It shares DBX connection storage and SQL safety rules with the MCP server.</Callout>
+
+## Install
+
+### npm
+
+```bash
+npm install -g @dbx-app/cli
+```
+
+### Homebrew
+
+```bash
+brew tap t8y2/dbx
+brew install dbx-cli
+```
+
+Requires Node.js 22.13.0 or newer.
+
+Check the installed version:
+
+```bash
+dbx --version
+```
+
+## Common Commands
+
+```bash
+dbx doctor
+dbx capabilities
+dbx connections list --json
+dbx connections list --format csv
+dbx schema list local --json
+dbx schema describe local users --json
+dbx query local "select count(*) as total from users" --json
+dbx query local "select id, name from users" --format csv
+dbx query local "select * from users" --limit 50 --timeout 10s --json
+dbx query local --file ./query.sql --json
+dbx context local --tables users,orders
+dbx open local users
+```
+
+## Diagnostics
+
+Use `dbx doctor` to inspect local DBX paths, connection-store health, and whether the desktop bridge is available:
+
+```bash
+dbx doctor
+dbx doctor --json
+```
+
+If `dbx doctor` reports a `NODE_MODULE_VERSION` mismatch after switching Node.js versions, rebuild the native dependencies with the Node.js version you use to run `dbx`:
+
+```bash
+pnpm rebuild better-sqlite3 keytar --pending
+```
+
+For global npm installs, reinstall the CLI with the same Node.js version:
+
+```bash
+npm uninstall -g @dbx-app/cli
+npm install -g @dbx-app/cli
+```
+
+Use `dbx capabilities` to see which database types can be queried directly and which currently require DBX Desktop:
+
+```bash
+dbx capabilities
+dbx capabilities --json
+```
+
+Direct execution currently supports PostgreSQL/Redshift, MySQL-compatible databases (MySQL, Doris, StarRocks), and SQLite. Other database types use the DBX Desktop bridge until their drivers are added to `@dbx-app/node-core`.
+
+## Default Connection
+
+Set `DBX_CONNECTION` to omit the connection name for query and context commands:
+
+```bash
+DBX_CONNECTION=local dbx query "select 1" --json
+DBX_CONNECTION=local dbx context --tables users,orders
+```
+
+## Output Formats
+
+Use `--json` or `--format json` for stable machine-readable output. Use `--format csv` for query, connection, and schema data that should be piped into other command line tools.
+
+```bash
+dbx query local "select id, name from users" --format csv
+```
+
+Errors are written to stderr and return a non-zero exit code.
+
+## Query Controls
+
+`dbx query` executes one SQL statement. It is read-only by default.
+
+```bash
+dbx query local "select * from users" --limit 50 --timeout 10s --json
+```
+
+Durations accept `ms`, `s`, or `m`, such as `500ms`, `10s`, or `1m`.
+
+Use `--allow-writes` for non-dangerous write statements:
+
+```bash
+dbx query local "update users set name = 'Ada' where id = 1" --allow-writes
+```
+
+Dangerous SQL such as `DROP`, `TRUNCATE`, and `ALTER` requires both `--allow-writes` and `--allow-dangerous-sql`.
+
+## SQL Starting With a Dash
+
+Pass `--` before SQL that starts with a dash:
+
+```bash
+dbx query local --json -- "-- comment
+select 1"
+```
+
+## Error Codes
+
+CLI JSON errors use stable codes:
+
+| Code                     | Meaning                                             |
+| ------------------------ | --------------------------------------------------- |
+| `UNKNOWN_OPTION`         | An unsupported flag was provided                    |
+| `INVALID_OPTION`         | A flag is missing a value or has an invalid value   |
+| `INVALID_ARGUMENT`       | Positional arguments are missing or conflicting     |
+| `CONNECTION_STORE_ERROR` | DBX connection storage exists but could not be read |
+| `CONNECTION_NOT_FOUND`   | No DBX connection matched the requested name        |
+| `SQL_BLOCKED`            | SQL safety rules blocked execution                  |
+| `DBX_NOT_RUNNING`        | DBX Desktop bridge is unavailable                   |
+| `ERROR`                  | Unexpected runtime failure                          |
+
+## Desktop Deep Links
+
+DBX Desktop supports `dbx://connection/new` links for opening the new connection dialog from browsers, bastion hosts, or scripts with connection fields prefilled.
+
+DSN mode:
+
+```bash
+open 'dbx://connection/new?url=postgres%3A%2F%2Fapp%3Asecret%40db.internal%3A5432%2Forders'
+```
+
+Field mode:
+
+```bash
+open 'dbx://connection/new?type=mysql&host=127.0.0.1&port=3306&user=root&password=secret&database=test'
+```
+
+Supported fields:
+
+| Field        | Meaning                                                                                  |
+| ------------ | ---------------------------------------------------------------------------------------- |
+| `type`       | Database type, such as `mysql`, `postgres`, `redis`, or `mongodb`                        |
+| `url`        | Database DSN; URL encoding is recommended                                                |
+| `name`       | Display name in DBX; when omitted, DBX uses `database`, then `host`                      |
+| `host`       | Hostname or IP address                                                                   |
+| `port`       | Port                                                                                     |
+| `user`       | Username                                                                                 |
+| `password`   | Password                                                                                 |
+| `database`   | Database name; for Redis this can be a DB index such as `0`                              |
+| `url_params` | Extra connection parameters, such as `sslmode=require`                                   |
+| `ssl`        | Enable SSL when set to `true`                                                            |
+| `one_time`   | Automatically connect when set to `true`, then delete the connection after disconnecting |
+
+One-time connection example:
+
+```bash
+open 'dbx://connection/new?type=redis&host=127.0.0.1&port=6379&user=default&password=secret&database=0&one_time=true'
+```
+
+<Callout type="info">Before testing system-level `dbx://` launches, install and open DBX Desktop once so the operating system can register the URL scheme. On macOS, use `open 'dbx://connection/new?...'` to test it.</Callout>
+
+## Codex
+
+Codex can call the CLI directly from shell tools:
+
+```bash
+dbx schema describe local users --json
+dbx context local --tables users,orders | codex exec "Write a retention query"
+```
diff --git a/docs/content/docs/cloud-sync.cn.mdx b/docs/content/docs/cloud-sync.cn.mdx
new file mode 100644
index 0000000..8cbf1bf
--- /dev/null
+++ b/docs/content/docs/cloud-sync.cn.mdx
@@ -0,0 +1,122 @@
+---
+title: 云同步与备份
+description: 使用 WebDAV、GitHub Gist 或 Gitee 代码片段同步 DBX 连接、设置和 SQL 库。
+---
+
+<Callout type="info">
+DBX 可以把连接配置、界面设置和保存的 SQL 组成一个快照，上传到 WebDAV 或私有代码片段，并在另一台设备恢复。
+</Callout>
+
+在 **设置 → 同步** 中选择同步方式：
+
+- **WebDAV**：适合已有 NAS、Nextcloud、坚果云或其他 WebDAV 服务的用户，支持定时自动上传。
+- **GitHub / Gitee 代码片段**：不需要自己维护服务器，通过私有 Gist 或私有代码片段保存快照。目前需要手动上传和下载。
+
+## 同步哪些内容
+
+| 项目 | 默认行为 |
+| --- | --- |
+| 数据库连接及普通连接参数 | 同步 |
+| 侧边栏布局、固定节点 | 同步 |
+| 保存的 SQL 库 | 同步 |
+| 桌面和编辑器设置 | 同步 |
+| 数据库密码、SSH 密码、代理密码、HTTP 隧道 Token、连接串、AI API Key | 默认不同步；可以选择加密后同步 |
+| JDBC 驱动、插件和本地文件 | 不同步 |
+
+<Callout type="warn">
+下载会用远端快照替换本地连接元信息和保存的 SQL。恢复前请确认代码片段 ID 或 WebDAV 路径正确。
+</Callout>
+
+## GitHub Gist
+
+### 创建访问令牌
+
+推荐使用 GitHub **Fine-grained personal access token**：
+
+[打开 GitHub Fine-grained token 创建页面](https://github.com/settings/personal-access-tokens/new)
+
+<Steps>
+  <Step>### 打开令牌设置 登录 GitHub，进入 **Settings → Developer settings → Personal access tokens → Fine-grained tokens**。</Step>
+  <Step>### 创建令牌 点击 **Generate new token**，设置名称和有效期。</Step>
+  <Step>### 设置权限 在 **Account permissions** 中找到 **Gists**，选择 **Read and write**。不需要授予仓库权限。</Step>
+  <Step>### 保存令牌 创建后立即复制令牌。GitHub 只会完整显示一次。</Step>
+</Steps>
+
+也可以使用 Classic token，但只应勾选 `gist` scope，不要授予无关权限。
+
+### 首次上传
+
+<Steps>
+  <Step>### 选择平台 打开 **设置 → 同步 → GitHub / Gitee**，平台选择 **GitHub Gist**。</Step>
+  <Step>### 填写令牌 将访问令牌粘贴到 **访问令牌**。建议勾选 **加密保存在本机**。</Step>
+  <Step>### 创建 Gist 将 **代码片段 ID** 留空，点击 **上传**。DBX 会创建私有 Gist，并自动保存返回的 ID。</Step>
+</Steps>
+
+DBX 会在 Gist 中保存一个 `dbx-sync.json` 文件。后续上传会更新同一个 Gist，GitHub 会保留 Gist 的修改历史。
+
+### 在另一台设备恢复
+
+1. 打开该私有 Gist，从地址栏复制 ID。地址通常类似 `https://gist.github.com/<实际用户名>/<gist-id>`，最后一段就是 ID。也可以直接访问 `https://gist.github.com/<gist-id>`，GitHub 会跳转到包含实际用户名的地址。
+2. 在新设备填写相同的 GitHub 令牌和 Gist ID。
+3. 点击 **测试**，确认令牌和 ID 可访问。
+4. 点击 **下载** 并确认恢复。
+
+## Gitee 代码片段
+
+### 创建私人令牌
+
+[打开 Gitee 私人令牌页面](https://gitee.com/profile/personal_access_tokens)
+
+<Steps>
+  <Step>### 打开私人令牌页面 登录 Gitee，进入 **设置 → 私人令牌**。</Step>
+  <Step>### 生成新令牌 点击 **生成新令牌**，填写描述。</Step>
+  <Step>### 设置权限 只勾选代码片段（`gists`）相关权限。如果界面只提供合并权限，选择能够读写代码片段的最小权限。</Step>
+  <Step>### 保存令牌 生成后立即复制令牌，并存放在密码管理器中。</Step>
+</Steps>
+
+### 上传与恢复
+
+1. 在 **设置 → 同步 → GitHub / Gitee** 中选择 **Gitee 代码片段**。
+2. 输入私人令牌。首次上传时将代码片段 ID 留空，DBX 会创建私有代码片段并保存 ID。
+3. 在其他设备恢复时，填写同一个代码片段 ID，然后点击 **下载**。
+
+Gitee 代码片段中同样使用 `dbx-sync.json` 文件。
+
+## 同步敏感信息
+
+默认快照不会包含数据库密码等密钥。如果需要在新设备直接恢复密码：
+
+1. 开启 **同步加密后的敏感信息**。
+2. 输入单独的 **同步密码**。
+3. 上传快照。
+4. 在另一台设备下载时输入相同的同步密码。
+
+敏感信息使用 **Argon2id** 派生密钥，并使用 **AES-256-GCM** 加密。访问令牌只会使用设备密钥加密保存在本机，永远不会写入 `dbx-sync.json`。
+
+<Callout type="warn">
+同步密码无法找回。丢失同步密码后，仍可恢复普通连接信息和 SQL，但无法解密远端敏感信息。
+</Callout>
+
+## WebDAV
+
+填写 WebDAV 服务地址、用户名、应用密码和远端快照路径。默认路径为 `DBX/sync/snapshot.json`。
+
+WebDAV 支持定时自动上传。自动上传只在 DBX 运行期间执行；下载始终需要手动确认，避免远端快照意外覆盖本地数据。
+
+## 常见问题
+
+### HTTP 401 或 403
+
+令牌无效、已过期，或没有代码片段读写权限。重新创建最小权限令牌后再测试。
+
+### HTTP 404
+
+代码片段 ID 不正确，或者当前令牌无权访问该私有代码片段。
+
+### 首次上传后在哪里找 ID
+
+DBX 会自动保存 ID。也可以在 GitHub Gist 或 Gitee 代码片段页面的地址栏中查看。
+
+### 多台设备可以同时自动同步吗
+
+代码片段同步目前只支持手动上传和下载，不会自动合并两台设备上的修改。上传前建议先下载最新快照，避免覆盖另一台设备刚上传的版本。
diff --git a/docs/content/docs/cloud-sync.mdx b/docs/content/docs/cloud-sync.mdx
new file mode 100644
index 0000000..d72d596
--- /dev/null
+++ b/docs/content/docs/cloud-sync.mdx
@@ -0,0 +1,122 @@
+---
+title: Cloud Sync and Backup
+description: Sync DBX connections, settings, and saved SQL with WebDAV, GitHub Gist, or Gitee snippets.
+---
+
+<Callout type="info">
+DBX can package connections, application settings, and saved SQL into a snapshot, upload it to WebDAV or a private code snippet, and restore it on another device.
+</Callout>
+
+Choose a provider under **Settings → Sync**:
+
+- **WebDAV**: Best when you already use a NAS, Nextcloud, or another WebDAV service. Supports scheduled uploads.
+- **GitHub / Gitee snippets**: Stores the snapshot in a private Gist or code snippet without requiring your own server. Uploads and downloads are currently manual.
+
+## What Is Synchronized
+
+| Item | Default behavior |
+| --- | --- |
+| Database connections and non-secret options | Synchronized |
+| Sidebar layout and pinned nodes | Synchronized |
+| Saved SQL library | Synchronized |
+| Desktop and editor settings | Synchronized |
+| Database, SSH, proxy, HTTP tunnel, connection string, and AI API secrets | Excluded by default; can be encrypted and synchronized |
+| JDBC drivers, plugins, and local files | Not synchronized |
+
+<Callout type="warn">
+Downloading replaces local connection metadata and saved SQL with the remote snapshot. Verify the snippet ID or WebDAV path before restoring.
+</Callout>
+
+## GitHub Gist
+
+### Create an Access Token
+
+A GitHub **fine-grained personal access token** is recommended:
+
+[Open the GitHub fine-grained token creation page](https://github.com/settings/personal-access-tokens/new)
+
+<Steps>
+  <Step>### Open token settings Sign in to GitHub and open **Settings → Developer settings → Personal access tokens → Fine-grained tokens**.</Step>
+  <Step>### Create a token Select **Generate new token**, then set a name and expiration.</Step>
+  <Step>### Grant permission Under **Account permissions**, set **Gists** to **Read and write**. Repository permissions are not required.</Step>
+  <Step>### Save the token Copy the token immediately. GitHub only displays the complete token once.</Step>
+</Steps>
+
+A classic token also works, but grant only the `gist` scope.
+
+### First Upload
+
+<Steps>
+  <Step>### Select GitHub Open **Settings → Sync → GitHub / Gitee** and select **GitHub Gist**.</Step>
+  <Step>### Enter the token Paste the access token. Enabling **Store encrypted on this device** is recommended.</Step>
+  <Step>### Create the Gist Leave **Snippet ID** empty and select **Upload**. DBX creates a private Gist and stores the returned ID.</Step>
+</Steps>
+
+DBX stores the snapshot as `dbx-sync.json`. Later uploads update the same Gist, and GitHub keeps its revision history.
+
+### Restore on Another Device
+
+1. Open the private Gist and copy its ID from the URL. The URL normally looks like `https://gist.github.com/<actual-username>/<gist-id>`, where the final segment is the ID. You can also open `https://gist.github.com/<gist-id>` and let GitHub redirect to the URL containing the actual username.
+2. Enter the same GitHub token and Gist ID on the new device.
+3. Select **Test** to verify access.
+4. Select **Download** and confirm the restore.
+
+## Gitee Snippets
+
+### Create a Personal Access Token
+
+[Open the Gitee personal access token page](https://gitee.com/profile/personal_access_tokens)
+
+<Steps>
+  <Step>### Open token settings Sign in to Gitee and open **Settings → Personal Access Tokens**.</Step>
+  <Step>### Create a token Select **Generate new token** and enter a description.</Step>
+  <Step>### Grant permission Select only the code snippet (`gists`) permission. If permissions are grouped, choose the smallest permission that allows reading and writing snippets.</Step>
+  <Step>### Save the token Copy the generated token immediately and store it in a password manager.</Step>
+</Steps>
+
+### Upload and Restore
+
+1. Select **Gitee Snippet** under **Settings → Sync → GitHub / Gitee**.
+2. Enter the personal access token. Leave the snippet ID empty on the first upload; DBX creates a private snippet and stores its ID.
+3. To restore elsewhere, enter the same snippet ID and select **Download**.
+
+Gitee snippets also use a `dbx-sync.json` file.
+
+## Synchronizing Secrets
+
+Snapshots exclude credentials by default. To restore passwords on another device:
+
+1. Enable **Synchronize encrypted secrets**.
+2. Enter a separate **sync passphrase**.
+3. Upload the snapshot.
+4. Enter the same passphrase when downloading on another device.
+
+DBX derives the encryption key with **Argon2id** and encrypts secrets using **AES-256-GCM**. Provider access tokens are encrypted with a device-local key and are never written to `dbx-sync.json`.
+
+<Callout type="warn">
+The sync passphrase cannot be recovered. Without it, DBX can still restore non-secret connection settings and saved SQL, but not the encrypted secrets.
+</Callout>
+
+## WebDAV
+
+Enter the WebDAV endpoint, username, application password, and remote snapshot path. The default path is `DBX/sync/snapshot.json`.
+
+WebDAV supports scheduled uploads while DBX is running. Downloads always require confirmation to prevent accidental replacement of local data.
+
+## Troubleshooting
+
+### HTTP 401 or 403
+
+The token is invalid, expired, or missing snippet read/write permission. Create a new least-privilege token and test again.
+
+### HTTP 404
+
+The snippet ID is incorrect, or the current token cannot access the private snippet.
+
+### Where is the ID after the first upload?
+
+DBX stores it automatically. You can also find it in the URL of the GitHub Gist or Gitee snippet page.
+
+### Can multiple devices synchronize automatically?
+
+Snippet synchronization currently uses manual upload and download and does not merge concurrent changes. Download the latest snapshot before uploading to avoid replacing changes from another device.
diff --git a/docs/content/docs/config-export.cn.mdx b/docs/content/docs/config-export.cn.mdx
new file mode 100644
index 0000000..7e72fb5
--- /dev/null
+++ b/docs/content/docs/config-export.cn.mdx
@@ -0,0 +1,45 @@
+---
+title: 配置导出/导入
+description: 导出数据库连接配置（AES-256-GCM 加密），安全地在不同电脑之间迁移。
+---
+
+<Callout type="info">导出你的数据库连接配置（含加密密码），用 AES-256-GCM 加密保护，安全地在不同电脑之间迁移。</Callout>
+
+## 导出
+
+<Steps>
+  <Step>### 发起导出 点击侧边栏顶部的 **导出** 按钮。</Step>
+  <Step>### 设置加密密码 输入密码短语来加密连接密码。</Step>
+  <Step>### 保存文件 选择保存位置。导出文件包含所有连接及密码，已加密。</Step>
+</Steps>
+
+## 导入
+
+<Steps>
+  <Step>### 发起导入 点击侧边栏顶部的 **导入** 按钮。</Step>
+  <Step>### 选择文件并解密 选择导出的文件，输入密码短语解密。</Step>
+  <Step>### 完成 连接导入完成，密码自动恢复。按 名称 + 主机 + 端口 自动去重。</Step>
+</Steps>
+
+## 安全性
+
+- 密码使用 **AES-256-GCM** 加密，密钥通过 **PBKDF2** 派生
+- 没有密码短语无法解密文件
+- 导出文件是标准 JSON 格式，可以通过 U 盘、网盘等方式传输
+- DBX 会把普通连接字段与数据库密码、SSH 密码、SSH 密钥密码、完整连接字符串等密钥信息分开存储；导出时只会在加密文件中重新组合。
+- 请把导出口令当作密钥管理。任何人同时拿到导出文件和口令，都可以恢复其中的连接。
+
+## 向后兼容
+
+导入同样支持旧版本导出的明文 JSON 文件（不含密码）和原始的连接配置数组。
+
+## 包含哪些内容
+
+| 项目                                           | 是否包含                           |
+| ---------------------------------------------- | ---------------------------------- |
+| 连接名称、类型、主机、端口、数据库、颜色       | 包含                               |
+| URL 参数、SSL、SSH、代理、可见数据库设置       | 包含                               |
+| 数据库密码、SSH 密码、SSH 密钥密码、连接字符串 | 包含，并在导出文件中加密           |
+| 厂商 JDBC 驱动 JAR 文件                        | 不包含；目标机器需要重新安装或导入 |
+
+如果要迁移 JDBC 连接，先在这里导出连接配置，再在目标机器通过 [JDBC 插件](/cn/docs/plugins) 安装插件并导入驱动 JAR。
diff --git a/docs/content/docs/config-export.mdx b/docs/content/docs/config-export.mdx
new file mode 100644
index 0000000..419780b
--- /dev/null
+++ b/docs/content/docs/config-export.mdx
@@ -0,0 +1,45 @@
+---
+title: Config Export/Import
+description: Export database connections with AES-256-GCM encrypted passwords. Migrate securely between machines.
+---
+
+<Callout type="info">Export your database connections with encrypted passwords (AES-256-GCM). Securely migrate between machines.</Callout>
+
+## Export
+
+<Steps>
+  <Step>### Start Export Click the **Export** button in the sidebar header.</Step>
+  <Step>### Set Passphrase Enter a passphrase to encrypt your passwords.</Step>
+  <Step>### Save File Choose a save location. The exported file contains all connections with passwords, encrypted.</Step>
+</Steps>
+
+## Import
+
+<Steps>
+  <Step>### Start Import Click the **Import** button in the sidebar header.</Step>
+  <Step>### Select File and Decrypt Select the exported file and enter the passphrase.</Step>
+  <Step>### Done Connections are imported with passwords restored. Deduplicated by name + host + port.</Step>
+</Steps>
+
+## Security
+
+- Passwords are encrypted using **AES-256-GCM** with **PBKDF2** key derivation
+- Without the passphrase, the file cannot be decrypted
+- The export file is standard JSON, transferable via USB drive, cloud storage, etc.
+- DBX stores ordinary connection fields separately from secrets such as database passwords, SSH passwords, SSH key passphrases, and full connection strings; export brings them together only inside the encrypted export file.
+- Treat the passphrase like a secret. Anyone with both the export file and passphrase can restore the saved connections.
+
+## Backward Compatibility
+
+Import also supports plain JSON files from older versions (without passwords) and raw connection config arrays.
+
+## What Is Included
+
+| Item                                                                   | Included                                                 |
+| ---------------------------------------------------------------------- | -------------------------------------------------------- |
+| Connection name, type, host, port, database, color                     | Yes                                                      |
+| URL parameters, SSL, SSH, proxy, visible database settings             | Yes                                                      |
+| Database password, SSH password, SSH key passphrase, connection string | Yes, encrypted in the export file                        |
+| Vendor JDBC driver JAR files                                           | No; reinstall or re-import drivers on the target machine |
+
+For JDBC migrations, export the connection settings here, then use [JDBC Plugin](/en/docs/plugins) to install the plugin and import driver JARs on the destination machine.
diff --git a/docs/content/docs/connection-import.cn.mdx b/docs/content/docs/connection-import.cn.mdx
new file mode 100644
index 0000000..b85b6cc
--- /dev/null
+++ b/docs/content/docs/connection-import.cn.mdx
@@ -0,0 +1,52 @@
+---
+title: 连接导入
+description: 从 Navicat 和 DBeaver 导入连接，切换工具时无需重新输入连接信息。
+---
+
+DBX 可以从其他数据库工具导入连接，在切换工具时无需手动重新创建大量连接。
+
+## 支持的格式
+
+| 来源    | 格式            | 导入内容                                 |
+| ------- | --------------- | ---------------------------------------- |
+| Navicat | `.ncx` 导出文件 | 主机、端口、用户名、数据库类型、连接名称 |
+| DBeaver | 连接配置文件    | 主机、端口、用户名、数据库类型、连接名称 |
+
+<Callout type="info">导入的连接保留原始连接名称和类型。其他工具以加密格式存储的密码无法解密——导入后需要重新输入密码。</Callout>
+
+## 导入 Navicat 连接
+
+<Steps>
+  <Step>### 从 Navicat 导出 在 Navicat 中，选择要迁移的连接。使用**文件 → 导出连接**并保存 `.ncx` 文件。</Step>
+  <Step>### 打开导入对话框 在 DBX 中，前往**设置 → 导入连接**，或右键点击侧边栏分组标题选择**导入连接**。</Step>
+  <Step>### 选择 NCX 文件 选择从 Navicat 导出的 `.ncx` 文件。</Step>
+  <Step>### 检查并完成 DBX 解析文件并列出所有找到的连接。检查列表，在需要处重新输入密码并保存。</Step>
+</Steps>
+
+## 导入 DBeaver 连接
+
+<Steps>
+  <Step>### 找到 DBeaver 配置 DBeaver 将连接存储在其工作区目录中。具体路径取决于操作系统和 DBeaver 版本。常见位置包括 `~/.local/share/DBeaverData/workspace6/General/.dbeaver/`。</Step>
+  <Step>### 打开导入对话框 在 DBX 中，前往**设置 → 导入连接**。</Step>
+  <Step>### 选择 DBeaver 文件 选择 DBeaver 连接配置文件（`.dbeaver-data-sources.xml` 或类似文件）。</Step>
+  <Step>### 检查并完成 DBX 从配置中提取连接信息。重新输入无法解密的密码。</Step>
+</Steps>
+
+## 导入后
+
+导入的连接与手动创建的连接一同出现在侧边栏中。你应该：
+
+- **测试每个连接**以验证导入的设置是否正常工作
+- **设置密码**，用于原始密码无法导入的连接
+- **分配连接颜色**以区分生产、测试和开发环境
+- **配置 SSH 隧道**，用于需要隧道访问的连接
+- **设置可见数据库过滤**，如果服务器包含大量数据库
+
+## 无法导入的内容
+
+| 设置           | 原因                                             |
+| -------------- | ------------------------------------------------ |
+| 加密密码       | 每个工具使用各自的加密方式，密码需要重新输入     |
+| SSH 隧道密钥   | 密钥文件路径可能因机器而异，需要重新选择密钥文件 |
+| 自定义驱动配置 | 驱动路径和版本是工具特定的                       |
+| 代理设置       | 在连接的代理标签页中重新配置                     |
diff --git a/docs/content/docs/connection-import.mdx b/docs/content/docs/connection-import.mdx
new file mode 100644
index 0000000..e851683
--- /dev/null
+++ b/docs/content/docs/connection-import.mdx
@@ -0,0 +1,52 @@
+---
+title: Connection Import
+description: Import connections from Navicat and DBeaver so you can switch to DBX without re-entering connection details.
+---
+
+DBX can import connections from other database tools, saving you from manually re-creating dozens of connections when switching tools.
+
+## Supported Formats
+
+| Source  | Format                         | What's Imported                                      |
+| ------- | ------------------------------ | ---------------------------------------------------- |
+| Navicat | `.ncx` export files            | Host, port, username, database type, connection name |
+| DBeaver | Connection configuration files | Host, port, username, database type, connection name |
+
+<Callout type="info">Imported connections preserve the original connection name and type. Passwords stored in encrypted format by other tools cannot be decrypted — you will need to re-enter passwords after import.</Callout>
+
+## Import Navicat Connections
+
+<Steps>
+  <Step>### Export from Navicat In Navicat, select the connections you want to migrate. Use **File → Export Connections** and save the `.ncx` file.</Step>
+  <Step>### Open Import Dialog In DBX, go to **Settings → Import Connections** or right-click the sidebar group header and choose **Import Connections**.</Step>
+  <Step>### Select the NCX File Choose the `.ncx` file you exported from Navicat.</Step>
+  <Step>### Review and Complete DBX parses the file and lists all found connections. Review the list, re-enter passwords where needed, and save.</Step>
+</Steps>
+
+## Import DBeaver Connections
+
+<Steps>
+  <Step>### Locate DBeaver Configuration DBeaver stores connections in its workspace directory. The exact path depends on your OS and DBeaver version. Common locations include `~/.local/share/DBeaverData/workspace6/General/.dbeaver/`.</Step>
+  <Step>### Open Import Dialog In DBX, go to **Settings → Import Connections**.</Step>
+  <Step>### Select DBeaver Files Choose the DBeaver connection configuration files (`.dbeaver-data-sources.xml` or similar).</Step>
+  <Step>### Review and Complete DBX extracts connection details from the configuration. Re-enter any passwords that could not be decrypted.</Step>
+</Steps>
+
+## After Import
+
+Imported connections appear in the sidebar alongside manually created ones. You should:
+
+- **Test each connection** to verify the imported settings work
+- **Set passwords** for connections where the original password could not be imported
+- **Assign connection colors** to distinguish production, staging, and development environments
+- **Configure SSH tunnels** for connections that require them
+- **Set visible database filters** if the server contains many databases
+
+## What Cannot Be Imported
+
+| Setting                      | Reason                                                              |
+| ---------------------------- | ------------------------------------------------------------------- |
+| Encrypted passwords          | Each tool uses proprietary encryption; passwords must be re-entered |
+| SSH tunnel keys              | Key file paths may differ between machines; re-select the key file  |
+| Custom driver configurations | Driver paths and versions are tool-specific                         |
+| Proxy settings               | Re-configure in the connection's Proxy tab                          |
diff --git a/docs/content/docs/data-grid.cn.mdx b/docs/content/docs/data-grid.cn.mdx
new file mode 100644
index 0000000..90a81a8
--- /dev/null
+++ b/docs/content/docs/data-grid.cn.mdx
@@ -0,0 +1,166 @@
+---
+title: 数据表格
+description: 在 DBX 中浏览、筛选、编辑、预览 SQL 并导出表数据。
+---
+
+数据表格用于查看查询结果或表数据。它适合处理两类场景：快速浏览数据，以及在确认 SQL 后进行小范围数据修改。
+
+## 浏览数据
+
+DBX 使用虚拟滚动渲染表格，只渲染当前可视区域内的行。大表浏览时，滚动和选择操作不会因为一次性渲染所有行而明显变慢。
+
+常用浏览操作：
+
+- 拖拽列边缘调整列宽
+- 双击列边缘根据内容自适应列宽
+- 点击列头排序
+- 使用行号定位数据
+- 打开单元格详情查看长文本、JSON 或其他复杂值
+
+## 过滤与排序
+
+| 功能     | 适合场景                                 |
+| -------- | ---------------------------------------- |
+| 搜索     | 在当前结果中快速定位包含关键字的行       |
+| WHERE    | 在数据库层面筛选数据，适合大表和精确条件 |
+| ORDER BY | 在数据库层面排序，适合稳定复现查询结果   |
+
+<Callout type="info">大表场景优先使用 `WHERE` 和 `ORDER BY`。它们在数据库层面执行，通常比客户端搜索更稳定。</Callout>
+
+## 行内编辑
+
+可以直接在表格里修改数据：
+
+- **修改单元格**：双击单元格进入编辑状态
+- **新增行**：在表格中添加一行待插入记录
+- **删除行**：选中行后标记为待删除
+- **设置 NULL**：在单元格详情面板中明确写入 `NULL`
+
+所有修改都会先暂存在本地。保存前，DBX 会展示即将执行的 SQL。
+
+## 什么时候可以编辑
+
+当 DBX 能识别目标表，并且有足够的键信息生成可审查的 `UPDATE`、`INSERT` 或 `DELETE` 语句时，结果才可编辑。直接打开表数据通常可以编辑；临时 join、聚合、表达式或没有可用主键/行标识的结果会视为只读。
+
+| 结果类型                   | 通常行为                             |
+| -------------------------- | ------------------------------------ |
+| 打开的表数据               | 数据库和表支持时可编辑               |
+| 简单 `SELECT * FROM table` | 有主键或行标识时通常可编辑           |
+| Join、聚合、计算列         | 只读结果                             |
+| Redis 或 MongoDB 视图      | 使用对应专用编辑器，不走关系型行 SQL |
+
+## SQL 预览
+
+<Callout type="warn">数据修改不会在编辑后立即写入数据库。点击保存前，请先检查 SQL 预览，尤其是在生产环境连接上。</Callout>
+
+SQL 预览会展示 `UPDATE`、`INSERT` 或 `DELETE` 语句。这个步骤可以帮助你确认：
+
+- 更新条件是否正确
+- 新增行的字段是否完整
+- 删除操作是否命中预期行
+- `NULL`、空字符串和默认值是否符合预期
+
+如果预览 SQL 的影响范围过大，请取消保存，先缩小筛选条件或选择范围。
+
+## 单元格详情
+
+点击单元格可以打开详情面板。它适合处理表格内不方便直接编辑的值：
+
+- 长文本
+- JSON
+- SQL 片段
+- 多行内容
+- 需要显式设置为 `NULL` 的字段
+
+## 转置视图
+
+切换转置视图可互换行和列。适用场景：
+
+- 表有很多列但行数较少
+- 需要并排比较列的元数据（类型、默认值、可空标志）
+- 查看具有宽列的单个行
+
+转置视图保留所有表格功能：排序、过滤、编辑和导出均可正常使用。
+
+## 列格式化器
+
+自定义列格式化器让你控制特定列值的显示方式：
+
+- **日期时间格式化**：为日期和时间列选择显示格式
+- **JSON 路径提取**：使用 JSONPath 表达式从 JSON/JSONB 列中提取特定字段
+- **值掩码**：隐藏或部分掩码敏感值
+- **自定义模板**：为列定义自己的显示模板
+
+从列头菜单配置格式化器。格式化器仅影响显示——不会更改底层数据。
+
+## 单元格详情编辑器
+
+单元格详情面板为单个单元格值提供完整的编辑器：
+
+- **值编辑器**：在更大的文本区域中编辑单元格内容，JSON 和 SQL 具有语法高亮
+- **设置 NULL**：将单元格显式设置为 NULL
+- **图片预览**：当单元格包含图片 URL 时，详情面板会显示渲染后的预览
+- **时间编辑器**：日期和时间单元格使用专用的日期/时间选择器
+
+## 多行操作
+
+选中多行执行批量操作：
+
+- **批量克隆**：一次性复制多行
+- **批量删除**：一次性标记多行为待删除
+- **批量复制**：以 TSV、CSV、JSON、Markdown 或 INSERT 语句格式复制多行
+- **复制为 INSERT**：生成包含多行值的单条 `INSERT` 语句
+- **复制为 UPDATE**：为选中的行生成 `UPDATE` 语句
+- **复制不含主键**：生成排除自增主键的 INSERT 语句
+
+## 列头控件
+
+列头提供快速操作入口：
+
+- **排序**：点击切换升序、降序或清除排序。右键点击可打开排序上下文菜单。
+- **列可见性**：从可搜索的清单中显示或隐藏列
+- **本地列过滤**：通过勾选特定值在当前结果集中过滤
+- **紧凑模式**：在设置中启用后，列头操作（排序、格式化、过滤）收起为单个下拉菜单，给列名留出更多空间
+- **紧凑过滤构建器**：在紧凑 UI 中使用多个条件构建复杂的客户端过滤
+- **拖放列重排序**：点击并拖动列头即可重新排序。列顺序按表/查询保存，跨会话持久化
+
+## 单元格详情编辑器
+
+单元格详情面板为单个单元格值提供完整的编辑器：
+
+- **值编辑器**：在更大的文本区域中编辑单元格内容，JSON 和 SQL 具有语法高亮
+- **设置 NULL**：将单元格显式设置为 NULL
+- **图片预览**：当单元格包含图片 URL 时，详情面板会显示渲染后的预览
+- **时间编辑器**：日期和时间单元格使用专用的日期/时间选择器
+- **二进制数据十六进制查看器**：以十六进制格式查看二进制数据，同时显示十六进制和 ASCII 表示，便于检查原始二进制内容
+
+## 导出与复制
+
+| 格式     | 用途                                                   |
+| -------- | ------------------------------------------------------ |
+| CSV      | 给 Excel、Numbers 或其他表格工具使用                   |
+| JSON     | 给脚本、接口调试或程序处理使用                         |
+| Markdown | 粘贴到 Issue、PR、文档或聊天中                         |
+| INSERT   | 将选中行复制为可执行的 `INSERT` 语句（支持单行或批量） |
+| UPDATE   | 将选中行复制为可执行的 `UPDATE` 语句                   |
+| XLSX     | 从表格上下文菜单直接导出为 Excel 格式                  |
+
+### 复制带表头
+
+DBX 支持在复制数据时包含列头：
+
+- **复制列名**：只复制当前选择的列名
+- **复制选择区域与表头**：复制选中的单元格及其列头
+- **复制为带表头的 TSV/CSV**：在制表符分隔或逗号分隔输出中包含表头
+
+这在将数据粘贴到电子表格、文档或分享查询结果时特别有用，可以保留列的上下文信息。
+
+导出前建议先确认当前筛选和排序条件，避免导出范围和预期不一致。
+
+## 分页与大结果集
+
+DBX 会通过分页和虚拟滚动让大结果集保持响应。面对大表时，优先使用数据库侧的 `WHERE` 和 `ORDER BY`，不要只依赖客户端搜索；数据库可以利用索引，并返回更小的结果集。分页大小可配置并跨会话持久化。
+
+### 行号显示
+
+数据表格在最左侧列显示行号。在翻页浏览大结果集时，行号会反映当前页面位置，帮助你跟踪正在查看的记录。当应用排序或筛选时，行号会自动调整。
diff --git a/docs/content/docs/data-grid.mdx b/docs/content/docs/data-grid.mdx
new file mode 100644
index 0000000..ee38f22
--- /dev/null
+++ b/docs/content/docs/data-grid.mdx
@@ -0,0 +1,166 @@
+---
+title: Data Grid
+description: Browse, filter, edit, preview SQL, and export table data in DBX.
+---
+
+The data grid displays query results and table data. It is designed for two common workflows: inspecting data quickly and making small, reviewable edits.
+
+## Browse Data
+
+DBX uses virtual scrolling, rendering only the rows visible on screen. Large tables remain responsive because the grid does not render every row at once.
+
+Common browsing actions:
+
+- Drag column borders to resize columns
+- Double-click a column border to auto-fit width
+- Click column headers to sort
+- Use row numbers to locate records
+- Open cell details for long text, JSON, or other complex values
+
+## Filter and Sort
+
+| Feature  | Best For                                                        |
+| -------- | --------------------------------------------------------------- |
+| Search   | Finding rows in the current result set                          |
+| WHERE    | Database-level filtering for large tables or precise conditions |
+| ORDER BY | Database-level ordering for reproducible results                |
+
+<Callout type="info">For large tables, prefer `WHERE` and `ORDER BY`. They run in the database and are usually more reliable than client-side search.</Callout>
+
+## Inline Editing
+
+You can edit data directly in the grid:
+
+- **Update a cell**: double-click a cell and edit its value
+- **Insert a row**: add a pending row in the grid
+- **Delete rows**: select rows and mark them for deletion
+- **Set NULL**: explicitly write `NULL` from the cell detail panel
+
+All changes are staged locally first. Before saving, DBX shows the SQL it is about to execute.
+
+## When Editing Is Available
+
+Editing is available when DBX can identify the target table and enough key information to generate reviewable `UPDATE`, `INSERT`, or `DELETE` statements. Simple table browsing is usually editable. Ad-hoc joins, aggregates, expressions, or result sets without usable keys are treated as read-only.
+
+| Result Type                         | Typical Behavior                                           |
+| ----------------------------------- | ---------------------------------------------------------- |
+| Opened table data                   | Editable when the database and table support edits         |
+| Simple `SELECT * FROM table`        | Often editable if primary key or row identity is available |
+| Joins, aggregates, computed columns | Read-only result set                                       |
+| Redis or MongoDB views              | Use their dedicated editors instead of relational row SQL  |
+
+## SQL Preview
+
+<Callout type="warn">Edits are not written to the database immediately. Before saving, review the SQL preview carefully, especially on production connections.</Callout>
+
+The preview shows `UPDATE`, `INSERT`, or `DELETE` statements. Use it to confirm:
+
+- Update conditions target the intended rows
+- Inserted rows contain the expected fields
+- Delete operations match the expected records
+- `NULL`, empty strings, and default values are handled correctly
+
+If the preview looks too broad, cancel the save and narrow the filter or selection first.
+
+## Cell Details
+
+Click a cell to open the detail panel. It is useful for values that are awkward to edit directly inside a table:
+
+- Long text
+- JSON
+- SQL fragments
+- Multi-line content
+- Fields that should be explicitly set to `NULL`
+
+## Transpose View
+
+Toggle the transpose view to swap rows and columns. This is useful when:
+
+- A table has many columns but few rows
+- You want to compare column metadata (types, defaults, nullable flags) side by side
+- You are inspecting a single row with wide columns
+
+The transpose view preserves all grid features: sorting, filtering, editing, and export work the same way.
+
+## Column Formatters
+
+Custom column formatters let you control how specific column values are displayed:
+
+- **Datetime formatting**: Choose a display format for date and time columns
+- **JSON path extraction**: Extract a specific field from JSON/JSONB columns using a JSONPath expression
+- **Value masking**: Hide or partially mask sensitive values
+- **Custom templates**: Define your own display template for a column
+
+Configure formatters from the column header menu. Formatters only affect display — they do not change the underlying data.
+
+## Cell Detail Editor
+
+The cell detail panel provides a full editor for individual cell values:
+
+- **Value editor**: Edit cell content in a larger text area with syntax highlighting for JSON and SQL
+- **Set NULL**: Explicitly write NULL to a cell
+- **Image preview**: When a cell contains an image URL, the detail panel shows a rendered preview
+- **Temporal editor**: Date and time cells use a dedicated date/time picker
+
+## Multi-Row Operations
+
+Select multiple rows to perform batch operations:
+
+- **Batch clone**: Duplicate multiple rows at once
+- **Batch delete**: Mark multiple rows for deletion in one action
+- **Batch copy**: Copy multiple rows as TSV, CSV, JSON, Markdown, or INSERT statements
+- **Copy as INSERT**: Generate a single `INSERT` statement with multiple value rows
+- **Copy as UPDATE**: Generate `UPDATE` statements for selected rows
+- **Copy without primary keys**: Generate INSERT statements that exclude auto-increment primary keys
+
+## Header Controls
+
+Column headers provide quick access to actions:
+
+- **Sort**: Click to toggle ascending, descending, or clear sort. Right-click for context menu with sort options.
+- **Column visibility**: Show or hide columns from a filterable checklist
+- **Local column filter**: Filter values within the current result set by checking specific values
+- **Compact mode**: When enabled in Settings, header actions (sort, format, filter) collapse into a single dropdown menu, giving column names more space
+- **Compact filter builder**: Build complex client-side filters with multiple conditions in a compact UI
+- **Drag-and-drop column reordering**: Click and drag column headers to reorder them. Column order is saved per table/query and persists across sessions
+
+## Cell Detail Editor
+
+The cell detail panel provides a full editor for individual cell values:
+
+- **Value editor**: Edit cell content in a larger text area with syntax highlighting for JSON and SQL
+- **Set NULL**: Explicitly write NULL to a cell
+- **Image preview**: When a cell contains an image URL, the detail panel shows a rendered preview
+- **Temporal editor**: Date and time cells use a dedicated date/time picker
+- **Binary data hex viewer**: View binary data in hexadecimal format with both hex and ASCII representations, making it easy to inspect raw binary content
+
+## Export and Copy
+
+| Format   | Use Case                                                                 |
+| -------- | ------------------------------------------------------------------------ |
+| CSV      | Excel, Numbers, or spreadsheet tools                                     |
+| JSON     | Scripts, API debugging, or programmatic processing                       |
+| Markdown | Issues, PRs, documentation, or chat                                      |
+| INSERT   | Copy selected rows as executable `INSERT` statements (single or batched) |
+| UPDATE   | Copy selected rows as executable `UPDATE` statements                     |
+| XLSX     | Export directly to Excel format from the table context menu              |
+
+### Copy with Headers
+
+DBX supports copying data with column headers included:
+
+- **Copy column names**: Copy just the column names from the current selection
+- **Copy selection with headers**: Copy selected cells along with their column headers
+- **Copy as TSV/CSV with headers**: Include headers in tab-separated or comma-separated output
+
+This is especially useful when pasting data into spreadsheets, documentation, or sharing query results where column context is important.
+
+Before exporting, check the active filters and sort order so the exported data matches what you expect.
+
+## Pagination And Large Results
+
+DBX can page result sets and keep large grids responsive with virtual scrolling. For large tables, prefer database-side `WHERE` and `ORDER BY` clauses instead of relying only on client search, because the database can use indexes and return a smaller result set. Page size is configurable and persists across sessions.
+
+### Row Number Display
+
+The data grid shows row numbers in the leftmost column. When paging through large result sets, row numbers reflect the current page position and help you track which records you're viewing. Row numbers automatically adjust when you apply sorting or filtering.
diff --git a/docs/content/docs/data-transfer.cn.mdx b/docs/content/docs/data-transfer.cn.mdx
new file mode 100644
index 0000000..db27b03
--- /dev/null
+++ b/docs/content/docs/data-transfer.cn.mdx
@@ -0,0 +1,96 @@
+---
+title: 数据传输
+description: 在不同连接或不同数据库引擎之间迁移表数据。
+---
+
+数据传输用于把表数据从一个连接复制到另一个连接。它适合开发、测试、迁移和数据整合场景，但不应该替代正式的数据同步链路。
+
+## 适合的场景
+
+- 把生产库的一部分数据复制到开发环境
+- 在 MySQL、PostgreSQL、SQLite、SQL Server 等引擎之间迁移数据
+- 将多个数据源整理到同一个分析库
+- 为测试环境准备一份可复现的数据集
+
+<Callout type="warn">跨引擎传输会涉及类型映射、默认值、约束和自增字段差异。传输完成后请抽样检查数据，重要迁移建议先在测试环境演练。</Callout>
+
+## 使用流程
+
+<Steps>
+  <Step>
+    ### 选择源连接
+
+    源连接是数据读取的位置。确认账号有读取目标表的权限。
+
+  </Step>
+  <Step>
+    ### 选择目标连接
+
+    目标连接是数据写入的位置。确认账号有写入权限，并确认目标库环境无误。
+
+  </Step>
+  <Step>
+    ### 选择表
+
+    可以传输全部表，也可以只选择需要的表。大表建议分批处理。
+
+  </Step>
+  <Step>
+    ### 开始传输
+
+    DBX 会按表读取数据，并根据所选模式写入目标数据库。可选择是否创建目标表。
+
+  </Step>
+  <Step>
+    ### 检查结果
+
+    传输完成后检查行数、错误列表和关键字段。
+
+  </Step>
+</Steps>
+
+## 传输过程
+
+DBX 会在传输过程中展示：
+
+- 当前正在处理的表
+- 已传输行数
+- 总体进度
+- 错误信息和对应表名
+
+如果某张表失败，当前传输会停止并展示错误信息。修正表结构、权限或约束问题后，可以重新发起传输。
+
+## 传输选项
+
+| 选项       | 说明                                       |
+| ---------- | ------------------------------------------ |
+| 创建目标表 | 目标库没有对应表时，尝试根据源表结构创建   |
+| 追加       | 将数据插入目标表现有数据之后               |
+| 覆盖       | 先清空目标表，再写入源数据                 |
+| Upsert     | 在目标数据库路径支持时使用基于键的写入行为 |
+| 批大小     | 控制每批写入的行数                         |
+
+## 数据库覆盖范围
+
+基于 SQL 的数据传输支持 MySQL、PostgreSQL、SQLite、SQL Server、Oracle、ClickHouse、DuckDB、DM 和 GaussDB。跨引擎传输会经过 DBX 的类型映射层，传输后请检查行数和关键字段值。
+
+## 传输前检查
+
+| 检查项   | 原因                                     |
+| -------- | ---------------------------------------- |
+| 目标环境 | 避免误写生产库或错误环境                 |
+| 表结构   | 字段名、类型、主键和唯一约束会影响写入   |
+| 数据量   | 大表可能需要更长时间，也可能触发超时     |
+| 约束     | 外键、唯一约束、非空字段可能导致写入失败 |
+| 敏感数据 | 从生产复制到低环境前，确认是否需要脱敏   |
+
+## 相关功能
+
+<Cards>
+  <Card title="表数据导入" href="/cn/docs/table-import">
+    从 CSV、TSV、JSON 或 Excel 导入到单张表。
+  </Card>
+  <Card title="数据库导出" href="/cn/docs/database-export">
+    将数据库导出为 SQL 文件，便于备份或离线迁移。
+  </Card>
+</Cards>
diff --git a/docs/content/docs/data-transfer.mdx b/docs/content/docs/data-transfer.mdx
new file mode 100644
index 0000000..a801bad
--- /dev/null
+++ b/docs/content/docs/data-transfer.mdx
@@ -0,0 +1,96 @@
+---
+title: Data Transfer
+description: Move table data between connections or database engines.
+---
+
+Data Transfer copies table data from one connection to another. Use it for development, testing, migration, and consolidation workflows. It is not a replacement for a production-grade replication pipeline.
+
+## Use Cases
+
+- Copy part of production data into a development environment
+- Move data between engines such as MySQL, PostgreSQL, SQLite, and SQL Server
+- Consolidate multiple sources into an analysis database
+- Prepare reproducible datasets for testing
+
+<Callout type="warn">Cross-engine transfer involves type mapping, defaults, constraints, and auto-increment differences. Validate transferred data afterward, and rehearse important migrations in a test environment first.</Callout>
+
+## Workflow
+
+<Steps>
+  <Step>
+    ### Select the Source
+
+    The source connection is where data is read from. Confirm the account can read the selected tables.
+
+  </Step>
+  <Step>
+    ### Select the Target
+
+    The target connection is where data is written. Confirm write permissions and verify the target environment.
+
+  </Step>
+  <Step>
+    ### Choose Tables
+
+    Transfer all tables or select only the tables you need. For large tables, consider transferring in smaller batches.
+
+  </Step>
+  <Step>
+    ### Start Transfer
+
+    DBX reads rows table by table and writes them to the target database using the selected mode. You can also choose whether target tables should be created.
+
+  </Step>
+  <Step>
+    ### Check Results
+
+    After transfer, inspect row counts, errors, and key fields.
+
+  </Step>
+</Steps>
+
+## During Transfer
+
+DBX shows:
+
+- Current table
+- Rows transferred
+- Overall progress
+- Errors and the table that caused each error
+
+If a table fails, the current transfer stops and shows the error. Fix the structure, permission, or constraint issue, then start the transfer again.
+
+## Transfer Options
+
+| Option              | Details                                                                         |
+| ------------------- | ------------------------------------------------------------------------------- |
+| Create target table | Try to create the target table from the source structure when it does not exist |
+| Append              | Insert data after existing target rows                                          |
+| Overwrite           | Clear the target table before writing source rows                               |
+| Upsert              | Use key-aware write behavior where the target database path supports it         |
+| Batch size          | Control how many rows are written per batch                                     |
+
+## Database Coverage
+
+SQL-based transfer is available for MySQL, PostgreSQL, SQLite, SQL Server, Oracle, ClickHouse, DuckDB, DM, and GaussDB. Cross-engine transfers use DBX's type mapping layer, so always verify row counts and important column values after transfer.
+
+## Before You Transfer
+
+| Check              | Why It Matters                                                          |
+| ------------------ | ----------------------------------------------------------------------- |
+| Target environment | Avoid writing to the wrong database                                     |
+| Table structure    | Field names, types, primary keys, and unique constraints affect inserts |
+| Data volume        | Large tables may take longer or hit timeouts                            |
+| Constraints        | Foreign keys, unique constraints, and NOT NULL fields may fail writes   |
+| Sensitive data     | Production data may need masking before copying into lower environments |
+
+## Related Features
+
+<Cards>
+  <Card title="Table Import" href="/en/docs/table-import">
+    Import CSV, TSV, JSON, or Excel into a single table.
+  </Card>
+  <Card title="Database Export" href="/en/docs/database-export">
+    Export a database as SQL for backup or offline migration.
+  </Card>
+</Cards>
diff --git a/docs/content/docs/database-export.cn.mdx b/docs/content/docs/database-export.cn.mdx
new file mode 100644
index 0000000..41e0669
--- /dev/null
+++ b/docs/content/docs/database-export.cn.mdx
@@ -0,0 +1,78 @@
+---
+title: 数据库导出
+description: 将数据库结构和数据导出为 SQL 文件，用于备份、迁移或创建测试数据集。
+---
+
+数据库导出会把表结构和表数据写入 SQL 文件。它适合在执行高风险操作前备份、迁移小型数据库，或为开发测试准备可复现的数据集。
+
+## 导出内容
+
+| 内容     | 说明                                            |
+| -------- | ----------------------------------------------- |
+| 表结构   | `CREATE TABLE`、字段、主键、索引、约束等 DDL    |
+| 表数据   | 以 `INSERT` 语句形式导出                        |
+| 批量插入 | 多行合并为一条 `INSERT`，减少文件体积和导入成本 |
+| 对象     | 数据库可提供源码时导出视图、存储过程和函数      |
+
+示例：
+
+```sql
+INSERT INTO users (id, name, email) VALUES
+  (1, '张三', 'zhangsan@example.com'),
+  (2, '李四', 'lisi@example.com'),
+  (3, '王五', 'wangwu@example.com');
+```
+
+## 使用流程
+
+<Steps>
+  <Step>
+    ### 选择连接和数据库
+
+    选择要导出的连接和数据库，确认当前环境无误。
+
+  </Step>
+  <Step>
+    ### 设置导出选项
+
+    选择是否包含结构、数据和数据库对象。可以导出全部表，也可以只导出选中的表。
+
+  </Step>
+  <Step>
+    ### 选择保存位置
+
+    选择 `.sql` 文件保存路径。
+
+  </Step>
+  <Step>
+    ### 开始导出
+
+    DBX 会生成 SQL 文件，并展示当前对象、进度、行数、错误和取消状态。
+
+  </Step>
+</Steps>
+
+## 批量与选择
+
+DBX 会分批读取表数据，并把生成的 `INSERT` 语句写入输出文件。如果没有设置批大小，默认每批 1000 行。
+
+选择部分表导出时，DBX 会先过滤表列表，再生成 DDL 和数据。视图、存储过程、函数等对象只会在启用对象导出且没有限定表子集时一起导出。
+
+<Callout type="info">MySQL 导出会在表内容前写入 `SET FOREIGN_KEY_CHECKS = 0`，并在文件末尾重新启用。</Callout>
+
+## 取消与错误
+
+导出可以在对象之间或行批次之间取消。如果某张表或某个对象无法导出，DBX 会在 SQL 文件中写入包含错误的注释，并在可能的情况下继续导出剩余内容。
+
+## 导入导出文件
+
+导出的 `.sql` 文件可以通过 [SQL 文件执行](/cn/docs/sql-file) 导入到数据库中。
+
+<Callout type="warn">导出文件可能包含敏感数据、账号信息、业务标识或用户隐私。分享前请确认是否需要脱敏。</Callout>
+
+## 使用建议
+
+- 高风险 Schema 操作前先导出备份
+- 迁移前先在测试库验证导入结果
+- 大型生产库或需要完整备份的场景更适合使用数据库原生备份工具
+- 导出的 SQL 文件建议妥善保存，避免提交到公开代码仓库
diff --git a/docs/content/docs/database-export.mdx b/docs/content/docs/database-export.mdx
new file mode 100644
index 0000000..1a9735a
--- /dev/null
+++ b/docs/content/docs/database-export.mdx
@@ -0,0 +1,78 @@
+---
+title: Database Export
+description: Export database structure and data as SQL for backup, migration, or test datasets.
+---
+
+Database Export writes table structure and table data into a SQL file. Use it before high-risk operations, for small database migrations, or to create reproducible development and test datasets.
+
+## What Gets Exported
+
+| Content         | Details                                                                         |
+| --------------- | ------------------------------------------------------------------------------- |
+| Structure       | `CREATE TABLE`, columns, primary keys, indexes, constraints, and other DDL      |
+| Data            | Rows exported as `INSERT` statements                                            |
+| Batched inserts | Multiple rows grouped into one `INSERT` to reduce file size and import overhead |
+| Objects         | Views, procedures, and functions where the database exposes source definitions  |
+
+Example:
+
+```sql
+INSERT INTO users (id, name, email) VALUES
+  (1, 'Alice', 'alice@example.com'),
+  (2, 'Bob', 'bob@example.com'),
+  (3, 'Carol', 'carol@example.com');
+```
+
+## Workflow
+
+<Steps>
+  <Step>
+    ### Select Connection and Database
+
+    Choose the database to export and verify the environment.
+
+  </Step>
+  <Step>
+    ### Configure Export Options
+
+    Choose whether to include structure, data, and database objects. You can export all tables or a selected table subset.
+
+  </Step>
+  <Step>
+    ### Choose Output Location
+
+    Select where the `.sql` file should be saved.
+
+  </Step>
+  <Step>
+    ### Start Export
+
+    DBX generates a SQL file and reports the current object, progress, row counts, errors, and cancellation state.
+
+  </Step>
+</Steps>
+
+## Batching And Selection
+
+DBX reads table data in batches and writes generated `INSERT` statements into the output file. If batch size is not set, the export uses a default batch size of 1000 rows.
+
+Selected-table export filters the table list before generating DDL and data. Routine objects such as procedures and functions are included only when object export is enabled and the export is not limited to a table subset.
+
+<Callout type="info">For MySQL exports, DBX temporarily writes `SET FOREIGN_KEY_CHECKS = 0` before table content and re-enables it at the end of the file.</Callout>
+
+## Cancellation And Errors
+
+You can cancel an export between objects or row batches. If a specific table or object cannot be exported, DBX writes a SQL comment with the error and continues with the remaining export where possible.
+
+## Importing the Export
+
+The generated `.sql` file can be imported with [SQL File Execution](/en/docs/sql-file).
+
+<Callout type="warn">Export files may contain sensitive data, account information, business identifiers, or user privacy data. Mask data before sharing when needed.</Callout>
+
+## Recommendations
+
+- Export a backup before high-risk schema operations
+- Test imports in a non-production database before migration
+- Use native database backup tools for large production databases or complete backups
+- Keep exported SQL files out of public repositories
diff --git a/docs/content/docs/databases.cn.mdx b/docs/content/docs/databases.cn.mdx
new file mode 100644
index 0000000..1f1b138
--- /dev/null
+++ b/docs/content/docs/databases.cn.mdx
@@ -0,0 +1,156 @@
+---
+title: 数据库支持
+description: 了解 DBX 可以连接哪些数据库，以及每类高级功能支持哪些引擎。
+---
+
+<Callout type="info">DBX 主应用会尽量使用 Rust 原生驱动。部分数据库通过 MySQL 或 PostgreSQL 兼容协议连接，部分数据库通过 Agent 驱动或可选的 [JDBC 插件](/cn/docs/plugins) 扩展。</Callout>
+
+## 连接类型
+
+新建连接窗口会提供带默认端口和驱动标签的预设类型。
+
+| 分组                | 类型                                                                                                             | 说明                                                         |
+| ------------------- | ---------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------ |
+| 核心 SQL 数据库     | MySQL、PostgreSQL、SQLite、DuckDB、ClickHouse、SQL Server、Oracle、Redshift、DM、GaussDB、KWDB、Teradata、Vertica、Exasol、Firebird、SAP HANA、崖山 YashanDB、GBase | 直接出现在 DBX 连接选择器中                                  |
+| 文档、键值与配置服务 | Redis、MongoDB、Elasticsearch、etcd、Nacos                                                                        | 根据数据模型使用专门浏览器、管理控制台或查询流程，不完全等同于关系型表格 |
+| MySQL 兼容类型      | MariaDB、TiDB、OceanBase、Doris、SelectDB、StarRocks、Manticore Search、GoldenDB、TDSQL、PolarDB、GreatSQL、自定义 MySQL | 复用 MySQL 风格连接能力                                      |
+| PostgreSQL 兼容类型 | openGauss、KingBase、HighGo、Vastbase、CockroachDB、自定义 PostgreSQL                                             | 复用 PostgreSQL 风格连接能力                                 |
+| 文件型数据库        | SQLite、DuckDB、Microsoft Access、RQLite、Turso                                                                   | 选择本地数据库文件或 HTTP 端点，不填写主机和端口             |
+| 时序与边缘数据库    | Cloudflare D1、InfluxDB、IoTDB、TDengine、Databend、QuestDB                                                       | 托管 SQLite、时序、IoT 或边缘场景                            |
+| Agent/JDBC 扩展类型 | H2、Snowflake、Trino、PrestoSQL、Hive、DB2、Informix、Neo4j、Cassandra、BigQuery、Kylin、SunDB、XuguDB、Databricks、IRIS、JDBC | 功能覆盖取决于对应驱动路径                                   |
+
+## 默认端口
+
+| 类型                                        | 默认端口 |
+| ------------------------------------------- | -------: |
+| MySQL / MariaDB / GoldenDB / TDSQL / PolarDB / GreatSQL |     3306 |
+| PostgreSQL / openGauss / GaussDB / Vastbase |     5432 |
+| Redis                                       |     6379 |
+| MongoDB                                     |    27017 |
+| ClickHouse                                  |     8123 |
+| SQL Server                                  |     1433 |
+| Oracle                                      |     1521 |
+| Elasticsearch                               |     9200 |
+| TiDB                                        |     4000 |
+| OceanBase                                   |     2881 |
+| Doris / SelectDB / StarRocks / Databend     |     9030 |
+| Manticore Search                            |     9306 |
+| Redshift                                    |     5439 |
+| CockroachDB                                 |    26257 |
+| DM                                          |     5236 |
+| KingBase                                    |    54321 |
+| HighGo                                      |     5866 |
+| KWDB                                        |    26257 |
+| 崖山 YashanDB                               |     1688 |
+| GBase                                       |     5258 |
+| Firebird                                    |     3050 |
+| Teradata                                    |     1025 |
+| Vertica                                     |     5433 |
+| Exasol                                      |     8563 |
+| SAP HANA                                    |    39015 |
+| Databricks                                  |      443 |
+| Cloudflare D1 REST API                      |      443 |
+| InfluxDB                                    |     8086 |
+| IoTDB                                       |     6667 |
+| etcd                                        |     2379 |
+| Nacos                                       |     8848 |
+| Nacos 控制台/admin API                      |     8085 |
+| IRIS                                        |     1972 |
+| RQLite                                      |     4001 |
+| H2                                          |     9092 |
+| Snowflake                                   |      443 |
+| Trino                                       |     8080 |
+| PrestoSQL                                   |     8080 |
+| Hive                                        |    10000 |
+| DB2                                         |    50000 |
+| Informix                                    |     9088 |
+| Neo4j                                       |     7687 |
+| Cassandra                                   |     9042 |
+| BigQuery                                    |      443 |
+| Kylin                                       |     7070 |
+| SunDB                                       |    22000 |
+| TDengine                                    |     6041 |
+| XuguDB                                      |     5138 |
+| QuestDB                                     |     8812 |
+
+<Callout type="info">SQLite、DuckDB、Access 和 JDBC 在不需要网络端口时，会在连接模型中保存为端口 `0`。</Callout>
+
+## 功能矩阵
+
+DBX 只会在具备足够元数据和 SQL 生成能力的数据库上启用高级功能。
+
+| 功能                | 支持类型                                                                                                                                                                                                                                                 |
+| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Schema 感知树       | PostgreSQL、SQL Server、Oracle、Redshift、DM、GaussDB、KWDB、KingBase、HighGo、Vastbase、JDBC、H2、Snowflake、Trino、DB2、TDengine、XuguDB、Teradata、Vertica、Exasol、Firebird、SAP HANA、YashanDB、GBase                              |
+| ER 图               | MySQL、PostgreSQL、SQLite、Cloudflare D1、SQL Server、Oracle、Redshift、DM、GaussDB、KWDB、KingBase、HighGo、Vastbase、GoldenDB、Access、H2、DB2、Teradata、Vertica、Firebird、Exasol、GBase、YashanDB                                      |
+| 数据库搜索          | MySQL、PostgreSQL、SQLite、SQL Server、Oracle、Redshift、DuckDB、ClickHouse、DM、GaussDB、KWDB、KingBase、HighGo、Vastbase、GoldenDB、Access、H2、Snowflake、Trino、Hive、DB2、Informix、Neo4j、Cassandra、BigQuery、Kylin、SunDB、TDengine、XuguDB、Databricks、Teradata、Vertica |
+| 表数据导入          | MySQL、PostgreSQL、SQLite、Cloudflare D1、DuckDB、ClickHouse、SQL Server、Oracle、Doris、StarRocks、Redshift、DM、GaussDB、KWDB、KingBase、HighGo、Vastbase、GoldenDB、Access、Databend                                                      |
+| 几何字段地图预览    | PostgreSQL、HighGo、KingBase、Vastbase、openGauss、GaussDB（PostGIS `geometry` / `geography` 列在结果集中以 WKT 显示，并提供网格工具栏的"地图预览"按钮）                                                                                       |
+| 表结构编辑器        | MySQL、PostgreSQL、SQLite、SQL Server、KWDB                                                                                                                                                                                                   |
+| 创建数据库          | MySQL、PostgreSQL、SQL Server、ClickHouse、Oracle、DM、GaussDB、KWDB、Doris、StarRocks、Redshift、Teradata、Vertica                                                                                                                           |
+| 字段血缘            | MySQL、PostgreSQL、SQLite、Cloudflare D1、SQL Server、Oracle、Redshift、DM、GaussDB、KWDB                                                                                                                                                     |
+| 数据传输            | MySQL、PostgreSQL、SQLite、Cloudflare D1、SQL Server、Oracle、ClickHouse、DuckDB、DM、GaussDB、KWDB                                                                                                                                           |
+| 不支持 SQL 文件执行 | Redis、MongoDB、Elasticsearch、etcd、Nacos                                                                                                                                                                                                    |
+
+<Callout type="warn">如果某个数据库可以连接，但没有出现在某个功能行中，该功能可能会被隐藏或受限。这是为了避免 DBX 生成无法可靠审查的 SQL。</Callout>
+
+## 连接选项
+
+大多数网络数据库支持主机、端口、用户名、密码、默认数据库、URL 参数、SSL、连接颜色和隧道/代理设置。文件型数据库会改为选择本地文件。
+
+DBX 也可以解析常见连接 URL，例如 MySQL、PostgreSQL、Redis、MongoDB、ClickHouse、SQL Server、Oracle、Elasticsearch、DM、GaussDB、KWDB、openGauss、TDengine、XuguDB、Access、Teradata、Vertica、Firebird、Exasol、GBase、YashanDB、SAP HANA、InfluxDB、QuestDB、IoTDB、etcd、Nacos、RQLite 和 Databricks。
+
+### Cloudflare D1
+
+新建 **Cloudflare D1** 连接时填写 Account ID、D1 Database ID（UUID）和 API Token。浏览元数据和查询至少需要 `D1 Read` 权限；插入、更新、DDL、导入或传输还需要 `D1 Write` 权限。DBX 会直接调用 Cloudflare HTTPS API，因此该类型不提供 SSH 或代理传输层。
+
+### Nacos 控制台
+
+Nacos 连接会打开专用管理控制台，用于管理命名空间、配置、服务、实例、配置历史和 Raw API 请求。创建连接时请填写 Nacos 控制台/admin API 地址。Nacos 3 Docker 部署通常使用 `8085` 暴露控制台；旧版本也可能与服务端口共用 `8848`。
+
+### ClickHouse TLS
+
+ClickHouse 连接支持 TLS 加密。创建 ClickHouse 连接时，启用 TLS 开关即可通过 HTTPS 而非 HTTP 进行连接。建议对生产环境的 ClickHouse 实例或 ClickHouse Cloud 部署启用此选项。
+
+### GaussDB 原生驱动
+
+GaussDB 和 openGauss 现在使用原生 Rust 驱动（`rust-gaussdb`）而非 ODBC。之前使用 PostgreSQL 兼容路径的连接会自动迁移到 GaussDB 驱动。原生驱动提供更好的类型处理和针对 GaussDB 的元数据支持。
+
+### DuckDB 文件与内存模式
+
+DuckDB 连接支持两种模式：
+
+- **文件模式**：选择 `.db` 或 `.duckdb` 文件进行持久化存储
+- **内存模式**：使用内存数据库进行临时分析。连接关闭后数据会丢失。
+
+可以直接从连接表单创建新的 DuckDB 数据库文件，只需输入尚不存在的文件路径即可。
+
+### SQLite 内存模式
+
+SQLite 连接可以使用 `:memory:` 作为文件路径，创建临时的内存数据库。适用于快速实验或临时数据转换。
+
+### Doris / StarRocks 多 Catalog
+
+Doris 与 StarRocks 作为 MPP 引擎，通过 Catalog 联邦访问外部数据源（`SHOW CATALOGS`）。DBX 会列出当前用户有权限读取的所有 Catalog，并以 `Catalog → 数据库 → 表` 的树形结构展示：
+
+- 内置的 `internal` Catalog 展示引擎自身的数据库与表。
+- 外部 Catalog（Hive、Iceberg、Hudi、Paimon、JDBC 等）同样列出其数据库与表。无权限访问的 Catalog 会被静默跳过。
+- 当只存在 `internal` Catalog 时，侧边栏保持扁平结构（不出现 Catalog 分组层），单 Catalog 部署不受影响。
+
+从外部 Catalog 打开表时，数据预览使用三段式 `catalog.database.table` 名称，无需在会话中执行 `SWITCH`。外部 Catalog 仅支持表与视图——存储过程、序列、触发器、外键均不可用。
+
+## 扩展支持
+
+当目标数据库不在内置类型中，或团队必须使用厂商 JDBC 驱动时，可以使用 [JDBC 插件](/cn/docs/plugins)。JDBC 会把厂商驱动 JAR 放在 DBX 主应用之外，由你决定安装哪些驱动文件。
+
+<Cards>
+  <Card title="创建连接" href="/cn/docs/getting-started">
+    安装 DBX、选择数据库类型并测试第一个连接。
+  </Card>
+  <Card title="JDBC 插件" href="/cn/docs/plugins">
+    安装可选 JDBC 插件并导入厂商驱动 JAR。
+  </Card>
+  <Card title="隧道/代理" href="/cn/docs/ssh-tunnel">
+    连接私有网络、跳板机、代理或 HTTP 隧道脚本后的数据库。
+  </Card>
+</Cards>
diff --git a/docs/content/docs/databases.mdx b/docs/content/docs/databases.mdx
new file mode 100644
index 0000000..0bb238b
--- /dev/null
+++ b/docs/content/docs/databases.mdx
@@ -0,0 +1,156 @@
+---
+title: Database Support
+description: Understand which databases DBX can connect to and which advanced features are available per engine.
+---
+
+<Callout type="info">DBX uses native Rust drivers for the main app whenever possible. Some engines are compatibility profiles over MySQL or PostgreSQL protocols, and some are handled through Agent drivers or the optional [JDBC Plugin](/en/docs/plugins).</Callout>
+
+## Connection Profiles
+
+The connection dialog exposes ready-to-use profiles with default ports and driver labels.
+
+| Group                          | Profiles                                                                                                                                                        | Notes                                                                                          |
+| ------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
+| Core SQL engines               | MySQL, PostgreSQL, SQLite, DuckDB, ClickHouse, SQL Server, Oracle, Redshift, DM, GaussDB, KWDB, Teradata, Vertica, Exasol, Firebird, SAP HANA, YashanDB, GBase   | Available directly in the DBX connection picker                                                |
+| Document, key-value, and config services | Redis, MongoDB, Elasticsearch, etcd, Nacos                                                                                                                        | Use dedicated browsers, admin consoles, or query flows instead of the generic relational grid where appropriate |
+| MySQL-compatible profiles      | MariaDB, TiDB, OceanBase, Doris, SelectDB, StarRocks, Manticore Search, GoldenDB, TDSQL, PolarDB, GreatSQL, custom MySQL                                          | Reuse MySQL-style connection handling where the engine speaks a compatible protocol            |
+| PostgreSQL-compatible profiles | openGauss, KingBase, HighGo, Vastbase, CockroachDB, custom PostgreSQL                                                                                            | Reuse PostgreSQL-style connection handling where the engine speaks a compatible protocol       |
+| File-based engines             | SQLite, DuckDB, Microsoft Access, RQLite, Turso                                                                                                                  | Choose a local database file or HTTP endpoint instead of host and port                         |
+| Time-series and edge           | Cloudflare D1, InfluxDB, IoTDB, TDengine, Databend, QuestDB                                                                                                      | Managed SQLite, time-series, IoT, or edge workloads                                            |
+| Agent/JDBC-oriented engines    | H2, Snowflake, Trino, PrestoSQL, Hive, DB2, Informix, Neo4j, Cassandra, BigQuery, Kylin, SunDB, XuguDB, Databricks, IRIS, JDBC                                   | Feature coverage depends on the driver path used by that engine                                |
+
+## Default Ports
+
+| Profile                                     | Default Port |
+| ------------------------------------------- | -----------: |
+| MySQL / MariaDB / GoldenDB / TDSQL / PolarDB / GreatSQL |         3306 |
+| PostgreSQL / openGauss / GaussDB / Vastbase |         5432 |
+| Redis                                       |         6379 |
+| MongoDB                                     |        27017 |
+| ClickHouse                                  |         8123 |
+| SQL Server                                  |         1433 |
+| Oracle                                      |         1521 |
+| Elasticsearch                               |         9200 |
+| TiDB                                        |         4000 |
+| OceanBase                                   |         2881 |
+| Doris / SelectDB / StarRocks / Databend     |         9030 |
+| Manticore Search                            |         9306 |
+| Redshift                                    |         5439 |
+| CockroachDB                                 |        26257 |
+| DM                                          |         5236 |
+| KingBase                                    |        54321 |
+| HighGo                                      |         5866 |
+| KWDB                                        |        26257 |
+| YashanDB                                    |         1688 |
+| GBase                                       |         5258 |
+| Firebird                                    |         3050 |
+| Teradata                                    |         1025 |
+| Vertica                                     |         5433 |
+| Exasol                                      |         8563 |
+| SAP HANA                                    |        39015 |
+| Databricks                                  |          443 |
+| Cloudflare D1 REST API                      |          443 |
+| InfluxDB                                    |         8086 |
+| IoTDB                                       |         6667 |
+| etcd                                        |         2379 |
+| Nacos                                       |         8848 |
+| Nacos console/admin API                     |         8085 |
+| IRIS                                        |         1972 |
+| RQLite                                      |         4001 |
+| H2                                          |         9092 |
+| Snowflake                                   |          443 |
+| Trino                                       |         8080 |
+| PrestoSQL                                   |         8080 |
+| Hive                                        |        10000 |
+| DB2                                         |        50000 |
+| Informix                                    |         9088 |
+| Neo4j                                       |         7687 |
+| Cassandra                                   |         9042 |
+| BigQuery                                    |          443 |
+| Kylin                                       |         7070 |
+| SunDB                                       |        22000 |
+| TDengine                                    |         6041 |
+| XuguDB                                      |         5138 |
+| QuestDB                                     |         8812 |
+
+<Callout type="info">SQLite, DuckDB, Access, and JDBC profiles use port `0` in the saved connection model when a network port is not part of the connection.</Callout>
+
+## Feature Matrix
+
+DBX intentionally enables advanced workflows only where the app has enough metadata and SQL-generation support.
+
+| Feature                        | Supported Types                                                                                                                                                                                                                                                                       |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Schema-aware tree              | PostgreSQL, SQL Server, Oracle, Redshift, DM, GaussDB, KWDB, KingBase, HighGo, Vastbase, JDBC, H2, Snowflake, Trino, DB2, TDengine, XuguDB, Teradata, Vertica, Exasol, Firebird, SAP HANA, YashanDB, GBase                                                                             |
+| ER diagram                     | MySQL, PostgreSQL, SQLite, Cloudflare D1, SQL Server, Oracle, Redshift, DM, GaussDB, KWDB, KingBase, HighGo, Vastbase, GoldenDB, Access, H2, DB2, Teradata, Vertica, Firebird, Exasol, GBase, YashanDB                                                                                 |
+| Database search                | MySQL, PostgreSQL, SQLite, SQL Server, Oracle, Redshift, DuckDB, ClickHouse, DM, GaussDB, KWDB, KingBase, HighGo, Vastbase, GoldenDB, Access, H2, Snowflake, Trino, Hive, DB2, Informix, Neo4j, Cassandra, BigQuery, Kylin, SunDB, TDengine, XuguDB, Databricks, Teradata, Vertica      |
+| Table import                   | MySQL, PostgreSQL, SQLite, Cloudflare D1, DuckDB, ClickHouse, SQL Server, Oracle, Doris, StarRocks, Redshift, DM, GaussDB, KWDB, KingBase, HighGo, Vastbase, GoldenDB, Access, Databend                                                                                                |
+| Geometry map preview           | PostgreSQL, HighGo, KingBase, Vastbase, openGauss, GaussDB (PostGIS `geometry` / `geography` columns are returned as WKT in the result grid and unlock the grid-toolbar map preview button)                                                                                                |
+| Table structure editor         | MySQL, PostgreSQL, SQLite, SQL Server, KWDB                                                                                                                                                                                                                                           |
+| Create database                | MySQL, PostgreSQL, SQL Server, ClickHouse, Oracle, DM, GaussDB, KWDB, Doris, StarRocks, Redshift, Teradata, Vertica                                                                                                                                                                   |
+| Field lineage                  | MySQL, PostgreSQL, SQLite, Cloudflare D1, SQL Server, Oracle, Redshift, DM, GaussDB, KWDB                                                                                                                                                                                             |
+| Data transfer                  | MySQL, PostgreSQL, SQLite, Cloudflare D1, SQL Server, Oracle, ClickHouse, DuckDB, DM, GaussDB, KWDB                                                                                                                                                                                   |
+| SQL file execution unavailable | Redis, MongoDB, Elasticsearch, etcd, Nacos                                                                                                                                                                                                                                            |
+
+<Callout type="warn">If a database can connect but does not appear in a feature row, that feature may be hidden or limited for that engine. This prevents DBX from generating SQL it cannot review reliably.</Callout>
+
+## Connection Options
+
+Most network databases support host, port, username, password, default database, optional URL parameters, SSL, connection color, and tunnel / proxy settings. File-based engines replace host and port with a file picker.
+
+DBX can also parse common connection URLs for engines such as MySQL, PostgreSQL, Redis, MongoDB, ClickHouse, SQL Server, Oracle, Elasticsearch, DM, GaussDB, KWDB, openGauss, TDengine, XuguDB, Access, Teradata, Vertica, Firebird, Exasol, GBase, YashanDB, SAP HANA, InfluxDB, QuestDB, IoTDB, etcd, Nacos, RQLite, and Databricks.
+
+### Cloudflare D1
+
+Create a **Cloudflare D1** connection with the Account ID, D1 Database ID (UUID), and an API Token. The token needs `D1 Read` permission for browsing and queries; add `D1 Write` for inserts, updates, DDL, imports, or transfers. DBX uses Cloudflare's HTTPS API directly, so SSH and proxy transport layers are not available for this profile.
+
+### Nacos Console
+
+Nacos connections open a dedicated admin console for namespaces, configs, services, instances, config history, and raw API requests. Use the Nacos console/admin API address when creating the connection. Nacos 3 Docker deployments usually expose that console on `8085`; older deployments may share `8848` with the service port.
+
+### ClickHouse TLS
+
+ClickHouse connections support TLS encryption. When creating a ClickHouse connection, enable the TLS toggle to connect over HTTPS instead of HTTP. This is recommended for production ClickHouse instances or any ClickHouse Cloud deployments.
+
+### GaussDB Native Driver
+
+GaussDB and openGauss now use a native Rust driver (`rust-gaussdb`) instead of ODBC. Connections that previously used the PostgreSQL compatibility path are auto-migrated to the GaussDB driver. The native driver provides better type handling and metadata support specific to GaussDB.
+
+### DuckDB File and Memory Modes
+
+DuckDB connections support two modes:
+
+- **File mode**: Select a `.db` or `.duckdb` file for persistent storage
+- **Memory mode**: Use an in-memory database for temporary analysis. Data is lost when the connection is closed.
+
+Create a new DuckDB database file directly from the connection form by entering a path that does not yet exist.
+
+### In-Memory SQLite
+
+SQLite connections can use `:memory:` as the file path for ephemeral, in-memory databases. This is useful for quick experiments or temporary data transformations.
+
+### Doris / StarRocks Multi-Catalog
+
+Doris and StarRocks are MPP engines that federate external data through catalogs (`SHOW CATALOGS`). DBX lists every catalog the current user can read and renders them as a `catalog → database → table` tree:
+
+- The built-in `internal` catalog shows the engine's own databases and tables.
+- External catalogs (Hive, Iceberg, Hudi, Paimon, JDBC, etc.) list their databases and tables the same way. Catalogs you lack permission to read are skipped silently.
+- When only the `internal` catalog is present, the sidebar stays flat (no catalog grouping layer) so single-catalog deployments are unaffected.
+
+Opening a table from an external catalog previews its data using the 3-part `catalog.database.table` name, so no session `SWITCH` is needed. External catalogs expose tables and views only — routines, sequences, triggers, and foreign keys are not available.
+
+## Extending Support
+
+Use the [JDBC Plugin](/en/docs/plugins) when a database is not covered by the built-in profiles or when your team must use a vendor JDBC driver. JDBC keeps vendor driver JARs outside the main DBX app, so you control which driver files are installed.
+
+<Cards>
+  <Card title="Create a Connection" href="/en/docs/getting-started">
+    Install DBX, choose a database profile, and test the first connection.
+  </Card>
+  <Card title="JDBC Plugin" href="/en/docs/plugins">
+    Install the optional JDBC plugin and import vendor driver JARs.
+  </Card>
+  <Card title="Tunnel / Proxy" href="/en/docs/ssh-tunnel">
+    Reach databases behind private networks, bastion hosts, proxies, or HTTP tunnel scripts.
+  </Card>
+</Cards>
diff --git a/docs/content/docs/driver-management.cn.mdx b/docs/content/docs/driver-management.cn.mdx
new file mode 100644
index 0000000..6af9429
--- /dev/null
+++ b/docs/content/docs/driver-management.cn.mdx
@@ -0,0 +1,74 @@
+---
+title: 驱动管理
+description: 管理内置和 Agent 驱动的 JDBC 驱动，配置 JRE 版本，处理驱动更新。
+---
+
+DBX 使用混合驱动架构：常用数据库使用内置原生驱动，需要供应商特定 JDBC 驱动的数据库使用 JDBC Agent 系统。
+
+## 驱动架构
+
+| 驱动类型     | 工作方式               | 适用场景                                                                                                                                                                  |
+| ------------ | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| 原生（内置） | Rust 驱动编译进 DBX    | MySQL、PostgreSQL、SQLite、SQL Server、Oracle、Redis、MongoDB、DuckDB、ClickHouse 等                                                                                      |
+| JDBC Agent   | DBX 管理的 Java 子进程 | 提供 JDBC 驱动的数据库：GaussDB、openGauss、DM、KingBase、HighGo、Vastbase、Trino、Hive、DB2、Informix、Neo4j、TDengine、虚谷 XuguDB、YashanDB、GoldenDB、Kylin、SunDB 等 |
+
+<Callout type="info">原生驱动安装后立即可用。Agent 驱动需要一次性下载 JDBC 驱动和 JRE 设置，首次创建连接时 DBX 会自动处理。</Callout>
+
+## 驱动商店
+
+驱动商店标签页显示所有可用的 Agent 驱动及其状态：
+
+- **已安装驱动**：版本号、大小和更新可用性
+- **可用驱动**：可一键安装的驱动
+- **更新角标**：注册中心有新版本时显示
+
+从**设置 → 驱动**打开驱动商店，或点击创建需要 Agent 驱动的连接时出现的驱动提示。
+
+## 安装驱动
+
+<Steps>
+  <Step>### 打开驱动商店 导航到**设置 → 驱动**或点击连接对话框中的驱动安装提示。</Step>
+  <Step>### 选择驱动 找到所需的数据库驱动。每个条目显示支持的数据库和驱动版本。</Step>
+  <Step>### 点击安装 DBX 会下载 JDBC 驱动 JAR 及所需的依赖项。下载过程中显示进度。</Step>
+  <Step>### 创建连接 返回连接对话框。驱动此时即可使用。</Step>
+</Steps>
+
+## JRE 管理
+
+JDBC Agent 驱动需要 Java 运行环境。DBX 内置 JRE 管理：
+
+- **系统 JRE**：DBX 可使用系统上已有的 Java 安装
+- **托管 JRE**：DBX 可下载并管理自己的 JRE，与系统 Java 隔离
+- **多 JRE 支持**：不同驱动可按需使用不同 JRE 版本
+- **重新安装**：如托管 JRE 损坏，可从驱动商店重新安装
+
+## 驱动更新
+
+DBX 会定期检查驱动更新：
+
+- 有新版本时，驱动商店标签页上会显示更新角标
+- 点击**升级全部驱动**一次性更新所有已安装的驱动
+- 单个驱动可从商店中对应条目升级
+
+## 离线驱动导入
+
+对于无法访问互联网的环境，DBX 支持离线驱动安装：
+
+1. 从另一台机器下载 JDBC 驱动 ZIP 包
+2. 将其传输到离线机器
+3. 在驱动商店中使用**从 ZIP 导入**安装驱动包
+
+这适用于气隙网络、严格防火墙环境或企业中预先批准的驱动版本。
+
+## 插件更新
+
+对于由 [JDBC 插件](/cn/docs/plugins)支持的数据库，当有新插件版本可用时，DBX 会显示更新通知。插件更新遵循与内置 Agent 驱动相同的安装流程。
+
+## 故障排除
+
+| 问题                   | 解决方案                                                    |
+| ---------------------- | ----------------------------------------------------------- |
+| 驱动下载失败           | 检查网络连接和防火墙规则。尝试离线导入方法。                |
+| Agent 无法启动         | 在驱动商店中验证 JRE 安装。如需要，重新安装托管 JRE。       |
+| 驱动安装后连接测试失败 | 确认 JDBC URL 格式与驱动的预期格式匹配。检查 SSH/代理设置。 |
+| 驱动版本错误           | 卸载当前驱动并从商店安装正确版本。                          |
diff --git a/docs/content/docs/driver-management.mdx b/docs/content/docs/driver-management.mdx
new file mode 100644
index 0000000..a0e5670
--- /dev/null
+++ b/docs/content/docs/driver-management.mdx
@@ -0,0 +1,74 @@
+---
+title: Driver Management
+description: Manage built-in and agent-based JDBC drivers, configure JRE versions, and handle driver updates.
+---
+
+DBX uses a hybrid driver architecture: built-in native drivers for common databases and a JDBC agent system for databases that require vendor-specific JDBC drivers.
+
+## Driver Architecture
+
+| Driver Type       | How It Works                   | Best For                                                                                                                                                                                 |
+| ----------------- | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Native (built-in) | Rust drivers compiled into DBX | MySQL, PostgreSQL, SQLite, SQL Server, Oracle, Redis, MongoDB, DuckDB, ClickHouse, and more                                                                                              |
+| JDBC Agent        | Java subprocess managed by DBX | Databases that provide JDBC drivers: GaussDB, openGauss, DM, KingBase, HighGo, Vastbase, Trino, Hive, DB2, Informix, Neo4j, TDengine, XuguDB, YashanDB, GoldenDB, Kylin, SunDB, and more |
+
+<Callout type="info">Native drivers work immediately after installation. Agent drivers require a one-time JDBC driver download and JRE setup, which DBX handles automatically when you first create a connection.</Callout>
+
+## Driver Store
+
+The Driver Store tab shows all available agent drivers and their status:
+
+- **Installed drivers**: version number, size, and update availability
+- **Available drivers**: drivers you can install with one click
+- **Update badges**: when a newer version is available from the registry
+
+Open the Driver Store from **Settings → Drivers** or click the driver hint that appears when creating a connection that needs an agent driver.
+
+## Installing Drivers
+
+<Steps>
+  <Step>### Open Driver Store Navigate to **Settings → Drivers** or click the driver install hint in the connection dialog.</Step>
+  <Step>### Choose a Driver Find the database driver you need. Each entry shows the supported database and driver version.</Step>
+  <Step>### Click Install DBX downloads the JDBC driver JAR and any required dependencies. Progress is shown during download.</Step>
+  <Step>### Create a Connection Return to the connection dialog. The driver is now ready for use.</Step>
+</Steps>
+
+## JRE Management
+
+JDBC agent drivers require a Java Runtime Environment. DBX includes JRE management:
+
+- **System JRE**: DBX can use an existing Java installation on your system
+- **Managed JRE**: DBX can download and manage its own JRE, isolated from your system Java
+- **Multi-JRE support**: Different drivers can target different JRE versions when needed
+- **Reinstall**: Reinstall the managed JRE from the Driver Store if it becomes corrupted
+
+## Driver Updates
+
+DBX checks for driver updates periodically:
+
+- Update badges appear on the Driver Store tab when newer versions are available
+- Click **Upgrade All Drivers** to update all installed drivers at once
+- Individual drivers can be upgraded from their entry in the store
+
+## Offline Driver Import
+
+For environments without internet access, DBX supports offline driver installation:
+
+1. Download the JDBC driver ZIP bundle from another machine
+2. Transfer it to the offline machine
+3. In Driver Store, use **Import from ZIP** to install the driver bundle
+
+This is useful for air-gapped networks, strict firewall environments, or pre-approved driver versions in enterprise settings.
+
+## Plugin Updates
+
+For databases supported by the [JDBC Plugin](/en/docs/plugins), DBX shows update notices when a new plugin version is available. Plugin updates follow the same install flow as built-in agent drivers.
+
+## Troubleshooting
+
+| Problem                                    | Solution                                                                                    |
+| ------------------------------------------ | ------------------------------------------------------------------------------------------- |
+| Driver download fails                      | Check network connectivity and firewall rules. Try the offline import method.               |
+| Agent won't start                          | Verify JRE installation in Driver Store. Reinstall the managed JRE if needed.               |
+| Connection test fails after driver install | Confirm the JDBC URL format matches the driver's expected format. Check SSH/proxy settings. |
+| Wrong driver version                       | Uninstall the current driver and install the correct version from the store.                |
diff --git a/docs/content/docs/field-lineage.cn.mdx b/docs/content/docs/field-lineage.cn.mdx
new file mode 100644
index 0000000..4301f9a
--- /dev/null
+++ b/docs/content/docs/field-lineage.cn.mdx
@@ -0,0 +1,51 @@
+---
+title: 字段血缘
+description: 追踪字段之间的来源、引用和潜在关联，辅助理解数据库结构。
+---
+
+字段血缘用于回答一个常见问题：某个字段的数据从哪里来，又可能影响到哪里。它适合理解复杂库、排查影响范围和阅读历史结构。
+
+<Callout type="info">字段血缘目前支持 MySQL、PostgreSQL、SQLite、SQL Server、Oracle、Redshift、DM 和 GaussDB。其他引擎可能无法提供足够的关系元数据，因此不会展示完整血缘。</Callout>
+
+## 能解决什么问题
+
+- 修改字段前，查看哪些表、视图或查询可能依赖它
+- 接手陌生数据库时，快速理解字段之间的关系
+- 分析报表字段的来源和可能的上游数据
+- 发现没有显式外键但命名相似的潜在关系
+
+## 关系来源
+
+| 来源     | 可信度 | 说明                                             |
+| -------- | ------ | ------------------------------------------------ |
+| 外键     | 高     | 数据库中已经声明的外键约束                       |
+| 视图     | 高     | 从视图定义中分析字段映射                         |
+| 查询历史 | 中     | 从执行过的 SQL 中分析 `JOIN`、`WHERE` 等引用关系 |
+| 同名字段 | 低到中 | 根据字段名称相似性推断可能关系                   |
+
+<Callout type="info">字段血缘是辅助分析工具，不等同于数据治理平台里的强一致血缘。对关键结论，请结合数据库约束、视图定义和业务代码确认。</Callout>
+
+## 查看方式
+
+- 搜索表名或字段名
+- 按置信度筛选关系
+- 点击表或字段跳转到数据浏览或结构查看
+- 从某个字段出发查看上游或下游关联
+
+## 使用建议
+
+- 优先相信外键和视图来源
+- 对查询历史和同名字段推断保持审查
+- 修改字段前，结合 Schema 对比和应用代码搜索一起判断影响范围
+- 对核心业务字段，建议补充数据库约束或文档注释
+
+## 相关功能
+
+<Cards>
+  <Card title="结构浏览" href="/cn/docs/schema-browser">
+    查看表、字段、外键和注释。
+  </Card>
+  <Card title="Schema 对比" href="/cn/docs/schema-diff">
+    检查不同环境之间的结构差异。
+  </Card>
+</Cards>
diff --git a/docs/content/docs/field-lineage.mdx b/docs/content/docs/field-lineage.mdx
new file mode 100644
index 0000000..929a7a9
--- /dev/null
+++ b/docs/content/docs/field-lineage.mdx
@@ -0,0 +1,51 @@
+---
+title: Field Lineage
+description: Trace where columns come from, how they are referenced, and which relationships may exist.
+---
+
+Field Lineage helps answer a common question: where does a column's data come from, and what might depend on it? Use it to understand complex schemas, inspect impact, and read legacy structures.
+
+<Callout type="info">Field Lineage is enabled for MySQL, PostgreSQL, SQLite, SQL Server, Oracle, Redshift, DM, and GaussDB. Other engines may not expose enough relationship metadata for DBX to build useful lineage.</Callout>
+
+## What It Helps With
+
+- Before changing a column, see which tables, views, or queries may depend on it
+- Understand relationships in an unfamiliar database
+- Trace where report fields may originate
+- Discover possible relationships that are not declared as foreign keys
+
+## Relationship Sources
+
+| Source            | Confidence    | Details                                                                      |
+| ----------------- | ------------- | ---------------------------------------------------------------------------- |
+| Foreign keys      | High          | Constraints declared in the database                                         |
+| Views             | High          | Field mappings analyzed from view definitions                                |
+| Query history     | Medium        | Relationships inferred from executed SQL, including `JOIN` and `WHERE` usage |
+| Same-name columns | Low to medium | Possible relationships inferred from similar column names                    |
+
+<Callout type="info">Field Lineage is an analysis aid, not a strongly governed lineage platform. For critical decisions, confirm results with database constraints, view definitions, and application code.</Callout>
+
+## Navigation
+
+- Search by table or column name
+- Filter relationships by confidence
+- Click a table or column to open data or structure views
+- Start from one column and inspect upstream or downstream relationships
+
+## Recommendations
+
+- Treat foreign key and view relationships as the strongest signals
+- Review query-history and same-name inferences carefully
+- Before changing a column, combine lineage with schema diff and application code search
+- For important business fields, add database constraints or documentation comments where possible
+
+## Related Features
+
+<Cards>
+  <Card title="Schema Browser" href="/en/docs/schema-browser">
+    Inspect tables, columns, foreign keys, and comments.
+  </Card>
+  <Card title="Schema Diff" href="/en/docs/schema-diff">
+    Compare structure differences across environments.
+  </Card>
+</Cards>
diff --git a/docs/content/docs/getting-started.cn.mdx b/docs/content/docs/getting-started.cn.mdx
new file mode 100644
index 0000000..2940003
--- /dev/null
+++ b/docs/content/docs/getting-started.cn.mdx
@@ -0,0 +1,243 @@
+---
+title: 快速开始
+description: 安装 DBX、创建第一个连接，并了解桌面版、Docker 版和源码运行方式。
+---
+
+本页帮助你完成三件事：
+
+1. 安装 DBX 或启动 Docker 版本
+2. 创建并测试第一个数据库连接
+3. 在需要参与开发或本地调试时从源码运行 DBX
+
+## 选择安装方式
+
+<Tabs groupId="platform" items={['macOS', 'Windows', 'Linux', 'Docker']}>
+  <Tab value="macOS">
+    使用 Homebrew 安装：
+
+    ```bash
+    brew install --cask dbx
+    ```
+
+    之后可用以下命令更新：
+
+    ```bash
+    brew upgrade --cask dbx
+    ```
+
+    也可以从 [GitHub Releases](https://github.com/t8y2/dbx/releases) 下载 `.dmg` 安装包。
+
+  </Tab>
+  <Tab value="Windows">
+    使用 Scoop 安装：
+
+    ```bash
+    scoop bucket add dbx https://github.com/t8y2/scoop-bucket
+    scoop install dbx
+    ```
+
+    之后可用以下命令更新：
+
+    ```bash
+    scoop update dbx
+    ```
+
+    也可以从 [GitHub Releases](https://github.com/t8y2/dbx/releases) 下载 `.msi` 安装包。
+
+  </Tab>
+  <Tab value="Linux">
+    使用 Flatpak 从 [FlatPark](https://flatpark.org/apps/com.dbxio.dbx/) 安装（适用于任意发行版）：
+
+    ```bash
+    flatpak remote-add --if-not-exists flatpark https://dl.flatpark.org/flatpark.flatpakrepo
+    flatpak install flatpark com.dbxio.dbx
+    ```
+
+    之后可用以下命令更新：
+
+    ```bash
+    flatpak update com.dbxio.dbx
+    ```
+
+    也可以从 [GitHub Releases](https://github.com/t8y2/dbx/releases) 下载对应安装包：
+
+    | 格式 | 适用场景 |
+    |---|---|
+    | `.deb` | Debian、Ubuntu 及兼容发行版 |
+    | `.AppImage` | 通用 Linux 桌面环境 |
+
+    如果使用 `.AppImage`，首次运行前可能需要添加执行权限：
+
+    ```bash
+    chmod +x DBX*.AppImage
+    ```
+
+  </Tab>
+  <Tab value="Docker">
+    Docker 版本适合部署在服务器上，并通过浏览器访问：
+
+    ```bash
+    docker run -d \
+      --pull=always \
+      --name dbx \
+      -p 4224:4224 \
+      -v dbx-data:/app/data \
+      t8y2/dbx:latest
+    ```
+
+    `latest` 标签会拉取当前发布版本。这里使用跨平台的 `dbx-data` 命名卷；中国大陆用户可改用 `docker.cnb.cool/dbxio.com/dbx:latest`，以获得更快的拉取速度。
+
+    启动后访问 `http://localhost:4224`。
+
+    `deploy/docker-compose.yml` 用于构建当前源码。若要部署已发布镜像，请使用 `deploy/docker-compose.release.yml`：
+
+    ```bash
+    docker compose -f deploy/docker-compose.release.yml up -d
+    ```
+
+    ```yaml
+    services:
+      dbx:
+        image: t8y2/dbx:latest
+        # 中国大陆用户可改用 CNB 镜像，以加快拉取速度：
+        # image: docker.cnb.cool/dbxio.com/dbx:latest
+        pull_policy: always
+        ports:
+          - "4224:4224"
+        volumes:
+          - dbx-data:/app/data
+        restart: unless-stopped
+
+    volumes:
+      dbx-data:
+    ```
+
+  </Tab>
+</Tabs>
+
+## 桌面版还是 Docker
+
+| 模式         | 适合场景                                               | 后端路径                      | 存储位置                       |
+| ------------ | ------------------------------------------------------ | ----------------------------- | ------------------------------ |
+| 桌面版       | 本机日常工作、本地文件、原生窗口、从 MCP 打开 DBX 界面 | Tauri 命令调用 Rust core      | 本机应用数据目录               |
+| Docker / Web | 服务器自托管、浏览器访问                               | HTTP 路由调用同一套 Rust core | Docker 卷或服务器数据目录     |
+
+<Callout type="info">核心数据库能力保持一致，但通过 MCP 打开桌面窗口等集成需要 DBX 桌面版正在运行。</Callout>
+
+## 创建第一个连接
+
+<Steps>
+  <Step>
+    ### 打开新建连接
+
+    在侧边栏或工具栏中点击 **新建连接**。
+
+  </Step>
+  <Step>
+    ### 选择数据库类型
+
+    选择 MySQL、PostgreSQL、SQLite、Redis、MongoDB、DuckDB、ClickHouse、SQL Server、Oracle，或 [数据库支持](/cn/docs/databases) 中列出的兼容类型、Agent/JDBC 类型。
+
+  </Step>
+  <Step>
+    ### 填写连接信息
+
+    网络数据库需要填写主机、端口、用户名、密码和必要的默认数据库。SQLite、DuckDB、Access 这类文件型数据库需要选择本地数据库文件，不填写主机和端口。
+
+  </Step>
+  <Step>
+    ### 有 URL 时直接粘贴
+
+    DBX 可以解析常见连接 URL，例如 MySQL、PostgreSQL、Redis、MongoDB、ClickHouse、SQL Server、Oracle、Elasticsearch、DM、GaussDB、openGauss、TDengine 和 Access。保存前请检查解析出的字段。
+
+  </Step>
+  <Step>
+    ### 配置网络选项
+
+    如果数据库在内网、跳板机后面、只能通过 Web 网关访问，或网络要求 SOCKS5/HTTP 代理，可以配置 [隧道/代理](/cn/docs/ssh-tunnel)。
+
+  </Step>
+  <Step>
+    ### 测试并保存
+
+    点击 **测试** 验证账号、网络和权限。测试通过后保存连接，并从侧边栏打开。
+
+  </Step>
+</Steps>
+
+<Callout type="info">连接密码、SSH 密码、SSH 密钥密码和连接字符串会与普通连接 JSON 分开存储在 DBX 本地数据中。需要迁移加密连接配置时，使用 [配置导出/导入](/cn/docs/config-export)。</Callout>
+
+## 降低生产误操作
+
+- 给生产连接起明确名称，例如 `prod-orders`。
+- 用连接颜色区分生产、预发、测试和本地环境。
+- 一个服务器上数据库很多时，只显示当前需要的数据库。
+- 对编辑、导入、传输、SQL 文件执行或 Schema 同步生成的 SQL，先审查再执行。
+
+## 下一步可以做什么
+
+<Cards>
+  <Card title="写 SQL" href="/cn/docs/query-editor">
+    使用补全、格式化、选中执行、取消执行和查询历史。
+  </Card>
+  <Card title="看数据" href="/cn/docs/data-grid">
+    查看结果、在安全时编辑行、预览 SQL 并导出数据。
+  </Card>
+  <Card title="看结构" href="/cn/docs/schema-browser">
+    浏览数据库、Schema、表、字段、Redis 键和 MongoDB 集合。
+  </Card>
+</Cards>
+
+## 常见连接问题
+
+| 现象               | 检查项                                                         |
+| ------------------ | -------------------------------------------------------------- |
+| 连接超时           | 主机、端口、防火墙、安全组、VPN、Docker 主机网络或内网访问权限 |
+| 认证失败           | 用户名、密码、认证方式、SSL 要求、账号是否允许远程登录         |
+| 能连接但看不到表   | 默认数据库、Schema、权限、元数据读取权限、可见数据库过滤       |
+| 文件数据库打不开   | 文件路径、文件权限、Docker volume 挂载、文件扩展名是否支持     |
+| 内网数据库无法访问 | 配置隧道/代理、VPN，或让 Docker 部署机器能访问目标数据库 |
+
+## 从源码运行
+
+当你想参与开发或本地调试 DBX 时，可以从源码运行。
+
+### 环境要求
+
+- [Node.js](https://nodejs.org/) >= 18
+- [pnpm](https://pnpm.io/)
+- Make
+- [Rust](https://www.rust-lang.org/tools/install) >= 1.77
+
+### 系统依赖
+
+<Tabs groupId="dev-platform" items={["macOS", "Linux", "Windows"]}>
+  <Tab value="macOS">```bash brew install unixodbc ```</Tab>
+  <Tab value="Linux">```bash sudo apt-get install -y libwebkit2gtk-4.1-dev libgtk-3-dev libappindicator3-dev librsvg2-dev patchelf libssl-dev unixodbc-dev ```</Tab>
+  <Tab value="Windows">Windows 通常不需要额外安装系统依赖。</Tab>
+</Tabs>
+
+### 启动开发环境
+
+```bash
+git clone https://github.com/t8y2/dbx.git
+cd dbx
+make
+```
+
+`make` 会在需要时安装根目录依赖，并启动本地 Tauri 桌面端开发环境。
+
+Web 版本：
+
+```bash
+make dev-web
+make dev-backend
+```
+
+### 构建桌面安装包
+
+```bash
+make package
+```
+
+桌面安装包会输出到 `src-tauri/target/release/bundle/`。
diff --git a/docs/content/docs/getting-started.mdx b/docs/content/docs/getting-started.mdx
new file mode 100644
index 0000000..c70d58d
--- /dev/null
+++ b/docs/content/docs/getting-started.mdx
@@ -0,0 +1,243 @@
+---
+title: Getting Started
+description: Install DBX, create your first connection, and understand the desktop, Docker, and source workflows.
+---
+
+This guide gets you through three things:
+
+1. Install DBX or start the Docker version
+2. Create and test your first database connection
+3. Run DBX from source when you want to contribute or debug locally
+
+## Choose An Install Method
+
+<Tabs groupId="platform" items={['macOS', 'Windows', 'Linux', 'Docker']}>
+  <Tab value="macOS">
+    Install with Homebrew:
+
+    ```bash
+    brew install --cask dbx
+    ```
+
+    Update later with:
+
+    ```bash
+    brew upgrade --cask dbx
+    ```
+
+    You can also download a `.dmg` installer from [GitHub Releases](https://github.com/t8y2/dbx/releases).
+
+  </Tab>
+  <Tab value="Windows">
+    Install with Scoop:
+
+    ```bash
+    scoop bucket add dbx https://github.com/t8y2/scoop-bucket
+    scoop install dbx
+    ```
+
+    Update later with:
+
+    ```bash
+    scoop update dbx
+    ```
+
+    You can also download a `.msi` installer from [GitHub Releases](https://github.com/t8y2/dbx/releases).
+
+  </Tab>
+  <Tab value="Linux">
+    Install with Flatpak from [FlatPark](https://flatpark.org/apps/com.dbxio.dbx/) (works on any distribution):
+
+    ```bash
+    flatpak remote-add --if-not-exists flatpark https://dl.flatpark.org/flatpark.flatpakrepo
+    flatpak install flatpark com.dbxio.dbx
+    ```
+
+    Update later with:
+
+    ```bash
+    flatpak update com.dbxio.dbx
+    ```
+
+    You can also download a package from [GitHub Releases](https://github.com/t8y2/dbx/releases):
+
+    | Format | Use Case |
+    |---|---|
+    | `.deb` | Debian, Ubuntu, and compatible distributions |
+    | `.AppImage` | Portable Linux desktop usage |
+
+    For `.AppImage`, make the file executable before first run:
+
+    ```bash
+    chmod +x DBX*.AppImage
+    ```
+
+  </Tab>
+  <Tab value="Docker">
+    Docker is for self-hosting DBX on a server and opening it from a browser:
+
+    ```bash
+    docker run -d \
+      --pull=always \
+      --name dbx \
+      -p 4224:4224 \
+      -v dbx-data:/app/data \
+      t8y2/dbx:latest
+    ```
+
+    The `latest` tag pulls the current release. This uses the cross-platform `dbx-data` named volume. For faster pulls in China, use `docker.cnb.cool/dbxio.com/dbx:latest` instead.
+
+    Then open `http://localhost:4224`.
+
+    `deploy/docker-compose.yml` builds the current checkout. To deploy a published image, use `deploy/docker-compose.release.yml`:
+
+    ```bash
+    docker compose -f deploy/docker-compose.release.yml up -d
+    ```
+
+    ```yaml
+    services:
+      dbx:
+        image: t8y2/dbx:latest
+        # For faster pulls in China, use the CNB image instead:
+        # image: docker.cnb.cool/dbxio.com/dbx:latest
+        pull_policy: always
+        ports:
+          - "4224:4224"
+        volumes:
+          - dbx-data:/app/data
+        restart: unless-stopped
+
+    volumes:
+      dbx-data:
+    ```
+
+  </Tab>
+</Tabs>
+
+## Desktop Or Docker
+
+| Mode         | Best For                                                              | Backend Path                           | Storage                                |
+| ------------ | --------------------------------------------------------------------- | -------------------------------------- | -------------------------------------- |
+| Desktop      | Daily local work, local files, native windows, DBX UI opened from MCP | Tauri commands calling the Rust core   | Local app data directory               |
+| Docker / Web | Self-hosted access from a server or browser                           | HTTP routes calling the same Rust core | Docker volume or server data directory |
+
+<Callout type="info">The core database features are shared, but desktop-only integrations such as opening DBX windows from MCP require the desktop app to be running.</Callout>
+
+## Create Your First Connection
+
+<Steps>
+  <Step>
+    ### Open New Connection
+
+    Click **New Connection** from the sidebar or toolbar.
+
+  </Step>
+  <Step>
+    ### Pick A Database Type
+
+    Choose a built-in profile such as MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, ClickHouse, SQL Server, Oracle, or one of the compatibility and Agent/JDBC profiles listed in [Database Support](/en/docs/databases).
+
+  </Step>
+  <Step>
+    ### Fill Connection Details
+
+    For network databases, enter host, port, username, password, and default database when needed. For SQLite, DuckDB, and Access, select a local database file instead of host and port.
+
+  </Step>
+  <Step>
+    ### Paste A URL When Available
+
+    DBX can parse common connection URLs for engines such as MySQL, PostgreSQL, Redis, MongoDB, ClickHouse, SQL Server, Oracle, Elasticsearch, DM, GaussDB, openGauss, TDengine, and Access. Review the parsed fields before saving.
+
+  </Step>
+  <Step>
+    ### Add Network Options
+
+    Use [Tunnel / Proxy](/en/docs/ssh-tunnel) for databases behind private networks, bastion hosts, web-only gateways, or SOCKS5/HTTP proxy environments.
+
+  </Step>
+  <Step>
+    ### Test And Save
+
+    Click **Test** to verify credentials, network access, and permissions. After the test passes, save the connection and open it from the sidebar.
+
+  </Step>
+</Steps>
+
+<Callout type="info">Connection passwords, SSH passwords, SSH key passphrases, and connection strings are stored separately from the regular connection JSON in DBX's local storage. Use [Config Export/Import](/en/docs/config-export) when you need to migrate encrypted connection settings.</Callout>
+
+## Reduce Production Mistakes
+
+- Give production connections a distinct name, for example `prod-orders`.
+- Use connection colors so production, staging, and local databases are visually different.
+- Use visible database filtering when a server contains many databases but you only need a few.
+- Review generated SQL before applying edits, imports, transfers, SQL files, or schema sync operations.
+
+## What To Try Next
+
+<Cards>
+  <Card title="Write SQL" href="/en/docs/query-editor">
+    Use completion, formatting, selected execution, cancellation, and history.
+  </Card>
+  <Card title="Browse Data" href="/en/docs/data-grid">
+    Inspect results, edit rows when safe, preview SQL, and export data.
+  </Card>
+  <Card title="Explore Schema" href="/en/docs/schema-browser">
+    Browse databases, schemas, tables, columns, Redis keys, and MongoDB collections.
+  </Card>
+</Cards>
+
+## Common Connection Problems
+
+| Symptom                      | Check                                                                                          |
+| ---------------------------- | ---------------------------------------------------------------------------------------------- |
+| Timeout                      | Host, port, firewall, security group, VPN, Docker host reachability, or private network access |
+| Authentication failed        | Username, password, auth mode, SSL requirement, remote login permission                        |
+| Connected but no tables      | Default database, schema, permissions, metadata read access, visible database filter           |
+| File database cannot open    | File path, file permissions, mounted Docker volume, or unsupported file extension              |
+| Private database unreachable | Configure tunnel / proxy, VPN, or run Docker on a machine that can reach the database          |
+
+## Run From Source
+
+Use source mode when contributing or debugging DBX locally.
+
+### Requirements
+
+- [Node.js](https://nodejs.org/) >= 18
+- [pnpm](https://pnpm.io/)
+- Make
+- [Rust](https://www.rust-lang.org/tools/install) >= 1.77
+
+### System Dependencies
+
+<Tabs groupId="dev-platform" items={["macOS", "Linux", "Windows"]}>
+  <Tab value="macOS">```bash brew install unixodbc ```</Tab>
+  <Tab value="Linux">```bash sudo apt-get install -y libwebkit2gtk-4.1-dev libgtk-3-dev libappindicator3-dev librsvg2-dev patchelf libssl-dev unixodbc-dev ```</Tab>
+  <Tab value="Windows">Windows usually needs no extra system dependency for local DBX development.</Tab>
+</Tabs>
+
+### Start Development
+
+```bash
+git clone https://github.com/t8y2/dbx.git
+cd dbx
+make
+```
+
+`make` installs root dependencies when needed and starts the local Tauri desktop development environment.
+
+For the web version:
+
+```bash
+make dev-web
+make dev-backend
+```
+
+### Build Desktop Packages
+
+```bash
+make package
+```
+
+Desktop installers are written to `src-tauri/target/release/bundle/`.
diff --git a/docs/content/docs/keyboard-shortcuts.cn.mdx b/docs/content/docs/keyboard-shortcuts.cn.mdx
new file mode 100644
index 0000000..ec4558b
--- /dev/null
+++ b/docs/content/docs/keyboard-shortcuts.cn.mdx
@@ -0,0 +1,82 @@
+---
+title: 快捷键
+description: 配置和使用键盘快捷键，高效导航 DBX、执行查询和编辑数据。
+---
+
+DBX 为常用操作提供可配置的键盘快捷键。使用默认快捷键或自定义它们以匹配你的工作流程。
+
+## 默认快捷键
+
+### 查询编辑器
+
+| 快捷键                                 | 操作             |
+| -------------------------------------- | ---------------- |
+| `Ctrl+Enter` / `Cmd+Enter`             | 执行当前查询     |
+| `Ctrl+Shift+Enter` / `Cmd+Shift+Enter` | 执行所有查询     |
+| `Ctrl+/` / `Cmd+/`                     | 切换行注释       |
+| `Ctrl+F` / `Cmd+F`                     | 在编辑器中搜索   |
+| `Ctrl+S` / `Cmd+S`                     | 保存当前标签页   |
+| `Ctrl+A` / `Cmd+A`                     | 全选             |
+| `Shift+Alt+U`                          | 选中内容转为大写 |
+| `Shift+Alt+L`                          | 选中内容转为小写 |
+| `Tab`                                  | 缩进选中行       |
+| `Shift+Tab`                            | 取消缩进选中行   |
+
+### 数据表格
+
+| 快捷键                         | 操作                       |
+| ------------------------------ | -------------------------- |
+| `F5`                           | 刷新当前数据               |
+| `Ctrl+C` / `Cmd+C`             | 复制选中单元格             |
+| `Ctrl+Shift+C` / `Cmd+Shift+C` | 将选中行复制为 INSERT      |
+| `Delete`                       | 删除选中行（标记为待删除） |
+
+### 导航
+
+| 快捷键                         | 操作               |
+| ------------------------------ | ------------------ |
+| `Ctrl+P` / `Cmd+P`             | 快速打开数据库对象 |
+| `Ctrl+N` / `Cmd+N`             | 新建查询标签页     |
+| `Ctrl+Shift+F` / `Cmd+Shift+F` | 聚焦侧边栏搜索     |
+| `Ctrl+,` / `Cmd+,`             | 打开设置           |
+| `Ctrl+W` / `Cmd+W`             | 关闭当前标签页     |
+| `鼠标中键`（点击标签页）       | 关闭标签页         |
+
+## 快速打开（Ctrl+P）
+
+按 **Ctrl+P**（macOS 上为 **Cmd+P**）可快速导航到数据库对象，无需使用侧边栏：
+
+- 输入文本搜索表、视图、schema 或数据库
+- 模糊匹配可以用部分名称找到对象
+- 按 Enter 打开选中的对象
+- 在工作区的所有连接中工作
+
+当处理大型数据库时，快速打开特别有用，滚动侧边栏树会很慢。
+
+## 配置快捷键
+
+打开**设置 → 快捷键**来自定义按键绑定：
+
+1. 在列表中找到要更改的操作
+2. 点击当前快捷键进入录制模式
+3. 按下新的按键组合
+4. 新快捷键自动保存
+
+<Callout type="info">快捷键使用 Electron 风格的修饰键表示法：`Ctrl`（Windows/Linux 的 Control）、`Cmd`（macOS 的 Command）、`Shift` 和 `Alt`（macOS 的 Option）。</Callout>
+
+## 复制快捷键
+
+两个可配置的复制快捷键控制行级别的复制行为：
+
+- **复制当前行**：将当前行复制为制表符分隔的值
+- **删除当前行**：将当前行标记为待删除
+
+在**设置 → 快捷键**中设置它们以匹配你的偏好工作流程。
+
+## 冲突解决
+
+如果自定义快捷键与现有快捷键冲突：
+
+- DBX 会在保存前发出警告
+- 你可以选择保留冲突或选择其他组合
+- 系统快捷键（如 macOS 的 `Cmd+Q`）无法被覆盖
diff --git a/docs/content/docs/keyboard-shortcuts.mdx b/docs/content/docs/keyboard-shortcuts.mdx
new file mode 100644
index 0000000..f811f5f
--- /dev/null
+++ b/docs/content/docs/keyboard-shortcuts.mdx
@@ -0,0 +1,82 @@
+---
+title: Keyboard Shortcuts
+description: Configure and use keyboard shortcuts to navigate DBX, execute queries, and edit data efficiently.
+---
+
+DBX provides configurable keyboard shortcuts for common actions. Use the default shortcuts or customize them to match your workflow.
+
+## Default Shortcuts
+
+### Query Editor
+
+| Shortcut                               | Action                         |
+| -------------------------------------- | ------------------------------ |
+| `Ctrl+Enter` / `Cmd+Enter`             | Execute current query          |
+| `Ctrl+Shift+Enter` / `Cmd+Shift+Enter` | Execute all queries            |
+| `Ctrl+/` / `Cmd+/`                     | Toggle line comment            |
+| `Ctrl+F` / `Cmd+F`                     | Search in editor               |
+| `Ctrl+S` / `Cmd+S`                     | Save current tab               |
+| `Ctrl+A` / `Cmd+A`                     | Select all text                |
+| `Shift+Alt+U`                          | Convert selection to uppercase |
+| `Shift+Alt+L`                          | Convert selection to lowercase |
+| `Tab`                                  | Indent selected lines          |
+| `Shift+Tab`                            | Outdent selected lines         |
+
+### Data Grid
+
+| Shortcut                       | Action                                   |
+| ------------------------------ | ---------------------------------------- |
+| `F5`                           | Refresh current data                     |
+| `Ctrl+C` / `Cmd+C`             | Copy selected cells                      |
+| `Ctrl+Shift+C` / `Cmd+Shift+C` | Copy selected rows as INSERT             |
+| `Delete`                       | Delete selected rows (mark for deletion) |
+
+### Navigation
+
+| Shortcut                       | Action                              |
+| ------------------------------ | ----------------------------------- |
+| `Ctrl+P` / `Cmd+P`             | Quick open database objects         |
+| `Ctrl+N` / `Cmd+N`             | New query tab                       |
+| `Ctrl+Shift+F` / `Cmd+Shift+F` | Focus sidebar search                |
+| `Ctrl+,` / `Cmd+,`             | Open settings                       |
+| `Ctrl+W` / `Cmd+W`             | Close current tab                   |
+| `Middle Click` (on tab)        | Close tab                           |
+
+## Quick Open (Ctrl+P)
+
+Press **Ctrl+P** (or **Cmd+P** on macOS) to quickly navigate to database objects without using the sidebar:
+
+- Type to search for tables, views, schemas, or databases
+- Fuzzy matching finds objects even with partial names
+- Press Enter to open the selected object
+- Works across all connections in your workspace
+
+Quick open is especially useful when working with large databases where scrolling through the sidebar tree is slow.
+
+## Configuring Shortcuts
+
+Open **Settings → Shortcuts** to customize key bindings:
+
+1. Find the action you want to change in the list
+2. Click the current shortcut to enter recording mode
+3. Press the new key combination
+4. The new shortcut is saved automatically
+
+<Callout type="info">Shortcuts use the Electron-style modifier key notation: `Ctrl` (Control on Windows/Linux), `Cmd` (Command on macOS), `Shift`, and `Alt` (Option on macOS).</Callout>
+
+## Copy Shortcuts
+
+Two configurable copy shortcuts control row-level copy behavior:
+
+- **Copy Current Row**: Copies the current row as tab-separated values
+- **Delete Current Row**: Marks the current row for deletion
+
+Set these in **Settings → Shortcuts** to match your preferred workflow.
+
+## Conflict Resolution
+
+If a custom shortcut conflicts with an existing one:
+
+- DBX warns you before saving
+- You can choose to keep the conflict or choose a different combination
+- System shortcuts (like `Cmd+Q` on macOS) cannot be overridden
diff --git a/docs/content/docs/mcp.cn.mdx b/docs/content/docs/mcp.cn.mdx
new file mode 100644
index 0000000..b6d8578
--- /dev/null
+++ b/docs/content/docs/mcp.cn.mdx
@@ -0,0 +1,275 @@
+---
+title: MCP 集成
+description: 通过 MCP 协议让 Claude Code、Cursor 等 AI 编程助手直接查询你的数据库。
+---
+
+<Callout type="info">一行配置，让 AI 编程助手直接查询你的数据库。支持 Claude Code、Cursor、Windsurf、VS Code Copilot。</Callout>
+
+## 什么是 MCP？
+
+MCP（Model Context Protocol）是一个开放协议，让 AI 编程助手能够调用外部工具。DBX 的 MCP Server 把你在 DBX 中配置的数据库连接暴露给 AI 助手，这样你可以用自然语言查询数据库，AI 自动生成并执行 SQL。
+
+```
+你："查看 orders 表最近 7 天的订单量趋势"
+
+AI 助手 → MCP Server → 你的数据库 → 返回结果
+                ↓
+         DBX 的连接配置（含密码）
+```
+
+## 快速开始
+
+<Steps>
+  <Step>
+    ### 安装 MCP Server
+
+    ```bash
+    npm install -g @dbx-app/mcp-server
+    ```
+
+  </Step>
+  <Step>
+    ### 配置 AI 助手
+
+    在你的工作目录创建 `.mcp.json`：
+
+    ```json
+    {
+      "mcpServers": {
+        "dbx": {
+          "command": "npx",
+          "args": ["-y", "@dbx-app/mcp-server"]
+        }
+      }
+    }
+    ```
+
+    Windows 便携版需要额外设置 `DBX_DATA_DIR`，指向 `DBX.exe` 同级的 `data` 目录：
+
+    ```json
+    {
+      "mcpServers": {
+        "dbx": {
+          "command": "npx",
+          "args": ["-y", "@dbx-app/mcp-server"],
+          "env": {
+            "DBX_DATA_DIR": "D:\\DBX_x64-portable\\data"
+          }
+        }
+      }
+    }
+    ```
+
+  </Step>
+  <Step>
+    ### 开始使用
+
+    在 AI 助手中直接用自然语言说：
+
+    - "列出我的数据库连接"
+    - "查看 local-pg 上有哪些表"
+    - "查看 users 表的结构"
+    - "查询最近 7 天的订单数量"
+    - "打开 orders 表"（需要 DBX 运行中）
+
+  </Step>
+</Steps>
+
+## 支持的 AI 助手
+
+| 助手              | 配置方式                |
+| ----------------- | ----------------------- |
+| Claude Code       | `.mcp.json`（原生支持） |
+| Cursor            | `.cursor/mcp.json`      |
+| Windsurf          | `.windsurfrules`        |
+| VS Code + Copilot | MCP 扩展                |
+
+## 工具列表
+
+DBX MCP Server 提供以下工具，AI 助手会根据你的需求自动调用：
+
+### `dbx_list_connections`
+
+列出 DBX 中所有已配置的数据库连接。
+
+**示例对话：**
+
+> "列出我的数据库连接"
+
+**返回：**
+
+```
+| Name     | Type     | Host      | Port | Database |
+| -------- | -------- | --------- | ---- | -------- |
+| local-pg | postgres | 127.0.0.1 | 5432 |          |
+| prod-db  | mysql    | db.example| 3306 | myapp    |
+```
+
+### `dbx_list_tables`
+
+列出指定连接的表和视图。
+
+| 参数              | 必填 | 说明                       |
+| ----------------- | ---- | -------------------------- |
+| `connection_name` | 是   | DBX 连接名称               |
+| `schema`          | 否   | Schema 名称（默认 public） |
+
+### `dbx_describe_table`
+
+获取表的列定义，AI 用它来理解你的数据结构。
+
+| 参数              | 必填 | 说明                       |
+| ----------------- | ---- | -------------------------- |
+| `connection_name` | 是   | DBX 连接名称               |
+| `table`           | 是   | 表名                       |
+| `schema`          | 否   | Schema 名称（默认 public） |
+
+**返回：**
+
+```
+| Column      | Type      | Nullable | Default | Comment |
+| ----------- | --------- | -------- | ------- | ------- |
+| id (PK)     | integer   | NO       |         |         |
+| user_id     | integer   | NO       |         | 用户 ID  |
+| total       | numeric   | NO       | 0       | 订单金额 |
+| created_at  | timestamp | NO       | now()   |         |
+```
+
+### `dbx_execute_query`
+
+执行 SQL 查询，返回结果（最多 100 行）。
+
+| 参数              | 必填 | 说明         |
+| ----------------- | ---- | ------------ |
+| `connection_name` | 是   | DBX 连接名称 |
+| `sql`             | 是   | SQL 查询语句 |
+
+### `dbx_get_schema_context`
+
+返回用于生成 SQL 的紧凑表结构上下文。
+
+| 参数              | 必填 | 说明                                 |
+| ----------------- | ---- | ------------------------------------ |
+| `connection_name` | 是   | DBX 连接名称                         |
+| `schema`          | 否   | Schema 名称                          |
+| `tables`          | 否   | 指定要包含的表名                     |
+| `max_tables`      | 否   | 最多包含多少张表，范围限制在 1 到 20 |
+
+### `dbx_add_connection`
+
+添加新的数据库连接。
+
+| 参数       | 必填 | 说明                                            |
+| ---------- | ---- | ----------------------------------------------- |
+| `name`     | 是   | 连接名称                                        |
+| `db_type`  | 是   | 数据库类型（postgres、mysql、sqlite、redis 等） |
+| `host`     | 是   | 数据库主机                                      |
+| `port`     | 是   | 数据库端口                                      |
+| `username` | 否   | 用户名                                          |
+| `password` | 否   | 密码                                            |
+| `database` | 否   | 默认数据库名                                    |
+| `ssl`      | 否   | 是否启用 SSL（默认 false）                      |
+
+**示例对话：**
+
+> "添加一个 PostgreSQL 连接，名称 prod-db，地址 db.example.com:5432"
+
+### `dbx_remove_connection`
+
+删除数据库连接。
+
+| 参数              | 必填 | 说明             |
+| ----------------- | ---- | ---------------- |
+| `connection_name` | 是   | 要删除的连接名称 |
+
+**示例对话：**
+
+> "删除 test-db 连接"
+
+### `dbx_open_table`
+
+在 DBX 桌面端打开指定表。**需要 DBX 正在运行。**
+
+| 参数              | 必填 | 说明         |
+| ----------------- | ---- | ------------ |
+| `connection_name` | 是   | DBX 连接名称 |
+| `table`           | 是   | 表名         |
+| `database`        | 否   | 数据库名     |
+| `schema`          | 否   | Schema 名称  |
+
+DBX 会自动新开一个 tab 显示数据，窗口自动置前。
+
+### `dbx_execute_and_show`
+
+在 DBX 桌面端执行 SQL 并展示结果。**需要 DBX 正在运行。**
+
+| 参数              | 必填 | 说明         |
+| ----------------- | ---- | ------------ |
+| `connection_name` | 是   | DBX 连接名称 |
+| `sql`             | 是   | SQL 查询语句 |
+| `database`        | 否   | 数据库名     |
+
+## 工作原理
+
+### 连接配置
+
+MCP Server 从 DBX 的 SQLite 数据库读取连接信息：
+
+| 平台    | 路径                                               |
+| ------- | -------------------------------------------------- |
+| macOS   | `~/Library/Application Support/com.dbx.app/dbx.db` |
+| Linux   | `~/.local/share/com.dbx.app/dbx.db`                |
+| Windows | `%APPDATA%\com.dbx.app\dbx.db`                     |
+
+Windows 便携版的数据通常在 `DBX.exe` 同级的 `data\dbx.db`。如果 MCP 列出的连接不是当前 DBX 中的最新连接，请在 MCP 配置中设置 `DBX_DATA_DIR`，值为包含 `dbx.db` 的 `data` 文件夹，例如 `D:\DBX_x64-portable\data`。不要手工复制 `dbx.db` 到默认目录，否则两个连接库会分叉。
+
+### UI 联动
+
+`dbx_open_table` 和 `dbx_execute_and_show` 通过本地 HTTP 接口与运行中的 DBX 应用通信：
+
+```
+AI 助手 → MCP Server → HTTP localhost → DBX 后端 → Tauri 事件 → 前端打开 tab
+```
+
+### 支持的数据库
+
+桌面本地模式下，MCP 查询支持 PostgreSQL、MySQL 及兼容数据库。Web 模式会通过 `DBX_WEB_URL` 转发到 DBX Web 后端。打开表等 UI 联动能力支持当前 DBX 桌面端可以打开的所有数据库类型。
+
+### SQL 安全
+
+MCP 查询执行默认非常保守：
+
+| 规则                                           | 默认行为                           |
+| ---------------------------------------------- | ---------------------------------- |
+| 空 SQL 或无法识别的 SQL                        | 阻止                               |
+| 多条 SQL 语句                                  | 允许；会逐条进行安全检查并依次执行 |
+| 非只读 SQL                                     | 阻止，除非显式允许写入             |
+| `DROP`、`TRUNCATE`、`ALTER`                    | 阻止，除非显式允许危险 SQL         |
+| 允许写入时没有 `WHERE` 的 `UPDATE` 或 `DELETE` | 阻止                               |
+
+设置 `DBX_MCP_ALLOW_WRITES=1` 可以允许写入语句。只有在受控环境并且确实需要破坏性 SQL 时，才设置 `DBX_MCP_ALLOW_DANGEROUS_SQL=1`。
+
+### 桌面模式与 Web 模式
+
+| 模式         | 如何选择           | 说明                                                     |
+| ------------ | ------------------ | -------------------------------------------------------- |
+| 桌面本地模式 | 默认               | 读取 DBX 桌面端连接存储，并可调用桌面专属 UI bridge 工具 |
+| Web 模式     | 设置 `DBX_WEB_URL` | 不读取本机桌面存储，而是把请求发给 DBX Web 后端          |
+
+对于启用了密码保护的 DBX Web 或 Docker 部署，还需要在 MCP Server 环境变量中设置 `DBX_WEB_PASSWORD`。这里填写的就是 DBX Web 登录页使用的密码，也包括首次打开 Web 页面时通过 setup 设置的密码。为了让 MCP 可用，不需要在启动 DBX Web 时额外设置 `DBX_PASSWORD`；`DBX_PASSWORD` 只是服务端环境变量覆盖。当 Web 后端要求认证但没有提供密码时，MCP 调用会在返回任何连接数据前失败。桌面本地模式不使用 `DBX_WEB_PASSWORD`。
+
+## 常见问题
+
+<Accordions>
+  <Accordion title="MCP Server 连不上数据库">检查 DBX 中该连接是否能正常连接。MCP Server 使用相同的连接配置和密码。确认数据库服务正在运行，网络可达。</Accordion>
+  <Accordion title="dbx_open_table 报 'DBX is not running'">需要先启动 DBX 桌面应用。UI 联动功能依赖 DBX 运行时的本地 HTTP 服务（端口 4224）。</Accordion>
+  <Accordion title="连接名称找不到">连接名称匹配不区分大小写，但需要和 DBX 中配置的名称一致。用 `dbx_list_connections` 查看所有可用名称。</Accordion>
+  <Accordion title="查询超时">MCP Server 的查询超时为 30 秒。如果查询较慢，考虑添加索引或简化查询。也可以让 AI 助手先用 `dbx_describe_table` 了解表结构，再生成优化后的查询。</Accordion>
+  <Accordion title="Docker 环境下如何使用 MCP？">把 `DBX_WEB_URL` 设置为 DBX Web 地址。如果 Web 页面需要密码，也要把 `DBX_WEB_PASSWORD` 设置为同一个 Web 登录密码；否则 MCP 会拒绝访问受保护的 Web API。</Accordion>
+</Accordions>
+
+## 系统要求
+
+- [DBX](https://github.com/t8y2/dbx) 已安装并配置了至少一个数据库连接
+- Node.js 18+
+- UI 联动功能需要 DBX v0.3.9+
diff --git a/docs/content/docs/mcp.mdx b/docs/content/docs/mcp.mdx
new file mode 100644
index 0000000..c213cb5
--- /dev/null
+++ b/docs/content/docs/mcp.mdx
@@ -0,0 +1,275 @@
+---
+title: MCP Integration
+description: Let AI coding agents query your databases through the Model Context Protocol.
+---
+
+<Callout type="info">One line of config to let AI coding agents query your databases directly. Works with Claude Code, Cursor, Windsurf, and VS Code Copilot.</Callout>
+
+## What is MCP?
+
+MCP (Model Context Protocol) is an open protocol that lets AI coding agents call external tools. DBX's MCP Server exposes your database connections to AI agents, so you can query databases using natural language — the AI generates and executes SQL automatically.
+
+```
+You: "Show me the order volume trend for the last 7 days"
+
+AI Agent → MCP Server → Your Database → Results
+                ↓
+         DBX connection configs (with passwords)
+```
+
+## Quick Start
+
+<Steps>
+  <Step>
+    ### Install the MCP Server
+
+    ```bash
+    npm install -g @dbx-app/mcp-server
+    ```
+
+  </Step>
+  <Step>
+    ### Configure Your AI Agent
+
+    Create `.mcp.json` in your working directory:
+
+    ```json
+    {
+      "mcpServers": {
+        "dbx": {
+          "command": "npx",
+          "args": ["-y", "@dbx-app/mcp-server"]
+        }
+      }
+    }
+    ```
+
+    Windows portable builds need `DBX_DATA_DIR` set to the `data` directory next to `DBX.exe`:
+
+    ```json
+    {
+      "mcpServers": {
+        "dbx": {
+          "command": "npx",
+          "args": ["-y", "@dbx-app/mcp-server"],
+          "env": {
+            "DBX_DATA_DIR": "D:\\DBX_x64-portable\\data"
+          }
+        }
+      }
+    }
+    ```
+
+  </Step>
+  <Step>
+    ### Start Using
+
+    Just ask your AI agent in natural language:
+
+    - "List my database connections"
+    - "Show the tables in my local-pg connection"
+    - "Describe the users table"
+    - "Query the average salary from employees"
+    - "Open the orders table" (requires DBX running)
+
+  </Step>
+</Steps>
+
+## Supported AI Agents
+
+| Agent             | Configuration                |
+| ----------------- | ---------------------------- |
+| Claude Code       | `.mcp.json` (native support) |
+| Cursor            | `.cursor/mcp.json`           |
+| Windsurf          | `.windsurfrules`             |
+| VS Code + Copilot | MCP extension                |
+
+## Tools
+
+DBX MCP Server provides the following tools. Your AI agent calls them automatically based on your requests:
+
+### `dbx_list_connections`
+
+List all database connections configured in DBX.
+
+**Example:**
+
+> "List my database connections"
+
+**Response:**
+
+```
+| Name     | Type     | Host      | Port | Database |
+| -------- | -------- | --------- | ---- | -------- |
+| local-pg | postgres | 127.0.0.1 | 5432 |          |
+| prod-db  | mysql    | db.example| 3306 | myapp    |
+```
+
+### `dbx_list_tables`
+
+List tables and views for a connection.
+
+| Parameter         | Required | Description                   |
+| ----------------- | -------- | ----------------------------- |
+| `connection_name` | Yes      | DBX connection name           |
+| `schema`          | No       | Schema name (default: public) |
+
+### `dbx_describe_table`
+
+Get column definitions for a table. The AI uses this to understand your data structure before generating queries.
+
+| Parameter         | Required | Description                   |
+| ----------------- | -------- | ----------------------------- |
+| `connection_name` | Yes      | DBX connection name           |
+| `table`           | Yes      | Table name                    |
+| `schema`          | No       | Schema name (default: public) |
+
+**Response:**
+
+```
+| Column      | Type      | Nullable | Default | Comment    |
+| ----------- | --------- | -------- | ------- | ---------- |
+| id (PK)     | integer   | NO       |         |            |
+| user_id     | integer   | NO       |         | User ID    |
+| total       | numeric   | NO       | 0       | Order total|
+| created_at  | timestamp | NO       | now()   |            |
+```
+
+### `dbx_execute_query`
+
+Execute a SQL query and return results (max 100 rows).
+
+| Parameter         | Required | Description         |
+| ----------------- | -------- | ------------------- |
+| `connection_name` | Yes      | DBX connection name |
+| `sql`             | Yes      | SQL query           |
+
+### `dbx_get_schema_context`
+
+Return compact table and column context for SQL generation.
+
+| Parameter         | Required | Description                                                  |
+| ----------------- | -------- | ------------------------------------------------------------ |
+| `connection_name` | Yes      | DBX connection name                                          |
+| `schema`          | No       | Schema name                                                  |
+| `tables`          | No       | Specific table names to include                              |
+| `max_tables`      | No       | Maximum number of tables to include; capped between 1 and 20 |
+
+### `dbx_add_connection`
+
+Add a new database connection to DBX.
+
+| Parameter  | Required | Description                                          |
+| ---------- | -------- | ---------------------------------------------------- |
+| `name`     | Yes      | Connection name                                      |
+| `db_type`  | Yes      | Database type (postgres, mysql, sqlite, redis, etc.) |
+| `host`     | Yes      | Database host                                        |
+| `port`     | Yes      | Database port                                        |
+| `username` | No       | Username                                             |
+| `password` | No       | Password                                             |
+| `database` | No       | Default database name                                |
+| `ssl`      | No       | Enable SSL (default: false)                          |
+
+**Example:**
+
+> "Add a PostgreSQL connection named prod-db on db.example.com:5432"
+
+### `dbx_remove_connection`
+
+Remove a database connection from DBX.
+
+| Parameter         | Required | Description                      |
+| ----------------- | -------- | -------------------------------- |
+| `connection_name` | Yes      | Name of the connection to remove |
+
+**Example:**
+
+> "Remove the test-db connection"
+
+### `dbx_open_table`
+
+Open a table in DBX desktop app UI. **Requires DBX to be running.**
+
+| Parameter         | Required | Description         |
+| ----------------- | -------- | ------------------- |
+| `connection_name` | Yes      | DBX connection name |
+| `table`           | Yes      | Table name          |
+| `database`        | No       | Database name       |
+| `schema`          | No       | Schema name         |
+
+DBX opens a new tab with the table data and brings the window to front.
+
+### `dbx_execute_and_show`
+
+Execute a SQL query in DBX desktop app UI. **Requires DBX to be running.**
+
+| Parameter         | Required | Description         |
+| ----------------- | -------- | ------------------- |
+| `connection_name` | Yes      | DBX connection name |
+| `sql`             | Yes      | SQL query           |
+| `database`        | No       | Database name       |
+
+## How It Works
+
+### Connection Configs
+
+The MCP Server reads DBX's SQLite database:
+
+| Platform | Path                                               |
+| -------- | -------------------------------------------------- |
+| macOS    | `~/Library/Application Support/com.dbx.app/dbx.db` |
+| Linux    | `~/.local/share/com.dbx.app/dbx.db`                |
+| Windows  | `%APPDATA%\com.dbx.app\dbx.db`                     |
+
+Windows portable builds usually store data in `data\dbx.db` next to `DBX.exe`. If MCP lists older connections than the running DBX app, set `DBX_DATA_DIR` in the MCP config to the `data` folder that contains `dbx.db`, for example `D:\DBX_x64-portable\data`. Do not copy `dbx.db` into the default directory, because that creates two diverging connection stores.
+
+### UI Integration
+
+`dbx_open_table` and `dbx_execute_and_show` communicate with the running DBX app via a local HTTP interface:
+
+```
+AI Agent → MCP Server → HTTP localhost → DBX backend → Tauri event → Frontend opens tab
+```
+
+### Supported Databases
+
+MCP query support in desktop local mode is implemented for PostgreSQL, MySQL, and compatible databases. Web mode delegates to the DBX web backend configured by `DBX_WEB_URL`. UI integration such as opening a table supports all database types that the running DBX desktop app can open.
+
+### SQL Safety
+
+MCP query execution is intentionally conservative:
+
+| Rule                                                         | Default                                                    |
+| ------------------------------------------------------------ | ---------------------------------------------------------- |
+| Empty or unrecognized SQL                                    | Blocked                                                    |
+| Multiple SQL statements                                      | Allowed; each statement is checked and executed separately |
+| Non-read SQL                                                 | Blocked unless writes are explicitly allowed               |
+| `DROP`, `TRUNCATE`, or `ALTER`                               | Blocked unless dangerous SQL is explicitly allowed         |
+| `UPDATE` or `DELETE` without `WHERE` when writes are allowed | Blocked                                                    |
+
+Set `DBX_MCP_ALLOW_WRITES=1` to allow write statements. Set `DBX_MCP_ALLOW_DANGEROUS_SQL=1` only in controlled environments where destructive SQL is expected.
+
+### Desktop And Web Mode
+
+| Mode               | How It Is Selected | Notes                                                                          |
+| ------------------ | ------------------ | ------------------------------------------------------------------------------ |
+| Desktop local mode | Default            | Reads DBX desktop connection storage and can call desktop-only UI bridge tools |
+| Web mode           | Set `DBX_WEB_URL`  | Sends requests to the DBX web backend instead of reading local desktop storage |
+
+For DBX Web or Docker deployments that have password protection enabled, also set `DBX_WEB_PASSWORD` in the MCP server environment. This is the same password used on the DBX Web login page, including the password created by the first-run setup screen. You do not need to set `DBX_PASSWORD` on the DBX Web server just for MCP; `DBX_PASSWORD` is only a server-side environment override. MCP calls fail before returning connection data when the Web backend requires authentication and no password is provided. Desktop local mode does not use `DBX_WEB_PASSWORD`.
+
+## FAQ
+
+<Accordions>
+  <Accordion title="MCP Server can't connect to my database">Check that the connection works in DBX first. The MCP Server uses the same config and credentials. Make sure the database is running and network-reachable.</Accordion>
+  <Accordion title="dbx_open_table says 'DBX is not running'">Start the DBX desktop app first. UI integration requires DBX's local HTTP service (port 4224).</Accordion>
+  <Accordion title="Connection name not found">Connection name matching is case-insensitive but must match the name configured in DBX. Use `dbx_list_connections` to see all available names.</Accordion>
+  <Accordion title="Query timeout">MCP Server has a 30-second query timeout. Consider adding indexes or simplifying your query. You can also ask the AI to use `dbx_describe_table` first to understand the schema, then generate an optimized query.</Accordion>
+  <Accordion title="How to use MCP with Docker?">Set `DBX_WEB_URL` to your DBX Web URL. If the Web UI requires a password, set `DBX_WEB_PASSWORD` to the same password used on the Web login page; otherwise MCP will refuse protected Web API access.</Accordion>
+</Accordions>
+
+## Requirements
+
+- [DBX](https://github.com/t8y2/dbx) installed with at least one connection configured
+- Node.js 18+
+- UI integration requires DBX v0.3.9+
diff --git a/docs/content/docs/meta.cn.json b/docs/content/docs/meta.cn.json
new file mode 100644
index 0000000..c26d840
--- /dev/null
+++ b/docs/content/docs/meta.cn.json
@@ -0,0 +1,40 @@
+{
+  "title": "DBX 文档",
+  "pages": [
+    "---介绍---",
+    "what-is-dbx",
+    "changelog",
+    "getting-started",
+    "databases",
+    "---核心功能---",
+    "query-editor",
+    "data-grid",
+    "schema-browser",
+    "redis",
+    "mongodb",
+    "object-browser",
+    "---高级功能---",
+    "schema-diff",
+    "data-transfer",
+    "table-structure",
+    "field-lineage",
+    "table-import",
+    "sql-file",
+    "database-export",
+    "sql-snippets",
+    "---AI 与自动化---",
+    "ai-assistant",
+    "cli",
+    "mcp",
+    "web-api",
+    "---设置---",
+    "plugins",
+    "driver-management",
+    "sql-formatter",
+    "keyboard-shortcuts",
+    "connection-import",
+    "config-export",
+    "cloud-sync",
+    "ssh-tunnel"
+  ]
+}
diff --git a/docs/content/docs/meta.json b/docs/content/docs/meta.json
new file mode 100644
index 0000000..6f42cf3
--- /dev/null
+++ b/docs/content/docs/meta.json
@@ -0,0 +1,40 @@
+{
+  "title": "DBX Docs",
+  "pages": [
+    "---Introduction---",
+    "what-is-dbx",
+    "changelog",
+    "getting-started",
+    "databases",
+    "---Core Features---",
+    "query-editor",
+    "data-grid",
+    "schema-browser",
+    "redis",
+    "mongodb",
+    "object-browser",
+    "---Advanced Features---",
+    "schema-diff",
+    "data-transfer",
+    "table-structure",
+    "field-lineage",
+    "table-import",
+    "sql-file",
+    "database-export",
+    "sql-snippets",
+    "---AI & Automation---",
+    "ai-assistant",
+    "cli",
+    "mcp",
+    "web-api",
+    "---Settings---",
+    "plugins",
+    "driver-management",
+    "sql-formatter",
+    "keyboard-shortcuts",
+    "connection-import",
+    "config-export",
+    "cloud-sync",
+    "ssh-tunnel"
+  ]
+}
diff --git a/docs/content/docs/mongodb.cn.mdx b/docs/content/docs/mongodb.cn.mdx
new file mode 100644
index 0000000..b8aa694
--- /dev/null
+++ b/docs/content/docs/mongodb.cn.mdx
@@ -0,0 +1,73 @@
+---
+title: MongoDB 浏览器
+description: 浏览 MongoDB 数据库和集合、查看文档，并使用内置 JSON 编辑器编辑数据。
+---
+
+DBX 支持浏览和编辑 MongoDB 数据库，提供专为 MongoDB 灵活 schema 模型设计的文档导向界面。
+
+## 集合浏览器
+
+MongoDB 数据库和集合与关系型数据库一同显示在侧边栏中。浏览器支持：
+
+- 列出服务器上的所有数据库
+- 列出每个数据库中的集合
+- 集合文档的分页浏览
+- 文档查询的过滤和排序支持
+- **数据库和集合删除**：右键点击数据库或集合即可删除
+- **集合元数据**：查看集合统计信息，包括文档数、大小和索引
+
+<Callout type="info">MongoDB 连接同时支持标准连接字符串和旧版连接格式。对于副本集，请使用标准的 `mongodb://` 连接 URL 并指定副本集名称。</Callout>
+
+## 切换数据库
+
+在 MongoDB 命令运行器中使用 `use <database>` 命令切换活动数据库。这相当于 MongoDB shell 的 `use` 命令，会更新后续操作的当前数据库上下文。
+
+## 表格视图
+
+集合以表格视图展示，将文档结构扁平化：
+
+- 顶层字段显示为列
+- 嵌套字段以点号表示（如 `address.city`）
+- 各文档之间缺失的字段会被妥善处理
+- 列宽自动适应内容
+
+## 文档查看器
+
+点击任意文档可在详情面板中打开。JSON 查看器提供：
+
+- 语法高亮的 JSON 显示
+- 可折叠的嵌套对象和数组
+- 复制单个字段或整个文档
+
+## 内联编辑
+
+直接从表格视图编辑文档：
+
+- 双击单元格编辑其值
+- 更改会在本地暂存，保存前可预览
+- 应用前检查生成的更新命令
+
+## JSON 编辑器
+
+对于涉及嵌套字段的复杂编辑，可使用 JSON 编辑器：
+
+- 以 JSON 格式编辑整个文档
+- 保存前进行语法验证
+- 适用于添加新的嵌套字段或重构文档结构
+- **日期保留**：编辑过程中正确保留日期值，维持其原始类型
+
+## MongoDB 版本
+
+DBX 通过内置驱动支持 MongoDB 4.2 及以上版本。对于 4.2 之前版本的 MongoDB 实例，DBX 可以回退到 JDBC Agent 驱动。有关配置 Agent 驱动的详细信息，请参阅[驱动管理](/cn/docs/driver-management)。
+
+## 功能覆盖
+
+| 功能               | 支持情况     |
+| ------------------ | ------------ |
+| 列出数据库和集合   | 所有版本     |
+| 分页文档浏览       | 所有版本     |
+| 扁平化字段表格视图 | 所有版本     |
+| 过滤和排序         | MongoDB 4.2+ |
+| 内联编辑           | 所有版本     |
+| JSON 文档编辑器    | 所有版本     |
+| SSH 隧道           | 标准连接     |
diff --git a/docs/content/docs/mongodb.mdx b/docs/content/docs/mongodb.mdx
new file mode 100644
index 0000000..0518d92
--- /dev/null
+++ b/docs/content/docs/mongodb.mdx
@@ -0,0 +1,73 @@
+---
+title: MongoDB Browser
+description: Browse MongoDB databases and collections, view documents, and edit data with the built-in JSON editor.
+---
+
+DBX supports browsing and editing MongoDB databases with a document-oriented interface designed for MongoDB's flexible schema model.
+
+## Collections Browser
+
+MongoDB databases and collections appear in the sidebar alongside relational databases. The browser supports:
+
+- Listing all databases on the server
+- Listing collections within each database
+- Paginated document browsing within collections
+- Filter and sort support for document queries
+- **Database and collection deletion**: Right-click on a database or collection to delete it
+- **Collection metadata**: View collection statistics including document count, size, and indexes
+
+<Callout type="info">MongoDB connections support both standard connection strings and legacy connection formats. For replica sets, use the standard `mongodb://` connection URL with the replica set name.</Callout>
+
+## Switching Databases
+
+Use the `use <database>` command in the MongoDB command runner to switch the active database. This is equivalent to the MongoDB shell's `use` command and updates the current database context for subsequent operations.
+
+## Table View
+
+Collections are displayed in a table view that flattens the document structure:
+
+- Top-level fields appear as columns
+- Nested fields are shown in dot notation (e.g., `address.city`)
+- Missing fields across documents are handled gracefully
+- Column widths auto-fit to content
+
+## Document Viewer
+
+Click any document to open it in the detail panel. The JSON viewer provides:
+
+- Syntax-highlighted JSON display
+- Collapsible nested objects and arrays
+- Copy individual fields or the entire document
+
+## Inline Editing
+
+Edit documents directly from the table view:
+
+- Double-click a cell to edit its value
+- Changes are staged locally before saving
+- Review the generated update command before applying
+
+## JSON Editor
+
+For complex edits that span nested fields, use the JSON editor:
+
+- Edit the full document as JSON
+- Syntax validation before saving
+- Useful for adding new nested fields or restructuring documents
+- **Date preservation**: Date values are preserved correctly during edits, maintaining their original type
+
+## MongoDB Versions
+
+DBX supports MongoDB 4.2 and later through the built-in driver. For pre-4.2 MongoDB instances, DBX can fall back to the JDBC agent driver. See [Driver Management](/en/docs/driver-management) for details on configuring agent drivers.
+
+## Feature Coverage
+
+| Feature                           | Support              |
+| --------------------------------- | -------------------- |
+| List databases and collections    | All versions         |
+| Document browsing with pagination | All versions         |
+| Table view with flattened fields  | All versions         |
+| Filter and sort                   | MongoDB 4.2+         |
+| Inline editing                    | All versions         |
+| JSON document editor              | All versions         |
+| SSH tunnel                        | Standard connections |
diff --git a/docs/content/docs/object-browser.cn.mdx b/docs/content/docs/object-browser.cn.mdx
new file mode 100644
index 0000000..22a3a4c
--- /dev/null
+++ b/docs/content/docs/object-browser.cn.mdx
@@ -0,0 +1,56 @@
+---
+title: 对象浏览器
+description: 浏览视图、存储过程、函数以及表与结构之外的数据库对象。
+---
+
+对象浏览器将侧边栏的功能扩展到表和集合之外，集中展示那些通常需要单独查询才能查看的数据库对象。
+
+## 对象浏览器展示的内容
+
+| 对象类型 | 展示信息                        |
+| -------- | ------------------------------- |
+| 视图     | 视图定义（DDL）、列列表、Schema |
+| 存储过程 | 源代码、参数、语言              |
+| 函数     | 返回类型、参数、源代码          |
+| 触发器   | 时机、事件、关联表、源代码      |
+| 例程     | 存储过程和函数的合并视图        |
+
+<Callout type="info">对象浏览器的可用性取决于数据库引擎及其元数据支持。并非所有数据库都能通过标准 SQL 暴露源代码或例程元数据。</Callout>
+
+## 打开对象浏览器
+
+从侧边栏打开对象浏览器：
+
+- **双击**数据库或 Schema 节点打开其对象浏览器
+- 右键点击并从上下文菜单中选择**对象浏览器**
+- 对任意对象使用**查看 DDL** 操作查看其源定义
+
+## 查看 DDL
+
+**查看 DDL** 操作显示视图、存储过程或函数的完整 `CREATE` 语句：
+
+- 在只读 SQL 查看器中以语法高亮显示
+- 复制 DDL 用于迁移脚本或文档
+- 跨环境比较定义差异
+
+## 编辑对象源代码
+
+对于支持 `CREATE OR REPLACE` 语义的数据库，可以直接编辑对象源代码：
+
+- 存储过程和函数可编辑并保存
+- DBX 会生成适当的 `CREATE OR REPLACE` 或 `ALTER` 语句
+- 在应用更改前检查生成的 SQL
+
+<Callout type="warn">在数据库中直接编辑对象可能会影响正在运行的应用程序。在保存更改前请验证对象的使用情况，尤其是在生产数据库上。</Callout>
+
+## 对象时间戳
+
+当数据库提供时，对象浏览器会显示对象元数据时间戳：
+
+- 创建时间
+- 最后修改时间
+- 有助于追踪最近更改或发现过时对象
+
+## 功能边界
+
+对象源代码编辑仅支持允许程序化替换源代码的数据库。只读数据库、某些旧版本和部分云数据库服务可能不提供可编辑的对象源代码。在这些情况下，可使用对象浏览器进行查看，并复制 DDL 进行手动执行。
diff --git a/docs/content/docs/object-browser.mdx b/docs/content/docs/object-browser.mdx
new file mode 100644
index 0000000..18068bc
--- /dev/null
+++ b/docs/content/docs/object-browser.mdx
@@ -0,0 +1,56 @@
+---
+title: Object Browser
+description: Browse views, procedures, functions, and other database objects beyond tables and schemas.
+---
+
+The Object Browser extends the sidebar beyond tables and collections. It surfaces database objects that are often hidden or require separate queries to inspect.
+
+## What the Object Browser Shows
+
+| Object Type | Information Shown                          |
+| ----------- | ------------------------------------------ |
+| Views       | View definition (DDL), column list, schema |
+| Procedures  | Source code, parameters, language          |
+| Functions   | Return type, parameters, source code       |
+| Triggers    | Timing, event, table, source               |
+| Routines    | Combined view of procedures and functions  |
+
+<Callout type="info">Object Browser availability depends on the database engine and its metadata support. Not all databases expose source code or routine metadata through standard SQL.</Callout>
+
+## Opening the Object Browser
+
+Open the Object Browser from the sidebar:
+
+- **Double-click** a database or schema node to open its Object Browser
+- Right-click and choose **Object Browser** from the context menu
+- Use the **View DDL** action on any object to see its source definition
+
+## View DDL
+
+The **View DDL** action shows the complete `CREATE` statement for a view, procedure, or function:
+
+- Displayed in a read-only SQL viewer with syntax highlighting
+- Copy the DDL to use in migration scripts or documentation
+- Compare definitions between environments
+
+## Editing Object Source
+
+For databases that support `CREATE OR REPLACE` semantics, you can edit object source directly:
+
+- Procedures and functions can be edited and saved
+- DBX generates the appropriate `CREATE OR REPLACE` or `ALTER` statement
+- Review the generated SQL before applying changes
+
+<Callout type="warn">Editing database objects in place may affect running applications. Verify the object's usage before saving changes, especially on production databases.</Callout>
+
+## Object Timestamps
+
+When the database provides it, the Object Browser shows object metadata timestamps:
+
+- Creation time
+- Last modification time
+- Useful for tracking recent changes or finding stale objects
+
+## Feature Boundaries
+
+Object source editing is supported for databases that allow programmatic source replacement. Read-only databases, certain legacy versions, and some cloud database services may not expose editable object source. In those cases, use the Object Browser for inspection and copy the DDL for manual execution.
diff --git a/docs/content/docs/plugins.cn.mdx b/docs/content/docs/plugins.cn.mdx
new file mode 100644
index 0000000..3b512ef
--- /dev/null
+++ b/docs/content/docs/plugins.cn.mdx
@@ -0,0 +1,298 @@
+---
+title: JDBC 插件
+description: 安装 DBX JDBC 插件、导入数据库厂商驱动 JAR，并创建 JDBC 连接。
+---
+
+DBX 默认使用 Rust 原生数据库驱动。JDBC 是可选能力：当你需要连接 DBX 暂未内置支持的数据库，或希望使用数据库厂商提供的 JDBC 驱动时，可以安装 JDBC 插件。
+
+<Callout type="info">JDBC 插件不会打包进 DBX 主应用，也不包含任何数据库厂商的 JDBC 驱动。你需要先安装 DBX JDBC 插件，再导入对应数据库的 JDBC driver JAR。</Callout>
+
+## 什么时候需要 JDBC
+
+优先使用 DBX 内置数据库类型，例如 MySQL、PostgreSQL、SQLite、Redis、MongoDB、DuckDB、ClickHouse、SQL Server、Oracle、DM、GaussDB 等。
+
+以下情况再使用 JDBC：
+
+- 目标数据库不在 DBX 内置类型中
+- 内置驱动无法满足某个厂商特性
+- 你的公司统一要求使用厂商 JDBC driver
+- 你想用 JDBC 连接达梦、H2、DB2、Snowflake、SQLite JDBC 等数据库
+
+## 需要准备什么
+
+| 项目                       |     是否必需 | 说明                                                        |
+| -------------------------- | -----------: | ----------------------------------------------------------- |
+| DBX JDBC 插件              |         必需 | 在 DBX 设置中一键安装，用来让 DBX 调用 JDBC                 |
+| Java Runtime               |         必需 | 本机需要能运行 `java`；建议 Java 17 或更高版本              |
+| 数据库厂商 JDBC driver JAR |         必需 | 例如 PostgreSQL、MySQL、达梦、Oracle、H2、SQLite 等驱动 JAR |
+| JDBC URL                   |         必需 | JDBC URL 通常已经包含主机、端口、数据库名和参数             |
+| 用户名/密码                | 视数据库而定 | 文件型数据库或部分认证方式可能不需要                        |
+| 驱动类                     |     通常可选 | 多数现代 JDBC 驱动可以自动注册；自动识别失败时再填写        |
+
+## 第一步：安装 Java
+
+JDBC 插件是 Java 程序，需要本机有 Java runtime。安装后在终端确认：
+
+```bash
+java -version
+```
+
+如果系统提示找不到 `java`，需要先安装 Java。DBX 会优先使用 `JAVA_HOME`，其次尝试常见系统路径和 `PATH` 中的 `java`。
+
+<Tabs groupId="java-install" items={['macOS', 'Windows', 'Linux']}>
+  <Tab value="macOS">
+    使用 Homebrew 安装：
+
+    ```bash
+    brew install openjdk
+    ```
+
+    如果 `java -version` 仍不可用，可以按 Homebrew 输出提示配置 `PATH` 或 `JAVA_HOME`。
+
+  </Tab>
+  <Tab value="Windows">
+    安装 Temurin、Oracle JDK 或 Microsoft Build of OpenJDK。安装后重新打开 DBX，并确认命令行中可以运行：
+
+    ```powershell
+    java -version
+    ```
+
+  </Tab>
+  <Tab value="Linux">
+    Debian / Ubuntu：
+
+    ```bash
+    sudo apt install openjdk-17-jre
+    ```
+
+    Fedora：
+
+    ```bash
+    sudo dnf install java-17-openjdk
+    ```
+
+  </Tab>
+</Tabs>
+
+## 第二步：安装 DBX JDBC 插件
+
+在 DBX 桌面版中打开：
+
+1. **设置**
+2. **JDBC 驱动**
+3. 点击 **安装 JDBC 插件**
+
+安装成功后会显示类似：
+
+```text
+已安装：v0.1.0
+```
+
+DBX JDBC 插件有自己的版本号，不会强制跟 DBX 主应用版本一致。主应用更新后不会自动安装 JDBC 插件；如果你手动卸载过，后续更新也不会自动装回来。
+
+## 第三步：下载数据库厂商 JDBC 驱动
+
+DBX 不会自动下载数据库厂商驱动。你需要从数据库官网或 Maven 仓库下载对应的 `.jar` 文件。
+
+常见驱动示例：
+
+| 数据库     | 常见 Maven Artifact                    | 驱动类                                         | JDBC URL 示例                                                     |
+| ---------- | -------------------------------------- | ---------------------------------------------- | ----------------------------------------------------------------- |
+| PostgreSQL | `org.postgresql:postgresql`            | `org.postgresql.Driver`                        | `jdbc:postgresql://localhost:5432/postgres`                       |
+| MySQL      | `com.mysql:mysql-connector-j`          | `com.mysql.cj.jdbc.Driver`                     | `jdbc:mysql://localhost:3306/test`                                |
+| MariaDB    | `org.mariadb.jdbc:mariadb-java-client` | `org.mariadb.jdbc.Driver`                      | `jdbc:mariadb://localhost:3306/test`                              |
+| 达梦 DM    | `com.dameng:DmJdbcDriver8`             | `dm.jdbc.driver.DmDriver`                      | `jdbc:dm://localhost:5236`                                        |
+| SQL Server | `com.microsoft.sqlserver:mssql-jdbc`   | `com.microsoft.sqlserver.jdbc.SQLServerDriver` | `jdbc:sqlserver://localhost:1433;databaseName=master`             |
+| Oracle     | `com.oracle.database.jdbc:ojdbc11`     | `oracle.jdbc.OracleDriver`                     | `jdbc:oracle:thin:@//localhost:1521/ORCLPDB1`                     |
+| H2         | `com.h2database:h2`                    | `org.h2.Driver`                                | `jdbc:h2:/tmp/dbx-h2-test`                                        |
+| SQLite     | `org.xerial:sqlite-jdbc`               | `org.sqlite.JDBC`                              | `jdbc:sqlite:/Users/me/test.db`                                   |
+| ClickHouse | `com.clickhouse:clickhouse-jdbc`       | `com.clickhouse.jdbc.ClickHouseDriver`         | `jdbc:clickhouse://localhost:8123/default`                        |
+| DB2        | `com.ibm.db2:jcc`                      | `com.ibm.db2.jcc.DB2Driver`                    | `jdbc:db2://localhost:50000/SAMPLE`                               |
+| Snowflake  | `net.snowflake:snowflake-jdbc`         | `net.snowflake.client.jdbc.SnowflakeDriver`    | `jdbc:snowflake://account.region.snowflakecomputing.com/?db=DEMO` |
+
+<Callout type="warn">不同数据库和驱动版本的 URL 参数可能不同。以厂商官方文档为准。如果驱动依赖多个 JAR，请把需要的 JAR 路径都导入或填写进去。</Callout>
+
+## 第四步：导入 JDBC 驱动 JAR
+
+在 DBX 中打开：
+
+1. **设置**
+2. **JDBC 驱动**
+3. 在 **JDBC 驱动 JAR** 区域点击导入按钮，选择下载好的 `.jar`
+
+也可以直接粘贴本机 JAR 路径，然后点击导入。导入后，JAR 会复制到 DBX 的应用数据目录中，之后新建 JDBC 连接时可以从下拉框选择它。
+
+导入驱动只复制文件，不会修改系统 Java、不安装数据库客户端，也不会把驱动上传到远端。
+
+## 第五步：创建 JDBC 连接
+
+创建连接时选择 **JDBC** 类型。
+
+| 字段           | 怎么填                                                          |
+| -------------- | --------------------------------------------------------------- |
+| 名称           | 连接显示名，例如 `H2 Test`、`DM Dev`、`Oracle Dev`              |
+| JDBC URL       | 完整 JDBC URL，例如 `jdbc:postgresql://localhost:5432/postgres` |
+| 用户名         | 数据库用户名；不需要认证时可以留空                              |
+| 密码           | 数据库密码；不需要认证时可以留空                                |
+| 驱动类（可选） | 自动识别失败时填写，例如 `org.postgresql.Driver`                |
+| 驱动 JAR       | 从已导入驱动下拉框选择，或填写本机 JAR 路径                     |
+
+JDBC URL 通常已经包含主机、端口和数据库名，因此 JDBC 表单不会再单独显示主机和端口。
+
+填写完成后点击 **测试**。测试成功后点击 **保存**，连接会出现在侧边栏中。
+
+## 示例：连接达梦 DM
+
+DBX 已经内置 DM ODBC 连接类型。如果你更想使用达梦官方 JDBC 驱动，可以走 JDBC 插件。
+
+1. 安装 DBX JDBC 插件
+2. 安装 Java
+3. 从达梦安装目录或 Maven 仓库获取达梦 JDBC driver JAR，例如 `DmJdbcDriver8.jar` 或 `DmJdbcDriver11.jar`
+4. 在 **设置 → JDBC 驱动** 中导入该 JAR
+5. 新建连接，选择 **JDBC**
+6. 填写：
+
+| 字段           | 值                         |
+| -------------- | -------------------------- |
+| JDBC URL       | `jdbc:dm://127.0.0.1:5236` |
+| 用户名         | `SYSDBA`                   |
+| 密码           | 你的达梦密码               |
+| 驱动类（可选） | `dm.jdbc.driver.DmDriver`  |
+| 驱动 JAR       | 选择已导入的达梦 JDBC JAR  |
+
+达梦这里建议直接填写驱动类 `dm.jdbc.driver.DmDriver`，这样不依赖驱动 JAR 的自动发现配置。
+
+## 示例：连接 H2 本地文件数据库
+
+H2 很适合验证 JDBC 流程。
+
+1. 安装 DBX JDBC 插件
+2. 下载 H2 JDBC driver JAR
+3. 在设置中导入 `h2-*.jar`
+4. 新建连接，选择 **JDBC**
+5. 填写：
+
+| 字段           | 值                         |
+| -------------- | -------------------------- |
+| JDBC URL       | `jdbc:h2:/tmp/dbx-h2-demo` |
+| 用户名         | `sa`                       |
+| 密码           | 留空                       |
+| 驱动类（可选） | `org.h2.Driver`            |
+| 驱动 JAR       | 选择已导入的 H2 JAR        |
+
+保存后可以执行：
+
+```sql
+CREATE TABLE users (
+  id INT PRIMARY KEY,
+  name VARCHAR(100)
+);
+
+INSERT INTO users VALUES (1, 'Alice');
+
+SELECT * FROM users;
+```
+
+## 示例：连接 PostgreSQL
+
+1. 下载 PostgreSQL JDBC driver JAR
+2. 在设置中导入该 JAR
+3. 新建 JDBC 连接
+4. 填写：
+
+| 字段           | 值                                          |
+| -------------- | ------------------------------------------- |
+| JDBC URL       | `jdbc:postgresql://localhost:5432/postgres` |
+| 用户名         | `postgres`                                  |
+| 密码           | 你的 PostgreSQL 密码                        |
+| 驱动类（可选） | `org.postgresql.Driver`                     |
+| 驱动 JAR       | 选择已导入的 PostgreSQL JAR                 |
+
+如果数据库要求 SSL，可以在 JDBC URL 后添加参数：
+
+```text
+jdbc:postgresql://localhost:5432/postgres?sslmode=require
+```
+
+## 常见问题
+
+### 安装 JDBC 插件失败
+
+检查网络是否能访问 DBX 的 GitHub Release。DBX 会尝试代理地址和 GitHub 原始地址，但代理站也可能不稳定。如果公司网络限制 GitHub，请换网络后重试。
+
+### 提示找不到 Java
+
+确认终端里可以运行：
+
+```bash
+java -version
+```
+
+如果终端可用但 DBX 不可用，重启 DBX。macOS 上如果 Java 只安装在 Homebrew 路径，也可以配置 `JAVA_HOME`。
+
+### 提示 `No JDBC driver was discovered`
+
+说明驱动 JAR 没有被自动识别。请在 **驱动类（可选）** 中填写对应驱动类，例如：
+
+```text
+org.postgresql.Driver
+com.mysql.cj.jdbc.Driver
+dm.jdbc.driver.DmDriver
+oracle.jdbc.OracleDriver
+```
+
+### 提示 `No suitable driver`
+
+通常是 JDBC URL 和驱动不匹配。检查：
+
+- 是否选择了正确数据库的 driver JAR
+- JDBC URL 前缀是否正确，例如 `jdbc:postgresql:`、`jdbc:mysql:`、`jdbc:dm:`、`jdbc:oracle:`
+- 是否需要填写驱动类
+
+### 能连接但看不到表
+
+JDBC 元数据依赖数据库驱动和账号权限。检查：
+
+- 当前账号是否有读取 metadata 的权限
+- JDBC URL 是否连接到了正确的数据库或 schema
+- 表是否在不同 schema 下
+- 数据库驱动是否完整支持 `DatabaseMetaData`
+
+### 一个驱动需要多个 JAR 怎么办
+
+在连接表单的 **驱动 JAR** 文本框中每行填写一个 JAR 路径，或在设置里分别导入多个 JAR 后选择/补充路径。
+
+## 卸载插件
+
+在 **设置 → JDBC 驱动** 中点击 **卸载**。卸载会移除 DBX JDBC 插件本体，但会保留你已经导入的数据库厂商 driver JAR，避免下次重新安装插件时还要重新导入。
+
+## 给开发者：插件协议
+
+DBX 会启动插件可执行文件，并通过 stdin/stdout 发送 JSON Lines 请求与响应。连接建立后，DBX 会复用同一个插件进程处理该连接上的查询和元数据请求。
+
+插件目录需要包含 `manifest.json`：
+
+```json
+{
+  "id": "jdbc",
+  "name": "DBX JDBC Plugin",
+  "version": "0.1.0",
+  "protocol_version": 1,
+  "description": "Adds JDBC driver support.",
+  "executable": "bin/dbx-jdbc-plugin",
+  "drivers": [
+    {
+      "id": "jdbc",
+      "label": "JDBC",
+      "kind": "external",
+      "database_type": "jdbc"
+    }
+  ]
+}
+```
+
+当前 DBX 主应用支持插件协议版本 `1`。如果插件 manifest 声明了不同协议版本，DBX 会拒绝加载；每次插件请求也有 30 秒超时，避免驱动进程卡住后无限阻塞应用。
+
+第一版协议支持 `testConnection`、`connect`、`executeQuery`、`listDatabases`、`listSchemas`、`listTables` 和 `getColumns`。
+
+<Callout type="info">JDBC 连接配置会保存 `jdbc_driver_class` 和 `jdbc_driver_paths`。如果一个驱动需要多个 JAR，请把所有路径都绑定到连接上，这样元数据和查询调用会使用同一套 classpath。</Callout>
diff --git a/docs/content/docs/plugins.mdx b/docs/content/docs/plugins.mdx
new file mode 100644
index 0000000..27d3048
--- /dev/null
+++ b/docs/content/docs/plugins.mdx
@@ -0,0 +1,298 @@
+---
+title: JDBC Plugin
+description: Install the DBX JDBC plugin, import vendor JDBC driver JARs, and create JDBC connections.
+---
+
+DBX uses native Rust database drivers by default. JDBC is optional: install the JDBC plugin when you need to connect to a database that DBX does not support natively, or when you specifically need a vendor JDBC driver.
+
+<Callout type="info">The JDBC plugin is not bundled with the main DBX app, and it does not include vendor JDBC drivers. Install the DBX JDBC plugin first, then import the database vendor's JDBC driver JAR.</Callout>
+
+## When to Use JDBC
+
+Prefer built-in DBX database types first, such as MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, ClickHouse, SQL Server, Oracle, DM, and GaussDB.
+
+Use JDBC when:
+
+- The target database is not built into DBX
+- The native driver does not cover a vendor-specific behavior
+- Your organization standardizes on a vendor JDBC driver
+- You want to connect to databases such as Dameng DM, H2, DB2, Snowflake, or SQLite through JDBC
+
+## Requirements
+
+| Item                   |         Required | Notes                                                                                  |
+| ---------------------- | ---------------: | -------------------------------------------------------------------------------------- |
+| DBX JDBC plugin        |              Yes | Installed from DBX settings; lets DBX call JDBC                                        |
+| Java Runtime           |              Yes | The local machine must be able to run `java`; Java 17 or newer is recommended          |
+| Vendor JDBC driver JAR |              Yes | For example PostgreSQL, MySQL, Dameng DM, Oracle, H2, SQLite, or another vendor driver |
+| JDBC URL               |              Yes | The URL usually contains host, port, database name, and parameters                     |
+| Username/password      |          Depends | File databases or some auth modes may not need them                                    |
+| Driver class           | Usually optional | Most modern JDBC drivers auto-register; enter it only when auto-discovery fails        |
+
+## Step 1: Install Java
+
+The JDBC plugin is a Java program, so your machine needs a Java runtime. After installation, verify it in a terminal:
+
+```bash
+java -version
+```
+
+If the command is missing, install Java first. DBX checks `JAVA_HOME` first, then common system locations and `java` from `PATH`.
+
+<Tabs groupId="java-install" items={['macOS', 'Windows', 'Linux']}>
+  <Tab value="macOS">
+    Install with Homebrew:
+
+    ```bash
+    brew install openjdk
+    ```
+
+    If `java -version` still does not work, follow the Homebrew output to configure `PATH` or `JAVA_HOME`.
+
+  </Tab>
+  <Tab value="Windows">
+    Install Temurin, Oracle JDK, or Microsoft Build of OpenJDK. Restart DBX after installation and verify:
+
+    ```powershell
+    java -version
+    ```
+
+  </Tab>
+  <Tab value="Linux">
+    Debian / Ubuntu:
+
+    ```bash
+    sudo apt install openjdk-17-jre
+    ```
+
+    Fedora:
+
+    ```bash
+    sudo dnf install java-17-openjdk
+    ```
+
+  </Tab>
+</Tabs>
+
+## Step 2: Install the DBX JDBC Plugin
+
+In DBX Desktop:
+
+1. Open **Settings**
+2. Go to **JDBC Drivers**
+3. Click **Install JDBC Plugin**
+
+After installation, DBX shows a status like:
+
+```text
+Installed: v0.1.0
+```
+
+The DBX JDBC plugin has its own version. It does not have to match the DBX app version. Updating DBX does not automatically install the JDBC plugin, and if you uninstall it manually, DBX will not reinstall it behind your back.
+
+## Step 3: Download the Vendor JDBC Driver
+
+DBX does not download vendor JDBC drivers automatically. Download the `.jar` file from the database vendor website or a Maven repository.
+
+Common examples:
+
+| Database   | Common Maven Artifact                  | Driver Class                                   | JDBC URL Example                                                  |
+| ---------- | -------------------------------------- | ---------------------------------------------- | ----------------------------------------------------------------- |
+| PostgreSQL | `org.postgresql:postgresql`            | `org.postgresql.Driver`                        | `jdbc:postgresql://localhost:5432/postgres`                       |
+| MySQL      | `com.mysql:mysql-connector-j`          | `com.mysql.cj.jdbc.Driver`                     | `jdbc:mysql://localhost:3306/test`                                |
+| MariaDB    | `org.mariadb.jdbc:mariadb-java-client` | `org.mariadb.jdbc.Driver`                      | `jdbc:mariadb://localhost:3306/test`                              |
+| Dameng DM  | `com.dameng:DmJdbcDriver8`             | `dm.jdbc.driver.DmDriver`                      | `jdbc:dm://localhost:5236`                                        |
+| SQL Server | `com.microsoft.sqlserver:mssql-jdbc`   | `com.microsoft.sqlserver.jdbc.SQLServerDriver` | `jdbc:sqlserver://localhost:1433;databaseName=master`             |
+| Oracle     | `com.oracle.database.jdbc:ojdbc11`     | `oracle.jdbc.OracleDriver`                     | `jdbc:oracle:thin:@//localhost:1521/ORCLPDB1`                     |
+| H2         | `com.h2database:h2`                    | `org.h2.Driver`                                | `jdbc:h2:/tmp/dbx-h2-test`                                        |
+| SQLite     | `org.xerial:sqlite-jdbc`               | `org.sqlite.JDBC`                              | `jdbc:sqlite:/Users/me/test.db`                                   |
+| ClickHouse | `com.clickhouse:clickhouse-jdbc`       | `com.clickhouse.jdbc.ClickHouseDriver`         | `jdbc:clickhouse://localhost:8123/default`                        |
+| DB2        | `com.ibm.db2:jcc`                      | `com.ibm.db2.jcc.DB2Driver`                    | `jdbc:db2://localhost:50000/SAMPLE`                               |
+| Snowflake  | `net.snowflake:snowflake-jdbc`         | `net.snowflake.client.jdbc.SnowflakeDriver`    | `jdbc:snowflake://account.region.snowflakecomputing.com/?db=DEMO` |
+
+<Callout type="warn">JDBC URL parameters vary by database and driver version. Follow the vendor documentation. If a driver depends on multiple JARs, import or list all required JAR paths.</Callout>
+
+## Step 4: Import JDBC Driver JARs
+
+In DBX:
+
+1. Open **Settings**
+2. Go to **JDBC Drivers**
+3. In the **JDBC driver JARs** section, choose the downloaded `.jar`
+
+You can also paste a local JAR path and import it. DBX copies imported JARs into the app data directory, and new JDBC connections can select them from the driver dropdown.
+
+Importing a driver only copies local files. It does not change your system Java installation, install database clients, or upload the driver anywhere.
+
+## Step 5: Create a JDBC Connection
+
+Create a new connection and choose **JDBC**.
+
+| Field                   | What to enter                                                          |
+| ----------------------- | ---------------------------------------------------------------------- |
+| Name                    | Display name, such as `H2 Test`, `DM Dev`, or `Oracle Dev`             |
+| JDBC URL                | Full JDBC URL, such as `jdbc:postgresql://localhost:5432/postgres`     |
+| Username                | Database username; leave empty if not needed                           |
+| Password                | Database password; leave empty if not needed                           |
+| Driver Class (optional) | Enter it only if auto-discovery fails, such as `org.postgresql.Driver` |
+| Driver JARs             | Choose an imported driver from the dropdown, or enter local JAR paths  |
+
+JDBC URLs usually already include host, port, and database name, so the JDBC form does not show separate host and port fields.
+
+Click **Test** after filling the form. If the test succeeds, click **Save** and the connection appears in the sidebar.
+
+## Example: Dameng DM
+
+DBX already has a built-in DM ODBC connection type. If you prefer the official Dameng JDBC driver, use the JDBC plugin.
+
+1. Install the DBX JDBC plugin
+2. Install Java
+3. Get the Dameng JDBC driver JAR from your DM installation directory or Maven repository, such as `DmJdbcDriver8.jar` or `DmJdbcDriver11.jar`
+4. Import the JAR in **Settings → JDBC Drivers**
+5. Create a new connection and choose **JDBC**
+6. Fill in:
+
+| Field                   | Value                           |
+| ----------------------- | ------------------------------- |
+| JDBC URL                | `jdbc:dm://127.0.0.1:5236`      |
+| Username                | `SYSDBA`                        |
+| Password                | Your DM password                |
+| Driver Class (optional) | `dm.jdbc.driver.DmDriver`       |
+| Driver JARs             | Choose the imported DM JDBC JAR |
+
+For DM, entering `dm.jdbc.driver.DmDriver` is recommended so the connection does not depend on automatic driver discovery metadata.
+
+## Example: H2 Local File Database
+
+H2 is a good way to verify the JDBC workflow.
+
+1. Install the DBX JDBC plugin
+2. Download the H2 JDBC driver JAR
+3. Import `h2-*.jar` in settings
+4. Create a new connection and choose **JDBC**
+5. Fill in:
+
+| Field                   | Value                      |
+| ----------------------- | -------------------------- |
+| JDBC URL                | `jdbc:h2:/tmp/dbx-h2-demo` |
+| Username                | `sa`                       |
+| Password                | Leave empty                |
+| Driver Class (optional) | `org.h2.Driver`            |
+| Driver JARs             | Choose the imported H2 JAR |
+
+After saving, try:
+
+```sql
+CREATE TABLE users (
+  id INT PRIMARY KEY,
+  name VARCHAR(100)
+);
+
+INSERT INTO users VALUES (1, 'Alice');
+
+SELECT * FROM users;
+```
+
+## Example: PostgreSQL
+
+1. Download the PostgreSQL JDBC driver JAR
+2. Import it in settings
+3. Create a new JDBC connection
+4. Fill in:
+
+| Field                   | Value                                       |
+| ----------------------- | ------------------------------------------- |
+| JDBC URL                | `jdbc:postgresql://localhost:5432/postgres` |
+| Username                | `postgres`                                  |
+| Password                | Your PostgreSQL password                    |
+| Driver Class (optional) | `org.postgresql.Driver`                     |
+| Driver JARs             | Choose the imported PostgreSQL JAR          |
+
+If SSL is required, add parameters to the JDBC URL:
+
+```text
+jdbc:postgresql://localhost:5432/postgres?sslmode=require
+```
+
+## Troubleshooting
+
+### JDBC plugin installation fails
+
+Check whether your network can access DBX GitHub Releases. DBX tries proxy URLs and the original GitHub URL, but public proxies can still be unavailable. Try another network if GitHub is blocked.
+
+### Java cannot be found
+
+Verify in a terminal:
+
+```bash
+java -version
+```
+
+If the terminal works but DBX does not, restart DBX. On macOS, if Java is only installed under a Homebrew path, configure `JAVA_HOME`.
+
+### `No JDBC driver was discovered`
+
+The driver JAR was not auto-discovered. Enter the driver class manually, for example:
+
+```text
+org.postgresql.Driver
+com.mysql.cj.jdbc.Driver
+dm.jdbc.driver.DmDriver
+oracle.jdbc.OracleDriver
+```
+
+### `No suitable driver`
+
+The JDBC URL and driver probably do not match. Check:
+
+- The selected driver JAR belongs to the target database
+- The JDBC URL prefix is correct, such as `jdbc:postgresql:`, `jdbc:mysql:`, `jdbc:dm:`, or `jdbc:oracle:`
+- The driver class may need to be entered manually
+
+### The connection works but tables are missing
+
+JDBC metadata depends on the database driver and account permissions. Check:
+
+- The account can read metadata
+- The JDBC URL points to the expected database or schema
+- Tables may live under a different schema
+- The driver supports `DatabaseMetaData` for the objects you expect
+
+### A driver requires multiple JARs
+
+Enter one JAR path per line in the **Driver JARs** field, or import each required JAR in settings and add the remaining paths manually.
+
+## Uninstalling
+
+Click **Uninstall** in **Settings → JDBC Drivers**. DBX removes the JDBC plugin itself but keeps your imported vendor driver JARs, so you do not have to import them again if you reinstall the plugin later.
+
+## For Developers: Plugin Protocol
+
+DBX starts the plugin executable and exchanges JSON Lines requests and responses over stdin/stdout. After a connection is established, DBX reuses the same plugin process for queries and metadata requests on that connection.
+
+The plugin directory must include `manifest.json`:
+
+```json
+{
+  "id": "jdbc",
+  "name": "DBX JDBC Plugin",
+  "version": "0.1.0",
+  "protocol_version": 1,
+  "description": "Adds JDBC driver support.",
+  "executable": "bin/dbx-jdbc-plugin",
+  "drivers": [
+    {
+      "id": "jdbc",
+      "label": "JDBC",
+      "kind": "external",
+      "database_type": "jdbc"
+    }
+  ]
+}
+```
+
+The current DBX app supports plugin protocol version `1`. DBX rejects a plugin whose manifest declares a different protocol version, and each plugin request has a 30 second timeout so a hung driver process does not block the app indefinitely.
+
+The initial protocol supports `testConnection`, `connect`, `executeQuery`, `listDatabases`, `listSchemas`, `listTables`, and `getColumns`.
+
+<Callout type="info">JDBC connection configs store `jdbc_driver_class` and `jdbc_driver_paths`. If a driver needs several JARs, keep all paths attached to the connection so metadata and query calls use the same classpath.</Callout>
diff --git a/docs/content/docs/query-editor.cn.mdx b/docs/content/docs/query-editor.cn.mdx
new file mode 100644
index 0000000..2c90925
--- /dev/null
+++ b/docs/content/docs/query-editor.cn.mdx
@@ -0,0 +1,103 @@
+---
+title: 查询编辑器
+description: 使用 DBX 的 SQL 编辑器编写、补全、格式化、执行和复用查询。
+---
+
+查询编辑器用于完成日常 SQL 工作：编写查询、查看补全建议、格式化语句、执行选中片段，以及从历史记录中找回之前的 SQL。
+
+## 基本工作流
+
+<Steps>
+  <Step>
+    ### 打开连接
+
+    从侧边栏选择一个数据库连接。DBX 会根据当前连接加载对应的数据库类型和元数据。
+
+  </Step>
+  <Step>
+    ### 编写 SQL
+
+    在编辑器中输入 SQL。补全会结合 SQL 关键字、表、视图、字段和部分关系信息给出建议。
+
+  </Step>
+  <Step>
+    ### 执行查询
+
+    使用快捷键执行全部 SQL 或选中的 SQL 片段。结果会显示在编辑器下方的数据表格中。
+
+  </Step>
+  <Step>
+    ### 复用历史
+
+    通过查询历史找回之前执行过的语句，适合重复排查和调试。
+
+  </Step>
+</Steps>
+
+## 执行 SQL
+
+| 操作         | macOS                  | Windows / Linux         |
+| ------------ | ---------------------- | ----------------------- |
+| 执行全部 SQL | `Cmd+Enter`            | `Ctrl+Enter`            |
+| 执行选中 SQL | 选中文本后 `Cmd+Enter` | 选中文本后 `Ctrl+Enter` |
+
+<Callout type="info">如果编辑器中有选中文本，DBX 只执行选中的 SQL；没有选中文本时，执行当前编辑器中的全部内容。</Callout>
+
+执行完成后，结果区域会展示返回行、耗时、影响行数或错误信息。多语句执行时，建议先选中要执行的片段，减少误操作。
+
+DBX 也会跟踪查询会话，离开结果集时可以关闭会话；当数据库驱动支持取消时，正在执行的查询也可以从界面中取消。
+
+### SQL 执行目标选择器
+
+对于只包含单条语句的查询，DBX 可以直接执行而不显示目标选择器。当 SQL 包含多条语句时，DBX 会显示执行目标选择器并提供预览装饰，帮助你选择要执行的语句。
+
+可以在设置中的 **显示执行目标选择器** 选项启用或禁用此功能。禁用后，DBX 会直接执行整个编辑器内容而不提示。
+
+## 执行范围
+
+| 范围     | 如何确定               | 适合场景                     |
+| -------- | ---------------------- | ---------------------------- |
+| 选中 SQL | 执行前先高亮文本       | 多语句草稿中最安全           |
+| 当前语句 | 使用编辑器光标相关流程 | 不手动选择文本时运行单条语句 |
+| 全部内容 | 没有选中文本时执行     | 单用途查询标签页或短脚本     |
+
+<Callout type="warn">DBX 可以执行批量 SQL 和脚本，但在查询编辑器里仍建议一次运行一条已审查语句。大型 `.sql` 文件请使用带进度跟踪的 [SQL 文件执行](/cn/docs/sql-file)。</Callout>
+
+## 自动补全
+
+补全建议来自当前连接的数据库上下文：
+
+- **SQL 关键字**：例如 `SELECT`、`FROM`、`WHERE`、`GROUP BY`
+- **对象名称**：表、视图、Schema、数据库
+- **字段名称**：根据已经输入的表名或别名推断字段
+- **JOIN 建议**：基于外键或已知关系提示可关联表和关联条件
+- **SQL Server 语法**：SQL Server 连接下支持 `CROSS APPLY`、`OUTER APPLY` 等补全
+
+<Callout type="info">补全的准确性依赖当前连接的元数据。如果刚创建表或修改字段，可以刷新连接元数据后再试。</Callout>
+
+## 格式化 SQL
+
+点击工具栏中的格式化按钮，可以统一缩进、换行和关键字风格。格式化适合在提交迁移脚本、分享查询或排查复杂 SQL 前使用。
+
+格式化只改变 SQL 文本，不会执行 SQL，也不会改变数据库内容。
+
+## 查询历史
+
+DBX 会记录已经执行过的 SQL，方便复用：
+
+- 每个连接独立保存查询历史
+- 可以按时间查看之前执行的语句
+- 点击历史记录可重新填入编辑器
+- 适合找回临时排查 SQL、报表查询和修复语句
+- 历史记录会保留足够上下文，用于区分手写查询和 AI 辅助操作
+- **执行时间范围过滤**：按日期范围过滤历史记录，查找特定时间段内执行的查询
+
+<Callout type="warn">查询历史可能包含业务字段、表名或筛选条件。共享电脑或演示环境中，建议注意历史记录里的敏感信息。</Callout>
+
+## 与数据表格配合
+
+查询结果会进入 [数据表格](/cn/docs/data-grid)。如果查询结果可编辑，DBX 会在保存前展示将要执行的 SQL；如果只是临时分析，可以直接导出 CSV、JSON 或 Markdown。
+
+## 与 AI 配合
+
+编辑器可以把当前 SQL、连接类型、数据库名、最近错误、结果预览和已加载的 Schema 上下文发送给 [AI 助手](/cn/docs/ai-assistant)。Ask 模式只返回 SQL 和说明；Agent 模式会先经过 DBX 的执行策略，再决定是否尝试执行生成的 SQL。
diff --git a/docs/content/docs/query-editor.mdx b/docs/content/docs/query-editor.mdx
new file mode 100644
index 0000000..c2ce412
--- /dev/null
+++ b/docs/content/docs/query-editor.mdx
@@ -0,0 +1,103 @@
+---
+title: Query Editor
+description: Write, complete, format, execute, and reuse SQL in DBX.
+---
+
+The query editor is where daily SQL work happens: writing queries, using completion, formatting statements, executing selected fragments, and returning to previous SQL through history.
+
+## Basic Workflow
+
+<Steps>
+  <Step>
+    ### Open a Connection
+
+    Select a database connection from the sidebar. DBX loads the database type and metadata for the active connection.
+
+  </Step>
+  <Step>
+    ### Write SQL
+
+    Type SQL in the editor. Completion suggestions use SQL keywords, tables, views, columns, and available relationship metadata.
+
+  </Step>
+  <Step>
+    ### Execute the Query
+
+    Use the shortcut to execute all SQL or only the selected fragment. Results appear in the data grid below the editor.
+
+  </Step>
+  <Step>
+    ### Reuse History
+
+    Open query history to bring back previously executed SQL for repeated debugging or analysis.
+
+  </Step>
+</Steps>
+
+## Execute SQL
+
+| Action               | macOS                         | Windows / Linux                |
+| -------------------- | ----------------------------- | ------------------------------ |
+| Execute all SQL      | `Cmd+Enter`                   | `Ctrl+Enter`                   |
+| Execute selected SQL | Select text, then `Cmd+Enter` | Select text, then `Ctrl+Enter` |
+
+<Callout type="info">When text is selected, DBX executes only the selected SQL. When nothing is selected, it executes the full editor content.</Callout>
+
+After execution, the result area shows returned rows, duration, affected row count, or the error message. For multi-statement scripts, select the exact fragment you want to run to reduce mistakes.
+
+DBX also tracks query sessions so long-running result sets can be closed when you leave them, and active queries can be cancelled from the UI when the database driver supports cancellation.
+
+### SQL Execution Target Picker
+
+For queries that contain a single statement, DBX can execute it directly without showing a target picker. When your SQL contains multiple statements, DBX displays an execution target picker with a preview decoration to help you choose which statement to run.
+
+Enable or disable the execution target picker in Settings under **Show execution target picker**. When disabled, DBX executes the entire editor content without prompting.
+
+## Execution Scope
+
+| Scope             | How It Is Chosen                            | Use Case                                          |
+| ----------------- | ------------------------------------------- | ------------------------------------------------- |
+| Selected SQL      | Highlight text before running               | Safest option for multi-statement scratch pads    |
+| Current statement | Use editor cursor workflows where available | Run one statement without selecting text manually |
+| Full editor       | Run with no selection                       | Single-purpose query tabs and short scripts       |
+
+<Callout type="warn">DBX can execute batches and scripts, but the query editor is still safest when you run one reviewed statement at a time. Use [SQL File Execution](/en/docs/sql-file) for large `.sql` files that need progress tracking.</Callout>
+
+## Autocomplete
+
+Completion suggestions come from the active database context:
+
+- **SQL keywords**: `SELECT`, `FROM`, `WHERE`, `GROUP BY`, and more
+- **Object names**: tables, views, schemas, and databases
+- **Column names**: inferred from referenced tables and aliases
+- **JOIN suggestions**: related tables and join conditions from foreign keys or known relationships
+- **SQL Server syntax**: `CROSS APPLY`, `OUTER APPLY`, and related completions for SQL Server connections
+
+<Callout type="info">Completion accuracy depends on connection metadata. If you just created a table or changed columns, refresh the connection metadata and try again.</Callout>
+
+## Format SQL
+
+Use the format button in the toolbar to standardize indentation, line breaks, and keyword style. Formatting is useful before sharing a query, reviewing a migration script, or debugging a complex statement.
+
+Formatting only changes the editor text. It does not execute SQL or modify the database.
+
+## Query History
+
+DBX records executed SQL so you can reuse it later:
+
+- History is stored per connection
+- Previous statements can be reviewed by time
+- Clicking a history item loads it back into the editor
+- Useful for investigation queries, reports, and repair statements
+- History entries preserve enough context to identify manual queries and AI-assisted work
+- **Execution time range filter**: Filter history entries by date range to find queries executed within a specific time period
+
+<Callout type="warn">Query history may include business fields, table names, or filter values. Be mindful of sensitive information on shared machines or demo environments.</Callout>
+
+## Working With the Data Grid
+
+Query results open in the [Data Grid](/en/docs/data-grid). If the result is editable, DBX shows the SQL before saving changes. For analysis-only results, you can export CSV, JSON, or Markdown.
+
+## Working With AI
+
+The editor can send the current SQL, active connection type, database name, recent error, result preview, and loaded schema context to the [AI Assistant](/en/docs/ai-assistant). In Ask mode, AI returns SQL and explanations only. In Agent mode, DBX applies an execution policy before attempting to run generated SQL.
diff --git a/docs/content/docs/redis.cn.mdx b/docs/content/docs/redis.cn.mdx
new file mode 100644
index 0000000..8fd1418
--- /dev/null
+++ b/docs/content/docs/redis.cn.mdx
@@ -0,0 +1,88 @@
+---
+title: Redis 浏览器
+description: 浏览 Redis 键、查看和编辑值、按模式搜索、以及跨所有 Redis 数据类型执行命令。
+---
+
+DBX 提供完整的 Redis 键浏览器，支持所有核心 Redis 数据类型。它将浏览、编辑、搜索和命令执行整合到一个视图中，无需在 Redis CLI 和 GUI 之间切换。
+
+## 键浏览器
+
+Redis 键浏览器以表格形式展示键，便于扫描和过滤：
+
+- 键列表支持分页，避免在大型键空间上阻塞
+- 点击任意键可在详情面板中查看其值
+- 使用搜索栏按模式过滤键（如 `user:*`、`cache:*`）
+- 内联显示键类型、TTL 和大小
+
+<Callout type="info">对于包含数百万键的 Redis 实例，建议在搜索栏中使用具体的键模式，而不是加载整个键空间。可在设置中调整扫描页大小，以控制每批获取的键数量。</Callout>
+
+## 值查看器与编辑器
+
+每种 Redis 数据类型都有专用的查看器和编辑器：
+
+| 类型       | 查看器                  | 编辑方式             |
+| ---------- | ----------------------- | -------------------- |
+| String     | 纯文本或 JSON 查看器    | 内联文本编辑         |
+| Hash       | 可调整列宽的字段/值表格 | 编辑单个字段         |
+| List       | 带索引的有序列表        | 添加、删除、重排元素 |
+| Set        | 带基数的成员列表        | 添加和删除成员       |
+| Sorted Set | 带分数的成员列表        | 编辑成员和分数       |
+| Stream     | 带 ID 的条目列表        | 查看流条目           |
+
+## JSON 值查看器
+
+对于包含有效 JSON 的 String 键，DBX 会自动渲染结构化 JSON 查看器，支持节点折叠、语法高亮和复制功能。
+
+## 值搜索
+
+按内容搜索 Redis 值，而不仅仅是键：
+
+- 扫描 String 值中的匹配文本
+- 按值查找 Hash 字段
+- 对于大型键空间，结果会逐步流式返回
+
+<Callout type="warn">值搜索会扫描匹配当前模式的所有键。在大型数据库上这可能会消耗大量资源。在开始值搜索之前，请先缩小键模式范围。</Callout>
+
+## 批量操作
+
+一次性对多个键执行批量操作：
+
+- 一次删除多个键
+- 查看键统计信息，包括内存使用和访问模式
+
+## 命令执行器
+
+直接从 UI 执行任意 Redis 命令：
+
+- 以 Redis CLI 语法输入命令
+- 结果以结构化表格显示
+- 适用于 `INFO`、`CONFIG GET`、`CLIENT LIST` 等管理命令
+- **命令历史导航**：使用方向键（↑/↓）浏览之前执行过的命令
+- **文本选择和复制**：直接从终端中选择并复制命令输出
+
+命令历史按连接保存，帮助你快速重新运行常用命令而无需重新输入。
+
+## 清空数据库
+
+**Flush DB** 按钮会删除当前 Redis 数据库中的所有键。此操作不可撤销。清空前请确认活动连接和数据库编号。
+
+## 键统计
+
+在设置中启用键统计跟踪，以监控：
+
+- 每个键的内存使用量
+- 访问频率
+- 空闲时间
+
+这些数据有助于识别可能需要关注的大键或不常用键。
+
+## Slowlog 面板
+
+**Slowlog** 面板帮助识别慢速 Redis 命令：
+
+- 查看最近的慢命令及其执行时间
+- 分析可能需要优化的查询模式
+- 用于性能调优和生产问题调试
+- 从 Redis 连接的工具菜单访问 slowlog
+
+Slowlog 条目显示命令、执行时间和时间戳，帮助你识别 Redis 工作负载中的性能瓶颈。
diff --git a/docs/content/docs/redis.mdx b/docs/content/docs/redis.mdx
new file mode 100644
index 0000000..d1c1e61
--- /dev/null
+++ b/docs/content/docs/redis.mdx
@@ -0,0 +1,88 @@
+---
+title: Redis Browser
+description: Browse Redis keys, view and edit values, search by pattern, and run commands across all Redis data types.
+---
+
+DBX provides a full Redis key browser with support for all core Redis data types. It replaces the need to switch between a Redis CLI and a GUI by combining browsing, editing, searching, and command execution in one view.
+
+## Key Browser
+
+The Redis key browser displays keys in a table format for easier scanning and filtering:
+
+- Keys are paginated to avoid blocking on large keyspaces
+- Click any key to open its value in the detail panel
+- Use the search bar to filter keys by pattern (e.g., `user:*`, `cache:*`)
+- Key type, TTL, and size are shown inline
+
+<Callout type="info">For Redis instances with millions of keys, use specific key patterns in the search bar instead of loading the entire keyspace. Set the scan page size in Settings to control how many keys are fetched per batch.</Callout>
+
+## Value Viewer and Editor
+
+Each Redis data type has a dedicated viewer and editor:
+
+| Type       | Viewer                                   | Editing                       |
+| ---------- | ---------------------------------------- | ----------------------------- |
+| String     | Plain text or JSON viewer                | Inline text edit              |
+| Hash       | Field/value table with resizable columns | Edit individual fields        |
+| List       | Ordered list with index                  | Add, remove, reorder elements |
+| Set        | Member list with cardinality             | Add and remove members        |
+| Sorted Set | Member list with scores                  | Edit members and scores       |
+| Stream     | Entry list with IDs                      | View stream entries           |
+
+## JSON Value Viewer
+
+For String keys that contain valid JSON, DBX automatically renders a structured JSON viewer with collapsible nodes, syntax highlighting, and copy support.
+
+## Value Search
+
+Search Redis values by content, not just keys:
+
+- Scan String values for matching text
+- Find Hash fields by value
+- Results are streamed progressively for large keyspaces
+
+<Callout type="warn">Value search scans all keys that match the current pattern. On large databases this can be resource-intensive. Narrow the key pattern before starting a value search.</Callout>
+
+## Bulk Operations
+
+Perform batch actions on multiple keys at once:
+
+- Delete multiple keys in one operation
+- View key statistics including memory usage and access patterns
+
+## Command Runner
+
+Execute arbitrary Redis commands directly from the UI:
+
+- Type commands in Redis CLI syntax
+- Results are displayed in a structured table
+- Useful for `INFO`, `CONFIG GET`, `CLIENT LIST`, and other admin commands
+- **Command history navigation**: Use arrow keys (↑/↓) to navigate through previously executed commands
+- **Text selection and copy**: Select and copy command output directly from the terminal
+
+The command history is preserved per connection and helps you quickly rerun frequently used commands without retyping them.
+
+## Flush Database
+
+The **Flush DB** button removes all keys from the current Redis database. This action cannot be undone. Confirm the active connection and database number before flushing.
+
+## Key Statistics
+
+Enable key statistics tracking in Settings to monitor:
+
+- Memory usage per key
+- Access frequency
+- Idle time
+
+This data helps identify large or infrequently used keys that may need attention.
+
+## Slowlog Panel
+
+The **Slowlog** panel helps identify slow Redis commands:
+
+- View recent slow commands with execution time
+- Analyze query patterns that may need optimization
+- Useful for performance tuning and debugging production issues
+- Access slowlog from the Redis connection's tools menu
+
+Slowlog entries show the command, execution time, and timestamp, helping you identify performance bottlenecks in your Redis workload.
diff --git a/docs/content/docs/schema-browser.cn.mdx b/docs/content/docs/schema-browser.cn.mdx
new file mode 100644
index 0000000..5c12680
--- /dev/null
+++ b/docs/content/docs/schema-browser.cn.mdx
@@ -0,0 +1,102 @@
+---
+title: 结构浏览
+description: 使用侧边栏浏览连接、数据库、Schema、表、字段和 Redis 键空间。
+---
+
+结构浏览器是 DBX 的左侧工作区，用于理解当前连接里有哪些数据库对象，并快速打开表数据、表结构或上下文操作。
+
+## 层级结构
+
+侧边栏按数据库对象层级组织：
+
+```text
+连接
+ └── 数据库
+      └── Schema
+           └── 表 / 视图
+                └── 字段（类型、约束、默认值）
+```
+
+点击节点可以展开或折叠；点击表名可以打开数据浏览；字段节点会展示类型、约束和默认值等信息。
+
+## 不同数据库的树结构
+
+| 连接类型     | 浏览模型                                                                        |
+| ------------ | ------------------------------------------------------------------------------- |
+| 关系型数据库 | 连接、数据库、Schema、表/视图、字段、索引、外键、触发器，以及可获取元数据的例程 |
+| Redis        | Redis 数据库和键，并为 String、Hash、List、Set、Sorted Set、Stream 提供值编辑   |
+| MongoDB      | 数据库、集合和分页文档浏览                                                      |
+| 对象浏览器   | 在数据库支持时查看视图、存储过程和函数源码                                      |
+| 保存的 SQL   | 侧边栏中的 SQL 文件夹和可复用 SQL 文件                                          |
+
+## 搜索
+
+侧边栏搜索用于在对象数量较多时快速定位：
+
+- 表名
+- 视图名
+- 字段名
+- 部分数据库对象路径
+
+<Callout type="info">当连接中有大量表时，搜索会优先面向可见对象和缓存的元数据工作。刚刷新或首次展开的对象，可能需要等待元数据加载完成后才能完整匹配。</Callout>
+
+## 置顶
+
+把常用连接、数据库或表置顶后，可以减少在深层树结构中反复展开的操作。置顶适合这些对象：
+
+- 高频查询表
+- 当前迭代相关表
+- 生产环境中需要重点区分的连接
+- 排查问题时反复查看的对象
+
+## 右键菜单
+
+不同节点会显示不同的上下文操作：
+
+| 节点   | 常用操作                                       |
+| ------ | ---------------------------------------------- |
+| 连接   | 刷新元数据、复制连接、断开连接、编辑连接       |
+| 数据库 | 创建数据库、删除数据库、导出数据库             |
+| Schema | 创建 Schema、删除 Schema                       |
+| 表     | 打开数据、查看结构、导入数据、复制表名、删除表 |
+| 字段   | 复制字段名、查看字段信息                       |
+
+<Callout type="warn">删除数据库、删除 Schema、删除表等操作可能不可恢复。执行前请确认当前连接环境，必要时先备份。</Callout>
+
+## 字段注释
+
+如果数据库支持字段注释，DBX 会在字段旁展示注释内容。对于接手陌生库或阅读历史表结构，这通常比只看字段名更有帮助。
+
+## 连接颜色
+
+可以给连接设置颜色，用于区分环境。例如：
+
+| 环境 | 建议颜色   |
+| ---- | ---------- |
+| 本地 | 灰色或绿色 |
+| 测试 | 蓝色或紫色 |
+| 预发 | 黄色       |
+| 生产 | 红色       |
+
+颜色会出现在侧边栏连接名称和标签页中，帮助减少误操作。
+
+## Redis 浏览器
+
+Redis 连接会使用更适合键值数据的浏览方式：
+
+- 键以表格方式展示，便于扫描
+- 支持分页浏览，避免一次性加载大量键
+- 可直接查看和编辑键值
+- 支持 String、Hash、List、Set、Sorted Set 和 Stream
+
+Redis 键空间较大时，建议配合搜索和分页使用，避免一次性展开过多数据。
+
+## 功能边界
+
+| 功能          | 支持类型                                                                                                                                                                                                                              |
+| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Schema 感知树 | PostgreSQL、SQL Server、Oracle、Redshift、DM、GaussDB、KingBase、HighGo、Vastbase、JDBC、H2、Snowflake、Trino、DB2、TDengine                                                                                                          |
+| ER 图         | MySQL、PostgreSQL、SQLite、SQL Server、Oracle、Redshift、DM、GaussDB、KingBase、HighGo、Vastbase、GoldenDB、Access、H2、DB2                                                                                                           |
+| 数据库搜索    | MySQL、PostgreSQL、SQLite、SQL Server、Oracle、Redshift、DuckDB、ClickHouse、DM、GaussDB、KingBase、HighGo、Vastbase、GoldenDB、Access、H2、Snowflake、Trino、Hive、DB2、Informix、Neo4j、Cassandra、BigQuery、Kylin、SunDB、TDengine |
+
+如果某个节点菜单里没有对应操作，通常说明当前数据库类型没有暴露所需元数据，或 DBX 没有足够把握生成安全 SQL。
diff --git a/docs/content/docs/schema-browser.mdx b/docs/content/docs/schema-browser.mdx
new file mode 100644
index 0000000..4b85d74
--- /dev/null
+++ b/docs/content/docs/schema-browser.mdx
@@ -0,0 +1,102 @@
+---
+title: Schema Browser
+description: Browse connections, databases, schemas, tables, columns, and Redis keyspaces from the sidebar.
+---
+
+The schema browser is the left-side workspace in DBX. Use it to understand what exists in a connection and to open data, inspect structure, or run context-specific actions.
+
+## Object Hierarchy
+
+The sidebar organizes objects by database hierarchy:
+
+```text
+Connection
+  └── Database
+        └── Schema
+              └── Tables / Views
+                    └── Columns (type, constraints, defaults)
+```
+
+Expand or collapse nodes to drill down. Click a table to open its data. Column entries show type, constraints, defaults, and related attributes when available.
+
+## Database-Specific Trees
+
+| Connection Type      | Browser Model                                                                                                                  |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| Relational databases | Connection, database, schema, tables/views, columns, indexes, foreign keys, triggers, and routines where metadata is available |
+| Redis                | Redis databases and keys, with value editors for String, Hash, List, Set, Sorted Set, and Stream                               |
+| MongoDB              | Databases, collections, and paginated document browsing                                                                        |
+| Object browser       | Views, procedures, and functions when the database exposes source metadata                                                     |
+| Saved SQL            | Folders and reusable SQL files in the sidebar library                                                                          |
+
+## Search
+
+Sidebar search helps locate objects when a connection contains many tables:
+
+- Table names
+- View names
+- Column names
+- Parts of database object paths
+
+<Callout type="info">For large schemas, search works best with visible objects and cached metadata. Objects that were just refreshed or not yet expanded may need metadata loading before they are fully matched.</Callout>
+
+## Pinning
+
+Pin frequently used connections, databases, or tables to reduce repeated navigation through deep trees. Pinning is useful for:
+
+- High-frequency query tables
+- Objects related to the current iteration
+- Production connections that should stand out
+- Tables repeatedly checked during debugging
+
+## Context Menus
+
+Different node types expose different actions:
+
+| Node       | Common Actions                                                      |
+| ---------- | ------------------------------------------------------------------- |
+| Connection | Refresh metadata, duplicate connection, disconnect, edit connection |
+| Database   | Create database, drop database, export database                     |
+| Schema     | Create schema, drop schema                                          |
+| Table      | Open data, open structure, import data, copy table name, drop table |
+| Column     | Copy column name, inspect column details                            |
+
+<Callout type="warn">Dropping databases, schemas, or tables may be irreversible. Confirm the active connection and back up data when needed.</Callout>
+
+## Column Comments
+
+When the database supports column comments, DBX displays them next to columns. This is especially helpful when you are reading an unfamiliar schema or legacy database.
+
+## Connection Colors
+
+Connection colors help separate environments:
+
+| Environment | Suggested Color |
+| ----------- | --------------- |
+| Local       | Gray or green   |
+| Test        | Blue or purple  |
+| Staging     | Yellow          |
+| Production  | Red             |
+
+Colors appear beside connection names in the sidebar and in tabs, reducing the chance of operating on the wrong environment.
+
+## Redis Browser
+
+Redis connections use a browser designed for key-value data:
+
+- Keys are displayed in a table for easier scanning
+- Pagination avoids loading large keyspaces at once
+- Values can be viewed and edited directly
+- String, Hash, List, Set, Sorted Set, and Stream are supported
+
+For large Redis keyspaces, use search and pagination together instead of expanding too much data at once.
+
+## Feature Boundaries
+
+| Feature           | Supported Types                                                                                                                                                                                                                       |
+| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Schema-aware tree | PostgreSQL, SQL Server, Oracle, Redshift, DM, GaussDB, KingBase, HighGo, Vastbase, JDBC, H2, Snowflake, Trino, DB2, TDengine                                                                                                          |
+| ER diagram        | MySQL, PostgreSQL, SQLite, SQL Server, Oracle, Redshift, DM, GaussDB, KingBase, HighGo, Vastbase, GoldenDB, Access, H2, DB2                                                                                                           |
+| Database search   | MySQL, PostgreSQL, SQLite, SQL Server, Oracle, Redshift, DuckDB, ClickHouse, DM, GaussDB, KingBase, HighGo, Vastbase, GoldenDB, Access, H2, Snowflake, Trino, Hive, DB2, Informix, Neo4j, Cassandra, BigQuery, Kylin, SunDB, TDengine |
+
+If an action is missing from a node menu, the active database type may not expose the required metadata or safe SQL generation path.
diff --git a/docs/content/docs/schema-diff.cn.mdx b/docs/content/docs/schema-diff.cn.mdx
new file mode 100644
index 0000000..e1d5a92
--- /dev/null
+++ b/docs/content/docs/schema-diff.cn.mdx
@@ -0,0 +1,89 @@
+---
+title: Schema 对比
+description: 对比两个数据库的结构差异，生成可审查的同步 SQL。
+---
+
+Schema 对比用于检查两个数据库环境之间的结构差异，例如开发库和生产库、测试库和预发库，或迁移前后的数据库。
+
+<Callout type="warn">Schema 同步可能包含删除表、删除字段、修改字段类型等破坏性操作。生成 SQL 后请逐条审查，生产环境建议先备份。</Callout>
+
+## 适合的场景
+
+- 检查开发环境中的结构变更是否已经同步到生产
+- 对齐 staging、QA、production 等多套环境
+- 生成迁移脚本，交给团队审查后执行
+- 对比两个版本数据库之间的表、字段、索引差异
+
+## 使用流程
+
+<Steps>
+  <Step>
+    ### 选择源库
+
+    源库通常是你认为“结构较新”或“结构正确”的数据库。
+
+  </Step>
+  <Step>
+    ### 选择目标库
+
+    目标库是需要被检查或同步的数据库。它可以和源库位于不同服务器，也可以是不同数据库引擎。
+
+  </Step>
+  <Step>
+    ### 执行对比
+
+    DBX 会读取两边的表、字段和索引元数据，并计算差异。当前对比只处理表，不包含视图。
+
+  </Step>
+  <Step>
+    ### 审查差异
+
+    重点检查缺失表、额外表、字段类型变化、是否允许 NULL、默认值变化、索引增删和可能的数据风险。
+
+  </Step>
+  <Step>
+    ### 生成同步 SQL
+
+    根据差异生成 `CREATE TABLE`、`ALTER TABLE`、`DROP TABLE` 等语句。确认后再决定是否执行。
+
+  </Step>
+</Steps>
+
+## 差异类型
+
+| 类型         | 含义                                         |
+| ------------ | -------------------------------------------- |
+| 仅源库存在   | 目标库缺少该对象，通常需要创建               |
+| 仅目标库存在 | 目标库多出该对象，删除前需要确认是否仍被使用 |
+| 字段差异     | 字段类型、是否允许 NULL 或默认值不同         |
+| 索引差异     | 按索引名称检查新增或删除的索引               |
+
+<Callout type="info">当前 Schema 对比不完整覆盖外键、触发器、视图定义、字段注释，也不会检测同名索引的列或唯一性变化。重要迁移仍建议人工审查生成的 SQL。</Callout>
+
+## 数据库覆盖范围
+
+Schema 对比依赖表、字段和索引元数据。它更适合 MySQL、PostgreSQL、SQLite、SQL Server、Oracle、Redshift、DM、GaussDB 系等可以稳定读取关系结构的数据库。Redis、MongoDB、Elasticsearch 的数据模型不同，不适合作为关系型 Schema 同步目标。
+
+## 执行前检查
+
+同步前建议确认：
+
+- 当前连接颜色和环境名称是否正确
+- 目标库是否已经备份
+- `DROP`、`TRUNCATE`、字段类型变更是否符合预期
+- 是否需要在业务低峰期执行
+- 是否需要先在测试环境验证生成的 SQL
+
+## 相关功能
+
+<Cards>
+  <Card title="表结构编辑器" href="/cn/docs/table-structure">
+    对单张表进行可视化结构修改，并在保存前预览 DDL。
+  </Card>
+  <Card title="数据库导出" href="/cn/docs/database-export">
+    在执行高风险同步前导出结构和数据。
+  </Card>
+  <Card title="数据库支持" href="/cn/docs/databases">
+    查看哪些数据库支持结构相关工作流。
+  </Card>
+</Cards>
diff --git a/docs/content/docs/schema-diff.mdx b/docs/content/docs/schema-diff.mdx
new file mode 100644
index 0000000..9abd673
--- /dev/null
+++ b/docs/content/docs/schema-diff.mdx
@@ -0,0 +1,89 @@
+---
+title: Schema Diff
+description: Compare two database schemas and generate reviewable sync SQL.
+---
+
+Schema Diff helps compare structure between database environments, such as development and production, staging and QA, or databases before and after a migration.
+
+<Callout type="warn">Schema sync may include destructive operations such as dropping tables, dropping columns, or changing column types. Review generated SQL line by line, and back up production databases first.</Callout>
+
+## Use Cases
+
+- Check whether schema changes from development are already applied to production
+- Align staging, QA, and production environments
+- Generate migration SQL for team review
+- Compare tables, columns, indexes, and constraints between database versions
+
+## Workflow
+
+<Steps>
+  <Step>
+    ### Select the Source
+
+    The source is usually the database whose structure is newer or considered correct.
+
+  </Step>
+  <Step>
+    ### Select the Target
+
+    The target is the database to inspect or sync. It can be on another server or even another database engine.
+
+  </Step>
+  <Step>
+    ### Run the Comparison
+
+    DBX reads table, column, and index metadata from both sides. The current comparison handles tables, not views.
+
+  </Step>
+  <Step>
+    ### Review Differences
+
+    Check missing tables, extra tables, column type changes, nullable changes, default value changes, added or removed indexes, and data risk.
+
+  </Step>
+  <Step>
+    ### Generate Sync SQL
+
+    DBX generates statements such as `CREATE TABLE`, `ALTER TABLE`, and `DROP TABLE`. Review them before execution.
+
+  </Step>
+</Steps>
+
+## Difference Types
+
+| Type              | Meaning                                                                |
+| ----------------- | ---------------------------------------------------------------------- |
+| Source only       | The object is missing from the target and may need to be created       |
+| Target only       | The object exists only in the target; confirm usage before dropping it |
+| Column difference | Type, nullable flag, or default value differs                          |
+| Index difference  | Added or removed indexes, matched by index name                        |
+
+<Callout type="info">Schema Diff currently does not fully compare foreign keys, triggers, view definitions, column comments, or changed columns/uniqueness inside an index with the same name. Important migrations still need manual SQL review.</Callout>
+
+## Database Coverage
+
+Schema Diff depends on table, column, and index metadata. It works best on relational engines where DBX can list structures consistently, such as MySQL, PostgreSQL, SQLite, SQL Server, Oracle, Redshift, DM, and GaussDB-family engines. Redis, MongoDB, and Elasticsearch use different data models and are not good targets for relational schema sync.
+
+## Before Running Sync SQL
+
+Before applying generated SQL, confirm:
+
+- The active connection color and environment name are correct
+- The target database has been backed up
+- `DROP`, `TRUNCATE`, and column type changes are intentional
+- The operation should run during a maintenance window
+- The SQL has been tested in a non-production environment
+
+## Related Features
+
+<Cards>
+  <Card title="Table Structure Editor" href="/en/docs/table-structure">
+    Edit one table visually and preview DDL before applying changes.
+  </Card>
+  <Card title="Database Export" href="/en/docs/database-export">
+    Export structure and data before high-risk sync operations.
+  </Card>
+  <Card title="Database Support" href="/en/docs/databases">
+    Check which engines support schema and structure workflows.
+  </Card>
+</Cards>
diff --git a/docs/content/docs/sql-file.cn.mdx b/docs/content/docs/sql-file.cn.mdx
new file mode 100644
index 0000000..0a93d92
--- /dev/null
+++ b/docs/content/docs/sql-file.cn.mdx
@@ -0,0 +1,76 @@
+---
+title: SQL 文件执行
+description: 选择连接后执行 .sql 文件，查看进度，并在需要时取消后续语句。
+---
+
+SQL 文件执行用于导入或运行本地 `.sql` 脚本。它适合执行初始化脚本、数据补丁、数据库导出文件和迁移脚本。
+
+<Callout type="warn">执行 SQL 文件可能修改大量数据或结构。运行前请确认目标连接、目标数据库和脚本来源，生产环境建议先备份。</Callout>
+
+## 使用流程
+
+<Steps>
+  <Step>
+    ### 打开 SQL 文件执行
+
+    在 DBX 中打开 SQL 文件执行面板。
+
+  </Step>
+  <Step>
+    ### 选择文件
+
+    选择本地 `.sql` 文件。大文件可能需要更长解析和执行时间。
+
+  </Step>
+  <Step>
+    ### 选择目标连接
+
+    选择要执行脚本的数据库连接和数据库。
+
+  </Step>
+  <Step>
+    ### 开始执行
+
+    点击执行后，DBX 会按语句执行并显示进度。
+
+  </Step>
+  <Step>
+    ### 检查结果
+
+    执行结束后查看成功数量、失败语句和错误信息。
+
+  </Step>
+</Steps>
+
+## 语句分割
+
+DBX 会按流式方式读取 SQL 文件，并尽量正确识别语句边界，避免简单按每个分号拆分：
+
+- 字符串中的分号不会被当作语句结束
+- 行注释和块注释中的分号不会被当作语句结束
+- PostgreSQL 的 dollar-quoted 函数体会保持为同一条语句
+- SQL Server 的 `GO` 行会被识别为批次分隔
+- MySQL executable comments 会在导入前按目标连接处理：MySQL 兼容连接会展开可执行内容，非 MySQL 连接会跳过；`ENABLE/DISABLE KEYS`、`LOCK/UNLOCK TABLES`、session 状态恢复这类导入辅助指令会跳过
+
+## 数据库覆盖范围
+
+SQL 文件执行面向 SQL 类数据库。Redis、MongoDB 和 Elasticsearch 不执行关系型 SQL 脚本，因此 DBX 会隐藏或禁用该功能。
+
+## 错误处理
+
+默认情况下，执行遇到错误会停止。你也可以启用“遇错继续”，让 DBX 继续执行后续语句并记录失败数量。
+
+## 取消执行
+
+执行过程中可以取消任务。取消只会阻止后续语句继续执行，已经提交到数据库的语句不会自动回滚。
+
+<Callout type="info">如果脚本需要整体原子性，建议脚本本身包含事务控制，并确认目标数据库支持相关事务语义。</Callout>
+
+## 执行前检查
+
+- 当前连接是否是预期环境
+- 脚本是否来自可信来源
+- 是否包含 `DROP`、`TRUNCATE`、大范围 `UPDATE` 或 `DELETE`
+- 是否需要先在测试环境执行
+- 是否需要启用“遇错继续”
+- 是否需要先使用 [数据库导出](/cn/docs/database-export) 备份
diff --git a/docs/content/docs/sql-file.mdx b/docs/content/docs/sql-file.mdx
new file mode 100644
index 0000000..9a8cf41
--- /dev/null
+++ b/docs/content/docs/sql-file.mdx
@@ -0,0 +1,76 @@
+---
+title: SQL File Execution
+description: Execute .sql files against a selected connection, monitor progress, and cancel remaining statements when needed.
+---
+
+SQL File Execution runs local `.sql` scripts in DBX. Use it for initialization scripts, data patches, database dumps, and migration scripts.
+
+<Callout type="warn">SQL files may modify large amounts of data or schema. Confirm the target connection, target database, and script source before running. Back up production databases first.</Callout>
+
+## Workflow
+
+<Steps>
+  <Step>
+    ### Open SQL File Execution
+
+    Open the SQL file execution panel in DBX.
+
+  </Step>
+  <Step>
+    ### Choose a File
+
+    Select a local `.sql` file. Large files may take longer to parse and execute.
+
+  </Step>
+  <Step>
+    ### Select Target Connection
+
+    Choose the connection and database where the script should run.
+
+  </Step>
+  <Step>
+    ### Start Execution
+
+    DBX executes the script statement by statement and shows progress.
+
+  </Step>
+  <Step>
+    ### Check Results
+
+    After execution, review successful statements, failed statements, and error messages.
+
+  </Step>
+</Steps>
+
+## Statement Splitting
+
+DBX reads SQL files as a stream and tries to detect statement boundaries correctly instead of splitting on every semicolon:
+
+- Semicolons inside strings are not treated as statement endings
+- Semicolons inside line and block comments are ignored
+- PostgreSQL dollar-quoted function bodies are kept together
+- SQL Server `GO` lines split batches
+- MySQL executable comments are prepared for the target connection before import: MySQL-compatible connections unwrap executable content, non-MySQL connections skip it, and import-helper directives such as `ENABLE/DISABLE KEYS`, `LOCK/UNLOCK TABLES`, and session state restores are skipped
+
+## Database Coverage
+
+SQL file execution is for SQL-oriented engines. DBX hides or disables it for Redis, MongoDB, and Elasticsearch because those connections do not execute relational SQL scripts.
+
+## Error Handling
+
+By default, execution stops when a statement fails. You can enable continue-on-error to keep running later statements while recording failures.
+
+## Cancelling Execution
+
+You can cancel while execution is running. Cancelling stops later statements from running, but statements already submitted to the database are not rolled back automatically.
+
+<Callout type="info">If a script must be atomic, include transaction control in the script itself and confirm the target database supports the required transaction behavior.</Callout>
+
+## Before Running
+
+- Confirm the active connection is the intended environment
+- Verify the script comes from a trusted source
+- Look for `DROP`, `TRUNCATE`, broad `UPDATE`, or broad `DELETE`
+- Run the script in a test environment first when possible
+- Decide whether continue-on-error is appropriate
+- Back up with [Database Export](/en/docs/database-export) when needed
diff --git a/docs/content/docs/sql-formatter.cn.mdx b/docs/content/docs/sql-formatter.cn.mdx
new file mode 100644
index 0000000..fabd928
--- /dev/null
+++ b/docs/content/docs/sql-formatter.cn.mdx
@@ -0,0 +1,225 @@
+---
+title: SQL 格式化
+description: 配置 SQL 格式化选项、导入导出 JSON 配置，并定制 JSON 配置编辑器快捷键。
+---
+
+DBX 的 SQL 格式化配置位于**设置 → SQL 格式化**。配置分为两部分：
+
+- `options`：控制 SQL 格式化结果，例如关键字大小写、缩进、操作符换行和参数类型。
+- `editor`：控制 SQL 格式化 JSON 配置编辑器中的快捷键。
+
+## 表单与 JSON
+
+表单模式适合修改常用选项。JSON 模式适合复制、粘贴、导入或批量修改完整配置。
+
+JSON 配置合法时，DBX 会把配置同步回表单；配置无效时，会显示具体错误并阻止应用。
+
+## 快捷键平台
+
+快捷键配置文件可以同时保存 Windows、Linux 和 macOS 三个平台的按键。
+
+表单中只显示当前系统的平台列。例如在 macOS 上只显示 macOS 快捷键，避免三端配置同时挤在一个表格里。导入和导出仍会保留完整三端配置，便于在不同系统间迁移。
+
+## 完整模板 JSON
+
+```json
+{
+  "version": 1,
+  "formatter": "sql-formatter",
+  "name": "DBX SQL 格式化配置",
+  "description": "SQL 格式化选项，以及 SQL 格式化 JSON 配置编辑器快捷键模板。",
+  "options": {
+    "keywordCase": "upper",
+    "dataTypeCase": "preserve",
+    "functionCase": "preserve",
+    "identifierCase": "preserve",
+    "indentStyle": "standard",
+    "useTabs": false,
+    "tabWidth": 2,
+    "logicalOperatorNewline": "before",
+    "expressionWidth": 80,
+    "linesBetweenQueries": 1,
+    "denseOperators": false,
+    "newlineBeforeSemicolon": false,
+    "paramTypes": null
+  },
+  "editor": {
+    "scope": "sqlFormatterConfigJsonEditor",
+    "platforms": ["windows", "linux", "macos"],
+    "shortcuts": [
+      {
+        "id": "find",
+        "action": "openSearchPanel",
+        "label": "查找",
+        "keys": {
+          "windows": "Ctrl+F",
+          "linux": "Ctrl+F",
+          "macos": "Cmd+F"
+        },
+        "enabled": true
+      },
+      {
+        "id": "replace",
+        "action": "openSearchPanel",
+        "label": "替换",
+        "keys": {
+          "windows": "Ctrl+H",
+          "linux": "Ctrl+H",
+          "macos": "Cmd+Option+F"
+        },
+        "enabled": true
+      },
+      {
+        "id": "indentMore",
+        "action": "indentMore",
+        "label": "增加缩进",
+        "keys": {
+          "windows": "Tab",
+          "linux": "Tab",
+          "macos": "Tab"
+        },
+        "enabled": true
+      },
+      {
+        "id": "indentLess",
+        "action": "indentLess",
+        "label": "减少缩进",
+        "keys": {
+          "windows": "Shift+Tab",
+          "linux": "Shift+Tab",
+          "macos": "Shift+Tab"
+        },
+        "enabled": true
+      },
+      {
+        "id": "duplicateLine",
+        "action": "copyLineDown",
+        "label": "复制当前行",
+        "keys": {
+          "windows": "Ctrl+D",
+          "linux": "Ctrl+D",
+          "macos": "Cmd+D"
+        },
+        "enabled": true
+      },
+      {
+        "id": "deleteLine",
+        "action": "deleteLine",
+        "label": "删除当前行",
+        "keys": {
+          "windows": "Ctrl+Shift+K",
+          "linux": "Ctrl+Shift+K",
+          "macos": "Cmd+Shift+K"
+        },
+        "enabled": true
+      },
+      {
+        "id": "moveLineUp",
+        "action": "moveLineUp",
+        "label": "当前行上移",
+        "keys": {
+          "windows": "Alt+Up",
+          "linux": "Alt+Up",
+          "macos": "Option+Up"
+        },
+        "enabled": true
+      },
+      {
+        "id": "moveLineDown",
+        "action": "moveLineDown",
+        "label": "当前行下移",
+        "keys": {
+          "windows": "Alt+Down",
+          "linux": "Alt+Down",
+          "macos": "Option+Down"
+        },
+        "enabled": true
+      },
+      {
+        "id": "copyLineUp",
+        "action": "copyLineUp",
+        "label": "向上复制当前行",
+        "keys": {
+          "windows": "Shift+Alt+Up",
+          "linux": "Shift+Alt+Up",
+          "macos": "Shift+Option+Up"
+        },
+        "enabled": true
+      },
+      {
+        "id": "copyLineDown",
+        "action": "copyLineDown",
+        "label": "向下复制当前行",
+        "keys": {
+          "windows": "Shift+Alt+Down",
+          "linux": "Shift+Alt+Down",
+          "macos": "Shift+Option+Down"
+        },
+        "enabled": true
+      },
+      {
+        "id": "undo",
+        "action": "undo",
+        "label": "撤销",
+        "keys": {
+          "windows": "Ctrl+Z",
+          "linux": "Ctrl+Z",
+          "macos": "Cmd+Z"
+        },
+        "enabled": true
+      },
+      {
+        "id": "redo",
+        "action": "redo",
+        "label": "重做",
+        "keys": {
+          "windows": "Ctrl+Y",
+          "linux": "Ctrl+Shift+Z",
+          "macos": "Cmd+Shift+Z"
+        },
+        "enabled": true
+      },
+      {
+        "id": "selectAll",
+        "action": "selectAll",
+        "label": "全选",
+        "keys": {
+          "windows": "Ctrl+A",
+          "linux": "Ctrl+A",
+          "macos": "Cmd+A"
+        },
+        "enabled": true
+      },
+      {
+        "id": "formatJson",
+        "action": "formatJson",
+        "label": "格式化 JSON 配置",
+        "keys": {
+          "windows": "Shift+Alt+F",
+          "linux": "Shift+Alt+F",
+          "macos": "Shift+Cmd+F"
+        },
+        "enabled": true
+      },
+      {
+        "id": "applyConfig",
+        "action": "applyJsonDraft",
+        "label": "应用 JSON 配置",
+        "keys": {
+          "windows": "Ctrl+S",
+          "linux": "Ctrl+S",
+          "macos": "Cmd+S"
+        },
+        "enabled": true
+      }
+    ]
+  }
+}
+```
+
+## 兼容说明
+
+- `version` 当前固定为 `1`。
+- `formatter` 当前固定为 `sql-formatter`。
+- `params` 参数替换不会被 SQL 格式化执行；需要参数识别时使用 `paramTypes`。
+- 旧模板中的 `replace` 动作如果写成 `openReplacePanel`，导入时会自动兼容并归一化。
diff --git a/docs/content/docs/sql-formatter.mdx b/docs/content/docs/sql-formatter.mdx
new file mode 100644
index 0000000..a682bbd
--- /dev/null
+++ b/docs/content/docs/sql-formatter.mdx
@@ -0,0 +1,225 @@
+---
+title: SQL Formatter
+description: Configure SQL formatting options, import and export JSON config, and customize JSON config editor shortcuts.
+---
+
+DBX SQL formatter settings live in **Settings → SQL Formatter**.
+
+- `options` controls formatting output such as keyword case, indentation, line breaks, and parameter types.
+- `editor` controls shortcuts used inside the SQL formatter JSON config editor.
+
+## Form And JSON
+
+Use the form for common options. Use JSON mode to copy, paste, import, export, or edit the full config.
+
+When the JSON config is valid, DBX syncs it back to the form. Invalid JSON shows an error and cannot be applied.
+
+## Shortcut Platform
+
+The config file can store Windows, Linux, and macOS shortcuts at the same time.
+
+The form only shows the current system column. For example, macOS shows only macOS shortcuts. Import and export still preserve all platform keys.
+
+## Full Template JSON
+
+```json
+{
+  "version": 1,
+  "formatter": "sql-formatter",
+  "name": "DBX SQL Formatter Config",
+  "description": "SQL formatter options and SQL formatter JSON config editor shortcut template.",
+  "options": {
+    "keywordCase": "upper",
+    "dataTypeCase": "preserve",
+    "functionCase": "preserve",
+    "identifierCase": "preserve",
+    "indentStyle": "standard",
+    "useTabs": false,
+    "tabWidth": 2,
+    "logicalOperatorNewline": "before",
+    "expressionWidth": 80,
+    "linesBetweenQueries": 1,
+    "denseOperators": false,
+    "newlineBeforeSemicolon": false,
+    "paramTypes": null
+  },
+  "editor": {
+    "scope": "sqlFormatterConfigJsonEditor",
+    "platforms": ["windows", "linux", "macos"],
+    "shortcuts": [
+      {
+        "id": "find",
+        "action": "openSearchPanel",
+        "label": "Find",
+        "keys": {
+          "windows": "Ctrl+F",
+          "linux": "Ctrl+F",
+          "macos": "Cmd+F"
+        },
+        "enabled": true
+      },
+      {
+        "id": "replace",
+        "action": "openSearchPanel",
+        "label": "Replace",
+        "keys": {
+          "windows": "Ctrl+H",
+          "linux": "Ctrl+H",
+          "macos": "Cmd+Option+F"
+        },
+        "enabled": true
+      },
+      {
+        "id": "indentMore",
+        "action": "indentMore",
+        "label": "Indent more",
+        "keys": {
+          "windows": "Tab",
+          "linux": "Tab",
+          "macos": "Tab"
+        },
+        "enabled": true
+      },
+      {
+        "id": "indentLess",
+        "action": "indentLess",
+        "label": "Indent less",
+        "keys": {
+          "windows": "Shift+Tab",
+          "linux": "Shift+Tab",
+          "macos": "Shift+Tab"
+        },
+        "enabled": true
+      },
+      {
+        "id": "duplicateLine",
+        "action": "copyLineDown",
+        "label": "Duplicate current line",
+        "keys": {
+          "windows": "Ctrl+D",
+          "linux": "Ctrl+D",
+          "macos": "Cmd+D"
+        },
+        "enabled": true
+      },
+      {
+        "id": "deleteLine",
+        "action": "deleteLine",
+        "label": "Delete current line",
+        "keys": {
+          "windows": "Ctrl+Shift+K",
+          "linux": "Ctrl+Shift+K",
+          "macos": "Cmd+Shift+K"
+        },
+        "enabled": true
+      },
+      {
+        "id": "moveLineUp",
+        "action": "moveLineUp",
+        "label": "Move line up",
+        "keys": {
+          "windows": "Alt+Up",
+          "linux": "Alt+Up",
+          "macos": "Option+Up"
+        },
+        "enabled": true
+      },
+      {
+        "id": "moveLineDown",
+        "action": "moveLineDown",
+        "label": "Move line down",
+        "keys": {
+          "windows": "Alt+Down",
+          "linux": "Alt+Down",
+          "macos": "Option+Down"
+        },
+        "enabled": true
+      },
+      {
+        "id": "copyLineUp",
+        "action": "copyLineUp",
+        "label": "Copy line up",
+        "keys": {
+          "windows": "Shift+Alt+Up",
+          "linux": "Shift+Alt+Up",
+          "macos": "Shift+Option+Up"
+        },
+        "enabled": true
+      },
+      {
+        "id": "copyLineDown",
+        "action": "copyLineDown",
+        "label": "Copy line down",
+        "keys": {
+          "windows": "Shift+Alt+Down",
+          "linux": "Shift+Alt+Down",
+          "macos": "Shift+Option+Down"
+        },
+        "enabled": true
+      },
+      {
+        "id": "undo",
+        "action": "undo",
+        "label": "Undo",
+        "keys": {
+          "windows": "Ctrl+Z",
+          "linux": "Ctrl+Z",
+          "macos": "Cmd+Z"
+        },
+        "enabled": true
+      },
+      {
+        "id": "redo",
+        "action": "redo",
+        "label": "Redo",
+        "keys": {
+          "windows": "Ctrl+Y",
+          "linux": "Ctrl+Shift+Z",
+          "macos": "Cmd+Shift+Z"
+        },
+        "enabled": true
+      },
+      {
+        "id": "selectAll",
+        "action": "selectAll",
+        "label": "Select all",
+        "keys": {
+          "windows": "Ctrl+A",
+          "linux": "Ctrl+A",
+          "macos": "Cmd+A"
+        },
+        "enabled": true
+      },
+      {
+        "id": "formatJson",
+        "action": "formatJson",
+        "label": "Format JSON config",
+        "keys": {
+          "windows": "Shift+Alt+F",
+          "linux": "Shift+Alt+F",
+          "macos": "Shift+Cmd+F"
+        },
+        "enabled": true
+      },
+      {
+        "id": "applyConfig",
+        "action": "applyJsonDraft",
+        "label": "Apply JSON config",
+        "keys": {
+          "windows": "Ctrl+S",
+          "linux": "Ctrl+S",
+          "macos": "Cmd+S"
+        },
+        "enabled": true
+      }
+    ]
+  }
+}
+```
+
+## Compatibility
+
+- `version` is currently `1`.
+- `formatter` is currently `sql-formatter`.
+- `params` replacement is not executed by SQL formatting. Use `paramTypes` when parameter recognition is needed.
+- Legacy templates that use `openReplacePanel` for the `replace` action are accepted and normalized on import.
diff --git a/docs/content/docs/sql-snippets.cn.mdx b/docs/content/docs/sql-snippets.cn.mdx
new file mode 100644
index 0000000..4aa33b1
--- /dev/null
+++ b/docs/content/docs/sql-snippets.cn.mdx
@@ -0,0 +1,70 @@
+---
+title: SQL 代码片段
+description: 创建带有自定义触发键的可复用 SQL 模板，加速查询编写。
+---
+
+SQL 代码片段允许你定义可复用的 SQL 模板，输入触发键时自动展开。这对于经常编写的查询模式、标准子句或团队特定的 SQL 约定非常有用。
+
+## 代码片段工作原理
+
+1. 使用**触发键**和**模板**定义一个代码片段
+2. 在 SQL 编辑器中输入触发键
+3. DBX 将触发键自动完成为完整模板
+4. 模板中的占位符让你可以按 Tab 键在可编辑位置之间跳转
+
+## 创建代码片段
+
+<Steps>
+  <Step>### 打开代码片段设置 前往**设置 → SQL 代码片段**。</Step>
+  <Step>### 添加新片段 点击**添加片段**并填写： - **触发键**：在编辑器中输入的简短关键字（如 `selall`、`joinex`） - **模板**：替换触发键的 SQL 文本</Step>
+  <Step>### 使用代码片段 在 SQL 编辑器中输入触发键，然后按 `Tab` 或从自动补全列表中选择。模板会在光标处展开。</Step>
+</Steps>
+
+## 示例片段
+
+以下是一些实用的片段模板：
+
+**带常用子句的 SELECT：**
+
+```sql
+SELECT ${1:columns}
+FROM ${2:table}
+WHERE ${3:condition}
+ORDER BY ${4:column}
+```
+
+**LEFT JOIN 模式：**
+
+```sql
+LEFT JOIN ${1:table} ON ${2:left_alias}.${3:column} = ${4:right_alias}.${5:column}
+```
+
+**带 GROUP BY 的 COUNT：**
+
+```sql
+SELECT ${1:column}, COUNT(*) AS cnt
+FROM ${2:table}
+GROUP BY ${1:column}
+HAVING COUNT(*) > ${3:threshold}
+ORDER BY cnt DESC
+```
+
+**CREATE TABLE 模板：**
+
+```sql
+CREATE TABLE ${1:table_name} (
+    ${2:id} INTEGER PRIMARY KEY,
+    ${3:column} ${4:type}
+);
+```
+
+## 占位符
+
+在模板中使用 `${1}`、`${2}` 等标记可编辑位置。展开后，按 `Tab` 在占位符之间跳转。相同编号的占位符会同时编辑。
+
+## 使用建议
+
+- 触发键保持简短但易记（3-6 个字符效果较好）
+- 使用一致的前缀来区分个人片段（如 `my_selall`）
+- 执行前检查展开的片段，尤其是在生产数据库上
+- 与团队分享实用的片段，以保持查询模式一致
diff --git a/docs/content/docs/sql-snippets.mdx b/docs/content/docs/sql-snippets.mdx
new file mode 100644
index 0000000..23ca7fd
--- /dev/null
+++ b/docs/content/docs/sql-snippets.mdx
@@ -0,0 +1,70 @@
+---
+title: SQL Snippets
+description: Create customizable SQL snippet templates with custom trigger keys for faster query writing.
+---
+
+SQL Snippets let you define reusable SQL templates that expand automatically when you type a trigger key. This is useful for frequently written query patterns, standard clauses, or team-specific SQL conventions.
+
+## How Snippets Work
+
+1. You define a snippet with a **trigger key** and a **template**
+2. In the SQL editor, type the trigger key
+3. DBX auto-completes the trigger to the full template
+4. Placeholders in the template let you tab through editable positions
+
+## Creating A Snippet
+
+<Steps>
+  <Step>### Open Snippet Settings Go to **Settings → SQL Snippets**.</Step>
+  <Step>### Add a New Snippet Click **Add Snippet** and fill in: - **Trigger**: a short key you type in the editor (e.g., `selall`, `joinex`) - **Template**: the SQL text that replaces the trigger</Step>
+  <Step>### Use the Snippet In the SQL editor, type the trigger key and press `Tab` or select it from the autocomplete list. The template expands in place.</Step>
+</Steps>
+
+## Example Snippets
+
+Here are some useful snippet templates to get started:
+
+**SELECT with common clauses:**
+
+```sql
+SELECT ${1:columns}
+FROM ${2:table}
+WHERE ${3:condition}
+ORDER BY ${4:column}
+```
+
+**LEFT JOIN pattern:**
+
+```sql
+LEFT JOIN ${1:table} ON ${2:left_alias}.${3:column} = ${4:right_alias}.${5:column}
+```
+
+**COUNT with GROUP BY:**
+
+```sql
+SELECT ${1:column}, COUNT(*) AS cnt
+FROM ${2:table}
+GROUP BY ${1:column}
+HAVING COUNT(*) > ${3:threshold}
+ORDER BY cnt DESC
+```
+
+**CREATE TABLE template:**
+
+```sql
+CREATE TABLE ${1:table_name} (
+    ${2:id} INTEGER PRIMARY KEY,
+    ${3:column} ${4:type}
+);
+```
+
+## Placeholders
+
+Use `${1}`, `${2}`, etc. in templates to mark editable positions. After expansion, press `Tab` to jump between placeholders. Placeholders with the same number are edited simultaneously.
+
+## Tips
+
+- Keep triggers short but memorable (3-6 characters works well)
+- Use a consistent prefix for personal snippets (e.g., `my_selall`)
+- Review expanded snippets before execution, especially on production databases
+- Share useful snippets with your team for consistent query patterns
diff --git a/docs/content/docs/ssh-tunnel.cn.mdx b/docs/content/docs/ssh-tunnel.cn.mdx
new file mode 100644
index 0000000..72c4374
--- /dev/null
+++ b/docs/content/docs/ssh-tunnel.cn.mdx
@@ -0,0 +1,134 @@
+---
+title: 隧道/代理
+description: 通过 SSH 隧道、HTTP 隧道、SOCKS5 代理或 HTTP 代理连接内网数据库。
+---
+
+<Callout type="info">当数据库不能直接访问时，DBX 可以在连接窗口的 **隧道/代理** 页签里配置连接层。</Callout>
+
+DBX 支持三类隧道/代理：
+
+| 类型     | 适用场景                                      |
+| -------- | --------------------------------------------- |
+| SSH 隧道 | 有跳板机、堡垒机或数据库服务器的 SSH 权限。   |
+| 代理     | 网络环境要求通过 SOCKS5 或 HTTP CONNECT 代理。 |
+| HTTP 隧道 | 只有内网 Web 服务器能访问数据库，不能使用 SSH/VPN。 |
+
+对网络数据库来说，DBX 会先在本机打开一个本地端口，让数据库驱动连接这个端口，再由隧道/代理层把数据库协议字节转发到真实目标。
+
+## SSH 隧道
+
+SSH 隧道是内置能力，不需要在终端里手动执行端口转发命令。
+
+| 字段       | 说明                                       |
+| ---------- | ------------------------------------------ |
+| SSH 主机   | SSH 服务器的地址                           |
+| SSH 端口   | SSH 端口，默认 `22`                        |
+| SSH 用户   | 登录 SSH 服务器的用户名                    |
+| 连接超时   | DBX 等待 SSH 连接建立的最长时间，默认 5 秒 |
+
+<Tabs groupId="ssh-auth" items={['密钥认证（推荐）', '密码认证']}>
+  <Tab value="密钥认证（推荐）">
+    选择本地的 SSH 私钥文件，例如 `~/.ssh/id_rsa`、`~/.ssh/id_ed25519`：
+
+    - **密钥路径**：浏览并选择私钥文件。
+    - **密钥密码**：如果私钥设置了密码保护，在这里输入。
+
+    密钥认证比密码认证更安全，推荐优先使用。
+
+  </Tab>
+  <Tab value="密码认证">
+    直接输入 SSH 用户的登录密码。适用于允许密码登录的服务器。
+  </Tab>
+</Tabs>
+
+### 允许局域网访问
+
+<Callout type="warn">启用“允许局域网访问”后，同一网络里的其他设备也可以通过你的机器访问转发后的数据库端口。只应在可信网络中启用。</Callout>
+
+默认情况下，SSH 隧道只监听 `localhost`。启用局域网访问后会绑定到 `0.0.0.0`，适合临时团队协作或多设备共享访问。
+
+## 代理
+
+如果当前网络要求通过代理访问数据库，可以添加代理层，而不是配置 SSH。
+
+DBX 支持：
+
+- SOCKS5 代理
+- HTTP CONNECT 代理
+- 可选代理用户名和密码
+
+## HTTP 隧道
+
+<Callout type="info">功能类型叫 HTTP 隧道。DBX 当前随代码提供的部署脚本是 `dbx_tunnel.php`，所以部署文件是 PHP 实现，但连接类型本身不是“PHP 隧道”。</Callout>
+
+当数据库在内网中，外部只能访问一台内网 Web 服务器，并且不能使用 SSH/VPN 时，可以使用 HTTP 隧道。这类场景和 Navicat、SQL-Front 的 HTTP 隧道类似。
+
+### 部署脚本
+
+把 `deploy/dbx_tunnel.php` 上传到一台能访问目标数据库的 PHP Web 服务器。
+
+在 PHP 服务器上配置环境变量：
+
+| 变量                             | 必填 | 说明                                         |
+| -------------------------------- | ---- | -------------------------------------------- |
+| `DBX_TUNNEL_TOKEN`               | 是   | 共享 token。DBX 里填写同一个值。             |
+| `DBX_TUNNEL_ALLOWED_HOSTS`       | 否   | 允许连接的目标主机列表，逗号分隔，强烈建议配置。 |
+| `DBX_TUNNEL_DIR`                 | 否   | 会话队列目录，默认使用临时目录。             |
+| `DBX_TUNNEL_MAX_SESSION_SECONDS` | 否   | 会话最长生命周期，默认 `3600` 秒。           |
+| `DBX_TUNNEL_PHP`                 | 否   | 当 PHP-FPM 没有 `fastcgi_finish_request` 时，用于启动 worker 的 PHP CLI 路径。 |
+
+在 DBX 里添加 **HTTP 隧道** 层，并填写：
+
+| 字段           | 说明                                                    |
+| -------------- | ------------------------------------------------------- |
+| 隧道脚本 URL   | `dbx_tunnel.php` 的 URL，例如 `https://example.com/dbx_tunnel.php` |
+| 隧道 Token     | `DBX_TUNNEL_TOKEN` 的值                                 |
+| 隧道超时       | 打开 HTTP 隧道以及连接目标数据库的超时时间              |
+
+数据库主机和端口要填写“PHP 服务器视角下能访问到的地址”，不一定是你本机能直接访问到的地址。
+
+### HTTP 隧道流程
+
+```text
+DBX 数据库驱动
+  -> 127.0.0.1:<本地临时端口>
+  -> DBX HTTP 隧道客户端
+  -> HTTP POST 请求
+  -> Web 服务器上的 dbx_tunnel.php
+  -> PHP 发起到内网数据库的 TCP 连接
+  -> 数据库
+```
+
+具体协议是短 HTTP 轮询：
+
+1. DBX 在本机启动一个 TCP 监听端口。
+2. 数据库驱动连接这个本地端口。
+3. DBX 向 `dbx_tunnel.php` 发送 `open`，带上 session id、目标主机、目标端口和连接超时。
+4. PHP 脚本校验 token 和 allow-list，然后启动 worker，worker 打开到数据库的 TCP socket。
+5. 数据库驱动发出的字节由 DBX 通过 `write` 发给脚本。
+6. DBX 通过 `read` 轮询脚本；脚本返回数据库响应字节后，DBX 写回本地数据库驱动连接。
+7. 连接结束时，DBX 发送 `close`，PHP worker 关闭数据库 socket。
+
+这个方案不需要部署 DBX Web，也不使用 WebSocket。
+
+### 安全与限制
+
+- 脚本 URL 建议使用 HTTPS。
+- `DBX_TUNNEL_TOKEN` 应使用足够长的随机值。
+- 建议配置 `DBX_TUNNEL_ALLOWED_HOSTS`，避免脚本变成通用内网 TCP 转发入口。
+- 如果条件允许，限制脚本路径的公网访问范围。
+- HTTP 隧道部署方便，但通常比直连、VPN、SSH 慢，因为它通过 HTTP 轮询和服务器端队列搬运数据库字节流。
+- 如果和其他连接层一起使用，HTTP 隧道必须放在隧道/代理第一层，因为它是最外层网络边界。
+
+## 文件型数据库
+
+SQLite 和 Access 是文件型连接，不使用隧道/代理。DuckDB 通常也使用本地文件，所以只有当当前驱动类型确实需要网络端点时才需要配置隧道/代理。
+
+<Cards>
+  <Card title="创建连接" href="/cn/docs/getting-started">
+    在同一个连接窗口里配置数据库类型、隧道/代理、SSL 和连接颜色。
+  </Card>
+  <Card title="数据库支持" href="/cn/docs/databases">
+    查看哪些数据库是文件型、原生驱动、兼容协议或插件驱动。
+  </Card>
+</Cards>
diff --git a/docs/content/docs/ssh-tunnel.mdx b/docs/content/docs/ssh-tunnel.mdx
new file mode 100644
index 0000000..85dbf41
--- /dev/null
+++ b/docs/content/docs/ssh-tunnel.mdx
@@ -0,0 +1,134 @@
+---
+title: Tunnel / Proxy
+description: Connect to private databases through SSH tunnels, HTTP tunnels, SOCKS5 proxies, or HTTP proxies.
+---
+
+<Callout type="info">DBX can open connection layers for databases that are not directly reachable. Configure them from the connection dialog's **Tunnel / Proxy** tab.</Callout>
+
+DBX supports three tunnel / proxy types:
+
+| Type        | Use When                                                                 |
+| ----------- | ------------------------------------------------------------------------ |
+| SSH tunnel  | You have SSH access to a bastion host or database server.                |
+| Proxy       | Your network requires SOCKS5 or HTTP CONNECT proxy access.               |
+| HTTP tunnel | Only a web server can reach the database, and SSH/VPN is not available. |
+
+For network databases, DBX opens a local port and points the database driver at that port. The tunnel / proxy layer then forwards the database protocol bytes to the real target.
+
+## SSH Tunnel
+
+SSH tunnels are built in. You do not need to create a manual terminal port forward.
+
+| Field           | Description                                                                   |
+| --------------- | ----------------------------------------------------------------------------- |
+| SSH Host        | Hostname or IP of the SSH server                                              |
+| SSH Port        | Port for SSH (default: 22)                                                    |
+| SSH User        | Username for SSH authentication                                               |
+| Connect Timeout | Maximum time DBX waits while opening the SSH connection; default is 5 seconds |
+
+<Tabs groupId="ssh-auth" items={['Private Key (Recommended)', 'Password']}>
+  <Tab value="Private Key (Recommended)">
+    Select a private key file (for example `~/.ssh/id_rsa` or `~/.ssh/id_ed25519`):
+
+    - **Key Path** — Browse and select your key file.
+    - **Key Passphrase** — Enter the passphrase if your key is encrypted.
+
+    Key authentication is more secure than password authentication.
+
+  </Tab>
+  <Tab value="Password">
+    Enter your SSH password directly. This works on servers that allow password authentication.
+  </Tab>
+</Tabs>
+
+### Expose Tunnel to LAN
+
+<Callout type="warn">Enabling LAN exposure means other devices on the same network can access the forwarded database port through your machine. Only enable this on trusted networks.</Callout>
+
+By default, the SSH tunnel listens on `localhost` only. Enable LAN exposure to bind to `0.0.0.0`, which is useful for temporary team sharing or multi-device access.
+
+## Proxy
+
+Use a proxy layer when your environment requires an outbound proxy instead of SSH.
+
+DBX supports:
+
+- SOCKS5 proxy
+- HTTP CONNECT proxy
+- Optional proxy username and password
+
+## HTTP Tunnel
+
+<Callout type="info">The feature is an HTTP tunnel. The script currently provided by DBX is `dbx_tunnel.php`, so the deployment artifact is PHP-specific, but the connection type in DBX is HTTP tunnel.</Callout>
+
+Use HTTP tunnel when the database is inside a private network, but a web server in that network can reach it. This matches environments where only HTTP/HTTPS is available and SSH tunnel permissions are too broad or unavailable.
+
+### Deploy The Script
+
+Upload `deploy/dbx_tunnel.php` to a PHP web server that can reach the database.
+
+Configure these environment variables on the PHP server:
+
+| Variable                         | Required | Description                                                                 |
+| -------------------------------- | -------- | --------------------------------------------------------------------------- |
+| `DBX_TUNNEL_TOKEN`               | Yes      | Shared token. Enter the same value in DBX.                                  |
+| `DBX_TUNNEL_ALLOWED_HOSTS`       | No       | Comma-separated target host allow-list. Strongly recommended.               |
+| `DBX_TUNNEL_DIR`                 | No       | Session queue directory. Defaults to a temp directory.                      |
+| `DBX_TUNNEL_MAX_SESSION_SECONDS` | No       | Maximum session lifetime. Defaults to `3600`.                               |
+| `DBX_TUNNEL_PHP`                 | No       | PHP CLI path used when PHP-FPM `fastcgi_finish_request` is not available.   |
+
+In DBX, add an **HTTP Tunnel** layer and fill:
+
+| Field             | Description                                                        |
+| ----------------- | ------------------------------------------------------------------ |
+| Tunnel Script URL | URL of `dbx_tunnel.php`, for example `https://example.com/dbx_tunnel.php` |
+| Tunnel Token      | Value of `DBX_TUNNEL_TOKEN`                                        |
+| Tunnel Timeout    | Timeout for opening the HTTP tunnel and target database connection |
+
+The database host and port should be the address as seen from the PHP server, not necessarily the address as seen from your laptop.
+
+### HTTP Tunnel Flow
+
+```text
+DBX database driver
+  -> 127.0.0.1:<local temporary port>
+  -> DBX HTTP tunnel client
+  -> HTTP POST requests
+  -> dbx_tunnel.php on the web server
+  -> TCP connection from PHP to the private database
+  -> database
+```
+
+The request protocol is short HTTP polling:
+
+1. DBX starts a local TCP listener.
+2. The database driver connects to that local port.
+3. DBX sends `open` to `dbx_tunnel.php` with a session id, target host, target port, and connect timeout.
+4. The PHP script validates the token and allow-list, then starts a worker that opens a TCP socket to the database.
+5. Bytes from the database driver are sent to the script with `write`.
+6. DBX polls the script with `read`; response bytes are written back to the local database driver connection.
+7. When the connection ends, DBX sends `close` and the PHP worker closes the database socket.
+
+This does not require DBX Web and does not use WebSocket.
+
+### Security And Limits
+
+- Use HTTPS for the script URL.
+- Set a long random `DBX_TUNNEL_TOKEN`.
+- Set `DBX_TUNNEL_ALLOWED_HOSTS` so the script cannot become a general internal TCP relay.
+- Restrict public access to the script path where possible.
+- HTTP tunnel is convenient, but it is usually slower than direct TCP, VPN, or SSH because it forwards bytes through HTTP polling and a server-side queue.
+- If combined with other layers, HTTP tunnel must be the first tunnel / proxy layer because it is the outermost network boundary.
+
+## File Databases
+
+SQLite and Access connections are file-based and do not use tunnel / proxy layers. DuckDB usually uses a local file as well, so only configure tunnel / proxy layers when the selected driver profile uses a network endpoint.
+
+<Cards>
+  <Card title="Create a Connection" href="/en/docs/getting-started">
+    Configure the database profile, tunnel / proxy layers, SSL, and connection color together.
+  </Card>
+  <Card title="Database Support" href="/en/docs/databases">
+    Check which database profiles are file-based, native, compatibility-based, or plugin-backed.
+  </Card>
+</Cards>
diff --git a/docs/content/docs/table-import.cn.mdx b/docs/content/docs/table-import.cn.mdx
new file mode 100644
index 0000000..bf98f71
--- /dev/null
+++ b/docs/content/docs/table-import.cn.mdx
@@ -0,0 +1,93 @@
+---
+title: 表数据导入
+description: 将 CSV、TSV、JSON 或 Excel 文件导入数据库表，并检查列映射和导入模式。
+---
+
+表数据导入用于把本地文件写入指定表。它适合一次性导入测试数据、业务数据补录、从表格工具迁移数据等场景。
+
+## 支持的文件
+
+| 格式  | 说明                                                  |
+| ----- | ----------------------------------------------------- |
+| CSV   | 逗号分隔文本，适合通用数据交换                        |
+| TSV   | 制表符分隔文本，适合字段中包含逗号的场景              |
+| JSON  | JSON 数组，适合从接口或脚本导出的数据                 |
+| Excel | `.xlsx`、`.xlsm` 或 `.xls` 文件；DBX 读取第一个工作表 |
+
+DBX 会在导入前预览前 50 行。CSV/TSV 中的空单元格会按 `NULL` 处理。JSON 可以是单个对象、对象数组或数组行；对象行和数组行混用会被拒绝。
+
+## 导入流程
+
+<Steps>
+  <Step>
+    ### 选择目标表
+
+    在侧边栏中右键目标表，选择 **导入数据**。
+
+  </Step>
+  <Step>
+    ### 选择文件
+
+    选择要导入的 CSV、TSV、JSON 或 Excel 文件。
+
+  </Step>
+  <Step>
+    ### 检查列映射
+
+    DBX 会按列名尝试匹配文件字段和数据库字段。请检查主键、必填字段、日期字段和数值字段。
+
+  </Step>
+  <Step>
+    ### 选择导入模式
+
+    选择追加或清空后导入。清空模式会先删除目标表已有数据。
+
+  </Step>
+  <Step>
+    ### 执行并检查结果
+
+    导入完成后检查成功行数、失败原因和目标表数据。
+
+  </Step>
+</Steps>
+
+## 导入模式
+
+| 模式       | 行为                         | 适合场景                 |
+| ---------- | ---------------------------- | ------------------------ |
+| 追加       | 保留原有数据，继续插入新行   | 补充数据、追加样例数据   |
+| 清空后导入 | 先清空目标表，再导入文件内容 | 重建测试表、替换临时数据 |
+
+<Callout type="warn">清空后导入会删除目标表中的现有数据。生产环境使用前请确认备份和影响范围。</Callout>
+
+导入会分批执行。默认批大小为 500 行，进度视图会显示已导入行数、总行数、错误和取消状态。
+
+## 字段映射规则
+
+- 先按字段名精确匹配
+- 也会按规范化名称匹配，忽略大小写、空格、下划线和连字符差异
+- 源字段可以跳过
+- 同一个目标字段不能被重复映射
+- 至少需要映射一个字段才能开始导入
+
+## 数据库覆盖范围
+
+表数据导入支持 MySQL、PostgreSQL、SQLite、DuckDB、ClickHouse、SQL Server、Oracle、Doris、StarRocks、Redshift、DM、GaussDB、KingBase、HighGo、Vastbase、GoldenDB 和 Access。
+
+## 导入前检查
+
+- 文件首行是否是列名
+- 字符编码是否正确
+- 日期、数字、布尔值格式是否符合目标数据库要求
+- 非空字段是否都有值
+- 唯一索引和主键是否会冲突
+- 是否需要先导入父表，再导入带外键的子表
+
+## 常见问题
+
+| 现象           | 可能原因                                         |
+| -------------- | ------------------------------------------------ |
+| 部分列没有导入 | 文件列名和表字段名不匹配，或列被取消映射         |
+| 导入失败       | 非空字段为空、类型不匹配、主键冲突或唯一约束冲突 |
+| 中文乱码       | 文件编码和解析方式不一致                         |
+| 日期错误       | 文件中的日期格式无法被目标数据库识别             |
diff --git a/docs/content/docs/table-import.mdx b/docs/content/docs/table-import.mdx
new file mode 100644
index 0000000..da770bc
--- /dev/null
+++ b/docs/content/docs/table-import.mdx
@@ -0,0 +1,93 @@
+---
+title: Table Import
+description: Import CSV, TSV, JSON, or Excel files into a table with reviewed column mapping and import mode.
+---
+
+Table Import writes a local file into a selected database table. Use it for one-off test data, operational data backfills, or moving data out of spreadsheet tools.
+
+## Supported Files
+
+| Format | Details                                                      |
+| ------ | ------------------------------------------------------------ |
+| CSV    | Comma-separated text for general data exchange               |
+| TSV    | Tab-separated text, useful when values contain commas        |
+| JSON   | JSON arrays exported from APIs or scripts                    |
+| Excel  | `.xlsx`, `.xlsm`, or `.xls` files; DBX reads the first sheet |
+
+DBX previews the first 50 rows before import. Empty CSV/TSV cells are treated as `NULL`. JSON imports can be a single object, an array of objects, or an array of arrays; mixed object and array rows are rejected.
+
+## Import Workflow
+
+<Steps>
+  <Step>
+    ### Select the Target Table
+
+    Right-click the target table in the sidebar and choose **Import Data**.
+
+  </Step>
+  <Step>
+    ### Choose a File
+
+    Select a CSV, TSV, JSON, or Excel file.
+
+  </Step>
+  <Step>
+    ### Review Column Mapping
+
+    DBX tries to match file columns to table columns by name. Check primary keys, required fields, dates, and numeric values.
+
+  </Step>
+  <Step>
+    ### Choose Import Mode
+
+    Select append or truncate-then-import. Truncate mode removes existing target data first.
+
+  </Step>
+  <Step>
+    ### Run and Inspect
+
+    After import, check inserted rows, failures, and the resulting table data.
+
+  </Step>
+</Steps>
+
+## Import Modes
+
+| Mode                 | Behavior                                          | Best For                                           |
+| -------------------- | ------------------------------------------------- | -------------------------------------------------- |
+| Append               | Keep existing data and insert new rows            | Backfills and sample data                          |
+| Truncate then import | Remove existing rows first, then insert file data | Rebuilding test tables or replacing temporary data |
+
+<Callout type="warn">Truncate-then-import deletes existing rows from the target table. Confirm backups and impact before using it on production data.</Callout>
+
+Imports run in batches. The default batch size is 500 rows, and the progress view reports imported rows, total rows, errors, and cancellation state.
+
+## Column Mapping Rules
+
+- Exact column names are matched first
+- Normalized names also match when spacing, underscores, hyphens, or case differ
+- A source column can be skipped
+- A target column cannot be mapped more than once
+- At least one column must be mapped before import can start
+
+## Database Coverage
+
+Table import is available for MySQL, PostgreSQL, SQLite, DuckDB, ClickHouse, SQL Server, Oracle, Doris, StarRocks, Redshift, DM, GaussDB, KingBase, HighGo, Vastbase, GoldenDB, and Access.
+
+## Before Importing
+
+- Confirm whether the first row contains column names
+- Check file encoding
+- Verify date, number, and boolean formats
+- Ensure required fields have values
+- Check for primary key and unique index conflicts
+- Import parent tables before child tables when foreign keys are involved
+
+## Troubleshooting
+
+| Symptom                  | Possible Cause                                                                             |
+| ------------------------ | ------------------------------------------------------------------------------------------ |
+| Some columns are skipped | File column names do not match table columns, or the mapping was disabled                  |
+| Import fails             | Required value missing, type mismatch, primary key conflict, or unique constraint conflict |
+| Text is garbled          | File encoding does not match parser settings                                               |
+| Dates are wrong          | Date format is not recognized by the target database                                       |
diff --git a/docs/content/docs/table-structure.cn.mdx b/docs/content/docs/table-structure.cn.mdx
new file mode 100644
index 0000000..3e0a178
--- /dev/null
+++ b/docs/content/docs/table-structure.cn.mdx
@@ -0,0 +1,77 @@
+---
+title: 表结构编辑器
+description: 可视化编辑表字段和索引，并在保存前预览 DDL。
+---
+
+表结构编辑器用于修改单张表的字段、索引和约束。它适合小范围结构调整，也适合在不手写 DDL 的情况下生成可审查的变更 SQL。
+
+<Callout type="info">表结构编辑器目前面向 MySQL、PostgreSQL、SQLite、SQL Server 和 ClickHouse 开启。其他数据库仍可能在结构浏览器中展示 DDL，但当 DBX 无法可靠生成安全变更时，不会显示可视化编辑器。</Callout>
+
+## 可以编辑什么
+
+| 对象   | 支持操作                                                           |
+| ------ | ------------------------------------------------------------------ |
+| 字段   | 新增、删除、重命名和修改字段；修改类型、长度、默认值、可空性和注释 |
+| 主键   | 添加、修改或移除主键字段                                           |
+| 索引   | 新增、删除和重建索引；配置索引类型、包含列、WHERE 过滤和注释       |
+| 注释   | MySQL/PostgreSQL 支持字段和索引注释写入                            |
+| 列顺序 | 可视化调整列顺序；DBX 会生成对应的 ALTER 语句                      |
+
+## 编辑器界面
+
+表结构编辑器以持久化标签页形式打开，而非模态对话框：
+
+- **类型 + 长度分列**：数据类型和长度/精度分离为独立列，配有可搜索的下拉选择器
+- **可调整列宽**：拖拽列边框调整编辑器布局
+- **语法高亮**：SQL 预览使用 Shiki 语法高亮
+- **DDL 能力矩阵**：编辑器了解每种数据库支持的 DDL 操作，仅启用相关控件
+
+不同数据库的 DDL 能力不完全一致，DBX 会按当前连接类型生成对应语法。
+
+## 工作流
+
+<Steps>
+  <Step>
+    ### 打开表结构
+
+    在侧边栏右键表，选择查看或编辑结构。
+
+  </Step>
+  <Step>
+    ### 修改字段或索引
+
+    在可视化界面中添加、修改或删除字段和索引。修改会先暂存在本地。
+
+  </Step>
+  <Step>
+    ### 查看 SQL 预览
+
+    保存前检查 DBX 生成的 `ALTER TABLE`、`CREATE INDEX`、`DROP INDEX` 等语句。
+
+  </Step>
+  <Step>
+    ### 确认执行
+
+    确认 SQL 没有问题后再应用到数据库。
+
+  </Step>
+</Steps>
+
+<Callout type="warn">删除字段、修改字段类型、修改 NULL 约束都可能影响现有数据。生产环境执行前建议先备份，并确认应用代码是否依赖旧结构。</Callout>
+
+## 数据库差异
+
+| 数据库          | 说明                                                                   |
+| --------------- | ---------------------------------------------------------------------- |
+| MySQL / MariaDB | 支持新增、删除、修改字段，以及新增/删除索引                            |
+| PostgreSQL      | 支持字段重命名、类型、默认值、NULL 约束和注释变更，以及新增/删除索引   |
+| SQLite          | 支持新增字段、删除字段和重命名字段；更复杂的字段修改会提示无法安全处理 |
+| SQL Server      | 支持常见单表结构操作                                                   |
+| 其他引擎        | 当 DBX 不显示可视化编辑器时，使用生成 DDL、Schema 对比或手写 SQL       |
+
+## 使用建议
+
+- 小改动可以直接使用表结构编辑器
+- 大规模结构迁移建议生成 SQL 后进入代码仓库审查
+- 多环境同步建议配合 [Schema 对比](/cn/docs/schema-diff)
+- 不确定影响范围时，先通过 [数据库导出](/cn/docs/database-export) 备份
diff --git a/docs/content/docs/table-structure.mdx b/docs/content/docs/table-structure.mdx
new file mode 100644
index 0000000..304f886
--- /dev/null
+++ b/docs/content/docs/table-structure.mdx
@@ -0,0 +1,77 @@
+---
+title: Table Structure Editor
+description: Edit table columns and indexes visually, then preview DDL before applying changes.
+---
+
+The table structure editor modifies columns, indexes, and constraints for a single table. Use it for focused structure changes or to generate reviewable DDL without writing it by hand.
+
+<Callout type="info">The structure editor is enabled for MySQL, PostgreSQL, SQLite, SQL Server, and ClickHouse. Other databases may still expose DDL through the schema browser, but DBX does not show the visual editor when it cannot generate safe changes.</Callout>
+
+## What You Can Edit
+
+| Object       | Supported Actions                                                                                    |
+| ------------ | ---------------------------------------------------------------------------------------------------- |
+| Columns      | Add, delete, rename, and modify columns; change type, length, default, nullable, and comments        |
+| Primary Key  | Add, modify, or remove primary key columns                                                           |
+| Indexes      | Add, delete, and rebuild indexes; configure index type, included columns, WHERE filter, and comments |
+| Comments     | MySQL/PostgreSQL can write column and index comments                                                 |
+| Column Order | Reorder columns visually; DBX generates the appropriate ALTER statements                             |
+
+## Editor Interface
+
+The table structure editor opens as a persistent tab, not a modal dialog:
+
+- **Type + Length columns**: Data type and length/precision are split into separate columns with searchable select dropdowns
+- **Resizable columns**: Drag column borders to adjust the editor layout
+- **Syntax highlighting**: SQL preview uses Shiki syntax highlighting
+- **DDL capability matrix**: The editor knows which DDL operations each database supports and only enables relevant controls
+
+Database engines differ in DDL capabilities. DBX generates SQL for the active connection type.
+
+## Workflow
+
+<Steps>
+  <Step>
+    ### Open Table Structure
+
+    Right-click a table in the sidebar and open its structure view.
+
+  </Step>
+  <Step>
+    ### Edit Columns or Indexes
+
+    Add, modify, or remove columns and indexes in the visual editor. Changes are staged locally first.
+
+  </Step>
+  <Step>
+    ### Review SQL Preview
+
+    Before saving, review generated statements such as `ALTER TABLE`, `CREATE INDEX`, and `DROP INDEX`.
+
+  </Step>
+  <Step>
+    ### Apply Changes
+
+    Execute the SQL only after confirming it matches your intent.
+
+  </Step>
+</Steps>
+
+<Callout type="warn">Dropping columns, changing column types, and changing nullable constraints can affect existing data. Back up production databases first and confirm application code does not depend on the old structure.</Callout>
+
+## Engine Differences
+
+| Engine          | Notes                                                                                          |
+| --------------- | ---------------------------------------------------------------------------------------------- |
+| MySQL / MariaDB | Add, delete, and modify columns; add and delete indexes                                        |
+| PostgreSQL      | Rename columns, change type/default/nullability/comments, and add/delete indexes               |
+| SQLite          | Add, delete, and rename columns; more complex existing-column edits are blocked with a warning |
+| SQL Server      | Focused editor support for common table structure operations                                   |
+| Other engines   | Use generated DDL, Schema Diff, or manual SQL when DBX does not expose the visual editor       |
+
+## Recommendations
+
+- Use the editor for small, focused changes
+- For large migrations, generate SQL and review it in your code repository
+- For environment sync, use [Schema Diff](/en/docs/schema-diff)
+- When impact is uncertain, back up first with [Database Export](/en/docs/database-export)
diff --git a/docs/content/docs/web-api.cn.mdx b/docs/content/docs/web-api.cn.mdx
new file mode 100644
index 0000000..ce49ad3
--- /dev/null
+++ b/docs/content/docs/web-api.cn.mdx
@@ -0,0 +1,331 @@
+---
+title: Web API 参考
+description: DBX Web 与 Docker 部署使用的 HTTP API，适用于自动化与集成场景。
+---
+
+<Callout type="warn">这套 API 主要服务于 DBX Web 界面，以及 MCP Web 模式等内部工具。它不是单独对外承诺的集成契约，路由和字段可能随版本调整。做脚本或 Agent 集成时，优先使用 [@dbx-app/cli](/cn/docs/cli) 或 [@dbx-app/mcp-server](/cn/docs/mcp)。</Callout>
+
+## 基础地址
+
+DBX Web 默认监听 `4224` 端口：
+
+```text
+http://localhost:4224
+```
+
+如果通过反向代理挂在子路径下，需要设置 `DBX_PUBLIC_BASE_PATH`。例如 `/dbx`：
+
+```text
+https://example.com/dbx/api/auth/check
+```
+
+所有 API 都位于 `/api` 路径下。
+
+## 认证
+
+受保护的路由需要名为 `dbx_session` 的会话 Cookie。
+
+### 检查认证状态
+
+```http
+GET /api/auth/check
+```
+
+示例响应：
+
+```json
+{
+  "authenticated": false,
+  "required": true,
+  "setup_required": false
+}
+```
+
+| 字段 | 含义 |
+| --- | --- |
+| `required` | 已启用密码保护 |
+| `setup_required` | 仍需首次设置密码 |
+| `authenticated` | 当前请求已持有有效会话 |
+
+### 首次设置密码
+
+```http
+POST /api/auth/setup
+Content-Type: application/json
+
+{
+  "password": "your-password"
+}
+```
+
+### 登录
+
+```http
+POST /api/auth/login
+Content-Type: application/json
+
+{
+  "password": "your-password"
+}
+```
+
+登录成功后，响应会返回 `Set-Cookie: dbx_session=...`。后续请求带上这个 Cookie 即可。
+
+### 退出登录
+
+```http
+POST /api/auth/logout
+Cookie: dbx_session=...
+```
+
+### 环境变量
+
+| 变量 | 作用 |
+| --- | --- |
+| `DBX_PASSWORD` | 容器启动时设置初始密码 |
+| `DBX_DISABLE_PASSWORD=1` | 完全关闭密码保护 |
+| `DBX_PORT` | 修改监听端口，默认 `4224` |
+| `DBX_DATA_DIR` | 存放 `dbx.db` 的数据目录 |
+| `DBX_PUBLIC_BASE_PATH` | 在子路径下提供服务，例如 `/dbx` |
+
+## 请求约定
+
+- JSON 请求体字段名默认使用 `camelCase`。
+- `GET` 请求的查询参数使用 `snake_case`，例如 `connection_id`。
+- 出错时通常返回带 `error` 字段的 JSON 和对应 HTTP 状态码。
+
+## 连接相关 API
+
+### 列出连接
+
+```http
+GET /api/connection/list
+Cookie: dbx_session=...
+```
+
+返回已保存的连接配置。密码等敏感信息不会直接出现在返回 JSON 中。
+
+### 保存连接
+
+```http
+POST /api/connection/save
+Content-Type: application/json
+Cookie: dbx_session=...
+
+{
+  "configs": [
+    {
+      "name": "local-mysql",
+      "db_type": "mysql",
+      "host": "127.0.0.1",
+      "port": 3306,
+      "username": "root",
+      "database": "app"
+    }
+  ]
+}
+```
+
+### 测试连接
+
+```http
+POST /api/connection/test
+Content-Type: application/json
+
+{
+  "config": {
+    "name": "temp",
+    "db_type": "mysql",
+    "host": "127.0.0.1",
+    "port": 3306,
+    "username": "root",
+    "database": "app"
+  }
+}
+```
+
+### 建立连接
+
+大多数数据类 API 会要求目标连接先处于已连接状态。
+
+```http
+POST /api/connection/connect
+Content-Type: application/json
+
+{
+  "config": {
+    "id": "connection-id",
+    "name": "local-mysql",
+    "db_type": "mysql",
+    "host": "127.0.0.1",
+    "port": 3306,
+    "username": "root",
+    "database": "app"
+  }
+}
+```
+
+### 健康检查
+
+```http
+POST /api/connection/check-health
+Content-Type: application/json
+
+{
+  "connectionId": "connection-id"
+}
+```
+
+## Schema API
+
+### 列出表
+
+```http
+GET /api/schema/tables?connection_id=CONNECTION_ID&database=app&schema=
+Cookie: dbx_session=...
+```
+
+### 列出字段
+
+```http
+GET /api/schema/columns?connection_id=CONNECTION_ID&database=app&schema=&table=users
+Cookie: dbx_session=...
+```
+
+其他常用 Schema 路由包括：
+
+- `/api/schema/databases`
+- `/api/schema/schemas`
+- `/api/schema/indexes`
+- `/api/schema/foreign-keys`
+- `/api/schema/ddl`
+
+## SQL 查询 API
+
+### 执行单条语句
+
+```http
+POST /api/query/execute
+Content-Type: application/json
+
+{
+  "connectionId": "connection-id",
+  "database": "app",
+  "sql": "select id, name from users limit 10"
+}
+```
+
+响应示例：
+
+```json
+{
+  "columns": ["id", "name"],
+  "rows": [[1, "Ada"], [2, "Lin"]]
+}
+```
+
+相关路由：
+
+| 路由 | 作用 |
+| --- | --- |
+| `/api/query/execute-multi` | 一次请求执行多个结果集 |
+| `/api/query/execute-batch` | 执行语句列表 |
+| `/api/query/cancel` | 取消正在执行的查询 |
+| `/api/query/build-table-select-sql` | 生成表浏览 SQL |
+
+## Redis API
+
+Redis 浏览和命令执行使用独立路由。
+
+```http
+POST /api/redis/execute-command
+Content-Type: application/json
+
+{
+  "connectionId": "redis-id",
+  "db": 0,
+  "command": "GET mykey"
+}
+```
+
+其他常见 Redis 路由：
+
+- `/api/redis/scan-keys`
+- `/api/redis/get-value`
+- `/api/redis/set-string`
+- `/api/redis/delete-key`
+
+## MongoDB API
+
+MongoDB 路由都是 `POST` 请求，使用 JSON 请求体。
+
+### 列出集合
+
+```http
+POST /api/mongo/list-collections
+Content-Type: application/json
+
+{
+  "connectionId": "mongo-id",
+  "database": "app"
+}
+```
+
+### 查询文档
+
+```http
+POST /api/mongo/find-documents
+Content-Type: application/json
+
+{
+  "connectionId": "mongo-id",
+  "database": "app",
+  "collection": "users",
+  "skip": 0,
+  "limit": 20,
+  "filter": "{}"
+}
+```
+
+其他 MongoDB 路由还包括 `aggregate-documents`、`insert-documents`、`update-documents`、`delete-documents` 等。
+
+## MCP 与 CLI 集成
+
+做自动化时，通常比直接调 Web API 更好维护：
+
+- MCP：[@dbx-app/mcp-server](/cn/docs/mcp)
+- CLI：[@dbx-app/cli](/cn/docs/cli)
+
+如果 MCP 连接的是已部署的 Web 实例，可设置：
+
+```json
+{
+  "env": {
+    "DBX_WEB_URL": "http://localhost:4224",
+    "DBX_WEB_PASSWORD": "your-password"
+  }
+}
+```
+
+MCP Server 会自动处理登录和会话 Cookie。
+
+## 示例脚本
+
+仓库内示例：
+
+- [examples/web-api/automation.sh](https://github.com/t8y2/dbx/tree/main/examples/web-api/automation.sh)
+- [examples/docker/docker-compose.yml](https://github.com/t8y2/dbx/tree/main/examples/docker/docker-compose.yml)
+- [examples/cli/basic-workflow.sh](https://github.com/t8y2/dbx/tree/main/examples/cli/basic-workflow.sh)
+
+## 其他路由分组
+
+Web 后端还为界面提供了更多路由，例如：
+
+- `/api/export/*`：导出与下载
+- `/api/import/*`：表导入
+- `/api/transfer/*`：数据传输任务
+- `/api/ai/*`：内置 AI 助手
+- `/api/agents/*`、`/api/jdbc/*`：驱动管理
+- `/api/history/*`、`/api/saved-sql/*`：编辑器状态
+
+完整路由列表见仓库中的 `crates/dbx-web/src/main.rs`。
diff --git a/docs/content/docs/web-api.mdx b/docs/content/docs/web-api.mdx
new file mode 100644
index 0000000..82da55d
--- /dev/null
+++ b/docs/content/docs/web-api.mdx
@@ -0,0 +1,331 @@
+---
+title: Web API Reference
+description: HTTP API used by DBX Web and Docker deployments for automation and integrations.
+---
+
+<Callout type="warn">This API powers the DBX Web UI and internal tooling such as the MCP Web backend. It is not a separate public integration contract. Endpoints and payloads may change between releases. For scripting and agent workflows, prefer [@dbx-app/cli](/en/docs/cli) or [@dbx-app/mcp-server](/en/docs/mcp) when possible.</Callout>
+
+## Base URL
+
+By default, DBX Web listens on port `4224`:
+
+```text
+http://localhost:4224
+```
+
+When deployed behind a reverse-proxy subpath, set `DBX_PUBLIC_BASE_PATH` and prefix every route. For example, with `/dbx`:
+
+```text
+https://example.com/dbx/api/auth/check
+```
+
+All API routes are under `/api`.
+
+## Authentication
+
+Protected routes require a session cookie named `dbx_session`.
+
+### Check Auth State
+
+```http
+GET /api/auth/check
+```
+
+Example response:
+
+```json
+{
+  "authenticated": false,
+  "required": true,
+  "setup_required": false
+}
+```
+
+| Field | Meaning |
+| --- | --- |
+| `required` | Password protection is enabled |
+| `setup_required` | First-run password setup is still needed |
+| `authenticated` | Current request already has a valid session |
+
+### First-Run Setup
+
+```http
+POST /api/auth/setup
+Content-Type: application/json
+
+{
+  "password": "your-password"
+}
+```
+
+### Login
+
+```http
+POST /api/auth/login
+Content-Type: application/json
+
+{
+  "password": "your-password"
+}
+```
+
+On success, the response sets `Set-Cookie: dbx_session=...`. Reuse that cookie on later requests.
+
+### Logout
+
+```http
+POST /api/auth/logout
+Cookie: dbx_session=...
+```
+
+### Environment Variables
+
+| Variable | Purpose |
+| --- | --- |
+| `DBX_PASSWORD` | Set an initial password at container startup |
+| `DBX_DISABLE_PASSWORD=1` | Disable password protection entirely |
+| `DBX_PORT` | Change the listen port (default `4224`) |
+| `DBX_DATA_DIR` | Data directory containing `dbx.db` |
+| `DBX_PUBLIC_BASE_PATH` | Serve DBX under a subpath such as `/dbx` |
+
+## Request Format
+
+- JSON request bodies use `camelCase` field names unless noted otherwise.
+- Query parameters for `GET` routes use `snake_case`, for example `connection_id`.
+- Errors usually return JSON with an `error` field and an HTTP status code.
+
+## Connection APIs
+
+### List Connections
+
+```http
+GET /api/connection/list
+Cookie: dbx_session=...
+```
+
+Returns saved connection profiles. Secrets such as passwords are stored separately from the returned JSON.
+
+### Save Connections
+
+```http
+POST /api/connection/save
+Content-Type: application/json
+Cookie: dbx_session=...
+
+{
+  "configs": [
+    {
+      "name": "local-mysql",
+      "db_type": "mysql",
+      "host": "127.0.0.1",
+      "port": 3306,
+      "username": "root",
+      "database": "app"
+    }
+  ]
+}
+```
+
+### Test Connection
+
+```http
+POST /api/connection/test
+Content-Type: application/json
+
+{
+  "config": {
+    "name": "temp",
+    "db_type": "mysql",
+    "host": "127.0.0.1",
+    "port": 3306,
+    "username": "root",
+    "database": "app"
+  }
+}
+```
+
+### Connect
+
+Most data APIs expect the target connection to be active first.
+
+```http
+POST /api/connection/connect
+Content-Type: application/json
+
+{
+  "config": {
+    "id": "connection-id",
+    "name": "local-mysql",
+    "db_type": "mysql",
+    "host": "127.0.0.1",
+    "port": 3306,
+    "username": "root",
+    "database": "app"
+  }
+}
+```
+
+### Check Health
+
+```http
+POST /api/connection/check-health
+Content-Type: application/json
+
+{
+  "connectionId": "connection-id"
+}
+```
+
+## Schema APIs
+
+### List Tables
+
+```http
+GET /api/schema/tables?connection_id=CONNECTION_ID&database=app&schema=
+Cookie: dbx_session=...
+```
+
+### List Columns
+
+```http
+GET /api/schema/columns?connection_id=CONNECTION_ID&database=app&schema=&table=users
+Cookie: dbx_session=...
+```
+
+Other schema routes include:
+
+- `/api/schema/databases`
+- `/api/schema/schemas`
+- `/api/schema/indexes`
+- `/api/schema/foreign-keys`
+- `/api/schema/ddl`
+
+## SQL Query APIs
+
+### Execute One Statement
+
+```http
+POST /api/query/execute
+Content-Type: application/json
+
+{
+  "connectionId": "connection-id",
+  "database": "app",
+  "sql": "select id, name from users limit 10"
+}
+```
+
+Example response shape:
+
+```json
+{
+  "columns": ["id", "name"],
+  "rows": [[1, "Ada"], [2, "Lin"]]
+}
+```
+
+Related routes:
+
+| Route | Purpose |
+| --- | --- |
+| `/api/query/execute-multi` | Execute multiple result sets in one request |
+| `/api/query/execute-batch` | Execute a list of statements |
+| `/api/query/cancel` | Cancel a running query |
+| `/api/query/build-table-select-sql` | Build a table browse query |
+
+## Redis APIs
+
+Redis browser and command execution use dedicated routes.
+
+```http
+POST /api/redis/execute-command
+Content-Type: application/json
+
+{
+  "connectionId": "redis-id",
+  "db": 0,
+  "command": "GET mykey"
+}
+```
+
+Other common Redis routes:
+
+- `/api/redis/scan-keys`
+- `/api/redis/get-value`
+- `/api/redis/set-string`
+- `/api/redis/delete-key`
+
+## MongoDB APIs
+
+MongoDB routes are `POST` endpoints with JSON bodies.
+
+### List Collections
+
+```http
+POST /api/mongo/list-collections
+Content-Type: application/json
+
+{
+  "connectionId": "mongo-id",
+  "database": "app"
+}
+```
+
+### Find Documents
+
+```http
+POST /api/mongo/find-documents
+Content-Type: application/json
+
+{
+  "connectionId": "mongo-id",
+  "database": "app",
+  "collection": "users",
+  "skip": 0,
+  "limit": 20,
+  "filter": "{}"
+}
+```
+
+Other MongoDB routes include `aggregate-documents`, `insert-documents`, `update-documents`, and `delete-documents`.
+
+## MCP and CLI Integration
+
+For automation, these packages are usually easier to maintain than calling the Web API directly:
+
+- MCP: [@dbx-app/mcp-server](/en/docs/mcp)
+- CLI: [@dbx-app/cli](/en/docs/cli)
+
+When MCP runs against a deployed Web instance, set:
+
+```json
+{
+  "env": {
+    "DBX_WEB_URL": "http://localhost:4224",
+    "DBX_WEB_PASSWORD": "your-password"
+  }
+}
+```
+
+The MCP server handles login and session cookies for you.
+
+## Example Scripts
+
+See the repository examples:
+
+- [examples/web-api/automation.sh](https://github.com/t8y2/dbx/tree/main/examples/web-api/automation.sh)
+- [examples/docker/docker-compose.yml](https://github.com/t8y2/dbx/tree/main/examples/docker/docker-compose.yml)
+- [examples/cli/basic-workflow.sh](https://github.com/t8y2/dbx/tree/main/examples/cli/basic-workflow.sh)
+
+## Route Groups
+
+The Web backend exposes many more routes for the UI, including:
+
+- `/api/export/*` for exports and downloads
+- `/api/import/*` for table imports
+- `/api/transfer/*` for data transfer jobs
+- `/api/ai/*` for the built-in AI assistant
+- `/api/agents/*` and `/api/jdbc/*` for driver management
+- `/api/history/*` and `/api/saved-sql/*` for editor state
+
+Browse `crates/dbx-web/src/main.rs` in the repository for the full route list.
diff --git a/docs/content/docs/what-is-dbx.cn.mdx b/docs/content/docs/what-is-dbx.cn.mdx
new file mode 100644
index 0000000..ed45754
--- /dev/null
+++ b/docs/content/docs/what-is-dbx.cn.mdx
@@ -0,0 +1,70 @@
+---
+title: 什么是 DBX？
+description: DBX 是一个开源数据库工作台，覆盖连接管理、SQL 编辑、数据浏览、结构工具、AI 助手和自托管访问。
+---
+
+DBX 是一个开源数据库工作台。它把日常数据库工作里的高频动作放在同一个界面里：连接数据库、写 SQL、查看和编辑数据、浏览结构、对比 Schema、导入导出数据，以及在需要时让 AI 辅助分析。
+
+它同时提供桌面应用和 Docker 版本。桌面应用适合本机开发和日常连接管理；Docker 版本适合在服务器上自托管，通过浏览器访问同一套能力。
+
+![DBX 截图](/screenshot-dark.png)
+
+## 适合的场景
+
+<Cards>
+  <Card title="日常查询与排查" href="/cn/docs/query-editor">
+    使用 SQL 编辑器编写、格式化和执行查询，并通过查询历史快速找回之前的排查过程。
+  </Card>
+  <Card title="查看与修改数据" href="/cn/docs/data-grid">
+    在数据表格中筛选、排序、编辑、预览 SQL，再决定是否写入数据库。
+  </Card>
+  <Card title="理解数据库结构" href="/cn/docs/schema-browser">
+    通过侧边栏浏览数据库、Schema、表、字段、索引、外键和触发器，适合接手陌生库时快速定位对象。
+  </Card>
+  <Card title="跨环境同步" href="/cn/docs/schema-diff">
+    对比开发、测试、生产等环境之间的结构差异，生成可审查的同步 SQL。
+  </Card>
+</Cards>
+
+## 主要能力
+
+| 能力         | 说明                                                                                            |
+| ------------ | ----------------------------------------------------------------------------------------------- |
+| 多数据库连接 | 支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、DuckDB、ClickHouse、SQL Server、Oracle 等数据库 |
+| SQL 编辑器   | 基于 CodeMirror 6，支持语法高亮、元数据补全、格式化、选中执行和查询历史                         |
+| 数据表格     | 虚拟滚动、行内编辑、WHERE/ORDER BY 控制、SQL 预览和多格式导出                                   |
+| 结构工具     | 结构浏览、表结构编辑、Schema 对比、ER 图、字段血缘、数据库导出和 SQL 文件执行                   |
+| 数据流转     | 表数据导入、数据传输、SQL 文件执行，以及支持进度和取消的 SQL 导出                               |
+| 专项浏览器   | Redis 键值浏览和 MongoDB 文档浏览                                                               |
+| AI 与自动化  | 根据连接元数据生成 SQL、解释查询、优化语句、辅助修复错误，并通过 MCP 暴露连接给编程助手         |
+| 自托管访问   | Docker 版本可部署在服务器上，通过浏览器访问 DBX                                                 |
+
+## 设计取向
+
+DBX 优先覆盖数据库客户端里的核心工作流，而不是把所有数据库管理场景都塞进一个复杂入口。它更关注这些细节：
+
+- **少切换上下文**：结构浏览、SQL 编辑、数据表格和结果查看尽量在同一工作区内完成。
+- **操作可审查**：涉及数据或结构变更时，尽量先展示将要执行的 SQL。
+- **多环境可区分**：连接颜色、置顶、搜索和上下文菜单帮助区分开发、测试和生产环境。
+- **轻量部署**：桌面版适合个人日常工作，Docker 版适合团队或服务器环境。
+
+## 数据与安全
+
+- 连接配置保存在本机应用数据目录的 SQLite 数据库中，密码、SSH 密码、SSH 密钥密码等敏感字段会从普通连接配置中拆出，单独存放在 `connection_secrets` 表。
+- 配置导出支持 AES-GCM 加密，适合在多台设备之间迁移连接。
+- SSH 隧道可以连接私有网络或防火墙后的数据库。
+- AI Ask 模式不会执行生成的 SQL。Agent 和 MCP 流程会使用保守执行策略，并默认阻止危险 SQL。
+
+## 下一步
+
+<Cards>
+  <Card title="安装并创建连接" href="/cn/docs/getting-started">
+    从桌面应用或 Docker 版本开始，创建第一个数据库连接。
+  </Card>
+  <Card title="查看支持的数据库" href="/cn/docs/databases">
+    了解不同数据库引擎、兼容协议和 ODBC 场景的支持情况。
+  </Card>
+  <Card title="配置 AI 助手" href="/cn/docs/ai-assistant">
+    设置 API Key 后，在 SQL 编辑器中使用自然语言生成和解释查询。
+  </Card>
+</Cards>
diff --git a/docs/content/docs/what-is-dbx.mdx b/docs/content/docs/what-is-dbx.mdx
new file mode 100644
index 0000000..5fc6d1d
--- /dev/null
+++ b/docs/content/docs/what-is-dbx.mdx
@@ -0,0 +1,70 @@
+---
+title: What is DBX?
+description: DBX is an open-source database workspace for connections, SQL editing, data grids, schema tools, AI assistance, and self-hosted access.
+---
+
+DBX is an open-source database workspace. It brings the daily database workflow into one place: connecting to databases, writing SQL, browsing and editing data, exploring schemas, comparing structures, importing and exporting data, and using AI assistance when it helps.
+
+DBX is available as both a desktop app and a Docker deployment. Use the desktop app for local daily work, or self-host the Docker version when you want browser-based access from a server.
+
+![DBX Screenshot](/screenshot-dark.png)
+
+## Where DBX Fits
+
+<Cards>
+  <Card title="Daily Query Work" href="/en/docs/query-editor">
+    Write, format, and execute SQL, then use query history to return to previous investigation steps.
+  </Card>
+  <Card title="Browse and Edit Data" href="/en/docs/data-grid">
+    Filter, sort, edit, preview SQL, and decide when changes should be committed to the database.
+  </Card>
+  <Card title="Understand Schemas" href="/en/docs/schema-browser">
+    Browse databases, schemas, tables, columns, indexes, foreign keys, and triggers from the sidebar.
+  </Card>
+  <Card title="Compare Environments" href="/en/docs/schema-diff">
+    Compare dev, staging, and production schemas, then generate SQL you can review before syncing.
+  </Card>
+</Cards>
+
+## Core Capabilities
+
+| Capability           | Details                                                                                                                        |
+| -------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| Database connections | MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, ClickHouse, SQL Server, Oracle, and more                                    |
+| SQL editor           | CodeMirror 6, syntax highlighting, metadata completion, formatting, selected execution, and query history                      |
+| Data grid            | Virtual scrolling, inline editing, WHERE/ORDER BY controls, SQL preview, and export tools                                      |
+| Schema tools         | Schema browser, table structure editing, schema diff, ER diagrams, field lineage, database export, and SQL file execution      |
+| Data movement        | Table import, data transfer, SQL file execution, and SQL export with progress and cancellation where supported                 |
+| Specialized browsers | Redis key/value browsing and MongoDB document browsing                                                                         |
+| AI and automation    | Generate SQL, explain queries, suggest optimizations, help fix errors, and expose DBX connections to coding agents through MCP |
+| Self-hosted access   | Run DBX with Docker and access it from a browser                                                                               |
+
+## Product Principles
+
+DBX focuses on the core work of a database client instead of turning every operation into a separate tool. A few details shape the product:
+
+- **Less context switching**: schema browsing, SQL editing, data grids, and results stay close together.
+- **Reviewable operations**: data and schema changes show the SQL before they are applied where possible.
+- **Clear environment separation**: connection colors, pins, search, and context menus help separate dev, test, and production.
+- **Flexible deployment**: the desktop app fits personal workflows; the Docker version fits shared or server-hosted access.
+
+## Data and Security
+
+- Connection configuration is stored in a local SQLite database under the app data directory. Sensitive fields such as passwords, SSH passwords, SSH key passphrases, and connection strings are removed from the normal connection JSON and stored separately in the `connection_secrets` table.
+- Config export can be encrypted with AES-GCM for migration between machines.
+- SSH tunnels can connect to databases behind firewalls or private networks.
+- AI Ask mode does not execute generated SQL. Agent and MCP flows use conservative execution policies and block dangerous SQL by default.
+
+## Next Steps
+
+<Cards>
+  <Card title="Install and Connect" href="/en/docs/getting-started">
+    Start with the desktop app or Docker version, then create your first database connection.
+  </Card>
+  <Card title="Review Database Support" href="/en/docs/databases">
+    Check supported engines, compatible protocols, and ODBC-specific setup.
+  </Card>
+  <Card title="Set Up AI Assistant" href="/en/docs/ai-assistant">
+    Add an API key and use natural language in the SQL editor.
+  </Card>
+</Cards>
diff --git a/docs/lib/agentRegistry.test.ts b/docs/lib/agentRegistry.test.ts
new file mode 100644
index 0000000..ec6b4cf
--- /dev/null
+++ b/docs/lib/agentRegistry.test.ts
@@ -0,0 +1,13 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { buildAgentDownloadCatalog } from "./agentRegistry";
+
+test("offline download catalog includes the JDBC plugin ZIP", () => {
+  const catalog = buildAgentDownloadCatalog([]);
+
+  assert.deepEqual(catalog.jdbcPlugin, {
+    label: "DBX JDBC Plugin",
+    filename: "dbx-jdbc-plugin-latest.zip",
+    url: "https://dl.dbxio.com/releases/latest/dbx-jdbc-plugin-latest.zip",
+  });
+});
diff --git a/docs/lib/agentRegistry.ts b/docs/lib/agentRegistry.ts
new file mode 100644
index 0000000..223d526
--- /dev/null
+++ b/docs/lib/agentRegistry.ts
@@ -0,0 +1,268 @@
+import driverVersions from "../../agents/versions.json";
+
+export interface ArtifactInfo {
+  url: string;
+  size: number;
+}
+
+export interface GitHubReleaseAsset {
+  name: string;
+  size: number;
+  browser_download_url: string;
+}
+
+interface GitHubRelease {
+  assets?: GitHubReleaseAsset[];
+}
+
+export interface OfflineBundleEntry {
+  platformKey: string;
+  platformLabel: string;
+  filename: string;
+  size: number;
+  url: string;
+}
+
+export interface JreDisplayEntry {
+  platformKey: string;
+  platformLabel: string;
+  info: ArtifactInfo;
+  jreVersion: string;
+  jreKey: string;
+}
+
+export interface DriverDisplayEntry {
+  key: string;
+  label: string;
+  version: string;
+  minAppVersion: string;
+  jar: ArtifactInfo;
+  jre: string;
+}
+
+export interface NativeAgentDisplayEntry {
+  key: string;
+  label: string;
+  version: string;
+  platformKey: string;
+  platformLabel: string;
+  filename: string;
+  info: ArtifactInfo;
+}
+
+export interface JdbcPluginDownloadEntry {
+  label: string;
+  filename: string;
+  url: string;
+}
+
+export interface AgentDownloadCatalog {
+  jdbcPlugin: JdbcPluginDownloadEntry;
+  bundles: OfflineBundleEntry[];
+  drivers: DriverDisplayEntry[];
+  jres: JreDisplayEntry[];
+  nativeAgents: NativeAgentDisplayEntry[];
+}
+
+const AGENTS_LATEST_RELEASE_API_URL = "https://api.github.com/repos/t8y2/dbx/releases/tags/agents-latest";
+const JDBC_PLUGIN_DOWNLOAD_URL = "https://dl.dbxio.com/releases/latest/dbx-jdbc-plugin-latest.zip";
+const MIN_APP_VERSION = "0.6.0";
+const driverVersionMap = driverVersions as Record<string, string>;
+const nativeDriverKeys = new Set(["oracle", "xugu"]);
+
+const platformLabels: Record<string, string> = {
+  "macos-aarch64": "macOS (Apple Silicon)",
+  "macos-x64": "macOS (Intel)",
+  "linux-aarch64": "Linux (ARM64)",
+  "linux-x64": "Linux (x64)",
+  "windows-aarch64": "Windows (ARM64)",
+  "windows-x64": "Windows (x64)",
+};
+
+const driverLabels: Record<string, string> = {
+  access: "Microsoft Access",
+  bigquery: "BigQuery",
+  cassandra: "Cassandra",
+  dameng: "Dameng",
+  databend: "Databend",
+  databricks: "Databricks",
+  db2: "DB2",
+  etcd: "etcd",
+  exasol: "Exasol",
+  firebird: "Firebird",
+  gbase8a: "GBase 8a",
+  gbase8s: "GBase 8s",
+  goldendb: "GoldenDB",
+  h2: "H2",
+  highgo: "HighGo",
+  hive: "Hive",
+  informix: "Informix",
+  iotdb: "Apache IoTDB",
+  iris: "InterSystems IRIS",
+  kingbase: "KingBase",
+  kylin: "Apache Kylin",
+  mongodb: "MongoDB (Legacy)",
+  neo4j: "Neo4j",
+  "oceanbase-oracle": "OceanBase Oracle Mode",
+  oracle: "Oracle",
+  saphana: "SAP HANA",
+  snowflake: "Snowflake",
+  sundb: "SunDB",
+  tdengine: "TDengine",
+  teradata: "Teradata",
+  trino: "Trino",
+  vastbase: "Vastbase",
+  vertica: "Vertica",
+  xugu: "虚谷 XuguDB",
+  yashandb: "YashanDB",
+  zookeeper: "ZooKeeper",
+};
+
+const currentDriverKeys = Object.keys(driverVersionMap).sort((a, b) => labelForDriver(a).localeCompare(labelForDriver(b)));
+const currentJavaDriverKeys = currentDriverKeys.filter((key) => !nativeDriverKeys.has(key));
+
+const jreVersions: Record<string, string> = {
+  "21": "21",
+};
+
+function labelForDriver(key: string): string {
+  return driverLabels[key] ?? key.replace(/-/g, " ");
+}
+
+function assetInfo(asset: GitHubReleaseAsset): ArtifactInfo {
+  return {
+    url: asset.browser_download_url,
+    size: asset.size,
+  };
+}
+
+function assetMap(assets: GitHubReleaseAsset[]): Map<string, GitHubReleaseAsset> {
+  return new Map(assets.map((asset) => [asset.name, asset]));
+}
+
+export async function fetchAgentDownloadCatalog(): Promise<AgentDownloadCatalog | null> {
+  try {
+    const res = await fetch(AGENTS_LATEST_RELEASE_API_URL, {
+      cache: "no-store",
+      headers: { Accept: "application/vnd.github+json" },
+    });
+    if (!res.ok) return null;
+
+    const release = (await res.json()) as GitHubRelease;
+    return buildAgentDownloadCatalog(release.assets ?? []);
+  } catch {
+    return null;
+  }
+}
+
+export function buildAgentDownloadCatalog(assets: GitHubReleaseAsset[]): AgentDownloadCatalog {
+  return {
+    jdbcPlugin: buildJdbcPluginDownloadEntry(),
+    bundles: buildOfflineBundleEntries(assets),
+    drivers: buildDriverEntries(assets),
+    jres: buildJreEntries(assets),
+    nativeAgents: buildNativeAgentEntries(assets),
+  };
+}
+
+export function buildJdbcPluginDownloadEntry(): JdbcPluginDownloadEntry {
+  return {
+    label: "DBX JDBC Plugin",
+    filename: "dbx-jdbc-plugin-latest.zip",
+    url: JDBC_PLUGIN_DOWNLOAD_URL,
+  };
+}
+
+export function buildJreEntries(assets: GitHubReleaseAsset[]): JreDisplayEntry[] {
+  return assets
+    .map((asset) => {
+      const match = /^dbx-jre-(\d+)-(.+)\.tar\.gz$/.exec(asset.name);
+      if (!match) return null;
+
+      const [, jreKey, platformKey] = match;
+      if (!jreVersions[jreKey]) return null;
+
+      return {
+        platformKey,
+        platformLabel: platformLabels[platformKey] ?? platformKey,
+        info: assetInfo(asset),
+        jreVersion: jreVersions[jreKey],
+        jreKey,
+      };
+    })
+    .filter((entry): entry is JreDisplayEntry => entry !== null)
+    .sort((a, b) => a.platformLabel.localeCompare(b.platformLabel));
+}
+
+export function buildDriverEntries(assets: GitHubReleaseAsset[]): DriverDisplayEntry[] {
+  const byName = assetMap(assets);
+
+  return currentJavaDriverKeys
+    .map((key) => {
+      const asset = byName.get(`dbx-agent-${key}.jar`);
+      if (!asset) return null;
+
+      return {
+        key,
+        label: labelForDriver(key),
+        version: driverVersionMap[key] ?? "",
+        minAppVersion: MIN_APP_VERSION,
+        jar: assetInfo(asset),
+        jre: "21",
+      };
+    })
+    .filter((entry): entry is DriverDisplayEntry => entry !== null);
+}
+
+export function buildNativeAgentEntries(assets: GitHubReleaseAsset[]): NativeAgentDisplayEntry[] {
+  const entries: NativeAgentDisplayEntry[] = [];
+
+  for (const asset of assets) {
+    const match = /^dbx-agent-(oracle|xugu)-(.+?)(?:\.exe)?$/.exec(asset.name);
+    if (!match) continue;
+
+    const [, key, platformKey] = match;
+    entries.push({
+      key,
+      label: labelForDriver(key),
+      version: driverVersionMap[key] ?? "",
+      platformKey,
+      platformLabel: platformLabels[platformKey] ?? platformKey,
+      filename: asset.name,
+      info: assetInfo(asset),
+    });
+  }
+
+  return entries.sort((a, b) => a.label.localeCompare(b.label) || a.platformLabel.localeCompare(b.platformLabel));
+}
+
+export function buildOfflineBundleEntries(assets: GitHubReleaseAsset[]): OfflineBundleEntry[] {
+  return assets
+    .map((asset) => {
+      const match = /^dbx-agents-offline-(.+)\.zip$/.exec(asset.name);
+      if (!match) return null;
+      const platformKey = match[1];
+      return {
+        platformKey,
+        platformLabel: platformLabels[platformKey] ?? platformKey,
+        filename: asset.name,
+        size: asset.size,
+        url: asset.browser_download_url,
+      };
+    })
+    .filter((entry): entry is OfflineBundleEntry => entry !== null)
+    .sort((a, b) => a.platformLabel.localeCompare(b.platformLabel));
+}
+
+export function formatSize(bytes: number): string {
+  if (bytes >= 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+  }
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${bytes} B`;
+}
diff --git a/docs/lib/appVersion.ts b/docs/lib/appVersion.ts
new file mode 100644
index 0000000..ed5667e
--- /dev/null
+++ b/docs/lib/appVersion.ts
@@ -0,0 +1,5 @@
+import appPackage from "../../package.json";
+
+export function getAppVersion() {
+  return appPackage.version;
+}
diff --git a/docs/lib/changelog.ts b/docs/lib/changelog.ts
new file mode 100644
index 0000000..da67b1c
--- /dev/null
+++ b/docs/lib/changelog.ts
@@ -0,0 +1,133 @@
+import { requestJson } from "@/lib/httpJson";
+
+export type ChangelogItem = {
+  title: string;
+  desc: string;
+};
+
+export type ChangelogSection = {
+  type: string;
+  title: string;
+  items: ChangelogItem[];
+};
+
+export type ChangelogRelease = {
+  tag: string;
+  name: string;
+  date: string;
+  sections: ChangelogSection[];
+};
+
+export type ChangelogData = {
+  updatedAt: string;
+  releases: ChangelogRelease[];
+};
+
+type GitHubRelease = {
+  tag_name: string;
+  name: string | null;
+  published_at: string | null;
+  body: string | null;
+  draft: boolean;
+  prerelease: boolean;
+};
+
+const DEFAULT_BASE_URL = "https://dl.dbxio.com/changelog";
+const GITHUB_RELEASES_URL = "https://api.github.com/repos/t8y2/dbx/releases?per_page=30";
+
+const SECTION_MAP: Record<string, string> = {
+  新功能: "added",
+  Added: "added",
+  改进: "improved",
+  Improved: "improved",
+  修复: "fixed",
+  Fixed: "fixed",
+  变更: "changed",
+  Changed: "changed",
+  移除: "removed",
+  Removed: "removed",
+};
+
+export function changelogUrl(lang: "en" | "cn") {
+  const baseUrl = (typeof process !== "undefined" && (process.env.NEXT_PUBLIC_CHANGELOG_BASE_URL || process.env.CHANGELOG_BASE_URL)) || DEFAULT_BASE_URL;
+
+  return `${baseUrl}/releases-${lang}.json`;
+}
+
+export async function fetchChangelog(lang: "en" | "cn"): Promise<ChangelogData> {
+  // 浏览器端同样优先走 R2 的翻译版 JSON（英文版由 sync-changelog 翻译生成）；
+  // 之前客户端直接 fallback 到 GitHub 原文（中文），会导致英文页面 hydrate 后被中文覆盖。
+  const url = changelogUrl(lang);
+
+  try {
+    return await requestJson<ChangelogData>(url);
+  } catch {
+    return fetchGitHubChangelog();
+  }
+}
+
+function stripDownloadSection(body: string) {
+  const markers = ["### 下载安装", "### Download", "### 系统要求", "### System Requirements"];
+  let idx = body.length;
+
+  for (const marker of markers) {
+    const markerIndex = body.indexOf(marker);
+    if (markerIndex !== -1 && markerIndex < idx) {
+      idx = markerIndex;
+    }
+  }
+
+  return body.slice(0, idx).trim();
+}
+
+function parseReleaseBody(body: string) {
+  const sections: ChangelogSection[] = [];
+  let current: ChangelogSection | null = null;
+
+  for (const line of stripDownloadSection(body).split("\n")) {
+    const headerMatch = line.match(/^###\s+(.+)/);
+    if (headerMatch) {
+      const title = headerMatch[1].trim();
+      current = { type: SECTION_MAP[title] || "other", title, items: [] };
+      sections.push(current);
+      continue;
+    }
+
+    if (!current) continue;
+
+    const itemMatch = line.match(/^-\s+\*\*(.+?)\*\*\s*[—–-]\s*(.+)/);
+    if (itemMatch) {
+      current.items.push({ title: itemMatch[1].trim(), desc: itemMatch[2].trim() });
+      continue;
+    }
+
+    const plainMatch = line.match(/^-\s+(.+)/);
+    if (plainMatch) {
+      current.items.push({ title: plainMatch[1].trim(), desc: "" });
+    }
+  }
+
+  return sections.filter((section) => section.items.length > 0);
+}
+
+export async function fetchGitHubChangelog(): Promise<ChangelogData> {
+  try {
+    const releases = await requestJson<GitHubRelease[]>(GITHUB_RELEASES_URL, {
+      headers: { Accept: "application/vnd.github+json" },
+    });
+
+    return {
+      updatedAt: new Date().toISOString(),
+      releases: releases
+        .filter((release) => !release.draft && !release.prerelease && !release.tag_name.startsWith("agents-"))
+        .map((release) => ({
+          tag: release.tag_name,
+          name: release.name || release.tag_name,
+          date: (release.published_at || "").slice(0, 10),
+          sections: parseReleaseBody(release.body || ""),
+        })),
+    };
+  } catch {
+    return { updatedAt: "", releases: [] };
+  }
+}
diff --git a/docs/lib/cjkSearchTokenizer.ts b/docs/lib/cjkSearchTokenizer.ts
new file mode 100644
index 0000000..ec2b185
--- /dev/null
+++ b/docs/lib/cjkSearchTokenizer.ts
@@ -0,0 +1,41 @@
+const asciiTokenPattern = /[a-z0-9_'-]+/gi;
+const hanTokenPattern = /[\u3400-\u9fff]+/g;
+
+function unique(tokens: string[]) {
+  return Array.from(new Set(tokens.filter(Boolean)));
+}
+
+function tokenizeCjkText(input: string) {
+  const source = input.toLowerCase();
+  const tokens: string[] = [];
+
+  for (const match of source.matchAll(asciiTokenPattern)) {
+    tokens.push(match[0]);
+  }
+
+  for (const match of source.matchAll(hanTokenPattern)) {
+    const text = match[0];
+    tokens.push(text);
+
+    for (const char of text) {
+      tokens.push(char);
+    }
+
+    for (let index = 0; index < text.length - 1; index += 1) {
+      tokens.push(text.slice(index, index + 2));
+    }
+  }
+
+  return unique(tokens);
+}
+
+export function createCjkSearchTokenizer() {
+  return {
+    language: "cjk",
+    normalizationCache: new Map<string, string>(),
+    tokenize(raw: string) {
+      if (typeof raw !== "string") return [raw];
+      return tokenizeCjkText(raw);
+    },
+  };
+}
diff --git a/docs/lib/contributors.ts b/docs/lib/contributors.ts
new file mode 100644
index 0000000..80e65e2
--- /dev/null
+++ b/docs/lib/contributors.ts
@@ -0,0 +1,88 @@
+export type Contributor = {
+  login: string;
+  avatar_url: string;
+  html_url: string;
+  contributions: number;
+  type?: string;
+};
+
+const GITHUB_CONTRIBUTORS_API = "https://api.github.com/repos/t8y2/dbx/contributors";
+
+function parseNextLink(linkHeader: string): string | null {
+  const parts = linkHeader.split(",");
+  for (const part of parts) {
+    const [url, rel] = part.split(";").map((s) => s.trim());
+    if (rel === 'rel="next"') {
+      return url.slice(1, -1); // strip < >
+    }
+  }
+  return null;
+}
+
+async function fetchPage(url: string, token?: string): Promise<{ data: Contributor[]; next: string | null }> {
+  const headers: Record<string, string> = {
+    Accept: "application/vnd.github+json",
+  };
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+
+  const response = await fetch(url, {
+    headers,
+    next: { revalidate: 60 * 60 * 6 },
+  });
+
+  if (!response.ok) return { data: [], next: null };
+
+  const data = (await response.json()) as Contributor[];
+  if (!Array.isArray(data)) return { data: [], next: null };
+
+  const linkHeader = response.headers.get("Link");
+  const next = linkHeader ? parseNextLink(linkHeader) : null;
+
+  return { data, next };
+}
+
+function fallbackContributors(): Contributor[] {
+  return [
+    { login: "t8y2", avatar_url: "https://avatars.githubusercontent.com/u/77960507", html_url: "https://github.com/t8y2", contributions: 1601 },
+    { login: "Illuminated2020", avatar_url: "https://avatars.githubusercontent.com/u/53017147", html_url: "https://github.com/Illuminated2020", contributions: 40 },
+    { login: "rarnu", avatar_url: "https://avatars.githubusercontent.com/u/28835581", html_url: "https://github.com/rarnu", contributions: 23 },
+    { login: "SuLea-IT", avatar_url: "https://avatars.githubusercontent.com/u/105108570", html_url: "https://github.com/SuLea-IT", contributions: 22 },
+    { login: "serenez", avatar_url: "https://github.com/serenez.png", html_url: "https://github.com/serenez", contributions: 22 },
+    { login: "yavon007", avatar_url: "https://avatars.githubusercontent.com/u/61088461", html_url: "https://github.com/yavon007", contributions: 18 },
+    { login: "Bacon2994", avatar_url: "https://avatars.githubusercontent.com/u/108093786", html_url: "https://github.com/Bacon2994", contributions: 11 },
+    { login: "Abeautifulsnow", avatar_url: "https://avatars.githubusercontent.com/u/115250255", html_url: "https://github.com/Abeautifulsnow", contributions: 9 },
+    { login: "CN-Scars", avatar_url: "https://avatars.githubusercontent.com/u/100192060", html_url: "https://github.com/CN-Scars", contributions: 8 },
+    { login: "DengQingNian", avatar_url: "https://avatars.githubusercontent.com/u/117324885", html_url: "https://github.com/DengQingNian", contributions: 7 },
+    { login: "xKrah", avatar_url: "https://avatars.githubusercontent.com/u/120772591", html_url: "https://github.com/xKrah", contributions: 7 },
+    { login: "agent-43", avatar_url: "https://avatars.githubusercontent.com/u/188405022", html_url: "https://github.com/agent-43", contributions: 6 },
+    { login: "eryajf", avatar_url: "https://avatars.githubusercontent.com/u/33259379", html_url: "https://github.com/eryajf", contributions: 5 },
+    { login: "wu-clan", avatar_url: "https://avatars.githubusercontent.com/u/114193468", html_url: "https://github.com/wu-clan", contributions: 4 },
+    { login: "fraluc06", avatar_url: "https://avatars.githubusercontent.com/u/67560467", html_url: "https://github.com/fraluc06", contributions: 4 },
+    { login: "Caisin", avatar_url: "https://avatars.githubusercontent.com/u/62819122", html_url: "https://github.com/Caisin", contributions: 3 },
+    { login: "wds824", avatar_url: "https://avatars.githubusercontent.com/u/93659702", html_url: "https://github.com/wds824", contributions: 3 },
+  ];
+}
+
+export async function fetchContributors(): Promise<Contributor[]> {
+  const token = process.env.GITHUB_TOKEN;
+  const firstPage = `${GITHUB_CONTRIBUTORS_API}?per_page=100`;
+
+  try {
+    const allContributors: Contributor[] = [];
+    let url: string | null = firstPage;
+
+    while (url) {
+      const { data, next } = await fetchPage(url, token);
+      allContributors.push(...data);
+      url = next;
+    }
+
+    if (allContributors.length === 0) return fallbackContributors();
+
+    return allContributors.filter((c) => c.login && c.avatar_url && c.type !== "Bot");
+  } catch {
+    return fallbackContributors();
+  }
+}
diff --git a/docs/lib/downloadLinks.ts b/docs/lib/downloadLinks.ts
new file mode 100644
index 0000000..fd43dff
--- /dev/null
+++ b/docs/lib/downloadLinks.ts
@@ -0,0 +1,51 @@
+export type InstallLang = "en" | "cn";
+
+export type InstallOption = {
+  id: string;
+  label: string;
+  href: string;
+};
+
+type DownloadArtifact = {
+  id: string;
+  labels: Record<InstallLang, string>;
+  suffix: string;
+};
+
+const DOWNLOAD_BASE_URL = "https://dl.dbxio.com/releases/latest";
+
+const downloadArtifacts: DownloadArtifact[] = [
+  {
+    id: "macos-arm",
+    labels: { en: "For macOS (Apple Silicon)", cn: "适用于 macOS (Apple Silicon)" },
+    suffix: "aarch64.dmg",
+  },
+  {
+    id: "macos-intel",
+    labels: { en: "For macOS (Intel)", cn: "适用于 macOS (Intel)" },
+    suffix: "x64.dmg",
+  },
+  {
+    id: "windows",
+    labels: { en: "For Windows", cn: "适用于 Windows" },
+    suffix: "x64-setup.exe",
+  },
+  {
+    id: "linux",
+    labels: { en: "For Linux x64", cn: "适用于 Linux x64" },
+    suffix: "amd64.AppImage",
+  },
+  {
+    id: "linux-arm",
+    labels: { en: "For Linux ARM64", cn: "适用于 Linux ARM64" },
+    suffix: "aarch64.AppImage",
+  },
+];
+
+export function createInstallOptions(lang: InstallLang, version: string): InstallOption[] {
+  return downloadArtifacts.map((artifact) => ({
+    id: artifact.id,
+    label: artifact.labels[lang],
+    href: `${DOWNLOAD_BASE_URL}/DBX_${version}_${artifact.suffix}?v=${version}`,
+  }));
+}
diff --git a/docs/lib/httpJson.ts b/docs/lib/httpJson.ts
new file mode 100644
index 0000000..3fff325
--- /dev/null
+++ b/docs/lib/httpJson.ts
@@ -0,0 +1,34 @@
+function requestJsonWithXhr<T>(url: string): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("GET", url, true);
+    xhr.responseType = "json";
+    xhr.setRequestHeader("Accept", "application/json");
+    xhr.onload = () => {
+      if (xhr.status < 200 || xhr.status >= 300) {
+        reject(new Error(`Request failed with status ${xhr.status}`));
+        return;
+      }
+
+      resolve((xhr.response ?? JSON.parse(xhr.responseText)) as T);
+    };
+    xhr.onerror = () => reject(new Error("Request failed"));
+    xhr.send();
+  });
+}
+
+export async function requestJson<T>(url: string, init?: RequestInit): Promise<T> {
+  if (typeof fetch === "function") {
+    const res = await fetch(url, init);
+    if (!res.ok) {
+      throw new Error(`Request failed with status ${res.status}`);
+    }
+    return res.json() as Promise<T>;
+  }
+
+  if (typeof XMLHttpRequest === "function") {
+    return requestJsonWithXhr<T>(url);
+  }
+
+  throw new Error("No browser request API is available");
+}
diff --git a/docs/lib/i18n.ts b/docs/lib/i18n.ts
new file mode 100644
index 0000000..66151c0
--- /dev/null
+++ b/docs/lib/i18n.ts
@@ -0,0 +1,24 @@
+import { defineI18n } from "fumadocs-core/i18n";
+import { defineI18nUI } from "fumadocs-ui/i18n";
+
+export const i18n = defineI18n({
+  defaultLanguage: "en",
+  languages: ["en", "cn"],
+});
+
+export const i18nUI = defineI18nUI(i18n, {
+  en: { displayName: "English" },
+  cn: {
+    displayName: "简体中文",
+    search: "搜索",
+    searchNoResult: "没有找到结果",
+    toc: "本页目录",
+    tocNoHeadings: "没有目录",
+    lastUpdate: "最后更新",
+    chooseLanguage: "选择语言",
+    nextPage: "下一页",
+    previousPage: "上一页",
+    chooseTheme: "选择主题",
+    editOnGithub: "在 GitHub 上编辑",
+  },
+});
diff --git a/docs/lib/landingLatest.ts b/docs/lib/landingLatest.ts
new file mode 100644
index 0000000..c1313ee
--- /dev/null
+++ b/docs/lib/landingLatest.ts
@@ -0,0 +1,48 @@
+import type { ChangelogRelease } from "@/lib/changelog";
+import type { LatestReleaseInfo } from "@/lib/latestRelease";
+
+type LandingLatestUpdates = {
+  version: string;
+  title: string;
+  desc: string;
+  link: string;
+  items: string[];
+};
+
+const text = {
+  en: {
+    title: "Latest updates",
+    desc: "Mirrored from the latest GitHub release notes.",
+    link: "Read the changelog",
+    fallbackItems: ["Desktop and Docker release assets", "Database workflow improvements", "Bug fixes and reliability updates", "Documentation and packaging updates"],
+  },
+  cn: {
+    title: "最近更新",
+    desc: "同步 GitHub 最新 Release Notes。",
+    link: "查看更新日志",
+    fallbackItems: ["桌面版与 Docker 发布资产", "数据库工作流改进", "问题修复与稳定性更新", "文档与打包流程更新"],
+  },
+};
+
+function releaseItems(release: ChangelogRelease, lang: "en" | "cn") {
+  const separator = lang === "cn" ? "，" : ": ";
+
+  return release.sections
+    .flatMap((section) => section.items)
+    .map((item) => (item.desc ? `${item.title}${separator}${item.desc}` : item.title))
+    .slice(0, 4);
+}
+
+export function buildLandingLatestUpdates(lang: "en" | "cn", release: ChangelogRelease | undefined, appVersion: string, latestRelease?: LatestReleaseInfo | null): LandingLatestUpdates {
+  const t = text[lang];
+  const items = release ? releaseItems(release, lang) : [];
+  const version = latestRelease?.version ? `v${latestRelease.version}` : (release?.tag ?? `v${appVersion}`);
+
+  return {
+    version,
+    title: t.title,
+    desc: t.desc,
+    link: t.link,
+    items: items.length > 0 ? items : t.fallbackItems,
+  };
+}
diff --git a/docs/lib/latestRelease.ts b/docs/lib/latestRelease.ts
new file mode 100644
index 0000000..e0c1767
--- /dev/null
+++ b/docs/lib/latestRelease.ts
@@ -0,0 +1,48 @@
+import { requestJson } from "@/lib/httpJson";
+import { browserCacheBuster, createUncachedUrl, releaseMetadataRequestInit } from "@/lib/releaseMetadataRequest";
+
+export type LatestReleaseInfo = {
+  version: string;
+  notes?: string;
+  pub_date?: string;
+};
+
+type GitHubLatestRelease = {
+  tag_name: string;
+  body: string | null;
+  published_at: string | null;
+};
+
+const LATEST_RELEASE_URL = "https://dl.dbxio.com/releases/latest/latest.json";
+const GITHUB_LATEST_RELEASE_URL = "https://api.github.com/repos/t8y2/dbx/releases/latest";
+
+function normalizeVersion(version: string) {
+  return version.replace(/^v/, "");
+}
+
+export async function fetchLatestReleaseInfo(): Promise<LatestReleaseInfo | null> {
+  if (typeof window !== "undefined") {
+    return fetchGitHubLatestReleaseInfo();
+  }
+
+  try {
+    const release = await requestJson<LatestReleaseInfo>(createUncachedUrl(LATEST_RELEASE_URL, browserCacheBuster()), releaseMetadataRequestInit());
+    return release.version ? { ...release, version: normalizeVersion(release.version) } : null;
+  } catch {
+    return fetchGitHubLatestReleaseInfo();
+  }
+}
+
+export async function fetchGitHubLatestReleaseInfo(): Promise<LatestReleaseInfo | null> {
+  try {
+    const release = await requestJson<GitHubLatestRelease>(createUncachedUrl(GITHUB_LATEST_RELEASE_URL, browserCacheBuster()), releaseMetadataRequestInit({ headers: { Accept: "application/vnd.github+json" } }));
+
+    return {
+      version: normalizeVersion(release.tag_name),
+      notes: release.body || undefined,
+      pub_date: release.published_at || undefined,
+    };
+  } catch {
+    return null;
+  }
+}
diff --git a/docs/lib/metadata.ts b/docs/lib/metadata.ts
new file mode 100644
index 0000000..5441955
--- /dev/null
+++ b/docs/lib/metadata.ts
@@ -0,0 +1,89 @@
+import type { Metadata } from "next";
+
+export const SITE_URL = "https://dbxio.com";
+export const SITE_NAME = "DBX";
+export const DEFAULT_DESCRIPTION = "60+ databases in 20 MB. Desktop & Docker self-hosting, with built-in AI assistant.";
+export const DEFAULT_OG_IMAGE = "/logo.png";
+
+const LOCALE_MAP: Record<string, string> = {
+  en: "en_US",
+  cn: "zh_CN",
+};
+
+const HTML_LANG_MAP: Record<string, string> = {
+  en: "en",
+  cn: "zh-CN",
+};
+
+export function getHtmlLang(lang: string): string {
+  return HTML_LANG_MAP[lang] ?? "en";
+}
+
+function swapLang(path: string, to: string): string {
+  return path.replace(/^\/(en|cn)/, `/${to}`);
+}
+
+interface BuildMetadataParams {
+  title: string;
+  description: string;
+  path: string;
+  lang: string;
+  ogType?: "website" | "article";
+  images?: string[];
+  lastModified?: Date;
+}
+
+export function buildMetadata({
+  title,
+  description,
+  path,
+  lang,
+  ogType = "website",
+  images,
+  lastModified,
+}: BuildMetadataParams): Metadata {
+  const canonical = `${SITE_URL}${path}`;
+  const locale = LOCALE_MAP[lang] ?? "en_US";
+  const ogImages = images?.map((url) => ({
+    url,
+    width: url === DEFAULT_OG_IMAGE ? 512 : 1200,
+    height: url === DEFAULT_OG_IMAGE ? 512 : 630,
+  })) ?? [{ url: DEFAULT_OG_IMAGE, width: 512, height: 512 }];
+
+  const base: Metadata = {
+    title,
+    description,
+    alternates: {
+      canonical,
+      languages: {
+        en: `${SITE_URL}${swapLang(path, "en")}`,
+        zh: `${SITE_URL}${swapLang(path, "cn")}`,
+        "x-default": `${SITE_URL}${swapLang(path, "en")}`,
+      },
+    },
+    openGraph: {
+      title,
+      description,
+      url: canonical,
+      siteName: SITE_NAME,
+      type: ogType,
+      locale,
+      images: ogImages,
+    },
+    twitter: {
+      card: "summary_large_image",
+      title,
+      description,
+      images: images ?? [DEFAULT_OG_IMAGE],
+    },
+    other: {
+      "og:image:alt": title,
+    },
+  };
+
+  if (lastModified) {
+    base.other = { ...base.other, "article:modified_time": lastModified.toISOString() };
+  }
+
+  return base;
+}
diff --git a/docs/lib/releaseMetadataRequest.test.ts b/docs/lib/releaseMetadataRequest.test.ts
new file mode 100644
index 0000000..8af7f51
--- /dev/null
+++ b/docs/lib/releaseMetadataRequest.test.ts
@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { createUncachedUrl, releaseMetadataRequestInit } from "./releaseMetadataRequest";
+
+test("createUncachedUrl appends cache buster without removing existing query params", () => {
+  assert.equal(createUncachedUrl("https://dl.dbxio.com/releases/latest/latest.json?lang=cn", 123), "https://dl.dbxio.com/releases/latest/latest.json?lang=cn&_ts=123");
+});
+
+test("createUncachedUrl leaves server-side build URLs stable without a cache buster", () => {
+  assert.equal(createUncachedUrl("https://dl.dbxio.com/releases/latest/latest.json"), "https://dl.dbxio.com/releases/latest/latest.json");
+});
+
+test("releaseMetadataRequestInit disables fetch cache and preserves custom headers", () => {
+  assert.deepEqual(releaseMetadataRequestInit({ headers: { Authorization: "token example" } }), {
+    cache: "no-store",
+    headers: {
+      Accept: "application/json",
+      Authorization: "token example",
+    },
+  });
+});
diff --git a/docs/lib/releaseMetadataRequest.ts b/docs/lib/releaseMetadataRequest.ts
new file mode 100644
index 0000000..ecc2741
--- /dev/null
+++ b/docs/lib/releaseMetadataRequest.ts
@@ -0,0 +1,22 @@
+export function createUncachedUrl(url: string, cacheBuster?: string | number) {
+  if (cacheBuster === undefined) return url;
+
+  const nextUrl = new URL(url);
+  nextUrl.searchParams.set("_ts", String(cacheBuster));
+  return nextUrl.toString();
+}
+
+export function browserCacheBuster() {
+  return typeof window === "undefined" ? undefined : Date.now();
+}
+
+export function releaseMetadataRequestInit(init: RequestInit = {}): RequestInit {
+  return {
+    ...init,
+    cache: "no-store",
+    headers: {
+      Accept: "application/json",
+      ...init.headers,
+    },
+  };
+}
diff --git a/docs/lib/source.ts b/docs/lib/source.ts
new file mode 100644
index 0000000..c0f7e27
--- /dev/null
+++ b/docs/lib/source.ts
@@ -0,0 +1,64 @@
+import { loader } from "fumadocs-core/source";
+import { icons } from "lucide-react";
+import { createElement } from "react";
+import { i18n } from "@/lib/i18n";
+import { docs } from "@/.source/server";
+
+const pageIcons: Record<string, keyof typeof icons> = {
+  "what-is-dbx": "BookOpen",
+  changelog: "History",
+  "getting-started": "Rocket",
+  databases: "Database",
+  "query-editor": "SquareTerminal",
+  "data-grid": "Table2",
+  "schema-browser": "Network",
+  redis: "KeyRound",
+  mongodb: "Braces",
+  "object-browser": "Package",
+  "schema-diff": "GitCompareArrows",
+  "data-transfer": "ArrowRightLeft",
+  "table-structure": "TableProperties",
+  "field-lineage": "GitBranch",
+  "table-import": "Upload",
+  "sql-file": "FileCode2",
+  "database-export": "Download",
+  "sql-snippets": "ScrollText",
+  "ai-assistant": "Bot",
+  cli: "Terminal",
+  mcp: "Cable",
+  plugins: "Plug",
+  "driver-management": "Package",
+  "keyboard-shortcuts": "Keyboard",
+  "connection-import": "Import",
+  "config-export": "FileUp",
+  "ssh-tunnel": "ShieldCheck",
+};
+
+export const source = loader({
+  baseUrl: "/docs",
+  source: docs.toFumadocsSource(),
+  i18n,
+  plugins: [
+    {
+      name: "dbx-sidebar-icons",
+      transformPageTree: {
+        file(node) {
+          const slug = node.url.split("/").filter(Boolean).at(-1);
+          const iconName = slug ? pageIcons[slug] : undefined;
+          const Icon = iconName ? icons[iconName] : undefined;
+
+          if (!Icon) return node;
+
+          return {
+            ...node,
+            icon: createElement(Icon, {
+              "aria-hidden": true,
+              className: "size-4",
+              strokeWidth: 2,
+            }),
+          };
+        },
+      },
+    },
+  ],
+});
diff --git a/docs/logo.png b/docs/logo.png
new file mode 100644
index 0000000..6150857
Binary files /dev/null and b/docs/logo.png differ
diff --git a/docs/mq-quick-start.md b/docs/mq-quick-start.md
new file mode 100644
index 0000000..3d4897c
--- /dev/null
+++ b/docs/mq-quick-start.md
@@ -0,0 +1,443 @@
+# 消息队列管理功能 - 快速开始
+
+## 概述
+
+该功能为 DBX 增加了消息队列（Message Queue）管理能力，首批支持 **Apache Pulsar** 的管理操作。架构保留 Kafka、RocketMQ 扩展点，但在适配器完成前 UI 只允许创建 Pulsar 连接。
+
+## 功能特性
+
+### 已实现（Pulsar 首期核心）
+- ✅ **租户管理**：创建、删除、查询、更新租户信息
+- ✅ **命名空间管理**：创建、删除、查询命名空间，配置策略
+- ✅ **主题管理**：创建普通/分区主题，删除、查询统计信息
+- ✅ **订阅管理**：创建、删除订阅，重置游标，清理积压，跳过消息
+- ✅ **生产者/消费者监控**：查看活跃的生产者和消费者
+- ✅ **策略配置**：发布速率、分发速率、订阅速率、积压配额、保留策略
+- ✅ **权限管理**：授予/撤销角色权限
+- ✅ **监控统计**：消息速率、吞吐量、积压大小
+- ✅ **Raw Admin API**：直接发送自定义管理请求（逃生通道）
+
+### 前端 UI（Pulsar 首期核心可用）
+- ✅ 连接配置、控制台入口、租户/命名空间/主题/订阅/监控/生产者消费者/策略/权限/Raw API 面板
+- ⚠️ 后续扩展：完整 i18n、Kafka/RocketMQ 适配器、高级 typed policy（最大生产者/消费者数、TTL、deduplication）
+
+## 架构设计
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                         前端 (Vue)                           │
+│  ┌─────────────┐  ┌──────────────┐  ┌──────────────────┐   │
+│  │ MqAdminConsole │  │ TenantsPanel │  │ TopicsPanel      │   │
+│  └─────────────┘  └──────────────┘  └──────────────────┘   │
+│           ▼ mq-api.ts (统一 API 层)                          │
+│      ┌──────────┴───────────┐                                │
+│      │ mq-tauri.ts │ mq-http.ts │                            │
+└──────┴─────────────┴────────────────────────────────────────┘
+         ▼ Tauri Invoke   ▼ HTTP Fetch
+┌─────────────────────────────────────────────────────────────┐
+│               Rust 后端 (Tauri / Axum)                       │
+│  ┌────────────────┐        ┌──────────────────┐            │
+│  │ commands/mq_cmd │  ◀─▶  │ routes/mq        │            │
+│  └────────────────┘        └──────────────────┘            │
+│           ▼                         ▼                        │
+│  ┌────────────────────────────────────────────────────┐    │
+│  │         dbx-core/mq/service.rs (*_core)             │    │
+│  └────────────────────────────────────────────────────┘    │
+│           ▼                                                  │
+│  ┌────────────────────────────────────────────────────┐    │
+│  │    MqAdminRegistry (缓存 adapter 实例)              │    │
+│  └────────────────────────────────────────────────────┘    │
+│           ▼                                                  │
+│  ┌────────────────────────────────────────────────────┐    │
+│  │    MessageQueueAdmin trait (port.rs)                │    │
+│  └────────────────────────────────────────────────────┘    │
+│           ▼                                                  │
+│  ┌────────────────────────────────────────────────────┐    │
+│  │  PulsarAdapter (adapters/pulsar.rs)                 │    │
+│  │  • 版本探测 (pulsar_version.rs)                     │    │
+│  │  • OAuth2 token 缓存 (auth.rs)                      │    │
+│  │  • SSRF 防护                                         │    │
+│  └────────────────────────────────────────────────────┘    │
+└─────────────────────────────────────────────────────────────┘
+         ▼ HTTPS
+┌─────────────────────────────────────────────────────────────┐
+│              Apache Pulsar Admin REST API                    │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## 快速配置
+
+### 1. 创建 Pulsar 连接
+
+在 DBX 中添加新连接，配置如下：
+
+**基本信息**：
+- **数据库类型**：选择 `mq` (Message Queue)
+- **连接名称**：例如 "Pulsar Production"
+- **Host/Port**：填写任意值（MQ 连接不使用这些字段）
+
+**扩展配置** (external_config JSON)：
+```json
+{
+  "systemKind": "pulsar",
+  "adminUrl": "https://pulsar.example.com:8443",
+  "auth": {
+    "kind": "token",
+    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+  },
+  "tlsSkipVerify": false
+}
+```
+
+### 2. 认证方式
+
+#### Token 认证（最常用）
+```json
+{
+  "kind": "token",
+  "token": "your-jwt-token"
+}
+```
+
+#### Basic 认证
+```json
+{
+  "kind": "basic",
+  "username": "admin",
+  "password": "admin-secret"
+}
+```
+
+#### OAuth2 认证（自动缓存 token）
+```json
+{
+  "kind": "oauth2",
+  "issuerUrl": "https://auth.example.com/oauth/token",
+  "clientId": "pulsar-admin",
+  "clientSecret": "client-secret",
+  "audience": "https://pulsar.example.com",
+  "scope": "pulsar:admin"
+}
+```
+
+#### API Key 认证
+```json
+{
+  "kind": "apiKey",
+  "header": "X-API-Key",
+  "value": "your-api-key"
+}
+```
+
+#### 无认证
+```json
+{
+  "kind": "none"
+}
+```
+
+### 3. 高级选项
+
+```json
+{
+  "systemKind": "pulsar",
+  "adminUrl": "https://pulsar.example.com:8443",
+  "auth": { "kind": "token", "token": "..." },
+  "tlsSkipVerify": true,           // 跳过 TLS 证书验证（开发环境）
+  "pinnedVersion": "3.1.0"         // 强制使用特定 API profile
+}
+```
+
+## 使用示例
+
+### 租户管理
+
+```typescript
+import { mqListTenants, mqCreateTenant } from '@/lib/mq-api'
+
+// 列出所有租户
+const tenants = await mqListTenants(connectionId)
+
+// 创建租户
+await mqCreateTenant(connectionId, 'my-tenant', {
+  adminRoles: ['admin', 'ops'],
+  allowedClusters: ['prod-cluster']
+})
+```
+
+### 命名空间管理
+
+```typescript
+import { mqListNamespaces, mqCreateNamespace } from '@/lib/mq-api'
+
+// 列出租户下的命名空间
+const namespaces = await mqListNamespaces(connectionId, 'my-tenant')
+
+// 创建命名空间
+await mqCreateNamespace(connectionId, {
+  tenant: 'my-tenant',
+  namespace: 'my-namespace'
+}, {})
+```
+
+### 主题管理
+
+```typescript
+import { mqListTopics, mqCreateTopic, mqGetTopicStats } from '@/lib/mq-api'
+
+// 列出主题
+const topics = await mqListTopics(connectionId, {
+  tenant: 'my-tenant',
+  namespace: 'my-namespace'
+}, {
+  includeNonPersistent: false
+})
+
+// 创建分区主题
+await mqCreateTopic(connectionId, {
+  tenant: 'my-tenant',
+  namespace: 'my-namespace',
+  topic: 'my-topic',
+  persistent: true
+}, 4) // 4 个分区
+
+// 查询主题统计
+const stats = await mqGetTopicStats(connectionId, {
+  tenant: 'my-tenant',
+  namespace: 'my-namespace',
+  topic: 'my-topic',
+  persistent: true
+})
+console.log(`消息速率: ${stats.msgRateIn}/s`)
+console.log(`积压大小: ${stats.backlogSize} bytes`)
+```
+
+### 订阅管理
+
+```typescript
+import { 
+  mqListSubscriptions, 
+  mqCreateSubscription, 
+  mqResetCursor,
+  mqClearBacklog 
+} from '@/lib/mq-api'
+
+const topicRef = {
+  tenant: 'my-tenant',
+  namespace: 'my-namespace',
+  topic: 'my-topic',
+  persistent: true
+}
+
+// 列出订阅
+const subs = await mqListSubscriptions(connectionId, topicRef)
+
+// 创建订阅（从最早消息开始）
+await mqCreateSubscription(connectionId, topicRef, 'my-subscription', {
+  kind: 'earliest'
+})
+
+// 重置游标到最新
+await mqResetCursor(connectionId, topicRef, 'my-subscription', {
+  kind: 'latest'
+})
+
+// 清空积压
+await mqClearBacklog(connectionId, topicRef, 'my-subscription')
+```
+
+### 策略配置
+
+```typescript
+import { mqSetPublishRate, mqSetRetention } from '@/lib/mq-api'
+
+const scope = {
+  level: 'namespace' as const,
+  tenant: 'my-tenant',
+  namespace: 'my-namespace'
+}
+
+// 设置发布速率限制
+await mqSetPublishRate(connectionId, scope, {
+  publishThrottlingRateInMsg: 1000,      // 1000 msg/s
+  publishThrottlingRateInByte: 1048576   // 1 MB/s
+})
+
+// 设置保留策略
+await mqSetRetention(connectionId, scope, {
+  retentionTimeInMinutes: 7 * 24 * 60,   // 7 天
+  retentionSizeInMb: 10240                // 10 GB
+})
+```
+
+### 权限管理
+
+```typescript
+import { mqGrantPermission, mqListPermissions } from '@/lib/mq-api'
+
+const scope = {
+  level: 'namespace' as const,
+  tenant: 'my-tenant',
+  namespace: 'my-namespace'
+}
+
+// 授予权限
+await mqGrantPermission(connectionId, scope, 'my-app-role', ['produce', 'consume'])
+
+// 查询权限
+const permissions = await mqListPermissions(connectionId, scope)
+console.log(permissions) // { 'my-app-role': ['produce', 'consume'] }
+```
+
+## 桌面端命令注册
+
+所有后端功能已通过 Tauri commands 暴露给前端：
+
+```rust
+// src-tauri/src/lib.rs
+.invoke_handler(tauri::generate_handler![
+    // ... 其他命令
+    commands::mq_cmd::mq_test_connection,
+    commands::mq_cmd::mq_list_tenants,
+    commands::mq_cmd::mq_create_tenant,
+    // ... 共 48 个 mq 命令
+])
+```
+
+## Web 端路由注册
+
+所有后端功能已通过 Axum routes 暴露为 REST API：
+
+```rust
+// crates/dbx-web/src/main.rs
+.route("/mq/test-connection", post(routes::mq::test_connection))
+.route("/mq/tenants/list", post(routes::mq::list_tenants))
+.route("/mq/tenants/create", post(routes::mq::create_tenant))
+// ... 共 48 个路由
+```
+
+## 安全特性
+
+### 1. 只读保护
+所有变更操作会检查连接的 `read_only` 标志：
+```rust
+ensure_connection_writable(&state, &connection_id, "Create tenant").await?;
+```
+
+### 2. SSRF 防护
+Raw request 路径必须是相对当前 Admin base 的绝对路径：必须以 `/` 开头，不能包含 scheme/host，也不能包含 `..` 路径段：
+```rust
+if path.contains("://") || path.starts_with("//") || !path.starts_with('/') || path.split('/').any(|seg| seg == "..") {
+    return Err("Raw request path is not safe".to_string());
+}
+```
+
+### 3. OAuth2 Token 缓存
+避免每次请求都交换 token（60 秒缓存，5 秒提前刷新）：
+```rust
+pub struct OAuth2TokenCache {
+    token: RwLock<Option<CachedToken>>,
+    config: OAuth2Config,
+}
+```
+
+### 4. 版本兼容性
+自动探测 Pulsar 版本，优雅降级不支持的 API：
+```rust
+async fn detect_pulsar_version(client: &reqwest::Client, base_url: &str) -> PulsarProfile {
+    // 探测 /admin/v2/brokers/version
+    // 返回 3.1.x baseline profile
+}
+```
+
+## 编译与运行
+
+### 启用 MQ 功能
+```bash
+# 默认已启用（default = ["duckdb-bundled", "mq-admin"]）
+cargo build --release
+
+# 或显式指定
+cargo build --release --features mq-admin
+```
+
+### 禁用 MQ 功能
+```bash
+cargo build --release --no-default-features --features duckdb-bundled
+```
+
+### 检查编译
+```bash
+cargo check --package dbx-core --features mq-admin
+cargo check --package dbx --features mq-admin
+cargo check --package dbx-web --features mq-admin
+```
+
+## 后续扩展
+
+### 添加新的 MQ 系统（如 Kafka）
+
+当前版本仅在架构和类型层预留 Kafka/RocketMQ；前端连接对话框不会提供这些选项。新增适配器并完成验证后，再开放 UI 选择。
+
+1. 实现 `MessageQueueAdmin` trait：
+```rust
+// crates/dbx-core/src/mq/adapters/kafka.rs
+pub struct KafkaAdapter {
+    config: Arc<ConnectionConfig>,
+    client: KafkaAdminClient,
+}
+
+#[async_trait]
+impl MessageQueueAdmin for KafkaAdapter {
+    async fn test_connection(&self) -> Result<MqClusterInfo, String> {
+        // Kafka 特定的连接测试
+    }
+    
+    async fn list_topics(&self, ns: &NamespaceRef, opts: ListTopicsOpts) -> Result<Vec<TopicInfo>, String> {
+        // Kafka 使用不同的 topic 模型，适配到统一接口
+    }
+    
+    // ... 实现其他方法
+}
+```
+
+2. 在 `MqAdminRegistry::build_adapter` 中注册：
+```rust
+match mq_config.system_kind {
+    MqSystemKind::Pulsar => { /* ... */ }
+    MqSystemKind::Kafka => {
+        Ok(Arc::new(KafkaAdapter::new(config.clone()).await?))
+    }
+    // ...
+}
+```
+
+3. 适配器、能力位和端到端验证完成后，再在连接对话框开放对应系统选择。
+
+## 常见问题
+
+### Q: 连接测试失败 "SSL certificate problem"
+A: 开发环境可设置 `tlsSkipVerify: true`，生产环境应配置正确的 CA 证书。
+
+### Q: 权限不足 "Not authorized"
+A: 检查 token 是否有 `admin` 或相应的角色权限。
+
+### Q: 某些 API 返回 404
+A: 可能是 Pulsar 版本不支持该 API，检查 `test_connection` 返回的 `capabilities`。
+
+### Q: OAuth2 token 一直刷新失败
+A: 检查 `issuerUrl`、`clientId`、`clientSecret`、`audience` 是否正确。
+
+### Q: 如何调试 Admin API
+A: 使用 Raw API 面板或直接调用 `mqRawRequest`：
+```typescript
+const response = await mqRawRequest(connectionId, {
+  method: 'GET',
+  path: '/admin/v2/clusters',
+  query: {},
+  body: null
+})
+console.log(response.body)
+```
+
+ 
\ No newline at end of file
diff --git a/docs/next-env.d.ts b/docs/next-env.d.ts
new file mode 100644
index 0000000..c4b7818
--- /dev/null
+++ b/docs/next-env.d.ts
@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+import "./.next/dev/types/routes.d.ts";
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.
diff --git a/docs/next.config.mjs b/docs/next.config.mjs
new file mode 100644
index 0000000..ec56b38
--- /dev/null
+++ b/docs/next.config.mjs
@@ -0,0 +1,11 @@
+import { createMDX } from "fumadocs-mdx/next";
+
+const withMDX = createMDX();
+
+/** @type {import('next').NextConfig} */
+const config = {
+  output: "export",
+  images: { unoptimized: true },
+};
+
+export default withMDX(config);
diff --git a/docs/package.json b/docs/package.json
new file mode 100644
index 0000000..1547e98
--- /dev/null
+++ b/docs/package.json
@@ -0,0 +1,33 @@
+{
+  "name": "dbx-docs",
+  "private": true,
+  "license": "Apache-2.0",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "postbuild": "node scripts/generate-sitemap.mjs",
+    "start": "next start",
+    "postinstall": "fumadocs-mdx"
+  },
+  "dependencies": {
+    "@orama/orama": "3.1.18",
+    "@tailwindcss/postcss": "^4.2.4",
+    "@types/mdx": "^2.0.13",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "fumadocs-core": "^16.8.7",
+    "fumadocs-mdx": "^14.3.2",
+    "fumadocs-ui": "^16.8.7",
+    "lucide-react": "^0.515.0",
+    "motion": "^12.38.0",
+    "next": "^16.2.4",
+    "postcss": "^8.5.14",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "tailwindcss": "^4.2.4",
+    "typescript": "^6.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0"
+  }
+}
diff --git a/docs/performance/dom-density-audit.md b/docs/performance/dom-density-audit.md
new file mode 100644
index 0000000..3be12c5
--- /dev/null
+++ b/docs/performance/dom-density-audit.md
@@ -0,0 +1,41 @@
+# DOM density and memory audit
+
+Date: 2026-05-22
+
+Baseline: `upstream/main` at `6c83b10`
+Candidate: `perf/dom-density-audit`
+
+## Method
+
+- Built both baseline and candidate as production Vite bundles.
+- Ran each measurement in a fresh headless Google Chrome process with a fresh profile.
+- Rendered the same synthetic large-result scenarios by driving the app stores and mocked desktop APIs.
+- Ran 3 isolated samples per scenario and reported the median.
+- Collected RSS from the full Chrome process tree after forced garbage collection. RSS includes browser process overhead, so the comparable signal is the delta.
+- Collected JS heap with `Runtime.getHeapUsage` after `HeapProfiler.collectGarbage` and `globalThis.gc()`.
+
+## Memory Results
+
+| Scenario              | Before RSS MiB | After RSS MiB | RSS Delta MiB | Before JS Heap MiB | After JS Heap MiB | JS Heap Delta MiB |
+| --------------------- | -------------: | ------------: | ------------: | -----------------: | ----------------: | ----------------: |
+| Grid 1000 x 20        |         1226.3 |        1214.2 |         -12.1 |               19.6 |              16.6 |              -3.0 |
+| Grid 1000 x 200       |         1462.5 |        1399.7 |         -62.8 |               96.7 |              67.5 |             -29.2 |
+| Redis list value 3000 |         1396.6 |        1185.4 |        -211.2 |               82.7 |              11.3 |             -71.4 |
+| Redis hash value 3000 |         1402.3 |        1183.8 |        -218.5 |               83.7 |              11.5 |             -72.2 |
+| Redis stream 1000 x 5 |         1444.3 |        1182.1 |        -262.2 |               92.5 |              13.3 |             -79.2 |
+
+## DOM Results
+
+| Scenario              | Before DOM Elements | After DOM Elements | Element Delta | Before DOM Nodes | After DOM Nodes | Node Delta | Listener Delta |
+| --------------------- | ------------------: | -----------------: | ------------: | ---------------: | --------------: | ---------: | -------------: |
+| Grid 1000 x 20        |                6937 |               1837 |         -5100 |            12644 |            8564 |      -4080 |          -1020 |
+| Grid 1000 x 200       |               65257 |              14257 |        -51000 |           106784 |           65984 |     -40800 |         -10200 |
+| Redis list value 3000 |               57293 |               1096 |        -56197 |            82472 |            2760 |     -79712 |         -11839 |
+| Redis hash value 3000 |               57295 |               1098 |        -56197 |            82478 |            2766 |     -79712 |         -11839 |
+| Redis stream 1000 x 5 |               62281 |               1180 |        -61101 |            96450 |            2928 |     -93522 |         -14759 |
+
+## Notes
+
+- The grid reduction comes from mounting the cell detail action only for the hovered or currently open detail cell.
+- The Redis reduction comes from virtualizing large list, set, hash, sorted set, and stream value rows.
+- Existing user operations remain available: the cell detail action appears on hover or while its detail panel is open, and Redis row actions still operate on the visible virtualized rows.
diff --git a/docs/performance/memory-usage-audit.md b/docs/performance/memory-usage-audit.md
new file mode 100644
index 0000000..fbd1a73
--- /dev/null
+++ b/docs/performance/memory-usage-audit.md
@@ -0,0 +1,234 @@
+# DBX 内存占用功能排查报告
+
+日期：2026-06-11
+
+## 结论摘要
+
+本次排查结合了当前运行进程快照、前端 bundle 体积、以及主要功能的代码路径。当前进程里最大的 repo 相关内存占用是开发服务器 `vite`，RSS 约 442 MiB；这属于开发工具链占用，不应直接归因到 DBX 某个业务功能。
+
+业务功能层面，最容易导致内存占用率升高的是这些路径：
+
+1. 查询结果 / 表数据 DataGrid / 导出：高风险，结果集会在原始 rows、筛选索引、显示项、搜索命中、导出 rows、磁盘缓存转换中多份存在。
+2. 数据对比 Data Compare：高风险，后端一次性持有源表和目标表全量数据，并构建 HashMap、diff、同步 SQL；前端也会保留完整 diff 和 sync plan。
+3. Redis Key Browser：高风险，`fetch all` 和 value search 可能扫描并保留大量 key，同时维护 flat list、tree list、visible rows 和命令历史。
+4. Mongo 文档表格视图：中高风险，`documents` 会转换成 DataGrid 的二维 rows，嵌套对象还会被 `JSON.stringify`，随后再进入 DataGrid 的派生结构。
+5. 查询图表 QueryChart：中高风险，打开图表会加载 ECharts，并把查询结果再次映射为 x/y series 数组。
+6. Schema / Object Browser / ER Diagram：中风险，连接树、补全缓存、schema 关系和图节点会随库规模增长。
+7. QueryEditor 补全、AI Assistant：中低风险，通常不是首要来源，但长会话、多 tab、频繁补全或长聊天会持续积累状态。
+
+## 当前进程快照
+
+命令：
+
+```bash
+ps -axo pid,ppid,rss,vsz,comm,args | awk 'NR==1 || /dbx|vite|pnpm|tauri|WebKit|node_repl|electron|cargo/ {print}' | sort -k3 -nr | head -40
+```
+
+主要观察：
+
+| 进程 | RSS | 说明 |
+| --- | ---: | --- |
+| `node ... vite --config apps/desktop/vite.config.ts --port 5173 --mode web` | 452,880 KB，约 442 MiB | 当前最大 repo 相关进程，属于开发服务器和 HMR，占用通常高于生产包 |
+| `com.apple.WebKit.WebContent` | 197,232 KB，约 193 MiB | WebKit 渲染进程，可能来自 Codex 内嵌浏览器或本地预览，需结合具体窗口确认 |
+| `com.apple.WebKit.WebContent` | 165,872 KB，约 162 MiB | 同上 |
+| `com.apple.WebKit.WebContent` | 130,672 KB，约 128 MiB | 同上 |
+| `pnpm dev:web` | 52,352 KB，约 51 MiB | Vite 父进程 |
+
+补充：`target`、`node_modules` 等目录体积是磁盘占用，不是运行时内存。当前 `target` 目录约 27 GiB，`node_modules` 约 543 MiB，主要影响磁盘空间和构建缓存，不直接解释内存占用率。
+
+## 前端 Chunk 观察
+
+当前 `dist/assets` 中较大的 JS chunk：
+
+| Chunk | 大小 | 相关功能 |
+| --- | ---: | --- |
+| `index-C0boAXCG.js` | 600 KB | 主应用入口 |
+| `QueryChart-DxFWVk_s.js` | 548 KB | 查询图表，包含 ECharts 相关逻辑 |
+| `codemirror-Dy52TtRW.js` | 464 KB | SQL 编辑器 |
+| `sql-formatter-BTQ26GQc.js` | 288 KB | SQL 格式化 |
+| `DataGrid-kZSBZBlT.js` | 148 KB | 查询结果表格 |
+| `RedisKeyBrowser-CdulxmUR.js` | 60 KB | Redis key 浏览器 |
+| `AiAssistant-BrEVPSc_.js` | 52 KB | AI 助手 |
+
+Chunk 体积不等于运行时内存，但能提示哪些功能首次打开会引入较重依赖。这里 `QueryChart` 的包体明显偏大，且运行时还会复制查询数据到 ECharts option。
+
+## 功能排名与占用来源
+
+| 排名 | 功能 | 风险 | 主要占用来源 | 典型触发 |
+| ---: | --- | --- | --- | --- |
+| 1 | 查询结果 / 表数据 / DataGrid / 导出 | 高 | 查询 rows、inactive tab 缓存、DataGrid 派生数组、搜索命中、导出 rows、缓存序列化峰值 | 大查询结果、多结果 tab、客户端搜索、全量导出 |
+| 2 | 数据对比 Data Compare | 高 | 源表 rows、目标表 rows、HashMap、diff clone、sync statements、sync SQL、前端 selectable diff | 大表对比、批量表对比、差异很多 |
+| 3 | Redis Key Browser | 高 | flat key list、tree key list、visible rows、checked set、命令历史 | `fetch all`、value search、大 keyspace |
+| 4 | Mongo 文档表格视图 | 中高 | 原始 documents、转换后的 grid rows、对象 JSON 字符串、DataGrid 派生数组 | 大 page size、宽文档、嵌套对象多 |
+| 5 | 查询图表 QueryChart | 中高 | ECharts 依赖、xData、series data、pie data | 大结果集打开图表、多 Y 轴列 |
+| 6 | Schema / Object Browser / ER Diagram | 中 | treeNodes、schema cache、completion cache、diagram tables / relationships | 多库多 schema、超大表结构 |
+| 7 | QueryEditor 补全和诊断 | 中 | CodeMirror、per-editor table/column/FK cache、语义诊断状态 | 多编辑器 tab、频繁触发补全 |
+| 8 | AI Assistant | 中低 | conversations、messages、Markdown/Shiki 高亮缓存 | 很长对话、代码块多 |
+| 9 | 连接池 / Agent / JDBC / SSH | 中低到中 | 后端连接、外部 driver/session、后台状态 | 打开很多连接或长时间不关闭 |
+
+## 1. 查询结果 / DataGrid / 导出
+
+这是最需要优先处理的业务路径。
+
+代码证据：
+
+- `apps/desktop/src/stores/queryStore.ts:136` 将 inactive 结果内存缓存上限设为 `MAX_CACHED_RESULTS = 5`。实际效果是当前 active tab 加最多 5 个 inactive tab 的结果仍可留在内存。
+- `apps/desktop/src/stores/queryStore.ts:1406` 到 `1410` 只按 tab 数量淘汰 inactive 结果，没有按行数、列数或估算字节数淘汰。
+- `apps/desktop/src/components/grid/DataGrid.vue:518` 到 `530` 即使没有本地列筛选，也会为所有 rows 构造一份索引数组。
+- `apps/desktop/src/components/grid/DataGrid.vue:2350` 到 `2374` 会为显示行构造 `displayRowRefs`，`2404` 又映射成 `displayItems`。虚拟滚动减少 DOM 节点，但没有避免 JS 内存里存在全量派生数组。
+- `apps/desktop/src/components/grid/DataGrid.vue:2445` 到 `2467` 客户端搜索会扫描所有显示行和列，并保存每个命中的坐标。
+- `apps/desktop/src/stores/queryStore.ts:1469` 到 `1592` 导出时循环分页并 `rows.push(...result.rows)`，最终返回一个包含全量 rows 的 `QueryResult`。这会让导出期间出现明显内存峰值。
+- `apps/desktop/src/lib/tabResultCache.ts:129` 到 `146` 在结果被转成列式 MessagePack 缓存时，会从 row-major rows 生成 column-major `columnValues`，恢复时又重建 rows。淘汰/恢复期间可能出现原始 rows、列式副本、编码 bytes 多份共存。
+
+建议：
+
+1. 将结果缓存从“最多 5 个 inactive tab”改为“按估算字节数 + tab 数”双上限，例如默认只保留当前 tab + 最近 1 到 2 个小结果；大结果立即落盘或只保留当前页。
+2. DataGrid 内部避免为全量 rows 同时维护 `localFilteredRows`、`displayRowRefs`、`displayItems`。可改为基于索引的懒计算，虚拟滚动只生成可视范围 item。
+3. 客户端搜索增加上限和渐进式扫描，例如只扫描当前页或前 N 行，超限提示用户改用 SQL 查询。
+4. 导出改成 streaming writer，不返回包含全量 rows 的 `QueryResult`。CSV/Excel/JSON 都应边拉边写，避免 `rows.push(...)` 聚合。
+5. 缓存落盘时避免 `structuredClone`、row-to-column、encode 同时叠加；可用分块序列化，或在清空原始引用后再进行后台转换。
+6. 对 `MAX_RESULT_PAGE_SIZE` 做产品级收紧。当前最大可到 100,000 行，配合宽表和 DataGrid 派生数组会非常容易冲高内存。
+
+## 2. 数据对比 Data Compare
+
+这是第二个最高风险路径，而且会同时占用 Rust 后端和前端内存。
+
+代码证据：
+
+- `crates/dbx-core/src/data_compare.rs:227` 到 `250` 通过 `tokio::try_join!` 同时拉取源表和目标表 rows。
+- `crates/dbx-core/src/data_compare.rs:723` 到 `768` 虽然按 batch 查询，但最终 `rows.extend(result.rows)` 聚合到一个 `Vec<Vec<Value>>` 后返回。
+- `crates/dbx-core/src/data_compare.rs:422` 到 `489` 会把两边 rows 转为 compare rows，再收集到 HashMap/order，并 clone added / removed / modified 的 values。
+- `crates/dbx-core/src/data_compare.rs:376` 到 `400` 会生成 `sync_statements`，再 join 成完整 `sync_sql`，SQL 文本本身也可能很大。
+- `apps/desktop/src/components/diff/DataCompareDialog.vue:413` 到 `418` 会把 diff row 映射成 selectable diff。
+- `apps/desktop/src/components/diff/DataCompareDialog.vue:500` 到 `528` 会把选中的 diff 发送给后端重建 sync plan。
+- `apps/desktop/src/components/diff/DataCompareDialog.vue:538` 到 `692` 批量表对比会逐表 push 结果，最后 `batchResults.value = results`，完整 diff 留在前端状态里。
+
+建议：
+
+1. 对单表对比加硬上限，例如行数超过阈值时要求用户确认，或默认只对比 key/hash 摘要。
+2. 改为按主键有序流式对比，避免源表和目标表全量同时驻留内存。
+3. diff 明细分页加载，只在概览里保留计数和少量样例。
+4. sync SQL 按需生成或流式下载，不在内存里长期保存完整 `sync_sql`。
+5. 批量对比时完成一张表就释放中间 rows，只保留摘要；用户展开表时再加载明细。
+
+## 3. Redis Key Browser
+
+Redis 浏览器在大 keyspace 下容易膨胀。
+
+代码证据：
+
+- `apps/desktop/src/components/redis/RedisKeyBrowser.vue:61` 到 `82` 同时持有 `flatKeys`、`treeKeys`、`checkedKeys`、`commandHistory` 等状态。
+- `apps/desktop/src/components/redis/RedisKeyBrowser.vue:141` 到 `146` 会从 tree 计算 `visibleRows`。
+- `apps/desktop/src/components/redis/RedisKeyBrowser.vue:154` 到 `177` 会基于 `flatKeys` 重建或合并 tree。
+- `apps/desktop/src/components/redis/RedisKeyBrowser.vue:222` 到 `227` value search 会持续 scan，直到没有更多结果。
+- `apps/desktop/src/components/redis/RedisKeyBrowser.vue:285` 到 `299` `fetchAll` 会循环 scan，直到所有 key 加载完。
+- `apps/desktop/src/components/redis/RedisKeyBrowser.vue:387` 到 `389` 命令历史追加后没有长度上限。
+
+建议：
+
+1. `fetch all` 加数量上限、内存提示和二次确认；默认不应全量加载百万级 key。
+2. value search 改成最多加载 N 条，然后提示继续加载。
+3. `commandHistory` 做 ring buffer，例如最多保留 200 条。
+4. tree 结构尽量使用紧凑节点，避免同时保留 flat、tree、visible 三份完整数据。
+
+## 4. Mongo 文档表格视图
+
+Mongo 单页默认受 page size 控制，但表格模式会复制数据。
+
+代码证据：
+
+- `apps/desktop/src/components/mongo/MongoDocBrowser.vue:35` 保存原始 `documents`。
+- `apps/desktop/src/components/mongo/MongoDocBrowser.vue:122` 到 `154` 将 documents 转成 DataGrid `QueryResult`，为所有文档推导 columns 并生成二维 rows。
+- `apps/desktop/src/components/mongo/MongoDocBrowser.vue:143` 到 `149` 对对象字段执行 `JSON.stringify`，宽文档或深嵌套对象会扩大字符串内存。
+- `apps/desktop/src/components/mongo/MongoDocBrowser.vue:332` 到 `340` 每次加载 page 后替换 documents。
+
+建议：
+
+1. 表格视图只展开顶层标量字段；对象字段延迟 stringify，用户展开单元格时再格式化。
+2. Mongo 表格模式使用更小的默认 page size。
+3. 对宽文档增加列数或单元格字符串长度限制。
+
+## 5. 查询图表 QueryChart
+
+QueryChart 的包体和运行时复制都偏重。
+
+代码证据：
+
+- `apps/desktop/src/components/chart/QueryChart.vue:4` 到 `15` 引入并注册 ECharts CanvasRenderer、Line、Bar、Pie、Grid、Tooltip、Legend。
+- `apps/desktop/src/components/chart/QueryChart.vue:29` `numericColumns` 会扫描 rows 判断数值列。
+- `apps/desktop/src/components/chart/QueryChart.vue:57` 生成全量 `xData`。
+- `apps/desktop/src/components/chart/QueryChart.vue:69` 到 `72` pie chart 为每一行生成 `{ name, value }`。
+- `apps/desktop/src/components/chart/QueryChart.vue:96` 到 `100` 每个 Y 列都会再 map 一份 series data。
+
+建议：
+
+1. 图表默认只取前 N 行或采样，例如 5,000 行以内。
+2. 多 Y 列时提示 series 数据量，超限则要求用户确认。
+3. `numericColumns` 可以基于抽样判断，不需要扫描所有 rows。
+
+## 6. Schema / Object Browser / ER Diagram
+
+这类功能一般不会像大结果集那样瞬间冲高，但在多连接、多库、多 schema 长会话里会累积。
+
+代码证据：
+
+- `apps/desktop/src/stores/connectionStore.ts` 中维护 `treeNodes`、`loadedTreeNodeChildrenIds`、`completionTablesCache`、`completionObjectsCache`、`completionColumnsCache`、`schemaListCache` 等长期状态。
+- 全局 completion cache 有 `COMPLETION_CACHE_MAX = 50`，但 schema tree 和已展开节点会随用户浏览而保留。
+- `apps/desktop/src/components/diagram/SchemaDiagramDialog.vue` 会持有 diagram tables、positions、relationships、visible map，超大 schema 下会增长明显。
+
+建议：
+
+1. 对 schema tree 增加“清理连接缓存”入口。
+2. 大 schema 的 ER 图只加载用户选择的表及一跳关系。
+3. completion cache 继续保留上限，但 per-connection/schema tree 也应考虑 LRU 或手动释放。
+
+## 7. QueryEditor 补全与 AI Assistant
+
+这两块不是当前首要嫌疑，但长时间使用会有累积。
+
+代码证据：
+
+- `apps/desktop/src/components/editor/QueryEditor.vue` 每个编辑器实例维护 `cachedTables`、`cachedCompletionObjects`、`cachedColumnsByTable`、`cachedForeignKeysByTable`。
+- CodeMirror、language packages、SQL formatter 是较大的编辑器相关依赖。
+- `apps/desktop/src/components/editor/AiAssistant.vue` 维护 messages、conversations、mention cache，并使用 Markdown / Shiki 代码高亮。
+
+建议：
+
+1. 编辑器 per-tab cache 增加容量或生命周期限制，tab 关闭时确认释放。
+2. AI conversations 只在当前会话保留最近 N 条渲染消息，旧消息可折叠或按需加载。
+3. 代码高亮按可见消息懒加载，避免一次性渲染长历史。
+
+## 优先优化清单
+
+短期优先做：
+
+1. 把查询结果缓存从 tab 数上限改成内存估算上限，先降低 inactive result 的保留数量。
+2. 导出改为 streaming，避免在 `fetchTabResultForExport` 聚合全量 rows。
+3. DataGrid 去掉或延迟 `displayItems` 全量数组，搜索命中做分批扫描和上限。
+4. Data Compare 加行数阈值、确认提示和 diff 明细分页。
+5. Redis `fetch all`、value search、command history 加上限。
+
+中期优化：
+
+1. Data Compare 改为主键有序流式对比或 hash 摘要对比。
+2. tab result cache 改成分块序列化，减少落盘时的峰值副本。
+3. QueryChart 加采样和最大点数。
+4. Mongo table mode 对对象字段做懒格式化。
+
+长期优化：
+
+1. 加内存诊断面板，显示当前 tab rows、列数、派生索引数量、缓存结果数量。
+2. 在开发和生产 Tauri 下分别采集 JS heap snapshot，建立固定的大数据压测场景。
+3. 对 Rust 后端的 Data Compare、Agent cursor、JDBC session 做 heap / allocation profile。
+
+## 需要进一步实测
+
+本报告没有拿到用户实际数据库数据集，因此功能排序主要基于代码路径和当前进程快照。若要定位“现在”具体是哪一个功能占用最多，建议补跑以下场景：
+
+1. 生产 Tauri 包下打开空应用，记录基线 RSS。
+2. 执行 10k、50k、100k 行查询，分别记录 DataGrid 首屏、搜索、切 tab、导出时的 JS heap 和 RSS。
+3. 对比 10 万、100 万行表，记录 Rust 进程峰值内存。
+4. Redis 分别加载 10k、100k、1M keys，记录 flat/tree/visibleRows 的前端 heap。
+5. Mongo 表格视图加载宽文档和深嵌套文档，比较 document mode 与 table mode。
+
+如果只看当前代码风险，首要优化对象应是“查询结果/DataGrid/导出”和“数据对比”。
diff --git a/docs/performance/runtime-memory-audit.md b/docs/performance/runtime-memory-audit.md
new file mode 100644
index 0000000..bc9ef9b
--- /dev/null
+++ b/docs/performance/runtime-memory-audit.md
@@ -0,0 +1,253 @@
+# DBX Web 运行内存功能排查报告
+
+日期：2026-06-11
+
+## 结论
+
+已将网页版 DBX 的访问密码设置为 `test`，并通过接口验证登录成功。当前可访问地址：
+
+```text
+http://127.0.0.1:5173/login
+```
+
+本次用独立 Chrome profile 打开 DBX Web，创建 5 万行 SQLite 测试库，逐项触发主要功能并采集运行内存。当前测到最占运行内存的功能是：
+
+1. 数据对比 Data Compare：优化前后端 `dbx-web` RSS 从约 213 MiB 峰值升到约 496 MiB，是原始基线中最高。
+2. 查询图表 QueryChart：在 5 万行结果上打开图表后，前端 JS heap 升到约 109 MiB，Chrome renderer 峰值约 567 MiB。
+3. 查询结果 DataGrid：5 万行、12 列查询结果进入 DataGrid 后，前端 JS heap 约 78 MiB，Chrome renderer 约 480 MiB，后端 RSS 约 194 MiB。
+4. 驱动管理 Driver Store：DOM 节点明显增加，但 JS heap 被 GC 后下降，未表现为主要内存来源。
+5. 空数据对比对话框：只打开对话框增量很小，不是内存大头；真正占用来自执行对比。
+
+第一轮已优化 Data Compare 后端内存路径：同样 50,000 vs 49,649 行场景下，`dbx-web` RSS 峰值从 507,504 KiB 降到 239,696 KiB，下降约 53%；接口输出计数、SQL 数量和响应大小保持一致。
+
+开发服务器 Vite 本身 RSS 很高，后续一度到约 1.1-1.2 GiB。这是 dev/HMR 工具链占用，不属于某个业务功能，但会显著抬高当前机器的总内存占用。
+
+## 密码重置
+
+认证实现：
+
+- 前端登录接口：`/api/auth/login`
+- 初始设置接口：`/api/auth/setup`
+- 后端密码存储：`~/.dbx-web/dbx.db` 的 `app_settings.settings_json.password_hash`
+- `DBX_PASSWORD` 环境变量会覆盖数据库密码，但本次没有用环境变量覆盖，而是走 `/api/auth/setup` 持久化设置。
+
+验证结果：
+
+```text
+POST /api/auth/setup {"password":"test"} -> 200 OK
+POST /api/auth/login {"password":"test"} -> 200 OK
+GET /api/auth/check with cookie -> {"authenticated":true,"required":true,"setup_required":false}
+```
+
+## 测试环境
+
+运行进程：
+
+| 组件 | 地址 / 进程 | 说明 |
+| --- | --- | --- |
+| Web 前端 | `http://127.0.0.1:5173` | 已存在的 Vite dev server |
+| Web 后端 | `target/debug/dbx-web`，端口 `4224` | 本次启动，用于 API 和认证 |
+| 测量浏览器 | Chrome 独立 profile：`/tmp/dbx-runtime-chrome-profile` | 只打开 DBX 页面，避免混入日常 Chrome tab |
+
+测试数据：
+
+| 对象 | 规模 |
+| --- | ---: |
+| SQLite 文件 | `/tmp/dbx-runtime-memory-probe.sqlite` |
+| DBX 连接名 | `Runtime Memory SQLite` |
+| `runtime_probe` | 50,000 行，12 列 |
+| `runtime_probe_target` | 49,649 行，12 列 |
+| DataGrid page size | 50,000 |
+| DataGrid render mode | Canvas |
+
+## 测量方法
+
+采集方式：
+
+- Chrome DevTools Protocol `Performance.getMetrics`
+  - `JSHeapUsedSize`
+  - `JSHeapTotalSize`
+  - DOM node count
+- macOS `ps`
+  - 独立 Chrome profile 总 RSS
+  - Chrome renderer RSS
+  - Vite RSS
+  - `dbx-web` RSS
+- 数据对比 API 额外用 50ms 间隔采样 `dbx-web` RSS 峰值。
+
+注意：
+
+- JS heap 是前端页面 heap，不包含浏览器共享库、GPU、网络进程等。
+- Chrome renderer RSS 更接近页面实际进程内存，但仍包含渲染器基础开销。
+- Vite 是开发工具链，不应归因到业务功能。
+- 数据对比 API 测到的是后端执行峰值；本轮没有自动填完整数据对比对话框并渲染 diff 明细。
+
+## 运行内存记录
+
+单位说明：
+
+- JS heap：MiB
+- RSS：KiB，括号内为约 MiB
+
+| 场景 | JS heap used | Chrome renderer RSS | Chrome profile 总 RSS | `dbx-web` RSS | Vite RSS | 备注 |
+| --- | ---: | ---: | ---: | ---: | ---: | --- |
+| 登录页 | 13.30 MiB | 未拆分 | 906,576 KiB（885 MiB） | 未启动/低 | 475,200 KiB（464 MiB） | 登录页 DOM 约 255 |
+| 登录后主界面 | 25.12 MiB | 未拆分 | 961,760 KiB（939 MiB） | 72,688 KiB（71 MiB） | 481,376 KiB（470 MiB） | 已加载连接列表 |
+| 打开查询编辑器 | 25.86 MiB | 未拆分 | 未记录 | 未记录 | 未记录 | CodeMirror 出现，增量很小 |
+| 设置 page size 后刷新 | 31.83 MiB | 408,608 KiB（399 MiB） | 1,003,440 KiB（980 MiB） | 54,048 KiB（53 MiB） | 1,224,272 KiB（1,196 MiB） | Dev server RSS 明显上升 |
+| 填入 SQL | 34.94 MiB | 414,144 KiB（404 MiB） | 1,016,384 KiB（993 MiB） | 54,720 KiB（53 MiB） | 1,224,272 KiB（1,196 MiB） | 编辑器文本变化 |
+| DataGrid 5 万行结果 | 77.98 MiB | 491,440 KiB（480 MiB） | 1,089,552 KiB（1,064 MiB） | 198,448 KiB（194 MiB） | 1,249,856 KiB（1,221 MiB） | 50,000 行、12 列、Canvas |
+| 图表前，GC 后 | 61.15 MiB | 443,040 KiB（433 MiB） | 1,046,128 KiB（1,022 MiB） | 198,448 KiB（194 MiB） | 1,161,296 KiB（1,134 MiB） | DataGrid 结果仍在 |
+| QueryChart 5 秒 | 109.77 MiB | 580,976 KiB（567 MiB） | 1,185,408 KiB（1,158 MiB） | 198,448 KiB（194 MiB） | 1,172,096 KiB（1,145 MiB） | ECharts + series 数据峰值 |
+| QueryChart 10 秒 | 108.74 MiB | 524,160 KiB（512 MiB） | 1,128,544 KiB（1,102 MiB） | 198,448 KiB（194 MiB） | 1,172,096 KiB（1,145 MiB） | 图表稳定后 |
+| 空数据对比对话框 | 110.72 MiB | 531,520 KiB（519 MiB） | 1,141,376 KiB（1,115 MiB） | 198,448 KiB（194 MiB） | 1,187,120 KiB（1,159 MiB） | 只打开弹窗，增量小 |
+| Data Compare API | 不适用 | 不适用 | 不适用 | 峰值 507,504 KiB（496 MiB） | 不适用 | 50k vs 49,649 行，两表对比 |
+| 驱动管理 | 67.49 MiB | 535,072 KiB（522 MiB） | 1,145,696 KiB（1,119 MiB） | 478,928 KiB（468 MiB） | 1,188,624 KiB（1,161 MiB） | DOM 到 1,157，但 JS heap 被 GC |
+
+## 数据对比明细
+
+### 优化前基线
+
+接口：
+
+```text
+POST /api/data-compare/prepare-from-tables
+```
+
+参数：
+
+```text
+source table: main.runtime_probe
+target table: main.runtime_probe_target
+key columns: id
+fetch batch size: 5000
+```
+
+结果：
+
+| 指标 | 值 |
+| --- | ---: |
+| 耗时 | 842 ms |
+| `dbx-web` RSS before | 217,904 KiB（213 MiB） |
+| `dbx-web` RSS peak | 507,504 KiB（496 MiB） |
+| `dbx-web` RSS after | 472,416 KiB（461 MiB） |
+| 响应大小 | 10,291,638 bytes |
+| source rows | 50,000 |
+| target rows | 49,649 |
+| added | 1,351 |
+| removed | 1,000 |
+| modified | 4,865 |
+| sync statements | 7,216 |
+| sync SQL 大小 | 1,537,738 bytes |
+
+判断：数据对比是本轮最高内存来源。原因是后端会同时持有两边 rows、HashMap、diff、sync statements 和完整 sync SQL；请求结束后 RSS 也没有立刻回到对比前。
+
+### 第一轮优化复测
+
+代码改动：
+
+- `crates/dbx-core/src/data_compare.rs`
+- 对比中间态从“每一行都转成 `HashMap<String, Value>`”改为“按列索引保存 `Vec<Value>`，只在 added/removed/modified 输出时组装 HashMap”。
+- 去掉 `prepare_data_compare` 和缺目标表路径里的 `DataCompareResult` clone。
+- 单元格比较改为借用比较，只有确认为变化时才 clone 到返回结果。
+- 同步计划生成改为内部借用 diff，公共 API 和返回字段不变。
+
+复测结果：
+
+| 指标 | 优化前 | 优化后 | 变化 |
+| --- | ---: | ---: | ---: |
+| 耗时 | 842 ms | 942 ms | +100 ms |
+| `dbx-web` RSS before | 217,904 KiB（213 MiB） | 65,168 KiB（64 MiB） | 启动基线更干净 |
+| `dbx-web` RSS peak | 507,504 KiB（496 MiB） | 239,696 KiB（234 MiB） | -267,808 KiB（约 -53%） |
+| `dbx-web` RSS after | 472,416 KiB（461 MiB） | 233,840 KiB（228 MiB） | -238,576 KiB |
+| 响应大小 | 10,291,638 bytes | 10,291,638 bytes | 不变 |
+| added / removed / modified | 1,351 / 1,000 / 4,865 | 1,351 / 1,000 / 4,865 | 不变 |
+| sync statements | 7,216 | 7,216 | 不变 |
+| sync SQL 大小 | 1,537,738 bytes | 1,537,738 bytes | 不变 |
+
+结论：这次优化不改变接口协议和功能结果，主要降低后端比较过程的峰值和结束后的 RSS 留存。剩余内存主要来自必须返回给前端的 diff 详情、`syncStatements` 数组、完整 `syncSql` 字符串以及约 10 MB JSON 响应。
+
+## 功能排名
+
+### 1. 数据对比 Data Compare
+
+原始基线最高。50k 级别两表对比让后端 RSS 峰值接近 496 MiB，且结束后仍约 461 MiB。第一轮优化后，同场景峰值降到约 234 MiB，结束后约 228 MiB。
+
+主要来源：
+
+- 源表 rows + 目标表 rows
+- diff 明细对象
+- sync statements
+- joined sync SQL
+- 约 10 MB JSON 响应
+
+建议：
+
+- 进一步对比可改为主键有序 merge，不一次性保留两边全量 rows。
+- diff 明细分页，默认只返回计数和样例。
+- sync SQL 按需生成或流式下载。
+- 大表对比增加行数阈值和用户确认。
+
+### 2. QueryChart
+
+本轮最高的前端内存增量。基于同一份 5 万行查询结果，打开图表后 JS heap 稳定在约 109 MiB，较图表前增加约 48 MiB；renderer RSS 峰值增加约 138 MiB。
+
+主要来源：
+
+- ECharts / vue-echarts 运行时
+- `xData = rows.map(...)`
+- 每个 Y 列再生成一份 series data
+- Canvas 图表内部缓存
+
+建议：
+
+- 图表默认采样或限制最大点数，例如 5,000。
+- 多 Y 轴列时显示数据点数量并要求确认。
+- 数值列识别用抽样，不扫描全部 rows。
+
+### 3. 查询结果 DataGrid
+
+5 万行、12 列进入 DataGrid 后，JS heap 约 78 MiB，较填 SQL 后增加约 43 MiB；后端 RSS 也从约 53 MiB 增至约 194 MiB。
+
+主要来源：
+
+- 查询结果 rows
+- DataGrid 显示索引和派生结构
+- Canvas 渲染状态
+- 后端查询结果构造和 JSON 序列化
+
+建议：
+
+- 默认 page size 不要轻易升到 50,000。
+- DataGrid 派生数组按可视范围懒生成。
+- 导出和大结果操作走 streaming。
+- 对大结果显示明确内存提示。
+
+### 4. 驱动管理
+
+驱动管理页面 DOM 节点从 426 增到 1,157，但 JS heap 因 GC 从约 112 MiB 降到约 67 MiB，说明它不是当前主要内存来源。它主要增加 DOM 和列表渲染，不像 DataGrid/Chart/DataCompare 那样复制大数据。
+
+### 5. 空数据对比对话框
+
+只打开对话框时 JS heap 从约 109 MiB 到约 111 MiB，增量很小。风险不在弹窗本身，而在点击“开始比较数据”后的后端对比和 diff 明细。
+
+## 未覆盖功能
+
+本轮没有实测以下功能，因为当前环境没有对应服务或没有构造完整数据流：
+
+- Redis Key Browser
+- Mongo 文档浏览
+- 数据传输
+- SQL 文件执行
+- 导出下载全流程
+- ER Diagram / Schema Diff 大 schema 场景
+- AI Assistant 长对话
+
+这些功能仍可能在真实环境中占用较高内存，尤其是 Redis 全量 key、Mongo 宽文档表格视图、导出聚合和大 schema diff。代码风险分析见同目录的 `memory-usage-audit.md`。
+
+## 当前最值得优化的点
+
+1. 继续优化 Data Compare 返回体：第一轮已降峰值，下一步是 diff 分页、SQL 按需生成，减少必须返回给前端的数据量。
+2. 限制 QueryChart 数据点：图表对大结果集的前端复制非常明显。
+3. 限制 DataGrid 大 page size：50,000 行能明显抬高前端和后端内存。
+4. 把 Vite/dev 内存与业务内存分开看：当前开发模式下 Vite RSS 本身可超过 1 GiB，生产 Tauri 或生产 Web 包需要另测。
diff --git a/docs/pips/PIP-0001-database-connection-timeout-recovery.md b/docs/pips/PIP-0001-database-connection-timeout-recovery.md
new file mode 100644
index 0000000..83db548
--- /dev/null
+++ b/docs/pips/PIP-0001-database-connection-timeout-recovery.md
@@ -0,0 +1,470 @@
+# PIP-0001: 数据库连接空闲失效恢复机制
+
+## 状态
+
+Proposed
+
+## 摘要
+
+本 PIP 提议改进 DBX 在 PostgreSQL、openGauss、MySQL 连接空闲失效后的恢复机制，解决 Windows 环境下常见的查询永久执行中、取消无效、连接树持续加载、必须重启应用才能恢复的问题。
+
+核心改动是将连接池检出、连接健康检查、SQL 执行、取消、清理和前端状态恢复纳入统一的超时与恢复模型，避免任一阶段永久挂起。
+
+详细分析和实施计划见：
+
+- `docs/pips/plans/2026-06-24-database-connection-timeout-recovery.md`
+
+## 背景
+
+用户在 Windows 环境下反馈，数据库连接建立后一段时间不活动，再次执行查询时会出现：
+
+- 查询结果区域持续显示执行中。
+- 点击中断无法停止。
+- 连接状态持续转圈，刷新无效。
+- 退出并重启应用后恢复。
+- PostgreSQL、openGauss、MySQL 均受影响。
+
+该问题不是单一数据库驱动或 SQL 语句问题。三个数据库共同受影响，说明问题边界位于 DBX 的连接生命周期管理、超时控制、取消机制和前端状态收敛层。
+
+## 问题定义
+
+当数据库连接空闲后，底层 TCP 连接或数据库会话可能被以下因素静默失效：
+
+- 数据库服务端 idle timeout。
+- VPN、NAT、防火墙、代理的空闲连接回收。
+- Windows 睡眠、网络切换、Wi-Fi/VPN 断开后恢复。
+- TCP 半开连接未及时被操作系统发现。
+
+此时 DBX 仍可能持有旧连接池，并且前端仍认为连接有效。下一次操作可能卡在：
+
+- `ensureConnected`
+- `checkConnectionHealth`
+- pool checkout
+- pool recycle/verify
+- MySQL ping
+- PostgreSQL `SET search_path`
+- SQL 执行或结果读取
+- PostgreSQL cancel request
+- MySQL `KILL QUERY`
+- 连接树元数据刷新
+
+当前系统缺少覆盖以上完整链路的统一执行预算，因此用户看到的现象是“前端一直执行中”，而真正的卡点可能在查询执行之前或取消请求本身。
+
+## 目标
+
+1. 空闲连接失效后，查询、刷新、取消操作都必须在可预期时间内完成或返回明确错误。
+2. 用户无需重启应用即可通过清池、重连恢复。
+3. PostgreSQL、openGauss、MySQL 的恢复行为保持一致。
+4. 前端执行中、取消中、加载中状态必须有兜底清理机制。
+5. 日志能够定位卡住阶段，便于后续排查。
+
+## 非目标
+
+1. 不保证所有服务端 SQL 一定被成功取消。客户端取消和服务端终止是两个不同结果。
+2. 不改变 `query_timeout_secs = 0` 表示禁用 SQL 查询超时的语义。
+3. 不重构所有数据库驱动，仅先覆盖 PostgreSQL、openGauss、MySQL 及共享连接管理链路。
+4. 不改变连接配置的存储结构，除非提供向后兼容默认值。
+
+## 提案
+
+### 1. 引入数据库操作执行预算
+
+为每次数据库操作建立统一预算，覆盖：
+
+- 连接池等待。
+- 新建连接。
+- 回收验证。
+- 健康检查。
+- SQL 执行。
+- 取消请求。
+- 清理连接池。
+
+建议模型：
+
+```rust
+pub struct DbOperationBudget {
+    pub checkout_timeout: Duration,
+    pub connect_timeout: Duration,
+    pub recycle_timeout: Duration,
+    pub query_timeout: Option<Duration>,
+    pub cancel_timeout: Duration,
+    pub cleanup_timeout: Duration,
+}
+```
+
+其中 `query_timeout = None` 仅表示 SQL 执行不设上限；连接检出、健康检查、取消和清理仍必须有安全上限。
+
+#### SQL 执行超时与基础设施超时的边界原则
+
+本 PIP 区分两类超时，语义不可混淆：
+
+**1. SQL 执行超时 — 遵循用户配置**
+
+- `query_timeout_secs = 0`：表示 SQL 执行本身不设超时。前端不得静默将其变为有限值（如 60s）。现有代码已正确处理：前端 `withFrontendQueryTimeout` 在 `timeoutSecs === 0` 时直接返回 promise 不加超时；后端 `resolve_query_timeout` 在 `Some(0)` 时返回 `None`。
+- `query_timeout_secs > 0`：SQL 执行超时为用户配置值。前端兜底超时设为配置值的 2 倍，让后端先触发自己的超时，前端超时仅作为网络异常下的兜底。
+- `query_timeout_secs` 缺失或无效：使用默认值 60s（`DEFAULT_QUERY_TIMEOUT_SECS`）。
+
+**2. 基础设施超时 — 始终有硬性上限**
+
+以下阶段与 SQL 执行无关，即使用户设置 `query_timeout_secs = 0`，也必须有硬性超时上限，否则可能导致应用永久挂起：
+
+- pool checkout（连接池等待）
+- pool create（新建连接）
+- pool recycle（回收验证）
+- 健康检查（ping）
+- 取消请求（PostgreSQL cancel / MySQL KILL QUERY）
+- 连接池清理
+
+这些超时值由 `DbOperationBudget` 中对应的非 `Option` 字段控制，不受 `query_timeout_secs` 影响。
+
+#### checkout 阶段的 cancel token 集成
+
+`deadpool-postgres` 的 `pool.get()` 不原生接受 `CancellationToken`。当前代码中 `pool.get().await` 为裸调用，无法在 checkout 阶段响应取消请求。
+
+统一 checkout helper 应使用 `tokio::select!` 包装 `pool.get()` 以支持取消：
+
+```rust
+async fn checkout_with_cancel(
+    pool: &Pool,
+    cancel_token: Option<CancellationToken>,
+    checkout_timeout: Duration,
+) -> Result<deadpool_postgres::Object, String> {
+    let get_future = tokio::time::timeout(checkout_timeout, pool.get());
+    match cancel_token {
+        Some(token) => {
+            tokio::select! {
+                biased;
+                _ = token.cancelled() => Err("cancelled during pool checkout".to_string()),
+                result = get_future => result.map_err(|e| e.to_string()).and_then(|r| r.map_err(|e| e.to_string())),
+            }
+        }
+        None => get_future.await.map_err(|e| e.to_string()).and_then(|r| r.map_err(|e| e.to_string())),
+    }
+}
+```
+
+当取消触发时，`pool.get()` future 被 drop，deadpool 内部会正确回滚等待状态。checkout timeout 通过 `tokio::time::timeout` 实现，超时错误应归类为连接错误并触发清池。
+
+### 2. 补齐 PostgreSQL/openGauss pool timeout
+
+PostgreSQL/openGauss 共用 `PoolKind::Postgres`。创建 `deadpool-postgres` pool 时应显式配置：
+
+- wait timeout
+- create timeout
+- recycle timeout
+
+同时在项目层统一包装 `pool.get()`，确保 checkout/recycle 阶段错误可被归类为连接池失效并触发恢复。
+
+### 3. 统一 MySQL checkout 和 cancel 保护
+
+MySQL 现有 `get_conn_with_health_check` 是有效的局部保护，但需要纳入统一执行预算。
+
+需要补齐：
+
+- `kill_query_with_opts` 的建连 timeout。
+- `KILL QUERY` 执行 timeout。
+- 元数据、事务、导出等路径中的直接 `pool.get_conn()` 审计。
+- MySQL `tcp_keepalive` 默认配置。
+
+### 4. 改进取消机制
+
+取消请求必须覆盖两个阶段：
+
+- SQL 已经在服务端执行：发送 PostgreSQL cancel 或 MySQL `KILL QUERY`。
+- 尚未进入 SQL 执行，例如卡在 checkout/health check：取消客户端任务，标记连接池可疑，并按策略清理 pool。
+
+PostgreSQL TLS 连接取消必须使用与原连接兼容的 TLS connector，避免当前 `cancel_query(NoTls)` 在 TLS 场景下失败。
+
+#### TLS cancel 改造说明
+
+当前代码 `cancel_postgres_query` 使用 `NoTls` 调用 `pg_cancel_token.cancel_query(NoTls)`。`tokio_postgres::CancelToken::cancel_query` 需要显式传入 `MakeSslConnect` 参数，**不会自动升级到 SSL**。若 PostgreSQL 服务器配置了 `hostssl` 或强制 TLS，`NoTls` 的 cancel 请求会被服务器拒绝。
+
+改造步骤：
+
+1. **验证阶段**：在改造前先编写测试验证当前驱动版本在 TLS 连接场景下 `cancel_query(NoTls)` 的实际行为，确认是否确实失败（服务器是否接受非 TLS cancel 请求取决于 `pg_hba.conf` 配置）。
+2. **存储 TLS connector**：在创建连接池时，将 `MakeRustlsConnect` 实例（或等价 TLS 配置）与 `CancelToken` 一并存储，使 cancel 时能重建正确的 TLS 连接。
+3. **重建 connector**：由于 `MakeRustlsConnect` 不一定实现 `Clone`，可能需要在 cancel 时从原始 `pg_config` 和 SSL 配置重新构建 connector。
+4. **不降低证书校验**：cancel connector 必须使用与原连接相同的证书校验级别，不能为了 cancel 成功而降低安全性。
+
+改造后的 `cancel_postgres_query` 签名应类似：
+
+```rust
+async fn cancel_postgres_query(
+    pg_cancel_token: tokio_postgres::CancelToken,
+    tls: tokio_postgres_rustls::MakeRustlsConnect,
+) {
+    match tokio::time::timeout(Duration::from_secs(5), pg_cancel_token.cancel_query(tls)).await {
+        Ok(Ok(())) => {}
+        Ok(Err(err)) => log::warn!("Failed to send PostgreSQL cancel request: {err}"),
+        Err(_) => log::warn!("Timed out sending PostgreSQL cancel request"),
+    }
+}
+```
+
+### 5. 前端状态兜底恢复
+
+前端需要对以下阶段设置超时并清理状态：
+
+- `ensureConnected`
+- `checkConnectionHealth`
+- `executeMulti`
+- `cancelQuery`
+- 连接树元数据刷新
+
+#### 各阶段超时值定义
+
+| 阶段 | 超时值 | 计算规则 | 说明 |
+|------|--------|----------|------|
+| `ensureConnected`（首次连接） | `connect_timeout_secs + 2s` | `connectionAttemptTimeoutMs(config)` | 已有实现，复用现有逻辑。Agent 驱动类型有 30s 下限。 |
+| `ensureConnected`（健康检查快路径） | 5s | 固定值 | 当 `hasRecentConnectionHealthCheck` 为 true 时跳过；否则调用 `checkConnectionHealth`，需加 5s 超时。当前代码缺少此超时。 |
+| `checkConnectionHealth` | `max(connect_timeout_secs * 2, 5s)` | 基于连接超时倍数 | 健康检查应在连接超时的 2 倍内完成，但不低于 5s。当前代码无超时保护。 |
+| `executeMulti`（SQL 执行） | `query_timeout_secs > 0` 时为 `query_timeout_secs * 2`；`query_timeout_secs = 0` 时为 `0`（不设超时） | 前端超时是后端超时的 2 倍，让后端先触发自己的超时 | 现有实现已正确处理：`queryTimeoutSecs === 0 ? 0 : frontendTimeoutSecs`。前端超时仅作为兜底，不是 SQL 执行本身的超时控制。 |
+| `cancelQuery` | 10s | 固定值 | 取消请求应在 10s 内返回。超时后强制清理 `isCancelling` 状态。当前代码无超时保护。 |
+| 连接树元数据刷新 | `max(query_timeout_secs + 5s, 15s)` | 复用 `metadataLoadTimeoutMs` | 已有实现，`query_timeout_secs = 0` 时使用 60s。 |
+
+所有超时触发后必须清理：
+
+- `isExecuting`
+- `isCancelling`
+- `executionId`
+- 连接节点 `isLoading`
+
+若错误表明连接失效，应调用连接丢失处理，并提供重新连接入口。
+
+### 6. 默认启用更适合桌面环境的 keepalive
+
+#### 当前默认值不一致问题
+
+现有代码存在两层 keepalive 默认值不一致：
+
+- **Rust 模型层**：`default_keepalive_interval_secs()` 返回 `60`（开启），通过 `#[serde(default = "default_keepalive_interval_secs")]` 生效。从 Rust API（web 后端、测试代码等）直接创建的 `ConnectionConfig` 默认 keepalive 为 60 秒。
+- **前端 UI 层**：`ConnectionDialog.vue` 中 `config.keepalive_interval_secs = ... ?? 0`（关闭）。从前端保存的连接配置默认 keepalive 为 0（关闭）。
+
+这意味着从前端 UI 创建的连接和从 Rust API 直接创建的连接在 keepalive 行为上不一致。P1-1 必须统一两层默认值策略。
+
+#### 统一策略
+
+应用层 keepalive 统一默认开启：
+
+- 默认间隔：30 秒（前后端统一使用此值作为默认值）。
+- 修改 `default_keepalive_interval_secs()` 返回 `30`，同步修改前端 `ConnectionDialog.vue` 的 fallback 值为 `30`。
+- 用户可以关闭（设为 0）。
+- 关闭时提示可能受 VPN/NAT/防火墙 idle timeout 影响。
+
+驱动层建议：
+
+- PostgreSQL/openGauss：默认注入或设置短周期 TCP keepalive。
+- MySQL：设置 `tcp_keepalive=30000` 或等价 builder 参数。
+
+keepalive 是预防手段，不能替代超时和清池恢复。
+
+### 7. 增加阶段化日志
+
+每个查询或刷新操作输出阶段日志：
+
+- `ensureConnected`
+- `pool.checkout`
+- `pool.recycle`
+- `ping`
+- `schema.set`
+- `query.execute`
+- `result.fetch`
+- `cancel`
+- `cleanup`
+
+日志应包含：
+
+- `trace_id`
+- `connection_id`
+- `database`
+- `db_type`
+- `pool_key`
+- `client_session_id`
+- `stage`
+- `elapsed_ms`
+- `timeout_ms`
+- `error`
+
+## 兼容性
+
+### 查询超时
+
+`query_timeout_secs = 0` 继续表示不限制 SQL 执行时间。这一语义在前后端必须保持一致：
+
+- **后端**：`resolve_query_timeout(Some(0))` 返回 `None`，SQL 执行不受 `tokio::time::timeout` 约束。
+- **前端**：`withFrontendQueryTimeout` 在 `timeoutSecs === 0` 时直接返回 promise，不施加前端超时。
+
+本 PIP 不得在任何路径中静默将 `query_timeout_secs = 0` 变为有限 SQL 超时。连接检出、健康检查、取消、清理属于基础设施阶段，必须有独立于 `query_timeout_secs` 的硬性上限（见"SQL 执行超时与基础设施超时的边界原则"）。
+
+### MySQL session-scoped pool
+
+MySQL session-scoped pool 用于保留临时表、用户变量等会话状态。清理策略不得在正常连续查询时破坏该行为。只有明确空闲超时、连接失效、用户关闭 tab 或用户强制断开时才清理。
+
+### PostgreSQL search_path
+
+PostgreSQL/openGauss 的 schema 执行上下文行为保持不变，但 `SET search_path` 和 `RESET search_path` 必须纳入超时和错误恢复。
+
+### 清池操作的并发安全
+
+清池操作（`remove_pool_by_key`、`remove_connection_pools_detached`、`close_database_pool`）通过 `RwLock` 保护 `connections` HashMap。需要明确以下并发场景：
+
+#### 1. 清池对在途查询的影响
+
+- **已 checkout 的连接不受影响**：当 `pool.get()` 成功返回 `Object` 后，调用方持有该连接的引用。即使 pool 从 HashMap 中移除，已 checkout 的连接仍可正常使用，直到 `Object` 被 drop 时归还到原 pool（此时原 pool 可能已被关闭，连接被直接丢弃）。
+- **新 checkout 请求失败**：pool 从 HashMap 移除后，新的 `pool.get()` 请求将找不到 pool，触发重连流程。
+- **结论**：清池操作是安全的，不会中断在途查询，但新请求会触发重连。
+
+#### 2. base pool 与 session-scoped pool 的清理顺序
+
+- `close_database_pool` 先收集所有需要清理的 key（base pool key + session pool keys），然后统一获取写锁批量移除。
+- 清理顺序：先停止 keepalive task → 清理 pool_activity → 获取 connections 写锁批量移除 → 关闭移除的 pools。
+- **要求**：不允许在持有 `connections` 写锁的同时执行 pool 内部操作（如 `close_pool_kind`），避免死锁。当前代码在 drop 写锁后才调用 `close_pool_kind`，符合此要求。
+
+#### 3. 并发清池的竞态条件
+
+- 多个操作可能同时触发同一 pool 的清理（如超时清理 + 用户手动断开）。`remove_pool_by_key` 通过写锁保证幂等性：第二次调用时 `remove` 返回 `None`，不会重复关闭。
+- **要求**：P2 实施时确保所有清池入口都通过 `remove_pool_by_key` 或 `drain_connection_pools` 统一路径，不绕过写锁直接操作 HashMap。
+
+## 分阶段实施
+
+### 阶段 1：止血
+
+目标：避免永久卡死。
+
+范围：
+
+- PostgreSQL/openGauss pool checkout、create、recycle 加 timeout。
+- MySQL cancel 加 timeout。
+- 前端 `ensureConnected`、`checkConnectionHealth`、`cancelQuery` 加兜底超时。
+- 超时后清理 UI 执行状态。
+
+验收：
+
+- 数据库不可达时，查询、取消、刷新都能在可预期时间内返回。
+
+### 阶段 2：自动恢复
+
+目标：空闲失效后可自动重连或明确失败。
+
+范围：
+
+- 统一 checkout helper。
+- pool checkout/ping timeout 进入连接错误分类。
+- 连接错误后清理对应 pool。
+- 添加强制清池和重新连接入口。
+
+#### timeout 错误消息格式与 is_connection_error 匹配
+
+当前 `is_connection_error` 通过 `lower.contains("timed out")` 匹配超时错误，仅排除 `starts_with("query timed out after ")` 格式。需要确保以下各 timeout 场景的错误消息能被正确分类：
+
+| 场景 | 错误来源 | 错误消息格式（lowercase） | 当前是否匹配 | 处理方式 |
+|------|----------|---------------------------|--------------|----------|
+| DBX query timeout | `tokio::time::timeout` | `"query timed out after {n} seconds"` | 已排除（`is_dbx_query_timeout_error`） | 保持排除，不触发清池 |
+| PostgreSQL pool checkout timeout | `deadpool-postgres PoolError::Timeout(TimeoutType::Wait)` | `"pool wait timeout"` | **不匹配**（是 "timeout" 不是 "timed out"） | 需新增匹配 `"pool"` + `"timeout"` 组合，或匹配 deadpool 的 `TimeoutType` 枚举变体 |
+| PostgreSQL pool create timeout | `deadpool-postgres PoolError::Timeout(TimeoutType::Create)` | `"pool create timeout"` | **不匹配** | 同上 |
+| PostgreSQL pool recycle timeout | `deadpool-postgres PoolError::Timeout(TimeoutType::Recycle)` | `"pool recycle timeout"` | **不匹配** | 同上 |
+| checkout helper 超时（`tokio::time::timeout` 包装） | 自定义 `tokio::time::timeout` | `"elapsed"` 或自定义消息 | **不匹配** | checkout helper 应返回包含 `"connection"` 或 `"checkout timed out"` 的错误消息 |
+| MySQL ping timeout | 自定义 `tokio::time::timeout` | 自定义消息 | 取决于消息内容 | 确保消息包含 `"connection"` 或 `"timed out"` |
+| Agent RPC timeout | Agent 驱动 | `"agent rpc call timed out ..."` | 已排除（`is_agent_rpc_timeout_error`） | 保持排除 |
+
+实施要求：
+
+1. checkout helper 返回的错误消息应包含 `"checkout timed out"` 或 `"connection"` 关键词，确保 `is_connection_error` 能正确匹配。
+2. 对于 deadpool 的 `PoolError::Timeout`，应在错误转换层（如 `pg_pool_error_to_string`）统一添加 `"timed out"` 关键词，或在 `is_connection_error` 中新增 `"pool"` + `"timeout"` 组合匹配。
+3. P2 实施时需编写单元测试覆盖以上每种 timeout 场景的错误分类。
+
+验收：
+
+- 数据库恢复后，不重启应用即可重新查询。
+
+### 阶段 3：预防
+
+目标：减少空闲失效概率。
+
+范围：
+
+- 默认开启应用层 keepalive。
+- PostgreSQL/openGauss 设置短周期 TCP keepalive。
+- MySQL 设置 `tcp_keepalive`。
+- 对齐 idle timeout 和 driver inactive TTL。
+
+验收：
+
+- 常规 Windows/VPN/NAT 环境下，空闲后连接可用或能自动恢复。
+
+### 阶段 4：可观测性
+
+目标：后续问题可定位。
+
+范围：
+
+- 阶段化日志。
+- 连接诊断信息。
+- 断链复现脚本和 QA 手册。
+
+验收：
+
+- 用户报告“执行中”时，可以从日志判断卡在具体阶段。
+
+## 测试计划
+
+### 自动化测试
+
+- PostgreSQL/openGauss：pool checkout timeout、query timeout、cancel timeout。
+- MySQL：ping timeout、kill query timeout、connection error 分类。
+- 前端：执行超时后清理 tab 状态；取消超时后清理 `isCancelling`；连接树刷新失败后清理 loading。
+
+### 手工测试
+
+Windows 环境验证：
+
+1. 建立 PostgreSQL/openGauss/MySQL 连接。
+2. 执行 `SELECT 1`。
+3. 停止数据库或断开 VPN。
+4. 再次执行 `SELECT 1`。
+5. 验证 UI 不永久执行中。
+6. 恢复数据库或 VPN。
+7. 验证无需重启应用即可重连恢复。
+
+取消验证：
+
+- PostgreSQL/openGauss：`SELECT pg_sleep(60)`。
+- MySQL：`SELECT SLEEP(60)`。
+- 点击取消后，UI 必须在 2 到 5 秒内退出取消中状态。
+
+## 风险
+
+- 过早清理 session-scoped pool 可能破坏会话状态。
+- TLS cancel 改造需要复用正确证书配置，不能降低证书校验。
+- 默认 keepalive 会增加少量后台请求。
+- 部分半开 TCP 场景难以稳定自动化复现。
+- 将所有 timeout 都视为连接失效可能误伤慢网络，需要区分 query timeout 与 checkout/ping/cancel timeout。
+
+## 回滚策略
+
+可独立回滚：
+
+- keepalive 默认值。
+- 新增 UI 诊断入口。
+- 连接参数默认注入策略。
+
+不建议回滚：
+
+- pool checkout timeout。
+- cancel timeout。
+- UI 状态兜底清理。
+
+这些属于防止应用永久挂起的基础安全边界。
+
+## 验收标准
+
+1. PostgreSQL、openGauss、MySQL 空闲失效后，查询不会永久执行中。
+2. 中断操作不会永久取消中。
+3. 连接树刷新不会永久加载中。
+4. 数据库或网络恢复后，不重启应用即可重新连接。
+5. 日志能指出失败阶段。
+6. 自动化和手工测试覆盖查询、取消、健康检查、元数据刷新、空闲清理和重连恢复。
+
+## 相关文档
+
+- `docs/pips/plans/2026-06-24-database-connection-timeout-recovery.md`
diff --git a/docs/pips/plans/2026-06-24-database-connection-timeout-recovery.md b/docs/pips/plans/2026-06-24-database-connection-timeout-recovery.md
new file mode 100644
index 0000000..fe35ee7
--- /dev/null
+++ b/docs/pips/plans/2026-06-24-database-connection-timeout-recovery.md
@@ -0,0 +1,561 @@
+# 数据库连接空闲失效恢复方案
+
+## Goal
+
+解决 Windows 环境下数据库连接空闲后再次使用时查询、刷新、取消操作卡死的问题。方案覆盖 PostgreSQL、openGauss、MySQL，并将问题边界从单一驱动缺陷上升到连接生命周期、超时、取消、连接池恢复和前端状态收敛的统一治理。
+
+## Architecture
+
+DBX 桌面端的相关链路由三层组成：
+
+1. 前端 Vue/Pinia 状态层：负责 `ensureConnected`、查询发起、取消、连接树刷新、执行中状态展示。
+2. Tauri 命令层：负责把前端请求转发到 Rust core，并注册运行中的查询。
+3. Rust core 数据库层：负责连接配置、连接池、健康检查、keepalive、查询执行、取消和清池。
+
+问题发生在跨层边界：底层数据库连接或 TCP 会话已经失效，但前端仍显示连接有效，后端仍复用旧连接池。再次查询时，任务可能卡在连接池检出、连接验证、健康检查、schema 设置、SQL 执行、结果读取或取消请求中。
+
+## Tech Stack
+
+- Desktop: Tauri + Vue + Pinia
+- Backend: Rust async/Tokio
+- PostgreSQL/openGauss: `deadpool-postgres` + `tokio-postgres-gaussdb`
+- MySQL: `mysql_async`
+- Query state: `apps/desktop/src/stores/queryStore.ts`
+- Connection state: `apps/desktop/src/stores/connectionStore.ts`
+- Core owners:
+  - `crates/dbx-core/src/connection.rs`
+  - `crates/dbx-core/src/query.rs`
+  - `crates/dbx-core/src/db/postgres.rs`
+  - `crates/dbx-core/src/db/mysql.rs`
+  - `src-tauri/src/commands/query.rs`
+  - `src-tauri/src/commands/connection.rs`
+
+## Baseline/Authority Refs
+
+本方案基于以下已核对的代码事实：
+
+- PostgreSQL/openGauss 走 `PoolKind::Postgres`：`crates/dbx-core/src/connection.rs`
+- MySQL 走 `PoolKind::Mysql`，且已有 `get_conn_with_health_check`：`crates/dbx-core/src/db/mysql.rs`
+- 前端查询前会执行 `ensureConnected`，查询 Promise 的前端超时只覆盖 `api.executeMulti`：`apps/desktop/src/stores/queryStore.ts`
+- `keepalive_interval_secs` 在前端规范化时默认为 `0`，应用层 keepalive 默认关闭：`apps/desktop/src/stores/connectionStore.ts`
+- `deadpool-postgres` 当前配置了 `RecyclingMethod::Verified` 和 `wait_timeout`，但没有显式配置 create/recycle timeout。
+- PostgreSQL `CancelToken` 会根据 token 内部 SSL mode 建立取消连接；当前项目调用 `cancel_query(NoTls)`，TLS 连接取消存在高风险。
+
+## Compatibility Boundary
+
+改动必须保持以下兼容性：
+
+- 不改变连接配置的序列化结构，除非提供默认值和迁移兼容。
+- 不破坏 MySQL session-scoped pool 保留临时表、用户变量等会话状态的行为。
+- PostgreSQL/openGauss 的 schema/search_path 行为保持不变。
+- 查询超时为 `0` 时仍表示禁用用户 SQL 查询超时，但连接检出、健康检查、取消、清理操作仍必须有安全上限，避免进程内任务永久挂起。
+- 取消和超时可以结束客户端等待，但不能假装服务端一定已经停止 SQL；UI 文案必须区分“已发送取消请求”和“客户端已停止等待并标记连接失效”。
+
+## Verification
+
+验收必须覆盖：
+
+- PostgreSQL、openGauss、MySQL 空闲后首次查询：在配置超时时间内成功或返回明确错误。
+- 长查询取消：`pg_sleep`、`SLEEP` 类查询在 2 到 5 秒内退出前端执行中状态。
+- 断网、VPN 断开、数据库重启：不需要重启 DBX 即可通过重连恢复。
+- 连接树刷新：后端不可达时不会持续转圈。
+- 任务泄漏：重复触发超时/取消后，运行中查询记录和连接池数量不会持续增长。
+
+## 原报告合理性评估
+
+用户提供的 `连接问题报告.txt` 方向基本合理：问题不是某一种数据库的 SQL 或驱动语法错误，而是连接生命周期管理缺陷。报告将影响范围扩展到 PostgreSQL、openGauss、MySQL 是正确的。
+
+但报告中有几处需要修正，避免形成错误实现方向：
+
+| 报告原判断 | 评估 | 修正后表述 |
+| --- | --- | --- |
+| PostgreSQL/openGauss `pool.get()` 无超时保护 | 基本成立，但不完整 | 项目只显式设置 deadpool `wait_timeout`；连接 create/recycle 验证没有在项目层统一纳入查询超时和取消边界。 |
+| `RecyclingMethod::Verified` 发送 `SELECT 1` | 不准确 | deadpool Verified 执行验证 query；项目自己的 stale check 和 keepalive 使用 `SELECT 1`。 |
+| PostgreSQL TLS 连接取消一定失败 | 方向成立但需复现确认 | 当前调用 `cancel_query(NoTls)`，TLS 连接取消存在高风险，应改为使用与原连接一致的 TLS connector。 |
+| 应用层 keepalive 无超时 | 不准确 | `start_keepalive_task` 外层已有 `tokio::time::timeout`；主要问题是默认关闭、覆盖面不足、健康检查和执行链路超时边界不统一。 |
+| MySQL 取连接失败会跳过外层重连逻辑 | 单条查询场景不准确 | `do_execute` 返回错误后，外层仍会进入 `pool_error_action`；但 MySQL 仍存在取消无超时、部分元数据路径直接取连接、session pool 恢复不完整等问题。 |
+| 未配置 TCP keepalive | 需要细化 | PostgreSQL 驱动默认启用 TCP keepalive，但默认 idle 约 2 小时，不适合桌面/VPN/NAT 场景；MySQL 当前未显式设置 `tcp_keepalive`。 |
+
+## 修正版问题报告
+
+### 问题描述
+
+在 Windows 电脑上，用户连接 PostgreSQL、openGauss、MySQL 后，如果一段时间不操作，再次执行 SQL 或刷新连接树时可能出现：
+
+- 查询结果区域一直显示执行中。
+- 中断按钮无法结束任务。
+- 连接树刷新持续转圈。
+- 断开、刷新后仍无法恢复。
+- 退出并重新打开应用后恢复。
+
+### 根因判断
+
+根因不是单一数据库驱动缺陷，而是跨数据库的连接生命周期恢复策略不完整。
+
+当连接空闲后，数据库服务端、VPN、防火墙、NAT、代理、Windows 睡眠或网络切换都可能让底层 TCP/数据库会话失效。客户端连接池仍保存旧连接，前端也仍认为连接有效。下一次操作触发旧连接复用时，任务可能卡在以下任一阶段：
+
+- 前端 `ensureConnected`
+- 后端 `checkConnectionHealth`
+- pool checkout
+- pool recycle/verify
+- 新建连接
+- MySQL ping
+- PostgreSQL `SET search_path`
+- SQL 执行
+- 结果流读取
+- PostgreSQL cancel request
+- MySQL `KILL QUERY`
+- 连接树元数据加载
+
+当前系统缺少一个覆盖以上阶段的统一执行预算和恢复机制，因此会出现“查询超时设置存在，但 UI 仍卡住”、“取消按钮可点，但无法停止底层任务”、“刷新连接树也恢复不了”的现象。
+
+### PostgreSQL/openGauss 关键风险
+
+PostgreSQL 和 openGauss 共用 `PoolKind::Postgres` 路径，因此同一类问题会同时影响两者。
+
+主要风险：
+
+- `execute_query_with_max_rows_and_cancel` 先 `pool.get()`，之后才进入 `wait_postgres_query`。如果卡在 pool checkout 或 recycle 阶段，用户查询超时和 cancel token 覆盖不到。
+- `execute_query_with_schema_and_max_rows_and_cancel` 中 `SET search_path` 和 `RESET search_path` 不在同一个统一可取消预算内。
+- `deadpool-postgres` 只配置 `wait_timeout`，应补齐 `create` 和 `recycle` timeout。
+- PostgreSQL cancel 当前传入 `NoTls`，TLS 连接取消存在失败风险。
+- TCP keepalive 默认周期过长，不能满足桌面网络环境下快速发现半开连接的需求。
+
+### MySQL 关键风险
+
+MySQL 已有 `get_conn_with_health_check`，会对取出的连接做 ping，并在失败后尝试重新取连接。这是有价值的局部修复，但仍不足以覆盖整体问题。
+
+主要风险：
+
+- 单条查询路径中取连接和 ping 发生在 SQL 查询超时包装之前，虽然内部有 5 秒超时，但没有统一纳入任务阶段和 UI 取消模型。
+- `kill_query_with_opts` 新建连接和执行 `KILL QUERY` 没有显式 timeout。
+- MySQL pool `inactive_connection_ttl` 固定为 300 秒，可能大于企业网络设备或数据库 `wait_timeout`。
+- `tcp_keepalive` 未显式设置，依赖系统默认行为。
+- 元数据、导出、事务等路径中仍存在直接 `pool.get_conn()` 或连接操作，需要统一审计。
+
+### 前端状态风险
+
+前端 `executeTabSql` 的主要执行状态由 Tauri command 的 resolve/reject 驱动。若后端任务卡在不可取消阶段，前端会持续等待。虽然局部有 `withFrontendQueryTimeout`，但它不覆盖 `ensureConnected` 和所有元数据刷新路径，也不能停止后端任务。
+
+结果是：
+
+- UI 可恢复和后端真实任务停止不是同一件事。
+- 前端可能显示错误或超时，但后端旧任务仍持有连接池引用。
+- 后续刷新和查询继续撞到旧池或旧任务状态。
+
+## 改进方案
+
+### P0-1：建立统一数据库操作执行预算
+
+新增一个后端执行预算模型，覆盖连接获取、健康检查、SQL 执行、取消和清理。
+
+建议在 `crates/dbx-core/src/query.rs` 或新模块中定义：
+
+```rust
+pub struct DbOperationBudget {
+    pub checkout_timeout: Duration,
+    pub connect_timeout: Duration,
+    pub recycle_timeout: Duration,
+    pub query_timeout: Option<Duration>,
+    pub cleanup_timeout: Duration,
+    pub cancel_timeout: Duration,
+}
+```
+
+默认策略：
+
+- checkout/connect/recycle：使用连接配置的 `connect_timeout_secs`，下限 1 秒，上限 300 秒。
+- query：使用 `query_timeout_secs`；`0` 表示不限制 SQL 执行。
+- cleanup/cancel：固定 2 到 5 秒，不允许禁用。
+
+验收：
+
+- 即使用户设置 query timeout 为 0，pool checkout、健康检查和取消操作也不会永久挂起。
+
+### P0-2：补齐 PostgreSQL deadpool timeout
+
+在 `crates/dbx-core/src/db/postgres.rs` 创建 pool 时，显式配置 deadpool 的 `wait/create/recycle` timeout。
+
+当前风险代码形态：
+
+```rust
+let pool = Pool::builder(mgr)
+    .max_size(10)
+    .runtime(Runtime::Tokio1)
+    .wait_timeout(Some(timeout))
+    .build()?;
+```
+
+目标：
+
+- `wait_timeout = timeout`
+- `create_timeout = timeout`
+- `recycle_timeout = timeout`
+
+同时，项目层仍应对 `pool.get()` 包一层明确 timeout，并将错误归类为连接错误或 pool stale。
+
+验收：
+
+- PostgreSQL/openGauss 空闲断链后，`pool.get()` 在 timeout 内返回错误并触发清池或重连。
+
+### P0-3：统一 pool checkout helper
+
+新增或抽象以下 helper，避免各处散落 `pool.get()`、`pool.get_conn()`：
+
+- `checkout_postgres_client(pool, budget)`
+- `checkout_mysql_conn(pool, budget)`
+- `run_with_connection_recovery(state, pool_key, operation)`
+
+要求：
+
+- 支持 cancel token。
+- 支持 timeout。
+- 错误统一进入 `pool_error_action`。
+- timeout 后标记 pool stale 或直接 remove。
+
+受影响文件：
+
+- `crates/dbx-core/src/db/postgres.rs`
+- `crates/dbx-core/src/db/mysql.rs`
+- `crates/dbx-core/src/query.rs`
+- `crates/dbx-core/src/connection.rs`
+
+验收：
+
+- grep 不应再出现关键执行路径中未包装的 `pool.get().await` 和 `pool.get_conn().await`。
+
+### P0-4：修复取消路径
+
+PostgreSQL：
+
+- 将 `cancel_postgres_query` 改为接收或重建正确 TLS connector。
+- 对 cancel request 保持 2 秒 timeout。
+- cancel 失败时，将当前连接池标记为可疑，必要时清理 session-scoped pool。
+
+MySQL：
+
+- `kill_query_with_opts` 中 `Conn::new(opts)` 添加 timeout。
+- `query_drop("KILL QUERY ...")` 添加 timeout。
+- kill 失败不应阻塞前端取消状态收敛。
+
+前端：
+
+- cancel 请求超时后，前端必须退出 `isCancelling`。
+- 如果后端确认无法取消，应显示“已停止等待，连接可能已失效”，并提供重新连接入口。
+
+验收：
+
+- `SELECT pg_sleep(60)` 和 `SELECT SLEEP(60)` 取消后，UI 2 到 5 秒内退出执行中状态。
+
+### P0-5：前端状态必须有兜底恢复
+
+改造 `apps/desktop/src/stores/queryStore.ts`：
+
+- `ensureConnected` 阶段加入前端超时。
+- `api.executeMulti` 超时后，主动调用 cancel。
+- cancel 超时后，清理当前 tab 的 `isExecuting`、`isCancelling`、`executionId`。
+- 对连接错误调用 `markConnectionLost`，同时清理连接树 loading 状态。
+
+改造 `apps/desktop/src/stores/connectionStore.ts`：
+
+- `checkConnectionHealth` 加前端超时。
+- 刷新连接树失败后必须清理 node loading。
+- 增加“强制重连/清理连接池”动作，调用后端清池命令。
+
+验收：
+
+- 任意失败路径都不能让 tab 永久处于执行中。
+- 任意刷新失败都不能让连接节点永久转圈。
+
+### P1-1：调整 keepalive 默认策略
+
+建议默认开启应用层 keepalive：
+
+- `keepalive_interval_secs = 30`
+- UI 中允许用户关闭，但关闭时提示可能受 VPN/NAT/防火墙 idle timeout 影响。
+
+PostgreSQL/openGauss：
+
+- 如果用户未在 URL 参数中指定 keepalive，默认注入：
+  - `keepalives=1`
+  - `keepalives_idle=30`
+  - `keepalives_interval=10`
+  - `keepalives_retries=3`
+
+MySQL：
+
+- 如果用户未指定 `tcp_keepalive`，默认使用 `tcp_keepalive=30000` 或 builder 设置。
+
+注意：
+
+- TCP keepalive 是预防手段，不是唯一恢复机制。
+- 企业网络 idle timeout 可能短于 30 秒，仍需要应用层超时和清池。
+
+验收：
+
+- 新建 PostgreSQL/openGauss/MySQL 连接默认具备短周期 keepalive。
+- 老连接读取时通过 normalize 补默认值，但不覆盖用户显式配置。
+
+### P1-2：统一 idle timeout 语义
+
+当前语义混杂：
+
+- `idle_timeout_secs` 主要用于 session-scoped pool 清理。
+- MySQL driver pool 有 `inactive_connection_ttl=300s`。
+- PostgreSQL pool 没有等价空闲 TTL。
+
+建议拆分语义：
+
+- `client_session_idle_timeout_secs`：清理 tab/session scoped pool。
+- `pool_inactive_connection_ttl_secs`：驱动池空闲连接最大保留时间。
+- `keepalive_interval_secs`：应用层 ping 间隔。
+
+若暂不改配置结构，则先将 MySQL `inactive_connection_ttl` 与 `idle_timeout_secs` 对齐，并为 PostgreSQL 使用应用层 keepalive 和 session pool cleanup 弥补。
+
+验收：
+
+- session-scoped pool 空闲后按配置被清理。
+- base pool 不因短 idle timeout 破坏正常连接复用。
+
+### P1-3：统一连接错误分类
+
+当前 `is_connection_error` 覆盖较宽，包含 `timed out` 等词，需保留同时避免误判普通 SQL 超时。
+
+改进：
+
+- 保留 `Query timed out after ...` 不作为连接错误的特殊规则。
+- 将 pool checkout timeout、ping timeout、cancel connect timeout 归类为连接/池错误。
+- 将 SQL 执行 timeout 归类为 query timeout，并按数据库类型决定是否清池。
+
+验收：
+
+- 单纯慢 SQL 超时不会被错误提示为配置错误。
+- 半开连接导致的 checkout/ping/cancel timeout 会触发清池或重连。
+
+### P2-1：增加阶段化日志
+
+每个 query execution id 输出阶段日志：
+
+- `ensureConnected:start/done/error`
+- `pool.checkout:start/done/error`
+- `pool.recycle:start/done/error`
+- `ping:start/done/error`
+- `schema.set:start/done/error`
+- `query:start/done/error`
+- `cancel:start/done/error`
+- `cleanup:start/done/error`
+
+日志字段：
+
+- `trace_id`
+- `connection_id`
+- `database`
+- `db_type`
+- `pool_key`
+- `client_session_id`
+- `stage`
+- `elapsed_ms`
+- `timeout_ms`
+- `error`
+
+验收：
+
+- 用户报告卡住时，可以从日志判断卡在前端、Tauri 命令、pool checkout、SQL 执行还是 cancel。
+
+### P2-2：增加强制诊断和恢复入口
+
+UI 增加连接级操作：
+
+- 检查连接健康
+- 强制断开并清理连接池
+- 重新连接
+- 复制诊断信息
+
+诊断信息包括：
+
+- 连接类型
+- 当前连接状态
+- 活跃查询数量
+- pool key 列表
+- 最近一次健康检查结果
+- 最近一次错误
+
+验收：
+
+- 用户不需要重启应用即可清理旧连接池并重新连接。
+
+## 推荐实施顺序
+
+### 阶段 1：止血
+
+目标：不再永久卡死。
+
+任务：
+
+1. PostgreSQL pool get/create/recycle 加 timeout。
+2. MySQL kill query 加 timeout。
+3. 前端 `ensureConnected` 和 `checkConnectionHealth` 加超时。
+4. cancel 超时后强制恢复 UI 状态。
+5. timeout/连接错误后清理对应 pool。
+
+验收：
+
+- 三类数据库无法访问时，查询和刷新都能在可预期时间内结束。
+
+### 阶段 2：恢复
+
+目标：空闲断链后自动重连或明确失败。
+
+任务：
+
+1. 统一 checkout helper。
+2. pool checkout/ping 错误进入 `pool_error_action`。
+3. session-scoped pool 清理覆盖查询、count、explain、export。
+4. 新增强制重连/清池入口。
+
+验收：
+
+- 数据库恢复后，不重启应用即可重新查询。
+
+### 阶段 3：预防
+
+目标：减少空闲断链发生概率。
+
+任务：
+
+1. 默认开启应用层 keepalive。
+2. 设置 PostgreSQL/openGauss TCP keepalive 参数。
+3. 设置 MySQL `tcp_keepalive`。
+4. 对齐 idle timeout 与 inactive TTL。
+
+验收：
+
+- 空闲 5 到 30 分钟后，常规网络环境下连接仍可用或能自动重连。
+
+### 阶段 4：可观测性
+
+目标：后续问题能快速定位。
+
+任务：
+
+1. 阶段化日志。
+2. 连接诊断面板。
+3. 测试环境断链脚本。
+
+验收：
+
+- QA 可以稳定复现并判断卡点阶段。
+
+## 测试方案
+
+### 单元测试
+
+建议新增或扩展：
+
+- `crates/dbx-core/src/query.rs`
+  - `pool_error_action` 对 checkout timeout、ping timeout、query timeout 的分类。
+  - cancel token 在 checkout 前取消时应返回 canceled。
+- `crates/dbx-core/src/db/mysql.rs`
+  - `kill_query_with_opts` timeout 分支。
+- `apps/desktop/src/stores/queryStore.ts`
+  - 前端 query timeout 后清理 `isExecuting`。
+  - cancel timeout 后清理 `isCancelling`。
+- `apps/desktop/src/stores/connectionStore.ts`
+  - `ensureConnected` health check timeout 后清理连接状态。
+
+### 集成测试
+
+PostgreSQL/openGauss：
+
+1. 创建连接。
+2. 执行 `SELECT 1`。
+3. 断开网络或停止数据库。
+4. 执行 `SELECT 1`。
+5. 断言超时内返回错误，UI 不保持执行中。
+6. 恢复数据库。
+7. 再次执行 `SELECT 1`，断言可恢复。
+
+MySQL：
+
+1. 创建连接。
+2. 设置测试库 `wait_timeout=5` 或使用测试容器配置。
+3. 空闲超过 10 秒。
+4. 执行 `SELECT 1`。
+5. 断言成功重连或明确失败。
+6. 执行 `SELECT SLEEP(60)` 并取消，断言 2 到 5 秒内 UI 恢复。
+
+前端：
+
+1. mock `api.checkConnectionHealth` 永不 resolve。
+2. 调用 `ensureConnected`。
+3. 断言超时后连接错误被记录，loading 状态被清理。
+4. mock `api.executeMulti` 永不 resolve。
+5. 调用 `executeTabSql`。
+6. 断言前端超时后 tab 状态恢复。
+
+### 手工验证
+
+Windows 场景：
+
+- Wi-Fi 断开/恢复。
+- VPN 断开/恢复。
+- 系统睡眠 5 分钟后恢复。
+- 数据库容器停止/启动。
+- 防火墙阻断数据库端口。
+
+每个场景验证：
+
+- 查询不会永久执行中。
+- 中断不会永久取消中。
+- 连接树不会永久加载中。
+- 重新连接后可恢复。
+- 不需要退出 DBX。
+
+## Rollback
+
+若改动引入新问题：
+
+- 可回退 keepalive 默认值到 0，但保留超时和 UI 状态恢复。
+- 可先只对 PostgreSQL/openGauss 启用 deadpool create/recycle timeout。
+- 可通过配置开关控制新的强制清池策略。
+
+不建议回退：
+
+- cancel timeout。
+- 前端状态兜底清理。
+- pool checkout timeout。
+
+这些属于防永久挂起的基础安全边界。
+
+## Risks
+
+- 对 session-scoped pool 清理过早可能破坏 MySQL 临时表、用户变量、PostgreSQL session state。
+- PostgreSQL TLS cancel connector 改造需要注意证书配置复用，避免取消连接绕过证书校验。
+- 将 SQL timeout 后统一清池可能影响长查询用户；需要保留 `query_timeout_secs=0` 的语义。
+- keepalive 默认开启会增加少量后台请求；应允许用户关闭。
+- 部分网络半开场景难以稳定自动化复现，需要手工和脚本结合。
+
+## Retirement
+
+需要逐步减少以下旧模式：
+
+- 在各驱动和业务路径中直接调用 `pool.get().await`、`pool.get_conn().await`。
+- 前端只依赖 Tauri command resolve/reject 恢复执行状态。
+- cancel 仅处理 SQL 已执行阶段，不处理连接获取和健康检查阶段。
+- keepalive 默认关闭且不提示风险。
+- 错误分类分散在前端和后端，缺少统一连接恢复语义。
+
+保留但收敛：
+
+- MySQL `get_conn_with_health_check` 可保留，但应纳入统一 checkout helper。
+- PostgreSQL `RecyclingMethod::Verified` 可保留，但必须有 recycle timeout。
+- 前端 `withFrontendQueryTimeout` 可保留，但只能作为 UI 兜底，不应替代后端执行预算。
+
+## 最终验收标准
+
+1. PostgreSQL、openGauss、MySQL 三类数据库空闲失效后，查询不会永久执行中。
+2. 用户点击中断后，UI 在 2 到 5 秒内退出取消中状态。
+3. 连接树刷新失败后不会永久转圈。
+4. 数据库或网络恢复后，不重启 DBX 即可重新连接并查询。
+5. 日志能明确指出失败阶段。
+6. 回归测试覆盖查询、取消、健康检查、元数据刷新、空闲清理和清池恢复。
diff --git a/docs/pnpm-lock.yaml b/docs/pnpm-lock.yaml
new file mode 100644
index 0000000..3f1abad
--- /dev/null
+++ b/docs/pnpm-lock.yaml
@@ -0,0 +1,4009 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      '@orama/orama':
+        specifier: 3.1.18
+        version: 3.1.18
+      '@tailwindcss/postcss':
+        specifier: ^4.2.4
+        version: 4.2.4
+      '@types/mdx':
+        specifier: ^2.0.13
+        version: 2.0.13
+      '@types/react':
+        specifier: ^19.2.14
+        version: 19.2.14
+      '@types/react-dom':
+        specifier: ^19.2.3
+        version: 19.2.3(@types/react@19.2.14)
+      fumadocs-core:
+        specifier: ^16.8.7
+        version: 16.8.7(@mdx-js/mdx@3.1.1)(@types/estree-jsx@1.0.5)(@types/hast@3.0.4)(@types/mdast@4.0.4)(@types/react@19.2.14)(lucide-react@0.515.0(react@19.2.5))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react-dom@19.2.5(react@19.2.5))(react@19.2.5)(zod@4.4.3)
+      fumadocs-mdx:
+        specifier: ^14.3.2
+        version: 14.3.2(@types/mdast@4.0.4)(@types/mdx@2.0.13)(@types/react@19.2.14)(fumadocs-core@16.8.7(@mdx-js/mdx@3.1.1)(@types/estree-jsx@1.0.5)(@types/hast@3.0.4)(@types/mdast@4.0.4)(@types/react@19.2.14)(lucide-react@0.515.0(react@19.2.5))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react-dom@19.2.5(react@19.2.5))(react@19.2.5)(zod@4.4.3))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react@19.2.5)
+      fumadocs-ui:
+        specifier: ^16.8.7
+        version: 16.8.7(@tailwindcss/oxide@4.2.4)(@types/mdx@2.0.13)(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(fumadocs-core@16.8.7(@mdx-js/mdx@3.1.1)(@types/estree-jsx@1.0.5)(@types/hast@3.0.4)(@types/mdast@4.0.4)(@types/react@19.2.14)(lucide-react@0.515.0(react@19.2.5))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react-dom@19.2.5(react@19.2.5))(react@19.2.5)(zod@4.4.3))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react-dom@19.2.5(react@19.2.5))(react@19.2.5)(tailwindcss@4.2.4)
+      lucide-react:
+        specifier: ^0.515.0
+        version: 0.515.0(react@19.2.5)
+      motion:
+        specifier: ^12.38.0
+        version: 12.38.0(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      next:
+        specifier: ^16.2.4
+        version: 16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      postcss:
+        specifier: ^8.5.14
+        version: 8.5.14
+      react:
+        specifier: ^19.2.5
+        version: 19.2.5
+      react-dom:
+        specifier: ^19.2.5
+        version: 19.2.5(react@19.2.5)
+      tailwindcss:
+        specifier: ^4.2.4
+        version: 4.2.4
+      typescript:
+        specifier: ^6.0.3
+        version: 6.0.3
+    devDependencies:
+      '@types/node':
+        specifier: ^25.6.0
+        version: 25.6.0
+
+packages:
+
+  '@alloc/quick-lru@5.2.0':
+    resolution: {integrity: sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==}
+    engines: {node: '>=10'}
+
+  '@emnapi/runtime@1.10.0':
+    resolution: {integrity: sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==}
+
+  '@esbuild/aix-ppc64@0.28.0':
+    resolution: {integrity: sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.28.0':
+    resolution: {integrity: sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.28.0':
+    resolution: {integrity: sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.28.0':
+    resolution: {integrity: sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.28.0':
+    resolution: {integrity: sha512-0T+A9WZm+bZ84nZBtk1ckYsOvyA3x7e2Acj1KdVfV4/2tdG4fzUp91YHx+GArWLtwqp77pBXVCPn2We7Letr0Q==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.28.0':
+    resolution: {integrity: sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.28.0':
+    resolution: {integrity: sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.28.0':
+    resolution: {integrity: sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.28.0':
+    resolution: {integrity: sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.28.0':
+    resolution: {integrity: sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.28.0':
+    resolution: {integrity: sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.28.0':
+    resolution: {integrity: sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.28.0':
+    resolution: {integrity: sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.28.0':
+    resolution: {integrity: sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.28.0':
+    resolution: {integrity: sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.28.0':
+    resolution: {integrity: sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.28.0':
+    resolution: {integrity: sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.28.0':
+    resolution: {integrity: sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.28.0':
+    resolution: {integrity: sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.28.0':
+    resolution: {integrity: sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.28.0':
+    resolution: {integrity: sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openharmony-arm64@0.28.0':
+    resolution: {integrity: sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/sunos-x64@0.28.0':
+    resolution: {integrity: sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.28.0':
+    resolution: {integrity: sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.28.0':
+    resolution: {integrity: sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.28.0':
+    resolution: {integrity: sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@floating-ui/core@1.7.5':
+    resolution: {integrity: sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==}
+
+  '@floating-ui/dom@1.7.6':
+    resolution: {integrity: sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==}
+
+  '@floating-ui/react-dom@2.1.8':
+    resolution: {integrity: sha512-cC52bHwM/n/CxS87FH0yWdngEZrjdtLW/qVruo68qg+prK7ZQ4YGdut2GyDVpoGeAYe/h899rVeOVm6Oi40k2A==}
+    peerDependencies:
+      react: '>=16.8.0'
+      react-dom: '>=16.8.0'
+
+  '@floating-ui/utils@0.2.11':
+    resolution: {integrity: sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==}
+
+  '@fumadocs/tailwind@0.0.5':
+    resolution: {integrity: sha512-ENKPWUDRmriccsrUDE4bDBq3FNr/ms3BP2rWlsAEMV1yP23pcCaan+ceGfeBUsAQjw7sj9Q3R4Kl3g/TCStPzQ==}
+    peerDependencies:
+      '@tailwindcss/oxide': ^4.0.0
+      tailwindcss: ^4.0.0
+    peerDependenciesMeta:
+      '@tailwindcss/oxide':
+        optional: true
+      tailwindcss:
+        optional: true
+
+  '@img/colour@1.1.0':
+    resolution: {integrity: sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==}
+    engines: {node: '>=18'}
+
+  '@img/sharp-darwin-arm64@0.34.5':
+    resolution: {integrity: sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-darwin-x64@0.34.5':
+    resolution: {integrity: sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-arm64@1.2.4':
+    resolution: {integrity: sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-x64@1.2.4':
+    resolution: {integrity: sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-linux-arm64@1.2.4':
+    resolution: {integrity: sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-arm@1.2.4':
+    resolution: {integrity: sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-ppc64@1.2.4':
+    resolution: {integrity: sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-riscv64@1.2.4':
+    resolution: {integrity: sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-s390x@1.2.4':
+    resolution: {integrity: sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-x64@1.2.4':
+    resolution: {integrity: sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
+    resolution: {integrity: sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-libvips-linuxmusl-x64@1.2.4':
+    resolution: {integrity: sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-linux-arm64@0.34.5':
+    resolution: {integrity: sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-linux-arm@0.34.5':
+    resolution: {integrity: sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-linux-ppc64@0.34.5':
+    resolution: {integrity: sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@img/sharp-linux-riscv64@0.34.5':
+    resolution: {integrity: sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@img/sharp-linux-s390x@0.34.5':
+    resolution: {integrity: sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [s390x]
+    os: [linux]
+
+  '@img/sharp-linux-x64@0.34.5':
+    resolution: {integrity: sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-linuxmusl-arm64@0.34.5':
+    resolution: {integrity: sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-linuxmusl-x64@0.34.5':
+    resolution: {integrity: sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-wasm32@0.34.5':
+    resolution: {integrity: sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [wasm32]
+
+  '@img/sharp-win32-arm64@0.34.5':
+    resolution: {integrity: sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@img/sharp-win32-ia32@0.34.5':
+    resolution: {integrity: sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@img/sharp-win32-x64@0.34.5':
+    resolution: {integrity: sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@jridgewell/gen-mapping@0.3.13':
+    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
+
+  '@jridgewell/remapping@2.3.5':
+    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
+
+  '@jridgewell/resolve-uri@3.1.2':
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/sourcemap-codec@1.5.5':
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
+
+  '@mdx-js/mdx@3.1.1':
+    resolution: {integrity: sha512-f6ZO2ifpwAQIpzGWaBQT2TXxPv6z3RBzQKpVftEWN78Vl/YweF1uwussDx8ECAXVtr3Rs89fKyG9YlzUs9DyGQ==}
+
+  '@next/env@16.2.4':
+    resolution: {integrity: sha512-dKkkOzOSwFYe5RX6y26fZgkSpVAlIOJKQHIiydQcrWH6y/97+RceSOAdjZ14Qa3zLduVUy0TXcn+EiM6t4rPgw==}
+
+  '@next/swc-darwin-arm64@16.2.4':
+    resolution: {integrity: sha512-OXTFFox5EKN1Ym08vfrz+OXxmCcEjT4SFMbNRsWZE99dMqt2Kcusl5MqPXcW232RYkMLQTy0hqgAMEsfEd/l2A==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@next/swc-darwin-x64@16.2.4':
+    resolution: {integrity: sha512-XhpVnUfmYWvD3YrXu55XdcAkQtOnvaI6wtQa8fuF5fGoKoxIUZ0kWPtcOfqJEWngFF/lOS9l3+O9CcownhiQxQ==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@next/swc-linux-arm64-gnu@16.2.4':
+    resolution: {integrity: sha512-Mx/tjlNA3G8kg14QvuGAJ4xBwPk1tUHq56JxZ8CXnZwz1Etz714soCEzGQQzVMz4bEnGPowzkV6Xrp6wAkEWOQ==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@next/swc-linux-arm64-musl@16.2.4':
+    resolution: {integrity: sha512-iVMMp14514u7Nup2umQS03nT/bN9HurK8ufylC3FZNykrwjtx7V1A7+4kvhbDSCeonTVqV3Txnv0Lu+m2oDXNg==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@next/swc-linux-x64-gnu@16.2.4':
+    resolution: {integrity: sha512-EZOvm1aQWgnI/N/xcWOlnS3RQBk0VtVav5Zo7n4p0A7UKyTDx047k8opDbXgBpHl4CulRqRfbw3QrX2w5UOXMQ==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+
+  '@next/swc-linux-x64-musl@16.2.4':
+    resolution: {integrity: sha512-h9FxsngCm9cTBf71AR4fGznDEDx1hS7+kSEiIRjq5kO1oXWm07DxVGZjCvk0SGx7TSjlUqhI8oOyz7NfwAdPoA==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+
+  '@next/swc-win32-arm64-msvc@16.2.4':
+    resolution: {integrity: sha512-3NdJV5OXMSOeJYijX+bjaLge3mJBlh4ybydbT4GFoB/2hAojWHtMhl3CYlYoMrjPuodp0nzFVi4Tj2+WaMg+Ow==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@next/swc-win32-x64-msvc@16.2.4':
+    resolution: {integrity: sha512-kMVGgsqhO5YTYODD9IPGGhA6iprWidQckK3LmPeW08PIFENRmgfb4MjXHO+p//d+ts2rpjvK5gXWzXSMrPl9cw==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [win32]
+
+  '@orama/orama@3.1.18':
+    resolution: {integrity: sha512-a61ljmRVVyG5MC/698C8/FfFDw5a8LOIvyOLW5fztgUXqUpc1jOfQzOitSCbge657OgXXThmY3Tk8fpiDb4UcA==}
+    engines: {node: '>= 20.0.0'}
+
+  '@radix-ui/number@1.1.1':
+    resolution: {integrity: sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g==}
+
+  '@radix-ui/primitive@1.1.3':
+    resolution: {integrity: sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==}
+
+  '@radix-ui/react-accordion@1.2.12':
+    resolution: {integrity: sha512-T4nygeh9YE9dLRPhAHSeOZi7HBXo+0kYIPJXayZfvWOWA0+n3dESrZbjfDPUABkUNym6Hd+f2IR113To8D2GPA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-arrow@1.1.7':
+    resolution: {integrity: sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-collapsible@1.1.12':
+    resolution: {integrity: sha512-Uu+mSh4agx2ib1uIGPP4/CKNULyajb3p92LsVXmH2EHVMTfZWpll88XJ0j4W0z3f8NK1eYl1+Mf/szHPmcHzyA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-collection@1.1.7':
+    resolution: {integrity: sha512-Fh9rGN0MoI4ZFUNyfFVNU4y9LUz93u9/0K+yLgA2bwRojxM8JU1DyvvMBabnZPBgMWREAJvU2jjVzq+LrFUglw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-compose-refs@1.1.2':
+    resolution: {integrity: sha512-z4eqJvfiNnFMHIIvXP3CY57y2WJs5g2v3X0zm9mEJkrkNv4rDxu+sg9Jh8EkXyeqBkB7SOcboo9dMVqhyrACIg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-context@1.1.2':
+    resolution: {integrity: sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-dialog@1.1.15':
+    resolution: {integrity: sha512-TCglVRtzlffRNxRMEyR36DGBLJpeusFcgMVD9PZEzAKnUs1lKCgX5u9BmC2Yg+LL9MgZDugFFs1Vl+Jp4t/PGw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-direction@1.1.1':
+    resolution: {integrity: sha512-1UEWRX6jnOA2y4H5WczZ44gOOjTEmlqv1uNW4GAJEO5+bauCBhv8snY65Iw5/VOS/ghKN9gr2KjnLKxrsvoMVw==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-dismissable-layer@1.1.11':
+    resolution: {integrity: sha512-Nqcp+t5cTB8BinFkZgXiMJniQH0PsUt2k51FUhbdfeKvc4ACcG2uQniY/8+h1Yv6Kza4Q7lD7PQV0z0oicE0Mg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-focus-guards@1.1.3':
+    resolution: {integrity: sha512-0rFg/Rj2Q62NCm62jZw0QX7a3sz6QCQU0LpZdNrJX8byRGaGVTqbrW9jAoIAHyMQqsNpeZ81YgSizOt5WXq0Pw==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-focus-scope@1.1.7':
+    resolution: {integrity: sha512-t2ODlkXBQyn7jkl6TNaw/MtVEVvIGelJDCG41Okq/KwUsJBwQ4XVZsHAVUkK4mBv3ewiAS3PGuUWuY2BoK4ZUw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-id@1.1.1':
+    resolution: {integrity: sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-navigation-menu@1.2.14':
+    resolution: {integrity: sha512-YB9mTFQvCOAQMHU+C/jVl96WmuWeltyUEpRJJky51huhds5W2FQr1J8D/16sQlf0ozxkPK8uF3niQMdUwZPv5w==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-popover@1.1.15':
+    resolution: {integrity: sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-popper@1.2.8':
+    resolution: {integrity: sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-portal@1.1.9':
+    resolution: {integrity: sha512-bpIxvq03if6UNwXZ+HTK71JLh4APvnXntDc6XOX8UVq4XQOVl7lwok0AvIl+b8zgCw3fSaVTZMpAPPagXbKmHQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-presence@1.1.5':
+    resolution: {integrity: sha512-/jfEwNDdQVBCNvjkGit4h6pMOzq8bHkopq458dPt2lMjx+eBQUohZNG9A7DtO/O5ukSbxuaNGXMjHicgwy6rQQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-primitive@2.1.3':
+    resolution: {integrity: sha512-m9gTwRkhy2lvCPe6QJp4d3G1TYEUHn/FzJUtq9MjH46an1wJU+GdoGC5VLof8RX8Ft/DlpshApkhswDLZzHIcQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-roving-focus@1.1.11':
+    resolution: {integrity: sha512-7A6S9jSgm/S+7MdtNDSb+IU859vQqJ/QAtcYQcfFC6W8RS4IxIZDldLR0xqCFZ6DCyrQLjLPsxtTNch5jVA4lA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-scroll-area@1.2.10':
+    resolution: {integrity: sha512-tAXIa1g3sM5CGpVT0uIbUx/U3Gs5N8T52IICuCtObaos1S8fzsrPXG5WObkQN3S6NVl6wKgPhAIiBGbWnvc97A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-slot@1.2.3':
+    resolution: {integrity: sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-slot@1.2.4':
+    resolution: {integrity: sha512-Jl+bCv8HxKnlTLVrcDE8zTMJ09R9/ukw4qBs/oZClOfoQk/cOTbDn+NceXfV7j09YPVQUryJPHurafcSg6EVKA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-tabs@1.1.13':
+    resolution: {integrity: sha512-7xdcatg7/U+7+Udyoj2zodtI9H/IIopqo+YOIcZOq1nJwXWBZ9p8xiu5llXlekDbZkca79a/fozEYQXIA4sW6A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-use-callback-ref@1.1.1':
+    resolution: {integrity: sha512-FkBMwD+qbGQeMu1cOHnuGB6x4yzPjho8ap5WtbEJ26umhgqVXbhekKUQO+hZEL1vU92a3wHwdp0HAcqAUF5iDg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-controllable-state@1.2.2':
+    resolution: {integrity: sha512-BjasUjixPFdS+NKkypcyyN5Pmg83Olst0+c6vGov0diwTEo6mgdqVR6hxcEgFuh4QrAs7Rc+9KuGJ9TVCj0Zzg==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-effect-event@0.0.2':
+    resolution: {integrity: sha512-Qp8WbZOBe+blgpuUT+lw2xheLP8q0oatc9UpmiemEICxGvFLYmHm9QowVZGHtJlGbS6A6yJ3iViad/2cVjnOiA==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-escape-keydown@1.1.1':
+    resolution: {integrity: sha512-Il0+boE7w/XebUHyBjroE+DbByORGR9KKmITzbR7MyQ4akpORYP/ZmbhAr0DG7RmmBqoOnZdy2QlvajJ2QA59g==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-layout-effect@1.1.1':
+    resolution: {integrity: sha512-RbJRS4UWQFkzHTTwVymMTUv8EqYhOp8dOOviLj2ugtTiXRaRQS7GLGxZTLL1jWhMeoSCf5zmcZkqTl9IiYfXcQ==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-previous@1.1.1':
+    resolution: {integrity: sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-rect@1.1.1':
+    resolution: {integrity: sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-use-size@1.1.1':
+    resolution: {integrity: sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  '@radix-ui/react-visually-hidden@1.2.3':
+    resolution: {integrity: sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/rect@1.1.1':
+    resolution: {integrity: sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==}
+
+  '@shikijs/core@4.0.2':
+    resolution: {integrity: sha512-hxT0YF4ExEqB8G/qFdtJvpmHXBYJ2lWW7qTHDarVkIudPFE6iCIrqdgWxGn5s+ppkGXI0aEGlibI0PAyzP3zlw==}
+    engines: {node: '>=20'}
+
+  '@shikijs/engine-javascript@4.0.2':
+    resolution: {integrity: sha512-7PW0Nm49DcoUIQEXlJhNNBHyoGMjalRETTCcjMqEaMoJRLljy1Bi/EGV3/qLBgLKQejdspiiYuHGQW6dX94Nag==}
+    engines: {node: '>=20'}
+
+  '@shikijs/engine-oniguruma@4.0.2':
+    resolution: {integrity: sha512-UpCB9Y2sUKlS9z8juFSKz7ZtysmeXCgnRF0dlhXBkmQnek7lAToPte8DkxmEYGNTMii72zU/lyXiCB6StuZeJg==}
+    engines: {node: '>=20'}
+
+  '@shikijs/langs@4.0.2':
+    resolution: {integrity: sha512-KaXby5dvoeuZzN0rYQiPMjFoUrz4hgwIE+D6Du9owcHcl6/g16/yT5BQxSW5cGt2MZBz6Hl0YuRqf12omRfUUg==}
+    engines: {node: '>=20'}
+
+  '@shikijs/primitive@4.0.2':
+    resolution: {integrity: sha512-M6UMPrSa3fN5ayeJwFVl9qWofl273wtK1VG8ySDZ1mQBfhCpdd8nEx7nPZ/tk7k+TYcpqBZzj/AnwxT9lO+HJw==}
+    engines: {node: '>=20'}
+
+  '@shikijs/themes@4.0.2':
+    resolution: {integrity: sha512-mjCafwt8lJJaVSsQvNVrJumbnnj1RI8jbUKrPKgE6E3OvQKxnuRoBaYC51H4IGHePsGN/QtALglWBU7DoKDFnA==}
+    engines: {node: '>=20'}
+
+  '@shikijs/types@4.0.2':
+    resolution: {integrity: sha512-qzbeRooUTPnLE+sHD/Z8DStmaDgnbbc/pMrU203950aRqjX/6AFHeDYT+j00y2lPdz0ywJKx7o/7qnqTivtlXg==}
+    engines: {node: '>=20'}
+
+  '@shikijs/vscode-textmate@10.0.2':
+    resolution: {integrity: sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==}
+
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
+  '@swc/helpers@0.5.15':
+    resolution: {integrity: sha512-JQ5TuMi45Owi4/BIMAJBoSQoOJu12oOk/gADqlcUL9JEdHB8vyjUSsxqeNXnmXHjYKMi2WcYtezGEEhqUI/E2g==}
+
+  '@tailwindcss/node@4.2.4':
+    resolution: {integrity: sha512-Ai7+yQPxz3ddrDQzFfBKdHEVBg0w3Zl83jnjuwxnZOsnH9pGn93QHQtpU0p/8rYWxvbFZHneni6p1BSLK4DkGA==}
+
+  '@tailwindcss/oxide-android-arm64@4.2.4':
+    resolution: {integrity: sha512-e7MOr1SAn9U8KlZzPi1ZXGZHeC5anY36qjNwmZv9pOJ8E4Q6jmD1vyEHkQFmNOIN7twGPEMXRHmitN4zCMN03g==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [android]
+
+  '@tailwindcss/oxide-darwin-arm64@4.2.4':
+    resolution: {integrity: sha512-tSC/Kbqpz/5/o/C2sG7QvOxAKqyd10bq+ypZNf+9Fi2TvbVbv1zNpcEptcsU7DPROaSbVgUXmrzKhurFvo5eDg==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@tailwindcss/oxide-darwin-x64@4.2.4':
+    resolution: {integrity: sha512-yPyUXn3yO/ufR6+Kzv0t4fCg2qNr90jxXc5QqBpjlPNd0NqyDXcmQb/6weunH/MEDXW5dhyEi+agTDiqa3WsGg==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@tailwindcss/oxide-freebsd-x64@4.2.4':
+    resolution: {integrity: sha512-BoMIB4vMQtZsXdGLVc2z+P9DbETkiopogfWZKbWwM8b/1Vinbs4YcUwo+kM/KeLkX3Ygrf4/PsRndKaYhS8Eiw==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.2.4':
+    resolution: {integrity: sha512-7pIHBLTHYRAlS7V22JNuTh33yLH4VElwKtB3bwchK/UaKUPpQ0lPQiOWcbm4V3WP2I6fNIJ23vABIvoy2izdwA==}
+    engines: {node: '>= 20'}
+    cpu: [arm]
+    os: [linux]
+
+  '@tailwindcss/oxide-linux-arm64-gnu@4.2.4':
+    resolution: {integrity: sha512-+E4wxJ0ZGOzSH325reXTWB48l42i93kQqMvDyz5gqfRzRZ7faNhnmvlV4EPGJU3QJM/3Ab5jhJ5pCRUsKn6OQw==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@tailwindcss/oxide-linux-arm64-musl@4.2.4':
+    resolution: {integrity: sha512-bBADEGAbo4ASnppIziaQJelekCxdMaxisrk+fB7Thit72IBnALp9K6ffA2G4ruj90G9XRS2VQ6q2bCKbfFV82g==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@tailwindcss/oxide-linux-x64-gnu@4.2.4':
+    resolution: {integrity: sha512-7Mx25E4WTfnht0TVRTyC00j3i0M+EeFe7wguMDTlX4mRxafznw0CA8WJkFjWYH5BlgELd1kSjuU2JiPnNZbJDA==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [linux]
+
+  '@tailwindcss/oxide-linux-x64-musl@4.2.4':
+    resolution: {integrity: sha512-2wwJRF7nyhOR0hhHoChc04xngV3iS+akccHTGtz965FwF0up4b2lOdo6kI1EbDaEXKgvcrFBYcYQQ/rrnWFVfA==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [linux]
+
+  '@tailwindcss/oxide-wasm32-wasi@4.2.4':
+    resolution: {integrity: sha512-FQsqApeor8Fo6gUEklzmaa9994orJZZDBAlQpK2Mq+DslRKFJeD6AjHpBQ0kZFQohVr8o85PPh8eOy86VlSCmw==}
+    engines: {node: '>=14.0.0'}
+    cpu: [wasm32]
+    bundledDependencies:
+      - '@napi-rs/wasm-runtime'
+      - '@emnapi/core'
+      - '@emnapi/runtime'
+      - '@tybys/wasm-util'
+      - '@emnapi/wasi-threads'
+      - tslib
+
+  '@tailwindcss/oxide-win32-arm64-msvc@4.2.4':
+    resolution: {integrity: sha512-L9BXqxC4ToVgwMFqj3pmZRqyHEztulpUJzCxUtLjobMCzTPsGt1Fa9enKbOpY2iIyVtaHNeNvAK8ERP/64sqGQ==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@tailwindcss/oxide-win32-x64-msvc@4.2.4':
+    resolution: {integrity: sha512-ESlKG0EpVJQwRjXDDa9rLvhEAh0mhP1sF7sap9dNZT0yyl9SAG6T7gdP09EH0vIv0UNTlo6jPWyujD6559fZvw==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [win32]
+
+  '@tailwindcss/oxide@4.2.4':
+    resolution: {integrity: sha512-9El/iI069DKDSXwTvB9J4BwdO5JhRrOweGaK25taBAvBXyXqJAX+Jqdvs8r8gKpsI/1m0LeJLyQYTf/WLrBT1Q==}
+    engines: {node: '>= 20'}
+
+  '@tailwindcss/postcss@4.2.4':
+    resolution: {integrity: sha512-wgAVj6nUWAolAu8YFvzT2cTBIElWHkjZwFYovF+xsqKsW2ADxM/X2opxj5NsF/qVccAOjRNe8X2IdPzMsWyHTg==}
+
+  '@types/debug@4.1.13':
+    resolution: {integrity: sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==}
+
+  '@types/estree-jsx@1.0.5':
+    resolution: {integrity: sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==}
+
+  '@types/estree@1.0.8':
+    resolution: {integrity: sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==}
+
+  '@types/hast@3.0.4':
+    resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
+
+  '@types/mdast@4.0.4':
+    resolution: {integrity: sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==}
+
+  '@types/mdx@2.0.13':
+    resolution: {integrity: sha512-+OWZQfAYyio6YkJb3HLxDrvnx6SWWDbC0zVPfBRzUk0/nqoDyf6dNxQi3eArPe8rJ473nobTMQ/8Zk+LxJ+Yuw==}
+
+  '@types/ms@2.1.0':
+    resolution: {integrity: sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==}
+
+  '@types/node@25.6.0':
+    resolution: {integrity: sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ==}
+
+  '@types/react-dom@19.2.3':
+    resolution: {integrity: sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==}
+    peerDependencies:
+      '@types/react': ^19.2.0
+
+  '@types/react@19.2.14':
+    resolution: {integrity: sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==}
+
+  '@types/unist@2.0.11':
+    resolution: {integrity: sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==}
+
+  '@types/unist@3.0.3':
+    resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==}
+
+  '@ungap/structured-clone@1.3.0':
+    resolution: {integrity: sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==}
+
+  acorn-jsx@5.3.2:
+    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
+    peerDependencies:
+      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+
+  acorn@8.16.0:
+    resolution: {integrity: sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+
+  argparse@2.0.1:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+
+  aria-hidden@1.2.6:
+    resolution: {integrity: sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==}
+    engines: {node: '>=10'}
+
+  astring@1.9.0:
+    resolution: {integrity: sha512-LElXdjswlqjWrPpJFg1Fx4wpkOCxj1TDHlSV4PlaRxHGWko024xICaa97ZkMfs6DRKlCguiAI+rbXv5GWwXIkg==}
+    hasBin: true
+
+  bail@2.0.2:
+    resolution: {integrity: sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==}
+
+  baseline-browser-mapping@2.10.27:
+    resolution: {integrity: sha512-zEs/ufmZoUd7WftKpKyXaT6RFxpQ5Qm9xytKRHvJfxFV9DFJkZph9RvJ1LcOUi0Z1ZVijMte65JbILeV+8QQEA==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  caniuse-lite@1.0.30001791:
+    resolution: {integrity: sha512-yk0l/YSrOnFZk3UROpDLQD9+kC1l4meK/wed583AXrzoarMGJcbRi2Q4RaUYbKxYAsZ8sWmaSa/DsLmdBeI1vQ==}
+
+  ccount@2.0.1:
+    resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==}
+
+  character-entities-html4@2.1.0:
+    resolution: {integrity: sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==}
+
+  character-entities-legacy@3.0.0:
+    resolution: {integrity: sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==}
+
+  character-entities@2.0.2:
+    resolution: {integrity: sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==}
+
+  character-reference-invalid@2.0.1:
+    resolution: {integrity: sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==}
+
+  chokidar@5.0.0:
+    resolution: {integrity: sha512-TQMmc3w+5AxjpL8iIiwebF73dRDF4fBIieAqGn9RGCWaEVwQ6Fb2cGe31Yns0RRIzii5goJ1Y7xbMwo1TxMplw==}
+    engines: {node: '>= 20.19.0'}
+
+  class-variance-authority@0.7.1:
+    resolution: {integrity: sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==}
+
+  client-only@0.0.1:
+    resolution: {integrity: sha512-IV3Ou0jSMzZrd3pZ48nLkT9DA7Ag1pnPzaiQhpW7c3RbcqqzvzzVu+L8gfqMp/8IM2MQtSiqaCxrrcfu8I8rMA==}
+
+  clsx@2.1.1:
+    resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
+    engines: {node: '>=6'}
+
+  collapse-white-space@2.1.0:
+    resolution: {integrity: sha512-loKTxY1zCOuG4j9f6EPnuyyYkf58RnhhWTvRoZEokgB+WbdXehfjFviyOVYkqzEWz1Q5kRiZdBYS5SwxbQYwzw==}
+
+  comma-separated-tokens@2.0.3:
+    resolution: {integrity: sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==}
+
+  compute-scroll-into-view@3.1.1:
+    resolution: {integrity: sha512-VRhuHOLoKYOy4UbilLbUzbYg93XLjv2PncJC50EuTWPA3gaja1UjBsUP/D/9/juV3vQFr6XBEzn9KCAHdUvOHw==}
+
+  csstype@3.2.3:
+    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
+
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  decode-named-character-reference@1.3.0:
+    resolution: {integrity: sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==}
+
+  dequal@2.0.3:
+    resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==}
+    engines: {node: '>=6'}
+
+  detect-libc@2.1.2:
+    resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
+    engines: {node: '>=8'}
+
+  detect-node-es@1.1.0:
+    resolution: {integrity: sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==}
+
+  devlop@1.1.0:
+    resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==}
+
+  enhanced-resolve@5.21.0:
+    resolution: {integrity: sha512-otxSQPw4lkOZWkHpB3zaEQs6gWYEsmX4xQF68ElXC/TWvGxGMSGOvoNbaLXm6/cS/fSfHtsEdw90y20PCd+sCA==}
+    engines: {node: '>=10.13.0'}
+
+  entities@6.0.1:
+    resolution: {integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==}
+    engines: {node: '>=0.12'}
+
+  esast-util-from-estree@2.0.0:
+    resolution: {integrity: sha512-4CyanoAudUSBAn5K13H4JhsMH6L9ZP7XbLVe/dKybkxMO7eDyLsT8UHl9TRNrU2Gr9nz+FovfSIjuXWJ81uVwQ==}
+
+  esast-util-from-js@2.0.1:
+    resolution: {integrity: sha512-8Ja+rNJ0Lt56Pcf3TAmpBZjmx8ZcK5Ts4cAzIOjsjevg9oSXJnl6SUQ2EevU8tv3h6ZLWmoKL5H4fgWvdvfETw==}
+
+  esbuild@0.28.0:
+    resolution: {integrity: sha512-sNR9MHpXSUV/XB4zmsFKN+QgVG82Cc7+/aaxJ8Adi8hyOac+EXptIp45QBPaVyX3N70664wRbTcLTOemCAnyqw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  escape-string-regexp@5.0.0:
+    resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==}
+    engines: {node: '>=12'}
+
+  estree-util-attach-comments@3.0.0:
+    resolution: {integrity: sha512-cKUwm/HUcTDsYh/9FgnuFqpfquUbwIqwKM26BVCGDPVgvaCl/nDCCjUfiLlx6lsEZ3Z4RFxNbOQ60pkaEwFxGw==}
+
+  estree-util-build-jsx@3.0.1:
+    resolution: {integrity: sha512-8U5eiL6BTrPxp/CHbs2yMgP8ftMhR5ww1eIKoWRMlqvltHF8fZn5LRDvTKuxD3DUn+shRbLGqXemcP51oFCsGQ==}
+
+  estree-util-is-identifier-name@3.0.0:
+    resolution: {integrity: sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==}
+
+  estree-util-scope@1.0.0:
+    resolution: {integrity: sha512-2CAASclonf+JFWBNJPndcOpA8EMJwa0Q8LUFJEKqXLW6+qBvbFZuF5gItbQOs/umBUkjviCSDCbBwU2cXbmrhQ==}
+
+  estree-util-to-js@2.0.0:
+    resolution: {integrity: sha512-WDF+xj5rRWmD5tj6bIqRi6CkLIXbbNQUcxQHzGysQzvHmdYG2G7p/Tf0J0gpxGgkeMZNTIjT/AoSvC9Xehcgdg==}
+
+  estree-util-value-to-estree@3.5.0:
+    resolution: {integrity: sha512-aMV56R27Gv3QmfmF1MY12GWkGzzeAezAX+UplqHVASfjc9wNzI/X6hC0S9oxq61WT4aQesLGslWP9tKk6ghRZQ==}
+
+  estree-util-visit@2.0.0:
+    resolution: {integrity: sha512-m5KgiH85xAhhW8Wta0vShLcUvOsh3LLPI2YVwcbio1l7E09NTLL1EyMZFM1OyWowoH0skScNbhOPl4kcBgzTww==}
+
+  estree-walker@3.0.3:
+    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
+
+  extend@3.0.2:
+    resolution: {integrity: sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==}
+
+  fdir@6.5.0:
+    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
+    engines: {node: '>=12.0.0'}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
+
+  framer-motion@12.38.0:
+    resolution: {integrity: sha512-rFYkY/pigbcswl1XQSb7q424kSTQ8q6eAC+YUsSKooHQYuLdzdHjrt6uxUC+PRAO++q5IS7+TamgIw1AphxR+g==}
+    peerDependencies:
+      '@emotion/is-prop-valid': '*'
+      react: ^18.0.0 || ^19.0.0
+      react-dom: ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@emotion/is-prop-valid':
+        optional: true
+      react:
+        optional: true
+      react-dom:
+        optional: true
+
+  fumadocs-core@16.8.7:
+    resolution: {integrity: sha512-y7awKyp4PwA2fGCsa/9z7a6/SlhAIABV9B/kmUAy9NlM+eo1Lm3P0A+Bcs7R36YsVsJd9tqiVuExbpLQ7n01Jw==}
+    peerDependencies:
+      '@mdx-js/mdx': '*'
+      '@mixedbread/sdk': 0.x.x
+      '@orama/core': 1.x.x
+      '@oramacloud/client': 2.x.x
+      '@tanstack/react-router': 1.x.x
+      '@types/estree-jsx': '*'
+      '@types/hast': '*'
+      '@types/mdast': '*'
+      '@types/react': '*'
+      algoliasearch: 5.x.x
+      flexsearch: '*'
+      lucide-react: '*'
+      next: 16.x.x
+      react: ^19.2.0
+      react-dom: ^19.2.0
+      react-router: 7.x.x
+      waku: ^0.26.0 || ^0.27.0 || ^1.0.0
+      zod: 4.x.x
+    peerDependenciesMeta:
+      '@mdx-js/mdx':
+        optional: true
+      '@mixedbread/sdk':
+        optional: true
+      '@orama/core':
+        optional: true
+      '@oramacloud/client':
+        optional: true
+      '@tanstack/react-router':
+        optional: true
+      '@types/estree-jsx':
+        optional: true
+      '@types/hast':
+        optional: true
+      '@types/mdast':
+        optional: true
+      '@types/react':
+        optional: true
+      algoliasearch:
+        optional: true
+      flexsearch:
+        optional: true
+      lucide-react:
+        optional: true
+      next:
+        optional: true
+      react:
+        optional: true
+      react-dom:
+        optional: true
+      react-router:
+        optional: true
+      waku:
+        optional: true
+      zod:
+        optional: true
+
+  fumadocs-mdx@14.3.2:
+    resolution: {integrity: sha512-73SoZkbUuqnD91G/0zBcaQdM1TMnYw5JJzKgkGvQTiZbtLQFuWTt8/uRqnzFMuNIUu/WY9Lo9d1iZ8G+jOVieA==}
+    hasBin: true
+    peerDependencies:
+      '@types/mdast': '*'
+      '@types/mdx': '*'
+      '@types/react': '*'
+      fumadocs-core: ^15.0.0 || ^16.0.0
+      mdast-util-directive: '*'
+      next: ^15.3.0 || ^16.0.0
+      react: ^19.2.0
+      vite: 6.x.x || 7.x.x || 8.x.x
+    peerDependenciesMeta:
+      '@types/mdast':
+        optional: true
+      '@types/mdx':
+        optional: true
+      '@types/react':
+        optional: true
+      mdast-util-directive:
+        optional: true
+      next:
+        optional: true
+      react:
+        optional: true
+      vite:
+        optional: true
+
+  fumadocs-ui@16.8.7:
+    resolution: {integrity: sha512-ICTA2y+R++f8UKF3RL6mT3jCk6l7F5wpfuPV5dc7VRWNGxeFeiEwHdqo6Zb51HTjt1jDc7PQ1/T8I+gwPniU8g==}
+    peerDependencies:
+      '@takumi-rs/image-response': '*'
+      '@types/mdx': '*'
+      '@types/react': '*'
+      fumadocs-core: 16.8.7
+      next: 16.x.x
+      react: ^19.2.0
+      react-dom: ^19.2.0
+    peerDependenciesMeta:
+      '@takumi-rs/image-response':
+        optional: true
+      '@types/mdx':
+        optional: true
+      '@types/react':
+        optional: true
+      next:
+        optional: true
+
+  get-nonce@1.0.1:
+    resolution: {integrity: sha512-FJhYRoDaiatfEkUK8HKlicmu/3SGFD51q3itKDGoSTysQJBnfOcxU5GxnhE1E6soB76MbT0MBtnKJuXyAx+96Q==}
+    engines: {node: '>=6'}
+
+  github-slugger@2.0.0:
+    resolution: {integrity: sha512-IaOQ9puYtjrkq7Y0Ygl9KDZnrf/aiUJYUpVf89y8kyaxbRG7Y1SrX/jaumrv81vc61+kiMempujsM3Yw7w5qcw==}
+
+  graceful-fs@4.2.11:
+    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
+
+  hast-util-from-parse5@8.0.3:
+    resolution: {integrity: sha512-3kxEVkEKt0zvcZ3hCRYI8rqrgwtlIOFMWkbclACvjlDw8Li9S2hk/d51OI0nr/gIpdMHNepwgOKqZ/sy0Clpyg==}
+
+  hast-util-parse-selector@4.0.0:
+    resolution: {integrity: sha512-wkQCkSYoOGCRKERFWcxMVMOcYE2K1AaNLU8DXS9arxnLOUEWbOXKXiJUNzEpqZ3JOKpnha3jkFrumEjVliDe7A==}
+
+  hast-util-raw@9.1.0:
+    resolution: {integrity: sha512-Y8/SBAHkZGoNkpzqqfCldijcuUKh7/su31kEBp67cFY09Wy0mTRgtsLYsiIxMJxlu0f6AA5SUTbDR8K0rxnbUw==}
+
+  hast-util-to-estree@3.1.3:
+    resolution: {integrity: sha512-48+B/rJWAp0jamNbAAf9M7Uf//UVqAoMmgXhBdxTDJLGKY+LRnZ99qcG+Qjl5HfMpYNzS5v4EAwVEF34LeAj7w==}
+
+  hast-util-to-html@9.0.5:
+    resolution: {integrity: sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==}
+
+  hast-util-to-jsx-runtime@2.3.6:
+    resolution: {integrity: sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==}
+
+  hast-util-to-parse5@8.0.1:
+    resolution: {integrity: sha512-MlWT6Pjt4CG9lFCjiz4BH7l9wmrMkfkJYCxFwKQic8+RTZgWPuWxwAfjJElsXkex7DJjfSJsQIt931ilUgmwdA==}
+
+  hast-util-whitespace@3.0.0:
+    resolution: {integrity: sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==}
+
+  hastscript@9.0.1:
+    resolution: {integrity: sha512-g7df9rMFX/SPi34tyGCyUBREQoKkapwdY/T04Qn9TDWfHhAYt4/I0gMVirzK5wEzeUqIjEB+LXC/ypb7Aqno5w==}
+
+  html-void-elements@3.0.0:
+    resolution: {integrity: sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==}
+
+  inline-style-parser@0.2.7:
+    resolution: {integrity: sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==}
+
+  is-alphabetical@2.0.1:
+    resolution: {integrity: sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==}
+
+  is-alphanumerical@2.0.1:
+    resolution: {integrity: sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==}
+
+  is-decimal@2.0.1:
+    resolution: {integrity: sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==}
+
+  is-hexadecimal@2.0.1:
+    resolution: {integrity: sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==}
+
+  is-plain-obj@4.1.0:
+    resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==}
+    engines: {node: '>=12'}
+
+  jiti@2.6.1:
+    resolution: {integrity: sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==}
+    hasBin: true
+
+  js-yaml@4.1.1:
+    resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
+    hasBin: true
+
+  lightningcss-android-arm64@1.32.0:
+    resolution: {integrity: sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [android]
+
+  lightningcss-darwin-arm64@1.32.0:
+    resolution: {integrity: sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [darwin]
+
+  lightningcss-darwin-x64@1.32.0:
+    resolution: {integrity: sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [darwin]
+
+  lightningcss-freebsd-x64@1.32.0:
+    resolution: {integrity: sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [freebsd]
+
+  lightningcss-linux-arm-gnueabihf@1.32.0:
+    resolution: {integrity: sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm]
+    os: [linux]
+
+  lightningcss-linux-arm64-gnu@1.32.0:
+    resolution: {integrity: sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  lightningcss-linux-arm64-musl@1.32.0:
+    resolution: {integrity: sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  lightningcss-linux-x64-gnu@1.32.0:
+    resolution: {integrity: sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+
+  lightningcss-linux-x64-musl@1.32.0:
+    resolution: {integrity: sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+
+  lightningcss-win32-arm64-msvc@1.32.0:
+    resolution: {integrity: sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [win32]
+
+  lightningcss-win32-x64-msvc@1.32.0:
+    resolution: {integrity: sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [win32]
+
+  lightningcss@1.32.0:
+    resolution: {integrity: sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==}
+    engines: {node: '>= 12.0.0'}
+
+  longest-streak@3.1.0:
+    resolution: {integrity: sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==}
+
+  lucide-react@0.515.0:
+    resolution: {integrity: sha512-Sy7bY0MeicRm2pzrnoHm2h6C1iVoeHyBU2fjdQDsXGP51fhkhau1/ZV/dzrcxEmAKsxYb6bGaIsMnGHuQ5s0dw==}
+    peerDependencies:
+      react: ^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0
+
+  lucide-react@1.14.0:
+    resolution: {integrity: sha512-+1mdWcfSJVUsaTIjN9zoezmUhfXo5l0vP7ekBMPo3jcS/aIkxHnXqAPsByszMZx/Y8oQBRJxJx5xg+RH3urzxA==}
+    peerDependencies:
+      react: ^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0
+
+  magic-string@0.30.21:
+    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+
+  markdown-extensions@2.0.0:
+    resolution: {integrity: sha512-o5vL7aDWatOTX8LzaS1WMoaoxIiLRQJuIKKe2wAw6IeULDHaqbiqiggmx+pKvZDb1Sj+pE46Sn1T7lCqfFtg1Q==}
+    engines: {node: '>=16'}
+
+  markdown-table@3.0.4:
+    resolution: {integrity: sha512-wiYz4+JrLyb/DqW2hkFJxP7Vd7JuTDm77fvbM8VfEQdmSMqcImWeeRbHwZjBjIFki/VaMK2BhFi7oUUZeM5bqw==}
+
+  mdast-util-find-and-replace@3.0.2:
+    resolution: {integrity: sha512-Tmd1Vg/m3Xz43afeNxDIhWRtFZgM2VLyaf4vSTYwudTyeuTneoL3qtWMA5jeLyz/O1vDJmmV4QuScFCA2tBPwg==}
+
+  mdast-util-from-markdown@2.0.3:
+    resolution: {integrity: sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==}
+
+  mdast-util-gfm-autolink-literal@2.0.1:
+    resolution: {integrity: sha512-5HVP2MKaP6L+G6YaxPNjuL0BPrq9orG3TsrZ9YXbA3vDw/ACI4MEsnoDpn6ZNm7GnZgtAcONJyPhOP8tNJQavQ==}
+
+  mdast-util-gfm-footnote@2.1.0:
+    resolution: {integrity: sha512-sqpDWlsHn7Ac9GNZQMeUzPQSMzR6Wv0WKRNvQRg0KqHh02fpTz69Qc1QSseNX29bhz1ROIyNyxExfawVKTm1GQ==}
+
+  mdast-util-gfm-strikethrough@2.0.0:
+    resolution: {integrity: sha512-mKKb915TF+OC5ptj5bJ7WFRPdYtuHv0yTRxK2tJvi+BDqbkiG7h7u/9SI89nRAYcmap2xHQL9D+QG/6wSrTtXg==}
+
+  mdast-util-gfm-table@2.0.0:
+    resolution: {integrity: sha512-78UEvebzz/rJIxLvE7ZtDd/vIQ0RHv+3Mh5DR96p7cS7HsBhYIICDBCu8csTNWNO6tBWfqXPWekRuj2FNOGOZg==}
+
+  mdast-util-gfm-task-list-item@2.0.0:
+    resolution: {integrity: sha512-IrtvNvjxC1o06taBAVJznEnkiHxLFTzgonUdy8hzFVeDun0uTjxxrRGVaNFqkU1wJR3RBPEfsxmU6jDWPofrTQ==}
+
+  mdast-util-gfm@3.1.0:
+    resolution: {integrity: sha512-0ulfdQOM3ysHhCJ1p06l0b0VKlhU0wuQs3thxZQagjcjPrlFRqY215uZGHHJan9GEAXd9MbfPjFJz+qMkVR6zQ==}
+
+  mdast-util-mdx-expression@2.0.1:
+    resolution: {integrity: sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==}
+
+  mdast-util-mdx-jsx@3.2.0:
+    resolution: {integrity: sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==}
+
+  mdast-util-mdx@3.0.0:
+    resolution: {integrity: sha512-JfbYLAW7XnYTTbUsmpu0kdBUVe+yKVJZBItEjwyYJiDJuZ9w4eeaqks4HQO+R7objWgS2ymV60GYpI14Ug554w==}
+
+  mdast-util-mdxjs-esm@2.0.1:
+    resolution: {integrity: sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==}
+
+  mdast-util-phrasing@4.1.0:
+    resolution: {integrity: sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==}
+
+  mdast-util-to-hast@13.2.1:
+    resolution: {integrity: sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==}
+
+  mdast-util-to-markdown@2.1.2:
+    resolution: {integrity: sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==}
+
+  mdast-util-to-string@4.0.0:
+    resolution: {integrity: sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==}
+
+  micromark-core-commonmark@2.0.3:
+    resolution: {integrity: sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==}
+
+  micromark-extension-gfm-autolink-literal@2.1.0:
+    resolution: {integrity: sha512-oOg7knzhicgQ3t4QCjCWgTmfNhvQbDDnJeVu9v81r7NltNCVmhPy1fJRX27pISafdjL+SVc4d3l48Gb6pbRypw==}
+
+  micromark-extension-gfm-footnote@2.1.0:
+    resolution: {integrity: sha512-/yPhxI1ntnDNsiHtzLKYnE3vf9JZ6cAisqVDauhp4CEHxlb4uoOTxOCJ+9s51bIB8U1N1FJ1RXOKTIlD5B/gqw==}
+
+  micromark-extension-gfm-strikethrough@2.1.0:
+    resolution: {integrity: sha512-ADVjpOOkjz1hhkZLlBiYA9cR2Anf8F4HqZUO6e5eDcPQd0Txw5fxLzzxnEkSkfnD0wziSGiv7sYhk/ktvbf1uw==}
+
+  micromark-extension-gfm-table@2.1.1:
+    resolution: {integrity: sha512-t2OU/dXXioARrC6yWfJ4hqB7rct14e8f7m0cbI5hUmDyyIlwv5vEtooptH8INkbLzOatzKuVbQmAYcbWoyz6Dg==}
+
+  micromark-extension-gfm-tagfilter@2.0.0:
+    resolution: {integrity: sha512-xHlTOmuCSotIA8TW1mDIM6X2O1SiX5P9IuDtqGonFhEK0qgRI4yeC6vMxEV2dgyr2TiD+2PQ10o+cOhdVAcwfg==}
+
+  micromark-extension-gfm-task-list-item@2.1.0:
+    resolution: {integrity: sha512-qIBZhqxqI6fjLDYFTBIa4eivDMnP+OZqsNwmQ3xNLE4Cxwc+zfQEfbs6tzAo2Hjq+bh6q5F+Z8/cksrLFYWQQw==}
+
+  micromark-extension-gfm@3.0.0:
+    resolution: {integrity: sha512-vsKArQsicm7t0z2GugkCKtZehqUm31oeGBV/KVSorWSy8ZlNAv7ytjFhvaryUiCUJYqs+NoE6AFhpQvBTM6Q4w==}
+
+  micromark-extension-mdx-expression@3.0.1:
+    resolution: {integrity: sha512-dD/ADLJ1AeMvSAKBwO22zG22N4ybhe7kFIZ3LsDI0GlsNr2A3KYxb0LdC1u5rj4Nw+CHKY0RVdnHX8vj8ejm4Q==}
+
+  micromark-extension-mdx-jsx@3.0.2:
+    resolution: {integrity: sha512-e5+q1DjMh62LZAJOnDraSSbDMvGJ8x3cbjygy2qFEi7HCeUT4BDKCvMozPozcD6WmOt6sVvYDNBKhFSz3kjOVQ==}
+
+  micromark-extension-mdx-md@2.0.0:
+    resolution: {integrity: sha512-EpAiszsB3blw4Rpba7xTOUptcFeBFi+6PY8VnJ2hhimH+vCQDirWgsMpz7w1XcZE7LVrSAUGb9VJpG9ghlYvYQ==}
+
+  micromark-extension-mdxjs-esm@3.0.0:
+    resolution: {integrity: sha512-DJFl4ZqkErRpq/dAPyeWp15tGrcrrJho1hKK5uBS70BCtfrIFg81sqcTVu3Ta+KD1Tk5vAtBNElWxtAa+m8K9A==}
+
+  micromark-extension-mdxjs@3.0.0:
+    resolution: {integrity: sha512-A873fJfhnJ2siZyUrJ31l34Uqwy4xIFmvPY1oj+Ean5PHcPBYzEsvqvWGaWcfEIr11O5Dlw3p2y0tZWpKHDejQ==}
+
+  micromark-factory-destination@2.0.1:
+    resolution: {integrity: sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==}
+
+  micromark-factory-label@2.0.1:
+    resolution: {integrity: sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==}
+
+  micromark-factory-mdx-expression@2.0.3:
+    resolution: {integrity: sha512-kQnEtA3vzucU2BkrIa8/VaSAsP+EJ3CKOvhMuJgOEGg9KDC6OAY6nSnNDVRiVNRqj7Y4SlSzcStaH/5jge8JdQ==}
+
+  micromark-factory-space@2.0.1:
+    resolution: {integrity: sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==}
+
+  micromark-factory-title@2.0.1:
+    resolution: {integrity: sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==}
+
+  micromark-factory-whitespace@2.0.1:
+    resolution: {integrity: sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==}
+
+  micromark-util-character@2.1.1:
+    resolution: {integrity: sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==}
+
+  micromark-util-chunked@2.0.1:
+    resolution: {integrity: sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==}
+
+  micromark-util-classify-character@2.0.1:
+    resolution: {integrity: sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==}
+
+  micromark-util-combine-extensions@2.0.1:
+    resolution: {integrity: sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==}
+
+  micromark-util-decode-numeric-character-reference@2.0.2:
+    resolution: {integrity: sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==}
+
+  micromark-util-decode-string@2.0.1:
+    resolution: {integrity: sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==}
+
+  micromark-util-encode@2.0.1:
+    resolution: {integrity: sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==}
+
+  micromark-util-events-to-acorn@2.0.3:
+    resolution: {integrity: sha512-jmsiEIiZ1n7X1Rr5k8wVExBQCg5jy4UXVADItHmNk1zkwEVhBuIUKRu3fqv+hs4nxLISi2DQGlqIOGiFxgbfHg==}
+
+  micromark-util-html-tag-name@2.0.1:
+    resolution: {integrity: sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==}
+
+  micromark-util-normalize-identifier@2.0.1:
+    resolution: {integrity: sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==}
+
+  micromark-util-resolve-all@2.0.1:
+    resolution: {integrity: sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==}
+
+  micromark-util-sanitize-uri@2.0.1:
+    resolution: {integrity: sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==}
+
+  micromark-util-subtokenize@2.1.0:
+    resolution: {integrity: sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==}
+
+  micromark-util-symbol@2.0.1:
+    resolution: {integrity: sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==}
+
+  micromark-util-types@2.0.2:
+    resolution: {integrity: sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==}
+
+  micromark@4.0.2:
+    resolution: {integrity: sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==}
+
+  motion-dom@12.38.0:
+    resolution: {integrity: sha512-pdkHLD8QYRp8VfiNLb8xIBJis1byQ9gPT3Jnh2jqfFtAsWUA3dEepDlsWe/xMpO8McV+VdpKVcp+E+TGJEtOoA==}
+
+  motion-utils@12.36.0:
+    resolution: {integrity: sha512-eHWisygbiwVvf6PZ1vhaHCLamvkSbPIeAYxWUuL3a2PD/TROgE7FvfHWTIH4vMl798QLfMw15nRqIaRDXTlYRg==}
+
+  motion@12.38.0:
+    resolution: {integrity: sha512-uYfXzeHlgThchzwz5Te47dlv5JOUC7OB4rjJ/7XTUgtBZD8CchMN8qEJ4ZVsUmTyYA44zjV0fBwsiktRuFnn+w==}
+    peerDependencies:
+      '@emotion/is-prop-valid': '*'
+      react: ^18.0.0 || ^19.0.0
+      react-dom: ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@emotion/is-prop-valid':
+        optional: true
+      react:
+        optional: true
+      react-dom:
+        optional: true
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  nanoid@3.3.12:
+    resolution: {integrity: sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  next-themes@0.4.6:
+    resolution: {integrity: sha512-pZvgD5L0IEvX5/9GWyHMf3m8BKiVQwsCMHfoFosXtXBMnaS0ZnIJ9ST4b4NqLVKDEm8QBxoNNGNaBv2JNF6XNA==}
+    peerDependencies:
+      react: ^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17 || ^18 || ^19 || ^19.0.0-rc
+
+  next@16.2.4:
+    resolution: {integrity: sha512-kPvz56wF5frc+FxlHI5qnklCzbq53HTwORaWBGdT0vNoKh1Aya9XC8aPauH4NJxqtzbWsS5mAbctm4cr+EkQ2Q==}
+    engines: {node: '>=20.9.0'}
+    hasBin: true
+    peerDependencies:
+      '@opentelemetry/api': ^1.1.0
+      '@playwright/test': ^1.51.1
+      babel-plugin-react-compiler: '*'
+      react: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0
+      react-dom: ^18.2.0 || 19.0.0-rc-de68d2f4-20241204 || ^19.0.0
+      sass: ^1.3.0
+    peerDependenciesMeta:
+      '@opentelemetry/api':
+        optional: true
+      '@playwright/test':
+        optional: true
+      babel-plugin-react-compiler:
+        optional: true
+      sass:
+        optional: true
+
+  oniguruma-parser@0.12.2:
+    resolution: {integrity: sha512-6HVa5oIrgMC6aA6WF6XyyqbhRPJrKR02L20+2+zpDtO5QAzGHAUGw5TKQvwi5vctNnRHkJYmjAhRVQF2EKdTQw==}
+
+  oniguruma-to-es@4.3.6:
+    resolution: {integrity: sha512-csuQ9x3Yr0cEIs/Zgx/OEt9iBw9vqIunAPQkx19R/fiMq2oGVTgcMqO/V3Ybqefr1TBvosI6jU539ksaBULJyA==}
+
+  parse-entities@4.0.2:
+    resolution: {integrity: sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==}
+
+  parse5@7.3.0:
+    resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  picomatch@4.0.4:
+    resolution: {integrity: sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==}
+    engines: {node: '>=12'}
+
+  postcss@8.4.31:
+    resolution: {integrity: sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  postcss@8.5.14:
+    resolution: {integrity: sha512-SoSL4+OSEtR99LHFZQiJLkT59C5B1amGO1NzTwj7TT1qCUgUO6hxOvzkOYxD+vMrXBM3XJIKzokoERdqQq/Zmg==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  property-information@7.1.0:
+    resolution: {integrity: sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==}
+
+  react-dom@19.2.5:
+    resolution: {integrity: sha512-J5bAZz+DXMMwW/wV3xzKke59Af6CHY7G4uYLN1OvBcKEsWOs4pQExj86BBKamxl/Ik5bx9whOrvBlSDfWzgSag==}
+    peerDependencies:
+      react: ^19.2.5
+
+  react-remove-scroll-bar@2.3.8:
+    resolution: {integrity: sha512-9r+yi9+mgU33AKcj6IbT9oRCO78WriSj6t/cF8DWBZJ9aOGPOTEDvdUDz1FwKim7QXWwmHqtdHnRJfhAxEG46Q==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  react-remove-scroll@2.7.2:
+    resolution: {integrity: sha512-Iqb9NjCCTt6Hf+vOdNIZGdTiH1QSqr27H/Ek9sv/a97gfueI/5h1s3yRi1nngzMUaOOToin5dI1dXKdXiF+u0Q==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  react-style-singleton@2.2.3:
+    resolution: {integrity: sha512-b6jSvxvVnyptAiLjbkWLE/lOnR4lfTtDAl+eUC7RZy+QQWc6wRzIV2CE6xBuMmDxc2qIihtDCZD5NPOFl7fRBQ==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  react@19.2.5:
+    resolution: {integrity: sha512-llUJLzz1zTUBrskt2pwZgLq59AemifIftw4aB7JxOqf1HY2FDaGDxgwpAPVzHU1kdWabH7FauP4i1oEeer2WCA==}
+    engines: {node: '>=0.10.0'}
+
+  readdirp@5.0.0:
+    resolution: {integrity: sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ==}
+    engines: {node: '>= 20.19.0'}
+
+  recma-build-jsx@1.0.0:
+    resolution: {integrity: sha512-8GtdyqaBcDfva+GUKDr3nev3VpKAhup1+RvkMvUxURHpW7QyIvk9F5wz7Vzo06CEMSilw6uArgRqhpiUcWp8ew==}
+
+  recma-jsx@1.0.1:
+    resolution: {integrity: sha512-huSIy7VU2Z5OLv6oFLosQGGDqPqdO1iq6bWNAdhzMxSJP7RAso4fCZ1cKu8j9YHCZf3TPrq4dw3okhrylgcd7w==}
+    peerDependencies:
+      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+
+  recma-parse@1.0.0:
+    resolution: {integrity: sha512-OYLsIGBB5Y5wjnSnQW6t3Xg7q3fQ7FWbw/vcXtORTnyaSFscOtABg+7Pnz6YZ6c27fG1/aN8CjfwoUEUIdwqWQ==}
+
+  recma-stringify@1.0.0:
+    resolution: {integrity: sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==}
+
+  regex-recursion@6.0.2:
+    resolution: {integrity: sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==}
+
+  regex-utilities@2.3.0:
+    resolution: {integrity: sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==}
+
+  regex@6.1.0:
+    resolution: {integrity: sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg==}
+
+  rehype-raw@7.0.0:
+    resolution: {integrity: sha512-/aE8hCfKlQeA8LmyeyQvQF3eBiLRGNlfBJEvWH7ivp9sBqs7TNqBL5X3v157rM4IFETqDnIOO+z5M/biZbo9Ww==}
+
+  rehype-recma@1.0.0:
+    resolution: {integrity: sha512-lqA4rGUf1JmacCNWWZx0Wv1dHqMwxzsDWYMTowuplHF3xH0N/MmrZ/G3BDZnzAkRmxDadujCjaKM2hqYdCBOGw==}
+
+  remark-gfm@4.0.1:
+    resolution: {integrity: sha512-1quofZ2RQ9EWdeN34S79+KExV1764+wCUGop5CPL1WGdD0ocPpu91lzPGbwWMECpEpd42kJGQwzRfyov9j4yNg==}
+
+  remark-mdx@3.1.1:
+    resolution: {integrity: sha512-Pjj2IYlUY3+D8x00UJsIOg5BEvfMyeI+2uLPn9VO9Wg4MEtN/VTIq2NEJQfde9PnX15KgtHyl9S0BcTnWrIuWg==}
+
+  remark-parse@11.0.0:
+    resolution: {integrity: sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==}
+
+  remark-rehype@11.1.2:
+    resolution: {integrity: sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==}
+
+  remark-stringify@11.0.0:
+    resolution: {integrity: sha512-1OSmLd3awB/t8qdoEOMazZkNsfVTeY4fTsgzcQFdXNq8ToTN4ZGwrMnlda4K6smTFKD+GRV6O48i6Z4iKgPPpw==}
+
+  remark@15.0.1:
+    resolution: {integrity: sha512-Eht5w30ruCXgFmxVUSlNWQ9iiimq07URKeFS3hNc8cUWy1llX4KDWfyEDZRycMc+znsN9Ux5/tJ/BFdgdOwA3A==}
+
+  scheduler@0.27.0:
+    resolution: {integrity: sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==}
+
+  scroll-into-view-if-needed@3.1.0:
+    resolution: {integrity: sha512-49oNpRjWRvnU8NyGVmUaYG4jtTkNonFZI86MmGRDqBphEK2EXT9gdEUoQPZhuBM8yWHxCWbobltqYO5M4XrUvQ==}
+
+  semver@7.7.4:
+    resolution: {integrity: sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  sharp@0.34.5:
+    resolution: {integrity: sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==}
+    engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
+
+  shiki@4.0.2:
+    resolution: {integrity: sha512-eAVKTMedR5ckPo4xne/PjYQYrU3qx78gtJZ+sHlXEg5IHhhoQhMfZVzetTYuaJS0L2Ef3AcCRzCHV8T0WI6nIQ==}
+    engines: {node: '>=20'}
+
+  source-map-js@1.2.1:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  source-map@0.7.6:
+    resolution: {integrity: sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==}
+    engines: {node: '>= 12'}
+
+  space-separated-tokens@2.0.2:
+    resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==}
+
+  stringify-entities@4.0.4:
+    resolution: {integrity: sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==}
+
+  style-to-js@1.1.21:
+    resolution: {integrity: sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==}
+
+  style-to-object@1.0.14:
+    resolution: {integrity: sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==}
+
+  styled-jsx@5.1.6:
+    resolution: {integrity: sha512-qSVyDTeMotdvQYoHWLNGwRFJHC+i+ZvdBRYosOFgC+Wg1vx4frN2/RG/NA7SYqqvKNLf39P2LSRA2pu6n0XYZA==}
+    engines: {node: '>= 12.0.0'}
+    peerDependencies:
+      '@babel/core': '*'
+      babel-plugin-macros: '*'
+      react: '>= 16.8.0 || 17.x.x || ^18.0.0-0 || ^19.0.0-0'
+    peerDependenciesMeta:
+      '@babel/core':
+        optional: true
+      babel-plugin-macros:
+        optional: true
+
+  tailwind-merge@3.5.0:
+    resolution: {integrity: sha512-I8K9wewnVDkL1NTGoqWmVEIlUcB9gFriAEkXkfCjX5ib8ezGxtR3xD7iZIxrfArjEsH7F1CHD4RFUtxefdqV/A==}
+
+  tailwindcss@4.2.4:
+    resolution: {integrity: sha512-HhKppgO81FQof5m6TEnuBWCZGgfRAWbaeOaGT00KOy/Pf/j6oUihdvBpA7ltCeAvZpFhW3j0PTclkxsd4IXYDA==}
+
+  tapable@2.3.3:
+    resolution: {integrity: sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==}
+    engines: {node: '>=6'}
+
+  tinyexec@1.1.2:
+    resolution: {integrity: sha512-dAqSqE/RabpBKI8+h26GfLq6Vb3JVXs30XYQjdMjaj/c2tS8IYYMbIzP599KtRj7c57/wYApb3QjgRgXmrCukA==}
+    engines: {node: '>=18'}
+
+  tinyglobby@0.2.16:
+    resolution: {integrity: sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==}
+    engines: {node: '>=12.0.0'}
+
+  trim-lines@3.0.1:
+    resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==}
+
+  trough@2.2.0:
+    resolution: {integrity: sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==}
+
+  tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
+
+  typescript@6.0.3:
+    resolution: {integrity: sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  undici-types@7.19.2:
+    resolution: {integrity: sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg==}
+
+  unified@11.0.5:
+    resolution: {integrity: sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==}
+
+  unist-util-is@6.0.1:
+    resolution: {integrity: sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==}
+
+  unist-util-position-from-estree@2.0.0:
+    resolution: {integrity: sha512-KaFVRjoqLyF6YXCbVLNad/eS4+OfPQQn2yOd7zF/h5T/CSL2v8NpN6a5TPvtbXthAGw5nG+PuTtq+DdIZr+cRQ==}
+
+  unist-util-position@5.0.0:
+    resolution: {integrity: sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==}
+
+  unist-util-remove-position@5.0.0:
+    resolution: {integrity: sha512-Hp5Kh3wLxv0PHj9m2yZhhLt58KzPtEYKQQ4yxfYFEO7EvHwzyDYnduhHnY1mDxoqr7VUwVuHXk9RXKIiYS1N8Q==}
+
+  unist-util-stringify-position@4.0.0:
+    resolution: {integrity: sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==}
+
+  unist-util-visit-parents@6.0.2:
+    resolution: {integrity: sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==}
+
+  unist-util-visit@5.1.0:
+    resolution: {integrity: sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==}
+
+  use-callback-ref@1.3.3:
+    resolution: {integrity: sha512-jQL3lRnocaFtu3V00JToYz/4QkNWswxijDaCVNZRiRTO3HQDLsdu1ZtmIUvV4yPp+rvWm5j0y0TG/S61cuijTg==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  use-sidecar@1.1.3:
+    resolution: {integrity: sha512-Fedw0aZvkhynoPYlA5WXrMCAMm+nSWdZt6lzJQ7Ok8S6Q+VsHmHpRWndVRJ8Be0ZbkfPc5LRYH+5XrzXcEeLRQ==}
+    engines: {node: '>=10'}
+    peerDependencies:
+      '@types/react': '*'
+      react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+
+  vfile-location@5.0.3:
+    resolution: {integrity: sha512-5yXvWDEgqeiYiBe1lbxYF7UMAIm/IcopxMHrMQDq3nvKcjPKIhZklUKL+AE7J7uApI4kwe2snsK+eI6UTj9EHg==}
+
+  vfile-message@4.0.3:
+    resolution: {integrity: sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==}
+
+  vfile@6.0.3:
+    resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==}
+
+  web-namespaces@2.0.1:
+    resolution: {integrity: sha512-bKr1DkiNa2krS7qxNtdrtHAmzuYGFQLiQ13TsorsdT6ULTkPLKuu5+GsFpDlg6JFjUTwX2DyhMPG2be8uPrqsQ==}
+
+  zod@4.4.3:
+    resolution: {integrity: sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==}
+
+  zwitch@2.0.4:
+    resolution: {integrity: sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==}
+
+snapshots:
+
+  '@alloc/quick-lru@5.2.0': {}
+
+  '@emnapi/runtime@1.10.0':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@esbuild/aix-ppc64@0.28.0':
+    optional: true
+
+  '@esbuild/android-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/android-arm@0.28.0':
+    optional: true
+
+  '@esbuild/android-x64@0.28.0':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/darwin-x64@0.28.0':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-arm@0.28.0':
+    optional: true
+
+  '@esbuild/linux-ia32@0.28.0':
+    optional: true
+
+  '@esbuild/linux-loong64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.28.0':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-s390x@0.28.0':
+    optional: true
+
+  '@esbuild/linux-x64@0.28.0':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.28.0':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.28.0':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/sunos-x64@0.28.0':
+    optional: true
+
+  '@esbuild/win32-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/win32-ia32@0.28.0':
+    optional: true
+
+  '@esbuild/win32-x64@0.28.0':
+    optional: true
+
+  '@floating-ui/core@1.7.5':
+    dependencies:
+      '@floating-ui/utils': 0.2.11
+
+  '@floating-ui/dom@1.7.6':
+    dependencies:
+      '@floating-ui/core': 1.7.5
+      '@floating-ui/utils': 0.2.11
+
+  '@floating-ui/react-dom@2.1.8(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@floating-ui/dom': 1.7.6
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+
+  '@floating-ui/utils@0.2.11': {}
+
+  '@fumadocs/tailwind@0.0.5(@tailwindcss/oxide@4.2.4)(tailwindcss@4.2.4)':
+    optionalDependencies:
+      '@tailwindcss/oxide': 4.2.4
+      tailwindcss: 4.2.4
+
+  '@img/colour@1.1.0':
+    optional: true
+
+  '@img/sharp-darwin-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-arm64': 1.2.4
+    optional: true
+
+  '@img/sharp-darwin-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-x64': 1.2.4
+    optional: true
+
+  '@img/sharp-libvips-darwin-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-darwin-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-ppc64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-riscv64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-s390x@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linux-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.2.4':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-x64@1.2.4':
+    optional: true
+
+  '@img/sharp-linux-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-arm@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-ppc64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-ppc64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-riscv64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-riscv64': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-s390x@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-s390x': 1.2.4
+    optional: true
+
+  '@img/sharp-linux-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-x64': 1.2.4
+    optional: true
+
+  '@img/sharp-linuxmusl-arm64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-arm64': 1.2.4
+    optional: true
+
+  '@img/sharp-linuxmusl-x64@0.34.5':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-x64': 1.2.4
+    optional: true
+
+  '@img/sharp-wasm32@0.34.5':
+    dependencies:
+      '@emnapi/runtime': 1.10.0
+    optional: true
+
+  '@img/sharp-win32-arm64@0.34.5':
+    optional: true
+
+  '@img/sharp-win32-ia32@0.34.5':
+    optional: true
+
+  '@img/sharp-win32-x64@0.34.5':
+    optional: true
+
+  '@jridgewell/gen-mapping@0.3.13':
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/remapping@2.3.5':
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/resolve-uri@3.1.2': {}
+
+  '@jridgewell/sourcemap-codec@1.5.5': {}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  '@mdx-js/mdx@3.1.1':
+    dependencies:
+      '@types/estree': 1.0.8
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdx': 2.0.13
+      acorn: 8.16.0
+      collapse-white-space: 2.1.0
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      estree-util-scope: 1.0.0
+      estree-walker: 3.0.3
+      hast-util-to-jsx-runtime: 2.3.6
+      markdown-extensions: 2.0.0
+      recma-build-jsx: 1.0.0
+      recma-jsx: 1.0.1(acorn@8.16.0)
+      recma-stringify: 1.0.0
+      rehype-recma: 1.0.0
+      remark-mdx: 3.1.1
+      remark-parse: 11.0.0
+      remark-rehype: 11.1.2
+      source-map: 0.7.6
+      unified: 11.0.5
+      unist-util-position-from-estree: 2.0.0
+      unist-util-stringify-position: 4.0.0
+      unist-util-visit: 5.1.0
+      vfile: 6.0.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@next/env@16.2.4': {}
+
+  '@next/swc-darwin-arm64@16.2.4':
+    optional: true
+
+  '@next/swc-darwin-x64@16.2.4':
+    optional: true
+
+  '@next/swc-linux-arm64-gnu@16.2.4':
+    optional: true
+
+  '@next/swc-linux-arm64-musl@16.2.4':
+    optional: true
+
+  '@next/swc-linux-x64-gnu@16.2.4':
+    optional: true
+
+  '@next/swc-linux-x64-musl@16.2.4':
+    optional: true
+
+  '@next/swc-win32-arm64-msvc@16.2.4':
+    optional: true
+
+  '@next/swc-win32-x64-msvc@16.2.4':
+    optional: true
+
+  '@orama/orama@3.1.18': {}
+
+  '@radix-ui/number@1.1.1': {}
+
+  '@radix-ui/primitive@1.1.3': {}
+
+  '@radix-ui/react-accordion@1.2.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collapsible': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-arrow@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-collapsible@1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-collection@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-compose-refs@1.1.2(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-context@1.1.2(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-dialog@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-focus-guards': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-focus-scope': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.5)
+      aria-hidden: 1.2.6
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      react-remove-scroll: 2.7.2(@types/react@19.2.14)(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-direction@1.1.1(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-dismissable-layer@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-escape-keydown': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-focus-guards@1.1.3(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-focus-scope@1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-id@1.1.1(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-navigation-menu@1.2.14(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-popover@1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-focus-guards': 1.1.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-focus-scope': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.5)
+      aria-hidden: 1.2.6
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      react-remove-scroll: 2.7.2(@types/react@19.2.14)(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-popper@1.2.8(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@floating-ui/react-dom': 2.1.8(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-arrow': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-rect': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/rect': 1.1.1
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-portal@1.1.9(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-presence@1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-primitive@2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-roving-focus@1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-scroll-area@1.2.10(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/number': 1.1.1
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-slot@1.2.3(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-slot@1.2.4(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-tabs@1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/react-use-callback-ref@1.1.1(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-controllable-state@1.2.2(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-effect-event@0.0.2(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-escape-keydown@1.1.1(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-layout-effect@1.1.1(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-previous@1.1.1(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-rect@1.1.1(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/rect': 1.1.1
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-use-size@1.1.1(@types/react@19.2.14)(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      react: 19.2.5
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  '@radix-ui/react-visually-hidden@1.2.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+      '@types/react-dom': 19.2.3(@types/react@19.2.14)
+
+  '@radix-ui/rect@1.1.1': {}
+
+  '@shikijs/core@4.0.2':
+    dependencies:
+      '@shikijs/primitive': 4.0.2
+      '@shikijs/types': 4.0.2
+      '@shikijs/vscode-textmate': 10.0.2
+      '@types/hast': 3.0.4
+      hast-util-to-html: 9.0.5
+
+  '@shikijs/engine-javascript@4.0.2':
+    dependencies:
+      '@shikijs/types': 4.0.2
+      '@shikijs/vscode-textmate': 10.0.2
+      oniguruma-to-es: 4.3.6
+
+  '@shikijs/engine-oniguruma@4.0.2':
+    dependencies:
+      '@shikijs/types': 4.0.2
+      '@shikijs/vscode-textmate': 10.0.2
+
+  '@shikijs/langs@4.0.2':
+    dependencies:
+      '@shikijs/types': 4.0.2
+
+  '@shikijs/primitive@4.0.2':
+    dependencies:
+      '@shikijs/types': 4.0.2
+      '@shikijs/vscode-textmate': 10.0.2
+      '@types/hast': 3.0.4
+
+  '@shikijs/themes@4.0.2':
+    dependencies:
+      '@shikijs/types': 4.0.2
+
+  '@shikijs/types@4.0.2':
+    dependencies:
+      '@shikijs/vscode-textmate': 10.0.2
+      '@types/hast': 3.0.4
+
+  '@shikijs/vscode-textmate@10.0.2': {}
+
+  '@standard-schema/spec@1.1.0': {}
+
+  '@swc/helpers@0.5.15':
+    dependencies:
+      tslib: 2.8.1
+
+  '@tailwindcss/node@4.2.4':
+    dependencies:
+      '@jridgewell/remapping': 2.3.5
+      enhanced-resolve: 5.21.0
+      jiti: 2.6.1
+      lightningcss: 1.32.0
+      magic-string: 0.30.21
+      source-map-js: 1.2.1
+      tailwindcss: 4.2.4
+
+  '@tailwindcss/oxide-android-arm64@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide-darwin-arm64@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide-darwin-x64@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide-freebsd-x64@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm64-gnu@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm64-musl@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide-linux-x64-gnu@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide-linux-x64-musl@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide-wasm32-wasi@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide-win32-arm64-msvc@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide-win32-x64-msvc@4.2.4':
+    optional: true
+
+  '@tailwindcss/oxide@4.2.4':
+    optionalDependencies:
+      '@tailwindcss/oxide-android-arm64': 4.2.4
+      '@tailwindcss/oxide-darwin-arm64': 4.2.4
+      '@tailwindcss/oxide-darwin-x64': 4.2.4
+      '@tailwindcss/oxide-freebsd-x64': 4.2.4
+      '@tailwindcss/oxide-linux-arm-gnueabihf': 4.2.4
+      '@tailwindcss/oxide-linux-arm64-gnu': 4.2.4
+      '@tailwindcss/oxide-linux-arm64-musl': 4.2.4
+      '@tailwindcss/oxide-linux-x64-gnu': 4.2.4
+      '@tailwindcss/oxide-linux-x64-musl': 4.2.4
+      '@tailwindcss/oxide-wasm32-wasi': 4.2.4
+      '@tailwindcss/oxide-win32-arm64-msvc': 4.2.4
+      '@tailwindcss/oxide-win32-x64-msvc': 4.2.4
+
+  '@tailwindcss/postcss@4.2.4':
+    dependencies:
+      '@alloc/quick-lru': 5.2.0
+      '@tailwindcss/node': 4.2.4
+      '@tailwindcss/oxide': 4.2.4
+      postcss: 8.5.14
+      tailwindcss: 4.2.4
+
+  '@types/debug@4.1.13':
+    dependencies:
+      '@types/ms': 2.1.0
+
+  '@types/estree-jsx@1.0.5':
+    dependencies:
+      '@types/estree': 1.0.8
+
+  '@types/estree@1.0.8': {}
+
+  '@types/hast@3.0.4':
+    dependencies:
+      '@types/unist': 3.0.3
+
+  '@types/mdast@4.0.4':
+    dependencies:
+      '@types/unist': 3.0.3
+
+  '@types/mdx@2.0.13': {}
+
+  '@types/ms@2.1.0': {}
+
+  '@types/node@25.6.0':
+    dependencies:
+      undici-types: 7.19.2
+
+  '@types/react-dom@19.2.3(@types/react@19.2.14)':
+    dependencies:
+      '@types/react': 19.2.14
+
+  '@types/react@19.2.14':
+    dependencies:
+      csstype: 3.2.3
+
+  '@types/unist@2.0.11': {}
+
+  '@types/unist@3.0.3': {}
+
+  '@ungap/structured-clone@1.3.0': {}
+
+  acorn-jsx@5.3.2(acorn@8.16.0):
+    dependencies:
+      acorn: 8.16.0
+
+  acorn@8.16.0: {}
+
+  argparse@2.0.1: {}
+
+  aria-hidden@1.2.6:
+    dependencies:
+      tslib: 2.8.1
+
+  astring@1.9.0: {}
+
+  bail@2.0.2: {}
+
+  baseline-browser-mapping@2.10.27: {}
+
+  caniuse-lite@1.0.30001791: {}
+
+  ccount@2.0.1: {}
+
+  character-entities-html4@2.1.0: {}
+
+  character-entities-legacy@3.0.0: {}
+
+  character-entities@2.0.2: {}
+
+  character-reference-invalid@2.0.1: {}
+
+  chokidar@5.0.0:
+    dependencies:
+      readdirp: 5.0.0
+
+  class-variance-authority@0.7.1:
+    dependencies:
+      clsx: 2.1.1
+
+  client-only@0.0.1: {}
+
+  clsx@2.1.1: {}
+
+  collapse-white-space@2.1.0: {}
+
+  comma-separated-tokens@2.0.3: {}
+
+  compute-scroll-into-view@3.1.1: {}
+
+  csstype@3.2.3: {}
+
+  debug@4.4.3:
+    dependencies:
+      ms: 2.1.3
+
+  decode-named-character-reference@1.3.0:
+    dependencies:
+      character-entities: 2.0.2
+
+  dequal@2.0.3: {}
+
+  detect-libc@2.1.2: {}
+
+  detect-node-es@1.1.0: {}
+
+  devlop@1.1.0:
+    dependencies:
+      dequal: 2.0.3
+
+  enhanced-resolve@5.21.0:
+    dependencies:
+      graceful-fs: 4.2.11
+      tapable: 2.3.3
+
+  entities@6.0.1: {}
+
+  esast-util-from-estree@2.0.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      devlop: 1.1.0
+      estree-util-visit: 2.0.0
+      unist-util-position-from-estree: 2.0.0
+
+  esast-util-from-js@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      acorn: 8.16.0
+      esast-util-from-estree: 2.0.0
+      vfile-message: 4.0.3
+
+  esbuild@0.28.0:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.28.0
+      '@esbuild/android-arm': 0.28.0
+      '@esbuild/android-arm64': 0.28.0
+      '@esbuild/android-x64': 0.28.0
+      '@esbuild/darwin-arm64': 0.28.0
+      '@esbuild/darwin-x64': 0.28.0
+      '@esbuild/freebsd-arm64': 0.28.0
+      '@esbuild/freebsd-x64': 0.28.0
+      '@esbuild/linux-arm': 0.28.0
+      '@esbuild/linux-arm64': 0.28.0
+      '@esbuild/linux-ia32': 0.28.0
+      '@esbuild/linux-loong64': 0.28.0
+      '@esbuild/linux-mips64el': 0.28.0
+      '@esbuild/linux-ppc64': 0.28.0
+      '@esbuild/linux-riscv64': 0.28.0
+      '@esbuild/linux-s390x': 0.28.0
+      '@esbuild/linux-x64': 0.28.0
+      '@esbuild/netbsd-arm64': 0.28.0
+      '@esbuild/netbsd-x64': 0.28.0
+      '@esbuild/openbsd-arm64': 0.28.0
+      '@esbuild/openbsd-x64': 0.28.0
+      '@esbuild/openharmony-arm64': 0.28.0
+      '@esbuild/sunos-x64': 0.28.0
+      '@esbuild/win32-arm64': 0.28.0
+      '@esbuild/win32-ia32': 0.28.0
+      '@esbuild/win32-x64': 0.28.0
+
+  escape-string-regexp@5.0.0: {}
+
+  estree-util-attach-comments@3.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+
+  estree-util-build-jsx@3.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      estree-walker: 3.0.3
+
+  estree-util-is-identifier-name@3.0.0: {}
+
+  estree-util-scope@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      devlop: 1.1.0
+
+  estree-util-to-js@2.0.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      astring: 1.9.0
+      source-map: 0.7.6
+
+  estree-util-value-to-estree@3.5.0:
+    dependencies:
+      '@types/estree': 1.0.8
+
+  estree-util-visit@2.0.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/unist': 3.0.3
+
+  estree-walker@3.0.3:
+    dependencies:
+      '@types/estree': 1.0.8
+
+  extend@3.0.2: {}
+
+  fdir@6.5.0(picomatch@4.0.4):
+    optionalDependencies:
+      picomatch: 4.0.4
+
+  framer-motion@12.38.0(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
+    dependencies:
+      motion-dom: 12.38.0
+      motion-utils: 12.36.0
+      tslib: 2.8.1
+    optionalDependencies:
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+
+  fumadocs-core@16.8.7(@mdx-js/mdx@3.1.1)(@types/estree-jsx@1.0.5)(@types/hast@3.0.4)(@types/mdast@4.0.4)(@types/react@19.2.14)(lucide-react@0.515.0(react@19.2.5))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react-dom@19.2.5(react@19.2.5))(react@19.2.5)(zod@4.4.3):
+    dependencies:
+      '@orama/orama': 3.1.18
+      estree-util-value-to-estree: 3.5.0
+      github-slugger: 2.0.0
+      hast-util-to-estree: 3.1.3
+      hast-util-to-jsx-runtime: 2.3.6
+      js-yaml: 4.1.1
+      mdast-util-mdx: 3.0.0
+      mdast-util-to-markdown: 2.1.2
+      remark: 15.0.1
+      remark-gfm: 4.0.1
+      remark-rehype: 11.1.2
+      scroll-into-view-if-needed: 3.1.0
+      shiki: 4.0.2
+      tinyglobby: 0.2.16
+      unified: 11.0.5
+      unist-util-visit: 5.1.0
+      vfile: 6.0.3
+    optionalDependencies:
+      '@mdx-js/mdx': 3.1.1
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@types/react': 19.2.14
+      lucide-react: 0.515.0(react@19.2.5)
+      next: 16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      zod: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  fumadocs-mdx@14.3.2(@types/mdast@4.0.4)(@types/mdx@2.0.13)(@types/react@19.2.14)(fumadocs-core@16.8.7(@mdx-js/mdx@3.1.1)(@types/estree-jsx@1.0.5)(@types/hast@3.0.4)(@types/mdast@4.0.4)(@types/react@19.2.14)(lucide-react@0.515.0(react@19.2.5))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react-dom@19.2.5(react@19.2.5))(react@19.2.5)(zod@4.4.3))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react@19.2.5):
+    dependencies:
+      '@mdx-js/mdx': 3.1.1
+      '@standard-schema/spec': 1.1.0
+      chokidar: 5.0.0
+      esbuild: 0.28.0
+      estree-util-value-to-estree: 3.5.0
+      fumadocs-core: 16.8.7(@mdx-js/mdx@3.1.1)(@types/estree-jsx@1.0.5)(@types/hast@3.0.4)(@types/mdast@4.0.4)(@types/react@19.2.14)(lucide-react@0.515.0(react@19.2.5))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react-dom@19.2.5(react@19.2.5))(react@19.2.5)(zod@4.4.3)
+      js-yaml: 4.1.1
+      mdast-util-mdx: 3.0.0
+      mdast-util-to-markdown: 2.1.2
+      picocolors: 1.1.1
+      picomatch: 4.0.4
+      tinyexec: 1.1.2
+      tinyglobby: 0.2.16
+      unified: 11.0.5
+      unist-util-remove-position: 5.0.0
+      unist-util-visit: 5.1.0
+      vfile: 6.0.3
+      zod: 4.4.3
+    optionalDependencies:
+      '@types/mdast': 4.0.4
+      '@types/mdx': 2.0.13
+      '@types/react': 19.2.14
+      next: 16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+    transitivePeerDependencies:
+      - supports-color
+
+  fumadocs-ui@16.8.7(@tailwindcss/oxide@4.2.4)(@types/mdx@2.0.13)(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(fumadocs-core@16.8.7(@mdx-js/mdx@3.1.1)(@types/estree-jsx@1.0.5)(@types/hast@3.0.4)(@types/mdast@4.0.4)(@types/react@19.2.14)(lucide-react@0.515.0(react@19.2.5))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react-dom@19.2.5(react@19.2.5))(react@19.2.5)(zod@4.4.3))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react-dom@19.2.5(react@19.2.5))(react@19.2.5)(tailwindcss@4.2.4):
+    dependencies:
+      '@fumadocs/tailwind': 0.0.5(@tailwindcss/oxide@4.2.4)(tailwindcss@4.2.4)
+      '@radix-ui/react-accordion': 1.2.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-collapsible': 1.1.12(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-dialog': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-navigation-menu': 1.2.14(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-popover': 1.1.15(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-scroll-area': 1.2.10(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      '@radix-ui/react-slot': 1.2.4(@types/react@19.2.14)(react@19.2.5)
+      '@radix-ui/react-tabs': 1.1.13(@types/react-dom@19.2.3(@types/react@19.2.14))(@types/react@19.2.14)(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      class-variance-authority: 0.7.1
+      fumadocs-core: 16.8.7(@mdx-js/mdx@3.1.1)(@types/estree-jsx@1.0.5)(@types/hast@3.0.4)(@types/mdast@4.0.4)(@types/react@19.2.14)(lucide-react@0.515.0(react@19.2.5))(next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5))(react-dom@19.2.5(react@19.2.5))(react@19.2.5)(zod@4.4.3)
+      lucide-react: 1.14.0(react@19.2.5)
+      motion: 12.38.0(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      next-themes: 0.4.6(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      react-remove-scroll: 2.7.2(@types/react@19.2.14)(react@19.2.5)
+      rehype-raw: 7.0.0
+      scroll-into-view-if-needed: 3.1.0
+      shiki: 4.0.2
+      tailwind-merge: 3.5.0
+      unist-util-visit: 5.1.0
+    optionalDependencies:
+      '@types/mdx': 2.0.13
+      '@types/react': 19.2.14
+      next: 16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+    transitivePeerDependencies:
+      - '@emotion/is-prop-valid'
+      - '@tailwindcss/oxide'
+      - '@types/react-dom'
+      - tailwindcss
+
+  get-nonce@1.0.1: {}
+
+  github-slugger@2.0.0: {}
+
+  graceful-fs@4.2.11: {}
+
+  hast-util-from-parse5@8.0.3:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      devlop: 1.1.0
+      hastscript: 9.0.1
+      property-information: 7.1.0
+      vfile: 6.0.3
+      vfile-location: 5.0.3
+      web-namespaces: 2.0.1
+
+  hast-util-parse-selector@4.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hast-util-raw@9.1.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      '@ungap/structured-clone': 1.3.0
+      hast-util-from-parse5: 8.0.3
+      hast-util-to-parse5: 8.0.1
+      html-void-elements: 3.0.0
+      mdast-util-to-hast: 13.2.1
+      parse5: 7.3.0
+      unist-util-position: 5.0.0
+      unist-util-visit: 5.1.0
+      vfile: 6.0.3
+      web-namespaces: 2.0.1
+      zwitch: 2.0.4
+
+  hast-util-to-estree@3.1.3:
+    dependencies:
+      '@types/estree': 1.0.8
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      comma-separated-tokens: 2.0.3
+      devlop: 1.1.0
+      estree-util-attach-comments: 3.0.0
+      estree-util-is-identifier-name: 3.0.0
+      hast-util-whitespace: 3.0.0
+      mdast-util-mdx-expression: 2.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      mdast-util-mdxjs-esm: 2.0.1
+      property-information: 7.1.0
+      space-separated-tokens: 2.0.2
+      style-to-js: 1.1.21
+      unist-util-position: 5.0.0
+      zwitch: 2.0.4
+    transitivePeerDependencies:
+      - supports-color
+
+  hast-util-to-html@9.0.5:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      ccount: 2.0.1
+      comma-separated-tokens: 2.0.3
+      hast-util-whitespace: 3.0.0
+      html-void-elements: 3.0.0
+      mdast-util-to-hast: 13.2.1
+      property-information: 7.1.0
+      space-separated-tokens: 2.0.2
+      stringify-entities: 4.0.4
+      zwitch: 2.0.4
+
+  hast-util-to-jsx-runtime@2.3.6:
+    dependencies:
+      '@types/estree': 1.0.8
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      comma-separated-tokens: 2.0.3
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      hast-util-whitespace: 3.0.0
+      mdast-util-mdx-expression: 2.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      mdast-util-mdxjs-esm: 2.0.1
+      property-information: 7.1.0
+      space-separated-tokens: 2.0.2
+      style-to-js: 1.1.21
+      unist-util-position: 5.0.0
+      vfile-message: 4.0.3
+    transitivePeerDependencies:
+      - supports-color
+
+  hast-util-to-parse5@8.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      comma-separated-tokens: 2.0.3
+      devlop: 1.1.0
+      property-information: 7.1.0
+      space-separated-tokens: 2.0.2
+      web-namespaces: 2.0.1
+      zwitch: 2.0.4
+
+  hast-util-whitespace@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  hastscript@9.0.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      comma-separated-tokens: 2.0.3
+      hast-util-parse-selector: 4.0.0
+      property-information: 7.1.0
+      space-separated-tokens: 2.0.2
+
+  html-void-elements@3.0.0: {}
+
+  inline-style-parser@0.2.7: {}
+
+  is-alphabetical@2.0.1: {}
+
+  is-alphanumerical@2.0.1:
+    dependencies:
+      is-alphabetical: 2.0.1
+      is-decimal: 2.0.1
+
+  is-decimal@2.0.1: {}
+
+  is-hexadecimal@2.0.1: {}
+
+  is-plain-obj@4.1.0: {}
+
+  jiti@2.6.1: {}
+
+  js-yaml@4.1.1:
+    dependencies:
+      argparse: 2.0.1
+
+  lightningcss-android-arm64@1.32.0:
+    optional: true
+
+  lightningcss-darwin-arm64@1.32.0:
+    optional: true
+
+  lightningcss-darwin-x64@1.32.0:
+    optional: true
+
+  lightningcss-freebsd-x64@1.32.0:
+    optional: true
+
+  lightningcss-linux-arm-gnueabihf@1.32.0:
+    optional: true
+
+  lightningcss-linux-arm64-gnu@1.32.0:
+    optional: true
+
+  lightningcss-linux-arm64-musl@1.32.0:
+    optional: true
+
+  lightningcss-linux-x64-gnu@1.32.0:
+    optional: true
+
+  lightningcss-linux-x64-musl@1.32.0:
+    optional: true
+
+  lightningcss-win32-arm64-msvc@1.32.0:
+    optional: true
+
+  lightningcss-win32-x64-msvc@1.32.0:
+    optional: true
+
+  lightningcss@1.32.0:
+    dependencies:
+      detect-libc: 2.1.2
+    optionalDependencies:
+      lightningcss-android-arm64: 1.32.0
+      lightningcss-darwin-arm64: 1.32.0
+      lightningcss-darwin-x64: 1.32.0
+      lightningcss-freebsd-x64: 1.32.0
+      lightningcss-linux-arm-gnueabihf: 1.32.0
+      lightningcss-linux-arm64-gnu: 1.32.0
+      lightningcss-linux-arm64-musl: 1.32.0
+      lightningcss-linux-x64-gnu: 1.32.0
+      lightningcss-linux-x64-musl: 1.32.0
+      lightningcss-win32-arm64-msvc: 1.32.0
+      lightningcss-win32-x64-msvc: 1.32.0
+
+  longest-streak@3.1.0: {}
+
+  lucide-react@0.515.0(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+
+  lucide-react@1.14.0(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+
+  magic-string@0.30.21:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  markdown-extensions@2.0.0: {}
+
+  markdown-table@3.0.4: {}
+
+  mdast-util-find-and-replace@3.0.2:
+    dependencies:
+      '@types/mdast': 4.0.4
+      escape-string-regexp: 5.0.0
+      unist-util-is: 6.0.1
+      unist-util-visit-parents: 6.0.2
+
+  mdast-util-from-markdown@2.0.3:
+    dependencies:
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      decode-named-character-reference: 1.3.0
+      devlop: 1.1.0
+      mdast-util-to-string: 4.0.0
+      micromark: 4.0.2
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-decode-string: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      unist-util-stringify-position: 4.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-autolink-literal@2.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      ccount: 2.0.1
+      devlop: 1.1.0
+      mdast-util-find-and-replace: 3.0.2
+      micromark-util-character: 2.1.1
+
+  mdast-util-gfm-footnote@2.1.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+      micromark-util-normalize-identifier: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-strikethrough@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-table@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      markdown-table: 3.0.4
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm-task-list-item@2.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-gfm@3.1.0:
+    dependencies:
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-gfm-autolink-literal: 2.0.1
+      mdast-util-gfm-footnote: 2.1.0
+      mdast-util-gfm-strikethrough: 2.0.0
+      mdast-util-gfm-table: 2.0.0
+      mdast-util-gfm-task-list-item: 2.0.0
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx-expression@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx-jsx@3.2.0:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      ccount: 2.0.1
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+      parse-entities: 4.0.2
+      stringify-entities: 4.0.4
+      unist-util-stringify-position: 4.0.0
+      vfile-message: 4.0.3
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdx@3.0.0:
+    dependencies:
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-mdx-expression: 2.0.1
+      mdast-util-mdx-jsx: 3.2.0
+      mdast-util-mdxjs-esm: 2.0.1
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-mdxjs-esm@2.0.1:
+    dependencies:
+      '@types/estree-jsx': 1.0.5
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      devlop: 1.1.0
+      mdast-util-from-markdown: 2.0.3
+      mdast-util-to-markdown: 2.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  mdast-util-phrasing@4.1.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      unist-util-is: 6.0.1
+
+  mdast-util-to-hast@13.2.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@ungap/structured-clone': 1.3.0
+      devlop: 1.1.0
+      micromark-util-sanitize-uri: 2.0.1
+      trim-lines: 3.0.1
+      unist-util-position: 5.0.0
+      unist-util-visit: 5.1.0
+      vfile: 6.0.3
+
+  mdast-util-to-markdown@2.1.2:
+    dependencies:
+      '@types/mdast': 4.0.4
+      '@types/unist': 3.0.3
+      longest-streak: 3.1.0
+      mdast-util-phrasing: 4.1.0
+      mdast-util-to-string: 4.0.0
+      micromark-util-classify-character: 2.0.1
+      micromark-util-decode-string: 2.0.1
+      unist-util-visit: 5.1.0
+      zwitch: 2.0.4
+
+  mdast-util-to-string@4.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+
+  micromark-core-commonmark@2.0.3:
+    dependencies:
+      decode-named-character-reference: 1.3.0
+      devlop: 1.1.0
+      micromark-factory-destination: 2.0.1
+      micromark-factory-label: 2.0.1
+      micromark-factory-space: 2.0.1
+      micromark-factory-title: 2.0.1
+      micromark-factory-whitespace: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-chunked: 2.0.1
+      micromark-util-classify-character: 2.0.1
+      micromark-util-html-tag-name: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-subtokenize: 2.1.0
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-autolink-literal@2.1.0:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-footnote@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-strikethrough@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-util-chunked: 2.0.1
+      micromark-util-classify-character: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-table@2.1.1:
+    dependencies:
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-tagfilter@2.0.0:
+    dependencies:
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm-task-list-item@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-gfm@3.0.0:
+    dependencies:
+      micromark-extension-gfm-autolink-literal: 2.1.0
+      micromark-extension-gfm-footnote: 2.1.0
+      micromark-extension-gfm-strikethrough: 2.1.0
+      micromark-extension-gfm-table: 2.1.1
+      micromark-extension-gfm-tagfilter: 2.0.0
+      micromark-extension-gfm-task-list-item: 2.1.0
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-mdx-expression@3.0.1:
+    dependencies:
+      '@types/estree': 1.0.8
+      devlop: 1.1.0
+      micromark-factory-mdx-expression: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-extension-mdx-jsx@3.0.2:
+    dependencies:
+      '@types/estree': 1.0.8
+      devlop: 1.1.0
+      estree-util-is-identifier-name: 3.0.0
+      micromark-factory-mdx-expression: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      vfile-message: 4.0.3
+
+  micromark-extension-mdx-md@2.0.0:
+    dependencies:
+      micromark-util-types: 2.0.2
+
+  micromark-extension-mdxjs-esm@3.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      unist-util-position-from-estree: 2.0.0
+      vfile-message: 4.0.3
+
+  micromark-extension-mdxjs@3.0.0:
+    dependencies:
+      acorn: 8.16.0
+      acorn-jsx: 5.3.2(acorn@8.16.0)
+      micromark-extension-mdx-expression: 3.0.1
+      micromark-extension-mdx-jsx: 3.0.2
+      micromark-extension-mdx-md: 2.0.0
+      micromark-extension-mdxjs-esm: 3.0.0
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-destination@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-label@2.0.1:
+    dependencies:
+      devlop: 1.1.0
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-mdx-expression@2.0.3:
+    dependencies:
+      '@types/estree': 1.0.8
+      devlop: 1.1.0
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-events-to-acorn: 2.0.3
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      unist-util-position-from-estree: 2.0.0
+      vfile-message: 4.0.3
+
+  micromark-factory-space@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-title@2.0.1:
+    dependencies:
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-factory-whitespace@2.0.1:
+    dependencies:
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-character@2.1.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-chunked@2.0.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-classify-character@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-combine-extensions@2.0.1:
+    dependencies:
+      micromark-util-chunked: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-decode-numeric-character-reference@2.0.2:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-decode-string@2.0.1:
+    dependencies:
+      decode-named-character-reference: 1.3.0
+      micromark-util-character: 2.1.1
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-encode@2.0.1: {}
+
+  micromark-util-events-to-acorn@2.0.3:
+    dependencies:
+      '@types/estree': 1.0.8
+      '@types/unist': 3.0.3
+      devlop: 1.1.0
+      estree-util-visit: 2.0.0
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+      vfile-message: 4.0.3
+
+  micromark-util-html-tag-name@2.0.1: {}
+
+  micromark-util-normalize-identifier@2.0.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-resolve-all@2.0.1:
+    dependencies:
+      micromark-util-types: 2.0.2
+
+  micromark-util-sanitize-uri@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-encode: 2.0.1
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-subtokenize@2.1.0:
+    dependencies:
+      devlop: 1.1.0
+      micromark-util-chunked: 2.0.1
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-symbol@2.0.1: {}
+
+  micromark-util-types@2.0.2: {}
+
+  micromark@4.0.2:
+    dependencies:
+      '@types/debug': 4.1.13
+      debug: 4.4.3
+      decode-named-character-reference: 1.3.0
+      devlop: 1.1.0
+      micromark-core-commonmark: 2.0.3
+      micromark-factory-space: 2.0.1
+      micromark-util-character: 2.1.1
+      micromark-util-chunked: 2.0.1
+      micromark-util-combine-extensions: 2.0.1
+      micromark-util-decode-numeric-character-reference: 2.0.2
+      micromark-util-encode: 2.0.1
+      micromark-util-normalize-identifier: 2.0.1
+      micromark-util-resolve-all: 2.0.1
+      micromark-util-sanitize-uri: 2.0.1
+      micromark-util-subtokenize: 2.1.0
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  motion-dom@12.38.0:
+    dependencies:
+      motion-utils: 12.36.0
+
+  motion-utils@12.36.0: {}
+
+  motion@12.38.0(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
+    dependencies:
+      framer-motion: 12.38.0(react-dom@19.2.5(react@19.2.5))(react@19.2.5)
+      tslib: 2.8.1
+    optionalDependencies:
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+
+  ms@2.1.3: {}
+
+  nanoid@3.3.12: {}
+
+  next-themes@0.4.6(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+
+  next@16.2.4(react-dom@19.2.5(react@19.2.5))(react@19.2.5):
+    dependencies:
+      '@next/env': 16.2.4
+      '@swc/helpers': 0.5.15
+      baseline-browser-mapping: 2.10.27
+      caniuse-lite: 1.0.30001791
+      postcss: 8.4.31
+      react: 19.2.5
+      react-dom: 19.2.5(react@19.2.5)
+      styled-jsx: 5.1.6(react@19.2.5)
+    optionalDependencies:
+      '@next/swc-darwin-arm64': 16.2.4
+      '@next/swc-darwin-x64': 16.2.4
+      '@next/swc-linux-arm64-gnu': 16.2.4
+      '@next/swc-linux-arm64-musl': 16.2.4
+      '@next/swc-linux-x64-gnu': 16.2.4
+      '@next/swc-linux-x64-musl': 16.2.4
+      '@next/swc-win32-arm64-msvc': 16.2.4
+      '@next/swc-win32-x64-msvc': 16.2.4
+      sharp: 0.34.5
+    transitivePeerDependencies:
+      - '@babel/core'
+      - babel-plugin-macros
+
+  oniguruma-parser@0.12.2: {}
+
+  oniguruma-to-es@4.3.6:
+    dependencies:
+      oniguruma-parser: 0.12.2
+      regex: 6.1.0
+      regex-recursion: 6.0.2
+
+  parse-entities@4.0.2:
+    dependencies:
+      '@types/unist': 2.0.11
+      character-entities-legacy: 3.0.0
+      character-reference-invalid: 2.0.1
+      decode-named-character-reference: 1.3.0
+      is-alphanumerical: 2.0.1
+      is-decimal: 2.0.1
+      is-hexadecimal: 2.0.1
+
+  parse5@7.3.0:
+    dependencies:
+      entities: 6.0.1
+
+  picocolors@1.1.1: {}
+
+  picomatch@4.0.4: {}
+
+  postcss@8.4.31:
+    dependencies:
+      nanoid: 3.3.12
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  postcss@8.5.14:
+    dependencies:
+      nanoid: 3.3.12
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  property-information@7.1.0: {}
+
+  react-dom@19.2.5(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+      scheduler: 0.27.0
+
+  react-remove-scroll-bar@2.3.8(@types/react@19.2.14)(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+      react-style-singleton: 2.2.3(@types/react@19.2.14)(react@19.2.5)
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  react-remove-scroll@2.7.2(@types/react@19.2.14)(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+      react-remove-scroll-bar: 2.3.8(@types/react@19.2.14)(react@19.2.5)
+      react-style-singleton: 2.2.3(@types/react@19.2.14)(react@19.2.5)
+      tslib: 2.8.1
+      use-callback-ref: 1.3.3(@types/react@19.2.14)(react@19.2.5)
+      use-sidecar: 1.1.3(@types/react@19.2.14)(react@19.2.5)
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  react-style-singleton@2.2.3(@types/react@19.2.14)(react@19.2.5):
+    dependencies:
+      get-nonce: 1.0.1
+      react: 19.2.5
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  react@19.2.5: {}
+
+  readdirp@5.0.0: {}
+
+  recma-build-jsx@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      estree-util-build-jsx: 3.0.1
+      vfile: 6.0.3
+
+  recma-jsx@1.0.1(acorn@8.16.0):
+    dependencies:
+      acorn: 8.16.0
+      acorn-jsx: 5.3.2(acorn@8.16.0)
+      estree-util-to-js: 2.0.0
+      recma-parse: 1.0.0
+      recma-stringify: 1.0.0
+      unified: 11.0.5
+
+  recma-parse@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      esast-util-from-js: 2.0.1
+      unified: 11.0.5
+      vfile: 6.0.3
+
+  recma-stringify@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      estree-util-to-js: 2.0.0
+      unified: 11.0.5
+      vfile: 6.0.3
+
+  regex-recursion@6.0.2:
+    dependencies:
+      regex-utilities: 2.3.0
+
+  regex-utilities@2.3.0: {}
+
+  regex@6.1.0:
+    dependencies:
+      regex-utilities: 2.3.0
+
+  rehype-raw@7.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+      hast-util-raw: 9.1.0
+      vfile: 6.0.3
+
+  rehype-recma@1.0.0:
+    dependencies:
+      '@types/estree': 1.0.8
+      '@types/hast': 3.0.4
+      hast-util-to-estree: 3.1.3
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-gfm@4.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-gfm: 3.1.0
+      micromark-extension-gfm: 3.0.0
+      remark-parse: 11.0.0
+      remark-stringify: 11.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-mdx@3.1.1:
+    dependencies:
+      mdast-util-mdx: 3.0.0
+      micromark-extension-mdxjs: 3.0.0
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-parse@11.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-from-markdown: 2.0.3
+      micromark-util-types: 2.0.2
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  remark-rehype@11.1.2:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      mdast-util-to-hast: 13.2.1
+      unified: 11.0.5
+      vfile: 6.0.3
+
+  remark-stringify@11.0.0:
+    dependencies:
+      '@types/mdast': 4.0.4
+      mdast-util-to-markdown: 2.1.2
+      unified: 11.0.5
+
+  remark@15.0.1:
+    dependencies:
+      '@types/mdast': 4.0.4
+      remark-parse: 11.0.0
+      remark-stringify: 11.0.0
+      unified: 11.0.5
+    transitivePeerDependencies:
+      - supports-color
+
+  scheduler@0.27.0: {}
+
+  scroll-into-view-if-needed@3.1.0:
+    dependencies:
+      compute-scroll-into-view: 3.1.1
+
+  semver@7.7.4:
+    optional: true
+
+  sharp@0.34.5:
+    dependencies:
+      '@img/colour': 1.1.0
+      detect-libc: 2.1.2
+      semver: 7.7.4
+    optionalDependencies:
+      '@img/sharp-darwin-arm64': 0.34.5
+      '@img/sharp-darwin-x64': 0.34.5
+      '@img/sharp-libvips-darwin-arm64': 1.2.4
+      '@img/sharp-libvips-darwin-x64': 1.2.4
+      '@img/sharp-libvips-linux-arm': 1.2.4
+      '@img/sharp-libvips-linux-arm64': 1.2.4
+      '@img/sharp-libvips-linux-ppc64': 1.2.4
+      '@img/sharp-libvips-linux-riscv64': 1.2.4
+      '@img/sharp-libvips-linux-s390x': 1.2.4
+      '@img/sharp-libvips-linux-x64': 1.2.4
+      '@img/sharp-libvips-linuxmusl-arm64': 1.2.4
+      '@img/sharp-libvips-linuxmusl-x64': 1.2.4
+      '@img/sharp-linux-arm': 0.34.5
+      '@img/sharp-linux-arm64': 0.34.5
+      '@img/sharp-linux-ppc64': 0.34.5
+      '@img/sharp-linux-riscv64': 0.34.5
+      '@img/sharp-linux-s390x': 0.34.5
+      '@img/sharp-linux-x64': 0.34.5
+      '@img/sharp-linuxmusl-arm64': 0.34.5
+      '@img/sharp-linuxmusl-x64': 0.34.5
+      '@img/sharp-wasm32': 0.34.5
+      '@img/sharp-win32-arm64': 0.34.5
+      '@img/sharp-win32-ia32': 0.34.5
+      '@img/sharp-win32-x64': 0.34.5
+    optional: true
+
+  shiki@4.0.2:
+    dependencies:
+      '@shikijs/core': 4.0.2
+      '@shikijs/engine-javascript': 4.0.2
+      '@shikijs/engine-oniguruma': 4.0.2
+      '@shikijs/langs': 4.0.2
+      '@shikijs/themes': 4.0.2
+      '@shikijs/types': 4.0.2
+      '@shikijs/vscode-textmate': 10.0.2
+      '@types/hast': 3.0.4
+
+  source-map-js@1.2.1: {}
+
+  source-map@0.7.6: {}
+
+  space-separated-tokens@2.0.2: {}
+
+  stringify-entities@4.0.4:
+    dependencies:
+      character-entities-html4: 2.1.0
+      character-entities-legacy: 3.0.0
+
+  style-to-js@1.1.21:
+    dependencies:
+      style-to-object: 1.0.14
+
+  style-to-object@1.0.14:
+    dependencies:
+      inline-style-parser: 0.2.7
+
+  styled-jsx@5.1.6(react@19.2.5):
+    dependencies:
+      client-only: 0.0.1
+      react: 19.2.5
+
+  tailwind-merge@3.5.0: {}
+
+  tailwindcss@4.2.4: {}
+
+  tapable@2.3.3: {}
+
+  tinyexec@1.1.2: {}
+
+  tinyglobby@0.2.16:
+    dependencies:
+      fdir: 6.5.0(picomatch@4.0.4)
+      picomatch: 4.0.4
+
+  trim-lines@3.0.1: {}
+
+  trough@2.2.0: {}
+
+  tslib@2.8.1: {}
+
+  typescript@6.0.3: {}
+
+  undici-types@7.19.2: {}
+
+  unified@11.0.5:
+    dependencies:
+      '@types/unist': 3.0.3
+      bail: 2.0.2
+      devlop: 1.1.0
+      extend: 3.0.2
+      is-plain-obj: 4.1.0
+      trough: 2.2.0
+      vfile: 6.0.3
+
+  unist-util-is@6.0.1:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-position-from-estree@2.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-position@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-remove-position@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-visit: 5.1.0
+
+  unist-util-stringify-position@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-visit-parents@6.0.2:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.1
+
+  unist-util-visit@5.1.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.1
+      unist-util-visit-parents: 6.0.2
+
+  use-callback-ref@1.3.3(@types/react@19.2.14)(react@19.2.5):
+    dependencies:
+      react: 19.2.5
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  use-sidecar@1.1.3(@types/react@19.2.14)(react@19.2.5):
+    dependencies:
+      detect-node-es: 1.1.0
+      react: 19.2.5
+      tslib: 2.8.1
+    optionalDependencies:
+      '@types/react': 19.2.14
+
+  vfile-location@5.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      vfile: 6.0.3
+
+  vfile-message@4.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-stringify-position: 4.0.0
+
+  vfile@6.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      vfile-message: 4.0.3
+
+  web-namespaces@2.0.1: {}
+
+  zod@4.4.3: {}
+
+  zwitch@2.0.4: {}
diff --git a/docs/pnpm-workspace.yaml b/docs/pnpm-workspace.yaml
new file mode 100644
index 0000000..dbb26c8
--- /dev/null
+++ b/docs/pnpm-workspace.yaml
@@ -0,0 +1,3 @@
+allowBuilds:
+  esbuild: true
+  sharp: true
diff --git a/docs/postcss.config.mjs b/docs/postcss.config.mjs
new file mode 100644
index 0000000..2df6729
--- /dev/null
+++ b/docs/postcss.config.mjs
@@ -0,0 +1,6 @@
+/** @type {import('postcss-load-config').Config} */
+export default {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
diff --git a/docs/public/avatars/acane.png b/docs/public/avatars/acane.png
new file mode 100644
index 0000000..9711f2b
Binary files /dev/null and b/docs/public/avatars/acane.png differ
diff --git a/docs/public/avatars/ar414.jpg b/docs/public/avatars/ar414.jpg
new file mode 100644
index 0000000..f771337
Binary files /dev/null and b/docs/public/avatars/ar414.jpg differ
diff --git a/docs/public/avatars/cyano.jpg b/docs/public/avatars/cyano.jpg
new file mode 100644
index 0000000..7dc96a0
Binary files /dev/null and b/docs/public/avatars/cyano.jpg differ
diff --git a/docs/public/avatars/dongxuyang85.jpg b/docs/public/avatars/dongxuyang85.jpg
new file mode 100644
index 0000000..6195132
Binary files /dev/null and b/docs/public/avatars/dongxuyang85.jpg differ
diff --git a/docs/public/avatars/eryajf.jpg b/docs/public/avatars/eryajf.jpg
new file mode 100644
index 0000000..891d152
Binary files /dev/null and b/docs/public/avatars/eryajf.jpg differ
diff --git a/docs/public/avatars/guangguang.jpg b/docs/public/avatars/guangguang.jpg
new file mode 100644
index 0000000..8681b6f
Binary files /dev/null and b/docs/public/avatars/guangguang.jpg differ
diff --git a/docs/public/avatars/husky.jpg b/docs/public/avatars/husky.jpg
new file mode 100644
index 0000000..d7880e9
Binary files /dev/null and b/docs/public/avatars/husky.jpg differ
diff --git a/docs/public/avatars/itkui.jpg b/docs/public/avatars/itkui.jpg
new file mode 100644
index 0000000..68dc947
Binary files /dev/null and b/docs/public/avatars/itkui.jpg differ
diff --git a/docs/public/avatars/mebiuw.jpg b/docs/public/avatars/mebiuw.jpg
new file mode 100644
index 0000000..4dd6dc0
Binary files /dev/null and b/docs/public/avatars/mebiuw.jpg differ
diff --git a/docs/public/avatars/momo.jpg b/docs/public/avatars/momo.jpg
new file mode 100644
index 0000000..90ee768
Binary files /dev/null and b/docs/public/avatars/momo.jpg differ
diff --git a/docs/public/avatars/patrickz.jpg b/docs/public/avatars/patrickz.jpg
new file mode 100644
index 0000000..d06729f
Binary files /dev/null and b/docs/public/avatars/patrickz.jpg differ
diff --git a/docs/public/avatars/ryan.jpg b/docs/public/avatars/ryan.jpg
new file mode 100644
index 0000000..b628f4d
Binary files /dev/null and b/docs/public/avatars/ryan.jpg differ
diff --git a/docs/public/avatars/sunzhigang.jpg b/docs/public/avatars/sunzhigang.jpg
new file mode 100644
index 0000000..834a3bb
Binary files /dev/null and b/docs/public/avatars/sunzhigang.jpg differ
diff --git a/docs/public/avatars/vbvb.png b/docs/public/avatars/vbvb.png
new file mode 100644
index 0000000..3450d14
Binary files /dev/null and b/docs/public/avatars/vbvb.png differ
diff --git a/docs/public/avatars/xuyuan.jpg b/docs/public/avatars/xuyuan.jpg
new file mode 100644
index 0000000..f56408b
Binary files /dev/null and b/docs/public/avatars/xuyuan.jpg differ
diff --git a/docs/public/avatars/yanxuecan.jpg b/docs/public/avatars/yanxuecan.jpg
new file mode 100644
index 0000000..ac3414c
Binary files /dev/null and b/docs/public/avatars/yanxuecan.jpg differ
diff --git a/docs/public/avatars/ydwang.png b/docs/public/avatars/ydwang.png
new file mode 100644
index 0000000..a6e433b
Binary files /dev/null and b/docs/public/avatars/ydwang.png differ
diff --git a/docs/public/avatars/yingtao.jpg b/docs/public/avatars/yingtao.jpg
new file mode 100644
index 0000000..cbc5161
Binary files /dev/null and b/docs/public/avatars/yingtao.jpg differ
diff --git a/docs/public/avatars/zhufeng.jpg b/docs/public/avatars/zhufeng.jpg
new file mode 100644
index 0000000..7b14f4b
Binary files /dev/null and b/docs/public/avatars/zhufeng.jpg differ
diff --git a/docs/public/favicon.png b/docs/public/favicon.png
new file mode 100644
index 0000000..23c91bc
Binary files /dev/null and b/docs/public/favicon.png differ
diff --git a/docs/public/icons/atomgit.png b/docs/public/icons/atomgit.png
new file mode 100644
index 0000000..db53780
Binary files /dev/null and b/docs/public/icons/atomgit.png differ
diff --git a/docs/public/icons/cnb.svg b/docs/public/icons/cnb.svg
new file mode 100644
index 0000000..0d00b53
--- /dev/null
+++ b/docs/public/icons/cnb.svg
@@ -0,0 +1,7 @@
+<svg width="320" height="320" viewBox="0 0 320 320" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M228.906 40.2412C229.882 37.5108 228.906 34.3903 226.759 32.44C219.342 26.004 200.799 12.3519 173.082 10.4016C141.852 8.06121 122.528 16.4475 112.769 22.6885C108.474 25.4189 108.279 31.4649 112.183 34.3903L191.625 96.2149C198.652 101.676 208.997 98.5553 211.729 90.169L228.711 40.2412H228.906Z" fill="#FF6200"/>
+<path d="M32.9381 223.564C29.6199 225.71 28.2536 229.805 29.2295 233.511C32.1573 244.432 41.3312 266.861 66.9009 287.534C92.4706 308.012 122.725 310.353 135.607 309.963C139.511 309.963 142.829 307.427 144 303.722L194.945 142.627C198.653 130.925 185.576 121.173 175.426 127.999L32.9381 223.564Z" fill="#FF6200"/>
+<path d="M70.2169 53.4955C67.6794 52.5203 64.9468 52.7153 62.6045 53.8855C53.2355 58.9563 29.032 74.7538 16.54 107.324C6.78054 132.288 10.0987 159.982 12.8314 173.439C13.6121 177.925 18.2967 180.46 22.5908 178.705L175.424 119.026C186.354 114.735 186.354 99.3276 175.424 95.0369L70.2169 53.4955Z" fill="#FF6200"/>
+<path d="M297.03 168.968C301.519 171.893 307.57 169.358 308.351 164.092C310.303 150.05 312.06 125.866 304.057 107.338C293.321 82.9591 274.974 67.7468 266.19 61.7008C263.458 59.7505 259.749 59.9456 257.212 62.2859L218.564 96.4162C212.318 102.072 212.904 112.019 219.931 116.699L297.03 168.968Z" fill="#FF6200"/>
+<path d="M189.089 299.428C188.699 303.914 192.603 307.814 197.092 307.229C211.731 305.669 241.79 299.818 264.237 278.365C286.098 257.496 293.32 232.728 295.272 222.781C295.858 220.051 295.272 217.32 293.515 215.175L225.98 131.897C218.758 122.925 204.119 127.411 203.143 138.918L189.089 299.233V299.428Z" fill="#FF6200"/>
+</svg>
diff --git a/docs/public/icons/community/qq.png b/docs/public/icons/community/qq.png
new file mode 100644
index 0000000..f87b2ac
Binary files /dev/null and b/docs/public/icons/community/qq.png differ
diff --git a/docs/public/icons/database/access.png b/docs/public/icons/database/access.png
new file mode 100644
index 0000000..44138a1
Binary files /dev/null and b/docs/public/icons/database/access.png differ
diff --git a/docs/public/icons/database/apache_kylin.svg b/docs/public/icons/database/apache_kylin.svg
new file mode 100644
index 0000000..7a15a5a
--- /dev/null
+++ b/docs/public/icons/database/apache_kylin.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="190.51" class="icon" viewBox="0 0 1075 1024"><path fill="#f09d13" d="M556.032 909.312a375 375 0 0 1-86.886-17.408c-79.31-26.01-146.637-78.336-195.84-151.91-13.62-20.43-18.79-32.461-19.559-45.568-.512-9.216.41-13.415 4.352-19.252a19.56 19.56 0 0 1 8.807-7.27c5.632-2.867 6.45-3.072 14.336-2.97 18.227.103 32.614 8.96 49.05 30.106 3.122 3.994 11.878 16.282 19.455 27.29 15.565 22.732 27.392 38.707 37.888 51.353 9.319 11.06 26.112 27.904 35.43 35.328 15.156 12.135 50.996 31.283 76.8 41.114 84.122 32.051 170.394 29.03 256.308-8.96a382.5 382.5 0 0 0 118.63-82.33c10.752-11.264 14.49-14.131 16.487-12.441 1.74 1.382 1.382 6.4-.717 10.496-4.455 8.704-18.79 25.6-36.557 42.905a350.3 350.3 0 0 1-96.973 68.301c-57.753 28.518-115.302 42.086-176.64 41.626-11.52-.103-22.528-.256-24.422-.461zm-57.037-272.538c-7.782-1.382-6.502-9.216 2.816-17.356 7.68-6.656 25.549-15.156 47.309-22.375 14.694-4.864 16.435-6.246 16.384-13.056-.102-10.496-8.55-20.787-31.642-38.4a63.334 63.334 0 0 1-15.564-81.1c9.42-15.617 26.47-28.365 43.417-32.513 29.184-7.116 51.917 1.178 62.464 22.784 4.045 8.192 6.656 17.255 5.837 20.43s-3.38 2.56-9.882-2.407c-9.37-7.168-15.718-9.83-24.73-10.189-9.215-.358-15.052 1.331-20.018 5.786-5.735 5.17-7.168 8.908-7.168 18.432-.052 7.577.204 8.806 2.764 14.233 13.67 28.877 57.959 34.458 88.935 11.162 10.086-7.578 22.528-28.57 26.265-44.083 1.536-6.554 1.792-9.728 1.434-19.15a50.5 50.5 0 0 0-2.97-18.84c-5.632-16.129-12.441-24.833-24.37-31.028-18.228-9.42-41.063-11.93-72.09-7.987-26.42 3.379-54.221 2.15-70.759-3.072-7.219-2.304-9.779-4.147-9.779-7.066 0-2.406.82-2.662 10.906-3.379 15.462-1.126 32.46-5.325 59.852-14.848 9.012-3.072 20.173-6.605 24.832-7.782 28.365-7.168 58.317-9.114 80.384-5.274 9.421 1.638 20.788 7.27 29.44 14.592 25.19 21.3 49.613 64.563 69.376 122.88 6.144 18.074 11.725 30.464 18.33 40.55 14.95 22.733 34.816 36.608 59.904 41.882 2.867.614 10.086 1.075 16.077 1.024a79.36 79.36 0 0 0 36.352-8.5c22.016-10.444 35.43-26.828 42.137-51.609 2.51-9.062 2.765-30.822.512-39.424-5.222-19.558-17.817-32.46-37.632-38.349-8.704-2.56-28.057-3.328-34.201-1.28A31.8 31.8 0 0 0 864.46 450.1c-1.587 3.994-1.997 6.759-2.048 14.49 0 8.601.205 10.086 2.304 14.54 6.297 13.466 18.278 19.815 37.376 19.866 9.42 0 10.905.768 9.933 5.12-1.024 4.864-6.4 8.141-15.872 9.575a60.47 60.47 0 0 1-35.738-4.71 54.73 54.73 0 0 1-26.112-30.311 52.74 52.74 0 0 1-.768-27.546c1.946-7.68 8.243-20.224 13.363-26.521 14.439-17.92 38.451-27.085 64.41-24.679 36.352 3.328 64.512 23.143 76.902 54.17 10.087 25.139 10.445 65.177.768 90.163-13.005 33.792-44.339 59.136-87.04 70.4-34.099 8.96-61.645 8.858-89.241-.307a156.7 156.7 0 0 1-51.508-30.464c-7.987-7.475-10.65-8.397-10.65-3.584 0 2.457 1.23 4.557 6.554 11.11 8.346 10.343 12.135 17.715 11.418 22.272-.717 4.455-3.738 6.912-9.472 7.578-6.707.819-92.262.153-94.003-.717-3.789-1.843.41-11.264 7.321-16.282a39.7 39.7 0 0 1 17.87-7.27c6.655-1.229 8.96-2.714 8.96-5.683 0-.768-1.998-5.274-4.404-10.087a94.4 94.4 0 0 1-8.294-26.214c-.87-4.66-6.4-2.611-11.572 4.25-8.96 12.032-15.155 31.027-19.25 58.88-1.998 13.67-3.073 16.64-6.503 18.227-1.741.768-20.275 1.024-75.162.921a3784 3784 0 0 1-75.059-.512zM201.216 635.7c-66.048-.41-71.168-.563-73.318-1.997-3.072-1.996-3.072-4.966-.103-10.956 8.141-16.23 28.263-27.597 60.826-34.15 20.838-4.25 33.229-9.166 44.595-17.716 13.568-10.189 15.155-19.456 4.3-25.037a91.4 91.4 0 0 1-31.436-28.467c-10.7-16.23-17.869-42.138-17.869-64.512 0-11.622 6.144-34.048 13.056-47.974 10.24-20.48 24.679-34.919 44.851-44.8 13.62-6.656 31.079-10.752 45.364-10.752 3.072 0 5.12-.512 6.45-1.639 1.793-1.433 1.895-1.843.922-4.71-1.433-4.301-7.475-9.626-13.516-11.879-5.632-2.15-12.032-3.072-29.287-4.403a113 113 0 0 1-16.077-2.201 28.57 28.57 0 0 1-14.899-10.138c-2.048-3.072-2.457-4.608-2.457-9.42 0-5.07.41-6.452 3.584-12.238 3.328-6.092 4.71-9.728 7.219-18.944.87-3.072 1.382-3.686 3.277-3.686 1.228 0 3.635 1.126 5.376 2.509 10.598 8.345 42.854 19.251 56.985 19.251 8.909 0 13.107-1.28 16.384-5.069 2.355-2.662 2.611-3.43 2.15-6.605a37.53 37.53 0 0 0-9.727-18.176c-5.12-5.068-15.463-10.342-25.19-12.902a69.5 69.5 0 0 0-18.28-1.946c-12.44-.153-13.465.154-20.377 5.888-5.734 4.813-7.629 4.404-14.029-3.174-15.974-18.944-23.398-38.656-18.79-49.715 1.536-3.584 3.482-4.403 16.947-6.656 5.94-1.024 18.074-3.328 26.983-5.223 35.02-7.321 54.323-9.728 78.49-9.625 20.377 0 21.247-.256 26.726-8.397 7.168-10.752 9.83-21.248 9.83-39.424 0-14.746.666-16.538 5.888-16.538 4.096 0 10.035 2.868 12.954 6.35 5.785 6.86 8.038 15.922 9.01 36.71.615 12.8 1.28 18.432 2.92 24.883 3.378 13.21 5.324 16.179 19.711 30.361 17.869 17.664 23.245 26.164 26.522 42.087 2.611 12.749 1.126 27.853-3.891 39.373-6.247 14.233-20.992 30.617-37.479 41.625-12.749 8.448-27.443 15.463-83.507 39.783-10.752 4.608-22.118 9.728-25.242 11.315-20.275 10.24-39.219 29.593-46.54 47.462-2.048 5.12-2.56 7.68-2.868 16.077-.614 15.616 2.714 26.112 12.288 38.86 6.605 8.705 19.2 18.433 28.672 21.966 11.776 4.352 28.16 4.608 41.882.563 13.414-3.891 28.928-13.107 27.136-16.026-.973-1.536-2.918-1.126-8.909 1.741-22.733 10.854-47.77 12.493-62.003 4.096a74.1 74.1 0 0 1-19.968-20.02c-8.243-13.977-10.854-33.791-6.246-47.257a41.2 41.2 0 0 1 11.315-16.998c8.704-8.448 36.045-22.375 89.241-45.568 31.488-13.824 37.684-16.896 48.64-24.167a134.81 134.81 0 0 0 60.57-113.664 32.3 32.3 0 0 1 .82-9.83c1.023 0 6.86 7.834 11.314 15.104 22.733 37.171 30.567 86.938 19.559 124.826-10.24 35.481-34.355 63.18-64.154 73.728-10.803 3.89-18.995 5.17-31.897 5.12a93.1 93.1 0 0 1-30.925-4.71c-16.896-4.916-29.491-5.377-43.213-1.588-12.493 3.43-18.79 8.5-21.3 17.05a24.83 24.83 0 0 0 2.92 18.739c3.122 5.785 5.99 7.833 11.724 8.294 8.448.666 19.814-5.273 19.814-10.393 0-1.127-2.56-6.452-5.632-11.828a52.7 52.7 0 0 1-5.632-11.93c0-3.225 3.021-4.812 9.063-4.812 7.936 0 13.005 2.765 19.149 10.291 5.734 7.168 10.905 10.855 17.05 12.34 7.474 1.791 8.55 5.734 4.71 17.254-6.35 18.944-22.528 41.113-51.815 71.117a315 315 0 0 0-21.606 23.91 157.4 157.4 0 0 0-20.48 44.39c-3.175 11.11-5.99 13.927-14.848 14.95-1.434.154-34.56.103-73.626-.153zm128.256-17.817c-5.018-2.202-4.608-9.575.82-15.77 4.76-5.478 6.4-5.888 23.602-6.451 14.03-.41 15.616-.615 16.743-2.15a6.86 6.86 0 0 0 1.229-3.482c0-2.919-3.738-11.008-7.68-16.896-6.4-9.319-7.476-12.493-7.527-22.016 0-9.319.87-11.52 6.4-15.258 9.165-6.246 33.946-3.584 58.931 6.298 24.32 9.625 48.18 13.414 83.764 13.414 18.432 0 21.196.205 21.657 1.383.666 1.74-2.048 5.427-5.837 7.987-9.574 6.553-36.966 9.728-69.376 7.987-19.814-1.024-21.76-.666-23.142 4.096-1.536 5.274 1.229 11.52 8.5 19.456 9.778 10.65 10.546 16.18 2.764 20.326-3.584 1.895-3.891 1.895-55.808 2.1-43.52.153-52.736 0-55.04-1.024m566.886-262.656a35.5 35.5 0 0 1-18.432-9.78 880 880 0 0 1-24.37-28.364c-47.463-56.679-62.823-72.807-87.194-91.239a313 313 0 0 0-67.328-37.888c-65.997-25.805-143.002-29.184-221.39-9.625-17.92 4.505-17.407 2.457 1.127-4.762a387.4 387.4 0 0 1 186.368-23.142c95.488 12.185 177.306 60.57 228.25 134.912 18.073 26.419 25.344 41.472 25.395 52.633 0 12.544-8.755 19.303-22.426 17.306z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/bigquery.svg b/docs/public/icons/database/bigquery.svg
new file mode 100644
index 0000000..a9a42f0
--- /dev/null
+++ b/docs/public/icons/database/bigquery.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#aecbfa" d="M328.704 465.306v95.385c15.053 25.907 36.352 47.616 62.054 63.079V465.306z"/><path fill="#669df6" d="M443.29 377.549v273.05c13.312 1.689 26.777 2.457 40.243 2.201q18.124 1.076 36.25 0V377.549z"/><path fill="#aecbfa" d="M579.277 502.63v119.296a181.4 181.4 0 0 0 61.645-65.996v-53.248h-61.645z"/><path fill="#4285f4" d="m727.962 664.371-51.508 51.507a15.31 15.31 0 0 0 0 21.76l128.41 128.359a15.206 15.206 0 0 0 21.402 0l51.814-51.866a15.26 15.26 0 0 0 0-21.401L749.722 664.37a15.26 15.26 0 0 0-21.76 0"/><path fill="#669df6" d="M483.533 145.05a326.4 326.4 0 1 0 0 652.8 326.4 326.4 0 0 0 0-652.8m0 568.985a242.278 242.278 0 1 1 .768-484.505 242.278 242.278 0 0 1-.768 484.505"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/cassandra.svg b/docs/public/icons/database/cassandra.svg
new file mode 100644
index 0000000..fbeedb1
--- /dev/null
+++ b/docs/public/icons/database/cassandra.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#bae6fa" d="M522.65 317.645c-87.45 1.945-176.384 28.877-277.044 84.582-18.278 21.146-27.699 44.032-25.702 67.277 6.758 78.95 142.029 131.84 302.08 118.118 160.102-13.721 284.365-88.883 277.555-167.833a79.46 79.46 0 0 0-16.691-41.472c-91.597-41.011-175.206-62.618-260.198-60.672"/><path fill="#fff" d="M533.965 317.491c-71.168-.102-142.95 16.077-220.98 50.842a154 154 0 0 0-5.017 39.014c0 93.696 84.582 169.626 188.928 169.626 104.294 0 188.928-75.981 188.928-169.626 0-25.241-6.246-49.152-17.254-70.707a512.5 512.5 0 0 0-134.656-19.149z" opacity=".35"/><path fill="#fff" d="M496.896 310.886c-33.792-2.048-92.109 15.565-140.646 33.178a144.2 144.2 0 0 0-11.52 56.474c0 82.073 74.444 148.633 153.139 148.633 78.182 0 147.405-66.662 153.139-148.633 1.894-26.676-7.322-51.815-20.07-73.524a1317 1317 0 0 0-134.042-16.128"/><path fill="#6a6a6a" d="M410.112 389.786c4.147-9.216 10.445-13.722 16.538-21.402a48 48 0 0 1-2.202-9.882 16.69 16.69 0 0 1 22.886-15.513 121.8 121.8 0 0 1 110.592-19.456c-36.198-4.967-77.004 7.833-104.704 30.208.82 2.048 3.175 7.68 3.175 10.035 0 9.216-5.99 11.469-15.207 11.469a16.9 16.9 0 0 1-5.939-1.127 169.2 169.2 0 0 0-17.715 34.458c15.36 13.722 29.184 18.688 47.258 25.446 0-.819.614-1.638.614-2.56 0-27.801 24.525-50.38 52.326-50.38a50.33 50.33 0 0 1 49.664 41.932c12.442-7.936 24.474-14.028 33.639-25.753a29.7 29.7 0 0 1-4.455-13.62 15.155 15.155 0 0 1 18.637-14.745c4.608-9.626 8.192-19.712 10.394-30.208-43.52-32.205-127.744-27.802-127.744-27.802s-67.021-3.481-112.384 18.637c3.072 21.863 11.776 42.65 24.627 60.263"/><path fill="#6a6a6a" d="M618.138 377.19c3.072 2.765 4.761 5.223 6.092 7.578 4.096 7.322-4.096 14.029-12.441 14.029a15 15 0 0 1-2.56-.256c-9.421 14.745-25.907 33.638-40.602 43.161 22.528 3.738 43.725 12.698 60.621 26.624 12.288-22.016 21.76-53.862 21.76-80.896 0-20.582-9.114-35.635-22.784-46.694-.717 11.008-6.656 26.42-10.086 36.454M435.354 516.813c7.526-20.685 26.01-36.762 43.468-50.893a96 96 0 0 1-7.987-16.23 122.16 122.16 0 0 1-54.784-34.663 110.4 110.4 0 0 0-2.201 38.144 21.965 21.965 0 0 1 17.92 21.555c0 6.4-5.632 15.616-9.933 19.661 4.71 10.138 7.885 15.053 13.568 22.426"/><path fill="#6a6a6a" d="M434.074 534.22c-8.96-8.908-15.156-26.623-20.992-37.785a21 21 0 0 1-3.328.307c-12.135 0-24.832-10.24-21.965-22.016 1.587-6.502 6.144-10.752 13.414-14.336-1.638-13.516-2.099-32.921 1.024-47.001.922-3.994 2.816-5.888 4.096-9.728a128.87 128.87 0 0 1-22.067-70.81l.051-2.765c-22.63 11.367-39.577 29.184-39.577 57.344 0 62.26 35.84 123.392 89.19 147.303zm131.174-86.067a50.38 50.38 0 0 1-78.592 22.886c-17.664 13.773-33.69 37.888-41.83 58.88 3.635 3.942 6.144 7.168 10.29 10.7 12.34 3.226 29.39 0 42.753 0 53.76 0 101.427-23.96 128.768-65.945-18.176-12.544-39.629-24.525-61.389-26.521"/><path fill="#1185b0" d="M408.73 397.056c4.096-9.062 9.267-17.613 15.462-25.395a16.742 16.742 0 0 1 21.811-21.402 121.86 121.86 0 0 1 110.541-19.456 134.14 134.14 0 0 0-101.325 28.519 16.742 16.742 0 0 1-21.35 22.067 112.7 112.7 0 0 0-15.155 27.75c13.21 14.183 29.337 25.447 47.41 32.154-.05-.82-.153-1.69-.153-2.56a50.38 50.38 0 0 1 100.045-8.448 131.5 131.5 0 0 0 32.666-29.85 15.155 15.155 0 0 1 15.155-24.269c4.659-9.574 8.192-19.712 10.393-30.208-43.52-32.204-127.744-27.801-127.744-27.801s-67.02-3.482-112.384 18.637c3.072 21.862 11.776 42.65 24.628 60.262"/><path fill="#1185b0" d="M620.493 379.7a15 15 0 0 1 .614 21.913 15.2 15.2 0 0 1-13.21 4.198 122.7 122.7 0 0 1-36.659 36.864 122.34 122.34 0 0 1 59.034 26.522 152.85 152.85 0 0 0 19.354-74.445c0-20.634-9.114-35.686-22.836-46.746a121.8 121.8 0 0 1-6.297 31.693M437.709 521.83c7.526-20.992 20.685-39.424 37.99-53.452a50.2 50.2 0 0 1-6.297-11.418 122.16 122.16 0 0 1-54.682-34.662l-.307 1.382a110.1 110.1 0 0 0-1.895 36.762 21.965 21.965 0 0 1 10.804 37.683c3.993 8.397 8.806 16.333 14.438 23.705z"/><path fill="#1185b0" d="M433.971 534.016a122.1 122.1 0 0 1-22.22-30.31 21.6 21.6 0 0 1-18.945-6.144 22.016 22.016 0 0 1 6.042-35.328 121.55 121.55 0 0 1 5.274-53.3 121.55 121.55 0 0 1-21.248-68.812l.05-2.765c-22.63 11.315-39.577 29.184-39.577 57.344 0 62.31 37.171 115.814 90.522 139.776l.102-.512zm129.895-78.592a50.38 50.38 0 0 1-78.592 22.886 124.8 124.8 0 0 0-39.168 53.504c3.686 3.943 7.577 7.68 11.673 11.11a152.99 152.99 0 0 0 167.117-64.818 128.5 128.5 0 0 0-61.03-22.682"/><path fill="#fff" d="m502.17 395.776-26.42-47.104 14.336 50.022-42.803-31.078 33.485 42.086-53.094-19.507 41.881 30.976-53.76 1.69 54.989 14.182-54.989 11.879 54.272 3.942-45.773 29.338 47.104-17.101-32.665 41.472 41.318-33.383-14.848 55.604 31.898-45.261-4.506 53.453 18.125-48.436 15.462 50.893 3.738-51.046 22.886 43.52-13.516-49.767 41.881 32.41-27.033-41.37 45.977 17.92-35.174-34.56 47.104 3.687-46.387-17.818 46.592-11.059-46.746-2.406 37.99-29.082-43.161 15.462 29.337-40.652-40.448 26.93 14.132-47.564-27.853 39.22-.615-49.562-18.33 44.134-15.206-44.646.82 52.633z"/><path fill="#6a6a6a" d="M69.99 531.558C214.374 387.174 329.728 342.58 434.38 322.202c13.825-2.714 16.436-32.973 16.436-32.973s1.946 22.323 11.622 25.241c9.728 2.868 22.324-34.918 22.324-34.918s-11.623 33.946 0 35.84c11.622 1.946 32.921-32.922 32.921-32.922s-8.704 30.055-2.867 31.95c5.786 1.945 34.816-43.572 34.816-43.572s-17.408 30.054-.922 32.922c16.487 2.918 40.5-20.48 40.5-20.48s-18.893 21.401-10.445 24.37c35.84 12.596 64.87-33.996 64.87-33.996s-6.758 20.48-24.166 42.7c37.785 9.729 65.843-47.206 65.843-47.206l-28.058 56.935c14.541 7.731 72.704-59.136 72.704-59.136s-30.054 52.326-47.513 62.976c9.728 7.782 44.544-23.245 44.544-23.245s-28.058 34.867-17.408 36.864c15.513 12.544 72.704-64.973 72.704-64.973s-22.323 45.568-55.296 81.408c27.545 13.824 95.949-74.598 95.949-74.598s-1.946 28.109-51.354 72.704c36.864-4.864 84.326-74.65 84.326-74.65s-17.408 52.327-59.136 89.14c36.199-3.738 94.004-93.031 94.004-93.031s-22.272 62.003-67.84 97.894c50.432 11.162 123.084-64 123.084-64s-28.518 53.402-65.894 75.162c41.677 15.974 98.816-49.92 98.816-49.92s-57.14 88.166-148.224 84.326c-29.9-1.28-120.32-90.726-314.01-83.353-255.795 9.728-310.067 118.22-446.72 191.897" opacity=".35"/><path fill="#6a6a6a" d="M735.846 256s-58.163 66.867-72.704 59.136l28.11-56.986s-28.11 56.935-65.895 47.258c17.408-22.272 24.166-42.7 24.166-42.7s-28.979 46.591-64.87 33.996c-8.397-2.97 10.496-24.371 10.496-24.371s-24.064 23.398-40.5 20.48c-16.486-2.919.922-32.922.922-32.922s-29.03 45.568-34.867 43.571c-5.837-1.894 2.918-31.948 2.918-31.948s-21.299 34.867-32.972 32.921c-11.623-1.945 0-35.84 0-35.84s-12.596 37.786-22.272 34.867c-9.728-2.867-11.623-25.19-11.623-25.19s-2.611 30.26-16.486 32.973C335.616 331.57 220.314 376.166 75.879 520.55c136.703-73.574 190.924-182.118 446.77-191.846 193.69-7.373 284.11 82.022 313.959 83.302 91.136 3.892 148.275-84.326 148.275-84.326s-57.139 65.894-98.816 49.92c37.274-21.811 65.895-75.11 65.895-75.11s-72.704 75.11-123.085 64c45.568-35.84 67.84-97.895 67.84-97.895s-57.856 89.293-94.003 93.03c41.676-36.812 59.084-89.139 59.084-89.139s-47.462 69.786-84.275 74.599c49.408-44.544 51.354-72.704 51.354-72.704s-68.403 88.422-95.949 74.65c32.922-35.84 55.245-81.409 55.245-81.409s-57.19 77.517-72.704 64.922c-10.65-1.946 17.459-36.813 17.459-36.813s-34.867 31.027-44.544 23.245C705.792 308.326 735.846 256 735.846 256m92.98 162.97c-9.728-.615-18.33 3.02-22.733 14.95-45.056 85.76-139.52 133.734-250.01 149.76-110.49 15.974-191.897-7.27-258.765-26.112-87.91-24.78-157.696 19.302-233.984-18.944 17.613 13.926 37.786 27.597 95.898 27.75 19.712.103 82.842-3.072 94.464 7.117 11.674 10.138-39.22 58.112-39.22 58.112s86.068-72.755 94.465-47.974c5.222 15.462-24.679 56.73-24.679 56.73s30.004-40.756 52.327-49.46c15.309-5.939 28.211-5.222 39.219 10.24 7.27 10.138-34.816 59.546-34.816 59.546s56.627-55.245 66.816-52.327c10.189 2.919 0 52.327 0 52.327s20.838-50.074 31.949-53.76c15.257-5.12-34.867 116.224-34.867 116.224s61.235-112.23 72.704-114.79c19.61-4.353 32.716 78.489 32.716 78.489s-9.574-72.346.717-77.005c65.024-29.491 27.648 124.98 27.648 124.98s42.496-104.807 16.384-128.052c69.018 45.773 60.621 128.051 60.621 128.051s18.125-39.168-32.768-135.526c27.648-1.434 69.12 71.578 69.12 71.578s-45.056-79.924-14.54-81.408c60.62-2.868 66.866 106.137 66.866 106.137s18.125-15.257-30.515-122.112c30.976-19.865 106.087 98.816 106.087 98.816s-69.274-115.763-58.164-123.545c11.162-7.732 51.866 36.864 51.866 36.864s-30.976-42.65-22.784-47.002c8.243-4.403 90.624 84.787 90.624 84.787s-72.704-87.245-60.109-97.894c7.475-6.298 29.082 5.376 45.568 15.974-23.091-16.537-56.32-42.445-45.568-48.025 22.323-11.572 85.811 27.648 85.811 27.648s-38.297-31.437-32-39.22c6.298-7.73 81.408 49.408 81.408 49.408s-66.406-52.326-69.785-65.382c-3.38-13.107 52.326 4.352 52.326 4.352s-61.542-28.57-62.464-36.864c-1.024-8.192 40.653 9.216 40.653 9.216s-27.034-22.17-48.486-23.654M826.93 541.49c6.656 4.762 13.517 9.472 20.327 14.08 0 0-8.96-6.81-20.327-14.131z"/><path fill="#6a6a6a" d="M66.202 547.328c76.288 38.298 146.073-5.837 234.035 18.944 66.867 18.842 148.275 42.086 258.713 26.112 110.49-15.974 205.005-64 250.061-149.709 14.029-38.297 71.22 8.704 71.22 8.704s-41.677-17.408-40.705-9.216c1.024 8.243 62.464 36.864 62.464 36.864s-55.705-17.459-52.275-4.403c3.38 13.107 69.735 65.434 69.735 65.434s-75.06-57.19-81.408-49.46c-6.247 7.783 32 39.27 32 39.27s-63.488-39.27-85.76-27.647c-16.026 8.294 65.894 62.054 65.894 62.054s-53.248-40.704-65.894-30.054c-12.596 10.7 60.108 97.894 60.108 97.894s-82.432-89.139-90.624-84.787c-8.243 4.352 22.784 47.002 22.784 47.002s-40.704-44.544-51.865-36.864c-11.11 7.782 58.163 123.596 58.163 123.596s-75.11-118.732-106.138-98.816c48.692 106.804 30.516 122.061 30.516 122.061s-6.144-109.005-66.868-106.137c-30.515 1.484 14.541 81.408 14.541 81.408s-41.472-73.012-69.12-71.527c50.944 96.307 32.768 135.475 32.768 135.475s8.448-82.227-60.62-128c26.163 23.245-16.385 128-16.385 128s37.428-154.419-27.648-124.928c-10.24 4.608-.716 77.005-.716 77.005s-13.108-82.893-32.717-78.49c-11.418 2.56-72.704 114.791-72.704 114.791s50.176-121.344 34.918-116.224c-11.11 3.686-31.949 53.76-31.949 53.76s10.138-49.408 0-52.326c-10.24-2.919-66.918 52.326-66.918 52.326s42.189-49.408 34.918-59.597c-11.008-15.411-23.961-16.179-39.27-10.24-22.272 8.704-52.326 49.46-52.326 49.46s29.952-41.268 24.73-56.679c-8.398-24.832-94.465 47.974-94.465 47.974s50.842-47.974 39.22-58.163-74.753-7.014-94.465-7.065c-58.163-.205-78.336-13.824-95.948-27.802" opacity=".35"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/clickhouse.svg b/docs/public/icons/database/clickhouse.svg
new file mode 100644
index 0000000..7c0e072
--- /dev/null
+++ b/docs/public/icons/database/clickhouse.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="red" d="M102.4 808.192h105.318v98.765H102.4z"/><path fill="#fc0" d="M192.614 204.8h79.616v537.6h-79.616zm159.232 0h79.668v614.4h-79.616V204.8zm159.335 0h79.667v614.4H511.13V204.8zm159.283 0h79.667v614.4h-79.667zm159.283 249.6h79.667v115.2h-79.667z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/cockroachdb.svg b/docs/public/icons/database/cockroachdb.svg
new file mode 100644
index 0000000..862e86f
--- /dev/null
+++ b/docs/public/icons/database/cockroachdb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="190.51" class="icon" viewBox="0 0 1075 1024"><path fill="#6646fe" d="M675.123 629.658A368.44 368.44 0 0 0 548.301 253.44a328.96 328.96 0 0 1 164.659-43.776c21.914 0 43.725 2.1 65.229 6.4l9.062-36.352a370.7 370.7 0 0 0-74.342-7.475 366.1 366.1 0 0 0-197.632 57.446 366.2 366.2 0 0 0-197.632-57.446 370 370 0 0 0-74.291 7.526l9.01 36.301c21.505-4.3 43.367-6.4 65.332-6.4a329.6 329.6 0 0 1 164.71 43.725 368.384 368.384 0 0 0 22.426 591.104l10.598 7.27 10.548-7.27a368.9 368.9 0 0 0 149.248-214.835zM496.59 791.04a330.91 330.91 0 0 1-99.533-349.286 370.4 370.4 0 0 0 69.632 84.275 90.62 90.62 0 0 1 29.9 67.481zm18.739-273.408a331.9 331.9 0 0 1-66.355-65.536 91.44 91.44 0 0 1 0-110.797c18.944-25.088 41.267-47.309 66.457-66.048 25.498 18.944 48.026 41.523 67.072 66.97a90.52 90.52 0 0 1 0 108.544 334.5 334.5 0 0 1-67.174 66.867m18.637 273.408V593.51a90.62 90.62 0 0 1 30.003-67.481 369 369 0 0 0 69.53-84.275 331.16 331.16 0 0 1-99.533 349.286"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/databend.svg b/docs/public/icons/database/databend.svg
new file mode 100644
index 0000000..ab3b974
--- /dev/null
+++ b/docs/public/icons/database/databend.svg
@@ -0,0 +1,16 @@
+<svg width="48" height="48" viewBox="0 0 48 48" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0_9_11)">
+<path d="M46.8741 35.0248C46.5214 35.3778 45.1611 34.1675 44.695 33.4741C44.7832 34.3188 44.4683 36.0207 44.0526 36.0081C43.2591 35.9829 42.7427 33.6884 43.045 32.1504C38.0696 29.2886 33.0061 31.7848 33.0061 31.7848H33.0313C33.6485 31.873 35.1222 32.0243 35.0844 32.6799C35.0592 33.1085 33.1698 34.407 27.2372 33.928C25.373 35.5038 17.8407 38.8951 11.1775 37.7857C6.34069 36.6511 3.74595 34.407 2.39819 32.0874C3.63259 32.9572 8.80948 35.882 18.9869 32.6547C30.7262 28.9356 34.4672 26.8933 44.1912 29.4273C44.1912 29.4273 44.1912 29.4399 44.1912 29.4525C44.6194 30.4863 44.7328 31.1418 44.7328 31.1418C46.3577 32.1756 47.3401 34.5709 46.8741 35.0374V35.0248Z" fill="#B3DFFF"/>
+<path d="M42.0625 25.7965C43.1331 27.1832 43.7881 28.4565 44.1912 29.4273C34.4672 26.8933 30.7136 28.9356 18.9869 32.6546C8.82206 35.882 3.63257 32.9572 2.39818 32.0873C2.39818 32.0873 2.39818 32.0747 2.39818 32.0621C0.231694 28.3305 1.22677 24.3845 1.22677 24.3845C1.44089 24.1576 1.69281 23.918 1.96992 23.6659C3.07835 24.6744 8.53235 28.8852 19.138 26.2251C19.138 26.2251 35.7646 22.0144 42.0625 25.7713V25.7965Z" fill="#52A6FF"/>
+<path d="M36.5202 20.9302C39.0646 22.4556 40.8406 24.1954 42.075 25.7839C35.7771 22.0144 19.1505 26.2377 19.1505 26.2377C8.54485 28.8978 3.09086 24.6871 1.98242 23.6785C3.83401 22.027 7.10893 19.8712 11.5049 18.4592C12.3614 18.8753 15.46 20.1738 19.6922 19.5686C24.6423 18.8627 30.4868 18.7492 36.5076 20.9302H36.5202Z" fill="#0175EE"/>
+<path d="M34.1774 19.6947C35.0213 20.0855 35.8023 20.5016 36.5076 20.9302C30.4868 18.7492 24.6424 18.8627 19.6922 19.5687C15.46 20.1738 12.3488 18.8753 11.4923 18.4592C16.4425 16.8582 22.8412 16.19 30.2349 18.2323C31.6834 18.661 32.9934 19.1652 34.1648 19.7073L34.1774 19.6947Z" fill="#015BC7"/>
+<path d="M19.201 11.1977C19.201 11.6894 18.8987 12.118 18.4704 12.3071C17.4628 12.8114 16.644 13.6182 16.1528 14.6268C16.0772 14.2738 16.0394 13.9082 16.0394 13.5426C16.0394 12.4332 16.3921 11.412 16.9841 10.5799C17.0219 10.5169 17.0723 10.4539 17.1227 10.4034C17.3368 10.1639 17.6517 10.0126 18.0044 10.0126C18.672 10.0126 19.201 10.5421 19.201 11.2103V11.1977Z" fill="#015BC7"/>
+<path d="M15.0569 15.837C15.0569 16.0261 15.0569 16.2152 15.0317 16.3917C14.4523 15.7992 13.7344 15.358 12.9282 15.1058C12.9156 15.1058 12.8904 15.1058 12.8653 15.0932C12.3488 14.9293 11.9709 14.4503 11.9709 13.8703C11.9709 13.1644 12.5378 12.597 13.2431 12.597C13.7218 12.597 14.15 12.8744 14.3642 13.2652C14.805 14.0216 15.0569 14.9041 15.0569 15.8244V15.837Z" fill="#015BC7"/>
+<path d="M20.0701 33.5119C20.6753 33.5119 21.1659 33.0209 21.1659 32.4151C21.1659 31.8094 20.6753 31.3183 20.0701 31.3183C19.4649 31.3183 18.9742 31.8094 18.9742 32.4151C18.9742 33.0209 19.4649 33.5119 20.0701 33.5119Z" fill="#0175EE"/>
+</g>
+<defs>
+<clipPath id="clip0_9_11">
+<rect width="46" height="28" fill="white" transform="translate(1 10)"/>
+</clipPath>
+</defs>
+</svg>
diff --git a/docs/public/icons/database/databricks.webp b/docs/public/icons/database/databricks.webp
new file mode 100644
index 0000000..0a74319
Binary files /dev/null and b/docs/public/icons/database/databricks.webp differ
diff --git a/docs/public/icons/database/db2.svg b/docs/public/icons/database/db2.svg
new file mode 100644
index 0000000..728876a
--- /dev/null
+++ b/docs/public/icons/database/db2.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path d="M559.309 379.085H51.2v237.568h508.109z"/><path fill="#093" d="M972.8 379.085H569.549v237.568H972.8z"/><path fill="#fff" d="M130.355 427.827v9.472h67.943v-9.472zm77.824 0v9.472h97.024s-9.881-9.472-22.937-9.472zm115.815 0v9.472h58.675l-3.38-9.472zm100.864 0-3.43 9.472h58.111v-9.472zm-294.503 18.586v9.472h67.943v-9.421h-67.943zm77.824.205v9.472h108.237s-1.331-7.373-3.43-9.472zm115.815 0v9.472h65.126l-3.226-9.472zm93.798 0-3.226 9.472h64.768v-9.472zM149.914 465.05v9.472h29.44v-9.524h-29.44zm77.824 0v9.472h29.44v-9.524h-29.44zm58.112 0v9.472h29.44s1.894-5.12 1.894-9.524H285.85zm57.702 0v9.472h52.224l-3.43-9.524h-48.794zm67.789 0-3.43 9.472h52.633v-9.524h-49.152zm-261.427 18.79v9.472h29.44v-9.472zm77.824 0v9.472h75.212s6.247-4.915 8.346-9.472zm115.814 0v9.472h29.44v-5.325l1.894 5.325h54.17l2.048-5.325v5.325h29.491v-9.472H405.3l-2.816 8.14-3.072-8.191h-55.859zm-193.638 18.586v9.472h29.44v-9.472zm77.824 0v9.472h83.558c-2.048-4.557-8.346-9.472-8.346-9.472zm115.814 0v9.472h29.44v-9.472zm34.97 0 3.584 9.472h40.448l3.43-9.472zm52.377 0v9.472h29.44v-9.472zm-280.985 18.432v9.472h29.44v-9.472zm77.824 0v9.472h29.44v-9.472zm58.112 0v9.472h31.334c0-4.557-1.894-9.472-1.894-9.472zm57.702 0v9.472h29.44v-9.472zm41.574 0 3.43 9.472h27.137l3.43-9.472zm45.773 0v9.472h29.44v-9.472zm-299.98 18.585v9.523h67.993v-9.523zm77.311 0v9.523h104.756c2.304-2.304 3.43-9.523 3.43-9.523H208.179zm116.378 0v9.523h48.384v-9.523zm67.174 0 3.584 9.523h13.876l3.43-9.523zm39.117 0v9.523h48.999v-9.523zm-299.98 18.79v9.524h67.993v-9.523zm77.311 0v9.524h73.83a36.86 36.86 0 0 0 22.99-9.523h-96.87zm116.378 0v9.524h48.384v-9.523zm74.035 0 3.43 9.524h.513l3.43-9.523zm32.256 0v9.524h48.999v-9.523zm224.256-17.459v-90.982h15.77c14.438 0 17.459 11.98 17.459 42.342 0 37.223-1.331 48.436-22.784 48.436h-10.445zm20.327 18.79a35.84 35.84 0 0 0 17.817-3.43c19.763-11.417 19.763-40.806 19.763-66.048 0-21.299-1.536-35.532-7.014-44.441a29.9 29.9 0 0 0-24.883-14.643H631.04v128.512h44.442zm83.148-18.738v-38.912h9.268c15.052 0 17.715 5.888 17.715 19.763 0 6.451-1.024 15.001-7.424 17.817-4.352 1.895-9.472 1.332-14.439 1.332zm0-57.703v-33.229h11.213c11.008.359 13.107 5.12 13.107 14.848 0 6.042-.41 10.599-2.662 13.824-3.84 4.762-11.418 4.352-17.1 4.352h-4.609v.205zm18.432 76.493c17.05 0 26.368-6.81 31.488-23.142 1.332-5.12 1.741-10.445 1.741-15.77 0-16.691-5.12-27.904-18.637-29.798v-.359c13.108-4.761 15.36-15.77 15.36-26.982 0-8.704-.921-16.128-6.246-23.143-6.81-8.755-16.896-9.523-27.34-9.523H734.72v128.512h42.342zm119.194 0v-18.79h-44.8c.154-8.704 7.578-17.101 12.493-22.221l18.79-19.559c9.882-10.035 15.207-20.89 15.207-35.123 0-20.48-14.234-33.024-34.304-33.229-37.07-.358-36.506 28.519-36.506 39.68v3.584h22.426c.153-6.041-.615-12.492 1.894-18.176 1.69-4.761 6.042-6.297 11.213-6.297 6.81 0 11.366 3.584 11.366 15.206 0 12.135-4.198 16.333-11.776 24.679l-11.571 12.339c-14.848 15.565-21.094 27.34-22.58 36.096a209 209 0 0 0-2.098 21.811zm33.024 6.195c9.728 0 17.664-7.987 17.664-17.664a17.613 17.613 0 1 0-17.664 17.664m0-3.225a14.44 14.44 0 0 1-14.387-14.439c0-7.936 6.451-14.233 14.438-14.233 7.936 0 14.234 6.45 14.234 14.233a14.13 14.13 0 0 1-14.234 14.439zm4.198-12.903c3.43-.205 5.325-1.69 5.325-5.12 0-1.894-.563-3.789-2.253-4.966-1.536-.922-3.635-.922-5.12-.922h-9.318v19.149h3.789v-8.14h3.789l4.147 8.191h4.403zm-7.577-2.867v-5.325h4.557c1.894 0 4.556 0 4.556 2.509 0 2.458-1.536 2.816-3.584 2.816z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/dm.svg b/docs/public/icons/database/dm.svg
new file mode 100644
index 0000000..5315156
--- /dev/null
+++ b/docs/public/icons/database/dm.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#ea4646" d="M295.526 392.14c19.456-16.486 40.704-33.177 62.67-47.615-16.692 55.04-19.866 173.568 106.905 193.536 95.232 15.001 119.296 45.21 108.083 195.942-19.558 9.216-39.014 16.896-58.88 24.064 12.544-62.464 26.47-174.592-64.307-192.819-110.541-22.272-167.936-36.864-154.47-173.107"/><path fill="#ea4646" d="M373.248 334.643a889 889 0 0 1 58.368-33.536c-21.504 100.864-14.336 188.416 103.782 206.848 69.99 10.957 124.263 36.25 110.234 186.368a714 714 0 0 1-54.374 31.027c10.393-59.904 10.65-180.838-72.192-193.587-124.57-19.2-162.253-53.248-145.818-197.12"/><path fill="#ea4646" d="M449.075 292.71c19.61-8.755 47.053-20.48 57.856-23.552-21.35 75.93-10.496 195.994 86.835 211.968 90.983 14.9 132.813 65.69 123.188 162.356-18.484 14.694-35.482 27.238-54.426 39.936 16.128-93.082-18.432-172.237-82.79-181.556-138.138-20.07-153.6-77.875-130.663-209.152"/><path fill="#1a2781" d="M267.008 418.918c-89.702 84.685-137.78 197.786-100.915 280.064 41.984 93.799 195.891 111.002 315.494 68.71 25.395-110.796 38.298-172.338-63.488-191.897-148.173-28.57-149.913-87.193-151.091-156.877m484.3 193.536c87.758-85.81 148.583-202.547 104.346-289.075-50.022-97.792-207.974-100.454-316.006-64.46-31.744 86.527-23.04 194.355 65.946 207.308 129.228 18.74 134.348 72.858 145.715 146.227"/><path fill="#de1a1b" d="M295.526 392.09c19.456-16.538 40.704-33.178 62.67-47.668-16.692 55.092-19.866 173.62 106.905 193.536 95.232 15.053 119.296 45.261 108.083 195.994-19.558 9.216-39.014 16.896-58.88 24.064 12.544-62.515 26.47-174.592-64.307-192.87-110.541-22.221-167.936-36.864-154.47-173.056"/><path fill="#de1a1b" d="M373.248 334.643c18.842-11.98 37.427-22.323 58.368-33.536-21.504 100.864-14.336 188.416 103.782 206.848 69.99 10.957 124.263 36.25 110.234 186.368-18.534 11.879-35.533 21.095-54.374 31.027 10.393-59.904 10.65-180.838-72.192-193.587-124.57-19.2-162.253-53.248-145.818-197.12"/><path fill="#de1a1b" d="M449.075 292.71c19.61-8.755 47.053-20.48 57.856-23.552-21.35 75.93-10.496 195.994 86.835 211.968 90.983 14.9 132.813 65.69 123.188 162.407-18.484 14.592-35.482 27.136-54.426 39.885 16.128-93.03-18.432-172.237-82.79-181.556-138.138-20.07-153.6-77.875-130.663-209.152"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/doris.svg b/docs/public/icons/database/doris.svg
new file mode 100644
index 0000000..e18c60e
--- /dev/null
+++ b/docs/public/icons/database/doris.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#52c9a3" d="M398.848 872.858c-36.813-8.704-69.99-47.616-76.698-89.856-3.84-24.372.41-44.442 14.08-66.458 4.096-6.554 69.018-74.086 151.757-157.798 84.48-85.504 147.61-151.143 151.86-158.004 8.601-13.824 17.51-35.174 19.763-47.36.921-4.812 2.816-9.216 4.25-9.728 3.122-1.228 85.094 81.05 100.351 100.762 28.365 36.096 32.103 51.814 32.256 69.786-.102 27.392-11.776 39.372-25.241 59.801-9.216 13.875-274.944 277.709-290.1 287.898-5.376 3.635-14.95 8.192-21.196 10.035-12.493 3.738-47.104 4.25-61.133.922z"/><path fill="#14a8c9" d="M419.328 389.018c-70.4-71.066-79.462-81.05-85.606-94.31-19.047-40.96-11.264-87.348 19.712-117.044 7.27-7.014 18.33-15.36 24.576-18.483 31.334-16.026 74.65-13.005 103.782 7.168 5.58 3.84 32.256 29.389 59.392 56.78 42.7 43.111 50.38 51.917 57.19 65.793 14.285 29.184 12.698 56.473-5.222 91.238-6.707 12.954-15.565 23.552-43.725 52.275-32.358 33.024-35.993 36.045-43.315 35.994-7.526 0-13.005-5.018-86.784-79.411"/><path fill="#5369a9" d="m256.666 698.624-4.967-5.325V327.526c0-7.372 11.776-9.881 18.33-9.932 7.27 0 14.336 6.553 100.352 93.184 80.793 81.254 92.672 88.012 92.62 99.993 0 11.981-11.775 18.688-92.62 99.994-87.347 87.859-93.03 93.133-100.71 93.133a16.64 16.64 0 0 1-13.057-5.274z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/duckdb.svg b/docs/public/icons/database/duckdb.svg
new file mode 100644
index 0000000..14dc392
--- /dev/null
+++ b/docs/public/icons/database/duckdb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path d="M512 921.6A409.09 409.09 0 0 1 102.4 512c0-226.611 182.989-409.6 409.6-409.6S921.6 285.389 921.6 512c0 226.355-182.989 409.6-409.6 409.6"/><path fill="#fff100" d="M731.034 450.765H650.65v121.241h80.384c33.536 0 60.979-27.648 60.979-60.979 0-33.28-27.443-60.262-60.98-60.262m-474.061 60.979a169.984 169.984 0 0 0 169.779 169.78 169.984 169.984 0 0 0 169.78-169.78 169.984 169.984 0 0 0-169.78-169.728 169.984 169.984 0 0 0-169.78 169.78z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/elasticsearch.svg b/docs/public/icons/database/elasticsearch.svg
new file mode 100644
index 0000000..48ef8a3
--- /dev/null
+++ b/docs/public/icons/database/elasticsearch.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#343741" d="M177.152 512c0 33.69 4.762 66.202 12.8 97.382h474.01a97.382 97.382 0 0 0 0-194.764h-474.01a388 388 0 0 0-12.8 97.382"/><path fill="#fec514" d="M832.512 309.043c13.62-12.544 26.317-26.06 37.888-40.448a388.6 388.6 0 0 0-303.77-146.022c-153.856 0-286.208 89.497-349.44 219.033h532.224a122.3 122.3 0 0 0 83.098-32.563"/><path fill="#00bfb3" d="M749.466 682.394H217.242c63.18 129.536 195.584 219.033 349.388 219.033A388.6 388.6 0 0 0 870.4 755.405a372 372 0 0 0-37.888-40.448 122.52 122.52 0 0 0-83.046-32.563"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/etcd.svg b/docs/public/icons/database/etcd.svg
new file mode 100644
index 0000000..a36ae07
--- /dev/null
+++ b/docs/public/icons/database/etcd.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" role="img" viewBox="-6.31 3.69 510.12 493.62">
+  <path fill="#419eda" d="M228.175 224.684a31.994 31.994 0 1 1-32.007-31.986 32.011 32.011 0 0 1 32.007 31.986zm41.37 0a32.007 32.007 0 1 0 32.007-31.986 31.988 31.988 0 0 0-32.007 31.986z"/>
+  <path fill="#419eda" d="M487.371 259.399a87.82 87.82 0 0 1-7.07.267 92.362 92.362 0 0 1-40.621-9.455 377.209 377.209 0 0 0 5.47-71.86 371.808 371.808 0 0 0-46.507-55.11 92.396 92.396 0 0 1 32.772-35.102l6.016-3.729-4.695-5.3a244.906 244.906 0 0 0-85.524-62.377l-6.507-2.828-1.654 6.862a92.144 92.144 0 0 1-23.19 42.096 371.928 371.928 0 0 0-67.006-27.602 370.624 370.624 0 0 0-66.908 27.558 91.915 91.915 0 0 1-23.098-42.003l-1.681-6.884-6.486 2.817a247.232 247.232 0 0 0-85.518 64.359l-4.689 5.3 6.005 3.724a92.249 92.249 0 0 1 32.695 34.917 374.63 374.63 0 0 0-46.425 54.908 376.956 376.956 0 0 0 5.328 72.334 92.115 92.115 0 0 1-40.376 9.374 86.36 86.36 0 0 1-7.086-.268l-7.053-.551.655 7.042a243.413 243.413 0 0 0 32.897 100.678l3.581 6.098 5.372-4.575a92.052 92.052 0 0 1 43.592-20.406 373.97 373.97 0 0 0 37.308 60.76 377.717 377.717 0 0 0 70.69 17.382 91.87 91.87 0 0 1-5.885 48.232l-2.686 6.54 6.9 1.529a246.355 246.355 0 0 0 52.966 5.857l52.954-5.857 6.906-1.529-2.675-6.54a91.755 91.755 0 0 1-5.869-48.286 377.784 377.784 0 0 0 70.407-17.328 372.3 372.3 0 0 0 37.335-60.815 92.233 92.233 0 0 1 43.81 20.428l5.377 4.553 3.587-6.049a242.844 242.844 0 0 0 32.859-100.672l.655-7.037zM324.644 345.45a285.884 285.884 0 0 1-151.628 0 290.124 290.124 0 0 1-46.141-143.385 288.675 288.675 0 0 1 54.957-52.315 293.065 293.065 0 0 1 67.028-36.462 293.976 293.976 0 0 1 66.891 36.364 290.886 290.886 0 0 1 55.198 52.675 292.253 292.253 0 0 1-13.817 74.682 293.726 293.726 0 0 1-32.488 68.441z"/>
+</svg>
diff --git a/docs/public/icons/database/exasol.webp b/docs/public/icons/database/exasol.webp
new file mode 100644
index 0000000..00b340d
Binary files /dev/null and b/docs/public/icons/database/exasol.webp differ
diff --git a/docs/public/icons/database/firebird.webp b/docs/public/icons/database/firebird.webp
new file mode 100644
index 0000000..fd84e6f
Binary files /dev/null and b/docs/public/icons/database/firebird.webp differ
diff --git a/docs/public/icons/database/gaussdb.svg b/docs/public/icons/database/gaussdb.svg
new file mode 100644
index 0000000..f115a85
--- /dev/null
+++ b/docs/public/icons/database/gaussdb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#9f53e6" d="M170.24 333.005a20.5 20.5 0 0 0-3.84 8.601h-.205v84.122a19.87 19.87 0 0 0 11.367 16.691l269.363 158.26a136.45 136.45 0 0 0 125.542 0l269.517-157.697a19.87 19.87 0 0 0 11.366-16.742l1.024-83.968-217.241-116.838-160.461 92.979a19.35 19.35 0 0 0-11.315 16.691v83.814c2.048 5.888 6.093 10.957 11.315 14.336 2.56-35.84 42.496-58.265 42.496-58.265l116.94-66.765 152.577 82.893-216.218 128.307a137.47 137.47 0 0 1-125.491 0l-226.509-133.58 226.407-133.53a126.5 126.5 0 0 1 62.873-15.207V153.6a126.8 126.8 0 0 0-62.873 15.155l-269.21 158.31a20.5 20.5 0 0 0-7.373 5.94zm679.22 236.851a19.9 19.9 0 0 0 3.378-9.882l-.307-83.302a19.87 19.87 0 0 1-11.366 16.691L572.109 651.571a136.5 136.5 0 0 1-125.491 0L177.05 492.75a19.87 19.87 0 0 1-11.367-16.691v83.456a19.87 19.87 0 0 0 11.367 16.69l269.568 158.414a137.42 137.42 0 0 0 125.49 0l269.364-157.901a19.97 19.97 0 0 0 7.987-6.81zm3.378 119.654a19.92 19.92 0 0 1-11.366 16.692L572.109 863.949a136.5 136.5 0 0 1-125.491 0L177.05 705.74a19.87 19.87 0 0 1-11.367-16.743v-83.456a19.71 19.71 0 0 0 11.367 16.692l269.568 158.412a137.47 137.47 0 0 0 125.49 0l269.057-157.9a19.56 19.56 0 0 0 11.366-16.692z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/gbase.webp b/docs/public/icons/database/gbase.webp
new file mode 100644
index 0000000..6a4bb56
Binary files /dev/null and b/docs/public/icons/database/gbase.webp differ
diff --git a/docs/public/icons/database/goldendb.png b/docs/public/icons/database/goldendb.png
new file mode 100644
index 0000000..b635a72
Binary files /dev/null and b/docs/public/icons/database/goldendb.png differ
diff --git a/docs/public/icons/database/greatsql.webp b/docs/public/icons/database/greatsql.webp
new file mode 100644
index 0000000..c7bd056
Binary files /dev/null and b/docs/public/icons/database/greatsql.webp differ
diff --git a/docs/public/icons/database/h2.svg b/docs/public/icons/database/h2.svg
new file mode 100644
index 0000000..56820c8
--- /dev/null
+++ b/docs/public/icons/database/h2.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#1021ff" d="M887.091 296.329H107.622v427.468h779.47v-427.52z"/><path fill="#0c08d5" d="M887.091 360.43c-365.568 45.21-688.23 165.787-770.56 363.367h770.56z"/><path fill="#fff" d="M531.354 477.32h44.441v72.602h39.424v-72.601h44.34v195.686h-44.442v-81.254h-39.424v81.254H531.2V477.32zm210.176 72.602h-42.957c0-14.643.563-26.112 1.74-34.457s3.84-15.719 7.68-22.016a40 40 0 0 1 17.716-15.36c7.936-3.84 17.459-5.735 28.313-5.735 18.023 0 32 4.66 41.677 14.234 9.677 9.523 14.49 23.142 14.49 41.062 0 9.216-1.895 19.047-5.581 29.645-3.635 10.547-9.216 22.272-16.691 34.867l-24.064 41.114h39.424v39.885H691.814l64-109.159c7.732-13.056 11.725-24.934 11.725-35.789a22.53 22.53 0 0 0-3.584-13.21c-2.304-3.378-5.222-5.12-8.755-5.12-5.58 0-9.216 2.202-10.854 6.606-1.741 4.403-2.51 13.21-2.51 26.265v7.168z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/highgo.png b/docs/public/icons/database/highgo.png
new file mode 100644
index 0000000..c1c434b
Binary files /dev/null and b/docs/public/icons/database/highgo.png differ
diff --git a/docs/public/icons/database/hive.svg b/docs/public/icons/database/hive.svg
new file mode 100644
index 0000000..4c95973
--- /dev/null
+++ b/docs/public/icons/database/hive.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#fdee21" d="M570.112 218.624c-7.066-19.354-250.266-113.92-253.389-103.526-44.646 11.622-62.822 63.13-93.542 95.744l-68.25-3.994c-30.003 38.656-45.773 78.131-35.072 119.194 38.554 52.172 83.251 96.563 111.104 162.099 2.202 30.925 133.735 3.225 161.895-2.867-38.503 27.545-72.039 70.297-57.6 193.33 13.158 57.806 22.118 122.318 138.803 187.649 15.36 8.601 47.155 18.534 66.816 25.805 18.79 8.601 40.755 12.134 102.758-6.81 35.84-15.462 74.599-24.78 109.722-40.192l-42.189 1.946c-58.112 1.28-102.963 5.632-116.838-10.599l-53.453-92.365 31.18-60.518c43.162 4.403 57.498 39.424 95.489 52.736l44.85-33.229c130.202 76.851 182.017-48.691 196.865-146.483-1.587-39.834-86.17 12.442-81.05-6.144 1.997-42.803-32.87-98.765-55.398-142.336L798.925 307.2c11.776-10.547-54.784-122.778-109.21-136.755-47.667-12.288-119.603 48.128-119.603 48.128z"/><path fill="#c8c037" d="M784.077 432.998c.46 10.804.41 24.013 1.433 32.256-.153 6.247-4.864 6.503-8.755 7.783l25.344 9.267c5.018 8.5 9.063 16.896 13.159 25.395 4.71 20.839 1.177 21.453-1.946 22.938-9.216.102-18.38.153-26.931-1.69 3.84 2.048 4.659 3.533 5.12 6.144.717 4.71-2.355 11.264-7.424 17.562 7.475 4.147 21.145 8.192 31.283 12.083l11.571-25.754c-5.222-37.888-21.145-72.704-42.854-105.984m47.257 126.976c14.08 5.837 33.485 4.096 60.416-9.728 3.994-2.867 7.68-1.177.512 3.482-35.276 31.693-52.172 15.872-60.928 6.195z"/><path fill="#c8c037" d="M894.464 546.048c4.096 7.987 1.587 14.49.205 21.248a180.2 180.2 0 0 1-36.045 89.856c-68.3 109.824-137.267 41.114-192.256-3.584l-22.733 56.934c-1.229 5.018-6.246 8.91 29.287 24.576l36.198-25.6c137.933 104.96 235.725-146.944 185.293-163.43zm-211.456 98.15c-9.318.615-37.018 10.036-38.246 15.514l12.8-18.995zm-18.074-116.48c1.69 0 9.882 2.202 9.012 1.741-1.28-.717-.154 11.469 2.406 17.818l-9.984 21.709c19.149-22.016 49.408-20.583 77.466-23.399l-13.364-8.345c2.304-7.732-.41-13.876-1.74-20.48zm47.002-65.433c-20.531 6.297-40.192 16.589-53.35 38.502 10.035-36.147 12.083-34.765 15.36-36.557 14.028-6.297 25.6-2.355 37.99-1.945"/><path fill="#fcf6a0" d="M602.266 885.76c-24.832 27.34-80.23-2.1-126.208-17.152-116.89-74.291-139.725-144.282-141.312-212.94-6.042-98.305 24.166-155.444 62.361-168.96-25.293 48.742-37.069 136.191-25.344 201.215 9.472 36.199 9.677 97.229 70.195 129.895 29.696 16.64 21.607 29.696 41.677 45.312 21.965 17.1 83.2 33.382 118.63 22.579zm37.068-454.451c-41.984-59.597-101.12-81.92-167.782-84.378 13.312-4.352 26.726-6.656 40.09-13.056 3.225-3.43 2.201-9.523.972-15.667-64.204-16.742-104.652-37.427-155.955-56.627l138.394 33.229c93.44 3.532 85.453 26.624 144.281 136.499m45.005-28.723c-31.078-44.34-61.184-98.15-102.041-132.352-98.714-44.544-196.352-77.67-310.784-107.776l36.505-46.95c121.447 27.698 235.52 74.086 337.664 150.527 17.255 43.725 28.775 87.552 38.656 136.55m62.618-78.336s-17.408-39.066-25.907-54.016c-19.661-21.76-29.594-62.362-69.888-81.51 12.8 3.43 21.504-.666 47.462 22.886l40.96 77.721zm21.657 67.686c3.994-33.894 11.623-88.166 2.868-109.568l-73.37-97.792c-4.096-3.789-7.014-8.96-10.189-12.954 34.509 8.96 70.503 32.922 119.04 127.59l-38.349 92.673z"/><path d="M623.616 395.93c-13.722-10.855-25.958-49.101-46.797-57.037-19.251-1.587-26.317-7.68-51.66-2.509 9.215-4.608 17.92-10.496 27.647-13.62 6.656-1.586 12.8.154 19.15 1.025 1.535-.768 2.56-1.639 2.2-3.072-25.497-15.719-77.823-15.975-113.151-24.935 40.96 1.332 86.323-.921 117.145 8.96 24.781 22.016 32.768 63.386 45.466 91.136zm75.11-184.423c5.684.512 36.352 48.896 37.735 56.986 2.56 17.613 8.806 37.376 10.496 55.808-5.018-17.715-10.496-35.38-17.408-53.043-1.997-4.864-7.066-15.872-21.146-31.437-6.605-10.957-7.987-19.61-9.677-28.314m103.732 263.68H789.35l14.49 3.789zm-89.344-13.107a118.3 118.3 0 0 0-39.834 1.075c-5.376 7.168-5.734 14.541-8.09 21.3 16.026-17.613 22.375-18.689 47.924-22.375m179.558 91.034c-7.322 5.836-8.038 11.366-29.696 17.92-15.82 3.788-24.73-2.56-32.154-11.06 11.264 3.226 13.056 11.725 43.316 2.202zm-65.638 3.686c-5.274 14.49-10.957 29.184-16.692 42.752-13.67 15.974-7.833 6.86-28.262 31.744 6.554-10.086 15.053-19.814 19.456-30.31 3.174-6.912 7.066-14.234 8.755-20.378-5.376-2.714-16.486-2.918-17.971-1.946-18.176 10.701-21.504 22.016-32.154 33.076 7.732-12.39 14.336-25.959 23.399-37.12 1.024-1.434 7.68-1.741 11.776-2.56-6.4-1.127-18.176-3.38-19.098-3.277-11.878 2.816-18.483 13.158-27.29 19.968 6.4-9.216 12.289-18.893 20.48-26.829.769-.922 22.785 1.024 34.202 5.53l.205 4.556 6.502 2.612 4.864-12.186 11.776-5.632zm-143.719 87.398c-2.97-1.024-28.774-4.3-28.774-3.532-9.933 7.065-11.418 13.824-11.213 19.66 16.486-16.23 15.872-16.281 39.936-16.128zm-19.66-116.736s18.636-2.713 18.278-.972c-1.331 6.502 2.304 22.22 2.662 20.019l-10.445 8.55c21.914-11.008 45.056-8.806 68.455-10.496 0 0-19.712-5.427-18.535-5.632 4.404-.614-1.177-20.531-2.662-20.992 3.738-1.229 7.424-2.201 11.213-3.174-28.211-7.373-44.544-3.021-68.967 12.697"/><path d="m824.986 541.389-4.096 2.048c-.615-12.135-13.67-11.264-24.679-11.367l-8.96-2.15c2.714 2.56 11.213 2.304 7.783 7.782-2.868 1.536-4.199 8.192-5.837 13.67l-4.915.257 26.112 10.24 5.58.87 13.364-7.168z"/><path fill="#fff" d="M701.44 533.197c-2.048-4.147-12.646-3.584-14.9-.87-1.842 2.201-.153 16.179 2.254 13.823a18.07 18.07 0 0 1 13.312-4.044 16.2 16.2 0 0 0-.666-8.91m101.222 20.838c.973-.717 3.072-7.68 2.407-9.83-1.383-4.967-11.213-3.891-11.213-3.891-2.406 1.382-4.506 9.113-3.584 11.673.41 2.15 10.752 2.816 12.39 2.048"/><path d="m383.078 796.262 6.144.615c36.762 18.022 97.28 44.8 184.832 30.413l13.824 21.606c-38.604 18.74-80.128 14.438-118.988 15.77zM330.342 653.62l18.381 77.312c49.255 30.771 133.427 66.048 203.623 63.232l-15.514-35.584c-146.432-31.13-158.874-70.451-206.54-104.96zm45.773-158.259c8.96 59.904 20.992 105.267 73.063 143.309 31.948 22.937 63.59 45.773 102.144 64.665 0 0-3.38 17.562-6.196 17.255C430.438 707.84 346.47 612.762 336.333 569.344c9.83-33.28 23.961-54.118 39.782-73.984m55.091-33.946c15.31 66.356 51.712 133.632 87.962 194.56 13.312 16.896 16.742 24.32 37.222 34.56 27.648 8.704 47.207 6.503 67.277 5.172-5.53-10.138-10.393-20.788-16.691-30.362-44.954-35.533-24.218-67.891-12.288-88.422-24.986-6.298-58.06-19.712-62.618-37.376-7.372-57.088-3.635-75.264 3.687-104.55-33.792 7.167-68.096 14.233-104.5 26.418z"/><path d="M307.046 108.851c-11.11 7.27-21.862 17.664-33.382 29.44-19.098 19.815-31.846 39.117-51.302 53.402-3.892 3.379-14.797 8.755-28.519 9.574-6.451.307-10.7 1.383-22.528-.102-10.496-5.632-20.48-1.997-30.208 9.625-10.65 15.36-24.115 44.39-29.696 62.72-11.571 46.695 17.92 85.197 46.131 114.842 25.19 24.576 39.68 39.936 50.023 62.464 7.782 14.643 13.619 34.662 19.865 48.742 2.253 4.455 1.792 4.404 7.885 5.786 13.159 2.765 31.386 2.816 47.616 4.198 7.015.103 16.64-.153 25.805-1.126 12.595-2.355 27.392-4.71 39.782-8.96 12.135-3.02 22.887-7.168 32.615-10.957-1.229 4.301-10.496 8.397-13.978 13.824-32.973 47.155-41.984 89.19-36.3 155.495 3.276 29.388 10.035 53.76 20.172 81.612 4.66 12.75 14.592 32.922 24.064 46.336 28.263 39.936 91.392 91.136 179.354 110.848 15.36 2.1 32.768 1.024 49.152-3.379 43.366-13.158 131.789-44.237 131.789-44.237s-78.49 6.503-114.432 2.919c-8.346-1.28-17.51-1.741-23.296-7.424-1.024-1.229-4.506-8.346-2.253-8.448 3.123-.051 12.083-3.789 25.856-5.018-29.44-3.174-29.03-3.072-31.181-8.499a337 337 0 0 0-13.722-29.696c12.954 1.126 41.626 2.714 51.303-7.322 0 0-16.896 1.946-31.949.205a92 92 0 0 1-16.23-4.608c-6.708-2.611-12.288-3.43-13.517-5.12-2.355-5.99-3.943-7.936-6.759-15.923-3.84-10.547-4.096-22.323-4.864-33.075 9.78 12.083 22.324 22.22 38.861 27.443.205-.46 21.453 9.216 36.864 4.25l3.226-1.024c0 .256-10.24.87-13.978-.973-31.385-13.312-36.096-24.986-41.165-30.823l-13.568-20.275c4.096-8.192 6.452-8.55 11.93-8.601 16.486 1.843 23.706 3.225 33.792.819 6.758 13.977 8.602 28.006 24.064 38.195 51.507 15.309 62.669-4.557 75.162-22.016 37.068 27.136 97.382 35.533 139.264.41 53.248-61.594 70.144-158.772 65.433-164.352-6.656-11.264-15.36-22.887-22.886-21.3-26.727 7.322-36.557 20.839-63.027 17.767 3.174-.205 8.448-.256 8.499-.563 2.048-22.426-.154-33.28-1.178-35.124-7.987-17.715-18.534-36.352-25.907-50.33-1.894-2.918-7.475-24.882-16.794-33.586-3.993-3.43-13.824-12.442-13.824-12.442l-.819 9.574s3.84.564 5.325 6.503c5.53 22.528 33.638 75.622 35.686 78.182 9.984 16.128 1.024 36.147 8.602 47.411.717 1.383 15.462-.153 26.88.512 18.74-3.993 17.92-12.288 34.202-13.516 10.905-.82 12.032 19.66 11.878 21.248-2.048 22.681-8.96 48.998-19.456 73.062-21.965 42.24-46.54 80.18-81.357 85.504-42.496 7.424-64.512-11.162-87.552-22.989l-8.857 7.527c-29.901 29.798-65.434 27.136-79.975-11.776-7.219-15.104-16.64-24.372-24.73-37.376l-42.803 30.873c-3.584 7.322-7.987 18.842-13.312 31.744a105.5 105.5 0 0 0-6.604 37.069c-5.479 9.318 19.046 47.258 34.508 70.298l13.364 19.456c3.072 7.936 9.83 15.001 10.24 15.872 28.672 37.478-36.25 28.825-49.664 26.572-26.522-4.198-52.43-15.308-76.8-30.054l-4.199-2.611a444.3 444.3 0 0 1-78.182-64.615c-13.466-15.257-26.317-46.592-35.84-68.812-14.183-53.402-34.611-145.92 20.685-216.064 3.481-3.994 7.27-10.701 10.496-12.032 16.435-11.11 34.304-18.688 53.452-22.887l-1.945-12.441a358.6 358.6 0 0 0-50.944 18.944c-20.736 5.99-37.94 12.288-64.41 18.944-8.601 1.024-17.05 1.024-25.293-.103-18.995-2.56-51.404-.256-53.504-2.201-12.85-17.92-16.384-50.125-28.16-67.328l-.102-.205-.154-.154c-6.86-9.216-14.848-16.691-22.732-24.525-28.16-27.955-52.224-55.04-58.983-83.712-1.69-8.448-6.041-17.203-3.737-42.24v-.153l.102-.103c6.758-23.398 17.766-42.496 36.454-61.593 19.456.307 38.759.768 53.76 3.584 6.861 1.177 21.197 3.072 35.994 8.55 37.427 13.978 86.886 36.864 86.886 36.864-37.12-20.377-78.643-46.848-104.857-52.224-3.891-.512-6.298-2.304-7.424-5.427 39.424-23.142 46.592-50.432 72.55-74.906 11.879-5.12 16.487-7.782 26.573-8.857 93.133 14.694 151.757 51.814 198.144 76.595 18.842 10.24 35.942 17.971 52.275 27.34 14.336 4.711 57.549 37.377 70.247 54.938 12.8 27.136 22.22 56.423 30.77 84.736 6.145 28.775 11.52 40.448 11.52 40.448s-5.222-24.064-4.351-28.416c5.427 2.048 18.227 6.042 23.552 5.428 0 0-23.706-12.288-26.829-23.04-9.933-34.765-19.968-88.781-22.63-91.597-7.578-9.523-39.22-33.792-58.624-44.954-7.322-4.25-11.264-6.86-11.623-8.704 6.195-6.297 13.824-14.592 20.736-19.814 6.554-5.069 12.544-10.752 21.76-14.183 40.295-18.124 63.335 7.015 68.813 1.895 0 0-8.704-9.933-4.813-8.295 3.943 2.15 16.794 4.66 18.227 5.99 14.695 11.47 53.095 53.454 76.237 97.793 5.581 10.854 7.834 18.022 5.223 31.078-2.56 13.107-4.608 20.275-7.373 29.03-2.56 5.837-16.999 45.825-16.896 51.2-2.919 21.965 9.37 49.46 9.37 49.46.153-7.475-.461-11.469.255-16.794l.82-9.523s-.512-2.56-.461-3.584c.665-6.554 2.253-12.083 2.713-15.872 4.608-28.672 12.698-49.306 21.812-74.445 2.713-6.349 6.246-9.881 6.092-14.694.154-8.602-7.526-20.07-13.056-31.335-5.632-11.366-12.288-24.064-21.094-37.376-19.968-28.774-37.069-51.302-68.3-65.382-8.705-3.84-43.111-7.578-54.99-5.376-14.387 3.02-26.777 5.99-36.659 12.288-15.565 9.984-27.75 25.395-42.086 34.458-31.744-15.872-47.002-27.7-49.869-29.338-18.842-10.086-41.472-21.811-65.74-32.922-11.674-10.905-84.122-36.864-150.426-42.086h-.052zm405.402 591.104c-19.558-15.257-35.994-31.027-46.848-47.155-3.533 18.995-16.384 32.563-26.317 45.875-1.945 3.123-3.379 7.424 6.349 20.992 2.611 3.635 12.134 4.25 18.534 3.943-6.502-4.967-16.435-10.138-18.022-14.695 11.469 7.834 22.016 10.087 31.642 8.807 2.201-.256 4.915-2.56 7.014-6.144 4.3-9.216 7.68-11.418 11.008-13.876l7.834 9.728z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/influxdb.svg b/docs/public/icons/database/influxdb.svg
new file mode 100644
index 0000000..18239a1
--- /dev/null
+++ b/docs/public/icons/database/influxdb.svg
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg width="154" height="156" viewBox="0 0 154 156" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path fill-rule="evenodd" clip-rule="evenodd" d="m 111.76244,105.55719 33.75203,-7.710196 c 0.51964,-0.104857 1.01231,-0.316521 1.4455,-0.621423 0.43411,-0.304901 0.7985,-0.696439 1.0718,-1.149608 0.27329,-0.453077 0.44899,-0.958023 0.51591,-1.482398 0.066,-0.524375 0.0223,-1.056837 -0.12921,-1.563456 l -14.3536,-62.024578 c -0.25936,-1.023558 -0.91564,-1.902939 -1.82477,-2.445254 -0.90912,-0.542316 -1.99673,-0.703319 -3.02484,-0.447685 l -33.738648,7.709824 c -1.021327,0.261025 -1.897268,0.914332 -2.43633,1.817045 -0.538969,0.902713 -0.697276,1.981302 -0.440062,2.99984 l 14.31261,62.025039 c 0.25936,1.02347 0.91471,1.90285 1.82383,2.44479 0.90913,0.54195 1.99767,0.70369 3.02578,0.44806 z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="m 100.13156,143.8846 40.92187,-37.74642 c 1.5431,-1.55054 1.15361,-2.50522 -0.97234,-1.74389 l -28.12437,6.36667 c -1.1629,0.28631 -2.2347,0.85986 -3.11687,1.6686 -0.88124,0.8078 -1.54403,1.82383 -1.92702,2.95512 l -8.532589,27.35097 c -0.58331,2.11757 0.195211,2.69856 1.751319,1.14895 z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="m 25.47096,131.56491 61.279242,18.86671 c 1.046984,0.19428 2.129198,0.0111 3.053291,-0.51685 0.924,-0.52707 1.629642,-1.36462 1.990783,-2.36205 l 10.268954,-32.74995 c 0.14873,-0.51034 0.19428,-1.04578 0.13479,-1.57378 -0.0586,-0.52893 -0.22217,-1.04019 -0.4806,-1.50591 -0.25842,-0.46572 -0.60608,-0.87566 -1.02346,-1.20752 -0.41738,-0.33093 -0.897043,-0.57727 -1.41017,-0.72322 L 38.004733,91.105883 c -1.037315,-0.295606 -2.149927,-0.170392 -3.095028,0.34822 -0.945009,0.518704 -1.645632,1.388696 -1.949046,2.420155 L 22.761334,126.55449 c -0.302949,1.02253 -0.188147,2.12222 0.31931,3.0611 0.507549,0.93794 1.366665,1.63884 2.390316,1.94932 z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="m 5.6834977,64.52991 12.4226043,54.1901 c 0.389028,2.11758 1.389533,2.11758 1.931477,0 l 8.531849,-27.35115 c 0.290772,-1.165411 0.30267,-2.3826 0.03477,-3.553403 C 28.33629,86.644654 27.796019,85.552772 27.02698,84.628028 L 7.4343376,63.560918 C 6.0725724,61.969203 5.0581988,62.412053 5.6834977,64.52991 Z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M 53.595516,6.602436 6.6564671,49.885345 c -0.7530573,0.714101 -1.1951843,1.693783 -1.2315519,2.728775 -0.036368,1.035084 0.3359197,2.043118 1.0370099,2.807882 L 29.931445,80.710788 c 0.723304,0.764299 1.72009,1.213378 2.773859,1.249632 1.05377,0.03635 2.079373,-0.343107 2.853897,-1.055815 l 46.92517,-43.352152 c 0.759558,-0.710384 1.206313,-1.691181 1.242752,-2.728404 0.03644,-1.037222 -0.340411,-2.046744 -1.048285,-2.808254 L 59.250973,6.7408501 C 58.890669,6.3587779 58.457672,6.0518109 57.977266,5.8377701 57.496767,5.6237302 56.978435,5.5068801 56.452294,5.4940029 55.926153,5.4811258 55.402708,5.5724784 54.912263,5.7627578 54.42191,5.9530368 53.974319,6.2384524 53.595516,6.602436 Z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="m 98.964945,104.58764 c 2.139885,0.58192 3.487775,-0.56704 2.917945,-2.76828 L 88.30678,43.269262 C 87.723098,41.151498 85.972332,40.57014 84.429884,42.106546 L 40.214339,83.022555 c -1.556299,1.536406 -1.167177,3.266629 0.958767,3.847986 z" fill="#d30971" />
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M 122.0445,22.922017 68.519141,6.6026591 C 66.393197,6.0213059 66.004075,6.7964388 67.740991,8.5266523 L 87.333698,29.524435 c 0.878916,0.818493 1.941981,1.415188 3.099956,1.740262 1.158067,0.325166 2.377394,0.369135 3.556006,0.128374 l 28.12456,-6.353291 c 2.07017,-0.581357 2.07017,-1.550256 -0.0697,-2.117763 z" fill="#d30971" />
+</svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/informix.svg b/docs/public/icons/database/informix.svg
new file mode 100644
index 0000000..60426de
--- /dev/null
+++ b/docs/public/icons/database/informix.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#fff" d="M551.629 505.907a49.7 49.7 0 0 0-21.248-3.993c-21.76 0-33.28 17.766-33.28 37.888v70.45h-33.792V472.116H497.1v15.463c7.475-12.032 21.248-17.204 31.59-17.767a42.96 42.96 0 0 1 22.938 3.43zm-539.546-93.44h35.021v197.786h-35.02zm291.84 88.883H266.65v108.954h-33.792V501.35h-17.204v-29.235h17.204v-11.469c0-29.235 20.633-48.128 53.862-48.128h17.203v29.184h-9.216c-22.886 0-28.057 8.602-28.057 27.546v2.867h37.273zm138.752 39.578c0 40.704-25.241 72.192-67.635 72.192-43.008 0-68.25-31.488-68.25-72.192 0-41.318 25.242-71.117 68.25-71.117 42.394 0 67.635 29.799 67.635 71.117m-33.28 0c0-22.374-9.165-42.445-34.355-42.445-25.805 0-34.97 20.634-34.97 42.445 0 22.886 8.602 43.008 34.97 43.008 25.805 0 34.406-20.122 34.406-43.008zm-208.077 69.325h-33.894v-75.674c0-20.07-6.912-33.792-27.546-33.229-17.766 0-29.184 11.47-29.184 34.407v74.547H76.851v-138.24h33.792v10.342c9.728-8.601 24.064-12.595 37.274-12.595 32.717 0 53.35 21.811 53.35 54.477v86.016zm398.439 0v-81.92c0-15.514 2.304-26.983 17.203-26.983 9.216 0 14.336 4.608 14.336 21.76v87.194h33.792v-82.022c0-15.463 2.355-26.932 17.254-26.932 9.165 0 14.336 4.608 14.336 21.76v87.194h33.792V509.952a39.58 39.58 0 0 0-10.29-28.672 41.98 41.98 0 0 0-30.977-11.469 50.7 50.7 0 0 0-32.102 10.906c-9.165-8.602-17.767-10.906-29.235-10.906a39.94 39.94 0 0 0-28.11 11.469v-9.216h-33.791v138.24h33.792z"/><path fill="#d35d35" d="M819.354 450.867c12.032 0 21.196-9.165 21.196-20.633a20.685 20.685 0 0 0-21.196-20.634 20.582 20.582 0 1 0 0 41.267m.563 55.04-26.931 70.554a81 81 0 0 0-3.43 10.905c-1.127 5.12 1.74 5.735 5.12 3.994 9.778-4.045 21.247-21.197 26.418-27.546l4.608 2.304c-10.342 18.944-29.85 47.616-53.913 47.616-10.906 0-17.203-7.475-17.767-17.203-.614-8.601 2.868-16.64 5.12-24.064l25.805-66.56a276 276 0 0 0 4.045-11.469c.512-4.608-2.304-5.12-5.734-3.43-9.728 4.045-21.248 21.248-26.368 27.546l-4.608-2.304c10.905-18.944 30.412-47.616 54.476-47.616 10.292 0 15.463 4.608 17.204 12.646 1.126 5.734 0 13.773-4.045 24.627"/><path fill="#3b68af" d="m825.702 610.304 67.584-10.906-55.552-4.044 65.895-10.292-55.603-5.17 65.945-9.729-55.603-5.171 66.509-9.216-56.218-6.86 66.56-7.425-65.997-8.038 56.218-6.912-65.946-8.602 56.167-5.683-65.895-9.728 55.604-4.608-65.383-10.342 55.655-3.994-67.072-11.469h76.236l25.805 39.527 25.19-39.527h43.623l-48.18 68.813 52.174 69.325h-43.572l-29.235-42.394-29.85 42.394h-75.059zm190.31-139.93h3.994c3.482 0 4.608-1.126 4.608-2.867s-1.126-2.304-3.993-2.304h-4.608zm5.12-6.86c4.097 0 6.35 1.126 6.35 3.993 0 1.741-.564 2.304-2.304 3.43l.614.564.512 1.177c.614.564.614 1.127.614 2.304v1.127l.564.563v1.74h-2.304c-.512-.562-.512-.562-.512-2.303 0-3.43-.615-3.994-4.608-3.994h-4.045v6.298h-2.253v-14.9h7.475zm-13.72 7.424c0 6.912 5.734 12.646 13.209 12.646a12.75 12.75 0 0 0 12.595-12.646 12.29 12.29 0 0 0-12.595-12.032c-7.475 0-13.21 5.17-13.21 12.032m28.671 0c0 8.038-6.86 14.336-15.462 14.336s-15.514-6.298-15.514-14.336c0-7.988 6.912-14.336 15.514-14.336s15.462 6.348 15.462 14.336"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/iotdb.svg b/docs/public/icons/database/iotdb.svg
new file mode 100644
index 0000000..d742630
--- /dev/null
+++ b/docs/public/icons/database/iotdb.svg
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 24.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1"
+	 id="Õ_xBA__x2264__x201E__1" xmlns:cc="http://creativecommons.org/ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:svg="http://www.w3.org/2000/svg"
+	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 107.7 107.7"
+	 style="enable-background:new 0 0 107.7 107.7;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill-rule:evenodd;clip-rule:evenodd;fill:#9E2878;}
+</style>
+<g>
+	<g id="g1133" transform="translate(-244.51235,-228.78793)">
+		<path id="path1119" class="st0" d="M340.8,253.8c2.6-1,5.5,0.4,6.2,3c0.7,2.6-1.1,5.7-3.7,6.4c-3.2,0.6-6.2-1.4-9.3,0.2
+			c-3.1,1.7-4,5.2-4.7,8.3c-1.4,5-8.5,7.3-12.1,4.2c-3.3-2.4-3.4-7.8-0.2-11c2.2-2.5,5.9-3.3,8.8-2c2.7,1.2,6,1.7,8.6-0.4
+			C337.5,260.1,336.7,255.1,340.8,253.8L340.8,253.8z"/>
+		<path id="path1121" class="st0" d="M280.5,244.7c4.2-2.2,9.5,1.5,8.2,6.1c-1.4,5.4-0.7,11.5,2.9,15.5c3.4,4,9.8,4.8,14.6,1.9
+			c3.7-2.1,6-5.8,7.4-9.6c1-3.1,0.6-6.2,1.1-9.3c1-3.8,5.8-6,9.1-4.2c3.2,1.4,4,5.9,1.7,8.8c-1.4,2.2-4.2,2.7-6.3,3.8
+			c-3.6,1.9-6.5,4.9-8.4,8.6c-1.2,2.1-1.1,4.5-1.7,6.7c-0.9,1.9-3,2.7-4.8,2.9c-4.8,0.6-9.5,3-13,6.7c-1.7,1.7-3.1,4.2-5.6,4.2
+			c-2.7-0.2-4.7-2.6-7.4-2.7c-4.9-0.7-10.2,0.7-14.4,4c-3.7,3.1-9.4,0.8-9.6-3.7c-0.9-5.1,6.2-9.5,10.1-6.2c4.3,4,10.8,5.6,16.9,3.7
+			c5.6-1.9,9.7-8.3,8.6-14c-0.9-4.9-4.2-9.3-8.6-11.4c-1.7-0.8-3.6-1.6-4.2-3.5C275.6,250.2,277.3,246.2,280.5,244.7L280.5,244.7z"
+			/>
+		<path id="path1123" class="st0" d="M277.8,235.9c2.2-0.8,4.2,1.3,3.3,3.4c-0.6,2.1-3.7,2.7-4.8,1.1
+			C275,238.9,276,236.4,277.8,235.9z"/>
+		<path id="path1125" class="st0" d="M246.9,278.8c2.2-0.8,4.2,1.2,3.3,3.4c-0.6,2.1-3.7,2.7-4.8,1C244,281.9,245,279.3,246.9,278.8
+			L246.9,278.8z"/>
+		<path id="path1127" class="st0" d="M328.2,236.2c2.2-0.7,4.2,1.3,3.3,3.5c-0.6,2-3.7,2.7-4.8,1
+			C325.4,239.2,326.3,236.8,328.2,236.2z"/>
+		<path id="path1129" class="st0" d="M253.6,257.7c0.4-3.7,5.5-5.9,8.1-3.6c1.9,1.1,1.6,3.6,2.2,5.4c0.4,2.4,2.7,4.3,5.2,4.3
+			c3.2,0.3,6.4-2.3,9.5-1.2c4.8,1.2,6.5,7.5,3.2,11.5c-2.9,4.1-9.3,4.5-12,0.7c-2.4-2.8-0.5-7.1-2.7-10.1c-1.7-2.9-5.4-2.7-8.3-1.9
+			C255.8,263.8,253,260.7,253.6,257.7L253.6,257.7z"/>
+		<path id="path1131" class="st0" d="M300.8,230c3.3-1.9,7.5,0.9,6.7,4.6c0,2.3-2.2,3.6-3.5,5.2c-1.9,1.9-2.3,4.9-1.2,7
+			c1.3,2.9,4.9,4,5.5,7.2c1.2,4.8-3.3,10.1-8.2,9.8c-4.8,0.1-8.3-5-6.3-9.5c1.2-3.8,5.8-4.9,7.2-8.5c1.7-3.2-0.4-6.1-2.4-8.1
+			C296.7,235.6,297.9,231.4,300.8,230z"/>
+	</g>
+	<g id="g1149" transform="translate(-244.51235,-228.78793)">
+		<path id="path1135" class="st0" d="M256,311.5c-2.6,1-5.5-0.4-6.2-3c-0.7-2.6,1.1-5.7,3.7-6.4c3.2-0.6,6.2,1.4,9.3-0.2
+			c3.1-1.6,4-5.1,4.7-8.2c1.4-5,8.5-7.3,12.1-4.2c3.3,2.4,3.4,7.8,0.2,10.9c-2.2,2.5-5.9,3.3-8.8,2c-2.7-1.2-6-1.7-8.6,0.4
+			C259.1,305,259.9,310.2,256,311.5L256,311.5z"/>
+		<path id="path1137" class="st0" d="M316.1,320.5c-4.2,2.2-9.5-1.5-8.2-6c1.4-5.4,0.7-11.6-2.9-15.6c-3.4-4-9.8-4.7-14.6-1.9
+			c-3.7,2-6,5.7-7.4,9.5c-1,3.1-0.6,6.2-1.1,9.3c-1,3.8-5.8,6-9.1,4.3c-3.2-1.4-4-5.9-1.7-8.9c1.4-2.2,4.2-2.7,6.3-3.8
+			c3.6-1.9,6.5-4.9,8.4-8.6c1.2-2,1.1-4.5,1.7-6.6c0.9-1.9,3-2.7,4.8-2.9c4.8-0.6,9.5-3,13-6.7c1.7-1.6,3.1-4.2,5.6-4.1
+			c2.7,0.1,4.7,2.5,7.4,2.7c4.9,0.6,10.2-0.8,14.4-4c3.7-3.2,9.4-0.9,9.6,3.6c0.9,5.1-6.2,9.5-10.1,6.2c-4.3-4-10.8-5.6-16.9-3.7
+			c-5.6,1.9-9.7,8.3-8.6,14c0.9,4.8,4.2,9.3,8.6,11.3c1.7,0.8,3.6,1.6,4.2,3.5C321.2,314.9,319.4,319.1,316.1,320.5L316.1,320.5z"/>
+		<path id="path1139" class="st0" d="M318.9,329.4c-2.2,0.8-4.2-1.3-3.3-3.4c0.6-2.1,3.7-2.7,4.8-1.1
+			C321.7,326.3,320.7,328.8,318.9,329.4z"/>
+		<path id="path1141" class="st0" d="M349.9,286.5c-2.2,0.7-4.2-1.3-3.3-3.5c0.6-2.1,3.7-2.7,4.8-1
+			C352.8,283.5,351.8,285.9,349.9,286.5z"/>
+		<path id="path1143" class="st0" d="M268.5,329c-2.2,0.7-4.2-1.3-3.3-3.5c0.6-2,3.7-2.7,4.8-1C271.3,325.9,270.3,328.5,268.5,329z"
+			/>
+		<path id="path1145" class="st0" d="M343.1,307.4c-0.4,3.7-5.5,5.9-8.1,3.6c-1.9-1.1-1.6-3.6-2.2-5.4c-0.4-2.4-2.7-4.3-5.2-4.3
+			c-3.2-0.3-6.4,2.3-9.5,1.2c-4.8-1.2-6.5-7.5-3.2-11.5c2.9-4.1,9.3-4.5,12-0.7c2.4,2.8,0.5,7,2.7,10c1.7,2.9,5.4,2.7,8.3,1.9
+			C341,301.4,343.8,304.4,343.1,307.4L343.1,307.4z"/>
+		<path id="path1147" class="st0" d="M295.8,335.2c-3.3,2-7.5-0.9-6.7-4.6c0-2.3,2.2-3.6,3.5-5.2c1.9-1.9,2.3-4.9,1.2-7
+			c-1.3-2.9-4.9-4-5.5-7.2c-1.2-4.8,3.3-10.1,8.2-9.8c4.8-0.1,8.3,5,6.3,9.6c-1.2,3.7-5.8,4.8-7.2,8.4c-1.7,3.2,0.4,6.1,2.4,8.2
+			C300,329.6,298.8,333.8,295.8,335.2L295.8,335.2z"/>
+	</g>
+</g>
+</svg>
diff --git a/docs/public/icons/database/iris.png b/docs/public/icons/database/iris.png
new file mode 100644
index 0000000..e4be5d9
Binary files /dev/null and b/docs/public/icons/database/iris.png differ
diff --git a/docs/public/icons/database/jdbc.svg b/docs/public/icons/database/jdbc.svg
new file mode 100644
index 0000000..94f9d6b
--- /dev/null
+++ b/docs/public/icons/database/jdbc.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 200 200">
+  <rect width="200" height="200" rx="36" fill="#6ea8ff"/>
+  <text x="100" y="118" font-family="system-ui, -apple-system, sans-serif" font-size="44" font-weight="700" fill="white" text-anchor="middle" letter-spacing="-1">JDBC</text>
+</svg>
diff --git a/docs/public/icons/database/kingbase.svg b/docs/public/icons/database/kingbase.svg
new file mode 100644
index 0000000..9d7f076
--- /dev/null
+++ b/docs/public/icons/database/kingbase.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#c9151e" d="M339.2 204.8v236.083l-148.531 73.421 148.48 69.99v239.104h130.457V650.342L833.28 823.398V687.872L469.606 514.304 833.28 338.381V209.05L469.606 377.702V204.8z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/kwdb.svg b/docs/public/icons/database/kwdb.svg
new file mode 100644
index 0000000..4877759
--- /dev/null
+++ b/docs/public/icons/database/kwdb.svg
@@ -0,0 +1 @@
+<svg id="图层_1" data-name="图层 1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 371.33 401.04"><defs><style>.cls-1{fill:none;}.cls-2{clip-path:url(#clip-path);}.cls-3{fill:#002db2;}.cls-4{fill:#012eb2;}.cls-5{fill:#012fb2;}.cls-6{fill:#0230b2;}.cls-7{fill:#0231b3;}.cls-8{fill:#0332b3;}.cls-9{fill:#0433b3;}.cls-10{fill:#0434b3;}.cls-11{fill:#0535b3;}.cls-12{fill:#0636b3;}.cls-13{fill:#0637b3;}.cls-14{fill:#0738b3;}.cls-15{fill:#0739b4;}.cls-16{fill:#083ab4;}.cls-17{fill:#093bb4;}.cls-18{fill:#093cb4;}.cls-19{fill:#0a3db4;}.cls-20{fill:#0b3eb4;}.cls-21{fill:#0b3fb4;}.cls-22{fill:#0c40b5;}.cls-23{fill:#0c41b5;}.cls-24{fill:#0d42b5;}.cls-25{fill:#0e43b5;}.cls-26{fill:#0e44b5;}.cls-27{fill:#0f45b5;}.cls-28{fill:#1046b5;}.cls-29{fill:#1047b5;}.cls-30{fill:#1148b6;}.cls-31{fill:#1149b6;}.cls-32{fill:#124ab6;}.cls-33{fill:#134bb6;}.cls-34{fill:#134cb6;}.cls-35{fill:#144db6;}.cls-36{fill:#144eb6;}.cls-37{fill:#154fb7;}.cls-38{fill:#1650b7;}.cls-39{fill:#1651b7;}.cls-40{fill:#1752b7;}.cls-41{fill:#1853b7;}.cls-42{fill:#1854b7;}.cls-43{fill:#1955b7;}.cls-44{fill:#1956b7;}.cls-45{fill:#1a57b8;}.cls-46{fill:#1b58b8;}.cls-47{fill:#1b59b8;}.cls-48{fill:#1c5ab8;}.cls-49{fill:#1d5bb8;}.cls-50{fill:#1d5cb8;}.cls-51{fill:#1e5db8;}.cls-52{fill:#1e5eb8;}.cls-53{fill:#1f5fb9;}.cls-54{fill:#2060b9;}.cls-55{fill:#2061b9;}.cls-56{fill:#2162b9;}.cls-57{fill:#2263b9;}.cls-58{fill:#2264b9;}.cls-59{fill:#2365b9;}.cls-60{fill:#2366ba;}.cls-61{fill:#2467ba;}.cls-62{fill:#2568ba;}.cls-63{fill:#2569ba;}.cls-64{fill:#266aba;}.cls-65{fill:#266bba;}.cls-66{fill:#276cba;}.cls-67{fill:#286dba;}.cls-68{fill:#286ebb;}.cls-69{fill:#296fbb;}.cls-70{fill:#2a70bb;}.cls-71{fill:#2a71bb;}.cls-72{fill:#2b72bb;}.cls-73{fill:#2b73bb;}.cls-74{fill:#2c74bb;}.cls-75{fill:#2d75bc;}.cls-76{fill:#2d76bc;}.cls-77{fill:#2e77bc;}.cls-78{fill:#2f78bc;}.cls-79{fill:#2f79bc;}.cls-80{fill:#307abc;}.cls-81{fill:#307bbc;}.cls-82{fill:#317cbc;}.cls-83{fill:#327dbd;}.cls-84{fill:#327ebd;}.cls-85{fill:#337fbd;}.cls-86{fill:#3380bd;}.cls-87{fill:#3482bd;}.cls-88{fill:#3583bd;}.cls-89{fill:#3584bd;}.cls-90{fill:#3685be;}.cls-91{fill:#3786be;}.cls-92{fill:#3787be;}.cls-93{fill:#3888be;}.cls-94{fill:#3889be;}.cls-95{fill:#398abe;}.cls-96{fill:#3a8bbe;}.cls-97{fill:#3a8cbe;}.cls-98{fill:#3b8dbf;}.cls-99{fill:#3c8ebf;}.cls-100{fill:#3c8fbf;}.cls-101{fill:#3d90bf;}.cls-102{fill:#3d91bf;}.cls-103{fill:#3e92bf;}.cls-104{fill:#3f93bf;}.cls-105{fill:#3f94c0;}.cls-106{fill:#4095c0;}.cls-107{fill:#4196c0;}.cls-108{fill:#4197c0;}.cls-109{fill:#4298c0;}.cls-110{fill:#4299c0;}.cls-111{fill:#439ac0;}.cls-112{fill:#449bc0;}.cls-113{fill:#449cc1;}.cls-114{fill:#459dc1;}.cls-115{fill:#459ec1;}.cls-116{fill:#469fc1;}.cls-117{fill:#47a0c1;}.cls-118{fill:#47a1c1;}.cls-119{fill:#48a2c1;}.cls-120{fill:#49a3c2;}.cls-121{fill:#49a4c2;}.cls-122{fill:#4aa5c2;}.cls-123{fill:#4aa6c2;}.cls-124{fill:#4ba7c2;}.cls-125{fill:#4ca8c2;}.cls-126{fill:#4ca9c2;}.cls-127{fill:#4daac2;}.cls-128{fill:#4eabc3;}.cls-129{fill:#4eacc3;}.cls-130{fill:#4fadc3;}.cls-131{fill:#4faec3;}.cls-132{fill:#50afc3;}.cls-133{fill:#51b0c3;}.cls-134{fill:#51b1c3;}.cls-135{fill:#52b2c3;}.cls-136{fill:#53b3c4;}.cls-137{fill:#53b4c4;}.cls-138{fill:#54b5c4;}.cls-139{fill:#54b6c4;}.cls-140{fill:#55b7c4;}.cls-141{fill:#56b8c4;}.cls-142{fill:#56b9c4;}.cls-143{fill:#57bac5;}.cls-144{fill:#57bbc5;}.cls-145{fill:#58bcc5;}.cls-146{fill:#59bdc5;}.cls-147{fill:#59bec5;}.cls-148{fill:#5abfc5;}.cls-149{fill:#5bc0c5;}.cls-150{fill:#5bc1c5;}.cls-151{fill:#5cc2c6;}.cls-152{fill:#5cc3c6;}.cls-153{fill:#5dc4c6;}.cls-154{fill:#5ec5c6;}.cls-155{fill:#5ec6c6;}.cls-156{fill:#5fc7c6;}.cls-157{fill:#60c8c6;}.cls-158{fill:#60c9c7;}.cls-159{fill:#61cac7;}.cls-160{fill:#61cbc7;}.cls-161{fill:#62ccc7;}.cls-162{fill:#63cdc7;}.cls-163{fill:#63cec7;}.cls-164{fill:#64cfc7;}.cls-165{fill:#65d0c7;}.cls-166{fill:#65d1c8;}.cls-167{fill:#66d2c8;}.cls-168{fill:#66d3c8;}.cls-169{fill:#67d4c8;}.cls-170{clip-path:url(#clip-path-2);}.cls-171{fill:#66d3c9;}.cls-172{fill:#66d2c9;}.cls-173{fill:#65d1ca;}.cls-174{fill:#64d0cb;}.cls-175{fill:#64cfcb;}.cls-176{fill:#63cecc;}.cls-177{fill:#62cdcd;}.cls-178{fill:#62cccd;}.cls-179{fill:#61cbce;}.cls-180{fill:#60cacf;}.cls-181{fill:#60c9cf;}.cls-182{fill:#5fc8d0;}.cls-183{fill:#5ec7d1;}.cls-184{fill:#5ec6d1;}.cls-185{fill:#5dc5d2;}.cls-186{fill:#5cc4d3;}.cls-187{fill:#5cc3d3;}.cls-188{fill:#5bc2d4;}.cls-189{fill:#5ac1d5;}.cls-190{fill:#59bfd6;}.cls-191{fill:#59bed6;}.cls-192{fill:#58bdd7;}.cls-193{fill:#57bcd8;}.cls-194{fill:#57bbd8;}.cls-195{fill:#56bad9;}.cls-196{fill:#55b9da;}.cls-197{fill:#55b8da;}.cls-198{fill:#54b7db;}.cls-199{fill:#53b6dc;}.cls-200{fill:#53b5dc;}.cls-201{fill:#52b4dd;}.cls-202{fill:#51b3de;}.cls-203{fill:#51b2de;}.cls-204{fill:#50b1df;}.cls-205{fill:#4fb0e0;}.cls-206{fill:#4fafe0;}.cls-207{fill:#4eaee1;}.cls-208{fill:#4dade2;}.cls-209{fill:#4dace2;}.cls-210{fill:#4cabe3;}.cls-211{fill:#4baae4;}.cls-212{fill:#4ba9e4;}.cls-213{fill:#4aa8e5;}.cls-214{fill:#49a7e6;}.cls-215{fill:#48a6e7;}.cls-216{fill:#48a5e7;}.cls-217{fill:#47a4e8;}.cls-218{fill:#46a3e9;}.cls-219{fill:#46a2e9;}.cls-220{fill:#45a1ea;}.cls-221{fill:#44a0eb;}.cls-222{fill:#449feb;}.cls-223{fill:#439eec;}.cls-224{fill:#429ded;}.cls-225{fill:#419cee;}.cls-226{fill:#419bee;}.cls-227{fill:#409aef;}.cls-228{fill:#3f99f0;}.cls-229{fill:#3f98f0;}.cls-230{fill:#3e96f1;}.cls-231{fill:#3d95f2;}.cls-232{fill:#3d94f2;}.cls-233{fill:#3c93f3;}.cls-234{fill:#3b92f4;}.cls-235{fill:#3a91f5;}.cls-236{fill:#3a90f5;}.cls-237{fill:#398ff6;}.cls-238{fill:#388ef7;}.cls-239{fill:#388df7;}.cls-240{fill:#378cf8;}.cls-241{fill:#368bf9;}.cls-242{fill:#368af9;}.cls-243{fill:#3589fa;}.cls-244{fill:#3488fb;}.cls-245{fill:#3387fc;}.cls-246{fill:#3386fc;}.cls-247{fill:#3285fd;}.cls-248{fill:#3184fe;}.cls-249{fill:#3183fe;}.cls-250{fill:#3082ff;}.cls-251{clip-path:url(#clip-path-3);}.cls-252{fill:#012eb3;}.cls-253{fill:#012fb4;}.cls-254{fill:#0230b5;}.cls-255{fill:#0231b6;}.cls-256{fill:#0332b7;}.cls-257{fill:#0333b8;}.cls-258{fill:#0434b8;}.cls-259{fill:#0535b9;}.cls-260{fill:#0536ba;}.cls-261{fill:#0637bb;}.cls-262{fill:#0638bc;}.cls-263{fill:#0739bd;}.cls-264{fill:#073abe;}.cls-265{fill:#083bbf;}.cls-266{fill:#093cc0;}.cls-267{fill:#093dc1;}.cls-268{fill:#0a3ec2;}.cls-269{fill:#0a3fc3;}.cls-270{fill:#0b40c4;}.cls-271{fill:#0c42c5;}.cls-272{fill:#0c43c5;}.cls-273{fill:#0d44c6;}.cls-274{fill:#0d45c7;}.cls-275{fill:#0e46c8;}.cls-276{fill:#0e47c9;}.cls-277{fill:#0f48ca;}.cls-278{fill:#1049cb;}.cls-279{fill:#104acc;}.cls-280{fill:#114bcd;}.cls-281{fill:#114cce;}.cls-282{fill:#124dcf;}.cls-283{fill:#124ed0;}.cls-284{fill:#134fd1;}.cls-285{fill:#1450d1;}.cls-286{fill:#1451d2;}.cls-287{fill:#1552d3;}.cls-288{fill:#1553d4;}.cls-289{fill:#1654d5;}.cls-290{fill:#1655d6;}.cls-291{fill:#1756d7;}.cls-292{clip-path:url(#clip-path-4);}.cls-293{fill:#0331b3;}.cls-294{fill:#0738b4;}.cls-295{fill:#0839b4;}.cls-296{fill:#0b3fb5;}.cls-297{fill:#0d41b5;}.cls-298{fill:#0f44b5;}.cls-299{fill:#1047b6;}.cls-300{fill:#1249b6;}.cls-301{fill:#144cb6;}.cls-302{fill:#154eb7;}.cls-303{fill:#164fb7;}.cls-304{fill:#1751b7;}.cls-305{fill:#1954b7;}.cls-306{fill:#1956b8;}.cls-307{fill:#1c5bb8;}.cls-308{fill:#1e5db9;}.cls-309{fill:#1e5eb9;}.cls-310{fill:#2264ba;}.cls-311{fill:#2365ba;}.cls-312{fill:#276bba;}.cls-313{fill:#276cbb;}.cls-314{fill:#286dbb;}.cls-315{fill:#296ebb;}.cls-316{fill:#2c73bc;}.cls-317{fill:#2c74bc;}.cls-318{fill:#2e76bc;}.cls-319{fill:#307abd;}.cls-320{fill:#317bbd;}.cls-321{fill:#317cbd;}.cls-322{clip-path:url(#clip-path-5);}.cls-323{fill:#1857d8;}.cls-324{fill:#1858d9;}.cls-325{fill:#1959da;}.cls-326{fill:#195adb;}.cls-327{fill:#1a5bdc;}.cls-328{fill:#1a5cdd;}.cls-329{fill:#1b5dde;}.cls-330{fill:#1c5ede;}.cls-331{fill:#1c5fdf;}.cls-332{fill:#1d60e0;}.cls-333{fill:#1d61e1;}.cls-334{fill:#1e62e2;}.cls-335{fill:#1f63e3;}.cls-336{fill:#1f64e4;}.cls-337{fill:#2065e5;}.cls-338{fill:#2066e6;}.cls-339{fill:#2167e7;}.cls-340{fill:#2168e8;}.cls-341{fill:#2269e9;}.cls-342{fill:#236aea;}.cls-343{fill:#236beb;}.cls-344{fill:#246deb;}.cls-345{fill:#246eec;}.cls-346{fill:#256fed;}.cls-347{fill:#2670ee;}.cls-348{fill:#2671ef;}.cls-349{fill:#2772f0;}.cls-350{fill:#2773f1;}.cls-351{fill:#2874f2;}.cls-352{fill:#2875f3;}.cls-353{fill:#2976f4;}.cls-354{fill:#2a77f5;}.cls-355{fill:#2a78f6;}.cls-356{fill:#2b79f7;}.cls-357{fill:#2b7af8;}.cls-358{fill:#2c7bf8;}.cls-359{fill:#2d7cf9;}.cls-360{fill:#2d7dfa;}.cls-361{fill:#2e7efb;}.cls-362{fill:#2e7ffc;}.cls-363{fill:#2f80fd;}.cls-364{fill:#2f81fe;}.cls-365{clip-path:url(#clip-path-6);}.cls-366{fill:#49a6e7;}.cls-367{fill:#429cee;}.cls-368{fill:#3e97f1;}.cls-369{fill:#3b91f5;}.cls-370{fill:#3487fc;}</style><clipPath id="clip-path"><path class="cls-1" d="M280.66,283.79,31,304.28c-19.95,1.64-31-12.78-24.78-32.2l37-114.6c6.26-19.41,27.51-36.48,47.45-38.12L340.28,98.87c20-1.64,31.05,12.78,24.78,32.2L328.12,245.66C321.85,265.08,300.61,282.15,280.66,283.79Z"/></clipPath><clipPath id="clip-path-2"><path class="cls-1" d="M152.8,327,16.52,125.8C5.63,109.72,13,92.46,32.87,87.25L150.44,56.47c19.92-5.21,44.9,3.59,55.79,19.67L342.51,277.35c10.89,16.07,3.56,33.34-16.36,38.55L208.59,346.68C188.67,351.89,163.69,343.09,152.8,327Z"/></clipPath><clipPath id="clip-path-3"><path class="cls-1" d="M307.73,164.43,199,381.77c-8.69,17.37-27.24,19.27-41.44,4.25L73.78,297.37c-14.2-15-18.66-41.28-10-58.65L172.52,21.38C181.21,4,199.76,2.11,214,17.13l83.79,88.65C312,120.81,316.42,147.06,307.73,164.43Z"/></clipPath><clipPath id="clip-path-4"><path class="cls-1" d="M43.21,158.33,6.26,272.93C0,292.35,11.09,306.76,31,305.13l100.76-8.27h0L76.21,214.78l113.65-12.36,38-93.48h0L90.66,120.21C70.72,121.84,49.47,138.91,43.21,158.33Z"/></clipPath><clipPath id="clip-path-5"><path class="cls-1" d="M215,15c-14.2-15-32.76-13.12-41.44,4.25l-48.66,97.28,102.94-8.45-38,93.47,56.78,85h0l62.15-124.26c8.69-17.37,4.22-43.62-10-58.65Z"/></clipPath><clipPath id="clip-path-6"><path class="cls-1" d="M290,199.85l-43.38,86.73-56.78-85L76.74,214.72,152.8,327c10.89,16.08,35.87,24.88,55.79,19.67L326.15,315.9c19.92-5.21,27.25-22.48,16.36-38.55Z"/></clipPath></defs><g class="cls-2"><polygon class="cls-3" points="139.5 97.23 33.17 305.92 7.09 305.92 0 302.31 0 97.23 139.5 97.23"/><polygon class="cls-3" points="140.69 97.23 34.36 305.92 33.17 305.92 139.5 97.23 140.69 97.23"/><polygon class="cls-4" points="141.88 97.23 35.55 305.92 34.36 305.92 140.69 97.23 141.88 97.23"/><polygon class="cls-5" points="143.07 97.23 36.74 305.92 35.55 305.92 141.88 97.23 143.07 97.23"/><polygon class="cls-6" points="144.26 97.23 37.93 305.92 36.74 305.92 143.07 97.23 144.26 97.23"/><polygon class="cls-7" points="145.45 97.23 39.12 305.92 37.93 305.92 144.26 97.23 145.45 97.23"/><polygon class="cls-8" points="146.64 97.23 40.31 305.92 39.12 305.92 145.45 97.23 146.64 97.23"/><polygon class="cls-9" points="147.83 97.23 41.5 305.92 40.31 305.92 146.64 97.23 147.83 97.23"/><polygon class="cls-10" points="149.02 97.23 42.69 305.92 41.5 305.92 147.83 97.23 149.02 97.23"/><polygon class="cls-11" points="150.21 97.23 43.88 305.92 42.69 305.92 149.02 97.23 150.21 97.23"/><polygon class="cls-12" points="151.4 97.23 45.07 305.92 43.88 305.92 150.21 97.23 151.4 97.23"/><polygon class="cls-13" points="152.59 97.23 46.26 305.92 45.07 305.92 151.4 97.23 152.59 97.23"/><polygon class="cls-14" points="153.78 97.23 47.45 305.92 46.26 305.92 152.59 97.23 153.78 97.23"/><polygon class="cls-15" points="154.97 97.23 48.64 305.92 47.45 305.92 153.78 97.23 154.97 97.23"/><polygon class="cls-16" points="156.15 97.23 49.83 305.92 48.64 305.92 154.97 97.23 156.15 97.23"/><polygon class="cls-17" points="157.34 97.23 51.02 305.92 49.83 305.92 156.15 97.23 157.34 97.23"/><polygon class="cls-18" points="158.53 97.23 52.2 305.92 51.02 305.92 157.34 97.23 158.53 97.23"/><polygon class="cls-19" points="159.72 97.23 53.39 305.92 52.2 305.92 158.53 97.23 159.72 97.23"/><polygon class="cls-20" points="160.91 97.23 54.58 305.92 53.39 305.92 159.72 97.23 160.91 97.23"/><polygon class="cls-21" points="162.1 97.23 55.77 305.92 54.58 305.92 160.91 97.23 162.1 97.23"/><polygon class="cls-22" points="163.29 97.23 56.96 305.92 55.77 305.92 162.1 97.23 163.29 97.23"/><polygon class="cls-23" points="164.48 97.23 58.15 305.92 56.96 305.92 163.29 97.23 164.48 97.23"/><polygon class="cls-24" points="165.67 97.23 59.34 305.92 58.15 305.92 164.48 97.23 165.67 97.23"/><polygon class="cls-25" points="166.86 97.23 60.53 305.92 59.34 305.92 165.67 97.23 166.86 97.23"/><polygon class="cls-26" points="168.05 97.23 61.72 305.92 60.53 305.92 166.86 97.23 168.05 97.23"/><polygon class="cls-27" points="169.24 97.23 62.91 305.92 61.72 305.92 168.05 97.23 169.24 97.23"/><polygon class="cls-28" points="170.43 97.23 64.1 305.92 62.91 305.92 169.24 97.23 170.43 97.23"/><polygon class="cls-29" points="171.62 97.23 65.29 305.92 64.1 305.92 170.43 97.23 171.62 97.23"/><polygon class="cls-30" points="172.81 97.23 66.48 305.92 65.29 305.92 171.62 97.23 172.81 97.23"/><polygon class="cls-31" points="174 97.23 67.67 305.92 66.48 305.92 172.81 97.23 174 97.23"/><polygon class="cls-32" points="175.19 97.23 68.86 305.92 67.67 305.92 174 97.23 175.19 97.23"/><polygon class="cls-33" points="176.38 97.23 70.05 305.92 68.86 305.92 175.19 97.23 176.38 97.23"/><polygon class="cls-34" points="177.57 97.23 71.24 305.92 70.05 305.92 176.38 97.23 177.57 97.23"/><polygon class="cls-35" points="178.76 97.23 72.43 305.92 71.24 305.92 177.57 97.23 178.76 97.23"/><polygon class="cls-36" points="179.94 97.23 73.62 305.92 72.43 305.92 178.76 97.23 179.94 97.23"/><polygon class="cls-37" points="181.13 97.23 74.81 305.92 73.62 305.92 179.94 97.23 181.13 97.23"/><polygon class="cls-38" points="182.32 97.23 76 305.92 74.81 305.92 181.13 97.23 182.32 97.23"/><polygon class="cls-39" points="183.51 97.23 77.19 305.92 76 305.92 182.32 97.23 183.51 97.23"/><polygon class="cls-40" points="184.7 97.23 78.37 305.92 77.19 305.92 183.51 97.23 184.7 97.23"/><polygon class="cls-41" points="185.89 97.23 79.56 305.92 78.37 305.92 184.7 97.23 185.89 97.23"/><polygon class="cls-42" points="187.08 97.23 80.75 305.92 79.56 305.92 185.89 97.23 187.08 97.23"/><polygon class="cls-43" points="188.27 97.23 81.94 305.92 80.75 305.92 187.08 97.23 188.27 97.23"/><polygon class="cls-44" points="189.46 97.23 83.13 305.92 81.94 305.92 188.27 97.23 189.46 97.23"/><polygon class="cls-45" points="190.65 97.23 84.32 305.92 83.13 305.92 189.46 97.23 190.65 97.23"/><polygon class="cls-46" points="191.84 97.23 85.51 305.92 84.32 305.92 190.65 97.23 191.84 97.23"/><polygon class="cls-47" points="193.03 97.23 86.7 305.92 85.51 305.92 191.84 97.23 193.03 97.23"/><polygon class="cls-48" points="194.22 97.23 87.89 305.92 86.7 305.92 193.03 97.23 194.22 97.23"/><polygon class="cls-49" points="195.41 97.23 89.08 305.92 87.89 305.92 194.22 97.23 195.41 97.23"/><polygon class="cls-50" points="196.6 97.23 90.27 305.92 89.08 305.92 195.41 97.23 196.6 97.23"/><polygon class="cls-51" points="197.79 97.23 91.46 305.92 90.27 305.92 196.6 97.23 197.79 97.23"/><polygon class="cls-52" points="198.98 97.23 92.65 305.92 91.46 305.92 197.79 97.23 198.98 97.23"/><polygon class="cls-53" points="200.17 97.23 93.84 305.92 92.65 305.92 198.98 97.23 200.17 97.23"/><polygon class="cls-54" points="201.36 97.23 95.03 305.92 93.84 305.92 200.17 97.23 201.36 97.23"/><polygon class="cls-55" points="202.55 97.23 96.22 305.92 95.03 305.92 201.36 97.23 202.55 97.23"/><polygon class="cls-56" points="203.74 97.23 97.41 305.92 96.22 305.92 202.55 97.23 203.74 97.23"/><polygon class="cls-57" points="204.93 97.23 98.6 305.92 97.41 305.92 203.74 97.23 204.93 97.23"/><polygon class="cls-58" points="206.12 97.23 99.79 305.92 98.6 305.92 204.93 97.23 206.12 97.23"/><polygon class="cls-59" points="207.31 97.23 100.97 305.92 99.79 305.92 206.12 97.23 207.31 97.23"/><polygon class="cls-60" points="208.49 97.23 102.17 305.92 100.97 305.92 207.31 97.23 208.49 97.23"/><polygon class="cls-61" points="209.68 97.23 103.35 305.92 102.17 305.92 208.49 97.23 209.68 97.23"/><polygon class="cls-62" points="210.87 97.23 104.54 305.92 103.35 305.92 209.68 97.23 210.87 97.23"/><polygon class="cls-63" points="212.06 97.23 105.73 305.92 104.54 305.92 210.87 97.23 212.06 97.23"/><polygon class="cls-64" points="213.25 97.23 106.92 305.92 105.73 305.92 212.06 97.23 213.25 97.23"/><polygon class="cls-65" points="214.44 97.23 108.11 305.92 106.92 305.92 213.25 97.23 214.44 97.23"/><polygon class="cls-66" points="215.63 97.23 109.3 305.92 108.11 305.92 214.44 97.23 215.63 97.23"/><polygon class="cls-67" points="216.82 97.23 110.49 305.92 109.3 305.92 215.63 97.23 216.82 97.23"/><polygon class="cls-68" points="218.01 97.23 111.68 305.92 110.49 305.92 216.82 97.23 218.01 97.23"/><polygon class="cls-69" points="219.2 97.23 112.87 305.92 111.68 305.92 218.01 97.23 219.2 97.23"/><polygon class="cls-70" points="220.39 97.23 114.06 305.92 112.87 305.92 219.2 97.23 220.39 97.23"/><polygon class="cls-71" points="221.58 97.23 115.25 305.92 114.06 305.92 220.39 97.23 221.58 97.23"/><polygon class="cls-72" points="222.77 97.23 116.44 305.92 115.25 305.92 221.58 97.23 222.77 97.23"/><polygon class="cls-73" points="223.96 97.23 117.63 305.92 116.44 305.92 222.77 97.23 223.96 97.23"/><polygon class="cls-74" points="225.15 97.23 118.82 305.92 117.63 305.92 223.96 97.23 225.15 97.23"/><polygon class="cls-75" points="226.34 97.23 120.01 305.92 118.82 305.92 225.15 97.23 226.34 97.23"/><polygon class="cls-76" points="227.53 97.23 121.2 305.92 120.01 305.92 226.34 97.23 227.53 97.23"/><polygon class="cls-77" points="228.72 97.23 122.39 305.92 121.2 305.92 227.53 97.23 228.72 97.23"/><polygon class="cls-78" points="229.91 97.23 123.58 305.92 122.39 305.92 228.72 97.23 229.91 97.23"/><polygon class="cls-79" points="231.1 97.23 124.77 305.92 123.58 305.92 229.91 97.23 231.1 97.23"/><polygon class="cls-80" points="232.28 97.23 125.96 305.92 124.77 305.92 231.1 97.23 232.28 97.23"/><polygon class="cls-81" points="233.47 97.23 127.14 305.92 125.96 305.92 232.28 97.23 233.47 97.23"/><polygon class="cls-82" points="234.66 97.23 128.34 305.92 127.14 305.92 233.47 97.23 234.66 97.23"/><polygon class="cls-83" points="235.85 97.23 129.52 305.92 128.34 305.92 234.66 97.23 235.85 97.23"/><polygon class="cls-84" points="237.04 97.23 130.71 305.92 129.52 305.92 235.85 97.23 237.04 97.23"/><polygon class="cls-85" points="238.23 97.23 131.9 305.92 130.71 305.92 237.04 97.23 238.23 97.23"/><polygon class="cls-86" points="239.42 97.23 133.09 305.92 131.9 305.92 238.23 97.23 239.42 97.23"/><polygon class="cls-87" points="240.61 97.23 134.28 305.92 133.09 305.92 239.42 97.23 240.61 97.23"/><polygon class="cls-88" points="241.8 97.23 135.47 305.92 134.28 305.92 240.61 97.23 241.8 97.23"/><polygon class="cls-89" points="242.99 97.23 136.66 305.92 135.47 305.92 241.8 97.23 242.99 97.23"/><polygon class="cls-90" points="244.18 97.23 137.85 305.92 136.66 305.92 242.99 97.23 244.18 97.23"/><polygon class="cls-91" points="245.37 97.23 139.04 305.92 137.85 305.92 244.18 97.23 245.37 97.23"/><polygon class="cls-92" points="246.56 97.23 140.23 305.92 139.04 305.92 245.37 97.23 246.56 97.23"/><polygon class="cls-93" points="247.75 97.23 141.42 305.92 140.23 305.92 246.56 97.23 247.75 97.23"/><polygon class="cls-94" points="248.94 97.23 142.61 305.92 141.42 305.92 247.75 97.23 248.94 97.23"/><polygon class="cls-95" points="250.13 97.23 143.8 305.92 142.61 305.92 248.94 97.23 250.13 97.23"/><polygon class="cls-96" points="251.32 97.23 144.99 305.92 143.8 305.92 250.13 97.23 251.32 97.23"/><polygon class="cls-97" points="252.51 97.23 146.18 305.92 144.99 305.92 251.32 97.23 252.51 97.23"/><polygon class="cls-98" points="253.7 97.23 147.37 305.92 146.18 305.92 252.51 97.23 253.7 97.23"/><polygon class="cls-99" points="254.89 97.23 148.56 305.92 147.37 305.92 253.7 97.23 254.89 97.23"/><polygon class="cls-100" points="256.08 97.23 149.75 305.92 148.56 305.92 254.89 97.23 256.08 97.23"/><polygon class="cls-101" points="257.26 97.23 150.94 305.92 149.75 305.92 256.08 97.23 257.26 97.23"/><polygon class="cls-102" points="258.45 97.23 152.13 305.92 150.94 305.92 257.26 97.23 258.45 97.23"/><polygon class="cls-103" points="259.64 97.23 153.31 305.92 152.13 305.92 258.45 97.23 259.64 97.23"/><polygon class="cls-104" points="260.83 97.23 154.5 305.92 153.31 305.92 259.64 97.23 260.83 97.23"/><polygon class="cls-105" points="262.02 97.23 155.69 305.92 154.5 305.92 260.83 97.23 262.02 97.23"/><polygon class="cls-106" points="263.21 97.23 156.88 305.92 155.69 305.92 262.02 97.23 263.21 97.23"/><polygon class="cls-107" points="264.4 97.23 158.07 305.92 156.88 305.92 263.21 97.23 264.4 97.23"/><polygon class="cls-108" points="265.59 97.23 159.26 305.92 158.07 305.92 264.4 97.23 265.59 97.23"/><polygon class="cls-109" points="266.78 97.23 160.45 305.92 159.26 305.92 265.59 97.23 266.78 97.23"/><polygon class="cls-110" points="267.97 97.23 161.64 305.92 160.45 305.92 266.78 97.23 267.97 97.23"/><polygon class="cls-111" points="269.16 97.23 162.83 305.92 161.64 305.92 267.97 97.23 269.16 97.23"/><polygon class="cls-112" points="270.35 97.23 164.02 305.92 162.83 305.92 269.16 97.23 270.35 97.23"/><polygon class="cls-113" points="271.54 97.23 165.21 305.92 164.02 305.92 270.35 97.23 271.54 97.23"/><polygon class="cls-114" points="272.73 97.23 166.4 305.92 165.21 305.92 271.54 97.23 272.73 97.23"/><polygon class="cls-115" points="273.92 97.23 167.59 305.92 166.4 305.92 272.73 97.23 273.92 97.23"/><polygon class="cls-116" points="275.11 97.23 168.78 305.92 167.59 305.92 273.92 97.23 275.11 97.23"/><polygon class="cls-117" points="276.3 97.23 169.97 305.92 168.78 305.92 275.11 97.23 276.3 97.23"/><polygon class="cls-118" points="277.49 97.23 171.16 305.92 169.97 305.92 276.3 97.23 277.49 97.23"/><polygon class="cls-119" points="278.68 97.23 172.35 305.92 171.16 305.92 277.49 97.23 278.68 97.23"/><polygon class="cls-120" points="279.87 97.23 173.54 305.92 172.35 305.92 278.68 97.23 279.87 97.23"/><polygon class="cls-121" points="281.06 97.23 174.73 305.92 173.54 305.92 279.87 97.23 281.06 97.23"/><polygon class="cls-122" points="282.25 97.23 175.92 305.92 174.73 305.92 281.06 97.23 282.25 97.23"/><polygon class="cls-123" points="283.44 97.23 177.11 305.92 175.92 305.92 282.25 97.23 283.44 97.23"/><polygon class="cls-124" points="284.63 97.23 178.29 305.92 177.11 305.92 283.44 97.23 284.63 97.23"/><polygon class="cls-125" points="285.81 97.23 179.49 305.92 178.29 305.92 284.63 97.23 285.81 97.23"/><polygon class="cls-126" points="287 97.23 180.68 305.92 179.49 305.92 285.81 97.23 287 97.23"/><polygon class="cls-127" points="288.19 97.23 181.86 305.92 180.68 305.92 287 97.23 288.19 97.23"/><polygon class="cls-128" points="289.38 97.23 183.05 305.92 181.86 305.92 288.19 97.23 289.38 97.23"/><polygon class="cls-129" points="290.57 97.23 184.24 305.92 183.05 305.92 289.38 97.23 290.57 97.23"/><polygon class="cls-130" points="291.76 97.23 185.43 305.92 184.24 305.92 290.57 97.23 291.76 97.23"/><polygon class="cls-131" points="292.95 97.23 186.62 305.92 185.43 305.92 291.76 97.23 292.95 97.23"/><polygon class="cls-132" points="294.14 97.23 187.81 305.92 186.62 305.92 292.95 97.23 294.14 97.23"/><polygon class="cls-133" points="295.33 97.23 189 305.92 187.81 305.92 294.14 97.23 295.33 97.23"/><polygon class="cls-134" points="296.52 97.23 190.19 305.92 189 305.92 295.33 97.23 296.52 97.23"/><polygon class="cls-135" points="297.71 97.23 191.38 305.92 190.19 305.92 296.52 97.23 297.71 97.23"/><polygon class="cls-136" points="298.9 97.23 192.57 305.92 191.38 305.92 297.71 97.23 298.9 97.23"/><polygon class="cls-137" points="300.09 97.23 193.76 305.92 192.57 305.92 298.9 97.23 300.09 97.23"/><polygon class="cls-138" points="301.28 97.23 194.95 305.92 193.76 305.92 300.09 97.23 301.28 97.23"/><polygon class="cls-139" points="302.47 97.23 196.14 305.92 194.95 305.92 301.28 97.23 302.47 97.23"/><polygon class="cls-140" points="303.66 97.23 197.33 305.92 196.14 305.92 302.47 97.23 303.66 97.23"/><polygon class="cls-141" points="304.85 97.23 198.52 305.92 197.33 305.92 303.66 97.23 304.85 97.23"/><polygon class="cls-142" points="306.04 97.23 199.71 305.92 198.52 305.92 304.85 97.23 306.04 97.23"/><polygon class="cls-143" points="307.23 97.23 200.9 305.92 199.71 305.92 306.04 97.23 307.23 97.23"/><polygon class="cls-144" points="308.42 97.23 202.09 305.92 200.9 305.92 307.23 97.23 308.42 97.23"/><polygon class="cls-145" points="309.61 97.23 203.28 305.92 202.09 305.92 308.42 97.23 309.61 97.23"/><polygon class="cls-146" points="310.8 97.23 204.47 305.92 203.28 305.92 309.61 97.23 310.8 97.23"/><polygon class="cls-147" points="311.98 97.23 205.66 305.92 204.47 305.92 310.8 97.23 311.98 97.23"/><polygon class="cls-148" points="313.17 97.23 206.84 305.92 205.66 305.92 311.98 97.23 313.17 97.23"/><polygon class="cls-149" points="314.36 97.23 208.03 305.92 206.84 305.92 313.17 97.23 314.36 97.23"/><polygon class="cls-150" points="315.55 97.23 209.22 305.92 208.03 305.92 314.36 97.23 315.55 97.23"/><polygon class="cls-151" points="316.74 97.23 210.41 305.92 209.22 305.92 315.55 97.23 316.74 97.23"/><polygon class="cls-152" points="317.93 97.23 211.6 305.92 210.41 305.92 316.74 97.23 317.93 97.23"/><polygon class="cls-153" points="319.12 97.23 212.79 305.92 211.6 305.92 317.93 97.23 319.12 97.23"/><polygon class="cls-154" points="320.31 97.23 213.98 305.92 212.79 305.92 319.12 97.23 320.31 97.23"/><polygon class="cls-155" points="321.5 97.23 215.17 305.92 213.98 305.92 320.31 97.23 321.5 97.23"/><polygon class="cls-156" points="322.69 97.23 216.36 305.92 215.17 305.92 321.5 97.23 322.69 97.23"/><polygon class="cls-157" points="323.88 97.23 217.55 305.92 216.36 305.92 322.69 97.23 323.88 97.23"/><polygon class="cls-158" points="325.07 97.23 218.74 305.92 217.55 305.92 323.88 97.23 325.07 97.23"/><polygon class="cls-159" points="326.26 97.23 219.93 305.92 218.74 305.92 325.07 97.23 326.26 97.23"/><polygon class="cls-160" points="327.45 97.23 221.12 305.92 219.93 305.92 326.26 97.23 327.45 97.23"/><polygon class="cls-161" points="328.64 97.23 222.31 305.92 221.12 305.92 327.45 97.23 328.64 97.23"/><polygon class="cls-162" points="329.83 97.23 223.5 305.92 222.31 305.92 328.64 97.23 329.83 97.23"/><polygon class="cls-163" points="331.02 97.23 224.69 305.92 223.5 305.92 329.83 97.23 331.02 97.23"/><polygon class="cls-164" points="332.21 97.23 225.88 305.92 224.69 305.92 331.02 97.23 332.21 97.23"/><polygon class="cls-165" points="333.4 97.23 227.07 305.92 225.88 305.92 332.21 97.23 333.4 97.23"/><polygon class="cls-166" points="334.58 97.23 228.26 305.92 227.07 305.92 333.4 97.23 334.58 97.23"/><polygon class="cls-167" points="335.77 97.23 229.45 305.92 228.26 305.92 334.58 97.23 335.77 97.23"/><polygon class="cls-168" points="336.96 97.23 230.63 305.92 229.45 305.92 335.77 97.23 336.96 97.23"/><polygon class="cls-169" points="338.15 97.23 231.82 305.92 230.63 305.92 336.96 97.23 338.15 97.23"/><polygon class="cls-169" points="364.24 97.23 371.33 100.84 371.33 305.92 231.82 305.92 338.15 97.23 364.24 97.23"/></g><g class="cls-170"><polygon class="cls-169" points="312.54 51.26 316.81 75.46 7.36 130.03 5.63 120.2 5.63 51.26 312.54 51.26"/><rect class="cls-169" x="5.19" y="102.72" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -15.59, 29.76)"/><rect class="cls-171" x="5.62" y="105.17" width="314.22" height="2.49" transform="translate(-16.01 29.88) rotate(-10)"/><rect class="cls-172" x="6.06" y="107.62" width="314.22" height="2.49" transform="translate(-16.43 29.99) rotate(-10)"/><rect class="cls-173" x="6.49" y="110.07" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -16.84, 30.1)"/><rect class="cls-174" x="6.92" y="112.52" width="314.22" height="2.49" transform="translate(-17.26 30.21) rotate(-10)"/><rect class="cls-175" x="7.35" y="114.98" width="314.22" height="2.49" transform="translate(-17.68 30.32) rotate(-10)"/><rect class="cls-176" x="7.78" y="117.43" width="314.22" height="2.49" transform="translate(-18.1 30.44) rotate(-10)"/><rect class="cls-177" x="8.22" y="119.88" width="314.22" height="2.49" transform="translate(-18.52 30.55) rotate(-10)"/><rect class="cls-178" x="8.65" y="122.33" width="314.22" height="2.49" transform="translate(-18.94 30.66) rotate(-10)"/><rect class="cls-179" x="9.08" y="124.78" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -19.36, 30.77)"/><rect class="cls-180" x="9.51" y="127.23" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -19.78, 30.89)"/><rect class="cls-181" x="9.94" y="129.68" width="314.22" height="2.49" transform="translate(-20.2 31) rotate(-10)"/><rect class="cls-182" x="10.38" y="132.13" width="314.22" height="2.49" transform="translate(-20.62 31.11) rotate(-10)"/><rect class="cls-183" x="10.81" y="134.58" width="314.22" height="2.49" transform="translate(-21.03 31.22) rotate(-10)"/><rect class="cls-184" x="11.24" y="137.03" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -21.45, 31.33)"/><rect class="cls-185" x="11.67" y="139.48" width="314.22" height="2.49" transform="translate(-21.87 31.45) rotate(-10)"/><rect class="cls-186" x="12.1" y="141.93" width="314.22" height="2.49" transform="translate(-22.29 31.56) rotate(-10)"/><rect class="cls-187" x="12.54" y="144.38" width="314.22" height="2.49" transform="translate(-22.71 31.67) rotate(-10)"/><rect class="cls-188" x="12.97" y="146.83" width="314.22" height="2.49" transform="translate(-23.13 31.78) rotate(-10)"/><rect class="cls-189" x="13.4" y="149.28" width="314.22" height="2.49" transform="translate(-23.55 31.9) rotate(-10)"/><rect class="cls-190" x="13.83" y="151.73" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -23.97, 32.01)"/><rect class="cls-191" x="14.26" y="154.18" width="314.22" height="2.49" transform="translate(-24.39 32.12) rotate(-10)"/><rect class="cls-192" x="14.7" y="156.63" width="314.22" height="2.49" transform="translate(-24.8 32.23) rotate(-10)"/><rect class="cls-193" x="15.13" y="159.08" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -25.22, 32.34)"/><rect class="cls-194" x="15.56" y="161.53" width="314.22" height="2.49" transform="translate(-25.64 32.46) rotate(-10)"/><rect class="cls-195" x="15.99" y="163.98" width="314.22" height="2.49" transform="translate(-26.06 32.57) rotate(-10)"/><rect class="cls-196" x="16.43" y="166.43" width="314.22" height="2.49" transform="translate(-26.48 32.68) rotate(-10)"/><rect class="cls-197" x="16.86" y="168.88" width="314.22" height="2.49" transform="translate(-26.9 32.79) rotate(-10)"/><rect class="cls-198" x="17.29" y="171.33" width="314.22" height="2.49" transform="translate(-27.32 32.91) rotate(-10)"/><rect class="cls-199" x="17.72" y="173.78" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -27.74, 33.02)"/><rect class="cls-200" x="18.15" y="176.23" width="314.22" height="2.49" transform="translate(-28.16 33.13) rotate(-10)"/><rect class="cls-201" x="18.59" y="178.68" width="314.22" height="2.49" transform="translate(-28.57 33.24) rotate(-10)"/><rect class="cls-202" x="19.02" y="181.13" width="314.22" height="2.49" transform="translate(-28.99 33.36) rotate(-10)"/><rect class="cls-203" x="19.45" y="183.58" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -29.41, 33.47)"/><rect class="cls-204" x="19.88" y="186.03" width="314.22" height="2.49" transform="translate(-29.83 33.58) rotate(-10)"/><rect class="cls-205" x="20.31" y="188.48" width="314.22" height="2.49" transform="translate(-30.25 33.69) rotate(-10)"/><rect class="cls-206" x="20.75" y="190.93" width="314.22" height="2.49" transform="translate(-30.67 33.8) rotate(-10)"/><rect class="cls-207" x="21.18" y="193.38" width="314.22" height="2.49" transform="translate(-31.09 33.92) rotate(-10)"/><rect class="cls-208" x="21.61" y="195.83" width="314.22" height="2.49" transform="translate(-31.51 34.03) rotate(-10)"/><rect class="cls-209" x="22.04" y="198.28" width="314.22" height="2.49" transform="translate(-31.93 34.14) rotate(-10)"/><rect class="cls-210" x="22.47" y="200.73" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -32.34, 34.25)"/><rect class="cls-210" x="22.91" y="203.18" width="314.22" height="2.49" transform="translate(-32.76 34.37) rotate(-10)"/><rect class="cls-211" x="23.34" y="205.64" width="314.22" height="2.49" transform="translate(-33.18 34.48) rotate(-10)"/><rect class="cls-212" x="23.77" y="208.09" width="314.22" height="2.49" transform="translate(-33.6 34.59) rotate(-10)"/><rect class="cls-213" x="24.2" y="210.54" width="314.22" height="2.49" transform="translate(-34.02 34.7) rotate(-10)"/><rect class="cls-214" x="24.63" y="212.99" width="314.22" height="2.49" transform="translate(-34.44 34.81) rotate(-10)"/><rect class="cls-215" x="25.07" y="215.44" width="314.22" height="2.49" transform="translate(-34.86 34.93) rotate(-10)"/><rect class="cls-216" x="25.5" y="217.89" width="314.22" height="2.49" transform="translate(-35.28 35.04) rotate(-10)"/><rect class="cls-217" x="25.93" y="220.34" width="314.22" height="2.49" transform="translate(-35.7 35.15) rotate(-10)"/><rect class="cls-218" x="26.36" y="222.79" width="314.22" height="2.49" transform="translate(-36.12 35.26) rotate(-10)"/><rect class="cls-219" x="26.79" y="225.24" width="314.22" height="2.49" transform="translate(-36.53 35.38) rotate(-10)"/><rect class="cls-220" x="27.23" y="227.69" width="314.22" height="2.49" transform="translate(-36.95 35.49) rotate(-10)"/><rect class="cls-221" x="27.66" y="230.14" width="314.22" height="2.49" transform="translate(-37.37 35.6) rotate(-10)"/><rect class="cls-222" x="28.09" y="232.59" width="314.22" height="2.49" transform="translate(-37.79 35.71) rotate(-10)"/><rect class="cls-223" x="28.52" y="235.04" width="314.22" height="2.49" transform="translate(-38.21 35.82) rotate(-10)"/><rect class="cls-224" x="28.95" y="237.49" width="314.22" height="2.49" transform="translate(-38.63 35.94) rotate(-10)"/><rect class="cls-225" x="29.39" y="239.94" width="314.22" height="2.49" transform="translate(-39.05 36.05) rotate(-10)"/><rect class="cls-226" x="29.82" y="242.39" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -39.47, 36.16)"/><rect class="cls-227" x="30.25" y="244.84" width="314.22" height="2.49" transform="translate(-39.89 36.27) rotate(-10)"/><rect class="cls-228" x="30.68" y="247.29" width="314.22" height="2.49" transform="translate(-40.3 36.39) rotate(-10)"/><rect class="cls-229" x="31.11" y="249.74" width="314.22" height="2.49" transform="translate(-40.72 36.5) rotate(-10)"/><rect class="cls-230" x="31.55" y="252.19" width="314.22" height="2.49" transform="translate(-41.14 36.61) rotate(-10)"/><rect class="cls-231" x="31.98" y="254.64" width="314.22" height="2.49" transform="translate(-41.56 36.72) rotate(-10)"/><rect class="cls-232" x="32.41" y="257.09" width="314.22" height="2.49" transform="translate(-41.98 36.83) rotate(-10)"/><rect class="cls-233" x="32.84" y="259.54" width="314.22" height="2.49" transform="translate(-42.4 36.95) rotate(-10)"/><rect class="cls-234" x="33.28" y="261.99" width="314.22" height="2.49" transform="translate(-42.82 37.06) rotate(-10)"/><rect class="cls-235" x="33.71" y="264.44" width="314.22" height="2.49" transform="translate(-43.24 37.17) rotate(-10)"/><rect class="cls-236" x="34.14" y="266.89" width="314.22" height="2.49" transform="translate(-43.66 37.28) rotate(-10)"/><rect class="cls-237" x="34.57" y="269.34" width="314.22" height="2.49" transform="translate(-44.07 37.4) rotate(-10)"/><rect class="cls-238" x="35" y="271.79" width="314.22" height="2.49" transform="translate(-44.49 37.51) rotate(-10)"/><rect class="cls-239" x="35.44" y="274.24" width="314.22" height="2.49" transform="translate(-44.91 37.62) rotate(-10)"/><rect class="cls-240" x="35.87" y="276.69" width="314.22" height="2.49" transform="translate(-45.33 37.73) rotate(-10)"/><rect class="cls-241" x="36.3" y="279.14" width="314.22" height="2.49" transform="translate(-45.75 37.85) rotate(-10)"/><rect class="cls-242" x="36.73" y="281.59" width="314.22" height="2.49" transform="translate(-46.17 37.96) rotate(-10)"/><rect class="cls-243" x="37.16" y="284.04" width="314.22" height="2.49" transform="translate(-46.59 38.07) rotate(-10)"/><rect class="cls-244" x="37.6" y="286.49" width="314.22" height="2.49" transform="translate(-47.01 38.18) rotate(-10)"/><rect class="cls-245" x="38.03" y="288.94" width="314.22" height="2.49" transform="translate(-47.43 38.29) rotate(-10)"/><rect class="cls-246" x="38.46" y="291.39" width="314.22" height="2.49" transform="translate(-47.85 38.41) rotate(-10)"/><rect class="cls-247" x="38.89" y="293.84" width="314.22" height="2.49" transform="translate(-48.26 38.52) rotate(-10)"/><rect class="cls-248" x="39.32" y="296.3" width="314.22" height="2.49" transform="matrix(0.98, -0.17, 0.17, 0.98, -48.68, 38.63)"/><rect class="cls-249" x="39.76" y="298.75" width="314.22" height="2.49" transform="translate(-49.1 38.74) rotate(-10)"/><rect class="cls-250" x="40.19" y="301.2" width="314.22" height="2.49" transform="translate(-49.52 38.86) rotate(-10)"/><polygon class="cls-250" points="352.24 276.38 353.4 282.95 353.4 351.89 46.48 351.89 42.79 330.95 352.24 276.38"/></g><g class="cls-251"><polygon class="cls-3" points="55.12 198.52 224.31 367.72 191 401.04 55.12 401.04 55.12 198.52"/><polygon class="cls-3" points="55.12 192.3 227.43 364.61 224.31 367.72 55.12 198.52 55.12 192.3"/><polygon class="cls-252" points="55.12 186.07 230.54 361.5 227.43 364.61 55.12 192.3 55.12 186.07"/><polygon class="cls-253" points="55.12 179.85 233.65 358.38 230.54 361.5 55.12 186.07 55.12 179.85"/><polygon class="cls-254" points="55.12 173.62 236.76 355.27 233.65 358.38 55.12 179.85 55.12 173.62"/><polygon class="cls-255" points="55.12 167.4 239.88 352.16 236.76 355.27 55.12 173.62 55.12 167.4"/><polygon class="cls-256" points="55.12 161.18 242.99 349.05 239.88 352.16 55.12 167.4 55.12 161.18"/><polygon class="cls-257" points="55.12 154.95 246.1 345.94 242.99 349.05 55.12 161.18 55.12 154.95"/><polygon class="cls-258" points="55.12 148.73 249.21 342.82 246.1 345.94 55.12 154.95 55.12 148.73"/><polygon class="cls-259" points="55.12 142.5 252.32 339.71 249.21 342.82 55.12 148.73 55.12 142.5"/><polygon class="cls-260" points="55.12 136.28 255.44 336.6 252.32 339.71 55.12 142.5 55.12 136.28"/><polygon class="cls-261" points="55.12 130.06 258.55 333.49 255.44 336.6 55.12 136.28 55.12 130.06"/><polygon class="cls-262" points="55.12 127.53 56.97 125.68 261.66 330.37 258.55 333.49 55.12 130.06 55.12 127.53"/><rect class="cls-263" x="158.67" y="81.73" width="4.4" height="289.48" transform="translate(-113.02 180.08) rotate(-45)"/><rect class="cls-264" x="161.78" y="78.62" width="4.4" height="289.48" transform="translate(-109.91 181.37) rotate(-45)"/><rect class="cls-265" x="164.89" y="75.51" width="4.4" height="289.48" transform="translate(-106.8 182.66) rotate(-45)"/><rect class="cls-266" x="168.01" y="72.39" width="4.4" height="289.48" transform="translate(-103.69 183.95) rotate(-45)"/><rect class="cls-267" x="171.12" y="69.28" width="4.4" height="289.48" transform="translate(-100.57 185.24) rotate(-45)"/><rect class="cls-268" x="174.23" y="66.17" width="4.4" height="289.48" transform="translate(-97.46 186.53) rotate(-45)"/><rect class="cls-269" x="177.34" y="63.06" width="4.4" height="289.48" transform="translate(-94.35 187.82) rotate(-45)"/><rect class="cls-270" x="180.45" y="59.95" width="4.4" height="289.48" transform="translate(-91.24 189.11) rotate(-45)"/><rect class="cls-271" x="183.57" y="56.83" width="4.4" height="289.48" transform="translate(-88.12 190.4) rotate(-45)"/><rect class="cls-272" x="186.68" y="53.72" width="4.4" height="289.48" transform="translate(-85.01 191.69) rotate(-45)"/><rect class="cls-273" x="189.79" y="50.61" width="4.4" height="289.48" transform="translate(-81.9 192.97) rotate(-45)"/><rect class="cls-274" x="192.9" y="47.5" width="4.4" height="289.48" transform="translate(-78.79 194.26) rotate(-45)"/><rect class="cls-275" x="196.01" y="44.39" width="4.4" height="289.48" transform="translate(-75.68 195.55) rotate(-45)"/><rect class="cls-276" x="199.13" y="41.27" width="4.4" height="289.48" transform="translate(-72.56 196.84) rotate(-45)"/><rect class="cls-277" x="202.24" y="38.16" width="4.4" height="289.48" transform="translate(-69.45 198.13) rotate(-45)"/><rect class="cls-278" x="205.35" y="35.05" width="4.4" height="289.48" transform="translate(-66.34 199.42) rotate(-45)"/><rect class="cls-279" x="208.46" y="31.94" width="4.4" height="289.48" transform="translate(-63.23 200.71) rotate(-45)"/><polygon class="cls-280" points="109.87 72.78 112.98 69.66 316.42 273.09 316.42 275.62 314.57 277.47 109.87 72.78"/><polygon class="cls-281" points="112.98 69.66 116.1 66.55 316.42 266.87 316.42 273.09 112.98 69.66"/><polygon class="cls-282" points="116.1 66.55 119.21 63.44 316.42 260.65 316.42 266.87 116.1 66.55"/><polygon class="cls-283" points="119.21 63.44 122.32 60.33 316.42 254.42 316.42 260.65 119.21 63.44"/><polygon class="cls-284" points="122.32 60.33 125.43 57.21 316.42 248.2 316.42 254.42 122.32 60.33"/><polygon class="cls-285" points="125.43 57.21 128.54 54.1 316.42 241.97 316.42 248.2 125.43 57.21"/><polygon class="cls-286" points="128.54 54.1 131.66 50.99 316.42 235.75 316.42 241.97 128.54 54.1"/><polygon class="cls-287" points="131.66 50.99 134.77 47.88 316.42 229.53 316.42 235.75 131.66 50.99"/><polygon class="cls-288" points="134.77 47.88 137.88 44.77 316.42 223.3 316.42 229.53 134.77 47.88"/><polygon class="cls-289" points="137.88 44.77 140.99 41.65 316.42 217.08 316.42 223.3 137.88 44.77"/><polygon class="cls-290" points="140.99 41.65 144.11 38.54 316.42 210.85 316.42 217.08 140.99 41.65"/><polygon class="cls-291" points="144.11 38.54 147.22 35.43 316.42 204.63 316.42 210.85 144.11 38.54"/><polygon class="cls-291" points="147.22 35.43 180.54 2.11 316.42 2.11 316.42 204.63 147.22 35.43"/></g><g class="cls-292"><polygon class="cls-3" points="101.7 108.94 2.18 304.26 0 303.15 0 108.94 101.7 108.94"/><polygon class="cls-3" points="103.39 108.94 3.52 304.95 2.18 304.26 101.7 108.94 103.39 108.94"/><polygon class="cls-4" points="105.09 108.94 4.87 305.63 3.52 304.95 103.39 108.94 105.09 108.94"/><polygon class="cls-5" points="106.79 108.94 6.22 306.32 4.87 305.63 105.09 108.94 106.79 108.94"/><polygon class="cls-6" points="108.49 108.94 7.69 306.76 7.09 306.76 6.22 306.32 106.79 108.94 108.49 108.94"/><polygon class="cls-293" points="110.18 108.94 9.39 306.76 7.69 306.76 108.49 108.94 110.18 108.94"/><polygon class="cls-8" points="111.88 108.94 11.09 306.76 9.39 306.76 110.18 108.94 111.88 108.94"/><polygon class="cls-9" points="113.58 108.94 12.78 306.76 11.09 306.76 111.88 108.94 113.58 108.94"/><polygon class="cls-10" points="115.28 108.94 14.48 306.76 12.78 306.76 113.58 108.94 115.28 108.94"/><polygon class="cls-11" points="116.97 108.94 16.18 306.76 14.48 306.76 115.28 108.94 116.97 108.94"/><polygon class="cls-12" points="118.67 108.94 17.88 306.76 16.18 306.76 116.97 108.94 118.67 108.94"/><polygon class="cls-13" points="120.37 108.94 19.57 306.76 17.88 306.76 118.67 108.94 120.37 108.94"/><polygon class="cls-294" points="122.06 108.94 21.27 306.76 19.57 306.76 120.37 108.94 122.06 108.94"/><polygon class="cls-295" points="123.76 108.94 22.97 306.76 21.27 306.76 122.06 108.94 123.76 108.94"/><polygon class="cls-16" points="125.46 108.94 24.67 306.76 22.97 306.76 123.76 108.94 125.46 108.94"/><polygon class="cls-17" points="127.16 108.94 26.36 306.76 24.67 306.76 125.46 108.94 127.16 108.94"/><polygon class="cls-18" points="128.85 108.94 28.06 306.76 26.36 306.76 127.16 108.94 128.85 108.94"/><polygon class="cls-19" points="130.55 108.94 29.76 306.76 28.06 306.76 128.85 108.94 130.55 108.94"/><polygon class="cls-20" points="132.25 108.94 31.46 306.76 29.76 306.76 130.55 108.94 132.25 108.94"/><polygon class="cls-296" points="133.95 108.94 33.15 306.76 31.46 306.76 132.25 108.94 133.95 108.94"/><polygon class="cls-22" points="135.65 108.94 34.85 306.76 33.15 306.76 133.95 108.94 135.65 108.94"/><polygon class="cls-297" points="137.34 108.94 36.55 306.76 34.85 306.76 135.65 108.94 137.34 108.94"/><polygon class="cls-24" points="139.04 108.94 38.24 306.76 36.55 306.76 137.34 108.94 139.04 108.94"/><polygon class="cls-25" points="140.74 108.94 39.94 306.76 38.24 306.76 139.04 108.94 140.74 108.94"/><polygon class="cls-298" points="142.43 108.94 41.64 306.76 39.94 306.76 140.74 108.94 142.43 108.94"/><polygon class="cls-27" points="144.13 108.94 43.34 306.76 41.64 306.76 142.43 108.94 144.13 108.94"/><polygon class="cls-28" points="145.83 108.94 45.03 306.76 43.34 306.76 144.13 108.94 145.83 108.94"/><polygon class="cls-299" points="147.53 108.94 46.73 306.76 45.03 306.76 145.83 108.94 147.53 108.94"/><polygon class="cls-30" points="149.22 108.94 48.43 306.76 46.73 306.76 147.53 108.94 149.22 108.94"/><polygon class="cls-300" points="150.92 108.94 50.13 306.76 48.43 306.76 149.22 108.94 150.92 108.94"/><polygon class="cls-32" points="152.62 108.94 51.83 306.76 50.13 306.76 150.92 108.94 152.62 108.94"/><polygon class="cls-33" points="154.32 108.94 53.52 306.76 51.83 306.76 152.62 108.94 154.32 108.94"/><polygon class="cls-301" points="156.01 108.94 55.22 306.76 53.52 306.76 154.32 108.94 156.01 108.94"/><polygon class="cls-35" points="157.71 108.94 56.92 306.76 55.22 306.76 156.01 108.94 157.71 108.94"/><polygon class="cls-302" points="159.41 108.94 58.61 306.76 56.92 306.76 157.71 108.94 159.41 108.94"/><polygon class="cls-303" points="161.11 108.94 60.31 306.76 58.61 306.76 159.41 108.94 161.11 108.94"/><polygon class="cls-38" points="162.8 108.94 62.01 306.76 60.31 306.76 161.11 108.94 162.8 108.94"/><polygon class="cls-304" points="164.5 108.94 63.71 306.76 62.01 306.76 162.8 108.94 164.5 108.94"/><polygon class="cls-40" points="166.2 108.94 65.4 306.76 63.71 306.76 164.5 108.94 166.2 108.94"/><polygon class="cls-41" points="167.9 108.94 67.1 306.76 65.4 306.76 166.2 108.94 167.9 108.94"/><polygon class="cls-305" points="169.59 108.94 68.8 306.76 67.1 306.76 167.9 108.94 169.59 108.94"/><polygon class="cls-306" points="171.29 108.94 70.5 306.76 68.8 306.76 169.59 108.94 171.29 108.94"/><polygon class="cls-45" points="172.99 108.94 72.19 306.76 70.5 306.76 171.29 108.94 172.99 108.94"/><polygon class="cls-46" points="174.69 108.94 73.89 306.76 72.19 306.76 172.99 108.94 174.69 108.94"/><polygon class="cls-47" points="176.38 108.94 75.59 306.76 73.89 306.76 174.69 108.94 176.38 108.94"/><polygon class="cls-48" points="178.08 108.94 77.29 306.76 75.59 306.76 176.38 108.94 178.08 108.94"/><polygon class="cls-307" points="179.78 108.94 78.98 306.76 77.29 306.76 178.08 108.94 179.78 108.94"/><polygon class="cls-50" points="181.47 108.94 80.68 306.76 78.98 306.76 179.78 108.94 181.47 108.94"/><polygon class="cls-308" points="183.17 108.94 82.38 306.76 80.68 306.76 181.47 108.94 183.17 108.94"/><polygon class="cls-309" points="184.87 108.94 84.08 306.76 82.38 306.76 183.17 108.94 184.87 108.94"/><polygon class="cls-53" points="186.57 108.94 85.77 306.76 84.08 306.76 184.87 108.94 186.57 108.94"/><polygon class="cls-54" points="188.26 108.94 87.47 306.76 85.77 306.76 186.57 108.94 188.26 108.94"/><polygon class="cls-55" points="189.96 108.94 89.17 306.76 87.47 306.76 188.26 108.94 189.96 108.94"/><polygon class="cls-56" points="191.66 108.94 90.86 306.76 89.17 306.76 189.96 108.94 191.66 108.94"/><polygon class="cls-57" points="193.36 108.94 92.56 306.76 90.86 306.76 191.66 108.94 193.36 108.94"/><polygon class="cls-310" points="195.05 108.94 94.26 306.76 92.56 306.76 193.36 108.94 195.05 108.94"/><polygon class="cls-311" points="196.75 108.94 95.96 306.76 94.26 306.76 195.05 108.94 196.75 108.94"/><polygon class="cls-60" points="198.45 108.94 97.66 306.76 95.96 306.76 196.75 108.94 198.45 108.94"/><polygon class="cls-61" points="200.15 108.94 99.35 306.76 97.66 306.76 198.45 108.94 200.15 108.94"/><polygon class="cls-62" points="201.84 108.94 101.05 306.76 99.35 306.76 200.15 108.94 201.84 108.94"/><polygon class="cls-63" points="203.54 108.94 102.75 306.76 101.05 306.76 201.84 108.94 203.54 108.94"/><polygon class="cls-64" points="205.24 108.94 104.44 306.76 102.75 306.76 203.54 108.94 205.24 108.94"/><polygon class="cls-312" points="206.94 108.94 106.14 306.76 104.44 306.76 205.24 108.94 206.94 108.94"/><polygon class="cls-313" points="208.63 108.94 107.84 306.76 106.14 306.76 206.94 108.94 208.63 108.94"/><polygon class="cls-314" points="210.33 108.94 109.54 306.76 107.84 306.76 208.63 108.94 210.33 108.94"/><polygon class="cls-315" points="212.03 108.94 111.23 306.76 109.54 306.76 210.33 108.94 212.03 108.94"/><polygon class="cls-69" points="213.73 108.94 112.93 306.76 111.23 306.76 212.03 108.94 213.73 108.94"/><polygon class="cls-70" points="215.42 108.94 114.63 306.76 112.93 306.76 213.73 108.94 215.42 108.94"/><polygon class="cls-71" points="217.12 108.94 116.33 306.76 114.63 306.76 215.42 108.94 217.12 108.94"/><polygon class="cls-72" points="218.82 108.94 118.02 306.76 116.33 306.76 217.12 108.94 218.82 108.94"/><polygon class="cls-316" points="220.52 108.94 119.72 306.76 118.02 306.76 218.82 108.94 220.52 108.94"/><polygon class="cls-317" points="222.21 108.94 121.42 306.76 119.72 306.76 220.52 108.94 222.21 108.94"/><polygon class="cls-75" points="223.91 108.94 123.12 306.76 121.42 306.76 222.21 108.94 223.91 108.94"/><polygon class="cls-318" points="225.61 108.94 124.81 306.76 123.12 306.76 223.91 108.94 225.61 108.94"/><polygon class="cls-77" points="227.31 108.94 126.51 306.76 124.81 306.76 225.61 108.94 227.31 108.94"/><polygon class="cls-78" points="227.87 111.16 128.21 306.76 126.51 306.76 227.31 108.94 227.87 108.94 227.87 111.16"/><polygon class="cls-79" points="227.87 114.49 129.91 306.76 128.21 306.76 227.87 111.16 227.87 114.49"/><polygon class="cls-319" points="227.87 117.83 131.6 306.76 129.91 306.76 227.87 114.49 227.87 117.83"/><polygon class="cls-320" points="227.87 121.16 133.3 306.76 131.6 306.76 227.87 117.83 227.87 121.16"/><polygon class="cls-321" points="227.87 124.49 135 306.76 133.3 306.76 227.87 121.16 227.87 124.49"/><polygon class="cls-83" points="227.87 127.82 136.7 306.76 135 306.76 227.87 124.49 227.87 127.82"/><polygon class="cls-83" points="136.7 306.76 227.87 127.82 227.87 306.76 136.7 306.76"/></g><g class="cls-322"><polygon class="cls-291" points="124.93 164.87 246.64 286.58 124.93 286.58 124.93 164.87"/><polygon class="cls-291" points="124.93 160.51 250.1 285.69 249.21 286.58 246.64 286.58 124.93 164.87 124.93 160.51"/><polygon class="cls-323" points="124.93 156.15 252.28 283.51 250.1 285.69 124.93 160.51 124.93 156.15"/><polygon class="cls-324" points="124.93 151.78 254.47 281.32 252.28 283.51 124.93 156.15 124.93 151.78"/><polygon class="cls-325" points="124.93 147.42 256.65 279.14 254.47 281.32 124.93 151.78 124.93 147.42"/><polygon class="cls-326" points="124.93 143.06 258.83 276.96 256.65 279.14 124.93 147.42 124.93 143.06"/><polygon class="cls-327" points="124.93 138.69 261.01 274.78 258.83 276.96 124.93 143.06 124.93 138.69"/><polygon class="cls-328" points="124.93 134.33 263.19 272.6 261.01 274.78 124.93 138.69 124.93 134.33"/><polygon class="cls-329" points="124.93 129.97 265.38 270.42 263.19 272.6 124.93 134.33 124.93 129.97"/><polygon class="cls-330" points="124.93 125.61 267.56 268.24 265.38 270.42 124.93 129.97 124.93 125.61"/><polygon class="cls-331" points="124.93 121.24 269.74 266.05 267.56 268.24 124.93 125.61 124.93 121.24"/><polygon class="cls-332" points="124.93 116.88 271.92 263.87 269.74 266.05 124.93 121.24 124.93 116.88"/><polygon class="cls-333" points="124.93 112.52 274.1 261.69 271.92 263.87 124.93 116.88 124.93 112.52"/><polygon class="cls-334" points="124.93 108.15 276.28 259.51 274.1 261.69 124.93 112.52 124.93 108.15"/><polygon class="cls-335" points="124.93 103.79 278.46 257.33 276.28 259.51 124.93 108.15 124.93 103.79"/><polygon class="cls-336" points="124.93 99.43 280.65 255.15 278.46 257.33 124.93 103.79 124.93 99.43"/><polygon class="cls-337" points="124.93 95.06 282.83 252.96 280.65 255.15 124.93 99.43 124.93 95.06"/><polygon class="cls-338" points="124.93 90.7 285.01 250.78 282.83 252.96 124.93 95.06 124.93 90.7"/><polygon class="cls-339" points="124.93 86.34 287.19 248.6 285.01 250.78 124.93 90.7 124.93 86.34"/><polygon class="cls-340" points="124.93 81.97 289.37 246.42 287.19 248.6 124.93 86.34 124.93 81.97"/><polygon class="cls-341" points="124.93 77.61 291.55 244.24 289.37 246.42 124.93 81.97 124.93 77.61"/><polygon class="cls-342" points="124.93 73.25 293.74 242.06 291.55 244.24 124.93 77.61 124.93 73.25"/><polygon class="cls-343" points="124.93 68.88 295.92 239.87 293.74 242.06 124.93 73.25 124.93 68.88"/><polygon class="cls-344" points="124.93 64.52 298.1 237.69 295.92 239.87 124.93 68.88 124.93 64.52"/><polygon class="cls-345" points="124.93 60.16 300.28 235.51 298.1 237.69 124.93 64.52 124.93 60.16"/><polygon class="cls-346" points="124.93 56.68 125.37 56.23 302.46 233.33 300.28 235.51 124.93 60.16 124.93 56.68"/><rect class="cls-347" x="213.46" y="18.47" width="3.09" height="250.45" transform="translate(-38.63 194.12) rotate(-45)"/><rect class="cls-348" x="215.64" y="16.29" width="3.09" height="250.45" transform="translate(-36.45 195.02) rotate(-45)"/><rect class="cls-349" x="217.83" y="14.1" width="3.09" height="250.45" transform="translate(-34.27 195.93) rotate(-45)"/><rect class="cls-350" x="220.01" y="11.92" width="3.09" height="250.45" transform="translate(-32.09 196.83) rotate(-45)"/><rect class="cls-351" x="222.19" y="9.74" width="3.09" height="250.45" transform="translate(-29.91 197.73) rotate(-45)"/><rect class="cls-352" x="224.37" y="7.56" width="3.09" height="250.45" transform="translate(-27.72 198.64) rotate(-45)"/><polygon class="cls-353" points="138.46 43.15 140.64 40.96 317.48 217.81 317.48 218.31 315.55 220.24 138.46 43.15"/><polygon class="cls-354" points="140.64 40.96 142.82 38.78 317.48 213.44 317.48 217.81 140.64 40.96"/><polygon class="cls-355" points="142.82 38.78 145 36.6 317.48 209.08 317.48 213.44 142.82 38.78"/><polygon class="cls-356" points="145 36.6 147.18 34.42 317.48 204.72 317.48 209.08 145 36.6"/><polygon class="cls-357" points="147.18 34.42 149.37 32.24 317.48 200.35 317.48 204.72 147.18 34.42"/><polygon class="cls-358" points="149.37 32.24 151.55 30.06 317.48 195.99 317.48 200.35 149.37 32.24"/><polygon class="cls-359" points="151.55 30.06 153.73 27.88 317.48 191.63 317.48 195.99 151.55 30.06"/><polygon class="cls-360" points="153.73 27.88 155.91 25.69 317.48 187.26 317.48 191.63 153.73 27.88"/><polygon class="cls-361" points="155.91 25.69 158.09 23.51 317.48 182.9 317.48 187.26 155.91 25.69"/><polygon class="cls-362" points="158.09 23.51 160.27 21.33 317.48 178.54 317.48 182.9 158.09 23.51"/><polygon class="cls-363" points="160.27 21.33 162.45 19.15 317.48 174.18 317.48 178.54 160.27 21.33"/><polygon class="cls-364" points="162.45 19.15 164.64 16.97 317.48 169.81 317.48 174.18 162.45 19.15"/><polygon class="cls-250" points="164.64 16.97 166.82 14.79 317.48 165.45 317.48 169.81 164.64 16.97"/><polygon class="cls-250" points="166.82 14.79 181.6 0 317.48 0 317.48 165.45 166.82 14.79"/></g><g class="cls-365"><polygon class="cls-210" points="161.05 199.85 76.74 214.72 76.74 199.85 161.05 199.85"/><polygon class="cls-210" points="179.32 199.85 76.74 217.94 76.74 214.72 161.05 199.85 179.32 199.85"/><polygon class="cls-211" points="197.58 199.85 76.74 221.16 76.74 217.94 179.32 199.85 197.58 199.85"/><polygon class="cls-212" points="215.85 199.85 76.74 224.38 76.74 221.16 197.58 199.85 215.85 199.85"/><polygon class="cls-213" points="234.12 199.85 77.16 227.53 76.74 225.19 76.74 224.38 215.85 199.85 234.12 199.85"/><polygon class="cls-214" points="252.38 199.85 77.71 230.65 77.16 227.53 234.12 199.85 252.38 199.85"/><polygon class="cls-366" points="270.65 199.85 78.26 233.78 77.71 230.65 252.38 199.85 270.65 199.85"/><polygon class="cls-216" points="288.91 199.85 78.81 236.9 78.26 233.78 270.65 199.85 288.91 199.85"/><polygon class="cls-217" points="307.18 199.85 79.36 240.02 78.81 236.9 288.91 199.85 307.18 199.85"/><polygon class="cls-218" points="325.44 199.85 79.91 243.15 79.36 240.02 307.18 199.85 325.44 199.85"/><polygon class="cls-219" points="338.74 199.85 338.89 200.7 80.46 246.27 79.91 243.15 325.44 199.85 338.74 199.85"/><rect class="cls-220" x="78.74" y="223.46" width="262.42" height="3.17" transform="translate(-35.89 39.88) rotate(-10)"/><rect class="cls-221" x="79.29" y="226.59" width="262.42" height="3.17" transform="translate(-36.42 40.02) rotate(-10)"/><rect class="cls-222" x="79.84" y="229.71" width="262.42" height="3.17" transform="translate(-36.96 40.16) rotate(-10)"/><rect class="cls-223" x="80.39" y="232.83" width="262.42" height="3.17" transform="translate(-37.49 40.31) rotate(-10)"/><rect class="cls-224" x="80.95" y="235.96" width="262.42" height="3.17" transform="translate(-38.03 40.45) rotate(-10)"/><rect class="cls-367" x="81.5" y="239.08" width="262.42" height="3.17" transform="translate(-38.56 40.59) rotate(-10)"/><rect class="cls-226" x="82.05" y="242.2" width="262.42" height="3.17" transform="translate(-39.09 40.74) rotate(-10)"/><rect class="cls-227" x="82.6" y="245.33" width="262.42" height="3.17" transform="translate(-39.63 40.88) rotate(-10)"/><rect class="cls-228" x="83.15" y="248.45" width="262.42" height="3.17" transform="translate(-40.16 41.02) rotate(-10)"/><rect class="cls-229" x="83.7" y="251.58" width="262.42" height="3.17" transform="translate(-40.7 41.16) rotate(-10)"/><rect class="cls-368" x="84.25" y="254.7" width="262.42" height="3.17" transform="translate(-41.23 41.31) rotate(-10)"/><rect class="cls-231" x="84.8" y="257.82" width="262.42" height="3.17" transform="matrix(0.98, -0.17, 0.17, 0.98, -41.76, 41.45)"/><rect class="cls-232" x="85.35" y="260.95" width="262.42" height="3.17" transform="translate(-42.3 41.59) rotate(-10)"/><rect class="cls-233" x="85.9" y="264.07" width="262.42" height="3.17" transform="translate(-42.83 41.74) rotate(-10)"/><rect class="cls-234" x="86.45" y="267.19" width="262.42" height="3.17" transform="translate(-43.37 41.88) rotate(-10)"/><rect class="cls-369" x="87" y="270.32" width="262.42" height="3.17" transform="matrix(0.98, -0.17, 0.17, 0.98, -43.9, 42.02)"/><rect class="cls-236" x="87.56" y="273.44" width="262.42" height="3.17" transform="translate(-44.43 42.17) rotate(-10)"/><rect class="cls-237" x="88.11" y="276.56" width="262.42" height="3.17" transform="translate(-44.97 42.31) rotate(-10)"/><rect class="cls-238" x="88.66" y="279.69" width="262.42" height="3.17" transform="translate(-45.5 42.45) rotate(-10)"/><rect class="cls-239" x="89.21" y="282.81" width="262.42" height="3.17" transform="translate(-46.04 42.6) rotate(-10)"/><rect class="cls-240" x="89.76" y="285.94" width="262.42" height="3.17" transform="translate(-46.57 42.74) rotate(-10)"/><rect class="cls-241" x="90.31" y="289.06" width="262.42" height="3.17" transform="translate(-47.1 42.88) rotate(-10)"/><rect class="cls-242" x="90.86" y="292.18" width="262.42" height="3.17" transform="translate(-47.64 43.03) rotate(-10)"/><rect class="cls-243" x="91.41" y="295.31" width="262.42" height="3.17" transform="translate(-48.17 43.17) rotate(-10)"/><rect class="cls-244" x="91.96" y="298.43" width="262.42" height="3.17" transform="translate(-48.71 43.31) rotate(-10)"/><rect class="cls-370" x="92.51" y="301.55" width="262.42" height="3.17" transform="translate(-49.24 43.45) rotate(-10)"/><polygon class="cls-246" points="353.21 281.92 353.4 282.95 353.4 285.11 95.33 330.61 94.78 327.49 353.21 281.92"/><polygon class="cls-247" points="353.4 288.33 95.88 333.73 95.33 330.61 353.4 285.11 353.4 288.33"/><polygon class="cls-248" points="353.4 291.55 96.43 336.86 95.88 333.73 353.4 288.33 353.4 291.55"/><polygon class="cls-249" points="353.4 294.77 96.98 339.98 96.43 336.86 353.4 291.55 353.4 294.77"/><polygon class="cls-250" points="353.4 297.99 97.53 343.1 96.98 339.98 353.4 294.77 353.4 297.99"/><polygon class="cls-250" points="99.08 351.89 97.53 343.1 353.4 297.99 353.4 351.89 99.08 351.89"/></g></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/manticoresearch.png b/docs/public/icons/database/manticoresearch.png
new file mode 100644
index 0000000..420cb72
Binary files /dev/null and b/docs/public/icons/database/manticoresearch.png differ
diff --git a/docs/public/icons/database/mariadb.svg b/docs/public/icons/database/mariadb.svg
new file mode 100644
index 0000000..3153880
--- /dev/null
+++ b/docs/public/icons/database/mariadb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#157997" d="M946.761 240.884a12.34 12.34 0 0 0-8.484-2.926c-8.485 0-19.456 5.852-25.357 9.021l-2.291 1.22a78.9 78.9 0 0 1-31.696 8.191c-11.215.341-20.919 1.024-33.548 2.39-74.8 7.85-108.154 66.608-140.288 123.367-17.554 30.964-35.596 63.05-60.367 87.576a164 164 0 0 1-16.335 14.141c-25.6 19.554-57.832 33.5-82.896 43.398-24.088 9.412-50.42 17.896-75.873 26.137-23.308 7.51-45.3 14.628-65.536 22.333-9.119 3.413-16.872 6.095-23.698 8.436-18.432 6.144-31.696 10.825-51.2 24.527a331 331 0 0 0-20.285 15.311c-15.41 12.63-29.062 27.307-40.521 43.788-9.9 15.116-21.31 29.16-34.085 41.838-4.096 4.145-11.362 6.144-22.235 6.144-12.776 0-28.234-2.682-44.618-5.559-16.871-3.072-34.328-5.949-49.25-5.949-12.19 0-21.454 2-28.427 6.095 0 0-11.703 7.022-16.628 16.092l4.876 2.194a100.5 100.5 0 0 1 20.675 15.311 101.2 101.2 0 0 0 21.553 15.702 19.3 19.3 0 0 1 6.631 4.34c-2.048 3.072-5.022 7.021-8.143 11.215-17.261 23.162-27.355 37.79-21.601 45.787 2.78 1.463 5.851 2.194 8.972 2.048 37.644 0 57.88-9.996 83.48-22.674 7.412-3.706 14.97-7.46 23.894-11.362 15.018-6.68 31.11-17.261 48.176-28.477 22.382-14.92 45.739-30.232 68.413-37.644a181.3 181.3 0 0 1 57.54-8.29c23.941 0 49.151 3.268 73.435 6.486 18.09 2.39 36.864 4.876 55.296 5.949 7.119.488 13.75.683 20.187.683 8.582 0 17.213-.488 25.747-1.414l2.096-.732c12.873-8.094 18.92-25.551 24.771-42.423 3.804-10.825 6.973-20.577 11.996-26.819a8 8 0 0 1 .975-.78 1.17 1.17 0 0 1 1.463.244v.487c-3.023 65.927-28.916 107.764-55.101 145.018l-17.554 19.213s24.527 0 38.473-5.51c50.858-15.604 89.234-49.884 117.223-104.644a452 452 0 0 0 18.432-43.203c.488-1.219 4.877-3.51 4.486 2.829-.195 1.901-.292 3.998-.438 6.144 0 1.316 0 2.633-.244 3.9-.732 9.265-2.828 28.673-2.828 28.673l15.701-8.631c37.888-24.528 67.096-73.972 89.234-150.967 9.216-32.086 15.994-63.878 21.943-91.965 7.12-33.743 13.263-62.61 20.285-73.874 11.02-17.555 27.892-29.453 44.178-41.01 2.243-1.56 4.486-3.071 6.68-4.73 20.48-14.774 40.863-31.743 45.35-63.487v-.732c3.266-23.649.487-29.696-2.634-32.426"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/milvus.png b/docs/public/icons/database/milvus.png
new file mode 100644
index 0000000..4d3214c
Binary files /dev/null and b/docs/public/icons/database/milvus.png differ
diff --git a/docs/public/icons/database/mongodb.svg b/docs/public/icons/database/mongodb.svg
new file mode 100644
index 0000000..ee47003
--- /dev/null
+++ b/docs/public/icons/database/mongodb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#10aa50" d="M707.072 419.789C658.944 204.544 558.797 147.2 533.197 106.7A463 463 0 0 1 505.344 51.2c-1.382 19.098-3.84 31.18-19.866 45.67-32.153 29.082-168.704 142.03-180.224 386.612-10.7 228.044 165.172 368.64 188.416 383.18 17.92 8.91 39.63.154 50.228-8.038C628.685 799.59 744.55 642.15 707.226 419.789"/><path fill="#b8c4c2" d="M528.486 716.8c-4.454 62.26-7.628 98.406-18.944 133.99 0 0 7.424 59.239 12.647 122.01h18.432a1260 1260 0 0 1 20.121-131.43c-23.859-13.056-31.334-69.94-32.256-124.57"/><path fill="#12924f" d="M546.304 870.4c-23.706-11.469-30.618-65.28-31.642-115.405 5.837-82.688 7.578-165.632 5.12-248.473-1.228-43.52.564-402.74-10.24-455.322 7.424 17.818 15.924 35.072 25.55 51.712 25.292 41.42 124.518 99.942 172.031 319.744C744.192 649.37 630.17 809.728 546.355 870.4z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/mysql.svg b/docs/public/icons/database/mysql.svg
new file mode 100644
index 0000000..0a3adb7
--- /dev/null
+++ b/docs/public/icons/database/mysql.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#0a5af6" d="M805.274 704c-38.196-1.024-67.84 2.918-92.672 13.62-7.168 2.918-18.586 2.918-19.559 12.185 3.84 3.84 4.301 10.189 7.68 15.565 5.683 9.728 15.719 22.835 24.781 29.696 10.035 7.73 20.07 15.513 30.618 22.323 18.585 11.725 39.628 18.483 57.753 30.208 10.547 6.758 20.992 15.513 31.54 22.835 5.222 3.891 8.55 10.24 15.257 12.646v-1.484c-3.38-4.352-4.3-10.701-7.629-15.565-4.761-4.864-9.574-9.216-14.336-14.08a229.6 229.6 0 0 0-49.664-49.152c-15.309-10.752-48.742-25.293-54.937-43.264l-.973-1.024c10.547-.922 22.989-4.864 32.973-7.783 16.23-4.403 31.027-3.379 47.77-7.782 7.68-1.946 15.257-4.403 22.937-6.758v-4.506c-8.653-8.704-14.848-20.429-23.86-28.672a641.5 641.5 0 0 0-78.847-59.853c-14.848-9.728-33.895-16.025-49.664-24.32-5.735-2.918-15.258-4.352-18.637-9.216-8.55-10.752-13.363-24.832-19.559-37.478a1217 1217 0 0 1-39.168-84.685c-8.601-18.944-13.824-37.888-24.32-55.45-49.254-82.688-102.707-132.761-184.832-181.913-17.715-10.24-38.707-14.643-61.132-19.968-11.93-.512-23.86-1.485-35.84-1.946-7.68-3.43-15.31-12.646-21.965-17.05-27.239-17.51-97.383-55.449-117.453-5.324-12.902 31.641 19.098 62.771 30.054 78.848 8.141 11.161 18.637 23.808 24.372 36.454 3.328 8.243 4.3 17.05 7.68 25.805 7.577 21.402 14.745 45.21 24.78 65.178 5.274 10.24 10.957 20.94 17.664 30.156 3.84 5.376 10.496 7.783 11.981 16.538-6.656 9.728-7.168 24.32-11.008 36.506-17.203 54.988-10.547 123.084 13.824 163.43 7.68 12.186 25.805 38.912 50.176 28.672 21.504-8.704 16.691-36.454 22.887-60.774 1.433-5.837.512-9.728 3.328-13.62v1.024c6.707 13.568 13.414 26.676 19.61 40.346 14.847 23.808 40.6 48.64 62.105 65.178 11.417 8.755 20.48 23.859 34.816 29.184v-1.434h-.922c-2.867-4.403-7.168-6.349-11.008-9.728a238.3 238.3 0 0 1-24.832-29.184 625 625 0 0 1-53.453-88.576c-7.68-15.104-14.336-31.642-20.53-46.694-2.868-5.837-2.868-14.592-7.68-17.51-7.169 10.7-17.665 19.967-22.887 33.023-9.063 20.992-10.035 46.746-13.415 73.523-1.894.512-.921 0-1.894.973-15.258-3.891-20.48-19.968-26.266-33.536-14.336-34.611-16.742-90.06-4.3-129.945 3.328-10.24 17.715-42.292 11.98-52.02-2.918-9.318-12.441-14.592-17.715-21.913a193.6 193.6 0 0 1-17.152-31.13c-11.469-27.238-17.254-57.446-29.593-84.685-5.735-12.646-15.821-25.804-23.91-37.427-9.063-13.158-19.098-22.374-26.266-37.939-2.356-5.376-5.735-14.131-1.895-19.968.922-3.891 2.867-5.376 6.656-6.349 6.195-5.325 23.91 1.485 30.106 4.403 17.664 7.27 32.46 14.132 47.257 24.32 6.656 4.864 13.824 14.08 22.426 16.538h10.086c15.258 3.38 32.461.973 46.797 5.376a303 303 0 0 1 68.762 33.536 428.85 428.85 0 0 1 148.992 166.4c5.734 11.162 8.14 21.402 13.363 33.075 10.035 23.86 22.477 48.18 32.46 71.527 10.036 22.886 19.61 46.182 33.946 65.177 7.168 10.24 35.84 15.565 48.692 20.941 9.574 4.352 24.37 8.243 32.972 13.62 16.23 10.188 32.461 21.862 47.77 33.074 7.578 5.837 31.488 18.023 32.922 27.75z"/><path fill="#0a5af6" d="M321.74 277.606a5.12 5.12 0 0 0-3.583-1.536 80.3 80.3 0 0 0-20.992 2.612 5.12 5.12 0 0 0-3.789 4.966v.973a5.12 5.12 0 0 0 2.662 4.505c2.048 3.482 4.506 6.503 6.81 9.216l1.946 2.15c2.048 2.305 3.89 4.404 5.478 6.708 1.843 3.686 3.584 7.424 5.325 11.213l.205.46 5.324 11.265a5.12 5.12 0 0 0 8.244 1.382 35 35 0 0 0 .716-.768c8.192-6.144 11.776-15.667 11.776-28.16a5.12 5.12 0 0 0-1.228-3.277 16 16 0 0 1-2.56-4.454 25.75 25.75 0 0 0-10.24-12.595l-1.741-1.23c-1.843-1.28-3.226-2.252-4.352-3.43"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/nacos.png b/docs/public/icons/database/nacos.png
new file mode 100644
index 0000000..0d7626a
Binary files /dev/null and b/docs/public/icons/database/nacos.png differ
diff --git a/docs/public/icons/database/neo4j.svg b/docs/public/icons/database/neo4j.svg
new file mode 100644
index 0000000..4f0e62f
--- /dev/null
+++ b/docs/public/icons/database/neo4j.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#edf4ff" d="M626.688 204.8h1.178c-135.117 0-225.946 77.824-225.946 230.963v93.338a125.7 125.7 0 0 1 44.032-10.24 86.07 86.07 0 0 1 44.288 10.24v-93.338c0-98.611 54.58-150.63 136.96-150.63s136.909 52.019 136.909 150.63V674.51h88.371V435.712c0-153.037-91.29-230.912-225.792-230.912"/><path fill="#018bff" d="M440.934 562.893a61.85 61.85 0 0 0-44.236 15.513L313.6 524.134a54.4 54.4 0 0 0 2.714-20.838 75.315 75.315 0 1 0-75.264 75.11c16.128.922 32-4.608 44.032-15.513l83.046 57.037c-2.048 6.758-2.867 13.772-2.509 20.787-.41 7.014.461 14.08 2.56 20.787l-83.097 57.293a70.14 70.14 0 0 0-44.032-15.77 75.315 75.315 0 1 0 75.264 75.315 54.3 54.3 0 0 0-2.714-20.787l83.098-57.037c12.492 10.138 28.16 15.616 44.236 15.514a75.11 75.11 0 0 0 75.11-75.315 77.363 77.363 0 0 0-75.11-77.824"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/oceanbase.svg b/docs/public/icons/database/oceanbase.svg
new file mode 100644
index 0000000..2ace405
--- /dev/null
+++ b/docs/public/icons/database/oceanbase.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#0181fd" d="M906.598 322.509v265.113a791.9 791.9 0 0 0-333.516 39.783 1051.55 1051.55 0 0 1-418.919 54.886V416.768c96.205 9.216 195.687.82 293.53-27.034 13.21-3.788 26.726-8.09 39.936-12.39a1055 1055 0 0 1 419.225-54.886h-.256z"/><path fill="#ffa005" d="M496.589 256a591 591 0 0 1-44.851 17.05c-7.066 2.406-14.08 4.608-21.35 7.014-5.684 1.638-11.367 3.533-17.306 5.12-86.784 24.064-174.592 30.566-259.482 21.094v88.628a770.3 770.3 0 0 0 303.77-31.079l22.732-7.27a762 762 0 0 0 43.52-16.487L496.332 256z"/><path fill="#07c846" d="M563.866 748.39a616 616 0 0 1 44.902-17.05c7.014-2.406 14.029-4.607 21.35-7.014 5.632-1.587 11.316-3.481 17.255-5.12a685.6 685.6 0 0 1 259.481-21.094v-88.627a770.3 770.3 0 0 0-286.72 25.958c-5.734 1.587-11.417 3.226-17.05 5.12l-22.732 7.27a762 762 0 0 0-43.52 16.487l27.34 84.07z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/opengauss.svg b/docs/public/icons/database/opengauss.svg
new file mode 100644
index 0000000..6f46971
--- /dev/null
+++ b/docs/public/icons/database/opengauss.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#1f80c4" d="M158.208 333.005a20.5 20.5 0 0 0-3.942 8.601h-.154v84.122a19.87 19.87 0 0 0 11.366 16.691l269.364 158.26a136.45 136.45 0 0 0 125.49 0l269.569-157.697a19.92 19.92 0 0 0 11.366-16.742l1.024-83.968-217.293-116.838-160.41 92.979a19.35 19.35 0 0 0-11.366 16.691v83.814c2.1 5.888 6.144 10.957 11.367 14.336 2.56-35.84 42.496-58.265 42.496-58.265l116.94-66.765 152.577 82.893-216.27 128.307a137.47 137.47 0 0 1-125.44 0l-226.508-133.58 226.406-133.53a126.4 126.4 0 0 1 62.823-15.207V153.6a126.8 126.8 0 0 0-62.823 15.155l-269.312 158.31a20.5 20.5 0 0 0-7.321 5.94zm679.117 236.851a19.87 19.87 0 0 0 3.43-9.882l-.358-83.302a19.87 19.87 0 0 1-11.367 16.691L560.026 651.571a136.45 136.45 0 0 1-125.543 0L164.966 492.75a19.87 19.87 0 0 1-11.366-16.743v83.456a19.87 19.87 0 0 0 11.366 16.692l269.517 158.412a137.42 137.42 0 0 0 125.543 0l269.312-157.9a19.87 19.87 0 0 0 7.987-6.81m3.43 119.654a19.87 19.87 0 0 1-11.366 16.692L560.026 863.949a136.45 136.45 0 0 1-125.543 0L164.966 705.74a19.87 19.87 0 0 1-11.366-16.794v-83.456a19.71 19.71 0 0 0 11.366 16.691l269.517 158.413a137.47 137.47 0 0 0 125.543 0l269.004-157.9a19.56 19.56 0 0 0 11.367-16.692l.358 83.456z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/oracle.svg b/docs/public/icons/database/oracle.svg
new file mode 100644
index 0000000..20e98a4
--- /dev/null
+++ b/docs/public/icons/database/oracle.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#c74634" d="M363.827 761.805A251.853 251.853 0 0 1 110.95 508.877 251.853 251.853 0 0 1 363.878 256h296.295A251.853 251.853 0 0 1 913.1 508.928a251.853 251.853 0 0 1-252.928 252.877zm288.717-89.395a162.97 162.97 0 0 0 163.482-163.533 162.97 162.97 0 0 0-163.533-163.482H371.507a162.97 162.97 0 0 0-163.481 163.533c0 89.446 74.086 163.533 163.481 163.533h281.037z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/polardb.webp b/docs/public/icons/database/polardb.webp
new file mode 100644
index 0000000..7363a49
Binary files /dev/null and b/docs/public/icons/database/polardb.webp differ
diff --git a/docs/public/icons/database/postgres.svg b/docs/public/icons/database/postgres.svg
new file mode 100644
index 0000000..a24c0a6
--- /dev/null
+++ b/docs/public/icons/database/postgres.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#326690" d="M637.03 195.02c46.746-10.137 96.82-8.857 141.824 8.244a188.6 188.6 0 0 1 79.719 59.085c9.881 12.595 11.161 29.44 11.776 44.902.512 36.813-6.861 73.216-16.23 108.544-17.92 65.536-45.057 128.359-79.156 186.829a170 170 0 0 1-11.11 16.589l-1.28-6.503c4.25-11.264 10.445-21.862 12.851-33.792 8.55-33.792 1.331-68.454-1.74-102.4-3.226-32.05 7.577-63.232 7.32-95.232 1.23-15.616-4.863-30.412-10.854-44.492-21.504-48.64-55.808-91.956-99.737-121.703-10.701-7.424-22.682-12.646-33.383-20.07"/><path fill="#326690" d="M507.29 199.475a220.16 220.16 0 0 1 163.532 44.954 261.9 261.9 0 0 1 83.61 116.94c-26.675-.972-56.986-2.047-78.592 16.692-19.558 16.691-22.118 45.21-17.715 69.12 10.24 56.985 43.469 105.318 67.993 156.518 6.503 12.032 15.258 22.528 23.552 33.28-9.932 5.069-20.992 9.882-26.624 20.173-9.83 16.077-6.348 35.686-8.806 53.555-5.632 50.023-11.264 100.096-19.302 149.76-3.79 23.808-13.824 49.152-36.096 60.98-22.733 11.775-49.255 19.097-74.906 15.103-24.32-4.3-39.629-27.238-46.592-49.612-5.018-18.74-5.53-38.298-6.963-57.55a1793 1793 0 0 1-1.331-139.775c1.024-18.227-8.192-37.171-24.27-46.08-7.782-4.352-16.895-4.967-25.6-5.632 6.862-34.304 27.495-63.847 34.56-98.048 9.217-42.291 4.097-86.323-5.273-128.103-4.608-20.838-20.275-39.27-41.165-44.339-32.153-8.192-64.512 4.557-93.286 18.074 3.584-47.207 16.128-95.54 44.698-133.888a132.56 132.56 0 0 1 88.576-52.122"/><path fill="#326690" d="M262.246 203.264c51.2-9.933 103.68.614 152.781 15.77a228.7 228.7 0 0 0-48.384 83.456 340.9 340.9 0 0 0-16.384 129.126c2.048 30.72.973 61.491-3.123 92.006a125.65 125.65 0 0 0 39.68 107.47c-19.866 23.5-40.96 45.926-60.211 69.99-8.55 10.137-19.968 22.17-34.509 19.148-16.947-4.966-27.75-20.582-37.171-34.662-25.549-41.267-40.96-87.86-55.04-134.144-15.77-54.784-29.082-110.438-36.762-167.014-3.789-43.008-1.433-89.19 20.378-127.488 16.333-29.082 46.745-47.565 78.745-53.607zm437.095 198.605c-6.298 5.222.512 12.953 5.837 15.462 13.107 7.731 30.976-3.072 31.436-18.227a37.53 37.53 0 0 0-37.273 2.765m-6.963-7.168c18.841-13.466 43.468-10.445 65.228-9.114-.921 30.413-10.24 60.263-7.168 90.931 2.714 37.888 13.568 78.592-4.096 114.535-23.705-47.667-54.374-93.184-65.024-146.279-3.072-16.896-3.788-38.297 11.06-50.022z"/><path fill="#326690" d="M439.45 402.79c-3.584 1.332-7.424 3.79-6.656 8.192 2.56 15.207 22.681 24.423 35.328 15.002 5.58-3.174 11.417-11.93 5.017-17.203-9.216-7.527-22.528-9.011-33.69-5.99m-66.356 11.623c23.604-15.463 51.2-27.495 79.821-25.856a34.82 34.82 0 0 1 32.051 25.958c13.005 52.327 16.999 110.49-7.884 160-8.55 19.149-15.872 38.861-21.812 58.983-41.37.41-76.544-34.919-83.916-74.752-5.018-22.528 1.536-45.159 2.304-67.738 1.74-25.498-.052-51.098-.512-76.595zm372.941 251.29c6.144-4.609 14.848-8.756 21.965-3.79 30.106 16.026 65.126 8.193 97.178 4.301-19.61 19.252-46.695 28.263-73.37 31.181-17.664 2.1-35.994 2.765-53.043-3.174.102-9.728-.41-21.3 7.27-28.519m-303.36 37.324c17.306-9.42 24.167-30.157 40.346-40.755 17.561-2.56 30.464 23.91 17.152 36.403-26.01 35.584-77.978 42.394-115.559 23.04 18.535-8.704 40.192-8.038 58.061-18.688"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/presto.svg b/docs/public/icons/database/presto.svg
new file mode 100644
index 0000000..873883c
--- /dev/null
+++ b/docs/public/icons/database/presto.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#5d88d6" d="M572.928 238.694a36.096 36.096 0 1 0-51.098-51.046 36.096 36.096 0 0 0 51.047 51.046zM674.97 340.787a40.09 40.09 0 1 0-56.679-56.73 40.09 40.09 0 0 0 56.679 56.73M777.062 442.88a44.134 44.134 0 1 0-62.361-62.362 44.134 44.134 0 0 0 62.361 62.362m101.99 101.99a48.128 48.128 0 1 0-68.095-68.096 48.128 48.128 0 0 0 68.096 68.096"/><path fill="#32dbfc" d="M371.712 235.878a32.102 32.102 0 1 0-45.414-45.414 32.102 32.102 0 0 0 45.414 45.414M473.754 337.92a36.096 36.096 0 1 0-51.098-50.995 36.096 36.096 0 0 0 51.098 51.046zm101.99 102.042a40.09 40.09 0 1 0-56.73-56.73 40.09 40.09 0 0 0 56.73 56.73m102.042 102.041a44.134 44.134 0 1 0-62.413-62.413 44.134 44.134 0 0 0 62.413 62.413m102.092 102.093a48.128 48.128 0 1 0-68.096-67.994 48.128 48.128 0 0 0 68.096 68.045z"/><path d="M170.496 233.165a28.109 28.109 0 1 0-39.68-39.731 28.109 28.109 0 0 0 39.731 39.73zm101.99 101.939a32.102 32.102 0 1 0-45.363-45.414 32.102 32.102 0 0 0 45.363 45.414M374.58 437.248a36.096 36.096 0 1 0-51.046-51.098 36.096 36.096 0 0 0 51.046 51.098M476.672 539.29a40.09 40.09 0 1 0-56.832-56.73 40.09 40.09 0 0 0 56.73 56.678zm101.94 102.041a44.134 44.134 0 1 0-62.362-62.413 44.134 44.134 0 0 0 62.361 62.413m102.04 101.888a48.128 48.128 0 1 0-68.095-68.096 48.128 48.128 0 0 0 68.096 68.096"/><path fill="#5d88d6" d="M371.712 632.678a32.102 32.102 0 1 0-45.414-45.414 32.102 32.102 0 0 0 45.414 45.414M249.805 741.274a32.102 32.102 0 1 0 0-64.205 32.102 32.102 0 0 0 0 64.205M150.63 840.55a32.102 32.102 0 1 0 0-64.204 32.102 32.102 0 0 0 0 64.204m198.35-.05a32.102 32.102 0 1 0 0-64.206 32.102 32.102 0 0 0 0 64.205m221.132-9.37a32.102 32.102 0 1 0-45.414-45.364 32.102 32.102 0 0 0 45.414 45.364m-99.226-99.277a32.102 32.102 0 1 0-45.363-45.415 32.102 32.102 0 0 0 45.363 45.415"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/pulsar.svg b/docs/public/icons/database/pulsar.svg
new file mode 100644
index 0000000..feca270
--- /dev/null
+++ b/docs/public/icons/database/pulsar.svg
@@ -0,0 +1,3 @@
+<svg width="35" height="30" viewBox="0 0 35 30" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M34.7333 8.16353H26.2455C23.9513 3.68838 21.5234 0.21138 18.2199 0.21138C13.9192 0.21138 11.9007 4.0266 9.94695 7.74283L9.77671 8.06867H0V10.2753H5.69498C7.70544 10.2753 8.11483 10.9641 8.11483 10.9641C6.53807 13.4553 4.6411 15.9177 1.47948 15.9177H0V18.2316H1.49164C7.62032 18.2316 10.2955 13.1749 12.4438 9.11631C14.4138 5.37533 15.7879 3.11095 18.2239 3.11095C20.7532 3.11095 23.4122 8.70797 25.751 13.6492C26.0915 14.3669 26.4401 15.101 26.7927 15.8311C17.8186 16.1198 13.5423 18.2563 10.0645 20.001C7.51899 21.2755 5.50852 22.8552 2.20098 22.8552H0V25.1732H2.18071C6.16517 25.1732 8.64988 23.9235 11.2927 22.5954C14.9529 20.7641 19.1035 18.6894 28.8883 18.6894H34.5428V16.3714H31.3487C31.0852 16.392 30.8218 16.3508 30.5786 16.2477C30.3354 16.1487 30.1165 15.9919 29.9422 15.7898C29.3828 14.6886 28.8356 13.5296 28.3006 12.3706L27.5588 10.828C27.5588 10.828 28.0898 10.2506 29.5571 10.2506H34.7333V8.16353Z" fill="#188FFF"/>
+</svg>
diff --git a/docs/public/icons/database/qdrant.svg b/docs/public/icons/database/qdrant.svg
new file mode 100644
index 0000000..c10ad96
--- /dev/null
+++ b/docs/public/icons/database/qdrant.svg
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg id="Capa_2" data-name="Capa 2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 346.42 400">
+  <defs>
+    <style>
+      .cls-1 {
+        fill: #9e0d38;
+      }
+
+      .cls-2 {
+        fill: #dc244c;
+      }
+
+      .cls-3 {
+        fill: #ff516b;
+      }
+    </style>
+  </defs>
+  <g id="Vectors">
+    <g>
+      <g>
+        <polygon class="cls-2" points="173.21 0 0 100 0 300 173.21 400 238.16 362.5 238.16 287.5 173.21 325 64.96 262.5 64.96 137.5 173.21 75 281.46 137.5 281.46 387.5 346.42 350 346.42 100 173.21 0"/>
+        <polygon class="cls-2" points="108.26 162.5 108.26 237.5 173.21 275 238.16 237.5 238.16 162.5 173.21 125 108.26 162.5"/>
+      </g>
+      <g>
+        <polygon class="cls-1" points="238.16 287.5 238.16 362.5 173.21 400 173.21 325 238.16 287.5"/>
+        <polygon class="cls-1" points="346.42 100 346.42 350 281.46 387.5 281.46 137.5 346.42 100"/>
+        <polygon class="cls-3" points="346.42 100 281.46 137.5 173.21 75 64.96 137.5 0 100 173.21 0 346.42 100"/>
+        <polygon class="cls-2" points="173.21 325 173.21 400 0 300 0 100 64.96 137.5 64.96 262.5 173.21 325"/>
+        <polygon class="cls-3" points="238.16 162.5 173.21 200 108.26 162.5 173.21 125 238.16 162.5"/>
+        <polygon class="cls-2" points="173.21 200 173.21 275 108.26 237.5 108.26 162.5 173.21 200"/>
+        <polygon class="cls-1" points="238.16 162.5 238.16 237.5 173.21 275 173.21 200 238.16 162.5"/>
+      </g>
+    </g>
+  </g>
+</svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/questdb.svg b/docs/public/icons/database/questdb.svg
new file mode 100644
index 0000000..48bff14
--- /dev/null
+++ b/docs/public/icons/database/questdb.svg
@@ -0,0 +1,25 @@
+<svg width="812" height="701" viewBox="0 0 812 701" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M133.387 350.187C133.387 228.785 233.243 130.989 357.202 130.989C401.965 130.989 443.284 143.354 477.717 165.836L574.13 72.5358C514.446 27.572 438.693 0.59375 357.202 0.59375C159.786 0.59375 0.246094 156.843 0.246094 350.187C0.246094 543.531 159.786 699.781 357.202 699.781V569.386C233.243 569.386 133.387 471.589 133.387 350.187Z" fill="url(#paint0_linear)"/>
+<path d="M581.015 350.192H714.156C714.156 258.016 677.428 173.709 617.744 110.76L523.627 202.935C559.208 242.279 581.015 293.987 581.015 350.192Z" fill="url(#paint1_linear)"/>
+<path d="M466.239 361.43H269.971L616.596 700.906L811.717 699.782L466.239 361.43Z" fill="url(#paint2_linear)"/>
+<path opacity="0.6" d="M47.3016 175.957C-38.7809 421.01 218.319 523.302 218.319 523.302C190.772 503.069 156.339 455.857 146.01 422.134C124.202 352.44 131.089 297.359 166.669 236.658" fill="url(#paint3_linear)"/>
+<defs>
+<linearGradient id="paint0_linear" x1="803.686" y1="702.01" x2="178.788" y2="54.7941" gradientUnits="userSpaceOnUse">
+<stop stop-color="#892C6C"/>
+<stop offset="1" stop-color="#D14671"/>
+</linearGradient>
+<linearGradient id="paint1_linear" x1="143.714" y1="42.0442" x2="790.93" y2="692.448" gradientUnits="userSpaceOnUse">
+<stop stop-color="#C34170"/>
+<stop offset="1" stop-color="#8B2C6C"/>
+</linearGradient>
+<linearGradient id="paint2_linear" x1="774.991" y1="686.071" x2="115.023" y2="42.0437" gradientUnits="userSpaceOnUse">
+<stop stop-color="#882B6B"/>
+<stop offset="1" stop-color="#CF4671"/>
+</linearGradient>
+<linearGradient id="paint3_linear" x1="85.9224" y1="476.222" x2="175.953" y2="220.969" gradientUnits="userSpaceOnUse">
+<stop stop-color="white" stop-opacity="0.38"/>
+<stop offset="0.8598" stop-color="white" stop-opacity="0.01"/>
+<stop offset="1" stop-color="white" stop-opacity="0"/>
+</linearGradient>
+</defs>
+</svg>
diff --git a/docs/public/icons/database/redis.svg b/docs/public/icons/database/redis.svg
new file mode 100644
index 0000000..2df1a4f
--- /dev/null
+++ b/docs/public/icons/database/redis.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#a32422" d="M844.8 724.855c-38.451 20.173-238.234 102.298-281.242 124.877-43.008 22.528-66.048 21.914-99.737 5.837-33.639-16.128-245.504-102.246-283.904-120.627-19.354-9.063-29.184-16.845-29.184-24.064v-73.114s276.685-60.057 321.382-76.237c44.647-16.179 60.109-16.588 98.048-2.662s265.421 54.989 303.002 68.608v72.038c0 7.476-8.653 14.848-28.314 25.293v.051z"/><path fill="#dc382c" d="M844.8 652.1c-38.451 20.02-238.234 102.195-281.242 124.365s-66.048 21.965-99.737 5.94c-33.69-16.078-245.504-102.196-283.904-120.423s-39.117-30.925-1.485-45.67c37.632-14.695 248.986-97.434 293.683-113.716 44.647-16.281 60.109-16.64 98.048-2.662 37.94 13.926 236.851 92.98 274.227 106.752 37.376 13.721 39.066 25.088.41 45.056z"/><path fill="#a32422" d="M844.8 605.815c-38.451 20.07-238.234 102.196-281.242 124.365-43.008 22.17-65.894 21.965-99.532 5.837-33.69-16.18-245.76-101.837-284.16-120.115-19.303-9.216-29.184-16.896-29.184-24.218v-72.806s276.736-60.263 321.433-76.442c44.647-16.179 60.109-16.64 98.048-2.56 37.94 14.131 265.421 54.784 303.002 68.506v72.09c0 7.475-8.653 15.001-28.314 25.343z"/><path fill="#dc382c" d="M844.8 532.753C806.298 552.875 606.566 635 563.507 657.17c-43.008 22.118-66.048 22.016-99.737 5.888C430.13 646.98 218.266 561.17 179.917 542.788c-38.4-18.33-39.117-30.822-1.536-45.568 37.632-14.694 249.037-97.638 293.683-113.459 44.698-15.872 60.109-16.845 98.048-3.072 37.99 13.773 236.902 93.491 274.227 106.854 37.376 13.312 39.117 25.088.512 45.056v.154z"/><path fill="#a32422" d="M844.8 482.27c-38.451 20.121-238.234 102.297-281.242 124.416-43.008 22.118-65.894 21.965-99.532 5.94-33.69-16.078-245.76-101.991-284.16-120.32-19.303-9.063-29.184-16.795-29.184-24.065v-73.114s276.736-60.057 321.433-76.185c44.647-16.128 60.109-16.64 98.048-2.714s265.319 54.99 302.9 68.71v72.04c.102 7.577-8.551 15-28.263 25.292"/><path fill="#dc382c" d="M844.8 409.31c-38.451 19.763-238.234 102.4-281.242 124.416-43.008 21.913-66.048 21.862-99.737 5.888-33.69-16.026-245.504-102.042-283.904-120.32-38.4-18.227-39.117-30.874-1.485-45.568 37.632-14.746 248.986-97.639 293.683-113.715 44.647-16.128 60.109-16.59 98.048-2.663 37.94 13.875 236.851 92.98 274.227 106.701 37.376 13.722 39.066 25.14.41 45.107z"/><path fill="#fff" d="m523.264 305.63 47.616-15.667-12.902 30.873 48.486 18.176L544 345.515l-14.08 33.792-22.63-37.684-72.295-6.502 54.016-19.456-16.281-29.9 50.483 19.865zm2.97 196.966L409.395 454.06l167.424-25.703zM364.288 357.751c49.306 0 89.446 15.565 89.446 34.56s-40.243 34.56-89.446 34.56c-49.254 0-89.549-15.564-89.549-34.56 0-18.995 40.141-34.56 89.549-34.56"/><path fill="#741113" d="m680.602 348.177 99.02 39.117-98.918 39.168-.102-78.336z"/><path fill="#ac2724" d="m680.602 348.177.102 78.285-10.752 4.147-99.02-39.117z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/redshift.svg b/docs/public/icons/database/redshift.svg
new file mode 100644
index 0000000..83b1036
--- /dev/null
+++ b/docs/public/icons/database/redshift.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#205b98" d="m518.963 719.411 262.042 63.437V290.816l-262.042 63.488V719.36z"/><path fill="#5294cf" d="m780.954 290.867 50.33 25.19v441.754l-50.33 25.14V290.917zM518.912 719.411l-261.99 63.437V290.816l261.99 63.488V719.36z"/><path fill="#205b98" d="m256.922 290.867-50.33 25.19v441.754l50.33 25.14V290.917z"/><path fill="#5294cf" d="m585.984 881.766 99.533-49.715V243.15l-99.533-49.715-31.232 327.321z"/><path fill="#205b98" d="m451.84 881.766-99.482-49.715V243.15l99.482-49.715 31.283 326.195-31.232 362.137z"/><path fill="#2d72b8" d="M585.984 193.434H451.84v688.332h134.144z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/rqlite.png b/docs/public/icons/database/rqlite.png
new file mode 100644
index 0000000..a85d121
Binary files /dev/null and b/docs/public/icons/database/rqlite.png differ
diff --git a/docs/public/icons/database/saphana.webp b/docs/public/icons/database/saphana.webp
new file mode 100644
index 0000000..ca36c34
Binary files /dev/null and b/docs/public/icons/database/saphana.webp differ
diff --git a/docs/public/icons/database/selectdb.svg b/docs/public/icons/database/selectdb.svg
new file mode 100644
index 0000000..f19f626
--- /dev/null
+++ b/docs/public/icons/database/selectdb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 400 400"><path fill="#1a6fef" d="M168 22c-3.6 1-7.8 2.3-9.5 2.9-1.6.5-6.3 1.7-10.4 2.6s-9 2.7-11 4.1c-1.9 1.3-4.6 2.4-5.8 2.4s-2.5.4-2.8 1c-.3.5-1.5 1-2.5 1-1.1 0-3.6 1.1-5.6 2.5s-4.2 2.5-4.9 2.5-1.8.7-2.5 1.4c-.6.8-2.7 2-4.6 2.6-1.9.7-5.2 2.7-7.2 4.6s-4.5 3.7-5.5 4-2.9 1.6-4.2 3c-1.3 1.3-2.9 2.4-3.6 2.4-.6 0-2 1.1-3.1 2.5S82.2 64 81.4 64s-1.4.6-1.4 1.2c0 .7-4.1 5.3-9 10.2-5 4.9-9 9.2-9 9.6 0 .3-1.3 2.2-3 4-1.6 1.8-3 3.9-3 4.6 0 .6-1.2 1.9-2.6 2.9-1.4.9-3.5 3.6-4.5 6-1.1 2.4-2.4 4.7-2.8 5-1.2.7-6.1 9.4-6.1 10.7 0 .5-1.6 4.2-3.6 8.1-3.9 7.9-6.4 14.4-6.4 16.7 0 .8-.6 2.6-1.3 4-1.9 3.6-4.3 12.3-5.9 21-1.7 10-1.8 54.6 0 65 .7 4.1 2.4 10.9 3.8 15s3.2 10.2 4.1 13.5 2.2 6.7 2.9 7.6c.8.8 1.4 2.2 1.4 2.9s.6 2.1 1.4 2.9c.7.9 2.6 4.8 4.1 8.8s3.8 8.2 5.1 9.4c1.3 1.3 2.4 3 2.4 3.9s1.8 3.6 4 6 4 4.8 4 5.3c0 1.4 4.6 6.9 12.8 15.3 3.9 4.2 7.2 7.9 7.2 8.3s3 3 6.7 5.7 8.1 6.1 9.7 7.6c1.7 1.6 3.5 2.8 4.1 2.8.7 0 2.2 1.2 3.6 2.6 1.3 1.5 4.3 3.5 6.6 4.6 2.3 1 4.5 2.3 4.8 2.8.3.4 1.9 1.1 3.6 1.5 1.6.4 3.8 1.5 4.7 2.5s3.3 2.1 5.2 2.5c2.9.5 4.3.1 8.3-2.5 2.6-1.8 4.7-3.6 4.7-4.2 0-.5 2-1.8 4.4-2.9 2.5-1.1 4.8-2.8 5.1-3.9.3-1 1.6-2.2 2.8-2.6 1.2-.3 4-2.3 6.2-4.4 2.2-2 6-5.1 8.5-6.7 2.5-1.7 6-4.5 7.7-6.2 1.8-1.7 3.8-3.1 4.4-3.1.7 0 2.7-1.8 4.6-4s3.9-4 4.5-4 3.5-2.3 6.5-5c3-2.8 5.8-5 6.2-5s1.4-1.2 2.1-2.6c.8-1.4 2.7-3.2 4.2-4 4.3-2.3 30-27 42.9-41.4 11.8-13.2 13.9-15.7 13.9-16.9 0-.6 1.7-3 3.8-5.4 2.1-2.3 4.5-5.8 5.2-7.7.8-1.9 2.5-5.3 3.9-7.5s3-7.1 3.7-11c1-6 1-7.7-.4-12-2.1-6.1-7.5-9.9-13.2-9.1-9.4 1.3-12.5 2.2-18 5.1-10.9 5.9-19.2 10.9-20.3 12.4-.6.9-2.7 2.3-4.5 3-1.8.8-4.2 2.7-5.3 4.2-1.1 1.6-2.8 2.9-3.8 2.9-.9 0-2.7.9-3.9 2s-2.7 2-3.5 2c-.7 0-2.4 1.2-3.8 2.6-1.3 1.4-4 3.4-5.9 4.4s-4.6 3-5.9 4.4c-1.4 1.4-2.9 2.6-3.4 2.6-1.9 0-12 5.4-14.5 7.7-1.4 1.3-3.1 2.3-3.8 2.3-1.2 0-10.7 4.3-15.4 6.9-3.5 2-11.8 3.1-22.6 3.1-11.6 0-18.7-1.2-21.2-3.7-.7-.7-1.8-1.3-2.3-1.3-.6 0-2-1.1-3.3-2.5s-2.8-2.5-3.3-2.5c-1 0-11.3-12.3-11.3-13.5 0-.5-.6-1.6-1.3-2.4-2.4-2.9-3.7-9.7-3.7-19.2.1-11.8 2.2-20.8 6.9-28.9.5-.8 2.7-5.3 5-10 5.2-10.6 7.3-14.2 12.2-20.6 2.1-2.8 3.9-5.8 3.9-6.7s.9-2.1 2.1-2.7c1.1-.6 3.2-3 4.7-5.4 3-4.7 9-12 14-17.1 1.7-1.8 3.2-3.6 3.2-3.9 0-.8 2.7-3.9 7.8-8.8 2.3-2.3 4.2-4.7 4.2-5.3 0-.7 2.1-3 4.8-5.1 2.6-2.1 5.1-4.5 5.6-5.4.6-.8 2.5-2.8 4.3-4.4s3.3-3.6 3.3-4.3c0-.8.8-1.7 1.8-2 .9-.4 2.9-1.5 4.4-2.6 2.1-1.6 3.6-1.8 7-1.4 9.5 1.4 19.9 4 26.8 6.6 6.5 2.5 16.3 5.1 19.2 5.1 2.1 0 8.8 3.7 8.8 4.8 0 .4-1.9 1.7-4.3 3s-5.7 3.5-7.4 5c-4.3 3.9-12 10.2-18 14.7-2.9 2.1-5.3 4.3-5.3 4.7s-1.3 1.4-2.8 2.2c-1.6.8-4.5 3-6.4 4.8s-5.9 5.3-8.7 7.8c-5.9 5-33.4 32.5-39.6 39.4-2.2 2.5-4.5 5.6-5 7-.6 1.4-2 3.5-3.2 4.8-2.4 2.6-3.8 5.8-5.9 13.6-1.8 6.9-1.8 7.9.9 13 1.7 3.4 3.1 4.7 6.2 5.8 4.8 1.7 12.9 1.8 19.3.3 5.7-1.3 5.9-1.4 9.7-3.9 3.4-2.3 3.5-2.3 9.6-4.5 2.5-.9 5.7-2.6 7-3.9 1.3-1.2 4-2.8 5.9-3.6s4.6-2.1 6-3.1c8.2-5.5 12.5-7.9 14.1-7.9.9 0 1.9-.6 2.2-1.3.2-.6 4.4-3.4 9.3-6s9.6-5.2 10.4-5.6c3.1-1.9 12-5.1 13.9-5.1 1.1 0 2.3-.5 2.7-1.1.9-1.6 7.1-4.1 12.9-5.2 6.9-1.4 29.2-1.3 33.8 0 2.2.6 4.9 2.1 6.2 3.3 1.2 1.2 4 3.1 6.2 4.3 4 2.2 12.3 10.6 12.3 12.4 0 .6.8 2.1 1.9 3.4 1 1.3 2.2 3.9 2.6 5.7s1.3 4.5 2.1 6c1.7 3.3 1.9 24.9.3 30.2-.6 1.9-1.7 6.3-2.4 9.7-.8 3.5-2.1 7.7-2.9 9.5s-2 5.1-2.7 7.3c-1.2 3.8-4 10.2-5.9 13.5-.4.8-1.6 3.3-2.6 5.5-.9 2.1-3.1 6.2-4.9 9-1.8 2.7-3.5 6.2-3.9 7.7-.3 1.5-1.9 4.2-3.5 6s-4 5.8-5.4 9c-1.4 3.1-3.5 6.2-4.6 7s-2.5 2.7-3.2 4.3c-1.4 3.3-13 19.6-16.6 23.4-1.3 1.3-2.3 3-2.3 3.7s-2.2 3.6-5 6.6c-2.7 2.9-5 5.7-5 6.1 0 .5-1.5 2.3-3.2 4.1-7.3 7.3-8.1 8.5-6.4 9.2.9.4 2.5-.1 3.5-1s3-1.6 4.5-1.6c4.2 0 11.4-2.1 16.4-4.7 2.6-1.4 6.7-3.1 9.2-4 2.5-.8 5.2-2.1 6-2.8.8-.6 4.6-2.7 8.4-4.5s8.3-4.5 10-6 5.2-3.9 7.9-5.5c2.6-1.5 5.2-3.5 5.7-4.5s2.9-2.9 5.3-4.3c2.3-1.4 4.9-3.7 5.6-5.1.8-1.3 2.6-3 4.2-3.6 1.6-.7 3.1-2.1 3.4-3.1.4-1.1 2.6-3.8 5.1-6.1 2.4-2.3 4.4-4.6 4.4-5.2s1.6-2.9 3.5-5.1c2-2.2 5-6.2 6.8-9 1.7-2.7 3.7-5.5 4.3-6 .6-.6 2.3-4.1 3.8-7.9s3.7-8.3 5-10 2.9-5.4 3.6-8.1c.7-2.8 2.6-7.6 4.2-10.7 1.5-3.2 2.8-6.6 2.8-7.8 0-1.1.4-3.9 1-6.2 3.5-15.9 5.4-41.6 4.1-55.7-2.6-26.9-5.7-43-9.2-47.6-1.1-1.5-3.9-9.8-3.9-11.7 0-.9-.6-2.3-1.3-3-2.2-2.2-8.7-15.5-8.7-17.7 0-.6-.6-1.4-1.4-1.8-.7-.4-2.5-2.7-4-5.1-1.5-2.3-3.4-5.1-4.4-6.2-2.8-3.1-3.8-4.4-6.6-8.8-1.4-2.3-3.7-4.9-5.1-5.8-1.5-.9-3.3-3-4-4.5-.8-1.5-2.8-3.6-4.4-4.5-1.6-1-3.5-2.7-4.1-3.8-.7-1.2-3.9-4.1-7.2-6.6-3.2-2.5-7.2-5.5-8.8-6.8-1.5-1.2-3.3-2.2-3.9-2.2-.7 0-2.7-1.6-4.7-3.5-1.9-1.9-4.7-3.8-6.2-4.1-1.5-.4-3.8-1.5-5.1-2.6-1.3-1-3-1.8-3.7-1.8s-1.9-.7-2.8-1.5c-.8-.9-4.1-2.4-7.3-3.4s-7.6-2.9-9.8-4.1c-3.7-2.2-6.4-3-14-4.5-3-.6-8.2-2-18.4-4.9-8.3-2.5-55.1-2.1-64.1.4"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/snowflake.svg b/docs/public/icons/database/snowflake.svg
new file mode 100644
index 0000000..e986bee
--- /dev/null
+++ b/docs/public/icons/database/snowflake.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#29b5e8" d="M395.418 524.8a43.264 43.264 0 0 0-19.968-50.688L226.61 388.608a43.88 43.88 0 0 0-59.853 16.026 43.315 43.315 0 0 0 16.026 59.545l83.2 47.821-83.149 47.718a43.52 43.52 0 0 0-16.025 59.648 43.88 43.88 0 0 0 59.852 15.872l148.736-85.504a43.37 43.37 0 0 0 19.968-24.934zm40.345 80.128a43.26 43.26 0 0 0-25.446 5.683l-148.839 85.453a43.622 43.622 0 1 0 43.776 75.571l83.456-47.872v95.693c0 24.064 19.559 43.622 43.828 43.622a43.725 43.725 0 0 0 43.776-43.622v-171.06a43.62 43.62 0 0 0-40.55-43.468m152.474-185.856a43.78 43.78 0 0 0 25.344-5.734l148.838-85.504a43.57 43.57 0 0 0 16.026-59.648 43.88 43.88 0 0 0-59.75-15.924l-83.354 47.924v-95.744a43.725 43.725 0 0 0-43.879-43.52 43.674 43.674 0 0 0-43.776 43.52v171.11c0 22.938 17.818 41.83 40.55 43.52m-326.759-91.29 148.839 85.504c8.038 4.608 16.896 6.4 25.446 5.684a43.776 43.776 0 0 0 40.55-43.52V204.442a43.725 43.725 0 0 0-43.775-43.572 43.725 43.725 0 0 0-43.879 43.52v95.744l-83.405-47.923a43.88 43.88 0 0 0-59.801 15.923 43.57 43.57 0 0 0 16.025 59.648M541.235 511.59a13 13 0 0 0-3.277-7.782l-17.92-17.766a12.7 12.7 0 0 0-7.73-3.175h-.718a12.54 12.54 0 0 0-7.68 3.175l-17.92 17.766a12.7 12.7 0 0 0-3.174 7.782v.717c0 2.458 1.382 5.888 3.174 7.68l17.92 17.767a12.54 12.54 0 0 0 7.68 3.225h.717a12.65 12.65 0 0 0 7.731-3.225l17.92-17.767a12.65 12.65 0 0 0 3.277-7.68zm49.46 17.101-61.901 61.491a12.34 12.34 0 0 1-7.732 3.277h-18.278a12.6 12.6 0 0 1-7.731-3.277l-61.85-61.49a12.4 12.4 0 0 1-3.225-7.68v-18.126c0-2.56 1.433-6.041 3.225-7.782l61.901-61.44a12.5 12.5 0 0 1 7.731-3.226h18.227c2.56 0 5.99 1.383 7.783 3.226l61.85 61.491a12.6 12.6 0 0 1 3.174 7.783v18.124a12.44 12.44 0 0 1-3.175 7.68zm171.724 167.322L613.581 610.56a43.16 43.16 0 0 0-25.344-5.632 43.62 43.62 0 0 0-40.55 43.418v171.008c0 24.115 19.558 43.673 43.775 43.673a43.725 43.725 0 0 0 43.879-43.622V723.66l83.353 47.923a43.674 43.674 0 1 0 43.776-75.571zm78.695-231.936L758.016 512l83.098 47.718a43.52 43.52 0 0 1 16.025 59.648 43.93 43.93 0 0 1-59.801 15.872l-148.89-85.504a43.26 43.26 0 0 1-21.811-39.116 43.78 43.78 0 0 1 21.862-36.455l148.839-85.504a43.93 43.93 0 0 1 59.801 15.975 43.366 43.366 0 0 1-16.025 59.545z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/sqlite.svg b/docs/public/icons/database/sqlite.svg
new file mode 100644
index 0000000..ebf14c3
--- /dev/null
+++ b/docs/public/icons/database/sqlite.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#0f80cc" d="M691.61 187.597H211.917a58.52 58.52 0 0 0-58.317 58.368v528.793c0 32.308 26.522 58.368 58.368 58.368h315.75c-3.379-156.672 50.637-461.824 163.892-645.53"/><path fill="#003b57" d="M803.482 170.189c-32.768-29.389-72.807-17.306-111.872 17.408-5.786 5.273-11.52 11.059-17.306 16.896-67.072 71.321-129.74 203.417-148.992 304.128 7.68 15.462 13.466 34.713 17.306 49.664 1.024 3.891 1.945 7.27 2.457 10.598 1.895 7.27 2.407 12.083 2.407 12.083s-.512-2.406-2.868-9.625c-.512-1.485-1.024-2.867-1.484-4.813-.512-.973-.512-1.485-.973-2.458-4.301-10.086-16.384-31.744-21.658-40.96-4.352 13.466-8.704 26.01-12.083 37.581 15.462 27.955 24.576 76.698 24.576 76.698l-4.813-14.029c-3.379-9.626-20.736-39.526-24.576-46.746-6.758 25.6-9.625 42.906-7.168 47.258 4.762 8.192 9.575 22.17 13.415 37.58 9.216 35.226 15.462 77.671 15.462 77.671s0 2.867.512 7.168a662 662 0 0 0 1.894 87.757c2.868 36.66 8.653 67.994 15.872 84.838l4.864-2.867c-10.598-33.28-14.95-76.185-13.004-126.31 2.867-76.186 20.224-168.704 52.992-264.704 54.988-145.101 131.174-261.274 200.55-316.672-63.59 57.344-149.402 242.944-175.002 311.91-28.928 77.107-49.152 149.402-61.696 218.368 21.197-65.075 89.703-92.57 89.703-92.57s33.69-41.471 72.755-100.761c-23.603 5.325-62.208 14.438-75.162 20.275-19.302 8.192-24.166 10.547-24.166 10.547s61.747-37.58 115.251-54.937c73.728-115.712 153.344-279.143 72.807-350.976"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/sqlserver.svg b/docs/public/icons/database/sqlserver.svg
new file mode 100644
index 0000000..360df61
--- /dev/null
+++ b/docs/public/icons/database/sqlserver.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#8a8a8a" d="M703.5 221.2c58 19.5 104.2 40 138.6 61.6 34.9 21 63.6 42.1 86.7 62.1 23.1 19.5 38.5 36.4 46.2 49.8 7.7 13.3 9.2 20.5 3.6 21-118 18-245.3 49.8-382.4 93.9 2.1 5.6 4.6 13.3 7.7 24.6s6.2 34.4 9.8 69.8c3.1 35.4 3.1 72.4-.5 109.8-4.1 37.5-14.9 84.7-32.8 140.6-18.5 55.9-44.1 111.4-76.5 166.8-3.1 4.6-32.8 3.1-89.8-4.1-128.8-16.9-227.4-46.2-297.2-86.7C9 865.3 17.8 785.8 143 691.4c61.6-47.7 109.3-97 144.2-148.8s54.9-101.6 60.1-148.8c5.1-47.2-2.1-91.4-21.6-132.9-19.5-42.1-50.8-77-92.9-105.7-20.5-13.3-27.7-28.2-21-44.1C226.1 74.9 298.5 38 426.8 0c-1 0 3.6 14.4 12.8 43.1 9.2 28.2 21 58 35.9 87.8s28.7 45.2 42.6 46.7c65.8 8.7 128.4 23.6 185.4 43.6M73.7 810.9c-.5.5-.5 5.6.5 14.9 1 9.2 6.2 22.1 15.4 38.5 9.8 15.9 24.1 30.8 43.1 44.7l21-28.2c13.3-18 27.7-37.5 42.1-59 14.4-21.6 23.1-34.9 25.1-41.1.5 0-8.7 2.6-28.2 7.7s-41.1 9.8-65.2 14.9c-24 5.6-42 7.6-53.8 7.6m71.9-112.4c-16.4 13.3-28.7 26.2-38 36.4-8.7 10.9-15.4 22.1-21.6 33.4-5.6 11.8-9.2 19.5-9.8 23.6s-1.5 7.2-2.6 9.2c13.9 0 65.2-13.3 152.9-41.1-17.5-40-25.7-72.4-24.1-97-20.9 9.9-39.9 22.2-56.8 35.5m2 223.3 183.2-67.2C299 837.1 269.3 815 241 787.3l-99 126.8zm11.3 2.1c12.8 11.8 29.3 22.1 50.8 30.8 21.6 8.7 36.4 13.3 46.2 15.4 9.8 1.5 16.4 3.1 22.1 4.6l67.2-101.1zm73.9-274.1c1.5 46.2 7.2 75.4 16.9 87.8 22.6-22.6 45.7-66.7 67.7-130.9-9.1 3.6-37.4 17.9-84.6 43.1m25.7-555.4c-6.7 4.6-12.8 9.8-19 15.9s-8.2 9.8-6.2 11.8c4.1 4.6 32.8 12.8 86.7 25.1l-51.3-60.1zm-18 524.6 141.1-123.2c-33.9 14.9-65.7 35.4-93.9 62.1zm14.4 0c14.4-9.8 71.3-37 169.9-82.1.5-10.8-1-20-4.6-28.7-4.1-8.2-6.7-13.3-9.2-15.9-2.6-2.1-4.6-3.6-6.7-4.6-5.2 9.6-55 53.3-149.4 131.3m75.9-384.4-19-62.1-50.8-17c13.9 9.8 37.5 35.9 69.8 79.1m-64.1 533.2c11.8 15.9 26.7 30.8 44.1 44.1 17.5 13.3 29.8 21.6 36.4 25.1 7.2 3.6 12.8 6.2 16.4 8.2 26.2-38.5 44.7-83.1 54.9-132.9-9.6 6.3-60.5 25.2-151.8 55.5m158.1-82.6c-17.5-15.9-31.8-31.8-43.6-48.2-11.8-15.9-18.5-26.7-21-31.8s-4.1-9.2-4.6-12.8c.5 2.1 0 5.6-1.5 9.8-1.5 4.6-4.1 9.8-6.7 15.9-2.6 6.2-6.2 12.8-10.8 21s-8.7 15.4-12.8 23.1c-4.1 7.2-8.7 15.4-12.8 24.1-4.6 8.2-8.7 15.9-11.8 22.1l-11.8 20c-3.6 6.2-5.6 9.8-7.2 11.8-1.5 2.1-2.6 3.6-3.1 5.1 69.1-21.1 118.4-41.1 147.7-60.1m-3.6-577.9c-12.8-2.6-26.7-5.1-40-7.7s-28.7-6.2-46.7-9.8c-17.5-3.6-29.8-6.2-35.9-7.7-6.2-1.5-11.8-2.6-15.9-4.1 1.5 4.6 24.6 30.8 69.8 77h19l73.9-46.2c-3.2 1-11.4.5-24.2-1.5M287.7 983.9c35.9-2.1 116.5-27.2 241.7-74.9-53.4-1-106.2-12.8-158.1-34.9zM400.6 89.3c24.6 3.6 39 5.1 43.1 5.1 1-2.1 2.1-4.1 2.1-6.7s-1.5-7.7-3.6-14.9c-2.6-7.7-4.6-14.4-6.2-20-2.1-5.6-4.1-12.8-7.2-20s-5.1-12.8-6.2-14.9-1.5-4.1-1.5-5.6c-1 0-10.8 4.6-29.8 12.8-19.5 8.2-39.5 17.5-60.1 27.2-20.5 9.8-31.8 14.9-33.9 16.9-2.1 2.1 8.7 5.1 31.8 9.2 22.8 3.7 47.4 7.8 71.5 10.9m-68.7 100.1c4.6 10.8 9.8 23.6 13.9 37 4.6 12.8 7.2 22.1 7.2 26.2l84.7-63.1-112.9-16.9zm-7.2 320.8c18.5-11.8 39.5-28.2 62.1-48.2-6.2-8.2-15.4-13.9-28.7-18-1.1 7.1-11.9 29.2-33.4 66.2m208.9 411.6c-63.1 26.7-132.4 47.2-208.9 62.1 26.2 14.4 82.6 25.7 168.9 32.8 8.2-9.2 21-41 40-94.9M363.7 291.5c4.6 2.1 7.7 35.4 8.2 100.6 18.5-16.9 43.6-40.5 73.9-70.8-16.9-10.8-44.1-21-82.1-29.8m102.1 3.1c1-23.1.5-42.6-2.6-59.5s-5.6-27.7-7.7-31.8-4.1-7.2-5.1-8.2l-79 68.3c14.9 2.5 46.2 13.2 94.4 31.2m-93.9 116.5c8.7 6.2 22.6 16.9 41.1 32.8 20.5-25.1 34.9-59.5 44.1-102.7-6.7 4.7-34.9 27.8-85.2 69.9m28.2 223.3c11.8 14.4 20 23.6 25.1 27.2s9.2 6.7 12.8 8.7c7.2-18.5 11.8-38 14.4-58.5 2.1-20 2.6-33.4 1.5-40.5l-2.1-18-80.1 32.8c7.4 18 17.1 33.9 28.4 48.3m170.4 133.4c-4.1 8.7-67.2 37.5-188.9 86.7 13.9 15.9 64.7 31.8 151.9 48.2 15-18.9 27.3-63.5 37-134.9m-178.1 62.1c8.7.5 28.7-5.6 62.1-19 32.8-13.3 57-24.1 73.9-31.8 16.4-8.2 30.8-14.4 42.1-20-21.6-4.6-61.1-22.6-119.1-52.9zm65.2-707.2-61.1 37 82.1 12.8zm95 270.5c-50.8 29.8-93.4 52.4-127.8 68.8 8.2 6.2 14.9 28.7 21 68.8 6.7-9.8 42.1-56 106.8-137.6m0-24.2-73.9-39.5c.5 5.1-2.1 16.4-7.2 33.4-5.6 17.5-9.8 30.8-12.8 39.5-3.1 9.2-5.6 16.4-7.7 21.6zm-85.7-173.5 7.2 11.8c4.6 8.7 7.7 20 9.8 34.4 1.5 13.9 0 30.8-4.6 49.8l123.2-67.7zm0 474.3L492 657c16.9-8.2 35.4-16.9 54.4-27.7s30.8-18 35.4-22.6l-104.2-62.1c0 65.7-4.1 107.2-10.7 125.2m114.9 59c3.1-10.8 6.2-26.2 8.7-46.7 2.1-20.5 2.6-40 .5-58.5l-26.2 14.9c-16.9 9.8-35.4 20.5-55.9 30.8-21 10.8-34.9 16.9-42.1 19l14.9 11.8c10.8 7.7 25.1 15.4 43.6 25.1 18 9.8 34.9 15.9 50.8 20zm86.3-272c-14.4-22.6-43.6-44.1-86.7-65.2-4.1 9.8-40.5 52.4-108.8 128.8 17.9-6.6 83.1-28.2 195.5-63.6m-155.6 94.4c11.8 7.7 26.2 15.4 42.1 24.6s27.7 14.9 34.9 17.5l1-13.9q0-13.05-1.5-33.9c-1-13.9-2.6-25.7-4.6-34.9l-90.8 30.8zm114-323.8-123.7 80.1c13.9 4.1 40 16.9 79 40 29.8-50.8 44.7-90.9 44.7-120.1m15.4 0c.5 5.1-2.1 19-8.2 41.1-6.2 22.1-10.8 38.5-14.4 50.8-4.1 11.8-7.2 21-9.8 28.7 39-20 101.1-42.1 185.8-66.2-17.9-12.3-69.2-30.3-153.4-54.4m46.2 222.7c22.1-21 43.6-45.7 64.2-73.4 21-27.7 33.9-46.7 40-56.5 6.2-10.8 10.8-19 13.9-25.7-10.8.5-77 23.6-196.6 68.8 26.1 15 52.3 44.2 78.5 86.8m274-41c-4.6-10.8-19.5-26.2-44.7-47.2-25.1-20.5-44.1-35.4-57.5-44.7-12.8-9.8-24.6-16.9-33.9-23.1-10.8 30.8-46.7 81.1-106.2 149.4 30.4-11.3 111.5-23.1 242.3-34.4"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/starrocks.svg b/docs/public/icons/database/starrocks.svg
new file mode 100644
index 0000000..25d0351
--- /dev/null
+++ b/docs/public/icons/database/starrocks.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="209.961" height="200" class="icon" viewBox="0 0 1075 1024"><path fill="#01808f" d="M224 303.667c-.922 19.456 7.936 30.003 20.275 39.731l238.387 195.994c22.016 18.534 23.808 30.874 8.807 54.733L374.938 771.533c-15.002 22.067-28.263 25.6-52.07 12.39l-74.19-42.393c-28.21-15.872-42.342-40.602-42.342-73.268V354.918c0-17.715 4.403-33.587 17.664-51.25m671.795 418.458c5.325-20.327-4.403-30.925-16.742-40.653-79.463-65.331-158.055-129.74-236.595-195.072-25.6-21.197-27.392-31.744-9.728-59.136 37.939-58.266 76.8-116.531 114.739-174.797 15.001-22.989 29.184-25.6 52.992-12.39 24.73 14.131 49.408 28.262 73.267 42.393 28.262 15.872 41.472 39.732 41.472 72.397v314.266c.922 18.534-4.403 36.198-19.405 52.94zM712.192 572.006c5.274 3.584 152.678 124.468 154.47 126.26 21.197 19.456 19.456 36.198-5.324 51.2-63.488 36.198-235.674 134.144-257.741 147.456-28.263 16.742-56.525 16.742-84.736 0-40.653-23.86-81.255-46.797-121.856-70.656-19.456-11.47-19.456-23.86 0-34.407 96.256-54.784 191.59-110.387 287.795-165.12 22.067-12.339 37.069-25.6 27.392-54.733"/><path fill="#febd02" d="M410.266 451.994a15286 15286 0 0 1-154.522-126.26c-21.146-19.456-19.405-36.198 5.325-51.2 63.539-36.198 235.725-134.144 257.792-147.456 28.211-16.742 56.473-16.742 84.736 0 40.601 23.86 81.203 46.797 121.856 70.656 19.405 11.47 19.405 23.808 0 34.407-96.256 54.784-191.59 110.387-287.847 165.12-22.016 12.339-37.068 25.6-27.34 54.733"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/sundb.svg b/docs/public/icons/database/sundb.svg
new file mode 100644
index 0000000..8626ff8
--- /dev/null
+++ b/docs/public/icons/database/sundb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#a9303c" d="m348.826 419.84 4.864 1.638a79 79 0 0 1-.615-2.048l-1.894-4.864c-1.28-3.43-2.56-6.81-3.584-10.24a32.1 32.1 0 0 1-1.178-11.724 98.3 98.3 0 0 1 3.789-16.59 20 20 0 0 1 4.352-8.55c5.325-5.068 10.957-9.83 16.896-14.182 7.885-5.94 16.077-11.571 24.269-17.152a254 254 0 0 1 36.25-20.224 410 410 0 0 1 24.934-10.291 192.8 192.8 0 0 1 68.505-12.647 143.2 143.2 0 0 1 64.103 12.903c11.059 5.12 20.992 11.878 30.208 19.763 8.704 7.475 15.616 16.64 21.913 26.317 7.168 10.957 12.032 22.937 16.026 35.328 1.28 4.045 2.048 8.192 2.867 12.441l.973 4.762 1.946 9.83.87 4.455c.358 1.945 1.382 2.765 3.533 2.765h50.637c1.894 0 2.764-.922 3.072-2.407a16.2 16.2 0 0 0 .307-6.502c-.512-5.223-.922-10.496-1.792-15.667a316 316 0 0 0-4.096-20.839 159.6 159.6 0 0 0-18.432-46.49 138.4 138.4 0 0 0-57.754-53.81 130.2 130.2 0 0 0-36.454-12.442 95.3 95.3 0 0 0-18.535-2.97l-4.608-.102c-12.339-.359-24.78-.717-37.222 1.024a247 247 0 0 0-40.038 8.704c-28.16 8.704-54.375 21.555-79.002 37.683a357 357 0 0 0-41.472 30.976c-6.349 5.632-12.544 11.418-18.74 17.254l-5.324 5.018a47 47 0 0 0-2.867 3.072c-1.741 1.894-3.482 3.84-5.632 5.069a47.1 47.1 0 0 1-26.01 6.553 59.5 59.5 0 0 1-18.944-4.864c-.614-.256-1.331-.204-2.048-.153l-1.024.051c.103 1.024.205 2.048.461 3.072.512 1.792 1.126 3.584 1.74 5.376 1.28 3.635 2.51 7.27 3.226 10.957a40.65 40.65 0 0 1-2.252 20.736l-3.584 10.393 3.225-1.075 4.045-1.433c5.734-2.1 11.725-3.584 17.818-4.301.768-.103 1.587 0 2.406.205a220 220 0 0 1 8.294 1.484c3.84 1.178 7.68 2.458 11.623 3.79zm30.566 380.109 8.5.717 9.42-.82A231.8 231.8 0 0 0 456.09 789.3c16.588-4.915 32.512-11.571 48.128-19.2a360.5 360.5 0 0 0 58.726-36.045 471 471 0 0 0 60.262-54.17 224 224 0 0 0 15.36-17.92c7.68-9.88 15.156-19.865 22.682-29.9l.666-.922c1.894-2.56 1.587-4.25-1.024-5.888a7.17 7.17 0 0 0-3.584-.87H640c-10.752 0-21.606 0-32.41-.205-5.273-.102-8.806 1.178-12.288 5.632-5.376 6.963-11.264 13.466-17.203 19.968l-6.349 7.066c-10.752 12.134-23.04 22.733-35.686 32.768a317.6 317.6 0 0 1-54.272 35.02 247 247 0 0 1-67.02 23.809l-.769.153a230 230 0 0 1-26.829 3.891 160.3 160.3 0 0 1-36.352-1.382 140.1 140.1 0 0 1-47.616-16.077 127.7 127.7 0 0 1-33.382-27.75 132 132 0 0 1-23.962-42.752c-1.74-4.864-2.867-9.933-3.993-15.002l-.256-1.024c-.717-3.277-1.28-6.605-1.895-9.881a340 340 0 0 0-1.228-6.708 19.5 19.5 0 0 0-1.536-5.12c-1.28-2.56-2.816-2.457-5.12-.716-1.792 1.33-1.639 2.918-1.434 4.608l.051.921c.205 2.867.307 5.786.461 8.653.307 6.758.614 13.568 1.382 20.275 1.895 15.667 5.172 31.079 11.264 45.722 2.919 7.014 5.837 14.08 9.472 20.736 5.018 9.165 11.316 17.408 18.228 25.395a128 128 0 0 0 27.904 24.013c18.432 11.776 38.553 19.149 60.313 21.709 6.656.768 13.363 1.28 19.917 1.843"/><path fill="#4550ff" d="M852.94 613.376h-49.254c-4.096 0-5.939-2.15-4.812-6.042 1.536-5.222 3.276-10.393 4.864-15.616l3.737-12.492 5.94-18.74c1.791-5.888 3.43-11.776 5.273-17.612 2.253-7.476 4.608-14.9 6.963-22.375l5.069-16.589 7.475-23.91c1.69-5.53 3.175-11.11 4.864-16.691l7.68-24.115c.717-2.304 2.1-3.072 4.352-3.072h107.52c6.963 0 13.722 1.075 19.968 4.044 8.192 3.84 13.927 9.933 15.872 19.15.461 2.047 1.843 4.095 1.741 6.143-.512 7.68-2.56 15.258-5.786 22.221a63.1 63.1 0 0 1-17.1 20.89c-1.946 1.69-4.455 2.816-6.708 4.198l-.768.256c-2.252 1.28-4.761 2.867-4.71 5.632 0 2.714 2.202 4.3 4.608 5.837a25.7 25.7 0 0 1 12.032 14.694 29.7 29.7 0 0 1 .973 14.439c-1.383 6.604-3.38 13.312-6.349 19.302-8.192 16.691-21.248 28.416-38.81 34.611-5.734 2.048-11.98 2.765-18.022 3.687-23.091 3.532-46.387 1.536-66.611 2.15m40.244-74.138v-.41c-4.352 0-8.704.257-13.107-.05-3.533-.256-5.376 1.536-6.503 4.812-2.56 7.732-4.864 15.463-7.321 23.194-1.946 6.349 0 9.062 6.656 9.114 5.683 0 11.469.102 17.152-.052 6.912-.204 13.824 0 20.633-1.843 7.783-2.048 18.484-12.237 17.562-23.757a9.93 9.93 0 0 0-4.403-7.68 22 22 0 0 0-12.442-3.328c-6.041-.204-12.134 0-18.227 0m20.02-68.915v.512H901.12c-4.096 0-6.144 1.536-7.27 5.427-1.383 4.762-2.868 9.472-4.199 14.285-.921 3.43-2.048 6.861-2.355 10.394s1.536 4.915 5.018 4.915c5.58-.051 11.161.154 16.69-.102 5.12-.154 10.24-.564 15.258-1.23 10.138-1.433 16.23-9.42 17.92-18.636 1.485-8.09-1.74-12.902-9.83-13.978-6.349-.87-12.8-1.075-19.149-1.536zM545.996 613.376c-8.704 0-17.306-.102-26.01 0-2.201 0-3.481-.922-4.25-2.918a22527 22527 0 0 0-29.9-79.668c-.615-1.587-1.536-3.43-2.867-4.3-3.021-1.997-6.656-.052-7.783 3.532l-10.342 33.946c-2.304 7.68-4.506 15.36-6.861 23.04a763 763 0 0 1-7.782 23.86 3.84 3.84 0 0 1-2.612 2.15 69 69 0 0 1-8.448.307l-36.044-.103c-1.076 0-2.202-.204-3.328-.256-2.304-.153-3.277-1.382-2.816-3.584a133 133 0 0 1 2.406-9.881c2.304-7.885 4.66-15.719 7.066-23.552 2.816-9.063 5.683-18.074 8.448-27.136l6.656-21.76 5.99-19.2c2.304-7.475 4.454-15.002 6.758-22.477 1.792-5.888 3.892-11.725 5.735-17.613 1.638-5.325 3.072-10.752 4.659-16.077l3.891-12.85c.615-1.946 2.048-2.868 4.096-2.868h48.64c1.536 0 2.663.41 3.328 2.1 2.355 6.348 4.864 12.594 7.27 18.943l13.364 35.226 9.83 26.419a12.8 12.8 0 0 0 1.639 3.226c2.764 3.635 6.656 3.328 8.652-.87 1.024-2.305 1.946-4.711 2.663-7.169 2.253-7.577 4.403-15.206 6.707-22.733a5702 5702 0 0 1 15.718-50.79c1.178-3.789 1.639-4.25 5.632-4.25 16.077-.05 32.256-.102 48.333-.05 2.355 0 3.994 1.535 3.635 3.89a55 55 0 0 1-1.894 7.936l-10.803 35.79c-3.84 12.39-7.783 24.78-11.571 37.17-2.407 7.834-4.608 15.719-6.964 23.552-3.225 10.496-6.553 20.89-9.728 31.335-2.816 9.062-5.478 18.125-8.243 27.187l-2.304 7.68c-.665 2.355-2.509 2.662-4.608 2.662h-25.958v.103zM269.568 435.968h23.194c3.84 0 5.58 2.406 4.403 6.144l-14.336 46.592c-4.403 14.387-8.704 28.774-13.056 43.213-1.895 6.297-3.789 12.595-5.427 18.944-2.56 9.881 3.02 22.118 14.694 23.859 11.315 1.69 22.118.717 31.693-6.144a39.63 39.63 0 0 0 15.257-19.814c3.43-10.24 6.4-20.685 9.626-30.976l8.704-27.034c1.638-5.325 3.072-10.752 4.71-16.18l7.168-23.142c1.23-3.89 2.458-7.782 3.584-11.724.768-2.765 1.844-3.687 4.66-3.687h48.384c3.072 0 4.966 2.304 4.096 5.223-3.38 11.264-6.861 22.374-10.24 33.587-3.584 11.622-6.912 23.296-10.548 34.867-4.505 14.54-8.704 29.184-14.028 43.418a80.4 80.4 0 0 1-14.95 25.241c-3.175 3.584-6.042 7.475-9.524 10.701a92.16 92.16 0 0 1-38.042 22.528c-16.742 4.608-33.792 5.837-51.097 4.506-7.322-.512-14.643-1.024-22.016-1.741a59 59 0 0 1-8.243-1.639 44.44 44.44 0 0 1-18.381-8.038 43.8 43.8 0 0 1-9.011-10.957 36.05 36.05 0 0 1-5.684-18.125c-.204-5.222.154-10.444.41-15.616.512-10.752 3.942-20.89 7.373-31.027 1.945-5.785 3.43-11.776 5.222-17.613 1.843-5.888 3.891-11.776 5.735-17.715 1.69-5.53 3.225-11.11 4.915-16.64 1.894-6.144 3.942-12.288 5.837-18.483 1.638-5.376 3.328-10.752 4.71-16.18 1.331-5.17 2.56-6.246 7.885-6.143h22.374v-.205zm-132.352-3.482c9.37.82 18.432 1.28 27.392 2.56 7.117 1.024 14.029 3.175 20.275 6.964 7.68 4.71 11.93 11.724 13.773 20.428 1.331 6.144 1.792 12.135.358 18.279-.614 2.56-1.382 4.198-4.352 4.352-5.222.205-10.393.819-15.616 1.126a1920 1920 0 0 1-29.747 1.536c-4.813.256-5.478-.46-6.144-5.12l-.512-4.352c-.717-6.246-4.25-10.035-10.137-11.776a31.59 31.59 0 0 0-26.47 2.919c-4.609 2.764-7.886 6.707-7.937 12.646-.051 3.328 1.28 5.888 4.096 7.168 3.943 1.69 8.039 3.072 12.288 4.25 4.352 1.28 8.96 2.048 13.312 3.379 8.192 2.406 16.384 4.761 24.423 7.629 10.29 3.584 19.302 9.318 25.292 18.688 2.663 3.942 4.096 8.55 4.096 13.312v.204c1.024 11.623-2.406 22.119-7.68 32.205-4.812 9.216-11.366 17.357-19.302 24.064-10.24 8.704-22.272 15.155-35.226 18.79a132.8 132.8 0 0 1-47.513 4.353c-6.81-.512-13.773-.512-20.48-1.792-11.52-2.15-22.938-5.12-30.72-15.156a30.05 30.05 0 0 1-6.298-14.643c-.768-6.349-.87-12.8-1.024-19.2 0-2.56.359-5.12 1.075-7.577.308-1.024 1.792-2.304 2.816-2.356 11.11-.87 22.221-1.484 33.28-2.15 4.813-.307 9.626-.768 14.388-1.024 3.276-.205 5.376 1.74 5.478 4.966.102 2.714 0 5.479.102 8.192.205 5.07 4.864 13.005 11.367 14.9 10.342 3.072 20.582 2.867 30.105-2.612 6.656-3.84 11.674-9.37 12.75-17.356.562-4.199-1.434-7.783-4.609-10.65a31.5 31.5 0 0 0-13.056-6.144c-8.294-2.458-16.64-4.506-24.883-7.014a77 77 0 0 1-22.733-10.599c-5.939-4.3-11.52-9.216-13.568-16.537a43.4 43.4 0 0 1-1.433-13.62c.563-10.854 4.812-20.428 11.264-29.03 6.041-8.192 13.414-15.002 22.323-20.122 9.42-5.376 19.353-9.625 30.105-11.161 9.728-1.383 19.559-2.048 29.133-2.919zm513.843 180.532h-40.397c-5.12-.103-6.4-1.946-4.915-7.168 2.202-7.476 4.608-14.95 6.963-22.426l6.298-20.787 7.168-23.552 9.933-32.256 8.857-28.928 8.295-27.443c1.126-3.636 2.355-7.27 3.43-10.957.717-2.355 2.15-3.43 4.66-3.38 5.631.103 11.161 0 16.742 0 24.883 0 49.766-.05 74.65.154 10.086.103 19.814 1.997 28.876 6.861a40.4 40.4 0 0 1 19.61 23.962c3.891 11.776 3.328 23.756 1.536 35.84-2.355 16.281-7.68 31.59-14.183 46.592a107.4 107.4 0 0 1-29.081 39.27 91.65 91.65 0 0 1-31.027 18.125c-13.67 4.505-27.648 6.451-41.882 6.4h-35.533zm61.184-137.524h-9.113c-2.15 0-3.328 1.178-3.943 3.072l-1.894 6.042c-1.639 5.632-3.175 11.162-4.864 16.742-2.304 7.578-4.813 15.053-7.168 22.63-2.97 9.626-5.837 19.252-8.704 28.878a832 832 0 0 0-4.455 15.001c-.614 2.253 1.434 5.325 3.738 5.479 10.547.768 21.043.512 31.386-1.536 10.188-1.946 17.356-8.602 22.886-16.948 4.608-7.014 7.885-14.745 10.496-22.732 3.891-11.879 7.424-23.757 7.117-36.506-.205-9.318-4.301-14.285-12.595-17.152a54.3 54.3 0 0 0-22.887-2.97"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/tdengine.svg b/docs/public/icons/database/tdengine.svg
new file mode 100644
index 0000000..9d20ae0
--- /dev/null
+++ b/docs/public/icons/database/tdengine.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#3578eb" d="M512 91.853c30.413 0 54.938 24.217 54.938 54.22S542.362 200.295 512 200.295a54.477 54.477 0 0 1-54.938-54.22A55.09 55.09 0 0 1 512 91.853m-362.854 258.56c30.412 0 54.937 24.166 54.937 54.17 0 30.003-24.525 54.271-54.937 54.271a54.477 54.477 0 0 1-54.887-54.272 55.81 55.81 0 0 1 54.887-54.22zm142.233 422.093c30.362 0 54.887 24.217 54.887 54.22s-24.525 54.221-54.887 54.221a54.477 54.477 0 0 1-54.937-54.22c0-30.004 24.524-54.221 54.937-54.221m441.293 0c30.362 0 54.886 24.217 54.886 54.22s-24.524 54.221-54.886 54.221a54.477 54.477 0 0 1-54.938-54.22c0-30.004 24.525-54.221 54.887-54.221zM592.384 412.314H431.616l-49.05 150.067L512 655.36l129.434-92.006-48.999-151.04zM436.48 399.77l55.91-170.445c-3.942-.973-8.806-1.895-12.748-3.84L422.81 399.77H236.442v12.544h181.401L370.79 554.65 223.693 449.126c-1.946 3.892-4.915 6.759-7.834 10.65l125.491 90.06 25.498 18.382-8.806 24.217-49.05 150.016c3.942 1.024 8.858 1.997 12.8 3.943l55.86-169.472 122.572 88.166-144.128 103.578c2.918 2.918 5.888 6.81 7.834 9.728L512 671.795l148.07 106.496a38 38 0 0 1 7.834-9.728l-145.1-104.55 122.572-88.064 5.888 16.384 50.995 154.01a48.8 48.8 0 0 1 12.749-3.892l-56.883-174.285 25.497-18.432 124.519-90.01c-2.919-2.918-4.864-6.758-7.834-10.649l-121.6 87.143-3.891 2.918-22.58 15.462-47.103-142.336h181.453v-13.516H600.218L543.386 224.46a49 49 0 0 1-12.75 3.84l55.911 170.445-150.016.972zm-217.702-48.436 220.672-158.77c1.945 3.84 4.864 6.758 7.833 9.676L225.638 361.984c-1.945-3.891-4.864-6.758-6.86-10.65m39.219 395.06-85.3-259.533c3.943-.922 7.834-2.867 11.777-3.84l86.272 259.481c-4.864.973-8.807 2.868-12.75 3.84zm388.352 83.25H378.624v-13.567H646.4v9.728c-1.024 1.894-1.024 2.867 0 3.84zm205.926-341.81-85.299 259.481a55.5 55.5 0 0 0-11.776-3.84l85.3-259.481c2.969.972 6.86 2.867 11.775 3.84m-266.752-295.27 220.672 158.77c-2.918 2.919-4.915 6.759-6.86 10.65L576.716 203.213c2.97-3.891 5.888-6.81 8.857-10.65zm289.28 157.798c30.464 0 54.938 24.217 54.938 54.272 0 29.952-24.525 54.17-54.887 54.17a54.477 54.477 0 0 1-54.937-54.222c0-30.003 24.525-54.22 54.937-54.22z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/tdsql.webp b/docs/public/icons/database/tdsql.webp
new file mode 100644
index 0000000..c6e6703
Binary files /dev/null and b/docs/public/icons/database/tdsql.webp differ
diff --git a/docs/public/icons/database/teradata.webp b/docs/public/icons/database/teradata.webp
new file mode 100644
index 0000000..cc35758
Binary files /dev/null and b/docs/public/icons/database/teradata.webp differ
diff --git a/docs/public/icons/database/tidb.svg b/docs/public/icons/database/tidb.svg
new file mode 100644
index 0000000..ee0b723
--- /dev/null
+++ b/docs/public/icons/database/tidb.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" class="icon" viewBox="0 0 1024 1024"><path fill="#e80230" d="M855.654 512.154c0 56.422-.153 112.896.256 169.267 0 9.062-2.713 13.773-10.854 17.92a74510 74510 0 0 0-321.024 169.984c-7.68 3.993-13.824 4.813-22.22.358a62695 62695 0 0 0-323.84-170.7c-7.527-3.943-9.882-8.602-9.882-17.05.256-113.255.256-226.56 0-339.866 0-8.448 2.713-13.107 10.035-16.998A92518 92518 0 0 0 501.914 154.47c7.526-3.993 13.21-4.352 20.992-.256A65522 65522 0 0 0 847.462 326.4c7.783 4.096 8.295 9.267 8.295 16.538a25193 25193 0 0 0-.103 169.216M489.472 727.552V709.12c0-101.888.154-203.776-.358-305.664 0-11.622 2.713-17.971 13.363-23.194 28.774-14.182 56.832-29.696 85.248-44.697 3.174-1.946 6.246-4.096 9.216-6.349-27.648-14.643-53.402-28.672-79.616-41.83-3.482-1.741-9.728-.666-13.568 1.33a21905 21905 0 0 0-166.81 87.604c-13.517 7.168-32 11.878-38.502 23.398-6.912 12.186-2.355 31.13-2.714 47.104-.153 13.517 0 26.983 0 42.701l107.879-56.73v16.897c0 73.37 0 146.79.153 220.262 0 4.915 1.331 12.493 4.455 14.285 25.958 14.54 52.377 28.057 81.254 43.213zm85.248-22.528c4.915-2.15 8.397-3.43 11.674-5.12 20.787-11.008 41.37-22.323 62.464-32.666 8.857-4.352 12.185-9.523 12.134-19.814-.41-81.664-.205-163.328-.205-245.094 0-4.352-.46-8.704-.717-14.95-25.753 13.567-49.766 26.93-74.393 38.911-8.96 4.352-11.11 9.882-11.06 19.098.257 64.717 0 129.433 0 194.048.103 21.197.103 42.291.103 65.536v.102z"/></svg>
\ No newline at end of file
diff --git a/docs/public/icons/database/trino.svg b/docs/public/icons/database/trino.svg
new file mode 100644
index 0000000..073e72d
--- /dev/null
+++ b/docs/public/icons/database/trino.svg
@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200" viewBox="0 0 200 200">
+  <rect width="200" height="200" rx="36" fill="#dd00a1"/>
+  <text x="100" y="118" font-family="system-ui, -apple-system, sans-serif" font-size="72" font-weight="700" fill="white" text-anchor="middle" letter-spacing="-1">TR</text>
+</svg>
diff --git a/docs/public/icons/database/turso.png b/docs/public/icons/database/turso.png
new file mode 100644
index 0000000..d78843d
Binary files /dev/null and b/docs/public/icons/database/turso.png differ
diff --git a/docs/public/icons/database/vastbase.png b/docs/public/icons/database/vastbase.png
new file mode 100644
index 0000000..1007b05
Binary files /dev/null and b/docs/public/icons/database/vastbase.png differ
diff --git a/docs/public/icons/database/vertica.webp b/docs/public/icons/database/vertica.webp
new file mode 100644
index 0000000..0ec01a3
Binary files /dev/null and b/docs/public/icons/database/vertica.webp differ
diff --git a/docs/public/icons/database/weaviate.png b/docs/public/icons/database/weaviate.png
new file mode 100644
index 0000000..8159f50
Binary files /dev/null and b/docs/public/icons/database/weaviate.png differ
diff --git a/docs/public/icons/database/xugu.png b/docs/public/icons/database/xugu.png
new file mode 100644
index 0000000..e564ac2
Binary files /dev/null and b/docs/public/icons/database/xugu.png differ
diff --git a/docs/public/icons/database/yashandb.png b/docs/public/icons/database/yashandb.png
new file mode 100644
index 0000000..ef3ab69
Binary files /dev/null and b/docs/public/icons/database/yashandb.png differ
diff --git a/docs/public/icons/database/zookeeper.svg b/docs/public/icons/database/zookeeper.svg
new file mode 100644
index 0000000..7d0da94
--- /dev/null
+++ b/docs/public/icons/database/zookeeper.svg
@@ -0,0 +1,19 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="45.02 22.32 53.115 57.774"><style><![CDATA[.I{stroke-width:.5}.J{stroke-miterlimit:10}.K{stroke:#000}.L{fill:none}.M{fill:#f9c89a}.N{fill:#4f2e0e}.O{fill:#6d9758}.P{stroke-width:.1}]]></style><g transform="matrix(.159884 0 0 .159884 34.20631 17.28392)"><g class="K I"><ellipse cx="299.73" cy="339.813" rx="10.957" ry="5.14" fill="#331e09"/><g stroke-miterlimit="10"><path d="M217.706 319.453s4.363 18.614 4.944 24.142 11.635 8.145 12.798 1.745 5.236-22.105 5.236-22.105zm69.518 4.072s5.816 13.962 5.816 21.814 13.96 9.017 15.125 3.78 2.908-25.887 2.908-25.887z" class="M"/><path d="M234.77 336.03c-2.327.97-8.92 1.746-11.44.777s.195 9.113.97 12.217 8.92 2.52 8.92 2.52z" fill="#a15813"/></g><g class="N"><ellipse cx="220.979" cy="344.03" rx="4.872" ry="11.636"/><ellipse cx="236.249" cy="345.268" rx="5.018" ry="11.416"/></g><g stroke-miterlimit="10"><path d="M202.145 377.77L202 364.1c-.145-7.562 7.854-17.16 24.142-16.725s23.85 9.453 23.85 18.18-.728 15.707-1.6 17.452-42.6 2.327-44.2.728-2.036-5.964-2.036-5.964z" fill="#9e5613"/><path d="M202.145 389.55c-2.763-.727-3.78-3.636-3.927-6.398s2.182-5.1 3.927-5.382c1.308 1.746 3.926 2.474 6.253 2.9s32.14.727 35.63.436 4.363-2.326 4.946-3.197c2.473.87 3.5 3.488 3.635 5.96s-1.018 4.8-3.5 5.673-15.562 2.9-24.578 2.763-22.396-2.764-22.396-2.764z" class="N"/><path d="M310.638 342.43s-7.854 4.653-17.9 1.164c-6.544-.873-8.3-.873-8.145 2.327s1.02 11.926-2.035 15.56-6.255 13.1-1.6 17.452 71.988 3.927 74.607 3.2 4.218-5.382 4.218-5.382.87-9.9.58-15.124-7.562-14.834-19.925-14.397-17.45 9.162-22.978 10.325c-4.654-4.362-6.4-9.452-6.4-10.472s-.434-4.653-.434-4.653z" fill="#9e5613"/><path d="M295.585 358.355c4.363 0 7.5-1.963 7.854-6.472s-.727-6.98-3.928-7.198-7.126-.873-9.016-2.108-2.1-3.5-1.3-4.437 2.18-1.817 2.18-1.817l-.5-1.38s-7.2 2.763-6.544 10.47 4.508 12.943 11.27 12.943zm7.927-13.67c2.398.945 2.907 2.764 2.545 4.727s-1.164 7.636 2.98 7.417 5.236-8.3 4.873-11.998-2.764-7.272-3.854-8.145l-.218 1.1s.824.58.85 2.036-2.45 4.216-7.175 4.872z" class="N"/><path d="M317.473 357.556c-2.23 4.85-4.363 20.363-2.424 24.626" class="L"/><path d="M280.97 378.935s-3.346 2.036-3.054 5.234 2.763 3.928 6.4 4.8 38.103 1.9 44.356 2.18 27.632-1.3 31.268-2.763 6.836-7.854-.145-11.636c-2.765 3.055-4.945 3.637-9.454 4.22s-25.597.727-34.322.436l-31.995-.727c-2.18-.146-3.053-1.745-3.053-1.745z" class="N"/></g><g stroke-miterlimit="10" class="M"><path d="M265.554 115.412c-1.02 1.163-5.817 6.7-3.5 11.343s15.56 25.015 15.56 25.015 29.232-14.834 28.36-21.815-6.836-15.27-6.836-15.27zm71.9 105.63c.97-.97 3.1-5.72-2.618-7.466-4.556-.582-7.853 1.552-8.822 2.62s2.035 6.787 3.877 6.98 7.563-2.133 7.563-2.133z"/><path d="M341.42 226.28c.873-1.26 2.715-4.46-1.55-6.593s-9.988.098-11.442 2.327 2.424 7.175 3.2 7.175 9.792-2.9 9.792-2.9z"/><path d="M331.87 202.816l-5.38 9.454s3.005 3.927 4.168 8.87-.776 6.7.872 6.4 11.248-2.908 13.1-1.746 4.363 5.915 2.618 9.114-6.787 9.792-13.865 11.538-15.608-1.455-18.8-5.915-8.24-18.8-8.436-21.33 3.2-10.18 3.2-10.18l13.186-5.914z"/><path d="M325.035 211.542c2.423 1.357 6.303 4.363 7.27 9.502s-1.066 11.635-4.362 14.35"/><path d="M341.7 234.423s-2.328 3.298-7.758 2.52-5.04-7.562-2.424-9.404 6.786-3.296 9.6-2.812 4.167 1.745 4.167 1.745"/><path d="M334.343 228.897l2.617 4.848s-1.65 1.357-3.588.484-1.94-2.327-1.455-3.587 2.426-1.745 2.426-1.745z"/></g><g stroke-miterlimit="10" class="O"><path d="M314.466 123.992s10.764 5.672 12.5 12.653c5.235 1.745 11.392 9.428 10.8 15.052 5.623 2.327 8.12 5.587 8.12 9.27 3.104 2.715 7.744 9.678 2.12 19.76s-8.927 17.055-8.927 17.055l-22.495-1.944-1.94-6.8 10.47-19.392s-4.654-7.562-10.085-7.757c-1.356 5.817-2.714 14.155-2.714 14.155l.58 31.995-2.908 1.745-.582 7.175 7.175 14.93 2.52 2.327-6.594 10.278 1.553 2.9 8.92 21.912-.194 2.715 5.237 6.786-.195 2.908 2.9 7.175-5.624 12.798-3.5 6.98 3.297 10.083s-9.113 8.34-24.24 8.145-25.4-7.95-25.4-7.95l-2.908-1.744s3.297-19.002 2.52-29.668-3.104-26.76-3.104-30.444-.97-14.155-.97-14.155l-1.553 33.546c-.193 11.247-1.745 26.565-3.683 29.667s-4.072 4.072-4.072 4.072l2.132 3.686.582 4.458-2.327 2.9-4.267-1.165s-8.337 9.697-23.462 7.953-24.432-9.308-25.402-15.514c-3.5-2.52-3.878-4.266-3.878-4.266l9.9-11.44-5.624-3.296 4.654-8.34s3.297-8.145 3.878-10.86 2.327-9.307 2.327-9.307l-4.848.193 7.95-12.4-.58-8.533 14.542-30.83-.582-5.042-1.95-2.715-1.587-10.762 1.02-5.818s5.03-6.107 5.6-11.15-2.417-10.083-2.417-10.083l-33.98 22.3-4.87.388-13.973 6.205-3.303-1.358s-1.166-1.938-1.554-5.04-.001-17.064 1.162-19.003 3.877-1.94 3.877-1.94 4.46-.775 7.95-3.103 25.014-18.228 30.25-22.3 23.463-19.778 23.463-19.778 6.205-4.848 9.695-6 5.815-.97 5.815-.97l.195 16.677 15.706 17.8 17.065-10.23 13.574-12.604z"/><path d="M262.936 115.993l-2.327 1.455-10.036 16.724 10.9 1.02-3.927 7.562 20.65 10.907 1.744-2.036-14.98-18.47c-3.5-4.363-4.5-14.107-.582-16.725s-1.453-.437-1.453-.437"/><path d="M272.242 155.915l31.196-5.2-3.673-13.3 13.344 1.7 1.164-15.417-13.816-8.87-1.3-.145s3.346 4.363 3.5 9.744-4.798 9.453-8.87 12.943l-21.525 18.543zm21.668 10.688l20.652-6.834 2.182 11.052-19.343 12.362zm-22.297-10.325l.776 45.18-3.493 12.798-.2 12.4-.582 12.216 2.715 4.072 7.368-1.746m13.573-28.696l-11.44-.97.774 5.43 11.443 2.132z"/><path d="M310.008 209.797l-10.084 2.52 1.357 6.786 8.145-2.132m-51.386-6.786l8.726.775.386 6.98-10.276-.97zm-21.525-1.745l12.604.388-.582 7.174-11.44-1.745m4.848-55.07l-4.848 8.726 21.135 16.482 6.4-15.707zm97.342 43.483s0-6.254 1.9-8.726c-4.654-2.037-15.852-6.544-21.96-5.817-2.9 3.5-8.094 13.67-6.302 19.924 6.737-2.327 26.37-5.38 26.37-5.38zm-147.032-37.085l6.7 9.744 4.218 10.908s-2.618 3.635-5.526 4.944-13.283 5.624-13.283 5.624l-3.296-1.358s3.054-1.938 3.5-13-2.326-12.507-2.326-12.507l6.544-2.473zm98.75 102.53s4.217 14.688 10.326 24.143c3.053-2.035 24.287-3.5 29.426-3.345"/></g><g stroke-miterlimit="10"><path d="M209.174 293.566c3.878 1.018 20.312 3.344 20.312 3.344s8.872 2.182 13.67.146c2.472-5.527 9.9-31.123 9.9-31.123s-7.126-8.3-13.525-9.598-16.433-4.8-16.433-4.8" class="L"/><path d="M220.033 265.062c3.5-.437 20.796 0 30.686 7.125" class="O"/><path d="M214.797 296.862l2.764 9.647" class="L"/><path d="M209.416 312.472c6.544 4.653 23.706 13.963 46.83 3.637" class="O"/><path d="M276.025 319.308c7.997 3.198 27.775 4.07 38.103-1.745" class="L"/></g><g stroke-miterlimit="10" class="O"><path d="M310.056 315.963c10.324 3.345 25.306 3.927 27.05.3S321.64 308.7 321.64 308.7"/><path d="M302.202 309.418c12.65 1.9 26.905-.582 26.905-4.945s-19.488-3.78-19.488-3.78m3.926-53.666c4.22 5.1 7.418 9.9 11.054 11.054-8.726 1.454-29.668 5.817-32.868 9.45-1.453-3.344-2.617-5.1-4.507-6.398 3.78-5.1 26.32-14.107 26.32-14.107z"/></g><path d="M183.093 172.7c-5.236-.582-15.998-2.763-19.924-12.943-2.472-5.1-6.544-5.962-8.435-7.272-2.473-2.18-5.963-3.78-10.908-3.054s-12.798-.437-17.743-3.345-10.18-1.018-11.925 1.455-1.9 5.962-.146 7.853l2.9 3.055s-6.835 1.018-7.417 6.108 3.054 7.562 5.38 8.58 4.363 1.164 4.363 1.164-2.617 3.5-.727 6.834 6.545 4.8 6.545 4.8 2.18 3.054 4.508 3.5 16.434 1.164 16.434 1.164 5.816-2.18 9.162-2.472 11.198-.437 13.816.727 14.107 1.454 14.107 1.454 1.454-6.254 1.3-9.6-1.308-8-1.308-8z" class="J M"/></g><linearGradient id="A" gradientUnits="userSpaceOnUse" x1="103.3" y1="357.36" x2="179.524" y2="357.36"><stop offset="0" stop-color="#442b1f"/><stop offset="1" stop-color="#442b1f"/></linearGradient><path d="M162.055 327.5c-7.95.775-50.222-.582-58.754-5.624.582 29.087 8.726 54.876 13.96 60.5s21.524 10.47 38.395 10.47 27.212-5.067 22.88-11.828c-12.8-19.973-16.483-53.52-16.483-53.52z" fill="url(#A)"/><linearGradient id="B" gradientUnits="userSpaceOnUse" x1="131.029" y1="233.936" x2="143.5" y2="233.936"><stop offset="0" stop-color="#c8b091"/><stop offset=".199" stop-color="#c5a788"/><stop offset=".529" stop-color="#bc8e6e"/><stop offset=".948" stop-color="#ad6745"/><stop offset=".994" stop-color="#ab6240"/></linearGradient><path d="M143.5 363.373V104.5h-12.47l.313 222.514c0 11.053.314 19.196 1.57 23.852s5.293 10.762 7.177 11.634 3.412.873 3.412.873z" fill="url(#B)" class="J K"/><linearGradient id="C" gradientUnits="userSpaceOnUse" x1="131.998" y1="341.231" x2="142.76" y2="341.231"><stop offset="0" stop-color="#88786f"/><stop offset=".105" stop-color="#806f66"/><stop offset=".281" stop-color="#6b574c"/><stop offset=".503" stop-color="#493023"/><stop offset=".622" stop-color="#34180a"/><stop offset="1" stop-color="#3e2316"/></linearGradient><path d="M142.663 332h-10.665s0 15.88 1.357 18.207l9.405.253z" fill="url(#C)"/><g stroke-miterlimit="10" class="I K M"><path d="M127.345 163.938s-3.2 5.526-3.006 7.27 6.206.486 6.593-1.745-3.587-5.526-3.587-5.526zm3.1 25.8c2.62.145 7.417.437 9.163-1.892s5.962-4.508 5.962-7.125-.727-4.072-3.344-6.108-15.416 2.9-16.144 4.217-1.745 4.945-1.308 5.963 1.308 2.9 2.617 3.78 3.054 1.164 3.054 1.164z"/><path d="M138 178.965l3.5 2.472s3.5-2.763.292-4.8-4.072 1.018-4.072 1.018z"/><path d="M123.078 185.267c1.745.485 1.553 1.65 6.012.485s9.5-5.042 10.956-8.532-6.7-9.2-10.083-8.435-9.2 3.587-10.714 5.526-1.793 5.72-.824 7.174 4.653 3.782 4.653 3.782zm15.802-27.05c-1.066-1.55-2.132-4.654-3.5-5.527s-5.816-4.363-7.174-5.235-5.527-4.072-9.114-3.103-6.883 3.006-6.4 7.853 3.587 5.333 5.235 6.98 3.976 3.976 5.333 4.75 5.235 2.618 8.144 2.9 5.72-1.552 6.787-3.394.678-5.235.678-5.235z"/><path d="M133.162 155.3l-4.944 8.144s5.396 2 7.368-.97c2.714-4.072-2.424-7.174-2.424-7.174z"/><path d="M146.008 150.897c-4.364 1.3-15.27 11.343-17.452 16.725s-1.454 10.035 2.9 11.78 10.762-2.18 12.507-5.38 4.508-13.525 4.508-13.525m-17.054 8.3l9.792 4.944s-1.455 2.714-4.46 3.103-6.398-2.036-6.496-4.072 1.163-3.975 1.163-3.975zm14.93-.873c.97 1.745 6.302 6.787 9.2 7.078m-.862 13.185c2.036-.484 3.394-1.648 4.654-2.618"/></g><linearGradient id="D" gradientUnits="userSpaceOnUse" x1="277.188" y1="161.441" x2="284.604" y2="161.441"><stop offset="0" stop-color="#f8fb9b"/><stop offset=".126" stop-color="#f5f892"/><stop offset=".334" stop-color="#efef78"/><stop offset=".601" stop-color="#e3e14f"/><stop offset=".911" stop-color="#d4ce16"/><stop offset="1" stop-color="#cfc804"/></linearGradient><g class="K"><circle cx="280.896" cy="161.441" r="3.708" fill="url(#D)" class="I"/><circle cx="280.871" cy="161.417" r="2.908" class="L P"/></g><linearGradient id="E" gradientUnits="userSpaceOnUse" x1="276.025" y1="182.383" x2="283.44" y2="182.383"><stop offset="0" stop-color="#f8fb9b"/><stop offset=".126" stop-color="#f5f892"/><stop offset=".334" stop-color="#efef78"/><stop offset=".601" stop-color="#e3e14f"/><stop offset=".911" stop-color="#d4ce16"/><stop offset="1" stop-color="#cfc804"/></linearGradient><g class="K"><circle cx="279.733" cy="182.383" r="3.708" fill="url(#E)" class="I"/><circle cx="279.708" cy="182.358" r="2.909" class="L P"/></g><linearGradient id="F" gradientUnits="userSpaceOnUse" x1="274.86" y1="203.325" x2="282.278" y2="203.325"><stop offset="0" stop-color="#f8fb9b"/><stop offset=".126" stop-color="#f5f892"/><stop offset=".334" stop-color="#efef78"/><stop offset=".601" stop-color="#e3e14f"/><stop offset=".911" stop-color="#d4ce16"/><stop offset="1" stop-color="#cfc804"/></linearGradient><g class="K"><circle cx="278.569" cy="203.325" r="3.709" fill="url(#F)" class="I"/><circle cx="278.545" cy="203.301" r="2.909" class="L P"/><path d="M251.542 77.454l-3.2-.873s-1.745.388-1.552 1.262 1.455 1.94 1.357 3.5-.3 4.556.875 6.496 3.975 4.848 5.43 5.623 1.842-.388 1.842-.388 1.356 13.96 1.746 15.416 2.424 5.042 5.72 7.854 8.92 9.2 11.538 11.15 11.246 3.588 14.93-.194 11.635-12.507 12.507-13.768 3.393-4.266 3.297-5.43-.484-13.574-.484-14.06c.58.194 1.84-.484 2.52-1.066s4.945-5.236 4.85-7.272-1.358-7.66-.872-8.047 1.162-1.94.3-2.327-6.012 3.393-6.012 3.393-1.042-13.258-5.815-16.676-43.438-5.817-45.764-2.715-3.204 18.132-3.204 18.132z" class="I J M"/></g><path d="M258 88.797l.457 4.75-1.132-2.472-1.68-6.666-5.053-7.356L250 66.4v-2.036l14.006-4.557-4.05 6.1-3.092 9.598-.158 4.46L258 82.302z"/><path d="M309.328 71.5c10.035 6.544-3.054 4.654-13.815 1.018s-32.286-9.9-37.232-10.035 32.724-3.055 38.54-1.164 12.507 10.18 12.507 10.18z" fill="#161616" class="I J K"/><linearGradient id="G" gradientUnits="userSpaceOnUse" x1="280.96" y1="69.02" x2="280.96" y2="31.748"><stop offset=".372" stop-color="#1d2739"/><stop offset=".994" stop-color="#1d2739"/></linearGradient><g stroke-miterlimit="10" class="I K"><path d="M247.568 61.263c-12.4-6-12.4-13.767.776-22.105s37.23-8.726 48.476-5.624 28.698 14.155 26.566 25.015c-2.132 8.337-11.83 10.47-11.83 10.47z" fill="url(#G)"/><path d="M248.684 65.383l-1.456-6.544c17.9-10.617 50.9-10.908 65.735 7.126-.437 1.308-2.326 4.508-3.636 5.526-25.45-18.906-60.643-6.108-60.643-6.108z" fill="#03468b"/></g><path d="M275.007 56.657l6.688.873-.3 1.744-11.925-1.017 8.727-7.854-5.964-.3.147-1.9 10.906 1.3zm17.523-5.6c3.272 1.9 4.364 4.944 3.2 7.562s-5.382 2.835-7.198 2.254-6.037-3.345-4.072-7.708c1.308-2.544 4.798-4 8.07-2.108zm-5.94 3.288c-1.205 2.677 1.383 4.372 2.5 4.73s3.702.222 4.416-1.382.046-3.48-1.964-4.64-4.15-.268-4.95 1.294zm16.982-.007c3.012 1.603 4.454 4.764 3.977 7.76s-3.88 3.804-5.472 3.42-5.53-2.804-4.714-7.798c.6-2.936 3.196-4.987 6.2-3.382zm-4.256 4.37c-.504 3.065 1.918 4.55 2.9 4.786s3.063-.262 3.357-2.098-.6-3.777-2.44-4.763-3.435.273-3.808 2.075z" fill="#fff"/><path d="M303.187 73.48l1.277 6.787-1.8 4.945.336 5.43v2.8l1.6-2.327.663-8.144 3.045-5.526.262-3.2z"/><g stroke-miterlimit="10" class="K L"><path d="M300.7 81.624c-.97-.583-3.394-2.9-4.557-2.9s-4.364.97-5.817 1.066-5.914 1.84-6.303 2.23m-9.986.195c-.97 0-3.878-.97-4.46-1.26s-3.5-.194-3.5-.194l-2.23-1.455-3.006 2.812"/><path d="M275.782 85.016c.68.388 2.23 2.52 2.135 3.684s-1.747 12.313-1.553 12.604 3.78.872 4.267.485m2.617-1.163c.68-.097 1.552-.3 2.23.582M273.65 86.76c-1.647-3.5-8.34-3.5-10.86.098m23.367.194c.774-4.265 10.567-5.138 12.7-.872" class="I"/></g><ellipse cx="268.414" cy="86.713" rx="3.006" ry="2.375"/><ellipse cx="292.119" cy="85.744" rx="3.151" ry="2.472"/><g stroke-miterlimit="10" class="I K"><path d="M269.867 107.995c4.655 5.914 18.52 5.72 21.695-.97-1.067.3-2.752.92-2.752.92s-5.758.243-7.018.922c-.87 0-2.035.193-2.035.193s-5.72-.776-6.594-.193-3.296-.873-3.296-.873z" fill="#d8d8d8"/><path d="M288.3 112.648c-3.104 3.684-11.054 3.587-14.253.775" class="L"/></g><path d="M289.017 85.355l3.586.437-3.054 1.357c-.58-.58-.532-1.794-.532-1.794zm-23.27 1.165l3.586.437-3.053 1.358c-.582-.583-.533-1.795-.533-1.795z" fill="#fcfcfc"/><path d="M309.9 79.2c-.653 1.163-2.544 3.563-2.7 4.726s.8 4.145.728 4.727m1.162-2.183c-.146-.8-.655-2.98-1.455-3.418m-58.08-3.926c.728 1.02 4.436 4.072 4.58 5.3s-.8 3.127-.5 4.217 1.02 2.763 1.02 2.763m-2.4-3.854c-.22-1.163.072-3.7 1.162-4" class="I J K L"/></g></svg>
\ No newline at end of file
diff --git a/docs/public/icons/platform/linux.svg b/docs/public/icons/platform/linux.svg
new file mode 100644
index 0000000..efafa8e
--- /dev/null
+++ b/docs/public/icons/platform/linux.svg
@@ -0,0 +1,15 @@
+<svg width="32" height="32" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M12.2665 9.498L12.3491 11.3984L11.0271 13.8771L8.96146 17.9257L8.54834 21.3134L10.0356 26.1056L13.4232 28.006H18.546L23.3382 24.3705L25.4865 18.6694L20.529 12.6377L19.1243 9.25012L12.2665 9.498Z" fill="#ECEFF1"/>
+<path d="M23.9993 14.2076C22.6773 12.3072 21.6032 11.1505 21.0248 8.75436C20.4464 6.35824 21.1901 7.01924 20.6943 4.95362C20.4464 3.87949 20.0333 3.13587 19.6202 2.55749C19.1244 1.97912 18.5461 1.64862 18.2156 1.56599C17.4719 1.15287 15.7368 0.491866 13.5886 1.64862C11.3577 2.80537 11.6056 5.28412 12.0187 10.3242C12.0187 10.6547 11.9361 11.0679 11.7708 11.3984C11.4403 12.142 10.8619 12.803 10.3662 13.3814C9.78781 14.2076 9.20943 15.0339 8.79631 15.9427C7.80481 17.8431 6.89593 20.2392 7.14381 21.1481C7.55693 21.0655 12.7623 28.9975 12.7623 29.1627C13.0928 29.0801 14.4974 29.0801 15.7368 29.0801C17.4719 28.9975 18.4634 28.9149 19.8681 29.2454C19.8681 28.9975 19.7854 28.7496 19.7854 28.5017C19.7854 28.006 19.8681 27.5929 19.9507 27.0145C20.0333 26.6014 20.1159 26.1882 20.1986 25.6925C19.3723 26.4361 17.8851 27.2624 16.4804 27.5102C15.2411 27.7581 13.1754 27.345 12.1839 26.1056C12.2666 26.1056 12.4318 26.1056 12.5144 26.023C12.7623 25.9404 13.0102 25.8577 13.0928 25.6925C13.3407 25.2794 13.1754 24.8662 13.0102 24.6184C12.8449 24.3705 11.6056 23.4616 11.0272 22.9659C10.4488 22.4701 10.1183 22.2222 9.78781 21.8917C9.78781 21.8917 9.29206 21.396 9.12681 21.2307C8.96156 21.0655 8.87893 20.9002 8.79631 20.8176C8.63106 20.4045 8.54843 19.9087 8.63106 19.2477C8.71368 18.3389 9.04418 17.5952 9.45731 16.769C9.62256 16.4385 10.0357 15.7775 10.0357 15.7775C10.0357 15.7775 8.63106 19.2477 9.37468 20.3219C9.37468 20.3219 9.45731 19.2477 9.78781 18.1736C10.0357 17.43 10.4488 16.3559 10.9446 15.7775C11.4403 15.1991 12.6797 13.0509 12.7623 11.7289C12.7623 11.1505 12.8449 10.5721 12.8449 10.159C12.5144 9.82849 18.2982 9.00224 18.6287 9.91112C18.7113 10.2416 19.8681 13.2161 20.5291 14.786C20.8596 15.5296 21.2727 16.1906 21.5206 17.0169C21.7684 17.9257 21.9337 19.1651 21.9337 20.4045C21.9337 20.6524 21.9337 21.0655 21.8511 21.4786C22.0163 21.4786 25.2387 18.0084 21.4379 15.1165C21.4379 15.1165 23.7514 16.1906 23.8341 18.3389C23.9167 20.074 23.1731 21.4786 23.0078 21.7265C23.0904 21.7265 24.7429 22.4701 24.8256 22.4701C25.1561 22.4701 25.8171 22.2222 25.8171 22.2222C25.8997 21.9744 26.1476 21.3134 26.1476 21.0655C26.7259 19.1651 25.3213 16.108 23.9993 14.2076Z" fill="#263238"/>
+<path d="M13.5058 8.75434C14.099 8.75434 14.5799 8.01449 14.5799 7.10184C14.5799 6.18919 14.099 5.44934 13.5058 5.44934C12.9125 5.44934 12.4316 6.18919 12.4316 7.10184C12.4316 8.01449 12.9125 8.75434 13.5058 8.75434Z" fill="#ECEFF1"/>
+<path d="M17.224 8.91965C17.9997 8.91965 18.6286 8.06882 18.6286 7.01927C18.6286 5.96972 17.9997 5.1189 17.224 5.1189C16.4482 5.1189 15.8193 5.96972 15.8193 7.01927C15.8193 8.06882 16.4482 8.91965 17.224 8.91965Z" fill="#ECEFF1"/>
+<path d="M14.1058 7.2149C14.0371 6.67164 13.7246 6.26371 13.4077 6.30377C13.0908 6.34382 12.8895 6.8167 12.9582 7.35996C13.0269 7.90322 13.3394 8.31116 13.6563 8.2711C13.9732 8.23104 14.1745 7.75817 14.1058 7.2149Z" fill="#212121"/>
+<path d="M17.1417 8.42388C17.598 8.42388 17.9679 7.94298 17.9679 7.34976C17.9679 6.75654 17.598 6.27563 17.1417 6.27563C16.6854 6.27563 16.3154 6.75654 16.3154 7.34976C16.3154 7.94298 16.6854 8.42388 17.1417 8.42388Z" fill="#212121"/>
+<path d="M28.1305 25.5272C27.8 25.3619 27.2216 25.1141 26.7259 24.3704C26.478 23.9573 26.5606 22.8006 26.1475 22.3048C25.8996 21.9743 25.5691 22.1396 25.4865 22.1396C24.7429 22.3048 23.0077 23.4616 21.851 22.1396C21.6857 21.9743 21.4379 21.7264 21.0247 21.7264C20.6116 21.7264 20.4464 21.8917 20.2811 22.2222C20.1159 22.5527 20.1159 22.8006 20.1159 23.6268C20.1159 24.2878 20.1159 25.0314 20.0332 25.6098C19.868 27.0144 19.6201 27.8407 19.6201 28.6669C19.6201 29.5758 19.868 30.1542 20.1985 30.4021C20.4464 30.6499 20.8595 30.8152 21.7684 30.8152C22.6772 30.8152 23.2556 30.4847 23.834 29.9063C24.2471 29.4932 24.5776 29.3279 25.7344 28.5017C26.6432 27.9233 28.0479 27.1797 28.2957 26.9318C28.461 26.7666 28.7089 26.6839 28.7089 26.1882C28.7089 25.7751 28.3784 25.6098 28.1305 25.5272Z" fill="#FFC107"/>
+<path d="M11.5232 25.775C10.6969 24.453 10.6143 24.2052 10.0359 23.3789C9.54016 22.5527 8.46603 20.9828 7.80503 20.9828C7.30928 20.9828 7.06141 21.2307 6.73091 21.5612C6.40041 21.8917 6.06991 22.6353 5.49153 23.0484C4.99578 23.4615 3.59116 23.3789 3.26066 23.8747C2.93016 24.3704 3.59116 25.114 3.59116 26.3534C3.59116 26.8492 3.17803 27.1797 3.09541 27.5102C3.01278 27.9233 2.93016 28.1712 3.09541 28.5017C3.42591 28.9974 3.83903 29.1627 6.64828 29.741C8.13553 30.0715 9.54016 30.8978 10.449 30.9804C11.3579 31.063 12.9278 30.9804 12.9278 28.7495C13.0104 27.4275 12.2668 27.097 11.5232 25.775Z" fill="#FFC107"/>
+<path d="M13.093 10.8199C12.5972 10.4894 12.1841 10.1589 12.1841 9.66318C12.1841 9.16743 12.5146 9.00218 13.0103 8.58905C13.093 8.50643 14.0018 7.68018 14.9107 7.68018C15.8196 7.68018 16.8937 8.25855 17.3068 8.4238C18.0505 8.58905 18.7941 8.7543 18.7115 9.33268C18.6288 10.1589 18.5462 10.3242 17.72 10.7373C17.1416 10.9026 16.0675 11.8114 15.3238 11.8114C14.9933 11.8114 14.4976 11.8114 14.1671 11.7288C13.9192 11.6462 13.5061 11.233 13.093 10.8199Z" fill="#FFC107"/>
+<path d="M12.9276 10.159C13.0928 10.3242 13.3407 10.4895 13.5886 10.5721C13.7538 10.6547 14.0017 10.7374 14.0017 10.7374C14.3322 10.7374 14.5801 10.7374 14.7453 10.7374C15.1585 10.7374 15.7368 10.5721 16.3152 10.2416C16.8936 9.99373 16.9762 9.82848 17.3893 9.66323C17.8025 9.41535 18.2156 9.16748 18.0503 9.08485C17.8851 9.00223 17.7198 9.08485 17.1415 9.41535C16.6457 9.74585 16.2326 9.9111 15.7368 10.159C15.489 10.2416 15.1585 10.4069 14.9106 10.4069C14.6627 10.4069 14.4148 10.4069 14.167 10.4069C13.9191 10.4069 13.7538 10.3242 13.506 10.2416C13.3407 10.159 13.2581 10.0764 13.1755 10.0764C13.0102 9.99373 12.6797 9.66323 12.5145 9.5806C12.5145 9.5806 12.3492 9.5806 12.4318 9.66323C12.6797 9.9111 12.7623 9.99373 12.9276 10.159Z" fill="#634703"/>
+<path d="M15.4062 8.34114C15.4889 8.50639 15.6541 8.50639 15.7367 8.58901C15.8194 8.67164 15.902 8.67164 15.902 8.67164C15.9846 8.58901 15.902 8.42376 15.8194 8.42376C15.8194 8.25851 15.4062 8.25851 15.4062 8.34114Z" fill="#634703"/>
+<path d="M14.084 8.50642C14.084 8.58904 14.2492 8.67167 14.2492 8.58904C14.3319 8.50642 14.4145 8.42379 14.4971 8.42379C14.6624 8.34117 14.5797 8.25854 14.3319 8.25854C14.1666 8.34117 14.1666 8.42379 14.084 8.50642Z" fill="#634703"/>
+<path d="M22.0991 23.131C22.0991 23.2136 22.0991 23.2963 22.0991 23.3789C22.2643 23.7094 22.6774 23.792 23.0079 23.792C23.5037 23.792 23.9994 23.4615 24.2473 23.131C24.2473 23.0484 24.3299 22.9658 24.4126 22.8831C24.5778 22.6353 24.6604 22.47 24.7431 22.3874C24.7431 22.3874 24.6604 22.3048 24.6604 22.2221C24.5778 22.0569 24.3299 21.8916 23.9994 21.809C23.7516 21.7264 23.3384 21.6438 23.1732 21.6438C22.4296 21.5611 22.0164 21.809 21.7686 22.0569C21.7686 22.0569 21.8512 22.0569 21.8512 22.1395C22.0164 22.3048 22.0991 22.47 22.0991 22.7179C22.1817 22.8831 22.0991 22.9658 22.0991 23.131Z" fill="#455A64"/>
+</svg>
diff --git a/docs/public/icons/platform/macos-white.png b/docs/public/icons/platform/macos-white.png
new file mode 100644
index 0000000..38e444c
Binary files /dev/null and b/docs/public/icons/platform/macos-white.png differ
diff --git a/docs/public/icons/platform/macos.png b/docs/public/icons/platform/macos.png
new file mode 100644
index 0000000..af6cce8
Binary files /dev/null and b/docs/public/icons/platform/macos.png differ
diff --git a/docs/public/icons/platform/windows.png b/docs/public/icons/platform/windows.png
new file mode 100644
index 0000000..e3b7640
Binary files /dev/null and b/docs/public/icons/platform/windows.png differ
diff --git a/docs/public/llms.txt b/docs/public/llms.txt
new file mode 100644
index 0000000..b20a8e0
--- /dev/null
+++ b/docs/public/llms.txt
@@ -0,0 +1,51 @@
+# DBX - Database Workspace
+# https://dbxio.com
+
+## What is DBX?
+DBX is an open-source database workspace that supports 25+ database engines in a 15 MB package, available as both desktop and Docker deployment. It includes AI-powered SQL generation, MCP server integration for coding agents, schema tools, and self-hosted browser access.
+
+## Core Features
+- **SQL Editor**: CodeMirror 6-based editor with syntax highlighting, auto-completion, formatting, and query history.
+- **AI SQL Assistant**: Generate, explain, optimize, and fix SQL using Claude or OpenAI models.
+- **MCP Integration**: Expose database connections to AI coding agents (Claude Code, Cursor, Windsurf) via Model Context Protocol.
+- **Data Grid**: Virtual scrolling, inline editing, filtering, sorting, and export to CSV/JSON/Markdown.
+- **Schema Browser**: Browse databases, schemas, tables, columns, indexes, foreign keys, and triggers.
+- **Schema Diff**: Compare schemas across environments and generate migration SQL.
+- **Redis Browser**: Pattern-based key search with support for all Redis data types.
+- **MongoDB Browser**: Document CRUD with paginated browsing.
+- **SSH Tunnels**: Connect to databases behind firewalls with key/password authentication.
+
+## Supported Databases
+MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, ClickHouse, SQL Server, Oracle, MariaDB, TiDB, and more.
+
+## MCP Server
+```bash
+npm install -g @dbx-app/mcp-server
+```
+Configure `.mcp.json` to let AI agents query databases through DBX connections:
+```json
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "npx",
+      "args": ["-y", "@dbx-app/mcp-server"]
+    }
+  }
+}
+```
+For Windows portable builds, set DBX_DATA_DIR to the portable data directory that contains dbx.db, for example D:\DBX_x64-portable\data.
+
+## Key Links
+- Documentation: https://dbxio.com/en/docs/what-is-dbx
+- Changelog: https://dbxio.com/en/changelog
+- Community: https://dbxio.com/en/community
+- GitHub: https://github.com/t8y2/dbx
+- Drivers: https://dbxio.com/en/drivers
+
+## Platform Support
+- Desktop: Windows, macOS (Intel + Apple Silicon), Linux
+- Docker: Self-hosted browser-based access
+- MCP: npm package for AI agent integration
+
+## Pricing
+DBX is free and open-source (AGPL-3.0).
diff --git a/docs/public/logo.png b/docs/public/logo.png
new file mode 100644
index 0000000..23c91bc
Binary files /dev/null and b/docs/public/logo.png differ
diff --git a/docs/public/robots.txt b/docs/public/robots.txt
new file mode 100644
index 0000000..89add43
--- /dev/null
+++ b/docs/public/robots.txt
@@ -0,0 +1,32 @@
+User-agent: *
+Allow: /
+
+# AI crawlers — explicitly allowed
+User-agent: GPTBot
+Allow: /
+
+User-agent: ChatGPT-User
+Allow: /
+
+User-agent: Claude-Web
+Allow: /
+
+User-agent: ClaudeBot
+Allow: /
+
+User-agent: anthropic-ai
+Allow: /
+
+User-agent: PerplexityBot
+Allow: /
+
+User-agent: Google-Extended
+Allow: /
+
+User-agent: GoogleOther
+Allow: /
+
+User-agent: CCBot
+Allow: /
+
+Sitemap: https://dbxio.com/sitemap.xml
diff --git a/docs/public/screenshot-ai.jpg b/docs/public/screenshot-ai.jpg
new file mode 100644
index 0000000..9969aee
Binary files /dev/null and b/docs/public/screenshot-ai.jpg differ
diff --git a/docs/public/screenshot-connections.jpg b/docs/public/screenshot-connections.jpg
new file mode 100644
index 0000000..7bc9512
Binary files /dev/null and b/docs/public/screenshot-connections.jpg differ
diff --git a/docs/public/screenshot-dark.png b/docs/public/screenshot-dark.png
new file mode 100644
index 0000000..7ef51c7
Binary files /dev/null and b/docs/public/screenshot-dark.png differ
diff --git a/docs/public/screenshot-er.png b/docs/public/screenshot-er.png
new file mode 100644
index 0000000..6c71ee8
Binary files /dev/null and b/docs/public/screenshot-er.png differ
diff --git a/docs/public/screenshot-grid.png b/docs/public/screenshot-grid.png
new file mode 100644
index 0000000..511ac87
Binary files /dev/null and b/docs/public/screenshot-grid.png differ
diff --git a/docs/public/screenshot-light.png b/docs/public/screenshot-light.png
new file mode 100644
index 0000000..7f35ab6
Binary files /dev/null and b/docs/public/screenshot-light.png differ
diff --git a/docs/public/screenshot.png b/docs/public/screenshot.png
new file mode 100644
index 0000000..ff0e04b
Binary files /dev/null and b/docs/public/screenshot.png differ
diff --git a/docs/qq-group.jpg b/docs/qq-group.jpg
new file mode 100644
index 0000000..175e63a
Binary files /dev/null and b/docs/qq-group.jpg differ
diff --git a/docs/screenshot-ai.jpg b/docs/screenshot-ai.jpg
new file mode 100644
index 0000000..9969aee
Binary files /dev/null and b/docs/screenshot-ai.jpg differ
diff --git a/docs/screenshot-connections.jpg b/docs/screenshot-connections.jpg
new file mode 100644
index 0000000..7bc9512
Binary files /dev/null and b/docs/screenshot-connections.jpg differ
diff --git a/docs/screenshot-dark.png b/docs/screenshot-dark.png
new file mode 100644
index 0000000..7ef51c7
Binary files /dev/null and b/docs/screenshot-dark.png differ
diff --git a/docs/screenshot-er.png b/docs/screenshot-er.png
new file mode 100644
index 0000000..6c71ee8
Binary files /dev/null and b/docs/screenshot-er.png differ
diff --git a/docs/screenshot-es-sql-completion.png b/docs/screenshot-es-sql-completion.png
new file mode 100644
index 0000000..9ca465e
Binary files /dev/null and b/docs/screenshot-es-sql-completion.png differ
diff --git a/docs/screenshot-es-sql-pagination.png b/docs/screenshot-es-sql-pagination.png
new file mode 100644
index 0000000..e4acc20
Binary files /dev/null and b/docs/screenshot-es-sql-pagination.png differ
diff --git a/docs/screenshot-es-sql-where.png b/docs/screenshot-es-sql-where.png
new file mode 100644
index 0000000..87bd762
Binary files /dev/null and b/docs/screenshot-es-sql-where.png differ
diff --git a/docs/screenshot-grid.png b/docs/screenshot-grid.png
new file mode 100644
index 0000000..511ac87
Binary files /dev/null and b/docs/screenshot-grid.png differ
diff --git a/docs/screenshot-light.png b/docs/screenshot-light.png
new file mode 100644
index 0000000..7f35ab6
Binary files /dev/null and b/docs/screenshot-light.png differ
diff --git a/docs/screenshot.png b/docs/screenshot.png
new file mode 100644
index 0000000..ff0e04b
Binary files /dev/null and b/docs/screenshot.png differ
diff --git a/docs/scripts/generate-sitemap.mjs b/docs/scripts/generate-sitemap.mjs
new file mode 100644
index 0000000..c9ebbd3
--- /dev/null
+++ b/docs/scripts/generate-sitemap.mjs
@@ -0,0 +1,90 @@
+import { readdirSync, writeFileSync } from "fs";
+import { resolve, relative } from "path";
+
+const OUT_DIR = resolve(import.meta.dirname, "../out");
+const SITE_URL = "https://dbxio.com";
+const TODAY = new Date().toISOString().split("T")[0];
+
+const EXCLUDE = new Set(["index.html", "404.html", "_not-found.html"]);
+
+function* walkDir(dir) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = resolve(dir, entry.name);
+    if (entry.isDirectory()) {
+      yield* walkDir(fullPath);
+    } else if (entry.isFile() && entry.name.endsWith(".html")) {
+      yield fullPath;
+    }
+  }
+}
+
+function pathToUrl(filePath) {
+  const rel = relative(OUT_DIR, filePath);
+  return "/" + rel.replace(/\.html$/, "").replace(/\\/g, "/");
+}
+
+const htmlFiles = [...walkDir(OUT_DIR)].filter((f) => {
+  const basename = f.split("/").pop() ?? "";
+  return !EXCLUDE.has(basename);
+});
+
+const pagesByPath = new Map();
+
+for (const file of htmlFiles) {
+  const url = pathToUrl(file);
+  const match = url.match(/^\/(en|cn)(\/.*)?$/);
+  if (!match) {
+    pagesByPath.set(url, { en: null, cn: null });
+    continue;
+  }
+  const relativePath = match[2] || "/";
+  if (!pagesByPath.has(relativePath)) {
+    pagesByPath.set(relativePath, { en: null, cn: null });
+  }
+  const entry = pagesByPath.get(relativePath);
+  entry[match[1]] = url;
+  pagesByPath.set(relativePath, entry);
+}
+
+const urls = [];
+const seen = new Set();
+
+for (const [, langs] of pagesByPath) {
+  const primary = langs.en || langs.cn;
+  if (!primary || seen.has(primary)) continue;
+  seen.add(primary);
+
+  const altLinks = [];
+  if (langs.en) {
+    altLinks.push({ lang: "en", href: `${SITE_URL}${langs.en}` });
+  }
+  if (langs.cn) {
+    altLinks.push({ lang: "zh", href: `${SITE_URL}${langs.cn}` });
+  }
+
+  if (altLinks.length > 1) {
+    altLinks.push({ lang: "x-default", href: `${SITE_URL}${langs.en}` });
+  }
+
+  urls.push({ loc: `${SITE_URL}${primary}`, lastmod: TODAY, altLinks });
+}
+
+const sitemapXml = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+        xmlns:xhtml="http://www.w3.org/1999/xhtml">
+${urls
+  .map(
+    (entry) =>
+      `  <url>
+    <loc>${entry.loc}</loc>
+    <lastmod>${entry.lastmod}</lastmod>
+${entry.altLinks.map((alt) => `    <xhtml:link rel="alternate" hreflang="${alt.lang}" href="${alt.href}" />`).join("\n")}
+  </url>`,
+  )
+  .join("\n")}
+</urlset>
+`;
+
+writeFileSync(resolve(OUT_DIR, "sitemap.xml"), sitemapXml);
+console.log(`sitemap.xml generated with ${urls.length} URLs`);
diff --git a/docs/source.config.ts b/docs/source.config.ts
new file mode 100644
index 0000000..71c0f61
--- /dev/null
+++ b/docs/source.config.ts
@@ -0,0 +1,9 @@
+import { defineDocs, defineConfig } from "fumadocs-mdx/config";
+
+export const docs = defineDocs({
+  dir: "content/docs",
+});
+
+export default defineConfig({
+  mdxOptions: {},
+});
diff --git a/docs/tsconfig.json b/docs/tsconfig.json
new file mode 100644
index 0000000..219e459
--- /dev/null
+++ b/docs/tsconfig.json
@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./*"],
+      "@/content/*": ["./.source/*"]
+    }
+  },
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".source/**/*.ts", ".next/types/**/*.ts", ".next/dev/types/**/*.ts"],
+  "exclude": ["node_modules"]
+}
diff --git a/docs/wechat-group.jpg b/docs/wechat-group.jpg
new file mode 100644
index 0000000..4285ea9
Binary files /dev/null and b/docs/wechat-group.jpg differ
diff --git a/docs/wrangler.json b/docs/wrangler.json
new file mode 100644
index 0000000..11cb31c
--- /dev/null
+++ b/docs/wrangler.json
@@ -0,0 +1,7 @@
+{
+  "name": "dbx",
+  "compatibility_date": "2026-05-07",
+  "assets": {
+    "directory": "./out"
+  }
+}
diff --git a/examples/README.md b/examples/README.md
new file mode 100644
index 0000000..8b2918a
--- /dev/null
+++ b/examples/README.md
@@ -0,0 +1,40 @@
+# DBX Examples
+
+Runnable samples for common DBX workflows.
+
+| Directory | What it shows |
+| --- | --- |
+| [cli/](cli/) | Terminal queries with `@dbx-app/cli` |
+| [mcp/](mcp/) | MCP configs for Cursor and Claude Code |
+| [docker/](docker/) | Self-hosted Docker deployment |
+| [web-api/](web-api/) | Minimal HTTP API automation against DBX Web |
+
+## Before You Run
+
+1. Install DBX Desktop, or start the Docker/Web version.
+2. Create at least one connection in DBX.
+3. For CLI examples, install the CLI:
+
+```bash
+npm install -g @dbx-app/cli
+```
+
+4. For MCP examples, install the MCP server:
+
+```bash
+npm install -g @dbx-app/mcp-server
+```
+
+## Suggested Learning Path
+
+1. Read [Getting Started](https://dbxio.com/en/docs/getting-started)
+2. Try the CLI workflow in `cli/basic-workflow.sh`
+3. Copy an MCP config from `mcp/` into your project
+4. If you self-host DBX, use `docker/docker-compose.yml`
+5. For custom integrations, inspect `web-api/automation.sh`
+
+More docs:
+
+- [CLI reference](https://dbxio.com/en/docs/cli)
+- [MCP integration](https://dbxio.com/en/docs/mcp)
+- [Web API reference](https://dbxio.com/en/docs/web-api)
diff --git a/examples/cli/basic-workflow.sh b/examples/cli/basic-workflow.sh
new file mode 100755
index 0000000..19ad684
--- /dev/null
+++ b/examples/cli/basic-workflow.sh
@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Basic DBX CLI workflow.
+# Replace "local" with one of your saved connection names.
+
+CONNECTION="${DBX_CONNECTION:-local}"
+
+echo "==> Checking local DBX setup"
+dbx doctor
+
+echo "==> Listing connections"
+dbx connections list --json
+
+echo "==> Listing tables"
+dbx schema list "$CONNECTION" --json
+
+echo "==> Running a read-only query"
+dbx query "$CONNECTION" "select 1 as ok" --json
+
+echo "==> Building schema context for prompts"
+dbx context "$CONNECTION" --tables users,orders
diff --git a/examples/docker/docker-compose.yml b/examples/docker/docker-compose.yml
new file mode 100644
index 0000000..399b711
--- /dev/null
+++ b/examples/docker/docker-compose.yml
@@ -0,0 +1,16 @@
+services:
+  dbx:
+    image: t8y2/dbx
+    ports:
+      - "4224:4224"
+    environment:
+      # Change this before exposing DBX to a network.
+      - DBX_PASSWORD=changeme
+      # Uncomment when serving DBX behind a reverse-proxy subpath.
+      # - DBX_PUBLIC_BASE_PATH=/dbx
+    volumes:
+      - dbx-data:/app/data
+    restart: unless-stopped
+
+volumes:
+  dbx-data:
diff --git a/examples/mcp/claude-code.mcp.json b/examples/mcp/claude-code.mcp.json
new file mode 100644
index 0000000..da08b4b
--- /dev/null
+++ b/examples/mcp/claude-code.mcp.json
@@ -0,0 +1,7 @@
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "dbx-mcp-server"
+    }
+  }
+}
diff --git a/examples/mcp/cursor.mcp.json b/examples/mcp/cursor.mcp.json
new file mode 100644
index 0000000..8b281cf
--- /dev/null
+++ b/examples/mcp/cursor.mcp.json
@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "npx",
+      "args": ["-y", "@dbx-app/mcp-server"]
+    }
+  }
+}
diff --git a/examples/mcp/web-deployment.mcp.json b/examples/mcp/web-deployment.mcp.json
new file mode 100644
index 0000000..3fee6e7
--- /dev/null
+++ b/examples/mcp/web-deployment.mcp.json
@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "dbx-mcp-server",
+      "env": {
+        "DBX_WEB_URL": "http://localhost:4224",
+        "DBX_WEB_PASSWORD": "changeme"
+      }
+    }
+  }
+}
diff --git a/examples/web-api/automation.sh b/examples/web-api/automation.sh
new file mode 100755
index 0000000..8908940
--- /dev/null
+++ b/examples/web-api/automation.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Minimal DBX Web API automation example.
+# Requires a running DBX Web/Docker instance.
+
+BASE_URL="${DBX_WEB_URL:-http://localhost:4224}"
+PASSWORD="${DBX_WEB_PASSWORD:-changeme}"
+COOKIE_JAR="$(mktemp)"
+trap 'rm -f "$COOKIE_JAR"' EXIT
+
+echo "==> Checking auth state"
+curl -fsS "$BASE_URL/api/auth/check"
+
+echo
+echo "==> Logging in"
+curl -fsS -c "$COOKIE_JAR" \
+  -H "Content-Type: application/json" \
+  -d "{\"password\":\"$PASSWORD\"}" \
+  "$BASE_URL/api/auth/login" >/dev/null
+
+echo "==> Listing saved connections"
+curl -fsS -b "$COOKIE_JAR" "$BASE_URL/api/connection/list" | jq .
+
+echo
+echo "Done. Reuse the session cookie for schema and query routes."
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 0000000..7fd8c48
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,82 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1783224372,
+        "narHash": "sha256-8i/87eeoqiGE4yOTjwSA3Eh/ziJRQEmd/unYU+K27sk=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "d407951447dcd00442e97087bf374aad70c04cea",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs",
+        "rust-overlay": "rust-overlay"
+      }
+    },
+    "rust-overlay": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1783614422,
+        "narHash": "sha256-zSX553aXiIKJHWzUF6nrDKgeNRlfNK/SdyNYSbs2nkM=",
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "rev": "e8e9d70b96113fd49ccde6c3e08fb260b6ef5dd6",
+        "type": "github"
+      },
+      "original": {
+        "owner": "oxalica",
+        "repo": "rust-overlay",
+        "type": "github"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 0000000..76a2cb1
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,409 @@
+{
+  description = "DBX - Open-source database management tool (Tauri 2 + Vue 3 + Rust)";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+    rust-overlay = {
+      url = "github:oxalica/rust-overlay";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+  };
+
+  outputs =
+    {
+      self,
+      nixpkgs,
+      flake-utils,
+      rust-overlay,
+    }:
+    flake-utils.lib.eachDefaultSystem (
+      system:
+      let
+        overlays = [ (import rust-overlay) ];
+        pkgs = import nixpkgs { inherit system overlays; };
+
+        # Rust toolchain — lock to the minimum required version (1.77)
+        # while allowing newer stable releases to satisfy all crate deps.
+        rustToolchain = pkgs.rust-bin.stable.latest.default.override {
+          extensions = [
+            "rust-src"
+            "rust-analyzer"
+            "clippy"
+            "rustfmt"
+          ];
+        };
+
+        # ------------------------------------------------------------------ #
+        # Linux-only system libraries required by Tauri / WebKit2GTK          #
+        # ------------------------------------------------------------------ #
+        linuxTauriDeps = pkgs.lib.optionals pkgs.stdenv.isLinux (
+          with pkgs;
+          [
+            webkitgtk_4_1
+            gtk3
+            libappindicator-gtk3
+            libayatana-appindicator   # provides libayatana-appindicator3.so.1 (dlopen'd at runtime)
+            librsvg
+            patchelf
+            openssl
+            pkg-config
+            # Additional GTK / glib runtime deps
+            glib
+            glib-networking
+            dbus
+            at-spi2-atk
+            atkmm
+            cairo
+            gdk-pixbuf
+            harfbuzz
+            pango
+            xdotool
+            libx11
+            libxext
+            libxfixes
+          ]
+        );
+
+        # Node / frontend tooling
+        nodeDeps = with pkgs; [
+          nodejs_22
+          pnpm
+          # Optional: for building native node addons (better-sqlite3 etc.)
+          python3
+          gnumake
+          gcc
+        ];
+
+        # General build tooling
+        buildDeps = with pkgs; [
+          pkg-config
+          openssl
+          openssl.dev
+          curl
+          wget
+          git
+        ];
+
+      in
+      {
+        # ------------------------------------------------------------------ #
+        # devShell — `nix develop`                                             #
+        # Provides everything needed to run `pnpm install && pnpm dev:tauri`  #
+        # or `pnpm dev:web` + `pnpm dev:backend` for the web variant.         #
+        # ------------------------------------------------------------------ #
+        devShells.default = pkgs.mkShell {
+          name = "dbx-dev";
+
+          buildInputs =
+            [ rustToolchain ]
+            ++ nodeDeps
+            ++ buildDeps
+            ++ linuxTauriDeps
+            ++ pkgs.lib.optionals pkgs.stdenv.isLinux (
+              with pkgs;
+              [
+                # cargo-watch is used by `pnpm dev:backend`
+                cargo-watch
+                # tauri-cli is installed via npm/pnpm, but Rust parts need this
+                pkg-config
+              ]
+            );
+
+          # Make pkg-config aware of all native libs
+          PKG_CONFIG_PATH = pkgs.lib.optionalString pkgs.stdenv.isLinux (
+            pkgs.lib.makeSearchPath "lib/pkgconfig" (
+              with pkgs;
+              [
+                openssl.dev
+                webkitgtk_4_1.dev
+                gtk3.dev
+                glib.dev
+                cairo.dev
+                gdk-pixbuf.dev
+                harfbuzz.dev
+                pango.dev
+                at-spi2-atk.dev
+              ]
+            )
+          );
+
+          # Required by rustls / aws-lc-rs which the project uses for TLS
+          OPENSSL_DIR = "${pkgs.openssl.dev}";
+          OPENSSL_LIB_DIR = "${pkgs.openssl.out}/lib";
+          OPENSSL_INCLUDE_DIR = "${pkgs.openssl.dev}/include";
+
+          shellHook = ''
+            echo "╔══════════════════════════════════════════════════════════════╗"
+            echo "║  DBX development environment                                 ║"
+            echo "║                                                              ║"
+            echo "║  Desktop (Tauri):   pnpm install && pnpm dev:tauri           ║"
+            echo "║  Web frontend:      pnpm dev:web                             ║"
+            echo "║  Web backend:       pnpm dev:backend                         ║"
+            echo "║  Build release:     pnpm tauri build                         ║"
+            echo "║                                                              ║"
+            echo "║  Node: $(node --version)  pnpm: $(pnpm --version)  Rust: $(rustc --version | cut -d' ' -f2)              ║"
+            echo "╚══════════════════════════════════════════════════════════════╝"
+          '';
+        };
+
+        # Convenience alias
+        packages.default = self.packages.${system}.dbx-desktop;
+
+        # ------------------------------------------------------------------ #
+        # packages.dbx-desktop — Tauri desktop application                    #
+        # Build with: nix build .#dbx-desktop                                 #
+        #                                                                      #
+        # Two-phase build strategy:                                            #
+        #   1. pnpm.fetchDeps  → vendor all npm/pnpm deps offline             #
+        #   2. importCargoLock → vendor all Cargo deps offline                 #
+        #   3. pnpm build      → compile Vue/TypeScript frontend               #
+        #   4. cargo build -p dbx → compile Tauri Rust backend                 #
+        #                                                                      #
+        # ⚠️  The pnpmDeps.hash below is a placeholder.                       #
+        #    Run `nix build .#dbx-desktop` once; Nix will report the          #
+        #    correct sha256 — paste it in place of the placeholder.           #
+        # ------------------------------------------------------------------ #
+        packages.dbx-desktop = pkgs.stdenv.mkDerivation (finalAttrs: {
+          pname = "dbx-desktop";
+          version = "0.5.55";
+
+          src = pkgs.lib.cleanSource ./.;
+
+          # ── Step 1: vendor pnpm (npm) dependencies ──────────────────────── #
+          # pnpm.fetchDeps downloads everything listed in pnpm-lock.yaml into  #
+          # a content-addressed store path so the build sandbox has no network. #
+          pnpmDeps = pkgs.fetchPnpmDeps {
+            inherit (finalAttrs) pname version src;
+            # nixpkgs 26.11+ requires fetcherVersion = 3 (versions 1 & 2 removed)
+            fetcherVersion = 3;
+            # Replace with the correct hash after the first failed build:
+            #   nix build .#dbx-desktop 2>&1 | grep 'got:'
+            hash = "sha256-e2/C37EaymMy3vG1MBZyxCa2sWlsl3OV9LLfJAHXrO0=";
+          };
+
+          # ── Step 2: vendor Cargo dependencies ───────────────────────────── #
+          cargoDeps = pkgs.rustPlatform.importCargoLock {
+            lockFile = ./Cargo.lock;
+            outputHashes = {
+              "tokio-postgres-0.7.17" = "sha256-mGzfqYmo1PPcpKOlyA6ePzZA4lrNspOJ5G52meHiocY=";
+              "mysql_async-0.36.2" = "sha256-qxSo2JX/ldU8Z+PVDrHy8+EB9ZG3Vdo9TbKLCLQt2CU=";
+              "mysql_common-0.35.5" = "sha256-CwXuC6QInSI1GcVSdaD1tcA7J+zTY9ZatOyTYTYPe0Q=";
+            };
+          };
+
+          # ── Native build tools (available during build, not linked) ──────── #
+          nativeBuildInputs =
+            [
+              rustToolchain
+              pkgs.nodejs_22
+              pkgs.pnpm
+              pkgs.pkg-config
+              pkgs.perl
+              pkgs.jq                         # used by preConfigure to strip packageManager
+              pkgs.cargo-tauri               # tauri CLI — needed to properly embed frontend assets
+              # Hooks that wire up the vendored deps automatically:
+              pkgs.rustPlatform.cargoSetupHook # sets CARGO_HOME to cargoDeps
+              pkgs.pnpmConfigHook             # sets up pnpm offline store
+              pkgs.desktop-file-utils         # for `desktop-file-validate`
+              pkgs.copyDesktopItems           # installs desktopItem into share/applications
+              pkgs.imagemagick                # generates correctly sized hicolor icons
+            ]
+            ++ pkgs.lib.optionals pkgs.stdenv.isLinux (
+              with pkgs;
+              [
+                wrapGAppsHook3 # wraps binary with GTK3/WebKit env
+              ]
+            );
+
+          # ── Desktop entry (freedesktop .desktop file) ────────────────────── #
+          # Built with `makeDesktopItem` so it is validated against the spec
+          # at build time. Icon name "dbx" resolves via the hicolor theme
+          # (the installPhase copies PNGs into share/icons/hicolor/<size>/apps).
+          desktopItem = pkgs.makeDesktopItem {
+            name = "dbx";
+            type = "Application";
+            exec = "dbx %u";
+            icon = "dbx";
+            desktopName = "DBX";
+            genericName = "Database Management Tool";
+            comment = "Open-source database management tool for 60+ databases";
+            categories = [ "Development" "Database" ];
+            keywords = [
+              "database"
+              "sql"
+              "client"
+              "mysql"
+              "postgresql"
+              "mongodb"
+              "redis"
+            ];
+            startupWMClass = "DBX";
+            terminal = false;
+            mimeTypes = [ "application/sql" "x-scheme-handler/dbx" ];
+          };
+
+          # ── Linked libraries (present at both build and runtime) ─────────── #
+          buildInputs =
+            (with pkgs; [
+              openssl
+              openssl.dev
+            ])
+            ++ linuxTauriDeps;
+
+          # ── Environment variables ─────────────────────────────────────────── #
+          PKG_CONFIG_PATH = pkgs.lib.optionalString pkgs.stdenv.isLinux (
+            pkgs.lib.makeSearchPath "lib/pkgconfig" (
+              with pkgs;
+              [
+                openssl.dev
+                webkitgtk_4_1.dev
+                gtk3.dev
+                glib.dev
+                cairo.dev
+                gdk-pixbuf.dev
+                harfbuzz.dev
+                pango.dev
+                at-spi2-atk.dev
+              ]
+            )
+          );
+          OPENSSL_DIR = "${pkgs.openssl.dev}";
+          OPENSSL_LIB_DIR = "${pkgs.openssl.out}/lib";
+          OPENSSL_INCLUDE_DIR = "${pkgs.openssl.dev}/include";
+
+          # Tauri reads the version from this env var during build
+          TAURI_SKIP_DEVSERVER_CHECK = "true";
+
+          # ── Runtime library path injection ───────────────────────────────── #
+          # libappindicator-sys uses dlopen() at runtime to load the appindicator
+          # shared library. dlopen() does NOT honour the binary's RPATH — it only
+          # searches LD_LIBRARY_PATH and system paths. In a Nix derivation the
+          # library lives in the store, not in /usr/lib, so we must inject the
+          # path explicitly into the wrapGAppsHook3 C-wrapper.
+          #
+          # IMPORTANT: wrapGAppsHook3 uses its own `gappsWrapperArgs` bash array
+          # (NOT `makeWrapperArgs`) — inject via preFixup before the hook runs.
+          preFixup = pkgs.lib.optionalString pkgs.stdenv.isLinux ''
+            gappsWrapperArgs+=(
+              --prefix LD_LIBRARY_PATH : "${pkgs.lib.makeLibraryPath linuxTauriDeps}"
+            )
+          '';
+
+          # ── Build phases ─────────────────────────────────────────────────── #
+          preConfigure = ''
+            export HOME=$TMPDIR
+            # The "packageManager" field in package.json causes pnpm to enforce a
+            # specific version via corepack, which requires network access in sandbox.
+            # Use jq (not sed) to drop the key so we don't leave a trailing comma
+            # in the file. A naive `sed '/"packageManager"/d'` removes only the
+            # value line and leaves `,\n}` behind, which pnpm then refuses to parse.
+            if [ -f package.json ]; then
+              jq 'del(.packageManager)' package.json > package.json.tmp \
+                && mv package.json.tmp package.json
+            fi
+          '';
+
+          buildPhase = ''
+            runHook preBuild
+
+            # ① Use `tauri build --no-bundle` which:
+            #   - Runs `beforeBuildCommand` (pnpm build) to compile the Vue/TS frontend
+            #   - Sets TAURI_ENV_* variables so the Rust build embeds the dist/ assets
+            #   - Properly initialises the Tauri IPC layer inside the binary
+            #   - Skips platform-specific installer/bundle creation (AppImage, deb, …)
+            #
+            # DO NOT replace this with a bare `cargo build -p dbx`.
+            # A raw cargo build skips Tauri's asset-embedding pipeline, so the
+            # WebView has no bundled frontend to load → __TAURI_INTERNALS__ is
+            # never injected → isTauriRuntime() returns false → the UI falls back
+            # to HTTP mode and immediately gets "Connection refused".
+            cargo tauri build --no-bundle
+
+            runHook postBuild
+          '';
+
+          installPhase = ''
+            runHook preInstall
+
+            mkdir -p $out/bin
+            # tauri build --no-bundle puts the binary at target/release/dbx
+            cp target/release/dbx $out/bin/dbx
+
+            # Install icon files into the hicolor theme tree so that all
+            # desktop environments (GNOME Shell, KDE Plasma, XFCE, etc.) can
+            # find the right size: task-switcher (32px), panel (48px),
+            # launcher (64px), app-menu (128px), HiDPI launcher (256px).
+            if [ -d src-tauri/icons ]; then
+              for size in 32 128; do
+                if [ -f "src-tauri/icons/''${size}x''${size}.png" ]; then
+                  mkdir -p "$out/share/icons/hicolor/''${size}x''${size}/apps"
+                  cp "src-tauri/icons/''${size}x''${size}.png" \
+                    "$out/share/icons/hicolor/''${size}x''${size}/apps/dbx.png"
+                fi
+              done
+
+              # @2x retina variant (128x128@2x) → install as 256x256
+              if [ -f "src-tauri/icons/128x128@2x.png" ]; then
+                mkdir -p "$out/share/icons/hicolor/256x256/apps"
+                cp "src-tauri/icons/128x128@2x.png" \
+                  "$out/share/icons/hicolor/256x256/apps/dbx.png"
+              fi
+
+              # Generate missing common sizes so hicolor directory metadata
+              # always matches the actual PNG dimensions.
+              for size in 16 48 64; do
+                mkdir -p "$out/share/icons/hicolor/''${size}x''${size}/apps"
+                if [ "$size" -le 32 ] && [ -f "src-tauri/icons/32x32.png" ]; then
+                  src="src-tauri/icons/32x32.png"
+                elif [ -f "src-tauri/icons/128x128.png" ]; then
+                  src="src-tauri/icons/128x128.png"
+                else
+                  continue
+                fi
+                magick "$src" -resize "''${size}x''${size}" \
+                  "$out/share/icons/hicolor/''${size}x''${size}/apps/dbx.png"
+              done
+
+              # Install the full-size icon.png as the scalable fallback so that
+              # Tauri's default_window_icon() and the taskbar always have an image.
+              if [ -f "src-tauri/icons/icon.png" ]; then
+                mkdir -p "$out/share/icons/hicolor/512x512/apps"
+                cp "src-tauri/icons/icon.png" \
+                  "$out/share/icons/hicolor/512x512/apps/dbx.png"
+              fi
+            fi
+
+            # Register the freedesktop .desktop file so app launchers (GNOME
+            # Shell, KDE Plasma, etc.) can discover the application.
+            mkdir -p $out/share/applications
+            cp ${finalAttrs.desktopItem}/share/applications/dbx.desktop \
+              $out/share/applications/dbx.desktop
+            ${pkgs.desktop-file-utils}/bin/desktop-file-validate \
+              $out/share/applications/dbx.desktop
+
+            runHook postInstall
+          '';
+
+          # ── Metadata ────────────────────────────────────────────────────── #
+          meta = with pkgs.lib; {
+            description = "DBX desktop — open-source database management tool (Tauri 2)";
+            longDescription = ''
+              DBX is a lightweight (~15 MB) database management tool supporting 60+
+              databases. Built with Tauri 2, Vue 3, and Rust. No Java, no Chromium.
+            '';
+            license = licenses.asl20;
+            homepage = "https://github.com/t8y2/dbx";
+            maintainers = [ ];
+            platforms = platforms.linux; # macOS/Windows need platform-specific adjustments
+            mainProgram = "dbx";
+          } // {
+            # Non-lib meta: absolute path to the installed .desktop file so
+            # `nix profile install`/home-manager can register it with the
+            # user's desktop environment.
+            desktopFile = "${placeholder "out"}/share/applications/dbx.desktop";
+          };
+        });
+      }
+    );
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..c0b377f
--- /dev/null
+++ b/package.json
@@ -0,0 +1,116 @@
+{
+  "name": "dbx",
+  "version": "0.5.55",
+  "private": true,
+  "license": "Apache-2.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite --config apps/desktop/vite.config.ts",
+    "dev:tauri": "tauri dev",
+    "dev:web": "vite --config apps/desktop/vite.config.ts --port 5173 --mode web",
+    "dev:backend": "node scripts/dev-backend.mjs",
+    "build:packages": "pnpm --filter @dbx-app/node-core build && pnpm --filter @dbx-app/cli build && pnpm --filter @dbx-app/mcp-server build",
+    "test:packages": "pnpm --filter @dbx-app/node-core test && pnpm --filter @dbx-app/cli test && pnpm --filter @dbx-app/mcp-server test",
+    "pack:packages": "rm -rf /tmp/dbx-pack-check && mkdir -p /tmp/dbx-pack-check && pnpm --filter @dbx-app/node-core pack --pack-destination /tmp/dbx-pack-check && pnpm --filter @dbx-app/cli pack --pack-destination /tmp/dbx-pack-check && pnpm --filter @dbx-app/mcp-server pack --pack-destination /tmp/dbx-pack-check",
+    "publish:dry-run": "pnpm build:packages && pnpm pack:packages",
+    "release": "node scripts/release.mjs",
+    "release:agents": "node scripts/release.mjs agents",
+    "release:app": "node scripts/release.mjs app",
+    "release:packages": "node scripts/release.mjs packages",
+    "build:knowledge-base": "node scripts/build-knowledge-base.mjs",
+    "typecheck": "vue-tsc --noEmit --project apps/desktop/tsconfig.json",
+    "build": "vite build --config apps/desktop/vite.config.ts",
+    "build:checked": "pnpm typecheck && pnpm build",
+    "check": "node scripts/run-check.mjs",
+    "bench:redis-key-search": "node scripts/bench/redis-key-search.mjs",
+    "lint": "oxlint --vue-plugin apps/desktop/src",
+    "fmt": "oxfmt \"apps/desktop/src/**/*.{ts,vue}\"",
+    "test": "vitest run",
+    "preview": "vite preview --config apps/desktop/vite.config.ts",
+    "tauri": "tauri",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.29.7",
+    "@codemirror/autocomplete": "^6.20.2",
+    "@codemirror/commands": "^6.10.3",
+    "@codemirror/lang-html": "^6.4.11",
+    "@codemirror/lang-json": "^6.0.2",
+    "@codemirror/lang-sql": "^6.10.0",
+    "@codemirror/lang-xml": "^6.1.0",
+    "@codemirror/lang-yaml": "^6.1.3",
+    "@codemirror/language": "^6.12.3",
+    "@codemirror/legacy-modes": "^6.5.3",
+    "@codemirror/search": "^6.7.0",
+    "@codemirror/state": "^6.6.0",
+    "@codemirror/theme-one-dark": "^6.1.3",
+    "@codemirror/view": "^6.43.0",
+    "@lezer/highlight": "^1.2.3",
+    "@lucide/vue": "1.17.0",
+    "@msgpack/msgpack": "^3.1.3",
+    "@replit/codemirror-vim": "^6.3.0",
+    "@tauri-apps/api": "^2.11.0",
+    "@tauri-apps/plugin-clipboard-manager": "^2.3.2",
+    "@tauri-apps/plugin-dialog": "^2.7.1",
+    "@tauri-apps/plugin-fs": "^2.5.1",
+    "@tauri-apps/plugin-process": "^2.3.1",
+    "@tauri-apps/plugin-shell": "^2.3.5",
+    "@tauri-apps/plugin-updater": "^2.10.1",
+    "@uiw/codemirror-theme-duotone": "^4.25.10",
+    "@uiw/codemirror-theme-material": "^4.25.10",
+    "@uiw/codemirror-theme-nord": "^4.25.10",
+    "@uiw/codemirror-theme-okaidia": "^4.25.10",
+    "@uiw/codemirror-theme-vscode": "^4.25.10",
+    "@uiw/codemirror-theme-xcode": "^4.25.10",
+    "@vueuse/core": "^14.2.1",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "codemirror": "^6.0.2",
+    "dayjs": "^1.11.21",
+    "diff": "^9.0.0",
+    "dom-to-image-more": "^3.7.2",
+    "echarts": "^6.1.0",
+    "leaflet": "^1.9.4",
+    "marked": "^18.0.4",
+    "pinia": "^3.0.0",
+    "reka-ui": "^2.10.1",
+    "shadcn-vue": "^2.7.4",
+    "shiki": "^4.2.0",
+    "splitpanes": "^4.1.2",
+    "sql-formatter": "^15.8.0",
+    "tailwind-merge": "^3.6.0",
+    "tw-animate-css": "^1.4.0",
+    "vue": "^3.5.35",
+    "vue-echarts": "^8.0.1",
+    "vue-i18n": "^11.4.4",
+    "vue-virtual-scroller": "^3.0.4"
+  },
+  "devDependencies": {
+    "@lezer/highlight": "^1.2.3",
+    "@oxfmt/binding-darwin-arm64": "0.53.0",
+    "@oxlint/binding-darwin-arm64": "1.68.0",
+    "@tailwindcss/vite": "^4.3.0",
+    "@tauri-apps/cli": "^2.11.2",
+    "@types/leaflet": "^1.9.21",
+    "@types/node": "^25.9.1",
+    "@types/splitpanes": "^2.2.6",
+    "@vitejs/plugin-vue": "^6.0.7",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "oxfmt": "0.53.0",
+    "oxlint": "^1.68.0",
+    "tailwindcss": "^4.3.0",
+    "tsx": "^4.22.4",
+    "typescript": "~6.0.3",
+    "vite": "^8.0.16",
+    "vitest": "^4.1.8",
+    "vue-tsc": "^3.3.3"
+  },
+  "lint-staged": {
+    "apps/desktop/src/**/*.{ts,vue}": "oxfmt"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "packageManager": "pnpm@10.27.0"
+}
diff --git a/packages/app-tests/actionActivation.test.ts b/packages/app-tests/actionActivation.test.ts
new file mode 100644
index 0000000..b671bf6
--- /dev/null
+++ b/packages/app-tests/actionActivation.test.ts
@@ -0,0 +1,35 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { shouldSuppressRepeatedActivation, tryStartExclusiveActivation } from "../../apps/desktop/src/lib/connection/actionActivation.ts";
+
+test("allows the first activation", () => {
+  const guard = {};
+
+  assert.equal(shouldSuppressRepeatedActivation(guard, 1000), false);
+});
+
+test("suppresses repeated activation inside the guard window", () => {
+  const guard = {};
+
+  assert.equal(shouldSuppressRepeatedActivation(guard, 1000, 500), false);
+  assert.equal(shouldSuppressRepeatedActivation(guard, 1200, 500), true);
+});
+
+test("allows activation after the guard window", () => {
+  const guard = {};
+
+  assert.equal(shouldSuppressRepeatedActivation(guard, 1000, 500), false);
+  assert.equal(shouldSuppressRepeatedActivation(guard, 1600, 500), false);
+});
+
+test("exclusive activation blocks concurrent starts until finished", () => {
+  const guard = {};
+  const finish = tryStartExclusiveActivation(guard);
+
+  assert.equal(typeof finish, "function");
+  assert.equal(tryStartExclusiveActivation(guard), null);
+
+  finish?.();
+
+  assert.equal(typeof tryStartExclusiveActivation(guard), "function");
+});
diff --git a/packages/app-tests/agentDriverInstallHint.test.ts b/packages/app-tests/agentDriverInstallHint.test.ts
new file mode 100644
index 0000000..47532cd
--- /dev/null
+++ b/packages/app-tests/agentDriverInstallHint.test.ts
@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { appendAgentDriverUpdateHint, hasAgentDriverUpdate, showAgentDriverInstallHint } from "../../apps/desktop/src/lib/connection/agentDriverInstallHint.ts";
+
+test("hides the agent driver install hint when the selected driver is installed", () => {
+  assert.equal(showAgentDriverInstallHint("informix", [{ db_type: "informix", installed: true }]), false);
+});
+
+test("shows the agent driver install hint when the selected driver is missing", () => {
+  assert.equal(showAgentDriverInstallHint("informix", [{ db_type: "informix", installed: false }]), true);
+});
+
+test("shows the agent driver install hint for TDengine when missing", () => {
+  assert.equal(showAgentDriverInstallHint("tdengine", [{ db_type: "tdengine", installed: false }]), true);
+});
+
+test("shows the agent driver install hint for Access when missing", () => {
+  assert.equal(showAgentDriverInstallHint("access", [{ db_type: "access", installed: false }]), true);
+});
+
+test("does not show agent driver install hints for built-in database types", () => {
+  assert.equal(showAgentDriverInstallHint("mysql", [{ db_type: "informix", installed: false }]), false);
+});
+
+test("uses the unified Oracle driver for legacy Oracle profiles", () => {
+  assert.equal(showAgentDriverInstallHint("oracle", [{ db_type: "oracle", installed: false }], "oracle-10g"), true);
+  assert.equal(showAgentDriverInstallHint("oracle", [{ db_type: "oracle", installed: true }], "oracle"), false);
+  assert.equal(showAgentDriverInstallHint("oracle", [{ db_type: "oracle", installed: true }], "oracle-legacy"), false);
+  assert.equal(showAgentDriverInstallHint("oracle", [{ db_type: "oracle", installed: false }], "oracle"), true);
+});
+
+test("uses selected non-Oracle agent driver profiles for install hints", () => {
+  assert.equal(
+    showAgentDriverInstallHint(
+      "gbase",
+      [
+        { db_type: "gbase", installed: true },
+        { db_type: "gbase8s", installed: false },
+      ],
+      "gbase8s",
+    ),
+    true,
+  );
+  assert.equal(
+    showAgentDriverInstallHint(
+      "gbase",
+      [
+        { db_type: "gbase", installed: false },
+        { db_type: "gbase8s", installed: true },
+      ],
+      "gbase8s",
+    ),
+    false,
+  );
+});
+
+test("detects available updates for the selected agent driver", () => {
+  assert.equal(hasAgentDriverUpdate("dameng", [{ db_type: "dameng", installed: true, update_available: true }], "dm"), true);
+  assert.equal(hasAgentDriverUpdate("dameng", [{ db_type: "dameng", installed: true, update_available: false }], "dm"), false);
+  assert.equal(hasAgentDriverUpdate("mysql", [{ db_type: "mysql", installed: true, update_available: true }]), false);
+});
+
+test("uses unified Oracle and selected profile keys for update hints", () => {
+  assert.equal(hasAgentDriverUpdate("oracle", [{ db_type: "oracle", installed: true, update_available: true }], "oracle-10g"), true);
+  assert.equal(
+    hasAgentDriverUpdate(
+      "gbase",
+      [
+        { db_type: "gbase", installed: true, update_available: false },
+        { db_type: "gbase8s", installed: true, update_available: true },
+      ],
+      "gbase8s",
+    ),
+    true,
+  );
+});
+
+test("appends agent driver update hints once", () => {
+  const hint = "Driver update available.";
+  assert.equal(appendAgentDriverUpdateHint("Original error", hint), "Original error\n\nDriver update available.");
+  assert.equal(appendAgentDriverUpdateHint("Original error\n\nDriver update available.", hint), "Original error\n\nDriver update available.");
+  assert.equal(appendAgentDriverUpdateHint("", hint), hint);
+});
diff --git a/packages/app-tests/agentVersionBump.test.ts b/packages/app-tests/agentVersionBump.test.ts
new file mode 100644
index 0000000..067309f
--- /dev/null
+++ b/packages/app-tests/agentVersionBump.test.ts
@@ -0,0 +1,130 @@
+import { strict as assert } from "node:assert";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { test } from "vitest";
+
+const { evaluateAgentVersionBump } = await importScript(".github/scripts/bump-agent-versions.mjs");
+
+function importScript(path: string): Promise<Record<string, any>> {
+  const source = readFileSync(resolve(path), "utf8").replace(/^#!.*\r?\n/, "");
+  return import(`data:text/javascript;base64,${Buffer.from(source).toString("base64")}`);
+}
+
+function moduleFixture(paths: string[], files: Record<string, string> = {}) {
+  const existing = new Set(paths);
+  return {
+    moduleExists: (path: string) => existing.has(path),
+    readModuleFile: (path: string) => files[path] ?? "",
+  };
+}
+
+test("common agent runtime changes bump only modules that package common", () => {
+  const fixture = moduleFixture(
+    [
+      "agents/drivers/access",
+      "agents/drivers/access/build.gradle",
+      "agents/drivers/kafka",
+      "agents/drivers/kafka/build.gradle",
+      "agents/drivers/mongodb",
+      "agents/drivers/mongodb/build.gradle",
+      "agents/drivers/oracle-go",
+      "agents/drivers/xugu",
+    ],
+    {
+      "agents/drivers/mongodb/build.gradle": "dependencies { implementation project(':common') }",
+    },
+  );
+
+  const result = evaluateAgentVersionBump({
+    versions: {
+      access: "0.1.0",
+      kafka: "0.1.0",
+      mongodb: "0.1.0",
+      oracle: "0.1.0",
+      xugu: "0.1.0",
+    },
+    changedFiles: ["agents/common/src/main/resources/agent-protocol-v1.json"],
+    legacyStandaloneModules: new Set(["kafka", "mongodb"]),
+    ...fixture,
+  });
+
+  assert.equal(result.changed, true);
+  assert.deepEqual(result.versions, {
+    access: "0.1.1",
+    kafka: "0.1.0",
+    mongodb: "0.1.1",
+    oracle: "0.1.0",
+    xugu: "0.1.0",
+  });
+});
+
+test("common agent test changes do not bump driver versions", () => {
+  const fixture = moduleFixture(["agents/drivers/access", "agents/drivers/access/build.gradle"]);
+
+  const result = evaluateAgentVersionBump({
+    versions: {
+      access: "0.1.0",
+    },
+    changedFiles: ["agents/common/src/test/java/com/dbx/agent/AbstractJdbcAgentTest.java"],
+    ...fixture,
+  });
+
+  assert.equal(result.changed, false);
+  assert.deepEqual(result.versions, {
+    access: "0.1.0",
+  });
+});
+
+test("native agent source changes still bump native module versions", () => {
+  const fixture = moduleFixture([
+    "agents/drivers/access",
+    "agents/drivers/access/build.gradle",
+    "agents/drivers/oracle-go",
+    "agents/drivers/xugu",
+  ]);
+
+  const result = evaluateAgentVersionBump({
+    versions: {
+      access: "0.1.0",
+      oracle: "0.1.0",
+      xugu: "0.1.0",
+    },
+    changedFiles: ["agents/drivers/oracle-go/main.go", "agents/drivers/xugu/main.go"],
+    ...fixture,
+  });
+
+  assert.equal(result.changed, true);
+  assert.deepEqual(result.versions, {
+    access: "0.1.0",
+    oracle: "0.1.1",
+    xugu: "0.1.1",
+  });
+});
+
+test("manual agent versions are preserved while other changed modules auto bump", () => {
+  const fixture = moduleFixture([
+    "agents/drivers/access",
+    "agents/drivers/access/build.gradle",
+    "agents/drivers/dameng",
+    "agents/drivers/dameng/build.gradle",
+  ]);
+
+  const result = evaluateAgentVersionBump({
+    versions: {
+      access: "0.1.2",
+      dameng: "0.1.0",
+    },
+    prevVersions: {
+      access: "0.1.1",
+      dameng: "0.1.0",
+    },
+    changedFiles: ["agents/common/src/main/java/com/dbx/agent/JdbcExecutor.java", "agents/versions.json"],
+    ...fixture,
+  });
+
+  assert.equal(result.changed, true);
+  assert.deepEqual(result.versions, {
+    access: "0.1.2",
+    dameng: "0.1.1",
+  });
+});
diff --git a/packages/app-tests/aiAgentPlan.test.ts b/packages/app-tests/aiAgentPlan.test.ts
new file mode 100644
index 0000000..64dd046
--- /dev/null
+++ b/packages/app-tests/aiAgentPlan.test.ts
@@ -0,0 +1,217 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildAiAgentPlan } from "../../apps/desktop/src/lib/ai/aiAgentPlan.ts";
+import type { AiAction, AiAssistantMode } from "../../apps/desktop/src/lib/ai/ai.ts";
+import type { ConnectionConfig } from "../../apps/desktop/src/types/database.ts";
+
+function conn(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
+  return {
+    id: "c1",
+    name: "local-pg",
+    db_type: "postgres",
+    host: "127.0.0.1",
+    port: 5432,
+    username: "postgres",
+    password: "",
+    database: "app_dev",
+    ...overrides,
+  };
+}
+
+function planInput(
+  overrides: {
+    mode?: AiAssistantMode;
+    action?: AiAction;
+    instruction?: string;
+    assistantContent?: string;
+    connection?: ConnectionConfig;
+  } = {},
+) {
+  return {
+    mode: overrides.mode ?? "agent",
+    action: overrides.action ?? "generate",
+    instruction: overrides.instruction ?? "查一下用户数量",
+    assistantContent: overrides.assistantContent ?? "```sql\nSELECT count(*) FROM users\n```",
+    connection: overrides.connection ?? conn(),
+  };
+}
+
+test("ask mode records generated SQL but skips execution", () => {
+  const plan = buildAiAgentPlan(planInput({ mode: "ask" }));
+
+  assert.deepEqual(plan.steps, [
+    { kind: "generate_sql", status: "done", sql: "SELECT count(*) FROM users" },
+    { kind: "execute_sql", status: "skipped", reason: "ask_mode" },
+  ]);
+  assert.equal(plan.executableSql, undefined);
+});
+
+test("agent mode auto-executes read SQL when the user asks to query", () => {
+  const plan = buildAiAgentPlan(planInput());
+
+  assert.deepEqual(plan.steps, [
+    { kind: "generate_sql", status: "done", sql: "SELECT count(*) FROM users" },
+    {
+      kind: "risk_check",
+      status: "done",
+      action: "auto_execute",
+      environment: "non_production",
+      category: "read",
+      reasons: [],
+    },
+    { kind: "execute_sql", status: "pending", sql: "SELECT count(*) FROM users" },
+  ]);
+  assert.equal(plan.executableSql, "SELECT count(*) FROM users");
+  assert.equal(plan.handoffSql, "SELECT count(*) FROM users");
+});
+
+test("agent mode auto-executes table inventory metadata SQL for natural Chinese questions", () => {
+  const sql = "SELECT tablename FROM pg_catalog.pg_tables WHERE schemaname = 'public' ORDER BY tablename;";
+  const plan = buildAiAgentPlan(
+    planInput({
+      instruction: "当前有哪些表",
+      assistantContent: `SQL\n\n\n\n\`\`\`sql\n${sql}\n\`\`\``,
+    }),
+  );
+
+  assert.deepEqual(plan.steps, [
+    { kind: "generate_sql", status: "done", sql },
+    {
+      kind: "risk_check",
+      status: "done",
+      action: "auto_execute",
+      environment: "non_production",
+      category: "read",
+      reasons: [],
+    },
+    { kind: "execute_sql", status: "pending", sql },
+  ]);
+  assert.equal(plan.handoffSql, sql);
+});
+
+test("agent mode skips execution when the user explicitly asks not to run", () => {
+  const plan = buildAiAgentPlan(planInput({ instruction: "只生成 SQL，不要执行" }));
+
+  assert.deepEqual(plan.steps, [
+    { kind: "generate_sql", status: "done", sql: "SELECT count(*) FROM users" },
+    { kind: "execute_sql", status: "skipped", reason: "no_execution_intent" },
+  ]);
+  assert.equal(plan.executableSql, undefined);
+  assert.equal(plan.handoffSql, undefined);
+});
+
+test("non-generate actions do not execute even in agent mode", () => {
+  const plan = buildAiAgentPlan(planInput({ action: "optimize", instruction: "优化这条 SQL" }));
+
+  assert.deepEqual(plan.steps, [
+    { kind: "generate_sql", status: "done", sql: "SELECT count(*) FROM users" },
+  ]);
+  assert.equal(plan.executableSql, undefined);
+  assert.equal(plan.handoffSql, undefined);
+});
+
+test("task-oriented Agent actions do not drive client-side execution", () => {
+  for (const action of ["query", "exploreSchema", "executeAndExplain"] as AiAction[]) {
+    const plan = buildAiAgentPlan(planInput({ action, instruction: "查一下用户数量" }));
+
+    assert.deepEqual(plan.steps, [
+      { kind: "generate_sql", status: "done", sql: "SELECT count(*) FROM users" },
+    ]);
+    assert.equal(plan.executableSql, undefined);
+    assert.equal(plan.handoffSql, undefined);
+  }
+});
+
+test("agent plan blocks dangerous SQL", () => {
+  const plan = buildAiAgentPlan(
+    planInput({
+      assistantContent: "```sql\nDROP TABLE users\n```",
+    }),
+  );
+
+  assert.deepEqual(plan.steps, [
+    { kind: "generate_sql", status: "done", sql: "DROP TABLE users" },
+    {
+      kind: "risk_check",
+      status: "done",
+      action: "block",
+      environment: "non_production",
+      category: "dangerous",
+      reasons: [],
+    },
+    { kind: "execute_sql", status: "skipped", reason: "blocked_by_policy" },
+  ]);
+  assert.equal(plan.executableSql, undefined);
+  assert.equal(plan.handoffSql, "DROP TABLE users");
+});
+
+test("agent plan requires confirmation for production writes", () => {
+  const plan = buildAiAgentPlan(
+    planInput({
+      assistantContent: "```sql\nINSERT INTO users(name) VALUES ('a')\n```",
+      connection: conn({ name: "prod-db", host: "10.0.0.9", database: "app_prod" }),
+    }),
+  );
+
+  assert.equal(plan.steps[1]?.kind, "risk_check");
+  assert.equal(plan.steps[1]?.status, "done");
+  if (plan.steps[1]?.kind === "risk_check") {
+    assert.equal(plan.steps[1].action, "confirm");
+    assert.equal(plan.steps[1].environment, "production");
+    assert.equal(plan.steps[1].category, "low_risk_write");
+  }
+  assert.deepEqual(plan.steps[2], {
+    kind: "execute_sql",
+    status: "skipped",
+    reason: "requires_confirmation",
+  });
+  assert.equal(plan.executableSql, undefined);
+  assert.equal(plan.handoffSql, "INSERT INTO users(name) VALUES ('a')");
+});
+
+test("agent plan skips execution when no SQL block is present", () => {
+  const plan = buildAiAgentPlan(planInput({ assistantContent: "我需要更多信息。" }));
+
+  assert.deepEqual(plan.steps, [
+    { kind: "generate_sql", status: "skipped", reason: "no_sql" },
+    { kind: "execute_sql", status: "skipped", reason: "no_sql" },
+  ]);
+  assert.equal(plan.executableSql, undefined);
+});
+
+test("agent plan ignores comment-only SQL blocks and executes the first real SQL block", () => {
+  const plan = buildAiAgentPlan(
+    planInput({
+      instruction: "查一下当前数据库里有哪些表",
+      assistantContent: ["当前数据库中的表：", "```sql", "-- 当前数据库中的表（仅从已加载的 Schema 上下文得知）：", "-- public.ihli_data", "```", "若需查看该表数据，可执行：", "```sql", "SELECT * FROM ihli_data", "LIMIT 10;", "```"].join("\n"),
+    }),
+  );
+
+  assert.deepEqual(plan.steps, [
+    { kind: "generate_sql", status: "done", sql: "SELECT * FROM ihli_data\nLIMIT 10;" },
+    {
+      kind: "risk_check",
+      status: "done",
+      action: "auto_execute",
+      environment: "non_production",
+      category: "read",
+      reasons: [],
+    },
+    { kind: "execute_sql", status: "pending", sql: "SELECT * FROM ihli_data\nLIMIT 10;" },
+  ]);
+  assert.equal(plan.handoffSql, "SELECT * FROM ihli_data\nLIMIT 10;");
+});
+
+test("agent plan treats comment-only SQL responses as no SQL", () => {
+  const plan = buildAiAgentPlan(
+    planInput({
+      assistantContent: "```sql\n-- public.ihli_data\n```",
+    }),
+  );
+
+  assert.deepEqual(plan.steps, [
+    { kind: "generate_sql", status: "skipped", reason: "no_sql" },
+    { kind: "execute_sql", status: "skipped", reason: "no_sql" },
+  ]);
+  assert.equal(plan.handoffSql, undefined);
+});
diff --git a/packages/app-tests/aiAgentStepPresentation.test.ts b/packages/app-tests/aiAgentStepPresentation.test.ts
new file mode 100644
index 0000000..481e7e0
--- /dev/null
+++ b/packages/app-tests/aiAgentStepPresentation.test.ts
@@ -0,0 +1,201 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildAiAgentStepItems, toolCallStepKey, upsertAgentStep, type AiAgentStepItem } from "../../apps/desktop/src/lib/ai/aiAgentStepPresentation.ts";
+import type { AiAgentPlan } from "../../apps/desktop/src/lib/ai/aiAgentPlan.ts";
+
+test("presents auto-execute agent plans as completed generation, safety, and execution steps", () => {
+  const plan: AiAgentPlan = {
+    executableSql: "SELECT count(*) FROM users",
+    handoffSql: "SELECT count(*) FROM users",
+    steps: [
+      { kind: "generate_sql", status: "done", sql: "SELECT count(*) FROM users" },
+      {
+        kind: "risk_check",
+        status: "done",
+        action: "auto_execute",
+        environment: "non_production",
+        category: "read",
+        reasons: [],
+      },
+      { kind: "execute_sql", status: "pending", sql: "SELECT count(*) FROM users" },
+    ],
+  };
+
+  assert.deepEqual(buildAiAgentStepItems(plan), [
+    { key: "generated", labelKey: "ai.agentSteps.generated", tone: "success" },
+    {
+      key: "safe",
+      labelKey: "ai.agentSteps.safe",
+      titleKey: "ai.agentStepTitles.riskCheck",
+      titleParams: { action: "auto_execute", category: "read", environment: "non_production", reasons: "-" },
+      tone: "success",
+    },
+    { key: "autoExecute", labelKey: "ai.agentSteps.autoExecute", tone: "active" },
+  ]);
+});
+
+test("presents blocked and confirmation plans with warning tones", () => {
+  const blocked: AiAgentPlan = {
+    handoffSql: "DROP TABLE users",
+    steps: [
+      { kind: "generate_sql", status: "done", sql: "DROP TABLE users" },
+      {
+        kind: "risk_check",
+        status: "done",
+        action: "block",
+        environment: "non_production",
+        category: "dangerous",
+        reasons: [],
+      },
+      { kind: "execute_sql", status: "skipped", reason: "blocked_by_policy" },
+    ],
+  };
+  const confirm: AiAgentPlan = {
+    handoffSql: "INSERT INTO users(name) VALUES ('a')",
+    steps: [
+      { kind: "generate_sql", status: "done", sql: "INSERT INTO users(name) VALUES ('a')" },
+      {
+        kind: "risk_check",
+        status: "done",
+        action: "confirm",
+        environment: "production",
+        category: "low_risk_write",
+        reasons: [],
+      },
+      { kind: "execute_sql", status: "skipped", reason: "requires_confirmation" },
+    ],
+  };
+
+  assert.deepEqual(
+    buildAiAgentStepItems(blocked).map((item) => [item.labelKey, item.tone, item.titleKey, item.titleParams]),
+    [
+      ["ai.agentSteps.generated", "success", undefined, undefined],
+      ["ai.agentSteps.blocked", "danger", "ai.agentStepTitles.riskCheck", { action: "block", category: "dangerous", environment: "non_production", reasons: "-" }],
+      ["ai.agentSteps.skipped", "muted", "ai.agentStepTitles.blocked", undefined],
+    ],
+  );
+  assert.deepEqual(
+    buildAiAgentStepItems(confirm).map((item) => [item.labelKey, item.tone, item.titleKey, item.titleParams]),
+    [
+      ["ai.agentSteps.generated", "success", undefined, undefined],
+      ["ai.agentSteps.needsConfirm", "warning", "ai.agentStepTitles.riskCheck", { action: "confirm", category: "low_risk_write", environment: "production", reasons: "-" }],
+      ["ai.agentSteps.skipped", "muted", "ai.agentStepTitles.requiresConfirmation", undefined],
+    ],
+  );
+});
+
+test("includes risk reasons in risk check titles", () => {
+  const plan: AiAgentPlan = {
+    handoffSql: "INSERT INTO users(name) VALUES ('a'); UPDATE users SET name='b' WHERE id=1",
+    steps: [
+      {
+        kind: "risk_check",
+        status: "done",
+        action: "confirm",
+        environment: "non_production",
+        category: "write",
+        reasons: ["multi_statement"],
+      },
+    ],
+  };
+
+  assert.deepEqual(buildAiAgentStepItems(plan)[0], {
+    key: "needsConfirm",
+    labelKey: "ai.agentSteps.needsConfirm",
+    titleKey: "ai.agentStepTitles.riskCheck",
+    titleParams: {
+      action: "confirm",
+      category: "write",
+      environment: "non_production",
+      reasons: "multi_statement",
+    },
+    tone: "warning",
+  });
+});
+
+test("presents no-sql and no-intent plans as muted skipped states", () => {
+  const noSql: AiAgentPlan = {
+    steps: [
+      { kind: "generate_sql", status: "skipped", reason: "no_sql" },
+      { kind: "execute_sql", status: "skipped", reason: "no_sql" },
+    ],
+  };
+  const noIntent: AiAgentPlan = {
+    steps: [
+      { kind: "generate_sql", status: "done", sql: "SELECT count(*) FROM users" },
+      { kind: "execute_sql", status: "skipped", reason: "no_execution_intent" },
+    ],
+  };
+
+  assert.deepEqual(
+    buildAiAgentStepItems(noSql).map((item) => item.labelKey),
+    ["ai.agentSteps.noSql", "ai.agentSteps.skipped"],
+  );
+  assert.deepEqual(
+    buildAiAgentStepItems(noIntent).map((item) => item.labelKey),
+    ["ai.agentSteps.generated", "ai.agentSteps.notRequested"],
+  );
+});
+
+test("uses stable tool step keys only for trustworthy tool call ids", () => {
+  assert.equal(toolCallStepKey("call-1", 1, "tool_call_start"), "tool-call-1");
+  assert.equal(toolCallStepKey("call-1", 2, "tool_call_end"), "tool-call-1");
+  assert.equal(toolCallStepKey("", 1, "tool_call_start"), "tool-tool_call_start-1");
+  assert.equal(toolCallStepKey("cli-tool-call", 2, "tool_call_end"), "tool-tool_call_end-2");
+});
+
+test("upserts tool call steps and preserves start args when final result arrives", () => {
+  const steps: AiAgentStepItem[] = [
+    { key: "context", labelKey: "ai.agentSteps.contextCompacted", tone: "active" },
+    {
+      key: "tool-call-1",
+      labelKey: "ai.agentSteps.callingTool",
+      tone: "active",
+      toolName: "list_tables",
+      toolArgs: { schema: "public" },
+    },
+  ];
+
+  upsertAgentStep(steps, {
+    key: "tool-call-1",
+    labelKey: "ai.agentSteps.toolDone",
+    tone: "success",
+    toolName: "list_tables",
+    toolResult: "users\norders",
+    isError: false,
+  });
+
+  assert.deepEqual(steps, [
+    { key: "context", labelKey: "ai.agentSteps.contextCompacted", tone: "active" },
+    {
+      key: "tool-call-1",
+      labelKey: "ai.agentSteps.toolDone",
+      tone: "success",
+      toolName: "list_tables",
+      toolArgs: { schema: "public" },
+      toolResult: "users\norders",
+      isError: false,
+    },
+  ]);
+});
+
+test("upserts with splice so array identity and ordering are preserved", () => {
+  const steps: AiAgentStepItem[] = [
+    { key: "before", labelKey: "before", tone: "muted" },
+    { key: "tool-call-1", labelKey: "ai.agentSteps.callingTool", tone: "active" },
+    { key: "after", labelKey: "after", tone: "muted" },
+  ];
+  const sameArray = steps;
+
+  upsertAgentStep(steps, { key: "tool-call-1", labelKey: "ai.agentSteps.toolError", tone: "danger", isError: true });
+
+  assert.equal(steps, sameArray);
+  assert.deepEqual(
+    steps.map((step) => [step.key, step.labelKey, step.tone]),
+    [
+      ["before", "before", "muted"],
+      ["tool-call-1", "ai.agentSteps.toolError", "danger"],
+      ["after", "after", "muted"],
+    ],
+  );
+});
diff --git a/packages/app-tests/aiPrompt.test.ts b/packages/app-tests/aiPrompt.test.ts
new file mode 100644
index 0000000..4294ae2
--- /dev/null
+++ b/packages/app-tests/aiPrompt.test.ts
@@ -0,0 +1,222 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import type { AiContext } from "../../apps/desktop/src/lib/ai/ai.ts";
+
+class MemoryStorage {
+  private values = new Map<string, string>();
+
+  getItem(key: string): string | null {
+    return this.values.get(key) ?? null;
+  }
+
+  setItem(key: string, value: string) {
+    this.values.set(key, value);
+  }
+
+  removeItem(key: string) {
+    this.values.delete(key);
+  }
+
+  clear() {
+    this.values.clear();
+  }
+}
+
+const localStorage = new MemoryStorage();
+localStorage.setItem("dbx-locale", "zh-CN");
+
+Object.defineProperty(globalThis, "localStorage", {
+  value: localStorage,
+  configurable: true,
+});
+
+const { buildSystemPrompt, isVectorDbType, buildUserPrompt } = await import("../../apps/desktop/src/lib/ai/ai.ts");
+
+function context(overrides: Partial<AiContext> = {}): AiContext {
+  return {
+    connectionId: "conn-1",
+    connectionName: "prod-analytics",
+    databaseType: "postgres",
+    database: "app",
+    currentSql: "",
+    tables: [
+      {
+        schema: "public",
+        name: "orders",
+        tableType: "TABLE",
+        columns: [
+          { name: "id", data_type: "uuid", is_nullable: false, is_primary_key: true },
+          { name: "user_id", data_type: "uuid", is_nullable: false },
+          { name: "total", data_type: "numeric", is_nullable: false },
+        ],
+        indexes: [{ name: "idx_orders_user_id", columns: ["user_id"], is_unique: false, is_primary: false }],
+        foreignKeys: [{ column: "user_id", ref_table: "users", ref_column: "id" }],
+      },
+    ],
+    sqlFiles: [],
+    truncated: false,
+    ...overrides,
+  };
+}
+
+test("agent mode prompt makes the first SQL block the executable recommendation", () => {
+  const prompt = buildSystemPrompt("generate", context(), "agent");
+
+  assert.match(prompt, /Agent 模式/);
+  assert.match(prompt, /第一个 ```sql 代码块只放最终推荐 SQL/);
+  assert.match(prompt, /execute_query/);
+});
+
+test("ask mode prompt forbids auto-execution assumptions", () => {
+  const prompt = buildSystemPrompt("generate", context(), "ask");
+
+  assert.match(prompt, /Ask 模式/);
+  assert.match(prompt, /只生成 SQL 和说明/);
+  assert.match(prompt, /不要暗示已经执行或即将自动执行/);
+});
+
+test("prompt gives explicit guidance for truncated schema context", () => {
+  const prompt = buildSystemPrompt("generate", context({ truncated: true }), "ask");
+
+  assert.match(prompt, /Schema context is truncated/);
+  assert.match(prompt, /如果请求可能涉及未出现的表或字段，不要猜测/);
+  assert.match(prompt, /@table/);
+});
+
+test("focused table context is not presented as a complete table list", () => {
+  const prompt = buildSystemPrompt("generate", context({ schemaScope: "focused_table" }), "agent");
+
+  assert.match(prompt, /focused table only; not a complete database table list/);
+  assert.match(prompt, /当前打开的表/);
+  assert.match(prompt, /只读元数据查询/);
+  assert.doesNotMatch(prompt, /Schema context is complete\./);
+});
+
+test("prompt enforces database dialect and single executable statement safety", () => {
+  const prompt = buildSystemPrompt("generate", context({ databaseType: "sqlserver" }), "agent");
+
+  assert.match(prompt, /严格使用当前数据库方言/);
+  assert.match(prompt, /分页、日期函数、字符串拼接/);
+  assert.match(prompt, /不要生成多语句 SQL/);
+  assert.match(prompt, /不要在同一个回答里混合 SELECT 和写操作/);
+});
+
+test("prompt includes referenced SQL library files as additional context", () => {
+  const prompt = buildSystemPrompt(
+    "generate",
+    context({
+      sqlFiles: [
+        {
+          id: "sql-1",
+          name: "monthly-orders.sql",
+          sql: "select date_trunc('month', created_at) as month, count(*) from public.orders group by 1",
+        },
+      ],
+    }),
+    "ask",
+  );
+
+  assert.match(prompt, /SQL 库文件是额外上下文/);
+  assert.match(prompt, /Referenced SQL library files:/);
+  assert.match(prompt, /File: monthly-orders\.sql/);
+  assert.match(prompt, /date_trunc\('month', created_at\)/);
+});
+
+// Vector database tests
+
+function vectorContext(overrides: Partial<AiContext> = {}): AiContext {
+  return {
+    connectionId: "conn-1",
+    connectionName: "my-qdrant",
+    databaseType: "qdrant",
+    database: "default",
+    currentSql: "articles",
+    tables: [
+      {
+        name: "articles",
+        tableType: "COLLECTION",
+        comment: "384d vector",
+        columns: [],
+      },
+    ],
+    sqlFiles: [],
+    truncated: false,
+    ...overrides,
+  };
+}
+
+test("isVectorDbType returns true for vector databases", () => {
+  assert.equal(isVectorDbType("qdrant"), true);
+  assert.equal(isVectorDbType("milvus"), true);
+  assert.equal(isVectorDbType("weaviate"), true);
+  assert.equal(isVectorDbType("chromadb"), true);
+});
+
+test("isVectorDbType returns false for SQL databases", () => {
+  assert.equal(isVectorDbType("mysql"), false);
+  assert.equal(isVectorDbType("postgres"), false);
+  assert.equal(isVectorDbType("sqlserver"), false);
+});
+
+test("vector system prompt does not contain SQL references", () => {
+  const prompt = buildSystemPrompt("generate", vectorContext(), "ask");
+
+  assert.doesNotMatch(prompt, /```sql/);
+  assert.doesNotMatch(prompt, /execute_query/);
+  assert.match(prompt, /collection/);
+  assert.match(prompt, /REST API/);
+});
+
+test("vector agent mode lists vector tools", () => {
+  const prompt = buildSystemPrompt("generate", vectorContext(), "agent");
+
+  assert.match(prompt, /list_collections/);
+  assert.match(prompt, /browse_collection/);
+  assert.doesNotMatch(prompt, /execute_query/);
+  assert.doesNotMatch(prompt, /list_tables/);
+});
+
+test("vector focused table prompt warns about unknown collections", () => {
+  const prompt = buildSystemPrompt("generate", vectorContext({ schemaScope: "focused_table" }), "agent");
+
+  assert.match(prompt, /不是完整的集合列表/);
+  assert.match(prompt, /当前打开的集合/);
+  assert.match(prompt, /list_collections/);
+});
+
+test("vector ask mode mentions REST API format", () => {
+  const prompt = buildSystemPrompt("generate", vectorContext(), "ask");
+
+  assert.match(prompt, /REST API/);
+  assert.match(prompt, /Qdrant/);
+  assert.match(prompt, /list_collections/);
+  assert.match(prompt, /do not browse collection data|不要浏览集合数据/);
+  assert.doesNotMatch(prompt, /```sql/);
+  assert.doesNotMatch(prompt, /execute_query/);
+});
+
+test("vector system prompt preserves last error and result preview", () => {
+  const prompt = buildSystemPrompt(
+    "generate",
+    vectorContext({
+      lastError: "Qdrant error",
+      lastResultPreview: "id | payload\n1 | {}",
+    }),
+    "ask",
+  );
+
+  assert.match(prompt, /Last error:\nQdrant error/);
+  assert.match(prompt, /Last result preview:\nid \| payload/);
+});
+
+test("buildUserPrompt skips action instruction for vector databases", () => {
+  const vectorCtx = vectorContext();
+  const sqlCtx = context();
+
+  const vectorPrompt = buildUserPrompt("generate", vectorCtx, "show me articles", true);
+  assert.equal(vectorPrompt, "show me articles");
+
+  const sqlPrompt = buildUserPrompt("generate", sqlCtx, "show me users", true);
+  assert.match(sqlPrompt, /Action: generate/);
+  assert.match(sqlPrompt, /生成 SQL/);
+});
diff --git a/packages/app-tests/aiPromptEval.test.ts b/packages/app-tests/aiPromptEval.test.ts
new file mode 100644
index 0000000..9630b39
--- /dev/null
+++ b/packages/app-tests/aiPromptEval.test.ts
@@ -0,0 +1,178 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import type { AiAction, AiAssistantMode, AiContext } from "../../apps/desktop/src/lib/ai/ai.ts";
+
+class MemoryStorage {
+  private values = new Map<string, string>();
+
+  getItem(key: string): string | null {
+    return this.values.get(key) ?? null;
+  }
+
+  setItem(key: string, value: string) {
+    this.values.set(key, value);
+  }
+
+  removeItem(key: string) {
+    this.values.delete(key);
+  }
+
+  clear() {
+    this.values.clear();
+  }
+}
+
+const localStorage = new MemoryStorage();
+localStorage.setItem("dbx-locale", "zh-CN");
+
+Object.defineProperty(globalThis, "localStorage", {
+  value: localStorage,
+  configurable: true,
+});
+
+const { buildSystemPrompt } = await import("../../apps/desktop/src/lib/ai/ai.ts");
+
+function baseContext(overrides: Partial<AiContext> = {}): AiContext {
+  return {
+    connectionId: "conn-1",
+    connectionName: "prod-analytics",
+    databaseType: "postgres",
+    database: "warehouse",
+    currentSql: "select user_id, count(*) from public.orders group by user_id",
+    lastError: undefined,
+    lastResultPreview: 'user_id="u1", count=3\nuser_id="u2", count=7',
+    tables: [
+      {
+        schema: "public",
+        name: "orders",
+        tableType: "TABLE",
+        columns: [
+          { name: "id", data_type: "uuid", is_nullable: false, is_primary_key: true },
+          { name: "user_id", data_type: "uuid", is_nullable: false },
+          { name: "created_at", data_type: "timestamp", is_nullable: false },
+          { name: "total", data_type: "numeric", is_nullable: false },
+        ],
+        indexes: [
+          { name: "idx_orders_user_id", columns: ["user_id"], is_unique: false, is_primary: false },
+          { name: "idx_orders_created_at", columns: ["created_at"], is_unique: false, is_primary: false },
+        ],
+        foreignKeys: [{ column: "user_id", ref_table: "users", ref_column: "id" }],
+      },
+      {
+        schema: "public",
+        name: "users",
+        tableType: "TABLE",
+        columns: [
+          { name: "id", data_type: "uuid", is_nullable: false, is_primary_key: true },
+          { name: "email", data_type: "text", is_nullable: false },
+        ],
+      },
+    ],
+    sqlFiles: [],
+    truncated: false,
+    ...overrides,
+  };
+}
+
+interface PromptEvalCase {
+  name: string;
+  action: AiAction;
+  mode: AiAssistantMode;
+  context?: Partial<AiContext>;
+  mustInclude: RegExp[];
+  mustNotInclude?: RegExp[];
+}
+
+const cases: PromptEvalCase[] = [
+  {
+    name: "agent generate keeps the first SQL block executable and read-oriented",
+    action: "generate",
+    mode: "agent",
+    mustInclude: [/Agent 模式/, /execute_query/, /第一个 ```sql 代码块只放最终推荐 SQL/, /只有 SELECT.*WITH.*SHOW.*DESCRIBE.*EXPLAIN.*可以通过 execute_query 执行/],
+  },
+  {
+    name: "ask generate never implies auto execution",
+    action: "generate",
+    mode: "ask",
+    mustInclude: [/Ask 模式/, /只生成 SQL 和说明/, /不要暗示已经执行或即将自动执行/],
+  },
+  {
+    name: "truncated schema blocks guessing and points users to table mentions",
+    action: "generate",
+    mode: "ask",
+    context: { truncated: true },
+    mustInclude: [/Schema context is truncated/, /不要猜测/, /@table/, /只读探索\/元数据查询/],
+  },
+  {
+    name: "focused table context tells agent to verify table inventory with metadata SQL",
+    action: "generate",
+    mode: "agent",
+    context: { schemaScope: "focused_table" },
+    mustInclude: [/focused table only; not a complete database table list/, /不要直接断言不存在/, /只读元数据查询/, /有哪些表/],
+    mustNotInclude: [/Schema context is complete\./],
+  },
+  {
+    name: "sqlserver generation requires dialect-specific pagination and quoting",
+    action: "generate",
+    mode: "agent",
+    context: { databaseType: "sqlserver" },
+    mustInclude: [/Database type: sqlserver/, /严格使用当前数据库方言/, /LIMIT\/TOP\/OFFSET/],
+  },
+  {
+    name: "optimization uses index evidence and calls out full scans",
+    action: "optimize",
+    mode: "ask",
+    mustInclude: [/idx_orders_user_id/, /索引信息/, /全表扫描/, /最多 3 条说明/],
+  },
+  {
+    name: "fixing SQL includes the backend error and a corrected SQL contract",
+    action: "fix",
+    mode: "ask",
+    context: { lastError: 'column "userid" does not exist' },
+    mustInclude: [/Last error:\ncolumn "userid" does not exist/, /修正后的 SQL/, /错误原因/, /改动说明/],
+  },
+  {
+    name: "explain action keeps execution logic, risks, and performance in scope",
+    action: "explain",
+    mode: "ask",
+    mustInclude: [/Current SQL:\nselect user_id/, /执行逻辑/, /风险点/, /性能注意事项/],
+  },
+  {
+    name: "convert action requires target dialect caveats",
+    action: "convert",
+    mode: "ask",
+    mustInclude: [/转换后的 SQL/, /目标方言/, /语法差异或不兼容点/],
+  },
+  {
+    name: "sample data action separates mock data from real production data",
+    action: "sampleData",
+    mode: "ask",
+    mustInclude: [/安全的示例 SQL/, /模拟数据/, /生产库写操作只给建议/],
+  },
+  {
+    name: "base prompt keeps destructive SQL and multi-statement safety rails",
+    action: "generate",
+    mode: "agent",
+    mustInclude: [/不要生成多语句 SQL/, /不要在同一个回答里混合 SELECT 和写操作/, /UPDATE 或 DELETE，必须带 WHERE/],
+  },
+  {
+    name: "schema evidence includes foreign keys and indexes for join reasoning",
+    action: "generate",
+    mode: "ask",
+    mustInclude: [/FK: user_id → users\.id/, /Index: idx_orders_user_id\(user_id\)/, /利用外键关系推断 JOIN 条件/],
+  },
+];
+
+for (const item of cases) {
+  test(`AI prompt eval: ${item.name}`, () => {
+    const prompt = buildSystemPrompt(item.action, baseContext(item.context), item.mode);
+
+    for (const pattern of item.mustInclude) {
+      assert.match(prompt, pattern, `${item.name} should include ${pattern}`);
+    }
+
+    for (const pattern of item.mustNotInclude ?? []) {
+      assert.doesNotMatch(prompt, pattern, `${item.name} should not include ${pattern}`);
+    }
+  });
+}
diff --git a/packages/app-tests/aiPromptKeyboard.test.ts b/packages/app-tests/aiPromptKeyboard.test.ts
new file mode 100644
index 0000000..f0d8a83
--- /dev/null
+++ b/packages/app-tests/aiPromptKeyboard.test.ts
@@ -0,0 +1,28 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { isAiPromptImeCompositionEvent, shouldSubmitAiPromptOnKeydown } from "../../apps/desktop/src/lib/ai/aiPromptKeyboard.ts";
+
+test("submits AI prompt on plain Enter", () => {
+  assert.equal(shouldSubmitAiPromptOnKeydown({ key: "Enter" }), true);
+});
+
+test("does not submit AI prompt while entering a newline", () => {
+  assert.equal(shouldSubmitAiPromptOnKeydown({ key: "Enter", shiftKey: true }), false);
+});
+
+test("does not submit AI prompt while IME composition is active", () => {
+  assert.equal(shouldSubmitAiPromptOnKeydown({ key: "Enter", isComposing: true }), false);
+  assert.equal(shouldSubmitAiPromptOnKeydown({ key: "Enter" }, true), false);
+});
+
+test("does not submit AI prompt for IME composition key events", () => {
+  assert.equal(shouldSubmitAiPromptOnKeydown({ key: "Enter", keyCode: 229 }), false);
+  assert.equal(shouldSubmitAiPromptOnKeydown({ key: "Process" }), false);
+});
+
+test("detects AI prompt IME composition key events before mention handling", () => {
+  assert.equal(isAiPromptImeCompositionEvent({ key: "Enter", isComposing: true }), true);
+  assert.equal(isAiPromptImeCompositionEvent({ key: "Enter", keyCode: 229 }), true);
+  assert.equal(isAiPromptImeCompositionEvent({ key: "Process" }), true);
+  assert.equal(isAiPromptImeCompositionEvent({ key: "Enter" }), false);
+});
diff --git a/packages/app-tests/aiSchemaComments.test.ts b/packages/app-tests/aiSchemaComments.test.ts
new file mode 100644
index 0000000..1dc8eb7
--- /dev/null
+++ b/packages/app-tests/aiSchemaComments.test.ts
@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+
+import { buildSystemPrompt, type AiContext } from "../../apps/desktop/src/lib/ai/ai.ts";
+
+const BASE_CONTEXT: AiContext = {
+  connectionId: "conn-1",
+  connectionName: "local",
+  databaseType: "mysql",
+  database: "app",
+  currentSql: "",
+  tables: [
+    {
+      name: "users",
+      tableType: "BASE TABLE",
+      comment: "用户表",
+      columns: [
+        {
+          name: "id",
+          data_type: "bigint",
+          is_nullable: false,
+          column_default: null,
+          is_primary_key: true,
+          extra: null,
+          comment: "用户ID",
+        },
+        {
+          name: "nickname",
+          data_type: "varchar(64)",
+          is_nullable: true,
+          column_default: null,
+          is_primary_key: false,
+          extra: null,
+          comment: "用户昵称",
+        },
+      ],
+    },
+  ],
+  sqlFiles: [],
+  truncated: false,
+};
+
+test("AI schema context includes table and column comments", () => {
+  const prompt = buildSystemPrompt("generate", BASE_CONTEXT);
+
+  assert.match(prompt, /users \(BASE TABLE\)/);
+  assert.match(prompt, /Comment: 用户表/);
+  assert.match(prompt, /- id: bigint \(PK, NOT NULL\) -- 用户ID/);
+  assert.match(prompt, /- nickname: varchar\(64\) \(nullable\) -- 用户昵称/);
+});
diff --git a/packages/app-tests/aiSkills.test.ts b/packages/app-tests/aiSkills.test.ts
new file mode 100644
index 0000000..2dd8e93
--- /dev/null
+++ b/packages/app-tests/aiSkills.test.ts
@@ -0,0 +1,55 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import type { AiAction } from "../../apps/desktop/src/lib/ai/ai.ts";
+import { AI_SKILL_DEFINITIONS, aiSkillForAction } from "../../apps/desktop/src/lib/ai/aiSkills.ts";
+
+const actions: AiAction[] = [
+  "general",
+  "generate",
+  "explain",
+  "optimize",
+  "fix",
+  "convert",
+  "sampleData",
+  "query",
+  "exploreSchema",
+  "executeAndExplain",
+];
+
+test("defines one internal AI skill per assistant action", () => {
+  assert.deepEqual(AI_SKILL_DEFINITIONS.map((skill) => skill.action).sort(), [...actions].sort());
+
+  for (const action of actions) {
+    const skill = aiSkillForAction(action);
+
+    assert.equal(skill.action, action);
+    assert.match(skill.id, /^[a-z][a-z0-9_]*$/);
+    assert.ok(skill.title.zh);
+    assert.ok(skill.title.en);
+    // general skill has empty contextNeeds, others must have at least one
+    if (action !== "general") {
+      assert.ok(skill.contextNeeds.length > 0);
+    }
+    assert.ok(skill.systemRules.zh.length > 0);
+    assert.ok(skill.systemRules.en.length > 0);
+    assert.ok(skill.userInstruction.zh.length > 0);
+    assert.ok(skill.userInstruction.en.length > 0);
+  }
+});
+
+test("captures safety and output contracts for agent-ready skills", () => {
+  const generate = aiSkillForAction("generate");
+  assert.equal(generate.riskPolicy, "readonly_preferred");
+  assert.match(generate.outputContract.zh.join("\n"), /第一个 ```sql 代码块/);
+  assert.match(generate.systemRules.zh.join("\n"), /外键关系/);
+
+  const optimize = aiSkillForAction("optimize");
+  assert.equal(optimize.riskPolicy, "readonly");
+  assert.deepEqual(optimize.contextNeeds, ["currentSql", "schema", "indexes", "foreignKeys"]);
+  assert.match(optimize.systemRules.zh.join("\n"), /索引信息/);
+  assert.match(optimize.outputContract.zh.join("\n"), /最多 3 条说明/);
+
+  const fix = aiSkillForAction("fix");
+  assert.ok(fix.contextNeeds.includes("lastError"));
+  assert.match(fix.outputContract.zh.join("\n"), /错误原因/);
+});
diff --git a/packages/app-tests/aiSqlAppend.test.ts b/packages/app-tests/aiSqlAppend.test.ts
new file mode 100644
index 0000000..fd6130d
--- /dev/null
+++ b/packages/app-tests/aiSqlAppend.test.ts
@@ -0,0 +1,35 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildAppendedEditorSql } from "../../apps/desktop/src/lib/ai/aiSqlAppend.ts";
+
+test("buildAppendedEditorSql returns newSql unchanged when editor is empty", () => {
+  assert.equal(buildAppendedEditorSql("", "SELECT 1"), "SELECT 1");
+});
+
+test("buildAppendedEditorSql prepends blank-line separator when editor has content", () => {
+  assert.equal(buildAppendedEditorSql("SELECT 1", "SELECT 2"), "SELECT 1\n\nSELECT 2");
+});
+
+test("buildAppendedEditorSql preserves multiline existing content", () => {
+  assert.equal(buildAppendedEditorSql("SELECT *\nFROM users", "SELECT *\nFROM orders"), "SELECT *\nFROM users\n\nSELECT *\nFROM orders");
+});
+
+test("buildAppendedEditorSql preserves trailing newlines already present in the editor", () => {
+  assert.equal(buildAppendedEditorSql("SELECT 1\n\n\n", "SELECT 2"), "SELECT 1\n\n\nSELECT 2");
+});
+
+test("buildAppendedEditorSql preserves trailing spaces", () => {
+  assert.equal(buildAppendedEditorSql("SELECT 1   ", "SELECT 2"), "SELECT 1   \n\nSELECT 2");
+});
+
+test("buildAppendedEditorSql preserves trailing tabs", () => {
+  assert.equal(buildAppendedEditorSql("SELECT 1\t\t", "SELECT 2"), "SELECT 1\t\t\n\nSELECT 2");
+});
+
+test("buildAppendedEditorSql preserves whitespace-only editor content", () => {
+  assert.equal(buildAppendedEditorSql(" \t ", "SELECT 2"), " \t \n\nSELECT 2");
+});
+
+test("buildAppendedEditorSql preserves unfinished SQL", () => {
+  assert.equal(buildAppendedEditorSql("SELECT * FROM", "SELECT * FROM users"), "SELECT * FROM\n\nSELECT * FROM users");
+});
diff --git a/packages/app-tests/aiSqlExecutionPolicy.test.ts b/packages/app-tests/aiSqlExecutionPolicy.test.ts
new file mode 100644
index 0000000..af66186
--- /dev/null
+++ b/packages/app-tests/aiSqlExecutionPolicy.test.ts
@@ -0,0 +1,89 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { classifyAiSqlExecution, classifyConnectionEnvironment, shouldAttemptAiAutoExecute } from "../../apps/desktop/src/lib/ai/aiSqlExecutionPolicy.ts";
+import type { ConnectionConfig } from "../../apps/desktop/src/types/database.ts";
+
+function conn(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
+  return {
+    id: "c1",
+    name: "local-pg",
+    db_type: "postgres",
+    host: "127.0.0.1",
+    port: 5432,
+    username: "postgres",
+    password: "",
+    database: "app_dev",
+    ...overrides,
+  };
+}
+
+test("classifyConnectionEnvironment treats local and dev targets as non-production", () => {
+  assert.equal(classifyConnectionEnvironment(conn()), "non_production");
+  assert.equal(classifyConnectionEnvironment(conn({ name: "staging-db", host: "10.0.0.8" })), "non_production");
+});
+
+test("classifyConnectionEnvironment treats production signals and unknown targets as production-like", () => {
+  assert.equal(classifyConnectionEnvironment(conn({ name: "prod-db", host: "10.0.0.9" })), "production");
+  assert.equal(classifyConnectionEnvironment(conn({ name: "analytics", host: "10.0.0.9", database: "warehouse" })), "unknown");
+});
+
+test("read SQL auto-executes on production and non-production", () => {
+  assert.equal(classifyAiSqlExecution("SELECT * FROM users", conn()).action, "auto_execute");
+  assert.equal(classifyAiSqlExecution("SHOW TABLES", conn({ name: "prod-db" })).action, "auto_execute");
+});
+
+test("single insert auto-executes only on non-production targets", () => {
+  assert.equal(classifyAiSqlExecution("INSERT INTO users(name) VALUES ('a')", conn()).action, "auto_execute");
+  assert.equal(classifyAiSqlExecution("INSERT INTO users(name) VALUES ('a')", conn({ name: "prod-db" })).action, "confirm");
+});
+
+test("scoped single update auto-executes only on non-production targets", () => {
+  const sql = "UPDATE users SET name = 'a' WHERE id = 1";
+  assert.equal(classifyAiSqlExecution(sql, conn()).action, "auto_execute");
+  assert.equal(classifyAiSqlExecution(sql, conn({ name: "prod-db" })).action, "confirm");
+});
+
+test("production target databases require confirmation even from staging", () => {
+  const decision = classifyAiSqlExecution(
+    "DELETE FROM prod_app.users WHERE id = 1",
+    conn({ db_type: "mysql", name: "staging-db", host: "10.0.0.8", database: "staging", production_databases: ["prod_app"] }),
+    "staging",
+  );
+
+  assert.equal(decision.action, "confirm");
+  assert.equal(decision.environment, "production");
+  assert.deepEqual(decision.reasons, ["production_write"]);
+});
+
+test("broad or destructive writes do not auto-execute", () => {
+  assert.equal(classifyAiSqlExecution("UPDATE users SET name = 'a'", conn()).action, "block");
+  assert.equal(classifyAiSqlExecution("UPDATE users SET name = 'a' WHERE 1=1", conn()).action, "block");
+  assert.equal(classifyAiSqlExecution("DELETE FROM users WHERE id = 1", conn()).action, "confirm");
+  assert.equal(classifyAiSqlExecution("DROP TABLE users", conn()).action, "block");
+});
+
+test("comments and multi-statement writes do not bypass policy", () => {
+  assert.equal(classifyAiSqlExecution("-- SELECT\nDROP TABLE users", conn()).action, "block");
+  assert.equal(classifyAiSqlExecution("INSERT INTO users(name) VALUES ('a'); UPDATE users SET name='b' WHERE id=1", conn()).action, "confirm");
+});
+
+test("AI auto-execution trusts generated SQL in agent generate mode unless the user opts out", () => {
+  assert.equal(shouldAttemptAiAutoExecute("查一下用户数量", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("帮我查ihli的平均值", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("看下 ihli 平均是多少", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("求 ihli 的最大值", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("计算 ihli 总数", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("显示最近 10 条订单", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("获取用户数量", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("当前有哪些表", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("这个库有什么表", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("当前表列表", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("show me recent orders", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("现在库里表的情况是？", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("生成一个查询用户数量的 SQL", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("你好", "generate"), true);
+  assert.equal(shouldAttemptAiAutoExecute("", "generate"), false);
+  assert.equal(shouldAttemptAiAutoExecute("只生成 SQL，不要执行", "generate"), false);
+  assert.equal(shouldAttemptAiAutoExecute("先别跑，帮我查一下用户数量", "generate"), false);
+  assert.equal(shouldAttemptAiAutoExecute("优化这条 SQL", "optimize"), false);
+});
diff --git a/packages/app-tests/aiTableMentions.test.ts b/packages/app-tests/aiTableMentions.test.ts
new file mode 100644
index 0000000..09d5a6f
--- /dev/null
+++ b/packages/app-tests/aiTableMentions.test.ts
@@ -0,0 +1,26 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { formatAiTableMention, parseAiTableMentions } from "../../apps/desktop/src/lib/ai/aiTableMentions.ts";
+
+test("parses simple and schema-qualified AI table mentions", () => {
+  assert.deepEqual(parseAiTableMentions("show @users and join @public.orders"), [
+    { raw: "@users", schema: undefined, table: "users" },
+    { raw: "@public.orders", schema: "public", table: "orders" },
+  ]);
+});
+
+test("parses quoted AI table mentions with spaces and dots", () => {
+  assert.deepEqual(parseAiTableMentions('compare @"sales schema"."order.items" with @"audit log"'), [
+    { raw: '@"sales schema"."order.items"', schema: "sales schema", table: "order.items" },
+    { raw: '@"audit log"', schema: undefined, table: "audit log" },
+  ]);
+});
+
+test("deduplicates AI table mentions case-insensitively", () => {
+  assert.deepEqual(parseAiTableMentions("check @public.Users then @PUBLIC.users"), [{ raw: "@public.Users", schema: "public", table: "Users" }]);
+});
+
+test("formats AI table mentions with quotes only when needed", () => {
+  assert.equal(formatAiTableMention("public", "users"), "@public.users");
+  assert.equal(formatAiTableMention("sales schema", "order items"), '@"sales schema"."order items"');
+});
diff --git a/packages/app-tests/appUpdater.test.ts b/packages/app-tests/appUpdater.test.ts
new file mode 100644
index 0000000..74f25de
--- /dev/null
+++ b/packages/app-tests/appUpdater.test.ts
@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+
+import { canDownloadAndInstallUpdate, normalizeUpdateDownloadSource, resolveUpdateReleaseUrl, tagVersion } from "../../apps/desktop/src/composables/useAppUpdater.ts";
+import type { UpdateInfo } from "../../apps/desktop/src/lib/backend/api.ts";
+
+function updateInfo(overrides: Partial<UpdateInfo> = {}): UpdateInfo {
+  return {
+    current_version: "0.5.25",
+    latest_version: "0.5.26",
+    update_available: true,
+    portable_mode: false,
+    release_name: "DBX v0.5.26",
+    release_url: "https://github.com/t8y2/dbx/releases/tag/v0.5.26",
+    release_notes: "",
+    ...overrides,
+  };
+}
+
+test("allows in-app update installation for installed desktop builds", () => {
+  assert.equal(canDownloadAndInstallUpdate(updateInfo(), true), true);
+});
+
+test("blocks in-app update installation for portable builds", () => {
+  assert.equal(canDownloadAndInstallUpdate(updateInfo({ portable_mode: true }), true), false);
+});
+
+test("blocks in-app update installation outside desktop runtime or without an update", () => {
+  assert.equal(canDownloadAndInstallUpdate(updateInfo(), false), false);
+  assert.equal(canDownloadAndInstallUpdate(updateInfo({ update_available: false }), true), false);
+  assert.equal(canDownloadAndInstallUpdate(null, true), false);
+});
+
+test("normalizes update download source", () => {
+  assert.equal(normalizeUpdateDownloadSource("official"), "official");
+  assert.equal(normalizeUpdateDownloadSource("cnb"), "cnb");
+  assert.equal(normalizeUpdateDownloadSource("atomgit"), "atomgit");
+  assert.equal(normalizeUpdateDownloadSource("unknown"), "official");
+});
+
+test("normalizes release tag versions", () => {
+  assert.equal(tagVersion("0.5.39"), "v0.5.39");
+  assert.equal(tagVersion("v0.5.39"), "v0.5.39");
+});
+
+test("resolves release page URL from update download source", () => {
+  const fallbackUrl = "https://github.com/t8y2/dbx/releases/latest";
+  assert.equal(resolveUpdateReleaseUrl(updateInfo({ latest_version: "0.5.39" }), "cnb", fallbackUrl), "https://cnb.cool/dbxio.com/dbx/-/releases/tag/v0.5.39");
+  assert.equal(resolveUpdateReleaseUrl(updateInfo({ latest_version: "0.5.44" }), "atomgit", fallbackUrl), "https://atomgit.com/t8y2/dbx/releases/v0.5.44");
+  assert.equal(resolveUpdateReleaseUrl(updateInfo({ release_url: "https://github.com/t8y2/dbx/releases/tag/v0.5.39" }), "official", fallbackUrl), "https://github.com/t8y2/dbx/releases/tag/v0.5.39");
+  assert.equal(resolveUpdateReleaseUrl(null, "cnb", fallbackUrl), fallbackUrl);
+});
diff --git a/packages/app-tests/binaryCellDownload.test.ts b/packages/app-tests/binaryCellDownload.test.ts
new file mode 100644
index 0000000..7df5444
--- /dev/null
+++ b/packages/app-tests/binaryCellDownload.test.ts
@@ -0,0 +1,63 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+
+import { binaryCellDisplayText, binaryCellDownloadFileName, binaryCellDownloadPayload, canDownloadBinaryCellValue, isBinaryCellColumnType, parseBinaryCellBytes, parseBinaryCellHexValue } from "../../apps/desktop/src/lib/dataGrid/binaryCellDownload.ts";
+
+test("parseBinaryCellHexValue accepts 0x and \\x prefixed hex values", () => {
+  assert.deepEqual(Array.from(parseBinaryCellHexValue("0X48656c6c6f") ?? []), [72, 101, 108, 108, 111]);
+  assert.deepEqual(Array.from(parseBinaryCellHexValue("\\x00 ff") ?? []), [0, 255]);
+});
+
+test("parseBinaryCellHexValue rejects non-hex and odd-length payloads", () => {
+  assert.equal(parseBinaryCellHexValue("hello"), null);
+  assert.equal(parseBinaryCellHexValue("0x123"), null);
+  assert.equal(parseBinaryCellHexValue(null), null);
+});
+
+test("parseBinaryCellBytes accepts common driver binary shapes", () => {
+  assert.deepEqual(Array.from(parseBinaryCellBytes("89504e47", "BLOB") ?? []), [137, 80, 78, 71]);
+  assert.deepEqual(Array.from(parseBinaryCellBytes("\\x89\\x50\\x4e\\x47") ?? []), [137, 80, 78, 71]);
+  assert.deepEqual(Array.from(parseBinaryCellBytes([0, 1, 171, 255]) ?? []), [0, 1, 171, 255]);
+  assert.deepEqual(Array.from(parseBinaryCellBytes({ type: "Buffer", data: [222, 173, 190, 239] }) ?? []), [222, 173, 190, 239]);
+});
+
+test("binary cell download detects common blob column types", () => {
+  assert.equal(isBinaryCellColumnType("BLOB"), true);
+  assert.equal(isBinaryCellColumnType("RAW(2000)"), true);
+  assert.equal(isBinaryCellColumnType("long raw"), true);
+  assert.equal(isBinaryCellColumnType("varchar"), false);
+});
+
+test("canDownloadBinaryCellValue allows displayed binary hex strings", () => {
+  assert.equal(canDownloadBinaryCellValue("0x89504e47", "BLOB"), true);
+  assert.equal(canDownloadBinaryCellValue("0x89504e47"), true);
+  assert.equal(canDownloadBinaryCellValue("89504e47", "BLOB"), true);
+  assert.equal(canDownloadBinaryCellValue("89504e47"), false);
+});
+
+test("binaryCellDisplayText summarizes binary values for grid display", () => {
+  assert.equal(binaryCellDisplayText("0x89504e47", "BLOB"), "BLOB [4 bytes]");
+  assert.equal(binaryCellDisplayText(`0x${"00".repeat(2048)}`, "VARBINARY(2048)"), "VARBINARY [2.0 KB]");
+  assert.equal(binaryCellDisplayText("0x89504e47"), null);
+});
+
+test("binaryCellDownloadPayload builds raw and decoded payloads", () => {
+  const binary = binaryCellDownloadPayload("0x4869", "binary");
+  assert.equal(binary.mimeType, "application/octet-stream");
+  assert.equal(binary.extension, "bin");
+  assert.deepEqual(Array.from(binary.data as Uint8Array), [72, 105]);
+
+  const text = binaryCellDownloadPayload("0x4869", "utf8");
+  assert.equal(text.mimeType, "text/plain;charset=utf-8");
+  assert.equal(text.extension, "txt");
+  assert.equal(text.data, "Hi");
+});
+
+test("binaryCellDownloadPayload decodes GBK text bytes", () => {
+  const payload = binaryCellDownloadPayload("0xd6d0cec4", "gbk");
+  assert.equal(payload.data, "中文");
+});
+
+test("binaryCellDownloadFileName sanitizes column names", () => {
+  assert.equal(binaryCellDownloadFileName({ column: "avatar/blob", rowNumber: 7, mode: "gbk", extension: "txt" }), "avatar-blob-row-7-gbk.txt");
+});
diff --git a/packages/app-tests/binaryHexViewer.test.ts b/packages/app-tests/binaryHexViewer.test.ts
new file mode 100644
index 0000000..dc8f5ca
--- /dev/null
+++ b/packages/app-tests/binaryHexViewer.test.ts
@@ -0,0 +1,24 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { buildBinaryHexViewRows } from "../../apps/desktop/src/lib/dataGrid/binaryHexViewer.ts";
+
+test("buildBinaryHexViewRows formats offsets, hex bytes, and ascii preview", () => {
+  const bytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x20, 0x41, 0x7e, 0x7f, 0x00, 0x01, 0x02, 0xff, 0x48]);
+
+  assert.deepEqual(buildBinaryHexViewRows(bytes), [
+    {
+      offset: "00000000",
+      hex: "89 50 4E 47 0D 0A 1A 0A 20 41 7E 7F 00 01 02 FF",
+      ascii: ".PNG.... A~.....",
+    },
+    {
+      offset: "00000010",
+      hex: "48",
+      ascii: "H",
+    },
+  ]);
+});
+
+test("buildBinaryHexViewRows handles empty binary values", () => {
+  assert.deepEqual(buildBinaryHexViewRows(new Uint8Array()), []);
+});
diff --git a/packages/app-tests/canvasDataGridRenderer.test.ts b/packages/app-tests/canvasDataGridRenderer.test.ts
new file mode 100644
index 0000000..b193e35
--- /dev/null
+++ b/packages/app-tests/canvasDataGridRenderer.test.ts
@@ -0,0 +1,23 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { fitCanvasText } from "../../apps/desktop/src/lib/dataGrid/canvasDataGridRenderer.ts";
+
+function measureContext(charWidth = 1): CanvasRenderingContext2D {
+  return {
+    font: "13px sans-serif",
+    measureText: (text: string) => ({ width: text.length * charWidth }),
+  } as CanvasRenderingContext2D;
+}
+
+test("fitCanvasText keeps text that fits the available cell width", () => {
+  const ctx = measureContext();
+  const text = "1234567890abcdefghijklmnopqrst";
+
+  assert.equal(fitCanvasText(ctx, text, text.length), text);
+});
+
+test("fitCanvasText truncates only when text exceeds the available cell width", () => {
+  const ctx = measureContext();
+
+  assert.equal(fitCanvasText(ctx, "1234567890", 8), "12345...");
+});
diff --git a/packages/app-tests/cellDetailPresentation.test.ts b/packages/app-tests/cellDetailPresentation.test.ts
new file mode 100644
index 0000000..8f9ebf6
--- /dev/null
+++ b/packages/app-tests/cellDetailPresentation.test.ts
@@ -0,0 +1,12 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { visibleCellDetailTabs } from "../../apps/desktop/src/lib/dataGrid/cellDetailPresentation.ts";
+
+test("visibleCellDetailTabs exposes hex viewer only for binary details", () => {
+  assert.deepEqual(visibleCellDetailTabs({ isEditable: false }), ["details"]);
+  assert.deepEqual(visibleCellDetailTabs({ isEditable: false, hasBinaryHexViewer: true }), ["details", "hexViewer"]);
+});
+
+test("visibleCellDetailTabs preserves value editor ordering", () => {
+  assert.deepEqual(visibleCellDetailTabs({ isEditable: true, hasBinaryHexViewer: true }), ["details", "hexViewer", "valueEditor"]);
+});
diff --git a/packages/app-tests/cellImageUrl.test.ts b/packages/app-tests/cellImageUrl.test.ts
new file mode 100644
index 0000000..3764521
--- /dev/null
+++ b/packages/app-tests/cellImageUrl.test.ts
@@ -0,0 +1,60 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { cellImagePreviewUrl } from "../../apps/desktop/src/lib/dataGrid/cellImageUrl.ts";
+
+test("detects obvious remote image URLs", () => {
+  assert.equal(cellImagePreviewUrl("https://cdn.example.com/avatar/user.png"), "https://cdn.example.com/avatar/user.png");
+  assert.equal(cellImagePreviewUrl(" https://cdn.example.com/photo.JPG?width=320#preview "), "https://cdn.example.com/photo.JPG?width=320#preview");
+  assert.equal(cellImagePreviewUrl("https://cdn.example.com/image.webp"), "https://cdn.example.com/image.webp");
+});
+
+test("allows localhost HTTP image URLs for development data", () => {
+  assert.equal(cellImagePreviewUrl("http://localhost:3000/image.gif"), "http://localhost:3000/image.gif");
+  assert.equal(cellImagePreviewUrl("http://127.0.0.1:8080/image.jpg"), "http://127.0.0.1:8080/image.jpg");
+});
+
+test("rejects non-image and unsafe URLs", () => {
+  assert.equal(cellImagePreviewUrl("https://example.com/page"), null);
+  assert.equal(cellImagePreviewUrl("https://example.com/image.txt"), null);
+  assert.equal(cellImagePreviewUrl("http://example.com/image.png"), null);
+  assert.equal(cellImagePreviewUrl("file:///tmp/image.png"), null);
+  assert.equal(cellImagePreviewUrl("javascript:alert(1)"), null);
+  assert.equal(cellImagePreviewUrl(42), null);
+  assert.equal(cellImagePreviewUrl(null), null);
+});
+
+test("detects safe data image URLs", () => {
+  assert.equal(cellImagePreviewUrl("data:image/png;base64,abc123"), "data:image/png;base64,abc123");
+  assert.equal(cellImagePreviewUrl("data:image/svg+xml;base64,abc123"), null);
+});
+
+test("detects binary image values from hex strings", () => {
+  assert.match(cellImagePreviewUrl("0x89504e470d0a1a0a0000000d49484452", "longblob") ?? "", /^data:image\/png;base64,/);
+  assert.match(cellImagePreviewUrl("0xffd8ffe000104a4649460001", "blob") ?? "", /^data:image\/jpeg;base64,/);
+  assert.match(cellImagePreviewUrl("0x47494638396101000100", "blob") ?? "", /^data:image\/gif;base64,/);
+  assert.match(cellImagePreviewUrl("0x524946461a00000057454250", "blob") ?? "", /^data:image\/webp;base64,/);
+  assert.match(cellImagePreviewUrl("0x89504e470d0a1a0a0000000d49484452") ?? "", /^data:image\/png;base64,/);
+  assert.match(cellImagePreviewUrl("89504e470d0a1a0a", "longblob") ?? "", /^data:image\/png;base64,/);
+  assert.equal(cellImagePreviewUrl("89504e470d0a1a0a"), null);
+});
+
+test("can skip generated binary image previews while keeping URL previews", () => {
+  assert.equal(cellImagePreviewUrl("0x89504e470d0a1a0a0000000d49484452", "longblob", { binary: false }), null);
+  assert.equal(cellImagePreviewUrl("https://cdn.example.com/avatar.png", "longblob", { binary: false }), "https://cdn.example.com/avatar.png");
+});
+
+test("detects binary image values from byte arrays and buffer-like values", () => {
+  assert.match(cellImagePreviewUrl([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]) ?? "", /^data:image\/png;base64,/);
+  assert.match(cellImagePreviewUrl({ type: "Buffer", data: [0xff, 0xd8, 0xff, 0xe0] }) ?? "", /^data:image\/jpeg;base64,/);
+});
+
+test("detects safe binary SVG values and rejects active SVG content", () => {
+  const svg = "0x3c73766720786d6c6e733d22687474703a2f2f7777772e77332e6f72672f323030302f737667223e3c2f7376673e";
+  const scriptedSvg = "0x3c7376673e3c7363726970743e616c6572742831293c2f7363726970743e3c2f7376673e";
+  assert.match(cellImagePreviewUrl(svg, "longblob") ?? "", /^data:image\/svg\+xml;base64,/);
+  assert.equal(cellImagePreviewUrl(scriptedSvg, "longblob"), null);
+});
+
+test("skips very large binary image previews", () => {
+  assert.equal(cellImagePreviewUrl(`0x${"00".repeat(8 * 1024 * 1024 + 1)}`, "longblob"), null);
+});
diff --git a/packages/app-tests/cellValue.test.ts b/packages/app-tests/cellValue.test.ts
new file mode 100644
index 0000000..c951582
--- /dev/null
+++ b/packages/app-tests/cellValue.test.ts
@@ -0,0 +1,52 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { displayCellValue } from "../../apps/desktop/src/lib/dataGrid/cellValue.ts";
+
+test("displayCellValue returns NULL for null", () => {
+  assert.equal(displayCellValue(null), "NULL");
+});
+
+test("displayCellValue returns string representation for booleans", () => {
+  assert.equal(displayCellValue(true), "true");
+  assert.equal(displayCellValue(false), "false");
+});
+
+test("displayCellValue returns String for numbers", () => {
+  assert.equal(displayCellValue(42), "42");
+  assert.equal(displayCellValue(-3.14), "-3.14");
+  assert.equal(displayCellValue(0), "0");
+});
+
+test("displayCellValue returns String for strings", () => {
+  assert.equal(displayCellValue("hello"), "hello");
+  assert.equal(displayCellValue(""), "");
+});
+
+test("displayCellValue does not truncate long strings", () => {
+  const long = "a".repeat(1000);
+  assert.equal(displayCellValue(long), long);
+});
+
+test("displayCellValue serializes JSON strings containing complex nested objects", () => {
+  const payload = '{"metadata":{"version":"2.1.0","tags":["alpha","beta"],"flags":{"enabled":true,"nested":{"depth":3,"items":[{"id":1,"label":"a"},{"id":2,"label":"b"}]}}},"data":{"records":[{"key":"k-001","value":42},{"key":"k-002","value":-999}],"summary":{"total":3,"valid":2}}}';
+  assert.equal(displayCellValue(payload), payload);
+});
+
+test("displayCellValue handles strings with unicode and special characters", () => {
+  const unicodeStr = "你好世界 🚀🎉 <div>test</div> Line1\nLine2\tTabbed";
+  assert.equal(displayCellValue(unicodeStr), unicodeStr);
+});
+
+test("displayCellValue handles large integer and scientific notation as strings", () => {
+  const bigIntStr = "9007199254740991";
+  const sciStr = "1e-10";
+  assert.equal(displayCellValue(bigIntStr), bigIntStr);
+  assert.equal(displayCellValue(sciStr), sciStr);
+});
+
+test("displayCellValue handles empty JSON-like strings without alteration", () => {
+  assert.equal(displayCellValue("{}"), "{}");
+  assert.equal(displayCellValue("[]"), "[]");
+  assert.equal(displayCellValue('{"key":"value"}'), '{"key":"value"}');
+  assert.equal(displayCellValue("[1,2,3]"), "[1,2,3]");
+});
diff --git a/packages/app-tests/clipboard.test.ts b/packages/app-tests/clipboard.test.ts
new file mode 100644
index 0000000..cb1fd4e
--- /dev/null
+++ b/packages/app-tests/clipboard.test.ts
@@ -0,0 +1,128 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { copyToClipboard, eventTargetAllowsAppClipboardShortcut, eventTargetAllowsNativeClipboard, hasNativeClipboardSelection, isPlainClipboardShortcut, readTextFromClipboard } from "../../apps/desktop/src/lib/common/clipboard.ts";
+
+test("copyToClipboard falls back when navigator clipboard is unavailable", async () => {
+  const appended: unknown[] = [];
+  const removed: unknown[] = [];
+  const selected: string[] = [];
+  const commands: string[] = [];
+
+  const textarea = {
+    value: "",
+    style: {} as Record<string, string>,
+    setAttribute(name: string, value: string) {
+      this.style[name] = value;
+    },
+    select() {
+      selected.push(this.value);
+    },
+  };
+
+  const env = {
+    navigator: {},
+    document: {
+      body: {
+        appendChild(node: unknown) {
+          appended.push(node);
+        },
+        removeChild(node: unknown) {
+          removed.push(node);
+        },
+      },
+      createElement(tagName: string) {
+        assert.equal(tagName, "textarea");
+        return textarea;
+      },
+      execCommand(command: string) {
+        commands.push(command);
+        return true;
+      },
+    },
+  };
+
+  await copyToClipboard("orders\t42", env);
+
+  assert.deepEqual(selected, ["orders\t42"]);
+  assert.deepEqual(commands, ["copy"]);
+  assert.equal(appended[0], textarea);
+  assert.equal(removed[0], textarea);
+});
+
+test("readTextFromClipboard uses navigator clipboard when available", async () => {
+  const text = await readTextFromClipboard({
+    navigator: {
+      clipboard: {
+        readText: async () => "orders\t42",
+      },
+    },
+  });
+
+  assert.equal(text, "orders\t42");
+});
+
+test("clipboard shortcut detection requires a plain mod shortcut", () => {
+  assert.equal(isPlainClipboardShortcut({ key: "C", ctrlKey: true }, "c"), true);
+  assert.equal(isPlainClipboardShortcut({ key: "c", metaKey: true }, "c"), true);
+  assert.equal(isPlainClipboardShortcut({ key: "c", ctrlKey: true, shiftKey: true }, "c"), false);
+  assert.equal(isPlainClipboardShortcut({ key: "c", altKey: true }, "c"), false);
+});
+
+test("eventTargetAllowsNativeClipboard lets editable targets keep clipboard shortcuts", () => {
+  const inputTarget = {
+    closest: (selector: string) => (selector.includes("input") ? {} : null),
+  } as unknown as EventTarget;
+
+  assert.equal(eventTargetAllowsNativeClipboard({ key: "v", ctrlKey: true, target: inputTarget }), true);
+});
+
+test("eventTargetAllowsAppClipboardShortcut ignores editable targets only", () => {
+  const inputTarget = {
+    closest: (selector: string) => (selector.includes("input") ? {} : null),
+  } as unknown as EventTarget;
+  const buttonTarget = {
+    closest: () => null,
+  } as unknown as EventTarget;
+
+  assert.equal(eventTargetAllowsAppClipboardShortcut({ key: "v", ctrlKey: true, target: inputTarget }), false);
+  assert.equal(eventTargetAllowsAppClipboardShortcut({ key: "v", ctrlKey: true, target: buttonTarget }), true);
+  assert.equal(eventTargetAllowsAppClipboardShortcut({ key: "v", ctrlKey: true, shiftKey: true, target: buttonTarget }), false);
+  assert.equal(eventTargetAllowsAppClipboardShortcut({ key: "c", metaKey: true, target: buttonTarget }, "c"), true);
+});
+
+test("hasNativeClipboardSelection detects selections inside one native clipboard region", () => {
+  const region = {};
+  const element = {
+    closest: (selector: string) => (selector === "[data-native-clipboard]" ? region : null),
+  };
+  const textNode = { parentElement: element } as unknown as Node;
+
+  assert.equal(
+    hasNativeClipboardSelection({
+      getSelection: () => ({
+        anchorNode: textNode,
+        focusNode: textNode,
+        isCollapsed: false,
+      }),
+    }),
+    true,
+  );
+});
+
+test("eventTargetAllowsNativeClipboard lets native regions handle copy only with a text selection", () => {
+  const region = {};
+  const element = {
+    closest: (selector: string) => (selector === "[data-native-clipboard]" ? region : null),
+  };
+  const textNode = { parentElement: element } as unknown as Node;
+  const env = {
+    getSelection: () => ({
+      anchorNode: textNode,
+      focusNode: textNode,
+      isCollapsed: false,
+    }),
+  };
+
+  assert.equal(eventTargetAllowsNativeClipboard({ key: "c", ctrlKey: true }, env), true);
+  assert.equal(eventTargetAllowsNativeClipboard({ key: "x", ctrlKey: true }, env), false);
+});
diff --git a/packages/app-tests/closeBracketsExtension.test.ts b/packages/app-tests/closeBracketsExtension.test.ts
new file mode 100644
index 0000000..a772fdb
--- /dev/null
+++ b/packages/app-tests/closeBracketsExtension.test.ts
@@ -0,0 +1,86 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { closeBrackets, closeBracketsKeymap } from "@codemirror/autocomplete";
+import { EditorState, Compartment } from "@codemirror/state";
+import { keymap } from "@codemirror/view";
+
+/**
+ * Replicates the closeBracketsExtension logic from QueryEditor.vue so we can
+ * verify that the Compartment-based toggle correctly includes/excludes both
+ * the closeBrackets() extension and the closeBracketsKeymap.
+ */
+function closeBracketsExtension(enabled: boolean) {
+  if (!enabled) return [];
+  const exts: any[] = [closeBrackets()];
+  if (closeBracketsKeymap.length) {
+    exts.push(keymap.of([...closeBracketsKeymap]));
+  }
+  return exts;
+}
+
+test("closeBracketsExtension returns empty array when disabled", () => {
+  const exts = closeBracketsExtension(false);
+
+  assert.deepEqual(exts, []);
+});
+
+test("closeBracketsExtension includes closeBrackets and its keymap when enabled", () => {
+  const exts = closeBracketsExtension(true);
+
+  assert.equal(exts.length, 2, "should contain closeBrackets() and keymap");
+});
+
+test("closeBracketsKeymap is non-empty so the keymap entry is always included when enabled", () => {
+  assert.ok(closeBracketsKeymap.length > 0, "closeBracketsKeymap should have bindings");
+});
+
+test("Compartment can create EditorState with closeBrackets enabled", () => {
+  const comp = new Compartment();
+  const state = EditorState.create({
+    doc: "select 1",
+    extensions: [comp.of(closeBracketsExtension(true))],
+  });
+
+  assert.ok(state.toJSON().doc, "state should be created with closeBrackets enabled");
+});
+
+test("Compartment reconfigure from enabled to disabled succeeds", () => {
+  const comp = new Compartment();
+  const stateOn = EditorState.create({
+    doc: "select 1",
+    extensions: [comp.of(closeBracketsExtension(true))],
+  });
+
+  // Toggle off — this verifies that closeBracketsExtension(false) returns []
+  // which means both the extension and the keymap are removed
+  const stateOff = stateOn.update({ effects: comp.reconfigure(closeBracketsExtension(false)) }).state;
+
+  assert.equal(stateOff.toJSON().doc, "select 1", "state should still be valid after reconfigure to disabled");
+});
+
+test("Compartment reconfigure from disabled to enabled succeeds", () => {
+  const comp = new Compartment();
+  const stateOff = EditorState.create({
+    doc: "select 1",
+    extensions: [comp.of(closeBracketsExtension(false))],
+  });
+
+  // Toggle on — this verifies that closeBracketsExtension(true) returns both
+  // the closeBrackets() extension and the keymap
+  const stateOn = stateOff.update({ effects: comp.reconfigure(closeBracketsExtension(true)) }).state;
+
+  assert.equal(stateOn.toJSON().doc, "select 1", "state should still be valid after reconfigure to enabled");
+});
+
+test("closeBracketsExtension(false) produces zero extensions", () => {
+  // The key assertion: when disabled, both closeBrackets() and
+  // closeBracketsKeymap are absent — no partial keymap leakage
+  const exts = closeBracketsExtension(false);
+  assert.equal(exts.length, 0);
+});
+
+test("closeBracketsExtension(true) produces exactly two extension groups", () => {
+  // When enabled, both closeBrackets() and the keymap are present
+  const exts = closeBracketsExtension(true);
+  assert.equal(exts.length, 2);
+});
diff --git a/packages/app-tests/codemirrorSqlDialect.test.ts b/packages/app-tests/codemirrorSqlDialect.test.ts
new file mode 100644
index 0000000..11fabdd
--- /dev/null
+++ b/packages/app-tests/codemirrorSqlDialect.test.ts
@@ -0,0 +1,33 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import * as langSql from "@codemirror/lang-sql";
+import { createDbxCodeMirrorSqlDialect } from "../../apps/desktop/src/lib/editor/codemirrorSqlDialect.ts";
+
+function hasKeyword(keywords: string | undefined, keyword: string): boolean {
+  return new RegExp(`(?:^|\\s)${keyword}(?:\\s|$)`, "i").test(keywords || "");
+}
+
+function countParsedNodes(dialect: langSql.SQLDialect, sql: string, nodeName: string, text: string): number {
+  const tree = dialect.language.parser.parse(sql);
+  const cursor = tree.cursor();
+  let count = 0;
+  do {
+    if (cursor.name === nodeName && sql.slice(cursor.from, cursor.to).toLowerCase() === text.toLowerCase()) count++;
+  } while (cursor.next());
+  return count;
+}
+
+test("adds SQL Server READONLY for table-valued procedure parameters", () => {
+  const dialect = createDbxCodeMirrorSqlDialect(langSql, "sqlserver");
+
+  assert.equal(hasKeyword(dialect.spec.keywords, "READONLY"), true);
+  assert.equal(countParsedNodes(dialect, "CREATE PROCEDURE [dbo].[gylxcx](@tp2 XTableType5 readonly,@tp xtabletype2 readonly) AS SELECT 1", "Keyword", "readonly"), 2);
+});
+
+test("keeps DBX PostgreSQL procedural dialect extensions", () => {
+  const dialect = createDbxCodeMirrorSqlDialect(langSql, "postgres");
+
+  assert.equal(hasKeyword(dialect.spec.keywords, "PERFORM"), true);
+  assert.equal(hasKeyword(dialect.spec.types, "JSONB"), true);
+  assert.equal(hasKeyword(dialect.spec.builtin, "TG_NAME"), true);
+});
diff --git a/packages/app-tests/codemirrorTrimmedSelectionLayer.test.ts b/packages/app-tests/codemirrorTrimmedSelectionLayer.test.ts
new file mode 100644
index 0000000..287a8da
--- /dev/null
+++ b/packages/app-tests/codemirrorTrimmedSelectionLayer.test.ts
@@ -0,0 +1,43 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { trimmedSelectionHorizontalBounds } from "../../apps/desktop/src/lib/editor/codemirrorTrimmedSelectionLayer.ts";
+
+test("line-break-only selection starts at the content end", () => {
+  const bounds = trimmedSelectionHorizontalBounds({
+    from: 42,
+    to: 42,
+    lineFrom: 0,
+    lineTo: 42,
+    includesLineBreak: true,
+    startLeft: 260,
+    startRight: 260,
+    endLeft: 260,
+    endRight: 260,
+    lineStartLeft: 80,
+    lineEndRight: 260,
+    emptySelectionWidth: 7,
+  });
+
+  assert.equal(bounds.left, 260);
+  assert.equal(bounds.right, 267);
+});
+
+test("empty selected line still uses the line start", () => {
+  const bounds = trimmedSelectionHorizontalBounds({
+    from: 12,
+    to: 12,
+    lineFrom: 12,
+    lineTo: 12,
+    includesLineBreak: true,
+    startLeft: 80,
+    startRight: 80,
+    endLeft: 80,
+    endRight: 80,
+    lineStartLeft: 80,
+    lineEndRight: 80,
+    emptySelectionWidth: 7,
+  });
+
+  assert.equal(bounds.left, 80);
+  assert.equal(bounds.right, 87);
+});
diff --git a/packages/app-tests/columnFormatter.test.ts b/packages/app-tests/columnFormatter.test.ts
new file mode 100644
index 0000000..774e701
--- /dev/null
+++ b/packages/app-tests/columnFormatter.test.ts
@@ -0,0 +1,96 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { applyColumnFormatter, buildColumnFormatterKey, resolveColumnFormatter, normalizeColumnFormatter, type ColumnFormatterConfig } from "../../apps/desktop/src/lib/dataGrid/columnFormatter.ts";
+import timezone from "dayjs/plugin/timezone";
+import utc from "dayjs/plugin/utc";
+import dayjs from "dayjs";
+
+test("formats unix timestamps in seconds, milliseconds, and auto mode", () => {
+  dayjs.extend(utc);
+  dayjs.extend(timezone);
+  assert.equal(dayjs.tz.guess(), "Asia/Shanghai");
+  assert.equal(applyColumnFormatter(1715758200, { kind: "datetime", unit: "seconds", pattern: "YYYY-MM-DD HH:mm:ssZ" }), "2024-05-15 15:30:00+08:00");
+  assert.equal(applyColumnFormatter(1715758200001, { kind: "datetime", unit: "milliseconds", pattern: "YYYY-MM-DD HH:mm:ss.SSSZ" }), "2024-05-15 15:30:00.001+08:00");
+  assert.equal(applyColumnFormatter(1715758200001, { kind: "datetime", unit: "auto", pattern: "YYYY-MM-DD HH:mm:ss.SSSZ" }), "2024-05-15 15:30:00.001+08:00");
+  assert.equal(applyColumnFormatter("1715758200001", { kind: "datetime", unit: "auto", pattern: "YYYY-MM-DD HH:mm:ss.SSSZ" }), "2024-05-15 15:30:00.001+08:00");
+  assert.equal(applyColumnFormatter(1715758200, { kind: "datetime", unit: "auto", pattern: "YYYY-MM-DD HH:mm:ssZ" }), "2024-05-15 15:30:00+08:00");
+  assert.equal(applyColumnFormatter("1715758200", { kind: "datetime", unit: "auto", pattern: "YYYY-MM-DD HH:mm:ssZ" }), "2024-05-15 15:30:00+08:00");
+});
+
+test("does not treat compact date strings as unix timestamps", () => {
+  dayjs.extend(utc);
+  dayjs.extend(timezone);
+  assert.equal(dayjs.tz.guess(), "Asia/Shanghai");
+  assert.equal(applyColumnFormatter("20260514", { kind: "datetime", unit: "auto", pattern: "YYYYMMDD" }), "20260514");
+  assert.equal(applyColumnFormatter("20260514", { kind: "datetime", unit: "auto", pattern: "YYYY-MM-DD HH:mm:ss" }), "20260514");
+  assert.equal(applyColumnFormatter(20260514, { kind: "datetime", unit: "auto", pattern: "YYYYMMDD" }), "20260514");
+  assert.equal(applyColumnFormatter("2026-05-14T16:00:00Z", { kind: "datetime", unit: "auto", pattern: "YYYY-MM-DDTHH:mm:ssZ" }), "2026-05-15T00:00:00+08:00");
+  assert.equal(applyColumnFormatter("2026-05-14", { kind: "datetime", unit: "auto", pattern: "YYYY-MM-DD" }), "2026-05-14");
+});
+
+test("extracts simple JSON paths from object and array strings", () => {
+  const payload = JSON.stringify({ user: { name: "Ada" }, items: [{ id: 7 }] });
+
+  assert.equal(applyColumnFormatter(payload, { kind: "json-path", path: "$.user.name" }), "Ada");
+  assert.equal(applyColumnFormatter(payload, { kind: "json-path", path: "$.items[0].id" }), "7");
+  assert.equal(applyColumnFormatter(payload, { kind: "json-path", path: "$.missing" }), "");
+});
+
+test("masks strings while preserving prefix and suffix", () => {
+  assert.equal(applyColumnFormatter("abcdef123456", { kind: "mask", prefix: 3, suffix: 2 }), "abc*******56");
+  assert.equal(applyColumnFormatter("short", { kind: "mask", prefix: 3, suffix: 3 }), "*****");
+});
+
+test("falls back to normal display for nulls and invalid formatter input", () => {
+  assert.equal(applyColumnFormatter(null, { kind: "datetime", unit: "auto", pattern: "YYYYMMDD" }), "NULL");
+  assert.equal(applyColumnFormatter("abc", { kind: "datetime", unit: "auto", pattern: "YYYYMMDD" }), "abc");
+  assert.equal(applyColumnFormatter("2022-01-33", { kind: "datetime", unit: "auto", pattern: "YYYY-MM-DD" }), "2022-01-33");
+  assert.equal(applyColumnFormatter("not json", { kind: "json-path", path: "$.a" }), "not json");
+  assert.deepEqual(normalizeColumnFormatter({ kind: "datetime", unit: "invalid" }), undefined);
+  assert.deepEqual(normalizeColumnFormatter({ kind: "datetime", unit: "auto", pattern: 123 }), { kind: "datetime", unit: "auto", pattern: "YYYY-MM-DD HH:mm:ss" });
+});
+
+test("normalizes only supported formatter configs", () => {
+  const config: ColumnFormatterConfig = { kind: "mask", prefix: 2, suffix: 4 };
+
+  assert.deepEqual(normalizeColumnFormatter(config), config);
+  assert.deepEqual(normalizeColumnFormatter({ kind: "json-path", path: "$.a[0]" }), {
+    kind: "json-path",
+    path: "$.a[0]",
+  });
+  assert.equal(normalizeColumnFormatter({ kind: "json-path", path: "a.b" }), undefined);
+  assert.deepEqual(normalizeColumnFormatter({ kind: "custom-template", template: "ID-${value}" }), {
+    kind: "custom-template",
+    template: "ID-${value}",
+  });
+  assert.deepEqual(normalizeColumnFormatter({ kind: "custom-ref", formatterId: "fmt_1" }), {
+    kind: "custom-ref",
+    formatterId: "fmt_1",
+  });
+});
+
+test("builds stable formatter keys for table columns", () => {
+  assert.equal(
+    buildColumnFormatterKey({
+      connectionId: "conn",
+      database: "db",
+      schema: "public",
+      tableName: "users",
+      column: "created_at",
+    }),
+    "conn::db::public::users::created_at",
+  );
+});
+
+test("applies safe custom formatter templates", () => {
+  assert.equal(applyColumnFormatter("ada", { kind: "custom-template", template: "user:${value}" }), "user:ada");
+  assert.equal(applyColumnFormatter("Ada", { kind: "custom-template", template: "${upper}" }), "ADA");
+  assert.equal(applyColumnFormatter("Ada", { kind: "custom-template", template: "${lower}" }), "ada");
+  assert.equal(applyColumnFormatter("Ada", { kind: "custom-template", template: "${length}" }), "3");
+  assert.equal(applyColumnFormatter(null, { kind: "custom-template", template: "value=${value}" }), "value=NULL");
+});
+
+test("resolves saved custom formatter references", () => {
+  assert.deepEqual(resolveColumnFormatter({ kind: "custom-ref", formatterId: "fmt_1" }, { fmt_1: { id: "fmt_1", name: "User label", template: "user:${value}" } }), { kind: "custom-template", template: "user:${value}" });
+  assert.equal(resolveColumnFormatter({ kind: "custom-ref", formatterId: "missing" }, {}), undefined);
+});
diff --git a/packages/app-tests/configCrypto.test.ts b/packages/app-tests/configCrypto.test.ts
new file mode 100644
index 0000000..2c2a763
--- /dev/null
+++ b/packages/app-tests/configCrypto.test.ts
@@ -0,0 +1,54 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { CONFIG_CRYPTO_UNAVAILABLE, encryptConfig, decryptConfig, isEncryptedConfig } from "../../apps/desktop/src/lib/backend/configCrypto.ts";
+
+test("encrypts and decrypts config round-trip", async () => {
+  const original = JSON.stringify([{ id: "1", name: "test", password: "secret123" }]);
+  const encrypted = await encryptConfig(original, "my-passphrase");
+
+  assert.equal(encrypted.format, "dbx-encrypted");
+  assert.equal(encrypted.version, 1);
+  assert.ok(encrypted.salt);
+  assert.ok(encrypted.iv);
+  assert.ok(encrypted.data);
+
+  const decrypted = await decryptConfig(encrypted, "my-passphrase");
+  assert.equal(decrypted, original);
+});
+
+test("fails to decrypt with wrong passphrase", async () => {
+  const encrypted = await encryptConfig('{"test":true}', "correct-passphrase");
+
+  await assert.rejects(
+    () => decryptConfig(encrypted, "wrong-passphrase"),
+    (err: Error) => err.message === "wrong_passphrase",
+  );
+});
+
+test("detects encrypted config format", () => {
+  assert.equal(isEncryptedConfig({ format: "dbx-encrypted", version: 1, salt: "a", iv: "b", data: "c" }), true);
+  assert.equal(isEncryptedConfig({ format: "dbx-config", version: 1, connections: [] }), false);
+  assert.equal(isEncryptedConfig([{ id: "1" }]), false);
+  assert.equal(isEncryptedConfig(null), false);
+  assert.equal(isEncryptedConfig("string"), false);
+});
+
+test("reports crypto unavailable when Web Crypto is missing", async () => {
+  const originalCrypto = globalThis.crypto;
+  Object.defineProperty(globalThis, "crypto", {
+    configurable: true,
+    value: { getRandomValues: originalCrypto.getRandomValues.bind(originalCrypto) },
+  });
+
+  try {
+    await assert.rejects(
+      () => encryptConfig("{}", "passphrase"),
+      (err: Error) => err.message === CONFIG_CRYPTO_UNAVAILABLE,
+    );
+  } finally {
+    Object.defineProperty(globalThis, "crypto", {
+      configurable: true,
+      value: originalCrypto,
+    });
+  }
+});
diff --git a/packages/app-tests/connectionClipboard.test.ts b/packages/app-tests/connectionClipboard.test.ts
new file mode 100644
index 0000000..de6ef31
--- /dev/null
+++ b/packages/app-tests/connectionClipboard.test.ts
@@ -0,0 +1,157 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { createPinia, setActivePinia } from "pinia";
+import { useConnectionStore } from "../../apps/desktop/src/stores/connectionStore.ts";
+import type { ConnectionConfig, SidebarLayout, TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+function installMemoryStorage() {
+  const values = new Map<string, string>();
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+      clear: () => values.clear(),
+    },
+  });
+  return {
+    restore() {
+      if (original) Object.defineProperty(globalThis, "localStorage", original);
+      else Reflect.deleteProperty(globalThis, "localStorage");
+    },
+  };
+}
+
+function conn(id: string, name: string): ConnectionConfig {
+  return {
+    id,
+    name,
+    db_type: "mysql",
+    host: "127.0.0.1",
+    port: 3306,
+    username: "root",
+    password: "secret",
+  };
+}
+
+async function withConnectionStore(initialConnections: ConnectionConfig[], initialLayout: SidebarLayout | null, run: (store: ReturnType<typeof useConnectionStore>) => Promise<void>) {
+  const originalFetch = globalThis.fetch;
+  const storage = installMemoryStorage();
+  let savedConnections = initialConnections;
+  let savedLayout = initialLayout;
+
+  globalThis.fetch = (async (input, init) => {
+    const url = String(input);
+    if (url === "/api/connection/list") {
+      return new Response(JSON.stringify(savedConnections), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/layout/sidebar") {
+      if (init?.method === "POST") {
+        savedLayout = JSON.parse(String(init.body ?? "null"));
+        return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+      }
+      return new Response(JSON.stringify(savedLayout), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/connection/save") {
+      savedConnections = JSON.parse(String(init?.body ?? "[]"));
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    await store.initFromDisk();
+    await run(store);
+  } finally {
+    globalThis.fetch = originalFetch;
+    storage.restore();
+  }
+}
+
+function connectionLabels(nodes: TreeNode[]): string[] {
+  const labels: string[] = [];
+  for (const node of nodes) {
+    if (node.type === "connection") labels.push(node.label);
+    if (node.children) labels.push(...connectionLabels(node.children));
+  }
+  return labels;
+}
+
+test("copies and pastes a root connection without writing to the OS clipboard", async () => {
+  await withConnectionStore([conn("conn-1", "Main MySQL")], { groups: [], order: [{ type: "connection", id: "conn-1" }] }, async (store) => {
+    assert.equal(store.copyConnectionsToTreeClipboard(["conn-1"]), 1);
+    assert.equal(store.treeClipboard?.kind, "connection-copy");
+
+    const pasted = await store.pasteConnectionClipboard(null);
+
+    assert.equal(pasted, 1);
+    assert.equal(store.connections.length, 2);
+    assert.deepEqual(connectionLabels(store.treeNodes), ["Main MySQL", "Main MySQL (Copy)"]);
+    assert.notEqual(store.connections[0].id, store.connections[1].id);
+  });
+});
+
+test("pastes a copied grouped connection into the same group when that group is targeted", async () => {
+  const originalConnection = conn("conn-1", "Grouped MySQL");
+  const layout: SidebarLayout = {
+    groups: [{ id: "group-1", name: "Group", collapsed: false }],
+    order: [{ type: "group", id: "group-1", children: [{ type: "connection", id: "conn-1" }] }],
+  };
+
+  await withConnectionStore([originalConnection], layout, async (store) => {
+    assert.equal(store.copyConnectionsToTreeClipboard(["conn-1"]), 1);
+    const pasted = await store.pasteConnectionClipboard();
+
+    assert.equal(pasted, 1);
+    assert.equal(store.treeNodes[0].type, "connection-group");
+    assert.deepEqual(
+      store.treeNodes[0].children?.map((node) => node.label),
+      ["Grouped MySQL", "Grouped MySQL (Copy)"],
+    );
+  });
+});
+
+test("pastes copied connections into an explicitly selected target group", async () => {
+  const layout: SidebarLayout = {
+    groups: [
+      { id: "group-1", name: "Source", collapsed: false },
+      { id: "group-2", name: "Target", collapsed: false },
+    ],
+    order: [
+      { type: "group", id: "group-1", children: [{ type: "connection", id: "conn-1" }] },
+      { type: "group", id: "group-2", children: [] },
+    ],
+  };
+
+  await withConnectionStore([conn("conn-1", "Source MySQL")], layout, async (store) => {
+    store.copyConnectionsToTreeClipboard(["conn-1"]);
+    await store.pasteConnectionClipboard("group-2");
+
+    assert.equal(store.treeNodes[1].type, "connection-group");
+    assert.deepEqual(
+      store.treeNodes[1].children?.map((node) => node.label),
+      ["Source MySQL (Copy)"],
+    );
+  });
+});
+
+test("pastes multiple copied connections in the copied order", async () => {
+  const layout: SidebarLayout = {
+    groups: [],
+    order: [
+      { type: "connection", id: "conn-1" },
+      { type: "connection", id: "conn-2" },
+    ],
+  };
+
+  await withConnectionStore([conn("conn-1", "First"), conn("conn-2", "Second")], layout, async (store) => {
+    store.copyConnectionsToTreeClipboard(["conn-2", "conn-1"]);
+    await store.pasteConnectionClipboard(null);
+
+    assert.deepEqual(connectionLabels(store.treeNodes), ["First", "Second", "Second (Copy)", "First (Copy)"]);
+  });
+});
diff --git a/packages/app-tests/connectionDeepLink.test.ts b/packages/app-tests/connectionDeepLink.test.ts
new file mode 100644
index 0000000..45cad41
--- /dev/null
+++ b/packages/app-tests/connectionDeepLink.test.ts
@@ -0,0 +1,69 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { parseConnectionDeepLink } from "../../apps/desktop/src/lib/connection/connectionDeepLink.ts";
+
+test("parses dbx connection deep link query fields", () => {
+  const draft = parseConnectionDeepLink("dbx://connection/new?type=postgres&host=db.internal&port=15432&user=app&database=orders&name=Orders");
+
+  assert.deepEqual(draft, {
+    name: "Orders",
+    dbType: "postgres",
+    driverProfile: "postgres",
+    driverLabel: "PostgreSQL",
+    host: "db.internal",
+    port: 15432,
+    username: "app",
+    password: undefined,
+    database: "orders",
+    urlParams: undefined,
+    ssl: false,
+  });
+});
+
+test("parses encoded database URL with password", () => {
+  const draft = parseConnectionDeepLink("dbx://connection/new?url=postgres%3A%2F%2Fapp%3Asecret%40db.internal%3A5432%2Forders%3Fsslmode%3Drequire");
+
+  assert.equal(draft?.dbType, "postgres");
+  assert.equal(draft?.driverProfile, "postgres");
+  assert.equal(draft?.host, "db.internal");
+  assert.equal(draft?.port, 5432);
+  assert.equal(draft?.username, "app");
+  assert.equal(draft?.password, "secret");
+  assert.equal(draft?.database, "orders");
+  assert.equal(draft?.urlParams, "sslmode=require");
+});
+
+test("uses the nested database URL name as connection name", () => {
+  const nested = encodeURIComponent("mysql://root:123456@localhost/?name=%E5%85%AC%E5%8F%B8+-+%E6%9C%AC%E5%9C%B0Docker&charset=utf8mb4");
+  const draft = parseConnectionDeepLink(`dbx://connection/new?url=${nested}`);
+
+  assert.equal(draft?.name, "公司 - 本地Docker");
+  assert.equal(draft?.dbType, "mysql");
+  assert.equal(draft?.host, "localhost");
+  assert.equal(draft?.urlParams, "charset=utf8mb4");
+});
+
+test("top-level deep link name overrides nested database URL name", () => {
+  const nested = encodeURIComponent("mysql://root@localhost/?name=Nested");
+  const draft = parseConnectionDeepLink(`dbx://connection/new?url=${nested}&name=Top+Level`);
+
+  assert.equal(draft?.name, "Top Level");
+});
+
+test("allows password query field to override database URL password", () => {
+  const draft = parseConnectionDeepLink("dbx://connection/new?url=postgres%3A%2F%2Fapp%3Asecret%40db.internal%3A5432%2Forders&password=override");
+
+  assert.equal(draft?.password, "override");
+});
+
+test("parses boolean control parameters consistently", () => {
+  const draft = parseConnectionDeepLink("dbx://connection/new?type=mysql&ssl=1&one_time=yes");
+
+  assert.equal(draft?.ssl, true);
+  assert.equal(draft?.oneTime, true);
+});
+
+test("ignores unsupported dbx deep link targets", () => {
+  assert.equal(parseConnectionDeepLink("dbx://query/open?sql=select%201"), null);
+  assert.equal(parseConnectionDeepLink("dbx://connections/new?type=postgres"), null);
+});
diff --git a/packages/app-tests/connectionLevelDatabaseBootstrap.test.ts b/packages/app-tests/connectionLevelDatabaseBootstrap.test.ts
new file mode 100644
index 0000000..b86bc65
--- /dev/null
+++ b/packages/app-tests/connectionLevelDatabaseBootstrap.test.ts
@@ -0,0 +1,54 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { canExecuteWithoutSelectedDatabase, requiresSqlFileTargetDatabaseSelection, supportsConnectionLevelDatabaseBootstrap } from "../../apps/desktop/src/lib/connection/connectionLevelDatabaseBootstrap.ts";
+import type { ConnectionConfig } from "../../apps/desktop/src/types/database.ts";
+
+function connection(dbType: ConnectionConfig["db_type"], driverProfile?: string): Pick<ConnectionConfig, "db_type" | "driver_profile"> {
+  return {
+    db_type: dbType,
+    driver_profile: driverProfile,
+  };
+}
+
+test("supports MySQL-compatible connection-level bootstrap targets", () => {
+  assert.equal(supportsConnectionLevelDatabaseBootstrap(connection("mysql")), true);
+  assert.equal(supportsConnectionLevelDatabaseBootstrap(connection("doris")), true);
+  assert.equal(supportsConnectionLevelDatabaseBootstrap(connection("starrocks")), true);
+  assert.equal(supportsConnectionLevelDatabaseBootstrap(connection("goldendb")), true);
+  assert.equal(supportsConnectionLevelDatabaseBootstrap(connection("mysql", "selectdb")), true);
+  assert.equal(supportsConnectionLevelDatabaseBootstrap(connection("mysql", "oceanbase")), true);
+  assert.equal(supportsConnectionLevelDatabaseBootstrap(connection("mysql", "OceanBase")), true);
+  assert.equal(supportsConnectionLevelDatabaseBootstrap(connection("mysql", "SelectDB")), true);
+});
+
+test("excludes non-MySQL bootstrap targets", () => {
+  assert.equal(supportsConnectionLevelDatabaseBootstrap(connection("postgres")), false);
+  assert.equal(supportsConnectionLevelDatabaseBootstrap(connection("manticoresearch")), false);
+  assert.equal(supportsConnectionLevelDatabaseBootstrap(connection("oceanbase-oracle")), false);
+});
+
+test("allows install scripts that create and switch databases before table DDL", () => {
+  const sql = "SET NAMES utf8mb4; DROP DATABASE IF EXISTS app_db; CREATE DATABASE app_db; USE app_db; CREATE TABLE users(id INT)";
+  assert.equal(canExecuteWithoutSelectedDatabase(connection("mysql"), sql), true);
+});
+
+test("blocks scripts that never establish database context", () => {
+  const sql = "CREATE DATABASE app_db; CREATE TABLE users(id INT)";
+  assert.equal(canExecuteWithoutSelectedDatabase(connection("mysql"), sql), false);
+});
+
+test("blocks malformed USE statements that trail into other SQL", () => {
+  const sql = "CREATE DATABASE app_db; USE app_db SELECT 1; CREATE TABLE users(id INT)";
+  assert.equal(canExecuteWithoutSelectedDatabase(connection("mysql"), sql), false);
+});
+
+test("accepts escaped MySQL-compatible identifiers in USE statements", () => {
+  const sql = "CREATE DATABASE [tenant]]01]; -- switch tenant\nUSE [tenant]]01]; CREATE TABLE users(id INT)";
+  assert.equal(canExecuteWithoutSelectedDatabase(connection("mysql"), sql), true);
+});
+
+test("SQL file execution still requires an explicit database for non-MySQL targets", () => {
+  assert.equal(requiresSqlFileTargetDatabaseSelection(connection("postgres"), true), true);
+  assert.equal(requiresSqlFileTargetDatabaseSelection(connection("mysql"), true), false);
+  assert.equal(requiresSqlFileTargetDatabaseSelection(connection("mysql"), false), true);
+});
diff --git a/packages/app-tests/connectionPresentation.test.ts b/packages/app-tests/connectionPresentation.test.ts
new file mode 100644
index 0000000..70106d3
--- /dev/null
+++ b/packages/app-tests/connectionPresentation.test.ts
@@ -0,0 +1,139 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import type { ConnectionConfig } from "../../apps/desktop/src/types/database.ts";
+import { connectionDriverLabel, connectionEndpointLabel, connectionIconType, connectionOptionSubtitle, connectionRedactedEndpointLabel, connectionRedactedNameLabel, connectionRedactedOptionSubtitle } from "../../apps/desktop/src/lib/connection/connectionPresentation.ts";
+
+const baseConnection: ConnectionConfig = {
+  id: "conn-1",
+  name: "localhost",
+  db_type: "mysql",
+  driver_profile: "tidb",
+  driver_label: "TiDB",
+  host: "127.0.0.1",
+  port: 4000,
+  username: "root",
+  password: "",
+  database: "test",
+};
+
+test("uses driver profile for connection option icon identity", () => {
+  assert.equal(connectionIconType(baseConnection), "tidb");
+});
+
+test("builds a compact subtitle for duplicate connection names", () => {
+  assert.equal(connectionDriverLabel(baseConnection), "TiDB");
+  assert.equal(connectionEndpointLabel(baseConnection), "127.0.0.1:4000");
+  assert.equal(connectionOptionSubtitle(baseConnection), "TiDB · 127.0.0.1:4000");
+});
+
+test("uses file path as endpoint for local database connections", () => {
+  const sqliteConnection: ConnectionConfig = {
+    ...baseConnection,
+    db_type: "sqlite",
+    driver_profile: "sqlite",
+    driver_label: "SQLite",
+    host: "/tmp/local.db",
+    port: 0,
+  };
+
+  assert.equal(connectionOptionSubtitle(sqliteConnection), "SQLite · /tmp/local.db");
+
+  const accessConnection: ConnectionConfig = {
+    ...baseConnection,
+    db_type: "access",
+    driver_profile: "access",
+    driver_label: "Microsoft Access",
+    host: "/tmp/Northwind.accdb",
+    port: 0,
+  };
+
+  assert.equal(connectionOptionSubtitle(accessConnection), "Microsoft Access · /tmp/Northwind.accdb");
+});
+
+test("redacts network endpoint labels for quick connection cards", () => {
+  assert.equal(
+    connectionRedactedEndpointLabel({
+      ...baseConnection,
+      host: "192.168.1.100",
+      port: 3306,
+    }),
+    "192.***.***.100:****",
+  );
+  assert.equal(
+    connectionRedactedOptionSubtitle({
+      ...baseConnection,
+      host: "db.prod.example.com",
+      port: 5432,
+    }),
+    "TiDB · db.***.***.com:****",
+  );
+  assert.equal(
+    connectionRedactedEndpointLabel({
+      ...baseConnection,
+      host: "2001:db8:85a3::8a2e:370:7334",
+      port: 5432,
+    }),
+    "[2001:***:***:***:***:7334]:****",
+  );
+});
+
+test("presents Cloudflare D1 account and database identifiers without treating them as a host and port", () => {
+  const d1Connection: ConnectionConfig = {
+    ...baseConnection,
+    db_type: "cloudflare-d1",
+    driver_profile: undefined,
+    driver_label: "Cloudflare D1",
+    host: "account-id",
+    port: 443,
+    database: "database-id",
+  };
+
+  assert.equal(connectionEndpointLabel(d1Connection), "account-id/database-id");
+  assert.equal(connectionRedactedEndpointLabel(d1Connection), "***/***");
+});
+
+test("redacts host-like quick connection names", () => {
+  assert.equal(
+    connectionRedactedNameLabel({
+      ...baseConnection,
+      name: "db.prod.example.com",
+      host: "db.prod.example.com",
+      port: 5432,
+    }),
+    "db.***.***.com:****",
+  );
+  assert.equal(
+    connectionRedactedNameLabel({
+      ...baseConnection,
+      name: "[2001:db8:85a3::8a2e:370:7334]:5432",
+      host: "2001:db8:85a3::8a2e:370:7334",
+      port: 5432,
+    }),
+    "[2001:***:***:***:***:7334]:****",
+  );
+});
+
+test("keeps friendly quick connection names readable", () => {
+  assert.equal(
+    connectionRedactedNameLabel({
+      ...baseConnection,
+      name: "Production Analytics",
+      host: "db.prod.example.com",
+      port: 5432,
+    }),
+    "Production Analytics",
+  );
+});
+
+test("keeps local file database endpoint labels readable when redacting", () => {
+  const sqliteConnection: ConnectionConfig = {
+    ...baseConnection,
+    db_type: "sqlite",
+    driver_profile: "sqlite",
+    driver_label: "SQLite",
+    host: "/tmp/local.db",
+    port: 0,
+  };
+
+  assert.equal(connectionRedactedOptionSubtitle(sqliteConnection), "SQLite · /tmp/local.db");
+});
diff --git a/packages/app-tests/connectionStoreErrorState.test.ts b/packages/app-tests/connectionStoreErrorState.test.ts
new file mode 100644
index 0000000..e8be781
--- /dev/null
+++ b/packages/app-tests/connectionStoreErrorState.test.ts
@@ -0,0 +1,550 @@
+import assert from "node:assert/strict";
+import { createPinia, setActivePinia } from "pinia";
+import { test, vi } from "vitest";
+import { useConnectionStore } from "../../apps/desktop/src/stores/connectionStore.ts";
+import type { ConnectionConfig } from "../../apps/desktop/src/types/database.ts";
+
+function installMemoryStorage() {
+  const values = new Map<string, string>();
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+      clear: () => values.clear(),
+    },
+  });
+  return () => {
+    if (original) Object.defineProperty(globalThis, "localStorage", original);
+    else Reflect.deleteProperty(globalThis, "localStorage");
+  };
+}
+
+function conn(id: string): ConnectionConfig {
+  return {
+    id,
+    name: id,
+    db_type: "postgres",
+    host: "localhost",
+    port: 5432,
+    username: "postgres",
+    password: "",
+  };
+}
+
+function jsonResponse(value: unknown): Response {
+  return new Response(JSON.stringify(value), { status: 200, headers: { "Content-Type": "application/json" } });
+}
+
+test("successful disconnect clears the connection error", async () => {
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = (async (input) => {
+    if (String(input) === "/api/connection/disconnect") {
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("unexpected request", { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    store.addEphemeralConnection(conn("conn-1"));
+    store.recordConnectionError("conn-1", new Error("metadata failed"));
+
+    await store.disconnect("conn-1");
+
+    assert.equal(store.connectionErrors["conn-1"], undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("failed disconnect keeps the existing connection error", async () => {
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = (async (input) => {
+    if (String(input) === "/api/connection/disconnect") {
+      return new Response("disconnect failed", { status: 500 });
+    }
+    return new Response("unexpected request", { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    store.addEphemeralConnection(conn("conn-1"));
+    store.recordConnectionError("conn-1", new Error("metadata failed"));
+
+    await assert.rejects(() => store.disconnect("conn-1"), /disconnect failed/);
+
+    assert.equal(store.connectionErrors["conn-1"], "metadata failed");
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("hanging disconnect request still clears local connection state", async () => {
+  vi.useFakeTimers();
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = (async (input) => {
+    if (String(input) === "/api/connection/disconnect") {
+      return new Promise<Response>(() => {});
+    }
+    return new Response("unexpected request", { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    store.addEphemeralConnection(conn("conn-1"));
+    store.activeConnectionId = "conn-1";
+    store.recordConnectionError("conn-1", new Error("metadata failed"));
+    store.treeNodes.push({
+      id: "conn-1",
+      label: "conn-1",
+      type: "connection",
+      connectionId: "conn-1",
+      isLoading: true,
+      isExpanded: true,
+      children: [{ id: "conn-1:db", label: "db", type: "database", connectionId: "conn-1", database: "db" }],
+    });
+
+    const disconnectPromise = store.disconnect("conn-1");
+    await vi.advanceTimersByTimeAsync(5000);
+    await disconnectPromise;
+
+    assert.equal(store.connectionErrors["conn-1"], undefined);
+    assert.equal(store.connectedIds.has("conn-1"), false);
+    assert.equal(store.activeConnectionId, null);
+    assert.equal(store.treeNodes[0].isLoading, false);
+    assert.equal(store.treeNodes[0].isExpanded, false);
+    assert.deepEqual(store.treeNodes[0].children, []);
+  } finally {
+    vi.useRealTimers();
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("query errors mentioning connection do not mark the connection disconnected", async () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    store.addEphemeralConnection(conn("conn-1"));
+    store.activeConnectionId = "conn-1";
+
+    store.recordConnectionLostError("conn-1", new Error('relation "connection" does not exist'));
+
+    assert.equal(store.connectedIds.has("conn-1"), true);
+    assert.equal(store.activeConnectionId, "conn-1");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("known backend connection errors mark the connection disconnected", async () => {
+  const restoreStorage = installMemoryStorage();
+  const messages = [
+    "java.sql.SQLRecoverableException: 关闭的连接",
+    "java.sql.SQLRecoverableException: 连接已关闭",
+    "server closed session with no notification",
+    "server closed the connection unexpectedly",
+    "Error occurred while creating a new object: error communicating with the server",
+    "ORA-02396: exceeded maximum idle time, please connect again",
+    "Agent stdin not available",
+    "Failed to write to agent stdin",
+    "MySQL connection failed: Input/output error: No route to host (os error 65)",
+  ];
+
+  try {
+    for (const [index, message] of messages.entries()) {
+      setActivePinia(createPinia());
+      const store = useConnectionStore();
+      const connectionId = `conn-${index}`;
+      store.addEphemeralConnection(conn(connectionId));
+      store.activeConnectionId = connectionId;
+
+      const marked = store.recordConnectionLostError(connectionId, new Error(message));
+
+      assert.equal(marked, true, message);
+      assert.equal(store.connectedIds.has(connectionId), false, message);
+      assert.equal(store.activeConnectionId, null, message);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("explicit lost-connection marker clears state without relying on error text", async () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    store.addEphemeralConnection(conn("conn-1"));
+    store.activeConnectionId = "conn-1";
+    store.treeNodes.push({
+      id: "conn-1",
+      label: "conn-1",
+      type: "connection",
+      connectionId: "conn-1",
+      isLoading: true,
+      children: [],
+    });
+
+    store.markConnectionLost("conn-1", new Error("连接可能已断开，请刷新数据重试"));
+
+    assert.equal(store.connectedIds.has("conn-1"), false);
+    assert.equal(store.activeConnectionId, null);
+    assert.equal(store.treeNodes[0].isLoading, false);
+    assert.equal(store.connectionErrors["conn-1"], "连接可能已断开，请刷新数据重试");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("late original connect errors replace the generic timeout detail", async () => {
+  vi.useFakeTimers();
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = (async (input) => {
+    if (String(input) === "/api/connection/connect") {
+      return new Promise<Response>((_, reject) => {
+        setTimeout(() => reject(new Error("MySQL connection failed: raw socket timeout")), 3500);
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    const config = { ...conn("conn-1"), connect_timeout_secs: 1 };
+    const connectPromise = store.connect(config);
+    const timeoutRejection = assert.rejects(() => connectPromise, /Connection attempt timed out after 3s/);
+
+    await vi.advanceTimersByTimeAsync(3000);
+    await timeoutRejection;
+    assert.equal(store.connectionErrors["conn-1"], "Connection attempt timed out after 3s. Please check the network or VPN and try again.");
+
+    await vi.advanceTimersByTimeAsync(500);
+    await Promise.resolve();
+
+    assert.match(store.connectionErrors["conn-1"], /Original database error returned after the UI timeout/);
+    assert.match(store.connectionErrors["conn-1"], /MySQL connection failed: raw socket timeout/);
+  } finally {
+    vi.useRealTimers();
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("late original connect success is disconnected after the UI timeout", async () => {
+  vi.useFakeTimers();
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  const disconnected: string[] = [];
+  globalThis.fetch = (async (input, init) => {
+    if (String(input) === "/api/connection/connect") {
+      return new Promise<Response>((resolve) => {
+        setTimeout(() => resolve(new Response(JSON.stringify("conn-1"), { status: 200, headers: { "Content-Type": "application/json" } })), 3500);
+      });
+    }
+    if (String(input) === "/api/connection/disconnect") {
+      const body = JSON.parse(String(init?.body ?? "{}")) as { connectionId?: string };
+      if (body.connectionId) disconnected.push(body.connectionId);
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("unexpected request", { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    const config = { ...conn("conn-1"), connect_timeout_secs: 1 };
+    const connectPromise = store.connect(config);
+    const timeoutRejection = assert.rejects(() => connectPromise, /Connection attempt timed out after 3s/);
+
+    await vi.advanceTimersByTimeAsync(3000);
+    await timeoutRejection;
+    assert.equal(store.connectedIds.has("conn-1"), false);
+
+    await vi.advanceTimersByTimeAsync(500);
+    await Promise.resolve();
+
+    assert.deepEqual(disconnected, ["conn-1"]);
+    assert.equal(store.connectedIds.has("conn-1"), false);
+  } finally {
+    vi.useRealTimers();
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("late original connect success does not disconnect a newer connected state", async () => {
+  vi.useFakeTimers();
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  const disconnected: string[] = [];
+  globalThis.fetch = (async (input, init) => {
+    if (String(input) === "/api/connection/connect") {
+      return new Promise<Response>((resolve) => {
+        setTimeout(() => resolve(new Response(JSON.stringify("conn-1"), { status: 200, headers: { "Content-Type": "application/json" } })), 3500);
+      });
+    }
+    if (String(input) === "/api/connection/disconnect") {
+      const body = JSON.parse(String(init?.body ?? "{}")) as { connectionId?: string };
+      if (body.connectionId) disconnected.push(body.connectionId);
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("unexpected request", { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    const config = { ...conn("conn-1"), connect_timeout_secs: 1 };
+    const connectPromise = store.connect(config);
+    const timeoutRejection = assert.rejects(() => connectPromise, /Connection attempt timed out after 3s/);
+
+    await vi.advanceTimersByTimeAsync(3000);
+    await timeoutRejection;
+    store.connectedIds.add("conn-1");
+
+    await vi.advanceTimersByTimeAsync(500);
+    await Promise.resolve();
+
+    assert.deepEqual(disconnected, []);
+    assert.equal(store.connectedIds.has("conn-1"), true);
+  } finally {
+    vi.useRealTimers();
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("hanging database metadata load times out and clears loading state", async () => {
+  vi.useFakeTimers();
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = (async (input) => {
+    if (String(input).startsWith("/api/schema/databases?")) {
+      return new Promise<Response>(() => {});
+    }
+    return new Response("unexpected request", { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    store.addEphemeralConnection(conn("conn-1"));
+    store.activeConnectionId = "conn-1";
+    store.treeNodes.push({
+      id: "conn-1",
+      label: "conn-1",
+      type: "connection",
+      connectionId: "conn-1",
+      children: [],
+    });
+
+    const loadPromise = store.loadDatabases("conn-1");
+    const timeoutRejection = assert.rejects(() => loadPromise, /Connection timed out while loading databases after 35s/);
+
+    await vi.advanceTimersByTimeAsync(35000);
+    await timeoutRejection;
+
+    assert.equal(store.treeNodes[0].isLoading, false);
+    assert.equal(store.connectedIds.has("conn-1"), false);
+    assert.equal(store.activeConnectionId, null);
+    assert.match(store.connectionErrors["conn-1"], /Connection timed out while loading databases/);
+  } finally {
+    vi.useRealTimers();
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("utility-only connection cache is ignored and replaced with live metadata children", async () => {
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  const utilityOnlyCache = {
+    version: 2,
+    cachedAt: new Date().toISOString(),
+    children: [
+      {
+        id: "conn-1:__user_admin",
+        label: "tree.userAdmin",
+        type: "user-admin",
+        connectionId: "conn-1",
+        database: "",
+      },
+    ],
+  };
+  let listDatabasesCalls = 0;
+  let savedPayload: any = null;
+
+  globalThis.fetch = (async (input, init) => {
+    const url = String(input);
+    if (url.startsWith("/api/schema/cache?")) {
+      return jsonResponse(utilityOnlyCache);
+    }
+    if (url.startsWith("/api/schema/databases?")) {
+      listDatabasesCalls++;
+      return jsonResponse([{ name: "app" }]);
+    }
+    if (url === "/api/schema/cache" && init?.method === "POST") {
+      savedPayload = JSON.parse(String(init.body ?? "{}")).payload;
+      return jsonResponse(null);
+    }
+    return new Response("unexpected request", { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    store.addEphemeralConnection({ ...conn("conn-1"), db_type: "mysql", port: 3306 });
+    store.treeNodes.push({
+      id: "conn-1",
+      label: "conn-1",
+      type: "connection",
+      connectionId: "conn-1",
+      children: [],
+    });
+
+    await store.loadDatabases("conn-1");
+
+    assert.equal(listDatabasesCalls, 1);
+    assert.deepEqual(
+      store.treeNodes[0].children?.map((child) => child.type),
+      ["database", "user-admin"],
+    );
+    assert.deepEqual(
+      savedPayload?.children?.map((child: any) => child.type),
+      ["database"],
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("empty root metadata does not replace existing databases with only user admin", async () => {
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  let savedPayload: any = null;
+
+  globalThis.fetch = (async (input, init) => {
+    const url = String(input);
+    if (url.startsWith("/api/schema/cache?")) {
+      return jsonResponse(null);
+    }
+    if (url.startsWith("/api/schema/databases?")) {
+      return jsonResponse([]);
+    }
+    if (url === "/api/schema/cache" && init?.method === "POST") {
+      savedPayload = JSON.parse(String(init.body ?? "{}")).payload;
+      return jsonResponse(null);
+    }
+    return new Response("unexpected request", { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    store.addEphemeralConnection({ ...conn("conn-1"), db_type: "mysql", port: 3306 });
+    store.treeNodes.push({
+      id: "conn-1",
+      label: "conn-1",
+      type: "connection",
+      connectionId: "conn-1",
+      children: [
+        {
+          id: "conn-1:app",
+          label: "app",
+          type: "database",
+          connectionId: "conn-1",
+          database: "app",
+          children: [],
+        },
+      ],
+    });
+
+    await store.loadDatabases("conn-1");
+
+    assert.deepEqual(
+      store.treeNodes[0].children?.map((child) => child.type),
+      ["database", "user-admin"],
+    );
+    assert.deepEqual(
+      store.treeNodes[0].children?.map((child) => child.id),
+      ["conn-1:app", "conn-1:__user_admin"],
+    );
+    assert.deepEqual(
+      savedPayload?.children?.map((child: any) => child.id),
+      ["conn-1:app"],
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test.each([
+  ["redis", "loadRedisDatabases", "/api/redis/list-databases", "Redis databases"],
+  ["mq", "loadMqTenants", "/api/mq/tenants/list", "message queue tenants"],
+  ["mongodb", "loadMongoDatabases", "/api/document-store/list-databases", "MongoDB databases"],
+  ["elasticsearch", "loadElasticsearchIndices", "/api/document-store/list-collections", "Elasticsearch indices"],
+  ["qdrant", "loadVectorCollections", "/api/document-store/list-collections", "vector collections"],
+] as const)("hanging %s root metadata load times out and clears loading state", async (dbType, loader, endpoint, label) => {
+  vi.useFakeTimers();
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = (async (input) => {
+    if (String(input) === endpoint) {
+      return new Promise<Response>(() => {});
+    }
+    // Marking a connection lost also cleans up any query client sessions.
+    if (String(input) === "/api/query/close-client-session") {
+      return jsonResponse(true);
+    }
+    return new Response("unexpected request", { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    store.addEphemeralConnection({ ...conn("conn-1"), db_type: dbType });
+    store.activeConnectionId = "conn-1";
+    store.treeNodes.push({
+      id: "conn-1",
+      label: "conn-1",
+      type: "connection",
+      connectionId: "conn-1",
+      children: [],
+    });
+
+    const loadPromise = store[loader]("conn-1");
+    const timeoutRejection = assert.rejects(() => loadPromise, new RegExp(`Connection timed out while loading ${label} after 35s`));
+
+    await vi.advanceTimersByTimeAsync(35000);
+    await timeoutRejection;
+
+    assert.equal(store.treeNodes[0].isLoading, false);
+    assert.equal(store.connectedIds.has("conn-1"), false);
+    assert.equal(store.activeConnectionId, null);
+    assert.match(store.connectionErrors["conn-1"], new RegExp(`Connection timed out while loading ${label}`));
+  } finally {
+    vi.useRealTimers();
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
diff --git a/packages/app-tests/connectionStoreGroupedConnect.test.ts b/packages/app-tests/connectionStoreGroupedConnect.test.ts
new file mode 100644
index 0000000..c1cc76b
--- /dev/null
+++ b/packages/app-tests/connectionStoreGroupedConnect.test.ts
@@ -0,0 +1,273 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { createPinia, setActivePinia } from "pinia";
+import { useConnectionStore } from "../../apps/desktop/src/stores/connectionStore.ts";
+import type { ConnectionConfig, SidebarLayout, TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+function installMemoryStorage() {
+  const values = new Map<string, string>();
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+      clear: () => values.clear(),
+    },
+  });
+  return {
+    restore() {
+      if (original) Object.defineProperty(globalThis, "localStorage", original);
+      else Reflect.deleteProperty(globalThis, "localStorage");
+    },
+  };
+}
+
+function conn(id: string, name: string): ConnectionConfig {
+  return {
+    id,
+    name,
+    db_type: "mysql",
+    host: "127.0.0.1",
+    port: 3306,
+    username: "root",
+    password: "secret",
+  };
+}
+
+function countConnectionNodes(nodes: TreeNode[], connectionId: string): number {
+  let count = 0;
+  for (const node of nodes) {
+    if (node.type === "connection" && node.connectionId === connectionId) count++;
+    if (node.children) count += countConnectionNodes(node.children, connectionId);
+  }
+  return count;
+}
+
+test("connecting a grouped connection updates it in place instead of adding a root node", async () => {
+  const originalFetch = globalThis.fetch;
+  const storage = installMemoryStorage();
+  const layout: SidebarLayout = {
+    groups: [{ id: "group-1", name: "Group", collapsed: false }],
+    order: [{ type: "group", id: "group-1", connectionIds: [] }],
+  };
+
+  globalThis.fetch = (async (input, init) => {
+    const url = String(input);
+    if (url === "/api/connection/list") {
+      return new Response("[]", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/layout/sidebar") {
+      if (init?.method === "POST") {
+        return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+      }
+      return new Response(JSON.stringify(layout), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/connection/save") {
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/connection/connect") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify(body.config.id), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    await store.initFromDisk();
+    store.startCreatingConnectionInGroup("group-1");
+
+    const config = conn("conn-1", "Grouped MySQL");
+    await store.addConnection(config);
+    await store.connect(config);
+
+    assert.equal(store.treeNodes.length, 1);
+    assert.equal(store.treeNodes[0].type, "connection-group");
+    assert.deepEqual(
+      store.treeNodes[0].children?.map((node) => node.id),
+      ["conn-1"],
+    );
+    assert.equal(countConnectionNodes(store.treeNodes, "conn-1"), 1);
+  } finally {
+    globalThis.fetch = originalFetch;
+    storage.restore();
+  }
+});
+
+test("duplicating a grouped connection keeps the copy in the same group", async () => {
+  const originalFetch = globalThis.fetch;
+  const storage = installMemoryStorage();
+  const originalConnection = conn("conn-1", "Grouped MySQL");
+  let savedConnections: ConnectionConfig[] = [originalConnection];
+  let savedLayout: SidebarLayout | null = {
+    groups: [{ id: "group-1", name: "Group", collapsed: false }],
+    order: [{ type: "group", id: "group-1", connectionIds: ["conn-1"] }],
+  };
+
+  globalThis.fetch = (async (input, init) => {
+    const url = String(input);
+    if (url === "/api/connection/list") {
+      return new Response(JSON.stringify(savedConnections), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/layout/sidebar") {
+      if (init?.method === "POST") {
+        savedLayout = JSON.parse(String(init.body ?? "null"));
+        return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+      }
+      return new Response(JSON.stringify(savedLayout), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/connection/save") {
+      savedConnections = JSON.parse(String(init?.body ?? "[]"));
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    await store.initFromDisk();
+
+    const copy = { ...originalConnection, id: "conn-copy", name: "Grouped MySQL (Copy)" };
+    await store.addConnection(copy, store.groupIdForConnection(originalConnection.id));
+
+    assert.deepEqual(
+      store.treeNodes.map((node) => node.id),
+      ["group-1"],
+    );
+    assert.equal(store.treeNodes[0].type, "connection-group");
+    assert.deepEqual(
+      store.treeNodes[0].children?.map((node) => node.id),
+      ["conn-1", "conn-copy"],
+    );
+    assert.equal(countConnectionNodes(store.treeNodes, "conn-copy"), 1);
+  } finally {
+    globalThis.fetch = originalFetch;
+    storage.restore();
+  }
+});
+
+test("reloading connections preserves the current grouped layout when the saved layout is temporarily unavailable", async () => {
+  const originalFetch = globalThis.fetch;
+  const storage = installMemoryStorage();
+  const savedConnections: ConnectionConfig[] = [
+    conn("pg", "pg"),
+    conn("pg2", "pg2"),
+    conn("pg3", "pg3"),
+    conn("pg4", "pg4"),
+  ];
+  let savedLayout: SidebarLayout | null = {
+    groups: [
+      { id: "group-a", name: "dir[a]", collapsed: false },
+      { id: "group-b", name: "dir[b]", collapsed: false },
+    ],
+    order: [
+      { type: "group", id: "group-a", connectionIds: ["pg", "pg2"] },
+      { type: "group", id: "group-b", connectionIds: ["pg3", "pg4"] },
+    ],
+  };
+
+  globalThis.fetch = (async (input, init) => {
+    const url = String(input);
+    if (url === "/api/connection/list") {
+      return new Response(JSON.stringify(savedConnections), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/layout/sidebar") {
+      if (init?.method === "POST") {
+        savedLayout = JSON.parse(String(init.body ?? "null"));
+        return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+      }
+      return new Response(JSON.stringify(savedLayout), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    await store.initFromDisk();
+
+    assert.deepEqual(
+      store.treeNodes.map((node) => node.label),
+      ["dir[a]", "dir[b]"],
+    );
+
+    savedLayout = null;
+    await store.initFromDisk();
+
+    assert.deepEqual(
+      store.treeNodes.map((node) => node.label),
+      ["dir[a]", "dir[b]"],
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    storage.restore();
+  }
+});
+
+test("importing grouped dbx connections remaps exported layout to new connection ids", async () => {
+  const originalFetch = globalThis.fetch;
+  const storage = installMemoryStorage();
+  let savedConnections: ConnectionConfig[] = [];
+  let savedLayout: SidebarLayout | null = null;
+
+  globalThis.fetch = (async (input, init) => {
+    const url = String(input);
+    if (url === "/api/connection/list") {
+      return new Response(JSON.stringify(savedConnections), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/layout/sidebar") {
+      if (init?.method === "POST") {
+        savedLayout = JSON.parse(String(init.body ?? "null"));
+        return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+      }
+      return new Response(JSON.stringify(savedLayout), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/connection/save") {
+      savedConnections = JSON.parse(String(init?.body ?? "[]"));
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    await store.initFromDisk();
+
+    const exportedLayout: SidebarLayout = {
+      groups: [{ id: "group-1", name: "Imported Group", collapsed: false }],
+      order: [{ type: "group", id: "group-1", connectionIds: ["old-conn-1", "old-conn-2"] }],
+    };
+    const content = JSON.stringify({
+      connections: [conn("old-conn-1", "Grouped A"), conn("old-conn-2", "Grouped B")],
+      layout: exportedLayout,
+    });
+
+    const result = await store.importConnectionsFromFile(content, null);
+    assert.equal(result.count, 2);
+    assert.ok(result.layout);
+    store.applySidebarLayout(result.layout!);
+
+    const group = store.treeNodes[0];
+    assert.equal(group.type, "connection-group");
+    assert.equal(group.label, "Imported Group");
+    assert.deepEqual(
+      group.children?.map((node) => node.label),
+      ["Grouped A", "Grouped B"],
+    );
+    assert.notDeepEqual(
+      group.children?.map((node) => node.id),
+      ["old-conn-1", "old-conn-2"],
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    storage.restore();
+  }
+});
diff --git a/packages/app-tests/connectionStorePinnedCleanup.test.ts b/packages/app-tests/connectionStorePinnedCleanup.test.ts
new file mode 100644
index 0000000..0f75ef9
--- /dev/null
+++ b/packages/app-tests/connectionStorePinnedCleanup.test.ts
@@ -0,0 +1,85 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { createPinia, setActivePinia } from "pinia";
+import { useConnectionStore } from "../../apps/desktop/src/stores/connectionStore.ts";
+import type { ConnectionConfig } from "../../apps/desktop/src/types/database.ts";
+
+function installMemoryStorage(initial: Record<string, string> = {}) {
+  const values = new Map(Object.entries(initial));
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+      clear: () => values.clear(),
+    },
+  });
+  return {
+    values,
+    restore() {
+      if (original) Object.defineProperty(globalThis, "localStorage", original);
+      else Reflect.deleteProperty(globalThis, "localStorage");
+    },
+  };
+}
+
+function conn(id: string, name: string): ConnectionConfig {
+  return {
+    id,
+    name,
+    db_type: "postgres",
+    host: "localhost",
+    port: 5432,
+    username: "postgres",
+    password: "",
+  };
+}
+
+test("removeConnection prunes pinned ids and persists the pruned set", async () => {
+  const storage = installMemoryStorage({
+    "dbx-pinned-tree-nodes": JSON.stringify(["conn-a", "conn-a:db:main", "conn-b:db:main"]),
+  });
+  const originalFetch = globalThis.fetch;
+  const savedPayloads: unknown[] = [];
+
+  globalThis.fetch = (async (input, init) => {
+    const url = String(input);
+    if (url === "/api/connection/list") {
+      return new Response(JSON.stringify([conn("conn-a", "A"), conn("conn-b", "B")]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/layout/sidebar") {
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/connection/save") {
+      savedPayloads.push(JSON.parse(String(init?.body ?? "{}")));
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("[]", { status: 200, headers: { "Content-Type": "application/json" } });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    await store.initFromDisk();
+
+    assert.equal(store.isTreeNodePinned("conn-a"), true);
+    assert.equal(store.isTreeNodePinned("conn-a:db:main"), true);
+    assert.equal(store.isTreeNodePinned("conn-b:db:main"), true);
+
+    await store.removeConnection("conn-a");
+
+    assert.equal(store.isTreeNodePinned("conn-a"), false);
+    assert.equal(store.isTreeNodePinned("conn-a:db:main"), false);
+    assert.equal(store.isTreeNodePinned("conn-b:db:main"), true);
+    assert.deepEqual(JSON.parse(storage.values.get("dbx-pinned-tree-nodes") || "[]"), ["conn-b:db:main"]);
+    assert.equal(savedPayloads.length >= 1, true);
+  } finally {
+    globalThis.fetch = originalFetch;
+    storage.restore();
+  }
+});
diff --git a/packages/app-tests/connectionUrl.test.ts b/packages/app-tests/connectionUrl.test.ts
new file mode 100644
index 0000000..1db0d9f
--- /dev/null
+++ b/packages/app-tests/connectionUrl.test.ts
@@ -0,0 +1,477 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { applyParsedConnectionUrl, normalizeMongoConnectionString, parseConnectionUrl } from "../../apps/desktop/src/lib/connection/connectionUrl.ts";
+import { h2FileJdbcUrlWithPath } from "../../apps/desktop/src/lib/database/h2Connection.ts";
+
+test("parses postgres connection URLs", () => {
+  assert.deepEqual(parseConnectionUrl("postgresql://alice:secret@db.example.com:5433/app?sslmode=require"), {
+    dbType: "postgres",
+    driverProfile: "postgres",
+    driverLabel: "PostgreSQL",
+    host: "db.example.com",
+    port: 5433,
+    username: "alice",
+    password: "secret",
+    database: "app",
+    urlParams: "sslmode=require",
+    ssl: true,
+  });
+});
+
+test("parses KWDB connection URLs", () => {
+  assert.deepEqual(parseConnectionUrl("kwdb://root:secret@kw.example.com/defaultdb?sslmode=require"), {
+    dbType: "kwdb",
+    driverProfile: "kwdb",
+    driverLabel: "KWDB",
+    host: "kw.example.com",
+    port: 26257,
+    username: "root",
+    password: "secret",
+    database: "defaultdb",
+    urlParams: "sslmode=require",
+    ssl: true,
+  });
+});
+
+test("parses mysql URLs with encoded credentials", () => {
+  const parsed = parseConnectionUrl("mysql://root:p%40ss@127.0.0.1/shop?charset=utf8mb4");
+
+  assert.equal(parsed.dbType, "mysql");
+  assert.equal(parsed.driverProfile, "mysql");
+  assert.equal(parsed.host, "127.0.0.1");
+  assert.equal(parsed.port, 3306);
+  assert.equal(parsed.username, "root");
+  assert.equal(parsed.password, "p@ss");
+  assert.equal(parsed.database, "shop");
+  assert.equal(parsed.urlParams, "charset=utf8mb4");
+});
+
+test("parses mysql URL name as decoded connection name", () => {
+  const parsed = parseConnectionUrl("mysql://root:123456@localhost/?name=%E5%85%AC%E5%8F%B8+-+%E6%9C%AC%E5%9C%B0Docker&charset=utf8mb4");
+
+  assert.equal(parsed.name, "公司 - 本地Docker");
+  assert.equal(parsed.host, "localhost");
+  assert.equal(parsed.username, "root");
+  assert.equal(parsed.password, "123456");
+  assert.equal(parsed.urlParams, "charset=utf8mb4");
+});
+
+test("consumes mysql URL name when it is the only URL param", () => {
+  const parsed = parseConnectionUrl("mysql://root:123456@localhost/?name=%E5%85%AC%E5%8F%B8+-+%E6%9C%AC%E5%9C%B0Docker");
+
+  assert.equal(parsed.name, "公司 - 本地Docker");
+  assert.equal(parsed.urlParams, "");
+});
+
+test("removes only the connection name from URL params", () => {
+  const parsed = parseConnectionUrl("mysql://root@localhost/app?Name=Analytics+Local&ssl-mode=required");
+
+  assert.equal(parsed.name, "Analytics Local");
+  assert.equal(parsed.database, "app");
+  assert.equal(parsed.urlParams, "ssl-mode=required");
+  assert.equal(parsed.ssl, true);
+});
+
+test("parses mysql TLS URL params into the SSL switch state", () => {
+  assert.equal(parseConnectionUrl("mysql://root@tidb.example.com:4000/test?ssl-mode=required").ssl, true);
+  assert.equal(parseConnectionUrl("mysql://root@tidb.example.com:4000/test?require_ssl=true").ssl, true);
+});
+
+test("parses TiDB Cloud MySQL URLs as TLS connections", () => {
+  const parsed = parseConnectionUrl("mysql://root:secret@gateway01.us-west-2.prod.aws.tidbcloud.com:4000/test");
+
+  assert.equal(parsed.dbType, "mysql");
+  assert.equal(parsed.ssl, true);
+});
+
+test("parses MySQL JDBC user and password URL params as credentials", () => {
+  const parsed = parseConnectionUrl("jdbc:mysql://127.0.0.1:1234/example?user=admin&password=pwd&useUnicode=true&characterEncoding=UTF8&useSSL=false");
+
+  assert.equal(parsed.dbType, "mysql");
+  assert.equal(parsed.host, "127.0.0.1");
+  assert.equal(parsed.port, 1234);
+  assert.equal(parsed.username, "admin");
+  assert.equal(parsed.password, "pwd");
+  assert.equal(parsed.database, "example");
+  assert.equal(parsed.urlParams, "useUnicode=true&characterEncoding=UTF8&useSSL=false");
+});
+
+test("parses MySQL JDBC URL params with ProxySQL multi-at usernames", () => {
+  const parsed = parseConnectionUrl("jdbc:mysql://127.0.0.1:6033/example?user=xxxxx%40db_readonly%40127.0.0.1&password=p%40wd&useSSL=false");
+
+  assert.equal(parsed.dbType, "mysql");
+  assert.equal(parsed.host, "127.0.0.1");
+  assert.equal(parsed.port, 6033);
+  assert.equal(parsed.username, "xxxxx@db_readonly@127.0.0.1");
+  assert.equal(parsed.password, "p@wd");
+  assert.equal(parsed.database, "example");
+  assert.equal(parsed.urlParams, "useSSL=false");
+});
+
+test("leaves non-JDBC MySQL user and password URL params untouched", () => {
+  const parsed = parseConnectionUrl("mysql://127.0.0.1:1234/example?user=admin&password=pwd&charset=utf8mb4");
+
+  assert.equal(parsed.username, "");
+  assert.equal(parsed.password, "");
+  assert.equal(parsed.urlParams, "user=admin&password=pwd&charset=utf8mb4");
+});
+
+test("parses Redis insecure TLS URL fragments into URL params", () => {
+  const parsed = parseConnectionUrl("rediss://default:secret@redis.example.com:6379/0#insecure");
+
+  assert.equal(parsed.dbType, "redis");
+  assert.equal(parsed.host, "redis.example.com");
+  assert.equal(parsed.port, 6379);
+  assert.equal(parsed.username, "default");
+  assert.equal(parsed.password, "secret");
+  assert.equal(parsed.database, "0");
+  assert.equal(parsed.urlParams, "insecure=true");
+  assert.equal(parsed.ssl, true);
+});
+
+test("parses JDBC URLs by using the inner database URL", () => {
+  const postgres = parseConnectionUrl("jdbc:postgresql://alice:secret@db.example.com:5433/app?sslmode=require");
+  assert.equal(postgres.dbType, "postgres");
+  assert.equal(postgres.driverProfile, "postgres");
+  assert.equal(postgres.host, "db.example.com");
+  assert.equal(postgres.port, 5433);
+  assert.equal(postgres.username, "alice");
+  assert.equal(postgres.password, "secret");
+  assert.equal(postgres.database, "app");
+  assert.equal(postgres.urlParams, "sslmode=require");
+
+  const mysql = parseConnectionUrl("jdbc:mysql://root:p%40ss@127.0.0.1:3307/shop?charset=utf8mb4");
+  assert.equal(mysql.dbType, "mysql");
+  assert.equal(mysql.driverProfile, "mysql");
+  assert.equal(mysql.host, "127.0.0.1");
+  assert.equal(mysql.port, 3307);
+  assert.equal(mysql.username, "root");
+  assert.equal(mysql.password, "p@ss");
+  assert.equal(mysql.database, "shop");
+  assert.equal(mysql.urlParams, "charset=utf8mb4");
+});
+
+test("parses TDengine WebSocket JDBC URLs", () => {
+  const parsed = parseConnectionUrl("jdbc:TAOS-WS://root:taosdata@td.example.com:6041/power?timezone=UTC");
+
+  assert.equal(parsed.dbType, "tdengine");
+  assert.equal(parsed.driverProfile, "tdengine");
+  assert.equal(parsed.driverLabel, "TDengine");
+  assert.equal(parsed.host, "td.example.com");
+  assert.equal(parsed.port, 6041);
+  assert.equal(parsed.username, "root");
+  assert.equal(parsed.password, "taosdata");
+  assert.equal(parsed.database, "power");
+  assert.equal(parsed.urlParams, "timezone=UTC");
+});
+
+test("parses XuguDB JDBC URLs", () => {
+  const parsed = parseConnectionUrl("jdbc:xugu://alice:secret@xugu.example.com:5138/demo?charset=utf8");
+
+  assert.equal(parsed.dbType, "xugu");
+  assert.equal(parsed.driverProfile, "xugu");
+  assert.equal(parsed.driverLabel, "XuguDB");
+  assert.equal(parsed.host, "xugu.example.com");
+  assert.equal(parsed.port, 5138);
+  assert.equal(parsed.username, "alice");
+  assert.equal(parsed.password, "secret");
+  assert.equal(parsed.database, "demo");
+  assert.equal(parsed.urlParams, "charset=utf8");
+});
+
+test("parses Apache IoTDB JDBC URLs", () => {
+  const parsed = parseConnectionUrl("jdbc:iotdb://root:secret@iotdb.example.com:6667?sql_dialect=table");
+
+  assert.equal(parsed.dbType, "iotdb");
+  assert.equal(parsed.driverProfile, "iotdb");
+  assert.equal(parsed.driverLabel, "Apache IoTDB");
+  assert.equal(parsed.host, "iotdb.example.com");
+  assert.equal(parsed.port, 6667);
+  assert.equal(parsed.username, "root");
+  assert.equal(parsed.password, "secret");
+  assert.equal(parsed.database, undefined);
+  assert.equal(parsed.urlParams, "sql_dialect=table");
+});
+
+test("parses GBase 8s JDBC URLs", () => {
+  const parsed = parseConnectionUrl("jdbc:gbasedbt-sqli://gbasedbt:secret@gbase.example.com:20013/testdb:GBASEDBTSERVER=gbase01;CLIENT_LOCALE=zh_cn.utf8");
+
+  assert.equal(parsed.dbType, "gbase");
+  assert.equal(parsed.driverProfile, "gbase8s");
+  assert.equal(parsed.driverLabel, "GBase 8s");
+  assert.equal(parsed.host, "gbase.example.com");
+  assert.equal(parsed.port, 20013);
+  assert.equal(parsed.username, "gbasedbt");
+  assert.equal(parsed.password, "secret");
+  assert.equal(parsed.database, "testdb");
+  assert.equal(parsed.urlParams, "GBASEDBTSERVER=gbase01;CLIENT_LOCALE=zh_cn.utf8");
+});
+
+test("parses Informix JDBC URLs with INFORMIXSERVER", () => {
+  const parsed = parseConnectionUrl("jdbc:informix-sqli://192.168.1.1:9088/mydb:INFORMIXSERVER=ol_informix");
+
+  assert.equal(parsed.dbType, "informix");
+  assert.equal(parsed.driverProfile, "informix");
+  assert.equal(parsed.driverLabel, "Informix");
+  assert.equal(parsed.host, "192.168.1.1");
+  assert.equal(parsed.port, 9088);
+  assert.equal(parsed.database, "mydb");
+  assert.equal(parsed.urlParams, "INFORMIXSERVER=ol_informix");
+});
+
+test("parses Informix JDBC URLs with multiple parameters", () => {
+  const parsed = parseConnectionUrl("jdbc:informix-sqli://192.168.1.1:9088/mydb:INFORMIXSERVER=ol_informix;DB_LOCALE=en_US.UTF8");
+
+  assert.equal(parsed.dbType, "informix");
+  assert.equal(parsed.host, "192.168.1.1");
+  assert.equal(parsed.port, 9088);
+  assert.equal(parsed.database, "mydb");
+  assert.equal(parsed.urlParams, "INFORMIXSERVER=ol_informix;DB_LOCALE=en_US.UTF8");
+});
+
+test("parses Informix JDBC URLs with credentials", () => {
+  const parsed = parseConnectionUrl("jdbc:informix-sqli://user:p%40ss@db.example.com:1533/testdb:INFORMIXSERVER=myserver");
+
+  assert.equal(parsed.dbType, "informix");
+  assert.equal(parsed.host, "db.example.com");
+  assert.equal(parsed.port, 1533);
+  assert.equal(parsed.username, "user");
+  assert.equal(parsed.password, "p@ss");
+  assert.equal(parsed.database, "testdb");
+  assert.equal(parsed.urlParams, "INFORMIXSERVER=myserver");
+});
+
+test("parses Informix JDBC URLs without extra parameters", () => {
+  const parsed = parseConnectionUrl("jdbc:informix-sqli://192.168.1.1:9088/mydb");
+
+  assert.equal(parsed.dbType, "informix");
+  assert.equal(parsed.host, "192.168.1.1");
+  assert.equal(parsed.port, 9088);
+  assert.equal(parsed.database, "mydb");
+  assert.equal(parsed.urlParams, "");
+});
+
+test("parses UCanAccess JDBC URLs as Access database files", () => {
+  const parsed = parseConnectionUrl("jdbc:ucanaccess:///Users/me/data/Northwind.accdb;memory=false");
+
+  assert.equal(parsed.dbType, "access");
+  assert.equal(parsed.driverProfile, "access");
+  assert.equal(parsed.driverLabel, "Microsoft Access");
+  assert.equal(parsed.host, "/Users/me/data/Northwind.accdb");
+  assert.equal(parsed.port, 0);
+  assert.equal(parsed.database, "Northwind.accdb");
+  assert.equal(parsed.connectionString, "jdbc:ucanaccess:///Users/me/data/Northwind.accdb;memory=false");
+});
+
+test("parses SQL Server JDBC URLs with semicolon properties", () => {
+  const parsed = parseConnectionUrl("jdbc:sqlserver://sql.example.com:1434;databaseName=erp;user=sa;password=s%40cret;encrypt=true");
+
+  assert.equal(parsed.dbType, "sqlserver");
+  assert.equal(parsed.driverProfile, "sqlserver");
+  assert.equal(parsed.host, "sql.example.com");
+  assert.equal(parsed.port, 1434);
+  assert.equal(parsed.username, "sa");
+  assert.equal(parsed.password, "s@cret");
+  assert.equal(parsed.database, "erp");
+  assert.equal(parsed.urlParams, "encrypt=true");
+});
+
+test("parses H2 split JDBC URLs as file connections", () => {
+  const source = "jdbc:h2:split:28:C:/dbx-test/h2/sample-db;AUTO_SERVER=TRUE";
+  const parsed = parseConnectionUrl(source);
+
+  assert.equal(parsed.dbType, "h2");
+  assert.equal(parsed.driverProfile, "h2");
+  assert.equal(parsed.driverLabel, "H2");
+  assert.equal(parsed.host, "C:/dbx-test/h2/sample-db");
+  assert.equal(parsed.port, 0);
+  assert.equal(parsed.username, "sa");
+  assert.equal(parsed.password, "");
+  assert.equal(parsed.database, "sample-db");
+  assert.equal(parsed.urlParams, "AUTO_SERVER=TRUE");
+  assert.equal(parsed.connectionString, source);
+});
+
+test("parses H2 TCP JDBC URLs as server connections", () => {
+  const source = "jdbc:h2:tcp://localhost:9123/~/sample-db;USER=sa;PASSWORD=s%40cret;MODE=MySQL";
+  const parsed = parseConnectionUrl(source);
+
+  assert.equal(parsed.dbType, "h2");
+  assert.equal(parsed.driverProfile, "h2");
+  assert.equal(parsed.driverLabel, "H2");
+  assert.equal(parsed.host, "localhost");
+  assert.equal(parsed.port, 9123);
+  assert.equal(parsed.username, "sa");
+  assert.equal(parsed.password, "s@cret");
+  assert.equal(parsed.database, "~/sample-db");
+  assert.equal(parsed.urlParams, "MODE=MySQL");
+  assert.equal(parsed.ssl, false);
+  assert.equal(parsed.connectionString, source);
+});
+
+test("keeps typed H2 credentials when JDBC URL does not include them", () => {
+  const parsed = parseConnectionUrl("jdbc:h2:split:28:C:/dbx-test/h2/sample-db;AUTO_SERVER=TRUE");
+  const applied = applyParsedConnectionUrl({ name: "", db_type: "h2", username: "typed-user", password: "typed-secret" } as any, parsed);
+
+  assert.equal(applied.username, "typed-user");
+  assert.equal(applied.password, "typed-secret");
+});
+
+test("uses H2 JDBC URL credentials when they are included", () => {
+  const parsed = parseConnectionUrl("jdbc:h2:split:28:C:/dbx-test/h2/sample-db;USER=url-user;PASSWORD=url-secret;AUTO_SERVER=TRUE");
+  const applied = applyParsedConnectionUrl({ name: "", db_type: "h2", username: "typed-user", password: "typed-secret" } as any, parsed);
+
+  assert.equal(applied.username, "url-user");
+  assert.equal(applied.password, "url-secret");
+});
+
+test("rebuilds H2 split JDBC URLs with an edited file path", () => {
+  assert.equal(h2FileJdbcUrlWithPath("jdbc:h2:split:28:C:/dbx-test/h2/sample-db;AUTO_SERVER=TRUE", "D:/dbx/new-sample.mv.db"), "jdbc:h2:split:28:D:/dbx/new-sample;AUTO_SERVER=TRUE");
+});
+
+test("parses Oracle JDBC service URLs", () => {
+  const parsed = parseConnectionUrl("jdbc:oracle:thin:@//oracle.example.com:1522/ORCLPDB1");
+
+  assert.equal(parsed.dbType, "oracle");
+  assert.equal(parsed.driverProfile, "oracle");
+  assert.equal(parsed.host, "oracle.example.com");
+  assert.equal(parsed.port, 1522);
+  assert.equal(parsed.database, "ORCLPDB1");
+  assert.equal(parsed.oracleConnectionType, "service_name");
+});
+
+test("parses Oracle JDBC SID URLs", () => {
+  const parsed = parseConnectionUrl("jdbc:oracle:thin:@oracle.example.com:1521:ORCL");
+
+  assert.equal(parsed.dbType, "oracle");
+  assert.equal(parsed.driverProfile, "oracle");
+  assert.equal(parsed.host, "oracle.example.com");
+  assert.equal(parsed.port, 1521);
+  assert.equal(parsed.database, "ORCL");
+  assert.equal(parsed.oracleConnectionType, "sid");
+});
+
+test("parses Oracle JDBC descriptors and keeps the original connection string", () => {
+  const source = "jdbc:oracle:thin:@(DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=oracle.example.com)(PORT=1521))(CONNECT_DATA=(SERVICE_NAME=orcl)))";
+  const parsed = parseConnectionUrl(source);
+
+  assert.equal(parsed.dbType, "oracle");
+  assert.equal(parsed.driverProfile, "oracle");
+  assert.equal(parsed.host, "oracle.example.com");
+  assert.equal(parsed.port, 1521);
+  assert.equal(parsed.database, "orcl");
+  assert.equal(parsed.oracleConnectionType, "service_name");
+  assert.equal(parsed.connectionString, source);
+});
+
+test("keeps MongoDB URLs as connection strings", () => {
+  const source = "mongodb+srv://reader:secret@cluster.example.com/app?retryWrites=true";
+  const parsed = parseConnectionUrl(source);
+
+  assert.equal(parsed.dbType, "mongodb");
+  assert.equal(parsed.driverProfile, "mongodb");
+  assert.equal(parsed.host, "cluster.example.com");
+  assert.equal(parsed.port, 27017);
+  assert.equal(parsed.database, "app");
+  assert.equal(parsed.connectionString, source);
+  assert.equal(parsed.useMongoUrl, true);
+  assert.equal(parsed.ssl, true);
+});
+
+test("normalizes MongoDB URL credentials when reserved characters can be parsed safely", () => {
+  const parsed = parseConnectionUrl("mongodb://reader:pa@ss:word@mongo.example.com/admin?authSource=admin");
+
+  assert.equal(parsed.username, "reader");
+  assert.equal(parsed.password, "pa@ss:word");
+  assert.equal(parsed.connectionString, "mongodb://reader:pa%40ss%3Aword@mongo.example.com/admin?authSource=admin");
+});
+
+test("normalizes invalid percent escapes in MongoDB URL credentials", () => {
+  assert.equal(normalizeMongoConnectionString("mongodb://reader:pa%ss@mongo.example.com/admin"), "mongodb://reader:pa%25ss@mongo.example.com/admin");
+});
+
+test("uses selected HTTP-compatible profile for HTTP URLs", () => {
+  const parsed = parseConnectionUrl("https://search.example.com:9243", "elasticsearch");
+
+  assert.equal(parsed.dbType, "elasticsearch");
+  assert.equal(parsed.driverProfile, "elasticsearch");
+  assert.equal(parsed.host, "search.example.com");
+  assert.equal(parsed.port, 9243);
+  assert.equal(parsed.ssl, true);
+});
+
+test("parses HTTPS ClickHouse URLs with selected profile", () => {
+  const parsed = parseConnectionUrl("https://default:secret@clickhouse.example.com:8443/default?secure=true", "clickhouse");
+
+  assert.equal(parsed.dbType, "clickhouse");
+  assert.equal(parsed.driverProfile, "clickhouse");
+  assert.equal(parsed.host, "clickhouse.example.com");
+  assert.equal(parsed.port, 8443);
+  assert.equal(parsed.username, "default");
+  assert.equal(parsed.password, "secret");
+  assert.equal(parsed.database, "default");
+  assert.equal(parsed.urlParams, "secure=true");
+  assert.equal(parsed.ssl, true);
+});
+
+test("parses MongoDB multi-host replica set URL", () => {
+  const source = "mongodb://test:test@1.1.1.1:27017,1.1.1.2:27017,1.1.1.3:27017/admin?authMechanism=SCRAM-SHA-256&authSource=admin&replicaSet=testRS0";
+  const parsed = parseConnectionUrl(source);
+
+  assert.equal(parsed.dbType, "mongodb");
+  assert.equal(parsed.driverProfile, "mongodb");
+  assert.equal(parsed.host, "1.1.1.1");
+  assert.equal(parsed.port, 27017);
+  assert.equal(parsed.username, "test");
+  assert.equal(parsed.password, "test");
+  assert.equal(parsed.database, "admin");
+  assert.equal(parsed.urlParams, "authMechanism=SCRAM-SHA-256&authSource=admin&replicaSet=testRS0");
+  assert.equal(parsed.connectionString, source);
+  assert.equal(parsed.useMongoUrl, true);
+  assert.equal(parsed.ssl, false);
+});
+
+test("parses MongoDB single-host URL with replicaSet and auth params", () => {
+  const source = "mongodb://test:test@1.1.1.1:27017/?authMechanism=SCRAM-SHA-256&authSource=admin&replicaSet=testRS0";
+  const parsed = parseConnectionUrl(source);
+
+  assert.equal(parsed.dbType, "mongodb");
+  assert.equal(parsed.host, "1.1.1.1");
+  assert.equal(parsed.port, 27017);
+  assert.equal(parsed.username, "test");
+  assert.equal(parsed.password, "test");
+  assert.equal(parsed.urlParams, "authMechanism=SCRAM-SHA-256&authSource=admin&replicaSet=testRS0");
+  assert.equal(parsed.connectionString, source);
+  assert.equal(parsed.useMongoUrl, true);
+});
+
+test("parses MongoDB multi-host URL without credentials", () => {
+  const source = "mongodb://host1:27017,host2:27017/?replicaSet=rs0";
+  const parsed = parseConnectionUrl(source);
+
+  assert.equal(parsed.dbType, "mongodb");
+  assert.equal(parsed.host, "host1");
+  assert.equal(parsed.port, 27017);
+  assert.equal(parsed.username, "");
+  assert.equal(parsed.password, "");
+  assert.equal(parsed.urlParams, "replicaSet=rs0");
+  assert.equal(parsed.connectionString, source);
+  assert.equal(parsed.useMongoUrl, true);
+});
+
+test("parses MongoDB URL with simple authSource only", () => {
+  const source = "mongodb://test:test@1.1.1.1:27017/?authSource=admin";
+  const parsed = parseConnectionUrl(source);
+
+  assert.equal(parsed.dbType, "mongodb");
+  assert.equal(parsed.host, "1.1.1.1");
+  assert.equal(parsed.port, 27017);
+  assert.equal(parsed.username, "test");
+  assert.equal(parsed.password, "test");
+  assert.equal(parsed.urlParams, "authSource=admin");
+  assert.equal(parsed.useMongoUrl, true);
+});
+
+test("rejects unsupported URL schemes", () => {
+  assert.throws(() => parseConnectionUrl("ftp://example.com"), /Unsupported connection URL scheme/);
+});
diff --git a/packages/app-tests/connectionVisibleDatabases.test.ts b/packages/app-tests/connectionVisibleDatabases.test.ts
new file mode 100644
index 0000000..f869f52
--- /dev/null
+++ b/packages/app-tests/connectionVisibleDatabases.test.ts
@@ -0,0 +1,104 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { appendVisibleDatabaseSelection, buildDraftVisibleDatabasesConnectionId, connectionCanChooseVisibleDatabases, visibleDatabaseSelectionIsStale, initialVisibleDatabaseSelection } from "../../apps/desktop/src/lib/connection/connectionVisibleDatabases.ts";
+import { connectionUsesVisibleSchemaFilter, filterDatabaseNamesForConnection, filterDatabaseNamesForVisiblePicker } from "../../apps/desktop/src/lib/database/visibleDatabases.ts";
+import type { ConnectionConfig } from "../../apps/desktop/src/types/database.ts";
+
+function config(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
+  return {
+    id: "conn",
+    name: "Local",
+    db_type: "mysql",
+    driver_profile: "mysql",
+    host: "127.0.0.1",
+    port: 3306,
+    username: "root",
+    password: "",
+    database: undefined,
+    visible_databases: undefined,
+    transport_layers: [],
+    connect_timeout_secs: 5,
+    query_timeout_secs: 30,
+    idle_timeout_secs: 60,
+    ssl: false,
+    ca_cert_path: "",
+    client_cert_path: "",
+    client_key_path: "",
+    sysdba: false,
+    jdbc_driver_paths: [],
+    redis_sentinel_master: "",
+    redis_sentinel_nodes: "",
+    redis_sentinel_username: "",
+    redis_sentinel_password: "",
+    redis_sentinel_tls: false,
+    redis_cluster_nodes: "",
+    etcd_endpoints: "",
+    ...overrides,
+  };
+}
+
+test("draft visible database connection ids are namespaced", () => {
+  assert.equal(buildDraftVisibleDatabasesConnectionId("abc"), "__visible_draft_abc");
+});
+
+test("initial selection uses configured visible databases when available", () => {
+  assert.deepEqual(initialVisibleDatabaseSelection(["app", "analytics", "billing"], ["billing", "missing"]), ["billing"]);
+});
+
+test("initial selection uses default visible database names when no filter is configured", () => {
+  assert.deepEqual(initialVisibleDatabaseSelection(["app", "mysql", "sys"], undefined, config()), ["app"]);
+});
+
+test("visible database picker ignores saved filters while keeping default system database hiding", () => {
+  const databaseNames = ["app", "analytics", "mysql", "sys"];
+  const connection = config({ visible_databases: ["app"] });
+  assert.deepEqual(filterDatabaseNamesForVisiblePicker(databaseNames, connection), ["app", "analytics"]);
+  assert.deepEqual(initialVisibleDatabaseSelection(databaseNames, connection.visible_databases, connection), ["app"]);
+});
+
+test("Redis visible database picker keeps every database and initial selection uses saved filters", () => {
+  const databaseNames = ["0", "1", "2"];
+  const connection = config({ db_type: "redis", driver_profile: "redis", visible_databases: ["0"] });
+  assert.deepEqual(filterDatabaseNamesForVisiblePicker(databaseNames, connection), ["0", "1", "2"]);
+  assert.deepEqual(initialVisibleDatabaseSelection(databaseNames, connection.visible_databases, connection), ["0"]);
+});
+
+test("connection database filtering still applies saved visible database filters for sidebar display", () => {
+  assert.deepEqual(filterDatabaseNamesForConnection(["app", "analytics", "mysql", "sys"], config({ visible_databases: ["app"] })), ["app"]);
+});
+
+test("append visible database selection only when filter is enabled", () => {
+  assert.deepEqual(appendVisibleDatabaseSelection(["app"], "analytics"), ["app", "analytics"]);
+  assert.deepEqual(appendVisibleDatabaseSelection(["app", "analytics"], "analytics"), ["app", "analytics"]);
+  assert.equal(appendVisibleDatabaseSelection(undefined, "analytics"), undefined);
+});
+
+test("append visible database selection trims new database names and ignores empty names", () => {
+  assert.deepEqual(appendVisibleDatabaseSelection(["app"], " analytics "), ["app", "analytics"]);
+  assert.deepEqual(appendVisibleDatabaseSelection(["app"], "   "), ["app"]);
+});
+
+test("ZooKeeper connections do not offer visible database selection", () => {
+  assert.equal(connectionCanChooseVisibleDatabases(config({ db_type: "zookeeper" })), false);
+});
+
+test("Cloudflare D1 does not offer a visible database filter for its fixed main namespace", () => {
+  assert.equal(connectionCanChooseVisibleDatabases(config({ db_type: "cloudflare-d1" })), false);
+});
+
+test("OceanBase Oracle uses schema filtering for visible object selection", () => {
+  assert.equal(connectionUsesVisibleSchemaFilter(config({ db_type: "oceanbase-oracle" })), true);
+  assert.equal(connectionUsesVisibleSchemaFilter(config({ db_type: "mysql", driver_profile: "oceanbase" })), false);
+});
+
+test("Dameng default SYSDBA user remains selectable", () => {
+  assert.deepEqual(filterDatabaseNamesForConnection(["SYS", "SYSDBA", "SYSAUDITOR"], config({ db_type: "dameng" })), ["SYSDBA"]);
+});
+
+test("visible database selection is stale when connection target changes", () => {
+  const previous = config({ host: "db.internal", visible_databases: ["app"] });
+  assert.equal(visibleDatabaseSelectionIsStale(previous, config({ host: "db.internal" })), false);
+  assert.equal(visibleDatabaseSelectionIsStale(previous, config({ host: "db2.internal" })), true);
+  assert.equal(visibleDatabaseSelectionIsStale(previous, config({ username: "readonly" })), true);
+  assert.equal(visibleDatabaseSelectionIsStale(previous, config({ database: "admin" })), true);
+});
diff --git a/packages/app-tests/dataGenerate.test.ts b/packages/app-tests/dataGenerate.test.ts
new file mode 100644
index 0000000..3334f88
--- /dev/null
+++ b/packages/app-tests/dataGenerate.test.ts
@@ -0,0 +1,100 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { defaultGeneratorParams, displayGeneratedValue, generateTableData, generateValue } from "../../apps/desktop/src/lib/dataGrid/dataGenerate.ts";
+
+test("enables default values for columns with schema defaults", () => {
+  const params = defaultGeneratorParams(
+    "status",
+    {
+      dataType: "varchar(16)",
+      columnDefault: "active",
+    },
+    "text",
+  );
+
+  assert.equal(params.includeDefault, true);
+  assert.equal(params.defaultPercent, 100);
+});
+
+test("uses string column defaults instead of random generated values", () => {
+  const result = generateTableData(
+    {
+      tableName: "users",
+      schema: "public",
+      database: "app",
+      rowCount: 2,
+      columns: [
+        {
+          columnName: "status",
+          dataType: "varchar(16)",
+          rowCount: 2,
+          generatorKey: "text",
+          generatorParams: { includeDefault: true, defaultPercent: 100 },
+          columnDefault: "active",
+        },
+      ],
+    },
+    "postgres",
+  );
+
+  assert.deepEqual(result.rows, [["active"], ["active"]]);
+  assert.match(result.sql, /VALUES\n\('active'\),\n\('active'\);$/);
+});
+
+test("unwraps quoted and casted PostgreSQL default literals", () => {
+  const result = generateTableData(
+    {
+      tableName: "users",
+      schema: "public",
+      database: "app",
+      rowCount: 1,
+      columns: [
+        {
+          columnName: "role",
+          dataType: "text",
+          rowCount: 1,
+          generatorKey: "text",
+          generatorParams: { includeDefault: true, defaultPercent: 100 },
+          columnDefault: "'guest'::text",
+        },
+      ],
+    },
+    "postgres",
+  );
+
+  assert.deepEqual(result.rows, [["guest"]]);
+  assert.match(result.sql, /VALUES\n\('guest'\);$/);
+});
+
+test("keeps expression defaults as raw SQL", () => {
+  const result = generateTableData(
+    {
+      tableName: "events",
+      schema: "public",
+      database: "app",
+      rowCount: 2,
+      columns: [
+        {
+          columnName: "created_at",
+          dataType: "timestamp",
+          rowCount: 2,
+          generatorKey: "datetime",
+          generatorParams: { includeDefault: true, defaultPercent: 100 },
+          columnDefault: "CURRENT_TIMESTAMP",
+        },
+      ],
+    },
+    "postgres",
+  );
+
+  assert.equal(displayGeneratedValue(result.rows[0][0]), "CURRENT_TIMESTAMP");
+  assert.match(result.sql, /VALUES\n\(CURRENT_TIMESTAMP\),\n\(CURRENT_TIMESTAMP\);$/);
+  assert.doesNotMatch(result.sql, /'CURRENT_TIMESTAMP'/);
+});
+
+test("includeDefault without a schema default no longer emits NULL", () => {
+  const value = generateValue("name", "varchar(32)", "text", 0, { includeDefault: true, defaultPercent: 100 });
+
+  assert.notEqual(value, null);
+  assert.notEqual(value, undefined);
+});
diff --git a/packages/app-tests/dataGridCellCoercion.mysql-json.test.ts b/packages/app-tests/dataGridCellCoercion.mysql-json.test.ts
new file mode 100644
index 0000000..87e3201
--- /dev/null
+++ b/packages/app-tests/dataGridCellCoercion.mysql-json.test.ts
@@ -0,0 +1,59 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { coerceDataGridCellValue } from "../../apps/desktop/src/lib/dataGrid/dataGridCellCoercion.ts";
+
+test("MySQL JSON field with English quotes should remain unchanged", () => {
+  const input = '{"2:3":"3:4","3:2":"4:3","21:9":"16:9"}';
+  const result = coerceDataGridCellValue({
+    value: input,
+    oldValue: null,
+    databaseType: "mysql",
+    columnInfo: { data_type: "json" },
+  });
+
+  assert.equal(result, input);
+  assert.ok(result.includes('"'), "Should contain English quotes");
+  assert.ok(!result.includes('“') && !result.includes('”'), "Should NOT contain Chinese quotes");
+});
+
+test("MySQL JSON field with Chinese quotes should be normalized to English quotes", () => {
+  const input = "{\u201c2:3\u201d:\u201c3:4\u201d,\u201c3:2\u201d:\u201c4:3\u201d,\u201c21:9\u201d:\u201c16:9\u201d}";
+  const expected = '{"2:3":"3:4","3:2":"4:3","21:9":"16:9"}';
+
+  const result = coerceDataGridCellValue({
+    value: input,
+    oldValue: null,
+    databaseType: "mysql",
+    columnInfo: { data_type: "json" },
+  });
+
+  assert.equal(result, expected);
+  assert.ok(result.includes('"'), "Should contain English quotes");
+  assert.ok(!result.includes('“') && !result.includes('”'), "Should NOT contain Chinese quotes");
+});
+
+test("MySQL JSON field with mixed quotes should be normalized", () => {
+  const input = "{\u201ckey\u201d:\"value\"}";
+  const expected = '{"key":"value"}';
+
+  const result = coerceDataGridCellValue({
+    value: input,
+    oldValue: null,
+    databaseType: "mysql",
+    columnInfo: { data_type: "json" },
+  });
+
+  assert.equal(result, expected);
+});
+
+test("MySQL JSON field with smart apostrophe inside a string should remain unchanged", () => {
+  const input = '{"text":"it\u2019s ok"}';
+  const result = coerceDataGridCellValue({
+    value: input,
+    oldValue: null,
+    databaseType: "mysql",
+    columnInfo: { data_type: "json" },
+  });
+
+  assert.equal(result, input);
+});
diff --git a/packages/app-tests/dataGridCellCoercion.test.ts b/packages/app-tests/dataGridCellCoercion.test.ts
new file mode 100644
index 0000000..3cd783e
--- /dev/null
+++ b/packages/app-tests/dataGridCellCoercion.test.ts
@@ -0,0 +1,194 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { coerceDataGridCellValue, dataGridCellDisplayText, dataGridCellEditorText } from "../../apps/desktop/src/lib/dataGrid/dataGridCellCoercion.ts";
+
+test("formats Postgres array cells with native brace syntax", () => {
+  const columnInfo = { data_type: "_text" };
+
+  assert.equal(
+    dataGridCellDisplayText({
+      value: ["draft", "发布", "needs space"],
+      databaseType: "postgres",
+      columnInfo,
+    }),
+    '{draft,发布,"needs space"}',
+  );
+  assert.equal(
+    dataGridCellEditorText({
+      value: ["draft", "发布", "needs space"],
+      databaseType: "postgres",
+      columnInfo,
+    }),
+    '{draft,发布,"needs space"}',
+  );
+});
+
+test("coerces JSON style input for Postgres array columns", () => {
+  assert.deepEqual(
+    coerceDataGridCellValue({
+      value: `["draft","发布"]`,
+      oldValue: "{legacy}",
+      databaseType: "postgres",
+      columnInfo: { data_type: "_text" },
+    }),
+    ["draft", "发布"],
+  );
+});
+
+test("coerces PG brace-style input for Postgres array columns", () => {
+  assert.deepEqual(
+    coerceDataGridCellValue({
+      value: "{1,2,3}",
+      oldValue: [1, 2, 3],
+      databaseType: "postgres",
+      columnInfo: { data_type: "_int4" },
+    }),
+    [1, 2, 3],
+  );
+});
+
+test("preserves high precision numeric edits as text", () => {
+  assert.equal(
+    coerceDataGridCellValue({
+      value: "144847503924137986",
+      oldValue: 142189065666650,
+      databaseType: "sqlserver",
+      columnInfo: { data_type: "bigint" },
+    }),
+    "144847503924137986",
+  );
+
+  assert.equal(
+    coerceDataGridCellValue({
+      value: "12345678901234567890123456789012345678",
+      oldValue: 1,
+      databaseType: "postgres",
+      columnInfo: { data_type: "numeric(38,0)" },
+    }),
+    "12345678901234567890123456789012345678",
+  );
+});
+
+test("keeps safe numeric edits on the existing number path", () => {
+  assert.equal(
+    coerceDataGridCellValue({
+      value: "42",
+      oldValue: 1,
+      databaseType: "sqlserver",
+      columnInfo: { data_type: "int" },
+    }),
+    42,
+  );
+
+  assert.strictEqual(
+    coerceDataGridCellValue({
+      value: "42",
+      oldValue: 42,
+      databaseType: "sqlserver",
+      columnInfo: { data_type: "bigint" },
+    }),
+    42,
+  );
+});
+
+test("coerces PG brace-style string array", () => {
+  assert.deepEqual(
+    coerceDataGridCellValue({
+      value: `{draft,"needs space",发布}`,
+      oldValue: [],
+      databaseType: "postgres",
+      columnInfo: { data_type: "_text" },
+    }),
+    ["draft", "needs space", "发布"],
+  );
+});
+
+test("preserves high precision numeric tokens in Postgres arrays", () => {
+  assert.deepEqual(
+    coerceDataGridCellValue({
+      value: "{144847503924137986,2}",
+      oldValue: [],
+      databaseType: "postgres",
+      columnInfo: { data_type: "_int8" },
+    }),
+    ["144847503924137986", 2],
+  );
+});
+
+test("coerces PG brace-style array with NULL", () => {
+  assert.deepEqual(
+    coerceDataGridCellValue({
+      value: "{1,NULL,3}",
+      oldValue: [],
+      databaseType: "postgres",
+      columnInfo: { data_type: "_int4" },
+    }),
+    [1, null, 3],
+  );
+});
+
+test("coerces empty PG brace-style array", () => {
+  assert.deepEqual(
+    coerceDataGridCellValue({
+      value: "{}",
+      oldValue: [],
+      databaseType: "postgres",
+      columnInfo: { data_type: "_int4" },
+    }),
+    [],
+  );
+});
+
+test("PG array round-trip: format -> coerce -> same values", () => {
+  const original = ["draft", "发布", "needs space"];
+  const columnInfo = { data_type: "_text" };
+
+  const formatted = dataGridCellEditorText({
+    value: original,
+    databaseType: "postgres",
+    columnInfo,
+  });
+
+  const coerced = coerceDataGridCellValue({
+    value: formatted,
+    oldValue: undefined,
+    databaseType: "postgres",
+    columnInfo,
+  });
+
+  assert.deepEqual(coerced as string[], original);
+});
+
+test("unchanged PG array value returns oldValue reference to avoid false dirty", () => {
+  const oldValue = [1, 2, 3];
+
+  const formatted = dataGridCellEditorText({
+    value: oldValue,
+    databaseType: "postgres",
+    columnInfo: { data_type: "_int4" },
+  });
+
+  const result = coerceDataGridCellValue({
+    value: formatted,
+    oldValue,
+    databaseType: "postgres",
+    columnInfo: { data_type: "_int4" },
+  });
+
+  assert.strictEqual(result, oldValue);
+});
+
+test("changed PG array value returns new array reference", () => {
+  const oldValue = [1, 2, 3];
+  const newText = "{1,2,3,4}";
+
+  const result = coerceDataGridCellValue({
+    value: newText,
+    oldValue,
+    databaseType: "postgres",
+    columnInfo: { data_type: "_int4" },
+  });
+
+  assert.notStrictEqual(result, oldValue);
+  assert.deepEqual(result, [1, 2, 3, 4]);
+});
diff --git a/packages/app-tests/dataGridColumnFilter.test.ts b/packages/app-tests/dataGridColumnFilter.test.ts
new file mode 100644
index 0000000..2aea023
--- /dev/null
+++ b/packages/app-tests/dataGridColumnFilter.test.ts
@@ -0,0 +1,76 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { appendColumnValueFilterCondition, buildColumnValueFilterCondition, buildColumnValuesFilterCondition } from "../../apps/desktop/src/lib/dataGrid/dataGridColumnFilter.ts";
+
+function installFilterFetchMock() {
+  globalThis.fetch = (async (input, init) => {
+    if (String(input) === "/api/query/build-data-grid-column-values-filter-condition") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      const options = body.options;
+      const quote = options.databaseType === "mysql" ? (name: string) => `\`${name}\`` : options.databaseType === "sqlserver" ? (name: string) => `[${name}]` : (name: string) => `"${name}"`;
+      const values = options.values ?? [];
+      const nonNull = values.filter((value: unknown) => value !== null);
+      const nullClause = values.some((value: unknown) => value === null) ? `${quote(options.columnName)} IS NULL` : "";
+      const valueClause = nonNull.length ? `${quote(options.columnName)} IN (${nonNull.map((value: unknown) => (typeof value === "number" ? value : `'${value}'`)).join(", ")})` : "";
+      const result = [nullClause, valueClause].filter(Boolean).join(" OR ");
+      return new Response(JSON.stringify(result ? `(${result})` : null), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (String(input) !== "/api/query/build-data-grid-column-value-filter-condition") {
+      return new Response("unexpected request", { status: 500 });
+    }
+    const body = JSON.parse(String(init?.body ?? "{}"));
+    const options = body.options;
+    const quote = options.databaseType === "mysql" ? (name: string) => `\`${name}\`` : options.databaseType === "sqlserver" ? (name: string) => `[${name}]` : (name: string) => `"${name}"`;
+    const text = String(options.rawValue ?? "").trim();
+    const result = /^null$/i.test(text) ? `${quote(options.columnName)} IS NULL` : `${quote(options.columnName)} = ${/^\d+$/.test(text) ? text : `'${text}'`}`;
+    return new Response(JSON.stringify(result), { status: 200, headers: { "Content-Type": "application/json" } });
+  }) as typeof fetch;
+}
+
+test("builds a numeric server-side column filter from typed text", async () => {
+  installFilterFetchMock();
+  const condition = await buildColumnValueFilterCondition({
+    databaseType: "mysql",
+    columnName: "id",
+    columnInfo: { name: "id", data_type: "int", is_nullable: false, is_primary_key: true },
+    rawValue: "49436",
+  });
+
+  assert.equal(condition, "`id` = 49436");
+});
+
+test("quotes text server-side column filters and appends them to existing WHERE input", async () => {
+  installFilterFetchMock();
+  const condition = await buildColumnValueFilterCondition({
+    databaseType: "postgres",
+    columnName: "status",
+    columnInfo: { name: "status", data_type: "varchar", is_nullable: true, is_primary_key: false },
+    rawValue: "active",
+  });
+
+  assert.equal(condition, `"status" = 'active'`);
+  assert.equal(appendColumnValueFilterCondition("deleted_at IS NULL", condition), `(deleted_at IS NULL) AND ("status" = 'active')`);
+});
+
+test("builds IS NULL for typed NULL filters", async () => {
+  installFilterFetchMock();
+  const condition = await buildColumnValueFilterCondition({
+    databaseType: "sqlserver",
+    columnName: "archived_at",
+    rawValue: "NULL",
+  });
+
+  assert.equal(condition, "[archived_at] IS NULL");
+});
+
+test("builds multi-value server-side column filters", async () => {
+  installFilterFetchMock();
+  const condition = await buildColumnValuesFilterCondition({
+    databaseType: "postgres",
+    columnName: "status",
+    columnInfo: { name: "status", data_type: "varchar", is_nullable: true, is_primary_key: false },
+    values: ["active", "pending", null],
+  });
+
+  assert.equal(condition, `("status" IS NULL OR "status" IN ('active', 'pending'))`);
+});
diff --git a/packages/app-tests/dataGridColumnHeaderInteraction.test.ts b/packages/app-tests/dataGridColumnHeaderInteraction.test.ts
new file mode 100644
index 0000000..a958412
--- /dev/null
+++ b/packages/app-tests/dataGridColumnHeaderInteraction.test.ts
@@ -0,0 +1,44 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { columnHeaderCanvasPointerDisabled, columnHeaderClickShouldBeSuppressed, columnHeaderPreviewEnabled, columnHeaderPreviewOffsetForColumn, columnHeaderTooltipDisabled } from "../../apps/desktop/src/lib/dataGrid/dataGridColumnHeaderInteraction";
+
+test("keeps column header tooltips closed during column pointer interactions", () => {
+  assert.equal(columnHeaderTooltipDisabled({ columnDragActive: false, columnResizeActive: false }), false);
+  assert.equal(columnHeaderTooltipDisabled({ columnDragActive: true, columnResizeActive: false }), true);
+  assert.equal(columnHeaderTooltipDisabled({ columnDragActive: false, columnResizeActive: true }), true);
+  assert.equal(columnHeaderTooltipDisabled({ columnDragActive: true, columnResizeActive: true }), true);
+});
+
+test("enables live column header reorder preview while dragging", () => {
+  assert.equal(columnHeaderPreviewEnabled({ columnDragActive: false }), false);
+  assert.equal(columnHeaderPreviewEnabled({ columnDragActive: true }), true);
+});
+
+test("ignores canvas pointer hit testing during column header interactions", () => {
+  assert.equal(columnHeaderCanvasPointerDisabled({ columnDragActive: false, columnResizeActive: false }), false);
+  assert.equal(columnHeaderCanvasPointerDisabled({ columnDragActive: true, columnResizeActive: false }), true);
+  assert.equal(columnHeaderCanvasPointerDisabled({ columnDragActive: false, columnResizeActive: true }), true);
+});
+
+test("suppresses the synthetic click that follows a column header drag", () => {
+  assert.equal(columnHeaderClickShouldBeSuppressed({ now: 1000, guardUntil: 0, suppressNextClick: false }), false);
+  assert.equal(columnHeaderClickShouldBeSuppressed({ now: 1000, guardUntil: 900, suppressNextClick: false }), false);
+  assert.equal(columnHeaderClickShouldBeSuppressed({ now: 1000, guardUntil: 1200, suppressNextClick: false }), true);
+  assert.equal(columnHeaderClickShouldBeSuppressed({ now: 1000, guardUntil: 0, suppressNextClick: true }), true);
+});
+
+test("calculates live reorder preview offsets for dragged and displaced columns", () => {
+  const base = {
+    columnDragActive: true,
+    sourceVisibleIndex: 1,
+    targetVisibleIndex: 3,
+    startX: 100,
+    currentX: 175,
+    sourceWidth: 240,
+  };
+
+  assert.equal(columnHeaderPreviewOffsetForColumn({ ...base, visibleColIdx: 1 }), 75);
+  assert.equal(columnHeaderPreviewOffsetForColumn({ ...base, visibleColIdx: 2 }), -240);
+  assert.equal(columnHeaderPreviewOffsetForColumn({ ...base, visibleColIdx: 3 }), -240);
+  assert.equal(columnHeaderPreviewOffsetForColumn({ ...base, visibleColIdx: 4 }), 0);
+});
diff --git a/packages/app-tests/dataGridColumnOrder.test.ts b/packages/app-tests/dataGridColumnOrder.test.ts
new file mode 100644
index 0000000..b912cf9
--- /dev/null
+++ b/packages/app-tests/dataGridColumnOrder.test.ts
@@ -0,0 +1,99 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { columnOrderKeysForIndexes, isDefaultColumnOrder, moveVisibleColumnIndex, orderedColumnIndexes, uniqueDataGridColumnOrderKeys } from "../../apps/desktop/src/lib/dataGrid/dataGridColumnOrder";
+
+test("creates stable keys for duplicate column names", () => {
+    assert.deepEqual(uniqueDataGridColumnOrderKeys(["id", "name", "name"]), [`id\u00000`, `name\u00000`, `name\u00001`]);
+});
+
+test("uses source columns when available", () => {
+    assert.deepEqual(uniqueDataGridColumnOrderKeys(["id", "display_name"], ["id", "name"]), [`id\u00000`, `name\u00000`]);
+});
+
+test("orders available indexes from persisted keys and appends new columns", () => {
+    const keys = uniqueDataGridColumnOrderKeys(["id", "name", "email", "created_at"]);
+    assert.deepEqual(
+        orderedColumnIndexes({
+            availableIndexes: [0, 1, 2, 3],
+            columnKeys: keys,
+            orderedKeys: [keys[2], keys[0], "missing"],
+        }),
+        [2, 0, 1, 3],
+    );
+});
+
+test("ignores unavailable indexes while preserving displayable columns", () => {
+    const keys = uniqueDataGridColumnOrderKeys(["id", "name", "email"]);
+    assert.deepEqual(
+        orderedColumnIndexes({
+            availableIndexes: [1, 2],
+            columnKeys: keys,
+            orderedKeys: [keys[0], keys[2], keys[1]],
+        }),
+        [2, 1],
+    );
+});
+
+test("moves a visible column forward", () => {
+    assert.deepEqual(
+        moveVisibleColumnIndex({
+            orderedIndexes: [0, 1, 2, 3],
+            hiddenIndexes: new Set(),
+            fromVisibleIndex: 3,
+            toVisibleIndex: 1,
+        }),
+        [0, 3, 1, 2],
+    );
+});
+
+test("moves a visible column backward", () => {
+    assert.deepEqual(
+        moveVisibleColumnIndex({
+            orderedIndexes: [0, 1, 2, 3],
+            hiddenIndexes: new Set(),
+            fromVisibleIndex: 1,
+            toVisibleIndex: 3,
+        }),
+        [0, 2, 3, 1],
+    );
+});
+
+test("moves a visible column to an adjacent later position", () => {
+    assert.deepEqual(
+        moveVisibleColumnIndex({
+            orderedIndexes: [0, 1, 2, 3],
+            hiddenIndexes: new Set(),
+            fromVisibleIndex: 1,
+            toVisibleIndex: 2,
+        }),
+        [0, 2, 1, 3],
+    );
+});
+
+test("moves visible columns without disturbing hidden column identity", () => {
+    assert.deepEqual(
+        moveVisibleColumnIndex({
+            orderedIndexes: [0, 1, 2, 3],
+            hiddenIndexes: new Set([1]),
+            fromVisibleIndex: 2,
+            toVisibleIndex: 0,
+        }),
+        [3, 0, 1, 2],
+    );
+});
+
+test("returns no-op for invalid or same visible indexes", () => {
+    const orderedIndexes = [0, 1, 2];
+    assert.deepEqual(moveVisibleColumnIndex({ orderedIndexes, hiddenIndexes: new Set(), fromVisibleIndex: 1, toVisibleIndex: 1 }), orderedIndexes);
+    assert.deepEqual(moveVisibleColumnIndex({ orderedIndexes, hiddenIndexes: new Set(), fromVisibleIndex: -1, toVisibleIndex: 1 }), orderedIndexes);
+});
+
+test("converts indexes back to persisted keys", () => {
+    const keys = uniqueDataGridColumnOrderKeys(["id", "name", "email"]);
+    assert.deepEqual(columnOrderKeysForIndexes([2, 0, 1], keys), [keys[2], keys[0], keys[1]]);
+});
+
+test("detects default order", () => {
+    assert.equal(isDefaultColumnOrder([0, 1, 2], [0, 1, 2]), true);
+    assert.equal(isDefaultColumnOrder([0, 1, 2], [1, 0, 2]), false);
+});
diff --git a/packages/app-tests/dataGridColumnType.test.ts b/packages/app-tests/dataGridColumnType.test.ts
new file mode 100644
index 0000000..2f128e4
--- /dev/null
+++ b/packages/app-tests/dataGridColumnType.test.ts
@@ -0,0 +1,61 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { compactHeaderColumnType, resolveHeaderColumnType } from "../../apps/desktop/src/lib/dataGrid/dataGridColumnType.ts";
+
+test("prefers table-metadata type over the result type", () => {
+  const type = resolveHeaderColumnType({
+    tableColumnType: "numeric(20,6)",
+    resultColumnTypes: ["int4"],
+    actualColIdx: 0,
+  });
+  assert.equal(type, "numeric(20,6)");
+});
+
+test("falls back to the result type at the column index when no table meta", () => {
+  const type = resolveHeaderColumnType({
+    tableColumnType: undefined,
+    resultColumnTypes: ["oid", "char", "bigint"],
+    actualColIdx: 1,
+  });
+  assert.equal(type, "char");
+});
+
+test("uses actualColIdx (by index), not column order assumptions", () => {
+  // The third result column should resolve to the third type, regardless of
+  // any name-based reordering elsewhere.
+  const type = resolveHeaderColumnType({
+    resultColumnTypes: ["a_type", "b_type", "c_type"],
+    actualColIdx: 2,
+  });
+  assert.equal(type, "c_type");
+});
+
+test("returns undefined when the result type index is out of range", () => {
+  const type = resolveHeaderColumnType({
+    resultColumnTypes: ["int4"],
+    actualColIdx: 5,
+  });
+  assert.equal(type, undefined);
+});
+
+test("returns undefined when neither source has a type", () => {
+  assert.equal(resolveHeaderColumnType({ actualColIdx: 0 }), undefined);
+  assert.equal(resolveHeaderColumnType({ resultColumnTypes: [], actualColIdx: 0 }), undefined);
+});
+
+test("treats blank/whitespace types as absent and falls through", () => {
+  const type = resolveHeaderColumnType({
+    tableColumnType: "   ",
+    resultColumnTypes: ["text"],
+    actualColIdx: 0,
+  });
+  assert.equal(type, "text");
+
+  assert.equal(resolveHeaderColumnType({ tableColumnType: "", resultColumnTypes: [""], actualColIdx: 0 }), undefined);
+});
+
+test("hides MySQL enum values from the compact header type", () => {
+  assert.equal(compactHeaderColumnType("enum('pending','active')"), "enum");
+  assert.equal(compactHeaderColumnType("ENUM('', 'normal')"), "enum");
+  assert.equal(compactHeaderColumnType("varchar(255)"), "varchar(255)");
+});
diff --git a/packages/app-tests/dataGridColumnVisibility.test.ts b/packages/app-tests/dataGridColumnVisibility.test.ts
new file mode 100644
index 0000000..7a3f409
--- /dev/null
+++ b/packages/app-tests/dataGridColumnVisibility.test.ts
@@ -0,0 +1,125 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildDataGridColumnLookupItems, filterDataGridColumnLookupItems } from "../../apps/desktop/src/lib/dataGrid/dataGridColumnLookup.ts";
+import { allNullColumnIndexes, filterColumnVisibilityOptions, hiddenColumnIndexesWithAllNullColumns, invertedHiddenColumnIndexes, nextHiddenColumnIndexes, removeAutoHiddenColumnIndexes, visibleColumnIndexesForFilter } from "../../apps/desktop/src/lib/dataGrid/dataGridColumnVisibility.ts";
+
+test("filters column visibility options by trimmed case-insensitive text", () => {
+  const options = filterColumnVisibilityOptions(["id", "created_at", "CustomerName"], "  NAME ");
+
+  assert.deepEqual(options, [{ column: "CustomerName", index: 2 }]);
+});
+
+test("filters column visibility options by column comments", () => {
+  const options = filterColumnVisibilityOptions(["id", "created_at", "customer_name"], "created time", {
+    commentByColumn: new Map([["created_at", "Created time"]]),
+  });
+
+  assert.deepEqual(options, [{ column: "created_at", comment: "Created time", index: 1 }]);
+});
+
+test("builds go-to column lookup items with source column comments first", () => {
+  const items = buildDataGridColumnLookupItems({
+    columns: ["display_name"],
+    sourceColumns: ["name"],
+    commentByColumn: new Map([
+      ["display_name", "Alias label"],
+      ["name", "Customer name"],
+    ]),
+  });
+
+  assert.deepEqual(items, [{ index: 0, name: "display_name", sourceName: "name", comment: "Customer name" }]);
+});
+
+test("filters go-to column lookup items by source column and comment", () => {
+  const items = buildDataGridColumnLookupItems({
+    columns: ["label", "created_at"],
+    sourceColumns: ["user_name", undefined],
+    commentByColumn: new Map([["user_name", "Customer name"]]),
+  });
+
+  assert.deepEqual(filterDataGridColumnLookupItems(items, "user_name").map((item) => item.index), [0]);
+  assert.deepEqual(filterDataGridColumnLookupItems(items, "customer").map((item) => item.index), [0]);
+});
+
+test("keeps go-to column lookup usable without metadata", () => {
+  const items = buildDataGridColumnLookupItems({ columns: ["id", "display_name"] });
+
+  assert.deepEqual(filterDataGridColumnLookupItems(items, "display"), [{ index: 1, name: "display_name" }]);
+});
+
+test("removes hidden indexes from visible columns", () => {
+  const indexes = visibleColumnIndexesForFilter([0, 1, 2, 3], new Set([1, 3]));
+
+  assert.deepEqual(indexes, [0, 2]);
+});
+
+test("keeps the last visible column when toggling visibility", () => {
+  const hidden = nextHiddenColumnIndexes({
+    columnIndex: 0,
+    hiddenIndexes: new Set([1, 2]),
+    totalColumns: 3,
+  });
+
+  assert.deepEqual([...hidden].sort(), [1, 2]);
+});
+
+test("shows a hidden column again when toggled", () => {
+  const hidden = nextHiddenColumnIndexes({
+    columnIndex: 1,
+    hiddenIndexes: new Set([1, 2]),
+    totalColumns: 4,
+  });
+
+  assert.deepEqual([...hidden].sort(), [2]);
+});
+
+test("inverts hidden column indexes", () => {
+  const hidden = invertedHiddenColumnIndexes([0, 1, 2, 3], new Set([1, 3]));
+
+  assert.deepEqual([...hidden].sort(), [0, 2]);
+});
+
+test("keeps one column visible when inverting all visible columns", () => {
+  const hidden = invertedHiddenColumnIndexes([0, 1, 2], new Set());
+
+  assert.deepEqual([...hidden].sort(), [1, 2]);
+});
+
+test("finds columns where every row is NULL", () => {
+  const indexes = allNullColumnIndexes(
+    [
+      [1, null, null, "x"],
+      [2, null, null, null],
+    ],
+    [0, 1, 2, 3],
+  );
+
+  assert.deepEqual(indexes, [1, 2]);
+});
+
+test("does not treat empty results as all-null columns", () => {
+  assert.deepEqual(allNullColumnIndexes([], [0, 1, 2]), []);
+});
+
+test("hides all-null columns without restoring manually hidden columns", () => {
+  const result = hiddenColumnIndexesWithAllNullColumns({
+    availableIndexes: [0, 1, 2, 3],
+    hiddenIndexes: new Set([3]),
+    allNullIndexes: new Set([1, 2, 3]),
+  });
+
+  assert.deepEqual([...result.hiddenIndexes].sort(), [1, 2, 3]);
+  assert.deepEqual([...result.autoHiddenIndexes].sort(), [1, 2]);
+  assert.deepEqual([...removeAutoHiddenColumnIndexes(result.hiddenIndexes, result.autoHiddenIndexes)].sort(), [3]);
+});
+
+test("keeps one all-null column visible when every column is NULL", () => {
+  const result = hiddenColumnIndexesWithAllNullColumns({
+    availableIndexes: [0, 1, 2],
+    hiddenIndexes: new Set(),
+    allNullIndexes: new Set([0, 1, 2]),
+  });
+
+  assert.deepEqual([...result.hiddenIndexes].sort(), [1, 2]);
+  assert.deepEqual([...result.autoHiddenIndexes].sort(), [1, 2]);
+});
diff --git a/packages/app-tests/dataGridColumnWidth.test.ts b/packages/app-tests/dataGridColumnWidth.test.ts
new file mode 100644
index 0000000..7eceb4a
--- /dev/null
+++ b/packages/app-tests/dataGridColumnWidth.test.ts
@@ -0,0 +1,33 @@
+import { expect, test } from "vitest";
+import { calculateDataGridColumnWidth, DATA_GRID_AUTO_FIT_VALUE_TEXT_LIMIT, DATA_GRID_COL_AUTO_FIT_MAX_WIDTH, DATA_GRID_COL_MAX_WIDTH } from "../../apps/desktop/src/lib/dataGrid/dataGridColumnWidth.ts";
+
+test("default data grid column width remains compact for long values", () => {
+  const width = calculateDataGridColumnWidth({
+    columnName: "description",
+    sampleValues: ["x".repeat(120)],
+  });
+
+  expect(width).toBe(DATA_GRID_COL_MAX_WIDTH);
+});
+
+test("auto-fit data grid column width expands long values beyond default width", () => {
+  const width = calculateDataGridColumnWidth({
+    columnName: "description",
+    sampleValues: ["x".repeat(120)],
+    maxWidth: DATA_GRID_COL_AUTO_FIT_MAX_WIDTH,
+    valueTextLimit: DATA_GRID_AUTO_FIT_VALUE_TEXT_LIMIT,
+  });
+
+  expect(width).toBeGreaterThan(DATA_GRID_COL_MAX_WIDTH);
+});
+
+test("auto-fit data grid column width stays bounded for very long values", () => {
+  const width = calculateDataGridColumnWidth({
+    columnName: "description",
+    sampleValues: ["x".repeat(1000)],
+    maxWidth: DATA_GRID_COL_AUTO_FIT_MAX_WIDTH,
+    valueTextLimit: DATA_GRID_AUTO_FIT_VALUE_TEXT_LIMIT,
+  });
+
+  expect(width).toBe(DATA_GRID_COL_AUTO_FIT_MAX_WIDTH);
+});
diff --git a/packages/app-tests/dataGridConditionHistory.test.ts b/packages/app-tests/dataGridConditionHistory.test.ts
new file mode 100644
index 0000000..dfcf96a
--- /dev/null
+++ b/packages/app-tests/dataGridConditionHistory.test.ts
@@ -0,0 +1,70 @@
+import { strict as assert } from "node:assert";
+import { beforeEach, test } from "vitest";
+import { forgetDataGridConditionHistory, loadDataGridConditionHistory, rememberDataGridConditionHistory } from "../../apps/desktop/src/lib/dataGrid/dataGridConditionHistory.ts";
+
+class MemoryStorage {
+  private values = new Map<string, string>();
+
+  getItem(key: string) {
+    return this.values.get(key) ?? null;
+  }
+
+  setItem(key: string, value: string) {
+    this.values.set(key, value);
+  }
+
+  removeItem(key: string) {
+    this.values.delete(key);
+  }
+}
+
+beforeEach(() => {
+  Object.defineProperty(globalThis, "localStorage", {
+    value: new MemoryStorage(),
+    configurable: true,
+  });
+});
+
+test("remembers table-scoped WHERE history with newest entries first", () => {
+  const scope = { connectionId: "c1", database: "app", schema: "public", tableName: "users" };
+
+  rememberDataGridConditionHistory("where", scope, "status = 'active'");
+  rememberDataGridConditionHistory("where", scope, "created_at > '2026-01-01'");
+  rememberDataGridConditionHistory("where", scope, "status = 'active'");
+
+  assert.deepEqual(loadDataGridConditionHistory("where", scope), ["status = 'active'", "created_at > '2026-01-01'"]);
+});
+
+test("keeps WHERE and ORDER BY histories separate", () => {
+  const scope = { connectionId: "c1", database: "app", schema: "public", tableName: "users" };
+
+  rememberDataGridConditionHistory("where", scope, "status = 'active'");
+  rememberDataGridConditionHistory("orderBy", scope, "created_at DESC");
+
+  assert.deepEqual(loadDataGridConditionHistory("where", scope), ["status = 'active'"]);
+  assert.deepEqual(loadDataGridConditionHistory("orderBy", scope), ["created_at DESC"]);
+});
+
+test("filters history by partial input and isolates different tables", () => {
+  const users = { connectionId: "c1", database: "app", schema: "public", tableName: "users" };
+  const orders = { connectionId: "c1", database: "app", schema: "public", tableName: "orders" };
+
+  rememberDataGridConditionHistory("where", users, "status = 'active'");
+  rememberDataGridConditionHistory("where", users, "email LIKE '%@example.com'");
+  rememberDataGridConditionHistory("where", orders, "status = 'paid'");
+
+  assert.deepEqual(loadDataGridConditionHistory("where", users, "email"), ["email LIKE '%@example.com'"]);
+  assert.deepEqual(loadDataGridConditionHistory("where", orders), ["status = 'paid'"]);
+});
+
+test("forgets a single condition without clearing other scoped history", () => {
+  const scope = { connectionId: "c1", database: "app", schema: "public", tableName: "users" };
+
+  rememberDataGridConditionHistory("where", scope, "status = 'active'");
+  rememberDataGridConditionHistory("where", scope, "email LIKE '%@example.com'");
+  rememberDataGridConditionHistory("orderBy", scope, "created_at DESC");
+
+  assert.deepEqual(forgetDataGridConditionHistory("where", scope, "status = 'active'"), ["email LIKE '%@example.com'"]);
+  assert.deepEqual(loadDataGridConditionHistory("where", scope), ["email LIKE '%@example.com'"]);
+  assert.deepEqual(loadDataGridConditionHistory("orderBy", scope), ["created_at DESC"]);
+});
diff --git a/packages/app-tests/dataGridDetail.test.ts b/packages/app-tests/dataGridDetail.test.ts
new file mode 100644
index 0000000..a143250
--- /dev/null
+++ b/packages/app-tests/dataGridDetail.test.ts
@@ -0,0 +1,319 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+
+import { buildDataGridCellDetail, buildDataGridColumnDetail, dataGridColumnDetailJson, dataGridColumnDetailTsv, buildDataGridRowDetail, dataGridRowDetailJson, dataGridRowDetailTsv, filterDataGridDetailFields, type DataGridCellDetail } from "../../apps/desktop/src/lib/dataGrid/dataGridDetail.ts";
+import type { CellValue } from "../../apps/desktop/src/lib/dataGrid/cellValue.ts";
+
+test("buildDataGridCellDetail returns null for an invalid column", () => {
+  const detail = buildDataGridCellDetail({
+    rowIndex: 0,
+    rowId: 10,
+    row: ["Ada"],
+    columns: ["name"],
+    columnIndex: 2,
+    displayValue: (value) => String(value),
+    isEditable: false,
+  });
+
+  assert.equal(detail, null);
+});
+
+test("buildDataGridCellDetail preserves full value metadata", () => {
+  const typeByColumn = new Map([["payload", "jsonb"]]);
+  const commentByColumn = new Map([["payload", "raw event payload"]]);
+  const detail = buildDataGridCellDetail({
+    rowIndex: 2,
+    rowId: 42,
+    row: [7, '{"ok":true,"items":[1,2]}'],
+    columns: ["id", "payload"],
+    columnIndex: 1,
+    typeByColumn,
+    commentByColumn,
+    displayValue: (value) => `formatted:${String(value).slice(0, 8)}`,
+    isEditable: true,
+  });
+
+  assert.deepEqual(detail, {
+    rowNumber: 3,
+    rowId: 42,
+    colIndex: 1,
+    column: "payload",
+    type: "jsonb",
+    comment: "raw event payload",
+    value: '{"ok":true,"items":[1,2]}',
+    rawValue: '{"ok":true,"items":[1,2]}',
+    rawValuePreview: '{"ok":true,"items":[1,2]}',
+    displayValue: 'formatted:{"ok":tr',
+    displayValuePreview: 'formatted:{"ok":tr',
+    isValuePreviewTruncated: false,
+    imagePreviewUrl: null,
+    length: 25,
+    formattedJson: '{\n  "ok": true,\n  "items": [\n    1,\n    2\n  ]\n}',
+    isEditable: true,
+  });
+});
+
+test("buildDataGridCellDetail reports image preview URLs", () => {
+  const detail = buildDataGridCellDetail({
+    rowIndex: 0,
+    rowId: 1,
+    row: ["https://example.com/avatar.png"],
+    columns: ["avatar"],
+    columnIndex: 0,
+    displayValue: (value) => String(value),
+    isEditable: false,
+  });
+
+  assert.equal(detail?.imagePreviewUrl, "https://example.com/avatar.png");
+});
+
+test("buildDataGridCellDetail reports binary image preview URLs", () => {
+  const detail = buildDataGridCellDetail({
+    rowIndex: 0,
+    rowId: 1,
+    row: ["0x89504e470d0a1a0a0000000d49484452"],
+    columns: ["avatar"],
+    columnIndex: 0,
+    typeByColumn: new Map([["avatar", "longblob"]]),
+    displayValue: (value) => String(value),
+    isEditable: false,
+  });
+
+  assert.match(detail?.imagePreviewUrl ?? "", /^data:image\/png;base64,/);
+});
+
+test("buildDataGridCellDetail uses result column types for query results", () => {
+  const detail = buildDataGridCellDetail({
+    rowIndex: 0,
+    rowId: 1,
+    row: [30001, "0x89504e470d0a1a0a0000000d49484452"],
+    columns: ["id", "image_data"],
+    columnIndex: 1,
+    resultColumnTypes: ["bigint", "longblob"],
+    displayValue: (value) => String(value),
+    isEditable: false,
+  });
+
+  assert.equal(detail?.type, "longblob");
+  assert.match(detail?.imagePreviewUrl ?? "", /^data:image\/png;base64,/);
+});
+
+test("aggregate details defer binary image preview generation", () => {
+  const rowDetail = buildDataGridRowDetail({
+    rowIndex: 0,
+    rowId: 1,
+    row: ["0x89504e470d0a1a0a0000000d49484452"],
+    columns: ["avatar"],
+    columnIndexes: [0],
+    resultColumnTypes: ["longblob"],
+    displayValue: (value) => String(value),
+  });
+  const columnDetail = buildDataGridColumnDetail({
+    rows: [{ rowIndex: 0, rowId: 1, row: ["0x89504e470d0a1a0a0000000d49484452"] }],
+    columns: ["avatar"],
+    columnIndex: 0,
+    resultColumnTypes: ["longblob"],
+    displayValue: (value) => String(value),
+  });
+
+  assert.equal(rowDetail.fields[0]?.type, "longblob");
+  assert.equal(rowDetail.fields[0]?.imagePreviewUrl, null);
+  assert.equal(columnDetail?.fields[0]?.type, "longblob");
+  assert.equal(columnDetail?.fields[0]?.imagePreviewUrl, null);
+});
+
+test("buildDataGridCellDetail limits rendered previews for huge text values", () => {
+  const hugeJson = `{"body":"${"x".repeat(120_000)}"}`;
+  const detail = buildDataGridCellDetail({
+    rowIndex: 0,
+    rowId: 1,
+    row: [hugeJson],
+    columns: ["payload"],
+    columnIndex: 0,
+    typeByColumn: new Map([["payload", "nvarchar(max)"]]),
+    displayValue: (value) => String(value),
+    isEditable: false,
+  });
+
+  assert.ok(detail);
+  assert.equal(detail.rawValue, hugeJson);
+  assert.equal(detail.rawValuePreview.length, 12_000);
+  assert.equal(detail.displayValuePreview.length, 12_000);
+  assert.equal(detail.isValuePreviewTruncated, true);
+  assert.equal(detail.formattedJson, "");
+});
+
+test("buildDataGridRowDetail maps requested column indexes in order", () => {
+  const row: CellValue[] = ["Ada", null, true];
+  const detail = buildDataGridRowDetail({
+    rowIndex: 4,
+    rowId: 99,
+    row,
+    columns: ["name", "nickname", "active"],
+    columnIndexes: [2, 0, 1],
+    displayValue: (value) => (value === null ? "NULL" : String(value)),
+    isEditableColumn: (columnIndex) => columnIndex !== 2,
+  });
+
+  assert.equal(detail.rowNumber, 5);
+  assert.equal(detail.rowId, 99);
+  assert.deepEqual(
+    detail.fields.map((field) => ({
+      column: field.column,
+      colIndex: field.colIndex,
+      rawValue: field.rawValue,
+      isEditable: field.isEditable,
+    })),
+    [
+      { column: "active", colIndex: 2, rawValue: "true", isEditable: false },
+      { column: "name", colIndex: 0, rawValue: "Ada", isEditable: true },
+      { column: "nickname", colIndex: 1, rawValue: "NULL", isEditable: true },
+    ],
+  );
+});
+
+test("buildDataGridRowDetail keeps duplicate columns as separate fields", () => {
+  const detail = buildDataGridRowDetail({
+    rowIndex: 0,
+    rowId: 1,
+    row: ["first", "second"],
+    columns: ["name", "name"],
+    columnIndexes: [0, 1],
+    displayValue: (value) => String(value),
+  });
+
+  assert.deepEqual(
+    detail.fields.map((field) => [field.colIndex, field.column, field.rawValue]),
+    [
+      [0, "name", "first"],
+      [1, "name", "second"],
+    ],
+  );
+});
+
+test("dataGridRowDetailJson and dataGridRowDetailTsv format copy payloads", () => {
+  const detail = buildDataGridRowDetail({
+    rowIndex: 0,
+    rowId: 1,
+    row: [1, "Ada", null],
+    columns: ["id", "name", "nickname"],
+    columnIndexes: [0, 1, 2],
+    displayValue: (value) => (value === null ? "NULL" : String(value)),
+  });
+
+  assert.equal(dataGridRowDetailJson(detail), '{\n  "id": 1,\n  "name": "Ada",\n  "nickname": null\n}');
+  assert.equal(dataGridRowDetailTsv(detail), "1\tAda\tNULL");
+});
+
+test("buildDataGridColumnDetail maps a whole column across rows", () => {
+  const typeByColumn = new Map([["name", "varchar"]]);
+  const commentByColumn = new Map([["name", "display name"]]);
+  const detail = buildDataGridColumnDetail({
+    rows: [
+      { rowIndex: 0, rowId: 10, row: [1, "Ada"], isEditable: true },
+      { rowIndex: 3, rowId: 13, row: [4, null], isEditable: false },
+    ],
+    columns: ["id", "name"],
+    columnIndex: 1,
+    typeByColumn,
+    commentByColumn,
+    displayValue: (value) => (value === null ? "NULL" : String(value)),
+  });
+
+  assert.equal(detail?.column, "name");
+  assert.equal(detail?.type, "varchar");
+  assert.equal(detail?.comment, "display name");
+  assert.deepEqual(
+    detail?.fields.map((field) => ({
+      rowNumber: field.rowNumber,
+      rowId: field.rowId,
+      rawValue: field.rawValue,
+      isEditable: field.isEditable,
+    })),
+    [
+      { rowNumber: 1, rowId: 10, rawValue: "Ada", isEditable: true },
+      { rowNumber: 4, rowId: 13, rawValue: "NULL", isEditable: false },
+    ],
+  );
+});
+
+test("buildDataGridColumnDetail returns null for an invalid column", () => {
+  const detail = buildDataGridColumnDetail({
+    rows: [{ rowIndex: 0, rowId: 1, row: ["Ada"] }],
+    columns: ["name"],
+    columnIndex: 3,
+    displayValue: (value) => String(value),
+  });
+
+  assert.equal(detail, null);
+});
+
+test("dataGridColumnDetailJson and dataGridColumnDetailTsv format copy payloads", () => {
+  const detail = buildDataGridColumnDetail({
+    rows: [
+      { rowIndex: 0, rowId: 1, row: [1, "Ada"] },
+      { rowIndex: 1, rowId: 2, row: [2, null] },
+    ],
+    columns: ["id", "name"],
+    columnIndex: 1,
+    displayValue: (value) => (value === null ? "NULL" : String(value)),
+  });
+
+  assert.ok(detail);
+  assert.equal(dataGridColumnDetailJson(detail), '[\n  {\n    "row": 1,\n    "value": "Ada"\n  },\n  {\n    "row": 2,\n    "value": null\n  }\n]');
+  assert.equal(dataGridColumnDetailTsv(detail), "Ada\nNULL");
+});
+
+const detailFields: DataGridCellDetail[] = [
+  { rowNumber: 1, column: "id", rawValuePreview: "7", displayValuePreview: "7" } as DataGridCellDetail,
+  { rowNumber: 2, column: "Email", rawValuePreview: "ada@example.com", displayValuePreview: "ada@example.com" } as DataGridCellDetail,
+  { rowNumber: 3, column: "status", rawValuePreview: "ACTIVE", displayValuePreview: "Active" } as DataGridCellDetail,
+];
+
+test("filterDataGridDetailFields returns all fields for an empty keyword", () => {
+  const result = filterDataGridDetailFields(detailFields, "   ");
+
+  assert.deepEqual(result, detailFields);
+  assert.notEqual(result, detailFields);
+});
+
+test("filterDataGridDetailFields matches column names case-insensitively", () => {
+  const result = filterDataGridDetailFields(detailFields, "EMAIL");
+
+  assert.deepEqual(
+    result.map((field) => field.column),
+    ["Email"],
+  );
+});
+
+test("filterDataGridDetailFields matches raw value previews", () => {
+  const result = filterDataGridDetailFields(detailFields, "example.com");
+
+  assert.deepEqual(
+    result.map((field) => field.column),
+    ["Email"],
+  );
+});
+
+test("filterDataGridDetailFields matches row numbers", () => {
+  const result = filterDataGridDetailFields(detailFields, "3");
+
+  assert.deepEqual(
+    result.map((field) => field.rowNumber),
+    [3],
+  );
+});
+
+test("filterDataGridDetailFields returns an empty array when nothing matches", () => {
+  const result = filterDataGridDetailFields(detailFields, "nope");
+
+  assert.deepEqual(result, []);
+});
+
+test("filterDataGridDetailFields does not mutate the input array", () => {
+  const original = [...detailFields];
+  const result = filterDataGridDetailFields(detailFields, "id");
+
+  assert.deepEqual(detailFields, original);
+  assert.notEqual(result, detailFields);
+});
diff --git a/packages/app-tests/dataGridEditor.test.ts b/packages/app-tests/dataGridEditor.test.ts
new file mode 100644
index 0000000..9edda0e
--- /dev/null
+++ b/packages/app-tests/dataGridEditor.test.ts
@@ -0,0 +1,1623 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { computed, nextTick, ref } from "vue";
+import { createPinia, setActivePinia } from "pinia";
+import { DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, useDataGridEditor } from "../../apps/desktop/src/composables/useDataGridEditor.ts";
+import type { CellValue } from "../../apps/desktop/src/lib/dataGrid/cellValue.ts";
+import type { DataGridSaveStatementOptions } from "../../apps/desktop/src/lib/dataGrid/dataGridSql.ts";
+import { matchesRowStatusFilter, type RowStatusFilter } from "../../apps/desktop/src/lib/dataGrid/gridRowStatus.ts";
+import type { ColumnInfo } from "../../apps/desktop/src/types/database.ts";
+
+function installBrowserTestGlobals() {
+  globalThis.document = { querySelector: () => null } as unknown as Document;
+  globalThis.localStorage = {
+    getItem: () => null,
+    setItem: () => {},
+    removeItem: () => {},
+    clear: () => {},
+    key: () => null,
+    length: 0,
+  };
+  globalThis.fetch = (async (input, init) => {
+    if (String(input) === "/api/history/save") {
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (String(input) !== "/api/query/prepare-data-grid-save") return new Response("unexpected request", { status: 500 });
+    const body = JSON.parse(String(init?.body ?? "{}"));
+    const options = body.options as DataGridSaveStatementOptions;
+    return new Response(
+      JSON.stringify({
+        statements: mockPreparedSaveStatements(options),
+        rollbackStatements: [],
+        executionSchema: options.databaseType === "oracle" || options.databaseType === "neo4j" ? undefined : options.tableMeta.schema,
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  }) as typeof fetch;
+}
+
+function mockPreparedSaveStatements(options: DataGridSaveStatementOptions): string[] {
+  const table = options.tableMeta.schema ? `${quotePgIdentifier(options.tableMeta.schema)}.${quotePgIdentifier(options.tableMeta.tableName)}` : quotePgIdentifier(options.tableMeta.tableName);
+  const statements: string[] = [];
+  for (const rowIndex of options.deletedRows) {
+    const row = options.rows[rowIndex];
+    if (!row) continue;
+    statements.push(`DELETE FROM ${table} WHERE ${primaryKeyWhere(options, row)};`);
+  }
+  for (const [rowIndex, changes] of options.dirtyRows) {
+    const row = options.rows[rowIndex];
+    if (!row) continue;
+    const sets = changes.map(([columnIndex, value]) => `${quotePgIdentifier(options.columns[columnIndex])} = ${formatGridSqlLiteral(value, options.databaseType)}`).join(", ");
+    statements.push(`UPDATE ${table} SET ${sets} WHERE ${primaryKeyWhere(options, row)};`);
+  }
+  for (const row of options.newRows) {
+    const columns = options.columns.map(quotePgIdentifier).join(", ");
+    const values = row.map((value) => formatGridSqlLiteral(value, options.databaseType)).join(", ");
+    statements.push(`INSERT INTO ${table} (${columns}) VALUES (${values});`);
+  }
+  return statements;
+}
+
+function primaryKeyWhere(options: DataGridSaveStatementOptions, row: CellValue[]): string {
+  return options.tableMeta.primaryKeys
+    .map((key) => {
+      const index = options.columns.indexOf(key);
+      return `${quotePgIdentifier(key)} = ${formatGridSqlLiteral(row[index], options.databaseType)}`;
+    })
+    .join(" AND ");
+}
+
+function quotePgIdentifier(name: string): string {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+
+function formatGridSqlLiteral(value: CellValue, databaseType?: string): string {
+  if (value === null) return "NULL";
+  if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+  if (typeof value === "number") return String(value);
+  if (Array.isArray(value) && databaseType === "postgres") {
+    return `'${formatPgArrayLiteral(value)}'`;
+  }
+  const escaped = `'${String(value).replace(/\\/g, "\\\\").replace(/'/g, "''")}'`;
+  return databaseType === "sqlserver" ? `N${escaped}` : escaped;
+}
+
+function formatPgArrayLiteral(value: CellValue[]): string {
+  return `{${value
+    .map((item) => {
+      if (Array.isArray(item)) return formatPgArrayLiteral(item);
+      if (item === null) return "NULL";
+      return `"${String(item).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+    })
+    .join(",")}}`;
+}
+
+function column(name: string, isPrimaryKey = false, extra: string | null = null): ColumnInfo {
+  return {
+    name,
+    data_type: "VARCHAR",
+    is_nullable: true,
+    column_default: null,
+    is_primary_key: isPrimaryKey,
+    extra,
+  };
+}
+
+function createQuickEntryEditor(options: {
+  quickEntryEnabled: boolean;
+  cacheKey?: string;
+  rowStatusFilter?: ReturnType<typeof ref<RowStatusFilter>>;
+  filterRowsInGetRowItem?: boolean;
+  supportsInsert?: boolean;
+  save?: (changes: { dirtyRows: Map<number, Map<number, CellValue>>; newRows: CellValue[][] }) => Promise<void>;
+}) {
+  const result = computed(() => ({
+    columns: ["id", "name"],
+    rows: [[1, "Ada"] as CellValue[]],
+  }));
+  const rowStatusFilter = options.rowStatusFilter ?? ref<RowStatusFilter>("all");
+  let editor: ReturnType<typeof useDataGridEditor>;
+  editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => undefined),
+    database: computed(() => undefined),
+    tableMeta: computed(() => ({
+      tableName: "people",
+      columns: [column("id", true), column("name")],
+      primaryKeys: ["id"],
+    })),
+    onExecuteSql: computed(() => undefined),
+    customSaveHandler: computed(() => ({
+      save: options.save ?? (async () => {}),
+      supportsInsert: options.supportsInsert ?? true,
+    })),
+    sql: computed(() => "SELECT id, name FROM people"),
+    searchText: ref(""),
+    whereFilterInput: ref(""),
+    orderByInput: ref(""),
+    currentWhereInput: computed(() => undefined),
+    rowStatusFilter,
+    dataGridQuickEntryEnabled: computed(() => options.quickEntryEnabled),
+    pageSize: ref(50),
+    currentPage: ref(1),
+    cacheKey: options.cacheKey ? computed(() => options.cacheKey) : undefined,
+    getRowItem: (rowId) => {
+      if (rowId === DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID) {
+        editor.ensureQuickEntryDraftRow();
+        return {
+          id: DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID,
+          data: editor.quickEntryDraftRow.value,
+          isNew: false,
+          isDraft: true,
+          isDeleted: false,
+          isDirtyCol: [false, false],
+          status: "draft",
+        };
+      }
+      if (rowId === 0) {
+        const dirty = editor.dirtyRows.value.get(0);
+        const status = dirty?.size ? "edited" : "clean";
+        if (options.filterRowsInGetRowItem && !matchesRowStatusFilter(status, rowStatusFilter.value)) return undefined;
+        return {
+          id: 0,
+          sourceIndex: 0,
+          data: editor.rowDataWithChanges(result.value.rows[0], 0),
+          isNew: false,
+          isDeleted: false,
+          isDirtyCol: [false, !!dirty?.has(1)],
+          status,
+        };
+      }
+      if (rowId < 0) {
+        const newIndex = -rowId - 1;
+        const row = editor.newRows.value[newIndex];
+        if (!row) return undefined;
+        return {
+          id: rowId,
+          newIndex,
+          data: row,
+          isNew: true,
+          isDeleted: false,
+          isDirtyCol: [false, false],
+          status: "new",
+        };
+      }
+      return undefined;
+    },
+    emit: () => {},
+  });
+  return editor;
+}
+
+function createPeopleGridEditor(result = computed(() => ({ columns: ["id", "name"], rows: [[1, "Ada"] as CellValue[]] }))) {
+  const rowStatusFilter = ref<RowStatusFilter>("all");
+  let editor: ReturnType<typeof useDataGridEditor>;
+
+  editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => undefined),
+    database: computed(() => undefined),
+    tableMeta: computed(() => ({
+      tableName: "people",
+      columns: [column("id", true), column("name")],
+      primaryKeys: ["id"],
+    })),
+    onExecuteSql: computed(() => undefined),
+    customSaveHandler: computed(() => undefined),
+    sql: computed(() => "SELECT id, name FROM people"),
+    searchText: ref(""),
+    whereFilterInput: ref(""),
+    orderByInput: ref(""),
+    currentWhereInput: computed(() => undefined),
+    rowStatusFilter,
+    pageSize: ref(50),
+    currentPage: ref(1),
+    getRowItem: (rowId) => {
+      if (rowId === 0) {
+        return {
+          id: 0,
+          sourceIndex: 0,
+          data: editor.rowDataWithChanges(result.value.rows[0], 0),
+          isNew: false,
+          isDeleted: editor.deletedRows.value.has(0),
+          isDirtyCol: [false, editor.dirtyRows.value.get(0)?.has(1) ?? false],
+          status: editor.deletedRows.value.has(0) ? "deleted" : editor.dirtyRows.value.has(0) ? "edited" : "clean",
+        };
+      }
+      if (rowId < 0) {
+        const newIndex = -rowId - 1;
+        const row = editor.newRows.value[newIndex];
+        if (!row) return undefined;
+        return {
+          id: rowId,
+          newIndex,
+          data: row,
+          isNew: true,
+          isDeleted: false,
+          isDirtyCol: [false, false],
+          status: "new",
+        };
+      }
+      return undefined;
+    },
+    emit: () => {},
+  });
+
+  return editor;
+}
+
+test("row data helper reuses unchanged rows and clones dirty rows only", () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const row = ["AFW", 1995, 35271.907090628745] as CellValue[];
+  const result = computed(() => ({
+    columns: ["code", "year", "score"],
+    rows: [row],
+  }));
+  const editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => undefined),
+    database: computed(() => undefined),
+    tableMeta: computed(() => ({
+      tableName: "metrics",
+      columns: [column("code", true), column("year", true), column("score")],
+      primaryKeys: ["code", "year"],
+    })),
+    onExecuteSql: computed(() => undefined),
+    sql: computed(() => undefined),
+    searchText: ref(""),
+    whereFilterInput: ref(""),
+    orderByInput: ref(""),
+    currentWhereInput: computed(() => undefined),
+    rowStatusFilter: ref("all"),
+    getRowItem: () => undefined,
+    pageSize: ref(100),
+    currentPage: ref(1),
+    emit: () => {},
+  });
+
+  assert.equal(editor.rowDataWithChanges(row, 0), row);
+
+  editor.dirtyRows.value.set(0, new Map([[2, 10]]));
+  const dirtyRow = editor.rowDataWithChanges(row, 0);
+
+  assert.notEqual(dirtyRow, row);
+  assert.deepEqual(dirtyRow, ["AFW", 1995, 10]);
+  assert.deepEqual(row, ["AFW", 1995, 35271.907090628745]);
+});
+
+test("cloning a row copies non-generated primary key values without executing save", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["code", "year", "score"],
+    rows: [["AFW", 1995, 35271.907090628745] as CellValue[]],
+  }));
+  const rowStatusFilter = ref<"all" | "changed" | "edited" | "new" | "deleted">("all");
+  let saveCalls = 0;
+  let editor: ReturnType<typeof useDataGridEditor>;
+
+  editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => undefined),
+    database: computed(() => undefined),
+    tableMeta: computed(() => ({
+      tableName: "metrics",
+      columns: [column("code", true), column("year", true), column("score")],
+      primaryKeys: ["code", "year"],
+    })),
+    onExecuteSql: computed(() => undefined),
+    customSaveHandler: computed(() => ({
+      save: async () => {
+        saveCalls += 1;
+      },
+      supportsInsert: true,
+    })),
+    sql: computed(() => undefined),
+    searchText: ref(""),
+    whereFilterInput: ref(""),
+    orderByInput: ref(""),
+    currentWhereInput: computed(() => undefined),
+    rowStatusFilter,
+    pageSize: ref(100),
+    currentPage: ref(1),
+    getRowItem: (rowId) => {
+      if (rowId === 0) {
+        return {
+          id: 0,
+          sourceIndex: 0,
+          data: result.value.rows[0],
+          isNew: false,
+          isDeleted: false,
+          isDirtyCol: [false, false, false],
+          status: "clean",
+        };
+      }
+      if (rowId < 0) {
+        const newIndex = -rowId - 1;
+        const row = editor.newRows.value[newIndex];
+        if (!row) return undefined;
+        return {
+          id: rowId,
+          newIndex,
+          data: row,
+          isNew: true,
+          isDeleted: false,
+          isDirtyCol: [false, false, false],
+          status: "new",
+        };
+      }
+      return undefined;
+    },
+    emit: () => {},
+  });
+
+  editor.cloneRow(0);
+  await nextTick();
+
+  assert.equal(saveCalls, 0);
+  assert.deepEqual(editor.newRows.value, [["AFW", 1995, 35271.907090628745]]);
+  assert.equal(editor.transactionActive.value, true);
+  assert.deepEqual(editor.editingCell.value, { rowId: -1, col: 0 });
+
+  await editor.saveChanges();
+
+  assert.equal(saveCalls, 1);
+  assert.deepEqual(editor.newRows.value, []);
+});
+
+test("cloning a row clears auto-generated key columns", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["id", "name"],
+    rows: [[1, "Ada"] as CellValue[]],
+  }));
+  const rowStatusFilter = ref<"all" | "changed" | "edited" | "new" | "deleted">("all");
+  let editor: ReturnType<typeof useDataGridEditor>;
+
+  editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "mysql"),
+    connectionId: computed(() => undefined),
+    database: computed(() => undefined),
+    tableMeta: computed(() => ({
+      tableName: "people",
+      columns: [column("id", true, "auto_increment"), column("name")],
+      primaryKeys: ["id"],
+    })),
+    onExecuteSql: computed(() => undefined),
+    customSaveHandler: computed(() => undefined),
+    sql: computed(() => undefined),
+    searchText: ref(""),
+    whereFilterInput: ref(""),
+    orderByInput: ref(""),
+    currentWhereInput: computed(() => undefined),
+    rowStatusFilter,
+    pageSize: ref(100),
+    currentPage: ref(1),
+    getRowItem: (rowId) => {
+      if (rowId !== 0) return undefined;
+      return {
+        id: 0,
+        sourceIndex: 0,
+        data: result.value.rows[0],
+        isNew: false,
+        isDeleted: false,
+        isDirtyCol: [false, false],
+        status: "clean",
+      };
+    },
+    emit: () => {},
+  });
+
+  editor.cloneRow(0);
+  await nextTick();
+
+  assert.deepEqual(editor.newRows.value, [[null, "Ada"]]);
+});
+
+test("saving deleted rows reloads current table data", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["id", "name"],
+    rows: [[1, "Ada"] as CellValue[]],
+  }));
+  const rowStatusFilter = ref<"all" | "changed" | "edited" | "new" | "deleted">("all");
+  const emitted: unknown[][] = [];
+  let editor: ReturnType<typeof useDataGridEditor>;
+
+  editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => "conn-1"),
+    database: computed(() => "main"),
+    tableMeta: computed(() => ({
+      tableName: "people",
+      columns: [column("id", true), column("name")],
+      primaryKeys: ["id"],
+    })),
+    onExecuteSql: computed(() => undefined),
+    customSaveHandler: computed(() => ({ save: async () => {} })),
+    sql: computed(() => "SELECT id, name FROM people"),
+    searchText: ref("ada"),
+    whereFilterInput: ref("name ILIKE '%a%'"),
+    orderByInput: ref("id DESC"),
+    currentWhereInput: computed(() => "name ILIKE '%a%'"),
+    rowStatusFilter,
+    pageSize: ref(50),
+    currentPage: ref(3),
+    getRowItem: (rowId) => {
+      if (rowId !== 0) return undefined;
+      return {
+        id: 0,
+        sourceIndex: 0,
+        data: result.value.rows[0],
+        isNew: false,
+        isDeleted: false,
+        isDirtyCol: [false, false],
+        status: "clean",
+      };
+    },
+    emit: (...args) => {
+      emitted.push(args);
+    },
+  });
+
+  editor.applyDeleteRow(0);
+  await editor.saveChanges();
+
+  assert.deepEqual(emitted, [["reload", "SELECT id, name FROM people", "ada", "name ILIKE '%a%'", "id DESC", 50, 100]]);
+});
+
+test("saving inserted rows reloads current table data", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["id", "name"],
+    rows: [[1, "Ada"] as CellValue[]],
+  }));
+  const rowStatusFilter = ref<"all" | "changed" | "edited" | "new" | "deleted">("all");
+  const emitted: unknown[][] = [];
+  const executedSql: string[] = [];
+
+  const editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => undefined),
+    database: computed(() => undefined),
+    tableMeta: computed(() => ({
+      schema: "public",
+      tableName: "people",
+      columns: [column("id", true), column("name")],
+      primaryKeys: ["id"],
+    })),
+    onExecuteSql: computed(() => async (sql: string) => {
+      executedSql.push(sql);
+    }),
+    customSaveHandler: computed(() => undefined),
+    sql: computed(() => "SELECT id, name FROM people"),
+    searchText: ref("linus"),
+    whereFilterInput: ref("name ILIKE '%l%'"),
+    orderByInput: ref("id DESC"),
+    currentWhereInput: computed(() => "name ILIKE '%l%'"),
+    rowStatusFilter,
+    pageSize: ref(50),
+    currentPage: ref(2),
+    getRowItem: () => undefined,
+    emit: (...args) => {
+      emitted.push(args);
+    },
+  });
+
+  editor.newRows.value = [[2, "Linus"]];
+  await editor.saveChanges();
+
+  assert.deepEqual(executedSql, [`INSERT INTO "public"."people" ("id", "name") VALUES (2, 'Linus');`]);
+  assert.deepEqual(emitted, [["reload", "SELECT id, name FROM people", "linus", "name ILIKE '%l%'", "id DESC", 50, 50]]);
+});
+
+test("saving edited rows without deletes does not reload table data", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["id", "name"],
+    rows: [[1, "Ada"] as CellValue[]],
+  }));
+  const rowStatusFilter = ref<"all" | "changed" | "edited" | "new" | "deleted">("all");
+  const emitted: unknown[][] = [];
+  let editor: ReturnType<typeof useDataGridEditor>;
+
+  editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => "conn-1"),
+    database: computed(() => "main"),
+    tableMeta: computed(() => ({
+      tableName: "people",
+      columns: [column("id", true), column("name")],
+      primaryKeys: ["id"],
+    })),
+    onExecuteSql: computed(() => undefined),
+    customSaveHandler: computed(() => ({ save: async () => {} })),
+    sql: computed(() => "SELECT id, name FROM people"),
+    searchText: ref(""),
+    whereFilterInput: ref(""),
+    orderByInput: ref(""),
+    currentWhereInput: computed(() => undefined),
+    rowStatusFilter,
+    pageSize: ref(50),
+    currentPage: ref(1),
+    getRowItem: (rowId) => {
+      if (rowId !== 0) return undefined;
+      return {
+        id: 0,
+        sourceIndex: 0,
+        data: result.value.rows[0],
+        isNew: false,
+        isDeleted: false,
+        isDirtyCol: [false, false],
+        status: "clean",
+      };
+    },
+    emit: (...args) => {
+      emitted.push(args);
+    },
+  });
+
+  editor.applyCellValue(0, 1, "Ada Lovelace");
+  await editor.saveChanges();
+
+  assert.deepEqual(emitted, []);
+  assert.deepEqual(result.value.rows[0], [1, "Ada Lovelace"]);
+});
+
+test("undo and redo restore pending cell edits before save", () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["id", "name"],
+    rows: [[1, "Ada"] as CellValue[]],
+  }));
+  const editor = createPeopleGridEditor(result);
+
+  editor.applyCellValue(0, 1, "Ada Lovelace");
+  assert.equal(editor.canUndoPendingChange.value, true);
+  assert.equal(editor.canRedoPendingChange.value, false);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada Lovelace"]);
+
+  editor.undoPendingChange();
+  assert.equal(editor.canUndoPendingChange.value, false);
+  assert.equal(editor.canRedoPendingChange.value, true);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada"]);
+
+  editor.redoPendingChange();
+  assert.equal(editor.canUndoPendingChange.value, true);
+  assert.equal(editor.canRedoPendingChange.value, false);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada Lovelace"]);
+});
+
+test("restoring a pending cell edit records undo and redo history", () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["id", "name"],
+    rows: [[1, "Ada"] as CellValue[]],
+  }));
+  const editor = createPeopleGridEditor(result);
+
+  editor.applyCellValue(0, 1, "Ada Lovelace");
+  editor.restoreCellValue(0, 1);
+  assert.equal(editor.canUndoPendingChange.value, true);
+  assert.equal(editor.canRedoPendingChange.value, false);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada"]);
+
+  editor.undoPendingChange();
+  assert.equal(editor.canUndoPendingChange.value, true);
+  assert.equal(editor.canRedoPendingChange.value, true);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada Lovelace"]);
+
+  editor.redoPendingChange();
+  assert.equal(editor.canUndoPendingChange.value, true);
+  assert.equal(editor.canRedoPendingChange.value, false);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada"]);
+});
+
+test("undo and redo cover row add and delete operations", () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const editor = createPeopleGridEditor();
+
+  editor.addRow();
+  assert.equal(editor.newRows.value.length, 1);
+  editor.undoPendingChange();
+  assert.equal(editor.newRows.value.length, 0);
+  editor.redoPendingChange();
+  assert.equal(editor.newRows.value.length, 1);
+
+  editor.applyDeleteRow(0);
+  assert.deepEqual([...editor.deletedRows.value], [0]);
+  editor.undoPendingChange();
+  assert.deepEqual([...editor.deletedRows.value], []);
+  assert.equal(editor.newRows.value.length, 1);
+  editor.redoPendingChange();
+  assert.deepEqual([...editor.deletedRows.value], [0]);
+});
+
+test("batch row delete records a single undo snapshot", () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["id", "name"],
+    rows: [[1, "Ada"] as CellValue[], [2, "Linus"] as CellValue[], [3, "Grace"] as CellValue[]],
+  }));
+  const rowStatusFilter = ref<"all" | "changed" | "edited" | "new" | "deleted">("all");
+  let editor: ReturnType<typeof useDataGridEditor>;
+
+  editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => undefined),
+    database: computed(() => undefined),
+    tableMeta: computed(() => ({
+      tableName: "people",
+      columns: [column("id", true), column("name")],
+      primaryKeys: ["id"],
+    })),
+    onExecuteSql: computed(() => undefined),
+    customSaveHandler: computed(() => undefined),
+    sql: computed(() => "SELECT id, name FROM people"),
+    searchText: ref(""),
+    whereFilterInput: ref(""),
+    orderByInput: ref(""),
+    currentWhereInput: computed(() => undefined),
+    rowStatusFilter,
+    pageSize: ref(50),
+    currentPage: ref(1),
+    getRowItem: (rowId) => {
+      if (rowId >= 0 && result.value.rows[rowId]) {
+        return {
+          id: rowId,
+          sourceIndex: rowId,
+          data: result.value.rows[rowId],
+          isNew: false,
+          isDeleted: editor.deletedRows.value.has(rowId),
+          isDirtyCol: [false, editor.dirtyRows.value.get(rowId)?.has(1) ?? false],
+          status: editor.deletedRows.value.has(rowId) ? "deleted" : editor.dirtyRows.value.has(rowId) ? "edited" : "clean",
+        };
+      }
+      if (rowId < 0) {
+        const newIndex = -rowId - 1;
+        const row = editor.newRows.value[newIndex];
+        if (!row) return undefined;
+        return {
+          id: rowId,
+          newIndex,
+          data: row,
+          isNew: true,
+          isDeleted: false,
+          isDirtyCol: [false, false],
+          status: "new",
+        };
+      }
+      return undefined;
+    },
+    emit: () => {},
+  });
+
+  editor.applyDeleteRows([0, 1]);
+  assert.deepEqual([...editor.deletedRows.value], [0, 1]);
+
+  editor.undoPendingChange();
+  assert.deepEqual([...editor.deletedRows.value], []);
+  assert.equal(editor.canUndoPendingChange.value, false);
+
+  editor.redoPendingChange();
+  assert.deepEqual([...editor.deletedRows.value], [0, 1]);
+
+  editor.newRows.value = [
+    [4, "Katherine"],
+    [5, "Margaret"],
+    [6, "Donald"],
+  ];
+  editor.applyDeleteRows([-1, -2]);
+  assert.deepEqual(editor.newRows.value, [[6, "Donald"]]);
+});
+
+test("undo and redo restore pending cell edits before save", () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["id", "name"],
+    rows: [[1, "Ada"] as CellValue[]],
+  }));
+  const editor = createPeopleGridEditor(result);
+
+  editor.applyCellValue(0, 1, "Ada Lovelace");
+  assert.equal(editor.canUndoPendingChange.value, true);
+  assert.equal(editor.canRedoPendingChange.value, false);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada Lovelace"]);
+
+  editor.undoPendingChange();
+  assert.equal(editor.canUndoPendingChange.value, false);
+  assert.equal(editor.canRedoPendingChange.value, true);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada"]);
+
+  editor.redoPendingChange();
+  assert.equal(editor.canUndoPendingChange.value, true);
+  assert.equal(editor.canRedoPendingChange.value, false);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada Lovelace"]);
+});
+
+test("restoring a pending cell edit records undo and redo history", () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["id", "name"],
+    rows: [[1, "Ada"] as CellValue[]],
+  }));
+  const editor = createPeopleGridEditor(result);
+
+  editor.applyCellValue(0, 1, "Ada Lovelace");
+  editor.restoreCellValue(0, 1);
+  assert.equal(editor.canUndoPendingChange.value, true);
+  assert.equal(editor.canRedoPendingChange.value, false);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada"]);
+
+  editor.undoPendingChange();
+  assert.equal(editor.canUndoPendingChange.value, true);
+  assert.equal(editor.canRedoPendingChange.value, true);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada Lovelace"]);
+
+  editor.redoPendingChange();
+  assert.equal(editor.canUndoPendingChange.value, true);
+  assert.equal(editor.canRedoPendingChange.value, false);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.deepEqual(editor.rowDataWithChanges(result.value.rows[0], 0), [1, "Ada"]);
+});
+
+test("undo and redo cover row add and delete operations", () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const editor = createPeopleGridEditor();
+
+  editor.addRow();
+  assert.equal(editor.newRows.value.length, 1);
+  editor.undoPendingChange();
+  assert.equal(editor.newRows.value.length, 0);
+  editor.redoPendingChange();
+  assert.equal(editor.newRows.value.length, 1);
+
+  editor.applyDeleteRow(0);
+  assert.deepEqual([...editor.deletedRows.value], [0]);
+  editor.undoPendingChange();
+  assert.deepEqual([...editor.deletedRows.value], []);
+  assert.equal(editor.newRows.value.length, 1);
+  editor.redoPendingChange();
+  assert.deepEqual([...editor.deletedRows.value], [0]);
+});
+
+test("keeps appended empty-table rows when parent refreshes an equivalent rows array", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = ref<{ columns: string[]; rows: CellValue[][] }>({ columns: ["id", "name"], rows: [] });
+  const editor = createPeopleGridEditor(computed(() => result.value));
+
+  editor.addRow();
+  await nextTick();
+  assert.equal(editor.newRows.value.length, 1);
+
+  result.value = { columns: ["id", "name"], rows: [] };
+  await nextTick();
+  assert.equal(editor.newRows.value.length, 1);
+
+  result.value = { columns: ["id", "name"], rows: [[1, "Ada"] as CellValue[]] };
+  await nextTick();
+  assert.equal(editor.newRows.value.length, 0);
+});
+
+test("saving manually typed JSON from a MySQL grid normalizes smart quotes", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["id", "payload"],
+    rows: [[1, "{}"] as CellValue[]],
+  }));
+  const rowStatusFilter = ref<"all" | "changed" | "edited" | "new" | "deleted">("all");
+  const executedSql: string[] = [];
+
+  const editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "mysql"),
+    connectionId: computed(() => undefined),
+    database: computed(() => undefined),
+    tableMeta: computed(() => ({
+      tableName: "settings",
+      columns: [column("id", true), { ...column("payload"), data_type: "json" }],
+      primaryKeys: ["id"],
+    })),
+    onExecuteSql: computed(() => async (sql: string) => {
+      executedSql.push(sql);
+    }),
+    customSaveHandler: computed(() => undefined),
+    sql: computed(() => "SELECT id, payload FROM settings"),
+    searchText: ref(""),
+    whereFilterInput: ref(""),
+    orderByInput: ref(""),
+    currentWhereInput: computed(() => undefined),
+    rowStatusFilter,
+    pageSize: ref(50),
+    currentPage: ref(1),
+    getRowItem: (rowId) => {
+      if (rowId !== 0) return undefined;
+      return {
+        id: 0,
+        sourceIndex: 0,
+        data: result.value.rows[0],
+        isNew: false,
+        isDeleted: false,
+        isDirtyCol: [false, false],
+        status: "clean",
+      };
+    },
+    emit: () => {},
+  });
+
+  editor.applyCellValue(0, 1, "{“2:3”:“3:4”,“3:2”:“4:3”,“21:9”:“16:9”}");
+  await editor.saveChanges();
+
+  assert.deepEqual(executedSql, [`UPDATE "settings" SET "payload" = '{"2:3":"3:4","3:2":"4:3","21:9":"16:9"}' WHERE "id" = 1;`]);
+});
+
+test("saving manually typed JSON arrays from a Postgres array column uses array values", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const result = computed(() => ({
+    columns: ["id", "tags"],
+    rows: [[1, "{legacy}"] as CellValue[]],
+  }));
+  const rowStatusFilter = ref<"all" | "changed" | "edited" | "new" | "deleted">("all");
+  const executedSql: string[] = [];
+
+  const editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => undefined),
+    database: computed(() => undefined),
+    tableMeta: computed(() => ({
+      tableName: "articles",
+      columns: [column("id", true), { ...column("tags"), data_type: "_text" }],
+      primaryKeys: ["id"],
+    })),
+    onExecuteSql: computed(() => async (sql: string) => {
+      executedSql.push(sql);
+    }),
+    customSaveHandler: computed(() => undefined),
+    sql: computed(() => "SELECT id, tags FROM articles"),
+    searchText: ref(""),
+    whereFilterInput: ref(""),
+    orderByInput: ref(""),
+    currentWhereInput: computed(() => undefined),
+    rowStatusFilter,
+    pageSize: ref(50),
+    currentPage: ref(1),
+    getRowItem: (rowId) => {
+      if (rowId !== 0) return undefined;
+      return {
+        id: 0,
+        sourceIndex: 0,
+        data: result.value.rows[0],
+        isNew: false,
+        isDeleted: false,
+        isDirtyCol: [false, false],
+        status: "clean",
+      };
+    },
+    emit: () => {},
+  });
+
+  editor.applyCellValue(0, 1, `["draft","发布"]`);
+  await editor.saveChanges();
+
+  assert.deepEqual(executedSql, [`UPDATE "articles" SET "tags" = '{"draft","发布"}' WHERE "id" = 1;`]);
+});
+
+test("failed table data save records a failed history entry", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const permissionError = "Statement 1 failed: Server error: ERROR 42000 (1142): UPDATE command denied to user";
+  const savedHistoryEntries: Array<Record<string, unknown>> = [];
+  globalThis.fetch = (async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-data-grid-save") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      const options = body.options as DataGridSaveStatementOptions;
+      return new Response(
+        JSON.stringify({
+          statements: mockPreparedSaveStatements(options),
+          rollbackStatements: [`UPDATE "pp_questions" SET "title" = 'Old title' WHERE "id" = 1;`],
+          executionSchema: options.tableMeta.schema,
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/execute-in-transaction") {
+      return new Response(permissionError, { status: 500 });
+    }
+    if (url === "/api/history/save") {
+      savedHistoryEntries.push(JSON.parse(String(init?.body ?? "{}")).entry);
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response(`unexpected request: ${url}`, { status: 500 });
+  }) as typeof fetch;
+
+  const result = computed(() => ({
+    columns: ["id", "title"],
+    rows: [[1, "Old title"] as CellValue[]],
+  }));
+  const rowStatusFilter = ref<"all" | "changed" | "edited" | "new" | "deleted">("all");
+  const editor = useDataGridEditor({
+    result,
+    editable: computed(() => true),
+    databaseType: computed(() => "mysql"),
+    connectionId: computed(() => "conn-1"),
+    database: computed(() => "app_db"),
+    tableMeta: computed(() => ({
+      tableName: "pp_questions",
+      columns: [column("id", true), column("title")],
+      primaryKeys: ["id"],
+    })),
+    onExecuteSql: computed(() => undefined),
+    customSaveHandler: computed(() => undefined),
+    sql: computed(() => "SELECT id, title FROM pp_questions"),
+    searchText: ref(""),
+    whereFilterInput: ref(""),
+    currentWhereInput: computed(() => undefined),
+    orderByInput: ref(""),
+    rowStatusFilter,
+    pageSize: ref(50),
+    currentPage: ref(1),
+    getRowItem: (rowId) => {
+      if (rowId !== 0) return undefined;
+      return {
+        id: 0,
+        sourceIndex: 0,
+        data: result.value.rows[0],
+        isNew: false,
+        isDeleted: false,
+        isDirtyCol: [false, false],
+        status: "clean",
+      };
+    },
+    emit: () => {},
+  });
+
+  editor.applyCellValue(0, 1, "New title");
+  await editor.saveChanges();
+
+  assert.equal(editor.saveError.value, permissionError);
+  assert.equal(editor.dirtyRows.value.size, 1);
+  assert.equal(savedHistoryEntries.length, 1);
+  const historyEntry = savedHistoryEntries[0];
+  assert.equal(historyEntry.success, false);
+  assert.equal(historyEntry.error, permissionError);
+  assert.equal(historyEntry.activity_kind, "data_change");
+  assert.equal(historyEntry.operation, "UPDATE");
+  assert.equal(historyEntry.target, "pp_questions");
+  assert.equal(historyEntry.rollback_sql, undefined);
+  assert.equal(historyEntry.affected_rows, undefined);
+  assert.equal(historyEntry.sql, `UPDATE "pp_questions" SET "title" = 'New title' WHERE "id" = 1;`);
+});
+
+test("quick entry off keeps blur edits pending without saving", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: false,
+    save: async () => {
+      saveCalls += 1;
+    },
+  });
+
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada Lovelace";
+  await editor.commitEditFromBlur();
+
+  assert.equal(saveCalls, 0);
+  assert.equal(editor.dirtyRows.value.size, 1);
+  assert.equal(editor.dirtyRows.value.get(0)?.get(1), "Ada Lovelace");
+});
+
+test("explicit enum commits distinguish NULL, empty string, and the literal NULL", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+
+  const nullEditor = createPeopleGridEditor();
+  nullEditor.startEdit(0, 1);
+  await nullEditor.commitEditAndMaybeAutoSave({ explicitValue: null });
+  assert.equal(nullEditor.dirtyRows.value.get(0)?.get(1), null);
+
+  const emptyEditor = createPeopleGridEditor();
+  emptyEditor.startEdit(0, 1);
+  await emptyEditor.commitEditAndMaybeAutoSave({ explicitValue: "" });
+  assert.equal(emptyEditor.dirtyRows.value.get(0)?.get(1), "");
+
+  const literalEditor = createPeopleGridEditor();
+  literalEditor.startEdit(0, 1);
+  await literalEditor.commitEditAndMaybeAutoSave({ explicitValue: "NULL" });
+  assert.equal(literalEditor.dirtyRows.value.get(0)?.get(1), "NULL");
+});
+
+test("quick entry on saves existing row edits on blur", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    save: async () => {
+      saveCalls += 1;
+    },
+  });
+
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada Lovelace";
+  await editor.commitEditFromBlur();
+
+  assert.equal(saveCalls, 1);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.equal(editor.saveError.value, "");
+});
+
+test("quick entry on saves existing row edits on Enter commit", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  let saveFinished!: () => void;
+  const saveFinishedPromise = new Promise<void>((resolve) => {
+    saveFinished = resolve;
+  });
+  const savedDirtyRows: Array<Array<[number, Array<[number, CellValue]>]>> = [];
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    save: async ({ dirtyRows }) => {
+      saveCalls += 1;
+      savedDirtyRows.push([...dirtyRows.entries()].map(([rowIndex, changes]) => [rowIndex, [...changes.entries()]]));
+      saveFinished();
+    },
+  });
+
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada Lovelace";
+  editor.onEditKeydown({
+    key: "Enter",
+    preventDefault: () => {},
+    stopPropagation: () => {},
+  } as KeyboardEvent);
+  await saveFinishedPromise;
+
+  assert.equal(saveCalls, 1);
+  assert.deepEqual(savedDirtyRows, [[[0, [[1, "Ada Lovelace"]]]]]);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.equal(editor.saveError.value, "");
+});
+
+test("quick entry queues blur saves made while a save is running", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  let firstSaveStarted!: () => void;
+  let releaseFirstSave!: () => void;
+  const firstSaveStartedPromise = new Promise<void>((resolve) => {
+    firstSaveStarted = resolve;
+  });
+  const firstSaveBlocker = new Promise<void>((resolve) => {
+    releaseFirstSave = resolve;
+  });
+  const savedDirtyRows: Array<Array<[number, Array<[number, CellValue]>]>> = [];
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    save: async ({ dirtyRows }) => {
+      saveCalls += 1;
+      savedDirtyRows.push([...dirtyRows.entries()].map(([rowIndex, changes]) => [rowIndex, [...changes.entries()]]));
+      if (saveCalls === 1) {
+        firstSaveStarted();
+        await firstSaveBlocker;
+      }
+    },
+  });
+
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada 1";
+  const firstCommit = editor.commitEditFromBlur();
+  await firstSaveStartedPromise;
+
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada 2";
+  await editor.commitEditFromBlur();
+
+  assert.equal(saveCalls, 1);
+  assert.equal(editor.dirtyRows.value.get(0)?.get(1), "Ada 2");
+
+  releaseFirstSave();
+  await firstCommit;
+
+  assert.equal(saveCalls, 2);
+  assert.deepEqual(savedDirtyRows, [[[0, [[1, "Ada 1"]]]], [[0, [[1, "Ada 2"]]]]]);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.equal(editor.saveError.value, "");
+});
+
+test("quick entry replays queued saves when row-status filters hide the saved row", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  const rowStatusFilter = ref<RowStatusFilter>("edited");
+  let saveCalls = 0;
+  let firstSaveStarted!: () => void;
+  let releaseFirstSave!: () => void;
+  const firstSaveStartedPromise = new Promise<void>((resolve) => {
+    firstSaveStarted = resolve;
+  });
+  const firstSaveBlocker = new Promise<void>((resolve) => {
+    releaseFirstSave = resolve;
+  });
+  const savedDirtyRows: Array<Array<[number, Array<[number, CellValue]>]>> = [];
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    rowStatusFilter,
+    filterRowsInGetRowItem: true,
+    save: async ({ dirtyRows }) => {
+      saveCalls += 1;
+      savedDirtyRows.push([...dirtyRows.entries()].map(([rowIndex, changes]) => [rowIndex, [...changes.entries()]]));
+      if (saveCalls === 1) {
+        firstSaveStarted();
+        await firstSaveBlocker;
+      }
+    },
+  });
+
+  rowStatusFilter.value = "all";
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada 1";
+  const firstCommit = editor.commitEditFromBlur();
+  await firstSaveStartedPromise;
+
+  rowStatusFilter.value = "edited";
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada 2";
+  await editor.commitEditFromBlur();
+
+  assert.equal(saveCalls, 1);
+  assert.equal(editor.dirtyRows.value.get(0)?.get(1), "Ada 2");
+
+  releaseFirstSave();
+  await firstCommit;
+
+  assert.equal(saveCalls, 2);
+  assert.deepEqual(savedDirtyRows, [[[0, [[1, "Ada 1"]]]], [[0, [[1, "Ada 2"]]]]]);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.equal(editor.saveError.value, "");
+});
+
+test("quick entry preserves an active edit when auto-save clears the row from a status filter", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  const rowStatusFilter = ref<RowStatusFilter>("edited");
+  let saveCalls = 0;
+  let firstSaveStarted!: () => void;
+  let releaseFirstSave!: () => void;
+  const firstSaveStartedPromise = new Promise<void>((resolve) => {
+    firstSaveStarted = resolve;
+  });
+  const firstSaveBlocker = new Promise<void>((resolve) => {
+    releaseFirstSave = resolve;
+  });
+  const savedDirtyRows: Array<Array<[number, Array<[number, CellValue]>]>> = [];
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    rowStatusFilter,
+    filterRowsInGetRowItem: true,
+    save: async ({ dirtyRows }) => {
+      saveCalls += 1;
+      savedDirtyRows.push([...dirtyRows.entries()].map(([rowIndex, changes]) => [rowIndex, [...changes.entries()]]));
+      if (saveCalls === 1) {
+        firstSaveStarted();
+        await firstSaveBlocker;
+      }
+    },
+  });
+
+  rowStatusFilter.value = "all";
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada 1";
+  const firstCommit = editor.commitEditFromBlur();
+  await firstSaveStartedPromise;
+
+  rowStatusFilter.value = "edited";
+  editor.startEdit(0, 0);
+  editor.editValue.value = "2";
+
+  releaseFirstSave();
+  await firstCommit;
+
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.equal(editor.editingCell.value?.rowId, 0);
+
+  await editor.commitEditFromBlur();
+
+  assert.equal(saveCalls, 2);
+  assert.deepEqual(savedDirtyRows, [[[0, [[1, "Ada 1"]]]], [[0, [[0, 2]]]]]);
+  assert.equal(editor.dirtyRows.value.size, 0);
+});
+
+test("quick entry keeps queued blur save after an earlier auto-save fails", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  let firstSaveStarted!: () => void;
+  let releaseFirstSave!: () => void;
+  const firstSaveStartedPromise = new Promise<void>((resolve) => {
+    firstSaveStarted = resolve;
+  });
+  const firstSaveBlocker = new Promise<void>((resolve) => {
+    releaseFirstSave = resolve;
+  });
+  const savedDirtyRows: Array<Array<[number, Array<[number, CellValue]>]>> = [];
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    save: async ({ dirtyRows }) => {
+      saveCalls += 1;
+      savedDirtyRows.push([...dirtyRows.entries()].map(([rowIndex, changes]) => [rowIndex, [...changes.entries()]]));
+      if (saveCalls === 1) {
+        firstSaveStarted();
+        await firstSaveBlocker;
+        throw new Error("first save failed");
+      }
+    },
+  });
+
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada 1";
+  const firstCommit = editor.commitEditFromBlur();
+  await firstSaveStartedPromise;
+
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada 2";
+  await editor.commitEditFromBlur();
+
+  assert.equal(saveCalls, 1);
+  assert.equal(editor.dirtyRows.value.get(0)?.get(1), "Ada 2");
+
+  releaseFirstSave();
+  await firstCommit;
+
+  assert.equal(saveCalls, 2);
+  assert.deepEqual(savedDirtyRows, [[[0, [[1, "Ada 1"]]]], [[0, [[1, "Ada 2"]]]]]);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.equal(editor.saveError.value, "");
+});
+
+test("quick entry saves a queued revert made while an earlier auto-save is running", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  let firstSaveStarted!: () => void;
+  let releaseFirstSave!: () => void;
+  const firstSaveStartedPromise = new Promise<void>((resolve) => {
+    firstSaveStarted = resolve;
+  });
+  const firstSaveBlocker = new Promise<void>((resolve) => {
+    releaseFirstSave = resolve;
+  });
+  const savedDirtyRows: Array<Array<[number, Array<[number, CellValue]>]>> = [];
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    save: async ({ dirtyRows }) => {
+      saveCalls += 1;
+      savedDirtyRows.push([...dirtyRows.entries()].map(([rowIndex, changes]) => [rowIndex, [...changes.entries()]]));
+      if (saveCalls === 1) {
+        firstSaveStarted();
+        await firstSaveBlocker;
+      }
+    },
+  });
+
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada 1";
+  const firstCommit = editor.commitEditFromBlur();
+  await firstSaveStartedPromise;
+
+  editor.startEdit(0, 1);
+  editor.editValue.value = "Ada";
+  await editor.commitEditFromBlur();
+
+  assert.equal(saveCalls, 1);
+  assert.equal(editor.dirtyRows.value.size, 0);
+
+  releaseFirstSave();
+  await firstCommit;
+
+  assert.equal(saveCalls, 2);
+  assert.deepEqual(savedDirtyRows, [[[0, [[1, "Ada 1"]]]], [[0, [[1, "Ada"]]]]]);
+  assert.equal(editor.dirtyRows.value.size, 0);
+  assert.equal(editor.saveError.value, "");
+});
+
+test("quick entry blocks editing a pending new row while its insert is saving", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  let firstSaveStarted!: () => void;
+  let releaseFirstSave!: () => void;
+  const firstSaveStartedPromise = new Promise<void>((resolve) => {
+    firstSaveStarted = resolve;
+  });
+  const firstSaveBlocker = new Promise<void>((resolve) => {
+    releaseFirstSave = resolve;
+  });
+  const savedNewRows: CellValue[][][] = [];
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    save: async ({ newRows }) => {
+      saveCalls += 1;
+      savedNewRows.push(newRows.map((row) => [...row]));
+      if (saveCalls === 1) {
+        firstSaveStarted();
+        await firstSaveBlocker;
+      }
+    },
+  });
+
+  editor.startEdit(DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, 1);
+  editor.editValue.value = "Grace";
+  const firstCommit = editor.commitEditFromBlur();
+  await firstSaveStartedPromise;
+
+  const pendingNewRowItem = {
+    id: -1,
+    newIndex: 0,
+    data: editor.newRows.value[0],
+    isNew: true,
+    isDeleted: false,
+    isDirtyCol: [false, false],
+    status: "new",
+  };
+  assert.equal(editor.isSavingNewRow(pendingNewRowItem), true);
+
+  editor.startEdit(-1, 1);
+
+  assert.equal(editor.editingCell.value, null);
+  assert.equal(saveCalls, 1);
+  assert.deepEqual(editor.newRows.value, [[null, "Grace"]]);
+
+  releaseFirstSave();
+  await firstCommit;
+
+  assert.equal(saveCalls, 1);
+  assert.deepEqual(savedNewRows, [[[null, "Grace"]]]);
+  assert.deepEqual(editor.newRows.value, []);
+  assert.equal(editor.isSavingNewRow(pendingNewRowItem), false);
+  assert.equal(editor.saveError.value, "");
+});
+
+test("quick entry draft row ignores blank blur commits", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    save: async () => {
+      saveCalls += 1;
+    },
+  });
+
+  editor.startEdit(DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, 1);
+  editor.editValue.value = "   ";
+  await editor.commitEditFromBlur();
+
+  assert.equal(saveCalls, 0);
+  assert.deepEqual(editor.newRows.value, []);
+  assert.deepEqual(editor.quickEntryDraftRow.value, [null, null]);
+});
+
+test("quick entry draft row becomes a new row and saves on blur", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  const savedNewRows: CellValue[][][] = [];
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    save: async ({ newRows }) => {
+      saveCalls += 1;
+      savedNewRows.push(newRows.map((row) => [...row]));
+    },
+  });
+
+  editor.startEdit(DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, 1);
+  editor.editValue.value = "Grace";
+  await editor.commitEditFromBlur();
+
+  assert.equal(saveCalls, 1);
+  assert.deepEqual(savedNewRows, [[[null, "Grace"]]]);
+  assert.deepEqual(editor.newRows.value, []);
+  assert.deepEqual(editor.quickEntryDraftRow.value, [null, null]);
+  assert.equal(editor.saveError.value, "");
+});
+
+test("custom save handler without insert support keeps pending new rows", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    supportsInsert: false,
+    save: async () => {
+      saveCalls += 1;
+    },
+  });
+  editor.newRows.value = [[null, "Grace"]];
+
+  await editor.saveChanges();
+
+  assert.equal(saveCalls, 0);
+  assert.equal(editor.saveError.value, "当前保存目标不支持新增行。");
+  assert.deepEqual(editor.newRows.value, [[null, "Grace"]]);
+  assert.equal(editor.hasPendingChanges.value, true);
+});
+
+test("quick entry draft row pasted values become a new row and save once", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  const savedNewRows: CellValue[][][] = [];
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    save: async ({ newRows }) => {
+      saveCalls += 1;
+      savedNewRows.push(newRows.map((row) => [...row]));
+    },
+  });
+
+  editor.applyCellValue(DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, 0, "2");
+  editor.applyCellValue(DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, 1, "Grace");
+  await Promise.resolve();
+  await Promise.resolve();
+
+  assert.equal(saveCalls, 1);
+  assert.deepEqual(savedNewRows, [[["2", "Grace"]]]);
+  assert.deepEqual(editor.newRows.value, []);
+  assert.deepEqual(editor.quickEntryDraftRow.value, [null, null]);
+  assert.equal(editor.saveError.value, "");
+});
+
+test("quick entry off keeps pasted draft row as a pending new row", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: false,
+    save: async () => {
+      saveCalls += 1;
+    },
+  });
+
+  editor.applyCellValue(DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, 1, "Grace");
+  await Promise.resolve();
+
+  assert.equal(saveCalls, 0);
+  assert.deepEqual(editor.newRows.value, [[null, "Grace"]]);
+  assert.deepEqual(editor.quickEntryDraftRow.value, [null, null]);
+  assert.equal(editor.hasPendingChanges.value, true);
+});
+
+test("quick entry draft row keeps editing across draft cells without saving", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  let saveCalls = 0;
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    save: async () => {
+      saveCalls += 1;
+    },
+  });
+
+  editor.startEdit(DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, 1);
+  editor.editValue.value = "Grace";
+  await editor.commitEditFromBlur({ promoteDraft: false });
+
+  assert.equal(saveCalls, 0);
+  assert.deepEqual(editor.newRows.value, []);
+  assert.deepEqual(editor.quickEntryDraftRow.value, [null, "Grace"]);
+  assert.equal(editor.saveError.value, "");
+});
+
+test("quick entry draft row survives pending snapshot restore", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  const firstEditor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    cacheKey: "quick-entry-draft-snapshot",
+  });
+
+  firstEditor.startEdit(DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, 1);
+  firstEditor.editValue.value = "Grace";
+  await firstEditor.commitEditFromBlur({ promoteDraft: false });
+  firstEditor.startEdit(DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, 0);
+  firstEditor.editValue.value = "2";
+  firstEditor.savePendingSnapshot(true, false);
+
+  const restoredEditor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    cacheKey: "quick-entry-draft-snapshot",
+  });
+
+  assert.deepEqual(restoredEditor.quickEntryDraftRow.value, [null, "Grace"]);
+  assert.deepEqual(restoredEditor.editingCell.value, { rowId: DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, col: 0 });
+  assert.equal(restoredEditor.editValue.value, "2");
+
+  await restoredEditor.commitEditFromBlur();
+
+  assert.deepEqual(restoredEditor.newRows.value, []);
+  assert.deepEqual(restoredEditor.quickEntryDraftRow.value, [null, null]);
+});
+
+test("quick entry auto-save failure keeps the pending new row", async () => {
+  setActivePinia(createPinia());
+  installBrowserTestGlobals();
+  const editor = createQuickEntryEditor({
+    quickEntryEnabled: true,
+    save: async () => {
+      throw new Error("insert failed");
+    },
+  });
+
+  editor.startEdit(DATA_GRID_QUICK_ENTRY_DRAFT_ROW_ID, 1);
+  editor.editValue.value = "Grace";
+  await editor.commitEditFromBlur();
+
+  assert.equal(editor.saveError.value, "insert failed");
+  assert.deepEqual(editor.newRows.value, [[null, "Grace"]]);
+  assert.equal(editor.hasPendingChanges.value, true);
+
+  editor.startEdit(-1, 1);
+
+  assert.deepEqual(editor.editingCell.value, { rowId: -1, col: 1 });
+});
diff --git a/packages/app-tests/dataGridExport.test.ts b/packages/app-tests/dataGridExport.test.ts
new file mode 100644
index 0000000..10b7067
--- /dev/null
+++ b/packages/app-tests/dataGridExport.test.ts
@@ -0,0 +1,128 @@
+import { strict as assert } from "node:assert";
+import { beforeEach, test, vi } from "vitest";
+import { computed, ref } from "vue";
+import { useDataGridExport } from "../../apps/desktop/src/composables/useDataGridExport.ts";
+import { copyToClipboard } from "@/lib/common/clipboard";
+import * as api from "@/lib/backend/api";
+
+vi.mock("vue-i18n", () => ({
+  useI18n: () => ({
+    t: (key: string) => key,
+  }),
+}));
+
+vi.mock("@/lib/common/clipboard", () => ({
+  copyToClipboard: vi.fn(async () => {}),
+}));
+
+vi.mock("@/lib/backend/api", () => ({
+  exportQueryResultCsv: vi.fn(async () => {}),
+}));
+
+const draftRowId = Number.MIN_SAFE_INTEGER;
+
+function createExportContext(options: {
+  contextRowId?: number;
+  selectedRowIds?: Set<number>;
+  fullExportResult?: () => Promise<{ columns: string[]; rows: Array<Array<string | number | boolean | null>>; affected_rows: number; execution_time_ms: number }>;
+} = {}) {
+  const contextRowId = options.contextRowId ?? draftRowId;
+  const selectedRowIds = ref(options.selectedRowIds ?? new Set<number>());
+  const rows = [
+    {
+      id: 0,
+      sourceIndex: 0,
+      data: [1, "Ada"],
+      isNew: false,
+      isDeleted: false,
+      isDirtyCol: [false, false],
+      status: "clean",
+    },
+    {
+      id: draftRowId,
+      data: [null, null],
+      isNew: false,
+      isDraft: true,
+      isDeleted: false,
+      isDirtyCol: [false, false],
+      status: "draft",
+    },
+  ];
+
+  return useDataGridExport({
+    columns: computed(() => ["id", "name"]),
+    displayItems: computed(() => rows),
+    sql: computed(() => undefined),
+    tableMeta: computed(() => undefined),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => undefined),
+    database: computed(() => undefined),
+    context: computed(() => "table-data"),
+    sourceColumns: computed(() => undefined),
+    columnTypes: computed(() => undefined),
+    whereInput: computed(() => undefined),
+    orderBy: computed(() => undefined),
+    exportBatchSize: computed(() => 1000),
+    hasCellSelection: computed(() => false),
+    selectedCells: computed(() => ({ columns: [], rows: [] })),
+    selectedRange: computed(() => null),
+    contextCell: ref({ rowId: contextRowId, rowIndex: contextRowId === draftRowId ? 1 : 0, col: 1 }),
+    getRowItem: (rowId) => rows.find((row) => row.id === rowId),
+    selectedRowIds,
+    hasRowSelection: computed(() => selectedRowIds.value.size > 0),
+    fullExportResult: options.fullExportResult,
+  });
+}
+
+beforeEach(() => {
+  globalThis.window = {
+    setTimeout,
+    clearTimeout,
+  } as unknown as Window & typeof globalThis;
+  vi.mocked(copyToClipboard).mockClear();
+  vi.mocked(api.exportQueryResultCsv).mockClear();
+});
+
+test("direct draft cell copy is ignored", async () => {
+  const exporter = createExportContext();
+
+  await exporter.copyCell();
+
+  assert.equal(vi.mocked(copyToClipboard).mock.calls.length, 0);
+});
+
+test("direct draft row copy is ignored", async () => {
+  const exporter = createExportContext();
+
+  await exporter.copyRow();
+
+  assert.equal(vi.mocked(copyToClipboard).mock.calls.length, 0);
+});
+
+test("selected draft row TSV copy is ignored", async () => {
+  const exporter = createExportContext({ selectedRowIds: new Set([draftRowId]) });
+
+  await exporter.copySelectedRowsTsv();
+
+  assert.equal(vi.mocked(copyToClipboard).mock.calls.length, 0);
+});
+
+test("empty selected row export does not fall back to full export", async () => {
+  let fullExportCalls = 0;
+  const exporter = createExportContext({
+    fullExportResult: async () => {
+      fullExportCalls += 1;
+      return {
+        columns: ["id", "name"],
+        rows: [[1, "Ada"]],
+        affected_rows: 1,
+        execution_time_ms: 1,
+      };
+    },
+  });
+
+  await exporter.exportCsv([]);
+
+  assert.equal(fullExportCalls, 0);
+  assert.deepEqual(vi.mocked(api.exportQueryResultCsv).mock.calls[0]?.slice(1, 3), [["id", "name"], []]);
+});
diff --git a/packages/app-tests/dataGridInfiniteScroll.test.ts b/packages/app-tests/dataGridInfiniteScroll.test.ts
new file mode 100644
index 0000000..60d016d
--- /dev/null
+++ b/packages/app-tests/dataGridInfiniteScroll.test.ts
@@ -0,0 +1,25 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { dataGridScrollPosition, isDataGridNearScrollBottom, shouldCheckInfiniteScrollAfterScroll } from "../../apps/desktop/src/lib/dataGrid/dataGridInfiniteScroll.ts";
+
+test("horizontal-only scroll does not check infinite scroll", () => {
+  assert.equal(shouldCheckInfiniteScrollAfterScroll(dataGridScrollPosition(240, 0), dataGridScrollPosition(240, 180)), false);
+});
+
+test("shift-wheel horizontal scroll near the bottom does not check infinite scroll", () => {
+  assert.equal(isDataGridNearScrollBottom({ scrollTop: 0, scrollHeight: 80, clientHeight: 120 }), true);
+  assert.equal(shouldCheckInfiniteScrollAfterScroll(dataGridScrollPosition(0, 0), dataGridScrollPosition(0, 320)), false);
+});
+
+test("vertical scroll checks infinite scroll even when horizontal offset also changes", () => {
+  assert.equal(shouldCheckInfiniteScrollAfterScroll(dataGridScrollPosition(240, 0), dataGridScrollPosition(360, 180)), true);
+});
+
+test("first scroll position only establishes the infinite scroll baseline", () => {
+  assert.equal(shouldCheckInfiniteScrollAfterScroll(undefined, dataGridScrollPosition(360, 180)), false);
+});
+
+test("near-bottom check matches the grid threshold", () => {
+  assert.equal(isDataGridNearScrollBottom({ scrollTop: 801, scrollHeight: 1000, clientHeight: 100 }), true);
+  assert.equal(isDataGridNearScrollBottom({ scrollTop: 800, scrollHeight: 1000, clientHeight: 100 }), false);
+});
diff --git a/packages/app-tests/dataGridPagination.test.ts b/packages/app-tests/dataGridPagination.test.ts
new file mode 100644
index 0000000..ca54de3
--- /dev/null
+++ b/packages/app-tests/dataGridPagination.test.ts
@@ -0,0 +1,93 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { canGoNextDataGridPage } from "../../apps/desktop/src/lib/dataGrid/dataGridPagination.ts";
+
+test("known total disables next page at the last exact page", () => {
+  assert.equal(
+    canGoNextDataGridPage({
+      rowCount: 1,
+      pageSize: 1,
+      pageOffset: 8,
+      totalRowCount: 9,
+    }),
+    false,
+  );
+});
+
+test("known total allows next page before the last page", () => {
+  assert.equal(
+    canGoNextDataGridPage({
+      rowCount: 1,
+      pageSize: 1,
+      pageOffset: 7,
+      totalRowCount: 9,
+    }),
+    true,
+  );
+});
+
+test("backend hasMore takes precedence over a stale known total", () => {
+  assert.equal(
+    canGoNextDataGridPage({
+      hasMore: true,
+      rowCount: 1,
+      pageSize: 1,
+      pageOffset: 8,
+      totalRowCount: 9,
+    }),
+    true,
+  );
+});
+
+test("unknown total falls back to full-page heuristic", () => {
+  assert.equal(canGoNextDataGridPage({ rowCount: 1, pageSize: 1 }), true);
+  assert.equal(canGoNextDataGridPage({ rowCount: 0, pageSize: 1 }), false);
+});
+
+// --- auto-redirect page calculation after refresh ---
+// These tests document the math used in DataGrid.vue's loading watcher:
+//   lastPageNum = Math.max(1, Math.ceil(total / pageSize))
+//   redirect when currentPage > lastPageNum
+
+test("auto-redirect: current page beyond last page after data deletion — should redirect", () => {
+  // user on page 5, data shrinks to 200 rows, pageSize=100 → last page=2
+  const total = 200;
+  const pageSize = 100;
+  const currentPage = 5;
+  const lastPageNum = Math.max(1, Math.ceil(total / pageSize));
+  assert.equal(lastPageNum, 2);
+  assert.equal(currentPage > lastPageNum, true, "redirect should be triggered");
+  assert.equal((lastPageNum - 1) * pageSize, 100, "paginate offset for last page should be 100");
+});
+
+test("auto-redirect: current page still valid after partial deletion — no redirect", () => {
+  // user on page 5, data still has 500 rows → last page stays 5
+  const total = 500;
+  const pageSize = 100;
+  const currentPage = 5;
+  const lastPageNum = Math.max(1, Math.ceil(total / pageSize));
+  assert.equal(lastPageNum, 5);
+  assert.equal(currentPage > lastPageNum, false, "no redirect should be triggered");
+});
+
+test("auto-redirect: fewer rows than one page — redirects to page 1", () => {
+  // user on page 3, data shrinks to 30 rows, pageSize=100 → last page=1
+  const total = 30;
+  const pageSize = 100;
+  const currentPage = 3;
+  const lastPageNum = Math.max(1, Math.ceil(total / pageSize));
+  assert.equal(lastPageNum, 1, "ceil(30/100)=1, max(1,1)=1");
+  assert.equal(currentPage > lastPageNum, true, "redirect should be triggered");
+  assert.equal((lastPageNum - 1) * pageSize, 0, "paginate offset for page 1 should be 0");
+});
+
+test("auto-redirect: total is zero — guard prevents redirect attempt", () => {
+  // When total=0, the '!total || total <= 0' guard fires and skips the redirect
+  const total = 0;
+  assert.equal(!total || total <= 0, true, "guard should prevent redirect when total is 0");
+});
+
+test("auto-redirect: total is undefined — guard prevents redirect attempt", () => {
+  const total = undefined;
+  assert.equal(!total || (total as any) <= 0, true, "guard should prevent redirect when total is unknown");
+});
diff --git a/packages/app-tests/dataGridProps.test.ts b/packages/app-tests/dataGridProps.test.ts
new file mode 100644
index 0000000..c571837
--- /dev/null
+++ b/packages/app-tests/dataGridProps.test.ts
@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "vitest";
+import { compileScript, parse } from "vue/compiler-sfc";
+
+function compiledDataGridScript(): string {
+  const source = readFileSync("apps/desktop/src/components/grid/DataGrid.vue", "utf8");
+  const { descriptor } = parse(source, { filename: "DataGrid.vue" });
+  return compileScript(descriptor, { id: "data-grid-props-test" }).content;
+}
+
+test("row action limit props default to undefined when omitted", () => {
+  const compiled = compiledDataGridScript();
+
+  // Vue Boolean props normally cast an absent prop to false. DataGrid callers
+  // omit these props to mean "not restricted", so the runtime default matters.
+  assert.match(compiled, /allowInsertRows:\s*\{\s*type:\s*Boolean,\s*required:\s*false,\s*default:\s*undefined\s*\}/);
+  assert.match(compiled, /allowDeleteRows:\s*\{\s*type:\s*Boolean,\s*required:\s*false,\s*default:\s*undefined\s*\}/);
+});
diff --git a/packages/app-tests/dataGridSaveUi.test.ts b/packages/app-tests/dataGridSaveUi.test.ts
new file mode 100644
index 0000000..4ac7781
--- /dev/null
+++ b/packages/app-tests/dataGridSaveUi.test.ts
@@ -0,0 +1,73 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { dataGridSaveActionMode, dataGridSaveToolbarState } from "../../apps/desktop/src/lib/dataGrid/dataGridSaveUi.ts";
+
+test("uses concise save and commit labels for the primary grid save action", () => {
+  assert.deepEqual(dataGridSaveActionMode({ pendingChangeCount: 3, useTransaction: true }), {
+    labelKey: "grid.commit",
+    tooltipKey: "grid.transactionSaveHint",
+    secondaryActionKey: "grid.rollback",
+  });
+
+  assert.deepEqual(dataGridSaveActionMode({ pendingChangeCount: 3, useTransaction: false }), {
+    labelKey: "grid.save",
+    tooltipKey: "grid.nonTransactionalSaveHint",
+    secondaryActionKey: "grid.discard",
+  });
+});
+
+test("keeps grid save actions visible for editable grids even without pending changes", () => {
+  assert.deepEqual(
+    dataGridSaveToolbarState({
+      editable: true,
+      hasSaveTarget: true,
+      hasPendingChanges: false,
+      isSaving: false,
+    }),
+    {
+      showActions: true,
+      actionsDisabled: true,
+    },
+  );
+
+  assert.deepEqual(
+    dataGridSaveToolbarState({
+      editable: true,
+      hasSaveTarget: true,
+      hasPendingChanges: true,
+      isSaving: false,
+    }),
+    {
+      showActions: true,
+      actionsDisabled: false,
+    },
+  );
+});
+
+test("hides grid save actions when a grid cannot save edits", () => {
+  assert.deepEqual(
+    dataGridSaveToolbarState({
+      editable: false,
+      hasSaveTarget: true,
+      hasPendingChanges: false,
+      isSaving: false,
+    }),
+    {
+      showActions: false,
+      actionsDisabled: true,
+    },
+  );
+
+  assert.deepEqual(
+    dataGridSaveToolbarState({
+      editable: true,
+      hasSaveTarget: false,
+      hasPendingChanges: true,
+      isSaving: false,
+    }),
+    {
+      showActions: false,
+      actionsDisabled: true,
+    },
+  );
+});
diff --git a/packages/app-tests/dataGridSelection.test.ts b/packages/app-tests/dataGridSelection.test.ts
new file mode 100644
index 0000000..0b8eb8b
--- /dev/null
+++ b/packages/app-tests/dataGridSelection.test.ts
@@ -0,0 +1,184 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { computed, ref } from "vue";
+import { useDataGridSelection } from "../../apps/desktop/src/composables/useDataGridSelection.ts";
+
+function createSelection() {
+  return useDataGridSelection({
+    columns: computed(() => ["id", "name", "note"]),
+    displayItems: computed(() => [
+      {
+        id: 0,
+        sourceIndex: 0,
+        data: [1, "Ada", "math"],
+        isNew: false,
+        isDeleted: false,
+        isDirtyCol: [false, false, false],
+        status: "clean",
+      },
+      {
+        id: 1,
+        sourceIndex: 1,
+        data: [2, "Bob", "quote"],
+        isNew: false,
+        isDeleted: false,
+        isDirtyCol: [false, false, false],
+        status: "clean",
+      },
+      {
+        id: 2,
+        sourceIndex: 2,
+        data: [3, "O'Hara", null],
+        isNew: false,
+        isDeleted: false,
+        isDirtyCol: [false, false, false],
+        status: "clean",
+      },
+    ]),
+    editingCell: ref(null),
+    showTranspose: ref(false),
+    transposeRowIndex: ref(null),
+    gridRef: ref(undefined),
+  });
+}
+
+function mouseEvent(options: Partial<MouseEvent> = {}): MouseEvent {
+  return {
+    button: 0,
+    preventDefault() {},
+    ...options,
+  } as MouseEvent;
+}
+
+function createSelectionWithDraftRow() {
+  return useDataGridSelection({
+    columns: computed(() => ["id", "name"]),
+    displayItems: computed(() => [
+      {
+        id: 0,
+        sourceIndex: 0,
+        data: [1, "Ada"],
+        isNew: false,
+        isDeleted: false,
+        isDirtyCol: [false, false],
+        status: "clean",
+      },
+      {
+        id: Number.MIN_SAFE_INTEGER,
+        data: [null, null],
+        isNew: false,
+        isDraft: true,
+        isDeleted: false,
+        isDirtyCol: [false, false],
+        status: "draft",
+      },
+    ]),
+    editingCell: ref(null),
+    showTranspose: ref(false),
+    transposeRowIndex: ref(null),
+    gridRef: ref(undefined),
+  });
+}
+
+test("cell selection does not read row data before a range exists", () => {
+  let displayItemsReads = 0;
+  const selection = useDataGridSelection({
+    columns: computed(() => ["id", "name"]),
+    displayItems: computed(() => {
+      displayItemsReads += 1;
+      return [
+        {
+          id: 0,
+          sourceIndex: 0,
+          data: [1, "Ada"],
+          isNew: false,
+          isDeleted: false,
+          isDirtyCol: [false, false],
+          status: "clean",
+        },
+      ];
+    }),
+    editingCell: ref(null),
+    showTranspose: ref(false),
+    transposeRowIndex: ref(null),
+    gridRef: ref(undefined),
+  });
+
+  assert.equal(selection.hasCellSelection.value, false);
+  assert.equal(displayItemsReads, 0);
+});
+
+test("all-cell selection excludes the quick entry draft row from selected data", () => {
+  const selection = createSelectionWithDraftRow();
+
+  selection.selectAllCells();
+
+  assert.deepEqual(selection.selectedCells.value, {
+    columns: ["id", "name"],
+    rows: [[1, "Ada"]],
+  });
+  assert.equal(selection.selectedCellCount.value, 2);
+});
+
+test("column selection excludes the quick entry draft row from selected data", () => {
+  const selection = createSelectionWithDraftRow();
+
+  selection.selectColumn(1);
+
+  assert.deepEqual(selection.selectedCells.value, {
+    columns: ["name"],
+    rows: [["Ada"]],
+  });
+  assert.equal(selection.selectedCellCount.value, 1);
+});
+
+test("discrete draft cell selection is excluded from selected cell count", () => {
+  const selection = createSelectionWithDraftRow();
+
+  selection.selectSingleCell(1, 0);
+  selection.handleDataCellMousedown(1, 1, Number.MIN_SAFE_INTEGER, mouseEvent({ ctrlKey: true }));
+
+  assert.deepEqual(selection.selectedCells.value, {
+    columns: [],
+    rows: [],
+  });
+  assert.equal(selection.selectedCellCount.value, 0);
+  assert.equal(selection.hasCellSelection.value, false);
+});
+
+test("mixed discrete cell selection counts only real data cells", () => {
+  const selection = createSelectionWithDraftRow();
+
+  selection.selectSingleCell(0, 0);
+  selection.handleDataCellMousedown(1, 1, Number.MIN_SAFE_INTEGER, mouseEvent({ ctrlKey: true }));
+
+  assert.deepEqual(selection.selectedCells.value, {
+    columns: ["id"],
+    rows: [[1]],
+  });
+  assert.equal(selection.selectedCellCount.value, 1);
+});
+
+test("ctrl clicking cells toggles only the clicked cells", () => {
+  const selection = createSelection();
+
+  selection.selectSingleCell(0, 0);
+  selection.handleDataCellMousedown(2, 2, 2, mouseEvent({ ctrlKey: true }));
+
+  assert.equal(selection.cellIsSelected(0, 0), true);
+  assert.equal(selection.cellIsSelected(2, 2), true);
+  assert.equal(selection.cellIsSelected(1, 1), false);
+  assert.equal(selection.selectedCellCount.value, 2);
+});
+
+test("shift clicking cells keeps range selection", () => {
+  const selection = createSelection();
+
+  selection.selectSingleCell(0, 0);
+  selection.handleDataCellMousedown(2, 2, 2, mouseEvent({ shiftKey: true }));
+
+  assert.equal(selection.cellIsSelected(0, 0), true);
+  assert.equal(selection.cellIsSelected(1, 1), true);
+  assert.equal(selection.cellIsSelected(2, 2), true);
+  assert.equal(selection.selectedCellCount.value, 9);
+});
diff --git a/packages/app-tests/dataGridSort.test.ts b/packages/app-tests/dataGridSort.test.ts
new file mode 100644
index 0000000..c9378dc
--- /dev/null
+++ b/packages/app-tests/dataGridSort.test.ts
@@ -0,0 +1,52 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { sortDataGridRowIndexes, sortDataGridRows } from "../../apps/desktop/src/lib/dataGrid/dataGridSort.ts";
+
+test("sortDataGridRows sorts numbers numerically and keeps null values last", () => {
+  const rows = [
+    [10, "ten"],
+    [2, "two"],
+    [null, "none"],
+    [1, "one"],
+  ];
+
+  assert.deepEqual(sortDataGridRows(rows, 0, "asc"), [
+    [1, "one"],
+    [2, "two"],
+    [10, "ten"],
+    [null, "none"],
+  ]);
+  assert.deepEqual(sortDataGridRows(rows, 0, "desc"), [
+    [10, "ten"],
+    [2, "two"],
+    [1, "one"],
+    [null, "none"],
+  ]);
+});
+
+test("sortDataGridRows uses natural string order and keeps equal values stable", () => {
+  const rows = [
+    ["item-10", "first"],
+    ["item-2", "second"],
+    ["item-2", "third"],
+  ];
+
+  assert.deepEqual(sortDataGridRows(rows, 0, "asc"), [
+    ["item-2", "second"],
+    ["item-2", "third"],
+    ["item-10", "first"],
+  ]);
+});
+
+test("sortDataGridRows sorts ISO date strings by time", () => {
+  const rows = [["2026-02-01"], ["2025-12-31"], ["2026-01-01"]];
+
+  assert.deepEqual(sortDataGridRows(rows, 0, "asc"), [["2025-12-31"], ["2026-01-01"], ["2026-02-01"]]);
+});
+
+test("sortDataGridRowIndexes preserves stable source ordering", () => {
+  const rows = [["item-10"], ["item-2"], ["item-2"]];
+
+  assert.deepEqual(sortDataGridRowIndexes(rows, 0, "asc"), [1, 2, 0]);
+  assert.deepEqual(sortDataGridRowIndexes(rows, 0, "desc"), [0, 1, 2]);
+});
diff --git a/packages/app-tests/dataGridTemporalEditor.test.ts b/packages/app-tests/dataGridTemporalEditor.test.ts
new file mode 100644
index 0000000..7fa3d01
--- /dev/null
+++ b/packages/app-tests/dataGridTemporalEditor.test.ts
@@ -0,0 +1,29 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { parseTemporalInputValue, stepTemporalInputValue } from "../../apps/desktop/src/lib/dataGrid/dataGridTemporalEditor.ts";
+
+test("steps datetime date and time parts", () => {
+  assert.equal(stepTemporalInputValue("2025-07-01 13:41:49", "datetime", "day", 1), "2025-07-02 13:41:49");
+  assert.equal(stepTemporalInputValue("2025-07-01 13:41:49", "datetime", "month", 1), "2025-08-01 13:41:49");
+  assert.equal(stepTemporalInputValue("2025-07-01 13:41:49", "datetime", "hour", 1), "2025-07-01 14:41:49");
+  assert.equal(stepTemporalInputValue("2025-07-01 13:41:49", "datetime", "minute", -1), "2025-07-01 13:40:49");
+  assert.equal(stepTemporalInputValue("2025-07-01 13:41:49", "datetime", "second", 1), "2025-07-01 13:41:50");
+});
+
+test("clamps stepped dates to the target month", () => {
+  assert.equal(stepTemporalInputValue("2025-01-31", "date", "month", 1), "2025-02-28");
+  assert.equal(stepTemporalInputValue("2024-01-31", "date", "month", 1), "2024-02-29");
+});
+
+test("wraps stepped time values", () => {
+  assert.equal(stepTemporalInputValue("23:59:59", "time", "hour", 1), "00:59:59");
+  assert.equal(stepTemporalInputValue("23:59:59", "time", "minute", 1), "23:00:59");
+  assert.equal(stepTemporalInputValue("23:59:59", "time", "second", 1), "23:59:00");
+});
+
+test("parses directly typed datetime values for MySQL-compatible editing", () => {
+  assert.equal(parseTemporalInputValue("2026-07-08 12:34:56", "datetime"), "2026-07-08 12:34:56");
+  assert.equal(parseTemporalInputValue("2026-07-08T12:34", "datetime"), "2026-07-08 12:34:00");
+  assert.equal(parseTemporalInputValue("not-a-date", "datetime"), "not-a-date");
+  assert.equal(parseTemporalInputValue("not-a-dateT12:34", "datetime"), "not-a-dateT12:34");
+});
diff --git a/packages/app-tests/dataGridTranspose.test.ts b/packages/app-tests/dataGridTranspose.test.ts
new file mode 100644
index 0000000..0eebbd2
--- /dev/null
+++ b/packages/app-tests/dataGridTranspose.test.ts
@@ -0,0 +1,311 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import {
+  buildTransposeRows,
+  buildVisibleTransposeRows,
+  transposeRecordIndexesForMode,
+  nextContextTransposeState,
+  nextAppendedTransposeState,
+  nextKeyboardTransposeState,
+  nextTransposeState,
+  nextTransposeStateForRecordCount,
+  transposeAnchorRowIndex,
+  transposeFieldWidth,
+  transposeScrollLeftForRecord,
+  visibleTransposeRecordWindow,
+} from "../../apps/desktop/src/lib/dataGrid/dataGridTranspose.ts";
+
+test("row number double click opens transpose for a row", () => {
+  assert.deepEqual(nextTransposeState(false, null, 2), {
+    showTranspose: true,
+    transposeRowIndex: 2,
+  });
+});
+
+test("row number double click switches transpose to another row", () => {
+  assert.deepEqual(nextTransposeState(true, 2, 4), {
+    showTranspose: true,
+    transposeRowIndex: 4,
+  });
+});
+
+test("row number double click closes transpose for the same row", () => {
+  assert.deepEqual(nextTransposeState(true, 2, 2), {
+    showTranspose: false,
+    transposeRowIndex: null,
+  });
+});
+
+test("context menu transpose closes when invoked for the current anchor row", () => {
+  assert.deepEqual(
+    nextContextTransposeState({
+      showTranspose: true,
+      transposeRowIndex: 2,
+      requestedRowIndex: 3,
+      rowIds: [10, 11, 12, 13, 14],
+      selectedRowIds: new Set([12, 13]),
+      selectedRange: null,
+    }),
+    {
+      showTranspose: false,
+      transposeRowIndex: null,
+    },
+  );
+});
+
+test("builds one virtualizable transpose row per field with all record values", () => {
+  const rows = buildTransposeRows({
+    columns: ["id", "name", "notes"],
+    records: [
+      [1, "Ada", null],
+      [2, "Grace", "compiler"],
+    ],
+    typeByColumn: new Map([
+      ["id", "int"],
+      ["name", "varchar"],
+    ]),
+    displayValue: (value) => (value === null ? "NULL" : String(value)),
+  });
+
+  assert.deepEqual(rows, [
+    {
+      id: "0:id",
+      column: "id",
+      type: "int",
+      values: [
+        { value: 1, display: "1", isNull: false },
+        { value: 2, display: "2", isNull: false },
+      ],
+    },
+    {
+      id: "1:name",
+      column: "name",
+      type: "varchar",
+      values: [
+        { value: "Ada", display: "Ada", isNull: false },
+        { value: "Grace", display: "Grace", isNull: false },
+      ],
+    },
+    {
+      id: "2:notes",
+      column: "notes",
+      type: "",
+      values: [
+        { value: null, display: "NULL", isNull: true },
+        { value: "compiler", display: "compiler", isNull: false },
+      ],
+    },
+  ]);
+});
+
+test("builds transpose rows for only the visible record window", () => {
+  const formatted: string[] = [];
+  const rows = buildVisibleTransposeRows({
+    columns: ["id", "name"],
+    records: [
+      [1, "Ada"],
+      [2, "Grace"],
+      [3, "Linus"],
+    ],
+    recordIndexes: [1, 2],
+    displayValue: (value, column, _columnIndex, recordIndex) => {
+      formatted.push(`${recordIndex}:${column}`);
+      return String(value);
+    },
+  });
+
+  assert.deepEqual(
+    rows.map((row) => ({
+      column: row.column,
+      values: row.values.map((cell) => ({ recordIndex: cell.recordIndex, display: cell.display })),
+    })),
+    [
+      {
+        column: "id",
+        values: [
+          { recordIndex: 1, display: "2" },
+          { recordIndex: 2, display: "3" },
+        ],
+      },
+      {
+        column: "name",
+        values: [
+          { recordIndex: 1, display: "Grace" },
+          { recordIndex: 2, display: "Linus" },
+        ],
+      },
+    ],
+  );
+  assert.deepEqual(formatted, ["1:id", "2:id", "1:name", "2:name"]);
+});
+
+test("builds visible transpose rows from mapped source column indexes", () => {
+  const rows = buildVisibleTransposeRows({
+    columns: ["name"],
+    records: [
+      [1, "Ada"],
+      [2, "Grace"],
+    ],
+    recordIndexes: [0],
+    valueIndexes: [1],
+    displayValue: (value) => String(value),
+  });
+
+  assert.equal(rows[0].values[0].display, "Ada");
+  assert.equal(rows[0].values[0].valueIndex, 1);
+});
+
+test("single-row transpose only includes the active record", () => {
+  assert.deepEqual(
+    transposeRecordIndexesForMode({
+      multiRow: false,
+      activeRecordIndex: 3,
+      totalRecords: 10,
+      visibleRecordIndexes: [1, 2, 3, 4],
+    }),
+    [3],
+  );
+});
+
+test("single-row transpose clamps the active record into range", () => {
+  assert.deepEqual(
+    transposeRecordIndexesForMode({
+      multiRow: false,
+      activeRecordIndex: 12,
+      totalRecords: 10,
+      visibleRecordIndexes: [7, 8, 9],
+    }),
+    [9],
+  );
+});
+
+test("multi-row transpose keeps the visible record window", () => {
+  assert.deepEqual(
+    transposeRecordIndexesForMode({
+      multiRow: true,
+      activeRecordIndex: 3,
+      totalRecords: 10,
+      visibleRecordIndexes: [1, 2, 3, 4],
+    }),
+    [1, 2, 3, 4],
+  );
+});
+
+test("keyboard transpose opens from the selected cell row and closes when active", () => {
+  assert.deepEqual(
+    nextKeyboardTransposeState({
+      showTranspose: false,
+      transposeRowIndex: null,
+      requestedRowIndex: 3,
+      rowIds: [10, 11, 12, 13, 14],
+      selectedRowIds: new Set(),
+      selectedRange: null,
+    }),
+    {
+      showTranspose: true,
+      transposeRowIndex: 3,
+    },
+  );
+
+  assert.deepEqual(
+    nextKeyboardTransposeState({
+      showTranspose: true,
+      transposeRowIndex: 3,
+      requestedRowIndex: 3,
+      rowIds: [10, 11, 12, 13, 14],
+      selectedRowIds: new Set(),
+      selectedRange: null,
+    }),
+    {
+      showTranspose: false,
+      transposeRowIndex: null,
+    },
+  );
+});
+
+test("transpose follows appended rows when already open", () => {
+  assert.deepEqual(nextAppendedTransposeState(true, 4), {
+    showTranspose: true,
+    transposeRowIndex: 3,
+  });
+  assert.deepEqual(nextAppendedTransposeState(false, 4), {
+    showTranspose: false,
+    transposeRowIndex: null,
+  });
+});
+
+test("transpose state is preserved and clamped after record refresh", () => {
+  assert.deepEqual(nextTransposeStateForRecordCount(true, 4, 3), {
+    showTranspose: true,
+    transposeRowIndex: 2,
+  });
+  assert.deepEqual(nextTransposeStateForRecordCount(true, 1, 0), {
+    showTranspose: false,
+    transposeRowIndex: null,
+  });
+});
+
+test("calculates a horizontal record window with spacer widths", () => {
+  assert.deepEqual(
+    visibleTransposeRecordWindow({
+      totalRecords: 100,
+      scrollLeft: 680,
+      viewportWidth: 720,
+      pinnedWidth: 320,
+      recordWidth: 160,
+      overscan: 1,
+    }),
+    {
+      start: 1,
+      end: 7,
+      beforeWidth: 160,
+      afterWidth: 14880,
+    },
+  );
+});
+
+test("uses the first selected row as the transpose anchor when context row is inside row selection", () => {
+  assert.equal(
+    transposeAnchorRowIndex({
+      requestedRowIndex: 3,
+      rowIds: [10, 11, 12, 13, 14, 15],
+      selectedRowIds: new Set([12, 13, 14]),
+      selectedRange: null,
+    }),
+    2,
+  );
+});
+
+test("uses the first selected cell range row as the transpose anchor when context row is inside range", () => {
+  assert.equal(
+    transposeAnchorRowIndex({
+      requestedRowIndex: 5,
+      rowIds: [10, 11, 12, 13, 14, 15],
+      selectedRowIds: new Set(),
+      selectedRange: { startRow: 2, endRow: 5, startCol: 0, endCol: 2 },
+    }),
+    2,
+  );
+});
+
+test("sizes the transpose field column from visible field names", () => {
+  assert.equal(transposeFieldWidth(["id", "iso3", "year"]), 104);
+  assert.equal(transposeFieldWidth(["country_name"]), 128);
+});
+
+test("caps the transpose field column width for long field names", () => {
+  assert.equal(transposeFieldWidth(["a_very_long_metric_column_name"]), 220);
+});
+
+test("aligns the selected transpose record at the start of the scrollable records", () => {
+  assert.equal(
+    transposeScrollLeftForRecord({
+      recordIndex: 55,
+      totalRecords: 100,
+      viewportWidth: 1200,
+      pinnedWidth: 104,
+      recordWidth: 168,
+    }),
+    9240,
+  );
+});
diff --git a/packages/app-tests/dataTabActivation.test.ts b/packages/app-tests/dataTabActivation.test.ts
new file mode 100644
index 0000000..82652e2
--- /dev/null
+++ b/packages/app-tests/dataTabActivation.test.ts
@@ -0,0 +1,59 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { canActivateExistingDataTableTab } from "../../apps/desktop/src/lib/tabs/dataTabActivation.ts";
+import type { QueryTab } from "../../apps/desktop/src/types/database.ts";
+
+function dataTab(overrides: Partial<QueryTab> = {}): QueryTab {
+  return {
+    id: "tab-1",
+    title: "users",
+    connectionId: "conn-1",
+    database: "app",
+    sql: "select * from users",
+    isExecuting: false,
+    isCancelling: false,
+    isExplaining: false,
+    mode: "data",
+    ...overrides,
+  };
+}
+
+test("activates an existing data table tab while it is still loading", () => {
+  assert.equal(canActivateExistingDataTableTab(dataTab({ isExecuting: true })), true);
+});
+
+test("activates an existing data table tab with a usable result", () => {
+  assert.equal(
+    canActivateExistingDataTableTab(
+      dataTab({
+        result: {
+          columns: ["id"],
+          rows: [[1]],
+          affected_rows: 0,
+          execution_time_ms: 1,
+        },
+      }),
+    ),
+    true,
+  );
+});
+
+test("reloads restored data table tabs without a result", () => {
+  assert.equal(canActivateExistingDataTableTab(dataTab()), false);
+});
+
+test("reloads existing data table tabs showing an error result", () => {
+  assert.equal(
+    canActivateExistingDataTableTab(
+      dataTab({
+        result: {
+          columns: ["Error"],
+          rows: [["MySQL connection failed: Input/output error: No route to host (os error 65)"]],
+          affected_rows: 0,
+          execution_time_ms: 0,
+        },
+      }),
+    ),
+    false,
+  );
+});
diff --git a/packages/app-tests/databaseCapabilities.test.ts b/packages/app-tests/databaseCapabilities.test.ts
new file mode 100644
index 0000000..93cc8cb
--- /dev/null
+++ b/packages/app-tests/databaseCapabilities.test.ts
@@ -0,0 +1,18 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { isSchemaAware, supportsDatabaseCreation, usesTreeSchemaMode } from "../../apps/desktop/src/lib/database/databaseCapabilities.ts";
+
+test("TDengine uses database/catalog tree nodes without a schema layer", () => {
+  assert.equal(isSchemaAware("tdengine"), false);
+  assert.equal(usesTreeSchemaMode("tdengine"), false);
+});
+
+test("IoTDB keeps schema-qualified paths without showing a duplicate schema node", () => {
+  assert.equal(isSchemaAware("iotdb"), true);
+  assert.equal(usesTreeSchemaMode("iotdb"), false);
+});
+
+test("GoldenDB and Vastbase expose database creation", () => {
+  assert.equal(supportsDatabaseCreation("goldendb"), true);
+  assert.equal(supportsDatabaseCreation("vastbase"), true);
+});
diff --git a/packages/app-tests/databaseExportPlan.test.ts b/packages/app-tests/databaseExportPlan.test.ts
new file mode 100644
index 0000000..f5170c0
--- /dev/null
+++ b/packages/app-tests/databaseExportPlan.test.ts
@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { buildAllDatabaseExportPlan } from "../../apps/desktop/src/lib/export/databaseExport.ts";
+
+test("all-database export includes every schema for schema-aware databases", () => {
+  const plan = buildAllDatabaseExportPlan({
+    databases: ["app", "analytics"],
+    schemaAware: true,
+    schemasByDatabase: {
+      app: ["public", "private"],
+      analytics: ["reporting"],
+    },
+  });
+
+  assert.deepEqual(plan, [
+    { database: "app", schema: "public", fileStem: "app.public", displayName: "app.public" },
+    { database: "app", schema: "private", fileStem: "app.private", displayName: "app.private" },
+    { database: "analytics", schema: "reporting", fileStem: "analytics", displayName: "analytics" },
+  ]);
+});
+
+test("all-database export uses the database as schema for non-schema-aware databases", () => {
+  const plan = buildAllDatabaseExportPlan({
+    databases: ["app", "analytics"],
+    schemaAware: false,
+    schemasByDatabase: {
+      app: ["ignored"],
+    },
+  });
+
+  assert.deepEqual(plan, [
+    { database: "app", schema: "app", fileStem: "app", displayName: "app" },
+    { database: "analytics", schema: "analytics", fileStem: "analytics", displayName: "analytics" },
+  ]);
+});
diff --git a/packages/app-tests/databaseIconAssets.test.ts b/packages/app-tests/databaseIconAssets.test.ts
new file mode 100644
index 0000000..fc45d42
--- /dev/null
+++ b/packages/app-tests/databaseIconAssets.test.ts
@@ -0,0 +1,11 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { test } from "vitest";
+
+test("Kafka database icon includes a light contrast stroke for dark themes", () => {
+  const svg = readFileSync(path.resolve("apps/desktop/public/icons/database/kafka.svg"), "utf8");
+
+  assert.match(svg, /stroke="#(?:F8FAFC|E5E7EB|FFFFFF)"/i);
+  assert.match(svg, /fill="#231F20"/i);
+});
diff --git a/packages/app-tests/databaseSearch.test.ts b/packages/app-tests/databaseSearch.test.ts
new file mode 100644
index 0000000..55eed2c
--- /dev/null
+++ b/packages/app-tests/databaseSearch.test.ts
@@ -0,0 +1,28 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import type { ColumnInfo } from "../../apps/desktop/src/types/database.ts";
+import { findMatchedSearchColumns, isNumericSearchColumn, isTextSearchColumn } from "../../apps/desktop/src/lib/database/databaseSearch.ts";
+
+function col(name: string, dataType: string, primary = false): ColumnInfo {
+  return {
+    name,
+    data_type: dataType,
+    is_nullable: true,
+    column_default: null,
+    is_primary_key: primary,
+    extra: null,
+  };
+}
+
+test("classifies searchable database search columns", () => {
+  assert.equal(isTextSearchColumn(col("email", "varchar")), true);
+  assert.equal(isNumericSearchColumn(col("id", "bigint")), true);
+  assert.equal(isTextSearchColumn(col("payload", "blob")), false);
+  assert.equal(isNumericSearchColumn(col("payload", "blob")), false);
+});
+
+test("finds matched columns from returned rows", () => {
+  const matches = findMatchedSearchColumns(["id", "email", "note"], [42, "Alice@Example.com", "inactive"], [col("id", "integer", true), col("email", "varchar"), col("note", "text")], "alice");
+
+  assert.deepEqual(matches, ["email"]);
+});
diff --git a/packages/app-tests/databaseTree.test.ts b/packages/app-tests/databaseTree.test.ts
new file mode 100644
index 0000000..01ded45
--- /dev/null
+++ b/packages/app-tests/databaseTree.test.ts
@@ -0,0 +1,17 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { buildDatabaseTreeNodes, sortSidebarNames } from "../../apps/desktop/src/lib/database/databaseTree.ts";
+
+test("数据库节点按自然名称排序", () => {
+  const nodes = buildDatabaseTreeNodes("conn-1", [{ name: "db10" }, { name: "db2" }, { name: "campaign_data" }, { name: "cms" }, { name: "mk_campaign" }]);
+
+  assert.deepEqual(
+    nodes.map((node) => node.database),
+    ["campaign_data", "cms", "db2", "db10", "mk_campaign"],
+  );
+  assert.equal(nodes.find((node) => node.database === "mk_campaign")?.id, "conn-1:mk_campaign");
+});
+
+test("sidebar name sorting uses numeric-aware ordering", () => {
+  assert.deepEqual(sortSidebarNames(["db10", "db2", "db1"]), ["db1", "db2", "db10"]);
+});
diff --git a/packages/app-tests/databaseUserAdmin.test.ts b/packages/app-tests/databaseUserAdmin.test.ts
new file mode 100644
index 0000000..eabff81
--- /dev/null
+++ b/packages/app-tests/databaseUserAdmin.test.ts
@@ -0,0 +1,177 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import {
+  grantsFromQueryResult,
+  mysqlAlterUserAccountLockSql,
+  mysqlAlterUserPasswordSql,
+  mysqlCreateUserSql,
+  mysqlDropUserSql,
+  mysqlGrantPrivilegesSql,
+  mysqlPrivilegeTargetSql,
+  mysqlRevokePrivilegesSql,
+  mysqlShowGrantsSql,
+  mysqlUserAccount,
+  normalizeMySqlPrivileges,
+  postgresAlterRoleLoginSql,
+  postgresAlterRolePasswordSql,
+  postgresCreateRoleSql,
+  postgresDropRoleSql,
+  postgresGrantPrivilegesSql,
+  postgresListRolesSql,
+  postgresPrivilegeTargetSql,
+  postgresRevokePrivilegesSql,
+  postgresRoleLabel,
+  postgresShowGrantsSql,
+  quoteMySqlIdentifier,
+  quoteMySqlString,
+  quotePostgresIdentifier,
+  usersFromMySqlGranteeResult,
+  usersFromMySqlUserResult,
+  usersFromPostgresRolesResult,
+} from "../../apps/desktop/src/lib/database/databaseUserAdmin.ts";
+import type { QueryResult } from "../../apps/desktop/src/types/database.ts";
+
+function result(columns: string[], rows: QueryResult["rows"]): QueryResult {
+  return {
+    columns,
+    rows,
+    affected_rows: 0,
+    execution_time_ms: 1,
+  };
+}
+
+test("quotes MySQL account parts and identifiers", () => {
+  assert.equal(quoteMySqlString("app'user\\"), "'app''user\\\\'");
+  assert.equal(quoteMySqlIdentifier("tenant`01"), "`tenant``01`");
+  assert.equal(mysqlUserAccount({ user: "app'user", host: "10.0.0.%" }), "'app''user'@'10.0.0.%'");
+});
+
+test("builds MySQL user lifecycle SQL", () => {
+  const user = { user: "app", host: "%" };
+
+  assert.equal(mysqlShowGrantsSql(user), "SHOW GRANTS FOR 'app'@'%';");
+  assert.equal(mysqlCreateUserSql({ ...user, password: "secret" }), "CREATE USER 'app'@'%' IDENTIFIED BY 'secret';");
+  assert.equal(mysqlAlterUserPasswordSql(user, "new'secret"), "ALTER USER 'app'@'%' IDENTIFIED BY 'new''secret';");
+  assert.equal(mysqlAlterUserAccountLockSql(user, true), "ALTER USER 'app'@'%' ACCOUNT LOCK;");
+  assert.equal(mysqlAlterUserAccountLockSql(user, false), "ALTER USER 'app'@'%' ACCOUNT UNLOCK;");
+  assert.equal(mysqlDropUserSql(user), "DROP USER 'app'@'%';");
+});
+
+test("builds MySQL grant and revoke SQL with normalized privileges", () => {
+  const input = {
+    user: { user: "reporter", host: "localhost" },
+    privileges: ["select", " SELECT ", "show view"],
+    database: "analytics",
+    table: "daily`rollup",
+    grantOption: true,
+  };
+
+  assert.deepEqual(normalizeMySqlPrivileges(input.privileges), ["SELECT", "SHOW VIEW"]);
+  assert.equal(mysqlPrivilegeTargetSql("analytics", "daily`rollup"), "`analytics`.`daily``rollup`");
+  assert.equal(mysqlGrantPrivilegesSql(input), "GRANT SELECT, SHOW VIEW ON `analytics`.`daily``rollup` TO 'reporter'@'localhost' WITH GRANT OPTION;");
+  assert.equal(mysqlRevokePrivilegesSql(input), "REVOKE SELECT, SHOW VIEW ON `analytics`.`daily``rollup` FROM 'reporter'@'localhost';");
+  assert.equal(mysqlPrivilegeTargetSql("", ""), "*.*");
+});
+
+test("parses MySQL user result variants", () => {
+  assert.deepEqual(
+    usersFromMySqlUserResult(
+      result(
+        ["User", "Host", "plugin"],
+        [
+          ["root", "localhost", "caching_sha2_password"],
+          ["app", "%", null],
+        ],
+      ),
+    ),
+    [
+      { user: "root", host: "localhost", plugin: "caching_sha2_password" },
+      { user: "app", host: "%", plugin: undefined },
+    ],
+  );
+
+  assert.deepEqual(usersFromMySqlGranteeResult(result(["GRANTEE"], [["'app'@'%'"], ["'o''brien'@'localhost'"], ["CURRENT_USER"]])), [
+    { user: "app", host: "%" },
+    { user: "o'brien", host: "localhost" },
+  ]);
+});
+
+test("extracts grants from show grants result", () => {
+  assert.deepEqual(grantsFromQueryResult(result(["Grants for app@%"], [["GRANT SELECT ON `app`.* TO 'app'@'%'"], [null]])), ["GRANT SELECT ON `app`.* TO 'app'@'%'"]);
+});
+
+test("builds PostgreSQL role lifecycle SQL", () => {
+  const role = { user: 'report"reader', host: "LOGIN" };
+
+  assert.equal(quotePostgresIdentifier('report"reader'), '"report""reader"');
+  assert.equal(postgresRoleLabel(role), 'report"reader');
+  assert.equal(postgresCreateRoleSql({ ...role, password: "it'works", canLogin: true }), "CREATE ROLE \"report\"\"reader\" LOGIN PASSWORD 'it''works';");
+  assert.equal(postgresCreateRoleSql({ ...role, password: "secret", canLogin: false }), 'CREATE ROLE "report""reader" NOLOGIN PASSWORD \'secret\';');
+  assert.equal(postgresAlterRolePasswordSql(role, "next"), 'ALTER ROLE "report""reader" PASSWORD \'next\';');
+  assert.equal(postgresAlterRoleLoginSql(role, false), 'ALTER ROLE "report""reader" NOLOGIN;');
+  assert.equal(postgresAlterRoleLoginSql(role, true), 'ALTER ROLE "report""reader" LOGIN;');
+  assert.equal(postgresDropRoleSql(role), 'DROP ROLE "report""reader";');
+});
+
+test("builds PostgreSQL privilege and membership SQL", () => {
+  const user = { user: "reporter", host: "LOGIN" };
+
+  assert.equal(postgresPrivilegeTargetSql({ scope: "database", database: "analytics" }), 'DATABASE "analytics"');
+  assert.equal(postgresPrivilegeTargetSql({ scope: "schema", database: "mart" }), 'SCHEMA "mart"');
+  assert.equal(postgresPrivilegeTargetSql({ scope: "table", database: "mart", table: 'daily"rollup' }), 'TABLE "mart"."daily""rollup"');
+  assert.equal(postgresPrivilegeTargetSql({ scope: "table", database: "mart", table: "*" }), 'ALL TABLES IN SCHEMA "mart"');
+  assert.equal(
+    postgresGrantPrivilegesSql({
+      user,
+      scope: "database",
+      database: "analytics",
+      privileges: ["connect", "CREATE"],
+      grantOption: true,
+    }),
+    'GRANT CONNECT, CREATE ON DATABASE "analytics" TO "reporter" WITH GRANT OPTION;',
+  );
+  assert.equal(postgresRevokePrivilegesSql({ user, scope: "schema", database: "mart", privileges: ["usage"] }), 'REVOKE USAGE ON SCHEMA "mart" FROM "reporter";');
+  assert.equal(
+    postgresGrantPrivilegesSql({
+      user,
+      scope: "role",
+      database: "",
+      privileges: [],
+      role: "readonly",
+      grantOption: true,
+    }),
+    'GRANT "readonly" TO "reporter" WITH ADMIN OPTION;',
+  );
+  assert.equal(postgresRevokePrivilegesSql({ user, scope: "role", database: "", privileges: [], role: "readonly" }), 'REVOKE "readonly" FROM "reporter";');
+});
+
+test("parses PostgreSQL role rows", () => {
+  assert.deepEqual(
+    usersFromPostgresRolesResult(
+      result(
+        ["user", "host", "plugin"],
+        [
+          ["postgres", "LOGIN", "SUPERUSER, CREATEDB"],
+          ["readonly", "ROLE", ""],
+        ],
+      ),
+    ),
+    [
+      { user: "postgres", host: "LOGIN", plugin: "SUPERUSER, CREATEDB" },
+      { user: "readonly", host: "ROLE", plugin: "" },
+    ],
+  );
+});
+
+test("builds PostgreSQL role metadata SQL without directly requiring rolbypassrls", () => {
+  const listSql = postgresListRolesSql();
+  const grantsSql = postgresShowGrantsSql({ user: "reporter", host: "LOGIN" });
+
+  assert.match(listSql, /row_to_json\(r\)::text LIKE '%"rolbypassrls":true%'/);
+  assert.match(grantsSql, /row_to_json\(r\)::text LIKE '%"rolbypassrls":true%'/);
+  assert.doesNotMatch(listSql, /r\.rolbypassrls/);
+  assert.doesNotMatch(grantsSql, /r\.rolbypassrls/);
+  assert.match(grantsSql, /AS rolbypassrls/);
+  assert.match(grantsSql, /n\.nspname NOT LIKE 'pg~_%' ESCAPE '~'/);
+  assert.ok(!grantsSql.includes("ESCAPE '\\'"));
+});
diff --git a/packages/app-tests/dbAdminSql.test.ts b/packages/app-tests/dbAdminSql.test.ts
new file mode 100644
index 0000000..9ad9e5e
--- /dev/null
+++ b/packages/app-tests/dbAdminSql.test.ts
@@ -0,0 +1,23 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+
+import { buildGetSchemaCommentSql, buildSetSchemaCommentSql, supportsSchemaComment } from "../../apps/desktop/src/lib/database/dbAdminSql.ts";
+
+test("postgres schema comment SQL quotes identifiers and literals", () => {
+  assert.equal(supportsSchemaComment("postgres"), true);
+  assert.equal(supportsSchemaComment("mysql"), false);
+  assert.equal(buildSetSchemaCommentSql({ databaseType: "postgres", name: 'tenant"one', comment: "Owner's area" }), `COMMENT ON SCHEMA "tenant""one" IS 'Owner''s area';`);
+});
+
+test("postgres schema comment SQL clears blank comments", () => {
+  assert.equal(buildSetSchemaCommentSql({ databaseType: "postgres", name: "analytics", comment: "  " }), `COMMENT ON SCHEMA "analytics" IS NULL;`);
+});
+
+test("postgres schema comment lookup uses pg_namespace description join", () => {
+  const sql = buildGetSchemaCommentSql({ databaseType: "postgres", name: "tenant's schema" });
+
+  assert.match(sql, /FROM pg_catalog\.pg_namespace n/);
+  assert.match(sql, /pg_catalog\.pg_description d/);
+  assert.match(sql, /d\.classoid = 'pg_namespace'::regclass/);
+  assert.match(sql, /WHERE n\.nspname = 'tenant''s schema';/);
+});
diff --git a/packages/app-tests/ddlExport.test.ts b/packages/app-tests/ddlExport.test.ts
new file mode 100644
index 0000000..a75d378
--- /dev/null
+++ b/packages/app-tests/ddlExport.test.ts
@@ -0,0 +1,28 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildSingleDdlExportFileContent, ensureSqlStatementTerminator, joinExportedDdls } from "../../apps/desktop/src/lib/export/ddlExport.ts";
+
+test("ensureSqlStatementTerminator appends a trailing semicolon when missing", () => {
+  assert.equal(ensureSqlStatementTerminator("CREATE TABLE `users` (\n  `id` int\n) ENGINE=InnoDB"), "CREATE TABLE `users` (\n  `id` int\n) ENGINE=InnoDB;");
+});
+
+test("ensureSqlStatementTerminator does not duplicate an existing trailing semicolon", () => {
+  assert.equal(ensureSqlStatementTerminator("CREATE VIEW v AS SELECT 1;"), "CREATE VIEW v AS SELECT 1;");
+});
+
+test("joinExportedDdls separates exported objects with blank lines and terminates each statement", () => {
+  assert.equal(
+    joinExportedDdls([
+      "CREATE TABLE `users` (`id` int)",
+      "CREATE TABLE `posts` (`id` int);",
+    ]),
+    "CREATE TABLE `users` (`id` int);\n\nCREATE TABLE `posts` (`id` int);\n",
+  );
+});
+
+test("buildSingleDdlExportFileContent emits a single importable statement with one trailing newline", () => {
+  assert.equal(
+    buildSingleDdlExportFileContent("  CREATE TABLE `users` (`id` int)  "),
+    "CREATE TABLE `users` (`id` int);\n",
+  );
+});
diff --git a/packages/app-tests/defaultDatabase.test.ts b/packages/app-tests/defaultDatabase.test.ts
new file mode 100644
index 0000000..6709329
--- /dev/null
+++ b/packages/app-tests/defaultDatabase.test.ts
@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { TREE_SCHEMA_DEFAULT_DATABASE_SELECT_VALUE, decodeSelectableDatabaseValue, encodeSelectableDatabaseValue, formatDatabaseLabel, isDefaultDatabase, resolveDefaultDatabase } from "../../apps/desktop/src/lib/database/defaultDatabase.ts";
+
+test("优先使用连接上已保存的默认数据库", () => {
+  assert.equal(resolveDefaultDatabase({ database: "analytics" }, ["app", "analytics"]), "analytics");
+});
+
+test("默认数据库为空时回退到首个可选数据库", () => {
+  assert.equal(resolveDefaultDatabase({ database: undefined }, ["app", "analytics"]), "app");
+});
+
+test("没有默认数据库且无候选项时返回空字符串", () => {
+  assert.equal(resolveDefaultDatabase({ database: undefined }, []), "");
+});
+
+test("Cloudflare D1 使用 SQLite main 命名空间而不是连接凭据中的 Database ID", () => {
+  assert.equal(resolveDefaultDatabase({ db_type: "cloudflare-d1", database: "d1-database-uuid" }, []), "main");
+  assert.equal(isDefaultDatabase({ db_type: "cloudflare-d1", database: "d1-database-uuid" }, "main"), true);
+  assert.equal(isDefaultDatabase({ db_type: "cloudflare-d1", database: "d1-database-uuid" }, "d1-database-uuid"), false);
+});
+
+test("判断当前数据库是否为默认数据库", () => {
+  assert.equal(isDefaultDatabase({ database: "analytics" }, "analytics"), true);
+  assert.equal(isDefaultDatabase({ database: "analytics" }, "app"), false);
+  assert.equal(isDefaultDatabase(undefined, "analytics"), false);
+  assert.equal(isDefaultDatabase({ database: "analytics" }, ""), false);
+});
+
+test("tree-schema 默认数据库会编码成可选中的稳定值并可解码回空字符串", () => {
+  assert.equal(encodeSelectableDatabaseValue("saphana", ""), TREE_SCHEMA_DEFAULT_DATABASE_SELECT_VALUE);
+  assert.equal(decodeSelectableDatabaseValue("saphana", TREE_SCHEMA_DEFAULT_DATABASE_SELECT_VALUE), "");
+});
+
+test("命名数据库保持原始值不变", () => {
+  assert.equal(encodeSelectableDatabaseValue("saphana", "SALES"), "SALES");
+  assert.equal(decodeSelectableDatabaseValue("saphana", "SALES"), "SALES");
+});
+
+test("数据库标签复用默认库显示语义", () => {
+  assert.equal(formatDatabaseLabel({ db_type: "saphana" }, "", { defaultDatabase: "Default", noDatabase: "No database selected" }), "Default");
+  assert.equal(
+    formatDatabaseLabel({ db_type: "postgres" }, "analytics", {
+      defaultDatabase: "Default",
+      noDatabase: "No database selected",
+    }),
+    "analytics",
+  );
+  assert.equal(formatDatabaseLabel({ db_type: "redis" }, "3", { defaultDatabase: "Default", noDatabase: "No database selected" }), "db3");
+});
diff --git a/packages/app-tests/diagramSvgExport.test.ts b/packages/app-tests/diagramSvgExport.test.ts
new file mode 100644
index 0000000..a692543
--- /dev/null
+++ b/packages/app-tests/diagramSvgExport.test.ts
@@ -0,0 +1,75 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildEngineeringDiagram } from "../../apps/desktop/src/lib/diagram/engineeringDiagram.ts";
+import { buildEngineeringDiagramSvg, buildTableDiagramSvg, diagramSvgFileName } from "../../apps/desktop/src/lib/export/diagramSvgExport.ts";
+import { buildDiagramRelationships, type DiagramTable } from "../../apps/desktop/src/lib/diagram/erDiagram.ts";
+
+const tables: DiagramTable[] = [
+  {
+    name: "users",
+    columns: [
+      { name: "id", data_type: "bigint", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+      { name: "name & note", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
+    ],
+    foreignKeys: [],
+  },
+  {
+    name: "orders",
+    columns: [
+      { name: "id", data_type: "bigint", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+      { name: "user_id", data_type: "bigint", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
+    ],
+    foreignKeys: [{ name: "orders_user_id_fk", column: "user_id", ref_table: "users", ref_column: "id" }],
+  },
+];
+
+test("exports the table diagram as standalone SVG", () => {
+  const relationships = buildDiagramRelationships(tables);
+  const svg = buildTableDiagramSvg({
+    tables,
+    relationships,
+    positions: {
+      users: { x: 40, y: 40 },
+      orders: { x: 360, y: 40 },
+    },
+    relationshipPaths: {
+      [relationships[0].id]: "M 360 96 L 310 96",
+    },
+    canvas: { width: 720, height: 320 },
+    cardWidth: 270,
+    cardHeaderHeight: 44,
+    columnRowHeight: 24,
+    maxVisibleColumns: 9,
+    moreColumnsLabel: (count) => `+ ${count} columns`,
+  });
+
+  assert.match(svg, /^<svg /);
+  assert.match(svg, /<path d="M 360 96 L 310 96"/);
+  assert.match(svg, />users</);
+  assert.match(svg, />orders</);
+  assert.match(svg, />name &amp; note</);
+  assert.doesNotMatch(svg, /<foreignObject/);
+});
+
+test("exports the engineering ER diagram with Chen-style shapes and cardinalities", () => {
+  const relationships = buildDiagramRelationships(tables);
+  const diagram = buildEngineeringDiagram(tables, relationships, {
+    users: { x: 40, y: 40 },
+    orders: { x: 360, y: 40 },
+  });
+  const svg = buildEngineeringDiagramSvg(diagram);
+
+  assert.match(svg, /^<svg /);
+  assert.match(svg, /<ellipse /);
+  assert.match(svg, /<polygon /);
+  assert.match(svg, /<rect /);
+  assert.match(svg, />N</);
+  assert.match(svg, />1</);
+  assert.match(svg, /text-decoration="underline"/);
+  assert.doesNotMatch(svg, /<foreignObject/);
+});
+
+test("builds safe SVG file names from the active diagram context", () => {
+  assert.equal(diagramSvgFileName("prod/main", "billing db", "engineering"), "dbx-prod-main-billing-db-engineering-er.svg");
+  assert.equal(diagramSvgFileName("", "", "table"), "dbx-diagram-table-structure.svg");
+});
diff --git a/packages/app-tests/documentBrowser.test.ts b/packages/app-tests/documentBrowser.test.ts
new file mode 100644
index 0000000..16e4914
--- /dev/null
+++ b/packages/app-tests/documentBrowser.test.ts
@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { test } from "vitest";
+
+function searchBarSlotSource(): string {
+  const source = readFileSync(path.resolve("apps/desktop/src/components/document/DocumentBrowser.vue"), "utf8");
+  const start = source.indexOf('<template #search-bar');
+  const end = source.indexOf("\n    </DataGrid>", start);
+  assert.notEqual(start, -1, "expected DocumentBrowser search-bar slot");
+  assert.notEqual(end, -1, "expected DocumentBrowser DataGrid closing tag");
+  return source.slice(start, end);
+}
+
+test("mongo document result search bar does not render a duplicate refresh button", () => {
+  const slot = searchBarSlotSource();
+  assert.equal(slot.includes('{{ t("grid.refresh") }}'), false);
+  assert.equal(slot.includes("RefreshCcw"), false);
+});
diff --git a/packages/app-tests/documentStoreProvider.test.ts b/packages/app-tests/documentStoreProvider.test.ts
new file mode 100644
index 0000000..864c100
--- /dev/null
+++ b/packages/app-tests/documentStoreProvider.test.ts
@@ -0,0 +1,100 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildDocumentFilterCondition, combineDocumentFilterConditions, currentDocumentFilterJson, documentStoreProviderFor, elasticsearchSearchBodyFromDocumentQuery, type DocumentFilterRule } from "../../apps/desktop/src/lib/app/documentStoreProvider.ts";
+
+function rule(patch: Partial<DocumentFilterRule>): DocumentFilterRule {
+  return {
+    id: "rule-1",
+    fieldName: "city",
+    mode: "equals",
+    rawValue: "长治",
+    conjunction: "AND",
+    ...patch,
+  };
+}
+
+test("selects MongoDB and Elasticsearch document store providers", () => {
+  assert.equal(documentStoreProviderFor("mongodb").kind, "mongodb");
+  assert.equal(documentStoreProviderFor("elasticsearch").kind, "elasticsearch");
+});
+
+test("providers build store-specific query previews", () => {
+  const t = ((key: string, params?: Record<string, unknown>) => `${key}:${params?.count ?? ""}`) as never;
+  const mongo = documentStoreProviderFor("mongodb");
+  const elasticsearch = documentStoreProviderFor("elasticsearch");
+
+  assert.equal(mongo.documentsLabel({ total: 7, t }), "mongo.documents:7");
+  assert.equal(mongo.queryPreview({ collection: "orders", filterJson: '{"city":"长治"}', sortJson: '{"createdAt":-1}', skip: 20, limit: 10 }), 'db.getCollection("orders").find({"city":"长治"}).sort({"createdAt":-1}).skip(20).limit(10)');
+  assert.equal(mongo.queryPreview({ collection: "order-events", filterJson: '{"city":"长治"}', sortJson: undefined, skip: 0, limit: 100 }), 'db.getCollection("order-events").find({"city":"长治"}).skip(0).limit(100)');
+  assert.equal(mongo.queryPreview({ collection: "orders", filterJson: '{"snowflake":{"$numberLong":"9007199254740993"}}', sortJson: undefined, skip: 0, limit: 100 }), 'db.getCollection("orders").find({"snowflake":NumberLong("9007199254740993")}).skip(0).limit(100)');
+  assert.equal(elasticsearch.documentsLabel({ total: 7, t }), "Documents");
+  assert.equal(elasticsearch.filterInputLabel, "filter");
+  assert.equal(
+    elasticsearch.queryPreview({ collection: "orders", filterJson: '{"city":"长治"}', sortJson: '{"createdAt":-1}', skip: 20, limit: 10 }),
+    ["POST /orders/_search", "{", '  "from": 20,', '  "size": 10,', '  "query": {', '    "term": {', '      "city": "长治"', "    }", "  },", '  "sort": [', "    {", '      "createdAt": {', '        "order": "desc"', "      }", "    }", "  ]", "}"].join("\n"),
+  );
+});
+
+test("builds reusable document filter conditions", () => {
+  assert.deepEqual(buildDocumentFilterCondition(rule({})), { city: "长治" });
+  assert.deepEqual(buildDocumentFilterCondition(rule({ mode: "not-like", rawValue: "test" })), {
+    city: { $not: { $regex: "test", $options: "i" } },
+  });
+  assert.deepEqual(buildDocumentFilterCondition(rule({ mode: "is-not-null", rawValue: "" })), { city: { $ne: null } });
+});
+
+test("preserves MongoDB int64 document filter values", () => {
+  const id = "2048938405781032962";
+  const firstUnsafeInteger = "9007199254740993";
+  assert.deepEqual(buildDocumentFilterCondition(rule({ fieldName: "processInfoId", rawValue: id }), { kind: "mongodb" }), {
+    processInfoId: { $numberLong: id },
+  });
+  assert.deepEqual(buildDocumentFilterCondition(rule({ fieldName: "snowflake", rawValue: firstUnsafeInteger }), { kind: "mongodb" }), {
+    snowflake: { $numberLong: firstUnsafeInteger },
+  });
+  assert.deepEqual(buildDocumentFilterCondition(rule({ fieldName: "processInfoId", mode: "greater-than", rawValue: id }), { kind: "mongodb" }), {
+    processInfoId: { $gt: { $numberLong: id } },
+  });
+  assert.deepEqual(buildDocumentFilterCondition(rule({ fieldName: "processInfoId", mode: "like", rawValue: id }), { kind: "mongodb" }), {
+    processInfoId: { $regex: id, $options: "i" },
+  });
+  assert.deepEqual(buildDocumentFilterCondition(rule({ fieldName: "processInfoId", rawValue: `"${id}"` }), { kind: "mongodb" }), {
+    processInfoId: id,
+  });
+  assert.equal(currentDocumentFilterJson(`{processInfoId:${id}}`, null, "mongodb"), JSON.stringify({ processInfoId: { $numberLong: id } }));
+  assert.equal(currentDocumentFilterJson("", { processInfoId: { $numberLong: id } }, "mongodb"), JSON.stringify({ processInfoId: { $numberLong: id } }));
+});
+
+test("keeps unsafe standalone document filter integers precise outside MongoDB", () => {
+  assert.deepEqual(buildDocumentFilterCondition(rule({ fieldName: "processInfoId", rawValue: "2048938405781032962" })), {
+    processInfoId: "2048938405781032962",
+  });
+});
+
+test("combines manual and structured document filters", () => {
+  const structured = combineDocumentFilterConditions([{ city: "长治" }, { status: "active" }], [rule({}), rule({ fieldName: "status", rawValue: "active", conjunction: "OR" })]);
+
+  assert.deepEqual(structured, { $or: [{ city: "长治" }, { status: "active" }] });
+  assert.equal(currentDocumentFilterJson('{"tenant":"a"}', structured), JSON.stringify({ $and: [{ tenant: "a" }, structured] }));
+});
+
+test("translates document filters to Elasticsearch search body previews", () => {
+  assert.deepEqual(
+    elasticsearchSearchBodyFromDocumentQuery({
+      filterJson: JSON.stringify({ $and: [{ city: { $ne: "上海" } }, { age: { $gt: 18, $lte: 60 } }] }),
+      sortJson: '{"createdAt":-1}',
+      skip: 0,
+      limit: 50,
+    }),
+    {
+      from: 0,
+      size: 50,
+      query: {
+        bool: {
+          filter: [{ bool: { must_not: [{ term: { city: "上海" } }] } }, { range: { age: { gt: 18, lte: 60 } } }],
+        },
+      },
+      sort: [{ createdAt: { order: "desc" } }],
+    },
+  );
+});
diff --git a/packages/app-tests/documentViewerFontStyle.test.ts b/packages/app-tests/documentViewerFontStyle.test.ts
new file mode 100644
index 0000000..c4eb6dd
--- /dev/null
+++ b/packages/app-tests/documentViewerFontStyle.test.ts
@@ -0,0 +1,17 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { EDITOR_FONT_FAMILY_CSS_VAR, EDITOR_FONT_SIZE_CSS_VAR } from "../../apps/desktop/src/lib/editor/editorThemes.ts";
+import { documentViewerFontStyle } from "../../apps/desktop/src/lib/document/documentViewerFontStyle.ts";
+
+test("document viewer font style follows editor font settings", () => {
+  assert.deepEqual(
+    documentViewerFontStyle({
+      fontFamily: "'Cascadia Code', monospace",
+      fontSize: 16,
+    }),
+    {
+      [EDITOR_FONT_FAMILY_CSS_VAR]: "'Cascadia Code', monospace",
+      [EDITOR_FONT_SIZE_CSS_VAR]: "16px",
+    },
+  );
+});
diff --git a/packages/app-tests/driverInstallProgressUi.test.ts b/packages/app-tests/driverInstallProgressUi.test.ts
new file mode 100644
index 0000000..bd6c7dd
--- /dev/null
+++ b/packages/app-tests/driverInstallProgressUi.test.ts
@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+
+import { addDriverInstallQueue, driverInstallProgressPercent, isDriverInstallProgressTarget, removeDriverInstallQueue, takeNextDriverInstallQueue } from "../../apps/desktop/src/lib/connection/driverInstallProgressUi.ts";
+
+test("formats driver install progress as a bounded whole percent", () => {
+  assert.equal(driverInstallProgressPercent({ step: "driver", downloaded: 3_900_000, total: 10_500_000 }), 37);
+  assert.equal(driverInstallProgressPercent({ step: "driver", downloaded: -1, total: 10 }), 0);
+  assert.equal(driverInstallProgressPercent({ step: "driver", downloaded: 11, total: 10 }), 100);
+});
+
+test("returns null when install progress has no measurable total", () => {
+  assert.equal(driverInstallProgressPercent(null), null);
+  assert.equal(driverInstallProgressPercent({ step: "jre-extract" }), null);
+  assert.equal(driverInstallProgressPercent({ step: "driver", downloaded: 1, total: 0 }), null);
+});
+
+test("targets only the row currently installing or upgrading", () => {
+  assert.equal(isDriverInstallProgressTarget("mysql", { installing: "mysql", upgradingAll: false, progress: null }), true);
+  assert.equal(isDriverInstallProgressTarget("postgres", { installing: "mysql", upgradingAll: false, progress: null }), false);
+  assert.equal(
+    isDriverInstallProgressTarget("postgres", {
+      installing: null,
+      upgradingAll: true,
+      progress: { step: "driver", db_type: "postgres", downloaded: 1, total: 2 },
+    }),
+    true,
+  );
+});
+
+test("adds queued driver installs without duplicating the active or queued driver", () => {
+  assert.deepEqual(addDriverInstallQueue(["postgres"], "mysql", "sqlite"), ["postgres", "mysql"]);
+  assert.deepEqual(addDriverInstallQueue(["postgres"], "postgres", "sqlite"), ["postgres"]);
+  assert.deepEqual(addDriverInstallQueue(["postgres"], "sqlite", "sqlite"), ["postgres"]);
+});
+
+test("removes queued driver installs", () => {
+  assert.deepEqual(removeDriverInstallQueue(["postgres", "mysql", "sqlite"], "mysql"), ["postgres", "sqlite"]);
+});
+
+test("takes the next installable queued driver and drops stale queued drivers", () => {
+  const result = takeNextDriverInstallQueue(["installed", "mysql", "sqlite"], (dbType) => dbType !== "installed");
+
+  assert.equal(result.next, "mysql");
+  assert.deepEqual(result.queue, ["sqlite"]);
+});
diff --git a/packages/app-tests/editorSettingsDraft.test.ts b/packages/app-tests/editorSettingsDraft.test.ts
new file mode 100644
index 0000000..0edff9d
--- /dev/null
+++ b/packages/app-tests/editorSettingsDraft.test.ts
@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { createPinia, setActivePinia } from "pinia";
+import { DEFAULT_UI_FONT_FAMILY } from "../../apps/desktop/src/lib/app/appFonts.ts";
+import { editorSettingsDraftFromSettings, editorSettingsPatchFromDraft } from "../../apps/desktop/src/lib/settings/editorSettingsDraft.ts";
+import { DEFAULT_EDITOR_SETTINGS, useSettingsStore } from "../../apps/desktop/src/stores/settingsStore.ts";
+
+test("keeps a loaded editor font when an old appearance draft only changes the UI font", () => {
+  setActivePinia(createPinia());
+  const store = useSettingsStore();
+  const savedEditorFont = "'Cascadia Code', 'Cascadia Mono', monospace";
+
+  store.updateEditorSettings({ fontFamily: savedEditorFont });
+
+  const staleDraftBase = editorSettingsDraftFromSettings(DEFAULT_EDITOR_SETTINGS);
+  const staleDraft = {
+    ...staleDraftBase,
+    uiFontFamily: `"Aptos", ${DEFAULT_UI_FONT_FAMILY}`,
+  };
+
+  const patch = editorSettingsPatchFromDraft(staleDraft, staleDraftBase);
+  store.updateEditorSettings(patch);
+
+  assert.equal(patch.fontFamily, undefined);
+  assert.equal(store.editorSettings.fontFamily, savedEditorFont);
+  assert.equal(store.editorSettings.uiFontFamily, staleDraft.uiFontFamily);
+});
diff --git a/packages/app-tests/elasticsearchCompletion.test.ts b/packages/app-tests/elasticsearchCompletion.test.ts
new file mode 100644
index 0000000..a0b84a5
--- /dev/null
+++ b/packages/app-tests/elasticsearchCompletion.test.ts
@@ -0,0 +1,83 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildElasticsearchCompletionItems, getElasticsearchCompletionContext, shouldAutoOpenElasticsearchCompletion } from "../../apps/desktop/src/lib/elasticsearch/elasticsearchCompletion.ts";
+import { buildSqlCompletionItems } from "../../apps/desktop/src/lib/sql/sqlCompletion.ts";
+
+const indices = ["orders", "order_items", "users"];
+
+function applyCompletion(text: string, cursor: number, label: string): string {
+  const context = getElasticsearchCompletionContext(text, cursor);
+  const item = buildElasticsearchCompletionItems(text, cursor, { indices }).find((candidate) => candidate.label === label);
+  assert.ok(item, `Expected completion item ${label}`);
+  return `${text.slice(0, context.from)}${item.apply ?? item.label}${text.slice(cursor)}`;
+}
+
+test("suggests Elasticsearch HTTP methods for empty and prefix input", () => {
+  assert.deepEqual(
+    buildElasticsearchCompletionItems("", 0).map((item) => item.label),
+    ["GET", "POST", "PUT", "DELETE"],
+  );
+
+  const items = buildElasticsearchCompletionItems("po", 2);
+  assert.equal(items.find((item) => item.label === "POST")?.apply, "POST /");
+});
+
+test("suggests Elasticsearch root endpoints", () => {
+  const items = buildElasticsearchCompletionItems("GET /_", "GET /_".length);
+
+  assert.ok(items.find((item) => item.label === "/_search"));
+  assert.ok(items.find((item) => item.label === "/_cat/indices"));
+});
+
+test("suggests Elasticsearch index endpoints", () => {
+  const items = buildElasticsearchCompletionItems("GET /orders/_", "GET /orders/_".length);
+
+  assert.ok(items.find((item) => item.label === "_search"));
+  assert.ok(items.find((item) => item.label === "_mapping"));
+  assert.ok(items.find((item) => item.label === "_count"));
+});
+
+test("suggests Elasticsearch indices by prefix", () => {
+  const items = buildElasticsearchCompletionItems("GET /ord", "GET /ord".length, { indices });
+
+  assert.deepEqual(
+    items.filter((item) => item.detail === "index").map((item) => item.label),
+    ["orders", "order_items"],
+  );
+});
+
+test("index completion preserves endpoint suffix after cursor", () => {
+  const text = "GET /ord/_search";
+  const cursor = "GET /ord".length;
+
+  assert.equal(applyCompletion(text, cursor, "orders"), "GET /orders/_search");
+});
+
+test("suggests Elasticsearch JSON DSL keys and snippets", () => {
+  const keyItems = buildElasticsearchCompletionItems('GET /orders/_search\n{\n  "qu', 'GET /orders/_search\n{\n  "qu'.length);
+  assert.ok(keyItems.find((item) => item.label === '"query"'));
+
+  const snippetItems = buildElasticsearchCompletionItems('GET /orders/_search\n{\n  "match_', 'GET /orders/_search\n{\n  "match_'.length);
+  const matchAll = snippetItems.find((item) => item.label === "match_all");
+  assert.ok(matchAll);
+  assert.doesNotThrow(() => JSON.parse(`{${matchAll?.apply}}`));
+});
+
+test("Elasticsearch completion auto trigger ignores structural JSON punctuation", () => {
+  assert.equal(shouldAutoOpenElasticsearchCompletion("GET /", "GET /".length), true);
+  assert.equal(shouldAutoOpenElasticsearchCompletion("GET /_", "GET /_".length), true);
+  assert.equal(shouldAutoOpenElasticsearchCompletion("GET /orders/_search\n{", "GET /orders/_search\n{".length), false);
+  assert.equal(shouldAutoOpenElasticsearchCompletion('GET /orders/_search\n{"query": {},', 'GET /orders/_search\n{"query": {},'.length), false);
+});
+
+test("SQL completion does not include Elasticsearch endpoints", () => {
+  const items = buildSqlCompletionItems("select", "select".length, {
+    tables: [],
+    columnsByTable: new Map(),
+  });
+
+  assert.equal(
+    items.some((item) => item.label === "/_search" || item.label === "_search"),
+    false,
+  );
+});
diff --git a/packages/app-tests/elasticsearchJsonResponse.test.ts b/packages/app-tests/elasticsearchJsonResponse.test.ts
new file mode 100644
index 0000000..e3eedb8
--- /dev/null
+++ b/packages/app-tests/elasticsearchJsonResponse.test.ts
@@ -0,0 +1,70 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { elasticsearchJsonResponseForResult } from "../../apps/desktop/src/lib/elasticsearch/elasticsearchJsonResponse.ts";
+import type { QueryResult } from "../../apps/desktop/src/types/database.ts";
+
+function jsonResponse(overrides: Partial<QueryResult> = {}): QueryResult {
+  return {
+    columns: ["status", "response"],
+    rows: [[200, '{\n  "acknowledged": true\n}']],
+    affected_rows: 0,
+    execution_time_ms: 1,
+    ...overrides,
+  };
+}
+
+test("classifies Elasticsearch GET mapping and POST JSON responses", () => {
+  const mapping = jsonResponse();
+  assert.deepEqual(elasticsearchJsonResponseForResult("elasticsearch", "GET /products/_mapping", mapping), {
+    status: 200,
+    body: '{\n  "acknowledged": true\n}',
+  });
+
+  const search = jsonResponse({ rows: [[201, '{"hits":{"hits":[]}}']] });
+  assert.deepEqual(elasticsearchJsonResponseForResult("elasticsearch", '  post /products/_search\n{"query":{"match_all":{}}}', search), {
+    status: 201,
+    body: '{"hits":{"hits":[]}}',
+  });
+});
+
+test("rejects SQL and non-JSON Elasticsearch result shapes", () => {
+  const response = jsonResponse();
+
+  assert.equal(elasticsearchJsonResponseForResult("elasticsearch", "SELECT * FROM products", response), undefined);
+  assert.equal(elasticsearchJsonResponseForResult("postgres", "GET /products/_mapping", response), undefined);
+  assert.equal(
+    elasticsearchJsonResponseForResult("elasticsearch", "GET /_cat/indices", {
+      columns: ["response"],
+      rows: [["green open products"]],
+      affected_rows: 1,
+      execution_time_ms: 1,
+    }),
+    undefined,
+  );
+});
+
+test("rejects invalid Elasticsearch JSON response status and row shapes", () => {
+  const invalidResults: QueryResult[] = [
+    jsonResponse({ columns: ["response", "status"] }),
+    jsonResponse({ rows: [[200, "{}", "unexpected"]] }),
+    jsonResponse({ rows: [[99, "{}"]] }),
+    jsonResponse({ rows: [[600, "{}"]] }),
+    jsonResponse({ rows: [["200", "{}"]] }),
+    jsonResponse({ rows: [[200, null]] }),
+  ];
+
+  for (const result of invalidResults) {
+    assert.equal(elasticsearchJsonResponseForResult("elasticsearch", "GET /products/_mapping", result), undefined);
+  }
+});
+
+test("uses the supplied result source statement to classify the response", () => {
+  const result = jsonResponse({ sourceStatement: "GET /products/_mapping" });
+
+  assert.deepEqual(elasticsearchJsonResponseForResult("elasticsearch", result.sourceStatement, result), {
+    status: 200,
+    body: '{\n  "acknowledged": true\n}',
+  });
+  assert.equal(elasticsearchJsonResponseForResult("elasticsearch", "SELECT * FROM products", result), undefined);
+  assert.equal(elasticsearchJsonResponseForResult("elasticsearch", undefined, result), undefined);
+});
diff --git a/packages/app-tests/engineeringDiagram.test.ts b/packages/app-tests/engineeringDiagram.test.ts
new file mode 100644
index 0000000..a9679ff
--- /dev/null
+++ b/packages/app-tests/engineeringDiagram.test.ts
@@ -0,0 +1,104 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildEngineeringDiagram } from "../../apps/desktop/src/lib/diagram/engineeringDiagram.ts";
+import type { DiagramRelationship, DiagramTable } from "../../apps/desktop/src/lib/diagram/erDiagram.ts";
+
+const tables: DiagramTable[] = [
+  {
+    name: "orders",
+    columns: [
+      { name: "id", data_type: "bigint", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+      { name: "user_id", data_type: "bigint", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
+      { name: "status", data_type: "varchar", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
+    ],
+    foreignKeys: [{ name: "orders_user_id_fk", column: "user_id", ref_table: "users", ref_column: "id" }],
+  },
+  {
+    name: "users",
+    columns: [
+      { name: "id", data_type: "bigint", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+      { name: "name", data_type: "varchar", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
+    ],
+    foreignKeys: [],
+  },
+];
+
+const relationships: DiagramRelationship[] = [
+  {
+    id: "orders:orders_user_id_fk:user_id:users:id",
+    name: "orders_user_id_fk",
+    sourceTable: "orders",
+    sourceColumn: "user_id",
+    targetTable: "users",
+    targetColumn: "id",
+  },
+];
+
+test("builds engineering ER nodes from tables, columns, and relationships", () => {
+  const diagram = buildEngineeringDiagram(tables, relationships, {
+    orders: { x: 300, y: 200 },
+    users: { x: 40, y: 200 },
+  });
+
+  assert.deepEqual(
+    diagram.entities.map((entity) => entity.name),
+    ["orders", "users"],
+  );
+  assert.equal(diagram.attributes.filter((attr) => attr.tableName === "orders").length, 3);
+  assert.equal(diagram.relationships[0]?.sourceCardinality, "N");
+  assert.equal(diagram.relationships[0]?.targetCardinality, "1");
+});
+
+test("sizes the engineering canvas around attributes and relationship diamonds", () => {
+  const diagram = buildEngineeringDiagram(tables, relationships, {
+    orders: { x: 300, y: 200 },
+    users: { x: 40, y: 200 },
+  });
+
+  assert.ok(diagram.canvas.width > 500);
+  assert.ok(diagram.canvas.height > 300);
+});
+
+test("keeps dense attribute clouds from overlapping", () => {
+  const denseTables: DiagramTable[] = [
+    {
+      name: "roles",
+      columns: Array.from({ length: 36 }, (_, index) => ({
+        name: `column_${index + 1}`,
+        data_type: "varchar",
+        is_nullable: true,
+        column_default: null,
+        is_primary_key: index === 0,
+        extra: null,
+      })),
+      foreignKeys: [],
+    },
+  ];
+
+  const diagram = buildEngineeringDiagram(denseTables, [], {
+    roles: { x: 40, y: 40 },
+  });
+  const rects = [...diagram.entities, ...diagram.attributes];
+
+  for (let i = 0; i < rects.length; i++) {
+    for (let j = i + 1; j < rects.length; j++) {
+      const left = rects[i];
+      const right = rects[j];
+      const overlaps = left.x < right.x + right.width && left.x + left.width > right.x && left.y < right.y + right.height && left.y + left.height > right.y;
+      assert.equal(overlaps, false, `${left.id} overlaps ${right.id}`);
+    }
+  }
+});
+
+test("keeps adjacent entity centers reasonably close", () => {
+  const diagram = buildEngineeringDiagram(tables, relationships, {
+    users: { x: 40, y: 40 },
+    orders: { x: 360, y: 40 },
+  });
+  const users = diagram.entities.find((entity) => entity.name === "users")!;
+  const orders = diagram.entities.find((entity) => entity.name === "orders")!;
+  const userCenter = users.x + users.width / 2;
+  const orderCenter = orders.x + orders.width / 2;
+
+  assert.ok(Math.abs(orderCenter - userCenter) <= 560);
+});
diff --git a/packages/app-tests/erDiagram.test.ts b/packages/app-tests/erDiagram.test.ts
new file mode 100644
index 0000000..7f69416
--- /dev/null
+++ b/packages/app-tests/erDiagram.test.ts
@@ -0,0 +1,208 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildDiagramJoinSql, buildDiagramRelationships, filterDiagramTables, layoutDiagramTables, normalizeCustomDiagramRelationship } from "../../apps/desktop/src/lib/diagram/erDiagram.ts";
+
+test("builds relationships only between tables in the diagram", () => {
+  const relationships = buildDiagramRelationships([
+    {
+      name: "orders",
+      columns: [],
+      foreignKeys: [
+        { name: "orders_user_id_fk", column: "user_id", ref_table: "users", ref_column: "id" },
+        { name: "orders_external_fk", column: "external_id", ref_table: "external_accounts", ref_column: "id" },
+      ],
+    },
+    {
+      name: "users",
+      columns: [],
+      foreignKeys: [],
+    },
+  ]);
+
+  assert.deepEqual(relationships, [
+    {
+      id: "orders:orders_user_id_fk:user_id:users:id",
+      name: "orders_user_id_fk",
+      kind: "foreign-key",
+      sourceTable: "orders",
+      sourceColumn: "user_id",
+      targetTable: "users",
+      targetColumn: "id",
+      sourceCardinality: "N",
+      targetCardinality: "1",
+    },
+  ]);
+});
+
+test("merges valid custom relationships with foreign key relationships", () => {
+  const relationship = normalizeCustomDiagramRelationship({
+    name: "users_audit",
+    sourceTable: "users",
+    sourceColumn: "email",
+    targetTable: "audit_log",
+    targetColumn: "actor_email",
+    sourceCardinality: "1",
+    targetCardinality: "N",
+  });
+
+  const relationships = buildDiagramRelationships(
+    [
+      {
+        name: "users",
+        columns: [{ name: "email", data_type: "varchar", is_nullable: false, column_default: null, is_primary_key: false, extra: null }],
+        foreignKeys: [],
+      },
+      {
+        name: "audit_log",
+        columns: [{ name: "actor_email", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null }],
+        foreignKeys: [],
+      },
+    ],
+    [relationship],
+  );
+
+  assert.deepEqual(relationships, [
+    {
+      ...relationship,
+      kind: "custom",
+    },
+  ]);
+});
+
+test("ignores custom relationships with missing tables or columns", () => {
+  const relationships = buildDiagramRelationships(
+    [
+      {
+        name: "users",
+        columns: [{ name: "id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null }],
+        foreignKeys: [],
+      },
+    ],
+    [
+      normalizeCustomDiagramRelationship({
+        name: "missing_table",
+        sourceTable: "users",
+        sourceColumn: "id",
+        targetTable: "orders",
+        targetColumn: "user_id",
+        sourceCardinality: "1",
+        targetCardinality: "N",
+      }),
+      normalizeCustomDiagramRelationship({
+        name: "missing_column",
+        sourceTable: "users",
+        sourceColumn: "email",
+        targetTable: "users",
+        targetColumn: "id",
+        sourceCardinality: "1",
+        targetCardinality: "1",
+      }),
+    ],
+  );
+
+  assert.deepEqual(relationships, []);
+});
+
+test("filters diagram tables by table, column, and foreign key names", () => {
+  const tables = [
+    {
+      name: "orders",
+      columns: [{ name: "user_id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: false, extra: null }],
+      foreignKeys: [{ name: "orders_user_id_fk", column: "user_id", ref_table: "users", ref_column: "id" }],
+    },
+    {
+      name: "audit_log",
+      columns: [{ name: "payload", data_type: "json", is_nullable: true, column_default: null, is_primary_key: false, extra: null }],
+      foreignKeys: [],
+    },
+  ];
+
+  assert.deepEqual(
+    filterDiagramTables(tables, "payload").map((table) => table.name),
+    ["audit_log"],
+  );
+  assert.deepEqual(
+    filterDiagramTables(tables, "orders_user").map((table) => table.name),
+    ["orders"],
+  );
+  assert.deepEqual(
+    filterDiagramTables(tables, "").map((table) => table.name),
+    ["orders", "audit_log"],
+  );
+});
+
+test("lays out diagram tables in stable rows", () => {
+  const positions = layoutDiagramTables(
+    [
+      { name: "users", columns: [] },
+      { name: "orders", columns: [] },
+      { name: "line_items", columns: [] },
+    ],
+    { columnsPerRow: 2, cardWidth: 240, rowHeight: 180, gapX: 40, gapY: 30 },
+  );
+
+  assert.deepEqual(positions, {
+    users: { x: 40, y: 40 },
+    orders: { x: 320, y: 40 },
+    line_items: { x: 40, y: 250 },
+  });
+});
+
+test("generates join SQL from diagram relationships", () => {
+  const relationships = buildDiagramRelationships(
+    [
+      {
+        name: "users",
+        columns: [{ name: "id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null }],
+        foreignKeys: [],
+      },
+      {
+        name: "orders",
+        columns: [{ name: "user_id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: false, extra: null }],
+        foreignKeys: [{ name: "orders_user_id_fk", column: "user_id", ref_table: "users", ref_column: "id" }],
+      },
+    ],
+    [],
+  );
+
+  assert.equal(
+    buildDiagramJoinSql(relationships),
+    `SELECT
+  t1.*,
+  t2.*
+FROM orders t1
+LEFT JOIN users t2 ON t1.user_id = t2.id`,
+  );
+});
+
+test("combines multiple relationship conditions between joined tables", () => {
+  const relationships = [
+    normalizeCustomDiagramRelationship({
+      name: "orders_customer_id",
+      sourceTable: "orders",
+      sourceColumn: "customer_id",
+      targetTable: "customers",
+      targetColumn: "id",
+      sourceCardinality: "N",
+      targetCardinality: "1",
+    }),
+    normalizeCustomDiagramRelationship({
+      name: "orders_customer_region",
+      sourceTable: "orders",
+      sourceColumn: "customer_region",
+      targetTable: "customers",
+      targetColumn: "region",
+      sourceCardinality: "N",
+      targetCardinality: "1",
+    }),
+  ].map((relationship) => ({ ...relationship, kind: "custom" as const }));
+
+  assert.equal(
+    buildDiagramJoinSql(relationships),
+    `SELECT
+  t1.*,
+  t2.*
+FROM orders t1
+LEFT JOIN customers t2 ON t1.customer_id = t2.id AND t1.customer_region = t2.region`,
+  );
+});
diff --git a/packages/app-tests/exportFormats.test.ts b/packages/app-tests/exportFormats.test.ts
new file mode 100644
index 0000000..b067de9
--- /dev/null
+++ b/packages/app-tests/exportFormats.test.ts
@@ -0,0 +1,7 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { formatCsv } from "../../apps/desktop/src/lib/export/exportFormats.ts";
+
+test("formatCsv preserves query result null display text", () => {
+  assert.equal(formatCsv(["id", "note"], [[1, null]]), "\"id\",\"note\"\n\"1\",\"NULL\"");
+});
diff --git a/packages/app-tests/fieldLineage.test.ts b/packages/app-tests/fieldLineage.test.ts
new file mode 100644
index 0000000..166cc33
--- /dev/null
+++ b/packages/app-tests/fieldLineage.test.ts
@@ -0,0 +1,76 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { analyzeFieldLineage, identifierInSql, summarizeLineageCounts } from "../../apps/desktop/src/lib/diagram/fieldLineage.ts";
+
+test("detects outgoing and incoming foreign key lineage as certain", () => {
+  const result = analyzeFieldLineage({
+    target: { schema: "public", table: "orders", column: "user_id" },
+    tables: [
+      {
+        schema: "public",
+        name: "orders",
+        columns: ["id", "user_id"],
+        foreignKeys: [{ name: "orders_user_id_fkey", column: "user_id", ref_table: "users", ref_column: "id" }],
+      },
+      {
+        schema: "public",
+        name: "order_events",
+        columns: ["id", "order_user_id"],
+        foreignKeys: [{ name: "events_user_fkey", column: "order_user_id", ref_table: "orders", ref_column: "user_id" }],
+      },
+    ],
+  });
+
+  assert.equal(result.items.length, 2);
+  assert.deepEqual(
+    result.items.map((item) => [item.kind, item.confidence, item.direction, item.table, item.column]),
+    [
+      ["foreignKey", "certain", "outgoing", "users", "id"],
+      ["foreignKey", "certain", "incoming", "order_events", "order_user_id"],
+    ],
+  );
+});
+
+test("finds view, query history, and same-name column references without scanning table data", () => {
+  const result = analyzeFieldLineage({
+    target: { schema: "public", table: "users", column: "email" },
+    tables: [
+      { schema: "public", name: "users", columns: ["id", "email"], foreignKeys: [] },
+      { schema: "public", name: "newsletter_subscribers", columns: ["id", "email"], foreignKeys: [] },
+    ],
+    views: [
+      {
+        schema: "public",
+        name: "active_user_emails",
+        ddl: "CREATE VIEW active_user_emails AS SELECT u.email FROM public.users u WHERE u.active = true",
+      },
+    ],
+    histories: [
+      {
+        id: "h1",
+        sql: "select email from users where email like '%@example.com'",
+        executed_at: "2026-05-02T00:00:00Z",
+      },
+    ],
+  });
+
+  assert.deepEqual(
+    result.items.map((item) => [item.kind, item.confidence, item.table, item.column]),
+    [
+      ["viewReference", "likely", "active_user_emails", undefined],
+      ["historyReference", "likely", undefined, undefined],
+      ["sameName", "possible", "newsletter_subscribers", "email"],
+    ],
+  );
+  assert.deepEqual(summarizeLineageCounts(result.items), {
+    certain: 0,
+    likely: 2,
+    possible: 1,
+  });
+});
+
+test("matches quoted and bare identifiers safely", () => {
+  assert.equal(identifierInSql('select "User Email" from users', "User Email"), true);
+  assert.equal(identifierInSql("select `email` from users", "email"), true);
+  assert.equal(identifierInSql("select user_email from users", "email"), false);
+});
diff --git a/packages/app-tests/gridFsBrowser.test.ts b/packages/app-tests/gridFsBrowser.test.ts
new file mode 100644
index 0000000..c67eb52
--- /dev/null
+++ b/packages/app-tests/gridFsBrowser.test.ts
@@ -0,0 +1,116 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import * as gridFsBrowserModule from "../../apps/desktop/src/lib/document/gridFsBrowser.ts";
+import {
+  buildGridFsFilesStructuredFilter,
+  currentGridFsBucketFilter,
+  currentGridFsBucketSort,
+  currentGridFsBucketSortDirection,
+  currentGridFsFileSortDirection,
+  gridFsFileFilterFieldOptions,
+  gridFsBucketSortInputForColumn,
+  gridFsFilesQueryPreview,
+  parseGridFsBucketSort,
+} from "../../apps/desktop/src/lib/document/gridFsBrowser.ts";
+
+test("builds a Mongo-style GridFS files query preview", () => {
+  assert.equal(
+    gridFsFilesQueryPreview({
+      bucket: "fs",
+      filterJson: '{"metadata.owner":"alice"}',
+      sortJson: '{"uploadDate":-1}',
+    }),
+    'db.getCollection("fs.files").find({"metadata.owner":"alice"}).sort({"uploadDate":-1})',
+  );
+});
+
+test("omits the sort stage when the GridFS file preview has no explicit sort", () => {
+  assert.equal(
+    gridFsFilesQueryPreview({
+      bucket: "fs",
+      filterJson: '{"filename":"report.zip"}',
+    }),
+    'db.getCollection("fs.files").find({"filename":"report.zip"})',
+  );
+});
+
+test("normalizes GridFS bucket filters by trimming blank input", () => {
+  assert.equal(currentGridFsBucketFilter("   nightly  "), "nightly");
+  assert.equal(currentGridFsBucketFilter("   "), undefined);
+});
+
+test("normalizes GridFS manager sort directions for supported fields", () => {
+  assert.deepEqual(parseGridFsBucketSort('{"totalBytes":-1}'), { field: "totalBytes", direction: "desc" });
+  assert.deepEqual(parseGridFsBucketSort("{ fileCount: 1 }"), { field: "fileCount", direction: "asc" });
+});
+
+test("serializes GridFS manager sort input for supported columns", () => {
+  assert.equal(gridFsBucketSortInputForColumn("name", "asc"), '{"name":1}');
+  assert.equal(gridFsBucketSortInputForColumn("totalBytes", "desc"), '{"totalBytes":-1}');
+  assert.equal(gridFsBucketSortInputForColumn("fileCount", null), "");
+});
+
+test("rejects unsupported GridFS bucket sort fields", () => {
+  assert.throws(() => parseGridFsBucketSort('{"createdAt":-1}'), /Unsupported GridFS bucket sort field/);
+});
+
+test("returns canonical GridFS bucket sort JSON", () => {
+  assert.equal(currentGridFsBucketSort("{ totalBytes: -1 }"), '{"totalBytes":-1}');
+  assert.equal(currentGridFsBucketSort("   "), undefined);
+});
+
+test("exposes the available GridFS file filter fields for the compact builder", () => {
+  assert.deepEqual(gridFsFileFilterFieldOptions, ["_id", "filename", "contentType", "length", "chunkSize", "uploadDate", "md5"]);
+});
+
+test("exposes shared GridFS file field display metadata for filters and headers", () => {
+  assert.deepEqual((gridFsBrowserModule as any).gridFsFileFieldDisplayOptions, [
+    { fieldName: "_id", label: "ID" },
+    { fieldName: "filename", labelKey: "gridfsBrowser.name" },
+    { fieldName: "contentType", labelKey: "gridfsBrowser.contentType" },
+    { fieldName: "length", labelKey: "gridfsBrowser.totalSize" },
+    { fieldName: "chunkSize", labelKey: "gridfsBrowser.chunkSize" },
+    { fieldName: "uploadDate", labelKey: "gridfsBrowser.uploadDate" },
+    { fieldName: "md5", label: "MD5" },
+  ]);
+});
+
+test("combines GridFS file filter rules into a MongoDB structured filter", () => {
+  assert.deepEqual(
+    buildGridFsFilesStructuredFilter([
+      {
+        id: "rule-1",
+        fieldName: "filename",
+        mode: "equals",
+        rawValue: "report.zip",
+        conjunction: "AND",
+      },
+      {
+        id: "rule-2",
+        fieldName: "contentType",
+        mode: "like",
+        rawValue: "image",
+        conjunction: "AND",
+      },
+    ]),
+    {
+      $and: [
+        { filename: "report.zip" },
+        { contentType: { $regex: "image", $options: "i" } },
+      ],
+    },
+  );
+});
+
+test("derives explicit GridFS file sort directions for visible header indicators", () => {
+  assert.equal(currentGridFsFileSortDirection('{"filename":1}', "filename"), "asc");
+  assert.equal(currentGridFsFileSortDirection('{"filename":-1}', "filename"), "desc");
+  assert.equal(currentGridFsFileSortDirection('{"filename":1}', "uploadDate"), "none");
+  assert.equal(currentGridFsFileSortDirection('{"filename":1,"uploadDate":-1}', "filename"), "none");
+});
+
+test("derives explicit GridFS bucket sort directions for visible header indicators", () => {
+  assert.equal(currentGridFsBucketSortDirection('{"name":1}', "name"), "asc");
+  assert.equal(currentGridFsBucketSortDirection('{"totalBytes":-1}', "totalBytes"), "desc");
+  assert.equal(currentGridFsBucketSortDirection('{"name":1}', "fileCount"), "none");
+});
diff --git a/packages/app-tests/gridRowStatus.test.ts b/packages/app-tests/gridRowStatus.test.ts
new file mode 100644
index 0000000..dbd9a2e
--- /dev/null
+++ b/packages/app-tests/gridRowStatus.test.ts
@@ -0,0 +1,43 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { canApplyGridSelectionValue, matchesRowStatusFilter, rowStatusFilterAfterAddingRow, type RowStatus } from "../../apps/desktop/src/lib/dataGrid/gridRowStatus.ts";
+
+const statuses: RowStatus[] = ["clean", "edited", "new", "deleted"];
+
+test("status filter includes every row in all mode", () => {
+  assert.deepEqual(
+    statuses.filter((status) => matchesRowStatusFilter(status, "all")),
+    ["clean", "edited", "new", "deleted"],
+  );
+});
+
+test("status filter includes only changed rows in changed mode", () => {
+  assert.deepEqual(
+    statuses.filter((status) => matchesRowStatusFilter(status, "changed")),
+    ["edited", "new", "deleted"],
+  );
+});
+
+test("status filter can isolate a single changed status", () => {
+  assert.deepEqual(
+    statuses.filter((status) => matchesRowStatusFilter(status, "edited")),
+    ["edited"],
+  );
+  assert.deepEqual(
+    statuses.filter((status) => matchesRowStatusFilter(status, "deleted")),
+    ["deleted"],
+  );
+});
+
+test("adding a row switches filters that would hide new rows back to all", () => {
+  assert.equal(rowStatusFilterAfterAddingRow("deleted"), "all");
+  assert.equal(rowStatusFilterAfterAddingRow("edited"), "all");
+  assert.equal(rowStatusFilterAfterAddingRow("changed"), "changed");
+  assert.equal(rowStatusFilterAfterAddingRow("new"), "new");
+});
+
+test("selection value fill skips quick entry draft rows", () => {
+  assert.equal(canApplyGridSelectionValue({ isDraft: false }), true);
+  assert.equal(canApplyGridSelectionValue({ isDraft: true }), false);
+  assert.equal(canApplyGridSelectionValue({ isDraft: true, allowDraft: true }), true);
+});
diff --git a/packages/app-tests/gridSelection.test.ts b/packages/app-tests/gridSelection.test.ts
new file mode 100644
index 0000000..27b143b
--- /dev/null
+++ b/packages/app-tests/gridSelection.test.ts
@@ -0,0 +1,110 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import {
+  allCellsSelectionRange,
+  columnSelectionRange,
+  extractColumnsSelection,
+  extractSelection,
+  formatSelectionAsCsv,
+  formatSelectionAsJson,
+  formatSelectionAsSqlInList,
+  formatSelectionAsTsv,
+  isCellInSelection,
+  normalizeSelectionRange,
+  parseClipboardTable,
+  rowSelectionRange,
+} from "../../apps/desktop/src/lib/dataGrid/gridSelection.ts";
+
+test("normalizes a dragged cell range in either direction", () => {
+  const range = normalizeSelectionRange({ rowIndex: 4, colIndex: 3 }, { rowIndex: 1, colIndex: 0 });
+
+  assert.deepEqual(range, {
+    startRow: 1,
+    endRow: 4,
+    startCol: 0,
+    endCol: 3,
+  });
+  assert.equal(isCellInSelection(2, 1, range), true);
+  assert.equal(isCellInSelection(5, 1, range), false);
+});
+
+test("extracts selection rows and columns from a rectangular range", () => {
+  const selection = extractSelection(
+    ["id", "name", "active"],
+    [
+      [1, "Ada", true],
+      [2, "Linus", false],
+      [3, null, true],
+    ],
+    { startRow: 0, endRow: 1, startCol: 1, endCol: 2 },
+  );
+
+  assert.deepEqual(selection.columns, ["name", "active"]);
+  assert.deepEqual(selection.rows, [
+    ["Ada", true],
+    ["Linus", false],
+  ]);
+});
+
+test("extracts non-contiguous columns in display order", () => {
+  const selection = extractColumnsSelection(
+    ["id", "name", "active", "email"],
+    [
+      [1, "Ada", true, "ada@example.com"],
+      [2, "Linus", false, "linus@example.com"],
+    ],
+    [3, 1, 3],
+  );
+
+  assert.deepEqual(selection.columns, ["name", "email"]);
+  assert.deepEqual(selection.rows, [
+    ["Ada", "ada@example.com"],
+    ["Linus", "linus@example.com"],
+  ]);
+});
+
+test("builds whole row, column, and table selection ranges", () => {
+  assert.deepEqual(rowSelectionRange(2, 4), { startRow: 2, endRow: 2, startCol: 0, endCol: 3 });
+  assert.deepEqual(rowSelectionRange(4, 4, 2), { startRow: 2, endRow: 4, startCol: 0, endCol: 3 });
+  assert.deepEqual(columnSelectionRange(5, 1), { startRow: 0, endRow: 4, startCol: 1, endCol: 1 });
+  assert.deepEqual(columnSelectionRange(5, 3, 1), { startRow: 0, endRow: 4, startCol: 1, endCol: 3 });
+  assert.deepEqual(allCellsSelectionRange(3, 2), { startRow: 0, endRow: 2, startCol: 0, endCol: 1 });
+  assert.equal(rowSelectionRange(0, 0), null);
+  assert.equal(columnSelectionRange(0, 0), null);
+  assert.equal(allCellsSelectionRange(0, 2), null);
+});
+
+test("formats selected cells as TSV, CSV, JSON, and SQL values", () => {
+  const selection = {
+    columns: ["name", "note"],
+    rows: [
+      ["Ada", "math"],
+      ["Bob", 'quote "here"'],
+      ["O'Hara", null],
+    ],
+  };
+
+  assert.equal(formatSelectionAsTsv(selection), 'Ada\tmath\nBob\tquote "here"\nO\'Hara\tNULL');
+  assert.equal(formatSelectionAsCsv(selection), '"name","note"\n"Ada","math"\n"Bob","quote ""here"""\n"O\'Hara","NULL"');
+  assert.equal(
+    formatSelectionAsJson(selection),
+    JSON.stringify(
+      [
+        { name: "Ada", note: "math" },
+        { name: "Bob", note: 'quote "here"' },
+        { name: "O'Hara", note: null },
+      ],
+      null,
+      2,
+    ),
+  );
+  assert.equal(formatSelectionAsSqlInList(selection), "('Ada', 'math', 'Bob', 'quote \"here\"', 'O''Hara', NULL)");
+});
+
+test("parses clipboard table text with spreadsheet line endings", () => {
+  assert.deepEqual(parseClipboardTable("0"), [["0"]]);
+  assert.deepEqual(parseClipboardTable("a\tb\r\nc\td\r\n"), [
+    ["a", "b"],
+    ["c", "d"],
+  ]);
+});
diff --git a/packages/app-tests/gridfsBrowserPagination.test.ts b/packages/app-tests/gridfsBrowserPagination.test.ts
new file mode 100644
index 0000000..b7c3cf4
--- /dev/null
+++ b/packages/app-tests/gridfsBrowserPagination.test.ts
@@ -0,0 +1,31 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "vitest";
+
+import { clampGridFsPage, gridFsTotalPages, paginateGridFsItems } from "../../apps/desktop/src/lib/document/gridfsPagination.ts";
+
+test("paginates GridFS files with a clamped page index", () => {
+  const files = ["f1", "f2", "f3", "f4", "f5"].map((id) => ({ id }));
+
+  assert.equal(gridFsTotalPages(files.length, 2), 3);
+  assert.equal(clampGridFsPage(9, files.length, 2), 2);
+  assert.deepEqual(paginateGridFsItems(files, 1, 2).map((file) => file.id), ["f3", "f4"]);
+  assert.deepEqual(paginateGridFsItems(files, 9, 2).map((file) => file.id), ["f5"]);
+});
+
+test("GridFS browsers keep a scrollable flex layout", () => {
+  const bucketBrowser = readFileSync("apps/desktop/src/components/document/MongoBucketBrowser.vue", "utf8");
+  const gridfsBrowser = readFileSync("apps/desktop/src/components/document/MongoGridFsBrowser.vue", "utf8");
+
+  assert.match(bucketBrowser, /class="flex h-full min-h-0 flex-col overflow-hidden"/);
+  assert.match(bucketBrowser, /v-else class="min-h-0 flex flex-1 flex-col overflow-hidden xl:flex-row/);
+  assert.match(gridfsBrowser, /class="flex h-full min-h-0 flex-col overflow-hidden"/);
+  assert.match(gridfsBrowser, /v-else class="min-h-0 flex flex-1 flex-col overflow-hidden xl:flex-row/);
+});
+
+test("GridFS file browser keeps metadata columns compact on a single line", () => {
+  const bucketBrowser = readFileSync("apps/desktop/src/components/document/MongoBucketBrowser.vue", "utf8");
+
+  assert.match(bucketBrowser, /<table class="min-w-full border-collapse text-\[13px\]">/);
+  assert.match(bucketBrowser, /whitespace-nowrap tabular-nums/);
+});
diff --git a/packages/app-tests/gridfsFiles.test.ts b/packages/app-tests/gridfsFiles.test.ts
new file mode 100644
index 0000000..d80dfca
--- /dev/null
+++ b/packages/app-tests/gridfsFiles.test.ts
@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import dayjs from "dayjs";
+import { test } from "vitest";
+
+import { buildGridFsDownloadArchive, defaultGridFsArchiveFileName, formatGridFsUploadDate } from "../../apps/desktop/src/lib/document/gridfsFiles.ts";
+
+test("formats GridFS upload timestamps as compact local datetimes", () => {
+  const raw = "2026-07-07T01:22:42.123Z";
+  assert.equal(formatGridFsUploadDate(raw), dayjs(raw).format("YYYY-MM-DD HH:mm:ss"));
+});
+
+test("keeps invalid GridFS upload timestamps readable", () => {
+  assert.equal(formatGridFsUploadDate("not-a-date"), "not-a-date");
+  assert.equal(formatGridFsUploadDate(""), "-");
+  assert.equal(formatGridFsUploadDate(undefined), "-");
+});
+
+test("builds a GridFS download zip with safe deduplicated file names", () => {
+  const archive = buildGridFsDownloadArchive([
+    { id: "alpha", filename: "report.txt", data: new TextEncoder().encode("hello") },
+    { id: "beta", filename: "report.txt", data: new TextEncoder().encode("world") },
+    { id: "gamma", filename: "bad/name?.json", data: new TextEncoder().encode("{}") },
+    { id: "delta", data: new TextEncoder().encode("fallback") },
+  ]);
+  const text = new TextDecoder().decode(archive);
+
+  assert.equal(archive[0], 0x50);
+  assert.equal(archive[1], 0x4b);
+  assert.match(text, /report\.txt/);
+  assert.match(text, /report-2\.txt/);
+  assert.match(text, /bad-name\.json/);
+  assert.match(text, /delta\.bin/);
+});
+
+test("builds a timestamped GridFS archive file name from the bucket", () => {
+  const now = new Date("2026-07-07T01:22:42.000Z");
+  assert.equal(
+    defaultGridFsArchiveFileName("user uploads", now),
+    `user-uploads-gridfs-${dayjs(now).format("YYYYMMDD-HHmmss")}.zip`,
+  );
+});
diff --git a/packages/app-tests/historyActivityKind.test.ts b/packages/app-tests/historyActivityKind.test.ts
new file mode 100644
index 0000000..f829b97
--- /dev/null
+++ b/packages/app-tests/historyActivityKind.test.ts
@@ -0,0 +1,36 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { resolveHistoryActivityKind } from "../../apps/desktop/src/lib/history/historyActivityKind.ts";
+
+test("legacy INSERT history entries are treated as data changes", () => {
+  assert.equal(
+    resolveHistoryActivityKind({
+      activity_kind: "query",
+      operation: "INSERT",
+      sql: "INSERT INTO job_entries (id) VALUES (1)",
+    }),
+    "data_change",
+  );
+});
+
+test("legacy CREATE history entries are treated as schema changes", () => {
+  assert.equal(
+    resolveHistoryActivityKind({
+      activity_kind: "query",
+      operation: "CREATE",
+      sql: "CREATE TABLE resume_contexts (id bigint)",
+    }),
+    "schema_change",
+  );
+});
+
+test("SELECT history entries stay queries", () => {
+  assert.equal(
+    resolveHistoryActivityKind({
+      activity_kind: "query",
+      operation: "SELECT",
+      sql: "SELECT * FROM education_notes",
+    }),
+    "query",
+  );
+});
diff --git a/packages/app-tests/historyAiAnalysis.test.ts b/packages/app-tests/historyAiAnalysis.test.ts
new file mode 100644
index 0000000..46ac59f
--- /dev/null
+++ b/packages/app-tests/historyAiAnalysis.test.ts
@@ -0,0 +1,50 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildHistoryAiAnalysisPrompt, canRollbackHistoryEntry, type HistoryAiAnalysisEntry } from "../../apps/desktop/src/lib/history/historyAiAnalysis.ts";
+
+const baseEntry: HistoryAiAnalysisEntry = {
+  id: "h1",
+  connection_name: "Local MySQL",
+  database: "app",
+  sql: "UPDATE users SET status = 'inactive' WHERE id = 42;",
+  executed_at: "2026-05-15T07:30:00.000Z",
+  execution_time_ms: 125,
+  success: true,
+  activity_kind: "data_change",
+  operation: "UPDATE",
+  target: "public.users",
+  affected_rows: 1,
+  rollback_sql: "UPDATE users SET status = 'active' WHERE id = 42;",
+};
+
+test("buildHistoryAiAnalysisPrompt includes operation details and rollback SQL", () => {
+  const prompt = buildHistoryAiAnalysisPrompt(baseEntry);
+
+  assert.match(prompt, /分析这条 DBX 历史记录/);
+  assert.match(prompt, /Connection: Local MySQL/);
+  assert.match(prompt, /Operation: UPDATE/);
+  assert.match(prompt, /Affected rows: 1/);
+  assert.match(prompt, /UPDATE users SET status = 'inactive'/);
+  assert.match(prompt, /Rollback SQL/);
+  assert.match(prompt, /UPDATE users SET status = 'active'/);
+});
+
+test("buildHistoryAiAnalysisPrompt records when rollback SQL is unavailable", () => {
+  const prompt = buildHistoryAiAnalysisPrompt({
+    ...baseEntry,
+    rollback_sql: null,
+    error: "permission denied",
+    success: false,
+  });
+
+  assert.match(prompt, /Status: failed/);
+  assert.match(prompt, /Error: permission denied/);
+  assert.match(prompt, /Rollback SQL:\n\(not available\)/);
+});
+
+test("canRollbackHistoryEntry requires connection, database, and rollback SQL", () => {
+  assert.equal(canRollbackHistoryEntry({ ...baseEntry, connection_id: "conn-1" }), true);
+  assert.equal(canRollbackHistoryEntry({ ...baseEntry, connection_id: "" }), false);
+  assert.equal(canRollbackHistoryEntry({ ...baseEntry, connection_id: "conn-1", database: "" }), false);
+  assert.equal(canRollbackHistoryEntry({ ...baseEntry, connection_id: "conn-1", rollback_sql: "" }), false);
+});
diff --git a/packages/app-tests/historyTimeRange.test.ts b/packages/app-tests/historyTimeRange.test.ts
new file mode 100644
index 0000000..fad0865
--- /dev/null
+++ b/packages/app-tests/historyTimeRange.test.ts
@@ -0,0 +1,25 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { historyDateRangeIsValid, historyEntryMatchesDateRange } from "../../apps/desktop/src/lib/history/historyTimeRange.ts";
+
+test("matches entries on the selected start and end dates inclusively", () => {
+  const range = { startDate: "2026-06-01", endDate: "2026-06-18" };
+
+  assert.equal(historyEntryMatchesDateRange("2026-06-01T00:00:00.000", range), true);
+  assert.equal(historyEntryMatchesDateRange("2026-06-18T23:59:59.999", range), true);
+  assert.equal(historyEntryMatchesDateRange("2026-05-31T23:59:59.999", range), false);
+  assert.equal(historyEntryMatchesDateRange("2026-06-19T00:00:00.000", range), false);
+});
+
+test("supports open-ended date ranges", () => {
+  assert.equal(historyEntryMatchesDateRange("2026-06-18T12:00:00.000", { startDate: "2026-06-18", endDate: "" }), true);
+  assert.equal(historyEntryMatchesDateRange("2026-06-17T23:59:59.999", { startDate: "2026-06-18", endDate: "" }), false);
+  assert.equal(historyEntryMatchesDateRange("2026-06-18T23:59:59.999", { startDate: "", endDate: "2026-06-18" }), true);
+  assert.equal(historyEntryMatchesDateRange("2026-06-19T00:00:00.000", { startDate: "", endDate: "2026-06-18" }), false);
+});
+
+test("validates date range ordering", () => {
+  assert.equal(historyDateRangeIsValid({ startDate: "2026-06-01", endDate: "2026-06-18" }), true);
+  assert.equal(historyDateRangeIsValid({ startDate: "2026-06-18", endDate: "2026-06-01" }), false);
+  assert.equal(historyDateRangeIsValid({ startDate: "2026-06-18", endDate: "" }), true);
+});
diff --git a/packages/app-tests/hiveKerberosOptions.test.ts b/packages/app-tests/hiveKerberosOptions.test.ts
new file mode 100644
index 0000000..35f129c
--- /dev/null
+++ b/packages/app-tests/hiveKerberosOptions.test.ts
@@ -0,0 +1,60 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { applyHiveKerberosSubmitConfig, hiveKerberosFormConfig } from "../../apps/desktop/src/lib/database/hiveKerberosOptions.ts";
+
+test("adds Hive Kerberos URL and JVM options while preserving unrelated params", () => {
+  const result = applyHiveKerberosSubmitConfig({
+    authMode: "kerberos",
+    principal: "hive/_HOST@EXAMPLE.COM",
+    krb5ConfPath: "C:\\ProgramData\\MIT\\Kerberos5\\krb5.ini",
+    jaasConfigPath: "C:\\dbx\\hive-jaas.conf",
+    useSubjectCredsOnlyFalse: true,
+    extraJavaOptions: "-Dsun.security.krb5.debug=true",
+    urlParams: ";serviceDiscoveryMode=zooKeeper;principal=hive/old@EXAMPLE.COM",
+  });
+
+  assert.equal(result.urlParams, "serviceDiscoveryMode=zooKeeper;principal=hive/_HOST@EXAMPLE.COM");
+  assert.deepEqual(result.agentJavaOptions, ["-Djava.security.krb5.conf=C:\\ProgramData\\MIT\\Kerberos5\\krb5.ini", "-Djava.security.auth.login.config=C:\\dbx\\hive-jaas.conf", "-Djavax.security.auth.useSubjectCredsOnly=false", "-Dsun.security.krb5.debug=true"]);
+});
+
+test("disabling Hive Kerberos removes generated URL params but keeps extra JVM options", () => {
+  const result = applyHiveKerberosSubmitConfig({
+    authMode: "none",
+    principal: "hive/_HOST@EXAMPLE.COM",
+    krb5ConfPath: "/etc/krb5.conf",
+    jaasConfigPath: "/etc/hive-jaas.conf",
+    useSubjectCredsOnlyFalse: true,
+    extraJavaOptions: "-Dcustom.flag=true",
+    urlParams: "auth=kerberos;principal=hive/_HOST@EXAMPLE.COM;transportMode=http",
+  });
+
+  assert.equal(result.urlParams, "transportMode=http");
+  assert.deepEqual(result.agentJavaOptions, ["-Dcustom.flag=true"]);
+});
+
+test("preserves non Kerberos Hive auth params when Kerberos is disabled", () => {
+  const result = applyHiveKerberosSubmitConfig({
+    authMode: "none",
+    principal: "",
+    krb5ConfPath: "",
+    jaasConfigPath: "",
+    useSubjectCredsOnlyFalse: false,
+    extraJavaOptions: "",
+    urlParams: "auth=noSasl;transportMode=http",
+  });
+
+  assert.equal(result.urlParams, "auth=noSasl;transportMode=http");
+});
+
+test("hydrates Hive Kerberos form values from saved URL and JVM options", () => {
+  const form = hiveKerberosFormConfig("principal=hive/_HOST@EXAMPLE.COM", ["-Djava.security.krb5.conf=/etc/krb5.conf", "-Djava.security.auth.login.config=/etc/hive-jaas.conf", "-Djavax.security.auth.useSubjectCredsOnly=false", "-Dsun.security.krb5.debug=true"]);
+
+  assert.deepEqual(form, {
+    authMode: "kerberos",
+    principal: "hive/_HOST@EXAMPLE.COM",
+    krb5ConfPath: "/etc/krb5.conf",
+    jaasConfigPath: "/etc/hive-jaas.conf",
+    useSubjectCredsOnlyFalse: true,
+    extraJavaOptions: "-Dsun.security.krb5.debug=true",
+  });
+});
diff --git a/packages/app-tests/imagePreviewViewer.test.ts b/packages/app-tests/imagePreviewViewer.test.ts
new file mode 100644
index 0000000..8bffcc8
--- /dev/null
+++ b/packages/app-tests/imagePreviewViewer.test.ts
@@ -0,0 +1,67 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { imagePreviewDialogSize } from "../../apps/desktop/src/lib/dataGrid/imagePreviewViewer.ts";
+
+test("sizes wide image preview dialogs as landscape", () => {
+  const size = imagePreviewDialogSize({
+    imageWidth: 1600,
+    imageHeight: 600,
+    viewportWidth: 1200,
+    viewportHeight: 900,
+  });
+
+  assert.ok(size);
+  assert.ok(size.width > size.height);
+  assert.ok(size.width > 384);
+});
+
+test("sizes tall image preview dialogs as portrait", () => {
+  const size = imagePreviewDialogSize({
+    imageWidth: 600,
+    imageHeight: 1600,
+    viewportWidth: 1200,
+    viewportHeight: 900,
+  });
+
+  assert.ok(size);
+  assert.ok(size.height > size.width);
+});
+
+test("keeps image preview dialogs inside viewport limits", () => {
+  const size = imagePreviewDialogSize({
+    imageWidth: 8000,
+    imageHeight: 3000,
+    viewportWidth: 1000,
+    viewportHeight: 700,
+  });
+
+  assert.ok(size);
+  assert.ok(size.width <= 920);
+  assert.ok(size.height <= 602);
+});
+
+test("keeps very tall image preview dialogs wide enough for controls", () => {
+  const size = imagePreviewDialogSize({
+    imageWidth: 100,
+    imageHeight: 3000,
+    viewportWidth: 1200,
+    viewportHeight: 900,
+  });
+
+  assert.ok(size);
+  assert.ok(size.width >= 360);
+  assert.ok(size.height <= 774);
+});
+
+test("keeps very wide image preview dialogs tall enough for controls", () => {
+  const size = imagePreviewDialogSize({
+    imageWidth: 3000,
+    imageHeight: 100,
+    viewportWidth: 1200,
+    viewportHeight: 900,
+  });
+
+  assert.ok(size);
+  assert.ok(size.width <= 1104);
+  assert.ok(size.height >= 228);
+});
diff --git a/packages/app-tests/insertValueHints.test.ts b/packages/app-tests/insertValueHints.test.ts
new file mode 100644
index 0000000..9f61cbf
--- /dev/null
+++ b/packages/app-tests/insertValueHints.test.ts
@@ -0,0 +1,174 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildInsertValueHints, expandToSqlStatementWindow, parseInsertValueHints, parseInsertValueHintsInRanges, parseInsertValuesClauses } from "../../apps/desktop/src/lib/sql/insertValueHints.ts";
+
+test("maps explicit column list to single-row VALUES", () => {
+  const sql = "INSERT INTO auth_user (id, password, last_login) VALUES (5, 'hash', NULL)";
+  const hints = parseInsertValueHints(sql);
+  assert.deepEqual(
+    hints.map((hint) => ({ column: hint.column, text: sql.slice(hint.from, hint.from + 1) })),
+    [
+      { column: "id", text: "5" },
+      { column: "password", text: "'" },
+      { column: "last_login", text: "N" },
+    ],
+  );
+});
+
+test("supports multi-row VALUES", () => {
+  const sql = "INSERT INTO users (id, name) VALUES (1, 'a'), (2, 'b')";
+  const hints = parseInsertValueHints(sql);
+  assert.deepEqual(
+    hints.map((hint) => hint.column),
+    ["id", "name", "id", "name"],
+  );
+  assert.equal(sql.slice(hints[0]!.from, hints[0]!.from + 1), "1");
+  assert.equal(sql.slice(hints[2]!.from, hints[2]!.from + 1), "2");
+});
+
+test("does not split nested parentheses inside a value", () => {
+  const sql = "INSERT INTO t (a, b) VALUES (COALESCE(x, y), NOW())";
+  const hints = parseInsertValueHints(sql);
+  assert.deepEqual(
+    hints.map((hint) => hint.column),
+    ["a", "b"],
+  );
+  assert.ok(sql.slice(hints[0]!.from).startsWith("COALESCE(x, y)"));
+  assert.ok(sql.slice(hints[1]!.from).startsWith("NOW()"));
+});
+
+test("does not split PostgreSQL dollar-quoted values", () => {
+  const sql = "INSERT INTO t (body, count) VALUES ($tag$hello,(world),again$tag$, 2)";
+  const hints = parseInsertValueHints(sql);
+  assert.deepEqual(
+    hints.map((hint) => hint.column),
+    ["body", "count"],
+  );
+  assert.ok(sql.slice(hints[0]!.from).startsWith("$tag$hello,(world),again$tag$"));
+  assert.equal(sql.slice(hints[1]!.from, hints[1]!.from + 1), "2");
+});
+
+test("skips SQL Server table hints before the INSERT column list", () => {
+  const sql = "INSERT INTO dbo.Users WITH (TABLOCK) (id, name) VALUES (1, 'alice')";
+  const hints = parseInsertValueHints(sql);
+  assert.deepEqual(
+    hints.map((hint) => hint.column),
+    ["id", "name"],
+  );
+});
+
+test("resolves columns from table metadata when column list is omitted", () => {
+  const sql = "INSERT INTO users VALUES (1, 'alice')";
+  const hints = parseInsertValueHints(sql, {
+    resolveTableColumns: (table) => (table === "users" ? ["id", "name"] : undefined),
+  });
+  assert.deepEqual(
+    hints.map((hint) => hint.column),
+    ["id", "name"],
+  );
+});
+
+test("returns no hints for INSERT ... SELECT", () => {
+  const sql = "INSERT INTO users (id, name) SELECT id, name FROM staging";
+  assert.deepEqual(parseInsertValueHints(sql), []);
+  assert.deepEqual(parseInsertValuesClauses(sql), []);
+});
+
+test("caps hints when value count exceeds column count", () => {
+  const sql = "INSERT INTO t (a, b) VALUES (1, 2, 3)";
+  const hints = parseInsertValueHints(sql);
+  assert.deepEqual(
+    hints.map((hint) => hint.column),
+    ["a", "b"],
+  );
+});
+
+test("caps hints when column count exceeds value count", () => {
+  const sql = "INSERT INTO t (a, b, c) VALUES (1, 2)";
+  const hints = parseInsertValueHints(sql);
+  assert.deepEqual(
+    hints.map((hint) => hint.column),
+    ["a", "b"],
+  );
+});
+
+test("handles quoted identifiers in column list", () => {
+  const sql = 'INSERT INTO "User" ("Id", "Name") VALUES (1, \'x\')';
+  const hints = parseInsertValueHints(sql);
+  assert.deepEqual(
+    hints.map((hint) => hint.column),
+    ["Id", "Name"],
+  );
+});
+
+test("parses schema-qualified table without column list", () => {
+  const clauses = parseInsertValuesClauses("INSERT INTO dbo.Users VALUES (1)");
+  assert.equal(clauses.length, 1);
+  assert.equal(clauses[0]?.table, "Users");
+  assert.equal(clauses[0]?.schema, "dbo");
+  assert.equal(clauses[0]?.database, undefined);
+  assert.equal(clauses[0]?.columns, null);
+});
+
+test("preserves three-part database.schema.table qualifiers", () => {
+  const clauses = parseInsertValuesClauses("INSERT INTO OtherDb.dbo.Users VALUES (1, 'a')");
+  assert.equal(clauses.length, 1);
+  assert.equal(clauses[0]?.database, "OtherDb");
+  assert.equal(clauses[0]?.schema, "dbo");
+  assert.equal(clauses[0]?.table, "Users");
+});
+
+test("preserves quoted three-part database.schema.table qualifiers", () => {
+  const clauses = parseInsertValuesClauses('INSERT INTO "OtherDb"."dbo"."Users" VALUES (1)');
+  assert.equal(clauses[0]?.database, "OtherDb");
+  assert.equal(clauses[0]?.schema, "dbo");
+  assert.equal(clauses[0]?.table, "Users");
+});
+
+test("routes three-part names through resolveTableColumns database argument", () => {
+  const sql = "INSERT INTO OtherDb.dbo.Users VALUES (1, 'a')";
+  const calls: Array<{ table: string; schema?: string; database?: string }> = [];
+  const hints = parseInsertValueHints(sql, {
+    resolveTableColumns: (table, schema, database) => {
+      calls.push({ table, schema, database });
+      if (database === "OtherDb" && schema === "dbo" && table === "Users") return ["id", "name"];
+      return ["wrong_id"];
+    },
+  });
+  assert.deepEqual(calls, [{ table: "Users", schema: "dbo", database: "OtherDb" }]);
+  assert.deepEqual(
+    hints.map((hint) => hint.column),
+    ["id", "name"],
+  );
+});
+
+test("parses only statement windows covering provided ranges", () => {
+  const prefix = `${"SELECT 1;\n".repeat(200)}`;
+  const insert = "INSERT INTO t (id, name) VALUES (1, 'x');";
+  const suffix = `\n${"SELECT 2;\n".repeat(200)}`;
+  const sql = `${prefix}${insert}${suffix}`;
+  const insertFrom = prefix.length;
+  const hints = parseInsertValueHintsInRanges(sql, [{ from: insertFrom, to: insertFrom + 10 }]);
+  assert.deepEqual(
+    hints.map((hint) => hint.column),
+    ["id", "name"],
+  );
+  assert.equal(sql.slice(hints[0]!.from, hints[0]!.from + 1), "1");
+});
+
+test("expandToSqlStatementWindow stops at neighboring statements", () => {
+  const sql = "SELECT 1; INSERT INTO t (a) VALUES (1); SELECT 2;";
+  const insertAt = sql.indexOf("INSERT");
+  const window = expandToSqlStatementWindow(sql, insertAt, insertAt + 6);
+  assert.equal(sql.slice(window.from, window.to), "INSERT INTO t (a) VALUES (1)");
+});
+
+test("ignores statements that are not INSERT VALUES", () => {
+  const sql = "SELECT 1; UPDATE users SET name = 'a' WHERE id = 1;";
+  assert.deepEqual(parseInsertValueHints(sql), []);
+});
+
+test("buildInsertValueHints skips unresolved tables without metadata", () => {
+  const clauses = parseInsertValuesClauses("INSERT INTO mystery VALUES (1, 2)");
+  assert.deepEqual(buildInsertValueHints(clauses), []);
+});
diff --git a/packages/app-tests/jdbcDialect.test.ts b/packages/app-tests/jdbcDialect.test.ts
new file mode 100644
index 0000000..0f1673f
--- /dev/null
+++ b/packages/app-tests/jdbcDialect.test.ts
@@ -0,0 +1,30 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { effectiveDatabaseTypeForConnection, inferJdbcDialect } from "../../apps/desktop/src/lib/database/jdbcDialect.ts";
+
+test("infers GoldenDB for generic JDBC connections", () => {
+  assert.equal(
+    inferJdbcDialect({
+      db_type: "jdbc",
+      connection_string: "jdbc:goldendb://127.0.0.1:3306/app",
+    }),
+    "goldendb",
+  );
+  assert.equal(
+    effectiveDatabaseTypeForConnection({
+      db_type: "jdbc",
+      jdbc_driver_class: "com.goldendb.jdbc.Driver",
+    }),
+    "goldendb",
+  );
+});
+
+test("infers JDBC dialect from driver profile", () => {
+  assert.equal(
+    inferJdbcDialect({
+      db_type: "jdbc",
+      driver_profile: "sqlserver",
+    }),
+    "sqlserver",
+  );
+});
diff --git a/packages/app-tests/jdbcPluginRelease.test.ts b/packages/app-tests/jdbcPluginRelease.test.ts
new file mode 100644
index 0000000..3e90b5a
--- /dev/null
+++ b/packages/app-tests/jdbcPluginRelease.test.ts
@@ -0,0 +1,142 @@
+import { strict as assert } from "node:assert";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { test } from "vitest";
+
+const { evaluateJdbcPluginReleaseBump } = await importScript(".github/scripts/bump-jdbc-plugin-version.mjs");
+const { evaluateJdbcPluginVersionChange } = await importScript(".github/scripts/check-jdbc-plugin-version.mjs");
+const { augmentLatestJsonWithJdbcPlugin } = await importScript(".github/scripts/augment-latest-json-jdbc-plugin.mjs");
+
+function importScript(path: string): Promise<Record<string, unknown>> {
+  const source = readFileSync(resolve(path), "utf8").replace(/^#!.*\r?\n/, "");
+  return import(`data:text/javascript;base64,${Buffer.from(source).toString("base64")}`);
+}
+
+test("allows JDBC plugin runtime changes without a manual version bump before release", () => {
+  assert.deepEqual(
+    evaluateJdbcPluginVersionChange({
+      changedFiles: ["plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java"],
+      basePomVersion: "0.1.1",
+      baseManifestVersion: "0.1.1",
+      headPomVersion: "0.1.1",
+      headManifestVersion: "0.1.1",
+    }),
+    [],
+  );
+});
+
+test("allows JDBC plugin runtime changes when pom and manifest versions are bumped together", () => {
+  assert.deepEqual(
+    evaluateJdbcPluginVersionChange({
+      changedFiles: ["plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java"],
+      basePomVersion: "0.1.1",
+      baseManifestVersion: "0.1.1",
+      headPomVersion: "0.1.2",
+      headManifestVersion: "0.1.2",
+    }),
+    [],
+  );
+});
+
+test("does not require a JDBC plugin version bump for docs or release packaging changes", () => {
+  assert.deepEqual(
+    evaluateJdbcPluginVersionChange({
+      changedFiles: ["plugins/jdbc/README.md", "plugins/jdbc/package.sh"],
+      basePomVersion: "0.1.1",
+      baseManifestVersion: "0.1.1",
+      headPomVersion: "0.1.1",
+      headManifestVersion: "0.1.1",
+    }),
+    [],
+  );
+});
+
+test("requires JDBC plugin pom and manifest versions to match", () => {
+  assert.deepEqual(
+    evaluateJdbcPluginVersionChange({
+      changedFiles: ["plugins/jdbc/manifest.json"],
+      basePomVersion: "0.1.1",
+      baseManifestVersion: "0.1.1",
+      headPomVersion: "0.1.2",
+      headManifestVersion: "0.1.1",
+    }),
+    ["JDBC plugin version mismatch: pom.xml is 0.1.2 but manifest.json is 0.1.1."],
+  );
+});
+
+test("auto bumps JDBC plugin patch version when runtime files changed for release", () => {
+  const result = evaluateJdbcPluginReleaseBump({
+    changedFiles: ["plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java"],
+    pomXml: "<project><version>0.1.9</version></project>",
+    manifestJson: '{ "version": "0.1.9" }',
+  });
+
+  assert.equal(result.changed, true);
+  assert.equal(result.oldVersion, "0.1.9");
+  assert.equal(result.newVersion, "0.1.10");
+  assert.match(result.pomXml, /<version>0\.1\.10<\/version>/);
+  assert.match(result.manifestJson, /"version": "0\.1\.10"/);
+});
+
+test("does not auto bump JDBC plugin again when release range already includes a version bump", () => {
+  const result = evaluateJdbcPluginReleaseBump({
+    changedFiles: ["plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java", "plugins/jdbc/pom.xml", "plugins/jdbc/manifest.json"],
+    pomXml: "<project><version>0.1.10</version></project>",
+    manifestJson: '{ "version": "0.1.10" }',
+  });
+
+  assert.equal(result.changed, false);
+  assert.equal(result.oldVersion, "0.1.10");
+  assert.equal(result.newVersion, "0.1.10");
+});
+
+test("does not auto bump JDBC plugin version for release packaging-only changes", () => {
+  const result = evaluateJdbcPluginReleaseBump({
+    changedFiles: ["plugins/jdbc/README.md", "plugins/jdbc/package.sh"],
+    pomXml: "<project><version>0.1.9</version></project>",
+    manifestJson: '{ "version": "0.1.9" }',
+  });
+
+  assert.equal(result.changed, false);
+  assert.equal(result.oldVersion, "0.1.9");
+  assert.equal(result.newVersion, "0.1.9");
+});
+
+test("auto bump refuses mismatched JDBC plugin source versions", () => {
+  assert.throws(
+    () =>
+      evaluateJdbcPluginReleaseBump({
+        changedFiles: ["plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java"],
+        pomXml: "<project><version>0.1.9</version></project>",
+        manifestJson: '{ "version": "0.1.8" }',
+      }),
+    /JDBC plugin version mismatch/,
+  );
+});
+
+test("adds JDBC plugin metadata to latest.json without disturbing updater fields", () => {
+  const result = augmentLatestJsonWithJdbcPlugin({
+    latestJson: JSON.stringify({
+      version: "0.5.12",
+      notes: "Release notes",
+      platforms: {
+        "darwin-aarch64": {
+          signature: "sig",
+          url: "https://example.com/app.dmg",
+        },
+      },
+    }),
+    jdbcVersion: "0.1.3",
+    protocolVersion: 1,
+    url: "https://github.com/t8y2/dbx/releases/latest/download/dbx-jdbc-plugin-latest.zip",
+  });
+  const parsed = JSON.parse(result);
+
+  assert.equal(parsed.version, "0.5.12");
+  assert.equal(parsed.platforms["darwin-aarch64"].signature, "sig");
+  assert.deepEqual(parsed.jdbc_plugin, {
+    version: "0.1.3",
+    protocol_version: 1,
+    url: "https://github.com/t8y2/dbx/releases/latest/download/dbx-jdbc-plugin-latest.zip",
+  });
+});
diff --git a/packages/app-tests/jsonCopyValue.test.ts b/packages/app-tests/jsonCopyValue.test.ts
new file mode 100644
index 0000000..cc5c03a
--- /dev/null
+++ b/packages/app-tests/jsonCopyValue.test.ts
@@ -0,0 +1,44 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { expandNestedJsonStringsForCopy } from "../../apps/desktop/src/lib/common/jsonCopyValue.ts";
+
+test("expands nested JSON strings for copied rows", () => {
+  const value = {
+    _id: "67218700e884ae1f527640b6",
+    accountId: 581,
+    data: '{"endingBalance":{"beginningBalance":"0","endingBalance":"20000","endingDate":"2024-10-30"},"financeChargeInfo":null,"interestChargeInfo":null,"Line":[]}',
+    status: "draft",
+  };
+
+  assert.deepEqual(expandNestedJsonStringsForCopy(value), {
+    _id: "67218700e884ae1f527640b6",
+    accountId: 581,
+    data: {
+      endingBalance: {
+        beginningBalance: "0",
+        endingBalance: "20000",
+        endingDate: "2024-10-30",
+      },
+      financeChargeInfo: null,
+      interestChargeInfo: null,
+      Line: [],
+    },
+    status: "draft",
+  });
+});
+
+test("recursively expands JSON strings in arrays and objects", () => {
+  const value = {
+    items: ['{"id":1,"meta":"{\\"ok\\":true}"}', "plain text"],
+  };
+
+  assert.deepEqual(expandNestedJsonStringsForCopy(value), {
+    items: [{ id: 1, meta: { ok: true } }, "plain text"],
+  });
+});
+
+test("keeps non-object JSON-like cell strings unchanged", () => {
+  assert.equal(expandNestedJsonStringsForCopy("123"), "123");
+  assert.equal(expandNestedJsonStringsForCopy('"text"'), '"text"');
+  assert.equal(expandNestedJsonStringsForCopy("2024-10-30T01:08:14.454Z"), "2024-10-30T01:08:14.454Z");
+});
diff --git a/packages/app-tests/keyboardShortcuts.test.ts b/packages/app-tests/keyboardShortcuts.test.ts
new file mode 100644
index 0000000..322e4de
--- /dev/null
+++ b/packages/app-tests/keyboardShortcuts.test.ts
@@ -0,0 +1,269 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import {
+  eventToShortcut,
+  isBrowserReloadShortcut,
+  isCancelSearchShortcut,
+  isCloseTabShortcut,
+  isCopySidebarSelectionShortcut,
+  isExecuteSqlShortcut,
+  isEditSidebarConnectionShortcut,
+  isFocusSearchShortcut,
+  isModRShortcut,
+  isNewQueryShortcut,
+  isObjectSourceSaveShortcutTarget,
+  isOpenSettingsShortcut,
+  isPasteSidebarSelectionShortcut,
+  isResetZoomShortcut,
+  isRefreshDataShortcut,
+  isSaveShortcut,
+  isSwitchToNextTabShortcut,
+  isSwitchToPreviousTabShortcut,
+  isCopyCurrentRowShortcut,
+  isDeleteCurrentRowShortcut,
+  isToggleTransposeShortcut,
+  isZoomInShortcut,
+  isZoomOutShortcut,
+  switchToTabIndexFromShortcut,
+} from "../../apps/desktop/src/lib/editor/keyboardShortcuts.ts";
+import { shortcutToCodeMirrorKey } from "../../apps/desktop/src/lib/editor/shortcutRegistry.ts";
+
+test("matches Cmd+Enter for SQL execution", () => {
+  assert.equal(isExecuteSqlShortcut({ key: "Enter", metaKey: true }), true);
+});
+
+test("matches custom shortcut settings for SQL execution", () => {
+  assert.equal(isExecuteSqlShortcut({ key: "Enter", metaKey: true }, { executeSql: "Shift+Mod+Enter" } as any), false);
+  assert.equal(
+    isExecuteSqlShortcut(
+      { key: "Enter", metaKey: true, shiftKey: true } as any,
+      {
+        executeSql: "Shift+Mod+Enter",
+      } as any,
+    ),
+    true,
+  );
+});
+
+test("records custom shortcuts from keydown events", () => {
+  assert.equal(eventToShortcut({ key: "r", metaKey: true, shiftKey: true } as any), "Shift+Mod+R");
+  assert.equal(eventToShortcut({ key: "F2" } as any), "F2");
+  assert.equal(eventToShortcut({ key: "Control", ctrlKey: true } as any), null);
+});
+
+test("converts custom shortcuts to CodeMirror key names", () => {
+  assert.equal(shortcutToCodeMirrorKey("Shift+Mod+R"), "Shift-Mod-r");
+  assert.equal(shortcutToCodeMirrorKey("Mod+/"), "Mod-/");
+});
+
+test("matches Ctrl+Enter for SQL execution", () => {
+  assert.equal(isExecuteSqlShortcut({ key: "Enter", ctrlKey: true }), true);
+});
+
+test("matches Cmd+T for opening a new query", () => {
+  assert.equal(isNewQueryShortcut({ key: "t", metaKey: true }), true);
+});
+
+test("matches Shift+Mod+brackets for switching adjacent tabs", () => {
+  assert.equal(isSwitchToPreviousTabShortcut({ key: "[", metaKey: true, shiftKey: true }), true);
+  assert.equal(isSwitchToPreviousTabShortcut({ key: "[", ctrlKey: true, shiftKey: true }), true);
+  assert.equal(isSwitchToNextTabShortcut({ key: "]", metaKey: true, shiftKey: true }), true);
+  assert.equal(isSwitchToNextTabShortcut({ key: "]", ctrlKey: true, shiftKey: true }), true);
+  assert.equal(isSwitchToPreviousTabShortcut({ key: "[", metaKey: true }), false);
+  assert.equal(isSwitchToNextTabShortcut({ key: "]", metaKey: true }), false);
+});
+
+test("matches Mod+number for switching to numbered tabs", () => {
+  assert.equal(switchToTabIndexFromShortcut({ key: "1", metaKey: true }), 0);
+  assert.equal(switchToTabIndexFromShortcut({ key: "5", ctrlKey: true }), 4);
+  assert.equal(switchToTabIndexFromShortcut({ key: "9", metaKey: true }), 8);
+  assert.equal(switchToTabIndexFromShortcut({ key: "0", metaKey: true }), null);
+  assert.equal(switchToTabIndexFromShortcut({ key: "1", metaKey: true, altKey: true }), null);
+});
+
+test("matches custom shortcut settings for tab switching", () => {
+  const shortcuts = {
+    switchToPreviousTab: "Alt+ArrowLeft",
+    switchToNextTab: "Alt+ArrowRight",
+    switchToTab3: "Shift+Mod+3",
+  } as any;
+
+  assert.equal(isSwitchToPreviousTabShortcut({ key: "[", metaKey: true }, shortcuts), false);
+  assert.equal(isSwitchToPreviousTabShortcut({ key: "ArrowLeft", altKey: true }, shortcuts), true);
+  assert.equal(isSwitchToNextTabShortcut({ key: "ArrowRight", altKey: true }, shortcuts), true);
+  assert.equal(switchToTabIndexFromShortcut({ key: "3", metaKey: true }, shortcuts), null);
+  assert.equal(switchToTabIndexFromShortcut({ key: "3", metaKey: true, shiftKey: true }, shortcuts), 2);
+});
+
+test("matches custom shortcut settings for opening a new query", () => {
+  assert.equal(isNewQueryShortcut({ key: "t", metaKey: true }, { newQuery: "Shift+Mod+N" } as any), false);
+  assert.equal(isNewQueryShortcut({ key: "n", ctrlKey: true, shiftKey: true } as any, { newQuery: "Shift+Mod+N" } as any), true);
+});
+
+test("matches Mod+Comma for opening settings", () => {
+  assert.equal(isOpenSettingsShortcut({ key: ",", metaKey: true }), true);
+  assert.equal(isOpenSettingsShortcut({ key: ",", ctrlKey: true }), true);
+  assert.equal(isOpenSettingsShortcut({ key: ",", altKey: true }), false);
+});
+
+test("matches custom shortcut settings for opening settings", () => {
+  assert.equal(isOpenSettingsShortcut({ key: ",", metaKey: true }, { openSettings: "Shift+Mod+P" } as any), false);
+  assert.equal(
+    isOpenSettingsShortcut(
+      { key: "p", ctrlKey: true, shiftKey: true } as any,
+      {
+        openSettings: "Shift+Mod+P",
+      } as any,
+    ),
+    true,
+  );
+});
+
+test("ignores Enter without modifier", () => {
+  assert.equal(isExecuteSqlShortcut({ key: "Enter" }), false);
+});
+
+test("ignores composing input events", () => {
+  assert.equal(isExecuteSqlShortcut({ key: "Enter", metaKey: true, isComposing: true }), false);
+});
+
+test("matches Cmd+W for closing query tabs", () => {
+  assert.equal(isCloseTabShortcut({ key: "w", metaKey: true }), true);
+});
+
+test("ignores Ctrl+W for closing query tabs", () => {
+  assert.equal(isCloseTabShortcut({ key: "w", ctrlKey: true }), false);
+});
+
+test("matches Ctrl+F for focusing search", () => {
+  assert.equal(isFocusSearchShortcut({ key: "f", ctrlKey: true }), true);
+});
+
+test("matches Cmd+F for focusing search", () => {
+  assert.equal(isFocusSearchShortcut({ key: "F", metaKey: true }), true);
+});
+
+test("matches F5 for refreshing data", () => {
+  assert.equal(isRefreshDataShortcut({ key: "F5" }), true);
+});
+
+test("matches configurable shortcut for toggling transpose view", () => {
+  assert.equal(isToggleTransposeShortcut({ key: "Tab" }), true);
+  assert.equal(isToggleTransposeShortcut({ key: "Tab" }, { toggleTranspose: "Alt+T" } as any), false);
+  assert.equal(isToggleTransposeShortcut({ key: "t", altKey: true }, { toggleTranspose: "Alt+T" } as any), true);
+});
+
+test("matches custom shortcut settings for refreshing data", () => {
+  assert.equal(isRefreshDataShortcut({ key: "F5" }, { refreshData: "Shift+Mod+R" } as any), false);
+  assert.equal(isRefreshDataShortcut({ key: "r", metaKey: true, shiftKey: true } as any, { refreshData: "Shift+Mod+R" } as any), true);
+});
+
+test("detects browser reload shortcuts for desktop suppression", () => {
+  assert.equal(isBrowserReloadShortcut({ key: "r", ctrlKey: true }), true);
+  assert.equal(isBrowserReloadShortcut({ key: "R", metaKey: true, shiftKey: true }), true);
+  assert.equal(isBrowserReloadShortcut({ key: "F5" }), true);
+  assert.equal(isBrowserReloadShortcut({ key: "r", altKey: true, ctrlKey: true }), false);
+  assert.equal(isBrowserReloadShortcut({ key: "r", ctrlKey: true, isComposing: true }), false);
+});
+
+test("matches Mod-R without shift or alt for scoped refresh and replace", () => {
+  assert.equal(isModRShortcut({ key: "r", ctrlKey: true }), true);
+  assert.equal(isModRShortcut({ key: "R", metaKey: true }), true);
+  assert.equal(isModRShortcut({ key: "R", metaKey: true, shiftKey: true }), false);
+  assert.equal(isModRShortcut({ key: "r", ctrlKey: true, altKey: true }), false);
+});
+
+test("matches desktop UI zoom shortcuts", () => {
+  assert.equal(isZoomInShortcut({ key: "=", ctrlKey: true }), true);
+  assert.equal(isZoomInShortcut({ key: "NumpadAdd", ctrlKey: true }), true);
+  assert.equal(isZoomOutShortcut({ key: "-", ctrlKey: true }), true);
+  assert.equal(isZoomOutShortcut({ key: "NumpadSubtract", metaKey: true }), true);
+  assert.equal(isResetZoomShortcut({ key: "0", ctrlKey: true }), true);
+  assert.equal(isResetZoomShortcut({ key: "Numpad0", metaKey: true }), true);
+});
+
+test("matches configurable desktop UI zoom shortcuts", () => {
+  assert.equal(isZoomInShortcut({ key: "i", ctrlKey: true }, { zoomInUi: "Mod+I" } as any), true);
+  assert.equal(isZoomOutShortcut({ key: "o", metaKey: true }, { zoomOutUi: "Mod+O" } as any), true);
+  assert.equal(isResetZoomShortcut({ key: "9", ctrlKey: true }, { resetUiZoom: "Mod+9" } as any), true);
+});
+
+test("ignores desktop UI zoom shortcuts with the wrong modifiers", () => {
+  assert.equal(isZoomInShortcut({ key: "=", ctrlKey: true, altKey: true }), false);
+  assert.equal(isZoomOutShortcut({ key: "-", isComposing: true, ctrlKey: true }), false);
+  assert.equal(isResetZoomShortcut({ key: "0", metaKey: true, shiftKey: true }), false);
+});
+
+test("ignores focus search shortcut while composing", () => {
+  assert.equal(isFocusSearchShortcut({ key: "f", ctrlKey: true, isComposing: true }), false);
+});
+
+test("ignores Alt+F for focusing search", () => {
+  assert.equal(isFocusSearchShortcut({ key: "f", altKey: true }), false);
+});
+
+test("matches Cmd+S for saving", () => {
+  assert.equal(isSaveShortcut({ key: "s", metaKey: true }), true);
+});
+
+test("matches Mod+D for copying current row", () => {
+  assert.equal(isCopyCurrentRowShortcut({ key: "d", metaKey: true }), true);
+});
+
+test("matches Delete for deleting current row", () => {
+  assert.equal(isDeleteCurrentRowShortcut({ key: "Delete" }), true);
+});
+
+test("matches Ctrl+S for saving", () => {
+  assert.equal(isSaveShortcut({ key: "S", ctrlKey: true }), true);
+});
+
+test("ignores save shortcut while composing", () => {
+  assert.equal(isSaveShortcut({ key: "s", metaKey: true, isComposing: true }), false);
+});
+
+test("ignores Alt+S for saving", () => {
+  assert.equal(isSaveShortcut({ key: "s", altKey: true }), false);
+});
+
+test("detects object source editor targets for contextual save", () => {
+  const target = {
+    closest: (selector: string) => (selector === "[data-object-source-editor], [data-object-source-preview]" ? {} : null),
+  };
+
+  assert.equal(isObjectSourceSaveShortcutTarget(target), true);
+});
+
+test("ignores regular editor targets for contextual object source save", () => {
+  const target = {
+    closest: () => null,
+  };
+
+  assert.equal(isObjectSourceSaveShortcutTarget(target), false);
+});
+
+test("matches Escape for cancelling search", () => {
+  assert.equal(isCancelSearchShortcut({ key: "Escape" }), true);
+});
+
+test("ignores cancelling search while composing", () => {
+  assert.equal(isCancelSearchShortcut({ key: "Escape", isComposing: true }), false);
+});
+
+test("matches configurable sidebar shortcuts", () => {
+  assert.equal(isCopySidebarSelectionShortcut({ key: "c", metaKey: true }), true);
+  assert.equal(isPasteSidebarSelectionShortcut({ key: "v", ctrlKey: true }), true);
+  assert.equal(isEditSidebarConnectionShortcut({ key: "e", metaKey: true }), true);
+
+  const shortcuts = {
+    copySidebarSelection: "Alt+C",
+    pasteSidebarSelection: "Alt+V",
+    editSidebarConnection: "Shift+Mod+E",
+  } as any;
+
+  assert.equal(isCopySidebarSelectionShortcut({ key: "c", metaKey: true }, shortcuts), false);
+  assert.equal(isCopySidebarSelectionShortcut({ key: "c", altKey: true }, shortcuts), true);
+  assert.equal(isPasteSidebarSelectionShortcut({ key: "v", altKey: true }, shortcuts), true);
+  assert.equal(isEditSidebarConnectionShortcut({ key: "e", metaKey: true }, shortcuts), false);
+  assert.equal(isEditSidebarConnectionShortcut({ key: "e", ctrlKey: true, shiftKey: true }, shortcuts), true);
+});
diff --git a/packages/app-tests/metadataLoadCoordinator.test.ts b/packages/app-tests/metadataLoadCoordinator.test.ts
new file mode 100644
index 0000000..06aa127
--- /dev/null
+++ b/packages/app-tests/metadataLoadCoordinator.test.ts
@@ -0,0 +1,169 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { createMetadataLoadTrace, MetadataLoadCoordinator } from "../../apps/desktop/src/lib/metadata/metadataLoadCoordinator.ts";
+import { metadataScopeKey } from "../../apps/desktop/src/lib/metadata/metadataLoadScope.ts";
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+test("metadata scope key treats equivalent object type sets as equal", () => {
+  const left = metadataScopeKey({
+    kind: "object-group",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    nodeKind: "group-tables",
+    objectTypes: ["view", "TABLE", "TABLE"],
+    searchFilter: "  user  ",
+    limit: 501,
+    offset: 0,
+    sidebarDisplayMode: "grouped",
+    driverProfile: "postgres",
+  });
+  const right = metadataScopeKey({
+    kind: "object-group",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    nodeKind: "group-tables",
+    objectTypes: ["TABLE", "VIEW"],
+    searchFilter: "user",
+    limit: 501,
+    offset: 0,
+    sidebarDisplayMode: "grouped",
+    driverProfile: "postgres",
+  });
+
+  assert.equal(left, right);
+});
+
+test("metadata scope key separates result-affecting fields", () => {
+  const base = {
+    kind: "sidebar-table-search",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    objectTypes: ["TABLE"],
+    limit: 500,
+    offset: 0,
+    sidebarDisplayMode: "simple",
+    driverProfile: "postgres",
+  };
+
+  assert.notEqual(metadataScopeKey({ ...base, searchFilter: "user" }), metadataScopeKey({ ...base, searchFilter: "order" }));
+  assert.notEqual(metadataScopeKey({ ...base, offset: 0 }), metadataScopeKey({ ...base, offset: 500 }));
+  assert.notEqual(metadataScopeKey({ ...base, objectTypes: ["TABLE"] }), metadataScopeKey({ ...base, objectTypes: ["VIEW"] }));
+  assert.notEqual(metadataScopeKey({ ...base, sidebarDisplayMode: "simple" }), metadataScopeKey({ ...base, sidebarDisplayMode: "grouped" }));
+});
+
+test("metadata load coordinator deduplicates equivalent in-flight loads", async () => {
+  const events: string[] = [];
+  const coordinator = new MetadataLoadCoordinator((event) => events.push(event.event));
+  const gate = deferred<string>();
+  let calls = 0;
+  const scope = { kind: "database-schemas", connectionId: "conn", database: "app", driverProfile: "postgres" };
+  const first = coordinator.run(scope, async () => {
+    calls++;
+    return gate.promise;
+  });
+  const second = coordinator.run(scope, async () => {
+    calls++;
+    return "unexpected";
+  });
+
+  assert.equal(calls, 0);
+  await Promise.resolve();
+  assert.equal(calls, 1);
+  assert.equal(first, second);
+  assert.deepEqual(events.slice(0, 2), ["start", "dedupe"]);
+
+  gate.resolve("schemas");
+  assert.equal(await first, "schemas");
+  assert.equal(await second, "schemas");
+  assert.equal(coordinator.has(scope), false);
+});
+
+test("metadata load coordinator keeps different filters independent", async () => {
+  const coordinator = new MetadataLoadCoordinator();
+  const first = deferred<string>();
+  const second = deferred<string>();
+  let calls = 0;
+
+  const user = coordinator.run({ kind: "sidebar-table-search", connectionId: "conn", database: "app", schema: "public", searchFilter: "user" }, async () => {
+    calls++;
+    return first.promise;
+  });
+  const order = coordinator.run({ kind: "sidebar-table-search", connectionId: "conn", database: "app", schema: "public", searchFilter: "order" }, async () => {
+    calls++;
+    return second.promise;
+  });
+
+  await Promise.resolve();
+  assert.equal(calls, 2);
+  first.resolve("users");
+  second.resolve("orders");
+  assert.deepEqual(await Promise.all([user, order]), ["users", "orders"]);
+});
+
+test("metadata load coordinator force bypasses in-flight reuse", async () => {
+  const coordinator = new MetadataLoadCoordinator();
+  const slow = deferred<string>();
+  let calls = 0;
+  const scope = { kind: "connection-databases", connectionId: "conn" };
+  const normal = coordinator.run(scope, async () => {
+    calls++;
+    return slow.promise;
+  });
+  const forced = coordinator.run(
+    scope,
+    async () => {
+      calls++;
+      return "fresh";
+    },
+    { force: true },
+  );
+
+  assert.equal(await forced, "fresh");
+  assert.equal(calls, 2);
+  slow.resolve("cached");
+  assert.equal(await normal, "cached");
+});
+
+test("metadata load trace reports scope, elapsed time, cache and request state", () => {
+  let now = 100;
+  const trace = createMetadataLoadTrace(
+    {
+      kind: "table-metadata",
+      connectionId: "conn",
+      database: "app",
+      schema: "public",
+      tableName: "users",
+    },
+    { traceId: "trace-1", now: () => now },
+  );
+
+  now = 137;
+  assert.deepEqual(trace.event("done", { cacheStatus: "stale", resultCount: 12, deduped: true, superseded: false }), {
+    event: "done",
+    traceId: "trace-1",
+    scopeKey: metadataScopeKey({
+      kind: "table-metadata",
+      connectionId: "conn",
+      database: "app",
+      schema: "public",
+      tableName: "users",
+    }),
+    elapsedMs: 37,
+    cacheStatus: "stale",
+    resultCount: 12,
+    deduped: true,
+    superseded: false,
+  });
+});
diff --git a/packages/app-tests/metadataResultCache.test.ts b/packages/app-tests/metadataResultCache.test.ts
new file mode 100644
index 0000000..a478cfc
--- /dev/null
+++ b/packages/app-tests/metadataResultCache.test.ts
@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { MetadataResultCache } from "../../apps/desktop/src/lib/metadata/metadataResultCache.ts";
+
+test("metadata result cache returns fresh hits and exposes stale hits when requested", () => {
+  let now = 1_000;
+  const cache = new MetadataResultCache<string>({ ttlMs: 50, maxEntries: 10, now: () => now });
+  const scope = { kind: "table-list-page", connectionId: "conn", database: "app", schema: "public", limit: 501, offset: 0 };
+
+  cache.set(scope, "tables");
+  assert.equal(cache.get(scope)?.value, "tables");
+
+  now = 1_100;
+  assert.equal(cache.get(scope), undefined);
+  const stale = cache.get(scope, { allowStale: true });
+  assert.equal(stale?.value, "tables");
+  assert.equal(stale?.stale, true);
+  assert.equal(stale?.ageMs, 100);
+});
+
+test("metadata result cache invalidates affected scopes without clearing unrelated databases", () => {
+  const cache = new MetadataResultCache<string>({ ttlMs: 30_000, maxEntries: 10, now: () => 1 });
+  const publicTables = { kind: "table-list-page", connectionId: "conn", database: "app", schema: "public", objectTypes: ["VIEW", "TABLE"], limit: 501, offset: 0 };
+  const auditTables = { kind: "table-list-page", connectionId: "conn", database: "app", schema: "audit", objectTypes: ["TABLE"], limit: 501, offset: 0 };
+  const otherDatabase = { kind: "table-list-page", connectionId: "conn", database: "other", schema: "public", objectTypes: ["TABLE"], limit: 501, offset: 0 };
+  const otherConnection = { kind: "table-list-page", connectionId: "other", database: "app", schema: "public", objectTypes: ["TABLE"], limit: 501, offset: 0 };
+
+  cache.set(publicTables, "public");
+  cache.set(auditTables, "audit");
+  cache.set(otherDatabase, "other-db");
+  cache.set(otherConnection, "other-conn");
+
+  assert.equal(cache.invalidate({ connectionId: "conn", database: "app", schema: "public" }), 1);
+  assert.equal(cache.get(publicTables), undefined);
+  assert.equal(cache.get(auditTables)?.value, "audit");
+  assert.equal(cache.get(otherDatabase)?.value, "other-db");
+  assert.equal(cache.get(otherConnection)?.value, "other-conn");
+});
+
+test("metadata result cache evicts least recently used entries", () => {
+  const cache = new MetadataResultCache<string>({ ttlMs: 30_000, maxEntries: 2, now: () => 1 });
+  const first = { kind: "object-list-page", connectionId: "conn", database: "app", schema: "public", nodeKind: "group-functions" };
+  const second = { kind: "object-list-page", connectionId: "conn", database: "app", schema: "audit", nodeKind: "group-functions" };
+  const third = { kind: "object-list-page", connectionId: "conn", database: "other", schema: "public", nodeKind: "group-functions" };
+
+  cache.set(first, "first");
+  cache.set(second, "second");
+  assert.equal(cache.get(first)?.value, "first");
+  cache.set(third, "third");
+
+  assert.equal(cache.get(first)?.value, "first");
+  assert.equal(cache.get(second), undefined);
+  assert.equal(cache.get(third)?.value, "third");
+});
diff --git a/packages/app-tests/metadataTaskLimiter.test.ts b/packages/app-tests/metadataTaskLimiter.test.ts
new file mode 100644
index 0000000..a5ea1ea
--- /dev/null
+++ b/packages/app-tests/metadataTaskLimiter.test.ts
@@ -0,0 +1,74 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { MetadataTaskLimiter } from "../../apps/desktop/src/lib/metadata/metadataTaskLimiter.ts";
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+test("metadata task limiter caps active tasks per scope and drains queued tasks", async () => {
+  const events: Array<{ event: string; active: number; queued: number; kind: string }> = [];
+  const limiter = new MetadataTaskLimiter(2, (event) => events.push(event));
+  const gates = [deferred<number>(), deferred<number>(), deferred<number>(), deferred<number>()];
+  let active = 0;
+  let maxActive = 0;
+
+  const tasks = gates.map((gate, index) =>
+    limiter.run("conn:db", `task-${index}`, async () => {
+      active++;
+      maxActive = Math.max(maxActive, active);
+      const result = await gate.promise;
+      active--;
+      return result;
+    }),
+  );
+
+  assert.equal(maxActive, 2);
+  assert.deepEqual(
+    events.filter((event) => event.event === "queued").map((event) => event.queued),
+    [1, 2],
+  );
+
+  gates[0].resolve(1);
+  await Promise.resolve();
+  await Promise.resolve();
+  assert.equal(maxActive, 2);
+
+  gates[1].resolve(2);
+  gates[2].resolve(3);
+  gates[3].resolve(4);
+
+  assert.deepEqual(await Promise.all(tasks), [1, 2, 3, 4]);
+  assert.equal(maxActive, 2);
+});
+
+test("metadata task limiter isolates independent scopes", async () => {
+  const limiter = new MetadataTaskLimiter(1);
+  const first = deferred<string>();
+  const second = deferred<string>();
+  let active = 0;
+
+  const a = limiter.run("conn:a", "columns", async () => {
+    active++;
+    const result = await first.promise;
+    active--;
+    return result;
+  });
+  const b = limiter.run("conn:b", "columns", async () => {
+    active++;
+    const result = await second.promise;
+    active--;
+    return result;
+  });
+
+  assert.equal(active, 2);
+  first.resolve("a");
+  second.resolve("b");
+  assert.deepEqual(await Promise.all([a, b]), ["a", "b"]);
+});
diff --git a/packages/app-tests/mongoCompletion.test.ts b/packages/app-tests/mongoCompletion.test.ts
new file mode 100644
index 0000000..7f3e26c
--- /dev/null
+++ b/packages/app-tests/mongoCompletion.test.ts
@@ -0,0 +1,134 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildMongoCompletionItems, getMongoCompletionContext, inferMongoCompletionFields, shouldAutoOpenMongoCompletion } from "../../apps/desktop/src/lib/mongo/mongoCompletion.ts";
+
+const collections = ["users", "user_events", "order-items"];
+const fields = [
+    { name: "_id", type: "object" },
+    { name: "name", type: "string" },
+    { name: "profile.email", type: "string" },
+    { name: "createdAt", type: "string" },
+];
+
+function labels(text: string, input = {}) {
+    return buildMongoCompletionItems(text, text.length, input).map((item) => item.label);
+}
+
+test("suggests MongoDB root snippets and methods", () => {
+    const items = buildMongoCompletionItems("fi", 2);
+
+    assert.ok(items.some((item) => item.type === "function" && item.label === "find" && item.apply === "find({})"));
+    assert.equal(items.some((item) => item.label === "SELECT"), false);
+});
+
+test("suggests collections after db dot", () => {
+    const items = buildMongoCompletionItems("db.us", "db.us".length, { collections });
+
+    assert.deepEqual(
+        items.filter((item) => item.type === "table" && item.detail === "collection").map((item) => item.label),
+        ["users", "user_events"],
+    );
+});
+
+test("uses getCollection apply text for unsafe collection names", () => {
+    const item = buildMongoCompletionItems("db.order", "db.order".length, { collections }).find((candidate) => candidate.label === "order-items");
+
+    assert.equal(item?.apply, 'getCollection("order-items")');
+});
+
+test("suggests collection methods after direct and getCollection references", () => {
+    assert.ok(labels("db.users.").includes("find"));
+    assert.ok(labels('db.getCollection("users").ag').includes("aggregate"));
+});
+
+test("suggests collection stats methods after a collection reference", () => {
+    const methodLabels = labels("db.users.");
+    for (const method of ["stats", "dataSize", "storageSize", "totalIndexSize"]) {
+        assert.ok(methodLabels.includes(method), `expected completion to include ${method}`);
+    }
+    const item = buildMongoCompletionItems("db.users.stat", "db.users.stat".length).find((candidate) => candidate.label === "stats");
+    assert.equal(item?.apply, "stats()");
+});
+
+test("suggests cursor methods after find result chains", () => {
+    const allItems = buildMongoCompletionItems("db.characters.find({}).", "db.characters.find({}).".length);
+    const prefixedItems = buildMongoCompletionItems("db.characters.find({}).li", "db.characters.find({}).li".length);
+    const formattedChainItems = buildMongoCompletionItems("db.characters.find({\n  name: 'Ada'\n})\n  .", "db.characters.find({\n  name: 'Ada'\n})\n  .".length);
+    const formattedPrefixedItems = buildMongoCompletionItems("db.characters.find({\n  name: 'Ada'\n})\n  .li", "db.characters.find({\n  name: 'Ada'\n})\n  .li".length);
+
+    assert.deepEqual(
+        allItems.map((item) => item.label),
+        ["limit", "skip", "sort"],
+    );
+    assert.deepEqual(
+        prefixedItems.map((item) => item.label),
+        ["limit"],
+    );
+    assert.deepEqual(
+        formattedChainItems.map((item) => item.label),
+        ["limit", "skip", "sort"],
+    );
+    assert.deepEqual(
+        formattedPrefixedItems.map((item) => item.label),
+        ["limit"],
+    );
+});
+
+test("suggests observed fields inside query objects", () => {
+    const items = buildMongoCompletionItems('db.users.find({ "pro', 'db.users.find({ "pro'.length, { fields });
+    const email = items.find((item) => item.label === "profile.email");
+
+    assert.equal(email?.detail, "observed field · string");
+    assert.equal(email?.type, "column");
+    assert.equal(email?.apply, '"profile.email": ');
+});
+
+test("suggests query fields at object starts and after commas", () => {
+    const objectStart = buildMongoCompletionItems("db.users.find({", "db.users.find({".length, { fields });
+    const afterComma = buildMongoCompletionItems("db.users.find({ name: 'Ada', ", "db.users.find({ name: 'Ada', ".length, { fields });
+
+    assert.ok(objectStart.find((item) => item.label === "name" && item.apply === "name: "));
+    assert.ok(afterComma.find((item) => item.label === "createdAt" && item.apply === "createdAt: "));
+});
+
+test("suggests query operators inside field value objects", () => {
+    const items = buildMongoCompletionItems("db.users.find({ age: { ", "db.users.find({ age: { ".length, { fields });
+
+    assert.ok(items.find((item) => item.label === "$gte"));
+    assert.equal(items.some((item) => item.label === "name"), false);
+});
+
+test("suggests query and update operators", () => {
+    assert.ok(labels("db.users.find({ age: { $g").includes("$gte"));
+    assert.ok(labels("db.users.updateOne({}, { $s").includes("$set"));
+});
+
+test("suggests aggregation stages inside aggregate pipeline", () => {
+    const items = buildMongoCompletionItems("db.users.aggregate([{ $m", "db.users.aggregate([{ $m".length);
+
+    assert.ok(items.find((item) => item.label === "$match" && item.detail === "aggregation stage"));
+});
+
+test("completion context is tolerant of unfinished input", () => {
+    const context = getMongoCompletionContext('db.getCollection("users").find({ "', 'db.getCollection("users").find({ "'.length);
+
+    assert.equal(context.mode, "field");
+    assert.equal(context.collection, "users");
+});
+
+test("auto trigger opens for useful MongoDB characters only", () => {
+    assert.equal(shouldAutoOpenMongoCompletion("db.", "db.".length), true);
+    assert.equal(shouldAutoOpenMongoCompletion("db.users.find({ $", "db.users.find({ $".length), true);
+    assert.equal(shouldAutoOpenMongoCompletion("db.users.find({", "db.users.find({".length), true);
+});
+
+test("infers dotted MongoDB fields from sampled documents", () => {
+    const inferred = inferMongoCompletionFields([
+        { _id: "1", profile: { email: "a@example.com" }, tags: ["a"] },
+        { _id: "2", profile: { age: 3 }, tags: [{ label: "vip" }] },
+    ]);
+
+    assert.ok(inferred.find((field) => field.name === "profile.email" && field.type === "string"));
+    assert.ok(inferred.find((field) => field.name === "profile.age" && field.type === "number"));
+    assert.ok(inferred.find((field) => field.name === "tags.label" && field.type === "string"));
+});
diff --git a/packages/app-tests/mongoConnectionOptions.test.ts b/packages/app-tests/mongoConnectionOptions.test.ts
new file mode 100644
index 0000000..0d22927
--- /dev/null
+++ b/packages/app-tests/mongoConnectionOptions.test.ts
@@ -0,0 +1,104 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { mongoUrlParam, mongoUrlParamIsTrue, normalizeMongoTlsFormState, setMongoUrlParam, setMongoUrlParamBoolean, mongodbAuthFailureHint } from "../../apps/desktop/src/lib/mongo/mongoConnectionOptions.ts";
+
+test("reads MongoDB authSource from URL params", () => {
+  assert.equal(mongoUrlParam("?replicaSet=rs0&authSource=admin", "authSource"), "admin");
+});
+
+test("sets MongoDB authSource while preserving other URL params", () => {
+  assert.equal(setMongoUrlParam("replicaSet=rs0", "authSource", "admin"), "replicaSet=rs0&authSource=admin");
+});
+
+test("removes empty MongoDB authSource from URL params", () => {
+  assert.equal(setMongoUrlParam("replicaSet=rs0&authSource=admin", "authSource", ""), "replicaSet=rs0");
+});
+
+test("reads MongoDB boolean URL params", () => {
+  assert.equal(mongoUrlParamIsTrue("tlsAllowInvalidCertificates=true", "tlsAllowInvalidCertificates"), true);
+  assert.equal(mongoUrlParamIsTrue("retryWrites=false", "retryWrites", true), false);
+  assert.equal(mongoUrlParamIsTrue("", "retryWrites", true), true);
+});
+
+test("sets MongoDB boolean URL params", () => {
+  assert.equal(setMongoUrlParamBoolean("replicaSet=rs0", "retryWrites", false, true), "replicaSet=rs0&retryWrites=false");
+  assert.equal(setMongoUrlParamBoolean("replicaSet=rs0&retryWrites=false", "retryWrites", true, true), "replicaSet=rs0");
+  assert.equal(setMongoUrlParamBoolean("", "tlsAllowInvalidCertificates", true), "tlsAllowInvalidCertificates=true");
+});
+
+test("clears MongoDB TLS form state when SSL is disabled", () => {
+  assert.deepEqual(
+    normalizeMongoTlsFormState(false, "replicaSet=rs0&tlsAllowInvalidCertificates=true&tlsAllowInvalidHostnames=true&tlsCAFile=%2Ftmp%2Fca.pem", "/tmp/ca.pem"),
+    { urlParams: "replicaSet=rs0", caCertPath: "" },
+  );
+  assert.deepEqual(normalizeMongoTlsFormState(true, "replicaSet=rs0", " /tmp/ca.pem "), {
+    urlParams: "replicaSet=rs0",
+    caCertPath: "/tmp/ca.pem",
+  });
+});
+
+test("preserves MongoDB tlsCAFile in URL params when caCertPath is empty", () => {
+  assert.deepEqual(normalizeMongoTlsFormState(true, "replicaSet=rs0&tlsCAFile=%2Ftmp%2Flegacy-ca.pem", ""), {
+    urlParams: "replicaSet=rs0&tlsCAFile=%2Ftmp%2Flegacy-ca.pem",
+    caCertPath: "",
+  });
+});
+
+test("form caCertPath overrides tlsCAFile in URL params when set", () => {
+  assert.deepEqual(normalizeMongoTlsFormState(true, "replicaSet=rs0&tlsCAFile=%2Ftmp%2Flegacy-ca.pem", "/tmp/explicit-ca.pem"), {
+    urlParams: "replicaSet=rs0",
+    caCertPath: "/tmp/explicit-ca.pem",
+  });
+});
+
+test("adds a MongoDB authSource hint for legacy authentication failures", () => {
+  const message = "Agent RPC error: Exception authenticating MongoCredential{mechanism=SCRAM-SHA-1, userName='rwuser', source='gray_lite_twin_fat'}";
+
+  assert.equal(
+    mongodbAuthFailureHint(message),
+    "Agent RPC error: Exception authenticating MongoCredential{mechanism=SCRAM-SHA-1, userName='rwuser', source='gray_lite_twin_fat'}\n\nCurrent authentication database: gray_lite_twin_fat. If this user was created in admin, set Authentication database to admin or add authSource=admin to URL params.",
+  );
+});
+
+test("adds a MongoDB URL encoding hint for reserved password characters", () => {
+  const message = "MongoDB connection failed: Kind: An invalid argument was provided: password must be URL encoded";
+
+  assert.match(mongodbAuthFailureHint(message), /@ becomes %40/);
+});
+
+test("adds a MongoDB directConnection multi-host hint", () => {
+  const message = "MongoDB connection failed: Kind: An invalid argument was provided: cannot specify multiple seeds with directConnection=true";
+
+  assert.match(mongodbAuthFailureHint(message), /Remove directConnection=true when using a multi-host replica set URL/);
+});
+
+test("adds a MongoDB SRV DNS hint for IP endpoints", () => {
+  const message = 'MongoDB connection failed: Kind: An error occurred during DNS resolution: DNS error: no records found for Query { name: Name("_mongodb._tcp.172.17.0.1."), query_type: SRV }';
+
+  assert.match(mongodbAuthFailureHint(message), /use mongodb:\/\/host:port instead of mongodb\+srv:\/\/host/);
+});
+
+test("adds a MongoDB replica set localhost advertisement hint", () => {
+  const message = "MongoDB connection failed: Kind: Server selection timeout: No available servers. Topology: { Type: ReplicaSetNoPrimary, Set Name: LIMLIU, Servers: [ { Address: 127.0.0.1:27017, Type: Unknown, Error: Kind: I/O error: Connection refused (os error 111) } ] }";
+
+  assert.match(mongodbAuthFailureHint(message), /Add directConnection=true/);
+});
+
+test("adds a MongoDB listDatabases permission hint", () => {
+  const message = "Command failed with error 13 (Unauthorized): not authorized on admin to execute command { listDatabases: 1 }";
+
+  assert.match(mongodbAuthFailureHint(message), /does not have permission to run listDatabases/);
+});
+
+test("adds a MongoDB rustls hint for tlsAllowInvalidHostnames", () => {
+  const message = "MongoDB connection failed: Kind: An invalid argument was provided: tlsAllowInvalidHostnames is an invalid option";
+
+  assert.match(mongodbAuthFailureHint(message), /tlsAllowInvalidCertificates=true/);
+});
+
+test("adds a MongoDB DocumentDB SSH tunnel hostname hint", () => {
+  const message =
+    'MongoDB connection failed: Kind: Server selection timeout: invalid peer certificate: certificate not valid for name "127.0.0.1"; certificate is only valid for DnsName("docdb-2023-06-13-09-23-15.ctofbpmjm2lc.ap-northeast-1.docdb.amazonaws.com")';
+
+  assert.match(mongodbAuthFailureHint(message), /tlsAllowInvalidCertificates=true/);
+});
diff --git a/packages/app-tests/mongoDocumentValues.test.ts b/packages/app-tests/mongoDocumentValues.test.ts
new file mode 100644
index 0000000..5695c7e
--- /dev/null
+++ b/packages/app-tests/mongoDocumentValues.test.ts
@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { applyMongoGridChangesToDocument, buildMongoCopyInsertDocument, buildMongoInsertDocument, buildMongoUpdateDocument, formatMongoShellLiteral, parseMongoDocumentInputValue } from "../../apps/desktop/src/lib/mongo/mongoDocumentValues.ts";
+
+test("parses Mongo shell ISODate literals as extended JSON dates", () => {
+  assert.deepEqual(parseMongoDocumentInputValue('ISODate("2026-06-10T13:59:31.287Z")'), {
+    $date: "2026-06-10T13:59:31.287Z",
+  });
+  assert.deepEqual(parseMongoDocumentInputValue('"ISODate(\\"2026-06-10T13:59:31.287Z\\")"'), {
+    $date: "2026-06-10T13:59:31.287Z",
+  });
+});
+
+test("parses legacy Mongo date display values as UTC dates", () => {
+  assert.deepEqual(parseMongoDocumentInputValue("2025-08-14 02:25:43.718"), {
+    $date: "2025-08-14T02:25:43.718Z",
+  });
+  assert.equal(parseMongoDocumentInputValue('"2025-08-14 02:25:43.718"'), "2025-08-14 02:25:43.718");
+});
+
+test("builds Mongo grid updates with set and unset operators", () => {
+  const changes = new Map<number, string | number | boolean | null>([
+    [1, "Ada"],
+    [2, 'ISODate("2026-06-10T13:59:31.287Z")'],
+    [3, null],
+  ]);
+
+  assert.deepEqual(buildMongoUpdateDocument(changes, ["_id", "name", "createdAt", "archivedAt"]), {
+    $set: {
+      name: "Ada",
+      createdAt: { $date: "2026-06-10T13:59:31.287Z" },
+    },
+    $unset: {
+      archivedAt: "",
+    },
+  });
+});
+
+test("applies saved Mongo grid changes to the raw preview document", () => {
+  const original = {
+    _id: "1",
+    name: "Ada",
+    profile: { role: "admin" },
+    archivedAt: "2026-01-01",
+  };
+  const changes = new Map<number, string | number | boolean | null>([
+    [1, "Lin"],
+    [2, '{"role":"maintainer"}'],
+    [3, null],
+  ]);
+
+  assert.deepEqual(applyMongoGridChangesToDocument(original, changes, ["_id", "name", "profile", "archivedAt"]), {
+    _id: "1",
+    name: "Lin",
+    profile: { role: "maintainer" },
+  });
+  assert.deepEqual(original, {
+    _id: "1",
+    name: "Ada",
+    profile: { role: "admin" },
+    archivedAt: "2026-01-01",
+  });
+});
+
+test("builds Mongo inserts with parsed date values", () => {
+  assert.deepEqual(buildMongoInsertDocument(["ignored", 'new Date("2026-06-10T13:59:31.287Z")'], ["_id", "createdAt"]), {
+    createdAt: { $date: "2026-06-10T13:59:31.287Z" },
+  });
+});
+
+test("builds Mongo copy inserts with ObjectId and parsed document values", () => {
+  assert.deepEqual(buildMongoCopyInsertDocument(["6743e4bfa3f6f84bc3fff6c8", "577", '{"endingBalance":{"beginningBalance":"0"},"Line":[]}', 'ISODate("2024-11-25T02:45:36.184Z")'], ["_id", "accountId", "data", "lastUpdatedDate"]), {
+    _id: { $oid: "6743e4bfa3f6f84bc3fff6c8" },
+    accountId: 577,
+    data: {
+      endingBalance: {
+        beginningBalance: "0",
+      },
+      Line: [],
+    },
+    lastUpdatedDate: { $date: "2024-11-25T02:45:36.184Z" },
+  });
+});
+
+test("builds Mongo copy inserts without primary keys when requested", () => {
+  assert.deepEqual(buildMongoCopyInsertDocument(["6743e4bfa3f6f84bc3fff6c8", "done"], ["_id", "status"], { excludePrimaryKeys: true }), {
+    status: "done",
+  });
+});
+
+test("formats extended JSON dates as Mongo shell ISODate literals", () => {
+  assert.equal(
+    formatMongoShellLiteral({
+      $set: {
+        createdAt: { $date: "2026-06-10T13:59:31.287Z" },
+      },
+    }),
+    '{"$set":{"createdAt":ISODate("2026-06-10T13:59:31.287Z")}}',
+  );
+});
+
+test("formats extended JSON object ids as Mongo shell ObjectId literals", () => {
+  assert.equal(formatMongoShellLiteral({ $oid: "6743e4bfa3f6f84bc3fff6c8" }), 'ObjectId("6743e4bfa3f6f84bc3fff6c8")');
+});
+
+test("formats extended JSON int64 values as Mongo shell NumberLong literals", () => {
+  assert.equal(formatMongoShellLiteral({ snowflake: { $numberLong: "9007199254740993" } }), '{"snowflake":NumberLong("9007199254740993")}');
+});
diff --git a/packages/app-tests/mongoFormatter.test.ts b/packages/app-tests/mongoFormatter.test.ts
new file mode 100644
index 0000000..d013f79
--- /dev/null
+++ b/packages/app-tests/mongoFormatter.test.ts
@@ -0,0 +1,67 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { formatMongoShellText, MAX_MONGO_FORMAT_CHARS } from "../../apps/desktop/src/lib/mongo/mongoFormatter.ts";
+
+test("formats MongoDB find query objects", () => {
+    assert.equal(
+        formatMongoShellText('db.characters.find({name:"Ada",age:{$gte:18,$lt:30}}).sort({createdAt:-1}).limit(20)'),
+        `db.characters.find({
+  name: "Ada",
+  age: {
+    $gte: 18,
+    $lt: 30
+  }
+})
+  .sort({
+    createdAt: -1
+  })
+  .limit(20)`,
+    );
+});
+
+test("formats MongoDB aggregation pipelines", () => {
+    assert.equal(
+        formatMongoShellText('db.orders.aggregate([{$match:{status:"paid"}},{$group:{_id:"$userId",total:{$sum:"$amount"}}}])'),
+        `db.orders.aggregate([
+  {
+    $match: {
+      status: "paid"
+    }
+  },
+  {
+    $group: {
+      _id: "$userId",
+      total: {
+        $sum: "$amount"
+      }
+    }
+  }
+])`,
+    );
+});
+
+test("preserves strings, regex literals, and comments", () => {
+    assert.equal(
+        formatMongoShellText('db.users.find({name:/a,b\\/c/i,note:"x,y",active:true}) // keep comment'),
+        `db.users.find({
+  name: /a,b\\/c/i,
+  note: "x,y",
+  active: true
+}) // keep comment`,
+    );
+});
+
+test("respects tab indentation setting", () => {
+    assert.equal(
+        formatMongoShellText("db.users.find({name:'Ada'})", { useTabs: true, tabWidth: 4 }),
+        "db.users.find({\n\tname: 'Ada'\n})",
+    );
+});
+
+test("leaves blank MongoDB text unchanged", () => {
+    assert.equal(formatMongoShellText("  \n\t"), "  \n\t");
+});
+
+test("rejects very large MongoDB queries", () => {
+    assert.throws(() => formatMongoShellText("x".repeat(MAX_MONGO_FORMAT_CHARS + 1)), /too large/i);
+});
diff --git a/packages/app-tests/mongoShellCommand.test.ts b/packages/app-tests/mongoShellCommand.test.ts
new file mode 100644
index 0000000..91f1166
--- /dev/null
+++ b/packages/app-tests/mongoShellCommand.test.ts
@@ -0,0 +1,533 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import {
+  evaluateMongoAggregateSafety,
+  evaluateMongoWriteSafety,
+  mongoAggregateWriteStage,
+  mongoCollectionStatsToQueryResult,
+  mongoCountToQueryResult,
+  mongoDocumentsToQueryResult,
+  mongoIndexesToQueryResult,
+  parseMongoAggregateCommand,
+  parseMongoCollectionStatsCommand,
+  parseMongoCommand,
+  parseMongoCountDocumentsCommand,
+  parseMongoFindCommand,
+  parseMongoGetIndexesCommand,
+  parseMongoVersionCommand,
+  parseMongoWriteCommand,
+  splitMongoCommands,
+  splitMongoCommandRanges,
+} from "../../apps/desktop/src/lib/mongo/mongoShellCommand.ts";
+import { buildMongoUpdateDocument as buildMongoDocumentUpdate, formatMongoShellLiteral as formatMongoDocumentShellLiteral } from "../../apps/desktop/src/lib/mongo/mongoDocumentValues.ts";
+
+test("parseMongoFindCommand parses db collection find with an empty JSON filter", () => {
+  assert.deepEqual(parseMongoFindCommand("db.users.find({})"), {
+    collection: "users",
+    filter: "{}",
+    skip: 0,
+    limit: 100,
+    sort: undefined,
+  });
+});
+
+test("parseMongoFindCommand parses getCollection find with chained sort skip and limit", () => {
+  assert.deepEqual(parseMongoFindCommand('db.getCollection("audit.logs").find({"level":"warn"}).sort({"createdAt":-1}).skip(20).limit(10)'), {
+    collection: "audit.logs",
+    filter: '{"level":"warn"}',
+    skip: 20,
+    limit: 10,
+    sort: '{"createdAt":-1}',
+  });
+});
+
+test("parseMongoFindCommand accepts line breaks before find and chained calls", () => {
+  const command = parseMongoFindCommand(`db.getCollection("accounting_reconciliations")
+.find({
+  "_id": ObjectId("68ad51ca84c8127bc7d44cb3")
+})
+.sort({ lineNo: -1 })
+.skip(5)
+.limit(20)`);
+  assert.ok(command);
+  assert.equal(command.collection, "accounting_reconciliations");
+  assert.deepEqual(JSON.parse(command.filter), { _id: { $oid: "68ad51ca84c8127bc7d44cb3" } });
+  assert.deepEqual(JSON.parse(command.sort || "{}"), { lineNo: -1 });
+  assert.equal(command.skip, 5);
+  assert.equal(command.limit, 20);
+});
+
+test("parseMongoFindCommand accepts Compass-style unquoted keys and ObjectId", () => {
+  const command = parseMongoFindCommand("db.products.find({_id: ObjectId('6a045a92d2971e44243771a1')}).limit(1)");
+  assert.ok(command);
+  assert.equal(command.collection, "products");
+  assert.equal(command.limit, 1);
+  assert.deepEqual(JSON.parse(command.filter), { _id: { $oid: "6a045a92d2971e44243771a1" } });
+});
+
+test("parseMongoFindCommand rewrites ISODate into extended JSON $date", () => {
+  const command = parseMongoFindCommand(`db.trainingdocuments.find({
+    createdAt: { $gte: ISODate("2025-02-25T04:57:39.965Z") }
+  })`);
+  assert.ok(command);
+  assert.equal(command.collection, "trainingdocuments");
+  assert.deepEqual(JSON.parse(command.filter), { createdAt: { $gte: { $date: "2025-02-25T04:57:39.965Z" } } });
+});
+
+test("parseMongoFindCommand rewrites new Date and single-quoted ISODate", () => {
+  const command = parseMongoFindCommand("db.events.find({ at: { $lt: new Date('2025-01-01T00:00:00Z'), $gte: ISODate('2024-01-01T00:00:00Z') } })");
+  assert.ok(command);
+  assert.deepEqual(JSON.parse(command.filter), {
+    at: { $lt: { $date: "2025-01-01T00:00:00Z" }, $gte: { $date: "2024-01-01T00:00:00Z" } },
+  });
+});
+
+test("parseMongoFindCommand accepts single-quoted string values and unquoted sort keys", () => {
+  const command = parseMongoFindCommand("db.products.find({category: 'Electronics'}).sort({price: -1}).limit(2)");
+  assert.ok(command);
+  assert.equal(command.collection, "products");
+  assert.equal(command.limit, 2);
+  assert.deepEqual(JSON.parse(command.filter), { category: "Electronics" });
+  assert.deepEqual(JSON.parse(command.sort || "{}"), { price: -1 });
+});
+
+test("parseMongoFindCommand parses projection arguments", () => {
+  const command = parseMongoFindCommand(`db.jobs.find({ status: "open" }, {
+    title: 1,
+    _id: 0
+  }).sort({ title: 1 })`);
+  assert.ok(command);
+  assert.equal(command.collection, "jobs");
+  assert.deepEqual(JSON.parse(command.filter), { status: "open" });
+  assert.deepEqual(JSON.parse(command.projection || "{}"), { title: 1, _id: 0 });
+  assert.deepEqual(JSON.parse(command.sort || "{}"), { title: 1 });
+});
+
+test("parseMongoFindCommand rejects unsupported mongo shell commands", () => {
+  assert.equal(parseMongoFindCommand("db.users.drop()"), null);
+  assert.equal(parseMongoFindCommand("db.users.find({}, {}, { hint: { name: 1 } })"), null);
+});
+
+test("parseMongoVersionCommand parses db.version", () => {
+  assert.deepEqual(parseMongoVersionCommand("db.version();"), { kind: "version" });
+  assert.equal(parseMongoVersionCommand("db.jobs.version()"), null);
+});
+
+test("parseMongoCommand normalizes outer comments around a command", () => {
+  const parsed = parseMongoCommand(`
+    // current database
+    use accounting;
+    // keep working here
+  `);
+  assert.deepEqual(parsed, {
+    text: "use accounting;",
+    command: {
+      kind: "use",
+      database: "accounting",
+    },
+  });
+});
+
+test("parseMongoWriteCommand accepts unquoted insert and update commands", () => {
+  assert.deepEqual(parseMongoWriteCommand("db.products.insertOne({name: 'demo', price: 1})"), {
+    kind: "insert",
+    collection: "products",
+    docsJson: '{"name": "demo", "price": 1}',
+  });
+  assert.deepEqual(parseMongoWriteCommand("db.products.updateOne({_id: ObjectId('507f1f77bcf86cd799439011')}, {$set: {stock: 3}})"), {
+    kind: "update",
+    collection: "products",
+    filter: '{"_id": {"$oid":"507f1f77bcf86cd799439011"}}',
+    update: '{"$set": {"stock": 3}}',
+    many: false,
+  });
+});
+
+test("parseMongoWriteCommand accepts updateMany arrayFilters options", () => {
+  assert.deepEqual(
+    parseMongoWriteCommand(`db.issue_3231.updateMany(
+      { msgType: 3, "order.orderId": { $in: [12345] } },
+      { $set: { "order.$[orderElem].bcorderproducts.$[prodElem].pankouType": "双双2" } },
+      { arrayFilters: [
+        { "orderElem.orderId": { $in: [12345] } },
+        { "prodElem.id": 322678 }
+      ] }
+    )`),
+    {
+      kind: "update",
+      collection: "issue_3231",
+      filter: '{ "msgType": 3, "order.orderId": { "$in": [12345] } }',
+      update: '{ "$set": { "order.$[orderElem].bcorderproducts.$[prodElem].pankouType": "双双2" } }',
+      options: '{ "arrayFilters": [\n        { "orderElem.orderId": { "$in": [12345] } },\n        { "prodElem.id": 322678 }\n      ] }',
+      many: true,
+    },
+  );
+});
+
+test("parseMongoWriteCommand parses createIndex with optional options", () => {
+  assert.deepEqual(parseMongoWriteCommand("db.users.createIndex({email: 1}, {unique: true, name: 'users_email_unique'})"), {
+    kind: "createIndex",
+    collection: "users",
+    keys: '{"email": 1}',
+    options: '{"unique": true, "name": "users_email_unique"}',
+  });
+});
+
+test("parseMongoWriteCommand parses dropIndex and dropIndexes variants", () => {
+  assert.deepEqual(parseMongoWriteCommand('db.users.dropIndex("users_email_unique")'), {
+    kind: "dropIndex",
+    collection: "users",
+    index: '"users_email_unique"',
+  });
+  assert.deepEqual(parseMongoWriteCommand("db.users.dropIndex({email: 1})"), {
+    kind: "dropIndex",
+    collection: "users",
+    index: '{"email": 1}',
+  });
+  assert.deepEqual(parseMongoWriteCommand("db.users.dropIndexes()"), {
+    kind: "dropIndexes",
+    collection: "users",
+  });
+  assert.deepEqual(parseMongoWriteCommand("db.users.dropIndexes({email: 1})"), {
+    kind: "dropIndexes",
+    collection: "users",
+    indexes: '{"email": 1}',
+  });
+  assert.deepEqual(parseMongoWriteCommand('db.users.dropIndexes("*")'), {
+    kind: "dropIndexes",
+    collection: "users",
+    indexes: '"*"',
+  });
+  assert.deepEqual(parseMongoWriteCommand('db.users.dropIndexes(["a_1", "b_1"])'), {
+    kind: "dropIndexes",
+    collection: "users",
+    indexes: '["a_1", "b_1"]',
+  });
+});
+
+test("parseMongoWriteCommand parses collection drop commands", () => {
+  assert.deepEqual(parseMongoWriteCommand("db.users.drop()"), {
+    kind: "dropCollection",
+    collection: "users",
+  });
+  assert.deepEqual(parseMongoWriteCommand('db.getCollection("audit.logs").drop();'), {
+    kind: "dropCollection",
+    collection: "audit.logs",
+  });
+  assert.deepEqual(parseMongoCommand("db.users.drop()")?.command, {
+    kind: "dropCollection",
+    collection: "users",
+  });
+});
+
+test("parseMongoWriteCommand rejects collection drop arguments", () => {
+  assert.equal(parseMongoWriteCommand("db.users.drop({ writeConcern: 1 })"), null);
+});
+
+test("parseMongoWriteCommand rejects invalid dropIndex/dropIndexes variants", () => {
+  assert.equal(parseMongoWriteCommand("db.users.dropIndex()"), null);
+  assert.equal(parseMongoWriteCommand('db.users.dropIndex("*")'), null);
+  assert.equal(parseMongoWriteCommand('db.users.dropIndex(["a_1"])'), null);
+  assert.equal(parseMongoWriteCommand('db.users.dropIndexes([{"a":1}])'), null);
+});
+
+test("evaluateMongoWriteSafety blocks collection drop unless dangerous writes are enabled", () => {
+  const dropCollection = parseMongoWriteCommand("db.users.drop()");
+  assert.ok(dropCollection);
+  assert.match(evaluateMongoWriteSafety(dropCollection, { allowWrites: true }).reason || "", /DBX_MCP_ALLOW_DANGEROUS_SQL=1/);
+  assert.equal(evaluateMongoWriteSafety(dropCollection, { allowWrites: true, allowDangerous: true }).allowed, true);
+});
+
+test("evaluateMongoWriteSafety blocks dangerous dropIndexes shapes unless enabled", () => {
+  const dropAll = parseMongoWriteCommand("db.users.dropIndexes()");
+  assert.ok(dropAll);
+  assert.match(evaluateMongoWriteSafety(dropAll, { allowWrites: true }).reason || "", /DBX_MCP_ALLOW_DANGEROUS_SQL=1/);
+
+  const dropOne = parseMongoWriteCommand('db.users.dropIndexes("users_email_unique")');
+  assert.ok(dropOne);
+  assert.equal(evaluateMongoWriteSafety(dropOne, { allowWrites: true }).allowed, true);
+});
+
+test("parseMongoCountDocumentsCommand parses db collection countDocuments", () => {
+  assert.deepEqual(parseMongoCountDocumentsCommand("db.products.countDocuments({})"), {
+    collection: "products",
+    filter: "{}",
+  });
+});
+
+test("parseMongoCountDocumentsCommand parses legacy count helpers", () => {
+  assert.deepEqual(parseMongoCountDocumentsCommand("db.products.count({ active: true })"), {
+    collection: "products",
+    filter: '{ "active": true }',
+  });
+  assert.deepEqual(parseMongoCountDocumentsCommand('db.getCollection("audit.logs").count()'), {
+    collection: "audit.logs",
+    filter: "{}",
+  });
+  assert.deepEqual(parseMongoCountDocumentsCommand("db.products.find({ active: true }).count()"), {
+    collection: "products",
+    filter: '{ "active": true }',
+  });
+  assert.equal(parseMongoFindCommand("db.products.find({ active: true }).count()"), null);
+  assert.deepEqual(parseMongoCommand("db.products.find({ active: true }).count()")?.command, {
+    kind: "countDocuments",
+    collection: "products",
+    filter: '{ "active": true }',
+  });
+});
+
+test("parseMongoAggregateCommand parses db collection aggregate", () => {
+  assert.deepEqual(parseMongoAggregateCommand('db.products.aggregate([{"$match":{"active":true}},{"$count":"total"}])'), {
+    collection: "products",
+    pipeline: '[{"$match":{"active":true}},{"$count":"total"}]',
+  });
+});
+
+test("parseMongoAggregateCommand accepts an empty pipeline", () => {
+  assert.deepEqual(parseMongoAggregateCommand("db.products.aggregate([])"), {
+    collection: "products",
+    pipeline: "[]",
+  });
+});
+
+test("parseMongoAggregateCommand rejects non-array pipelines and extra arguments", () => {
+  assert.equal(parseMongoAggregateCommand('db.products.aggregate({"$match":{}})'), null);
+  assert.equal(parseMongoAggregateCommand("db.products.aggregate([], {})"), null);
+  assert.equal(parseMongoAggregateCommand("db.products.aggregate([]).limit(10)"), null);
+});
+
+test("parseMongoAggregateCommand normalises ObjectId arguments with either quote style", () => {
+  const oid = "507f1f77bcf86cd799439011";
+  for (const quote of ['"', "'"]) {
+    const command = parseMongoAggregateCommand(`db.orders.aggregate([{"$match":{"_id":ObjectId(${quote}${oid}${quote})}}])`);
+    assert.ok(command, `quote=${quote} should parse`);
+    assert.equal(command.collection, "orders");
+    assert.deepEqual(JSON.parse(command.pipeline), [{ $match: { _id: { $oid: oid } } }]);
+  }
+});
+
+test("parseMongoGetIndexesCommand parses collection index commands", () => {
+  assert.deepEqual(parseMongoGetIndexesCommand("db.web_log.getIndexes();"), {
+    collection: "web_log",
+  });
+  assert.deepEqual(parseMongoGetIndexesCommand('db.getCollection("audit.logs").getIndexes()'), {
+    collection: "audit.logs",
+  });
+  assert.equal(parseMongoGetIndexesCommand("db.web_log.getIndexes({})"), null);
+});
+
+test("parseMongoCollectionStatsCommand parses collection stats commands", () => {
+  assert.deepEqual(parseMongoCollectionStatsCommand("db.users.stats()"), {
+    collection: "users",
+    metric: "stats",
+  });
+  assert.deepEqual(parseMongoCollectionStatsCommand("db.users.dataSize();"), {
+    collection: "users",
+    metric: "dataSize",
+  });
+  assert.deepEqual(parseMongoCollectionStatsCommand("db.users.storageSize(1024)"), {
+    collection: "users",
+    metric: "storageSize",
+    scale: 1024,
+  });
+  assert.deepEqual(parseMongoCollectionStatsCommand("db.users.totalIndexSize()"), {
+    collection: "users",
+    metric: "totalIndexSize",
+  });
+  assert.deepEqual(parseMongoCollectionStatsCommand('db.getCollection("audit.logs").stats()'), {
+    collection: "audit.logs",
+    metric: "stats",
+  });
+  // A non-numeric argument is rejected rather than silently ignored.
+  assert.equal(parseMongoCollectionStatsCommand('db.users.storageSize("big")'), null);
+});
+
+test("parseMongoCommand tags collection stats commands with the collectionStats kind", () => {
+  const parsed = parseMongoCommand("db.users.stats()");
+  assert.ok(parsed);
+  assert.deepEqual(parsed.command, { kind: "collectionStats", collection: "users", metric: "stats" });
+});
+
+test("mongoCollectionStatsToQueryResult formats stats and single-metric results", () => {
+  const stats = {
+    count: 12,
+    size: 4096,
+    avgObjSize: 341,
+    storageSize: 8192,
+    totalIndexSize: 2048,
+    nindexes: 3,
+  };
+  assert.deepEqual(mongoCollectionStatsToQueryResult("stats", stats, 5), {
+    columns: ["count", "size", "avgObjSize", "storageSize", "totalIndexSize", "nindexes"],
+    rows: [[12, 4096, 341, 8192, 2048, 3]],
+    affected_rows: 1,
+    execution_time_ms: 5,
+  });
+  assert.deepEqual(mongoCollectionStatsToQueryResult("dataSize", stats, 0), {
+    columns: ["dataSize"],
+    rows: [[4096]],
+    affected_rows: 1,
+    execution_time_ms: 0,
+  });
+  assert.deepEqual(mongoCollectionStatsToQueryResult("totalIndexSize", {}, 0), {
+    columns: ["totalIndexSize"],
+    rows: [[null]],
+    affected_rows: 1,
+    execution_time_ms: 0,
+  });
+});
+
+test("splitMongoCommands keeps semicolon-separated mongo commands in order", () => {
+  const commands = splitMongoCommands(`
+    db.users.insertOne({ name: "A" });
+    db.users.insertOne({ name: "B" });
+  `);
+  assert.deepEqual(
+    commands.map(({ text, command }) => ({ kind: command.kind, text })),
+    [
+      { kind: "insert", text: 'db.users.insertOne({ name: "A" })' },
+      { kind: "insert", text: 'db.users.insertOne({ name: "B" })' },
+    ],
+  );
+});
+
+test("splitMongoCommands splits top-level line starts without semicolons", () => {
+  const commands = splitMongoCommands(`
+    use accounting
+    db.getCollection("entries")
+      .find({ status: "open" })
+      .limit(5)
+  `);
+  assert.deepEqual(
+    commands.map(({ text, command }) => ({ kind: command.kind, text })),
+    [
+      { kind: "use", text: "use accounting" },
+      { kind: "find", text: 'db.getCollection("entries")\n      .find({ status: "open" })\n      .limit(5)' },
+    ],
+  );
+});
+
+test("splitMongoCommandRanges preserve document offsets for newline-separated commands", () => {
+  const source = `
+    use accounting
+    db.getCollection("entries")
+      .find({ status: "open" })
+      .limit(5)
+  `;
+  const commands = splitMongoCommandRanges(source);
+
+  assert.deepEqual(
+    commands.map(({ from, to, text, command }) => ({
+      from,
+      to,
+      text,
+      kind: command.kind,
+    })),
+    [
+      {
+        from: source.indexOf("use accounting"),
+        to: source.indexOf("use accounting") + "use accounting".length,
+        text: "use accounting",
+        kind: "use",
+      },
+      {
+        from: source.indexOf('db.getCollection("entries")'),
+        to: source.indexOf('      .limit(5)') + "      .limit(5)".length,
+        text: 'db.getCollection("entries")\n      .find({ status: "open" })\n      .limit(5)',
+        kind: "find",
+      },
+    ],
+  );
+});
+
+test("evaluateMongoAggregateSafety blocks write stages unless MCP write flags allow them", () => {
+  const out = parseMongoAggregateCommand('db.products.aggregate([{"$out":"products_copy"}])');
+  assert.ok(out);
+  assert.equal(mongoAggregateWriteStage(out.pipeline), "$out");
+  assert.match(evaluateMongoAggregateSafety(out, {}).reason || "", /DBX_MCP_ALLOW_WRITES=1/);
+
+  const merge = parseMongoAggregateCommand('db.products.aggregate([{"$merge":{"into":"products_copy"}}])');
+  assert.ok(merge);
+  assert.equal(mongoAggregateWriteStage(merge.pipeline), "$merge");
+  assert.match(evaluateMongoAggregateSafety(merge, { allowWrites: true }).reason || "", /DBX_MCP_ALLOW_DANGEROUS_SQL=1/);
+  assert.equal(evaluateMongoAggregateSafety(merge, { allowWrites: true, allowDangerous: true }).allowed, true);
+});
+
+test("mongoIndexesToQueryResult formats index metadata", () => {
+  assert.deepEqual(
+    mongoIndexesToQueryResult(
+      [
+        {
+          name: "_id_",
+          columns: ["_id"],
+          is_unique: false,
+          is_primary: true,
+          index_type: "_id: 1",
+          filter: null,
+        },
+      ],
+      7,
+    ),
+    {
+      columns: ["name", "columns", "unique", "primary", "type", "filter"],
+      rows: [["_id_", "_id", false, true, "_id: 1", null]],
+      affected_rows: 1,
+      execution_time_ms: 7,
+    },
+  );
+});
+
+test("mongoCountToQueryResult returns a single count row", () => {
+  assert.deepEqual(mongoCountToQueryResult(42, 5), {
+    columns: ["count"],
+    rows: [[42]],
+    affected_rows: 42,
+    execution_time_ms: 5,
+  });
+});
+
+test("mongoDocumentsToQueryResult turns mongo documents into grid rows", () => {
+  const result = mongoDocumentsToQueryResult(
+    [
+      { _id: "1", name: "Ada", profile: { role: "admin" } },
+      { _id: "2", active: true, name: "Lin" },
+    ],
+    5,
+    12,
+  );
+
+  assert.deepEqual(result.columns, ["_id", "name", "profile", "active"]);
+  assert.deepEqual(result.rows, [
+    ["1", "Ada", '{"role":"admin"}', null],
+    ["2", "Lin", null, true],
+  ]);
+  assert.deepEqual(result.mongo_documents, [
+    { _id: "1", name: "Ada", profile: { role: "admin" } },
+    { _id: "2", active: true, name: "Lin" },
+  ]);
+  assert.equal(result.affected_rows, 12);
+  assert.equal(result.execution_time_ms, 5);
+  assert.equal(result.truncated, true);
+});
+
+test("buildMongoUpdateDocument ignores _id and preserves typed values", () => {
+  const changes = new Map<number, string | number | boolean | null>([
+    [0, "other-id"],
+    [1, "42"],
+    [2, '{"role":"admin"}'],
+    [3, null],
+  ]);
+
+  const update = buildMongoDocumentUpdate(changes, ["_id", "age", "profile", "nickname"]);
+
+  assert.deepEqual(update, {
+    $set: {
+      age: 42,
+      profile: { role: "admin" },
+    },
+    $unset: {
+      nickname: "",
+    },
+  });
+  assert.equal(formatMongoDocumentShellLiteral(update), '{"$set":{"age":42,"profile":{"role":"admin"}},"$unset":{"nickname":""}}');
+});
diff --git a/packages/app-tests/mqAuth.test.ts b/packages/app-tests/mqAuth.test.ts
new file mode 100644
index 0000000..df4d0b6
--- /dev/null
+++ b/packages/app-tests/mqAuth.test.ts
@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+
+import { detectMqUiAuthKind, isMqAuthKindAllowedForSystem } from "../../apps/desktop/src/lib/connection/mqAuth.ts";
+
+test("keeps hydrated Kafka Kerberos auth allowed during edit", () => {
+  const authKind = detectMqUiAuthKind({
+    systemKind: "kafka",
+    authKind: "none",
+    saslMechanism: "GSSAPI",
+    jaasConfig: 'com.sun.security.auth.module.Krb5LoginModule required useKeyTab=true keyTab="/etc/user.keytab" principal="user@EXAMPLE.COM";',
+  });
+
+  assert.equal(authKind, "kerberos");
+  assert.equal(isMqAuthKindAllowedForSystem("kafka", authKind), true);
+});
+
+test("normalizes unsupported Kafka auth kinds to none", () => {
+  assert.equal(
+    detectMqUiAuthKind({
+      systemKind: "kafka",
+      authKind: "token",
+      saslMechanism: "PLAIN",
+      jaasConfig: "",
+    }),
+    "none",
+  );
+});
+
+test("does not allow Kerberos auth outside Kafka", () => {
+  assert.equal(isMqAuthKindAllowedForSystem("pulsar", "kerberos"), false);
+});
diff --git a/packages/app-tests/nacosConfigListLayout.test.ts b/packages/app-tests/nacosConfigListLayout.test.ts
new file mode 100644
index 0000000..dbd4101
--- /dev/null
+++ b/packages/app-tests/nacosConfigListLayout.test.ts
@@ -0,0 +1,112 @@
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, test } from "vitest";
+import {
+  NACOS_CONFIG_LIST_COLUMN_WIDTHS_STORAGE_KEY,
+  DEFAULT_NACOS_CONFIG_LIST_COLUMN_WIDTHS,
+  useNacosConfigListColumnResize,
+} from "../../apps/desktop/src/composables/useNacosConfigListColumnResize.ts";
+
+function installLocalStorage() {
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  const store = new Map<string, string>();
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => store.get(key) ?? null,
+      setItem: (key: string, value: string) => {
+        store.set(key, value);
+      },
+      removeItem: (key: string) => {
+        store.delete(key);
+      },
+      clear: () => {
+        store.clear();
+      },
+    },
+  });
+  return () => {
+    if (original) Object.defineProperty(globalThis, "localStorage", original);
+    else Reflect.deleteProperty(globalThis, "localStorage");
+  };
+}
+
+function installDocument() {
+  const original = Object.getOwnPropertyDescriptor(globalThis, "document");
+  const listeners = new Map<string, Set<(event: MouseEvent) => void>>();
+  Object.defineProperty(globalThis, "document", {
+    configurable: true,
+    value: {
+      addEventListener: (type: string, listener: (event: MouseEvent) => void) => {
+        const set = listeners.get(type) ?? new Set();
+        set.add(listener);
+        listeners.set(type, set);
+      },
+      removeEventListener: (type: string, listener: (event: MouseEvent) => void) => {
+        listeners.get(type)?.delete(listener);
+      },
+    },
+  });
+  return {
+    dispatchMouseEvent(type: string, clientX: number) {
+      const event = { type, clientX } as MouseEvent;
+      listeners.get(type)?.forEach((listener) => listener(event));
+    },
+    restore() {
+      if (original) Object.defineProperty(globalThis, "document", original);
+      else Reflect.deleteProperty(globalThis, "document");
+    },
+  };
+}
+
+let restoreLocalStorage: (() => void) | undefined;
+let documentHarness: ReturnType<typeof installDocument> | undefined;
+
+beforeEach(() => {
+  restoreLocalStorage = installLocalStorage();
+  documentHarness = installDocument();
+});
+
+afterEach(() => {
+  documentHarness?.restore();
+  documentHarness = undefined;
+  restoreLocalStorage?.();
+  restoreLocalStorage = undefined;
+});
+
+test("Nacos config list keeps overflow tied to the computed width and updates it after drag resizing", () => {
+  const layout = useNacosConfigListColumnResize();
+
+  assert.deepEqual(layout.columnWidths.value, [...DEFAULT_NACOS_CONFIG_LIST_COLUMN_WIDTHS]);
+  assert.equal(layout.gridTemplateColumns.value, "280px 180px 180px 96px");
+  assert.equal(layout.totalWidth.value, 736);
+  assert.equal(layout.minWidth.value, "736px");
+  assert.equal(layout.totalWidth.value > 700, true);
+  assert.equal(layout.totalWidth.value > 820, false);
+
+  let prevented = false;
+  layout.onResizeStart(0, {
+    clientX: 280,
+    preventDefault() {
+      prevented = true;
+    },
+  } as MouseEvent);
+
+  assert.equal(prevented, true);
+  assert.equal(layout.resizingColumnIndex.value, 0);
+
+  documentHarness!.dispatchMouseEvent("mousemove", 400);
+
+  assert.deepEqual(layout.columnWidths.value, [400, 180, 180, 96]);
+  assert.equal(layout.gridTemplateColumns.value, "400px 180px 180px 96px");
+  assert.equal(layout.totalWidth.value, 856);
+  assert.equal(layout.minWidth.value, "856px");
+  assert.equal(layout.totalWidth.value > 820, true);
+
+  documentHarness!.dispatchMouseEvent("mouseup", 400);
+
+  assert.equal(layout.resizingColumnIndex.value, null);
+  assert.equal(localStorage.getItem(NACOS_CONFIG_LIST_COLUMN_WIDTHS_STORAGE_KEY), JSON.stringify([400, 180, 180, 96]));
+
+  const restoredLayout = useNacosConfigListColumnResize();
+  assert.deepEqual(restoredLayout.columnWidths.value, [400, 180, 180, 96]);
+});
diff --git a/packages/app-tests/newQueryContext.test.ts b/packages/app-tests/newQueryContext.test.ts
new file mode 100644
index 0000000..e3d5b74
--- /dev/null
+++ b/packages/app-tests/newQueryContext.test.ts
@@ -0,0 +1,117 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { resolveNewQueryTarget } from "../../apps/desktop/src/lib/sql/newQueryContext.ts";
+import type { ConnectionConfig, QueryTab, TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+function connection(id: string, database = ""): ConnectionConfig {
+  return {
+    id,
+    name: id,
+    db_type: "postgres",
+    host: "localhost",
+    port: 5432,
+    username: "postgres",
+    password: "",
+    database,
+  };
+}
+
+function queryTab(connectionId: string, database: string, mode: QueryTab["mode"] = "data"): QueryTab {
+  return {
+    id: `${connectionId}-${database}`,
+    title: "users",
+    connectionId,
+    database,
+    sql: "",
+    isExecuting: false,
+    isCancelling: false,
+    isExplaining: false,
+    mode,
+  };
+}
+
+test("new query target prefers the active data tab context", () => {
+  const target = resolveNewQueryTarget({
+    activeTab: queryTab("conn-data", "analytics", "data"),
+    selectedTreeNode: {
+      id: "conn-tree:reporting",
+      label: "reporting",
+      type: "database",
+      connectionId: "conn-tree",
+      database: "reporting",
+    },
+    activeConnectionId: "conn-active",
+    connections: [connection("conn-active"), connection("conn-data"), connection("conn-tree")],
+  });
+
+  assert.deepEqual(target, {
+    connectionId: "conn-data",
+    database: "analytics",
+    schema: undefined,
+    shouldRefreshDefaultDatabase: false,
+  });
+});
+
+test("new query target uses the selected sidebar node when there is no active tab", () => {
+  const selectedTreeNode: TreeNode = {
+    id: "conn-tree:reporting:public:users",
+    label: "users",
+    type: "table",
+    connectionId: "conn-tree",
+    database: "reporting",
+    schema: "public",
+  };
+
+  const target = resolveNewQueryTarget({
+    activeTab: undefined,
+    selectedTreeNode,
+    activeConnectionId: "conn-active",
+    connections: [connection("conn-active"), connection("conn-tree")],
+  });
+
+  assert.deepEqual(target, {
+    connectionId: "conn-tree",
+    database: "reporting",
+    schema: "public",
+    shouldRefreshDefaultDatabase: false,
+  });
+});
+
+test("new query target prefers the selected sidebar node after sidebar focus", () => {
+  const target = resolveNewQueryTarget({
+    activeTab: queryTab("conn-data", "analytics", "data"),
+    selectedTreeNode: {
+      id: "conn-tree:reporting:public:users",
+      label: "users",
+      type: "table",
+      connectionId: "conn-tree",
+      database: "reporting",
+    },
+    activeConnectionId: "conn-active",
+    connections: [connection("conn-active"), connection("conn-data"), connection("conn-tree")],
+    preferredSource: "sidebar",
+  });
+
+  assert.deepEqual(target, {
+    connectionId: "conn-tree",
+    database: "reporting",
+    schema: undefined,
+    shouldRefreshDefaultDatabase: false,
+  });
+});
+
+test("new query target refreshes default database for connection-only sidebar nodes", () => {
+  const target = resolveNewQueryTarget({
+    activeTab: undefined,
+    selectedTreeNode: { id: "conn-tree", label: "conn-tree", type: "connection", connectionId: "conn-tree" },
+    activeConnectionId: "conn-active",
+    connections: [connection("conn-active"), connection("conn-tree", "saved_default")],
+  });
+
+  assert.deepEqual(target, {
+    connectionId: "conn-tree",
+    database: "saved_default",
+    schema: undefined,
+    shouldRefreshDefaultDatabase: true,
+  });
+});
diff --git a/packages/app-tests/objectBrowserRows.test.ts b/packages/app-tests/objectBrowserRows.test.ts
new file mode 100644
index 0000000..6b4fe70
--- /dev/null
+++ b/packages/app-tests/objectBrowserRows.test.ts
@@ -0,0 +1,256 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildObjectBrowserRows, filterObjectBrowserRows, formatObjectBrowserBytes, formatObjectBrowserCount, formatObjectBrowserTimestamp, sortObjectBrowserRows } from "../../apps/desktop/src/lib/table/objectBrowserRows.ts";
+
+test("builds unique row ids for overloaded routines with the same visible name", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [
+      { name: "list_pipes", object_type: "FUNCTION", schema: "dbms_pipe", signature: "" },
+      { name: "list_pipes", object_type: "FUNCTION", schema: "dbms_pipe", signature: "name text" },
+      { name: "create_pipe", object_type: "FUNCTION", schema: "dbms_pipe", signature: "" },
+    ],
+    database: "highgo",
+    fallbackSchema: "dbms_pipe",
+    needsSchema: true,
+  });
+
+  assert.deepEqual(
+    rows.map((row) => row.id),
+    ["dbms_pipe:list_pipes:FUNCTION::0", "dbms_pipe:list_pipes:FUNCTION:name text:0", "dbms_pipe:create_pipe:FUNCTION::0"],
+  );
+  assert.deepEqual(
+    rows.map((row) => row.displayName),
+    ["list_pipes()", "list_pipes(name text)", "create_pipe()"],
+  );
+  assert.deepEqual(
+    rows.map((row) => row.name),
+    ["list_pipes", "list_pipes", "create_pipe"],
+  );
+});
+
+test("object browser search matches routine signatures", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [
+      { name: "refresh_stats", object_type: "PROCEDURE", schema: "public", signature: "target_table text" },
+      { name: "refresh_stats", object_type: "PROCEDURE", schema: "public", signature: "" },
+      { name: "orders", object_type: "TABLE", schema: "public" },
+    ],
+    database: "app",
+    fallbackSchema: "public",
+    needsSchema: true,
+  });
+
+  assert.deepEqual(
+    filterObjectBrowserRows(rows, "target_table").map((row) => row.displayName),
+    ["refresh_stats(target_table text)"],
+  );
+});
+
+test("object browser rows normalize Oracle package body objects", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [
+      { name: "PAYROLL", object_type: "PACKAGE", schema: "HR" },
+      { name: "PAYROLL", object_type: "PACKAGE BODY", schema: "HR" },
+    ],
+    database: "orcl",
+    fallbackSchema: "HR",
+    needsSchema: true,
+  });
+
+  assert.deepEqual(
+    rows.map((row) => ({ id: row.id, type: row.type })),
+    [
+      { id: "HR:PAYROLL:PACKAGE:0", type: "PACKAGE" },
+      { id: "HR:PAYROLL:PACKAGE_BODY:0", type: "PACKAGE_BODY" },
+    ],
+  );
+});
+
+test("object browser rows normalize PostgreSQL sequence objects", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [{ name: "order_id_seq", object_type: "SEQUENCE", schema: "public" }],
+    database: "app",
+    fallbackSchema: "public",
+    needsSchema: true,
+  });
+
+  assert.deepEqual(
+    rows.map((row) => ({ id: row.id, type: row.type })),
+    [{ id: "public:order_id_seq:SEQUENCE:0", type: "SEQUENCE" }],
+  );
+});
+
+test("object browser rows normalize space separated materialized views", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [{ name: "user_summary_mv", object_type: "MATERIALIZED VIEW", schema: "APP" }],
+    database: "dameng",
+    fallbackSchema: "APP",
+    needsSchema: true,
+  });
+
+  assert.deepEqual(
+    rows.map((row) => ({ id: row.id, type: row.type })),
+    [{ id: "APP:user_summary_mv:MATERIALIZED_VIEW:0", type: "MATERIALIZED_VIEW" }],
+  );
+});
+
+test("object browser search matches names, types, and comments but not schema names", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [
+      { name: "users", object_type: "TABLE", schema: "exam_hub", comment: "account records" },
+      { name: "orders", object_type: "TABLE", schema: "sales", comment: "exam invoices" },
+      { name: "refresh_exam_stats", object_type: "PROCEDURE", schema: "public" },
+    ],
+    database: "app",
+    fallbackSchema: "public",
+    needsSchema: true,
+  });
+
+  assert.deepEqual(
+    filterObjectBrowserRows(rows, "exam").map((row) => row.name),
+    ["orders", "refresh_exam_stats"],
+  );
+});
+
+test("object browser search supports slash-delimited regular expression queries", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [
+      { name: "sys_user_log", object_type: "TABLE", schema: "public" },
+      { name: "sys_order_archive", object_type: "TABLE", schema: "public" },
+      { name: "app_user_log", object_type: "TABLE", schema: "public" },
+    ],
+    database: "app",
+    fallbackSchema: "public",
+    needsSchema: true,
+  });
+
+  assert.deepEqual(
+    filterObjectBrowserRows(rows, "/^sys_.*_log$/").map((row) => row.name),
+    ["sys_user_log"],
+  );
+});
+
+test("object browser rows preserve table timestamps and sort recent updates first", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [
+      {
+        name: "users",
+        object_type: "TABLE",
+        schema: "public",
+        created_at: "2026-05-20 09:30:00",
+        updated_at: "2026-05-21 10:15:00",
+      },
+      {
+        name: "orders",
+        object_type: "TABLE",
+        schema: "public",
+        created_at: "2026-05-22 08:00:00",
+        updated_at: "2026-05-22 08:20:00",
+      },
+      { name: "active_users", object_type: "VIEW", schema: "public" },
+    ],
+    database: "app",
+    fallbackSchema: "public",
+    needsSchema: true,
+  });
+
+  assert.deepEqual(
+    sortObjectBrowserRows(rows, "updated_at", "desc").map((row) => row.name),
+    ["orders", "users", "active_users"],
+  );
+  assert.equal(formatObjectBrowserTimestamp(rows[0].created_at), "2026-05-20 09:30:00");
+});
+
+test("object browser rows sort estimated rows and table size with empty values last", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [
+      { name: "empty_stats", object_type: "TABLE", schema: "public" },
+      { name: "small_table", object_type: "TABLE", schema: "public" },
+      { name: "large_table", object_type: "TABLE", schema: "public" },
+    ],
+    database: "app",
+    fallbackSchema: "public",
+    needsSchema: true,
+  });
+  rows.find((row) => row.name === "small_table")!.estimatedRows = 12;
+  rows.find((row) => row.name === "large_table")!.estimatedRows = 1200;
+  rows.find((row) => row.name === "small_table")!.totalBytes = 4096;
+  rows.find((row) => row.name === "large_table")!.totalBytes = 8192;
+
+  assert.deepEqual(
+    sortObjectBrowserRows(rows, "estimatedRows", "desc").map((row) => row.name),
+    ["large_table", "small_table", "empty_stats"],
+  );
+  assert.deepEqual(
+    sortObjectBrowserRows(rows, "totalBytes", "asc").map((row) => row.name),
+    ["small_table", "large_table", "empty_stats"],
+  );
+});
+
+test("object browser formats statistics for compact table cells", () => {
+  assert.equal(formatObjectBrowserCount(1234567), "1,234,567");
+  assert.equal(formatObjectBrowserBytes(1536), "1.50 KB");
+  assert.equal(formatObjectBrowserBytes(null), "");
+});
+
+test("object browser name sort keeps base-prefixed tables before prefixed variants", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [
+      { name: "chat_staff", object_type: "TABLE", schema: "public" },
+      { name: "chat_staff_his", object_type: "TABLE", schema: "public" },
+      { name: "staff", object_type: "TABLE", schema: "public" },
+      { name: "staff_his", object_type: "TABLE", schema: "public" },
+    ],
+    database: "app",
+    fallbackSchema: "public",
+    needsSchema: true,
+  });
+
+  assert.deepEqual(
+    sortObjectBrowserRows(rows, "name", "asc").map((row) => row.name),
+    ["staff", "staff_his", "chat_staff", "chat_staff_his"],
+  );
+});
+
+test("object browser rows mark partition-like tables when their parent table exists", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [
+      { name: "order_data", object_type: "TABLE", schema: "public" },
+      { name: "order_data_p20220802", object_type: "TABLE", schema: "public" },
+      { name: "order_data_p20220803", object_type: "TABLE", schema: "public" },
+      { name: "audit_p20220802", object_type: "TABLE", schema: "public" },
+    ],
+    database: "app",
+    fallbackSchema: "public",
+    needsSchema: true,
+  });
+
+  const parent = rows.find((row) => row.name === "order_data");
+  assert.equal(parent?.partitionCount, 2);
+  assert.deepEqual(
+    rows.filter((row) => row.partitionParentId === parent?.id).map((row) => row.name),
+    ["order_data_p20220802", "order_data_p20220803"],
+  );
+  assert.equal(rows.find((row) => row.name === "audit_p20220802")?.partitionParentId, undefined);
+});
+
+test("object browser rows use explicit partition metadata before name heuristics", () => {
+  const rows = buildObjectBrowserRows({
+    objects: [
+      { name: "events", object_type: "TABLE", schema: "public" },
+      { name: "events_may", object_type: "TABLE", schema: "public", parent_schema: "public", parent_name: "events" },
+    ],
+    database: "app",
+    fallbackSchema: "public",
+    needsSchema: true,
+  });
+
+  const parent = rows.find((row) => row.name === "events");
+  assert.equal(parent?.partitionCount, 1);
+  assert.equal(rows.find((row) => row.name === "events_may")?.partitionParentId, parent?.id);
+});
+
+test("object browser timestamp display strips timezone suffixes", () => {
+  assert.equal(formatObjectBrowserTimestamp("2026-05-22 10:18:24+08"), "2026-05-22 10:18:24");
+  assert.equal(formatObjectBrowserTimestamp("2026-05-22 10:18:24.123456+08:00"), "2026-05-22 10:18:24");
+});
diff --git a/packages/app-tests/oceanbaseConnectionMode.test.ts b/packages/app-tests/oceanbaseConnectionMode.test.ts
new file mode 100644
index 0000000..446f98a
--- /dev/null
+++ b/packages/app-tests/oceanbaseConnectionMode.test.ts
@@ -0,0 +1,22 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { oceanbaseModeConnectionPatch, oceanbaseSubModeFromConfig } from "../../apps/desktop/src/lib/database/oceanbaseConnectionMode.ts";
+
+test("detects OceanBase Oracle mode from either database type or driver profile", () => {
+  assert.equal(oceanbaseSubModeFromConfig({ db_type: "mysql", driver_profile: "oceanbase-oracle" }), "oracle");
+  assert.equal(oceanbaseSubModeFromConfig({ db_type: "oceanbase-oracle", driver_profile: "oceanbase" }), "oracle");
+  assert.equal(oceanbaseSubModeFromConfig({ db_type: "mysql", driver_profile: "oceanbase" }), "mysql");
+});
+
+test("builds submit config identity from the selected OceanBase mode", () => {
+  assert.deepEqual(oceanbaseModeConnectionPatch("oracle"), {
+    db_type: "oceanbase-oracle",
+    driver_profile: "oceanbase-oracle",
+    driver_label: "OceanBase Oracle Mode",
+  });
+  assert.deepEqual(oceanbaseModeConnectionPatch("mysql"), {
+    db_type: "mysql",
+    driver_profile: "oceanbase",
+    driver_label: "OceanBase",
+  });
+});
diff --git a/packages/app-tests/openTabsPersistence.test.ts b/packages/app-tests/openTabsPersistence.test.ts
new file mode 100644
index 0000000..aea8ce7
--- /dev/null
+++ b/packages/app-tests/openTabsPersistence.test.ts
@@ -0,0 +1,406 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { restoreOpenTabsState, serializeOpenTabs } from "../../apps/desktop/src/lib/app/openTabsPersistence.ts";
+import type { QueryTab } from "../../apps/desktop/src/types/database.ts";
+
+function queryTab(overrides: Partial<QueryTab> = {}): QueryTab {
+  return {
+    id: "tab-1",
+    title: "Query 1",
+    connectionId: "conn-1",
+    database: "app",
+    schema: "public",
+    sql: "select * from users",
+    pinned: true,
+    isExecuting: false,
+    isCancelling: false,
+    isExplaining: false,
+    mode: "query",
+    ...overrides,
+  };
+}
+
+test("serializes unsaved query tabs with editor context", () => {
+  const saved = serializeOpenTabs([queryTab()]);
+
+  assert.deepEqual(saved, [
+    {
+      id: "tab-1",
+      title: "Query 1",
+      connectionId: "conn-1",
+      database: "app",
+      schema: "public",
+      sql: "select * from users",
+      savedSqlId: undefined,
+      externalSqlPath: undefined,
+      pinned: true,
+      mode: "query",
+      objectBrowser: undefined,
+      objectSource: undefined,
+      tableMeta: undefined,
+    },
+  ]);
+});
+
+test("serializes object source query tabs with save context", () => {
+  const saved = serializeOpenTabs([
+    queryTab({
+      title: "fn_add",
+      customTitle: true,
+      objectSource: {
+        schema: "public",
+        name: "fn_add",
+        objectType: "FUNCTION",
+      },
+    }),
+  ]);
+
+  assert.deepEqual(saved[0]?.objectSource, {
+    schema: "public",
+    name: "fn_add",
+    objectType: "FUNCTION",
+  });
+  assert.equal(saved[0]?.customTitle, true);
+});
+
+test("serializes table tabs with reload context", () => {
+  const saved = serializeOpenTabs([
+    queryTab({
+      mode: "data",
+      lastExecutedSql: "select * from users limit 100 offset 100",
+      resultPageLimit: 100,
+      resultPageOffset: 100,
+      whereInput: "active = true",
+      orderByInput: "created_at DESC",
+      tableMeta: { schema: "public", tableName: "users", columns: [], primaryKeys: [] },
+    }),
+  ]);
+
+  assert.deepEqual(
+    {
+      mode: saved[0]?.mode,
+      lastExecutedSql: saved[0]?.lastExecutedSql,
+      resultPageLimit: saved[0]?.resultPageLimit,
+      resultPageOffset: saved[0]?.resultPageOffset,
+      whereInput: saved[0]?.whereInput,
+      orderByInput: saved[0]?.orderByInput,
+      tableMeta: saved[0]?.tableMeta,
+    },
+    {
+      mode: "data",
+      lastExecutedSql: "select * from users limit 100 offset 100",
+      resultPageLimit: 100,
+      resultPageOffset: 100,
+      whereInput: "active = true",
+      orderByInput: "created_at DESC",
+      tableMeta: { schema: "public", tableName: "users", columns: [], primaryKeys: [] },
+    },
+  );
+});
+
+test("serializes MQ tabs with selected tenant context", () => {
+  const saved = serializeOpenTabs([
+    queryTab({
+      mode: "mq",
+      database: "",
+      mqTenant: "public",
+    }),
+  ]);
+
+  assert.equal(saved[0]?.mqTenant, "public");
+});
+
+test("serializes Nacos admin tabs", () => {
+  const saved = serializeOpenTabs([
+    queryTab({
+      mode: "nacos",
+      database: "",
+      nacosNamespace: "dev",
+      nacosNamespaceName: "Development",
+    }),
+  ]);
+
+  assert.equal(saved[0]?.mode, "nacos");
+  assert.equal(saved[0]?.nacosNamespace, "dev");
+  assert.equal(saved[0]?.nacosNamespaceName, "Development");
+});
+
+test("serializes evicted result cache handles", () => {
+  const saved = serializeOpenTabs([
+    queryTab({
+      resultEvicted: true,
+      resultCacheKey: "tab:tab-1:result",
+    }),
+  ]);
+
+  assert.equal(saved[0]?.resultEvicted, true);
+  assert.equal(saved[0]?.resultCacheKey, "tab:tab-1:result");
+});
+
+test("does not persist table data result cache handles across restarts", () => {
+  const saved = serializeOpenTabs([
+    queryTab({
+      mode: "data",
+      resultEvicted: true,
+      resultCacheKey: "tab:tab-1:result",
+    }),
+  ]);
+
+  assert.equal(saved[0]?.resultEvicted, undefined);
+  assert.equal(saved[0]?.resultCacheKey, undefined);
+});
+
+test("restores evicted result cache handles as disk-backed runtime state", () => {
+  const raw = JSON.stringify([queryTab({ resultEvicted: true, resultCacheKey: "tab:tab-1:result" })]);
+
+  const restored = restoreOpenTabsState(raw, "tab-1");
+
+  assert.equal(restored.tabs[0]?.resultEvicted, true);
+  assert.equal(restored.tabs[0]?.resultCacheKey, "tab:tab-1:result");
+  assert.equal(restored.tabs[0]?.resultCacheState, "disk");
+});
+
+test("serializes query result run metadata without row payloads", () => {
+  const saved = serializeOpenTabs([
+    queryTab({
+      activeResultRunId: "run-2",
+      resultRuns: [
+        {
+          id: "run-1",
+          title: "Run 1",
+          sequence: 1,
+          sql: "select 1",
+          createdAt: 100,
+          result: {
+            columns: ["id"],
+            rows: [[1]],
+            affected_rows: 0,
+            execution_time_ms: 1,
+          },
+          resultCacheKey: "tab:tab-1:run:run-1",
+          resultCacheState: "disk",
+          resultEvicted: true,
+        },
+      ],
+    }),
+  ]);
+
+  assert.deepEqual(saved[0]?.resultRuns, [
+    {
+      id: "run-1",
+      title: "Run 1",
+      sequence: 1,
+      sql: "select 1",
+      createdAt: 100,
+      activeResultIndex: undefined,
+      resultCacheKey: "tab:tab-1:run:run-1",
+      resultEvicted: true,
+    },
+  ]);
+  assert.equal(JSON.stringify(saved).includes("[[1]]"), false);
+  assert.equal(saved[0]?.activeResultRunId, "run-2");
+});
+
+test("restores query result run metadata as disk-backed runtime state", () => {
+  const raw = JSON.stringify([
+    {
+      ...queryTab(),
+      activeResultRunId: "run-1",
+      resultRuns: [
+        {
+          id: "run-1",
+          title: "Run 1",
+          sequence: 1,
+          sql: "select 1",
+          createdAt: 100,
+          resultCacheKey: "tab:tab-1:run:run-1",
+          resultEvicted: true,
+        },
+      ],
+    },
+  ]);
+
+  const restored = restoreOpenTabsState(raw, "tab-1");
+
+  assert.equal(restored.tabs[0]?.activeResultRunId, "run-1");
+  assert.equal(restored.tabs[0]?.resultRuns?.[0]?.id, "run-1");
+  assert.equal(restored.tabs[0]?.resultRuns?.[0]?.resultCacheState, "disk");
+  assert.equal(restored.tabs[0]?.resultRuns?.[0]?.result, undefined);
+});
+
+test("ignores legacy table data result cache handles on restore", () => {
+  const raw = JSON.stringify([queryTab({ mode: "data", resultEvicted: true, resultCacheKey: "tab:tab-1:result" })]);
+
+  const restored = restoreOpenTabsState(raw, "tab-1");
+
+  assert.equal(restored.tabs[0]?.resultEvicted, undefined);
+  assert.equal(restored.tabs[0]?.resultCacheKey, undefined);
+  assert.equal(restored.tabs[0]?.resultCacheState, undefined);
+});
+
+test("restores unsaved query tabs and active tab after restart", () => {
+  const raw = JSON.stringify([queryTab({ id: "tab-1", sql: "select 1" }), queryTab({ id: "tab-2", title: "Query 2", sql: "select 2" })]);
+
+  const restored = restoreOpenTabsState(raw, "tab-2");
+
+  assert.deepEqual(
+    restored.tabs.map((tab) => ({ id: tab.id, sql: tab.sql, originalSql: tab.originalSql, isExecuting: tab.isExecuting })),
+    [
+      { id: "tab-1", sql: "select 1", originalSql: "", isExecuting: false },
+      { id: "tab-2", sql: "select 2", originalSql: "", isExecuting: false },
+    ],
+  );
+  assert.equal(restored.activeTabId, "tab-2");
+});
+
+test("restores only pinned tabs when requested", () => {
+  const raw = JSON.stringify([queryTab({ id: "tab-1", pinned: true }), queryTab({ id: "tab-2", pinned: false }), queryTab({ id: "tab-3", pinned: true })]);
+
+  const restored = restoreOpenTabsState(raw, "tab-2", { filter: "pinned" });
+
+  assert.deepEqual(
+    restored.tabs.map((tab) => tab.id),
+    ["tab-1", "tab-3"],
+  );
+  assert.equal(restored.activeTabId, "tab-1");
+});
+
+test("restores object source save context", () => {
+  const raw = JSON.stringify([
+    queryTab({
+      customTitle: true,
+      objectSource: {
+        schema: "public",
+        name: "fn_add",
+        objectType: "FUNCTION",
+      },
+    }),
+  ]);
+
+  const restored = restoreOpenTabsState(raw, "tab-1");
+
+  assert.deepEqual(restored.tabs[0]?.objectSource, {
+    schema: "public",
+    name: "fn_add",
+    objectType: "FUNCTION",
+  });
+  assert.equal(restored.tabs[0]?.customTitle, true);
+});
+
+test("restores data and structure tabs with table state", () => {
+  const raw = JSON.stringify([
+    queryTab({
+      id: "data",
+      title: "public.users",
+      mode: "data",
+      sql: 'SELECT * FROM "public"."users" LIMIT 50 OFFSET 50;',
+      lastExecutedSql: 'SELECT * FROM "public"."users" LIMIT 50 OFFSET 50;',
+      resultPageLimit: 50,
+      resultPageOffset: 50,
+      whereInput: "id > 10",
+      orderByInput: "id DESC",
+      tableMeta: {
+        schema: "public",
+        tableName: "users",
+        columns: [
+          {
+            name: "id",
+            data_type: "integer",
+            is_nullable: false,
+            column_default: null,
+            is_primary_key: true,
+            extra: null,
+          },
+        ],
+        primaryKeys: ["id"],
+      },
+    }),
+    queryTab({
+      id: "structure",
+      title: "Edit users",
+      mode: "structure",
+      sql: "",
+      structureTableName: "users",
+    }),
+  ]);
+
+  const restored = restoreOpenTabsState(raw, "data");
+
+  assert.deepEqual(
+    restored.tabs.map((tab) => ({ id: tab.id, mode: tab.mode })),
+    [
+      { id: "data", mode: "data" },
+      { id: "structure", mode: "structure" },
+    ],
+  );
+  assert.equal(restored.activeTabId, "data");
+  assert.equal(restored.tabs[0]?.tableMeta?.tableName, "users");
+  assert.equal(restored.tabs[0]?.resultPageLimit, 50);
+  assert.equal(restored.tabs[0]?.resultPageOffset, 50);
+  assert.equal(restored.tabs[0]?.whereInput, "id > 10");
+  assert.equal(restored.tabs[0]?.orderByInput, "id DESC");
+  assert.equal(restored.tabs[1]?.structureTableName, "users");
+});
+
+test("restores MQ tabs with selected tenant context", () => {
+  const raw = JSON.stringify([
+    queryTab({
+      mode: "mq",
+      database: "",
+      mqTenant: "public",
+    }),
+  ]);
+
+  const restored = restoreOpenTabsState(raw, "tab-1");
+
+  assert.equal(restored.tabs[0]?.mqTenant, "public");
+});
+
+test("restores GridFS manager tabs with their mode intact", () => {
+  const raw = JSON.stringify([
+    queryTab({
+      id: "gridfs",
+      title: "GridFS",
+      mode: "mongo-gridfs" as QueryTab["mode"],
+      sql: "",
+      database: "amazon",
+    }),
+  ]);
+
+  const restored = restoreOpenTabsState(raw, "gridfs");
+
+  assert.equal(restored.tabs[0]?.mode, "mongo-gridfs");
+  assert.equal(restored.tabs[0]?.title, "GridFS");
+  assert.equal(restored.activeTabId, "gridfs");
+});
+
+test("query-only restore keeps legacy query tabs without a mode", () => {
+  const raw = JSON.stringify([
+    {
+      id: "legacy",
+      title: "Query 1",
+      connectionId: "conn-1",
+      database: "app",
+      sql: "select now()",
+    },
+    queryTab({ id: "data", title: "users", mode: "data" }),
+  ]);
+
+  const restored = restoreOpenTabsState(raw, "data", { queryOnly: true });
+
+  assert.deepEqual(
+    restored.tabs.map((tab) => ({ id: tab.id, mode: tab.mode })),
+    [{ id: "legacy", mode: "query" }],
+  );
+  assert.equal(restored.activeTabId, "legacy");
+});
+
+test("ignores invalid persisted tab payloads", () => {
+  const restored = restoreOpenTabsState(JSON.stringify([{ id: "missing-fields" }, queryTab()]), "missing-fields");
+
+  assert.deepEqual(
+    restored.tabs.map((tab) => tab.id),
+    ["tab-1"],
+  );
+  assert.equal(restored.activeTabId, "tab-1");
+});
diff --git a/packages/app-tests/pinnedItems.test.ts b/packages/app-tests/pinnedItems.test.ts
new file mode 100644
index 0000000..8879c21
--- /dev/null
+++ b/packages/app-tests/pinnedItems.test.ts
@@ -0,0 +1,40 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { applyPinnedTreeNodeState, orderPinnedFirst } from "../../apps/desktop/src/lib/app/pinnedItems.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+test("orders pinned items before unpinned items without changing relative order", () => {
+  const items = [{ id: "a" }, { id: "b", pinned: true }, { id: "c" }, { id: "d", pinned: true }, { id: "e" }];
+
+  const ordered = orderPinnedFirst(items, (item) => !!item.pinned);
+
+  assert.deepEqual(
+    ordered.map((item) => item.id),
+    ["b", "d", "a", "c", "e"],
+  );
+  assert.deepEqual(
+    items.map((item) => item.id),
+    ["a", "b", "c", "d", "e"],
+  );
+});
+
+test("applies pinned state recursively to grouped tree nodes", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn:db:__tables",
+      label: "tree.tables",
+      type: "group-tables",
+      children: [
+        { id: "conn:db:orders", label: "orders", type: "table" },
+        { id: "conn:db:users", label: "users", type: "table" },
+      ],
+    },
+  ];
+
+  const result = applyPinnedTreeNodeState(nodes, new Set(["conn:db:users"]));
+
+  assert.equal(result[0].children?.[0].id, "conn:db:users");
+  assert.equal(result[0].children?.[0].pinned, true);
+  assert.equal(result[0].children?.[1].id, "conn:db:orders");
+  assert.equal(result[0].children?.[1].pinned, false);
+});
diff --git a/packages/app-tests/productionGuardEntrypoints.test.ts b/packages/app-tests/productionGuardEntrypoints.test.ts
new file mode 100644
index 0000000..ce61514
--- /dev/null
+++ b/packages/app-tests/productionGuardEntrypoints.test.ts
@@ -0,0 +1,107 @@
+import { readFileSync } from "node:fs";
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+
+function readSource(path: string): string {
+  return readFileSync(path, "utf8");
+}
+
+function functionBody(source: string, name: string): string {
+  const signature = `function ${name}(`;
+  const asyncSignature = `async ${signature}`;
+  const signatureIndex = source.indexOf(asyncSignature) >= 0 ? source.indexOf(asyncSignature) : source.indexOf(signature);
+  assert.notEqual(signatureIndex, -1, `Could not find function ${name}`);
+  const bodyStart = source.indexOf("{", signatureIndex);
+  assert.notEqual(bodyStart, -1, `Could not find body for ${name}`);
+
+  let depth = 0;
+  for (let index = bodyStart; index < source.length; index += 1) {
+    const char = source[index];
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return source.slice(bodyStart + 1, index);
+    }
+  }
+  throw new Error(`Could not parse body for ${name}`);
+}
+
+test("secondary write entrypoints use the shared production SQL guard", () => {
+  const entrypoints = [
+    {
+      path: "apps/desktop/src/components/diff/SchemaDiffDialog.vue",
+      executor: "api.executeScript",
+      sourceKey: "production.sourceSchemaDiff",
+    },
+    {
+      path: "apps/desktop/src/components/diff/DataCompareDialog.vue",
+      executor: "api.executeBatch",
+      sourceKey: "production.sourceDataCompare",
+    },
+    {
+      path: "apps/desktop/src/components/objects/InstallExtensionDialog.vue",
+      executor: "api.executeQuery",
+      sourceKey: "production.sourceExtension",
+    },
+    {
+      path: "apps/desktop/src/components/sidebar/TreeItem.vue",
+      executor: "api.executeQuery",
+      sourceKey: "production.sourceSidebar",
+    },
+    {
+      path: "apps/desktop/src/App.vue",
+      executor: "executeObjectSourceSave",
+      sourceKey: "production.sourceObjectSource",
+    },
+    {
+      path: "apps/desktop/src/components/objects/ObjectSourceDialog.vue",
+      executor: "executeObjectSourceSave",
+      sourceKey: "production.sourceObjectSource",
+    },
+    {
+      path: "apps/desktop/src/components/objects/ObjectBrowser.vue",
+      executor: "executeObjectSourceSave",
+      sourceKey: "production.sourceObjectSource",
+    },
+    {
+      path: "apps/desktop/src/components/objects/ObjectBrowser.vue",
+      executor: "api.executeQuery",
+      sourceKey: "production.sourceObjectBrowser",
+    },
+    {
+      path: "apps/desktop/src/components/generate/DataGenerateDialog.vue",
+      executor: "api.executeQuery",
+      sourceKey: "production.sourceDataGenerate",
+    },
+    {
+      path: "apps/desktop/src/components/editor/QueryHistory.vue",
+      executor: "api.executeScript",
+      sourceKey: "production.sourceQueryHistory",
+    },
+    {
+      path: "apps/desktop/src/components/admin/DatabaseUserAdmin.vue",
+      executor: "api.executeMulti",
+      sourceKey: "production.sourceAdmin",
+    },
+    {
+      path: "apps/desktop/src/components/admin/DamengJobAdmin.vue",
+      executor: "api.executeMulti",
+      sourceKey: "production.sourceAdmin",
+    },
+  ];
+
+  for (const entrypoint of entrypoints) {
+    const source = readSource(entrypoint.path);
+    assert.match(source, /executeWithProductionSqlGuard/, entrypoint.path);
+    assert.ok(source.includes(entrypoint.executor), `${entrypoint.path} should still execute SQL through its original backend API`);
+    assert.ok(source.includes(entrypoint.sourceKey), `${entrypoint.path} should label the confirmation source`);
+  }
+});
+
+test("object browser batch empty reviews the frozen SQL plan before executing", () => {
+  const source = readSource("apps/desktop/src/components/objects/ObjectBrowser.vue");
+  const body = functionBody(source, "confirmBatchEmptyTables");
+  assert.match(body, /executeObjectBrowserSqlWithProductionGuard\(\s*reviewSql/, "batch empty must use the Object Browser production guard");
+  assert.match(body, /runBatchTableEmpty/, "batch empty should still use the batch executor after confirmation");
+  assert.ok(body.indexOf("executeObjectBrowserSqlWithProductionGuard") < body.indexOf("runBatchTableEmpty"), "production guard must be entered before the batch executor");
+});
diff --git a/packages/app-tests/queryCursorTableTarget.test.ts b/packages/app-tests/queryCursorTableTarget.test.ts
new file mode 100644
index 0000000..569d1df
--- /dev/null
+++ b/packages/app-tests/queryCursorTableTarget.test.ts
@@ -0,0 +1,105 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { extractQualifiedIdentifierPartsAt, findLoadedTableTargetForCandidate, qualifiedTableNameAtSqlPosition, queryContextTargetFromCandidate, queryCursorTableCandidate } from "../../apps/desktop/src/lib/sql/queryCursorTableTarget.ts";
+import type { QueryTab, TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+function queryTab(sql: string, head: number, schema = "public"): QueryTab {
+  return {
+    id: "tab-1",
+    title: "Query 1",
+    connectionId: "conn-1",
+    database: "app",
+    schema,
+    sql,
+    editorSelection: { anchor: head, head },
+    isExecuting: false,
+    mode: "query",
+  };
+}
+
+test("extracts the qualified identifier under or after the cursor", () => {
+  const sql = "select * from public.users";
+  assert.deepEqual(
+    extractQualifiedIdentifierPartsAt(sql, sql.length).map((part) => part.value),
+    ["public", "users"],
+  );
+  assert.deepEqual(
+    extractQualifiedIdentifierPartsAt("select * from `sales-db`.`Order`", 29).map((part) => part.value),
+    ["sales-db", "Order"],
+  );
+  assert.deepEqual(
+    extractQualifiedIdentifierPartsAt('select * from "public"."order"', 26).map((part) => part.value),
+    ["public", "order"],
+  );
+});
+
+test("resolves the table name at a context-menu position", () => {
+  const sql = "select * from reporting.users where id = 1";
+
+  assert.equal(qualifiedTableNameAtSqlPosition(sql, sql.indexOf("users") + 2), "reporting.users");
+  assert.equal(qualifiedTableNameAtSqlPosition("select * from users", "select * from users".length), "users");
+  assert.equal(qualifiedTableNameAtSqlPosition(sql, sql.indexOf("where") + 1), null);
+});
+
+test("builds schema-aware cursor table candidates", () => {
+  const tab = queryTab("select * from reporting.users", "select * from reporting.users".length);
+
+  assert.deepEqual(queryCursorTableCandidate(tab, "postgres"), {
+    connectionId: "conn-1",
+    database: "app",
+    schema: "reporting",
+    tableName: "users",
+  });
+});
+
+test("builds database-qualified candidates for multi-database non-schema engines", () => {
+  const tab = queryTab("select * from analytics.events", "select * from analytics.events".length, undefined);
+
+  assert.deepEqual(queryCursorTableCandidate(tab, "mysql"), {
+    connectionId: "conn-1",
+    database: "analytics",
+    schema: undefined,
+    tableName: "events",
+  });
+});
+
+test("falls back to the candidate database and schema when no table is loaded", () => {
+  const tab = queryTab("select * from reporting.missing", "select * from reporting.missing".length);
+  const candidate = queryCursorTableCandidate(tab, "postgres");
+
+  assert.deepEqual(queryContextTargetFromCandidate(tab, candidate), {
+    type: "query-context",
+    connectionId: "conn-1",
+    database: "app",
+    schema: "reporting",
+  });
+});
+
+test("resolves loaded table targets case-insensitively and keeps actual tree labels", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn-1",
+      label: "local",
+      type: "connection",
+      connectionId: "conn-1",
+      children: [
+        {
+          id: "db-app",
+          label: "app",
+          type: "database",
+          connectionId: "conn-1",
+          database: "app",
+          children: [{ id: "users", label: "Users", type: "table", connectionId: "conn-1", database: "app", schema: "public" }],
+        },
+      ],
+    },
+  ];
+
+  assert.deepEqual(findLoadedTableTargetForCandidate(nodes, { connectionId: "conn-1", database: "APP", schema: "PUBLIC", tableName: "users" }), {
+    type: "table",
+    connectionId: "conn-1",
+    database: "app",
+    schema: "public",
+    tableName: "Users",
+  });
+});
diff --git a/packages/app-tests/queryEditorTableDrop.test.ts b/packages/app-tests/queryEditorTableDrop.test.ts
new file mode 100644
index 0000000..b893929
--- /dev/null
+++ b/packages/app-tests/queryEditorTableDrop.test.ts
@@ -0,0 +1,184 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import {
+  DBX_TABLE_REFERENCE_MIME,
+  activeTableReferencePayloadValue,
+  clearActiveTableReferencePayload,
+  createTableReferencePayload,
+  hasTableReferencePayloadType,
+  parseTableReferencePayload,
+  serializeTableReferencePayload,
+  setActiveTableReferencePayload,
+  tableReferenceInsertText,
+} from "../../apps/desktop/src/lib/editor/queryEditorTableDrop.ts";
+
+test("creates table drag payload only when table context is complete", () => {
+  assert.equal(createTableReferencePayload({ connectionId: "c1", database: "db" }), null);
+  assert.deepEqual(
+    createTableReferencePayload({
+      connectionId: "c1",
+      database: "",
+      tableName: "catalogless_table",
+      databaseType: "sqlite",
+    }),
+    {
+      kind: "dbx-table-reference",
+      connectionId: "c1",
+      database: "",
+      tableName: "catalogless_table",
+      databaseType: "sqlite",
+    },
+  );
+  assert.deepEqual(
+    createTableReferencePayload({
+      connectionId: "c1",
+      database: "db",
+      schema: "public",
+      tableName: "very long table",
+      databaseType: "postgres",
+    }),
+    {
+      kind: "dbx-table-reference",
+      connectionId: "c1",
+      database: "db",
+      schema: "public",
+      tableName: "very long table",
+      databaseType: "postgres",
+    },
+  );
+});
+
+test("creates column drag payload when column context is complete", () => {
+  assert.deepEqual(
+    createTableReferencePayload({
+      connectionId: "c1",
+      database: "db",
+      schema: "public",
+      tableName: "users",
+      columnName: "user_id",
+      databaseType: "postgres",
+    }),
+    {
+      kind: "dbx-table-reference",
+      connectionId: "c1",
+      database: "db",
+      schema: "public",
+      tableName: "users",
+      columnName: "user_id",
+      referenceType: "column",
+      databaseType: "postgres",
+    },
+  );
+});
+
+test("round trips table drag payload and rejects unrelated data", () => {
+  const payload = createTableReferencePayload({
+    connectionId: "c1",
+    database: "db",
+    tableName: "orders",
+    databaseType: "mysql",
+  });
+  assert.ok(payload);
+  assert.deepEqual(parseTableReferencePayload(serializeTableReferencePayload(payload)), payload);
+  assert.deepEqual(
+    parseTableReferencePayload(
+      JSON.stringify({
+        kind: "dbx-table-reference",
+        connectionId: "c1",
+        database: "",
+        tableName: "orders",
+      }),
+    ),
+    {
+      kind: "dbx-table-reference",
+      connectionId: "c1",
+      database: "",
+      tableName: "orders",
+    },
+  );
+  assert.equal(parseTableReferencePayload("not json"), null);
+  assert.equal(parseTableReferencePayload(JSON.stringify({ kind: "dbx-table-reference", tableName: "orders" })), null);
+  assert.equal(
+    parseTableReferencePayload(
+      JSON.stringify({
+        kind: "dbx-table-reference",
+        connectionId: "c1",
+        database: "db",
+        tableName: "orders",
+        referenceType: "column",
+      }),
+    ),
+    null,
+  );
+});
+
+test("tracks the active in-app table drag payload without dataTransfer reads", () => {
+  const payload = createTableReferencePayload({
+    connectionId: "c1",
+    database: "",
+    tableName: "orders",
+    databaseType: "sqlite",
+  });
+  assert.ok(payload);
+  setActiveTableReferencePayload(payload);
+  assert.equal(activeTableReferencePayloadValue(), payload);
+  clearActiveTableReferencePayload(payload);
+  assert.equal(activeTableReferencePayloadValue(), null);
+});
+
+test("detects table drag payload type without reading drag data", () => {
+  assert.equal(hasTableReferencePayloadType(undefined), false);
+  assert.equal(hasTableReferencePayloadType(["text/plain"]), false);
+  assert.equal(hasTableReferencePayloadType(["text/plain", DBX_TABLE_REFERENCE_MIME]), true);
+});
+
+test("formats dropped table reference for the source database type", () => {
+  assert.equal(
+    tableReferenceInsertText({
+      kind: "dbx-table-reference",
+      connectionId: "c1",
+      database: "db",
+      schema: "sales",
+      tableName: "customer order",
+      databaseType: "postgres",
+    }),
+    '"sales"."customer order"',
+  );
+  assert.equal(
+    tableReferenceInsertText({
+      kind: "dbx-table-reference",
+      connectionId: "c1",
+      database: "db",
+      schema: "dbo",
+      tableName: "Order Detail",
+      databaseType: "sqlserver",
+    }),
+    "[dbo].[Order Detail]",
+  );
+  assert.equal(
+    tableReferenceInsertText({
+      kind: "dbx-table-reference",
+      connectionId: "c1",
+      database: "db",
+      schema: "ignored",
+      tableName: "order-detail",
+      databaseType: "mysql",
+    }),
+    "`order-detail`",
+  );
+});
+
+test("formats dropped column references for the source database type", () => {
+  assert.equal(
+    tableReferenceInsertText({
+      kind: "dbx-table-reference",
+      connectionId: "c1",
+      database: "db",
+      tableName: "users",
+      columnName: "display name",
+      referenceType: "column",
+      databaseType: "postgres",
+    }),
+    '"display name"',
+  );
+});
diff --git a/packages/app-tests/queryResultArchive.test.ts b/packages/app-tests/queryResultArchive.test.ts
new file mode 100644
index 0000000..dec9c87
--- /dev/null
+++ b/packages/app-tests/queryResultArchive.test.ts
@@ -0,0 +1,202 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildTabResultSnapshot } from "../../apps/desktop/src/lib/tabs/tabResultCache.ts";
+import { decodeQueryResultArchive, defaultQueryResultArchiveFileName, encodeQueryResultArchive } from "../../apps/desktop/src/lib/query/queryResultArchive.ts";
+import type { QueryTab } from "../../apps/desktop/src/types/database.ts";
+
+function queryTab(overrides: Partial<QueryTab> = {}): QueryTab {
+  return {
+    id: "tab-1",
+    title: "Revenue / daily check",
+    connectionId: "conn-1",
+    database: "warehouse",
+    schema: "public",
+    sql: "select * from revenue",
+    lastExecutedSql: "select * from revenue",
+    isExecuting: false,
+    mode: "query",
+    ...overrides,
+  };
+}
+
+test("query result archives round-trip query tab metadata and result runs", async () => {
+  const tab = queryTab({
+    resultRuns: [
+      {
+        id: "run-1",
+        title: "Run 1",
+        sequence: 1,
+        sql: "select 1",
+        createdAt: 10,
+        result: {
+          columns: ["id", "name"],
+          rows: [
+            [1, "Ada"],
+            [2, "Linus"],
+          ],
+          mongo_documents: [
+            { _id: "1", profile: { role: "admin" } },
+            { _id: "2", profile: { role: "maintainer" } },
+          ],
+          affected_rows: 0,
+          execution_time_ms: 3,
+          session_id: "live-session",
+        },
+      },
+      {
+        id: "run-2",
+        title: "Run 2",
+        sequence: 2,
+        sql: "select 2",
+        createdAt: 20,
+        result: {
+          columns: ["id", "status"],
+          rows: [[2, "paid"]],
+          affected_rows: 0,
+          execution_time_ms: 5,
+        },
+      },
+    ],
+    activeResultRunId: "run-2",
+    result: {
+      columns: ["id", "status"],
+      rows: [[2, "paid"]],
+      affected_rows: 0,
+      execution_time_ms: 5,
+    },
+    resultLocalSortOriginalRows: [[1, "pending"]],
+    resultLocalSortOriginalMongoDocuments: [{ _id: "1", status: "pending" }],
+  });
+  const snapshot = buildTabResultSnapshot(tab);
+  assert.ok(snapshot);
+
+  const bytes = await encodeQueryResultArchive(tab, snapshot);
+  const decoded = await decodeQueryResultArchive(bytes);
+
+  assert.ok(bytes instanceof Uint8Array);
+  assert.equal(decoded?.tab.title, "Revenue / daily check");
+  assert.equal(decoded?.tab.connectionId, "conn-1");
+  assert.equal(decoded?.tab.database, "warehouse");
+  assert.equal(decoded?.tab.schema, "public");
+  assert.equal(decoded?.tab.sql, "select * from revenue");
+  assert.equal(decoded?.snapshot.activeResultRunId, "run-2");
+  assert.deepEqual(decoded?.snapshot.resultRuns?.map((run) => run.sequence), [1, 2]);
+  assert.deepEqual(decoded?.snapshot.resultRuns?.[0]?.result?.rows, [
+    [1, "Ada"],
+    [2, "Linus"],
+  ]);
+  assert.deepEqual(decoded?.snapshot.resultRuns?.[0]?.result?.mongo_documents, [
+    { _id: "1", profile: { role: "admin" } },
+    { _id: "2", profile: { role: "maintainer" } },
+  ]);
+  assert.equal(decoded?.snapshot.resultRuns?.[0]?.result?.session_id, undefined);
+  assert.deepEqual(decoded?.snapshot.resultLocalSortOriginalRows, [[1, "pending"]]);
+  assert.deepEqual(decoded?.snapshot.resultLocalSortOriginalMongoDocuments, [{ _id: "1", status: "pending" }]);
+});
+
+test("query result archives reject invalid files", async () => {
+  assert.equal(await decodeQueryResultArchive(new Uint8Array([1, 2, 3, 4])), undefined);
+});
+
+test("query result archive file names are safe and use dbxresults extension", () => {
+  assert.equal(defaultQueryResultArchiveFileName("Revenue / daily check"), "Revenue_daily_check.dbxresults");
+  assert.equal(defaultQueryResultArchiveFileName(""), "query-results.dbxresults");
+});
+
+test("query result archives are compact for repeated tabular values", async () => {
+  const rows = Array.from({ length: 100 }, (_, index) => [index, "same-region", "same-status"]);
+  const tab = queryTab({
+    title: "Repeated values",
+    result: {
+      columns: ["id", "region", "status"],
+      rows,
+      affected_rows: 0,
+      execution_time_ms: 7,
+    },
+  });
+  const snapshot = buildTabResultSnapshot(tab);
+  assert.ok(snapshot);
+
+  const bytes = await encodeQueryResultArchive(tab, snapshot);
+  const jsonSize = new TextEncoder().encode(JSON.stringify({ tab, snapshot })).length;
+
+  assert.ok(bytes.length < jsonSize, `expected archive ${bytes.length} bytes to be smaller than JSON ${jsonSize} bytes`);
+});
+
+test("query result archive compression starts reading before writing to avoid stream backpressure", async () => {
+  const originalCompressionStream = Object.getOwnPropertyDescriptor(globalThis, "CompressionStream");
+  const originalResponse = Object.getOwnPropertyDescriptor(globalThis, "Response");
+  class BackpressureCompressionStream {
+    private chunk?: Uint8Array;
+    private readerStarted = false;
+    private releaseWrite?: () => void;
+
+    readable = {
+      startReading: () => {
+        this.readerStarted = true;
+        this.releaseWrite?.();
+        this.releaseWrite = undefined;
+      },
+      arrayBuffer: () => {
+        const bytes = this.chunk ?? new Uint8Array();
+        return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+      },
+    };
+
+    writable = {
+      getWriter: () => ({
+        write: async (chunk: Uint8Array | ArrayBuffer) => {
+          this.chunk = chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+          if (!this.readerStarted) {
+            await new Promise<void>((resolve) => {
+              this.releaseWrite = resolve;
+            });
+          }
+        },
+        close: async () => {},
+      }),
+    };
+  }
+
+  class BackpressureResponse {
+    constructor(private readonly readable: { startReading?: () => void; arrayBuffer?: () => ArrayBuffer }) {
+      this.readable.startReading?.();
+    }
+
+    async arrayBuffer() {
+      return this.readable.arrayBuffer?.() ?? new ArrayBuffer(0);
+    }
+  }
+
+  Object.defineProperty(globalThis, "CompressionStream", {
+    configurable: true,
+    value: BackpressureCompressionStream,
+  });
+  Object.defineProperty(globalThis, "Response", {
+    configurable: true,
+    value: BackpressureResponse,
+  });
+
+  try {
+    const tab = queryTab({
+      result: {
+        columns: ["id"],
+        rows: [[1]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    });
+    const snapshot = buildTabResultSnapshot(tab);
+    assert.ok(snapshot);
+
+    const result = await Promise.race([encodeQueryResultArchive(tab, snapshot), new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 100))]);
+
+    assert.notEqual(result, "timeout");
+    assert.ok(result instanceof Uint8Array);
+  } finally {
+    if (originalCompressionStream) Object.defineProperty(globalThis, "CompressionStream", originalCompressionStream);
+    else Reflect.deleteProperty(globalThis, "CompressionStream");
+    if (originalResponse) Object.defineProperty(globalThis, "Response", originalResponse);
+    else Reflect.deleteProperty(globalThis, "Response");
+  }
+});
diff --git a/packages/app-tests/queryResultToolbar.test.ts b/packages/app-tests/queryResultToolbar.test.ts
new file mode 100644
index 0000000..2343064
--- /dev/null
+++ b/packages/app-tests/queryResultToolbar.test.ts
@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "vitest";
+import { compileScript, compileTemplate, parse } from "vue/compiler-sfc";
+
+const contentAreaPath = "apps/desktop/src/components/layout/ContentArea.vue";
+const dataGridPath = "apps/desktop/src/components/grid/DataGrid.vue";
+const viewSwitcherPath = "apps/desktop/src/components/layout/QueryResultViewSwitcher.vue";
+const toolbarActionsPath = "apps/desktop/src/components/layout/QueryResultToolbarActions.vue";
+
+function source(path: string): string {
+  return readFileSync(path, "utf8");
+}
+
+function assertSfcCompiles(path: string): void {
+  const { descriptor, errors } = parse(source(path), { filename: path });
+  assert.deepEqual(errors, [], `${path} should parse without SFC errors`);
+  assert.ok(descriptor.scriptSetup, `${path} should have a script setup block`);
+  compileScript(descriptor, { id: path });
+  if (descriptor.template) {
+    const result = compileTemplate({ id: path, filename: path, source: descriptor.template.content });
+    assert.deepEqual(result.errors, [], `${path} template should compile`);
+  }
+}
+
+test("query result toolbar SFCs compile", () => {
+  for (const path of [contentAreaPath, dataGridPath, viewSwitcherPath, toolbarActionsPath]) assertSfcCompiles(path);
+});
+
+test("query result toolbar reuses the production icon contract", () => {
+  const contentArea = source(contentAreaPath);
+  const viewSwitcher = source(viewSwitcherPath);
+  const toolbarActions = source(toolbarActionsPath);
+
+  assert.match(contentArea, /<Pin class="h-3\.5 w-3\.5"/);
+  assert.match(contentArea, /<Wrench class="h-4 w-4"/);
+  assert.match(contentArea, /<ChevronDown class="h-3\.5 w-3\.5"/);
+  assert.match(viewSwitcher, /import \{ BarChart3, ListChecks \} from "@lucide\/vue"/);
+  assert.match(toolbarActions, /import \{ GitBranch, Loader2, Upload \} from "@lucide\/vue"/);
+  assert.match(viewSwitcher, /inline-flex h-4 items-center leading-none/);
+  assert.match(toolbarActions, /block h-3\.5 w-3\.5 self-center/);
+  assert.doesNotMatch(viewSwitcher + toolbarActions, /<svg\b|<symbol\b|<use\b/);
+});
+
+test("ContentArea keeps result history conditional and removes duplicate refresh state", () => {
+  const contentArea = source(contentAreaPath);
+
+  assert.match(contentArea, /showResultRunSelector = computed\(\(\) => resultAutoSave\.value && resultRuns\.value\.length > 0\)/);
+  assert.match(contentArea, /<template v-if="showResultRunSelector">/);
+  assert.match(contentArea, /resultAutoSave \? 'bg-primary\/10 text-primary[\s\S]*: 'text-muted-foreground hover:bg-accent hover:text-foreground'/);
+  assert.doesNotMatch(contentArea, /queryResultAutoRefresh|QUERY_RESULT_AUTO_REFRESH|nextResultToolbarLayout/);
+  assert.equal((contentArea.match(/<QueryResultViewSwitcher\b/g) ?? []).length, 2);
+  assert.equal((contentArea.match(/<QueryResultToolbarActions\b/g) ?? []).length, 2);
+});
+
+test("ContentArea keeps MySQL standard explain results available in the shared toolbar", () => {
+  const contentArea = source(contentAreaPath);
+
+  assert.match(contentArea, /canShowExplainOutput = computed\([\s\S]*explainTableResult[\s\S]*explainTableError/);
+  assert.match(contentArea, /:table-result="activeTab\.explainTableResult"/);
+  assert.match(contentArea, /:table-error="activeTab\.explainTableError"/);
+});
+
+test("DataGrid exposes persistent result toolbar slots", () => {
+  const dataGrid = source(dataGridPath);
+
+  assert.match(dataGrid, /slots\["result-toolbar-leading"\]/);
+  assert.match(dataGrid, /slots\["result-toolbar-actions"\]/);
+  assert.match(dataGrid, /<slot name="result-toolbar-leading" :compact="compactDataGridToolbar"/);
+  assert.match(dataGrid, /<slot v-if="hasResultToolbarActionsSlot" name="result-toolbar-actions" :compact="compactDataGridToolbar"/);
+  assert.match(dataGrid, /hasResultToolbarLeadingSlot\.value \|\|[\s\S]*hasResultToolbarActionsSlot\.value/);
+});
+
+test("standalone result views use the same compact toolbar breakpoint", () => {
+  const contentArea = source(contentAreaPath);
+  const dataGrid = source(dataGridPath);
+
+  assert.match(contentArea, /ref="standaloneResultToolbarRef"/);
+  assert.match(contentArea, /standaloneResultToolbarWidth\.value < DATA_GRID_COMPACT_TOPBAR_WIDTH/);
+  assert.equal((contentArea.match(/:compact="standaloneResultToolbarCompact"/g) ?? []).length, 2);
+  assert.match(dataGrid, /dataGridTopbarWidth\.value < DATA_GRID_COMPACT_TOPBAR_WIDTH/);
+});
+
+test("DataGrid marks toolbar refresh separately from current-result reloads", () => {
+  const dataGrid = source(dataGridPath);
+
+  assert.match(dataGrid, /emit\("reload", props\.sql,[^;]+"refresh"\);/);
+  assert.match(dataGrid, /function onToolbarRollback\(\)[\s\S]*?emit\("reload", props\.sql,[^;]+\);/);
+});
+
+test("Elasticsearch JSON refresh preserves multi-result query groups", () => {
+  const contentArea = source(contentAreaPath);
+
+  assert.match(
+    contentArea,
+    /if \(activeElasticsearchJsonResponse\.value\) \{[\s\S]*?emit\("reload", activeResultSql\.value, undefined, undefined, undefined, undefined, undefined, "refresh"\);/,
+  );
+});
diff --git a/packages/app-tests/queryStore.test.ts b/packages/app-tests/queryStore.test.ts
new file mode 100644
index 0000000..363726c
--- /dev/null
+++ b/packages/app-tests/queryStore.test.ts
@@ -0,0 +1,4646 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { createPinia, setActivePinia } from "pinia";
+import { isReactive } from "vue";
+import { decodeQueryResultArchive } from "../../apps/desktop/src/lib/query/queryResultArchive.ts";
+import { resultSqlForGrid } from "../../apps/desktop/src/lib/tabs/tabPresentation.ts";
+import { useConnectionStore } from "../../apps/desktop/src/stores/connectionStore.ts";
+import { useQueryStore } from "../../apps/desktop/src/stores/queryStore.ts";
+import { useSettingsStore } from "../../apps/desktop/src/stores/settingsStore.ts";
+import type { ConnectionConfig } from "../../apps/desktop/src/types/database.ts";
+import type { QueryResult } from "../../apps/desktop/src/types/database.ts";
+
+function installMemoryStorage() {
+  const values = new Map<string, string>();
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+      clear: () => values.clear(),
+    },
+  });
+  return () => {
+    if (original) Object.defineProperty(globalThis, "localStorage", original);
+    else Reflect.deleteProperty(globalThis, "localStorage");
+  };
+}
+
+function conn(id: string): ConnectionConfig {
+  return {
+    id,
+    name: id,
+    db_type: "postgres",
+    host: "localhost",
+    port: 5432,
+    username: "postgres",
+    password: "",
+  };
+}
+
+function oracleConn(id: string): ConnectionConfig {
+  return {
+    ...conn(id),
+    db_type: "oracle",
+    port: 1521,
+  };
+}
+
+function sqlServerConn(id: string): ConnectionConfig {
+  return {
+    ...conn(id),
+    db_type: "sqlserver",
+    port: 1433,
+    username: "sa",
+  };
+}
+
+function sparkConn(id: string): ConnectionConfig {
+  return {
+    ...conn(id),
+    db_type: "spark",
+    port: 10000,
+  };
+}
+
+function withConnectionHealthMock(handler: typeof fetch): typeof fetch {
+  return async (input, init) => {
+    if (String(input) === "/api/connection/check-health") {
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return handler(input, init);
+  };
+}
+
+async function waitFor(predicate: () => boolean, timeoutMs = 1000) {
+  const started = Date.now();
+  while (!predicate()) {
+    if (Date.now() - started > timeoutMs) throw new Error("timed out waiting for condition");
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}
+
+test("setErrorResult stops loading and shows the error result", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db", "users", "data");
+
+  store.setExecuting(tabId, true);
+  store.setErrorResult(tabId, new Error("metadata failed"));
+
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.equal(tab?.isExecuting, false);
+  assert.equal(tab?.isCancelling, false);
+  assert.equal(tab?.executionId, undefined);
+  assert.deepEqual(tab?.result?.columns, ["Error"]);
+  assert.deepEqual(tab?.result?.rows, [["metadata failed"]]);
+});
+
+test("renames query tab titles", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db");
+
+  assert.equal(store.renameTab(tabId, " Revenue checks "), true);
+
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.equal(tab?.title, "Revenue checks");
+  assert.equal(tab?.customTitle, true);
+});
+
+test("closing an active data tab restores the previously focused query tab", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const firstQueryId = store.createTab("conn-1", "db", "query_1", "query");
+  store.createTab("conn-1", "db", "query_2", "query");
+
+  store.activeTabId = firstQueryId;
+  const dataTabId = store.createTab("conn-1", "db", "public.users", "data", "public");
+
+  assert.equal(store.activeTabId, dataTabId);
+
+  store.closeTab(dataTabId);
+
+  assert.equal(store.activeTabId, firstQueryId);
+});
+
+test("linkExternalSqlPath records the local path and detaches saved SQL", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db", "draft.sql");
+
+  store.updateSql(tabId, "select 1;");
+  store.linkSavedSql(tabId, "saved-1", "library.sql");
+  store.linkExternalSqlPath(tabId, "/tmp/draft.sql", "draft.sql");
+  const tab = store.tabs.find((item) => item.id === tabId);
+
+  assert.equal(tab?.externalSqlPath, "/tmp/draft.sql");
+  assert.equal(tab?.savedSqlId, undefined);
+  assert.equal(tab?.title, "draft.sql");
+  assert.equal(store.isTabDirty(tab!), false);
+
+  store.updateSql(tabId, "");
+  assert.equal(store.isTabDirty(tab!), true);
+});
+
+test("external SQL files use full paths as tab identity", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+
+  const demoId = store.openExternalSqlFile("conn-1", "db", "/work/demo/create.sql", "select 'demo';");
+  const learnId = store.openExternalSqlFile("conn-1", "db", "/work/learn/create.sql", "select 'learn';");
+
+  assert.notEqual(demoId, learnId);
+  assert.equal(store.tabs.find((tab) => tab.id === demoId)?.title, "demo/create.sql");
+  assert.equal(store.tabs.find((tab) => tab.id === learnId)?.title, "learn/create.sql");
+  assert.equal(store.tabs.find((tab) => tab.id === demoId)?.sql, "select 'demo';");
+  assert.equal(store.tabs.find((tab) => tab.id === learnId)?.sql, "select 'learn';");
+});
+
+test("reopening an external SQL path preserves unsaved editor content", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.openExternalSqlFile("conn-1", "db", "C:\\work\\draft.sql", "select 1;");
+  store.updateSql(tabId, "select 2;");
+
+  const reopenedId = store.openExternalSqlFile("conn-2", "other", "C:/work/draft.sql", "select 3;");
+
+  assert.equal(reopenedId, tabId);
+  assert.equal(store.tabs.length, 1);
+  assert.equal(store.tabs[0].sql, "select 2;");
+  assert.equal(store.tabs[0].connectionId, "conn-1");
+});
+
+test("external SQL titles collapse after a duplicate filename tab closes", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const firstId = store.openExternalSqlFile("conn-1", "db", "/work/demo/create.sql", "select 1;");
+  const secondId = store.openExternalSqlFile("conn-1", "db", "/work/learn/create.sql", "select 2;");
+
+  store.closeTab(secondId, { force: true });
+
+  assert.equal(store.tabs.find((tab) => tab.id === firstId)?.title, "create.sql");
+});
+
+test("external SQL file paths persist with open query tabs", async () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    setActivePinia(createPinia());
+    let store = useQueryStore();
+    const tabId = store.createTab("conn-1", "db", "draft.sql");
+    store.updateSql(tabId, "select 1;");
+    store.linkExternalSqlPath(tabId, "/tmp/draft.sql", "draft.sql");
+    await store.flushPendingPersist();
+
+    setActivePinia(createPinia());
+    store = useQueryStore();
+    await store.initOpenTabs();
+    const tab = store.tabs.find((item) => item.id === tabId);
+
+    assert.equal(tab?.externalSqlPath, "/tmp/draft.sql");
+    assert.equal(tab?.savedSqlId, undefined);
+    assert.equal(tab?.sql, "select 1;");
+    assert.equal(store.isTabDirty(tab!), false);
+
+    store.updateSql(tabId, "select 2;");
+    assert.equal(store.isTabDirty(tab!), true);
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("clean saved SQL tabs persist without duplicating SQL text", async () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    setActivePinia(createPinia());
+    let store = useQueryStore();
+    store.openSavedSql({
+      id: "saved-1",
+      connectionId: "conn-1",
+      name: "large.sql",
+      database: "db",
+      sql: "SELECT * FROM large_table;".repeat(100),
+      sqlLoaded: true,
+      createdAt: "2026-06-27T00:00:00.000Z",
+      updatedAt: "2026-06-27T00:00:00.000Z",
+    });
+    await store.flushPendingPersist();
+
+    const rawTabs = localStorage.getItem("dbx-app-state:open_tabs") ?? "";
+    assert.equal(rawTabs.includes("large_table"), false);
+
+    setActivePinia(createPinia());
+    store = useQueryStore();
+    await store.initOpenTabs();
+    const tab = store.tabs.find((item) => item.savedSqlId === "saved-1");
+
+    assert.equal(tab?.sql, "");
+    assert.equal(store.isTabDirty(tab!), false);
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("dirty saved SQL tabs keep unsaved edits in open tab persistence", async () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    setActivePinia(createPinia());
+    let store = useQueryStore();
+    const tabId = store.openSavedSql({
+      id: "saved-1",
+      connectionId: "conn-1",
+      name: "draft.sql",
+      database: "db",
+      sql: "SELECT 1;",
+      sqlLoaded: true,
+      createdAt: "2026-06-27T00:00:00.000Z",
+      updatedAt: "2026-06-27T00:00:00.000Z",
+    });
+    store.updateSql(tabId, "SELECT 2;");
+    await store.flushPendingPersist();
+
+    const rawTabs = localStorage.getItem("dbx-app-state:open_tabs") ?? "";
+    assert.equal(rawTabs.includes("SELECT 2;"), true);
+
+    setActivePinia(createPinia());
+    store = useQueryStore();
+    await store.initOpenTabs();
+    const tab = store.tabs.find((item) => item.savedSqlId === "saved-1");
+
+    assert.equal(tab?.sql, "SELECT 2;");
+    assert.equal(store.isTabDirty(tab!), true);
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("marked-clean object source tabs close without unsaved confirmation", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db", "Source - refresh_orders");
+  store.updateSql(tabId, "CREATE PROCEDURE refresh_orders() SELECT 1;");
+  store.setObjectSource(tabId, {
+    schema: "public",
+    name: "refresh_orders",
+    objectType: "PROCEDURE",
+  });
+
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  assert.equal(store.isTabDirty(tab), true);
+
+  store.markTabClean(tab);
+  assert.equal(store.isTabDirty(tab), false);
+
+  store.closeTab(tabId);
+
+  assert.equal(store.showCloseConfirm, false);
+  assert.equal(
+    store.tabs.some((item) => item.id === tabId),
+    false,
+  );
+});
+
+test("close all tabs pauses on unsaved query tabs", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const queryId = store.createTab("conn-1", "db", "draft query");
+  store.updateSql(queryId, "select 1;");
+  const dataId = store.createTab("conn-1", "db", "users", "data");
+
+  store.closeAllTabs();
+
+  assert.equal(store.showCloseConfirm, true);
+  assert.equal(store.pendingCloseTabId, queryId);
+  assert.equal(store.closeConfirmContext, "batch");
+  assert.equal(store.activeTabId, queryId);
+  assert.deepEqual(
+    store.tabs.map((tab) => tab.id),
+    [queryId, dataId],
+  );
+
+  store.forceClosePendingTab();
+
+  assert.equal(store.showCloseConfirm, false);
+  assert.deepEqual(store.tabs, []);
+  assert.equal(store.activeTabId, null);
+});
+
+test("disabled unsaved SQL close confirmation closes dirty tabs directly", () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    setActivePinia(createPinia());
+    const settingsStore = useSettingsStore();
+    settingsStore.updateEditorSettings({ confirmUnsavedSqlClose: false });
+    const store = useQueryStore();
+    const queryId = store.createTab("conn-1", "db", "draft query");
+    store.updateSql(queryId, "select 1;");
+
+    store.closeTab(queryId);
+
+    assert.equal(store.showCloseConfirm, false);
+    assert.deepEqual(
+      store.tabs.map((tab) => tab.id),
+      [],
+    );
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("disabled unsaved SQL close confirmation skips batch close prompt", () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    setActivePinia(createPinia());
+    const settingsStore = useSettingsStore();
+    settingsStore.updateEditorSettings({ confirmUnsavedSqlClose: false });
+    const store = useQueryStore();
+    const queryId = store.createTab("conn-1", "db", "draft query");
+    store.updateSql(queryId, "select 1;");
+    const dataId = store.createTab("conn-1", "db", "users", "data");
+
+    store.closeAllTabs();
+
+    assert.equal(store.showCloseConfirm, false);
+    assert.deepEqual(
+      store.tabs.map((tab) => tab.id),
+      [],
+    );
+    assert.equal(store.activeTabId, null);
+    assert.equal(
+      store.tabs.some((tab) => tab.id === queryId || tab.id === dataId),
+      false,
+    );
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("close other tabs pauses on unsaved query tabs before keeping target tab", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const queryId = store.createTab("conn-1", "db", "draft query");
+  store.updateSql(queryId, "select 1;");
+  const dataId = store.createTab("conn-1", "db", "users", "data");
+
+  store.closeOtherTabs(dataId);
+
+  assert.equal(store.showCloseConfirm, true);
+  assert.equal(store.pendingCloseTabId, queryId);
+  assert.equal(store.closeConfirmContext, "batch");
+  assert.equal(store.activeTabId, queryId);
+  assert.deepEqual(
+    store.tabs.map((tab) => tab.id),
+    [queryId, dataId],
+  );
+
+  store.cancelClosePendingTab();
+
+  assert.equal(store.showCloseConfirm, false);
+  assert.deepEqual(
+    store.tabs.map((tab) => tab.id),
+    [queryId, dataId],
+  );
+
+  store.closeOtherTabs(dataId);
+  store.forceClosePendingTab();
+
+  assert.equal(store.showCloseConfirm, false);
+  assert.deepEqual(
+    store.tabs.map((tab) => tab.id),
+    [dataId],
+  );
+  assert.equal(store.activeTabId, dataId);
+});
+
+test("close regular tabs keeps fixed tabs open", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const fixedId = store.createTab("conn-1", "db", "fixed query");
+  const regularA = store.createTab("conn-1", "db", "regular a");
+  const regularB = store.createTab("conn-1", "db", "regular b");
+  store.togglePinnedTab(fixedId);
+  store.activeTabId = regularB;
+
+  store.closeRegularTabs();
+
+  assert.deepEqual(
+    store.tabs.map((tab) => tab.id),
+    [fixedId],
+  );
+  assert.equal(store.activeTabId, fixedId);
+  assert.equal(
+    store.tabs.some((tab) => tab.id === regularA),
+    false,
+  );
+  assert.equal(
+    store.tabs.some((tab) => tab.id === regularB),
+    false,
+  );
+});
+
+test("close fixed tabs keeps regular tabs open", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const fixedA = store.createTab("conn-1", "db", "fixed a");
+  const fixedB = store.createTab("conn-1", "db", "fixed b");
+  const regularId = store.createTab("conn-1", "db", "regular");
+  store.togglePinnedTab(fixedA);
+  store.togglePinnedTab(fixedB);
+  store.activeTabId = fixedB;
+
+  store.closeFixedTabs();
+
+  assert.deepEqual(
+    store.tabs.map((tab) => tab.id),
+    [regularId],
+  );
+  assert.equal(store.activeTabId, regularId);
+});
+
+test("close other regular tabs does not close fixed tabs", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const fixedId = store.createTab("conn-1", "db", "fixed");
+  const keepId = store.createTab("conn-1", "db", "keep");
+  const closeId = store.createTab("conn-1", "db", "close");
+  store.togglePinnedTab(fixedId);
+
+  store.closeOtherRegularTabs(keepId);
+
+  assert.deepEqual(
+    store.tabs.map((tab) => tab.id),
+    [fixedId, keepId],
+  );
+  assert.equal(store.activeTabId, keepId);
+  assert.equal(
+    store.tabs.some((tab) => tab.id === closeId),
+    false,
+  );
+});
+
+test("close other fixed tabs does not close regular tabs", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const keepFixedId = store.createTab("conn-1", "db", "keep fixed");
+  const closeFixedId = store.createTab("conn-1", "db", "close fixed");
+  const regularId = store.createTab("conn-1", "db", "regular");
+  store.togglePinnedTab(keepFixedId);
+  store.togglePinnedTab(closeFixedId);
+
+  store.closeOtherFixedTabs(keepFixedId);
+
+  assert.deepEqual(
+    store.tabs.map((tab) => tab.id),
+    [keepFixedId, regularId],
+  );
+  assert.equal(store.activeTabId, keepFixedId);
+  assert.equal(
+    store.tabs.some((tab) => tab.id === closeFixedId),
+    false,
+  );
+});
+
+test("close other tabs pauses on restored unsaved query tabs", async () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    localStorage.setItem(
+      "dbx-open-tabs",
+      JSON.stringify([
+        {
+          id: "a",
+          title: "a.sql",
+          connectionId: "conn-1",
+          database: "db",
+          sql: "select 1;",
+          mode: "query",
+        },
+        {
+          id: "b",
+          title: "b.sql",
+          connectionId: "conn-1",
+          database: "db",
+          sql: "",
+          mode: "query",
+        },
+      ]),
+    );
+    localStorage.setItem("dbx-active-tab", "b");
+    setActivePinia(createPinia());
+    const store = useQueryStore();
+    await store.initOpenTabs();
+
+    store.closeOtherTabs("b");
+
+    assert.equal(store.showCloseConfirm, true);
+    assert.equal(store.pendingCloseTabId, "a");
+    assert.equal(store.closeConfirmContext, "batch");
+    assert.equal(store.activeTabId, "a");
+    assert.deepEqual(
+      store.tabs.map((tab) => tab.id),
+      ["a", "b"],
+    );
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("close other tabs pauses on dirty saved SQL file tabs", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const savedId = store.createTab("conn-1", "db", "a.sql");
+  const keepId = store.createTab("conn-1", "db", "b.sql");
+  const savedTab = store.tabs.find((item) => item.id === savedId);
+  assert.ok(savedTab);
+  savedTab.savedSqlId = "saved-a";
+  savedTab.sql = "select 1;";
+  savedTab.originalSql = "select 0;";
+
+  store.closeOtherTabs(keepId);
+
+  assert.equal(store.showCloseConfirm, true);
+  assert.equal(store.pendingCloseTabId, savedId);
+  assert.equal(store.closeConfirmContext, "batch");
+  assert.equal(store.activeTabId, savedId);
+  assert.deepEqual(
+    store.tabs.map((tab) => tab.id),
+    [savedId, keepId],
+  );
+});
+
+test("discard all pending close changes closes the full pending batch", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const firstId = store.createTab("conn-1", "db", "a.sql");
+  store.updateSql(firstId, "select 1;");
+  const secondId = store.createTab("conn-1", "db", "b.sql");
+  store.updateSql(secondId, "select 2;");
+  const keepId = store.createTab("conn-1", "db", "c.sql");
+
+  store.closeOtherTabs(keepId);
+
+  assert.equal(store.showCloseConfirm, true);
+  assert.deepEqual(store.closeConfirmDirtyTabIds, [firstId, secondId]);
+
+  store.forceCloseAllPendingTabs();
+
+  assert.equal(store.showCloseConfirm, false);
+  assert.deepEqual(
+    store.tabs.map((tab) => tab.id),
+    [keepId],
+  );
+  assert.equal(store.activeTabId, keepId);
+});
+
+test("app close confirmation discards dirty SQL without closing the tab", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db", "a.sql");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.savedSqlId = "saved-a";
+  tab.sql = "select 2;";
+  tab.originalSql = "select 1;";
+
+  assert.equal(store.requestAppCloseConfirmation(), true);
+  assert.equal(store.showCloseConfirm, true);
+  assert.equal(store.pendingCloseTabId, tabId);
+  assert.equal(store.closeConfirmContext, "app");
+  assert.equal(store.activeTabId, tabId);
+
+  store.forceClosePendingTab();
+
+  assert.equal(store.showCloseConfirm, false);
+  assert.equal(store.hasDirtyTabs, false);
+  assert.deepEqual(
+    store.tabs.map((item) => item.id),
+    [tabId],
+  );
+  assert.equal(tab.sql, "select 1;");
+});
+
+test("disabled unsaved SQL close confirmation skips app close prompt", () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    setActivePinia(createPinia());
+    const settingsStore = useSettingsStore();
+    settingsStore.updateEditorSettings({ confirmUnsavedSqlClose: false });
+    const store = useQueryStore();
+    const tabId = store.createTab("conn-1", "db", "a.sql");
+    const tab = store.tabs.find((item) => item.id === tabId);
+    assert.ok(tab);
+    tab.savedSqlId = "saved-a";
+    tab.sql = "select 2;";
+    tab.originalSql = "select 1;";
+
+    assert.equal(store.requestAppCloseConfirmation(), false);
+    assert.equal(store.showCloseConfirm, false);
+    assert.equal(store.hasDirtyTabs, true);
+    assert.deepEqual(
+      store.tabs.map((item) => item.id),
+      [tabId],
+    );
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("discard all app close changes keeps tabs open and clean", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const firstId = store.createTab("conn-1", "db", "a.sql");
+  const first = store.tabs.find((item) => item.id === firstId);
+  assert.ok(first);
+  first.sql = "select 2;";
+  first.originalSql = "select 1;";
+  const secondId = store.createTab("conn-1", "db", "b.sql");
+  const second = store.tabs.find((item) => item.id === secondId);
+  assert.ok(second);
+  second.sql = "select 4;";
+  second.originalSql = "select 3;";
+
+  assert.equal(store.requestAppCloseConfirmation(), true);
+  assert.deepEqual(store.closeConfirmDirtyTabIds, [firstId, secondId]);
+  assert.equal(store.activeTabId, firstId);
+
+  store.forceCloseAllPendingTabs();
+
+  assert.equal(store.showCloseConfirm, false);
+  assert.equal(store.hasDirtyTabs, false);
+  assert.deepEqual(
+    store.tabs.map((item) => item.id),
+    [firstId, secondId],
+  );
+  assert.equal(first.sql, "select 1;");
+  assert.equal(second.sql, "select 3;");
+});
+
+test("editing query sql preserves the displayed result editability state", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  tab.sql = "select id, name from users";
+  tab.lastExecutedSql = tab.sql;
+  tab.resultBaseSql = tab.sql;
+  tab.resultSortedSql = "select id, name from users order by name";
+  tab.result = {
+    columns: ["id", "name"],
+    rows: [[1, "Ada"]],
+    affected_rows: 0,
+    execution_time_ms: 1,
+  };
+  tab.tableMeta = {
+    tableName: "users",
+    columns: [
+      {
+        name: "id",
+        data_type: "integer",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: true,
+        extra: null,
+      },
+    ],
+    primaryKeys: ["id"],
+  };
+  tab.queryAnalysis = {
+    tableName: "users",
+    selectStar: false,
+    columns: [
+      { sourceName: "id", resultName: "id", expression: "id" },
+      { sourceName: "name", resultName: "name", expression: "name" },
+    ],
+  };
+  tab.querySourceColumns = ["id", "name"];
+
+  store.updateSql(tabId, "select id, name from users where active = true");
+
+  assert.equal(tab.sql, "select id, name from users where active = true");
+  assert.equal(tab.resultBaseSql, "select id, name from users");
+  assert.equal(tab.resultSortedSql, "select id, name from users order by name");
+  assert.deepEqual(tab.querySourceColumns, ["id", "name"]);
+  assert.equal(tab.queryAnalysis?.tableName, "users");
+  assert.equal(tab.tableMeta?.tableName, "users");
+});
+
+test("sortTabResultLocally sorts current rows and restores original order", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  tab.resultBaseSql = "select id, name from users";
+  tab.resultSortedSql = "select id, name from users order by name";
+  tab.result = {
+    columns: ["id", "name"],
+    rows: [
+      [2, "Grace"],
+      [1, "Ada"],
+      [3, "Linus"],
+    ],
+    mongo_documents: [
+      { id: 2, name: "Grace", nested: { level: 2 } },
+      { id: 1, name: "Ada", nested: { level: 1 } },
+      { id: 3, name: "Linus", nested: { level: 3 } },
+    ],
+    affected_rows: 0,
+    execution_time_ms: 1,
+  };
+
+  store.sortTabResultLocally(tabId, "name", 1, "asc");
+
+  assert.deepEqual(tab.result?.rows, [
+    [1, "Ada"],
+    [2, "Grace"],
+    [3, "Linus"],
+  ]);
+  assert.deepEqual(tab.result?.mongo_documents?.map((document) => (document as { id: number }).id), [1, 2, 3]);
+  assert.equal(tab.resultSortColumn, "name");
+  assert.equal(tab.resultSortColumnIndex, 1);
+  assert.equal(tab.resultSortDirection, "asc");
+  assert.equal(tab.resultSortMode, "local");
+  assert.equal(tab.resultSortedSql, undefined);
+
+  store.sortTabResultLocally(tabId, "name", 1, "desc");
+
+  assert.deepEqual(tab.result?.rows, [
+    [3, "Linus"],
+    [2, "Grace"],
+    [1, "Ada"],
+  ]);
+  assert.deepEqual(tab.result?.mongo_documents?.map((document) => (document as { id: number }).id), [3, 2, 1]);
+
+  store.sortTabResultLocally(tabId, "name", 1, null);
+
+  assert.deepEqual(tab.result?.rows, [
+    [2, "Grace"],
+    [1, "Ada"],
+    [3, "Linus"],
+  ]);
+  assert.deepEqual(tab.result?.mongo_documents?.map((document) => (document as { id: number }).id), [2, 1, 3]);
+  assert.equal(tab.resultSortColumn, undefined);
+  assert.equal(tab.resultSortMode, undefined);
+});
+
+test("selecting a result run restores its displayed result without changing SQL draft", async () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  tab.sql = "select draft";
+  tab.resultRuns = [
+    {
+      id: "run-1",
+      title: "Run 1",
+      sequence: 1,
+      sql: "select 1",
+      createdAt: 1,
+      result: { columns: ["one"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+      resultBaseSql: "select 1",
+    },
+    {
+      id: "run-2",
+      title: "Run 2",
+      sequence: 2,
+      sql: "select 2",
+      createdAt: 2,
+      result: { columns: ["two"], rows: [[2]], affected_rows: 0, execution_time_ms: 1 },
+      resultBaseSql: "select 2",
+    },
+  ];
+  tab.activeResultRunId = "run-2";
+
+  await store.setActiveResultRun(tabId, "run-1");
+
+  assert.equal(tab.sql, "select draft");
+  assert.equal(tab.activeResultRunId, "run-1");
+  assert.deepEqual(tab.result?.columns, ["one"]);
+  assert.deepEqual(tab.result?.rows, [[1]]);
+  assert.equal(tab.resultBaseSql, "select 1");
+});
+
+test("removing the active result run selects an adjacent run", async () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  tab.sql = "select draft";
+  tab.resultRuns = [
+    {
+      id: "run-1",
+      title: "Run 1",
+      sequence: 1,
+      sql: "select 1",
+      createdAt: 1,
+      result: { columns: ["one"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+      resultBaseSql: "select 1",
+    },
+    {
+      id: "run-2",
+      title: "Run 2",
+      sequence: 2,
+      sql: "select 2",
+      createdAt: 2,
+      result: { columns: ["two"], rows: [[2]], affected_rows: 0, execution_time_ms: 1 },
+      resultBaseSql: "select 2",
+    },
+    {
+      id: "run-3",
+      title: "Run 3",
+      sequence: 3,
+      sql: "select 3",
+      createdAt: 3,
+      result: { columns: ["three"], rows: [[3]], affected_rows: 0, execution_time_ms: 1 },
+      resultBaseSql: "select 3",
+    },
+  ];
+  await store.setActiveResultRun(tabId, "run-2");
+
+  assert.equal(await store.removeResultRun(tabId, "run-2"), true);
+
+  assert.deepEqual(
+    tab.resultRuns?.map((run) => run.id),
+    ["run-1", "run-3"],
+  );
+  assert.equal(tab.activeResultRunId, "run-3");
+  assert.deepEqual(tab.result?.columns, ["three"]);
+  assert.deepEqual(tab.result?.rows, [[3]]);
+  assert.equal(tab.sql, "select draft");
+
+  assert.equal(await store.removeResultRun(tabId, "run-3"), true);
+
+  assert.deepEqual(
+    tab.resultRuns?.map((run) => run.id),
+    ["run-1"],
+  );
+  assert.equal(tab.activeResultRunId, "run-1");
+  assert.deepEqual(tab.result?.columns, ["one"]);
+});
+
+test("removing the active result run clears output when remaining caches are unavailable", async () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  tab.resultRuns = [
+    {
+      id: "run-1",
+      title: "Run 1",
+      sequence: 1,
+      sql: "select 1",
+      createdAt: 1,
+      result: { columns: ["one"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+    },
+    {
+      id: "run-2",
+      title: "Run 2",
+      sequence: 2,
+      sql: "select 2",
+      createdAt: 2,
+      resultCacheKey: `missing-result-run-${Date.now()}`,
+      resultCacheState: "disk",
+      resultEvicted: true,
+    },
+  ];
+  await store.setActiveResultRun(tabId, "run-1");
+
+  assert.equal(await store.removeResultRun(tabId, "run-1"), true);
+  assert.equal(tab.activeResultRunId, undefined);
+  assert.equal(tab.result, undefined);
+  assert.equal(tab.results, undefined);
+  assert.deepEqual(tab.resultRuns?.map((run) => run.id), ["run-2"]);
+});
+
+test("removed result runs are excluded from result archives", async () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db", "Revenue checks", "query", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  tab.sql = "select draft";
+  tab.resultRuns = [
+    {
+      id: "run-1",
+      title: "Run 1",
+      sequence: 1,
+      sql: "select 1",
+      createdAt: 1,
+      result: { columns: ["one"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+      resultBaseSql: "select 1",
+    },
+    {
+      id: "run-2",
+      title: "Run 2",
+      sequence: 2,
+      sql: "select 2",
+      createdAt: 2,
+      result: { columns: ["two"], rows: [[2]], affected_rows: 0, execution_time_ms: 1 },
+      resultBaseSql: "select 2",
+    },
+  ];
+  await store.setActiveResultRun(tabId, "run-2");
+
+  assert.equal(await store.removeResultRun(tabId, "run-1"), true);
+  const archive = await store.exportResultArchive(tabId);
+  assert.ok(archive);
+  const decoded = await decodeQueryResultArchive(archive);
+
+  assert.deepEqual(
+    decoded?.snapshot.resultRuns?.map((run) => run.id),
+    ["run-2"],
+  );
+  assert.deepEqual(decoded?.snapshot.resultRuns?.[0]?.result?.columns, ["two"]);
+  assert.deepEqual(decoded?.snapshot.resultRuns?.[0]?.result?.rows, [[2]]);
+});
+
+test("removing the last result run clears output and makes result archive unavailable", async () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  tab.resultRuns = [
+    {
+      id: "run-1",
+      title: "Run 1",
+      sequence: 1,
+      sql: "select 1",
+      createdAt: 1,
+      result: { columns: ["one"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+      resultBaseSql: "select 1",
+    },
+  ];
+  await store.setActiveResultRun(tabId, "run-1");
+
+  assert.equal(await store.removeResultRun(tabId, "run-1"), true);
+
+  assert.deepEqual(tab.resultRuns, []);
+  assert.equal(tab.activeResultRunId, undefined);
+  assert.equal(tab.result, undefined);
+  assert.equal(tab.results, undefined);
+  assert.equal(await store.exportResultArchive(tabId), undefined);
+});
+
+test("result archives import into a new query tab with switchable runs", async () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db", "Revenue checks", "query", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  tab.sql = "select draft";
+  tab.lastExecutedSql = "select 2";
+  tab.resultRuns = [
+    {
+      id: "run-1",
+      title: "Run 1",
+      sequence: 1,
+      sql: "select 1",
+      createdAt: 1,
+      result: { columns: ["one"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+      resultBaseSql: "select 1",
+    },
+    {
+      id: "run-2",
+      title: "Run 2",
+      sequence: 2,
+      sql: "select 2",
+      createdAt: 2,
+      result: { columns: ["two"], rows: [[2]], affected_rows: 0, execution_time_ms: 1 },
+      resultBaseSql: "select 2",
+    },
+  ];
+  tab.activeResultRunId = "run-2";
+  await store.setActiveResultRun(tabId, "run-2");
+
+  const archive = await store.exportResultArchive(tabId);
+  assert.ok(archive);
+
+  const importedTabId = await store.importResultArchive(archive);
+  assert.ok(importedTabId);
+  assert.notEqual(importedTabId, tabId);
+
+  const imported = store.tabs.find((item) => item.id === importedTabId);
+  assert.equal(imported?.title, "Revenue checks");
+  assert.equal(imported?.customTitle, true);
+  assert.equal(imported?.connectionId, "conn-1");
+  assert.equal(imported?.database, "db");
+  assert.equal(imported?.schema, "public");
+  assert.equal(imported?.sql, "select draft");
+  assert.equal(imported?.activeResultRunId, "run-2");
+  assert.deepEqual(imported?.result?.columns, ["two"]);
+  assert.deepEqual(imported?.result?.rows, [[2]]);
+
+  await store.setActiveResultRun(importedTabId, "run-1");
+  assert.deepEqual(imported?.result?.columns, ["one"]);
+  assert.deepEqual(imported?.result?.rows, [[1]]);
+});
+
+test("completed query executions append result runs and select the latest run", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let executeCount = 0;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      executeCount++;
+      return new Response(JSON.stringify([{ columns: [`run_${executeCount}`], rows: [[executeCount]], affected_rows: 0, execution_time_ms: 1 }]), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("conn-1", "db", "Query");
+    store.toggleResultAutoSave(tabId);
+    await store.executeTabSql(tabId, "select 1");
+    await store.executeTabSql(tabId, "select 2");
+
+    const tab = store.tabs.find((item) => item.id === tabId);
+    assert.equal(tab?.resultRuns?.length, 2);
+    assert.deepEqual(
+      tab?.resultRuns?.map((run) => run.title),
+      ["Run 1", "Run 2"],
+    );
+    assert.equal(tab?.resultRuns?.[0]?.sql, "select 1");
+    assert.equal(tab?.resultRuns?.[1]?.sql, "select 2");
+    assert.equal(tab?.activeResultRunId, tab?.resultRuns?.[1]?.id);
+    assert.deepEqual(tab?.result?.columns, ["run_2"]);
+
+    await store.setActiveResultRun(tabId, tab!.resultRuns![0]!.id);
+    assert.deepEqual(tab?.result?.columns, ["run_1"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("kept result runs evict inactive payloads without losing switch or archive data", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const runtimeCache = new Map<string, string>();
+  let executeCount = 0;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      executeCount++;
+      return new Response(JSON.stringify([{ columns: [`run_${executeCount}`], rows: [[executeCount]], affected_rows: 0, execution_time_ms: 1 }]), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/tab-runtime-cache" && init?.method === "POST") {
+      const body = JSON.parse(String(init.body ?? "{}")) as { key: string; payloadBase64: string };
+      runtimeCache.set(body.key, body.payloadBase64);
+      return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url.startsWith("/api/tab-runtime-cache?")) {
+      const key = new URL(url, "http://localhost").searchParams.get("key") ?? "";
+      if (init?.method === "DELETE") {
+        runtimeCache.delete(key);
+        return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+      }
+      return new Response(JSON.stringify({ payloadBase64: runtimeCache.get(key) }), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("conn-1", "db", "Query");
+    store.toggleResultAutoSave(tabId);
+    await store.executeTabSql(tabId, "select 1");
+    await store.executeTabSql(tabId, "select 2");
+
+    const tab = store.tabs.find((item) => item.id === tabId);
+    assert.ok(tab?.resultRuns?.[0]);
+    assert.ok(tab.resultRuns[1]);
+    await waitFor(() => tab.resultRuns?.[0]?.result === undefined && tab.resultRuns?.[0]?.resultCacheState === "disk");
+    assert.deepEqual(tab.result?.columns, ["run_2"]);
+    assert.deepEqual(tab.resultRuns[1]?.result?.columns, ["run_2"]);
+
+    await store.setActiveResultRun(tabId, tab.resultRuns[0].id);
+    assert.deepEqual(tab.result?.columns, ["run_1"]);
+    assert.deepEqual(tab.result?.rows, [[1]]);
+    assert.deepEqual(tab.resultRuns[0]?.result?.columns, ["run_1"]);
+
+    const archive = await store.exportResultArchive(tabId);
+    assert.ok(archive);
+    const decoded = await decodeQueryResultArchive(archive);
+    assert.deepEqual(
+      decoded?.snapshot.resultRuns?.map((run) => run.result?.rows),
+      [[[1]], [[2]]],
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("removing the active result run restores a disk-backed adjacent run", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const runtimeCache = new Map<string, string>();
+  let executeCount = 0;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      executeCount++;
+      return new Response(JSON.stringify([{ columns: [`run_${executeCount}`], rows: [[executeCount]], affected_rows: 0, execution_time_ms: 1 }]), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/tab-runtime-cache" && init?.method === "POST") {
+      const body = JSON.parse(String(init.body ?? "{}")) as { key: string; payloadBase64: string };
+      runtimeCache.set(body.key, body.payloadBase64);
+      return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url.startsWith("/api/tab-runtime-cache?")) {
+      const key = new URL(url, "http://localhost").searchParams.get("key") ?? "";
+      if (init?.method === "DELETE") {
+        runtimeCache.delete(key);
+        return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+      }
+      return new Response(JSON.stringify({ payloadBase64: runtimeCache.get(key) }), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("conn-1", "db", "Query");
+    store.toggleResultAutoSave(tabId);
+    await store.executeTabSql(tabId, "select 1");
+    await store.executeTabSql(tabId, "select 2");
+
+    const tab = store.tabs.find((item) => item.id === tabId);
+    assert.ok(tab?.resultRuns?.[0]);
+    assert.ok(tab.resultRuns[1]);
+    await waitFor(() => tab.resultRuns?.[0]?.result === undefined && tab.resultRuns?.[0]?.resultCacheState === "disk");
+
+    assert.equal(await store.removeResultRun(tabId, tab.resultRuns[1].id), true);
+
+    assert.equal(tab.activeResultRunId, tab.resultRuns[0]?.id);
+    assert.deepEqual(tab.result?.columns, ["run_1"]);
+    assert.deepEqual(tab.result?.rows, [[1]]);
+    assert.deepEqual(tab.resultRuns[0]?.result?.columns, ["run_1"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("failed query executions append switchable error result runs", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      return new Response("backend exploded", { status: 500 });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("conn-1", "db", "Query");
+    store.toggleResultAutoSave(tabId);
+    await store.executeTabSql(tabId, "select broken");
+
+    const tab = store.tabs.find((item) => item.id === tabId);
+    assert.equal(tab?.resultRuns?.length, 1);
+    assert.equal(tab?.activeResultRunId, tab?.resultRuns?.[0]?.id);
+    assert.deepEqual(tab?.resultRuns?.[0]?.result?.columns, ["Error"]);
+    assert.deepEqual(tab?.result?.columns, ["Error"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("query execution errors mentioning connection keep the connection active", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  connectionStore.activeConnectionId = "conn-1";
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      return new Response('relation "connection" does not exist', { status: 500 });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("conn-1", "db", "Query");
+    await store.executeTabSql(tabId, "select connection from missing_table");
+
+    assert.equal(connectionStore.connectedIds.has("conn-1"), true);
+    assert.equal(connectionStore.activeConnectionId, "conn-1");
+    assert.equal(connectionStore.connectionErrors["conn-1"], undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("statement result switching is scoped to the active result run", async () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+  const tabId = store.createTab("conn-1", "db");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  tab.resultRuns = [
+    {
+      id: "run-1",
+      title: "Run 1",
+      sequence: 1,
+      sql: "select 1; select 10",
+      createdAt: 1,
+      results: [
+        { columns: ["a"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+        { columns: ["b"], rows: [[10]], affected_rows: 0, execution_time_ms: 1 },
+      ],
+      activeResultIndex: 0,
+    },
+    {
+      id: "run-2",
+      title: "Run 2",
+      sequence: 2,
+      sql: "select 2; select 20",
+      createdAt: 2,
+      results: [
+        { columns: ["c"], rows: [[2]], affected_rows: 0, execution_time_ms: 1 },
+        { columns: ["d"], rows: [[20]], affected_rows: 0, execution_time_ms: 1 },
+      ],
+      activeResultIndex: 0,
+    },
+  ];
+  tab.activeResultRunId = "run-1";
+  await store.setActiveResultRun(tabId, "run-1");
+
+  store.setActiveResultIndex(tabId, 1);
+  assert.deepEqual(tab.result?.columns, ["b"]);
+  assert.equal(tab.resultRuns[0]?.activeResultIndex, 1);
+
+  await store.setActiveResultRun(tabId, "run-2");
+  assert.deepEqual(tab.result?.columns, ["c"]);
+  assert.equal(tab.activeResultIndex, 0);
+});
+
+test("normalizes unquoted Oracle query identifiers before loading editable metadata", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const columnRequests: Array<{ schema: string | null; table: string | null }> = [];
+
+  connectionStore.addEphemeralConnection(oracleConn("oracle-1"));
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/execute-multi") {
+      return new Response(
+        JSON.stringify([
+          {
+            columns: ["ID", "NAME"],
+            rows: [[1, "Ada"]],
+            affected_rows: 0,
+            execution_time_ms: 1,
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/analyze-editability") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      assert.equal(body.sql, "select id, name from users");
+      return new Response(
+        JSON.stringify({
+          editable: true,
+          analysis: {
+            schema: undefined,
+            schemaQuoted: false,
+            tableName: "users",
+            tableNameQuoted: false,
+            tableAlias: undefined,
+            selectStar: false,
+            columns: [
+              { sourceName: "id", sourceNameQuoted: false, resultName: "id", expression: "id" },
+              { sourceName: "name", sourceNameQuoted: false, resultName: "name", expression: "name" },
+            ],
+          },
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url.startsWith("/api/schema/columns?")) {
+      const params = new URL(url, "http://localhost").searchParams;
+      columnRequests.push({ schema: params.get("schema"), table: params.get("table") });
+      return new Response(
+        JSON.stringify([
+          {
+            name: "ID",
+            data_type: "NUMBER",
+            is_nullable: false,
+            column_default: null,
+            is_primary_key: true,
+            extra: null,
+            comment: "identifier",
+          },
+          {
+            name: "NAME",
+            data_type: "VARCHAR2",
+            is_nullable: true,
+            column_default: null,
+            is_primary_key: false,
+            extra: null,
+            comment: "display name",
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("oracle-1", "ORCL", "Query 1", "query", "app");
+    await store.executeTabSql(tabId, "select id, name from users");
+
+    const tab = store.tabs.find((item) => item.id === tabId);
+    await waitFor(() => columnRequests.length > 0 && tab?.tableMeta?.tableName === "USERS");
+    assert.deepEqual(columnRequests, [{ schema: "APP", table: "USERS" }]);
+    assert.equal(tab?.tableMeta?.schema, "APP");
+    assert.equal(tab?.tableMeta?.tableName, "USERS");
+    assert.deepEqual(tab?.querySourceColumns, ["ID", "NAME"]);
+    assert.equal(tab?.queryEditabilityReason, undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("binds DISTINCT qualified-star edits to the single safe joined source", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const columnRequests: Array<{ schema: string | null; table: string | null }> = [];
+
+  connectionStore.addEphemeralConnection(conn("pg-join-1"));
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/execute-multi") {
+      return new Response(
+        JSON.stringify([
+          {
+            columns: ["id", "name"],
+            rows: [[1, "Ada"]],
+            affected_rows: 0,
+            execution_time_ms: 1,
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/analyze-editability") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      assert.equal(body.sql, "select distinct u.* from users u join orders o on o.user_id = u.id");
+      return new Response(
+        JSON.stringify({
+          editable: true,
+          analysis: {
+            schema: undefined,
+            schemaQuoted: false,
+            tableName: "users",
+            tableNameQuoted: false,
+            tableAlias: "u",
+            selectStar: false,
+            distinct: true,
+            multiSource: true,
+            allowInsertDelete: false,
+            sources: [
+              { key: "u:0", tableName: "users", tableNameQuoted: false, schemaQuoted: false, alias: "u" },
+              { key: "o:1", tableName: "orders", tableNameQuoted: false, schemaQuoted: false, alias: "o" },
+            ],
+            columns: [{ star: true, sourceQualifier: "u", sourceKey: "u:0", resultName: "*", expression: "u.*" }],
+          },
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url.startsWith("/api/schema/columns?")) {
+      const params = new URL(url, "http://localhost").searchParams;
+      const table = params.get("table");
+      columnRequests.push({ schema: params.get("schema"), table });
+      const columns =
+        table === "users"
+          ? [
+              { name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null, comment: null },
+              { name: "name", data_type: "text", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
+            ]
+          : [
+              { name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null, comment: null },
+              { name: "user_id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: false, extra: null, comment: null },
+              { name: "total", data_type: "numeric", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
+            ];
+      return new Response(JSON.stringify(columns), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const sql = "select distinct u.* from users u join orders o on o.user_id = u.id";
+    const tabId = store.createTab("pg-join-1", "appdb", "Query 1", "query");
+    await store.executeTabSql(tabId, sql);
+
+    const tab = store.tabs.find((item) => item.id === tabId);
+    await waitFor(() => columnRequests.length === 2 && tab?.tableMeta?.tableName === "users");
+    assert.deepEqual(columnRequests, [
+      { schema: "public", table: "users" },
+      { schema: "public", table: "orders" },
+    ]);
+    assert.equal(tab?.queryEditabilityReason, undefined);
+    assert.equal(tab?.queryAnalysis?.multiSource, true);
+    assert.equal(tab?.queryAnalysis?.distinct, true);
+    assert.equal(tab?.queryAnalysis?.allowInsertDelete, false);
+    assert.equal(tab?.tableMeta?.tableName, "users");
+    assert.deepEqual(tab?.querySourceColumns, ["id", "name"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("expands single-table alias star projections for editable query metadata", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const columnRequests: Array<{ schema: string | null; table: string | null }> = [];
+
+  connectionStore.addEphemeralConnection(conn("pg-star-1"));
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/execute-multi") {
+      return new Response(
+        JSON.stringify([
+          {
+            columns: ["create_date", "id", "container_main_id"],
+            rows: [["2026-07-09 13:59:35", "20750975119640248", null]],
+            affected_rows: 0,
+            execution_time_ms: 1,
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/analyze-editability") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      assert.equal(body.sql, "select t.create_date, t.* from tt_kd_material_container_sap t where t.order_no = 'KD2607071336' order by t.create_date desc");
+      return new Response(
+        JSON.stringify({
+          editable: true,
+          analysis: {
+            schema: undefined,
+            schemaQuoted: false,
+            tableName: "tt_kd_material_container_sap",
+            tableNameQuoted: false,
+            tableAlias: "t",
+            selectStar: false,
+            columns: [
+              { sourceName: "create_date", sourceNameQuoted: false, sourceQualifier: "t", sourceKey: "t:0", resultName: "create_date", expression: "t.create_date" },
+              { star: true, sourceQualifier: "t", sourceKey: "t:0", resultName: "*", expression: "t.*" },
+            ],
+          },
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url.startsWith("/api/schema/columns?")) {
+      const params = new URL(url, "http://localhost").searchParams;
+      columnRequests.push({ schema: params.get("schema"), table: params.get("table") });
+      return new Response(
+        JSON.stringify([
+          { name: "create_date", data_type: "timestamp", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
+          { name: "id", data_type: "varchar", is_nullable: false, column_default: null, is_primary_key: true, extra: null, comment: null },
+          { name: "container_main_id", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const sql = "select t.create_date, t.* from tt_kd_material_container_sap t where t.order_no = 'KD2607071336' order by t.create_date desc";
+    const tabId = store.createTab("pg-star-1", "appdb", "Query 1", "query");
+    await store.executeTabSql(tabId, sql);
+
+    const tab = store.tabs.find((item) => item.id === tabId);
+    await waitFor(() => columnRequests.length === 1 && tab?.tableMeta?.tableName === "tt_kd_material_container_sap");
+    assert.deepEqual(columnRequests, [{ schema: "public", table: "tt_kd_material_container_sap" }]);
+    assert.equal(tab?.queryEditabilityReason, undefined);
+    assert.equal(tab?.queryAnalysis?.selectStar, false);
+    assert.equal(tab?.tableMeta?.tableName, "tt_kd_material_container_sap");
+    assert.deepEqual(tab?.querySourceColumns, ["create_date", "id", "container_main_id"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("keeps joined query read-only when multiple source tables are writable candidates", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const columnRequests: Array<{ schema: string | null; table: string | null }> = [];
+
+  connectionStore.addEphemeralConnection(conn("pg-join-ambiguous"));
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/execute-multi") {
+      return new Response(
+        JSON.stringify([
+          {
+            columns: ["user_id", "name", "order_id", "total"],
+            rows: [[1, "Ada", 10, 42]],
+            affected_rows: 0,
+            execution_time_ms: 1,
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/analyze-editability") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      assert.equal(body.sql, "select u.id as user_id, u.name, o.id as order_id, o.total from users u join orders o on o.user_id = u.id");
+      return new Response(
+        JSON.stringify({
+          editable: true,
+          analysis: {
+            schema: undefined,
+            schemaQuoted: false,
+            tableName: "users",
+            tableNameQuoted: false,
+            tableAlias: "u",
+            selectStar: false,
+            multiSource: true,
+            allowInsertDelete: false,
+            sources: [
+              { key: "u:0", tableName: "users", tableNameQuoted: false, schemaQuoted: false, alias: "u" },
+              { key: "o:1", tableName: "orders", tableNameQuoted: false, schemaQuoted: false, alias: "o" },
+            ],
+            columns: [
+              { sourceName: "id", sourceNameQuoted: false, sourceQualifier: "u", sourceKey: "u:0", resultName: "user_id", expression: "u.id" },
+              { sourceName: "name", sourceNameQuoted: false, sourceQualifier: "u", sourceKey: "u:0", resultName: "name", expression: "u.name" },
+              { sourceName: "id", sourceNameQuoted: false, sourceQualifier: "o", sourceKey: "o:1", resultName: "order_id", expression: "o.id" },
+              { sourceName: "total", sourceNameQuoted: false, sourceQualifier: "o", sourceKey: "o:1", resultName: "total", expression: "o.total" },
+            ],
+          },
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url.startsWith("/api/schema/columns?")) {
+      const params = new URL(url, "http://localhost").searchParams;
+      const table = params.get("table");
+      columnRequests.push({ schema: params.get("schema"), table });
+      const columns =
+        table === "users"
+          ? [
+              { name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null, comment: null },
+              { name: "name", data_type: "text", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
+            ]
+          : [
+              { name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null, comment: null },
+              { name: "total", data_type: "numeric", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
+            ];
+      return new Response(JSON.stringify(columns), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const sql = "select u.id as user_id, u.name, o.id as order_id, o.total from users u join orders o on o.user_id = u.id";
+    const tabId = store.createTab("pg-join-ambiguous", "appdb", "Query 1", "query");
+    await store.executeTabSql(tabId, sql);
+
+    const tab = store.tabs.find((item) => item.id === tabId);
+    await waitFor(() => columnRequests.length === 2 && tab?.queryEditabilityReason === "complex-source");
+    assert.equal(tab?.queryAnalysis, undefined);
+    assert.equal(tab?.tableMeta, undefined);
+    assert.equal(tab?.querySourceColumns, undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("uses dbo as SQL Server metadata schema when query omits schema", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const columnRequests: Array<{ schema: string | null; table: string | null }> = [];
+
+  connectionStore.addEphemeralConnection(sqlServerConn("sqlserver-1"));
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/execute-multi") {
+      return new Response(
+        JSON.stringify([
+          {
+            columns: ["ID", "NAME"],
+            rows: [[1, "Ada"]],
+            affected_rows: 0,
+            execution_time_ms: 1,
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/analyze-editability") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      assert.equal(body.sql, "select id, name from users");
+      return new Response(
+        JSON.stringify({
+          editable: true,
+          analysis: {
+            schema: undefined,
+            schemaQuoted: false,
+            tableName: "users",
+            tableNameQuoted: false,
+            tableAlias: undefined,
+            selectStar: false,
+            columns: [
+              { sourceName: "id", sourceNameQuoted: false, resultName: "ID", expression: "id" },
+              { sourceName: "name", sourceNameQuoted: false, resultName: "NAME", expression: "name" },
+            ],
+          },
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url.startsWith("/api/schema/columns?")) {
+      const params = new URL(url, "http://localhost").searchParams;
+      columnRequests.push({ schema: params.get("schema"), table: params.get("table") });
+      return new Response(
+        JSON.stringify([
+          {
+            name: "ID",
+            data_type: "int",
+            is_nullable: false,
+            column_default: null,
+            is_primary_key: true,
+            extra: null,
+            comment: "编号",
+          },
+          {
+            name: "NAME",
+            data_type: "nvarchar(100)",
+            is_nullable: true,
+            column_default: null,
+            is_primary_key: false,
+            extra: null,
+            comment: "姓名",
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("sqlserver-1", "app", "Query 1", "query");
+    await store.executeTabSql(tabId, "select id, name from users");
+
+    const tab = store.tabs.find((item) => item.id === tabId);
+    await waitFor(() => columnRequests.length > 0 && tab?.tableMeta?.tableName === "users");
+    assert.deepEqual(columnRequests, [{ schema: "dbo", table: "users" }]);
+    assert.equal(tab?.tableMeta?.schema, "dbo");
+    assert.equal(tab?.tableMeta?.columns[0]?.comment, "编号");
+    assert.equal(tab?.tableMeta?.columns[1]?.comment, "姓名");
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("evicting cached tab results releases multi-result payloads and sessions", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let executeCount = 0;
+  const closedSessions: string[] = [];
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/execute-multi") {
+      executeCount++;
+      const results: QueryResult[] = [
+        {
+          columns: ["id"],
+          rows: [[executeCount]],
+          affected_rows: 0,
+          execution_time_ms: 1,
+          session_id: `session-${executeCount}`,
+        },
+        {
+          columns: ["detail"],
+          rows: [[`payload-${executeCount}`]],
+          affected_rows: 0,
+          execution_time_ms: 1,
+        },
+      ];
+      return new Response(JSON.stringify(results), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/query/close-session") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      closedSessions.push(body.sessionId);
+      return new Response(JSON.stringify(true), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(
+        JSON.stringify({
+          sqlToExecute: body.options.sql,
+          useAgentResultSession: false,
+        }),
+        {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabIds: string[] = [];
+    for (let i = 0; i < 7; i++) {
+      const tabId = store.createTab("conn-1", "db", `Query ${i + 1}`);
+      tabIds.push(tabId);
+      await store.executeTabSql(tabId, `select ${i + 1}; select ${i + 1} as detail`);
+    }
+
+    await waitFor(() => store.tabs.find((tab) => tab.id === tabIds[0])?.resultEvicted === true);
+    const evicted = store.tabs.find((tab) => tab.id === tabIds[0]);
+    assert.equal(executeCount, 7);
+    assert.equal(evicted?.result, undefined);
+    assert.equal(evicted?.results, undefined);
+    assert.equal(evicted?.activeResultIndex, undefined);
+    assert.equal(evicted?.resultSessionId, undefined);
+    assert.equal(evicted?.resultEvicted, true);
+    assert.deepEqual(closedSessions, ["session-1"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("result cache eviction keeps recently accessed inactive tabs", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let executeCount = 0;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+
+  globalThis.fetch = withConnectionHealthMock(async (input) => {
+    const url = String(input);
+    if (url === "/api/query/execute-multi") {
+      executeCount++;
+      const results: QueryResult[] = [
+        {
+          columns: ["id"],
+          rows: [[executeCount]],
+          affected_rows: 0,
+          execution_time_ms: 1,
+          session_id: `session-${executeCount}`,
+        },
+      ];
+      return new Response(JSON.stringify(results), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/query/close-session") {
+      return new Response(JSON.stringify(true), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/prepare-pagination-plan") {
+      return new Response(JSON.stringify({ sqlToExecute: "select 1", useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabIds: string[] = [];
+    for (let i = 0; i < 6; i++) {
+      const tabId = store.createTab("conn-1", "db", `Query ${i + 1}`);
+      tabIds.push(tabId);
+      await store.executeTabSql(tabId, `select ${i + 1}`);
+    }
+
+    store.activeTabId = tabIds[0];
+    await new Promise((resolve) => setTimeout(resolve, 1));
+
+    const tabId = store.createTab("conn-1", "db", "Query 7");
+    tabIds.push(tabId);
+    await store.executeTabSql(tabId, "select 7");
+
+    await waitFor(() => store.tabs.find((tab) => tab.id === tabIds[1])?.resultEvicted === true);
+    const recentlyViewed = store.tabs.find((tab) => tab.id === tabIds[0]);
+    const leastRecentlyUsed = store.tabs.find((tab) => tab.id === tabIds[1]);
+    assert.ok(recentlyViewed?.result);
+    assert.equal(recentlyViewed?.resultEvicted, undefined);
+    assert.equal(leastRecentlyUsed?.result, undefined);
+    assert.equal(leastRecentlyUsed?.resultEvicted, true);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("closing tabs clears removed result payloads before dropping tab references", async () => {
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = withConnectionHealthMock(async () => {
+    return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+  });
+  try {
+    setActivePinia(createPinia());
+    const store = useQueryStore();
+    const keepId = store.createTab("conn-1", "db", "keep");
+    const closeId = store.createTab("conn-1", "db", "close");
+    const closingTab = store.tabs.find((item) => item.id === closeId);
+
+    assert.ok(closingTab);
+    closingTab.result = {
+      columns: ["payload"],
+      rows: [[new Array(10_000).fill("x").join("")]],
+      affected_rows: 0,
+      execution_time_ms: 1,
+      session_id: "session-close",
+    };
+    closingTab.results = [closingTab.result];
+    closingTab.activeResultIndex = 0;
+    closingTab.resultSessionId = "session-close";
+
+    store.closeOtherTabs(keepId);
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    assert.equal(closingTab.result, undefined);
+    assert.equal(closingTab.results, undefined);
+    assert.equal(closingTab.activeResultIndex, undefined);
+    assert.equal(closingTab.resultSessionId, undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("closing database tabs removes browser tabs for that database only", async () => {
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = withConnectionHealthMock(async () => {
+    return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+  });
+
+  try {
+    setActivePinia(createPinia());
+    const store = useQueryStore();
+    const dataId = store.createTab("conn-1", "db", "users", "data", "public");
+    const objectsId = store.openObjectBrowser("conn-1", "db", "public");
+    const structureId = store.openTableStructure("conn-1", "db", "public", "users");
+    const mongoId = store.createTab("conn-1", "db", "orders", "mongo");
+    const queryId = store.createTab("conn-1", "db", "draft query", "query");
+    const otherDbId = store.createTab("conn-1", "analytics", "users", "data", "public");
+    const otherConnectionId = store.createTab("conn-2", "db", "users", "data", "public");
+    const structureTab = store.tabs.find((item) => item.id === structureId);
+
+    assert.ok(structureTab);
+    structureTab.result = {
+      columns: ["payload"],
+      rows: [["structure"]],
+      affected_rows: 0,
+      execution_time_ms: 1,
+      session_id: "session-structure",
+    };
+    structureTab.resultSessionId = "session-structure";
+    store.activeTabId = structureId;
+
+    store.closeDatabaseTabs("conn-1", "db");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    assert.deepEqual(
+      store.tabs.map((tab) => tab.id),
+      [otherDbId, otherConnectionId],
+    );
+    assert.equal(store.activeTabId, otherConnectionId);
+    assert.equal(
+      store.tabs.some((tab) => [dataId, objectsId, structureId, mongoId, queryId].includes(tab.id)),
+      false,
+    );
+    assert.equal(structureTab.result, undefined);
+    assert.equal(structureTab.resultSessionId, undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("closing connection tabs removes every tab for that connection only", async () => {
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = withConnectionHealthMock(async () => {
+    return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+  });
+
+  try {
+    setActivePinia(createPinia());
+    const store = useQueryStore();
+    const queryId = store.createTab("conn-1", "db", "draft query", "query");
+    const dataId = store.createTab("conn-1", "db", "users", "data", "public");
+    const objectsId = store.openObjectBrowser("conn-1", "db", "public");
+    const otherConnectionId = store.createTab("conn-2", "db", "users", "data", "public");
+    const queryTab = store.tabs.find((item) => item.id === queryId);
+
+    assert.ok(queryTab);
+    queryTab.result = {
+      columns: ["payload"],
+      rows: [["query"]],
+      affected_rows: 0,
+      execution_time_ms: 1,
+      session_id: "session-query",
+    };
+    queryTab.resultSessionId = "session-query";
+    store.activeTabId = queryId;
+
+    store.closeConnectionTabs("conn-1");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    assert.deepEqual(
+      store.tabs.map((tab) => tab.id),
+      [otherConnectionId],
+    );
+    assert.equal(store.activeTabId, otherConnectionId);
+    assert.equal(
+      store.tabs.some((tab) => [queryId, dataId, objectsId].includes(tab.id)),
+      false,
+    );
+    assert.equal(queryTab.result, undefined);
+    assert.equal(queryTab.resultSessionId, undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("releasing connection tabs keeps SQL tabs and closes object tabs", async () => {
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = withConnectionHealthMock(async () => {
+    return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+  });
+
+  try {
+    setActivePinia(createPinia());
+    const store = useQueryStore();
+    const queryId = store.createTab("conn-1", "db", "draft query", "query");
+    const dataId = store.createTab("conn-1", "db", "users", "data", "public");
+    const objectsId = store.openObjectBrowser("conn-1", "db", "public");
+    const structureId = store.openTableStructure("conn-1", "db", "public", "users");
+    const otherConnectionId = store.createTab("conn-2", "db", "users", "data", "public");
+    const queryTab = store.tabs.find((item) => item.id === queryId);
+    const dataTab = store.tabs.find((item) => item.id === dataId);
+
+    assert.ok(queryTab);
+    assert.ok(dataTab);
+    queryTab.result = {
+      columns: ["payload"],
+      rows: [["query"]],
+      affected_rows: 0,
+      execution_time_ms: 1,
+      session_id: "session-query",
+    };
+    queryTab.resultSessionId = "session-query";
+    dataTab.result = {
+      columns: ["payload"],
+      rows: [["data"]],
+      affected_rows: 0,
+      execution_time_ms: 1,
+      session_id: "session-data",
+    };
+    dataTab.resultSessionId = "session-data";
+    store.activeTabId = dataId;
+
+    store.releaseConnectionTabs("conn-1");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    assert.deepEqual(
+      store.tabs.map((tab) => tab.id),
+      [queryId, otherConnectionId],
+    );
+    assert.equal(store.activeTabId, otherConnectionId);
+    assert.equal(
+      store.tabs.some((tab) => [dataId, objectsId, structureId].includes(tab.id)),
+      false,
+    );
+    assert.equal(queryTab.result, undefined);
+    assert.equal(queryTab.resultSessionId, undefined);
+    assert.equal(dataTab.result, undefined);
+    assert.equal(dataTab.resultSessionId, undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("releasing database tabs keeps SQL tabs and closes table tabs for that database only", async () => {
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = withConnectionHealthMock(async () => {
+    return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+  });
+
+  try {
+    setActivePinia(createPinia());
+    const store = useQueryStore();
+    const queryId = store.createTab("conn-1", "db", "draft query", "query");
+    const dataId = store.createTab("conn-1", "db", "users", "data", "public");
+    const otherDbId = store.createTab("conn-1", "analytics", "orders", "data", "public");
+    const otherConnectionId = store.createTab("conn-2", "db", "users", "data", "public");
+    const queryTab = store.tabs.find((item) => item.id === queryId);
+
+    assert.ok(queryTab);
+    queryTab.result = {
+      columns: ["payload"],
+      rows: [["query"]],
+      affected_rows: 0,
+      execution_time_ms: 1,
+      session_id: "session-query",
+    };
+    queryTab.resultSessionId = "session-query";
+
+    store.releaseDatabaseTabs("conn-1", "db");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    assert.deepEqual(
+      store.tabs.map((tab) => tab.id),
+      [queryId, otherDbId, otherConnectionId],
+    );
+    assert.equal(
+      store.tabs.some((tab) => tab.id === dataId),
+      false,
+    );
+    assert.equal(queryTab.result, undefined);
+    assert.equal(queryTab.resultSessionId, undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("disconnecting a connection closes every tab for that connection", async () => {
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = withConnectionHealthMock(async () => {
+    return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+  });
+
+  try {
+    setActivePinia(createPinia());
+    const connectionStore = useConnectionStore();
+    const queryStore = useQueryStore();
+    connectionStore.addEphemeralConnection(conn("conn-1"));
+    connectionStore.addEphemeralConnection(conn("conn-2"));
+    const queryId = queryStore.createTab("conn-1", "db", "draft query", "query");
+    const dataId = queryStore.createTab("conn-1", "db", "users", "data", "public");
+    const otherConnectionId = queryStore.createTab("conn-2", "db", "users", "data", "public");
+
+    queryStore.activeTabId = dataId;
+    await connectionStore.disconnect("conn-1");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    assert.deepEqual(
+      queryStore.tabs.map((tab) => tab.id),
+      [otherConnectionId],
+    );
+    assert.equal(queryStore.activeTabId, otherConnectionId);
+    assert.equal(
+      queryStore.tabs.some((tab) => [queryId, dataId].includes(tab.id)),
+      false,
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("starting a new query clears the previous result payload immediately", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "Query");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.result = {
+    columns: ["old"],
+    rows: [[new Array(10_000).fill("old").join("")]],
+    affected_rows: 0,
+    execution_time_ms: 1,
+  };
+
+  globalThis.fetch = withConnectionHealthMock(async (input) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      return new Response(JSON.stringify({ sqlToExecute: "select 1", useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      return new Response(JSON.stringify([{ columns: ["new"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const execution = store.executeTabSql(tabId, "select 1");
+    assert.equal(tab.result, undefined);
+    assert.equal(tab.results, undefined);
+    await execution;
+    assert.deepEqual(tab.result?.columns, ["new"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("grid refreshes can preserve the previous result while loading", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "Query");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  const previousResult: QueryResult = {
+    columns: ["id", "name"],
+    rows: [[1, "Ada"]],
+    affected_rows: 0,
+    execution_time_ms: 1,
+  };
+  tab.result = previousResult;
+
+  globalThis.fetch = withConnectionHealthMock(async (input) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      return new Response(JSON.stringify({ sqlToExecute: "select 1 order by name", useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      return new Response(JSON.stringify([{ columns: ["id", "name"], rows: [[2, "Grace"]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const execution = store.executeTabSql(tabId, "select 1 order by name", {
+      preserveResultDuringExecution: true,
+    });
+    assert.deepEqual(tab.result?.columns, previousResult.columns);
+    assert.deepEqual(tab.result?.rows, previousResult.rows);
+    assert.equal(tab.isExecuting, true);
+    await execution;
+    assert.deepEqual(tab.result?.rows, [[2, "Grace"]]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("data tab execution preserves pagination offset metadata", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let executeBody: any;
+  let preparedPagination = false;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "users", "data", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      preparedPagination = true;
+      return new Response("unexpected pagination plan request", { status: 500 });
+    }
+    if (url === "/api/query/execute-multi") {
+      executeBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify([{ columns: ["id"], rows: [[101]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, 'SELECT * FROM "users" LIMIT 100 OFFSET 100;', {
+      pagination: { limit: 100, offset: 100 },
+    });
+
+    assert.equal(preparedPagination, false);
+    assert.equal(executeBody.sql, 'SELECT * FROM "users" LIMIT 100 OFFSET 100;');
+    assert.equal(executeBody.maxRows, 100);
+    assert.equal(executeBody.fetchSize, 100);
+    assert.equal(executeBody.schema, undefined);
+    assert.equal(tab.resultPageLimit, 100);
+    assert.equal(tab.resultPageOffset, 100);
+    assert.deepEqual(tab.result?.rows, [[101]]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("data tab default pagination is independent from query result page size", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const settingsStore = useSettingsStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let executeBody: any;
+  let preparedPagination = false;
+
+  settingsStore.updateEditorSettings({ pageSize: 1000 });
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "users", "data", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      preparedPagination = true;
+      return new Response("unexpected pagination plan request", { status: 500 });
+    }
+    if (url === "/api/query/execute-multi") {
+      executeBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify([{ columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, 'SELECT * FROM "users" LIMIT 100;');
+
+    assert.equal(preparedPagination, false);
+    assert.equal(executeBody.maxRows, 100);
+    assert.equal(executeBody.fetchSize, 100);
+    assert.equal(tab.resultPageLimit, 100);
+    assert.equal(tab.resultPageOffset, 0);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("reloading an evicted data tab preserves its saved pagination", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const settingsStore = useSettingsStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let executeBody: any;
+
+  settingsStore.updateEditorSettings({ pageSize: 1000 });
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "users", "data", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.sql = 'SELECT * FROM "public"."users" LIMIT 50 OFFSET 50;';
+  tab.lastExecutedSql = tab.sql;
+  tab.resultPageLimit = 50;
+  tab.resultPageOffset = 50;
+  tab.resultEvicted = true;
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/execute-multi") {
+      executeBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify([{ columns: ["id"], rows: [[51]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.reloadEvictedTab(tabId);
+
+    assert.equal(executeBody.maxRows, 50);
+    assert.equal(executeBody.fetchSize, 50);
+    assert.equal(tab.resultPageLimit, 50);
+    assert.equal(tab.resultPageOffset, 50);
+    assert.equal(tab.resultEvicted, undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("activating an empty data tab waits for explicit execution", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let executeBody: any;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "users", "data", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.sql = 'SELECT * FROM "public"."users" LIMIT 50 OFFSET 50;';
+  tab.lastExecutedSql = tab.sql;
+  tab.resultPageLimit = 50;
+  tab.resultPageOffset = 50;
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/execute-multi") {
+      executeBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify([{ columns: ["id"], rows: [[51]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.reloadEvictedTab(tabId);
+
+    assert.equal(executeBody, undefined);
+    assert.equal(tab.result, undefined);
+    assert.equal(tab.resultPageLimit, 50);
+    assert.equal(tab.resultPageOffset, 50);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("query result export fetches every paginated page", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const preparedOffsets: number[] = [];
+  const executedSqls: string[] = [];
+  const timeoutSecs: unknown[] = [];
+
+  connectionStore.addEphemeralConnection({ ...conn("conn-1"), query_timeout_secs: 600 });
+  const tabId = store.createTab("conn-1", "db");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.lastExecutedSql = "select id from users";
+  tab.resultPageLimit = 100;
+  tab.resultPageOffset = 0;
+  tab.result = {
+    columns: ["id"],
+    rows: [[1]],
+    affected_rows: 0,
+    execution_time_ms: 1,
+    truncated: false,
+    has_more: true,
+  };
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      const offset = Number(body.options.pagination.offset);
+      const limit = Number(body.options.pagination.limit);
+      preparedOffsets.push(offset);
+      return new Response(
+        JSON.stringify({
+          sqlToExecute: `select id from users /* offset:${offset} */`,
+          pageSql: `select id from users /* offset:${offset} */`,
+          pageLimit: limit,
+          pageOffset: offset,
+          useAgentResultSession: false,
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/execute-multi") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      executedSqls.push(body.sql);
+      timeoutSecs.push(body.timeoutSecs);
+      const rows = String(body.sql).includes("offset:0") ? Array.from({ length: 10_000 }, (_, index) => [index + 1]) : [[10_001], [10_002]];
+      return new Response(JSON.stringify([{ columns: ["id"], rows, affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const exported = await store.fetchTabResultForExport(tabId);
+
+    assert.deepEqual(preparedOffsets, [0, 10_000]);
+    assert.deepEqual(executedSqls, ["select id from users /* offset:0 */", "select id from users /* offset:10000 */"]);
+    assert.deepEqual(timeoutSecs, [600, 600]);
+    assert.equal(exported?.rows.length, 10_002);
+    assert.deepEqual(exported?.rows.at(-1), [10_002]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("query result export treats the known query total as a progress estimate", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const preparedOffsets: number[] = [];
+  const executedSqls: string[] = [];
+  const progress: Array<{ rowsExported: number; totalRows: number | null }> = [];
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.lastExecutedSql = "select id from users";
+  tab.resultBaseSql = tab.lastExecutedSql;
+  tab.resultPageLimit = 100;
+  tab.resultPageOffset = 0;
+  tab.resultTotalRowCount = 5;
+  tab.result = {
+    columns: ["id"],
+    rows: [[1], [2], [3], [4], [5]],
+    affected_rows: 0,
+    execution_time_ms: 1,
+    truncated: false,
+    has_more: true,
+  };
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      const offset = Number(body.options.pagination.offset);
+      const limit = Number(body.options.pagination.limit);
+      preparedOffsets.push(offset);
+      return new Response(
+        JSON.stringify({
+          sqlToExecute: `select id from users /* offset:${offset} */`,
+          pageSql: `select id from users /* offset:${offset} */`,
+          pageLimit: limit,
+          pageOffset: offset,
+          useAgentResultSession: false,
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/execute-multi") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      executedSqls.push(body.sql);
+      const rows = String(body.sql).includes("offset:0") ? Array.from({ length: 10_000 }, (_, index) => [index + 1]) : [[10_001], [10_002]];
+      return new Response(JSON.stringify([{ columns: ["id"], rows, affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const exported = await store.fetchTabResultForExport(tabId, (info) => progress.push(info));
+
+    assert.deepEqual(preparedOffsets, [0, 10_000]);
+    assert.deepEqual(executedSqls, ["select id from users /* offset:0 */", "select id from users /* offset:10000 */"]);
+    assert.equal(exported?.rows.length, 10_002);
+    assert.deepEqual(exported?.rows.at(-1), [10_002]);
+    assert.deepEqual(progress, [
+      { rowsExported: 10_000, totalRows: 5 },
+      { rowsExported: 10_002, totalRows: 5 },
+    ]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("jdbc query pagination uses result sessions without capping max rows to one page", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let prepareBody: any;
+  let executeBody: any;
+
+  connectionStore.addEphemeralConnection({
+    ...conn("jdbc-1"),
+    db_type: "jdbc",
+    connection_string: "jdbc:Cache://127.0.0.1:1972/USER",
+    jdbc_driver_class: "com.intersys.jdbc.CacheDriver",
+  });
+  const tabId = store.createTab("jdbc-1", "", "Query", "query", "SQLUser");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      prepareBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(
+        JSON.stringify({
+          sqlToExecute: "SELECT * FROM CT_Loc",
+          pageLimit: 100,
+          pageOffset: 0,
+          useAgentResultSession: true,
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/execute-multi") {
+      executeBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(
+        JSON.stringify([
+          {
+            columns: ["id"],
+            rows: Array.from({ length: 100 }, (_, index) => [index + 1]),
+            affected_rows: 0,
+            execution_time_ms: 1,
+            session_id: "session-1",
+            has_more: true,
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, "SELECT * FROM CT_Loc");
+
+    assert.equal(prepareBody.options.useAgentCursor, true);
+    assert.equal(executeBody.pageSize, 100);
+    assert.equal(executeBody.fetchSize, 100);
+    assert.equal(executeBody.maxRows, undefined);
+    assert.equal(executeBody.clientSessionId, tabId);
+    assert.equal(tab.resultSessionId, "session-1");
+    assert.equal(tab.result?.has_more, true);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("mongo aggregate execution uses editor page size when pagination plan has no limit", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const settingsStore = useSettingsStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let aggregateBody: any;
+
+  settingsStore.updateEditorSettings({ pageSize: 1000 });
+  connectionStore.addEphemeralConnection({
+    ...conn("mongo-1"),
+    db_type: "mongodb",
+    port: 27017,
+  });
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/mongo/aggregate-documents") {
+      aggregateBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(
+        JSON.stringify({
+          documents: Array.from({ length: 811 }, (_, index) => ({ line: index + 1 })),
+          total: 811,
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("mongo-1", "accounting", "Query", "query", "");
+    await store.executeTabSql(tabId, 'db.getCollection("accounting_reconciliations").aggregate([{ "$match": {} }])');
+    const tab = store.tabs.find((item) => item.id === tabId);
+
+    assert.equal(aggregateBody.maxRows, 1000);
+    assert.equal(aggregateBody.collection, "accounting_reconciliations");
+    assert.equal(tab?.result?.rows.length, 811);
+    assert.equal(tab?.result?.truncated, false);
+    assert.equal(tab?.result?.sourceLabel, "accounting.accounting_reconciliations");
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("mongo multi-find results use database and collection source labels", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const collections: string[] = [];
+
+  connectionStore.addEphemeralConnection({
+    ...conn("mongo-1"),
+    db_type: "mongodb",
+    port: 27017,
+  });
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/document-store/find-documents") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      collections.push(body.collection);
+      return new Response(JSON.stringify({ documents: [{ _id: `${body.collection}-1` }], total: 1 }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("mongo-1", "cmdb", "Query", "query", "");
+    const groupedSql = "db.model_field_group.find({})\n\ndb.model_field_info.find({})";
+    await store.executeTabSql(tabId, groupedSql);
+    const tab = store.tabs.find((item) => item.id === tabId);
+
+    assert.deepEqual(collections, ["model_field_group", "model_field_info"]);
+    assert.deepEqual(
+      tab?.results?.map((result) => result.sourceLabel),
+      ["cmdb.model_field_group", "cmdb.model_field_info"],
+    );
+
+    assert.ok(tab);
+    store.setActiveResultIndex(tabId, 1);
+    const sortedSql = "db.model_field_info.find({}).sort({ name: 1 })";
+    await store.executeTabSql(tabId, sortedSql, {
+      resultBaseSql: "db.model_field_info.find({})",
+      resultSortedSql: sortedSql,
+      preserveResultDuringExecution: true,
+      replaceActiveResultInGroup: true,
+    });
+
+    assert.deepEqual(collections, ["model_field_group", "model_field_info", "model_field_info"]);
+    assert.equal(tab.results?.length, 2);
+    assert.equal(tab.activeResultIndex, 1);
+    assert.equal(tab.resultBaseSql, groupedSql);
+    assert.deepEqual(
+      tab.results?.map((result) => result.sourceLabel),
+      ["cmdb.model_field_group", "cmdb.model_field_info"],
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("replacing one paginated SQL result preserves the grouped refresh SQL", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(
+        JSON.stringify({
+          sqlToExecute: body.options.sql,
+          pageSql: body.options.sql,
+          pageLimit: 100,
+          pageOffset: 100,
+          useAgentResultSession: false,
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/execute-multi") {
+      return new Response(JSON.stringify([{ columns: ["id"], rows: [[202]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("conn-1", "app", "Query", "query");
+    const tab = store.tabs.find((item) => item.id === tabId);
+    assert.ok(tab);
+    const groupedSql = "select * from users; select * from orders";
+    const activeSql = "select * from orders";
+    tab.resultBaseSql = groupedSql;
+    tab.results = [
+      { columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, sourceStatement: "select * from users" },
+      { columns: ["id"], rows: [[2]], affected_rows: 0, execution_time_ms: 1, sourceStatement: activeSql },
+    ];
+    tab.activeResultIndex = 1;
+    tab.result = tab.results[1];
+
+    await store.executeTabSql(tabId, activeSql, {
+      resultBaseSql: activeSql,
+      pagination: { limit: 100, offset: 100 },
+      preserveResultDuringExecution: true,
+      preserveTotalRowCountDuringExecution: true,
+      replaceActiveResultInGroup: true,
+    });
+
+    assert.equal(tab.results?.length, 2);
+    assert.equal(tab.activeResultIndex, 1);
+    assert.deepEqual(tab.result?.rows, [[202]]);
+    assert.equal(tab.resultBaseSql, groupedSql);
+    assert.equal(tab.result?.sourceStatement, activeSql);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("mongo createIndex execution uses the dedicated create-index endpoint", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let createIndexBody: any;
+
+  connectionStore.addEphemeralConnection({
+    ...conn("mongo-1"),
+    db_type: "mongodb",
+    port: 27017,
+  });
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/mongo/create-index") {
+      createIndexBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ name: "users_email_unique" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("mongo-1", "accounting", "Query", "query", "");
+    await store.executeTabSql(tabId, 'db.users.createIndex({email: 1}, {unique: true, name: "users_email_unique"})');
+    const tab = store.tabs.find((item) => item.id === tabId);
+
+    assert.deepEqual(createIndexBody, {
+      connectionId: "mongo-1",
+      database: "accounting",
+      collection: "users",
+      keysJson: '{"email": 1}',
+      optionsJson: '{"unique": true, "name": "users_email_unique"}',
+    });
+    assert.deepEqual(tab?.result?.columns, ["name"]);
+    assert.deepEqual(tab?.result?.rows, [["users_email_unique"]]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("mongo dropIndex execution uses the dedicated drop-indexes endpoint", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let dropIndexesBody: any;
+
+  connectionStore.addEphemeralConnection({
+    ...conn("mongo-1"),
+    db_type: "mongodb",
+    port: 27017,
+  });
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/mongo/drop-indexes") {
+      dropIndexesBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ dropped_names: ["users_email_unique"], affected_rows: 1 }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("mongo-1", "accounting", "Query", "query", "");
+    await store.executeTabSql(tabId, 'db.users.dropIndex("users_email_unique")');
+    const tab = store.tabs.find((item) => item.id === tabId);
+
+    assert.deepEqual(dropIndexesBody, {
+      connectionId: "mongo-1",
+      database: "accounting",
+      collection: "users",
+      indexesJson: '"users_email_unique"',
+      single: true,
+    });
+    assert.deepEqual(tab?.result?.columns, ["name"]);
+    assert.deepEqual(tab?.result?.rows, [["users_email_unique"]]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("mongo dropIndexes execution returns dropped index names", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let dropIndexesBody: any;
+
+  connectionStore.addEphemeralConnection({
+    ...conn("mongo-1"),
+    db_type: "mongodb",
+    port: 27017,
+  });
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ sqlToExecute: body.options.sql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/mongo/drop-indexes") {
+      dropIndexesBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify({ dropped_names: ["a_1", "b_1"], affected_rows: 2 }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("mongo-1", "accounting", "Query", "query", "");
+    await store.executeTabSql(tabId, "db.users.dropIndexes()");
+    const tab = store.tabs.find((item) => item.id === tabId);
+
+    assert.deepEqual(dropIndexesBody, {
+      connectionId: "mongo-1",
+      database: "accounting",
+      collection: "users",
+      single: false,
+    });
+    assert.deepEqual(tab?.result?.columns, ["name"]);
+    assert.deepEqual(tab?.result?.rows, [["a_1"], ["b_1"]]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("mongo multi-command execution runs writes sequentially and keeps grouped results", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const insertBodies: any[] = [];
+
+  connectionStore.addEphemeralConnection({
+    ...conn("mongo-1"),
+    db_type: "mongodb",
+    port: 27017,
+  });
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/mongo/insert-documents") {
+      insertBodies.push(JSON.parse(String(init?.body ?? "{}")));
+      return new Response(JSON.stringify({ affected_rows: 1 }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("mongo-1", "accounting", "Query", "query", "");
+    await store.executeTabSql(
+      tabId,
+      `
+        db.users.insertOne({ name: "Ada" });
+        db.users.insertOne({ name: "Grace" });
+      `,
+    );
+    const tab = store.tabs.find((item) => item.id === tabId);
+
+    assert.equal(insertBodies.length, 2);
+    assert.deepEqual(
+      insertBodies.map((body) => ({ database: body.database, collection: body.collection, docsJson: body.docsJson })),
+      [
+        { database: "accounting", collection: "users", docsJson: '{ "name": "Ada" }' },
+        { database: "accounting", collection: "users", docsJson: '{ "name": "Grace" }' },
+      ],
+    );
+    assert.equal(tab?.results?.length, 2);
+    assert.equal(tab?.activeResultIndex, 0);
+    assert.equal(tab?.result?.affected_rows, 1);
+    assert.deepEqual(
+      tab?.results?.map((result) => result.sourceStatement),
+      ['db.users.insertOne({ name: "Ada" })', 'db.users.insertOne({ name: "Grace" })'],
+    );
+    assert.deepEqual(
+      tab?.results?.map((result) => result.sourceLabel),
+      ["accounting.users", "accounting.users"],
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("redis multi-command execution records source statements for each result", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const commandBodies: any[] = [];
+
+  connectionStore.addEphemeralConnection({
+    ...conn("redis-1"),
+    db_type: "redis",
+    port: 6379,
+  });
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/redis/execute-command") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      commandBodies.push(body);
+      if (body.command === "BAD") return new Response("bad command", { status: 500 });
+      return new Response(JSON.stringify({ command: body.command, safety: "allowed", value: body.command === "GET user:1" ? "Ada" : "OK" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("redis-1", "0", "Redis", "query", "");
+    await store.executeTabSql(tabId, "GET user:1\nBAD\nPING");
+    const tab = store.tabs.find((item) => item.id === tabId);
+
+    assert.deepEqual(
+      commandBodies.map((body) => body.command),
+      ["GET user:1", "BAD", "PING"],
+    );
+    assert.deepEqual(
+      tab?.results?.map((result) => result.sourceStatement),
+      ["GET user:1", "BAD", "PING"],
+    );
+    assert.deepEqual(tab?.results?.[1]?.columns, ["Error"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("mongo multi-command execution records source statements for error results", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let insertCount = 0;
+
+  connectionStore.addEphemeralConnection({
+    ...conn("mongo-1"),
+    db_type: "mongodb",
+    port: 27017,
+  });
+
+  globalThis.fetch = withConnectionHealthMock(async (input) => {
+    const url = String(input);
+    if (url === "/api/mongo/insert-documents") {
+      insertCount += 1;
+      if (insertCount === 2) return new Response("duplicate key", { status: 500 });
+      return new Response(JSON.stringify({ affected_rows: 1 }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("mongo-1", "accounting", "Query", "query", "");
+    await store.executeTabSql(tabId, 'db.users.insertOne({ name: "Ada" });\ndb.users.insertOne({ name: "Ada" });');
+    const tab = store.tabs.find((item) => item.id === tabId);
+
+    assert.deepEqual(
+      tab?.results?.map((result) => result.sourceStatement),
+      ['db.users.insertOne({ name: "Ada" })', 'db.users.insertOne({ name: "Ada" })'],
+    );
+    assert.deepEqual(tab?.results?.[1]?.columns, ["Error"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("mongo multi-command execution reconnects before running commands", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const requests: string[] = [];
+
+  connectionStore.addEphemeralConnection({
+    ...conn("mongo-1"),
+    db_type: "mongodb",
+    port: 27017,
+  });
+  connectionStore.connectedIds.delete("mongo-1");
+
+  globalThis.fetch = async (input, init) => {
+    const url = String(input);
+    if (url === "/api/connection/connect") {
+      requests.push(url);
+      return new Response(JSON.stringify("connected"), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/mongo/insert-documents") {
+      requests.push(url);
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      assert.equal(body.database, "accounting");
+      return new Response(JSON.stringify({ affected_rows: 1 }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  };
+
+  try {
+    const tabId = store.createTab("mongo-1", "accounting", "Query", "query", "");
+    await store.executeTabSql(tabId, 'db.users.insertOne({ name: "Ada" })');
+
+    assert.deepEqual(requests, ["/api/connection/connect", "/api/mongo/insert-documents"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("mongo multi-command execution applies use database before later commands", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const insertBodies: any[] = [];
+
+  connectionStore.addEphemeralConnection({
+    ...conn("mongo-1"),
+    db_type: "mongodb",
+    port: 27017,
+  });
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/mongo/insert-documents") {
+      insertBodies.push(JSON.parse(String(init?.body ?? "{}")));
+      return new Response(JSON.stringify({ affected_rows: 1 }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const tabId = store.createTab("mongo-1", "accounting", "Query", "query", "");
+    await store.executeTabSql(
+      tabId,
+      `
+        use archive
+        db.users.insertOne({ name: "Ada" })
+      `,
+    );
+    const tab = store.tabs.find((item) => item.id === tabId);
+
+    assert.equal(insertBodies.length, 1);
+    assert.equal(insertBodies[0]?.database, "archive");
+    assert.equal(tab?.database, "archive");
+    assert.equal(tab?.results?.length, 2);
+    assert.deepEqual(tab?.results?.[0]?.rows, [["switched to db archive"]]);
+    assert.equal(tab?.results?.[0]?.sourceLabel, undefined);
+    assert.equal(tab?.results?.[1]?.sourceLabel, "archive.users");
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("mongo use-only execution updates the tab without reconnecting", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const requests: string[] = [];
+
+  connectionStore.addEphemeralConnection({
+    ...conn("mongo-1"),
+    db_type: "mongodb",
+    port: 27017,
+  });
+  connectionStore.connectedIds.delete("mongo-1");
+
+  globalThis.fetch = async (input) => {
+    requests.push(String(input));
+    return new Response("unexpected request", { status: 500 });
+  };
+
+  try {
+    const tabId = store.createTab("mongo-1", "accounting", "Query", "query", "");
+    await store.executeTabSql(tabId, "use archive");
+    const tab = store.tabs.find((item) => item.id === tabId);
+
+    assert.deepEqual(requests, []);
+    assert.equal(tab?.database, "archive");
+    assert.deepEqual(tab?.result?.rows, [["switched to db archive"]]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("table data export fetches every filtered page", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const buildRequests: unknown[] = [];
+  const executedSqls: string[] = [];
+
+  connectionStore.addEphemeralConnection({ ...conn("conn-1"), db_type: "saphana" });
+  const tabId = store.createTab("conn-1", "db", "users", "data", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.whereInput = "status = 'active'";
+  tab.orderByInput = '"id" DESC';
+  tab.result = {
+    columns: ["id", "status"],
+    rows: [[1, "active"]],
+    affected_rows: 0,
+    execution_time_ms: 1,
+    truncated: false,
+    has_more: true,
+  };
+  tab.tableMeta = {
+    schema: "public",
+    tableName: "users",
+    columns: [
+      {
+        name: "id",
+        data_type: "integer",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: true,
+        extra: null,
+      },
+      {
+        name: "status",
+        data_type: "varchar",
+        is_nullable: true,
+        column_default: null,
+        is_primary_key: false,
+        extra: null,
+      },
+    ],
+    primaryKeys: ["id"],
+  };
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/build-table-select-sql") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      buildRequests.push(body.options);
+      const { limit, offset } = body.options;
+      return new Response(JSON.stringify(`SELECT * FROM "public"."users" WHERE (status = 'active') ORDER BY "id" DESC LIMIT ${limit} OFFSET ${offset ?? 0};`), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/query/execute-multi") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      executedSqls.push(body.sql);
+      const rows = String(body.sql).includes("OFFSET 0")
+        ? Array.from({ length: 10_000 }, (_, index) => [index + 1, "active"])
+        : [
+            [10_001, "active"],
+            [10_002, "active"],
+          ];
+      return new Response(JSON.stringify([{ columns: ["id", "status"], rows, affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const exported = await store.fetchTabResultForExport(tabId);
+
+    assert.deepEqual(
+      buildRequests.map((request) => ({
+        databaseType: (request as any).databaseType,
+        schema: (request as any).schema,
+        tableName: (request as any).tableName,
+        whereInput: (request as any).whereInput,
+        orderBy: (request as any).orderBy,
+        limit: (request as any).limit,
+        offset: (request as any).offset,
+      })),
+      [
+        {
+          databaseType: "saphana",
+          schema: "public",
+          tableName: "users",
+          whereInput: "status = 'active'",
+          orderBy: '"id" DESC',
+          limit: 10_000,
+          offset: 0,
+        },
+        {
+          databaseType: "saphana",
+          schema: "public",
+          tableName: "users",
+          whereInput: "status = 'active'",
+          orderBy: '"id" DESC',
+          limit: 10_000,
+          offset: 10_000,
+        },
+      ],
+    );
+    assert.deepEqual(executedSqls, ['SELECT * FROM "public"."users" WHERE (status = \'active\') ORDER BY "id" DESC LIMIT 10000 OFFSET 0;', 'SELECT * FROM "public"."users" WHERE (status = \'active\') ORDER BY "id" DESC LIMIT 10000 OFFSET 10000;']);
+    assert.equal(exported?.rows.length, 10_002);
+    assert.deepEqual(exported?.rows.at(-1), [10_002, "active"]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("agent-session query export raises maxRows to the configured export limit", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const settingsStore = useSettingsStore();
+  settingsStore.updateEditorSettings({ exportRowLimit: 50_000, exportRowLimitEnabled: true });
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const executeBodies: any[] = [];
+
+  connectionStore.addEphemeralConnection({
+    ...conn("jdbc-1"),
+    db_type: "jdbc",
+    connection_string: "jdbc:sqlserver://127.0.0.1:1433;databaseName=db",
+    jdbc_driver_class: "com.microsoft.sqlserver.jdbc.SQLServerDriver",
+  });
+  const tabId = store.createTab("jdbc-1", "db", "Query", "query", "dbo");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.lastExecutedSql = "SELECT * FROM big_table";
+  tab.result = {
+    columns: ["id"],
+    rows: [[1]],
+    affected_rows: 0,
+    execution_time_ms: 1,
+    truncated: false,
+    has_more: true,
+  };
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      return new Response(JSON.stringify({ sqlToExecute: "SELECT * FROM big_table", pageLimit: 10_000, pageOffset: 0, useAgentResultSession: true }), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/query/execute-multi") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      executeBodies.push(body);
+      const page = executeBodies.length;
+      return new Response(
+        JSON.stringify([
+          {
+            columns: ["id"],
+            rows: Array.from({ length: 10_000 }, (_, index) => [(page - 1) * 10_000 + index + 1]),
+            affected_rows: 0,
+            execution_time_ms: 1,
+            session_id: "session-1",
+            has_more: page < 2,
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/close-session") {
+      return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/query/close-client-session") {
+      return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const exported = await store.fetchTabResultForExport(tabId);
+
+    // Every agent-session execute call must carry the configured export limit
+    // as maxRows so the agent's cumulative cap doesn't truncate at 10000.
+    assert.ok(executeBodies.length >= 2);
+    for (const body of executeBodies) {
+      assert.equal(body.maxRows, 50_000);
+    }
+    assert.equal(exported?.rows.length, 20_000);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("query export stops at the configured row limit when enabled", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const settingsStore = useSettingsStore();
+  settingsStore.updateEditorSettings({ exportRowLimit: 15_000, exportRowLimitEnabled: true });
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  const planLimits: number[] = [];
+  const executeMaxRows: number[] = [];
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "analytics", "Query", "query", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.lastExecutedSql = "SELECT * FROM events";
+  tab.result = {
+    columns: ["id"],
+    rows: [[1]],
+    affected_rows: 0,
+    execution_time_ms: 1,
+    truncated: false,
+    has_more: true,
+  };
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      const pagination = body.options.pagination;
+      planLimits.push(pagination.limit);
+      return new Response(
+        JSON.stringify({
+          sqlToExecute: `SELECT * FROM events LIMIT ${pagination.limit} OFFSET ${pagination.offset}`,
+          pageLimit: pagination.limit,
+          pageOffset: pagination.offset,
+          useAgentResultSession: false,
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/execute-multi") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      executeMaxRows.push(body.maxRows);
+      const start = executeMaxRows.length === 1 ? 1 : 10_001;
+      return new Response(
+        JSON.stringify([
+          {
+            columns: ["id"],
+            rows: Array.from({ length: body.maxRows }, (_, index) => [start + index]),
+            affected_rows: 0,
+            execution_time_ms: 1,
+            has_more: true,
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/close-client-session") {
+      return new Response(JSON.stringify(true), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    const exported = await store.fetchTabResultForExport(tabId);
+
+    assert.deepEqual(planLimits, [10_000, 5_000]);
+    assert.deepEqual(executeMaxRows, [10_000, 5_000]);
+    assert.equal(exported?.rows.length, 15_000);
+    assert.deepEqual(exported?.rows.at(-1), [15_000]);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("buildQueryResultExportRequest uses sorted SQL and independent row-limit settings", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const settingsStore = useSettingsStore();
+  settingsStore.updateEditorSettings({
+    exportBatchSize: 2500,
+    exportRowLimit: 200000,
+    exportRowLimitEnabled: false,
+    queryExportKeysetOptimizationEnabled: false,
+  });
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "analytics", "Query", "query", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.sql = "SELECT * FROM events";
+  tab.lastExecutedSql = "SELECT * FROM events";
+  tab.resultBaseSql = "SELECT * FROM events";
+  tab.resultSortedSql = "SELECT * FROM (SELECT * FROM events) t ORDER BY created_at DESC";
+  tab.resultTotalRowCount = 123456;
+  tab.result = {
+    columns: ["id", "created_at"],
+    rows: [[1, "2026-06-24"]],
+    affected_rows: 0,
+    execution_time_ms: 1,
+  };
+
+  globalThis.fetch = withConnectionHealthMock(async () => new Response("unexpected request", { status: 500 }));
+
+  try {
+    const request = await store.buildQueryResultExportRequest(tabId, {
+      exportId: "export-1",
+      filePath: "C:\\tmp\\events.csv",
+      format: "csv",
+    });
+
+    assert.equal(request?.exportId, "export-1");
+    assert.equal(request?.connectionId, "conn-1");
+    assert.equal(request?.database, "analytics");
+    assert.equal(request?.schema, "public");
+    assert.equal(request?.sql, "SELECT * FROM (SELECT * FROM events) t ORDER BY created_at DESC");
+    assert.equal(request?.queryBaseSql, "SELECT * FROM events");
+    assert.equal(request?.databaseType, "postgres");
+    assert.equal(request?.useAgentCursor, false);
+    assert.equal(request?.filePath, "C:\\tmp\\events.csv");
+    assert.equal(request?.format, "csv");
+    assert.equal(request?.pageSize, 2500);
+    assert.equal(request?.rowLimit, null);
+    assert.equal(request?.totalRows, 123456);
+    assert.equal(request?.keysetOptimizationEnabled, false);
+    assert.equal(request?.clientSessionId, `${tabId}:export`);
+    assert.match(request?.executionId ?? "", /^[0-9a-f-]{36}$/i);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("buildQueryResultExportRequest uses exportRowLimit when enabled", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const settingsStore = useSettingsStore();
+  settingsStore.updateEditorSettings({ exportBatchSize: 2500, exportRowLimit: 200000, exportRowLimitEnabled: true });
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "analytics", "Query", "query", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.lastExecutedSql = "SELECT * FROM events";
+  tab.result = {
+    columns: ["id"],
+    rows: [[1]],
+    affected_rows: 0,
+    execution_time_ms: 1,
+  };
+
+  globalThis.fetch = withConnectionHealthMock(async () => new Response("unexpected request", { status: 500 }));
+
+  try {
+    const request = await store.buildQueryResultExportRequest(tabId, {
+      exportId: "export-2",
+      filePath: "C:\\tmp\\events.xlsx",
+      format: "xlsx",
+    });
+
+    assert.equal(request?.pageSize, 2500);
+    assert.equal(request?.rowLimit, 200000);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("buildQueryResultExportRequest caps progress total when export row limit is enabled", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const settingsStore = useSettingsStore();
+  settingsStore.updateEditorSettings({ exportBatchSize: 2500, exportRowLimit: 100000, exportRowLimitEnabled: true });
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "analytics", "Query", "query", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.lastExecutedSql = "SELECT * FROM events";
+  tab.resultTotalRowCount = 120000;
+  tab.result = {
+    columns: ["id"],
+    rows: [[1]],
+    affected_rows: 0,
+    execution_time_ms: 1,
+  };
+
+  globalThis.fetch = withConnectionHealthMock(async () => new Response("unexpected request", { status: 500 }));
+
+  try {
+    const request = await store.buildQueryResultExportRequest(tabId, {
+      exportId: "export-3",
+      filePath: "C:\\tmp\\events.csv",
+      format: "csv",
+    });
+
+    assert.equal(request?.rowLimit, 100000);
+    assert.equal(request?.totalRows, 100000);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("query execution finishes without waiting for metadata analysis", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "Query");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  let resolveMetadata: ((value: Response) => void) | undefined;
+  globalThis.fetch = withConnectionHealthMock(async (input) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      return new Response(JSON.stringify({ sqlToExecute: "select id from users", useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      return new Response(JSON.stringify([{ columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Promise<Response>((resolve) => {
+        resolveMetadata = resolve;
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, "select id from users");
+
+    assert.equal(tab.isExecuting, false);
+    assert.equal(tab.executionId, undefined);
+    assert.deepEqual(tab.result?.columns, ["id"]);
+
+    resolveMetadata?.(
+      new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      }),
+    );
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("query execution is scoped to the tab client session", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "Query");
+  let executeBody: any;
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      return new Response(JSON.stringify({ sqlToExecute: "select 1", useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      executeBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify([{ columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, "select 1");
+
+    assert.equal(executeBody.clientSessionId, tabId);
+    assert.equal(executeBody.timeoutSecs, 30);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("Spark query execution applies the selected database as schema context", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(sparkConn("spark-1"));
+  const tabId = store.createTab("spark-1", "ai_test", "Query");
+  let executeBody: any;
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      return new Response(JSON.stringify({ sqlToExecute: "select * from user_orders_v2", useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      executeBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify([{ columns: ["order_id"], rows: [["ORD001"]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, "select * from user_orders_v2");
+
+    assert.equal(executeBody.database, "ai_test");
+    assert.equal(executeBody.schema, "ai_test");
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("data tab execution uses a tab-scoped client session", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "users", "data", "public");
+  let executeBody: any;
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/execute-multi") {
+      executeBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify([{ columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, "select * from users");
+
+    assert.equal(executeBody.clientSessionId, tabId);
+    assert.equal(executeBody.timeoutSecs, 30);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("closing a data tab releases its tab-scoped client session", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "users", "data", "public");
+  let executeBody: any;
+  const closedSessions: any[] = [];
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/execute-multi") {
+      executeBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Response(JSON.stringify([{ columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/close-client-session") {
+      closedSessions.push(JSON.parse(String(init?.body ?? "{}")));
+      return new Response(JSON.stringify(true), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, "select * from users");
+    assert.equal(executeBody.clientSessionId, tabId);
+
+    store.closeTab(tabId, { force: true });
+
+    // closeClientConnectionSession is fire-and-forget; wait for the request to land.
+    await waitFor(() => closedSessions.some((body) => body.clientSessionId === tabId));
+    assert.ok(
+      closedSessions.some((body) => body.clientSessionId === tabId && body.connectionId === "conn-1"),
+      `expected close-client-session for tab session, got ${JSON.stringify(closedSessions)}`,
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("query execution keeps automatically counting total rows in the background", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const settingsStore = useSettingsStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  settingsStore.updateEditorSettings({ autoCalculateTotalRows: true });
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "Query", "query", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+
+  let resolveCount: ((value: Response) => void) | undefined;
+  let countBody: any;
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      return new Response(
+        JSON.stringify({
+          sqlToExecute: "select id from users limit 100",
+          pageSql: "select id from users limit 100",
+          pageLimit: 100,
+          pageOffset: 0,
+          countSql: "select count(*) from users",
+          useAgentResultSession: false,
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/execute-multi") {
+      return new Response(
+        JSON.stringify([
+          {
+            columns: ["id"],
+            rows: Array.from({ length: 100 }, (_, index) => [index + 1]),
+            affected_rows: 0,
+            execution_time_ms: 1,
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/execute") {
+      countBody = JSON.parse(String(init?.body ?? "{}"));
+      return new Promise<Response>((resolve) => {
+        resolveCount = resolve;
+      });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, "select id from users");
+
+    assert.equal(tab.executionId, undefined);
+    assert.equal(tab.resultTotalRowCount, undefined);
+    assert.equal(tab.resultTotalRowCountLoading, true);
+    assert.equal(countBody.sql, "select count(*) from users");
+    assert.equal(countBody.schema, "public");
+
+    resolveCount?.(
+      new Response(
+        JSON.stringify({
+          columns: ["count"],
+          rows: [[250]],
+          affected_rows: 0,
+          execution_time_ms: 1,
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      ),
+    );
+    await waitFor(() => tab.resultTotalRowCount === 250);
+    assert.equal(tab.resultTotalRowCountLoading, false);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("paginated query execution keeps the previous total while refreshing it in the background", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const settingsStore = useSettingsStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  settingsStore.updateEditorSettings({ autoCalculateTotalRows: true });
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "Query", "query", "public");
+  const tab = store.tabs.find((item) => item.id === tabId);
+  assert.ok(tab);
+  tab.resultTotalRowCount = 250;
+
+  let resolveCount: ((value: Response) => void) | undefined;
+  globalThis.fetch = withConnectionHealthMock(async (input) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      return new Response(
+        JSON.stringify({
+          sqlToExecute: "select id from users limit 100 offset 100",
+          pageSql: "select id from users limit 100 offset 100",
+          pageLimit: 100,
+          pageOffset: 100,
+          countSql: "select count(*) from users",
+          useAgentResultSession: false,
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/execute-multi") {
+      return new Response(
+        JSON.stringify([
+          {
+            columns: ["id"],
+            rows: Array.from({ length: 100 }, (_, index) => [index + 101]),
+            affected_rows: 0,
+            execution_time_ms: 1,
+          },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/execute") {
+      return new Promise<Response>((resolve) => {
+        resolveCount = resolve;
+      });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, "select id from users", {
+      pagination: { limit: 100, offset: 100 },
+      preserveResultDuringExecution: true,
+      preserveTotalRowCountDuringExecution: true,
+    });
+
+    assert.equal(tab.resultTotalRowCount, 250);
+    assert.equal(tab.resultTotalRowCountLoading, true);
+
+    resolveCount?.(
+      new Response(
+        JSON.stringify({
+          columns: ["count"],
+          rows: [[275]],
+          affected_rows: 0,
+          execution_time_ms: 1,
+        }),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      ),
+    );
+    await waitFor(() => tab.resultTotalRowCount === 275);
+    assert.equal(tab.resultTotalRowCountLoading, false);
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("multi statement execution shows the first result set by default", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+
+  connectionStore.addEphemeralConnection(conn("conn-1"));
+  const tabId = store.createTab("conn-1", "db", "Query");
+
+  globalThis.fetch = withConnectionHealthMock(async (input) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      return new Response(JSON.stringify({ sqlToExecute: "set @id = 1; select @id", useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      return new Response(
+        JSON.stringify([
+          { columns: [], rows: [], affected_rows: 0, execution_time_ms: 1 },
+          { columns: ["@id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+        ]),
+        { status: 200, headers: { "Content-Type": "application/json" } },
+      );
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, "set @id = 1; select @id");
+
+    const tab = store.tabs.find((item) => item.id === tabId);
+    assert.equal(tab?.activeResultIndex, 1);
+    assert.deepEqual(tab?.result?.columns, ["@id"]);
+    assert.deepEqual(tab?.result?.rows, [[1]]);
+    assert.equal(isReactive(tab?.result?.rows), false);
+    assert.equal(isReactive(tab?.result?.rows[0]), false);
+    assert.equal(
+      tab?.results?.every((result) => !isReactive(result.rows)),
+      true,
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("query results keep readable table source labels with active database context", async () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  const connectionStore = useConnectionStore();
+  const store = useQueryStore();
+  const originalFetch = globalThis.fetch;
+  let currentSql = "";
+
+  connectionStore.addEphemeralConnection({ ...conn("conn-1"), database: "aaa" });
+  const tabId = store.createTab("conn-1", "db", "Query");
+  const defaultDatabaseTabId = store.createTab("conn-1", "", "Default database query");
+
+  globalThis.fetch = withConnectionHealthMock(async (input, init) => {
+    const url = String(input);
+    if (url === "/api/query/prepare-pagination-plan") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      currentSql = body.options.sql;
+      return new Response(JSON.stringify({ sqlToExecute: currentSql, useAgentResultSession: false }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/query/execute-multi") {
+      const results =
+        currentSql === "select * from users; select * from orders"
+          ? [
+              { columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+              { columns: ["id"], rows: [[2]], affected_rows: 0, execution_time_ms: 1 },
+            ]
+          : currentSql === "SELECT *\nFROM apis AS ap\nLIMIT 10;\n\nSELECT *\nFROM menus AS mn\nLIMIT 10;"
+            ? [
+                { columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+                { columns: ["id"], rows: [[2]], affected_rows: 0, execution_time_ms: 1 },
+              ]
+            : currentSql === "select * from public.users"
+              ? [{ columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }]
+              : currentSql === "select u.id from users u join orders o on o.user_id = u.id"
+                ? [{ columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }]
+                : [
+                    { columns: [], rows: [], affected_rows: 1, execution_time_ms: 1 },
+                    { columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 },
+                  ];
+      return new Response(JSON.stringify(results), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/query/analyze-editability") {
+      return new Response(JSON.stringify({ editable: false, reason: "complex-source" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    return new Response("unexpected request", { status: 500 });
+  });
+
+  try {
+    await store.executeTabSql(tabId, "select * from users; select * from orders");
+    let tab = store.tabs.find((item) => item.id === tabId);
+    assert.deepEqual(
+      tab?.results?.map((result) => result.sourceLabel),
+      ["db.users", "db.orders"],
+    );
+    assert.deepEqual(
+      tab?.results?.map((result) => result.sourceStatement),
+      ["select * from users", "select * from orders"],
+    );
+    assert.equal(resultSqlForGrid(tab!), "select * from users");
+    store.setActiveResultIndex(tabId, 1);
+    tab = store.tabs.find((item) => item.id === tabId);
+    assert.equal(resultSqlForGrid(tab!), "select * from orders");
+
+    await store.executeTabSql(tabId, "select * from users; select * from orders", {
+      resultBaseSql: "select * from users; select * from orders",
+      preserveResultDuringExecution: true,
+      preserveActiveResultIndex: true,
+    });
+    tab = store.tabs.find((item) => item.id === tabId);
+    assert.equal(tab?.activeResultIndex, 1);
+    assert.equal(resultSqlForGrid(tab!), "select * from orders");
+
+    await store.executeTabSql(defaultDatabaseTabId, "SELECT *\nFROM apis AS ap\nLIMIT 10;\n\nSELECT *\nFROM menus AS mn\nLIMIT 10;");
+    tab = store.tabs.find((item) => item.id === defaultDatabaseTabId);
+    assert.deepEqual(
+      tab?.results?.map((result) => result.sourceLabel),
+      ["aaa.apis", "aaa.menus"],
+    );
+
+    await store.executeTabSql(tabId, "select * from public.users");
+    tab = store.tabs.find((item) => item.id === tabId);
+    assert.equal(tab?.result?.sourceLabel, "public.users");
+
+    await store.executeTabSql(tabId, "select u.id from users u join orders o on o.user_id = u.id");
+    tab = store.tabs.find((item) => item.id === tabId);
+    assert.equal(tab?.result?.sourceLabel, "db.users");
+    assert.equal(tab?.result?.sourceStatement, "select u.id from users u join orders o on o.user_id = u.id");
+
+    await store.executeTabSql(tabId, "update users set active = true; select * from users");
+    tab = store.tabs.find((item) => item.id === tabId);
+    assert.equal(tab?.results?.[0]?.sourceLabel, "db.users");
+    assert.equal(tab?.results?.[0]?.sourceStatement, "update users set active = true");
+    assert.equal(tab?.results?.[1]?.sourceLabel, "db.users");
+    assert.equal(tab?.results?.[1]?.sourceStatement, "select * from users");
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("tab reuse is scoped by mode and schema instead of title alone", () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    setActivePinia(createPinia());
+    const store = useQueryStore();
+
+    const dataTabId = store.createTab("conn-1", "db", "users", "data", "public");
+    const sourceTabId = store.createTab("conn-1", "db", "users", "query", "public");
+    const otherSchemaTabId = store.createTab("conn-1", "db", "users", "data", "audit");
+    const reusedDataTabId = store.createTab("conn-1", "db", "users", "data", "public");
+
+    assert.notEqual(sourceTabId, dataTabId);
+    assert.notEqual(otherSchemaTabId, dataTabId);
+    assert.equal(reusedDataTabId, dataTabId);
+    assert.equal(store.tabs.length, 3);
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("new table structure tabs can open multiple drafts while existing tables still reuse tabs", () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    setActivePinia(createPinia());
+    const store = useQueryStore();
+
+    const firstDraftId = store.openTableStructure("conn-1", "db", "public", "");
+    const secondDraftId = store.openTableStructure("conn-1", "db", "public", "");
+    const firstEditId = store.openTableStructure("conn-1", "db", "public", "users");
+    const secondEditId = store.openTableStructure("conn-1", "db", "public", "users");
+
+    assert.notEqual(secondDraftId, firstDraftId);
+    assert.equal(secondEditId, firstEditId);
+    assert.equal(store.tabs.length, 3);
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("reopening table structure tabs records the requested initial tab", () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    setActivePinia(createPinia());
+    const store = useQueryStore();
+
+    const structureId = store.openTableStructure("conn-1", "db", "public", "users", "indexes", { kind: "index", name: "idx_users_email" });
+    const firstTab = store.tabs.find((item) => item.id === structureId);
+
+    assert.equal(firstTab?.structureInitialTab, "indexes");
+    assert.equal(firstTab?.structureInitialTabRequestId, 1);
+    assert.deepEqual(firstTab?.structureInitialTarget, { kind: "index", name: "idx_users_email" });
+
+    const reusedStructureId = store.openTableStructure("conn-1", "db", "public", "users", "columns", { kind: "column", name: "email" });
+    const reusedTab = store.tabs.find((item) => item.id === reusedStructureId);
+
+    assert.equal(reusedStructureId, structureId);
+    assert.equal(reusedTab?.structureInitialTab, "columns");
+    assert.equal(reusedTab?.structureInitialTabRequestId, 2);
+    assert.deepEqual(reusedTab?.structureInitialTarget, { kind: "column", name: "email" });
+    assert.equal(store.activeTabId, structureId);
+
+    store.openTableStructure("conn-1", "db", "public", "users", "foreignKeys");
+    assert.equal(reusedTab?.structureInitialTab, "foreignKeys");
+    assert.equal(reusedTab?.structureInitialTabRequestId, 3);
+    assert.equal(reusedTab?.structureInitialTarget, undefined);
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("table structure refresh versions are scoped by table target", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+
+  assert.equal(store.tableStructureRefreshVersion("conn-1", "db", "public", "users"), 0);
+
+  store.invalidateTableStructure("conn-1", "db", "public", "users");
+  store.invalidateTableStructure("conn-1", "db", "public", "users");
+  store.invalidateTableStructure("conn-1", "db", undefined, "users");
+
+  assert.equal(store.tableStructureRefreshVersion("conn-1", "db", "public", "users"), 2);
+  assert.equal(store.tableStructureRefreshVersion("conn-1", "db", undefined, "users"), 1);
+  assert.equal(store.tableStructureRefreshVersion("conn-1", "db", "public", "orders"), 0);
+});
+
+test("duplicating a table structure tab clones its unsaved draft", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+
+  const tabId = store.openTableStructure("conn-1", "db", "public", "users");
+  const tab = store.tabs.find((item) => item.id === tabId)!;
+  tab.structureDraft = {
+    activeTab: "columns",
+    newTableName: "",
+    tableComment: "",
+    originalTableComment: "",
+    columns: [
+      {
+        id: "new:1",
+        name: "draft_name",
+        dataType: "varchar(255)",
+        isNullable: true,
+        defaultValue: "",
+        comment: "",
+        isPrimaryKey: false,
+        extra: {},
+        markedForDrop: false,
+      },
+    ],
+    indexes: [],
+    foreignKeys: [],
+    triggers: [],
+    initialized: true,
+  };
+
+  store.duplicateTab(tabId);
+
+  const copy = store.tabs.find((item) => item.id !== tabId && item.mode === "structure")!;
+  assert.deepEqual(copy.structureDraft, tab.structureDraft);
+  copy.structureDraft!.columns[0]!.name = "copy_only";
+  assert.equal(tab.structureDraft.columns[0]!.name, "draft_name");
+});
+
+test("reorderTab keeps pinned tabs before unpinned tabs after reorder", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+
+  const tabA = store.createTab("conn-1", "db", "A", "query");
+  const tabB = store.createTab("conn-1", "db", "B", "query");
+  const tabC = store.createTab("conn-1", "db", "C", "query");
+  const tabD = store.createTab("conn-1", "db", "D", "query");
+
+  store.tabs[0].pinned = false;
+  store.tabs[1].pinned = true;
+  store.tabs[2].pinned = false;
+  store.tabs[3].pinned = true;
+
+  // Force store to apply pinned ordering
+  store.togglePinnedTab(tabB);
+  store.togglePinnedTab(tabB);
+  // Now tabs: D(b), B(b), A, C
+
+  // Try dragging unpinned tab A before pinned tab B
+  store.reorderTab(tabA, tabB, "before");
+  const idsAfter = store.tabs.map((t) => t.id);
+  const pinnedIndices = store.tabs.map((t, i) => ({ pinned: t.pinned, i })).filter((t) => t.pinned);
+  const unpinnedIndices = store.tabs.map((t, i) => ({ pinned: t.pinned, i })).filter((t) => !t.pinned);
+
+  // All pinned tabs should come before any unpinned tab
+  assert.equal(Math.max(...pinnedIndices.map((t) => t.i)) < Math.min(...unpinnedIndices.map((t) => t.i)), true);
+});
+
+test("reorderTab preserves relative order within pinned group", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+
+  const tabA = store.createTab("conn-1", "db", "A", "query");
+  const tabB = store.createTab("conn-1", "db", "B", "query");
+  const tabC = store.createTab("conn-1", "db", "C", "query");
+  const tabD = store.createTab("conn-1", "db", "D", "query");
+  const tabE = store.createTab("conn-1", "db", "E", "query");
+
+  // Pin A, B, C; leave D, E unpinned
+  store.togglePinnedTab(tabA);
+  // toggle so orderPinnedFirst runs: [A, B, C, D, E]
+  store.togglePinnedTab(tabB);
+  // [A, B, C, D, E]
+  assert.equal(store.tabs.filter((t) => t.pinned).length, 2);
+
+  store.togglePinnedTab(tabC);
+  // pinned = [A, B, C], unpinned = [D, E]
+  assert.equal(store.tabs.filter((t) => t.pinned).length, 3);
+
+  // Now: A, B, C (pinned), D, E (unpinned)
+  // Drag C before A (within pinned group)
+  store.reorderTab(tabC, tabA, "before");
+  // After orderPinnedFirst: C, A, B, D, E
+  const ids = store.tabs.map((t) => t.id);
+  assert.equal(ids[0], tabC, "C should be first pinned tab");
+  assert.equal(ids[1], tabA, "A should be second pinned tab");
+  assert.equal(ids[2], tabB, "B should be third pinned tab");
+  assert.equal(ids[3], tabD, "D should be first unpinned");
+  assert.equal(ids[4], tabE, "E should be second unpinned");
+});
+
+test("reorderTab preserves relative order within unpinned group", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+
+  const tabA = store.createTab("conn-1", "db", "A", "query");
+  const tabB = store.createTab("conn-1", "db", "B", "query");
+  const tabC = store.createTab("conn-1", "db", "C", "query");
+  const tabD = store.createTab("conn-1", "db", "D", "query");
+
+  store.tabs[0].pinned = true;
+  store.tabs[1].pinned = false;
+  store.tabs[2].pinned = false;
+  store.tabs[3].pinned = false;
+
+  store.togglePinnedTab(tabA);
+  store.togglePinnedTab(tabA);
+
+  // Now tabs: A(pinned), B, C, D(unpinned)
+  // Drag D before B
+  store.reorderTab(tabD, tabB, "before");
+  // After orderPinnedFirst: A, D, B, C
+  const ids = store.tabs.map((t) => t.id);
+  assert.equal(ids[0], tabA, "A should stay pinned");
+  assert.equal(ids[1], tabD, "D should be first unpinned");
+  assert.equal(ids[2], tabB, "B should be second unpinned");
+  assert.equal(ids[3], tabC, "C should be last unpinned");
+});
+
+test("reorderTab with after position places tab correctly", () => {
+  setActivePinia(createPinia());
+  const store = useQueryStore();
+
+  const tabA = store.createTab("conn-1", "db", "A", "query");
+  const tabB = store.createTab("conn-1", "db", "B", "query");
+  const tabC = store.createTab("conn-1", "db", "C", "query");
+
+  // Drag A after C
+  store.reorderTab(tabA, tabC, "after");
+  assert.deepEqual(
+    store.tabs.map((t) => t.id),
+    [tabB, tabC, tabA],
+  );
+});
diff --git a/packages/app-tests/queryTimeout.test.ts b/packages/app-tests/queryTimeout.test.ts
new file mode 100644
index 0000000..83b6926
--- /dev/null
+++ b/packages/app-tests/queryTimeout.test.ts
@@ -0,0 +1,19 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { DEFAULT_QUERY_TIMEOUT_SECS, frontendQueryTimeoutSecsForSql, queryTimeoutSecsForConnection } from "../../apps/desktop/src/lib/sql/queryTimeout.ts";
+
+test("queryTimeoutSecsForConnection falls back to the default timeout", () => {
+  assert.equal(DEFAULT_QUERY_TIMEOUT_SECS, 60);
+  assert.equal(queryTimeoutSecsForConnection(undefined), DEFAULT_QUERY_TIMEOUT_SECS);
+  assert.equal(queryTimeoutSecsForConnection({ query_timeout_secs: -1 }), DEFAULT_QUERY_TIMEOUT_SECS);
+  assert.equal(queryTimeoutSecsForConnection({ query_timeout_secs: 0 }), 0);
+  assert.equal(queryTimeoutSecsForConnection({ query_timeout_secs: 15 }), 15);
+});
+
+test("frontend query timeout scales with SQL statement count", () => {
+  assert.equal(frontendQueryTimeoutSecsForSql("INSERT INTO users VALUES (1)", "mysql", 30), 60);
+  assert.equal(frontendQueryTimeoutSecsForSql("INSERT INTO users VALUES (1); INSERT INTO users VALUES (2);", "mysql", 30), 120);
+  assert.equal(frontendQueryTimeoutSecsForSql("INSERT INTO users VALUES (1); INSERT INTO users VALUES (2); INSERT INTO users VALUES (3);", "mysql", 10), 180);
+  assert.equal(frontendQueryTimeoutSecsForSql("/* prep */\nINSERT INTO users VALUES (1);\n-- keep batching\nINSERT INTO users VALUES (2);", "mysql", 30), 120);
+  assert.equal(frontendQueryTimeoutSecsForSql("INSERT INTO users VALUES (1); INSERT INTO users VALUES (2);", "mysql", 0), 0);
+});
diff --git a/packages/app-tests/redisCommandSafety.test.ts b/packages/app-tests/redisCommandSafety.test.ts
new file mode 100644
index 0000000..0b4e8b7
--- /dev/null
+++ b/packages/app-tests/redisCommandSafety.test.ts
@@ -0,0 +1,13 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { classifyRedisCommandSafety } from "../../apps/desktop/src/lib/redis/redisCommandSafety.ts";
+
+test("classifies normal Redis writes separately from destructive commands", () => {
+  assert.equal(classifyRedisCommandSafety("SET session:1 value"), "write");
+  assert.equal(classifyRedisCommandSafety("HSET hash field value"), "write");
+  assert.equal(classifyRedisCommandSafety("LPUSH queue value"), "write");
+  assert.equal(classifyRedisCommandSafety("DEL session:1"), "confirm");
+  assert.equal(classifyRedisCommandSafety("FLUSHDB"), "confirm");
+  assert.equal(classifyRedisCommandSafety("KEYS *"), "blocked");
+  assert.equal(classifyRedisCommandSafety("GET session:1"), "allowed");
+});
diff --git a/packages/app-tests/redisCommandSession.test.ts b/packages/app-tests/redisCommandSession.test.ts
new file mode 100644
index 0000000..1c295f2
--- /dev/null
+++ b/packages/app-tests/redisCommandSession.test.ts
@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { isRedisClearScreenCommand, nextRedisCommandDb, redisKeyTextToRaw } from "../../apps/desktop/src/lib/redis/redisCommandSession.ts";
+
+test("keeps Redis command session database after SELECT succeeds", () => {
+  assert.equal(nextRedisCommandDb(3, "SELECT 0", "OK"), 0);
+  assert.equal(nextRedisCommandDb(0, "select 12", "OK"), 12);
+});
+
+test("does not change Redis command session database for failed or non-select commands", () => {
+  assert.equal(nextRedisCommandDb(3, "SELECT nope", "OK"), 3);
+  assert.equal(nextRedisCommandDb(3, "SELECT 2", "ERR invalid DB index"), 3);
+  assert.equal(nextRedisCommandDb(3, "HGET farmer:1 balance", "42"), 3);
+});
+
+test("recognizes local Redis terminal clear commands", () => {
+  assert.equal(isRedisClearScreenCommand("clear"), true);
+  assert.equal(isRedisClearScreenCommand(" CLEAR "), true);
+  assert.equal(isRedisClearScreenCommand("cls"), true);
+  assert.equal(isRedisClearScreenCommand("clear key"), false);
+  assert.equal(isRedisClearScreenCommand("DEL clear"), false);
+});
+
+test("encodes Redis key text as the raw base64 transport value", () => {
+  assert.equal(redisKeyTextToRaw("user:1"), "dXNlcjox");
+  assert.equal(redisKeyTextToRaw("用户:配置"), "55So5oi3OumFjee9rg==");
+});
diff --git a/packages/app-tests/redisCommandTable.test.ts b/packages/app-tests/redisCommandTable.test.ts
new file mode 100644
index 0000000..8be1ef3
--- /dev/null
+++ b/packages/app-tests/redisCommandTable.test.ts
@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { isRedisMutatingCommand, resolveRedisCommandSpec } from "../../apps/desktop/src/lib/redis/redisCommandTable.ts";
+
+test("write commands are flagged as mutating", () => {
+  assert.equal(isRedisMutatingCommand("SET foo bar"), true);
+  assert.equal(isRedisMutatingCommand("DEL foo"), true);
+  assert.equal(isRedisMutatingCommand("HSET h k v"), true);
+  assert.equal(isRedisMutatingCommand("LPUSH list a"), true);
+  assert.equal(isRedisMutatingCommand("INCR counter"), true);
+  assert.equal(isRedisMutatingCommand("EXPIRE foo 60"), true);
+  assert.equal(isRedisMutatingCommand("RENAME a b"), true);
+});
+
+test("subcommand mutations are detected via MAIN SUB spec", () => {
+  assert.equal(isRedisMutatingCommand("XGROUP CREATE s g 0"), true);
+  assert.equal(isRedisMutatingCommand("XADD stream * field value"), true);
+  assert.equal(isRedisMutatingCommand("CLUSTER RESET HARD"), true);
+});
+
+test("destructive/blocked commands are flagged as mutating", () => {
+  assert.equal(isRedisMutatingCommand("FLUSHDB"), true);
+  assert.equal(isRedisMutatingCommand("FLUSHALL"), true);
+});
+
+test("read-only commands are not mutating", () => {
+  assert.equal(isRedisMutatingCommand("GET foo"), false);
+  assert.equal(isRedisMutatingCommand("LRANGE list 0 -1"), false);
+  assert.equal(isRedisMutatingCommand("HGETALL h"), false);
+  assert.equal(isRedisMutatingCommand("KEYS *"), false);
+  assert.equal(isRedisMutatingCommand("TYPE foo"), false);
+  assert.equal(isRedisMutatingCommand("SCAN 0"), false);
+  assert.equal(isRedisMutatingCommand("SELECT 1"), false);
+  assert.equal(isRedisMutatingCommand("INFO"), false);
+});
+
+test("read-only subcommands are not mutating", () => {
+  // XLEN is a read on a stream; XINFO ... is read
+  assert.equal(isRedisMutatingCommand("XLEN stream"), false);
+});
+
+test("case-insensitive and quoted command tokens", () => {
+  assert.equal(isRedisMutatingCommand("set foo bar"), true);
+  assert.equal(isRedisMutatingCommand("del foo"), true);
+  assert.equal(isRedisMutatingCommand('get "weird key"'), false);
+});
+
+test("unknown / empty commands are treated as non-mutating (no cache thrash)", () => {
+  assert.equal(isRedisMutatingCommand(""), false);
+  assert.equal(isRedisMutatingCommand("NOTACMD x y"), false);
+});
+
+test("resolveRedisCommandSpec resolves subcommand then main", () => {
+  const sub = resolveRedisCommandSpec(["XGROUP", "CREATE"]);
+  assert.ok(sub);
+  assert.equal(sub?.safety, "write");
+  const main = resolveRedisCommandSpec(["GET"]);
+  assert.ok(main);
+  assert.equal(main?.group, "string");
+});
+
+test("normal writes do not require confirmation but destructive commands do", () => {
+  assert.equal(resolveRedisCommandSpec(["SET"])?.safety, "write");
+  assert.equal(resolveRedisCommandSpec(["HSET"])?.safety, "write");
+  assert.equal(resolveRedisCommandSpec(["LPUSH"])?.safety, "write");
+  assert.equal(resolveRedisCommandSpec(["DEL"])?.safety, "confirm");
+  assert.equal(resolveRedisCommandSpec(["FLUSHDB"])?.safety, "confirm");
+});
diff --git a/packages/app-tests/redisCompletion.test.ts b/packages/app-tests/redisCompletion.test.ts
new file mode 100644
index 0000000..26e77cc
--- /dev/null
+++ b/packages/app-tests/redisCompletion.test.ts
@@ -0,0 +1,147 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import {
+  buildRedisCompletionItems,
+  getRedisCompletionContext,
+  getRedisCompletionResultValidFor,
+  shouldAutoOpenRedisCompletion,
+  takesKeyArgument,
+} from "../../apps/desktop/src/lib/redis/redisCompletion.ts";
+
+function labels(items: { label: string }[]): string[] {
+  return items.map((item) => item.label);
+}
+
+test("command mode: completes command names by prefix (case-insensitive)", () => {
+  const items = buildRedisCompletionItems("GE", 2);
+  const names = labels(items);
+  assert.ok(names.includes("GET"));
+  assert.ok(names.includes("GETSET"));
+  assert.ok(names.includes("GETRANGE"));
+  // no subcommand forms leak in
+  assert.ok(!names.some((n) => n.includes(" ")));
+  // lowercase prefix also works
+  assert.ok(labels(buildRedisCompletionItems("ge", 2)).includes("GET"));
+});
+
+test("command mode: does not surface bare subcommand labels", () => {
+  const items = buildRedisCompletionItems("XGROUP", 6);
+  const names = labels(items);
+  assert.ok(names.includes("XGROUP"));
+  // "CREATE" alone is not a top-level command
+  assert.ok(!names.includes("CREATE"));
+});
+
+test("command mode: detail/info carry group + arity + safety", () => {
+  const items = buildRedisCompletionItems("FLUSHALL", 9);
+  const flush = items.find((item) => item.label === "FLUSHALL");
+  assert.ok(flush);
+  assert.match(flush!.detail ?? "", /server.*blocked/i);
+  assert.match(flush!.info ?? "", /Group:\s*server/i);
+  assert.match(flush!.info ?? "", /Arity:/i);
+  assert.match(flush!.info ?? "", /Safety:\s*blocked/i);
+});
+
+test("subcommand mode: after 'XGROUP ' suggests its subcommands", () => {
+  const items = buildRedisCompletionItems("XGROUP ", 7);
+  const names = labels(items);
+  assert.ok(names.includes("CREATE"));
+  assert.ok(names.includes("DESTROY"));
+  assert.ok(names.includes("SETID"));
+  // unrelated commands absent
+  assert.ok(!names.includes("GET"));
+});
+
+test("subcommand mode: filters subcommands by prefix", () => {
+  const items = buildRedisCompletionItems("XGROUP C", 8);
+  const names = labels(items);
+  assert.ok(names.includes("CREATE"));
+  assert.ok(names.includes("CREATECONSUMER"));
+  assert.ok(!names.includes("DESTROY"));
+});
+
+test("argument mode: offers key names for key-taking commands", () => {
+  const items = buildRedisCompletionItems("GET ", 4, { keys: ["user:1", "user:2", "config:db"] });
+  const names = labels(items);
+  assert.ok(names.includes("user:1"));
+  assert.ok(names.includes("user:2"));
+});
+
+test("argument mode: filters keys by substring prefix", () => {
+  const items = buildRedisCompletionItems("GET user", 8, { keys: ["user:1", "user:2", "config:db"] });
+  const names = labels(items);
+  assert.ok(names.includes("user:1"));
+  assert.ok(names.includes("user:2"));
+  assert.ok(!names.includes("config:db"));
+});
+
+test("argument mode: empty keys yields no key items", () => {
+  const items = buildRedisCompletionItems("GET ", 4, { keys: [] });
+  assert.equal(items.length, 0);
+});
+
+test("argument mode: does not suggest keys once the key argument is filled in", () => {
+  // GET takes exactly one key argument; after "GET key " the next slot is out of range.
+  assert.equal(buildRedisCompletionItems("GET key ", 8, { keys: ["user:1"] }).length, 0);
+  assert.equal(buildRedisCompletionItems("GET key extra ", 14, { keys: ["user:1"] }).length, 0);
+  // HSET takes key then field/value; after the key only non-key args remain.
+  assert.equal(buildRedisCompletionItems("HSET k ", 7, { keys: ["user:1"] }).length, 0);
+});
+
+test("argument mode: variadic key-list commands keep suggesting keys", () => {
+  // DEL accepts multiple keys — keep suggesting after the first one.
+  assert.ok(labels(buildRedisCompletionItems("DEL k1 ", 7, { keys: ["user:1"] })).includes("user:1"));
+  assert.ok(labels(buildRedisCompletionItems("EXISTS k1 k2 ", 13, { keys: ["user:1"] })).includes("user:1"));
+});
+
+test("argument mode: still suggests keys at the first argument slot", () => {
+  // GET <here> — first argument position
+  const items = buildRedisCompletionItems("GET ", 4, { keys: ["user:1", "user:2"] });
+  assert.ok(labels(items).includes("user:1"));
+});
+
+test("argument mode: non-key commands (FLUSHDB) do not suggest keys", () => {
+  const items = buildRedisCompletionItems("FLUSHDB ", 8, { keys: ["user:1", "user:2"] });
+  assert.equal(items.length, 0);
+});
+
+test("takesKeyArgument reflects command group", () => {
+  assert.equal(takesKeyArgument("GET"), true); // string
+  assert.equal(takesKeyArgument("HSET"), true); // hash
+  assert.equal(takesKeyArgument("DEL"), true); // generic
+  assert.equal(takesKeyArgument("FLUSHDB"), false); // server
+  assert.equal(takesKeyArgument("SELECT"), false); // connection
+  assert.equal(takesKeyArgument(undefined), false);
+});
+
+test("context parsing: empty line → command mode", () => {
+  const ctx = getRedisCompletionContext("", 0);
+  assert.equal(ctx.mode, "command");
+  assert.equal(ctx.prefix, "");
+});
+
+test("context parsing: command + space → subcommand mode when the command has subcommands", () => {
+  const ctx = getRedisCompletionContext("XGROUP ", 7);
+  assert.equal(ctx.mode, "subcommand");
+  assert.equal(ctx.mainCommand, "XGROUP");
+});
+
+test("context parsing: GET + space → argument mode", () => {
+  const ctx = getRedisCompletionContext("GET ", 4);
+  assert.equal(ctx.mode, "argument");
+  assert.equal(ctx.mainCommand, "GET");
+});
+
+test("shouldAutoOpenRedisCompletion opens on word/space chars, not newline", () => {
+  assert.equal(shouldAutoOpenRedisCompletion("GET", 3), true);
+  assert.equal(shouldAutoOpenRedisCompletion("GET ", 4), true); // space → offer keys/subcommands
+  assert.equal(shouldAutoOpenRedisCompletion("GET\n", 4), false);
+  assert.equal(shouldAutoOpenRedisCompletion("user:", 5), true);
+});
+
+test("result validFor covers command-name and key-name characters", () => {
+  const re = getRedisCompletionResultValidFor();
+  assert.equal(re.test("GET"), true);
+  assert.equal(re.test("user:1"), true);
+  assert.equal(re.test("a.b-c"), true);
+});
diff --git a/packages/app-tests/redisKeyTree.test.ts b/packages/app-tests/redisKeyTree.test.ts
new file mode 100644
index 0000000..1d1d3a3
--- /dev/null
+++ b/packages/app-tests/redisKeyTree.test.ts
@@ -0,0 +1,205 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { buildRedisKeyTree, collectRedisGroupKeyRaws, collectExpandedGroupIds, flattenVisibleRedisKeyTree, mergeKeysIntoRedisKeyTree, redisKeyNameCopyText, redisKeyToFlatTreeRow, type RedisKeyTreeNode } from "../../apps/desktop/src/lib/redis/redisKeyTree.ts";
+import type { RedisKeyInfo } from "../../apps/desktop/src/lib/backend/api.ts";
+
+function makeKey(key_display: string, key_raw: string, key_type = "string", ttl = -1): RedisKeyInfo {
+  return { key_display, key_raw, key_type, ttl };
+}
+
+function leafLabels(nodes: RedisKeyTreeNode[]): string[] {
+  return nodes.filter((node) => node.kind === "leaf").map((node) => node.label);
+}
+
+test("buildRedisKeyTree groups colon-delimited keys by segment", () => {
+  const tree = buildRedisKeyTree([makeKey("a:b:c", "k1"), makeKey("a:b:d", "k2"), makeKey("a:e", "k3"), makeKey("x", "k4")], 0);
+
+  assert.equal(tree.length, 2);
+  assert.equal(tree[0]?.kind, "group");
+  assert.equal(tree[1]?.kind, "leaf");
+  assert.equal(tree[1]?.kind === "leaf" ? tree[1].fullKeyDisplay : "", "x");
+
+  const aGroup = tree[0];
+  assert.equal(aGroup?.kind, "group");
+  if (aGroup?.kind !== "group") return;
+
+  assert.deepEqual(aGroup.pathSegments, ["a"]);
+  assert.deepEqual(leafLabels(aGroup.children), ["e"]);
+
+  const bGroup = aGroup.children.find((node) => node.kind === "group" && node.label === "b");
+  assert.ok(bGroup);
+  if (!bGroup || bGroup.kind !== "group") return;
+
+  assert.deepEqual(
+    bGroup.children.map((node) => (node.kind === "leaf" ? node.fullKeyDisplay : node.label)),
+    ["a:b:c", "a:b:d"],
+  );
+});
+
+test("buildRedisKeyTree preserves binary prefix segments from display text", () => {
+  const tree = buildRedisKeyTree([makeKey("\\xac\\xed\\x00\\x05t\\x00token:work:app", "k1")], 2);
+
+  assert.equal(tree.length, 1);
+  const root = tree[0];
+  assert.equal(root?.kind, "group");
+  if (!root || root.kind !== "group") return;
+
+  assert.equal(root.label, "\\xac\\xed\\x00\\x05t\\x00token");
+  const work = root.children[0];
+  assert.equal(work?.kind, "group");
+  if (!work || work.kind !== "group") return;
+
+  assert.equal(work.label, "work");
+  const appLeaf = work.children[0];
+  assert.equal(appLeaf?.kind, "leaf");
+  if (!appLeaf || appLeaf.kind !== "leaf") return;
+  assert.equal(appLeaf.label, "app");
+  assert.equal(appLeaf.fullKeyDisplay, "\\xac\\xed\\x00\\x05t\\x00token:work:app");
+});
+
+test("collectExpandedGroupIds and flattenVisibleRedisKeyTree expand all search paths", () => {
+  const tree = buildRedisKeyTree([makeKey("user:profile:name", "k1"), makeKey("user:settings", "k2")], 0);
+  const expanded = collectExpandedGroupIds(tree);
+  const rows = flattenVisibleRedisKeyTree(tree, expanded);
+
+  assert.deepEqual(
+    rows.map(({ node, depth }) => `${depth}:${node.kind}:${node.label}`),
+    ["0:group:user", "1:group:profile", "2:leaf:name", "1:leaf:settings"],
+  );
+});
+
+test("flattenVisibleRedisKeyTree handles very large expanded groups without stack overflow", () => {
+  const keys = Array.from({ length: 150_000 }, (_, index) => {
+    const id = String(index).padStart(6, "0");
+    return makeKey(`user:${id}`, `user:${id}`);
+  });
+  const tree = buildRedisKeyTree(keys, 0);
+  const expanded = collectExpandedGroupIds(tree);
+
+  const rows = flattenVisibleRedisKeyTree(tree, expanded);
+
+  assert.equal(rows.length, keys.length + 1);
+  assert.equal(rows[0]?.node.kind, "group");
+  assert.equal(rows[0]?.node.label, "user");
+  assert.equal(rows[1]?.depth, 1);
+  assert.equal(rows.at(-1)?.depth, 1);
+});
+
+test("redisKeyToFlatTreeRow keeps search results flat with the full key label", () => {
+  const row = redisKeyToFlatTreeRow(makeKey("user:profile:1", "user:profile:1", ""), 0);
+
+  assert.equal(row.depth, 0);
+  assert.equal(row.node.kind, "leaf");
+  if (row.node.kind !== "leaf") return;
+  assert.equal(row.node.label, "user:profile:1");
+  assert.deepEqual(row.node.pathSegments, ["user:profile:1"]);
+  assert.equal(row.node.keyType, "");
+});
+
+test("redisKeyNameCopyText uses the display name instead of raw encoding", () => {
+  const tree = buildRedisKeyTree([makeKey("user:profile:1", "dXNlcjpwcm9maWxlOjE=")], 0);
+  const userGroup = tree[0];
+  assert.equal(userGroup?.kind, "group");
+  if (!userGroup || userGroup.kind !== "group") return;
+
+  assert.equal(redisKeyNameCopyText(userGroup), null);
+  const profileGroup = userGroup.children[0];
+  assert.equal(profileGroup?.kind, "group");
+  if (!profileGroup || profileGroup.kind !== "group") return;
+
+  const leaf = profileGroup.children[0];
+  assert.equal(leaf?.kind, "leaf");
+  if (!leaf || leaf.kind !== "leaf") return;
+  assert.equal(redisKeyNameCopyText(leaf), "user:profile:1");
+  assert.notEqual(redisKeyNameCopyText(leaf), leaf.keyRaw);
+});
+
+test("collectRedisGroupKeyRaws returns every leaf key under a group", () => {
+  const tree = buildRedisKeyTree([makeKey("user:profile:name", "k1"), makeKey("user:profile:email", "k2"), makeKey("user:settings", "k3"), makeKey("session:1", "k4")], 0);
+
+  const userGroup = tree.find((node) => node.kind === "group" && node.label === "user");
+  assert.ok(userGroup);
+  if (!userGroup || userGroup.kind !== "group") return;
+
+  assert.deepEqual(collectRedisGroupKeyRaws(userGroup), ["k2", "k1", "k3"]);
+});
+
+test("mergeKeysIntoRedisKeyTree adds new leaf to existing group", () => {
+  const tree = buildRedisKeyTree([makeKey("user:profile:name", "k1")], 0);
+  const merged = mergeKeysIntoRedisKeyTree(tree, [makeKey("user:profile:email", "k2")], 0);
+
+  const userGroup = merged.find((node) => node.kind === "group" && node.label === "user");
+  assert.ok(userGroup);
+  if (!userGroup || userGroup.kind !== "group") return;
+
+  const profileGroup = userGroup.children.find((node) => node.kind === "group" && node.label === "profile");
+  assert.ok(profileGroup);
+  if (!profileGroup || profileGroup.kind !== "group") return;
+
+  assert.equal(profileGroup.children.length, 2);
+  const labels = profileGroup.children.map((node) => (node.kind === "leaf" ? node.label : ""));
+  assert.deepEqual(labels, ["email", "name"]);
+});
+
+test("mergeKeysIntoRedisKeyTree creates new group for new prefix", () => {
+  const tree = buildRedisKeyTree([makeKey("user:profile:name", "k1")], 0);
+  const merged = mergeKeysIntoRedisKeyTree(tree, [makeKey("session:1", "k2")], 0);
+
+  assert.equal(merged.length, 2);
+  const labels = merged.map((node) => node.label);
+  assert.deepEqual(labels, ["session", "user"]);
+});
+
+test("mergeKeysIntoRedisKeyTree handles root-level keys", () => {
+  const tree = buildRedisKeyTree([makeKey("user:profile:name", "k1")], 0);
+  const merged = mergeKeysIntoRedisKeyTree(tree, [makeKey("standalone", "k2")], 0);
+
+  assert.equal(merged.length, 2);
+  const rootLeaf = merged.find((node) => node.kind === "leaf");
+  assert.ok(rootLeaf);
+  if (!rootLeaf || rootLeaf.kind !== "leaf") return;
+  assert.equal(rootLeaf.label, "standalone");
+});
+
+test("mergeKeysIntoRedisKeyTree returns same result as full build", () => {
+  const batch1 = [makeKey("a:b:c", "k1"), makeKey("a:d", "k2")];
+  const batch2 = [makeKey("a:b:e", "k3"), makeKey("x", "k4")];
+
+  const tree = buildRedisKeyTree(batch1, 0);
+  const merged = mergeKeysIntoRedisKeyTree(tree, batch2, 0);
+  const full = buildRedisKeyTree([...batch1, ...batch2], 0);
+
+  const toStr = (nodes: RedisKeyTreeNode[]): string =>
+    JSON.stringify(
+      nodes.map((node) => {
+        if (node.kind === "leaf") return { l: node.label, id: node.id };
+        return { g: node.label, id: node.id, c: toStr(node.children) };
+      }),
+    );
+
+  assert.equal(toStr(merged), toStr(full));
+});
+
+test("mergeKeysIntoRedisKeyTree skips duplicate keys", () => {
+  const tree = buildRedisKeyTree([makeKey("user:profile:name", "k1")], 0);
+  const merged = mergeKeysIntoRedisKeyTree(tree, [makeKey("user:profile:name", "k1")], 0);
+
+  const userGroup = merged[0];
+  assert.ok(userGroup && userGroup.kind === "group");
+  if (!userGroup || userGroup.kind !== "group") return;
+
+  const profileGroup = userGroup.children[0];
+  assert.ok(profileGroup && profileGroup.kind === "group");
+  if (!profileGroup || profileGroup.kind !== "group") return;
+
+  assert.equal(profileGroup.children.length, 1);
+});
+
+test("mergeKeysIntoRedisKeyTree into empty tree falls back to full build", () => {
+  const merged = mergeKeysIntoRedisKeyTree([], [makeKey("a:b:c", "k1"), makeKey("x", "k2")], 0);
+  const full = buildRedisKeyTree([makeKey("a:b:c", "k1"), makeKey("x", "k2")], 0);
+
+  const toStr = (nodes: RedisKeyTreeNode[]): string => JSON.stringify(nodes.map((node) => node.label));
+
+  assert.equal(toStr(merged), toStr(full));
+});
diff --git a/packages/app-tests/redisSyntaxDiagnostics.test.ts b/packages/app-tests/redisSyntaxDiagnostics.test.ts
new file mode 100644
index 0000000..21562bf
--- /dev/null
+++ b/packages/app-tests/redisSyntaxDiagnostics.test.ts
@@ -0,0 +1,146 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { buildRedisSyntaxDiagnostics, shouldRunRedisDiagnostics, tokenizeRedisLine } from "../../apps/desktop/src/lib/redis/redisSyntaxDiagnostics.ts";
+
+function messages(source: string): string[] {
+  return buildRedisSyntaxDiagnostics(source).map((d) => d.message);
+}
+
+test("reports no diagnostics for read-only valid commands", () => {
+  assert.deepEqual(messages("GET foo"), []);
+  assert.deepEqual(messages("HGETALL k"), []);
+  assert.deepEqual(messages("SCAN 0"), []);
+  assert.deepEqual(messages("ZRANDMEMBER leaderboard 2 WITHSCORES"), []);
+});
+
+test("recognizes set store commands as writes", () => {
+  const diags = buildRedisSyntaxDiagnostics("SDIFFSTORE destination source-a source-b");
+  assert.equal(diags.length, 1);
+  assert.equal(diags[0].severity, "warning");
+  assert.doesNotMatch(diags[0].message, /Unknown command/);
+});
+
+test("flags unknown command name", () => {
+  const diags = buildRedisSyntaxDiagnostics("GETT foo");
+  assert.equal(diags.length, 1);
+  assert.equal(diags[0].severity, "error");
+  assert.match(diags[0].message, /Unknown command 'GETT'/);
+  // span covers the command-name token on line 1
+  assert.equal(diags[0].span.start_line, 1);
+  assert.equal(diags[0].span.start_column, 1);
+});
+
+test("flags wrong arity (too few arguments)", () => {
+  const diags = buildRedisSyntaxDiagnostics("GET");
+  assert.equal(diags.length, 1);
+  assert.match(diags[0].message, /Wrong number of arguments for 'GET'/);
+  assert.match(diags[0].message, /expected exactly 1 argument/);
+});
+
+test("flags wrong arity (too many arguments)", () => {
+  // GET arity is 2 (exact). Extra args → error.
+  const diags = buildRedisSyntaxDiagnostics("GET a b");
+  assert.equal(diags.length, 1);
+  assert.match(diags[0].message, /Wrong number of arguments for 'GET'/);
+});
+
+test("respects variable arity (negative arity is a minimum)", () => {
+  // MSET arity -3 → at least 2 args; 2 args (3 tokens) is valid.
+  const ok3 = buildRedisSyntaxDiagnostics("MSET k1 v1");
+  assert.equal(ok3.length, 0);
+  const ok4 = buildRedisSyntaxDiagnostics("MSET k1 v1 k2 v2");
+  assert.equal(ok4.length, 0);
+  // Too few → arity error takes precedence.
+  const diags = buildRedisSyntaxDiagnostics("MSET k1");
+  assert.equal(diags.length, 1);
+  assert.match(diags[0].message, /Wrong number of arguments for 'MSET'/);
+});
+
+test("flags unclosed quote and spans to end of line", () => {
+  const diags = buildRedisSyntaxDiagnostics('SET "abc b');
+  assert.equal(diags.length, 1);
+  assert.equal(diags[0].severity, "error");
+  assert.match(diags[0].message, /Unclosed quote/);
+  assert.equal(diags[0].span.start_column, 5); // quote starts at column 5
+});
+
+test("highlights destructive commands as warning", () => {
+  const diags = buildRedisSyntaxDiagnostics("DEL x");
+  assert.equal(diags.length, 1);
+  assert.equal(diags[0].severity, "warning");
+  assert.match(diags[0].message, /Dangerous command 'DEL'/);
+});
+
+test("highlights flushall as blocked error but flushdb as confirm warning", () => {
+  // Aligned with the execution safety classification: FLUSHALL=blocked, FLUSHDB=confirm.
+  const all = buildRedisSyntaxDiagnostics("FLUSHALL");
+  assert.equal(all.length, 1);
+  assert.equal(all[0].severity, "error");
+  assert.match(all[0].message, /Blocked command 'FLUSHALL'/);
+
+  const db = buildRedisSyntaxDiagnostics("FLUSHDB");
+  assert.equal(db.length, 1);
+  assert.equal(db[0].severity, "warning");
+  assert.match(db[0].message, /Dangerous command 'FLUSHDB'/);
+});
+
+test("subcommands resolve via MAIN SUB key", () => {
+  // XGROUP CREATE stream group id MKSTREAM → 6 tokens, satisfies arity -6.
+  const diags = buildRedisSyntaxDiagnostics("XGROUP CREATE stream group $ MKSTREAM");
+  assert.equal(diags.length, 0);
+});
+
+test("treats command names case-insensitively", () => {
+  assert.deepEqual(messages("get foo"), []);
+  const setDiag = buildRedisSyntaxDiagnostics("Set a b");
+  assert.equal(setDiag.length, 0);
+  const diags = buildRedisSyntaxDiagnostics("flushall");
+  assert.match(diags[0].message, /Blocked command 'flushall'/);
+});
+
+test("handles multi-line input with per-line diagnostics", () => {
+  const source = "GET ok\nFLUSHALL\nBADCMD x";
+  const diags = buildRedisSyntaxDiagnostics(source);
+  assert.equal(diags.length, 2);
+  const lines = diags.map((d) => d.span.start_line).sort((a, b) => a - b);
+  assert.deepEqual(lines, [2, 3]);
+  assert.match(diags.find((d) => d.span.start_line === 2)!.message, /Blocked/);
+  assert.match(diags.find((d) => d.span.start_line === 3)!.message, /Unknown command/);
+});
+
+test("ignores blank and comment lines", () => {
+  assert.deepEqual(messages(""), []);
+  assert.deepEqual(messages("\n\n"), []);
+  assert.deepEqual(messages("# a note\nGET foo"), []);
+  assert.deepEqual(messages("-- note\nGET foo"), []);
+});
+
+test("strips trailing semicolon terminator", () => {
+  assert.deepEqual(messages("GET foo;"), []);
+});
+
+test("shouldRunRedisDiagnostics waits while typing the command name", () => {
+  // cursor at end of a bare partial token (no whitespace yet) → wait
+  assert.equal(shouldRunRedisDiagnostics("GETT", 4), false);
+  // once a space exists after the command name → run
+  assert.equal(shouldRunRedisDiagnostics("GETT foo", 8), true);
+  assert.equal(shouldRunRedisDiagnostics("", 0), false);
+});
+
+test("tokenizeRedisLine preserves quoted values with spaces", () => {
+  const { argv, unclosedQuote } = tokenizeRedisLine('SET mykey "hello world"');
+  assert.equal(unclosedQuote, false);
+  assert.deepEqual(
+    argv.map((t) => t.value),
+    ["SET", "mykey", "hello world"],
+  );
+  assert.equal(argv[2]!.startColumn, 11);
+});
+
+test("tokenizeRedisLine handles backslash escapes", () => {
+  const { argv } = tokenizeRedisLine("SET k a\\ b");
+  assert.deepEqual(
+    argv.map((t) => t.value),
+    ["SET", "k", "a b"],
+  );
+});
diff --git a/packages/app-tests/redisValuePresentation.test.ts b/packages/app-tests/redisValuePresentation.test.ts
new file mode 100644
index 0000000..4b06569
--- /dev/null
+++ b/packages/app-tests/redisValuePresentation.test.ts
@@ -0,0 +1,277 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { isLosslessJsonNumber } from "../../apps/desktop/src/lib/common/safeJsonFormat.ts";
+import {
+  canRenderRedisValueFormat,
+  canEditRedisMemberDetail,
+  clampRedisMemberDetailSheetWidth,
+  formatRedisCommandResult,
+  formatRedisMemberDetail,
+  formatRedisStringValue,
+  getRedisMemberSelectionKey,
+  highlightRedisJsonDetail,
+  parseRedisJsonDetail,
+  preferredRedisValueFormat,
+  redisMemberCopyText,
+  redisValueCopyText,
+} from "../../apps/desktop/src/lib/redis/redisValuePresentation.ts";
+
+function blobFromText(value: string) {
+  return {
+    raw_base64: Buffer.from(value, "utf8").toString("base64"),
+    encoding: "utf8" as const,
+  };
+}
+
+test("keeps JSON-like strings as raw text in Redis member details", () => {
+  const detail = formatRedisMemberDetail('{"id":1,"name":"Ada","tags":["dbx","redis"]}');
+
+  assert.equal(detail.format, "text");
+  assert.equal(detail.rawText, '{"id":1,"name":"Ada","tags":["dbx","redis"]}');
+  assert.equal(detail.text, '{"id":1,"name":"Ada","tags":["dbx","redis"]}');
+});
+
+test("keeps plain Redis member strings unchanged", () => {
+  const detail = formatRedisMemberDetail("plain long member value");
+
+  assert.equal(detail.format, "text");
+  assert.equal(detail.rawLabel, "ASCII");
+  assert.equal(detail.text, "plain long member value");
+  assert.deepEqual(detail.availableFormats, ["utf8", "ascii", "binary", "hex", "base64"]);
+});
+
+test("formats JSON string values without changing plain strings", () => {
+  assert.equal(formatRedisStringValue('{"id":1,"name":"Ada"}'), '{\n  "id": 1,\n  "name": "Ada"\n}');
+  assert.equal(formatRedisStringValue("plain redis value"), "plain redis value");
+});
+
+test("parses Redis JSON details for any valid JSON payload", () => {
+  const objectDetail = parseRedisJsonDetail('{"id":1,"name":"Ada"}');
+  assert.equal(objectDetail?.rawText, '{"id":1,"name":"Ada"}');
+  assert.equal(objectDetail?.formattedText, '{\n  "id": 1,\n  "name": "Ada"\n}');
+  assert.deepEqual(objectDetail?.value, { id: 1, name: "Ada" });
+
+  assert.equal(parseRedisJsonDetail("[1,2]")?.formattedText, "[\n  1,\n  2\n]");
+  assert.equal(parseRedisJsonDetail('"plain json string"')?.formattedText, '"plain json string"');
+  assert.equal(parseRedisJsonDetail("123")?.formattedText, "123");
+  assert.equal(parseRedisJsonDetail("plain redis value"), null);
+});
+
+test("preserves large Redis JSON integers in formatted and tree values", () => {
+  const detail = parseRedisJsonDetail('{"companyId":518400931654815740,"nested":[-9007199254740992]}');
+
+  assert.equal(detail?.formattedText, '{\n  "companyId": 518400931654815740,\n  "nested": [\n    -9007199254740992\n  ]\n}');
+  const value = detail?.value as { companyId?: unknown; nested?: unknown[] };
+  assert.equal(isLosslessJsonNumber(value.companyId) ? value.companyId.raw : null, "518400931654815740");
+  assert.equal(isLosslessJsonNumber(value.nested?.[0]) ? value.nested[0].raw : null, "-9007199254740992");
+});
+
+test("string/blob formats stay text-oriented and binary-first where needed", () => {
+  const jsonLikeTextDetail = formatRedisMemberDetail(blobFromText('{"name":"Ada"}'));
+  assert.equal(jsonLikeTextDetail.rawLabel, "ASCII");
+  assert.deepEqual(jsonLikeTextDetail.availableFormats, ["utf8", "ascii", "binary", "hex", "base64"]);
+  assert.equal(jsonLikeTextDetail.defaultFormat, "utf8");
+  assert.equal(jsonLikeTextDetail.utf8Text, '{"name":"Ada"}');
+  assert.equal(jsonLikeTextDetail.asciiText, '{"name":"Ada"}');
+  assert.equal(jsonLikeTextDetail.binaryText, "0111101100100010011011100110000101101101011001010010001000111010001000100100000101100100011000010010001001111101");
+  assert.equal(jsonLikeTextDetail.rawText, '{"name":"Ada"}');
+
+  const utf8Detail = formatRedisMemberDetail({
+    raw_base64: Buffer.from("你好", "utf8").toString("base64"),
+    encoding: "utf8" as const,
+  });
+  assert.equal(utf8Detail.rawLabel, "UTF-8");
+  assert.deepEqual(utf8Detail.availableFormats, ["utf8", "ascii", "binary", "hex", "base64"]);
+  assert.equal(utf8Detail.defaultFormat, "utf8");
+  assert.equal(utf8Detail.utf8Text, "你好");
+  assert.equal(utf8Detail.asciiText, "\\xe4\\xbd\\xa0\\xe5\\xa5\\xbd");
+  assert.equal(utf8Detail.binaryText, "111001001011110110100000111001011010010110111101");
+  assert.equal(utf8Detail.rawText, "你好");
+
+  const binaryDetail = formatRedisMemberDetail({
+    raw_base64: Buffer.from([0xac, 0xed, 0x00, 0x05]).toString("base64"),
+    encoding: "binary" as const,
+  });
+  assert.equal(binaryDetail.rawLabel, "Binary");
+  assert.deepEqual(binaryDetail.availableFormats, ["hex", "binary", "base64"]);
+  assert.equal(binaryDetail.defaultFormat, "hex");
+  assert.equal(binaryDetail.utf8Text, new TextDecoder("utf-8").decode(Uint8Array.from([0xac, 0xed, 0x00, 0x05])));
+  assert.equal(binaryDetail.binaryText, "10101100111011010000000000000101");
+});
+
+test("detects Java-serialized payloads as a dedicated view", () => {
+  const javaSerializedString = formatRedisMemberDetail({
+    raw_base64: "rO0ABXQACHNvbWV0ZXh0",
+    encoding: "binary" as const,
+  });
+  assert.deepEqual(javaSerializedString.availableFormats, ["javaserialize", "binary", "hex", "base64"]);
+  assert.equal(javaSerializedString.defaultFormat, "javaserialize");
+  assert.equal(javaSerializedString.javaSerialized?.formattedText, '"sometext"');
+
+  const javaSerializedMap = formatRedisMemberDetail({
+    raw_base64:
+      "rO0ABXNyABFqYXZhLnV0aWwuSGFzaE1hcAUHsMEzFmDRAwACRgAKbG9hZEZhY3RvckkACXRocmVzaG9sZHhwP0AAAAAAAAx3CAAAABAAAAACdAADYmFydAADYmF6dAADZm9vc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAHt4",
+    encoding: "binary" as const,
+  });
+  assert.equal((javaSerializedMap.javaSerialized?.value as { $class?: string }).$class, "java.util.HashMap");
+  assert.equal(
+    ((javaSerializedMap.javaSerialized?.value as { obj?: { bar?: string } }).obj ?? {}).bar,
+    "baz",
+  );
+
+  const plainText = formatRedisMemberDetail(blobFromText("Ada"));
+  assert.equal(canRenderRedisValueFormat(plainText, "json"), false);
+  assert.equal(canRenderRedisValueFormat(plainText, "javaserialize"), false);
+  assert.equal(canRenderRedisValueFormat(plainText, "utf8"), true);
+
+  assert.equal(canRenderRedisValueFormat(javaSerializedMap, "javaserialize"), true);
+});
+
+test("normalizes self-referential Java maps without recursing forever", () => {
+  const detail = formatRedisMemberDetail({
+    raw_base64: "rO0ABXNyABFqYXZhLnV0aWwuSGFzaE1hcAUH2sHDFmDRAwACRgAKbG9hZEZhY3RvckkACXRocmVzaG9sZHhwP0AAAAAAAAx3CAAAABAAAAABdAAEc2VsZnEAfgABeA==",
+    encoding: "binary" as const,
+  });
+
+  const normalized = detail.javaSerialized?.value as {
+    $id?: string;
+    map?: { $entries?: Array<{ key?: string; value?: { $ref?: string } }> };
+    obj?: { self?: { $ref?: string } };
+  };
+
+  assert.equal(normalized.$id, "#1");
+  assert.equal(normalized.map?.$entries?.[0]?.key, "self");
+  assert.equal(normalized.map?.$entries?.[0]?.value?.$ref, "#1");
+  assert.equal(normalized.obj?.self?.$ref, "#1");
+});
+
+test("only payload views opt into JSON text formatting", () => {
+  const identityDetail = formatRedisMemberDetail(blobFromText('{"name":"Ada"}'));
+  assert.deepEqual(identityDetail.availableFormats, ["utf8", "ascii", "binary", "hex", "base64"]);
+  assert.equal(identityDetail.json, undefined);
+
+  const payloadDetail = formatRedisMemberDetail(blobFromText('{"name":"Ada"}'), { allowJsonText: true });
+  assert.equal(payloadDetail.rawLabel, "ASCII");
+  assert.deepEqual(payloadDetail.availableFormats, ["utf8", "ascii", "binary", "json", "hex", "base64"]);
+  assert.equal(payloadDetail.defaultFormat, "utf8");
+  assert.equal(payloadDetail.json?.formattedText, '{\n  "name": "Ada"\n}');
+});
+
+test("reuses only safe default formats for editable text values", () => {
+  const textBlob = blobFromText("Ada");
+  assert.equal(preferredRedisValueFormat(textBlob, "hex"), "utf8");
+  assert.equal(preferredRedisValueFormat(textBlob, "base64"), "utf8");
+  assert.equal(preferredRedisValueFormat(textBlob, "binary"), "utf8");
+
+  const jsonTextBlob = blobFromText('{"name":"Ada"}');
+  assert.equal(preferredRedisValueFormat(jsonTextBlob, "json", { allowJsonText: true }), "json");
+
+  const binaryBlob = {
+    raw_base64: Buffer.from([0xac, 0xed, 0x00, 0x05]).toString("base64"),
+    encoding: "binary" as const,
+  };
+  assert.equal(preferredRedisValueFormat(binaryBlob, "base64"), "base64");
+});
+
+test("formats Redis command results with JSON strings expanded", () => {
+  assert.equal(formatRedisCommandResult('{"balance":42,"unit":"USD"}'), '{\n  "balance": 42,\n  "unit": "USD"\n}');
+  assert.equal(formatRedisCommandResult(["a", 2]), '[\n  "a",\n  2\n]');
+});
+
+test("formats non-string Redis member values as JSON", () => {
+  const detail = formatRedisMemberDetail({ field: "name", value: '{"nested":true}' });
+
+  assert.equal(detail.format, "json");
+  assert.equal(detail.text, '{\n  "field": "name",\n  "value": "{\\"nested\\":true}"\n}');
+});
+
+test("builds stable Redis member selection keys from title and raw value identity", () => {
+  const key = getRedisMemberSelectionKey("#2", '{"id":240,"kind":"json"}');
+
+  assert.equal(key, '#2\n{"id":240,"kind":"json"}');
+});
+
+test("lets selection keys disambiguate duplicate stream fields", () => {
+  const first = getRedisMemberSelectionKey("event", "login", "stream:1714470000000-0:0");
+  const second = getRedisMemberSelectionKey("event", "login", "stream:1714470000000-0:1");
+
+  assert.notEqual(first, second);
+});
+
+test("copies binary members as escaped raw bytes instead of bitstrings", () => {
+  const binaryBlob = {
+    raw_base64: Buffer.from([0xac, 0xed, 0x00, 0x05]).toString("base64"),
+    encoding: "binary" as const,
+  };
+
+  assert.equal(redisMemberCopyText(binaryBlob), "\\xac\\xed\\x00\\x05");
+});
+
+test("copies collection values as readable content instead of blob transport objects", () => {
+  const value = {
+    key_display: "users",
+    key_raw: "users",
+    ttl: -1,
+    redis_type: "hash",
+    data: {
+      kind: "hash" as const,
+      items: [{ field: blobFromText("name"), value: blobFromText("Ada") }],
+      total: 1,
+    },
+  };
+
+  assert.equal(redisValueCopyText(value), '[\n  {\n    "field": "name",\n    "value": "Ada"\n  }\n]');
+});
+
+test("copies stream entries without collapsing repeated field names", () => {
+  const value = {
+    key_display: "events",
+    key_raw: "events",
+    ttl: -1,
+    redis_type: "stream",
+    data: {
+      kind: "stream" as const,
+      entries: [
+        {
+          id: "1728123456789-0",
+          fields: [
+            { field: "event", value: "login" },
+            { field: "event", value: "logout" },
+            { field: "user_id", value: "42" },
+          ],
+        },
+      ],
+    },
+  };
+
+  assert.equal(
+    redisValueCopyText(value),
+    '[\n  {\n    "id": "1728123456789-0",\n    "fields": [\n      {\n        "field": "event",\n        "value": "login"\n      },\n      {\n        "field": "event",\n        "value": "logout"\n      },\n      {\n        "field": "user_id",\n        "value": "42"\n      }\n    ]\n  }\n]',
+  );
+});
+
+test("highlights formatted Redis JSON detail safely", () => {
+  const html = highlightRedisJsonDetail('{"id":240,"name":"<script>","active":true,"meta":null}');
+
+  assert.match(html, /<span class="json-key">"id":<\/span>/);
+  assert.match(html, /<span class="json-number">240<\/span>/);
+  assert.match(html, /<span class="json-string">"&lt;script&gt;"<\/span>/);
+  assert.match(html, /<span class="json-boolean">true<\/span>/);
+  assert.match(html, /<span class="json-null">null<\/span>/);
+  assert.doesNotMatch(html, /<script>/);
+});
+
+test("allows editing Redis collection members except stream fields", () => {
+  assert.equal(canEditRedisMemberDetail("list"), true);
+  assert.equal(canEditRedisMemberDetail("hash"), true);
+  assert.equal(canEditRedisMemberDetail("set"), true);
+  assert.equal(canEditRedisMemberDetail("zset"), true);
+  assert.equal(canEditRedisMemberDetail("stream"), false);
+});
+
+test("clamps Redis member detail sheet width to viewport and usable bounds", () => {
+  assert.equal(clampRedisMemberDetailSheetWidth(200, 1200), 360);
+  assert.equal(clampRedisMemberDetailSheetWidth(640, 1200), 640);
+  assert.equal(clampRedisMemberDetailSheetWidth(1200, 1400), 900);
+  assert.equal(clampRedisMemberDetailSheetWidth(900, 500), 468);
+});
diff --git a/packages/app-tests/routineExecutionSql.test.ts b/packages/app-tests/routineExecutionSql.test.ts
new file mode 100644
index 0000000..a5804c2
--- /dev/null
+++ b/packages/app-tests/routineExecutionSql.test.ts
@@ -0,0 +1,150 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildProcedureExecutionSql, buildProcedureExecutionSqlFromValues } from "../../apps/desktop/src/lib/table/routineExecutionSql.ts";
+import { routineParametersFromResult, routineParametersQuery } from "../../apps/desktop/src/lib/table/routineParameters.ts";
+
+test("builds procedure execution templates for common dialect families", () => {
+  assert.equal(buildProcedureExecutionSql({ databaseType: "postgres", schema: "public", routineName: "refresh_stats" }), 'CALL "public"."refresh_stats"();');
+  assert.equal(buildProcedureExecutionSql({ databaseType: "mysql", schema: "app", routineName: "refresh_stats" }), "CALL `refresh_stats`();");
+  assert.equal(buildProcedureExecutionSql({ databaseType: "sqlserver", schema: "dbo", routineName: "refresh_stats" }), "EXEC [dbo].[refresh_stats];");
+  assert.equal(buildProcedureExecutionSql({ databaseType: "dameng", schema: "SYSDBA", routineName: "refresh_stats" }), 'BEGIN\n  "SYSDBA"."refresh_stats"();\nEND;');
+  assert.equal(buildProcedureExecutionSql({ databaseType: "databend", schema: "default", routineName: "refresh_stats" }), "CALL PROCEDURE refresh_stats();");
+});
+
+test("builds procedure execution templates from parameter values", () => {
+  const parameters = [
+    { name: "p_message", dataType: "text", mode: "IN" as const, ordinal: 1, value: "it's ready" },
+    { name: "p_count", dataType: "integer", mode: "IN" as const, ordinal: 2, value: "3" },
+    { name: "p_debug", dataType: "boolean", mode: "IN" as const, ordinal: 3, value: "true" },
+    { name: "p_result", dataType: "text", mode: "OUT" as const, ordinal: 4, value: "" },
+  ];
+
+  assert.equal(
+    buildProcedureExecutionSqlFromValues({
+      databaseType: "postgres",
+      schema: "public",
+      routineName: "refresh_stats",
+      parameters,
+    }),
+    'CALL "public"."refresh_stats"(' + "'it''s ready', 3, TRUE);",
+  );
+
+  assert.equal(
+    buildProcedureExecutionSqlFromValues({
+      databaseType: "sqlserver",
+      schema: "dbo",
+      routineName: "refresh_stats",
+      parameters,
+    }),
+    "EXEC [dbo].[refresh_stats] @p_message = 'it''s ready', @p_count = 3, @p_debug = 1;",
+  );
+});
+
+test("omits parameters that use database defaults", () => {
+  assert.equal(
+    buildProcedureExecutionSqlFromValues({
+      databaseType: "postgres",
+      schema: "public",
+      routineName: "refresh_stats",
+      parameters: [
+        {
+          name: "p_message",
+          dataType: "text",
+          mode: "IN",
+          ordinal: 1,
+          value: "",
+          hasDefault: true,
+          useDefault: true,
+        },
+      ],
+    }),
+    'CALL "public"."refresh_stats"();',
+  );
+});
+
+test("uses named arguments when a defaulted positional argument is skipped", () => {
+  assert.equal(
+    buildProcedureExecutionSqlFromValues({
+      databaseType: "postgres",
+      schema: "public",
+      routineName: "refresh_stats",
+      parameters: [
+        {
+          name: "p_first",
+          dataType: "text",
+          mode: "IN",
+          ordinal: 1,
+          value: "",
+          hasDefault: true,
+          useDefault: true,
+        },
+        { name: "p_second", dataType: "integer", mode: "IN", ordinal: 2, value: "8" },
+      ],
+    }),
+    'CALL "public"."refresh_stats"("p_second" => 8);',
+  );
+
+  assert.equal(
+    buildProcedureExecutionSqlFromValues({
+      databaseType: "oracle",
+      schema: "APP",
+      routineName: "refresh_stats",
+      parameters: [
+        {
+          name: "P_FIRST",
+          dataType: "VARCHAR2",
+          mode: "IN",
+          ordinal: 1,
+          value: "",
+          hasDefault: true,
+          useDefault: true,
+        },
+        { name: "P_SECOND", dataType: "NUMBER", mode: "IN", ordinal: 2, value: "8" },
+      ],
+    }),
+    'BEGIN\n  "APP"."refresh_stats"("P_SECOND" => 8);\nEND;',
+  );
+});
+
+test("maps routine parameter query results into form metadata", () => {
+  const parameters = routineParametersFromResult({
+    columns: ["name", "data_type", "mode", "ordinal", "has_default"],
+    rows: [
+      ["p_message", "text", "IN", 1, true],
+      ["p_total", "integer", "OUT", 2, false],
+    ],
+    affected_rows: 0,
+    execution_time_ms: 1,
+  });
+
+  assert.deepEqual(parameters, [
+    { name: "p_message", dataType: "text", mode: "IN", ordinal: 1, hasDefault: true },
+    { name: "p_total", dataType: "integer", mode: "OUT", ordinal: 2, hasDefault: false },
+  ]);
+});
+
+test("maps Databend procedure signatures into positional input parameters", () => {
+  const parameters = routineParametersFromResult(
+    {
+      columns: ["arguments"],
+      rows: [["convert_weight(Decimal(10, 2), String) RETURN (Decimal(10, 2))"]],
+      affected_rows: 0,
+      execution_time_ms: 1,
+    },
+    "databend",
+  );
+
+  assert.deepEqual(parameters, [
+    { name: "arg1", dataType: "Decimal(10, 2)", mode: "IN", ordinal: 1, hasDefault: false },
+    { name: "arg2", dataType: "String", mode: "IN", ordinal: 2, hasDefault: false },
+  ]);
+});
+
+test("builds parameter metadata queries for supported dialects", () => {
+  assert.match(routineParametersQuery({ database: "app", databaseType: "postgres", schema: "public", routineName: "demo" }) ?? "", /pg_proc/);
+  assert.match(routineParametersQuery({ database: "app", databaseType: "sqlserver", schema: "dbo", routineName: "demo" }) ?? "", /sys\.parameters/);
+  assert.match(routineParametersQuery({ database: "app", databaseType: "mysql", routineName: "demo" }) ?? "", /SPECIFIC_SCHEMA = 'app'/);
+  assert.match(routineParametersQuery({ database: "default", databaseType: "databend", schema: "default", routineName: "demo" }) ?? "", /system\.procedures/);
+  assert.match(routineParametersQuery({ database: "app", databaseType: "postgres", routineName: "demo" }) ?? "", /n\.nspname = 'public'/);
+  assert.equal(routineParametersQuery({ database: "app", databaseType: "sqlite", schema: "main", routineName: "demo" }), null);
+});
diff --git a/packages/app-tests/savedSqlHistory.test.ts b/packages/app-tests/savedSqlHistory.test.ts
new file mode 100644
index 0000000..5b5f1ba
--- /dev/null
+++ b/packages/app-tests/savedSqlHistory.test.ts
@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { rankSavedSqlHistory, savedSqlHistoryScore, savedSqlMatchesHistoryScope } from "../../apps/desktop/src/lib/savedSql/savedSqlHistory.ts";
+import type { SavedSqlFile } from "../../apps/desktop/src/types/database.ts";
+
+function file(input: Partial<SavedSqlFile> & Pick<SavedSqlFile, "id" | "name" | "connectionId" | "database">): SavedSqlFile {
+  return {
+    folderId: undefined,
+    schema: undefined,
+    sql: "select 1",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    updatedAt: "2026-01-01T00:00:00.000Z",
+    ...input,
+  };
+}
+
+test("SQL 库历史按连接和数据库过滤", () => {
+  const files = [file({ id: "a", name: "a.sql", connectionId: "conn-1", database: "app" }), file({ id: "b", name: "b.sql", connectionId: "conn-1", database: "analytics" }), file({ id: "c", name: "c.sql", connectionId: "conn-2", database: "app" })];
+
+  assert.deepEqual(
+    rankSavedSqlHistory(files, {
+      connectionId: "conn-1",
+      database: "app",
+    }).map((item) => item.id),
+    ["a"],
+  );
+  assert.equal(savedSqlMatchesHistoryScope(files[2], { connectionId: "conn-1" }), false);
+});
+
+test("SQL 库历史综合打开次数和最近打开时间排序", () => {
+  const now = Date.parse("2026-06-11T12:00:00.000Z");
+  const files = [
+    file({ id: "recent", name: "recent.sql", connectionId: "conn", database: "app", openCount: 2, openedAt: "2026-06-11T11:00:00.000Z" }),
+    file({ id: "frequent", name: "frequent.sql", connectionId: "conn", database: "app", openCount: 7, openedAt: "2026-04-01T00:00:00.000Z" }),
+    file({ id: "unused", name: "unused.sql", connectionId: "conn", database: "app", openCount: 0 }),
+  ];
+
+  assert.deepEqual(
+    rankSavedSqlHistory(files, { now }).map((item) => item.id),
+    ["frequent", "recent", "unused"],
+  );
+  assert.ok(savedSqlHistoryScore(files[0], now) > savedSqlHistoryScore(files[2], now));
+});
+
+test("表级入口会优先展示命中表名的 SQL", () => {
+  const now = Date.parse("2026-06-11T12:00:00.000Z");
+  const files = [
+    file({ id: "generic", name: "daily.sql", connectionId: "conn", database: "app", openCount: 1, openedAt: "2026-06-11T11:00:00.000Z" }),
+    file({ id: "orders", name: "orders-report.sql", connectionId: "conn", database: "app", sql: "select * from public.orders", openCount: 1, openedAt: "2026-06-11T10:00:00.000Z" }),
+  ];
+
+  assert.deepEqual(
+    rankSavedSqlHistory(files, { connectionId: "conn", database: "app", schema: "public", tableName: "orders", now }).map((item) => item.id),
+    ["orders", "generic"],
+  );
+});
diff --git a/packages/app-tests/savedSqlStore.test.ts b/packages/app-tests/savedSqlStore.test.ts
new file mode 100644
index 0000000..d90d4c2
--- /dev/null
+++ b/packages/app-tests/savedSqlStore.test.ts
@@ -0,0 +1,337 @@
+import assert from "node:assert/strict";
+import { createPinia, setActivePinia } from "pinia";
+import { beforeEach, test, vi } from "vitest";
+import type { SavedSqlFile, SavedSqlFolder, SavedSqlLibrary } from "../../apps/desktop/src/types/database.ts";
+import { useSavedSqlStore } from "../../apps/desktop/src/stores/savedSqlStore.ts";
+import { useQueryStore } from "../../apps/desktop/src/stores/queryStore.ts";
+
+const apiMock = vi.hoisted(() => ({
+  loadSavedSqlLibrary: vi.fn<() => Promise<SavedSqlLibrary>>(),
+  loadSavedSqlFile: vi.fn<(id: string) => Promise<SavedSqlFile | null>>(),
+  saveSavedSqlFolder: vi.fn<(folder: SavedSqlFolder) => Promise<SavedSqlFolder>>(),
+  saveSavedSqlFile: vi.fn<(file: SavedSqlFile) => Promise<SavedSqlFile>>(),
+  syncSavedSqlDirectory: vi.fn<() => Promise<void>>(),
+}));
+
+vi.mock("@/lib/backend/api", () => apiMock);
+
+beforeEach(() => {
+  setActivePinia(createPinia());
+  apiMock.loadSavedSqlLibrary.mockResolvedValue({ folders: [], files: [] });
+  apiMock.loadSavedSqlFile.mockResolvedValue(null);
+  apiMock.saveSavedSqlFolder.mockImplementation(async (folder) => folder);
+  apiMock.saveSavedSqlFile.mockImplementation(async (file) => file);
+  apiMock.syncSavedSqlDirectory.mockResolvedValue();
+  vi.clearAllMocks();
+});
+
+test("concurrent saved SQL folder creates reuse the same pending folder", async () => {
+  let resolveSave: ((folder: SavedSqlFolder) => void) | undefined;
+  apiMock.saveSavedSqlFolder.mockImplementation(
+    (folder) =>
+      new Promise<SavedSqlFolder>((resolve) => {
+        resolveSave = () => resolve(folder);
+      }),
+  );
+
+  const store = useSavedSqlStore();
+  const first = store.createFolder("conn-1", "新建文件夹");
+  const second = store.createFolder("conn-1", "新建文件夹");
+
+  assert.equal(apiMock.saveSavedSqlFolder.mock.calls.length, 1);
+  resolveSave?.(apiMock.saveSavedSqlFolder.mock.calls[0]![0]);
+
+  const [firstFolder, secondFolder] = await Promise.all([first, second]);
+
+  assert.equal(firstFolder.id, secondFolder.id);
+  assert.equal(store.folders.length, 1);
+  assert.equal(store.folders[0]?.id, firstFolder.id);
+});
+
+test("saved SQL summaries load file content on demand", async () => {
+  const summaryFile: SavedSqlFile = {
+    id: "sql-1",
+    connectionId: "conn-1",
+    name: "large.sql",
+    database: "",
+    sql: "",
+    sqlLoaded: false,
+    createdAt: "2026-06-27T00:00:00.000Z",
+    updatedAt: "2026-06-27T00:00:00.000Z",
+  };
+  const loadedFile = { ...summaryFile, sql: "SELECT 1;", sqlLoaded: true };
+  apiMock.loadSavedSqlLibrary.mockResolvedValue({ folders: [], files: [summaryFile] });
+  apiMock.loadSavedSqlFile.mockResolvedValue(loadedFile);
+
+  const store = useSavedSqlStore();
+  await store.initFromStorage();
+
+  assert.equal(store.files[0]?.sql, "");
+  assert.equal(store.files[0]?.sqlLoaded, false);
+
+  const hydrated = await store.ensureFileContent("sql-1");
+
+  assert.equal(hydrated?.sql, "SELECT 1;");
+  assert.equal(store.files[0]?.sql, "SELECT 1;");
+  assert.equal(apiMock.loadSavedSqlFile.mock.calls.length, 1);
+});
+
+test("saving an existing SQL file without folderId keeps its folder", async () => {
+  const file: SavedSqlFile = {
+    id: "sql-1",
+    connectionId: "conn-1",
+    folderId: "folder-1",
+    name: "query.sql",
+    database: "db",
+    sql: "SELECT 1;",
+    sqlLoaded: true,
+    createdAt: "2026-06-27T00:00:00.000Z",
+    updatedAt: "2026-06-27T00:00:00.000Z",
+  };
+  apiMock.loadSavedSqlLibrary.mockResolvedValue({ folders: [], files: [file] });
+
+  const store = useSavedSqlStore();
+  await store.initFromStorage();
+
+  const saved = await store.saveFile({
+    id: "sql-1",
+    connectionId: "conn-2",
+    name: "query.sql",
+    database: "other_db",
+    sql: "SELECT 1;",
+  });
+
+  assert.equal(saved.folderId, "folder-1");
+  assert.equal(apiMock.saveSavedSqlFile.mock.calls[0]?.[0].folderId, "folder-1");
+  assert.equal(store.getFile("sql-1")?.folderId, "folder-1");
+});
+
+test("saving an existing SQL file with root folder explicitly moves it to root", async () => {
+  const file: SavedSqlFile = {
+    id: "sql-1",
+    connectionId: "conn-1",
+    folderId: "folder-1",
+    name: "query.sql",
+    database: "db",
+    sql: "SELECT 1;",
+    sqlLoaded: true,
+    createdAt: "2026-06-27T00:00:00.000Z",
+    updatedAt: "2026-06-27T00:00:00.000Z",
+  };
+  apiMock.loadSavedSqlLibrary.mockResolvedValue({ folders: [], files: [file] });
+
+  const store = useSavedSqlStore();
+  await store.initFromStorage();
+
+  const saved = await store.saveFile({
+    id: "sql-1",
+    connectionId: "conn-1",
+    folderId: undefined,
+    name: "query.sql",
+    database: "db",
+    sql: "SELECT 1;",
+  });
+
+  assert.equal(saved.folderId, undefined);
+  assert.equal(apiMock.saveSavedSqlFile.mock.calls[0]?.[0].folderId, undefined);
+  assert.equal(store.getFile("sql-1")?.folderId, undefined);
+});
+
+test("moving multiple saved SQL files to a folder keeps existing target files", async () => {
+  const files: SavedSqlFile[] = [
+    {
+      id: "sql-1",
+      connectionId: "conn-1",
+      name: "one.sql",
+      database: "db",
+      sql: "SELECT 1;",
+      orderIndex: 0,
+      createdAt: "2026-06-27T00:00:00.000Z",
+      updatedAt: "2026-06-27T00:00:00.000Z",
+    },
+    {
+      id: "sql-2",
+      connectionId: "conn-1",
+      name: "two.sql",
+      database: "db",
+      sql: "SELECT 2;",
+      orderIndex: 1,
+      createdAt: "2026-06-27T00:00:00.000Z",
+      updatedAt: "2026-06-27T00:00:00.000Z",
+    },
+    {
+      id: "sql-3",
+      connectionId: "conn-1",
+      folderId: "folder-1",
+      name: "three.sql",
+      database: "db",
+      sql: "SELECT 3;",
+      orderIndex: 0,
+      createdAt: "2026-06-27T00:00:00.000Z",
+      updatedAt: "2026-06-27T00:00:00.000Z",
+    },
+  ];
+  apiMock.loadSavedSqlLibrary.mockResolvedValue({ folders: [], files });
+
+  const store = useSavedSqlStore();
+  await store.initFromStorage();
+
+  await store.moveFilesToFolder(["sql-1", "sql-2"], "folder-1");
+
+  assert.deepEqual(
+    store.filesInFolder("folder-1").map((file) => [file.id, file.folderId, file.orderIndex]),
+    [
+      ["sql-3", "folder-1", 0],
+      ["sql-1", "folder-1", 1],
+      ["sql-2", "folder-1", 2],
+    ],
+  );
+  assert.deepEqual(
+    store.filesWithoutFolder().map((file) => file.id),
+    [],
+  );
+});
+
+test("moving selected files already in the target folder keeps them in place", async () => {
+  const files: SavedSqlFile[] = [
+    {
+      id: "sql-1",
+      connectionId: "conn-1",
+      name: "one.sql",
+      database: "db",
+      sql: "SELECT 1;",
+      orderIndex: 0,
+      createdAt: "2026-06-27T00:00:00.000Z",
+      updatedAt: "2026-06-27T00:00:00.000Z",
+    },
+    {
+      id: "sql-2",
+      connectionId: "conn-1",
+      folderId: "folder-1",
+      name: "two.sql",
+      database: "db",
+      sql: "SELECT 2;",
+      orderIndex: 0,
+      createdAt: "2026-06-27T00:00:00.000Z",
+      updatedAt: "2026-06-27T00:00:00.000Z",
+    },
+  ];
+  apiMock.loadSavedSqlLibrary.mockResolvedValue({ folders: [], files });
+
+  const store = useSavedSqlStore();
+  await store.initFromStorage();
+
+  await store.moveFilesToFolder(["sql-1", "sql-2"], "folder-1");
+
+  assert.deepEqual(
+    store.filesInFolder("folder-1").map((file) => file.id),
+    ["sql-2", "sql-1"],
+  );
+});
+
+test("renaming a saved SQL file syncs linked tab titles", async () => {
+  const file: SavedSqlFile = {
+    id: "sql-1",
+    connectionId: "conn-1",
+    name: "draft.sql",
+    database: "db",
+    sql: "SELECT 1;",
+    sqlLoaded: true,
+    createdAt: "2026-06-27T00:00:00.000Z",
+    updatedAt: "2026-06-27T00:00:00.000Z",
+  };
+  apiMock.loadSavedSqlLibrary.mockResolvedValue({ folders: [], files: [file] });
+
+  const savedSqlStore = useSavedSqlStore();
+  await savedSqlStore.initFromStorage();
+
+  const queryStore = useQueryStore();
+  const tabId = queryStore.openSavedSql(file);
+  const tab = queryStore.tabs.find((item) => item.id === tabId);
+  assert.equal(tab?.title, "draft.sql");
+
+  await savedSqlStore.renameFile("sql-1", "revenue.sql");
+
+  assert.equal(savedSqlStore.getFile("sql-1")?.name, "revenue.sql");
+  assert.equal(queryStore.tabs.find((item) => item.id === tabId)?.title, "revenue.sql");
+});
+
+test("renaming a saved SQL tab syncs the library file name", async () => {
+  const file: SavedSqlFile = {
+    id: "sql-1",
+    connectionId: "conn-1",
+    name: "draft.sql",
+    database: "db",
+    sql: "SELECT 1;",
+    sqlLoaded: true,
+    createdAt: "2026-06-27T00:00:00.000Z",
+    updatedAt: "2026-06-27T00:00:00.000Z",
+  };
+  apiMock.loadSavedSqlLibrary.mockResolvedValue({ folders: [], files: [file] });
+
+  const savedSqlStore = useSavedSqlStore();
+  await savedSqlStore.initFromStorage();
+
+  const queryStore = useQueryStore();
+  const tabId = queryStore.openSavedSql(file);
+
+  assert.equal(queryStore.renameTab(tabId, " Revenue checks "), true);
+  await Promise.resolve();
+
+  assert.equal(queryStore.tabs.find((item) => item.id === tabId)?.title, "Revenue checks.sql");
+  assert.equal(savedSqlStore.getFile("sql-1")?.name, "Revenue checks.sql");
+  assert.equal(apiMock.saveSavedSqlFile.mock.calls.at(-1)?.[0].name, "Revenue checks.sql");
+});
+
+test("renaming a saved SQL tab keeps uppercase .SQL extension without double-appending", async () => {
+  const file: SavedSqlFile = {
+    id: "sql-1",
+    connectionId: "conn-1",
+    name: "report.SQL",
+    database: "db",
+    sql: "SELECT 1;",
+    sqlLoaded: true,
+    createdAt: "2026-06-27T00:00:00.000Z",
+    updatedAt: "2026-06-27T00:00:00.000Z",
+  };
+  apiMock.loadSavedSqlLibrary.mockResolvedValue({ folders: [], files: [file] });
+
+  const savedSqlStore = useSavedSqlStore();
+  await savedSqlStore.initFromStorage();
+
+  const queryStore = useQueryStore();
+  const tabId = queryStore.openSavedSql(file);
+
+  assert.equal(queryStore.renameTab(tabId, "report.SQL"), true);
+  await Promise.resolve();
+
+  assert.equal(queryStore.tabs.find((item) => item.id === tabId)?.title, "report.SQL");
+  assert.equal(savedSqlStore.getFile("sql-1")?.name, "report.SQL");
+  assert.equal(apiMock.saveSavedSqlFile.mock.calls.length, 0);
+});
+
+test("renaming a saved SQL tab reverts title when persistence fails", async () => {
+  const file: SavedSqlFile = {
+    id: "sql-1",
+    connectionId: "conn-1",
+    name: "draft.sql",
+    database: "db",
+    sql: "SELECT 1;",
+    sqlLoaded: true,
+    createdAt: "2026-06-27T00:00:00.000Z",
+    updatedAt: "2026-06-27T00:00:00.000Z",
+  };
+  apiMock.loadSavedSqlLibrary.mockResolvedValue({ folders: [], files: [file] });
+
+  const savedSqlStore = useSavedSqlStore();
+  await savedSqlStore.initFromStorage();
+
+  const queryStore = useQueryStore();
+  const tabId = queryStore.openSavedSql(file);
+
+  apiMock.saveSavedSqlFile.mockRejectedValueOnce(new Error("disk full"));
+  assert.equal(queryStore.renameTab(tabId, "broken"), true);
+  await vi.waitFor(() => queryStore.tabs.find((item) => item.id === tabId)?.title === "draft.sql");
+
+  assert.equal(savedSqlStore.getFile("sql-1")?.name, "draft.sql");
+});
diff --git a/packages/app-tests/schemaDiff.test.ts b/packages/app-tests/schemaDiff.test.ts
new file mode 100644
index 0000000..ed11bb0
--- /dev/null
+++ b/packages/app-tests/schemaDiff.test.ts
@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { buildDeploySqlForObjects, convertToSchemaDiffObjects, schemaDiffDeployTargetSchema, type TableDiff } from "../../apps/desktop/src/lib/schema/schemaDiff.ts";
+
+test("uses generated sync SQL for modified table deployment", () => {
+  const tableDiffs: TableDiff[] = [
+    {
+      type: "modified",
+      objectType: "table",
+      name: "users",
+      ddl: "CREATE TABLE `users` (`name` varchar(64));",
+      syncSql: "-- Alter table: users\nALTER TABLE `users`\n  MODIFY COLUMN `name` varchar(128) NOT NULL;",
+      columns: [
+        {
+          type: "modified",
+          name: "name",
+          changes: ["type: varchar(64) -> varchar(128)"],
+        },
+      ],
+    },
+  ];
+
+  const objects = convertToSchemaDiffObjects(tableDiffs);
+  const deploySql = buildDeploySqlForObjects(objects);
+
+  assert.equal(
+    deploySql,
+    "-- Alter table: users\nALTER TABLE `users`\n  MODIFY COLUMN `name` varchar(128) NOT NULL;\n",
+  );
+  assert.equal(deploySql.includes("CREATE TABLE"), false);
+});
+
+test("falls back to source DDL when object sync SQL is unavailable", () => {
+  const tableDiffs: TableDiff[] = [
+    {
+      type: "added",
+      objectType: "table",
+      name: "users",
+      ddl: "CREATE TABLE `users` (`id` int);",
+    },
+  ];
+
+  const objects = convertToSchemaDiffObjects(tableDiffs);
+
+  assert.equal(buildDeploySqlForObjects(objects), "-- Create table: users\nCREATE TABLE `users` (`id` int);\n");
+});
+
+test("uses mysql target database as schema diff deploy qualifier", () => {
+  assert.equal(schemaDiffDeployTargetSchema("mysql", "target_db", ""), "target_db");
+  assert.equal(schemaDiffDeployTargetSchema("mysql", "target_db", "  "), "target_db");
+  assert.equal(schemaDiffDeployTargetSchema("mysql", "target_db", "explicit_schema"), "explicit_schema");
+  assert.equal(schemaDiffDeployTargetSchema("sqlite", "main", ""), undefined);
+});
diff --git a/packages/app-tests/schemaDiffTableFilter.test.ts b/packages/app-tests/schemaDiffTableFilter.test.ts
new file mode 100644
index 0000000..cdb5540
--- /dev/null
+++ b/packages/app-tests/schemaDiffTableFilter.test.ts
@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { compileSchemaDiffTableFilter, filterSchemaDiffTables } from "../../apps/desktop/src/lib/schema/schemaDiffTableFilter.ts";
+import type { TableInfo } from "../../apps/desktop/src/types/database.ts";
+import { normalizeSchemaDiffCompareOptions } from "../../apps/desktop/src/types/schemaDiff.ts";
+
+function table(name: string): TableInfo {
+  return {
+    name,
+    table_type: "BASE TABLE",
+    comment: null,
+    parent_schema: null,
+    parent_name: null,
+  };
+}
+
+test("filters schema diff tables before detail loading", () => {
+  const filter = compileSchemaDiffTableFilter(
+    normalizeSchemaDiffCompareOptions({
+      tableIncludePattern: "^user_|^orders$",
+      tableExcludePattern: "_bak$",
+      tableFilterPriority: "exclude",
+    }),
+  );
+
+  const result = filterSchemaDiffTables([table("user_profile"), table("user_profile_bak"), table("orders"), table("audit_log")], [table("user_profile"), table("orders_bak"), table("orders")], filter);
+
+  assert.deepEqual(
+    result.sourceTables.map((item) => item.name),
+    ["user_profile", "orders"],
+  );
+  assert.deepEqual(
+    result.targetTables.map((item) => item.name),
+    ["user_profile", "orders"],
+  );
+});
+
+test("lets include priority keep tables that also match exclude", () => {
+  const filter = compileSchemaDiffTableFilter(
+    normalizeSchemaDiffCompareOptions({
+      tableIncludePattern: "^user_",
+      tableExcludePattern: "_bak$",
+      tableFilterPriority: "include",
+    }),
+  );
+
+  const result = filterSchemaDiffTables([table("user_profile_bak")], [], filter);
+
+  assert.deepEqual(
+    result.sourceTables.map((item) => item.name),
+    ["user_profile_bak"],
+  );
+});
+
+test("rejects invalid schema diff table regex", () => {
+  assert.throws(
+    () =>
+      compileSchemaDiffTableFilter(
+        normalizeSchemaDiffCompareOptions({
+          tableIncludePattern: "[",
+        }),
+      ),
+    /Invalid include table name regex/,
+  );
+});
diff --git a/packages/app-tests/schemaOptions.test.ts b/packages/app-tests/schemaOptions.test.ts
new file mode 100644
index 0000000..6f1906e
--- /dev/null
+++ b/packages/app-tests/schemaOptions.test.ts
@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { schemaOptionsForConnection } from "../../apps/desktop/src/composables/useSchemaOptions.ts";
+
+test("schema options respect Oracle visible database filters", () => {
+  assert.deepEqual(
+    schemaOptionsForConnection(["CAM", "00010", "00012", "SYS"], {
+      db_type: "oracle",
+      visible_databases: ["CAM", "00010"],
+    }),
+    ["00010", "CAM"],
+  );
+});
+
+test("schema options keep default system-schema filtering without explicit filters", () => {
+  assert.deepEqual(
+    schemaOptionsForConnection(["CAM", "SYS", "SYSTEM"], {
+      db_type: "oracle",
+      visible_databases: undefined,
+    }),
+    ["CAM"],
+  );
+});
+
+test("schema options respect visible schemas for OceanBase Oracle mode", () => {
+  assert.deepEqual(
+    schemaOptionsForConnection(
+      ["ORAAUDITOR", "APP", "SYS"],
+      {
+        db_type: "oceanbase-oracle",
+        visible_schemas: { SYS: ["ORAAUDITOR"] },
+      },
+      "SYS",
+    ),
+    ["ORAAUDITOR"],
+  );
+});
+
+test("schema options support legacy visible database filters for OceanBase Oracle mode", () => {
+  assert.deepEqual(
+    schemaOptionsForConnection(["ORAAUDITOR", "APP", "SYS"], {
+      db_type: "oceanbase-oracle",
+      visible_databases: ["ORAAUDITOR"],
+    }),
+    ["ORAAUDITOR"],
+  );
+});
diff --git a/packages/app-tests/schemaTreeCache.test.ts b/packages/app-tests/schemaTreeCache.test.ts
new file mode 100644
index 0000000..ca98572
--- /dev/null
+++ b/packages/app-tests/schemaTreeCache.test.ts
@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { SCHEMA_TREE_CACHE_TTL_MS, decodeSchemaTreeCache, encodeSchemaTreeCache } from "../../apps/desktop/src/lib/metadata/schemaTreeCache.ts";
+
+const children = [{ id: "conn:db", label: "db", type: "database" }];
+const now = Date.parse("2026-05-17T10:00:00.000Z");
+
+test("wraps tree children with a cache timestamp", () => {
+  assert.deepEqual(encodeSchemaTreeCache(children, now), {
+    version: 2,
+    cachedAt: "2026-05-17T10:00:00.000Z",
+    children,
+  });
+});
+
+test("treats recent schema tree cache envelopes as fresh", () => {
+  const payload = encodeSchemaTreeCache(children, now);
+
+  assert.deepEqual(decodeSchemaTreeCache(payload, now + SCHEMA_TREE_CACHE_TTL_MS - 1), {
+    children,
+    isStale: false,
+  });
+});
+
+test("treats expired schema tree cache envelopes as stale", () => {
+  const payload = encodeSchemaTreeCache(children, now);
+
+  assert.deepEqual(decodeSchemaTreeCache(payload, now + SCHEMA_TREE_CACHE_TTL_MS + 1), {
+    children,
+    isStale: true,
+  });
+});
+
+test("keeps legacy array cache readable but stale", () => {
+  assert.deepEqual(decodeSchemaTreeCache(children, now), {
+    children,
+    isStale: true,
+  });
+});
+
+test("rejects invalid schema tree cache payloads", () => {
+  assert.equal(decodeSchemaTreeCache({ version: 2, cachedAt: "bad", children: "nope" }, now), null);
+  assert.equal(decodeSchemaTreeCache({ version: 1, cachedAt: "2026-05-17T10:00:00.000Z", children }, now), null);
+});
diff --git a/packages/app-tests/settingsStore.test.ts b/packages/app-tests/settingsStore.test.ts
new file mode 100644
index 0000000..82078f7
--- /dev/null
+++ b/packages/app-tests/settingsStore.test.ts
@@ -0,0 +1,524 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { createPinia, setActivePinia } from "pinia";
+import { DEFAULT_SQL_FORMATTER_SETTINGS } from "../../apps/desktop/src/lib/sql/sqlFormatterConfig.ts";
+import { DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS } from "../../apps/desktop/src/lib/table/tableColumnTemplates.ts";
+import { DEFAULT_UI_FONT_FAMILY, SYSTEM_UI_FONT_FAMILY } from "../../apps/desktop/src/lib/app/appFonts.ts";
+import { tableOpenPageLimit } from "../../apps/desktop/src/lib/table/tableOpenPageLimit.ts";
+import { AI_PROVIDER_PRESETS, DEFAULT_EDITOR_SETTINGS, normalizeAiConfig, normalizeEditorSettings, useSettingsStore } from "../../apps/desktop/src/stores/settingsStore.ts";
+
+const OLD_FONT_SIZE_KEY = "dbx-query-editor-font-size";
+
+async function withMockLocalStorage(initial: Record<string, string>, run: () => void | Promise<void>) {
+  const previousDescriptor = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  const values = new Map(Object.entries(initial));
+  const localStorageMock = {
+    getItem: (key: string) => values.get(key) ?? null,
+    setItem: (key: string, value: string) => {
+      values.set(key, value);
+    },
+    removeItem: (key: string) => {
+      values.delete(key);
+    },
+    clear: () => {
+      values.clear();
+    },
+  };
+
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: localStorageMock,
+  });
+
+  try {
+    await run();
+  } finally {
+    if (previousDescriptor) {
+      Object.defineProperty(globalThis, "localStorage", previousDescriptor);
+    } else {
+      delete (globalThis as any).localStorage;
+    }
+  }
+}
+
+test("normalizes saved query result page size", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.pageSize, 100);
+  assert.equal(normalizeEditorSettings({ pageSize: 5000 }).pageSize, 5000);
+  assert.equal(normalizeEditorSettings({ pageSize: 200000 }).pageSize, 100000);
+  assert.equal(normalizeEditorSettings({ pageSize: 0 }).pageSize, 100);
+});
+
+test("uses dedicated default row limit for table opens", () => {
+  assert.equal(tableOpenPageLimit(), 100);
+});
+
+test("defaults export batch size to 2000 rows", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.exportBatchSize, 2000);
+  assert.equal(normalizeEditorSettings({}).exportBatchSize, 2000);
+  assert.equal(normalizeEditorSettings({ exportBatchSize: 2000 }).exportBatchSize, 2000);
+});
+
+test("migrates the legacy saved export batch default to 2000 once", async () => {
+  await withMockLocalStorage({ "dbx-editor-settings": JSON.stringify({ exportBatchSize: 10000 }) }, async () => {
+    setActivePinia(createPinia());
+    const store = useSettingsStore();
+    await store.initEditorSettings();
+
+    assert.equal(store.editorSettings.exportBatchSize, 2000);
+    assert.equal(localStorage.getItem("dbx-editor-settings"), null);
+    assert.equal(JSON.parse(localStorage.getItem("dbx-app-state:editor_settings") || "{}").exportBatchSize, 2000);
+  });
+});
+
+test("keeps a manually saved 10000 export batch size after migration", async () => {
+  await withMockLocalStorage(
+    {
+      "dbx-editor-settings": JSON.stringify({ exportBatchSize: 10000 }),
+      "dbx-export-batch-size-default-migrated-v1": "1",
+    },
+    async () => {
+      setActivePinia(createPinia());
+      const store = useSettingsStore();
+      await store.initEditorSettings();
+
+      assert.equal(store.editorSettings.exportBatchSize, 10000);
+    },
+  );
+});
+
+test("defaults query-result export row limit settings", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.exportRowLimitEnabled, false);
+  assert.equal(DEFAULT_EDITOR_SETTINGS.exportRowLimit, 100000);
+  assert.equal(DEFAULT_EDITOR_SETTINGS.queryExportKeysetOptimizationEnabled, true);
+  assert.equal(normalizeEditorSettings({}).exportRowLimitEnabled, false);
+  assert.equal(normalizeEditorSettings({}).exportRowLimit, 100000);
+  assert.equal(normalizeEditorSettings({}).queryExportKeysetOptimizationEnabled, true);
+  assert.equal(normalizeEditorSettings({ exportRowLimitEnabled: true }).exportRowLimitEnabled, true);
+  assert.equal(normalizeEditorSettings({ exportRowLimitEnabled: "nope" as any }).exportRowLimitEnabled, false);
+  assert.equal(normalizeEditorSettings({ exportRowLimit: 250000 }).exportRowLimit, 250000);
+  assert.equal(normalizeEditorSettings({ exportRowLimit: 10 }).exportRowLimit, 100000);
+  assert.equal(normalizeEditorSettings({ queryExportKeysetOptimizationEnabled: false }).queryExportKeysetOptimizationEnabled, false);
+  assert.equal(normalizeEditorSettings({ queryExportKeysetOptimizationEnabled: "nope" as any }).queryExportKeysetOptimizationEnabled, true);
+});
+
+test("normalizes editor theme settings", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.theme, "app");
+  assert.equal(normalizeEditorSettings({}).theme, "app");
+  assert.equal(normalizeEditorSettings({ theme: "app" }).theme, "app");
+  assert.equal(normalizeEditorSettings({ theme: "vscode-light" }).theme, "vscode-light");
+  assert.equal(normalizeEditorSettings({ theme: "invalid" as any }).theme, DEFAULT_EDITOR_SETTINGS.theme);
+});
+
+test("defaults UI font family to the app sans stack", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.uiFontFamily, DEFAULT_UI_FONT_FAMILY);
+  assert.equal(normalizeEditorSettings({}).uiFontFamily, DEFAULT_UI_FONT_FAMILY);
+  assert.equal(normalizeEditorSettings({ uiFontFamily: "" as any }).uiFontFamily, DEFAULT_UI_FONT_FAMILY);
+});
+
+test("keeps saved UI font family", () => {
+  const uiFontFamily = `"Aptos", system-ui, sans-serif`;
+  assert.equal(normalizeEditorSettings({ uiFontFamily } as any).uiFontFamily, uiFontFamily);
+  assert.equal(normalizeEditorSettings({ uiFontFamily: SYSTEM_UI_FONT_FAMILY } as any).uiFontFamily, SYSTEM_UI_FONT_FAMILY);
+});
+
+test("defaults dangerous SQL confirmation to enabled", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.confirmDangerousSqlExecution, true);
+  assert.equal(normalizeEditorSettings({}).confirmDangerousSqlExecution, true);
+  assert.equal(normalizeEditorSettings({ confirmDangerousSqlExecution: false }).confirmDangerousSqlExecution, false);
+});
+
+test("defaults statement run buttons to enabled and preserves saved booleans", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.showStatementRunButtons, true);
+  assert.equal(normalizeEditorSettings({}).showStatementRunButtons, true);
+  assert.equal(normalizeEditorSettings({ showStatementRunButtons: false }).showStatementRunButtons, false);
+  assert.equal(normalizeEditorSettings({ showStatementRunButtons: "nope" as any }).showStatementRunButtons, true);
+});
+
+test("normalizes SQL snippet enabled state", () => {
+  const settings = normalizeEditorSettings({
+    snippets: [
+      { id: "legacy", label: "legacy", prefix: "leg", body: "SELECT 1;" },
+      { id: "disabled", label: "disabled", prefix: "dis", body: "SELECT 2;", enabled: false },
+      { id: "invalid", label: "invalid", prefix: "inv", body: "SELECT 3;", enabled: "nope" },
+    ],
+  } as any);
+
+  assert.deepEqual(settings.snippets, [
+    { id: "legacy", label: "legacy", prefix: "leg", body: "SELECT 1;", enabled: true },
+    { id: "disabled", label: "disabled", prefix: "dis", body: "SELECT 2;", enabled: false },
+    { id: "invalid", label: "invalid", prefix: "inv", body: "SELECT 3;", enabled: true },
+  ]);
+});
+
+test("defaults unsaved SQL close confirmation to enabled", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.confirmUnsavedSqlClose, true);
+  assert.equal(normalizeEditorSettings({}).confirmUnsavedSqlClose, true);
+  assert.equal(normalizeEditorSettings({ confirmUnsavedSqlClose: false }).confirmUnsavedSqlClose, false);
+});
+
+test("defaults Vim mode to off and preserves saved booleans", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.vimModeEnabled, false);
+  assert.equal(normalizeEditorSettings({}).vimModeEnabled, false);
+  assert.equal(normalizeEditorSettings({ vimModeEnabled: true }).vimModeEnabled, true);
+  assert.equal(normalizeEditorSettings({ vimModeEnabled: "yes" as any }).vimModeEnabled, false);
+});
+
+test("defaults auto-close brackets to on and preserves saved booleans", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.autoCloseBrackets, true);
+  assert.equal(normalizeEditorSettings({}).autoCloseBrackets, true);
+  assert.equal(normalizeEditorSettings({ autoCloseBrackets: false }).autoCloseBrackets, false);
+  assert.equal(normalizeEditorSettings({ autoCloseBrackets: "nope" as any }).autoCloseBrackets, true);
+});
+
+test("defaults update notifications to enabled", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.updateNotificationsEnabled, true);
+  assert.equal(normalizeEditorSettings({}).updateNotificationsEnabled, true);
+  assert.equal(normalizeEditorSettings({ updateNotificationsEnabled: false } as any).updateNotificationsEnabled, false);
+});
+
+test("defaults sidebar table search to disabled and preserves saved booleans", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.sidebarTableSearchEnabled, false);
+  assert.equal(normalizeEditorSettings({}).sidebarTableSearchEnabled, false);
+  assert.equal(normalizeEditorSettings({ sidebarTableSearchEnabled: true }).sidebarTableSearchEnabled, true);
+  assert.equal(normalizeEditorSettings({ sidebarTableSearchEnabled: false }).sidebarTableSearchEnabled, false);
+  assert.equal(normalizeEditorSettings({ sidebarTableSearchEnabled: "yes" as any }).sidebarTableSearchEnabled, false);
+});
+
+test("defaults shortcut settings", () => {
+  const settings = normalizeEditorSettings({});
+
+  assert.equal(settings.shortcuts.executeSql, "Mod+Enter");
+  assert.equal(settings.shortcuts.saveSql, "Mod+S");
+  assert.equal(settings.shortcuts.copyCurrentRow, "Mod+D");
+  assert.equal(settings.shortcuts.deleteCurrentRow, "Delete");
+  assert.equal(settings.shortcuts.newQuery, "Mod+T");
+  assert.equal(settings.shortcuts.openSettings, "Mod+,");
+  assert.equal(settings.shortcuts.focusSearch, "Mod+F");
+  assert.equal(settings.shortcuts.zoomInUi, "Mod+=");
+  assert.equal(settings.shortcuts.zoomOutUi, "Mod+-");
+  assert.equal(settings.shortcuts.resetUiZoom, "Mod+0");
+  assert.equal(settings.shortcuts.refreshData, "F5");
+  assert.equal(settings.shortcuts.toggleTranspose, "Tab");
+  assert.equal(settings.shortcuts.copySidebarSelection, "Mod+C");
+  assert.equal(settings.shortcuts.pasteSidebarSelection, "Mod+V");
+  assert.equal(settings.shortcuts.editSidebarConnection, "Mod+E");
+});
+
+test("keeps saved shortcut overrides", () => {
+  const settings = normalizeEditorSettings({
+    shortcuts: {
+      executeSql: "Shift+Mod+Enter",
+      copyCurrentRow: "Alt+Shift+D",
+      deleteCurrentRow: "Backspace",
+      newQuery: "Shift+Mod+N",
+      openSettings: "Shift+Mod+P",
+      zoomInUi: "Alt+Mod+=",
+      editSidebarConnection: "Alt+E",
+    } as any,
+  });
+
+  assert.equal(settings.shortcuts.executeSql, "Shift+Mod+Enter");
+  assert.equal(settings.shortcuts.copyCurrentRow, "Alt+Shift+D");
+  assert.equal(settings.shortcuts.deleteCurrentRow, "Backspace");
+  assert.equal(settings.shortcuts.newQuery, "Shift+Mod+N");
+  assert.equal(settings.shortcuts.openSettings, "Shift+Mod+P");
+  assert.equal(settings.shortcuts.zoomInUi, "Alt+Mod+=");
+  assert.equal(settings.shortcuts.editSidebarConnection, "Alt+E");
+  assert.equal(settings.shortcuts.saveSql, "Mod+S");
+});
+
+test("defaults sidebar activation to single click", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.sidebarActivation, "single");
+  assert.equal(normalizeEditorSettings({}).sidebarActivation, "single");
+});
+
+test("defaults active tab sidebar selection to off", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.autoSelectActiveSidebarNode, false);
+  assert.equal(normalizeEditorSettings({}).autoSelectActiveSidebarNode, false);
+});
+
+test("defaults sidebar horizontal scroll to off", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.sidebarAllowHorizontalScroll, false);
+  assert.equal(normalizeEditorSettings({}).sidebarAllowHorizontalScroll, false);
+});
+
+test("defaults data grid header display settings", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.showColumnCommentsInHeader, true);
+  assert.equal(DEFAULT_EDITOR_SETTINGS.compactColumnHeaderActions, true);
+  assert.equal(normalizeEditorSettings({}).showColumnCommentsInHeader, true);
+  assert.equal(normalizeEditorSettings({}).compactColumnHeaderActions, true);
+});
+
+test("keeps saved data grid header display settings", () => {
+  const settings = normalizeEditorSettings({
+    showColumnCommentsInHeader: true,
+    compactColumnHeaderActions: false,
+  } as any);
+
+  assert.equal(settings.showColumnCommentsInHeader, true);
+  assert.equal(settings.compactColumnHeaderActions, false);
+});
+
+test("normalizes data grid render mode", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.dataGridRenderMode, "canvas");
+  assert.equal(normalizeEditorSettings({}).dataGridRenderMode, "canvas");
+  assert.equal(normalizeEditorSettings({ dataGridRenderMode: "canvas" as any }).dataGridRenderMode, "canvas");
+  assert.equal(normalizeEditorSettings({ dataGridRenderMode: "unknown" as any }).dataGridRenderMode, "canvas");
+});
+
+test("normalizes table font size", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.tableFontSize, 13);
+  assert.equal(normalizeEditorSettings({}).tableFontSize, 13);
+  assert.equal(normalizeEditorSettings({ tableFontSize: 12 }).tableFontSize, 12);
+  assert.equal(normalizeEditorSettings({ tableFontSize: 14.6 }).tableFontSize, 15);
+  assert.equal(normalizeEditorSettings({ tableFontSize: 8 }).tableFontSize, 8);
+  assert.equal(normalizeEditorSettings({ tableFontSize: 20 }).tableFontSize, 16);
+  assert.equal(normalizeEditorSettings({ tableFontSize: "large" as any }).tableFontSize, 13);
+});
+
+test("normalizes table structure editor density", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.structureEditorDensity, "compact");
+  assert.equal(normalizeEditorSettings({}).structureEditorDensity, "compact");
+  assert.equal(normalizeEditorSettings({ structureEditorDensity: "standard" }).structureEditorDensity, "standard");
+  assert.equal(normalizeEditorSettings({ structureEditorDensity: "comfortable" }).structureEditorDensity, "comfortable");
+  assert.equal(normalizeEditorSettings({ structureEditorDensity: "invalid" as any }).structureEditorDensity, "compact");
+});
+
+test("normalizes table column template fields", () => {
+  assert.deepEqual(DEFAULT_EDITOR_SETTINGS.tableColumnTemplateFields, DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS);
+  assert.deepEqual(DEFAULT_EDITOR_SETTINGS.tableColumnTemplateFields, []);
+  assert.deepEqual(normalizeEditorSettings({}).tableColumnTemplateFields, DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS);
+  const normalizedTemplateFields = normalizeEditorSettings({ tableColumnTemplateFields: [" tenant_id | mysql:bigint ", "request_id | mysql:varchar(64)", "TENANT_ID | mysql:bigint", ""] } as any).tableColumnTemplateFields;
+  assert.equal(
+    normalizedTemplateFields.find((field) => field.startsWith("tenant_id")),
+    "tenant_id | mysql:bigint",
+  );
+  assert.equal(
+    normalizedTemplateFields.find((field) => field.startsWith("request_id")),
+    "request_id | mysql:varchar(64)",
+  );
+  assert.deepEqual(normalizeEditorSettings({ tableColumnTemplateFields: [] } as any).tableColumnTemplateFields, DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS);
+});
+
+test("normalizes grid drawer widths", () => {
+  assert.equal(DEFAULT_EDITOR_SETTINGS.tableInfoDrawerWidth, 320);
+  assert.equal(DEFAULT_EDITOR_SETTINGS.cellDetailDrawerWidth, 380);
+  assert.equal(DEFAULT_EDITOR_SETTINGS.cellDetailPanelLayout, "bottom");
+  assert.equal(DEFAULT_EDITOR_SETTINGS.cellDetailJsonFormatted, false);
+  assert.equal(normalizeEditorSettings({}).tableInfoDrawerWidth, 320);
+  assert.equal(normalizeEditorSettings({}).cellDetailDrawerWidth, 380);
+  assert.equal(normalizeEditorSettings({}).cellDetailPanelLayout, "bottom");
+  assert.equal(normalizeEditorSettings({}).cellDetailJsonFormatted, false);
+  assert.equal(normalizeEditorSettings({ tableInfoDrawerWidth: 200 } as any).tableInfoDrawerWidth, 240);
+  assert.equal(normalizeEditorSettings({ cellDetailDrawerWidth: 200 } as any).cellDetailDrawerWidth, 260);
+  assert.equal(normalizeEditorSettings({ tableInfoDrawerWidth: 1000 } as any).tableInfoDrawerWidth, 900);
+  assert.equal(normalizeEditorSettings({ cellDetailDrawerWidth: 456.7 } as any).cellDetailDrawerWidth, 457);
+  assert.equal(normalizeEditorSettings({ cellDetailPanelLayout: "right" } as any).cellDetailPanelLayout, "right");
+  assert.equal(normalizeEditorSettings({ cellDetailPanelLayout: "invalid" } as any).cellDetailPanelLayout, "bottom");
+  assert.equal(normalizeEditorSettings({ cellDetailJsonFormatted: true } as any).cellDetailJsonFormatted, true);
+  assert.equal(normalizeEditorSettings({ cellDetailJsonFormatted: "true" } as any).cellDetailJsonFormatted, false);
+});
+
+test("keeps saved active tab sidebar selection", () => {
+  assert.equal(normalizeEditorSettings({ autoSelectActiveSidebarNode: true } as any).autoSelectActiveSidebarNode, true);
+});
+
+test("keeps saved sidebar horizontal scroll preference", () => {
+  assert.equal(normalizeEditorSettings({ sidebarAllowHorizontalScroll: true } as any).sidebarAllowHorizontalScroll, true);
+});
+
+test("keeps saved sidebar activation", () => {
+  assert.equal(normalizeEditorSettings({ sidebarActivation: "double" } as any).sidebarActivation, "double");
+  assert.equal(normalizeEditorSettings({ sidebarActivation: "invalid" } as any).sidebarActivation, "single");
+});
+
+test("normalizes saved sidebar hidden table prefixes", () => {
+  assert.deepEqual(DEFAULT_EDITOR_SETTINGS.sidebarHiddenTablePrefixes, []);
+  assert.deepEqual(normalizeEditorSettings({ sidebarHiddenTablePrefixes: [" app_", "app_", "", "ods."] } as any).sidebarHiddenTablePrefixes, ["app_", "ods."]);
+});
+
+test("defaults column formatters to an empty record", () => {
+  assert.deepEqual(DEFAULT_EDITOR_SETTINGS.columnFormatters, {});
+  assert.deepEqual(normalizeEditorSettings({}).columnFormatters, {});
+});
+
+test("keeps only valid saved column formatter configs", () => {
+  const settings = normalizeEditorSettings({
+    columnFormatters: {
+      "conn::db::public::users::created_at": { kind: "datetime", unit: "auto", pattern: "YYYY-MM-DD HH:mm:ss" },
+      "conn::db::public::users::bad_date": { kind: "datetime", unit: "bogus" },
+      "conn::db::public::users::name": { kind: "mask", prefix: 2, suffix: 2 },
+      "conn::db::public::users::payload": { kind: "json-path", path: "$.user.name" },
+      "conn::db::public::users::invalid_json": { kind: "json-path", path: "user.name" },
+      "conn::db::public::users::status": { kind: "custom-ref", formatterId: "fmt_1" },
+    },
+    customColumnFormatters: {
+      fmt_1: { id: "fmt_1", name: "Status label", template: "status:${value}" },
+      fmt_empty_name: { id: "fmt_empty_name", name: "", template: "x:${value}" },
+      fmt_empty_template: { id: "fmt_empty_template", name: "Broken", template: "" },
+    },
+  } as any);
+
+  assert.deepEqual(settings.columnFormatters, {
+    "conn::db::public::users::created_at": { kind: "datetime", unit: "auto", pattern: "YYYY-MM-DD HH:mm:ss" },
+    "conn::db::public::users::name": { kind: "mask", prefix: 2, suffix: 2 },
+    "conn::db::public::users::payload": { kind: "json-path", path: "$.user.name" },
+    "conn::db::public::users::status": { kind: "custom-ref", formatterId: "fmt_1" },
+  });
+  assert.deepEqual(settings.customColumnFormatters, {
+    fmt_1: { id: "fmt_1", name: "Status label", template: "status:${value}" },
+  });
+});
+
+test("AI provider presets include common hosted and local providers", () => {
+  assert.equal(AI_PROVIDER_PRESETS.gemini.endpoint, "https://generativelanguage.googleapis.com");
+  assert.equal(AI_PROVIDER_PRESETS.gemini.model, "gemini-1.5-pro");
+  assert.equal(AI_PROVIDER_PRESETS.deepseek.endpoint, "https://api.deepseek.com/v1");
+  assert.equal(AI_PROVIDER_PRESETS.deepseek.model, "deepseek-v4-flash");
+  assert.equal(AI_PROVIDER_PRESETS.qwen.endpoint, "https://dashscope.aliyuncs.com/compatible-mode/v1");
+  assert.equal(AI_PROVIDER_PRESETS.ollama.endpoint, "http://localhost:11434/v1");
+  assert.equal(AI_PROVIDER_PRESETS.ollama.requiresApiKey, false);
+  assert.equal(AI_PROVIDER_PRESETS.claude.authMethod, "api-key");
+  assert.equal(AI_PROVIDER_PRESETS.openai.authMethod, "bearer");
+  assert.equal(AI_PROVIDER_PRESETS.openai.iconSlug, "openai");
+  assert.equal(AI_PROVIDER_PRESETS.deepseek.iconSlug, "deepseek");
+});
+
+test("normalizes legacy AI config and fills provider defaults", () => {
+  const legacy = normalizeAiConfig({
+    provider: "openai",
+    apiKey: "key",
+    endpoint: "https://api.openai.com/v1/chat/completions",
+    model: "gpt-4o",
+  } as any);
+
+  assert.equal(legacy.apiStyle, "completions");
+  assert.equal(legacy.provider, "openai");
+  assert.equal(legacy.apiKey, "key");
+  assert.equal(legacy.authMethod, "bearer");
+
+  const ollama = normalizeAiConfig({ provider: "ollama" } as any);
+  assert.equal(ollama.endpoint, "http://localhost:11434/v1");
+  assert.equal(ollama.model, "llama3.1");
+  assert.equal(ollama.apiKey, "");
+  assert.equal(ollama.authMethod, "bearer");
+
+  const claudeToken = normalizeAiConfig({ provider: "claude", apiKey: "token", authMethod: "bearer" } as any);
+  assert.equal(claudeToken.authMethod, "bearer");
+});
+
+test("infers legacy AI provider from saved endpoint and model", () => {
+  const deepseek = normalizeAiConfig({
+    apiKey: "key",
+    endpoint: "https://api.deepseek.com/anthropic/v1/messages",
+    model: "deepseek-v4-pro",
+  } as any);
+
+  assert.equal(deepseek.provider, "deepseek");
+  assert.equal(deepseek.endpoint, "https://api.deepseek.com/anthropic/v1/messages");
+  assert.equal(deepseek.model, "deepseek-v4-pro");
+});
+
+test("normalizeEditorSettings falls back to the default UI scale", () => {
+  const settings = normalizeEditorSettings({});
+
+  assert.equal(settings.uiScale, DEFAULT_EDITOR_SETTINGS.uiScale);
+});
+
+test("normalizeEditorSettings clamps UI scale into the supported range", () => {
+  assert.equal(normalizeEditorSettings({ uiScale: 0.2 }).uiScale, 0.75);
+  assert.equal(normalizeEditorSettings({ uiScale: 2.8 }).uiScale, 2);
+});
+
+test("normalizeEditorSettings keeps valid UI scales with two-decimal precision", () => {
+  assert.equal(normalizeEditorSettings({ uiScale: 1.125 }).uiScale, 1.13);
+});
+
+test("defaults SQL formatter settings", () => {
+  assert.deepEqual(DEFAULT_EDITOR_SETTINGS.sqlFormatter, DEFAULT_SQL_FORMATTER_SETTINGS);
+  assert.deepEqual(normalizeEditorSettings({}).sqlFormatter, DEFAULT_EDITOR_SETTINGS.sqlFormatter);
+});
+
+test("normalizes saved SQL formatter settings", () => {
+  assert.deepEqual(
+    normalizeEditorSettings({
+      sqlFormatter: {
+        keywordCase: "lower",
+        functionCase: "upper",
+        dataTypeCase: "upper",
+        useTabs: true,
+        tabWidth: 4,
+        logicalOperatorNewline: "after",
+        expressionWidth: 120,
+        linesBetweenQueries: 2,
+        denseOperators: true,
+        newlineBeforeSemicolon: true,
+      },
+    } as any).sqlFormatter,
+    {
+      ...DEFAULT_SQL_FORMATTER_SETTINGS,
+      keywordCase: "lower",
+      functionCase: "upper",
+      dataTypeCase: "upper",
+      useTabs: true,
+      tabWidth: 4,
+      logicalOperatorNewline: "after",
+      expressionWidth: 120,
+      linesBetweenQueries: 2,
+      denseOperators: true,
+      newlineBeforeSemicolon: true,
+    },
+  );
+});
+
+test("keeps SQL formatter default objects distinct", () => {
+  const normalized = normalizeEditorSettings({});
+
+  assert.notEqual(DEFAULT_EDITOR_SETTINGS.sqlFormatter, DEFAULT_SQL_FORMATTER_SETTINGS);
+  assert.notEqual(normalized.sqlFormatter, DEFAULT_EDITOR_SETTINGS.sqlFormatter);
+  assert.notEqual(normalized.sqlFormatter, DEFAULT_SQL_FORMATTER_SETTINGS);
+});
+
+test("does not leak default-loaded SQL formatter mutations into defaults", async () => {
+  await withMockLocalStorage({}, async () => {
+    setActivePinia(createPinia());
+    const store = useSettingsStore();
+    const editorDefaultKeywordCase = DEFAULT_EDITOR_SETTINGS.sqlFormatter.keywordCase;
+    const formatterDefaultKeywordCase = DEFAULT_SQL_FORMATTER_SETTINGS.keywordCase;
+
+    try {
+      store.editorSettings.sqlFormatter.keywordCase = "lower";
+
+      assert.notEqual(store.editorSettings.sqlFormatter, DEFAULT_EDITOR_SETTINGS.sqlFormatter);
+      assert.notEqual(store.editorSettings.sqlFormatter, DEFAULT_SQL_FORMATTER_SETTINGS);
+      assert.equal(DEFAULT_EDITOR_SETTINGS.sqlFormatter.keywordCase, editorDefaultKeywordCase);
+      assert.equal(DEFAULT_SQL_FORMATTER_SETTINGS.keywordCase, formatterDefaultKeywordCase);
+    } finally {
+      DEFAULT_EDITOR_SETTINGS.sqlFormatter.keywordCase = editorDefaultKeywordCase;
+      DEFAULT_SQL_FORMATTER_SETTINGS.keywordCase = formatterDefaultKeywordCase;
+    }
+  });
+});
+
+test("does not leak migrated SQL formatter mutations into defaults", async () => {
+  await withMockLocalStorage({ [OLD_FONT_SIZE_KEY]: "18" }, async () => {
+    setActivePinia(createPinia());
+    const store = useSettingsStore();
+    await store.initEditorSettings();
+    const editorDefaultKeywordCase = DEFAULT_EDITOR_SETTINGS.sqlFormatter.keywordCase;
+    const formatterDefaultKeywordCase = DEFAULT_SQL_FORMATTER_SETTINGS.keywordCase;
+
+    try {
+      assert.equal(store.editorSettings.fontSize, 18);
+      store.editorSettings.sqlFormatter.keywordCase = "lower";
+
+      assert.notEqual(store.editorSettings.sqlFormatter, DEFAULT_EDITOR_SETTINGS.sqlFormatter);
+      assert.notEqual(store.editorSettings.sqlFormatter, DEFAULT_SQL_FORMATTER_SETTINGS);
+      assert.equal(DEFAULT_EDITOR_SETTINGS.sqlFormatter.keywordCase, editorDefaultKeywordCase);
+      assert.equal(DEFAULT_SQL_FORMATTER_SETTINGS.keywordCase, formatterDefaultKeywordCase);
+    } finally {
+      DEFAULT_EDITOR_SETTINGS.sqlFormatter.keywordCase = editorDefaultKeywordCase;
+      DEFAULT_SQL_FORMATTER_SETTINGS.keywordCase = formatterDefaultKeywordCase;
+    }
+  });
+});
diff --git a/packages/app-tests/sidebarActiveTabTarget.test.ts b/packages/app-tests/sidebarActiveTabTarget.test.ts
new file mode 100644
index 0000000..c67cef4
--- /dev/null
+++ b/packages/app-tests/sidebarActiveTabTarget.test.ts
@@ -0,0 +1,464 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { activeTabSidebarTarget, findNodePathForTarget, findSidebarNodeForActiveTab, scrollTopForSidebarNode, shouldScrollActiveSidebarSelection } from "../../apps/desktop/src/lib/sidebar/sidebarActiveTabTarget.ts";
+import type { FlatTreeNode } from "../../apps/desktop/src/composables/useFlatTree.ts";
+import type { QueryTab, TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+function flat(node: TreeNode, depth = 0): FlatTreeNode {
+  return { id: node.id, node, depth, type: node.type };
+}
+
+test("findNodePathForTarget handles loaded, unloaded, and MySQL schema fallback trees", () => {
+  const cases = [
+    {
+      name: "nested table path",
+      tree: [
+        {
+          id: "conn-1",
+          label: "mysql.example.test",
+          type: "connection",
+          connectionId: "conn-1",
+          isExpanded: true,
+          children: [
+            {
+              id: "conn-1:__user_admin",
+              label: "tree.userAdmin",
+              type: "user-admin",
+              connectionId: "conn-1",
+              database: "",
+              isExpanded: false,
+            },
+            {
+              id: "conn-1:app",
+              label: "app",
+              type: "database",
+              connectionId: "conn-1",
+              database: "app",
+              isExpanded: true,
+              children: [
+                {
+                  id: "conn-1:app:__tables",
+                  label: "tree.tables",
+                  type: "group-tables",
+                  connectionId: "conn-1",
+                  database: "app",
+                  isExpanded: true,
+                  children: [
+                    {
+                      id: "conn-1:app:__tables:users",
+                      label: "users",
+                      type: "table",
+                      connectionId: "conn-1",
+                      database: "app",
+                      isExpanded: false,
+                      children: [],
+                      pinned: false,
+                    },
+                  ],
+                  pinned: false,
+                },
+              ],
+              pinned: false,
+            },
+          ],
+          pinned: false,
+        },
+      ],
+      target: {
+        type: "table",
+        connectionId: "conn-1",
+        database: "app",
+        tableName: "users",
+      },
+      expectedPath: ["conn-1", "conn-1:app", "conn-1:app:__tables", "conn-1:app:__tables:users"],
+    },
+    {
+      name: "unloaded connection tree",
+      tree: [
+        {
+          id: "mysql-conn-1",
+          label: "mysql.example.test",
+          type: "connection",
+          connectionId: "mysql-conn-1",
+          isExpanded: false,
+          children: [
+            {
+              id: "mysql-conn-1:__user_admin",
+              label: "tree.userAdmin",
+              type: "user-admin",
+              connectionId: "mysql-conn-1",
+              database: "",
+              isExpanded: false,
+            },
+          ],
+          pinned: false,
+        },
+      ],
+      target: {
+        type: "query-context",
+        connectionId: "mysql-conn-1",
+        database: "app_prd",
+      },
+      expectedPath: null,
+    },
+    {
+      name: "MySQL schema fallback to database",
+      tree: [
+        {
+          id: "mysql-conn-1",
+          label: "mysql.example.test",
+          type: "connection",
+          connectionId: "mysql-conn-1",
+          isExpanded: true,
+          children: [
+            {
+              id: "mysql-conn-1:app_dev",
+              label: "app_dev",
+              type: "database",
+              connectionId: "mysql-conn-1",
+              database: "app_dev",
+              isExpanded: true,
+              children: [
+                {
+                  id: "mysql-conn-1:app_dev:__tables",
+                  label: "tree.tables",
+                  type: "group-tables",
+                  connectionId: "mysql-conn-1",
+                  database: "app_dev",
+                  isExpanded: true,
+                  children: [
+                    {
+                      id: "mysql-conn-1:app_dev:__tables:enum_info",
+                      label: "enum_info",
+                      type: "table",
+                      tableType: "BASE TABLE",
+                      connectionId: "mysql-conn-1",
+                      database: "app_dev",
+                      isExpanded: false,
+                      children: [],
+                      pinned: false,
+                    },
+                  ],
+                  pinned: false,
+                },
+              ],
+              pinned: false,
+            },
+          ],
+        },
+      ],
+      target: {
+        type: "table",
+        connectionId: "mysql-conn-1",
+        database: "app_dev",
+        schema: "app_dev",
+        tableName: "enum_info",
+      },
+      expectedPath: [
+        "mysql-conn-1",
+        "mysql-conn-1:app_dev",
+        "mysql-conn-1:app_dev:__tables",
+        "mysql-conn-1:app_dev:__tables:enum_info",
+      ],
+    },
+  ] satisfies Array<{
+    name: string;
+    tree: TreeNode[];
+    target: Parameters<typeof findNodePathForTarget>[0];
+    expectedPath: string[] | null;
+  }>;
+
+  for (const item of cases) {
+    const path = findNodePathForTarget(item.target, item.tree);
+    assert.deepEqual(path?.map((node) => node.id) ?? null, item.expectedPath, item.name);
+  }
+});
+
+test("data tabs target the matching visible table or view node", () => {
+  const tab: QueryTab = {
+    id: "tab-1",
+    title: "users",
+    connectionId: "conn-1",
+    database: "app",
+    sql: "",
+    isExecuting: false,
+    mode: "data",
+    tableMeta: { schema: "public", tableName: "users", columns: [], primaryKeys: [] },
+  };
+  const users: TreeNode = {
+    id: "users-node",
+    label: "users",
+    type: "table",
+    connectionId: "conn-1",
+    database: "app",
+    schema: "public",
+  };
+
+  assert.deepEqual(activeTabSidebarTarget(tab), {
+    type: "table",
+    connectionId: "conn-1",
+    database: "app",
+    schema: "public",
+    tableName: "users",
+  });
+  assert.equal(findSidebarNodeForActiveTab(tab, [flat(users)])?.id, "users-node");
+});
+
+test("mongo tabs target the matching visible collection node", () => {
+  const tab: QueryTab = {
+    id: "tab-1",
+    title: "app.events",
+    connectionId: "conn-1",
+    database: "app",
+    sql: "events",
+    isExecuting: false,
+    mode: "mongo",
+  };
+  const collection: TreeNode = {
+    id: "events-node",
+    label: "events",
+    type: "mongo-collection",
+    connectionId: "conn-1",
+    database: "app",
+  };
+
+  assert.equal(findSidebarNodeForActiveTab(tab, [flat(collection)])?.id, "events-node");
+});
+
+test("GridFS tabs target the shared GridFS sidebar entry", () => {
+  const managerTab: QueryTab = {
+    id: "tab-gridfs",
+    title: "GridFS",
+    connectionId: "conn-1",
+    database: "app",
+    sql: "",
+    isExecuting: false,
+    mode: "mongo-gridfs" as QueryTab["mode"],
+  };
+  const bucketTab: QueryTab = {
+    id: "tab-bucket",
+    title: "app.receipts",
+    connectionId: "conn-1",
+    database: "app",
+    sql: "receipts",
+    isExecuting: false,
+    mode: "mongo-bucket",
+    mongoBucket: {
+      bucketName: "receipts",
+    },
+  };
+  const gridFsNode: TreeNode = {
+    id: "gridfs-node",
+    label: "GridFS",
+    type: "mongo-gridfs" as TreeNode["type"],
+    connectionId: "conn-1",
+    database: "app",
+  };
+
+  assert.deepEqual(activeTabSidebarTarget(managerTab), {
+    type: "mongo-gridfs",
+    connectionId: "conn-1",
+    database: "app",
+  });
+  assert.deepEqual(activeTabSidebarTarget(bucketTab), {
+    type: "mongo-gridfs",
+    connectionId: "conn-1",
+    database: "app",
+  });
+  assert.equal(findSidebarNodeForActiveTab(managerTab, [flat(gridFsNode)])?.id, "gridfs-node");
+  assert.equal(findSidebarNodeForActiveTab(bucketTab, [flat(gridFsNode)])?.id, "gridfs-node");
+});
+
+test("MQ tabs with a selected tenant target the matching tenant node", () => {
+  const tab: QueryTab = {
+    id: "tab-1",
+    title: "Apache Pulsar Admin",
+    connectionId: "conn-1",
+    database: "",
+    sql: "",
+    isExecuting: false,
+    mode: "mq",
+    mqTenant: "public",
+  };
+  const tenant: TreeNode = {
+    id: "tenant-node",
+    label: "public",
+    type: "mq-tenant",
+    connectionId: "conn-1",
+    mqTenant: "public",
+  };
+
+  assert.deepEqual(activeTabSidebarTarget(tab), {
+    type: "mq-tenant",
+    connectionId: "conn-1",
+    tenant: "public",
+  });
+  assert.equal(findSidebarNodeForActiveTab(tab, [flat(tenant)])?.id, "tenant-node");
+});
+
+test("ZooKeeper tabs target the matching visible zookeeper root node", () => {
+  const tab: QueryTab = {
+    id: "tab-1",
+    title: "ZooKeeper Keys",
+    connectionId: "conn-1",
+    database: "",
+    sql: "",
+    isExecuting: false,
+    mode: "zookeeper",
+  };
+  const root: TreeNode = {
+    id: "zookeeper-root",
+    label: "Keys",
+    type: "zookeeper-root",
+    connectionId: "conn-1",
+  };
+
+  assert.deepEqual(activeTabSidebarTarget(tab), {
+    type: "zookeeper-root",
+    connectionId: "conn-1",
+  });
+  assert.equal(findSidebarNodeForActiveTab(tab, [flat(root)])?.id, "zookeeper-root");
+});
+
+test("Nacos tabs target the matching namespace node", () => {
+  const tab: QueryTab = {
+    id: "tab-1",
+    title: "Nacos:dev",
+    connectionId: "conn-1",
+    database: "",
+    sql: "",
+    isExecuting: false,
+    mode: "nacos",
+    nacosNamespace: "dev",
+    nacosNamespaceName: "Development",
+  };
+  const namespace: TreeNode = {
+    id: "namespace-node",
+    label: "Development",
+    type: "nacos-namespace",
+    connectionId: "conn-1",
+    nacosNamespace: "dev",
+  };
+
+  assert.deepEqual(activeTabSidebarTarget(tab), {
+    type: "nacos-namespace",
+    connectionId: "conn-1",
+    namespace: "dev",
+  });
+  assert.equal(findSidebarNodeForActiveTab(tab, [flat(namespace)])?.id, "namespace-node");
+});
+
+test("saved SQL tabs target the matching visible saved SQL file node", () => {
+  const tab: QueryTab = {
+    id: "tab-1",
+    title: "report.sql",
+    connectionId: "conn-1",
+    database: "app",
+    sql: "select 1",
+    savedSqlId: "sql-1",
+    isExecuting: false,
+    mode: "query",
+  };
+  const file: TreeNode = { id: "file-node", label: "report.sql", type: "saved-sql-file", savedSqlId: "sql-1" };
+
+  assert.deepEqual(activeTabSidebarTarget(tab), { type: "saved-sql-file", savedSqlId: "sql-1" });
+  assert.equal(findSidebarNodeForActiveTab(tab, [flat(file)])?.id, "file-node");
+});
+
+test("query tabs target their database node in the sidebar", () => {
+  const tab: QueryTab = {
+    id: "tab-1",
+    title: "Query 1",
+    connectionId: "conn-1",
+    database: "app",
+    sql: "select 1",
+    isExecuting: false,
+    mode: "query",
+  };
+
+  assert.deepEqual(activeTabSidebarTarget(tab), {
+    type: "query-context",
+    connectionId: "conn-1",
+    database: "app",
+    schema: undefined,
+  });
+});
+
+test("query tabs without connectionId have no sidebar target", () => {
+  const tab: QueryTab = {
+    id: "tab-1",
+    title: "Query 1",
+    connectionId: "",
+    database: "",
+    sql: "select 1",
+    isExecuting: false,
+    mode: "query",
+  };
+
+  assert.equal(activeTabSidebarTarget(tab), null);
+});
+test("sidebar target lookup only uses the current flat visible tree", () => {
+  const tab: QueryTab = {
+    id: "tab-1",
+    title: "users",
+    connectionId: "conn-1",
+    database: "app",
+    sql: "",
+    isExecuting: false,
+    mode: "data",
+    tableMeta: { tableName: "users", columns: [], primaryKeys: [] },
+  };
+  const collapsedParentOnly: TreeNode = {
+    id: "db-node",
+    label: "app",
+    type: "database",
+    connectionId: "conn-1",
+    database: "app",
+  };
+
+  assert.equal(findSidebarNodeForActiveTab(tab, [flat(collapsedParentOnly)]), null);
+});
+
+test("sidebar node scrolling keeps visible rows in place and reveals hidden rows", () => {
+  assert.equal(scrollTopForSidebarNode({ index: 2, currentScrollTop: 0, viewportHeight: 140 }), 0);
+  assert.equal(scrollTopForSidebarNode({ index: 20, currentScrollTop: 0, viewportHeight: 140 }), 448);
+  assert.equal(scrollTopForSidebarNode({ index: 1, currentScrollTop: 280, viewportHeight: 140 }), 28);
+  assert.equal(scrollTopForSidebarNode({ index: 11, currentScrollTop: 300, viewportHeight: 140, topOcclusionHeight: 28 }), 280);
+});
+
+test("sidebar node scrolling supports top and smart locate alignment", () => {
+  assert.equal(scrollTopForSidebarNode({ index: 20, currentScrollTop: 0, viewportHeight: 140, align: "top" }), 560);
+  assert.equal(scrollTopForSidebarNode({ index: 20, currentScrollTop: 0, viewportHeight: 140, align: "smart" }), 523);
+  assert.equal(scrollTopForSidebarNode({ index: 11, currentScrollTop: 300, viewportHeight: 140, topOcclusionHeight: 28, align: "smart" }), 252);
+  assert.equal(scrollTopForSidebarNode({ index: 0, currentScrollTop: 300, viewportHeight: 140, topOcclusionHeight: 28, align: "smart" }), 0);
+});
+
+test("active sidebar selection only scrolls on tab or setting changes", () => {
+  assert.equal(
+    shouldScrollActiveSidebarSelection({
+      activeTabId: "tab-1",
+      previousActiveTabId: "tab-1",
+      autoSelectEnabled: true,
+      previousAutoSelectEnabled: true,
+    }),
+    false,
+  );
+  assert.equal(
+    shouldScrollActiveSidebarSelection({
+      activeTabId: "tab-2",
+      previousActiveTabId: "tab-1",
+      autoSelectEnabled: true,
+      previousAutoSelectEnabled: true,
+    }),
+    true,
+  );
+  assert.equal(
+    shouldScrollActiveSidebarSelection({
+      activeTabId: "tab-1",
+      previousActiveTabId: "tab-1",
+      autoSelectEnabled: true,
+      previousAutoSelectEnabled: false,
+    }),
+    true,
+  );
+});
diff --git a/packages/app-tests/sidebarConnectionSelection.test.ts b/packages/app-tests/sidebarConnectionSelection.test.ts
new file mode 100644
index 0000000..82bdf1d
--- /dev/null
+++ b/packages/app-tests/sidebarConnectionSelection.test.ts
@@ -0,0 +1,69 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { connectionPasteTargetGroupId, selectedConnectionClipboardNodes, selectedConnectionClipboardTargets, selectedConnectionEditTarget } from "../../apps/desktop/src/lib/sidebar/sidebarConnectionSelection.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+function connectionNode(id: string): TreeNode {
+  return {
+    id,
+    label: id,
+    type: "connection",
+    connectionId: id,
+  };
+}
+
+test("uses selected connections as clipboard targets only when the selection is connection-only", () => {
+  const first = connectionNode("conn-1");
+  const second = connectionNode("conn-2");
+  const table: TreeNode = {
+    id: "table-1",
+    label: "users",
+    type: "table",
+    connectionId: "conn-1",
+    database: "main",
+  };
+
+  assert.deepEqual(selectedConnectionClipboardNodes([first, second]).map((node) => node.connectionId), ["conn-1", "conn-2"]);
+  assert.deepEqual(selectedConnectionClipboardNodes([first, table]), []);
+  assert.deepEqual(selectedConnectionClipboardTargets(first, [first, second]).map((node) => node.connectionId), ["conn-1", "conn-2"]);
+  assert.deepEqual(selectedConnectionClipboardTargets(first, [first, table]).map((node) => node.connectionId), ["conn-1"]);
+});
+
+test("resolves connection paste target groups from the selected sidebar node", () => {
+  const group: TreeNode = {
+    id: "group-1",
+    label: "Group",
+    type: "connection-group",
+  };
+  const connection = connectionNode("conn-1");
+  const table: TreeNode = {
+    id: "table-1",
+    label: "users",
+    type: "table",
+    connectionId: "conn-1",
+    database: "main",
+  };
+
+  const groupIdForConnection = (connectionId: string) => (connectionId === "conn-1" ? "group-1" : null);
+
+  assert.equal(connectionPasteTargetGroupId(group, groupIdForConnection), "group-1");
+  assert.equal(connectionPasteTargetGroupId(connection, groupIdForConnection), "group-1");
+  assert.equal(connectionPasteTargetGroupId(table, groupIdForConnection), null);
+  assert.equal(connectionPasteTargetGroupId(null, groupIdForConnection), null);
+});
+
+test("allows editing only a single selected connection", () => {
+  const first = connectionNode("conn-1");
+  const second = connectionNode("conn-2");
+  const table: TreeNode = {
+    id: "table-1",
+    label: "users",
+    type: "table",
+    connectionId: "conn-1",
+    database: "main",
+  };
+
+  assert.equal(selectedConnectionEditTarget(first, [first])?.connectionId, "conn-1");
+  assert.equal(selectedConnectionEditTarget(first, [first, second]), null);
+  assert.equal(selectedConnectionEditTarget(table, [table]), null);
+});
diff --git a/packages/app-tests/sidebarDatabaseOpenState.test.ts b/packages/app-tests/sidebarDatabaseOpenState.test.ts
new file mode 100644
index 0000000..0da6e0c
--- /dev/null
+++ b/packages/app-tests/sidebarDatabaseOpenState.test.ts
@@ -0,0 +1,43 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { canCloseSidebarDatabaseConnection, isSidebarDatabaseOpened } from "../../apps/desktop/src/lib/sidebar/sidebarDatabaseOpenState.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+function databaseNode(id: string): TreeNode {
+  return {
+    id,
+    label: "app",
+    type: "database",
+    connectionId: "conn-1",
+    database: "app",
+  };
+}
+
+test("database open state is based on the database node children cache", () => {
+  const opened = databaseNode("conn-1:app");
+  const unopened = databaseNode("conn-1:other");
+  unopened.label = "other";
+  unopened.database = "other";
+
+  const loadedIds = new Set([opened.id]);
+  const isLoaded = (id: string) => loadedIds.has(id);
+
+  assert.equal(isSidebarDatabaseOpened(opened, isLoaded), true);
+  assert.equal(canCloseSidebarDatabaseConnection(opened, isLoaded), true);
+  assert.equal(isSidebarDatabaseOpened(unopened, isLoaded), false);
+  assert.equal(canCloseSidebarDatabaseConnection(unopened, isLoaded), false);
+});
+
+test("non-SQL database nodes can be marked open without showing close database connection", () => {
+  const mongoDatabase: TreeNode = {
+    id: "mongo:app",
+    label: "app",
+    type: "mongo-db",
+    connectionId: "mongo",
+    database: "app",
+  };
+  const isLoaded = (id: string) => id === mongoDatabase.id;
+
+  assert.equal(isSidebarDatabaseOpened(mongoDatabase, isLoaded), true);
+  assert.equal(canCloseSidebarDatabaseConnection(mongoDatabase, isLoaded), false);
+});
diff --git a/packages/app-tests/sidebarLayout.test.ts b/packages/app-tests/sidebarLayout.test.ts
new file mode 100644
index 0000000..313ab05
--- /dev/null
+++ b/packages/app-tests/sidebarLayout.test.ts
@@ -0,0 +1,369 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import {
+  reconcileLayout,
+  buildTreeNodesFromLayout,
+  createGroup,
+  deleteGroup,
+  renameGroup,
+  moveConnectionToGroup,
+  reorderEntry,
+  toggleGroupCollapsed,
+  appendConnectionToLayout,
+  removeConnectionFromSidebarLayout,
+  emptyLayout,
+  remapSidebarLayoutConnectionIds,
+  collapseAllGroups,
+} from "../../apps/desktop/src/lib/sidebar/sidebarLayout.ts";
+import type { ConnectionConfig, SidebarLayout } from "../../apps/desktop/src/types/database.ts";
+
+function conn(id: string, name?: string): ConnectionConfig {
+  return {
+    id,
+    name: name || id,
+    db_type: "postgres",
+    host: "localhost",
+    port: 5432,
+    username: "user",
+    password: "",
+  };
+}
+
+function groupConnectionIds(entry: SidebarLayout["order"][number]): string[] {
+  assert.equal(entry.type, "group");
+  return (entry.children ?? []).filter((child) => child.type === "connection").map((child) => child.id);
+}
+
+// --- reconcileLayout ---
+
+test("reconcileLayout returns all connections ungrouped when layout is null", () => {
+  const result = reconcileLayout(["a", "b", "c"], null);
+  assert.deepEqual(result.groups, []);
+  assert.deepEqual(result.order, [
+    { type: "connection", id: "a" },
+    { type: "connection", id: "b" },
+    { type: "connection", id: "c" },
+  ]);
+});
+
+test("reconcileLayout appends new connections not in layout", () => {
+  const layout: SidebarLayout = {
+    groups: [],
+    order: [{ type: "connection", id: "a" }],
+  };
+  const result = reconcileLayout(["a", "b"], layout);
+  assert.equal(result.order.length, 2);
+  assert.deepEqual(result.order[1], { type: "connection", id: "b" });
+});
+
+test("reconcileLayout removes stale connections from layout", () => {
+  const layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "Group", collapsed: false }],
+    order: [
+      { type: "group", id: "g1", connectionIds: ["a", "removed"] },
+      { type: "connection", id: "b" },
+    ],
+  };
+  const result = reconcileLayout(["a", "b"], layout);
+  const groupEntry = result.order.find((e) => e.type === "group");
+  assert.ok(groupEntry && groupEntry.type === "group");
+  assert.deepEqual(groupConnectionIds(groupEntry), ["a"]);
+  assert.equal(result.order.length, 2);
+});
+
+test("reconcileLayout removes groups with no order entry", () => {
+  const layout: SidebarLayout = {
+    groups: [
+      { id: "g1", name: "Used", collapsed: false },
+      { id: "g2", name: "Orphan", collapsed: false },
+    ],
+    order: [{ type: "group", id: "g1", connectionIds: ["a"] }],
+  };
+  const result = reconcileLayout(["a"], layout);
+  assert.equal(result.groups.length, 1);
+  assert.equal(result.groups[0].id, "g1");
+});
+
+test("remapSidebarLayoutConnectionIds preserves imported grouping with new connection ids", () => {
+  const layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "Imported", collapsed: false }],
+    order: [
+      { type: "connection", id: "old-root" },
+      { type: "group", id: "g1", connectionIds: ["old-a", "old-b"] },
+    ],
+  };
+
+  const remapped = remapSidebarLayoutConnectionIds(
+    layout,
+    new Map([
+      ["old-root", "new-root"],
+      ["old-a", "new-a"],
+      ["old-b", "new-b"],
+    ]),
+  );
+  const reconciled = reconcileLayout(["new-root", "new-a", "new-b"], remapped);
+
+  assert.deepEqual(reconciled.order, [
+    { type: "connection", id: "new-root" },
+    {
+      type: "group",
+      id: "g1",
+      children: [
+        { type: "connection", id: "new-a" },
+        { type: "connection", id: "new-b" },
+      ],
+    },
+  ]);
+});
+
+// --- buildTreeNodesFromLayout ---
+
+test("buildTreeNodesFromLayout creates group nodes with connection children", () => {
+  const layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "Production", collapsed: false }],
+    order: [
+      { type: "group", id: "g1", connectionIds: ["a", "b"] },
+      { type: "connection", id: "c" },
+    ],
+  };
+  const connections = [conn("a", "Server A"), conn("b", "Server B"), conn("c", "Server C")];
+  const nodes = buildTreeNodesFromLayout(layout, connections, new Set());
+
+  assert.equal(nodes.length, 2);
+  assert.equal(nodes[0].type, "connection-group");
+  assert.equal(nodes[0].label, "Production");
+  assert.equal(nodes[0].children?.length, 2);
+  assert.equal(nodes[0].isExpanded, true);
+  assert.equal(nodes[1].type, "connection");
+  assert.equal(nodes[1].id, "c");
+});
+
+test("buildTreeNodesFromLayout respects collapsed groups", () => {
+  const layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "G", collapsed: true }],
+    order: [{ type: "group", id: "g1", connectionIds: ["a"] }],
+  };
+  const nodes = buildTreeNodesFromLayout(layout, [conn("a")], new Set());
+  assert.equal(nodes[0].isExpanded, false);
+});
+
+test("buildTreeNodesFromLayout applies pinning within groups", () => {
+  const layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "G", collapsed: false }],
+    order: [{ type: "group", id: "g1", connectionIds: ["a", "b"] }],
+  };
+  const nodes = buildTreeNodesFromLayout(layout, [conn("a"), conn("b")], new Set(["b"]));
+  const children = nodes[0].children!;
+  assert.equal(children[0].id, "b");
+  assert.equal(children[1].id, "a");
+});
+
+// --- createGroup ---
+
+test("createGroup adds a new empty group", () => {
+  const layout = emptyLayout();
+  const result = createGroup(layout, "Dev");
+  assert.equal(result.layout.groups.length, 1);
+  assert.equal(result.layout.groups[0].name, "Dev");
+  assert.equal(result.layout.order.length, 1);
+  assert.ok(result.layout.order[0].type === "group");
+});
+
+test("createGroup expands parent group when adding a subgroup", () => {
+  const layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "Parent", collapsed: true }],
+    order: [{ type: "group", id: "g1", children: [] }],
+  };
+
+  const result = createGroup(layout, "Child", "g1");
+  const parentGroup = result.layout.groups.find((group) => group.id === "g1");
+  const parentEntry = result.layout.order[0];
+
+  assert.equal(parentGroup?.collapsed, false);
+  assert.equal(parentEntry.type, "group");
+  assert.deepEqual(parentEntry.type === "group" ? parentEntry.children : undefined, [{ type: "group", id: result.groupId, children: [] }]);
+});
+
+// --- renameGroup ---
+
+test("renameGroup updates group name", () => {
+  const { layout, groupId } = createGroup(emptyLayout(), "Old");
+  const result = renameGroup(layout, groupId, "New");
+  assert.equal(result.groups[0].name, "New");
+});
+
+// --- deleteGroup ---
+
+test("deleteGroup moves connections to ungrouped", () => {
+  let layout = emptyLayout();
+  layout = appendConnectionToLayout(layout, "a");
+  const { layout: withGroup, groupId } = createGroup(layout, "G");
+  const moved = moveConnectionToGroup(withGroup, "a", groupId);
+  const result = deleteGroup(moved, groupId);
+
+  assert.equal(result.groups.length, 0);
+  assert.deepEqual(result.order, [{ type: "connection", id: "a" }]);
+});
+
+// --- toggleGroupCollapsed ---
+
+test("toggleGroupCollapsed flips collapsed state", () => {
+  const { layout, groupId } = createGroup(emptyLayout(), "G");
+  assert.equal(layout.groups[0].collapsed, false);
+  const toggled = toggleGroupCollapsed(layout, groupId);
+  assert.equal(toggled.groups[0].collapsed, true);
+});
+
+test("collapseAllGroups keeps other groups collapsed after one group is reopened", async () => {
+  const layout: SidebarLayout = {
+    groups: [
+      { id: "g1", name: "G1", collapsed: false },
+      { id: "g2", name: "G2", collapsed: false },
+    ],
+    order: [
+      { type: "group", id: "g1", children: [{ type: "connection", id: "a" }] },
+      { type: "group", id: "g2", children: [{ type: "connection", id: "b" }] },
+    ],
+  };
+
+  const collapsed = collapseAllGroups(layout);
+  assert.deepEqual(
+    collapsed.groups.map((group) => [group.id, group.collapsed]),
+    [
+      ["g1", true],
+      ["g2", true],
+    ],
+  );
+
+  const reopenedFirst = toggleGroupCollapsed(collapsed, "g1");
+  assert.deepEqual(
+    reopenedFirst.groups.map((group) => [group.id, group.collapsed]),
+    [
+      ["g1", false],
+      ["g2", true],
+    ],
+  );
+});
+
+// --- moveConnectionToGroup ---
+
+test("moveConnectionToGroup moves connection into a group", () => {
+  let layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "G", collapsed: false }],
+    order: [
+      { type: "group", id: "g1", connectionIds: [] },
+      { type: "connection", id: "a" },
+    ],
+  };
+  const result = moveConnectionToGroup(layout, "a", "g1");
+  const groupEntry = result.order.find((e) => e.type === "group" && e.id === "g1");
+  assert.ok(groupEntry && groupEntry.type === "group");
+  assert.deepEqual(groupConnectionIds(groupEntry), ["a"]);
+  assert.equal(result.order.length, 1);
+});
+
+test("moveConnectionToGroup moves connection out of a group", () => {
+  let layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "G", collapsed: false }],
+    order: [{ type: "group", id: "g1", connectionIds: ["a"] }],
+  };
+  const result = moveConnectionToGroup(layout, "a", null);
+  assert.equal(result.order.length, 2);
+  assert.deepEqual(result.order[1], { type: "connection", id: "a" });
+});
+
+// --- reorderEntry ---
+
+test("reorderEntry moves connection before another", () => {
+  const layout: SidebarLayout = {
+    groups: [],
+    order: [
+      { type: "connection", id: "a" },
+      { type: "connection", id: "b" },
+      { type: "connection", id: "c" },
+    ],
+  };
+  const result = reorderEntry(layout, "c", "a", "before");
+  assert.deepEqual(
+    result.order.map((e) => e.id),
+    ["c", "a", "b"],
+  );
+});
+
+test("reorderEntry moves connection after another", () => {
+  const layout: SidebarLayout = {
+    groups: [],
+    order: [
+      { type: "connection", id: "a" },
+      { type: "connection", id: "b" },
+      { type: "connection", id: "c" },
+    ],
+  };
+  const result = reorderEntry(layout, "a", "b", "after");
+  assert.deepEqual(
+    result.order.map((e) => e.id),
+    ["b", "a", "c"],
+  );
+});
+
+test("reorderEntry moves connection inside a group", () => {
+  const layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "G", collapsed: false }],
+    order: [
+      { type: "group", id: "g1", connectionIds: [] },
+      { type: "connection", id: "a" },
+    ],
+  };
+  const result = reorderEntry(layout, "a", "g1", "inside");
+  assert.equal(result.order.length, 1);
+  const groupEntry = result.order[0];
+  assert.ok(groupEntry.type === "group");
+  assert.deepEqual(groupConnectionIds(groupEntry), ["a"]);
+});
+
+test("reorderEntry is a no-op when dragging to same position", () => {
+  const layout: SidebarLayout = {
+    groups: [],
+    order: [{ type: "connection", id: "a" }],
+  };
+  const result = reorderEntry(layout, "a", "a", "before");
+  assert.deepEqual(result, layout);
+});
+
+// --- appendConnectionToLayout / removeConnectionFromSidebarLayout ---
+
+test("appendConnectionToLayout adds to the end", () => {
+  const layout = appendConnectionToLayout(emptyLayout(), "x");
+  assert.equal(layout.order.length, 1);
+  assert.deepEqual(layout.order[0], { type: "connection", id: "x" });
+});
+
+test("appendConnectionToLayout adds to target group and expands it", () => {
+  const layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "G", collapsed: true }],
+    order: [{ type: "group", id: "g1", connectionIds: ["a"] }],
+  };
+  const result = appendConnectionToLayout(layout, "b", "g1");
+  const groupEntry = result.order[0];
+
+  assert.equal(result.groups[0].collapsed, false);
+  assert.ok(groupEntry.type === "group");
+  assert.deepEqual(groupConnectionIds(groupEntry), ["a", "b"]);
+});
+
+test("removeConnectionFromSidebarLayout removes from ungrouped", () => {
+  let layout = appendConnectionToLayout(emptyLayout(), "x");
+  layout = removeConnectionFromSidebarLayout(layout, "x");
+  assert.equal(layout.order.length, 0);
+});
+
+test("removeConnectionFromSidebarLayout removes from inside a group", () => {
+  const layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "G", collapsed: false }],
+    order: [{ type: "group", id: "g1", connectionIds: ["a", "b"] }],
+  };
+  const result = removeConnectionFromSidebarLayout(layout, "a");
+  const groupEntry = result.order[0];
+  assert.ok(groupEntry.type === "group");
+  assert.deepEqual(groupConnectionIds(groupEntry), ["b"]);
+});
diff --git a/packages/app-tests/sidebarLayoutNested.test.ts b/packages/app-tests/sidebarLayoutNested.test.ts
new file mode 100644
index 0000000..69363cc
--- /dev/null
+++ b/packages/app-tests/sidebarLayoutNested.test.ts
@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { buildTreeNodesFromLayout, deleteGroup, moveConnectionToGroup, reconcileLayout, reorderEntry } from "../../apps/desktop/src/lib/sidebar/sidebarLayout.ts";
+import type { ConnectionConfig, SidebarLayout } from "../../apps/desktop/src/types/database.ts";
+
+function conn(id: string): ConnectionConfig {
+  return {
+    id,
+    name: id,
+    db_type: "mysql",
+    host: "localhost",
+    port: 3306,
+    username: "root",
+    password: "",
+  };
+}
+
+test("reconciles legacy grouped layout into nested children", () => {
+  const layout: SidebarLayout = {
+    groups: [{ id: "g1", name: "Group", collapsed: false }],
+    order: [{ type: "group", id: "g1", connectionIds: ["c1"] }],
+  };
+
+  const reconciled = reconcileLayout(["c1", "c2"], layout);
+
+  assert.deepEqual(reconciled.order, [
+    { type: "group", id: "g1", children: [{ type: "connection", id: "c1" }] },
+    { type: "connection", id: "c2" },
+  ]);
+});
+
+test("builds nested connection group tree nodes", () => {
+  const layout: SidebarLayout = {
+    groups: [
+      { id: "g1", name: "Parent", collapsed: false },
+      { id: "g2", name: "Child", collapsed: false },
+    ],
+    order: [
+      {
+        type: "group",
+        id: "g1",
+        children: [{ type: "group", id: "g2", children: [{ type: "connection", id: "c1" }] }],
+      },
+    ],
+  };
+
+  const nodes = buildTreeNodesFromLayout(layout, [conn("c1")], new Set());
+
+  assert.deepEqual(
+    nodes.map((node) => [node.type, node.label, node.children?.[0]?.type, node.children?.[0]?.children?.[0]?.id]),
+    [["connection-group", "Parent", "connection-group", "c1"]],
+  );
+});
+
+test("moves connections and groups into nested groups", () => {
+  const layout: SidebarLayout = {
+    groups: [
+      { id: "g1", name: "Parent", collapsed: false },
+      { id: "g2", name: "Child", collapsed: false },
+    ],
+    order: [
+      { type: "group", id: "g1", children: [] },
+      { type: "group", id: "g2", children: [] },
+      { type: "connection", id: "c1" },
+    ],
+  };
+
+  const withNestedGroup = reorderEntry(layout, "g2", "g1", "inside");
+  const withNestedConnection = moveConnectionToGroup(withNestedGroup, "c1", "g2");
+
+  assert.deepEqual(withNestedConnection.order, [
+    {
+      type: "group",
+      id: "g1",
+      children: [{ type: "group", id: "g2", children: [{ type: "connection", id: "c1" }] }],
+    },
+  ]);
+});
+
+test("deleting a parent group keeps nested child groups", () => {
+  const layout: SidebarLayout = {
+    groups: [
+      { id: "g1", name: "Parent", collapsed: false },
+      { id: "g2", name: "Child", collapsed: false },
+    ],
+    order: [{ type: "group", id: "g1", children: [{ type: "group", id: "g2", children: [{ type: "connection", id: "c1" }] }] }],
+  };
+
+  const next = deleteGroup(layout, "g1");
+
+  assert.deepEqual(next.groups, [{ id: "g2", name: "Child", collapsed: false }]);
+  assert.deepEqual(next.order, [{ type: "group", id: "g2", children: [{ type: "connection", id: "c1" }] }]);
+});
diff --git a/packages/app-tests/sidebarNodeOrdering.test.ts b/packages/app-tests/sidebarNodeOrdering.test.ts
new file mode 100644
index 0000000..d9fae9d
--- /dev/null
+++ b/packages/app-tests/sidebarNodeOrdering.test.ts
@@ -0,0 +1,104 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { sortSidebarTreeChildrenForParent } from "../../apps/desktop/src/lib/sidebar/sidebarNodeOrdering.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+test("reorders cached MongoDB collections alphabetically", () => {
+  const parent: Pick<TreeNode, "type"> = { type: "mongo-db" };
+  const children: TreeNode[] = [
+    { id: "c:db:comments", label: "comments", type: "mongo-collection" },
+    { id: "c:db:movies", label: "movies", type: "mongo-collection" },
+    { id: "c:db:sessions", label: "sessions", type: "mongo-collection" },
+  ];
+
+  const sorted = sortSidebarTreeChildrenForParent(parent, [children[2], children[0], children[1]], "mongodb");
+
+  assert.deepEqual(
+    sorted.map((child) => child.label),
+    ["comments", "movies", "sessions"],
+  );
+});
+
+test("keeps MongoDB GridFS entry before collections", () => {
+  const parent: Pick<TreeNode, "type"> = { type: "mongo-db" };
+  const children: TreeNode[] = [
+    { id: "c:db:movies", label: "movies", type: "mongo-collection" },
+    { id: "c:db:__gridfs", label: "GridFS", type: "mongo-gridfs" as TreeNode["type"] },
+    { id: "c:db:comments", label: "comments", type: "mongo-collection" },
+  ];
+
+  const sorted = sortSidebarTreeChildrenForParent(parent, children, "mongodb");
+
+  assert.deepEqual(
+    sorted.map((child) => [child.type, child.label]),
+    [
+      ["mongo-gridfs", "GridFS"],
+      ["mongo-collection", "comments"],
+      ["mongo-collection", "movies"],
+    ],
+  );
+});
+
+test("keeps SQL Server object groups first and sorts schema children after them", () => {
+  const parent: Pick<TreeNode, "type"> = { type: "database" };
+  const children: TreeNode[] = [
+    { id: "conn:app:zeta", label: "zeta", type: "schema" },
+    { id: "conn:app:__tables", label: "tree.tables", type: "group-tables" },
+    { id: "conn:app:archive", label: "archive", type: "schema" },
+  ];
+
+  const sorted = sortSidebarTreeChildrenForParent(parent, children, "sqlserver");
+
+  assert.deepEqual(
+    sorted.map((child) => [child.type, child.label]),
+    [
+      ["group-tables", "tree.tables"],
+      ["schema", "archive"],
+      ["schema", "zeta"],
+    ],
+  );
+});
+
+test("keeps DuckDB schemas before attached catalogs while sorting both", () => {
+  const parent: Pick<TreeNode, "type"> = { type: "connection" };
+  const children: TreeNode[] = [
+    { id: "conn:analytics_20", label: "analytics_20", type: "database" },
+    { id: "conn:main:mysql", label: "mysql", type: "schema" },
+    { id: "conn:analytics_3", label: "analytics_3", type: "database" },
+    { id: "conn:main:main", label: "main", type: "schema" },
+  ];
+
+  const sorted = sortSidebarTreeChildrenForParent(parent, children, "duckdb");
+
+  assert.deepEqual(
+    sorted.map((child) => [child.type, child.label]),
+    [
+      ["schema", "main"],
+      ["schema", "mysql"],
+      ["database", "analytics_3"],
+      ["database", "analytics_20"],
+    ],
+  );
+});
+
+test("keeps connection utility nodes in fixed positions", () => {
+  const parent: Pick<TreeNode, "type"> = { type: "connection" };
+  const children: TreeNode[] = [
+    { id: "conn:__user_admin", label: "tree.userAdmin", type: "user-admin" },
+    { id: "conn:z", label: "z", type: "database" },
+    { id: "conn:__saved_sql", label: "tree.savedSql", type: "saved-sql-root" },
+    { id: "conn:a", label: "a", type: "database" },
+  ];
+
+  const sorted = sortSidebarTreeChildrenForParent(parent, children, "postgres");
+
+  assert.deepEqual(
+    sorted.map((child) => [child.type, child.label]),
+    [
+      ["saved-sql-root", "tree.savedSql"],
+      ["database", "a"],
+      ["database", "z"],
+      ["user-admin", "tree.userAdmin"],
+    ],
+  );
+});
diff --git a/packages/app-tests/sidebarRenameFocus.test.ts b/packages/app-tests/sidebarRenameFocus.test.ts
new file mode 100644
index 0000000..b401a05
--- /dev/null
+++ b/packages/app-tests/sidebarRenameFocus.test.ts
@@ -0,0 +1,47 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { focusSidebarRenameInput, shouldPreventRenameCloseAutoFocus } from "../../apps/desktop/src/lib/sidebar/sidebarRenameFocus.ts";
+
+test("focusSidebarRenameInput waits for menu focus restoration before focusing", () => {
+  const calls: string[] = [];
+  let scheduled: (() => void) | undefined;
+
+  focusSidebarRenameInput(
+    () => ({
+      focus: () => calls.push("focus"),
+      select: () => calls.push("select"),
+    }),
+    (callback) => {
+      scheduled = callback;
+      return 1;
+    },
+  );
+
+  assert.deepEqual(calls, []);
+
+  scheduled?.();
+
+  assert.deepEqual(calls, ["focus", "select"]);
+});
+
+test("focusSidebarRenameInput skips focusing when the input disappeared", () => {
+  let scheduled: (() => void) | undefined;
+
+  focusSidebarRenameInput(
+    () => undefined,
+    (callback) => {
+      scheduled = callback;
+      return 1;
+    },
+  );
+
+  assert.doesNotThrow(() => scheduled?.());
+});
+
+test("shouldPreventRenameCloseAutoFocus consumes exactly one pending rename focus restore", () => {
+  const pending = { value: true };
+
+  assert.equal(shouldPreventRenameCloseAutoFocus(pending), true);
+  assert.equal(pending.value, false);
+  assert.equal(shouldPreventRenameCloseAutoFocus(pending), false);
+});
diff --git a/packages/app-tests/sidebarSearch.test.ts b/packages/app-tests/sidebarSearch.test.ts
new file mode 100644
index 0000000..baa1de3
--- /dev/null
+++ b/packages/app-tests/sidebarSearch.test.ts
@@ -0,0 +1,43 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { matchSidebarLabel } from "../../apps/desktop/src/lib/sidebar/sidebarSearch.ts";
+
+test("matches exact and prefix labels first", () => {
+  assert.equal(matchSidebarLabel("orders", "orders")?.kind, "exact");
+  assert.equal(matchSidebarLabel("orders_archive", "ord")?.kind, "prefix");
+});
+
+test("matches word prefixes in underscored and dotted identifiers", () => {
+  assert.equal(matchSidebarLabel("user_orders", "ord")?.kind, "word-prefix");
+  assert.equal(matchSidebarLabel("sales.customer_profile", "cust")?.kind, "word-prefix");
+});
+
+test("matches DataGrip-style abbreviations by identifier word boundaries", () => {
+  assert.equal(matchSidebarLabel("additional_country", "ac")?.kind, "abbreviation");
+  assert.equal(matchSidebarLabel("sales.customer_profile", "scp")?.kind, "abbreviation");
+});
+
+test("keeps one-character fuzzy matches disabled", () => {
+  assert.equal(matchSidebarLabel("orders", "r")?.kind, "substring");
+  assert.equal(matchSidebarLabel("orders", "x"), null);
+});
+
+test("does not match loose subsequences that object search would exclude", () => {
+  assert.equal(matchSidebarLabel("sys_role_data_scope", "roles"), null);
+  assert.equal(matchSidebarLabel("sys_role_data_scope", "role")?.kind, "word-prefix");
+});
+
+test("keeps fuzzy subsequence matching inside a single identifier word", () => {
+  assert.equal(matchSidebarLabel("orders", "odr")?.kind, "fuzzy");
+  assert.equal(matchSidebarLabel("user_profile", "up")?.kind, "abbreviation");
+  assert.equal(matchSidebarLabel("user_profile", "urf"), null);
+});
+
+test("matches slash-delimited regular expression queries case-insensitively by default", () => {
+  assert.equal(matchSidebarLabel("SYS_USER_LOG", "/^sys_.*_log$/")?.kind, "regex");
+  assert.equal(matchSidebarLabel("sys_user_archive", "/^sys_.*_log$/"), null);
+});
+
+test("keeps invalid regular expression queries from matching every label", () => {
+  assert.equal(matchSidebarLabel("orders", "/["), null);
+});
diff --git a/packages/app-tests/sidebarSearchTree.test.ts b/packages/app-tests/sidebarSearchTree.test.ts
new file mode 100644
index 0000000..7f4843c
--- /dev/null
+++ b/packages/app-tests/sidebarSearchTree.test.ts
@@ -0,0 +1,328 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { filterSidebarSearchRootsByConnectionState, filterSidebarTree } from "../../apps/desktop/src/lib/sidebar/sidebarSearchTree.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+test("preserves loaded table children when the table itself matches search", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn:db",
+      label: "app",
+      type: "database",
+      connectionId: "conn",
+      database: "app",
+      isExpanded: true,
+      children: [
+        {
+          id: "conn:db:orders",
+          label: "orders",
+          type: "table",
+          connectionId: "conn",
+          database: "app",
+          isExpanded: true,
+          children: [
+            {
+              id: "conn:db:orders:__columns",
+              label: "tree.columns",
+              type: "group-columns",
+              connectionId: "conn",
+              database: "app",
+              tableName: "orders",
+              isExpanded: true,
+              children: [
+                {
+                  id: "conn:db:orders:__columns:id",
+                  label: "id",
+                  type: "column",
+                  connectionId: "conn",
+                  database: "app",
+                  tableName: "orders",
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  ];
+
+  const filtered = filterSidebarTree(nodes, "orders", new Set());
+
+  const table = filtered[0]?.children?.[0];
+  assert.equal(table?.label, "orders");
+  assert.equal(table?.children?.[0]?.label, "tree.columns");
+  assert.equal(table?.children?.[0]?.children?.[0]?.label, "id");
+});
+
+test("preserves loaded schema children when the database itself matches search", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn:hdi",
+      label: "hdi",
+      type: "database",
+      connectionId: "conn",
+      database: "hdi",
+      isExpanded: true,
+      children: [
+        {
+          id: "conn:hdi:public",
+          label: "public",
+          type: "schema",
+          connectionId: "conn",
+          database: "hdi",
+          schema: "public",
+          isExpanded: false,
+          children: [],
+        },
+      ],
+    },
+  ];
+
+  const filtered = filterSidebarTree(nodes, "hdi", new Set());
+
+  assert.equal(filtered[0]?.label, "hdi");
+  assert.equal(filtered[0]?.children?.[0]?.label, "public");
+});
+
+test("preserves loaded MongoDB collection children when the database itself matches search", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn:analytics",
+      label: "analytics",
+      type: "mongo-db",
+      connectionId: "conn",
+      database: "analytics",
+      isExpanded: true,
+      children: [
+        {
+          id: "conn:analytics:__gridfs",
+          label: "tree.gridfs",
+          type: "mongo-gridfs",
+          connectionId: "conn",
+          database: "analytics",
+          isExpanded: false,
+        },
+        {
+          id: "conn:analytics:orders",
+          label: "orders",
+          type: "mongo-collection",
+          connectionId: "conn",
+          database: "analytics",
+          isExpanded: false,
+        },
+      ],
+    },
+  ];
+
+  const filtered = filterSidebarTree(nodes, "analytics", new Set());
+
+  assert.equal(filtered[0]?.label, "analytics");
+  assert.deepEqual(
+    filtered[0]?.children?.map((child) => child.type),
+    ["mongo-gridfs", "mongo-collection"],
+  );
+  assert.equal(filtered[0]?.children?.[1]?.label, "orders");
+});
+
+test("preserves loaded MongoDB collection groups when the collection itself matches search", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn:analytics",
+      label: "analytics",
+      type: "mongo-db",
+      connectionId: "conn",
+      database: "analytics",
+      isExpanded: true,
+      children: [
+        {
+          id: "conn:analytics:orders",
+          label: "orders",
+          type: "mongo-collection",
+          connectionId: "conn",
+          database: "analytics",
+          isExpanded: true,
+          children: [
+            {
+              id: "conn:analytics:orders:__columns",
+              label: "tree.columns",
+              type: "group-columns",
+              connectionId: "conn",
+              database: "analytics",
+              tableName: "orders",
+              isExpanded: true,
+              children: [
+                {
+                  id: "conn:analytics:orders:__columns:_id",
+                  label: "_id",
+                  type: "column",
+                  connectionId: "conn",
+                  database: "analytics",
+                  tableName: "orders",
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  ];
+
+  const filtered = filterSidebarTree(nodes, "orders", new Set());
+
+  const collection = filtered[0]?.children?.[0];
+  assert.equal(collection?.label, "orders");
+  assert.equal(collection?.children?.[0]?.label, "tree.columns");
+  assert.equal(collection?.children?.[0]?.children?.[0]?.label, "_id");
+});
+
+test("preserves loaded children when the connection itself matches search", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn:1",
+      label: "192.168.0.200_3306",
+      type: "connection",
+      connectionId: "conn:1",
+      isExpanded: true,
+      children: [
+        {
+          id: "conn:1:inventory",
+          label: "inventory",
+          type: "database",
+          connectionId: "conn:1",
+          database: "inventory",
+          isExpanded: true,
+          children: [
+            {
+              id: "conn:1:inventory:products",
+              label: "products",
+              type: "table",
+              connectionId: "conn:1",
+              database: "inventory",
+            },
+          ],
+        },
+      ],
+    },
+  ];
+
+  const filtered = filterSidebarTree(nodes, "192.168.0.200", new Set());
+
+  assert.equal(filtered[0]?.label, "192.168.0.200_3306");
+  assert.equal(filtered[0]?.children?.[0]?.label, "inventory");
+  assert.equal(filtered[0]?.children?.[0]?.children?.[0]?.label, "products");
+});
+
+test("matches table comments during sidebar search", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn:db",
+      label: "app",
+      type: "database",
+      connectionId: "conn",
+      database: "app",
+      isExpanded: true,
+      children: [
+        {
+          id: "conn:db:inventory",
+          label: "inventory",
+          type: "table",
+          connectionId: "conn",
+          database: "app",
+          comment: "purchase order history",
+        },
+      ],
+    },
+  ];
+
+  const filtered = filterSidebarTree(nodes, "purchase", new Set());
+
+  assert.equal(filtered[0]?.children?.[0]?.label, "inventory");
+});
+
+test("search scope excludes non-selected node self matches", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn:1",
+      label: "orders-conn",
+      type: "connection",
+      connectionId: "conn",
+      isExpanded: true,
+      children: [
+        {
+          id: "conn:1:db",
+          label: "orders_db",
+          type: "database",
+          connectionId: "conn",
+          database: "orders_db",
+          isExpanded: true,
+          children: [
+            {
+              id: "conn:1:db:table",
+              label: "customers",
+              type: "table",
+              connectionId: "conn",
+              database: "orders_db",
+            },
+          ],
+        },
+      ],
+    },
+  ];
+
+  const filtered = filterSidebarTree(nodes, "orders", new Set(), new Set(["table"]));
+
+  assert.equal(filtered.length, 0);
+});
+
+test("connection search results stay visible before connecting", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn:1",
+      label: "Orders local",
+      type: "connection",
+      connectionId: "conn:1",
+      isExpanded: false,
+      children: [],
+    },
+    {
+      id: "conn:1:db",
+      label: "orders",
+      type: "database",
+      connectionId: "conn:1",
+      database: "orders",
+    },
+  ];
+
+  const filtered = filterSidebarSearchRootsByConnectionState(nodes, new Set());
+
+  assert.deepEqual(
+    filtered.map((node) => node.id),
+    ["conn:1"],
+  );
+});
+
+test("connection search copies preserve loading state", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn:1",
+      label: "Orders local",
+      type: "connection",
+      connectionId: "conn:1",
+      isLoading: true,
+      children: [
+        {
+          id: "conn:1:db",
+          label: "orders",
+          type: "database",
+          connectionId: "conn:1",
+          database: "orders",
+        },
+      ],
+    },
+  ];
+
+  const filtered = filterSidebarTree(nodes, "orders", new Set());
+
+  assert.equal(filtered[0]?.type, "connection");
+  assert.equal(filtered[0]?.isLoading, true);
+});
diff --git a/packages/app-tests/sidebarTableSearchControl.test.ts b/packages/app-tests/sidebarTableSearchControl.test.ts
new file mode 100644
index 0000000..4fe6369
--- /dev/null
+++ b/packages/app-tests/sidebarTableSearchControl.test.ts
@@ -0,0 +1,227 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { insertSidebarTableSearchControls } from "../../apps/desktop/src/lib/sidebar/sidebarTableSearchControl.ts";
+import type { FlatTreeNode } from "../../apps/desktop/src/composables/useFlatTree.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+function flat(node: TreeNode, depth = 0): FlatTreeNode {
+  return {
+    node,
+    depth,
+    id: node.id,
+    type: node.type,
+    poolType: node.type,
+  };
+}
+
+test("inserts a local table search control above simple table children", () => {
+  const database: TreeNode = {
+    id: "conn:app",
+    label: "app",
+    type: "database",
+    connectionId: "conn",
+    database: "app",
+    isExpanded: true,
+    children: [{ id: "conn:app:orders", label: "orders", type: "table", connectionId: "conn", database: "app" }],
+  };
+  const table = database.children![0];
+
+  const nodes = insertSidebarTableSearchControls([flat(database), flat(table, 1)], {
+    enabled: true,
+    sidebarObjectDisplay: "simple",
+    activeQueries: {},
+  });
+
+  assert.deepEqual(
+    nodes.map((item) => item.node.type),
+    ["database", "table-search-control", "table"],
+  );
+  assert.equal(nodes[1].node.tableSearchParentId, "conn:app");
+  assert.equal(nodes[1].depth, 1);
+});
+
+test("keeps a simple local table search control visible when the current search has no results", () => {
+  const database: TreeNode = {
+    id: "conn:app",
+    label: "app",
+    type: "database",
+    connectionId: "conn",
+    database: "app",
+    isExpanded: true,
+    children: [],
+  };
+
+  const nodes = insertSidebarTableSearchControls([flat(database)], {
+    enabled: true,
+    sidebarObjectDisplay: "simple",
+    activeQueries: { "conn:app": "invoice" },
+  });
+
+  assert.deepEqual(
+    nodes.map((item) => item.node.type),
+    ["database", "table-search-control"],
+  );
+});
+
+test("inserts a grouped local table search control only for expanded table groups", () => {
+  const tableGroup: TreeNode = {
+    id: "conn:app:__tables",
+    label: "tree.tables",
+    type: "group-tables",
+    connectionId: "conn",
+    database: "app",
+    isExpanded: true,
+    children: [{ id: "conn:app:orders", label: "orders", type: "table", connectionId: "conn", database: "app" }],
+  };
+  const viewGroup: TreeNode = {
+    id: "conn:app:__views",
+    label: "tree.views",
+    type: "group-views",
+    connectionId: "conn",
+    database: "app",
+    isExpanded: true,
+    children: [],
+  };
+
+  const nodes = insertSidebarTableSearchControls([flat(tableGroup, 1), flat(viewGroup, 1)], {
+    enabled: true,
+    sidebarObjectDisplay: "grouped",
+    activeQueries: {},
+  });
+
+  assert.deepEqual(
+    nodes.map((item) => item.node.type),
+    ["group-tables", "table-search-control", "group-views"],
+  );
+  assert.equal(nodes[1].node.tableSearchParentId, "conn:app:__tables");
+});
+
+test("does not insert a local table search control for empty table scopes", () => {
+  const tableGroup: TreeNode = {
+    id: "conn:app:__tables",
+    label: "tree.tables",
+    type: "group-tables",
+    connectionId: "conn",
+    database: "app",
+    isExpanded: true,
+    children: [],
+  };
+  const routineOnlySchema: TreeNode = {
+    id: "conn:app:public",
+    label: "public",
+    type: "schema",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    isExpanded: true,
+    children: [{ id: "conn:app:public:sync_orders", label: "sync_orders", type: "procedure", connectionId: "conn", database: "app", schema: "public" }],
+  };
+
+  const groupedNodes = insertSidebarTableSearchControls([flat(tableGroup, 1)], {
+    enabled: true,
+    sidebarObjectDisplay: "grouped",
+    activeQueries: {},
+  });
+  const simpleNodes = insertSidebarTableSearchControls([flat(routineOnlySchema, 1)], {
+    enabled: true,
+    sidebarObjectDisplay: "simple",
+    activeQueries: {},
+  });
+
+  assert.deepEqual(groupedNodes.map((item) => item.node.type), ["group-tables"]);
+  assert.deepEqual(simpleNodes.map((item) => item.node.type), ["schema"]);
+});
+
+test("keeps a grouped local table search control visible when the current search has no results", () => {
+  const tableGroup: TreeNode = {
+    id: "conn:app:__tables",
+    label: "tree.tables",
+    type: "group-tables",
+    connectionId: "conn",
+    database: "app",
+    isExpanded: true,
+    children: [],
+  };
+
+  const nodes = insertSidebarTableSearchControls([flat(tableGroup, 1)], {
+    enabled: true,
+    sidebarObjectDisplay: "grouped",
+    activeQueries: { "conn:app:__tables": "invoice" },
+  });
+
+  assert.deepEqual(
+    nodes.map((item) => item.node.type),
+    ["group-tables", "table-search-control"],
+  );
+});
+
+test("uses isolated virtual scroller pools for each local table search input", () => {
+  const first: TreeNode = {
+    id: "conn:first:__tables",
+    label: "tree.tables",
+    type: "group-tables",
+    connectionId: "conn",
+    database: "first",
+    isExpanded: true,
+    children: [{ id: "conn:first:orders", label: "orders", type: "table", connectionId: "conn", database: "first" }],
+  };
+  const second: TreeNode = {
+    id: "conn:second:__tables",
+    label: "tree.tables",
+    type: "group-tables",
+    connectionId: "conn",
+    database: "second",
+    isExpanded: true,
+    children: [{ id: "conn:second:orders", label: "orders", type: "table", connectionId: "conn", database: "second" }],
+  };
+
+  const nodes = insertSidebarTableSearchControls([flat(first, 1), flat(second, 1)], {
+    enabled: true,
+    sidebarObjectDisplay: "grouped",
+    activeQueries: {},
+  });
+
+  const pools = nodes.filter((item) => item.node.type === "table-search-control").map((item) => item.poolType);
+  assert.equal(pools.length, 2);
+  assert.equal(new Set(pools).size, 2);
+});
+
+test("hides local table search controls while global sidebar filtering is active", () => {
+  const database: TreeNode = {
+    id: "conn:app",
+    label: "app",
+    type: "database",
+    connectionId: "conn",
+    database: "app",
+    isExpanded: true,
+    children: [{ id: "conn:app:orders", label: "orders", type: "table", connectionId: "conn", database: "app" }],
+  };
+
+  const nodes = insertSidebarTableSearchControls([flat(database)], {
+    enabled: false,
+    sidebarObjectDisplay: "simple",
+    activeQueries: { "conn:app": "orders" },
+  });
+
+  assert.deepEqual(nodes.map((item) => item.node.type), ["database"]);
+});
+
+test("does not insert local table search controls when the user setting is disabled", () => {
+  const tableGroup: TreeNode = {
+    id: "conn:app:__tables",
+    label: "tree.tables",
+    type: "group-tables",
+    connectionId: "conn",
+    database: "app",
+    isExpanded: true,
+    children: [{ id: "conn:app:orders", label: "orders", type: "table", connectionId: "conn", database: "app" }],
+  };
+
+  const nodes = insertSidebarTableSearchControls([flat(tableGroup, 1)], {
+    enabled: false,
+    sidebarObjectDisplay: "grouped",
+    activeQueries: { "conn:app:__tables": "orders" },
+  });
+
+  assert.deepEqual(nodes.map((item) => item.node.type), ["group-tables"]);
+});
diff --git a/packages/app-tests/sidebarTreeCollapse.test.ts b/packages/app-tests/sidebarTreeCollapse.test.ts
new file mode 100644
index 0000000..72c644e
--- /dev/null
+++ b/packages/app-tests/sidebarTreeCollapse.test.ts
@@ -0,0 +1,42 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { collapseExpandedTreeNodes } from "../../apps/desktop/src/lib/sidebar/sidebarTreeCollapse.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+test("collapseExpandedTreeNodes collapses all expanded descendants", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn",
+      label: "conn",
+      type: "connection",
+      isExpanded: true,
+      children: [
+        {
+          id: "db",
+          label: "db",
+          type: "database",
+          isExpanded: true,
+          children: [
+            { id: "tables", label: "Tables", type: "group-tables", isExpanded: false },
+            { id: "views", label: "Views", type: "group-views", isExpanded: true },
+          ],
+        },
+      ],
+    },
+    { id: "closed", label: "closed", type: "connection", isExpanded: false },
+  ];
+
+  assert.equal(collapseExpandedTreeNodes(nodes), 3);
+  assert.equal(nodes[0].isExpanded, false);
+  assert.equal(nodes[0].children?.[0]?.isExpanded, false);
+  assert.equal(nodes[0].children?.[0]?.children?.[0]?.isExpanded, false);
+  assert.equal(nodes[0].children?.[0]?.children?.[1]?.isExpanded, false);
+  assert.equal(nodes[1].isExpanded, false);
+});
+
+test("collapseExpandedTreeNodes returns zero when nothing is expanded", () => {
+  const nodes: TreeNode[] = [{ id: "conn", label: "conn", type: "connection", isExpanded: false }];
+
+  assert.equal(collapseExpandedTreeNodes(nodes), 0);
+  assert.equal(nodes[0].isExpanded, false);
+});
diff --git a/packages/app-tests/sidebarTreeItemLayout.test.ts b/packages/app-tests/sidebarTreeItemLayout.test.ts
new file mode 100644
index 0000000..d2d9062
--- /dev/null
+++ b/packages/app-tests/sidebarTreeItemLayout.test.ts
@@ -0,0 +1,15 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { canTreeNodePin, canTreeNodeShowExpander } from "../../apps/desktop/src/lib/sidebar/sidebarTreeItemLayout.ts";
+
+test("mongodb collection rows can show an expander for metadata groups", () => {
+  assert.equal(canTreeNodeShowExpander({ type: "mongo-collection", childCount: 0 }), true);
+});
+
+test("ZooKeeper root rows do not show an empty expander", () => {
+  assert.equal(canTreeNodeShowExpander({ type: "zookeeper-root", childCount: 0 }), false);
+});
+
+test("Nacos namespace rows can show the pin action", () => {
+  assert.equal(canTreeNodePin("nacos-namespace"), true);
+});
diff --git a/packages/app-tests/sidebarTreeSelection.test.ts b/packages/app-tests/sidebarTreeSelection.test.ts
new file mode 100644
index 0000000..84cdf49
--- /dev/null
+++ b/packages/app-tests/sidebarTreeSelection.test.ts
@@ -0,0 +1,38 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { selectedTreeNodesInVisibleOrder, treeSelectionRangeIdsByIndex, treeSelectionRangeIds } from "../../apps/desktop/src/lib/sidebar/sidebarTreeSelection.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+const nodes: TreeNode[] = [
+  { id: "orders", label: "orders", type: "table" },
+  { id: "order_lines", label: "order_lines", type: "table" },
+  { id: "products", label: "products", type: "table" },
+  { id: "customers", label: "customers", type: "table" },
+];
+
+test("tree range selection uses the current visible node order", () => {
+  const filtered = [nodes[0], nodes[1], nodes[3]];
+
+  assert.deepEqual(treeSelectionRangeIds(filtered, "customers", "orders"), ["orders", "order_lines", "customers"]);
+});
+
+test("tree range selection falls back to the current node when the anchor is filtered out", () => {
+  const filtered = [nodes[1], nodes[3]];
+
+  assert.deepEqual(treeSelectionRangeIds(filtered, "customers", "orders"), ["customers"]);
+});
+
+test("tree range selection can reuse precomputed visible indexes", () => {
+  const filtered = [nodes[0], nodes[1], nodes[3]];
+
+  assert.deepEqual(treeSelectionRangeIdsByIndex(filtered, 2, 0, "customers"), ["orders", "order_lines", "customers"]);
+});
+
+test("selected tree nodes are ordered and limited by visible nodes", () => {
+  const filtered = [nodes[1], nodes[3]];
+
+  assert.deepEqual(
+    selectedTreeNodesInVisibleOrder(filtered, ["products", "customers", "order_lines"]).map((node) => node.id),
+    ["order_lines", "customers"],
+  );
+});
diff --git a/packages/app-tests/sidebarTypeSearch.test.ts b/packages/app-tests/sidebarTypeSearch.test.ts
new file mode 100644
index 0000000..f472c7b
--- /dev/null
+++ b/packages/app-tests/sidebarTypeSearch.test.ts
@@ -0,0 +1,20 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { sidebarTypeSearchNextQuery } from "../../apps/desktop/src/lib/sidebar/sidebarTypeSearch.ts";
+
+test("starts sidebar search from printable keys", () => {
+  assert.equal(sidebarTypeSearchNextQuery("", { key: "e" }), "e");
+  assert.equal(sidebarTypeSearchNextQuery("ec", { key: "m" }), "ecm");
+});
+
+test("removes one search character with Backspace", () => {
+  assert.equal(sidebarTypeSearchNextQuery("ecm", { key: "Backspace" }), "ec");
+  assert.equal(sidebarTypeSearchNextQuery("", { key: "Backspace" }), null);
+});
+
+test("ignores shortcuts and non-searchable initial space", () => {
+  assert.equal(sidebarTypeSearchNextQuery("", { key: "f", metaKey: true }), null);
+  assert.equal(sidebarTypeSearchNextQuery("", { key: "ArrowDown" }), null);
+  assert.equal(sidebarTypeSearchNextQuery("", { key: " " }), null);
+  assert.equal(sidebarTypeSearchNextQuery("order", { key: " " }), "order ");
+});
diff --git a/packages/app-tests/sqlAnalysis.test.ts b/packages/app-tests/sqlAnalysis.test.ts
new file mode 100644
index 0000000..0bcd68a
--- /dev/null
+++ b/packages/app-tests/sqlAnalysis.test.ts
@@ -0,0 +1,169 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { allEditableColumnsWriteable, allPrimaryKeysPresent, analyzeEditableQuery, analyzeEditableQueryEditability, isBinaryType, queryEditabilityMessageKey, sourceColumnsForResult } from "../../apps/desktop/src/lib/sql/sqlAnalysis.ts";
+
+test("recognizes a simple single-table SELECT as editable", () => {
+  const result = analyzeEditableQueryEditability("select id, name from public.users where active = true order by id");
+
+  assert.equal(result.editable, true);
+  assert.equal(result.analysis.schema, "public");
+  assert.equal(result.analysis.tableName, "users");
+  assert.equal(result.analysis.selectStar, false);
+  assert.deepEqual(result.analysis.columns, [
+    { sourceName: "id", sourceNameQuoted: false, resultName: "id", expression: "id" },
+    { sourceName: "name", sourceNameQuoted: false, resultName: "name", expression: "name" },
+  ]);
+});
+
+test("recognizes quoted table names and table aliases", () => {
+  const result = analyzeEditableQueryEditability('SELECT u."id", u."full name" FROM "app schema"."user table" AS u');
+
+  assert.equal(result.editable, true);
+  assert.equal(result.analysis.schema, "app schema");
+  assert.equal(result.analysis.tableName, "user table");
+  assert.equal(result.analysis.tableAlias, "u");
+  assert.deepEqual(result.analysis.columns, [
+    { sourceName: "id", sourceNameQuoted: true, sourceQualifier: "u", sourceKey: "u:0", resultName: "id", expression: 'u."id"' },
+    { sourceName: "full name", sourceNameQuoted: true, sourceQualifier: "u", sourceKey: "u:0", resultName: "full name", expression: 'u."full name"' },
+  ]);
+});
+
+test("keeps the legacy analyzer API for editable SELECT queries", () => {
+  const analysis = analyzeEditableQuery("select * from users");
+  assert.ok(analysis);
+  assert.equal(analysis.tableName, "users");
+  assert.equal(analysis.selectStar, true);
+  assert.deepEqual(analysis.columns, []);
+});
+
+test("maps joined query source columns for column-level editing", () => {
+  const result = analyzeEditableQueryEditability("select u.id as user_id, u.name, o.total from users u join orders o on o.user_id = u.id");
+
+  assert.equal(result.editable, true);
+  assert.equal(result.analysis.multiSource, true);
+  assert.equal(result.analysis.allowInsertDelete, false);
+  assert.deepEqual(
+    result.analysis.sources?.map((source) => ({ key: source.key, tableName: source.tableName, alias: source.alias })),
+    [
+      { key: "u:0", tableName: "users", alias: "u" },
+      { key: "o:1", tableName: "orders", alias: "o" },
+    ],
+  );
+  assert.deepEqual(result.analysis.columns, [
+    { sourceName: "id", sourceNameQuoted: false, sourceQualifier: "u", sourceKey: "u:0", resultName: "user_id", expression: "u.id" },
+    { sourceName: "name", sourceNameQuoted: false, sourceQualifier: "u", sourceKey: "u:0", resultName: "name", expression: "u.name" },
+    { sourceName: "total", sourceNameQuoted: false, sourceQualifier: "o", sourceKey: "o:1", resultName: "total", expression: "o.total" },
+  ]);
+  assert.equal(allPrimaryKeysPresent(["id"], ["user_id", "name", "total"], result.analysis, "u:0"), true);
+  assert.deepEqual(sourceColumnsForResult(result.analysis, ["user_id", "name", "total"], "u:0"), ["id", "name", undefined]);
+});
+
+test("recognizes single-table explicit columns mixed with alias star", () => {
+  const result = analyzeEditableQueryEditability("select t.create_date, t.* from tt_kd_material_container_sap t where t.order_no = 'KD2607071336' order by t.create_date desc");
+
+  assert.equal(result.editable, true);
+  assert.equal(result.analysis.tableName, "tt_kd_material_container_sap");
+  assert.equal(result.analysis.tableAlias, "t");
+  assert.deepEqual(result.analysis.columns, [
+    { sourceName: "create_date", sourceNameQuoted: false, sourceQualifier: "t", sourceKey: "t:0", resultName: "create_date", expression: "t.create_date" },
+    { star: true, sourceQualifier: "t", sourceKey: "t:0", resultName: "*", expression: "t.*" },
+  ]);
+});
+
+test("treats DISTINCT single-table projections as update-only", () => {
+  const result = analyzeEditableQueryEditability("select distinct id, name from users");
+
+  assert.equal(result.editable, true);
+  assert.equal(result.analysis.distinct, true);
+  assert.equal(result.analysis.allowInsertDelete, false);
+  assert.deepEqual(result.analysis.columns, [
+    { sourceName: "id", sourceNameQuoted: false, resultName: "id", expression: "id" },
+    { sourceName: "name", sourceNameQuoted: false, resultName: "name", expression: "name" },
+  ]);
+});
+
+test("maps a DISTINCT qualified star to one joined source", () => {
+  const result = analyzeEditableQueryEditability("select distinct u.* from users u left join orders o on o.user_id = u.id");
+
+  assert.equal(result.editable, true);
+  assert.equal(result.analysis.distinct, true);
+  assert.equal(result.analysis.multiSource, true);
+  assert.equal(result.analysis.allowInsertDelete, false);
+  assert.deepEqual(result.analysis.columns, [{ star: true, sourceQualifier: "u", sourceKey: "u:0", resultName: "*", expression: "u.*" }]);
+});
+
+test("keeps ambiguous DISTINCT projections read-only", () => {
+  assert.deepEqual(analyzeEditableQueryEditability("select distinct * from users u join orders o on o.user_id = u.id"), {
+    editable: false,
+    reason: "complex-source",
+  });
+  assert.deepEqual(analyzeEditableQueryEditability("select distinct on (user_id) id, user_id from orders order by user_id, id desc"), {
+    editable: false,
+    reason: "aggregation",
+  });
+});
+
+test("reports DuckDB external file scans as read-only external sources", () => {
+  const result = analyzeEditableQueryEditability("SELECT * FROM '/tmp/duckdb_excel_extension_test.xlsx'");
+
+  assert.deepEqual(result, {
+    editable: false,
+    reason: "external-source",
+  });
+  assert.equal(queryEditabilityMessageKey(result.reason), "grid.queryEditUnsupported.external-source");
+});
+
+test("reports computed result columns as unsafe to edit", () => {
+  const result = analyzeEditableQueryEditability("select id, count(*) as total from users group by id");
+
+  assert.deepEqual(result, {
+    editable: false,
+    reason: "aggregation",
+  });
+});
+
+test("keeps single-table expression columns while mapping writable source columns", () => {
+  const result = analyzeEditableQueryEditability("select iso3, year, country_name, ihli / gdp_pc as score from ihli_data");
+
+  assert.equal(result.editable, true);
+  assert.deepEqual(result.analysis.columns, [
+    { sourceName: "iso3", sourceNameQuoted: false, resultName: "iso3", expression: "iso3" },
+    { sourceName: "year", sourceNameQuoted: false, resultName: "year", expression: "year" },
+    { sourceName: "country_name", sourceNameQuoted: false, resultName: "country_name", expression: "country_name" },
+    { sourceName: undefined, sourceNameQuoted: false, resultName: "score", expression: "ihli / gdp_pc" },
+  ]);
+  assert.equal(allPrimaryKeysPresent(["iso3", "year"], ["iso3", "year", "country_name", "score"], result.analysis), true);
+  assert.equal(allEditableColumnsWriteable(result.analysis, ["iso3", "year", "country_name", "score"]), true);
+});
+
+test("accepts aliased primary key source columns for row identity", () => {
+  const analysis = analyzeEditableQuery("select id as user_id, name from users");
+
+  assert.ok(analysis);
+  assert.equal(allPrimaryKeysPresent(["id"], ["user_id", "name"], analysis), true);
+  assert.equal(allEditableColumnsWriteable(analysis, ["user_id", "name"]), true);
+  assert.equal(allPrimaryKeysPresent(["id"], ["id", "name"], analyzeEditableQuery("select id, name from users")!), true);
+});
+
+test("maps ClickHouse simple query results when identifier columns are returned", () => {
+  const analysis = analyzeEditableQuery("SELECT id, name, score + 1 AS next_score FROM default.people");
+
+  assert.ok(analysis);
+  assert.equal(allPrimaryKeysPresent(["id"], ["id", "name", "next_score"], analysis), true);
+  assert.equal(allEditableColumnsWriteable(analysis, ["id", "name", "next_score"]), true);
+  assert.deepEqual(sourceColumnsForResult(analysis, ["id", "name", "next_score"]), ["id", "name", undefined]);
+});
+
+test("rejects ClickHouse query result editing when identifier source columns are omitted", () => {
+  const analysis = analyzeEditableQuery("SELECT name FROM default.people");
+
+  assert.ok(analysis);
+  assert.equal(allPrimaryKeysPresent(["id"], ["name"], analysis), false);
+  assert.deepEqual(sourceColumnsForResult(analysis, ["name"]), ["name"]);
+});
+
+test("recognizes binary type declarations with lengths", () => {
+  assert.equal(isBinaryType("binary(16)"), true);
+  assert.equal(isBinaryType("VARBINARY(255)"), true);
+  assert.equal(isBinaryType("varchar(255)"), false);
+});
diff --git a/packages/app-tests/sqlCompletion.test.ts b/packages/app-tests/sqlCompletion.test.ts
new file mode 100644
index 0000000..8b0d1df
--- /dev/null
+++ b/packages/app-tests/sqlCompletion.test.ts
@@ -0,0 +1,2792 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import {
+  buildSqlCompletionItems,
+  getSqlFunctionSignatureHelp,
+  getSqlCompletionResultValidFor,
+  isSqlCommentContext,
+  isSqlStringLiteralContext,
+  shouldAutoOpenSqlCompletion,
+  extractCteDefinitions,
+  getSqlCompletionContext,
+  recordCompletionSelection,
+  type SqlCompletionColumn,
+  type SqlCompletionForeignKey,
+  type SqlCompletionObject,
+  type SqlCompletionTable,
+} from "../../apps/desktop/src/lib/sql/sqlCompletion.ts";
+
+const tables: SqlCompletionTable[] = [
+  { name: "users", schema: "public", type: "table" },
+  { name: "user_profiles", schema: "public", type: "table" },
+  { name: "orders", schema: "public", type: "table" },
+  { name: "ticket_summary", schema: "public", type: "view" },
+];
+
+const columnsByTable = new Map<string, SqlCompletionColumn[]>([
+  [
+    "public.users",
+    [
+      { name: "id", table: "users", schema: "public", dataType: "bigint" },
+      { name: "name", table: "users", schema: "public", dataType: "varchar" },
+      { name: "email", table: "users", schema: "public", dataType: "varchar" },
+    ],
+  ],
+  [
+    "public.orders",
+    [
+      { name: "id", table: "orders", schema: "public", dataType: "bigint" },
+      { name: "user_id", table: "orders", schema: "public", dataType: "bigint" },
+      { name: "status", table: "orders", schema: "public", dataType: "varchar" },
+    ],
+  ],
+]);
+
+const mysqlCrossDatabaseColumnsByTable = new Map<string, SqlCompletionColumn[]>([
+  [
+    "other_db.orders",
+    [
+      { name: "id", table: "orders", dataType: "bigint" },
+      { name: "number", table: "orders", dataType: "varchar" },
+      { name: "status", table: "orders", dataType: "varchar" },
+    ],
+  ],
+  ["current_db.orders", [{ name: "local_status", table: "orders", dataType: "varchar" }]],
+]);
+
+const completionObjects: SqlCompletionObject[] = [
+  { name: "refresh_user_stats", schema: "app", type: "procedure" },
+  { name: "format_user_name", schema: "app", type: "function" },
+  { name: "trg_users_audit", schema: "app", type: "trigger", parentName: "users" },
+];
+
+const postgresQuotedTables: SqlCompletionTable[] = [
+  { name: "article", schema: "public", type: "table" },
+  { name: "order_lines", schema: "public", type: "table" },
+  { name: "OrderLines", schema: "public", type: "table" },
+  { name: "User", schema: "public", type: "table" },
+  { name: 'has"quote', schema: "public", type: "table" },
+];
+
+const postgresQuotedColumnsByTable = new Map<string, SqlCompletionColumn[]>([
+  [
+    "public.OrderLines",
+    [
+      { name: "article", table: "OrderLines", schema: "public", dataType: "text" },
+      { name: "OrderId", table: "OrderLines", schema: "public", dataType: "uuid" },
+      { name: "User", table: "OrderLines", schema: "public", dataType: "text" },
+      { name: 'has"quote', table: "OrderLines", schema: "public", dataType: "text" },
+    ],
+  ],
+]);
+
+test("suggests SQL keywords for generic keyword input", () => {
+  const items = buildSqlCompletionItems("sel", 3, {
+    tables,
+    columnsByTable,
+  });
+
+  const keyword = items.find((item) => item.type === "keyword" && item.label === "SELECT");
+  assert.ok(keyword);
+  assert.equal(keyword.type, "keyword");
+});
+
+test("suggests lower-case SQL keywords when configured", () => {
+  const items = buildSqlCompletionItems("sel", 3, {
+    tables,
+    columnsByTable,
+    keywordCase: "lower",
+  });
+
+  const keyword = items.find((item) => item.type === "keyword" && item.label === "select");
+  assert.ok(keyword);
+  assert.equal(
+    items.some((item) => item.type === "keyword" && item.label === "SELECT"),
+    false,
+  );
+});
+
+test("suggests PostgreSQL-specific data types and functions", () => {
+  const typeItems = buildSqlCompletionItems("create table events (payload js", "create table events (payload js".length, {
+    tables: [],
+    columnsByTable: new Map(),
+    databaseType: "postgres",
+  });
+  const serialItems = buildSqlCompletionItems("create table events (id ser", "create table events (id ser".length, {
+    tables: [],
+    columnsByTable: new Map(),
+    databaseType: "postgres",
+  });
+  const functionItems = buildSqlCompletionItems("select jsonb_b", "select jsonb_b".length, {
+    tables: [],
+    columnsByTable: new Map(),
+    databaseType: "postgres",
+  });
+  const mysqlFunctionItems = buildSqlCompletionItems("select date_f", "select date_f".length, {
+    tables: [],
+    columnsByTable: new Map(),
+    databaseType: "mysql",
+  });
+  const postgresDateItems = buildSqlCompletionItems("select date_f", "select date_f".length, {
+    tables: [],
+    columnsByTable: new Map(),
+    databaseType: "postgres",
+  });
+
+  assert.ok(typeItems.some((item) => item.type === "keyword" && item.label === "JSONB"));
+  assert.ok(serialItems.some((item) => item.type === "keyword" && item.label === "SERIAL"));
+  assert.ok(functionItems.some((item) => item.type === "function" && item.label === "JSONB_BUILD_OBJECT"));
+  assert.ok(mysqlFunctionItems.some((item) => item.type === "function" && item.label === "DATE_FORMAT"));
+  assert.equal(
+    postgresDateItems.some((item) => item.type === "function" && item.label === "DATE_FORMAT"),
+    false,
+  );
+});
+
+test("suggests Manticore Search SQL functions and command snippets", () => {
+  const matchItems = buildSqlCompletionItems("select * from products where mat", "select * from products where mat".length, {
+    tables,
+    columnsByTable,
+    databaseType: "manticoresearch",
+  });
+  const facetItems = buildSqlCompletionItems("select * from products fac", "select * from products fac".length, {
+    tables,
+    columnsByTable,
+    databaseType: "manticoresearch",
+  });
+  const showItems = buildSqlCompletionItems("show m", "show m".length, {
+    tables,
+    columnsByTable,
+    databaseType: "manticoresearch",
+  });
+  const showTablesItems = buildSqlCompletionItems("show tab", "show tab".length, {
+    tables,
+    columnsByTable,
+    databaseType: "manticoresearch",
+  });
+  const callPqItems = buildSqlCompletionItems("call p", "call p".length, {
+    tables,
+    columnsByTable,
+    databaseType: "manticoresearch",
+  });
+  const rankingItems = buildSqlCompletionItems("select bm", "select bm".length, {
+    tables,
+    columnsByTable,
+    databaseType: "manticoresearch",
+  });
+
+  assert.ok(matchItems.some((item) => item.type === "function" && item.label === "MATCH" && item.apply === "MATCH(${query})"));
+  assert.ok(facetItems.some((item) => item.type === "keyword" && item.label === "FACET"));
+  assert.ok(showItems.some((item) => item.type === "snippet" && item.label === "show meta" && item.apply === "SHOW META;"));
+  assert.ok(showTablesItems.some((item) => item.type === "snippet" && item.label === "show tables" && item.apply === "SHOW TABLES;"));
+  assert.ok(callPqItems.some((item) => item.type === "snippet" && item.label === "call pq" && item.apply === "CALL PQ ('pq', ('{\"title\":\"query\"}'));"));
+  assert.ok(rankingItems.some((item) => item.type === "function" && item.label === "BM25F"));
+});
+
+test("MongoDB completion avoids SQL keywords", () => {
+  const items = buildSqlCompletionItems("fi", 2, {
+    tables: [],
+    columnsByTable: new Map(),
+    databaseType: "mongodb",
+  });
+
+  assert.ok(items.some((item) => item.type === "function" && item.label === "find"));
+  assert.equal(
+    items.some((item) => item.type === "keyword" && item.label === "SELECT"),
+    false,
+  );
+});
+
+test("quotes PostgreSQL table identifiers when completion inserts them", () => {
+  const sql = "select * from Order";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: postgresQuotedTables,
+    columnsByTable: new Map(),
+    dialect: "postgres",
+  });
+
+  const table = items.find((item) => item.type === "table" && item.label === "OrderLines");
+  assert.equal(table?.apply, '"OrderLines"');
+});
+
+test("leaves safe PostgreSQL table identifiers unquoted when completion inserts them", () => {
+  const sql = "select * from article";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: postgresQuotedTables,
+    columnsByTable: new Map(),
+    dialect: "postgres",
+  });
+
+  const table = items.find((item) => item.type === "table" && item.label === "article");
+  assert.equal(table?.apply, "article");
+});
+
+test("quotes PostgreSQL keyword-like and escaped table identifiers when completion inserts them", () => {
+  const userItems = buildSqlCompletionItems("select * from User", "select * from User".length, {
+    tables: postgresQuotedTables,
+    columnsByTable: new Map(),
+    dialect: "postgres",
+  });
+  const quotedItems = buildSqlCompletionItems("select * from has", "select * from has".length, {
+    tables: postgresQuotedTables,
+    columnsByTable: new Map(),
+    dialect: "postgres",
+  });
+
+  assert.equal(userItems.find((item) => item.label === "User")?.apply, '"User"');
+  assert.equal(quotedItems.find((item) => item.label === 'has"quote')?.apply, '"has""quote"');
+});
+
+test("quotes PostgreSQL column identifiers when completion inserts them", () => {
+  const sql = "select Order from public.OrderLines";
+  const cursor = "select Order".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables: postgresQuotedTables,
+    columnsByTable: postgresQuotedColumnsByTable,
+    dialect: "postgres",
+  });
+
+  const column = items.find((item) => item.type === "column" && item.label === "OrderId");
+  assert.equal(column?.apply, '"OrderId"');
+});
+
+test("leaves safe PostgreSQL column identifiers unquoted when completion inserts them", () => {
+  const sql = "select arti from public.OrderLines";
+  const cursor = "select arti".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables: postgresQuotedTables,
+    columnsByTable: postgresQuotedColumnsByTable,
+    dialect: "postgres",
+  });
+
+  const column = items.find((item) => item.type === "column" && item.label === "article");
+  assert.equal(column?.apply, "article");
+});
+
+test("suggests matching table names after FROM", () => {
+  const sql = "select * from us";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.deepEqual(
+    items.slice(0, 2).map((item) => item.label),
+    ["users", "user_profiles"],
+  );
+});
+
+test("ranks prefix matches above substring matches for table names", () => {
+  const sql = "select * from user";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.deepEqual(
+    items.filter((item) => item.type === "table").map((item) => item.label),
+    ["users", "user_profiles"],
+  );
+});
+
+test("suggests columns for an explicit alias qualifier", () => {
+  const sql = "select u. from public.users u";
+  const cursor = "select u.".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables,
+    columnsByTable,
+  });
+
+  const columnItems = items.filter((item) => item.type === "column");
+  assert.deepEqual(
+    columnItems.map((item) => item.label),
+    ["id", "name", "email"],
+  );
+});
+
+test("suggests only matching columns for an explicit alias qualifier prefix", () => {
+  const sql = "select u.na from public.users u join public.orders o on u.id = o.user_id";
+  const cursor = "select u.na".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables,
+    columnsByTable,
+  });
+  const columnItems = items.filter((item) => item.type === "column");
+
+  assert.deepEqual(
+    columnItems.map((item) => [item.label, item.type, item.detail]),
+    [["name", "column", "public.users  [varchar]"]],
+  );
+});
+
+test("keeps explicit alias column suggestions scoped to the alias table", () => {
+  const sql = "select * from public.users u join public.orders o on u.id = o.user_id where o.st";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.deepEqual(
+    items.map((item) => [item.label, item.type, item.detail]),
+    [["status", "column", "public.orders  [varchar]"]],
+  );
+});
+
+test("does not show table names after an explicit alias qualifier", () => {
+  const sql = "select * from billing_owner b where b.";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "base_gateway_expand", schema: "BU", type: "table" },
+      { name: "billing_owner", schema: "BU", type: "table" },
+    ],
+    columnsByTable: new Map(),
+  });
+
+  assert.deepEqual(items, []);
+});
+
+test("suggests columns after an explicit alias qualifier without leaking tables", () => {
+  const sql = "select * from billing_owner b where b.";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "base_gateway_expand", schema: "BU", type: "table" },
+      { name: "billing_owner", schema: "BU", type: "table" },
+    ],
+    columnsByTable: new Map([
+      [
+        "BU.billing_owner",
+        [
+          { name: "owner_id", table: "billing_owner", schema: "BU", dataType: "number" },
+          { name: "owner_name", table: "billing_owner", schema: "BU", dataType: "varchar" },
+        ],
+      ],
+    ]),
+  });
+
+  assert.deepEqual(
+    items.map((item) => [item.label, item.type, item.detail]),
+    [
+      ["owner_id", "column", "BU.billing_owner  [number]"],
+      ["owner_name", "column", "BU.billing_owner  [varchar]"],
+    ],
+  );
+});
+
+test("shows column comments in WHERE field completions", () => {
+  const sql = "select * from public.orders where st";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable: new Map([
+      [
+        "public.orders",
+        [
+          {
+            name: "status",
+            table: "orders",
+            schema: "public",
+            dataType: "varchar",
+            isNullable: false,
+            comment: "Order lifecycle state",
+          },
+        ],
+      ],
+    ]),
+  });
+
+  const column = items.find((item) => item.type === "column" && item.label === "status");
+  assert.equal(column?.detail, "public.orders  [varchar]  NOT NULL  -- Order lifecycle state");
+  assert.equal(column?.info, "public.orders.status\nType: varchar\nNullable: no\nComment: Order lifecycle state");
+});
+
+test("suggests only fields after numbered table aliases in join conditions", () => {
+  const sql = "select * from public.users t1 join public.orders t2 on t1.";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.deepEqual(
+    items.map((item) => [item.label, item.type]),
+    [
+      ["id", "column"],
+      ["name", "column"],
+      ["email", "column"],
+    ],
+  );
+  assert.equal(
+    items.some((item) => item.type === "table"),
+    false,
+  );
+});
+
+test("scopes numbered alias field suggestions to the requested joined table", () => {
+  const sql = "select * from public.users t1 join public.orders t2 on t2.";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.deepEqual(
+    items.map((item) => [item.label, item.type]),
+    [
+      ["id", "column"],
+      ["user_id", "column"],
+      ["status", "column"],
+    ],
+  );
+  assert.equal(
+    items.some((item) => item.type === "table"),
+    false,
+  );
+});
+
+test("suggests columns from referenced tables in select list", () => {
+  const sql = "select na from public.users u join public.orders o on u.id = o.user_id";
+  const cursor = "select na".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.equal(items[0]?.label, "name");
+  assert.equal(items[0]?.type, "column");
+});
+
+test("suggests all columns expansion in select list when typing a column prefix", () => {
+  const sql = "select id from public.users";
+  const cursor = "select id".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables,
+    columnsByTable,
+  });
+
+  const allColumns = items.find((item) => item.type === "snippet" && item.label === "users.*");
+  assert.ok(allColumns);
+  assert.equal(allColumns.apply, "id, name, email");
+});
+
+test("qualifies all columns expansion with table aliases", () => {
+  const sql = "select id from public.users u";
+  const cursor = "select id".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables,
+    columnsByTable,
+  });
+
+  const allColumns = items.find((item) => item.type === "snippet" && item.label === "u.*");
+  assert.ok(allColumns);
+  assert.equal(allColumns.apply, "u.id, u.name, u.email");
+});
+
+test("suggests all columns expansion for each joined table", () => {
+  const sql = "select id from public.users u join public.orders o on u.id = o.user_id";
+  const cursor = "select id".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.equal(items.find((item) => item.type === "snippet" && item.label === "u.*")?.apply, "u.id, u.name, u.email");
+  assert.equal(items.find((item) => item.type === "snippet" && item.label === "o.*")?.apply, "o.id, o.user_id, o.status");
+});
+
+test("suggests all columns expansion after an alias qualifier in select list", () => {
+  const sql = "select u. from public.users u join public.orders o on u.id = o.user_id";
+  const cursor = "select u.".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables,
+    columnsByTable,
+  });
+
+  const allColumns = items.find((item) => item.type === "snippet" && item.label === "u.*");
+  assert.ok(allColumns);
+  assert.equal(allColumns.apply, "id, u.name, u.email");
+  assert.equal(
+    items.some((item) => item.type === "snippet" && item.label === "o.*"),
+    false,
+  );
+});
+
+test("keeps all columns expansion available after an alias-qualified column prefix", () => {
+  const sql = "select u.i from public.users u join public.orders o on u.id = o.user_id";
+  const cursor = "select u.i".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables,
+    columnsByTable,
+  });
+
+  const allColumns = items.find((item) => item.type === "snippet" && item.label === "u.*");
+  assert.ok(allColumns);
+  assert.equal(allColumns.apply, "id, u.name, u.email");
+});
+
+test("does not suggest all columns expansion outside select list", () => {
+  const sql = "select * from public.users u where id";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.equal(
+    items.some((item) => item.type === "snippet" && item.label === "u.*"),
+    false,
+  );
+});
+
+test("suggests tables after LEFT JOIN", () => {
+  const sql = "select * from users left join us";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.ok(items.some((item) => item.label === "users" && item.type === "table"));
+  assert.ok(items.some((item) => item.label === "user_profiles" && item.type === "table"));
+});
+
+test("suggests compound JOIN keywords while typing a join modifier", () => {
+  const sql = "select * from users le";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  const leftJoinIndex = items.findIndex((item) => item.type === "keyword" && item.label === "LEFT JOIN");
+  const leftIndex = items.findIndex((item) => item.type === "keyword" && item.label === "LEFT");
+
+  assert.ok(leftJoinIndex >= 0);
+  assert.ok(leftIndex >= 0);
+  assert.ok(leftJoinIndex < leftIndex, "LEFT JOIN should rank ahead of the single LEFT token");
+  assert.equal(items[leftJoinIndex]?.apply, "LEFT JOIN ");
+});
+
+test("suggests JOIN after a join modifier", () => {
+  const sql = "select * from users left ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.deepEqual(
+    items.map((item) => [item.label, item.type]),
+    [["JOIN", "keyword"]],
+  );
+});
+
+test("suggests tables after comma in FROM clause", () => {
+  const sql = "select * from users, or";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.ok(items.some((item) => item.label === "orders" && item.type === "table"));
+});
+
+test("suggests keywords when typing without context", () => {
+  const sql = "us";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.ok(items.some((item) => item.type === "keyword" && item.label === "USING"));
+});
+
+test("suggests only matching table names after FROM object input", () => {
+  const sql = "select * from us";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  const tableItems = items.filter((item) => item.type === "table");
+  assert.ok(tableItems.length > 0);
+  assert.deepEqual(
+    tableItems.map((item) => item.label),
+    ["users", "user_profiles"],
+  );
+});
+
+test("keeps schema-qualified FROM object input in table suggestion mode", () => {
+  const sql = "select * from public.us";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  const tableItems = items.filter((item) => item.type === "table");
+  assert.ok(tableItems.length > 0);
+  assert.deepEqual(
+    tableItems.map((item) => item.label),
+    ["users", "user_profiles"],
+  );
+});
+
+test("keeps database-qualified FROM input in table suggestion mode", () => {
+  const sql = "select * from other_db.or";
+  const context = getSqlCompletionContext(sql, sql.length);
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [{ name: "orders", schema: "other_db", type: "table" }],
+    columnsByTable: new Map(),
+    databaseType: "mysql",
+  });
+
+  assert.equal(context.qualifier, "other_db");
+  assert.deepEqual(context.qualifierParts, ["other_db"]);
+  assert.equal(context.prefix, "or");
+  assert.equal(context.suggestTables, true);
+  assert.equal(context.exclusiveColumnSuggestions, false);
+  assert.deepEqual(
+    items.map((item) => [item.label, item.type, item.detail]),
+    [["orders", "table", "other_db.orders"]],
+  );
+});
+
+test("tracks qualifier parts for database-qualified column completion", () => {
+  const sql = "select * from other_db.orders where other_db.orders.st";
+  const context = getSqlCompletionContext(sql, sql.length);
+
+  assert.equal(context.qualifier, "other_db.orders");
+  assert.deepEqual(context.qualifierParts, ["other_db", "orders"]);
+  assert.equal(context.prefix, "st");
+  assert.equal(context.exclusiveColumnSuggestions, true);
+});
+
+test("suggests columns after database-qualified table qualifier", () => {
+  const sql = "select * from other_db.orders where other_db.orders.";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [{ name: "orders", schema: "other_db", type: "table" }],
+    columnsByTable: mysqlCrossDatabaseColumnsByTable,
+    databaseType: "mysql",
+  });
+
+  assert.deepEqual(
+    items.map((item) => [item.label, item.type, item.detail]),
+    [
+      ["id", "column", "orders  [bigint]"],
+      ["number", "column", "orders  [varchar]"],
+      ["status", "column", "orders  [varchar]"],
+    ],
+  );
+});
+
+test("scopes database-qualified table column suggestions to the matching database", () => {
+  const sql = "select * from other_db.orders where other_db.orders.st";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [{ name: "orders", schema: "other_db", type: "table" }],
+    columnsByTable: mysqlCrossDatabaseColumnsByTable,
+    databaseType: "mysql",
+  });
+
+  assert.deepEqual(
+    items.map((item) => [item.label, item.type, item.detail]),
+    [["status", "column", "orders  [varchar]"]],
+  );
+});
+
+test("keeps aliases working for database-qualified tables", () => {
+  const sql = "select * from other_db.orders o where o.";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [{ name: "orders", schema: "other_db", type: "table" }],
+    columnsByTable: mysqlCrossDatabaseColumnsByTable,
+    databaseType: "mysql",
+  });
+
+  assert.deepEqual(
+    items.map((item) => [item.label, item.type]),
+    [
+      ["id", "column"],
+      ["number", "column"],
+      ["status", "column"],
+    ],
+  );
+});
+
+test("includes views in exclusive FROM object suggestions", () => {
+  const sql = "select * from tick";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  const tableItems = items.filter((item) => item.type === "table");
+  assert.deepEqual(
+    tableItems.map((item) => [item.label, item.type, item.detail]),
+    [["ticket_summary", "table", "public.ticket_summary"]],
+  );
+});
+
+test("suggests only table names after JOIN object input", () => {
+  const sql = "select * from users join us";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  const tableItems = items.filter((item) => item.type === "table");
+  assert.ok(tableItems.length > 0);
+  assert.deepEqual(
+    tableItems.map((item) => item.label),
+    ["users", "user_profiles"],
+  );
+});
+
+test("suggests SQL Server IF keyword for conditional DDL", () => {
+  const sql = "DROP TABLE I";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.ok(items.some((item) => item.type === "keyword" && item.label === "IF"));
+});
+
+test("suggests SQL Server IIF and CHOOSE scalar functions", () => {
+  const iifItems = buildSqlCompletionItems("SELECT II", "SELECT II".length, {
+    tables,
+    columnsByTable,
+  });
+  const chooseItems = buildSqlCompletionItems("SELECT CHO", "SELECT CHO".length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.ok(
+    iifItems.some((item) => item.label === "IIF"),
+    "IIF should appear in completion",
+  );
+  assert.ok(
+    chooseItems.some((item) => item.label === "CHOOSE"),
+    "CHOOSE should appear in completion",
+  );
+});
+
+test("only suggests Cloudflare D1 supported common functions", () => {
+  const supported = buildSqlCompletionItems("SELECT SQ", "SELECT SQ".length, {
+    tables,
+    columnsByTable,
+    databaseType: "cloudflare-d1",
+  });
+  const unsupportedNow = buildSqlCompletionItems("SELECT NO", "SELECT NO".length, {
+    tables,
+    columnsByTable,
+    databaseType: "cloudflare-d1",
+  });
+  const unsupportedPower = buildSqlCompletionItems("SELECT PO", "SELECT PO".length, {
+    tables,
+    columnsByTable,
+    databaseType: "cloudflare-d1",
+  });
+
+  assert.ok(supported.some((item) => item.label === "SQRT"));
+  assert.ok(!unsupportedNow.some((item) => item.label === "NOW"));
+  assert.ok(!unsupportedPower.some((item) => item.label === "POWER"));
+});
+
+test("suggests SQL Server IDENTITY_INSERT after SET", () => {
+  const sql = "set  iden";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+    databaseType: "sqlserver",
+  });
+
+  assert.ok(items.some((item) => item.type === "keyword" && item.label === "IDENTITY_INSERT"));
+});
+
+test("suggests common SQL Server SET options", () => {
+  for (const [sql, expected] of [
+    ["set noc", "NOCOUNT"],
+    ["set xact", "XACT_ABORT"],
+    ["set ansi", "ANSI_NULLS"],
+    ["set stat", "STATISTICS IO"],
+    ["set transaction iso", "TRANSACTION ISOLATION LEVEL"],
+  ] as const) {
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      tables,
+      columnsByTable,
+      databaseType: "sqlserver",
+    });
+
+    assert.ok(
+      items.some((item) => item.type === "keyword" && item.label === expected),
+      `${expected} should appear for ${sql}`,
+    );
+  }
+});
+
+test("suggests SQL Server data types in CREATE TABLE column definitions", () => {
+  const sql = "CREATE TABLE dbo.jobs (id ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.ok(items.some((item) => item.type === "keyword" && item.label === "INT"));
+  assert.ok(items.some((item) => item.type === "keyword" && item.label === "BIGINT"));
+  assert.ok(items.some((item) => item.type === "keyword" && item.label === "NVARCHAR"));
+});
+
+test("does not auto-open completion after structural punctuation", () => {
+  for (const sql of ["select count(*)", "select * from users;", "select * from users,"]) {
+    assert.equal(shouldAutoOpenSqlCompletion(sql, sql.length), false, sql);
+  }
+});
+
+test("does not auto-open completion inside SQL comments", () => {
+  for (const { sql, cursor } of [
+    { sql: "-- sougou", cursor: "-- sougou".length },
+    { sql: "select 1 -- sougou", cursor: "select 1 -- sougou".length },
+    { sql: "# sougou", cursor: "# sougou".length },
+    { sql: "select /* sougou */ 1", cursor: "select /* sougou".length },
+    { sql: "select /* sougou", cursor: "select /* sougou".length },
+  ]) {
+    assert.equal(shouldAutoOpenSqlCompletion(sql, cursor), false, sql);
+  }
+  assert.equal(isSqlCommentContext("select '-- not comment' as value", "select '-- not comment'".length), false);
+  assert.equal(isSqlCommentContext("select /* comment */ val", "select /* comment */ val".length), false);
+  assert.equal(shouldAutoOpenSqlCompletion("select '-- not comment' as value", "select '-- not comment' as value".length), true);
+  assert.equal(shouldAutoOpenSqlCompletion("select /* comment */ val", "select /* comment */ val".length), true);
+});
+
+test("does not auto-open or build metadata completion inside SQL string literals", () => {
+  const likeSql = "select * from orders where status like '%9250%'";
+  const likeCursor = "select * from orders where status like '%9250%".length;
+  assert.equal(isSqlStringLiteralContext(likeSql, likeCursor), true);
+  assert.equal(shouldAutoOpenSqlCompletion(likeSql, likeCursor), false);
+  assert.deepEqual(
+    buildSqlCompletionItems(likeSql, likeCursor, {
+      tables,
+      columnsByTable,
+    }),
+    [],
+  );
+
+  const escapedQuoteSql = "select * from orders where status = 'it''s 9250'";
+  const escapedQuoteCursor = "select * from orders where status = 'it''s 9250".length;
+  assert.equal(isSqlStringLiteralContext(escapedQuoteSql, escapedQuoteCursor), true);
+  assert.equal(shouldAutoOpenSqlCompletion(escapedQuoteSql, escapedQuoteCursor), false);
+
+  const afterLiteralSql = "select '-- not comment' as value";
+  assert.equal(isSqlStringLiteralContext(afterLiteralSql, afterLiteralSql.length), false);
+  assert.equal(shouldAutoOpenSqlCompletion(afterLiteralSql, afterLiteralSql.length), true);
+});
+
+test("auto-opens completion after word characters and explicit dot qualifiers", () => {
+  for (const sql of ["sel", "select * from us", "select u."]) {
+    assert.equal(shouldAutoOpenSqlCompletion(sql, sql.length), true, sql);
+  }
+});
+
+test("auto-opens table completion immediately after FROM context whitespace", () => {
+  for (const sql of ["select * from ", "select * from users join ", "select * from users, ", "insert into "]) {
+    assert.equal(shouldAutoOpenSqlCompletion(sql, sql.length), true, sql);
+  }
+});
+
+test("auto-opens column completion immediately after condition context whitespace", () => {
+  for (const { sql, cursor = sql.length } of [
+    { sql: "select * from users where " },
+    {
+      sql: "SELECT *\nFROM t_0001 AS t0 WHERE \nLIMIT 100;",
+      cursor: "SELECT *\nFROM t_0001 AS t0 WHERE ".length,
+    },
+  ]) {
+    assert.equal(shouldAutoOpenSqlCompletion(sql, cursor), true, sql);
+  }
+});
+
+test("does not auto-open column completion immediately after comparison operators", () => {
+  for (const sql of ["SELECT * FROM public.users WHERE id>", "SELECT * FROM public.users WHERE id> ", "SELECT * FROM public.users WHERE id = "]) {
+    assert.equal(shouldAutoOpenSqlCompletion(sql, sql.length), false, sql);
+  }
+  const rhsColumnPrefix = "SELECT * FROM public.users WHERE id > i";
+  assert.equal(shouldAutoOpenSqlCompletion(rhsColumnPrefix, rhsColumnPrefix.length), true);
+});
+
+test("does not auto-open keyword completion immediately after a completed numeric WHERE value", () => {
+  for (const { sql, cursor = sql.length } of [
+    { sql: "SELECT * FROM public.users WHERE id > 0" },
+    { sql: "SELECT * FROM public.users WHERE id > 0 " },
+    {
+      sql: "SELECT *\nFROM t_0001 AS t0 WHERE id>0\nLIMIT 100;",
+      cursor: "SELECT *\nFROM t_0001 AS t0 WHERE id>0".length,
+    },
+  ]) {
+    assert.equal(shouldAutoOpenSqlCompletion(sql, cursor), false, sql);
+  }
+  const nextKeywordPrefix = "SELECT * FROM public.users WHERE id > 0 l";
+  assert.equal(shouldAutoOpenSqlCompletion(nextKeywordPrefix, nextKeywordPrefix.length), true);
+});
+
+test("auto-opens keyword completion after JOIN modifier whitespace", () => {
+  assert.equal(shouldAutoOpenSqlCompletion("select * from users left ", "select * from users left ".length), true);
+  assert.equal(shouldAutoOpenSqlCompletion("select left ", "select left ".length), false);
+});
+
+test("auto-opens INSERT target column completion after column-list punctuation", () => {
+  for (const sql of ["insert into users (", "insert into users (id, "]) {
+    assert.equal(shouldAutoOpenSqlCompletion(sql, sql.length), true, sql);
+  }
+});
+
+test("suggests table names for empty FROM context prefix", () => {
+  const items = buildSqlCompletionItems("select * from ", "select * from ".length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.deepEqual(
+    items.slice(0, 4).map((item) => [item.label, item.type]),
+    [
+      ["users", "table"],
+      ["user_profiles", "table"],
+      ["orders", "table"],
+      ["ticket_summary", "table"],
+    ],
+  );
+});
+
+test("suggests table names for empty INSERT INTO target prefix", () => {
+  const items = buildSqlCompletionItems("insert into ", "insert into ".length, {
+    tables,
+    columnsByTable,
+    schemas: ["public", "express-vue", "mall"],
+  });
+
+  assert.deepEqual(
+    items.slice(0, 4).map((item) => [item.label, item.type]),
+    [
+      ["users", "table"],
+      ["user_profiles", "table"],
+      ["orders", "table"],
+      ["ticket_summary", "table"],
+    ],
+  );
+  assert.ok(items.findIndex((item) => item.type === "schema" && item.label === "public") > 3);
+});
+
+test("suggests matching table names for partial table input", () => {
+  const items = buildSqlCompletionItems("select * from ihli", "select * from ihli".length, {
+    tables: [{ name: "ihli_data", schema: "public", type: "table" }],
+    columnsByTable,
+  });
+
+  const tableItems = items.filter((item) => item.type === "table");
+  assert.deepEqual(
+    tableItems.map((item) => [item.label, item.type, item.detail]),
+    [["ihli_data", "table", "public.ihli_data"]],
+  );
+});
+
+test("keeps completed references while removing active JOIN table prefixes", () => {
+  const context = getSqlCompletionContext("select * from users join ex", "select * from users join ex".length);
+
+  assert.deepEqual(
+    context.referencedTables.map((table) => table.name),
+    ["users"],
+  );
+});
+
+test("extracts JOIN tables without explicit aliases", () => {
+  const sql = "select * from a join b on a.id = b.id";
+  const context = getSqlCompletionContext(sql, sql.length);
+
+  assert.deepEqual(
+    context.referencedTables.map((table) => table.name),
+    ["a", "b"],
+  );
+});
+
+test("extracts MySQL backtick-qualified tables across a JOIN", () => {
+  const sql = [
+    "select",
+    "  `jobdb`.`job_application_ats_process`.`process_id`,",
+    "  count(*)",
+    "from",
+    "  `jobdb`.`job_application`",
+    "join `jobdb`.`job_application_ats_process` on",
+    "  `jobdb`.`job_application`.`id` = `jobdb`.`job_application_ats_process`.`app_id`",
+  ].join("\n");
+  const context = getSqlCompletionContext(sql, sql.length);
+
+  assert.deepEqual(
+    context.referencedTables.map(({ schema, name }) => ({ schema, name })),
+    [
+      { schema: "jobdb", name: "job_application" },
+      { schema: "jobdb", name: "job_application_ats_process" },
+    ],
+  );
+});
+
+test("extracts every table across consecutive JOINs", () => {
+  const sql = "select * from db.a join db.b on 1=1 join db.c on 2=2";
+  const context = getSqlCompletionContext(sql, sql.length);
+
+  assert.deepEqual(
+    context.referencedTables.map(({ schema, name }) => ({ schema, name })),
+    [
+      { schema: "db", name: "a" },
+      { schema: "db", name: "b" },
+      { schema: "db", name: "c" },
+    ],
+  );
+});
+
+test("extracts tables across a MySQL STRAIGHT_JOIN", () => {
+  const sql = "select * from db.a straight_join db.b on db.a.id = db.b.id";
+  const context = getSqlCompletionContext(sql, sql.length);
+
+  assert.deepEqual(
+    context.referencedTables.map(({ schema, name, alias }) => ({ schema, name, alias })),
+    [
+      { schema: "db", name: "a", alias: undefined },
+      { schema: "db", name: "b", alias: undefined },
+    ],
+  );
+});
+
+test("keeps explicit table aliases across a JOIN", () => {
+  const sql = "select * from db.a x join db.b y";
+  const context = getSqlCompletionContext(sql, sql.length);
+
+  assert.deepEqual(
+    context.referencedTables.map(({ schema, name, alias }) => ({ schema, name, alias })),
+    [
+      { schema: "db", name: "a", alias: "x" },
+      { schema: "db", name: "b", alias: "y" },
+    ],
+  );
+});
+
+test("does not treat WHERE as a table alias", () => {
+  const sql = "select * from a where id = 1";
+  const context = getSqlCompletionContext(sql, sql.length);
+
+  assert.deepEqual(
+    context.referencedTables.map(({ name, alias }) => ({ name, alias })),
+    [{ name: "a", alias: undefined }],
+  );
+});
+
+test("ranks exact table matches above prefix and fuzzy matches", () => {
+  const items = buildSqlCompletionItems("select * from toh", "select * from toh".length, {
+    tables: [
+      { name: "to_his_rec", schema: "public", type: "table" },
+      { name: "toh", schema: "public", type: "table" },
+      { name: "toh_archive", schema: "public", type: "table" },
+    ],
+    columnsByTable,
+  });
+
+  const tableItems = items.filter((item) => item.type === "table");
+  assert.deepEqual(
+    tableItems.map((item) => item.label),
+    ["toh", "toh_archive", "to_his_rec"],
+  );
+});
+
+test("ranks exact keyword matches above prefix-matching routines (#3002)", () => {
+  const sql = "create table t (id int";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [],
+    objects: [
+      { name: "int_proc_sync", type: "procedure" },
+      { name: "sp_interface", type: "procedure" },
+      { name: "fn_to_int", type: "function" },
+    ],
+    columnsByTable: new Map(),
+    databaseType: "sqlserver",
+  });
+
+  assert.equal(items[0]?.label, "INT");
+  assert.equal(items[0]?.type, "keyword");
+});
+
+test("preserves an exact routine match before truncating candidates", () => {
+  const sql = "select aaa";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [],
+    objects: [
+      ...Array.from({ length: 200 }, (_, index) => ({ name: `a_a_a_${index}`, type: "procedure" as const })),
+      { name: "aaa", type: "function" },
+    ],
+    columnsByTable: new Map(),
+  });
+
+  assert.equal(items[0]?.label, "aaa");
+  assert.equal(items[0]?.type, "function");
+});
+
+test("ranks an exact table label match first", () => {
+  const sql = "select * from orders";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "orders", type: "table" },
+      { name: "orders_archive", type: "table" },
+    ],
+    columnsByTable: new Map(),
+  });
+
+  assert.equal(items[0]?.label, "orders");
+  assert.equal(items[0]?.type, "table");
+});
+
+test("ranks an exact column match above an exact keyword match", () => {
+  const sql = "select limit from t";
+  const items = buildSqlCompletionItems(sql, "select limit".length, {
+    tables: [{ name: "t", type: "table" }],
+    columnsByTable: new Map([["t", [{ name: "limit", table: "t", dataType: "text" }]]]),
+  });
+  const columnIndex = items.findIndex((item) => item.type === "column" && item.label === "limit");
+  const keywordIndex = items.findIndex((item) => item.type === "keyword" && item.label === "LIMIT");
+
+  assert.ok(columnIndex >= 0);
+  assert.ok(keywordIndex >= 0);
+  assert.ok(columnIndex < keywordIndex);
+});
+
+test("ranks an exact table match above foreign-key related prefix matches", () => {
+  const sql = "select * from orders join customers";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "orders", type: "table" },
+      { name: "customers", type: "table" },
+      { name: "customers_ext", type: "table" },
+    ],
+    columnsByTable: new Map(),
+    foreignKeysByTable: new Map([["orders", [{ column: "customer_id", ref_table: "customers_ext", ref_column: "id" }]]]),
+  });
+
+  assert.equal(items[0]?.label, "customers");
+  assert.equal(items[0]?.type, "table");
+});
+
+test("ranks an exact match first even when a fuzzy candidate outscores the numeric boost", () => {
+  // A long tight-fuzzy foreign-key candidate accumulates boundary bonuses beyond
+  // EXACT_LABEL_MATCH_BOOST; only the exactMatch comparator key keeps the exact item first.
+  const exactName = "ab".repeat(300);
+  const fuzzyName = Array.from({ length: 300 }, () => "ab").join("_");
+  const sql = `select * from orders join ${exactName}`;
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "orders", type: "table" },
+      { name: exactName, type: "table" },
+      { name: fuzzyName, type: "table" },
+    ],
+    columnsByTable: new Map(),
+    foreignKeysByTable: new Map([["orders", [{ column: "x_id", ref_table: fuzzyName, ref_column: "id" }]]]),
+  });
+
+  assert.equal(items[0]?.label, exactName);
+  assert.equal(items[0]?.type, "table");
+});
+
+test("does not reuse table completion results across typed prefixes", () => {
+  const validFor = getSqlCompletionResultValidFor("select * from ", "select * from ".length);
+
+  assert.equal(validFor, undefined);
+});
+
+test("does not reuse keyword completion results across typed prefixes", () => {
+  const validFor = getSqlCompletionResultValidFor("select * f", "select * f".length);
+
+  assert.equal(validFor, undefined);
+});
+
+test("auto-opens completion after ON whitespace for join conditions", () => {
+  const sql = "select * from public.users u join public.orders o on ";
+
+  assert.equal(shouldAutoOpenSqlCompletion(sql, sql.length), true);
+});
+
+test("limits table suggestions for large schemas after filtering by prefix", () => {
+  const largeTables: SqlCompletionTable[] = Array.from({ length: 500 }, (_, index) => ({
+    name: `erp_invoice_${String(index).padStart(4, "0")}`,
+    schema: "dbo",
+    type: "table",
+  }));
+
+  const sql = "select * from erp_invoice_";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: largeTables,
+    columnsByTable,
+  });
+
+  const tableItems = items.filter((item) => item.type === "table");
+  assert.equal(tableItems.length, 200);
+  assert.equal(tableItems[0]?.label, "erp_invoice_0000");
+  assert.equal(tableItems.at(-1)?.label, "erp_invoice_0199");
+});
+
+test("suggests SQL snippets for common abbreviations", () => {
+  const items = buildSqlCompletionItems("sel", 3, {
+    tables,
+    columnsByTable,
+  });
+
+  const snippet = items.find((item) => item.type === "snippet" && item.label === "select *");
+  assert.ok(snippet);
+  assert.equal(snippet.detail, "SELECT *\nFROM table\nLIMIT 100;");
+  assert.equal(snippet.apply, "SELECT *\nFROM ${table}\nLIMIT 100;");
+});
+
+test("prioritizes FROM after SELECT star when typing the keyword", () => {
+  const sql = "SELECT * f";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+    databaseType: "mysql",
+  });
+
+  assert.equal(items[0]?.label, "FROM");
+});
+
+test("prioritizes referenced columns in WHERE conditions", () => {
+  const sql = "SELECT * FROM public.users WHERE i";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+    databaseType: "mysql",
+  });
+
+  assert.equal(items[0]?.label, "id");
+});
+
+test("prioritizes referenced columns after WHERE comparison operators", () => {
+  const sql = "SELECT * FROM public.users WHERE id > i";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+    databaseType: "mysql",
+  });
+
+  assert.equal(items[0]?.label, "id");
+});
+
+test("prioritizes LIMIT after SELECT WHERE condition", () => {
+  const sql = "SELECT * FROM public.users WHERE id > 0 l";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+    databaseType: "mysql",
+  });
+
+  assert.equal(items[0]?.label, "LIMIT");
+});
+
+test("prioritizes AND after a completed WHERE condition", () => {
+  const sql = "SELECT * FROM public.users WHERE id > 0 a";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+    databaseType: "mysql",
+  });
+
+  assert.equal(items[0]?.label, "AND");
+});
+
+test("prioritizes OR after a completed WHERE condition", () => {
+  const sql = "SELECT * FROM public.users WHERE id > 0 o";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+    databaseType: "mysql",
+  });
+
+  assert.equal(items[0]?.label, "OR");
+});
+
+test("applies keyword case to built-in SQL snippets", () => {
+  const items = buildSqlCompletionItems("sel", 3, {
+    tables,
+    columnsByTable,
+    keywordCase: "lower",
+  });
+
+  const snippet = items.find((item) => item.type === "snippet" && item.label === "select *");
+  assert.ok(snippet);
+  assert.equal(snippet.detail, "select *\nfrom table\nlimit 100;");
+  assert.equal(snippet.apply, "select *\nfrom ${table}\nlimit 100;");
+});
+
+test("suggests DATE_FORMAT as parameter snippet", () => {
+  const sql = "select date_";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  const snippet = items.find((item) => item.type === "function" && item.label === "DATE_FORMAT");
+  assert.ok(snippet);
+  assert.equal(snippet.apply, "DATE_FORMAT(${date}, ${format})");
+});
+
+test("suggests stored procedures after CALL", () => {
+  const sql = "CALL rfs";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    objects: completionObjects,
+    columnsByTable,
+    dialect: "mysql",
+  });
+
+  const procedure = items.find((item) => item.label === "refresh_user_stats");
+  assert.ok(procedure);
+  assert.equal(procedure.type, "function");
+  assert.equal(procedure.apply, "app.refresh_user_stats()");
+  assert.equal(
+    items.some((item) => item.label === "format_user_name"),
+    false,
+  );
+});
+
+test("prioritizes referenced table columns in WHERE field input", () => {
+  const sql = "select * from A1User WHERE userc";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [{ name: "A1User", schema: "dbo", type: "table" }],
+    objects: [
+      { name: "P1UserCodeGenerate", schema: "dbo", type: "procedure" },
+      { name: "F22UserAccUnit", schema: "dbo", type: "function" },
+    ],
+    columnsByTable: new Map([
+      [
+        "dbo.A1User",
+        [
+          { name: "UserCode", table: "A1User", schema: "dbo", dataType: "varchar" },
+          { name: "UserName", table: "A1User", schema: "dbo", dataType: "varchar" },
+        ],
+      ],
+      ["dbo.OtherUserTable", [{ name: "UserCheck", table: "OtherUserTable", schema: "dbo", dataType: "varchar" }]],
+    ]),
+    databaseType: "sqlserver",
+  });
+
+  assert.deepEqual(
+    items.map((item) => [item.label, item.type]),
+    [["UserCode", "column"]],
+  );
+});
+
+test("keeps snippets below matching WHERE field columns", () => {
+  const sql = "select * from demo_2000_tables.t_0001 WHERE i";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [{ name: "t_0001", schema: "demo_2000_tables", type: "table" }],
+    columnsByTable: new Map([
+      [
+        "demo_2000_tables.t_0001",
+        [
+          { name: "id", table: "t_0001", schema: "demo_2000_tables", dataType: "int", comment: "注释test" },
+          { name: "image_url", table: "t_0001", schema: "demo_2000_tables", dataType: "varchar(512)", comment: "xixixi" },
+          { name: "image_mime", table: "t_0001", schema: "demo_2000_tables", dataType: "varchar(64)", comment: "hahaha" },
+        ],
+      ],
+    ]),
+  });
+
+  assert.deepEqual(
+    items.slice(0, 3).map((item) => [item.label, item.type]),
+    [
+      ["id", "column"],
+      ["image_url", "column"],
+      ["image_mime", "column"],
+    ],
+  );
+  assert.equal(
+    items.some((item) => item.type === "snippet" && item.label === "insert into"),
+    false,
+  );
+});
+
+test("suggests referenced table columns after WHERE whitespace", () => {
+  const sql = "select * from users where ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.deepEqual(
+    items
+      .filter((item) => item.type === "column")
+      .slice(0, 3)
+      .map((item) => item.label),
+    ["id", "name", "email"],
+  );
+});
+
+test("suggests user functions and triggers with fuzzy matching", () => {
+  const sql = "select fun";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    objects: completionObjects,
+    columnsByTable,
+    dialect: "mysql",
+  });
+
+  assert.ok(items.some((item) => item.label === "format_user_name" && item.detail === "function in app"));
+
+  const triggerItems = buildSqlCompletionItems("drop trigger tua", "drop trigger tua".length, {
+    tables,
+    objects: completionObjects,
+    columnsByTable,
+    dialect: "mysql",
+  });
+  assert.ok(triggerItems.some((item) => item.label === "trg_users_audit" && item.detail === "trigger on users"));
+});
+
+test("suggests Oracle table-function helpers in table reference context", () => {
+  const items = buildSqlCompletionItems("select * from tab", "select * from tab".length, {
+    tables,
+    columnsByTable,
+    databaseType: "oracle",
+  });
+
+  const tableFunction = items.find((item) => item.label === "TABLE" && item.type === "function");
+  assert.ok(tableFunction);
+  assert.ok(tableFunction.apply?.startsWith("TABLE("));
+});
+
+test("suggests package members after package qualifier", () => {
+  const items = buildSqlCompletionItems("begin PAYROLL.ca", "begin PAYROLL.ca".length, {
+    tables,
+    columnsByTable,
+    objects: [
+      { name: "PAYROLL", schema: "HR", type: "package" },
+      { name: "calculate_bonus", schema: "HR", type: "function", parentSchema: "HR", parentName: "PAYROLL" },
+    ],
+    databaseType: "oracle",
+  });
+
+  const member = items.find((item) => item.label === "calculate_bonus");
+  assert.ok(member);
+  assert.equal(member.type, "function");
+  assert.equal(member.apply, "calculate_bonus()");
+});
+
+test("matches alias qualifier case-insensitively", () => {
+  const sql = "select O. from public.orders o";
+  const cursor = "select O.".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables,
+    columnsByTable,
+  });
+
+  const columnItems = items.filter((item) => item.type === "column");
+  assert.deepEqual(
+    columnItems.map((item) => item.label),
+    ["id", "user_id", "status"],
+  );
+});
+
+test("suggests referenced columns after ORDER BY", () => {
+  const sql = "select name from public.users u order by na";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.equal(items[0]?.label, "name");
+  assert.equal(items[0]?.type, "column");
+});
+
+test("prioritizes select aliases in ORDER BY completion", () => {
+  const sql = "select u.name as display_name, count(*) order_count from public.users u order by ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.deepEqual(
+    items.slice(0, 2).map((item) => [item.label, item.detail]),
+    [
+      ["display_name", "SELECT alias"],
+      ["order_count", "SELECT alias"],
+    ],
+  );
+});
+
+test("prioritizes select aliases in GROUP BY completion", () => {
+  const sql = "select u.name as display_name from public.users u group by ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.equal(items[0]?.label, "display_name");
+  assert.equal(items[0]?.detail, "SELECT alias");
+});
+
+test("suggests likely join condition snippets after ON", () => {
+  const sql = "select * from public.users u join public.orders o on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  const joinCondition = items.find((item) => item.type === "snippet" && item.label === "u.id = o.user_id");
+  assert.ok(joinCondition);
+  assert.equal(joinCondition.apply, "u.id = o.user_id");
+});
+
+test("suggests likely join condition snippets when joined table owns the id column", () => {
+  const sql = "select * from public.orders o join public.users u on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  const joinCondition = items.find((item) => item.type === "snippet" && item.label === "o.user_id = u.id");
+  assert.ok(joinCondition);
+  assert.equal(joinCondition.apply, "o.user_id = u.id");
+});
+
+test("returns function signature help inside function arguments", () => {
+  const sql = "select date_format(created_at, ";
+  const signature = getSqlFunctionSignatureHelp(sql, sql.length);
+
+  assert.deepEqual(signature, {
+    name: "DATE_FORMAT",
+    signature: "DATE_FORMAT(date, format)",
+    activeParameter: 1,
+    parameters: ["date", "format"],
+  });
+});
+
+test("returns cast signature with AS syntax", () => {
+  const sql = "select cast(created_at ";
+  const signature = getSqlFunctionSignatureHelp(sql, sql.length);
+
+  assert.deepEqual(signature, {
+    name: "CAST",
+    signature: "CAST(expression AS type)",
+    activeParameter: 0,
+    parameters: ["expression AS type"],
+  });
+});
+
+test("returns null signature help outside function calls", () => {
+  assert.equal(getSqlFunctionSignatureHelp("select created_at from users", "select created_at".length), null);
+});
+
+// --- CTE support ---
+
+test("extracts CTE names from WITH clause", () => {
+  const ctes = extractCteDefinitions("WITH recent_orders AS (SELECT id FROM orders) SELECT * FROM recent_orders");
+  assert.equal(ctes.length, 1);
+  assert.equal(ctes[0]?.name, "recent_orders");
+});
+
+test("extracts CTE columns from SELECT body", () => {
+  const ctes = extractCteDefinitions("WITH cte AS (SELECT id, name, status FROM users) SELECT * FROM cte");
+  assert.equal(ctes.length, 1);
+  assert.deepEqual(ctes[0]?.columns, ["id", "name", "status"]);
+});
+
+test("extracts CTE explicit column list", () => {
+  const ctes = extractCteDefinitions("WITH cte (col1, col2) AS (SELECT 1, 2) SELECT * FROM cte");
+  assert.equal(ctes.length, 1);
+  assert.deepEqual(ctes[0]?.columns, ["col1", "col2"]);
+});
+
+test("extracts multiple CTEs", () => {
+  const ctes = extractCteDefinitions("WITH first AS (SELECT id FROM users), second AS (SELECT id FROM orders) SELECT * FROM first JOIN second");
+  assert.equal(ctes.length, 2);
+  assert.equal(ctes[0]?.name, "first");
+  assert.equal(ctes[1]?.name, "second");
+});
+
+test("handles WITH RECURSIVE", () => {
+  const ctes = extractCteDefinitions("WITH RECURSIVE tree AS (SELECT id, parent_id FROM categories UNION ALL SELECT c.id, c.parent_id FROM categories c JOIN tree t ON c.parent_id = t.id) SELECT * FROM tree");
+  assert.equal(ctes.length, 1);
+  assert.equal(ctes[0]?.name, "tree");
+});
+
+test("adds CTE tables to referenced tables in context", () => {
+  const sql = "WITH cte AS (SELECT id, name FROM users) SELECT * FROM cte";
+  const context = getSqlCompletionContext(sql, sql.length);
+  const cteRef = context.referencedTables.find((t) => t.name.toLowerCase() === "cte");
+  assert.ok(cteRef);
+  assert.ok(cteRef.columns);
+  assert.ok(cteRef.columns!.includes("id"));
+  assert.ok(cteRef.columns!.includes("name"));
+});
+
+// --- INSERT column list detection ---
+
+test("detects INSERT INTO column list context", () => {
+  const context = getSqlCompletionContext("INSERT INTO users (", "INSERT INTO users (".length);
+  assert.equal(context.insertTable, "users");
+  assert.equal(context.exclusiveColumnSuggestions, true);
+  assert.deepEqual(context.referencedTables, []);
+});
+
+test("detects INSERT INTO with schema-qualified table", () => {
+  const context = getSqlCompletionContext("INSERT INTO public.users (", "INSERT INTO public.users (".length);
+  assert.equal(context.insertTable, "users");
+  assert.equal(context.insertSchema, "public");
+});
+
+test("detects INSERT INTO column list with three-part qualified table", () => {
+  const sql = "INSERT INTO analytics.public.users (";
+  const context = getSqlCompletionContext(sql, sql.length);
+
+  assert.equal(context.insertTable, "users");
+  assert.equal(context.insertSchema, "public");
+});
+
+test("detects MySQL backtick-qualified INSERT INTO column list context", () => {
+  const sql = "INSERT INTO `other_db`.`orders` (";
+  const context = getSqlCompletionContext(sql, sql.length);
+  assert.equal(context.insertTable, "orders");
+  assert.equal(context.insertSchema, "other_db");
+});
+
+test("does not treat partial INSERT INTO targets as referenced tables", () => {
+  const context = getSqlCompletionContext("INSERT INTO ord", "INSERT INTO ord".length);
+
+  assert.equal(context.contextKind, "insert_target");
+  assert.equal(context.suggestTables, true);
+  assert.equal(context.exclusiveTableSuggestions, true);
+  assert.deepEqual(context.referencedTables, []);
+});
+
+test("does not treat following SQL keywords as table references while completing table names", () => {
+  const sql = "SELECT *\nFROM \nLIMIT 100";
+  const cursor = "SELECT *\nFROM ".length;
+  const context = getSqlCompletionContext(sql, cursor);
+
+  assert.equal(context.suggestTables, true);
+  assert.deepEqual(context.referencedTables, []);
+});
+
+test("suggests columns for INSERT INTO target table", () => {
+  const items = buildSqlCompletionItems("INSERT INTO users (", "INSERT INTO users (".length, {
+    tables,
+    columnsByTable,
+  });
+  const columnItems = items.filter((item) => item.type === "column");
+  assert.ok(columnItems.length >= 3);
+  assert.ok(columnItems.some((item) => item.label === "id"));
+  assert.ok(columnItems.some((item) => item.label === "name"));
+  assert.ok(columnItems.some((item) => item.label === "email"));
+});
+
+test("suggests all target columns for INSERT INTO column list", () => {
+  const items = buildSqlCompletionItems("INSERT INTO users (", "INSERT INTO users (".length, {
+    tables,
+    columnsByTable,
+  });
+
+  const allColumns = items.find((item) => item.type === "snippet" && item.label === "users.*");
+  assert.ok(allColumns);
+  assert.equal(allColumns.apply, "id, name, email");
+});
+
+test("keeps INSERT INTO all-column expansion available after a column prefix", () => {
+  const items = buildSqlCompletionItems("INSERT INTO users (id", "INSERT INTO users (id".length, {
+    tables,
+    columnsByTable,
+  });
+
+  const allColumns = items.find((item) => item.type === "snippet" && item.label === "users.*");
+  assert.ok(allColumns);
+  assert.equal(allColumns.apply, "id, name, email");
+});
+
+test("quotes PostgreSQL identifiers in INSERT INTO all-column expansion", () => {
+  const sql = 'INSERT INTO public."OrderLines" (';
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: postgresQuotedTables,
+    columnsByTable: postgresQuotedColumnsByTable,
+    databaseType: "postgres",
+    dialect: "postgres",
+  });
+
+  const allColumns = items.find((item) => item.type === "snippet" && item.label === "OrderLines.*");
+  assert.ok(allColumns);
+  assert.equal(allColumns.apply, 'article, "OrderId", "User", "has""quote"');
+});
+
+test("suggests all target columns for schema-qualified INSERT INTO column lists", () => {
+  const sql = "INSERT INTO dbo.Users (";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [{ name: "Users", schema: "dbo", type: "table" }],
+    columnsByTable: new Map([
+      [
+        "dbo.Users",
+        [
+          { name: "Id", table: "Users", schema: "dbo", dataType: "bigint" },
+          { name: "DisplayName", table: "Users", schema: "dbo", dataType: "nvarchar" },
+        ],
+      ],
+    ]),
+    databaseType: "sqlserver",
+    dialect: "sqlserver",
+  });
+
+  const allColumns = items.find((item) => item.type === "snippet" && item.label === "Users.*");
+  assert.ok(allColumns);
+  assert.equal(allColumns.apply, "Id, DisplayName");
+});
+
+test("scopes INSERT INTO all-column expansion to the database-qualified MySQL target", () => {
+  const sql = "INSERT INTO other_db.orders (";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [{ name: "orders", schema: "other_db", type: "table" }],
+    columnsByTable: mysqlCrossDatabaseColumnsByTable,
+    databaseType: "mysql",
+    dialect: "mysql",
+  });
+
+  const allColumns = items.find((item) => item.type === "snippet" && item.label === "orders.*");
+  assert.ok(allColumns);
+  assert.equal(allColumns.apply, "id, number, status");
+});
+
+test("suggests all target columns for MySQL backtick-qualified INSERT INTO", () => {
+  const sql = "INSERT INTO `other_db`.`orders` (";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [{ name: "orders", schema: "other_db", type: "table" }],
+    columnsByTable: mysqlCrossDatabaseColumnsByTable,
+    databaseType: "mysql",
+    dialect: "mysql",
+  });
+
+  const allColumns = items.find((item) => item.type === "snippet" && item.label === "orders.*");
+  assert.ok(allColumns);
+  assert.equal(allColumns.apply, "id, number, status");
+});
+
+// --- Column data type in detail ---
+
+test("shows column data type in detail", () => {
+  const items = buildSqlCompletionItems("select id from public.users u where u.", "select id from public.users u where u.".length, {
+    tables,
+    columnsByTable,
+  });
+  const emailColumn = items.find((item) => item.label === "email");
+  assert.ok(emailColumn);
+  assert.ok(emailColumn.detail!.includes("[varchar]"));
+});
+
+test("key columns get priority boost in column suggestions", () => {
+  const items = buildSqlCompletionItems("select  from public.users u", "select ".length, {
+    tables,
+    columnsByTable,
+  });
+  const columns = items.filter((item) => item.type === "column");
+  // id column may be qualified as "users.id" if duplicate exists across tables
+  const idItem = columns.find((item) => item.label === "users.id" || item.label === "id");
+  const nameItem = columns.find((item) => item.label === "name");
+  assert.ok(idItem);
+  assert.ok(nameItem);
+  assert.ok(idItem.boost > nameItem.boost, "id column should have higher boost than name");
+});
+
+test("referenced-table columns rank above keywords (#801)", () => {
+  const items = buildSqlCompletionItems("select  from public.users u", "select ".length, {
+    tables,
+    columnsByTable,
+  });
+  const column = items.find((item) => item.type === "column");
+  assert.ok(column, "should suggest columns when a table is referenced");
+  assert.ok(column.boost >= 2000, "referenced-table columns should be boosted above plain keywords");
+  const columnIdx = items.findIndex((item) => item.type === "column");
+  const keywordIdx = items.findIndex((item) => item.type === "keyword");
+  if (keywordIdx >= 0) {
+    assert.ok(columnIdx < keywordIdx, "columns should appear before keywords in a referenced-table context");
+  }
+});
+
+// --- Schema name completion ---
+
+test("suggests schema names alongside tables in FROM context", () => {
+  const items = buildSqlCompletionItems("select * from ", "select * from ".length, {
+    tables,
+    columnsByTable,
+    schemas: ["public", "private", "audit"],
+  });
+  const schemaItems = items.filter((item) => item.type === "schema");
+  const firstSchemaIndex = items.findIndex((item) => item.type === "schema");
+  const firstTableIndex = items.findIndex((item) => item.type === "table");
+
+  assert.ok(firstTableIndex >= 0);
+  assert.ok(firstSchemaIndex > firstTableIndex);
+  assert.equal(schemaItems.length, 3);
+  assert.ok(schemaItems.some((item) => item.label === "public"));
+  assert.equal(schemaItems[0]?.apply, "public.");
+});
+
+test("schema items include apply value with trailing dot", () => {
+  const items = buildSqlCompletionItems("select * from pub", "select * from pub".length, {
+    tables,
+    columnsByTable,
+    schemas: ["public"],
+  });
+  const schemaItems = items.filter((item) => item.type === "schema");
+  assert.equal(schemaItems.length, 1);
+  assert.equal(schemaItems[0]?.apply, "public.");
+});
+
+// --- Quoted identifier fix ---
+
+test("handles quoted identifiers with dots in splitQualifiedName", () => {
+  const sql = "select * from ";
+  const context = getSqlCompletionContext(sql, sql.length);
+  // Verify context handles quoted identifiers — just ensure no crash
+  assert.ok(context);
+});
+
+// --- Snippet ranking ---
+
+test("snippet boost uses label when label matches prefix better than snippet prefix", () => {
+  const items = buildSqlCompletionItems("select", "select".length, {
+    tables,
+    columnsByTable,
+  });
+  const snippet = items.find((item) => item.type === "snippet" && item.label === "select *");
+  assert.ok(snippet);
+  // Snippet should appear in top results even when typing full keyword
+  const topFive = items.slice(0, 5);
+  assert.ok(
+    topFive.some((item) => item.label === "select *"),
+    "select * snippet should be in top 5",
+  );
+});
+
+// --- Context-aware keyword filtering ---
+
+test("hides DDL keywords in SELECT statement context", () => {
+  const items = buildSqlCompletionItems("select * from users where ", "select * from users where ".length, {
+    tables,
+    columnsByTable,
+  });
+  const keywords = items.filter((item) => item.type === "keyword");
+  assert.ok(!keywords.some((item) => item.label === "CREATE"), "CREATE should not appear in SELECT context");
+  assert.ok(!keywords.some((item) => item.label === "ALTER"), "ALTER should not appear in SELECT context");
+  assert.ok(!keywords.some((item) => item.label === "DROP"), "DROP should not appear in SELECT context");
+  assert.ok(
+    keywords.some((item) => item.label === "AND"),
+    "AND should appear in SELECT context",
+  );
+  assert.ok(
+    keywords.some((item) => item.label === "OR"),
+    "OR should appear in SELECT context",
+  );
+});
+
+test("shows DDL keywords in CREATE TABLE context", () => {
+  const sql = "create table ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+  // In CREATE context, data types should appear
+  assert.ok(
+    items.some((item) => item.label === "INT" || item.label === "BIGINT"),
+    "data types should appear in CREATE",
+  );
+});
+
+test("filters data type keywords out of SELECT context", () => {
+  const sql = "select ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [{ name: "varchar_test", type: "table" }],
+    columnsByTable,
+  });
+  // Should not suggest VARCHAR as a keyword in SELECT context
+  const varcharAsKeyword = items.find((item) => item.type === "keyword" && item.label === "VARCHAR");
+  assert.ok(!varcharAsKeyword, "VARCHAR should not appear as keyword in SELECT context");
+});
+
+// --- Qualified column names for duplicates ---
+
+test("shows qualified column names when multiple tables share column name", () => {
+  const sql = "select  from public.users u join public.orders o on u.id = o.user_id";
+  const items = buildSqlCompletionItems(sql, "select ".length, {
+    tables,
+    columnsByTable,
+  });
+  const columns = items.filter((item) => item.type === "column");
+  assert.ok(
+    columns.some((item) => item.label === "users.id"),
+    "should show users.id",
+  );
+  assert.ok(
+    columns.some((item) => item.label === "orders.id"),
+    "should show orders.id",
+  );
+  assert.ok(
+    columns.some((item) => item.label === "name"),
+    "unique name should remain unqualified",
+  );
+  assert.ok(
+    columns.some((item) => item.label === "user_id"),
+    "unique user_id should remain unqualified",
+  );
+});
+
+// --- Window function OVER() ---
+
+test("suggests ROW_NUMBER with OVER clause", () => {
+  const items = buildSqlCompletionItems("select row_", "select row_".length, {
+    tables,
+    columnsByTable,
+  });
+  const rn = items.find((item) => item.label === "ROW_NUMBER" && item.type === "function")!;
+  assert.ok(rn);
+  assert.ok(rn.apply!.includes("OVER"), "ROW_NUMBER should include OVER()");
+  assert.ok(rn.apply!.includes("PARTITION BY"), "ROW_NUMBER should include PARTITION BY");
+});
+
+test("suggests RANK with OVER clause", () => {
+  const items = buildSqlCompletionItems("select ra", "select ra".length, {
+    tables,
+    columnsByTable,
+  });
+  const rank = items.find((item) => item.label === "RANK");
+  assert.ok(rank);
+  assert.ok(rank.apply!.includes("OVER"), "RANK should include OVER()");
+});
+
+// --- Subquery alias support ---
+
+test("extracts subquery alias as referenced table", () => {
+  const sql = "select * from (select id, name from users) sub";
+  const context = getSqlCompletionContext(sql, sql.length);
+  const subRef = context.referencedTables.find((t) => t.name === "sub");
+  assert.ok(subRef, "subquery alias should be in referenced tables");
+});
+
+test("extracts subquery alias columns", () => {
+  const sql = "select s. from (select id, name from users) s";
+  const context = getSqlCompletionContext(sql, "select s.".length);
+  const sqRef = context.referencedTables.find((t) => t.name === "s");
+  assert.ok(sqRef);
+  assert.ok(sqRef.columns!.includes("id"));
+  assert.ok(sqRef.columns!.includes("name"));
+});
+
+// --- Table alias suggestions ---
+
+test("suggests table alias after FROM table", () => {
+  const items = buildSqlCompletionItems("select * from users ", "select * from users ".length, {
+    tables,
+    columnsByTable,
+  });
+  const aliasItem = items.find((item) => item.type === "snippet" && item.detail?.includes("alias for"));
+  assert.ok(aliasItem, "should suggest alias for table");
+  assert.ok(aliasItem!.apply!.includes("AS"), "alias apply should include AS");
+});
+
+test("prioritizes table acronym matches above alias snippets", () => {
+  const acronymTables: SqlCompletionTable[] = [...tables, { name: "user_basic_info", schema: "public", type: "table" }];
+  const items = buildSqlCompletionItems("select * from ubi", "select * from ubi".length, {
+    tables: acronymTables,
+    columnsByTable,
+  });
+
+  assert.equal(items[0]?.label, "user_basic_info");
+  assert.equal(items[0]?.type, "table");
+  assert.ok(
+    items.some((item) => item.type === "snippet" && item.apply === "AS ubi "),
+    "alias snippet should remain available",
+  );
+});
+
+test("matches camelCase table acronyms", () => {
+  const acronymTables: SqlCompletionTable[] = [...tables, { name: "userBasicInfo", schema: "public", type: "table" }];
+  const items = buildSqlCompletionItems("select * from ubi", "select * from ubi".length, {
+    tables: acronymTables,
+    columnsByTable,
+  });
+
+  assert.equal(items[0]?.label, "userBasicInfo");
+  assert.equal(items[0]?.type, "table");
+});
+
+test("table alias suggestions avoid reserved words", () => {
+  const items = buildSqlCompletionItems("select * from orders ", "select * from orders ".length, {
+    tables,
+    columnsByTable,
+  });
+
+  const aliasItem = items.find((item) => item.type === "snippet" && item.detail === "alias for orders");
+  assert.ok(aliasItem);
+  assert.notEqual(aliasItem!.apply, "AS or ");
+  assert.equal(aliasItem!.apply, "AS ord ");
+});
+
+test("automatic table aliases avoid reserved words", () => {
+  const items = buildSqlCompletionItems("select * from ord", "select * from ord".length, {
+    tables,
+    columnsByTable,
+    autoAliasTables: true,
+  });
+
+  const tableItem = items.find((item) => item.type === "table" && item.label === "orders");
+  assert.ok(tableItem);
+  assert.notEqual(tableItem!.apply, "orders AS or");
+  assert.equal(tableItem!.apply, "orders AS ord");
+});
+
+test("automatic table aliases respect text after the cursor", () => {
+  const cases: Array<[string, number, string]> = [
+    ["select * from ord AS o", "select * from ord".length, "orders"],
+    ["select * from ord o", "select * from ord".length, "orders"],
+    ["select * from ord where id = 1", "select * from ord".length, "orders AS ord"],
+    ["select * from ord", "select * from ord".length, "orders AS ord"],
+    ["select * from ord, users", "select * from ord".length, "orders AS ord"],
+    ["select * from orders AS o", "select * from or".length, "orders"],
+    ["select * from ord单 AS o", "select * from ord".length, "orders"],
+    ["select * from orde\u0301 AS o", "select * from ord".length, "orders"],
+    ["select * from ord𐐀 AS o", "select * from ord".length, "orders"],
+    ['select * from ord AS "o"', "select * from ord".length, "orders"],
+    ["select * from ord `o`", "select * from ord".length, "orders"],
+    ["select * from ord AS ", "select * from ord".length, "orders"],
+    ["select * from ord /* comment */ AS o", "select * from ord".length, "orders"],
+    ["select * from ord -- comment\n  o", "select * from ord".length, "orders"],
+    ["select * from ord\n  o", "select * from ord".length, "orders"],
+    ["select * from ord /* ; */ AS o", "select * from ord".length, "orders"],
+    ["select * from ord /* comment */ where id = 1", "select * from ord".length, "orders AS ord"],
+  ];
+
+  for (const [sql, cursor, expectedApply] of cases) {
+    const items = buildSqlCompletionItems(sql, cursor, {
+      tables,
+      columnsByTable,
+      autoAliasTables: true,
+    });
+
+    const tableItem = items.find((item) => item.type === "table" && item.label === "orders");
+    assert.ok(tableItem, `should suggest orders for ${sql}`);
+    assert.equal(tableItem!.apply, expectedApply, sql);
+  }
+});
+
+test("table alias suggestions respect text after the cursor", () => {
+  const aliasedCases: Array<[string, number]> = [
+    ["select * from orders AS o", "select * from orders ".length],
+    ['select * from orders AS "o"', "select * from orders ".length],
+    ["select * from orders AS ", "select * from orders ".length],
+    ["select * from orders /* c */ AS o", "select * from orders ".length],
+  ];
+
+  for (const [sql, cursor] of aliasedCases) {
+    const items = buildSqlCompletionItems(sql, cursor, { tables, columnsByTable });
+    const aliasItem = items.find((item) => item.type === "snippet" && item.detail === "alias for orders");
+    assert.equal(aliasItem, undefined, sql);
+  }
+
+  const items = buildSqlCompletionItems("select * from orders ", "select * from orders ".length, { tables, columnsByTable });
+  const aliasItem = items.find((item) => item.type === "snippet" && item.detail === "alias for orders");
+  assert.ok(aliasItem, "alias snippet should remain available when no alias follows");
+});
+
+test("table alias suggestions avoid SQL keywords", () => {
+  const items = buildSqlCompletionItems("select * from item_file ", "select * from item_file ".length, {
+    tables: [{ name: "item_file", schema: "public", type: "table" }],
+    columnsByTable,
+  });
+
+  const aliasItem = items.find((item) => item.type === "snippet" && item.detail === "alias for item_file");
+  assert.ok(aliasItem);
+  assert.notEqual(aliasItem!.apply, "AS if ");
+  assert.equal(aliasItem!.apply, "AS it ");
+});
+
+test("automatic table aliases avoid SQL keywords", () => {
+  const cases: Array<[string, string]> = [
+    ["account_store", "account_store AS ac"],
+    ["account_type", "account_type AS ac"],
+    ["data_order", "data_order AS da"],
+    ["invoice_note", "invoice_note AS inv"],
+    ["item_file", "item_file AS it"],
+    ["item_status", "item_status AS it"],
+    ["new_order", "new_order AS ne"],
+    ["no_config", "no_config AS nc"],
+    ["order_node", "order_node AS ord"],
+    ["order_flow", "order_flow AS ord"],
+    ["order_region", "order_region AS ord"],
+    ["row_value", "row_value AS rv"],
+    ["use_case", "use_case AS uc"],
+    ["user_role", "user_role AS ur"],
+  ];
+
+  for (const [tableName, expectedApply] of cases) {
+    const sql = `select * from ${tableName.slice(0, 3)}`;
+    const items = buildSqlCompletionItems(sql, sql.length, {
+      tables: [{ name: tableName, schema: "public", type: "table" }],
+      columnsByTable,
+      autoAliasTables: true,
+    });
+
+    const tableItem = items.find((item) => item.type === "table" && item.label === tableName);
+    assert.ok(tableItem, `should suggest ${tableName}`);
+    assert.equal(tableItem!.apply, expectedApply);
+  }
+});
+
+test("table alias suggestions avoid existing aliases", () => {
+  const items = buildSqlCompletionItems("select * from customer_orders co join customer_orders ", "select * from customer_orders co join customer_orders ".length, {
+    tables: [...tables, { name: "customer_orders", schema: "public", type: "table" }],
+    columnsByTable,
+  });
+
+  const aliasItem = items.find((item) => item.type === "snippet" && item.detail === "alias for customer_orders");
+  assert.ok(aliasItem);
+  assert.notEqual(aliasItem!.apply, "AS co ");
+  assert.equal(aliasItem!.apply, "AS cu ");
+});
+
+// --- CASE snippet ---
+
+test("suggests CASE WHEN snippet", () => {
+  const items = buildSqlCompletionItems("case", "case".length, {
+    tables,
+    columnsByTable,
+  });
+  const caseSnippet = items.find((item) => item.type === "snippet" && item.label === "case when");
+  assert.ok(caseSnippet);
+  assert.ok(caseSnippet.apply!.includes("CASE"), "should include CASE");
+  assert.ok(caseSnippet.apply!.includes("WHEN"), "should include WHEN");
+  assert.ok(caseSnippet.apply!.includes("THEN"), "should include THEN");
+  assert.ok(caseSnippet.apply!.includes("END"), "should include END");
+});
+
+// --- Expanded function signatures ---
+
+test("suggests REGEXP_REPLACE with parameters", () => {
+  const items = buildSqlCompletionItems("select regexp_", "select regexp_".length, {
+    tables,
+    columnsByTable,
+  });
+  const fn = items.find((item) => item.label === "REGEXP_REPLACE" && item.type === "function");
+  assert.ok(fn);
+  assert.ok(fn.apply!.includes("pattern"), "should include pattern param");
+});
+
+test("suggests JSON_EXTRACT with parameters", () => {
+  const items = buildSqlCompletionItems("select json_", "select json_".length, {
+    tables,
+    columnsByTable,
+  });
+  const fn = items.find((item) => item.label === "JSON_EXTRACT" && item.type === "function");
+  assert.ok(fn);
+  assert.ok(fn.apply!.includes("json"), "should include json param");
+});
+
+// --- Smart GROUP BY suggestions ---
+
+test("boosts non-aggregated SELECT columns in GROUP BY context", () => {
+  const sql = "select u.name, count(o.id) from public.users u join public.orders o on u.id = o.user_id group by ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+  const nonAggItem = items.find((item) => item.label === "name" && item.detail?.includes("non-aggregated"));
+  assert.ok(nonAggItem, "non-aggregated column should appear with GROUP BY hint");
+});
+
+test("does not boost aggregated columns in GROUP BY context", () => {
+  const sql = "select u.name, count(o.id) from public.users u join public.orders o on u.id = o.user_id group by ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+  const aggHint = items.find((item) => item.detail?.includes("non-aggregated") && item.label === "id");
+  // "id" appears in count(o.id) — it's inside an aggregate, so shouldn't get the non-aggregated boost
+  // Note: id from users is not aggregated and appears as u.name is not aliased
+  assert.ok(!aggHint, "id inside aggregate should not get non-aggregated boost");
+});
+
+test("getSqlCompletionContext returns nonAggregatedSelectColumns", () => {
+  const sql = "select name, count(id) from users group by ";
+  const context = getSqlCompletionContext(sql, sql.length);
+  assert.ok(context.isGroupBy, "should detect GROUP BY context");
+  assert.ok(context.nonAggregatedSelectColumns.includes("name"), "name should be non-aggregated");
+  assert.ok(!context.nonAggregatedSelectColumns.includes("id"), "id inside COUNT should not be non-aggregated");
+});
+
+// --- UPDATE / DELETE completion contexts ---
+
+test("suggests SET immediately after UPDATE target table", () => {
+  const sql = "update users se";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.equal(items[0]?.label, "SET");
+});
+
+test("suggests target table columns inside UPDATE SET clause", () => {
+  const sql = "update users set na";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.equal(items[0]?.label, "name");
+  assert.equal(items[0]?.type, "column");
+});
+
+test("suggests WHERE after UPDATE SET assignments", () => {
+  const sql = "update users set name = 'a' wh";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.equal(items[0]?.label, "WHERE");
+});
+
+test("suggests WHERE immediately after DELETE target table", () => {
+  const sql = "delete from users wh";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+
+  assert.equal(items[0]?.label, "WHERE");
+});
+
+// --- Better FK join inference ---
+
+test("prefers explicit foreign-key join condition with table aliases", () => {
+  const foreignKeysByTable = new Map<string, SqlCompletionForeignKey[]>([["public.orders", [{ name: "orders_customer_id_fkey", column: "customer_id", ref_table: "customers", ref_column: "id" }]]]);
+  const sql = "select * from public.orders o join public.customers c on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "orders", schema: "public", type: "table" },
+      { name: "customers", schema: "public", type: "table" },
+    ],
+    columnsByTable,
+    foreignKeysByTable,
+  });
+
+  assert.deepEqual(items[0], {
+    label: "o.customer_id = c.id",
+    type: "snippet",
+    detail: "JOIN condition from foreign key",
+    apply: "o.customer_id = c.id",
+    boost: 3201,
+  });
+});
+
+test("applies keyword case to composite join condition snippets", () => {
+  const foreignKeysByTable = new Map<string, SqlCompletionForeignKey[]>([
+    [
+      "public.order_lines",
+      [
+        { name: "order_lines_product_fkey", column: "tenant_id", ref_table: "products", ref_column: "tenant_id" },
+        { name: "order_lines_product_fkey", column: "product_id", ref_table: "products", ref_column: "id" },
+      ],
+    ],
+  ]);
+  const cols = new Map<string, SqlCompletionColumn[]>([
+    [
+      "public.order_lines",
+      [
+        { name: "tenant_id", table: "order_lines", schema: "public", dataType: "bigint" },
+        { name: "product_id", table: "order_lines", schema: "public", dataType: "bigint" },
+      ],
+    ],
+    [
+      "public.products",
+      [
+        { name: "tenant_id", table: "products", schema: "public", dataType: "bigint" },
+        { name: "id", table: "products", schema: "public", dataType: "bigint" },
+      ],
+    ],
+  ]);
+  const sql = "select * from public.order_lines ol join public.products p on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "order_lines", schema: "public", type: "table" },
+      { name: "products", schema: "public", type: "table" },
+    ],
+    columnsByTable: cols,
+    foreignKeysByTable,
+    keywordCase: "lower",
+  });
+
+  const fkJoin = items.find((item) => item.detail === "JOIN condition from composite foreign key");
+  assert.equal(fkJoin?.label, "ol.tenant_id = p.tenant_id and ol.product_id = p.id");
+  assert.equal(fkJoin?.apply, "ol.tenant_id = p.tenant_id and ol.product_id = p.id");
+});
+
+test("suggests explicit foreign-key join when the joined table owns the key", () => {
+  const foreignKeysByTable = new Map<string, SqlCompletionForeignKey[]>([["public.orders", [{ name: "orders_customer_id_fkey", column: "customer_id", ref_table: "customers", ref_column: "id" }]]]);
+  const sql = "select * from public.customers c join public.orders o on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "customers", schema: "public", type: "table" },
+      { name: "orders", schema: "public", type: "table" },
+    ],
+    columnsByTable,
+    foreignKeysByTable,
+  });
+
+  const fkJoin = items.find((item) => item.label === "o.customer_id = c.id");
+  assert.ok(fkJoin, "should suggest FK join when the right side owns the foreign key");
+});
+
+test("boosts foreign-key related table candidates in JOIN table context", () => {
+  const foreignKeysByTable = new Map<string, SqlCompletionForeignKey[]>([["public.orders", [{ name: "orders_user_id_fkey", column: "user_id", ref_table: "users", ref_column: "id" }]]]);
+  const sql = "select * from public.orders o join us";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+    foreignKeysByTable,
+  });
+
+  assert.equal(items[0]?.label, "users");
+  assert.equal(items[0]?.type, "table");
+  assert.ok(items[0]?.detail?.includes("related by"));
+});
+
+test("boosts inbound foreign-key table candidates in JOIN table context", () => {
+  const foreignKeysByTable = new Map<string, SqlCompletionForeignKey[]>([["public.orders", [{ name: "orders_customer_id_fkey", column: "customer_id", ref_schema: "public", ref_table: "customers", ref_column: "id" }]]]);
+  const sql = "select * from public.customers c join ord";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+    foreignKeysByTable,
+  });
+
+  assert.equal(items[0]?.label, "orders");
+  assert.equal(items[0]?.type, "table");
+  assert.ok(items[0]?.detail?.includes("orders.customer_id"));
+});
+
+test("uses owner schema when ranking inbound foreign-key table candidates", () => {
+  const foreignKeysByTable = new Map<string, SqlCompletionForeignKey[]>([["sales.orders", [{ name: "orders_customer_id_fkey", column: "customer_id", ref_schema: "crm", ref_table: "customers", ref_column: "id" }]]]);
+  const sql = "select * from crm.customers c join ord";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "orders", schema: "public", type: "table" },
+      { name: "orders", schema: "sales", type: "table" },
+      { name: "customers", schema: "crm", type: "table" },
+    ],
+    columnsByTable,
+    foreignKeysByTable,
+  });
+
+  assert.equal(items[0]?.label, "orders");
+  assert.equal(items[0]?.detail, "related by sales.orders.customer_id → id");
+  assert.equal(items[0]?.apply, "orders");
+});
+
+test("suggests composite explicit foreign-key join conditions", () => {
+  const colsWithCompositeFk = new Map<string, SqlCompletionColumn[]>([
+    [
+      "public.products",
+      [
+        { name: "tenant_id", table: "products", schema: "public", dataType: "text" },
+        { name: "id", table: "products", schema: "public", dataType: "text" },
+      ],
+    ],
+    [
+      "public.order_lines",
+      [
+        { name: "tenant_id", table: "order_lines", schema: "public", dataType: "text" },
+        { name: "product_id", table: "order_lines", schema: "public", dataType: "text" },
+      ],
+    ],
+  ]);
+  const foreignKeysByTable = new Map<string, SqlCompletionForeignKey[]>([
+    [
+      "public.order_lines",
+      [
+        { name: "order_lines_product_fkey", column: "tenant_id", ref_table: "products", ref_column: "tenant_id" },
+        { name: "order_lines_product_fkey", column: "product_id", ref_table: "products", ref_column: "id" },
+      ],
+    ],
+  ]);
+  const sql = "select * from public.order_lines ol join public.products p on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "order_lines", schema: "public", type: "table" },
+      { name: "products", schema: "public", type: "table" },
+    ],
+    columnsByTable: colsWithCompositeFk,
+    foreignKeysByTable,
+  });
+
+  const fkJoin = items.find((item) => item.label === "ol.tenant_id = p.tenant_id AND ol.product_id = p.id");
+  assert.ok(fkJoin, "should suggest full composite FK join");
+  assert.equal(fkJoin?.detail, "JOIN condition from composite foreign key");
+});
+
+test("uses referenced schema to disambiguate explicit foreign-key joins", () => {
+  const foreignKeysByTable = new Map<string, SqlCompletionForeignKey[]>([
+    [
+      "sales.orders",
+      [
+        {
+          name: "orders_customer_id_fkey",
+          column: "customer_id",
+          ref_schema: "crm",
+          ref_table: "customers",
+          ref_column: "id",
+        },
+      ],
+    ],
+  ]);
+  const sql = "select * from sales.orders o join public.customers pc on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "orders", schema: "sales", type: "table" },
+      { name: "customers", schema: "public", type: "table" },
+      { name: "customers", schema: "crm", type: "table" },
+    ],
+    columnsByTable,
+    foreignKeysByTable,
+  });
+
+  assert.equal(
+    items.some((item) => item.label === "o.customer_id = pc.id" && item.detail === "JOIN condition from foreign key"),
+    false,
+  );
+});
+
+test("suggests likely composite joins from shared scope columns and id naming", () => {
+  const colsWithTenantRelationship = new Map<string, SqlCompletionColumn[]>([
+    [
+      "public.orders",
+      [
+        { name: "tenant_id", table: "orders", schema: "public", dataType: "text" },
+        { name: "id", table: "orders", schema: "public", dataType: "uuid" },
+      ],
+    ],
+    [
+      "public.order_lines",
+      [
+        { name: "tenant_id", table: "order_lines", schema: "public", dataType: "text" },
+        { name: "order_id", table: "order_lines", schema: "public", dataType: "uuid" },
+        { name: "article_id", table: "order_lines", schema: "public", dataType: "text" },
+      ],
+    ],
+  ]);
+  const sql = "select * from public.orders o join public.order_lines ol on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "orders", schema: "public", type: "table" },
+      { name: "order_lines", schema: "public", type: "table" },
+    ],
+    columnsByTable: colsWithTenantRelationship,
+  });
+
+  const compositeJoin = items.find((item) => item.label === "o.tenant_id = ol.tenant_id AND o.id = ol.order_id");
+  assert.ok(compositeJoin, "should combine tenant scope with id/FK naming");
+  assert.equal(compositeJoin?.detail, "Likely composite JOIN condition");
+});
+
+test("does not suggest heuristic joins for incompatible column types", () => {
+  const colsWithIncompatibleIds = new Map<string, SqlCompletionColumn[]>([
+    [
+      "public.users",
+      [
+        { name: "id", table: "users", schema: "public", dataType: "uuid" },
+        { name: "tenant_id", table: "users", schema: "public", dataType: "text" },
+      ],
+    ],
+    [
+      "public.orders",
+      [
+        { name: "user_id", table: "orders", schema: "public", dataType: "bigint" },
+        { name: "tenant_id", table: "orders", schema: "public", dataType: "text" },
+      ],
+    ],
+  ]);
+  const sql = "select * from public.users u join public.orders o on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "users", schema: "public", type: "table" },
+      { name: "orders", schema: "public", type: "table" },
+    ],
+    columnsByTable: colsWithIncompatibleIds,
+  });
+
+  assert.equal(
+    items.some((item) => item.label === "u.id = o.user_id"),
+    false,
+  );
+  assert.equal(
+    items.some((item) => item.label === "u.tenant_id = o.tenant_id AND u.id = o.user_id"),
+    false,
+  );
+});
+
+test("suggests join condition for same FK column in both tables", () => {
+  const colsWithFk = new Map<string, SqlCompletionColumn[]>([
+    [
+      "public.authors",
+      [
+        { name: "id", table: "authors", schema: "public", dataType: "bigint" },
+        { name: "publisher_id", table: "authors", schema: "public", dataType: "bigint" },
+      ],
+    ],
+    [
+      "public.books",
+      [
+        { name: "id", table: "books", schema: "public", dataType: "bigint" },
+        { name: "publisher_id", table: "books", schema: "public", dataType: "bigint" },
+      ],
+    ],
+  ]);
+  const sql = "select * from public.authors a join public.books b on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "authors", schema: "public", type: "table" },
+      { name: "books", schema: "public", type: "table" },
+    ],
+    columnsByTable: colsWithFk,
+  });
+  const fkJoin = items.find((item) => item.label === "a.publisher_id = b.publisher_id");
+  assert.ok(fkJoin, "should suggest join on shared FK column publisher_id");
+});
+
+test("suggests join condition for parent_id self-reference", () => {
+  const colsWithParent = new Map<string, SqlCompletionColumn[]>([
+    [
+      "public.categories",
+      [
+        { name: "id", table: "categories", schema: "public", dataType: "bigint" },
+        { name: "parent_id", table: "categories", schema: "public", dataType: "bigint" },
+        { name: "name", table: "categories", schema: "public", dataType: "varchar" },
+      ],
+    ],
+  ]);
+  // Self-join
+  const sql = "select * from public.categories c1 join public.categories c2 on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [{ name: "categories", schema: "public", type: "table" }],
+    columnsByTable: colsWithParent,
+  });
+  const parentJoin = items.find((item) => item.label === "c1.parent_id = c2.id" || item.label === "c2.parent_id = c1.id");
+  assert.ok(parentJoin, "should suggest parent_id = id for self-reference");
+});
+
+test("suggests join condition for created_by → id pattern", () => {
+  const colsWithCreator = new Map<string, SqlCompletionColumn[]>([
+    [
+      "public.users",
+      [
+        { name: "id", table: "users", schema: "public", dataType: "bigint" },
+        { name: "name", table: "users", schema: "public", dataType: "varchar" },
+      ],
+    ],
+    [
+      "public.documents",
+      [
+        { name: "id", table: "documents", schema: "public", dataType: "bigint" },
+        { name: "created_by", table: "documents", schema: "public", dataType: "bigint" },
+      ],
+    ],
+  ]);
+  const sql = "select * from public.users u join public.documents d on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "users", schema: "public", type: "table" },
+      { name: "documents", schema: "public", type: "table" },
+    ],
+    columnsByTable: colsWithCreator,
+  });
+  const creatorJoin = items.find((item) => item.label === "u.id = d.created_by");
+  assert.ok(creatorJoin, "should suggest id = created_by join");
+});
+
+test("suggests generic foreign-key to id join when table names differ from column names", () => {
+  const colsWithGenericFk = new Map<string, SqlCompletionColumn[]>([
+    [
+      "public.first_table",
+      [
+        { name: "id", table: "first_table", schema: "public", dataType: "bigint" },
+        { name: "user_id", table: "first_table", schema: "public", dataType: "bigint" },
+      ],
+    ],
+    [
+      "public.second_table",
+      [
+        { name: "id", table: "second_table", schema: "public", dataType: "bigint" },
+        { name: "name", table: "second_table", schema: "public", dataType: "varchar" },
+      ],
+    ],
+  ]);
+  const sql = "select * from public.first_table t1 join public.second_table t2 on ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables: [
+      { name: "first_table", schema: "public", type: "table" },
+      { name: "second_table", schema: "public", type: "table" },
+    ],
+    columnsByTable: colsWithGenericFk,
+  });
+
+  const genericJoin = items.find((item) => item.label === "t1.user_id = t2.id");
+  assert.ok(genericJoin, "should suggest generic *_id = id joins");
+  assert.equal(genericJoin.apply, "t1.user_id = t2.id");
+});
+
+// --- Fuzzy matching ---
+
+test("fuzzy matches table names with character gaps", () => {
+  const items = buildSqlCompletionItems("select * from usrs", "select * from usrs".length, {
+    tables,
+    columnsByTable,
+  });
+  // "usrs" should fuzzy-match "users" (skip 'e')
+  const tableItems = items.filter((item) => item.type === "table");
+  assert.ok(
+    tableItems.some((item) => item.label === "users"),
+    "should fuzzy-match users",
+  );
+});
+
+test("fuzzy matches columns with abbreviation pattern", () => {
+  const sql = "select nm from public.users u";
+  const items = buildSqlCompletionItems(sql, "select nm".length, {
+    tables,
+    columnsByTable,
+  });
+  // "nm" should fuzzy-match "name"
+  assert.ok(
+    items.some((item) => item.label === "name" && item.type === "column"),
+    "should fuzzy-match name from 'nm'",
+  );
+});
+
+test("prefix matches still rank above fuzzy matches", () => {
+  // Use "na" which is an exact prefix for "name" but also fuzzy-matches "ANALYZE" and others
+  const sql = "select na from public.users u";
+  const items = buildSqlCompletionItems(sql, "select na".length, {
+    tables,
+    columnsByTable,
+  });
+  // Prefix match "name" should be first
+  assert.equal(items[0]?.label, "name");
+});
+
+test("suggests columns after multiple select-list expressions", () => {
+  const sql = "select project_name, review_accountant, doc from ypmng_archive LIMIT 100";
+  const cursor = "select project_name, review_accountant, doc".length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables: [{ name: "ypmng_archive", type: "table" }],
+    objects: [{ name: "proc_get_ypfmm_pd_score_list_with_template_doc_id", schema: "y_jnpf", type: "procedure" }],
+    columnsByTable: new Map([
+      [
+        "ypmng_archive",
+        [
+          { name: "doc_id", table: "ypmng_archive", dataType: "bigint" },
+          { name: "project_name", table: "ypmng_archive", dataType: "varchar" },
+          { name: "review_accountant", table: "ypmng_archive", dataType: "varchar" },
+        ],
+      ],
+    ]),
+  });
+
+  assert.ok(items.some((item) => item.label === "doc_id" && item.type === "column"));
+  assert.ok(!items.some((item) => item.type === "function" && item.label.startsWith("proc_")));
+});
+
+test("suggests columns after multiple group by expressions", () => {
+  const sql = "select project_name, count(*) from ypmng_archive group by project_name, review";
+  const cursor = sql.length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables: [{ name: "ypmng_archive", type: "table" }],
+    objects: [{ name: "proc_get_ypfmm_pd_score_list_with_template_doc_id", schema: "y_jnpf", type: "procedure" }],
+    columnsByTable: new Map([
+      [
+        "ypmng_archive",
+        [
+          { name: "doc_id", table: "ypmng_archive", dataType: "bigint" },
+          { name: "project_name", table: "ypmng_archive", dataType: "varchar" },
+          { name: "review_accountant", table: "ypmng_archive", dataType: "varchar" },
+        ],
+      ],
+    ]),
+  });
+
+  assert.ok(items.some((item) => item.label === "review_accountant" && item.type === "column"));
+  assert.ok(!items.some((item) => item.type === "function" && item.label.startsWith("proc_")));
+});
+
+test("suggests columns after multiple order by expressions", () => {
+  const sql = "select project_name, review_accountant, doc_id from ypmng_archive order by project_name, review";
+  const cursor = sql.length;
+  const items = buildSqlCompletionItems(sql, cursor, {
+    tables: [{ name: "ypmng_archive", type: "table" }],
+    objects: [{ name: "proc_get_ypfmm_pd_score_list_with_template_doc_id", schema: "y_jnpf", type: "procedure" }],
+    columnsByTable: new Map([
+      [
+        "ypmng_archive",
+        [
+          { name: "doc_id", table: "ypmng_archive", dataType: "bigint" },
+          { name: "project_name", table: "ypmng_archive", dataType: "varchar" },
+          { name: "review_accountant", table: "ypmng_archive", dataType: "varchar" },
+        ],
+      ],
+    ]),
+  });
+
+  assert.ok(items.some((item) => item.label === "review_accountant" && item.type === "column"));
+  assert.ok(!items.some((item) => item.type === "function" && item.label.startsWith("proc_")));
+});
+
+// --- Type-aware comparison hints ---
+
+test("suggests NULL and IS NULL after comparison operator", () => {
+  const sql = "select * from public.users u where u.name = ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+  assert.ok(
+    items.some((item) => item.label === "NULL"),
+    "should suggest NULL",
+  );
+  assert.ok(
+    items.some((item) => item.label === "IS NULL"),
+    "should suggest IS NULL",
+  );
+});
+
+test("suggests string snippet for varchar column after =", () => {
+  const sql = "select * from public.users u where u.name = ";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+  const strSnippet = items.find((item) => item.label === "''");
+  assert.ok(strSnippet, "should suggest string literal snippet for varchar column");
+});
+
+// --- SELECT * expansion ---
+
+test("shows SELECT * column expansion", () => {
+  const sql = "select *";
+  const items = buildSqlCompletionItems(sql, sql.length, {
+    tables,
+    columnsByTable,
+  });
+  const starItem = items.find((item) => item.label === "* → columns");
+  assert.ok(starItem, "should show column expansion for *");
+});
+
+// --- History-based ranking ---
+
+test("recordCompletionSelection boosts future ranking", () => {
+  // Record a few selections of a specific table
+  recordCompletionSelection("user_profiles", "table");
+  recordCompletionSelection("user_profiles", "table");
+
+  const items = buildSqlCompletionItems("select * from user", "select * from user".length, {
+    tables,
+    columnsByTable,
+  });
+  const tableItems = items.filter((item) => item.type === "table");
+  // user_profiles should now rank higher than users due to history boost
+  assert.equal(tableItems[0]?.label, "user_profiles");
+});
diff --git a/packages/app-tests/sqlCompletionPerformance.test.ts b/packages/app-tests/sqlCompletionPerformance.test.ts
new file mode 100644
index 0000000..4fe0aed
--- /dev/null
+++ b/packages/app-tests/sqlCompletionPerformance.test.ts
@@ -0,0 +1,169 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { createPinia, setActivePinia } from "pinia";
+import { buildSqlCompletionItems, buildSqlCompletionItemsFromContext, getSqlCompletionContext, recordCompletionSelection } from "../../apps/desktop/src/lib/sql/sqlCompletion.ts";
+import { sqlCompletionContextFromSemantic } from "../../apps/desktop/src/lib/sql/semantic/completion.ts";
+import { buildSqlSemanticModel } from "../../apps/desktop/src/lib/sql/semantic/model.ts";
+import { useConnectionStore } from "../../apps/desktop/src/stores/connectionStore.ts";
+import type { ConnectionConfig, TableInfo } from "../../apps/desktop/src/types/database.ts";
+
+function installMemoryStorage() {
+  const values = new Map<string, string>();
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+      clear: () => values.clear(),
+    },
+  });
+  return {
+    restore() {
+      if (original) Object.defineProperty(globalThis, "localStorage", original);
+      else Reflect.deleteProperty(globalThis, "localStorage");
+    },
+  };
+}
+
+function postgresConnection(): ConnectionConfig {
+  return {
+    id: "conn-large",
+    name: "Large Postgres",
+    db_type: "postgres",
+    host: "127.0.0.1",
+    port: 5432,
+    username: "postgres",
+    password: "secret",
+  };
+}
+
+function largeCatalogFixture(schemaCount = 120, tablesPerSchema = 25) {
+  const schemas = Array.from({ length: schemaCount }, (_, index) => `schema_${String(index).padStart(3, "0")}`);
+  const tablesBySchema = new Map<string, TableInfo[]>();
+  for (const schema of schemas) {
+    tablesBySchema.set(
+      schema,
+      Array.from({ length: tablesPerSchema }, (_, index) => ({
+        name: `customer_event_${schema}_${String(index).padStart(3, "0")}`,
+        table_type: index % 7 === 0 ? "VIEW" : "BASE TABLE",
+      })),
+    );
+  }
+  return { schemas, tablesBySchema };
+}
+
+test("large table catalogs produce bounded SQL completion items", () => {
+  const tables = Array.from({ length: 2500 }, (_, index) => ({
+    name: `customer_event_${String(index).padStart(4, "0")}`,
+    schema: `schema_${index % 100}`,
+    type: "table" as const,
+  }));
+
+  const items = buildSqlCompletionItems("select * from customer", "select * from customer".length, {
+    tables,
+    columnsByTable: new Map(),
+    dialect: "postgres",
+  });
+
+  const tableItems = items.filter((item) => item.type === "table");
+  assert.equal(tableItems.length, 200);
+  assert.equal(tableItems[0].label, "customer_event_0000");
+});
+
+test("semantic completion parses only the active large-script statement within bounds", () => {
+  const inactiveStatements = Array.from({ length: 400 }, (_, index) => `SELECT * FROM archived_${index} WHERE id = ${index};`).join("\n");
+  const activeStatement = "SELECT * FROM active_orders ao JOIN active_users au ON au.id = ao.user_id WHERE au.na";
+  const sql = `${inactiveStatements}\n${activeStatement}`;
+  const cursor = sql.length;
+  const tables = Array.from({ length: 2500 }, (_, index) => ({
+    name: `active_${String(index).padStart(4, "0")}`,
+    schema: "public",
+    type: "table" as const,
+  }));
+  const columnsByTable = new Map([
+    ["active_users", ["id", "name", "email"].map((name) => ({ name, table: "active_users" }))],
+    ["active_orders", ["id", "user_id", "total"].map((name) => ({ name, table: "active_orders" }))],
+  ]);
+
+  const startedAt = performance.now();
+  const model = buildSqlSemanticModel(sql, cursor, { databaseType: "postgres" });
+  const elapsedMs = performance.now() - startedAt;
+  const context = sqlCompletionContextFromSemantic(model, getSqlCompletionContext(sql, cursor));
+  const items = buildSqlCompletionItemsFromContext(context, { tables, columnsByTable, dialect: "postgres" });
+
+  assert.equal(model.statement.text, activeStatement);
+  assert.ok(elapsedMs < 200, `semantic model build took ${elapsedMs.toFixed(1)}ms`);
+  assert.ok(items.length <= 200);
+  assert.deepEqual(
+    items.filter((item) => item.type === "column").map((item) => item.label),
+    ["name"],
+  );
+});
+
+test("recently selected completion items receive a ranking boost", () => {
+  const tables = [
+    { name: "customer_accounts", schema: "public", type: "table" as const },
+    { name: "customer_accounts_archive", schema: "public", type: "table" as const },
+  ];
+
+  const before = buildSqlCompletionItems("select * from customer_acc", "select * from customer_acc".length, {
+    tables,
+    columnsByTable: new Map(),
+    dialect: "postgres",
+  }).filter((item) => item.type === "table");
+  assert.equal(before[0].label, "customer_accounts");
+
+  recordCompletionSelection("customer_accounts_archive", "table");
+  const after = buildSqlCompletionItems("select * from customer_acc", "select * from customer_acc".length, {
+    tables,
+    columnsByTable: new Map(),
+    dialect: "postgres",
+  }).filter((item) => item.type === "table");
+  assert.equal(after[0].label, "customer_accounts_archive");
+});
+
+test("completion metadata refresh is deduplicated and local lookups rank the current schema first", async () => {
+  const originalFetch = globalThis.fetch;
+  const storage = installMemoryStorage();
+  const { schemas, tablesBySchema } = largeCatalogFixture();
+  let schemaCalls = 0;
+  let tableCalls = 0;
+
+  globalThis.fetch = (async (input) => {
+    const url = new URL(String(input), "http://localhost");
+    if (url.pathname === "/api/schema/schemas") {
+      schemaCalls++;
+      return Response.json(schemas);
+    }
+    if (url.pathname === "/api/schema/tables") {
+      tableCalls++;
+      const schema = url.searchParams.get("schema") ?? "";
+      const filter = (url.searchParams.get("filter") ?? "").toLowerCase();
+      const limit = Number(url.searchParams.get("limit") || "0") || undefined;
+      const tables = (tablesBySchema.get(schema) ?? []).filter((table) => !filter || table.name.toLowerCase().includes(filter)).slice(0, limit);
+      return Response.json(tables);
+    }
+    return Response.json(null);
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    store.addEphemeralConnection(postgresConnection());
+
+    await Promise.all([store.refreshCompletionTables("conn-large", "app", "customer", 20, "schema_010"), store.refreshCompletionTables("conn-large", "app", "customer", 20, "schema_010")]);
+
+    assert.equal(tableCalls, 1);
+    assert.equal(schemaCalls, 0);
+
+    await store.refreshCompletionTables("conn-large", "app", "customer", 20, "schema_011");
+    const localTables = store.lookupLocalCompletionTables("conn-large", "app", "customer", 5, "schema_011");
+    assert.equal(localTables.length, 5);
+    assert.equal(localTables[0].schema, "schema_011");
+  } finally {
+    globalThis.fetch = originalFetch;
+    storage.restore();
+  }
+});
diff --git a/packages/app-tests/sqlExecutionTarget.test.ts b/packages/app-tests/sqlExecutionTarget.test.ts
new file mode 100644
index 0000000..1fbe8ae
--- /dev/null
+++ b/packages/app-tests/sqlExecutionTarget.test.ts
@@ -0,0 +1,67 @@
+import { strict as assert } from "node:assert";
+import { beforeEach, test, vi } from "vitest";
+
+const apiMock = vi.hoisted(() => ({
+  findStatementAtCursor: vi.fn(),
+}));
+
+vi.mock("@/lib/backend/api", () => apiMock);
+
+const { resolveExecutableSqlWithBackend } = await import("../../apps/desktop/src/lib/sql/sqlExecutionTarget.ts");
+
+beforeEach(() => {
+  apiMock.findStatementAtCursor.mockReset();
+});
+
+test("mongodb backend resolution uses the current command when configured", async () => {
+  apiMock.findStatementAtCursor.mockResolvedValue("db.users.insertOne({ name: 'ignored' })");
+
+  const fullSql = 'db.users.find({ name: "Ada" });\ndb.users.find({ name: "Grace" });\ndb.users.find({ name: "Linus" });';
+  const resolved = await resolveExecutableSqlWithBackend(fullSql, "", {
+    mode: "current",
+    cursorPos: fullSql.indexOf("Grace"),
+    databaseType: "mongodb",
+  });
+
+  assert.equal(resolved, 'db.users.find({ name: "Grace" })');
+  assert.equal(apiMock.findStatementAtCursor.mock.calls.length, 0);
+});
+
+test("mongodb backend resolution keeps the full text in all mode", async () => {
+  const fullSql = 'db.users.find({ name: "Ada" });\ndb.users.find({ name: "Grace" });';
+  const resolved = await resolveExecutableSqlWithBackend(fullSql, "", {
+    mode: "all",
+    cursorPos: fullSql.indexOf("Grace"),
+    databaseType: "mongodb",
+  });
+
+  assert.equal(resolved, fullSql);
+  assert.equal(apiMock.findStatementAtCursor.mock.calls.length, 0);
+});
+
+test("mongodb backend resolution prefers the manual selection", async () => {
+  const fullSql = 'db.users.find({ name: "Ada" });\ndb.users.find({ name: "Grace" });';
+  const selectedSql = 'db.users.find({ name: "Ada" })';
+  const resolved = await resolveExecutableSqlWithBackend(fullSql, selectedSql, {
+    mode: "current",
+    cursorPos: fullSql.indexOf("Grace"),
+    databaseType: "mongodb",
+  });
+
+  assert.equal(resolved, selectedSql);
+  assert.equal(apiMock.findStatementAtCursor.mock.calls.length, 0);
+});
+
+test("non-mongodb backend resolution still asks the backend for the current statement", async () => {
+  apiMock.findStatementAtCursor.mockResolvedValue("SELECT 2");
+
+  const fullSql = "SELECT 1;\nSELECT 2;";
+  const resolved = await resolveExecutableSqlWithBackend(fullSql, "", {
+    mode: "current",
+    cursorPos: fullSql.indexOf("2"),
+    databaseType: "postgres",
+  });
+
+  assert.equal(resolved, "SELECT 2");
+  assert.deepEqual(apiMock.findStatementAtCursor.mock.calls[0], [fullSql, fullSql.indexOf("2"), "postgres"]);
+});
diff --git a/packages/app-tests/sqlFormatter.test.ts b/packages/app-tests/sqlFormatter.test.ts
new file mode 100644
index 0000000..7ce915a
--- /dev/null
+++ b/packages/app-tests/sqlFormatter.test.ts
@@ -0,0 +1,54 @@
+import { strict as assert } from "node:assert";
+import { afterEach, test, vi } from "vitest";
+import { formatSqlText, MAX_SQL_FORMAT_CHARS } from "../../apps/desktop/src/lib/sql/sqlFormatter.ts";
+
+afterEach(() => {
+  vi.doUnmock("sql-formatter");
+});
+
+test("rejects very large SQL before importing formatter", async () => {
+  vi.resetModules();
+  vi.doMock("sql-formatter", () => {
+    throw new Error("formatter should not load");
+  });
+
+  const { formatSqlText: isolatedFormatSqlText, MAX_SQL_FORMAT_CHARS: isolatedMaxSqlFormatChars } = await import("../../apps/desktop/src/lib/sql/sqlFormatter.ts");
+
+  await assert.rejects(() => isolatedFormatSqlText("x".repeat(isolatedMaxSqlFormatChars + 1), "generic"), /too large/i);
+});
+
+test("formats SQL with uppercase keywords and readable line breaks by default", async () => {
+  const formatted = await formatSqlText("select id, name from users where active = 1 order by name", "postgres");
+
+  assert.match(formatted, /^SELECT\b/);
+  assert.match(formatted, /\nFROM\b/);
+  assert.match(formatted, /\nWHERE\b/);
+  assert.match(formatted, /\nORDER BY\b/);
+});
+
+test("formats SQL with custom keyword case and indentation settings", async () => {
+  const formatted = await formatSqlText("select id from users where active = 1", "postgres", {
+    keywordCase: "lower",
+    dataTypeCase: "preserve",
+    functionCase: "preserve",
+    useTabs: true,
+    tabWidth: 2,
+    logicalOperatorNewline: "before",
+    expressionWidth: 50,
+    linesBetweenQueries: 1,
+    denseOperators: false,
+    newlineBeforeSemicolon: false,
+  });
+
+  assert.match(formatted, /^select\b/);
+  assert.match(formatted, /\nfrom\b/);
+  assert.doesNotMatch(formatted, /^SELECT\b/);
+});
+
+test("leaves blank SQL unchanged", async () => {
+  assert.equal(await formatSqlText("  \n\t", "mysql"), "  \n\t");
+});
+
+test("rejects very large SQL before loading formatter work", async () => {
+  await assert.rejects(() => formatSqlText("x".repeat(MAX_SQL_FORMAT_CHARS + 1), "generic"), /too large/i);
+});
diff --git a/packages/app-tests/sqlFormatterConfig.test.ts b/packages/app-tests/sqlFormatterConfig.test.ts
new file mode 100644
index 0000000..cbfd298
--- /dev/null
+++ b/packages/app-tests/sqlFormatterConfig.test.ts
@@ -0,0 +1,276 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { DEFAULT_SQL_FORMATTER_SETTINGS, normalizeSqlFormatterSettings, parseSqlFormatterConfig, serializeSqlFormatterConfig, sqlFormatterOptions, syncSqlFormatterConfigDraft } from "../../apps/desktop/src/lib/sql/sqlFormatterConfig.ts";
+
+const defaultOptionSettings = DEFAULT_SQL_FORMATTER_SETTINGS;
+
+test("normalizes empty formatter settings to defaults", () => {
+  assert.deepEqual(normalizeSqlFormatterSettings({}), DEFAULT_SQL_FORMATTER_SETTINGS);
+});
+
+test("keeps valid formatter settings and clamps invalid values", () => {
+  const settings = normalizeSqlFormatterSettings({
+    keywordCase: "lower",
+    dataTypeCase: "upper",
+    functionCase: "lower",
+    identifierCase: "upper",
+    indentStyle: "tabularLeft",
+    useTabs: true,
+    tabWidth: 4,
+    logicalOperatorNewline: "after",
+    expressionWidth: 120,
+    linesBetweenQueries: 2,
+    denseOperators: true,
+    newlineBeforeSemicolon: true,
+    paramTypes: { named: [":"], custom: [{ regex: "\\{\\w+\\}" }] },
+  });
+
+  assert.deepEqual(settings, {
+    ...DEFAULT_SQL_FORMATTER_SETTINGS,
+    keywordCase: "lower",
+    dataTypeCase: "upper",
+    functionCase: "lower",
+    identifierCase: "upper",
+    indentStyle: "tabularLeft",
+    useTabs: true,
+    tabWidth: 4,
+    logicalOperatorNewline: "after",
+    expressionWidth: 120,
+    linesBetweenQueries: 2,
+    denseOperators: true,
+    newlineBeforeSemicolon: true,
+    paramTypes: { named: [":"], custom: [{ regex: "\\{\\w+\\}" }] },
+  });
+
+  assert.deepEqual(
+    normalizeSqlFormatterSettings({
+      keywordCase: "camel",
+      dataTypeCase: "invalid",
+      functionCase: "invalid",
+      identifierCase: "invalid",
+      indentStyle: "wide",
+      useTabs: "yes",
+      tabWidth: 99,
+      logicalOperatorNewline: "middle",
+      expressionWidth: -1,
+      linesBetweenQueries: 9,
+      denseOperators: "true",
+      newlineBeforeSemicolon: "false",
+      paramTypes: { named: ["#"] },
+      editor: { shortcuts: [{ id: "duplicateLine", keys: { windows: "Ctrl+W", linux: "Ctrl+W", macos: "Cmd+W" }, enabled: false }] },
+    }),
+    DEFAULT_SQL_FORMATTER_SETTINGS,
+  );
+});
+
+test("serializes formatter config as a stable versioned envelope", () => {
+  const json = serializeSqlFormatterConfig({
+    ...DEFAULT_SQL_FORMATTER_SETTINGS,
+    keywordCase: "lower",
+  });
+  assert.equal(
+    json,
+    JSON.stringify(
+      {
+        version: 1,
+        formatter: "sql-formatter",
+        options: {
+          ...defaultOptionSettings,
+          keywordCase: "lower",
+        },
+      },
+      null,
+      2,
+    ),
+  );
+});
+
+test("parses valid formatter config files", () => {
+  const result = parseSqlFormatterConfig(
+    JSON.stringify({
+      version: 1,
+      formatter: "sql-formatter",
+      ignoredTopLevelField: "ok",
+      options: {
+        keywordCase: "lower",
+        functionCase: "upper",
+        dataTypeCase: "preserve",
+        identifierCase: "lower",
+        indentStyle: "tabularRight",
+        useTabs: false,
+        tabWidth: 4,
+        logicalOperatorNewline: "after",
+        expressionWidth: 80,
+        linesBetweenQueries: 0,
+        denseOperators: false,
+        newlineBeforeSemicolon: true,
+        paramTypes: { named: [":"], quoted: ["@"], positional: true },
+      },
+      editor: {
+        scope: "legacyJsonEditorScope",
+        platforms: ["windows", "macos"],
+        shortcuts: [{ id: "unknownLegacyShortcut", action: "copyLineDown", keys: { windows: "", linux: "Ctrl+W", macos: "Cmd+W" }, enabled: "yes" }],
+      },
+    }),
+  );
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.settings, {
+    ...DEFAULT_SQL_FORMATTER_SETTINGS,
+    keywordCase: "lower",
+    functionCase: "upper",
+    dataTypeCase: "preserve",
+    identifierCase: "lower",
+    indentStyle: "tabularRight",
+    useTabs: false,
+    tabWidth: 4,
+    logicalOperatorNewline: "after",
+    expressionWidth: 80,
+    linesBetweenQueries: 0,
+    denseOperators: false,
+    newlineBeforeSemicolon: true,
+    paramTypes: { named: [":"], quoted: ["@"], positional: true },
+  });
+});
+
+test("ignores legacy editor shortcut fields in formatter config files", () => {
+  const result = parseSqlFormatterConfig(
+    JSON.stringify({
+      version: 1,
+      formatter: "sql-formatter",
+      options: {},
+      editor: {
+        shortcuts: [{ id: "unknown", keys: { windows: "" }, enabled: "not-a-boolean" }],
+      },
+    }),
+  );
+
+  assert.equal(result.ok, true);
+  if (result.ok) {
+    assert.deepEqual(result.settings, DEFAULT_SQL_FORMATTER_SETTINGS);
+  }
+});
+
+test("rejects malformed formatter config files", () => {
+  assert.deepEqual(parseSqlFormatterConfig("{bad json").ok, false);
+  assert.deepEqual(parseSqlFormatterConfig(JSON.stringify({ version: 2, formatter: "sql-formatter", options: {} })).ok, false);
+  assert.deepEqual(parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "prettier", options: {} })).ok, false);
+  assert.deepEqual(parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { unknown: true } })).ok, false);
+});
+
+test("rejects invalid known formatter option values when parsing config files", () => {
+  const invalidKeywordCase = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { keywordCase: "camel" } }));
+  assert.equal(invalidKeywordCase.ok, false);
+  if (!invalidKeywordCase.ok) assert.match(invalidKeywordCase.message, /keywordCase/);
+
+  const invalidBoolean = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { useTabs: "yes" } }));
+  assert.equal(invalidBoolean.ok, false);
+  if (!invalidBoolean.ok) assert.match(invalidBoolean.message, /useTabs/);
+
+  const invalidNumericChoice = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { tabWidth: 3 } }));
+  assert.equal(invalidNumericChoice.ok, false);
+  if (!invalidNumericChoice.ok) assert.match(invalidNumericChoice.message, /tabWidth/);
+
+  const invalidParams = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { params: ["42"] } }));
+  assert.equal(invalidParams.ok, false);
+  if (!invalidParams.ok) assert.match(invalidParams.message, /params/);
+
+  const legacyNullParams = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { params: null } }));
+  assert.equal(legacyNullParams.ok, true);
+
+  const invalidParamTypes = parseSqlFormatterConfig(JSON.stringify({ version: 1, formatter: "sql-formatter", options: { paramTypes: { custom: [{ regex: "" }] } } }));
+  assert.equal(invalidParamTypes.ok, false);
+  if (!invalidParamTypes.ok) assert.match(invalidParamTypes.message, /paramTypes/);
+});
+
+test("syncs valid JSON drafts so outer settings apply can persist them", () => {
+  let synced = DEFAULT_SQL_FORMATTER_SETTINGS;
+  const result = syncSqlFormatterConfigDraft(
+    JSON.stringify({
+      version: 1,
+      formatter: "sql-formatter",
+      options: {
+        ...defaultOptionSettings,
+        keywordCase: "lower",
+        tabWidth: 4,
+      },
+    }),
+    (settings) => {
+      synced = settings;
+    },
+  );
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(synced, {
+    ...DEFAULT_SQL_FORMATTER_SETTINGS,
+    keywordCase: "lower",
+    tabWidth: 4,
+  });
+});
+
+test("does not sync invalid JSON drafts", () => {
+  let synced = DEFAULT_SQL_FORMATTER_SETTINGS;
+  const result = syncSqlFormatterConfigDraft(
+    JSON.stringify({
+      version: 1,
+      formatter: "sql-formatter",
+      options: {
+        ...defaultOptionSettings,
+        keywordCase: "camel",
+      },
+    }),
+    (settings) => {
+      synced = settings;
+    },
+  );
+
+  assert.equal(result.ok, false);
+  assert.deepEqual(synced, DEFAULT_SQL_FORMATTER_SETTINGS);
+});
+
+test("maps DBX formatter settings to sql-formatter options", () => {
+  assert.deepEqual(
+    sqlFormatterOptions({
+      ...DEFAULT_SQL_FORMATTER_SETTINGS,
+      keywordCase: "lower",
+      useTabs: true,
+      newlineBeforeSemicolon: true,
+    }),
+    {
+      keywordCase: "lower",
+      dataTypeCase: "preserve",
+      functionCase: "preserve",
+      identifierCase: "preserve",
+      indentStyle: "standard",
+      useTabs: true,
+      tabWidth: 2,
+      logicalOperatorNewline: "before",
+      expressionWidth: 50,
+      linesBetweenQueries: 1,
+      denseOperators: false,
+      newlineBeforeSemicolon: true,
+    },
+  );
+
+  assert.deepEqual(
+    sqlFormatterOptions({
+      ...DEFAULT_SQL_FORMATTER_SETTINGS,
+      paramTypes: { positional: true },
+    }),
+    {
+      keywordCase: "upper",
+      dataTypeCase: "preserve",
+      functionCase: "preserve",
+      identifierCase: "preserve",
+      indentStyle: "standard",
+      useTabs: false,
+      tabWidth: 2,
+      logicalOperatorNewline: "before",
+      expressionWidth: 50,
+      linesBetweenQueries: 1,
+      denseOperators: false,
+      newlineBeforeSemicolon: false,
+      paramTypes: { positional: true },
+    },
+  );
+});
diff --git a/packages/app-tests/sqlMetadataRefresh.test.ts b/packages/app-tests/sqlMetadataRefresh.test.ts
new file mode 100644
index 0000000..72275d2
--- /dev/null
+++ b/packages/app-tests/sqlMetadataRefresh.test.ts
@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { sqlMetadataRefreshScope, sqlMetadataRefreshTarget } from "../../apps/desktop/src/lib/sql/sqlMetadataRefresh.ts";
+
+test("database DDL refreshes the connection database list", () => {
+  assert.equal(sqlMetadataRefreshScope("CREATE DATABASE app;"), "connection");
+  assert.deepEqual(sqlMetadataRefreshTarget("DROP DATABASE app;"), { scope: "connection" });
+});
+
+test("schema DDL refreshes the selected database tree", () => {
+  assert.equal(sqlMetadataRefreshScope("drop schema public cascade;"), "database");
+  assert.deepEqual(sqlMetadataRefreshTarget("CREATE SCHEMA analytics;"), { scope: "database" });
+});
+
+test("object DDL refreshes the selected database tree", () => {
+  assert.equal(sqlMetadataRefreshScope("CREATE TABLE users (id int);"), "database");
+  assert.equal(sqlMetadataRefreshScope("CREATE TEMP TABLE scratch (id int);"), "database");
+  assert.equal(sqlMetadataRefreshScope("CREATE MATERIALIZED VIEW daily_users AS SELECT 1;"), "database");
+  assert.equal(sqlMetadataRefreshScope("ALTER TABLE users ADD COLUMN name text;"), "database");
+  assert.equal(sqlMetadataRefreshScope("DROP VIEW active_users;"), "database");
+  assert.equal(sqlMetadataRefreshScope("CREATE OR REPLACE FUNCTION f() RETURNS int AS $$ SELECT 1 $$ LANGUAGE SQL;"), "database");
+});
+
+test("qualified object DDL refreshes the matching schema node", () => {
+  assert.deepEqual(sqlMetadataRefreshTarget("CREATE TABLE public.users (id int);"), {
+    scope: "database",
+    schema: "public",
+  });
+  assert.deepEqual(sqlMetadataRefreshTarget('ALTER TABLE "Sales".orders ADD COLUMN name text;'), {
+    scope: "database",
+    schema: "Sales",
+  });
+  assert.deepEqual(sqlMetadataRefreshTarget("DROP VIEW `reporting`.active_users;"), {
+    scope: "database",
+    schema: "reporting",
+  });
+  assert.deepEqual(sqlMetadataRefreshTarget("CREATE INDEX idx_users_email ON public.users (email);"), {
+    scope: "database",
+    schema: "public",
+  });
+});
+
+test("unqualified object DDL can use the active schema as the refresh target", () => {
+  assert.deepEqual(sqlMetadataRefreshTarget("ALTER TABLE users ADD COLUMN name text;", "public"), {
+    scope: "database",
+    schema: "public",
+  });
+  assert.deepEqual(sqlMetadataRefreshTarget("CREATE SCHEMA analytics;", "public"), { scope: "database" });
+});
+
+test("multiple object DDL schemas fall back to refreshing the database tree", () => {
+  assert.deepEqual(sqlMetadataRefreshTarget("CREATE TABLE public.users (id int); CREATE TABLE audit.events (id int);"), { scope: "database" });
+});
+
+test("data-only SQL does not refresh metadata trees", () => {
+  assert.equal(sqlMetadataRefreshScope("SELECT * FROM users;"), "none");
+  assert.equal(sqlMetadataRefreshScope("INSERT INTO users VALUES (1);"), "none");
+  assert.equal(sqlMetadataRefreshScope("TRUNCATE TABLE users;"), "none");
+  assert.deepEqual(sqlMetadataRefreshTarget("SELECT * FROM users;"), { scope: "none" });
+});
diff --git a/packages/app-tests/sqlQuoteCaret.test.ts b/packages/app-tests/sqlQuoteCaret.test.ts
new file mode 100644
index 0000000..6383b6b
--- /dev/null
+++ b/packages/app-tests/sqlQuoteCaret.test.ts
@@ -0,0 +1,63 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { caretPositionInsideInsertedSqlSingleQuotes, insertedSqlSingleQuoteAtCaret } from "../../apps/desktop/src/lib/sql/sqlQuoteCaret.ts";
+
+test("detects a newly typed SQL single quote", () => {
+  assert.equal(
+    insertedSqlSingleQuoteAtCaret({
+      previousValue: "name = ",
+      nextValue: "name = '",
+      selectionStart: 8,
+    }),
+    true,
+  );
+  assert.equal(
+    insertedSqlSingleQuoteAtCaret({
+      previousValue: "name = '",
+      nextValue: "name = ''",
+      selectionStart: 9,
+    }),
+    true,
+  );
+});
+
+test("moves the caret between SQL single quotes after typing the closing quote", () => {
+  assert.equal(
+    caretPositionInsideInsertedSqlSingleQuotes({
+      previousValue: "name = '",
+      nextValue: "name = ''",
+      selectionStart: 9,
+    }),
+    8,
+  );
+});
+
+test("moves the caret between pasted SQL single quotes", () => {
+  assert.equal(
+    caretPositionInsideInsertedSqlSingleQuotes({
+      previousValue: "name = ",
+      nextValue: "name = ''",
+      selectionStart: 9,
+    }),
+    8,
+  );
+});
+
+test("keeps the caret unchanged for ordinary quote edits", () => {
+  assert.equal(
+    caretPositionInsideInsertedSqlSingleQuotes({
+      previousValue: "name = ",
+      nextValue: "name = '",
+      selectionStart: 8,
+    }),
+    null,
+  );
+  assert.equal(
+    caretPositionInsideInsertedSqlSingleQuotes({
+      previousValue: "name = 'a",
+      nextValue: "name = 'a'",
+      selectionStart: 10,
+    }),
+    null,
+  );
+});
diff --git a/packages/app-tests/sqlSemanticDiagnostics.test.ts b/packages/app-tests/sqlSemanticDiagnostics.test.ts
new file mode 100644
index 0000000..e032ef0
--- /dev/null
+++ b/packages/app-tests/sqlSemanticDiagnostics.test.ts
@@ -0,0 +1,389 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildSqlParserErrorDiagnostic, buildSqlSemanticDiagnostics, areSqlSemanticDiagnosticsEqual, isSqlSemanticDiagnosticInputContext, shouldRunSqlSemanticDiagnostics, sqlSemanticDiagnosticRangesForViewport } from "../../apps/desktop/src/lib/sql/semantic/diagnostics.ts";
+import type { SqlReferenceAnalysis } from "../../apps/desktop/src/types/database.ts";
+
+const span = (startColumn: number, endColumn: number) => ({
+  start_line: 1,
+  start_column: startColumn,
+  end_line: 1,
+  end_column: endColumn,
+});
+
+test("flags missing qualified columns against the referenced table", () => {
+  const analysis: SqlReferenceAnalysis = {
+    tables: [{ name: "users", alias: "u", span: span(23, 27) }],
+    columns: [
+      { name: "missing", qualifier: "u", span: span(10, 16) },
+      { name: "id", qualifier: "u", span: span(34, 35) },
+    ],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [{ name: "users", type: "table" }],
+    columnsByTable: new Map([["users", [{ name: "id", table: "users" }]]]),
+  });
+
+  assert.deepEqual(
+    diagnostics.map((diagnostic) => diagnostic.message),
+    ["Unknown column u.missing"],
+  );
+  assert.equal(diagnostics[0]?.severity, "error");
+});
+
+test("flags confirmed missing tables", () => {
+  const analysis: SqlReferenceAnalysis = {
+    tables: [{ name: "t_19991", span: span(15, 23) }],
+    columns: [],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [],
+    columnsByTable: new Map(),
+    missingTables: new Set(["t_19991"]),
+  });
+
+  assert.deepEqual(
+    diagnostics.map((diagnostic) => diagnostic.message),
+    ["Unknown table t_19991"],
+  );
+  assert.equal(diagnostics[0]?.severity, "error");
+});
+
+test("trims whitespace from missing table diagnostic spans", () => {
+  const analysis: SqlReferenceAnalysis = {
+    tables: [{ name: "t_00011", span: span(32, 39) }],
+    columns: [],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [],
+    columnsByTable: new Map(),
+    missingTables: new Set(["t_00011"]),
+    sql: "SELECT * FROM demo_2000_tables.t_00011 AS t0",
+  });
+
+  assert.deepEqual(diagnostics[0]?.span, span(32, 38));
+});
+
+test("flags missing columns when column metadata is cached with a schema key", () => {
+  const analysis: SqlReferenceAnalysis = {
+    tables: [{ name: "t_10001", span: span(24, 32) }],
+    columns: [{ name: "bad_field", span: span(8, 17) }],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [{ name: "t_10001", type: "table" }],
+    columnsByTable: new Map([["demo_2000_tables.t_10001", [{ name: "id", table: "t_10001" }]]]),
+  });
+
+  assert.deepEqual(
+    diagnostics.map((diagnostic) => diagnostic.message),
+    ["Unknown column bad_field"],
+  );
+  assert.equal(diagnostics[0]?.severity, "error");
+});
+
+test("flags missing columns when loaded column metadata is empty", () => {
+  const analysis: SqlReferenceAnalysis = {
+    tables: [{ name: "t_0001", span: span(15, 22) }],
+    columns: [{ name: "ids", span: span(30, 33) }],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [{ name: "t_0001", type: "table" }],
+    columnsByTable: new Map([["t_0001", []]]),
+    loadedColumnTables: new Set(["t_0001"]),
+  });
+
+  assert.deepEqual(
+    diagnostics.map((diagnostic) => diagnostic.message),
+    ["Unknown column ids"],
+  );
+});
+
+test("flags where-clause columns missing from a single referenced table", () => {
+  const analysis: SqlReferenceAnalysis = {
+    tables: [{ name: "t_0001", span: span(15, 22) }],
+    columns: [{ name: "ids", span: span(30, 33) }],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [{ name: "t_0001", type: "table" }],
+    columnsByTable: new Map([["t_0001", ["id", "image_name", "image_mime", "image_data", "image_url"].map((name) => ({ name, table: "t_0001" }))]]),
+  });
+
+  assert.deepEqual(
+    diagnostics.map((diagnostic) => diagnostic.message),
+    ["Unknown column ids"],
+  );
+});
+
+test("resolves unqualified columns against the table in the same statement", () => {
+  const sql = "SELECT * FROM `t_00011` WHERE id > 1; SELECT * FROM `t_0001` where ids > 1 LIMIT 50;";
+  const analysis: SqlReferenceAnalysis = {
+    tables: [
+      { name: "t_00011", span: { start_line: 1, start_column: 15, end_line: 1, end_column: 24 } },
+      { name: "t_0001", span: { start_line: 1, start_column: 54, end_line: 1, end_column: 62 } },
+    ],
+    columns: [
+      { name: "id", span: { start_line: 1, start_column: 31, end_line: 1, end_column: 33 } },
+      { name: "ids", span: { start_line: 1, start_column: 69, end_line: 1, end_column: 72 } },
+    ],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [
+      { name: "t_00011", type: "table" },
+      { name: "t_0001", type: "table" },
+    ],
+    columnsByTable: new Map([
+      ["t_00011", [{ name: "id", table: "t_00011" }]],
+      ["t_0001", [{ name: "id", table: "t_0001" }]],
+    ]),
+    sql,
+  });
+
+  assert.deepEqual(
+    diagnostics.map((diagnostic) => diagnostic.message),
+    ["Unknown column ids"],
+  );
+});
+
+test("resolves qualified aliases against the table in the same statement", () => {
+  const sql = "SELECT x.id FROM t_one x; SELECT x.bad FROM t_two x;";
+  const analysis: SqlReferenceAnalysis = {
+    tables: [
+      { name: "t_one", alias: "x", span: { start_line: 1, start_column: 18, end_line: 1, end_column: 23 } },
+      { name: "t_two", alias: "x", span: { start_line: 1, start_column: 45, end_line: 1, end_column: 50 } },
+    ],
+    columns: [
+      { name: "id", qualifier: "x", span: { start_line: 1, start_column: 10, end_line: 1, end_column: 12 } },
+      { name: "bad", qualifier: "x", span: { start_line: 1, start_column: 36, end_line: 1, end_column: 39 } },
+    ],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [
+      { name: "t_one", type: "table" },
+      { name: "t_two", type: "table" },
+    ],
+    columnsByTable: new Map([
+      ["t_one", [{ name: "id", table: "t_one" }]],
+      ["t_two", [{ name: "other", table: "t_two" }]],
+    ]),
+    sql,
+  });
+
+  assert.deepEqual(
+    diagnostics.map((diagnostic) => diagnostic.message),
+    ["Unknown column x.bad"],
+  );
+});
+
+test("resolves correlated subquery columns against the visible query scopes", () => {
+  const analysis: SqlReferenceAnalysis = {
+    tables: [
+      { name: "mds_base_house", alias: "aa", span: span(1, 14), scope_id: 0 },
+      { name: "mds_base_owner", span: span(1, 14), scope_id: 1 },
+      { name: "FDS_PAY_ORDER", span: span(1, 13), scope_id: 2 },
+      { name: "ac_fund_acct", span: span(1, 12), scope_id: 3 },
+    ],
+    columns: [
+      { name: "house_id", qualifier: "aa", span: span(8, 15), scope_id: 0 },
+      { name: "hou_add", qualifier: "aa", span: span(18, 24), scope_id: 0 },
+      { name: "contract_code", qualifier: "aa", span: span(27, 39), scope_id: 0 },
+      { name: "pay_type", qualifier: "aa", span: span(42, 49), scope_id: 0 },
+      { name: "HOU_PAY_AMT", qualifier: "aa", span: span(52, 62), scope_id: 0 },
+      { name: "OWNER_NAME", span: span(8, 17), scope_id: 1 },
+      { name: "HOUSE_ID", span: span(8, 15), scope_id: 1 },
+      { name: "HOUSE_ID", qualifier: "aa", span: span(8, 15), scope_id: 1 },
+      { name: "PAY_DATA", span: span(8, 15), scope_id: 2 },
+      { name: "contract_code", qualifier: "aa", span: span(8, 20), scope_id: 2 },
+      { name: "owner_id", span: span(8, 15), scope_id: 3 },
+      { name: "house_id", qualifier: "aa", span: span(8, 15), scope_id: 3 },
+    ],
+    scopes: [
+      { id: 0, parent_id: null },
+      { id: 1, parent_id: 0 },
+      { id: 2, parent_id: 0 },
+      { id: 3, parent_id: 0 },
+    ],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [
+      { name: "mds_base_house", type: "table" },
+      { name: "mds_base_owner", type: "table" },
+      { name: "FDS_PAY_ORDER", type: "table" },
+      { name: "ac_fund_acct", type: "table" },
+    ],
+    columnsByTable: new Map([
+      ["mds_base_house", ["house_id", "hou_add", "contract_code", "pay_type", "HOU_PAY_AMT"].map((name) => ({ name, table: "mds_base_house" }))],
+      ["mds_base_owner", ["OWNER_NAME", "HOUSE_ID"].map((name) => ({ name, table: "mds_base_owner" }))],
+      ["FDS_PAY_ORDER", [{ name: "PAY_DATA", table: "FDS_PAY_ORDER" }]],
+      ["ac_fund_acct", [{ name: "owner_id", table: "ac_fund_acct" }]],
+    ]),
+  });
+
+  assert.deepEqual(diagnostics, []);
+});
+
+test("keeps missing-column diagnostics inside nested query scopes", () => {
+  const analysis: SqlReferenceAnalysis = {
+    tables: [
+      { name: "parent_table", alias: "p", span: span(1, 12), scope_id: 0 },
+      { name: "child_table", alias: "c", span: span(1, 11), scope_id: 1 },
+    ],
+    columns: [
+      { name: "id", qualifier: "p", span: span(8, 9), scope_id: 0 },
+      { name: "missing", qualifier: "c", span: span(8, 15), scope_id: 1 },
+      { name: "id", qualifier: "p", span: span(8, 9), scope_id: 1 },
+    ],
+    scopes: [
+      { id: 0, parent_id: null },
+      { id: 1, parent_id: 0 },
+    ],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [
+      { name: "parent_table", type: "table" },
+      { name: "child_table", type: "table" },
+    ],
+    columnsByTable: new Map([
+      ["parent_table", [{ name: "id", table: "parent_table" }]],
+      ["child_table", [{ name: "id", table: "child_table" }]],
+    ]),
+  });
+
+  assert.deepEqual(
+    diagnostics.map((diagnostic) => diagnostic.message),
+    ["Unknown column c.missing"],
+  );
+});
+
+test("does not flag unqualified columns when multiple tables make ownership ambiguous", () => {
+  const analysis: SqlReferenceAnalysis = {
+    tables: [
+      { name: "users", alias: "u", span: span(25, 29) },
+      { name: "orders", alias: "o", span: span(35, 40) },
+    ],
+    columns: [{ name: "id", span: span(8, 9) }],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [
+      { name: "users", type: "table" },
+      { name: "orders", type: "table" },
+    ],
+    columnsByTable: new Map(),
+  });
+
+  assert.deepEqual(diagnostics, []);
+});
+
+test("builds a syntax diagnostic from parser errors with line and column", () => {
+  const diagnostic = buildSqlParserErrorDiagnostic("Expected: end of statement, found: FOM at Line: 1, Column: 10", "SELECT * FOM");
+
+  assert.equal(diagnostic?.message, "Expected: end of statement, found: FOM at Line: 1, Column: 10");
+  assert.deepEqual(diagnostic?.span, span(10, 12));
+});
+
+test("compares diagnostics by severity message and span", () => {
+  const diagnostics = [
+    {
+      message: "Unknown column u.missing",
+      severity: "warning" as const,
+      span: span(10, 16),
+    },
+  ];
+
+  assert.equal(
+    areSqlSemanticDiagnosticsEqual(
+      diagnostics,
+      diagnostics.map((item) => ({ ...item })),
+    ),
+    true,
+  );
+  assert.equal(areSqlSemanticDiagnosticsEqual(diagnostics, [{ ...diagnostics[0], message: "Unknown column u.name" }]), false);
+});
+
+test("defers diagnostics while the cursor is in table completion context", () => {
+  assert.equal(shouldRunSqlSemanticDiagnostics("select * from ", "select * from ".length), false);
+  assert.equal(shouldRunSqlSemanticDiagnostics("select * from us", "select * from us".length), false);
+  assert.equal(shouldRunSqlSemanticDiagnostics("select u.", "select u.".length), false);
+  assert.equal(shouldRunSqlSemanticDiagnostics("select * from users where missing = 1", 42), true);
+  assert.equal(shouldRunSqlSemanticDiagnostics("SELECT * FROM `t_19991` LIMIT 100", "SELECT * FROM `t_19991` LIMIT 100".length, { databaseType: "mysql" }), true);
+  assert.equal(shouldRunSqlSemanticDiagnostics("SELECT * FROM `t_0001` where ids > 1 LIMIT 50;", "SELECT * FROM `t_0001` where ids > 1 LIMIT 50;".length, { databaseType: "mysql" }), true);
+  assert.equal(isSqlSemanticDiagnosticInputContext("SELECT * FROM `t_0001` where ids > 1 LIMIT 50;", "SELECT * FROM `t_0001` where ids > 1 LIMIT 50;".length, { databaseType: "mysql" }), false);
+});
+
+test("skips diagnostics for MongoDB connections", () => {
+  assert.equal(shouldRunSqlSemanticDiagnostics("db.my_collection.find({})", 0, { databaseType: "mongodb" }), false);
+});
+
+test("skips diagnostics for Elasticsearch connections", () => {
+  assert.equal(shouldRunSqlSemanticDiagnostics("db.my_collection.find({})", 0, { databaseType: "elasticsearch" }), false);
+});
+
+test("still runs diagnostics for SQL connections", () => {
+  assert.equal(shouldRunSqlSemanticDiagnostics("SELECT * FROM users WHERE id = 1", 42, { databaseType: "mysql" }), true);
+});
+
+test("selects complete SQL statements intersecting the visible viewport for diagnostics", () => {
+  const sql = "SELECT * FROM first;\nSELECT id, missing_field FROM second WHERE id > 1;\nSELECT * FROM third;";
+  const visibleFrom = sql.indexOf("missing_field");
+  const visibleTo = visibleFrom + "missing_field".length;
+
+  const ranges = sqlSemanticDiagnosticRangesForViewport(sql, [{ from: visibleFrom, to: visibleTo }], "mysql");
+
+  assert.equal(ranges.length, 1);
+  assert.equal(ranges[0]?.sql, "SELECT id, missing_field FROM second WHERE id > 1");
+  assert.equal(ranges[0]?.from, sql.indexOf("SELECT id"));
+  assert.equal(ranges[0]?.to, sql.indexOf(";\nSELECT * FROM third"));
+});
+
+test("skips Oracle PL/SQL blocks when selecting semantic diagnostic ranges", () => {
+  const sql = `DECLARE
+  v_order_count NUMBER;
+BEGIN
+  SELECT COUNT(*) INTO v_order_count
+  FROM "DBX_TEST"."ORDERS_10K";
+
+  IF v_order_count = 0 THEN
+    COMMIT;
+  END IF;
+END;
+/
+SELECT * FROM "DBX_TEST"."ORDERS_10K";`;
+
+  const ranges = sqlSemanticDiagnosticRangesForViewport(sql, [{ from: 0, to: sql.length }], "oracle");
+
+  assert.equal(ranges.length, 1);
+  assert.equal(ranges[0]?.sql, 'SELECT * FROM "DBX_TEST"."ORDERS_10K"');
+});
+
+test("keeps a long statement complete when only its middle is visible", () => {
+  const sql = "SELECT id,\n  name,\n  missing_field\nFROM users\nWHERE id > 1;";
+  const visibleFrom = sql.indexOf("missing_field");
+  const visibleTo = sql.indexOf("FROM users");
+
+  const ranges = sqlSemanticDiagnosticRangesForViewport(sql, [{ from: visibleFrom, to: visibleTo }], "mysql");
+
+  assert.deepEqual(
+    ranges.map((range) => range.sql),
+    ["SELECT id,\n  name,\n  missing_field\nFROM users\nWHERE id > 1"],
+  );
+});
+
+test("uses executable soft statement ranges for viewport diagnostics", () => {
+  const sql = "SELECT * FROM first\nSELECT missing_field FROM second";
+  const visibleFrom = sql.indexOf("missing_field");
+  const ranges = sqlSemanticDiagnosticRangesForViewport(sql, [{ from: visibleFrom, to: visibleFrom + 1 }], "mysql");
+
+  assert.deepEqual(
+    ranges.map((range) => range.sql),
+    ["SELECT missing_field FROM second"],
+  );
+});
diff --git a/packages/app-tests/sqlServerTree.test.ts b/packages/app-tests/sqlServerTree.test.ts
new file mode 100644
index 0000000..4e1796d
--- /dev/null
+++ b/packages/app-tests/sqlServerTree.test.ts
@@ -0,0 +1,35 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { buildSqlServerDatabaseTreeNodes } from "../../apps/desktop/src/lib/database/sqlServerTree.ts";
+
+test("SQL Server database tree shows schemas before objects", () => {
+  const nodes = buildSqlServerDatabaseTreeNodes("conn", "app", ["dbo", "zeta", "sales"]);
+
+  const topLevel = nodes.map((n) => ({ id: n.id, label: n.label, type: n.type }));
+  assert.deepEqual(topLevel, [
+    { id: "conn:app:dbo", label: "dbo", type: "schema" },
+    { id: "conn:app:sales", label: "sales", type: "schema" },
+    { id: "conn:app:zeta", label: "zeta", type: "schema" },
+  ]);
+});
+
+test("SQL Server database tree keeps dbo when no other schemas exist", () => {
+  const nodes = buildSqlServerDatabaseTreeNodes("conn", "app", ["dbo"]);
+
+  assert.deepEqual(
+    nodes.map((node) => ({ id: node.id, label: node.label, type: node.type })),
+    [{ id: "conn:app:dbo", label: "dbo", type: "schema" }],
+  );
+});
+
+test("SQL Server database tree includes cdc schema", () => {
+  const nodes = buildSqlServerDatabaseTreeNodes("conn", "app", ["dbo", "cdc"]);
+
+  assert.deepEqual(
+    nodes.map((node) => ({ id: node.id, label: node.label, type: node.type })),
+    [
+      { id: "conn:app:cdc", label: "cdc", type: "schema" },
+      { id: "conn:app:dbo", label: "dbo", type: "schema" },
+    ],
+  );
+});
diff --git a/packages/app-tests/sqlserverSemanticDiagnostics.test.ts b/packages/app-tests/sqlserverSemanticDiagnostics.test.ts
new file mode 100644
index 0000000..e14c0f8
--- /dev/null
+++ b/packages/app-tests/sqlserverSemanticDiagnostics.test.ts
@@ -0,0 +1,104 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { createPinia, setActivePinia } from "pinia";
+import { useConnectionStore } from "../../apps/desktop/src/stores/connectionStore.ts";
+import { buildSqlSemanticDiagnostics } from "../../apps/desktop/src/lib/sql/semantic/diagnostics.ts";
+import type { ConnectionConfig, SqlReferenceAnalysis } from "../../apps/desktop/src/types/database.ts";
+
+const span = (startColumn: number, endColumn: number) => ({
+  start_line: 1,
+  start_column: startColumn,
+  end_line: 1,
+  end_column: endColumn,
+});
+
+function installMemoryStorage(initial: Record<string, string> = {}) {
+  const values = new Map(Object.entries(initial));
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+      clear: () => values.clear(),
+    },
+  });
+  return {
+    restore() {
+      if (original) Object.defineProperty(globalThis, "localStorage", original);
+      else Reflect.deleteProperty(globalThis, "localStorage");
+    },
+  };
+}
+
+function sqlServerConn(): ConnectionConfig {
+  return {
+    id: "sqlserver-1",
+    name: "SQL Server",
+    db_type: "sqlserver",
+    host: "localhost",
+    port: 1433,
+    username: "sa",
+    password: "",
+    database: "appdb",
+  };
+}
+
+test("semantic diagnostics skip warnings when column metadata is inconclusive", () => {
+  const analysis: SqlReferenceAnalysis = {
+    tables: [{ name: "Evt_GCM_Qop_Info", span: span(15, 30) }],
+    columns: [{ name: "PDReceiveDatePartInfo", span: span(40, 60) }],
+  };
+
+  const diagnostics = buildSqlSemanticDiagnostics(analysis, {
+    tables: [{ name: "Evt_GCM_Qop_Info", type: "table" }],
+    columnsByTable: new Map([["Evt_GCM_Qop_Info", []]]),
+  });
+
+  assert.deepEqual(diagnostics, []);
+});
+
+test("sqlserver completion columns do not query using database name as schema fallback", async () => {
+  const storage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  const requests: string[] = [];
+
+  globalThis.fetch = (async (input) => {
+    const url = String(input);
+    requests.push(url);
+    if (url === "/api/connection/list") {
+      return new Response(JSON.stringify([sqlServerConn()]), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+    if (url === "/api/layout/sidebar") {
+      return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url === "/api/connection/connect") {
+      return new Response(JSON.stringify("ok"), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    if (url.startsWith("/api/schema/columns?")) {
+      throw new Error(`unexpected columns lookup: ${url}`);
+    }
+    return new Response("null", { status: 200, headers: { "Content-Type": "application/json" } });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const store = useConnectionStore();
+    await store.initFromDisk();
+
+    const columns = await store.listCompletionColumns("sqlserver-1", "appdb", "Evt_GCM_Qop_Info");
+
+    assert.deepEqual(columns, []);
+    assert.equal(
+      requests.some((url) => url.startsWith("/api/schema/columns?")),
+      false,
+    );
+  } finally {
+    globalThis.fetch = originalFetch;
+    storage.restore();
+  }
+});
diff --git a/packages/app-tests/supportInfo.test.ts b/packages/app-tests/supportInfo.test.ts
new file mode 100644
index 0000000..82c247d
--- /dev/null
+++ b/packages/app-tests/supportInfo.test.ts
@@ -0,0 +1,51 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildAppSupportInfoRows, formatAppSupportInfoForClipboard, normalizeSupportInfoVersion } from "../../apps/desktop/src/lib/app/supportInfo.ts";
+import type { AppSupportInfoLabels } from "../../apps/desktop/src/lib/app/supportInfo.ts";
+import type { AppSupportInfo } from "../../apps/desktop/src/lib/backend/tauri.ts";
+
+const labels: AppSupportInfoLabels = {
+  appVersion: "DBX Version",
+  runtime: "Runtime",
+  runtimeDesktop: "Desktop",
+  runtimeWeb: "Web",
+  operatingSystem: "Operating System",
+  architecture: "Architecture",
+  unknown: "Unknown",
+};
+
+test("normalizes support info versions with a single v prefix", () => {
+  assert.equal(normalizeSupportInfoVersion("0.5.50", labels.unknown), "v0.5.50");
+  assert.equal(normalizeSupportInfoVersion("v0.5.50", labels.unknown), "v0.5.50");
+  assert.equal(normalizeSupportInfoVersion("V0.5.50", labels.unknown), "v0.5.50");
+});
+
+test("support info rows use stable fallback values", () => {
+  const info: AppSupportInfo = {
+    appVersion: "",
+    runtime: "desktop",
+    osName: "",
+    osVersion: null,
+    arch: "",
+  };
+
+  assert.deepEqual(
+    buildAppSupportInfoRows(info, labels).map((row) => row.value),
+    ["Unknown", "Desktop", "Unknown", "Unknown"],
+  );
+});
+
+test("formats support info clipboard text in stable issue-friendly order", () => {
+  const info: AppSupportInfo = {
+    appVersion: "0.5.50",
+    runtime: "desktop",
+    osName: "macOS",
+    osVersion: "15.5",
+    arch: "aarch64",
+  };
+
+  assert.equal(
+    formatAppSupportInfoForClipboard(info, labels),
+    ["DBX Version: v0.5.50", "Runtime: Desktop", "Operating System: macOS 15.5", "Architecture: aarch64"].join("\n"),
+  );
+});
diff --git a/packages/app-tests/syncChangelog.test.ts b/packages/app-tests/syncChangelog.test.ts
new file mode 100644
index 0000000..deb4917
--- /dev/null
+++ b/packages/app-tests/syncChangelog.test.ts
@@ -0,0 +1,122 @@
+import { strict as assert } from "node:assert";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { test } from "vitest";
+
+const syncChangelog = await importScript(".github/scripts/sync-changelog.mjs");
+
+function importScript(path: string): Promise<Record<string, unknown>> {
+  const source = readFileSync(resolve(path), "utf8")
+    .replace(/^#!.*\r?\n/, "")
+    .replace("if (process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1]))", "if (false)");
+  return import(`data:text/javascript;base64,${Buffer.from(source).toString("base64")}`);
+}
+
+test("translateToEnglish reuses cached release translations when source hash is unchanged", async () => {
+  const cnJson = syncChangelog.buildReleasesJson(
+    [
+      {
+        tag_name: "v1.1.0",
+        name: "DBX v1.1.0",
+        published_at: "2026-05-18T00:00:00Z",
+        body: "### 新功能\n- **新增导出** — 支持导出表数据",
+        draft: false,
+        prerelease: false,
+      },
+      {
+        tag_name: "v1.0.0",
+        name: "DBX v1.0.0",
+        published_at: "2026-05-17T00:00:00Z",
+        body: "### 修复\n- **修复连接** — 避免重复连接",
+        draft: false,
+        prerelease: false,
+      },
+    ],
+    new Date("2026-05-18T01:00:00Z"),
+  );
+  const cachedRelease = {
+    ...cnJson.releases[1],
+    sections: [{ type: "fixed", title: "Fixed", items: [{ title: "Connection fix", desc: "Avoid duplicate connects" }] }],
+  };
+  const cachedEnJson = {
+    updatedAt: "2026-05-17T01:00:00.000Z",
+    releases: [cachedRelease],
+  };
+  let translationCalls = 0;
+
+  const enJson = await syncChangelog.translateToEnglish(cnJson, {
+    cachedEnJson,
+    deepseekApiKey: "test-key",
+    fetchImpl: async () => {
+      translationCalls++;
+      return {
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { content: "### Added\n- **Export added** — Supports table data export" } }],
+        }),
+      };
+    },
+    sleep: async () => {},
+  });
+
+  assert.equal(translationCalls, 1);
+  assert.deepEqual(enJson.releases[1], cachedRelease);
+  assert.equal(enJson.releases[0].sections[0].title, "Added");
+  assert.equal(enJson.releases[0]._sourceHash, cnJson.releases[0]._sourceHash);
+});
+
+test("translateToEnglish falls back to cached translations when API key is missing", async () => {
+  const cnJson = syncChangelog.buildReleasesJson(
+    [
+      {
+        tag_name: "v1.1.0",
+        name: "DBX v1.1.0",
+        published_at: "2026-05-18T00:00:00Z",
+        body: "### 新功能\n- **新增导出** — 支持导出表数据",
+        draft: false,
+        prerelease: false,
+      },
+      {
+        tag_name: "v1.0.0",
+        name: "DBX v1.0.0",
+        published_at: "2026-05-17T00:00:00Z",
+        body: "### 修复\n- **修复连接** — 避免重复连接",
+        draft: false,
+        prerelease: false,
+      },
+    ],
+    new Date("2026-05-18T01:00:00Z"),
+  );
+  const cachedRelease = {
+    ...cnJson.releases[1],
+    sections: [{ type: "fixed", title: "Fixed", items: [{ title: "Connection fix", desc: "Avoid duplicate connects" }] }],
+  };
+  const cachedEnJson = { updatedAt: "2026-05-17T01:00:00.000Z", releases: [cachedRelease] };
+
+  let translationCalls = 0;
+  const enJson = await syncChangelog.translateToEnglish(cnJson, {
+    cachedEnJson,
+    deepseekApiKey: "",
+    fetchImpl: async () => {
+      translationCalls++;
+      return { ok: true, json: async () => ({}) };
+    },
+    sleep: async () => {},
+  });
+
+  // 无 key 时不调用翻译 API
+  assert.equal(translationCalls, 0);
+  // cache 命中的条目复用英文翻译
+  assert.deepEqual(enJson.releases[1], cachedRelease);
+  // cache 未命中的条目回退中文原文，保证 CHANGELOG 条目不缺失
+  assert.equal(enJson.releases[0].sections[0].title, "新功能");
+});
+
+test("parseBody strips closes # issue refs but keeps contributor attribution", () => {
+  const sections = syncChangelog.parseBody(
+    "### 新功能\n- **导出** — 支持导出表数据 (contributed by @wuxiemian, closes #2577, closes #2473)\n- **清理** — 删除旧资源 (closes #2586)\n- **校验** — 预校验路径 (closes #88, contributed by @Mukesh)",
+  );
+  assert.equal(sections[0].items[0].desc, "支持导出表数据 (contributed by @wuxiemian)");
+  assert.equal(sections[0].items[1].desc, "删除旧资源");
+  assert.equal(sections[0].items[2].desc, "预校验路径 (contributed by @Mukesh)");
+});
diff --git a/packages/app-tests/tabCloseActions.test.ts b/packages/app-tests/tabCloseActions.test.ts
new file mode 100644
index 0000000..76ed095
--- /dev/null
+++ b/packages/app-tests/tabCloseActions.test.ts
@@ -0,0 +1,38 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { closeAllTabsState, closeOtherTabsState } from "../../apps/desktop/src/lib/tabs/tabCloseActions.ts";
+
+test("close other tabs keeps the target tab and makes it active", () => {
+  const tabs = [{ id: "a" }, { id: "b" }, { id: "c" }];
+
+  const result = closeOtherTabsState(tabs, "a", "b");
+
+  assert.deepEqual(
+    result.tabs.map((tab) => tab.id),
+    ["b"],
+  );
+  assert.equal(result.activeTabId, "b");
+  assert.deepEqual(
+    tabs.map((tab) => tab.id),
+    ["a", "b", "c"],
+  );
+});
+
+test("close other tabs is a no-op when the target tab is missing", () => {
+  const tabs = [{ id: "a" }, { id: "b" }];
+
+  const result = closeOtherTabsState(tabs, "a", "missing");
+
+  assert.deepEqual(
+    result.tabs.map((tab) => tab.id),
+    ["a", "b"],
+  );
+  assert.equal(result.activeTabId, "a");
+});
+
+test("close all tabs clears every tab and active tab", () => {
+  const result = closeAllTabsState([{ id: "a" }, { id: "b" }], "a");
+
+  assert.deepEqual(result.tabs, []);
+  assert.equal(result.activeTabId, null);
+});
diff --git a/packages/app-tests/tabPresentation.test.ts b/packages/app-tests/tabPresentation.test.ts
new file mode 100644
index 0000000..27294bc
--- /dev/null
+++ b/packages/app-tests/tabPresentation.test.ts
@@ -0,0 +1,277 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { createPinia, setActivePinia } from "pinia";
+import { activeResultRun, databaseDisplayNameForTab, executionSummaryItems, nextExecutionSummaryView, resultGridCacheKey, resultRunItems, resultSqlForGrid, tabDisplayTitle, tabModeLabel, tabularResultItems } from "../../apps/desktop/src/lib/tabs/tabPresentation.ts";
+import { useConnectionStore } from "../../apps/desktop/src/stores/connectionStore.ts";
+import type { ConnectionConfig, QueryResult, QueryTab } from "../../apps/desktop/src/types/database.ts";
+
+function installMemoryStorage() {
+  const values = new Map<string, string>();
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+      clear: () => values.clear(),
+    },
+  });
+  return () => {
+    if (original) Object.defineProperty(globalThis, "localStorage", original);
+    else Reflect.deleteProperty(globalThis, "localStorage");
+  };
+}
+
+function conn(id: string): ConnectionConfig {
+  return {
+    id,
+    name: "Prod",
+    db_type: "postgres",
+    host: "localhost",
+    port: 5432,
+    username: "postgres",
+    password: "",
+  };
+}
+
+function queryTab(overrides: Partial<QueryTab> = {}): QueryTab {
+  return {
+    id: "tab-1",
+    title: "Query 1",
+    connectionId: "conn-1",
+    database: "app",
+    sql: "",
+    isExecuting: false,
+    mode: "query",
+    ...overrides,
+  };
+}
+
+function result(columns: string[], overrides: Partial<QueryResult> = {}): QueryResult {
+  return {
+    columns,
+    rows: [],
+    affected_rows: 0,
+    execution_time_ms: 1,
+    ...overrides,
+  };
+}
+
+test("query tab display title uses custom title when present", () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  useConnectionStore().addEphemeralConnection(conn("conn-1"));
+  const t = (key: string) => key;
+
+  try {
+    assert.equal(tabDisplayTitle(queryTab(), t), "Prod@app");
+    assert.equal(tabDisplayTitle(queryTab({ title: "Revenue checks", customTitle: true }), t), "Revenue checks");
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("jdbc tabs use the connection target when database is empty", () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  useConnectionStore().addEphemeralConnection({
+    ...conn("conn-1"),
+    db_type: "jdbc",
+    connection_string: "jdbc:oracle:thin:@172.20.66.143:20001:XE",
+  });
+  const t = (key: string) => (key === "editor.noDatabase" ? "No database selected" : key);
+
+  try {
+    assert.equal(databaseDisplayNameForTab("conn-1", "", t), "XE");
+    assert.equal(
+      tabDisplayTitle(
+        queryTab({
+          database: "",
+          mode: "data",
+          tableMeta: {
+            schema: "SYSTEM",
+            tableName: "DBX_JDBC_TEST",
+            columns: [],
+            primaryKeys: ["ID"],
+          },
+        }),
+        t,
+      ),
+      "DBX_JDBC_TEST@XE.SYSTEM",
+    );
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("zookeeper tabs use key browser labels", () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  useConnectionStore().addEphemeralConnection({
+    ...conn("conn-1"),
+    name: "ZK Prod",
+    db_type: "zookeeper",
+    port: 2181,
+  });
+  const t = (key: string) => (key === "tabs.zookeeper" ? "ZooKeeper" : key);
+
+  try {
+    const tab = queryTab({ mode: "zookeeper", database: "", title: "ZooKeeper Keys" });
+    assert.equal(tabDisplayTitle(tab, t), "ZK Prod@keys");
+    assert.equal(tabModeLabel(tab, t), "ZooKeeper");
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("GridFS tabs use dedicated titles and labels", () => {
+  const restoreStorage = installMemoryStorage();
+  setActivePinia(createPinia());
+  useConnectionStore().addEphemeralConnection({
+    ...conn("conn-1"),
+    name: "uat-mongo",
+    db_type: "mongodb",
+    port: 27017,
+  });
+  const t = (key: string) => {
+    if (key === "tabs.gridfs") return "GridFS";
+    if (key === "tabs.mongo") return "Mongo";
+    return key;
+  };
+
+  try {
+    const managerTab = queryTab({
+      title: "GridFS",
+      database: "amazon",
+      mode: "mongo-gridfs" as QueryTab["mode"],
+      sql: "",
+    });
+    const bucketTab = queryTab({
+      title: "amazon.NMDocumentData_acc001",
+      database: "amazon",
+      mode: "mongo-bucket",
+      sql: "NMDocumentData_acc001",
+      mongoBucket: { bucketName: "NMDocumentData_acc001" },
+    });
+
+    assert.equal(tabDisplayTitle(managerTab, t), "GridFS@amazon");
+    assert.equal(tabDisplayTitle(bucketTab, t), "NMDocumentData_acc001@amazon");
+    assert.equal(tabModeLabel(managerTab, t), "GridFS");
+    assert.equal(tabModeLabel(bucketTab, t), "GridFS");
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("tabular result items hide statement results without returned columns", () => {
+  const results = [result([]), result(["id"]), result([]), result(["name"])];
+
+  assert.deepEqual(
+    tabularResultItems(results).map((item) => ({ index: item.index, n: item.n, columns: item.result.columns })),
+    [
+      { index: 1, n: 1, columns: ["id"] },
+      { index: 3, n: 2, columns: ["name"] },
+    ],
+  );
+  assert.deepEqual(tabularResultItems([result([])]), []);
+  assert.deepEqual(tabularResultItems(undefined), []);
+});
+
+test("tabular result items expose source labels when available", () => {
+  const results = [result([]), result(["id"], { sourceLabel: "public.users", sourceStatement: "select * from public.users" }), result(["name"], { sourceStatement: "select id, name, email, created_at from users where active = true order by created_at desc" })];
+
+  assert.deepEqual(
+    tabularResultItems(results).map((item) => ({ index: item.index, n: item.n, label: item.label, title: item.title })),
+    [
+      { index: 1, n: 1, label: "public.users", title: "select * from public.users" },
+      { index: 2, n: 2, label: undefined, title: "select id, name, email, created_at from users where active = true order by created_at desc" },
+    ],
+  );
+  assert.deepEqual(
+    tabularResultItems([result(["id"], { sourceLabel: "db.users" })]).map((item) => item.label),
+    ["db.users"],
+  );
+});
+
+test("resultSqlForGrid prefers the active result source statement", () => {
+  const tab = queryTab({
+    sql: "select * from users; select * from orders",
+    lastExecutedSql: "select * from users; select * from orders",
+    resultBaseSql: "select * from users; select * from orders",
+    result: result(["id"], { sourceStatement: "select * from orders" }),
+  });
+
+  assert.equal(resultSqlForGrid(tab), "select * from orders");
+  assert.equal(resultSqlForGrid(queryTab({ sql: "select 1", resultBaseSql: "select 2" })), "select 2");
+  assert.equal(resultSqlForGrid(queryTab({ sql: "select 1", lastExecutedSql: "select 3" })), "select 3");
+});
+
+test("result run items expose ordered labels and active state", () => {
+  const tab = queryTab({
+    activeResultRunId: "run-2",
+    resultRuns: [
+      {
+        id: "run-1",
+        title: "Run 1",
+        sequence: 1,
+        sql: "select 1",
+        createdAt: 10,
+        result: result(["one"]),
+      },
+      {
+        id: "run-2",
+        title: "Run 2",
+        sequence: 2,
+        sql: "select 2",
+        createdAt: 20,
+        result: result(["two"]),
+      },
+    ],
+  });
+
+  assert.deepEqual(resultRunItems(tab), [
+    { id: "run-1", title: "Run 1", sequence: 1, active: false },
+    { id: "run-2", title: "Run 2", sequence: 2, active: true },
+  ]);
+  assert.equal(activeResultRun(tab)?.id, "run-2");
+  assert.deepEqual(
+    resultRunItems(queryTab()).map((item) => item.title),
+    [],
+  );
+});
+
+test("result grid cache key includes result run id and statement result index", () => {
+  const tab = queryTab({ activeResultRunId: "run-7", activeResultIndex: 3 });
+
+  assert.equal(resultGridCacheKey(tab), "tab-1-run-7-3");
+  assert.equal(resultGridCacheKey(queryTab({ activeResultIndex: undefined })), "tab-1-current-0");
+});
+
+test("execution summary items include table and non-table statement results", () => {
+  const items = executionSummaryItems({
+    results: [result([]), result(["id"]), { ...result(["Error"]), rows: [["boom"]] }],
+  });
+
+  assert.deepEqual(
+    items.map((item) => ({
+      index: item.index,
+      hasTabularResult: item.hasTabularResult,
+      returnedColumns: item.returnedColumns,
+      returnedRows: item.returnedRows,
+      isError: item.isError,
+    })),
+    [
+      { index: 0, hasTabularResult: false, returnedColumns: 0, returnedRows: 0, isError: false },
+      { index: 1, hasTabularResult: true, returnedColumns: 1, returnedRows: 0, isError: false },
+      { index: 2, hasTabularResult: true, returnedColumns: 1, returnedRows: 1, isError: true },
+    ],
+  );
+});
+
+test("execution summary button toggles back to result only when result view is available", () => {
+  assert.equal(nextExecutionSummaryView("result", true), "summary");
+  assert.equal(nextExecutionSummaryView("chart", true), "summary");
+  assert.equal(nextExecutionSummaryView("summary", true), "result");
+  assert.equal(nextExecutionSummaryView("summary", false), "summary");
+});
diff --git a/packages/app-tests/tabResultCache.test.ts b/packages/app-tests/tabResultCache.test.ts
new file mode 100644
index 0000000..2d289bf
--- /dev/null
+++ b/packages/app-tests/tabResultCache.test.ts
@@ -0,0 +1,153 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildTabResultSnapshot, decodeTabResultSnapshot, encodeTabResultSnapshot } from "../../apps/desktop/src/lib/tabs/tabResultCache.ts";
+import type { QueryTab } from "../../apps/desktop/src/types/database.ts";
+
+function queryTab(overrides: Partial<QueryTab> = {}): QueryTab {
+  return {
+    id: "tab-1",
+    title: "Query 1",
+    connectionId: "conn-1",
+    database: "app",
+    sql: "select * from users",
+    isExecuting: false,
+    mode: "query",
+    ...overrides,
+  };
+}
+
+test("result snapshots strip live session handles and clone result rows", () => {
+  const tab = queryTab({
+    result: {
+      columns: ["id"],
+      rows: [[1]],
+      mongo_documents: [{ _id: "1", profile: { role: "admin" } }],
+      affected_rows: 0,
+      execution_time_ms: 1,
+      session_id: "live-session",
+      sourceLabel: "public.users",
+      sourceStatement: "select * from public.users",
+    },
+    results: [
+      {
+        columns: ["id"],
+        rows: [[1]],
+        affected_rows: 0,
+        execution_time_ms: 1,
+        session_id: "live-session",
+      },
+    ],
+    activeResultIndex: 0,
+    resultLocalSortOriginalRows: [[2]],
+    resultLocalSortOriginalMongoDocuments: [{ _id: "2", profile: { role: "maintainer" } }],
+  });
+
+  const snapshot = buildTabResultSnapshot(tab);
+
+  assert.equal(snapshot?.result?.session_id, undefined);
+  assert.equal(snapshot?.result?.sourceLabel, "public.users");
+  assert.equal(snapshot?.result?.sourceStatement, "select * from public.users");
+  assert.equal(snapshot?.results?.[0]?.session_id, undefined);
+  assert.deepEqual(snapshot?.result?.rows, [[1]]);
+  assert.deepEqual(snapshot?.result?.mongo_documents, [{ _id: "1", profile: { role: "admin" } }]);
+  assert.deepEqual(snapshot?.resultLocalSortOriginalRows, [[2]]);
+  assert.deepEqual(snapshot?.resultLocalSortOriginalMongoDocuments, [{ _id: "2", profile: { role: "maintainer" } }]);
+  tab.result!.rows[0]![0] = 2;
+  tab.resultLocalSortOriginalRows![0]![0] = 3;
+  assert.deepEqual(snapshot?.result?.rows, [[1]]);
+  assert.deepEqual(snapshot?.resultLocalSortOriginalRows, [[2]]);
+});
+
+test("result snapshots strip session handles from result runs", () => {
+  const tab = queryTab({
+    resultRuns: [
+      {
+        id: "run-1",
+        title: "Run 1",
+        sequence: 1,
+        sql: "select 1",
+        createdAt: 1,
+        result: {
+          columns: ["id"],
+          rows: [[1]],
+          affected_rows: 0,
+          execution_time_ms: 1,
+          session_id: "live-run-session",
+          sourceLabel: "users",
+          sourceStatement: "select * from users",
+        },
+        resultLocalSortOriginalRows: [[2]],
+        resultLocalSortOriginalMongoDocuments: [{ _id: "2", role: "maintainer" }],
+      },
+    ],
+  });
+
+  const snapshot = buildTabResultSnapshot(tab);
+
+  assert.equal(snapshot?.resultRuns?.[0]?.result?.session_id, undefined);
+  assert.equal(snapshot?.resultRuns?.[0]?.result?.sourceLabel, "users");
+  assert.equal(snapshot?.resultRuns?.[0]?.result?.sourceStatement, "select * from users");
+  assert.deepEqual(snapshot?.resultRuns?.[0]?.result?.rows, [[1]]);
+  assert.deepEqual(snapshot?.resultRuns?.[0]?.resultLocalSortOriginalRows, [[2]]);
+  assert.deepEqual(snapshot?.resultRuns?.[0]?.resultLocalSortOriginalMongoDocuments, [{ _id: "2", role: "maintainer" }]);
+});
+
+test("result snapshots encode as binary columnar payloads and decode back to rows", () => {
+  const snapshot = buildTabResultSnapshot(
+    queryTab({
+      result: {
+        columns: ["id", "name", "active"],
+        rows: [
+          [1, "Ada", true],
+          [2, "Linus", false],
+        ],
+        mongo_documents: [
+          { _id: "1", name: "Ada", tags: ["admin"] },
+          { _id: "2", name: "Linus", tags: ["maintainer"] },
+        ],
+        affected_rows: 0,
+        execution_time_ms: 3,
+        session_id: "live-session",
+        has_more: true,
+        sourceLabel: "public.users",
+        sourceStatement: "select id, name, active from public.users",
+      },
+      resultLocalSortOriginalRows: [
+        [2, "Linus", false],
+        [1, "Ada", true],
+      ],
+      resultLocalSortOriginalMongoDocuments: [
+        { _id: "2", name: "Linus", tags: ["maintainer"] },
+        { _id: "1", name: "Ada", tags: ["admin"] },
+      ],
+    }),
+  );
+  assert.ok(snapshot);
+
+  const encoded = encodeTabResultSnapshot(snapshot);
+  const decoded = decodeTabResultSnapshot(encoded);
+
+  assert.ok(encoded instanceof Uint8Array);
+  assert.deepEqual(decoded?.result?.columns, ["id", "name", "active"]);
+  assert.deepEqual(decoded?.result?.rows, [
+    [1, "Ada", true],
+    [2, "Linus", false],
+  ]);
+  assert.deepEqual(decoded?.result?.mongo_documents, [
+    { _id: "1", name: "Ada", tags: ["admin"] },
+    { _id: "2", name: "Linus", tags: ["maintainer"] },
+  ]);
+  assert.deepEqual(decoded?.resultLocalSortOriginalRows, [
+    [2, "Linus", false],
+    [1, "Ada", true],
+  ]);
+  assert.deepEqual(decoded?.resultLocalSortOriginalMongoDocuments, [
+    { _id: "2", name: "Linus", tags: ["maintainer"] },
+    { _id: "1", name: "Ada", tags: ["admin"] },
+  ]);
+  assert.equal(decoded?.result?.session_id, undefined);
+  assert.equal(decoded?.result?.has_more, true);
+  assert.equal(decoded?.result?.sourceLabel, "public.users");
+  assert.equal(decoded?.result?.sourceStatement, "select id, name, active from public.users");
+  assert.equal(decoded?.cachedAt, snapshot.cachedAt);
+});
diff --git a/packages/app-tests/tableClipboard.test.ts b/packages/app-tests/tableClipboard.test.ts
new file mode 100644
index 0000000..742a82f
--- /dev/null
+++ b/packages/app-tests/tableClipboard.test.ts
@@ -0,0 +1,61 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import type { ColumnInfo } from "../../apps/desktop/src/types/database.ts";
+import { defaultPasteTableMode, pasteTableModeCopiesData, supportsWholeRowTableDataCopy, tableClipboardMatchesTarget, tableDataCopyColumnOptions } from "../../apps/desktop/src/lib/table/tableClipboard.ts";
+
+test("table clipboard entries must match the paste target context", () => {
+  const target = { connectionId: "c1", database: "app", schema: "public" };
+
+  assert.equal(tableClipboardMatchesTarget([{ connectionId: "c1", database: "app", schema: "public" }], target), true);
+  assert.equal(tableClipboardMatchesTarget([{ connectionId: "c2", database: "app", schema: "public" }], target), false);
+  assert.equal(tableClipboardMatchesTarget([{ connectionId: "c1", database: "other", schema: "public" }], target), false);
+  assert.equal(tableClipboardMatchesTarget([{ connectionId: "c1", database: "app", schema: "audit" }], target), false);
+  assert.equal(tableClipboardMatchesTarget([], target), false);
+  assert.equal(tableClipboardMatchesTarget([{ connectionId: "c1", database: "app" }], null), false);
+});
+
+test("whole-row table data copy is enabled for known database types", () => {
+  assert.equal(supportsWholeRowTableDataCopy("mysql"), true);
+  assert.equal(supportsWholeRowTableDataCopy("postgres"), true);
+  assert.equal(supportsWholeRowTableDataCopy("sqlserver"), true);
+  assert.equal(supportsWholeRowTableDataCopy(undefined), false);
+  assert.equal(supportsWholeRowTableDataCopy("sqlite"), true);
+  assert.equal(defaultPasteTableMode("mysql"), "structure-and-data");
+  assert.equal(defaultPasteTableMode(undefined), "structure-only");
+  assert.equal(defaultPasteTableMode("sqlite"), "structure-and-data");
+  assert.equal(pasteTableModeCopiesData("structure-and-data"), true);
+  assert.equal(pasteTableModeCopiesData("data-only"), true);
+  assert.equal(pasteTableModeCopiesData("structure-only"), false);
+});
+
+test("table data copy uses only writable columns for first-class databases", () => {
+  const column = (name: string, extra: string | null): ColumnInfo => ({
+    name,
+    data_type: "int",
+    is_nullable: true,
+    column_default: null,
+    is_primary_key: name === "id",
+    extra,
+    comment: null,
+    numeric_precision: null,
+    numeric_scale: null,
+    character_maximum_length: null,
+  });
+  const columns = [column("id", "identity(1,1)"), column("name", null), column("full_name", "computed")];
+
+  assert.deepEqual(tableDataCopyColumnOptions("sqlserver", columns), {
+    columns: ["id", "name"],
+    postgresOverridingSystemValue: false,
+    sqlserverIdentityInsert: true,
+  });
+  assert.deepEqual(tableDataCopyColumnOptions("postgres", [{ ...columns[0], extra: "generated always as identity" }, { ...columns[1] }, { ...columns[2], extra: "generated always as (name) stored" }]), {
+    columns: ["id", "name"],
+    postgresOverridingSystemValue: true,
+    sqlserverIdentityInsert: false,
+  });
+  assert.deepEqual(tableDataCopyColumnOptions("mysql", [{ ...columns[0], extra: "auto_increment" }, { ...columns[1] }, { ...columns[2], extra: "STORED GENERATED" }]), {
+    columns: ["id", "name"],
+    postgresOverridingSystemValue: false,
+    sqlserverIdentityInsert: false,
+  });
+});
diff --git a/packages/app-tests/tableColumnTemplates.test.ts b/packages/app-tests/tableColumnTemplates.test.ts
new file mode 100644
index 0000000..22b514a
--- /dev/null
+++ b/packages/app-tests/tableColumnTemplates.test.ts
@@ -0,0 +1,116 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { createTableColumnTemplateDrafts, DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS, normalizeTableColumnTemplateFields, parseTableColumnTemplateFields, PRESET_FIELDS_TEMPLATE_ID, tableColumnTemplates, TABLE_COLUMN_TEMPLATE_DATABASE_TYPES } from "../../apps/desktop/src/lib/table/tableColumnTemplates.ts";
+
+const sixCustomFields = [
+  "tenant_id | mysql:bigint | postgres:uuid | default:0 | comment:Tenant",
+  "request_id | mysql:varchar(64) | postgres:varchar(64)",
+  "created_time | mysql:datetime | postgres:timestamp | default:CURRENT_TIMESTAMP",
+  "modified_time | mysql:datetime | postgres:timestamp",
+  "creator_id | mysql:bigint | postgres:bigint",
+  "modifier_id | mysql:bigint | postgres:bigint | required:false",
+];
+
+test("has no built-in preset field names by default", () => {
+  assert.deepEqual(DEFAULT_TABLE_COLUMN_TEMPLATE_FIELDS, []);
+  assert.deepEqual(normalizeTableColumnTemplateFields(undefined), []);
+  assert.deepEqual(normalizeTableColumnTemplateFields([]), []);
+  assert.deepEqual(tableColumnTemplates(), [
+    {
+      id: PRESET_FIELDS_TEMPLATE_ID,
+      labelKey: "structureEditor.presetFieldsTemplate",
+      columnNames: [],
+    },
+  ]);
+});
+
+test("builds no preset field drafts until users configure fields", () => {
+  const columns = createTableColumnTemplateDrafts({
+    templateId: PRESET_FIELDS_TEMPLATE_ID,
+    databaseType: "postgres",
+    createId: () => "id",
+  });
+
+  assert.deepEqual(columns, []);
+});
+
+test("builds configured preset field drafts", () => {
+  let id = 0;
+  const columns = createTableColumnTemplateDrafts({
+    templateId: PRESET_FIELDS_TEMPLATE_ID,
+    databaseType: "mysql",
+    columnNames: sixCustomFields,
+    createId: () => String(++id),
+  });
+
+  assert.deepEqual(
+    columns.map((column) => ({
+      id: column.id,
+      name: column.name,
+      dataType: column.dataType,
+      isNullable: column.isNullable,
+      defaultValue: column.defaultValue,
+      comment: column.comment,
+    })),
+    [
+      { id: "new:1", name: "tenant_id", dataType: "bigint", isNullable: false, defaultValue: "0", comment: "Tenant" },
+      { id: "new:2", name: "request_id", dataType: "varchar(64)", isNullable: false, defaultValue: "", comment: "" },
+      { id: "new:3", name: "created_time", dataType: "datetime", isNullable: false, defaultValue: "CURRENT_TIMESTAMP", comment: "" },
+      { id: "new:4", name: "modified_time", dataType: "datetime", isNullable: false, defaultValue: "", comment: "" },
+      { id: "new:5", name: "creator_id", dataType: "bigint", isNullable: false, defaultValue: "", comment: "" },
+      { id: "new:6", name: "modifier_id", dataType: "bigint", isNullable: true, defaultValue: "", comment: "" },
+    ],
+  );
+});
+
+test("filters configured fields by current database type", () => {
+  const columns = createTableColumnTemplateDrafts({
+    templateId: PRESET_FIELDS_TEMPLATE_ID,
+    databaseType: "postgres",
+    columnNames: ["mysql_only | mysql:bigint", "postgres_only | postgres:uuid", "common_name | mysql:<empty> | postgres:<empty>", "common_code | mysql:varchar(64) | postgres:varchar(32)"],
+    createId: () => "id",
+  });
+
+  assert.deepEqual(
+    columns.map((column) => ({ name: column.name, dataType: column.dataType })),
+    [
+      { name: "postgres_only", dataType: "uuid" },
+      { name: "common_name", dataType: "" },
+      { name: "common_code", dataType: "varchar(32)" },
+    ],
+  );
+});
+
+test("normalizes configured preset fields without adding built-in fields", () => {
+  const [tenantId, requestId] = normalizeTableColumnTemplateFields([" tenant_id | mysql:bigint | postgres:uuid | default:0 ", "tenant_id | mysql:int", "", "request_id | mysql:varchar(64)"]);
+  assert.equal(tenantId, "tenant_id | mysql:bigint | postgres:uuid | default:0");
+  assert.equal(requestId, "request_id | mysql:varchar(64)");
+
+  const parsed = parseTableColumnTemplateFields(["tenant_id | mysql:bigint | postgres:uuid | nullable:true | default:0 | comment:Tenant"]);
+  assert.deepEqual(parsed[0], { name: "tenant_id", dataTypesByDatabase: { mysql: "bigint", postgres: "uuid" }, defaultValue: "0", isNullable: true, comment: "Tenant" });
+});
+
+test("limits preset field database types to create-table capable SQL structures", () => {
+  assert.ok(TABLE_COLUMN_TEMPLATE_DATABASE_TYPES.includes("mysql"));
+  assert.ok(TABLE_COLUMN_TEMPLATE_DATABASE_TYPES.includes("postgres"));
+  assert.ok(TABLE_COLUMN_TEMPLATE_DATABASE_TYPES.includes("clickhouse"));
+  assert.ok(!TABLE_COLUMN_TEMPLATE_DATABASE_TYPES.includes("mongodb"));
+  assert.ok(!TABLE_COLUMN_TEMPLATE_DATABASE_TYPES.includes("redis"));
+  assert.ok(!TABLE_COLUMN_TEMPLATE_DATABASE_TYPES.includes("elasticsearch"));
+  assert.ok(!TABLE_COLUMN_TEMPLATE_DATABASE_TYPES.includes("manticoresearch"));
+});
+
+test("skips configured preset fields that already exist", () => {
+  const columns = createTableColumnTemplateDrafts({
+    templateId: PRESET_FIELDS_TEMPLATE_ID,
+    databaseType: "mysql",
+    columnNames: sixCustomFields,
+    existingColumnNames: ["tenant_id", "MODIFIER_ID"],
+    createId: () => "x",
+  });
+
+  assert.deepEqual(
+    columns.map((column) => column.name),
+    ["request_id", "created_time", "modified_time", "creator_id"],
+  );
+});
diff --git a/packages/app-tests/tableDataExport.test.ts b/packages/app-tests/tableDataExport.test.ts
new file mode 100644
index 0000000..1e7569b
--- /dev/null
+++ b/packages/app-tests/tableDataExport.test.ts
@@ -0,0 +1,35 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { fetchTableDataForExport, TABLE_DATA_EXPORT_PAGE_SIZE } from "../../apps/desktop/src/lib/table/tableDataExport.ts";
+import type { QueryResult } from "../../apps/desktop/src/types/database.ts";
+
+function result(rows: QueryResult["rows"]): QueryResult {
+  return {
+    columns: ["id"],
+    rows,
+    affected_rows: 0,
+    execution_time_ms: 1,
+    truncated: false,
+    has_more: false,
+  };
+}
+
+test("fetchTableDataForExport pages past the 10000 row export boundary", async () => {
+  const sqls: string[] = [];
+  const pages = [result(Array.from({ length: TABLE_DATA_EXPORT_PAGE_SIZE }, (_, index) => [index + 1])), result([[10_001], [10_002]])];
+
+  const exported = await fetchTableDataForExport({
+    databaseType: "mysql",
+    tableName: "users",
+    buildPageSql: ({ limit, offset }) => (offset ? `SELECT * FROM \`users\` LIMIT ${limit} OFFSET ${offset};` : `SELECT * FROM \`users\` LIMIT ${limit};`),
+    executePage: async (sql) => {
+      sqls.push(sql);
+      return pages.shift() ?? result([]);
+    },
+  });
+
+  assert.equal(exported.rows.length, TABLE_DATA_EXPORT_PAGE_SIZE + 2);
+  assert.deepEqual(exported.rows.at(-1), [10_002]);
+  assert.deepEqual(sqls, ["SELECT * FROM `users` LIMIT 10000;", "SELECT * FROM `users` LIMIT 10000 OFFSET 10000;"]);
+  assert.equal(exported.truncated, false);
+});
diff --git a/packages/app-tests/tableDataTabMeta.test.ts b/packages/app-tests/tableDataTabMeta.test.ts
new file mode 100644
index 0000000..eaa1f38
--- /dev/null
+++ b/packages/app-tests/tableDataTabMeta.test.ts
@@ -0,0 +1,81 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { tableMetaForDataTab } from "../../apps/desktop/src/lib/table/tableDataTabMeta.ts";
+import type { QueryTab } from "../../apps/desktop/src/types/database.ts";
+
+function tab(overrides: Partial<QueryTab> = {}): QueryTab {
+  return {
+    id: "tab-1",
+    title: "users",
+    connectionId: "conn-1",
+    database: "app",
+    schema: "public",
+    sql: "select * from users",
+    isExecuting: false,
+    isCancelling: false,
+    isExplaining: false,
+    mode: "data",
+    ...overrides,
+  };
+}
+
+test("returns persisted table metadata for a data tab", () => {
+  const tableMeta = {
+    schema: "public",
+    tableName: "users",
+    columns: [
+      {
+        name: "id",
+        data_type: "integer",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: true,
+        extra: null,
+      },
+    ],
+    primaryKeys: ["id"],
+  };
+
+  assert.equal(tableMetaForDataTab(tab({ tableMeta })), tableMeta);
+});
+
+test("builds fallback metadata from a data tab when column metadata is unavailable", () => {
+  const meta = tableMetaForDataTab(
+    tab({
+      result: {
+        columns: ["id", "name"],
+        rows: [],
+        affected_rows: 0,
+        execution_time_ms: 1,
+      },
+    }),
+  );
+
+  assert.deepEqual(meta, {
+    schema: "public",
+    tableName: "users",
+    columns: [
+      {
+        name: "id",
+        data_type: "",
+        is_nullable: true,
+        column_default: null,
+        is_primary_key: false,
+        extra: null,
+      },
+      {
+        name: "name",
+        data_type: "",
+        is_nullable: true,
+        column_default: null,
+        is_primary_key: false,
+        extra: null,
+      },
+    ],
+    primaryKeys: [],
+  });
+});
+
+test("does not infer table metadata for query tabs", () => {
+  assert.equal(tableMetaForDataTab(tab({ mode: "query" })), undefined);
+});
diff --git a/packages/app-tests/tableEditing.test.ts b/packages/app-tests/tableEditing.test.ts
new file mode 100644
index 0000000..94262e0
--- /dev/null
+++ b/packages/app-tests/tableEditing.test.ts
@@ -0,0 +1,157 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import {
+  DBX_NEO4J_ELEMENT_ID_COLUMN,
+  DBX_ROWID_COLUMN,
+  DBX_TDENGINE_TBNAME_COLUMN,
+  canEditExistingTableRows,
+  canInsertTableRows,
+  editablePrimaryKeys,
+  hasCompleteTdengineRowIdentity,
+  hiveTablePropertiesIndicateTransactional,
+  isHiddenGridColumn,
+  isTdengineExistingRowReadonlyColumn,
+  isTableDataEditable,
+  supportsDataGridTransaction,
+  usesSyntheticRowIdKey,
+} from "../../apps/desktop/src/lib/table/tableEditing.ts";
+import type { ColumnInfo } from "../../apps/desktop/src/types/database.ts";
+
+function column(name: string, isPrimaryKey = false): ColumnInfo {
+  return {
+    name,
+    data_type: "VARCHAR2",
+    is_nullable: true,
+    column_default: null,
+    is_primary_key: isPrimaryKey,
+    extra: null,
+  };
+}
+
+test("uses ROWID as Oracle editable key when a table has no primary key", () => {
+  assert.deepEqual(editablePrimaryKeys("oracle", [column("ID"), column("CITY")]), [DBX_ROWID_COLUMN]);
+});
+
+test("keeps declared primary keys ahead of Oracle ROWID fallback", () => {
+  assert.deepEqual(editablePrimaryKeys("oracle", [column("ID", true), column("CITY")]), ["ID"]);
+});
+
+test("does not synthesize ROWID for non-Oracle keyless tables", () => {
+  assert.deepEqual(editablePrimaryKeys("mysql", [column("ID"), column("CITY")]), []);
+});
+
+test("uses table-specific TDengine editable keys", () => {
+  const columns = [column("ts", true), column("seq", true), column("current")];
+  assert.deepEqual(editablePrimaryKeys("tdengine", columns, "STABLE"), [DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"]);
+  assert.deepEqual(editablePrimaryKeys("tdengine", columns, "TABLE"), ["ts", "seq"]);
+  assert.equal(hasCompleteTdengineRowIdentity("tdengine", [DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"], ["tbname", "ts", "seq", "current"]), true);
+  assert.equal(hasCompleteTdengineRowIdentity("tdengine", [DBX_TDENGINE_TBNAME_COLUMN, "ts", "seq"], ["tbname", "ts", "current"]), false);
+});
+
+test("allows updateable SQL table data editing even without declared primary keys", () => {
+  assert.equal(isTableDataEditable("access", []), true);
+  assert.equal(isTableDataEditable("sqlite", []), true);
+  assert.equal(isTableDataEditable("duckdb", []), true);
+  assert.equal(isTableDataEditable("dameng", []), true);
+  assert.equal(isTableDataEditable("hive", []), true);
+  assert.equal(isTableDataEditable("trino", []), true);
+  assert.equal(isTableDataEditable("informix", []), true);
+  assert.equal(isTableDataEditable("tdengine", []), true);
+  assert.equal(isTableDataEditable("mysql", []), true);
+  assert.equal(isTableDataEditable("manticoresearch", []), true);
+  assert.equal(isTableDataEditable("databend", []), true);
+  assert.equal(isTableDataEditable("postgres", []), true);
+  assert.equal(isTableDataEditable("postgres", ["id"]), true);
+});
+
+test("does not use transactional grid saves for non-transactional engines", () => {
+  assert.equal(supportsDataGridTransaction("hive"), false);
+  assert.equal(supportsDataGridTransaction("manticoresearch"), false);
+  assert.equal(supportsDataGridTransaction("trino"), false);
+  assert.equal(supportsDataGridTransaction("jdbc"), false);
+  assert.equal(supportsDataGridTransaction("yashandb"), true);
+  assert.equal(supportsDataGridTransaction("postgres"), true);
+});
+
+test("detects whether table data supports inserted rows", () => {
+  assert.equal(canInsertTableRows("postgres"), true);
+  assert.equal(canInsertTableRows("mysql"), true);
+  assert.equal(canInsertTableRows("hive"), true);
+  assert.equal(canInsertTableRows("jdbc"), false);
+  assert.equal(canInsertTableRows("clickhouse"), true);
+  assert.equal(canInsertTableRows("influxdb"), false);
+});
+
+test("allows existing row edits according to database-specific key requirements", () => {
+  assert.equal(canEditExistingTableRows("access", undefined, []), true);
+  assert.equal(canEditExistingTableRows("access", undefined, ["ID"]), true);
+  assert.equal(canEditExistingTableRows("dameng", undefined, []), true);
+  assert.equal(canEditExistingTableRows("dameng", undefined, ["ID"]), true);
+  assert.equal(canEditExistingTableRows("hive", true), true);
+  assert.equal(canEditExistingTableRows("hive", false), false);
+  assert.equal(canEditExistingTableRows("hive", undefined), false);
+  assert.equal(canEditExistingTableRows("trino", undefined, []), false);
+  assert.equal(canEditExistingTableRows("trino", undefined, ["id"]), true);
+  assert.equal(canEditExistingTableRows("mysql", undefined, []), true);
+  assert.equal(canEditExistingTableRows("manticoresearch", undefined, []), true);
+  assert.equal(canEditExistingTableRows("databend", undefined, []), true);
+  assert.equal(canEditExistingTableRows("postgres", undefined, []), true);
+  assert.equal(canEditExistingTableRows("sqlite", undefined, []), true);
+  assert.equal(canEditExistingTableRows("sqlite", undefined, ["id"]), true);
+  assert.equal(canEditExistingTableRows("duckdb", undefined, []), true);
+  assert.equal(canEditExistingTableRows("duckdb", undefined, ["id"]), true);
+  assert.equal(canEditExistingTableRows("informix", undefined, []), true);
+  assert.equal(canEditExistingTableRows("informix", undefined, ["id"]), true);
+  assert.equal(canEditExistingTableRows("tdengine", undefined, []), false);
+  assert.equal(canEditExistingTableRows("tdengine", undefined, ["ts"]), true);
+  assert.equal(canEditExistingTableRows("tdengine", undefined, [DBX_TDENGINE_TBNAME_COLUMN, "ts"]), true);
+  assert.equal(canEditExistingTableRows("postgres", undefined), true);
+});
+
+test("detects transactional Hive table properties", () => {
+  assert.equal(
+    hiveTablePropertiesIndicateTransactional({
+      columns: ["prpt_name", "prpt_value"],
+      rows: [["transactional", "true"]],
+    }),
+    true,
+  );
+  assert.equal(
+    hiveTablePropertiesIndicateTransactional({
+      columns: ["prpt_name", "prpt_value"],
+      rows: [["Table testdb.departments does not have property: transactional", null]],
+    }),
+    false,
+  );
+});
+
+test("uses elementId as Neo4j editable key when labels have no primary key", () => {
+  assert.deepEqual(editablePrimaryKeys("neo4j", [column("name"), column("role")]), [DBX_NEO4J_ELEMENT_ID_COLUMN]);
+});
+
+test("keeps TDengine existing row identity and tag columns read-only", () => {
+  assert.equal(isTdengineExistingRowReadonlyColumn("tdengine", DBX_TDENGINE_TBNAME_COLUMN, [column("ts", true)]), true);
+  assert.equal(isTdengineExistingRowReadonlyColumn("tdengine", "ts", [column("ts", true)]), true);
+  assert.equal(isTdengineExistingRowReadonlyColumn("tdengine", "seq", [column("ts", true), column("seq", true)]), true);
+  assert.equal(isTdengineExistingRowReadonlyColumn("tdengine", "location", [column("location")]), false);
+  assert.equal(isTdengineExistingRowReadonlyColumn("mysql", "ts", [column("ts", true)]), false);
+  assert.equal(isTdengineExistingRowReadonlyColumn("tdengine", "location", [{ ...column("location"), extra: "TAG", comment: "TAG" }]), true);
+});
+
+test("detects the synthetic Oracle ROWID key case", () => {
+  assert.equal(usesSyntheticRowIdKey("oracle", [DBX_ROWID_COLUMN]), true);
+  assert.equal(usesSyntheticRowIdKey("oracle", [DBX_ROWID_COLUMN.toLowerCase()]), true);
+  assert.equal(usesSyntheticRowIdKey("oracle", [DBX_ROWID_COLUMN], "VIEW"), false);
+  assert.equal(usesSyntheticRowIdKey("oracle", [DBX_ROWID_COLUMN], "MATERIALIZED_VIEW"), false);
+  assert.equal(usesSyntheticRowIdKey("postgres", [DBX_ROWID_COLUMN]), false);
+  assert.equal(usesSyntheticRowIdKey("oracle", ["ID"]), false);
+  assert.equal(usesSyntheticRowIdKey("neo4j", [DBX_NEO4J_ELEMENT_ID_COLUMN]), true);
+});
+
+test("hides only the synthetic Oracle ROWID grid column", () => {
+  assert.equal(isHiddenGridColumn("oracle", DBX_ROWID_COLUMN, [DBX_ROWID_COLUMN]), true);
+  assert.equal(isHiddenGridColumn("oracle", DBX_ROWID_COLUMN, [DBX_ROWID_COLUMN], "VIEW"), false);
+  assert.equal(isHiddenGridColumn("oracle", "ROWID", [DBX_ROWID_COLUMN]), false);
+  assert.equal(isHiddenGridColumn("mysql", DBX_ROWID_COLUMN, [DBX_ROWID_COLUMN]), false);
+  assert.equal(isHiddenGridColumn("neo4j", DBX_NEO4J_ELEMENT_ID_COLUMN, [DBX_NEO4J_ELEMENT_ID_COLUMN]), true);
+});
diff --git a/packages/app-tests/tableImport.test.ts b/packages/app-tests/tableImport.test.ts
new file mode 100644
index 0000000..4952d48
--- /dev/null
+++ b/packages/app-tests/tableImport.test.ts
@@ -0,0 +1,20 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { autoMapImportColumns, normalizeImportColumnName } from "../../apps/desktop/src/lib/table/tableImport.ts";
+
+test("normalizes import column names for matching", () => {
+  assert.equal(normalizeImportColumnName(" User ID "), "user id");
+  assert.equal(normalizeImportColumnName("user_id"), "user id");
+  assert.equal(normalizeImportColumnName("USER-ID"), "user id");
+});
+
+test("auto maps source columns to matching target columns and skips unknown columns", () => {
+  const mapping = autoMapImportColumns(["id", "Name", "created-at", "ignored"], ["user_id", "name", "created_at"]);
+
+  assert.deepEqual(mapping, {
+    id: "",
+    Name: "name",
+    "created-at": "created_at",
+    ignored: "",
+  });
+});
diff --git a/packages/app-tests/tableMetadataCache.test.ts b/packages/app-tests/tableMetadataCache.test.ts
new file mode 100644
index 0000000..d555f59
--- /dev/null
+++ b/packages/app-tests/tableMetadataCache.test.ts
@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import { beforeEach, test, vi } from "vitest";
+import type { ColumnInfo, IndexInfo } from "../../apps/desktop/src/types/database.ts";
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+beforeEach(() => {
+  vi.resetModules();
+});
+
+test("table metadata loader deduplicates equivalent in-flight requests and caches the result", async () => {
+  const columnsGate = deferred<ColumnInfo[]>();
+  const indexes: IndexInfo[] = [{ name: "users_pkey", columns: ["id"], is_unique: true, is_primary: true }];
+  const getColumns = vi.fn(() => columnsGate.promise);
+  const listIndexes = vi.fn().mockResolvedValue(indexes);
+  vi.doMock("@/lib/backend/api", () => ({ getColumns, listIndexes }));
+
+  const { clearTableMetadataCache, loadTableMetadata } = await import("../../apps/desktop/src/lib/metadata/tableMetadataCache.ts");
+  clearTableMetadataCache();
+
+  const request = {
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    tableName: "users",
+    tableType: "TABLE",
+    databaseType: "postgres",
+    driverProfile: "postgres",
+  };
+  const first = loadTableMetadata(request);
+  const second = loadTableMetadata(request);
+  await Promise.resolve();
+  assert.equal(getColumns.mock.calls.length, 1);
+
+  columnsGate.resolve([
+    {
+      name: "id",
+      data_type: "integer",
+      is_nullable: false,
+      column_default: null,
+      is_primary_key: true,
+      extra: null,
+    },
+  ]);
+
+  const [firstResult, secondResult] = await Promise.all([first, second]);
+  assert.deepEqual(firstResult.metadata.primaryKeys, ["id"]);
+  assert.equal(secondResult.metadata.columns.length, 1);
+  assert.equal(listIndexes.mock.calls.length, 1);
+
+  const cached = await loadTableMetadata(request);
+  assert.equal(cached.cacheStatus, "hit");
+  assert.equal(getColumns.mock.calls.length, 1);
+});
+
+test("table metadata invalidation keeps unrelated schemas cached", async () => {
+  const getColumns = vi.fn(
+    async (_connectionId: string, _database: string, _schema: string, table: string): Promise<ColumnInfo[]> => [
+      {
+        name: `${table}_id`,
+        data_type: "integer",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: true,
+        extra: null,
+      },
+    ],
+  );
+  const listIndexes = vi.fn(async (): Promise<IndexInfo[]> => []);
+  vi.doMock("@/lib/backend/api", () => ({ getColumns, listIndexes }));
+
+  const { clearTableMetadataCache, getCachedTableMetadata, invalidateTableMetadataCache, loadTableMetadata } = await import("../../apps/desktop/src/lib/metadata/tableMetadataCache.ts");
+  clearTableMetadataCache();
+
+  const publicRequest = {
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    tableName: "users",
+    tableType: "TABLE",
+    databaseType: "postgres",
+    driverProfile: "postgres",
+  };
+  const auditRequest = { ...publicRequest, schema: "audit", tableName: "audit_log" };
+
+  await loadTableMetadata(publicRequest);
+  await loadTableMetadata(auditRequest);
+  assert.equal(getColumns.mock.calls.length, 2);
+
+  assert.equal(invalidateTableMetadataCache({ connectionId: "conn", database: "app", schema: "public" }), 1);
+  assert.equal(getCachedTableMetadata(publicRequest), undefined);
+  assert.equal(getCachedTableMetadata(auditRequest)?.metadata.tableName, "audit_log");
+});
diff --git a/packages/app-tests/tableSqlTemplates.test.ts b/packages/app-tests/tableSqlTemplates.test.ts
new file mode 100644
index 0000000..c7fac22
--- /dev/null
+++ b/packages/app-tests/tableSqlTemplates.test.ts
@@ -0,0 +1,78 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import type { ColumnInfo } from "../../apps/desktop/src/types/database.ts";
+import { buildTableDeleteTemplate, buildTableInsertTemplate, buildTableSelectTemplate, buildTableUpdateTemplate } from "../../apps/desktop/src/lib/table/tableSqlTemplates.ts";
+
+function col(overrides: Partial<ColumnInfo> & { name: string; data_type: string }): ColumnInfo {
+  return {
+    is_nullable: true,
+    column_default: null,
+    is_primary_key: false,
+    extra: null,
+    ...overrides,
+  };
+}
+
+const columns: ColumnInfo[] = [
+  col({ name: "id", data_type: "integer", is_primary_key: true, extra: "auto_increment" }),
+  col({ name: "name", data_type: "varchar" }),
+  col({ name: "created_at", data_type: "timestamp" }),
+];
+
+test("builds SELECT template with explicit table columns", () => {
+  assert.equal(
+    buildTableSelectTemplate({
+      databaseType: "postgres",
+      schema: "public",
+      tableName: "users",
+      columns,
+    }),
+    'SELECT "id", "name", "created_at"\nFROM "public"."users";',
+  );
+});
+
+test("builds INSERT template without auto generated columns", () => {
+  assert.equal(
+    buildTableInsertTemplate({
+      databaseType: "mysql",
+      tableName: "users",
+      columns,
+    }),
+    "INSERT INTO `users` (`name`, `created_at`)\nVALUES ('name_value', CURRENT_TIMESTAMP);",
+  );
+});
+
+test("builds UPDATE template with primary key WHERE clause", () => {
+  assert.equal(
+    buildTableUpdateTemplate({
+      databaseType: "postgres",
+      schema: "public",
+      tableName: "users",
+      columns,
+    }),
+    'UPDATE "public"."users"\nSET "name" = \'name_value\',\n    "created_at" = CURRENT_TIMESTAMP\nWHERE "id" = 0;',
+  );
+});
+
+test("builds DELETE template with primary key WHERE clause", () => {
+  assert.equal(
+    buildTableDeleteTemplate({
+      databaseType: "postgres",
+      schema: "public",
+      tableName: "users",
+      columns,
+    }),
+    'DELETE FROM "public"."users"\nWHERE "id" = 0;',
+  );
+});
+
+test("builds DELETE template with TODO WHERE clause when no primary key exists", () => {
+  assert.equal(
+    buildTableDeleteTemplate({
+      databaseType: "sqlite",
+      tableName: "audit",
+      columns: [col({ name: "message", data_type: "text" })],
+    }),
+    'DELETE FROM "audit"\nWHERE /* TODO: add WHERE clause */;',
+  );
+});
diff --git a/packages/app-tests/tableStructureEditorState.test.ts b/packages/app-tests/tableStructureEditorState.test.ts
new file mode 100644
index 0000000..6f3200a
--- /dev/null
+++ b/packages/app-tests/tableStructureEditorState.test.ts
@@ -0,0 +1,502 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { test } from "vitest";
+import {
+  applyManticoreDdlColumnExtras,
+  buildStructureTargetLabel,
+  canEditManticoreColumnProperties,
+  combineDataTypeForDatabase,
+  createColumnDrafts,
+  createIndexDrafts,
+  dataTypeLengthInputValue,
+  generateIndexName,
+  generateUniqueIndexName,
+  getColumnEditorControls,
+  getDataTypeOptions,
+  isProtectedManticoreIdColumn,
+  isDamengIdentityCompatibleDataType,
+  isMysqlEnumDataType,
+  isSqlServerIdentityCompatibleDataType,
+  mysqlEnumDataType,
+  normalizeDataTypeParams,
+  parseExtraToColumnExtra,
+  rehydrateColumnDraftsFromMetadata,
+  toColumnNames,
+} from "../../apps/desktop/src/lib/table/tableStructureEditorState.ts";
+import { firstStructureMetadataTab, isStructureMetadataTabSupported } from "../../apps/desktop/src/lib/table/tableMetadataCapabilities.ts";
+import type { ColumnInfo, IndexInfo, TableInfoTab } from "../../apps/desktop/src/types/database.ts";
+
+const columns: ColumnInfo[] = [
+  {
+    name: "id",
+    data_type: "bigint",
+    is_nullable: false,
+    column_default: null,
+    is_primary_key: true,
+    extra: "auto_increment",
+    comment: "identifier",
+  },
+  {
+    name: "name",
+    data_type: "varchar(120)",
+    is_nullable: true,
+    column_default: "'guest'",
+    is_primary_key: false,
+    extra: null,
+    comment: null,
+  },
+];
+
+const indexes: IndexInfo[] = [
+  { name: "PRIMARY", columns: ["id"], is_unique: true, is_primary: true },
+  { name: "idx_name", columns: ["name"], is_unique: false, is_primary: false },
+];
+
+test("creates editable column drafts from column metadata", () => {
+  const drafts = createColumnDrafts(columns, "mysql");
+
+  assert.deepEqual(
+    drafts.map((draft) => ({
+      id: draft.id,
+      name: draft.name,
+      dataType: draft.dataType,
+      isNullable: draft.isNullable,
+      defaultValue: draft.defaultValue,
+      comment: draft.comment,
+      isPrimaryKey: draft.isPrimaryKey,
+      extra: draft.extra,
+      originalPosition: draft.originalPosition,
+      markedForDrop: draft.markedForDrop,
+      originalName: draft.original?.name,
+    })),
+    [
+      {
+        id: "existing:id",
+        name: "id",
+        dataType: "bigint",
+        isNullable: false,
+        defaultValue: "",
+        comment: "identifier",
+        isPrimaryKey: true,
+        extra: { autoIncrement: true },
+        originalPosition: 0,
+        markedForDrop: false,
+        originalName: "id",
+      },
+      {
+        id: "existing:name",
+        name: "name",
+        dataType: "varchar(120)",
+        isNullable: true,
+        defaultValue: "'guest'",
+        comment: "",
+        isPrimaryKey: false,
+        extra: {},
+        originalPosition: 1,
+        markedForDrop: false,
+        originalName: "name",
+      },
+    ],
+  );
+});
+
+test("rehydrates restored existing column drafts from live metadata", () => {
+  const drafts = rehydrateColumnDraftsFromMetadata(
+    [
+      {
+        id: "existing:id",
+        name: "id",
+        dataType: "varchar(10)",
+        isNullable: true,
+        defaultValue: "",
+        comment: "",
+        isPrimaryKey: false,
+        extra: {},
+        markedForDrop: false,
+      },
+      {
+        id: "existing:data",
+        name: "data",
+        dataType: "timestamp",
+        isNullable: true,
+        defaultValue: "",
+        comment: "",
+        isPrimaryKey: false,
+        extra: {},
+        markedForDrop: false,
+      },
+      {
+        id: "new:note",
+        name: "note",
+        dataType: "varchar2(100)",
+        isNullable: true,
+        defaultValue: "",
+        comment: "",
+        isPrimaryKey: false,
+        extra: {},
+        markedForDrop: false,
+      },
+    ],
+    [
+      {
+        name: "id",
+        data_type: "varchar(10)",
+        is_nullable: true,
+        column_default: null,
+        is_primary_key: false,
+        extra: null,
+        comment: null,
+      },
+      {
+        name: "data",
+        data_type: "timestamp",
+        is_nullable: true,
+        column_default: null,
+        is_primary_key: false,
+        extra: null,
+        comment: null,
+      },
+    ],
+    "oracle",
+  );
+
+  assert.equal(drafts[0].original?.name, "id");
+  assert.equal(drafts[0].originalPosition, 0);
+  assert.equal(drafts[1].original?.name, "data");
+  assert.equal(drafts[1].originalPosition, 1);
+  assert.equal(drafts[2].original, undefined);
+});
+
+test("normalizes PostgreSQL string default casts in editable column drafts", () => {
+  const drafts = createColumnDrafts(
+    [
+      {
+        name: "category",
+        data_type: "character varying",
+        is_nullable: true,
+        column_default: "''::character varying",
+        is_primary_key: false,
+        extra: null,
+        comment: null,
+      },
+      {
+        name: "status",
+        data_type: "user_status",
+        is_nullable: true,
+        column_default: "'active'::public.user_status",
+        is_primary_key: false,
+        extra: null,
+        comment: null,
+      },
+      {
+        name: "stock",
+        data_type: "integer",
+        is_nullable: true,
+        column_default: "0",
+        is_primary_key: false,
+        extra: null,
+        comment: null,
+      },
+    ],
+    "postgres",
+  );
+
+  assert.equal(drafts[0].defaultValue, "''");
+  assert.equal(drafts[0].original?.column_default, "''");
+  assert.equal(drafts[1].defaultValue, "'active'::public.user_status");
+  assert.equal(drafts[1].original?.column_default, "'active'::public.user_status");
+  assert.equal(drafts[2].defaultValue, "0");
+  assert.equal(drafts[2].original?.column_default, "0");
+});
+
+test("applies manticore column properties from ddl", () => {
+  const manticoreColumns: ColumnInfo[] = [
+    { name: "name", data_type: "string", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
+    { name: "code", data_type: "string", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
+    { name: "resource", data_type: "json", is_nullable: true, column_default: null, is_primary_key: false, extra: null, comment: null },
+  ];
+  const ddl = `CREATE TABLE materials (
+name string indexed attribute,
+code string attribute,
+resource json secondary_index='1'
+)`;
+
+  const drafts = createColumnDrafts(applyManticoreDdlColumnExtras(manticoreColumns, ddl), "manticoresearch");
+
+  assert.deepEqual(
+    drafts.map((draft) => ({ name: draft.name, dataType: draft.dataType, extra: draft.extra })),
+    [
+      { name: "name", dataType: "string", extra: { manticoreIndexed: true, manticoreAttribute: true } },
+      { name: "code", dataType: "string", extra: { manticoreAttribute: true } },
+      { name: "resource", dataType: "json", extra: { manticoreSecondaryIndex: true } },
+    ],
+  );
+});
+
+test("parses MySQL extra string to ColumnExtra", () => {
+  assert.deepEqual(parseExtraToColumnExtra("auto_increment", "mysql"), { autoIncrement: true });
+  assert.deepEqual(parseExtraToColumnExtra("on update CURRENT_TIMESTAMP", "mysql"), {
+    onUpdateCurrentTimestamp: true,
+  });
+  assert.deepEqual(parseExtraToColumnExtra("auto_increment on update current_timestamp", "mysql"), {
+    autoIncrement: true,
+    onUpdateCurrentTimestamp: true,
+  });
+  assert.deepEqual(parseExtraToColumnExtra(null, "mysql"), {});
+  assert.deepEqual(parseExtraToColumnExtra("", "mysql"), {});
+});
+
+test("parses PostgreSQL extra string to ColumnExtra", () => {
+  assert.deepEqual(parseExtraToColumnExtra("generated by default as identity", "postgres"), {
+    identity: { generation: "BY DEFAULT" },
+  });
+  assert.deepEqual(parseExtraToColumnExtra("generated by default as identity", "opengauss"), {
+    identity: { generation: "BY DEFAULT" },
+  });
+  assert.deepEqual(parseExtraToColumnExtra("generated by default as identity", "gaussdb"), {
+    identity: { generation: "BY DEFAULT" },
+  });
+  assert.deepEqual(parseExtraToColumnExtra("GENERATED ALWAYS AS IDENTITY", "postgres"), {
+    identity: { generation: "ALWAYS" },
+  });
+  assert.deepEqual(parseExtraToColumnExtra("generated always as identity (start with 10 increment by 2)", "postgres"), {
+    identity: { generation: "ALWAYS", seed: 10, increment: 2 },
+  });
+});
+
+test("parses SQL Server identity extra string to ColumnExtra", () => {
+  assert.deepEqual(parseExtraToColumnExtra("identity(1,1)", "sqlserver"), {
+    autoIncrement: true,
+    identity: { seed: 1, increment: 1 },
+  });
+  assert.deepEqual(parseExtraToColumnExtra("IDENTITY(100, 5)", "sqlserver"), {
+    autoIncrement: true,
+    identity: { seed: 100, increment: 5 },
+  });
+});
+
+test("parses Dameng identity extra string to ColumnExtra", () => {
+  assert.deepEqual(parseExtraToColumnExtra("identity", "dameng"), {
+    autoIncrement: true,
+  });
+  assert.deepEqual(parseExtraToColumnExtra("IDENTITY(100, 5)", "dameng"), {
+    autoIncrement: true,
+    identity: { seed: 100, increment: 5 },
+  });
+});
+
+test("recognizes SQL Server identity-compatible data types", () => {
+  assert.equal(isSqlServerIdentityCompatibleDataType("tinyint"), true);
+  assert.equal(isSqlServerIdentityCompatibleDataType("smallint"), true);
+  assert.equal(isSqlServerIdentityCompatibleDataType("int"), true);
+  assert.equal(isSqlServerIdentityCompatibleDataType("integer"), true);
+  assert.equal(isSqlServerIdentityCompatibleDataType("bigint"), true);
+  assert.equal(isSqlServerIdentityCompatibleDataType("decimal(18,0)"), true);
+  assert.equal(isSqlServerIdentityCompatibleDataType("numeric(10)"), true);
+  assert.equal(isSqlServerIdentityCompatibleDataType("varchar(255)"), false);
+  assert.equal(isSqlServerIdentityCompatibleDataType("numeric(18,2)"), false);
+});
+
+test("recognizes Dameng identity-compatible data types", () => {
+  assert.equal(isDamengIdentityCompatibleDataType("int"), true);
+  assert.equal(isDamengIdentityCompatibleDataType("integer"), true);
+  assert.equal(isDamengIdentityCompatibleDataType("bigint"), true);
+  assert.equal(isDamengIdentityCompatibleDataType("number(18, 0)"), true);
+  assert.equal(isDamengIdentityCompatibleDataType("decimal(10)"), true);
+  assert.equal(isDamengIdentityCompatibleDataType("varchar(255)"), false);
+  assert.equal(isDamengIdentityCompatibleDataType("number(18, 2)"), false);
+});
+
+test("does not add MySQL-style display widths to SQL Server integer types", () => {
+  assert.equal(combineDataTypeForDatabase("sqlserver", "int", "11"), "int");
+  assert.equal(combineDataTypeForDatabase("sqlserver", "integer", "11"), "integer");
+  assert.equal(combineDataTypeForDatabase("sqlserver", "bigint", "20"), "bigint");
+  assert.equal(dataTypeLengthInputValue("sqlserver", "int(11)"), "");
+  assert.equal(combineDataTypeForDatabase("sqlserver", "decimal", "10,0"), "decimal(10,0)");
+  assert.equal(combineDataTypeForDatabase("sqlserver", "varchar", "255"), "varchar(255)");
+  assert.equal(combineDataTypeForDatabase("sqlserver", "float", "53"), "float(53)");
+});
+
+test("hydrates and serializes MySQL enum values for structure editing", () => {
+  const [draft] = createColumnDrafts(
+    [
+      {
+        name: "status",
+        data_type: "enum",
+        enum_values: ["", "pending", "it's", "path\\name"],
+        is_nullable: false,
+        column_default: "'pending'",
+        is_primary_key: false,
+        extra: null,
+      },
+    ],
+    "mysql",
+  );
+
+  assert.deepEqual(draft?.enumValues, ["", "pending", "it's", "path\\name"]);
+  assert.equal(draft?.dataType, "enum('','pending','it''s','path\\\\name')");
+  assert.equal(draft?.original?.data_type, draft?.dataType);
+  assert.equal(isMysqlEnumDataType("mysql", draft?.dataType ?? ""), true);
+  assert.equal(mysqlEnumDataType(["a'b", "a\\b"]), "enum('a''b','a\\\\b')");
+});
+
+test("parses Manticore Search text properties to ColumnExtra", () => {
+  assert.deepEqual(parseExtraToColumnExtra("stored indexed", "manticoresearch"), {
+    manticoreStored: true,
+    manticoreIndexed: true,
+  });
+  assert.deepEqual(parseExtraToColumnExtra("attribute indexed", "manticoresearch"), {
+    manticoreAttribute: true,
+    manticoreIndexed: true,
+  });
+  assert.deepEqual(parseExtraToColumnExtra("secondary_index='1'", "manticoresearch"), {
+    manticoreSecondaryIndex: true,
+  });
+});
+
+test("creates editable index drafts and splits pasted column lists", () => {
+  const drafts = createIndexDrafts(indexes);
+
+  assert.deepEqual(
+    drafts.map((draft) => ({
+      id: draft.id,
+      name: draft.name,
+      columns: draft.columns,
+      isUnique: draft.isUnique,
+      isPrimary: draft.isPrimary,
+      originalName: draft.original?.name,
+    })),
+    [
+      {
+        id: "existing:PRIMARY",
+        name: "PRIMARY",
+        columns: ["id"],
+        isUnique: true,
+        isPrimary: true,
+        originalName: "PRIMARY",
+      },
+      {
+        id: "existing:idx_name",
+        name: "idx_name",
+        columns: ["name"],
+        isUnique: false,
+        isPrimary: false,
+        originalName: "idx_name",
+      },
+    ],
+  );
+  assert.equal(toColumnNames(["id", "name"]), "id, name");
+});
+
+test("generates conventional index names from table and columns", () => {
+  assert.equal(generateIndexName("A", ["B"]), "A_B_IDX");
+  assert.equal(generateIndexName("order item", ["customer-id", "created_at"]), "ORDER_ITEM_CUSTOMER_ID_CREATED_AT_IDX");
+  assert.equal(generateIndexName("users", ["email"], 12), "USERS_EM_IDX");
+});
+
+test("generates unique index names when automatic name already exists", () => {
+  assert.equal(generateUniqueIndexName("users", ["email"], ["USERS_EMAIL_IDX"]), "USERS_EMAIL_IDX_2");
+  assert.equal(generateUniqueIndexName("users", ["email"], ["users_email_idx", "USERS_EMAIL_IDX_2"]), "USERS_EMAIL_IDX_3");
+});
+
+test("structure editor target label omits duplicate database and schema", () => {
+  assert.equal(buildStructureTargetLabel("online-clickhouse", "testdb", "testdb", "users"), "online-clickhouse / testdb / users");
+  assert.equal(buildStructureTargetLabel("online-postgres", "app", "public", "users"), "online-postgres / app / public / users");
+});
+
+test("normalizes temporal precision when combining data types", () => {
+  assert.equal(combineDataTypeForDatabase("mysql", "timestamp", "255"), "timestamp");
+  assert.equal(combineDataTypeForDatabase("mysql", "timestamp", "3"), "timestamp(3)");
+  assert.equal(combineDataTypeForDatabase("mysql", "varchar", "255"), "varchar(255)");
+  assert.equal(normalizeDataTypeParams("oracle", "timestamp", "9"), "9");
+  assert.equal(normalizeDataTypeParams("oracle", "timestamp", "10"), "");
+});
+
+test("returns data type options for compatible table structure editors", () => {
+  assert.deepEqual(getDataTypeOptions("dameng"), getDataTypeOptions("oracle"));
+  assert.deepEqual(getDataTypeOptions("gaussdb"), getDataTypeOptions("postgres"));
+  assert.deepEqual(getDataTypeOptions("doris"), getDataTypeOptions("mysql"));
+  assert.equal(getDataTypeOptions("dameng").includes("varchar2"), true);
+  assert.equal(getDataTypeOptions("sqlserver").includes("nvarchar"), true);
+});
+
+test("returns Xugu data type options", () => {
+  const options = getDataTypeOptions("xugu");
+  assert.equal(options.includes("INTEGER"), true);
+  assert.equal(options.includes("VARCHAR"), true);
+  assert.equal(options.includes("NUMERIC"), true);
+  assert.equal(options.includes("INT"), true);
+});
+
+test("returns Manticore Search data type options", () => {
+  assert.deepEqual(getDataTypeOptions("manticoresearch"), ["text", "string", "int", "bit", "bigint", "bool", "timestamp", "float", "json", "float_vector", "multi", "mva"]);
+});
+
+test("returns Manticore Search column editor controls", () => {
+  assert.deepEqual(getColumnEditorControls("manticoresearch"), {
+    length: true,
+    nullable: false,
+    primaryKey: false,
+    defaultValue: false,
+    comment: false,
+  });
+  assert.equal(getColumnEditorControls("mysql").nullable, true);
+});
+
+test("protects Manticore Search id column from destructive structure edits", () => {
+  assert.equal(isProtectedManticoreIdColumn("manticoresearch", "id"), true);
+  assert.equal(isProtectedManticoreIdColumn("manticoresearch", "ID"), true);
+  assert.equal(isProtectedManticoreIdColumn("manticoresearch", "name"), false);
+  assert.equal(isProtectedManticoreIdColumn("mysql", "id"), false);
+});
+
+test("allows Manticore Search column properties only before the column exists", () => {
+  assert.equal(canEditManticoreColumnProperties("manticoresearch", false), true);
+  assert.equal(canEditManticoreColumnProperties("manticoresearch", true), false);
+  assert.equal(canEditManticoreColumnProperties("mysql", false), false);
+});
+
+const fullCapabilities = { columns: true, indexes: true, foreignKeys: true, triggers: true, ddl: true };
+const noDdlCapabilities = { columns: true, indexes: true, foreignKeys: true, triggers: true, ddl: false };
+const ddlOnlyCapabilities = { columns: false, indexes: false, foreignKeys: false, triggers: false, ddl: true };
+
+test("defaults to columns tab for edit mode with full capabilities", () => {
+  assert.equal(firstStructureMetadataTab(fullCapabilities, false), "columns");
+});
+
+test("defaults to columns tab for create mode", () => {
+  assert.equal(firstStructureMetadataTab(fullCapabilities, true), "columns");
+});
+
+test("falls back to columns tab when DDL is not available in edit mode", () => {
+  assert.equal(firstStructureMetadataTab(noDdlCapabilities, false), "columns");
+});
+
+test("falls back to DDL when no editable metadata tab is available", () => {
+  assert.equal(firstStructureMetadataTab(ddlOnlyCapabilities, false), "ddl");
+});
+
+test("preserves a restored structure draft tab without an explicit initial tab", () => {
+  const source = readFileSync("apps/desktop/src/components/structure/TableStructureEditor.vue", "utf8");
+  const restoredDraftBlock = source.match(/if \(props\.draft\?\.initialized\) \{[\s\S]*?\n  \} else if/);
+
+  assert.ok(restoredDraftBlock);
+  assert.match(restoredDraftBlock[0], /restoreDraft\(props\.draft\);[\s\S]*applyInitialStructureTab\(false\);/);
+});
+
+test("supports DDL tab in edit mode", () => {
+  assert.equal(isStructureMetadataTabSupported("ddl", fullCapabilities, false), true);
+});
+
+test("does not support DDL tab in create mode", () => {
+  assert.equal(isStructureMetadataTabSupported("ddl", fullCapabilities, true), false);
+});
+
+test("does not support DDL tab when capability is disabled", () => {
+  assert.equal(isStructureMetadataTabSupported("ddl", noDdlCapabilities, false), false);
+});
+
+test("supports columns tab in both modes", () => {
+  assert.equal(isStructureMetadataTabSupported("columns", fullCapabilities, false), true);
+  assert.equal(isStructureMetadataTabSupported("columns", fullCapabilities, true), true);
+});
diff --git a/packages/app-tests/tableTree.test.ts b/packages/app-tests/tableTree.test.ts
new file mode 100644
index 0000000..09853af
--- /dev/null
+++ b/packages/app-tests/tableTree.test.ts
@@ -0,0 +1,346 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { buildGroupedObjectTreeNodes, buildObjectGroupPlaceholderNodes, buildSimpleObjectTreeNodes, buildTableTreeNodes, filterSimpleSidebarSupplementalObjects, mergeTableInfosIntoObjects, mergeTableTreePageChildren } from "../../apps/desktop/src/lib/table/tableTree.ts";
+import type { ObjectInfo, TableInfo, TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+function table(name: string, parent?: string): TableInfo {
+  return {
+    name,
+    table_type: "BASE TABLE",
+    comment: null,
+    parent_schema: parent ? "public" : null,
+    parent_name: parent ?? null,
+  };
+}
+
+function object(name: string, parent?: string): ObjectInfo {
+  return {
+    name,
+    object_type: "TABLE",
+    schema: "public",
+    comment: null,
+    created_at: null,
+    updated_at: null,
+    parent_schema: parent ? "public" : null,
+    parent_name: parent ?? null,
+  };
+}
+
+function partitionGroup(node: TreeNode): TreeNode | undefined {
+  return node.children?.find((child) => child.type === "group-partitions");
+}
+
+test("buildTableTreeNodes nests multi-level table partitions", () => {
+  const nodes = buildTableTreeNodes({
+    nodeId: "conn:app:public",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    tables: [table("events"), table("events_2026", "events"), table("events_2026_05", "events_2026"), table("users")],
+  });
+
+  assert.deepEqual(
+    nodes.map((node) => node.label),
+    ["events", "users"],
+  );
+  assert.equal(nodes[0].id, "conn:app:public:events");
+
+  const events = nodes[0];
+  const firstLevel = partitionGroup(events);
+  assert.equal(firstLevel?.label, "tree.partitions");
+  assert.deepEqual(
+    firstLevel?.children?.map((node) => node.label),
+    ["events_2026"],
+  );
+
+  const secondLevel = partitionGroup(firstLevel!.children![0]);
+  assert.deepEqual(
+    secondLevel?.children?.map((node) => node.label),
+    ["events_2026_05"],
+  );
+});
+
+test("buildTableTreeNodes keeps partitions visible when their parent is not loaded", () => {
+  const nodes = buildTableTreeNodes({
+    nodeId: "conn:app:public",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    tables: [table("events_2026", "events")],
+  });
+
+  assert.deepEqual(
+    nodes.map((node) => node.label),
+    ["events_2026"],
+  );
+});
+
+test("mergeTableTreePageChildren attaches later page partitions to loaded parents", () => {
+  const firstPage = buildTableTreeNodes({
+    nodeId: "conn:app:public",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    tables: [table("events"), table("events_region_0", "events")],
+  });
+  const secondPage = buildTableTreeNodes({
+    nodeId: "conn:app:public",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    tables: [table("events_region_0_2026_01", "events_region_0")],
+  });
+
+  const merged = mergeTableTreePageChildren(firstPage, secondPage, "conn", "app");
+  assert.deepEqual(
+    merged.map((node) => node.label),
+    ["events"],
+  );
+
+  const regionPartition = partitionGroup(merged[0])?.children?.[0];
+  assert.equal(regionPartition?.label, "events_region_0");
+  assert.deepEqual(
+    partitionGroup(regionPartition!)?.children?.map((node) => node.label),
+    ["events_region_0_2026_01"],
+  );
+});
+
+test("buildTableTreeNodes keeps sidebar tables in natural name order", () => {
+  const nodes = buildTableTreeNodes({
+    nodeId: "conn:app:public",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    tables: [table("chat_staff"), table("chat_staff_his"), table("staff"), table("staff_his")],
+  });
+
+  assert.deepEqual(
+    nodes.map((node) => node.label),
+    ["chat_staff", "chat_staff_his", "staff", "staff_his"],
+  );
+});
+
+test("buildTableTreeNodes does not relocate prefixed business tables by suffix", () => {
+  const nodes = buildTableTreeNodes({
+    nodeId: "conn:app",
+    connectionId: "conn",
+    database: "app",
+    tables: [table("CurrentStock"), table("YonSuite_CurrentStock"), table("YonSuite_LocationStock")],
+  });
+
+  assert.deepEqual(
+    nodes.map((node) => node.label),
+    ["CurrentStock", "YonSuite_CurrentStock", "YonSuite_LocationStock"],
+  );
+});
+
+test("buildGroupedObjectTreeNodes nests partitions inside the tables group", () => {
+  const groups = buildGroupedObjectTreeNodes({
+    nodeId: "conn:app:public",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    objects: [object("events"), object("events_2026", "events"), object("events_2026_05", "events_2026")],
+  });
+
+  const tableGroup = groups.find((node) => node.type === "group-tables");
+  assert.equal(tableGroup?.objectCount, 3);
+  assert.deepEqual(
+    tableGroup?.children?.map((node) => node.label),
+    ["events"],
+  );
+  assert.equal(tableGroup?.children?.[0]?.id, "conn:app:public:__tables:public:events");
+  assert.deepEqual(
+    partitionGroup(tableGroup!.children![0])?.children?.map((node) => node.label),
+    ["events_2026"],
+  );
+});
+
+test("buildGroupedObjectTreeNodes applies natural name sorting inside object groups", () => {
+  const groups = buildGroupedObjectTreeNodes({
+    nodeId: "conn:app:public",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    objects: [object("chat_staff"), object("chat_staff_his"), object("staff"), object("staff_his")],
+  });
+
+  const tableGroup = groups.find((node) => node.type === "group-tables");
+  assert.deepEqual(
+    tableGroup?.children?.map((node) => node.label),
+    ["chat_staff", "chat_staff_his", "staff", "staff_his"],
+  );
+});
+
+test("buildGroupedObjectTreeNodes groups Oracle packages and package bodies", () => {
+  const groups = buildGroupedObjectTreeNodes({
+    nodeId: "conn:app:HR",
+    connectionId: "conn",
+    database: "app",
+    schema: "HR",
+    objects: [
+      { name: "PAYROLL", object_type: "PACKAGE", schema: "HR" },
+      { name: "PAYROLL", object_type: "PACKAGE_BODY", schema: "HR" },
+    ],
+  });
+
+  const packageGroup = groups.find((node) => node.type === "group-packages");
+  assert.equal(packageGroup?.label, "tree.packages");
+  assert.deepEqual(
+    packageGroup?.children?.map((node) => ({ label: node.label, type: node.type, id: node.id })),
+    [
+      { label: "PAYROLL", type: "package", id: "conn:app:HR:__packages:HR:PAYROLL:PACKAGE" },
+      { label: "PAYROLL", type: "package-body", id: "conn:app:HR:__packages:HR:PAYROLL:PACKAGE_BODY" },
+    ],
+  );
+});
+
+test("buildGroupedObjectTreeNodes groups materialized views separately from views", () => {
+  const groups = buildGroupedObjectTreeNodes({
+    nodeId: "conn:app:APP",
+    connectionId: "conn",
+    database: "app",
+    schema: "APP",
+    objects: [
+      { name: "ACTIVE_USERS", object_type: "VIEW", schema: "APP" },
+      { name: "USER_SUMMARY_MV", object_type: "MATERIALIZED_VIEW", schema: "APP" },
+    ],
+  });
+
+  const viewGroup = groups.find((node) => node.type === "group-views");
+  const materializedViewGroup = groups.find((node) => node.type === "group-materialized-views");
+  assert.deepEqual(
+    viewGroup?.children?.map((node) => ({ label: node.label, type: node.type })),
+    [{ label: "ACTIVE_USERS", type: "view" }],
+  );
+  assert.deepEqual(
+    materializedViewGroup?.children?.map((node) => ({ label: node.label, type: node.type })),
+    [{ label: "USER_SUMMARY_MV", type: "materialized_view" }],
+  );
+});
+
+test("buildObjectGroupPlaceholderNodes creates capability-driven lazy sidebar groups", () => {
+  const groups = buildObjectGroupPlaceholderNodes({
+    nodeId: "conn:app:HR",
+    connectionId: "conn",
+    database: "app",
+    schema: "HR",
+    objectTypes: ["TABLE", "VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE"],
+  });
+
+  assert.deepEqual(
+    groups.map((node) => ({ label: node.label, type: node.type, count: node.objectCount, children: node.children })),
+    [
+      { label: "tree.tables", type: "group-tables", count: undefined, children: [] },
+      { label: "tree.views", type: "group-views", count: undefined, children: [] },
+      { label: "tree.procedures", type: "group-procedures", count: undefined, children: [] },
+      { label: "tree.functions", type: "group-functions", count: undefined, children: [] },
+      { label: "tree.sequences", type: "group-sequences", count: undefined, children: [] },
+    ],
+  );
+});
+
+test("buildSimpleObjectTreeNodes keeps routines, sequences, and packages visible in flat sidebar mode", () => {
+  const nodes = buildSimpleObjectTreeNodes({
+    nodeId: "conn:app:HR",
+    connectionId: "conn",
+    database: "app",
+    schema: "HR",
+    objects: [
+      { name: "ORDERS", object_type: "TABLE", schema: "HR" },
+      { name: "ACTIVE_ORDERS", object_type: "VIEW", schema: "HR" },
+      { name: "REFRESH_STATS", object_type: "PROCEDURE", schema: "HR" },
+      { name: "TOTAL_DUE", object_type: "FUNCTION", schema: "HR" },
+      { name: "ORDER_ID_SEQ", object_type: "SEQUENCE", schema: "HR" },
+      { name: "PAYROLL", object_type: "PACKAGE", schema: "HR" },
+      { name: "PAYROLL", object_type: "PACKAGE_BODY", schema: "HR" },
+    ],
+  });
+
+  assert.deepEqual(
+    nodes.map((node) => ({ label: node.label, type: node.type })),
+    [
+      { label: "ORDERS", type: "table" },
+      { label: "ACTIVE_ORDERS", type: "view" },
+      { label: "ORDER_ID_SEQ", type: "sequence" },
+      { label: "PAYROLL", type: "package" },
+      { label: "PAYROLL", type: "package-body" },
+      { label: "REFRESH_STATS", type: "procedure" },
+      { label: "TOTAL_DUE", type: "function" },
+    ],
+  );
+});
+
+test("mergeTableInfosIntoObjects restores views missing from object metadata", () => {
+  const merged = mergeTableInfosIntoObjects(
+    [object("orders")],
+    [
+      table("orders"),
+      {
+        name: "active_orders",
+        table_type: "VIEW",
+        comment: "current orders",
+        parent_schema: null,
+        parent_name: null,
+      },
+    ],
+    "public",
+  );
+
+  assert.deepEqual(
+    merged.map((item) => ({ name: item.name, type: item.object_type, schema: item.schema, comment: item.comment })),
+    [
+      { name: "orders", type: "TABLE", schema: "public", comment: null },
+      { name: "active_orders", type: "VIEW", schema: "public", comment: "current orders" },
+    ],
+  );
+});
+
+test("filterSimpleSidebarSupplementalObjects leaves paged tables and views to listTables", () => {
+  const supplemental = filterSimpleSidebarSupplementalObjects([
+    { name: "orders", object_type: "TABLE", schema: "public" },
+    { name: "active_orders", object_type: "VIEW", schema: "public" },
+    { name: "order_summary", object_type: "MATERIALIZED VIEW", schema: "public" },
+    { name: "refresh_stats", object_type: "PROCEDURE", schema: "public" },
+    { name: "total_due", object_type: "FUNCTION", schema: "public" },
+  ]);
+  const nodes = buildSimpleObjectTreeNodes({
+    nodeId: "conn:app:public",
+    connectionId: "conn",
+    database: "app",
+    schema: "public",
+    objects: mergeTableInfosIntoObjects(supplemental, [table("orders")], "public"),
+  });
+
+  assert.deepEqual(
+    nodes.map((node) => ({ label: node.label, type: node.type })),
+    [
+      { label: "orders", type: "table" },
+      { label: "refresh_stats", type: "procedure" },
+      { label: "total_due", type: "function" },
+    ],
+  );
+});
+
+test("mergeTableInfosIntoObjects dedupes MySQL tables when object metadata carries database as schema", () => {
+  const merged = mergeTableInfosIntoObjects(
+    [
+      {
+        name: "orders",
+        object_type: "TABLE",
+        schema: "app",
+        comment: null,
+        created_at: null,
+        updated_at: null,
+        parent_schema: null,
+        parent_name: null,
+      },
+    ],
+    [table("orders")],
+  );
+
+  assert.deepEqual(
+    merged.map((item) => ({ name: item.name, type: item.object_type, schema: item.schema })),
+    [{ name: "orders", type: "TABLE", schema: "app" }],
+  );
+});
diff --git a/packages/app-tests/transferProgress.test.ts b/packages/app-tests/transferProgress.test.ts
new file mode 100644
index 0000000..d5bbf99
--- /dev/null
+++ b/packages/app-tests/transferProgress.test.ts
@@ -0,0 +1,12 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+
+const { isTerminalTransferProgress } = await import("../../apps/desktop/src/lib/backend/transferProgress.ts");
+
+test("treats only terminal transfer progress as the end of a transfer stream", () => {
+  assert.equal(isTerminalTransferProgress({ status: "error", terminal: false }), false);
+  assert.equal(isTerminalTransferProgress({ status: "error", terminal: true }), true);
+  assert.equal(isTerminalTransferProgress({ status: "done", terminal: false }), true);
+  assert.equal(isTerminalTransferProgress({ status: "cancelled", terminal: false }), true);
+  assert.equal(isTerminalTransferProgress({ status: "running", terminal: false }), false);
+});
diff --git a/packages/app-tests/transferProgressState.test.ts b/packages/app-tests/transferProgressState.test.ts
new file mode 100644
index 0000000..98017b2
--- /dev/null
+++ b/packages/app-tests/transferProgressState.test.ts
@@ -0,0 +1,38 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { isTransferRunActive, nextTransferTerminalState, shouldKeepTransferDraftOnOpen, shouldResetTransferDialogOnOpen } from "../../apps/desktop/src/lib/app/transferProgressState.ts";
+
+test("marks transfer as failed when a table progress event reports error", () => {
+  const state = nextTransferTerminalState({ done: false, cancelled: false, error: false }, { status: "error" });
+
+  assert.deepEqual(state, { done: false, cancelled: false, error: true });
+});
+
+test("keeps terminal flags for done and cancelled progress events", () => {
+  assert.deepEqual(nextTransferTerminalState({ done: false, cancelled: false, error: false }, { status: "done" }), { done: true, cancelled: false, error: false });
+  assert.deepEqual(nextTransferTerminalState({ done: false, cancelled: false, error: false }, { status: "cancelled" }), { done: false, cancelled: true, error: false });
+});
+
+test("keeps transfer failed after a later done event", () => {
+  const afterError = nextTransferTerminalState({ done: false, cancelled: false, error: false }, { status: "error" });
+
+  assert.deepEqual(nextTransferTerminalState(afterError, { status: "done" }), {
+    done: true,
+    cancelled: false,
+    error: true,
+  });
+});
+
+test("keeps running transfer dialog state but resets terminal result on reopen", () => {
+  assert.equal(isTransferRunActive({ transferring: true, done: false, cancelled: false, error: false }), true);
+  assert.equal(shouldResetTransferDialogOnOpen({ transferring: true, done: false, cancelled: false, error: false }), false);
+  assert.equal(shouldResetTransferDialogOnOpen({ transferring: true, done: false, cancelled: false, error: true }), true);
+  assert.equal(shouldResetTransferDialogOnOpen({ transferring: true, done: true, cancelled: false, error: false }), true);
+  assert.equal(shouldResetTransferDialogOnOpen({ transferring: true, done: false, cancelled: true, error: false }), true);
+});
+
+test("keeps editable transfer draft across repeated dialog opens until user starts a new task", () => {
+  assert.equal(shouldKeepTransferDraftOnOpen(true, { transferring: false, done: false, cancelled: false, error: false }), true);
+  assert.equal(shouldKeepTransferDraftOnOpen(false, { transferring: true, done: false, cancelled: false, error: true }), true);
+  assert.equal(shouldKeepTransferDraftOnOpen(false, { transferring: false, done: false, cancelled: false, error: false }), false);
+});
diff --git a/packages/app-tests/treeNodeClick.test.ts b/packages/app-tests/treeNodeClick.test.ts
new file mode 100644
index 0000000..9bd4ee4
--- /dev/null
+++ b/packages/app-tests/treeNodeClick.test.ts
@@ -0,0 +1,185 @@
+import { test } from "vitest";
+import assert from "node:assert/strict";
+import { copyNameForTreeNode, isDocumentBrowserTreeNode, objectSourceKindForTreeNode, shouldRunTreeNodeRowAction, sidebarSelectionCopyAction, treeNodeRowAction, treeNodeRowDoubleClickAction } from "../../apps/desktop/src/lib/sidebar/treeNodeClick.ts";
+
+test("table and view rows open data without toggling structure groups", () => {
+  assert.equal(treeNodeRowAction("table", true), "open-data");
+  assert.equal(treeNodeRowAction("view", true), "open-data");
+});
+
+test("double click navigation mode selects rows on single click", () => {
+  assert.equal(treeNodeRowAction("table", true, "double"), "none");
+  assert.equal(treeNodeRowAction("view", true, "double"), "none");
+  assert.equal(treeNodeRowAction("procedure", false, "double"), "none");
+  assert.equal(treeNodeRowAction("saved-sql-file", false, "double"), "none");
+});
+
+test("double click navigation mode opens actionable rows on double click", () => {
+  assert.equal(treeNodeRowDoubleClickAction("table", true, "double"), "open-data");
+  assert.equal(treeNodeRowDoubleClickAction("view", true, "double"), "open-data");
+  assert.equal(treeNodeRowDoubleClickAction("procedure", false, "double"), "open-source");
+  assert.equal(treeNodeRowDoubleClickAction("saved-sql-file", false, "double"), "open-saved-sql");
+});
+
+test("double click navigation mode toggles expandable rows on double click", () => {
+  assert.equal(treeNodeRowDoubleClickAction("connection", false, "double", true), "toggle");
+  assert.equal(treeNodeRowDoubleClickAction("group-columns", false, "double", true), "toggle");
+  assert.equal(treeNodeRowDoubleClickAction("redis-db", false, "double", false), "toggle");
+  assert.equal(treeNodeRowDoubleClickAction("etcd-root", false, "double", false), "toggle");
+  assert.equal(treeNodeRowDoubleClickAction("zookeeper-root", false, "double", false), "toggle");
+});
+
+test("expandable non-table rows still toggle from row clicks", () => {
+  assert.equal(treeNodeRowAction("connection", true), "toggle");
+  assert.equal(treeNodeRowAction("database", true), "toggle");
+  assert.equal(treeNodeRowAction("schema", true), "toggle");
+  assert.equal(treeNodeRowAction("group-columns", true), "toggle");
+});
+
+test("leaf data browser nodes keep their open behavior through toggle handler", () => {
+  assert.equal(treeNodeRowAction("redis-db", false), "toggle");
+  assert.equal(treeNodeRowAction("etcd-root", false), "toggle");
+  assert.equal(treeNodeRowAction("zookeeper-root", false), "toggle");
+  assert.equal(treeNodeRowAction("mongo-gridfs" as never, false), "toggle");
+  assert.equal(treeNodeRowAction("mongo-collection", false), "toggle");
+  assert.equal(treeNodeRowAction("mongo-bucket", false), "toggle");
+});
+
+test("document browser helper covers Mongo collections and GridFS buckets", () => {
+  assert.equal(isDocumentBrowserTreeNode("mongo-collection"), true);
+  assert.equal(isDocumentBrowserTreeNode("mongo-bucket"), true);
+  assert.equal(isDocumentBrowserTreeNode("redis-db"), false);
+});
+
+test("double-click follow-up clicks do not run row actions", () => {
+  assert.equal(shouldRunTreeNodeRowAction("toggle", 1), true);
+  assert.equal(shouldRunTreeNodeRowAction("toggle", 2), false);
+  assert.equal(shouldRunTreeNodeRowAction("toggle", 3), false);
+  assert.equal(shouldRunTreeNodeRowAction("open-data", 1), true);
+  assert.equal(shouldRunTreeNodeRowAction("open-data", 2), false);
+  assert.equal(shouldRunTreeNodeRowAction("none", 1), false);
+});
+
+test("plain metadata leaf rows do nothing on row clicks", () => {
+  assert.equal(treeNodeRowAction("column", false), "none");
+  assert.equal(treeNodeRowAction("index", false), "none");
+});
+
+test("maps source-capable sidebar nodes to object source kinds", () => {
+  assert.equal(objectSourceKindForTreeNode("view"), "VIEW");
+  assert.equal(objectSourceKindForTreeNode("procedure"), "PROCEDURE");
+  assert.equal(objectSourceKindForTreeNode("function"), "FUNCTION");
+  assert.equal(objectSourceKindForTreeNode("sequence"), "SEQUENCE");
+  assert.equal(objectSourceKindForTreeNode("package"), "PACKAGE");
+  assert.equal(objectSourceKindForTreeNode("package-body"), "PACKAGE_BODY");
+  assert.equal(objectSourceKindForTreeNode("table"), null);
+});
+
+test("database and schema rows open object browser only on double click", () => {
+  assert.equal(treeNodeRowAction("database", true), "toggle");
+  assert.equal(treeNodeRowAction("schema", true), "toggle");
+  assert.equal(treeNodeRowDoubleClickAction("database", true), "open-object-browser");
+  assert.equal(treeNodeRowDoubleClickAction("schema", true), "open-object-browser");
+  assert.equal(treeNodeRowAction("database", true, "double"), "none");
+  assert.equal(treeNodeRowAction("schema", true, "double"), "none");
+});
+
+test("double click navigation mode opens object browser for database and schema rows", () => {
+  assert.equal(treeNodeRowDoubleClickAction("database", true, "double", false), "open-object-browser");
+  assert.equal(treeNodeRowDoubleClickAction("schema", true, "double", false), "open-object-browser");
+});
+
+test("double click navigation mode opens object browser and expands expandable database and schema rows", () => {
+  assert.equal(treeNodeRowDoubleClickAction("database", true, "double", true), "open-object-browser-and-expand");
+  assert.equal(treeNodeRowDoubleClickAction("schema", true, "double", true), "open-object-browser-and-expand");
+});
+
+test("double click does not open object browser for non-browsable rows", () => {
+  assert.equal(treeNodeRowDoubleClickAction("database", false), "none");
+  assert.equal(treeNodeRowDoubleClickAction("table", true), "none");
+  assert.equal(treeNodeRowDoubleClickAction("column", true), "none");
+});
+
+test("double click navigation mode copies the selected sidebar row name", () => {
+  assert.equal(sidebarSelectionCopyAction({ key: "c", metaKey: true }), "copy-name");
+  assert.equal(sidebarSelectionCopyAction({ key: "C", ctrlKey: true }), "copy-name");
+});
+
+test("single click navigation mode copies the selected sidebar row name", () => {
+  assert.equal(sidebarSelectionCopyAction({ key: "c", metaKey: true }), "copy-name");
+  assert.equal(sidebarSelectionCopyAction({ key: "C", ctrlKey: true }), "copy-name");
+});
+
+test("copying table child group rows uses the parent table name", () => {
+  assert.equal(
+    copyNameForTreeNode({
+      id: "conn:db:public:orders:__columns",
+      label: "tree.columns",
+      type: "group-columns",
+      tableName: "orders",
+    }),
+    "orders",
+  );
+  assert.equal(
+    copyNameForTreeNode({
+      id: "conn:db:public:orders:__indexes",
+      label: "tree.indexes",
+      type: "group-indexes",
+      tableName: "orders",
+    }),
+    "orders",
+  );
+});
+
+test("copying database object group rows uses the parent schema or database name", () => {
+  assert.equal(
+    copyNameForTreeNode({
+      id: "conn:db:public:__tables",
+      label: "tree.tables",
+      type: "group-tables",
+      database: "db",
+      schema: "public",
+    }),
+    "public",
+  );
+  assert.equal(
+    copyNameForTreeNode({
+      id: "conn:db:__views",
+      label: "tree.views",
+      type: "group-views",
+      database: "db",
+    }),
+    "db",
+  );
+});
+
+test("copying column rows uses the column name without type suffix", () => {
+  assert.equal(
+    copyNameForTreeNode({
+      id: "conn:db:public:orders:__columns:status",
+      label: "status (varchar)",
+      type: "column",
+      meta: {
+        name: "status",
+        data_type: "varchar",
+        is_nullable: true,
+        column_default: null,
+        is_primary_key: false,
+        extra: null,
+        comment: null,
+        numeric_precision: null,
+        numeric_scale: null,
+        character_maximum_length: null,
+      },
+    }),
+    "status",
+  );
+  assert.equal(
+    copyNameForTreeNode({
+      id: "conn:db:public:orders:__columns:status",
+      label: "status (varchar)",
+      type: "column",
+    }),
+    "status",
+  );
+});
diff --git a/packages/app-tests/treeNodeContext.test.ts b/packages/app-tests/treeNodeContext.test.ts
new file mode 100644
index 0000000..e3810bb
--- /dev/null
+++ b/packages/app-tests/treeNodeContext.test.ts
@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { hasTreeNodeDatabaseContext, normalizeCataloglessDatabaseNodes, treeNodeSchemaCachePrefix } from "../../apps/desktop/src/lib/sidebar/treeNodeContext.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+test("treats empty database string as a valid catalogless context", () => {
+  assert.equal(hasTreeNodeDatabaseContext({ database: "" }), true);
+  assert.equal(hasTreeNodeDatabaseContext({ database: "app" }), true);
+  assert.equal(hasTreeNodeDatabaseContext({}), false);
+});
+
+test("builds cache prefixes for catalogless database and schema nodes", () => {
+  const databaseNode: TreeNode = {
+    id: "conn:",
+    label: "tree.defaultDatabase",
+    type: "database",
+    connectionId: "conn",
+    database: "",
+  };
+  const schemaNode: TreeNode = {
+    id: "conn::APP",
+    label: "APP",
+    type: "schema",
+    connectionId: "conn",
+    database: "",
+    schema: "APP",
+  };
+
+  assert.equal(treeNodeSchemaCachePrefix(databaseNode), "conn::");
+  assert.equal(treeNodeSchemaCachePrefix(schemaNode), "conn::APP:");
+});
+
+test("normalizes legacy blank cached catalogless database labels", () => {
+  const nodes = normalizeCataloglessDatabaseNodes([
+    {
+      id: "conn:",
+      label: "",
+      type: "database",
+      connectionId: "conn",
+      database: "",
+      children: [],
+    },
+  ]);
+
+  assert.equal(nodes[0].label, "tree.defaultDatabase");
+});
diff --git a/packages/app-tests/treeNodeIcon.test.ts b/packages/app-tests/treeNodeIcon.test.ts
new file mode 100644
index 0000000..a61962e
--- /dev/null
+++ b/packages/app-tests/treeNodeIcon.test.ts
@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { getTreeNodeIconInfo } from "../../apps/desktop/src/lib/sidebar/treeNodeIcon.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+test("GridFS sidebar nodes use a dedicated cool-color icon treatment", () => {
+  const gridfs = getTreeNodeIconInfo({ type: "mongo-gridfs" } as TreeNode);
+  const bucket = getTreeNodeIconInfo({ type: "mongo-bucket" } as TreeNode);
+
+  assert.equal(gridfs?.colorClass, "text-cyan-500");
+  assert.equal(bucket?.colorClass, "text-cyan-400");
+});
+
+test("GridFS sidebar icon mapping stays distinct from Mongo collections", () => {
+  const gridfs = getTreeNodeIconInfo({ type: "mongo-gridfs" } as TreeNode);
+  const collection = getTreeNodeIconInfo({ type: "mongo-collection" } as TreeNode);
+
+  assert.notEqual(gridfs?.colorClass, collection?.colorClass);
+});
diff --git a/packages/app-tests/treeRefreshTarget.test.ts b/packages/app-tests/treeRefreshTarget.test.ts
new file mode 100644
index 0000000..84fe38b
--- /dev/null
+++ b/packages/app-tests/treeRefreshTarget.test.ts
@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { findDatabaseTreeNode } from "../../apps/desktop/src/lib/sidebar/treeRefreshTarget.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+test("finds database refresh targets inside grouped sidebar trees", () => {
+  const target: TreeNode = {
+    id: "conn-1:app",
+    label: "app",
+    type: "database",
+    connectionId: "conn-1",
+    database: "app",
+  };
+  const nodes: TreeNode[] = [
+    {
+      id: "group-1",
+      label: "Production",
+      type: "connection-group",
+      children: [
+        {
+          id: "conn-1",
+          label: "mysql",
+          type: "connection",
+          connectionId: "conn-1",
+          children: [target],
+        },
+      ],
+    },
+  ];
+
+  assert.equal(findDatabaseTreeNode(nodes, "conn-1", "app"), target);
+});
+
+test("returns null when the target database node is not loaded", () => {
+  assert.equal(findDatabaseTreeNode([], "conn-1", "app"), null);
+});
diff --git a/packages/app-tests/useDataGridActions.test.ts b/packages/app-tests/useDataGridActions.test.ts
new file mode 100644
index 0000000..fdcb712
--- /dev/null
+++ b/packages/app-tests/useDataGridActions.test.ts
@@ -0,0 +1,233 @@
+import assert from "node:assert/strict";
+import { computed } from "vue";
+import { createPinia, setActivePinia } from "pinia";
+import { test, vi } from "vitest";
+import { useConnectionStore } from "../../apps/desktop/src/stores/connectionStore.ts";
+import { useQueryStore } from "../../apps/desktop/src/stores/queryStore.ts";
+import type { ColumnInfo, ConnectionConfig } from "../../apps/desktop/src/types/database.ts";
+
+vi.mock("vue-i18n", async () => {
+  const actual = await vi.importActual<typeof import("vue-i18n")>("vue-i18n");
+  return {
+    ...actual,
+    useI18n: () => ({ t: (key: string) => key }),
+  };
+});
+
+vi.mock("@/composables/useToast", () => ({
+  useToast: () => ({ toast: vi.fn() }),
+}));
+
+function installMemoryStorage() {
+  const values = new Map<string, string>();
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+      clear: () => values.clear(),
+    },
+  });
+  return () => {
+    if (original) Object.defineProperty(globalThis, "localStorage", original);
+    else Reflect.deleteProperty(globalThis, "localStorage");
+  };
+}
+
+function conn(id: string): ConnectionConfig {
+  return {
+    id,
+    name: id,
+    db_type: "mysql",
+    host: "localhost",
+    port: 3306,
+    username: "root",
+    password: "",
+  };
+}
+
+async function waitFor(predicate: () => boolean, timeoutMs = 1000) {
+  const started = Date.now();
+  while (!predicate()) {
+    if (Date.now() - started > timeoutMs) throw new Error("timed out waiting for condition");
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}
+
+test("data reload executes before slow metadata refresh completes", async () => {
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  const { useDataGridActions } = await import("../../apps/desktop/src/composables/useDataGridActions.ts");
+  let executeBody: any;
+  let resolveColumns!: (columns: ColumnInfo[]) => void;
+
+  globalThis.fetch = (async (input, init) => {
+    const url = new URL(String(input), "http://localhost");
+    if (url.pathname === "/api/connection/check-health") {
+      return Response.json(null);
+    }
+    if (url.pathname === "/api/schema/columns") {
+      return Response.json(await new Promise<ColumnInfo[]>((resolve) => (resolveColumns = resolve)));
+    }
+    if (url.pathname === "/api/schema/indexes") {
+      return Response.json([]);
+    }
+    if (url.pathname === "/api/query/build-table-select-sql") {
+      return Response.json("SELECT * FROM `users` LIMIT 50 OFFSET 0");
+    }
+    if (url.pathname === "/api/query/execute-multi") {
+      executeBody = JSON.parse(String(init?.body ?? "{}"));
+      return Response.json([{ columns: ["id"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }]);
+    }
+    return new Response(`unexpected ${url.pathname}`, { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const connectionStore = useConnectionStore();
+    const queryStore = useQueryStore();
+    connectionStore.addEphemeralConnection(conn("mysql-1"));
+    const tabId = queryStore.createTab("mysql-1", "app", "users", "data");
+    queryStore.setTableMeta(tabId, { tableName: "users", tableType: "TABLE", columns: [], primaryKeys: [] });
+    const tab = queryStore.tabs.find((item) => item.id === tabId);
+    assert.ok(tab);
+
+    const actions = useDataGridActions(computed(() => tab));
+    const reload = actions.onReloadData(undefined, undefined, undefined, undefined, 50, 0);
+
+    await waitFor(() => !!executeBody, 5_000);
+    assert.equal(executeBody.clientSessionId, tabId);
+    assert.deepEqual(tab.result?.rows, [[1]]);
+
+    await waitFor(() => typeof resolveColumns === "function");
+    resolveColumns([
+      {
+        name: "id",
+        data_type: "int",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: true,
+        extra: null,
+      },
+    ]);
+    await reload;
+    await waitFor(() => tab.tableMeta?.columns.length === 1);
+    assert.equal(tab.tableMeta?.primaryKeys[0], "id");
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("data reload preserves current page offset instead of resetting to page 1", async () => {
+  // Verifies the fix: onReloadData called with offset=400 (page 5, pageSize=100)
+  // should pass offset=400 to build-table-select-sql and store it in resultPageOffset,
+  // rather than defaulting to offset=0.
+  const restoreStorage = installMemoryStorage();
+  const originalFetch = globalThis.fetch;
+  const { useDataGridActions } = await import("../../apps/desktop/src/composables/useDataGridActions.ts");
+  let buildSqlOptions: any;
+  let executePagination: any;
+
+  globalThis.fetch = (async (input, init) => {
+    const url = new URL(String(input), "http://localhost");
+    if (url.pathname === "/api/connection/check-health") return Response.json(null);
+    if (url.pathname === "/api/schema/columns") return Response.json([]);
+    if (url.pathname === "/api/schema/indexes") return Response.json([]);
+    if (url.pathname === "/api/query/build-table-select-sql") {
+      buildSqlOptions = JSON.parse(String(init?.body ?? "{}"))?.options;
+      return Response.json(`SELECT * FROM \`orders\` LIMIT 100 OFFSET ${buildSqlOptions?.offset ?? 0}`);
+    }
+    if (url.pathname === "/api/query/execute-multi") {
+      const body = JSON.parse(String(init?.body ?? "{}"));
+      executePagination = body?.page_offset;
+      return Response.json([{ columns: ["id"], rows: [[42]], affected_rows: 0, execution_time_ms: 1 }]);
+    }
+    return new Response(`unexpected ${url.pathname}`, { status: 500 });
+  }) as typeof fetch;
+
+  try {
+    setActivePinia(createPinia());
+    const connectionStore = useConnectionStore();
+    const queryStore = useQueryStore();
+    connectionStore.addEphemeralConnection(conn("mysql-1"));
+    const tabId = queryStore.createTab("mysql-1", "app", "orders", "data");
+    queryStore.setTableMeta(tabId, { tableName: "orders", tableType: "TABLE", columns: [], primaryKeys: [] });
+    const tab = queryStore.tabs.find((item) => item.id === tabId);
+    assert.ok(tab);
+
+    const actions = useDataGridActions(computed(() => tab));
+    // Simulate refresh from page 5 with pageSize=100 → offset=400
+    await actions.onReloadData(undefined, undefined, undefined, undefined, 100, 400);
+
+    assert.equal(buildSqlOptions?.offset, 400, "build-table-select-sql must receive offset=400 to stay on page 5");
+    assert.equal(buildSqlOptions?.limit, 100, "limit must be 100");
+    assert.equal(tab.resultPageOffset, 400, "resultPageOffset must be 400 after reload to keep DataGrid on page 5");
+  } finally {
+    globalThis.fetch = originalFetch;
+    restoreStorage();
+  }
+});
+
+test("query toolbar refresh reruns the complete multi-result SQL and keeps the active result", async () => {
+  const restoreStorage = installMemoryStorage();
+  const { useDataGridActions } = await import("../../apps/desktop/src/composables/useDataGridActions.ts");
+
+  try {
+    setActivePinia(createPinia());
+    const queryStore = useQueryStore();
+    const tabId = queryStore.createTab("mysql-1", "app", "query", "query");
+    const tab = queryStore.tabs.find((item) => item.id === tabId);
+    assert.ok(tab);
+
+    const batchSql = "select * from users; select * from orders";
+    const refreshedResults = [
+      { columns: ["id"], rows: [[11]], affected_rows: 0, execution_time_ms: 1, sourceStatement: "select * from users" },
+      { columns: ["id"], rows: [[22]], affected_rows: 0, execution_time_ms: 1, sourceStatement: "select * from orders" },
+    ];
+    tab.sql = batchSql;
+    tab.lastExecutedSql = batchSql;
+    tab.resultBaseSql = batchSql;
+    tab.results = refreshedResults.map((result) => ({ ...result, rows: result.rows.map((row) => [...row]) }));
+    tab.activeResultIndex = 1;
+    tab.result = tab.results[1];
+    tab.resultSortColumn = "id";
+    tab.resultSortColumnIndex = 0;
+    tab.resultSortDirection = "desc";
+    tab.resultSortMode = "database";
+    tab.resultSortedSql = "select * from orders order by id desc";
+
+    const executeTabSql = vi.spyOn(queryStore, "executeTabSql").mockImplementation(async (_tabId, _sql, options) => {
+      assert.equal(tab.resultSortColumn, undefined);
+      assert.equal(tab.resultSortColumnIndex, undefined);
+      assert.equal(tab.resultSortDirection, undefined);
+      assert.equal(tab.resultSortMode, undefined);
+      assert.equal(tab.resultSortedSql, undefined);
+      tab.results = refreshedResults;
+      if (!options?.preserveActiveResultIndex) tab.activeResultIndex = 0;
+      tab.result = refreshedResults[tab.activeResultIndex ?? 0];
+    });
+    const actions = useDataGridActions(computed(() => tab));
+
+    await actions.onReloadData("select * from orders", undefined, undefined, undefined, 100, 0, "refresh");
+    await actions.onReloadData("select * from orders", undefined, undefined, undefined, 100, 0, "refresh");
+
+    assert.equal(executeTabSql.mock.calls.length, 2);
+    for (const call of executeTabSql.mock.calls) {
+      assert.equal(call[1], batchSql);
+      assert.deepEqual(call[2], {
+        resultBaseSql: batchSql,
+        resultSortedSql: undefined,
+        preserveResultDuringExecution: true,
+        preserveActiveResultIndex: true,
+      });
+    }
+    assert.equal(tab.results?.length, 2);
+    assert.equal(tab.activeResultIndex, 1);
+    assert.deepEqual(tab.result, refreshedResults[1]);
+  } finally {
+    restoreStorage();
+  }
+});
diff --git a/packages/app-tests/useDataGridExport.test.ts b/packages/app-tests/useDataGridExport.test.ts
new file mode 100644
index 0000000..a8f354e
--- /dev/null
+++ b/packages/app-tests/useDataGridExport.test.ts
@@ -0,0 +1,705 @@
+import { strict as assert } from "node:assert";
+import { computed, ref } from "vue";
+import { beforeEach, test, vi } from "vitest";
+import { createPinia, setActivePinia } from "pinia";
+import { useSettingsStore } from "../../apps/desktop/src/stores/settingsStore.ts";
+
+const apiMock = vi.hoisted(() => ({
+  startQueryResultExport: vi.fn(),
+  cancelQueryResultExport: vi.fn(),
+  startTableExport: vi.fn(),
+  cancelTableExport: vi.fn(),
+  saveEditorSettings: vi.fn(async () => {}),
+  exportQueryResultCsv: vi.fn(),
+  exportQueryResultXlsx: vi.fn(),
+  exportQueryResultJson: vi.fn(),
+  exportQueryResultMarkdown: vi.fn(),
+  exportQueryResultsXlsx: vi.fn(),
+  buildDataGridCopyInsertStatement: vi.fn(),
+}));
+const clipboardMock = vi.hoisted(() => ({
+  copyToClipboard: vi.fn(),
+}));
+
+vi.mock("@/lib/backend/api", () => apiMock);
+vi.mock("@/lib/common/clipboard", () => clipboardMock);
+vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
+vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: vi.fn() }) }));
+vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string) => key }) }));
+
+const { defaultDataGridExportFileName, useDataGridExport } = await import("../../apps/desktop/src/composables/useDataGridExport.ts");
+
+function installMemoryStorage() {
+  const values = new Map<string, string>();
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => values.get(key) ?? null,
+      setItem: (key: string, value: string) => values.set(key, value),
+      removeItem: (key: string) => values.delete(key),
+      clear: () => values.clear(),
+    },
+  });
+  return () => {
+    if (original) Object.defineProperty(globalThis, "localStorage", original);
+    else Reflect.deleteProperty(globalThis, "localStorage");
+  };
+}
+
+function buildExportHarness(options: { currentResultLabel?: string; exportFileBaseName?: string } = {}) {
+  const exportProgressDialog = ref(false);
+  const exportProgressState = ref({
+    title: "",
+    tableName: "",
+    format: "csv",
+    rowsExported: 0,
+    totalRows: null as number | null,
+    status: "",
+    errorMessage: null as string | null,
+  });
+  const exportCancelHandler = ref<(() => Promise<void>) | null>(null);
+  const fullExportResult = vi.fn(async () => {
+    throw new Error("fullExportResult should not be called for streaming CSV/XLSX query exports");
+  });
+  const queryResultExportRequest = vi.fn(async (options: { exportId: string; filePath: string; format: "csv" | "xlsx" }) => ({
+    exportId: options.exportId,
+    connectionId: "conn-1",
+    database: "db",
+    schema: "public",
+    sql: "SELECT * FROM users",
+    queryBaseSql: "SELECT * FROM users",
+    databaseType: "postgres" as const,
+    useAgentCursor: false,
+    filePath: options.filePath,
+    format: options.format,
+    pageSize: 1000,
+    rowLimit: 100000,
+    totalRows: 2,
+    timeoutSecs: 30,
+    keysetOptimizationEnabled: true,
+    clientSessionId: "tab-1:export",
+    executionId: "exec-1",
+  }));
+
+  const composable = useDataGridExport({
+    columns: computed(() => ["id", "name"]),
+    displayItems: computed(() => [
+      { id: 1, data: [1, "Ada"], isNew: false, isDeleted: false, isDirtyCol: [false, false], status: "" },
+      { id: 2, data: [2, "Lin"], isNew: false, isDeleted: false, isDirtyCol: [false, false], status: "" },
+    ]),
+    sql: computed(() => "SELECT * FROM users"),
+    tableMeta: computed(() => undefined),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => "conn-1"),
+    database: computed(() => "db"),
+    context: computed(() => "results"),
+    sourceColumns: computed(() => undefined),
+    columnTypes: computed(() => undefined),
+    whereInput: computed(() => undefined),
+    orderBy: computed(() => undefined),
+    exportBatchSize: computed(() => 1000),
+    hasCellSelection: computed(() => false),
+    selectedCells: computed(() => ({ columns: [], rows: [] })),
+    selectedRange: computed(() => null),
+    contextCell: ref(null),
+    getRowItem: (rowId: number) =>
+      [
+        { id: 1, data: [1, "Ada"], isNew: false, isDeleted: false, isDirtyCol: [false, false], status: "" },
+        { id: 2, data: [2, "Lin"], isNew: false, isDeleted: false, isDirtyCol: [false, false], status: "" },
+      ].find((item) => item.id === rowId),
+    selectedRowIds: ref(new Set<number>()),
+    hasRowSelection: computed(() => false),
+    fullExportResult,
+    queryResultExportRequest,
+    currentResultLabel: computed(() => options.currentResultLabel),
+    exportFileBaseName: computed(() => options.exportFileBaseName),
+    exportProgressDialog,
+    exportProgressState,
+    exportCancelHandler,
+  });
+
+  return {
+    composable,
+    fullExportResult,
+    queryResultExportRequest,
+    exportProgressDialog,
+    exportProgressState,
+    exportCancelHandler,
+  };
+}
+
+function buildTableDataExportHarness() {
+  const exportProgressDialog = ref(false);
+  const exportProgressState = ref({
+    title: "",
+    tableName: "",
+    format: "csv",
+    rowsExported: 0,
+    totalRows: null as number | null,
+    status: "",
+    errorMessage: null as string | null,
+  });
+  const exportCancelHandler = ref<(() => Promise<void>) | null>(null);
+
+  const composable = useDataGridExport({
+    columns: computed(() => ["id", "name"]),
+    displayItems: computed(() => [
+      { id: 1, data: [1, "Ada"], isNew: false, isDeleted: false, isDirtyCol: [false, false], status: "" },
+      { id: 2, data: [2, "Lin"], isNew: false, isDeleted: false, isDirtyCol: [false, false], status: "" },
+    ]),
+    sql: computed(() => undefined),
+    tableMeta: computed(() => ({
+      schema: "public",
+      tableName: "users",
+      columns: [
+        { name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
+        { name: "name", data_type: "text", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
+      ],
+      primaryKeys: ["id"],
+    })),
+    databaseType: computed(() => "postgres"),
+    connectionId: computed(() => "conn-1"),
+    database: computed(() => "db"),
+    context: computed(() => "table-data"),
+    sourceColumns: computed(() => undefined),
+    columnTypes: computed(() => ["integer", "text"]),
+    whereInput: computed(() => undefined),
+    orderBy: computed(() => undefined),
+    exportBatchSize: computed(() => 1000),
+    hasCellSelection: computed(() => false),
+    selectedCells: computed(() => ({ columns: [], rows: [] })),
+    selectedRange: computed(() => null),
+    contextCell: ref(null),
+    getRowItem: () => undefined,
+    selectedRowIds: ref(new Set<number>()),
+    hasRowSelection: computed(() => false),
+    exportProgressDialog,
+    exportProgressState,
+    exportCancelHandler,
+  });
+
+  return {
+    composable,
+    exportProgressDialog,
+    exportProgressState,
+    exportCancelHandler,
+  };
+}
+
+beforeEach(() => {
+  setActivePinia(createPinia());
+  vi.clearAllMocks();
+  clipboardMock.copyToClipboard.mockResolvedValue(undefined);
+  apiMock.startQueryResultExport.mockImplementation(async (_request, onProgress) => {
+    onProgress({ exportId: _request.exportId, tableName: "", rowsExported: 2, totalRows: 2, status: "Done" });
+    return { exportId: _request.exportId, tableName: "", rowsExported: 2, totalRows: 2, status: "Done" };
+  });
+  apiMock.startTableExport.mockImplementation(async (_request, onProgress) => {
+    onProgress({ exportId: _request.exportId, tableName: _request.tableName, rowsExported: 2, totalRows: 2, status: "Done" });
+    return { exportId: _request.exportId, tableName: _request.tableName, rowsExported: 2, totalRows: 2, status: "Done" };
+  });
+});
+
+test("copy row JSON expands nested JSON strings", async () => {
+  const contextCell = ref({ rowId: 1, rowIndex: 0, col: 0 });
+  const jsonString = '{"endingBalance":{"beginningBalance":"0","endingBalance":"20000","endingDate":"2024-10-30"},"financeChargeInfo":null,"interestChargeInfo":null,"Line":[]}';
+  const row = {
+    id: 1,
+    data: ["67218700e884ae1f527640b6", jsonString, "draft"],
+    isNew: false,
+    isDeleted: false,
+    isDirtyCol: [false, false, false],
+    status: "",
+  };
+  const composable = useDataGridExport({
+    columns: computed(() => ["_id", "data", "status"]),
+    displayItems: computed(() => [row]),
+    sql: computed(() => undefined),
+    tableMeta: computed(() => undefined),
+    databaseType: computed(() => "mongodb"),
+    connectionId: computed(() => "conn-1"),
+    database: computed(() => "db"),
+    context: computed(() => "results"),
+    sourceColumns: computed(() => undefined),
+    columnTypes: computed(() => undefined),
+    whereInput: computed(() => undefined),
+    orderBy: computed(() => undefined),
+    exportBatchSize: computed(() => 1000),
+    hasCellSelection: computed(() => false),
+    selectedCells: computed(() => ({ columns: [], rows: [] })),
+    selectedRange: computed(() => null),
+    contextCell,
+    getRowItem: () => row,
+    selectedRowIds: ref(new Set<number>()),
+    hasRowSelection: computed(() => false),
+  });
+
+  await composable.copyRow();
+
+  assert.equal(clipboardMock.copyToClipboard.mock.calls.length, 1);
+  assert.deepEqual(JSON.parse(clipboardMock.copyToClipboard.mock.calls[0][0]), {
+    _id: "67218700e884ae1f527640b6",
+    data: {
+      endingBalance: {
+        beginningBalance: "0",
+        endingBalance: "20000",
+        endingDate: "2024-10-30",
+      },
+      financeChargeInfo: null,
+      interestChargeInfo: null,
+      Line: [],
+    },
+    status: "draft",
+  });
+});
+
+test("copy row JSON keeps nested JSON strings for non-MongoDB rows", async () => {
+  const contextCell = ref({ rowId: 1, rowIndex: 0, col: 0 });
+  const jsonString = '{"enabled":true}';
+  const row = {
+    id: 1,
+    data: [1, jsonString],
+    isNew: false,
+    isDeleted: false,
+    isDirtyCol: [false, false],
+    status: "",
+  };
+  const composable = useDataGridExport({
+    columns: computed(() => ["id", "payload"]),
+    displayItems: computed(() => [row]),
+    sql: computed(() => undefined),
+    tableMeta: computed(() => undefined),
+    databaseType: computed(() => "mysql"),
+    connectionId: computed(() => "conn-1"),
+    database: computed(() => "db"),
+    context: computed(() => "table"),
+    sourceColumns: computed(() => undefined),
+    columnTypes: computed(() => undefined),
+    whereInput: computed(() => undefined),
+    orderBy: computed(() => undefined),
+    exportBatchSize: computed(() => 1000),
+    hasCellSelection: computed(() => false),
+    selectedCells: computed(() => ({ columns: [], rows: [] })),
+    selectedRange: computed(() => null),
+    contextCell,
+    getRowItem: () => row,
+    selectedRowIds: ref(new Set<number>()),
+    hasRowSelection: computed(() => false),
+  });
+
+  await composable.copyRow();
+
+  assert.deepEqual(JSON.parse(clipboardMock.copyToClipboard.mock.calls[0][0]), {
+    id: 1,
+    payload: jsonString,
+  });
+});
+
+test("copy MongoDB row as INSERT uses Mongo shell insert syntax", async () => {
+  const contextCell = ref({ rowId: 1, rowIndex: 0, col: 0 });
+  const jsonString = '{"endingBalance":{"beginningBalance":"0","endingBalance":"100","endingDate":"2024-11-25"},"Line":[]}';
+  const row = {
+    id: 1,
+    data: ["6743e4bfa3f6f84bc3fff6c8", "577", "done", jsonString, 'ISODate("2024-11-25T02:45:36.184Z")'],
+    isNew: false,
+    isDeleted: false,
+    isDirtyCol: [false, false, false, false, false],
+    status: "",
+  };
+  const composable = useDataGridExport({
+    columns: computed(() => ["_id", "accountId", "status", "data", "lastUpdatedDate"]),
+    displayItems: computed(() => [row]),
+    sql: computed(() => undefined),
+    tableMeta: computed(() => undefined),
+    copyInsertTargetLabel: computed(() => "accounting_reconciliations"),
+    databaseType: computed(() => "mongodb"),
+    connectionId: computed(() => "conn-1"),
+    database: computed(() => "db"),
+    context: computed(() => "results"),
+    sourceColumns: computed(() => undefined),
+    columnTypes: computed(() => undefined),
+    whereInput: computed(() => undefined),
+    orderBy: computed(() => undefined),
+    exportBatchSize: computed(() => 1000),
+    hasCellSelection: computed(() => false),
+    selectedCells: computed(() => ({ columns: [], rows: [] })),
+    selectedRange: computed(() => null),
+    contextCell,
+    getRowItem: () => row,
+    selectedRowIds: ref(new Set<number>()),
+    hasRowSelection: computed(() => false),
+  });
+
+  await composable.prefetchRowAsInsertStatement(false);
+  await composable.copyRowAsInsert();
+
+  assert.equal(apiMock.buildDataGridCopyInsertStatement.mock.calls.length, 0);
+  assert.equal(
+    clipboardMock.copyToClipboard.mock.calls[0][0],
+    'db.getCollection("accounting_reconciliations").insert({"_id":ObjectId("6743e4bfa3f6f84bc3fff6c8"),"accountId":577,"status":"done","data":{"endingBalance":{"beginningBalance":"0","endingBalance":"100","endingDate":"2024-11-25"},"Line":[]},"lastUpdatedDate":ISODate("2024-11-25T02:45:36.184Z")});',
+  );
+});
+
+test("copy MongoDB rows as INSERT excludes _id for insert without primary keys", async () => {
+  const selectedRowIds = ref(new Set([1, 2]));
+  const rows = [
+    { id: 1, data: ["6743e4bfa3f6f84bc3fff6c8", "done"], isNew: false, isDeleted: false, isDirtyCol: [false, false], status: "" },
+    { id: 2, data: ["6743e4bfa3f6f84bc3fff6c9", "draft"], isNew: false, isDeleted: false, isDirtyCol: [false, false], status: "" },
+  ];
+  const composable = useDataGridExport({
+    columns: computed(() => ["_id", "status"]),
+    displayItems: computed(() => rows),
+    sql: computed(() => undefined),
+    tableMeta: computed(() => ({
+      tableName: "accounting_reconciliations",
+      primaryKeys: ["_id"],
+    })),
+    databaseType: computed(() => "mongodb"),
+    connectionId: computed(() => "conn-1"),
+    database: computed(() => "db"),
+    context: computed(() => "results"),
+    sourceColumns: computed(() => undefined),
+    columnTypes: computed(() => undefined),
+    whereInput: computed(() => undefined),
+    orderBy: computed(() => undefined),
+    exportBatchSize: computed(() => 1000),
+    hasCellSelection: computed(() => false),
+    selectedCells: computed(() => ({ columns: [], rows: [] })),
+    selectedRange: computed(() => null),
+    contextCell: ref(null),
+    getRowItem: (rowId: number) => rows.find((item) => item.id === rowId),
+    selectedRowIds,
+    hasRowSelection: computed(() => true),
+  });
+
+  await composable.prefetchRowAsInsertStatement(true);
+  await composable.copyRowAsInsertWithoutPrimaryKeys();
+
+  assert.equal(apiMock.buildDataGridCopyInsertStatement.mock.calls.length, 0);
+  assert.equal(clipboardMock.copyToClipboard.mock.calls[0][0], 'db.getCollection("accounting_reconciliations").insertMany([{"status":"done"},{"status":"draft"}]);');
+});
+
+test("copy row as INSERT refreshes prepared SQL after row data changes", async () => {
+  const contextCell = ref({ rowId: 1, rowIndex: 0, col: 0 });
+  const row = {
+    id: 1,
+    data: [1, "before"],
+    isNew: false,
+    isDeleted: false,
+    isDirtyCol: [false, false],
+    status: "",
+  };
+  apiMock.buildDataGridCopyInsertStatement.mockResolvedValueOnce("INSERT INTO users (id, name) VALUES (1, 'before');").mockResolvedValueOnce("INSERT INTO users (id, name) VALUES (1, 'after');");
+  const composable = useDataGridExport({
+    columns: computed(() => ["id", "name"]),
+    displayItems: computed(() => [row]),
+    sql: computed(() => undefined),
+    tableMeta: computed(() => ({
+      tableName: "users",
+      primaryKeys: ["id"],
+    })),
+    databaseType: computed(() => "mysql"),
+    connectionId: computed(() => "conn-1"),
+    database: computed(() => "db"),
+    context: computed(() => "table-data"),
+    sourceColumns: computed(() => undefined),
+    columnTypes: computed(() => undefined),
+    whereInput: computed(() => undefined),
+    orderBy: computed(() => undefined),
+    exportBatchSize: computed(() => 1000),
+    hasCellSelection: computed(() => false),
+    selectedCells: computed(() => ({ columns: [], rows: [] })),
+    selectedRange: computed(() => null),
+    contextCell,
+    getRowItem: () => row,
+    selectedRowIds: ref(new Set<number>()),
+    hasRowSelection: computed(() => false),
+  });
+
+  await composable.prefetchRowAsInsertStatement(false);
+  await composable.copyRowAsInsert();
+  row.data = [1, "after"];
+  await composable.prefetchRowAsInsertStatement(false);
+  await composable.copyRowAsInsert();
+
+  assert.equal(apiMock.buildDataGridCopyInsertStatement.mock.calls.length, 2);
+  assert.deepEqual(
+    apiMock.buildDataGridCopyInsertStatement.mock.calls.map((call) => call[0].rows),
+    [[[1, "before"]], [[1, "after"]]],
+  );
+  assert.deepEqual(
+    clipboardMock.copyToClipboard.mock.calls.map((call) => call[0]),
+    ["INSERT INTO users (id, name) VALUES (1, 'before');", "INSERT INTO users (id, name) VALUES (1, 'after');"],
+  );
+});
+
+test("copy row as INSERT works without prior prefetch (first context-menu click)", async () => {
+  const contextCell = ref({ rowId: 1, rowIndex: 0, col: 0 });
+  const row = {
+    id: 1,
+    data: [1, "alice"],
+    isNew: false,
+    isDeleted: false,
+    isDirtyCol: [false, false],
+    status: "",
+  };
+  apiMock.buildDataGridCopyInsertStatement.mockResolvedValueOnce("INSERT INTO users (id, name) VALUES (1, 'alice');");
+  const composable = useDataGridExport({
+    columns: computed(() => ["id", "name"]),
+    displayItems: computed(() => [row]),
+    sql: computed(() => undefined),
+    tableMeta: computed(() => ({
+      tableName: "users",
+      primaryKeys: ["id"],
+    })),
+    databaseType: computed(() => "mysql"),
+    connectionId: computed(() => "conn-1"),
+    database: computed(() => "db"),
+    context: computed(() => "table-data"),
+    sourceColumns: computed(() => undefined),
+    columnTypes: computed(() => undefined),
+    whereInput: computed(() => undefined),
+    orderBy: computed(() => undefined),
+    exportBatchSize: computed(() => 1000),
+    hasCellSelection: computed(() => false),
+    selectedCells: computed(() => ({ columns: [], rows: [] })),
+    selectedRange: computed(() => null),
+    contextCell,
+    getRowItem: () => row,
+    selectedRowIds: ref(new Set<number>()),
+    hasRowSelection: computed(() => false),
+  });
+
+  assert.equal(composable.canCopyRowAsInsert.value, true);
+  assert.equal(composable.canCopyPreparedInsert(false), false);
+
+  await composable.copyRowAsInsert();
+
+  assert.equal(apiMock.buildDataGridCopyInsertStatement.mock.calls.length, 1);
+  assert.equal(clipboardMock.copyToClipboard.mock.calls[0][0], "INSERT INTO users (id, name) VALUES (1, 'alice');");
+  assert.equal(composable.canCopyPreparedInsert(false), true);
+});
+
+test("default data grid export file names use sanitized base names and compact local timestamps", () => {
+  vi.useFakeTimers();
+  try {
+    vi.setSystemTime(new Date(2026, 5, 2, 15, 4, 5));
+
+    assert.equal(defaultDataGridExportFileName("daily/report.sql", "export", "csv"), "daily_report_260602150405.csv");
+    assert.equal(defaultDataGridExportFileName("daily/report.sql", "export", "xlsx", { page: true }), "daily_report_page_260602150405.xlsx");
+    assert.equal(defaultDataGridExportFileName("  .sql  ", "query-result", "csv"), "query-result_260602150405.csv");
+  } finally {
+    vi.useRealTimers();
+  }
+});
+
+test("full query result CSV export streams through the backend without loading all rows", async () => {
+  const { composable, fullExportResult, queryResultExportRequest, exportProgressDialog, exportProgressState } = buildExportHarness();
+
+  await composable.exportCsv();
+
+  assert.equal(fullExportResult.mock.calls.length, 0);
+  assert.equal(queryResultExportRequest.mock.calls.length, 1);
+  assert.equal(apiMock.startQueryResultExport.mock.calls.length, 1);
+  assert.equal(apiMock.exportQueryResultCsv.mock.calls.length, 0);
+  assert.equal(exportProgressDialog.value, true);
+  assert.equal(exportProgressState.value.status, "Done");
+});
+
+test("full query result CSV export defaults to the saved SQL title", async () => {
+  vi.useFakeTimers();
+  try {
+    vi.setSystemTime(new Date(2026, 5, 2, 15, 4, 5));
+    const { composable, queryResultExportRequest } = buildExportHarness({ exportFileBaseName: "daily/report.sql" });
+
+    await composable.exportCsv();
+
+    assert.equal(queryResultExportRequest.mock.calls[0][0].filePath, "daily_report_260602150405.csv");
+    assert.equal(apiMock.startQueryResultExport.mock.calls[0][0].filePath, "daily_report_260602150405.csv");
+  } finally {
+    vi.useRealTimers();
+  }
+});
+
+test("selected query result CSV export defaults to the saved SQL title", async () => {
+  vi.useFakeTimers();
+  try {
+    vi.setSystemTime(new Date(2026, 5, 2, 15, 4, 5));
+    const { composable } = buildExportHarness({ exportFileBaseName: "daily/report.sql" });
+
+    await composable.exportCsv([1]);
+
+    assert.equal(apiMock.exportQueryResultCsv.mock.calls[0][0], "daily_report_260602150405.csv");
+  } finally {
+    vi.useRealTimers();
+  }
+});
+
+test("table data export keeps the table name as the default file base", async () => {
+  vi.useFakeTimers();
+  const restoreStorage = installMemoryStorage();
+  try {
+    vi.setSystemTime(new Date(2026, 5, 2, 15, 4, 5));
+    const { composable } = buildTableDataExportHarness();
+
+    await composable.exportCsv();
+
+    assert.equal(apiMock.startTableExport.mock.calls[0][0].filePath, "users_260602150405.csv");
+  } finally {
+    vi.useRealTimers();
+    restoreStorage();
+  }
+});
+
+test("query result CSV cancel handler passes export and execution ids", async () => {
+  const { composable, exportCancelHandler } = buildExportHarness();
+  let resolveExport!: () => void;
+  apiMock.startQueryResultExport.mockImplementationOnce(async (_request, onProgress) => {
+    await new Promise<void>((resolve) => {
+      resolveExport = () => {
+        onProgress({
+          exportId: _request.exportId,
+          tableName: "",
+          rowsExported: 1,
+          totalRows: 2,
+          status: "Cancelled",
+          errorMessage: "Export cancelled",
+        });
+        resolve();
+      };
+    });
+    return {
+      exportId: _request.exportId,
+      tableName: "",
+      rowsExported: 1,
+      totalRows: 2,
+      status: "Cancelled",
+      errorMessage: "Export cancelled",
+    };
+  });
+
+  const exportPromise = composable.exportCsv();
+  await vi.waitFor(() => assert.ok(exportCancelHandler.value));
+  await exportCancelHandler.value?.();
+
+  const request = apiMock.startQueryResultExport.mock.calls[0][0];
+  assert.deepEqual(apiMock.cancelQueryResultExport.mock.calls[0], [request.exportId, "exec-1"]);
+
+  resolveExport();
+  await exportPromise;
+});
+
+test("missing query result export request does not fall back to the in-memory path", async () => {
+  const { composable, fullExportResult, queryResultExportRequest } = buildExportHarness();
+  queryResultExportRequest.mockResolvedValueOnce(undefined);
+
+  await composable.exportCsv();
+
+  assert.equal(queryResultExportRequest.mock.calls.length, 1);
+  assert.equal(fullExportResult.mock.calls.length, 0);
+  assert.equal(apiMock.startQueryResultExport.mock.calls.length, 0);
+  assert.equal(apiMock.exportQueryResultCsv.mock.calls.length, 0);
+});
+
+test("selected query result CSV export keeps the existing in-memory path", async () => {
+  const { composable, queryResultExportRequest } = buildExportHarness();
+
+  await composable.exportCsv([1]);
+
+  assert.equal(queryResultExportRequest.mock.calls.length, 0);
+  assert.equal(apiMock.startQueryResultExport.mock.calls.length, 0);
+  assert.equal(apiMock.exportQueryResultCsv.mock.calls.length, 1);
+  assert.deepEqual(apiMock.exportQueryResultCsv.mock.calls[0][1], ["id", "name"]);
+  assert.deepEqual(apiMock.exportQueryResultCsv.mock.calls[0][2], [[1, "Ada"]]);
+});
+
+test("selected query result XLSX export uses the current source label as the sheet name", async () => {
+  const { composable, queryResultExportRequest } = buildExportHarness({ currentResultLabel: "aaa.apis" });
+
+  await composable.exportXlsx([1]);
+
+  assert.equal(queryResultExportRequest.mock.calls.length, 0);
+  assert.equal(apiMock.startQueryResultExport.mock.calls.length, 0);
+  assert.equal(apiMock.exportQueryResultXlsx.mock.calls.length, 1);
+  assert.equal(apiMock.exportQueryResultXlsx.mock.calls[0][1], "aaa.apis");
+  assert.deepEqual(apiMock.exportQueryResultXlsx.mock.calls[0][2], ["id", "name"]);
+  assert.deepEqual(apiMock.exportQueryResultXlsx.mock.calls[0][3], []);
+  assert.deepEqual(apiMock.exportQueryResultXlsx.mock.calls[0][4], [[1, "Ada"]]);
+});
+
+test("cancelled query result CSV export clears the cancel handler without using the in-memory path", async () => {
+  const { composable, fullExportResult, exportProgressState, exportCancelHandler } = buildExportHarness();
+  apiMock.startQueryResultExport.mockImplementationOnce(async (_request, onProgress) => {
+    onProgress({
+      exportId: _request.exportId,
+      tableName: "",
+      rowsExported: 1,
+      totalRows: 2,
+      status: "Cancelled",
+      errorMessage: "Export cancelled",
+    });
+    return {
+      exportId: _request.exportId,
+      tableName: "",
+      rowsExported: 1,
+      totalRows: 2,
+      status: "Cancelled",
+      errorMessage: "Export cancelled",
+    };
+  });
+
+  await composable.exportCsv();
+
+  assert.equal(fullExportResult.mock.calls.length, 0);
+  assert.equal(apiMock.startQueryResultExport.mock.calls.length, 1);
+  assert.equal(apiMock.exportQueryResultCsv.mock.calls.length, 0);
+  assert.equal(exportProgressState.value.status, "Cancelled");
+  assert.equal(exportProgressState.value.errorMessage, "Export cancelled");
+  assert.equal(exportCancelHandler.value, null);
+});
+
+test("table data export leaves row limit unset by default", async () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    const { composable } = buildTableDataExportHarness();
+
+    await composable.exportCsv();
+
+    assert.equal(apiMock.startTableExport.mock.calls.length, 1);
+    assert.equal(apiMock.startTableExport.mock.calls[0][0].rowLimit, null);
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("table data export requests row count for determinate progress", async () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    const { composable, exportProgressState } = buildTableDataExportHarness();
+
+    await composable.exportCsv();
+
+    assert.equal(apiMock.startTableExport.mock.calls.length, 1);
+    assert.equal(apiMock.startTableExport.mock.calls[0][0].skipCount, false);
+    assert.equal(exportProgressState.value.totalRows, 2);
+  } finally {
+    restoreStorage();
+  }
+});
+
+test("table data export passes row limit when enabled", async () => {
+  const restoreStorage = installMemoryStorage();
+  try {
+    const settingsStore = useSettingsStore();
+    settingsStore.updateEditorSettings({ exportRowLimitEnabled: true, exportRowLimit: 12_345 });
+    const { composable } = buildTableDataExportHarness();
+
+    await composable.exportCsv();
+
+    assert.equal(apiMock.startTableExport.mock.calls.length, 1);
+    assert.equal(apiMock.startTableExport.mock.calls[0][0].rowLimit, 12_345);
+  } finally {
+    restoreStorage();
+  }
+});
diff --git a/packages/app-tests/useExportTracker.test.ts b/packages/app-tests/useExportTracker.test.ts
new file mode 100644
index 0000000..f9a0d69
--- /dev/null
+++ b/packages/app-tests/useExportTracker.test.ts
@@ -0,0 +1,375 @@
+import { strict as assert } from "node:assert";
+import { test, vi } from "vitest";
+
+const apiMock = vi.hoisted(() => ({
+  cancelDatabaseExport: vi.fn(),
+  cancelSqlFileExecution: vi.fn(),
+  cancelTableExport: vi.fn(),
+  cancelTransfer: vi.fn(),
+  startTransfer: vi.fn(),
+}));
+
+vi.mock("@/lib/backend/api", () => apiMock);
+
+const { useExportTracker } = await import("../../apps/desktop/src/composables/useExportTracker.ts");
+
+test("tracks database export progress and cancels through database export API", async () => {
+  const tracker = useExportTracker();
+  const task = tracker.addDatabaseExportTask("db-export-1", "app", "/tmp/app.sql");
+
+  tracker.updateDatabaseExportTask("db-export-1", {
+    exportId: "db-export-1",
+    currentObject: "users",
+    objectIndex: 2,
+    totalObjects: 5,
+    rowsExported: 120,
+    totalRows: null,
+    status: "Running",
+    error: null,
+  });
+
+  assert.equal(task.kind, "database-export");
+  assert.equal(task.tableName, "users");
+  assert.equal(task.objectIndex, 2);
+  assert.equal(task.totalObjects, 5);
+  assert.equal(tracker.activeCount.value, 1);
+
+  await tracker.cancelTask("db-export-1");
+  assert.equal(apiMock.cancelDatabaseExport.mock.calls[0][0], "db-export-1");
+
+  tracker.clearFinished();
+  assert.equal(
+    tracker.tasks.value.some((item) => item.exportId === "db-export-1"),
+    true,
+  );
+});
+
+test("tracks SQL file progress and clears terminal tasks", () => {
+  const tracker = useExportTracker();
+  const task = tracker.addSqlFileTask("sql-1", "init.sql", "/tmp/init.sql");
+
+  tracker.updateSqlFileTask("sql-1", {
+    executionId: "sql-1",
+    status: "statementDone",
+    statementIndex: 3,
+    successCount: 2,
+    failureCount: 1,
+    affectedRows: 12,
+    elapsedMs: 1500,
+    statementSummary: "insert into users...",
+    error: null,
+  });
+
+  assert.equal(task.kind, "sql-file");
+  assert.equal(task.status, "Running");
+  assert.equal(task.rowsExported, 3);
+  assert.equal(task.totalRows, 3);
+  assert.equal(task.affectedRows, 12);
+
+  tracker.updateSqlFileTask("sql-1", {
+    executionId: "sql-1",
+    status: "done",
+    statementIndex: 3,
+    successCount: 3,
+    failureCount: 0,
+    affectedRows: 16,
+    elapsedMs: 2000,
+    statementSummary: "",
+    error: null,
+  });
+
+  assert.equal(task.status, "Done");
+  tracker.clearFinished();
+  assert.equal(
+    tracker.tasks.value.some((item) => item.exportId === "sql-1"),
+    false,
+  );
+});
+
+test("keeps the legacy table export task API and routes cancel to table export API", async () => {
+  const tracker = useExportTracker();
+  const task = tracker.addTask("orders", "csv", "/tmp/orders.csv");
+
+  tracker.updateTableExportTask(task.exportId, {
+    exportId: task.exportId,
+    tableName: "orders",
+    rowsExported: 10,
+    totalRows: 20,
+    status: "Writing",
+    errorMessage: null,
+  });
+
+  assert.equal(task.kind, "table-export");
+  assert.equal(task.status, "Writing");
+  assert.equal(task.rowsExported, 10);
+
+  await tracker.cancelTask(task.exportId);
+  assert.equal(apiMock.cancelTableExport.mock.calls[0][0], task.exportId);
+});
+
+test("tracks data transfer progress and routes cancel to transfer API", async () => {
+  const tracker = useExportTracker();
+  const task = tracker.addDataTransferTask("transfer-1", "source → target", 4);
+
+  tracker.updateDataTransferTask("transfer-1", {
+    transferId: "transfer-1",
+    table: "users",
+    tableIndex: 2,
+    totalTables: 4,
+    rowsTransferred: 250,
+    totalRows: 500,
+    status: "running",
+    error: null,
+    terminal: false,
+  });
+
+  assert.equal(task.kind, "data-transfer");
+  assert.equal(task.currentTable, "users");
+  assert.equal(task.tableIndex, 2);
+  assert.equal(task.totalTables, 4);
+  assert.equal(task.rowsExported, 250);
+  assert.equal(task.totalRows, 500);
+  assert.equal(task.status, "Running");
+
+  await tracker.cancelTask("transfer-1");
+  assert.equal(apiMock.cancelTransfer.mock.calls[0][0], "transfer-1");
+});
+
+test("keeps data transfer active after a non-terminal table error", () => {
+  const tracker = useExportTracker();
+  const task = tracker.addDataTransferTask("transfer-error-1", "source → target", 2);
+
+  tracker.updateDataTransferTask("transfer-error-1", {
+    transferId: "transfer-error-1",
+    table: "users",
+    tableIndex: 0,
+    totalTables: 2,
+    rowsTransferred: 0,
+    totalRows: null,
+    status: "error",
+    error: "permission denied",
+    terminal: false,
+  });
+
+  assert.equal(task.status, "Running");
+  assert.equal(task.errorMessage, "permission denied");
+
+  tracker.clearFinished();
+  assert.equal(
+    tracker.tasks.value.some((item) => item.exportId === "transfer-error-1"),
+    true,
+  );
+
+  tracker.updateDataTransferTask("transfer-error-1", {
+    transferId: "transfer-error-1",
+    table: "orders",
+    tableIndex: 1,
+    totalTables: 2,
+    rowsTransferred: 10,
+    totalRows: 50,
+    status: "running",
+    error: null,
+    terminal: false,
+  });
+
+  assert.equal(task.status, "Running");
+  assert.equal(task.errorMessage, "permission denied");
+  assert.equal(task.currentTable, "orders");
+  assert.equal(task.tableIndex, 1);
+  assert.equal(task.rowsExported, 10);
+});
+
+test("marks data transfer failed only on terminal error summary", () => {
+  const tracker = useExportTracker();
+  const task = tracker.addDataTransferTask("transfer-terminal-error-1", "source → target", 2);
+
+  tracker.updateDataTransferTask("transfer-terminal-error-1", {
+    transferId: "transfer-terminal-error-1",
+    table: "users",
+    tableIndex: 0,
+    totalTables: 2,
+    rowsTransferred: 0,
+    totalRows: null,
+    status: "error",
+    error: "permission denied",
+    terminal: false,
+  });
+  tracker.updateDataTransferTask("transfer-terminal-error-1", {
+    transferId: "transfer-terminal-error-1",
+    table: "",
+    tableIndex: 2,
+    totalTables: 2,
+    rowsTransferred: 0,
+    totalRows: null,
+    status: "error",
+    error: "1 table(s) failed: users",
+    terminal: true,
+  });
+
+  assert.equal(task.status, "Error");
+  assert.equal(task.errorMessage, "1 table(s) failed: users");
+  assert.equal(task.tableIndex, 2);
+});
+
+test("keeps data transfer row counts when terminal summary does not include rows", () => {
+  const tracker = useExportTracker();
+  const task = tracker.addDataTransferTask("transfer-rows-1", "source → target", 1);
+
+  tracker.updateDataTransferTask("transfer-rows-1", {
+    transferId: "transfer-rows-1",
+    table: "users",
+    tableIndex: 0,
+    totalTables: 1,
+    rowsTransferred: 200,
+    totalRows: 200,
+    status: "tableDone",
+    error: null,
+    terminal: false,
+  });
+  tracker.updateDataTransferTask("transfer-rows-1", {
+    transferId: "transfer-rows-1",
+    table: "",
+    tableIndex: 1,
+    totalTables: 1,
+    rowsTransferred: 0,
+    totalRows: null,
+    status: "done",
+    error: null,
+    terminal: true,
+  });
+
+  assert.equal(task.status, "Done");
+  assert.equal(task.rowsExported, 200);
+  assert.equal(task.totalRows, 200);
+  assert.equal(task.tableIndex, 1);
+});
+
+test("starts independent data transfer background tasks and routes progress by transfer id", async () => {
+  const tracker = useExportTracker();
+  const callbacks = new Map<string, (progress: any) => void>();
+  const resolvers = new Map<string, () => void>();
+  const onDone = vi.fn();
+
+  apiMock.startTransfer.mockImplementation((request: any, onProgress: (progress: any) => void) => {
+    callbacks.set(request.transferId, onProgress);
+    return new Promise<void>((resolve) => resolvers.set(request.transferId, resolve));
+  });
+
+  const firstRequest = {
+    transferId: "parallel-transfer-1",
+    sourceConnectionId: "source-a",
+    sourceDatabase: "app_a",
+    sourceSchema: "public",
+    targetConnectionId: "target-a",
+    targetDatabase: "warehouse_a",
+    targetSchema: "public",
+    tables: ["users"],
+    createTable: true,
+    mode: "append",
+    targetTableNameCase: "preserve",
+    batchSize: 1000,
+  };
+  const secondRequest = {
+    ...firstRequest,
+    transferId: "parallel-transfer-2",
+    sourceDatabase: "app_b",
+    targetDatabase: "warehouse_b",
+    tables: ["orders"],
+  };
+
+  const firstTask = tracker.startDataTransferTask(firstRequest, "app_a → warehouse_a", { onDone });
+  const secondTask = tracker.startDataTransferTask(secondRequest, "app_b → warehouse_b");
+
+  assert.equal(apiMock.startTransfer.mock.calls.at(-2)?.[0].transferId, "parallel-transfer-1");
+  assert.equal(apiMock.startTransfer.mock.calls.at(-1)?.[0].transferId, "parallel-transfer-2");
+
+  callbacks.get("parallel-transfer-2")?.({
+    transferId: "parallel-transfer-2",
+    table: "orders",
+    tableIndex: 0,
+    totalTables: 1,
+    rowsTransferred: 40,
+    totalRows: 100,
+    status: "running",
+    error: null,
+    terminal: false,
+  });
+  callbacks.get("parallel-transfer-1")?.({
+    transferId: "parallel-transfer-1",
+    table: "users",
+    tableIndex: 0,
+    totalTables: 1,
+    rowsTransferred: 10,
+    totalRows: 50,
+    status: "running",
+    error: null,
+    terminal: false,
+  });
+
+  assert.equal(firstTask.currentTable, "users");
+  assert.equal(firstTask.rowsExported, 10);
+  assert.equal(secondTask.currentTable, "orders");
+  assert.equal(secondTask.rowsExported, 40);
+
+  callbacks.get("parallel-transfer-1")?.({
+    transferId: "parallel-transfer-1",
+    table: "",
+    tableIndex: 1,
+    totalTables: 1,
+    rowsTransferred: 50,
+    totalRows: 50,
+    status: "done",
+    error: null,
+    terminal: true,
+  });
+  resolvers.get("parallel-transfer-1")?.();
+  await new Promise((resolve) => setTimeout(resolve, 0));
+
+  assert.equal(firstTask.status, "Done");
+  assert.equal(secondTask.status, "Running");
+  assert.equal(onDone.mock.calls.length, 1);
+});
+
+test("blocks concurrent data transfers that write the same target table", () => {
+  const tracker = useExportTracker();
+  apiMock.startTransfer.mockImplementation(() => new Promise<void>(() => {}));
+
+  const firstRequest = {
+    transferId: "same-target-transfer-1",
+    sourceConnectionId: "source-a",
+    sourceDatabase: "app_a",
+    sourceSchema: "public",
+    targetConnectionId: "target-a",
+    targetDatabase: "warehouse",
+    targetSchema: "public",
+    tables: ["users"],
+    createTable: true,
+    mode: "append",
+    targetTableNameCase: "preserve",
+    batchSize: 1000,
+  };
+  const secondRequest = {
+    ...firstRequest,
+    transferId: "same-target-transfer-2",
+    sourceDatabase: "app_b",
+  };
+
+  const firstTask = tracker.startDataTransferTask(firstRequest, "app_a → warehouse");
+  const secondTask = tracker.startDataTransferTask(secondRequest, "app_b → warehouse");
+
+  assert.equal(firstTask.status, "Running");
+  assert.equal(secondTask.status, "Error");
+  assert.match(secondTask.errorMessage ?? "", /already running/);
+
+  tracker.updateDataTransferTask("same-target-transfer-1", {
+    transferId: "same-target-transfer-1",
+    table: "",
+    tableIndex: 1,
+    totalTables: 1,
+    rowsTransferred: 0,
+    totalRows: null,
+    status: "done",
+    error: null,
+    terminal: true,
+  });
+});
diff --git a/packages/app-tests/useFlatTree.test.ts b/packages/app-tests/useFlatTree.test.ts
new file mode 100644
index 0000000..d3bcfea
--- /dev/null
+++ b/packages/app-tests/useFlatTree.test.ts
@@ -0,0 +1,68 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { SIDEBAR_TREE_ROW_HEIGHT, SIDEBAR_TREE_PRERENDER_COUNT, SIDEBAR_TREE_SCROLL_BUFFER, flattenTree, shouldVirtualizeFlatTree } from "../../apps/desktop/src/composables/useFlatTree.ts";
+import type { TreeNode } from "../../apps/desktop/src/types/database.ts";
+
+test("flattenTree preserves depth and node type for virtualized sidebar rows", () => {
+  const nodes: TreeNode[] = [
+    {
+      id: "conn",
+      label: "Connection",
+      type: "connection",
+      isExpanded: true,
+      children: [
+        { id: "conn:file", label: "Query.sql", type: "saved-sql-file" },
+        {
+          id: "conn:db",
+          label: "db",
+          type: "database",
+          isExpanded: true,
+          children: [{ id: "conn:db:table", label: "table", type: "table" }],
+        },
+      ],
+    },
+  ];
+
+  const flat = flattenTree(nodes);
+
+  assert.deepEqual(
+    flat.map((item) => ({ id: item.id, depth: item.depth, type: item.type })),
+    [
+      { id: "conn", depth: 0, type: "connection" },
+      { id: "conn:file", depth: 1, type: "saved-sql-file" },
+      { id: "conn:db", depth: 1, type: "database" },
+      { id: "conn:db:table", depth: 2, type: "table" },
+    ],
+  );
+});
+
+test("connection groups use per-node pool types to avoid recycled row state", () => {
+  const nodes: TreeNode[] = [
+    { id: "g1", label: "Group 1", type: "connection-group", isExpanded: false },
+    { id: "g2", label: "Group 2", type: "connection-group", isExpanded: false },
+    { id: "c1", label: "Connection", type: "connection", isExpanded: false },
+  ];
+
+  const flat = flattenTree(nodes);
+
+  assert.equal(flat[0].type, "connection-group");
+  assert.equal(flat[1].type, "connection-group");
+  assert.notEqual(flat[0].poolType, flat[1].poolType);
+  assert.equal(flat[2].poolType, "connection");
+});
+
+test("shouldVirtualizeFlatTree virtualizes every non-empty sidebar tree", () => {
+  assert.equal(shouldVirtualizeFlatTree(0), false);
+  assert.equal(shouldVirtualizeFlatTree(1), true);
+  assert.equal(shouldVirtualizeFlatTree(100), true);
+});
+
+test("sidebar virtual tree keeps enough buffered rows for fast scrolling", () => {
+  assert.equal(SIDEBAR_TREE_ROW_HEIGHT, 28);
+  assert.equal(SIDEBAR_TREE_SCROLL_BUFFER, 600);
+  assert.ok(SIDEBAR_TREE_SCROLL_BUFFER >= SIDEBAR_TREE_ROW_HEIGHT * 20);
+});
+
+test("sidebar virtual tree prerenders enough rows for the first frame", () => {
+  assert.ok(SIDEBAR_TREE_PRERENDER_COUNT >= 40);
+});
diff --git a/packages/app-tests/useSqlExecution.test.ts b/packages/app-tests/useSqlExecution.test.ts
new file mode 100644
index 0000000..4cfe14c
--- /dev/null
+++ b/packages/app-tests/useSqlExecution.test.ts
@@ -0,0 +1,68 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { isDangerousSql, stripSqlComments } from "../../apps/desktop/src/composables/useSqlExecution.ts";
+
+test("stripSqlComments removes block comments", () => {
+  assert.equal(stripSqlComments("SELECT /* drop */ 1").includes("drop"), false);
+});
+
+test("stripSqlComments removes line comments", () => {
+  assert.equal(stripSqlComments("SELECT 1 -- DROP TABLE").includes("DROP"), false);
+});
+
+test("stripSqlComments removes MySQL hash comments", () => {
+  assert.equal(stripSqlComments("SELECT 1 # DELETE").includes("DELETE"), false);
+});
+
+test("SELECT with REPLACE function is not dangerous", () => {
+  assert.equal(isDangerousSql("SELECT REPLACE(col, ';', ',') FROM t"), false);
+});
+
+test("SELECT with TRUNCATE function is not dangerous", () => {
+  assert.equal(isDangerousSql("SELECT TRUNCATE(1.234, 2)"), false);
+});
+
+test("REPLACE INTO is dangerous", () => {
+  assert.equal(isDangerousSql("REPLACE INTO t VALUES (1, 2)"), true);
+});
+
+test("DELETE FROM is dangerous", () => {
+  assert.equal(isDangerousSql("DELETE FROM t WHERE id = 1"), true);
+});
+
+test("DROP TABLE is dangerous", () => {
+  assert.equal(isDangerousSql("DROP TABLE t"), true);
+});
+
+test("UPDATE is dangerous", () => {
+  assert.equal(isDangerousSql("UPDATE t SET col = 1"), true);
+});
+
+test("ALTER TABLE is dangerous", () => {
+  assert.equal(isDangerousSql("ALTER TABLE t ADD COLUMN c INT"), true);
+});
+
+test("TRUNCATE TABLE is dangerous", () => {
+  assert.equal(isDangerousSql("TRUNCATE TABLE t"), true);
+});
+
+test("multi-statement with danger in second statement is dangerous", () => {
+  assert.equal(isDangerousSql("SELECT 1; DROP TABLE t"), true);
+});
+
+test("danger keyword inside comment is not dangerous", () => {
+  assert.equal(isDangerousSql("SELECT 1 /* DROP TABLE t */"), false);
+});
+
+test("leading whitespace before danger keyword is dangerous", () => {
+  assert.equal(isDangerousSql("  DELETE FROM t"), true);
+});
+
+test("complex SELECT with joins and functions is not dangerous", () => {
+  const sql = `select mkey, replace(xxxx,';',',') as xxxx_content,
+    SUBSTRING_INDEX(SUBSTRING_INDEX(pmid,'/',3),'/',-1) as xxx
+    from m_xxx left join (
+      select xxx from m_alarm where alarm_time >= SUBDATE(now(), interval 3 minute)
+    ) as xxxx on m_alarm.mid = m_alarm_tmp.mid`;
+  assert.equal(isDangerousSql(sql), false);
+});
diff --git a/packages/app-tests/webdavAutoUpload.test.ts b/packages/app-tests/webdavAutoUpload.test.ts
new file mode 100644
index 0000000..a55a25c
--- /dev/null
+++ b/packages/app-tests/webdavAutoUpload.test.ts
@@ -0,0 +1,134 @@
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, test, vi } from "vitest";
+import { createPinia, setActivePinia } from "pinia";
+import { useWebDavAutoUpload } from "@/composables/useWebDavAutoUpload";
+import { readWebDavAutoUploadConfig } from "@/lib/webdav/webdavAutoUploadConfig";
+
+const { webdavSyncUploadMock } = vi.hoisted(() => ({
+  webdavSyncUploadMock: vi.fn(),
+}));
+
+vi.mock("vue", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("vue")>();
+  return {
+    ...actual,
+    onMounted: (hook: () => void) => hook(),
+    onUnmounted: vi.fn(),
+  };
+});
+
+vi.mock("@/lib/backend/api", () => ({
+  webdavSyncUpload: webdavSyncUploadMock,
+}));
+
+function installLocalStorage() {
+  const original = Object.getOwnPropertyDescriptor(globalThis, "localStorage");
+  const store = new Map<string, string>();
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: {
+      getItem: (key: string) => store.get(key) ?? null,
+      setItem: (key: string, value: string) => {
+        store.set(key, value);
+      },
+      removeItem: (key: string) => {
+        store.delete(key);
+      },
+      clear: () => {
+        store.clear();
+      },
+    },
+  });
+  return () => {
+    if (original) Object.defineProperty(globalThis, "localStorage", original);
+    else Reflect.deleteProperty(globalThis, "localStorage");
+  };
+}
+
+let restoreLocalStorage: (() => void) | undefined;
+let restoreWindow: (() => void) | undefined;
+
+function installWindow() {
+  const original = Object.getOwnPropertyDescriptor(globalThis, "window");
+  const listeners = new Map<string, Set<(event: Event) => void>>();
+  Object.defineProperty(globalThis, "window", {
+    configurable: true,
+    value: {
+      setInterval: globalThis.setInterval.bind(globalThis),
+      clearInterval: globalThis.clearInterval.bind(globalThis),
+      addEventListener: (type: string, listener: (event: Event) => void) => {
+        const set = listeners.get(type) ?? new Set();
+        set.add(listener);
+        listeners.set(type, set);
+      },
+      removeEventListener: (type: string, listener: (event: Event) => void) => {
+        listeners.get(type)?.delete(listener);
+      },
+      dispatchEvent: (event: Event) => {
+        listeners.get(event.type)?.forEach((listener) => listener(event));
+        return true;
+      },
+    },
+  });
+  return () => {
+    if (original) Object.defineProperty(globalThis, "window", original);
+    else Reflect.deleteProperty(globalThis, "window");
+  };
+}
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  webdavSyncUploadMock.mockResolvedValue({ bytes: 42, remotePath: "DBX/sync/snapshot.json" });
+  restoreLocalStorage = installLocalStorage();
+  restoreWindow = installWindow();
+  setActivePinia(createPinia());
+});
+
+afterEach(() => {
+  restoreWindow?.();
+  restoreWindow = undefined;
+  restoreLocalStorage?.();
+  restoreLocalStorage = undefined;
+  vi.useRealTimers();
+  vi.clearAllMocks();
+});
+
+test("reads normalized WebDAV auto-upload config from localStorage", () => {
+  localStorage.setItem("dbx-webdav-endpoint", " https://dav.example.com/ ");
+  localStorage.setItem("dbx-webdav-username", " alice ");
+  localStorage.setItem("dbx-webdav-auto-upload-enabled", "true");
+  localStorage.setItem("dbx-webdav-auto-upload-interval-minutes", "0");
+
+  const config = readWebDavAutoUploadConfig();
+
+  assert.equal(config.enabled, true);
+  assert.equal(config.intervalMinutes, 1);
+  assert.deepEqual(config.webDavConfig, {
+    endpoint: "https://dav.example.com/",
+    username: "alice",
+    remotePath: "DBX/sync/snapshot.json",
+  });
+});
+
+test("keeps WebDAV auto-upload running outside the settings dialog", async () => {
+  localStorage.setItem("dbx-webdav-endpoint", "https://dav.example.com/");
+  localStorage.setItem("dbx-webdav-auto-upload-enabled", "true");
+  localStorage.setItem("dbx-webdav-auto-upload-interval-minutes", "1");
+
+  useWebDavAutoUpload();
+
+  await vi.advanceTimersByTimeAsync(60_000);
+
+  assert.equal(webdavSyncUploadMock.mock.calls.length, 1);
+  assert.deepEqual(webdavSyncUploadMock.mock.calls[0][0], {
+    endpoint: "https://dav.example.com/",
+    username: undefined,
+    remotePath: "DBX/sync/snapshot.json",
+  });
+
+  localStorage.setItem("dbx-webdav-auto-upload-enabled", "false");
+  window.dispatchEvent(new Event("dbx:webdav-auto-upload-config-changed"));
+  await vi.advanceTimersByTimeAsync(60_000);
+
+  assert.equal(webdavSyncUploadMock.mock.calls.length, 1);
+});
diff --git a/packages/app-tests/xlsxExport.test.ts b/packages/app-tests/xlsxExport.test.ts
new file mode 100644
index 0000000..20c6b5f
--- /dev/null
+++ b/packages/app-tests/xlsxExport.test.ts
@@ -0,0 +1,35 @@
+import { strict as assert } from "node:assert";
+import { test } from "vitest";
+import { buildXlsxWorkbook } from "../../apps/desktop/src/lib/export/xlsxExport.ts";
+
+test("builds an xlsx workbook zip with worksheet data", () => {
+  const workbook = buildXlsxWorkbook({
+    sheetName: "Users",
+    columns: ["id", "name", "active"],
+    rows: [
+      [1, "Ada & Bob", true],
+      [2, null, false],
+    ],
+  });
+  const text = new TextDecoder().decode(workbook);
+
+  assert.equal(workbook[0], 0x50);
+  assert.equal(workbook[1], 0x4b);
+  assert.match(text, /\[Content_Types\]\.xml/);
+  assert.match(text, /xl\/worksheets\/sheet1\.xml/);
+  assert.match(text, /name="Users"/);
+  assert.match(text, /<c r="A2"><v>1<\/v><\/c>/);
+  assert.match(text, /Ada &amp; Bob/);
+  assert.match(text, /<c r="C2" t="b"><v>1<\/v><\/c>/);
+});
+
+test("sanitizes invalid sheet names", () => {
+  const workbook = buildXlsxWorkbook({
+    sheetName: "bad/name:with*chars?and-a-very-long-tail",
+    columns: ["value"],
+    rows: [["ok"]],
+  });
+  const text = new TextDecoder().decode(workbook);
+
+  assert.match(text, /name="bad name with chars and-a-very-"/);
+});
diff --git a/packages/cli/README.md b/packages/cli/README.md
new file mode 100644
index 0000000..158a066
--- /dev/null
+++ b/packages/cli/README.md
@@ -0,0 +1,132 @@
+# DBX CLI
+
+Command line interface for DBX database connections, schema inspection, safe queries, and prompt-ready schema context.
+
+## Install
+
+### npm
+
+```bash
+npm install -g @dbx-app/cli
+```
+
+### Homebrew
+
+```bash
+brew tap t8y2/dbx
+brew install dbx-cli
+```
+
+Requires Node.js 22.13.0 or newer.
+
+## Usage
+
+```bash
+dbx doctor
+dbx capabilities
+dbx connections list --json
+dbx connections list --format csv
+dbx schema list local --json
+dbx schema describe local users --json
+dbx query local "select count(*) as total from users" --json
+dbx query local "select id, name from users" --format csv
+dbx query local "select * from users" --limit 50 --timeout 10s --json
+dbx query local --file ./query.sql --json
+dbx context local --tables users,orders
+dbx open local users
+```
+
+## Commands
+
+| Command                                     | Description                                           |
+| ------------------------------------------- | ----------------------------------------------------- |
+| `dbx doctor`                                | Show local DBX config and desktop bridge diagnostics  |
+| `dbx capabilities`                          | Show direct-query and desktop-bridge database support |
+| `dbx connections list`                      | List DBX connections without printing secrets         |
+| `dbx schema list <connection>`              | List tables and views                                 |
+| `dbx schema describe <connection> <table>`  | Show table columns                                    |
+| `dbx query <connection> <sql>`              | Execute one SQL statement                             |
+| `dbx query <connection> --file ./query.sql` | Execute SQL from a file                               |
+| `dbx context <connection>`                  | Print compact schema context for prompts              |
+| `dbx open <connection> <table>`             | Open a table in DBX Desktop                           |
+
+## Output
+
+Use `--json` or `--format json` for stable machine-readable output. Use `--format csv` for query, connection, and schema data that should be piped into other command line tools.
+
+Errors are written to stderr and return a non-zero exit code.
+
+## Query Controls
+
+`dbx query` is read-only by default.
+
+Use `--limit <n>` to control returned query rows and `--timeout <duration>` to control query timeout. Durations accept `ms`, `s`, or `m`, such as `500ms`, `10s`, or `1m`.
+
+Use `--allow-writes` for non-dangerous write statements. Dangerous SQL such as `DROP`, `TRUNCATE`, and `ALTER` requires both `--allow-writes` and `--allow-dangerous-sql`.
+
+For SQL that starts with a dash, pass `--` before the SQL:
+
+```bash
+dbx query local --json -- "-- comment
+select 1"
+```
+
+## Default Connection
+
+Set `DBX_CONNECTION` to omit the connection name for query and context commands:
+
+```bash
+DBX_CONNECTION=local dbx query "select 1" --json
+DBX_CONNECTION=local dbx context --tables users,orders
+```
+
+## Desktop App Requirements
+
+Some CLI commands can run without DBX Desktop:
+
+- `connections list`
+- `schema list`
+- `schema describe`
+- `query`
+- `context`
+
+Direct execution currently supports PostgreSQL/Redshift, MySQL-compatible databases (MySQL, Doris, StarRocks), and SQLite. Other database types use the DBX Desktop bridge until their drivers are added to `@dbx-app/node-core`.
+
+Use `dbx doctor` to check whether the DBX connection database, connection table, native SQLite loader, and desktop bridge are available. Use `dbx capabilities` to list direct-query and bridge-required database types.
+
+If `dbx doctor` reports a `NODE_MODULE_VERSION` mismatch after switching Node.js versions, rebuild the native dependencies with the Node.js version you use to run `dbx`:
+
+```bash
+pnpm rebuild better-sqlite3 keytar --pending
+```
+
+For global npm installs, reinstall the CLI with the same Node.js version:
+
+```bash
+npm uninstall -g @dbx-app/cli
+npm install -g @dbx-app/cli
+```
+
+## Error Codes
+
+CLI JSON errors use stable codes:
+
+| Code                     | Meaning                                             |
+| ------------------------ | --------------------------------------------------- |
+| `UNKNOWN_OPTION`         | An unsupported flag was provided                    |
+| `INVALID_OPTION`         | A flag is missing a value or has an invalid value   |
+| `INVALID_ARGUMENT`       | Positional arguments are missing or conflicting     |
+| `CONNECTION_STORE_ERROR` | DBX connection storage exists but could not be read |
+| `CONNECTION_NOT_FOUND`   | No DBX connection matched the requested name        |
+| `SQL_BLOCKED`            | SQL safety rules blocked execution                  |
+| `DBX_NOT_RUNNING`        | DBX Desktop bridge is unavailable                   |
+| `ERROR`                  | Unexpected runtime failure                          |
+
+## Codex
+
+Codex can call the CLI directly from shell tools:
+
+```bash
+dbx schema describe local users --json
+dbx context local --tables users,orders | codex exec "Write a retention query"
+```
diff --git a/packages/cli/package.json b/packages/cli/package.json
new file mode 100644
index 0000000..82cfad2
--- /dev/null
+++ b/packages/cli/package.json
@@ -0,0 +1,47 @@
+{
+  "name": "@dbx-app/cli",
+  "version": "0.4.28",
+  "description": "Command line interface for DBX database connections, schema, and safe queries",
+  "keywords": [
+    "ai-agent",
+    "automation",
+    "cli",
+    "codex",
+    "database",
+    "dbx",
+    "mysql",
+    "postgresql",
+    "terminal"
+  ],
+  "homepage": "https://github.com/t8y2/dbx/tree/main/packages/cli",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/t8y2/dbx",
+    "directory": "packages/cli"
+  },
+  "bin": {
+    "dbx": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "scripts": {
+    "start": "tsx src/cli.ts",
+    "test": "pnpm --filter @dbx-app/node-core build && vitest run --config vitest.config.ts",
+    "build": "pnpm --filter @dbx-app/node-core build && tsc",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "@dbx-app/node-core": "workspace:^"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  }
+}
diff --git a/packages/cli/src/cli-format.ts b/packages/cli/src/cli-format.ts
new file mode 100644
index 0000000..6a26fad
--- /dev/null
+++ b/packages/cli/src/cli-format.ts
@@ -0,0 +1,62 @@
+import { formatCell, mdTable, type ConnectionConfig } from "@dbx-app/node-core";
+
+export { formatCell, mdTable };
+
+export interface ConnectionSummary {
+  name: string;
+  type: string;
+  host: string;
+  port: number;
+  database?: string;
+}
+
+export function connectionSummary(connection: ConnectionConfig): ConnectionSummary {
+  return {
+    name: connection.name,
+    type: connection.db_type,
+    host: connection.host,
+    port: connection.port,
+    database: connection.database || undefined,
+  };
+}
+
+export interface ErrorPayload {
+  error: {
+    code: string;
+    message: string;
+    hint?: string;
+  };
+}
+
+export function errorPayload(code: string, message: string): ErrorPayload {
+  const hint = errorHint(code, message);
+  return { error: hint ? { code, message, hint } : { code, message } };
+}
+
+export function formatErrorMessage(code: string, message: string): string {
+  const hint = errorHint(code, message);
+  return hint ? `${message}\n\nHint: ${hint}` : message;
+}
+
+function errorHint(code: string, message: string): string | undefined {
+  if (code === "CONNECTION_STORE_ERROR" && /NODE_MODULE_VERSION|compiled against a different Node\.js version/i.test(message)) {
+    return "Rebuild DBX CLI native dependencies with your active Node.js: pnpm rebuild better-sqlite3 keytar --pending, or reinstall the package with the same Node.js version you use to run dbx.";
+  }
+  return undefined;
+}
+
+export function csvTable<T extends object>(headers: string[], rows: T[]): string {
+  const lines = [headers.map(csvCell).join(",")];
+  for (const row of rows) {
+    const values = row as Record<string, unknown>;
+    lines.push(headers.map((header) => csvCell(values[header])).join(","));
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+function csvCell(value: unknown): string {
+  if (value === null || value === undefined) return "";
+  const text = typeof value === "object" ? JSON.stringify(value) : String(value);
+  if (/[",\r\n]/.test(text)) return `"${text.replace(/"/g, '""')}"`;
+  return text;
+}
diff --git a/packages/cli/src/cli.ts b/packages/cli/src/cli.ts
new file mode 100644
index 0000000..ae85200
--- /dev/null
+++ b/packages/cli/src/cli.ts
@@ -0,0 +1,409 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { buildSchemaContext, createBackend, DIRECT_QUERY_TYPES, BRIDGE_REQUIRED_TYPES, evaluateSqlSafety, formatSchemaContext, getDbxDiagnostics, isMainModule, postBridge, type Backend, type DbxDiagnostics, type SqlSafetyOptions } from "@dbx-app/node-core";
+import { connectionSummary, csvTable, errorPayload, formatCell, formatErrorMessage, mdTable } from "./cli-format.js";
+
+export interface CliResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+interface RunOptions {
+  backend?: Backend;
+  backendFactory?: (env?: NodeJS.ProcessEnv) => Promise<Backend>;
+  env?: NodeJS.ProcessEnv;
+  diagnostics?: () => Promise<DbxDiagnostics>;
+}
+
+interface ParsedFlags {
+  args: string[];
+  json: boolean;
+  format: "table" | "json" | "csv";
+  schema?: string;
+  database?: string;
+  tables?: string[];
+  maxTables?: number;
+  maxRows?: number;
+  timeoutMs?: number;
+  file?: string;
+  allowWrites: boolean;
+  allowDangerous: boolean;
+  help: boolean;
+  version: boolean;
+}
+
+class CliError extends Error {
+  constructor(
+    readonly code: string,
+    message: string,
+  ) {
+    super(message);
+  }
+}
+
+export async function runCli(argv: string[], options: RunOptions = {}): Promise<CliResult> {
+  const env = options.env ?? process.env;
+  let ownedBackend: Backend | undefined;
+
+  try {
+    const flags = parseFlags(argv);
+    const args = flags.args;
+
+    if (flags.version) {
+      return ok(`${await packageVersion()}\n`);
+    }
+
+    if (args.length === 0 || flags.help || args[0] === "help") {
+      return ok(`${usage()}\n`);
+    }
+
+    const backendFactory = options.backendFactory ?? createBackend;
+    const backend = options.backend ?? (ownedBackend = await backendFactory(env));
+
+    if (args[0] === "doctor") {
+      ensureArgCount(args, 1, "dbx doctor");
+      const diagnostics = await (options.diagnostics ?? getDbxDiagnostics)();
+      if (flags.format === "json") return okJson(diagnostics);
+      if (flags.format === "csv") {
+        return ok(
+          csvTable(
+            ["check", "value"],
+            [
+              { check: "appDataDir", value: diagnostics.appDataDir },
+              { check: "dbPath", value: diagnostics.dbPath },
+              { check: "dbPathExists", value: diagnostics.dbPathExists },
+              { check: "connectionsTableExists", value: diagnostics.connectionsTableExists },
+              { check: "connectionRowCount", value: diagnostics.connectionRowCount },
+              { check: "loadConnectionsOk", value: diagnostics.loadConnectionsOk },
+              { check: "loadedConnectionCount", value: diagnostics.loadedConnectionCount },
+              { check: "loadConnectionsError", value: diagnostics.loadConnectionsError ?? "" },
+              { check: "loadConnectionsHint", value: diagnostics.loadConnectionsHint ?? "" },
+              { check: "bridgePortFile", value: diagnostics.bridgePortFile },
+              { check: "bridgePortFileExists", value: diagnostics.bridgePortFileExists },
+              { check: "bridgeUrl", value: diagnostics.bridgeUrl ?? "" },
+            ],
+          ),
+        );
+      }
+      return ok(formatDoctor(diagnostics));
+    }
+
+    if (args[0] === "capabilities") {
+      ensureArgCount(args, 1, "dbx capabilities");
+      const payload = {
+        directQueryTypes: [...DIRECT_QUERY_TYPES],
+        bridgeRequiredTypes: [...BRIDGE_REQUIRED_TYPES],
+      };
+      if (flags.format === "json") return okJson(payload);
+      if (flags.format === "csv") {
+        return ok(csvTable(["mode", "type"], [...payload.directQueryTypes.map((type) => ({ mode: "direct", type })), ...payload.bridgeRequiredTypes.map((type) => ({ mode: "bridge", type }))]));
+      }
+      return ok(
+        `${mdTable(
+          ["Mode", "Types"],
+          [
+            ["Direct", payload.directQueryTypes.join(", ")],
+            ["Requires DBX Desktop", payload.bridgeRequiredTypes.join(", ")],
+          ],
+        )}\n`,
+      );
+    }
+
+    if (args[0] === "connections" && args[1] === "list") {
+      ensureArgCount(args, 2, "dbx connections list");
+      const connections = (await backend.loadConnections()).map(connectionSummary);
+      if (flags.format === "json") return okJson({ connections });
+      if (flags.format === "csv") return ok(csvTable(["name", "type", "host", "port", "database"], connections));
+      return ok(
+        `${mdTable(
+          ["Name", "Type", "Host", "Port", "Database"],
+          connections.map((c) => [c.name, c.type, c.host, String(c.port), c.database ?? ""]),
+        )}\n`,
+      );
+    }
+
+    if (args[0] === "schema" && args[1] === "list") {
+      ensureArgCount(args, 3, "dbx schema list");
+      const connectionName = required(args[2], "Connection name is required.");
+      const config = await findConnectionOrThrow(backend, connectionName);
+      const tables = await backend.listTables(config, flags.schema);
+      if (flags.format === "json") return okJson({ connection: connectionName, schema: flags.schema, tables });
+      if (flags.format === "csv") return ok(csvTable(["name", "type"], tables));
+      return ok(
+        `${mdTable(
+          ["Table", "Type"],
+          tables.map((t) => [t.name, t.type]),
+        )}\n`,
+      );
+    }
+
+    if (args[0] === "schema" && args[1] === "describe") {
+      ensureArgCount(args, 4, "dbx schema describe");
+      const connectionName = required(args[2], "Connection name is required.");
+      const table = required(args[3], "Table name is required.");
+      const config = await findConnectionOrThrow(backend, connectionName);
+      const columns = await backend.describeTable(config, table, flags.schema);
+      if (flags.format === "json") return okJson({ connection: connectionName, schema: flags.schema, table, columns });
+      if (flags.format === "csv") {
+        return ok(csvTable(["name", "data_type", "is_nullable", "is_primary_key", "column_default", "comment"], columns));
+      }
+      return ok(
+        `${mdTable(
+          ["Column", "Type", "Nullable", "Default", "Comment"],
+          columns.map((c) => [c.is_primary_key ? `${c.name} (PK)` : c.name, c.data_type, c.is_nullable ? "YES" : "NO", c.column_default ?? "", c.comment ?? ""]),
+        )}\n`,
+      );
+    }
+
+    if (args[0] === "query") {
+      const usesDefaultConnection = !!env.DBX_CONNECTION && args.length === (flags.file ? 1 : 2);
+      ensureArgCount(args, usesDefaultConnection ? (flags.file ? 1 : 2) : flags.file ? 2 : 3, "dbx query");
+      const connectionName = usesDefaultConnection ? env.DBX_CONNECTION! : required(args[1], "Connection name is required.");
+      if (flags.file && args[2]) {
+        throw new CliError("INVALID_ARGUMENT", "Provide SQL either inline or with --file, not both.");
+      }
+      const sqlArg = usesDefaultConnection ? args[1] : args[2];
+      const sql = flags.file ? await readFile(flags.file, "utf-8") : required(sqlArg, "SQL string or --file is required.");
+      const envSafety = sqlSafetyFromCliEnv(env);
+      if (flags.allowDangerous && !flags.allowWrites && !envSafety.allowWrites) {
+        throw new CliError("INVALID_OPTION", "--allow-dangerous-sql requires --allow-writes.");
+      }
+      const safetyOptions: SqlSafetyOptions = {
+        allowWrites: flags.allowWrites || envSafety.allowWrites,
+        allowDangerous: flags.allowDangerous || envSafety.allowDangerous,
+      };
+      const safety = evaluateSqlSafety(sql, safetyOptions);
+      if (!safety.allowed) return fail("SQL_BLOCKED", safety.reason ?? "SQL blocked.", flags.json);
+      const config = await findConnectionOrThrow(backend, connectionName);
+      const result = await backend.executeQuery(config, sql, { maxRows: flags.maxRows, timeoutMs: flags.timeoutMs });
+      if (flags.format === "json") {
+        return okJson({ connection: connectionName, columns: result.columns, rows: result.rows, row_count: result.row_count });
+      }
+      if (flags.format === "csv") return ok(csvTable(result.columns, result.rows));
+      if (result.columns.length === 0) return ok(`Query executed. ${result.row_count} row(s) affected.\n`);
+      return ok(
+        `${mdTable(
+          result.columns,
+          result.rows.map((row) => result.columns.map((column) => formatCell(row[column]))),
+        )}\n\n${result.row_count} row(s)\n`,
+      );
+    }
+
+    if (args[0] === "context") {
+      const usesDefaultConnection = !!env.DBX_CONNECTION && args.length === 1;
+      ensureArgCount(args, usesDefaultConnection ? 1 : 2, "dbx context");
+      const connectionName = usesDefaultConnection ? env.DBX_CONNECTION! : required(args[1], "Connection name is required.");
+      const config = await findConnectionOrThrow(backend, connectionName);
+      const context = await buildSchemaContext(backend, config, {
+        schema: flags.schema,
+        tables: flags.tables,
+        maxTables: flags.maxTables,
+      });
+      if (flags.format === "json") return okJson(context);
+      if (flags.format === "csv") throw new CliError("INVALID_OPTION", "CSV format is not supported for dbx context.");
+      return ok(`${formatSchemaContext(context)}\n`);
+    }
+
+    if (args[0] === "open") {
+      ensureArgCount(args, 3, "dbx open");
+      const connectionName = required(args[1], "Connection name is required.");
+      const table = required(args[2], "Table name is required.");
+      const response = await postBridge("/open-table", {
+        connection_name: connectionName,
+        table,
+        schema: flags.schema,
+        database: flags.database,
+      });
+      if (!response.ok) {
+        return fail("DBX_NOT_RUNNING", response.text || "DBX is not running. Please start DBX first.", flags.json);
+      }
+      if (flags.format === "json") return okJson({ opened: true, connection: connectionName, table, schema: flags.schema, database: flags.database });
+      if (flags.format === "csv") throw new CliError("INVALID_OPTION", "CSV format is not supported for dbx open.");
+      return ok(`Opened ${table} in DBX\n`);
+    }
+
+    return fail("USAGE", usage(), flags.json);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof CliError ? error.code : typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : "ERROR";
+    const wantsJson = argv.includes("--json");
+    return fail(code, message, wantsJson);
+  } finally {
+    await ownedBackend?.close?.().catch(() => {});
+  }
+}
+
+function parseFlags(argv: string[]): ParsedFlags {
+  const args: string[] = [];
+  const flags: ParsedFlags = {
+    args,
+    json: false,
+    format: "table",
+    allowWrites: false,
+    allowDangerous: false,
+    help: false,
+    version: false,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--") {
+      args.push(...argv.slice(i + 1));
+      break;
+    }
+    if (arg === "--json") {
+      flags.json = true;
+      flags.format = "json";
+    } else if (arg === "--format") flags.format = parseFormat(readOptionValue(argv, ++i, "--format"));
+    else if (arg === "--help" || arg === "-h") flags.help = true;
+    else if (arg === "--version" || arg === "-V") flags.version = true;
+    else if (arg === "--schema") flags.schema = readOptionValue(argv, ++i, "--schema");
+    else if (arg === "--database") flags.database = readOptionValue(argv, ++i, "--database");
+    else if (arg === "--tables") flags.tables = splitCsv(readOptionValue(argv, ++i, "--tables"));
+    else if (arg === "--max-tables") flags.maxTables = parsePositiveInt(readOptionValue(argv, ++i, "--max-tables"), "--max-tables");
+    else if (arg === "--limit") flags.maxRows = parsePositiveInt(readOptionValue(argv, ++i, "--limit"), "--limit");
+    else if (arg === "--timeout") flags.timeoutMs = parseDurationMs(readOptionValue(argv, ++i, "--timeout"), "--timeout");
+    else if (arg === "--file") flags.file = readOptionValue(argv, ++i, "--file");
+    else if (arg === "--allow-writes") flags.allowWrites = true;
+    else if (arg === "--allow-dangerous-sql") flags.allowDangerous = true;
+    else if (arg.startsWith("-")) throw new CliError("UNKNOWN_OPTION", `Unknown option: ${arg}`);
+    else args.push(arg);
+  }
+
+  return flags;
+}
+
+function parseFormat(value: string): "table" | "json" | "csv" {
+  if (value === "table" || value === "json" || value === "csv") return value;
+  throw new CliError("INVALID_OPTION", "--format must be one of: table, json, csv.");
+}
+
+function ensureArgCount(args: string[], count: number, command: string): void {
+  if (args.length !== count) {
+    throw new CliError("INVALID_ARGUMENT", `${command} expects ${count - 1} argument(s); received ${args.length - 1}.`);
+  }
+}
+
+function readOptionValue(argv: string[], index: number, option: string): string {
+  const value = argv[index];
+  if (!value || value.startsWith("-")) {
+    throw new CliError("INVALID_OPTION", `${option} requires a value.`);
+  }
+  return value;
+}
+
+function parsePositiveInt(value: string, option: string): number {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new CliError("INVALID_OPTION", `${option} must be a positive integer.`);
+  }
+  return parsed;
+}
+
+function parseDurationMs(value: string, option: string): number {
+  const match = value.match(/^(\d+)(ms|s|m)?$/);
+  if (!match) {
+    throw new CliError("INVALID_OPTION", `${option} must be a positive duration such as 500ms, 10s, or 1m.`);
+  }
+  const amount = Number(match[1]);
+  if (!Number.isInteger(amount) || amount < 1) {
+    throw new CliError("INVALID_OPTION", `${option} must be a positive duration such as 500ms, 10s, or 1m.`);
+  }
+  const unit = match[2] ?? "ms";
+  if (unit === "ms") return amount;
+  if (unit === "s") return amount * 1000;
+  return amount * 60_000;
+}
+
+function parseBooleanEnv(value: string | undefined): boolean {
+  if (value === undefined) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true";
+}
+
+function sqlSafetyFromCliEnv(env: NodeJS.ProcessEnv): Required<Pick<SqlSafetyOptions, "allowWrites" | "allowDangerous">> {
+  return {
+    allowWrites: parseBooleanEnv(env.DBX_MCP_ALLOW_WRITES),
+    allowDangerous: parseBooleanEnv(env.DBX_MCP_ALLOW_DANGEROUS_SQL),
+  };
+}
+
+function splitCsv(value: string | undefined): string[] {
+  return (value ?? "")
+    .split(",")
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+async function findConnectionOrThrow(backend: Backend, name: string) {
+  const config = await backend.findConnection(name);
+  if (!config) throw new CliError("CONNECTION_NOT_FOUND", `Connection "${name}" not found.`);
+  return config;
+}
+
+function required(value: string | undefined, message: string): string {
+  if (!value) throw new Error(message);
+  return value;
+}
+
+function ok(stdout: string): CliResult {
+  return { exitCode: 0, stdout, stderr: "" };
+}
+
+function okJson(payload: unknown): CliResult {
+  return ok(`${JSON.stringify(payload, null, 2)}\n`);
+}
+
+function fail(code: string, message: string, json: boolean): CliResult {
+  const text = json ? `${JSON.stringify(errorPayload(code, message), null, 2)}\n` : `${formatErrorMessage(code, message)}\n`;
+  return { exitCode: 1, stdout: "", stderr: text };
+}
+
+function usage(): string {
+  return [
+    "Usage:",
+    "  dbx doctor [--json]",
+    "  dbx capabilities [--json]",
+    "  dbx connections list [--json]",
+    "  dbx schema list <connection> [--schema name] [--json]",
+    "  dbx schema describe <connection> <table> [--schema name] [--json]",
+    "  dbx query <connection> <sql> [--file path] [--limit n] [--timeout 10s] [--allow-writes] [--allow-dangerous-sql] [--json]",
+    "  dbx context <connection> [--schema name] [--tables a,b] [--max-tables n] [--json]",
+    "  dbx open <connection> <table> [--schema name] [--database name] [--json]",
+  ].join("\n");
+}
+
+function formatDoctor(diagnostics: DbxDiagnostics): string {
+  const rows = [
+    ["App data directory", diagnostics.appDataDir],
+    ["DBX database", diagnostics.dbPathExists ? `found (${diagnostics.dbPath})` : `missing (${diagnostics.dbPath})`],
+    ["Connections table", diagnostics.connectionsTableExists ? `${diagnostics.connectionRowCount} row(s)` : "missing"],
+    ["Connection loading", diagnostics.loadConnectionsOk ? `ok (${diagnostics.loadedConnectionCount} loaded)` : `failed (${diagnostics.loadConnectionsError ?? "unknown error"})`],
+    ...(diagnostics.loadConnectionsHint ? [["Connection fix", diagnostics.loadConnectionsHint]] : []),
+    ["Desktop bridge", diagnostics.bridgePortFileExists ? `available (${diagnostics.bridgeUrl ?? diagnostics.bridgePortFile})` : "not running"],
+    ["Direct query types", diagnostics.directQueryTypes.join(", ")],
+    ["Bridge-required types", diagnostics.bridgeRequiredTypes.join(", ")],
+  ];
+  return `${mdTable(["Check", "Value"], rows)}\n`;
+}
+
+async function packageVersion(): Promise<string> {
+  const packageJson = await readFile(new URL("../package.json", import.meta.url), "utf-8");
+  const parsed = JSON.parse(packageJson) as { version?: string };
+  return parsed.version ?? "0.0.0";
+}
+
+async function main() {
+  const result = await runCli(process.argv.slice(2));
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  process.exitCode = result.exitCode;
+}
+
+if (isMainModule(import.meta.url, process.argv[1])) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  });
+}
diff --git a/packages/cli/tests/bin.test.ts b/packages/cli/tests/bin.test.ts
new file mode 100644
index 0000000..ce3f05f
--- /dev/null
+++ b/packages/cli/tests/bin.test.ts
@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, symlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { test } from "vitest";
+
+const packageDir = fileURLToPath(new URL("..", import.meta.url));
+const cliSource = fileURLToPath(new URL("../src/cli.ts", import.meta.url));
+
+test("prints version when invoked through an npm-style symlink", async () => {
+  const bin = await symlinkedCli();
+  try {
+    const result = runDbx(bin, ["--version"]);
+
+    assert.equal(result.status, 0);
+    assert.match(result.stdout, /^\d+\.\d+\.\d+\n$/);
+    assert.equal(result.stderr, "");
+  } finally {
+    await rm(bin.dir, { recursive: true, force: true });
+  }
+});
+
+test("prints capabilities when invoked through an npm-style symlink", async () => {
+  const bin = await symlinkedCli();
+  try {
+    const result = runDbx(bin, ["capabilities", "--json"]);
+
+    assert.equal(result.status, 0);
+    assert.equal(result.stderr, "");
+    const payload = JSON.parse(result.stdout) as { directQueryTypes: string[]; bridgeRequiredTypes: string[] };
+    assert.ok(payload.directQueryTypes.includes("postgres"));
+    assert.ok(payload.directQueryTypes.includes("rqlite"));
+    assert.ok(payload.bridgeRequiredTypes.includes("oracle"));
+  } finally {
+    await rm(bin.dir, { recursive: true, force: true });
+  }
+});
+
+async function symlinkedCli() {
+  const dir = await mkdtemp(join(tmpdir(), "dbx-cli-bin-"));
+  const path = join(dir, "dbx");
+  await symlink(cliSource, path);
+  return { dir, path };
+}
+
+function runDbx(bin: { path: string }, args: string[]) {
+  return spawnSync(process.execPath, ["--import", "tsx", bin.path, ...args], {
+    cwd: packageDir,
+    encoding: "utf-8",
+  });
+}
diff --git a/packages/cli/tests/cli-format.test.ts b/packages/cli/tests/cli-format.test.ts
new file mode 100644
index 0000000..32d5ba6
--- /dev/null
+++ b/packages/cli/tests/cli-format.test.ts
@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import type { ConnectionConfig } from "@dbx-app/node-core";
+import { connectionSummary, csvTable, errorPayload, formatCell, formatErrorMessage, mdTable } from "../src/cli-format.js";
+
+const connection: ConnectionConfig = {
+  id: "1",
+  name: "local",
+  db_type: "postgres",
+  host: "127.0.0.1",
+  port: 5432,
+  username: "app",
+  password: "secret",
+  database: "demo",
+  ssh_enabled: false,
+  proxy_password: "proxy-secret",
+  ssl: false,
+};
+
+test("redacts secrets from connection summaries", () => {
+  const summary = connectionSummary(connection);
+
+  assert.deepEqual(summary, {
+    name: "local",
+    type: "postgres",
+    host: "127.0.0.1",
+    port: 5432,
+    database: "demo",
+  });
+  assert.equal(JSON.stringify(summary).includes("secret"), false);
+});
+
+test("formats markdown tables", () => {
+  const table = mdTable(["Name", "Type"], [["local", "postgres"]]);
+
+  assert.match(table, /Name/);
+  assert.match(table, /postgres/);
+});
+
+test("formats database cell values with shared formatter", () => {
+  assert.equal(formatCell(null), "NULL");
+  assert.equal(formatCell({ ok: true }), '{"ok":true}');
+});
+
+test("builds stable error payloads", () => {
+  assert.deepEqual(errorPayload("SQL_BLOCKED", "read-only"), {
+    error: { code: "SQL_BLOCKED", message: "read-only" },
+  });
+});
+
+test("adds remediation hints for native SQLite ABI errors", () => {
+  assert.deepEqual(errorPayload("CONNECTION_STORE_ERROR", "NODE_MODULE_VERSION 127 mismatch"), {
+    error: {
+      code: "CONNECTION_STORE_ERROR",
+      message: "NODE_MODULE_VERSION 127 mismatch",
+      hint: "Rebuild DBX CLI native dependencies with your active Node.js: pnpm rebuild better-sqlite3 keytar --pending, or reinstall the package with the same Node.js version you use to run dbx.",
+    },
+  });
+  assert.match(formatErrorMessage("CONNECTION_STORE_ERROR", "compiled against a different Node.js version"), /Hint: Rebuild/);
+});
+
+test("formats csv tables with escaping", () => {
+  const csv = csvTable(["name", "note"], [{ name: "Ada", note: 'hello, "dbx"' }]);
+
+  assert.equal(csv, 'name,note\nAda,"hello, ""dbx"""\n');
+});
diff --git a/packages/cli/tests/cli.test.ts b/packages/cli/tests/cli.test.ts
new file mode 100644
index 0000000..b1cd7a6
--- /dev/null
+++ b/packages/cli/tests/cli.test.ts
@@ -0,0 +1,429 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "vitest";
+import type { Backend, ConnectionConfig, DbxDiagnostics } from "@dbx-app/node-core";
+import { runCli } from "../src/cli.js";
+
+const connection: ConnectionConfig = {
+  id: "1",
+  name: "local",
+  db_type: "postgres",
+  host: "127.0.0.1",
+  port: 5432,
+  username: "app",
+  password: "secret",
+  database: "demo",
+  ssh_enabled: false,
+  ssl: false,
+};
+
+function fakeBackend(overrides: Partial<Backend> = {}): Backend {
+  return {
+    loadConnections: async () => [connection],
+    findConnection: async (name) => (name === "local" ? connection : undefined),
+    addConnection: async () => connection,
+    removeConnection: async () => true,
+    listTables: async () => [{ name: "users", type: "BASE TABLE" }],
+    describeTable: async () => [
+      {
+        name: "id",
+        data_type: "integer",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: true,
+        comment: null,
+      },
+    ],
+    executeQuery: async () => ({ columns: ["total"], rows: [{ total: 1 }], row_count: 1 }),
+    ...overrides,
+  };
+}
+
+const diagnostics: DbxDiagnostics = {
+  appDataDir: "/tmp/dbx",
+  dbPath: "/tmp/dbx/dbx.db",
+  dbPathExists: true,
+  connectionsTableExists: true,
+  connectionRowCount: 2,
+  loadConnectionsOk: true,
+  loadedConnectionCount: 2,
+  bridgePortFile: "/tmp/dbx/mcp-bridge-port",
+  bridgePortFileExists: false,
+  directQueryTypes: ["postgres", "mysql", "sqlite", "rqlite"],
+  bridgeRequiredTypes: ["oracle", "mongodb"],
+};
+
+test("lists connections as json", async () => {
+  const result = await runCli(["connections", "list", "--json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 0);
+  assert.deepEqual(JSON.parse(result.stdout), {
+    connections: [{ name: "local", type: "postgres", host: "127.0.0.1", port: 5432, database: "demo" }],
+  });
+});
+
+test("blocks write query by default", async () => {
+  const result = await runCli(["query", "local", "update users set name = 'x' where id = 1", "--json"], {
+    backend: fakeBackend(),
+  });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "SQL_BLOCKED");
+});
+
+test("runs read query as json", async () => {
+  const result = await runCli(["query", "local", "select count(*) as total from users", "--json"], {
+    backend: fakeBackend(),
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.deepEqual(JSON.parse(result.stdout), {
+    connection: "local",
+    columns: ["total"],
+    rows: [{ total: 1 }],
+    row_count: 1,
+  });
+});
+
+test("closes backend resources created by the CLI", async () => {
+  let closed = false;
+  const result = await runCli(["query", "local", "select count(*) as total from users", "--json"], {
+    backendFactory: async () =>
+      fakeBackend({
+        close: async () => {
+          closed = true;
+        },
+      }),
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.equal(closed, true);
+});
+
+test("closes backend resources created by the CLI after failures", async () => {
+  let closed = false;
+  const result = await runCli(["query", "local", "select count(*) as total from users", "--json"], {
+    backendFactory: async () =>
+      fakeBackend({
+        executeQuery: async () => {
+          throw new Error("boom");
+        },
+        close: async () => {
+          closed = true;
+        },
+      }),
+  });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.message, "boom");
+  assert.equal(closed, true);
+});
+
+test("does not close caller-provided backend resources", async () => {
+  let closed = false;
+  const result = await runCli(["query", "local", "select count(*) as total from users", "--json"], {
+    backend: fakeBackend({
+      close: async () => {
+        closed = true;
+      },
+    }),
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.equal(closed, false);
+});
+
+test("runs query as csv", async () => {
+  const result = await runCli(["query", "local", "select count(*) as total from users", "--format", "csv"], {
+    backend: fakeBackend(),
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.equal(result.stdout, "total\n1\n");
+});
+
+test("uses json format alias", async () => {
+  const result = await runCli(["connections", "list", "--format", "json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 0);
+  assert.deepEqual(JSON.parse(result.stdout), {
+    connections: [{ name: "local", type: "postgres", host: "127.0.0.1", port: 5432, database: "demo" }],
+  });
+});
+
+test("prints diagnostics as json", async () => {
+  const result = await runCli(["doctor", "--json"], {
+    backend: fakeBackend(),
+    diagnostics: async () => diagnostics,
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.deepEqual(JSON.parse(result.stdout), diagnostics);
+});
+
+test("prints connection-store remediation in doctor output", async () => {
+  const result = await runCli(["doctor"], {
+    backend: fakeBackend(),
+    diagnostics: async () => ({
+      ...diagnostics,
+      loadConnectionsOk: false,
+      loadConnectionsError: "compiled against a different Node.js version",
+      loadConnectionsHint: "Rebuild DBX CLI native dependencies with your active Node.js.",
+    }),
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /Connection fix/);
+  assert.match(result.stdout, /Rebuild DBX CLI native dependencies/);
+});
+
+test("surfaces connection store failures instead of returning an empty list", async () => {
+  const result = await runCli(["connections", "list", "--json"], {
+    backend: fakeBackend({
+      loadConnections: async () => {
+        throw Object.assign(new Error("Failed to load DBX connections from /tmp/dbx/dbx.db: NODE_MODULE_VERSION 127 mismatch"), {
+          code: "CONNECTION_STORE_ERROR",
+        });
+      },
+    }),
+  });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "CONNECTION_STORE_ERROR");
+  assert.match(JSON.parse(result.stderr).error.hint, /Rebuild DBX CLI native dependencies/);
+});
+
+test("prints capabilities as json", async () => {
+  const result = await runCli(["capabilities", "--json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 0);
+  const payload = JSON.parse(result.stdout) as { directQueryTypes: string[]; bridgeRequiredTypes: string[] };
+  assert.ok(payload.directQueryTypes.includes("postgres"));
+  assert.ok(payload.directQueryTypes.includes("sqlite"));
+  assert.ok(payload.directQueryTypes.includes("rqlite"));
+  assert.ok(payload.bridgeRequiredTypes.includes("oracle"));
+});
+
+test("rejects invalid formats", async () => {
+  const result = await runCli(["query", "local", "select 1", "--json", "--format", "xml"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "INVALID_OPTION");
+});
+
+test("uses DBX_CONNECTION when query connection is omitted", async () => {
+  const result = await runCli(["query", "select count(*) as total from users", "--json"], {
+    backend: fakeBackend(),
+    env: { DBX_CONNECTION: "local" },
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.equal(JSON.parse(result.stdout).connection, "local");
+});
+
+test("uses DBX_CONNECTION when context connection is omitted", async () => {
+  const result = await runCli(["context", "--tables", "users"], {
+    backend: fakeBackend(),
+    env: { DBX_CONNECTION: "local" },
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /Connection: local/);
+});
+
+test("passes query limit and timeout to the backend", async () => {
+  let received: unknown;
+  const result = await runCli(["query", "local", "select * from users", "--limit", "5", "--timeout", "2s", "--json"], {
+    backend: fakeBackend({
+      executeQuery: async (_config, _sql, options) => {
+        received = options;
+        return { columns: ["id"], rows: [{ id: 1 }], row_count: 1 };
+      },
+    }),
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.deepEqual(received, { maxRows: 5, timeoutMs: 2000 });
+});
+
+test("rejects invalid query limits", async () => {
+  const result = await runCli(["query", "local", "select 1", "--limit", "0", "--json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "INVALID_OPTION");
+});
+
+test("rejects invalid query timeouts", async () => {
+  const result = await runCli(["query", "local", "select 1", "--timeout", "forever", "--json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "INVALID_OPTION");
+});
+
+test("requires a connection when DBX_CONNECTION is not set", async () => {
+  const result = await runCli(["query", "select 1", "--json"], { backend: fakeBackend(), env: {} });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "INVALID_ARGUMENT");
+});
+
+test("describes schema as json", async () => {
+  const result = await runCli(["schema", "describe", "local", "users", "--json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 0);
+  assert.equal(JSON.parse(result.stdout).columns[0].name, "id");
+});
+
+test("lists schema tables as json", async () => {
+  const result = await runCli(["schema", "list", "local", "--schema", "public", "--json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 0);
+  assert.deepEqual(JSON.parse(result.stdout), {
+    connection: "local",
+    schema: "public",
+    tables: [{ name: "users", type: "BASE TABLE" }],
+  });
+});
+
+test("builds schema context as prompt-ready text", async () => {
+  const result = await runCli(["context", "local", "--tables", "users"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /Connection: local/);
+  assert.match(result.stdout, /## users/);
+  assert.match(result.stdout, /id integer NOT NULL PK/);
+});
+
+test("runs SQL from file", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "dbx-cli-"));
+  const file = join(dir, "query.sql");
+  let executedSql = "";
+
+  try {
+    await writeFile(file, "select count(*) as total from users", "utf-8");
+
+    const result = await runCli(["query", "local", "--file", file, "--json"], {
+      backend: fakeBackend({
+        executeQuery: async (_config, sql) => {
+          executedSql = sql;
+          return { columns: ["total"], rows: [{ total: 1 }], row_count: 1 };
+        },
+      }),
+    });
+
+    assert.equal(result.exitCode, 0);
+    assert.equal(executedSql, "select count(*) as total from users");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("allows non-dangerous writes when explicitly enabled", async () => {
+  let executed = false;
+  const result = await runCli(["query", "local", "update users set name = 'x' where id = 1", "--allow-writes", "--json"], {
+    backend: fakeBackend({
+      executeQuery: async () => {
+        executed = true;
+        return { columns: [], rows: [], row_count: 1 };
+      },
+    }),
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.equal(executed, true);
+  assert.equal(JSON.parse(result.stdout).row_count, 1);
+});
+
+test("keeps dangerous SQL blocked without allow-dangerous-sql", async () => {
+  const result = await runCli(["query", "local", "drop table users", "--allow-writes", "--json"], {
+    backend: fakeBackend(),
+  });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "SQL_BLOCKED");
+});
+
+test("rejects unknown options", async () => {
+  const result = await runCli(["connections", "list", "--wat", "--json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "UNKNOWN_OPTION");
+});
+
+test("rejects options with missing values", async () => {
+  const result = await runCli(["schema", "list", "local", "--schema", "--json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "INVALID_OPTION");
+});
+
+test("rejects query with both inline SQL and file SQL", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "dbx-cli-"));
+  const file = join(dir, "query.sql");
+
+  try {
+    await writeFile(file, "select 1", "utf-8");
+
+    const result = await runCli(["query", "local", "select 2", "--file", file, "--json"], { backend: fakeBackend() });
+
+    assert.equal(result.exitCode, 1);
+    assert.equal(JSON.parse(result.stderr).error.code, "INVALID_ARGUMENT");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("requires allow-writes before allow-dangerous-sql", async () => {
+  const result = await runCli(["query", "local", "drop table users", "--allow-dangerous-sql", "--json"], {
+    backend: fakeBackend(),
+    env: {},
+  });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "INVALID_OPTION");
+});
+
+test("rejects invalid max-tables values", async () => {
+  const result = await runCli(["context", "local", "--max-tables", "nope", "--json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "INVALID_OPTION");
+});
+
+test("prints the package version", async () => {
+  const result = await runCli(["--version"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 0);
+  assert.match(result.stdout, /^\d+\.\d+\.\d+\n$/);
+});
+
+test("rejects unexpected positional arguments", async () => {
+  const result = await runCli(["connections", "list", "extra", "--json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "INVALID_ARGUMENT");
+});
+
+test("uses a specific connection-not-found error code", async () => {
+  const result = await runCli(["schema", "list", "missing", "--json"], { backend: fakeBackend() });
+
+  assert.equal(result.exitCode, 1);
+  assert.equal(JSON.parse(result.stderr).error.code, "CONNECTION_NOT_FOUND");
+});
+
+test("supports -- to pass SQL that starts with a dash", async () => {
+  let executedSql = "";
+  const result = await runCli(["query", "local", "--json", "--", "-- comment\nselect 1"], {
+    backend: fakeBackend({
+      executeQuery: async (_config, sql) => {
+        executedSql = sql;
+        return { columns: ["total"], rows: [{ total: 1 }], row_count: 1 };
+      },
+    }),
+  });
+
+  assert.equal(result.exitCode, 0);
+  assert.equal(executedSql, "-- comment\nselect 1");
+});
diff --git a/packages/cli/tsconfig.json b/packages/cli/tsconfig.json
new file mode 100644
index 0000000..9b2da40
--- /dev/null
+++ b/packages/cli/tsconfig.json
@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true
+  },
+  "include": ["src"]
+}
diff --git a/packages/cli/vitest.config.ts b/packages/cli/vitest.config.ts
new file mode 100644
index 0000000..4cfb639
--- /dev/null
+++ b/packages/cli/vitest.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/*.test.ts"],
+  },
+});
diff --git a/packages/mcp-server/README.md b/packages/mcp-server/README.md
new file mode 100644
index 0000000..2980268
--- /dev/null
+++ b/packages/mcp-server/README.md
@@ -0,0 +1,329 @@
+# DBX MCP Server
+
+MCP server for [DBX](https://github.com/t8y2/dbx) — lets AI agents (Claude Code, Cursor, etc.) query your databases using connections already configured in DBX.
+
+[中文](#中文说明) | English
+
+## Features
+
+- **Zero config** — Automatically reads your DBX connections (including passwords from system keyring)
+- **9 tools** — List/add/remove connections, list tables, describe table, get schema context, execute SQL, execute Redis commands, open table in DBX UI
+- **Connection pooling** — Reuses database connections across queries
+- **Direct execution** — PostgreSQL, MySQL, SQLite, and compatible databases (Doris, StarRocks, etc.) can run without opening DBX
+- **Writes enabled by default** — regular `INSERT` / `UPDATE` / `DELETE` statements work out of the box, while dangerous SQL stays blocked unless explicitly enabled
+- **DBX UI integration** — Open tables directly in the DBX desktop app from your AI agent
+
+## Quick Start
+
+### 1. Install
+
+```bash
+npm install -g @dbx-app/mcp-server
+```
+
+Or run directly:
+
+```bash
+npx @dbx-app/mcp-server
+```
+
+### 2. Configure Claude Code
+
+Add to your project's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "dbx-mcp-server"
+    }
+  }
+}
+```
+
+For Windows portable builds, set `DBX_DATA_DIR` to the portable data directory that contains `dbx.db`:
+
+```json
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "dbx-mcp-server",
+      "env": {
+        "DBX_DATA_DIR": "D:\\DBX_x64-portable\\data"
+      }
+    }
+  }
+}
+```
+
+Or for development (from source):
+
+```json
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "npx",
+      "args": ["tsx", "packages/mcp-server/src/index.ts"],
+      "cwd": "/path/to/dbx"
+    }
+  }
+}
+```
+
+### 3. Use
+
+In Claude Code, just ask:
+
+- "List my database connections"
+- "Show the tables in my local-pg connection"
+- "Describe the users table"
+- "Query the average salary from employees"
+- "Open the orders table in DBX"
+
+## CLI
+
+For terminal, script, and Codex workflows, install the dedicated CLI package:
+
+```bash
+npm install -g @dbx-app/cli
+dbx connections list --json
+dbx query local "select 1" --json
+```
+
+See the [DBX CLI README](../cli/README.md) for command details.
+
+## Tools
+
+| Tool                        | Description                                          |
+| --------------------------- | ---------------------------------------------------- |
+| `dbx_list_connections`      | List all database connections configured in DBX      |
+| `dbx_add_connection`        | Add a new database connection                        |
+| `dbx_remove_connection`     | Remove a database connection                         |
+| `dbx_list_tables`           | List tables and views for a connection               |
+| `dbx_describe_table`        | Get column definitions for a table                   |
+| `dbx_get_schema_context`    | Get compact table and column context for writing SQL |
+| `dbx_execute_query`         | Execute a SQL query (max 100 rows)                   |
+| `dbx_execute_redis_command` | Execute a Redis command on a Redis connection        |
+| `dbx_open_table`            | Open a table in DBX desktop app UI                   |
+
+## SQL Safety
+
+`dbx_execute_query` accepts multiple SQL statements and executes them one at a time after checking each statement. Regular write statements such as `INSERT`, `UPDATE`, and `DELETE ... WHERE ...` are allowed by default.
+
+If you need to force a read-only MCP session, set:
+
+```bash
+DBX_MCP_ALLOW_WRITES=0
+```
+
+Dangerous statements such as `DROP`, `TRUNCATE`, and `ALTER` remain blocked unless you also set:
+
+```bash
+DBX_MCP_ALLOW_DANGEROUS_SQL=1
+```
+
+Redis connections use `dbx_execute_redis_command` instead of `dbx_execute_query`. Redis write commands honor `DBX_MCP_ALLOW_WRITES`; dangerous Redis commands such as `KEYS`, `FLUSHALL`, and `EVAL` require `DBX_MCP_ALLOW_DANGEROUS_SQL=1`.
+
+## How It Works
+
+```
+AI Agent → MCP Server → Database
+                ↓
+         DBX SQLite database (dbx.db)
+```
+
+The MCP server reads your database connections from DBX's SQLite database:
+
+- **macOS**: `~/Library/Application Support/com.dbx.app/dbx.db`
+- **Linux**: `~/.local/share/com.dbx.app/dbx.db`
+- **Windows**: `%APPDATA%\com.dbx.app\dbx.db`
+
+Windows portable builds store data next to `DBX.exe`, usually in `data\dbx.db`. Set `DBX_DATA_DIR` to that `data` folder instead of copying `dbx.db` into the default directory.
+
+## DBX Web / Docker Mode
+
+When connecting MCP to a deployed DBX Web instance, set `DBX_WEB_URL` instead of reading local desktop storage:
+
+```json
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "dbx-mcp-server",
+      "env": {
+        "DBX_WEB_URL": "https://dbx.example.com",
+        "DBX_WEB_PASSWORD": "your-web-password"
+      }
+    }
+  }
+}
+```
+
+If the Web instance has password protection enabled, `DBX_WEB_PASSWORD` is required. Use the same password you enter on the DBX Web login page, including the password created by the first-run setup screen. You do not need to set `DBX_PASSWORD` on the DBX Web server just for MCP; `DBX_PASSWORD` is only a server-side environment override. Without `DBX_WEB_PASSWORD`, MCP calls fail before any connection data is returned. Desktop local mode does not use `DBX_WEB_PASSWORD`.
+
+## DBX UI Integration
+
+The `dbx_open_table` tool communicates with the running DBX app to open tables directly in the UI. This requires DBX to be running. If DBX is not running, the tool will return an error message.
+
+PostgreSQL, MySQL, SQLite, Doris, StarRocks, and Redshift queries run directly from the MCP server. Redis standalone command execution also runs directly. Other database types, plus Redis Sentinel/Cluster or SSH-backed Redis connections, still use the DBX desktop bridge unless `DBX_WEB_URL` is configured.
+
+## Requirements
+
+- [DBX](https://github.com/t8y2/dbx) installed with at least one connection configured
+- Node.js 22.13.0 或更高版本
+
+## License
+
+Apache-2.0
+
+---
+
+## 中文说明
+
+[DBX](https://github.com/t8y2/dbx) 的 MCP Server，让 AI 编程助手（Claude Code、Cursor 等）直接使用 DBX 中已配置的数据库连接查询数据。
+
+### 特性
+
+- **零配置** — 自动读取 DBX 的连接配置
+- **9 个工具** — 列出/添加/删除连接、列出表、查看表结构、获取 Schema 上下文、执行 SQL、执行 Redis 命令、在 DBX 中打开表
+- **连接池** — 跨查询复用数据库连接
+- **直接执行** — PostgreSQL、MySQL、SQLite 及兼容数据库（Doris、StarRocks 等）无需打开 DBX 即可查询
+- **默认允许常规写入** — `INSERT` / `UPDATE` / `DELETE` 可直接执行，危险语句仍需显式开启
+- **DBX UI 联动** — 从 AI 助手直接在 DBX 桌面端打开表
+
+### 快速开始
+
+#### 1. 安装
+
+```bash
+npm install -g @dbx-app/mcp-server
+```
+
+或直接运行：
+
+```bash
+npx @dbx-app/mcp-server
+```
+
+#### 2. 配置 Claude Code
+
+在项目的 `.mcp.json` 中添加：
+
+```json
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "dbx-mcp-server"
+    }
+  }
+}
+```
+
+Windows 便携版需要在 MCP 配置中设置 `DBX_DATA_DIR`，指向包含 `dbx.db` 的便携版数据目录：
+
+```json
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "dbx-mcp-server",
+      "env": {
+        "DBX_DATA_DIR": "D:\\DBX_x64-portable\\data"
+      }
+    }
+  }
+}
+```
+
+#### 3. 使用
+
+在 Claude Code 中直接说：
+
+- "列出我的数据库连接"
+- "查看 local-pg 上有哪些表"
+- "查看 users 表的结构"
+- "查询最近 7 天的订单数量"
+- "打开 orders 表"
+
+### CLI
+
+终端、脚本和 Codex 工作流请安装独立 CLI 包：
+
+```bash
+npm install -g @dbx-app/cli
+dbx connections list --json
+dbx query local "select 1" --json
+```
+
+命令详情见 [DBX CLI README](../cli/README.md)。
+
+### 工具列表
+
+| 工具                        | 说明                                  |
+| --------------------------- | ------------------------------------- |
+| `dbx_list_connections`      | 列出 DBX 中所有已配置的数据库连接     |
+| `dbx_add_connection`        | 添加新的数据库连接                    |
+| `dbx_remove_connection`     | 删除数据库连接                        |
+| `dbx_list_tables`           | 列出指定连接的表和视图                |
+| `dbx_describe_table`        | 获取表的列定义                        |
+| `dbx_get_schema_context`    | 获取适合 AI 写 SQL 的紧凑表结构上下文 |
+| `dbx_execute_query`         | 执行 SQL 查询（最多返回 100 行）      |
+| `dbx_execute_redis_command` | 在 Redis 连接上执行 Redis 命令        |
+| `dbx_open_table`            | 在 DBX 桌面端打开指定表               |
+
+### SQL 安全
+
+`dbx_execute_query` 支持多条 SQL 语句，会逐条完成安全检查并依次执行。默认允许常规写操作，例如 `INSERT`、`UPDATE`、`DELETE ... WHERE ...`。
+
+如果你希望 MCP 会话强制退回只读，可设置：
+
+```bash
+DBX_MCP_ALLOW_WRITES=0
+```
+
+`DROP`、`TRUNCATE`、`ALTER` 等危险语句仍会被拦截，除非额外设置：
+
+```bash
+DBX_MCP_ALLOW_DANGEROUS_SQL=1
+```
+
+Redis 连接使用 `dbx_execute_redis_command`，不通过 `dbx_execute_query` 执行。Redis 写命令遵循 `DBX_MCP_ALLOW_WRITES`；`KEYS`、`FLUSHALL`、`EVAL` 等危险 Redis 命令需要设置 `DBX_MCP_ALLOW_DANGEROUS_SQL=1`。
+
+### 工作原理
+
+MCP Server 从 DBX 的 SQLite 数据库读取连接信息：
+
+- **macOS**: `~/Library/Application Support/com.dbx.app/dbx.db`
+- **Linux**: `~/.local/share/com.dbx.app/dbx.db`
+- **Windows**: `%APPDATA%\com.dbx.app\dbx.db`
+
+Windows 便携版的数据通常在 `DBX.exe` 同级的 `data\dbx.db`。请把 `DBX_DATA_DIR` 设置为这个 `data` 文件夹，不要手工复制 `dbx.db` 到默认目录。
+
+### DBX Web / Docker 模式
+
+如果 MCP 连接的是已部署的 DBX Web 实例，请设置 `DBX_WEB_URL`，不要读取本机桌面端存储：
+
+```json
+{
+  "mcpServers": {
+    "dbx": {
+      "command": "dbx-mcp-server",
+      "env": {
+        "DBX_WEB_URL": "https://dbx.example.com",
+        "DBX_WEB_PASSWORD": "你的 Web 访问密码"
+      }
+    }
+  }
+}
+```
+
+当 Web 实例启用了密码保护时，必须提供 `DBX_WEB_PASSWORD`。这里填写的就是 DBX Web 登录页使用的密码，也包括首次打开 Web 页面时通过 setup 设置的密码。为了让 MCP 可用，不需要在启动 DBX Web 时额外设置 `DBX_PASSWORD`；`DBX_PASSWORD` 只是服务端环境变量覆盖。未提供 `DBX_WEB_PASSWORD` 时，MCP 调用会在返回任何连接数据前失败。桌面本地模式不使用 `DBX_WEB_PASSWORD`。
+
+### DBX UI 联动
+
+`dbx_open_table` 工具通过本地 HTTP 接口与运行中的 DBX 应用通信，直接在 UI 中打开表。需要 DBX 正在运行。
+
+PostgreSQL、MySQL、SQLite、Doris、StarRocks、Redshift 查询可由 MCP Server 直接执行。Redis standalone 命令执行也会直接连接。其他数据库类型，以及 Redis Sentinel/Cluster 或 SSH Redis 连接，仍会走 DBX 桌面端 bridge，除非配置了 `DBX_WEB_URL` 使用 Web 后端。
+
+### 系统要求
+
+- 已安装 [DBX](https://github.com/t8y2/dbx) 并配置了至少一个数据库连接
+- Node.js 22.13.0 or newer
diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
new file mode 100644
index 0000000..1a26760
--- /dev/null
+++ b/packages/mcp-server/package.json
@@ -0,0 +1,50 @@
+{
+  "name": "@dbx-app/mcp-server",
+  "version": "0.4.28",
+  "description": "MCP server for DBX — query databases from Claude Code, Cursor, and other AI agents",
+  "keywords": [
+    "ai-agent",
+    "claude",
+    "database",
+    "dbx",
+    "mcp",
+    "mysql",
+    "postgresql"
+  ],
+  "homepage": "https://github.com/t8y2/dbx/tree/main/packages/mcp-server",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/t8y2/dbx",
+    "directory": "packages/mcp-server"
+  },
+  "bin": {
+    "dbx-mcp-server": "dist/index.js",
+    "mcp-server": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "server.json"
+  ],
+  "type": "module",
+  "scripts": {
+    "start": "tsx src/index.ts",
+    "test": "pnpm --filter @dbx-app/mcp-server build && vitest run --config vitest.config.ts",
+    "build": "pnpm --filter @dbx-app/node-core build && tsc",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "@dbx-app/node-core": "workspace:^",
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.25.20"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.21",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "mcpName": "io.github.t8y2/dbx"
+}
diff --git a/packages/mcp-server/server.json b/packages/mcp-server/server.json
new file mode 100644
index 0000000..c481898
--- /dev/null
+++ b/packages/mcp-server/server.json
@@ -0,0 +1,20 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.t8y2/dbx",
+  "description": "Query and manage databases from AI agents using connections configured in DBX.",
+  "repository": {
+    "url": "https://github.com/t8y2/dbx",
+    "source": "github"
+  },
+  "version": "0.4.28",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@dbx-app/mcp-server",
+      "version": "0.4.28",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}
diff --git a/packages/mcp-server/src/index.ts b/packages/mcp-server/src/index.ts
new file mode 100644
index 0000000..ea6a880
--- /dev/null
+++ b/packages/mcp-server/src/index.ts
@@ -0,0 +1,535 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createRequire } from "node:module";
+import { z } from "zod";
+import {
+  buildSchemaContext,
+  createBackend,
+  evaluateRedisCommandSafety,
+  evaluateMongoAggregateSafety,
+  evaluateSqlSafety,
+  formatCell,
+  formatSchemaContext,
+  isMainModule,
+  mdTable,
+  notifyReload,
+  parseMongoAggregateCommand,
+  assessProductionSql,
+  isLikelyMongoMutation,
+  isProductionDatabase,
+  postBridge,
+  sqlSafetyFromEnv,
+  splitSqlStatements,
+  type Backend,
+  type ConnectionConfig,
+  type QueryResult,
+  type RedisCommandResult,
+} from "@dbx-app/node-core";
+
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json") as { version?: string };
+export const DBX_MCP_PACKAGE_VERSION = packageJson.version ?? "0.0.0";
+
+function text(s: string) {
+  return { content: [{ type: "text" as const, text: s }] };
+}
+
+function toolError(code: string, message: string) {
+  return { ...text(`${code}: ${message}`), isError: true };
+}
+
+function withDatabase(config: ConnectionConfig, database?: string): ConnectionConfig {
+  return database === undefined ? config : { ...config, database };
+}
+
+function metadataScope(config: ConnectionConfig, database?: string, schema?: string): { config: ConnectionConfig; schema?: string } {
+  if (config.db_type !== "dameng") {
+    return { config: withDatabase(config, database), schema };
+  }
+
+  // Dameng exposes tables under user-owned schemas rather than separate
+  // databases. Accept the legacy database argument as a schema, and default to
+  // the login user when neither argument is provided.
+  const resolvedSchema = schema?.trim() || database?.trim() || config.username?.trim() || undefined;
+  return { config, schema: resolvedSchema };
+}
+
+function connectionIdentity(config: ConnectionConfig): string {
+  return `${config.name} (${config.id}) [${config.db_type} @ ${config.host}:${config.port}]`;
+}
+
+function labeledText(config: ConnectionConfig, body: string): ReturnType<typeof text> {
+  return text(`[${connectionIdentity(config)}]\n${body}`);
+}
+
+function formatQueryToolResult(result: QueryResult, title?: string) {
+  const prefix = title ? `${title}\n` : "";
+  if (result.columns.length === 0) return text(`${prefix}Query executed. ${result.row_count} row(s) affected.`);
+  const rows = result.rows.map((r) => result.columns.map((c) => formatCell(r[c])));
+  return text(`${prefix}${mdTable(result.columns, rows)}\n\n${result.row_count} row(s)`);
+}
+
+function redisDbFromValue(value?: string): number | undefined {
+  const trimmed = value?.trim();
+  if (!trimmed) return undefined;
+  const db = Number(trimmed);
+  return Number.isInteger(db) && db >= 0 ? db : undefined;
+}
+
+function defaultRedisDb(config: ConnectionConfig, scope: McpScope, db?: number): number {
+  return db ?? redisDbFromValue(scope.database) ?? redisDbFromValue(config.database) ?? 0;
+}
+
+function formatRedisCommandValue(value: unknown): string {
+  if (typeof value === "string") return value;
+  return JSON.stringify(value, null, 2) ?? String(value);
+}
+
+function formatRedisCommandToolResult(result: RedisCommandResult) {
+  return text(`Command: ${result.command}\nSafety: ${result.safety}\n\n${formatRedisCommandValue(result.value)}`);
+}
+
+export const DBX_CONNECTION_TYPE_DESCRIPTION =
+  "Database type: postgres, mysql, sqlite, rqlite, cloudflare-d1, redis, duckdb, clickhouse, sqlserver, mongodb, oracle, elasticsearch, etcd, doris, starrocks, manticoresearch, milvus, qdrant, weaviate, chromadb, redshift, dameng, kingbase, highgo, vastbase, goldendb, databend, gaussdb, kwdb, yashandb, databricks, saphana, teradata, vertica, firebird, exasol, opengauss, oceanbase-oracle, questdb, gbase, h2, snowflake, trino, prestosql, hive, spark, db2, informix, influxdb, iris, neo4j, cassandra, bigquery, kylin, sundb, oscar, tdengine, iotdb, xugu, zookeeper, jdbc, access, mq";
+const FILE_CAPABLE_CONNECTION_TYPES = new Set(["sqlite", "duckdb", "access", "h2"]);
+
+interface McpScope {
+  connectionId?: string;
+  connectionName?: string;
+  database?: string;
+}
+
+function scopedValue(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function mcpScopeFromEnv(): McpScope {
+  return {
+    connectionId: scopedValue(process.env.DBX_MCP_SCOPE_CONNECTION_ID),
+    connectionName: scopedValue(process.env.DBX_MCP_SCOPE_CONNECTION_NAME),
+    database: scopedValue(process.env.DBX_MCP_SCOPE_DATABASE),
+  };
+}
+
+function scopeEnabled(scope: McpScope): boolean {
+  return !!(scope.connectionId || scope.connectionName);
+}
+
+function connectionMatchesScope(config: ConnectionConfig, scope: McpScope): boolean {
+  return (!!scope.connectionId && config.id === scope.connectionId) || (!!scope.connectionName && config.name === scope.connectionName);
+}
+
+async function loadScopedConnections(backend: Backend, scope: McpScope): Promise<ConnectionConfig[]> {
+  const connections = await backend.loadConnections();
+  if (!scopeEnabled(scope)) return connections;
+  return connections.filter((config) => connectionMatchesScope(config, scope));
+}
+
+async function resolveConnection(backend: Backend, scope: McpScope, requestedId?: string, requestedName?: string): Promise<{ config?: ConnectionConfig; error?: ReturnType<typeof toolError> }> {
+  // connection_id takes priority over connection_name when both are provided.
+  if (requestedId?.trim()) {
+    const connections = await backend.loadConnections();
+    const config = connections.find((c) => c.id === requestedId.trim());
+    if (!config) return { error: toolError("CONNECTION_NOT_FOUND", `Connection with id "${requestedId}" not found.`) };
+    // In scoped mode, verify the resolved connection is within the scope.
+    if (scopeEnabled(scope) && !connectionMatchesScope(config, scope)) {
+      return { error: toolError("CONNECTION_OUT_OF_SCOPE", `Connection "${requestedId}" is outside this DBX AI session scope.`) };
+    }
+    return { config };
+  }
+
+  if (!scopeEnabled(scope)) {
+    if (!requestedName?.trim()) return { error: toolError("CONNECTION_NOT_FOUND", "Connection name is required.") };
+    const connections = await backend.loadConnections();
+    const matching = connections.filter((c) => c.name.toLowerCase() === requestedName.trim().toLowerCase());
+    if (matching.length === 0) return { error: toolError("CONNECTION_NOT_FOUND", `Connection "${requestedName}" not found.`) };
+    if (matching.length > 1) {
+      const lines = matching.map((c) => `- ${c.id}: ${c.db_type} @ ${c.host}:${c.port}`);
+      return {
+        error: toolError("AMBIGUOUS_CONNECTION", `Multiple connections found with name "${requestedName}". Please specify connection_id:\n${lines.join("\n")}`),
+      };
+    }
+    return { config: matching[0] };
+  }
+
+  const [scopedConfig] = await loadScopedConnections(backend, scope);
+  if (!scopedConfig) return { error: toolError("CONNECTION_NOT_FOUND", "Scoped DBX connection was not found.") };
+  if (requestedName?.trim() && requestedName !== scopedConfig.name && requestedName !== scopedConfig.id) {
+    return { error: toolError("CONNECTION_OUT_OF_SCOPE", `Connection "${requestedName}" is outside this DBX AI session scope.`) };
+  }
+  return { config: scopedConfig };
+}
+
+export function createDbxMcpServer(backend: Backend, options: { isWebMode?: boolean } = {}): McpServer {
+  const isWebMode = options.isWebMode ?? !!process.env.DBX_WEB_URL;
+  const scope = mcpScopeFromEnv();
+  const scoped = scopeEnabled(scope);
+  const server = new McpServer({
+    name: "dbx",
+    version: DBX_MCP_PACKAGE_VERSION,
+  });
+
+  server.tool("dbx_list_connections", "List all database connections configured in DBX", {}, async () => {
+    const connections = await loadScopedConnections(backend, scope);
+    if (connections.length === 0) return text("No connections configured in DBX.");
+    const rows = connections.map((c) => [c.id, c.name, c.db_type, c.host, String(c.port), c.database || ""]);
+    return text(mdTable(["ID", "Name", "Type", "Host", "Port", "Database"], rows));
+  });
+
+  server.tool(
+    "dbx_list_tables",
+    "List tables and views for a database connection",
+    {
+      connection_id: z.string().optional().describe("Unique ID of the DBX connection (use this to disambiguate when multiple connections share the same name)"),
+      connection_name: z.string().optional().describe("Name of the DBX connection"),
+      database: z.string().optional().describe("Database name; for Dameng this is also accepted as a schema alias"),
+      schema: z.string().optional().describe("Schema name (default: public for PostgreSQL, login user for Dameng)"),
+    },
+    async ({ connection_id, connection_name, database, schema }) => {
+      const { config, error } = await resolveConnection(backend, scope, connection_id, connection_name);
+      if (error) return error;
+      const resolvedConfig = config!;
+      const scopeValue = metadataScope(resolvedConfig, database ?? scope.database, schema);
+      const tables = await backend.listTables(scopeValue.config, scopeValue.schema);
+      if (tables.length === 0) return text("No tables found.");
+      const rows = tables.map((t) => [t.name, t.type]);
+      return labeledText(resolvedConfig, mdTable(["Table", "Type"], rows));
+    },
+  );
+
+  server.tool(
+    "dbx_describe_table",
+    "Get column definitions for a table",
+    {
+      connection_id: z.string().optional().describe("Unique ID of the DBX connection (use this to disambiguate when multiple connections share the same name)"),
+      connection_name: z.string().optional().describe("Name of the DBX connection"),
+      table: z.string().describe("Table name"),
+      database: z.string().optional().describe("Database name; for Dameng this is also accepted as a schema alias"),
+      schema: z.string().optional().describe("Schema name (default: public for PostgreSQL, login user for Dameng)"),
+    },
+    async ({ connection_id, connection_name, table, database, schema }) => {
+      const { config, error } = await resolveConnection(backend, scope, connection_id, connection_name);
+      if (error) return error;
+      const resolvedConfig = config!;
+      const scopeValue = metadataScope(resolvedConfig, database ?? scope.database, schema);
+      const columns = await backend.describeTable(scopeValue.config, table, scopeValue.schema);
+      if (columns.length === 0) return text("No columns found.");
+      const rows = columns.map((c) => [c.is_primary_key ? `${c.name} (PK)` : c.name, c.data_type, c.is_nullable ? "YES" : "NO", c.column_default ?? "", c.comment ?? ""]);
+      return labeledText(resolvedConfig, mdTable(["Column", "Type", "Nullable", "Default", "Comment"], rows));
+    },
+  );
+
+  server.tool(
+    "dbx_execute_query",
+    "Execute a SQL query on a database connection (max 100 rows returned)",
+    {
+      connection_id: z.string().optional().describe("Unique ID of the DBX connection (use this to disambiguate when multiple connections share the same name)"),
+      connection_name: z.string().optional().describe("Name of the DBX connection"),
+      database: z.string().optional().describe("Database name"),
+      sql: z.string().describe("SQL query to execute"),
+    },
+    async ({ connection_id, connection_name, database, sql }) => {
+      const { config, error } = await resolveConnection(backend, scope, connection_id, connection_name);
+      if (error) return error;
+      const scopedConfig = config!;
+      if (scopedConfig.db_type === "redis") {
+        return toolError("REDIS_COMMAND_REQUIRED", "Redis connections do not accept SQL through dbx_execute_query. Use dbx_execute_redis_command with a Redis command such as GET key or INFO.");
+      }
+      if (scopedConfig.db_type !== "mongodb") {
+        const safety = evaluateSqlSafety(sql, { ...sqlSafetyFromEnv(), allowMultipleStatements: true });
+        if (!safety.allowed) return toolError("SQL_BLOCKED", safety.reason ?? "SQL blocked.");
+        const production = assessProductionSql(sql, scopedConfig, database ?? scope.database ?? scopedConfig.database);
+        if (production.active && production.isMutation) {
+          return toolError("PRODUCTION_WRITE_BLOCKED", "MCP cannot execute writes against a production database. Return the SQL for a user to review and run in DBX.");
+        }
+      } else if (isProductionDatabase(scopedConfig, database ?? scope.database ?? scopedConfig.database) && isLikelyMongoMutation(sql)) {
+        return toolError("PRODUCTION_WRITE_BLOCKED", "MCP cannot execute writes against a production database. Return the command for a user to review and run in DBX.");
+      }
+      // MongoDB shell commands don't fit the SQL safety evaluator; the backend
+      // (node-core executeQuery) applies command-aware read/write gating.
+      try {
+        const statements = scopedConfig.db_type === "mongodb" ? [sql] : splitSqlStatements(sql);
+        const results = [];
+        for (const statement of statements) {
+          results.push(await backend.executeQuery(withDatabase(scopedConfig, database ?? scope.database), statement));
+        }
+        if (results.length === 1) return labeledText(scopedConfig, formatQueryToolResult(results[0]).content[0].text);
+        return labeledText(scopedConfig, results.map((result, index) => formatQueryToolResult(result, `Statement ${index + 1}`).content[0].text).join("\n\n"));
+      } catch (e: unknown) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return toolError("QUERY_ERROR", msg);
+      }
+    },
+  );
+
+  server.tool(
+    "dbx_execute_redis_command",
+    "Execute a Redis command on a Redis connection",
+    {
+      connection_id: z.string().optional().describe("Unique ID of the DBX connection (use this to disambiguate when multiple connections share the same name)"),
+      connection_name: z.string().optional().describe("Name of the DBX Redis connection"),
+      db: z.number().int().min(0).optional().describe("Redis logical database number (default: scoped/default database or 0)"),
+      command: z.string().describe("Redis command to execute, for example: GET mykey, INFO, or DBSIZE"),
+    },
+    async ({ connection_id, connection_name, db, command }) => {
+      const { config, error } = await resolveConnection(backend, scope, connection_id, connection_name);
+      if (error) return error;
+      const scopedConfig = config!;
+      if (scopedConfig.db_type !== "redis") {
+        return toolError("INVALID_CONNECTION_TYPE", `Connection "${scopedConfig.name}" is ${scopedConfig.db_type}, not Redis.`);
+      }
+      if (!backend.executeRedisCommand) {
+        return toolError("UNSUPPORTED_BACKEND", "This DBX backend does not support Redis command execution.");
+      }
+      const safety = evaluateRedisCommandSafety(command, sqlSafetyFromEnv());
+      if (!safety.allowed) return toolError("REDIS_COMMAND_BLOCKED", safety.reason ?? "Redis command blocked.");
+      if (isProductionDatabase(scopedConfig, String(defaultRedisDb(scopedConfig, scope, db))) && safety.safety !== "allowed") {
+        return toolError("PRODUCTION_WRITE_BLOCKED", "MCP cannot execute write or dangerous Redis commands against a production database.");
+      }
+      try {
+        const result = await backend.executeRedisCommand(scopedConfig, defaultRedisDb(scopedConfig, scope, db), command, {
+          skipSafetyCheck: safety.skipSafetyCheck,
+        });
+        return labeledText(scopedConfig, formatRedisCommandToolResult(result).content[0].text);
+      } catch (e: unknown) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return toolError("REDIS_COMMAND_ERROR", msg);
+      }
+    },
+  );
+
+  server.tool(
+    "dbx_get_schema_context",
+    "Get compact table and column context for writing SQL",
+    {
+      connection_id: z.string().optional().describe("Unique ID of the DBX connection (use this to disambiguate when multiple connections share the same name)"),
+      connection_name: z.string().optional().describe("Name of the DBX connection"),
+      database: z.string().optional().describe("Database name"),
+      schema: z.string().optional().describe("Schema name (default: public for PostgreSQL)"),
+      tables: z.array(z.string()).optional().describe("Specific table names to include"),
+      max_tables: z.number().int().min(1).max(20).default(8).describe("Maximum number of tables to include"),
+    },
+    async ({ connection_id, connection_name, database, schema, tables, max_tables }) => {
+      const { config, error } = await resolveConnection(backend, scope, connection_id, connection_name);
+      if (error) return error;
+      const resolvedConfig = config!;
+      const context = await buildSchemaContext(backend, withDatabase(resolvedConfig, database ?? scope.database), {
+        schema,
+        tables,
+        maxTables: max_tables,
+      });
+      if (context.tables.length === 0) return text("No matching tables found.");
+      return labeledText(resolvedConfig, formatSchemaContext(context));
+    },
+  );
+
+  if (!scoped) {
+    server.tool(
+      "dbx_add_connection",
+      "Add a new database connection to DBX",
+      {
+        name: z.string().describe("Connection name"),
+        db_type: z.string().describe(DBX_CONNECTION_TYPE_DESCRIPTION),
+        host: z.string().describe("Database host; for cloudflare-d1, use the Cloudflare Account ID"),
+        port: z.number().optional().describe("Database port (TDengine defaults to 6041, IoTDB defaults to 6667, XuguDB defaults to 5138)"),
+        username: z.string().default("").describe("Username"),
+        password: z.string().default("").describe("Password; for cloudflare-d1, use the API Token"),
+        database: z.string().optional().describe("Default database name; for cloudflare-d1, use the D1 Database ID"),
+        ssl: z.boolean().default(false).describe("Enable SSL"),
+        driver_profile: z.string().optional().describe("Driver profile (e.g. 'gbase8a', 'gbase8s')"),
+      },
+      async ({ name, db_type, host, port, username, password, database, ssl, driver_profile }) => {
+        const existing = await backend.findConnection(name);
+        if (existing) return text(`Connection "${name}" already exists.`);
+        const DEFAULT_PORTS: Record<string, number> = {
+          kwdb: 26257,
+          rqlite: 4001,
+          "cloudflare-d1": 443,
+          tdengine: 6041,
+          oscar: 2003,
+          iotdb: 6667,
+          xugu: 5138,
+        };
+        const resolvedPort = port ?? DEFAULT_PORTS[db_type] ?? (FILE_CAPABLE_CONNECTION_TYPES.has(db_type) ? 0 : undefined);
+        if (resolvedPort === undefined) return text("Port is required for this database type.");
+        const config = await backend.addConnection({
+          name,
+          db_type,
+          host,
+          port: resolvedPort,
+          username,
+          password,
+          database,
+          ssl,
+          driver_profile,
+          ssh_enabled: false,
+        } as Omit<ConnectionConfig, "id">);
+        await notifyReload();
+        return text(`Connection "${config.name}" added (id: ${config.id}).`);
+      },
+    );
+
+    server.tool(
+      "dbx_remove_connection",
+      "Remove a database connection from DBX",
+      {
+        connection_name: z.string().describe("Name of the connection to remove"),
+        connection_id: z.string().optional().describe("Unique ID of the DBX connection (use this to remove by id instead of name)"),
+      },
+      async ({ connection_name, connection_id }) => {
+        if (connection_id?.trim()) {
+          if (backend.removeConnectionById) {
+            const removed = await backend.removeConnectionById(connection_id.trim());
+            if (!removed) return toolError("CONNECTION_NOT_FOUND", `Connection with id "${connection_id}" not found.`);
+            await notifyReload();
+            return text(`Connection with id "${connection_id}" removed.`);
+          }
+          // Fallback: resolve by id then remove by name
+          const connections = await backend.loadConnections();
+          const config = connections.find((c) => c.id === connection_id.trim());
+          if (!config) return toolError("CONNECTION_NOT_FOUND", `Connection with id "${connection_id}" not found.`);
+          const removed = await backend.removeConnection(config.name);
+          if (!removed) return toolError("CONNECTION_NOT_FOUND", `Connection "${config.name}" could not be removed.`);
+          await notifyReload();
+          return text(`Connection "${config.name}" (id: ${config.id}) removed.`);
+        }
+        const allConnections = await backend.loadConnections();
+        const matching = allConnections.filter((c) => c.name.toLowerCase() === connection_name.toLowerCase());
+        if (matching.length === 0) return toolError("CONNECTION_NOT_FOUND", `Connection "${connection_name}" not found.`);
+        if (matching.length > 1) {
+          const lines = matching.map((c) => `- ${c.id}: ${c.db_type} @ ${c.host}:${c.port}`);
+          return toolError("AMBIGUOUS_CONNECTION", `Multiple connections found with name "${connection_name}". Please specify connection_id:\n${lines.join("\n")}`);
+        }
+        const removed = await backend.removeConnection(connection_name);
+        if (!removed) return toolError("CONNECTION_NOT_FOUND", `Connection "${connection_name}" not found.`);
+        await notifyReload();
+        return text(`Connection "${connection_name}" removed.`);
+      },
+    );
+  }
+
+  // Desktop-only tools: open table and execute-and-show require the Tauri bridge
+  if (!isWebMode && !scoped) {
+    server.tool(
+      "dbx_open_table",
+      "Open a table in DBX desktop app UI. Requires DBX to be running.",
+      {
+        connection_id: z.string().optional().describe("Unique ID of the DBX connection (use this to disambiguate when multiple connections share the same name)"),
+        connection_name: z.string().optional().describe("Name of the DBX connection"),
+        table: z.string().describe("Table name to open"),
+        database: z.string().optional().describe("Database name"),
+        schema: z.string().optional().describe("Schema name"),
+      },
+      async ({ connection_id, connection_name, table, database, schema }) => {
+        let config: ConnectionConfig | undefined;
+        if (connection_id?.trim()) {
+          const connections = await backend.loadConnections();
+          config = connections.find((c) => c.id === connection_id.trim());
+          if (!config) return toolError("CONNECTION_NOT_FOUND", `Connection with id "${connection_id}" not found.`);
+        } else if (connection_name?.trim()) {
+          const connections = await backend.loadConnections();
+          const matching = connections.filter((c) => c.name.toLowerCase() === connection_name.toLowerCase());
+          if (matching.length === 0) return toolError("CONNECTION_NOT_FOUND", `Connection "${connection_name}" not found.`);
+          if (matching.length > 1) {
+            const lines = matching.map((c) => `- ${c.id}: ${c.db_type} @ ${c.host}:${c.port}`);
+            return toolError("AMBIGUOUS_CONNECTION", `Multiple connections found with name "${connection_name}". Please specify connection_id:\n${lines.join("\n")}`);
+          }
+          config = matching[0];
+        } else {
+          return toolError("CONNECTION_NOT_FOUND", "Either connection_id or connection_name is required.");
+        }
+        return bridgeRequest("/open-table", { connection_id: config.id, connection_name: config.name, table, database, schema }, `Opened ${table} in DBX`);
+      },
+    );
+
+    server.tool(
+      "dbx_execute_and_show",
+      "Execute a SQL query in DBX desktop app UI and show results there. Requires DBX to be running.",
+      {
+        connection_id: z.string().optional().describe("Unique ID of the DBX connection (use this to disambiguate when multiple connections share the same name)"),
+        connection_name: z.string().optional().describe("Name of the DBX connection"),
+        sql: z.string().describe("SQL query to execute"),
+        database: z.string().optional().describe("Database name"),
+      },
+      async ({ connection_id, connection_name, sql, database }) => {
+        let config: ConnectionConfig | undefined;
+        if (connection_id?.trim()) {
+          const connections = await backend.loadConnections();
+          config = connections.find((c) => c.id === connection_id.trim());
+          if (!config) return toolError("CONNECTION_NOT_FOUND", `Connection with id "${connection_id}" not found.`);
+        } else if (connection_name?.trim()) {
+          const connections = await backend.loadConnections();
+          const matching = connections.filter((c) => c.name.toLowerCase() === connection_name.toLowerCase());
+          if (matching.length === 0) return toolError("CONNECTION_NOT_FOUND", `Connection "${connection_name}" not found.`);
+          if (matching.length > 1) {
+            const lines = matching.map((c) => `- ${c.id}: ${c.db_type} @ ${c.host}:${c.port}`);
+            return toolError("AMBIGUOUS_CONNECTION", `Multiple connections found with name "${connection_name}". Please specify connection_id:\n${lines.join("\n")}`);
+          }
+          config = matching[0];
+        } else {
+          return toolError("CONNECTION_NOT_FOUND", "Either connection_id or connection_name is required.");
+        }
+        const safetyOptions = sqlSafetyFromEnv();
+        if (config?.db_type === "mongodb") {
+          const aggregate = parseMongoAggregateCommand(sql);
+          if (aggregate) {
+            const safety = evaluateMongoAggregateSafety(aggregate, safetyOptions);
+            if (!safety.allowed) return toolError("SQL_BLOCKED", safety.reason ?? "Query blocked.");
+          }
+        } else {
+          const safety = evaluateSqlSafety(sql, { ...safetyOptions, allowMultipleStatements: true });
+          if (!safety.allowed) return toolError("SQL_BLOCKED", safety.reason ?? "SQL blocked.");
+        }
+        if (config?.db_type === "mongodb") {
+          if (isProductionDatabase(config, database ?? scope.database ?? config.database) && isLikelyMongoMutation(sql)) {
+            return toolError("PRODUCTION_WRITE_BLOCKED", "MCP cannot send writes against a production database to DBX.");
+          }
+        } else {
+          const production = assessProductionSql(sql, config, database ?? scope.database ?? config.database);
+          if (production.active && production.isMutation) {
+            return toolError("PRODUCTION_WRITE_BLOCKED", "MCP cannot send writes against a production database to DBX.");
+          }
+        }
+        // MongoDB shell commands bypass the SQL safety evaluator; pass MCP
+        // safety flags to the desktop executor for command-aware gating.
+        return bridgeRequest(
+          "/execute-query",
+          {
+            connection_id: config!.id,
+            connection_name: config!.name,
+            sql,
+            database,
+            allow_writes: safetyOptions.allowWrites,
+            allow_dangerous: safetyOptions.allowDangerous,
+          },
+          "Query sent to DBX",
+        );
+      },
+    );
+  }
+
+  return server;
+}
+
+async function bridgeRequest(path: string, body: Record<string, unknown>, successMsg: string) {
+  const res = await postBridge(path, body);
+  if (res.ok) return text(successMsg);
+  const message = res.text.startsWith("DBX is not running") ? res.text : `Failed: ${res.text}`;
+  return toolError("DBX_NOT_RUNNING", message);
+}
+
+async function main() {
+  const backend = await createBackend();
+  const server = createDbxMcpServer(backend);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+if (isMainModule(import.meta.url, process.argv[1])) {
+  main().catch((e) => {
+    console.error("MCP Server failed to start:", e);
+    process.exit(1);
+  });
+}
diff --git a/packages/mcp-server/tests/bin.test.ts b/packages/mcp-server/tests/bin.test.ts
new file mode 100644
index 0000000..b3a4557
--- /dev/null
+++ b/packages/mcp-server/tests/bin.test.ts
@@ -0,0 +1,110 @@
+import assert from "node:assert/strict";
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { mkdtemp, rm, symlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { test } from "vitest";
+
+const packageDir = fileURLToPath(new URL("..", import.meta.url));
+const mcpBin = fileURLToPath(new URL("../dist/index.js", import.meta.url));
+
+type InitializeResponse = {
+  id: number;
+  result: {
+    serverInfo: {
+      name: string;
+    };
+  };
+};
+
+test("responds to initialize when invoked through an npm-style symlink", async () => {
+  const bin = await symlinkedMcpServer();
+  let child: ChildProcessWithoutNullStreams | undefined;
+  try {
+    child = spawn(process.execPath, [bin.path], {
+      cwd: packageDir,
+      env: { ...process.env },
+    });
+
+    const responsePromise = readJsonRpcResponse(child, 5000);
+    child.stdin.write(
+      encodeMessage({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "dbx-test", version: "0.0.0" },
+        },
+      }),
+    );
+
+    const response = await responsePromise;
+
+    assert.equal(response.id, 1);
+    assert.equal(response.result.serverInfo.name, "dbx");
+  } finally {
+    child?.kill();
+    await rm(bin.dir, { recursive: true, force: true });
+  }
+});
+
+async function symlinkedMcpServer() {
+  const dir = await mkdtemp(join(tmpdir(), "dbx-mcp-bin-"));
+  const path = join(dir, "dbx-mcp-server");
+  await symlink(mcpBin, path);
+  return { dir, path };
+}
+
+function encodeMessage(payload: unknown): string {
+  return `${JSON.stringify(payload)}\n`;
+}
+
+function readJsonRpcResponse(child: ChildProcessWithoutNullStreams, timeoutMs: number): Promise<InitializeResponse> {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error(`Timed out waiting for initialize response. stderr: ${stderr}`));
+    }, timeoutMs);
+
+    const cleanup = () => {
+      clearTimeout(timeout);
+      child.stdout.off("data", onStdout);
+      child.stderr.off("data", onStderr);
+      child.off("exit", onExit);
+      child.off("error", onError);
+    };
+
+    const onStdout = (chunk: Buffer) => {
+      stdout += chunk.toString("utf-8");
+      const lineEnd = stdout.indexOf("\n");
+      if (lineEnd === -1) return;
+      cleanup();
+      resolve(JSON.parse(stdout.slice(0, lineEnd)));
+    };
+
+    const onStderr = (chunk: Buffer) => {
+      stderr += chunk.toString("utf-8");
+    };
+
+    const onExit = (code: number | null, signal: NodeJS.Signals | null) => {
+      cleanup();
+      reject(new Error(`MCP server exited before initialize response. code=${code} signal=${signal} stderr: ${stderr}`));
+    };
+
+    const onError = (error: Error) => {
+      cleanup();
+      reject(error);
+    };
+
+    child.stdout.on("data", onStdout);
+    child.stderr.on("data", onStderr);
+    child.on("exit", onExit);
+    child.on("error", onError);
+  });
+}
diff --git a/packages/mcp-server/tests/driver-manifest.test.ts b/packages/mcp-server/tests/driver-manifest.test.ts
new file mode 100644
index 0000000..6538050
--- /dev/null
+++ b/packages/mcp-server/tests/driver-manifest.test.ts
@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { test } from "vitest";
+import { DBX_CONNECTION_TYPE_DESCRIPTION } from "../src/index.js";
+
+interface DriverManifest {
+  drivers: Array<{
+    dbType: string;
+    supportLevel: "connect" | "browse" | "understand" | "operate";
+    capabilities: Record<DatabaseProductCapability, boolean>;
+  }>;
+}
+
+const PRODUCT_CAPABILITY_KEYS = [
+  "queryExecution",
+  "metadataBrowse",
+  "objectBrowser",
+  "objectSource",
+  "schemaSearch",
+  "diagram",
+  "tableDataEdit",
+  "tableStructureEdit",
+  "tableImport",
+  "dataTransfer",
+  "sqlFileExecution",
+  "databaseCreate",
+  "fieldLineage",
+  "sqlExplain",
+  "userAdmin",
+  "driverManagement",
+] as const;
+type DatabaseProductCapability = (typeof PRODUCT_CAPABILITY_KEYS)[number];
+
+function loadManifest(): DriverManifest {
+  const path = fileURLToPath(new URL("../../../crates/dbx-core/assets/database-drivers.manifest.json", import.meta.url));
+  return JSON.parse(readFileSync(path, "utf8")) as DriverManifest;
+}
+
+test("add connection database type description includes every manifest database type", () => {
+  const manifest = loadManifest();
+
+  for (const driver of manifest.drivers) {
+    assert.match(DBX_CONNECTION_TYPE_DESCRIPTION, new RegExp(`\\b${driver.dbType}\\b`));
+  }
+});
+
+test("driver manifest includes product capability metadata for every database type", () => {
+  const manifest = loadManifest();
+
+  for (const driver of manifest.drivers) {
+    assert.match(driver.supportLevel, /^(connect|browse|understand|operate)$/);
+    for (const key of PRODUCT_CAPABILITY_KEYS) {
+      assert.equal(typeof driver.capabilities[key], "boolean", `${driver.dbType}.${key} should be a boolean`);
+    }
+  }
+});
diff --git a/packages/mcp-server/tests/server.test.ts b/packages/mcp-server/tests/server.test.ts
new file mode 100644
index 0000000..d64f012
--- /dev/null
+++ b/packages/mcp-server/tests/server.test.ts
@@ -0,0 +1,791 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "vitest";
+import type { Backend, ConnectionConfig } from "@dbx-app/node-core";
+import { createDbxMcpServer, DBX_MCP_PACKAGE_VERSION } from "../src/index.js";
+
+const connection: ConnectionConfig = {
+  id: "1",
+  name: "local",
+  db_type: "postgres",
+  host: "127.0.0.1",
+  port: 5432,
+  username: "app",
+  password: "",
+  database: "demo",
+  ssh_enabled: false,
+  ssl: false,
+};
+
+const backend: Backend = {
+  loadConnections: async () => [connection],
+  findConnection: async (name) => (name === "local" ? connection : undefined),
+  addConnection: async () => connection,
+  removeConnection: async () => true,
+  listTables: async () => [{ name: "users", type: "BASE TABLE" }],
+  describeTable: async () => [{ name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, comment: null }],
+  executeQuery: async () => ({ columns: ["total"], rows: [{ total: 1 }], row_count: 1 }),
+};
+
+async function withScopedEnv<T>(env: Record<string, string>, fn: () => T | Promise<T>): Promise<T> {
+  const oldValues = new Map<string, string | undefined>();
+  for (const key of Object.keys(env)) {
+    oldValues.set(key, process.env[key]);
+    process.env[key] = env[key];
+  }
+  try {
+    return await fn();
+  } finally {
+    for (const [key, value] of oldValues) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  }
+}
+
+test("creates an MCP server without starting stdio transport", () => {
+  const server = createDbxMcpServer(backend, { isWebMode: true });
+
+  assert.equal(typeof server.connect, "function");
+});
+
+test("MCP server metadata version matches package metadata", () => {
+  const server = createDbxMcpServer(backend, { isWebMode: true });
+
+  assert.equal((server as any).server._serverInfo.version, DBX_MCP_PACKAGE_VERSION);
+});
+
+test("README runtime requirements match package engines", async () => {
+  const packageJson = JSON.parse(await readFile(new URL("../package.json", import.meta.url), "utf-8")) as {
+    engines: { node: string };
+  };
+  const readme = await readFile(new URL("../README.md", import.meta.url), "utf-8");
+  const minimumNodeVersion = packageJson.engines.node.replace(">=", "");
+
+  assert.match(readme, new RegExp(`Node\\.js ${minimumNodeVersion.replace(/\./g, "\\.")} or newer`));
+  assert.match(readme, new RegExp(`Node\\.js ${minimumNodeVersion.replace(/\./g, "\\.")} 或更高版本`));
+});
+
+test("execute query scopes the connection to the requested database", async () => {
+  let usedDatabase = "";
+  const scopedBackend: Backend = {
+    ...backend,
+    executeQuery: async (config) => {
+      usedDatabase = config.database || "";
+      return { columns: ["total"], rows: [{ total: 1 }], row_count: 1 };
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  await (server as any)._registeredTools.dbx_execute_query.handler({
+    connection_name: "local",
+    database: "stores_demo",
+    sql: "SELECT FIRST 1 tabname FROM systables",
+  });
+
+  assert.equal(usedDatabase, "stores_demo");
+});
+
+test("execute query runs safe multi-statement SQL one statement at a time", async () => {
+  const executed: string[] = [];
+  const scopedBackend: Backend = {
+    ...backend,
+    executeQuery: async (_config, sql) => {
+      executed.push(sql);
+      return { columns: ["value"], rows: [{ value: executed.length }], row_count: 1 };
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_execute_query.handler({
+    connection_name: "local",
+    sql: "select 1; select 2;",
+  });
+
+  assert.deepEqual(executed, ["select 1", "select 2"]);
+  assert.match(result.content[0].text, /Statement 1/);
+  assert.match(result.content[0].text, /Statement 2/);
+});
+
+test("execute query reports the blocked statement number for unsafe multi-statement SQL", async () => {
+  const server = createDbxMcpServer(backend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_execute_query.handler({
+    connection_name: "local",
+    sql: "select 1; delete from users;",
+  });
+
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /SQL_BLOCKED:/);
+  assert.match(result.content[0].text, /Statement 2/);
+  assert.match(result.content[0].text, /WHERE/);
+});
+
+test("scoped MCP lists only the active connection", async () => {
+  const other: ConnectionConfig = { ...connection, id: "2", name: "other", database: "other_db" };
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [connection, other],
+  };
+
+  const result = await withScopedEnv({ DBX_MCP_SCOPE_CONNECTION_ID: "1" }, () => {
+    const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+    return (server as any)._registeredTools.dbx_list_connections.handler({});
+  });
+
+  assert.match(result.content[0].text, /local/);
+  assert.doesNotMatch(result.content[0].text, /other/);
+});
+
+test("scoped MCP rejects out-of-scope connection tool calls", async () => {
+  const result = await withScopedEnv({ DBX_MCP_SCOPE_CONNECTION_ID: "1" }, () => {
+    const server = createDbxMcpServer(backend, { isWebMode: true });
+    return (server as any)._registeredTools.dbx_list_tables.handler({ connection_name: "other" });
+  });
+
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /CONNECTION_OUT_OF_SCOPE:/);
+});
+
+test("scoped MCP defaults connection-taking tools to the active connection and database", async () => {
+  let usedDatabase = "";
+  const scopedBackend: Backend = {
+    ...backend,
+    listTables: async (config) => {
+      usedDatabase = config.database || "";
+      return [{ name: "users", type: "BASE TABLE" }];
+    },
+  };
+
+  const result = await withScopedEnv({ DBX_MCP_SCOPE_CONNECTION_ID: "1", DBX_MCP_SCOPE_DATABASE: "scoped_db" }, () => {
+    const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+    return (server as any)._registeredTools.dbx_list_tables.handler({});
+  });
+
+  assert.match(result.content[0].text, /users/);
+  assert.equal(usedDatabase, "scoped_db");
+});
+
+test("scoped MCP does not register mutation or desktop bridge tools", async () => {
+  await withScopedEnv({ DBX_MCP_SCOPE_CONNECTION_ID: "1" }, () => {
+    const server = createDbxMcpServer(backend, { isWebMode: false });
+    const tools = (server as any)._registeredTools;
+
+    assert.equal(tools.dbx_add_connection, undefined);
+    assert.equal(tools.dbx_remove_connection, undefined);
+    assert.equal(tools.dbx_open_table, undefined);
+    assert.equal(tools.dbx_execute_and_show, undefined);
+  });
+});
+
+test("scoped MCP with writes disabled blocks write SQL", async () => {
+  const result = await withScopedEnv({ DBX_MCP_SCOPE_CONNECTION_ID: "1", DBX_MCP_ALLOW_WRITES: "0" }, () => {
+    const server = createDbxMcpServer(backend, { isWebMode: true });
+    return (server as any)._registeredTools.dbx_execute_query.handler({
+      sql: "update users set name = 'x' where id = 1",
+    });
+  });
+
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /SQL_BLOCKED:/);
+});
+
+test("redis execute query points callers to the redis command tool", async () => {
+  const redisConnection: ConnectionConfig = { ...connection, db_type: "redis", database: "0" };
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [redisConnection],
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_execute_query.handler({
+    connection_name: "local",
+    sql: "GET session:1",
+  });
+
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /REDIS_COMMAND_REQUIRED:/);
+  assert.match(result.content[0].text, /dbx_execute_redis_command/);
+});
+
+test("redis command tool executes redis commands on the selected database", async () => {
+  const redisConnection: ConnectionConfig = { ...connection, db_type: "redis", database: "2" };
+  let usedDb = -1;
+  let usedCommand = "";
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [redisConnection],
+    executeRedisCommand: async (_config, db, command) => {
+      usedDb = db;
+      usedCommand = command;
+      return { command: "GET", safety: "allowed", value: "value-1" };
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_execute_redis_command.handler({
+    connection_name: "local",
+    command: "GET session:1",
+  });
+
+  assert.equal(result.isError, undefined);
+  assert.equal(usedDb, 2);
+  assert.equal(usedCommand, "GET session:1");
+  assert.match(result.content[0].text, /Command: GET/);
+  assert.match(result.content[0].text, /value-1/);
+});
+
+test("redis command tool blocks write commands in read-only MCP sessions", async () => {
+  let executed = false;
+  const redisConnection: ConnectionConfig = { ...connection, db_type: "redis" };
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [redisConnection],
+    executeRedisCommand: async () => {
+      executed = true;
+      return { command: "SET", safety: "write", value: "OK" };
+    },
+  };
+
+  const result = await withScopedEnv({ DBX_MCP_ALLOW_WRITES: "0" }, () => {
+    const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+    return (server as any)._registeredTools.dbx_execute_redis_command.handler({
+      connection_name: "local",
+      command: "SET session:1 value",
+    });
+  });
+
+  assert.equal(executed, false);
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /REDIS_COMMAND_BLOCKED:/);
+});
+
+test("redis command tool allows dangerous redis commands only when explicitly enabled", async () => {
+  const redisConnection: ConnectionConfig = { ...connection, db_type: "redis" };
+  let skipSafetyCheck = false;
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [redisConnection],
+    executeRedisCommand: async (_config, _db, _command, options) => {
+      skipSafetyCheck = options?.skipSafetyCheck ?? false;
+      return { command: "KEYS", safety: "blocked", value: ["session:1"] };
+    },
+  };
+
+  const blocked = await withScopedEnv({ DBX_MCP_ALLOW_DANGEROUS_SQL: "0" }, () => {
+    const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+    return (server as any)._registeredTools.dbx_execute_redis_command.handler({
+      connection_name: "local",
+      command: "KEYS *",
+    });
+  });
+  const allowed = await withScopedEnv({ DBX_MCP_ALLOW_DANGEROUS_SQL: "1" }, () => {
+    const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+    return (server as any)._registeredTools.dbx_execute_redis_command.handler({
+      connection_name: "local",
+      command: "KEYS *",
+    });
+  });
+
+  assert.equal(blocked.isError, true);
+  assert.match(blocked.content[0].text, /REDIS_COMMAND_BLOCKED:/);
+  assert.equal(allowed.isError, undefined);
+  assert.equal(skipSafetyCheck, true);
+  assert.match(allowed.content[0].text, /session:1/);
+});
+
+test("mongodb list tables returns collections from the selected database", async () => {
+  let usedDatabase = "";
+  const mongoConnection: ConnectionConfig = { ...connection, db_type: "mongodb", database: "admin" };
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [mongoConnection],
+    listTables: async (config) => {
+      usedDatabase = config.database || "";
+      return [{ name: "projects", type: "COLLECTION" }];
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_list_tables.handler({
+    connection_name: "local",
+    database: "pystrument",
+  });
+
+  assert.equal(usedDatabase, "pystrument");
+  assert.match(result.content[0].text, /projects/);
+  assert.match(result.content[0].text, /COLLECTION/);
+});
+
+test("mongodb describe table returns inferred document fields", async () => {
+  const mongoConnection: ConnectionConfig = { ...connection, db_type: "mongodb" };
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [mongoConnection],
+    describeTable: async () => [
+      {
+        name: "_id",
+        data_type: "object",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: true,
+        comment: null,
+      },
+      {
+        name: "name",
+        data_type: "string",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: false,
+        comment: null,
+      },
+    ],
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_describe_table.handler({
+    connection_name: "local",
+    database: "pystrument",
+    table: "projects",
+  });
+
+  assert.match(result.content[0].text, /_id \(PK\)/);
+  assert.match(result.content[0].text, /name/);
+});
+
+test("dameng metadata tools default to the login user schema", async () => {
+  const damengConnection: ConnectionConfig = {
+    ...connection,
+    db_type: "dameng",
+    username: "SYSDBA",
+    database: "DAMENG",
+  };
+  const usedScopes: Array<{ database?: string; schema?: string }> = [];
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [damengConnection],
+    listTables: async (config, schema) => {
+      usedScopes.push({ database: config.database, schema });
+      return [{ name: "ORDERS", type: "TABLE" }];
+    },
+    describeTable: async (config, _table, schema) => {
+      usedScopes.push({ database: config.database, schema });
+      return [{ name: "ID", data_type: "BIGINT", is_nullable: false, column_default: null, is_primary_key: true, comment: null }];
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  await (server as any)._registeredTools.dbx_list_tables.handler({ connection_name: "local" });
+  await (server as any)._registeredTools.dbx_describe_table.handler({ connection_name: "local", table: "ORDERS" });
+
+  assert.deepEqual(usedScopes, [
+    { database: "DAMENG", schema: "SYSDBA" },
+    { database: "DAMENG", schema: "SYSDBA" },
+  ]);
+});
+
+test("dameng metadata tools treat database as a schema alias while preferring explicit schema", async () => {
+  const damengConnection: ConnectionConfig = { ...connection, db_type: "dameng", username: "SYSDBA", database: "DAMENG" };
+  let usedSchema = "";
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [damengConnection],
+    listTables: async (_config, schema) => {
+      usedSchema = schema || "";
+      return [{ name: "ORDERS", type: "TABLE" }];
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  await (server as any)._registeredTools.dbx_list_tables.handler({ connection_name: "local", database: "XC" });
+
+  assert.equal(usedSchema, "XC");
+
+  await (server as any)._registeredTools.dbx_list_tables.handler({ connection_name: "local", database: "XC", schema: "REPORTING" });
+
+  assert.equal(usedSchema, "REPORTING");
+});
+
+test("mongodb execute query formats shell-style find results", async () => {
+  const mongoConnection: ConnectionConfig = { ...connection, db_type: "mongodb" };
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [mongoConnection],
+    executeQuery: async () => ({
+      columns: ["_id", "meta", "missing"],
+      rows: [{ _id: "1", meta: { name: "demo" }, missing: null }],
+      row_count: 1,
+    }),
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_execute_query.handler({
+    connection_name: "local",
+    database: "pystrument",
+    sql: "db.projects.find({}).limit(1)",
+  });
+
+  assert.match(result.content[0].text, /"name":"demo"/);
+  assert.match(result.content[0].text, /NULL/);
+  assert.match(result.content[0].text, /1 row\(s\)/);
+});
+
+test("connection lookup failures include a stable MCP error code", async () => {
+  const server = createDbxMcpServer(backend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_list_tables.handler({
+    connection_name: "missing",
+  });
+
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /CONNECTION_NOT_FOUND:/);
+  assert.match(result.content[0].text, /missing/);
+});
+
+test("add connection accepts H2 file paths without a port", async () => {
+  let added: Omit<ConnectionConfig, "id"> | undefined;
+  const scopedBackend: Backend = {
+    ...backend,
+    addConnection: async (config) => {
+      added = config;
+      return { id: "h2-file", ...config };
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_add_connection.handler({
+    name: "h2-local",
+    db_type: "h2",
+    host: "/data/app.mv.db",
+    username: "sa",
+    password: "",
+  });
+
+  assert.equal(result.isError, undefined);
+  assert.equal(added?.db_type, "h2");
+  assert.equal(added?.host, "/data/app.mv.db");
+  assert.equal(added?.port, 0);
+});
+
+test("SQL safety failures include a stable MCP error code", async () => {
+  const server = createDbxMcpServer(backend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_execute_query.handler({
+    connection_name: "local",
+    sql: "drop table users",
+  });
+
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /SQL_BLOCKED:/);
+  assert.match(result.content[0].text, /Dangerous SQL/);
+});
+
+test("query exceptions include a stable MCP error code", async () => {
+  const scopedBackend: Backend = {
+    ...backend,
+    executeQuery: async () => {
+      throw new Error("database timeout");
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_execute_query.handler({
+    connection_name: "local",
+    sql: "select 1",
+  });
+
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /QUERY_ERROR: database timeout/);
+});
+
+test("desktop bridge failures include a stable MCP error code", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "dbx-mcp-home-"));
+
+  try {
+    // Use DBX_DATA_DIR (honoured cross-platform) to point bridgePortFilePath()
+    // at an empty temp directory so no real bridge is reachable.
+    await withScopedEnv({ DBX_DATA_DIR: dir }, async () => {
+      const server = createDbxMcpServer(backend, { isWebMode: false });
+      const result = await (server as any)._registeredTools.dbx_open_table.handler({
+        connection_name: "local",
+        table: "users",
+      });
+
+      assert.equal(result.isError, true);
+      assert.match(result.content[0].text, /DBX_NOT_RUNNING:/);
+      assert.match(result.content[0].text, /DBX is not running/);
+    });
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("mongodb execute-and-show blocks aggregate write stages before desktop bridge", async () => {
+  const oldAllowWrites = process.env.DBX_MCP_ALLOW_WRITES;
+  const oldAllowDangerous = process.env.DBX_MCP_ALLOW_DANGEROUS_SQL;
+  delete process.env.DBX_MCP_ALLOW_WRITES;
+  delete process.env.DBX_MCP_ALLOW_DANGEROUS_SQL;
+  const mongoConnection: ConnectionConfig = { ...connection, db_type: "mongodb" };
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [mongoConnection],
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: false });
+
+  try {
+    const result = await (server as any)._registeredTools.dbx_execute_and_show.handler({
+      connection_name: "local",
+      database: "pystrument",
+      sql: 'db.projects.aggregate([{"$out":"projects_dump"}])',
+    });
+
+    assert.match(result.content[0].text, /SQL_BLOCKED:/);
+    assert.match(result.content[0].text, /DBX_MCP_ALLOW_DANGEROUS_SQL=1/);
+  } finally {
+    if (oldAllowWrites === undefined) delete process.env.DBX_MCP_ALLOW_WRITES;
+    else process.env.DBX_MCP_ALLOW_WRITES = oldAllowWrites;
+    if (oldAllowDangerous === undefined) delete process.env.DBX_MCP_ALLOW_DANGEROUS_SQL;
+    else process.env.DBX_MCP_ALLOW_DANGEROUS_SQL = oldAllowDangerous;
+  }
+});
+
+test("connection_id parameter resolves correctly", async () => {
+  const connA: ConnectionConfig = { ...connection, id: "a1b2c3", name: "shared-name", db_type: "postgres" };
+  const connB: ConnectionConfig = { ...connection, id: "d4e5f6", name: "shared-name", db_type: "redis", host: "redis.local", port: 6379 };
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [connA, connB],
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  // Resolve by connection_id should return the correct connection
+  const result = await (server as any)._registeredTools.dbx_list_tables.handler({
+    connection_id: "d4e5f6",
+  });
+
+  assert.match(result.content[0].text, /users/);
+});
+
+test("duplicate connection names return AMBIGUOUS_CONNECTION error", async () => {
+  const connA: ConnectionConfig = { ...connection, id: "a1b2c3", name: "shared-name", db_type: "postgres", host: "pg.local", port: 5432 };
+  const connB: ConnectionConfig = { ...connection, id: "d4e5f6", name: "shared-name", db_type: "redis", host: "redis.local", port: 6379 };
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [connA, connB],
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  // Using connection_name with duplicates should return AMBIGUOUS_CONNECTION
+  const result = await (server as any)._registeredTools.dbx_list_tables.handler({
+    connection_name: "shared-name",
+  });
+
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /AMBIGUOUS_CONNECTION:/);
+  assert.match(result.content[0].text, /a1b2c3:/);
+  assert.match(result.content[0].text, /d4e5f6:/);
+  assert.match(result.content[0].text, /postgres @ pg.local:5432/);
+  assert.match(result.content[0].text, /redis @ redis.local:6379/);
+});
+
+test("connection_id takes priority over connection_name", async () => {
+  const connA: ConnectionConfig = { ...connection, id: "a1b2c3", name: "shared-name", db_type: "postgres" };
+  const connB: ConnectionConfig = { ...connection, id: "d4e5f6", name: "shared-name", db_type: "mysql", host: "mysql.local", port: 3306 };
+  let usedConfig: ConnectionConfig | undefined;
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [connA, connB],
+    listTables: async (config) => {
+      usedConfig = config;
+      return [{ name: "users", type: "BASE TABLE" }];
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  // Provide both connection_id and connection_name; connection_id should win
+  await (server as any)._registeredTools.dbx_list_tables.handler({
+    connection_id: "d4e5f6",
+    connection_name: "shared-name",
+  });
+
+  assert.equal(usedConfig?.id, "d4e5f6");
+});
+
+test("dbx_list_connections includes ID column", async () => {
+  const server = createDbxMcpServer(backend, { isWebMode: true });
+  const result = await (server as any)._registeredTools.dbx_list_connections.handler({});
+
+  // The table header should include the ID column
+  assert.match(result.content[0].text, /ID.*Name.*Type.*Host.*Port.*Database/);
+  // The connection's ID value "1" should appear in the table
+  assert.match(result.content[0].text, /1\s+\|\s+local/);
+});
+
+test("same name and db_type with different host/port returns AMBIGUOUS_CONNECTION", async () => {
+  const connA: ConnectionConfig = {
+    ...connection,
+    id: "pg-prod-us",
+    name: "my-db",
+    db_type: "postgres",
+    host: "10.0.1.100",
+    port: 5432,
+    database: "app",
+  };
+  const connB: ConnectionConfig = {
+    ...connection,
+    id: "pg-prod-eu",
+    name: "my-db",
+    db_type: "postgres",
+    host: "10.0.2.200",
+    port: 5432,
+    database: "app",
+  };
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [connA, connB],
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  // Using connection_name with duplicates (same db_type) should still return AMBIGUOUS_CONNECTION
+  const result = await (server as any)._registeredTools.dbx_list_tables.handler({
+    connection_name: "my-db",
+  });
+
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /AMBIGUOUS_CONNECTION:/);
+  assert.match(result.content[0].text, /pg-prod-us: postgres @ 10\.0\.1\.100:5432/);
+  assert.match(result.content[0].text, /pg-prod-eu: postgres @ 10\.0\.2\.200:5432/);
+});
+
+test("connection_id routes to correct host among same-name same-type connections", async () => {
+  const connA: ConnectionConfig = {
+    ...connection,
+    id: "pg-prod-us",
+    name: "my-db",
+    db_type: "postgres",
+    host: "10.0.1.100",
+    port: 5432,
+    database: "app",
+  };
+  const connB: ConnectionConfig = {
+    ...connection,
+    id: "pg-prod-eu",
+    name: "my-db",
+    db_type: "postgres",
+    host: "10.0.2.200",
+    port: 5432,
+    database: "app",
+  };
+  const usedConfigs: ConnectionConfig[] = [];
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [connA, connB],
+    listTables: async (config) => {
+      usedConfigs.push(config);
+      return [{ name: "orders", type: "BASE TABLE" }];
+    },
+    executeQuery: async (config, _sql) => {
+      usedConfigs.push(config);
+      return { columns: ["cnt"], rows: [{ cnt: 42 }], row_count: 1 };
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  // Route to US instance via connection_id
+  const listResult = await (server as any)._registeredTools.dbx_list_tables.handler({
+    connection_id: "pg-prod-us",
+  });
+  assert.match(listResult.content[0].text, /orders/);
+  assert.equal(usedConfigs[0].id, "pg-prod-us");
+  assert.equal(usedConfigs[0].host, "10.0.1.100");
+
+  // Route to EU instance via connection_id
+  const queryResult = await (server as any)._registeredTools.dbx_execute_query.handler({
+    connection_id: "pg-prod-eu",
+    database: "app",
+    sql: "select count(*) as cnt from orders",
+  });
+  assert.match(queryResult.content[0].text, /42/);
+  assert.equal(usedConfigs[1].id, "pg-prod-eu");
+  assert.equal(usedConfigs[1].host, "10.0.2.200");
+});
+
+test("tool responses are prefixed with connection identity label", async () => {
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [{ ...connection, id: "conn-xyz", name: "orders-db", db_type: "postgres", host: "10.5.5.5", port: 5432 }],
+    listTables: async () => [{ name: "orders", type: "BASE TABLE" }],
+    executeQuery: async () => ({ columns: ["cnt"], rows: [{ cnt: 7 }], row_count: 1 }),
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  const listResult = await (server as any)._registeredTools.dbx_list_tables.handler({ connection_id: "conn-xyz" });
+  assert.match(listResult.content[0].text, /^\[orders-db \(conn-xyz\) \[postgres @ 10\.5\.5\.5:5432\]\]/);
+
+  const queryResult = await (server as any)._registeredTools.dbx_execute_query.handler({ connection_id: "conn-xyz", sql: "select count(*) as cnt from orders" });
+  assert.match(queryResult.content[0].text, /^\[orders-db \(conn-xyz\) \[postgres @ 10\.5\.5\.5:5432\]\]/);
+});
+
+test("dbx_remove_connection with duplicate names returns AMBIGUOUS_CONNECTION", async () => {
+  const connA: ConnectionConfig = { ...connection, id: "db-a", name: "staging", db_type: "postgres", host: "pg-a.local" };
+  const connB: ConnectionConfig = { ...connection, id: "db-b", name: "staging", db_type: "mysql", host: "mysql-b.local", port: 3306 };
+  let removedName: string | undefined;
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [connA, connB],
+    removeConnection: async (name) => {
+      removedName = name;
+      return true;
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  const result = await (server as any)._registeredTools.dbx_remove_connection.handler({
+    connection_name: "staging",
+  });
+
+  assert.equal(result.isError, true);
+  assert.match(result.content[0].text, /AMBIGUOUS_CONNECTION:/);
+  assert.match(result.content[0].text, /db-a: postgres @ pg-a\.local/);
+  assert.match(result.content[0].text, /db-b: mysql @ mysql-b\.local/);
+  // removeConnection must NOT have been called — no silent deletion
+  assert.equal(removedName, undefined);
+});
+
+test("dbx_execute_query with connection_id routes correctly on bridge-backed (SSH) connections", async () => {
+  const connDirect: ConnectionConfig = { ...connection, id: "pg-direct", name: "shared", db_type: "postgres", host: "direct.local", ssh_enabled: false };
+  const connSsh: ConnectionConfig = { ...connection, id: "pg-ssh", name: "shared", db_type: "postgres", host: "private.local", ssh_enabled: true };
+  const usedConfigs: ConnectionConfig[] = [];
+  const scopedBackend: Backend = {
+    ...backend,
+    loadConnections: async () => [connDirect, connSsh],
+    executeQuery: async (config, _sql) => {
+      usedConfigs.push(config);
+      return { columns: ["result"], rows: [{ result: "ok" }], row_count: 1 };
+    },
+  };
+  const server = createDbxMcpServer(scopedBackend, { isWebMode: true });
+
+  // connection_name with two same-name connections (one SSH-backed) → AMBIGUOUS_CONNECTION
+  const ambigResult = await (server as any)._registeredTools.dbx_execute_query.handler({
+    connection_name: "shared",
+    sql: "select 1",
+  });
+  assert.equal(ambigResult.isError, true);
+  assert.match(ambigResult.content[0].text, /AMBIGUOUS_CONNECTION:/);
+  assert.match(ambigResult.content[0].text, /pg-direct/);
+  assert.match(ambigResult.content[0].text, /pg-ssh/);
+
+  // connection_id routes to the SSH-backed instance and passes its config through
+  const result = await (server as any)._registeredTools.dbx_execute_query.handler({
+    connection_id: "pg-ssh",
+    sql: "select 1",
+  });
+  assert.equal(result.isError, undefined);
+  assert.equal(usedConfigs.length, 1);
+  assert.equal(usedConfigs[0].id, "pg-ssh");
+  assert.equal(usedConfigs[0].host, "private.local");
+  assert.equal(usedConfigs[0].ssh_enabled, true);
+});
diff --git a/packages/mcp-server/tsconfig.json b/packages/mcp-server/tsconfig.json
new file mode 100644
index 0000000..27e5870
--- /dev/null
+++ b/packages/mcp-server/tsconfig.json
@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "types": ["node"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true
+  },
+  "include": ["src"]
+}
diff --git a/packages/mcp-server/vitest.config.ts b/packages/mcp-server/vitest.config.ts
new file mode 100644
index 0000000..4cfb639
--- /dev/null
+++ b/packages/mcp-server/vitest.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/*.test.ts"],
+  },
+});
diff --git a/packages/node-core/README.md b/packages/node-core/README.md
new file mode 100644
index 0000000..69f055a
--- /dev/null
+++ b/packages/node-core/README.md
@@ -0,0 +1,27 @@
+# DBX Node Core
+
+Shared Node.js runtime utilities for DBX CLI and DBX MCP Server.
+
+This package reads DBX Desktop connection storage, redacts connection summaries, builds schema context, applies SQL safety rules, and executes supported direct database queries.
+
+## Supported Runtime
+
+Requires Node.js 22.13.0 or newer.
+
+## Direct Query Support
+
+Direct execution currently supports:
+
+- PostgreSQL and Redshift
+- MySQL-compatible databases, including MySQL, Doris, and StarRocks
+- SQLite
+
+Other DBX connection types can be routed through DBX Desktop bridge integrations used by the CLI and MCP server.
+
+## Public Modules
+
+```ts
+import { createBackend, loadConnections, getDbxDiagnostics, evaluateSqlSafety, buildSchemaContext } from "@dbx-app/node-core";
+```
+
+The package is intended as a shared implementation layer for official DBX Node packages. Applications should prefer `@dbx-app/cli` for terminal workflows and `@dbx-app/mcp-server` for MCP clients.
diff --git a/packages/node-core/package.json b/packages/node-core/package.json
new file mode 100644
index 0000000..7d55077
--- /dev/null
+++ b/packages/node-core/package.json
@@ -0,0 +1,48 @@
+{
+  "name": "@dbx-app/node-core",
+  "version": "0.4.28",
+  "description": "Shared Node.js database and DBX connection utilities for DBX CLI and MCP server",
+  "license": "Apache-2.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./backend": "./dist/backend.js",
+    "./bridge": "./dist/bridge.js",
+    "./connections": "./dist/connections.js",
+    "./database": "./dist/database.js",
+    "./diagnostics": "./dist/diagnostics.js",
+    "./entrypoint": "./dist/entrypoint.js",
+    "./format": "./dist/format.js",
+    "./paths": "./dist/paths.js",
+    "./production-safety": "./dist/production-safety.js",
+    "./redis-command": "./dist/redis-command.js",
+    "./schema-context": "./dist/schema-context.js",
+    "./sql-risk": "./dist/sql-risk.js",
+    "./sql-safety": "./dist/sql-safety.js"
+  },
+  "scripts": {
+    "test": "vitest run --config vitest.config.ts",
+    "build": "tsc",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "better-sqlite3": "^12.9.0",
+    "ioredis": "^5.11.1",
+    "keytar": "^7.9.0",
+    "mysql2": "^3.14.1",
+    "pg": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.15.21",
+    "@types/pg": "^8.15.4",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  }
+}
diff --git a/packages/node-core/src/backend.ts b/packages/node-core/src/backend.ts
new file mode 100644
index 0000000..8f0be02
--- /dev/null
+++ b/packages/node-core/src/backend.ts
@@ -0,0 +1,37 @@
+import { addConnection as desktopAddConnection, findConnection as desktopFindConnection, loadConnections as desktopLoadConnections, removeConnection as desktopRemoveConnection, removeConnectionById as desktopRemoveConnectionById } from "./connections.js";
+import { closeDatabaseResources as desktopCloseDatabaseResources, describeTable as desktopDescribeTable, executeQuery as desktopExecuteQuery, executeRedisCommand as desktopExecuteRedisCommand, listTables as desktopListTables } from "./database.js";
+import type { ConnectionConfig } from "./connections.js";
+import type { ColumnInfo, QueryOptions, QueryResult, TableInfo } from "./database.js";
+import type { RedisCommandOptions, RedisCommandResult } from "./redis-command.js";
+
+export interface Backend {
+  loadConnections(): Promise<ConnectionConfig[]>;
+  findConnection(name: string): Promise<ConnectionConfig | undefined>;
+  addConnection(config: Omit<ConnectionConfig, "id">): Promise<ConnectionConfig>;
+  removeConnection(name: string): Promise<boolean>;
+  removeConnectionById?(id: string): Promise<boolean>;
+  listTables(config: ConnectionConfig, schema?: string): Promise<TableInfo[]>;
+  describeTable(config: ConnectionConfig, table: string, schema?: string): Promise<ColumnInfo[]>;
+  executeQuery(config: ConnectionConfig, sql: string, options?: QueryOptions): Promise<QueryResult>;
+  executeRedisCommand?(config: ConnectionConfig, db: number, command: string, options?: RedisCommandOptions): Promise<RedisCommandResult>;
+  close?(): Promise<void>;
+}
+
+export async function createBackend(env: NodeJS.ProcessEnv = process.env): Promise<Backend> {
+  if (env.DBX_WEB_URL) {
+    return await import("./web-backend.js");
+  }
+
+  return {
+    loadConnections: desktopLoadConnections,
+    findConnection: desktopFindConnection,
+    addConnection: desktopAddConnection,
+    removeConnection: desktopRemoveConnection,
+    removeConnectionById: desktopRemoveConnectionById,
+    listTables: desktopListTables,
+    describeTable: desktopDescribeTable,
+    executeQuery: desktopExecuteQuery,
+    executeRedisCommand: desktopExecuteRedisCommand,
+    close: desktopCloseDatabaseResources,
+  };
+}
diff --git a/packages/node-core/src/bridge.ts b/packages/node-core/src/bridge.ts
new file mode 100644
index 0000000..475f481
--- /dev/null
+++ b/packages/node-core/src/bridge.ts
@@ -0,0 +1,25 @@
+import { readFile } from "node:fs/promises";
+import { bridgePortFilePath } from "./paths.js";
+
+export async function getBridgeUrl(): Promise<string> {
+  const port = (await readFile(bridgePortFilePath(), "utf-8")).trim();
+  return `http://127.0.0.1:${port}`;
+}
+
+export async function postBridge(path: string, body: Record<string, unknown>): Promise<{ ok: true; text: string } | { ok: false; text: string }> {
+  try {
+    const bridgeUrl = await getBridgeUrl();
+    const res = await fetch(`${bridgeUrl}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    return { ok: res.ok, text: res.ok ? "" : await res.text() };
+  } catch {
+    return { ok: false, text: "DBX is not running. Please start DBX first." };
+  }
+}
+
+export async function notifyReload(): Promise<void> {
+  await postBridge("/reload-connections", {});
+}
diff --git a/packages/node-core/src/connections.ts b/packages/node-core/src/connections.ts
new file mode 100644
index 0000000..270879b
--- /dev/null
+++ b/packages/node-core/src/connections.ts
@@ -0,0 +1,376 @@
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import Database from "better-sqlite3";
+import { dbPath as defaultDbPath } from "./paths.js";
+
+export interface ConnectionConfig {
+  id: string;
+  name: string;
+  db_type: string;
+  driver_profile?: string;
+  host: string;
+  port: number;
+  username: string;
+  password: string;
+  database?: string;
+  url_params?: string;
+  transport_layers?: TransportLayerConfig[];
+  keepalive_interval_secs?: number;
+  ssl: boolean;
+  ca_cert_path?: string;
+  client_cert_path?: string;
+  client_key_path?: string;
+  oracle_connection_type?: "service_name" | "sid";
+  redis_connection_mode?: "standalone" | "sentinel" | "cluster";
+  redis_sentinel_master?: string;
+  redis_sentinel_nodes?: string;
+  redis_sentinel_username?: string;
+  redis_sentinel_password?: string;
+  redis_sentinel_tls?: boolean;
+  redis_cluster_nodes?: string;
+  redis_key_separator?: string;
+  read_only?: boolean;
+  is_production?: boolean;
+  production_databases?: string[];
+}
+
+export type TransportLayerConfig = ({ type: "ssh" } & SshTunnelConfig) | ({ type: "proxy" } & ProxyTunnelConfig);
+
+export interface SshTunnelConfig {
+  id: string;
+  name?: string;
+  enabled?: boolean;
+  host: string;
+  port: number;
+  user: string;
+  password?: string;
+  key_path?: string;
+  key_passphrase?: string;
+  connect_timeout_secs?: number;
+  expose_lan?: boolean;
+  use_ssh_agent?: boolean;
+  ssh_agent_sock_path?: string;
+}
+
+export interface ProxyTunnelConfig {
+  id: string;
+  name?: string;
+  enabled?: boolean;
+  proxy_type?: "socks5" | "http";
+  host: string;
+  port: number;
+  username?: string;
+  password?: string;
+}
+
+export interface ConnectionStoreOptions {
+  path?: string;
+}
+
+export interface ConnectionStoreDiagnostics {
+  dbPath: string;
+  dbPathExists: boolean;
+  connectionsTableExists: boolean;
+  connectionSecretsTableExists: boolean;
+  connectionRowCount: number;
+  loadConnectionsOk: boolean;
+  loadedConnectionCount: number;
+  loadConnectionsError?: string;
+}
+
+export class ConnectionStoreError extends Error {
+  readonly code = "CONNECTION_STORE_ERROR";
+
+  constructor(path: string, cause: unknown) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    super(`Failed to load DBX connections from ${path}: ${message}`);
+    this.name = "ConnectionStoreError";
+  }
+}
+
+export function canonicalizeConnection(config: ConnectionConfig): ConnectionConfig {
+  if (config.db_type === "mysql" && config.driver_profile?.toLowerCase() === "tdengine") {
+    return {
+      ...config,
+      db_type: "tdengine",
+      driver_profile: "tdengine",
+      port: config.port === 0 || config.port === 6030 ? 6041 : config.port,
+    };
+  }
+  if (config.db_type === "tdengine") {
+    return {
+      ...config,
+      driver_profile: "tdengine",
+      port: config.port || 6041,
+    };
+  }
+  return config;
+}
+
+function openDb(readonly = false, path = defaultDbPath()): Database.Database {
+  return new Database(path, { readonly });
+}
+
+function getSecret(db: Database.Database, connectionId: string, key: string): string {
+  const row = db.prepare("SELECT secret FROM connection_secrets WHERE connection_id = ? AND key = ?").get(connectionId, key) as { secret: string } | undefined;
+  return row?.secret ?? "";
+}
+
+function transportLayerSecretSegment(index: number, layer: TransportLayerConfig): string {
+  return layer.id?.trim() || String(index);
+}
+
+function transportLayerSshPasswordKey(index: number, layer: TransportLayerConfig): string {
+  return `transport_layers.${transportLayerSecretSegment(index, layer)}.ssh_password`;
+}
+
+function transportLayerSshKeyPassphraseKey(index: number, layer: TransportLayerConfig): string {
+  return `transport_layers.${transportLayerSecretSegment(index, layer)}.ssh_key_passphrase`;
+}
+
+function transportLayerProxyPasswordKey(index: number, layer: TransportLayerConfig): string {
+  return `transport_layers.${transportLayerSecretSegment(index, layer)}.proxy_password`;
+}
+
+type LegacyConnectionConfig = ConnectionConfig & {
+  ssh_enabled?: boolean;
+  ssh_host?: string;
+  ssh_port?: number;
+  ssh_user?: string;
+  ssh_password?: string;
+  ssh_key_path?: string;
+  ssh_key_passphrase?: string;
+  ssh_expose_lan?: boolean;
+  ssh_connect_timeout_secs?: number;
+  ssh_tunnels?: SshTunnelConfig[];
+  proxy_enabled?: boolean;
+  proxy_type?: "socks5" | "http";
+  proxy_host?: string;
+  proxy_port?: number;
+  proxy_username?: string;
+  proxy_password?: string;
+};
+
+function normalizeTransportLayers(config: LegacyConnectionConfig): TransportLayerConfig[] {
+  if (Array.isArray(config.transport_layers) && config.transport_layers.length > 0) return config.transport_layers;
+  const layers: TransportLayerConfig[] = [];
+  if (config.ssh_enabled && Array.isArray(config.ssh_tunnels) && config.ssh_tunnels.length > 0) {
+    layers.push(...config.ssh_tunnels.map((hop) => ({ type: "ssh" as const, ...hop })));
+  } else if (config.ssh_enabled && config.ssh_host) {
+    layers.push({
+      type: "ssh",
+      id: "legacy",
+      enabled: true,
+      host: config.ssh_host,
+      port: config.ssh_port || 22,
+      user: config.ssh_user || "",
+      password: config.ssh_password || "",
+      key_path: config.ssh_key_path || "",
+      key_passphrase: config.ssh_key_passphrase || "",
+      connect_timeout_secs: config.ssh_connect_timeout_secs || 5,
+      expose_lan: !!config.ssh_expose_lan,
+      use_ssh_agent: false,
+    });
+  }
+  if (config.proxy_enabled && config.proxy_host) {
+    layers.push({
+      type: "proxy",
+      id: "legacy-proxy",
+      enabled: true,
+      proxy_type: config.proxy_type || "socks5",
+      host: config.proxy_host,
+      port: config.proxy_port || 1080,
+      username: config.proxy_username || "",
+      password: config.proxy_password || "",
+    });
+  }
+  return layers;
+}
+
+function hydrateTransportLayerSecrets(db: Database.Database, config: ConnectionConfig, connectionId: string) {
+  config.transport_layers = normalizeTransportLayers(config as LegacyConnectionConfig);
+  config.transport_layers.forEach((layer, index) => {
+    if (layer.type === "ssh") {
+      layer.password ||= getSecret(db, connectionId, transportLayerSshPasswordKey(index, layer)) || (layer.id === "legacy" ? getSecret(db, connectionId, "ssh_password") : getSecret(db, connectionId, `ssh_tunnels.${layer.id || index}.password`));
+      layer.key_passphrase ||= getSecret(db, connectionId, transportLayerSshKeyPassphraseKey(index, layer)) || (layer.id === "legacy" ? getSecret(db, connectionId, "ssh_key_passphrase") : getSecret(db, connectionId, `ssh_tunnels.${layer.id || index}.key_passphrase`));
+    } else {
+      layer.password ||= getSecret(db, connectionId, transportLayerProxyPasswordKey(index, layer)) || (layer.id === "legacy-proxy" ? getSecret(db, connectionId, "proxy_password") : "");
+    }
+  });
+}
+
+export async function loadConnections(options: ConnectionStoreOptions = {}): Promise<ConnectionConfig[]> {
+  const path = options.path ?? defaultDbPath();
+  if (!existsSync(path)) return [];
+
+  let db: Database.Database | undefined;
+  try {
+    db = openDb(true, path);
+    const rows = db.prepare("SELECT id, config_json FROM connections").all() as { id: string; config_json: string }[];
+    const configs: ConnectionConfig[] = [];
+
+    for (const row of rows) {
+      const config: ConnectionConfig = canonicalizeConnection(JSON.parse(row.config_json));
+      config.id = row.id;
+      if (!config.password) config.password = getSecret(db, row.id, "password");
+      hydrateTransportLayerSecrets(db, config, row.id);
+      if (!config.redis_sentinel_password) {
+        config.redis_sentinel_password = getSecret(db, row.id, "redis_sentinel_password");
+      }
+      configs.push(config);
+    }
+
+    return configs;
+  } catch (error) {
+    throw new ConnectionStoreError(path, error);
+  } finally {
+    db?.close();
+  }
+}
+
+export async function inspectConnectionStore(options: ConnectionStoreOptions = {}): Promise<ConnectionStoreDiagnostics> {
+  const path = options.path ?? defaultDbPath();
+  const diagnostics: ConnectionStoreDiagnostics = {
+    dbPath: path,
+    dbPathExists: existsSync(path),
+    connectionsTableExists: false,
+    connectionSecretsTableExists: false,
+    connectionRowCount: 0,
+    loadConnectionsOk: true,
+    loadedConnectionCount: 0,
+  };
+
+  if (!diagnostics.dbPathExists) return diagnostics;
+
+  let db: Database.Database | undefined;
+  try {
+    db = openDb(true, path);
+    diagnostics.connectionsTableExists = tableExists(db, "connections");
+    diagnostics.connectionSecretsTableExists = tableExists(db, "connection_secrets");
+    if (diagnostics.connectionsTableExists) {
+      const row = db.prepare("SELECT COUNT(*) AS count FROM connections").get() as { count: number };
+      diagnostics.connectionRowCount = row.count;
+    }
+  } catch (error) {
+    diagnostics.loadConnectionsOk = false;
+    diagnostics.loadConnectionsError = error instanceof Error ? error.message : String(error);
+    return diagnostics;
+  } finally {
+    db?.close();
+  }
+
+  try {
+    const connections = await loadConnections({ path });
+    diagnostics.loadedConnectionCount = connections.length;
+  } catch (error) {
+    diagnostics.loadConnectionsOk = false;
+    diagnostics.loadConnectionsError = error instanceof Error ? error.message : String(error);
+  }
+
+  return diagnostics;
+}
+
+function tableExists(db: Database.Database, name: string): boolean {
+  const row = db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(name) as { "1": number } | undefined;
+  return !!row;
+}
+
+export async function findConnection(name: string): Promise<ConnectionConfig | undefined> {
+  const connections = await loadConnections();
+  return connections.find((c) => c.name.toLowerCase() === name.toLowerCase());
+}
+
+export async function findConnectionById(id: string): Promise<ConnectionConfig | undefined> {
+  const connections = await loadConnections();
+  return connections.find((c) => c.id === id);
+}
+
+export async function addConnection(config: Omit<ConnectionConfig, "id">): Promise<ConnectionConfig> {
+  const id = randomUUID();
+  const db = openDb();
+  const normalized = canonicalizeConnection({ ...config, id } as ConnectionConfig);
+
+  const full = {
+    id,
+    name: normalized.name,
+    db_type: normalized.db_type,
+    driver_profile: normalized.driver_profile ?? normalized.db_type,
+    driver_label: null,
+    url_params: normalized.url_params ?? "",
+    host: normalized.host,
+    port: normalized.port,
+    username: normalized.username,
+    password: "",
+    database: normalized.database ?? null,
+    color: null,
+    transport_layers: normalizeTransportLayers(normalized as LegacyConnectionConfig).map((layer) => {
+      if (layer.type === "ssh") return { ...layer, password: "", key_passphrase: "" };
+      return { ...layer, password: "" };
+    }),
+    ssl: normalized.ssl ?? false,
+    sysdba: false,
+    oracle_connection_type: normalized.oracle_connection_type ?? null,
+    connection_string: null,
+    redis_connection_mode: normalized.redis_connection_mode ?? "standalone",
+    redis_sentinel_master: normalized.redis_sentinel_master ?? "",
+    redis_sentinel_nodes: normalized.redis_sentinel_nodes ?? "",
+    redis_sentinel_username: normalized.redis_sentinel_username ?? "",
+    redis_sentinel_password: "",
+    redis_sentinel_tls: normalized.redis_sentinel_tls ?? false,
+  };
+  const configJson = JSON.stringify(full);
+
+  const insert = db.transaction(() => {
+    db.prepare("INSERT INTO connections (id, config_json) VALUES (?, ?)").run(id, configJson);
+    if (normalized.password) {
+      db.prepare("INSERT INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)").run(id, "password", normalized.password);
+    }
+    normalizeTransportLayers(normalized as LegacyConnectionConfig).forEach((layer, index) => {
+      if (layer.type === "ssh") {
+        if (layer.password) {
+          db.prepare("INSERT INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)").run(id, transportLayerSshPasswordKey(index, layer), layer.password);
+        }
+        if (layer.key_passphrase) {
+          db.prepare("INSERT INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)").run(id, transportLayerSshKeyPassphraseKey(index, layer), layer.key_passphrase);
+        }
+      } else if (layer.password) {
+        db.prepare("INSERT INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)").run(id, transportLayerProxyPasswordKey(index, layer), layer.password);
+      }
+    });
+    if (normalized.redis_sentinel_password) {
+      db.prepare("INSERT INTO connection_secrets (connection_id, key, secret) VALUES (?, ?, ?)").run(id, "redis_sentinel_password", normalized.redis_sentinel_password);
+    }
+  });
+  insert();
+  db.close();
+
+  return normalized;
+}
+
+export async function removeConnection(name: string): Promise<boolean> {
+  const connection = await findConnection(name);
+  if (!connection) return false;
+
+  const db = openDb();
+  const remove = db.transaction(() => {
+    db.prepare("DELETE FROM connections WHERE id = ?").run(connection.id);
+    db.prepare("DELETE FROM connection_secrets WHERE connection_id = ?").run(connection.id);
+  });
+  remove();
+  db.close();
+
+  return true;
+}
+
+export async function removeConnectionById(id: string): Promise<boolean> {
+  const db = openDb();
+  const remove = db.transaction(() => {
+    const result = db.prepare("DELETE FROM connections WHERE id = ?").run(id);
+    db.prepare("DELETE FROM connection_secrets WHERE connection_id = ?").run(id);
+    return result.changes > 0;
+  });
+  const deleted = remove();
+  db.close();
+  return deleted;
+}
diff --git a/packages/node-core/src/database.ts b/packages/node-core/src/database.ts
new file mode 100644
index 0000000..55fac5f
--- /dev/null
+++ b/packages/node-core/src/database.ts
@@ -0,0 +1,1846 @@
+import type { ConnectionConfig, ProxyTunnelConfig } from "./connections.js";
+import type { SslOptions } from "mysql2";
+import { createServer, connect as netConnect, type Server, type Socket } from "node:net";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+import { sqlSafetyFromEnv } from "./sql-safety.js";
+import { isDirectQueryType } from "./diagnostics.js";
+import { bridgePortFilePath } from "./paths.js";
+import { parseRedisCommandArgv, classifyRedisCommand, type RedisCommandOptions, type RedisCommandResult, type RedisCommandSafety } from "./redis-command.js";
+
+export interface TableInfo {
+  name: string;
+  type: string;
+}
+
+export interface CollectionInfo {
+  name: string;
+  id?: string;
+  dimension?: number | null;
+}
+
+type CollectionListEntry = string | CollectionInfo;
+
+export interface ColumnInfo {
+  name: string;
+  data_type: string;
+  is_nullable: boolean;
+  column_default: string | null;
+  is_primary_key: boolean;
+  comment: string | null;
+  numeric_precision?: number | null;
+  numeric_scale?: number | null;
+  character_maximum_length?: number | null;
+  enum_values?: string[] | null;
+  character_set?: string | null;
+  collation?: string | null;
+}
+
+export interface QueryResult {
+  columns: string[];
+  rows: Record<string, unknown>[];
+  row_count: number;
+}
+
+export interface QueryOptions {
+  maxRows?: number;
+  timeoutMs?: number;
+}
+
+const MAX_ROWS = 100;
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+const QUERY_TIMEOUT_MS = 30_000;
+
+interface PoolEntry {
+  type: "pg" | "mysql";
+  pool: unknown;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+interface RqliteResult {
+  columns?: string[];
+  values?: unknown[][];
+  rows_affected?: number;
+  error?: string;
+}
+
+interface RqliteResponse {
+  results?: RqliteResult[];
+}
+
+const pools = new Map<string, PoolEntry>();
+const proxyTunnels = new Map<string, { server: Server; port: number; sockets: Set<Socket> }>();
+
+function poolKey(config: ConnectionConfig): string {
+  return `${config.id}:${config.database || ""}`;
+}
+
+function evictPool(key: string, entry: PoolEntry) {
+  pools.delete(key);
+  clearTimeout(entry.timer);
+  if (entry.type === "pg") {
+    (entry.pool as import("pg").Pool).end().catch(() => {});
+  } else {
+    (entry.pool as import("mysql2/promise").Pool).end().catch(() => {});
+  }
+}
+
+function resetIdleTimer(key: string, entry: PoolEntry) {
+  clearTimeout(entry.timer);
+  entry.timer = setTimeout(() => evictPool(key, entry), IDLE_TIMEOUT_MS);
+}
+
+export async function closeDatabaseResources(): Promise<void> {
+  const poolEntries = [...pools.entries()];
+  pools.clear();
+  await Promise.all(
+    poolEntries.map(async ([, entry]) => {
+      clearTimeout(entry.timer);
+      if (entry.type === "pg") {
+        await (entry.pool as import("pg").Pool).end().catch(() => {});
+      } else {
+        await (entry.pool as import("mysql2/promise").Pool).end().catch(() => {});
+      }
+    }),
+  );
+
+  const tunnels = [...proxyTunnels.values()];
+  proxyTunnels.clear();
+  await Promise.all(
+    tunnels.map(
+      ({ server, sockets }) =>
+        new Promise<void>((resolve) => {
+          for (const socket of sockets) socket.destroy();
+          server.close(() => resolve());
+        }),
+    ),
+  );
+}
+
+async function getPgPool(config: ConnectionConfig): Promise<import("pg").Pool> {
+  const key = poolKey(config);
+  const existing = pools.get(key);
+  if (existing?.type === "pg") {
+    resetIdleTimer(key, existing);
+    return existing.pool as import("pg").Pool;
+  }
+
+  const pg = await import("pg");
+  const endpoint = await connectionEndpoint(config);
+  const pool = new pg.default.Pool({
+    connectionString: buildConnectionUrl(config, endpoint),
+    max: 3,
+    idleTimeoutMillis: 30_000,
+    connectionTimeoutMillis: 10_000,
+  });
+  pool.on("error", () => {});
+  const entry: PoolEntry = { type: "pg", pool, timer: setTimeout(() => {}, 0) };
+  pools.set(key, entry);
+  resetIdleTimer(key, entry);
+  return pool;
+}
+
+async function getMysqlPool(config: ConnectionConfig): Promise<import("mysql2/promise").Pool> {
+  const key = poolKey(config);
+  const existing = pools.get(key);
+  if (existing?.type === "mysql") {
+    resetIdleTimer(key, existing);
+    return existing.pool as import("mysql2/promise").Pool;
+  }
+
+  const mysql = await import("mysql2/promise");
+  const endpoint = await connectionEndpoint(config);
+  const poolOptions: import("mysql2/promise").PoolOptions = {
+    uri: buildConnectionUrl(config, endpoint),
+    connectionLimit: 3,
+    idleTimeout: 30_000,
+    connectTimeout: 10_000,
+  };
+  const tls = await mysqlTlsOptions(config);
+  if (tls) poolOptions.ssl = tls;
+  const pool = mysql.default.createPool(poolOptions);
+  const entry: PoolEntry = { type: "mysql", pool, timer: setTimeout(() => {}, 0) };
+  pools.set(key, entry);
+  resetIdleTimer(key, entry);
+  return pool;
+}
+
+type ProxyLayer = { type: "proxy" } & ProxyTunnelConfig;
+
+function hasActiveSshLayer(config: ConnectionConfig): boolean {
+  return config.transport_layers?.some((layer) => layer.type === "ssh" && layer.enabled !== false && !!layer.host) ?? false;
+}
+
+function firstProxyLayer(config: ConnectionConfig): ProxyLayer | undefined {
+  return config.transport_layers?.find((layer): layer is ProxyLayer => layer.type === "proxy" && layer.enabled !== false && !!layer.host);
+}
+
+function hasDirectRedisSupport(config: ConnectionConfig): boolean {
+  const mode = config.redis_connection_mode || "standalone";
+  return config.db_type === "redis" && mode === "standalone" && !hasActiveSshLayer(config);
+}
+
+async function connectionEndpoint(config: ConnectionConfig): Promise<{ host: string; port: number }> {
+  const proxy = firstProxyLayer(config);
+  if (!proxy) return { host: config.host, port: config.port };
+  const existing = proxyTunnels.get(config.id);
+  if (existing) return { host: "127.0.0.1", port: existing.port };
+
+  const sockets = new Set<Socket>();
+  const server = createServer((inbound) => {
+    sockets.add(inbound);
+    inbound.once("close", () => sockets.delete(inbound));
+    connectViaProxy(config, proxy)
+      .then((outbound) => {
+        sockets.add(outbound);
+        outbound.once("close", () => sockets.delete(outbound));
+        inbound.pipe(outbound);
+        outbound.pipe(inbound);
+      })
+      .catch(() => inbound.destroy());
+  });
+  const port = await new Promise<number>((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address && typeof address === "object") resolve(address.port);
+      else reject(new Error("Failed to bind proxy tunnel"));
+    });
+  });
+  proxyTunnels.set(config.id, { server, port, sockets });
+  return { host: "127.0.0.1", port };
+}
+
+export function buildConnectionUrl(config: ConnectionConfig, endpoint: { host: string; port: number }): string {
+  const db = config.database || "";
+  if (isMysqlType(config.db_type)) {
+    const params = buildMysqlUrlParams(config);
+    const suffix = params ? `?${params}` : "";
+    return `mysql://${encodeURIComponent(config.username)}:${encodeURIComponent(config.password)}@${endpoint.host}:${endpoint.port}/${db}${suffix}`;
+  }
+  if (!isPostgresType(config.db_type)) {
+    throw new Error(`Unsupported pooled connection type: ${config.db_type}`);
+  }
+  const params = normalizePostgresUrlParams(config.url_params || "", config.ssl);
+  const suffix = params ? `?${params}` : "";
+  return `postgres://${encodeURIComponent(config.username)}:${encodeURIComponent(config.password)}@${endpoint.host}:${endpoint.port}/${db}${suffix}`;
+}
+
+function normalizePostgresUrlParams(value: string, forceTls: boolean): string {
+  const parts: string[] = [];
+  let timezone: string | undefined;
+  let searchPath: string | undefined;
+  for (const part of value.trim().replace(/^\?/, "").split("&")) {
+    if (!part) continue;
+    const [rawKey, rawValue] = splitUrlParam(part);
+    const key = decodeUrlParamPart(rawKey);
+    const lowerKey = key.toLowerCase();
+    if (lowerKey === "timezone" || lowerKey === "time_zone") {
+      const decoded = decodeUrlParamPart(rawValue).trim();
+      if (decoded) timezone = decoded;
+      continue;
+    }
+    if (lowerKey === "schema" || lowerKey === "currentschema") {
+      const decoded = decodeUrlParamPart(rawValue).trim();
+      if (decoded) searchPath = decoded;
+      continue;
+    }
+    if (lowerKey === "ssl-mode") {
+      const value = decodeUrlParamPart(rawValue).toLowerCase().replaceAll("_", "-");
+      if (value === "require" || value === "required") parts.push("sslmode=require");
+      else if (value === "prefer" || value === "preferred") parts.push("sslmode=prefer");
+      else if (value === "disable" || value === "disabled") parts.push("sslmode=disable");
+      else if (value === "verify-ca") parts.push("sslmode=verify-ca");
+      else if (value === "verify-full" || value === "verify-identity") parts.push("sslmode=verify-full");
+      continue;
+    }
+    if (lowerKey === "charset" || lowerKey === "require_ssl" || lowerKey === "verify_ca" || lowerKey === "verify_identity") {
+      continue;
+    }
+    parts.push(part);
+  }
+
+  const connectionOptions: Array<{ needle: string; value: string }> = [];
+  if (searchPath) connectionOptions.push({ needle: "search_path=", value: `-c search_path=${searchPath}` });
+  if (timezone) connectionOptions.push({ needle: "timezone=", value: `-c TimeZone=${timezone}` });
+  if (connectionOptions.length > 0) {
+    const optionsIndex = parts.findIndex((part) => urlParamKeyIs(part, "options"));
+    if (optionsIndex >= 0) {
+      const [rawKey, rawValue] = splitUrlParam(parts[optionsIndex]);
+      const optionsValue = decodeUrlParamPart(rawValue);
+      const lowerOptions = optionsValue.toLowerCase();
+      const appended = connectionOptions
+        .filter((option) => !lowerOptions.includes(option.needle))
+        .map((option) => option.value)
+        .join(" ");
+      if (appended) {
+        const combined = `${optionsValue.trim()} ${appended}`.trim();
+        parts[optionsIndex] = `${rawKey}=${encodeURIComponent(combined)}`;
+      }
+    } else {
+      parts.push(`options=${encodeURIComponent(connectionOptions.map((option) => option.value).join(" "))}`);
+    }
+  }
+
+  if (forceTls && !parts.some((part) => urlParamKeyIs(part, "sslmode"))) {
+    parts.unshift("sslmode=require");
+  }
+  return parts.join("&");
+}
+
+function urlParamKeyIs(part: string, expected: string): boolean {
+  const [rawKey] = splitUrlParam(part);
+  return decodeUrlParamPart(rawKey).toLowerCase() === expected.toLowerCase();
+}
+
+function splitUrlParam(part: string): [string, string] {
+  const index = part.indexOf("=");
+  if (index < 0) return [part, ""];
+  return [part.slice(0, index), part.slice(index + 1)];
+}
+
+function decodeUrlParamPart(value: string): string {
+  try {
+    return decodeURIComponent(value.replace(/\+/g, " "));
+  } catch {
+    return value;
+  }
+}
+
+function urlParams(config: ConnectionConfig): URLSearchParams {
+  return new URLSearchParams((config.url_params || "").trim().replace(/^\?/, ""));
+}
+
+function connectViaProxy(config: ConnectionConfig, proxy: ProxyLayer): Promise<Socket> {
+  return new Promise((resolve, reject) => {
+    const socket = netConnect(proxy.port || 1080, proxy.host || "127.0.0.1");
+    socket.once("error", reject);
+    socket.once("connect", () => {
+      if ((proxy.proxy_type || "socks5") === "http") {
+        httpConnect(socket, config, proxy, resolve, reject);
+      } else {
+        socks5Connect(socket, config, proxy, resolve, reject);
+      }
+    });
+  });
+}
+
+function httpConnect(socket: Socket, config: ConnectionConfig, proxy: ProxyLayer, resolve: (socket: Socket) => void, reject: (err: Error) => void) {
+  const target = `${config.host}:${config.port}`;
+  const lines = [`CONNECT ${target} HTTP/1.1`, `Host: ${target}`];
+  if (proxy.username || proxy.password) {
+    const token = Buffer.from(`${proxy.username || ""}:${proxy.password || ""}`).toString("base64");
+    lines.push(`Proxy-Authorization: Basic ${token}`);
+  }
+  socket.write(`${lines.join("\r\n")}\r\n\r\n`);
+  let buffer = Buffer.alloc(0);
+  socket.on("data", function onData(chunk: Buffer) {
+    buffer = Buffer.concat([buffer, chunk]);
+    const end = buffer.indexOf("\r\n\r\n");
+    if (end < 0) return;
+    socket.off("data", onData);
+    const head = buffer.subarray(0, end).toString("utf8");
+    if (!/^HTTP\/1\.[01] 200\b/.test(head)) {
+      reject(new Error(`HTTP proxy CONNECT failed: ${head.split("\r\n")[0] || "invalid response"}`));
+      socket.destroy();
+      return;
+    }
+    const rest = buffer.subarray(end + 4);
+    if (rest.length) socket.unshift(rest);
+    resolve(socket);
+  });
+}
+
+function socks5Connect(socket: Socket, config: ConnectionConfig, proxy: ProxyLayer, resolve: (socket: Socket) => void, reject: (err: Error) => void) {
+  const wantsAuth = !!(proxy.username || proxy.password);
+  socket.write(Buffer.from(wantsAuth ? [0x05, 0x02, 0x00, 0x02] : [0x05, 0x01, 0x00]));
+  socket.once("data", (method) => {
+    if (method.length < 2 || method[0] !== 0x05) {
+      reject(new Error("Invalid SOCKS greeting"));
+      socket.destroy();
+      return;
+    }
+    if (method[1] === 0x02) {
+      const user = Buffer.from(proxy.username || "");
+      const pass = Buffer.from(proxy.password || "");
+      socket.write(Buffer.concat([Buffer.from([0x01, user.length]), user, Buffer.from([pass.length]), pass]));
+      socket.once("data", (auth) => {
+        if (auth.length < 2 || auth[1] !== 0x00) {
+          reject(new Error("SOCKS proxy authentication failed"));
+          socket.destroy();
+          return;
+        }
+        sendSocksConnect(socket, config, resolve, reject);
+      });
+    } else if (method[1] === 0x00) {
+      sendSocksConnect(socket, config, resolve, reject);
+    } else {
+      reject(new Error("SOCKS proxy rejected authentication methods"));
+      socket.destroy();
+    }
+  });
+}
+
+function sendSocksConnect(socket: Socket, config: ConnectionConfig, resolve: (socket: Socket) => void, reject: (err: Error) => void) {
+  const host = Buffer.from(config.host);
+  socket.write(Buffer.concat([Buffer.from([0x05, 0x01, 0x00, 0x03, host.length]), host, portBytes(config.port)]));
+  socket.once("data", (res) => {
+    if (res.length < 4 || res[0] !== 0x05 || res[1] !== 0x00) {
+      reject(new Error(`SOCKS proxy connect failed with code ${res[1] ?? "unknown"}`));
+      socket.destroy();
+      return;
+    }
+    resolve(socket);
+  });
+}
+
+function portBytes(port: number): Buffer {
+  const buf = Buffer.alloc(2);
+  buf.writeUInt16BE(port);
+  return buf;
+}
+
+function isMysqlType(dbType: string): boolean {
+  return dbType === "mysql" || dbType === "doris" || dbType === "starrocks" || dbType === "manticoresearch";
+}
+
+function isStarrocksConnection(config: ConnectionConfig): boolean {
+  return config.db_type === "starrocks" || config.driver_profile?.toLowerCase() === "starrocks";
+}
+
+function needsBareMysql(config: ConnectionConfig): boolean {
+  const profile = config.driver_profile?.toLowerCase();
+  return config.db_type === "doris" || config.db_type === "starrocks" || config.db_type === "manticoresearch" || profile === "doris" || profile === "starrocks" || profile === "manticoresearch" || profile === "selectdb" || profile === "oceanbase";
+}
+
+function mysqlTlsFileParamIs(key: string, target: "cert" | "key"): boolean {
+  return key.toLowerCase().replace(/[-_]/g, "") === `ssl${target}`;
+}
+
+function mysqlUrlParamsRequireTls(params: string): boolean {
+  for (const part of params.trim().replace(/^\?/, "").split("&")) {
+    if (!part) continue;
+    const [rawKey, rawValue = ""] = splitUrlParam(part);
+    const key = decodeUrlParamPart(rawKey);
+    const value = decodeUrlParamPart(rawValue);
+    if (key.toLowerCase() === "require_ssl" && value.toLowerCase() === "true") return true;
+    if (mysqlTlsFileParamIs(key, "cert") || mysqlTlsFileParamIs(key, "key")) return true;
+    if (key.toLowerCase() === "ssl-mode" || key.toLowerCase() === "sslmode") {
+      const mode = value.toLowerCase().replace(/-/g, "_");
+      if (mode === "required" || mode === "require" || mode === "verify_ca" || mode === "verify_identity") return true;
+    }
+  }
+  return false;
+}
+
+function mysqlUrlParamsTlsDisabled(params: string): boolean {
+  for (const part of params.trim().replace(/^\?/, "").split("&")) {
+    if (!part) continue;
+    const [rawKey, rawValue = ""] = splitUrlParam(part);
+    const key = decodeUrlParamPart(rawKey).toLowerCase();
+    const value = decodeUrlParamPart(rawValue).toLowerCase();
+    if (key === "require_ssl" && value === "false") return true;
+    if ((key === "ssl-mode" || key === "sslmode") && (value === "disabled" || value === "disable")) return true;
+  }
+  return false;
+}
+
+function mysqlUsesTls(config: ConnectionConfig): boolean {
+  return !!config.ssl || mysqlUrlParamsRequireTls(config.url_params || "");
+}
+
+function bareMysqlUsesTls(config: ConnectionConfig): boolean {
+  if (!isStarrocksConnection(config)) {
+    return false;
+  }
+  if (mysqlUrlParamsTlsDisabled(config.url_params || "")) {
+    return false;
+  }
+  return mysqlUsesTls(config);
+}
+
+function normalizeBareMysqlUrlParams(value: string): string {
+  return value
+    .trim()
+    .replace(/^\?/, "")
+    .split("&")
+    .filter((part) => {
+      if (!part) return false;
+      const key = decodeUrlParamPart(splitUrlParam(part)[0]).toLowerCase();
+      return key !== "charset" && key !== "ssl-mode" && key !== "sslmode" && key !== "require_ssl" && key !== "verify_ca" && key !== "verify_identity";
+    })
+    .join("&");
+}
+
+function normalizeMysqlUrlParams(value: string, forceTls: boolean, acceptInvalidCerts: boolean): string {
+  const parts = value
+    .trim()
+    .replace(/^\?/, "")
+    .split("&")
+    .filter((part) => part.length > 0);
+
+  if (forceTls) {
+    const filtered = parts.filter((part) => {
+      const key = decodeUrlParamPart(splitUrlParam(part)[0]).toLowerCase();
+      return key !== "ssl-mode" && key !== "sslmode" && key !== "require_ssl";
+    });
+    filtered.unshift("require_ssl=true");
+    if (acceptInvalidCerts && !filtered.some((part) => urlParamKeyIs(part, "verify_ca"))) {
+      filtered.push("verify_ca=false");
+    }
+    if (!filtered.some((part) => urlParamKeyIs(part, "verify_identity"))) {
+      filtered.push("verify_identity=false");
+    }
+    if (!filtered.some((part) => urlParamKeyIs(part, "charset"))) {
+      filtered.push("charset=utf8mb4");
+    }
+    return filtered.join("&");
+  }
+
+  if (!parts.some((part) => urlParamKeyIs(part, "ssl-mode") || urlParamKeyIs(part, "sslmode") || urlParamKeyIs(part, "require_ssl"))) {
+    parts.unshift("ssl-mode=disabled");
+  }
+  if (!parts.some((part) => urlParamKeyIs(part, "charset"))) {
+    parts.push("charset=utf8mb4");
+  }
+  return parts.join("&");
+}
+
+function buildMysqlUrlParams(config: ConnectionConfig): string {
+  const raw = config.url_params || "";
+  if (needsBareMysql(config)) {
+    if (bareMysqlUsesTls(config)) {
+      return normalizeMysqlUrlParams(raw, true, !config.ca_cert_path?.trim());
+    }
+    return normalizeBareMysqlUrlParams(raw);
+  }
+  return raw;
+}
+
+async function mysqlTlsOptions(config: ConnectionConfig): Promise<SslOptions | undefined> {
+  if (!bareMysqlUsesTls(config)) return undefined;
+
+  const params = urlParams(config);
+  const tls: SslOptions = {};
+  const verifyCa = (params.get("verify_ca") || "").toLowerCase() === "true";
+  const verifyIdentity = (params.get("verify_identity") || "").toLowerCase() === "true";
+  if (!verifyCa && !verifyIdentity) {
+    tls.rejectUnauthorized = false;
+  }
+  if (config.ca_cert_path) tls.ca = await readFile(config.ca_cert_path);
+  const certPath = params.get("ssl-cert") || params.get("sslcert");
+  const keyPath = params.get("ssl-key") || params.get("sslkey");
+  if (certPath) tls.cert = await readFile(certPath);
+  if (keyPath) tls.key = await readFile(keyPath);
+  return tls;
+}
+
+function isPostgresType(dbType: string): boolean {
+  return dbType === "postgres" || dbType === "redshift" || dbType === "gaussdb" || dbType === "kwdb" || dbType === "opengauss" || dbType === "questdb";
+}
+
+interface BridgeQueryResult {
+  columns: string[];
+  rows: unknown[][];
+  affected_rows: number;
+  execution_time_ms: number;
+  truncated: boolean;
+}
+
+interface BridgeTableInfo {
+  name: string;
+  table_type: string;
+  comment: string | null;
+}
+
+interface BridgeColumnInfo {
+  name: string;
+  data_type: string;
+  is_nullable: boolean;
+  column_default: string | null;
+  is_primary_key: boolean;
+  comment: string | null;
+  numeric_precision?: number | null;
+  numeric_scale?: number | null;
+  character_maximum_length?: number | null;
+  enum_values?: string[] | null;
+  character_set?: string | null;
+  collation?: string | null;
+}
+
+const POSTGRES_DESCRIBE_TABLE_SQL = `SELECT c.column_name AS name, CASE WHEN c.data_type = 'USER-DEFINED' THEN c.udt_name ELSE c.data_type END AS data_type, c.is_nullable = 'YES' AS is_nullable, c.column_default, CASE WHEN tc.constraint_type = 'PRIMARY KEY' THEN true ELSE false END AS is_primary_key, col_description(cls.oid, c.ordinal_position) AS comment, CASE WHEN enum_t.oid IS NULL THEN NULL ELSE COALESCE((SELECT array_to_json(array_agg(e.enumlabel ORDER BY e.enumsortorder)) FROM pg_enum e WHERE e.enumtypid = enum_t.oid), '[]'::json) END AS enum_values FROM information_schema.columns c LEFT JOIN information_schema.key_column_usage kcu ON kcu.table_schema = c.table_schema AND kcu.table_name = c.table_name AND kcu.column_name = c.column_name LEFT JOIN information_schema.table_constraints tc ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema AND tc.constraint_type = 'PRIMARY KEY' LEFT JOIN pg_class cls ON cls.relname = c.table_name AND cls.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema) LEFT JOIN pg_namespace type_ns ON type_ns.nspname = c.udt_schema LEFT JOIN pg_type t ON t.typnamespace = type_ns.oid AND t.typname = c.udt_name LEFT JOIN pg_type enum_t ON enum_t.oid = CASE WHEN t.typtype = 'd' THEN t.typbasetype WHEN t.typtype = 'e' THEN t.oid ELSE NULL END AND enum_t.typtype = 'e' WHERE c.table_schema = $1 AND c.table_name = $2 ORDER BY c.ordinal_position`;
+const POSTGRES_DESCRIBE_TABLE_COMPAT_SQL = `SELECT c.column_name AS name, CASE WHEN c.data_type = 'USER-DEFINED' THEN c.udt_name ELSE c.data_type END AS data_type, c.is_nullable = 'YES' AS is_nullable, c.column_default, CASE WHEN tc.constraint_type = 'PRIMARY KEY' THEN true ELSE false END AS is_primary_key, col_description(cls.oid, c.ordinal_position) AS comment, NULL AS enum_values FROM information_schema.columns c LEFT JOIN information_schema.key_column_usage kcu ON kcu.table_schema = c.table_schema AND kcu.table_name = c.table_name AND kcu.column_name = c.column_name LEFT JOIN information_schema.table_constraints tc ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema AND tc.constraint_type = 'PRIMARY KEY' LEFT JOIN pg_class cls ON cls.relname = c.table_name AND cls.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema) WHERE c.table_schema = $1 AND c.table_name = $2 ORDER BY c.ordinal_position`;
+const MYSQL_DESCRIBE_TABLE_SQL = `SELECT c.COLUMN_NAME AS name, c.DATA_TYPE AS data_type, c.COLUMN_TYPE AS column_type, c.IS_NULLABLE = 'YES' AS is_nullable, c.COLUMN_DEFAULT AS column_default, c.COLUMN_KEY = 'PRI' AS is_primary_key, c.COLUMN_COMMENT AS comment, c.CHARACTER_SET_NAME AS character_set, c.COLLATION_NAME AS collation FROM information_schema.COLUMNS c WHERE c.TABLE_SCHEMA = DATABASE() AND c.TABLE_NAME = ? ORDER BY c.ORDINAL_POSITION`;
+
+function normalizeEnumValues(value: unknown): string[] | null {
+  if (value == null) return null;
+  if (Array.isArray(value)) return value.map((item) => String(item));
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value) as unknown;
+      return Array.isArray(parsed) ? parsed.map((item) => String(item)) : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+function parseMysqlEnumValues(columnType: unknown): string[] | null {
+  if (typeof columnType !== "string") return null;
+  const trimmed = columnType.trim();
+  if (!trimmed.toLowerCase().startsWith("enum(") || !trimmed.endsWith(")")) return null;
+
+  const inner = trimmed.slice(5, -1);
+  const values: string[] = [];
+  let index = 0;
+
+  const skipWhitespace = () => {
+    while (index < inner.length && /\s/.test(inner[index] ?? "")) index += 1;
+  };
+
+  while (index < inner.length) {
+    skipWhitespace();
+    if (inner[index] !== "'") return null;
+    index += 1;
+
+    let value = "";
+    while (index < inner.length) {
+      const char = inner[index++];
+      if (char === "'") {
+        if (inner[index] === "'") {
+          value += "'";
+          index += 1;
+          continue;
+        }
+        break;
+      }
+      if (char === "\\") {
+        if (index >= inner.length) return null;
+        const escaped = inner[index++];
+        if (escaped === "0") value += "\0";
+        else if (escaped === "b") value += "\b";
+        else if (escaped === "n") value += "\n";
+        else if (escaped === "r") value += "\r";
+        else if (escaped === "t") value += "\t";
+        else if (escaped === "Z") value += "\x1a";
+        else value += escaped;
+        continue;
+      }
+      value += char;
+    }
+    values.push(value);
+
+    skipWhitespace();
+    if (index >= inner.length) return values;
+    if (inner[index] !== ",") return null;
+    index += 1;
+  }
+
+  return values;
+}
+
+function mapDescribeTableColumn(
+  row: {
+    name?: unknown;
+    data_type?: unknown;
+    is_nullable?: unknown;
+    column_default?: unknown;
+    is_primary_key?: unknown;
+    comment?: unknown;
+    numeric_precision?: number | null;
+    numeric_scale?: number | null;
+    character_maximum_length?: number | null;
+    character_set?: string | null;
+    collation?: string | null;
+  },
+  enumValues: string[] | null,
+): ColumnInfo {
+  const column: ColumnInfo = {
+    name: String(row.name || ""),
+    data_type: String(row.data_type || ""),
+    is_nullable: Boolean(row.is_nullable),
+    column_default: row.column_default != null ? String(row.column_default) : null,
+    is_primary_key: Boolean(row.is_primary_key),
+    comment: row.comment != null ? String(row.comment) : null,
+    enum_values: enumValues,
+  };
+  if ("numeric_precision" in row) column.numeric_precision = row.numeric_precision;
+  if ("numeric_scale" in row) column.numeric_scale = row.numeric_scale;
+  if ("character_maximum_length" in row) column.character_maximum_length = row.character_maximum_length;
+  if ("character_set" in row) column.character_set = row.character_set ?? null;
+  if ("collation" in row) column.collation = row.collation ?? null;
+  return column;
+}
+
+export function collectionListToTableInfos(collections: CollectionListEntry[]): TableInfo[] {
+  return collections.map((collection) => ({
+    name: typeof collection === "string" ? collection : collection.name,
+    type: "COLLECTION",
+  }));
+}
+
+interface MongoDocumentResult {
+  documents: unknown[];
+  total: number;
+}
+
+async function bridgeDataRequest<T>(path: string, body: Record<string, unknown>): Promise<T> {
+  let bridgeUrl: string;
+  try {
+    const port = (await readFile(bridgePortFilePath(), "utf-8")).trim();
+    bridgeUrl = `http://127.0.0.1:${port}`;
+  } catch {
+    throw new Error("DBX desktop app is not running. This database type requires DBX to be running for query execution.");
+  }
+  const res = await fetch(`${bridgeUrl}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const errBody = await res.text().catch(() => "");
+    let errorMsg: string;
+    try {
+      const parsed = JSON.parse(errBody);
+      errorMsg = parsed.error || errBody;
+    } catch {
+      errorMsg = errBody;
+    }
+    throw new Error(errorMsg || `Bridge request failed: ${res.status}`);
+  }
+  return res.json() as Promise<T>;
+}
+
+function resolveMaxRows(options?: QueryOptions): number {
+  return options?.maxRows ?? MAX_ROWS;
+}
+
+function resolveTimeoutMs(options?: QueryOptions): number {
+  return options?.timeoutMs ?? QUERY_TIMEOUT_MS;
+}
+
+function convertBridgeQueryResult(result: BridgeQueryResult, options?: QueryOptions): QueryResult {
+  const rows = result.rows.slice(0, resolveMaxRows(options)).map((row) => {
+    const obj: Record<string, unknown> = {};
+    result.columns.forEach((col, i) => {
+      obj[col] = row[i];
+    });
+    return obj;
+  });
+  return { columns: result.columns, rows, row_count: rows.length };
+}
+
+function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`Query timed out after ${ms}ms`)), ms);
+    promise.then(resolve, reject).finally(() => clearTimeout(timer));
+  });
+}
+
+async function queryWithRetry(config: ConnectionConfig, fn: () => Promise<QueryResult>, options?: QueryOptions): Promise<QueryResult> {
+  const timeoutMs = resolveTimeoutMs(options);
+  try {
+    return await withTimeout(fn(), timeoutMs);
+  } catch (e: unknown) {
+    const msg = e instanceof Error ? e.message : String(e);
+    const retriable = /terminating connection|Connection lost|ECONNRESET|EPIPE|connection refused/i.test(msg);
+    if (retriable) {
+      const key = poolKey(config);
+      const entry = pools.get(key);
+      if (entry) evictPool(key, entry);
+      return withTimeout(fn(), timeoutMs);
+    }
+    throw e;
+  }
+}
+
+async function pgQuery(config: ConnectionConfig, sql: string, params?: unknown[], options?: QueryOptions): Promise<QueryResult> {
+  return queryWithRetry(
+    config,
+    async () => {
+      const pool = await getPgPool(config);
+      const result = await pool.query(sql, params);
+      const rows = (result.rows || []).slice(0, resolveMaxRows(options));
+      return { columns: result.fields?.map((f) => f.name) ?? [], rows, row_count: rows.length };
+    },
+    options,
+  );
+}
+
+async function mysqlQuery(config: ConnectionConfig, sql: string, params?: unknown[], options?: QueryOptions): Promise<QueryResult> {
+  return queryWithRetry(
+    config,
+    async () => {
+      const pool = await getMysqlPool(config);
+      const [results, fields] = await pool.query(sql, params);
+      const rows = (Array.isArray(results) ? results : []).slice(0, resolveMaxRows(options)) as Record<string, unknown>[];
+      return { columns: (fields as Array<{ name: string }>)?.map((f) => f.name) ?? [], rows, row_count: rows.length };
+    },
+    options,
+  );
+}
+
+async function query(config: ConnectionConfig, sql: string, params?: unknown[], options?: QueryOptions): Promise<QueryResult> {
+  if (config.db_type === "sqlite") return sqliteQuery(config, sql, options);
+  if (config.db_type === "rqlite") return rqliteQuery(config, sql, options);
+  if (isMysqlType(config.db_type)) return mysqlQuery(config, sql, params, options);
+  return pgQuery(config, sql, params, options);
+}
+
+function sqlitePath(config: ConnectionConfig): string {
+  return expandTilde(config.host || config.database || "");
+}
+
+function expandTilde(path: string): string {
+  if (path === "~") return homedir();
+  if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+  return path;
+}
+
+function quoteSqliteIdentifier(identifier: string): string {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+
+function sqliteQuery(config: ConnectionConfig, sql: string, options?: QueryOptions): QueryResult {
+  const db = new Database(sqlitePath(config), { readonly: !sqlSafetyFromEnv().allowWrites });
+  try {
+    const stmt = db.prepare(sql);
+    if (stmt.reader) {
+      const rows = stmt.all().slice(0, resolveMaxRows(options)) as Record<string, unknown>[];
+      return { columns: stmt.columns().map((column) => column.name), rows, row_count: rows.length };
+    }
+    const result = stmt.run();
+    return { columns: [], rows: [], row_count: result.changes };
+  } finally {
+    db.close();
+  }
+}
+
+async function rqliteQuery(config: ConnectionConfig, sql: string, options?: QueryOptions): Promise<QueryResult> {
+  const isReader = /^\s*(?:--[^\n]*\n|\s|\/\*[\s\S]*?\*\/)*(select|pragma|explain|with)\b/i.test(sql);
+  const endpoint = isReader ? "/db/query" : "/db/execute";
+  const result = await rqliteRequest(config, endpoint, sql);
+  if (isReader) {
+    const columns = result.columns ?? [];
+    const rows = (result.values ?? []).slice(0, resolveMaxRows(options)).map((row) => {
+      const record: Record<string, unknown> = {};
+      columns.forEach((column, index) => {
+        record[column] = row[index];
+      });
+      return record;
+    });
+    return { columns, rows, row_count: rows.length };
+  }
+  return { columns: [], rows: [], row_count: result.rows_affected ?? 0 };
+}
+
+async function rqliteRequest(config: ConnectionConfig, endpoint: "/db/query" | "/db/execute", sql: string): Promise<RqliteResult> {
+  const { host, port } = await connectionEndpoint(config);
+  const scheme = config.ssl ? "https" : "http";
+  const params = (config.url_params || "").trim().replace(/^\?/, "");
+  const url = `${scheme}://${host}:${port}${endpoint}${params ? `?${params}` : ""}`;
+  const headers: Record<string, string> = { "content-type": "application/json" };
+  if (config.username) {
+    headers.authorization = `Basic ${Buffer.from(`${config.username}:${config.password || ""}`).toString("base64")}`;
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify([sql]),
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`rqlite error (${response.status}): ${text}`);
+  const payload = JSON.parse(text) as RqliteResponse;
+  const result = payload.results?.[0];
+  if (!result) throw new Error("rqlite returned no result");
+  if (result.error) throw new Error(`rqlite error: ${result.error}`);
+  return result;
+}
+
+export async function executeQuery(config: ConnectionConfig, sql: string, options?: QueryOptions): Promise<QueryResult> {
+  if (hasActiveSshLayer(config)) {
+    const result = await withTimeout(
+      bridgeDataRequest<BridgeQueryResult>("/data/execute-query", {
+        connection_id: config.id,
+        connection_name: config.name,
+        database: config.database || "",
+        sql,
+      }),
+      resolveTimeoutMs(options),
+    );
+    return convertBridgeQueryResult(result, options);
+  }
+  if (config.db_type === "mongodb") {
+    const version = parseMongoVersionCommand(sql);
+    if (version) {
+      const result = await withTimeout(mongoServerVersion(config), resolveTimeoutMs(options));
+      return { columns: ["version"], rows: [{ version: result }], row_count: 1 };
+    }
+    const count = parseMongoCountDocumentsCommand(sql);
+    if (count) {
+      const result = await withTimeout(mongoFindDocuments(config, count.collection, 0, 1, count.filter), resolveTimeoutMs(options));
+      return { columns: ["count"], rows: [{ count: result.total }], row_count: 1 };
+    }
+    const find = parseMongoFindCommand(sql);
+    if (find) {
+      const result = await withTimeout(mongoFindDocuments(config, find.collection, find.skip, find.limit, find.filter, find.projection, find.sort), resolveTimeoutMs(options));
+      return mongoDocumentsToQueryResult(result.documents.slice(0, resolveMaxRows(options)), result.total);
+    }
+    const aggregate = parseMongoAggregateCommand(sql);
+    if (aggregate) {
+      const safety = evaluateMongoAggregateSafety(aggregate, sqlSafetyFromEnv());
+      if (!safety.allowed) throw new Error(safety.reason);
+      const result = await withTimeout(mongoAggregateDocuments(config, aggregate.collection, aggregate.pipeline, resolveMaxRows(options)), resolveTimeoutMs(options));
+      return mongoDocumentsToQueryResult(result.documents.slice(0, resolveMaxRows(options)), result.total);
+    }
+    const getIndexes = parseMongoGetIndexesCommand(sql);
+    if (getIndexes) {
+      const result = await withTimeout(mongoAggregateDocuments(config, getIndexes.collection, '[{"$indexStats":{}}]', resolveMaxRows(options)), resolveTimeoutMs(options));
+      return mongoDocumentsToQueryResult(result.documents.slice(0, resolveMaxRows(options)), result.total);
+    }
+    const collectionStats = parseMongoCollectionStatsCommand(sql);
+    if (collectionStats) {
+      const result = await withTimeout(mongoCollectionStats(config, collectionStats.collection, collectionStats.scale), resolveTimeoutMs(options));
+      return mongoCollectionStatsToQueryResult(collectionStats.metric, result);
+    }
+    const write = parseMongoWriteCommand(sql);
+    if (write) {
+      const safety = evaluateMongoWriteSafety(write, sqlSafetyFromEnv());
+      if (!safety.allowed) throw new Error(safety.reason);
+      const result = await withTimeout(executeMongoWrite(config, write), resolveTimeoutMs(options));
+      if (write.kind === "createIndex") {
+        return {
+          columns: ["name"],
+          rows: [{ name: result.indexName ?? "" }],
+          row_count: 1,
+        };
+      }
+      if (write.kind === "dropIndex" || write.kind === "dropIndexes") {
+        return {
+          columns: ["name"],
+          rows: (result.droppedNames ?? []).map((name) => ({ name })),
+          row_count: result.affectedRows,
+        };
+      }
+      return { columns: [], rows: [], row_count: result.affectedRows };
+    }
+    throw new Error(
+      'Use MongoDB shell-style commands, for example: db.projects.find({}).limit(100), db.version(), db.projects.countDocuments({}), db.projects.count({}), db.projects.getIndexes(), db.projects.dataSize(), db.projects.storageSize(1024), db.projects.totalIndexSize(), db.projects.stats(), db.projects.createIndex({...}), db.projects.dropIndex("name"), db.projects.dropIndexes(), db.projects.drop(), db.projects.insertOne({...}), db.projects.updateOne({...}, {$set: {...}}), or db.projects.deleteOne({...})',
+    );
+  }
+  if (isDirectQueryType(config.db_type)) {
+    return query(config, sql, undefined, options);
+  }
+  const result = await withTimeout(
+    bridgeDataRequest<BridgeQueryResult>("/data/execute-query", {
+      connection_id: config.id,
+      connection_name: config.name,
+      database: config.database || "",
+      sql,
+    }),
+    resolveTimeoutMs(options),
+  );
+  return convertBridgeQueryResult(result, options);
+}
+
+export async function executeRedisCommand(config: ConnectionConfig, db: number, command: string, options?: RedisCommandOptions): Promise<RedisCommandResult> {
+  if (config.db_type !== "redis") {
+    throw new Error("Connection is not Redis.");
+  }
+  if (hasDirectRedisSupport(config)) {
+    return executeRedisCommandDirect(config, db, command, options);
+  }
+  return withTimeout(
+    bridgeDataRequest<RedisCommandResult>("/data/redis/execute-command", {
+      connection_id: config.id,
+      connection_name: config.name,
+      db,
+      command,
+      skip_safety_check: options?.skipSafetyCheck ?? false,
+    }),
+    resolveTimeoutMs(options),
+  );
+}
+
+async function executeRedisCommandDirect(config: ConnectionConfig, db: number, commandText: string, options?: RedisCommandOptions): Promise<RedisCommandResult> {
+  const argv = parseRedisCommandArgv(commandText);
+  const command = argv[0].toUpperCase();
+  const safety = classifyRedisCommand(command) as RedisCommandSafety;
+  if (!options?.skipSafetyCheck && safety === "blocked") {
+    throw new Error(`Redis command is blocked for safety: ${command}`);
+  }
+
+  const { Redis } = await import("ioredis");
+  const endpoint = await connectionEndpoint(config);
+  const tls = await redisTlsOptions(config);
+  const client = new Redis({
+    host: endpoint.host,
+    port: endpoint.port,
+    username: config.username || undefined,
+    password: config.password || undefined,
+    db,
+    tls,
+    lazyConnect: true,
+    enableReadyCheck: false,
+    maxRetriesPerRequest: 0,
+    enableOfflineQueue: false,
+    connectTimeout: Math.min(resolveTimeoutMs(options), 10_000),
+    commandTimeout: resolveTimeoutMs(options),
+  });
+
+  try {
+    await client.connect();
+    const value = await client.call(command, ...argv.slice(1));
+    return { command, safety, value: redisValueToJson(value) };
+  } finally {
+    client.disconnect();
+  }
+}
+
+async function redisTlsOptions(config: ConnectionConfig): Promise<import("node:tls").ConnectionOptions | undefined> {
+  if (!config.ssl) return undefined;
+  const params = urlParams(config);
+  const tls: import("node:tls").ConnectionOptions = {
+    servername: config.host,
+  };
+  if ((params.get("insecure") || "").toLowerCase() === "true") {
+    tls.rejectUnauthorized = false;
+  }
+  if (config.ca_cert_path) tls.ca = await readFile(config.ca_cert_path);
+  if (config.client_cert_path) tls.cert = await readFile(config.client_cert_path);
+  if (config.client_key_path) tls.key = await readFile(config.client_key_path);
+  return tls;
+}
+
+function redisValueToJson(value: unknown): unknown {
+  if (Buffer.isBuffer(value)) return redisTextToJson(value.toString("utf8"));
+  if (Array.isArray(value)) return value.map(redisValueToJson);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redisValueToJson(item)]));
+  }
+  if (typeof value === "string") return redisTextToJson(value);
+  return value;
+}
+
+function redisTextToJson(value: string): unknown {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+
+export async function listTables(config: ConnectionConfig, schema?: string): Promise<TableInfo[]> {
+  if (config.db_type === "mongodb") {
+    const collections = await bridgeDataRequest<CollectionListEntry[]>("/data/mongo/list-collections", {
+      connection_id: config.id,
+      connection_name: config.name,
+      database: config.database || "",
+      schema: schema || "",
+    });
+    return collectionListToTableInfos(collections);
+  }
+  if (config.db_type === "sqlite" || config.db_type === "rqlite") {
+    const result = await query(config, `SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY name`);
+    return result.rows.map((r) => ({ name: String(r.name || ""), type: String(r.type || "table") }));
+  }
+  if (hasActiveSshLayer(config) || !isDirectQueryType(config.db_type)) {
+    const tables = await bridgeDataRequest<BridgeTableInfo[]>("/data/list-tables", {
+      connection_id: config.id,
+      connection_name: config.name,
+      database: config.database || "",
+      schema: schema || "",
+    });
+    return tables.map((t) => ({ name: t.name, type: t.table_type || "TABLE" }));
+  }
+  let result: QueryResult;
+  if (isMysqlType(config.db_type)) {
+    result = await query(config, `SELECT TABLE_NAME AS name, TABLE_TYPE AS type FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() ORDER BY TABLE_NAME`);
+  } else {
+    result = await query(config, `SELECT table_name AS name, table_type AS type FROM information_schema.tables WHERE table_schema = $1 ORDER BY table_name`, [schema || "public"]);
+  }
+  return result.rows.map((r) => ({ name: String(r.name || r.NAME), type: String(r.type || r.TYPE || "TABLE") }));
+}
+
+export async function describeTable(config: ConnectionConfig, table: string, schema?: string): Promise<ColumnInfo[]> {
+  if (config.db_type === "mongodb") {
+    const result = await mongoFindDocuments(config, table, 0, 20, "{}");
+    return inferMongoColumns(result.documents);
+  }
+  if (config.db_type === "sqlite" || config.db_type === "rqlite") {
+    const result = await query(config, `PRAGMA table_info(${quoteSqliteIdentifier(table)})`);
+    return result.rows.map((r) => ({
+      name: String(r.name || ""),
+      data_type: String(r.type || ""),
+      is_nullable: Number(r.notnull || 0) === 0,
+      column_default: r.dflt_value != null ? String(r.dflt_value) : null,
+      is_primary_key: Number(r.pk || 0) > 0,
+      comment: null,
+    }));
+  }
+  if (hasActiveSshLayer(config) || !isDirectQueryType(config.db_type)) {
+    const columns = await bridgeDataRequest<BridgeColumnInfo[]>("/data/describe-table", {
+      connection_id: config.id,
+      connection_name: config.name,
+      database: config.database || "",
+      schema: schema || "",
+      table,
+    });
+    return columns.map((column) => mapDescribeTableColumn(column, column.enum_values ?? null));
+  }
+  let result: QueryResult;
+  if (isMysqlType(config.db_type)) {
+    result = await query(config, MYSQL_DESCRIBE_TABLE_SQL, [table]);
+    return result.rows.map((row) => mapDescribeTableColumn(row, String(row.data_type || "").toLowerCase() === "enum" ? parseMysqlEnumValues(row.column_type) : null));
+  } else if (config.db_type === "postgres") {
+    try {
+      result = await query(config, POSTGRES_DESCRIBE_TABLE_SQL, [schema || "public", table]);
+    } catch {
+      result = await query(config, POSTGRES_DESCRIBE_TABLE_COMPAT_SQL, [schema || "public", table]);
+    }
+  } else {
+    result = await query(config, POSTGRES_DESCRIBE_TABLE_COMPAT_SQL, [schema || "public", table]);
+  }
+  return result.rows.map((row) => mapDescribeTableColumn(row, normalizeEnumValues(row.enum_values)));
+}
+
+async function mongoFindDocuments(config: ConnectionConfig, collection: string, skip: number, limit: number, filter: string, projection?: string, sort?: string): Promise<MongoDocumentResult> {
+  return bridgeDataRequest<MongoDocumentResult>("/data/mongo/find-documents", {
+    connection_id: config.id,
+    connection_name: config.name,
+    database: config.database || "",
+    collection,
+    skip,
+    limit,
+    filter,
+    projection,
+    sort,
+  });
+}
+
+async function mongoServerVersion(config: ConnectionConfig): Promise<string> {
+  return bridgeDataRequest<string>("/data/mongo/server-version", {
+    connection_id: config.id,
+    connection_name: config.name,
+    database: config.database || "",
+  });
+}
+
+async function mongoCollectionStats(config: ConnectionConfig, collection: string, scale?: number): Promise<Record<string, unknown>> {
+  return bridgeDataRequest<Record<string, unknown>>("/data/mongo/collection-stats", {
+    connection_id: config.id,
+    connection_name: config.name,
+    database: config.database || "",
+    collection,
+    scale,
+  });
+}
+
+async function executeMongoWrite(config: ConnectionConfig, command: MongoWriteCommand): Promise<{ affectedRows: number; indexName?: string; droppedNames?: string[] }> {
+  if (command.kind === "insert") {
+    const result = await bridgeDataRequest<{ affected_rows: number }>("/data/mongo/insert-documents", {
+      connection_id: config.id,
+      connection_name: config.name,
+      database: config.database || "",
+      collection: command.collection,
+      docs_json: command.docsJson,
+    });
+    return { affectedRows: result.affected_rows };
+  }
+  if (command.kind === "update") {
+    const result = await bridgeDataRequest<{ affected_rows: number }>("/data/mongo/update-documents", {
+      connection_id: config.id,
+      connection_name: config.name,
+      database: config.database || "",
+      collection: command.collection,
+      filter_json: command.filter,
+      update_json: command.update,
+      many: command.many,
+      options_json: command.options,
+    });
+    return { affectedRows: result.affected_rows };
+  }
+  if (command.kind === "createIndex") {
+    const result = await bridgeDataRequest<{ name: string }>("/data/mongo/create-index", {
+      connection_id: config.id,
+      connection_name: config.name,
+      database: config.database || "",
+      collection: command.collection,
+      keys_json: command.keys,
+      options_json: command.options,
+    });
+    return { affectedRows: 1, indexName: result.name };
+  }
+  if (command.kind === "dropIndex" || command.kind === "dropIndexes") {
+    const result = await bridgeDataRequest<{ dropped_names: string[]; affected_rows: number }>("/data/mongo/drop-indexes", {
+      connection_id: config.id,
+      connection_name: config.name,
+      database: config.database || "",
+      collection: command.collection,
+      indexes_json: command.kind === "dropIndex" ? command.index : command.indexes,
+      single: command.kind === "dropIndex",
+    });
+    return { affectedRows: result.affected_rows, droppedNames: result.dropped_names };
+  }
+  if (command.kind === "dropCollection") {
+    await bridgeDataRequest<{ ok: boolean }>("/data/mongo/drop-collection", {
+      connection_id: config.id,
+      connection_name: config.name,
+      database: config.database || "",
+      collection: command.collection,
+    });
+    return { affectedRows: 1 };
+  }
+  const result = await bridgeDataRequest<{ affected_rows: number }>("/data/mongo/delete-documents", {
+    connection_id: config.id,
+    connection_name: config.name,
+    database: config.database || "",
+    collection: command.collection,
+    filter_json: command.filter,
+    many: command.many,
+  });
+  return { affectedRows: result.affected_rows };
+}
+
+async function mongoAggregateDocuments(config: ConnectionConfig, collection: string, pipelineJson: string, maxRows: number): Promise<MongoDocumentResult> {
+  return bridgeDataRequest<MongoDocumentResult>("/data/mongo/aggregate-documents", {
+    connection_id: config.id,
+    connection_name: config.name,
+    database: config.database || "",
+    collection,
+    pipeline_json: pipelineJson,
+    max_rows: maxRows,
+  });
+}
+
+export function mongoCollectionStatsToQueryResult(metric: MongoCollectionStatsMetric, stats: Record<string, unknown>): QueryResult {
+  if (metric === "stats") {
+    const columns = ["count", "size", "avgObjSize", "storageSize", "totalIndexSize", "nindexes"];
+    const row: Record<string, unknown> = {};
+    for (const column of columns) {
+      row[column] = column in stats ? toCellValue(stats[column]) : null;
+    }
+    return { columns, rows: [row], row_count: 1 };
+  }
+  const sourceField = metric === "dataSize" ? "size" : metric;
+  return {
+    columns: [metric],
+    rows: [{ [metric]: sourceField in stats ? toCellValue(stats[sourceField]) : null }],
+    row_count: 1,
+  };
+}
+
+export function mongoDocumentsToQueryResult(documents: unknown[], _total: number): QueryResult {
+  const columns: string[] = [];
+  for (const doc of documents) {
+    if (isRecord(doc)) {
+      for (const key of Object.keys(doc)) {
+        if (!columns.includes(key)) columns.push(key);
+      }
+    } else if (!columns.includes("value")) {
+      columns.push("value");
+    }
+  }
+  const rows = documents.map((doc) => {
+    const row: Record<string, unknown> = {};
+    for (const column of columns) {
+      row[column] = isRecord(doc) ? toCellValue(doc[column]) : column === "value" ? toCellValue(doc) : null;
+    }
+    return row;
+  });
+  return { columns, rows, row_count: rows.length };
+}
+
+export function inferMongoColumns(documents: unknown[]): ColumnInfo[] {
+  const columns = new Map<string, { types: Set<string>; nullable: boolean }>();
+  for (const doc of documents) {
+    if (!isRecord(doc)) {
+      const entry = columns.get("value") ?? { types: new Set<string>(), nullable: false };
+      entry.types.add(mongoTypeName(doc));
+      columns.set("value", entry);
+      continue;
+    }
+    for (const [name, value] of Object.entries(doc)) {
+      const entry = columns.get(name) ?? { types: new Set<string>(), nullable: false };
+      entry.types.add(mongoTypeName(value));
+      if (value === null || value === undefined) entry.nullable = true;
+      columns.set(name, entry);
+    }
+  }
+  return Array.from(columns.entries()).map(([name, entry]) => ({
+    name,
+    data_type: Array.from(entry.types).sort().join(" | ") || "unknown",
+    is_nullable: entry.nullable,
+    column_default: null,
+    is_primary_key: name === "_id",
+    comment: null,
+  }));
+}
+
+interface MongoFindCommand {
+  collection: string;
+  filter: string;
+  projection?: string;
+  skip: number;
+  limit: number;
+  sort?: string;
+}
+
+interface MongoCountDocumentsCommand {
+  collection: string;
+  filter: string;
+}
+
+interface MongoAggregateCommand {
+  collection: string;
+  pipeline: string;
+}
+
+interface MongoGetIndexesCommand {
+  collection: string;
+}
+
+type MongoCollectionStatsMetric = "stats" | "dataSize" | "storageSize" | "totalIndexSize";
+
+interface MongoCollectionStatsCommand {
+  collection: string;
+  metric: MongoCollectionStatsMetric;
+  scale?: number;
+}
+
+export type MongoWriteCommand =
+  | { kind: "insert"; collection: string; docsJson: string }
+  | { kind: "update"; collection: string; filter: string; update: string; options?: string; many: boolean }
+  | { kind: "delete"; collection: string; filter: string; many: boolean }
+  | { kind: "createIndex"; collection: string; keys: string; options?: string }
+  | { kind: "dropIndex"; collection: string; index: string }
+  | { kind: "dropIndexes"; collection: string; indexes?: string }
+  | { kind: "dropCollection"; collection: string };
+
+export function parseMongoFindCommand(input: string): MongoFindCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  const target = parseCollectionMethodTarget(source, "find");
+  if (!target) return null;
+  const findOpenIndex = source.indexOf("(", target.methodCallIndex);
+  const findCloseIndex = findMatchingParen(source, findOpenIndex);
+  if (findCloseIndex < 0) return null;
+  const findArgs = splitTopLevel(source.slice(findOpenIndex + 1, findCloseIndex));
+  if (findArgs.length > 2 && findArgs.slice(2).some((arg) => arg.trim())) return null;
+  const filter = normalizeJsonArgument(findArgs[0] || "{}");
+  if (!filter) return null;
+  let projection: string | undefined;
+  if (findArgs[1]?.trim()) {
+    const parsedProjection = normalizeJsonArgument(findArgs[1]);
+    if (!parsedProjection) return null;
+    projection = parsedProjection;
+  }
+  const chain = source.slice(findCloseIndex + 1).trim();
+  if (chain && !chain.startsWith(".")) return null;
+  if (findChainedMethodCallIndex(chain, "count") >= 0) return null;
+  const sortArg = readChainedCallArgument(chain, "sort");
+  let sort: string | undefined;
+  if (sortArg !== undefined) {
+    const parsedSort = normalizeJsonArgument(sortArg);
+    if (!parsedSort) return null;
+    sort = parsedSort;
+  }
+  const skip = readChainedIntegerArgument(chain, "skip", 0);
+  const limit = readChainedIntegerArgument(chain, "limit", MAX_ROWS);
+  if (skip === null || limit === null) return null;
+  return { collection: target.collection, filter, ...(projection ? { projection } : {}), skip, limit, sort };
+}
+
+export function parseMongoVersionCommand(input: string): boolean {
+  const source = input.trim().replace(/;$/, "").trim();
+  return /^db\s*\.\s*version\s*\(\s*\)$/i.test(source);
+}
+
+export function parseMongoCountDocumentsCommand(input: string): MongoCountDocumentsCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  // Accept deprecated Mongo shell count helpers for old server workflows, but
+  // keep DBX's internal execution mapped to the countDocuments result shape.
+  return parseCollectionCountCommand(source, "countDocuments") ?? parseCollectionCountCommand(source, "count") ?? parseFindCountCommand(source);
+}
+
+function parseCollectionCountCommand(source: string, method: "countDocuments" | "count"): MongoCountDocumentsCommand | null {
+  const target = parseCollectionMethodTarget(source, method);
+  if (!target) return null;
+  const openIndex = source.indexOf("(", target.methodCallIndex);
+  const closeIndex = findMatchingParen(source, openIndex);
+  if (closeIndex < 0 || source.slice(closeIndex + 1).trim()) return null;
+  const args = splitTopLevel(source.slice(openIndex + 1, closeIndex));
+  if (args.length > 1 && args.slice(1).some((arg) => arg.trim())) return null;
+  const filter = normalizeJsonArgument(args[0] || "{}");
+  return filter ? { collection: target.collection, filter } : null;
+}
+
+function parseFindCountCommand(source: string): MongoCountDocumentsCommand | null {
+  const target = parseCollectionMethodTarget(source, "find");
+  if (!target) return null;
+  const findOpenIndex = source.indexOf("(", target.methodCallIndex);
+  const findCloseIndex = findMatchingParen(source, findOpenIndex);
+  if (findCloseIndex < 0) return null;
+  const chain = source.slice(findCloseIndex + 1).trim();
+  if (!hasSingleEmptyChainedCall(chain, "count")) return null;
+  const findArgs = splitTopLevel(source.slice(findOpenIndex + 1, findCloseIndex));
+  if (findArgs.length > 2 && findArgs.slice(2).some((arg) => arg.trim())) return null;
+  const filter = normalizeJsonArgument(findArgs[0] || "{}");
+  return filter ? { collection: target.collection, filter } : null;
+}
+
+export function parseMongoAggregateCommand(input: string): MongoAggregateCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  const target = parseCollectionMethodTarget(source, "aggregate");
+  if (!target) return null;
+  const args = parseMethodArgs(source, target.methodCallIndex);
+  if (!args || args.length !== 1) return null;
+  const pipeline = normalizeJsonArgument(args[0]);
+  if (!pipeline) return null;
+  return Array.isArray(JSON.parse(pipeline)) ? { collection: target.collection, pipeline } : null;
+}
+
+export function parseMongoGetIndexesCommand(input: string): MongoGetIndexesCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  const target = parseCollectionMethodTarget(source, "getIndexes");
+  if (!target) return null;
+  const args = parseMethodArgs(source, target.methodCallIndex);
+  if (!args || args.some((arg) => arg.trim())) return null;
+  return { collection: target.collection };
+}
+
+export function parseMongoCollectionStatsCommand(input: string): MongoCollectionStatsCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  for (const metric of ["stats", "dataSize", "storageSize", "totalIndexSize"] as const) {
+    const target = parseCollectionMethodTarget(source, metric);
+    if (!target) continue;
+    const args = parseMethodArgs(source, target.methodCallIndex);
+    if (!args) return null;
+    const scale = parseMongoCollectionStatsScale(args);
+    return scale === null ? null : { collection: target.collection, metric, ...(scale === undefined ? {} : { scale }) };
+  }
+  return null;
+}
+
+export function mongoAggregateWriteStage(pipelineJson: string): "$out" | "$merge" | null {
+  try {
+    const pipeline = JSON.parse(pipelineJson);
+    if (!Array.isArray(pipeline)) return null;
+    for (const stage of pipeline) {
+      if (!isRecord(stage)) continue;
+      if (Object.prototype.hasOwnProperty.call(stage, "$out")) return "$out";
+      if (Object.prototype.hasOwnProperty.call(stage, "$merge")) return "$merge";
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function parseMongoWriteCommand(input: string): MongoWriteCommand | null {
+  const source = input.trim().replace(/;$/, "").trim();
+  const insertOne = parseCollectionMethodTarget(source, "insertOne");
+  if (insertOne) {
+    const args = parseMethodArgs(source, insertOne.methodCallIndex);
+    if (!args || args.length !== 1) return null;
+    const doc = normalizeJsonArgument(args[0]);
+    return doc ? { kind: "insert", collection: insertOne.collection, docsJson: doc } : null;
+  }
+
+  const insertMany = parseCollectionMethodTarget(source, "insertMany");
+  if (insertMany) {
+    const args = parseMethodArgs(source, insertMany.methodCallIndex);
+    if (!args || args.length !== 1) return null;
+    const docs = normalizeJsonArgument(args[0]);
+    if (!docs) return null;
+    return Array.isArray(JSON.parse(docs)) ? { kind: "insert", collection: insertMany.collection, docsJson: docs } : null;
+  }
+
+  for (const method of ["updateOne", "updateMany"] as const) {
+    const target = parseCollectionMethodTarget(source, method);
+    if (!target) continue;
+    const args = parseMethodArgs(source, target.methodCallIndex);
+    if (!args || args.length < 2 || args.length > 3) return null;
+    const filter = normalizeJsonArgument(args[0]);
+    const update = normalizeJsonArgument(args[1]);
+    if (!filter || !update) return null;
+    const options = args[2]?.trim() ? normalizeJsonArgument(args[2]) : undefined;
+    if (args[2]?.trim() && !options) return null;
+    return { kind: "update", collection: target.collection, filter, update, ...(options ? { options } : {}), many: method === "updateMany" };
+  }
+
+  for (const method of ["deleteOne", "deleteMany"] as const) {
+    const target = parseCollectionMethodTarget(source, method);
+    if (!target) continue;
+    const args = parseMethodArgs(source, target.methodCallIndex);
+    if (!args || args.length !== 1) return null;
+    const filter = normalizeJsonArgument(args[0]);
+    if (!filter) return null;
+    return { kind: "delete", collection: target.collection, filter, many: method === "deleteMany" };
+  }
+
+  const createIndex = parseCollectionMethodTarget(source, "createIndex");
+  if (createIndex) {
+    const args = parseMethodArgs(source, createIndex.methodCallIndex);
+    if (!args || args.length < 1 || args.length > 2) return null;
+    const keys = normalizeJsonArgument(args[0]);
+    if (!keys) return null;
+    let options: string | undefined;
+    if (args[1]?.trim()) {
+      const parsedOptions = normalizeJsonArgument(args[1]);
+      if (!parsedOptions) return null;
+      options = parsedOptions;
+    }
+    return { kind: "createIndex", collection: createIndex.collection, keys, ...(options ? { options } : {}) };
+  }
+
+  const dropIndex = parseCollectionMethodTarget(source, "dropIndex");
+  if (dropIndex) {
+    const args = parseMethodArgs(source, dropIndex.methodCallIndex);
+    if (!args) return null;
+    const index = parseMongoDropIndexArgument(args);
+    return index ? { kind: "dropIndex", collection: dropIndex.collection, index } : null;
+  }
+
+  const dropIndexes = parseCollectionMethodTarget(source, "dropIndexes");
+  if (dropIndexes) {
+    const args = parseMethodArgs(source, dropIndexes.methodCallIndex);
+    if (!args) return null;
+    const indexes = parseMongoDropIndexesArgument(args);
+    return indexes !== null ? { kind: "dropIndexes", collection: dropIndexes.collection, ...(indexes ? { indexes } : {}) } : null;
+  }
+
+  const dropCollection = parseCollectionMethodTarget(source, "drop");
+  if (dropCollection) {
+    const args = parseMethodArgs(source, dropCollection.methodCallIndex);
+    if (!args || args.some((arg) => arg.trim())) return null;
+    return { kind: "dropCollection", collection: dropCollection.collection };
+  }
+
+  return null;
+}
+
+export function evaluateMongoWriteSafety(command: MongoWriteCommand, options: { allowWrites?: boolean; allowDangerous?: boolean }): { allowed: boolean; reason?: string } {
+  if (!options.allowWrites) {
+    return {
+      allowed: false,
+      reason: "MCP MongoDB execution is read-only by default. Set DBX_MCP_ALLOW_WRITES=1 to allow write commands.",
+    };
+  }
+  if (!options.allowDangerous && (command.kind === "update" || command.kind === "delete") && isEmptyJsonObject(command.filter)) {
+    return {
+      allowed: false,
+      reason: "MongoDB update/delete commands must include a non-empty filter unless DBX_MCP_ALLOW_DANGEROUS_SQL=1 is set.",
+    };
+  }
+  if (!options.allowDangerous && mongoDropIndexesRequiresDangerous(command)) {
+    return {
+      allowed: false,
+      reason: "MongoDB dropIndexes() without a specific single index requires DBX_MCP_ALLOW_DANGEROUS_SQL=1.",
+    };
+  }
+  if (!options.allowDangerous && command.kind === "dropCollection") {
+    return {
+      allowed: false,
+      reason: "MongoDB drop() requires DBX_MCP_ALLOW_DANGEROUS_SQL=1.",
+    };
+  }
+  return { allowed: true };
+}
+
+export function evaluateMongoAggregateSafety(command: MongoAggregateCommand, options: { allowWrites?: boolean; allowDangerous?: boolean }): { allowed: boolean; reason?: string } {
+  const writeStage = mongoAggregateWriteStage(command.pipeline);
+  if (!writeStage) return { allowed: true };
+  if (!options.allowWrites) {
+    return {
+      allowed: false,
+      reason: `MongoDB aggregate stage "${writeStage}" writes data. Set DBX_MCP_ALLOW_WRITES=1 to allow write commands.`,
+    };
+  }
+  if (!options.allowDangerous) {
+    return {
+      allowed: false,
+      reason: `MongoDB aggregate stage "${writeStage}" is dangerous. Set DBX_MCP_ALLOW_DANGEROUS_SQL=1 to allow it.`,
+    };
+  }
+  return { allowed: true };
+}
+
+function parseCollectionMethodTarget(source: string, method: string): { collection: string; methodCallIndex: number } | null {
+  const escapedMethod = escapeRegExp(method);
+  const direct = new RegExp(`^db\\s*\\.\\s*([A-Za-z_$][\\w$]*)\\s*\\.\\s*${escapedMethod}\\s*\\(`).exec(source);
+  if (direct) return { collection: direct[1], methodCallIndex: findChainedMethodCallIndex(source, method) };
+  const quoted = new RegExp(`^db\\s*\\.\\s*getCollection\\s*\\(\\s*(['"])([^'"]+)\\1\\s*\\)\\s*\\.\\s*${escapedMethod}\\s*\\(`).exec(source);
+  if (quoted) return { collection: quoted[2], methodCallIndex: findChainedMethodCallIndex(source, method) };
+  return null;
+}
+
+function parseMethodArgs(source: string, methodCallIndex: number): string[] | null {
+  const openIndex = source.indexOf("(", methodCallIndex);
+  const closeIndex = findMatchingParen(source, openIndex);
+  if (closeIndex < 0 || source.slice(closeIndex + 1).trim()) return null;
+  return splitTopLevel(source.slice(openIndex + 1, closeIndex));
+}
+
+function readChainedCallArgument(chain: string, method: string): string | undefined {
+  const match = chainedMethodCallPattern(method).exec(chain);
+  if (!match) return undefined;
+  const openIndex = chain.indexOf("(", match.index);
+  const closeIndex = findMatchingParen(chain, openIndex);
+  return closeIndex < 0 ? undefined : chain.slice(openIndex + 1, closeIndex);
+}
+
+function hasSingleEmptyChainedCall(chain: string, method: string): boolean {
+  const trimmed = chain.trim();
+  const match = chainedMethodCallPattern(method).exec(trimmed);
+  if (!match || match.index !== 0) return false;
+  const openIndex = trimmed.indexOf("(", match.index);
+  const closeIndex = findMatchingParen(trimmed, openIndex);
+  return closeIndex >= 0 && !trimmed.slice(openIndex + 1, closeIndex).trim() && !trimmed.slice(closeIndex + 1).trim();
+}
+
+function findChainedMethodCallIndex(source: string, method: string): number {
+  return chainedMethodCallPattern(method).exec(source)?.index ?? -1;
+}
+
+function chainedMethodCallPattern(method: string): RegExp {
+  return new RegExp(`\\.\\s*${escapeRegExp(method)}\\s*\\(`, "g");
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function readChainedIntegerArgument(chain: string, method: string, fallback: number): number | null {
+  const arg = readChainedCallArgument(chain, method);
+  if (arg === undefined) return fallback;
+  if (!/^\d+$/.test(arg.trim())) return null;
+  return Number(arg.trim());
+}
+
+function normalizeJsonArgument(arg: string): string | null {
+  const value = quoteUnquotedObjectKeys(convertSingleQuotedStrings((arg.trim() || "{}").replace(/ObjectId\s*\(\s*["']([^"']+)["']\s*\)/g, '{"$oid":"$1"}')));
+  try {
+    JSON.parse(value);
+    return value;
+  } catch {
+    return null;
+  }
+}
+
+function parseMongoDropIndexArgument(args: string[]): string | null {
+  if (args.length !== 1 || !args[0]?.trim()) return null;
+  const normalized = normalizeJsonArgument(args[0]);
+  if (!normalized) return null;
+  const parsed = parseNormalizedJson(normalized);
+  if (typeof parsed === "string") return parsed === "*" ? null : normalized;
+  return isNonEmptyRecord(parsed) ? normalized : null;
+}
+
+function parseMongoDropIndexesArgument(args: string[]): string | undefined | null {
+  if (args.length !== 1) return null;
+  if (!args[0]?.trim()) return undefined;
+  const normalized = normalizeJsonArgument(args[0]);
+  if (!normalized) return null;
+  const parsed = parseNormalizedJson(normalized);
+  if (typeof parsed === "string") return normalized;
+  if (isNonEmptyRecord(parsed)) return normalized;
+  return Array.isArray(parsed) && parsed.length > 0 && parsed.every((item) => typeof item === "string") ? normalized : null;
+}
+
+function parseMongoCollectionStatsScale(args: string[]): number | undefined | null {
+  if (args.length === 1 && !args[0]?.trim()) return undefined;
+  if (args.length !== 1) return null;
+  const raw = args[0].trim();
+  if (!/^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(raw)) return null;
+  const scale = Number(raw);
+  if (!Number.isFinite(scale)) return null;
+  return scale;
+}
+
+function convertSingleQuotedStrings(source: string): string {
+  let result = "";
+  let copiedUntil = 0;
+  let quote: string | null = null;
+  let start = 0;
+  let value = "";
+  let escaped = false;
+
+  for (let i = 0; i < source.length; i += 1) {
+    const char = source[i];
+    if (!quote) {
+      if (char === "'") {
+        quote = char;
+        start = i;
+        value = "";
+        escaped = false;
+      } else if (char === '"') {
+        quote = char;
+      }
+      continue;
+    }
+
+    if (quote === '"') {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') quote = null;
+      continue;
+    }
+
+    if (escaped) {
+      value += char;
+      escaped = false;
+    } else if (char === "\\") {
+      escaped = true;
+    } else if (char === "'") {
+      result += source.slice(copiedUntil, start) + JSON.stringify(value);
+      copiedUntil = i + 1;
+      quote = null;
+    } else {
+      value += char;
+    }
+  }
+
+  return quote === "'" ? source : result + source.slice(copiedUntil);
+}
+
+function quoteUnquotedObjectKeys(source: string): string {
+  let result = "";
+  let quote: string | null = null;
+  let escaped = false;
+
+  for (let i = 0; i < source.length; i += 1) {
+    const char = source[i];
+    if (quote) {
+      result += char;
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === quote) quote = null;
+      continue;
+    }
+
+    if (char === '"' || char === "'") {
+      quote = char;
+      result += char;
+      continue;
+    }
+
+    if (/[A-Za-z_$]/.test(char) && shouldQuoteObjectKey(source, i)) {
+      let end = i + 1;
+      while (/[\w$]/.test(source[end] || "")) end += 1;
+      result += `"${source.slice(i, end)}"`;
+      i = end - 1;
+      continue;
+    }
+
+    result += char;
+  }
+
+  return result;
+}
+
+function shouldQuoteObjectKey(source: string, index: number): boolean {
+  let before = index - 1;
+  while (/\s/.test(source[before] || "")) before -= 1;
+  if (source[before] !== "{" && source[before] !== ",") return false;
+
+  let after = index + 1;
+  while (/[\w$]/.test(source[after] || "")) after += 1;
+  while (/\s/.test(source[after] || "")) after += 1;
+  return source[after] === ":";
+}
+
+function parseNormalizedJson(json: string): unknown {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return undefined;
+  }
+}
+
+function isNonEmptyRecord(value: unknown): value is Record<string, unknown> {
+  return isRecord(value) && Object.keys(value).length > 0;
+}
+
+function isEmptyJsonObject(json: string): boolean {
+  try {
+    const parsed = JSON.parse(json);
+    return isRecord(parsed) && Object.keys(parsed).length === 0;
+  } catch {
+    return false;
+  }
+}
+
+function mongoDropIndexesRequiresDangerous(command: MongoWriteCommand): boolean {
+  if (command.kind !== "dropIndexes") return false;
+  if (!command.indexes) return true;
+  const parsed = parseNormalizedJson(command.indexes);
+  if (parsed === "*") return true;
+  return Array.isArray(parsed) && parsed.length > 1;
+}
+
+function splitTopLevel(source: string): string[] {
+  const parts: string[] = [];
+  let depth = 0;
+  let start = 0;
+  let quote: string | null = null;
+  for (let i = 0; i < source.length; i += 1) {
+    const ch = source[i];
+    if (quote) {
+      if (ch === "\\" && i + 1 < source.length) i += 1;
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') quote = ch;
+    else if (ch === "{" || ch === "[" || ch === "(") depth += 1;
+    else if (ch === "}" || ch === "]" || ch === ")") depth -= 1;
+    else if (ch === "," && depth === 0) {
+      parts.push(source.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(source.slice(start));
+  return parts;
+}
+
+function findMatchingParen(source: string, openIndex: number): number {
+  if (openIndex < 0 || source[openIndex] !== "(") return -1;
+  let depth = 0;
+  let quote: string | null = null;
+  for (let i = openIndex; i < source.length; i += 1) {
+    const ch = source[i];
+    if (quote) {
+      if (ch === "\\" && i + 1 < source.length) i += 1;
+      else if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"') quote = ch;
+    else if (ch === "(") depth += 1;
+    else if (ch === ")") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function mongoTypeName(value: unknown): string {
+  if (value === null || value === undefined) return "null";
+  if (Array.isArray(value)) return "array";
+  if (isRecord(value)) return "object";
+  return typeof value;
+}
+
+function toCellValue(value: unknown): unknown {
+  return typeof value === "object" && value !== null ? JSON.stringify(value) : value;
+}
diff --git a/packages/node-core/src/diagnostics.ts b/packages/node-core/src/diagnostics.ts
new file mode 100644
index 0000000..9b97e00
--- /dev/null
+++ b/packages/node-core/src/diagnostics.ts
@@ -0,0 +1,132 @@
+import { access, readFile } from "node:fs/promises";
+import { bridgePortFilePath, dbPath, appDataDir } from "./paths.js";
+import { inspectConnectionStore } from "./connections.js";
+
+export const DIRECT_QUERY_TYPES = ["postgres", "redshift", "mysql", "doris", "starrocks", "manticoresearch", "sqlite", "rqlite", "kwdb", "questdb"] as const;
+
+export type DirectQueryType = (typeof DIRECT_QUERY_TYPES)[number];
+
+const DIRECT_QUERY_TYPE_SET = new Set<string>(DIRECT_QUERY_TYPES);
+
+export function isDirectQueryType(dbType: string): dbType is DirectQueryType {
+  return DIRECT_QUERY_TYPE_SET.has(dbType);
+}
+
+export const BRIDGE_REQUIRED_TYPES = [
+  "cloudflare-d1",
+  "redis",
+  "mongodb",
+  "duckdb",
+  "clickhouse",
+  "sqlserver",
+  "oracle",
+  "elasticsearch",
+  "qdrant",
+  "milvus",
+  "weaviate",
+  "chromadb",
+  "etcd",
+  "dameng",
+  "kingbase",
+  "highgo",
+  "vastbase",
+  "goldendb",
+  "databend",
+  "gaussdb",
+  "yashandb",
+  "databricks",
+  "saphana",
+  "teradata",
+  "vertica",
+  "firebird",
+  "exasol",
+  "opengauss",
+  "oceanbase-oracle",
+  "gbase",
+  "tdengine",
+  "iotdb",
+  "h2",
+  "snowflake",
+  "trino",
+  "prestosql",
+  "hive",
+  "spark",
+  "db2",
+  "informix",
+  "iris",
+  "neo4j",
+  "cassandra",
+  "bigquery",
+  "kylin",
+  "sundb",
+  "oscar",
+  "xugu",
+  "jdbc",
+  "access",
+  "influxdb",
+  "zookeeper",
+] as const;
+
+export interface DbxDiagnostics {
+  appDataDir: string;
+  dbPath: string;
+  dbPathExists: boolean;
+  connectionsTableExists: boolean;
+  connectionSecretsTableExists?: boolean;
+  connectionRowCount: number;
+  loadConnectionsOk: boolean;
+  loadedConnectionCount: number;
+  loadConnectionsError?: string;
+  loadConnectionsHint?: string;
+  bridgePortFile: string;
+  bridgePortFileExists: boolean;
+  bridgeUrl?: string;
+  directQueryTypes: string[];
+  bridgeRequiredTypes: string[];
+}
+
+export async function getDbxDiagnostics(): Promise<DbxDiagnostics> {
+  const portFile = bridgePortFilePath();
+  const bridgePortFileExists = await exists(portFile);
+  let bridgeUrl: string | undefined;
+  if (bridgePortFileExists) {
+    const port = (await readFile(portFile, "utf-8")).trim();
+    if (port) bridgeUrl = `http://127.0.0.1:${port}`;
+  }
+
+  const path = dbPath();
+  const connectionStore = await inspectConnectionStore({ path });
+  return {
+    appDataDir: appDataDir(),
+    dbPath: path,
+    dbPathExists: connectionStore.dbPathExists,
+    connectionsTableExists: connectionStore.connectionsTableExists,
+    connectionSecretsTableExists: connectionStore.connectionSecretsTableExists,
+    connectionRowCount: connectionStore.connectionRowCount,
+    loadConnectionsOk: connectionStore.loadConnectionsOk,
+    loadedConnectionCount: connectionStore.loadedConnectionCount,
+    loadConnectionsError: connectionStore.loadConnectionsError,
+    loadConnectionsHint: connectionStore.loadConnectionsError ? connectionStoreHint(connectionStore.loadConnectionsError) : undefined,
+    bridgePortFile: portFile,
+    bridgePortFileExists,
+    bridgeUrl,
+    directQueryTypes: [...DIRECT_QUERY_TYPES],
+    bridgeRequiredTypes: [...BRIDGE_REQUIRED_TYPES],
+  };
+}
+
+function connectionStoreHint(message: string): string | undefined {
+  if (/NODE_MODULE_VERSION|compiled against a different Node\.js version/i.test(message)) {
+    return "Rebuild DBX CLI native dependencies with your active Node.js: pnpm rebuild better-sqlite3 keytar --pending, or reinstall the package with the same Node.js version you use to run dbx.";
+  }
+  return undefined;
+}
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
diff --git a/packages/node-core/src/entrypoint.ts b/packages/node-core/src/entrypoint.ts
new file mode 100644
index 0000000..4bfec99
--- /dev/null
+++ b/packages/node-core/src/entrypoint.ts
@@ -0,0 +1,21 @@
+import { realpathSync } from "node:fs";
+import { normalize, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function isMainModule(moduleUrl: string, argvPath: string | undefined): boolean {
+  if (!argvPath) return false;
+  return normalizeEntryPath(fileURLToPath(moduleUrl)) === normalizeEntryPath(argvPath);
+}
+
+function normalizeEntryPath(path: string): string {
+  const normalized = normalize(realpathIfPossible(resolve(path)));
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+
+function realpathIfPossible(path: string): string {
+  try {
+    return realpathSync.native(path);
+  } catch {
+    return path;
+  }
+}
diff --git a/packages/node-core/src/format.ts b/packages/node-core/src/format.ts
new file mode 100644
index 0000000..4acf16c
--- /dev/null
+++ b/packages/node-core/src/format.ts
@@ -0,0 +1,13 @@
+export function mdTable(headers: string[], rows: string[][]): string {
+  const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || "").length), 3));
+  const header = `| ${headers.map((h, i) => h.padEnd(widths[i])).join(" | ")} |`;
+  const sep = `| ${widths.map((w) => "-".repeat(w)).join(" | ")} |`;
+  const body = rows.map((r) => `| ${r.map((c, i) => (c || "").padEnd(widths[i])).join(" | ")} |`).join("\n");
+  return body ? `${header}\n${sep}\n${body}` : `${header}\n${sep}`;
+}
+
+export function formatCell(value: unknown): string {
+  if (value === null || value === undefined) return "NULL";
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
diff --git a/packages/node-core/src/index.ts b/packages/node-core/src/index.ts
new file mode 100644
index 0000000..694d4c5
--- /dev/null
+++ b/packages/node-core/src/index.ts
@@ -0,0 +1,13 @@
+export * from "./backend.js";
+export * from "./bridge.js";
+export * from "./connections.js";
+export * from "./database.js";
+export * from "./diagnostics.js";
+export * from "./entrypoint.js";
+export * from "./format.js";
+export * from "./paths.js";
+export * from "./production-safety.js";
+export * from "./redis-command.js";
+export * from "./schema-context.js";
+export * from "./sql-risk.js";
+export * from "./sql-safety.js";
diff --git a/packages/node-core/src/paths.ts b/packages/node-core/src/paths.ts
new file mode 100644
index 0000000..1edcd65
--- /dev/null
+++ b/packages/node-core/src/paths.ts
@@ -0,0 +1,35 @@
+import { homedir, platform } from "node:os";
+import { join, posix, win32 } from "node:path";
+
+export function appDataDir(): string {
+  // 支持 DBX_DATA_DIR 环境变量（与 Rust 侧 data_dir.rs 保持一致）
+  return appDataDirFromInputs({
+    platform: platform(),
+    home: homedir(),
+    appData: process.env.APPDATA,
+    envDataDir: process.env.DBX_DATA_DIR,
+  });
+}
+
+export function appDataDirFromInputs(options: { platform: NodeJS.Platform; home: string; appData?: string; envDataDir?: string }): string {
+  if (options.envDataDir && options.envDataDir.trim() !== "") {
+    return options.envDataDir;
+  }
+
+  switch (options.platform) {
+    case "darwin":
+      return posix.join(options.home, "Library", "Application Support", "com.dbx.app");
+    case "win32":
+      return win32.join(options.appData || win32.join(options.home, "AppData", "Roaming"), "com.dbx.app");
+    default:
+      return posix.join(options.home, ".local", "share", "com.dbx.app");
+  }
+}
+
+export function dbPath(): string {
+  return join(appDataDir(), "dbx.db");
+}
+
+export function bridgePortFilePath(): string {
+  return join(appDataDir(), "mcp-bridge-port");
+}
diff --git a/packages/node-core/src/production-safety.ts b/packages/node-core/src/production-safety.ts
new file mode 100644
index 0000000..4ec708b
--- /dev/null
+++ b/packages/node-core/src/production-safety.ts
@@ -0,0 +1,314 @@
+import type { ConnectionConfig } from "./connections.js";
+import { classifySqlRisk, isSqlRiskMutation } from "./sql-risk.js";
+
+export interface ProductionSqlAssessment {
+  active: boolean;
+  isMutation: boolean;
+  databases: string[];
+}
+
+const IDENTIFIER_PATTERN = String.raw`[A-Za-z0-9_@$#-]*[A-Za-z_@$#][A-Za-z0-9_@$#-]*`;
+const TARGET_NAME_PATTERN = String.raw`${IDENTIFIER_PATTERN}(?:\s*\.\s*(?:\*|${IDENTIFIER_PATTERN})){0,2}`;
+const QUALIFIED_NAME_PATTERN = String.raw`${IDENTIFIER_PATTERN}\s*\.\s*(?:\*|${IDENTIFIER_PATTERN})(?:\s*\.\s*(?:\*|${IDENTIFIER_PATTERN}))?`;
+const USE_RE = new RegExp(String.raw`^\s*USE\s+(${IDENTIFIER_PATTERN})`, "i");
+const DML_TARGET_RE = new RegExp(String.raw`\b(?:FROM|JOIN|UPDATE|INTO|REFERENCES)\s+(${TARGET_NAME_PATTERN})`, "gi");
+const DDL_OBJECT_TARGET_RE = new RegExp(String.raw`\b(?:CREATE|ALTER|DROP)\s+(?:OR\s+REPLACE\s+)?(?:TABLE|VIEW|MATERIALIZED\s+VIEW|INDEX|SEQUENCE|FUNCTION|PROCEDURE|ROUTINE|TRIGGER|EVENT|TYPE|SYNONYM)\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?(?:ONLY\s+)?(${TARGET_NAME_PATTERN})`, "gi");
+const INDEX_ON_TARGET_RE = new RegExp(String.raw`\b(?:CREATE|ALTER|DROP)\s+(?:UNIQUE\s+)?INDEX\b[\s\S]*?\bON\s+(${TARGET_NAME_PATTERN})`, "gi");
+const DATABASE_TARGET_RE = new RegExp(String.raw`\b(?:CREATE|ALTER|DROP)\s+(DATABASE|SCHEMA|CATALOG)\s+(?:IF\s+(?:NOT\s+)?EXISTS\s+)?(${IDENTIFIER_PATTERN})`, "gi");
+const COPY_TARGET_RE = new RegExp(String.raw`^\s*COPY\s+(${TARGET_NAME_PATTERN})\s+FROM\b`, "i");
+const TRUNCATE_TARGET_RE = new RegExp(String.raw`\bTRUNCATE\s+(?:TABLE\s+)?(${TARGET_NAME_PATTERN})`, "gi");
+const RENAME_TABLE_TARGET_RE = new RegExp(String.raw`\bRENAME\s+TABLE\s+(${TARGET_NAME_PATTERN})\s+TO\s+(${TARGET_NAME_PATTERN})`, "gi");
+const MAINTENANCE_TABLE_TARGET_RE = new RegExp(String.raw`\b(?:ANALYZE|OPTIMIZE|REPAIR|CHECK)\s+(?:NO_WRITE_TO_BINLOG\s+|LOCAL\s+)?TABLE\s+(${TARGET_NAME_PATTERN})`, "gi");
+const COMMENT_TARGET_RE = new RegExp(String.raw`\bCOMMENT\s+ON\s+(?:TABLE|VIEW|COLUMN|INDEX|SEQUENCE|FUNCTION|PROCEDURE|TYPE)\s+(${TARGET_NAME_PATTERN})`, "gi");
+const ROUTINE_CALL_TARGET_RE = new RegExp(String.raw`\b(?:CALL|EXEC|EXECUTE)\s+(${QUALIFIED_NAME_PATTERN})`, "gi");
+const PRIVILEGE_TARGET_RE = new RegExp(String.raw`\b(?:GRANT|REVOKE|DENY)\b[\s\S]*?\bON\s+(?:(?:TABLE|SEQUENCE|FUNCTION|PROCEDURE|ROUTINE|OBJECT)\s+|OBJECT\s*::\s*)?(${QUALIFIED_NAME_PATTERN})`, "gi");
+const PRIVILEGE_DATABASE_TARGET_RE = new RegExp(String.raw`\b(?:GRANT|REVOKE|DENY)\b[\s\S]*?\bON\s+(?:DATABASE|CATALOG)(?:::|\s+)\s*(${IDENTIFIER_PATTERN})`, "gi");
+const GLOBAL_PRIVILEGE_TARGET_RE = /\b(?:GRANT|REVOKE|DENY)\b[\s\S]*?\bON\s+\*\s*\.\s*\*/i;
+const GLOBAL_DDL_TARGET_RE = /^\s*(?:CREATE|ALTER|DROP)\s+(?:USER|ROLE|LOGIN|SERVER|TABLESPACE|RESOURCE|PROFILE|ACCOUNT)\b/i;
+const MULTI_TARGET_MUTATION_RE = /^\s*(?:DROP\s+(?:TEMPORARY\s+)?TABLE\b[\s\S]*,|RENAME\s+TABLE\b[\s\S]*,)/i;
+const THREE_PART_DATABASE_QUALIFIER_TYPES = new Set(["sqlserver", "snowflake", "trino", "prestosql", "databricks", "bigquery"]);
+const TRANSACTION_KEYWORDS = new Set(["begin", "start", "commit", "rollback", "abort", "savepoint", "release"]);
+const SCHEMA_FIRST_QUALIFIER_TYPES = new Set([
+  "postgres",
+  "redshift",
+  "gaussdb",
+  "kwdb",
+  "opengauss",
+  "kingbase",
+  "highgo",
+  "vastbase",
+  "yashandb",
+  "oracle",
+  "oceanbase-oracle",
+  "dameng",
+  "firebird",
+  "exasol",
+  "teradata",
+  "vertica",
+  "db2",
+  "informix",
+  "h2",
+  "iris",
+  "xugu",
+  "oscar",
+  "gbase",
+  "saphana",
+  "sqlserver",
+  "snowflake",
+  "trino",
+  "prestosql",
+  "databricks",
+  "bigquery",
+]);
+
+interface ReferencedDatabaseAssessment {
+  databases: string[];
+  uncertain: boolean;
+}
+
+interface SqlTargetSafetyText {
+  text: string;
+  quotedIdentifiers: Map<string, string>;
+}
+
+/** Normalizes quoted database names before production scope comparison. */
+export function normalizeProductionDatabase(value: string | undefined | null): string {
+  return String(value ?? "")
+    .trim()
+    .replace(/^[`"[]|[`"\]]$/g, "")
+    .toLowerCase();
+}
+
+export function isProductionDatabase(config: ConnectionConfig | undefined, database?: string): boolean {
+  if (!config) return false;
+  if (config.is_production) return true;
+  const selected = normalizeProductionDatabase(database);
+  return !!selected && (config.production_databases ?? []).some((name) => normalizeProductionDatabase(name) === selected);
+}
+
+/**
+ * Finds writes that target a marked production database, including a MySQL
+ * USE switch or a qualified database.table reference in a statement batch.
+ */
+export function assessProductionSql(sql: string, config: ConnectionConfig | undefined, activeDatabase?: string): ProductionSqlAssessment {
+  const targetText = sqlTargetSafetyText(sql);
+  const statements = splitTargetStatements(targetText.text);
+  const isMutation = isSqlRiskMutation(classifySqlRisk(sql).risk);
+  if (!isMutation || !config) return { active: isProductionDatabase(config, activeDatabase), isMutation, databases: [] };
+  if (config.is_production) return { active: true, isMutation, databases: [] };
+  if (isProductionDatabase(config, activeDatabase)) return { active: true, isMutation, databases: activeDatabase ? [activeDatabase] : [] };
+
+  const marked = new Set((config.production_databases ?? []).map(normalizeProductionDatabase).filter(Boolean));
+  if (!marked.size) return { active: false, isMutation, databases: [] };
+
+  const targets = referencedDatabases(statements, config.db_type, activeDatabase, targetText.quotedIdentifiers);
+  const databases = targets.databases.filter((database) => marked.has(normalizeProductionDatabase(database)));
+  return { active: databases.length > 0 || targets.uncertain, isMutation, databases: databases.length > 0 ? databases : targets.uncertain ? [...marked] : [] };
+}
+
+function referencedDatabases(statements: string[], dbType: string, activeDatabase: string | undefined, quotedIdentifiers: Map<string, string>): ReferencedDatabaseAssessment {
+  const databases = new Set<string>();
+  let uncertain = false;
+  let useDatabase = "";
+  const normalizedActiveDatabase = normalizeProductionDatabase(activeDatabase);
+
+  for (const statement of statements) {
+    const statementDatabases = new Set<string>();
+    const statementAssessment = classifySqlRisk(statement);
+    const statementIsMutation = isSqlRiskMutation(statementAssessment.risk);
+    const useMatch = statement.match(USE_RE);
+    if (useMatch?.[1]) {
+      useDatabase = normalizeTargetDatabase(useMatch[1], quotedIdentifiers);
+      continue;
+    }
+    if (!statementIsMutation) continue;
+    const currentDatabase = useDatabase || normalizedActiveDatabase;
+
+    collectQualifiedTargetDatabases(statement, dbType, quotedIdentifiers, currentDatabase, statementDatabases, DML_TARGET_RE, DDL_OBJECT_TARGET_RE, INDEX_ON_TARGET_RE, TRUNCATE_TARGET_RE, MAINTENANCE_TABLE_TARGET_RE, COMMENT_TARGET_RE, ROUTINE_CALL_TARGET_RE, PRIVILEGE_TARGET_RE);
+    collectQualifiedTargetDatabaseGroups(statement, dbType, quotedIdentifiers, currentDatabase, statementDatabases, RENAME_TABLE_TARGET_RE, [1, 2]);
+    for (const match of statement.matchAll(DATABASE_TARGET_RE)) {
+      const database = databaseTargetKindMeansDatabase(match[1], dbType) ? normalizeTargetDatabase(match[2], quotedIdentifiers) : "";
+      if (database) statementDatabases.add(database);
+    }
+    for (const match of statement.matchAll(PRIVILEGE_DATABASE_TARGET_RE)) {
+      const database = normalizeTargetDatabase(match[1], quotedIdentifiers);
+      if (database) statementDatabases.add(database);
+    }
+    const copyTarget = statement.match(COPY_TARGET_RE);
+    if (copyTarget?.[1]) {
+      const database = databaseFromQualifiedName(copyTarget[1], dbType, quotedIdentifiers, currentDatabase);
+      if (database) statementDatabases.add(database);
+    }
+    for (const database of statementDatabases) databases.add(database);
+    // The target regexes intentionally extract one object at a time. Until all
+    // list forms are parsed, never let a resolved first target disable fallback.
+    uncertain = uncertain || GLOBAL_PRIVILEGE_TARGET_RE.test(statement) || MULTI_TARGET_MUTATION_RE.test(statement) || isAmbiguousProductionTargetStatement(statement, statementAssessment, statementDatabases.size > 0);
+  }
+  return { databases: [...databases], uncertain };
+}
+
+function collectQualifiedTargetDatabases(statement: string, dbType: string, quotedIdentifiers: Map<string, string>, currentDatabase: string, databases: Set<string>, ...patterns: RegExp[]): void {
+  for (const pattern of patterns) {
+    collectQualifiedTargetDatabaseGroups(statement, dbType, quotedIdentifiers, currentDatabase, databases, pattern, [1]);
+  }
+}
+
+function collectQualifiedTargetDatabaseGroups(statement: string, dbType: string, quotedIdentifiers: Map<string, string>, currentDatabase: string, databases: Set<string>, pattern: RegExp, captureIndexes: number[]): void {
+  pattern.lastIndex = 0;
+  for (const match of statement.matchAll(pattern)) {
+    for (const captureIndex of captureIndexes) {
+      const database = databaseFromQualifiedName(match[captureIndex], dbType, quotedIdentifiers, currentDatabase);
+      if (database) databases.add(database);
+    }
+  }
+}
+
+function databaseFromQualifiedName(qualifiedName: string | undefined, dbType: string, quotedIdentifiers: Map<string, string>, currentDatabase: string): string {
+  const parts = String(qualifiedName ?? "")
+    .split(".")
+    .map((part) => normalizeTargetDatabase(part, quotedIdentifiers))
+    .filter(Boolean);
+  if (parts.length < 2) return currentDatabase;
+  if (qualifiedFirstPartIsDatabase(dbType, parts.length)) return parts[0] ?? "";
+  return currentDatabase;
+}
+
+function normalizeTargetDatabase(value: string | undefined, quotedIdentifiers: Map<string, string>): string {
+  const normalized = normalizeProductionDatabase(value);
+  const quoted = quotedIdentifiers.get(normalized);
+  return quoted === undefined ? normalized : normalizeProductionDatabase(quoted);
+}
+
+function qualifiedFirstPartIsDatabase(dbType: string, partCount: number): boolean {
+  const normalizedType = dbType.toLowerCase();
+  if (partCount >= 3 && THREE_PART_DATABASE_QUALIFIER_TYPES.has(normalizedType)) return true;
+  if (SCHEMA_FIRST_QUALIFIER_TYPES.has(normalizedType)) return false;
+  return partCount >= 2;
+}
+
+function databaseTargetKindMeansDatabase(kind: string | undefined, dbType: string): boolean {
+  const normalizedKind = String(kind ?? "").toLowerCase();
+  if (normalizedKind === "database" || normalizedKind === "catalog") return true;
+  if (normalizedKind !== "schema") return false;
+  return !SCHEMA_FIRST_QUALIFIER_TYPES.has(dbType.toLowerCase());
+}
+
+function isAmbiguousProductionTargetStatement(statement: string, assessment: ReturnType<typeof classifySqlRisk>, hasResolvedTarget: boolean): boolean {
+  if (!isSqlRiskMutation(assessment.risk)) return false;
+  if (assessment.risk === "transaction") return false;
+  const firstKeyword = assessment.firstKeyword;
+  if (firstKeyword && TRANSACTION_KEYWORDS.has(firstKeyword)) return false;
+  return GLOBAL_DDL_TARGET_RE.test(statement) || !hasResolvedTarget;
+}
+
+function splitTargetStatements(sql: string): string[] {
+  return sql
+    .split(";")
+    .map((statement) => statement.trim())
+    .filter(Boolean);
+}
+
+function sqlTargetSafetyText(sql: string, quotedIdentifiers = new Map<string, string>()): SqlTargetSafetyText {
+  let output = "";
+  let index = 0;
+  while (index < sql.length) {
+    const char = sql[index] ?? "";
+    const next = sql[index + 1] ?? "";
+    if (char === "-" && next === "-") {
+      index += 2;
+      while (index < sql.length && sql[index] !== "\n" && sql[index] !== "\r") index += 1;
+      output += " ";
+      continue;
+    }
+    if (char === "#") {
+      index += 1;
+      while (index < sql.length && sql[index] !== "\n" && sql[index] !== "\r") index += 1;
+      output += " ";
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      const close = sql.indexOf("*/", index + 2);
+      if (close < 0) return { text: output, quotedIdentifiers };
+      const executablePrefixLength = mysqlExecutableCommentPrefixLength(sql, index);
+      if (executablePrefixLength > 0) {
+        const bodyStart = skipExecutableCommentVersion(sql, index + executablePrefixLength);
+        output += ` ${sqlTargetSafetyText(sql.slice(bodyStart, close), quotedIdentifiers).text} `;
+      } else {
+        output += " ";
+      }
+      index = close + 2;
+      continue;
+    }
+    const dollarQuote = dollarQuoteTagAt(sql, index);
+    if (dollarQuote) {
+      const close = sql.indexOf(dollarQuote, index + dollarQuote.length);
+      index = close < 0 ? sql.length : close + dollarQuote.length;
+      output += " ";
+      continue;
+    }
+    if (char === "'") {
+      index = readQuotedEnd(sql, index, "'", "'");
+      output += " ";
+      continue;
+    }
+    if (char === '"' || char === "`" || char === "[") {
+      const close = char === "[" ? "]" : char;
+      const end = readQuotedEnd(sql, index, char, close);
+      const identifier = unquoteIdentifier(sql.slice(index, end), char, close).replace(/[;]/g, " ");
+      const token = `__dbxq${quotedIdentifiers.size}__`;
+      quotedIdentifiers.set(token.toLowerCase(), identifier);
+      output += ` ${token} `;
+      index = end;
+      continue;
+    }
+    output += char;
+    index += 1;
+  }
+  return { text: output, quotedIdentifiers };
+}
+
+function mysqlExecutableCommentPrefixLength(sql: string, index: number): number {
+  if (sql[index] !== "/" || sql[index + 1] !== "*") return 0;
+  if (sql[index + 2] === "!") return 3;
+  if (sql[index + 2] === "M" && sql[index + 3] === "!") return 4;
+  return 0;
+}
+
+function skipExecutableCommentVersion(sql: string, index: number): number {
+  let cursor = index;
+  while (cursor < sql.length && /[0-9\s]/.test(sql[cursor] ?? "")) cursor += 1;
+  return cursor;
+}
+
+function dollarQuoteTagAt(sql: string, index: number): string | undefined {
+  return sql.slice(index).match(/^\$[A-Za-z_][A-Za-z0-9_]*\$|^\$\$/)?.[0];
+}
+
+function readQuotedEnd(sql: string, start: number, open: string, close: string): number {
+  let index = start + open.length;
+  while (index < sql.length) {
+    if (sql[index] === "\\" && (open === "'" || open === '"')) {
+      index += 2;
+      continue;
+    }
+    if (sql.startsWith(close, index)) {
+      if (sql.startsWith(close + close, index)) {
+        index += close.length * 2;
+        continue;
+      }
+      return index + close.length;
+    }
+    index += 1;
+  }
+  return sql.length;
+}
+
+function unquoteIdentifier(value: string, open: string, close: string): string {
+  if (!value.startsWith(open) || !value.endsWith(close)) return value;
+  return value.slice(open.length, value.length - close.length).replaceAll(close + close, close);
+}
+
+/** MCP receives Mongo shell text rather than SQL, so use a conservative write detector. */
+export function isLikelyMongoMutation(command: string): boolean {
+  return /\.(?:insert(?:One|Many)?|update(?:One|Many)?|replaceOne|delete(?:One|Many)?|findOneAnd(?:Update|Replace|Delete)|drop(?:Index|Indexes)?|renameCollection|createIndex)\s*\(|\bdb\.createCollection\s*\(/i.test(command);
+}
diff --git a/packages/node-core/src/redis-command.ts b/packages/node-core/src/redis-command.ts
new file mode 100644
index 0000000..e5801eb
--- /dev/null
+++ b/packages/node-core/src/redis-command.ts
@@ -0,0 +1,213 @@
+import type { SqlSafetyOptions } from "./sql-safety.js";
+
+export type RedisCommandSafety = "allowed" | "write" | "confirm" | "blocked";
+
+export interface RedisCommandResult {
+  command: string;
+  safety: RedisCommandSafety;
+  value: unknown;
+}
+
+export interface RedisCommandOptions {
+  skipSafetyCheck?: boolean;
+  timeoutMs?: number;
+}
+
+export interface RedisCommandSafetyDecision {
+  allowed: boolean;
+  command?: string;
+  safety?: RedisCommandSafety;
+  reason?: string;
+  skipSafetyCheck?: boolean;
+}
+
+const BLOCKED_REDIS_COMMANDS = new Set(["KEYS", "FLUSHALL", "SHUTDOWN", "CONFIG", "SAVE", "BGSAVE", "SLAVEOF", "REPLICAOF", "MIGRATE", "MODULE", "SCRIPT", "EVAL", "EVALSHA"]);
+
+const CONFIRM_REDIS_COMMANDS = new Set([
+  "DEL",
+  "UNLINK",
+  "EXPIRE",
+  "EXPIREAT",
+  "PEXPIRE",
+  "PEXPIREAT",
+  "RENAME",
+  "RENAMENX",
+  "GETDEL",
+  "HDEL",
+  "LPOP",
+  "RPOP",
+  "LREM",
+  "LTRIM",
+  "SPOP",
+  "SREM",
+  "ZREM",
+  "ZPOPMAX",
+  "ZPOPMIN",
+  "ZMPOP",
+  "ZREMRANGEBYLEX",
+  "ZREMRANGEBYRANK",
+  "ZREMRANGEBYSCORE",
+  "XDEL",
+  "XTRIM",
+  "MOVE",
+  "SORT",
+  "SDIFFSTORE",
+  "SINTERSTORE",
+  "SUNIONSTORE",
+  "ZDIFFSTORE",
+  "ZINTERSTORE",
+  "ZRANGESTORE",
+  "ZUNIONSTORE",
+  "PFMERGE",
+  "GEOSEARCHSTORE",
+  "FLUSHDB",
+]);
+
+const WRITE_REDIS_COMMANDS = new Set([
+  "APPEND",
+  "BITFIELD",
+  "BITOP",
+  "COPY",
+  "DECR",
+  "DECRBY",
+  "GEOADD",
+  "GEORADIUS",
+  "GEORADIUSBYMEMBER",
+  "GETSET",
+  "INCR",
+  "INCRBY",
+  "INCRBYFLOAT",
+  "SET",
+  "SETEX",
+  "PSETEX",
+  "SETNX",
+  "SETRANGE",
+  "MSET",
+  "MSETNX",
+  "PERSIST",
+  "HSET",
+  "HMSET",
+  "HINCRBY",
+  "HINCRBYFLOAT",
+  "HSETNX",
+  "LINSERT",
+  "LSET",
+  "LMOVE",
+  "LPUSH",
+  "LPUSHX",
+  "PFADD",
+  "RPUSH",
+  "RPUSHX",
+  "RESTORE",
+  "SADD",
+  "ZADD",
+  "ZINCRBY",
+  "SETBIT",
+  "XADD",
+  "XACK",
+  "XAUTOCLAIM",
+  "XCLAIM",
+  "XSETID",
+]);
+
+export function firstRedisCommandToken(commandText: string): string | undefined {
+  try {
+    return parseRedisCommandArgv(commandText)[0]?.toUpperCase();
+  } catch {
+    const token = commandText.trim().match(/^\S+/)?.[0]?.toUpperCase();
+    return token || undefined;
+  }
+}
+
+export function classifyRedisCommand(commandText: string): RedisCommandSafety {
+  const command = firstRedisCommandToken(commandText);
+  if (!command) return "blocked";
+  if (BLOCKED_REDIS_COMMANDS.has(command)) return "blocked";
+  if (CONFIRM_REDIS_COMMANDS.has(command)) return "confirm";
+  if (WRITE_REDIS_COMMANDS.has(command)) return "write";
+  return "allowed";
+}
+
+export function evaluateRedisCommandSafety(commandText: string, options: SqlSafetyOptions = {}): RedisCommandSafetyDecision {
+  const command = firstRedisCommandToken(commandText);
+  if (!command) {
+    return { allowed: false, reason: "Redis command is empty." };
+  }
+
+  const safety = classifyRedisCommand(command);
+  if (safety === "blocked" && !options.allowDangerous) {
+    return {
+      allowed: false,
+      command,
+      safety,
+      reason: `Dangerous Redis command "${command}" is blocked. Set DBX_MCP_ALLOW_DANGEROUS_SQL=1 to allow it.`,
+    };
+  }
+
+  if (safety !== "allowed" && !options.allowWrites) {
+    return {
+      allowed: false,
+      command,
+      safety,
+      reason: "MCP Redis command execution is read-only for this session. Set DBX_MCP_ALLOW_WRITES=1 to allow write or dangerous commands.",
+    };
+  }
+
+  return {
+    allowed: true,
+    command,
+    safety,
+    skipSafetyCheck: safety === "blocked" && options.allowDangerous === true,
+  };
+}
+
+export function parseRedisCommandArgv(commandText: string): string[] {
+  const trimmed = commandText.trimEnd().replace(/;+$/, "");
+  const argv: string[] = [];
+  let current = "";
+  let quote: '"' | "'" | undefined;
+  let escaping = false;
+
+  for (const ch of trimmed) {
+    if (escaping) {
+      if (ch === "n") current += "\n";
+      else if (ch === "r") current += "\r";
+      else if (ch === "t") current += "\t";
+      else current += ch;
+      escaping = false;
+      continue;
+    }
+
+    if (ch === "\\") {
+      escaping = true;
+      continue;
+    }
+
+    if (quote) {
+      if (ch === quote) quote = undefined;
+      else current += ch;
+      continue;
+    }
+
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+
+    if (/\s/.test(ch)) {
+      if (current) {
+        argv.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += ch;
+  }
+
+  if (escaping) current += "\\";
+  if (quote) throw new Error("Redis command has an unterminated quote");
+  if (current) argv.push(current);
+  if (argv.length === 0) throw new Error("Redis command is empty");
+  return argv;
+}
diff --git a/packages/node-core/src/schema-context.ts b/packages/node-core/src/schema-context.ts
new file mode 100644
index 0000000..b9f847f
--- /dev/null
+++ b/packages/node-core/src/schema-context.ts
@@ -0,0 +1,66 @@
+import type { ConnectionConfig } from "./connections.js";
+import type { ColumnInfo, TableInfo } from "./database.js";
+
+export interface SchemaContextBackend {
+  listTables(config: ConnectionConfig, schema?: string): Promise<TableInfo[]>;
+  describeTable(config: ConnectionConfig, table: string, schema?: string): Promise<ColumnInfo[]>;
+}
+
+export interface SchemaContextOptions {
+  schema?: string;
+  tables?: string[];
+  maxTables?: number;
+}
+
+export interface SchemaContextTable {
+  name: string;
+  type: string;
+  columns: ColumnInfo[];
+}
+
+export interface SchemaContext {
+  connection: string;
+  database: string;
+  schema: string;
+  truncated: boolean;
+  tables: SchemaContextTable[];
+}
+
+const DEFAULT_MAX_TABLES = 8;
+
+export async function buildSchemaContext(backend: SchemaContextBackend, config: ConnectionConfig, options: SchemaContextOptions = {}): Promise<SchemaContext> {
+  const maxTables = Math.max(1, Math.min(options.maxTables ?? DEFAULT_MAX_TABLES, 20));
+  const availableTables = await backend.listTables(config, options.schema);
+  const requested = new Set((options.tables ?? []).map((table) => table.toLowerCase()));
+  const selected = requested.size ? availableTables.filter((table) => requested.has(table.name.toLowerCase())) : availableTables.slice(0, maxTables);
+
+  const limited = selected.slice(0, maxTables);
+  const tables = await Promise.all(
+    limited.map(async (table) => ({
+      name: table.name,
+      type: table.type,
+      columns: await backend.describeTable(config, table.name, options.schema),
+    })),
+  );
+
+  return {
+    connection: config.name,
+    database: config.database || "",
+    schema: options.schema || "",
+    truncated: selected.length > limited.length || (!requested.size && availableTables.length > limited.length),
+    tables,
+  };
+}
+
+export function formatSchemaContext(context: SchemaContext): string {
+  const header = [`Connection: ${context.connection}`, context.database ? `Database: ${context.database}` : "", context.schema ? `Schema: ${context.schema}` : ""].filter(Boolean);
+  const sections = context.tables.map((table) => {
+    const lines = table.columns.map((column) => {
+      const parts = [column.name, column.data_type, column.is_nullable ? "NULL" : "NOT NULL", column.is_primary_key ? "PK" : ""].filter(Boolean);
+      return `- ${parts.join(" ")}${column.comment ? ` -- ${column.comment}` : ""}`;
+    });
+    return [`## ${table.name}`, `Type: ${table.type}`, ...lines].join("\n");
+  });
+  const suffix = context.truncated ? "\n\nNote: table list was truncated; request specific table names for more context." : "";
+  return `${header.join("\n")}\n\n${sections.join("\n\n")}${suffix}`;
+}
diff --git a/packages/node-core/src/sql-risk.ts b/packages/node-core/src/sql-risk.ts
new file mode 100644
index 0000000..fcd0b0e
--- /dev/null
+++ b/packages/node-core/src/sql-risk.ts
@@ -0,0 +1,234 @@
+export type SqlRiskLevel = "read" | "write" | "ddl" | "transaction" | "unknown";
+
+export interface SqlRiskStatementAssessment {
+  risk: SqlRiskLevel;
+  firstKeyword?: string;
+}
+
+export interface SqlRiskAssessment extends SqlRiskStatementAssessment {
+  statements: SqlRiskStatementAssessment[];
+}
+
+interface SqlRiskToken {
+  text: string;
+  normalized: string;
+}
+
+const READ_KEYWORDS = new Set(["select", "show", "describe", "desc", "values", "table"]);
+const WRITE_KEYWORDS = new Set(["insert", "update", "delete", "merge", "replace", "upsert", "load", "call", "exec", "execute", "flush"]);
+const DDL_KEYWORDS = new Set(["create", "alter", "drop", "truncate", "rename", "grant", "revoke", "deny", "comment", "reindex", "vacuum", "optimize"]);
+const TRANSACTION_KEYWORDS = new Set(["begin", "start", "commit", "rollback", "abort", "savepoint", "release"]);
+const EXPLAIN_OPTION_KEYWORDS = new Set(["explain", "analyze", "analyse", "verbose", "query", "plan", "format", "type", "costs", "buffers", "timing", "summary", "settings", "wal", "generic_plan"]);
+const PRIMARY_STATEMENT_KEYWORDS = new Set([...READ_KEYWORDS, ...WRITE_KEYWORDS, ...DDL_KEYWORDS, ...TRANSACTION_KEYWORDS, "with", "copy", "pragma", "use", "set"]);
+const SAFE_READ_PRAGMA_NAMES = new Set(["table_info", "table_xinfo", "index_list", "index_info", "foreign_key_list", "database_list", "compile_options", "data_version"]);
+const RISK_ORDER: Record<SqlRiskLevel, number> = { read: 0, write: 1, ddl: 2, transaction: 3, unknown: 4 };
+
+export function splitSqlStatementsForSafety(sql: string): string[] {
+  return sqlSafetyText(sql)
+    .split(";")
+    .map((statement) => statement.trim())
+    .filter(Boolean);
+}
+
+export function classifySqlRisk(sql: string): SqlRiskAssessment {
+  const statements = splitSqlStatementsForSafety(sql).map(classifySqlStatementRisk);
+  if (!statements.length) return { risk: "unknown", statements: [] };
+  const highest = statements.reduce<SqlRiskStatementAssessment>((current, statement) => (RISK_ORDER[statement.risk] > RISK_ORDER[current.risk] ? statement : current), { risk: "read" });
+  return { ...highest, statements };
+}
+
+export function classifySqlStatementRisk(sql: string): SqlRiskStatementAssessment {
+  return classifyTokens(tokenizeSqlForRisk(sql));
+}
+
+export function isSqlRiskMutation(risk: SqlRiskLevel): boolean {
+  return risk !== "read";
+}
+
+export function sqlSafetyText(sql: string): string {
+  let output = "";
+  let index = 0;
+  while (index < sql.length) {
+    const char = sql[index] ?? "";
+    const next = sql[index + 1] ?? "";
+    if (char === "-" && next === "-") {
+      index += 2;
+      while (index < sql.length && sql[index] !== "\n" && sql[index] !== "\r") index += 1;
+      output += " ";
+      continue;
+    }
+    if (char === "#") {
+      index += 1;
+      while (index < sql.length && sql[index] !== "\n" && sql[index] !== "\r") index += 1;
+      output += " ";
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      const close = sql.indexOf("*/", index + 2);
+      if (close < 0) return output;
+      const executablePrefixLength = mysqlExecutableCommentPrefixLength(sql, index);
+      if (executablePrefixLength > 0) {
+        const bodyStart = skipExecutableCommentVersion(sql, index + executablePrefixLength);
+        output += ` ${sqlSafetyText(sql.slice(bodyStart, close))} `;
+      } else {
+        output += " ";
+      }
+      index = close + 2;
+      continue;
+    }
+    const dollarQuote = dollarQuoteTagAt(sql, index);
+    if (dollarQuote) {
+      const close = sql.indexOf(dollarQuote, index + dollarQuote.length);
+      index = close < 0 ? sql.length : close + dollarQuote.length;
+      output += " ";
+      continue;
+    }
+    if (char === "'") {
+      index = readQuotedEnd(sql, index, "'", "'");
+      output += " ";
+      continue;
+    }
+    if (char === '"' || char === "`" || char === "[") {
+      const close = char === "[" ? "]" : char;
+      const end = readQuotedEnd(sql, index, char, close);
+      output += ` ${unquoteIdentifier(sql.slice(index, end), char, close).replace(/[;]/g, " ")} `;
+      index = end;
+      continue;
+    }
+    output += char;
+    index += 1;
+  }
+  return output;
+}
+
+function tokenizeSqlForRisk(sql: string): SqlRiskToken[] {
+  const tokens: SqlRiskToken[] = [];
+  const re = /[A-Za-z_@$#][A-Za-z0-9_@$#-]*|[0-9]+|[(),.;*]|\S/g;
+  for (const match of sql.matchAll(re)) {
+    const text = match[0] ?? "";
+    tokens.push({ text, normalized: /^[A-Za-z_@$#]/.test(text) ? text.toLowerCase() : text });
+  }
+  return tokens;
+}
+
+function classifyTokens(tokens: SqlRiskToken[]): SqlRiskStatementAssessment {
+  const useful = trimWrappingParentheses(tokens);
+  const firstKeyword = useful.find((token) => /^[a-z_]/i.test(token.text))?.normalized;
+  if (!firstKeyword) return { risk: "unknown" };
+  if (READ_KEYWORDS.has(firstKeyword)) {
+    return { risk: firstKeyword === "select" && hasTopLevelSelectInto(useful) ? "write" : "read", firstKeyword };
+  }
+  if (firstKeyword === "with") return { risk: highestRiskInTokens(useful) ?? "read", firstKeyword };
+  if (firstKeyword === "explain") return classifyExplainTokens(useful);
+  if (firstKeyword === "copy") return { risk: classifyCopyTokens(useful), firstKeyword };
+  if (firstKeyword === "pragma") return { risk: classifyPragmaTokens(useful), firstKeyword };
+  if (firstKeyword === "use") return { risk: "read", firstKeyword };
+  if (WRITE_KEYWORDS.has(firstKeyword)) return { risk: "write", firstKeyword };
+  if (DDL_KEYWORDS.has(firstKeyword)) return { risk: "ddl", firstKeyword };
+  if (TRANSACTION_KEYWORDS.has(firstKeyword)) return { risk: "transaction", firstKeyword };
+  return { risk: "unknown", firstKeyword };
+}
+
+function classifyExplainTokens(tokens: SqlRiskToken[]): SqlRiskStatementAssessment {
+  const analyze = tokens.some((token) => token.normalized === "analyze" || token.normalized === "analyse");
+  const innerIndex = tokens.findIndex((token, index) => index > 0 && PRIMARY_STATEMENT_KEYWORDS.has(token.normalized) && !EXPLAIN_OPTION_KEYWORDS.has(token.normalized));
+  if (innerIndex < 0) return { risk: "read", firstKeyword: "explain" };
+  const inner = classifyTokens(tokens.slice(innerIndex));
+  if (!analyze) return { risk: inner.risk === "unknown" ? "unknown" : "read", firstKeyword: "explain" };
+  return { risk: inner.risk, firstKeyword: inner.firstKeyword ?? "explain" };
+}
+
+function classifyCopyTokens(tokens: SqlRiskToken[]): SqlRiskLevel {
+  if (tokens.some((token) => token.normalized === "from")) return "write";
+  if (tokens.some((token) => token.normalized === "to")) return "read";
+  return "unknown";
+}
+
+function classifyPragmaTokens(tokens: SqlRiskToken[]): SqlRiskLevel {
+  const name = tokens.find((token, index) => index > 0 && /^[a-z_]/i.test(token.text))?.normalized;
+  if (name && SAFE_READ_PRAGMA_NAMES.has(name) && !tokens.some((token) => token.text === "=")) return "read";
+  return "write";
+}
+
+function highestRiskInTokens(tokens: SqlRiskToken[]): SqlRiskLevel | undefined {
+  let result: SqlRiskLevel | undefined;
+  for (const token of tokens) {
+    const risk = WRITE_KEYWORDS.has(token.normalized) ? "write" : DDL_KEYWORDS.has(token.normalized) ? "ddl" : TRANSACTION_KEYWORDS.has(token.normalized) ? "transaction" : undefined;
+    if (risk && (!result || RISK_ORDER[risk] > RISK_ORDER[result])) result = risk;
+  }
+  return result;
+}
+
+function hasTopLevelSelectInto(tokens: SqlRiskToken[]): boolean {
+  let depth = 0;
+  for (const token of tokens) {
+    if (token.text === "(") depth += 1;
+    if (token.text === ")") depth = Math.max(0, depth - 1);
+    if (depth !== 0) continue;
+    if (token.normalized === "into") return true;
+  }
+  return false;
+}
+
+function trimWrappingParentheses(tokens: SqlRiskToken[]): SqlRiskToken[] {
+  let start = 0;
+  let end = tokens.length;
+  while (tokens[start]?.text === "(" && matchingParenIndex(tokens, start) === end - 1) {
+    start += 1;
+    end -= 1;
+  }
+  return tokens.slice(start, end);
+}
+
+function matchingParenIndex(tokens: readonly SqlRiskToken[], openIndex: number): number {
+  let depth = 0;
+  for (let index = openIndex; index < tokens.length; index += 1) {
+    if (tokens[index]?.text === "(") depth += 1;
+    if (tokens[index]?.text === ")") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+}
+
+function mysqlExecutableCommentPrefixLength(sql: string, index: number): number {
+  if (sql[index] !== "/" || sql[index + 1] !== "*") return 0;
+  if (sql[index + 2] === "!") return 3;
+  if (sql[index + 2] === "M" && sql[index + 3] === "!") return 4;
+  return 0;
+}
+
+function skipExecutableCommentVersion(sql: string, index: number): number {
+  let cursor = index;
+  while (cursor < sql.length && /[0-9\s]/.test(sql[cursor] ?? "")) cursor += 1;
+  return cursor;
+}
+
+function dollarQuoteTagAt(sql: string, index: number): string | undefined {
+  return sql.slice(index).match(/^\$[A-Za-z_][A-Za-z0-9_]*\$|^\$\$/)?.[0];
+}
+
+function readQuotedEnd(sql: string, start: number, open: string, close: string): number {
+  let index = start + open.length;
+  while (index < sql.length) {
+    if (sql[index] === "\\" && (open === "'" || open === '"')) {
+      index += 2;
+      continue;
+    }
+    if (sql.startsWith(close, index)) {
+      if (sql.startsWith(close + close, index)) {
+        index += close.length * 2;
+        continue;
+      }
+      return index + close.length;
+    }
+    index += 1;
+  }
+  return sql.length;
+}
+
+function unquoteIdentifier(value: string, open: string, close: string): string {
+  if (!value.startsWith(open) || !value.endsWith(close)) return value;
+  return value.slice(open.length, value.length - close.length).replaceAll(close + close, close);
+}
diff --git a/packages/node-core/src/sql-safety.ts b/packages/node-core/src/sql-safety.ts
new file mode 100644
index 0000000..782b6cc
--- /dev/null
+++ b/packages/node-core/src/sql-safety.ts
@@ -0,0 +1,85 @@
+import { classifySqlStatementRisk, splitSqlStatementsForSafety, sqlSafetyText } from "./sql-risk.js";
+
+export interface SqlSafetyOptions {
+  allowWrites?: boolean;
+  allowDangerous?: boolean;
+  allowMultipleStatements?: boolean;
+}
+
+export interface SqlSafetyDecision {
+  allowed: boolean;
+  reason?: string;
+}
+
+const DANGEROUS_RISKS = new Set(["ddl", "transaction", "unknown"]);
+
+function parseBooleanEnv(value: string | undefined): boolean | undefined {
+  if (value === undefined) return undefined;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "1" || normalized === "true") return true;
+  if (normalized === "0" || normalized === "false") return false;
+  return undefined;
+}
+
+export function evaluateSqlSafety(sql: string, options: SqlSafetyOptions = {}): SqlSafetyDecision {
+  const statements = splitSqlStatementsForSafety(sql);
+  if (statements.length === 0) return { allowed: false, reason: "SQL is empty." };
+  if (statements.length > 1 && !options.allowMultipleStatements) {
+    return { allowed: false, reason: "Only one SQL statement is allowed per query." };
+  }
+
+  for (let i = 0; i < statements.length; i++) {
+    const decision = evaluateSingleSqlStatementSafety(statements[i], options);
+    if (!decision.allowed && statements.length > 1) {
+      return {
+        allowed: false,
+        reason: `Statement ${i + 1}: ${decision.reason ?? "SQL blocked."}`,
+      };
+    }
+    if (!decision.allowed) return decision;
+  }
+
+  return { allowed: true };
+}
+
+function evaluateSingleSqlStatementSafety(sql: string, options: SqlSafetyOptions = {}): SqlSafetyDecision {
+  const assessment = classifySqlStatementRisk(sql);
+  const firstKeyword = assessment.firstKeyword;
+  if (!firstKeyword) return { allowed: false, reason: "SQL statement is not recognized." };
+
+  if (DANGEROUS_RISKS.has(assessment.risk) && !options.allowDangerous) {
+    return { allowed: false, reason: `Dangerous SQL or unrecognized SQL statement "${firstKeyword.toUpperCase()}" is blocked.` };
+  }
+
+  if (!options.allowWrites && assessment.risk !== "read") {
+    return {
+      allowed: false,
+      reason: "MCP SQL execution is read-only for this session. Set DBX_MCP_ALLOW_WRITES=1 to allow write statements.",
+    };
+  }
+
+  if (options.allowWrites && !options.allowDangerous) {
+    const tokens: string[] = sqlSafetyText(sql).toLowerCase().match(/[a-z_]+/g) ?? [];
+    if (firstKeyword === "update" && !tokens.includes("where")) {
+      return { allowed: false, reason: "UPDATE statements must include a WHERE clause." };
+    }
+    if (firstKeyword === "delete" && !tokens.includes("where")) {
+      return { allowed: false, reason: "DELETE statements must include a WHERE clause." };
+    }
+  }
+
+  return { allowed: true };
+}
+
+export function sqlSafetyFromEnv(env: NodeJS.ProcessEnv = process.env): SqlSafetyOptions {
+  const allowWrites = parseBooleanEnv(env.DBX_MCP_ALLOW_WRITES);
+  const allowDangerous = parseBooleanEnv(env.DBX_MCP_ALLOW_DANGEROUS_SQL);
+  return {
+    allowWrites: allowWrites ?? true,
+    allowDangerous: allowDangerous ?? false,
+  };
+}
+
+export function splitSqlStatements(sql: string): string[] {
+  return splitSqlStatementsForSafety(sql);
+}
diff --git a/packages/node-core/src/web-backend.ts b/packages/node-core/src/web-backend.ts
new file mode 100644
index 0000000..e3968ee
--- /dev/null
+++ b/packages/node-core/src/web-backend.ts
@@ -0,0 +1,435 @@
+import type { ConnectionConfig } from "./connections.js";
+import type { TableInfo, ColumnInfo, QueryOptions, QueryResult } from "./database.js";
+import {
+  collectionListToTableInfos,
+  evaluateMongoAggregateSafety,
+  evaluateMongoWriteSafety,
+  inferMongoColumns,
+  mongoCollectionStatsToQueryResult,
+  mongoDocumentsToQueryResult,
+  parseMongoAggregateCommand,
+  parseMongoCollectionStatsCommand,
+  parseMongoCountDocumentsCommand,
+  parseMongoFindCommand,
+  parseMongoGetIndexesCommand,
+  parseMongoVersionCommand,
+  parseMongoWriteCommand,
+  type CollectionInfo,
+  type MongoWriteCommand,
+} from "./database.js";
+import type { RedisCommandOptions, RedisCommandResult } from "./redis-command.js";
+import { sqlSafetyFromEnv } from "./sql-safety.js";
+
+let sessionCookie: string | null = null;
+let authChecked = false;
+
+interface AuthCheckResponse {
+  authenticated: boolean;
+  required: boolean;
+  setup_required: boolean;
+}
+
+function baseUrl(): string {
+  return process.env.DBX_WEB_URL!.replace(/\/+$/, "");
+}
+
+function webPassword(): string {
+  return process.env.DBX_WEB_PASSWORD || "";
+}
+
+function extractSessionCookie(setCookie: string | null): string | null {
+  const match = setCookie?.match(/dbx_session=([^;]+)/);
+  return match?.[1] ?? null;
+}
+
+async function checkAuth(): Promise<AuthCheckResponse> {
+  const res = await fetch(`${baseUrl()}/api/auth/check`, {
+    method: "GET",
+    redirect: "manual",
+  });
+  if (!res.ok) {
+    throw new Error(`Authentication check failed: ${res.status} ${res.statusText}`);
+  }
+  return (await res.json()) as AuthCheckResponse;
+}
+
+async function ensureAuth(): Promise<void> {
+  if (sessionCookie) return;
+  if (authChecked) return;
+
+  const auth = await checkAuth();
+  if (auth.setup_required) {
+    throw new Error("DBX Web password setup is required before MCP Web mode can access APIs.");
+  }
+  if (!auth.required || auth.authenticated) {
+    authChecked = true;
+    return;
+  }
+
+  const password = webPassword();
+  if (!password) {
+    throw new Error("DBX Web authentication is required. Set DBX_WEB_PASSWORD for MCP Web mode.");
+  }
+
+  const res = await fetch(`${baseUrl()}/api/auth/login`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ password }),
+    redirect: "manual",
+  });
+
+  if (!res.ok) {
+    throw new Error(`Authentication failed: ${res.status} ${res.statusText}`);
+  }
+
+  sessionCookie = extractSessionCookie(res.headers.get("set-cookie"));
+  if (!sessionCookie) {
+    throw new Error("Authentication failed: DBX Web did not return a session cookie.");
+  }
+  authChecked = true;
+}
+
+function headers(extra?: Record<string, string>): Record<string, string> {
+  const h: Record<string, string> = { "Content-Type": "application/json", ...extra };
+  if (sessionCookie) {
+    h["Cookie"] = `dbx_session=${sessionCookie}`;
+  }
+  return h;
+}
+
+async function apiFetch(path: string, init?: RequestInit): Promise<Response> {
+  await ensureAuth();
+  let res = await fetch(`${baseUrl()}${path}`, {
+    ...init,
+    headers: headers(init?.headers as Record<string, string> | undefined),
+  });
+  if (res.status === 401 && sessionCookie && webPassword()) {
+    sessionCookie = null;
+    authChecked = false;
+    await ensureAuth();
+    res = await fetch(`${baseUrl()}${path}`, {
+      ...init,
+      headers: headers(init?.headers as Record<string, string> | undefined),
+    });
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`API request ${path} failed: ${res.status} ${res.statusText} ${body}`);
+  }
+  return res;
+}
+
+export function resetWebAuthForTests(): void {
+  sessionCookie = null;
+  authChecked = false;
+}
+
+export async function loadConnections(): Promise<ConnectionConfig[]> {
+  const res = await apiFetch("/api/connection/list");
+  return res.json();
+}
+
+export async function findConnection(name: string): Promise<ConnectionConfig | undefined> {
+  const connections = await loadConnections();
+  return connections.find((c) => c.name.toLowerCase() === name.toLowerCase());
+}
+
+export async function addConnection(config: Omit<ConnectionConfig, "id">): Promise<ConnectionConfig> {
+  const res = await apiFetch("/api/connection/save", {
+    method: "POST",
+    body: JSON.stringify({ configs: [config] }),
+  });
+  const saved = (await res.json()) as ConnectionConfig;
+  return saved;
+}
+
+export async function removeConnection(name: string): Promise<boolean> {
+  const connection = await findConnection(name);
+  if (!connection) return false;
+  await apiFetch(`/api/connection/delete?id=${encodeURIComponent(connection.id)}`, { method: "DELETE" });
+  return true;
+}
+
+export async function removeConnectionById(id: string): Promise<boolean> {
+  const connection = await loadConnections().then((cs) => cs.find((c) => c.id === id));
+  if (!connection) return false;
+  await apiFetch(`/api/connection/delete?id=${encodeURIComponent(id)}`, { method: "DELETE" });
+  return true;
+}
+
+async function ensureConnected(config: ConnectionConfig): Promise<void> {
+  await apiFetch("/api/connection/connect", {
+    method: "POST",
+    body: JSON.stringify({ config }),
+  });
+}
+
+export async function listTables(config: ConnectionConfig, schema?: string): Promise<TableInfo[]> {
+  await ensureConnected(config);
+  if (config.db_type === "mongodb") {
+    const res = await apiFetch("/api/mongo/list-collections", {
+      method: "POST",
+      body: JSON.stringify({ connectionId: config.id, database: config.database || "" }),
+    });
+    const collections = (await res.json()) as Array<string | CollectionInfo>;
+    return collectionListToTableInfos(collections);
+  }
+  const params = new URLSearchParams({
+    connection_id: config.id,
+    database: config.database || "",
+    schema: schema || "",
+  });
+  const res = await apiFetch(`/api/schema/tables?${params}`);
+  return res.json();
+}
+
+export async function describeTable(config: ConnectionConfig, table: string, schema?: string): Promise<ColumnInfo[]> {
+  await ensureConnected(config);
+  if (config.db_type === "mongodb") {
+    const res = await apiFetch("/api/mongo/find-documents", {
+      method: "POST",
+      body: JSON.stringify({ connectionId: config.id, database: config.database || "", collection: table, skip: 0, limit: 20, filter: "{}" }),
+    });
+    const result = (await res.json()) as { documents: unknown[]; total: number };
+    return inferMongoColumns(result.documents);
+  }
+  const params = new URLSearchParams({
+    connection_id: config.id,
+    database: config.database || "",
+    schema: schema || "",
+    table,
+  });
+  const res = await apiFetch(`/api/schema/columns?${params}`);
+  return res.json();
+}
+
+export async function executeQuery(config: ConnectionConfig, sql: string, options?: QueryOptions): Promise<QueryResult> {
+  await ensureConnected(config);
+  if (config.db_type === "mongodb") {
+    if (parseMongoVersionCommand(sql)) {
+      const res = await apiFetch("/api/mongo/server-version", {
+        method: "POST",
+        body: JSON.stringify({
+          connectionId: config.id,
+          database: config.database || "",
+        }),
+      });
+      const version = (await res.json()) as string;
+      return { columns: ["version"], rows: [{ version }], row_count: 1 };
+    }
+    const count = parseMongoCountDocumentsCommand(sql);
+    if (count) {
+      const res = await apiFetch("/api/mongo/find-documents", {
+        method: "POST",
+        body: JSON.stringify({
+          connectionId: config.id,
+          database: config.database || "",
+          collection: count.collection,
+          skip: 0,
+          limit: 1,
+          filter: count.filter,
+        }),
+      });
+      const result = (await res.json()) as { documents: unknown[]; total: number };
+      return { columns: ["count"], rows: [{ count: result.total }], row_count: 1 };
+    }
+    const find = parseMongoFindCommand(sql);
+    if (find) {
+      const res = await apiFetch("/api/mongo/find-documents", {
+        method: "POST",
+        body: JSON.stringify({
+          connectionId: config.id,
+          database: config.database || "",
+          collection: find.collection,
+          skip: find.skip,
+          limit: find.limit,
+          filter: find.filter,
+          projection: find.projection,
+          sort: find.sort,
+        }),
+      });
+      const result = (await res.json()) as { documents: unknown[]; total: number };
+      return mongoDocumentsToQueryResult(result.documents.slice(0, options?.maxRows ?? result.documents.length), result.total);
+    }
+    const aggregate = parseMongoAggregateCommand(sql);
+    if (aggregate) {
+      const safety = evaluateMongoAggregateSafety(aggregate, sqlSafetyFromEnv());
+      if (!safety.allowed) throw new Error(safety.reason);
+      const res = await apiFetch("/api/mongo/aggregate-documents", {
+        method: "POST",
+        body: JSON.stringify({
+          connectionId: config.id,
+          database: config.database || "",
+          collection: aggregate.collection,
+          pipelineJson: aggregate.pipeline,
+          maxRows: options?.maxRows ?? 100,
+        }),
+      });
+      const result = (await res.json()) as { documents: unknown[]; total: number };
+      return mongoDocumentsToQueryResult(result.documents.slice(0, options?.maxRows ?? result.documents.length), result.total);
+    }
+    const getIndexes = parseMongoGetIndexesCommand(sql);
+    if (getIndexes) {
+      const res = await apiFetch("/api/mongo/aggregate-documents", {
+        method: "POST",
+        body: JSON.stringify({
+          connectionId: config.id,
+          database: config.database || "",
+          collection: getIndexes.collection,
+          pipelineJson: '[{"$indexStats":{}}]',
+          maxRows: options?.maxRows ?? 100,
+        }),
+      });
+      const result = (await res.json()) as { documents: unknown[]; total: number };
+      return mongoDocumentsToQueryResult(result.documents.slice(0, options?.maxRows ?? result.documents.length), result.total);
+    }
+    const collectionStats = parseMongoCollectionStatsCommand(sql);
+    if (collectionStats) {
+      const res = await apiFetch("/api/mongo/collection-stats", {
+        method: "POST",
+        body: JSON.stringify({
+          connectionId: config.id,
+          database: config.database || "",
+          collection: collectionStats.collection,
+          scale: collectionStats.scale,
+        }),
+      });
+      const result = (await res.json()) as Record<string, unknown>;
+      return mongoCollectionStatsToQueryResult(collectionStats.metric, result);
+    }
+    const write = parseMongoWriteCommand(sql);
+    if (write) {
+      const safety = evaluateMongoWriteSafety(write, sqlSafetyFromEnv());
+      if (!safety.allowed) throw new Error(safety.reason);
+      const result = await executeMongoWrite(config, write);
+      if (write.kind === "createIndex") {
+        return { columns: ["name"], rows: [{ name: result.indexName ?? "" }], row_count: 1 };
+      }
+      if (write.kind === "dropIndex" || write.kind === "dropIndexes") {
+        return { columns: ["name"], rows: (result.droppedNames ?? []).map((name) => ({ name })), row_count: result.affectedRows };
+      }
+      return { columns: [], rows: [], row_count: result.affectedRows };
+    }
+    throw new Error(
+      'Use MongoDB shell-style commands, for example: db.projects.find({}).limit(100), db.version(), db.projects.countDocuments({}), db.projects.count({}), db.projects.getIndexes(), db.projects.dataSize(), db.projects.storageSize(1024), db.projects.totalIndexSize(), db.projects.stats(), db.projects.createIndex({...}), db.projects.dropIndex("name"), db.projects.dropIndexes(), db.projects.drop(), db.projects.insertOne({...}), db.projects.updateOne({...}, {$set: {...}}), or db.projects.deleteOne({...})',
+    );
+  }
+  const res = await apiFetch("/api/query/execute", {
+    method: "POST",
+    body: JSON.stringify({
+      connectionId: config.id,
+      database: config.database || "",
+      sql,
+    }),
+  });
+  const data = (await res.json()) as { columns: string[]; rows: unknown[][] };
+  const rows = data.rows.map((row: unknown[]) => {
+    const obj: Record<string, unknown> = {};
+    data.columns.forEach((col: string, i: number) => {
+      obj[col] = row[i];
+    });
+    return obj;
+  });
+  const limitedRows = rows.slice(0, options?.maxRows ?? rows.length);
+  return { columns: data.columns, rows: limitedRows, row_count: limitedRows.length };
+}
+
+export async function executeRedisCommand(config: ConnectionConfig, db: number, command: string, options?: RedisCommandOptions): Promise<RedisCommandResult> {
+  if (config.db_type !== "redis") {
+    throw new Error("Connection is not Redis.");
+  }
+  await ensureConnected(config);
+  const res = await apiFetch("/api/redis/execute-command", {
+    method: "POST",
+    body: JSON.stringify({
+      connectionId: config.id,
+      db,
+      command,
+      skipSafetyCheck: options?.skipSafetyCheck ?? false,
+    }),
+  });
+  return (await res.json()) as RedisCommandResult;
+}
+
+async function executeMongoWrite(config: ConnectionConfig, command: MongoWriteCommand): Promise<{ affectedRows: number; indexName?: string; droppedNames?: string[] }> {
+  if (command.kind === "insert") {
+    const res = await apiFetch("/api/mongo/insert-documents", {
+      method: "POST",
+      body: JSON.stringify({
+        connectionId: config.id,
+        database: config.database || "",
+        collection: command.collection,
+        docsJson: command.docsJson,
+      }),
+    });
+    const result = (await res.json()) as { affected_rows: number };
+    return { affectedRows: result.affected_rows };
+  }
+  if (command.kind === "update") {
+    const res = await apiFetch("/api/mongo/update-documents", {
+      method: "POST",
+      body: JSON.stringify({
+        connectionId: config.id,
+        database: config.database || "",
+        collection: command.collection,
+        filterJson: command.filter,
+        updateJson: command.update,
+        many: command.many,
+        optionsJson: command.options,
+      }),
+    });
+    const result = (await res.json()) as { affected_rows: number };
+    return { affectedRows: result.affected_rows };
+  }
+  if (command.kind === "createIndex") {
+    const res = await apiFetch("/api/mongo/create-index", {
+      method: "POST",
+      body: JSON.stringify({
+        connectionId: config.id,
+        database: config.database || "",
+        collection: command.collection,
+        keysJson: command.keys,
+        optionsJson: command.options,
+      }),
+    });
+    const result = (await res.json()) as { name: string };
+    return { affectedRows: 1, indexName: result.name };
+  }
+  if (command.kind === "dropIndex" || command.kind === "dropIndexes") {
+    const res = await apiFetch("/api/mongo/drop-indexes", {
+      method: "POST",
+      body: JSON.stringify({
+        connectionId: config.id,
+        database: config.database || "",
+        collection: command.collection,
+        indexesJson: command.kind === "dropIndex" ? command.index : command.indexes,
+        single: command.kind === "dropIndex",
+      }),
+    });
+    const result = (await res.json()) as { dropped_names: string[]; affected_rows: number };
+    return { affectedRows: result.affected_rows, droppedNames: result.dropped_names };
+  }
+  if (command.kind === "dropCollection") {
+    await apiFetch("/api/mongo/drop-collection", {
+      method: "POST",
+      body: JSON.stringify({
+        connectionId: config.id,
+        database: config.database || "",
+        collection: command.collection,
+      }),
+    });
+    return { affectedRows: 1 };
+  }
+  const res = await apiFetch("/api/mongo/delete-documents", {
+    method: "POST",
+    body: JSON.stringify({
+      connectionId: config.id,
+      database: config.database || "",
+      collection: command.collection,
+      filterJson: command.filter,
+      many: command.many,
+    }),
+  });
+  const result = (await res.json()) as { affected_rows: number };
+  return { affectedRows: result.affected_rows };
+}
diff --git a/packages/node-core/tests/collections.test.ts b/packages/node-core/tests/collections.test.ts
new file mode 100644
index 0000000..1f78568
--- /dev/null
+++ b/packages/node-core/tests/collections.test.ts
@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { collectionListToTableInfos } from "../src/database.js";
+
+test("maps legacy collection name responses to table infos", () => {
+  assert.deepEqual(collectionListToTableInfos(["projects", "users"]), [
+    { name: "projects", type: "COLLECTION" },
+    { name: "users", type: "COLLECTION" },
+  ]);
+});
+
+test("maps collection info responses to table infos", () => {
+  assert.deepEqual(
+    collectionListToTableInfos([
+      { name: "projects", id: "projects", dimension: null },
+      { name: "embeddings", id: "uuid-123", dimension: 384 },
+    ]),
+    [
+      { name: "projects", type: "COLLECTION" },
+      { name: "embeddings", type: "COLLECTION" },
+    ],
+  );
+});
diff --git a/packages/node-core/tests/connection-store.test.ts b/packages/node-core/tests/connection-store.test.ts
new file mode 100644
index 0000000..77aaf94
--- /dev/null
+++ b/packages/node-core/tests/connection-store.test.ts
@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "vitest";
+import Database from "better-sqlite3";
+import { inspectConnectionStore, loadConnections } from "../src/connections.js";
+
+test("connection store diagnostics report rows even when loading fails", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "dbx-store-"));
+  const path = join(dir, "dbx.db");
+
+  try {
+    const db = new Database(path);
+    db.exec(`
+      CREATE TABLE connections (id TEXT PRIMARY KEY, config_json TEXT NOT NULL);
+      CREATE TABLE connection_secrets (connection_id TEXT, key TEXT, secret TEXT);
+    `);
+    db.prepare("INSERT INTO connections (id, config_json) VALUES (?, ?)").run("broken", "{not json");
+    db.close();
+
+    await assert.rejects(() => loadConnections({ path }), /Failed to load DBX connections/);
+
+    const diagnostics = await inspectConnectionStore({ path });
+    assert.equal(diagnostics.dbPath, path);
+    assert.equal(diagnostics.dbPathExists, true);
+    assert.equal(diagnostics.connectionsTableExists, true);
+    assert.equal(diagnostics.connectionRowCount, 1);
+    assert.equal(diagnostics.loadConnectionsOk, false);
+    assert.match(diagnostics.loadConnectionsError ?? "", /Failed to load DBX connections/);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("missing connection store is treated as an empty store", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "dbx-store-"));
+  const path = join(dir, "missing.db");
+
+  try {
+    assert.deepEqual(await loadConnections({ path }), []);
+
+    const diagnostics = await inspectConnectionStore({ path });
+    assert.equal(diagnostics.dbPathExists, false);
+    assert.equal(diagnostics.connectionsTableExists, false);
+    assert.equal(diagnostics.connectionRowCount, 0);
+    assert.equal(diagnostics.loadConnectionsOk, true);
+    assert.equal(diagnostics.loadedConnectionCount, 0);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
diff --git a/packages/node-core/tests/describe-table.test.ts b/packages/node-core/tests/describe-table.test.ts
new file mode 100644
index 0000000..bd35d65
--- /dev/null
+++ b/packages/node-core/tests/describe-table.test.ts
@@ -0,0 +1,295 @@
+import assert from "node:assert/strict";
+import { afterEach, test, vi } from "vitest";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ConnectionConfig } from "../src/connections.js";
+
+const fakeMysqlQuery = vi.fn();
+const fakeMysqlEnd = vi.fn().mockResolvedValue(undefined);
+const fakePgQuery = vi.fn();
+const fakePgEnd = vi.fn().mockResolvedValue(undefined);
+const fakePgOn = vi.fn();
+
+vi.mock("mysql2/promise", () => ({
+  default: {
+    createPool: vi.fn(() => ({
+      query: fakeMysqlQuery,
+      end: fakeMysqlEnd,
+    })),
+  },
+}));
+
+vi.mock("pg", () => ({
+  default: {
+    Pool: vi.fn(function MockPool() {
+      return {
+        query: fakePgQuery,
+        end: fakePgEnd,
+        on: fakePgOn,
+      };
+    }),
+  },
+}));
+
+import { closeDatabaseResources, describeTable } from "../src/database.js";
+
+function mysqlConfig(): ConnectionConfig {
+  return {
+    id: "mysql-direct-test",
+    name: "mysql-direct",
+    db_type: "mysql",
+    host: "127.0.0.1",
+    port: 3306,
+    username: "root",
+    password: "secret",
+    database: "app",
+    ssl: false,
+  };
+}
+
+function postgresConfig(): ConnectionConfig {
+  return {
+    id: "postgres-direct-test",
+    name: "postgres-direct",
+    db_type: "postgres",
+    host: "127.0.0.1",
+    port: 5432,
+    username: "postgres",
+    password: "postgres",
+    database: "app",
+    ssl: false,
+  };
+}
+
+const bridgeConfig: ConnectionConfig = {
+  id: "pg-bridge",
+  name: "bridge-postgres",
+  db_type: "postgres",
+  host: "127.0.0.1",
+  port: 5432,
+  username: "postgres",
+  password: "postgres",
+  database: "postgres",
+  ssl: false,
+  transport_layers: [
+    {
+      type: "ssh",
+      id: "jump",
+      enabled: true,
+      host: "bastion.internal",
+      port: 22,
+      user: "dbx",
+    },
+  ],
+};
+
+afterEach(async () => {
+  await closeDatabaseResources();
+  fakeMysqlQuery.mockReset();
+  fakeMysqlEnd.mockClear();
+  fakePgQuery.mockReset();
+  fakePgEnd.mockClear();
+  fakePgOn.mockClear();
+});
+
+test("describeTable maps mysql enum_values from metadata", async () => {
+  fakeMysqlQuery.mockResolvedValue([
+    [
+      {
+        name: "state",
+        data_type: "enum",
+        column_type: "enum('pending','active','archived')",
+        is_nullable: 0,
+        column_default: "pending",
+        is_primary_key: 0,
+        comment: "workflow state",
+      },
+    ],
+    [{ name: "name" }],
+  ]);
+
+  const columns = await describeTable(mysqlConfig(), "orders");
+
+  assert.match(String(fakeMysqlQuery.mock.calls[0]?.[0] ?? ""), /COLUMN_TYPE AS column_type/);
+  assert.deepEqual(fakeMysqlQuery.mock.calls[0]?.[1], ["orders"]);
+  assert.deepEqual(columns, [
+    {
+      name: "state",
+      data_type: "enum",
+      is_nullable: false,
+      column_default: "pending",
+      is_primary_key: false,
+      comment: "workflow state",
+      enum_values: ["pending", "active", "archived"],
+    },
+  ]);
+});
+
+test("describeTable parses mysql enum literal edge cases", async () => {
+  fakeMysqlQuery.mockResolvedValue([
+    [
+      {
+        name: "empty_state",
+        data_type: "enum",
+        column_type: "enum('','a')",
+        is_nullable: 1,
+        column_default: null,
+        is_primary_key: 0,
+        comment: null,
+      },
+      {
+        name: "quoted_state",
+        data_type: "enum",
+        column_type: "enum('x'',''y','z')",
+        is_nullable: 1,
+        column_default: null,
+        is_primary_key: 0,
+        comment: null,
+      },
+      {
+        name: "escaped_state",
+        data_type: "enum",
+        column_type: String.raw`enum('it''s','quote\"d','back\\slash')`,
+        is_nullable: 1,
+        column_default: null,
+        is_primary_key: 0,
+        comment: null,
+      },
+    ],
+    [{ name: "name" }],
+  ]);
+
+  const columns = await describeTable(mysqlConfig(), "orders");
+
+  assert.deepEqual(
+    columns.map((column) => column.enum_values),
+    [
+      ["", "a"],
+      ["x','y", "z"],
+      ["it's", 'quote"d', "back\\slash"],
+    ],
+  );
+});
+
+test("describeTable preserves enum values from bridge metadata", async () => {
+  const tempDir = await mkdtemp(join(tmpdir(), "dbx-node-core-"));
+  const previousDataDir = process.env.DBX_DATA_DIR;
+
+  const server = createServer((req, res) => {
+    assert.equal(req.url, "/data/describe-table");
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(
+      JSON.stringify([
+        {
+          name: "state",
+          data_type: "status",
+          is_nullable: false,
+          column_default: null,
+          is_primary_key: false,
+          comment: "workflow state",
+          enum_values: ["pending", "active", "archived"],
+        },
+      ]),
+    );
+  });
+
+  try {
+    await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
+    const address = server.address();
+    if (!address || typeof address === "string") throw new Error("expected TCP bridge address");
+
+    process.env.DBX_DATA_DIR = tempDir;
+    await writeFile(join(tempDir, "mcp-bridge-port"), String(address.port));
+
+    const columns = await describeTable(bridgeConfig, "orders", "public");
+
+    assert.deepEqual(columns, [
+      {
+        name: "state",
+        data_type: "status",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: false,
+        comment: "workflow state",
+        enum_values: ["pending", "active", "archived"],
+      },
+    ]);
+  } finally {
+    server.close();
+    if (previousDataDir === undefined) {
+      delete process.env.DBX_DATA_DIR;
+    } else {
+      process.env.DBX_DATA_DIR = previousDataDir;
+    }
+    await rm(tempDir, { recursive: true, force: true });
+  }
+});
+
+test("describeTable reads postgres enum_values from the primary metadata query", async () => {
+  fakePgQuery.mockResolvedValueOnce({
+    rows: [
+      {
+        name: "state",
+        data_type: "status",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: false,
+        comment: "workflow state",
+        enum_values: ["pending", "active", "archived"],
+      },
+    ],
+    fields: [{ name: "name" }],
+  });
+
+  const columns = await describeTable(postgresConfig(), "orders", "public");
+
+  assert.match(String(fakePgQuery.mock.calls[0]?.[0] ?? ""), /FROM pg_enum e WHERE e\.enumtypid = enum_t\.oid/);
+  assert.equal(fakePgQuery.mock.calls.length, 1);
+  assert.deepEqual(columns, [
+    {
+      name: "state",
+      data_type: "status",
+      is_nullable: false,
+      column_default: null,
+      is_primary_key: false,
+      comment: "workflow state",
+      enum_values: ["pending", "active", "archived"],
+    },
+  ]);
+});
+
+test("describeTable falls back to compat postgres metadata query when enum joins fail", async () => {
+  fakePgQuery.mockRejectedValueOnce(new Error("pg_enum catalog unavailable")).mockResolvedValueOnce({
+    rows: [
+      {
+        name: "state",
+        data_type: "status",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: false,
+        comment: "workflow state",
+        enum_values: null,
+      },
+    ],
+    fields: [{ name: "name" }],
+  });
+
+  const columns = await describeTable(postgresConfig(), "orders", "public");
+
+  assert.match(String(fakePgQuery.mock.calls[0]?.[0] ?? ""), /FROM pg_enum e WHERE e\.enumtypid = enum_t\.oid/);
+  assert.match(String(fakePgQuery.mock.calls[1]?.[0] ?? ""), /NULL AS enum_values/);
+  assert.doesNotMatch(String(fakePgQuery.mock.calls[1]?.[0] ?? ""), /pg_enum/);
+  assert.deepEqual(columns, [
+    {
+      name: "state",
+      data_type: "status",
+      is_nullable: false,
+      column_default: null,
+      is_primary_key: false,
+      comment: "workflow state",
+      enum_values: null,
+    },
+  ]);
+});
diff --git a/packages/node-core/tests/driver-manifest.test.ts b/packages/node-core/tests/driver-manifest.test.ts
new file mode 100644
index 0000000..4e95c69
--- /dev/null
+++ b/packages/node-core/tests/driver-manifest.test.ts
@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { test } from "vitest";
+import { BRIDGE_REQUIRED_TYPES, DIRECT_QUERY_TYPES, isDirectQueryType } from "../src/diagnostics.js";
+
+interface DriverManifest {
+  drivers: Array<{
+    dbType: string;
+    mcpMode: "direct" | "bridge" | "unsupported";
+    supportLevel: "connect" | "browse" | "understand" | "operate";
+    capabilities: Record<DatabaseProductCapability, boolean>;
+  }>;
+}
+
+const PRODUCT_CAPABILITY_KEYS = [
+  "queryExecution",
+  "metadataBrowse",
+  "objectBrowser",
+  "objectSource",
+  "schemaSearch",
+  "diagram",
+  "tableDataEdit",
+  "tableStructureEdit",
+  "tableImport",
+  "dataTransfer",
+  "sqlFileExecution",
+  "databaseCreate",
+  "fieldLineage",
+  "sqlExplain",
+  "userAdmin",
+  "driverManagement",
+] as const;
+type DatabaseProductCapability = (typeof PRODUCT_CAPABILITY_KEYS)[number];
+
+function loadManifest(): DriverManifest {
+  const path = fileURLToPath(new URL("../../../crates/dbx-core/assets/database-drivers.manifest.json", import.meta.url));
+  return JSON.parse(readFileSync(path, "utf8")) as DriverManifest;
+}
+
+test("diagnostic query mode lists match the driver manifest", () => {
+  const manifest = loadManifest();
+  const directTypes = manifest.drivers.filter((driver) => driver.mcpMode === "direct").map((driver) => driver.dbType);
+  const bridgeTypes = manifest.drivers.filter((driver) => driver.mcpMode === "bridge").map((driver) => driver.dbType);
+
+  assert.deepEqual([...DIRECT_QUERY_TYPES].sort(), directTypes.sort());
+  assert.deepEqual([...BRIDGE_REQUIRED_TYPES].sort(), bridgeTypes.sort());
+});
+
+test("runtime direct query routing matches diagnostic direct query types", () => {
+  for (const dbType of DIRECT_QUERY_TYPES) {
+    assert.equal(isDirectQueryType(dbType), true, `${dbType} should use direct query routing`);
+  }
+
+  for (const dbType of BRIDGE_REQUIRED_TYPES) {
+    assert.equal(isDirectQueryType(dbType), false, `${dbType} should not use direct query routing`);
+  }
+});
+
+test("Manticore Search is direct-query capable", () => {
+  assert.equal(isDirectQueryType("manticoresearch"), true);
+  assert.equal(DIRECT_QUERY_TYPES.includes("manticoresearch" as any), true);
+});
+
+test("GaussDB family requires the DBX Desktop bridge for MCP", () => {
+  for (const dbType of ["gaussdb", "opengauss"] as const) {
+    assert.equal(isDirectQueryType(dbType), false);
+    assert.equal(DIRECT_QUERY_TYPES.includes(dbType as any), false);
+    assert.equal(BRIDGE_REQUIRED_TYPES.includes(dbType as any), true);
+  }
+});
+
+test("driver manifest declares support levels and product capabilities", () => {
+  const manifest = loadManifest();
+
+  for (const driver of manifest.drivers) {
+    assert.match(driver.supportLevel, /^(connect|browse|understand|operate)$/);
+    for (const key of PRODUCT_CAPABILITY_KEYS) {
+      assert.equal(typeof driver.capabilities[key], "boolean", `${driver.dbType}.${key} should be a boolean`);
+    }
+    assert.equal(Object.keys(driver.capabilities).sort().join(","), [...PRODUCT_CAPABILITY_KEYS].sort().join(","));
+  }
+
+  const jdbc = manifest.drivers.find((driver) => driver.dbType === "jdbc");
+  assert.equal(jdbc?.supportLevel, "browse");
+  assert.equal(jdbc?.capabilities.metadataBrowse, true);
+  assert.equal(jdbc?.capabilities.tableStructureEdit, false);
+
+  const manticore = manifest.drivers.find((driver) => driver.dbType === "manticoresearch");
+  assert.equal(manticore?.supportLevel, "operate");
+  assert.equal(manticore?.capabilities.queryExecution, true);
+  assert.equal(manticore?.capabilities.metadataBrowse, true);
+  assert.equal(manticore?.capabilities.objectBrowser, false);
+  assert.equal(manticore?.capabilities.tableDataEdit, true);
+  assert.equal(manticore?.capabilities.tableStructureEdit, true);
+  assert.equal(manticore?.capabilities.databaseCreate, false);
+  assert.equal(manticore?.capabilities.userAdmin, false);
+});
diff --git a/packages/node-core/tests/entrypoint.test.ts b/packages/node-core/tests/entrypoint.test.ts
new file mode 100644
index 0000000..d624194
--- /dev/null
+++ b/packages/node-core/tests/entrypoint.test.ts
@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { test } from "vitest";
+import { isMainModule } from "../src/entrypoint.js";
+
+test("matches a module invoked through its real file path", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "dbx-entrypoint-"));
+  try {
+    const entry = join(dir, "cli.js");
+    await writeFile(entry, "", "utf-8");
+
+    assert.equal(isMainModule(pathToFileURL(entry).href, entry), true);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("matches a module invoked through an npm-style symlink", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "dbx-entrypoint-"));
+  try {
+    const entry = join(dir, "dist", "cli.js");
+    const bin = join(dir, "dbx");
+    await mkdir(join(dir, "dist"));
+    await writeFile(entry, "", "utf-8");
+    try {
+      await symlink(entry, bin);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EPERM") throw error;
+      return;
+    }
+
+    assert.equal(isMainModule(pathToFileURL(entry).href, bin), true);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("does not match a different entry file", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "dbx-entrypoint-"));
+  try {
+    const entry = join(dir, "cli.js");
+    const other = join(dir, "other.js");
+    await writeFile(entry, "", "utf-8");
+    await writeFile(other, "", "utf-8");
+
+    assert.equal(isMainModule(pathToFileURL(entry).href, other), false);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
diff --git a/packages/node-core/tests/format.test.ts b/packages/node-core/tests/format.test.ts
new file mode 100644
index 0000000..bfa21a4
--- /dev/null
+++ b/packages/node-core/tests/format.test.ts
@@ -0,0 +1,14 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { formatCell, mdTable } from "../src/format.js";
+
+test("formats markdown tables", () => {
+  assert.equal(mdTable(["Name", "Type"], [["local", "postgres"]]), "| Name  | Type     |\n| ----- | -------- |\n| local | postgres |");
+});
+
+test("formats database cell values", () => {
+  assert.equal(formatCell(null), "NULL");
+  assert.equal(formatCell(undefined), "NULL");
+  assert.equal(formatCell({ ok: true }), '{"ok":true}');
+  assert.equal(formatCell("hello"), "hello");
+});
diff --git a/packages/node-core/tests/mongo-query.test.ts b/packages/node-core/tests/mongo-query.test.ts
new file mode 100644
index 0000000..a7d0cce
--- /dev/null
+++ b/packages/node-core/tests/mongo-query.test.ts
@@ -0,0 +1,433 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import {
+  executeQuery,
+  inferMongoColumns,
+  mongoAggregateWriteStage,
+  mongoCollectionStatsToQueryResult,
+  mongoDocumentsToQueryResult,
+  parseMongoAggregateCommand,
+  parseMongoCollectionStatsCommand,
+  parseMongoCountDocumentsCommand,
+  parseMongoFindCommand,
+  parseMongoGetIndexesCommand,
+  parseMongoVersionCommand,
+  parseMongoWriteCommand,
+} from "../src/database.js";
+
+test("parseMongoFindCommand accepts shell-style find commands", () => {
+  assert.deepEqual(parseMongoFindCommand('db.getCollection("operation_logs").find({"level":"info"}).sort({"ts":-1}).skip(5).limit(10)'), {
+    collection: "operation_logs",
+    filter: '{"level":"info"}',
+    skip: 5,
+    limit: 10,
+    sort: '{"ts":-1}',
+  });
+});
+
+test("parseMongoFindCommand accepts line breaks before find and chained calls", () => {
+  const command = parseMongoFindCommand(`db.getCollection("operation_logs")
+.find({
+  "_id": ObjectId("68ad51ca84c8127bc7d44cb3")
+})
+.sort({ ts: -1 })
+.skip(5)
+.limit(10)`);
+  assert.ok(command);
+  assert.equal(command.collection, "operation_logs");
+  assert.deepEqual(JSON.parse(command.filter), { _id: { $oid: "68ad51ca84c8127bc7d44cb3" } });
+  assert.deepEqual(JSON.parse(command.sort || "{}"), { ts: -1 });
+  assert.equal(command.skip, 5);
+  assert.equal(command.limit, 10);
+});
+
+test("parseMongoFindCommand accepts Compass-style unquoted keys and ObjectId", () => {
+  const command = parseMongoFindCommand("db.products.find({_id: ObjectId('6a045a92d2971e44243771a1')}).limit(1)");
+  assert.ok(command);
+  assert.equal(command.collection, "products");
+  assert.equal(command.limit, 1);
+  assert.deepEqual(JSON.parse(command.filter), { _id: { $oid: "6a045a92d2971e44243771a1" } });
+});
+
+test("parseMongoFindCommand accepts projection arguments", () => {
+  const command = parseMongoFindCommand("db.jobs.find({status: 'open'}, {title: 1, _id: 0}).sort({title: 1})");
+  assert.ok(command);
+  assert.equal(command.collection, "jobs");
+  assert.deepEqual(JSON.parse(command.filter), { status: "open" });
+  assert.deepEqual(JSON.parse(command.projection || "{}"), { title: 1, _id: 0 });
+  assert.deepEqual(JSON.parse(command.sort || "{}"), { title: 1 });
+});
+
+test("parseMongoVersionCommand accepts db.version", () => {
+  assert.equal(parseMongoVersionCommand("db.version();"), true);
+  assert.equal(parseMongoVersionCommand("db.jobs.version()"), false);
+});
+
+test("parseMongoWriteCommand accepts unquoted update operator keys", () => {
+  assert.deepEqual(parseMongoWriteCommand("db.projects.updateOne({_id: ObjectId('507f1f77bcf86cd799439011')}, {$set: {name: 'next'}})"), {
+    kind: "update",
+    collection: "projects",
+    filter: '{"_id": {"$oid":"507f1f77bcf86cd799439011"}}',
+    update: '{"$set": {"name": "next"}}',
+    many: false,
+  });
+});
+
+test("parseMongoWriteCommand accepts updateMany arrayFilters options", () => {
+  assert.deepEqual(
+    parseMongoWriteCommand(
+      'db.orders.updateMany({status: "open"}, {$set: {"items.$[item].status": "done"}}, {arrayFilters: [{"item.id": 7}]})',
+    ),
+    {
+      kind: "update",
+      collection: "orders",
+      filter: '{"status": "open"}',
+      update: '{"$set": {"items.$[item].status": "done"}}',
+      options: '{"arrayFilters": [{"item.id": 7}]}',
+      many: true,
+    },
+  );
+});
+
+test("parseMongoCountDocumentsCommand accepts shell-style count commands", () => {
+  assert.deepEqual(parseMongoCountDocumentsCommand('db.projects.countDocuments({"active":true})'), {
+    collection: "projects",
+    filter: '{"active":true}',
+  });
+});
+
+test("parseMongoCountDocumentsCommand accepts legacy count helpers", () => {
+  assert.deepEqual(parseMongoCountDocumentsCommand("db.projects.count({ active: true })"), {
+    collection: "projects",
+    filter: '{ "active": true }',
+  });
+  assert.deepEqual(parseMongoCountDocumentsCommand('db.getCollection("audit.logs").count()'), {
+    collection: "audit.logs",
+    filter: "{}",
+  });
+  assert.deepEqual(parseMongoCountDocumentsCommand("db.projects.find({ active: true }).count()"), {
+    collection: "projects",
+    filter: '{ "active": true }',
+  });
+  assert.equal(parseMongoFindCommand("db.projects.find({ active: true }).count()"), null);
+});
+
+test("parseMongoAggregateCommand accepts aggregate pipelines", () => {
+  assert.deepEqual(parseMongoAggregateCommand('db.projects.aggregate([{"$match":{"active":true}},{"$group":{"_id":"$owner","total":{"$sum":1}}}])'), {
+    collection: "projects",
+    pipeline: '[{"$match":{"active":true}},{"$group":{"_id":"$owner","total":{"$sum":1}}}]',
+  });
+});
+
+test("parseMongoGetIndexesCommand accepts shell-style index commands", () => {
+  assert.deepEqual(parseMongoGetIndexesCommand("db.web_log.getIndexes();"), {
+    collection: "web_log",
+  });
+  assert.deepEqual(parseMongoGetIndexesCommand('db.getCollection("audit.logs").getIndexes()'), {
+    collection: "audit.logs",
+  });
+  assert.equal(parseMongoGetIndexesCommand("db.web_log.getIndexes({})"), null);
+});
+
+test("parseMongoCollectionStatsCommand accepts Mongo shell stats helpers", () => {
+  assert.deepEqual(parseMongoCollectionStatsCommand("db.users.dataSize()"), {
+    collection: "users",
+    metric: "dataSize",
+  });
+  assert.deepEqual(parseMongoCollectionStatsCommand('db.getCollection("audit.logs").dataSize(1024)'), {
+    collection: "audit.logs",
+    metric: "dataSize",
+    scale: 1024,
+  });
+  assert.deepEqual(parseMongoCollectionStatsCommand("db.users.storageSize(1024)"), {
+    collection: "users",
+    metric: "storageSize",
+    scale: 1024,
+  });
+  assert.deepEqual(parseMongoCollectionStatsCommand("db.users.totalIndexSize()"), {
+    collection: "users",
+    metric: "totalIndexSize",
+  });
+  assert.deepEqual(parseMongoCollectionStatsCommand("db.users.stats()"), {
+    collection: "users",
+    metric: "stats",
+  });
+  assert.deepEqual(parseMongoCollectionStatsCommand("db.users.stats(1024)"), {
+    collection: "users",
+    metric: "stats",
+    scale: 1024,
+  });
+});
+
+test("parseMongoCollectionStatsCommand rejects unsupported stats helper arguments", () => {
+  assert.equal(parseMongoCollectionStatsCommand("db.users.dataSize(1, 2)"), null);
+  assert.equal(parseMongoCollectionStatsCommand("db.users.storageSize({scale: 1024})"), null);
+  assert.equal(parseMongoCollectionStatsCommand("db.users.stats().limit(1)"), null);
+});
+
+test("mongoCollectionStatsToQueryResult maps dataSize helper to collStats size", () => {
+  assert.deepEqual(mongoCollectionStatsToQueryResult("dataSize", { size: 2048 }), {
+    columns: ["dataSize"],
+    rows: [{ dataSize: 2048 }],
+    row_count: 1,
+  });
+  assert.deepEqual(
+    mongoCollectionStatsToQueryResult("stats", {
+      count: 3,
+      size: 128,
+      storageSize: 512,
+      totalIndexSize: 64,
+    }),
+    {
+      columns: ["count", "size", "avgObjSize", "storageSize", "totalIndexSize", "nindexes"],
+      rows: [{ count: 3, size: 128, avgObjSize: null, storageSize: 512, totalIndexSize: 64, nindexes: null }],
+      row_count: 1,
+    },
+  );
+});
+
+test("mongoAggregateWriteStage detects write stages", () => {
+  assert.equal(mongoAggregateWriteStage('[{"$match":{"active":true}}]'), null);
+  assert.equal(mongoAggregateWriteStage('[{"$match":{}},{"$out":"projects_dump"}]'), "$out");
+  assert.equal(mongoAggregateWriteStage('[{"$merge":{"into":"projects_dump"}}]'), "$merge");
+});
+
+test("mongodb executeQuery blocks aggregate write stages until dangerous SQL is enabled", async () => {
+  const oldAllowWrites = process.env.DBX_MCP_ALLOW_WRITES;
+  const oldAllowDangerous = process.env.DBX_MCP_ALLOW_DANGEROUS_SQL;
+  delete process.env.DBX_MCP_ALLOW_WRITES;
+  delete process.env.DBX_MCP_ALLOW_DANGEROUS_SQL;
+  const config = {
+    id: "mongo",
+    name: "mongo",
+    db_type: "mongodb",
+    host: "127.0.0.1",
+    port: 27017,
+    username: "",
+    password: "",
+    database: "app",
+    ssh_enabled: false,
+    ssl: false,
+  } as const;
+
+  await assert.rejects(executeQuery(config, 'db.projects.aggregate([{"$merge":{"into":"projects_dump"}}])'), /DBX_MCP_ALLOW_DANGEROUS_SQL=1/);
+
+  if (oldAllowWrites === undefined) delete process.env.DBX_MCP_ALLOW_WRITES;
+  else process.env.DBX_MCP_ALLOW_WRITES = oldAllowWrites;
+  if (oldAllowDangerous === undefined) delete process.env.DBX_MCP_ALLOW_DANGEROUS_SQL;
+  else process.env.DBX_MCP_ALLOW_DANGEROUS_SQL = oldAllowDangerous;
+});
+
+test("parseMongoWriteCommand accepts supported write commands", () => {
+  assert.deepEqual(parseMongoWriteCommand('db.projects.insertOne({"name":"demo"})'), {
+    kind: "insert",
+    collection: "projects",
+    docsJson: '{"name":"demo"}',
+  });
+  assert.deepEqual(parseMongoWriteCommand('db.projects.updateOne({"_id":"1"},{"$set":{"name":"next"}})'), {
+    kind: "update",
+    collection: "projects",
+    filter: '{"_id":"1"}',
+    update: '{"$set":{"name":"next"}}',
+    many: false,
+  });
+  assert.deepEqual(parseMongoWriteCommand('db.projects.deleteMany({"stale":true})'), {
+    kind: "delete",
+    collection: "projects",
+    filter: '{"stale":true}',
+    many: true,
+  });
+  assert.deepEqual(parseMongoWriteCommand('db.projects.createIndex({"email":1},{"unique":true,"name":"projects_email_unique"})'), {
+    kind: "createIndex",
+    collection: "projects",
+    keys: '{"email":1}',
+    options: '{"unique":true,"name":"projects_email_unique"}',
+  });
+  assert.deepEqual(parseMongoWriteCommand('db.projects.dropIndex("projects_email_unique")'), {
+    kind: "dropIndex",
+    collection: "projects",
+    index: '"projects_email_unique"',
+  });
+  assert.deepEqual(parseMongoWriteCommand("db.projects.dropIndexes()"), {
+    kind: "dropIndexes",
+    collection: "projects",
+  });
+  assert.deepEqual(parseMongoWriteCommand('db.projects.dropIndexes({"email":1})'), {
+    kind: "dropIndexes",
+    collection: "projects",
+    indexes: '{"email":1}',
+  });
+  assert.deepEqual(parseMongoWriteCommand('db.projects.dropIndexes(["a_1","b_1"])'), {
+    kind: "dropIndexes",
+    collection: "projects",
+    indexes: '["a_1","b_1"]',
+  });
+  assert.deepEqual(parseMongoWriteCommand("db.projects.drop()"), {
+    kind: "dropCollection",
+    collection: "projects",
+  });
+  assert.deepEqual(parseMongoWriteCommand('db.getCollection("audit.logs").drop();'), {
+    kind: "dropCollection",
+    collection: "audit.logs",
+  });
+});
+
+test("parseMongoWriteCommand rejects invalid dropIndex and dropIndexes commands", () => {
+  assert.equal(parseMongoWriteCommand("db.projects.dropIndex()"), null);
+  assert.equal(parseMongoWriteCommand('db.projects.dropIndex("*")'), null);
+  assert.equal(parseMongoWriteCommand('db.projects.dropIndex(["a_1"])'), null);
+  assert.equal(parseMongoWriteCommand('db.projects.dropIndexes([{"email":1}])'), null);
+  assert.equal(parseMongoWriteCommand("db.projects.drop({ writeConcern: 1 })"), null);
+});
+
+test("mongodb executeQuery blocks writes when writes are explicitly disabled", async () => {
+  const oldAllowWrites = process.env.DBX_MCP_ALLOW_WRITES;
+  process.env.DBX_MCP_ALLOW_WRITES = "0";
+  await assert.rejects(
+    executeQuery(
+      {
+        id: "mongo",
+        name: "mongo",
+        db_type: "mongodb",
+        host: "127.0.0.1",
+        port: 27017,
+        username: "",
+        password: "",
+        database: "app",
+        ssh_enabled: false,
+        ssl: false,
+      },
+      'db.projects.insertOne({"name":"demo"})',
+    ),
+    /read-only/i,
+  );
+  if (oldAllowWrites === undefined) delete process.env.DBX_MCP_ALLOW_WRITES;
+  else process.env.DBX_MCP_ALLOW_WRITES = oldAllowWrites;
+});
+
+test("mongodb executeQuery treats createIndex as a write when writes are explicitly disabled", async () => {
+  const oldAllowWrites = process.env.DBX_MCP_ALLOW_WRITES;
+  process.env.DBX_MCP_ALLOW_WRITES = "0";
+  await assert.rejects(
+    executeQuery(
+      {
+        id: "mongo",
+        name: "mongo",
+        db_type: "mongodb",
+        host: "127.0.0.1",
+        port: 27017,
+        username: "",
+        password: "",
+        database: "app",
+        ssh_enabled: false,
+        ssl: false,
+      },
+      'db.projects.createIndex({"email":1})',
+    ),
+    /read-only/i,
+  );
+  if (oldAllowWrites === undefined) delete process.env.DBX_MCP_ALLOW_WRITES;
+  else process.env.DBX_MCP_ALLOW_WRITES = oldAllowWrites;
+});
+
+test("mongodb executeQuery treats dropIndex as a write when writes are explicitly disabled", async () => {
+  const oldAllowWrites = process.env.DBX_MCP_ALLOW_WRITES;
+  process.env.DBX_MCP_ALLOW_WRITES = "0";
+  await assert.rejects(
+    executeQuery(
+      {
+        id: "mongo",
+        name: "mongo",
+        db_type: "mongodb",
+        host: "127.0.0.1",
+        port: 27017,
+        username: "",
+        password: "",
+        database: "app",
+        ssh_enabled: false,
+        ssl: false,
+      },
+      'db.projects.dropIndex("projects_email_unique")',
+    ),
+    /read-only/i,
+  );
+  if (oldAllowWrites === undefined) delete process.env.DBX_MCP_ALLOW_WRITES;
+  else process.env.DBX_MCP_ALLOW_WRITES = oldAllowWrites;
+});
+
+test("mongodb executeQuery blocks dangerous dropIndexes shapes until dangerous SQL is enabled", async () => {
+  const oldAllowWrites = process.env.DBX_MCP_ALLOW_WRITES;
+  const oldAllowDangerous = process.env.DBX_MCP_ALLOW_DANGEROUS_SQL;
+  process.env.DBX_MCP_ALLOW_WRITES = "1";
+  delete process.env.DBX_MCP_ALLOW_DANGEROUS_SQL;
+
+  const config = {
+    id: "mongo",
+    name: "mongo",
+    db_type: "mongodb",
+    host: "127.0.0.1",
+    port: 27017,
+    username: "",
+    password: "",
+    database: "app",
+    ssh_enabled: false,
+    ssl: false,
+  } as const;
+
+  await assert.rejects(executeQuery(config, "db.projects.dropIndexes()"), /DBX_MCP_ALLOW_DANGEROUS_SQL=1/);
+  await assert.rejects(executeQuery(config, 'db.projects.dropIndexes("*")'), /DBX_MCP_ALLOW_DANGEROUS_SQL=1/);
+  await assert.rejects(executeQuery(config, 'db.projects.dropIndexes(["a_1","b_1"])'), /DBX_MCP_ALLOW_DANGEROUS_SQL=1/);
+  await assert.rejects(executeQuery(config, "db.projects.drop()"), /DBX_MCP_ALLOW_DANGEROUS_SQL=1/);
+
+  if (oldAllowWrites === undefined) delete process.env.DBX_MCP_ALLOW_WRITES;
+  else process.env.DBX_MCP_ALLOW_WRITES = oldAllowWrites;
+  if (oldAllowDangerous === undefined) delete process.env.DBX_MCP_ALLOW_DANGEROUS_SQL;
+  else process.env.DBX_MCP_ALLOW_DANGEROUS_SQL = oldAllowDangerous;
+});
+
+test("mongoDocumentsToQueryResult turns documents into rows", () => {
+  assert.deepEqual(
+    mongoDocumentsToQueryResult(
+      [
+        { _id: "1", nested: { ok: true } },
+        { _id: "2", name: "demo" },
+      ],
+      2,
+    ),
+    {
+      columns: ["_id", "nested", "name"],
+      rows: [
+        { _id: "1", nested: '{"ok":true}', name: undefined },
+        { _id: "2", nested: undefined, name: "demo" },
+      ],
+      row_count: 2,
+    },
+  );
+});
+
+test("inferMongoColumns marks _id as primary and reports observed types", () => {
+  assert.deepEqual(
+    inferMongoColumns([
+      { _id: "1", active: true },
+      { _id: "2", active: null },
+    ]),
+    [
+      {
+        name: "_id",
+        data_type: "string",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: true,
+        comment: null,
+      },
+      {
+        name: "active",
+        data_type: "boolean | null",
+        is_nullable: true,
+        column_default: null,
+        is_primary_key: false,
+        comment: null,
+      },
+    ],
+  );
+});
diff --git a/packages/node-core/tests/mysql-url.test.ts b/packages/node-core/tests/mysql-url.test.ts
new file mode 100644
index 0000000..6cf2b85
--- /dev/null
+++ b/packages/node-core/tests/mysql-url.test.ts
@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import type { ConnectionConfig } from "../src/connections.js";
+import { buildConnectionUrl } from "../src/database.js";
+
+function mysqlConfig(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
+  return {
+    id: "mysql-test",
+    name: "mysql",
+    db_type: "mysql",
+    host: "mysql.example.com",
+    port: 3306,
+    username: "root",
+    password: "secret",
+    database: "app",
+    ssl: false,
+    ...overrides,
+  };
+}
+
+test("mysql MCP URL does not enable TLS by default", () => {
+  const url = buildConnectionUrl(mysqlConfig(), { host: "mysql.example.com", port: 3306 });
+
+  assert.equal(url, "mysql://root:secret@mysql.example.com:3306/app");
+});
+
+test("mysql MCP URL preserves explicit preferred TLS mode", () => {
+  const url = buildConnectionUrl(mysqlConfig({ url_params: "ssl-mode=preferred" }), {
+    host: "mysql.example.com",
+    port: 3306,
+  });
+
+  assert.equal(url, "mysql://root:secret@mysql.example.com:3306/app?ssl-mode=preferred");
+});
diff --git a/packages/node-core/tests/paths.test.ts b/packages/node-core/tests/paths.test.ts
new file mode 100644
index 0000000..2480591
--- /dev/null
+++ b/packages/node-core/tests/paths.test.ts
@@ -0,0 +1,11 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { appDataDirFromInputs } from "../src/paths.js";
+
+test("default app data dir matches Tauri local data dir on Linux", () => {
+  assert.equal(appDataDirFromInputs({ platform: "linux", home: "/home/dbx" }), "/home/dbx/.local/share/com.dbx.app");
+});
+
+test("DBX_DATA_DIR overrides the default app data dir", () => {
+  assert.equal(appDataDirFromInputs({ platform: "linux", home: "/home/dbx", envDataDir: "/tmp/dbx-data" }), "/tmp/dbx-data");
+});
diff --git a/packages/node-core/tests/postgres-url.test.ts b/packages/node-core/tests/postgres-url.test.ts
new file mode 100644
index 0000000..6cd4f48
--- /dev/null
+++ b/packages/node-core/tests/postgres-url.test.ts
@@ -0,0 +1,70 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import type { ConnectionConfig } from "../src/connections.js";
+import { buildConnectionUrl } from "../src/database.js";
+
+function postgresConfig(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
+  return {
+    id: "pg-test",
+    name: "pg",
+    db_type: "postgres",
+    host: "pg.example.com",
+    port: 5432,
+    username: "postgres",
+    password: "secret",
+    database: "app",
+    ssl: false,
+    ...overrides,
+  };
+}
+
+test("postgres MCP URL adds sslmode=require when TLS is enabled", () => {
+  const url = buildConnectionUrl(postgresConfig({ ssl: true }), { host: "pg.example.com", port: 5432 });
+
+  assert.equal(url, "postgres://postgres:secret@pg.example.com:5432/app?sslmode=require");
+});
+
+test("postgres MCP URL keeps explicit sslmode", () => {
+  const url = buildConnectionUrl(postgresConfig({ ssl: true, url_params: "sslmode=verify-full&application_name=dbx" }), {
+    host: "pg.example.com",
+    port: 5432,
+  });
+
+  assert.equal(url, "postgres://postgres:secret@pg.example.com:5432/app?sslmode=verify-full&application_name=dbx");
+});
+
+test("postgres MCP URL maps ssl-mode to sslmode", () => {
+  const url = buildConnectionUrl(postgresConfig({ url_params: "ssl-mode=required" }), {
+    host: "pg.example.com",
+    port: 5432,
+  });
+
+  assert.equal(url, "postgres://postgres:secret@pg.example.com:5432/app?sslmode=require");
+});
+
+test("postgres MCP URL drops MySQL-style TLS params", () => {
+  const url = buildConnectionUrl(
+    postgresConfig({
+      url_params: "ssl-mode=required&verify_ca=false&verify_identity=false&require_ssl=true&charset=utf8mb4&application_name=dbx",
+    }),
+    { host: "pg.example.com", port: 5432 },
+  );
+
+  assert.equal(url, "postgres://postgres:secret@pg.example.com:5432/app?sslmode=require&application_name=dbx");
+});
+
+test("postgres MCP URL maps schema and timezone to options", () => {
+  const url = buildConnectionUrl(postgresConfig({ url_params: "schema=app&timezone=UTC" }), {
+    host: "pg.example.com",
+    port: 5432,
+  });
+
+  assert.equal(url, "postgres://postgres:secret@pg.example.com:5432/app?options=-c%20search_path%3Dapp%20-c%20TimeZone%3DUTC");
+});
+
+test("pooled URL builder rejects non-pooled direct types", () => {
+  assert.throws(
+    () => buildConnectionUrl(postgresConfig({ db_type: "sqlite", host: "/tmp/app.db", port: 0 }), { host: "/tmp/app.db", port: 0 }),
+    /Unsupported pooled connection type: sqlite/,
+  );
+});
diff --git a/packages/node-core/tests/production-safety.test.ts b/packages/node-core/tests/production-safety.test.ts
new file mode 100644
index 0000000..fcfe8a1
--- /dev/null
+++ b/packages/node-core/tests/production-safety.test.ts
@@ -0,0 +1,108 @@
+import { describe, expect, it } from "vitest";
+import { readFileSync } from "node:fs";
+import { assessProductionSql, isLikelyMongoMutation, isProductionDatabase } from "../src/production-safety.js";
+import type { ConnectionConfig } from "../src/connections.js";
+
+interface ProductionSafetyCorpusCase {
+  name: string;
+  dialect: ConnectionConfig["db_type"];
+  productionDatabases: string[];
+  activeDatabase: string;
+  sql: string;
+  active: boolean;
+  isMutation: boolean;
+  databases: string[];
+}
+
+const productionSafetyCorpus = JSON.parse(readFileSync(new URL("../../../tests/fixtures/production-safety-corpus.json", import.meta.url), "utf8")) as ProductionSafetyCorpusCase[];
+
+function connection(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
+  return {
+    id: "conn-1",
+    name: "Operations",
+    db_type: "mysql",
+    host: "db.internal",
+    port: 3306,
+    username: "readonly",
+    password: "",
+    production_databases: ["prod_app"],
+    ...overrides,
+  };
+}
+
+describe("production safety", () => {
+  it("keeps an explicit production connection in scope", () => {
+    expect(isProductionDatabase(connection({ is_production: true }), "scratch")).toBe(true);
+  });
+
+  it("detects a production write through USE and a qualified table name", () => {
+    expect(assessProductionSql("-- migrate\nUSE prod_app; /* delete old rows */ DELETE FROM users", connection(), "staging")).toMatchObject({ active: true, isMutation: true });
+    expect(assessProductionSql("DELETE FROM prod_app.orders", connection(), "staging")).toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+    expect(assessProductionSql("DROP DATABASE IF EXISTS prod_app", connection(), "staging")).toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+  });
+
+  it("detects production writes hidden behind parser-sensitive SQL forms", () => {
+    for (const sql of ["EXPLAIN ANALYZE DELETE FROM prod_app.users WHERE id = 1", "/*! DELETE FROM prod_app.users WHERE id = 1 */", "COPY prod_app.users FROM '/tmp/users.csv'", "SELECT * INTO prod_app.backup_users FROM users", "SELECT * FROM prod_app.users INTO OUTFILE '/tmp/users.csv'"]) {
+      expect(assessProductionSql(sql, connection(), "staging")).toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+    }
+  });
+
+  it("matches the shared SQL target safety corpus", () => {
+    for (const corpusCase of productionSafetyCorpus) {
+      const assessment = assessProductionSql(
+        corpusCase.sql,
+        connection({
+          db_type: corpusCase.dialect,
+          production_databases: corpusCase.productionDatabases,
+        }),
+        corpusCase.activeDatabase,
+      );
+      expect(
+        {
+          active: assessment.active,
+          isMutation: assessment.isMutation,
+          databases: assessment.databases,
+        },
+        corpusCase.name,
+      ).toEqual({
+        active: corpusCase.active,
+        isMutation: corpusCase.isMutation,
+        databases: corpusCase.databases,
+      });
+    }
+  });
+
+  it("detects qualified procedure calls and privilege targets", () => {
+    for (const sql of ["CALL prod_app.purge_users()", "CALL `prod_app`.`purge_users`()", "GRANT ALL ON prod_app.* TO 'u'@'%'", "GRANT EXECUTE ON PROCEDURE prod_app.purge_users TO 'u'@'%'"]) {
+      expect(assessProductionSql(sql, connection(), "staging")).toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+    }
+  });
+
+  it("allows resolved non-production procedure and privilege targets", () => {
+    expect(assessProductionSql("CALL staging.purge_users()", connection(), "staging")).toMatchObject({ active: false, isMutation: true });
+    expect(assessProductionSql("GRANT ALL ON staging.* TO 'u'@'%'", connection(), "staging")).toMatchObject({ active: false, isMutation: true });
+  });
+
+  it("conservatively confirms ambiguous production targets", () => {
+    for (const sql of ["CALL purge_users()", "GRANT PROCESS ON *.* TO 'u'@'%'", "GRANT ALL ON users TO 'u'@'%'", "CREATE USER 'u'@'%'"]) {
+      expect(assessProductionSql(sql, connection(), "staging")).toMatchObject({ active: true, isMutation: true, databases: ["prod_app"] });
+    }
+  });
+
+  it("does not treat read-only qualified references as write targets", () => {
+    expect(assessProductionSql("SELECT * FROM prod_app.orders; DELETE FROM staging.users WHERE id = 1", connection(), "staging")).toMatchObject({ active: false, isMutation: true });
+  });
+
+  it("treats unrecognized SQL as a mutation when production is selected", () => {
+    expect(assessProductionSql("MAINTAIN UNKNOWN THING", connection(), "prod_app")).toMatchObject({ active: true, isMutation: true });
+  });
+
+  it("does not treat a read as a production write", () => {
+    expect(assessProductionSql("SELECT * FROM prod_app.orders", connection(), "staging")).toMatchObject({ active: false, isMutation: false });
+  });
+
+  it("recognizes Mongo write commands before MCP forwards them", () => {
+    expect(isLikelyMongoMutation("db.orders.updateOne({_id: 1}, {$set: {status: 'paid'}})")).toBe(true);
+    expect(isLikelyMongoMutation("db.orders.find({status: 'paid'})")).toBe(false);
+  });
+});
diff --git a/packages/node-core/tests/redis-command.test.ts b/packages/node-core/tests/redis-command.test.ts
new file mode 100644
index 0000000..cf1cff1
--- /dev/null
+++ b/packages/node-core/tests/redis-command.test.ts
@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { classifyRedisCommand, evaluateRedisCommandSafety, firstRedisCommandToken, parseRedisCommandArgv } from "../src/redis-command.js";
+
+test("firstRedisCommandToken normalizes the command name", () => {
+  assert.equal(firstRedisCommandToken("  get session:1"), "GET");
+});
+
+test("parseRedisCommandArgv handles quoted values and escapes", () => {
+  assert.deepEqual(parseRedisCommandArgv('SET session:1 "hello world"'), ["SET", "session:1", "hello world"]);
+  assert.deepEqual(parseRedisCommandArgv("SET key line\\nnext;"), ["SET", "key", "line\nnext"]);
+  assert.throws(() => parseRedisCommandArgv('GET "unterminated'), /unterminated quote/);
+});
+
+test("classifyRedisCommand mirrors DBX redis command safety classes", () => {
+  assert.equal(classifyRedisCommand("GET session:1"), "allowed");
+  assert.equal(classifyRedisCommand("SET session:1 value"), "write");
+  assert.equal(classifyRedisCommand("DEL session:1"), "confirm");
+  assert.equal(classifyRedisCommand("KEYS *"), "blocked");
+});
+
+test("evaluateRedisCommandSafety blocks write commands when writes are disabled", () => {
+  const decision = evaluateRedisCommandSafety("SET session:1 value", { allowWrites: false });
+
+  assert.equal(decision.allowed, false);
+  assert.match(decision.reason ?? "", /read-only/i);
+});
+
+test("evaluateRedisCommandSafety requires dangerous mode for blocked commands", () => {
+  const blocked = evaluateRedisCommandSafety("KEYS *", { allowWrites: true, allowDangerous: false });
+  const allowed = evaluateRedisCommandSafety("KEYS *", { allowWrites: true, allowDangerous: true });
+
+  assert.equal(blocked.allowed, false);
+  assert.match(blocked.reason ?? "", /dangerous/i);
+  assert.equal(allowed.allowed, true);
+  assert.equal(allowed.skipSafetyCheck, true);
+});
diff --git a/packages/node-core/tests/redis-direct.test.ts b/packages/node-core/tests/redis-direct.test.ts
new file mode 100644
index 0000000..c34ec4a
--- /dev/null
+++ b/packages/node-core/tests/redis-direct.test.ts
@@ -0,0 +1,145 @@
+import assert from "node:assert/strict";
+import { createServer, type Socket } from "node:net";
+import { test } from "vitest";
+import type { ConnectionConfig } from "../src/connections.js";
+import { executeRedisCommand } from "../src/database.js";
+
+type RedisRequest = { command: string; args: string[] };
+
+function redisConnection(port: number): ConnectionConfig {
+  return {
+    id: "redis-direct",
+    name: "redis-direct",
+    db_type: "redis",
+    host: "127.0.0.1",
+    port,
+    username: "",
+    password: "",
+    database: "0",
+    redis_connection_mode: "standalone",
+    ssh_enabled: false,
+    ssl: false,
+  };
+}
+
+async function withRedisServer<T>(handler: (request: RedisRequest) => string, fn: (port: number, seen: RedisRequest[]) => Promise<T>): Promise<T> {
+  const seen: RedisRequest[] = [];
+  const server = createServer((socket) => {
+    let buffer = Buffer.alloc(0);
+    socket.on("data", (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      while (buffer.length > 0) {
+        const parsed = parseRespRequest(buffer);
+        if (!parsed) break;
+        buffer = buffer.subarray(parsed.bytes);
+        seen.push(parsed.request);
+        socket.write(handler(parsed.request));
+      }
+    });
+  });
+
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  try {
+    const address = server.address();
+    assert.equal(typeof address, "object");
+    assert(address && "port" in address);
+    return await fn(address.port, seen);
+  } finally {
+    await new Promise<void>((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+  }
+}
+
+function parseRespRequest(buffer: Buffer): { request: RedisRequest; bytes: number } | undefined {
+  let offset = 0;
+  const firstLine = readLine(buffer, offset);
+  if (!firstLine) return undefined;
+  offset = firstLine.next;
+  const count = Number(firstLine.line.slice(1));
+  const parts: string[] = [];
+
+  for (let i = 0; i < count; i++) {
+    const lengthLine = readLine(buffer, offset);
+    if (!lengthLine) return undefined;
+    offset = lengthLine.next;
+    const length = Number(lengthLine.line.slice(1));
+    if (buffer.length < offset + length + 2) return undefined;
+    parts.push(buffer.subarray(offset, offset + length).toString("utf8"));
+    offset += length + 2;
+  }
+
+  return {
+    request: {
+      command: parts[0]?.toUpperCase() ?? "",
+      args: parts.slice(1),
+    },
+    bytes: offset,
+  };
+}
+
+function readLine(buffer: Buffer, offset: number): { line: string; next: number } | undefined {
+  const end = buffer.indexOf("\r\n", offset);
+  if (end < 0) return undefined;
+  return { line: buffer.subarray(offset, end).toString("utf8"), next: end + 2 };
+}
+
+function bulk(value: string): string {
+  return `$${Buffer.byteLength(value)}\r\n${value}\r\n`;
+}
+
+test("executeRedisCommand runs standalone redis commands without the DBX bridge", async () => {
+  await withRedisServer(
+    (request) => {
+      if (request.command === "CLIENT") return "+OK\r\n";
+      if (request.command === "SELECT") return "+OK\r\n";
+      assert.deepEqual(request, { command: "GET", args: ["session:1"] });
+      return bulk("value-1");
+    },
+    async (port, seen) => {
+      const result = await executeRedisCommand(redisConnection(port), 2, "GET session:1");
+
+      assert.deepEqual(result, { command: "GET", safety: "allowed", value: "value-1" });
+      const dataCommands = seen.filter((request) => request.command !== "CLIENT");
+      assert.deepEqual(
+        dataCommands.map((request) => request.command),
+        ["SELECT", "GET"],
+      );
+      assert.deepEqual(dataCommands[0].args, ["2"]);
+    },
+  );
+});
+
+test("executeRedisCommand parses quoted arguments and JSON bulk replies", async () => {
+  await withRedisServer(
+    (request) => {
+      if (request.command === "CLIENT") return "+OK\r\n";
+      if (request.command === "SET") {
+        assert.deepEqual(request.args, ["session:1", "hello world"]);
+        return "+OK\r\n";
+      }
+      return bulk('{"ok":true}');
+    },
+    async (port) => {
+      const set = await executeRedisCommand(redisConnection(port), 0, 'SET session:1 "hello world"');
+      const get = await executeRedisCommand(redisConnection(port), 0, "GET session:1");
+
+      assert.deepEqual(set, { command: "SET", safety: "write", value: "OK" });
+      assert.deepEqual(get, { command: "GET", safety: "allowed", value: { ok: true } });
+    },
+  );
+});
+
+test("executeRedisCommand keeps blocked redis commands behind skipSafetyCheck", async () => {
+  await withRedisServer(
+    (request) => {
+      if (request.command === "CLIENT") return "+OK\r\n";
+      return bulk('["session:1"]');
+    },
+    async (port) => {
+      await assert.rejects(() => executeRedisCommand(redisConnection(port), 0, "KEYS *"), /blocked for safety/);
+
+      const result = await executeRedisCommand(redisConnection(port), 0, "KEYS *", { skipSafetyCheck: true });
+
+      assert.deepEqual(result, { command: "KEYS", safety: "blocked", value: ["session:1"] });
+    },
+  );
+});
diff --git a/packages/node-core/tests/rqlite-direct.test.ts b/packages/node-core/tests/rqlite-direct.test.ts
new file mode 100644
index 0000000..5832738
--- /dev/null
+++ b/packages/node-core/tests/rqlite-direct.test.ts
@@ -0,0 +1,131 @@
+import assert from "node:assert/strict";
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { test } from "vitest";
+import type { ConnectionConfig } from "../src/connections.js";
+import { describeTable, executeQuery, listTables } from "../src/database.js";
+
+function rqliteConfig(port: number): ConnectionConfig {
+  return {
+    id: "rqlite-test",
+    name: "local-rqlite",
+    db_type: "rqlite",
+    host: "127.0.0.1",
+    port,
+    username: "dbx",
+    password: "secret",
+    database: "main",
+    ssh_enabled: false,
+    ssl: false,
+  };
+}
+
+async function withRqliteServer(handler: (req: IncomingMessage, res: ServerResponse, body: string) => void) {
+  const server = createServer((req, res) => {
+    let body = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => handler(req, res, body));
+  });
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const address = server.address();
+  assert.ok(address && typeof address === "object");
+  return {
+    port: address.port,
+    close: () => new Promise<void>((resolve, reject) => server.close((err) => (err ? reject(err) : resolve()))),
+  };
+}
+
+function json(res: ServerResponse, body: unknown) {
+  res.writeHead(200, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+
+test("executes rqlite query through the HTTP API", async () => {
+  const server = await withRqliteServer((req, res, body) => {
+    assert.equal(req.url, "/db/query");
+    assert.equal(req.headers.authorization, "Basic ZGJ4OnNlY3JldA==");
+    assert.deepEqual(JSON.parse(body), ["select id, name from users"]);
+    json(res, {
+      results: [
+        {
+          columns: ["id", "name"],
+          values: [
+            [1, "Ada"],
+            [2, "Linus"],
+          ],
+        },
+      ],
+    });
+  });
+
+  try {
+    const result = await executeQuery(rqliteConfig(server.port), "select id, name from users", { maxRows: 1 });
+    assert.deepEqual(result, { columns: ["id", "name"], rows: [{ id: 1, name: "Ada" }], row_count: 1 });
+  } finally {
+    await server.close();
+  }
+});
+
+test("lists rqlite tables and describes columns", async () => {
+  const server = await withRqliteServer((_req, res, body) => {
+    const sql = JSON.parse(body)[0] as string;
+    if (sql.includes("sqlite_master")) {
+      json(res, {
+        results: [
+          {
+            columns: ["name", "type"],
+            values: [
+              ["users", "table"],
+              ["active_users", "view"],
+            ],
+          },
+        ],
+      });
+      return;
+    }
+    if (sql.includes("PRAGMA table_info")) {
+      json(res, {
+        results: [
+          {
+            columns: ["cid", "name", "type", "notnull", "dflt_value", "pk"],
+            values: [
+              [0, "id", "INTEGER", 1, null, 1],
+              [1, "name", "TEXT", 0, "'unknown'", 0],
+            ],
+          },
+        ],
+      });
+      return;
+    }
+    json(res, { results: [{ columns: [], values: [] }] });
+  });
+
+  try {
+    assert.deepEqual(await listTables(rqliteConfig(server.port)), [
+      { name: "users", type: "table" },
+      { name: "active_users", type: "view" },
+    ]);
+    assert.deepEqual(await describeTable(rqliteConfig(server.port), "users"), [
+      {
+        name: "id",
+        data_type: "INTEGER",
+        is_nullable: false,
+        column_default: null,
+        is_primary_key: true,
+        comment: null,
+      },
+      {
+        name: "name",
+        data_type: "TEXT",
+        is_nullable: true,
+        column_default: "'unknown'",
+        is_primary_key: false,
+        comment: null,
+      },
+    ]);
+  } finally {
+    await server.close();
+  }
+});
diff --git a/packages/node-core/tests/schema-context.test.ts b/packages/node-core/tests/schema-context.test.ts
new file mode 100644
index 0000000..ff96db0
--- /dev/null
+++ b/packages/node-core/tests/schema-context.test.ts
@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import type { ConnectionConfig } from "../src/connections.js";
+import type { ColumnInfo, TableInfo } from "../src/database.js";
+import { buildSchemaContext, formatSchemaContext } from "../src/schema-context.js";
+
+const config: ConnectionConfig = {
+  id: "pg",
+  name: "analytics",
+  db_type: "postgres",
+  host: "localhost",
+  port: 5432,
+  username: "app",
+  password: "",
+  database: "warehouse",
+  ssh_enabled: false,
+  ssl: false,
+};
+
+const tableRows: TableInfo[] = [
+  { name: "users", type: "BASE TABLE" },
+  { name: "orders", type: "BASE TABLE" },
+  { name: "events", type: "BASE TABLE" },
+];
+
+const columns: Record<string, ColumnInfo[]> = {
+  users: [
+    { name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, comment: null },
+    { name: "email", data_type: "text", is_nullable: false, column_default: null, is_primary_key: false, comment: "Login email" },
+  ],
+  orders: [
+    { name: "id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: true, comment: null },
+    { name: "user_id", data_type: "integer", is_nullable: false, column_default: null, is_primary_key: false, comment: null },
+  ],
+};
+
+test("builds schema context for requested tables", async () => {
+  const context = await buildSchemaContext(
+    {
+      listTables: async () => tableRows,
+      describeTable: async (_config, table) => columns[table] ?? [],
+    },
+    config,
+    { tables: ["users", "orders"], maxTables: 5 },
+  );
+
+  assert.equal(context.connection, "analytics");
+  assert.deepEqual(
+    context.tables.map((table) => table.name),
+    ["users", "orders"],
+  );
+  assert.equal(context.tables[0].columns[0].is_primary_key, true);
+});
+
+test("limits schema context when no table list is provided", async () => {
+  const context = await buildSchemaContext(
+    {
+      listTables: async () => tableRows,
+      describeTable: async (_config, table) => columns[table] ?? [],
+    },
+    config,
+    { maxTables: 2 },
+  );
+
+  assert.deepEqual(
+    context.tables.map((table) => table.name),
+    ["users", "orders"],
+  );
+});
+
+test("formats schema context as compact markdown", async () => {
+  const context = await buildSchemaContext(
+    {
+      listTables: async () => tableRows,
+      describeTable: async (_config, table) => columns[table] ?? [],
+    },
+    config,
+    { tables: ["users"] },
+  );
+
+  const markdown = formatSchemaContext(context);
+
+  assert.match(markdown, /Connection: analytics/);
+  assert.match(markdown, /## users/);
+  assert.match(markdown, /id integer NOT NULL PK/);
+  assert.match(markdown, /email text NOT NULL -- Login email/);
+});
diff --git a/packages/node-core/tests/sql-safety.test.ts b/packages/node-core/tests/sql-safety.test.ts
new file mode 100644
index 0000000..fe2375a
--- /dev/null
+++ b/packages/node-core/tests/sql-safety.test.ts
@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import { evaluateSqlSafety, sqlSafetyFromEnv } from "../src/sql-safety.js";
+
+test("allows read-only SQL by default", () => {
+  const decision = evaluateSqlSafety("select * from users limit 5");
+
+  assert.equal(decision.allowed, true);
+});
+
+test("allows read-only EXPLAIN without ANALYZE", () => {
+  const decision = evaluateSqlSafety("EXPLAIN SELECT * FROM users");
+
+  assert.equal(decision.allowed, true);
+});
+
+test("allows non-dangerous write SQL by default when scoped", () => {
+  const decision = evaluateSqlSafety("update users set role = 'admin' where id = 1", sqlSafetyFromEnv({}));
+
+  assert.equal(decision.allowed, true);
+});
+
+test("blocks dangerous SQL even when writes are enabled", () => {
+  const decision = evaluateSqlSafety("drop table users", { allowWrites: true });
+
+  assert.equal(decision.allowed, false);
+  assert.match(decision.reason ?? "", /dangerous/i);
+});
+
+test("blocks update without where when writes are enabled", () => {
+  const decision = evaluateSqlSafety("update users set disabled = true", { allowWrites: true });
+
+  assert.equal(decision.allowed, false);
+  assert.match(decision.reason ?? "", /WHERE/i);
+});
+
+test("blocks writes that do not start with a write keyword in read-only mode", () => {
+  for (const sql of [
+    "EXPLAIN ANALYZE DELETE FROM users WHERE id = 1",
+    "/*! DELETE FROM users WHERE id = 1 */",
+    "COPY users FROM '/tmp/users.csv'",
+    "SELECT * INTO backup_users FROM users",
+    "SELECT * FROM users INTO OUTFILE '/tmp/users.csv'",
+  ]) {
+    const decision = evaluateSqlSafety(sql);
+    assert.equal(decision.allowed, false, sql);
+    assert.match(decision.reason ?? "", /read-only|blocked/i);
+  }
+});
+
+test("blocks unrecognized SQL unless dangerous SQL is explicitly enabled", () => {
+  const decision = evaluateSqlSafety("MAINTAIN UNKNOWN THING", { allowWrites: true });
+
+  assert.equal(decision.allowed, false);
+  assert.match(decision.reason ?? "", /unrecognized/i);
+});
+
+test("blocks multiple SQL statements unless explicitly allowed", () => {
+  const decision = evaluateSqlSafety("select 1; select 2");
+
+  assert.equal(decision.allowed, false);
+  assert.match(decision.reason ?? "", /Only one SQL statement/);
+});
+
+test("allows multiple read-only SQL statements when enabled", () => {
+  const decision = evaluateSqlSafety("select 1; show tables", { allowMultipleStatements: true });
+
+  assert.equal(decision.allowed, true);
+});
+
+test("checks every statement in a multi-statement SQL string", () => {
+  const decision = evaluateSqlSafety("select 1; delete from users", {
+    allowMultipleStatements: true,
+    allowWrites: true,
+  });
+
+  assert.equal(decision.allowed, false);
+  assert.match(decision.reason ?? "", /Statement 2/i);
+  assert.match(decision.reason ?? "", /WHERE/i);
+});
+
+test("sqlSafetyFromEnv allows writes by default but keeps dangerous SQL blocked", () => {
+  const options = sqlSafetyFromEnv({});
+
+  assert.equal(options.allowWrites, true);
+  assert.equal(options.allowDangerous, false);
+});
+
+test("sqlSafetyFromEnv supports explicitly disabling writes", () => {
+  const options = sqlSafetyFromEnv({ DBX_MCP_ALLOW_WRITES: "0" } as NodeJS.ProcessEnv);
+
+  assert.equal(options.allowWrites, false);
+  assert.equal(options.allowDangerous, false);
+});
diff --git a/packages/node-core/tests/sqlite-direct.test.ts b/packages/node-core/tests/sqlite-direct.test.ts
new file mode 100644
index 0000000..9c529fc
--- /dev/null
+++ b/packages/node-core/tests/sqlite-direct.test.ts
@@ -0,0 +1,131 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "vitest";
+import Database from "better-sqlite3";
+import type { ConnectionConfig } from "../src/connections.js";
+import { describeTable, executeQuery, listTables } from "../src/database.js";
+
+function sqliteConfig(path: string): ConnectionConfig {
+  return {
+    id: "sqlite-test",
+    name: "local-sqlite",
+    db_type: "sqlite",
+    host: path,
+    port: 0,
+    username: "",
+    password: "",
+    ssh_enabled: false,
+    ssl: false,
+  };
+}
+
+function mysqlSshConfig(): ConnectionConfig {
+  return {
+    id: "mysql-ssh-test",
+    name: "mysql-over-ssh",
+    db_type: "mysql",
+    host: "10.0.0.10",
+    port: 3306,
+    username: "root",
+    password: "secret",
+    ssl: false,
+    transport_layers: [
+      {
+        type: "ssh",
+        id: "bastion",
+        enabled: true,
+        host: "bastion.example.com",
+        port: 22,
+        user: "root",
+        password: "ssh-secret",
+      },
+    ],
+  };
+}
+
+test("queries SQLite connections without the DBX bridge", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "dbx-mcp-sqlite-"));
+  const path = join(dir, "app.db");
+  const db = new Database(path);
+  db.exec("create table users (id integer primary key, name text not null); insert into users (name) values ('Ada');");
+  db.close();
+
+  try {
+    const result = await executeQuery(sqliteConfig(path), "select id, name from users");
+
+    assert.deepEqual(result.columns, ["id", "name"]);
+    assert.deepEqual(result.rows, [{ id: 1, name: "Ada" }]);
+    assert.equal(result.row_count, 1);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("applies query row limits to SQLite connections", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "dbx-mcp-sqlite-"));
+  const path = join(dir, "app.db");
+  const db = new Database(path);
+  db.exec("create table users (id integer primary key, name text not null); insert into users (name) values ('Ada'), ('Grace');");
+  db.close();
+
+  try {
+    const result = await executeQuery(sqliteConfig(path), "select id, name from users order by id", { maxRows: 1 });
+
+    assert.deepEqual(result.columns, ["id", "name"]);
+    assert.deepEqual(result.rows, [{ id: 1, name: "Ada" }]);
+    assert.equal(result.row_count, 1);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("lists and describes SQLite tables without the DBX bridge", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "dbx-mcp-sqlite-"));
+  const path = join(dir, "app.db");
+  const db = new Database(path);
+  db.exec("create table users (id integer primary key, name text not null);");
+  db.close();
+
+  try {
+    const tables = await listTables(sqliteConfig(path));
+    const columns = await describeTable(sqliteConfig(path), "users");
+
+    assert.deepEqual(tables, [{ name: "users", type: "table" }]);
+    assert.deepEqual(
+      columns.map((column) => ({
+        name: column.name,
+        data_type: column.data_type,
+        is_nullable: column.is_nullable,
+        is_primary_key: column.is_primary_key,
+      })),
+      [
+        { name: "id", data_type: "INTEGER", is_nullable: true, is_primary_key: true },
+        { name: "name", data_type: "TEXT", is_nullable: false, is_primary_key: false },
+      ],
+    );
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("routes SSH transport layer connections through the DBX bridge", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "dbx-mcp-bridge-home-"));
+  const originalHome = process.env.HOME;
+  const originalDbxDataDir = process.env.DBX_DATA_DIR;
+  process.env.HOME = dir;
+  process.env.DBX_DATA_DIR = dir;
+
+  try {
+    await assert.rejects(() => executeQuery(mysqlSshConfig(), "select 1"), /DBX desktop app is not running/);
+    await assert.rejects(() => listTables(mysqlSshConfig()), /DBX desktop app is not running/);
+    await assert.rejects(() => describeTable(mysqlSshConfig(), "users"), /DBX desktop app is not running/);
+  } finally {
+    if (originalHome === undefined) delete process.env.HOME;
+    else process.env.HOME = originalHome;
+    if (originalDbxDataDir === undefined) delete process.env.DBX_DATA_DIR;
+    else process.env.DBX_DATA_DIR = originalDbxDataDir;
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
diff --git a/packages/node-core/tests/starrocks-url.test.ts b/packages/node-core/tests/starrocks-url.test.ts
new file mode 100644
index 0000000..9362484
--- /dev/null
+++ b/packages/node-core/tests/starrocks-url.test.ts
@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import { test } from "vitest";
+import type { ConnectionConfig } from "../src/connections.js";
+import { buildConnectionUrl } from "../src/database.js";
+
+function starrocksConfig(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
+  return {
+    id: "sr-1",
+    name: "starrocks",
+    db_type: "starrocks",
+    host: "fe-example.starrocks.aliyuncs.com",
+    port: 9030,
+    username: "admin",
+    password: "secret",
+    database: "analytics",
+    ssl: false,
+    ...overrides,
+  };
+}
+
+test("starrocks omits tls params when ssl is disabled", () => {
+  const url = buildConnectionUrl(
+    starrocksConfig({
+      url_params: "ssl-mode=disabled&require_ssl=true&verify_ca=true&charset=utf8mb4",
+    }),
+    { host: "fe-example.starrocks.aliyuncs.com", port: 9030 },
+  );
+
+  assert.equal(url, "mysql://admin:secret@fe-example.starrocks.aliyuncs.com:9030/analytics");
+});
+
+test("starrocks preserves tls params when ssl is enabled", () => {
+  const url = buildConnectionUrl(
+    starrocksConfig({
+      ssl: true,
+      url_params: "verify_ca=true&verify_identity=false",
+    }),
+    { host: "fe-example.starrocks.aliyuncs.com", port: 9030 },
+  );
+
+  assert.equal(
+    url,
+    "mysql://admin:secret@fe-example.starrocks.aliyuncs.com:9030/analytics?require_ssl=true&verify_ca=true&verify_identity=false&charset=utf8mb4",
+  );
+});
+
+test("mysql starrocks profile preserves tls params when ssl is enabled", () => {
+  const url = buildConnectionUrl(
+    starrocksConfig({
+      db_type: "mysql",
+      driver_profile: "starrocks",
+      ssl: true,
+      ca_cert_path: "/tmp/ca.pem",
+    }),
+    { host: "fe-example.starrocks.aliyuncs.com", port: 9030 },
+  );
+
+  assert.equal(
+    url,
+    "mysql://admin:secret@fe-example.starrocks.aliyuncs.com:9030/analytics?require_ssl=true&verify_identity=false&charset=utf8mb4",
+  );
+});
diff --git a/packages/node-core/tests/web-backend.test.ts b/packages/node-core/tests/web-backend.test.ts
new file mode 100644
index 0000000..176ec52
--- /dev/null
+++ b/packages/node-core/tests/web-backend.test.ts
@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import { afterEach, test } from "vitest";
+
+import { loadConnections, resetWebAuthForTests } from "../src/web-backend.js";
+
+const originalFetch = globalThis.fetch;
+const originalWebUrl = process.env.DBX_WEB_URL;
+const originalWebPassword = process.env.DBX_WEB_PASSWORD;
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  if (originalWebUrl === undefined) delete process.env.DBX_WEB_URL;
+  else process.env.DBX_WEB_URL = originalWebUrl;
+  if (originalWebPassword === undefined) delete process.env.DBX_WEB_PASSWORD;
+  else process.env.DBX_WEB_PASSWORD = originalWebPassword;
+  resetWebAuthForTests();
+});
+
+function jsonResponse(body: unknown, init?: ResponseInit): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "Content-Type": "application/json", ...(init?.headers ?? {}) },
+    ...init,
+  });
+}
+
+test("web backend rejects protected DBX Web access without DBX_WEB_PASSWORD", async () => {
+  process.env.DBX_WEB_URL = "http://127.0.0.1:4224";
+  delete process.env.DBX_WEB_PASSWORD;
+  const calls: string[] = [];
+  globalThis.fetch = (async (input) => {
+    const url = String(input);
+    calls.push(url);
+    if (url.endsWith("/api/auth/check")) {
+      return jsonResponse({ authenticated: false, required: true, setup_required: false });
+    }
+    throw new Error(`unexpected request: ${url}`);
+  }) as typeof fetch;
+
+  await assert.rejects(loadConnections(), /DBX_WEB_PASSWORD/);
+  assert.deepEqual(calls, ["http://127.0.0.1:4224/api/auth/check"]);
+});
+
+test("web backend rejects DBX Web access before password setup is complete", async () => {
+  process.env.DBX_WEB_URL = "http://127.0.0.1:4224";
+  delete process.env.DBX_WEB_PASSWORD;
+  const calls: string[] = [];
+  globalThis.fetch = (async (input) => {
+    const url = String(input);
+    calls.push(url);
+    if (url.endsWith("/api/auth/check")) {
+      return jsonResponse({ authenticated: false, required: false, setup_required: true });
+    }
+    throw new Error(`unexpected request: ${url}`);
+  }) as typeof fetch;
+
+  await assert.rejects(loadConnections(), /password setup is required/);
+  assert.deepEqual(calls, ["http://127.0.0.1:4224/api/auth/check"]);
+});
+
+test("web backend logs in with DBX_WEB_PASSWORD and sends the session cookie", async () => {
+  process.env.DBX_WEB_URL = "http://127.0.0.1:4224/";
+  process.env.DBX_WEB_PASSWORD = "secret";
+  const calls: Array<{ url: string; init?: RequestInit }> = [];
+  globalThis.fetch = (async (input, init) => {
+    const url = String(input);
+    calls.push({ url, init });
+    if (url.endsWith("/api/auth/check")) {
+      return jsonResponse({ authenticated: false, required: true, setup_required: false });
+    }
+    if (url.endsWith("/api/auth/login")) {
+      assert.equal(init?.method, "POST");
+      assert.equal(init?.body, JSON.stringify({ password: "secret" }));
+      return jsonResponse({ ok: true }, { headers: { "set-cookie": "dbx_session=session-1; Path=/; HttpOnly" } });
+    }
+    if (url.endsWith("/api/connection/list")) {
+      assert.equal((init?.headers as Record<string, string>).Cookie, "dbx_session=session-1");
+      return jsonResponse([
+        {
+          id: "1",
+          name: "local",
+          db_type: "postgres",
+          host: "127.0.0.1",
+          port: 5432,
+          username: "app",
+          password: "",
+          database: "demo",
+          ssh_enabled: false,
+          ssl: false,
+        },
+      ]);
+    }
+    throw new Error(`unexpected request: ${url}`);
+  }) as typeof fetch;
+
+  const connections = await loadConnections();
+
+  assert.equal(connections[0]?.name, "local");
+  assert.deepEqual(
+    calls.map((call) => call.url),
+    [
+      "http://127.0.0.1:4224/api/auth/check",
+      "http://127.0.0.1:4224/api/auth/login",
+      "http://127.0.0.1:4224/api/connection/list",
+    ],
+  );
+});
+
+test("web backend still allows DBX Web instances with password auth disabled", async () => {
+  process.env.DBX_WEB_URL = "http://127.0.0.1:4224";
+  delete process.env.DBX_WEB_PASSWORD;
+  globalThis.fetch = (async (input, init) => {
+    const url = String(input);
+    if (url.endsWith("/api/auth/check")) {
+      return jsonResponse({ authenticated: true, required: false, setup_required: false });
+    }
+    if (url.endsWith("/api/connection/list")) {
+      assert.equal((init?.headers as Record<string, string>).Cookie, undefined);
+      return jsonResponse([]);
+    }
+    throw new Error(`unexpected request: ${url}`);
+  }) as typeof fetch;
+
+  assert.deepEqual(await loadConnections(), []);
+});
diff --git a/packages/node-core/tsconfig.json b/packages/node-core/tsconfig.json
new file mode 100644
index 0000000..9b2da40
--- /dev/null
+++ b/packages/node-core/tsconfig.json
@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "declaration": true
+  },
+  "include": ["src"]
+}
diff --git a/packages/node-core/vitest.config.ts b/packages/node-core/vitest.config.ts
new file mode 100644
index 0000000..4cfb639
--- /dev/null
+++ b/packages/node-core/vitest.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/*.test.ts"],
+  },
+});
diff --git a/packages/test-globals.ts b/packages/test-globals.ts
new file mode 100644
index 0000000..5db3b8d
--- /dev/null
+++ b/packages/test-globals.ts
@@ -0,0 +1,3 @@
+export const setup = () => {
+  process.env.TZ = "Asia/Shanghai";
+};
\ No newline at end of file
diff --git a/plugins/README.md b/plugins/README.md
new file mode 100644
index 0000000..401e581
--- /dev/null
+++ b/plugins/README.md
@@ -0,0 +1,11 @@
+# Plugins
+
+DBX extension plugins live here.
+
+Plugins are not Node packages, so they intentionally stay separate from `packages/`.
+
+## Directories
+
+- `jdbc/` - optional Java/JDBC plugin for connecting through vendor JDBC drivers and custom JDBC URLs.
+
+Plugin build artifacts, downloaded driver JARs, and local targets are ignored by Git.
diff --git a/plugins/jdbc/README.md b/plugins/jdbc/README.md
new file mode 100644
index 0000000..f69d3c0
--- /dev/null
+++ b/plugins/jdbc/README.md
@@ -0,0 +1,38 @@
+# DBX JDBC Plugin Prototype
+
+This is an optional sidecar plugin for DBX. It is not bundled with the main DBX app.
+
+## Build
+
+```sh
+mvn -q -DskipTests package
+mkdir -p lib
+cp target/dbx-jdbc-plugin-*-all.jar lib/dbx-jdbc-plugin.jar
+```
+
+## Package for release
+
+```sh
+./package.sh
+```
+
+The package version follows the JDBC plugin version in `pom.xml` and `manifest.json`.
+The package script writes both `dbx-jdbc-plugin-<version>.zip` and `dbx-jdbc-plugin-latest.zip`.
+
+## Install for local DBX
+
+Copy this folder to the DBX app data plugin directory:
+
+```text
+<DBX app data>/plugins/jdbc
+```
+
+The folder must contain:
+
+```text
+manifest.json
+bin/dbx-jdbc-plugin
+lib/dbx-jdbc-plugin.jar
+```
+
+DBX does not bundle Java or JDBC drivers. Install Java locally and add database-specific driver JAR paths in the DBX JDBC connection form.
diff --git a/plugins/jdbc/bin/dbx-jdbc-plugin b/plugins/jdbc/bin/dbx-jdbc-plugin
new file mode 100755
index 0000000..0bc1415
--- /dev/null
+++ b/plugins/jdbc/bin/dbx-jdbc-plugin
@@ -0,0 +1,47 @@
+#!/usr/bin/env sh
+set -eu
+DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+
+if [ -n "${DBX_JAVA_BIN:-}" ] && [ -x "$DBX_JAVA_BIN" ]; then
+  JAVA_BIN="$DBX_JAVA_BIN"
+elif [ -n "${JAVA_HOME:-}" ] && [ -x "$JAVA_HOME/bin/java" ]; then
+  JAVA_BIN="$JAVA_HOME/bin/java"
+elif [ -x "/opt/homebrew/opt/openjdk/bin/java" ]; then
+  JAVA_BIN="/opt/homebrew/opt/openjdk/bin/java"
+elif [ -x "/usr/local/opt/openjdk/bin/java" ]; then
+  JAVA_BIN="/usr/local/opt/openjdk/bin/java"
+elif command -v java >/dev/null 2>&1 && java -version >/dev/null 2>&1; then
+  JAVA_BIN="java"
+else
+  echo "Java runtime not found. Install Java or the optional DBX JDBC runtime." >&2
+  exit 127
+fi
+
+exec "$JAVA_BIN" \
+  -XX:+IgnoreUnrecognizedVMOptions \
+  --add-opens=java.base/java.io=ALL-UNNAMED \
+  --add-opens=java.base/java.lang=ALL-UNNAMED \
+  --add-opens=java.base/java.lang.reflect=ALL-UNNAMED \
+  --add-opens=java.base/java.net=ALL-UNNAMED \
+  --add-opens=java.base/java.nio=ALL-UNNAMED \
+  --add-opens=java.base/java.nio.charset=ALL-UNNAMED \
+  --add-opens=java.base/java.text=ALL-UNNAMED \
+  --add-opens=java.base/java.time=ALL-UNNAMED \
+  --add-opens=java.base/java.util=ALL-UNNAMED \
+  --add-opens=java.base/java.util.concurrent=ALL-UNNAMED \
+  --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED \
+  --add-opens=java.base/jdk.internal.misc=ALL-UNNAMED \
+  --add-opens=java.base/jdk.internal.vm=ALL-UNNAMED \
+  --add-opens=java.base/sun.nio.ch=ALL-UNNAMED \
+  --add-opens=java.base/sun.nio.fs=ALL-UNNAMED \
+  --add-opens=java.base/sun.security.action=ALL-UNNAMED \
+  --add-opens=java.base/sun.security.ssl=ALL-UNNAMED \
+  --add-opens=java.base/sun.security.util=ALL-UNNAMED \
+  --add-opens=java.security.jgss/sun.security.jgss=ALL-UNNAMED \
+  --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED \
+  --add-opens=java.sql/java.sql=ALL-UNNAMED \
+  ${DBX_JAVA_OPTS:-} \
+  -Dfile.encoding=UTF-8 \
+  -Dsun.stdout.encoding=UTF-8 \
+  -Dsun.stderr.encoding=UTF-8 \
+  -jar "$DIR/../lib/dbx-jdbc-plugin.jar"
diff --git a/plugins/jdbc/bin/dbx-jdbc-plugin.bat b/plugins/jdbc/bin/dbx-jdbc-plugin.bat
new file mode 100644
index 0000000..00e1917
--- /dev/null
+++ b/plugins/jdbc/bin/dbx-jdbc-plugin.bat
@@ -0,0 +1,31 @@
+@echo off
+setlocal
+
+if defined DBX_JAVA_BIN (
+    if exist "%DBX_JAVA_BIN%" (
+        set "JAVA_BIN=%DBX_JAVA_BIN%"
+        goto :run
+    )
+)
+
+if defined JAVA_HOME (
+    if exist "%JAVA_HOME%\bin\java.exe" (
+        set "JAVA_BIN=%JAVA_HOME%\bin\java.exe"
+        goto :run
+    )
+)
+
+where java >nul 2>nul
+if %errorlevel% equ 0 (
+    java -version >nul 2>nul
+    if %errorlevel% equ 0 (
+        set "JAVA_BIN=java"
+        goto :run
+    )
+)
+
+echo Java runtime not found. Install Java or the optional DBX JDBC runtime. >&2
+exit /b 127
+
+:run
+"%JAVA_BIN%" -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.io=ALL-UNNAMED --add-opens=java.base/java.lang=ALL-UNNAMED --add-opens=java.base/java.lang.reflect=ALL-UNNAMED --add-opens=java.base/java.net=ALL-UNNAMED --add-opens=java.base/java.nio=ALL-UNNAMED --add-opens=java.base/java.nio.charset=ALL-UNNAMED --add-opens=java.base/java.text=ALL-UNNAMED --add-opens=java.base/java.time=ALL-UNNAMED --add-opens=java.base/java.util=ALL-UNNAMED --add-opens=java.base/java.util.concurrent=ALL-UNNAMED --add-opens=java.base/java.util.concurrent.atomic=ALL-UNNAMED --add-opens=java.base/jdk.internal.misc=ALL-UNNAMED --add-opens=java.base/jdk.internal.vm=ALL-UNNAMED --add-opens=java.base/sun.nio.ch=ALL-UNNAMED --add-opens=java.base/sun.nio.fs=ALL-UNNAMED --add-opens=java.base/sun.security.action=ALL-UNNAMED --add-opens=java.base/sun.security.ssl=ALL-UNNAMED --add-opens=java.base/sun.security.util=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.jgss=ALL-UNNAMED --add-opens=java.security.jgss/sun.security.krb5=ALL-UNNAMED --add-opens=java.sql/java.sql=ALL-UNNAMED %DBX_JAVA_OPTS% -Dfile.encoding=UTF-8 -Dsun.stdout.encoding=UTF-8 -Dsun.stderr.encoding=UTF-8 -jar "%~dp0..\lib\dbx-jdbc-plugin.jar"
diff --git a/plugins/jdbc/bin/dbx-maven-resolver b/plugins/jdbc/bin/dbx-maven-resolver
new file mode 100644
index 0000000..f97f70b
--- /dev/null
+++ b/plugins/jdbc/bin/dbx-maven-resolver
@@ -0,0 +1,25 @@
+#!/usr/bin/env sh
+set -eu
+DIR="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+
+if [ -n "${DBX_JAVA_BIN:-}" ] && [ -x "$DBX_JAVA_BIN" ]; then
+  JAVA_BIN="$DBX_JAVA_BIN"
+elif [ -n "${JAVA_HOME:-}" ] && [ -x "$JAVA_HOME/bin/java" ]; then
+  JAVA_BIN="$JAVA_HOME/bin/java"
+elif [ -x "/opt/homebrew/opt/openjdk/bin/java" ]; then
+  JAVA_BIN="/opt/homebrew/opt/openjdk/bin/java"
+elif [ -x "/usr/local/opt/openjdk/bin/java" ]; then
+  JAVA_BIN="/usr/local/opt/openjdk/bin/java"
+elif command -v java >/dev/null 2>&1 && java -version >/dev/null 2>&1; then
+  JAVA_BIN="java"
+else
+  echo "Java runtime not found. Install Java or the optional DBX JDBC runtime." >&2
+  exit 127
+fi
+
+exec "$JAVA_BIN" \
+  -Dfile.encoding=UTF-8 \
+  -Dsun.stdout.encoding=UTF-8 \
+  -Dsun.stderr.encoding=UTF-8 \
+  -cp "$DIR/../lib/dbx-jdbc-plugin.jar" \
+  app.dbx.jdbc.maven.DbxMavenResolver "$@"
diff --git a/plugins/jdbc/bin/dbx-maven-resolver.bat b/plugins/jdbc/bin/dbx-maven-resolver.bat
new file mode 100644
index 0000000..f2abd7d
--- /dev/null
+++ b/plugins/jdbc/bin/dbx-maven-resolver.bat
@@ -0,0 +1,31 @@
+@echo off
+setlocal
+
+if defined DBX_JAVA_BIN (
+    if exist "%DBX_JAVA_BIN%" (
+        set "JAVA_BIN=%DBX_JAVA_BIN%"
+        goto :run
+    )
+)
+
+if defined JAVA_HOME (
+    if exist "%JAVA_HOME%\bin\java.exe" (
+        set "JAVA_BIN=%JAVA_HOME%\bin\java.exe"
+        goto :run
+    )
+)
+
+where java >nul 2>nul
+if %errorlevel% equ 0 (
+    java -version >nul 2>nul
+    if %errorlevel% equ 0 (
+        set "JAVA_BIN=java"
+        goto :run
+    )
+)
+
+echo Java runtime not found. Install Java or the optional DBX JDBC runtime. >&2
+exit /b 127
+
+:run
+"%JAVA_BIN%" -Dfile.encoding=UTF-8 -Dsun.stdout.encoding=UTF-8 -Dsun.stderr.encoding=UTF-8 -cp "%~dp0..\lib\dbx-jdbc-plugin.jar" app.dbx.jdbc.maven.DbxMavenResolver %*
diff --git a/plugins/jdbc/manifest.json b/plugins/jdbc/manifest.json
new file mode 100644
index 0000000..0f2e73e
--- /dev/null
+++ b/plugins/jdbc/manifest.json
@@ -0,0 +1,16 @@
+{
+  "id": "jdbc",
+  "name": "DBX JDBC Plugin",
+  "version": "0.1.21",
+  "protocol_version": 1,
+  "description": "Adds optional JDBC driver support to DBX.",
+  "executable": "bin/dbx-jdbc-plugin",
+  "drivers": [
+    {
+      "id": "jdbc",
+      "label": "JDBC",
+      "kind": "external",
+      "database_type": "jdbc"
+    }
+  ]
+}
diff --git a/plugins/jdbc/package.sh b/plugins/jdbc/package.sh
new file mode 100755
index 0000000..236ba36
--- /dev/null
+++ b/plugins/jdbc/package.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env sh
+set -eu
+
+ROOT="$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)"
+VERSION="$(grep -m1 '<version>' "$ROOT/pom.xml" | sed -E 's/.*<version>([^<]+)<.*/\1/')"
+PACKAGE_DIR="$ROOT/dist/dbx-jdbc-plugin-$VERSION"
+ZIP_PATH="$ROOT/dist/dbx-jdbc-plugin-$VERSION.zip"
+LATEST_ZIP_PATH="$ROOT/dist/dbx-jdbc-plugin-latest.zip"
+
+cd "$ROOT"
+mvn -q -DskipTests package
+
+rm -rf "$PACKAGE_DIR" "$ZIP_PATH" "$LATEST_ZIP_PATH"
+mkdir -p "$PACKAGE_DIR/bin" "$PACKAGE_DIR/lib"
+cp "$ROOT/manifest.json" "$PACKAGE_DIR/manifest.json"
+cp "$ROOT/bin/dbx-jdbc-plugin" "$PACKAGE_DIR/bin/dbx-jdbc-plugin"
+cp "$ROOT/bin/dbx-jdbc-plugin.bat" "$PACKAGE_DIR/bin/dbx-jdbc-plugin.bat"
+cp "$ROOT/bin/dbx-maven-resolver" "$PACKAGE_DIR/bin/dbx-maven-resolver"
+cp "$ROOT/bin/dbx-maven-resolver.bat" "$PACKAGE_DIR/bin/dbx-maven-resolver.bat"
+cp "$ROOT/target/dbx-jdbc-plugin-$VERSION-all.jar" "$PACKAGE_DIR/lib/dbx-jdbc-plugin.jar"
+chmod +x "$PACKAGE_DIR/bin/dbx-jdbc-plugin"
+chmod +x "$PACKAGE_DIR/bin/dbx-maven-resolver"
+
+(cd "$ROOT/dist" && zip -qr "dbx-jdbc-plugin-$VERSION.zip" "dbx-jdbc-plugin-$VERSION")
+cp "$ZIP_PATH" "$LATEST_ZIP_PATH"
+echo "$ZIP_PATH"
+echo "$LATEST_ZIP_PATH"
diff --git a/plugins/jdbc/pom.xml b/plugins/jdbc/pom.xml
new file mode 100644
index 0000000..54d95f0
--- /dev/null
+++ b/plugins/jdbc/pom.xml
@@ -0,0 +1,134 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>app.dbx</groupId>
+  <artifactId>dbx-jdbc-plugin</artifactId>
+  <version>0.1.21</version>
+
+  <properties>
+    <maven.compiler.source>17</maven.compiler.source>
+    <maven.compiler.target>17</maven.compiler.target>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <maven.resolver.version>2.0.18</maven.resolver.version>
+    <maven.core.version>4.0.0-rc-5</maven.core.version>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>com.fasterxml.jackson.core</groupId>
+      <artifactId>jackson-databind</artifactId>
+      <version>2.17.2</version>
+    </dependency>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-api</artifactId>
+      <version>1.7.36</version>
+    </dependency>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-nop</artifactId>
+      <version>1.7.36</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.commons</groupId>
+      <artifactId>commons-lang3</artifactId>
+      <version>3.18.0</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven.resolver</groupId>
+      <artifactId>maven-resolver-api</artifactId>
+      <version>${maven.resolver.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven.resolver</groupId>
+      <artifactId>maven-resolver-spi</artifactId>
+      <version>${maven.resolver.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven.resolver</groupId>
+      <artifactId>maven-resolver-util</artifactId>
+      <version>${maven.resolver.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven.resolver</groupId>
+      <artifactId>maven-resolver-impl</artifactId>
+      <version>${maven.resolver.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven.resolver</groupId>
+      <artifactId>maven-resolver-connector-basic</artifactId>
+      <version>${maven.resolver.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven.resolver</groupId>
+      <artifactId>maven-resolver-transport-file</artifactId>
+      <version>${maven.resolver.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven.resolver</groupId>
+      <artifactId>maven-resolver-transport-jdk</artifactId>
+      <version>${maven.resolver.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven.resolver</groupId>
+      <artifactId>maven-resolver-supplier-mvn4</artifactId>
+      <version>${maven.resolver.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-resolver-provider</artifactId>
+      <version>${maven.core.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.maven</groupId>
+      <artifactId>maven-model-builder</artifactId>
+      <version>${maven.core.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>com.h2database</groupId>
+      <artifactId>h2</artifactId>
+      <version>2.2.224</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter</artifactId>
+      <version>5.10.3</version>
+      <scope>test</scope>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>3.2.5</version>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.5.3</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <createDependencyReducedPom>false</createDependencyReducedPom>
+              <shadedArtifactAttached>true</shadedArtifactAttached>
+              <shadedClassifierName>all</shadedClassifierName>
+              <transformers>
+                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                  <mainClass>app.dbx.jdbc.DbxJdbcPlugin</mainClass>
+                </transformer>
+              </transformers>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>
diff --git a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java
new file mode 100644
index 0000000..7aa12c1
--- /dev/null
+++ b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java
@@ -0,0 +1,2591 @@
+package app.dbx.jdbc;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.Date;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.DriverPropertyInfo;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
+import java.lang.reflect.Method;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.time.temporal.TemporalAccessor;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Properties;
+import java.util.ServiceLoader;
+import java.util.Set;
+import java.util.UUID;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+public final class DbxJdbcPlugin {
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+    private static final int MAX_ROWS = 10_000;
+    private static final String[] DEFAULT_TABLE_TYPES = new String[] {
+        "TABLE",
+        "VIEW",
+        "BASE TABLE",
+        "MATERIALIZED VIEW",
+        "SYSTEM TABLE",
+        "SYSTEM VIEW"
+    };
+    private static final JdbcDriverQuirks DEFAULT_QUIRKS = new JdbcDriverQuirks(
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        StatementMaxRowsMode.READ_LOOP_ONLY
+    );
+    private static final JdbcDriverQuirks USE_CATALOG_QUIRKS = DEFAULT_QUIRKS.withUseCatalogFallbackSql(true);
+    private static final JdbcDriverQuirks KINGBASE_QUIRKS = DEFAULT_QUIRKS.withIgnoreCatalogForSchemaMetadata(true);
+    private static final JdbcDriverQuirks TAOS_QUIRKS = DEFAULT_QUIRKS.withPreferExecuteQueryForResultSetSql(true);
+    private static final JdbcDriverQuirks YASHAN_QUIRKS = new JdbcDriverQuirks(
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        StatementMaxRowsMode.APPLY_STATEMENT_MAX_ROWS
+    );
+    private static final JdbcDriverQuirks IRIS_QUIRKS = new JdbcDriverQuirks(
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        StatementMaxRowsMode.READ_LOOP_ONLY
+    );
+    private static final JdbcDriverQuirks ORACLE_QUIRKS = new JdbcDriverQuirks(
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        StatementMaxRowsMode.APPLY_STATEMENT_MAX_ROWS
+    );
+    private static final List<JdbcDriverQuirkRule> DRIVER_QUIRK_RULES = List.of(
+        new JdbcDriverQuirkRule("jdbc:mysql:", USE_CATALOG_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:mariadb:", USE_CATALOG_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:starrocks:", USE_CATALOG_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:doris:", USE_CATALOG_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:hive2:", USE_CATALOG_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:kingbase", KINGBASE_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:yasdb:", YASHAN_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:iris:", IRIS_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:oracle:", ORACLE_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:dm:", ORACLE_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:taos:", TAOS_QUIRKS),
+        new JdbcDriverQuirkRule("jdbc:taos-ws:", TAOS_QUIRKS)
+    );
+    private static String registeredDriverKey = "";
+    private static String sharedConnectionKey = "";
+    private static Connection sharedConnection;
+    private static final Map<String, QuerySession> QUERY_SESSIONS = new HashMap<>();
+
+    record JdbcDriverQuirks(
+        boolean skipExecutionContext,
+        boolean useOracleMetadata,
+        boolean caseInsensitiveSchemaMetadata,
+        boolean useCatalogFallbackSql,
+        boolean ignoreCatalogForSchemaMetadata,
+        boolean preferExecuteQueryForResultSetSql,
+        StatementMaxRowsMode statementMaxRowsMode
+    ) {
+        JdbcDriverQuirks withUseCatalogFallbackSql(boolean value) {
+            return new JdbcDriverQuirks(
+                skipExecutionContext,
+                useOracleMetadata,
+                caseInsensitiveSchemaMetadata,
+                value,
+                ignoreCatalogForSchemaMetadata,
+                preferExecuteQueryForResultSetSql,
+                statementMaxRowsMode
+            );
+        }
+
+        JdbcDriverQuirks withIgnoreCatalogForSchemaMetadata(boolean value) {
+            return new JdbcDriverQuirks(
+                skipExecutionContext,
+                useOracleMetadata,
+                caseInsensitiveSchemaMetadata,
+                useCatalogFallbackSql,
+                value,
+                preferExecuteQueryForResultSetSql,
+                statementMaxRowsMode
+            );
+        }
+
+        JdbcDriverQuirks withPreferExecuteQueryForResultSetSql(boolean value) {
+            return new JdbcDriverQuirks(
+                skipExecutionContext,
+                useOracleMetadata,
+                caseInsensitiveSchemaMetadata,
+                useCatalogFallbackSql,
+                ignoreCatalogForSchemaMetadata,
+                value,
+                statementMaxRowsMode
+            );
+        }
+    }
+
+    enum StatementMaxRowsMode {
+        APPLY_STATEMENT_MAX_ROWS,
+        READ_LOOP_ONLY
+    }
+
+    private record JdbcDriverQuirkRule(String urlPrefix, JdbcDriverQuirks quirks) {
+    }
+
+    private DbxJdbcPlugin() {
+    }
+
+    public static void main(String[] args) throws Exception {
+        try (
+            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8));
+            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out, StandardCharsets.UTF_8))
+        ) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                if (line.isBlank()) {
+                    continue;
+                }
+                ObjectNode response = handleLine(line);
+                writer.write(MAPPER.writeValueAsString(response));
+                writer.newLine();
+                writer.flush();
+                if (response.path("_dbx_close").asBoolean(false)) {
+                    break;
+                }
+            }
+        } finally {
+            closeSharedConnection();
+        }
+    }
+
+    private static ObjectNode handleLine(String line) throws Exception {
+        JsonNode request = MAPPER.readTree(line);
+        JsonNode id = request.path("id");
+        ObjectNode response = MAPPER.createObjectNode();
+        response.set("id", id.isMissingNode() ? MAPPER.getNodeFactory().numberNode(1) : id);
+
+        try {
+            String method = requireText(request, "method");
+            JsonNode params = request.path("params");
+            JsonNode connection = params.path("connection");
+            if ("close".equals(method)) {
+                closeSharedConnection();
+                ObjectNode result = MAPPER.createObjectNode();
+                result.put("ok", true);
+                response.set("result", result);
+                response.put("_dbx_close", true);
+                return response;
+            }
+            registerDrivers(connection);
+            response.set("result", handle(method, params, connection));
+        } catch (Throwable error) {
+            // The plugin protocol boundary must report linkage errors from vendor drivers instead of exiting silently.
+            ObjectNode errorNode = MAPPER.createObjectNode();
+            errorNode.put("message", throwableMessage(error));
+            response.set("error", errorNode);
+        }
+        return response;
+    }
+
+    private static String throwableMessage(Throwable error) {
+        Throwable cause = error;
+        while (cause.getCause() != null && cause.getCause() != cause) {
+            cause = cause.getCause();
+        }
+        return cause.getMessage() == null ? cause.toString() : cause.getMessage();
+    }
+
+    private static JsonNode handle(String method, JsonNode params, JsonNode connection) throws Exception {
+        return switch (method) {
+            case "testConnection", "connect" -> {
+                openConnection(connection);
+                ObjectNode result = MAPPER.createObjectNode();
+                result.put("ok", true);
+                yield result;
+            }
+            case "executeQuery" -> executeQuery(
+                connection,
+                requireText(params, "sql"),
+                optionalText(params, "database"),
+                optionalText(params, "schema"),
+                positiveInt(params, "maxRows", MAX_ROWS),
+                nonNegativeInt(params, "fetchSize", 0),
+                nonNegativeInt(params, "timeoutSecs", -1)
+            );
+            case "executeQueryPage", "execute_query_page" -> executeQueryPage(
+                connection,
+                requireText(params, "sql"),
+                optionalText(params, "database"),
+                optionalText(params, "schema"),
+                positiveInt(params, "pageSize", 100),
+                positiveInt(params, "maxRows", MAX_ROWS),
+                nonNegativeInt(params, "fetchSize", 0),
+                nonNegativeInt(params, "timeoutSecs", -1)
+            );
+            case "fetchQueryPage", "fetch_query_page" -> fetchQueryPage(
+                requireText(params, "sessionId"),
+                positiveInt(params, "pageSize", 100)
+            );
+            case "closeQuerySession", "close_query_session" -> closeQuerySessionResult(requireText(params, "sessionId"));
+            case "listDatabases" -> listDatabases(connection);
+            case "listSchemas" -> listSchemas(connection, optionalText(params, "database"));
+            case "listTables" -> listTables(
+                connection,
+                optionalText(params, "database"),
+                optionalText(params, "schema"),
+                optionalText(params, "filter"),
+                nonNegativeInt(params, "limit", 0),
+                nonNegativeInt(params, "offset", 0),
+                optionalStringList(params, "object_types")
+            );
+            case "listObjects", "list_objects" -> listObjects(
+                connection,
+                optionalText(params, "database"),
+                optionalText(params, "schema"),
+                optionalText(params, "filter"),
+                nonNegativeInt(params, "limit", 0),
+                nonNegativeInt(params, "offset", 0),
+                optionalStringList(params, "object_types")
+            );
+            case "listDataTypes", "list_data_types" -> listDataTypes(connection, optionalText(params, "database"));
+            case "getObjectSource", "get_object_source" -> getObjectSource(
+                connection,
+                optionalText(params, "database"),
+                optionalText(params, "schema"),
+                requireText(params, "name"),
+                requireText(params, "object_type")
+            );
+            case "getColumns" -> getColumns(
+                connection,
+                optionalText(params, "database"),
+                optionalText(params, "schema"),
+                requireText(params, "table")
+            );
+            case "getExplainInfo" -> getExplainInfo(
+                connection,
+                requireText(params, "sql"),
+                optionalText(params, "database"),
+                optionalText(params, "schema"),
+                nonNegativeInt(params, "timeoutSecs", -1),
+                optionalText(params, "mode")
+            );
+            default -> throw new IllegalArgumentException("Unsupported JDBC plugin method: " + method);
+        };
+    }
+
+    private static void registerDrivers(JsonNode connection) throws Exception {
+        String driverKey = driverKey(connection);
+        if (driverKey.equals(registeredDriverKey)) {
+            return;
+        }
+        closeSharedConnection();
+        List<URL> urls = new ArrayList<>();
+        JsonNode paths = connection.path("jdbc_driver_paths");
+        if (paths.isArray()) {
+            for (JsonNode path : paths) {
+                String value = path.asText("").trim();
+                if (!value.isEmpty()) {
+                    urls.add(expandHome(value).toUri().toURL());
+                }
+            }
+        }
+
+        ClassLoader loader = urls.isEmpty()
+            ? Thread.currentThread().getContextClassLoader()
+            : new URLClassLoader(urls.toArray(URL[]::new), DbxJdbcPlugin.class.getClassLoader());
+        Thread.currentThread().setContextClassLoader(loader);
+
+        String driverClass = optionalText(connection, "jdbc_driver_class");
+        if (driverClass != null) {
+            Driver driver = (Driver) Class.forName(driverClass, true, loader).getDeclaredConstructor().newInstance();
+            DriverManager.registerDriver(new DriverShim(driver));
+            registeredDriverKey = driverKey;
+            return;
+        }
+
+        boolean loaded = false;
+        for (Driver driver : ServiceLoader.load(Driver.class, loader)) {
+            DriverManager.registerDriver(new DriverShim(driver));
+            loaded = true;
+        }
+        if (!loaded && !urls.isEmpty()) {
+            throw new IllegalArgumentException("No JDBC driver was discovered. Enter the driver class name for this JAR.");
+        }
+        registeredDriverKey = driverKey;
+    }
+
+    private static Connection openConnection(JsonNode connection) throws SQLException {
+        String url = jdbcUrl(connection);
+        if (url == null) {
+            throw new IllegalArgumentException("JDBC URL is required.");
+        }
+        String key = connectionKey(connection);
+        if (sharedConnection != null && key.equals(sharedConnectionKey) && !sharedConnection.isClosed()) {
+            return sharedConnection;
+        }
+        closeSharedConnection();
+
+        JdbcUrlCredentials urlCredentials = extractJdbcUrlCredentials(url);
+        url = urlCredentials.url;
+        Properties properties = new Properties();
+        String username = optionalText(connection, "username");
+        String password = optionalText(connection, "password");
+        if (username == null) {
+            username = urlCredentials.username;
+        }
+        if (password == null) {
+            password = urlCredentials.password;
+        }
+        if (username != null) {
+            properties.setProperty("user", username);
+        }
+        if (password != null) {
+            properties.setProperty("password", password);
+        }
+        applyConnectTimeout(connection, properties);
+        if (isOracleUrl(url)) {
+            applyOracleProperties(connection, properties);
+        }
+        sharedConnection = DriverManager.getConnection(url, properties);
+        sharedConnectionKey = key;
+        return sharedConnection;
+    }
+
+    private static void applyConnectTimeout(JsonNode connection, Properties properties) {
+        int connectTimeoutSecs = positiveInt(connection, "connect_timeout_secs", 30);
+        DriverManager.setLoginTimeout(connectTimeoutSecs);
+        if (isPrestoOrTrinoConnection(connection)) {
+            return;
+        }
+        String value = Integer.toString(connectTimeoutSecs);
+        properties.putIfAbsent("loginTimeout", value);
+        properties.putIfAbsent("connectTimeout", value);
+    }
+
+    private static boolean isPrestoOrTrinoConnection(JsonNode connection) {
+        String url = jdbcUrl(connection);
+        if (urlMatchesPrefix(url, "jdbc:presto:") || urlMatchesPrefix(url, "jdbc:trino:")) {
+            return true;
+        }
+        String driverClass = optionalText(connection, "jdbc_driver_class");
+        if (driverClass == null) {
+            return false;
+        }
+        String normalized = driverClass.toLowerCase(Locale.ROOT);
+        return normalized.equals("io.prestosql.jdbc.prestodriver") ||
+            normalized.equals("com.facebook.presto.jdbc.prestodriver") ||
+            normalized.equals("io.trino.jdbc.trinodriver");
+    }
+
+    private static void applyOracleProperties(JsonNode connection, Properties properties) {
+        properties.putIfAbsent("remarksReporting", "false");
+        properties.putIfAbsent("restrictGetTables", "true");
+        properties.putIfAbsent("includeSynonyms", "false");
+        properties.putIfAbsent("oracle.jdbc.defaultRowPrefetch", "100");
+        if (connection.path("sysdba").asBoolean(false)) {
+            properties.putIfAbsent("internal_logon", "sysdba");
+        }
+    }
+
+    private static JsonNode executeQuery(
+        JsonNode connection,
+        String sql,
+        String database,
+        String schema,
+        int maxRows,
+        int fetchSize,
+        int timeoutSecs
+    ) throws Exception {
+        long start = System.nanoTime();
+        Connection conn = openConnection(connection);
+        applyExecutionContext(connection, conn, database, schema);
+        JdbcDriverQuirks quirks = driverQuirks(connection);
+        try (Statement statement = conn.createStatement()) {
+            applyStatementOptions(statement, maxRows, fetchSize, timeoutSecs, quirks);
+            String trimmedSql = trimStatementSql(sql);
+            ExecutedStatement executed = executeStatementForResult(statement, trimmedSql, quirks);
+            ObjectNode result = MAPPER.createObjectNode();
+            ArrayNode columns = MAPPER.createArrayNode();
+            ArrayNode rows = MAPPER.createArrayNode();
+            boolean truncated = false;
+
+            try (ResultSet rs = executed.resultSet()) {
+                if (rs != null) {
+                    ResultSetMetaData meta = rs.getMetaData();
+                    int columnCount = meta.getColumnCount();
+                    for (int i = 1; i <= columnCount; i++) {
+                        String label = meta.getColumnLabel(i);
+                        columns.add(label == null || label.isBlank() ? meta.getColumnName(i) : label);
+                    }
+                    while (rs.next()) {
+                        if (rows.size() >= maxRows) {
+                            truncated = true;
+                            break;
+                        }
+                        ArrayNode row = MAPPER.createArrayNode();
+                        for (int i = 1; i <= columnCount; i++) {
+                            row.add(MAPPER.valueToTree(readValue(rs, meta, i)));
+                        }
+                        rows.add(row);
+                    }
+                }
+            }
+
+            result.set("columns", columns);
+            result.set("rows", rows);
+            result.put("affected_rows", columns.isEmpty() ? Math.max(executed.updateCount(), 0) : 0);
+            result.put("execution_time_ms", (System.nanoTime() - start) / 1_000_000);
+            result.put("truncated", truncated);
+            return result;
+        }
+    }
+
+    private record ExecutedStatement(ResultSet resultSet, int updateCount) {
+    }
+
+    private static final class QuerySession {
+        private final String id;
+        private final Statement statement;
+        private final ResultSet resultSet;
+        private final ResultSetMetaData meta;
+        private final ArrayNode columns;
+        private final int maxRows;
+        private final long startNanos;
+        private int rowsReturned;
+        private ArrayNode pendingRow;
+
+        private QuerySession(
+            String id,
+            Statement statement,
+            ResultSet resultSet,
+            ResultSetMetaData meta,
+            ArrayNode columns,
+            int maxRows,
+            long startNanos
+        ) {
+            this.id = id;
+            this.statement = statement;
+            this.resultSet = resultSet;
+            this.meta = meta;
+            this.columns = columns;
+            this.maxRows = Math.max(1, maxRows);
+            this.startNanos = startNanos;
+        }
+    }
+
+    private static JsonNode executeQueryPage(
+        JsonNode connection,
+        String sql,
+        String database,
+        String schema,
+        int pageSize,
+        int maxRows,
+        int fetchSize,
+        int timeoutSecs
+    ) throws Exception {
+        long start = System.nanoTime();
+        Connection conn = openConnection(connection);
+        applyExecutionContext(connection, conn, database, schema);
+        JdbcDriverQuirks quirks = driverQuirks(connection);
+        Statement statement = conn.createStatement();
+        try {
+            applyStatementOptions(statement, maxRows, fetchSize, timeoutSecs, quirks);
+            String trimmedSql = trimStatementSql(sql);
+            ExecutedStatement executed = executeStatementForResult(statement, trimmedSql, quirks);
+            ResultSet rs = executed.resultSet();
+            if (rs == null) {
+                ObjectNode result = MAPPER.createObjectNode();
+                result.set("columns", MAPPER.createArrayNode());
+                result.set("rows", MAPPER.createArrayNode());
+                result.put("affected_rows", Math.max(executed.updateCount(), 0));
+                result.put("execution_time_ms", (System.nanoTime() - start) / 1_000_000);
+                result.put("truncated", false);
+                result.putNull("session_id");
+                result.put("has_more", false);
+                statement.close();
+                return result;
+            }
+
+            ResultSetMetaData meta = rs.getMetaData();
+            ArrayNode columns = MAPPER.createArrayNode();
+            int columnCount = meta.getColumnCount();
+            for (int i = 1; i <= columnCount; i++) {
+                String label = meta.getColumnLabel(i);
+                columns.add(label == null || label.isBlank() ? meta.getColumnName(i) : label);
+            }
+            String sessionId = UUID.randomUUID().toString();
+            QuerySession session = new QuerySession(sessionId, statement, rs, meta, columns, maxRows, start);
+            QUERY_SESSIONS.put(sessionId, session);
+            return readQuerySessionPage(session, pageSize);
+        } catch (Exception error) {
+            try {
+                statement.close();
+            } catch (Exception ignored) {
+            }
+            throw error;
+        }
+    }
+
+    private static JsonNode fetchQueryPage(String sessionId, int pageSize) throws SQLException {
+        QuerySession session = QUERY_SESSIONS.get(sessionId);
+        if (session == null) {
+            throw new IllegalArgumentException("Unknown query session: " + sessionId);
+        }
+        return readQuerySessionPage(session, pageSize);
+    }
+
+    private static JsonNode readQuerySessionPage(QuerySession session, int pageSize) throws SQLException {
+        int effectivePageSize = Math.max(1, pageSize);
+        ArrayNode rows = MAPPER.createArrayNode();
+        boolean truncated = false;
+
+        while (rows.size() < effectivePageSize && session.rowsReturned < session.maxRows) {
+            ArrayNode row;
+            if (session.pendingRow != null) {
+                row = session.pendingRow;
+                session.pendingRow = null;
+            } else {
+                if (!session.resultSet.next()) {
+                    closeQuerySession(session.id);
+                    return queryPageResult(session, rows, false, false);
+                }
+                row = readRow(session.resultSet, session.meta);
+            }
+            rows.add(row);
+            session.rowsReturned++;
+        }
+
+        if (session.rowsReturned >= session.maxRows) {
+            truncated = session.pendingRow != null || session.resultSet.next();
+            closeQuerySession(session.id);
+            return queryPageResult(session, rows, truncated, false);
+        }
+
+        boolean hasMore = session.resultSet.next();
+        if (!hasMore) {
+            closeQuerySession(session.id);
+            return queryPageResult(session, rows, false, false);
+        }
+
+        session.pendingRow = readRow(session.resultSet, session.meta);
+        return queryPageResult(session, rows, false, true);
+    }
+
+    private static ObjectNode queryPageResult(QuerySession session, ArrayNode rows, boolean truncated, boolean hasMore) {
+        ObjectNode result = MAPPER.createObjectNode();
+        result.set("columns", session.columns.deepCopy());
+        result.set("rows", rows);
+        result.put("affected_rows", 0);
+        result.put("execution_time_ms", (System.nanoTime() - session.startNanos) / 1_000_000);
+        result.put("truncated", truncated);
+        if (hasMore) {
+            result.put("session_id", session.id);
+        } else {
+            result.putNull("session_id");
+        }
+        result.put("has_more", hasMore);
+        return result;
+    }
+
+    private static ObjectNode closeQuerySessionResult(String sessionId) {
+        ObjectNode result = MAPPER.createObjectNode();
+        result.put("ok", closeQuerySession(sessionId));
+        return result;
+    }
+
+    private static boolean closeQuerySession(String sessionId) {
+        QuerySession session = QUERY_SESSIONS.remove(sessionId);
+        if (session == null) {
+            return false;
+        }
+        try {
+            session.resultSet.close();
+        } catch (Exception ignored) {
+        }
+        try {
+            session.statement.close();
+        } catch (Exception ignored) {
+        }
+        return true;
+    }
+
+    private static void closeAllQuerySessions() {
+        List<String> sessionIds = new ArrayList<>(QUERY_SESSIONS.keySet());
+        for (String sessionId : sessionIds) {
+            closeQuerySession(sessionId);
+        }
+    }
+
+    private static ArrayNode readRow(ResultSet rs, ResultSetMetaData meta) throws SQLException {
+        ArrayNode row = MAPPER.createArrayNode();
+        for (int i = 1; i <= meta.getColumnCount(); i++) {
+            row.add(MAPPER.valueToTree(readValue(rs, meta, i)));
+        }
+        return row;
+    }
+
+    private static ExecutedStatement executeStatementForResult(
+        Statement statement,
+        String sql,
+        JdbcDriverQuirks quirks
+    ) throws SQLException {
+        if (quirks.preferExecuteQueryForResultSetSql() && looksLikeResultSetSql(sql)) {
+            return new ExecutedStatement(statement.executeQuery(sql), -1);
+        }
+        boolean hasResultSet = statement.execute(sql);
+        int updateCount = hasResultSet ? -1 : statement.getUpdateCount();
+        ResultSet rs = hasResultSet ? statement.getResultSet() : null;
+        if (rs == null && shouldRetryWithExecuteQuery(sql, hasResultSet, updateCount)) {
+            rs = statement.executeQuery(sql);
+        }
+        return new ExecutedStatement(rs, updateCount);
+    }
+
+    private static boolean shouldRetryWithExecuteQuery(String sql, boolean hasResultSet, int updateCount) {
+        if (hasResultSet) {
+            return true;
+        }
+        return updateCount < 0 && looksLikeResultSetSql(sql);
+    }
+
+    static boolean looksLikeResultSetSql(String sql) {
+        String keyword = firstSqlKeyword(sql);
+        return switch (keyword) {
+            case "SELECT", "WITH", "SHOW", "DESCRIBE", "DESC", "EXPLAIN", "VALUES", "TABLE", "PRAGMA" -> true;
+            default -> false;
+        };
+    }
+
+    private static String firstSqlKeyword(String sql) {
+        String text = stripLeadingSqlComments(sql).trim();
+        int end = 0;
+        while (end < text.length() && Character.isLetter(text.charAt(end))) {
+            end++;
+        }
+        return text.substring(0, end).toUpperCase(Locale.ROOT);
+    }
+
+    private static String stripLeadingSqlComments(String sql) {
+        String text = sql.trim();
+        boolean changed;
+        do {
+            changed = false;
+            if (text.startsWith("--")) {
+                int lineEnd = text.indexOf('\n');
+                if (lineEnd < 0) {
+                    return "";
+                }
+                text = text.substring(lineEnd + 1).trim();
+                changed = true;
+            } else if (text.startsWith("/*")) {
+                int commentEnd = text.indexOf("*/", 2);
+                if (commentEnd < 0) {
+                    return "";
+                }
+                text = text.substring(commentEnd + 2).trim();
+                changed = true;
+            }
+        } while (changed);
+        return text;
+    }
+
+    /**
+     * Get DM execution plan using DmdbConnection.getExplainInfo() via reflection.
+     *
+     * Two modes:
+     *   mode="explain" (default) — dmConn.getExplainInfo(sqlStr) — direct plan, no execution
+     *   mode="autotrace"         — execute SQL, then dmConn.getExplainInfo(stmt) — actual stats
+     *
+     * Falls back to standard EXPLAIN if DM driver is not available.
+     */
+    private static JsonNode getExplainInfo(
+        JsonNode connection,
+        String sql,
+        String database,
+        String schema,
+        int timeoutSecs,
+        String mode
+    ) throws Exception {
+        Connection conn = openConnection(connection);
+        applyExecutionContext(connection, conn, database, schema);
+
+        boolean autotrace = "autotrace".equalsIgnoreCase(mode);
+        String planText = null;
+        String dmMethod = null;
+
+        if (autotrace) {
+            if (!isSafeAutotraceSql(sql)) {
+                throw new IllegalArgumentException("unsafe");
+            }
+            // ── Autotrace mode: execute SQL first, then getExplainInfo(stmt) ──
+            boolean monitorEnabled = false;
+            try (Statement s = conn.createStatement()) {
+                s.execute("SF_SET_SESSION_PARA_VALUE('MONITOR_SQL_EXEC', 1)");
+                monitorEnabled = true;
+            } catch (Exception ignored) {}
+
+            try {
+                try (Statement stmt = conn.createStatement()) {
+                    if (timeoutSecs >= 0) {
+                        try { stmt.setQueryTimeout(timeoutSecs); } catch (SQLFeatureNotSupportedException | UnsupportedOperationException ignored) {}
+                    }
+                    boolean hasResultSet = stmt.execute(trimStatementSql(sql));
+                    if (hasResultSet) {
+                        try (ResultSet rs = stmt.getResultSet()) {
+                            while (rs.next()) { /* consume */ }
+                        }
+                    }
+
+                    // Try DM getExplainInfo(Statement)
+                    try {
+                        Class<?> dmConnClass = Class.forName("dm.jdbc.driver.DmdbConnection");
+                        if (dmConnClass.isInstance(conn)) {
+                            Method m = dmConnClass.getMethod("getExplainInfo", Statement.class);
+                            planText = (String) m.invoke(dmConnClass.cast(conn), stmt);
+                            dmMethod = "getExplainInfo(stmt)";
+                        }
+                    } catch (ClassNotFoundException | NoSuchMethodException e) {
+                        // Not DM or DM driver version doesn't support it
+                    }
+                }
+            } finally {
+                if (monitorEnabled) {
+                    try (Statement s = conn.createStatement()) {
+                        s.execute("SF_SET_SESSION_PARA_VALUE('MONITOR_SQL_EXEC', 0)");
+                    } catch (Exception ignored) {}
+                }
+            }
+        } else {
+            // ── Explain mode: direct plan via getExplainInfo(sqlStr), no execution ──
+            try {
+                Class<?> dmConnClass = Class.forName("dm.jdbc.driver.DmdbConnection");
+                if (dmConnClass.isInstance(conn)) {
+                    Method m = dmConnClass.getMethod("getExplainInfo", String.class);
+                    planText = (String) m.invoke(dmConnClass.cast(conn), sql);
+                    dmMethod = "getExplainInfo(sql)";
+                }
+            } catch (ClassNotFoundException | NoSuchMethodException e) {
+                // Not DM or DM driver version doesn't support it
+            }
+        }
+
+        // Fallback: if DM method didn't work, try standard EXPLAIN
+        if (planText == null || planText.trim().isEmpty()) {
+            try (Statement explainStmt = conn.createStatement();
+                 ResultSet rs = explainStmt.executeQuery("EXPLAIN " + sql)) {
+                StringBuilder sb = new StringBuilder();
+                while (rs.next()) {
+                    sb.append(rs.getString(1)).append("\n");
+                }
+                planText = sb.toString().trim();
+            }
+            dmMethod = "explain(sql)";
+        }
+
+        ObjectNode result = MAPPER.createObjectNode();
+        result.put("ok", true);
+        result.put("plan", planText != null ? planText : "");
+        result.put("has_actual_stats", "getExplainInfo(stmt)".equals(dmMethod));
+        result.put("mode", autotrace ? "autotrace" : "explain");
+        return result;
+    }
+
+    private static void applyStatementOptions(
+        Statement statement,
+        int maxRows,
+        int fetchSize,
+        int timeoutSecs,
+        JdbcDriverQuirks quirks
+    )
+        throws SQLException {
+        if (quirks.statementMaxRowsMode() == StatementMaxRowsMode.APPLY_STATEMENT_MAX_ROWS) {
+            statement.setMaxRows((int) Math.min(Integer.MAX_VALUE, (long) maxRows + 1L));
+        }
+        if (fetchSize > 0) {
+            try {
+                statement.setFetchSize(fetchSize);
+            } catch (SQLFeatureNotSupportedException | UnsupportedOperationException ignored) {
+            }
+        }
+        if (timeoutSecs >= 0) {
+            try {
+                statement.setQueryTimeout(timeoutSecs);
+            } catch (SQLFeatureNotSupportedException | UnsupportedOperationException ignored) {
+            }
+        }
+    }
+
+    private static String trimStatementSql(String sql) {
+        return sql == null ? "" : sql.trim().replaceFirst(";\\s*$", "");
+    }
+
+    private static boolean isSafeAutotraceSql(String sql) {
+        String stripped = stripCommentsAndLiterals(trimStatementSql(sql));
+        if (stripped.isBlank()) {
+            return false;
+        }
+        String[] statements = stripped.split(";", -1);
+        for (int i = 1; i < statements.length; i++) {
+            if (!statements[i].isBlank()) {
+                return false;
+            }
+        }
+        String lower = statements[0].stripLeading().toLowerCase(Locale.ROOT);
+        boolean readOnly = lower.equals("select")
+            || lower.startsWith("select ")
+            || lower.startsWith("select\n")
+            || lower.equals("with")
+            || lower.startsWith("with ")
+            || lower.startsWith("with\n")
+            || lower.equals("table")
+            || lower.startsWith("table ")
+            || lower.startsWith("table\n")
+            || lower.equals("values")
+            || lower.startsWith("values ")
+            || lower.startsWith("values\n");
+        if (!readOnly) {
+            return false;
+        }
+        for (String keyword : new String[] {"drop", "delete", "truncate", "alter", "update", "merge", "replace", "insert", "create"}) {
+            if (containsWord(lower, keyword)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    private static boolean containsWord(String source, String word) {
+        int index = source.indexOf(word);
+        while (index >= 0) {
+            boolean before = index == 0 || !isIdentifierChar(source.charAt(index - 1));
+            int afterIndex = index + word.length();
+            boolean after = afterIndex >= source.length() || !isIdentifierChar(source.charAt(afterIndex));
+            if (before && after) {
+                return true;
+            }
+            index = source.indexOf(word, index + 1);
+        }
+        return false;
+    }
+
+    private static boolean isIdentifierChar(char ch) {
+        return Character.isLetterOrDigit(ch) || ch == '_';
+    }
+
+    private static String stripCommentsAndLiterals(String sql) {
+        StringBuilder output = new StringBuilder(sql.length());
+        boolean inLineComment = false;
+        boolean inBlockComment = false;
+        boolean inSingleQuote = false;
+        boolean inDoubleQuote = false;
+
+        for (int i = 0; i < sql.length(); i++) {
+            char ch = sql.charAt(i);
+            char next = i + 1 < sql.length() ? sql.charAt(i + 1) : '\0';
+
+            if (inLineComment) {
+                if (ch == '\n') {
+                    inLineComment = false;
+                    output.append(' ');
+                }
+                continue;
+            }
+            if (inBlockComment) {
+                if (ch == '*' && next == '/') {
+                    i++;
+                    inBlockComment = false;
+                    output.append(' ');
+                }
+                continue;
+            }
+            if (inSingleQuote) {
+                if (ch == '\'' && next == '\'') {
+                    i++;
+                } else if (ch == '\'') {
+                    inSingleQuote = false;
+                }
+                output.append(' ');
+                continue;
+            }
+            if (inDoubleQuote) {
+                if (ch == '"' && next == '"') {
+                    i++;
+                } else if (ch == '"') {
+                    inDoubleQuote = false;
+                }
+                output.append(' ');
+                continue;
+            }
+
+            if (ch == '-' && next == '-') {
+                i++;
+                inLineComment = true;
+                continue;
+            }
+            if (ch == '#') {
+                inLineComment = true;
+                continue;
+            }
+            if (ch == '/' && next == '*') {
+                i++;
+                inBlockComment = true;
+                continue;
+            }
+            if (ch == '\'') {
+                inSingleQuote = true;
+                output.append(' ');
+                continue;
+            }
+            if (ch == '"') {
+                inDoubleQuote = true;
+                output.append(' ');
+                continue;
+            }
+            output.append(ch);
+        }
+        return output.toString();
+    }
+
+    private static void applyExecutionContext(JsonNode connection, Connection conn, String database, String schema) throws SQLException {
+        if (driverQuirks(connection).skipExecutionContext()) {
+            return;
+        }
+        String catalog = emptyToNull(database);
+        if (catalog != null) {
+            try {
+                conn.setCatalog(catalog);
+            } catch (SQLFeatureNotSupportedException | AbstractMethodError | UnsupportedOperationException ignored) {
+            }
+            if (driverQuirks(connection).useCatalogFallbackSql()) {
+                applyUseCatalogFallback(conn, catalog);
+            }
+        }
+        if (schema != null) {
+            try {
+                conn.setSchema(schema);
+            } catch (SQLFeatureNotSupportedException | AbstractMethodError | UnsupportedOperationException ignored) {
+            }
+        }
+    }
+
+    private static void applyUseCatalogFallback(Connection conn, String catalog) {
+        try (Statement statement = conn.createStatement()) {
+            statement.execute("USE " + quoteJdbcIdentifier(catalog));
+        } catch (SQLException | AbstractMethodError | UnsupportedOperationException ignored) {
+        }
+    }
+
+    private static String quoteJdbcIdentifier(String identifier) {
+        if (identifier != null && identifier.matches("[A-Za-z_][A-Za-z0-9_]*")) {
+            return identifier;
+        }
+        return "`" + identifier.replace("`", "``") + "`";
+    }
+
+    static JdbcDriverQuirks driverQuirks(JsonNode connection) {
+        String url = optionalText(connection, "connection_string");
+        for (JdbcDriverQuirkRule rule : DRIVER_QUIRK_RULES) {
+            if (urlMatchesPrefix(url, rule.urlPrefix())) {
+                return rule.quirks();
+            }
+        }
+        if (isKyuubiDriver(connection)) {
+            return USE_CATALOG_QUIRKS;
+        }
+        return DEFAULT_QUIRKS;
+    }
+
+    private static boolean isKyuubiDriver(JsonNode connection) {
+        String driverClass = optionalText(connection, "jdbc_driver_class");
+        if (driverClass != null && driverClass.toLowerCase(Locale.ROOT).contains("kyuubi")) {
+            return true;
+        }
+        JsonNode paths = connection.path("jdbc_driver_paths");
+        if (!paths.isArray()) {
+            return false;
+        }
+        for (JsonNode path : paths) {
+            if (path.asText("").toLowerCase(Locale.ROOT).contains("kyuubi")) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static boolean urlMatchesPrefix(String url, String prefix) {
+        return url != null && url.regionMatches(true, 0, prefix, 0, prefix.length());
+    }
+
+    private static JsonNode listDatabases(JsonNode connection) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        Connection conn = openConnection(connection);
+        if (driverQuirks(connection).useOracleMetadata()) {
+            return result;
+        }
+        try (ResultSet rs = conn.getMetaData().getCatalogs()) {
+            while (rs.next()) {
+                String name = rs.getString("TABLE_CAT");
+                addDatabase(result, name);
+            }
+        }
+        addDatabase(result, optionalText(connection, "database"));
+        try {
+            addDatabase(result, conn.getCatalog());
+        } catch (SQLFeatureNotSupportedException | AbstractMethodError | UnsupportedOperationException ignored) {
+        }
+        return result;
+    }
+
+    private static void addDatabase(ArrayNode result, String name) {
+        if (name == null || name.isBlank()) {
+            return;
+        }
+        for (JsonNode item : result) {
+            if (name.equals(item.path("name").asText())) {
+                return;
+            }
+        }
+        ObjectNode item = MAPPER.createObjectNode();
+        item.put("name", name);
+        result.add(item);
+    }
+
+    private static JsonNode listSchemas(JsonNode connection, String database) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        Connection conn = openConnection(connection);
+        JdbcDriverQuirks quirks = driverQuirks(connection);
+        String catalog = metadataCatalog(database, quirks);
+        if (quirks.useOracleMetadata()) {
+            return oracleListSchemas(conn);
+        }
+        DatabaseMetaData meta = conn.getMetaData();
+        if (quirks.caseInsensitiveSchemaMetadata()) {
+            try (ResultSet rs = meta.getSchemas(catalog, null)) {
+                appendSchemas(result, rs, true);
+            } catch (SQLException ignored) {
+                try (ResultSet rs = meta.getSchemas()) {
+                    appendSchemas(result, rs, true);
+                }
+            }
+            try (ResultSet rs = meta.getSchemas(null, null)) {
+                appendSchemas(result, rs, true);
+            } catch (SQLException ignored) {
+            }
+        } else {
+            try (ResultSet rs = meta.getSchemas(catalog, null)) {
+                appendSchemas(result, rs, false);
+            } catch (SQLFeatureNotSupportedException | UnsupportedOperationException ignored) {
+                try (ResultSet rs = meta.getSchemas()) {
+                    appendSchemas(result, rs, false);
+                }
+            }
+            if (result.isEmpty() && catalog != null) {
+                try (ResultSet rs = meta.getSchemas(null, null)) {
+                    appendSchemas(result, rs, false);
+                } catch (SQLFeatureNotSupportedException | UnsupportedOperationException ignored) {
+                }
+            }
+        }
+        if (result.isEmpty()) {
+            try {
+                String schema = conn.getSchema();
+                if (schema != null) {
+                    addSchema(result, schema, quirks.caseInsensitiveSchemaMetadata());
+                }
+            } catch (SQLFeatureNotSupportedException | AbstractMethodError | UnsupportedOperationException ignored) {
+            }
+        }
+        return result;
+    }
+
+    private static JsonNode listTables(
+        JsonNode connection,
+        String database,
+        String schema,
+        String filter,
+        int limit,
+        int offset,
+        List<String> objectTypes
+    ) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        Connection conn = openConnection(connection);
+        JdbcDriverQuirks quirks = driverQuirks(connection);
+        if (quirks.useOracleMetadata()) {
+            return filterMetadataNodes(
+                (ArrayNode) oracleListTables(conn, oracleEffectiveSchema(conn, schema)),
+                filter,
+                limit,
+                offset,
+                objectTypes,
+                "table_type",
+                true
+            );
+        }
+        if (usePrestoInformationSchemaTables(connection)) {
+            return prestoListTables(conn, database, schema, filter, limit, offset, objectTypes);
+        }
+        DatabaseMetaData meta = conn.getMetaData();
+        String[] types = constrainedJdbcTableTypes(jdbcTableTypes(meta), objectTypes);
+        if (types.length == 0) {
+            return result;
+        }
+        String catalog = metadataCatalog(database, quirks);
+        String schemaPattern = resolveSchemaPattern(meta, database, schema, quirks);
+        appendTables(result, meta, catalog, schemaPattern, types);
+        if (result.isEmpty() && catalog != null) {
+            appendTables(result, meta, null, schemaPattern, types);
+        }
+        return filterMetadataNodes(result, filter, limit, offset, objectTypes, "table_type", true);
+    }
+
+    private static JsonNode listObjects(
+        JsonNode connection,
+        String database,
+        String schema,
+        String filter,
+        int limit,
+        int offset,
+        List<String> objectTypes
+    ) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        Connection conn = openConnection(connection);
+        if (driverQuirks(connection).useOracleMetadata()) {
+            return filterMetadataNodes(
+                (ArrayNode) oracleListObjects(conn, oracleEffectiveSchema(conn, schema), schema),
+                filter,
+                limit,
+                offset,
+                objectTypes,
+                "object_type",
+                false
+            );
+        }
+        if (usePrestoInformationSchemaTables(connection)) {
+            return prestoListObjects(conn, database, schema, filter, limit, offset, objectTypes);
+        }
+        DatabaseMetaData meta = conn.getMetaData();
+        JdbcDriverQuirks quirks = driverQuirks(connection);
+        String catalog = metadataCatalog(database, quirks);
+        String schemaPattern = resolveSchemaPattern(meta, database, schema, quirks);
+
+        String[] tableTypes = constrainedJdbcTableTypes(jdbcTableTypes(meta), objectTypes);
+        if (tableTypes.length > 0) {
+            appendTableObjects(result, meta, catalog, schemaPattern, schema, tableTypes);
+            if (result.isEmpty() && catalog != null) {
+                appendTableObjects(result, meta, null, schemaPattern, schema, tableTypes);
+            }
+        }
+
+        try (ResultSet rs = meta.getProcedures(catalog, schemaPattern, "%")) {
+            while (rs.next()) {
+                ObjectNode item = MAPPER.createObjectNode();
+                item.put("name", rs.getString("PROCEDURE_NAME"));
+                item.put("object_type", "PROCEDURE");
+                putNullable(item, "schema", schema);
+                putNullable(item, "comment", rs.getString("REMARKS"));
+                result.add(item);
+            }
+        } catch (SQLException ignored) {
+        }
+
+        Set<String> procedureNames = new HashSet<>();
+        for (JsonNode node : result) {
+            if ("PROCEDURE".equals(node.path("object_type").asText())) {
+                procedureNames.add(node.path("name").asText());
+            }
+        }
+        try (ResultSet rs = meta.getFunctions(catalog, schemaPattern, "%")) {
+            while (rs.next()) {
+                String name = rs.getString("FUNCTION_NAME");
+                if (!procedureNames.contains(name)) {
+                    ObjectNode item = MAPPER.createObjectNode();
+                    item.put("name", name);
+                    item.put("object_type", "FUNCTION");
+                    putNullable(item, "schema", schema);
+                    putNullable(item, "comment", rs.getString("REMARKS"));
+                    result.add(item);
+                }
+            }
+        } catch (SQLException ignored) {
+        }
+
+        return filterMetadataNodes(result, filter, limit, offset, objectTypes, "object_type", false);
+    }
+
+    private static JsonNode listDataTypes(JsonNode connection, String database) throws SQLException {
+        Connection conn = openConnection(connection);
+        JdbcDriverQuirks quirks = driverQuirks(connection);
+        String catalog = metadataCatalog(database, quirks);
+        if (catalog != null) {
+            try {
+                conn.setCatalog(catalog);
+            } catch (SQLFeatureNotSupportedException | AbstractMethodError | UnsupportedOperationException ignored) {
+            }
+        }
+        ArrayNode result = MAPPER.createArrayNode();
+        Set<String> seen = new HashSet<>();
+        try (ResultSet rs = conn.getMetaData().getTypeInfo()) {
+            while (rs.next()) {
+                String name = rs.getString("TYPE_NAME");
+                if (name == null || name.isBlank()) {
+                    continue;
+                }
+                String trimmed = name.trim();
+                if (seen.add(trimmed.toLowerCase(Locale.ROOT))) {
+                    result.add(trimmed);
+                }
+            }
+        }
+        return result;
+    }
+
+    private static JsonNode getColumns(JsonNode connection, String database, String schema, String table) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        Connection conn = openConnection(connection);
+        if (driverQuirks(connection).useOracleMetadata()) {
+            return oracleGetColumns(conn, oracleEffectiveSchema(conn, schema), table);
+        }
+        if (isKingbaseUrl(optionalText(connection, "connection_string"))) {
+            return kingbaseGetColumns(conn, schema, table);
+        }
+        if (usePrestoInformationSchemaTables(connection)) {
+            return prestoGetColumns(conn, database, schema, table);
+        }
+        DatabaseMetaData meta = conn.getMetaData();
+        JdbcDriverQuirks quirks = driverQuirks(connection);
+        String catalog = metadataCatalog(database, quirks);
+        String schemaPattern = resolveSchemaPattern(meta, database, schema, quirks);
+        Set<String> primaryKeys = safePrimaryKeys(meta, catalog, schemaPattern, table);
+        appendColumns(result, meta, catalog, schemaPattern, table, primaryKeys);
+        if (result.isEmpty() && catalog != null) {
+            primaryKeys = safePrimaryKeys(meta, null, schemaPattern, table);
+            appendColumns(result, meta, null, schemaPattern, table, primaryKeys);
+        }
+        if (quirks.useCatalogFallbackSql()) {
+            mergeShowFullColumnMetadata(conn, result, schemaPattern, table);
+        }
+        return result;
+    }
+
+    private static void appendSchemas(ArrayNode result, ResultSet rs, boolean caseInsensitive) throws SQLException {
+        while (rs.next()) {
+            String schema = rs.getString("TABLE_SCHEM");
+            addSchema(result, schema, caseInsensitive);
+        }
+    }
+
+    private static void addSchema(ArrayNode result, String schema, boolean caseInsensitive) {
+        if (schema == null || schema.isBlank()) {
+            return;
+        }
+        String key = schemaKey(schema, caseInsensitive);
+        for (int i = 0; i < result.size(); i++) {
+            String existing = result.get(i).asText("");
+            if (schemaKey(existing, caseInsensitive).equals(key)) {
+                if (preferSchemaDisplayName(existing, schema)) {
+                    result.set(i, MAPPER.getNodeFactory().textNode(schema));
+                }
+                return;
+            }
+        }
+        result.add(schema);
+    }
+
+    static boolean preferSchemaDisplayName(String existing, String candidate) {
+        return isAllUppercaseIdentifier(existing) && !isAllUppercaseIdentifier(candidate);
+    }
+
+    private static boolean isAllUppercaseIdentifier(String value) {
+        return value != null && value.equals(value.toUpperCase(Locale.ROOT)) && !value.equals(value.toLowerCase(Locale.ROOT));
+    }
+
+    private static String schemaKey(String schema, boolean caseInsensitive) {
+        return caseInsensitive ? schema.toLowerCase(Locale.ROOT) : schema;
+    }
+
+    private static String metadataCatalog(String database, JdbcDriverQuirks quirks) {
+        if (quirks.caseInsensitiveSchemaMetadata() || quirks.ignoreCatalogForSchemaMetadata()) {
+            return null;
+        }
+        return emptyToNull(database);
+    }
+
+    private static String resolveSchemaPattern(
+        DatabaseMetaData meta,
+        String database,
+        String schema,
+        JdbcDriverQuirks quirks
+    ) throws SQLException {
+        String schemaPattern = emptyToNull(schema);
+        if (schemaPattern == null || !quirks.caseInsensitiveSchemaMetadata()) {
+            return schemaPattern;
+        }
+        String resolved = null;
+        try {
+            resolved = findSchemaPattern(meta, metadataCatalog(database, quirks), schemaPattern);
+        } catch (SQLException ignored) {
+        }
+        if (resolved != null) {
+            return resolved;
+        }
+        resolved = findSchemaPattern(meta, null, schemaPattern);
+        return resolved == null ? schemaPattern : resolved;
+    }
+
+    private static String findSchemaPattern(DatabaseMetaData meta, String catalog, String schema) throws SQLException {
+        try (ResultSet rs = meta.getSchemas(catalog, null)) {
+            String fallback = null;
+            while (rs.next()) {
+                String candidate = rs.getString("TABLE_SCHEM");
+                if (candidate == null || candidate.isBlank()) {
+                    continue;
+                }
+                if (candidate.equals(schema)) {
+                    return candidate;
+                }
+                if (candidate.equalsIgnoreCase(schema) && (fallback == null || preferSchemaDisplayName(fallback, candidate))) {
+                    fallback = candidate;
+                }
+            }
+            return fallback;
+        } catch (SQLFeatureNotSupportedException | UnsupportedOperationException ignored) {
+            return null;
+        }
+    }
+
+    private static void appendTables(
+        ArrayNode result,
+        DatabaseMetaData meta,
+        String catalog,
+        String schema,
+        String[] types
+    ) throws SQLException {
+        try (ResultSet rs = meta.getTables(catalog, schema, "%", types)) {
+            while (rs.next()) {
+                ObjectNode item = MAPPER.createObjectNode();
+                item.put("name", rs.getString("TABLE_NAME"));
+                item.put("table_type", rs.getString("TABLE_TYPE"));
+                putNullable(item, "comment", rs.getString("REMARKS"));
+                result.add(item);
+            }
+        }
+    }
+
+    static String[] jdbcTableTypes(DatabaseMetaData meta) throws SQLException {
+        Set<String> allowed = new HashSet<>();
+        for (String type : DEFAULT_TABLE_TYPES) {
+            allowed.add(type.toUpperCase(Locale.ROOT));
+        }
+        try (ResultSet rs = meta.getTableTypes()) {
+            List<String> types = new ArrayList<>();
+            while (rs.next()) {
+                String type = rs.getString("TABLE_TYPE");
+                if (type != null && allowed.contains(type.toUpperCase(Locale.ROOT))) {
+                    types.add(type);
+                }
+            }
+            if (!types.isEmpty()) {
+                return types.toArray(new String[0]);
+            }
+        } catch (SQLFeatureNotSupportedException | UnsupportedOperationException ignored) {
+        }
+        return DEFAULT_TABLE_TYPES;
+    }
+
+    private static String[] constrainedJdbcTableTypes(String[] tableTypes, List<String> objectTypes) {
+        Set<String> allowed = normalizedObjectTypes(objectTypes);
+        if (allowed.isEmpty()) {
+            return tableTypes;
+        }
+        List<String> result = new ArrayList<>();
+        for (String tableType : tableTypes) {
+            if (allowed.contains(normalizeTableObjectType(tableType))) {
+                result.add(tableType);
+            }
+        }
+        return result.toArray(new String[0]);
+    }
+
+    private static ArrayNode filterMetadataNodes(
+        ArrayNode source,
+        String filter,
+        int limit,
+        int offset,
+        List<String> objectTypes,
+        String typeField,
+        boolean defaultBlankTypeToTable
+    ) {
+        ArrayNode result = MAPPER.createArrayNode();
+        Set<String> allowedTypes = normalizedObjectTypes(objectTypes);
+        String normalizedFilter = filter == null ? "" : filter.trim().toLowerCase(Locale.ROOT);
+        int start = Math.max(0, offset);
+        int max = limit <= 0 ? Integer.MAX_VALUE : limit;
+        int skipped = 0;
+        for (JsonNode item : source) {
+            if (!metadataNameMatches(item.path("name").asText(""), normalizedFilter)) {
+                continue;
+            }
+            String type = item.path(typeField).asText("");
+            String normalizedType = defaultBlankTypeToTable ? normalizeTableObjectType(type) : normalizeObjectType(type);
+            if (!allowedTypes.isEmpty() && (normalizedType.isEmpty() || !allowedTypes.contains(normalizedType))) {
+                continue;
+            }
+            if (skipped++ < start) {
+                continue;
+            }
+            if (result.size() >= max) {
+                break;
+            }
+            result.add(item);
+        }
+        return result;
+    }
+
+    private static boolean metadataNameMatches(String name, String filter) {
+        if (filter == null || filter.isEmpty()) {
+            return true;
+        }
+        String candidate = name == null ? "" : name.toLowerCase(Locale.ROOT);
+        return candidate.contains(filter) || (filter.length() >= 2 && fuzzySubsequenceMatches(candidate, filter));
+    }
+
+    private static boolean fuzzySubsequenceMatches(String candidate, String expected) {
+        int cursor = 0;
+        for (int i = 0; i < expected.length(); i++) {
+            cursor = candidate.indexOf(expected.charAt(i), cursor);
+            if (cursor < 0) {
+                return false;
+            }
+            cursor++;
+        }
+        return true;
+    }
+
+    private static Set<String> normalizedObjectTypes(List<String> objectTypes) {
+        Set<String> result = new HashSet<>();
+        if (objectTypes == null) {
+            return result;
+        }
+        for (String objectType : objectTypes) {
+            String normalized = normalizeObjectType(objectType);
+            if (!normalized.isEmpty()) {
+                result.add(normalized);
+            }
+        }
+        return result;
+    }
+
+    private static String normalizeTableObjectType(String value) {
+        String normalized = normalizeObjectType(value);
+        return normalized.isEmpty() ? "TABLE" : normalized;
+    }
+
+    private static String normalizeObjectType(String value) {
+        if (value == null || value.isBlank()) {
+            return "";
+        }
+        String upper = value.trim().toUpperCase(Locale.ROOT).replace(' ', '_');
+        if (upper.contains("MATERIALIZED") && upper.contains("VIEW")) {
+            return "MATERIALIZED_VIEW";
+        }
+        if ("BASE_TABLE".equals(upper) || upper.contains("TABLE")) {
+            return "TABLE";
+        }
+        if (upper.contains("VIEW")) {
+            return "VIEW";
+        }
+        return upper;
+    }
+
+    private static void appendTableObjects(
+        ArrayNode result,
+        DatabaseMetaData meta,
+        String catalog,
+        String schemaPattern,
+        String schema,
+        String[] tableTypes
+    ) throws SQLException {
+        try (ResultSet rs = meta.getTables(catalog, schemaPattern, "%", tableTypes)) {
+            while (rs.next()) {
+                ObjectNode item = MAPPER.createObjectNode();
+                item.put("name", rs.getString("TABLE_NAME"));
+                item.put("object_type", rs.getString("TABLE_TYPE"));
+                putNullable(item, "schema", schema);
+                putNullable(item, "comment", rs.getString("REMARKS"));
+                result.add(item);
+            }
+        }
+    }
+
+    private static boolean usePrestoInformationSchemaTables(JsonNode connection) {
+        String url = optionalText(connection, "connection_string");
+        return urlMatchesPrefix(url, "jdbc:presto:") || urlMatchesPrefix(url, "jdbc:trino:");
+    }
+
+    private static JsonNode prestoListTables(
+        Connection conn,
+        String database,
+        String schema,
+        String filter,
+        int limit,
+        int offset,
+        List<String> objectTypes
+    ) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        int queryLimit = limit > 0 ? Math.max(1, limit + Math.max(0, offset)) : 0;
+        try (PreparedStatement ps = conn.prepareStatement(prestoInformationSchemaTablesSql(database, filter, queryLimit))) {
+            ps.setString(1, schema);
+            if (emptyToNull(filter) != null) {
+                ps.setString(2, escapeLikePattern(filter.toLowerCase(Locale.ROOT)) + "%");
+            }
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) {
+                    ObjectNode item = MAPPER.createObjectNode();
+                    item.put("name", rs.getString(1));
+                    item.put("table_type", normalizeInformationSchemaTableType(rs.getString(2)));
+                    item.putNull("comment");
+                    result.add(item);
+                }
+            }
+        }
+        return filterMetadataNodes(result, filter, limit, offset, objectTypes, "table_type", true);
+    }
+
+    private static JsonNode prestoListObjects(
+        Connection conn,
+        String database,
+        String schema,
+        String filter,
+        int limit,
+        int offset,
+        List<String> objectTypes
+    ) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        int queryLimit = limit > 0 ? Math.max(1, limit + Math.max(0, offset)) : 0;
+        try (PreparedStatement ps = conn.prepareStatement(prestoInformationSchemaTablesSql(database, filter, queryLimit))) {
+            ps.setString(1, schema);
+            if (emptyToNull(filter) != null) {
+                ps.setString(2, escapeLikePattern(filter.toLowerCase(Locale.ROOT)) + "%");
+            }
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) {
+                    ObjectNode item = MAPPER.createObjectNode();
+                    item.put("name", rs.getString(1));
+                    item.put("object_type", normalizeInformationSchemaTableType(rs.getString(2)));
+                    putNullable(item, "schema", schema);
+                    item.putNull("comment");
+                    result.add(item);
+                }
+            }
+        }
+        return filterMetadataNodes(result, filter, limit, offset, objectTypes, "object_type", false);
+    }
+
+    private static JsonNode prestoGetColumns(Connection conn, String database, String schema, String table) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        try (PreparedStatement ps = conn.prepareStatement(prestoInformationSchemaColumnsSql(database))) {
+            ps.setString(1, schema);
+            ps.setString(2, table);
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) {
+                    String dataType = rs.getString(2);
+                    ObjectNode item = columnNode(result, rs.getString(1));
+                    item.put("data_type", dataType);
+                    item.put("is_nullable", !"NO".equalsIgnoreCase(rs.getString(3)));
+                    putNullablePreferValue(item, "column_default", rs.getString(4));
+                    item.put("is_primary_key", false);
+                    item.putNull("extra");
+                    putNullablePreferValue(item, "comment", rs.getString(5));
+                    // Presto/Trino information_schema.columns does not expose precision/length fields.
+                    putNullableInt(item, "numeric_precision", prestoNumericPrecision(dataType));
+                    putNullableInt(item, "numeric_scale", prestoNumericScale(dataType));
+                    putNullableInt(item, "character_maximum_length", prestoCharacterMaximumLength(dataType));
+                }
+            }
+        }
+        return result;
+    }
+
+    static String prestoInformationSchemaTablesSql(String database, String filter, int limit) {
+        String source = emptyToNull(database) == null
+            ? "information_schema.tables"
+            : quoteAnsiIdentifier(database) + ".information_schema.tables";
+        StringBuilder sql = new StringBuilder("SELECT table_name, table_type FROM " + source +
+            " WHERE table_schema = ? AND table_type IN ('BASE TABLE', 'VIEW')" +
+            (emptyToNull(filter) == null ? "" : " AND lower(table_name) LIKE ? ESCAPE '\\'") +
+            " ORDER BY table_type, table_name");
+        if (limit > 0) {
+            sql.append(" LIMIT ").append(limit);
+        }
+        return sql.toString();
+    }
+
+    static String prestoInformationSchemaColumnsSql(String database) {
+        String source = emptyToNull(database) == null
+            ? "information_schema.columns"
+            : quoteAnsiIdentifier(database) + ".information_schema.columns";
+        return "SELECT column_name, data_type, is_nullable, column_default, comment FROM " + source +
+            " WHERE table_schema = ? AND table_name = ?" +
+            " ORDER BY ordinal_position";
+    }
+
+    private static Integer prestoNumericPrecision(String dataType) {
+        return prestoTypeArgument(dataType, 0, "decimal", "numeric");
+    }
+
+    private static Integer prestoNumericScale(String dataType) {
+        return prestoTypeArgument(dataType, 1, "decimal", "numeric");
+    }
+
+    private static Integer prestoCharacterMaximumLength(String dataType) {
+        return prestoTypeArgument(dataType, 0, "char", "varchar");
+    }
+
+    private static Integer prestoTypeArgument(String dataType, int argumentIndex, String... typeNames) {
+        if (dataType == null) {
+            return null;
+        }
+        int open = dataType.indexOf('(');
+        int close = open < 0 ? -1 : dataType.indexOf(')', open + 1);
+        if (open <= 0 || close <= open) {
+            return null;
+        }
+        String name = dataType.substring(0, open).trim().toLowerCase(Locale.ROOT);
+        boolean matches = false;
+        for (String typeName : typeNames) {
+            if (typeName.equals(name)) {
+                matches = true;
+                break;
+            }
+        }
+        if (!matches) {
+            return null;
+        }
+        String[] arguments = dataType.substring(open + 1, close).split(",");
+        if (argumentIndex >= arguments.length) {
+            return null;
+        }
+        try {
+            return Integer.valueOf(arguments[argumentIndex].trim());
+        } catch (NumberFormatException e) {
+            return null;
+        }
+    }
+
+    static String normalizeInformationSchemaTableType(String tableType) {
+        if (tableType == null) {
+            return "TABLE";
+        }
+        String normalized = tableType.trim().toUpperCase(Locale.ROOT).replace(' ', '_');
+        return switch (normalized) {
+            case "BASE_TABLE" -> "TABLE";
+            case "MATERIALIZED_VIEW" -> "MATERIALIZED_VIEW";
+            case "VIEW" -> "VIEW";
+            default -> tableType;
+        };
+    }
+
+    private static JsonNode kingbaseGetColumns(Connection conn, String schema, String table) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        String effectiveSchema = emptyToNull(schema) == null ? "PUBLIC" : schema;
+        Set<String> primaryKeys = kingbasePrimaryKeys(conn, effectiveSchema, table);
+        String sql = "SELECT a.attname AS column_name, " +
+            "format_type(a.atttypid, a.atttypmod) AS data_type, " +
+            "NOT a.attnotnull AS is_nullable, " +
+            "sys_get_expr(ad.adbin, ad.adrelid) AS column_default, " +
+            "d.description AS column_comment, " +
+            "CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 " +
+            "THEN ((a.atttypmod - 4) >> 16) & 65535 ELSE NULL END AS numeric_precision, " +
+            "CASE WHEN t.typname = 'numeric' AND a.atttypmod > 0 " +
+            "THEN (a.atttypmod - 4) & 65535 ELSE NULL END AS numeric_scale, " +
+            "CASE WHEN t.typname IN ('varchar', 'bpchar') AND a.atttypmod > 0 " +
+            "THEN a.atttypmod - 4 ELSE NULL END AS character_maximum_length " +
+            "FROM sys_catalog.sys_attribute a " +
+            "JOIN sys_catalog.sys_type t ON t.oid = a.atttypid " +
+            "JOIN sys_catalog.sys_class c ON c.oid = a.attrelid " +
+            "JOIN sys_catalog.sys_namespace n ON n.oid = c.relnamespace " +
+            "LEFT JOIN sys_catalog.sys_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum " +
+            "LEFT JOIN sys_catalog.sys_description d ON d.objoid = a.attrelid AND d.objsubid = a.attnum " +
+            "WHERE n.nspname = " + sqlString(effectiveSchema) +
+            " AND c.relname = " + sqlString(table) + " " +
+            "AND a.attnum > 0 AND NOT a.attisdropped " +
+            "ORDER BY a.attnum";
+        try (Statement statement = conn.createStatement()) {
+            try (ResultSet rs = statement.executeQuery(sql)) {
+                while (rs.next()) {
+                    String name = rs.getString("column_name");
+                    ObjectNode item = columnNode(result, name);
+                    item.put("data_type", rs.getString("data_type"));
+                    item.put("is_nullable", rs.getBoolean("is_nullable"));
+                    putNullablePreferValue(item, "column_default", rs.getString("column_default"));
+                    item.put("is_primary_key", primaryKeys.contains(name));
+                    item.putNull("extra");
+                    putNullablePreferValue(item, "comment", rs.getString("column_comment"));
+                    putNullableInt(item, "numeric_precision", rs.getObject("numeric_precision"));
+                    putNullableInt(item, "numeric_scale", rs.getObject("numeric_scale"));
+                    putNullableInt(item, "character_maximum_length", rs.getObject("character_maximum_length"));
+                }
+            }
+        }
+        return result;
+    }
+
+    private static Set<String> kingbasePrimaryKeys(Connection conn, String schema, String table) {
+        Set<String> primaryKeys = new HashSet<>();
+        String sql = "SELECT a.attname AS column_name " +
+            "FROM sys_catalog.sys_constraint co " +
+            "JOIN sys_catalog.sys_class c ON c.oid = co.conrelid " +
+            "JOIN sys_catalog.sys_namespace n ON n.oid = c.relnamespace " +
+            "JOIN LATERAL (SELECT unnest(co.conkey) AS attnum, generate_series(1, array_length(co.conkey, 1)) AS ord) AS pk_cols ON true " +
+            "JOIN sys_catalog.sys_attribute a ON a.attrelid = c.oid AND a.attnum = pk_cols.attnum " +
+            "WHERE co.contype = 'p' " +
+            "AND n.nspname = " + sqlString(schema) + " " +
+            "AND c.relname = " + sqlString(table) + " " +
+            "ORDER BY pk_cols.ord";
+        try (Statement statement = conn.createStatement()) {
+            try (ResultSet rs = statement.executeQuery(sql)) {
+                while (rs.next()) {
+                    primaryKeys.add(rs.getString("column_name"));
+                }
+            }
+        } catch (SQLException ignored) {
+            return Collections.emptySet();
+        }
+        return primaryKeys;
+    }
+
+    private static boolean isKingbaseUrl(String url) {
+        return urlMatchesPrefix(url, "jdbc:kingbase");
+    }
+
+    private static String quoteAnsiIdentifier(String identifier) {
+        return "\"" + identifier.replace("\"", "\"\"") + "\"";
+    }
+
+    private static String sqlString(String value) {
+        return "'" + (value == null ? "" : value).replace("'", "''") + "'";
+    }
+
+    private static void appendColumns(
+        ArrayNode result,
+        DatabaseMetaData meta,
+        String catalog,
+        String schema,
+        String table,
+        Set<String> primaryKeys
+    ) throws SQLException {
+        try (ResultSet rs = meta.getColumns(catalog, schema, table, "%")) {
+            while (rs.next()) {
+                String name = rs.getString("COLUMN_NAME");
+                ObjectNode item = columnNode(result, name);
+                item.put("data_type", rs.getString("TYPE_NAME"));
+                item.put("is_nullable", columnIsNullable(rs));
+                putNullablePreferValue(item, "column_default", rs.getString("COLUMN_DEF"));
+                item.put("is_primary_key", primaryKeys.contains(name));
+                item.putNull("extra");
+                putNullablePreferValue(item, "comment", rs.getString("REMARKS"));
+                putNullableInt(item, "numeric_precision", rs.getObject("COLUMN_SIZE"));
+                putNullableInt(item, "numeric_scale", rs.getObject("DECIMAL_DIGITS"));
+                putNullableInt(item, "character_maximum_length", rs.getObject("COLUMN_SIZE"));
+            }
+        }
+    }
+
+    private static boolean columnIsNullable(ResultSet rs) throws SQLException {
+        try {
+            String isNullableStr = rs.getString("IS_NULLABLE");
+            if ("YES".equalsIgnoreCase(isNullableStr)) {
+                return true;
+            }
+            if ("NO".equalsIgnoreCase(isNullableStr)) {
+                return false;
+            }
+        } catch (SQLException ignored) {
+        }
+        return rs.getInt("NULLABLE") != DatabaseMetaData.columnNoNulls;
+    }
+
+    private static void mergeShowFullColumnMetadata(Connection conn, ArrayNode result, String schema, String table) {
+        String target = qualifiedJdbcTableName(schema, table);
+        try (Statement statement = conn.createStatement(); ResultSet rs = statement.executeQuery("SHOW FULL COLUMNS FROM " + target)) {
+            int fieldIndex = resultSetColumnIndex(rs, "Field");
+            int typeIndex = resultSetColumnIndex(rs, "Type");
+            int extraIndex = resultSetColumnIndex(rs, "Extra");
+            int commentIndex = resultSetColumnIndex(rs, "Comment");
+            if (fieldIndex <= 0) {
+                return;
+            }
+            while (rs.next()) {
+                String name = rs.getString(fieldIndex);
+                if (name != null) {
+                    ObjectNode item = columnNode(result, name);
+                    if (typeIndex > 0) {
+                        putNullablePreferValue(item, "data_type", rs.getString(typeIndex));
+                    }
+                    if (extraIndex > 0) {
+                        putNullablePreferValue(item, "extra", rs.getString(extraIndex));
+                    }
+                    if (commentIndex > 0) {
+                        putNullablePreferValue(item, "comment", rs.getString(commentIndex));
+                    }
+                }
+            }
+        } catch (SQLException | AbstractMethodError | UnsupportedOperationException ignored) {
+        }
+    }
+
+    private static String qualifiedJdbcTableName(String schema, String table) {
+        String tableName = quoteJdbcIdentifier(table);
+        String schemaName = emptyToNull(schema);
+        return schemaName == null ? tableName : quoteJdbcIdentifier(schemaName) + "." + tableName;
+    }
+
+    private static int resultSetColumnIndex(ResultSet rs, String label) throws SQLException {
+        ResultSetMetaData meta = rs.getMetaData();
+        for (int i = 1; i <= meta.getColumnCount(); i++) {
+            if (label.equalsIgnoreCase(meta.getColumnLabel(i)) || label.equalsIgnoreCase(meta.getColumnName(i))) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private static void closeSharedConnection() {
+        closeAllQuerySessions();
+        if (sharedConnection != null) {
+            try {
+                sharedConnection.close();
+            } catch (SQLException ignored) {
+            }
+            sharedConnection = null;
+            sharedConnectionKey = "";
+        }
+    }
+
+    private static String driverKey(JsonNode connection) {
+        return optionalText(connection, "jdbc_driver_class") + "|" + connection.path("jdbc_driver_paths").toString();
+    }
+
+    private static String connectionKey(JsonNode connection) {
+        return optionalText(connection, "connection_string")
+            + "|" + optionalText(connection, "url_params")
+            + "|" + optionalText(connection, "username")
+            + "|" + optionalText(connection, "password")
+            + "|" + connection.path("sysdba").asBoolean(false);
+    }
+
+    private static Set<String> primaryKeys(DatabaseMetaData meta, String database, String schema, String table) throws SQLException {
+        Set<String> primaryKeys = new HashSet<>();
+        try (ResultSet rs = meta.getPrimaryKeys(emptyToNull(database), emptyToNull(schema), table)) {
+            while (rs.next()) {
+                primaryKeys.add(rs.getString("COLUMN_NAME"));
+            }
+        }
+        return primaryKeys;
+    }
+
+    private static Set<String> safePrimaryKeys(DatabaseMetaData meta, String database, String schema, String table) {
+        try {
+            return primaryKeys(meta, database, schema, table);
+        } catch (SQLException ignored) {
+            return Collections.emptySet();
+        }
+    }
+
+    // --- Oracle-specific metadata methods ---
+
+    private static boolean isOracleUrl(String url) {
+        return url != null && url.regionMatches(true, 0, "jdbc:oracle:", 0, 12);
+    }
+
+    static String jdbcUrlWithPasswordKey(String url, String password) {
+        if (url == null || password == null || password.isBlank() || !isSqliteUrl(url)) {
+            return url;
+        }
+        if (!urlHasQueryParam(url, "cipher") || urlHasQueryParam(url, "key")) {
+            return url;
+        }
+        return appendJdbcUrlParam(url, "key", password);
+    }
+
+    static String jdbcUrl(JsonNode connection) {
+        String url = appendJdbcUrlParams(optionalText(connection, "connection_string"), optionalText(connection, "url_params"));
+        return jdbcUrlWithPasswordKey(url, optionalText(connection, "password"));
+    }
+
+    private record JdbcUrlCredentials(String url, String username, String password) {}
+
+    static JdbcUrlCredentials extractJdbcUrlCredentials(String url) {
+        if (url == null) {
+            return new JdbcUrlCredentials(null, null, null);
+        }
+        int queryStart = url.indexOf('?');
+        if (queryStart < 0) {
+            return new JdbcUrlCredentials(url, null, null);
+        }
+
+        int fragmentStart = url.indexOf('#', queryStart + 1);
+        String base = url.substring(0, queryStart);
+        String query = fragmentStart < 0 ? url.substring(queryStart + 1) : url.substring(queryStart + 1, fragmentStart);
+        String fragment = fragmentStart < 0 ? "" : url.substring(fragmentStart);
+
+        String username = null;
+        String password = null;
+        boolean foundCredential = false;
+        List<String> keptParams = new ArrayList<>();
+        for (String part : splitJdbcUrlParams(query)) {
+            String name = partName(part);
+            String key = decodeQueryPart(name).trim().toLowerCase(Locale.ROOT);
+            if ("user".equals(key)) {
+                username = decodeQueryPart(partValue(part));
+                foundCredential = true;
+            } else if ("password".equals(key)) {
+                password = decodeQueryPart(partValue(part));
+                foundCredential = true;
+            } else {
+                keptParams.add(part);
+            }
+        }
+
+        if (!foundCredential) {
+            return new JdbcUrlCredentials(url, null, null);
+        }
+        String sanitizedQuery = joinJdbcUrlParams(keptParams);
+        String sanitizedUrl = sanitizedQuery.isEmpty() ? base + fragment : base + "?" + sanitizedQuery + fragment;
+        return new JdbcUrlCredentials(sanitizedUrl, username, password);
+    }
+
+    private static List<String> splitJdbcUrlParams(String query) {
+        List<String> result = new ArrayList<>();
+        int start = 0;
+        for (int i = 0; i < query.length(); i++) {
+            char ch = query.charAt(i);
+            if (ch == '&') {
+                result.add(query.substring(start, i));
+                start = i + 1;
+            }
+        }
+        result.add(query.substring(start));
+        return result;
+    }
+
+    private static String joinJdbcUrlParams(List<String> params) {
+        return params.stream().filter(param -> !param.isEmpty()).collect(Collectors.joining("&"));
+    }
+
+    private static String partName(String part) {
+        int equals = part.indexOf('=');
+        return equals < 0 ? part : part.substring(0, equals);
+    }
+
+    private static String partValue(String part) {
+        int equals = part.indexOf('=');
+        return equals < 0 ? "" : part.substring(equals + 1);
+    }
+
+    private static String decodeQueryPart(String value) {
+        try {
+            return URLDecoder.decode(value, StandardCharsets.UTF_8);
+        } catch (IllegalArgumentException ignored) {
+            return value;
+        }
+    }
+
+    private static boolean isSqliteUrl(String url) {
+        return url.regionMatches(true, 0, "jdbc:sqlite:", 0, 12);
+    }
+
+    private static boolean urlHasQueryParam(String url, String key) {
+        int queryStart = url.indexOf('?');
+        if (queryStart < 0) {
+            return false;
+        }
+        int fragmentStart = url.indexOf('#', queryStart + 1);
+        String query = fragmentStart < 0 ? url.substring(queryStart + 1) : url.substring(queryStart + 1, fragmentStart);
+        for (String part : query.split("[&;]")) {
+            int equals = part.indexOf('=');
+            String name = equals < 0 ? part : part.substring(0, equals);
+            if (name.equalsIgnoreCase(key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static String appendJdbcUrlParam(String url, String key, String value) {
+        int fragmentStart = url.indexOf('#');
+        String base = fragmentStart < 0 ? url : url.substring(0, fragmentStart);
+        String fragment = fragmentStart < 0 ? "" : url.substring(fragmentStart);
+        String separator = base.contains("?") ? (base.endsWith("?") || base.endsWith("&") ? "" : "&") : "?";
+        String encodedValue = URLEncoder.encode(value, StandardCharsets.UTF_8);
+        return base + separator + key + "=" + encodedValue + fragment;
+    }
+
+    static String appendJdbcUrlParams(String url, String urlParams) {
+        if (url == null || urlParams == null || urlParams.isBlank()) {
+            return url;
+        }
+        String params = urlParams.trim();
+        while (params.startsWith("?") || params.startsWith("&") || params.startsWith(";") || params.startsWith(":")) {
+            params = params.substring(1).trim();
+        }
+        if (params.isEmpty()) {
+            return url;
+        }
+
+        int fragmentStart = url.indexOf('#');
+        String base = fragmentStart < 0 ? url : url.substring(0, fragmentStart);
+        String fragment = fragmentStart < 0 ? "" : url.substring(fragmentStart);
+        if (jdbcUrlUsesColonProperties(base) && !params.endsWith(";")) {
+            params = params + ";";
+        }
+        String separator = jdbcUrlParamSeparator(base);
+        return base + separator + params + fragment;
+    }
+
+    private static String jdbcUrlParamSeparator(String base) {
+        if (urlMatchesPrefix(base, "jdbc:sqlserver:") || urlMatchesPrefix(base, "jdbc:dremio:")) {
+            return base.endsWith(";") ? "" : ";";
+        }
+        if (jdbcUrlUsesColonProperties(base)) {
+            if (base.endsWith(":") || base.endsWith(";")) {
+                return "";
+            }
+            return jdbcUrlHasColonProperties(base) ? ";" : ":";
+        }
+        return base.contains("?") ? (base.endsWith("?") || base.endsWith("&") ? "" : "&") : "?";
+    }
+
+    private static boolean jdbcUrlUsesColonProperties(String base) {
+        return urlMatchesPrefix(base, "jdbc:db2:") || urlMatchesPrefix(base, "jdbc:informix-sqli:");
+    }
+
+    private static boolean jdbcUrlHasColonProperties(String base) {
+        int schemeEnd = base.indexOf("://");
+        if (schemeEnd < 0) {
+            return false;
+        }
+        int pathStart = base.indexOf('/', schemeEnd + 3);
+        if (pathStart < 0) {
+            return false;
+        }
+        return base.indexOf(':', pathStart + 1) >= 0;
+    }
+
+    private static String oracleEffectiveSchema(Connection conn, String schema) throws SQLException {
+        if (schema != null && !schema.isBlank()) {
+            return oracleResolveOwner(conn, schema);
+        }
+        String username = conn.getMetaData().getUserName();
+        return username == null || username.isBlank() ? username : oracleResolveOwner(conn, username);
+    }
+
+    private static String oracleResolveOwner(Connection conn, String owner) throws SQLException {
+        String exact = oracleFindIdentifier(
+            conn,
+            "SELECT username FROM all_users WHERE username = ?",
+            owner
+        );
+        if (exact != null) {
+            return exact;
+        }
+        String upper = owner.toUpperCase();
+        exact = oracleFindIdentifier(
+            conn,
+            "SELECT username FROM all_users WHERE username = ?",
+            upper
+        );
+        return exact == null ? owner : exact;
+    }
+
+    private static String oracleResolveTable(Connection conn, String owner, String table) throws SQLException {
+        String exact = oracleFindIdentifier(
+            conn,
+            "SELECT table_name FROM all_tab_comments WHERE owner = ? AND table_name = ?",
+            owner,
+            table
+        );
+        if (exact != null) {
+            return exact;
+        }
+        String upper = table.toUpperCase();
+        exact = oracleFindIdentifier(
+            conn,
+            "SELECT table_name FROM all_tab_comments WHERE owner = ? AND table_name = ?",
+            owner,
+            upper
+        );
+        return exact == null ? table : exact;
+    }
+
+    private static String oracleFindIdentifier(Connection conn, String sql, String first) throws SQLException {
+        try (PreparedStatement ps = conn.prepareStatement(sql)) {
+            ps.setString(1, first);
+            try (ResultSet rs = ps.executeQuery()) {
+                if (rs.next()) {
+                    return rs.getString(1);
+                }
+            }
+        }
+        return null;
+    }
+
+    private static String oracleFindIdentifier(Connection conn, String sql, String first, String second) throws SQLException {
+        try (PreparedStatement ps = conn.prepareStatement(sql)) {
+            ps.setString(1, first);
+            ps.setString(2, second);
+            try (ResultSet rs = ps.executeQuery()) {
+                if (rs.next()) {
+                    return rs.getString(1);
+                }
+            }
+        }
+        return null;
+    }
+
+    private static JsonNode oracleListSchemas(Connection conn) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        try (Statement stmt = conn.createStatement();
+             ResultSet rs = stmt.executeQuery("SELECT username FROM all_users ORDER BY username")) {
+            while (rs.next()) {
+                String name = rs.getString(1);
+                if (name != null && !name.isBlank()) {
+                    result.add(name);
+                }
+            }
+        }
+        return result;
+    }
+
+    private static JsonNode oracleListTables(Connection conn, String owner) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        String sql =
+            "SELECT table_name AS name, 'TABLE' AS table_type, comments " +
+            "FROM all_tab_comments WHERE owner = ? AND table_type = 'TABLE' " +
+            "UNION ALL " +
+            "SELECT table_name AS name, 'VIEW' AS table_type, comments " +
+            "FROM all_tab_comments WHERE owner = ? AND table_type = 'VIEW' " +
+            "ORDER BY name";
+        try (PreparedStatement ps = conn.prepareStatement(sql)) {
+            ps.setString(1, owner);
+            ps.setString(2, owner);
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) {
+                    ObjectNode item = MAPPER.createObjectNode();
+                    item.put("name", rs.getString("name"));
+                    item.put("table_type", rs.getString("table_type"));
+                    putNullable(item, "comment", rs.getString("comments"));
+                    result.add(item);
+                }
+            }
+        }
+        return result;
+    }
+
+    private static JsonNode oracleListObjects(Connection conn, String owner, String schemaLabel) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        String tableSql =
+            "SELECT table_name AS name, table_type AS object_type, comments " +
+            "FROM all_tab_comments WHERE owner = ? ORDER BY name";
+        try (PreparedStatement ps = conn.prepareStatement(tableSql)) {
+            ps.setString(1, owner);
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) {
+                    ObjectNode item = MAPPER.createObjectNode();
+                    item.put("name", rs.getString("name"));
+                    item.put("object_type", rs.getString("object_type"));
+                    putNullable(item, "schema", schemaLabel);
+                    putNullable(item, "comment", rs.getString("comments"));
+                    result.add(item);
+                }
+            }
+        }
+        String procSql =
+            "SELECT object_name AS name, object_type " +
+            "FROM all_procedures WHERE owner = ? AND object_type IN ('PROCEDURE', 'FUNCTION') " +
+            "AND procedure_name IS NULL ORDER BY object_name";
+        try (PreparedStatement ps = conn.prepareStatement(procSql)) {
+            ps.setString(1, owner);
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) {
+                    ObjectNode item = MAPPER.createObjectNode();
+                    item.put("name", rs.getString("name"));
+                    item.put("object_type", rs.getString("object_type"));
+                    putNullable(item, "schema", schemaLabel);
+                    item.putNull("comment");
+                    result.add(item);
+                }
+            }
+        }
+        String packageSql =
+            "SELECT object_name AS name, CASE object_type WHEN 'PACKAGE BODY' THEN 'PACKAGE_BODY' ELSE object_type END AS object_type " +
+            "FROM all_objects WHERE owner = ? AND object_type IN ('PACKAGE', 'PACKAGE BODY') ORDER BY object_type, object_name";
+        try (PreparedStatement ps = conn.prepareStatement(packageSql)) {
+            ps.setString(1, owner);
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) {
+                    ObjectNode item = MAPPER.createObjectNode();
+                    item.put("name", rs.getString("name"));
+                    item.put("object_type", rs.getString("object_type"));
+                    putNullable(item, "schema", schemaLabel);
+                    item.putNull("comment");
+                    result.add(item);
+                }
+            }
+        }
+        return result;
+    }
+
+    private static JsonNode getObjectSource(JsonNode connection, String database, String schema, String name, String objectType)
+        throws SQLException {
+        Connection conn = openConnection(connection);
+        if (!driverQuirks(connection).useOracleMetadata()) {
+            throw new SQLException("Object source is not supported by this JDBC driver");
+        }
+        String owner = oracleEffectiveSchema(conn, schema);
+        String metadataType = oracleMetadataObjectType(objectType);
+        String sql = "SELECT DBMS_METADATA.GET_DDL(?, ?, ?) FROM DUAL";
+        try (PreparedStatement ps = conn.prepareStatement(sql)) {
+            ps.setString(1, metadataType);
+            ps.setString(2, name);
+            ps.setString(3, owner);
+            try (ResultSet rs = ps.executeQuery()) {
+                if (!rs.next()) {
+                    throw new SQLException("Object source not found");
+                }
+                ObjectNode item = MAPPER.createObjectNode();
+                item.put("name", name);
+                item.put("object_type", objectType);
+                putNullable(item, "schema", owner);
+                putNullable(item, "source", rs.getString(1));
+                return item;
+            }
+        }
+    }
+
+    private static String oracleMetadataObjectType(String objectType) {
+        String normalized = objectType == null ? "" : objectType.trim().toUpperCase().replace(' ', '_');
+        return switch (normalized) {
+            case "VIEW" -> "VIEW";
+            case "PROCEDURE" -> "PROCEDURE";
+            case "FUNCTION" -> "FUNCTION";
+            case "PACKAGE" -> "PACKAGE";
+            case "PACKAGE_BODY" -> "PACKAGE_BODY";
+            default -> normalized;
+        };
+    }
+
+    private static JsonNode oracleGetColumns(Connection conn, String owner, String table) throws SQLException {
+        ArrayNode result = MAPPER.createArrayNode();
+        String resolvedTable = oracleResolveTable(conn, owner, table);
+        Set<String> pks = oraclePrimaryKeys(conn, owner, resolvedTable);
+        // data_default is a LONG column — it must be read first in JDBC, before any other
+        // column, otherwise the data is truncated. We put it at position 1 for this reason.
+        String sql =
+            "SELECT c.data_default, c.column_name, c.data_type, c.nullable, " +
+            "c.data_precision, c.data_scale, c.char_length, cc.comments " +
+            "FROM all_tab_columns c " +
+            "LEFT JOIN all_col_comments cc ON cc.owner = c.owner AND cc.table_name = c.table_name AND cc.column_name = c.column_name " +
+            "WHERE c.owner = ? AND c.table_name = ? ORDER BY c.column_id";
+        try (PreparedStatement ps = conn.prepareStatement(sql)) {
+            ps.setString(1, owner);
+            ps.setString(2, resolvedTable);
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) {
+                    // data_default is a LONG — read it first, before all other columns.
+                    String dataDefault = rs.getString("data_default");
+                    String name = rs.getString("column_name");
+                    ObjectNode item = columnNode(result, name);
+                    item.put("data_type", rs.getString("data_type"));
+                    item.put("is_nullable", !"N".equals(rs.getString("nullable")));
+                    putNullablePreferValue(item, "column_default", dataDefault);
+                    item.put("is_primary_key", pks.contains(name));
+                    item.putNull("extra");
+                    putNullablePreferValue(item, "comment", rs.getString("comments"));
+                    putNullableInt(item, "numeric_precision", rs.getObject("data_precision"));
+                    putNullableInt(item, "numeric_scale", rs.getObject("data_scale"));
+                    putNullableInt(item, "character_maximum_length", rs.getObject("char_length"));
+                }
+            }
+        }
+        return result;
+    }
+
+    private static Set<String> oraclePrimaryKeys(Connection conn, String owner, String table) throws SQLException {
+        Set<String> keys = new HashSet<>();
+        String sql =
+            "SELECT cols.column_name FROM all_constraints cons " +
+            "JOIN all_cons_columns cols ON cons.constraint_name = cols.constraint_name AND cons.owner = cols.owner " +
+            "WHERE cons.constraint_type = 'P' AND cons.owner = ? AND cons.table_name = ?";
+        try (PreparedStatement ps = conn.prepareStatement(sql)) {
+            ps.setString(1, owner);
+            ps.setString(2, table);
+            try (ResultSet rs = ps.executeQuery()) {
+                while (rs.next()) {
+                    keys.add(rs.getString("column_name"));
+                }
+            }
+        }
+        return keys;
+    }
+
+    private static Object readValue(ResultSet rs, ResultSetMetaData meta, int index) throws SQLException {
+        Object value = rs.getObject(index);
+        if (value == null) {
+            return null;
+        }
+        if (value instanceof byte[] bytes) {
+            return binaryToHex(bytes);
+        }
+        if (isBinaryColumn(meta, index)) {
+            byte[] bytes = rs.getBytes(index);
+            return bytes == null ? null : binaryToHex(bytes);
+        }
+        Object temporalValue = readTemporalValue(rs, meta, index);
+        if (temporalValue != null) {
+            return temporalValue;
+        }
+        if (value instanceof Date || value instanceof Time || value instanceof Timestamp || value instanceof TemporalAccessor) {
+            return value.toString();
+        }
+        if (value instanceof BigDecimal decimal) {
+            return decimal;
+        }
+        if (value instanceof Number || value instanceof Boolean || value instanceof String) {
+            return value;
+        }
+        return value.toString();
+    }
+
+    private static Object readTemporalValue(ResultSet rs, ResultSetMetaData meta, int index) throws SQLException {
+        return switch (meta.getColumnType(index)) {
+            case Types.DATE -> {
+                Date date = rs.getDate(index);
+                yield date == null ? null : date.toString();
+            }
+            case Types.TIME -> {
+                Time time = rs.getTime(index);
+                yield time == null ? null : time.toString();
+            }
+            case Types.TIMESTAMP -> {
+                Timestamp timestamp = rs.getTimestamp(index);
+                yield timestamp == null ? null : timestamp.toString();
+            }
+            default -> null;
+        };
+    }
+
+    private static boolean isBinaryColumn(ResultSetMetaData meta, int index) throws SQLException {
+        return switch (meta.getColumnType(index)) {
+            case Types.BINARY,
+                 Types.VARBINARY,
+                 Types.LONGVARBINARY,
+                 Types.BLOB -> true;
+            default -> false;
+        };
+    }
+
+    private static String binaryToHex(byte[] bytes) {
+        StringBuilder out = new StringBuilder(2 + bytes.length * 2);
+        out.append("0x");
+        for (byte b : bytes) {
+            out.append(Character.forDigit((b >> 4) & 0x0f, 16));
+            out.append(Character.forDigit(b & 0x0f, 16));
+        }
+        return out.toString();
+    }
+
+    private static void putNullable(ObjectNode node, String field, String value) {
+        if (value == null) {
+            node.putNull(field);
+        } else {
+            node.put(field, value);
+        }
+    }
+
+    private static ObjectNode columnNode(ArrayNode result, String name) {
+        for (JsonNode node : result) {
+            if (name.equals(node.path("name").asText()) && node instanceof ObjectNode objectNode) {
+                return objectNode;
+            }
+        }
+        ObjectNode item = MAPPER.createObjectNode();
+        item.put("name", name);
+        result.add(item);
+        return item;
+    }
+
+    private static void putNullablePreferValue(ObjectNode node, String field, String value) {
+        if (value == null || value.isBlank()) {
+            if (!node.has(field)) {
+                node.putNull(field);
+            }
+            return;
+        }
+        node.put(field, value);
+    }
+
+    private static void putNullableInt(ObjectNode node, String field, Object value) {
+        if (value instanceof Number number) {
+            node.put(field, number.intValue());
+        } else {
+            node.putNull(field);
+        }
+    }
+
+    private static String requireText(JsonNode node, String field) {
+        String value = optionalText(node, field);
+        if (value == null) {
+            throw new IllegalArgumentException(field + " is required.");
+        }
+        return value;
+    }
+
+    private static String optionalText(JsonNode node, String field) {
+        JsonNode value = node.path(field);
+        if (value.isMissingNode() || value.isNull()) {
+            return null;
+        }
+        String text = value.asText("").trim();
+        return text.isEmpty() ? null : text;
+    }
+
+    private static List<String> optionalStringList(JsonNode node, String field) {
+        JsonNode value = node.path(field);
+        if (value.isMissingNode() || value.isNull()) {
+            return null;
+        }
+        List<String> result = new ArrayList<>();
+        if (value.isArray()) {
+            for (JsonNode item : value) {
+                String text = item.asText("").trim();
+                if (!text.isEmpty()) {
+                    result.add(text);
+                }
+            }
+            return result;
+        }
+        String text = value.asText("").trim();
+        if (text.isEmpty()) {
+            return null;
+        }
+        for (String part : text.split(",")) {
+            String item = part.trim();
+            if (!item.isEmpty()) {
+                result.add(item);
+            }
+        }
+        return result;
+    }
+
+    private static int positiveInt(JsonNode node, String field, int defaultValue) {
+        return Math.max(1, nonNegativeInt(node, field, defaultValue));
+    }
+
+    private static int nonNegativeInt(JsonNode node, String field, int defaultValue) {
+        JsonNode value = node.path(field);
+        if (value.isMissingNode() || value.isNull()) {
+            return defaultValue;
+        }
+        if (!value.canConvertToInt()) {
+            return defaultValue;
+        }
+        return Math.max(0, value.asInt(defaultValue));
+    }
+
+    private static String emptyToNull(String value) {
+        return value == null || value.isBlank() ? null : value;
+    }
+
+    private static String escapeLikePattern(String value) {
+        return value.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_");
+    }
+
+    private static Path expandHome(String path) {
+        if (path.equals("~") || path.startsWith("~/")) {
+            return Path.of(System.getProperty("user.home") + path.substring(1));
+        }
+        return Path.of(path);
+    }
+
+    private static final class DriverShim implements Driver {
+        private final Driver driver;
+
+        private DriverShim(Driver driver) {
+            this.driver = driver;
+        }
+
+        @Override
+        public Connection connect(String url, Properties info) throws SQLException {
+            return driver.connect(url, info);
+        }
+
+        @Override
+        public boolean acceptsURL(String url) throws SQLException {
+            return driver.acceptsURL(url);
+        }
+
+        @Override
+        public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException {
+            return driver.getPropertyInfo(url, info);
+        }
+
+        @Override
+        public int getMajorVersion() {
+            return driver.getMajorVersion();
+        }
+
+        @Override
+        public int getMinorVersion() {
+            return driver.getMinorVersion();
+        }
+
+        @Override
+        public boolean jdbcCompliant() {
+            return driver.jdbcCompliant();
+        }
+
+        @Override
+        public Logger getParentLogger() throws SQLFeatureNotSupportedException {
+            return driver.getParentLogger();
+        }
+    }
+}
diff --git a/plugins/jdbc/src/main/java/app/dbx/jdbc/maven/DbxMavenResolver.java b/plugins/jdbc/src/main/java/app/dbx/jdbc/maven/DbxMavenResolver.java
new file mode 100644
index 0000000..c6e59c3
--- /dev/null
+++ b/plugins/jdbc/src/main/java/app/dbx/jdbc/maven/DbxMavenResolver.java
@@ -0,0 +1,209 @@
+package app.dbx.jdbc.maven;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import java.io.File;
+import java.nio.file.Path;
+import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import org.eclipse.aether.RepositorySystem;
+import org.eclipse.aether.RepositorySystemSession;
+import org.eclipse.aether.artifact.Artifact;
+import org.eclipse.aether.artifact.DefaultArtifact;
+import org.eclipse.aether.collection.CollectRequest;
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.graph.DependencyNode;
+import org.eclipse.aether.repository.LocalRepository;
+import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.resolution.DependencyRequest;
+import org.eclipse.aether.resolution.DependencyResult;
+import org.eclipse.aether.supplier.RepositorySystemSupplier;
+import org.eclipse.aether.supplier.SessionBuilderSupplier;
+import org.eclipse.aether.util.artifact.JavaScopes;
+import org.eclipse.aether.util.filter.DependencyFilterUtils;
+
+public final class DbxMavenResolver {
+    private static final String DEFAULT_REPOSITORY = "https://repo.maven.apache.org/maven2/";
+    private static final ObjectMapper JSON = new ObjectMapper().enable(SerializationFeature.INDENT_OUTPUT);
+
+    private DbxMavenResolver() {
+    }
+
+    public static void main(String[] args) throws Exception {
+        try {
+            ResolverOptions options = ResolverOptions.parse(args);
+            ResolveResult result = resolve(options);
+            JSON.writeValue(System.out, result);
+            System.out.println();
+        } catch (Throwable err) {
+            // Resolver dependencies may fail with linkage errors when a runtime image is missing a required module.
+            Map<String, String> error = new LinkedHashMap<>();
+            error.put("error", throwableMessage(err));
+            JSON.writeValue(System.err, error);
+            System.err.println();
+            System.exit(1);
+        }
+    }
+
+    private static String throwableMessage(Throwable error) {
+        Throwable cause = error;
+        while (cause.getCause() != null && cause.getCause() != cause) {
+            cause = cause.getCause();
+        }
+        return cause.getMessage() == null ? cause.toString() : cause.getMessage();
+    }
+
+    private static ResolveResult resolve(ResolverOptions options) throws Exception {
+        RepositorySystem system = new RepositorySystemSupplier().get();
+        RepositorySystemSession session = new SessionBuilderSupplier(system)
+            .get()
+            .withLocalRepositories(new LocalRepository(options.localRepository))
+            .setRepositoryListener(null)
+            .setTransferListener(null)
+            .build();
+
+        Artifact rootArtifact = parseCoordinate(options.coordinate);
+        Dependency root = new Dependency(rootArtifact, options.scope);
+        CollectRequest collect = new CollectRequest();
+        collect.setRoot(root);
+        for (int index = 0; index < options.repositories.size(); index++) {
+            collect.addRepository(new RemoteRepository.Builder("repo-" + index, "default", options.repositories.get(index)).build());
+        }
+
+        DependencyRequest request = new DependencyRequest(collect, DependencyFilterUtils.classpathFilter(options.scope));
+        DependencyResult dependencyResult = system.resolveDependencies(session, request);
+        List<ResolvedArtifact> artifacts = new ArrayList<>();
+        collectRuntimeArtifacts(dependencyResult.getRoot(), true, artifacts);
+        return new ResolveResult(options.coordinate, options.scope, options.repositories, artifacts);
+    }
+
+    private static void collectRuntimeArtifacts(DependencyNode node, boolean root, List<ResolvedArtifact> artifacts) throws Exception {
+        Dependency dependency = node.getDependency();
+        if (!root && dependency != null && !isRuntimeDependency(dependency)) {
+            return;
+        }
+        Artifact artifact = node.getArtifact();
+        if (artifact != null && artifact.getFile() != null) {
+            artifacts.add(ResolvedArtifact.from(artifact, artifact.getFile()));
+        }
+        for (DependencyNode child : node.getChildren()) {
+            collectRuntimeArtifacts(child, false, artifacts);
+        }
+    }
+
+    private static boolean isRuntimeDependency(Dependency dependency) {
+        if (dependency.isOptional()) {
+            return false;
+        }
+        String scope = dependency.getScope();
+        return scope == null || scope.isBlank() || JavaScopes.COMPILE.equals(scope) || JavaScopes.RUNTIME.equals(scope);
+    }
+
+    private static Artifact parseCoordinate(String coordinate) {
+        String trimmed = coordinate == null ? "" : coordinate.trim();
+        if (trimmed.isEmpty()) {
+            throw new IllegalArgumentException("Maven coordinate is required");
+        }
+        String[] parts = trimmed.split(":");
+        if (parts.length == 3) {
+            return new DefaultArtifact(parts[0], parts[1], "", "jar", parts[2]);
+        }
+        if (parts.length == 4) {
+            return new DefaultArtifact(parts[0], parts[1], parts[3], "jar", parts[2]);
+        }
+        if (parts.length == 5) {
+            return new DefaultArtifact(parts[0], parts[1], parts[3], parts[2], parts[4]);
+        }
+        return new DefaultArtifact(trimmed);
+    }
+
+    private static String sha256(File file) throws Exception {
+        MessageDigest digest = MessageDigest.getInstance("SHA-256");
+        byte[] bytes = java.nio.file.Files.readAllBytes(file.toPath());
+        byte[] hash = digest.digest(bytes);
+        StringBuilder value = new StringBuilder(hash.length * 2);
+        for (byte b : hash) {
+            value.append(String.format("%02x", b));
+        }
+        return value.toString();
+    }
+
+    private static final class ResolverOptions {
+        private String coordinate;
+        private String scope = JavaScopes.RUNTIME;
+        private Path localRepository = Path.of(System.getProperty("user.home"), ".dbx", "maven");
+        private final List<String> repositories = new ArrayList<>();
+
+        private static ResolverOptions parse(String[] args) {
+            ResolverOptions options = new ResolverOptions();
+            for (int index = 0; index < args.length; index++) {
+                String arg = args[index];
+                switch (arg) {
+                    case "resolve" -> {
+                    }
+                    case "--coordinate", "-c" -> options.coordinate = value(args, ++index, arg);
+                    case "--scope" -> options.scope = value(args, ++index, arg).toLowerCase(Locale.ROOT);
+                    case "--repo", "--repository" -> options.repositories.add(value(args, ++index, arg));
+                    case "--local-repo" -> options.localRepository = Path.of(value(args, ++index, arg));
+                    default -> {
+                        if (arg.startsWith("-")) {
+                            throw new IllegalArgumentException("Unsupported option: " + arg);
+                        }
+                        if (options.coordinate == null) {
+                            options.coordinate = arg;
+                        } else {
+                            throw new IllegalArgumentException("Unexpected argument: " + arg);
+                        }
+                    }
+                }
+            }
+            if (options.repositories.isEmpty()) {
+                options.repositories.add(DEFAULT_REPOSITORY);
+            }
+            return options;
+        }
+
+        private static String value(String[] args, int index, String option) {
+            if (index >= args.length || args[index].isBlank()) {
+                throw new IllegalArgumentException(option + " requires a value");
+            }
+            return args[index];
+        }
+    }
+
+    public record ResolveResult(
+        String coordinate,
+        String scope,
+        List<String> repositories,
+        List<ResolvedArtifact> artifacts
+    ) {
+    }
+
+    public record ResolvedArtifact(
+        String groupId,
+        String artifactId,
+        String version,
+        String classifier,
+        String extension,
+        String file,
+        long size,
+        String sha256
+    ) {
+        private static ResolvedArtifact from(Artifact artifact, File file) throws Exception {
+            return new ResolvedArtifact(
+                artifact.getGroupId(),
+                artifact.getArtifactId(),
+                artifact.getVersion(),
+                artifact.getClassifier(),
+                artifact.getExtension(),
+                file.getAbsolutePath(),
+                file.length(),
+                DbxMavenResolver.sha256(file)
+            );
+        }
+    }
+}
diff --git a/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java b/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java
new file mode 100644
index 0000000..f9d8839
--- /dev/null
+++ b/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java
@@ -0,0 +1,1799 @@
+package app.dbx.jdbc;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.Date;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.DriverPropertyInfo;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+final class DbxJdbcPluginTest {
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+    private static final String CONNECTION = """
+        {
+          "connection_string": "jdbc:h2:mem:dbx_ctx;DB_CLOSE_DELAY=-1",
+          "username": "sa",
+          "connect_timeout_secs": 30
+        }
+        """;
+
+    @AfterEach
+    void closeConnection() throws Exception {
+        request("close", """
+            { "connection": %s }
+            """.formatted(CONNECTION));
+    }
+
+    @Test
+    void executeQueryAppliesSchemaContext() throws Exception {
+        request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "CREATE SCHEMA IF NOT EXISTS app"
+            }
+            """.formatted(CONNECTION));
+
+        JsonNode response = request("executeQuery", """
+            {
+              "connection": %s,
+              "schema": "APP",
+              "sql": "SELECT SCHEMA() AS schema_name"
+            }
+            """.formatted(CONNECTION));
+
+        assertFalse(response.has("error"), response.toString());
+        assertEquals("APP", response.path("result").path("rows").path(0).path(0).asText());
+    }
+
+    @Test
+    void reportsDriverLinkageErrorsWithoutTerminatingThePlugin() throws Exception {
+        JsonNode response = request("testConnection", """
+            {
+              "connection": {
+                "connection_string": "jdbc:broken:test",
+                "jdbc_driver_class": "app.dbx.jdbc.DbxJdbcPluginTest$ErrorOnLoad"
+              }
+            }
+            """);
+
+        assertEquals("linkage boom", response.path("error").path("message").asText());
+    }
+
+    @Test
+    void executeQueryTrimsSingleTrailingSemicolon() throws Exception {
+        JsonNode response = request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "SELECT 1 AS n;"
+            }
+            """.formatted(CONNECTION));
+
+        assertFalse(response.has("error"), response.toString());
+        assertEquals(1, response.path("result").path("rows").path(0).path(0).asInt());
+    }
+
+    @Test
+    void executeQueryFormatsBinaryColumnsAsHex() throws Exception {
+        JsonNode response = request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "SELECT X'0001ABFF' AS payload"
+            }
+            """.formatted(CONNECTION));
+
+        assertFalse(response.has("error"), response.toString());
+        assertEquals("0x0001abff", response.path("result").path("rows").path(0).path(0).asText());
+    }
+
+    @Test
+    void executeQueryPreservesChineseTextValues() throws Exception {
+        JsonNode response = request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "SELECT '中文测试' AS label"
+            }
+            """.formatted(CONNECTION));
+
+        assertFalse(response.has("error"), response.toString());
+        assertEquals("中文测试", response.path("result").path("rows").path(0).path(0).asText());
+    }
+
+    @Test
+    void executeQueryPageKeepsCursorForNextPages() throws Exception {
+        JsonNode first = request("executeQueryPage", """
+            {
+              "connection": %s,
+              "sql": "SELECT X FROM SYSTEM_RANGE(1, 5)",
+              "pageSize": 2,
+              "maxRows": 10
+            }
+            """.formatted(CONNECTION));
+
+        assertFalse(first.has("error"), first.toString());
+        assertEquals(1, first.path("result").path("rows").path(0).path(0).asInt());
+        assertEquals(2, first.path("result").path("rows").path(1).path(0).asInt());
+        assertEquals(true, first.path("result").path("has_more").asBoolean());
+        String sessionId = first.path("result").path("session_id").asText();
+
+        JsonNode second = request("fetchQueryPage", """
+            {
+              "connection": %s,
+              "sessionId": "%s",
+              "pageSize": 2
+            }
+            """.formatted(CONNECTION, sessionId));
+
+        assertFalse(second.has("error"), second.toString());
+        assertEquals(3, second.path("result").path("rows").path(0).path(0).asInt());
+        assertEquals(4, second.path("result").path("rows").path(1).path(0).asInt());
+        assertEquals(true, second.path("result").path("has_more").asBoolean());
+
+        JsonNode third = request("fetch_query_page", """
+            {
+              "connection": %s,
+              "sessionId": "%s",
+              "pageSize": 2
+            }
+            """.formatted(CONNECTION, second.path("result").path("session_id").asText()));
+
+        assertFalse(third.has("error"), third.toString());
+        assertEquals(5, third.path("result").path("rows").path(0).path(0).asInt());
+        assertEquals(false, third.path("result").path("has_more").asBoolean());
+        assertEquals(true, third.path("result").path("session_id").isNull());
+    }
+
+    @Test
+    void readValueFormatsDateColumnsWithoutMidnightTime() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("readValue", ResultSet.class, ResultSetMetaData.class, int.class);
+        method.setAccessible(true);
+        ResultSet rs = temporalResultSet(Timestamp.valueOf("2026-06-10 00:00:00"), Date.valueOf("2026-06-10"));
+
+        assertEquals("2026-06-10", method.invoke(null, rs, columnMeta(Types.DATE), 1));
+    }
+
+    @Test
+    void readValueKeepsTimestampTimeComponent() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("readValue", ResultSet.class, ResultSetMetaData.class, int.class);
+        method.setAccessible(true);
+        Timestamp timestamp = Timestamp.valueOf("2026-06-10 12:34:56");
+        ResultSet rs = temporalResultSet(timestamp, Date.valueOf("2026-06-10"));
+
+        assertEquals("2026-06-10 12:34:56.0", method.invoke(null, rs, columnMeta(Types.TIMESTAMP), 1));
+    }
+
+    @Test
+    void executeQueryHonorsMaxRowsAndAcceptsExecutionOptions() throws Exception {
+        JsonNode response = request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "SELECT * FROM (VALUES (1), (2)) AS t(n)",
+              "maxRows": 1,
+              "fetchSize": 1,
+              "timeoutSecs": 60
+            }
+            """.formatted(CONNECTION));
+
+        assertFalse(response.has("error"), response.toString());
+        assertEquals(1, response.path("result").path("rows").size());
+        assertEquals(true, response.path("result").path("truncated").asBoolean());
+    }
+
+    @Test
+    void executeQueryFallsBackWhenExecutedStatementReturnsNullResultSet() throws Exception {
+        Driver driver = new BrokenResultSetDriver("jdbc:dbx-null-execute-rs:", true, -1);
+        DriverManager.registerDriver(driver);
+        try {
+            JsonNode response = request("executeQuery", """
+                {
+                  "connection": {
+                    "connection_string": "jdbc:dbx-null-execute-rs:demo",
+                    "connect_timeout_secs": 30
+                  },
+                  "sql": "SELECT v FROM meters"
+                }
+                """);
+
+            assertFalse(response.has("error"), response.toString());
+            assertEquals("VALUE", response.path("result").path("columns").path(0).asText());
+            assertEquals("row-value", response.path("result").path("rows").path(0).path(0).asText());
+        } finally {
+            DriverManager.deregisterDriver(driver);
+        }
+    }
+
+    @Test
+    void executeQueryFallsBackForQuerySqlWithoutUpdateCount() throws Exception {
+        Driver driver = new BrokenResultSetDriver("jdbc:dbx-no-result-flag:", false, -1);
+        DriverManager.registerDriver(driver);
+        try {
+            JsonNode response = request("executeQuery", """
+                {
+                  "connection": {
+                    "connection_string": "jdbc:dbx-no-result-flag:demo",
+                    "connect_timeout_secs": 30
+                  },
+                  "sql": "-- generated preview\\nSHOW TABLES"
+                }
+                """);
+
+            assertFalse(response.has("error"), response.toString());
+            assertEquals("row-value", response.path("result").path("rows").path(0).path(0).asText());
+        } finally {
+            DriverManager.deregisterDriver(driver);
+        }
+    }
+
+    @Test
+    void taosQuerySqlUsesExecuteQueryDirectly() throws Exception {
+        List<String> calls = new ArrayList<>();
+        Driver driver = new BrokenResultSetDriver("jdbc:taos:", true, -1, calls);
+        DriverManager.registerDriver(driver);
+        try {
+            JsonNode response = request("executeQuery", """
+                {
+                  "connection": {
+                    "connection_string": "jdbc:taos://dbx-fake:6030/power",
+                    "connect_timeout_secs": 30
+                  },
+                  "sql": "SELECT v FROM meters"
+                }
+                """);
+
+            assertFalse(response.has("error"), response.toString());
+            assertEquals("row-value", response.path("result").path("rows").path(0).path(0).asText());
+            assertEquals(List.of("executeQuery"), calls);
+        } finally {
+            DriverManager.deregisterDriver(driver);
+        }
+    }
+
+    @Test
+    void connectionUsernameWithMultipleAtSignsIsPassedToDriverProperties() throws Exception {
+        RecordingConnectDriver driver = new RecordingConnectDriver("jdbc:dbx-proxysql-form:");
+        DriverManager.registerDriver(driver);
+        try {
+            JsonNode response = request("testConnection", """
+                {
+                  "connection": {
+                    "connection_string": "jdbc:dbx-proxysql-form://127.0.0.1:6033/example",
+                    "username": "xxxxx@db_readonly@127.0.0.1",
+                    "password": "p@wd",
+                    "connect_timeout_secs": 30
+                  }
+                }
+                """);
+
+            assertFalse(response.has("error"), response.toString());
+            assertEquals("jdbc:dbx-proxysql-form://127.0.0.1:6033/example", driver.urls.get(0));
+            assertEquals("xxxxx@db_readonly@127.0.0.1", driver.properties.get(0).getProperty("user"));
+            assertEquals("p@wd", driver.properties.get(0).getProperty("password"));
+        } finally {
+            DriverManager.deregisterDriver(driver);
+        }
+    }
+
+    @Test
+    void jdbcUrlUserParamsWithMultipleAtSignsAreDecodedIntoDriverProperties() throws Exception {
+        RecordingConnectDriver driver = new RecordingConnectDriver("jdbc:dbx-proxysql-url:");
+        DriverManager.registerDriver(driver);
+        try {
+            JsonNode response = request("testConnection", """
+                {
+                  "connection": {
+                    "connection_string": "jdbc:dbx-proxysql-url://127.0.0.1:6033/example?socketTimeout=5&user=xxxxx%40db_readonly%40127.0.0.1&password=p%40wd&useSSL=false",
+                    "connect_timeout_secs": 30
+                  }
+                }
+                """);
+
+            assertFalse(response.has("error"), response.toString());
+            assertEquals("jdbc:dbx-proxysql-url://127.0.0.1:6033/example?socketTimeout=5&useSSL=false", driver.urls.get(0));
+            assertEquals("xxxxx@db_readonly@127.0.0.1", driver.properties.get(0).getProperty("user"));
+            assertEquals("p@wd", driver.properties.get(0).getProperty("password"));
+        } finally {
+            DriverManager.deregisterDriver(driver);
+        }
+    }
+
+    @Test
+    void jdbcUrlCredentialExtractionKeepsSemicolonInsidePasswordValue() throws Exception {
+        RecordingConnectDriver driver = new RecordingConnectDriver("jdbc:dbx-proxysql-semicolon-password:");
+        DriverManager.registerDriver(driver);
+        try {
+            JsonNode response = request("testConnection", """
+                {
+                  "connection": {
+                    "connection_string": "jdbc:dbx-proxysql-semicolon-password://127.0.0.1:6033/example?password=p;ss&useSSL=false",
+                    "connect_timeout_secs": 30
+                  }
+                }
+                """);
+
+            assertFalse(response.has("error"), response.toString());
+            assertEquals("jdbc:dbx-proxysql-semicolon-password://127.0.0.1:6033/example?useSSL=false", driver.urls.get(0));
+            assertEquals("p;ss", driver.properties.get(0).getProperty("password"));
+        } finally {
+            DriverManager.deregisterDriver(driver);
+        }
+    }
+
+    @Test
+    void jdbcUrlCredentialExtractionPreservesDecodedWhitespace() throws Exception {
+        RecordingConnectDriver driver = new RecordingConnectDriver("jdbc:dbx-proxysql-space-password:");
+        DriverManager.registerDriver(driver);
+        try {
+            JsonNode response = request("testConnection", """
+                {
+                  "connection": {
+                    "connection_string": "jdbc:dbx-proxysql-space-password://127.0.0.1:6033/example?user=tenant%40host&password=%20secret%20&useSSL=false",
+                    "connect_timeout_secs": 30
+                  }
+                }
+                """);
+
+            assertFalse(response.has("error"), response.toString());
+            assertEquals("jdbc:dbx-proxysql-space-password://127.0.0.1:6033/example?useSSL=false", driver.urls.get(0));
+            assertEquals("tenant@host", driver.properties.get(0).getProperty("user"));
+            assertEquals(" secret ", driver.properties.get(0).getProperty("password"));
+        } finally {
+            DriverManager.deregisterDriver(driver);
+        }
+    }
+
+    @Test
+    void explicitConnectionCredentialsOverrideJdbcUrlCredentialParams() throws Exception {
+        RecordingConnectDriver driver = new RecordingConnectDriver("jdbc:dbx-proxysql-override:");
+        DriverManager.registerDriver(driver);
+        try {
+            JsonNode response = request("testConnection", """
+                {
+                  "connection": {
+                    "connection_string": "jdbc:dbx-proxysql-override://127.0.0.1:6033/example?user=url%40tenant&password=url-secret&useSSL=false",
+                    "username": "form@tenant@host",
+                    "password": "form-secret",
+                    "connect_timeout_secs": 30
+                  }
+                }
+                """);
+
+            assertFalse(response.has("error"), response.toString());
+            assertEquals("jdbc:dbx-proxysql-override://127.0.0.1:6033/example?useSSL=false", driver.urls.get(0));
+            assertEquals("form@tenant@host", driver.properties.get(0).getProperty("user"));
+            assertEquals("form-secret", driver.properties.get(0).getProperty("password"));
+        } finally {
+            DriverManager.deregisterDriver(driver);
+        }
+    }
+
+    @Test
+    void connectTimeoutIsMappedToDriverProperties() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("applyConnectTimeout", JsonNode.class, Properties.class);
+        method.setAccessible(true);
+        Properties properties = new Properties();
+        JsonNode connection = MAPPER.readTree("""
+            { "connect_timeout_secs": 45 }
+            """);
+
+        method.invoke(null, connection, properties);
+
+        assertEquals("45", properties.getProperty("loginTimeout"));
+        assertEquals("45", properties.getProperty("connectTimeout"));
+    }
+
+    @Test
+    void prestoConnectTimeoutDoesNotSetUnsupportedDriverProperties() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("applyConnectTimeout", JsonNode.class, Properties.class);
+        method.setAccessible(true);
+        Properties properties = new Properties();
+        JsonNode connection = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:presto://presto.example.test:8080/hive",
+              "jdbc_driver_class": "io.prestosql.jdbc.PrestoDriver",
+              "connect_timeout_secs": 45
+            }
+            """);
+
+        method.invoke(null, connection, properties);
+
+        assertFalse(properties.containsKey("loginTimeout"));
+        assertFalse(properties.containsKey("connectTimeout"));
+    }
+
+    @Test
+    void jdbcUrlAppendsConnectionUrlParams() throws Exception {
+        JsonNode connection = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:kingbase8://db.example.com:54321/demo",
+              "url_params": "useUnicode=true&characterEncoding=UTF-8"
+            }
+            """);
+
+        assertEquals(
+            "jdbc:kingbase8://db.example.com:54321/demo?useUnicode=true&characterEncoding=UTF-8",
+            DbxJdbcPlugin.jdbcUrl(connection)
+        );
+    }
+
+    @Test
+    void jdbcUrlAppendsConnectionUrlParamsBeforeFragment() throws Exception {
+        JsonNode connection = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:example://db/demo?ssl=true#section",
+              "url_params": "?characterEncoding=UTF-8"
+            }
+            """);
+
+        assertEquals(
+            "jdbc:example://db/demo?ssl=true&characterEncoding=UTF-8#section",
+            DbxJdbcPlugin.jdbcUrl(connection)
+        );
+    }
+
+    @Test
+    void jdbcUrlAppendsSqlServerConnectionUrlParamsWithSemicolon() throws Exception {
+        JsonNode connection = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:sqlserver://localhost:1433",
+              "url_params": "databaseName=master;encrypt=true"
+            }
+            """);
+
+        assertEquals(
+            "jdbc:sqlserver://localhost:1433;databaseName=master;encrypt=true",
+            DbxJdbcPlugin.jdbcUrl(connection)
+        );
+    }
+
+    @Test
+    void jdbcUrlAppendsDremioConnectionUrlParamsWithSemicolon() throws Exception {
+        JsonNode connection = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:dremio:direct=dremio.example.com:31010",
+              "url_params": "schema=Samples;ssl=true"
+            }
+            """);
+
+        assertEquals(
+            "jdbc:dremio:direct=dremio.example.com:31010;schema=Samples;ssl=true",
+            DbxJdbcPlugin.jdbcUrl(connection)
+        );
+    }
+
+    @Test
+    void jdbcUrlAppendsDb2ConnectionUrlParamsWithColonProperties() throws Exception {
+        JsonNode connection = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:db2://localhost:50000/SAMPLE",
+              "url_params": "sslConnection=true;"
+            }
+            """);
+
+        assertEquals("jdbc:db2://localhost:50000/SAMPLE:sslConnection=true;", DbxJdbcPlugin.jdbcUrl(connection));
+    }
+
+    @Test
+    void jdbcUrlAppendsInformixConnectionUrlParamsWithColonProperties() throws Exception {
+        JsonNode connection = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:informix-sqli://localhost:9088/sysmaster",
+              "url_params": "INFORMIXSERVER=informix;CLIENT_LOCALE=en_US.utf8"
+            }
+            """);
+
+        assertEquals(
+            "jdbc:informix-sqli://localhost:9088/sysmaster:INFORMIXSERVER=informix;CLIENT_LOCALE=en_US.utf8;",
+            DbxJdbcPlugin.jdbcUrl(connection)
+        );
+    }
+
+    @Test
+    void oracleSysdbaIsMappedToInternalLogonProperty() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("applyOracleProperties", JsonNode.class, Properties.class);
+        method.setAccessible(true);
+        Properties properties = new Properties();
+        JsonNode connection = MAPPER.readTree("""
+            { "sysdba": true }
+            """);
+
+        method.invoke(null, connection, properties);
+
+        assertEquals("sysdba", properties.getProperty("internal_logon"));
+    }
+
+    @Test
+    void driverQuirksDetectYashanJdbcUrl() throws Exception {
+        JsonNode yashan = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:yasdb://172.26.128.159:20027/yasdb"
+            }
+            """);
+        JsonNode iris = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:IRIS://127.0.0.1:1972/USER"
+            }
+            """);
+        JsonNode h2 = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:h2:mem:dbx_quirks"
+            }
+            """);
+        JsonNode cache = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:Cache://127.0.0.1:1972/USER"
+            }
+            """);
+        JsonNode mysql = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:mysql://127.0.0.1:9030/demo"
+            }
+            """);
+        JsonNode kingbase = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:kingbase8://127.0.0.1:54321/demo"
+            }
+            """);
+        JsonNode kyuubi = MAPPER.readTree("""
+            {
+              "jdbc_driver_class": "org.apache.kyuubi.jdbc.KyuubiHiveDriver"
+            }
+            """);
+        JsonNode taos = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:TAOS://127.0.0.1:6030/power"
+            }
+            """);
+
+        assertEquals(true, DbxJdbcPlugin.driverQuirks(yashan).skipExecutionContext());
+        assertEquals(true, DbxJdbcPlugin.driverQuirks(yashan).useOracleMetadata());
+        assertEquals(true, DbxJdbcPlugin.driverQuirks(iris).skipExecutionContext());
+        assertEquals(false, DbxJdbcPlugin.driverQuirks(iris).useOracleMetadata());
+        assertEquals(true, DbxJdbcPlugin.driverQuirks(iris).caseInsensitiveSchemaMetadata());
+        assertEquals(
+            DbxJdbcPlugin.StatementMaxRowsMode.READ_LOOP_ONLY,
+            DbxJdbcPlugin.driverQuirks(iris).statementMaxRowsMode()
+        );
+        assertEquals(false, DbxJdbcPlugin.driverQuirks(h2).skipExecutionContext());
+        assertEquals(false, DbxJdbcPlugin.driverQuirks(h2).useOracleMetadata());
+        assertEquals(false, DbxJdbcPlugin.driverQuirks(h2).caseInsensitiveSchemaMetadata());
+        assertEquals(false, DbxJdbcPlugin.driverQuirks(h2).useCatalogFallbackSql());
+        assertEquals(
+            DbxJdbcPlugin.StatementMaxRowsMode.READ_LOOP_ONLY,
+            DbxJdbcPlugin.driverQuirks(h2).statementMaxRowsMode()
+        );
+        assertEquals(
+            DbxJdbcPlugin.StatementMaxRowsMode.READ_LOOP_ONLY,
+            DbxJdbcPlugin.driverQuirks(cache).statementMaxRowsMode()
+        );
+        assertEquals(true, DbxJdbcPlugin.driverQuirks(mysql).useCatalogFallbackSql());
+        assertEquals(true, DbxJdbcPlugin.driverQuirks(kingbase).ignoreCatalogForSchemaMetadata());
+        assertEquals(true, DbxJdbcPlugin.driverQuirks(kyuubi).useCatalogFallbackSql());
+        assertEquals(true, DbxJdbcPlugin.driverQuirks(taos).preferExecuteQueryForResultSetSql());
+    }
+
+    @Test
+    void irisStatementOptionsSkipDriverMaxRowsRewrite() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod(
+            "applyStatementOptions",
+            Statement.class,
+            int.class,
+            int.class,
+            int.class,
+            DbxJdbcPlugin.JdbcDriverQuirks.class
+        );
+        method.setAccessible(true);
+        JsonNode iris = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:IRIS://127.0.0.1:1972/USER"
+            }
+            """);
+        List<String> calls = new ArrayList<>();
+
+        method.invoke(null, recordingStatement(calls), 100, 50, 30, DbxJdbcPlugin.driverQuirks(iris));
+
+        assertFalse(calls.contains("setMaxRows"), calls.toString());
+        assertEquals(true, calls.contains("setFetchSize"));
+        assertEquals(true, calls.contains("setQueryTimeout"));
+    }
+
+    @Test
+    void defaultStatementOptionsSkipDriverMaxRowsRewrite() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod(
+            "applyStatementOptions",
+            Statement.class,
+            int.class,
+            int.class,
+            int.class,
+            DbxJdbcPlugin.JdbcDriverQuirks.class
+        );
+        method.setAccessible(true);
+        JsonNode h2 = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:h2:mem:dbx_quirks"
+            }
+            """);
+        List<String> calls = new ArrayList<>();
+
+        method.invoke(null, recordingStatement(calls), 100, 50, 30, DbxJdbcPlugin.driverQuirks(h2));
+
+        assertFalse(calls.contains("setMaxRows"), calls.toString());
+        assertEquals(true, calls.contains("setFetchSize"));
+        assertEquals(true, calls.contains("setQueryTimeout"));
+    }
+
+    @Test
+    void optInStatementOptionsCanApplyDriverMaxRowsProtection() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod(
+            "applyStatementOptions",
+            Statement.class,
+            int.class,
+            int.class,
+            int.class,
+            DbxJdbcPlugin.JdbcDriverQuirks.class
+        );
+        method.setAccessible(true);
+        JsonNode yashan = MAPPER.readTree("""
+            {
+              "connection_string": "jdbc:yasdb://127.0.0.1:1688/yasdb"
+            }
+            """);
+        List<String> calls = new ArrayList<>();
+
+        method.invoke(null, recordingStatement(calls), 100, 50, 30, DbxJdbcPlugin.driverQuirks(yashan));
+
+        assertEquals(true, calls.contains("setMaxRows"));
+        assertEquals(true, calls.contains("setFetchSize"));
+        assertEquals(true, calls.contains("setQueryTimeout"));
+    }
+
+    @Test
+    void schemaDisplayNamePrefersMixedCaseOverAllUppercaseDuplicate() {
+        assertEquals(true, DbxJdbcPlugin.preferSchemaDisplayName("SQLUSER", "SQLUser"));
+        assertEquals(false, DbxJdbcPlugin.preferSchemaDisplayName("SQLUser", "SQLUSER"));
+    }
+
+    @Test
+    void jdbcTableTypesUsesDriverTypesWithinDefaultAllowList() throws Exception {
+        String[] types = DbxJdbcPlugin.jdbcTableTypes(tableTypesMeta("TABLE", "LOCAL TEMPORARY", "BASE TABLE"));
+
+        assertEquals(List.of("TABLE", "BASE TABLE"), List.of(types));
+    }
+
+    @Test
+    void jdbcTableTypesFallsBackWhenDriverReturnsNoAllowedTypes() throws Exception {
+        String[] types = DbxJdbcPlugin.jdbcTableTypes(tableTypesMeta("LOCAL TEMPORARY"));
+
+        assertEquals(true, List.of(types).contains("BASE TABLE"));
+        assertEquals(true, List.of(types).contains("TABLE"));
+    }
+
+    @Test
+    void sqliteCipherUrlUsesPasswordAsKeyWhenKeyIsMissing() {
+        String url = DbxJdbcPlugin.jdbcUrlWithPasswordKey(
+            "jdbc:sqlite:/tmp/library.db?cipher=chacha20",
+            "my password"
+        );
+
+        assertEquals("jdbc:sqlite:/tmp/library.db?cipher=chacha20&key=my+password", url);
+    }
+
+    @Test
+    void sqliteCipherUrlKeepsExplicitKey() {
+        String url = DbxJdbcPlugin.jdbcUrlWithPasswordKey(
+            "jdbc:sqlite:/tmp/library.db?cipher=chacha20&key=from-url",
+            "from-password"
+        );
+
+        assertEquals("jdbc:sqlite:/tmp/library.db?cipher=chacha20&key=from-url", url);
+    }
+
+    @Test
+    void nonSqliteUrlDoesNotUsePasswordAsKey() {
+        String url = DbxJdbcPlugin.jdbcUrlWithPasswordKey(
+            "jdbc:h2:mem:dbx_cipher?cipher=sqlcipher",
+            "secret"
+        );
+
+        assertEquals("jdbc:h2:mem:dbx_cipher?cipher=sqlcipher", url);
+    }
+
+    @Test
+    void listTablesFallsBackWhenCatalogFiltersEverything() throws Exception {
+        request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "CREATE SCHEMA IF NOT EXISTS app"
+            }
+            """.formatted(CONNECTION));
+        request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "CREATE TABLE IF NOT EXISTS app.people (id INT PRIMARY KEY, name VARCHAR(30))"
+            }
+            """.formatted(CONNECTION));
+
+        JsonNode response = request("listTables", """
+            {
+              "connection": %s,
+              "database": "UNRELATED_CATALOG",
+              "schema": "APP"
+            }
+            """.formatted(CONNECTION));
+
+        assertFalse(response.has("error"), response.toString());
+        assertEquals("PEOPLE", response.path("result").path(0).path("name").asText());
+    }
+
+    @Test
+    void listTablesAppliesMetadataConstraints() throws Exception {
+        request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "CREATE SCHEMA IF NOT EXISTS app"
+            }
+            """.formatted(CONNECTION));
+        request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "CREATE TABLE IF NOT EXISTS app.people (id INT PRIMARY KEY)"
+            }
+            """.formatted(CONNECTION));
+        request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "CREATE TABLE IF NOT EXISTS app.people_archive (id INT PRIMARY KEY)"
+            }
+            """.formatted(CONNECTION));
+
+        JsonNode response = request("listTables", """
+            {
+              "connection": %s,
+              "schema": "APP",
+              "filter": "people",
+              "limit": 1,
+              "offset": 1,
+              "object_types": ["TABLE"]
+            }
+            """.formatted(CONNECTION));
+
+        assertFalse(response.has("error"), response.toString());
+        assertEquals(1, response.path("result").size());
+        assertEquals("PEOPLE_ARCHIVE", response.path("result").path(0).path("name").asText());
+    }
+
+    @Test
+    void listDatabasesIncludesConfiguredDatabaseWhenDriverDoesNotReturnIt() throws Exception {
+        String connection = """
+            {
+              "connection_string": "jdbc:h2:mem:dbx_catalog;DB_CLOSE_DELAY=-1",
+              "username": "sa",
+              "database": "DBX_DEMO"
+            }
+            """;
+
+        JsonNode response = request("listDatabases", """
+            { "connection": %s }
+            """.formatted(connection));
+
+        assertFalse(response.has("error"), response.toString());
+        boolean found = false;
+        for (JsonNode database : response.path("result")) {
+            if ("DBX_DEMO".equals(database.path("name").asText())) {
+                found = true;
+                break;
+            }
+        }
+        assertEquals(true, found);
+    }
+
+    @Test
+    void listDataTypesUsesJdbcTypeInfo() throws Exception {
+        JsonNode response = request("listDataTypes", """
+            { "connection": %s }
+            """.formatted(CONNECTION));
+
+        assertFalse(response.has("error"), response.toString());
+        boolean foundInteger = false;
+        boolean foundVarchar = false;
+        for (JsonNode type : response.path("result")) {
+            String name = type.asText();
+            if ("INTEGER".equalsIgnoreCase(name)) {
+                foundInteger = true;
+            }
+            if ("VARCHAR".equalsIgnoreCase(name) || "CHARACTER VARYING".equalsIgnoreCase(name)) {
+                foundVarchar = true;
+            }
+        }
+        assertEquals(true, foundInteger);
+        assertEquals(true, foundVarchar);
+    }
+
+    @Test
+    void listObjectsAcceptsCamelCaseMethodAndFallsBackWhenCatalogFiltersEverything() throws Exception {
+        createPeopleTable();
+
+        JsonNode response = request("listObjects", """
+            {
+              "connection": %s,
+              "database": "UNRELATED_CATALOG",
+              "schema": "APP"
+            }
+            """.formatted(CONNECTION));
+
+        assertFalse(response.has("error"), response.toString());
+        assertEquals("PEOPLE", response.path("result").path(0).path("name").asText());
+    }
+
+    @Test
+    void listObjectsAppliesMetadataConstraints() throws Exception {
+        request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "CREATE SCHEMA IF NOT EXISTS app"
+            }
+            """.formatted(CONNECTION));
+        request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "CREATE TABLE IF NOT EXISTS app.people (id INT PRIMARY KEY)"
+            }
+            """.formatted(CONNECTION));
+        request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "CREATE TABLE IF NOT EXISTS app.people_archive (id INT PRIMARY KEY)"
+            }
+            """.formatted(CONNECTION));
+
+        JsonNode response = request("listObjects", """
+            {
+              "connection": %s,
+              "schema": "APP",
+              "filter": "people",
+              "limit": 1,
+              "offset": 1,
+              "object_types": ["TABLE"]
+            }
+            """.formatted(CONNECTION));
+
+        assertFalse(response.has("error"), response.toString());
+        assertEquals(1, response.path("result").size());
+        assertEquals("PEOPLE_ARCHIVE", response.path("result").path(0).path("name").asText());
+    }
+
+    @Test
+    void getColumnsFallsBackWhenCatalogFiltersEverything() throws Exception {
+        createPeopleTable();
+
+        JsonNode response = request("getColumns", """
+            {
+              "connection": %s,
+              "database": "UNRELATED_CATALOG",
+              "schema": "APP",
+              "table": "PEOPLE"
+            }
+            """.formatted(CONNECTION));
+
+        assertFalse(response.has("error"), response.toString());
+        assertEquals("ID", response.path("result").path(0).path("name").asText());
+        assertEquals(true, response.path("result").path(0).path("is_primary_key").asBoolean());
+    }
+
+    @Test
+    void kingbaseGetColumnsUsesFormattedCatalogTypes() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("kingbaseGetColumns", Connection.class, String.class, String.class);
+        method.setAccessible(true);
+        List<String> sql = new ArrayList<>();
+
+        JsonNode result = (JsonNode) method.invoke(null, kingbaseColumnsConnection(sql), "dbx_issue_1942", "t_timestamp_type");
+
+        assertEquals("id", result.path(0).path("name").asText());
+        assertEquals("INTEGER", result.path(0).path("data_type").asText());
+        assertEquals(true, result.path(0).path("is_primary_key").asBoolean());
+        assertEquals("create_time", result.path(1).path("name").asText());
+        assertEquals("TIMESTAMP WITH TIME ZONE", result.path(1).path("data_type").asText());
+        assertEquals("create_by", result.path(2).path("name").asText());
+        assertEquals("CHARACTER VARYING(64 byte)", result.path(2).path("data_type").asText());
+        assertEquals(64, result.path(2).path("character_maximum_length").asInt());
+        assertEquals(true, sql.get(1).contains("format_type(a.atttypid, a.atttypmod) AS data_type"));
+        assertEquals(true, sql.get(1).contains("FROM sys_catalog.sys_attribute"));
+    }
+
+    @Test
+    void columnIsNullablePrefersIsNullableStringWhenNullableCodeIsWrong() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("columnIsNullable", ResultSet.class);
+        method.setAccessible(true);
+
+        ResultSet rs = columnNullableResultSet("YES", DatabaseMetaData.columnNoNulls);
+
+        assertEquals(true, method.invoke(null, rs));
+    }
+
+    @Test
+    void columnIsNullableFallsBackToNullableCodeWhenStringIsMissing() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("columnIsNullable", ResultSet.class);
+        method.setAccessible(true);
+
+        ResultSet rs = columnNullableResultSet(null, DatabaseMetaData.columnNullable);
+
+        assertEquals(true, method.invoke(null, rs));
+    }
+
+    @Test
+    void showFullColumnsMetadataCompletesMysqlCompatibleTypesAndComments() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod(
+            "mergeShowFullColumnMetadata",
+            Connection.class,
+            ArrayNode.class,
+            String.class,
+            String.class
+        );
+        method.setAccessible(true);
+        ArrayNode columns = MAPPER.createArrayNode();
+        ObjectNode column = columns.addObject();
+        column.put("name", "name");
+        column.put("data_type", "varchar");
+        column.putNull("extra");
+        column.putNull("comment");
+
+        method.invoke(null, showFullColumnsConnection(), columns, "app", "people");
+
+        assertEquals("varchar(32)", columns.path(0).path("data_type").asText());
+        assertEquals("auto_increment", columns.path(0).path("extra").asText());
+        assertEquals("姓名", columns.path(0).path("comment").asText());
+    }
+
+    @Test
+    void prestoListTablesUsesInformationSchemaInsteadOfJdbcMetadata() throws Exception {
+        List<String> calls = new ArrayList<>();
+        Driver driver = new PrestoMetadataDriver(calls);
+        DriverManager.registerDriver(driver);
+        try {
+            JsonNode response = request("listTables", """
+                {
+                  "connection": {
+                    "connection_string": "jdbc:presto://presto.example.test:8080/hive",
+                    "connect_timeout_secs": 30
+                  },
+                  "database": "hive",
+                  "schema": "sales_analytics"
+                }
+                """);
+
+            assertFalse(response.has("error"), response.toString());
+            assertEquals("daily_revenue", response.path("result").path(0).path("name").asText());
+            assertEquals("TABLE", response.path("result").path(0).path("table_type").asText());
+            assertEquals("revenue_view", response.path("result").path(1).path("name").asText());
+            assertEquals("VIEW", response.path("result").path(1).path("table_type").asText());
+            assertEquals(
+                List.of(
+                    "prepare:SELECT table_name, table_type FROM \"hive\".information_schema.tables WHERE table_schema = ? AND table_type IN ('BASE TABLE', 'VIEW') ORDER BY table_type, table_name",
+                    "setString:1:sales_analytics",
+                    "executeQuery"
+                ),
+                calls
+            );
+        } finally {
+            DriverManager.deregisterDriver(driver);
+        }
+    }
+
+    @Test
+    void prestoListTablesPushesFilterAndLimitToInformationSchema() throws Exception {
+        List<String> calls = new ArrayList<>();
+        Driver driver = new PrestoMetadataDriver(calls);
+        DriverManager.registerDriver(driver);
+        try {
+            JsonNode response = request("listTables", """
+                {
+                  "connection": {
+                    "connection_string": "jdbc:presto://presto.example.test:8080/hive",
+                    "connect_timeout_secs": 30
+                  },
+                  "database": "hive",
+                  "schema": "sales_analytics",
+                  "filter": "Daily_%",
+                  "limit": 20
+                }
+                """);
+
+            assertFalse(response.has("error"), response.toString());
+            assertEquals(
+                List.of(
+                    "prepare:SELECT table_name, table_type FROM \"hive\".information_schema.tables WHERE table_schema = ? AND table_type IN ('BASE TABLE', 'VIEW') AND lower(table_name) LIKE ? ESCAPE '\\' ORDER BY table_type, table_name LIMIT 20",
+                    "setString:1:sales_analytics",
+                    "setString:2:daily\\_\\%%",
+                    "executeQuery"
+                ),
+                calls
+            );
+        } finally {
+            DriverManager.deregisterDriver(driver);
+        }
+    }
+
+    @Test
+    void prestoGetColumnsUsesInformationSchemaInsteadOfJdbcMetadata() throws Exception {
+        List<String> calls = new ArrayList<>();
+        Driver driver = new PrestoMetadataDriver(calls);
+        DriverManager.registerDriver(driver);
+        try {
+            JsonNode response = request("getColumns", """
+                {
+                  "connection": {
+                    "connection_string": "jdbc:presto://presto.example.test:8080/hive",
+                    "connect_timeout_secs": 30
+                  },
+                  "database": "hive",
+                  "schema": "sales_analytics",
+                  "table": "daily_revenue"
+                }
+                """);
+
+            assertFalse(response.has("error"), response.toString());
+            assertEquals("amount", response.path("result").path(0).path("name").asText());
+            assertEquals("decimal(12,2)", response.path("result").path(0).path("data_type").asText());
+            assertEquals(12, response.path("result").path(0).path("numeric_precision").asInt());
+            assertEquals(2, response.path("result").path(0).path("numeric_scale").asInt());
+            assertEquals(
+                List.of(
+                    "prepare:SELECT column_name, data_type, is_nullable, column_default, comment FROM \"hive\".information_schema.columns WHERE table_schema = ? AND table_name = ? ORDER BY ordinal_position",
+                    "setString:1:sales_analytics",
+                    "setString:2:daily_revenue",
+                    "executeQuery"
+                ),
+                calls
+            );
+        } finally {
+            DriverManager.deregisterDriver(driver);
+        }
+    }
+
+    @Test
+    void oracleMetadataObjectTypeAcceptsPackageBodyAliases() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("oracleMetadataObjectType", String.class);
+        method.setAccessible(true);
+
+        assertEquals("PACKAGE_BODY", method.invoke(null, "PACKAGE BODY"));
+        assertEquals("PACKAGE_BODY", method.invoke(null, "PACKAGE_BODY"));
+        assertEquals("PACKAGE", method.invoke(null, "PACKAGE"));
+    }
+
+    @Test
+    void oracleEffectiveSchemaUsesExactOwnerBeforeUppercaseFallback() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("oracleEffectiveSchema", Connection.class, String.class);
+        method.setAccessible(true);
+
+        try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:dbx_oracle_owner;DB_CLOSE_DELAY=-1", "sa", "")) {
+            conn.createStatement().execute("CREATE TABLE all_users (username VARCHAR(64))");
+            conn.createStatement().execute("INSERT INTO all_users(username) VALUES ('mixed_owner'), ('SYSDBA')");
+
+            assertEquals("mixed_owner", method.invoke(null, conn, "mixed_owner"));
+            assertEquals("SYSDBA", method.invoke(null, conn, "sysdba"));
+        }
+    }
+
+    @Test
+    void oracleResolveTableUsesExactNameBeforeUppercaseFallback() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("oracleResolveTable", Connection.class, String.class, String.class);
+        method.setAccessible(true);
+
+        try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:dbx_oracle_table;DB_CLOSE_DELAY=-1", "sa", "")) {
+            conn.createStatement().execute("CREATE TABLE all_tab_comments (owner VARCHAR(64), table_name VARCHAR(64))");
+            conn.createStatement().execute(
+                "INSERT INTO all_tab_comments(owner, table_name) VALUES ('SYSDBA', 'mixed_table'), ('SYSDBA', 'ORDERS')"
+            );
+
+            assertEquals("mixed_table", method.invoke(null, conn, "SYSDBA", "mixed_table"));
+            assertEquals("ORDERS", method.invoke(null, conn, "SYSDBA", "orders"));
+        }
+    }
+
+    @Test
+    void oracleGetColumnsMergesDuplicateMetadataRowsAndKeepsComments() throws Exception {
+        Method method = DbxJdbcPlugin.class.getDeclaredMethod("oracleGetColumns", Connection.class, String.class, String.class);
+        method.setAccessible(true);
+
+        try (Connection conn = DriverManager.getConnection("jdbc:h2:mem:dbx_oracle_duplicate_columns;DB_CLOSE_DELAY=-1", "sa", "")) {
+            conn.createStatement().execute(
+                "CREATE TABLE all_tab_comments (owner VARCHAR(64), table_name VARCHAR(64), table_type VARCHAR(16))"
+            );
+            conn.createStatement().execute(
+                "CREATE TABLE all_tab_columns (" +
+                    "owner VARCHAR(64), table_name VARCHAR(64), column_name VARCHAR(64), data_type VARCHAR(32), " +
+                    "nullable VARCHAR(1), data_default VARCHAR(64), data_precision INT, data_scale INT, char_length INT, column_id INT)"
+            );
+            conn.createStatement().execute(
+                "CREATE TABLE all_col_comments (owner VARCHAR(64), table_name VARCHAR(64), column_name VARCHAR(64), comments VARCHAR(128))"
+            );
+            conn.createStatement().execute(
+                "CREATE TABLE all_constraints (owner VARCHAR(64), table_name VARCHAR(64), constraint_name VARCHAR(64), constraint_type VARCHAR(1))"
+            );
+            conn.createStatement().execute(
+                "CREATE TABLE all_cons_columns (owner VARCHAR(64), table_name VARCHAR(64), constraint_name VARCHAR(64), column_name VARCHAR(64))"
+            );
+            conn.createStatement().execute(
+                "INSERT INTO all_tab_comments(owner, table_name, table_type) VALUES ('SYSDBA', 'F02_TFBH', 'TABLE')"
+            );
+            conn.createStatement().execute(
+                "INSERT INTO all_tab_columns(owner, table_name, column_name, data_type, nullable, data_default, data_precision, data_scale, char_length, column_id) " +
+                    "VALUES ('SYSDBA', 'F02_TFBH', 'ID', 'INT', 'N', NULL, 10, 0, NULL, 1), " +
+                    "('SYSDBA', 'F02_TFBH', 'TFBH', 'VARCHAR', 'Y', NULL, NULL, NULL, 8, 2)"
+            );
+            conn.createStatement().execute(
+                "INSERT INTO all_col_comments(owner, table_name, column_name, comments) VALUES " +
+                    "('SYSDBA', 'F02_TFBH', 'ID', NULL), " +
+                    "('SYSDBA', 'F02_TFBH', 'ID', '源主键'), " +
+                    "('SYSDBA', 'F02_TFBH', 'TFBH', NULL), " +
+                    "('SYSDBA', 'F02_TFBH', 'TFBH', '台账编号')"
+            );
+            conn.createStatement().execute(
+                "INSERT INTO all_constraints(owner, table_name, constraint_name, constraint_type) VALUES ('SYSDBA', 'F02_TFBH', 'PK_F02_TFBH', 'P')"
+            );
+            conn.createStatement().execute(
+                "INSERT INTO all_cons_columns(owner, table_name, constraint_name, column_name) VALUES ('SYSDBA', 'F02_TFBH', 'PK_F02_TFBH', 'ID')"
+            );
+
+            JsonNode columns = MAPPER.valueToTree(method.invoke(null, conn, "SYSDBA", "F02_TFBH"));
+
+            assertEquals(2, columns.size());
+            assertEquals("ID", columns.path(0).path("name").asText());
+            assertEquals("源主键", columns.path(0).path("comment").asText());
+            assertEquals(true, columns.path(0).path("is_primary_key").asBoolean());
+            assertEquals("TFBH", columns.path(1).path("name").asText());
+            assertEquals("台账编号", columns.path(1).path("comment").asText());
+        }
+    }
+
+    private static void createPeopleTable() throws Exception {
+        request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "CREATE SCHEMA IF NOT EXISTS app"
+            }
+            """.formatted(CONNECTION));
+        request("executeQuery", """
+            {
+              "connection": %s,
+              "sql": "CREATE TABLE IF NOT EXISTS app.people (id INT PRIMARY KEY, name VARCHAR(30))"
+            }
+            """.formatted(CONNECTION));
+    }
+
+    private static Statement recordingStatement(List<String> calls) {
+        return (Statement) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { Statement.class },
+            (proxy, method, args) -> {
+                calls.add(method.getName());
+                Class<?> returnType = method.getReturnType();
+                if (returnType == boolean.class) return false;
+                if (returnType == int.class) return 0;
+                if (returnType == long.class) return 0L;
+                if (returnType == float.class) return 0f;
+                if (returnType == double.class) return 0d;
+                return null;
+            }
+        );
+    }
+
+    private static ResultSet temporalResultSet(Object objectValue, Date dateValue) {
+        return (ResultSet) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { ResultSet.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "getObject", "getTimestamp" -> objectValue;
+                case "getDate" -> dateValue;
+                case "getBytes" -> null;
+                default -> null;
+            }
+        );
+    }
+
+    private static ResultSetMetaData columnMeta(int columnType) {
+        return (ResultSetMetaData) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { ResultSetMetaData.class },
+            (proxy, method, args) -> {
+                if ("getColumnType".equals(method.getName())) {
+                    return columnType;
+                }
+                return null;
+            }
+        );
+    }
+
+    private static DatabaseMetaData tableTypesMeta(String... types) {
+        return (DatabaseMetaData) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { DatabaseMetaData.class },
+            (proxy, method, args) -> {
+                if ("getTableTypes".equals(method.getName())) {
+                    return tableTypesResultSet(types);
+                }
+                return null;
+            }
+        );
+    }
+
+    private static ResultSet tableTypesResultSet(String[] types) {
+        return (ResultSet) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { ResultSet.class },
+            new java.lang.reflect.InvocationHandler() {
+                private int index = -1;
+
+                @Override
+                public Object invoke(Object proxy, Method method, Object[] args) {
+                    return switch (method.getName()) {
+                        case "next" -> ++index < types.length;
+                        case "getString" -> types[index];
+                        case "close" -> null;
+                        default -> null;
+                    };
+                }
+            }
+        );
+    }
+
+    private static Connection showFullColumnsConnection() {
+        return (Connection) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { Connection.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "createStatement" -> showFullColumnsStatement();
+                case "isClosed" -> false;
+                case "close" -> null;
+                default -> defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static Connection kingbaseColumnsConnection(List<String> sql) {
+        ResultSet primaryKeys = rowsResultSet(
+            new String[] { "column_name" },
+            new Object[][] { { "id" } }
+        );
+        ResultSet columns = rowsResultSet(
+            new String[] {
+                "column_name",
+                "data_type",
+                "is_nullable",
+                "column_default",
+                "column_comment",
+                "numeric_precision",
+                "numeric_scale",
+                "character_maximum_length"
+            },
+            new Object[][] {
+                { "id", "INTEGER", false, null, null, 32, 0, null },
+                { "create_time", "TIMESTAMP WITH TIME ZONE", true, null, null, null, null, null },
+                { "create_by", "CHARACTER VARYING(64 byte)", true, null, null, null, null, 64 }
+            }
+        );
+        int[] index = { 0 };
+        return (Connection) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { Connection.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "createStatement" -> {
+                    yield statement(sql, index[0]++ == 0 ? primaryKeys : columns);
+                }
+                case "isClosed" -> false;
+                case "close" -> null;
+                default -> defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static Statement statement(List<String> sql, ResultSet rs) {
+        return (Statement) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { Statement.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "executeQuery" -> {
+                    sql.add(String.valueOf(args[0]));
+                    yield rs;
+                }
+                case "close" -> null;
+                default -> defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static PreparedStatement preparedStatement(ResultSet rs) {
+        return (PreparedStatement) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { PreparedStatement.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "executeQuery" -> rs;
+                case "setString", "close" -> null;
+                default -> defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static ResultSet rowsResultSet(String[] columns, Object[][] rows) {
+        return (ResultSet) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { ResultSet.class },
+            new java.lang.reflect.InvocationHandler() {
+                private int index = -1;
+
+                @Override
+                public Object invoke(Object proxy, Method method, Object[] args) {
+                    return switch (method.getName()) {
+                        case "next" -> ++index < rows.length;
+                        case "getString" -> stringValue(columns, rows[index], args[0]);
+                        case "getBoolean" -> booleanValue(columns, rows[index], args[0]);
+                        case "getObject" -> columnValue(columns, rows[index], args[0]);
+                        case "close" -> null;
+                        default -> defaultValue(method.getReturnType());
+                    };
+                }
+            }
+        );
+    }
+
+    private static String stringValue(String[] columns, Object[] row, Object key) {
+        Object value = columnValue(columns, row, key);
+        return value == null ? null : String.valueOf(value);
+    }
+
+    private static boolean booleanValue(String[] columns, Object[] row, Object key) {
+        Object value = columnValue(columns, row, key);
+        if (value instanceof Boolean bool) return bool;
+        if (value instanceof Number number) return number.intValue() != 0;
+        return Boolean.parseBoolean(String.valueOf(value));
+    }
+
+    private static Object columnValue(String[] columns, Object[] row, Object key) {
+        if (key instanceof Number number) {
+            return row[number.intValue() - 1];
+        }
+        for (int i = 0; i < columns.length; i++) {
+            if (columns[i].equalsIgnoreCase(String.valueOf(key))) {
+                return row[i];
+            }
+        }
+        return null;
+    }
+
+    private static ResultSet columnNullableResultSet(String isNullable, int nullableCode) {
+        return (ResultSet) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { ResultSet.class },
+            (proxy, method, args) -> {
+                if ("getString".equals(method.getName()) && "IS_NULLABLE".equals(args[0])) {
+                    if (isNullable == null) {
+                        throw new SQLException("Column not found: IS_NULLABLE");
+                    }
+                    return isNullable;
+                }
+                if ("getInt".equals(method.getName()) && "NULLABLE".equals(args[0])) {
+                    return nullableCode;
+                }
+                return defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static Statement showFullColumnsStatement() {
+        return (Statement) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { Statement.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "executeQuery" -> showFullColumnsResultSet();
+                case "close" -> null;
+                default -> defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static ResultSet showFullColumnsResultSet() {
+        String[] labels = { "Field", "Type", "Extra", "Comment" };
+        String[][] rows = { { "name", "varchar(32)", "auto_increment", "姓名" } };
+        return (ResultSet) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { ResultSet.class },
+            new java.lang.reflect.InvocationHandler() {
+                private int index = -1;
+
+                @Override
+                public Object invoke(Object proxy, Method method, Object[] args) {
+                    return switch (method.getName()) {
+                        case "next" -> ++index < rows.length;
+                        case "getMetaData" -> resultSetMeta(labels);
+                        case "getString" -> rows[index][((Integer) args[0]) - 1];
+                        case "close" -> null;
+                        default -> defaultValue(method.getReturnType());
+                    };
+                }
+            }
+        );
+    }
+
+    private static ResultSetMetaData resultSetMeta(String[] labels) {
+        return (ResultSetMetaData) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { ResultSetMetaData.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "getColumnCount" -> labels.length;
+                case "getColumnLabel", "getColumnName" -> labels[((Integer) args[0]) - 1];
+                default -> defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static final class PrestoMetadataDriver implements Driver {
+        private final List<String> calls;
+
+        private PrestoMetadataDriver(List<String> calls) {
+            this.calls = calls;
+        }
+
+        @Override
+        public Connection connect(String url, Properties info) throws SQLException {
+            if (!acceptsURL(url)) {
+                return null;
+            }
+            return prestoMetadataConnection(calls);
+        }
+
+        @Override
+        public boolean acceptsURL(String url) {
+            return url != null && url.startsWith("jdbc:presto:");
+        }
+
+        @Override
+        public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) {
+            return new DriverPropertyInfo[0];
+        }
+
+        @Override
+        public int getMajorVersion() {
+            return 1;
+        }
+
+        @Override
+        public int getMinorVersion() {
+            return 0;
+        }
+
+        @Override
+        public boolean jdbcCompliant() {
+            return false;
+        }
+
+        @Override
+        public java.util.logging.Logger getParentLogger() {
+            return java.util.logging.Logger.getGlobal();
+        }
+    }
+
+    private static Connection prestoMetadataConnection(List<String> calls) {
+        return (Connection) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { Connection.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "prepareStatement" -> {
+                    String sql = String.valueOf(args[0]);
+                    calls.add("prepare:" + sql);
+                    yield prestoMetadataStatement(calls, sql);
+                }
+                case "getMetaData" -> throw new SQLException("DatabaseMetaData should not be used for Presto metadata");
+                case "isClosed" -> false;
+                case "close" -> null;
+                default -> defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static PreparedStatement prestoMetadataStatement(List<String> calls, String sql) {
+        return (PreparedStatement) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { PreparedStatement.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "setString" -> {
+                    calls.add("setString:" + args[0] + ":" + args[1]);
+                    yield null;
+                }
+                case "executeQuery" -> {
+                    calls.add("executeQuery");
+                    yield sql.contains("information_schema.columns") ? prestoColumnMetadataResultSet() : prestoMetadataResultSet();
+                }
+                case "close" -> null;
+                default -> defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static ResultSet prestoColumnMetadataResultSet() {
+        String[] labels = { "column_name", "data_type", "is_nullable", "column_default", "comment" };
+        Object[][] rows = { { "amount", "decimal(12,2)", "NO", null, "daily amount" } };
+        return (ResultSet) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { ResultSet.class },
+            new java.lang.reflect.InvocationHandler() {
+                private int index = -1;
+
+                @Override
+                public Object invoke(Object proxy, Method method, Object[] args) {
+                    return switch (method.getName()) {
+                        case "next" -> ++index < rows.length;
+                        case "getMetaData" -> resultSetMeta(labels);
+                        case "getString" -> {
+                            Object value = rows[index][((Integer) args[0]) - 1];
+                            yield value == null ? null : value.toString();
+                        }
+                        case "getObject" -> rows[index][((Integer) args[0]) - 1];
+                        case "close" -> null;
+                        default -> defaultValue(method.getReturnType());
+                    };
+                }
+            }
+        );
+    }
+
+    private static ResultSet prestoMetadataResultSet() {
+        String[] labels = { "table_name", "table_type" };
+        String[][] rows = { { "daily_revenue", "BASE TABLE" }, { "revenue_view", "VIEW" } };
+        return (ResultSet) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { ResultSet.class },
+            new java.lang.reflect.InvocationHandler() {
+                private int index = -1;
+
+                @Override
+                public Object invoke(Object proxy, Method method, Object[] args) {
+                    return switch (method.getName()) {
+                        case "next" -> ++index < rows.length;
+                        case "getMetaData" -> resultSetMeta(labels);
+                        case "getString" -> rows[index][((Integer) args[0]) - 1];
+                        case "getObject" -> rows[index][((Integer) args[0]) - 1];
+                        case "close" -> null;
+                        default -> defaultValue(method.getReturnType());
+                    };
+                }
+            }
+        );
+    }
+
+    private static final class RecordingConnectDriver implements Driver {
+        private final String urlPrefix;
+        private final List<String> urls = new ArrayList<>();
+        private final List<Properties> properties = new ArrayList<>();
+
+        private RecordingConnectDriver(String urlPrefix) {
+            this.urlPrefix = urlPrefix;
+        }
+
+        @Override
+        public Connection connect(String url, Properties info) throws SQLException {
+            if (!acceptsURL(url)) {
+                return null;
+            }
+            urls.add(url);
+            Properties copy = new Properties();
+            copy.putAll(info);
+            properties.add(copy);
+            return recordingConnection();
+        }
+
+        @Override
+        public boolean acceptsURL(String url) {
+            return url != null && url.startsWith(urlPrefix);
+        }
+
+        @Override
+        public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) {
+            return new DriverPropertyInfo[0];
+        }
+
+        @Override
+        public int getMajorVersion() {
+            return 1;
+        }
+
+        @Override
+        public int getMinorVersion() {
+            return 0;
+        }
+
+        @Override
+        public boolean jdbcCompliant() {
+            return false;
+        }
+
+        @Override
+        public java.util.logging.Logger getParentLogger() {
+            return java.util.logging.Logger.getGlobal();
+        }
+    }
+
+    private static Connection recordingConnection() {
+        return (Connection) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { Connection.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "isClosed" -> false;
+                case "isValid" -> true;
+                case "close" -> null;
+                default -> defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static final class BrokenResultSetDriver implements Driver {
+        private final String urlPrefix;
+        private final boolean executeReturnsResultSet;
+        private final int updateCount;
+        private final List<String> calls;
+
+        private BrokenResultSetDriver(String urlPrefix, boolean executeReturnsResultSet, int updateCount) {
+            this(urlPrefix, executeReturnsResultSet, updateCount, new ArrayList<>());
+        }
+
+        private BrokenResultSetDriver(String urlPrefix, boolean executeReturnsResultSet, int updateCount, List<String> calls) {
+            this.urlPrefix = urlPrefix;
+            this.executeReturnsResultSet = executeReturnsResultSet;
+            this.updateCount = updateCount;
+            this.calls = calls;
+        }
+
+        @Override
+        public Connection connect(String url, Properties info) throws SQLException {
+            if (!acceptsURL(url)) {
+                return null;
+            }
+            return brokenResultSetConnection(executeReturnsResultSet, updateCount, calls);
+        }
+
+        @Override
+        public boolean acceptsURL(String url) {
+            return url != null && url.startsWith(urlPrefix);
+        }
+
+        @Override
+        public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) {
+            return new DriverPropertyInfo[0];
+        }
+
+        @Override
+        public int getMajorVersion() {
+            return 1;
+        }
+
+        @Override
+        public int getMinorVersion() {
+            return 0;
+        }
+
+        @Override
+        public boolean jdbcCompliant() {
+            return false;
+        }
+
+        @Override
+        public java.util.logging.Logger getParentLogger() {
+            return java.util.logging.Logger.getGlobal();
+        }
+    }
+
+    private static Connection brokenResultSetConnection(boolean executeReturnsResultSet, int updateCount, List<String> calls) {
+        return (Connection) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { Connection.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "createStatement" -> brokenResultSetStatement(executeReturnsResultSet, updateCount, calls);
+                case "isClosed" -> false;
+                case "close" -> null;
+                default -> defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static Statement brokenResultSetStatement(boolean executeReturnsResultSet, int updateCount, List<String> calls) {
+        return (Statement) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { Statement.class },
+            (proxy, method, args) -> {
+                if ("execute".equals(method.getName()) || "executeQuery".equals(method.getName())) {
+                    calls.add(method.getName());
+                }
+                return switch (method.getName()) {
+                    case "execute" -> executeReturnsResultSet;
+                    case "getResultSet" -> null;
+                    case "getUpdateCount" -> updateCount;
+                    case "executeQuery" -> singleRowResultSet();
+                    case "setMaxRows", "setFetchSize", "setQueryTimeout", "close" -> null;
+                    default -> defaultValue(method.getReturnType());
+                };
+            }
+        );
+    }
+
+    private static ResultSet singleRowResultSet() {
+        return (ResultSet) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { ResultSet.class },
+            new java.lang.reflect.InvocationHandler() {
+                private int index = -1;
+
+                @Override
+                public Object invoke(Object proxy, Method method, Object[] args) {
+                    return switch (method.getName()) {
+                        case "next" -> ++index == 0;
+                        case "getMetaData" -> singleColumnMeta();
+                        case "getObject", "getString" -> "row-value";
+                        case "close" -> null;
+                        default -> defaultValue(method.getReturnType());
+                    };
+                }
+            }
+        );
+    }
+
+    private static ResultSetMetaData singleColumnMeta() {
+        return (ResultSetMetaData) Proxy.newProxyInstance(
+            DbxJdbcPluginTest.class.getClassLoader(),
+            new Class<?>[] { ResultSetMetaData.class },
+            (proxy, method, args) -> switch (method.getName()) {
+                case "getColumnCount" -> 1;
+                case "getColumnLabel", "getColumnName" -> "VALUE";
+                case "getColumnType" -> Types.VARCHAR;
+                default -> defaultValue(method.getReturnType());
+            }
+        );
+    }
+
+    private static Object defaultValue(Class<?> returnType) {
+        if (returnType == boolean.class) return false;
+        if (returnType == byte.class) return (byte) 0;
+        if (returnType == short.class) return (short) 0;
+        if (returnType == int.class) return 0;
+        if (returnType == long.class) return 0L;
+        if (returnType == float.class) return 0f;
+        if (returnType == double.class) return 0d;
+        if (returnType == char.class) return '\0';
+        return null;
+    }
+
+    public static final class ErrorOnLoad {
+        private static final Object FAILURE = fail();
+
+        private static Object fail() {
+            throw new AssertionError("linkage boom");
+        }
+    }
+
+    private static JsonNode request(String method, String params) throws Exception {
+        Method handleLine = DbxJdbcPlugin.class.getDeclaredMethod("handleLine", String.class);
+        handleLine.setAccessible(true);
+        String line = """
+            { "id": 1, "method": "%s", "params": %s }
+            """.formatted(method, params);
+        return MAPPER.valueToTree(handleLine.invoke(null, line));
+    }
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
new file mode 100644
index 0000000..3ea3f57
--- /dev/null
+++ b/pnpm-lock.yaml
@@ -0,0 +1,7883 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+importers:
+
+  .:
+    dependencies:
+      '@babel/runtime':
+        specifier: ^7.29.7
+        version: 7.29.7
+      '@codemirror/autocomplete':
+        specifier: ^6.20.2
+        version: 6.20.2
+      '@codemirror/commands':
+        specifier: ^6.10.3
+        version: 6.10.3
+      '@codemirror/lang-html':
+        specifier: ^6.4.11
+        version: 6.4.11
+      '@codemirror/lang-json':
+        specifier: ^6.0.2
+        version: 6.0.2
+      '@codemirror/lang-sql':
+        specifier: ^6.10.0
+        version: 6.10.0
+      '@codemirror/lang-xml':
+        specifier: ^6.1.0
+        version: 6.1.0
+      '@codemirror/lang-yaml':
+        specifier: ^6.1.3
+        version: 6.1.3
+      '@codemirror/language':
+        specifier: ^6.12.3
+        version: 6.12.3
+      '@codemirror/legacy-modes':
+        specifier: ^6.5.3
+        version: 6.5.3
+      '@codemirror/search':
+        specifier: ^6.7.0
+        version: 6.7.0
+      '@codemirror/state':
+        specifier: ^6.6.0
+        version: 6.6.0
+      '@codemirror/theme-one-dark':
+        specifier: ^6.1.3
+        version: 6.1.3
+      '@codemirror/view':
+        specifier: ^6.43.0
+        version: 6.43.0
+      '@lezer/highlight':
+        specifier: ^1.2.3
+        version: 1.2.3
+      '@lucide/vue':
+        specifier: 1.17.0
+        version: 1.17.0(vue@3.5.35(typescript@6.0.3))
+      '@msgpack/msgpack':
+        specifier: ^3.1.3
+        version: 3.1.3
+      '@replit/codemirror-vim':
+        specifier: ^6.3.0
+        version: 6.3.0(@codemirror/commands@6.10.3)(@codemirror/language@6.12.3)(@codemirror/search@6.7.0)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+      '@tauri-apps/api':
+        specifier: ^2.11.0
+        version: 2.11.0
+      '@tauri-apps/plugin-clipboard-manager':
+        specifier: ^2.3.2
+        version: 2.3.2
+      '@tauri-apps/plugin-dialog':
+        specifier: ^2.7.1
+        version: 2.7.1
+      '@tauri-apps/plugin-fs':
+        specifier: ^2.5.1
+        version: 2.5.1
+      '@tauri-apps/plugin-process':
+        specifier: ^2.3.1
+        version: 2.3.1
+      '@tauri-apps/plugin-shell':
+        specifier: ^2.3.5
+        version: 2.3.5
+      '@tauri-apps/plugin-updater':
+        specifier: ^2.10.1
+        version: 2.10.1
+      '@uiw/codemirror-theme-duotone':
+        specifier: ^4.25.10
+        version: 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+      '@uiw/codemirror-theme-material':
+        specifier: ^4.25.10
+        version: 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+      '@uiw/codemirror-theme-nord':
+        specifier: ^4.25.10
+        version: 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+      '@uiw/codemirror-theme-okaidia':
+        specifier: ^4.25.10
+        version: 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+      '@uiw/codemirror-theme-vscode':
+        specifier: ^4.25.10
+        version: 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+      '@uiw/codemirror-theme-xcode':
+        specifier: ^4.25.10
+        version: 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+      '@vueuse/core':
+        specifier: ^14.2.1
+        version: 14.2.1(vue@3.5.35(typescript@6.0.3))
+      class-variance-authority:
+        specifier: ^0.7.1
+        version: 0.7.1
+      clsx:
+        specifier: ^2.1.1
+        version: 2.1.1
+      codemirror:
+        specifier: ^6.0.2
+        version: 6.0.2
+      dayjs:
+        specifier: ^1.11.21
+        version: 1.11.21
+      diff:
+        specifier: ^9.0.0
+        version: 9.0.0
+      dom-to-image-more:
+        specifier: ^3.7.2
+        version: 3.7.2
+      echarts:
+        specifier: ^6.1.0
+        version: 6.1.0
+      leaflet:
+        specifier: ^1.9.4
+        version: 1.9.4
+      marked:
+        specifier: ^18.0.4
+        version: 18.0.4
+      pinia:
+        specifier: ^3.0.0
+        version: 3.0.4(typescript@6.0.3)(vue@3.5.35(typescript@6.0.3))
+      reka-ui:
+        specifier: ^2.10.1
+        version: 2.10.1(vue@3.5.35(typescript@6.0.3))
+      shadcn-vue:
+        specifier: ^2.7.4
+        version: 2.7.4(eslint@10.2.1(jiti@2.7.0))(vue@3.5.35(typescript@6.0.3))
+      shiki:
+        specifier: ^4.2.0
+        version: 4.2.0
+      splitpanes:
+        specifier: ^4.1.2
+        version: 4.1.2(vue@3.5.35(typescript@6.0.3))
+      sql-formatter:
+        specifier: ^15.8.0
+        version: 15.8.0
+      tailwind-merge:
+        specifier: ^3.6.0
+        version: 3.6.0
+      tw-animate-css:
+        specifier: ^1.4.0
+        version: 1.4.0
+      vue:
+        specifier: ^3.5.35
+        version: 3.5.35(typescript@6.0.3)
+      vue-echarts:
+        specifier: ^8.0.1
+        version: 8.0.1(echarts@6.1.0)(vue@3.5.35(typescript@6.0.3))
+      vue-i18n:
+        specifier: ^11.4.4
+        version: 11.4.4(vue@3.5.35(typescript@6.0.3))
+      vue-virtual-scroller:
+        specifier: ^3.0.4
+        version: 3.0.4(vue@3.5.35(typescript@6.0.3))
+    devDependencies:
+      '@oxfmt/binding-darwin-arm64':
+        specifier: 0.53.0
+        version: 0.53.0
+      '@oxlint/binding-darwin-arm64':
+        specifier: 1.68.0
+        version: 1.68.0
+      '@tailwindcss/vite':
+        specifier: ^4.3.0
+        version: 4.3.0(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4))
+      '@tauri-apps/cli':
+        specifier: ^2.11.2
+        version: 2.11.2
+      '@types/leaflet':
+        specifier: ^1.9.21
+        version: 1.9.21
+      '@types/node':
+        specifier: ^25.9.1
+        version: 25.9.1
+      '@types/splitpanes':
+        specifier: ^2.2.6
+        version: 2.2.6
+      '@vitejs/plugin-vue':
+        specifier: ^6.0.7
+        version: 6.0.7(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4))(vue@3.5.35(typescript@6.0.3))
+      husky:
+        specifier: ^9.1.7
+        version: 9.1.7
+      lint-staged:
+        specifier: ^16.4.0
+        version: 16.4.0
+      oxfmt:
+        specifier: 0.53.0
+        version: 0.53.0
+      oxlint:
+        specifier: ^1.68.0
+        version: 1.68.0
+      tailwindcss:
+        specifier: ^4.3.0
+        version: 4.3.0
+      tsx:
+        specifier: ^4.22.4
+        version: 4.22.4
+      typescript:
+        specifier: ~6.0.3
+        version: 6.0.3
+      vite:
+        specifier: ^8.0.16
+        version: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4)
+      vitest:
+        specifier: ^4.1.8
+        version: 4.1.8(@types/node@25.9.1)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4))
+      vue-tsc:
+        specifier: ^3.3.3
+        version: 3.3.3(typescript@6.0.3)
+
+  packages/cli:
+    dependencies:
+      '@dbx-app/node-core':
+        specifier: workspace:^
+        version: link:../node-core
+    devDependencies:
+      '@types/node':
+        specifier: ^22.15.21
+        version: 22.19.19
+      tsx:
+        specifier: ^4.19.4
+        version: 4.21.0
+      typescript:
+        specifier: ^5.8.3
+        version: 5.9.3
+
+  packages/mcp-server:
+    dependencies:
+      '@dbx-app/node-core':
+        specifier: workspace:^
+        version: link:../node-core
+      '@modelcontextprotocol/sdk':
+        specifier: ^1.12.1
+        version: 1.29.0(zod@3.25.76)
+      zod:
+        specifier: ^3.25.20
+        version: 3.25.76
+    devDependencies:
+      '@types/node':
+        specifier: ^22.15.21
+        version: 22.19.19
+      tsx:
+        specifier: ^4.19.4
+        version: 4.21.0
+      typescript:
+        specifier: ^5.8.3
+        version: 5.9.3
+
+  packages/node-core:
+    dependencies:
+      better-sqlite3:
+        specifier: ^12.9.0
+        version: 12.10.0
+      ioredis:
+        specifier: ^5.11.1
+        version: 5.11.1
+      keytar:
+        specifier: ^7.9.0
+        version: 7.9.0
+      mysql2:
+        specifier: ^3.14.1
+        version: 3.22.3(@types/node@22.19.19)
+      pg:
+        specifier: ^8.16.0
+        version: 8.20.0
+    devDependencies:
+      '@types/better-sqlite3':
+        specifier: ^7.6.13
+        version: 7.6.13
+      '@types/node':
+        specifier: ^22.15.21
+        version: 22.19.19
+      '@types/pg':
+        specifier: ^8.15.4
+        version: 8.20.0
+      tsx:
+        specifier: ^4.19.4
+        version: 4.21.0
+      typescript:
+        specifier: ^5.8.3
+        version: 5.9.3
+
+packages:
+
+  '@babel/code-frame@7.29.7':
+    resolution: {integrity: sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/compat-data@7.29.7':
+    resolution: {integrity: sha512-locTkQyKvwIEgBzVrn8693ebc97F2U8ZHjbXwDXJ5Fn2TCpNwTlKcaKLkdHop5c/icOFE7qt7Q9JC5hnKNa6Gg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/core@7.29.7':
+    resolution: {integrity: sha512-RgHBCvtjbOK2gXSNBNIkNoEc9qoVEtau3hj8gEqKQuL3HZAibKarWFEI3Lfm6EYKkLalOh8eSrj9b+ch9H/VBA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/generator@7.29.7':
+    resolution: {integrity: sha512-DkXD5OJQaAQIdZ1bt3UZdEnHAn9Imd3IVBdX03UFe+ony9Ojw5pzr9YVKGDY1jt+Gcn/FnGkNf8r+Vj5NOJWtQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-annotate-as-pure@7.29.7':
+    resolution: {integrity: sha512-OoK6239jHPuSQOoS0kfTVKn0b/rVTk0seKq4Gd2UMLtmOVLjDC0ki3e+c90Trqv2gMfvJFqkiljrr568+qddiw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-compilation-targets@7.29.7':
+    resolution: {integrity: sha512-wem6WaBj4NaVYVdNhLPPVacES6ZJ+KBBfSkTMD3YZxbP3rm3Di85tJU5ljaUNhaOynt+Aj0xruhYuzQBt8n71g==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-create-class-features-plugin@7.29.7':
+    resolution: {integrity: sha512-IY3ZD9Tmooqr3TUhc3DUWxiuo8xx1DWLhd5M7hQ+ZWJamqM2BbalrBJb2MisSLoYorOj75U03qULCxQTY9r3hg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-globals@7.29.7':
+    resolution: {integrity: sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-member-expression-to-functions@7.29.7':
+    resolution: {integrity: sha512-j+7JYmk1JYDtACIGj0QJqqWZjoUpMoEikQGADMaHgCMCSDqd2+P32rfcibUNrGOMWrlzK1WJBdxrB3JJQZwWtg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-imports@7.29.7':
+    resolution: {integrity: sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-module-transforms@7.29.7':
+    resolution: {integrity: sha512-UPUVSyXbOh627KiCIGQSgwWzGeBKLkaJ9PJEdrngIwMSzxLR4jS4+f1f1jb7VzBbg8nFLaYotvVPFCTqdrmTAg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-optimise-call-expression@7.29.7':
+    resolution: {integrity: sha512-+kmGVjcT9RGYzoDwdwEqEvGgKe3BYq+O1iGzjFubaNgZHwYHP6lsF2Yghf4kEuv9BV7tYDZ913aBW9am6YKong==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-plugin-utils@7.29.7':
+    resolution: {integrity: sha512-G7sHYigPY17oO5SYWnfD/0MTBwVR781S/JI643e/JhUYgVgWE/61SoW3NH9KWUKyKq5LVh3npif99Wkt6j86Jw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-replace-supers@7.29.7':
+    resolution: {integrity: sha512-atfGXWSeCiF4DnKZIfmJfQRkSw9b9gNNXR1kqKjbhG4pGYCOnkp8OcTB8E3NXjBu8NpheSnOeNKz8KT7UNFTmQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+
+  '@babel/helper-skip-transparent-expression-wrappers@7.29.7':
+    resolution: {integrity: sha512-brcMGQaVzIeUb+6/bs1Av0f8YuNNjKY2JyvfRCsFuFsdKccEQ5Ges2y74D74NZ1Rz8lKJ9ksJkfqwQFJ/iNEyQ==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-string-parser@7.29.7':
+    resolution: {integrity: sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-identifier@7.29.7':
+    resolution: {integrity: sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helper-validator-option@7.29.7':
+    resolution: {integrity: sha512-N9ZErrD+yW5geCDtBqnOoxmR8+tNKiGuxKlDpuJxfsqpa2dFcexaziGAE/qoHLiDDreVNMupxGmSoNlyvsA3gw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/helpers@7.29.7':
+    resolution: {integrity: sha512-1k2lAGRMfHTcwuNYcCNUmaUffmQv8KWMfh2iJUUeRlwlwH4FdNG7mfPI10NPfLHJFThE4Tyr4mv7kTNZOiPuBg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/parser@7.29.7':
+    resolution: {integrity: sha512-hnORnjP/1P/zFEndoeX+n+t1RwWRJiJpM/jO7FW32Kn9r5+sJB2JWOdYo4L6k78j15eCwY3Gm/7364B1EMwtNg==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  '@babel/parser@8.0.0-alpha.12':
+    resolution: {integrity: sha512-AzWmrp4uJ+DcXVH0uoUpJVhRqxNirC0BbXsZ82AQuVod41CoaV5G+cwcvtYusrIIxv7BIJb6ce0dQ9L0wAl1iA==}
+    engines: {node: ^18.20.0 || ^20.10.0 || >=21.0.0}
+    hasBin: true
+
+  '@babel/plugin-syntax-jsx@7.29.7':
+    resolution: {integrity: sha512-TSu8+mHCoEaaCDEZ0I3+6mvTBYR4PCxQwf2z9/r5Tbztv6NaLR3B9thGTTxX2WGuGHJqRiAbKPeGTJ5XWXVg6A==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-syntax-typescript@7.29.7':
+    resolution: {integrity: sha512-ngr+82Sh0xMz25TPCZi+nC2iTzjfCdWS2ONXTp/PtSCHCgaCNBpdMqgvJ2ccdLlClVZ7sisIgB914j/JFe+RZA==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-modules-commonjs@7.29.7':
+    resolution: {integrity: sha512-j0vCldybPC5b5dwCQOJ21uKtHzt7hxLygJTg9eF1ScfaikEDNfzn94XoW5Fi+seBR0nCyL23xaBFFkq7dTM8XQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/plugin-transform-typescript@7.29.7':
+    resolution: {integrity: sha512-jK52h8LaLc7JarhQV2ofeFMts4H7vnOXnqZNA6fYglBTZewRBE51KWt3BUltW1P+KoPsYkHoJeXePuz4zo2LMw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/preset-typescript@7.29.7':
+    resolution: {integrity: sha512-/Foi8vKY2EVbed/1eZx0gJEEwHAIxogrySI7rULcRIvhZzbvoE/b5qG5Ghc0WKAFKOHA9SD1x7RsFlOYdutIiQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+
+  '@babel/runtime@7.29.7':
+    resolution: {integrity: sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/template@7.29.7':
+    resolution: {integrity: sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/traverse@7.29.7':
+    resolution: {integrity: sha512-EhlfNQtZ+NK22w5BM61ciuiq1m58ed33Wr1Xan//ZRTy6hgjnwyCffRYwzsGXdASJSUJ1guZILsErh1eQcl+zw==}
+    engines: {node: '>=6.9.0'}
+
+  '@babel/types@7.29.7':
+    resolution: {integrity: sha512-4zBIxpPzowiZpusoFkyGVwakdRJUyuH5PxQ/PrqghfdFWWasvnCdPfQXHrenDai+gyLARulZjZowCOj6fjT4pA==}
+    engines: {node: '>=6.9.0'}
+
+  '@codemirror/autocomplete@6.20.2':
+    resolution: {integrity: sha512-G5FPkgIiLjOgZMjqVjvuKQ1rGPtHogLldJr33eFJdVLtmwY+giGrlv/ewljLz6b9BSQLkjxuwBc6g6omDM+YxQ==}
+
+  '@codemirror/commands@6.10.3':
+    resolution: {integrity: sha512-JFRiqhKu+bvSkDLI+rUhJwSxQxYb759W5GBezE8Uc8mHLqC9aV/9aTC7yJSqCtB3F00pylrLCwnyS91Ap5ej4Q==}
+
+  '@codemirror/lang-css@6.3.1':
+    resolution: {integrity: sha512-kr5fwBGiGtmz6l0LSJIbno9QrifNMUusivHbnA1H6Dmqy4HZFte3UAICix1VuKo0lMPKQr2rqB+0BkKi/S3Ejg==}
+
+  '@codemirror/lang-html@6.4.11':
+    resolution: {integrity: sha512-9NsXp7Nwp891pQchI7gPdTwBuSuT3K65NGTHWHNJ55HjYcHLllr0rbIZNdOzas9ztc1EUVBlHou85FFZS4BNnw==}
+
+  '@codemirror/lang-javascript@6.2.5':
+    resolution: {integrity: sha512-zD4e5mS+50htS7F+TYjBPsiIFGanfVqg4HyUz6WNFikgOPf2BgKlx+TQedI1w6n/IqRBVBbBWmGFdLB/7uxO4A==}
+
+  '@codemirror/lang-json@6.0.2':
+    resolution: {integrity: sha512-x2OtO+AvwEHrEwR0FyyPtfDUiloG3rnVTSZV1W8UteaLL8/MajQd8DpvUb2YVzC+/T18aSDv0H9mu+xw0EStoQ==}
+
+  '@codemirror/lang-sql@6.10.0':
+    resolution: {integrity: sha512-6ayPkEd/yRw0XKBx5uAiToSgGECo/GY2NoJIHXIIQh1EVwLuKoU8BP/qK0qH5NLXAbtJRLuT73hx7P9X34iO4w==}
+
+  '@codemirror/lang-xml@6.1.0':
+    resolution: {integrity: sha512-3z0blhicHLfwi2UgkZYRPioSgVTo9PV5GP5ducFH6FaHy0IAJRg+ixj5gTR1gnT/glAIC8xv4w2VL1LoZfs+Jg==}
+
+  '@codemirror/lang-yaml@6.1.3':
+    resolution: {integrity: sha512-AZ8DJBuXGVHybpBQhmZtgew5//4hv3tdkXnr3vDmOUMJRuB6vn/uuwtmTOTlqEaQFg3hQSVeA90NmvIQyUV6FQ==}
+
+  '@codemirror/language@6.12.3':
+    resolution: {integrity: sha512-QwCZW6Tt1siP37Jet9Tb02Zs81TQt6qQrZR2H+eGMcFsL1zMrk2/b9CLC7/9ieP1fjIUMgviLWMmgiHoJrj+ZA==}
+
+  '@codemirror/legacy-modes@6.5.3':
+    resolution: {integrity: sha512-xCsmIzH78MyWkib9jlPaaun57XNkfbMIhagfaZVd0iLTqlpw3jXaIcbZm72MTmmn64eTZpBVNjbyYh+QXnxRsg==}
+
+  '@codemirror/lint@6.9.5':
+    resolution: {integrity: sha512-GElsbU9G7QT9xXhpUg1zWGmftA/7jamh+7+ydKRuT0ORpWS3wOSP0yT1FOlIZa7mIJjpVPipErsyvVqB9cfTFA==}
+
+  '@codemirror/search@6.7.0':
+    resolution: {integrity: sha512-ZvGm99wc/s2cITtMT15LFdn8aH/aS+V+DqyGq/N5ZlV5vWtH+nILvC2nw0zX7ByNoHHDZ2IxxdW38O0tc5nVHg==}
+
+  '@codemirror/state@6.6.0':
+    resolution: {integrity: sha512-4nbvra5R5EtiCzr9BTHiTLc+MLXK2QGiAVYMyi8PkQd3SR+6ixar/Q/01Fa21TBIDOZXgeWV4WppsQolSreAPQ==}
+
+  '@codemirror/theme-one-dark@6.1.3':
+    resolution: {integrity: sha512-NzBdIvEJmx6fjeremiGp3t/okrLPYT0d9orIc7AFun8oZcRk58aejkqhv6spnz4MLAevrKNPMQYXEWMg4s+sKA==}
+
+  '@codemirror/view@6.43.0':
+    resolution: {integrity: sha512-V7ZCLQO3Jus9hzh2jVCCPW3mO4IBMr43O37PqSUYautJSnnJF41YlgLw21x0fLJTYvJ+Vkm6Gp+qKGH9pltgXA==}
+
+  '@dotenvx/dotenvx@1.75.1':
+    resolution: {integrity: sha512-/BITOC9dmS/edY2zQwZNicQ059O6RKabtQfyEafV0nGtfYRNHYy1DIPiYVcov40+tob9hfmBnbR963dS+EQ1DQ==}
+    hasBin: true
+
+  '@dotenvx/primitives@0.8.0':
+    resolution: {integrity: sha512-VYJy0uhFm9zTJ1TxBaW/pA8bjbOM/OttaNMwZ1RHG4JKyRG7DhSdiqD1ipQoAyoD22olUtxbP78W9xY3Wd11bg==}
+
+  '@emnapi/core@1.10.0':
+    resolution: {integrity: sha512-yq6OkJ4p82CAfPl0u9mQebQHKPJkY7WrIuk205cTYnYe+k2Z8YBh11FrbRG/H6ihirqcacOgl2BIO8oyMQLeXw==}
+
+  '@emnapi/runtime@1.10.0':
+    resolution: {integrity: sha512-ewvYlk86xUoGI0zQRNq/mC+16R1QeDlKQy21Ki3oSYXNgLb45GV1P6A0M+/s6nyCuNDqe5VpaY84BzXGwVbwFA==}
+
+  '@emnapi/wasi-threads@1.2.1':
+    resolution: {integrity: sha512-uTII7OYF+/Mes/MrcIOYp5yOtSMLBWSIoLPpcgwipoiKbli6k322tcoFsxoIIxPDqW01SQGAgko4EzZi2BNv2w==}
+
+  '@esbuild/aix-ppc64@0.27.7':
+    resolution: {integrity: sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/aix-ppc64@0.28.0':
+    resolution: {integrity: sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [aix]
+
+  '@esbuild/android-arm64@0.27.7':
+    resolution: {integrity: sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm64@0.28.0':
+    resolution: {integrity: sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [android]
+
+  '@esbuild/android-arm@0.27.7':
+    resolution: {integrity: sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-arm@0.28.0':
+    resolution: {integrity: sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [android]
+
+  '@esbuild/android-x64@0.27.7':
+    resolution: {integrity: sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/android-x64@0.28.0':
+    resolution: {integrity: sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [android]
+
+  '@esbuild/darwin-arm64@0.27.7':
+    resolution: {integrity: sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-arm64@0.28.0':
+    resolution: {integrity: sha512-0T+A9WZm+bZ84nZBtk1ckYsOvyA3x7e2Acj1KdVfV4/2tdG4fzUp91YHx+GArWLtwqp77pBXVCPn2We7Letr0Q==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.27.7':
+    resolution: {integrity: sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/darwin-x64@0.28.0':
+    resolution: {integrity: sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@esbuild/freebsd-arm64@0.27.7':
+    resolution: {integrity: sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-arm64@0.28.0':
+    resolution: {integrity: sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.27.7':
+    resolution: {integrity: sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/freebsd-x64@0.28.0':
+    resolution: {integrity: sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@esbuild/linux-arm64@0.27.7':
+    resolution: {integrity: sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm64@0.28.0':
+    resolution: {integrity: sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.27.7':
+    resolution: {integrity: sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-arm@0.28.0':
+    resolution: {integrity: sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw==}
+    engines: {node: '>=18'}
+    cpu: [arm]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.27.7':
+    resolution: {integrity: sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-ia32@0.28.0':
+    resolution: {integrity: sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.27.7':
+    resolution: {integrity: sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-loong64@0.28.0':
+    resolution: {integrity: sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg==}
+    engines: {node: '>=18'}
+    cpu: [loong64]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.27.7':
+    resolution: {integrity: sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-mips64el@0.28.0':
+    resolution: {integrity: sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w==}
+    engines: {node: '>=18'}
+    cpu: [mips64el]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.27.7':
+    resolution: {integrity: sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-ppc64@0.28.0':
+    resolution: {integrity: sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg==}
+    engines: {node: '>=18'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.27.7':
+    resolution: {integrity: sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-riscv64@0.28.0':
+    resolution: {integrity: sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ==}
+    engines: {node: '>=18'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.27.7':
+    resolution: {integrity: sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-s390x@0.28.0':
+    resolution: {integrity: sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q==}
+    engines: {node: '>=18'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.27.7':
+    resolution: {integrity: sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/linux-x64@0.28.0':
+    resolution: {integrity: sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [linux]
+
+  '@esbuild/netbsd-arm64@0.27.7':
+    resolution: {integrity: sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-arm64@0.28.0':
+    resolution: {integrity: sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.27.7':
+    resolution: {integrity: sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/netbsd-x64@0.28.0':
+    resolution: {integrity: sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [netbsd]
+
+  '@esbuild/openbsd-arm64@0.27.7':
+    resolution: {integrity: sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-arm64@0.28.0':
+    resolution: {integrity: sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.27.7':
+    resolution: {integrity: sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openbsd-x64@0.28.0':
+    resolution: {integrity: sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [openbsd]
+
+  '@esbuild/openharmony-arm64@0.27.7':
+    resolution: {integrity: sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/openharmony-arm64@0.28.0':
+    resolution: {integrity: sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@esbuild/sunos-x64@0.27.7':
+    resolution: {integrity: sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/sunos-x64@0.28.0':
+    resolution: {integrity: sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [sunos]
+
+  '@esbuild/win32-arm64@0.27.7':
+    resolution: {integrity: sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-arm64@0.28.0':
+    resolution: {integrity: sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA==}
+    engines: {node: '>=18'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.27.7':
+    resolution: {integrity: sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-ia32@0.28.0':
+    resolution: {integrity: sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA==}
+    engines: {node: '>=18'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.27.7':
+    resolution: {integrity: sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@esbuild/win32-x64@0.28.0':
+    resolution: {integrity: sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw==}
+    engines: {node: '>=18'}
+    cpu: [x64]
+    os: [win32]
+
+  '@eslint-community/eslint-utils@4.9.1':
+    resolution: {integrity: sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
+
+  '@eslint-community/regexpp@4.12.2':
+    resolution: {integrity: sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew==}
+    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
+
+  '@eslint/config-array@0.23.5':
+    resolution: {integrity: sha512-Y3kKLvC1dvTOT+oGlqNQ1XLqK6D1HU2YXPc52NmAlJZbMMWDzGYXMiPRJ8TYD39muD/OTjlZmNJ4ib7dvSrMBA==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/config-helpers@0.5.5':
+    resolution: {integrity: sha512-eIJYKTCECbP/nsKaaruF6LW967mtbQbsw4JTtSVkUQc9MneSkbrgPJAbKl9nWr0ZeowV8BfsarBmPpBzGelA2w==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/core@1.2.1':
+    resolution: {integrity: sha512-MwcE1P+AZ4C6DWlpin/OmOA54mmIZ/+xZuJiQd4SyB29oAJjN30UW9wkKNptW2ctp4cEsvhlLY/CsQ1uoHDloQ==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/object-schema@3.0.5':
+    resolution: {integrity: sha512-vqTaUEgxzm+YDSdElad6PiRoX4t8VGDjCtt05zn4nU810UIx/uNEV7/lZJ6KwFThKZOzOxzXy48da+No7HZaMw==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@eslint/plugin-kit@0.7.2':
+    resolution: {integrity: sha512-+CNAzxglkrpNf/kKywqQfk74QjtceuOE7Qm+AF8miRvPF/wmmK5+OJOgVh3AVTT3RP2mH3+FOaxlE5v72owk0A==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  '@floating-ui/core@1.7.5':
+    resolution: {integrity: sha512-1Ih4WTWyw0+lKyFMcBHGbb5U5FtuHJuujoyyr5zTaWS5EYMeT6Jb2AuDeftsCsEuchO+mM2ij5+q9crhydzLhQ==}
+
+  '@floating-ui/dom@1.7.6':
+    resolution: {integrity: sha512-9gZSAI5XM36880PPMm//9dfiEngYoC6Am2izES1FF406YFsjvyBMmeJ2g4SAju3xWwtuynNRFL2s9hgxpLI5SQ==}
+
+  '@floating-ui/utils@0.2.11':
+    resolution: {integrity: sha512-RiB/yIh78pcIxl6lLMG0CgBXAZ2Y0eVHqMPYugu+9U0AeT6YBeiJpf7lbdJNIugFP5SIjwNRgo4DhR1Qxi26Gg==}
+
+  '@floating-ui/vue@1.1.11':
+    resolution: {integrity: sha512-HzHKCNVxnGS35r9fCHBc3+uCnjw9IWIlCPL683cGgM9Kgj2BiAl8x1mS7vtvP6F9S/e/q4O6MApwSHj8hNLGfw==}
+
+  '@hono/node-server@1.19.14':
+    resolution: {integrity: sha512-GwtvgtXxnWsucXvbQXkRgqksiH2Qed37H9xHZocE5sA3N8O8O8/8FA3uclQXxXVzc9XBZuEOMK7+r02FmSpHtw==}
+    engines: {node: '>=18.14.1'}
+    peerDependencies:
+      hono: ^4
+
+  '@humanfs/core@0.19.2':
+    resolution: {integrity: sha512-UhXNm+CFMWcbChXywFwkmhqjs3PRCmcSa/hfBgLIb7oQ5HNb1wS0icWsGtSAUNgefHeI+eBrA8I1fxmbHsGdvA==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanfs/node@0.16.8':
+    resolution: {integrity: sha512-gE1eQNZ3R++kTzFUpdGlpmy8kDZD/MLyHqDwqjkVQI0JMdI1D51sy1H958PNXYkM2rAac7e5/CnIKZrHtPh3BQ==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanfs/types@0.15.0':
+    resolution: {integrity: sha512-ZZ1w0aoQkwuUuC7Yf+7sdeaNfqQiiLcSRbfI08oAxqLtpXQr9AIVX7Ay7HLDuiLYAaFPu8oBYNq/QIi9URHJ3Q==}
+    engines: {node: '>=18.18.0'}
+
+  '@humanwhocodes/module-importer@1.0.1':
+    resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==}
+    engines: {node: '>=12.22'}
+
+  '@humanwhocodes/retry@0.4.3':
+    resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==}
+    engines: {node: '>=18.18'}
+
+  '@internationalized/date@3.12.2':
+    resolution: {integrity: sha512-FY1Y+H64NDs+HAF6omlnWxm3mEpfgaCSWtL5l551ZZfImA+kGjPFgrnJrGjH6lfmLL0g8Z/mBu1R3kufeCp6Jw==}
+
+  '@internationalized/number@3.6.7':
+    resolution: {integrity: sha512-3ji1fcrT+FPAK86UqEhB/psHixYo6niWPJtt7+qRaYFynt/BaJG8GhAPimtWUpEiVSTq8ZM8L5psMxGquiB/Vg==}
+
+  '@intlify/core-base@11.4.4':
+    resolution: {integrity: sha512-w/vItlylrAmhebkIbVl5YY8XMCtj8Mb2g70ttxktMYuf5AuRahgEHL2iLgLIsZBIbTSgs4hkUo7ucCL0uTJvOg==}
+    engines: {node: '>= 22'}
+
+  '@intlify/devtools-types@11.4.4':
+    resolution: {integrity: sha512-PcBLmGmDQsTSVV911P8upzpcLJO1CNVYi/IH6bGnLR2nA+0L963+kXN1ZrisTEnbtw2ewN6HMMSldqzjronA0Q==}
+    engines: {node: '>= 22'}
+
+  '@intlify/message-compiler@11.4.4':
+    resolution: {integrity: sha512-vn0OAV9pYkJlPPmgnsSm5eAG3mL0+9C/oaded2JY9jmxBbhmUXT3TcAUY8WRgLY9Hte7lkUJKpXrVlYjMXBD2w==}
+    engines: {node: '>= 22'}
+
+  '@intlify/shared@11.4.4':
+    resolution: {integrity: sha512-QRUCHqda1U6aR14FR0vvXD4+4gj6+fm0AhAozvSuRCw0fCvrmCugWpgiR4xH2NI6s8am6N9p5OhirplsX8ZS3g==}
+    engines: {node: '>= 22'}
+
+  '@ioredis/commands@1.10.0':
+    resolution: {integrity: sha512-UmeW7z4LfctwoQ5wkhVzgq8tXkreED2xZGpX+Bg+zA+WJFZCT6c062AfCK/Dfk81xZnnwdhJCUMkitihRaoC2Q==}
+
+  '@isaacs/cliui@9.0.0':
+    resolution: {integrity: sha512-AokJm4tuBHillT+FpMtxQ60n8ObyXBatq7jD2/JA9dxbDDokKQm8KMht5ibGzLVU9IJDIKK4TPKgMHEYMn3lMg==}
+    engines: {node: '>=18'}
+
+  '@jridgewell/gen-mapping@0.3.13':
+    resolution: {integrity: sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==}
+
+  '@jridgewell/remapping@2.3.5':
+    resolution: {integrity: sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==}
+
+  '@jridgewell/resolve-uri@3.1.2':
+    resolution: {integrity: sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==}
+    engines: {node: '>=6.0.0'}
+
+  '@jridgewell/sourcemap-codec@1.5.5':
+    resolution: {integrity: sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
+
+  '@lezer/common@1.5.2':
+    resolution: {integrity: sha512-sxQE460fPZyU3sdc8lafxiPwJHBzZRy/udNFynGQky1SePYBdhkBl1kOagA9uT3pxR8K09bOrmTUqA9wb/PjSQ==}
+
+  '@lezer/css@1.3.3':
+    resolution: {integrity: sha512-RzBo8r+/6QJeow7aPHIpGVIH59xTcJXp399820gZoMo9noQDRVpJLheIBUicYwKcsbOYoBRoLZlf2720dG/4Tg==}
+
+  '@lezer/highlight@1.2.3':
+    resolution: {integrity: sha512-qXdH7UqTvGfdVBINrgKhDsVTJTxactNNxLk7+UMwZhU13lMHaOBlJe9Vqp907ya56Y3+ed2tlqzys7jDkTmW0g==}
+
+  '@lezer/html@1.3.13':
+    resolution: {integrity: sha512-oI7n6NJml729m7pjm9lvLvmXbdoMoi2f+1pwSDJkl9d68zGr7a9Btz8NdHTGQZtW2DA25ybeuv/SyDb9D5tseg==}
+
+  '@lezer/javascript@1.5.4':
+    resolution: {integrity: sha512-vvYx3MhWqeZtGPwDStM2dwgljd5smolYD2lR2UyFcHfxbBQebqx8yjmFmxtJ/E6nN6u1D9srOiVWm3Rb4tmcUA==}
+
+  '@lezer/json@1.0.3':
+    resolution: {integrity: sha512-BP9KzdF9Y35PDpv04r0VeSTKDeox5vVr3efE7eBbx3r4s3oNLfunchejZhjArmeieBH+nVOpgIiBJpEAv8ilqQ==}
+
+  '@lezer/lr@1.4.10':
+    resolution: {integrity: sha512-rnCpTIBafOx4mRp43xOxDJbFipJm/c0cia/V5TiGlhmMa+wsSdoGmUN3w5Bqrks/09Q/D4tNAmWaT8p6NRi77A==}
+
+  '@lezer/xml@1.0.6':
+    resolution: {integrity: sha512-CdDwirL0OEaStFue/66ZmFSeppuL6Dwjlk8qk153mSQwiSH/Dlri4GNymrNWnUmPl2Um7QfV1FO9KFUyX3Twww==}
+
+  '@lezer/yaml@1.0.4':
+    resolution: {integrity: sha512-2lrrHqxalACEbxIbsjhqGpSW8kWpUKuY6RHgnSAFZa6qK62wvnPxA8hGOwOoDbwHcOFs5M4o27mjGu+P7TvBmw==}
+
+  '@lucide/vue@1.17.0':
+    resolution: {integrity: sha512-6Q1ZHgr5FbmJzKWe5BxlNdjLj2lbmuH1zwDtVzUJofX0w9UREwKgq4F4jwKqFYyyIS4Rj3FiJvDi2k6djukmmw==}
+    peerDependencies:
+      vue: '>=3.0.1'
+
+  '@marijn/find-cluster-break@1.0.2':
+    resolution: {integrity: sha512-l0h88YhZFyKdXIFNfSWpyjStDjGHwZ/U7iobcK1cQQD8sejsONdQtTVU+1wVN1PBw40PiiHB1vA5S7VTfQiP9g==}
+
+  '@modelcontextprotocol/sdk@1.29.0':
+    resolution: {integrity: sha512-zo37mZA9hJWpULgkRpowewez1y6ML5GsXJPY8FI0tBBCd77HEvza4jDqRKOXgHNn867PVGCyTdzqpz0izu5ZjQ==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@cfworker/json-schema': ^4.1.1
+      zod: ^3.25 || ^4.0
+    peerDependenciesMeta:
+      '@cfworker/json-schema':
+        optional: true
+
+  '@msgpack/msgpack@3.1.3':
+    resolution: {integrity: sha512-47XIizs9XZXvuJgoaJUIE2lFoID8ugvc0jzSHP+Ptfk8nTbnR8g788wv48N03Kx0UkAv559HWRQ3yzOgzlRNUA==}
+    engines: {node: '>= 18'}
+
+  '@napi-rs/wasm-runtime@1.1.4':
+    resolution: {integrity: sha512-3NQNNgA1YSlJb/kMH1ildASP9HW7/7kYnRI2szWJaofaS1hWmbGI4H+d3+22aGzXXN9IJ+n+GiFVcGipJP18ow==}
+    peerDependencies:
+      '@emnapi/core': ^1.7.1
+      '@emnapi/runtime': ^1.7.1
+
+  '@nodelib/fs.scandir@2.1.5':
+    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.stat@2.0.5':
+    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
+    engines: {node: '>= 8'}
+
+  '@nodelib/fs.walk@1.2.8':
+    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
+    engines: {node: '>= 8'}
+
+  '@oxc-project/types@0.133.0':
+    resolution: {integrity: sha512-KzkdCd6Uxqnf6l3HOw1xfatAlUURA0g14cvBYFyJ5SaNOQbOUvBr9PKArcPcrNIeRsBdgcUzOGrhKveVpvOIGA==}
+
+  '@oxfmt/binding-android-arm-eabi@0.53.0':
+    resolution: {integrity: sha512-XfVM8AmIovBTKXCt14Op5wbfcoM8418nttd+nhMgM3RAVaJg1MtJc73FyWfUt0oxLyBGVwfniNVUsbV/b3VmPg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [android]
+
+  '@oxfmt/binding-android-arm64@0.53.0':
+    resolution: {integrity: sha512-btHDfXckwdf9zgyAVznfZkf+GVyB0I1m1hlvaOMRx2xoyz3hphfPX97s89J3wfCN8QBETLtk4lQUaeOkrMuQOg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [android]
+
+  '@oxfmt/binding-darwin-arm64@0.53.0':
+    resolution: {integrity: sha512-k2RjMcSTkHjoOlsVGbL35JVzXL+oQco3GHPl/5kjebVF4oHNfE24In8F5isqBh9LBJucycWHKDXdGrCchdWcHQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@oxfmt/binding-darwin-x64@0.53.0':
+    resolution: {integrity: sha512-65jIBE2H1l5SSs16fmv6/7b6sAx/WpvnsgDhVWK9qSjNFDUro7MPQ6q5UhpY7kl46yltfR046iAnxy/Bzqbiew==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@oxfmt/binding-freebsd-x64@0.53.0':
+    resolution: {integrity: sha512-oYe1gkz7U49PCYrS9147d2fJZj8mDI4Di6AvlsU5fu9p+Tq8S7qqOMSZjUiVTLX8bXuSA9Lk/tIxuegVjkNYRA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@oxfmt/binding-linux-arm-gnueabihf@0.53.0':
+    resolution: {integrity: sha512-ailB2vLzGi629tymdAb2VYJyEHref7oqGxP+tRBrtRBxQrb6NV55JMT7xtGZ8uTeG2+Y9zojqW4LhJYxQnz9Pg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@oxfmt/binding-linux-arm-musleabihf@0.53.0':
+    resolution: {integrity: sha512-abh4mWBvOvD966sobqF7r103y2yYx7Rb4WGHLOS4+5igGqLbbPxS9aK5+45D6iUY7dWMsk3Muz9a8gUtufvqJA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@oxfmt/binding-linux-arm64-gnu@0.53.0':
+    resolution: {integrity: sha512-z73PvuhJ8qA+cDbaiqbtopHglA91U4+y5wn2sTJJrnpB957d5P33FEuyP3DQIFd7ofljmDmfVT4G0CVGHZaJWg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxfmt/binding-linux-arm64-musl@0.53.0':
+    resolution: {integrity: sha512-I6bhOTroqc3ThrwZ89l2k3ivKuELhdPLbAcJhRNyjWvlgwb0vjRgEnVL1XLx5Jud04/ypNRZBykAWrSk6l/D+g==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxfmt/binding-linux-ppc64-gnu@0.53.0':
+    resolution: {integrity: sha512-w0p3JzB/PkkQjXALMJMqP9YfP3yq4w6zGsu5kezQmUnxRkN3b/Theg2l/nDgBsOcczxS3gL6Gam5XNAVrO6QJQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxfmt/binding-linux-riscv64-gnu@0.53.0':
+    resolution: {integrity: sha512-mzBhF6k1Yq1K/dqDmVe/AAafnlJfEpx7yfUiksyeWXJk5iSzZqBSxcsa02zIytYgQFRZ7h6WPZfwHg/DoOE1Kw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxfmt/binding-linux-riscv64-musl@0.53.0':
+    resolution: {integrity: sha512-AlFCpnRQhogQFzZXWbO6xB6/Udy745L+eQNmDPGg7G/OeWsYmJc4jZYfUN5pQg0reOPWSED2mOQqKZOJM1U8cA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxfmt/binding-linux-s390x-gnu@0.53.0':
+    resolution: {integrity: sha512-XD4ulY4f1DWbuuZXAqxhVn+gdPmrhnmojWtFN78ctVoupmS845fGhsUrk1HZXKQI+iymbaiz9vAjPsghHNQ7Ag==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxfmt/binding-linux-x64-gnu@0.53.0':
+    resolution: {integrity: sha512-xg8KWX0QnxmYWRe60CgHYWXI0ZOtBbqTsXvWiWrcl2XUHJ3fht2QerOk2iWvylzX3zNT2GpvBRxGoR4d3sxPRQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxfmt/binding-linux-x64-musl@0.53.0':
+    resolution: {integrity: sha512-MWExpYBGvl+pIvVB/gj/CcWlN2al8AizT7rUbtaYaWNoQkhWARM6W3qpgoCr72CYSN9PborzPmM5MIRe2BrNdA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxfmt/binding-openharmony-arm64@0.53.0':
+    resolution: {integrity: sha512-u4sajgO4nxgmJIgc/y2AqPhkdbOkQH8WugXpA1+pW0ESQhvGZ1oGq61Q4xMbJHJU1hFgtO18QNrcFYDPYH0gwQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@oxfmt/binding-win32-arm64-msvc@0.53.0':
+    resolution: {integrity: sha512-Yq9sOZoIOJ5xPjO0qOyHJS4CiPuTkB2en9auxZz7Ar2p5RaC7BzLyVVmAA7zz9/L9YnjjY1DwNxN+ivKXimN/A==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@oxfmt/binding-win32-ia32-msvc@0.53.0':
+    resolution: {integrity: sha512-es1fVNZEkBqEcQtBpn19SYFgZF7FawlkCjkT/iImfEAus4gun8fBwB1E9hpV5LcR9B0DBNvRIXhW8BQk3JaE+Q==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@oxfmt/binding-win32-x64-msvc@0.53.0':
+    resolution: {integrity: sha512-QFmJs2bEu9AO4O6qsmEaZNGi6dFq8N+rT8EHAAnZIq/B9SeJDUbc4DzVxQ48MfDsL7D3sCZzo37zuTuspcURgg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@oxlint/binding-android-arm-eabi@1.68.0':
+    resolution: {integrity: sha512-wEdsIspexXLLMCPAEOcCuFLMt6aE3AzTuA/nQKLPRnoJ+EQTturmGheDkhHuuVHx0GbutjQ3JKmEn+Gz6Ag28Q==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [android]
+
+  '@oxlint/binding-android-arm64@1.68.0':
+    resolution: {integrity: sha512-6aZRNNXQTsYtgaus8HTb9nuCcsrQTlKXGnktwvwW0n/SooRWNxNb3925grDkC63aEYZuCIyOVLV16IdYIoC2aQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [android]
+
+  '@oxlint/binding-darwin-arm64@1.68.0':
+    resolution: {integrity: sha512-lVTbsE3kO4bLpZELgjRZuAJc8kP98wb83yMXWH8gaPaFZ+cM2IDeZto4ByoUAYj0Mxv2rvw+A1ssZequSepVSg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@oxlint/binding-darwin-x64@1.68.0':
+    resolution: {integrity: sha512-nCmw2XrmQskjBUh/sfP5yKs93V68LijQgjd1cuuZ/q4SCARngLYs60/qqyzuMsg8QQ9KArDI98hxs/RDGE4KRQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@oxlint/binding-freebsd-x64@1.68.0':
+    resolution: {integrity: sha512-TI4ovQJliYE9V6e06cEv+qEI9uj7Ao65fmif4er4HD+aouyYyh0P31q2jh3KtqsOHHcQqv2PZ61TjJFLpBDGWQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@oxlint/binding-linux-arm-gnueabihf@1.68.0':
+    resolution: {integrity: sha512-LcNnEi9g71Cmry5ZpLbKT+oVv+/zYG3hYVAbBBB5X85nOQZSk8l92CnDkxJMcxUg0NCnMCOFZuaVDlMyv4tYJw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@oxlint/binding-linux-arm-musleabihf@1.68.0':
+    resolution: {integrity: sha512-OovHahL3FX4UaK+hgSf11llUx2vszqjSdQQ61Ck9InOEI/ptZoC4XSQJurITqItVvd53JSlmkLMeaNjM1PoQew==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@oxlint/binding-linux-arm64-gnu@1.68.0':
+    resolution: {integrity: sha512-YbzTglnHLzzi9zv5or8Ztz5fykAoZE8W9iM42/bOrF4HBSB6rJTqdLQWuoP76EHQw9DuKl76K1QmFlG29sPJXQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxlint/binding-linux-arm64-musl@1.68.0':
+    resolution: {integrity: sha512-qVKtCZNic+OoNnOr/hCQAu22HSQzflI7Fsq/Blzkw02SnLuv163k3kfmrVpZjSBlUHgsRKj6WgQiw30d3SX02Q==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxlint/binding-linux-ppc64-gnu@1.68.0':
+    resolution: {integrity: sha512-zExyZ8ZOUuAyQ0y9jpTcyjKUz62YY9JhKPyVxzvjTpXzZ3ujdqiVwfPWDdnA1SsIOrxdtxHn7KErDHLWskFjXg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxlint/binding-linux-riscv64-gnu@1.68.0':
+    resolution: {integrity: sha512-6C4MPuwewyDavA7sxM14wzgRi5GGL68HPIxRCdVyS75U4MDbpFVYzKO9WNR6KLKTMPq2pcz3THwo1sK2uiqngw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxlint/binding-linux-riscv64-musl@1.68.0':
+    resolution: {integrity: sha512-bnZooVeHAcvA+dH0EDLgx+7HY/DRi6e0hFszg3P+OBatuUjV6EvfIyNIzWOusmqAVh4L6r21GGTZtiKE4iqM4Q==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxlint/binding-linux-s390x-gnu@1.68.0':
+    resolution: {integrity: sha512-dIqnZnJSmHCMOUpUcWQOiV14o3DDPVx1DSsMaSzvdhNjC1tB1iEPZbdiMSCIEYbkgbsYznHXWqFdKL8WUB3F8g==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxlint/binding-linux-x64-gnu@1.68.0':
+    resolution: {integrity: sha512-zc9lEnfV/HreDTY6gdMlZe+irkwHSxQ4/B1pS9GyK7RVaA5LxhoZY/w6/o2vIwLLEYiXQ5ujGxOM1ZazeFAAIA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxlint/binding-linux-x64-musl@1.68.0':
+    resolution: {integrity: sha512-Dl5QEX0TCo/40Cdh1o1JdPS//+YiWqjC+Hrrya5OQmStZZr4svAFtdlqcpCrU9yq2Mo3vRVyO9B3h0dzD8s36Q==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxlint/binding-openharmony-arm64@1.68.0':
+    resolution: {integrity: sha512-/qy6dOvi4S3/LeXq0l5BT5pRKPYA7oj3uKwJOAZOr5HRLL+HK6jdBynvWuXIA2wwfE01RzNYmbBdM7vwYx00sA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@oxlint/binding-win32-arm64-msvc@1.68.0':
+    resolution: {integrity: sha512-fHNtVqPHSYE7UFDSLVFUjxQjnSVXxseNJmRW+XuP4pXXDwePdPda43NL7/BBCFTxHjycOc44JNDaOPtFDNui9A==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@oxlint/binding-win32-ia32-msvc@1.68.0':
+    resolution: {integrity: sha512-NnKXr4Wgo4nps3erhrE0f8shBvBPZMHg72nDsvX0JyrRvsNiP3f1JNvbCKh+A6VFvpF7ZoJxu904P3cKMhvZnA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@oxlint/binding-win32-x64-msvc@1.68.0':
+    resolution: {integrity: sha512-zg5pA+84AlU6XHJ3ruiRxziO71QTrz8nLsk6u01JGS5+tL9/bnlakFiklFrcy4R1/V7ktWtaNitN3JZWmKnf6g==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@replit/codemirror-vim@6.3.0':
+    resolution: {integrity: sha512-aTx931ULAMuJx6xLf7KQDOL7CxD+Sa05FktTDrtLaSy53uj01ll3Zf17JdKsriER248oS55GBzg0CfCTjEneAQ==}
+    peerDependencies:
+      '@codemirror/commands': 6.x.x
+      '@codemirror/language': 6.x.x
+      '@codemirror/search': 6.x.x
+      '@codemirror/state': 6.x.x
+      '@codemirror/view': 6.x.x
+
+  '@rolldown/binding-android-arm64@1.0.3':
+    resolution: {integrity: sha512-454rs7jHngixp/NMxd5srYD57OnzSlZ/eFTETjORQHLwJG1lRtmNOJcBerZlfu4GjKqeq8aCCIQrMdHyhI51Hw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [android]
+
+  '@rolldown/binding-darwin-arm64@1.0.3':
+    resolution: {integrity: sha512-PcAhP+ynjURNyy8SKGl5DQP94aGuB/7JrXJb/t7P+hanXvQVMWzUvRRhBAcg/lNRadBhoUPqSoP4xw5tR/KBEA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@rolldown/binding-darwin-x64@1.0.3':
+    resolution: {integrity: sha512-9YpfeUvSE2RS7wysJ81uOZkXJz7f7Q55H2Gvp3VEw/EsahqDtrphrZ0EwDLK5vvKOzaCrBsjF8JmnMLcUt78Gg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@rolldown/binding-freebsd-x64@1.0.3':
+    resolution: {integrity: sha512-yB1IlAsSNHncV6SCTL27/MVGR5htvQsoGxIv5KMGXALp+Ll1wYsn+x98M9MW7qa+NdSbvrrY7ANI4wLJ0n1e6g==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@rolldown/binding-linux-arm-gnueabihf@1.0.3':
+    resolution: {integrity: sha512-Yi30IVAAfLUCy2MseFjbB1jAMDl1VMCAas5StnYp8da9+CKvMd2H2cbEjWcw5NPaPqzvYkVIaF1nNUG+b7u/sw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@rolldown/binding-linux-arm64-gnu@1.0.3':
+    resolution: {integrity: sha512-jsO7R8To+AdlYgUmN5sHSCZbfhtMBkO0WUx8iORQnPcMMdgr7qM2DQmMwgabs3GhNztdmoKkMKQFHD6DTMCIQw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rolldown/binding-linux-arm64-musl@1.0.3':
+    resolution: {integrity: sha512-VWkUHwWriDciit80wleYwKILoR/KMvxh/IdwS/paX+ZgpuRpCrKLUdadJbc0NpBEiyhpYawsJ73j9aCvOH+f7Q==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@rolldown/binding-linux-ppc64-gnu@1.0.3':
+    resolution: {integrity: sha512-5f1laC0SlIR0yDbFCd8acUhvJIag6N3zC5P7oUPN6wX0aOma+uKJ0wBDH5aq7I1PVI2ttTlhJwzwRIBnLiSGEg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rolldown/binding-linux-s390x-gnu@1.0.3':
+    resolution: {integrity: sha512-Iq4ko0r4XsgbrF/LunNgHtAGLRRVE2kXonAXQ/MV0mC6jQpMOhW1SvtZja2EhC/kd05++bP78dsqBeIQyYJ6Yg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@rolldown/binding-linux-x64-gnu@1.0.3':
+    resolution: {integrity: sha512-B8m6tD5+/N5FeNQFbKlLA/2yVq9ycQP1SeedyEYYKWBNR3ZQbkvIUcNnDNM03lO1l5F2roiiFJGgvoLLyZXtSg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@rolldown/binding-linux-x64-musl@1.0.3':
+    resolution: {integrity: sha512-pSdpdUJHkuCxun9LE7jvgUB9qsRgaiyNNCX7m/AvHTcq67AiT/Yhoxvw5zPfhrM8k/BfP8ce/hMOpthKDpEUow==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@rolldown/binding-openharmony-arm64@1.0.3':
+    resolution: {integrity: sha512-OXXS3RKJgX2uLwM+gYyuH5omcH8fL1LJs96pZGgtetVCahON57+d4SJHzTgZiOjxgGkSnpXpOsWuPDGAKAigEg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@rolldown/binding-wasm32-wasi@1.0.3':
+    resolution: {integrity: sha512-JTtb8BWFynicNSoPrehsCzBtOKjZ6jhMiPFEmOiuXg1Fl8dn2KHQob+GuPSGR0dryQa1PQJbzjF3dqO/whhjLg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [wasm32]
+
+  '@rolldown/binding-win32-arm64-msvc@1.0.3':
+    resolution: {integrity: sha512-gEdFFEN70A/jxb2svrWsN3aDL7OUtmvlOy+6fa2jxG8K0wQ1ZbdeLGnidov6Yu5/733dI5ySfzFlQ/cb0bSz1g==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@rolldown/binding-win32-x64-msvc@1.0.3':
+    resolution: {integrity: sha512-eXB7CHuaQdqmJcc3koCNtNPmT/bj2gc999kUFgBxG8Ac0NdgXc4rkCHhqrgrhN3zddvvvrgzj1e90SuSfmyIXA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [win32]
+
+  '@rolldown/pluginutils@1.0.1':
+    resolution: {integrity: sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==}
+
+  '@shikijs/core@4.2.0':
+    resolution: {integrity: sha512-Hc87Ab1Ld/vEbZRCbwx344I5v+4RU8CVToUTRkqXL1+TjbuOp9U5Xa0M23V4GEWHxVn+yO5otb+HkQVm3ptWQQ==}
+    engines: {node: '>=20'}
+
+  '@shikijs/engine-javascript@4.2.0':
+    resolution: {integrity: sha512-fjETeq1k5ffyXqRgS6+3hpvqseLalp1kjNfRbXpUgWR8FpZ1CmQfiNHovc5lncYjt/Vg5JK/WJEmLahjwMa0og==}
+    engines: {node: '>=20'}
+
+  '@shikijs/engine-oniguruma@4.2.0':
+    resolution: {integrity: sha512-hTorK1dffPkpbMUk6Z+828PgRo7d07HbnizoP0hNPFjhxMHctj0Px/qoHeGMYafc6ju+u9iMldN4JbVzNQM++g==}
+    engines: {node: '>=20'}
+
+  '@shikijs/langs@4.2.0':
+    resolution: {integrity: sha512-bwrVRlJ0wUhZxAbVdvBbv2TTC9yLsh4C/IO5Ofz0T8MQntgDvyVnkbjw9vi50r1kx7RCIJdnJnjZAwmAsXFLZQ==}
+    engines: {node: '>=20'}
+
+  '@shikijs/primitive@4.2.0':
+    resolution: {integrity: sha512-NOq+DtUkVBJtZMVXL5A0vI0Xk8nvDYaXetFHSJFlOqjDZIVhIPRYFdGkSoElDqNuegikcc3A76SNUa8dTqtAYA==}
+    engines: {node: '>=20'}
+
+  '@shikijs/themes@4.2.0':
+    resolution: {integrity: sha512-RX8IHYeLv8Cu2W6ruc3RxUqWn0IYCqSrMBzi/uRGAmfyDNOnNO5BF/Px7o97n4XTpmFTo5GbRaazuOWj+2ak2w==}
+    engines: {node: '>=20'}
+
+  '@shikijs/types@4.2.0':
+    resolution: {integrity: sha512-VT/MKtlpOhEPZloSH3Pb9WCZEBDoQVMa9jedp5UAwmJOar1DVc9DRODAxmYPW9M93IK4ryuqRejFfmlvlVDemw==}
+    engines: {node: '>=20'}
+
+  '@shikijs/vscode-textmate@10.0.2':
+    resolution: {integrity: sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==}
+
+  '@standard-schema/spec@1.1.0':
+    resolution: {integrity: sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==}
+
+  '@swc/helpers@0.5.23':
+    resolution: {integrity: sha512-5lSsMOTXURePglDfvuAQUqkGek9Hg2kksOYay2m0+XR++b2NWYL/4sWyuvVBIs8oKnJaxkdi9whaL/sqN13afw==}
+
+  '@tailwindcss/node@4.3.0':
+    resolution: {integrity: sha512-aFb4gUhFOgdh9AXo4IzBEOzBkkAxm9VigwDJnMIYv3lcfXCJVesNfbEaBl4BNgVRyid92AmdviqwBUBRKSeY3g==}
+
+  '@tailwindcss/oxide-android-arm64@4.3.0':
+    resolution: {integrity: sha512-TJPiq67tKlLuObP6RkwvVGDoxCMBVtDgKkLfa/uyj7/FyxvQwHS+UOnVrXXgbEsfUaMgiVvC4KbJnRr26ho4Ng==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [android]
+
+  '@tailwindcss/oxide-darwin-arm64@4.3.0':
+    resolution: {integrity: sha512-oMN/WZRb+SO37BmUElEgeEWuU8E/HXRkiODxJxLe1UTHVXLrdVSgfaJV7pSlhRGMSOiXLuxTIjfsF3wYvz8cgQ==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@tailwindcss/oxide-darwin-x64@4.3.0':
+    resolution: {integrity: sha512-N6CUmu4a6bKVADfw77p+iw6Yd9Q3OBhe0veaDX+QazfuVYlQsHfDgxBrsjQ/IW+zywL8mTrNd0SdJT/zgtvMdA==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@tailwindcss/oxide-freebsd-x64@4.3.0':
+    resolution: {integrity: sha512-zDL5hBkQdH5C6MpqbK3gQAgP80tsMwSI26vjOzjJtNCMUo0lFgOItzHKBIupOZNQxt3ouPH7RPhvNhiTfCe5CQ==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.3.0':
+    resolution: {integrity: sha512-R06HdNi7A7OEoMsf6d4tjZ71RCWnZQPHj2mnotSFURjNLdBC+cIgXQ7l81CqeoiQftjf6OOblxXMInMgN2VzMA==}
+    engines: {node: '>= 20'}
+    cpu: [arm]
+    os: [linux]
+
+  '@tailwindcss/oxide-linux-arm64-gnu@4.3.0':
+    resolution: {integrity: sha512-qTJHELX8jetjhRQHCLilkVLmybpzNQAtaI/gaoVoidn/ufbNDbAo8KlK2J+yPoc8wQxvDxCmh/5lr8nC1+lTbg==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@tailwindcss/oxide-linux-arm64-musl@4.3.0':
+    resolution: {integrity: sha512-Z6sukiQsngnWO+l39X4pPbiWT81IC+PLKF+PHxIlyZbGNb9MODfYlXEVlFvej5BOZInWX01kVyzeLvHsXhfczQ==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@tailwindcss/oxide-linux-x64-gnu@4.3.0':
+    resolution: {integrity: sha512-DRNdQRpSGzRGfARVuVkxvM8Q12nh19l4BF/G7zGA1oe+9wcC6saFBHTISrpIcKzhiXtSrlSrluCfvMuledoCTQ==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@tailwindcss/oxide-linux-x64-musl@4.3.0':
+    resolution: {integrity: sha512-Z0IADbDo8bh6I7h2IQMx601AdXBLfFpEdUotft86evd/8ZPflZe9COPO8Q1vw+pfLWIUo9zN/JGZvwuAJqduqg==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@tailwindcss/oxide-wasm32-wasi@4.3.0':
+    resolution: {integrity: sha512-HNZGOUxEmElksYR7S6sC5jTeNGpobAsy9u7Gu0AskJ8/20FR9GqebUyB+HBcU/ax6BHuiuJi+Oda4B+YX6H1yA==}
+    engines: {node: '>=14.0.0'}
+    cpu: [wasm32]
+    bundledDependencies:
+      - '@napi-rs/wasm-runtime'
+      - '@emnapi/core'
+      - '@emnapi/runtime'
+      - '@tybys/wasm-util'
+      - '@emnapi/wasi-threads'
+      - tslib
+
+  '@tailwindcss/oxide-win32-arm64-msvc@4.3.0':
+    resolution: {integrity: sha512-Pe+RPVTi1T+qymuuRpcdvwSVZjnll/f7n8gBxMMh3xLTctMDKqpdfGimbMyioqtLhUYZxdJ9wGNhV7MKHvgZsQ==}
+    engines: {node: '>= 20'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@tailwindcss/oxide-win32-x64-msvc@4.3.0':
+    resolution: {integrity: sha512-Mvrf2kXW/yeW/OTezZlCGOirXRcUuLIBx/5Y12BaPM7wJoryG6dfS/NJL8aBPqtTEx/Vm4T4vKzFUcKDT+TKUA==}
+    engines: {node: '>= 20'}
+    cpu: [x64]
+    os: [win32]
+
+  '@tailwindcss/oxide@4.3.0':
+    resolution: {integrity: sha512-F7HZGBeN9I0/AuuJS5PwcD8xayx5ri5GhjYUDBEVYUkexyA/giwbDNjRVrxSezE3T250OU2K/wp/ltWx3UOefg==}
+    engines: {node: '>= 20'}
+
+  '@tailwindcss/vite@4.3.0':
+    resolution: {integrity: sha512-t6J3OrB5Fc0ExuhohouH0fWUGMYL6PTLhW+E7zIk/pdbnJARZDCwjBznFnkh5ynRnIRSI4YjtTH0t6USjJISrw==}
+    peerDependencies:
+      vite: ^5.2.0 || ^6 || ^7 || ^8
+
+  '@tanstack/virtual-core@3.17.3':
+    resolution: {integrity: sha512-8Np/TFELpI0ySuJoVmjvOrQYXH/8sTX0Biv9szhFhY39xOdAAY+smrMxjxOum/ux3eM8MUJQsEJ0/R0UpvC8dw==}
+
+  '@tanstack/vue-virtual@3.13.31':
+    resolution: {integrity: sha512-wZMEoSf852jQqaf3Ika1J7PiBae6341LNy/2CxmIyn0XKDQXMuK41wVX+xp6G0yx8jyR95Ef+Tdr13DK7mbJtQ==}
+    peerDependencies:
+      vue: ^2.7.0 || ^3.0.0
+
+  '@tauri-apps/api@2.11.0':
+    resolution: {integrity: sha512-7CinYODhky9lmO23xHnUFv0Xt43fbtWMyxZcLcRBlFkcgXKuEirBvHpmtJ89YMhyeGcq20Wuc47Fa4XjyniywA==}
+
+  '@tauri-apps/cli-darwin-arm64@2.11.2':
+    resolution: {integrity: sha512-+4UZzLt+eOAEQCwgd+TqKgyUJMrvx+BgdXLLaqJYmPqzP+nE6YZr/hY6CWLYGQb8jFn99jEkmC6uA3tNvamA1w==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@tauri-apps/cli-darwin-x64@2.11.2':
+    resolution: {integrity: sha512-VjYYtZUPqDMLutSfJEyxFE3Bz+DPi7c8wC3imckgvciLDZLq4qwKJxBicg0BXGhXjJsl8vKWgWRFNMPELQ+Xyg==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@tauri-apps/cli-linux-arm-gnueabihf@2.11.2':
+    resolution: {integrity: sha512-yMemD6f4i95AQriS8EazyOFzbE34yjnP16i3IOzpHGQvBoy2DjypFMFBq0NtPuITURv/cOGguRtHR5d79/9CSA==}
+    engines: {node: '>= 10'}
+    cpu: [arm]
+    os: [linux]
+
+  '@tauri-apps/cli-linux-arm64-gnu@2.11.2':
+    resolution: {integrity: sha512-cgI91D2wL8GSgoWwZXDqt+DwnuZCP2/bz03QAE4TrhgAKIsrB4hX26W/H1EONPUUNkqrsgeCD0wU6pcNjV/5kw==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@tauri-apps/cli-linux-arm64-musl@2.11.2':
+    resolution: {integrity: sha512-X1rm0BERqAAggtYTESSgXrS3sz4Sb/OiPiz54UqISlXW+GkR3vNIGnsy/lejNmoXGVqri3Q53BCfQiclOIyRPw==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@tauri-apps/cli-linux-riscv64-gnu@2.11.2':
+    resolution: {integrity: sha512-usbMLJbT3KtkOrBMDVeGYNM35aTHXx38SJSzTMSqqjeUIOQ+iVPjb2yAGNAE+KqmBbAx4FOFIyMeKXx2M/JKGQ==}
+    engines: {node: '>= 10'}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@tauri-apps/cli-linux-x64-gnu@2.11.2':
+    resolution: {integrity: sha512-Ru4gwJKPG0ctVGchRGpRup4Y4lW2SSfFnrbQcyHhCliKy4g8Qz97TrUgCur4CbWyAgKxvGh3SjrkA0LDYzDGiw==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@tauri-apps/cli-linux-x64-musl@2.11.2':
+    resolution: {integrity: sha512-eUm7T6clN1MMmNSRQ9gaWsQdyehQx2Gmn5hht/QUlqZQI/qcP2OJK5dnaxqwFzCr2HdsEo9ydxaqcS1oJzMvUw==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@tauri-apps/cli-win32-arm64-msvc@2.11.2':
+    resolution: {integrity: sha512-HeeZW80jU+gVTOEX4X/hC6NVSAdDVXajwP5fxIZ/3z9WvUC7qrudX2GMTilYq6Dg0e0sk0XgsAJD1hZ5wPBXUA==}
+    engines: {node: '>= 10'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@tauri-apps/cli-win32-ia32-msvc@2.11.2':
+    resolution: {integrity: sha512-YhjQNZcXfbkCLyazSv1nPnJ9iRFE1wm6kc51FDbU10/Dk09io+6PAGMLjkxnX2GdM0qMnDmTjstY8mTDVvtKeA==}
+    engines: {node: '>= 10'}
+    cpu: [ia32]
+    os: [win32]
+
+  '@tauri-apps/cli-win32-x64-msvc@2.11.2':
+    resolution: {integrity: sha512-d2JchlFIpZevZVReyqhQOekJmb1UH3rhZ5VX6sH3ty9ETE0TKQavpihvoScUXfKKpW6HZC0MrFGRU0ZtD+w3gA==}
+    engines: {node: '>= 10'}
+    cpu: [x64]
+    os: [win32]
+
+  '@tauri-apps/cli@2.11.2':
+    resolution: {integrity: sha512-bk3HemqvGRoy+5D/dVMUQHKMYLglD0jVnMm/0iGMH6ufZ+p8r14m6BpIixwij3PBvZdvORUp1YifTD8QxVZ1Nw==}
+    engines: {node: '>= 10'}
+    hasBin: true
+
+  '@tauri-apps/plugin-clipboard-manager@2.3.2':
+    resolution: {integrity: sha512-CUlb5Hqi2oZbcZf4VUyUH53XWPPdtpw43EUpCza5HWZJwxEoDowFzNUDt1tRUXA8Uq+XPn17Ysfptip33sG4eQ==}
+
+  '@tauri-apps/plugin-dialog@2.7.1':
+    resolution: {integrity: sha512-OK1UBXYt+ojcmxMktzzuyonYIFta8CmAASpX+CA+DTGK24KlHjhYI6x2iOJ/TjZF4N7/ACK1oFmEOjIY9IhzOQ==}
+
+  '@tauri-apps/plugin-fs@2.5.1':
+    resolution: {integrity: sha512-9Lz+Jopp6QyeEWhlpkMx4R/+P9HgR+AVAI4vOZhlT8Xaymtz8iVI/Ov984/XTqgJz/5gz5NretqPB/XEMS3NhQ==}
+
+  '@tauri-apps/plugin-process@2.3.1':
+    resolution: {integrity: sha512-nCa4fGVaDL/B9ai03VyPOjfAHRHSBz5v6F/ObsB73r/dA3MHHhZtldaDMIc0V/pnUw9ehzr2iEG+XkSEyC0JJA==}
+
+  '@tauri-apps/plugin-shell@2.3.5':
+    resolution: {integrity: sha512-jewtULhiQ7lI7+owCKAjc8tYLJr92U16bPOeAa472LHJdgaibLP83NcfAF2e+wkEcA53FxKQAZ7byDzs2eeizg==}
+
+  '@tauri-apps/plugin-updater@2.10.1':
+    resolution: {integrity: sha512-NFYMg+tWOZPJdzE/PpFj2qfqwAWwNS3kXrb1tm1gnBJ9mYzZ4WDRrwy8udzWoAnfGCHLuePNLY1WVCNHnh3eRA==}
+
+  '@ts-morph/common@0.28.1':
+    resolution: {integrity: sha512-W74iWf7ILp1ZKNYXY5qbddNaml7e9Sedv5lvU1V8lftlitkc9Pq1A+jlH23ltDgWYeZFFEqGCD1Ies9hqu3O+g==}
+
+  '@tybys/wasm-util@0.10.2':
+    resolution: {integrity: sha512-RoBvJ2X0wuKlWFIjrwffGw1IqZHKQqzIchKaadZZfnNpsAYp2mM0h36JtPCjNDAHGgYez/15uMBpfGwchhiMgg==}
+
+  '@types/better-sqlite3@7.6.13':
+    resolution: {integrity: sha512-NMv9ASNARoKksWtsq/SHakpYAYnhBrQgGD8zkLYk/jaK8jUGn08CfEdTRgYhMypUQAfzSP8W6gNLe0q19/t4VA==}
+
+  '@types/chai@5.2.3':
+    resolution: {integrity: sha512-Mw558oeA9fFbv65/y4mHtXDs9bPnFMZAL/jxdPFUpOHHIXX91mcgEHbS5Lahr+pwZFR8A7GQleRWeI6cGFC2UA==}
+
+  '@types/deep-eql@4.0.2':
+    resolution: {integrity: sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==}
+
+  '@types/esrecurse@4.3.1':
+    resolution: {integrity: sha512-xJBAbDifo5hpffDBuHl0Y8ywswbiAp/Wi7Y/GtAgSlZyIABppyurxVueOPE8LUQOxdlgi6Zqce7uoEpqNTeiUw==}
+
+  '@types/estree@1.0.9':
+    resolution: {integrity: sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==}
+
+  '@types/geojson@7946.0.16':
+    resolution: {integrity: sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==}
+
+  '@types/hast@3.0.4':
+    resolution: {integrity: sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==}
+
+  '@types/json-schema@7.0.15':
+    resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
+
+  '@types/leaflet@1.9.21':
+    resolution: {integrity: sha512-TbAd9DaPGSnzp6QvtYngntMZgcRk+igFELwR2N99XZn7RXUdKgsXMR+28bUO0rPsWp8MIu/f47luLIQuSLYv/w==}
+
+  '@types/mdast@4.0.4':
+    resolution: {integrity: sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==}
+
+  '@types/node@22.19.19':
+    resolution: {integrity: sha512-dyh/xO2Fh5bYrfWaaqGrRQQGkNdmYw6AmaAUvYeUMNTWQtvb796ikLdmTchRmOlOiIJ1TDXfWgVx1QkUlQ6Hew==}
+
+  '@types/node@25.9.1':
+    resolution: {integrity: sha512-xfrlY7UD5rMJk3ZVJP8BNzS28J36YJg+xp+LPXV1TdWxr8uMH5A860QNxYDGQe/ylDSgjxE52Q9VnO7p75tJxg==}
+
+  '@types/pg@8.20.0':
+    resolution: {integrity: sha512-bEPFOaMAHTEP1EzpvHTbmwR8UsFyHSKsRisLIHVMXnpNefSbGA1bD6CVy+qKjGSqmZqNqBDV2azOBo8TgkcVow==}
+
+  '@types/splitpanes@2.2.6':
+    resolution: {integrity: sha512-3dV5sO1Ht74iER4jJU03mreL3f+Q2h47ZqXS6Sfbqc6hkCvsDrX1GA0NbYWRdNvZemPyTDzUoApWKeoGbALwkQ==}
+
+  '@types/unist@3.0.3':
+    resolution: {integrity: sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==}
+
+  '@types/web-bluetooth@0.0.21':
+    resolution: {integrity: sha512-oIQLCGWtcFZy2JW77j9k8nHzAOpqMHLQejDA48XXMWH6tjCQHz5RCFz1bzsmROyL6PUm+LLnUiI4BCn221inxA==}
+
+  '@uiw/codemirror-theme-duotone@4.25.10':
+    resolution: {integrity: sha512-OQzg73rlUnDQ1NDT2KR4Nt+67oMg5yRWXz60WoSATiLGhNoz8Af8hAKnY1TC+v4P8OmLoFnufFL7DQARX1wqQQ==}
+
+  '@uiw/codemirror-theme-material@4.25.10':
+    resolution: {integrity: sha512-UP9Hokx8Kkm4EOXkqiHIXlC2wkqkPnMuz7/2E6Pqi3h5nCvtkUhSpvJ9fldWOPQRnuhX/suu6bi6a0H3LoFI1Q==}
+
+  '@uiw/codemirror-theme-nord@4.25.10':
+    resolution: {integrity: sha512-gTPczh7qHSJxMdUBvLMdN2BXkJ2AbJyRhcjY8m+tjp+Hpg3ClQvu4S2mH/57slCUOq0DS0BbSi9jXnu2hFbSdw==}
+
+  '@uiw/codemirror-theme-okaidia@4.25.10':
+    resolution: {integrity: sha512-+gawy5f5ullggww/wUqyvI/DXJ3nTVPZsitm9QUSLDHUTTbbMK4QWJUUYjt6wd0EZ/aZ2v75OKoY+qs/9SGHkg==}
+
+  '@uiw/codemirror-theme-vscode@4.25.10':
+    resolution: {integrity: sha512-5wyYu4/WBsdDVeHStWHnvgkaSQ4X97tdwXETsJQAt/ZSjHY4Gs+mzwMj9azJQnr9uA19yjFtU2PkAcXFQIFOsA==}
+
+  '@uiw/codemirror-theme-xcode@4.25.10':
+    resolution: {integrity: sha512-wsvBm7t7DlCy0rDqgygxKg7CjtYmxJ+fAZ9IbJKY/RGce4/9F8vHeGBy1MRqNl//7PG1Y1txCIX77IaAQptjpg==}
+
+  '@uiw/codemirror-themes@4.25.10':
+    resolution: {integrity: sha512-Fqiz1HIuDlDftcL+/O53V333UOH6MqQ84VbiQB5egn6u+uDwAqACp1FrdAoi4wgpR3b3TGW4Gr0wIYcrJSSz1A==}
+    peerDependencies:
+      '@codemirror/language': '>=6.0.0'
+      '@codemirror/state': '>=6.0.0'
+      '@codemirror/view': '>=6.0.0'
+
+  '@ungap/structured-clone@1.3.1':
+    resolution: {integrity: sha512-mUFwbeTqrVgDQxFveS+df2yfap6iuP20NAKAsBt5jDEoOTDew+zwLAOilHCeQJOVSvmgCX4ogqIrA0mnyr08yQ==}
+
+  '@unovue/detypes@0.8.5':
+    resolution: {integrity: sha512-Yz4JeWOHGa+w/3YudVdng8hgN/VGW9cvp8xmFkmPPFzalGblLPPSpIRiwVo853yLstMZO2LLwe0vOoLAQsUQXw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  '@vitejs/plugin-vue@6.0.7':
+    resolution: {integrity: sha512-km+p+XdSz9Sxm5rqUbqcSfZYaAniKxWBj1KURl+Jr7UaPvvX7BmaWMdP69I5rrFDeQGyxAG7NXdc57vz+snhWg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    peerDependencies:
+      vite: ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0
+      vue: ^3.2.25
+
+  '@vitest/expect@4.1.8':
+    resolution: {integrity: sha512-h3nDO677RDLEGlBxyQ5CW8RlMThSKSRLUePLOx09gNIWRL40edgA1GCZSZgf1W55MFAG6/Sw14KeaAnqv0NKdQ==}
+
+  '@vitest/mocker@4.1.8':
+    resolution: {integrity: sha512-LEiN/xe4OSIbKe9HQIp5OC24agGD9J5CnmMgsLohVVoOPWL9a2sBoR6VBx43jQZb7Kr1l4RCuyCJzcAa0+dojw==}
+    peerDependencies:
+      msw: ^2.4.9
+      vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+    peerDependenciesMeta:
+      msw:
+        optional: true
+      vite:
+        optional: true
+
+  '@vitest/pretty-format@4.1.8':
+    resolution: {integrity: sha512-9GasEBxpZ1VYIpqHf/0+YGg121uSNwCKOJqIrTwWP/TB7DmFCiaBpNl3aPZzoLWfWkuqhbH8vJIVobZkvdo2cA==}
+
+  '@vitest/runner@4.1.8':
+    resolution: {integrity: sha512-EmVxeBAfMJvycdjd6Hm+RbFBbA9fKvo0Kx37hNpBYoYeavH3RNsBXWDooR1mgD52dCrxIIuP7UotpfiwOikvcg==}
+
+  '@vitest/snapshot@4.1.8':
+    resolution: {integrity: sha512-acfZboRmAIf05DEKcBQy33VXojFJjtUdLyo7oOmV9kebb2xdU01UknNiPuPZoJZQyO7DF0gZdTGTpeAzET9QPQ==}
+
+  '@vitest/spy@4.1.8':
+    resolution: {integrity: sha512-6EevtBp6OZOPF7bmz36HrGMeP3txgVSrgebWxHOafDXGkhIzfXK14f8KF6MuFfgXXUeHxmpD3BQxkV00/3s5mA==}
+
+  '@vitest/utils@4.1.8':
+    resolution: {integrity: sha512-uOJamYALNhfJ6iolExyQM40yIQwDqYnkKtQ5VCiSe17E33H0aQ/u+1GlRuz4LZBk6Mm3sg90G9hEbmEt37C1Zg==}
+
+  '@volar/language-core@2.4.28':
+    resolution: {integrity: sha512-w4qhIJ8ZSitgLAkVay6AbcnC7gP3glYM3fYwKV3srj8m494E3xtrCv6E+bWviiK/8hs6e6t1ij1s2Endql7vzQ==}
+
+  '@volar/source-map@2.4.28':
+    resolution: {integrity: sha512-yX2BDBqJkRXfKw8my8VarTyjv48QwxdJtvRgUpNE5erCsgEUdI2DsLbpa+rOQVAJYshY99szEcRDmyHbF10ggQ==}
+
+  '@volar/typescript@2.4.28':
+    resolution: {integrity: sha512-Ja6yvWrbis2QtN4ClAKreeUZPVYMARDYZl9LMEv1iQ1QdepB6wn0jTRxA9MftYmYa4DQ4k/DaSZpFPUfxl8giw==}
+
+  '@vue/compiler-core@3.5.35':
+    resolution: {integrity: sha512-BUmHaR1J+O+CKZ9uJucdVTEr1LHsdyvv7vG3eNRhK3CczEHeMd/LtsHAuD7PbrxvI2envCY2v7HI1vC1aBRzKw==}
+
+  '@vue/compiler-core@3.5.39':
+    resolution: {integrity: sha512-16KBTEXAJCpDr0mwlw+AZyhu8iyC7R3S2vBwsI7QnWJU6X3WKc9VKeNEZpiMdZ569qWhz9574L3vV55qRL0Vtw==}
+
+  '@vue/compiler-dom@3.5.35':
+    resolution: {integrity: sha512-k+bprkXxuqhVajgTx5mUHuir7TwQzUKOWR40ng1ncAqQRPnrLngGGgqVEEhOnTMlc8btHYVKmrP8s5Qyg0hvYA==}
+
+  '@vue/compiler-dom@3.5.39':
+    resolution: {integrity: sha512-oQPigALqYbNxTNPvNgSOe+czwVExfbVF02lz8jP0S3AXJiu3jxYDygNUiqSep4ezzW8XgnubqH63My2A7JR/vg==}
+
+  '@vue/compiler-sfc@2.7.16':
+    resolution: {integrity: sha512-KWhJ9k5nXuNtygPU7+t1rX6baZeqOYLEforUPjgNDBnLicfHCoi48H87Q8XyLZOrNNsmhuwKqtpDQWjEFe6Ekg==}
+
+  '@vue/compiler-sfc@3.5.35':
+    resolution: {integrity: sha512-G5VPMcXTSywXBgtFOZOnHKBxKSrwXUcvY1iaF5/hRcy7t0J6CH/d8ha9F4nzi00Fax1eLV0QHM7v4mQu68jydw==}
+
+  '@vue/compiler-sfc@3.5.39':
+    resolution: {integrity: sha512-d0ki86iOyN8LoZPBmk5SJWNwHP19CnDDCfuo//+2WJa2g5Ke0Jay983PIBIcSSzldC68I8DrD5GrHV3OSDfodg==}
+
+  '@vue/compiler-ssr@3.5.35':
+    resolution: {integrity: sha512-rGhAeXgdM7/ffTJGXT69rCCdTmjDewnFuUZfBQQHTdcEBeWdT5HCGY60y2ytLJr9/Dsu7IntUi5z/w0h6Rjnzw==}
+
+  '@vue/compiler-ssr@3.5.39':
+    resolution: {integrity: sha512-Ce7/wvwMHai74bdszfXExdazFigYnlF9zgCmEQUcM1j0fOymlouZ7XilTYNo8oUjhlnjYOZbGrcYKuqjz89Ucw==}
+
+  '@vue/devtools-api@6.6.4':
+    resolution: {integrity: sha512-sGhTPMuXqZ1rVOk32RylztWkfXTRhuS7vgAKv0zjqk8gbsHkJ7xfFf+jbySxt7tWObEJwyKaHMikV/WGDiQm8g==}
+
+  '@vue/devtools-api@7.7.9':
+    resolution: {integrity: sha512-kIE8wvwlcZ6TJTbNeU2HQNtaxLx3a84aotTITUuL/4bzfPxzajGBOoqjMhwZJ8L9qFYDU/lAYMEEm11dnZOD6g==}
+
+  '@vue/devtools-kit@7.7.9':
+    resolution: {integrity: sha512-PyQ6odHSgiDVd4hnTP+aDk2X4gl2HmLDfiyEnn3/oV+ckFDuswRs4IbBT7vacMuGdwY/XemxBoh302ctbsptuA==}
+
+  '@vue/devtools-shared@7.7.9':
+    resolution: {integrity: sha512-iWAb0v2WYf0QWmxCGy0seZNDPdO3Sp5+u78ORnyeonS6MT4PC7VPrryX2BpMJrwlDeaZ6BD4vP4XKjK0SZqaeA==}
+
+  '@vue/language-core@3.3.3':
+    resolution: {integrity: sha512-X6p+7nfY7vVT6dQwUJ+v0Jfq/lwIfhL2jMi91dQ3ln4hnlGXlxsDu/FNkeyHYgvYtyQy18ZX76IZy7X4diDbiQ==}
+
+  '@vue/reactivity@3.5.35':
+    resolution: {integrity: sha512-tVc+SsHConvh/Lz64qq1pP3rYArBmK42xonovEcxY74SQtvctZodG/zhq54P5dr38cVuw25d27cPNRdlMidpGQ==}
+
+  '@vue/runtime-core@3.5.35':
+    resolution: {integrity: sha512-A/xFNX9loIcWDygeQuNCfKuh0CoYBzxhqEMNah5TSFg9Z53DrFYEN2qi5CU9necjM1OWYegYREUTHmXTmhfXtg==}
+
+  '@vue/runtime-dom@3.5.35':
+    resolution: {integrity: sha512-odrJ1C391dbGnyDRh8U+rnP7J2amIEzfmRk5vXy7xi3aZhEXofTvpi0T4HJb6jlNqQZTNPR5MPHSB3RHNkIORA==}
+
+  '@vue/server-renderer@3.5.35':
+    resolution: {integrity: sha512-NkebSOYdB97wi8OQcO3HqzZSlymJi/aWsN/7h74OSVhRTm6qGs3Jp3e0rCXynmWwSlKeRrnlIug+ilYoHBmQDA==}
+    peerDependencies:
+      vue: 3.5.35
+
+  '@vue/shared@3.5.35':
+    resolution: {integrity: sha512-zSbjL7gRXwks2ZQLRGCajBtBXEOXW9Ddhn/HvSdrGkE2dqGnumzW8XtusRrxrE9LvqtiqDXQ+A60Hp6mvdYxfA==}
+
+  '@vue/shared@3.5.39':
+    resolution: {integrity: sha512-l1rrBtBfTnmxvtsvdQDXltUUy8S1Y+ZaqdfUzmAnJkTd8Z8rv5v/ytW+TKiqEOWyHPoqtPlNFSs0lhRmYVSHVA==}
+
+  '@vuedx/template-ast-types@0.7.1':
+    resolution: {integrity: sha512-Mqugk/F0lFN2u9bhimH6G1kSu2hhLi2WoqgCVxrMvgxm2kDc30DtdvVGRq+UgEmKVP61OudcMtZqkUoGQeFBUQ==}
+
+  '@vueuse/core@14.2.1':
+    resolution: {integrity: sha512-3vwDzV+GDUNpdegRY6kzpLm4Igptq+GA0QkJ3W61Iv27YWwW/ufSlOfgQIpN6FZRMG0mkaz4gglJRtq5SeJyIQ==}
+    peerDependencies:
+      vue: ^3.5.0
+
+  '@vueuse/metadata@14.2.1':
+    resolution: {integrity: sha512-1ButlVtj5Sb/HDtIy1HFr1VqCP4G6Ypqt5MAo0lCgjokrk2mvQKsK2uuy0vqu/Ks+sHfuHo0B9Y9jn9xKdjZsw==}
+
+  '@vueuse/shared@14.2.1':
+    resolution: {integrity: sha512-shTJncjV9JTI4oVNyF1FQonetYAiTBd+Qj7cY89SWbXSkx7gyhrgtEdF2ZAVWS1S3SHlaROO6F2IesJxQEkZBw==}
+    peerDependencies:
+      vue: ^3.5.0
+
+  '@vueuse/shared@14.3.0':
+    resolution: {integrity: sha512-bZpge9eSXwa4ToSiqJ7j6KRwhAsneMFoSz3LMWKQDkqimm3D/tbFlrklrs/IOqC8tEcYmXQZJ6N0UrjhBirVCg==}
+    peerDependencies:
+      vue: ^3.5.0
+
+  accepts@2.0.0:
+    resolution: {integrity: sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==}
+    engines: {node: '>= 0.6'}
+
+  acorn-jsx@5.3.2:
+    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
+    peerDependencies:
+      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
+
+  acorn@8.17.0:
+    resolution: {integrity: sha512-xRQbDb9BnwDafYNn6Vwl839DYVjqXYb1XVGtWAZ1kcDc6iwAL4hg3B1dZlRiuENFeO2H53gFG3in621AdERVAg==}
+    engines: {node: '>=0.4.0'}
+    hasBin: true
+
+  ajv-formats@2.1.1:
+    resolution: {integrity: sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==}
+    peerDependencies:
+      ajv: ^8.0.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
+  ajv-formats@3.0.1:
+    resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==}
+    peerDependencies:
+      ajv: ^8.0.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
+  ajv@6.15.0:
+    resolution: {integrity: sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw==}
+
+  ajv@8.20.0:
+    resolution: {integrity: sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==}
+
+  alien-signals@3.2.1:
+    resolution: {integrity: sha512-I8FjmltrfnDFoZedi5CG8DghVYNhzb/Ijluz7tCSJH0xpd0484Kowhbb1XDYOxfJpU1p5wnM2X54dA+IfGyD1g==}
+
+  ansi-colors@4.1.3:
+    resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
+    engines: {node: '>=6'}
+
+  ansi-escapes@7.3.0:
+    resolution: {integrity: sha512-BvU8nYgGQBxcmMuEeUEmNTvrMVjJNSH7RgW24vXexN4Ven6qCvy4TntnvlnwnMLTVlcRQQdbRY8NKnaIoeWDNg==}
+    engines: {node: '>=18'}
+
+  ansi-regex@5.0.1:
+    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
+    engines: {node: '>=8'}
+
+  ansi-regex@6.2.2:
+    resolution: {integrity: sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==}
+    engines: {node: '>=12'}
+
+  ansi-styles@4.3.0:
+    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
+    engines: {node: '>=8'}
+
+  ansi-styles@6.2.3:
+    resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==}
+    engines: {node: '>=12'}
+
+  argparse@2.0.1:
+    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
+
+  aria-hidden@1.2.6:
+    resolution: {integrity: sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==}
+    engines: {node: '>=10'}
+
+  assertion-error@2.0.1:
+    resolution: {integrity: sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==}
+    engines: {node: '>=12'}
+
+  ast-types-x@1.18.0:
+    resolution: {integrity: sha512-ZtfIlyTCmnAXPCQo4mSDtFsHL7L3q0sJfpVYPmy5uYPjs+fynzOuc1Cg6yQ9fF6h61RjEWtOlRFwV1Kc80Qs6A==}
+    engines: {node: '>=4'}
+
+  astral-regex@2.0.0:
+    resolution: {integrity: sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==}
+    engines: {node: '>=8'}
+
+  atob@2.1.2:
+    resolution: {integrity: sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==}
+    engines: {node: '>= 4.5.0'}
+    hasBin: true
+
+  atomically@1.7.0:
+    resolution: {integrity: sha512-Xcz9l0z7y9yQ9rdDaxlmaI4uJHf/T8g9hOEzJcsEqX2SjCj4J20uK7+ldkDHMbpJDK76wF7xEIgxc/vSlsfw5w==}
+    engines: {node: '>=10.12.0'}
+
+  aws-ssl-profiles@1.1.2:
+    resolution: {integrity: sha512-NZKeq9AfyQvEeNlN0zSYAaWrmBffJh3IELMZfRpJVWgrpEbtEpnjvzqBPf+mxoI287JohRDoa+/nsfqqiZmF6g==}
+    engines: {node: '>= 6.0.0'}
+
+  balanced-match@1.0.2:
+    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
+
+  balanced-match@4.0.4:
+    resolution: {integrity: sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==}
+    engines: {node: 18 || 20 || >=22}
+
+  base64-js@1.5.1:
+    resolution: {integrity: sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==}
+
+  baseline-browser-mapping@2.10.40:
+    resolution: {integrity: sha512-BSSLZ9/Cjjv7Gtj5B68ZzXcXUg8iOf3fme+FCuh8rC/Go+Kmh8cox7M3A8dolou16s64QjLPOSdngh7GxXvkSw==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+
+  better-sqlite3@12.10.0:
+    resolution: {integrity: sha512-CyzaZRQKyHkB2ZInfTTl2nvT33EbDpjkLEbE8/Zck3Ll6O0qqvuGdrJ45HgtH+HykRg88ITY3AdreBGN70aBSQ==}
+    engines: {node: 20.x || 22.x || 23.x || 24.x || 25.x || 26.x}
+
+  bindings@1.5.0:
+    resolution: {integrity: sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==}
+
+  birpc@2.9.0:
+    resolution: {integrity: sha512-KrayHS5pBi69Xi9JmvoqrIgYGDkD6mcSe/i6YKi3w5kekCLzrX4+nawcXqrj2tIp50Kw/mT/s3p+GVK0A0sKxw==}
+
+  bl@4.1.0:
+    resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==}
+
+  body-parser@2.2.2:
+    resolution: {integrity: sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==}
+    engines: {node: '>=18'}
+
+  boolbase@1.0.0:
+    resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==}
+
+  brace-expansion@1.1.15:
+    resolution: {integrity: sha512-EwOCDEex4quD37XhqM3omwtMoJjr//isUZz1JopUNWms+4Z2ViyM/k1YIRePpoVNnQhENnxtFjLaxNHrT7xIUg==}
+
+  brace-expansion@5.0.7:
+    resolution: {integrity: sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA==}
+    engines: {node: 18 || 20 || >=22}
+
+  braces@3.0.3:
+    resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
+    engines: {node: '>=8'}
+
+  browserslist@4.28.4:
+    resolution: {integrity: sha512-MTc8i/x9jBQd1iMw2CFGS+rwMa07eYjLR0CCTLDACl9xhxy+nIs3KeML/biicXtk9JrZ6dnnTatmc7ErPXIxqw==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
+
+  buffer@5.7.1:
+    resolution: {integrity: sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==}
+
+  bundle-name@4.1.0:
+    resolution: {integrity: sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q==}
+    engines: {node: '>=18'}
+
+  bytes@3.1.2:
+    resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==}
+    engines: {node: '>= 0.8'}
+
+  c12@3.3.4:
+    resolution: {integrity: sha512-cM0ApFQSBXuourJejzwv/AuPRvAxordTyParRVcHjjtXirtkzM0uK2L9TTn9s0cXZbG7E55jCivRQzoxYmRAlA==}
+    peerDependencies:
+      magicast: '*'
+    peerDependenciesMeta:
+      magicast:
+        optional: true
+
+  call-bind-apply-helpers@1.0.2:
+    resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
+    engines: {node: '>= 0.4'}
+
+  call-bound@1.0.4:
+    resolution: {integrity: sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==}
+    engines: {node: '>= 0.4'}
+
+  caniuse-lite@1.0.30001800:
+    resolution: {integrity: sha512-MMHtuAz9Ys840zAY5F4k6fV5GaivZ9sPk+nz0mY+GYVzRBnYkN0mpqkSR92oWRQ19yQWo4HvBV/FnC16AJX8MA==}
+
+  ccount@2.0.1:
+    resolution: {integrity: sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==}
+
+  chai@6.2.2:
+    resolution: {integrity: sha512-NUPRluOfOiTKBKvWPtSD4PhFvWCqOi0BGStNWs57X9js7XGTprSmFoz5F0tWhR4WPjNeR9jXqdC7/UpSJTnlRg==}
+    engines: {node: '>=18'}
+
+  chalk@5.6.2:
+    resolution: {integrity: sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==}
+    engines: {node: ^12.17.0 || ^14.13 || >=16.0.0}
+
+  character-entities-html4@2.1.0:
+    resolution: {integrity: sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==}
+
+  character-entities-legacy@3.0.0:
+    resolution: {integrity: sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==}
+
+  chokidar@5.0.0:
+    resolution: {integrity: sha512-TQMmc3w+5AxjpL8iIiwebF73dRDF4fBIieAqGn9RGCWaEVwQ6Fb2cGe31Yns0RRIzii5goJ1Y7xbMwo1TxMplw==}
+    engines: {node: '>= 20.19.0'}
+
+  chownr@1.1.4:
+    resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==}
+
+  citty@0.2.2:
+    resolution: {integrity: sha512-+6vJA3L98yv+IdfKGZHBNiGW5KHn22e/JwID0Strsz8h4S/csAu/OuICwxrg44k5MRiZHWIo8XXuJgQTriRP4w==}
+
+  class-variance-authority@0.7.1:
+    resolution: {integrity: sha512-Ka+9Trutv7G8M6WT6SeiRWz792K5qEqIGEGzXKhAE6xOWAY6pPH8U+9IY3oCMv6kqTmLsv7Xh/2w2RigkePMsg==}
+
+  cli-cursor@5.0.0:
+    resolution: {integrity: sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==}
+    engines: {node: '>=18'}
+
+  cli-progress@3.12.0:
+    resolution: {integrity: sha512-tRkV3HJ1ASwm19THiiLIXLO7Im7wlTuKnvkYaTkyoAPefqjNg7W7DHKUlGRxy9vxDvbyCYQkQozvptuMkGCg8A==}
+    engines: {node: '>=4'}
+
+  cli-spinners@3.4.0:
+    resolution: {integrity: sha512-bXfOC4QcT1tKXGorxL3wbJm6XJPDqEnij2gQ2m7ESQuE+/z9YFIWnl/5RpTiKWbMq3EVKR4fRLJGn6DVfu0mpw==}
+    engines: {node: '>=18.20'}
+
+  cli-truncate@5.2.0:
+    resolution: {integrity: sha512-xRwvIOMGrfOAnM1JYtqQImuaNtDEv9v6oIYAs4LIHwTiKee8uwvIi363igssOC0O5U04i4AlENs79LQLu9tEMw==}
+    engines: {node: '>=20'}
+
+  clsx@2.1.1:
+    resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
+    engines: {node: '>=6'}
+
+  cluster-key-slot@1.1.1:
+    resolution: {integrity: sha512-rwHwUfXL40Chm1r08yrhU3qpUvdVlgkKNeyeGPOxnW8/SyVDvgRaed/Uz54AqWNaTCAThlj6QAs3TZcKI0xDEw==}
+    engines: {node: '>=0.10.0'}
+
+  code-block-writer@13.0.3:
+    resolution: {integrity: sha512-Oofo0pq3IKnsFtuHqSF7TqBfr71aeyZDVJ0HpmqB7FBM2qEigL0iPONSCZSO9pE9dZTAxANe5XHG9Uy0YMv8cg==}
+
+  codemirror@6.0.2:
+    resolution: {integrity: sha512-VhydHotNW5w1UGK0Qj96BwSk/Zqbp9WbnyK2W/eVMv4QyF41INRGpjUhFJY7/uDNuudSc33a/PKr4iDqRduvHw==}
+
+  color-convert@2.0.1:
+    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
+    engines: {node: '>=7.0.0'}
+
+  color-name@1.1.4:
+    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
+
+  colorette@2.0.20:
+    resolution: {integrity: sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==}
+
+  comma-separated-tokens@2.0.3:
+    resolution: {integrity: sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==}
+
+  commander@11.1.0:
+    resolution: {integrity: sha512-yPVavfyCcRhmorC7rWlkHn15b4wDVgVmBA7kV4QVBsF7kv/9TKJAbAXVTxvTnwP8HHKjRCJDClKbciiYS7p0DQ==}
+    engines: {node: '>=16'}
+
+  commander@14.0.3:
+    resolution: {integrity: sha512-H+y0Jo/T1RZ9qPP4Eh1pkcQcLRglraJaSLoyOtHxu6AapkjWVCy2Sit1QQ4x3Dng8qDlSsZEet7g5Pq06MvTgw==}
+    engines: {node: '>=20'}
+
+  commander@2.20.3:
+    resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
+
+  concat-map@0.0.1:
+    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
+
+  conf@10.2.0:
+    resolution: {integrity: sha512-8fLl9F04EJqjSqH+QjITQfJF8BrOVaYr1jewVgSRAEWePfxT0sku4w2hrGQ60BC/TNLGQ2pgxNlTbWQmMPFvXg==}
+    engines: {node: '>=12'}
+
+  confbox@0.2.4:
+    resolution: {integrity: sha512-ysOGlgTFbN2/Y6Cg3Iye8YKulHw+R2fNXHrgSmXISQdMnomY6eNDprVdW9R5xBguEqI954+S6709UyiO7B+6OQ==}
+
+  consola@3.4.2:
+    resolution: {integrity: sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==}
+    engines: {node: ^14.18.0 || >=16.10.0}
+
+  content-disposition@1.1.0:
+    resolution: {integrity: sha512-5jRCH9Z/+DRP7rkvY83B+yGIGX96OYdJmzngqnw2SBSxqCFPd0w2km3s5iawpGX8krnwSGmF0FW5Nhr0Hfai3g==}
+    engines: {node: '>=18'}
+
+  content-type@1.0.5:
+    resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
+    engines: {node: '>= 0.6'}
+
+  convert-hrtime@5.0.0:
+    resolution: {integrity: sha512-lOETlkIeYSJWcbbcvjRKGxVMXJR+8+OQb/mTPbA4ObPMytYIsUbuOE0Jzy60hjARYszq1id0j8KgVhC+WGZVTg==}
+    engines: {node: '>=12'}
+
+  convert-source-map@2.0.0:
+    resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
+
+  cookie-signature@1.2.2:
+    resolution: {integrity: sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==}
+    engines: {node: '>=6.6.0'}
+
+  cookie@0.7.2:
+    resolution: {integrity: sha512-yki5XnKuf750l50uGTllt6kKILY4nQ1eNIQatoXEByZ5dWgnKqbnqmTrBE5B4N7lrMJKQ2ytWMiTO2o0v6Ew/w==}
+    engines: {node: '>= 0.6'}
+
+  copy-anything@4.0.5:
+    resolution: {integrity: sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==}
+    engines: {node: '>=18'}
+
+  cors@2.8.6:
+    resolution: {integrity: sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==}
+    engines: {node: '>= 0.10'}
+
+  crelt@1.0.6:
+    resolution: {integrity: sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==}
+
+  cross-spawn@7.0.6:
+    resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
+    engines: {node: '>= 8'}
+
+  css-select@5.2.2:
+    resolution: {integrity: sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==}
+
+  css-what@6.2.2:
+    resolution: {integrity: sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==}
+    engines: {node: '>= 6'}
+
+  css@3.0.0:
+    resolution: {integrity: sha512-DG9pFfwOrzc+hawpmqX/dHYHJG+Bsdb0klhyi1sDneOgGOXy9wQIC8hzyVp1e4NRYDBdxcylvywPkkXCHAzTyQ==}
+
+  cssesc@3.0.0:
+    resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
+    engines: {node: '>=4'}
+    hasBin: true
+
+  csstype@3.2.3:
+    resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
+
+  dayjs@1.11.21:
+    resolution: {integrity: sha512-98IT+HOahAisibz/yjKbzuOBwYcjJ7BCLPzARyHiyEBmRz4fatF+KPJszEHXsGYjUG234aH/cOjW1wwTbKUZlA==}
+
+  debounce-fn@4.0.0:
+    resolution: {integrity: sha512-8pYCQiL9Xdcg0UPSD3d+0KMlOjp+KGU5EPwYddgzQ7DATsg4fuUDjQtsYLmWjnk2obnNHgV3vE2Y4jejSOJVBQ==}
+    engines: {node: '>=10'}
+
+  debug@4.4.3:
+    resolution: {integrity: sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==}
+    engines: {node: '>=6.0'}
+    peerDependencies:
+      supports-color: '*'
+    peerDependenciesMeta:
+      supports-color:
+        optional: true
+
+  decode-uri-component@0.2.2:
+    resolution: {integrity: sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ==}
+    engines: {node: '>=0.10'}
+
+  decompress-response@6.0.0:
+    resolution: {integrity: sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==}
+    engines: {node: '>=10'}
+
+  dedent@1.7.2:
+    resolution: {integrity: sha512-WzMx3mW98SN+zn3hgemf4OzdmyNhhhKz5Ay0pUfQiMQ3e1g+xmTJWp/pKdwKVXhdSkAEGIIzqeuWrL3mV/AXbA==}
+    peerDependencies:
+      babel-plugin-macros: ^3.1.0
+    peerDependenciesMeta:
+      babel-plugin-macros:
+        optional: true
+
+  deep-diff@1.0.2:
+    resolution: {integrity: sha512-aWS3UIVH+NPGCD1kki+DCU9Dua032iSsO43LqQpcs4R3+dVv7tX0qBGjiVHJHjplsoUM2XRO/KB92glqc68awg==}
+    deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.
+
+  deep-extend@0.6.0:
+    resolution: {integrity: sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA==}
+    engines: {node: '>=4.0.0'}
+
+  deep-is@0.1.4:
+    resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
+
+  deepmerge@4.3.1:
+    resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
+    engines: {node: '>=0.10.0'}
+
+  default-browser-id@5.0.1:
+    resolution: {integrity: sha512-x1VCxdX4t+8wVfd1so/9w+vQ4vx7lKd2Qp5tDRutErwmR85OgmfX7RlLRMWafRMY7hbEiXIbudNrjOAPa/hL8Q==}
+    engines: {node: '>=18'}
+
+  default-browser@5.5.0:
+    resolution: {integrity: sha512-H9LMLr5zwIbSxrmvikGuI/5KGhZ8E2zH3stkMgM5LpOWDutGM2JZaj460Udnf1a+946zc7YBgrqEWwbk7zHvGw==}
+    engines: {node: '>=18'}
+
+  define-lazy-prop@2.0.0:
+    resolution: {integrity: sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==}
+    engines: {node: '>=8'}
+
+  define-lazy-prop@3.0.0:
+    resolution: {integrity: sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==}
+    engines: {node: '>=12'}
+
+  defu@6.1.7:
+    resolution: {integrity: sha512-7z22QmUWiQ/2d0KkdYmANbRUVABpZ9SNYyH5vx6PZ+nE5bcC0l7uFvEfHlyld/HcGBFTL536ClDt3DEcSlEJAQ==}
+
+  denque@2.1.0:
+    resolution: {integrity: sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==}
+    engines: {node: '>=0.10'}
+
+  depd@2.0.0:
+    resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==}
+    engines: {node: '>= 0.8'}
+
+  dequal@2.0.3:
+    resolution: {integrity: sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==}
+    engines: {node: '>=6'}
+
+  destr@2.0.5:
+    resolution: {integrity: sha512-ugFTXCtDZunbzasqBxrK93Ik/DRYsO6S/fedkWEMKqt04xZ4csmnmwGDBAb07QWNaGMAmnTIemsYZCksjATwsA==}
+
+  detect-libc@2.1.2:
+    resolution: {integrity: sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==}
+    engines: {node: '>=8'}
+
+  devlop@1.1.0:
+    resolution: {integrity: sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==}
+
+  diff@8.0.4:
+    resolution: {integrity: sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw==}
+    engines: {node: '>=0.3.1'}
+
+  diff@9.0.0:
+    resolution: {integrity: sha512-svtcdpS8CgJyqAjEQIXdb3OjhFVVYjzGAPO8WGCmRbrml64SPw/jJD4GoE98aR7r25A0XcgrK3F02yw9R/vhQw==}
+    engines: {node: '>=0.3.1'}
+
+  discontinuous-range@1.0.0:
+    resolution: {integrity: sha512-c68LpLbO+7kP/b1Hr1qs8/BJ09F5khZGTxqxZuhzxpmwJKOgRFHJWIb9/KmqnqHhLdO55aOxFH/EGBvUQbL/RQ==}
+
+  dom-serializer@2.0.0:
+    resolution: {integrity: sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==}
+
+  dom-to-image-more@3.7.2:
+    resolution: {integrity: sha512-uQf+pHv6eQhgfI8t2bFuinV0KsPyT8TZgCLwcSU8uBVgN9v6leb0mMpvp6HQAlAcplP3NCcGjxbdqef6pTzvmw==}
+
+  domelementtype@2.3.0:
+    resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==}
+
+  domhandler@5.0.3:
+    resolution: {integrity: sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==}
+    engines: {node: '>= 4'}
+
+  domutils@3.2.2:
+    resolution: {integrity: sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==}
+
+  dot-prop@6.0.1:
+    resolution: {integrity: sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==}
+    engines: {node: '>=10'}
+
+  dotenv@17.4.2:
+    resolution: {integrity: sha512-nI4U3TottKAcAD9LLud4Cb7b2QztQMUEfHbvhTH09bqXTxnSie8WnjPALV/WMCrJZ6UV/qHJ6L03OqO3LcdYZw==}
+    engines: {node: '>=12'}
+
+  dunder-proto@1.0.1:
+    resolution: {integrity: sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==}
+    engines: {node: '>= 0.4'}
+
+  echarts@6.1.0:
+    resolution: {integrity: sha512-q0yaFPggC9FUdsWH4blavRWFmxdrIodbkoKNAjJudAI6CA9gNPxHtV2RcZNEepZVlk4yvBYkOkbk6HIVpIyHZA==}
+
+  ee-first@1.1.1:
+    resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
+
+  electron-to-chromium@1.5.382:
+    resolution: {integrity: sha512-8ETaWbV6SZOrno+G93Ffd9ENsMtetqdnqj4nlfxFW90Sm5GgnuV28Kf62hqQVD6VUgzm7qFQKsTsAPmeUiU3Ug==}
+
+  emoji-regex@10.6.0:
+    resolution: {integrity: sha512-toUI84YS5YmxW219erniWD0CIVOo46xGKColeNQRgOzDorgBi1v4D71/OFzgD9GO2UGKIv1C3Sp8DAn0+j5w7A==}
+
+  emoji-regex@8.0.0:
+    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
+
+  encodeurl@2.0.0:
+    resolution: {integrity: sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==}
+    engines: {node: '>= 0.8'}
+
+  end-of-stream@1.4.5:
+    resolution: {integrity: sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==}
+
+  enhanced-resolve@5.22.1:
+    resolution: {integrity: sha512-6QEuw3zoX1SJQc7b87aBXke/no+mG2bTBgw29gWMQonLmpEkWoCAVkl+M49e48AZlWzxiDzDZzYdp6kobcyLww==}
+    engines: {node: '>=10.13.0'}
+
+  enquirer@2.4.1:
+    resolution: {integrity: sha512-rRqJg/6gd538VHvR3PSrdRBb/1Vy2YfzHqzvbhGIQpDRKIa4FgV/54b5Q1xYSxOOwKvjXweS26E0Q+nAMwp2pQ==}
+    engines: {node: '>=8.6'}
+
+  entities@4.5.0:
+    resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==}
+    engines: {node: '>=0.12'}
+
+  entities@7.0.1:
+    resolution: {integrity: sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==}
+    engines: {node: '>=0.12'}
+
+  env-paths@2.2.1:
+    resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
+    engines: {node: '>=6'}
+
+  environment@1.1.0:
+    resolution: {integrity: sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==}
+    engines: {node: '>=18'}
+
+  es-define-property@1.0.1:
+    resolution: {integrity: sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==}
+    engines: {node: '>= 0.4'}
+
+  es-errors@1.3.0:
+    resolution: {integrity: sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==}
+    engines: {node: '>= 0.4'}
+
+  es-module-lexer@2.1.0:
+    resolution: {integrity: sha512-n27zTYMjYu1aj4MjCWzSP7G9r75utsaoc8m61weK+W8JMBGGQybd43GstCXZ3WNmSFtGT9wi59qQTW6mhTR5LQ==}
+
+  es-object-atoms@1.1.1:
+    resolution: {integrity: sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==}
+    engines: {node: '>= 0.4'}
+
+  esbuild@0.27.7:
+    resolution: {integrity: sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  esbuild@0.28.0:
+    resolution: {integrity: sha512-sNR9MHpXSUV/XB4zmsFKN+QgVG82Cc7+/aaxJ8Adi8hyOac+EXptIp45QBPaVyX3N70664wRbTcLTOemCAnyqw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  escalade@3.2.0:
+    resolution: {integrity: sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==}
+    engines: {node: '>=6'}
+
+  escape-html@1.0.3:
+    resolution: {integrity: sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==}
+
+  escape-string-regexp@4.0.0:
+    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
+    engines: {node: '>=10'}
+
+  eslint-scope@9.1.2:
+    resolution: {integrity: sha512-xS90H51cKw0jltxmvmHy2Iai1LIqrfbw57b79w/J7MfvDfkIkFZ+kj6zC3BjtUwh150HsSSdxXZcsuv72miDFQ==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  eslint-visitor-keys@3.4.3:
+    resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+
+  eslint-visitor-keys@5.0.1:
+    resolution: {integrity: sha512-tD40eHxA35h0PEIZNeIjkHoDR4YjjJp34biM0mDvplBe//mB+IHCqHDGV7pxF+7MklTvighcCPPZC7ynWyjdTA==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  eslint@10.2.1:
+    resolution: {integrity: sha512-wiyGaKsDgqXvF40P8mDwiUp/KQjE1FdrIEJsM8PZ3XCiniTMXS3OHWWUe5FI5agoCnr8x4xPrTDZuxsBlNHl+Q==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+    hasBin: true
+    peerDependencies:
+      jiti: '*'
+    peerDependenciesMeta:
+      jiti:
+        optional: true
+
+  espree@11.2.0:
+    resolution: {integrity: sha512-7p3DrVEIopW1B1avAGLuCSh1jubc01H2JHc8B4qqGblmg5gI9yumBgACjWo4JlIc04ufug4xJ3SQI8HkS/Rgzw==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24}
+
+  esquery@1.7.0:
+    resolution: {integrity: sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g==}
+    engines: {node: '>=0.10'}
+
+  esrecurse@4.3.0:
+    resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
+    engines: {node: '>=4.0'}
+
+  estraverse@5.3.0:
+    resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
+    engines: {node: '>=4.0'}
+
+  estree-walker@2.0.2:
+    resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
+
+  estree-walker@3.0.3:
+    resolution: {integrity: sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==}
+
+  esutils@2.0.3:
+    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
+    engines: {node: '>=0.10.0'}
+
+  etag@1.8.1:
+    resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
+    engines: {node: '>= 0.6'}
+
+  eventemitter3@5.0.4:
+    resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==}
+
+  eventsource-parser@3.0.8:
+    resolution: {integrity: sha512-70QWGkr4snxr0OXLRWsFLeRBIRPuQOvt4s8QYjmUlmlkyTZkRqS7EDVRZtzU3TiyDbXSzaOeF0XUKy8PchzukQ==}
+    engines: {node: '>=18.0.0'}
+
+  eventsource@3.0.7:
+    resolution: {integrity: sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==}
+    engines: {node: '>=18.0.0'}
+
+  execa@5.1.1:
+    resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
+    engines: {node: '>=10'}
+
+  expand-template@2.0.3:
+    resolution: {integrity: sha512-XYfuKMvj4O35f/pOXLObndIRvyQ+/+6AhODh+OKWj9S9498pHHn/IMszH+gt0fBCRWMNfk1ZSp5x3AifmnI2vg==}
+    engines: {node: '>=6'}
+
+  expect-type@1.3.0:
+    resolution: {integrity: sha512-knvyeauYhqjOYvQ66MznSMs83wmHrCycNEN6Ao+2AeYEfxUIkuiVxdEa1qlGEPK+We3n0THiDciYSsCcgW/DoA==}
+    engines: {node: '>=12.0.0'}
+
+  express-rate-limit@8.4.1:
+    resolution: {integrity: sha512-NGVYwQSAyEQgzxX1iCM978PP9AdO/hW93gMcF6ZwQCm+rFvLsBH6w4xcXWTcliS8La5EPRN3p9wzItqBwJrfNw==}
+    engines: {node: '>= 16'}
+    peerDependencies:
+      express: '>= 4.11'
+
+  express@5.2.1:
+    resolution: {integrity: sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw==}
+    engines: {node: '>= 18'}
+
+  exsolve@1.1.0:
+    resolution: {integrity: sha512-D+42+T12DdIlJM3uepa55qGiL3sYdLBOxIl2ifQCzCHz4c7eiolaHsi3BIqEr7JxBzxv2pYZQX9kw16ziMcEmw==}
+
+  fast-deep-equal@3.1.3:
+    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
+
+  fast-diff@1.3.0:
+    resolution: {integrity: sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==}
+
+  fast-glob@3.3.3:
+    resolution: {integrity: sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==}
+    engines: {node: '>=8.6.0'}
+
+  fast-json-stable-stringify@2.1.0:
+    resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
+
+  fast-levenshtein@2.0.6:
+    resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
+
+  fast-uri@3.1.0:
+    resolution: {integrity: sha512-iPeeDKJSWf4IEOasVVrknXpaBV0IApz/gp7S2bb7Z4Lljbl2MGJRqInZiUrQwV16cpzw/D3S5j5Julj/gT52AA==}
+
+  fastq@1.20.1:
+    resolution: {integrity: sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==}
+
+  fdir@6.5.0:
+    resolution: {integrity: sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==}
+    engines: {node: '>=12.0.0'}
+    peerDependencies:
+      picomatch: ^3 || ^4
+    peerDependenciesMeta:
+      picomatch:
+        optional: true
+
+  file-entry-cache@8.0.0:
+    resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
+    engines: {node: '>=16.0.0'}
+
+  file-uri-to-path@1.0.0:
+    resolution: {integrity: sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==}
+
+  fill-range@7.1.1:
+    resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
+    engines: {node: '>=8'}
+
+  finalhandler@2.1.1:
+    resolution: {integrity: sha512-S8KoZgRZN+a5rNwqTxlZZePjT/4cnm0ROV70LedRHZ0p8u9fRID0hJUZQpkKLzro8LfmC8sx23bY6tVNxv8pQA==}
+    engines: {node: '>= 18.0.0'}
+
+  find-up@3.0.0:
+    resolution: {integrity: sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==}
+    engines: {node: '>=6'}
+
+  find-up@5.0.0:
+    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
+    engines: {node: '>=10'}
+
+  flat-cache@4.0.1:
+    resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
+    engines: {node: '>=16'}
+
+  flatted@3.4.2:
+    resolution: {integrity: sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==}
+
+  foreground-child@3.3.1:
+    resolution: {integrity: sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==}
+    engines: {node: '>=14'}
+
+  forwarded@0.2.0:
+    resolution: {integrity: sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==}
+    engines: {node: '>= 0.6'}
+
+  fresh@2.0.0:
+    resolution: {integrity: sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==}
+    engines: {node: '>= 0.8'}
+
+  fs-constants@1.0.0:
+    resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
+
+  fs-extra@11.3.6:
+    resolution: {integrity: sha512-w8ZNZr2mKIc7qeNaQ9AVPT1+iFaI+Avd4xudVOvdDJ8VytREi1Ft5Ih7hd9jjehod8vAM5GMsfQ/TpPf4EyoEA==}
+    engines: {node: '>=14.14'}
+
+  fs.realpath@1.0.0:
+    resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==}
+
+  fsevents@2.3.3:
+    resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
+    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
+    os: [darwin]
+
+  function-bind@1.1.2:
+    resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
+
+  function-timeout@1.0.2:
+    resolution: {integrity: sha512-939eZS4gJ3htTHAldmyyuzlrD58P03fHG49v2JfFXbV6OhvZKRC9j2yAtdHw/zrp2zXHuv05zMIy40F0ge7spA==}
+    engines: {node: '>=18'}
+
+  fuzzysort@3.1.0:
+    resolution: {integrity: sha512-sR9BNCjBg6LNgwvxlBd0sBABvQitkLzoVY9MYYROQVX/FvfJ4Mai9LsGhDgd8qYdds0bY77VzYd5iuB+v5rwQQ==}
+
+  generate-function@2.3.1:
+    resolution: {integrity: sha512-eeB5GfMNeevm/GRYq20ShmsaGcmI81kIX2K9XQx5miC8KdHaC6Jm0qQ8ZNeGOi7wYB8OsdxKs+Y2oVuTFuVwKQ==}
+
+  gensync@1.0.0-beta.2:
+    resolution: {integrity: sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==}
+    engines: {node: '>=6.9.0'}
+
+  get-east-asian-width@1.5.0:
+    resolution: {integrity: sha512-CQ+bEO+Tva/qlmw24dCejulK5pMzVnUOFOijVogd3KQs07HnRIgp8TGipvCCRT06xeYEbpbgwaCxglFyiuIcmA==}
+    engines: {node: '>=18'}
+
+  get-east-asian-width@1.6.0:
+    resolution: {integrity: sha512-QRbvDIbx6YklUe6RxeTeleMR0yv3cYH6PsPZHcnVn7xv7zO1BHN8r0XETu8n6Ye3Q+ahtSarc3WgtNWmehIBfA==}
+    engines: {node: '>=18'}
+
+  get-intrinsic@1.3.0:
+    resolution: {integrity: sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==}
+    engines: {node: '>= 0.4'}
+
+  get-own-enumerable-keys@1.0.0:
+    resolution: {integrity: sha512-PKsK2FSrQCyxcGHsGrLDcK0lx+0Ke+6e8KFFozA9/fIQLhQzPaRvJFdcz7+Axg3jUH/Mq+NI4xa5u/UT2tQskA==}
+    engines: {node: '>=14.16'}
+
+  get-proto@1.0.1:
+    resolution: {integrity: sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==}
+    engines: {node: '>= 0.4'}
+
+  get-stream@6.0.1:
+    resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
+    engines: {node: '>=10'}
+
+  get-tsconfig@4.14.0:
+    resolution: {integrity: sha512-yTb+8DXzDREzgvYmh6s9vHsSVCHeC0G3PI5bEXNBHtmshPnO+S5O7qgLEOn0I5QvMy6kpZN8K1NKGyilLb93wA==}
+
+  giget@3.3.0:
+    resolution: {integrity: sha512-gzi2D96p+AMfDcmJHGDj3KJ9NRiwvlFAU5yfa3ROwWZmFUjX4P43x3BcyRaOMMLto1vUo7C+86+MFhYTl6Ryiw==}
+    hasBin: true
+
+  github-from-package@0.0.0:
+    resolution: {integrity: sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw==}
+
+  glob-parent@5.1.2:
+    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
+    engines: {node: '>= 6'}
+
+  glob-parent@6.0.2:
+    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
+    engines: {node: '>=10.13.0'}
+
+  glob@11.1.0:
+    resolution: {integrity: sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==}
+    engines: {node: 20 || >=22}
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
+    hasBin: true
+
+  glob@7.2.3:
+    resolution: {integrity: sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==}
+    deprecated: Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting i@izs.me
+
+  gonzales-pe@4.3.0:
+    resolution: {integrity: sha512-otgSPpUmdWJ43VXyiNgEYE4luzHCL2pz4wQ0OnDluC6Eg4Ko3Vexy/SrSynglw/eR+OhkzmqFCZa/OFa/RgAOQ==}
+    engines: {node: '>=0.6.0'}
+    hasBin: true
+
+  gopd@1.2.0:
+    resolution: {integrity: sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==}
+    engines: {node: '>= 0.4'}
+
+  graceful-fs@4.2.11:
+    resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
+
+  has-symbols@1.1.0:
+    resolution: {integrity: sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==}
+    engines: {node: '>= 0.4'}
+
+  hasown@2.0.3:
+    resolution: {integrity: sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==}
+    engines: {node: '>= 0.4'}
+
+  hast-util-to-html@9.0.5:
+    resolution: {integrity: sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==}
+
+  hast-util-whitespace@3.0.0:
+    resolution: {integrity: sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==}
+
+  he@1.2.0:
+    resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==}
+    hasBin: true
+
+  hono@4.12.15:
+    resolution: {integrity: sha512-qM0jDhFEaCBb4TxoW7f53Qrpv9RBiayUHo0S52JudprkhvpjIrGoU1mnnr29Fvd1U335ZFPZQY1wlkqgfGXyLg==}
+    engines: {node: '>=16.9.0'}
+
+  hookable@5.5.3:
+    resolution: {integrity: sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==}
+
+  html-void-elements@3.0.0:
+    resolution: {integrity: sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==}
+
+  http-errors@2.0.1:
+    resolution: {integrity: sha512-4FbRdAX+bSdmo4AUFuS0WNiPz8NgFt+r8ThgNWmlrjQjt1Q7ZR9+zTlce2859x4KSXrwIsaeTqDoKQmtP8pLmQ==}
+    engines: {node: '>= 0.8'}
+
+  human-signals@2.1.0:
+    resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
+    engines: {node: '>=10.17.0'}
+
+  husky@9.1.7:
+    resolution: {integrity: sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  iconv-lite@0.7.2:
+    resolution: {integrity: sha512-im9DjEDQ55s9fL4EYzOAv0yMqmMBSZp6G0VvFyTMPKWxiSBHUj9NW/qqLmXUwXrrM7AvqSlTCfvqRb0cM8yYqw==}
+    engines: {node: '>=0.10.0'}
+
+  identifier-regex@1.0.1:
+    resolution: {integrity: sha512-ZrYyM0sozNPZlvBvE7Oq9Bn44n0qKGrYu5sQ0JzMUnjIhpgWYE2JB6aBoFwEYdPjqj7jPyxXTMJiHDOxDfd8yw==}
+    engines: {node: '>=18'}
+
+  ieee754@1.2.1:
+    resolution: {integrity: sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==}
+
+  ignore@5.3.2:
+    resolution: {integrity: sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g==}
+    engines: {node: '>= 4'}
+
+  imurmurhash@0.1.4:
+    resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
+    engines: {node: '>=0.8.19'}
+
+  inflight@1.0.6:
+    resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==}
+    deprecated: This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.
+
+  inherits@2.0.4:
+    resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
+
+  ini@1.3.8:
+    resolution: {integrity: sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==}
+
+  ioredis@5.11.1:
+    resolution: {integrity: sha512-ehuGcf94bQXhfagULNXrJdfnWO38v070jxSx/qE87Kjzmu2fU7ro5EFAb+OPituLqgfyuQaym5DlrNydW2sJ9A==}
+    engines: {node: '>=12.22.0'}
+
+  ip-address@10.1.0:
+    resolution: {integrity: sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==}
+    engines: {node: '>= 12'}
+
+  ipaddr.js@1.9.1:
+    resolution: {integrity: sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==}
+    engines: {node: '>= 0.10'}
+
+  is-docker@2.2.1:
+    resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==}
+    engines: {node: '>=8'}
+    hasBin: true
+
+  is-docker@3.0.0:
+    resolution: {integrity: sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==}
+    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
+    hasBin: true
+
+  is-extglob@2.1.1:
+    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
+    engines: {node: '>=0.10.0'}
+
+  is-fullwidth-code-point@3.0.0:
+    resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
+    engines: {node: '>=8'}
+
+  is-fullwidth-code-point@5.1.0:
+    resolution: {integrity: sha512-5XHYaSyiqADb4RnZ1Bdad6cPp8Toise4TzEjcOYDHZkTCbKgiUl7WTUCpNWHuxmDt91wnsZBc9xinNzopv3JMQ==}
+    engines: {node: '>=18'}
+
+  is-glob@4.0.3:
+    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
+    engines: {node: '>=0.10.0'}
+
+  is-identifier@1.0.1:
+    resolution: {integrity: sha512-HQ5v4rEJ7REUV54bCd2l5FaD299SGDEn2UPoVXaTHAyGviLq2menVUD2udi3trQ32uvB6LdAh/0ck2EuizrtpA==}
+    engines: {node: '>=18'}
+
+  is-inside-container@1.0.0:
+    resolution: {integrity: sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA==}
+    engines: {node: '>=14.16'}
+    hasBin: true
+
+  is-interactive@2.0.0:
+    resolution: {integrity: sha512-qP1vozQRI+BMOPcjFzrjXuQvdak2pHNUMZoeG2eRbiSqyvbEf/wQtEOTOX1guk6E3t36RkaqiSt8A/6YElNxLQ==}
+    engines: {node: '>=12'}
+
+  is-number@7.0.0:
+    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
+    engines: {node: '>=0.12.0'}
+
+  is-obj@2.0.0:
+    resolution: {integrity: sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w==}
+    engines: {node: '>=8'}
+
+  is-obj@3.0.0:
+    resolution: {integrity: sha512-IlsXEHOjtKhpN8r/tRFj2nDyTmHvcfNeu/nrRIcXE17ROeatXchkojffa1SpdqW4cr/Fj6QkEf/Gn4zf6KKvEQ==}
+    engines: {node: '>=12'}
+
+  is-promise@4.0.0:
+    resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==}
+
+  is-property@1.0.2:
+    resolution: {integrity: sha512-Ks/IoX00TtClbGQr4TWXemAnktAQvYB7HzcCxDGqEZU6oCmb2INHuOoKxbtR+HFkmYWBKv/dOZtGRiAjDhj92g==}
+
+  is-regexp@3.1.0:
+    resolution: {integrity: sha512-rbku49cWloU5bSMI+zaRaXdQHXnthP6DZ/vLnfdSKyL4zUzuWnomtOEiZZOd+ioQ+avFo/qau3KPTc7Fjy1uPA==}
+    engines: {node: '>=12'}
+
+  is-stream@2.0.1:
+    resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==}
+    engines: {node: '>=8'}
+
+  is-unicode-supported@2.1.0:
+    resolution: {integrity: sha512-mE00Gnza5EEB3Ds0HfMyllZzbBrmLOX3vfWoj9A9PEnTfratQ/BcaJOuMhnkhjXvb2+FkY3VuHqtAGpTPmglFQ==}
+    engines: {node: '>=18'}
+
+  is-what@5.5.0:
+    resolution: {integrity: sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw==}
+    engines: {node: '>=18'}
+
+  is-wsl@2.2.0:
+    resolution: {integrity: sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==}
+    engines: {node: '>=8'}
+
+  is-wsl@3.1.1:
+    resolution: {integrity: sha512-e6rvdUCiQCAuumZslxRJWR/Doq4VpPR82kqclvcS0efgt430SlGIk05vdCN58+VrzgtIcfNODjozVielycD4Sw==}
+    engines: {node: '>=16'}
+
+  isexe@2.0.0:
+    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
+
+  isexe@3.1.5:
+    resolution: {integrity: sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w==}
+    engines: {node: '>=18'}
+
+  jackspeak@4.2.3:
+    resolution: {integrity: sha512-ykkVRwrYvFm1nb2AJfKKYPr0emF6IiXDYUaFx4Zn9ZuIH7MrzEZ3sD5RlqGXNRpHtvUHJyOnCEFxOlNDtGo7wg==}
+    engines: {node: 20 || >=22}
+
+  jiti@2.7.0:
+    resolution: {integrity: sha512-AC/7JofJvZGrrneWNaEnJeOLUx+JlGt7tNa0wZiRPT4MY1wmfKjt2+6O2p2uz2+skll8OZZmJMNqeke7kKbNgQ==}
+    hasBin: true
+
+  jose@6.2.3:
+    resolution: {integrity: sha512-YYVDInQKFJfR/xa3ojUTl8c2KoTwiL1R5Wg9YCydwH0x0B9grbzlg5HC7mMjCtUJjbQ/YnGEZIhI5tCgfTb4Hw==}
+
+  js-tokens@4.0.0:
+    resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
+
+  jsesc@3.1.0:
+    resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
+    engines: {node: '>=6'}
+    hasBin: true
+
+  json-buffer@3.0.1:
+    resolution: {integrity: sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==}
+
+  json-schema-traverse@0.4.1:
+    resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
+
+  json-schema-traverse@1.0.0:
+    resolution: {integrity: sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==}
+
+  json-schema-typed@7.0.3:
+    resolution: {integrity: sha512-7DE8mpG+/fVw+dTpjbxnx47TaMnDfOI1jwft9g1VybltZCduyRQPJPvc+zzKY9WPHxhPWczyFuYa6I8Mw4iU5A==}
+
+  json-schema-typed@8.0.2:
+    resolution: {integrity: sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==}
+
+  json-stable-stringify-without-jsonify@1.0.1:
+    resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
+
+  json5@2.2.3:
+    resolution: {integrity: sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==}
+    engines: {node: '>=6'}
+    hasBin: true
+
+  jsonfile@6.2.1:
+    resolution: {integrity: sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==}
+
+  keytar@7.9.0:
+    resolution: {integrity: sha512-VPD8mtVtm5JNtA2AErl6Chp06JBfy7diFQ7TQQhdpWOl6MrCRB+eRbvAZUsbGQS9kiMq0coJsy0W0vHpDCkWsQ==}
+
+  keyv@4.5.4:
+    resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
+
+  kleur@3.0.3:
+    resolution: {integrity: sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w==}
+    engines: {node: '>=6'}
+
+  leaflet@1.9.4:
+    resolution: {integrity: sha512-nxS1ynzJOmOlHp+iL3FyWqK89GtNL8U8rvlMOsQdTTssxZwCXh8N2NB3GDQOL+YR3XnWyZAxwQixURb+FA74PA==}
+
+  levn@0.4.1:
+    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
+    engines: {node: '>= 0.8.0'}
+
+  lightningcss-android-arm64@1.32.0:
+    resolution: {integrity: sha512-YK7/ClTt4kAK0vo6w3X+Pnm0D2cf2vPHbhOXdoNti1Ga0al1P4TBZhwjATvjNwLEBCnKvjJc2jQgHXH0NEwlAg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [android]
+
+  lightningcss-darwin-arm64@1.32.0:
+    resolution: {integrity: sha512-RzeG9Ju5bag2Bv1/lwlVJvBE3q6TtXskdZLLCyfg5pt+HLz9BqlICO7LZM7VHNTTn/5PRhHFBSjk5lc4cmscPQ==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [darwin]
+
+  lightningcss-darwin-x64@1.32.0:
+    resolution: {integrity: sha512-U+QsBp2m/s2wqpUYT/6wnlagdZbtZdndSmut/NJqlCcMLTWp5muCrID+K5UJ6jqD2BFshejCYXniPDbNh73V8w==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [darwin]
+
+  lightningcss-freebsd-x64@1.32.0:
+    resolution: {integrity: sha512-JCTigedEksZk3tHTTthnMdVfGf61Fky8Ji2E4YjUTEQX14xiy/lTzXnu1vwiZe3bYe0q+SpsSH/CTeDXK6WHig==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [freebsd]
+
+  lightningcss-linux-arm-gnueabihf@1.32.0:
+    resolution: {integrity: sha512-x6rnnpRa2GL0zQOkt6rts3YDPzduLpWvwAF6EMhXFVZXD4tPrBkEFqzGowzCsIWsPjqSK+tyNEODUBXeeVHSkw==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm]
+    os: [linux]
+
+  lightningcss-linux-arm64-gnu@1.32.0:
+    resolution: {integrity: sha512-0nnMyoyOLRJXfbMOilaSRcLH3Jw5z9HDNGfT/gwCPgaDjnx0i8w7vBzFLFR1f6CMLKF8gVbebmkUN3fa/kQJpQ==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  lightningcss-linux-arm64-musl@1.32.0:
+    resolution: {integrity: sha512-UpQkoenr4UJEzgVIYpI80lDFvRmPVg6oqboNHfoH4CQIfNA+HOrZ7Mo7KZP02dC6LjghPQJeBsvXhJod/wnIBg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  lightningcss-linux-x64-gnu@1.32.0:
+    resolution: {integrity: sha512-V7Qr52IhZmdKPVr+Vtw8o+WLsQJYCTd8loIfpDaMRWGUZfBOYEJeyJIkqGIDMZPwPx24pUMfwSxxI8phr/MbOA==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  lightningcss-linux-x64-musl@1.32.0:
+    resolution: {integrity: sha512-bYcLp+Vb0awsiXg/80uCRezCYHNg1/l3mt0gzHnWV9XP1W5sKa5/TCdGWaR/zBM2PeF/HbsQv/j2URNOiVuxWg==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  lightningcss-win32-arm64-msvc@1.32.0:
+    resolution: {integrity: sha512-8SbC8BR40pS6baCM8sbtYDSwEVQd4JlFTOlaD3gWGHfThTcABnNDBda6eTZeqbofalIJhFx0qKzgHJmcPTnGdw==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [arm64]
+    os: [win32]
+
+  lightningcss-win32-x64-msvc@1.32.0:
+    resolution: {integrity: sha512-Amq9B/SoZYdDi1kFrojnoqPLxYhQ4Wo5XiL8EVJrVsB8ARoC1PWW6VGtT0WKCemjy8aC+louJnjS7U18x3b06Q==}
+    engines: {node: '>= 12.0.0'}
+    cpu: [x64]
+    os: [win32]
+
+  lightningcss@1.32.0:
+    resolution: {integrity: sha512-NXYBzinNrblfraPGyrbPoD19C1h9lfI/1mzgWYvXUTe414Gz/X1FD2XBZSZM7rRTrMA8JL3OtAaGifrIKhQ5yQ==}
+    engines: {node: '>= 12.0.0'}
+
+  lint-staged@16.4.0:
+    resolution: {integrity: sha512-lBWt8hujh/Cjysw5GYVmZpFHXDCgZzhrOm8vbcUdobADZNOK/bRshr2kM3DfgrrtR1DQhfupW9gnIXOfiFi+bw==}
+    engines: {node: '>=20.17'}
+    hasBin: true
+
+  listr2@9.0.5:
+    resolution: {integrity: sha512-ME4Fb83LgEgwNw96RKNvKV4VTLuXfoKudAmm2lP8Kk87KaMK0/Xrx/aAkMWmT8mDb+3MlFDspfbCs7adjRxA2g==}
+    engines: {node: '>=20.0.0'}
+
+  locate-path@3.0.0:
+    resolution: {integrity: sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==}
+    engines: {node: '>=6'}
+
+  locate-path@6.0.0:
+    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
+    engines: {node: '>=10'}
+
+  lodash-es@4.18.1:
+    resolution: {integrity: sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A==}
+
+  lodash.sortedlastindex@4.1.0:
+    resolution: {integrity: sha512-s8xEQdsp2Tu5zUqVdFSe9C0kR8YlnAJYLqMdkh+pIRBRxF6/apWseLdHl3/+jv2I61dhPwtI/Ff+EqvCpc+N8w==}
+
+  lodash.truncate@4.4.2:
+    resolution: {integrity: sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw==}
+
+  log-symbols@7.0.1:
+    resolution: {integrity: sha512-ja1E3yCr9i/0hmBVaM0bfwDjnGy8I/s6PP4DFp+yP+a+mrHO4Rm7DtmnqROTUkHIkqffC84YY7AeqX6oFk0WFg==}
+    engines: {node: '>=18'}
+
+  log-update@6.1.0:
+    resolution: {integrity: sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==}
+    engines: {node: '>=18'}
+
+  long@5.3.2:
+    resolution: {integrity: sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==}
+
+  lru-cache@11.5.1:
+    resolution: {integrity: sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==}
+    engines: {node: 20 || >=22}
+
+  lru-cache@5.1.1:
+    resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
+
+  lru.min@1.1.4:
+    resolution: {integrity: sha512-DqC6n3QQ77zdFpCMASA1a3Jlb64Hv2N2DciFGkO/4L9+q/IpIAuRlKOvCXabtRW6cQf8usbmM6BE/TOPysCdIA==}
+    engines: {bun: '>=1.0.0', deno: '>=1.30.0', node: '>=8.0.0'}
+
+  magic-string@0.30.21:
+    resolution: {integrity: sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==}
+
+  make-asynchronous@1.1.0:
+    resolution: {integrity: sha512-ayF7iT+44LXdxJLTrTd3TLQpFDDvPCBxXxbv+pMUSuHA5Q8zyAfwkRP6aHHwNVFBUFWtxAHqwNJxF8vMZLAbVg==}
+    engines: {node: '>=18'}
+
+  marked@18.0.4:
+    resolution: {integrity: sha512-c/BTaKzg0G6ezQx97DAkYU7k0HM6ys0FqYeKBL6hlBByZwy+ycA1+f0vDdjMHKKeEjdgkx0GOv9Il6D+85cOqA==}
+    engines: {node: '>= 20'}
+    hasBin: true
+
+  math-intrinsics@1.1.0:
+    resolution: {integrity: sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==}
+    engines: {node: '>= 0.4'}
+
+  mdast-util-to-hast@13.2.1:
+    resolution: {integrity: sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==}
+
+  media-typer@1.1.0:
+    resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==}
+    engines: {node: '>= 0.8'}
+
+  merge-descriptors@2.0.0:
+    resolution: {integrity: sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==}
+    engines: {node: '>=18'}
+
+  merge-stream@2.0.0:
+    resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
+
+  merge2@1.4.1:
+    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
+    engines: {node: '>= 8'}
+
+  micromark-util-character@2.1.1:
+    resolution: {integrity: sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==}
+
+  micromark-util-encode@2.0.1:
+    resolution: {integrity: sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==}
+
+  micromark-util-sanitize-uri@2.0.1:
+    resolution: {integrity: sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==}
+
+  micromark-util-symbol@2.0.1:
+    resolution: {integrity: sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==}
+
+  micromark-util-types@2.0.2:
+    resolution: {integrity: sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==}
+
+  micromatch@4.0.8:
+    resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
+    engines: {node: '>=8.6'}
+
+  mime-db@1.54.0:
+    resolution: {integrity: sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==}
+    engines: {node: '>= 0.6'}
+
+  mime-types@3.0.2:
+    resolution: {integrity: sha512-Lbgzdk0h4juoQ9fCKXW4by0UJqj+nOOrI9MJ1sSj4nI8aI2eo1qmvQEie4VD1glsS250n15LsWsYtCugiStS5A==}
+    engines: {node: '>=18'}
+
+  mimic-fn@2.1.0:
+    resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
+    engines: {node: '>=6'}
+
+  mimic-fn@3.1.0:
+    resolution: {integrity: sha512-Ysbi9uYW9hFyfrThdDEQuykN4Ey6BuwPD2kpI5ES/nFTDn/98yxYNLZJcgUAKPT/mcrLLKaGzJR9YVxJrIdASQ==}
+    engines: {node: '>=8'}
+
+  mimic-function@5.0.1:
+    resolution: {integrity: sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==}
+    engines: {node: '>=18'}
+
+  mimic-response@3.1.0:
+    resolution: {integrity: sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==}
+    engines: {node: '>=10'}
+
+  minimatch@10.2.5:
+    resolution: {integrity: sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==}
+    engines: {node: 18 || 20 || >=22}
+
+  minimatch@3.1.5:
+    resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==}
+
+  minimist@1.2.8:
+    resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
+
+  minipass@7.1.3:
+    resolution: {integrity: sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==}
+    engines: {node: '>=16 || 14 >=14.17'}
+
+  mitt@3.0.1:
+    resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==}
+
+  mkdirp-classic@0.5.3:
+    resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==}
+
+  moo@0.5.3:
+    resolution: {integrity: sha512-m2fmM2dDm7GZQsY7KK2cme8agi+AAljILjQnof7p1ZMDe6dQ4bdnSMx0cPppudoeNv5hEFQirN6u+O4fDE0IWA==}
+
+  ms@2.1.3:
+    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
+
+  muggle-string@0.4.1:
+    resolution: {integrity: sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ==}
+
+  mysql2@3.22.3:
+    resolution: {integrity: sha512-uWWxvZSRvRhtBdh2CdcuK83YcOfPdmEeEYB069bAmPnV93QApDGVPuvCQOLjlh7tYHEWdgQPrn6kosDxHBVLkA==}
+    engines: {node: '>= 8.0'}
+    peerDependencies:
+      '@types/node': '>= 8'
+
+  named-placeholders@1.1.6:
+    resolution: {integrity: sha512-Tz09sEL2EEuv5fFowm419c1+a/jSMiBjI9gHxVLrVdbUkkNUUfjsVYs9pVZu5oCon/kmRh9TfLEObFtkVxmY0w==}
+    engines: {node: '>=8.0.0'}
+
+  nanoid@3.3.12:
+    resolution: {integrity: sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  nanoid@3.3.15:
+    resolution: {integrity: sha512-y7Wygv/7mEOvxTuEQDB8StXdMRBWf1kR/tlhAzBRUFkB2jfcLOAxO/SHmOO2zgz1pVgK29/kyupn059/bCHdjA==}
+    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
+    hasBin: true
+
+  napi-build-utils@2.0.0:
+    resolution: {integrity: sha512-GEbrYkbfF7MoNaoh2iGG84Mnf/WZfB0GdGEsM8wz7Expx/LlWf5U8t9nvJKXSp3qr5IsEbK04cBGhol/KwOsWA==}
+
+  natural-compare@1.4.0:
+    resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
+
+  nearley@2.20.1:
+    resolution: {integrity: sha512-+Mc8UaAebFzgV+KpI5n7DasuuQCHA89dmwm7JXw3TV43ukfNQ9DnBH3Mdb2g/I4Fdxc26pwimBWvjIw0UAILSQ==}
+    hasBin: true
+
+  negotiator@1.0.0:
+    resolution: {integrity: sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==}
+    engines: {node: '>= 0.6'}
+
+  node-abi@3.92.0:
+    resolution: {integrity: sha512-KdHvFWZjEKDf0cakgFjebl371GPsISX2oZHcuyKqM7DtogIsHrqKeLTo8wBHxaXRAQlY2PsPlZmfo+9ZCxEREQ==}
+    engines: {node: '>=10'}
+
+  node-addon-api@4.3.0:
+    resolution: {integrity: sha512-73sE9+3UaLYYFmDsFZnqCInzPyh3MqIwZO9cw58yIqAZhONrrabrYyYe3TuIqtIiOuTXVhsGau8hcrhhwSsDIQ==}
+
+  node-fetch-native@1.6.7:
+    resolution: {integrity: sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q==}
+
+  node-html-parser@7.1.0:
+    resolution: {integrity: sha512-iJo8b2uYGT40Y8BTyy5ufL6IVbN8rbm/1QK2xffXU/1a/v3AAa0d1YAoqBNYqaS4R/HajkWIpIfdE6KcyFh1AQ==}
+
+  node-releases@2.0.50:
+    resolution: {integrity: sha512-J6l92tKHX6w8Jy5nO1Vuc01NoIiRGi/d6qBKVxh+IQ8Cr3b6HbVNfKiF8ZpFKufTwpwxMmce2W3iQZ861ZRyTg==}
+    engines: {node: '>=18'}
+
+  npm-run-path@4.0.1:
+    resolution: {integrity: sha512-S48WzZW777zhNIrn7gxOlISNAqi9ZC/uQFnRdbeIHhZhCA6UqpkOT8T1G7BvfdgP4Er8gF4sUbaS0i7QvIfCWw==}
+    engines: {node: '>=8'}
+
+  nth-check@2.1.1:
+    resolution: {integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==}
+
+  nypm@0.6.8:
+    resolution: {integrity: sha512-Q9K4Diu6l5u6xJQogeFSs/zKtyMSgFKFtRQV+tHP4kL7KPm2grpBU0dFIwFaXwNxN0MtfKWc43VpCugAa+LPsw==}
+    engines: {node: '>=18'}
+    hasBin: true
+
+  object-assign@4.1.1:
+    resolution: {integrity: sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==}
+    engines: {node: '>=0.10.0'}
+
+  object-inspect@1.13.4:
+    resolution: {integrity: sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==}
+    engines: {node: '>= 0.4'}
+
+  object-treeify@1.1.33:
+    resolution: {integrity: sha512-EFVjAYfzWqWsBMRHPMAXLCDIJnpMhdWAqR7xG6M6a2cs6PMFpl/+Z20w9zDW4vkxOFfddegBKq9Rehd0bxWE7A==}
+    engines: {node: '>= 10'}
+
+  obug@2.1.2:
+    resolution: {integrity: sha512-AWGB9WFcRXOQs48Z/udjI5ZcZMHXwX8XPByNpOydgcGsDLIzjGizhoMWJyKAWze7AVW/2W1i+/gPX4YtKe5cyg==}
+    engines: {node: '>=12.20.0'}
+
+  ofetch@1.5.1:
+    resolution: {integrity: sha512-2W4oUZlVaqAPAil6FUg/difl6YhqhUR7x2eZY4bQCko22UXg3hptq9KLQdqFClV+Wu85UX7hNtdGTngi/1BxcA==}
+
+  ohash@2.0.11:
+    resolution: {integrity: sha512-RdR9FQrFwNBNXAr4GixM8YaRZRJ5PUWbKYbE5eOsrwAjJW0q2REGcf79oYPsLyskQCZG1PLN+S/K1V00joZAoQ==}
+
+  on-finished@2.4.1:
+    resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
+    engines: {node: '>= 0.8'}
+
+  once@1.4.0:
+    resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
+
+  onetime@5.1.2:
+    resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==}
+    engines: {node: '>=6'}
+
+  onetime@7.0.0:
+    resolution: {integrity: sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==}
+    engines: {node: '>=18'}
+
+  oniguruma-parser@0.12.2:
+    resolution: {integrity: sha512-6HVa5oIrgMC6aA6WF6XyyqbhRPJrKR02L20+2+zpDtO5QAzGHAUGw5TKQvwi5vctNnRHkJYmjAhRVQF2EKdTQw==}
+
+  oniguruma-to-es@4.3.6:
+    resolution: {integrity: sha512-csuQ9x3Yr0cEIs/Zgx/OEt9iBw9vqIunAPQkx19R/fiMq2oGVTgcMqO/V3Ybqefr1TBvosI6jU539ksaBULJyA==}
+
+  open@10.2.0:
+    resolution: {integrity: sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA==}
+    engines: {node: '>=18'}
+
+  open@8.4.2:
+    resolution: {integrity: sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==}
+    engines: {node: '>=12'}
+
+  optionator@0.9.4:
+    resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
+    engines: {node: '>= 0.8.0'}
+
+  ora@9.4.1:
+    resolution: {integrity: sha512-6VlU9MLXbjVQD04AZCMX28hVtA5bUoadvUqO76MUCVA0ilwJbMiHsITRPfyVm6p/BC0Av/BXMujx39WCe1LEqw==}
+    engines: {node: '>=20'}
+
+  oxfmt@0.53.0:
+    resolution: {integrity: sha512-9cB5glS3Ip6NMuZ+6NYTao9FCWkDhRtPYCtR3QBu/NxHoFbgzzTvi41N4jxz/GqGfuLKspui1qb/LlSu2IbMcw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      svelte: ^5.0.0
+      vite-plus: '*'
+    peerDependenciesMeta:
+      svelte:
+        optional: true
+      vite-plus:
+        optional: true
+
+  oxlint@1.68.0:
+    resolution: {integrity: sha512-dXcbq+xsmLrMy6T8d0euf3IYUfLmjHIE11pOxiUSi5LHkFZaYPv568R6sEjcavVpUxoaQe66UBuK4HEi74NxpA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      oxlint-tsgolint: '>=0.22.1'
+      vite-plus: '*'
+    peerDependenciesMeta:
+      oxlint-tsgolint:
+        optional: true
+      vite-plus:
+        optional: true
+
+  p-event@6.0.1:
+    resolution: {integrity: sha512-Q6Bekk5wpzW5qIyUP4gdMEujObYstZl6DMMOSenwBvV0BlE5LkDwkjs5yHbZmdCEq2o4RJx4tE1vwxFVf2FG1w==}
+    engines: {node: '>=16.17'}
+
+  p-limit@2.3.0:
+    resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
+    engines: {node: '>=6'}
+
+  p-limit@3.1.0:
+    resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
+    engines: {node: '>=10'}
+
+  p-locate@3.0.0:
+    resolution: {integrity: sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==}
+    engines: {node: '>=6'}
+
+  p-locate@5.0.0:
+    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
+    engines: {node: '>=10'}
+
+  p-timeout@6.1.4:
+    resolution: {integrity: sha512-MyIV3ZA/PmyBN/ud8vV9XzwTrNtR4jFrObymZYnZqMmW0zA8Z17vnT0rBgFE/TlohB+YCHqXMgZzb3Csp49vqg==}
+    engines: {node: '>=14.16'}
+
+  p-try@2.2.0:
+    resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
+    engines: {node: '>=6'}
+
+  package-json-from-dist@1.0.1:
+    resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}
+
+  parseurl@1.3.3:
+    resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==}
+    engines: {node: '>= 0.8'}
+
+  path-browserify@1.0.1:
+    resolution: {integrity: sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==}
+
+  path-exists@3.0.0:
+    resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==}
+    engines: {node: '>=4'}
+
+  path-exists@4.0.0:
+    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
+    engines: {node: '>=8'}
+
+  path-is-absolute@1.0.1:
+    resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==}
+    engines: {node: '>=0.10.0'}
+
+  path-key@3.1.1:
+    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
+    engines: {node: '>=8'}
+
+  path-scurry@2.0.2:
+    resolution: {integrity: sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==}
+    engines: {node: 18 || 20 || >=22}
+
+  path-to-regexp@8.4.2:
+    resolution: {integrity: sha512-qRcuIdP69NPm4qbACK+aDogI5CBDMi1jKe0ry5rSQJz8JVLsC7jV8XpiJjGRLLol3N+R5ihGYcrPLTno6pAdBA==}
+
+  pathe@2.0.3:
+    resolution: {integrity: sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==}
+
+  perfect-debounce@1.0.0:
+    resolution: {integrity: sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==}
+
+  perfect-debounce@2.1.0:
+    resolution: {integrity: sha512-LjgdTytVFXeUgtHZr9WYViYSM/g8MkcTPYDlPa3cDqMirHjKiSZPYd6DoL7pK8AJQr+uWkQvCjHNdiMqsrJs+g==}
+
+  pg-cloudflare@1.3.0:
+    resolution: {integrity: sha512-6lswVVSztmHiRtD6I8hw4qP/nDm1EJbKMRhf3HCYaqud7frGysPv7FYJ5noZQdhQtN2xJnimfMtvQq21pdbzyQ==}
+
+  pg-connection-string@2.12.0:
+    resolution: {integrity: sha512-U7qg+bpswf3Cs5xLzRqbXbQl85ng0mfSV/J0nnA31MCLgvEaAo7CIhmeyrmJpOr7o+zm0rXK+hNnT5l9RHkCkQ==}
+
+  pg-int8@1.0.1:
+    resolution: {integrity: sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==}
+    engines: {node: '>=4.0.0'}
+
+  pg-pool@3.13.0:
+    resolution: {integrity: sha512-gB+R+Xud1gLFuRD/QgOIgGOBE2KCQPaPwkzBBGC9oG69pHTkhQeIuejVIk3/cnDyX39av2AxomQiyPT13WKHQA==}
+    peerDependencies:
+      pg: '>=8.0'
+
+  pg-protocol@1.13.0:
+    resolution: {integrity: sha512-zzdvXfS6v89r6v7OcFCHfHlyG/wvry1ALxZo4LqgUoy7W9xhBDMaqOuMiF3qEV45VqsN6rdlcehHrfDtlCPc8w==}
+
+  pg-types@2.2.0:
+    resolution: {integrity: sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==}
+    engines: {node: '>=4'}
+
+  pg@8.20.0:
+    resolution: {integrity: sha512-ldhMxz2r8fl/6QkXnBD3CR9/xg694oT6DZQ2s6c/RI28OjtSOpxnPrUCGOBJ46RCUxcWdx3p6kw/xnDHjKvaRA==}
+    engines: {node: '>= 16.0.0'}
+    peerDependencies:
+      pg-native: '>=3.0.1'
+    peerDependenciesMeta:
+      pg-native:
+        optional: true
+
+  pgpass@1.0.5:
+    resolution: {integrity: sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==}
+
+  picocolors@1.1.1:
+    resolution: {integrity: sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==}
+
+  picomatch@2.3.2:
+    resolution: {integrity: sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==}
+    engines: {node: '>=8.6'}
+
+  picomatch@4.0.4:
+    resolution: {integrity: sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==}
+    engines: {node: '>=12'}
+
+  pinia@3.0.4:
+    resolution: {integrity: sha512-l7pqLUFTI/+ESXn6k3nu30ZIzW5E2WZF/LaHJEpoq6ElcLD+wduZoB2kBN19du6K/4FDpPMazY2wJr+IndBtQw==}
+    peerDependencies:
+      typescript: '>=4.5.0'
+      vue: ^3.5.11
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+
+  pkce-challenge@5.0.1:
+    resolution: {integrity: sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==}
+    engines: {node: '>=16.20.0'}
+
+  pkg-types@2.3.1:
+    resolution: {integrity: sha512-y+ichcgc2LrADuhLNAx8DFjVfgz91pRxfZdI3UDhxHvcVEZsenLO+7XaU5vOp0u/7V/wZ+plyuQxtrDlZJ+yeg==}
+
+  pkg-up@3.1.0:
+    resolution: {integrity: sha512-nDywThFk1i4BQK4twPQ6TA4RT8bDY96yeuCVBWL3ePARCiEKDRSrNGbFIgUJpLp+XeIR65v8ra7WuJOFUBtkMA==}
+    engines: {node: '>=8'}
+
+  postcss-less@6.0.0:
+    resolution: {integrity: sha512-FPX16mQLyEjLzEuuJtxA8X3ejDLNGGEG503d2YGZR5Ask1SpDN8KmZUMpzCvyalWRywAn1n1VOA5dcqfCLo5rg==}
+    engines: {node: '>=12'}
+    peerDependencies:
+      postcss: ^8.3.5
+
+  postcss-sass@0.5.0:
+    resolution: {integrity: sha512-qtu8awh1NMF3o9j/x9j3EZnd+BlF66X6NZYl12BdKoG2Z4hmydOt/dZj2Nq+g0kfk2pQy3jeYFBmvG9DBwynGQ==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  postcss-scss@4.0.9:
+    resolution: {integrity: sha512-AjKOeiwAitL/MXxQW2DliT28EKukvvbEWx3LBmJIRN8KfBGZbRTxNYW0kSqi1COiTZ57nZ9NW06S6ux//N1c9A==}
+    engines: {node: '>=12.0'}
+    peerDependencies:
+      postcss: ^8.4.29
+
+  postcss-selector-parser@7.1.4:
+    resolution: {integrity: sha512-HeP7D2wyhkR+XaK6v4W8oRF62Dsz4flyuczALJp61GckGm42u1saSSJ/0auvcBqxs3jMRFEcPK34At/0JBKdOg==}
+    engines: {node: '>=4'}
+
+  postcss-styl@0.12.3:
+    resolution: {integrity: sha512-8I7Cd8sxiEITIp32xBK4K/Aj1ukX6vuWnx8oY/oAH35NfQI4OZaY5nd68Yx8HeN5S49uhQ6DL0rNk0ZBu/TaLg==}
+    engines: {node: ^8.10.0 || ^10.13.0 || ^11.10.1 || >=12.13.0}
+
+  postcss@8.5.15:
+    resolution: {integrity: sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  postcss@8.5.16:
+    resolution: {integrity: sha512-vuwillviilfKZsg0VGj5R/YwwcHx4SLsIOI/7K6mQkWx+l5cUHTjj5g0AasTBcyXsbfTgrwsUNmVUb5xVwyPwg==}
+    engines: {node: ^10 || ^12 || >=14}
+
+  postgres-array@2.0.0:
+    resolution: {integrity: sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==}
+    engines: {node: '>=4'}
+
+  postgres-bytea@1.0.1:
+    resolution: {integrity: sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==}
+    engines: {node: '>=0.10.0'}
+
+  postgres-date@1.0.7:
+    resolution: {integrity: sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==}
+    engines: {node: '>=0.10.0'}
+
+  postgres-interval@1.2.0:
+    resolution: {integrity: sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==}
+    engines: {node: '>=0.10.0'}
+
+  prebuild-install@7.1.3:
+    resolution: {integrity: sha512-8Mf2cbV7x1cXPUILADGI3wuhfqWvtiLA1iclTDbFRZkgRQS0NqsPZphna9V+HyTEadheuPmjaJMsbzKQFOzLug==}
+    engines: {node: '>=10'}
+    deprecated: No longer maintained. Please contact the author of the relevant native addon; alternatives are available.
+    hasBin: true
+
+  prelude-ls@1.2.1:
+    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
+    engines: {node: '>= 0.8.0'}
+
+  prettier@2.8.8:
+    resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
+    engines: {node: '>=10.13.0'}
+    hasBin: true
+
+  prettier@3.9.4:
+    resolution: {integrity: sha512-yWG/o/4oJfo036EKAfK6ACAoDOfHeRHx4tuxkfBZiauURiaSmYwlpOr5LQqKtIkRD2z1PLteme2WoxEnj4tHTg==}
+    engines: {node: '>=14'}
+    hasBin: true
+
+  prompts@2.4.2:
+    resolution: {integrity: sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q==}
+    engines: {node: '>= 6'}
+
+  property-information@7.2.0:
+    resolution: {integrity: sha512-IAtzIB6sUiWaJYrX9smp3V46pBGbBeLFRGdh25kg1334VcBlD8HzhPeNIWQH9zhGmo2itIe25EHt9dQP7G5hmg==}
+
+  proxy-addr@2.0.7:
+    resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
+    engines: {node: '>= 0.10'}
+
+  pump@3.0.4:
+    resolution: {integrity: sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==}
+
+  punycode@2.3.1:
+    resolution: {integrity: sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==}
+    engines: {node: '>=6'}
+
+  qs@6.15.1:
+    resolution: {integrity: sha512-6YHEFRL9mfgcAvql/XhwTvf5jKcOiiupt2FiJxHkiX1z4j7WL8J/jRHYLluORvc1XxB5rV20KoeK00gVJamspg==}
+    engines: {node: '>=0.6'}
+
+  queue-microtask@1.2.3:
+    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
+
+  railroad-diagrams@1.0.0:
+    resolution: {integrity: sha512-cz93DjNeLY0idrCNOH6PviZGRN9GJhsdm9hpn1YCS879fj4W+x5IFJhhkRZcwVgMmFF7R82UA/7Oh+R8lLZg6A==}
+
+  randexp@0.4.6:
+    resolution: {integrity: sha512-80WNmd9DA0tmZrw9qQa62GPPWfuXJknrmVmLcxvq4uZBdYqb1wYoKTmnlGUchvVWe0XiLupYkBoXVOxz3C8DYQ==}
+    engines: {node: '>=0.12'}
+
+  range-parser@1.2.1:
+    resolution: {integrity: sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==}
+    engines: {node: '>= 0.6'}
+
+  raw-body@3.0.2:
+    resolution: {integrity: sha512-K5zQjDllxWkf7Z5xJdV0/B0WTNqx6vxG70zJE4N0kBs4LovmEYWJzQGxC9bS9RAKu3bgM40lrd5zoLJ12MQ5BA==}
+    engines: {node: '>= 0.10'}
+
+  rc9@3.0.1:
+    resolution: {integrity: sha512-gMDyleLWVE+i6Sgtc0QbbY6pEKqYs97NGi6isHQPqYlLemPoO8dxQ3uGi0f4NiP98c+jMW6cG1Kx9dDwfvqARQ==}
+
+  rc@1.2.8:
+    resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==}
+    hasBin: true
+
+  readable-stream@3.6.2:
+    resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==}
+    engines: {node: '>= 6'}
+
+  readdirp@5.0.0:
+    resolution: {integrity: sha512-9u/XQ1pvrQtYyMpZe7DXKv2p5CNvyVwzUB6uhLAnQwHMSgKMBR62lc7AHljaeteeHXn11XTAaLLUVZYVZyuRBQ==}
+    engines: {node: '>= 20.19.0'}
+
+  recast-x@1.0.5:
+    resolution: {integrity: sha512-CkfWKhQiYsMQYaWUkHdERXUxT2jJLBoa5y7zFv3dUAE7Ly5oU/0hsqrENyEfrCL03pDsQYbnoz17Cbagx/c2OA==}
+    engines: {node: '>= 4'}
+
+  redis-errors@1.2.0:
+    resolution: {integrity: sha512-1qny3OExCf0UvUV/5wpYKf2YwPcOqXzkwKKSmKHiE6ZMQs5heeE/c8eXK+PNllPvmjgAbfnsbpkGZWy8cBpn9w==}
+    engines: {node: '>=4'}
+
+  redis-parser@3.0.0:
+    resolution: {integrity: sha512-DJnGAeenTdpMEH6uAJRK/uiyEIH9WVsUmoLwzudwGJUwZPp80PDBWPHXSAGNPwNvIXAbe7MSUB1zQFugFml66A==}
+    engines: {node: '>=4'}
+
+  regex-recursion@6.0.2:
+    resolution: {integrity: sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==}
+
+  regex-utilities@2.3.0:
+    resolution: {integrity: sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==}
+
+  regex@6.1.0:
+    resolution: {integrity: sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg==}
+
+  reka-ui@2.10.1:
+    resolution: {integrity: sha512-drcOQ4rQtDYAcGCsyQBqQg8QQ+H3B+zDaMJU0h8KPEPMa7g9BHu3zcOi4OB39XJSWizceFoNO0Z9tctSGLOXqg==}
+    peerDependencies:
+      vue: '>= 3.4.0'
+
+  require-from-string@2.0.2:
+    resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
+    engines: {node: '>=0.10.0'}
+
+  reserved-identifiers@1.2.0:
+    resolution: {integrity: sha512-yE7KUfFvaBFzGPs5H3Ops1RevfUEsDc5Iz65rOwWg4lE8HJSYtle77uul3+573457oHvBKuHYDl/xqUkKpEEdw==}
+    engines: {node: '>=18'}
+
+  resolve-pkg-maps@1.0.0:
+    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
+
+  restore-cursor@5.1.0:
+    resolution: {integrity: sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==}
+    engines: {node: '>=18'}
+
+  ret@0.1.15:
+    resolution: {integrity: sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==}
+    engines: {node: '>=0.12'}
+
+  reusify@1.1.0:
+    resolution: {integrity: sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==}
+    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
+
+  rfdc@1.4.1:
+    resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==}
+
+  rolldown@1.0.3:
+    resolution: {integrity: sha512-i00lAJ2ks1BYr7rjNjKC7BcqAS7nVfiT3QX1SI5aY+AFHblCmaUf9OE9dbdzDvW6dJxbi2ZCZiy9v3CcwOiX3g==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+
+  router@2.2.0:
+    resolution: {integrity: sha512-nLTrUKm2UyiL7rlhapu/Zl45FwNgkZGaCpZbIHajDYgwlJCOzLSk+cIPAnsEqV955GjILJnKbdQC1nVPz+gAYQ==}
+    engines: {node: '>= 18'}
+
+  run-applescript@7.1.0:
+    resolution: {integrity: sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q==}
+    engines: {node: '>=18'}
+
+  run-parallel@1.2.0:
+    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
+
+  safe-buffer@5.2.1:
+    resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
+
+  safer-buffer@2.1.2:
+    resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
+
+  sax@1.2.4:
+    resolution: {integrity: sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==}
+
+  semver@6.3.1:
+    resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
+    hasBin: true
+
+  semver@7.8.5:
+    resolution: {integrity: sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==}
+    engines: {node: '>=10'}
+    hasBin: true
+
+  send@1.2.1:
+    resolution: {integrity: sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==}
+    engines: {node: '>= 18'}
+
+  serve-static@2.2.1:
+    resolution: {integrity: sha512-xRXBn0pPqQTVQiC8wyQrKs2MOlX24zQ0POGaj0kultvoOCstBQM5yvOhAVSUwOMjQtTvsPWoNCHfPGwaaQJhTw==}
+    engines: {node: '>= 18'}
+
+  setprototypeof@1.2.0:
+    resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
+
+  shadcn-vue@2.7.4:
+    resolution: {integrity: sha512-+ZxxEbxbYvKerod/vFNdnQ8JEiQWhfZJWH/bKr6MFvFGSSulJS29QjyFrT1VudkOwUhLFtm+6sTT+ZVBxeNQIg==}
+    hasBin: true
+
+  shebang-command@2.0.0:
+    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
+    engines: {node: '>=8'}
+
+  shebang-regex@3.0.0:
+    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
+    engines: {node: '>=8'}
+
+  shiki@4.2.0:
+    resolution: {integrity: sha512-hjNax6o/ylDy9lefQEaSDtzaT3iVNtZ3WmpQnbuQNoG4xvnSKf2kSKbihZVO4JRG1TTMejs7CmNRYlWgAL66pQ==}
+    engines: {node: '>=20'}
+
+  side-channel-list@1.0.1:
+    resolution: {integrity: sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w==}
+    engines: {node: '>= 0.4'}
+
+  side-channel-map@1.0.1:
+    resolution: {integrity: sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==}
+    engines: {node: '>= 0.4'}
+
+  side-channel-weakmap@1.0.2:
+    resolution: {integrity: sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==}
+    engines: {node: '>= 0.4'}
+
+  side-channel@1.1.0:
+    resolution: {integrity: sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==}
+    engines: {node: '>= 0.4'}
+
+  siginfo@2.0.0:
+    resolution: {integrity: sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==}
+
+  signal-exit@3.0.7:
+    resolution: {integrity: sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==}
+
+  signal-exit@4.1.0:
+    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
+    engines: {node: '>=14'}
+
+  simple-concat@1.0.1:
+    resolution: {integrity: sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==}
+
+  simple-get@4.0.1:
+    resolution: {integrity: sha512-brv7p5WgH0jmQJr1ZDDfKDOSeWWg+OVypG99A/5vYGPqJ6pxiaHLy8nxtFjBA7oMa01ebA9gfh1uMCFqOuXxvA==}
+
+  sisteransi@1.0.5:
+    resolution: {integrity: sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg==}
+
+  slice-ansi@4.0.0:
+    resolution: {integrity: sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ==}
+    engines: {node: '>=10'}
+
+  slice-ansi@7.1.2:
+    resolution: {integrity: sha512-iOBWFgUX7caIZiuutICxVgX1SdxwAVFFKwt1EvMYYec/NWO5meOJ6K5uQxhrYBdQJne4KxiqZc+KptFOWFSI9w==}
+    engines: {node: '>=18'}
+
+  slice-ansi@8.0.0:
+    resolution: {integrity: sha512-stxByr12oeeOyY2BlviTNQlYV5xOj47GirPr4yA1hE9JCtxfQN0+tVbkxwCtYDQWhEKWFHsEK48ORg5jrouCAg==}
+    engines: {node: '>=20'}
+
+  source-map-js@1.2.1:
+    resolution: {integrity: sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==}
+    engines: {node: '>=0.10.0'}
+
+  source-map-resolve@0.6.0:
+    resolution: {integrity: sha512-KXBr9d/fO/bWo97NXsPIAW1bFSBOuCnjbNTBMO7N59hsv5i9yzRDfcYwwt0l04+VqnKC+EwzvJZIP/qkuMgR/w==}
+    deprecated: See https://github.com/lydell/source-map-resolve#deprecated
+
+  source-map@0.6.1:
+    resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
+    engines: {node: '>=0.10.0'}
+
+  source-map@0.7.6:
+    resolution: {integrity: sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==}
+    engines: {node: '>= 12'}
+
+  space-separated-tokens@2.0.2:
+    resolution: {integrity: sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==}
+
+  speakingurl@14.0.1:
+    resolution: {integrity: sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==}
+    engines: {node: '>=0.10.0'}
+
+  split2@4.2.0:
+    resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==}
+    engines: {node: '>= 10.x'}
+
+  splitpanes@4.1.2:
+    resolution: {integrity: sha512-frNchoCv7w0nMQEuaDGgMGMU6jv3NhN6bBGQVfCNgwJdVcYaRmi1dwYDjp7SifAoUFdiQjBRB254LJNidzo15Q==}
+    peerDependencies:
+      vue: ^3.2.0
+
+  sql-escaper@1.3.3:
+    resolution: {integrity: sha512-BsTCV265VpTp8tm1wyIm1xqQCS+Q9NHx2Sr+WcnUrgLrQ6yiDIvHYJV5gHxsj1lMBy2zm5twLaZao8Jd+S8JJw==}
+    engines: {bun: '>=1.0.0', deno: '>=2.0.0', node: '>=12.0.0'}
+
+  sql-formatter@15.8.0:
+    resolution: {integrity: sha512-HnjdRHlSsO4Ap2erB5YXAvWggrnk/S4TezUn8zmpq9J/hEKn9+6gGaqiKPyDtI10Xf4zJmHYPREGjMjZmmP1fg==}
+    hasBin: true
+
+  stackback@0.0.2:
+    resolution: {integrity: sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==}
+
+  standard-as-callback@2.1.0:
+    resolution: {integrity: sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A==}
+
+  statuses@2.0.2:
+    resolution: {integrity: sha512-DvEy55V3DB7uknRo+4iOGT5fP1slR8wQohVdknigZPMpMstaKJQWhwiYBACJE3Ul2pTnATihhBYnRhZQHGBiRw==}
+    engines: {node: '>= 0.8'}
+
+  std-env@4.1.0:
+    resolution: {integrity: sha512-Rq7ybcX2RuC55r9oaPVEW7/xu3tj8u4GeBYHBWCychFtzMIr86A7e3PPEBPT37sHStKX3+TiX/Fr/ACmJLVlLQ==}
+
+  stdin-discarder@0.3.2:
+    resolution: {integrity: sha512-eCPu1qRxPVkl5605OTWF8Wz40b4Mf45NY5LQmVPQ599knfs5QhASUm9GbJ5BDMDOXgrnh0wyEdvzmL//YMlw0A==}
+    engines: {node: '>=18'}
+
+  string-argv@0.3.2:
+    resolution: {integrity: sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==}
+    engines: {node: '>=0.6.19'}
+
+  string-width@4.2.3:
+    resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
+    engines: {node: '>=8'}
+
+  string-width@7.2.0:
+    resolution: {integrity: sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==}
+    engines: {node: '>=18'}
+
+  string-width@8.2.1:
+    resolution: {integrity: sha512-IIaP0g3iy9Cyy18w3M9YcaDudujEAVHKt3a3QJg1+sr/oX96TbaGUubG0hJyCjCBThFH+tFpcIyoUHUn1ogaLA==}
+    engines: {node: '>=20'}
+
+  string_decoder@1.3.0:
+    resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
+
+  stringify-entities@4.0.4:
+    resolution: {integrity: sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==}
+
+  stringify-object@6.0.0:
+    resolution: {integrity: sha512-6f94vIED6vmJJfh3lyVsVWxCYSfI5uM+16ntED/Ql37XIyV6kj0mRAAiTeMMc/QLYIaizC3bUprQ8pQnDDrKfA==}
+    engines: {node: '>=20'}
+
+  strip-ansi@6.0.1:
+    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
+    engines: {node: '>=8'}
+
+  strip-ansi@7.2.0:
+    resolution: {integrity: sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==}
+    engines: {node: '>=12'}
+
+  strip-final-newline@2.0.0:
+    resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==}
+    engines: {node: '>=6'}
+
+  strip-json-comments@2.0.1:
+    resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==}
+    engines: {node: '>=0.10.0'}
+
+  style-mod@4.1.3:
+    resolution: {integrity: sha512-i/n8VsZydrugj3Iuzll8+x/00GH2vnYsk1eomD8QiRrSAeW6ItbCQDtfXCeJHd0iwiNagqjQkvpvREEPtW3IoQ==}
+
+  stylus@0.57.0:
+    resolution: {integrity: sha512-yOI6G8WYfr0q8v8rRvE91wbxFU+rJPo760Va4MF6K0I6BZjO4r+xSynkvyPBP9tV1CIEUeRsiidjIs2rzb1CnQ==}
+    hasBin: true
+
+  super-regex@1.1.0:
+    resolution: {integrity: sha512-WHkws2ZflZe41zj6AolvvmaTrWds/VuyeYr9iPVv/oQeaIoVxMKaushfFWpOGDT+GuBrM/sVqF8KUCYQlSSTdQ==}
+    engines: {node: '>=18'}
+
+  superjson@2.2.6:
+    resolution: {integrity: sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA==}
+    engines: {node: '>=16'}
+
+  systeminformation@5.31.11:
+    resolution: {integrity: sha512-I6O7iaUj23AXRgCPDDnvi3xHvdOLp4+1YMbF+X194lJwY1NeWojgHJPhslVKcmTtrLTguRk3QJK+xEdTiI3P0w==}
+    engines: {node: '>=8.0.0'}
+    os: [darwin, linux, win32, freebsd, openbsd, netbsd, sunos, android]
+    hasBin: true
+
+  table@6.9.0:
+    resolution: {integrity: sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A==}
+    engines: {node: '>=10.0.0'}
+
+  tailwind-merge@3.6.0:
+    resolution: {integrity: sha512-uxL7qAVQriqRQPAyK3pj66VqskWqoZ37PW94jwOTwNfq/z9oyu1V+eqrZqtR2+fCiXdYOZe/Modt8GtvqNzu+w==}
+
+  tailwindcss@4.3.0:
+    resolution: {integrity: sha512-y6nxMGB1nMW9R6k96e5gdIFzcfL/gTJRNaqGes1YvkLnPVXzWgbqFF2yLC0T8G774n24cx3Pe8XrKoniCOAH+Q==}
+
+  tapable@2.3.3:
+    resolution: {integrity: sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==}
+    engines: {node: '>=6'}
+
+  tar-fs@2.1.4:
+    resolution: {integrity: sha512-mDAjwmZdh7LTT6pNleZ05Yt65HC3E+NiQzl672vQG38jIrehtJk/J3mNwIg+vShQPcLF/LV7CMnDW6vjj6sfYQ==}
+
+  tar-stream@2.2.0:
+    resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}
+    engines: {node: '>=6'}
+
+  time-span@5.1.0:
+    resolution: {integrity: sha512-75voc/9G4rDIJleOo4jPvN4/YC4GRZrY8yy1uU4lwrB3XEQbWve8zXoO5No4eFrGcTAMYyoY67p8jRQdtA1HbA==}
+    engines: {node: '>=12'}
+
+  tiny-invariant@1.3.3:
+    resolution: {integrity: sha512-+FbBPE1o9QAYvviau/qC5SE3caw21q3xkvWKBtja5vgqOWIHHJ3ioaq1VPfn/Szqctz2bU/oYeKd9/z5BL+PVg==}
+
+  tinybench@2.9.0:
+    resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
+
+  tinyexec@1.1.1:
+    resolution: {integrity: sha512-VKS/ZaQhhkKFMANmAOhhXVoIfBXblQxGX1myCQ2faQrfmobMftXeJPcZGp0gS07ocvGJWDLZGyOZDadDBqYIJg==}
+    engines: {node: '>=18'}
+
+  tinyexec@1.2.4:
+    resolution: {integrity: sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg==}
+    engines: {node: '>=18'}
+
+  tinyglobby@0.2.17:
+    resolution: {integrity: sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==}
+    engines: {node: '>=12.0.0'}
+
+  tinypool@2.1.0:
+    resolution: {integrity: sha512-Pugqs6M0m7Lv1I7FtxN4aoyToKg1C4tu+/381vH35y8oENM/Ai7f7C4StcoK4/+BSw9ebcS8jRiVrORFKCALLw==}
+    engines: {node: ^20.0.0 || >=22.0.0}
+
+  tinyrainbow@3.1.0:
+    resolution: {integrity: sha512-Bf+ILmBgretUrdJxzXM0SgXLZ3XfiaUuOj/IKQHuTXip+05Xn+uyEYdVg0kYDipTBcLrCVyUzAPz7QmArb0mmw==}
+    engines: {node: '>=14.0.0'}
+
+  to-regex-range@5.0.1:
+    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
+    engines: {node: '>=8.0'}
+
+  toidentifier@1.0.1:
+    resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
+    engines: {node: '>=0.6'}
+
+  trim-lines@3.0.1:
+    resolution: {integrity: sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==}
+
+  ts-morph@27.0.2:
+    resolution: {integrity: sha512-fhUhgeljcrdZ+9DZND1De1029PrE+cMkIP7ooqkLRTrRLTqcki2AstsyJm0vRNbTbVCNJ0idGlbBrfqc7/nA8w==}
+
+  tslib@2.3.0:
+    resolution: {integrity: sha512-N82ooyxVNm6h1riLCoyS9e3fuJ3AMG2zIZs2Gd1ATcSFjSA23Q0fzjjZeh0jbJvWVDZ0cJT8yaNNaaXHzueNjg==}
+
+  tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
+
+  tsx@4.21.0:
+    resolution: {integrity: sha512-5C1sg4USs1lfG0GFb2RLXsdpXqBSEhAaA/0kPL01wxzpMqLILNxIxIOKiILz+cdg/pLnOUxFYOR5yhHU666wbw==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  tsx@4.22.4:
+    resolution: {integrity: sha512-X8EX+XV4QR5xCsrgxaED954zTDfY8KqlDtskKEL0cHhyS/P8b4IFOvGDQpsC9Q1XnLq915wEfwwY/zzskCtmhg==}
+    engines: {node: '>=18.0.0'}
+    hasBin: true
+
+  tunnel-agent@0.6.0:
+    resolution: {integrity: sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w==}
+
+  tw-animate-css@1.4.0:
+    resolution: {integrity: sha512-7bziOlRqH0hJx80h/3mbicLW7o8qLsH5+RaLR2t+OHM3D0JlWGODQKQ4cxbK7WlvmUxpcj6Kgu6EKqjrGFe3QQ==}
+
+  type-check@0.4.0:
+    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
+    engines: {node: '>= 0.8.0'}
+
+  type-fest@4.41.0:
+    resolution: {integrity: sha512-TeTSQ6H5YHvpqVwBRcnLDCBnDOHWYu7IvGbHT6N8AOymcr9PJGjc1GTtiWZTYg0NCgYwvnYWEkVChQAr9bjfwA==}
+    engines: {node: '>=16'}
+
+  type-is@2.0.1:
+    resolution: {integrity: sha512-OZs6gsjF4vMp32qrCbiVSkrFmXtG/AZhY3t0iAMrMBiAZyV9oALtXO8hsrHbMXF9x6L3grlFuwW2oAz7cav+Gw==}
+    engines: {node: '>= 0.6'}
+
+  typescript@5.9.3:
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  typescript@6.0.3:
+    resolution: {integrity: sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  ufo@1.6.4:
+    resolution: {integrity: sha512-JFNbkD1Svwe0KvGi8GOeLcP4kAWQ609twvCdcHxq1oSL8svv39ZuSvajcD8B+5D0eL4+s1Is2D/O6KN3qcTeRA==}
+
+  undici-types@6.21.0:
+    resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}
+
+  undici-types@7.24.6:
+    resolution: {integrity: sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==}
+
+  undici@7.28.0:
+    resolution: {integrity: sha512-cRZYrTDwWznlnRiPjggAGxZXanty6M8RV1ff8Wm4LWXBp7/IG8v5DnOm74DtUBp9OONpK75YlPnIjQqX0dBDtA==}
+    engines: {node: '>=20.18.1'}
+
+  unist-util-is@6.0.1:
+    resolution: {integrity: sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==}
+
+  unist-util-position@5.0.0:
+    resolution: {integrity: sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==}
+
+  unist-util-stringify-position@4.0.0:
+    resolution: {integrity: sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==}
+
+  unist-util-visit-parents@6.0.2:
+    resolution: {integrity: sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==}
+
+  unist-util-visit@5.1.0:
+    resolution: {integrity: sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==}
+
+  universalify@2.0.1:
+    resolution: {integrity: sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==}
+    engines: {node: '>= 10.0.0'}
+
+  unpipe@1.0.0:
+    resolution: {integrity: sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==}
+    engines: {node: '>= 0.8'}
+
+  update-browserslist-db@1.2.3:
+    resolution: {integrity: sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==}
+    hasBin: true
+    peerDependencies:
+      browserslist: '>= 4.21.0'
+
+  uri-js@4.4.1:
+    resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
+
+  util-deprecate@1.0.2:
+    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
+
+  validate-npm-package-name@5.0.1:
+    resolution: {integrity: sha512-OljLrQ9SQdOUqTaQxqL5dEfZWrXExyyWsozYlAWFawPVNuD83igl7uJD2RTkNMbniIYgt8l81eCJGIdQF7avLQ==}
+    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
+
+  vary@1.1.2:
+    resolution: {integrity: sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==}
+    engines: {node: '>= 0.8'}
+
+  vfile-message@4.0.3:
+    resolution: {integrity: sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==}
+
+  vfile@6.0.3:
+    resolution: {integrity: sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==}
+
+  vite@8.0.16:
+    resolution: {integrity: sha512-h9bXPmJichP5fLmVQo3PyaGSDE2n3aPuomeAlVRm0JLmt4rY6zmPKd59HYI4LNW8oTK7tlTsuC7l/m7awx9Jcw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^20.19.0 || >=22.12.0
+      '@vitejs/devtools': ^0.1.18
+      esbuild: ^0.27.0 || ^0.28.0
+      jiti: '>=1.21.0'
+      less: ^4.0.0
+      sass: ^1.70.0
+      sass-embedded: ^1.70.0
+      stylus: '>=0.54.8'
+      sugarss: ^5.0.0
+      terser: ^5.16.0
+      tsx: ^4.8.1
+      yaml: ^2.4.2
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      '@vitejs/devtools':
+        optional: true
+      esbuild:
+        optional: true
+      jiti:
+        optional: true
+      less:
+        optional: true
+      sass:
+        optional: true
+      sass-embedded:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+      tsx:
+        optional: true
+      yaml:
+        optional: true
+
+  vitest@4.1.8:
+    resolution: {integrity: sha512-flY6ScbCIt9HThs+C5HS7jvGOB560DJtk/Z15IQROTA6zEy49Nh8T/dofWTQL+n3vswqn87sbJNiuqw1SDp5Ig==}
+    engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
+    hasBin: true
+    peerDependencies:
+      '@edge-runtime/vm': '*'
+      '@opentelemetry/api': ^1.9.0
+      '@types/node': ^20.0.0 || ^22.0.0 || >=24.0.0
+      '@vitest/browser-playwright': 4.1.8
+      '@vitest/browser-preview': 4.1.8
+      '@vitest/browser-webdriverio': 4.1.8
+      '@vitest/coverage-istanbul': 4.1.8
+      '@vitest/coverage-v8': 4.1.8
+      '@vitest/ui': 4.1.8
+      happy-dom: '*'
+      jsdom: '*'
+      vite: ^6.0.0 || ^7.0.0 || ^8.0.0
+    peerDependenciesMeta:
+      '@edge-runtime/vm':
+        optional: true
+      '@opentelemetry/api':
+        optional: true
+      '@types/node':
+        optional: true
+      '@vitest/browser-playwright':
+        optional: true
+      '@vitest/browser-preview':
+        optional: true
+      '@vitest/browser-webdriverio':
+        optional: true
+      '@vitest/coverage-istanbul':
+        optional: true
+      '@vitest/coverage-v8':
+        optional: true
+      '@vitest/ui':
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+
+  vscode-uri@3.1.0:
+    resolution: {integrity: sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==}
+
+  vue-demi@0.14.10:
+    resolution: {integrity: sha512-nMZBOwuzabUO0nLgIcc6rycZEebF6eeUfaiQx9+WSk8e29IbLvPU9feI6tqW4kTo3hvoYAJkMh8n8D0fuISphg==}
+    engines: {node: '>=12'}
+    hasBin: true
+    peerDependencies:
+      '@vue/composition-api': ^1.0.0-rc.1
+      vue: ^3.0.0-0 || ^2.6.0
+    peerDependenciesMeta:
+      '@vue/composition-api':
+        optional: true
+
+  vue-echarts@8.0.1:
+    resolution: {integrity: sha512-23rJTFLu1OUEGRWjJGmdGt8fP+8+ja1gVgzMYPIPaHWpXegcO1viIAaeu2H4QHESlVeHzUAHIxKXGrwjsyXAaA==}
+    peerDependencies:
+      echarts: ^6.0.0
+      vue: ^3.3.0
+
+  vue-eslint-parser@10.4.1:
+    resolution: {integrity: sha512-Gk6gRDj0n/fkRa3C3l0bBheoBckUq/Rs0F/TvMWIS6nzzx67amAViMe9CkNgsP2tXyQONvGiHQESHwFtZ3aYDA==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+    peerDependencies:
+      eslint: ^8.57.0 || ^9.0.0 || ^10.0.0
+
+  vue-i18n@11.4.4:
+    resolution: {integrity: sha512-gIbXVSFQV4jcSJxfwdZ5zSZmZ+12CnX0K3vBkRSd6Zn+HSzCp+QwUgPwpD/uN0oKNKI9RzlUXPKVedEuMgNG0A==}
+    engines: {node: '>= 22'}
+    peerDependencies:
+      vue: ^3.0.0
+
+  vue-metamorph@3.3.4:
+    resolution: {integrity: sha512-WZ1xzHrmYh9UiZ7OC9eG1ASzgSybEB10jhop+k5KzMY9I1JmRKdreqUYzbV3hOnOMvLhyDn7y6f62mLE2jHFSg==}
+    hasBin: true
+
+  vue-tsc@3.3.3:
+    resolution: {integrity: sha512-SWUEG7YRUeDJHT7Xsuhf02elYX2gxPzzAII7OxDAh4KNOr4QHQ0Lls0YfnaO5GNd560CwVa2HTfdqmA5MqvRqQ==}
+    hasBin: true
+    peerDependencies:
+      typescript: '>=5.0.0'
+
+  vue-virtual-scroller@3.0.4:
+    resolution: {integrity: sha512-3qh3c9VUVysuXynaa4fVZ3ncx3VgD7EPRiQcj+jUVZl5u/TTkD3c27XvSEu3JGJfsJt/vVTVziZ3djiiHtW4cQ==}
+    peerDependencies:
+      vue: ^3.3.0
+
+  vue@2.7.16:
+    resolution: {integrity: sha512-4gCtFXaAA3zYZdTp5s4Hl2sozuySsgz4jy1EnpBHNfpMa9dK1ZCG7viqBPCwXtmgc8nHqUsAu3G4gtmXkkY3Sw==}
+    deprecated: Vue 2 has reached EOL and is no longer actively maintained. See https://v2.vuejs.org/eol/ for more details.
+
+  vue@3.5.35:
+    resolution: {integrity: sha512-cx89fnr+0kVGHiNFG6y6s0bdjypJRFNZn6x3WPstNdQR1bi1mbB7h4v5IBGTsPJU3nK1+0Iqj3Zf+hZWMieR4Q==}
+    peerDependencies:
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+
+  w3c-keyname@2.2.8:
+    resolution: {integrity: sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==}
+
+  web-worker@1.5.0:
+    resolution: {integrity: sha512-RiMReJrTAiA+mBjGONMnjVDP2u3p9R1vkcGz6gDIrOMT3oGuYwX2WRMYI9ipkphSuE5XKEhydbhNEJh4NY9mlw==}
+
+  which@2.0.2:
+    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
+    engines: {node: '>= 8'}
+    hasBin: true
+
+  which@4.0.0:
+    resolution: {integrity: sha512-GlaYyEb07DPxYCKhKzplCWBJtvxZcZMrL+4UkrTSJHHPyZU4mYYTv3qaOe77H7EODLSSopAUFAc6W8U4yqvscg==}
+    engines: {node: ^16.13.0 || >=18.0.0}
+    hasBin: true
+
+  why-is-node-running@2.3.0:
+    resolution: {integrity: sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==}
+    engines: {node: '>=8'}
+    hasBin: true
+
+  word-wrap@1.2.5:
+    resolution: {integrity: sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==}
+    engines: {node: '>=0.10.0'}
+
+  wrap-ansi@9.0.2:
+    resolution: {integrity: sha512-42AtmgqjV+X1VpdOfyTGOYRi0/zsoLqtXQckTmqTeybT+BDIbM/Guxo7x3pE2vtpr1ok6xRqM9OpBe+Jyoqyww==}
+    engines: {node: '>=18'}
+
+  wrappy@1.0.2:
+    resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
+
+  wsl-utils@0.1.0:
+    resolution: {integrity: sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw==}
+    engines: {node: '>=18'}
+
+  xtend@4.0.2:
+    resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==}
+    engines: {node: '>=0.4'}
+
+  yallist@3.1.1:
+    resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
+
+  yaml@2.8.4:
+    resolution: {integrity: sha512-ml/JPOj9fOQK8RNnWojA67GbZ0ApXAUlN2UQclwv2eVgTgn7O9gg9o7paZWKMp4g0H3nTLtS9LVzhkpOFIKzog==}
+    engines: {node: '>= 14.6'}
+    hasBin: true
+
+  yocto-queue@0.1.0:
+    resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
+    engines: {node: '>=10'}
+
+  yocto-spinner@1.2.0:
+    resolution: {integrity: sha512-Yw0hUB6UA3o4YUgKy3oSe9a4cxoaZ9sBfYDw+JSxo6Id0KoJGoxzPA24qqUXYKBWABs/zDSGTz9kww7t3F0XGw==}
+    engines: {node: '>=18.19'}
+
+  yoctocolors@2.1.2:
+    resolution: {integrity: sha512-CzhO+pFNo8ajLM2d2IW/R93ipy99LWjtwblvC1RsoSUMZgyLbYFr221TnSNT7GjGdYui6P459mw9JH/g/zW2ug==}
+    engines: {node: '>=18'}
+
+  zod-to-json-schema@3.25.2:
+    resolution: {integrity: sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==}
+    peerDependencies:
+      zod: ^3.25.28 || ^4
+
+  zod@3.25.76:
+    resolution: {integrity: sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==}
+
+  zrender@6.1.0:
+    resolution: {integrity: sha512-oEGMDB6pOP2S6OwRR4PdVv610zrjnA3Bh+JnSG12fYJlBKjtNAoEb5fSUoCOOINlH96I2fU38/A2UpRKs67xYQ==}
+
+  zwitch@2.0.4:
+    resolution: {integrity: sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==}
+
+snapshots:
+
+  '@babel/code-frame@7.29.7':
+    dependencies:
+      '@babel/helper-validator-identifier': 7.29.7
+      js-tokens: 4.0.0
+      picocolors: 1.1.1
+
+  '@babel/compat-data@7.29.7': {}
+
+  '@babel/core@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-compilation-targets': 7.29.7
+      '@babel/helper-module-transforms': 7.29.7(@babel/core@7.29.7)
+      '@babel/helpers': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+      '@jridgewell/remapping': 2.3.5
+      convert-source-map: 2.0.0
+      debug: 4.4.3
+      gensync: 1.0.0-beta.2
+      json5: 2.2.3
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/generator@7.29.7':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+      jsesc: 3.1.0
+
+  '@babel/helper-annotate-as-pure@7.29.7':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@babel/helper-compilation-targets@7.29.7':
+    dependencies:
+      '@babel/compat-data': 7.29.7
+      '@babel/helper-validator-option': 7.29.7
+      browserslist: 4.28.4
+      lru-cache: 5.1.1
+      semver: 6.3.1
+
+  '@babel/helper-create-class-features-plugin@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-annotate-as-pure': 7.29.7
+      '@babel/helper-member-expression-to-functions': 7.29.7
+      '@babel/helper-optimise-call-expression': 7.29.7
+      '@babel/helper-replace-supers': 7.29.7(@babel/core@7.29.7)
+      '@babel/helper-skip-transparent-expression-wrappers': 7.29.7
+      '@babel/traverse': 7.29.7
+      semver: 6.3.1
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-globals@7.29.7': {}
+
+  '@babel/helper-member-expression-to-functions@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-module-imports@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-module-transforms@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-module-imports': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
+      '@babel/traverse': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-optimise-call-expression@7.29.7':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@babel/helper-plugin-utils@7.29.7': {}
+
+  '@babel/helper-replace-supers@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-member-expression-to-functions': 7.29.7
+      '@babel/helper-optimise-call-expression': 7.29.7
+      '@babel/traverse': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-skip-transparent-expression-wrappers@7.29.7':
+    dependencies:
+      '@babel/traverse': 7.29.7
+      '@babel/types': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/helper-string-parser@7.29.7': {}
+
+  '@babel/helper-validator-identifier@7.29.7': {}
+
+  '@babel/helper-validator-option@7.29.7': {}
+
+  '@babel/helpers@7.29.7':
+    dependencies:
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+
+  '@babel/parser@7.29.7':
+    dependencies:
+      '@babel/types': 7.29.7
+
+  '@babel/parser@8.0.0-alpha.12': {}
+
+  '@babel/plugin-syntax-jsx@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
+
+  '@babel/plugin-syntax-typescript@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
+
+  '@babel/plugin-transform-modules-commonjs@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-module-transforms': 7.29.7(@babel/core@7.29.7)
+      '@babel/helper-plugin-utils': 7.29.7
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/plugin-transform-typescript@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-annotate-as-pure': 7.29.7
+      '@babel/helper-create-class-features-plugin': 7.29.7(@babel/core@7.29.7)
+      '@babel/helper-plugin-utils': 7.29.7
+      '@babel/helper-skip-transparent-expression-wrappers': 7.29.7
+      '@babel/plugin-syntax-typescript': 7.29.7(@babel/core@7.29.7)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/preset-typescript@7.29.7(@babel/core@7.29.7)':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/helper-plugin-utils': 7.29.7
+      '@babel/helper-validator-option': 7.29.7
+      '@babel/plugin-syntax-jsx': 7.29.7(@babel/core@7.29.7)
+      '@babel/plugin-transform-modules-commonjs': 7.29.7(@babel/core@7.29.7)
+      '@babel/plugin-transform-typescript': 7.29.7(@babel/core@7.29.7)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/runtime@7.29.7': {}
+
+  '@babel/template@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/types': 7.29.7
+
+  '@babel/traverse@7.29.7':
+    dependencies:
+      '@babel/code-frame': 7.29.7
+      '@babel/generator': 7.29.7
+      '@babel/helper-globals': 7.29.7
+      '@babel/parser': 7.29.7
+      '@babel/template': 7.29.7
+      '@babel/types': 7.29.7
+      debug: 4.4.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@babel/types@7.29.7':
+    dependencies:
+      '@babel/helper-string-parser': 7.29.7
+      '@babel/helper-validator-identifier': 7.29.7
+
+  '@codemirror/autocomplete@6.20.2':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+      '@lezer/common': 1.5.2
+
+  '@codemirror/commands@6.10.3':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+      '@lezer/common': 1.5.2
+
+  '@codemirror/lang-css@6.3.1':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.2
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@lezer/common': 1.5.2
+      '@lezer/css': 1.3.3
+
+  '@codemirror/lang-html@6.4.11':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.2
+      '@codemirror/lang-css': 6.3.1
+      '@codemirror/lang-javascript': 6.2.5
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+      '@lezer/common': 1.5.2
+      '@lezer/css': 1.3.3
+      '@lezer/html': 1.3.13
+
+  '@codemirror/lang-javascript@6.2.5':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.2
+      '@codemirror/language': 6.12.3
+      '@codemirror/lint': 6.9.5
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+      '@lezer/common': 1.5.2
+      '@lezer/javascript': 1.5.4
+
+  '@codemirror/lang-json@6.0.2':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@lezer/json': 1.0.3
+
+  '@codemirror/lang-sql@6.10.0':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.2
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@codemirror/lang-xml@6.1.0':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.2
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+      '@lezer/common': 1.5.2
+      '@lezer/xml': 1.0.6
+
+  '@codemirror/lang-yaml@6.1.3':
+    dependencies:
+      '@codemirror/autocomplete': 6.20.2
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+      '@lezer/yaml': 1.0.4
+
+  '@codemirror/language@6.12.3':
+    dependencies:
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+      style-mod: 4.1.3
+
+  '@codemirror/legacy-modes@6.5.3':
+    dependencies:
+      '@codemirror/language': 6.12.3
+
+  '@codemirror/lint@6.9.5':
+    dependencies:
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+      crelt: 1.0.6
+
+  '@codemirror/search@6.7.0':
+    dependencies:
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+      crelt: 1.0.6
+
+  '@codemirror/state@6.6.0':
+    dependencies:
+      '@marijn/find-cluster-break': 1.0.2
+
+  '@codemirror/theme-one-dark@6.1.3':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+      '@lezer/highlight': 1.2.3
+
+  '@codemirror/view@6.43.0':
+    dependencies:
+      '@codemirror/state': 6.6.0
+      crelt: 1.0.6
+      style-mod: 4.1.3
+      w3c-keyname: 2.2.8
+
+  '@dotenvx/dotenvx@1.75.1':
+    dependencies:
+      '@dotenvx/primitives': 0.8.0
+      commander: 11.1.0
+      conf: 10.2.0
+      dotenv: 17.4.2
+      enquirer: 2.4.1
+      env-paths: 2.2.1
+      execa: 5.1.1
+      fdir: 6.5.0(picomatch@4.0.4)
+      ignore: 5.3.2
+      object-treeify: 1.1.33
+      open: 8.4.2
+      picomatch: 4.0.4
+      systeminformation: 5.31.11
+      undici: 7.28.0
+      which: 4.0.0
+      yocto-spinner: 1.2.0
+
+  '@dotenvx/primitives@0.8.0': {}
+
+  '@emnapi/core@1.10.0':
+    dependencies:
+      '@emnapi/wasi-threads': 1.2.1
+      tslib: 2.8.1
+    optional: true
+
+  '@emnapi/runtime@1.10.0':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@emnapi/wasi-threads@1.2.1':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@esbuild/aix-ppc64@0.27.7':
+    optional: true
+
+  '@esbuild/aix-ppc64@0.28.0':
+    optional: true
+
+  '@esbuild/android-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/android-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/android-arm@0.27.7':
+    optional: true
+
+  '@esbuild/android-arm@0.28.0':
+    optional: true
+
+  '@esbuild/android-x64@0.27.7':
+    optional: true
+
+  '@esbuild/android-x64@0.28.0':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/darwin-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/darwin-x64@0.27.7':
+    optional: true
+
+  '@esbuild/darwin-x64@0.28.0':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/freebsd-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.27.7':
+    optional: true
+
+  '@esbuild/freebsd-x64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-arm@0.27.7':
+    optional: true
+
+  '@esbuild/linux-arm@0.28.0':
+    optional: true
+
+  '@esbuild/linux-ia32@0.27.7':
+    optional: true
+
+  '@esbuild/linux-ia32@0.28.0':
+    optional: true
+
+  '@esbuild/linux-loong64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-loong64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.27.7':
+    optional: true
+
+  '@esbuild/linux-mips64el@0.28.0':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-ppc64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-riscv64@0.28.0':
+    optional: true
+
+  '@esbuild/linux-s390x@0.27.7':
+    optional: true
+
+  '@esbuild/linux-s390x@0.28.0':
+    optional: true
+
+  '@esbuild/linux-x64@0.27.7':
+    optional: true
+
+  '@esbuild/linux-x64@0.28.0':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/netbsd-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.27.7':
+    optional: true
+
+  '@esbuild/netbsd-x64@0.28.0':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/openbsd-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.27.7':
+    optional: true
+
+  '@esbuild/openbsd-x64@0.28.0':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/openharmony-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/sunos-x64@0.27.7':
+    optional: true
+
+  '@esbuild/sunos-x64@0.28.0':
+    optional: true
+
+  '@esbuild/win32-arm64@0.27.7':
+    optional: true
+
+  '@esbuild/win32-arm64@0.28.0':
+    optional: true
+
+  '@esbuild/win32-ia32@0.27.7':
+    optional: true
+
+  '@esbuild/win32-ia32@0.28.0':
+    optional: true
+
+  '@esbuild/win32-x64@0.27.7':
+    optional: true
+
+  '@esbuild/win32-x64@0.28.0':
+    optional: true
+
+  '@eslint-community/eslint-utils@4.9.1(eslint@10.2.1(jiti@2.7.0))':
+    dependencies:
+      eslint: 10.2.1(jiti@2.7.0)
+      eslint-visitor-keys: 3.4.3
+
+  '@eslint-community/regexpp@4.12.2': {}
+
+  '@eslint/config-array@0.23.5':
+    dependencies:
+      '@eslint/object-schema': 3.0.5
+      debug: 4.4.3
+      minimatch: 10.2.5
+    transitivePeerDependencies:
+      - supports-color
+
+  '@eslint/config-helpers@0.5.5':
+    dependencies:
+      '@eslint/core': 1.2.1
+
+  '@eslint/core@1.2.1':
+    dependencies:
+      '@types/json-schema': 7.0.15
+
+  '@eslint/object-schema@3.0.5': {}
+
+  '@eslint/plugin-kit@0.7.2':
+    dependencies:
+      '@eslint/core': 1.2.1
+      levn: 0.4.1
+
+  '@floating-ui/core@1.7.5':
+    dependencies:
+      '@floating-ui/utils': 0.2.11
+
+  '@floating-ui/dom@1.7.6':
+    dependencies:
+      '@floating-ui/core': 1.7.5
+      '@floating-ui/utils': 0.2.11
+
+  '@floating-ui/utils@0.2.11': {}
+
+  '@floating-ui/vue@1.1.11(vue@3.5.35(typescript@6.0.3))':
+    dependencies:
+      '@floating-ui/dom': 1.7.6
+      '@floating-ui/utils': 0.2.11
+      vue-demi: 0.14.10(vue@3.5.35(typescript@6.0.3))
+    transitivePeerDependencies:
+      - '@vue/composition-api'
+      - vue
+
+  '@hono/node-server@1.19.14(hono@4.12.15)':
+    dependencies:
+      hono: 4.12.15
+
+  '@humanfs/core@0.19.2':
+    dependencies:
+      '@humanfs/types': 0.15.0
+
+  '@humanfs/node@0.16.8':
+    dependencies:
+      '@humanfs/core': 0.19.2
+      '@humanfs/types': 0.15.0
+      '@humanwhocodes/retry': 0.4.3
+
+  '@humanfs/types@0.15.0': {}
+
+  '@humanwhocodes/module-importer@1.0.1': {}
+
+  '@humanwhocodes/retry@0.4.3': {}
+
+  '@internationalized/date@3.12.2':
+    dependencies:
+      '@swc/helpers': 0.5.23
+
+  '@internationalized/number@3.6.7':
+    dependencies:
+      '@swc/helpers': 0.5.23
+
+  '@intlify/core-base@11.4.4':
+    dependencies:
+      '@intlify/devtools-types': 11.4.4
+      '@intlify/message-compiler': 11.4.4
+      '@intlify/shared': 11.4.4
+
+  '@intlify/devtools-types@11.4.4':
+    dependencies:
+      '@intlify/core-base': 11.4.4
+      '@intlify/shared': 11.4.4
+
+  '@intlify/message-compiler@11.4.4':
+    dependencies:
+      '@intlify/shared': 11.4.4
+      source-map-js: 1.2.1
+
+  '@intlify/shared@11.4.4': {}
+
+  '@ioredis/commands@1.10.0': {}
+
+  '@isaacs/cliui@9.0.0': {}
+
+  '@jridgewell/gen-mapping@0.3.13':
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/remapping@2.3.5':
+    dependencies:
+      '@jridgewell/gen-mapping': 0.3.13
+      '@jridgewell/trace-mapping': 0.3.31
+
+  '@jridgewell/resolve-uri@3.1.2': {}
+
+  '@jridgewell/sourcemap-codec@1.5.5': {}
+
+  '@jridgewell/trace-mapping@0.3.31':
+    dependencies:
+      '@jridgewell/resolve-uri': 3.1.2
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  '@lezer/common@1.5.2': {}
+
+  '@lezer/css@1.3.3':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/highlight@1.2.3':
+    dependencies:
+      '@lezer/common': 1.5.2
+
+  '@lezer/html@1.3.13':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/javascript@1.5.4':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/json@1.0.3':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/lr@1.4.10':
+    dependencies:
+      '@lezer/common': 1.5.2
+
+  '@lezer/xml@1.0.6':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lezer/yaml@1.0.4':
+    dependencies:
+      '@lezer/common': 1.5.2
+      '@lezer/highlight': 1.2.3
+      '@lezer/lr': 1.4.10
+
+  '@lucide/vue@1.17.0(vue@3.5.35(typescript@6.0.3))':
+    dependencies:
+      vue: 3.5.35(typescript@6.0.3)
+
+  '@marijn/find-cluster-break@1.0.2': {}
+
+  '@modelcontextprotocol/sdk@1.29.0(zod@3.25.76)':
+    dependencies:
+      '@hono/node-server': 1.19.14(hono@4.12.15)
+      ajv: 8.20.0
+      ajv-formats: 3.0.1(ajv@8.20.0)
+      content-type: 1.0.5
+      cors: 2.8.6
+      cross-spawn: 7.0.6
+      eventsource: 3.0.7
+      eventsource-parser: 3.0.8
+      express: 5.2.1
+      express-rate-limit: 8.4.1(express@5.2.1)
+      hono: 4.12.15
+      jose: 6.2.3
+      json-schema-typed: 8.0.2
+      pkce-challenge: 5.0.1
+      raw-body: 3.0.2
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.2(zod@3.25.76)
+    transitivePeerDependencies:
+      - supports-color
+
+  '@msgpack/msgpack@3.1.3': {}
+
+  '@napi-rs/wasm-runtime@1.1.4(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)':
+    dependencies:
+      '@emnapi/core': 1.10.0
+      '@emnapi/runtime': 1.10.0
+      '@tybys/wasm-util': 0.10.2
+    optional: true
+
+  '@nodelib/fs.scandir@2.1.5':
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      run-parallel: 1.2.0
+
+  '@nodelib/fs.stat@2.0.5': {}
+
+  '@nodelib/fs.walk@1.2.8':
+    dependencies:
+      '@nodelib/fs.scandir': 2.1.5
+      fastq: 1.20.1
+
+  '@oxc-project/types@0.133.0': {}
+
+  '@oxfmt/binding-android-arm-eabi@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-android-arm64@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-darwin-arm64@0.53.0': {}
+
+  '@oxfmt/binding-darwin-x64@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-freebsd-x64@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-linux-arm-gnueabihf@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-linux-arm-musleabihf@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-linux-arm64-gnu@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-linux-arm64-musl@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-linux-ppc64-gnu@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-linux-riscv64-gnu@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-linux-riscv64-musl@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-linux-s390x-gnu@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-linux-x64-gnu@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-linux-x64-musl@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-openharmony-arm64@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-win32-arm64-msvc@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-win32-ia32-msvc@0.53.0':
+    optional: true
+
+  '@oxfmt/binding-win32-x64-msvc@0.53.0':
+    optional: true
+
+  '@oxlint/binding-android-arm-eabi@1.68.0':
+    optional: true
+
+  '@oxlint/binding-android-arm64@1.68.0':
+    optional: true
+
+  '@oxlint/binding-darwin-arm64@1.68.0': {}
+
+  '@oxlint/binding-darwin-x64@1.68.0':
+    optional: true
+
+  '@oxlint/binding-freebsd-x64@1.68.0':
+    optional: true
+
+  '@oxlint/binding-linux-arm-gnueabihf@1.68.0':
+    optional: true
+
+  '@oxlint/binding-linux-arm-musleabihf@1.68.0':
+    optional: true
+
+  '@oxlint/binding-linux-arm64-gnu@1.68.0':
+    optional: true
+
+  '@oxlint/binding-linux-arm64-musl@1.68.0':
+    optional: true
+
+  '@oxlint/binding-linux-ppc64-gnu@1.68.0':
+    optional: true
+
+  '@oxlint/binding-linux-riscv64-gnu@1.68.0':
+    optional: true
+
+  '@oxlint/binding-linux-riscv64-musl@1.68.0':
+    optional: true
+
+  '@oxlint/binding-linux-s390x-gnu@1.68.0':
+    optional: true
+
+  '@oxlint/binding-linux-x64-gnu@1.68.0':
+    optional: true
+
+  '@oxlint/binding-linux-x64-musl@1.68.0':
+    optional: true
+
+  '@oxlint/binding-openharmony-arm64@1.68.0':
+    optional: true
+
+  '@oxlint/binding-win32-arm64-msvc@1.68.0':
+    optional: true
+
+  '@oxlint/binding-win32-ia32-msvc@1.68.0':
+    optional: true
+
+  '@oxlint/binding-win32-x64-msvc@1.68.0':
+    optional: true
+
+  '@replit/codemirror-vim@6.3.0(@codemirror/commands@6.10.3)(@codemirror/language@6.12.3)(@codemirror/search@6.7.0)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)':
+    dependencies:
+      '@codemirror/commands': 6.10.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/search': 6.7.0
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+
+  '@rolldown/binding-android-arm64@1.0.3':
+    optional: true
+
+  '@rolldown/binding-darwin-arm64@1.0.3':
+    optional: true
+
+  '@rolldown/binding-darwin-x64@1.0.3':
+    optional: true
+
+  '@rolldown/binding-freebsd-x64@1.0.3':
+    optional: true
+
+  '@rolldown/binding-linux-arm-gnueabihf@1.0.3':
+    optional: true
+
+  '@rolldown/binding-linux-arm64-gnu@1.0.3':
+    optional: true
+
+  '@rolldown/binding-linux-arm64-musl@1.0.3':
+    optional: true
+
+  '@rolldown/binding-linux-ppc64-gnu@1.0.3':
+    optional: true
+
+  '@rolldown/binding-linux-s390x-gnu@1.0.3':
+    optional: true
+
+  '@rolldown/binding-linux-x64-gnu@1.0.3':
+    optional: true
+
+  '@rolldown/binding-linux-x64-musl@1.0.3':
+    optional: true
+
+  '@rolldown/binding-openharmony-arm64@1.0.3':
+    optional: true
+
+  '@rolldown/binding-wasm32-wasi@1.0.3':
+    dependencies:
+      '@emnapi/core': 1.10.0
+      '@emnapi/runtime': 1.10.0
+      '@napi-rs/wasm-runtime': 1.1.4(@emnapi/core@1.10.0)(@emnapi/runtime@1.10.0)
+    optional: true
+
+  '@rolldown/binding-win32-arm64-msvc@1.0.3':
+    optional: true
+
+  '@rolldown/binding-win32-x64-msvc@1.0.3':
+    optional: true
+
+  '@rolldown/pluginutils@1.0.1': {}
+
+  '@shikijs/core@4.2.0':
+    dependencies:
+      '@shikijs/primitive': 4.2.0
+      '@shikijs/types': 4.2.0
+      '@shikijs/vscode-textmate': 10.0.2
+      '@types/hast': 3.0.4
+      hast-util-to-html: 9.0.5
+
+  '@shikijs/engine-javascript@4.2.0':
+    dependencies:
+      '@shikijs/types': 4.2.0
+      '@shikijs/vscode-textmate': 10.0.2
+      oniguruma-to-es: 4.3.6
+
+  '@shikijs/engine-oniguruma@4.2.0':
+    dependencies:
+      '@shikijs/types': 4.2.0
+      '@shikijs/vscode-textmate': 10.0.2
+
+  '@shikijs/langs@4.2.0':
+    dependencies:
+      '@shikijs/types': 4.2.0
+
+  '@shikijs/primitive@4.2.0':
+    dependencies:
+      '@shikijs/types': 4.2.0
+      '@shikijs/vscode-textmate': 10.0.2
+      '@types/hast': 3.0.4
+
+  '@shikijs/themes@4.2.0':
+    dependencies:
+      '@shikijs/types': 4.2.0
+
+  '@shikijs/types@4.2.0':
+    dependencies:
+      '@shikijs/vscode-textmate': 10.0.2
+      '@types/hast': 3.0.4
+
+  '@shikijs/vscode-textmate@10.0.2': {}
+
+  '@standard-schema/spec@1.1.0': {}
+
+  '@swc/helpers@0.5.23':
+    dependencies:
+      tslib: 2.8.1
+
+  '@tailwindcss/node@4.3.0':
+    dependencies:
+      '@jridgewell/remapping': 2.3.5
+      enhanced-resolve: 5.22.1
+      jiti: 2.7.0
+      lightningcss: 1.32.0
+      magic-string: 0.30.21
+      source-map-js: 1.2.1
+      tailwindcss: 4.3.0
+
+  '@tailwindcss/oxide-android-arm64@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-darwin-arm64@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-darwin-x64@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-freebsd-x64@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm-gnueabihf@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm64-gnu@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-linux-arm64-musl@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-linux-x64-gnu@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-linux-x64-musl@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-wasm32-wasi@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-win32-arm64-msvc@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide-win32-x64-msvc@4.3.0':
+    optional: true
+
+  '@tailwindcss/oxide@4.3.0':
+    optionalDependencies:
+      '@tailwindcss/oxide-android-arm64': 4.3.0
+      '@tailwindcss/oxide-darwin-arm64': 4.3.0
+      '@tailwindcss/oxide-darwin-x64': 4.3.0
+      '@tailwindcss/oxide-freebsd-x64': 4.3.0
+      '@tailwindcss/oxide-linux-arm-gnueabihf': 4.3.0
+      '@tailwindcss/oxide-linux-arm64-gnu': 4.3.0
+      '@tailwindcss/oxide-linux-arm64-musl': 4.3.0
+      '@tailwindcss/oxide-linux-x64-gnu': 4.3.0
+      '@tailwindcss/oxide-linux-x64-musl': 4.3.0
+      '@tailwindcss/oxide-wasm32-wasi': 4.3.0
+      '@tailwindcss/oxide-win32-arm64-msvc': 4.3.0
+      '@tailwindcss/oxide-win32-x64-msvc': 4.3.0
+
+  '@tailwindcss/vite@4.3.0(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4))':
+    dependencies:
+      '@tailwindcss/node': 4.3.0
+      '@tailwindcss/oxide': 4.3.0
+      tailwindcss: 4.3.0
+      vite: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4)
+
+  '@tanstack/virtual-core@3.17.3': {}
+
+  '@tanstack/vue-virtual@3.13.31(vue@3.5.35(typescript@6.0.3))':
+    dependencies:
+      '@tanstack/virtual-core': 3.17.3
+      vue: 3.5.35(typescript@6.0.3)
+
+  '@tauri-apps/api@2.11.0': {}
+
+  '@tauri-apps/cli-darwin-arm64@2.11.2':
+    optional: true
+
+  '@tauri-apps/cli-darwin-x64@2.11.2':
+    optional: true
+
+  '@tauri-apps/cli-linux-arm-gnueabihf@2.11.2':
+    optional: true
+
+  '@tauri-apps/cli-linux-arm64-gnu@2.11.2':
+    optional: true
+
+  '@tauri-apps/cli-linux-arm64-musl@2.11.2':
+    optional: true
+
+  '@tauri-apps/cli-linux-riscv64-gnu@2.11.2':
+    optional: true
+
+  '@tauri-apps/cli-linux-x64-gnu@2.11.2':
+    optional: true
+
+  '@tauri-apps/cli-linux-x64-musl@2.11.2':
+    optional: true
+
+  '@tauri-apps/cli-win32-arm64-msvc@2.11.2':
+    optional: true
+
+  '@tauri-apps/cli-win32-ia32-msvc@2.11.2':
+    optional: true
+
+  '@tauri-apps/cli-win32-x64-msvc@2.11.2':
+    optional: true
+
+  '@tauri-apps/cli@2.11.2':
+    optionalDependencies:
+      '@tauri-apps/cli-darwin-arm64': 2.11.2
+      '@tauri-apps/cli-darwin-x64': 2.11.2
+      '@tauri-apps/cli-linux-arm-gnueabihf': 2.11.2
+      '@tauri-apps/cli-linux-arm64-gnu': 2.11.2
+      '@tauri-apps/cli-linux-arm64-musl': 2.11.2
+      '@tauri-apps/cli-linux-riscv64-gnu': 2.11.2
+      '@tauri-apps/cli-linux-x64-gnu': 2.11.2
+      '@tauri-apps/cli-linux-x64-musl': 2.11.2
+      '@tauri-apps/cli-win32-arm64-msvc': 2.11.2
+      '@tauri-apps/cli-win32-ia32-msvc': 2.11.2
+      '@tauri-apps/cli-win32-x64-msvc': 2.11.2
+
+  '@tauri-apps/plugin-clipboard-manager@2.3.2':
+    dependencies:
+      '@tauri-apps/api': 2.11.0
+
+  '@tauri-apps/plugin-dialog@2.7.1':
+    dependencies:
+      '@tauri-apps/api': 2.11.0
+
+  '@tauri-apps/plugin-fs@2.5.1':
+    dependencies:
+      '@tauri-apps/api': 2.11.0
+
+  '@tauri-apps/plugin-process@2.3.1':
+    dependencies:
+      '@tauri-apps/api': 2.11.0
+
+  '@tauri-apps/plugin-shell@2.3.5':
+    dependencies:
+      '@tauri-apps/api': 2.11.0
+
+  '@tauri-apps/plugin-updater@2.10.1':
+    dependencies:
+      '@tauri-apps/api': 2.11.0
+
+  '@ts-morph/common@0.28.1':
+    dependencies:
+      minimatch: 10.2.5
+      path-browserify: 1.0.1
+      tinyglobby: 0.2.17
+
+  '@tybys/wasm-util@0.10.2':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
+  '@types/better-sqlite3@7.6.13':
+    dependencies:
+      '@types/node': 22.19.19
+
+  '@types/chai@5.2.3':
+    dependencies:
+      '@types/deep-eql': 4.0.2
+      assertion-error: 2.0.1
+
+  '@types/deep-eql@4.0.2': {}
+
+  '@types/esrecurse@4.3.1': {}
+
+  '@types/estree@1.0.9': {}
+
+  '@types/geojson@7946.0.16': {}
+
+  '@types/hast@3.0.4':
+    dependencies:
+      '@types/unist': 3.0.3
+
+  '@types/json-schema@7.0.15': {}
+
+  '@types/leaflet@1.9.21':
+    dependencies:
+      '@types/geojson': 7946.0.16
+
+  '@types/mdast@4.0.4':
+    dependencies:
+      '@types/unist': 3.0.3
+
+  '@types/node@22.19.19':
+    dependencies:
+      undici-types: 6.21.0
+
+  '@types/node@25.9.1':
+    dependencies:
+      undici-types: 7.24.6
+
+  '@types/pg@8.20.0':
+    dependencies:
+      '@types/node': 22.19.19
+      pg-protocol: 1.13.0
+      pg-types: 2.2.0
+
+  '@types/splitpanes@2.2.6':
+    dependencies:
+      vue: 2.7.16
+
+  '@types/unist@3.0.3': {}
+
+  '@types/web-bluetooth@0.0.21': {}
+
+  '@uiw/codemirror-theme-duotone@4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)':
+    dependencies:
+      '@uiw/codemirror-themes': 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+    transitivePeerDependencies:
+      - '@codemirror/language'
+      - '@codemirror/state'
+      - '@codemirror/view'
+
+  '@uiw/codemirror-theme-material@4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)':
+    dependencies:
+      '@uiw/codemirror-themes': 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+    transitivePeerDependencies:
+      - '@codemirror/language'
+      - '@codemirror/state'
+      - '@codemirror/view'
+
+  '@uiw/codemirror-theme-nord@4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)':
+    dependencies:
+      '@uiw/codemirror-themes': 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+    transitivePeerDependencies:
+      - '@codemirror/language'
+      - '@codemirror/state'
+      - '@codemirror/view'
+
+  '@uiw/codemirror-theme-okaidia@4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)':
+    dependencies:
+      '@uiw/codemirror-themes': 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+    transitivePeerDependencies:
+      - '@codemirror/language'
+      - '@codemirror/state'
+      - '@codemirror/view'
+
+  '@uiw/codemirror-theme-vscode@4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)':
+    dependencies:
+      '@uiw/codemirror-themes': 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+    transitivePeerDependencies:
+      - '@codemirror/language'
+      - '@codemirror/state'
+      - '@codemirror/view'
+
+  '@uiw/codemirror-theme-xcode@4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)':
+    dependencies:
+      '@uiw/codemirror-themes': 4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)
+    transitivePeerDependencies:
+      - '@codemirror/language'
+      - '@codemirror/state'
+      - '@codemirror/view'
+
+  '@uiw/codemirror-themes@4.25.10(@codemirror/language@6.12.3)(@codemirror/state@6.6.0)(@codemirror/view@6.43.0)':
+    dependencies:
+      '@codemirror/language': 6.12.3
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+
+  '@ungap/structured-clone@1.3.1': {}
+
+  '@unovue/detypes@0.8.5':
+    dependencies:
+      '@babel/core': 7.29.7
+      '@babel/preset-typescript': 7.29.7(@babel/core@7.29.7)
+      '@vue/compiler-dom': 3.5.39
+      '@vue/compiler-sfc': 3.5.39
+      '@vuedx/template-ast-types': 0.7.1
+      fast-glob: 3.3.3
+      prettier: 3.9.4
+      typescript: 5.9.3
+    transitivePeerDependencies:
+      - supports-color
+
+  '@vitejs/plugin-vue@6.0.7(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4))(vue@3.5.35(typescript@6.0.3))':
+    dependencies:
+      '@rolldown/pluginutils': 1.0.1
+      vite: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4)
+      vue: 3.5.35(typescript@6.0.3)
+
+  '@vitest/expect@4.1.8':
+    dependencies:
+      '@standard-schema/spec': 1.1.0
+      '@types/chai': 5.2.3
+      '@vitest/spy': 4.1.8
+      '@vitest/utils': 4.1.8
+      chai: 6.2.2
+      tinyrainbow: 3.1.0
+
+  '@vitest/mocker@4.1.8(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4))':
+    dependencies:
+      '@vitest/spy': 4.1.8
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4)
+
+  '@vitest/pretty-format@4.1.8':
+    dependencies:
+      tinyrainbow: 3.1.0
+
+  '@vitest/runner@4.1.8':
+    dependencies:
+      '@vitest/utils': 4.1.8
+      pathe: 2.0.3
+
+  '@vitest/snapshot@4.1.8':
+    dependencies:
+      '@vitest/pretty-format': 4.1.8
+      '@vitest/utils': 4.1.8
+      magic-string: 0.30.21
+      pathe: 2.0.3
+
+  '@vitest/spy@4.1.8': {}
+
+  '@vitest/utils@4.1.8':
+    dependencies:
+      '@vitest/pretty-format': 4.1.8
+      convert-source-map: 2.0.0
+      tinyrainbow: 3.1.0
+
+  '@volar/language-core@2.4.28':
+    dependencies:
+      '@volar/source-map': 2.4.28
+
+  '@volar/source-map@2.4.28': {}
+
+  '@volar/typescript@2.4.28':
+    dependencies:
+      '@volar/language-core': 2.4.28
+      path-browserify: 1.0.1
+      vscode-uri: 3.1.0
+
+  '@vue/compiler-core@3.5.35':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@vue/shared': 3.5.35
+      entities: 7.0.1
+      estree-walker: 2.0.2
+      source-map-js: 1.2.1
+
+  '@vue/compiler-core@3.5.39':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@vue/shared': 3.5.39
+      entities: 7.0.1
+      estree-walker: 2.0.2
+      source-map-js: 1.2.1
+
+  '@vue/compiler-dom@3.5.35':
+    dependencies:
+      '@vue/compiler-core': 3.5.35
+      '@vue/shared': 3.5.35
+
+  '@vue/compiler-dom@3.5.39':
+    dependencies:
+      '@vue/compiler-core': 3.5.39
+      '@vue/shared': 3.5.39
+
+  '@vue/compiler-sfc@2.7.16':
+    dependencies:
+      '@babel/parser': 7.29.7
+      postcss: 8.5.16
+      source-map: 0.6.1
+    optionalDependencies:
+      prettier: 2.8.8
+
+  '@vue/compiler-sfc@3.5.35':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@vue/compiler-core': 3.5.35
+      '@vue/compiler-dom': 3.5.35
+      '@vue/compiler-ssr': 3.5.35
+      '@vue/shared': 3.5.35
+      estree-walker: 2.0.2
+      magic-string: 0.30.21
+      postcss: 8.5.15
+      source-map-js: 1.2.1
+
+  '@vue/compiler-sfc@3.5.39':
+    dependencies:
+      '@babel/parser': 7.29.7
+      '@vue/compiler-core': 3.5.39
+      '@vue/compiler-dom': 3.5.39
+      '@vue/compiler-ssr': 3.5.39
+      '@vue/shared': 3.5.39
+      estree-walker: 2.0.2
+      magic-string: 0.30.21
+      postcss: 8.5.16
+      source-map-js: 1.2.1
+
+  '@vue/compiler-ssr@3.5.35':
+    dependencies:
+      '@vue/compiler-dom': 3.5.35
+      '@vue/shared': 3.5.35
+
+  '@vue/compiler-ssr@3.5.39':
+    dependencies:
+      '@vue/compiler-dom': 3.5.39
+      '@vue/shared': 3.5.39
+
+  '@vue/devtools-api@6.6.4': {}
+
+  '@vue/devtools-api@7.7.9':
+    dependencies:
+      '@vue/devtools-kit': 7.7.9
+
+  '@vue/devtools-kit@7.7.9':
+    dependencies:
+      '@vue/devtools-shared': 7.7.9
+      birpc: 2.9.0
+      hookable: 5.5.3
+      mitt: 3.0.1
+      perfect-debounce: 1.0.0
+      speakingurl: 14.0.1
+      superjson: 2.2.6
+
+  '@vue/devtools-shared@7.7.9':
+    dependencies:
+      rfdc: 1.4.1
+
+  '@vue/language-core@3.3.3':
+    dependencies:
+      '@volar/language-core': 2.4.28
+      '@vue/compiler-dom': 3.5.35
+      '@vue/shared': 3.5.35
+      alien-signals: 3.2.1
+      muggle-string: 0.4.1
+      path-browserify: 1.0.1
+      picomatch: 4.0.4
+
+  '@vue/reactivity@3.5.35':
+    dependencies:
+      '@vue/shared': 3.5.35
+
+  '@vue/runtime-core@3.5.35':
+    dependencies:
+      '@vue/reactivity': 3.5.35
+      '@vue/shared': 3.5.35
+
+  '@vue/runtime-dom@3.5.35':
+    dependencies:
+      '@vue/reactivity': 3.5.35
+      '@vue/runtime-core': 3.5.35
+      '@vue/shared': 3.5.35
+      csstype: 3.2.3
+
+  '@vue/server-renderer@3.5.35(vue@3.5.35(typescript@6.0.3))':
+    dependencies:
+      '@vue/compiler-ssr': 3.5.35
+      '@vue/shared': 3.5.35
+      vue: 3.5.35(typescript@6.0.3)
+
+  '@vue/shared@3.5.35': {}
+
+  '@vue/shared@3.5.39': {}
+
+  '@vuedx/template-ast-types@0.7.1':
+    dependencies:
+      '@vue/compiler-core': 3.5.39
+
+  '@vueuse/core@14.2.1(vue@3.5.35(typescript@6.0.3))':
+    dependencies:
+      '@types/web-bluetooth': 0.0.21
+      '@vueuse/metadata': 14.2.1
+      '@vueuse/shared': 14.2.1(vue@3.5.35(typescript@6.0.3))
+      vue: 3.5.35(typescript@6.0.3)
+
+  '@vueuse/metadata@14.2.1': {}
+
+  '@vueuse/shared@14.2.1(vue@3.5.35(typescript@6.0.3))':
+    dependencies:
+      vue: 3.5.35(typescript@6.0.3)
+
+  '@vueuse/shared@14.3.0(vue@3.5.35(typescript@6.0.3))':
+    dependencies:
+      vue: 3.5.35(typescript@6.0.3)
+
+  accepts@2.0.0:
+    dependencies:
+      mime-types: 3.0.2
+      negotiator: 1.0.0
+
+  acorn-jsx@5.3.2(acorn@8.17.0):
+    dependencies:
+      acorn: 8.17.0
+
+  acorn@8.17.0: {}
+
+  ajv-formats@2.1.1(ajv@8.20.0):
+    optionalDependencies:
+      ajv: 8.20.0
+
+  ajv-formats@3.0.1(ajv@8.20.0):
+    optionalDependencies:
+      ajv: 8.20.0
+
+  ajv@6.15.0:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-json-stable-stringify: 2.1.0
+      json-schema-traverse: 0.4.1
+      uri-js: 4.4.1
+
+  ajv@8.20.0:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-uri: 3.1.0
+      json-schema-traverse: 1.0.0
+      require-from-string: 2.0.2
+
+  alien-signals@3.2.1: {}
+
+  ansi-colors@4.1.3: {}
+
+  ansi-escapes@7.3.0:
+    dependencies:
+      environment: 1.1.0
+
+  ansi-regex@5.0.1: {}
+
+  ansi-regex@6.2.2: {}
+
+  ansi-styles@4.3.0:
+    dependencies:
+      color-convert: 2.0.1
+
+  ansi-styles@6.2.3: {}
+
+  argparse@2.0.1: {}
+
+  aria-hidden@1.2.6:
+    dependencies:
+      tslib: 2.8.1
+
+  assertion-error@2.0.1: {}
+
+  ast-types-x@1.18.0:
+    dependencies:
+      tslib: 2.8.1
+
+  astral-regex@2.0.0: {}
+
+  atob@2.1.2: {}
+
+  atomically@1.7.0: {}
+
+  aws-ssl-profiles@1.1.2: {}
+
+  balanced-match@1.0.2: {}
+
+  balanced-match@4.0.4: {}
+
+  base64-js@1.5.1: {}
+
+  baseline-browser-mapping@2.10.40: {}
+
+  better-sqlite3@12.10.0:
+    dependencies:
+      bindings: 1.5.0
+      prebuild-install: 7.1.3
+
+  bindings@1.5.0:
+    dependencies:
+      file-uri-to-path: 1.0.0
+
+  birpc@2.9.0: {}
+
+  bl@4.1.0:
+    dependencies:
+      buffer: 5.7.1
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+
+  body-parser@2.2.2:
+    dependencies:
+      bytes: 3.1.2
+      content-type: 1.0.5
+      debug: 4.4.3
+      http-errors: 2.0.1
+      iconv-lite: 0.7.2
+      on-finished: 2.4.1
+      qs: 6.15.1
+      raw-body: 3.0.2
+      type-is: 2.0.1
+    transitivePeerDependencies:
+      - supports-color
+
+  boolbase@1.0.0: {}
+
+  brace-expansion@1.1.15:
+    dependencies:
+      balanced-match: 1.0.2
+      concat-map: 0.0.1
+
+  brace-expansion@5.0.7:
+    dependencies:
+      balanced-match: 4.0.4
+
+  braces@3.0.3:
+    dependencies:
+      fill-range: 7.1.1
+
+  browserslist@4.28.4:
+    dependencies:
+      baseline-browser-mapping: 2.10.40
+      caniuse-lite: 1.0.30001800
+      electron-to-chromium: 1.5.382
+      node-releases: 2.0.50
+      update-browserslist-db: 1.2.3(browserslist@4.28.4)
+
+  buffer@5.7.1:
+    dependencies:
+      base64-js: 1.5.1
+      ieee754: 1.2.1
+
+  bundle-name@4.1.0:
+    dependencies:
+      run-applescript: 7.1.0
+
+  bytes@3.1.2: {}
+
+  c12@3.3.4:
+    dependencies:
+      chokidar: 5.0.0
+      confbox: 0.2.4
+      defu: 6.1.7
+      dotenv: 17.4.2
+      exsolve: 1.1.0
+      giget: 3.3.0
+      jiti: 2.7.0
+      ohash: 2.0.11
+      pathe: 2.0.3
+      perfect-debounce: 2.1.0
+      pkg-types: 2.3.1
+      rc9: 3.0.1
+
+  call-bind-apply-helpers@1.0.2:
+    dependencies:
+      es-errors: 1.3.0
+      function-bind: 1.1.2
+
+  call-bound@1.0.4:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      get-intrinsic: 1.3.0
+
+  caniuse-lite@1.0.30001800: {}
+
+  ccount@2.0.1: {}
+
+  chai@6.2.2: {}
+
+  chalk@5.6.2: {}
+
+  character-entities-html4@2.1.0: {}
+
+  character-entities-legacy@3.0.0: {}
+
+  chokidar@5.0.0:
+    dependencies:
+      readdirp: 5.0.0
+
+  chownr@1.1.4: {}
+
+  citty@0.2.2: {}
+
+  class-variance-authority@0.7.1:
+    dependencies:
+      clsx: 2.1.1
+
+  cli-cursor@5.0.0:
+    dependencies:
+      restore-cursor: 5.1.0
+
+  cli-progress@3.12.0:
+    dependencies:
+      string-width: 4.2.3
+
+  cli-spinners@3.4.0: {}
+
+  cli-truncate@5.2.0:
+    dependencies:
+      slice-ansi: 8.0.0
+      string-width: 8.2.1
+
+  clsx@2.1.1: {}
+
+  cluster-key-slot@1.1.1: {}
+
+  code-block-writer@13.0.3: {}
+
+  codemirror@6.0.2:
+    dependencies:
+      '@codemirror/autocomplete': 6.20.2
+      '@codemirror/commands': 6.10.3
+      '@codemirror/language': 6.12.3
+      '@codemirror/lint': 6.9.5
+      '@codemirror/search': 6.7.0
+      '@codemirror/state': 6.6.0
+      '@codemirror/view': 6.43.0
+
+  color-convert@2.0.1:
+    dependencies:
+      color-name: 1.1.4
+
+  color-name@1.1.4: {}
+
+  colorette@2.0.20: {}
+
+  comma-separated-tokens@2.0.3: {}
+
+  commander@11.1.0: {}
+
+  commander@14.0.3: {}
+
+  commander@2.20.3: {}
+
+  concat-map@0.0.1: {}
+
+  conf@10.2.0:
+    dependencies:
+      ajv: 8.20.0
+      ajv-formats: 2.1.1(ajv@8.20.0)
+      atomically: 1.7.0
+      debounce-fn: 4.0.0
+      dot-prop: 6.0.1
+      env-paths: 2.2.1
+      json-schema-typed: 7.0.3
+      onetime: 5.1.2
+      pkg-up: 3.1.0
+      semver: 7.8.5
+
+  confbox@0.2.4: {}
+
+  consola@3.4.2: {}
+
+  content-disposition@1.1.0: {}
+
+  content-type@1.0.5: {}
+
+  convert-hrtime@5.0.0: {}
+
+  convert-source-map@2.0.0: {}
+
+  cookie-signature@1.2.2: {}
+
+  cookie@0.7.2: {}
+
+  copy-anything@4.0.5:
+    dependencies:
+      is-what: 5.5.0
+
+  cors@2.8.6:
+    dependencies:
+      object-assign: 4.1.1
+      vary: 1.1.2
+
+  crelt@1.0.6: {}
+
+  cross-spawn@7.0.6:
+    dependencies:
+      path-key: 3.1.1
+      shebang-command: 2.0.0
+      which: 2.0.2
+
+  css-select@5.2.2:
+    dependencies:
+      boolbase: 1.0.0
+      css-what: 6.2.2
+      domhandler: 5.0.3
+      domutils: 3.2.2
+      nth-check: 2.1.1
+
+  css-what@6.2.2: {}
+
+  css@3.0.0:
+    dependencies:
+      inherits: 2.0.4
+      source-map: 0.6.1
+      source-map-resolve: 0.6.0
+
+  cssesc@3.0.0: {}
+
+  csstype@3.2.3: {}
+
+  dayjs@1.11.21: {}
+
+  debounce-fn@4.0.0:
+    dependencies:
+      mimic-fn: 3.1.0
+
+  debug@4.4.3:
+    dependencies:
+      ms: 2.1.3
+
+  decode-uri-component@0.2.2: {}
+
+  decompress-response@6.0.0:
+    dependencies:
+      mimic-response: 3.1.0
+
+  dedent@1.7.2: {}
+
+  deep-diff@1.0.2: {}
+
+  deep-extend@0.6.0: {}
+
+  deep-is@0.1.4: {}
+
+  deepmerge@4.3.1: {}
+
+  default-browser-id@5.0.1: {}
+
+  default-browser@5.5.0:
+    dependencies:
+      bundle-name: 4.1.0
+      default-browser-id: 5.0.1
+
+  define-lazy-prop@2.0.0: {}
+
+  define-lazy-prop@3.0.0: {}
+
+  defu@6.1.7: {}
+
+  denque@2.1.0: {}
+
+  depd@2.0.0: {}
+
+  dequal@2.0.3: {}
+
+  destr@2.0.5: {}
+
+  detect-libc@2.1.2: {}
+
+  devlop@1.1.0:
+    dependencies:
+      dequal: 2.0.3
+
+  diff@8.0.4: {}
+
+  diff@9.0.0: {}
+
+  discontinuous-range@1.0.0: {}
+
+  dom-serializer@2.0.0:
+    dependencies:
+      domelementtype: 2.3.0
+      domhandler: 5.0.3
+      entities: 4.5.0
+
+  dom-to-image-more@3.7.2: {}
+
+  domelementtype@2.3.0: {}
+
+  domhandler@5.0.3:
+    dependencies:
+      domelementtype: 2.3.0
+
+  domutils@3.2.2:
+    dependencies:
+      dom-serializer: 2.0.0
+      domelementtype: 2.3.0
+      domhandler: 5.0.3
+
+  dot-prop@6.0.1:
+    dependencies:
+      is-obj: 2.0.0
+
+  dotenv@17.4.2: {}
+
+  dunder-proto@1.0.1:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-errors: 1.3.0
+      gopd: 1.2.0
+
+  echarts@6.1.0:
+    dependencies:
+      tslib: 2.3.0
+      zrender: 6.1.0
+
+  ee-first@1.1.1: {}
+
+  electron-to-chromium@1.5.382: {}
+
+  emoji-regex@10.6.0: {}
+
+  emoji-regex@8.0.0: {}
+
+  encodeurl@2.0.0: {}
+
+  end-of-stream@1.4.5:
+    dependencies:
+      once: 1.4.0
+
+  enhanced-resolve@5.22.1:
+    dependencies:
+      graceful-fs: 4.2.11
+      tapable: 2.3.3
+
+  enquirer@2.4.1:
+    dependencies:
+      ansi-colors: 4.1.3
+      strip-ansi: 6.0.1
+
+  entities@4.5.0: {}
+
+  entities@7.0.1: {}
+
+  env-paths@2.2.1: {}
+
+  environment@1.1.0: {}
+
+  es-define-property@1.0.1: {}
+
+  es-errors@1.3.0: {}
+
+  es-module-lexer@2.1.0: {}
+
+  es-object-atoms@1.1.1:
+    dependencies:
+      es-errors: 1.3.0
+
+  esbuild@0.27.7:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.27.7
+      '@esbuild/android-arm': 0.27.7
+      '@esbuild/android-arm64': 0.27.7
+      '@esbuild/android-x64': 0.27.7
+      '@esbuild/darwin-arm64': 0.27.7
+      '@esbuild/darwin-x64': 0.27.7
+      '@esbuild/freebsd-arm64': 0.27.7
+      '@esbuild/freebsd-x64': 0.27.7
+      '@esbuild/linux-arm': 0.27.7
+      '@esbuild/linux-arm64': 0.27.7
+      '@esbuild/linux-ia32': 0.27.7
+      '@esbuild/linux-loong64': 0.27.7
+      '@esbuild/linux-mips64el': 0.27.7
+      '@esbuild/linux-ppc64': 0.27.7
+      '@esbuild/linux-riscv64': 0.27.7
+      '@esbuild/linux-s390x': 0.27.7
+      '@esbuild/linux-x64': 0.27.7
+      '@esbuild/netbsd-arm64': 0.27.7
+      '@esbuild/netbsd-x64': 0.27.7
+      '@esbuild/openbsd-arm64': 0.27.7
+      '@esbuild/openbsd-x64': 0.27.7
+      '@esbuild/openharmony-arm64': 0.27.7
+      '@esbuild/sunos-x64': 0.27.7
+      '@esbuild/win32-arm64': 0.27.7
+      '@esbuild/win32-ia32': 0.27.7
+      '@esbuild/win32-x64': 0.27.7
+
+  esbuild@0.28.0:
+    optionalDependencies:
+      '@esbuild/aix-ppc64': 0.28.0
+      '@esbuild/android-arm': 0.28.0
+      '@esbuild/android-arm64': 0.28.0
+      '@esbuild/android-x64': 0.28.0
+      '@esbuild/darwin-arm64': 0.28.0
+      '@esbuild/darwin-x64': 0.28.0
+      '@esbuild/freebsd-arm64': 0.28.0
+      '@esbuild/freebsd-x64': 0.28.0
+      '@esbuild/linux-arm': 0.28.0
+      '@esbuild/linux-arm64': 0.28.0
+      '@esbuild/linux-ia32': 0.28.0
+      '@esbuild/linux-loong64': 0.28.0
+      '@esbuild/linux-mips64el': 0.28.0
+      '@esbuild/linux-ppc64': 0.28.0
+      '@esbuild/linux-riscv64': 0.28.0
+      '@esbuild/linux-s390x': 0.28.0
+      '@esbuild/linux-x64': 0.28.0
+      '@esbuild/netbsd-arm64': 0.28.0
+      '@esbuild/netbsd-x64': 0.28.0
+      '@esbuild/openbsd-arm64': 0.28.0
+      '@esbuild/openbsd-x64': 0.28.0
+      '@esbuild/openharmony-arm64': 0.28.0
+      '@esbuild/sunos-x64': 0.28.0
+      '@esbuild/win32-arm64': 0.28.0
+      '@esbuild/win32-ia32': 0.28.0
+      '@esbuild/win32-x64': 0.28.0
+
+  escalade@3.2.0: {}
+
+  escape-html@1.0.3: {}
+
+  escape-string-regexp@4.0.0: {}
+
+  eslint-scope@9.1.2:
+    dependencies:
+      '@types/esrecurse': 4.3.1
+      '@types/estree': 1.0.9
+      esrecurse: 4.3.0
+      estraverse: 5.3.0
+
+  eslint-visitor-keys@3.4.3: {}
+
+  eslint-visitor-keys@5.0.1: {}
+
+  eslint@10.2.1(jiti@2.7.0):
+    dependencies:
+      '@eslint-community/eslint-utils': 4.9.1(eslint@10.2.1(jiti@2.7.0))
+      '@eslint-community/regexpp': 4.12.2
+      '@eslint/config-array': 0.23.5
+      '@eslint/config-helpers': 0.5.5
+      '@eslint/core': 1.2.1
+      '@eslint/plugin-kit': 0.7.2
+      '@humanfs/node': 0.16.8
+      '@humanwhocodes/module-importer': 1.0.1
+      '@humanwhocodes/retry': 0.4.3
+      '@types/estree': 1.0.9
+      ajv: 6.15.0
+      cross-spawn: 7.0.6
+      debug: 4.4.3
+      escape-string-regexp: 4.0.0
+      eslint-scope: 9.1.2
+      eslint-visitor-keys: 5.0.1
+      espree: 11.2.0
+      esquery: 1.7.0
+      esutils: 2.0.3
+      fast-deep-equal: 3.1.3
+      file-entry-cache: 8.0.0
+      find-up: 5.0.0
+      glob-parent: 6.0.2
+      ignore: 5.3.2
+      imurmurhash: 0.1.4
+      is-glob: 4.0.3
+      json-stable-stringify-without-jsonify: 1.0.1
+      minimatch: 10.2.5
+      natural-compare: 1.4.0
+      optionator: 0.9.4
+    optionalDependencies:
+      jiti: 2.7.0
+    transitivePeerDependencies:
+      - supports-color
+
+  espree@11.2.0:
+    dependencies:
+      acorn: 8.17.0
+      acorn-jsx: 5.3.2(acorn@8.17.0)
+      eslint-visitor-keys: 5.0.1
+
+  esquery@1.7.0:
+    dependencies:
+      estraverse: 5.3.0
+
+  esrecurse@4.3.0:
+    dependencies:
+      estraverse: 5.3.0
+
+  estraverse@5.3.0: {}
+
+  estree-walker@2.0.2: {}
+
+  estree-walker@3.0.3:
+    dependencies:
+      '@types/estree': 1.0.9
+
+  esutils@2.0.3: {}
+
+  etag@1.8.1: {}
+
+  eventemitter3@5.0.4: {}
+
+  eventsource-parser@3.0.8: {}
+
+  eventsource@3.0.7:
+    dependencies:
+      eventsource-parser: 3.0.8
+
+  execa@5.1.1:
+    dependencies:
+      cross-spawn: 7.0.6
+      get-stream: 6.0.1
+      human-signals: 2.1.0
+      is-stream: 2.0.1
+      merge-stream: 2.0.0
+      npm-run-path: 4.0.1
+      onetime: 5.1.2
+      signal-exit: 3.0.7
+      strip-final-newline: 2.0.0
+
+  expand-template@2.0.3: {}
+
+  expect-type@1.3.0: {}
+
+  express-rate-limit@8.4.1(express@5.2.1):
+    dependencies:
+      express: 5.2.1
+      ip-address: 10.1.0
+
+  express@5.2.1:
+    dependencies:
+      accepts: 2.0.0
+      body-parser: 2.2.2
+      content-disposition: 1.1.0
+      content-type: 1.0.5
+      cookie: 0.7.2
+      cookie-signature: 1.2.2
+      debug: 4.4.3
+      depd: 2.0.0
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      etag: 1.8.1
+      finalhandler: 2.1.1
+      fresh: 2.0.0
+      http-errors: 2.0.1
+      merge-descriptors: 2.0.0
+      mime-types: 3.0.2
+      on-finished: 2.4.1
+      once: 1.4.0
+      parseurl: 1.3.3
+      proxy-addr: 2.0.7
+      qs: 6.15.1
+      range-parser: 1.2.1
+      router: 2.2.0
+      send: 1.2.1
+      serve-static: 2.2.1
+      statuses: 2.0.2
+      type-is: 2.0.1
+      vary: 1.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  exsolve@1.1.0: {}
+
+  fast-deep-equal@3.1.3: {}
+
+  fast-diff@1.3.0: {}
+
+  fast-glob@3.3.3:
+    dependencies:
+      '@nodelib/fs.stat': 2.0.5
+      '@nodelib/fs.walk': 1.2.8
+      glob-parent: 5.1.2
+      merge2: 1.4.1
+      micromatch: 4.0.8
+
+  fast-json-stable-stringify@2.1.0: {}
+
+  fast-levenshtein@2.0.6: {}
+
+  fast-uri@3.1.0: {}
+
+  fastq@1.20.1:
+    dependencies:
+      reusify: 1.1.0
+
+  fdir@6.5.0(picomatch@4.0.4):
+    optionalDependencies:
+      picomatch: 4.0.4
+
+  file-entry-cache@8.0.0:
+    dependencies:
+      flat-cache: 4.0.1
+
+  file-uri-to-path@1.0.0: {}
+
+  fill-range@7.1.1:
+    dependencies:
+      to-regex-range: 5.0.1
+
+  finalhandler@2.1.1:
+    dependencies:
+      debug: 4.4.3
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      on-finished: 2.4.1
+      parseurl: 1.3.3
+      statuses: 2.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  find-up@3.0.0:
+    dependencies:
+      locate-path: 3.0.0
+
+  find-up@5.0.0:
+    dependencies:
+      locate-path: 6.0.0
+      path-exists: 4.0.0
+
+  flat-cache@4.0.1:
+    dependencies:
+      flatted: 3.4.2
+      keyv: 4.5.4
+
+  flatted@3.4.2: {}
+
+  foreground-child@3.3.1:
+    dependencies:
+      cross-spawn: 7.0.6
+      signal-exit: 4.1.0
+
+  forwarded@0.2.0: {}
+
+  fresh@2.0.0: {}
+
+  fs-constants@1.0.0: {}
+
+  fs-extra@11.3.6:
+    dependencies:
+      graceful-fs: 4.2.11
+      jsonfile: 6.2.1
+      universalify: 2.0.1
+
+  fs.realpath@1.0.0: {}
+
+  fsevents@2.3.3:
+    optional: true
+
+  function-bind@1.1.2: {}
+
+  function-timeout@1.0.2: {}
+
+  fuzzysort@3.1.0: {}
+
+  generate-function@2.3.1:
+    dependencies:
+      is-property: 1.0.2
+
+  gensync@1.0.0-beta.2: {}
+
+  get-east-asian-width@1.5.0: {}
+
+  get-east-asian-width@1.6.0: {}
+
+  get-intrinsic@1.3.0:
+    dependencies:
+      call-bind-apply-helpers: 1.0.2
+      es-define-property: 1.0.1
+      es-errors: 1.3.0
+      es-object-atoms: 1.1.1
+      function-bind: 1.1.2
+      get-proto: 1.0.1
+      gopd: 1.2.0
+      has-symbols: 1.1.0
+      hasown: 2.0.3
+      math-intrinsics: 1.1.0
+
+  get-own-enumerable-keys@1.0.0: {}
+
+  get-proto@1.0.1:
+    dependencies:
+      dunder-proto: 1.0.1
+      es-object-atoms: 1.1.1
+
+  get-stream@6.0.1: {}
+
+  get-tsconfig@4.14.0:
+    dependencies:
+      resolve-pkg-maps: 1.0.0
+
+  giget@3.3.0: {}
+
+  github-from-package@0.0.0: {}
+
+  glob-parent@5.1.2:
+    dependencies:
+      is-glob: 4.0.3
+
+  glob-parent@6.0.2:
+    dependencies:
+      is-glob: 4.0.3
+
+  glob@11.1.0:
+    dependencies:
+      foreground-child: 3.3.1
+      jackspeak: 4.2.3
+      minimatch: 10.2.5
+      minipass: 7.1.3
+      package-json-from-dist: 1.0.1
+      path-scurry: 2.0.2
+
+  glob@7.2.3:
+    dependencies:
+      fs.realpath: 1.0.0
+      inflight: 1.0.6
+      inherits: 2.0.4
+      minimatch: 3.1.5
+      once: 1.4.0
+      path-is-absolute: 1.0.1
+
+  gonzales-pe@4.3.0:
+    dependencies:
+      minimist: 1.2.8
+
+  gopd@1.2.0: {}
+
+  graceful-fs@4.2.11: {}
+
+  has-symbols@1.1.0: {}
+
+  hasown@2.0.3:
+    dependencies:
+      function-bind: 1.1.2
+
+  hast-util-to-html@9.0.5:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/unist': 3.0.3
+      ccount: 2.0.1
+      comma-separated-tokens: 2.0.3
+      hast-util-whitespace: 3.0.0
+      html-void-elements: 3.0.0
+      mdast-util-to-hast: 13.2.1
+      property-information: 7.2.0
+      space-separated-tokens: 2.0.2
+      stringify-entities: 4.0.4
+      zwitch: 2.0.4
+
+  hast-util-whitespace@3.0.0:
+    dependencies:
+      '@types/hast': 3.0.4
+
+  he@1.2.0: {}
+
+  hono@4.12.15: {}
+
+  hookable@5.5.3: {}
+
+  html-void-elements@3.0.0: {}
+
+  http-errors@2.0.1:
+    dependencies:
+      depd: 2.0.0
+      inherits: 2.0.4
+      setprototypeof: 1.2.0
+      statuses: 2.0.2
+      toidentifier: 1.0.1
+
+  human-signals@2.1.0: {}
+
+  husky@9.1.7: {}
+
+  iconv-lite@0.7.2:
+    dependencies:
+      safer-buffer: 2.1.2
+
+  identifier-regex@1.0.1:
+    dependencies:
+      reserved-identifiers: 1.2.0
+
+  ieee754@1.2.1: {}
+
+  ignore@5.3.2: {}
+
+  imurmurhash@0.1.4: {}
+
+  inflight@1.0.6:
+    dependencies:
+      once: 1.4.0
+      wrappy: 1.0.2
+
+  inherits@2.0.4: {}
+
+  ini@1.3.8: {}
+
+  ioredis@5.11.1:
+    dependencies:
+      '@ioredis/commands': 1.10.0
+      cluster-key-slot: 1.1.1
+      debug: 4.4.3
+      denque: 2.1.0
+      redis-errors: 1.2.0
+      redis-parser: 3.0.0
+      standard-as-callback: 2.1.0
+    transitivePeerDependencies:
+      - supports-color
+
+  ip-address@10.1.0: {}
+
+  ipaddr.js@1.9.1: {}
+
+  is-docker@2.2.1: {}
+
+  is-docker@3.0.0: {}
+
+  is-extglob@2.1.1: {}
+
+  is-fullwidth-code-point@3.0.0: {}
+
+  is-fullwidth-code-point@5.1.0:
+    dependencies:
+      get-east-asian-width: 1.6.0
+
+  is-glob@4.0.3:
+    dependencies:
+      is-extglob: 2.1.1
+
+  is-identifier@1.0.1:
+    dependencies:
+      identifier-regex: 1.0.1
+      super-regex: 1.1.0
+
+  is-inside-container@1.0.0:
+    dependencies:
+      is-docker: 3.0.0
+
+  is-interactive@2.0.0: {}
+
+  is-number@7.0.0: {}
+
+  is-obj@2.0.0: {}
+
+  is-obj@3.0.0: {}
+
+  is-promise@4.0.0: {}
+
+  is-property@1.0.2: {}
+
+  is-regexp@3.1.0: {}
+
+  is-stream@2.0.1: {}
+
+  is-unicode-supported@2.1.0: {}
+
+  is-what@5.5.0: {}
+
+  is-wsl@2.2.0:
+    dependencies:
+      is-docker: 2.2.1
+
+  is-wsl@3.1.1:
+    dependencies:
+      is-inside-container: 1.0.0
+
+  isexe@2.0.0: {}
+
+  isexe@3.1.5: {}
+
+  jackspeak@4.2.3:
+    dependencies:
+      '@isaacs/cliui': 9.0.0
+
+  jiti@2.7.0: {}
+
+  jose@6.2.3: {}
+
+  js-tokens@4.0.0: {}
+
+  jsesc@3.1.0: {}
+
+  json-buffer@3.0.1: {}
+
+  json-schema-traverse@0.4.1: {}
+
+  json-schema-traverse@1.0.0: {}
+
+  json-schema-typed@7.0.3: {}
+
+  json-schema-typed@8.0.2: {}
+
+  json-stable-stringify-without-jsonify@1.0.1: {}
+
+  json5@2.2.3: {}
+
+  jsonfile@6.2.1:
+    dependencies:
+      universalify: 2.0.1
+    optionalDependencies:
+      graceful-fs: 4.2.11
+
+  keytar@7.9.0:
+    dependencies:
+      node-addon-api: 4.3.0
+      prebuild-install: 7.1.3
+
+  keyv@4.5.4:
+    dependencies:
+      json-buffer: 3.0.1
+
+  kleur@3.0.3: {}
+
+  leaflet@1.9.4: {}
+
+  levn@0.4.1:
+    dependencies:
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+
+  lightningcss-android-arm64@1.32.0:
+    optional: true
+
+  lightningcss-darwin-arm64@1.32.0:
+    optional: true
+
+  lightningcss-darwin-x64@1.32.0:
+    optional: true
+
+  lightningcss-freebsd-x64@1.32.0:
+    optional: true
+
+  lightningcss-linux-arm-gnueabihf@1.32.0:
+    optional: true
+
+  lightningcss-linux-arm64-gnu@1.32.0:
+    optional: true
+
+  lightningcss-linux-arm64-musl@1.32.0:
+    optional: true
+
+  lightningcss-linux-x64-gnu@1.32.0:
+    optional: true
+
+  lightningcss-linux-x64-musl@1.32.0:
+    optional: true
+
+  lightningcss-win32-arm64-msvc@1.32.0:
+    optional: true
+
+  lightningcss-win32-x64-msvc@1.32.0:
+    optional: true
+
+  lightningcss@1.32.0:
+    dependencies:
+      detect-libc: 2.1.2
+    optionalDependencies:
+      lightningcss-android-arm64: 1.32.0
+      lightningcss-darwin-arm64: 1.32.0
+      lightningcss-darwin-x64: 1.32.0
+      lightningcss-freebsd-x64: 1.32.0
+      lightningcss-linux-arm-gnueabihf: 1.32.0
+      lightningcss-linux-arm64-gnu: 1.32.0
+      lightningcss-linux-arm64-musl: 1.32.0
+      lightningcss-linux-x64-gnu: 1.32.0
+      lightningcss-linux-x64-musl: 1.32.0
+      lightningcss-win32-arm64-msvc: 1.32.0
+      lightningcss-win32-x64-msvc: 1.32.0
+
+  lint-staged@16.4.0:
+    dependencies:
+      commander: 14.0.3
+      listr2: 9.0.5
+      picomatch: 4.0.4
+      string-argv: 0.3.2
+      tinyexec: 1.1.1
+      yaml: 2.8.4
+
+  listr2@9.0.5:
+    dependencies:
+      cli-truncate: 5.2.0
+      colorette: 2.0.20
+      eventemitter3: 5.0.4
+      log-update: 6.1.0
+      rfdc: 1.4.1
+      wrap-ansi: 9.0.2
+
+  locate-path@3.0.0:
+    dependencies:
+      p-locate: 3.0.0
+      path-exists: 3.0.0
+
+  locate-path@6.0.0:
+    dependencies:
+      p-locate: 5.0.0
+
+  lodash-es@4.18.1: {}
+
+  lodash.sortedlastindex@4.1.0: {}
+
+  lodash.truncate@4.4.2: {}
+
+  log-symbols@7.0.1:
+    dependencies:
+      is-unicode-supported: 2.1.0
+      yoctocolors: 2.1.2
+
+  log-update@6.1.0:
+    dependencies:
+      ansi-escapes: 7.3.0
+      cli-cursor: 5.0.0
+      slice-ansi: 7.1.2
+      strip-ansi: 7.2.0
+      wrap-ansi: 9.0.2
+
+  long@5.3.2: {}
+
+  lru-cache@11.5.1: {}
+
+  lru-cache@5.1.1:
+    dependencies:
+      yallist: 3.1.1
+
+  lru.min@1.1.4: {}
+
+  magic-string@0.30.21:
+    dependencies:
+      '@jridgewell/sourcemap-codec': 1.5.5
+
+  make-asynchronous@1.1.0:
+    dependencies:
+      p-event: 6.0.1
+      type-fest: 4.41.0
+      web-worker: 1.5.0
+
+  marked@18.0.4: {}
+
+  math-intrinsics@1.1.0: {}
+
+  mdast-util-to-hast@13.2.1:
+    dependencies:
+      '@types/hast': 3.0.4
+      '@types/mdast': 4.0.4
+      '@ungap/structured-clone': 1.3.1
+      devlop: 1.1.0
+      micromark-util-sanitize-uri: 2.0.1
+      trim-lines: 3.0.1
+      unist-util-position: 5.0.0
+      unist-util-visit: 5.1.0
+      vfile: 6.0.3
+
+  media-typer@1.1.0: {}
+
+  merge-descriptors@2.0.0: {}
+
+  merge-stream@2.0.0: {}
+
+  merge2@1.4.1: {}
+
+  micromark-util-character@2.1.1:
+    dependencies:
+      micromark-util-symbol: 2.0.1
+      micromark-util-types: 2.0.2
+
+  micromark-util-encode@2.0.1: {}
+
+  micromark-util-sanitize-uri@2.0.1:
+    dependencies:
+      micromark-util-character: 2.1.1
+      micromark-util-encode: 2.0.1
+      micromark-util-symbol: 2.0.1
+
+  micromark-util-symbol@2.0.1: {}
+
+  micromark-util-types@2.0.2: {}
+
+  micromatch@4.0.8:
+    dependencies:
+      braces: 3.0.3
+      picomatch: 2.3.2
+
+  mime-db@1.54.0: {}
+
+  mime-types@3.0.2:
+    dependencies:
+      mime-db: 1.54.0
+
+  mimic-fn@2.1.0: {}
+
+  mimic-fn@3.1.0: {}
+
+  mimic-function@5.0.1: {}
+
+  mimic-response@3.1.0: {}
+
+  minimatch@10.2.5:
+    dependencies:
+      brace-expansion: 5.0.7
+
+  minimatch@3.1.5:
+    dependencies:
+      brace-expansion: 1.1.15
+
+  minimist@1.2.8: {}
+
+  minipass@7.1.3: {}
+
+  mitt@3.0.1: {}
+
+  mkdirp-classic@0.5.3: {}
+
+  moo@0.5.3: {}
+
+  ms@2.1.3: {}
+
+  muggle-string@0.4.1: {}
+
+  mysql2@3.22.3(@types/node@22.19.19):
+    dependencies:
+      '@types/node': 22.19.19
+      aws-ssl-profiles: 1.1.2
+      denque: 2.1.0
+      generate-function: 2.3.1
+      iconv-lite: 0.7.2
+      long: 5.3.2
+      lru.min: 1.1.4
+      named-placeholders: 1.1.6
+      sql-escaper: 1.3.3
+
+  named-placeholders@1.1.6:
+    dependencies:
+      lru.min: 1.1.4
+
+  nanoid@3.3.12: {}
+
+  nanoid@3.3.15: {}
+
+  napi-build-utils@2.0.0: {}
+
+  natural-compare@1.4.0: {}
+
+  nearley@2.20.1:
+    dependencies:
+      commander: 2.20.3
+      moo: 0.5.3
+      railroad-diagrams: 1.0.0
+      randexp: 0.4.6
+
+  negotiator@1.0.0: {}
+
+  node-abi@3.92.0:
+    dependencies:
+      semver: 7.8.5
+
+  node-addon-api@4.3.0: {}
+
+  node-fetch-native@1.6.7: {}
+
+  node-html-parser@7.1.0:
+    dependencies:
+      css-select: 5.2.2
+      he: 1.2.0
+
+  node-releases@2.0.50: {}
+
+  npm-run-path@4.0.1:
+    dependencies:
+      path-key: 3.1.1
+
+  nth-check@2.1.1:
+    dependencies:
+      boolbase: 1.0.0
+
+  nypm@0.6.8:
+    dependencies:
+      citty: 0.2.2
+      pathe: 2.0.3
+      tinyexec: 1.2.4
+
+  object-assign@4.1.1: {}
+
+  object-inspect@1.13.4: {}
+
+  object-treeify@1.1.33: {}
+
+  obug@2.1.2: {}
+
+  ofetch@1.5.1:
+    dependencies:
+      destr: 2.0.5
+      node-fetch-native: 1.6.7
+      ufo: 1.6.4
+
+  ohash@2.0.11: {}
+
+  on-finished@2.4.1:
+    dependencies:
+      ee-first: 1.1.1
+
+  once@1.4.0:
+    dependencies:
+      wrappy: 1.0.2
+
+  onetime@5.1.2:
+    dependencies:
+      mimic-fn: 2.1.0
+
+  onetime@7.0.0:
+    dependencies:
+      mimic-function: 5.0.1
+
+  oniguruma-parser@0.12.2: {}
+
+  oniguruma-to-es@4.3.6:
+    dependencies:
+      oniguruma-parser: 0.12.2
+      regex: 6.1.0
+      regex-recursion: 6.0.2
+
+  open@10.2.0:
+    dependencies:
+      default-browser: 5.5.0
+      define-lazy-prop: 3.0.0
+      is-inside-container: 1.0.0
+      wsl-utils: 0.1.0
+
+  open@8.4.2:
+    dependencies:
+      define-lazy-prop: 2.0.0
+      is-docker: 2.2.1
+      is-wsl: 2.2.0
+
+  optionator@0.9.4:
+    dependencies:
+      deep-is: 0.1.4
+      fast-levenshtein: 2.0.6
+      levn: 0.4.1
+      prelude-ls: 1.2.1
+      type-check: 0.4.0
+      word-wrap: 1.2.5
+
+  ora@9.4.1:
+    dependencies:
+      chalk: 5.6.2
+      cli-cursor: 5.0.0
+      cli-spinners: 3.4.0
+      is-interactive: 2.0.0
+      is-unicode-supported: 2.1.0
+      log-symbols: 7.0.1
+      stdin-discarder: 0.3.2
+      string-width: 8.2.1
+
+  oxfmt@0.53.0:
+    dependencies:
+      tinypool: 2.1.0
+    optionalDependencies:
+      '@oxfmt/binding-android-arm-eabi': 0.53.0
+      '@oxfmt/binding-android-arm64': 0.53.0
+      '@oxfmt/binding-darwin-arm64': 0.53.0
+      '@oxfmt/binding-darwin-x64': 0.53.0
+      '@oxfmt/binding-freebsd-x64': 0.53.0
+      '@oxfmt/binding-linux-arm-gnueabihf': 0.53.0
+      '@oxfmt/binding-linux-arm-musleabihf': 0.53.0
+      '@oxfmt/binding-linux-arm64-gnu': 0.53.0
+      '@oxfmt/binding-linux-arm64-musl': 0.53.0
+      '@oxfmt/binding-linux-ppc64-gnu': 0.53.0
+      '@oxfmt/binding-linux-riscv64-gnu': 0.53.0
+      '@oxfmt/binding-linux-riscv64-musl': 0.53.0
+      '@oxfmt/binding-linux-s390x-gnu': 0.53.0
+      '@oxfmt/binding-linux-x64-gnu': 0.53.0
+      '@oxfmt/binding-linux-x64-musl': 0.53.0
+      '@oxfmt/binding-openharmony-arm64': 0.53.0
+      '@oxfmt/binding-win32-arm64-msvc': 0.53.0
+      '@oxfmt/binding-win32-ia32-msvc': 0.53.0
+      '@oxfmt/binding-win32-x64-msvc': 0.53.0
+
+  oxlint@1.68.0:
+    optionalDependencies:
+      '@oxlint/binding-android-arm-eabi': 1.68.0
+      '@oxlint/binding-android-arm64': 1.68.0
+      '@oxlint/binding-darwin-arm64': 1.68.0
+      '@oxlint/binding-darwin-x64': 1.68.0
+      '@oxlint/binding-freebsd-x64': 1.68.0
+      '@oxlint/binding-linux-arm-gnueabihf': 1.68.0
+      '@oxlint/binding-linux-arm-musleabihf': 1.68.0
+      '@oxlint/binding-linux-arm64-gnu': 1.68.0
+      '@oxlint/binding-linux-arm64-musl': 1.68.0
+      '@oxlint/binding-linux-ppc64-gnu': 1.68.0
+      '@oxlint/binding-linux-riscv64-gnu': 1.68.0
+      '@oxlint/binding-linux-riscv64-musl': 1.68.0
+      '@oxlint/binding-linux-s390x-gnu': 1.68.0
+      '@oxlint/binding-linux-x64-gnu': 1.68.0
+      '@oxlint/binding-linux-x64-musl': 1.68.0
+      '@oxlint/binding-openharmony-arm64': 1.68.0
+      '@oxlint/binding-win32-arm64-msvc': 1.68.0
+      '@oxlint/binding-win32-ia32-msvc': 1.68.0
+      '@oxlint/binding-win32-x64-msvc': 1.68.0
+
+  p-event@6.0.1:
+    dependencies:
+      p-timeout: 6.1.4
+
+  p-limit@2.3.0:
+    dependencies:
+      p-try: 2.2.0
+
+  p-limit@3.1.0:
+    dependencies:
+      yocto-queue: 0.1.0
+
+  p-locate@3.0.0:
+    dependencies:
+      p-limit: 2.3.0
+
+  p-locate@5.0.0:
+    dependencies:
+      p-limit: 3.1.0
+
+  p-timeout@6.1.4: {}
+
+  p-try@2.2.0: {}
+
+  package-json-from-dist@1.0.1: {}
+
+  parseurl@1.3.3: {}
+
+  path-browserify@1.0.1: {}
+
+  path-exists@3.0.0: {}
+
+  path-exists@4.0.0: {}
+
+  path-is-absolute@1.0.1: {}
+
+  path-key@3.1.1: {}
+
+  path-scurry@2.0.2:
+    dependencies:
+      lru-cache: 11.5.1
+      minipass: 7.1.3
+
+  path-to-regexp@8.4.2: {}
+
+  pathe@2.0.3: {}
+
+  perfect-debounce@1.0.0: {}
+
+  perfect-debounce@2.1.0: {}
+
+  pg-cloudflare@1.3.0:
+    optional: true
+
+  pg-connection-string@2.12.0: {}
+
+  pg-int8@1.0.1: {}
+
+  pg-pool@3.13.0(pg@8.20.0):
+    dependencies:
+      pg: 8.20.0
+
+  pg-protocol@1.13.0: {}
+
+  pg-types@2.2.0:
+    dependencies:
+      pg-int8: 1.0.1
+      postgres-array: 2.0.0
+      postgres-bytea: 1.0.1
+      postgres-date: 1.0.7
+      postgres-interval: 1.2.0
+
+  pg@8.20.0:
+    dependencies:
+      pg-connection-string: 2.12.0
+      pg-pool: 3.13.0(pg@8.20.0)
+      pg-protocol: 1.13.0
+      pg-types: 2.2.0
+      pgpass: 1.0.5
+    optionalDependencies:
+      pg-cloudflare: 1.3.0
+
+  pgpass@1.0.5:
+    dependencies:
+      split2: 4.2.0
+
+  picocolors@1.1.1: {}
+
+  picomatch@2.3.2: {}
+
+  picomatch@4.0.4: {}
+
+  pinia@3.0.4(typescript@6.0.3)(vue@3.5.35(typescript@6.0.3)):
+    dependencies:
+      '@vue/devtools-api': 7.7.9
+      vue: 3.5.35(typescript@6.0.3)
+    optionalDependencies:
+      typescript: 6.0.3
+
+  pkce-challenge@5.0.1: {}
+
+  pkg-types@2.3.1:
+    dependencies:
+      confbox: 0.2.4
+      exsolve: 1.1.0
+      pathe: 2.0.3
+
+  pkg-up@3.1.0:
+    dependencies:
+      find-up: 3.0.0
+
+  postcss-less@6.0.0(postcss@8.5.16):
+    dependencies:
+      postcss: 8.5.16
+
+  postcss-sass@0.5.0:
+    dependencies:
+      gonzales-pe: 4.3.0
+      postcss: 8.5.16
+
+  postcss-scss@4.0.9(postcss@8.5.16):
+    dependencies:
+      postcss: 8.5.16
+
+  postcss-selector-parser@7.1.4:
+    dependencies:
+      cssesc: 3.0.0
+      util-deprecate: 1.0.2
+
+  postcss-styl@0.12.3:
+    dependencies:
+      debug: 4.4.3
+      fast-diff: 1.3.0
+      lodash.sortedlastindex: 4.1.0
+      postcss: 8.5.16
+      stylus: 0.57.0
+    transitivePeerDependencies:
+      - supports-color
+
+  postcss@8.5.15:
+    dependencies:
+      nanoid: 3.3.12
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  postcss@8.5.16:
+    dependencies:
+      nanoid: 3.3.15
+      picocolors: 1.1.1
+      source-map-js: 1.2.1
+
+  postgres-array@2.0.0: {}
+
+  postgres-bytea@1.0.1: {}
+
+  postgres-date@1.0.7: {}
+
+  postgres-interval@1.2.0:
+    dependencies:
+      xtend: 4.0.2
+
+  prebuild-install@7.1.3:
+    dependencies:
+      detect-libc: 2.1.2
+      expand-template: 2.0.3
+      github-from-package: 0.0.0
+      minimist: 1.2.8
+      mkdirp-classic: 0.5.3
+      napi-build-utils: 2.0.0
+      node-abi: 3.92.0
+      pump: 3.0.4
+      rc: 1.2.8
+      simple-get: 4.0.1
+      tar-fs: 2.1.4
+      tunnel-agent: 0.6.0
+
+  prelude-ls@1.2.1: {}
+
+  prettier@2.8.8:
+    optional: true
+
+  prettier@3.9.4: {}
+
+  prompts@2.4.2:
+    dependencies:
+      kleur: 3.0.3
+      sisteransi: 1.0.5
+
+  property-information@7.2.0: {}
+
+  proxy-addr@2.0.7:
+    dependencies:
+      forwarded: 0.2.0
+      ipaddr.js: 1.9.1
+
+  pump@3.0.4:
+    dependencies:
+      end-of-stream: 1.4.5
+      once: 1.4.0
+
+  punycode@2.3.1: {}
+
+  qs@6.15.1:
+    dependencies:
+      side-channel: 1.1.0
+
+  queue-microtask@1.2.3: {}
+
+  railroad-diagrams@1.0.0: {}
+
+  randexp@0.4.6:
+    dependencies:
+      discontinuous-range: 1.0.0
+      ret: 0.1.15
+
+  range-parser@1.2.1: {}
+
+  raw-body@3.0.2:
+    dependencies:
+      bytes: 3.1.2
+      http-errors: 2.0.1
+      iconv-lite: 0.7.2
+      unpipe: 1.0.0
+
+  rc9@3.0.1:
+    dependencies:
+      defu: 6.1.7
+      destr: 2.0.5
+
+  rc@1.2.8:
+    dependencies:
+      deep-extend: 0.6.0
+      ini: 1.3.8
+      minimist: 1.2.8
+      strip-json-comments: 2.0.1
+
+  readable-stream@3.6.2:
+    dependencies:
+      inherits: 2.0.4
+      string_decoder: 1.3.0
+      util-deprecate: 1.0.2
+
+  readdirp@5.0.0: {}
+
+  recast-x@1.0.5:
+    dependencies:
+      ast-types: ast-types-x@1.18.0
+      source-map: 0.6.1
+      tiny-invariant: 1.3.3
+      tslib: 2.8.1
+
+  redis-errors@1.2.0: {}
+
+  redis-parser@3.0.0:
+    dependencies:
+      redis-errors: 1.2.0
+
+  regex-recursion@6.0.2:
+    dependencies:
+      regex-utilities: 2.3.0
+
+  regex-utilities@2.3.0: {}
+
+  regex@6.1.0:
+    dependencies:
+      regex-utilities: 2.3.0
+
+  reka-ui@2.10.1(vue@3.5.35(typescript@6.0.3)):
+    dependencies:
+      '@floating-ui/dom': 1.7.6
+      '@floating-ui/vue': 1.1.11(vue@3.5.35(typescript@6.0.3))
+      '@internationalized/date': 3.12.2
+      '@internationalized/number': 3.6.7
+      '@tanstack/vue-virtual': 3.13.31(vue@3.5.35(typescript@6.0.3))
+      '@vueuse/core': 14.2.1(vue@3.5.35(typescript@6.0.3))
+      '@vueuse/shared': 14.3.0(vue@3.5.35(typescript@6.0.3))
+      aria-hidden: 1.2.6
+      defu: 6.1.7
+      ohash: 2.0.11
+      vue: 3.5.35(typescript@6.0.3)
+    transitivePeerDependencies:
+      - '@vue/composition-api'
+
+  require-from-string@2.0.2: {}
+
+  reserved-identifiers@1.2.0: {}
+
+  resolve-pkg-maps@1.0.0: {}
+
+  restore-cursor@5.1.0:
+    dependencies:
+      onetime: 7.0.0
+      signal-exit: 4.1.0
+
+  ret@0.1.15: {}
+
+  reusify@1.1.0: {}
+
+  rfdc@1.4.1: {}
+
+  rolldown@1.0.3:
+    dependencies:
+      '@oxc-project/types': 0.133.0
+      '@rolldown/pluginutils': 1.0.1
+    optionalDependencies:
+      '@rolldown/binding-android-arm64': 1.0.3
+      '@rolldown/binding-darwin-arm64': 1.0.3
+      '@rolldown/binding-darwin-x64': 1.0.3
+      '@rolldown/binding-freebsd-x64': 1.0.3
+      '@rolldown/binding-linux-arm-gnueabihf': 1.0.3
+      '@rolldown/binding-linux-arm64-gnu': 1.0.3
+      '@rolldown/binding-linux-arm64-musl': 1.0.3
+      '@rolldown/binding-linux-ppc64-gnu': 1.0.3
+      '@rolldown/binding-linux-s390x-gnu': 1.0.3
+      '@rolldown/binding-linux-x64-gnu': 1.0.3
+      '@rolldown/binding-linux-x64-musl': 1.0.3
+      '@rolldown/binding-openharmony-arm64': 1.0.3
+      '@rolldown/binding-wasm32-wasi': 1.0.3
+      '@rolldown/binding-win32-arm64-msvc': 1.0.3
+      '@rolldown/binding-win32-x64-msvc': 1.0.3
+
+  router@2.2.0:
+    dependencies:
+      debug: 4.4.3
+      depd: 2.0.0
+      is-promise: 4.0.0
+      parseurl: 1.3.3
+      path-to-regexp: 8.4.2
+    transitivePeerDependencies:
+      - supports-color
+
+  run-applescript@7.1.0: {}
+
+  run-parallel@1.2.0:
+    dependencies:
+      queue-microtask: 1.2.3
+
+  safe-buffer@5.2.1: {}
+
+  safer-buffer@2.1.2: {}
+
+  sax@1.2.4: {}
+
+  semver@6.3.1: {}
+
+  semver@7.8.5: {}
+
+  send@1.2.1:
+    dependencies:
+      debug: 4.4.3
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      etag: 1.8.1
+      fresh: 2.0.0
+      http-errors: 2.0.1
+      mime-types: 3.0.2
+      ms: 2.1.3
+      on-finished: 2.4.1
+      range-parser: 1.2.1
+      statuses: 2.0.2
+    transitivePeerDependencies:
+      - supports-color
+
+  serve-static@2.2.1:
+    dependencies:
+      encodeurl: 2.0.0
+      escape-html: 1.0.3
+      parseurl: 1.3.3
+      send: 1.2.1
+    transitivePeerDependencies:
+      - supports-color
+
+  setprototypeof@1.2.0: {}
+
+  shadcn-vue@2.7.4(eslint@10.2.1(jiti@2.7.0))(vue@3.5.35(typescript@6.0.3)):
+    dependencies:
+      '@dotenvx/dotenvx': 1.75.1
+      '@modelcontextprotocol/sdk': 1.29.0(zod@3.25.76)
+      '@unovue/detypes': 0.8.5
+      '@vue/compiler-sfc': 3.5.39
+      c12: 3.3.4
+      commander: 14.0.3
+      consola: 3.4.2
+      dedent: 1.7.2
+      deepmerge: 4.3.1
+      diff: 8.0.4
+      fs-extra: 11.3.6
+      fuzzysort: 3.1.0
+      get-tsconfig: 4.14.0
+      giget: 3.3.0
+      magic-string: 0.30.21
+      nypm: 0.6.8
+      ofetch: 1.5.1
+      open: 10.2.0
+      ora: 9.4.1
+      pathe: 2.0.3
+      postcss: 8.5.16
+      postcss-selector-parser: 7.1.4
+      prompts: 2.4.2
+      reka-ui: 2.10.1(vue@3.5.35(typescript@6.0.3))
+      semver: 7.8.5
+      stringify-object: 6.0.0
+      tailwindcss: 4.3.0
+      tinyexec: 1.2.4
+      tinyglobby: 0.2.17
+      ts-morph: 27.0.2
+      undici: 7.28.0
+      validate-npm-package-name: 5.0.1
+      vue-metamorph: 3.3.4(eslint@10.2.1(jiti@2.7.0))
+      zod: 3.25.76
+      zod-to-json-schema: 3.25.2(zod@3.25.76)
+    transitivePeerDependencies:
+      - '@cfworker/json-schema'
+      - '@vue/composition-api'
+      - babel-plugin-macros
+      - eslint
+      - magicast
+      - supports-color
+      - vue
+
+  shebang-command@2.0.0:
+    dependencies:
+      shebang-regex: 3.0.0
+
+  shebang-regex@3.0.0: {}
+
+  shiki@4.2.0:
+    dependencies:
+      '@shikijs/core': 4.2.0
+      '@shikijs/engine-javascript': 4.2.0
+      '@shikijs/engine-oniguruma': 4.2.0
+      '@shikijs/langs': 4.2.0
+      '@shikijs/themes': 4.2.0
+      '@shikijs/types': 4.2.0
+      '@shikijs/vscode-textmate': 10.0.2
+      '@types/hast': 3.0.4
+
+  side-channel-list@1.0.1:
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.4
+
+  side-channel-map@1.0.1:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      object-inspect: 1.13.4
+
+  side-channel-weakmap@1.0.2:
+    dependencies:
+      call-bound: 1.0.4
+      es-errors: 1.3.0
+      get-intrinsic: 1.3.0
+      object-inspect: 1.13.4
+      side-channel-map: 1.0.1
+
+  side-channel@1.1.0:
+    dependencies:
+      es-errors: 1.3.0
+      object-inspect: 1.13.4
+      side-channel-list: 1.0.1
+      side-channel-map: 1.0.1
+      side-channel-weakmap: 1.0.2
+
+  siginfo@2.0.0: {}
+
+  signal-exit@3.0.7: {}
+
+  signal-exit@4.1.0: {}
+
+  simple-concat@1.0.1: {}
+
+  simple-get@4.0.1:
+    dependencies:
+      decompress-response: 6.0.0
+      once: 1.4.0
+      simple-concat: 1.0.1
+
+  sisteransi@1.0.5: {}
+
+  slice-ansi@4.0.0:
+    dependencies:
+      ansi-styles: 4.3.0
+      astral-regex: 2.0.0
+      is-fullwidth-code-point: 3.0.0
+
+  slice-ansi@7.1.2:
+    dependencies:
+      ansi-styles: 6.2.3
+      is-fullwidth-code-point: 5.1.0
+
+  slice-ansi@8.0.0:
+    dependencies:
+      ansi-styles: 6.2.3
+      is-fullwidth-code-point: 5.1.0
+
+  source-map-js@1.2.1: {}
+
+  source-map-resolve@0.6.0:
+    dependencies:
+      atob: 2.1.2
+      decode-uri-component: 0.2.2
+
+  source-map@0.6.1: {}
+
+  source-map@0.7.6: {}
+
+  space-separated-tokens@2.0.2: {}
+
+  speakingurl@14.0.1: {}
+
+  split2@4.2.0: {}
+
+  splitpanes@4.1.2(vue@3.5.35(typescript@6.0.3)):
+    dependencies:
+      vue: 3.5.35(typescript@6.0.3)
+
+  sql-escaper@1.3.3: {}
+
+  sql-formatter@15.8.0:
+    dependencies:
+      argparse: 2.0.1
+      nearley: 2.20.1
+
+  stackback@0.0.2: {}
+
+  standard-as-callback@2.1.0: {}
+
+  statuses@2.0.2: {}
+
+  std-env@4.1.0: {}
+
+  stdin-discarder@0.3.2: {}
+
+  string-argv@0.3.2: {}
+
+  string-width@4.2.3:
+    dependencies:
+      emoji-regex: 8.0.0
+      is-fullwidth-code-point: 3.0.0
+      strip-ansi: 6.0.1
+
+  string-width@7.2.0:
+    dependencies:
+      emoji-regex: 10.6.0
+      get-east-asian-width: 1.5.0
+      strip-ansi: 7.2.0
+
+  string-width@8.2.1:
+    dependencies:
+      get-east-asian-width: 1.6.0
+      strip-ansi: 7.2.0
+
+  string_decoder@1.3.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  stringify-entities@4.0.4:
+    dependencies:
+      character-entities-html4: 2.1.0
+      character-entities-legacy: 3.0.0
+
+  stringify-object@6.0.0:
+    dependencies:
+      get-own-enumerable-keys: 1.0.0
+      is-identifier: 1.0.1
+      is-obj: 3.0.0
+      is-regexp: 3.1.0
+
+  strip-ansi@6.0.1:
+    dependencies:
+      ansi-regex: 5.0.1
+
+  strip-ansi@7.2.0:
+    dependencies:
+      ansi-regex: 6.2.2
+
+  strip-final-newline@2.0.0: {}
+
+  strip-json-comments@2.0.1: {}
+
+  style-mod@4.1.3: {}
+
+  stylus@0.57.0:
+    dependencies:
+      css: 3.0.0
+      debug: 4.4.3
+      glob: 7.2.3
+      safer-buffer: 2.1.2
+      sax: 1.2.4
+      source-map: 0.7.6
+    transitivePeerDependencies:
+      - supports-color
+
+  super-regex@1.1.0:
+    dependencies:
+      function-timeout: 1.0.2
+      make-asynchronous: 1.1.0
+      time-span: 5.1.0
+
+  superjson@2.2.6:
+    dependencies:
+      copy-anything: 4.0.5
+
+  systeminformation@5.31.11: {}
+
+  table@6.9.0:
+    dependencies:
+      ajv: 8.20.0
+      lodash.truncate: 4.4.2
+      slice-ansi: 4.0.0
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+
+  tailwind-merge@3.6.0: {}
+
+  tailwindcss@4.3.0: {}
+
+  tapable@2.3.3: {}
+
+  tar-fs@2.1.4:
+    dependencies:
+      chownr: 1.1.4
+      mkdirp-classic: 0.5.3
+      pump: 3.0.4
+      tar-stream: 2.2.0
+
+  tar-stream@2.2.0:
+    dependencies:
+      bl: 4.1.0
+      end-of-stream: 1.4.5
+      fs-constants: 1.0.0
+      inherits: 2.0.4
+      readable-stream: 3.6.2
+
+  time-span@5.1.0:
+    dependencies:
+      convert-hrtime: 5.0.0
+
+  tiny-invariant@1.3.3: {}
+
+  tinybench@2.9.0: {}
+
+  tinyexec@1.1.1: {}
+
+  tinyexec@1.2.4: {}
+
+  tinyglobby@0.2.17:
+    dependencies:
+      fdir: 6.5.0(picomatch@4.0.4)
+      picomatch: 4.0.4
+
+  tinypool@2.1.0: {}
+
+  tinyrainbow@3.1.0: {}
+
+  to-regex-range@5.0.1:
+    dependencies:
+      is-number: 7.0.0
+
+  toidentifier@1.0.1: {}
+
+  trim-lines@3.0.1: {}
+
+  ts-morph@27.0.2:
+    dependencies:
+      '@ts-morph/common': 0.28.1
+      code-block-writer: 13.0.3
+
+  tslib@2.3.0: {}
+
+  tslib@2.8.1: {}
+
+  tsx@4.21.0:
+    dependencies:
+      esbuild: 0.27.7
+      get-tsconfig: 4.14.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  tsx@4.22.4:
+    dependencies:
+      esbuild: 0.28.0
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  tunnel-agent@0.6.0:
+    dependencies:
+      safe-buffer: 5.2.1
+
+  tw-animate-css@1.4.0: {}
+
+  type-check@0.4.0:
+    dependencies:
+      prelude-ls: 1.2.1
+
+  type-fest@4.41.0: {}
+
+  type-is@2.0.1:
+    dependencies:
+      content-type: 1.0.5
+      media-typer: 1.1.0
+      mime-types: 3.0.2
+
+  typescript@5.9.3: {}
+
+  typescript@6.0.3: {}
+
+  ufo@1.6.4: {}
+
+  undici-types@6.21.0: {}
+
+  undici-types@7.24.6: {}
+
+  undici@7.28.0: {}
+
+  unist-util-is@6.0.1:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-position@5.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-stringify-position@4.0.0:
+    dependencies:
+      '@types/unist': 3.0.3
+
+  unist-util-visit-parents@6.0.2:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.1
+
+  unist-util-visit@5.1.0:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-is: 6.0.1
+      unist-util-visit-parents: 6.0.2
+
+  universalify@2.0.1: {}
+
+  unpipe@1.0.0: {}
+
+  update-browserslist-db@1.2.3(browserslist@4.28.4):
+    dependencies:
+      browserslist: 4.28.4
+      escalade: 3.2.0
+      picocolors: 1.1.1
+
+  uri-js@4.4.1:
+    dependencies:
+      punycode: 2.3.1
+
+  util-deprecate@1.0.2: {}
+
+  validate-npm-package-name@5.0.1: {}
+
+  vary@1.1.2: {}
+
+  vfile-message@4.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      unist-util-stringify-position: 4.0.0
+
+  vfile@6.0.3:
+    dependencies:
+      '@types/unist': 3.0.3
+      vfile-message: 4.0.3
+
+  vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4):
+    dependencies:
+      lightningcss: 1.32.0
+      picomatch: 4.0.4
+      postcss: 8.5.15
+      rolldown: 1.0.3
+      tinyglobby: 0.2.17
+    optionalDependencies:
+      '@types/node': 25.9.1
+      esbuild: 0.28.0
+      fsevents: 2.3.3
+      jiti: 2.7.0
+      stylus: 0.57.0
+      tsx: 4.22.4
+      yaml: 2.8.4
+
+  vitest@4.1.8(@types/node@25.9.1)(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4)):
+    dependencies:
+      '@vitest/expect': 4.1.8
+      '@vitest/mocker': 4.1.8(vite@8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4))
+      '@vitest/pretty-format': 4.1.8
+      '@vitest/runner': 4.1.8
+      '@vitest/snapshot': 4.1.8
+      '@vitest/spy': 4.1.8
+      '@vitest/utils': 4.1.8
+      es-module-lexer: 2.1.0
+      expect-type: 1.3.0
+      magic-string: 0.30.21
+      obug: 2.1.2
+      pathe: 2.0.3
+      picomatch: 4.0.4
+      std-env: 4.1.0
+      tinybench: 2.9.0
+      tinyexec: 1.1.1
+      tinyglobby: 0.2.17
+      tinyrainbow: 3.1.0
+      vite: 8.0.16(@types/node@25.9.1)(esbuild@0.28.0)(jiti@2.7.0)(stylus@0.57.0)(tsx@4.22.4)(yaml@2.8.4)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/node': 25.9.1
+    transitivePeerDependencies:
+      - msw
+
+  vscode-uri@3.1.0: {}
+
+  vue-demi@0.14.10(vue@3.5.35(typescript@6.0.3)):
+    dependencies:
+      vue: 3.5.35(typescript@6.0.3)
+
+  vue-echarts@8.0.1(echarts@6.1.0)(vue@3.5.35(typescript@6.0.3)):
+    dependencies:
+      echarts: 6.1.0
+      vue: 3.5.35(typescript@6.0.3)
+
+  vue-eslint-parser@10.4.1(eslint@10.2.1(jiti@2.7.0)):
+    dependencies:
+      debug: 4.4.3
+      eslint: 10.2.1(jiti@2.7.0)
+      eslint-scope: 9.1.2
+      eslint-visitor-keys: 5.0.1
+      espree: 11.2.0
+      esquery: 1.7.0
+      semver: 7.8.5
+    transitivePeerDependencies:
+      - supports-color
+
+  vue-i18n@11.4.4(vue@3.5.35(typescript@6.0.3)):
+    dependencies:
+      '@intlify/core-base': 11.4.4
+      '@intlify/devtools-types': 11.4.4
+      '@intlify/shared': 11.4.4
+      '@vue/devtools-api': 6.6.4
+      vue: 3.5.35(typescript@6.0.3)
+
+  vue-metamorph@3.3.4(eslint@10.2.1(jiti@2.7.0)):
+    dependencies:
+      '@babel/parser': 8.0.0-alpha.12
+      ast-types-x: 1.18.0
+      chalk: 5.6.2
+      cli-progress: 3.12.0
+      commander: 14.0.3
+      deep-diff: 1.0.2
+      fs-extra: 11.3.6
+      glob: 11.1.0
+      lodash-es: 4.18.1
+      magic-string: 0.30.21
+      micromatch: 4.0.8
+      node-html-parser: 7.1.0
+      postcss: 8.5.16
+      postcss-less: 6.0.0(postcss@8.5.16)
+      postcss-sass: 0.5.0
+      postcss-scss: 4.0.9(postcss@8.5.16)
+      postcss-styl: 0.12.3
+      recast-x: 1.0.5
+      table: 6.9.0
+      vue-eslint-parser: 10.4.1(eslint@10.2.1(jiti@2.7.0))
+    transitivePeerDependencies:
+      - eslint
+      - supports-color
+
+  vue-tsc@3.3.3(typescript@6.0.3):
+    dependencies:
+      '@volar/typescript': 2.4.28
+      '@vue/language-core': 3.3.3
+      typescript: 6.0.3
+
+  vue-virtual-scroller@3.0.4(vue@3.5.35(typescript@6.0.3)):
+    dependencies:
+      vue: 3.5.35(typescript@6.0.3)
+
+  vue@2.7.16:
+    dependencies:
+      '@vue/compiler-sfc': 2.7.16
+      csstype: 3.2.3
+
+  vue@3.5.35(typescript@6.0.3):
+    dependencies:
+      '@vue/compiler-dom': 3.5.35
+      '@vue/compiler-sfc': 3.5.35
+      '@vue/runtime-dom': 3.5.35
+      '@vue/server-renderer': 3.5.35(vue@3.5.35(typescript@6.0.3))
+      '@vue/shared': 3.5.35
+    optionalDependencies:
+      typescript: 6.0.3
+
+  w3c-keyname@2.2.8: {}
+
+  web-worker@1.5.0: {}
+
+  which@2.0.2:
+    dependencies:
+      isexe: 2.0.0
+
+  which@4.0.0:
+    dependencies:
+      isexe: 3.1.5
+
+  why-is-node-running@2.3.0:
+    dependencies:
+      siginfo: 2.0.0
+      stackback: 0.0.2
+
+  word-wrap@1.2.5: {}
+
+  wrap-ansi@9.0.2:
+    dependencies:
+      ansi-styles: 6.2.3
+      string-width: 7.2.0
+      strip-ansi: 7.2.0
+
+  wrappy@1.0.2: {}
+
+  wsl-utils@0.1.0:
+    dependencies:
+      is-wsl: 3.1.1
+
+  xtend@4.0.2: {}
+
+  yallist@3.1.1: {}
+
+  yaml@2.8.4: {}
+
+  yocto-queue@0.1.0: {}
+
+  yocto-spinner@1.2.0:
+    dependencies:
+      yoctocolors: 2.1.2
+
+  yoctocolors@2.1.2: {}
+
+  zod-to-json-schema@3.25.2(zod@3.25.76):
+    dependencies:
+      zod: 3.25.76
+
+  zod@3.25.76: {}
+
+  zrender@6.1.0:
+    dependencies:
+      tslib: 2.3.0
+
+  zwitch@2.0.4: {}
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
new file mode 100644
index 0000000..5d221fe
--- /dev/null
+++ b/pnpm-workspace.yaml
@@ -0,0 +1,8 @@
+packages:
+  - "packages/*"
+
+allowBuilds:
+  better-sqlite3: true
+  esbuild: true
+  keytar: true
+  vue-demi: false
diff --git a/rustfmt.toml b/rustfmt.toml
new file mode 100644
index 0000000..4a2877a
--- /dev/null
+++ b/rustfmt.toml
@@ -0,0 +1,3 @@
+edition = "2021"
+max_width = 120
+use_small_heuristics = "Max"
diff --git a/scripts/bench/redis-key-search.mjs b/scripts/bench/redis-key-search.mjs
new file mode 100644
index 0000000..796df9e
--- /dev/null
+++ b/scripts/bench/redis-key-search.mjs
@@ -0,0 +1,384 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { performance } from "node:perf_hooks";
+
+const DEFAULTS = {
+  apiBase: "http://127.0.0.1:4224/api",
+  container: "dbx_bench_redis_key_search",
+  image: "redis:7-alpine",
+  host: "127.0.0.1",
+  port: 16151,
+  db: 0,
+  keyCount: 1_000_000,
+  keyPrefix: "user:",
+  pattern: "user:*",
+  scanCount: 10_000,
+  maxIterations: 15,
+  includeTyped: true,
+  json: false,
+};
+
+function parseArgs(argv) {
+  const options = { ...DEFAULTS };
+  for (const arg of argv) {
+    if (arg === "--") continue;
+    const [rawKey, rawValue] = arg.split("=", 2);
+    const key = rawKey.replace(/^--/, "");
+    const value = rawValue ?? "true";
+    switch (key) {
+      case "api-base":
+        options.apiBase = value;
+        break;
+      case "container":
+        options.container = value;
+        break;
+      case "image":
+        options.image = value;
+        break;
+      case "port":
+        options.port = Number.parseInt(value, 10);
+        break;
+      case "key-count":
+        options.keyCount = Number.parseInt(value, 10);
+        break;
+      case "key-prefix":
+        options.keyPrefix = value;
+        break;
+      case "pattern":
+        options.pattern = value;
+        break;
+      case "scan-count":
+        options.scanCount = Number.parseInt(value, 10);
+        break;
+      case "max-iterations":
+        options.maxIterations = Number.parseInt(value, 10);
+        break;
+      case "typed":
+        options.includeTyped = value !== "false";
+        break;
+      case "json":
+        options.json = value !== "false";
+        break;
+      case "help":
+        printHelp();
+        process.exit(0);
+      default:
+        throw new Error(`Unknown option: ${rawKey}`);
+    }
+  }
+  return options;
+}
+
+function printHelp() {
+  console.log(`Redis key search benchmark
+
+Usage:
+  pnpm bench:redis-key-search [options]
+
+Options:
+  --api-base=http://127.0.0.1:4224/api  DBX Web API base URL
+  --container=dbx_bench_redis_key_search Redis Docker container name
+  --port=16151                              Host port for Redis
+  --key-count=1000000                       Number of generated keys
+  --pattern=user:*                          SCAN MATCH pattern
+  --scan-count=10000                        DBX SCAN COUNT value
+  --max-iterations=15                       DBX server-side SCAN iterations per API call
+  --typed=false                             Skip DBX includeTypes=true comparison
+  --json                                    Print JSON only
+
+Before running this benchmark, start DBX Web separately, for example:
+  DBX_DATA_DIR=/tmp/dbx-bench DBX_PORT=4224 DBX_DISABLE_PASSWORD=1 cargo run -p dbx-web
+`);
+}
+
+function assertFinitePositiveInteger(name, value) {
+  if (!Number.isFinite(value) || value <= 0 || Math.trunc(value) !== value) {
+    throw new Error(`${name} must be a positive integer, got ${value}`);
+  }
+}
+
+function run(command, args, options = {}) {
+  const startedAt = performance.now();
+  const child = spawn(command, args, {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: options.stdio ?? ["ignore", "pipe", "pipe"],
+  });
+  const stdout = [];
+  const stderr = [];
+  if (child.stdout) child.stdout.on("data", (chunk) => stdout.push(chunk));
+  if (child.stderr) child.stderr.on("data", (chunk) => stderr.push(chunk));
+  return new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code) => {
+      const result = {
+        code,
+        stdout: Buffer.concat(stdout).toString(),
+        stderr: Buffer.concat(stderr).toString(),
+        elapsedMs: performance.now() - startedAt,
+      };
+      if (code === 0) resolve(result);
+      else reject(new Error(`${command} ${args.join(" ")} failed with ${code}\n${result.stderr || result.stdout}`));
+    });
+  });
+}
+
+async function dockerExec(container, args) {
+  return run("docker", ["exec", container, ...args]);
+}
+
+async function ensureRedisContainer(options) {
+  try {
+    await run("docker", ["inspect", options.container]);
+    await run("docker", ["start", options.container]);
+  } catch {
+    await run("docker", [
+      "run",
+      "-d",
+      "--name",
+      options.container,
+      "-p",
+      `${options.host}:${options.port}:6379`,
+      options.image,
+      "redis-server",
+      "--save",
+      "",
+      "--appendonly",
+      "no",
+    ]);
+  }
+
+  const deadline = Date.now() + 15_000;
+  while (Date.now() < deadline) {
+    try {
+      const pong = (await dockerExec(options.container, ["redis-cli", "PING"])).stdout.trim();
+      if (pong === "PONG") return;
+    } catch {
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+  }
+  throw new Error("Timed out waiting for Redis container");
+}
+
+async function redisDbSize(container) {
+  const out = await dockerExec(container, ["redis-cli", "DBSIZE"]);
+  return Number.parseInt(out.stdout.trim(), 10);
+}
+
+function redisSetCommand(key, value = "1") {
+  const keyBytes = Buffer.byteLength(key);
+  const valueBytes = Buffer.byteLength(value);
+  return `*3\r\n$3\r\nSET\r\n$${keyBytes}\r\n${key}\r\n$${valueBytes}\r\n${value}\r\n`;
+}
+
+async function seedRedis(options) {
+  const currentSize = await redisDbSize(options.container);
+  if (currentSize === options.keyCount) return { skipped: true, elapsedMs: 0 };
+
+  await dockerExec(options.container, ["redis-cli", "FLUSHALL"]);
+
+  const startedAt = performance.now();
+  const child = spawn("docker", ["exec", "-i", options.container, "redis-cli", "--pipe"], {
+    stdio: ["pipe", "pipe", "pipe"],
+  });
+  const stderr = [];
+  child.stderr.on("data", (chunk) => stderr.push(chunk));
+
+  const width = Math.max(7, String(options.keyCount - 1).length);
+  for (let index = 0; index < options.keyCount; index += 1) {
+    const key = `${options.keyPrefix}${String(index).padStart(width, "0")}`;
+    if (!child.stdin.write(redisSetCommand(key))) {
+      await new Promise((resolve) => child.stdin.once("drain", resolve));
+    }
+  }
+  child.stdin.end();
+
+  await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`redis-cli --pipe failed with ${code}\n${Buffer.concat(stderr).toString()}`));
+    });
+  });
+
+  return { skipped: false, elapsedMs: performance.now() - startedAt };
+}
+
+async function measureRedisCliScan(options) {
+  const startedAt = performance.now();
+  const child = spawn("docker", ["exec", options.container, "redis-cli", "--scan", "--pattern", options.pattern], {
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  let count = 0;
+  let pending = "";
+  const stderr = [];
+
+  child.stdout.on("data", (chunk) => {
+    pending += chunk.toString();
+    const lines = pending.split(/\r?\n/);
+    pending = lines.pop() ?? "";
+    count += lines.filter(Boolean).length;
+  });
+  child.stderr.on("data", (chunk) => stderr.push(chunk));
+
+  await new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (pending.trim()) count += 1;
+      if (code === 0) resolve();
+      else reject(new Error(`redis-cli --scan failed with ${code}\n${Buffer.concat(stderr).toString()}`));
+    });
+  });
+
+  return { label: "redis-cli --scan", keys: count, elapsedMs: performance.now() - startedAt };
+}
+
+async function postJsonText(url, body) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  if (!response.ok) throw new Error(`${url} ${response.status}\n${text}`);
+  return { text, json: JSON.parse(text) };
+}
+
+async function ensureDbxConnection(options) {
+  const connectionId = `bench-redis-key-search-${options.port}`;
+  const config = {
+    id: connectionId,
+    name: `Bench Redis Key Search ${options.port}`,
+    db_type: "redis",
+    host: options.host,
+    port: options.port,
+    username: "",
+    password: "",
+    database: String(options.db),
+    auth_database: "",
+    ssl: false,
+    redis_key_separator: ":",
+    connection_timeout: 10,
+    connect_timeout_secs: 10,
+  };
+
+  await postJsonText(`${options.apiBase}/connection/save`, { configs: [config] });
+  await postJsonText(`${options.apiBase}/connection/connect`, { config });
+  return connectionId;
+}
+
+async function measureDbxScan(options, connectionId, includeTypes) {
+  let cursor = 0;
+  let calls = 0;
+  let keys = 0;
+  let payloadBytes = 0;
+  const startedAt = performance.now();
+
+  do {
+    const { text, json } = await postJsonText(`${options.apiBase}/redis/scan-keys-batch`, {
+      connectionId,
+      db: options.db,
+      cursor,
+      pattern: options.pattern,
+      count: options.scanCount,
+      maxIterations: options.maxIterations,
+      includeTypes,
+    });
+    payloadBytes += Buffer.byteLength(text);
+    cursor = json.cursor;
+    keys += json.keys.length;
+    calls += 1;
+  } while (cursor !== 0);
+
+  return {
+    label: includeTypes ? "DBX scan-keys-batch includeTypes=true" : "DBX scan-keys-batch includeTypes=false",
+    keys,
+    calls,
+    payloadBytes,
+    elapsedMs: performance.now() - startedAt,
+  };
+}
+
+function formatMs(ms) {
+  return `${Math.round(ms)}ms`;
+}
+
+function formatBytes(bytes) {
+  if (!bytes) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  return `${value.toFixed(unit === 0 ? 0 : 1)} ${units[unit]}`;
+}
+
+function printReport(result) {
+  console.log("# Redis key search benchmark");
+  console.log("");
+  console.log(`- API: ${result.config.apiBase}`);
+  console.log(`- Redis: ${result.config.container} on ${result.config.host}:${result.config.port}`);
+  console.log(`- Keys: ${result.config.keyCount}`);
+  console.log(`- Pattern: ${result.config.pattern}`);
+  console.log(`- DBX scan count: ${result.config.scanCount}`);
+  console.log(`- DBX max iterations: ${result.config.maxIterations}`);
+  console.log(`- Seed: ${result.seed.skipped ? "reused existing dataset" : `loaded in ${formatMs(result.seed.elapsedMs)}`}`);
+  console.log("");
+  console.log("| Case | Keys | Calls | Payload | Time |");
+  console.log("| --- | ---: | ---: | ---: | ---: |");
+  for (const row of result.measurements) {
+    console.log(`| ${row.label} | ${row.keys} | ${row.calls ?? "-"} | ${row.payloadBytes ? formatBytes(row.payloadBytes) : "-"} | ${formatMs(row.elapsedMs)} |`);
+  }
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  assertFinitePositiveInteger("port", options.port);
+  assertFinitePositiveInteger("key-count", options.keyCount);
+  assertFinitePositiveInteger("scan-count", options.scanCount);
+  assertFinitePositiveInteger("max-iterations", options.maxIterations);
+
+  if (!options.json) {
+    console.log("Preparing Redis benchmark dataset...");
+  }
+  await ensureRedisContainer(options);
+  const seed = await seedRedis(options);
+
+  if (!options.json) {
+    console.log("Connecting DBX Web API...");
+  }
+  const connectionId = await ensureDbxConnection(options);
+
+  const measurements = [];
+  measurements.push(await measureRedisCliScan(options));
+  measurements.push(await measureDbxScan(options, connectionId, false));
+  if (options.includeTyped) {
+    measurements.push(await measureDbxScan(options, connectionId, true));
+  }
+
+  const result = {
+    config: {
+      apiBase: options.apiBase,
+      container: options.container,
+      host: options.host,
+      port: options.port,
+      keyCount: options.keyCount,
+      pattern: options.pattern,
+      scanCount: options.scanCount,
+      maxIterations: options.maxIterations,
+    },
+    seed,
+    measurements,
+    generatedAt: new Date().toISOString(),
+  };
+
+  if (options.json) console.log(JSON.stringify(result, null, 2));
+  else printReport(result);
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.stack || error.message : String(error));
+  process.exit(1);
+});
diff --git a/scripts/build-knowledge-base.mjs b/scripts/build-knowledge-base.mjs
new file mode 100644
index 0000000..10aaa97
--- /dev/null
+++ b/scripts/build-knowledge-base.mjs
@@ -0,0 +1,278 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const DEFAULT_INPUT = "docs/content/docs";
+const DEFAULT_OUTPUT = "outputs/knowledge-base/DBX_knowledge_base_cn.md";
+const DEFAULT_LANG = "cn";
+
+await main();
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const inputDir = path.resolve(args.input ?? DEFAULT_INPUT);
+  const outputFile = path.resolve(args.output ?? DEFAULT_OUTPUT);
+  const lang = args.lang ?? DEFAULT_LANG;
+  const fileSuffix = lang ? `.${lang}.mdx` : ".mdx";
+
+  const files = (await fs.readdir(inputDir))
+    .filter((name) => name.endsWith(fileSuffix))
+    .sort((a, b) => a.localeCompare(b));
+
+  if (files.length === 0) {
+    throw new Error(`No ${fileSuffix} files found in ${inputDir}`);
+  }
+
+  const documents = [];
+  let entryCount = 0;
+
+  for (const file of files) {
+    const sourcePath = path.join(inputDir, file);
+    const displayPath = path.relative(process.cwd(), sourcePath).replaceAll(path.sep, "/");
+    const raw = await fs.readFile(sourcePath, "utf8");
+    const { fields, body } = parseFrontmatter(raw);
+    const title = fields.title || file.replace(/\.mdx$/, "");
+    const description = fields.description || "";
+    const sections = [];
+
+    for (const section of splitSections(body)) {
+      const clean = normalizeMdx(section.lines.join("\n"));
+      if (!clean || clean.length < 20) continue;
+
+      const chunks = chunkText(clean).map((chunk, index, all) => {
+        const heading = all.length > 1 ? `${section.heading}（${index + 1}/${all.length}）` : section.heading;
+        return {
+          heading,
+          question: questionFor(title, section.heading, chunk),
+          keywords: keywordsFor(title, section.heading, description, chunk),
+          answer: chunk,
+        };
+      });
+
+      entryCount += chunks.length;
+      sections.push(...chunks);
+    }
+
+    documents.push({ source: displayPath, title, description, sections });
+  }
+
+  await fs.mkdir(path.dirname(outputFile), { recursive: true });
+  await fs.writeFile(outputFile, renderMarkdown(documents), "utf8");
+
+  console.log(`Knowledge base written: ${path.relative(process.cwd(), outputFile)}`);
+  console.log(`Sources: ${files.length}`);
+  console.log(`Entries: ${entryCount}`);
+}
+
+function parseArgs(argv) {
+  const parsed = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--help" || arg === "-h") {
+      printHelp();
+      process.exit(0);
+    }
+    if (!arg.startsWith("--")) {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+    const key = arg.slice(2);
+    const value = argv[index + 1];
+    if (!value || value.startsWith("--")) {
+      throw new Error(`Missing value for ${arg}`);
+    }
+    parsed[key] = value;
+    index += 1;
+  }
+  return parsed;
+}
+
+function printHelp() {
+  console.log(`Usage: node scripts/build-knowledge-base.mjs [options]
+
+Options:
+  --input <dir>      MDX docs directory. Default: ${DEFAULT_INPUT}
+  --output <file>    Output Markdown path. Default: ${DEFAULT_OUTPUT}
+  --lang <suffix>    File language suffix, e.g. cn for *.cn.mdx. Default: ${DEFAULT_LANG}
+`);
+}
+
+function parseFrontmatter(source) {
+  const match = source.match(/^---\n([\s\S]*?)\n---\n?/);
+  const fields = {};
+  if (!match) return { fields, body: source };
+
+  for (const line of match[1].split("\n")) {
+    const separator = line.indexOf(":");
+    if (separator === -1) continue;
+    const key = line.slice(0, separator).trim();
+    const value = line.slice(separator + 1).trim().replace(/^["']|["']$/g, "");
+    fields[key] = value;
+  }
+
+  return { fields, body: source.slice(match[0].length) };
+}
+
+function splitSections(body) {
+  const sections = [];
+  let current = { heading: "概览", lines: [] };
+
+  for (const line of body.split("\n")) {
+    const heading = line.match(/^(#{2,3})\s+(.+?)\s*$/);
+    if (heading) {
+      if (current.lines.join("\n").trim()) sections.push(current);
+      current = { heading: heading[2].replace(/`/g, "").trim(), lines: [] };
+      continue;
+    }
+    current.lines.push(line);
+  }
+
+  if (current.lines.join("\n").trim()) sections.push(current);
+  return sections;
+}
+
+function normalizeMdx(text) {
+  return text
+    .replace(/<Card\s+([^>]*)>([\s\S]*?)<\/Card>/g, (_, attrs, inner) => {
+      const title = attrs.match(/title=["']([^"']+)["']/)?.[1] ?? "";
+      const href = attrs.match(/href=["']([^"']+)["']/)?.[1] ?? "";
+      return [title && `**${title}**`, normalizeMdx(inner), href && `参考链接：${href}`].filter(Boolean).join("\n\n");
+    })
+    .replace(/<Callout[^>]*>([\s\S]*?)<\/Callout>/g, (_, inner) => normalizeMdx(inner))
+    .replace(/<Tab[^>]*>([\s\S]*?)<\/Tab>/g, (_, inner) => normalizeMdx(inner))
+    .replace(/<Step[^>]*>([\s\S]*?)<\/Step>/g, (_, inner) => normalizeMdx(inner))
+    .replace(/<[^>\n]+>/g, "")
+    .replace(/\{\/\*[\s\S]*?\*\/\}/g, "")
+    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1（$2）")
+    .replace(/^\s{0,6}#{1,6}\s+(.+)$/gm, "$1")
+    .replace(/^\s*import\s+.*$/gm, "")
+    .replace(/^\s*export\s+.*$/gm, "")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function chunkText(text, maxLength = 2200) {
+  if (text.length <= maxLength) return [text];
+
+  const chunks = [];
+  let current = "";
+  for (const paragraph of text.split(/\n{2,}/)) {
+    const next = [current, paragraph].filter(Boolean).join("\n\n");
+    if (next.length > maxLength && current) {
+      chunks.push(current);
+      current = paragraph;
+    } else {
+      current = next;
+    }
+  }
+  if (current) chunks.push(current);
+
+  return chunks.flatMap((chunk) => {
+    if (chunk.length <= maxLength) return [chunk];
+    const pieces = [];
+    for (let index = 0; index < chunk.length; index += maxLength) {
+      pieces.push(chunk.slice(index, index + maxLength));
+    }
+    return pieces;
+  });
+}
+
+function questionFor(category, heading, text) {
+  if (heading === "概览") return `DBX 的${category}是什么？`;
+  if (/安装|配置|导入|导出|创建|连接|使用流程|快速开始|启动|构建|下载|打开|执行|添加|删除|更新/.test(heading)) {
+    return `DBX 中如何${heading.replace(/^(第一步|第二步|第三步|第四步|第五步)：/, "")}？`;
+  }
+  if (/常见|问题|故障|错误|诊断|冲突|无法/.test(heading) || /失败|报错|检查/.test(text)) {
+    return `DBX ${heading}时应该检查什么？`;
+  }
+  if (/支持|覆盖|矩阵|类型|数据库|文件|供应商|快捷键|命令|端口/.test(heading)) {
+    return `DBX ${heading}支持哪些内容？`;
+  }
+  return `DBX 的${heading}是什么？`;
+}
+
+function keywordsFor(category, heading, description, text) {
+  const pool = `${category} ${heading} ${description} ${text}`;
+  const candidates = [
+    "DBX",
+    "AI",
+    "SQL",
+    "MCP",
+    "JDBC",
+    "SSH",
+    "Docker",
+    "CLI",
+    "MongoDB",
+    "Redis",
+    "MySQL",
+    "PostgreSQL",
+    "SQLite",
+    "DuckDB",
+    "ClickHouse",
+    "Oracle",
+    "SQL Server",
+    "Schema",
+    "ER",
+    "导入",
+    "导出",
+    "连接",
+    "表",
+    "字段",
+    "查询",
+    "快捷键",
+    "插件",
+    "驱动",
+    "配置",
+    "安全",
+    "数据传输",
+    "格式化",
+    "代码片段",
+    "隧道",
+    "生产环境",
+  ];
+  const found = candidates.filter((word) => pool.includes(word));
+  return [...new Set([category, heading, ...found])].slice(0, 14).join(", ");
+}
+
+function renderMarkdown(documents) {
+  const lines = [
+    "# DBX 中文知识库",
+    "",
+    "> 从 `docs/content/docs/*.cn.mdx` 生成的纯 Markdown 知识库内容。",
+    "",
+    "## 来源索引",
+    "",
+    "| 来源文件 | 标题 | 描述 | 知识条数 |",
+    "| --- | --- | --- | ---: |",
+  ];
+
+  for (const document of documents) {
+    lines.push(
+      `| ${escapeTableCell(document.source)} | ${escapeTableCell(document.title)} | ${escapeTableCell(document.description)} | ${document.sections.length} |`,
+    );
+  }
+
+  for (const document of documents) {
+    lines.push("", `## ${document.title}`, "");
+    if (document.description) lines.push(document.description, "");
+    lines.push(`来源：\`${document.source}\``, "");
+
+    for (const section of document.sections) {
+      lines.push(`### ${section.heading}`, "");
+      lines.push(`问题：${section.question}`, "");
+      lines.push(`关键词：${section.keywords}`, "");
+      lines.push("答案：", "");
+      lines.push(section.answer, "");
+      lines.push("---", "");
+    }
+  }
+
+  return `${lines.join("\n").replace(/\n{4,}/g, "\n\n\n").trim()}\n`;
+}
+
+function escapeTableCell(value) {
+  return String(value ?? "")
+    .replaceAll("\\", "\\\\")
+    .replaceAll("|", "\\|")
+    .replace(/\s+/g, " ")
+    .trim();
+}
diff --git a/scripts/check-mq-integration.mjs b/scripts/check-mq-integration.mjs
new file mode 100644
index 0000000..0d3d26c
--- /dev/null
+++ b/scripts/check-mq-integration.mjs
@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+
+const root = path.resolve(import.meta.dirname, "..");
+const read = (file) => fs.readFileSync(path.join(root, file), "utf8");
+
+function assertIncludes(file, needle, message) {
+  assert.ok(read(file).includes(needle), `${message}\nMissing ${needle} in ${file}`);
+}
+
+function assertMatches(file, pattern, message) {
+  assert.match(read(file), pattern, `${message}\nPattern ${pattern} not found in ${file}`);
+}
+
+assertMatches("src-tauri/Cargo.toml", /mq-admin\s*=\s*\[[^\]]*"dbx-core\/mq-admin"[^\]]*\]/, "Tauri crate must expose an mq-admin feature that enables dbx-core/mq-admin.");
+assertMatches("src-tauri/Cargo.toml", /default\s*=\s*\[[^\]]*"mq-admin"[^\]]*\]/, "Tauri default features must include mq-admin so desktop commands are registered.");
+assertMatches("crates/dbx-web/Cargo.toml", /\[features\][\s\S]*mq-admin\s*=\s*\[[^\]]*"dbx-core\/mq-admin"[^\]]*\]/, "Web crate must expose an mq-admin feature that enables dbx-core/mq-admin.");
+assertMatches("crates/dbx-web/Cargo.toml", /\[features\][\s\S]*default\s*=\s*\[[^\]]*"mq-admin"[^\]]*\]/, "Web default features must include mq-admin so web routes are registered.");
+
+assertIncludes("apps/desktop/src/components/layout/ContentArea.vue", "MqAdminConsole", "Main content area must import and render the MQ admin console.");
+assertIncludes("apps/desktop/src/components/layout/ContentArea.vue", "activeTab.mode === 'mq'", "Main content area must have an mq mode render branch.");
+assertIncludes("apps/desktop/src/components/sidebar/TreeItem.vue", '"mq"', "Sidebar connection handling must be aware of MQ connections.");
+assertIncludes("apps/desktop/src/stores/queryStore.ts", "openMqAdmin", "Query store must expose an MQ admin tab opener.");
+
+const manifest = JSON.parse(read("crates/dbx-core/assets/database-drivers.manifest.json"));
+const drivers = Array.isArray(manifest) ? manifest : manifest.drivers;
+assert.ok(drivers?.some((driver) => driver.dbType === "mq"), "Driver manifest must include dbType=mq.");
+
+const mqHttp = read("apps/desktop/src/lib/mq-http.ts");
+assert.ok(!mqHttp.includes('post("/mq/'), "MQ HTTP client must not call unprefixed /mq paths.");
+assert.ok(mqHttp.includes('post("/api/mq/'), "MQ HTTP client must call /api/mq paths in web mode.");
+
+assertIncludes("apps/desktop/src/lib/api.ts", 'mqTestConnection = forward("mqTestConnection")', "MQ frontend calls must use the shared forward() API layer.");
+assertIncludes("apps/desktop/src/components/connection/ConnectionDialog.vue", "mqAdminUrl", "Connection dialog must include MQ admin URL fields.");
+assertIncludes("apps/desktop/src/components/connection/ConnectionDialog.vue", "external_config", "Connection dialog must submit MQ external_config.");
+
+const mqConsole = read("apps/desktop/src/components/mq/MqAdminConsole.vue");
+for (const tab of ["policies", "permissions", "raw"]) {
+  assert.ok(mqConsole.includes(`'${tab}'`), `MQ console must expose a ${tab} tab.`);
+}
+for (const panel of ["PoliciesPanel.vue", "PermissionsPanel.vue", "RawApiPanel.vue"]) {
+  assert.ok(fs.existsSync(path.join(root, "apps/desktop/src/components/mq", panel)), `Missing MQ panel: ${panel}`);
+  assertIncludes(`apps/desktop/src/components/mq/${panel}`, "readOnly", `${panel} must honor read-only mode.`);
+}
+for (const panel of ["TenantsPanel.vue", "NamespacesPanel.vue", "TopicsPanel.vue", "SubscriptionsPanel.vue"]) {
+  assertIncludes(`apps/desktop/src/components/mq/${panel}`, "readOnly", `${panel} must disable mutating actions in read-only mode.`);
+}
+
+console.log("MQ integration checks passed");
diff --git a/scripts/dev-backend.mjs b/scripts/dev-backend.mjs
new file mode 100644
index 0000000..3c0d625
--- /dev/null
+++ b/scripts/dev-backend.mjs
@@ -0,0 +1,54 @@
+import { spawn } from "node:child_process";
+
+const env = {
+  ...process.env,
+  RUST_LOG: process.env.RUST_LOG || "info",
+};
+
+const hasCargoWatch = await commandSucceeds("cargo", ["watch", "--version"]);
+
+if (!hasCargoWatch) {
+  console.warn(
+    "cargo-watch is not installed; running dbx-web without hot reload. Install with: cargo install cargo-watch",
+  );
+}
+
+const args = hasCargoWatch ? ["watch", "-x", "run -p dbx-web"] : ["run", "-p", "dbx-web"];
+const child = spawn("cargo", args, {
+  cwd: process.cwd(),
+  env,
+  stdio: "inherit",
+});
+
+// Keep signal handling in Node so Windows does not have to parse nested shell quotes.
+for (const signal of ["SIGINT", "SIGTERM"]) {
+  process.on(signal, () => {
+    child.kill(signal);
+  });
+}
+
+child.on("error", (error) => {
+  console.error(error.stack ?? String(error));
+  process.exit(1);
+});
+
+child.on("close", (code, signal) => {
+  if (signal) {
+    process.kill(process.pid, signal);
+    return;
+  }
+  process.exit(code ?? 1);
+});
+
+function commandSucceeds(command, args) {
+  const child = spawn(command, args, {
+    cwd: process.cwd(),
+    env,
+    stdio: "ignore",
+  });
+
+  return new Promise((resolve) => {
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+  });
+}
diff --git a/scripts/release-node-packages.mjs b/scripts/release-node-packages.mjs
new file mode 100644
index 0000000..6af92e5
--- /dev/null
+++ b/scripts/release-node-packages.mjs
@@ -0,0 +1,9 @@
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const releaseScript = fileURLToPath(new URL("./release.mjs", import.meta.url));
+const result = spawnSync(process.execPath, [releaseScript, "packages", ...process.argv.slice(2)], {
+  stdio: "inherit",
+});
+
+process.exit(result.status ?? 1);
diff --git a/scripts/release.mjs b/scripts/release.mjs
new file mode 100644
index 0000000..8788068
--- /dev/null
+++ b/scripts/release.mjs
@@ -0,0 +1,553 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+
+const REPO = "t8y2/dbx";
+const PACKAGES_WORKFLOW = "mcp-release.yml";
+const APP_PUBLISH_WORKFLOW = "publish-packages.yml";
+const PACKAGE_TAG_PREFIX = "packages-v";
+const AGENT_TAG_PREFIX = "agents-v";
+const APP_TAG_PREFIX = "v";
+const PACKAGE_RELEASE_PATHS = [
+  "packages/node-core/src/",
+  "packages/node-core/README.md",
+  "packages/node-core/package.json",
+  "packages/node-core/tsconfig.json",
+  "packages/cli/src/",
+  "packages/cli/README.md",
+  "packages/cli/package.json",
+  "packages/cli/tsconfig.json",
+  "packages/mcp-server/src/",
+  "packages/mcp-server/README.md",
+  "packages/mcp-server/package.json",
+  "packages/mcp-server/server.json",
+  "packages/mcp-server/tsconfig.json",
+];
+const AGENT_RELEASE_PATHS = [
+  "agents/build.gradle",
+  "agents/settings.gradle",
+  "agents/versions.json",
+  "agents/common/build.gradle",
+  "agents/common/src/main/",
+  "agents/drivers/",
+  "agents/opengauss/",
+];
+
+const args = process.argv.slice(2);
+let target = null;
+let requestedBump = null;
+let dryRun = false;
+let yes = false;
+let skipFetch = false;
+let force = false;
+
+// NO_COLOR (https://no-color.org) wins, then FORCE_COLOR, then autodetect TTY.
+const USE_COLOR = !process.env.NO_COLOR && (process.stdout.isTTY || (process.env.FORCE_COLOR && process.env.FORCE_COLOR !== "0"));
+function ansi(code, text) {
+  return USE_COLOR ? `\x1b[${code}m${text}\x1b[0m` : text;
+}
+const bold = (s) => ansi(1, s);
+const dim = (s) => ansi(2, s);
+const cyan = (s) => ansi(36, s);
+const green = (s) => ansi(32, s);
+const yellow = (s) => ansi(33, s);
+const red = (s) => ansi(31, s);
+const magenta = (s) => ansi(35, s);
+// `Label: value` with a dimmed label and a colored value.
+function kv(label, value, color = cyan) {
+  return `${dim(label)}: ${color(value)}`;
+}
+
+for (const arg of args) {
+  switch (arg) {
+    case "--":
+      break;
+    case "--dry-run":
+      dryRun = true;
+      break;
+    case "-y":
+    case "--yes":
+      yes = true;
+      break;
+    case "--skip-fetch":
+      skipFetch = true;
+      break;
+    case "--force":
+      force = true;
+      break;
+    case "-h":
+    case "--help":
+      printHelp();
+      process.exit(0);
+      break;
+    default: {
+      const normalizedTarget = normalizeTarget(arg);
+      if (!target && normalizedTarget) {
+        target = normalizedTarget;
+      } else if (!requestedBump) {
+        requestedBump = arg;
+      } else {
+        fail(`Unexpected argument: ${arg}`);
+      }
+      break;
+    }
+  }
+}
+
+const repoRoot = run("git", ["rev-parse", "--show-toplevel"]).stdout.trim();
+process.chdir(repoRoot);
+
+if (!skipFetch) {
+  fetchReleaseTags();
+}
+
+if (!target) {
+  if (!process.stdin.isTTY) {
+    fail("Release target is required in a non-interactive shell. Use packages, agents, or app.");
+  }
+  target = await promptTarget();
+}
+
+if (target === "packages") {
+  await releasePackages(requestedBump ?? "patch");
+} else if (target === "agents") {
+  await releaseAgents(requestedBump ?? "patch");
+} else if (target === "app") {
+  await publishApp(requestedBump);
+} else {
+  fail(`Unknown release target: ${target}`);
+}
+
+async function releasePackages(bump) {
+  const status = getPackageReleaseStatus();
+  const latestVersion = status.latestVersion ?? getLatestPackageVersion();
+  const releaseVersion = resolveReleaseVersion(bump, latestVersion, PACKAGE_TAG_PREFIX);
+  const releaseTag = `${PACKAGE_TAG_PREFIX}${releaseVersion}`;
+  const workflowArgs = ["workflow", "run", PACKAGES_WORKFLOW, "--repo", REPO, "-f", `version=${releaseVersion}`];
+
+  console.log(kv("Release target", "Node packages / MCP", bold));
+  console.log(kv("Current package version", latestVersion ?? "none", green));
+  printReleaseStatus(status);
+  if (!status.needed && !force) {
+    console.log(yellow("No Node package release needed; publish-relevant package files have not changed."));
+    console.log(dim("Use --force to trigger the workflow anyway."));
+    return;
+  }
+  console.log(kv("New package version", releaseVersion, green));
+  console.log(kv("Release tag", releaseTag, yellow));
+  console.log(kv("Workflow", `Node Packages Release (${PACKAGES_WORKFLOW})`, magenta));
+  console.log(kv("Command", `gh ${workflowArgs.join(" ")}`, dim));
+
+  if (dryRun) {
+    console.log(dim("Dry run only; workflow was not triggered."));
+    return;
+  }
+
+  ensureGhReady(PACKAGES_WORKFLOW);
+  await confirmOrExit(`Confirm triggering Node Packages Release for ${bold(releaseVersion)}? [y/N] `);
+
+  run("gh", workflowArgs, { stdio: "inherit" });
+  console.log(green(`Triggered Node Packages Release for ${releaseVersion}.`));
+}
+
+async function releaseAgents(bump) {
+  const latest = getLatestAgentTag();
+  const status = getAgentReleaseStatus(latest);
+  const releaseTag = resolveAgentTag(bump, latest.tag);
+
+  if (tagExists(releaseTag)) {
+    fail(`Tag ${releaseTag} already exists.`);
+  }
+
+  console.log(kv("Release target", "Agents", bold));
+  console.log(kv("Current agent tag", `${latest.tag}${latest.source ? ` (${latest.source})` : ""}`, yellow));
+  printReleaseStatus(status);
+  if (!status.needed && !force) {
+    console.log(yellow("No agents release needed; publish-relevant agent runtime files have not changed."));
+    console.log(dim("Use --force to create the tag anyway."));
+    return;
+  }
+  console.log(kv("New agent tag", releaseTag, yellow));
+  console.log(kv("Workflow", "Agents Release (.github/workflows/agents-release.yml)", magenta));
+  console.log(kv("Commands", `git tag ${releaseTag} && git push origin ${releaseTag}`, dim));
+
+  if (dryRun) {
+    console.log(dim("Dry run only; tag was not created or pushed."));
+    return;
+  }
+
+  await confirmOrExit(`Confirm creating and pushing tag ${bold(releaseTag)}? [y/N] `);
+
+  run("git", ["tag", releaseTag], { stdio: "inherit" });
+  run("git", ["push", "origin", releaseTag], { stdio: "inherit" });
+  console.log(green(`Pushed ${releaseTag}; Agents Release will run from the tag push.`));
+}
+
+async function publishApp(tagInput) {
+  const latest = getLatestAppTag();
+  const releaseTag = tagInput ? resolveAppTag(tagInput) : latest.tag;
+  const workflowArgs = ["workflow", "run", APP_PUBLISH_WORKFLOW, "--repo", REPO, "-f", `tag=${releaseTag}`];
+
+  console.log(kv("Release target", "App distribution", bold));
+  console.log(kv("Latest app tag", latest.tag, yellow));
+  console.log(kv("Publish tag", releaseTag, yellow));
+  console.log(kv("Workflow", `Publish Packages (${APP_PUBLISH_WORKFLOW})`, magenta));
+  console.log(kv("Command", `gh ${workflowArgs.join(" ")}`, dim));
+
+  if (dryRun) {
+    console.log(dim("Dry run only; workflow was not triggered."));
+    return;
+  }
+
+  ensureGhReady(APP_PUBLISH_WORKFLOW);
+  run("gh", ["release", "view", releaseTag, "--repo", REPO], { stdio: "inherit" });
+  await confirmOrExit(`Confirm publishing app distribution for ${bold(releaseTag)}? [y/N] `);
+
+  run("gh", workflowArgs, { stdio: "inherit" });
+  console.log(green(`Triggered Publish Packages for ${releaseTag}.`));
+}
+
+async function promptTarget() {
+  const packageStatus = getPackageReleaseStatus();
+  const agentStatus = getAgentReleaseStatus(getLatestAgentTag());
+  const answer = await ask(`${bold("Select release target:")}
+  ${cyan("1")}. Node packages / MCP (${formatStatusSummary(packageStatus)})
+  ${cyan("2")}. Agents (${formatStatusSummary(agentStatus)})
+  ${cyan("3")}. App distribution
+${dim("Choice")} [1]: `);
+
+  const normalized = answer.trim().toLowerCase();
+  if (!normalized || normalized === "1" || normalized === "packages" || normalized === "mcp") return "packages";
+  if (normalized === "2" || normalized === "agents" || normalized === "agent") return "agents";
+  if (normalized === "3" || normalized === "app" || normalized === "desktop" || normalized === "publish") return "app";
+  fail(`Unknown release target: ${answer}`);
+}
+
+async function confirmOrExit(message) {
+  if (yes) return;
+  if (!process.stdin.isTTY) {
+    fail("Refusing to trigger release without confirmation in a non-interactive shell. Re-run with --yes if this is intentional.");
+  }
+
+  const answer = await ask(message);
+  if (!["y", "yes"].includes(answer.trim().toLowerCase())) {
+    console.log(dim("Cancelled."));
+    process.exit(0);
+  }
+}
+
+async function ask(question) {
+  const rl = createInterface({ input, output });
+  const answer = await rl.question(question);
+  rl.close();
+  return answer;
+}
+
+function normalizeTarget(value) {
+  if (["package", "packages", "node-packages", "node", "mcp"].includes(value)) return "packages";
+  if (["agent", "agents"].includes(value)) return "agents";
+  if (["app", "desktop", "publish", "publish-packages", "distribution"].includes(value)) return "app";
+  return null;
+}
+
+function getLatestPackageVersion() {
+  const tag = getLatestSemverTag(PACKAGE_TAG_PREFIX);
+  if (tag) return tag.versionText;
+
+  const packageVersions = [
+    "packages/node-core/package.json",
+    "packages/cli/package.json",
+    "packages/mcp-server/package.json",
+  ].map((path) => JSON.parse(readFileSync(path, "utf8")).version);
+
+  const uniqueVersions = [...new Set(packageVersions)];
+  if (uniqueVersions.length !== 1) {
+    fail(`Package versions differ and no ${PACKAGE_TAG_PREFIX} tag was found: ${uniqueVersions.join(", ")}`);
+  }
+
+  return uniqueVersions[0];
+}
+
+function getPackageReleaseStatus() {
+  const latest = getLatestSemverTag(PACKAGE_TAG_PREFIX);
+  if (!latest) {
+    return {
+      needed: true,
+      baseline: "no packages-v* tag",
+      latestVersion: getLatestPackageVersion(),
+      changedFiles: [],
+      reason: "No previous package release tag was found.",
+    };
+  }
+
+  const changedFiles = getChangedFilesSince(latest.tag, PACKAGE_RELEASE_PATHS);
+  return {
+    needed: changedFiles.length > 0,
+    baseline: latest.tag,
+    latestVersion: latest.versionText,
+    changedFiles,
+  };
+}
+
+function getLatestAgentTag() {
+  const tag = getLatestSemverTag(AGENT_TAG_PREFIX);
+  if (tag) return { tag: tag.tag, source: "current repo" };
+
+  const legacyRepo = "../dbx-agents";
+  const legacyRepoCheck = spawnSync("git", ["-C", legacyRepo, "rev-parse", "--is-inside-work-tree"], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    stdio: "pipe",
+  });
+
+  if (legacyRepoCheck.status === 0) {
+    const legacyTags = run("git", ["-C", legacyRepo, "tag", "--list", "v*"]).stdout
+      .split(/\r?\n/)
+      .map((legacyTag) => legacyTag.trim())
+      .filter(Boolean)
+      .map((legacyTag) => ({ legacyTag, version: parseVersion(legacyTag.replace(/^v/, "")) }))
+      .filter((entry) => entry.version)
+      .sort((a, b) => compareVersions(b.version, a.version));
+
+    if (legacyTags.length > 0) {
+      return {
+        tag: `${AGENT_TAG_PREFIX}${formatVersion(legacyTags[0].version)}`,
+        source: `${legacyRepo} ${legacyTags[0].legacyTag}`,
+      };
+    }
+  }
+
+  return { tag: `${AGENT_TAG_PREFIX}0.0.0`, source: "initial baseline" };
+}
+
+function getAgentReleaseStatus(latest = getLatestAgentTag()) {
+  if (!refExists(`refs/tags/${latest.tag}`)) {
+    return {
+      needed: true,
+      baseline: `${latest.tag} (${latest.source ?? "missing local tag"})`,
+      changedFiles: [],
+      reason: "No comparable local agents release tag was found.",
+    };
+  }
+
+  const changedFiles = getChangedFilesSince(latest.tag, AGENT_RELEASE_PATHS);
+  return {
+    needed: changedFiles.length > 0,
+    baseline: latest.tag,
+    changedFiles,
+  };
+}
+
+function getLatestAppTag() {
+  const tag = getLatestSemverTag(APP_TAG_PREFIX);
+  if (!tag) {
+    fail("No v* app release tag was found.");
+  }
+  return { tag: tag.tag };
+}
+
+function getChangedFilesSince(ref, paths) {
+  const output = run("git", ["diff", "--name-only", `${ref}..HEAD`, "--", ...paths]).stdout.trim();
+  if (!output) return [];
+  return output.split(/\r?\n/).filter(Boolean);
+}
+
+function printReleaseStatus(status) {
+  console.log(kv("Release needed", status.needed ? "yes" : "no", status.needed ? yellow : green));
+  console.log(kv("Compared against", status.baseline, dim));
+  if (status.reason) {
+    console.log(kv("Reason", status.reason, dim));
+  }
+  if (status.changedFiles.length > 0) {
+    console.log(dim("Changed publish-relevant files:"));
+    for (const file of status.changedFiles.slice(0, 20)) {
+      console.log(`  ${dim("-")} ${file}`);
+    }
+    if (status.changedFiles.length > 20) {
+      console.log(dim(`  ... and ${status.changedFiles.length - 20} more`));
+    }
+  }
+}
+
+function formatStatusSummary(status) {
+  if (status.needed) {
+    const detail = status.changedFiles.length > 0 ? `${status.changedFiles.length} changed file${status.changedFiles.length === 1 ? "" : "s"}` : "release baseline missing";
+    return `${yellow("needs release")}, ${detail}`;
+  }
+  return `${green("no release needed")} since ${status.baseline}`;
+}
+
+function getLatestSemverTag(prefix) {
+  const tags = run("git", ["tag", "--list", `${prefix}*`]).stdout
+    .split(/\r?\n/)
+    .map((tag) => tag.trim())
+    .filter(Boolean)
+    .map((tag) => ({ tag, version: parseVersion(tag.replace(prefix, "")) }))
+    .filter((entry) => entry.version)
+    .sort((a, b) => compareVersions(b.version, a.version));
+
+  if (tags.length === 0) return null;
+  return { ...tags[0], versionText: formatVersion(tags[0].version) };
+}
+
+function refExists(ref) {
+  const result = spawnSync("git", ["rev-parse", "-q", "--verify", ref], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    stdio: "pipe",
+  });
+  return result.status === 0;
+}
+
+function resolveAgentTag(bump, latestTag) {
+  const explicitVersion = normalizeExplicitVersion(bump, AGENT_TAG_PREFIX);
+  if (explicitVersion) return `${AGENT_TAG_PREFIX}${explicitVersion}`;
+
+  const latestVersion = latestTag.replace(AGENT_TAG_PREFIX, "");
+  return `${AGENT_TAG_PREFIX}${resolveReleaseVersion(bump, latestVersion, AGENT_TAG_PREFIX)}`;
+}
+
+function resolveAppTag(value) {
+  if (["patch", "minor", "major"].includes(value)) {
+    fail("App distribution publishing requires an existing vX.Y.Z release tag, not a version bump.");
+  }
+
+  const explicitVersion = normalizeExplicitVersion(value, APP_TAG_PREFIX);
+  if (!explicitVersion) {
+    fail(`Invalid app release tag '${value}'. Use vX.Y.Z or X.Y.Z.`);
+  }
+
+  return `${APP_TAG_PREFIX}${explicitVersion}`;
+}
+
+function resolveReleaseVersion(bump, latestVersion, explicitTagPrefix) {
+  const normalizedVersion = normalizeExplicitVersion(bump, explicitTagPrefix);
+  if (normalizedVersion) return normalizedVersion;
+
+  if (!["patch", "minor", "major"].includes(bump)) {
+    fail(`Unknown version bump '${bump}'. Use patch, minor, major, or an explicit semver version.`);
+  }
+
+  const latest = parseVersion(latestVersion);
+  if (!latest || latest.prerelease) {
+    fail(`Cannot ${bump} bump from non-standard version '${latestVersion}'. Pass an explicit version instead.`);
+  }
+
+  if (bump === "major") return `${latest.major + 1}.0.0`;
+  if (bump === "minor") return `${latest.major}.${latest.minor + 1}.0`;
+  return `${latest.major}.${latest.minor}.${latest.patch + 1}`;
+}
+
+function normalizeExplicitVersion(value, explicitTagPrefix) {
+  const trimmed = value.trim().replace(new RegExp(`^${escapeRegExp(explicitTagPrefix)}`), "").replace(/^v/, "");
+  const version = parseVersion(trimmed);
+  return version ? formatVersion(version) : null;
+}
+
+function parseVersion(value) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(value);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ?? "",
+  };
+}
+
+function formatVersion(version) {
+  return `${version.major}.${version.minor}.${version.patch}${version.prerelease ? `-${version.prerelease}` : ""}`;
+}
+
+function compareVersions(a, b) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key]) return a[key] - b[key];
+  }
+  if (a.prerelease === b.prerelease) return 0;
+  if (!a.prerelease) return 1;
+  if (!b.prerelease) return -1;
+  return a.prerelease.localeCompare(b.prerelease);
+}
+
+function tagExists(tag) {
+  const result = spawnSync("git", ["rev-parse", "-q", "--verify", `refs/tags/${tag}`], {
+    cwd: process.cwd(),
+    encoding: "utf8",
+    stdio: "pipe",
+  });
+  return result.status === 0;
+}
+
+function ensureGhReady(workflow) {
+  run("gh", ["auth", "status", "--hostname", "github.com"], { stdio: "inherit" });
+  run("gh", ["workflow", "view", workflow, "--repo", REPO], { stdio: "inherit" });
+}
+
+function fetchReleaseTags() {
+  run("git", [
+    "fetch",
+    "--quiet",
+    "origin",
+    "+refs/tags/v*:refs/tags/v*",
+    "+refs/tags/packages-v*:refs/tags/packages-v*",
+    "+refs/tags/agents-v*:refs/tags/agents-v*",
+  ]);
+}
+
+function run(command, commandArgs, options = {}) {
+  const result = spawnSync(command, commandArgs, {
+    cwd: process.cwd(),
+    env: process.env,
+    encoding: "utf8",
+    stdio: options.stdio ?? "pipe",
+  });
+
+  if (result.error) {
+    fail(`${command} ${commandArgs.join(" ")} failed: ${result.error.message}`);
+  }
+
+  if (result.status !== 0) {
+    const stderr = typeof result.stderr === "string" ? result.stderr.trim() : "";
+    fail(`${command} ${commandArgs.join(" ")} failed${stderr ? `:\n${stderr}` : ""}`);
+  }
+
+  return result;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function fail(message) {
+  console.error(red(message));
+  process.exit(1);
+}
+
+function printHelp() {
+  console.log(`Usage: node scripts/release.mjs [packages|agents|app] [patch|minor|major|version] [options]
+
+Unified release trigger for DBX packages, agents, and app distribution.
+
+Targets:
+  packages              Trigger Node Packages Release via gh workflow run
+  agents                Create and push an agents-v* tag
+  app                   Trigger Publish Packages for an existing v* app release tag
+
+Arguments:
+  patch                 Bump the latest target tag by one patch version (default)
+  minor                 Bump the latest target tag by one minor version
+  major                 Bump the latest target tag by one major version
+  0.4.14                Trigger an explicit version
+  packages-v0.4.14      Explicit package tag style, for packages
+  agents-v0.4.14        Explicit agent tag style, for agents
+  v0.5.38               Existing app release tag, for app
+
+Options:
+  --dry-run             Print the release command without triggering it
+  -y, --yes             Skip the confirmation prompt
+  --skip-fetch          Do not run git fetch --tags before reading release tags
+  --force               Allow a package/agent release even when no relevant files changed
+  -h, --help            Show this help
+`);
+}
diff --git a/scripts/run-check.mjs b/scripts/run-check.mjs
new file mode 100644
index 0000000..888015e
--- /dev/null
+++ b/scripts/run-check.mjs
@@ -0,0 +1,137 @@
+import { spawn } from "node:child_process";
+import { performance } from "node:perf_hooks";
+import { delimiter, join } from "node:path";
+
+const tasks = [
+  {
+    name: "format",
+    command: "oxfmt",
+    args: ["--check", "apps/desktop/src/**/*.{ts,vue}"],
+  },
+  {
+    name: "lint",
+    command: "oxlint",
+    args: ["--vue-plugin", "apps/desktop/src"],
+  },
+  {
+    name: "typecheck",
+    command: "vue-tsc",
+    args: ["--noEmit", "--project", "apps/desktop/tsconfig.json"],
+  },
+  {
+    name: "test",
+    command: "vitest",
+    args: ["run"],
+  },
+];
+
+function runTask(task) {
+  const startedAt = performance.now();
+  const command = commandSpec(task);
+  const child = spawn(command.program, command.args, {
+    cwd: process.cwd(),
+    env: commandEnv(),
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  const stdout = [];
+  const stderr = [];
+
+  child.stdout.on("data", (chunk) => stdout.push(chunk));
+  child.stderr.on("data", (chunk) => stderr.push(chunk));
+
+  return new Promise((resolve) => {
+    child.on("error", (error) => {
+      resolve({
+        ...task,
+        code: 1,
+        durationMs: performance.now() - startedAt,
+        output: "",
+        errorOutput: error.stack ?? String(error),
+      });
+    });
+
+    child.on("close", (code) => {
+      resolve({
+        ...task,
+        code,
+        durationMs: performance.now() - startedAt,
+        output: Buffer.concat(stdout).toString(),
+        errorOutput: Buffer.concat(stderr).toString(),
+      });
+    });
+  });
+}
+
+function commandSpec(task) {
+  if (process.platform !== "win32") return { program: task.command, args: task.args };
+  const command = join(process.cwd(), "node_modules", ".bin", `${task.command}.CMD`);
+  return { program: "cmd.exe", args: ["/d", "/c", "call", command, ...task.args] };
+}
+
+function commandEnv() {
+  return {
+    ...process.env,
+    PATH: [join(process.cwd(), "node_modules", ".bin"), process.env.PATH].filter(Boolean).join(delimiter),
+  };
+}
+
+function outputFailureExcerpt(output) {
+  const lines = output.trimEnd().split(/\r?\n/);
+  const selected = new Set();
+
+  for (let index = 0; index < lines.length; index += 1) {
+    if (!/\bnot ok\b|AssertionError|ERR_ASSERT|^# fail\b|^# tests\b|^# pass\b/.test(lines[index])) continue;
+    const start = Math.max(0, index - 2);
+    const end = Math.min(lines.length, index + 14);
+    for (let lineIndex = start; lineIndex < end; lineIndex += 1) {
+      selected.add(lineIndex);
+    }
+  }
+
+  if (selected.size === 0) return "";
+
+  const excerpt = [];
+  let previous = -2;
+  for (const index of [...selected].sort((a, b) => a - b)) {
+    if (index > previous + 1 && excerpt.length > 0) excerpt.push("...");
+    excerpt.push(lines[index]);
+    previous = index;
+  }
+  return excerpt.join("\n");
+}
+
+function tailOutput(output, maxLines = 120) {
+  const lines = output.trimEnd().split(/\r?\n/);
+  if (lines.length <= maxLines) return lines.join("\n");
+  return [`... omitted ${lines.length - maxLines} earlier line(s) ...`, ...lines.slice(-maxLines)].join("\n");
+}
+
+const results = await Promise.all(tasks.map(runTask));
+
+for (const result of results) {
+  const seconds = (result.durationMs / 1000).toFixed(2);
+  const status = result.code === 0 ? "ok" : "failed";
+  console.log(`${status.padEnd(6)} ${result.name.padEnd(9)} ${seconds}s`);
+}
+
+const failures = results.filter((result) => result.code !== 0);
+
+for (const failure of failures) {
+  console.error(`\n${failure.name} output:`);
+  if (failure.output) {
+    const excerpt = outputFailureExcerpt(failure.output);
+    if (excerpt) {
+      console.error("failure excerpt:");
+      console.error(excerpt);
+      console.error("\noutput tail:");
+    }
+    console.error(tailOutput(failure.output));
+  }
+  if (failure.errorOutput) {
+    console.error(tailOutput(failure.errorOutput));
+  }
+}
+
+if (failures.length > 0) {
+  process.exit(1);
+}
diff --git a/skills/dbx/SKILL.md b/skills/dbx/SKILL.md
new file mode 100644
index 0000000..94f9472
--- /dev/null
+++ b/skills/dbx/SKILL.md
@@ -0,0 +1,171 @@
+---
+name: dbx
+version: 1.0.0
+description: "DBX CLI for database schema exploration and read-only queries. When the user needs to list connections, explore tables, describe schemas, run queries, or generate AI-friendly schema context from DBX-managed databases. Do NOT use for write operations unless the user explicitly confirms with --allow-writes."
+metadata:
+  requires:
+    bins: ["dbx"]
+  cliHelp: "dbx --help"
+---
+
+# DBX CLI
+
+> **Prerequisite:** DBX Desktop must be installed and configured with at least one connection. Run `dbx doctor` to verify setup. Install CLI: `npm install -g @dbx-app/cli`
+
+## Core Concepts
+
+- **Connection**: A named database connection configured in DBX Desktop (e.g. "prod", "local"). Identified by name.
+- **Schema**: Tables and views within a connection. Listed via `dbx schema list`.
+- **Query**: Read-only SQL executed against a connection. Gated by `--allow-writes` and `--allow-dangerous-sql`.
+- **Context**: Compact schema dump optimized for AI prompts — smaller and more focused than full schema output.
+
+## Resource Relationships
+
+```
+DBX Desktop
+├── Connection (named)
+│   ├── Schema (tables, views)
+│   │   └── Table
+│   │       └── Column (name, type, nullable, default)
+│   └── Query (read-only by default)
+└── Context (prompt-optimized schema dump)
+```
+
+## Commands
+
+> **⛔ NEVER bypass dbx CLI for database operations.** If `dbx` returns `SQL_BLOCKED` or any error, do NOT use Python sqlite3, shell redirects, or any other tool to access the database directly. Always respect the CLI's safety gates. When in doubt, tell the user what the CLI returned and ask for their decision.
+
+### 1. Check Setup
+
+```bash
+dbx doctor
+dbx capabilities
+```
+
+Use `doctor` when the agent starts or when a command fails — it reveals whether the desktop bridge, connection DB, and native SQLite loader are available. Use `capabilities` to check which databases support direct execution vs require the desktop bridge.
+
+### 2. List Connections
+
+```bash
+dbx connections list --json
+```
+
+Returns connections without exposing secrets. Parse JSON to present a clean list to the user. Always run this first before any schema or query operation — the user might not remember connection names.
+
+### 3. Explore Schema
+
+```bash
+# List all tables in a connection
+dbx schema list <connection> --json
+
+# Describe a specific table
+dbx schema describe <connection> <table> --json
+```
+
+Use `schema list` to survey what's available, then `schema describe` on specific tables the user asks about. Present column names, types, and nullability clearly.
+
+### 4. Execute Queries
+
+```bash
+# Read-only query (default)
+dbx query <connection> "SELECT ..." --json
+
+# From file
+dbx query <connection> --file ./query.sql --json
+
+# With row limit and timeout
+dbx query <connection> "SELECT ..." --limit 50 --timeout 10s --json
+```
+
+**CRITICAL — Read-only by default.** Write operations (INSERT/UPDATE/DELETE) require `--allow-writes`. Dangerous SQL (DROP/TRUNCATE/ALTER) requires BOTH `--allow-writes` AND `--allow-dangerous-sql`. Never add these flags unless the user explicitly confirms a write operation.
+
+If the SQL starts with a dash, separate with `--`:
+```bash
+dbx query local --json -- "-- comment
+select 1"
+```
+
+### 5. Generate Context for Prompts
+
+```bash
+# Full schema context
+dbx context <connection>
+
+# Filtered to specific tables
+dbx context <connection> --tables users,orders,products
+```
+
+Use `context` when the user wants to write a query but needs schema reference first. Pipe the output directly into the prompt — it's designed for this. Prefer `--tables` to limit scope and save tokens.
+
+### 6. Default Connection
+
+Set `DBX_CONNECTION` to skip the connection argument:
+
+```bash
+export DBX_CONNECTION=prod
+dbx query "SELECT 1" --json
+dbx context --tables users
+```
+
+Detect and use this if set in the environment.
+
+## Output
+
+| Flag | Use Case |
+|------|----------|
+| `--json` | Machine-readable, auto-parsed (always use this) |
+| `--format csv` | Piping to other CLI tools |
+
+Errors go to stderr with non-zero exit code. Run `dbx doctor` first if any command fails unexpectedly.
+
+## Error Codes
+
+| Code | Meaning | Agent Response |
+|------|---------|---------------|
+| `CONNECTION_NOT_FOUND` | Connection name doesn't exist | List available connections with `dbx connections list --json` |
+| `SQL_BLOCKED` | Write operation attempted without `--allow-writes` | Ask user: "This is a write operation. Confirm?" Never add write flags automatically. |
+| `DBX_NOT_RUNNING` | Desktop bridge unavailable | Tell user to open DBX Desktop. Check which commands work without bridge via `dbx capabilities`. |
+| `INVALID_OPTION` | Wrong flag or flag value | Check `dbx --help` and retry |
+| `ERROR` | Unexpected runtime failure | Run `dbx doctor`, check logs, retry once |
+
+## Direct vs Bridge Execution
+
+PostgreSQL, MySQL (and compatible: Doris, StarRocks), SQLite run directly without DBX Desktop. Other database types require the desktop bridge. Check with `dbx capabilities` to confirm.
+
+## Common Pitfalls
+
+1. **Wrong connection name** — Always list connections first with `dbx connections list --json` before running schema or query commands. Never assume connection names from conversation context.
+
+2. **Schema confusion from context pollution** — When the user asks about a table, verify the connection and table exist before running queries. `dbx schema list <conn> --json` is your verification step.
+
+3. **Write operations by accident** — Never add `--allow-writes` or `--allow-dangerous-sql` unless the user explicitly confirms. When in doubt, ask.
+
+4. **Missing desktop bridge** — If `dbx open` or bridge-required connections fail, run `dbx doctor` and tell the user to open DBX Desktop. Commands that don't require the bridge: `connections list`, `schema list`, `schema describe`, `query`, `context` (for PostgreSQL/MySQL/SQLite).
+
+5. **Timeout on large queries** — Always use `--limit 50 --timeout 10s` for exploratory queries. Remove or increase limits only when the user explicitly asks for full results.
+
+6. **JSON parse errors** — Old DBX versions may not support `--json` on some commands. If JSON output looks malformed, try without `--json` and parse the human-readable output instead.
+
+## Multi-Step Workflows
+
+### Explore then Query
+
+1. `dbx connections list --json` — verify connection exists
+2. `dbx schema list <conn> --json` — survey available tables
+3. `dbx schema describe <conn> <table> --json` — understand target table
+4. `dbx query <conn> "SELECT ..." --limit 50 --timeout 10s --json` — execute
+5. Present results to user with row count
+
+### Generate Context then Help Write Query
+
+1. `dbx context <conn> --tables a,b` — get compact schema
+2. Read the output, understand relationships
+3. Draft the SQL, show it to user for review
+4. `dbx query <conn> "polished sql" --json` — execute after approval
+
+### Cross-Connection Comparison
+
+1. `dbx connections list --json` — identify source and target
+2. `dbx schema describe <source_conn> <table> --json` — get source structure
+3. `dbx schema describe <target_conn> <table> --json` — get target structure
+4. Compare and report differences
diff --git a/src-tauri/.gitignore b/src-tauri/.gitignore
new file mode 100644
index 0000000..b0cadf4
--- /dev/null
+++ b/src-tauri/.gitignore
@@ -0,0 +1,5 @@
+# Generated by Cargo
+/target/
+/gen/schemas
+# CI-only: copied by release workflow for macOS bundling
+*.dylib
diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
new file mode 100644
index 0000000..1e0064e
--- /dev/null
+++ b/src-tauri/Cargo.lock
@@ -0,0 +1,9703 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common 0.1.7",
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "aead"
+version = "0.6.0-rc.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b657e772794c6b04730ea897b66a058ccd866c16d1967da05eeeecec39043fe"
+dependencies = [
+ "crypto-common 0.2.1",
+ "inout 0.2.2",
+]
+
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher 0.4.4",
+ "cpufeatures 0.2.17",
+]
+
+[[package]]
+name = "aes"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66bd29a732b644c0431c6140f370d097879203d79b80c94a6747ba0872adaef8"
+dependencies = [
+ "cipher 0.5.1",
+ "cpubits",
+ "cpufeatures 0.3.0",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
+dependencies = [
+ "aead 0.5.2",
+ "aes 0.8.4",
+ "cipher 0.4.4",
+ "ctr 0.9.2",
+ "ghash 0.5.1",
+ "subtle",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.11.0-rc.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22c0c90bbe8d4f77c3ca9ddabe41a1f8382d6fc1f7cea89459d0f320371f972"
+dependencies = [
+ "aead 0.6.0-rc.10",
+ "aes 0.9.0",
+ "cipher 0.5.1",
+ "ctr 0.10.0",
+ "ghash 0.6.0",
+ "subtle",
+]
+
+[[package]]
+name = "ahash"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
+dependencies = [
+ "getrandom 0.2.17",
+ "once_cell",
+ "version_check",
+]
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "const-random",
+ "getrandom 0.3.4",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "android_log-sys"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84521a3cf562bc62942e294181d9eef17eb38ceb8c68677bc49f144e4c3d4f8d"
+
+[[package]]
+name = "android_logger"
+version = "0.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbb4e440d04be07da1f1bf44fb4495ebd58669372fe0cffa6e48595ac5bd88a3"
+dependencies = [
+ "android_log-sys",
+ "env_filter",
+ "log",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
+dependencies = [
+ "derive_arbitrary",
+]
+
+[[package]]
+name = "argon2"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c3610892ee6e0cbce8ae2700349fcf8f98adb0dbfbee85aec3c9179d29cc072"
+dependencies = [
+ "base64ct",
+ "blake2",
+ "cpufeatures 0.2.17",
+ "password-hash",
+]
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "arrow"
+version = "58.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "607e64bb911ee4f90483e044fe78f175989148c2892e659a2cd25429e782ec54"
+dependencies = [
+ "arrow-arith",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-data",
+ "arrow-ord",
+ "arrow-row",
+ "arrow-schema",
+ "arrow-select",
+ "arrow-string",
+]
+
+[[package]]
+name = "arrow-arith"
+version = "58.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e754319ed8a85d817fe7adf183227e0b5308b82790a737b426c1124626b48118"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-array"
+version = "58.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841321891f247aa86c6112c80d83d89cb36e0addd020fa2425085b8eb6c3f579"
+dependencies = [
+ "ahash 0.8.12",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "half",
+ "hashbrown 0.17.0",
+ "num-complex",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-buffer"
+version = "58.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f955dfb73fae000425f49c8226d2044dab60fb7ad4af1e24f961756354d996c9"
+dependencies = [
+ "bytes",
+ "half",
+ "num-bigint",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-cast"
+version = "58.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca5e686972523798f76bef355145bc1ae25a84c731e650268d31ab763c701663"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-ord",
+ "arrow-schema",
+ "arrow-select",
+ "atoi",
+ "base64 0.22.1",
+ "chrono",
+ "comfy-table",
+ "half",
+ "lexical-core",
+ "num-traits",
+ "ryu",
+]
+
+[[package]]
+name = "arrow-data"
+version = "58.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db3b5846209775b6dc8056d77ff9a032b27043383dd5488abd0b663e265b9373"
+dependencies = [
+ "arrow-buffer",
+ "arrow-schema",
+ "half",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-ord"
+version = "58.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efa70d9d6b1356f1fb9f1f651b84a725b7e0abb93f188cf7d31f14abfa2f2e6f"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+]
+
+[[package]]
+name = "arrow-row"
+version = "58.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "faec88a945338192beffbbd4be0def70135422930caa244ac3cec0cd213b26b4"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "half",
+]
+
+[[package]]
+name = "arrow-schema"
+version = "58.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18aa020f6bc8e5201dcd2d4b7f98c68f8a410ef37128263243e6ff2a47a67d4f"
+dependencies = [
+ "bitflags 2.11.1",
+]
+
+[[package]]
+name = "arrow-select"
+version = "58.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a657ab5132e9c8ca3b24eb15a823d0ced38017fe3930ff50167466b02e2d592c"
+dependencies = [
+ "ahash 0.8.12",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "num-traits",
+]
+
+[[package]]
+name = "arrow-string"
+version = "58.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6de2efbbd1a9f9780ceb8d1ff5d20421b35863b361e3386b4f571f1fc69fcb8"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+ "memchr",
+ "num-traits",
+ "regex",
+ "regex-syntax",
+]
+
+[[package]]
+name = "async-broadcast"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "435a87a52755b8f27fcf321ac4f04b2802e337c8c4872923137471ec39c37532"
+dependencies = [
+ "event-listener",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-channel"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
+dependencies = [
+ "concurrent-queue",
+ "event-listener-strategy",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-io"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
+dependencies = [
+ "autocfg",
+ "cfg-if",
+ "concurrent-queue",
+ "futures-io",
+ "futures-lite",
+ "parking",
+ "polling",
+ "rustix 1.1.4",
+ "slab",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "async-lock"
+version = "3.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"
+dependencies = [
+ "event-listener",
+ "event-listener-strategy",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-native-tls"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d57d4cec3c647232e1094dc013546c0b33ce785d8aeb251e1f20dfaf8a9a13fe"
+dependencies = [
+ "futures-util",
+ "native-tls",
+ "thiserror 1.0.69",
+ "url",
+]
+
+[[package]]
+name = "async-process"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"
+dependencies = [
+ "async-channel",
+ "async-io",
+ "async-lock",
+ "async-signal",
+ "async-task",
+ "blocking",
+ "cfg-if",
+ "event-listener",
+ "futures-lite",
+ "rustix 1.1.4",
+]
+
+[[package]]
+name = "async-recursion"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "async-signal"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52b5aaafa020cf5053a01f2a60e8ff5dccf550f0f77ec54a4e47285ac2bab485"
+dependencies = [
+ "async-io",
+ "async-lock",
+ "atomic-waker",
+ "cfg-if",
+ "futures-core",
+ "futures-io",
+ "rustix 1.1.4",
+ "signal-hook-registry",
+ "slab",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "async-task"
+version = "4.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
+
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "asynchronous-codec"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4057f2c32adbb2fc158e22fb38433c8e9bbf76b75a4732c7c0cbaf695fb65568"
+dependencies = [
+ "bytes",
+ "futures-sink",
+ "futures-util",
+ "memchr",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "atk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "241b621213072e993be4f6f3a9e4b45f65b7e6faad43001be957184b7bb1824b"
+dependencies = [
+ "atk-sys",
+ "glib",
+ "libc",
+]
+
+[[package]]
+name = "atk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e48b684b0ca77d2bbadeef17424c2ea3c897d44d566a1617e7e8f30614d086"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "atoi"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "atoi_simd"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a49e05797ca52e312a0c658938b7d00693ef037799ef7187678f212d7684cf"
+dependencies = [
+ "debug_unsafe",
+]
+
+[[package]]
+name = "atomic-waker"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "aws-lc-rs"
+version = "1.16.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ec6fb3fe69024a75fa7e1bfb48aa6cf59706a101658ea01bfd33b2b248a038f"
+dependencies = [
+ "aws-lc-sys",
+ "untrusted 0.7.1",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-lc-sys"
+version = "0.40.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f50037ee5e1e41e7b8f9d161680a725bd1626cb6f8c7e901f91f942850852fe7"
+dependencies = [
+ "cc",
+ "cmake",
+ "dunce",
+ "fs_extra",
+]
+
+[[package]]
+name = "base16ct"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd307490d624467aa6f74b0eabb77633d1f758a7b25f12bceb0b22e08d9726f6"
+
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "base64ct"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06"
+
+[[package]]
+name = "bcrypt-pbkdf"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6aeac2e1fe888769f34f05ac343bbef98b14d1ffb292ab69d4608b3abc86f2a2"
+dependencies = [
+ "blowfish",
+ "pbkdf2 0.12.2",
+ "sha2 0.10.9",
+]
+
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "blake2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8894febbff9f758034a5b8e12d87918f56dfc64a8e1fe757d65e29041538d93"
+dependencies = [
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "block-padding"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "710f1dd022ef4e93f8a438b4ba958de7f64308434fa6a87104481645cc30068b"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "block2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
+dependencies = [
+ "objc2",
+]
+
+[[package]]
+name = "blocking"
+version = "1.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
+dependencies = [
+ "async-channel",
+ "async-task",
+ "futures-io",
+ "futures-lite",
+ "piper",
+]
+
+[[package]]
+name = "blowfish"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e412e2cd0f2b2d93e02543ceae7917b3c70331573df19ee046bcbc35e45e87d7"
+dependencies = [
+ "byteorder",
+ "cipher 0.4.4",
+]
+
+[[package]]
+name = "borsh"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfd1e3f8955a5d7de9fab72fc8373fade9fb8a703968cb200ae3dc6cf08e185a"
+dependencies = [
+ "borsh-derive",
+ "bytes",
+ "cfg_aliases",
+]
+
+[[package]]
+name = "borsh-derive"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfcfdc083699101d5a7965e49925975f2f55060f94f9a05e7187be95d530ca59"
+dependencies = [
+ "once_cell",
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "brotli"
+version = "8.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "bson"
+version = "2.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969a9ba84b0ff843813e7249eed1678d9b6607ce5a3b8f0a47af3fcf7978e6e"
+dependencies = [
+ "ahash 0.8.12",
+ "base64 0.22.1",
+ "bitvec",
+ "getrandom 0.2.17",
+ "getrandom 0.3.4",
+ "hex",
+ "indexmap 2.14.0",
+ "js-sys",
+ "once_cell",
+ "rand 0.9.4",
+ "serde",
+ "serde_bytes",
+ "serde_json",
+ "time",
+ "uuid",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+
+[[package]]
+name = "byte-unit"
+version = "5.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c6d47a4e2961fb8721bcfc54feae6455f2f64e7054f9bc67e875f0e77f4c58d"
+dependencies = [
+ "rust_decimal",
+ "schemars 1.2.1",
+ "serde",
+ "utf8-width",
+]
+
+[[package]]
+name = "bytecheck"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23cdc57ce23ac53c931e88a43d06d070a6fd142f2617be5855eb75efc9beb1c2"
+dependencies = [
+ "bytecheck_derive",
+ "ptr_meta",
+ "simdutf8",
+]
+
+[[package]]
+name = "bytecheck_derive"
+version = "0.6.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3db406d29fbcd95542e92559bed4d8ad92636d1ca8b3b72ede10b4bcc010e659"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cairo-rs"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ca26ef0159422fb77631dc9d17b102f253b876fe1586b03b803e63a309b4ee2"
+dependencies = [
+ "bitflags 2.11.1",
+ "cairo-sys-rs",
+ "glib",
+ "libc",
+ "once_cell",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "cairo-sys-rs"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "685c9fa8e590b8b3d678873528d83411db17242a73fccaed827770ea0fedda51"
+dependencies = [
+ "glib-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "calamine"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b1a9acfeb1555aa8def91fe8ff208aadaea850c109968ec35ac965edbe7d210b"
+dependencies = [
+ "atoi_simd",
+ "byteorder",
+ "codepage",
+ "encoding_rs",
+ "fast-float2",
+ "log",
+ "quick-xml 0.37.5",
+ "serde",
+ "zip 4.6.1",
+]
+
+[[package]]
+name = "camino"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e629a66d692cb9ff1a1c664e41771b3dcaf961985a9774c0eb0bd1b51cf60a48"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "cargo-platform"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e35af189006b9c0f00a064685c727031e3ed2d8020f7ba284d78cc2671bd36ea"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "cargo_metadata"
+version = "0.19.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd5eb614ed4c27c5d706420e4320fbe3216ab31fa1c33cd8246ac36dae4479ba"
+dependencies = [
+ "camino",
+ "cargo-platform",
+ "semver",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "cargo_toml"
+version = "0.22.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "374b7c592d9c00c1f4972ea58390ac6b18cbb6ab79011f3bdc90a0b82ca06b77"
+dependencies = [
+ "serde",
+ "toml 0.9.12+spec-1.1.0",
+]
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cbc"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26b52a9543ae338f279b96b0b9fed9c8093744685043739079ce85cd58f289a6"
+dependencies = [
+ "cipher 0.4.4",
+]
+
+[[package]]
+name = "cbc"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "98db6aeaef0eeef2c1e3ce9a27b739218825dae116076352ac3777076aa22225"
+dependencies = [
+ "cipher 0.5.1",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.61"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d16d90359e986641506914ba71350897565610e87ce0ad9e6f28569db3dd5c6d"
+dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cesu8"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"
+
+[[package]]
+name = "cfb"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38f2da7a0a2c4ccf0065be06397cc26a81f4e528be095826eee9d4adbb8c60f"
+dependencies = [
+ "byteorder",
+ "fnv",
+ "uuid",
+]
+
+[[package]]
+name = "cfg-expr"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
+dependencies = [
+ "smallvec",
+ "target-lexicon",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "chacha20"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
+dependencies = [
+ "cfg-if",
+ "cipher 0.4.4",
+ "cpufeatures 0.2.17",
+]
+
+[[package]]
+name = "chacha20"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f8d983286843e49675a4b7a2d174efe136dc93a18d69130dd18198a6c167601"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "serde",
+ "wasm-bindgen",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common 0.1.7",
+ "inout 0.1.4",
+]
+
+[[package]]
+name = "cipher"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e34d8227fe1ba289043aeb13792056ff80fd6de1a9f49137a5f499de8e8c78ea"
+dependencies = [
+ "block-buffer 0.12.0",
+ "crypto-common 0.2.1",
+ "inout 0.2.2",
+]
+
+[[package]]
+name = "cmake"
+version = "0.1.58"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "cmov"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f88a43d011fc4a6876cb7344703e297c71dda42494fee094d5f7c76bf13f746"
+
+[[package]]
+name = "codepage"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48f68d061bc2828ae826206326e61251aca94c1e4a5305cf52d9138639c918b4"
+dependencies = [
+ "encoding_rs",
+]
+
+[[package]]
+name = "combine"
+version = "4.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba5a308b75df32fe02788e748662718f03fde005016435c444eea572398219fd"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "memchr",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "comfy-table"
+version = "7.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a65ebfec4fb190b6f90e944a817d60499ee0744e582530e2c9900a22e591d9a"
+dependencies = [
+ "crossterm",
+ "unicode-segmentation",
+ "unicode-width",
+]
+
+[[package]]
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "connection-string"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "510ca239cf13b7f8d16a2b48f263de7b4f8c566f0af58d901031473c76afb1e3"
+
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
+[[package]]
+name = "const-oid"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+
+[[package]]
+name = "const-random"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
+dependencies = [
+ "const-random-macro",
+]
+
+[[package]]
+name = "const-random-macro"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
+dependencies = [
+ "getrandom 0.2.17",
+ "once_cell",
+ "tiny-keccak",
+]
+
+[[package]]
+name = "convert_case"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "633458d4ef8c78b72454de2d54fd6ab2e60f9e02be22f3c6104cdc8a4e0fceb9"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "cookie"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
+dependencies = [
+ "time",
+ "version_check",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "core-graphics"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "064badf302c3194842cf2c5d61f56cc88e54a759313879cdf03abdd27d0c3b97"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.10.1",
+ "core-graphics-types",
+ "foreign-types 0.5.0",
+ "libc",
+]
+
+[[package]]
+name = "core-graphics-types"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d44a101f213f6c4cdc1853d4b78aef6db6bdfa3468798cc1d9912f4735013eb"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.10.1",
+ "libc",
+]
+
+[[package]]
+name = "cpubits"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15b85f9c39137c3a891689859392b1bd49812121d0d61c9caf00d46ed5ce06ae"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5eb8a2a1cd12ab0d987a5d5e825195d372001a4094a0376319d5a0ad71c1ba0d"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "217698eaf96b4a3f0bc4f3662aaa55bdf913cd54d7204591faa790070c6d0853"
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "critical-section"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crossterm"
+version = "0.28.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
+dependencies = [
+ "bitflags 2.11.1",
+ "crossterm_winapi",
+ "parking_lot",
+ "rustix 0.38.44",
+ "winapi",
+]
+
+[[package]]
+name = "crossterm_winapi"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
+dependencies = [
+ "winapi",
+]
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "crypto-bigint"
+version = "0.7.0-rc.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96dacf199529fb801ae62a9aafdc01b189e9504c0d1ee1512a4c16bcd8666a93"
+dependencies = [
+ "cpubits",
+ "ctutils",
+ "getrandom 0.4.2",
+ "hybrid-array",
+ "num-traits",
+ "rand_core 0.10.1",
+ "serdect",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array 0.14.7",
+ "typenum",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77727bb15fa921304124b128af125e7e3b968275d1b108b379190264f4423710"
+dependencies = [
+ "getrandom 0.4.2",
+ "hybrid-array",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "crypto-primes"
+version = "0.7.0-pre.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6081ce8b60c0e533e2bba42771b94eb6149052115f4179744d5779883dc98583"
+dependencies = [
+ "crypto-bigint",
+ "libm",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "cssparser"
+version = "0.36.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dae61cf9c0abb83bd659dab65b7e4e38d8236824c85f0f804f173567bda257d2"
+dependencies = [
+ "cssparser-macros",
+ "dtoa-short",
+ "itoa",
+ "phf 0.13.1",
+ "smallvec",
+]
+
+[[package]]
+name = "cssparser-macros"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13b588ba4ac1a99f7f2964d24b3d896ddc6bf847ee3855dbd4366f058cfcd331"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "csv"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde_core",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "ctor"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "352d39c2f7bef1d6ad73db6f5160efcaed66d94ef8c6c573a8410c00bf909a98"
+dependencies = [
+ "ctor-proc-macro",
+ "dtor",
+]
+
+[[package]]
+name = "ctor-proc-macro"
+version = "0.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52560adf09603e58c9a7ee1fe1dcb95a16927b17c127f0ac02d6e768a0e25bc1"
+
+[[package]]
+name = "ctr"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
+dependencies = [
+ "cipher 0.4.4",
+]
+
+[[package]]
+name = "ctr"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17469f8eb9bdbfad10f71f4cfddfd38b01143520c0e717d8796ccb4d44d44e42"
+dependencies = [
+ "cipher 0.5.1",
+]
+
+[[package]]
+name = "ctutils"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5515a3834141de9eafb9717ad39eea8247b5674e6066c404e8c4b365d2a29e"
+dependencies = [
+ "cmov",
+ "subtle",
+]
+
+[[package]]
+name = "curve25519-dalek"
+version = "5.0.0-pre.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335f1947f241137a14106b6f5acc5918a5ede29c9d71d3f2cb1678d5075d9fc3"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "curve25519-dalek-derive",
+ "digest 0.11.3",
+ "fiat-crypto",
+ "rustc_version",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "curve25519-dalek-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "darling"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0"
+dependencies = [
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4ae5f15dda3c708c0ade84bfee31ccab44a3da4f88015ed22f63732abe300c8"
+
+[[package]]
+name = "dbus"
+version = "0.9.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b942602992bb7acfd1f51c49811c58a610ef9181b6e66f3e519d79b540a3bf73"
+dependencies = [
+ "libc",
+ "libdbus-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dbus-secret-service"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "708b509edf7889e53d7efb0ffadd994cc6c2345ccb62f55cfd6b0682165e4fa6"
+dependencies = [
+ "aes 0.8.4",
+ "block-padding 0.3.3",
+ "cbc 0.1.2",
+ "dbus",
+ "fastrand",
+ "hkdf 0.12.4",
+ "num",
+ "once_cell",
+ "sha2 0.10.9",
+ "zeroize",
+]
+
+[[package]]
+name = "dbx"
+version = "0.4.2"
+dependencies = [
+ "anyhow",
+ "calamine",
+ "chrono",
+ "csv",
+ "duckdb",
+ "futures",
+ "keyring",
+ "log",
+ "mongodb",
+ "oracle-rs",
+ "percent-encoding",
+ "portpicker",
+ "redis",
+ "reqwest 0.12.28",
+ "russh",
+ "rust_decimal",
+ "rustls",
+ "serde",
+ "serde_json",
+ "sqlx",
+ "tauri",
+ "tauri-build",
+ "tauri-plugin-dialog",
+ "tauri-plugin-fs",
+ "tauri-plugin-log",
+ "tauri-plugin-process",
+ "tauri-plugin-shell",
+ "tauri-plugin-updater",
+ "tiberius",
+ "tokio",
+ "tokio-util",
+ "uuid",
+]
+
+[[package]]
+name = "debug_unsafe"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7eed2c4702fa172d1ce21078faa7c5203e69f5394d48cc436d25928394a867a2"
+
+[[package]]
+name = "delegate"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "780eb241654bf097afb00fc5f054a09b687dad862e485fdcf8399bb056565370"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "der"
+version = "0.7.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb"
+dependencies = [
+ "const-oid 0.9.6",
+ "pem-rfc7468 0.7.0",
+ "zeroize",
+]
+
+[[package]]
+name = "der"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71fd89660b2dc699704064e59e9dba0147b903e85319429e131620d022be411b"
+dependencies = [
+ "const-oid 0.10.2",
+ "pem-rfc7468 1.0.0",
+ "zeroize",
+]
+
+[[package]]
+name = "deranged"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+dependencies = [
+ "powerfmt",
+ "serde_core",
+]
+
+[[package]]
+name = "derive-syn-parse"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d65d7ce8132b7c0e54497a4d9a55a1c2a0912a0d786cf894472ba818fba45762"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "derive-where"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d08b3a0bcc0d079199cd476b2cae8435016ec11d1c0986c6901c5ac223041534"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "derive_arbitrary"
+version = "1.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d751e9e49156b02b44f9c1815bcb94b984cdcc4396ecc32521c739452808b134"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "799a97264921d8623a957f6c3b9011f3b5492f557bbb7a5a19b7fa6d06ba8dcb"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn 2.0.117",
+ "unicode-xid",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer 0.10.4",
+ "const-oid 0.9.6",
+ "crypto-common 0.1.7",
+ "subtle",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer 0.12.0",
+ "const-oid 0.10.2",
+ "crypto-common 0.2.1",
+ "ctutils",
+]
+
+[[package]]
+name = "dirs"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "dispatch2"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "libc",
+ "objc2",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dlopen2"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e2c5bd4158e66d1e215c49b837e11d62f3267b30c92f1d171c4d3105e3dc4d4"
+dependencies = [
+ "dlopen2_derive",
+ "libc",
+ "once_cell",
+ "winapi",
+]
+
+[[package]]
+name = "dlopen2_derive"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fbbb781877580993a8707ec48672673ec7b81eeba04cfd2310bd28c08e47c8f"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "dom_query"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521e380c0c8afb8d9a1e83a1822ee03556fc3e3e7dbc1fd30be14e37f9cb3f89"
+dependencies = [
+ "bit-set",
+ "cssparser",
+ "foldhash 0.2.0",
+ "html5ever",
+ "precomputed-hash",
+ "selectors",
+ "tendril",
+]
+
+[[package]]
+name = "dotenvy"
+version = "0.15.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b"
+
+[[package]]
+name = "dpi"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "dtoa"
+version = "1.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c3cf4824e2d5f025c7b531afcb2325364084a16806f6d47fbc1f5fbd9960590"
+
+[[package]]
+name = "dtoa-short"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd1511a7b6a56299bd043a9c167a6d2bfb37bf84a6dfceaba651168adfb43c87"
+dependencies = [
+ "dtoa",
+]
+
+[[package]]
+name = "dtor"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1057d6c64987086ff8ed0fd3fbf377a6b7d205cc7715868cd401705f715cbe4"
+dependencies = [
+ "dtor-proc-macro",
+]
+
+[[package]]
+name = "dtor-proc-macro"
+version = "0.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f678cf4a922c215c63e0de95eb1ff08a958a81d47e485cf9da1e27bf6305cfa5"
+
+[[package]]
+name = "duckdb"
+version = "1.10502.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fdc796383b176dd5a45353fbb5e64583c0ee4da12cb62c9e510b785324b2488"
+dependencies = [
+ "arrow",
+ "cast",
+ "comfy-table",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "hashlink",
+ "libduckdb-sys",
+ "num-integer",
+ "rust_decimal",
+ "strum",
+]
+
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
+
+[[package]]
+name = "ecdsa"
+version = "0.17.0-rc.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91bbdd377139884fafcad8dc43a760a3e1e681aa26db910257fa6535b70e1829"
+dependencies = [
+ "der 0.8.0",
+ "digest 0.11.3",
+ "elliptic-curve",
+ "rfc6979",
+ "signature 3.0.0",
+ "spki 0.8.0-rc.4",
+ "zeroize",
+]
+
+[[package]]
+name = "ed25519"
+version = "3.0.0-rc.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6e914c7c52decb085cea910552e24c63ac019e3ab8bf001ff736da9a9d9d890"
+dependencies = [
+ "pkcs8 0.11.0-rc.11",
+ "signature 3.0.0",
+]
+
+[[package]]
+name = "ed25519-dalek"
+version = "3.0.0-pre.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053618a4c3d3bc24f188aa660ae75a46eeab74ef07fb415c61431e5e7cd4749b"
+dependencies = [
+ "curve25519-dalek",
+ "ed25519",
+ "rand_core 0.10.1",
+ "serde",
+ "sha2 0.11.0",
+ "signature 3.0.0",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "elliptic-curve"
+version = "0.14.0-rc.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bde7860544606d222fd6bd6d9f9a0773321bf78072a637e1d560a058c0031978"
+dependencies = [
+ "base16ct",
+ "crypto-bigint",
+ "crypto-common 0.2.1",
+ "digest 0.11.3",
+ "hkdf 0.13.0",
+ "hybrid-array",
+ "once_cell",
+ "pem-rfc7468 1.0.0",
+ "pkcs8 0.11.0-rc.11",
+ "rand_core 0.10.1",
+ "rustcrypto-ff",
+ "rustcrypto-group",
+ "sec1",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "embed-resource"
+version = "3.0.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31a88c8d26de40ed18fe748c547845aa39de1db3afd958f8cb91579f3644bcb"
+dependencies = [
+ "cc",
+ "memchr",
+ "rustc_version",
+ "toml 1.1.2+spec-1.1.0",
+ "vswhom",
+ "winreg",
+]
+
+[[package]]
+name = "embed_plist"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ef6b89e5b37196644d8796de5268852ff179b44e96276cf4290264843743bb7"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "endi"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "66b7e2430c6dff6a955451e2cfc438f09cea1965a9d6f87f7e3b90decc014099"
+
+[[package]]
+name = "enum-as-inner"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "enum_dispatch"
+version = "0.3.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"
+dependencies = [
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "enumflags2"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1027f7680c853e056ebcec683615fb6fbbc07dbaa13b4d5d9442b146ded4ecef"
+dependencies = [
+ "enumflags2_derive",
+ "serde",
+]
+
+[[package]]
+name = "enumflags2_derive"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67c78a4d8fdf9953a5c9d458f9efe940fd97a0cab0941c075a813ac594733827"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "env_filter"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf3c259d255ca70051b30e2e95b5446cdb8949ac4cd22c0d7fd634d89f568e2"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "erased-serde"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2add8a07dd6a8d93ff627029c51de145e12686fbc36ecb298ac22e74cf02dec"
+dependencies = [
+ "serde",
+ "serde_core",
+ "typeid",
+]
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "etcetera"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "136d1b5283a1ab77bd9257427ffd09d8667ced0570b6f938942bc7568ed5b943"
+dependencies = [
+ "cfg-if",
+ "home",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "event-listener"
+version = "5.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
+dependencies = [
+ "event-listener",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
+[[package]]
+name = "fast-float2"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8eb564c5c7423d25c886fb561d1e4ee69f72354d16918afa32c08811f6b6a55"
+
+[[package]]
+name = "fastrand"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
+[[package]]
+name = "fdeflate"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e6853b52649d4ac5c0bd02320cddc5ba956bdb407c4b75a2c6b75bf51500f8c"
+dependencies = [
+ "simd-adler32",
+]
+
+[[package]]
+name = "fern"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4316185f709b23713e41e3195f90edef7fb00c3ed4adc79769cf09cc762a3b29"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "fiat-crypto"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64cd1e32ddd350061ae6edb1b082d7c54915b5c672c389143b9a63403a109f24"
+
+[[package]]
+name = "field-offset"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38e2275cc4e4fc009b0669731a1e5ab7ebf11f469eaede2bab9309a5b4d6057f"
+dependencies = [
+ "memoffset",
+ "rustc_version",
+]
+
+[[package]]
+name = "filetime"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f98844151eee8917efc50bd9e8318cb963ae8b297431495d3f758616ea5c57db"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "libredox",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+ "zlib-rs",
+]
+
+[[package]]
+name = "flume"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0e4dd2a88388a1f4ccc7c9ce104604dab68d9f408dc34cd45823d5a9069095"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+ "spin",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foldhash"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared 0.1.1",
+]
+
+[[package]]
+name = "foreign-types"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d737d9aa519fb7b749cbc3b962edcf310a8dd1f4b67c91c4f83975dbdd17d965"
+dependencies = [
+ "foreign-types-macros",
+ "foreign-types-shared 0.3.1",
+]
+
+[[package]]
+name = "foreign-types-macros"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a5c6c585bc94aaf2c7b51dd4c2ba22680844aba4c687be581871a6f518c5742"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "futures"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-intrusive"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d930c203dd0b6ff06e0201a4a2fe9149b43c684fd4420555b26d21b1a02956f"
+dependencies = [
+ "futures-core",
+ "lock_api",
+ "parking_lot",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-lite"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
+dependencies = [
+ "fastrand",
+ "futures-core",
+ "futures-io",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "gdk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9f245958c627ac99d8e529166f9823fb3b838d1d41fd2b297af3075093c2691"
+dependencies = [
+ "cairo-rs",
+ "gdk-pixbuf",
+ "gdk-sys",
+ "gio",
+ "glib",
+ "libc",
+ "pango",
+]
+
+[[package]]
+name = "gdk-pixbuf"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50e1f5f1b0bfb830d6ccc8066d18db35c487b1b2b1e8589b5dfe9f07e8defaec"
+dependencies = [
+ "gdk-pixbuf-sys",
+ "gio",
+ "glib",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "gdk-pixbuf-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9839ea644ed9c97a34d129ad56d38a25e6756f99f3a88e15cd39c20629caf7"
+dependencies = [
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gdk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c2d13f38594ac1e66619e188c6d5a1adb98d11b2fcf7894fc416ad76aa2f3f7"
+dependencies = [
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "pkg-config",
+ "system-deps",
+]
+
+[[package]]
+name = "gdkwayland-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "140071d506d223f7572b9f09b5e155afbd77428cd5cc7af8f2694c41d98dfe69"
+dependencies = [
+ "gdk-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pkg-config",
+ "system-deps",
+]
+
+[[package]]
+name = "gdkx11"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3caa00e14351bebbc8183b3c36690327eb77c49abc2268dd4bd36b856db3fbfe"
+dependencies = [
+ "gdk",
+ "gdkx11-sys",
+ "gio",
+ "glib",
+ "libc",
+ "x11",
+]
+
+[[package]]
+name = "gdkx11-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e7445fe01ac26f11601db260dd8608fe172514eb63b3b5e261ea6b0f4428d"
+dependencies = [
+ "gdk-sys",
+ "glib-sys",
+ "libc",
+ "system-deps",
+ "x11",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "generic-array"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dab9e9188e97a93276e1fe7b56401b851e2b45a46d045ca658100c1303ada649"
+dependencies = [
+ "generic-array 0.14.7",
+ "rustversion",
+ "typenum",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.9.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "js-sys",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+ "rand_core 0.10.1",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "ghash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"
+dependencies = [
+ "opaque-debug",
+ "polyval 0.6.2",
+]
+
+[[package]]
+name = "ghash"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2eecf2d5dc9b66b732b97707a0210906b1d30523eb773193ab777c0c84b3e8d5"
+dependencies = [
+ "polyval 0.7.1",
+]
+
+[[package]]
+name = "gio"
+version = "0.18.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4fc8f532f87b79cbc51a79748f16a6828fb784be93145a322fa14d06d354c73"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "gio-sys",
+ "glib",
+ "libc",
+ "once_cell",
+ "pin-project-lite",
+ "smallvec",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "gio-sys"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37566df850baf5e4cb0dfb78af2e4b9898d817ed9263d1090a2df958c64737d2"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+ "winapi",
+]
+
+[[package]]
+name = "glib"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "233daaf6e83ae6a12a52055f568f9d7cf4671dabb78ff9560ab6da230ce00ee5"
+dependencies = [
+ "bitflags 2.11.1",
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-task",
+ "futures-util",
+ "gio-sys",
+ "glib-macros",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "memchr",
+ "once_cell",
+ "smallvec",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "glib-macros"
+version = "0.18.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bb0228f477c0900c880fd78c8759b95c7636dbd7842707f49e132378aa2acdc"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro-crate 2.0.2",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "glib-sys"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "063ce2eb6a8d0ea93d2bf8ba1957e78dbab6be1c2220dd3daca57d5a9d869898"
+dependencies = [
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "gobject-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0850127b514d1c4a4654ead6dedadb18198999985908e6ffe4436f53c785ce44"
+dependencies = [
+ "glib-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "gtk"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd56fb197bfc42bd5d2751f4f017d44ff59fbb58140c6b49f9b3b2bdab08506a"
+dependencies = [
+ "atk",
+ "cairo-rs",
+ "field-offset",
+ "futures-channel",
+ "gdk",
+ "gdk-pixbuf",
+ "gio",
+ "glib",
+ "gtk-sys",
+ "gtk3-macros",
+ "libc",
+ "pango",
+ "pkg-config",
+]
+
+[[package]]
+name = "gtk-sys"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f29a1c21c59553eb7dd40e918be54dccd60c52b049b75119d5d96ce6b624414"
+dependencies = [
+ "atk-sys",
+ "cairo-sys-rs",
+ "gdk-pixbuf-sys",
+ "gdk-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "pango-sys",
+ "system-deps",
+]
+
+[[package]]
+name = "gtk3-macros"
+version = "0.18.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52ff3c5b21f14f0736fed6dcfc0bfb4225ebf5725f3c0209edeec181e4d73e9d"
+dependencies = [
+ "proc-macro-crate 1.3.1",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "h2"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f44da3a8150a6703ed5d34e164b875fd14c2cdab9af1252a9a1020bde2bdc54"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "http",
+ "indexmap 2.14.0",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "half"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+ "num-traits",
+ "zerocopy",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+dependencies = [
+ "ahash 0.7.8",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "allocator-api2",
+ "equivalent",
+ "foldhash 0.1.5",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51"
+
+[[package]]
+name = "hashlink"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7382cf6263419f2d8df38c55d7da83da5c18aef87fc7a7fc1fb1e344edfe14c1"
+dependencies = [
+ "hashbrown 0.15.5",
+]
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "hex-literal"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e712f64ec3850b98572bffac52e2c6f282b29fe6c5fa6d42334b30be438d95c1"
+
+[[package]]
+name = "hickory-proto"
+version = "0.25.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8a6fe56c0038198998a6f217ca4e7ef3a5e51f46163bd6dd60b5c71ca6c6502"
+dependencies = [
+ "async-trait",
+ "cfg-if",
+ "data-encoding",
+ "enum-as-inner",
+ "futures-channel",
+ "futures-io",
+ "futures-util",
+ "idna",
+ "ipnet",
+ "once_cell",
+ "rand 0.9.4",
+ "ring",
+ "thiserror 2.0.18",
+ "tinyvec",
+ "tokio",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "hickory-resolver"
+version = "0.25.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc62a9a99b0bfb44d2ab95a7208ac952d31060efc16241c87eaf36406fecf87a"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "hickory-proto",
+ "ipconfig",
+ "moka",
+ "once_cell",
+ "parking_lot",
+ "rand 0.9.4",
+ "resolv-conf",
+ "smallvec",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac 0.12.1",
+]
+
+[[package]]
+name = "hkdf"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4aaa26c720c68b866f2c96ef5c1264b3e6f473fe5d4ce61cd44bbe913e553018"
+dependencies = [
+ "hmac 0.13.0",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "hmac"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f"
+dependencies = [
+ "digest 0.11.3",
+]
+
+[[package]]
+name = "home"
+version = "0.5.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "hostname"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "617aaa3557aef3810a6369d0a99fac8a080891b68bd9f9812a1eeda0c0730cbd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "html5ever"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1054432bae2f14e0061e33d23402fbaa67a921d319d56adc6bcf887ddad1cbc2"
+dependencies = [
+ "log",
+ "markup5ever",
+]
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "http-body"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+dependencies = [
+ "bytes",
+ "http",
+]
+
+[[package]]
+name = "http-body-util"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "http",
+ "http-body",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "hybrid-array"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08d46837a0ed51fe95bd3b05de33cd64a1ee88fc797477ca48446872504507c5"
+dependencies = [
+ "ctutils",
+ "subtle",
+ "typenum",
+ "zeroize",
+]
+
+[[package]]
+name = "hyper"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6299f016b246a94207e63da54dbe807655bf9e00044f73ded42c3ac5305fbcca"
+dependencies = [
+ "atomic-waker",
+ "bytes",
+ "futures-channel",
+ "futures-core",
+ "h2",
+ "http",
+ "http-body",
+ "httparse",
+ "itoa",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+ "want",
+]
+
+[[package]]
+name = "hyper-rustls"
+version = "0.27.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33ca68d021ef39cf6463ab54c1d0f5daf03377b70561305bb89a8f83aab66e0f"
+dependencies = [
+ "http",
+ "hyper",
+ "hyper-util",
+ "rustls",
+ "tokio",
+ "tokio-rustls",
+ "tower-service",
+ "webpki-roots 1.0.7",
+]
+
+[[package]]
+name = "hyper-tls"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
+dependencies = [
+ "bytes",
+ "http-body-util",
+ "hyper",
+ "hyper-util",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+ "tower-service",
+]
+
+[[package]]
+name = "hyper-util"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-channel",
+ "futures-util",
+ "http",
+ "http-body",
+ "hyper",
+ "ipnet",
+ "libc",
+ "percent-encoding",
+ "pin-project-lite",
+ "socket2",
+ "system-configuration",
+ "tokio",
+ "tower-service",
+ "tracing",
+ "windows-registry",
+]
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core 0.62.2",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "ico"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e795dff5605e0f04bff85ca41b51a96b83e80b281e96231bcaaf1ac35103371"
+dependencies = [
+ "byteorder",
+ "png 0.17.16",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2984d1cd16c883d7935b9e07e44071dca8d917fd52ecc02c04d5fa0b5a3f191c"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "utf8_iter",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92219b62b3e2b4d88ac5119f8904c10f8f61bf7e95b640d25ba3075e6cac2c29"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c56e5ee99d6e3d33bd91c5d85458b6005a22140021cc324cea84dd0e72cff3b4"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da3be0ae77ea334f4da67c12f149704f19f81d1adf7c51cf482943e84a2bad38"
+
+[[package]]
+name = "icu_properties"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bee3b67d0ea5c2cca5003417989af8996f8604e34fb9ddf96208a033901e70de"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e2bbb201e0c04f7b4b3e14382af113e17ba4f63e2c9d2ee626b720cbce54a14"
+
+[[package]]
+name = "icu_provider"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "139c4cf31c8b5f33d7e199446eff9c1e02decfc2f0eec2c8d71f65befa45b421"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.0",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "infer"
+version = "0.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a588916bfdfd92e71cacef98a63d9b1f0d74d6599980d11894290e7ddefffcf7"
+dependencies = [
+ "cfb",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "block-padding 0.3.3",
+ "generic-array 0.14.7",
+]
+
+[[package]]
+name = "inout"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4250ce6452e92010fdf7268ccc5d14faa80bb12fc741938534c58f16804e03c7"
+dependencies = [
+ "block-padding 0.4.2",
+ "hybrid-array",
+]
+
+[[package]]
+name = "internal-russh-forked-ssh-key"
+version = "0.6.18+upstream-0.6.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25f8a978272e3cbdf4768f7363eb1c8e1e6ba63c52a3ed05e29e222da4aec7cb"
+dependencies = [
+ "argon2",
+ "bcrypt-pbkdf",
+ "crypto-bigint",
+ "ecdsa",
+ "ed25519-dalek",
+ "hex",
+ "hmac 0.13.0",
+ "num-bigint-dig",
+ "p256",
+ "p384",
+ "p521",
+ "rand_core 0.10.1",
+ "rsa 0.10.0-rc.16",
+ "sec1",
+ "sha1 0.11.0",
+ "sha2 0.11.0",
+ "signature 3.0.0",
+ "ssh-cipher",
+ "ssh-encoding",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "internal-russh-num-bigint"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae8e22120c32fb4d19ec55fba35015f57095cd95a2e3b732e44457f5915b2ee8"
+dependencies = [
+ "num-integer",
+ "num-traits",
+ "rand 0.10.1",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "ipconfig"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d40460c0ce33d6ce4b0630ad68ff63d6661961c48b6dba35e5a4d81cfb48222"
+dependencies = [
+ "socket2",
+ "widestring",
+ "windows-registry",
+ "windows-result 0.4.1",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
+
+[[package]]
+name = "iri-string"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25e659a4bb38e810ebc252e53b5814ff908a8c58c2a9ce2fae1bbec24cbf4e20"
+dependencies = [
+ "memchr",
+ "serde",
+]
+
+[[package]]
+name = "is-docker"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "928bae27f42bc99b60d9ac7334e3a21d10ad8f1835a4e12ec3ec0464765ed1b3"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "is-wsl"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "173609498df190136aa7dea1a91db051746d339e18476eed5ca40521f02d7aa5"
+dependencies = [
+ "is-docker",
+ "once_cell",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "javascriptcore-rs"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca5671e9ffce8ffba57afc24070e906da7fc4b1ba66f2cabebf61bf2ea257fcc"
+dependencies = [
+ "bitflags 1.3.2",
+ "glib",
+ "javascriptcore-rs-sys",
+]
+
+[[package]]
+name = "javascriptcore-rs-sys"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af1be78d14ffa4b75b66df31840478fef72b51f8c2465d4ca7c194da9f7a5124"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "jni"
+version = "0.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97"
+dependencies = [
+ "cesu8",
+ "cfg-if",
+ "combine",
+ "jni-sys 0.3.1",
+ "log",
+ "thiserror 1.0.69",
+ "walkdir",
+ "windows-sys 0.45.0",
+]
+
+[[package]]
+name = "jni"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498"
+dependencies = [
+ "cfg-if",
+ "combine",
+ "jni-macros",
+ "jni-sys 0.4.1",
+ "log",
+ "simd_cesu8",
+ "thiserror 2.0.18",
+ "walkdir",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "jni-macros"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "simd_cesu8",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258"
+dependencies = [
+ "jni-sys 0.4.1",
+]
+
+[[package]]
+name = "jni-sys"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6377a88cb3910bee9b0fa88d4f42e1d2da8e79915598f65fb0c7ee14c878af2"
+dependencies = [
+ "jni-sys-macros",
+]
+
+[[package]]
+name = "jni-sys-macros"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38c0b942f458fe50cdac086d2f946512305e5631e720728f2a61aabcd47a6264"
+dependencies = [
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.4",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.97"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1840c94c045fbcf8ba2812c95db44499f7c64910a912551aaaa541decebcacf"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "json-patch"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "863726d7afb6bc2590eeff7135d923545e5e964f004c2ccf8716c25e70a86f08"
+dependencies = [
+ "jsonptr",
+ "serde",
+ "serde_json",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "jsonptr"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dea2b27dd239b2556ed7a25ba842fe47fd602e7fc7433c2a8d6106d4d9edd70"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "keccak"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e24a010dd405bd7ed803e5253182815b41bf2e6a80cc3bfc066658e03a198aa"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+]
+
+[[package]]
+name = "kem"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01737161ba802849cfd486b5bd209d38ba4943494c249a8126005170c7621edd"
+dependencies = [
+ "crypto-common 0.2.1",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "keyboard-types"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b750dcadc39a09dbadd74e118f6dd6598df77fa01df0cfcdc52c28dece74528a"
+dependencies = [
+ "bitflags 2.11.1",
+ "serde",
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "keyring"
+version = "3.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eebcc3aff044e5944a8fbaf69eb277d11986064cba30c468730e8b9909fb551c"
+dependencies = [
+ "byteorder",
+ "dbus-secret-service",
+ "linux-keyutils",
+ "log",
+ "secret-service",
+ "security-framework 2.11.1",
+ "security-framework 3.7.0",
+ "windows-sys 0.60.2",
+ "zeroize",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+dependencies = [
+ "spin",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "lexical-core"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8d125a277f807e55a77304455eb7b1cb52f2b18c143b60e766c120bd64a594"
+dependencies = [
+ "lexical-parse-float",
+ "lexical-parse-integer",
+ "lexical-util",
+ "lexical-write-float",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-parse-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52a9f232fbd6f550bc0137dcb5f99ab674071ac2d690ac69704593cb4abbea56"
+dependencies = [
+ "lexical-parse-integer",
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-parse-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a7a039f8fb9c19c996cd7b2fcce303c1b2874fe1aca544edc85c4a5f8489b34"
+dependencies = [
+ "lexical-util",
+]
+
+[[package]]
+name = "lexical-util"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2604dd126bb14f13fb5d1bd6a66155079cb9fa655b37f875b3a742c705dbed17"
+
+[[package]]
+name = "lexical-write-float"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50c438c87c013188d415fbabbb1dceb44249ab81664efbd31b14ae55dabb6361"
+dependencies = [
+ "lexical-util",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-write-integer"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "409851a618475d2d5796377cad353802345cba92c867d9fbcde9cf4eac4e14df"
+dependencies = [
+ "lexical-util",
+]
+
+[[package]]
+name = "libappindicator"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03589b9607c868cc7ae54c0b2a22c8dc03dd41692d48f2d7df73615c6a95dc0a"
+dependencies = [
+ "glib",
+ "gtk",
+ "gtk-sys",
+ "libappindicator-sys",
+ "log",
+]
+
+[[package]]
+name = "libappindicator-sys"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e9ec52138abedcc58dc17a7c6c0c00a2bdb4f3427c7f63fa97fd0d859155caf"
+dependencies = [
+ "gtk-sys",
+ "libloading",
+ "once_cell",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "libdbus-sys"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "328c4789d42200f1eeec05bd86c9c13c7f091d2ba9a6ea35acdf51f31bc0f043"
+dependencies = [
+ "pkg-config",
+]
+
+[[package]]
+name = "libduckdb-sys"
+version = "1.10502.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d7401630ae2abcff642f7156294289e50f2d222e061c026ad797b01bf20c215"
+dependencies = [
+ "cc",
+ "flate2",
+ "pkg-config",
+ "reqwest 0.12.28",
+ "serde",
+ "serde_json",
+ "tar",
+ "vcpkg",
+ "zip 6.0.0",
+]
+
+[[package]]
+name = "libloading"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
+dependencies = [
+ "cfg-if",
+ "winapi",
+]
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "libredox"
+version = "0.1.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c"
+dependencies = [
+ "bitflags 2.11.1",
+ "libc",
+ "plain",
+ "redox_syscall 0.7.4",
+]
+
+[[package]]
+name = "libsqlite3-sys"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "linux-keyutils"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83270a18e9f90d0707c41e9f35efada77b64c0e6f3f1810e71c8368a864d5590"
+dependencies = [
+ "bitflags 2.11.1",
+ "libc",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litemap"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92daf443525c4cce67b150400bc2316076100ce0b3686209eb8cf3c31612e6f0"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+dependencies = [
+ "value-bag",
+]
+
+[[package]]
+name = "lru-slab"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+
+[[package]]
+name = "macro_magic"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc33f9f0351468d26fbc53d9ce00a096c8522ecb42f19b50f34f2c422f76d21d"
+dependencies = [
+ "macro_magic_core",
+ "macro_magic_macros",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "macro_magic_core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1687dc887e42f352865a393acae7cf79d98fab6351cde1f58e9e057da89bf150"
+dependencies = [
+ "const-random",
+ "derive-syn-parse",
+ "macro_magic_core_macros",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "macro_magic_core_macros"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b02abfe41815b5bd98dbd4260173db2c116dda171dc0fe7838cb206333b83308"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "macro_magic_macros"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ea28ee64b88876bf45277ed9a5817c1817df061a74f2b988971a12570e5869"
+dependencies = [
+ "macro_magic_core",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "markup5ever"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8983d30f2915feeaaab2d6babdd6bc7e9ed1a00b66b5e6d74df19aa9c0e91862"
+dependencies = [
+ "log",
+ "tendril",
+ "web_atoms",
+]
+
+[[package]]
+name = "md-5"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf"
+dependencies = [
+ "cfg-if",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "md5"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e6bcd6433cff03a4bfc3d9834d504467db1f1cf6d0ea765d37d330249ed629d"
+
+[[package]]
+name = "md5"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "490cc448043f947bae3cbee9c203358d62dbee0db12107a74be5c30ccfd09771"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "minisign-verify"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22f9645cb765ea72b8111f36c522475d2daa0d22c957a9826437e97534bc4e9e"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
+dependencies = [
+ "libc",
+ "wasi 0.11.1+wasi-snapshot-preview1",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "ml-kem"
+version = "0.3.0-rc.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8198b5db27ac9773534c371751a59dc18aec8b80aa141e69abfdd1dec2e3f78c"
+dependencies = [
+ "hybrid-array",
+ "kem",
+ "module-lattice",
+ "rand_core 0.10.1",
+ "sha3",
+]
+
+[[package]]
+name = "module-lattice"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc7c90d33a0dac244570c26461d761ffaeadb3bfc2b17cc625ae2185cafdffae"
+dependencies = [
+ "ctutils",
+ "hybrid-array",
+ "num-traits",
+]
+
+[[package]]
+name = "moka"
+version = "0.12.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "957228ad12042ee839f93c8f257b62b4c0ab5eaae1d4fa60de53b27c9d7c5046"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "equivalent",
+ "parking_lot",
+ "portable-atomic",
+ "smallvec",
+ "tagptr",
+ "uuid",
+]
+
+[[package]]
+name = "mongocrypt"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8da0cd419a51a5fb44819e290fbdb0665a54f21dead8923446a799c7f4d26ad9"
+dependencies = [
+ "bson",
+ "mongocrypt-sys",
+ "once_cell",
+ "serde",
+]
+
+[[package]]
+name = "mongocrypt-sys"
+version = "0.1.5+1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224484c5d09285a7b8cb0a0c117e847ebd14cb6e4470ecf68cdb89c503b0edb9"
+
+[[package]]
+name = "mongodb"
+version = "3.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ef2c933617431ad0246fb5b43c425ebdae18c7f7259c87de0726d93b0e7e91b"
+dependencies = [
+ "base64 0.22.1",
+ "bitflags 2.11.1",
+ "bson",
+ "derive-where",
+ "derive_more",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "hex",
+ "hickory-proto",
+ "hickory-resolver",
+ "hmac 0.12.1",
+ "macro_magic",
+ "md-5",
+ "mongocrypt",
+ "mongodb-internal-macros",
+ "pbkdf2 0.12.2",
+ "percent-encoding",
+ "rand 0.9.4",
+ "rustc_version_runtime",
+ "rustls",
+ "rustversion",
+ "serde",
+ "serde_bytes",
+ "serde_with",
+ "sha1 0.10.6",
+ "sha2 0.10.9",
+ "socket2",
+ "stringprep",
+ "strsim",
+ "take_mut",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-rustls",
+ "tokio-util",
+ "typed-builder",
+ "uuid",
+ "webpki-roots 1.0.7",
+]
+
+[[package]]
+name = "mongodb-internal-macros"
+version = "3.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5758dc828eb2d02ec30563cba365609d56ddd833190b192beaee2b475a7bb3"
+dependencies = [
+ "macro_magic",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "muda"
+version = "0.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ae8844f63b5b118e334e205585b8c5c17b984121dbdb179d44aeb087ffad3cb"
+dependencies = [
+ "crossbeam-channel",
+ "dpi",
+ "gtk",
+ "keyboard-types",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "once_cell",
+ "png 0.18.1",
+ "serde",
+ "thiserror 2.0.18",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "native-tls"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "465500e14ea162429d264d44189adc38b199b62b1c21eea9f69e4b73cb03bbf2"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework 3.7.0",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "ndk"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4"
+dependencies = [
+ "bitflags 2.11.1",
+ "jni-sys 0.3.1",
+ "log",
+ "ndk-sys",
+ "num_enum",
+ "raw-window-handle",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "ndk-sys"
+version = "0.6.0+11769913"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee6cda3051665f1fb8d9e08fc35c96d5a244fb1be711a03b71118828afc9a873"
+dependencies = [
+ "jni-sys 0.3.1",
+]
+
+[[package]]
+name = "new_debug_unreachable"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
+
+[[package]]
+name = "nix"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
+dependencies = [
+ "bitflags 2.11.1",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+ "memoffset",
+]
+
+[[package]]
+name = "nix"
+version = "0.31.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d6d0705320c1e6ba1d912b5e37cf18071b6c2e9b7fa8215a1e8a7651966f5d3"
+dependencies = [
+ "bitflags 2.11.1",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
+name = "num"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "35bd024e8b2ff75562e5f34e7f4905839deb4b22955ef5e73d2fea1b9813cb23"
+dependencies = [
+ "num-bigint",
+ "num-complex",
+ "num-integer",
+ "num-iter",
+ "num-rational",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+dependencies = [
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-bigint-dig"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e661dda6640fad38e827a6d4a310ff4763082116fe217f279885c97f511bb0b7"
+dependencies = [
+ "lazy_static",
+ "libm",
+ "num-integer",
+ "num-iter",
+ "num-traits",
+ "rand 0.8.6",
+ "serde",
+ "smallvec",
+ "zeroize",
+]
+
+[[package]]
+name = "num-complex"
+version = "0.4.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6673768db2d862beb9b39a78fdcb1a69439615d5794a1be50caa9bc92c81967"
+
+[[package]]
+name = "num-integer"
+version = "0.1.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "num-iter"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1429034a0490724d0075ebb2bc9e875d6503c3cf69e235a8941aa757d83ef5bf"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-rational"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f83d14da390562dca69fc84082e73e548e1ad308d24accdedd2720017cb37824"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+ "libm",
+]
+
+[[package]]
+name = "num_enum"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0bca838442ec211fa11de3a8b0e0e8f3a4522575b5c4c06ed722e005036f26"
+dependencies = [
+ "num_enum_derive",
+ "rustversion",
+]
+
+[[package]]
+name = "num_enum_derive"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "680998035259dcfcafe653688bf2aa6d3e2dc05e98be6ab46afb089dc84f1df8"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "num_threads"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "objc2"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
+dependencies = [
+ "objc2-encode",
+ "objc2-exception-helper",
+]
+
+[[package]]
+name = "objc2-app-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-cloud-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-data"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
+dependencies = [
+ "bitflags 2.11.1",
+ "dispatch2",
+ "objc2",
+]
+
+[[package]]
+name = "objc2-core-graphics"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
+dependencies = [
+ "bitflags 2.11.1",
+ "dispatch2",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-io-surface",
+]
+
+[[package]]
+name = "objc2-core-image"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-location"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca347214e24bc973fc025fd0d36ebb179ff30536ed1f80252706db19ee452009"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-text"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
+[[package]]
+name = "objc2-exception-helper"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7a1c5fbb72d7735b076bb47b578523aedc40f3c439bea6dfd595c089d79d98a"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "objc2-foundation"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "libc",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-io-surface"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-core-foundation",
+]
+
+[[package]]
+name = "objc2-osa-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f112d1746737b0da274ef79a23aac283376f335f4095a083a267a082f21db0c0"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-quartz-core"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
+dependencies = [
+ "bitflags 2.11.1",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-ui-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "objc2",
+ "objc2-cloud-kit",
+ "objc2-core-data",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-core-image",
+ "objc2-core-location",
+ "objc2-core-text",
+ "objc2-foundation",
+ "objc2-quartz-core",
+ "objc2-user-notifications",
+]
+
+[[package]]
+name = "objc2-user-notifications"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9df9128cbbfef73cda168416ccf7f837b62737d748333bfe9ab71c245d76613e"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-web-kit"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2e5aaab980c433cf470df9d7af96a7b46a9d892d521a2cbbb2f8a4c16751e7f"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+dependencies = [
+ "critical-section",
+ "portable-atomic",
+]
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "open"
+version = "5.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f3bab717c29a857abf75fcef718d441ec7cb2725f937343c734740a985d37fd"
+dependencies = [
+ "dunce",
+ "is-wsl",
+ "libc",
+ "pathdiff",
+]
+
+[[package]]
+name = "openssl"
+version = "0.10.78"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f38c4372413cdaaf3cc79dd92d29d7d9f5ab09b51b10dded508fb90bb70b9222"
+dependencies = [
+ "bitflags 2.11.1",
+ "cfg-if",
+ "foreign-types 0.3.2",
+ "libc",
+ "once_cell",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13ce1245cd07fcc4cfdb438f7507b0c7e4f3849a69fd84d52374c66d83741bb6"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
+[[package]]
+name = "oracle-rs"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c9ca364b441f92b717658c62e85207158b30285deb01811ccd923017f61612e"
+dependencies = [
+ "aes 0.8.4",
+ "async-trait",
+ "bytes",
+ "cbc 0.1.2",
+ "chrono",
+ "hex",
+ "hmac 0.12.1",
+ "hostname",
+ "indexmap 2.14.0",
+ "md-5",
+ "pbkdf2 0.12.2",
+ "pkcs8 0.10.2",
+ "rand 0.8.6",
+ "rustls",
+ "rustls-pemfile",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "sha1 0.10.6",
+ "sha2 0.10.9",
+ "thiserror 1.0.69",
+ "tokio",
+ "tokio-rustls",
+ "tracing",
+ "webpki-roots 0.26.11",
+]
+
+[[package]]
+name = "ordered-stream"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aa2b01e1d916879f73a53d01d1d6cee68adbb31d6d9177a8cfce093cced1d50"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "os_pipe"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "osakit"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "732c71caeaa72c065bb69d7ea08717bd3f4863a4f451402fc9513e29dbd5261b"
+dependencies = [
+ "objc2",
+ "objc2-foundation",
+ "objc2-osa-kit",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "p256"
+version = "0.14.0-rc.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "018bfbb86e05fd70a83e985921241035ee09fcd369c4a2c3680b389a01d2ad28"
+dependencies = [
+ "ecdsa",
+ "elliptic-curve",
+ "primefield",
+ "primeorder",
+ "sha2 0.11.0",
+]
+
+[[package]]
+name = "p384"
+version = "0.14.0-rc.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c91df688211f5957dbe2ab599dcbcaade8d6d3cdc15c5b350d350d7d07ce423"
+dependencies = [
+ "ecdsa",
+ "elliptic-curve",
+ "fiat-crypto",
+ "primefield",
+ "primeorder",
+ "sha2 0.11.0",
+]
+
+[[package]]
+name = "p521"
+version = "0.14.0-rc.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de6cd9451de522549d36cc78a1b45a699a3d55a872e8ea0c8f0318e502d99e2c"
+dependencies = [
+ "base16ct",
+ "ecdsa",
+ "elliptic-curve",
+ "primefield",
+ "primeorder",
+ "sha2 0.11.0",
+]
+
+[[package]]
+name = "pageant"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b537f975f6d8dcf48db368d7ec209d583b015713b5df0f5d92d2631e4ff5595"
+dependencies = [
+ "byteorder",
+ "bytes",
+ "delegate",
+ "futures",
+ "log",
+ "rand 0.8.6",
+ "sha2 0.10.9",
+ "thiserror 1.0.69",
+ "tokio",
+ "windows 0.62.2",
+ "windows-strings 0.5.1",
+]
+
+[[package]]
+name = "pango"
+version = "0.18.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ca27ec1eb0457ab26f3036ea52229edbdb74dee1edd29063f5b9b010e7ebee4"
+dependencies = [
+ "gio",
+ "glib",
+ "libc",
+ "once_cell",
+ "pango-sys",
+]
+
+[[package]]
+name = "pango-sys"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436737e391a843e5933d6d9aa102cb126d501e815b83601365a948a518555dc5"
+dependencies = [
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "parking"
+version = "2.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall 0.5.18",
+ "smallvec",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "password-hash"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "346f04948ba92c43e8469c1ee6736c7563d71012b17d40745260fe106aac2166"
+dependencies = [
+ "base64ct",
+ "rand_core 0.6.4",
+ "subtle",
+]
+
+[[package]]
+name = "pathdiff"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3"
+
+[[package]]
+name = "pbkdf2"
+version = "0.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2"
+dependencies = [
+ "digest 0.10.7",
+ "hmac 0.12.1",
+]
+
+[[package]]
+name = "pbkdf2"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "112d82ceb8c5bf524d9af484d4e4970c9fd5a0cc15ba14ad93dccd28873b0629"
+dependencies = [
+ "digest 0.11.3",
+ "hmac 0.13.0",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "pem-rfc7468"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6305423e0e7738146434843d1694d621cce767262b2a86910beab705e4493d9"
+dependencies = [
+ "base64ct",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "phf"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
+dependencies = [
+ "phf_macros 0.11.3",
+ "phf_shared 0.11.3",
+]
+
+[[package]]
+name = "phf"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c1562dc717473dbaa4c1f85a36410e03c047b2e7df7f45ee938fbef64ae7fadf"
+dependencies = [
+ "phf_macros 0.13.1",
+ "phf_shared 0.13.1",
+ "serde",
+]
+
+[[package]]
+name = "phf_codegen"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49aa7f9d80421bca176ca8dbfebe668cc7a2684708594ec9f3c0db0805d5d6e1"
+dependencies = [
+ "phf_generator 0.13.1",
+ "phf_shared 0.13.1",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
+dependencies = [
+ "phf_shared 0.11.3",
+ "rand 0.8.6",
+]
+
+[[package]]
+name = "phf_generator"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135ace3a761e564ec88c03a77317a7c6b80bb7f7135ef2544dbe054243b89737"
+dependencies = [
+ "fastrand",
+ "phf_shared 0.13.1",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
+dependencies = [
+ "phf_generator 0.11.3",
+ "phf_shared 0.11.3",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "phf_macros"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812f032b54b1e759ccd5f8b6677695d5268c588701effba24601f6932f8269ef"
+dependencies = [
+ "phf_generator 0.13.1",
+ "phf_shared 0.13.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "phf_shared"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e57fef6bc5981e38c2ce2d63bfa546861309f875b8a75f092d1d54ae2d64f266"
+dependencies = [
+ "siphasher",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
+[[package]]
+name = "piper"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c835479a4443ded371d6c535cbfd8d31ad92c5d23ae9770a61bc155e4992a3c1"
+dependencies = [
+ "atomic-waker",
+ "fastrand",
+ "futures-io",
+]
+
+[[package]]
+name = "pkcs1"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f"
+dependencies = [
+ "der 0.7.10",
+ "pkcs8 0.10.2",
+ "spki 0.7.3",
+]
+
+[[package]]
+name = "pkcs1"
+version = "0.8.0-rc.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "986d2e952779af96ea048f160fd9194e1751b4faea78bcf3ceb456efe008088e"
+dependencies = [
+ "der 0.8.0",
+ "spki 0.8.0-rc.4",
+]
+
+[[package]]
+name = "pkcs5"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e847e2c91a18bfa887dd028ec33f2fe6f25db77db3619024764914affe8b69a6"
+dependencies = [
+ "aes 0.8.4",
+ "cbc 0.1.2",
+ "der 0.7.10",
+ "pbkdf2 0.12.2",
+ "scrypt 0.11.0",
+ "sha2 0.10.9",
+ "spki 0.7.3",
+]
+
+[[package]]
+name = "pkcs5"
+version = "0.8.0-rc.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5a777c6e26664bc9504b3ce3f6133f8f20d9071f130a4f9fcbd3186959d8dd6"
+dependencies = [
+ "aes 0.9.0",
+ "aes-gcm 0.11.0-rc.3",
+ "cbc 0.2.0",
+ "der 0.8.0",
+ "pbkdf2 0.13.0",
+ "rand_core 0.10.1",
+ "scrypt 0.12.0",
+ "sha2 0.11.0",
+ "spki 0.8.0-rc.4",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der 0.7.10",
+ "pkcs5 0.7.1",
+ "rand_core 0.6.4",
+ "spki 0.7.3",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.11.0-rc.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "12922b6296c06eb741b02d7b5161e3aaa22864af38dfa025a1a3ba3f68c84577"
+dependencies = [
+ "der 0.8.0",
+ "pkcs5 0.8.0-rc.13",
+ "rand_core 0.10.1",
+ "spki 0.8.0-rc.4",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e"
+
+[[package]]
+name = "plain"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
+
+[[package]]
+name = "plist"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "092791278e026273c1b65bbdcfbba3a300f2994c896bd01ab01da613c29c46f1"
+dependencies = [
+ "base64 0.22.1",
+ "indexmap 2.14.0",
+ "quick-xml 0.39.2",
+ "serde",
+ "time",
+]
+
+[[package]]
+name = "png"
+version = "0.17.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526"
+dependencies = [
+ "bitflags 1.3.2",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "png"
+version = "0.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60769b8b31b2a9f263dae2776c37b1b28ae246943cf719eb6946a1db05128a61"
+dependencies = [
+ "bitflags 2.11.1",
+ "crc32fast",
+ "fdeflate",
+ "flate2",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "polling"
+version = "3.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
+dependencies = [
+ "cfg-if",
+ "concurrent-queue",
+ "hermit-abi",
+ "pin-project-lite",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "poly1305"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
+dependencies = [
+ "cpufeatures 0.2.17",
+ "opaque-debug",
+ "universal-hash 0.5.1",
+]
+
+[[package]]
+name = "polyval"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "opaque-debug",
+ "universal-hash 0.5.1",
+]
+
+[[package]]
+name = "polyval"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dfc63250416fea14f5749b90725916a6c903f599d51cb635aa7a52bfd03eede"
+dependencies = [
+ "cpubits",
+ "cpufeatures 0.3.0",
+ "universal-hash 0.6.1",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "portpicker"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be97d76faf1bfab666e1375477b23fde79eccf0276e9b63b92a39d676a889ba9"
+dependencies = [
+ "rand 0.8.6",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0103b1cef7ec0cf76490e969665504990193874ea05c85ff9bab8b911d0a0564"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "precomputed-hash"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
+
+[[package]]
+name = "pretty-hex"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6fa0831dd7cc608c38a5e323422a0077678fa5744aa2be4ad91c4ece8eec8d5"
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "primefield"
+version = "0.14.0-rc.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93401c13cc7ff24684571cfca9d3cf9ebabfaf3d4b7b9963ade41ec54da196b5"
+dependencies = [
+ "crypto-bigint",
+ "crypto-common 0.2.1",
+ "rand_core 0.10.1",
+ "rustcrypto-ff",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "primeorder"
+version = "0.14.0-rc.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0c5c8a39bcd764bfedf456e8d55e115fe86dda3e0f555371849f2a41cbc9706"
+dependencies = [
+ "elliptic-curve",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
+dependencies = [
+ "once_cell",
+ "toml_edit 0.19.15",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b00f26d3400549137f92511a46ac1cd8ce37cb5598a96d382381458b992a5d24"
+dependencies = [
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
+dependencies = [
+ "toml_edit 0.25.11+spec-1.1.0",
+]
+
+[[package]]
+name = "proc-macro-error"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+dependencies = [
+ "proc-macro-error-attr",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro-error-attr"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "version_check",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "ptr_meta"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1"
+dependencies = [
+ "ptr_meta_derive",
+]
+
+[[package]]
+name = "ptr_meta_derive"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.37.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "331e97a1af0bf59823e6eadffe373d7b27f485be8748f71471c662c1f269b7fb"
+dependencies = [
+ "encoding_rs",
+ "memchr",
+]
+
+[[package]]
+name = "quick-xml"
+version = "0.39.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "958f21e8e7ceb5a1aa7fa87fab28e7c75976e0bfe7e23ff069e0a260f894067d"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "quinn"
+version = "0.11.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
+dependencies = [
+ "bytes",
+ "cfg_aliases",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash",
+ "rustls",
+ "socket2",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-proto"
+version = "0.11.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
+dependencies = [
+ "bytes",
+ "getrandom 0.3.4",
+ "lru-slab",
+ "rand 0.9.4",
+ "ring",
+ "rustc-hash",
+ "rustls",
+ "rustls-pki-types",
+ "slab",
+ "thiserror 2.0.18",
+ "tinyvec",
+ "tracing",
+ "web-time",
+]
+
+[[package]]
+name = "quinn-udp"
+version = "0.5.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
+dependencies = [
+ "cfg_aliases",
+ "libc",
+ "once_cell",
+ "socket2",
+ "tracing",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "rand"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
+dependencies = [
+ "getrandom 0.1.16",
+ "libc",
+ "rand_chacha 0.2.2",
+ "rand_core 0.5.1",
+ "rand_hc",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
+dependencies = [
+ "chacha20 0.10.0",
+ "getrandom 0.4.2",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.5.1",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
+dependencies = [
+ "getrandom 0.1.16",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.17",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+
+[[package]]
+name = "rand_hc"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
+dependencies = [
+ "rand_core 0.5.1",
+]
+
+[[package]]
+name = "raw-window-handle"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
+
+[[package]]
+name = "redis"
+version = "0.32.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "014cc767fefab6a3e798ca45112bccad9c6e0e218fbd49720042716c73cfef44"
+dependencies = [
+ "bytes",
+ "cfg-if",
+ "combine",
+ "futures-util",
+ "itoa",
+ "num-bigint",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls",
+ "rustls-native-certs",
+ "ryu",
+ "sha1_smol",
+ "socket2",
+ "tokio",
+ "tokio-rustls",
+ "tokio-util",
+ "url",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.11.1",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f450ad9c3b1da563fb6948a8e0fb0fb9269711c9c73d9ea1de5058c79c8d643a"
+dependencies = [
+ "bitflags 2.11.1",
+]
+
+[[package]]
+name = "redox_users"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "ref-cast"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+
+[[package]]
+name = "rend"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71fe3824f5629716b1589be05dacd749f6aa084c87e00e016714a8cdfccc997c"
+dependencies = [
+ "bytecheck",
+]
+
+[[package]]
+name = "reqwest"
+version = "0.12.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "encoding_rs",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-tls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "mime",
+ "native-tls",
+ "percent-encoding",
+ "pin-project-lite",
+ "quinn",
+ "rustls",
+ "rustls-pki-types",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "sync_wrapper",
+ "tokio",
+ "tokio-native-tls",
+ "tokio-rustls",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams 0.4.2",
+ "web-sys",
+ "webpki-roots 1.0.7",
+]
+
+[[package]]
+name = "reqwest"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62e0021ea2c22aed41653bc7e1419abb2c97e038ff2c33d0e1309e49a97deec0"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http",
+ "http-body",
+ "http-body-util",
+ "hyper",
+ "hyper-rustls",
+ "hyper-util",
+ "js-sys",
+ "log",
+ "percent-encoding",
+ "pin-project-lite",
+ "rustls",
+ "rustls-pki-types",
+ "rustls-platform-verifier",
+ "serde",
+ "serde_json",
+ "sync_wrapper",
+ "tokio",
+ "tokio-rustls",
+ "tokio-util",
+ "tower",
+ "tower-http",
+ "tower-service",
+ "url",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "wasm-streams 0.5.0",
+ "web-sys",
+]
+
+[[package]]
+name = "resolv-conf"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e061d1b48cb8d38042de4ae0a7a6401009d6143dc80d2e2d6f31f0bdd6470c7"
+
+[[package]]
+name = "rfc6979"
+version = "0.5.0-rc.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23a3127ee32baec36af75b4107082d9bd823501ec14a4e016be4b6b37faa74ae"
+dependencies = [
+ "hmac 0.13.0",
+ "subtle",
+]
+
+[[package]]
+name = "rfd"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a15ad77d9e70a92437d8f74c35d99b4e4691128df018833e99f90bcd36152672"
+dependencies = [
+ "block2",
+ "dispatch2",
+ "glib-sys",
+ "gobject-sys",
+ "gtk-sys",
+ "js-sys",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "raw-window-handle",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted 0.9.0",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rkyv"
+version = "0.7.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2297bf9c81a3f0dc96bc9521370b88f054168c29826a75e89c55ff196e7ed6a1"
+dependencies = [
+ "bitvec",
+ "bytecheck",
+ "bytes",
+ "hashbrown 0.12.3",
+ "ptr_meta",
+ "rend",
+ "rkyv_derive",
+ "seahash",
+ "tinyvec",
+ "uuid",
+]
+
+[[package]]
+name = "rkyv_derive"
+version = "0.7.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84d7b42d4b8d06048d3ac8db0eb31bcb942cbeb709f0b5f2b2ebde398d3038f5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "rsa"
+version = "0.9.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8573f03f5883dcaebdfcf4725caa1ecb9c15b2ef50c43a07b816e06799bb12d"
+dependencies = [
+ "const-oid 0.9.6",
+ "digest 0.10.7",
+ "num-bigint-dig",
+ "num-integer",
+ "num-traits",
+ "pkcs1 0.7.5",
+ "pkcs8 0.10.2",
+ "rand_core 0.6.4",
+ "signature 2.2.0",
+ "spki 0.7.3",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rsa"
+version = "0.10.0-rc.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fb9fd8c1edd9e6a2693623baf0fe77ff05ce022a5d7746900ffc38a15c233de"
+dependencies = [
+ "const-oid 0.10.2",
+ "crypto-bigint",
+ "crypto-primes",
+ "digest 0.11.3",
+ "pkcs1 0.8.0-rc.4",
+ "pkcs8 0.11.0-rc.11",
+ "rand_core 0.10.1",
+ "sha2 0.11.0",
+ "signature 3.0.0",
+ "spki 0.8.0-rc.4",
+ "zeroize",
+]
+
+[[package]]
+name = "russh"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c9e358980fe9b079b99da387117864ee6f0a3fd02f39e5b5fde6af9c2895374"
+dependencies = [
+ "aead 0.6.0-rc.10",
+ "aes 0.8.4",
+ "aes 0.9.0",
+ "aes-gcm 0.11.0-rc.3",
+ "aws-lc-rs",
+ "bitflags 2.11.1",
+ "block-padding 0.3.3",
+ "byteorder",
+ "bytes",
+ "cbc 0.1.2",
+ "cbc 0.2.0",
+ "cipher 0.5.1",
+ "crypto-bigint",
+ "ctr 0.10.0",
+ "ctr 0.9.2",
+ "curve25519-dalek",
+ "data-encoding",
+ "delegate",
+ "der 0.8.0",
+ "digest 0.10.7",
+ "ecdsa",
+ "ed25519-dalek",
+ "elliptic-curve",
+ "enum_dispatch",
+ "flate2",
+ "futures",
+ "generic-array 1.4.1",
+ "getrandom 0.2.17",
+ "ghash 0.6.0",
+ "hex-literal",
+ "hkdf 0.13.0",
+ "hmac 0.12.1",
+ "hmac 0.13.0",
+ "inout 0.1.4",
+ "internal-russh-forked-ssh-key",
+ "internal-russh-num-bigint",
+ "keccak",
+ "log",
+ "md5 0.7.0",
+ "ml-kem",
+ "module-lattice",
+ "num-bigint",
+ "p256",
+ "p384",
+ "p521",
+ "pageant",
+ "pbkdf2 0.12.2",
+ "pbkdf2 0.13.0",
+ "pkcs1 0.8.0-rc.4",
+ "pkcs5 0.8.0-rc.13",
+ "pkcs8 0.11.0-rc.11",
+ "polyval 0.7.1",
+ "rand 0.10.1",
+ "rand_core 0.10.1",
+ "rsa 0.10.0-rc.16",
+ "russh-cryptovec",
+ "russh-util",
+ "salsa20 0.11.0",
+ "scrypt 0.12.0",
+ "sec1",
+ "sha1 0.10.6",
+ "sha1 0.11.0",
+ "sha2 0.10.9",
+ "sha2 0.11.0",
+ "sha3",
+ "signature 3.0.0",
+ "spki 0.8.0-rc.4",
+ "ssh-encoding",
+ "subtle",
+ "thiserror 2.0.18",
+ "tokio",
+ "typenum",
+ "universal-hash 0.6.1",
+ "zeroize",
+]
+
+[[package]]
+name = "russh-cryptovec"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36140e8a20297bc2e8338807c3d9ca911f7fa49d7539cbcd6d48d3befd70efd8"
+dependencies = [
+ "log",
+ "nix 0.31.2",
+ "ssh-encoding",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "russh-util"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "668424a5dde0bcb45b55ba7de8476b93831b4aa2fa6947e145f3b053e22c60b6"
+dependencies = [
+ "chrono",
+ "tokio",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+]
+
+[[package]]
+name = "rust_decimal"
+version = "1.41.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ce901f9a19d251159075a4c37af514c3b8ef99c22e02dd8c19161cf397ee94a"
+dependencies = [
+ "arrayvec",
+ "borsh",
+ "bytes",
+ "num-traits",
+ "rand 0.8.6",
+ "rkyv",
+ "serde",
+ "serde_json",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustc_version_runtime"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dd18cd2bae1820af0b6ad5e54f4a51d0f3fcc53b05f845675074efcc7af071d"
+dependencies = [
+ "rustc_version",
+ "semver",
+]
+
+[[package]]
+name = "rustcrypto-ff"
+version = "0.14.0-rc.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd2a8adb347447693cd2ba0d218c4b66c62da9b0a5672b17b981e4291ec65ff6"
+dependencies = [
+ "rand_core 0.10.1",
+ "subtle",
+]
+
+[[package]]
+name = "rustcrypto-group"
+version = "0.14.0-rc.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "369f9b61aa45933c062c9f6b5c3c50ab710687eca83dd3802653b140b43f85ed"
+dependencies = [
+ "rand_core 0.10.1",
+ "rustcrypto-ff",
+ "subtle",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
+dependencies = [
+ "bitflags 2.11.1",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.15",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags 2.11.1",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.12.1",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef86cd5876211988985292b91c96a8f2d298df24e75989a43a3c73f2d4d8168b"
+dependencies = [
+ "aws-lc-rs",
+ "log",
+ "once_cell",
+ "ring",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework 3.7.0",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.14.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30a7197ae7eb376e574fe940d068c30fe0462554a3ddbe4eca7838e049c937a9"
+dependencies = [
+ "web-time",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-platform-verifier"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d1e2536ce4f35f4846aa13bff16bd0ff40157cdb14cc056c7b14ba41233ba0"
+dependencies = [
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "jni 0.22.4",
+ "log",
+ "once_cell",
+ "rustls",
+ "rustls-native-certs",
+ "rustls-platform-verifier-android",
+ "rustls-webpki",
+ "security-framework 3.7.0",
+ "security-framework-sys",
+ "webpki-root-certs",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
+dependencies = [
+ "aws-lc-rs",
+ "ring",
+ "rustls-pki-types",
+ "untrusted 0.9.0",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "salsa20"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213"
+dependencies = [
+ "cipher 0.4.4",
+]
+
+[[package]]
+name = "salsa20"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f874456e72520ff1375a06c588eaf074b0f01f9e9e1aada45bd9b7954a6e42c"
+dependencies = [
+ "cfg-if",
+ "cipher 0.5.1",
+]
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91c1b7e4904c873ef0710c1f407dde2e6287de2bebc1bbbf7d430bb7cbffd939"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "schemars"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fbf2ae1b8bc8e02df939598064d22402220cd5bbcca1c76f7d6a310974d5615"
+dependencies = [
+ "dyn-clone",
+ "indexmap 1.9.3",
+ "schemars_derive",
+ "serde",
+ "serde_json",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "schemars"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars_derive"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e265784ad618884abaea0600a9adf15393368d840e0222d101a072f3f7534d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "serde_derive_internals",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "scrypt"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0516a385866c09368f0b5bcd1caff3366aace790fcd46e2bb032697bb172fd1f"
+dependencies = [
+ "pbkdf2 0.12.2",
+ "salsa20 0.10.2",
+ "sha2 0.10.9",
+]
+
+[[package]]
+name = "scrypt"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d87af57419b594aa23fa95f09f0e06d80d84ba01c26148c43844cad6ff4485f0"
+dependencies = [
+ "cfg-if",
+ "pbkdf2 0.13.0",
+ "salsa20 0.11.0",
+ "sha2 0.11.0",
+]
+
+[[package]]
+name = "seahash"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
+
+[[package]]
+name = "sec1"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d56d437c2f19203ce5f7122e507831de96f3d2d4d3be5af44a0b0a09d8a80e4d"
+dependencies = [
+ "base16ct",
+ "ctutils",
+ "der 0.8.0",
+ "hybrid-array",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "secret-service"
+version = "4.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4d35ad99a181be0a60ffcbe85d680d98f87bdc4d7644ade319b87076b9dbfd4"
+dependencies = [
+ "aes 0.8.4",
+ "cbc 0.1.2",
+ "futures-util",
+ "generic-array 0.14.7",
+ "hkdf 0.12.4",
+ "num",
+ "once_cell",
+ "rand 0.8.6",
+ "serde",
+ "sha2 0.10.9",
+ "zbus",
+]
+
+[[package]]
+name = "security-framework"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.10.1",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "selectors"
+version = "0.36.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5d9c0c92a92d33f08817311cf3f2c29a3538a8240e94a6a3c622ce652d7e00c"
+dependencies = [
+ "bitflags 2.11.1",
+ "cssparser",
+ "derive_more",
+ "log",
+ "new_debug_unreachable",
+ "phf 0.13.1",
+ "phf_codegen",
+ "precomputed-hash",
+ "rustc-hash",
+ "servo_arc",
+ "smallvec",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde-untagged"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9faf48a4a2d2693be24c6289dbe26552776eb7737074e6722891fadbe6c5058"
+dependencies = [
+ "erased-serde",
+ "serde",
+ "serde_core",
+ "typeid",
+]
+
+[[package]]
+name = "serde_bytes"
+version = "0.11.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a5d440709e79d88e51ac01c4b72fc6cb7314017bb7da9eeff678aa94c10e3ea8"
+dependencies = [
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_derive_internals"
+version = "0.29.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "indexmap 2.14.0",
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_repr"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf41e0cfaf7226dca15e8197172c295a782857fcb97fad1808a166870dee75a3"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_with"
+version = "3.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f05839ce67618e14a09b286535c0d9c94e85ef25469b0e13cb4f844e5593eb19"
+dependencies = [
+ "base64 0.22.1",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.14.0",
+ "schemars 0.9.0",
+ "schemars 1.2.1",
+ "serde_core",
+ "serde_json",
+ "serde_with_macros",
+ "time",
+]
+
+[[package]]
+name = "serde_with_macros"
+version = "3.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf2ebbe86054f9b45bc3881e865683ccfaccce97b9b4cb53f3039d67f355a334"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serdect"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9af4a3e75ebd5599b30d4de5768e00b5095d518a79fefc3ecbaf77e665d1ec06"
+dependencies = [
+ "base16ct",
+ "serde",
+]
+
+[[package]]
+name = "serialize-to-javascript"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04f3666a07a197cdb77cdf306c32be9b7f598d7060d50cfd4d5aa04bfd92f6c5"
+dependencies = [
+ "serde",
+ "serde_json",
+ "serialize-to-javascript-impl",
+]
+
+[[package]]
+name = "serialize-to-javascript-impl"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "772ee033c0916d670af7860b6e1ef7d658a4629a6d0b4c8c3e67f09b3765b75d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "servo_arc"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "170fb83ab34de17dc69aa7c67482b22218ddb85da56546f9bd6b929e32a05930"
+dependencies = [
+ "stable_deref_trait",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha1"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "digest 0.11.3",
+]
+
+[[package]]
+name = "sha1_smol"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d"
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.2.17",
+ "digest 0.10.7",
+]
+
+[[package]]
+name = "sha2"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "digest 0.11.3",
+]
+
+[[package]]
+name = "sha3"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be176f1a57ce4e3d31c1a166222d9768de5954f811601fb7ca06fc8203905ce1"
+dependencies = [
+ "digest 0.11.3",
+ "keccak",
+]
+
+[[package]]
+name = "shared_child"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e362d9935bc50f019969e2f9ecd66786612daae13e8f277be7bfb66e8bed3f7"
+dependencies = [
+ "libc",
+ "sigchld",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "sigchld"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47106eded3c154e70176fc83df9737335c94ce22f821c32d17ed1db1f83badb1"
+dependencies = [
+ "libc",
+ "os_pipe",
+ "signal-hook",
+]
+
+[[package]]
+name = "signal-hook"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
+dependencies = [
+ "libc",
+ "signal-hook-registry",
+]
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "digest 0.10.7",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "signature"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d567dcbaf0049cb8ac2608a76cd95ff9e4412e1899d389ee400918ca7537f5"
+dependencies = [
+ "digest 0.11.3",
+ "rand_core 0.10.1",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "703d5c7ef118737c72f1af64ad2f6f8c5e1921f818cdcb97b8fe6fc69bf66214"
+
+[[package]]
+name = "simd_cesu8"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94f90157bb87cddf702797c5dadfa0be7d266cdf49e22da2fcaa32eff75b2c33"
+dependencies = [
+ "rustc_version",
+ "simdutf8",
+]
+
+[[package]]
+name = "simdutf8"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
+
+[[package]]
+name = "siphasher"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "socket2"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "softbuffer"
+version = "0.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aac18da81ebbf05109ab275b157c22a653bb3c12cf884450179942f81bcbf6c3"
+dependencies = [
+ "bytemuck",
+ "js-sys",
+ "ndk",
+ "objc2",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "objc2-quartz-core",
+ "raw-window-handle",
+ "redox_syscall 0.5.18",
+ "tracing",
+ "wasm-bindgen",
+ "web-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "soup3"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "471f924a40f31251afc77450e781cb26d55c0b650842efafc9c6cbd2f7cc4f9f"
+dependencies = [
+ "futures-channel",
+ "gio",
+ "glib",
+ "libc",
+ "soup3-sys",
+]
+
+[[package]]
+name = "soup3-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ebe8950a680a12f24f15ebe1bf70db7af98ad242d9db43596ad3108aab86c27"
+dependencies = [
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "libc",
+ "system-deps",
+]
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api",
+]
+
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der 0.7.10",
+]
+
+[[package]]
+name = "spki"
+version = "0.8.0-rc.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8baeff88f34ed0691978ec34440140e1572b68c7dd4a495fd14a3dc1944daa80"
+dependencies = [
+ "base64ct",
+ "der 0.8.0",
+]
+
+[[package]]
+name = "sqlx"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fefb893899429669dcdd979aff487bd78f4064e5e7907e4269081e0ef7d97dc"
+dependencies = [
+ "sqlx-core",
+ "sqlx-macros",
+ "sqlx-mysql",
+ "sqlx-postgres",
+ "sqlx-sqlite",
+]
+
+[[package]]
+name = "sqlx-core"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee6798b1838b6a0f69c007c133b8df5866302197e404e8b6ee8ed3e3a5e68dc6"
+dependencies = [
+ "base64 0.22.1",
+ "bytes",
+ "chrono",
+ "crc",
+ "crossbeam-queue",
+ "either",
+ "event-listener",
+ "futures-core",
+ "futures-intrusive",
+ "futures-io",
+ "futures-util",
+ "hashbrown 0.15.5",
+ "hashlink",
+ "indexmap 2.14.0",
+ "log",
+ "memchr",
+ "native-tls",
+ "once_cell",
+ "percent-encoding",
+ "rust_decimal",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+ "smallvec",
+ "thiserror 2.0.18",
+ "tokio",
+ "tokio-stream",
+ "tracing",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "sqlx-macros"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2d452988ccaacfbf5e0bdbc348fb91d7c8af5bee192173ac3636b5fb6e6715d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "sqlx-core",
+ "sqlx-macros-core",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "sqlx-macros-core"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19a9c1841124ac5a61741f96e1d9e2ec77424bf323962dd894bdb93f37d5219b"
+dependencies = [
+ "dotenvy",
+ "either",
+ "heck 0.5.0",
+ "hex",
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+ "sqlx-core",
+ "sqlx-mysql",
+ "sqlx-postgres",
+ "sqlx-sqlite",
+ "syn 2.0.117",
+ "tokio",
+ "url",
+]
+
+[[package]]
+name = "sqlx-mysql"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa003f0038df784eb8fecbbac13affe3da23b45194bd57dba231c8f48199c526"
+dependencies = [
+ "atoi",
+ "base64 0.22.1",
+ "bitflags 2.11.1",
+ "byteorder",
+ "bytes",
+ "chrono",
+ "crc",
+ "digest 0.10.7",
+ "dotenvy",
+ "either",
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-util",
+ "generic-array 0.14.7",
+ "hex",
+ "hkdf 0.12.4",
+ "hmac 0.12.1",
+ "itoa",
+ "log",
+ "md-5",
+ "memchr",
+ "once_cell",
+ "percent-encoding",
+ "rand 0.8.6",
+ "rsa 0.9.10",
+ "rust_decimal",
+ "serde",
+ "sha1 0.10.6",
+ "sha2 0.10.9",
+ "smallvec",
+ "sqlx-core",
+ "stringprep",
+ "thiserror 2.0.18",
+ "tracing",
+ "uuid",
+ "whoami",
+]
+
+[[package]]
+name = "sqlx-postgres"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db58fcd5a53cf07c184b154801ff91347e4c30d17a3562a635ff028ad5deda46"
+dependencies = [
+ "atoi",
+ "base64 0.22.1",
+ "bitflags 2.11.1",
+ "byteorder",
+ "chrono",
+ "crc",
+ "dotenvy",
+ "etcetera",
+ "futures-channel",
+ "futures-core",
+ "futures-util",
+ "hex",
+ "hkdf 0.12.4",
+ "hmac 0.12.1",
+ "home",
+ "itoa",
+ "log",
+ "md-5",
+ "memchr",
+ "once_cell",
+ "rand 0.8.6",
+ "rust_decimal",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+ "smallvec",
+ "sqlx-core",
+ "stringprep",
+ "thiserror 2.0.18",
+ "tracing",
+ "uuid",
+ "whoami",
+]
+
+[[package]]
+name = "sqlx-sqlite"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2d12fe70b2c1b4401038055f90f151b78208de1f9f89a7dbfd41587a10c3eea"
+dependencies = [
+ "atoi",
+ "chrono",
+ "flume",
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-intrusive",
+ "futures-util",
+ "libsqlite3-sys",
+ "log",
+ "percent-encoding",
+ "serde",
+ "serde_urlencoded",
+ "sqlx-core",
+ "thiserror 2.0.18",
+ "tracing",
+ "url",
+ "uuid",
+]
+
+[[package]]
+name = "ssh-cipher"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caac132742f0d33c3af65bfcde7f6aa8f62f0e991d80db99149eb9d44708784f"
+dependencies = [
+ "aes 0.8.4",
+ "aes-gcm 0.10.3",
+ "cbc 0.1.2",
+ "chacha20 0.9.1",
+ "cipher 0.4.4",
+ "ctr 0.9.2",
+ "poly1305",
+ "ssh-encoding",
+ "subtle",
+]
+
+[[package]]
+name = "ssh-encoding"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb9242b9ef4108a78e8cd1a2c98e193ef372437f8c22be363075233321dd4a15"
+dependencies = [
+ "base64ct",
+ "bytes",
+ "pem-rfc7468 0.7.0",
+ "sha2 0.10.9",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "string_cache"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a18596f8c785a729f2819c0f6a7eae6ebeebdfffbfe4214ae6b087f690e31901"
+dependencies = [
+ "new_debug_unreachable",
+ "parking_lot",
+ "phf_shared 0.13.1",
+ "precomputed-hash",
+]
+
+[[package]]
+name = "string_cache_codegen"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "585635e46db231059f76c5849798146164652513eb9e8ab2685939dd90f29b69"
+dependencies = [
+ "phf_generator 0.13.1",
+ "phf_shared 0.13.1",
+ "proc-macro2",
+ "quote",
+]
+
+[[package]]
+name = "stringprep"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+ "unicode-properties",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "strum"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "swift-rs"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4057c98e2e852d51fdcfca832aac7b571f6b351ad159f9eda5db1655f8d0c4d7"
+dependencies = [
+ "base64 0.21.7",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "sync_wrapper"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "system-configuration"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.9.4",
+ "system-configuration-sys",
+]
+
+[[package]]
+name = "system-configuration-sys"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "system-deps"
+version = "6.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3e535eb8dded36d55ec13eddacd30dec501792ff23a0b1682c38601b8cf2349"
+dependencies = [
+ "cfg-expr",
+ "heck 0.5.0",
+ "pkg-config",
+ "toml 0.8.2",
+ "version-compare",
+]
+
+[[package]]
+name = "tagptr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
+
+[[package]]
+name = "take_mut"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60"
+
+[[package]]
+name = "tao"
+version = "0.35.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1cf65722394c2ac443e80120064987f8914ee1d4e4e36e63cdf10f2990f01159"
+dependencies = [
+ "bitflags 2.11.1",
+ "block2",
+ "core-foundation 0.10.1",
+ "core-graphics",
+ "crossbeam-channel",
+ "dbus",
+ "dispatch2",
+ "dlopen2",
+ "dpi",
+ "gdkwayland-sys",
+ "gdkx11-sys",
+ "gtk",
+ "jni 0.21.1",
+ "libc",
+ "log",
+ "ndk",
+ "ndk-sys",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "once_cell",
+ "parking_lot",
+ "percent-encoding",
+ "raw-window-handle",
+ "tao-macros",
+ "unicode-segmentation",
+ "url",
+ "windows 0.61.3",
+ "windows-core 0.61.2",
+ "windows-version",
+ "x11-dl",
+]
+
+[[package]]
+name = "tao-macros"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4e16beb8b2ac17db28eab8bca40e62dbfbb34c0fcdc6d9826b11b7b5d047dfd"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "tar"
+version = "0.4.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22692a6476a21fa75fdfc11d452fda482af402c008cdbaf3476414e122040973"
+dependencies = [
+ "filetime",
+ "libc",
+ "xattr",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "tauri"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d059f2527558d9dba6f186dec4772610e1aecfd3f94002397613e7e648752b66"
+dependencies = [
+ "anyhow",
+ "bytes",
+ "cookie",
+ "dirs",
+ "dunce",
+ "embed_plist",
+ "getrandom 0.3.4",
+ "glob",
+ "gtk",
+ "heck 0.5.0",
+ "http",
+ "jni 0.21.1",
+ "libc",
+ "log",
+ "mime",
+ "muda",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "percent-encoding",
+ "plist",
+ "raw-window-handle",
+ "reqwest 0.13.3",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "serialize-to-javascript",
+ "swift-rs",
+ "tauri-build",
+ "tauri-macros",
+ "tauri-runtime",
+ "tauri-runtime-wry",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "tokio",
+ "tray-icon",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "window-vibrancy",
+ "windows 0.61.3",
+]
+
+[[package]]
+name = "tauri-build"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be9aa8c59a894f76c29a002501c589de5eb4987a5913d62a6e0a47f320901988"
+dependencies = [
+ "anyhow",
+ "cargo_toml",
+ "dirs",
+ "glob",
+ "heck 0.5.0",
+ "json-patch",
+ "schemars 0.8.22",
+ "semver",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "tauri-winres",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-codegen"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3e4e8230d565106aa19dfbaa01a7ed01abf78047fe0577a83377224bd1bf20e"
+dependencies = [
+ "base64 0.22.1",
+ "brotli",
+ "ico",
+ "json-patch",
+ "plist",
+ "png 0.17.16",
+ "proc-macro2",
+ "quote",
+ "semver",
+ "serde",
+ "serde_json",
+ "sha2 0.10.9",
+ "syn 2.0.117",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "time",
+ "url",
+ "uuid",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-macros"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc8de2cddbbc33dbdf4c84f170121886595efdbcc9cb4b3d76342b79d082cedc"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "tauri-codegen",
+ "tauri-utils",
+]
+
+[[package]]
+name = "tauri-plugin"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8d5f58bfd0cdcfdbc0a68dc08b354eea2afc551b421de91b07b69e0dd769d57"
+dependencies = [
+ "anyhow",
+ "glob",
+ "plist",
+ "schemars 0.8.22",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-plugin-dialog"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65981abb771e74e571a38196c3baa11c459379164791eba0e67abc1a5fac9884"
+dependencies = [
+ "log",
+ "raw-window-handle",
+ "rfd",
+ "serde",
+ "serde_json",
+ "tauri",
+ "tauri-plugin",
+ "tauri-plugin-fs",
+ "thiserror 2.0.18",
+ "url",
+]
+
+[[package]]
+name = "tauri-plugin-fs"
+version = "2.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7ecc274121aca0c036a2b42d1cbe83d368d348f54e0bb8a735c2b1548e8f371"
+dependencies = [
+ "anyhow",
+ "dunce",
+ "glob",
+ "log",
+ "objc2-foundation",
+ "percent-encoding",
+ "schemars 0.8.22",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "tauri",
+ "tauri-plugin",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "toml 1.1.2+spec-1.1.0",
+ "url",
+]
+
+[[package]]
+name = "tauri-plugin-log"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7545bd67f070a4500432c826e2e0682146a1d6712aee22a2786490156b574d93"
+dependencies = [
+ "android_logger",
+ "byte-unit",
+ "fern",
+ "log",
+ "objc2",
+ "objc2-foundation",
+ "serde",
+ "serde_json",
+ "serde_repr",
+ "swift-rs",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.18",
+ "time",
+]
+
+[[package]]
+name = "tauri-plugin-process"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d55511a7bf6cd70c8767b02c97bf8134fa434daf3926cfc1be0a0f94132d165a"
+dependencies = [
+ "tauri",
+ "tauri-plugin",
+]
+
+[[package]]
+name = "tauri-plugin-shell"
+version = "2.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8457dbf9e2bab1edd8df22bb2c20857a59a9868e79cb3eac5ed639eec4d0c73b"
+dependencies = [
+ "encoding_rs",
+ "log",
+ "open",
+ "os_pipe",
+ "regex",
+ "schemars 0.8.22",
+ "serde",
+ "serde_json",
+ "shared_child",
+ "tauri",
+ "tauri-plugin",
+ "thiserror 2.0.18",
+ "tokio",
+]
+
+[[package]]
+name = "tauri-plugin-updater"
+version = "2.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "806d9dac662c2e4594ff03c647a552f2c9bd544e7d0f683ec58f872f952ce4af"
+dependencies = [
+ "base64 0.22.1",
+ "dirs",
+ "flate2",
+ "futures-util",
+ "http",
+ "infer",
+ "log",
+ "minisign-verify",
+ "osakit",
+ "percent-encoding",
+ "reqwest 0.13.3",
+ "rustls",
+ "semver",
+ "serde",
+ "serde_json",
+ "tar",
+ "tauri",
+ "tauri-plugin",
+ "tempfile",
+ "thiserror 2.0.18",
+ "time",
+ "tokio",
+ "url",
+ "windows-sys 0.60.2",
+ "zip 4.6.1",
+]
+
+[[package]]
+name = "tauri-runtime"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e42bbcb76237351fbaa02f08d808c537dc12eb5a6eabbf3e517b50056334d95"
+dependencies = [
+ "cookie",
+ "dpi",
+ "gtk",
+ "http",
+ "jni 0.21.1",
+ "objc2",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "raw-window-handle",
+ "serde",
+ "serde_json",
+ "tauri-utils",
+ "thiserror 2.0.18",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "windows 0.61.3",
+]
+
+[[package]]
+name = "tauri-runtime-wry"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2cadb13dad0c681e1e0a2c49ae488f0e2906ded3d57e7a0017f4aaf46e387117"
+dependencies = [
+ "gtk",
+ "http",
+ "jni 0.21.1",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "once_cell",
+ "percent-encoding",
+ "raw-window-handle",
+ "softbuffer",
+ "tao",
+ "tauri-runtime",
+ "tauri-utils",
+ "url",
+ "webkit2gtk",
+ "webview2-com",
+ "windows 0.61.3",
+ "wry",
+]
+
+[[package]]
+name = "tauri-utils"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55f61d2bf7188fbcf2b0ed095b67a6bc498f713c939314bb19eb700118a573b7"
+dependencies = [
+ "anyhow",
+ "brotli",
+ "cargo_metadata",
+ "ctor",
+ "dom_query",
+ "dunce",
+ "glob",
+ "http",
+ "infer",
+ "json-patch",
+ "log",
+ "memchr",
+ "phf 0.11.3",
+ "plist",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "schemars 0.8.22",
+ "semver",
+ "serde",
+ "serde-untagged",
+ "serde_json",
+ "serde_with",
+ "swift-rs",
+ "thiserror 2.0.18",
+ "toml 1.1.2+spec-1.1.0",
+ "url",
+ "urlpattern",
+ "uuid",
+ "walkdir",
+]
+
+[[package]]
+name = "tauri-winres"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc65d45c68858bfe420dd29e834b5d15dbecf8a07a8a16cf4d532c7b1f69d4b6"
+dependencies = [
+ "dunce",
+ "embed-resource",
+ "toml 1.1.2+spec-1.1.0",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.2",
+ "once_cell",
+ "rustix 1.1.4",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tendril"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4790fc369d5a530f4b544b094e31388b9b3a37c0f4652ade4505945f5660d24"
+dependencies = [
+ "new_debug_unreachable",
+ "utf-8",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tiberius"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1446cb4198848d1562301a3340424b4f425ef79f35ef9ee034769a9dd92c10d"
+dependencies = [
+ "async-native-tls",
+ "async-trait",
+ "asynchronous-codec",
+ "byteorder",
+ "bytes",
+ "chrono",
+ "connection-string",
+ "encoding_rs",
+ "enumflags2",
+ "futures-util",
+ "num-traits",
+ "once_cell",
+ "pin-project-lite",
+ "pretty-hex",
+ "rust_decimal",
+ "thiserror 1.0.69",
+ "tracing",
+ "uuid",
+ "winauth",
+]
+
+[[package]]
+name = "time"
+version = "0.3.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
+dependencies = [
+ "deranged",
+ "itoa",
+ "libc",
+ "num-conv",
+ "num_threads",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
+
+[[package]]
+name = "time-macros"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tiny-keccak"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+dependencies = [
+ "crunchy",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8323304221c2a851516f22236c5722a72eaa19749016521d6dff0824447d96d"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tokio"
+version = "1.52.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67dee974fe86fd92cc45b7a95fdd2f99a36a6d7b0d431a231178d3d670bbcc6"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
+dependencies = [
+ "rustls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-io",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "toml"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "185d8ab0dfbb35cf1399a6344d8484209c088f75f8f68230da55d48d95d43e3d"
+dependencies = [
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.3",
+ "toml_edit 0.20.2",
+]
+
+[[package]]
+name = "toml"
+version = "0.9.12+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
+dependencies = [
+ "indexmap 2.14.0",
+ "serde_core",
+ "serde_spanned 1.1.1",
+ "toml_datetime 0.7.5+spec-1.1.0",
+ "toml_parser",
+ "toml_writer",
+ "winnow 0.7.15",
+]
+
+[[package]]
+name = "toml"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81f3d15e84cbcd896376e6730314d59fb5a87f31e4b038454184435cd57defee"
+dependencies = [
+ "indexmap 2.14.0",
+ "serde_core",
+ "serde_spanned 1.1.1",
+ "toml_datetime 1.1.1+spec-1.1.0",
+ "toml_parser",
+ "toml_writer",
+ "winnow 1.0.2",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.19.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
+dependencies = [
+ "indexmap 2.14.0",
+ "toml_datetime 0.6.3",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "396e4d48bbb2b7554c944bde63101b5ae446cff6ec4a24227428f15eb72ef338"
+dependencies = [
+ "indexmap 2.14.0",
+ "serde",
+ "serde_spanned 0.6.9",
+ "toml_datetime 0.6.3",
+ "winnow 0.5.40",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.25.11+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b59c4d22ed448339746c59b905d24568fcbb3ab65a500494f7b8c3e97739f2b"
+dependencies = [
+ "indexmap 2.14.0",
+ "toml_datetime 1.1.1+spec-1.1.0",
+ "toml_parser",
+ "winnow 1.0.2",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
+dependencies = [
+ "winnow 1.0.2",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db"
+
+[[package]]
+name = "tower"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
+dependencies = [
+ "futures-core",
+ "futures-util",
+ "pin-project-lite",
+ "sync_wrapper",
+ "tokio",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-http"
+version = "0.6.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
+dependencies = [
+ "bitflags 2.11.1",
+ "bytes",
+ "futures-util",
+ "http",
+ "http-body",
+ "iri-string",
+ "pin-project-lite",
+ "tower",
+ "tower-layer",
+ "tower-service",
+]
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tracing"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+dependencies = [
+ "log",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "tray-icon"
+version = "0.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15edbb0d80583e85ee8df283410038e17314df5cba30da2087a54a85216c0773"
+dependencies = [
+ "crossbeam-channel",
+ "dirs",
+ "libappindicator",
+ "muda",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-core-graphics",
+ "objc2-foundation",
+ "once_cell",
+ "png 0.18.1",
+ "serde",
+ "thiserror 2.0.18",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "try-lock"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "typed-builder"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "398a3a3c918c96de527dc11e6e846cd549d4508030b8a33e1da12789c856b81a"
+dependencies = [
+ "typed-builder-macro",
+]
+
+[[package]]
+name = "typed-builder-macro"
+version = "0.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e48cea23f68d1f78eb7bc092881b6bb88d3d6b5b7e6234f6f9c911da1ffb221"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "typeid"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
+
+[[package]]
+name = "typenum"
+version = "1.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40ce102ab67701b8526c123c1bab5cbe42d7040ccfd0f64af1a385808d2f43de"
+
+[[package]]
+name = "uds_windows"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f6fb2847f6742cd76af783a2a2c49e9375d0a111c7bef6f71cd9e738c72d6e"
+dependencies = [
+ "memoffset",
+ "tempfile",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "unic-char-property"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8c57a407d9b6fa02b4795eb81c5b6652060a15a7903ea981f3d723e6c0be221"
+dependencies = [
+ "unic-char-range",
+]
+
+[[package]]
+name = "unic-char-range"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0398022d5f700414f6b899e10b8348231abf9173fa93144cbc1a43b9793c1fbc"
+
+[[package]]
+name = "unic-common"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80d7ff825a6a654ee85a63e80f92f054f904f21e7d12da4e22f9834a4aaa35bc"
+
+[[package]]
+name = "unic-ucd-ident"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e230a37c0381caa9219d67cf063aa3a375ffed5bf541a452db16e744bdab6987"
+dependencies = [
+ "unic-char-property",
+ "unic-char-range",
+ "unic-ucd-version",
+]
+
+[[package]]
+name = "unic-ucd-version"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96bd2f2237fe450fcd0a1d2f5f4e91711124f7857ba2e964247776ebeeb7b0c4"
+dependencies = [
+ "unic-common",
+]
+
+[[package]]
+name = "unicode-bidi"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c1cb5db39152898a79168971543b1cb5020dff7fe43c8dc468b0885f5e29df5"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-properties"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d"
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9629274872b2bfaf8d66f5f15725007f635594914870f65218920345aa11aa8c"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common 0.1.7",
+ "subtle",
+]
+
+[[package]]
+name = "universal-hash"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4987bdc12753382e0bec4a65c50738ffaabc998b9cdd1f952fb5f39b0048a96"
+dependencies = [
+ "crypto-common 0.2.1",
+ "ctutils",
+]
+
+[[package]]
+name = "untrusted"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+ "serde_derive",
+]
+
+[[package]]
+name = "urlpattern"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70acd30e3aa1450bc2eece896ce2ad0d178e9c079493819301573dae3c37ba6d"
+dependencies = [
+ "regex",
+ "serde",
+ "unic-ucd-ident",
+ "url",
+]
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8-width"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1292c0d970b54115d14f2492fe0170adf21d68a1de108eebc51c1df4f346a091"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "uuid"
+version = "1.23.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd74a9687298c6858e9b88ec8935ec45d22e8fd5e6394fa1bd4e99a87789c76"
+dependencies = [
+ "getrandom 0.4.2",
+ "js-sys",
+ "serde_core",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "value-bag"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ba6f5989077681266825251a52748b8c1d8a4ad098cc37e440103d0ea717fc0"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version-compare"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03c2856837ef78f57382f06b2b8563a2f512f7185d732608fd9176cb3b8edf0e"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "vswhom"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be979b7f07507105799e854203b470ff7c78a1639e330a58f183b5fea574608b"
+dependencies = [
+ "libc",
+ "vswhom-sys",
+]
+
+[[package]]
+name = "vswhom-sys"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb067e4cbd1ff067d1df46c9194b5de0e98efd2810bbc95c5d5e5f25a3231150"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "want"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
+
+[[package]]
+name = "wasi"
+version = "0.9.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.3+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20064672db26d7cdc89c7798c48a0fdfac8213434a1186e5ef29fd560ae223d6"
+dependencies = [
+ "wit-bindgen 0.57.1",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen 0.51.0",
+]
+
+[[package]]
+name = "wasite"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.120"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df52b6d9b87e0c74c9edfa1eb2d9bf85e5d63515474513aa50fa181b3c4f5db1"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "serde",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-futures"
+version = "0.4.70"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af934872acec734c2d80e6617bbb5ff4f12b052dd8e6332b0817bce889516084"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.120"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78b1041f495fb322e64aca85f5756b2172e35cd459376e67f2a6c9dffcedb103"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.120"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dcd0ff20416988a18ac686d4d4d0f6aae9ebf08a389ff5d29012b05af2a1b41"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.120"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49757b3c82ebf16c57d69365a142940b384176c24df52a087fb748e2085359ea"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap 2.14.0",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-streams"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "wasm-streams"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb"
+dependencies = [
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.11.1",
+ "hashbrown 0.15.5",
+ "indexmap 2.14.0",
+ "semver",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.97"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2eadbac71025cd7b0834f20d1fe8472e8495821b4e9801eb0a60bd1f19827602"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web-time"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "web_atoms"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7cff6eef815df1834fd250e3a2ff436044d82a9f1bc1980ca1dbdf07effc538"
+dependencies = [
+ "phf 0.13.1",
+ "phf_codegen",
+ "string_cache",
+ "string_cache_codegen",
+]
+
+[[package]]
+name = "webkit2gtk"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1027150013530fb2eaf806408df88461ae4815a45c541c8975e61d6f2fc4793"
+dependencies = [
+ "bitflags 1.3.2",
+ "cairo-rs",
+ "gdk",
+ "gdk-sys",
+ "gio",
+ "gio-sys",
+ "glib",
+ "glib-sys",
+ "gobject-sys",
+ "gtk",
+ "gtk-sys",
+ "javascriptcore-rs",
+ "libc",
+ "once_cell",
+ "soup3",
+ "webkit2gtk-sys",
+]
+
+[[package]]
+name = "webkit2gtk-sys"
+version = "2.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "916a5f65c2ef0dfe12fff695960a2ec3d4565359fdbb2e9943c974e06c734ea5"
+dependencies = [
+ "bitflags 1.3.2",
+ "cairo-sys-rs",
+ "gdk-sys",
+ "gio-sys",
+ "glib-sys",
+ "gobject-sys",
+ "gtk-sys",
+ "javascriptcore-rs-sys",
+ "libc",
+ "pkg-config",
+ "soup3-sys",
+ "system-deps",
+]
+
+[[package]]
+name = "webpki-root-certs"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31141ce3fc3e300ae89b78c0dd67f9708061d1d2eda54b8209346fd6be9a92c"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.7",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52f5ee44c96cf55f1b349600768e3ece3a8f26010c05265ab73f945bb1a2eb9d"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "webview2-com"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7130243a7a5b33c54a444e54842e6a9e133de08b5ad7b5861cd8ed9a6a5bc96a"
+dependencies = [
+ "webview2-com-macros",
+ "webview2-com-sys",
+ "windows 0.61.3",
+ "windows-core 0.61.2",
+ "windows-implement",
+ "windows-interface",
+]
+
+[[package]]
+name = "webview2-com-macros"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67a921c1b6914c367b2b823cd4cde6f96beec77d30a939c8199bb377cf9b9b54"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "webview2-com-sys"
+version = "0.38.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "381336cfffd772377d291702245447a5251a2ffa5bad679c99e61bc48bacbf9c"
+dependencies = [
+ "thiserror 2.0.18",
+ "windows 0.61.3",
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "whoami"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d4a4db5077702ca3015d3d02d74974948aba2ad9e12ab7df718ee64ccd7e97d"
+dependencies = [
+ "libredox",
+ "wasite",
+]
+
+[[package]]
+name = "widestring"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "winauth"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f820cd208ce9c6b050812dc2d724ba98c6c1e9db5ce9b3f58d925ae5723a5e6"
+dependencies = [
+ "bitflags 1.3.2",
+ "byteorder",
+ "md5 0.6.1",
+ "rand 0.7.3",
+ "winapi",
+]
+
+[[package]]
+name = "window-vibrancy"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9bec5a31f3f9362f2258fd0e9c9dd61a9ca432e7306cc78c444258f0dce9a9c"
+dependencies = [
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "raw-window-handle",
+ "windows-sys 0.59.0",
+ "windows-version",
+]
+
+[[package]]
+name = "windows"
+version = "0.61.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9babd3a767a4c1aef6900409f85f5d53ce2544ccdfaa86dad48c91782c6d6893"
+dependencies = [
+ "windows-collections 0.2.0",
+ "windows-core 0.61.2",
+ "windows-future 0.2.1",
+ "windows-link 0.1.3",
+ "windows-numerics 0.2.0",
+]
+
+[[package]]
+name = "windows"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"
+dependencies = [
+ "windows-collections 0.3.2",
+ "windows-core 0.62.2",
+ "windows-future 0.3.2",
+ "windows-numerics 0.3.1",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+dependencies = [
+ "windows-core 0.61.2",
+]
+
+[[package]]
+name = "windows-collections"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"
+dependencies = [
+ "windows-core 0.62.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link 0.1.3",
+ "windows-result 0.3.4",
+ "windows-strings 0.4.2",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+ "windows-threading 0.1.0",
+]
+
+[[package]]
+name = "windows-future"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
+dependencies = [
+ "windows-core 0.62.2",
+ "windows-link 0.2.1",
+ "windows-threading 0.2.1",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-numerics"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+dependencies = [
+ "windows-core 0.61.2",
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-numerics"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
+dependencies = [
+ "windows-core 0.62.2",
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-registry"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02752bf7fbdcce7f2a27a742f798510f3e5ad88dbe84871e5168e2120c3d5720"
+dependencies = [
+ "windows-link 0.2.1",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.45.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+dependencies = [
+ "windows-targets 0.42.2",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+dependencies = [
+ "windows_aarch64_gnullvm 0.42.2",
+ "windows_aarch64_msvc 0.42.2",
+ "windows_i686_gnu 0.42.2",
+ "windows_i686_msvc 0.42.2",
+ "windows_x86_64_gnu 0.42.2",
+ "windows_x86_64_gnullvm 0.42.2",
+ "windows_x86_64_msvc 0.42.2",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link 0.2.1",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
+name = "windows-threading"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+dependencies = [
+ "windows-link 0.1.3",
+]
+
+[[package]]
+name = "windows-threading"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows-version"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4060a1da109b9d0326b7262c8e12c84df67cc0dbc9e33cf49e01ccc2eb63631"
+dependencies = [
+ "windows-link 0.2.1",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winnow"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945"
+
+[[package]]
+name = "winnow"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ee1708bef14716a11bae175f579062d4554d95be2c6829f518df847b7b3fdd0"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "winreg"
+version = "0.55.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb5a765337c50e9ec252c2069be9bf91c7df47afb103b642ba3a53bf8101be97"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.57.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap 2.14.0",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.1",
+ "indexmap 2.14.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap 2.14.0",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "writeable"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
+
+[[package]]
+name = "wry"
+version = "0.55.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3013fd6116aac351dd2e18f349b28b2cfef3a5ff3253a9d0ce2d7193bb1b4429"
+dependencies = [
+ "base64 0.22.1",
+ "block2",
+ "cookie",
+ "crossbeam-channel",
+ "dirs",
+ "dom_query",
+ "dpi",
+ "dunce",
+ "gdkx11",
+ "gtk",
+ "http",
+ "javascriptcore-rs",
+ "jni 0.21.1",
+ "libc",
+ "ndk",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-core-foundation",
+ "objc2-foundation",
+ "objc2-ui-kit",
+ "objc2-web-kit",
+ "once_cell",
+ "percent-encoding",
+ "raw-window-handle",
+ "sha2 0.10.9",
+ "soup3",
+ "tao-macros",
+ "thiserror 2.0.18",
+ "url",
+ "webkit2gtk",
+ "webkit2gtk-sys",
+ "webview2-com",
+ "windows 0.61.3",
+ "windows-core 0.61.2",
+ "windows-version",
+ "x11-dl",
+]
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
+[[package]]
+name = "x11"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "502da5464ccd04011667b11c435cb992822c2c0dbde1770c988480d312a0db2e"
+dependencies = [
+ "libc",
+ "pkg-config",
+]
+
+[[package]]
+name = "x11-dl"
+version = "2.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38735924fedd5314a6e548792904ed8c6de6636285cb9fec04d5b1db85c1516f"
+dependencies = [
+ "libc",
+ "once_cell",
+ "pkg-config",
+]
+
+[[package]]
+name = "xattr"
+version = "1.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32e45ad4206f6d2479085147f02bc2ef834ac85886624a23575ae137c8aa8156"
+dependencies = [
+ "libc",
+ "rustix 1.1.4",
+]
+
+[[package]]
+name = "xdg-home"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec1cdab258fb55c0da61328dc52c8764709b249011b2cad0454c72f0bf10a1f6"
+dependencies = [
+ "libc",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "yoke"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "abe8c5fda708d9ca3df187cae8bfb9ceda00dd96231bed36e445a1a48e66f9ca"
+dependencies = [
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de844c262c8848816172cef550288e7dc6c7b7814b4ee56b3e1553f275f1858e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zbus"
+version = "4.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb97012beadd29e654708a0fdb4c84bc046f537aecfde2c3ee0a9e4b4d48c725"
+dependencies = [
+ "async-broadcast",
+ "async-process",
+ "async-recursion",
+ "async-trait",
+ "enumflags2",
+ "event-listener",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "hex",
+ "nix 0.29.0",
+ "ordered-stream",
+ "rand 0.8.6",
+ "serde",
+ "serde_repr",
+ "sha1 0.10.6",
+ "static_assertions",
+ "tracing",
+ "uds_windows",
+ "windows-sys 0.52.0",
+ "xdg-home",
+ "zbus_macros",
+ "zbus_names",
+ "zvariant",
+]
+
+[[package]]
+name = "zbus_macros"
+version = "4.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "267db9407081e90bbfa46d841d3cbc60f59c0351838c4bc65199ecd79ab1983e"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "zvariant_utils",
+]
+
+[[package]]
+name = "zbus_names"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b9b1fef7d021261cc16cba64c351d291b715febe0fa10dc3a443ac5a5022e6c"
+dependencies = [
+ "serde",
+ "static_assertions",
+ "zvariant",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eed437bf9d6692032087e337407a86f04cd8d6a16a37199ed57949d415bd68e9"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.48"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70e3cd084b1788766f53af483dd21f93881ff30d7320490ec3ef7526d203bad4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69faa1f2a1ea75661980b013019ed6687ed0e83d069bc1114e2cc74c6c04c4df"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "11532158c46691caf0f2593ea8358fed6bbf68a0315e80aae9bd41fbade684a1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+dependencies = [
+ "zeroize_derive",
+]
+
+[[package]]
+name = "zeroize_derive"
+version = "1.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zerotrie"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f9152d31db0792fa83f70fb2f83148effb5c1f5b8c7686c3459e361d9bc20bf"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.11.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90f911cbc359ab6af17377d242225f4d75119aec87ea711a880987b18cd7b239"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "625dc425cab0dca6dc3c3319506e6593dcb08a9f387ea3b284dbd52a92c40555"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "zip"
+version = "4.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "caa8cd6af31c3b31c6631b8f483848b91589021b28fffe50adada48d4f4d2ed1"
+dependencies = [
+ "arbitrary",
+ "crc32fast",
+ "flate2",
+ "indexmap 2.14.0",
+ "memchr",
+ "zopfli",
+]
+
+[[package]]
+name = "zip"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb2a05c7c36fde6c09b08576c9f7fb4cda705990f73b58fe011abf7dfb24168b"
+dependencies = [
+ "arbitrary",
+ "crc32fast",
+ "flate2",
+ "indexmap 2.14.0",
+ "memchr",
+ "zopfli",
+]
+
+[[package]]
+name = "zlib-rs"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3be3d40e40a133f9c916ee3f9f4fa2d9d63435b5fbe1bfc6d9dae0aa0ada1513"
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+
+[[package]]
+name = "zopfli"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249"
+dependencies = [
+ "bumpalo",
+ "crc32fast",
+ "log",
+ "simd-adler32",
+]
+
+[[package]]
+name = "zvariant"
+version = "4.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2084290ab9a1c471c38fc524945837734fbf124487e105daec2bb57fd48c81fe"
+dependencies = [
+ "endi",
+ "enumflags2",
+ "serde",
+ "static_assertions",
+ "zvariant_derive",
+]
+
+[[package]]
+name = "zvariant_derive"
+version = "4.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73e2ba546bda683a90652bac4a279bc146adad1386f25379cf73200d2002c449"
+dependencies = [
+ "proc-macro-crate 3.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "zvariant_utils",
+]
+
+[[package]]
+name = "zvariant_utils"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c51bcff7cc3dbb5055396bcf774748c3dab426b4b8659046963523cee4808340"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
new file mode 100644
index 0000000..386918f
--- /dev/null
+++ b/src-tauri/Cargo.toml
@@ -0,0 +1,71 @@
+[package]
+name = "dbx"
+version = "0.5.55"
+description = "Open-source database management tool"
+authors = ["skyler"]
+license = "Apache-2.0"
+repository = ""
+edition = "2021"
+rust-version = "1.77.2"
+
+[lib]
+name = "dbx_lib"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[features]
+default = ["duckdb-bundled", "mq-admin", "sqlite-sqlcipher"]
+duckdb-bundled = ["duckdb", "dbx-core/duckdb-bundled"]
+mq-admin = ["dbx-core/mq-admin"]
+sqlite-sqlcipher = ["dbx-core/sqlite-sqlcipher"]
+
+[build-dependencies]
+tauri-build = { version = "2.5.6", features = [] }
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+base64 = "0.22"
+log = "0.4"
+tauri = { version = "2.10.3", features = ["tray-icon"] }
+tauri-plugin-log = "2"
+tokio-postgres = { version = "0.7", features = ["with-chrono-0_4", "with-uuid-1", "with-serde_json-1"] }
+deadpool-postgres = { version = "0.14", features = ["rt_tokio_1"] }
+rust_decimal = { version = "1", features = ["serde", "db-postgres"] }
+tokio = { version = "1", features = ["full"] }
+uuid = { version = "1", features = ["v4", "serde"] }
+anyhow = "1"
+chrono = { version = "0.4", features = ["serde"] }
+tauri-plugin-deep-link = "2"
+tauri-plugin-dialog = "2.7.0"
+tauri-plugin-fs = "2.5.0"
+tauri-plugin-single-instance = "2.4.2"
+tauri-plugin-shell = "2"
+tauri-plugin-updater = "2"
+tauri-plugin-process = "2"
+tauri-plugin-window-state = "2"
+redis = { version = "0.32.2", features = ["tokio-comp", "tls-rustls", "tokio-rustls-comp", "cluster-async"] }
+rustls = { version = "0.23", features = ["aws-lc-rs"] }
+portpicker = "0.1.1"
+duckdb = { version = "1.3.2", optional = true }
+tiberius = { version = "0.12.3", default-features = false, features = ["tds73", "chrono", "rust_decimal", "rustls", "sql-browser-tokio"] }
+tokio-util = { version = "0.7", features = ["compat"] }
+reqwest = { version = "0.12", features = ["json", "stream"] }
+futures = "0.3"
+mongodb = "3.2.5"
+percent-encoding = "2"
+russh = "0.60"
+csv = "1.4.0"
+calamine = "0.30.1"
+zip = "4.6.1"
+dbx-core = { path = "../crates/dbx-core", default-features = false }
+axum = { version = "0.8", features = ["ws"] }
+font-kit = "0.14.3"
+tauri-plugin-clipboard-manager = "2.3.2"
+
+[target.'cfg(target_os = "macos")'.dependencies]
+objc2 = { version = "0.6.4", default-features = false, features = ["std"] }
+objc2-app-kit = { version = "0.3.2", default-features = false, features = ["NSApplication", "NSButton", "NSControl", "NSImage", "NSResponder", "NSView", "NSWindow"] }
+objc2-foundation = { version = "0.3.2", default-features = false, features = ["NSData"] }
+
+[target.'cfg(target_os = "linux")'.dependencies]
+libloading = "0.8"
diff --git a/src-tauri/Entitlements.plist b/src-tauri/Entitlements.plist
new file mode 100644
index 0000000..5a07243
--- /dev/null
+++ b/src-tauri/Entitlements.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "https://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>com.apple.security.cs.disable-library-validation</key>
+  <true/>
+</dict>
+</plist>
diff --git a/src-tauri/Info.plist b/src-tauri/Info.plist
new file mode 100644
index 0000000..5a03e62
--- /dev/null
+++ b/src-tauri/Info.plist
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "https://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>NSLocalNetworkUsageDescription</key>
+  <string>DBX needs local network access to connect to database servers on your LAN.</string>
+</dict>
+</plist>
diff --git a/src-tauri/build.rs b/src-tauri/build.rs
new file mode 100644
index 0000000..7631374
--- /dev/null
+++ b/src-tauri/build.rs
@@ -0,0 +1,4 @@
+fn main() {
+    // Force rebuild to re-embed frontend assets
+    tauri_build::build()
+}
diff --git a/src-tauri/capabilities/default.json b/src-tauri/capabilities/default.json
new file mode 100644
index 0000000..c3c181c
--- /dev/null
+++ b/src-tauri/capabilities/default.json
@@ -0,0 +1,33 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "enables the default permissions",
+  "windows": ["main"],
+  "permissions": [
+    "core:default",
+    "core:window:allow-show",
+    "core:window:allow-hide",
+    "core:window:allow-set-theme",
+    "core:window:allow-minimize",
+    "core:window:allow-maximize",
+    "core:window:allow-unmaximize",
+    "core:window:allow-toggle-maximize",
+    "core:window:allow-is-maximized",
+    "core:window:allow-close",
+    "core:window:allow-start-dragging",
+    "core:webview:allow-set-webview-zoom",
+    "clipboard-manager:allow-read-text",
+    "clipboard-manager:allow-write-text",
+    "dialog:default",
+    "dialog:allow-save",
+    "dialog:allow-open",
+    "fs:default",
+    "fs:allow-write-file",
+    "fs:allow-write-text-file",
+    "fs:allow-read-text-file",
+    "process:default",
+    "shell:allow-open",
+    "updater:default",
+    "window-state:default"
+  ]
+}
diff --git a/src-tauri/icons/128x128.png b/src-tauri/icons/128x128.png
new file mode 100644
index 0000000..3f9abc0
Binary files /dev/null and b/src-tauri/icons/128x128.png differ
diff --git a/src-tauri/icons/128x128@2x.png b/src-tauri/icons/128x128@2x.png
new file mode 100644
index 0000000..8bf8181
Binary files /dev/null and b/src-tauri/icons/128x128@2x.png differ
diff --git a/src-tauri/icons/32x32.png b/src-tauri/icons/32x32.png
new file mode 100644
index 0000000..b0cd326
Binary files /dev/null and b/src-tauri/icons/32x32.png differ
diff --git a/src-tauri/icons/Square107x107Logo.png b/src-tauri/icons/Square107x107Logo.png
new file mode 100644
index 0000000..32b3826
Binary files /dev/null and b/src-tauri/icons/Square107x107Logo.png differ
diff --git a/src-tauri/icons/Square142x142Logo.png b/src-tauri/icons/Square142x142Logo.png
new file mode 100644
index 0000000..2f4605c
Binary files /dev/null and b/src-tauri/icons/Square142x142Logo.png differ
diff --git a/src-tauri/icons/Square150x150Logo.png b/src-tauri/icons/Square150x150Logo.png
new file mode 100644
index 0000000..4bcdaf8
Binary files /dev/null and b/src-tauri/icons/Square150x150Logo.png differ
diff --git a/src-tauri/icons/Square284x284Logo.png b/src-tauri/icons/Square284x284Logo.png
new file mode 100644
index 0000000..e7afa0b
Binary files /dev/null and b/src-tauri/icons/Square284x284Logo.png differ
diff --git a/src-tauri/icons/Square30x30Logo.png b/src-tauri/icons/Square30x30Logo.png
new file mode 100644
index 0000000..2625692
Binary files /dev/null and b/src-tauri/icons/Square30x30Logo.png differ
diff --git a/src-tauri/icons/Square310x310Logo.png b/src-tauri/icons/Square310x310Logo.png
new file mode 100644
index 0000000..39bd1d7
Binary files /dev/null and b/src-tauri/icons/Square310x310Logo.png differ
diff --git a/src-tauri/icons/Square44x44Logo.png b/src-tauri/icons/Square44x44Logo.png
new file mode 100644
index 0000000..53fd057
Binary files /dev/null and b/src-tauri/icons/Square44x44Logo.png differ
diff --git a/src-tauri/icons/Square71x71Logo.png b/src-tauri/icons/Square71x71Logo.png
new file mode 100644
index 0000000..d61757c
Binary files /dev/null and b/src-tauri/icons/Square71x71Logo.png differ
diff --git a/src-tauri/icons/Square89x89Logo.png b/src-tauri/icons/Square89x89Logo.png
new file mode 100644
index 0000000..a5a9c4a
Binary files /dev/null and b/src-tauri/icons/Square89x89Logo.png differ
diff --git a/src-tauri/icons/StoreLogo.png b/src-tauri/icons/StoreLogo.png
new file mode 100644
index 0000000..d01666a
Binary files /dev/null and b/src-tauri/icons/StoreLogo.png differ
diff --git a/src-tauri/icons/icon-black.png b/src-tauri/icons/icon-black.png
new file mode 100644
index 0000000..c016b38
Binary files /dev/null and b/src-tauri/icons/icon-black.png differ
diff --git a/src-tauri/icons/icon-macos-dark.icns b/src-tauri/icons/icon-macos-dark.icns
new file mode 100644
index 0000000..1b4a3d6
Binary files /dev/null and b/src-tauri/icons/icon-macos-dark.icns differ
diff --git a/src-tauri/icons/icon.icns b/src-tauri/icons/icon.icns
new file mode 100644
index 0000000..9924338
Binary files /dev/null and b/src-tauri/icons/icon.icns differ
diff --git a/src-tauri/icons/icon.ico b/src-tauri/icons/icon.ico
new file mode 100644
index 0000000..ef4c6bb
Binary files /dev/null and b/src-tauri/icons/icon.ico differ
diff --git a/src-tauri/icons/icon.png b/src-tauri/icons/icon.png
new file mode 100644
index 0000000..41bb5f9
Binary files /dev/null and b/src-tauri/icons/icon.png differ
diff --git a/src-tauri/icons/tray-macos-template.png b/src-tauri/icons/tray-macos-template.png
new file mode 100644
index 0000000..02c7ee6
Binary files /dev/null and b/src-tauri/icons/tray-macos-template.png differ
diff --git a/src-tauri/src/commands/agents.rs b/src-tauri/src/commands/agents.rs
new file mode 100644
index 0000000..8ff69d7
--- /dev/null
+++ b/src-tauri/src/commands/agents.rs
@@ -0,0 +1,225 @@
+use std::sync::Arc;
+
+use tauri::{Emitter, State};
+
+use dbx_core::agent_manager::{AgentDriverInfo, DriverStoreUsage, JavaRuntimeConfig, JavaRuntimeMode, DEFAULT_JRE_KEY};
+use dbx_core::agent_service::{
+    build_agent_list, clear_agent_download_cache, fetch_registry_from, import_agent_jar,
+    import_agents_from_zip as import_agents_from_zip_core, install_agent_driver_from, invalidate_registry_cache,
+    reinstall_agent_jre_from, uninstall_agent_driver, uninstall_agent_jre, upgrade_all_agent_drivers_from,
+    AgentProgressEvent, UpgradeAllAgentDriversResult,
+};
+use dbx_core::connection::AppState;
+use dbx_core::driver_runtime::DriverRuntimeSummary;
+use dbx_core::DownloadSource;
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct AgentUpdateBlocker {
+    pub db_type: String,
+    pub label: String,
+}
+
+#[tauri::command]
+pub async fn list_installed_agents_local(state: State<'_, Arc<AppState>>) -> Result<Vec<AgentDriverInfo>, String> {
+    Ok(build_agent_list(&state.agent_manager, None))
+}
+
+#[tauri::command]
+pub async fn list_installed_agents(
+    state: State<'_, Arc<AppState>>,
+    source: Option<DownloadSource>,
+) -> Result<Vec<AgentDriverInfo>, String> {
+    let registry = fetch_registry_from(source.unwrap_or_default()).await.ok();
+    Ok(build_agent_list(&state.agent_manager, registry.as_ref()))
+}
+
+#[tauri::command]
+pub async fn is_agent_installed(state: State<'_, Arc<AppState>>, db_type: String) -> Result<bool, String> {
+    Ok(state.agent_manager.is_driver_installed(&db_type))
+}
+
+#[tauri::command]
+pub async fn get_driver_store_usage(state: State<'_, Arc<AppState>>) -> Result<DriverStoreUsage, String> {
+    Ok(state.agent_manager.collect_driver_store_usage(state.plugins.root_dir()))
+}
+
+#[tauri::command]
+pub async fn clear_driver_download_cache(state: State<'_, Arc<AppState>>) -> Result<(), String> {
+    clear_agent_download_cache(&state.agent_manager)
+}
+
+#[tauri::command]
+pub async fn get_driver_runtime_summary(state: State<'_, Arc<AppState>>) -> Result<DriverRuntimeSummary, String> {
+    Ok(dbx_core::driver_runtime::collect_driver_runtime_summary(state.inner().as_ref()).await)
+}
+
+#[tauri::command]
+pub async fn stop_driver_runtime(state: State<'_, Arc<AppState>>, runtime_id: String) -> Result<(), String> {
+    dbx_core::driver_runtime::stop_driver_runtime(state.inner().as_ref(), &runtime_id).await
+}
+
+#[tauri::command]
+pub async fn restart_driver_runtime(state: State<'_, Arc<AppState>>, runtime_id: String) -> Result<(), String> {
+    dbx_core::driver_runtime::restart_driver_runtime(state.inner().as_ref(), &runtime_id).await
+}
+
+#[tauri::command]
+pub async fn install_agent(
+    app: tauri::AppHandle,
+    state: State<'_, Arc<AppState>>,
+    db_type: String,
+    source: Option<DownloadSource>,
+) -> Result<(), String> {
+    ensure_no_agent_update_blockers(state.inner().as_ref(), std::slice::from_ref(&db_type)).await?;
+    let app_handle = app.clone();
+    install_agent_driver_from(&state.agent_manager, &db_type, source.unwrap_or_default(), move |event| {
+        emit_agent_progress(&app_handle, event)
+    })
+    .await
+}
+
+#[tauri::command]
+pub async fn upgrade_all_agents(
+    app: tauri::AppHandle,
+    state: State<'_, Arc<AppState>>,
+    source: Option<DownloadSource>,
+) -> Result<UpgradeAllAgentDriversResult, String> {
+    let source = source.unwrap_or_default();
+    let registry = fetch_registry_from(source).await?;
+    let agents = build_agent_list(&state.agent_manager, Some(&registry));
+    let updatable: Vec<String> =
+        agents.iter().filter(|agent| agent.update_available).map(|agent| agent.db_type.clone()).collect();
+    ensure_no_agent_update_blockers(state.inner().as_ref(), &updatable).await?;
+    let app_handle = app.clone();
+    upgrade_all_agent_drivers_from(&state.agent_manager, source, move |event| emit_agent_progress(&app_handle, event))
+        .await
+}
+
+#[tauri::command]
+pub async fn check_agent_update_blockers(
+    state: State<'_, Arc<AppState>>,
+    db_types: Vec<String>,
+) -> Result<Vec<AgentUpdateBlocker>, String> {
+    Ok(agent_update_blockers(state.inner().as_ref(), &db_types).await)
+}
+
+#[tauri::command]
+pub async fn uninstall_agent(state: State<'_, Arc<AppState>>, db_type: String) -> Result<(), String> {
+    uninstall_agent_driver(&state.agent_manager, &db_type).await
+}
+
+#[tauri::command]
+pub async fn check_jre_installed(state: State<'_, Arc<AppState>>, jre_key: Option<String>) -> Result<bool, String> {
+    let key = jre_key.as_deref().unwrap_or(DEFAULT_JRE_KEY);
+    Ok(state.agent_manager.is_jre_installed(key))
+}
+
+#[tauri::command]
+pub async fn get_agent_java_runtime_config(state: State<'_, Arc<AppState>>) -> Result<JavaRuntimeConfig, String> {
+    Ok(state.agent_manager.load_state().java_runtime)
+}
+
+#[tauri::command]
+pub async fn set_agent_java_runtime_config(
+    state: State<'_, Arc<AppState>>,
+    mut config: JavaRuntimeConfig,
+) -> Result<JavaRuntimeConfig, String> {
+    let am = &state.agent_manager;
+    if config.mode == JavaRuntimeMode::Custom || config.mode == JavaRuntimeMode::System {
+        let candidate_state = dbx_core::agent_manager::AgentState { java_runtime: config.clone(), ..am.load_state() };
+        let resolved = am.resolve_java_runtime(&candidate_state, DEFAULT_JRE_KEY)?;
+        if config.mode == JavaRuntimeMode::Custom {
+            config.custom_java_path = Some(resolved.to_string_lossy().to_string());
+        }
+    }
+    if config.mode != JavaRuntimeMode::Custom {
+        config.custom_java_path = None;
+    }
+
+    let mut local_state = am.load_state();
+    local_state.java_runtime = config.clone();
+    am.save_state(&local_state)?;
+    am.stop_daemons().await;
+    Ok(config)
+}
+
+#[tauri::command]
+pub async fn uninstall_jre(state: State<'_, Arc<AppState>>, jre_key: String) -> Result<(), String> {
+    uninstall_agent_jre(&state.agent_manager, &jre_key).await
+}
+
+#[tauri::command]
+pub async fn invalidate_agent_registry_cache() -> Result<(), String> {
+    invalidate_registry_cache().await;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn import_agents_from_zip(
+    app: tauri::AppHandle,
+    state: State<'_, Arc<AppState>>,
+    path: String,
+) -> Result<u32, String> {
+    let am = &state.agent_manager;
+    let zip_path = std::path::PathBuf::from(&path);
+    let app_handle = app.clone();
+    let result = import_agents_from_zip_core(am, &zip_path, |event| emit_agent_progress(&app_handle, event))?;
+    let count = result.drivers_installed.len() as u32;
+    emit_agent_progress(&app, AgentProgressEvent::step("done"));
+    Ok(count)
+}
+
+#[tauri::command]
+pub async fn import_agent_jar_cmd(
+    state: State<'_, Arc<AppState>>,
+    db_type: String,
+    path: String,
+) -> Result<(), String> {
+    import_agent_jar(&state.agent_manager, &db_type, std::path::Path::new(&path))
+}
+
+#[tauri::command]
+pub async fn reinstall_jre(
+    app: tauri::AppHandle,
+    state: State<'_, Arc<AppState>>,
+    jre_key: Option<String>,
+    source: Option<DownloadSource>,
+) -> Result<(), String> {
+    let key = jre_key.as_deref().unwrap_or(DEFAULT_JRE_KEY);
+    let app_handle = app.clone();
+    reinstall_agent_jre_from(&state.agent_manager, key, source.unwrap_or_default(), move |event| {
+        emit_agent_progress(&app_handle, event)
+    })
+    .await
+}
+
+fn emit_agent_progress(app: &tauri::AppHandle, event: AgentProgressEvent) {
+    let _ = app.emit("agent-install-progress", event);
+}
+
+async fn ensure_no_agent_update_blockers(state: &AppState, db_types: &[String]) -> Result<(), String> {
+    let blockers = agent_update_blockers(state, db_types).await;
+    if blockers.is_empty() {
+        return Ok(());
+    }
+    let labels = blockers.into_iter().map(|blocker| blocker.label).collect::<Vec<_>>().join(", ");
+    Err(format!("请先关闭以下数据库连接后再更新驱动: {labels}"))
+}
+
+async fn agent_update_blockers(state: &AppState, db_types: &[String]) -> Vec<AgentUpdateBlocker> {
+    let candidate_keys: std::collections::HashSet<&str> = db_types.iter().map(String::as_str).collect();
+    if candidate_keys.is_empty() {
+        return Vec::new();
+    }
+    let active_keys = state.active_agent_driver_keys().await;
+    let mut blockers = active_keys
+        .into_iter()
+        .filter(|key| candidate_keys.contains(key.as_str()))
+        .map(|db_type| AgentUpdateBlocker {
+            label: dbx_core::agent_catalog::label_for_key(&db_type).unwrap_or(&db_type).to_string(),
+            db_type,
+        })
+        .collect::<Vec<_>>();
+    blockers.sort_by(|left, right| left.label.cmp(&right.label));
+    blockers
+}
diff --git a/src-tauri/src/commands/ai.rs b/src-tauri/src/commands/ai.rs
new file mode 100644
index 0000000..ca8f674
--- /dev/null
+++ b/src-tauri/src/commands/ai.rs
@@ -0,0 +1,183 @@
+use std::path::Path;
+use std::sync::Arc;
+use tauri::{AppHandle, Emitter, State};
+
+use super::connection::AppState;
+pub use dbx_core::ai::*;
+
+#[tauri::command]
+pub async fn ai_test_connection(config: AiConfig) -> Result<AiTestConnectionResult, String> {
+    let config = resolve_codex_cli_config(config);
+    dbx_core::ai::test_connection_core(&config).await
+}
+
+#[tauri::command]
+pub async fn ai_list_models(config: AiConfig) -> Result<Vec<AiModelInfo>, String> {
+    let config = resolve_codex_cli_config(config);
+    dbx_core::ai::list_models_core(&config).await
+}
+
+#[tauri::command]
+pub async fn save_ai_config(state: State<'_, Arc<AppState>>, config: AiConfig) -> Result<(), String> {
+    state.storage.save_ai_config(&config).await
+}
+
+#[tauri::command]
+pub async fn load_ai_config(state: State<'_, Arc<AppState>>) -> Result<Option<AiConfig>, String> {
+    state.storage.load_ai_config().await
+}
+
+#[tauri::command]
+pub async fn save_ai_provider_config(
+    state: State<'_, Arc<AppState>>,
+    provider: String,
+    config: AiConfig,
+) -> Result<(), String> {
+    let parsed_provider: AiProvider = serde_json::from_value(serde_json::Value::String(provider.clone()))
+        .map_err(|_| format!("Invalid AI provider: {provider}"))?;
+    let mut config = config;
+    config.provider = parsed_provider;
+    state.storage.save_ai_provider_config(&provider, &config).await
+}
+
+#[tauri::command]
+pub async fn load_ai_provider_configs(
+    state: State<'_, Arc<AppState>>,
+) -> Result<std::collections::HashMap<String, AiConfig>, String> {
+    state.storage.load_ai_provider_configs().await
+}
+
+#[tauri::command]
+pub async fn ai_complete(request: AiCompletionRequest) -> Result<String, String> {
+    dbx_core::ai::complete(&request).await
+}
+
+#[tauri::command]
+pub async fn ai_stream(app: AppHandle, session_id: String, request: AiCompletionRequest) -> Result<(), String> {
+    let cancelled = dbx_core::ai::register_stream(&session_id).await;
+
+    let result = dbx_core::ai::stream(&session_id, &request, &cancelled, |chunk| {
+        let _ = app.emit("ai-stream-chunk", &chunk);
+    })
+    .await;
+
+    dbx_core::ai::unregister_stream(&session_id).await;
+    result
+}
+
+use dbx_core::agent_events::AgentEvent;
+use dbx_core::agent_loop::{run_agent_loop, AgentLoopContext};
+use dbx_core::ai_cli_agent::CliAgentCommandSpec;
+use dbx_core::models::connection::DatabaseType;
+
+#[tauri::command]
+pub async fn ai_cancel_stream(session_id: String) -> Result<bool, String> {
+    Ok(dbx_core::ai::cancel_stream(&session_id).await)
+}
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+pub async fn ai_agent_stream(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    session_id: String,
+    request: AiCompletionRequest,
+    connection_id: String,
+    database: String,
+    db_type: String,
+    mode: Option<String>,
+    allow_write_sql: Option<bool>,
+) -> Result<String, String> {
+    let request = resolve_codex_cli_request(request);
+    let cancelled = dbx_core::ai::register_stream(&session_id).await;
+
+    let parsed_db_type: DatabaseType =
+        serde_json::from_str(&format!("\"{}\"", db_type)).map_err(|_| format!("Unknown database type: {db_type}"))?;
+
+    let cli_mcp_server_command = if matches!(request.config.provider, AiProvider::CodexCli) {
+        super::mcp::resolve_mcp_server_command().map(|(program, args)| CliAgentCommandSpec { program, args })
+    } else {
+        None
+    };
+    let production_database = state
+        .configs
+        .read()
+        .await
+        .get(&connection_id)
+        .is_some_and(|config| dbx_core::production_safety::is_production_database(config, &database));
+    let agent_ctx = AgentLoopContext {
+        state: state.inner().clone(),
+        connection_id,
+        database,
+        db_type: parsed_db_type,
+        cli_mcp_server_command,
+        // Explicit confirmation grants write access only to this agent run, never to production.
+        sql_permissions: dbx_core::agent_tools::AgentSqlPermissions {
+            allow_writes: !production_database && allow_write_sql.unwrap_or(false),
+            allow_dangerous: !production_database && allow_write_sql.unwrap_or(false),
+        },
+    };
+    let is_agent_mode = mode.as_deref() == Some("agent");
+
+    let result = run_agent_loop(
+        &request.config,
+        &request.system_prompt,
+        &request.messages,
+        &agent_ctx,
+        {
+            let app = app.clone();
+            move |event: AgentEvent| {
+                let _ = app.emit("ai-agent-event", &event);
+            }
+        },
+        &cancelled,
+        request.max_tokens,
+        request.task_contract.as_ref(),
+        is_agent_mode,
+    )
+    .await;
+
+    dbx_core::ai::unregister_stream(&session_id).await;
+    result
+}
+
+fn resolve_codex_cli_request(mut request: AiCompletionRequest) -> AiCompletionRequest {
+    request.config = resolve_codex_cli_config(request.config);
+    request
+}
+
+fn resolve_codex_cli_config(mut config: AiConfig) -> AiConfig {
+    if !matches!(config.provider, AiProvider::CodexCli) {
+        return config;
+    }
+
+    let command = config.codex_cli_path.as_deref().map(str::trim).filter(|path| !path.is_empty()).unwrap_or("codex");
+    if is_explicit_cli_path(command) {
+        return config;
+    }
+
+    if let Some(path) = super::mcp::locate_command(command) {
+        config.codex_cli_path = Some(path);
+    }
+    config
+}
+
+fn is_explicit_cli_path(command: &str) -> bool {
+    let path = Path::new(command);
+    path.is_absolute() || command.contains('/') || command.contains('\\')
+}
+
+#[tauri::command]
+pub async fn save_ai_conversation(state: State<'_, Arc<AppState>>, conversation: AiConversation) -> Result<(), String> {
+    state.storage.save_ai_conversation(&conversation).await
+}
+
+#[tauri::command]
+pub async fn load_ai_conversations(state: State<'_, Arc<AppState>>) -> Result<Vec<AiConversation>, String> {
+    state.storage.load_ai_conversations().await
+}
+
+#[tauri::command]
+pub async fn delete_ai_conversation(state: State<'_, Arc<AppState>>, id: String) -> Result<(), String> {
+    state.storage.delete_ai_conversation(&id).await
+}
diff --git a/src-tauri/src/commands/app_settings.rs b/src-tauri/src/commands/app_settings.rs
new file mode 100644
index 0000000..b935578
--- /dev/null
+++ b/src-tauri/src/commands/app_settings.rs
@@ -0,0 +1,526 @@
+use std::{
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+
+use dbx_core::storage::DesktopSettings;
+use tauri::{AppHandle, Manager, State, Window};
+
+use super::connection::AppState;
+use crate::{
+    apply_debug_log_level, apply_desktop_settings, hide_main_window_for_close, request_app_close, CloseBehaviorState,
+};
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct DriverStoreMigrationResult {
+    pub driver_store_dir: Option<String>,
+    pub plugin_store_dir: Option<String>,
+    pub agent_store_dir: Option<String>,
+    pub plugins_dir: String,
+    pub agents_dir: String,
+    pub migrated_plugins: bool,
+    pub migrated_agents: bool,
+}
+
+#[tauri::command]
+pub async fn load_desktop_settings(state: State<'_, Arc<AppState>>) -> Result<DesktopSettings, String> {
+    state.storage.load_desktop_settings().await
+}
+
+#[tauri::command]
+pub async fn save_desktop_settings(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    settings: DesktopSettings,
+) -> Result<(), String> {
+    state.storage.save_desktop_settings(&settings).await?;
+    state.apply_duckdb_worker_process_isolation(settings.duckdb_worker_process_isolation).await;
+    apply_debug_log_level(settings.debug_logging_enabled);
+    if let Err(err) = apply_desktop_settings(&app, &settings) {
+        eprintln!("Failed to apply desktop settings: {err}");
+    }
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn complete_app_close(app: AppHandle, window: Window, action: String) -> Result<(), String> {
+    match action.as_str() {
+        "quit" => {
+            if let Some(state) = app.try_state::<CloseBehaviorState>() {
+                state.allow_next_exit();
+            }
+            app.exit(0);
+        }
+        "hide" => {
+            hide_main_window_for_close(&app, &window);
+        }
+        _ => return Err(format!("unsupported close action: {action}")),
+    }
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn request_app_close_from_window_controls(app: AppHandle) -> Result<(), String> {
+    request_app_close(&app, "settings");
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn load_pinned_tree_node_ids(state: State<'_, Arc<AppState>>) -> Result<Vec<String>, String> {
+    state.storage.load_pinned_tree_node_ids().await
+}
+
+#[tauri::command]
+pub async fn save_pinned_tree_node_ids(state: State<'_, Arc<AppState>>, ids: Vec<String>) -> Result<(), String> {
+    state.storage.save_pinned_tree_node_ids(&ids).await
+}
+
+#[tauri::command]
+pub async fn load_editor_settings(state: State<'_, Arc<AppState>>) -> Result<Option<serde_json::Value>, String> {
+    state.storage.load_editor_settings().await
+}
+
+#[tauri::command]
+pub async fn save_editor_settings(state: State<'_, Arc<AppState>>, settings: serde_json::Value) -> Result<(), String> {
+    state.storage.save_editor_settings(&settings).await
+}
+
+#[tauri::command]
+pub async fn load_open_tabs_state(state: State<'_, Arc<AppState>>) -> Result<Option<serde_json::Value>, String> {
+    state.storage.load_open_tabs_state().await
+}
+
+#[tauri::command]
+pub async fn save_open_tabs_state(state: State<'_, Arc<AppState>>, payload: serde_json::Value) -> Result<(), String> {
+    state.storage.save_open_tabs_state(&payload).await
+}
+
+#[tauri::command]
+pub async fn load_saved_sql_editor_positions(
+    state: State<'_, Arc<AppState>>,
+) -> Result<Option<serde_json::Value>, String> {
+    state.storage.load_saved_sql_editor_positions().await
+}
+
+#[tauri::command]
+pub async fn save_saved_sql_editor_positions(
+    state: State<'_, Arc<AppState>>,
+    positions: serde_json::Value,
+) -> Result<(), String> {
+    state.storage.save_saved_sql_editor_positions(&positions).await
+}
+
+#[tauri::command]
+pub async fn load_native_debug_logs(app: AppHandle) -> Result<String, String> {
+    let log_dir = app.path().app_log_dir().map_err(|e| e.to_string())?;
+    tauri::async_runtime::spawn_blocking(move || load_native_debug_logs_from_dir(log_dir))
+        .await
+        .map_err(|err| err.to_string())?
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct DriverStorePathInfo {
+    pub driver_store_dir: Option<String>,
+    pub plugin_store_dir: Option<String>,
+    pub agent_store_dir: Option<String>,
+    pub plugins_dir: String,
+    pub agents_dir: String,
+}
+
+#[tauri::command]
+pub async fn get_driver_store_path(state: State<'_, Arc<AppState>>) -> Result<DriverStorePathInfo, String> {
+    let settings = state.storage.load_desktop_settings().await.unwrap_or_default();
+    Ok(DriverStorePathInfo {
+        driver_store_dir: settings.driver_store_dir,
+        plugin_store_dir: settings.plugin_store_dir,
+        agent_store_dir: settings.agent_store_dir,
+        plugins_dir: state.plugins.root_dir().to_string_lossy().to_string(),
+        agents_dir: state.agent_manager.base_dir().to_string_lossy().to_string(),
+    })
+}
+
+#[tauri::command]
+pub async fn set_driver_store_dir(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    new_dir: Option<String>,
+) -> Result<DriverStoreMigrationResult, String> {
+    let new_dir = normalize_store_dir(new_dir);
+    let current_plugins_dir = state.plugins.root_dir().to_path_buf();
+    let current_agents_dir = state.agent_manager.base_dir().clone();
+    let (target_plugins_dir, target_agents_dir) = match new_dir.as_ref() {
+        Some(dir) => {
+            let driver_base = PathBuf::from(dir);
+            (driver_base.join("plugins"), driver_base.join("agents"))
+        }
+        None => default_store_dirs(&app)?,
+    };
+
+    state.agent_manager.stop_daemons().await;
+    let migrated_plugins = migrate_store_directory(&current_plugins_dir, &target_plugins_dir)?;
+    let migrated_agents = migrate_store_directory(&current_agents_dir, &target_agents_dir)?;
+
+    let mut settings = state.storage.load_desktop_settings().await.unwrap_or_default();
+    settings.driver_store_dir = new_dir.clone();
+    settings.plugin_store_dir = None;
+    settings.agent_store_dir = None;
+    state.storage.save_desktop_settings(&settings).await?;
+
+    Ok(driver_store_migration_result(
+        settings,
+        &target_plugins_dir,
+        &target_agents_dir,
+        migrated_plugins,
+        migrated_agents,
+    ))
+}
+
+#[tauri::command]
+pub async fn set_plugin_store_dir(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    new_dir: Option<String>,
+) -> Result<DriverStoreMigrationResult, String> {
+    let new_dir = normalize_store_dir(new_dir);
+    let current_plugins_dir = state.plugins.root_dir().to_path_buf();
+    let current_agents_dir = state.agent_manager.base_dir().clone();
+    let target_plugins_dir = match new_dir.as_ref() {
+        Some(dir) => PathBuf::from(dir),
+        None => default_plugin_store_dir(&app)?,
+    };
+
+    let migrated_plugins = migrate_store_directory(&current_plugins_dir, &target_plugins_dir)?;
+
+    let mut settings = state.storage.load_desktop_settings().await.unwrap_or_default();
+    convert_legacy_driver_store(&mut settings, &current_plugins_dir, &current_agents_dir);
+    settings.plugin_store_dir = new_dir;
+    state.storage.save_desktop_settings(&settings).await?;
+
+    Ok(driver_store_migration_result(settings, &target_plugins_dir, &current_agents_dir, migrated_plugins, false))
+}
+
+#[tauri::command]
+pub async fn set_agent_store_dir(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    new_dir: Option<String>,
+) -> Result<DriverStoreMigrationResult, String> {
+    let new_dir = normalize_store_dir(new_dir);
+    let current_plugins_dir = state.plugins.root_dir().to_path_buf();
+    let current_agents_dir = state.agent_manager.base_dir().clone();
+    let target_agents_dir = match new_dir.as_ref() {
+        Some(dir) => PathBuf::from(dir),
+        None => default_agent_store_dir(&app)?,
+    };
+
+    state.agent_manager.stop_daemons().await;
+    let migrated_agents = migrate_store_directory(&current_agents_dir, &target_agents_dir)?;
+
+    let mut settings = state.storage.load_desktop_settings().await.unwrap_or_default();
+    convert_legacy_driver_store(&mut settings, &current_plugins_dir, &current_agents_dir);
+    settings.agent_store_dir = new_dir;
+    state.storage.save_desktop_settings(&settings).await?;
+
+    Ok(driver_store_migration_result(settings, &current_plugins_dir, &target_agents_dir, false, migrated_agents))
+}
+
+fn normalize_store_dir(dir: Option<String>) -> Option<String> {
+    dir.and_then(|value| {
+        let trimmed = value.trim();
+        (!trimmed.is_empty()).then(|| trimmed.to_string())
+    })
+}
+
+fn default_store_dirs(app: &AppHandle) -> Result<(PathBuf, PathBuf), String> {
+    Ok((default_plugin_store_dir(app)?, default_agent_store_dir(app)?))
+}
+
+fn default_plugin_store_dir(app: &AppHandle) -> Result<PathBuf, String> {
+    let default_data_dir = app.path().app_data_dir().map_err(|e| e.to_string())?;
+    Ok(crate::data_dir::resolve_data_dir_with_mode(default_data_dir).data_dir.join("plugins"))
+}
+
+fn default_agent_store_dir(app: &AppHandle) -> Result<PathBuf, String> {
+    let default_data_dir = app.path().app_data_dir().map_err(|e| e.to_string())?;
+    let data_dir_resolution = crate::data_dir::resolve_data_dir_with_mode(default_data_dir);
+    Ok(if data_dir_resolution.uses_custom_data_dir() {
+        data_dir_resolution.data_dir.join("agents")
+    } else {
+        dbx_core::connection::default_agent_dir()
+    })
+}
+
+pub(crate) fn resolve_driver_store_dirs_from_settings(
+    settings: &DesktopSettings,
+    data_dir: &Path,
+    default_agent_dir: Option<PathBuf>,
+) -> (PathBuf, Option<PathBuf>) {
+    let legacy_driver_base =
+        settings.driver_store_dir.as_ref().filter(|value| !value.trim().is_empty()).map(PathBuf::from);
+    let plugin_dir = settings
+        .plugin_store_dir
+        .as_ref()
+        .filter(|value| !value.trim().is_empty())
+        .map(PathBuf::from)
+        .or_else(|| legacy_driver_base.as_ref().map(|base| base.join("plugins")))
+        .unwrap_or_else(|| data_dir.join("plugins"));
+    let agent_dir = settings
+        .agent_store_dir
+        .as_ref()
+        .filter(|value| !value.trim().is_empty())
+        .map(PathBuf::from)
+        .or_else(|| legacy_driver_base.as_ref().map(|base| base.join("agents")))
+        .or(default_agent_dir);
+
+    (plugin_dir, agent_dir)
+}
+
+fn convert_legacy_driver_store(settings: &mut DesktopSettings, current_plugins_dir: &Path, current_agents_dir: &Path) {
+    if settings.driver_store_dir.is_none() {
+        return;
+    }
+    if settings.plugin_store_dir.is_none() {
+        settings.plugin_store_dir = Some(current_plugins_dir.to_string_lossy().to_string());
+    }
+    if settings.agent_store_dir.is_none() {
+        settings.agent_store_dir = Some(current_agents_dir.to_string_lossy().to_string());
+    }
+    settings.driver_store_dir = None;
+}
+
+fn driver_store_migration_result(
+    settings: DesktopSettings,
+    plugins_dir: &Path,
+    agents_dir: &Path,
+    migrated_plugins: bool,
+    migrated_agents: bool,
+) -> DriverStoreMigrationResult {
+    DriverStoreMigrationResult {
+        driver_store_dir: settings.driver_store_dir,
+        plugin_store_dir: settings.plugin_store_dir,
+        agent_store_dir: settings.agent_store_dir,
+        plugins_dir: plugins_dir.to_string_lossy().to_string(),
+        agents_dir: agents_dir.to_string_lossy().to_string(),
+        migrated_plugins,
+        migrated_agents,
+    }
+}
+
+fn migrate_store_directory(current_dir: &Path, target_dir: &Path) -> Result<bool, String> {
+    std::fs::create_dir_all(target_dir)
+        .map_err(|e| format!("Failed to create directory {}: {e}", target_dir.display()))?;
+    let target_canonical =
+        target_dir.canonicalize().map_err(|e| format!("Invalid path {}: {e}", target_dir.display()))?;
+
+    if !current_dir.exists() {
+        return Ok(false);
+    }
+
+    let current_canonical =
+        current_dir.canonicalize().map_err(|e| format!("Invalid path {}: {e}", current_dir.display()))?;
+    if current_canonical == target_canonical {
+        return Ok(false);
+    }
+    if target_canonical.starts_with(&current_canonical) {
+        return Err(format!(
+            "Target directory {} cannot be inside current directory {}",
+            target_dir.display(),
+            current_dir.display()
+        ));
+    }
+    if target_dir_has_entries(target_dir)? {
+        return Err(format!(
+            "Target directory {} is not empty. Please choose an empty directory or remove the existing data first.",
+            target_dir.display()
+        ));
+    }
+
+    migrate_directory(current_dir, target_dir)?;
+    verify_migration(current_dir, target_dir)?;
+    if let Err(err) = std::fs::remove_dir_all(current_dir) {
+        log::warn!("Failed to remove old driver store dir {}: {err}", current_dir.display());
+    }
+    Ok(true)
+}
+
+fn target_dir_has_entries(dir: &Path) -> Result<bool, String> {
+    let mut entries = std::fs::read_dir(dir).map_err(|e| format!("Failed to read {}: {e}", dir.display()))?;
+    Ok(entries.next().transpose().map_err(|e| e.to_string())?.is_some())
+}
+
+/// Recursively copy a directory to a new location.
+fn migrate_directory(src: &Path, dst: &Path) -> Result<(), String> {
+    if !src.exists() {
+        return Ok(());
+    }
+    std::fs::create_dir_all(dst).map_err(|e| format!("Failed to create {}: {e}", dst.display()))?;
+    copy_dir_recursive(src, dst)
+}
+
+fn copy_dir_recursive(src: &std::path::Path, dst: &std::path::Path) -> Result<(), String> {
+    std::fs::create_dir_all(dst).map_err(|e| format!("Failed to create {}: {e}", dst.display()))?;
+    for entry in std::fs::read_dir(src).map_err(|e| format!("Failed to read {}: {e}", src.display()))? {
+        let entry = entry.map_err(|e| e.to_string())?;
+        let src_path = entry.path();
+        let dst_path = dst.join(entry.file_name());
+        if src_path.is_dir() {
+            copy_dir_recursive(&src_path, &dst_path)?;
+        } else {
+            std::fs::copy(&src_path, &dst_path)
+                .map_err(|e| format!("Failed to copy {} to {}: {e}", src_path.display(), dst_path.display()))?;
+        }
+    }
+    Ok(())
+}
+
+/// Verify that the migrated directory has the same file count and total size.
+fn verify_migration(src: &Path, dst: &Path) -> Result<(), String> {
+    let src_info = count_files_recursive(src)?;
+    let dst_info = count_files_recursive(dst)?;
+    if src_info.count != dst_info.count || src_info.total_size != dst_info.total_size {
+        // Rollback: remove the incomplete destination
+        let _ = std::fs::remove_dir_all(dst);
+        return Err(format!(
+            "Migration verification failed: source had {} files ({} bytes), destination has {} files ({} bytes)",
+            src_info.count, src_info.total_size, dst_info.count, dst_info.total_size
+        ));
+    }
+    Ok(())
+}
+
+struct DirStats {
+    count: usize,
+    total_size: u64,
+}
+
+fn count_files_recursive(dir: &std::path::Path) -> Result<DirStats, String> {
+    let mut count = 0usize;
+    let mut total_size = 0u64;
+    fn walk(dir: &std::path::Path, count: &mut usize, total_size: &mut u64) -> Result<(), String> {
+        for entry in std::fs::read_dir(dir).map_err(|e| e.to_string())? {
+            let entry = entry.map_err(|e| e.to_string())?;
+            let path = entry.path();
+            if path.is_dir() {
+                walk(&path, count, total_size)?;
+            } else {
+                *count += 1;
+                *total_size += entry.metadata().map(|m| m.len()).unwrap_or(0);
+            }
+        }
+        Ok(())
+    }
+    walk(dir, &mut count, &mut total_size)?;
+    Ok(DirStats { count, total_size })
+}
+
+fn load_native_debug_logs_from_dir(log_dir: PathBuf) -> Result<String, String> {
+    const MAX_FILES: usize = 6;
+    const MAX_FILE_BYTES: u64 = 512 * 1024;
+    if !log_dir.exists() {
+        return Ok(format!("Native log dir does not exist yet: {}", log_dir.display()));
+    }
+    let mut files = std::fs::read_dir(&log_dir)
+        .map_err(|e| e.to_string())?
+        .filter_map(|entry| entry.ok())
+        .filter_map(|entry| {
+            let path = entry.path();
+            let metadata = entry.metadata().ok()?;
+            if !metadata.is_file() {
+                return None;
+            }
+            let modified = metadata.modified().ok()?;
+            Some((path, modified, metadata.len()))
+        })
+        .collect::<Vec<_>>();
+    files.sort_by_key(|(_, modified, _)| *modified);
+    files.reverse();
+
+    let mut output = String::new();
+    output.push_str(&format!("Native log dir: {}\n", log_dir.display()));
+    for (path, _, len) in files.into_iter().take(MAX_FILES) {
+        let name = path.file_name().and_then(|name| name.to_str()).unwrap_or("unknown");
+        output.push_str(&format!("\n===== {name} =====\n"));
+        let bytes = std::fs::read(&path).map_err(|e| e.to_string())?;
+        let start = if len > MAX_FILE_BYTES { bytes.len().saturating_sub(MAX_FILE_BYTES as usize) } else { 0 };
+        if start > 0 {
+            output.push_str("[truncated to last 512 KiB]\n");
+        }
+        output.push_str(&String::from_utf8_lossy(&bytes[start..]));
+        output.push('\n');
+    }
+    Ok(output)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{driver_store_migration_result, resolve_driver_store_dirs_from_settings, DesktopSettings};
+    use std::path::PathBuf;
+
+    #[test]
+    fn plugin_store_result_uses_selected_directory_without_agent_prefix() {
+        let settings = DesktopSettings {
+            plugin_store_dir: Some(path("D:/develop/DBX")),
+            agent_store_dir: Some(path("D:/develop/DBX/agents")),
+            ..Default::default()
+        };
+        let plugins_dir = PathBuf::from(path("D:/develop/DBX"));
+        let agents_dir = PathBuf::from(path("D:/develop/DBX/agents"));
+
+        let result = driver_store_migration_result(settings, &plugins_dir, &agents_dir, true, false);
+
+        assert_eq!(result.plugin_store_dir.as_deref(), Some(path("D:/develop/DBX").as_str()));
+        assert_eq!(result.plugins_dir, path("D:/develop/DBX"));
+        assert_eq!(result.agents_dir, path("D:/develop/DBX/agents"));
+        assert!(!result.plugins_dir.contains(&path("agents/com.dbx.app/plugins")));
+    }
+
+    #[test]
+    fn legacy_driver_store_result_keeps_plugins_and_agents_as_siblings() {
+        let settings = DesktopSettings { driver_store_dir: Some(path("D:/develop/DBX")), ..Default::default() };
+        let plugins_dir = PathBuf::from(path("D:/develop/DBX/plugins"));
+        let agents_dir = PathBuf::from(path("D:/develop/DBX/agents"));
+
+        let result = driver_store_migration_result(settings, &plugins_dir, &agents_dir, true, true);
+
+        assert_eq!(result.driver_store_dir.as_deref(), Some(path("D:/develop/DBX").as_str()));
+        assert_eq!(result.plugins_dir, path("D:/develop/DBX/plugins"));
+        assert_eq!(result.agents_dir, path("D:/develop/DBX/agents"));
+    }
+
+    #[test]
+    fn resolves_separate_plugin_store_dir_as_exact_selected_dir() {
+        let settings = DesktopSettings {
+            driver_store_dir: Some(path("D:/legacy-base")),
+            plugin_store_dir: Some(path("D:/develop/DBX")),
+            agent_store_dir: Some(path("D:/develop/DBX/agents")),
+            ..Default::default()
+        };
+
+        let (plugins_dir, agents_dir) = resolve_driver_store_dirs_from_settings(
+            &settings,
+            &PathBuf::from(path("C:/Users/lenovo/AppData/Roaming/com.dbx.app")),
+            Some(PathBuf::from(path("C:/Users/lenovo/.dbx/agents"))),
+        );
+
+        assert_eq!(plugins_dir, PathBuf::from(path("D:/develop/DBX")));
+        assert_eq!(agents_dir, Some(PathBuf::from(path("D:/develop/DBX/agents"))));
+    }
+
+    #[test]
+    fn resolves_legacy_driver_store_dir_to_sibling_plugins_and_agents() {
+        let settings = DesktopSettings { driver_store_dir: Some(path("D:/develop/DBX")), ..Default::default() };
+
+        let (plugins_dir, agents_dir) = resolve_driver_store_dirs_from_settings(
+            &settings,
+            &PathBuf::from(path("C:/Users/lenovo/AppData/Roaming/com.dbx.app")),
+            Some(PathBuf::from(path("C:/Users/lenovo/.dbx/agents"))),
+        );
+
+        assert_eq!(plugins_dir, PathBuf::from(path("D:/develop/DBX/plugins")));
+        assert_eq!(agents_dir, Some(PathBuf::from(path("D:/develop/DBX/agents"))));
+    }
+
+    fn path(value: &str) -> String {
+        value.replace('/', std::path::MAIN_SEPARATOR_STR)
+    }
+}
diff --git a/src-tauri/src/commands/cloud_sync.rs b/src-tauri/src/commands/cloud_sync.rs
new file mode 100644
index 0000000..1422305
--- /dev/null
+++ b/src-tauri/src/commands/cloud_sync.rs
@@ -0,0 +1,204 @@
+use std::sync::Arc;
+
+use dbx_core::cloud_sync::{
+    apply_sync_snapshot, build_sync_snapshot_with_saved_secrets, forget_snippet_token, forget_webdav_password,
+    forget_webdav_sync_secrets_passphrase as core_forget_webdav_sync_secrets_passphrase, resolve_snippet_token,
+    resolve_webdav_password, resolve_webdav_sync_secrets_passphrase, save_snippet_token, save_webdav_password,
+    save_webdav_sync_secrets_preference as core_save_webdav_sync_secrets_preference, snippet_saved_token_status,
+    webdav_saved_password_status, webdav_sync_secrets_status as core_webdav_sync_secrets_status, ApplySnapshotOptions,
+    ApplySnapshotSummary, SnippetSyncClient, SnippetSyncConfig, SnippetSyncSummary, SnippetTokenStatus, WebDavClient,
+    WebDavConfig, WebDavPasswordStatus, WebDavSyncSecretsStatus, WebDavSyncSummary,
+};
+use dbx_core::storage::DesktopSettings;
+use serde::{Deserialize, Serialize};
+use tauri::State;
+
+use dbx_core::connection::AppState;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct WebDavDownloadResult {
+    pub summary: WebDavSyncSummary,
+    pub editor_settings: Option<serde_json::Value>,
+    pub desktop_settings: DesktopSettings,
+    pub apply_summary: ApplySnapshotSummary,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SnippetDownloadResult {
+    pub summary: SnippetSyncSummary,
+    pub editor_settings: Option<serde_json::Value>,
+    pub desktop_settings: DesktopSettings,
+    pub apply_summary: ApplySnapshotSummary,
+}
+
+#[tauri::command]
+pub async fn webdav_sync_test(state: State<'_, Arc<AppState>>, mut config: WebDavConfig) -> Result<(), String> {
+    resolve_webdav_password(&state.storage, &mut config).await?;
+    WebDavClient::new(config).test().await
+}
+
+#[tauri::command]
+pub async fn webdav_password_status(
+    state: State<'_, Arc<AppState>>,
+    config: WebDavConfig,
+) -> Result<WebDavPasswordStatus, String> {
+    webdav_saved_password_status(&state.storage, &config).await
+}
+
+#[tauri::command]
+pub async fn save_webdav_saved_password(
+    state: State<'_, Arc<AppState>>,
+    config: WebDavConfig,
+    password: String,
+) -> Result<(), String> {
+    save_webdav_password(&state.storage, &config, &password).await
+}
+
+#[tauri::command]
+pub async fn forget_webdav_saved_password(state: State<'_, Arc<AppState>>, config: WebDavConfig) -> Result<(), String> {
+    forget_webdav_password(&state.storage, &config).await
+}
+
+#[tauri::command]
+pub async fn webdav_sync_secrets_status(state: State<'_, Arc<AppState>>) -> Result<WebDavSyncSecretsStatus, String> {
+    core_webdav_sync_secrets_status(&state.storage).await
+}
+
+#[tauri::command]
+pub async fn save_webdav_sync_secrets_preference(
+    state: State<'_, Arc<AppState>>,
+    enabled: bool,
+    passphrase: Option<String>,
+) -> Result<(), String> {
+    core_save_webdav_sync_secrets_preference(&state.storage, enabled, passphrase.as_deref()).await
+}
+
+#[tauri::command]
+pub async fn forget_webdav_sync_secrets_passphrase(state: State<'_, Arc<AppState>>) -> Result<(), String> {
+    core_forget_webdav_sync_secrets_passphrase(&state.storage).await
+}
+
+#[tauri::command]
+pub async fn webdav_sync_upload(
+    state: State<'_, Arc<AppState>>,
+    mut config: WebDavConfig,
+    editor_settings: Option<serde_json::Value>,
+    secrets_passphrase: Option<String>,
+) -> Result<WebDavSyncSummary, String> {
+    resolve_webdav_password(&state.storage, &mut config).await?;
+    let snapshot = build_sync_snapshot_with_saved_secrets(
+        &state.storage,
+        env!("CARGO_PKG_VERSION"),
+        editor_settings,
+        secrets_passphrase.as_deref(),
+    )
+    .await?;
+    WebDavClient::new(config).put_snapshot(&snapshot).await
+}
+
+#[tauri::command]
+pub async fn webdav_sync_download(
+    state: State<'_, Arc<AppState>>,
+    mut config: WebDavConfig,
+    secrets_passphrase: Option<String>,
+) -> Result<WebDavDownloadResult, String> {
+    resolve_webdav_password(&state.storage, &mut config).await?;
+    let (snapshot, summary) = WebDavClient::new(config).get_snapshot().await?;
+    let explicit_passphrase = secrets_passphrase.as_deref().map(str::trim).filter(|value| !value.is_empty());
+    let saved_passphrase = if explicit_passphrase.is_some() {
+        None
+    } else {
+        resolve_webdav_sync_secrets_passphrase(&state.storage).await?
+    };
+    let apply_summary = apply_sync_snapshot(
+        &state.storage,
+        &snapshot,
+        ApplySnapshotOptions { secrets_passphrase: explicit_passphrase.or(saved_passphrase.as_deref()) },
+    )
+    .await?;
+    Ok(WebDavDownloadResult {
+        summary,
+        editor_settings: snapshot.editor_settings,
+        desktop_settings: snapshot.desktop_settings,
+        apply_summary,
+    })
+}
+
+#[tauri::command]
+pub async fn snippet_sync_test(state: State<'_, Arc<AppState>>, mut config: SnippetSyncConfig) -> Result<(), String> {
+    resolve_snippet_token(&state.storage, &mut config).await?;
+    SnippetSyncClient::new(config).test().await
+}
+
+#[tauri::command]
+pub async fn snippet_token_status(
+    state: State<'_, Arc<AppState>>,
+    config: SnippetSyncConfig,
+) -> Result<SnippetTokenStatus, String> {
+    snippet_saved_token_status(&state.storage, &config).await
+}
+
+#[tauri::command]
+pub async fn save_snippet_saved_token(
+    state: State<'_, Arc<AppState>>,
+    config: SnippetSyncConfig,
+    token: String,
+) -> Result<(), String> {
+    save_snippet_token(&state.storage, &config, &token).await
+}
+
+#[tauri::command]
+pub async fn forget_snippet_saved_token(
+    state: State<'_, Arc<AppState>>,
+    config: SnippetSyncConfig,
+) -> Result<(), String> {
+    forget_snippet_token(&state.storage, &config).await
+}
+
+#[tauri::command]
+pub async fn snippet_sync_upload(
+    state: State<'_, Arc<AppState>>,
+    mut config: SnippetSyncConfig,
+    editor_settings: Option<serde_json::Value>,
+    secrets_passphrase: Option<String>,
+) -> Result<SnippetSyncSummary, String> {
+    resolve_snippet_token(&state.storage, &mut config).await?;
+    let snapshot = build_sync_snapshot_with_saved_secrets(
+        &state.storage,
+        env!("CARGO_PKG_VERSION"),
+        editor_settings,
+        secrets_passphrase.as_deref(),
+    )
+    .await?;
+    SnippetSyncClient::new(config).put_snapshot(&snapshot).await
+}
+
+#[tauri::command]
+pub async fn snippet_sync_download(
+    state: State<'_, Arc<AppState>>,
+    mut config: SnippetSyncConfig,
+    secrets_passphrase: Option<String>,
+) -> Result<SnippetDownloadResult, String> {
+    resolve_snippet_token(&state.storage, &mut config).await?;
+    let (snapshot, summary) = SnippetSyncClient::new(config).get_snapshot().await?;
+    let explicit_passphrase = secrets_passphrase.as_deref().map(str::trim).filter(|value| !value.is_empty());
+    let saved_passphrase = if explicit_passphrase.is_some() {
+        None
+    } else {
+        resolve_webdav_sync_secrets_passphrase(&state.storage).await?
+    };
+    let apply_summary = apply_sync_snapshot(
+        &state.storage,
+        &snapshot,
+        ApplySnapshotOptions { secrets_passphrase: explicit_passphrase.or(saved_passphrase.as_deref()) },
+    )
+    .await?;
+    Ok(SnippetDownloadResult {
+        summary,
+        editor_settings: snapshot.editor_settings,
+        desktop_settings: snapshot.desktop_settings,
+        apply_summary,
+    })
+}
diff --git a/src-tauri/src/commands/connection.rs b/src-tauri/src/commands/connection.rs
new file mode 100644
index 0000000..a0c6855
--- /dev/null
+++ b/src-tauri/src/commands/connection.rs
@@ -0,0 +1,1263 @@
+use std::collections::HashSet;
+use std::sync::Arc;
+use tauri::State;
+
+pub use dbx_core::agent_connection::{
+    agent_connect_params, mongo_legacy_error_with_auth_hint, mongo_uses_legacy_driver, oracle_alternate_connect_config,
+    oracle_error_with_driver_hint, should_retry_mongo_with_legacy_driver,
+};
+pub use dbx_core::connection::{
+    agent_connect_timeout, connect_bare_metadata_pool, connect_mysql_metadata_pool, connection_url_for_endpoint,
+    metadata_connection_config, prestosql_jdbc_config_for_endpoint, probe_connection_endpoint,
+    redacted_connection_url_for_endpoint, AppState, MysqlMode, PoolKind,
+};
+use dbx_core::database_capabilities;
+use dbx_core::db;
+use dbx_core::db::agent_driver::AgentMethod;
+use dbx_core::models::connection::{rewrite_jdbc_url_host, ConnectionConfig, DatabaseType};
+pub use dbx_core::path_utils::expand_tilde;
+
+const MONGO_LEGACY_DRIVER_PROFILE: &str = "mongodb-legacy";
+const MONGO_LEGACY_DRIVER_LABEL: &str = "MongoDB (Legacy)";
+
+fn mongo_legacy_connect_params(config: &ConnectionConfig, host: &str, port: u16) -> serde_json::Value {
+    serde_json::json!({
+        "connection": agent_connect_params(config, host, port, config.effective_database().unwrap_or(""))
+    })
+}
+
+fn mark_mongo_legacy_driver(config: &mut ConnectionConfig) -> bool {
+    if config.db_type != DatabaseType::MongoDb {
+        return false;
+    }
+    let changed = config.driver_profile.as_deref() != Some(MONGO_LEGACY_DRIVER_PROFILE)
+        || config.driver_label.as_deref() != Some(MONGO_LEGACY_DRIVER_LABEL);
+    config.driver_profile = Some(MONGO_LEGACY_DRIVER_PROFILE.to_string());
+    config.driver_label = Some(MONGO_LEGACY_DRIVER_LABEL.to_string());
+    changed
+}
+
+async fn persist_mongo_legacy_driver_profile(state: &AppState, config: &ConnectionConfig) -> Result<(), String> {
+    if config.one_time {
+        return Ok(());
+    }
+
+    let mut configs: Vec<ConnectionConfig> =
+        state.storage.load_connections().await?.into_iter().map(|config| config.canonicalized()).collect();
+    let Some(saved_config) = configs.iter_mut().find(|saved_config| saved_config.id == config.id) else {
+        return Ok(());
+    };
+    if !mark_mongo_legacy_driver(saved_config) {
+        return Ok(());
+    }
+    save_connection_configs(state, &configs).await
+}
+
+async fn test_agent_connection(
+    state: &Arc<AppState>,
+    config: &ConnectionConfig,
+    host: &str,
+    port: u16,
+) -> Result<String, String> {
+    let connect_params = agent_connect_params(config, host, port, config.database.as_deref().unwrap_or(""));
+    let result = state
+        .agent_manager
+        .call_daemon_method_with_timeout::<serde_json::Value>(
+            &config.db_type,
+            config.driver_profile.as_deref(),
+            AgentMethod::TestConnection,
+            connect_params,
+            Some(agent_connect_timeout(config)),
+        )
+        .await;
+
+    if let Err(err) = result {
+        if let Some(alternate_config) = oracle_alternate_connect_config(config, &err) {
+            state
+                .agent_manager
+                .call_daemon_method_with_timeout::<serde_json::Value>(
+                    &alternate_config.db_type,
+                    alternate_config.driver_profile.as_deref(),
+                    AgentMethod::TestConnection,
+                    agent_connect_params(
+                        &alternate_config,
+                        host,
+                        port,
+                        alternate_config.database.as_deref().unwrap_or(""),
+                    ),
+                    Some(agent_connect_timeout(&alternate_config)),
+                )
+                .await
+                .map_err(|alternate_err| {
+                    format!("{err}\n\nFallback with alternate Oracle descriptor failed: {alternate_err}")
+                })?;
+        } else {
+            return Err(oracle_error_with_driver_hint(config, &err));
+        }
+    }
+
+    Ok("Connection successful".to_string())
+}
+
+async fn connect_agent_pool(
+    state: &Arc<AppState>,
+    config: &ConnectionConfig,
+    host: &str,
+    port: u16,
+) -> Result<PoolKind, String> {
+    let connect_params = agent_connect_params(config, host, port, config.effective_database().unwrap_or(""));
+    let mut client = state.agent_manager.spawn(&config.db_type, config.driver_profile.as_deref()).await?;
+    let connect_result = client
+        .call_method_with_timeout::<serde_json::Value>(
+            AgentMethod::Connect,
+            connect_params,
+            Some(agent_connect_timeout(config)),
+        )
+        .await;
+
+    if let Err(err) = connect_result {
+        if let Some(alternate_config) = oracle_alternate_connect_config(config, &err) {
+            client
+                .call_method_with_timeout::<serde_json::Value>(
+                    AgentMethod::Connect,
+                    agent_connect_params(
+                        &alternate_config,
+                        host,
+                        port,
+                        alternate_config.effective_database().unwrap_or(""),
+                    ),
+                    Some(agent_connect_timeout(&alternate_config)),
+                )
+                .await
+                .map_err(|alternate_err| {
+                    format!("{err}\n\nFallback with alternate Oracle descriptor failed: {alternate_err}")
+                })?;
+        } else {
+            return Err(oracle_error_with_driver_hint(config, &err));
+        }
+    }
+
+    Ok(PoolKind::Agent(Arc::new(tokio::sync::Mutex::new(client))))
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "sqlite-sqlcipher")]
+    use super::connect_sqlite_from_config;
+    use super::{
+        mark_mongo_legacy_driver, mongo_legacy_connect_params, MONGO_LEGACY_DRIVER_LABEL, MONGO_LEGACY_DRIVER_PROFILE,
+    };
+    use dbx_core::models::connection::{ConnectionConfig, DatabaseType};
+    #[cfg(feature = "mq-admin")]
+    use {
+        super::{load_connection_configs, save_connection_configs},
+        dbx_core::connection::{AppState, PoolKind},
+        dbx_core::storage::Storage,
+    };
+
+    fn mongodb_config() -> ConnectionConfig {
+        ConnectionConfig {
+            id: "mongo".to_string(),
+            name: "MongoDB".to_string(),
+            db_type: DatabaseType::MongoDb,
+            driver_profile: Some("mongodb".to_string()),
+            driver_label: Some("MongoDB".to_string()),
+            url_params: Some("authSource=admin&authMechanism=SCRAM-SHA-1".to_string()),
+            agent_java_options: Vec::new(),
+            host: "172.22.4.42".to_string(),
+            port: 27017,
+            username: "mongouser".to_string(),
+            password: "secret".to_string(),
+            database: Some("RestCloud_V45PUB_Gateway".to_string()),
+            visible_databases: None,
+            visible_schemas: None,
+            attached_databases: Vec::new(),
+            color: None,
+            transport_layers: Vec::new(),
+            connect_timeout_secs: dbx_core::models::connection::default_connect_timeout_secs(),
+            query_timeout_secs: dbx_core::models::connection::default_query_timeout_secs(),
+            idle_timeout_secs: dbx_core::models::connection::default_idle_timeout_secs(),
+            keepalive_interval_secs: dbx_core::models::connection::default_keepalive_interval_secs(),
+            ssl: false,
+            ca_cert_path: String::new(),
+            client_cert_path: String::new(),
+            client_key_path: String::new(),
+            sysdba: false,
+            oracle_connection_type: None,
+            connection_string: Some(
+                "mongodb://mongouser:secret@172.22.4.42:27017/RestCloud_V45PUB_Gateway?authSource=admin".to_string(),
+            ),
+            redis_connection_mode: None,
+            redis_sentinel_master: String::new(),
+            redis_sentinel_nodes: String::new(),
+            redis_sentinel_username: String::new(),
+            redis_sentinel_password: String::new(),
+            redis_sentinel_tls: false,
+            redis_cluster_nodes: String::new(),
+            redis_key_separator: dbx_core::models::connection::default_redis_key_separator(),
+            redis_scan_page_size: None,
+            etcd_endpoints: String::new(),
+            gbase_server: String::new(),
+            informix_server: String::new(),
+            external_config: None,
+            jdbc_driver_class: None,
+            jdbc_driver_paths: Vec::new(),
+            one_time: false,
+            read_only: false,
+            is_production: false,
+            production_databases: vec![],
+        }
+    }
+
+    #[cfg(feature = "sqlite-sqlcipher")]
+    fn sqlite_config(path: &std::path::Path, password: &str) -> ConnectionConfig {
+        let mut config = mongodb_config();
+        config.id = "sqlite".to_string();
+        config.name = "SQLite".to_string();
+        config.db_type = DatabaseType::Sqlite;
+        config.driver_profile = None;
+        config.driver_label = None;
+        config.url_params = None;
+        config.host = path.to_string_lossy().to_string();
+        config.port = 0;
+        config.username = String::new();
+        config.password = password.to_string();
+        config.database = None;
+        config.connection_string = None;
+        config
+    }
+
+    #[cfg(feature = "mq-admin")]
+    fn mq_config(id: &str, admin_url: &str) -> ConnectionConfig {
+        let mut config = mongodb_config();
+        config.id = id.to_string();
+        config.name = "Pulsar".to_string();
+        config.db_type = DatabaseType::MessageQueue;
+        config.driver_profile = None;
+        config.driver_label = None;
+        config.url_params = None;
+        config.host = String::new();
+        config.port = 0;
+        config.username = String::new();
+        config.password = String::new();
+        config.database = None;
+        config.connection_string = None;
+        config.external_config = Some(serde_json::json!({
+            "systemKind": "pulsar",
+            "adminUrl": admin_url,
+            "auth": { "kind": "none" },
+            "pinnedVersion": "3.1"
+        }));
+        config
+    }
+
+    #[test]
+    fn mongo_legacy_connect_params_preserve_auth_options() {
+        let config = mongodb_config();
+
+        let params = mongo_legacy_connect_params(&config, "172.22.4.42", 27017);
+
+        assert_eq!(params["connection"]["database"], "RestCloud_V45PUB_Gateway");
+        assert_eq!(params["connection"]["url_params"], "authSource=admin&authMechanism=SCRAM-SHA-1");
+        assert_eq!(
+            params["connection"]["connection_string"],
+            "mongodb://mongouser:secret@172.22.4.42:27017/RestCloud_V45PUB_Gateway?authSource=admin"
+        );
+    }
+
+    #[test]
+    fn mark_mongo_legacy_driver_updates_profile_and_label() {
+        let mut config = mongodb_config();
+
+        assert!(mark_mongo_legacy_driver(&mut config));
+        assert_eq!(config.driver_profile.as_deref(), Some(MONGO_LEGACY_DRIVER_PROFILE));
+        assert_eq!(config.driver_label.as_deref(), Some(MONGO_LEGACY_DRIVER_LABEL));
+        assert!(!mark_mongo_legacy_driver(&mut config));
+    }
+
+    #[cfg(feature = "sqlite-sqlcipher")]
+    #[tokio::test]
+    async fn sqlite_connect_from_config_uses_sqlcipher_key() {
+        let path = std::env::temp_dir().join(format!("dbx-tauri-sqlcipher-{}.db", uuid::Uuid::new_v4()));
+        let key = "dbx-pass";
+
+        {
+            let pool =
+                dbx_core::db::sqlite::connect_path_create_if_missing_with_cipher_key(path.to_str().unwrap(), key)
+                    .await
+                    .expect("create encrypted sqlite");
+            pool.with_connection(|conn| {
+                conn.execute_batch(
+                    "CREATE TABLE users(id INTEGER PRIMARY KEY, name TEXT); INSERT INTO users(name) VALUES ('Ada'), ('Grace');",
+                )
+                .map_err(|err| err.to_string())
+            })
+            .expect("write encrypted sqlite");
+        }
+
+        let config = sqlite_config(&path, key);
+        let pool = connect_sqlite_from_config(&config).await.expect("open encrypted sqlite");
+        let count = pool
+            .with_connection(|conn| {
+                conn.query_row("SELECT count(*) FROM users", [], |row| row.get::<_, i64>(0))
+                    .map_err(|err| err.to_string())
+            })
+            .expect("read encrypted sqlite");
+        assert_eq!(count, 2);
+
+        let wrong_key = match connect_sqlite_from_config(&sqlite_config(&path, "wrong-key")).await {
+            Ok(_) => panic!("wrong SQLCipher key must fail"),
+            Err(err) => err,
+        };
+        assert!(wrong_key.contains("SQLCipher database unlock failed"));
+
+        let missing_key = match connect_sqlite_from_config(&sqlite_config(&path, "")).await {
+            Ok(_) => panic!("missing SQLCipher key must fail"),
+            Err(err) => err,
+        };
+        assert!(missing_key.contains("not a valid SQLite database"));
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[cfg(feature = "mq-admin")]
+    #[tokio::test]
+    async fn save_connection_configs_updates_runtime_cache_and_drops_mq_adapter() {
+        let dir = std::env::temp_dir().join(format!("dbx-tauri-conn-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new_with_plugin_dir(storage, dir.join("plugins"));
+        let initial = mq_config("mq-conn", "http://127.0.0.1:8080");
+        state.configs.write().await.insert(initial.id.clone(), initial.clone());
+        state.connections.write().await.insert(initial.id.clone(), PoolKind::MessageQueue);
+        let first = state.mq_registry.get_or_build(&initial).await.unwrap();
+
+        let updated = mq_config("mq-conn", "http://127.0.0.1:8081");
+        save_connection_configs(&state, &[updated.clone()]).await.unwrap();
+
+        let cached_admin_url = state
+            .configs
+            .read()
+            .await
+            .get("mq-conn")
+            .and_then(|config| config.external_config.as_ref())
+            .and_then(|external| external.get("adminUrl"))
+            .and_then(serde_json::Value::as_str)
+            .map(str::to_string);
+        assert_eq!(cached_admin_url.as_deref(), Some("http://127.0.0.1:8081"));
+
+        let second = state.mq_registry.get_or_build(&updated).await.unwrap();
+        assert!(!std::sync::Arc::ptr_eq(&first, &second));
+        assert!(!state.connections.read().await.contains_key(&initial.id));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(feature = "mq-admin")]
+    #[tokio::test]
+    async fn load_connection_configs_syncs_runtime_cache_and_drops_stale_pool() {
+        let dir = std::env::temp_dir().join(format!("dbx-tauri-conn-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new_with_plugin_dir(storage, dir.join("plugins"));
+        let initial = mq_config("mq-conn", "http://127.0.0.1:8080");
+        let updated = mq_config("mq-conn", "http://127.0.0.1:8081");
+        state.storage.save_connections(&[updated.clone()]).await.unwrap();
+        state.configs.write().await.insert(initial.id.clone(), initial.clone());
+        state.connections.write().await.insert(initial.id.clone(), PoolKind::MessageQueue);
+
+        let loaded = load_connection_configs(&state).await.unwrap();
+
+        assert_eq!(loaded.len(), 1);
+        let cached_admin_url = state
+            .configs
+            .read()
+            .await
+            .get("mq-conn")
+            .and_then(|config| config.external_config.as_ref())
+            .and_then(|external| external.get("adminUrl"))
+            .and_then(serde_json::Value::as_str)
+            .map(str::to_string);
+        assert_eq!(cached_admin_url.as_deref(), Some("http://127.0.0.1:8081"));
+        assert!(!state.connections.read().await.contains_key(&initial.id));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(feature = "mq-admin")]
+    #[tokio::test]
+    async fn save_connection_configs_removes_deleted_runtime_config_and_mq_adapter() {
+        let dir = std::env::temp_dir().join(format!("dbx-tauri-conn-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new_with_plugin_dir(storage, dir.join("plugins"));
+        let kept = mongodb_config();
+        let removed = mq_config("removed-mq", "http://127.0.0.1:8080");
+        {
+            let mut configs = state.configs.write().await;
+            configs.insert(kept.id.clone(), kept.clone());
+            configs.insert(removed.id.clone(), removed.clone());
+        }
+        let stale = state.mq_registry.get_or_build(&removed).await.unwrap();
+
+        save_connection_configs(&state, &[kept.clone()]).await.unwrap();
+
+        let configs = state.configs.read().await;
+        assert!(configs.contains_key(&kept.id));
+        assert!(!configs.contains_key("removed-mq"));
+        drop(configs);
+
+        let rebuilt = state.mq_registry.get_or_build(&removed).await.unwrap();
+        assert!(!std::sync::Arc::ptr_eq(&stale, &rebuilt));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
+    #[cfg(feature = "mq-admin")]
+    #[tokio::test]
+    async fn save_connection_configs_removes_deleted_connection_pools() {
+        let dir = std::env::temp_dir().join(format!("dbx-tauri-conn-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let storage = Storage::open(&dir.join("storage.db")).await.unwrap();
+        let state = AppState::new_with_plugin_dir(storage, dir.join("plugins"));
+        let kept = mongodb_config();
+        let removed = mq_config("removed-mq", "http://127.0.0.1:8080");
+        {
+            let mut configs = state.configs.write().await;
+            configs.insert(kept.id.clone(), kept.clone());
+            configs.insert(removed.id.clone(), removed.clone());
+        }
+        state.connections.write().await.insert(removed.id.clone(), PoolKind::MessageQueue);
+
+        save_connection_configs(&state, &[kept.clone()]).await.unwrap();
+
+        assert!(!state.connections.read().await.contains_key(&removed.id));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+}
+
+#[tauri::command]
+pub async fn save_connections(state: State<'_, Arc<AppState>>, configs: Vec<ConnectionConfig>) -> Result<(), String> {
+    let configs: Vec<ConnectionConfig> = configs.into_iter().map(|config| config.canonicalized()).collect();
+    save_connection_configs(state.inner(), &configs).await
+}
+
+async fn save_connection_configs(state: &AppState, configs: &[ConnectionConfig]) -> Result<(), String> {
+    state.storage.save_connections(configs).await?;
+    let sync = sync_connection_configs(state, configs).await;
+    remove_connection_pools_for_connection_ids(state, &sync.connection_pool_ids_to_drop).await;
+    drop_nacos_adapters_for_connection_ids(state, &sync.nacos_adapter_ids_to_drop).await;
+    drop_mq_adapters_for_connection_ids(state, &sync.mq_adapter_ids_to_drop).await;
+    Ok(())
+}
+
+struct ConnectionConfigSync {
+    nacos_adapter_ids_to_drop: Vec<String>,
+    mq_adapter_ids_to_drop: Vec<String>,
+    connection_pool_ids_to_drop: Vec<String>,
+}
+
+async fn sync_connection_configs(state: &AppState, configs: &[ConnectionConfig]) -> ConnectionConfigSync {
+    let saved_ids: HashSet<&str> = configs.iter().map(|config| config.id.as_str()).collect();
+    let mut nacos_adapter_ids_to_drop = HashSet::new();
+    let mut mq_adapter_ids_to_drop = HashSet::new();
+    let mut connection_pool_ids_to_drop = HashSet::new();
+    let mut runtime_configs = state.configs.write().await;
+    runtime_configs.retain(|id, existing| {
+        if saved_ids.contains(id.as_str()) || is_transient_runtime_config_id(id) {
+            true
+        } else {
+            connection_pool_ids_to_drop.insert(id.clone());
+            if existing.db_type == DatabaseType::Nacos {
+                nacos_adapter_ids_to_drop.insert(id.clone());
+            }
+            if existing.db_type == DatabaseType::MessageQueue {
+                mq_adapter_ids_to_drop.insert(id.clone());
+            }
+            false
+        }
+    });
+    for config in configs {
+        if config.db_type == DatabaseType::Nacos {
+            nacos_adapter_ids_to_drop.insert(config.id.clone());
+        }
+        if config.db_type == DatabaseType::MessageQueue {
+            mq_adapter_ids_to_drop.insert(config.id.clone());
+        }
+        if let Some(previous) = runtime_configs.insert(config.id.clone(), config.clone()) {
+            if previous.db_type == DatabaseType::Nacos {
+                nacos_adapter_ids_to_drop.insert(config.id.clone());
+            }
+            if previous.db_type == DatabaseType::MessageQueue {
+                mq_adapter_ids_to_drop.insert(config.id.clone());
+            }
+            if &previous != config {
+                connection_pool_ids_to_drop.insert(config.id.clone());
+            }
+        }
+    }
+    ConnectionConfigSync {
+        nacos_adapter_ids_to_drop: nacos_adapter_ids_to_drop.into_iter().collect(),
+        mq_adapter_ids_to_drop: mq_adapter_ids_to_drop.into_iter().collect(),
+        connection_pool_ids_to_drop: connection_pool_ids_to_drop.into_iter().collect(),
+    }
+}
+
+fn is_transient_runtime_config_id(id: &str) -> bool {
+    id.starts_with("__test_") || id.starts_with("__visible_draft_") || id.starts_with("__visible_schema_draft_")
+}
+
+async fn drop_nacos_adapters_for_connection_ids(state: &AppState, connection_ids: &[String]) {
+    for connection_id in connection_ids {
+        state.nacos_registry.drop_connection(connection_id).await;
+    }
+}
+
+#[cfg(feature = "mq-admin")]
+async fn drop_mq_adapters_for_connection_ids(state: &AppState, connection_ids: &[String]) {
+    for connection_id in connection_ids {
+        state.mq_registry.drop_connection(connection_id).await;
+    }
+}
+
+#[cfg(not(feature = "mq-admin"))]
+async fn drop_mq_adapters_for_connection_ids(_state: &AppState, _connection_ids: &[String]) {}
+
+async fn remove_connection_pools_for_connection_ids(state: &AppState, connection_ids: &[String]) {
+    for connection_id in connection_ids {
+        state.remove_connection_pools_detached(connection_id).await;
+    }
+}
+
+#[tauri::command]
+pub async fn load_connections(state: State<'_, Arc<AppState>>) -> Result<Vec<ConnectionConfig>, String> {
+    load_connection_configs(state.inner()).await
+}
+
+async fn load_connection_configs(state: &AppState) -> Result<Vec<ConnectionConfig>, String> {
+    let configs: Vec<ConnectionConfig> =
+        state.storage.load_connections().await?.into_iter().map(|config| config.canonicalized()).collect();
+    let sync = sync_connection_configs(state, &configs).await;
+    remove_connection_pools_for_connection_ids(state, &sync.connection_pool_ids_to_drop).await;
+    drop_nacos_adapters_for_connection_ids(state, &sync.nacos_adapter_ids_to_drop).await;
+    drop_mq_adapters_for_connection_ids(state, &sync.mq_adapter_ids_to_drop).await;
+    Ok(configs)
+}
+
+#[tauri::command]
+pub async fn save_sidebar_layout(state: State<'_, Arc<AppState>>, layout: serde_json::Value) -> Result<(), String> {
+    state.storage.save_sidebar_layout(&layout).await
+}
+
+#[tauri::command]
+pub async fn load_sidebar_layout(state: State<'_, Arc<AppState>>) -> Result<Option<serde_json::Value>, String> {
+    state.storage.load_sidebar_layout().await
+}
+
+fn sqlite_extension_specs_from_config(config: &ConnectionConfig) -> Vec<db::sqlite::SqliteExtensionSpec> {
+    db::sqlite::sqlite_extension_specs_from_url_params(config.url_params.as_deref())
+        .into_iter()
+        .map(|mut extension| {
+            extension.path = expand_tilde(&extension.path);
+            extension
+        })
+        .collect()
+}
+
+async fn connect_sqlite_from_config(config: &ConnectionConfig) -> Result<db::sqlite::SqliteHandle, String> {
+    db::sqlite::connect_path_with_cipher_key_and_extensions(
+        &expand_tilde(&config.host),
+        &config.password,
+        sqlite_extension_specs_from_config(config),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn test_connection(state: State<'_, Arc<AppState>>, config: ConnectionConfig) -> Result<String, String> {
+    let tunnel_id = format!("{}:test", config.id);
+    let has_transport_layers = config.has_effective_transport_layers();
+    let connection_id = if has_transport_layers { tunnel_id.as_str() } else { config.id.as_str() };
+    let (host, port) = state.connection_host_port(connection_id, &config).await?;
+    let probe_result = probe_connection_endpoint(&config, &host, port).await;
+    let url = connection_url_for_endpoint(&config, &host, port);
+    let target = redacted_connection_url_for_endpoint(&config, &host, port);
+    let connect_timeout = std::time::Duration::from_secs(config.effective_connect_timeout_secs());
+    let idle_timeout = std::time::Duration::from_secs(config.idle_timeout_secs);
+    log::info!("[test_connection] db_type={:?} target={}", config.db_type, target);
+    let result = match probe_result {
+        Err(e) => Err(e),
+        Ok(()) => match config.db_type {
+            DatabaseType::Mysql if config.needs_bare_mysql() && !config.bare_mysql_uses_tls() => {
+                match db::mysql::connect_bare(&url, connect_timeout).await {
+                    Ok(pool) => {
+                        let _ = pool.disconnect().await;
+                        Ok("Connection successful".to_string())
+                    }
+                    Err(e) => Err(e),
+                }
+            }
+            DatabaseType::Mysql if config.needs_bare_mysql() && config.bare_mysql_uses_tls() => {
+                match db::mysql::connect_compatible_with_ca_cert_pool_limit_idle_and_setup(
+                    &url,
+                    Some(&config.ca_cert_path),
+                    connect_timeout,
+                    10,
+                    None,
+                    &[],
+                )
+                .await
+                {
+                    Ok(pool) => {
+                        let _ = pool.disconnect().await;
+                        Ok("Connection successful".to_string())
+                    }
+                    Err(e) => Err(e),
+                }
+            }
+            DatabaseType::Mysql => {
+                match db::mysql::connect_with_ca_cert(&url, Some(&config.ca_cert_path), connect_timeout).await {
+                    Ok(pool) => {
+                        let _ = pool.disconnect().await;
+                        Ok("Connection successful".to_string())
+                    }
+                    Err(e) => Err(e),
+                }
+            }
+            DatabaseType::Doris | DatabaseType::ManticoreSearch => {
+                match db::mysql::connect_bare(&url, connect_timeout).await {
+                    Ok(pool) => {
+                        let _ = pool.disconnect().await;
+                        Ok("Connection successful".to_string())
+                    }
+                    Err(e) => Err(e),
+                }
+            }
+            DatabaseType::StarRocks => {
+                let connect = if config.bare_mysql_uses_tls() {
+                    db::mysql::connect_compatible_with_ca_cert_pool_limit_idle_and_setup(
+                        &url,
+                        Some(&config.ca_cert_path),
+                        connect_timeout,
+                        10,
+                        None,
+                        &[],
+                    )
+                    .await
+                } else {
+                    db::mysql::connect_bare(&url, connect_timeout).await
+                };
+                match connect {
+                    Ok(pool) => {
+                        let _ = pool.disconnect().await;
+                        Ok("Connection successful".to_string())
+                    }
+                    Err(e) => Err(e),
+                }
+            }
+            DatabaseType::Postgres
+            | DatabaseType::Redshift
+            | DatabaseType::Gaussdb
+            | DatabaseType::Kwdb
+            | DatabaseType::Questdb
+            | DatabaseType::OpenGauss => match db::postgres::connect(&url, connect_timeout).await {
+                Ok(pool) => {
+                    pool.close();
+                    Ok("Connection successful".to_string())
+                }
+                Err(e) => Err(e),
+            },
+            DatabaseType::Sqlite => match connect_sqlite_from_config(&config).await {
+                Ok(_) => Ok("Connection successful".to_string()),
+                Err(e) => Err(e),
+            },
+            DatabaseType::Redis => {
+                let con = if config.uses_redis_cluster() {
+                    state.connect_redis_cluster(&tunnel_id, &config).await?;
+                    return Ok("Connection successful".to_string());
+                } else if config.uses_redis_sentinel() {
+                    state.connect_redis_sentinel(&tunnel_id, &config).await?;
+                    return Ok("Connection successful".to_string());
+                } else {
+                    db::redis_driver::connect(&url, connect_timeout).await?
+                };
+                drop(con);
+                Ok("Connection successful".to_string())
+            }
+            #[cfg(feature = "duckdb-bundled")]
+            DatabaseType::DuckDb => {
+                if state.duckdb_existing_pool_is_usable_for_config(&config).await? {
+                    Ok("Connection successful".to_string())
+                } else {
+                    let con = db::duckdb_driver::connect_path(&expand_tilde(&config.host))?;
+                    dbx_core::db::duckdb_driver::close_connection(con);
+                    Ok("Connection successful".to_string())
+                }
+            }
+            #[cfg(not(feature = "duckdb-bundled"))]
+            DatabaseType::DuckDb => Err("DuckDB support not compiled (enable duckdb-bundled feature)".to_string()),
+            DatabaseType::MongoDb => {
+                if mongo_uses_legacy_driver(&config) {
+                    let am = &state.agent_manager;
+                    let mut client = am.spawn(&config.db_type, config.driver_profile.as_deref()).await?;
+                    client
+                        .connect(mongo_legacy_connect_params(&config, &host, port))
+                        .await
+                        .map_err(|err| mongo_legacy_error_with_auth_hint(&err))?;
+                    client.disconnect().await.ok();
+                    return Ok("Connection successful (via legacy driver)".to_string());
+                }
+
+                let native_err = match db::mongo_driver::connect(&url, connect_timeout, idle_timeout).await {
+                    Ok(client) => {
+                        match db::mongo_driver::test_connection(&client, connect_timeout, config.effective_database())
+                            .await
+                        {
+                            Ok(()) => return Ok("Connection successful".to_string()),
+                            Err(e) => e,
+                        }
+                    }
+                    Err(e) => e,
+                };
+                if should_retry_mongo_with_legacy_driver(&native_err) {
+                    let am = &state.agent_manager;
+                    let mut client = am.spawn(&config.db_type, Some("mongodb-legacy")).await?;
+                    client.connect(mongo_legacy_connect_params(&config, &host, port)).await.map_err(|err| {
+                        format!(
+                            "{native_err}\n\nFallback with MongoDB (Legacy) driver failed: {}",
+                            mongo_legacy_error_with_auth_hint(&err)
+                        )
+                    })?;
+                    client.disconnect().await.ok();
+                    Ok("Connection successful (via legacy driver)".to_string())
+                } else {
+                    Err(native_err)
+                }
+            }
+            DatabaseType::ClickHouse => {
+                let username = if config.username.is_empty() { None } else { Some(config.username.clone()) };
+                let password = if config.password.is_empty() { None } else { Some(config.password.clone()) };
+                let client = db::clickhouse_driver::ChClient::new_with_ca_cert(
+                    &url,
+                    username,
+                    password,
+                    Some(&config.ca_cert_path),
+                    connect_timeout,
+                )?;
+                db::clickhouse_driver::test_connection(&client, connect_timeout)
+                    .await
+                    .map(|_| "Connection successful".to_string())
+            }
+            DatabaseType::SqlServer => {
+                state.test_sqlserver_connection_with_legacy_fallback(&config, &host, port, connect_timeout).await
+            }
+            DatabaseType::Elasticsearch => {
+                let mut client = db::elasticsearch_driver::EsClient::from_config(
+                    &url,
+                    Some(&config.username),
+                    Some(&config.password),
+                    config.ssl,
+                    config.url_params.as_deref(),
+                    connect_timeout,
+                );
+                db::elasticsearch_driver::test_connection(&mut client, connect_timeout)
+                    .await
+                    .map(|_| "Connection successful".to_string())
+            }
+            DatabaseType::Qdrant | DatabaseType::Milvus | DatabaseType::Weaviate | DatabaseType::ChromaDb => {
+                let kind = match config.db_type {
+                    DatabaseType::Qdrant => db::vector_driver::VectorDbKind::Qdrant,
+                    DatabaseType::Milvus => db::vector_driver::VectorDbKind::Milvus,
+                    DatabaseType::Weaviate => db::vector_driver::VectorDbKind::Weaviate,
+                    DatabaseType::ChromaDb => db::vector_driver::VectorDbKind::ChromaDb,
+                    _ => unreachable!(),
+                };
+                let client = db::vector_driver::VectorClient::new(
+                    kind,
+                    &url,
+                    Some(&config.username),
+                    Some(&config.password),
+                    config.ssl,
+                    connect_timeout,
+                );
+                db::vector_driver::test_connection(&client, connect_timeout)
+                    .await
+                    .map(|_| "Connection successful".to_string())
+            }
+            DatabaseType::Rqlite => {
+                let client = db::rqlite_driver::RqliteClient::new(
+                    &url,
+                    config.url_params.as_deref(),
+                    &config.username,
+                    &config.password,
+                    config.ssl,
+                    connect_timeout,
+                )?;
+                db::rqlite_driver::test_connection(&client, connect_timeout)
+                    .await
+                    .map(|_| "Connection successful".to_string())
+            }
+            DatabaseType::Turso => {
+                let auth_token = if !config.password.is_empty() {
+                    config.password.clone()
+                } else {
+                    config
+                        .url_params
+                        .as_deref()
+                        .and_then(|p| {
+                            p.trim()
+                                .trim_start_matches('?')
+                                .split('&')
+                                .filter_map(|pair| pair.split_once('='))
+                                .find(|(key, _)| {
+                                    let k = key.trim().to_ascii_lowercase();
+                                    k == "auth_token" || k == "authtoken" || k == "auth-token"
+                                })
+                                .map(|(_, value)| value.trim().to_string())
+                        })
+                        .unwrap_or_default()
+                };
+                let client = db::turso_driver::TursoClient::new(&url, &auth_token, config.ssl, connect_timeout)?;
+                db::turso_driver::test_connection(&client, connect_timeout)
+                    .await
+                    .map(|_| "Connection successful".to_string())
+            }
+            DatabaseType::CloudflareD1 => db::cloudflare_d1_driver::connect(&config, connect_timeout)
+                .await
+                .map(|_| "Connection successful".to_string()),
+            DatabaseType::InfluxDb => {
+                let client = db::influxdb_driver::InfluxdbClient::new_for_config(&url, &config, connect_timeout)?;
+                db::influxdb_driver::test_connection(&client, connect_timeout)
+                    .await
+                    .map(|_| "Connection successful".to_string())
+            }
+            DatabaseType::Nacos => {
+                let admin_config = state.nacos_admin_config_for_connection(connection_id, &config).await?;
+                let adapter = state.nacos_registry.build_transient_config(admin_config).await?;
+                adapter.test_connection().await?;
+                Ok("Connection successful".to_string())
+            }
+            #[cfg(feature = "mq-admin")]
+            DatabaseType::MessageQueue => {
+                let mqc = state.mq_admin_config_for_connection(connection_id, &config).await?;
+                let kafka_launch = dbx_core::mq::service::resolve_kafka_launch_spec(&mqc, &state);
+                let adapter = match state.mq_registry.get_or_build_config(connection_id, mqc, kafka_launch).await {
+                    Ok(adapter) => adapter,
+                    Err(err) => {
+                        state.mq_registry.drop_connection(connection_id).await;
+                        return Err(err);
+                    }
+                };
+                if let Err(err) = adapter.test_connection().await {
+                    state.mq_registry.drop_connection(connection_id).await;
+                    return Err(err);
+                }
+                Ok("Connection successful".to_string())
+            }
+            #[cfg(not(feature = "mq-admin"))]
+            DatabaseType::MessageQueue => {
+                Err("Message queue admin support is not compiled in this build. Rebuild with the 'mq-admin' feature."
+                    .to_string())
+            }
+            db_type if database_capabilities::is_agent_type(&db_type) => {
+                test_agent_connection(state.inner(), &config, &host, port).await
+            }
+            DatabaseType::PrestoSql => {
+                let jdbc_config = prestosql_jdbc_config_for_endpoint(&config, &host, port);
+                state.test_external_driver("jdbc", &jdbc_config).await
+            }
+            DatabaseType::Jdbc => {
+                let mut jdbc_config = config.clone();
+                if host != config.host || port != config.port {
+                    if let Some(ref url) = jdbc_config.connection_string {
+                        jdbc_config.connection_string = Some(rewrite_jdbc_url_host(url, &host, port));
+                    }
+                }
+                state.test_external_driver("jdbc", &jdbc_config).await
+            }
+            db_type => Err(format!("Unsupported database type: {db_type:?}")),
+        },
+    };
+
+    if has_transport_layers {
+        state.reset_connection_transport_for_config(&tunnel_id, &config).await;
+    }
+
+    result
+}
+
+#[tauri::command]
+pub async fn connect_db(
+    state: State<'_, Arc<AppState>>,
+    config: ConnectionConfig,
+    client_attempt: Option<u64>,
+) -> Result<String, String> {
+    let config = config.canonicalized();
+    let id = config.id.clone();
+    let db_config = metadata_connection_config(&config);
+    let attempt = state.begin_connection_attempt_with_client_attempt(&id, client_attempt).await;
+    let mut connected_config = config.clone();
+    let mut connected_db_config = db_config.clone();
+
+    state.remove_connection_pools_detached(&id).await;
+    state.reset_connection_transport_for_config(&id, &db_config).await;
+
+    let (host, port) = state.connection_host_port(&id, &db_config).await?;
+    if let Err(err) = state.ensure_current_connection_attempt(&id, Some(attempt)).await {
+        state.reset_connection_transport_for_config(&id, &db_config).await;
+        return Err(err);
+    }
+    probe_connection_endpoint(&db_config, &host, port).await?;
+    if let Err(err) = state.ensure_current_connection_attempt(&id, Some(attempt)).await {
+        state.reset_connection_transport_for_config(&id, &db_config).await;
+        return Err(err);
+    }
+    let url = connection_url_for_endpoint(&db_config, &host, port);
+    let connect_timeout = std::time::Duration::from_secs(db_config.effective_connect_timeout_secs());
+    let idle_timeout = std::time::Duration::from_secs(db_config.idle_timeout_secs);
+
+    let pool = match db_config.db_type {
+        DatabaseType::Mysql => {
+            let (pool, mode) =
+                connect_mysql_metadata_pool(&config, &db_config, &host, port, connect_timeout, 3).await?;
+            PoolKind::Mysql(pool, mode)
+        }
+        DatabaseType::Doris | DatabaseType::StarRocks | DatabaseType::ManticoreSearch => PoolKind::Mysql(
+            connect_bare_metadata_pool(&db_config, &host, port, connect_timeout, 3).await?,
+            MysqlMode::Bare,
+        ),
+        DatabaseType::Postgres
+        | DatabaseType::Redshift
+        | DatabaseType::Gaussdb
+        | DatabaseType::Kwdb
+        | DatabaseType::Questdb
+        | DatabaseType::OpenGauss => PoolKind::Postgres(db::postgres::connect(&url, connect_timeout).await?),
+        DatabaseType::Sqlite => PoolKind::Sqlite(connect_sqlite_from_config(&db_config).await?),
+        DatabaseType::Redis => {
+            let con = if db_config.uses_redis_cluster() {
+                PoolKind::Redis(db::redis_driver::RedisConnection::Cluster(
+                    state.connect_redis_cluster(&id, &db_config).await?,
+                ))
+            } else if db_config.uses_redis_sentinel() {
+                PoolKind::Redis(db::redis_driver::RedisConnection::Direct(tokio::sync::Mutex::new(
+                    state.connect_redis_sentinel(&id, &db_config).await?,
+                )))
+            } else {
+                PoolKind::Redis(db::redis_driver::RedisConnection::Direct(tokio::sync::Mutex::new(
+                    db::redis_driver::connect(&url, connect_timeout).await?,
+                )))
+            };
+            con
+        }
+        #[cfg(feature = "duckdb-bundled")]
+        DatabaseType::DuckDb => {
+            let con = db::duckdb_driver::connect_path(&expand_tilde(&db_config.host))?;
+            {
+                let locked = con.lock().map_err(|e| e.to_string())?;
+                for attached in &db_config.attached_databases {
+                    dbx_core::schema::duckdb_attach_database(&locked, &attached.name, &expand_tilde(&attached.path))?;
+                }
+            }
+            PoolKind::DuckDb(con)
+        }
+        #[cfg(not(feature = "duckdb-bundled"))]
+        DatabaseType::DuckDb => return Err("DuckDB support not compiled (enable duckdb-bundled feature)".to_string()),
+        DatabaseType::MongoDb => {
+            if mongo_uses_legacy_driver(&db_config) {
+                let mut client =
+                    state.agent_manager.spawn(&db_config.db_type, Some(MONGO_LEGACY_DRIVER_PROFILE)).await?;
+                state.ensure_current_connection_attempt(&id, Some(attempt)).await?;
+                client
+                    .connect(mongo_legacy_connect_params(&db_config, &host, port))
+                    .await
+                    .map_err(|err| mongo_legacy_error_with_auth_hint(&err))?;
+                state.ensure_current_connection_attempt(&id, Some(attempt)).await?;
+                PoolKind::Agent(std::sync::Arc::new(tokio::sync::Mutex::new(client)))
+            } else {
+                let native_err = match db::mongo_driver::connect(&url, connect_timeout, idle_timeout).await {
+                    Ok(client) => {
+                        state.ensure_current_connection_attempt(&id, Some(attempt)).await?;
+                        match db::mongo_driver::test_connection(
+                            &client,
+                            connect_timeout,
+                            db_config.effective_database(),
+                        )
+                        .await
+                        {
+                            Ok(()) => {
+                                state.ensure_current_connection_attempt(&id, Some(attempt)).await?;
+                                if let Err(err) = state
+                                    .insert_connection_pool_for_attempt(
+                                        &id,
+                                        attempt,
+                                        id.clone(),
+                                        PoolKind::MongoDb(client),
+                                        &db_config,
+                                    )
+                                    .await
+                                {
+                                    state.reset_connection_transport_for_config(&id, &db_config).await;
+                                    return Err(err);
+                                }
+                                state.configs.write().await.insert(id.clone(), config);
+                                return Ok(id);
+                            }
+                            Err(e) => e,
+                        }
+                    }
+                    Err(e) => e,
+                };
+                if should_retry_mongo_with_legacy_driver(&native_err) {
+                    log::info!("Native MongoDB driver failed ({native_err}), falling back to agent driver");
+                    let mut client =
+                        state.agent_manager.spawn(&db_config.db_type, Some(MONGO_LEGACY_DRIVER_PROFILE)).await?;
+                    state.ensure_current_connection_attempt(&id, Some(attempt)).await?;
+                    client.connect(mongo_legacy_connect_params(&db_config, &host, port)).await.map_err(|err| {
+                        format!(
+                            "{native_err}\n\nFallback with MongoDB (Legacy) driver failed: {}",
+                            mongo_legacy_error_with_auth_hint(&err)
+                        )
+                    })?;
+                    state.ensure_current_connection_attempt(&id, Some(attempt)).await?;
+                    mark_mongo_legacy_driver(&mut connected_config);
+                    connected_db_config = metadata_connection_config(&connected_config);
+                    persist_mongo_legacy_driver_profile(state.inner(), &connected_config).await?;
+                    PoolKind::Agent(std::sync::Arc::new(tokio::sync::Mutex::new(client)))
+                } else {
+                    return Err(native_err);
+                }
+            }
+        }
+        DatabaseType::ClickHouse => {
+            let username = if db_config.username.is_empty() { None } else { Some(db_config.username.clone()) };
+            let password = if db_config.password.is_empty() { None } else { Some(db_config.password.clone()) };
+            log::info!("[connect_db] ClickHouse url={url} user={:?} has_pass={}", username, password.is_some());
+            let client = db::clickhouse_driver::ChClient::new_with_ca_cert(
+                &url,
+                username,
+                password,
+                Some(&db_config.ca_cert_path),
+                connect_timeout,
+            )?;
+            db::clickhouse_driver::test_connection(&client, connect_timeout).await?;
+            PoolKind::ClickHouse(client)
+        }
+        DatabaseType::SqlServer => {
+            state.connect_sqlserver_pool_with_legacy_fallback(&db_config, &host, port, connect_timeout).await?
+        }
+        DatabaseType::Elasticsearch => {
+            let mut client = db::elasticsearch_driver::EsClient::from_config(
+                &url,
+                Some(&db_config.username),
+                Some(&db_config.password),
+                db_config.ssl,
+                db_config.url_params.as_deref(),
+                connect_timeout,
+            );
+            db::elasticsearch_driver::test_connection(&mut client, connect_timeout).await?;
+            PoolKind::Elasticsearch(client)
+        }
+        DatabaseType::Qdrant | DatabaseType::Milvus | DatabaseType::Weaviate | DatabaseType::ChromaDb => {
+            let kind = match db_config.db_type {
+                DatabaseType::Qdrant => db::vector_driver::VectorDbKind::Qdrant,
+                DatabaseType::Milvus => db::vector_driver::VectorDbKind::Milvus,
+                DatabaseType::Weaviate => db::vector_driver::VectorDbKind::Weaviate,
+                DatabaseType::ChromaDb => db::vector_driver::VectorDbKind::ChromaDb,
+                _ => unreachable!(),
+            };
+            let client = db::vector_driver::VectorClient::new(
+                kind,
+                &url,
+                Some(&db_config.username),
+                Some(&db_config.password),
+                db_config.ssl,
+                connect_timeout,
+            );
+            db::vector_driver::test_connection(&client, connect_timeout).await?;
+            PoolKind::VectorDb(client)
+        }
+        DatabaseType::Rqlite => {
+            let client = db::rqlite_driver::RqliteClient::new(
+                &url,
+                db_config.url_params.as_deref(),
+                &db_config.username,
+                &db_config.password,
+                db_config.ssl,
+                connect_timeout,
+            )?;
+            db::rqlite_driver::test_connection(&client, connect_timeout).await?;
+            PoolKind::Rqlite(client)
+        }
+        DatabaseType::Turso => {
+            let auth_token = if !db_config.password.is_empty() {
+                db_config.password.clone()
+            } else {
+                db_config
+                    .url_params
+                    .as_deref()
+                    .and_then(|p| {
+                        p.trim()
+                            .trim_start_matches('?')
+                            .split('&')
+                            .filter_map(|pair| pair.split_once('='))
+                            .find(|(key, _)| {
+                                let k = key.trim().to_ascii_lowercase();
+                                k == "auth_token" || k == "authtoken" || k == "auth-token"
+                            })
+                            .map(|(_, value)| value.trim().to_string())
+                    })
+                    .unwrap_or_default()
+            };
+            let client = db::turso_driver::TursoClient::new(&url, &auth_token, db_config.ssl, connect_timeout)?;
+            db::turso_driver::test_connection(&client, connect_timeout).await?;
+            PoolKind::Turso(client)
+        }
+        DatabaseType::CloudflareD1 => {
+            PoolKind::CloudflareD1(db::cloudflare_d1_driver::connect(&db_config, connect_timeout).await?)
+        }
+        DatabaseType::InfluxDb => {
+            let client = db::influxdb_driver::InfluxdbClient::new_for_config(&url, &db_config, connect_timeout)?;
+            db::influxdb_driver::test_connection(&client, connect_timeout).await?;
+            PoolKind::InfluxDb(client)
+        }
+        DatabaseType::Nacos => {
+            let admin_config = state.nacos_admin_config_for_connection(&id, &config).await?;
+            let adapter = state.nacos_registry.build_transient_config(admin_config).await?;
+            adapter.test_connection().await?;
+            PoolKind::Nacos
+        }
+        #[cfg(feature = "mq-admin")]
+        DatabaseType::MessageQueue => {
+            let mqc = state.mq_admin_config_for_connection(&id, &config).await?;
+            let kafka_launch = dbx_core::mq::service::resolve_kafka_launch_spec(&mqc, &state);
+            let adapter = match state.mq_registry.get_or_build_config(&id, mqc, kafka_launch).await {
+                Ok(adapter) => adapter,
+                Err(err) => {
+                    state.mq_registry.drop_connection(&id).await;
+                    return Err(err);
+                }
+            };
+            if let Err(err) = state.ensure_current_connection_attempt(&id, Some(attempt)).await {
+                state.mq_registry.drop_connection(&id).await;
+                return Err(err);
+            }
+            if let Err(err) = adapter.test_connection().await {
+                state.mq_registry.drop_connection(&id).await;
+                return Err(err);
+            }
+            if let Err(err) = state.ensure_current_connection_attempt(&id, Some(attempt)).await {
+                state.mq_registry.drop_connection(&id).await;
+                return Err(err);
+            }
+            PoolKind::MessageQueue
+        }
+        #[cfg(not(feature = "mq-admin"))]
+        DatabaseType::MessageQueue => {
+            return Err(
+                "Message queue admin support is not compiled in this build. Rebuild with the 'mq-admin' feature."
+                    .to_string(),
+            );
+        }
+        db_type if database_capabilities::is_agent_type(&db_type) => {
+            connect_agent_pool(state.inner(), &db_config, &host, port).await?
+        }
+        DatabaseType::PrestoSql => {
+            let jdbc_config = prestosql_jdbc_config_for_endpoint(&db_config, &host, port);
+            state.external_driver_pool("jdbc", &jdbc_config).await?
+        }
+        DatabaseType::Jdbc => state.external_driver_pool("jdbc", &db_config).await?,
+        db_type => return Err(format!("Unsupported database type: {db_type:?}")),
+    };
+
+    if let Err(err) =
+        state.insert_connection_pool_for_attempt(&id, attempt, id.clone(), pool, &connected_db_config).await
+    {
+        state.reset_connection_transport_for_config(&id, &connected_db_config).await;
+        return Err(err);
+    }
+    state.configs.write().await.insert(id.clone(), connected_config);
+
+    Ok(id)
+}
+
+#[tauri::command]
+pub async fn connection_final_proxy_port(
+    state: State<'_, Arc<AppState>>,
+    config: ConnectionConfig,
+) -> Result<u16, String> {
+    let runtime_config = config.canonicalized();
+    if !runtime_config.has_effective_transport_layers() {
+        return Err("Connection has no configured transport layers".to_string());
+    }
+
+    let connection_id = runtime_config.id.clone();
+    let db_config = metadata_connection_config(&runtime_config);
+    state.configs.write().await.insert(connection_id.clone(), runtime_config);
+
+    let (_, port) = state.connection_host_port(&connection_id, &db_config).await?;
+    Ok(port)
+}
+
+#[tauri::command]
+pub async fn disconnect_db(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    client_attempt: Option<u64>,
+) -> Result<(), String> {
+    let should_disconnect = if let Some(client_attempt) = client_attempt {
+        state.supersede_connection_attempt_if_client_attempt(&connection_id, client_attempt).await
+    } else {
+        state.supersede_connection_attempt(&connection_id).await;
+        true
+    };
+    if !should_disconnect {
+        return Ok(());
+    }
+    state.remove_connection_pools_detached(&connection_id).await;
+    drop_nacos_adapters_for_connection_ids(state.inner(), std::slice::from_ref(&connection_id)).await;
+    drop_mq_adapters_for_connection_ids(state.inner(), std::slice::from_ref(&connection_id)).await;
+    state.reset_connection_transport(&connection_id).await;
+    if connection_id.starts_with("__visible_draft_") || connection_id.starts_with("__visible_schema_draft_") {
+        state.configs.write().await.remove(&connection_id);
+    }
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn close_database_connection(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+) -> Result<bool, String> {
+    let database = database.trim();
+    let database = if database.is_empty() { None } else { Some(database) };
+    state.close_database_pool(&connection_id, database).await
+}
+
+#[tauri::command]
+pub async fn refresh_connections(state: State<'_, Arc<AppState>>) -> Result<(), String> {
+    state.refresh_connections().await;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn check_connection_health(state: State<'_, Arc<AppState>>, connection_id: String) -> Result<(), String> {
+    state.check_connection_health(&connection_id).await
+}
+
+/// Check whether a connection has read-only protection enabled.
+/// Returns an error if the connection is read-only, preventing write operations.
+pub async fn ensure_connection_writable(
+    state: &Arc<AppState>,
+    connection_id: &str,
+    action: &str,
+) -> Result<(), String> {
+    if let Some(name) = dbx_core::query::connection_readonly_name(state, connection_id).await {
+        return Err(format!(
+            "Read-only mode: connection '{}' has read-only protection enabled. {} blocked.",
+            name, action
+        ));
+    }
+    Ok(())
+}
diff --git a/src-tauri/src/commands/connection_secrets.rs b/src-tauri/src/commands/connection_secrets.rs
new file mode 100644
index 0000000..5ad5e1c
--- /dev/null
+++ b/src-tauri/src/commands/connection_secrets.rs
@@ -0,0 +1 @@
+// Legacy module — no longer used. All storage now goes through dbx_core::storage::Storage (SQLite).
diff --git a/src-tauri/src/commands/csv_export.rs b/src-tauri/src/commands/csv_export.rs
new file mode 100644
index 0000000..790d287
--- /dev/null
+++ b/src-tauri/src/commands/csv_export.rs
@@ -0,0 +1,33 @@
+use std::sync::Arc;
+
+use crate::commands::connection::AppState;
+use dbx_core::csv_export::{export_table_data_csv_core, format_query_result_csv, TableCsvExportOptions};
+use serde::Deserialize;
+use serde_json::Value;
+use tauri::State;
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryResultCsvExportRequest {
+    pub file_path: String,
+    pub columns: Vec<String>,
+    pub rows: Vec<Vec<Value>>,
+}
+
+#[tauri::command]
+pub async fn export_query_result_csv(request: QueryResultCsvExportRequest) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let csv = format_query_result_csv(&request.columns, &request.rows);
+        std::fs::write(&request.file_path, format!("\u{FEFF}{csv}")).map_err(|err| err.to_string())
+    })
+    .await
+    .map_err(|err| err.to_string())?
+}
+
+#[tauri::command]
+pub async fn export_table_data_csv(
+    state: State<'_, Arc<AppState>>,
+    request: TableCsvExportOptions,
+) -> Result<u64, String> {
+    export_table_data_csv_core(&state, request).await
+}
diff --git a/src-tauri/src/commands/data_compare.rs b/src-tauri/src/commands/data_compare.rs
new file mode 100644
index 0000000..ca353ab
--- /dev/null
+++ b/src-tauri/src/commands/data_compare.rs
@@ -0,0 +1,34 @@
+use std::sync::Arc;
+use tauri::State;
+
+use crate::commands::connection::AppState;
+
+#[tauri::command]
+pub fn prepare_data_compare(
+    options: dbx_core::data_compare::DataComparePreparationOptions,
+) -> Result<dbx_core::data_compare::DataComparePreparation, String> {
+    dbx_core::data_compare::prepare_data_compare(options)
+}
+
+#[tauri::command]
+pub async fn prepare_data_compare_from_tables(
+    state: State<'_, Arc<AppState>>,
+    options: dbx_core::data_compare::DataCompareFromTablesOptions,
+) -> Result<dbx_core::data_compare::DataCompareFromTablesPreparation, String> {
+    dbx_core::data_compare::prepare_data_compare_from_tables(&state, options).await
+}
+
+#[tauri::command]
+pub async fn prepare_data_compare_missing_target(
+    state: State<'_, Arc<AppState>>,
+    options: dbx_core::data_compare::DataCompareMissingTargetOptions,
+) -> Result<dbx_core::data_compare::DataCompareFromTablesPreparation, String> {
+    dbx_core::data_compare::prepare_data_compare_missing_target(&state, options).await
+}
+
+#[tauri::command]
+pub fn build_data_compare_sync_plan(
+    options: dbx_core::data_compare::DataCompareSyncPlanOptions,
+) -> dbx_core::data_compare::DataCompareSyncPlan {
+    dbx_core::data_compare::build_data_compare_sync_plan(options)
+}
diff --git a/src-tauri/src/commands/database_export.rs b/src-tauri/src/commands/database_export.rs
new file mode 100644
index 0000000..d4119a0
--- /dev/null
+++ b/src-tauri/src/commands/database_export.rs
@@ -0,0 +1,57 @@
+use std::sync::Arc;
+use tauri::{AppHandle, Emitter, State};
+
+use crate::commands::connection::AppState;
+
+pub use dbx_core::database_export::{DatabaseExportRequest, ExportProgress, ExportStatus};
+
+fn emit_progress(app: &AppHandle, progress: ExportProgress) {
+    let _ = app.emit("database-export-progress", progress);
+}
+
+#[tauri::command]
+pub async fn export_database_sql(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    request: DatabaseExportRequest,
+) -> Result<(), String> {
+    let state = state.inner().clone();
+    let export_id = request.export_id.clone();
+
+    tokio::spawn(async move {
+        let result = dbx_core::database_export::export_database_sql_core(&state, &request, |progress| {
+            emit_progress(&app, progress)
+        })
+        .await;
+
+        let client_session_id = dbx_core::database_export::database_export_client_session_id(&export_id);
+        let _ =
+            state.close_client_session_pool(&request.connection_id, Some(&request.database), &client_session_id).await;
+
+        if let Err(e) = result {
+            emit_progress(
+                &app,
+                ExportProgress {
+                    export_id: export_id.clone(),
+                    current_object: String::new(),
+                    object_index: 0,
+                    total_objects: 0,
+                    rows_exported: 0,
+                    total_rows: None,
+                    status: ExportStatus::Error,
+                    error: Some(e),
+                },
+            );
+        }
+
+        dbx_core::database_export::clear_export_cancelled(&export_id).await;
+    });
+
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn cancel_database_export(export_id: String) -> Result<(), String> {
+    dbx_core::database_export::set_export_cancelled(&export_id).await;
+    Ok(())
+}
diff --git a/src-tauri/src/commands/deep_link.rs b/src-tauri/src/commands/deep_link.rs
new file mode 100644
index 0000000..a42cfa6
--- /dev/null
+++ b/src-tauri/src/commands/deep_link.rs
@@ -0,0 +1,102 @@
+use std::collections::HashSet;
+use std::sync::Mutex;
+
+const CONNECTION_DEEP_LINK_PREFIX: &str = "dbx://connection/new";
+
+#[tauri::command]
+pub fn pending_open_connection_links(state: tauri::State<'_, DeepLinkOpenState>) -> Vec<String> {
+    dedupe_links(state.drain())
+}
+
+#[derive(Default)]
+pub struct DeepLinkOpenState {
+    pending: Mutex<Vec<String>>,
+}
+
+impl DeepLinkOpenState {
+    pub fn push(&self, links: Vec<String>) {
+        if links.is_empty() {
+            return;
+        }
+        if let Ok(mut pending) = self.pending.lock() {
+            pending.extend(links);
+        }
+    }
+
+    fn drain(&self) -> Vec<String> {
+        self.pending.lock().map(|mut pending| pending.drain(..).collect()).unwrap_or_default()
+    }
+}
+
+pub fn connection_deep_links_from_args<I, S>(args: I) -> Vec<String>
+where
+    I: IntoIterator<Item = S>,
+    S: AsRef<str>,
+{
+    args.into_iter().filter_map(|arg| connection_deep_link_from_arg(arg.as_ref())).collect()
+}
+
+pub fn connection_deep_link_from_arg(arg: &str) -> Option<String> {
+    let trimmed = arg.trim();
+    let suffix = trimmed.strip_prefix(CONNECTION_DEEP_LINK_PREFIX)?;
+    if !(suffix.is_empty()
+        || suffix.starts_with('?')
+        || suffix.starts_with('#')
+        || suffix == "/"
+        || suffix.starts_with("/?")
+        || suffix.starts_with("/#"))
+    {
+        return None;
+    }
+    Some(trimmed.to_string())
+}
+
+fn dedupe_links(links: Vec<String>) -> Vec<String> {
+    let mut seen = HashSet::new();
+    let mut unique = Vec::new();
+    for link in links {
+        if seen.insert(link.clone()) {
+            unique.push(link);
+        }
+    }
+    unique
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn filters_connection_deep_links() {
+        let links = connection_deep_links_from_args([
+            "dbx://connection/new?type=mysql&host=127.0.0.1",
+            "--flag",
+            "dbx://open?x=1",
+            "dbx://connections/new?type=postgres",
+            "dbx://connection/newer?type=mysql",
+        ]);
+
+        assert_eq!(links, vec!["dbx://connection/new?type=mysql&host=127.0.0.1".to_string()]);
+    }
+
+    #[test]
+    fn drains_pending_links_once() {
+        let state = DeepLinkOpenState::default();
+        state.push(vec!["dbx://connection/new?type=mysql".to_string()]);
+
+        assert_eq!(state.drain(), vec!["dbx://connection/new?type=mysql"]);
+        assert!(state.drain().is_empty());
+    }
+
+    #[test]
+    fn dedupes_links_while_preserving_order() {
+        assert_eq!(
+            dedupe_links(vec![
+                "dbx://connection/new?type=mysql".to_string(),
+                "dbx://connection/new?type=postgres".to_string(),
+                "dbx://connection/new?type=mysql".to_string(),
+            ]),
+            vec!["dbx://connection/new?type=mysql", "dbx://connection/new?type=postgres"]
+        );
+    }
+}
diff --git a/src-tauri/src/commands/document_cmd.rs b/src-tauri/src/commands/document_cmd.rs
new file mode 100644
index 0000000..fb222b8
--- /dev/null
+++ b/src-tauri/src/commands/document_cmd.rs
@@ -0,0 +1,237 @@
+use std::future::Future;
+use std::sync::Arc;
+use tauri::State;
+
+use crate::commands::connection::{ensure_connection_writable, AppState};
+use dbx_core::db::mongo_driver::MongoDocumentResult;
+use dbx_core::document_ops::CollectionInfo;
+
+async fn run_cancellable<T, F>(state: &Arc<AppState>, execution_id: Option<String>, future: F) -> Result<T, String>
+where
+    F: Future<Output = Result<T, String>>,
+{
+    let registered_query =
+        execution_id.as_ref().filter(|id| !id.trim().is_empty()).map(|id| state.running_queries.register(id.clone()));
+    if let Some(query) = registered_query.as_ref() {
+        let token = query.token();
+        tokio::select! {
+            biased;
+            _ = token.cancelled() => Err(dbx_core::query::canceled_error()),
+            result = future => result,
+        }
+    } else {
+        future.await
+    }
+}
+
+#[tauri::command]
+pub async fn document_list_databases(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<Vec<String>, String> {
+    dbx_core::document_ops::list_databases_core(&state, &connection_id).await
+}
+
+#[tauri::command]
+pub async fn document_list_collections(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+) -> Result<Vec<CollectionInfo>, String> {
+    dbx_core::document_ops::list_collections_core(&state, &connection_id, &database).await
+}
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+pub async fn document_find_documents(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    skip: u64,
+    limit: i64,
+    filter: Option<String>,
+    projection: Option<String>,
+    sort: Option<String>,
+    execution_id: Option<String>,
+) -> Result<MongoDocumentResult, String> {
+    let app = state.inner().clone();
+    run_cancellable(
+        &app,
+        execution_id,
+        dbx_core::document_ops::find_documents_core(
+            &app,
+            &connection_id,
+            &database,
+            &collection,
+            skip,
+            limit,
+            filter.as_deref(),
+            projection.as_deref(),
+            sort.as_deref(),
+        ),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn document_insert_document(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    doc_json: String,
+) -> Result<String, String> {
+    ensure_connection_writable(&state, &connection_id, "Insert").await?;
+    dbx_core::document_ops::insert_document_core(&state, &connection_id, &database, &collection, &doc_json).await
+}
+
+#[tauri::command]
+pub async fn document_update_document(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    id: String,
+    doc_json: String,
+    routing: Option<String>,
+) -> Result<u64, String> {
+    ensure_connection_writable(&state, &connection_id, "Update").await?;
+    dbx_core::document_ops::update_document_core(
+        &state,
+        &connection_id,
+        &database,
+        &collection,
+        &id,
+        &doc_json,
+        routing.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn document_delete_document(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    id: String,
+    routing: Option<String>,
+) -> Result<u64, String> {
+    ensure_connection_writable(&state, &connection_id, "Delete").await?;
+    dbx_core::document_ops::delete_document_core(
+        &state,
+        &connection_id,
+        &database,
+        &collection,
+        &id,
+        routing.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn document_list_gridfs_buckets(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    filter: Option<String>,
+    sort: Option<String>,
+) -> Result<Vec<dbx_core::document_ops::MongoGridFsBucketInfo>, String> {
+    dbx_core::document_ops::list_gridfs_buckets_core(
+        &state,
+        &connection_id,
+        &database,
+        filter.as_deref(),
+        sort.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn document_create_gridfs_bucket(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    bucket: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Create GridFS bucket").await?;
+    dbx_core::document_ops::create_gridfs_bucket_core(&state, &connection_id, &database, &bucket).await
+}
+
+#[tauri::command]
+pub async fn document_delete_gridfs_bucket(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    bucket: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Delete GridFS bucket").await?;
+    dbx_core::document_ops::delete_gridfs_bucket_core(&state, &connection_id, &database, &bucket).await
+}
+
+#[tauri::command]
+pub async fn document_list_gridfs_files(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    bucket: String,
+    filter: Option<String>,
+    sort: Option<String>,
+) -> Result<Vec<dbx_core::document_ops::MongoGridFsFileInfo>, String> {
+    dbx_core::document_ops::list_gridfs_files_core(
+        &state,
+        &connection_id,
+        &database,
+        &bucket,
+        filter.as_deref(),
+        sort.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn document_download_gridfs_file(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    bucket: String,
+    file_id: String,
+) -> Result<Vec<u8>, String> {
+    dbx_core::document_ops::download_gridfs_file_core(&state, &connection_id, &database, &bucket, &file_id).await
+}
+
+#[tauri::command]
+pub async fn document_upload_gridfs_file(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    bucket: String,
+    file_name: String,
+    data: Vec<u8>,
+    content_type: Option<String>,
+) -> Result<String, String> {
+    ensure_connection_writable(&state, &connection_id, "Upload GridFS file").await?;
+    dbx_core::document_ops::upload_gridfs_file_core(
+        &state,
+        &connection_id,
+        &database,
+        &bucket,
+        &file_name,
+        &data,
+        content_type.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn document_delete_gridfs_file(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    bucket: String,
+    file_id: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Delete GridFS file").await?;
+    dbx_core::document_ops::delete_gridfs_file_core(&state, &connection_id, &database, &bucket, &file_id).await
+}
diff --git a/src-tauri/src/commands/etcd_cmd.rs b/src-tauri/src/commands/etcd_cmd.rs
new file mode 100644
index 0000000..d8a22d4
--- /dev/null
+++ b/src-tauri/src/commands/etcd_cmd.rs
@@ -0,0 +1,47 @@
+use std::sync::Arc;
+use tauri::State;
+
+use crate::commands::connection::{ensure_connection_writable, AppState};
+use dbx_core::agent_kv::{KvDeleteResponse, KvGetResponse, KvListPrefixResponse, KvPutResponse, KvValue};
+
+#[tauri::command]
+pub async fn etcd_list_prefix(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    prefix: String,
+    limit: usize,
+    continuation: Option<String>,
+) -> Result<KvListPrefixResponse, String> {
+    dbx_core::agent_kv::kv_list_prefix_core(&state, &connection_id, &prefix, limit, continuation.as_deref()).await
+}
+
+#[tauri::command]
+pub async fn etcd_get(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: String,
+) -> Result<KvGetResponse, String> {
+    dbx_core::agent_kv::kv_get_core(&state, &connection_id, &key).await
+}
+
+#[tauri::command]
+pub async fn etcd_put(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: String,
+    value: KvValue,
+    lease: Option<i64>,
+) -> Result<KvPutResponse, String> {
+    ensure_connection_writable(&state, &connection_id, "Put").await?;
+    dbx_core::agent_kv::kv_put_core(&state, &connection_id, &key, value, lease).await
+}
+
+#[tauri::command]
+pub async fn etcd_delete(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: String,
+) -> Result<KvDeleteResponse, String> {
+    ensure_connection_writable(&state, &connection_id, "Delete").await?;
+    dbx_core::agent_kv::kv_delete_core(&state, &connection_id, &key).await
+}
diff --git a/src-tauri/src/commands/external_db.rs b/src-tauri/src/commands/external_db.rs
new file mode 100644
index 0000000..ca5b650
--- /dev/null
+++ b/src-tauri/src/commands/external_db.rs
@@ -0,0 +1,114 @@
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
+
+const DB_EXTENSIONS: &[&str] = &["db", "db3", "sqlite", "sqlite3", "duckdb"];
+
+#[derive(Default)]
+pub struct ExternalDbOpenState {
+    pending: Mutex<Vec<String>>,
+}
+
+impl ExternalDbOpenState {
+    pub fn push(&self, paths: Vec<String>) {
+        if paths.is_empty() {
+            return;
+        }
+        if let Ok(mut pending) = self.pending.lock() {
+            pending.extend(paths);
+        }
+    }
+
+    fn drain(&self) -> Vec<String> {
+        self.pending.lock().map(|mut pending| pending.drain(..).collect()).unwrap_or_default()
+    }
+}
+
+#[tauri::command]
+pub fn pending_open_db_files(state: tauri::State<'_, ExternalDbOpenState>) -> Vec<String> {
+    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+    let mut paths = db_file_paths_from_args(std::env::args().skip(1), &cwd);
+    paths.extend(state.drain());
+    dedupe_paths(paths)
+}
+
+pub fn db_file_paths_from_args<I, S>(args: I, cwd: &Path) -> Vec<String>
+where
+    I: IntoIterator<Item = S>,
+    S: AsRef<str>,
+{
+    args.into_iter().filter_map(|arg| db_file_path_from_arg(arg.as_ref(), cwd)).collect()
+}
+
+fn db_file_path_from_arg(arg: &str, cwd: &Path) -> Option<String> {
+    if arg.starts_with('-') {
+        return None;
+    }
+
+    let path = PathBuf::from(arg);
+    if !is_db_file_path(&path) {
+        return None;
+    }
+
+    let resolved = if path.is_absolute() { path } else { cwd.join(path) };
+    Some(resolved.to_string_lossy().to_string())
+}
+
+pub fn is_db_file_path(path: &Path) -> bool {
+    path.extension()
+        .and_then(|ext| ext.to_str())
+        .map(|ext| DB_EXTENSIONS.iter().any(|e| e.eq_ignore_ascii_case(ext)))
+        .unwrap_or(false)
+}
+
+fn dedupe_paths(paths: Vec<String>) -> Vec<String> {
+    let mut unique = Vec::new();
+    for path in paths {
+        if !unique.contains(&path) {
+            unique.push(path);
+        }
+    }
+    unique
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn filters_db_file_args_case_insensitively() {
+        let paths = db_file_paths_from_args(
+            ["/tmp/a.db", "--flag", "/tmp/b.SQLITE", "/tmp/c.sqlite3", "/tmp/d.duckdb", "/tmp/e.db3", "/tmp/f.txt"],
+            Path::new("/work"),
+        );
+
+        assert_eq!(paths, vec!["/tmp/a.db", "/tmp/b.SQLITE", "/tmp/c.sqlite3", "/tmp/d.duckdb", "/tmp/e.db3"]);
+    }
+
+    #[test]
+    fn resolves_relative_db_file_args_against_cwd() {
+        let paths = db_file_paths_from_args(["data/mydb.db"], Path::new("/work"));
+
+        assert_eq!(paths, vec!["/work/data/mydb.db"]);
+    }
+
+    #[test]
+    fn drains_pending_db_file_paths_once() {
+        let state = ExternalDbOpenState::default();
+        state.push(vec!["/tmp/a.db".to_string()]);
+
+        assert_eq!(state.drain(), vec!["/tmp/a.db"]);
+        assert!(state.drain().is_empty());
+    }
+
+    #[test]
+    fn is_db_file_path_recognizes_extensions() {
+        assert!(is_db_file_path(Path::new("test.db")));
+        assert!(is_db_file_path(Path::new("test.db3")));
+        assert!(is_db_file_path(Path::new("test.sqlite")));
+        assert!(is_db_file_path(Path::new("test.sqlite3")));
+        assert!(is_db_file_path(Path::new("test.duckdb")));
+        assert!(is_db_file_path(Path::new("test.DB")));
+        assert!(!is_db_file_path(Path::new("test.sql")));
+        assert!(!is_db_file_path(Path::new("test.txt")));
+    }
+}
diff --git a/src-tauri/src/commands/external_sql.rs b/src-tauri/src/commands/external_sql.rs
new file mode 100644
index 0000000..c7e9197
--- /dev/null
+++ b/src-tauri/src/commands/external_sql.rs
@@ -0,0 +1,193 @@
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
+
+use dbx_core::sql::decode_sql_file_bytes;
+
+#[tauri::command]
+pub fn pending_open_sql_files(state: tauri::State<'_, ExternalSqlOpenState>) -> Vec<String> {
+    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+    let mut paths = sql_file_paths_from_args(std::env::args().skip(1), &cwd);
+    paths.extend(state.drain());
+    dedupe_paths(paths)
+}
+
+#[tauri::command]
+pub async fn read_external_sql_file(path: String) -> Result<String, String> {
+    read_external_sql_file_content_async(PathBuf::from(path)).await
+}
+
+#[tauri::command]
+pub async fn write_external_sql_file(path: String, content: String) -> Result<(), String> {
+    write_external_sql_file_content_async(PathBuf::from(path), content).await
+}
+
+#[derive(Default)]
+pub struct ExternalSqlOpenState {
+    pending: Mutex<Vec<String>>,
+}
+
+impl ExternalSqlOpenState {
+    pub fn push(&self, paths: Vec<String>) {
+        if paths.is_empty() {
+            return;
+        }
+        if let Ok(mut pending) = self.pending.lock() {
+            pending.extend(paths);
+        }
+    }
+
+    fn drain(&self) -> Vec<String> {
+        self.pending.lock().map(|mut pending| pending.drain(..).collect()).unwrap_or_default()
+    }
+}
+
+pub fn sql_file_paths_from_args<I, S>(args: I, cwd: &Path) -> Vec<String>
+where
+    I: IntoIterator<Item = S>,
+    S: AsRef<str>,
+{
+    args.into_iter().filter_map(|arg| sql_file_path_from_arg(arg.as_ref(), cwd)).collect()
+}
+
+fn sql_file_path_from_arg(arg: &str, cwd: &Path) -> Option<String> {
+    if arg.starts_with('-') {
+        return None;
+    }
+
+    let path = PathBuf::from(arg);
+    if !is_sql_file_path(&path) {
+        return None;
+    }
+
+    let resolved = if path.is_absolute() { path } else { cwd.join(path) };
+    Some(resolved.to_string_lossy().to_string())
+}
+
+pub fn is_sql_file_path(path: &Path) -> bool {
+    path.extension().and_then(|ext| ext.to_str()).map(|ext| ext.eq_ignore_ascii_case("sql")).unwrap_or(false)
+}
+
+#[cfg(test)]
+fn read_external_sql_file_content(path: &Path) -> Result<String, String> {
+    if !is_sql_file_path(path) {
+        return Err("Only .sql files can be opened this way".to_string());
+    }
+    let bytes = std::fs::read(path).map_err(|e| format!("Failed to read SQL file: {e}"))?;
+    decode_sql_file_bytes(&bytes)
+}
+
+async fn read_external_sql_file_content_async(path: PathBuf) -> Result<String, String> {
+    if !is_sql_file_path(&path) {
+        return Err("Only .sql files can be opened this way".to_string());
+    }
+    let bytes = tokio::fs::read(&path).await.map_err(|e| format!("Failed to read SQL file: {e}"))?;
+    decode_sql_file_bytes(&bytes)
+}
+
+#[cfg(test)]
+fn write_external_sql_file_content(path: &Path, content: &str) -> Result<(), String> {
+    if !is_sql_file_path(path) {
+        return Err("Only .sql files can be saved this way".to_string());
+    }
+    std::fs::write(path, content).map_err(|e| format!("Failed to save SQL file: {e}"))
+}
+
+async fn write_external_sql_file_content_async(path: PathBuf, content: String) -> Result<(), String> {
+    if !is_sql_file_path(&path) {
+        return Err("Only .sql files can be saved this way".to_string());
+    }
+    tokio::fs::write(&path, content).await.map_err(|e| format!("Failed to save SQL file: {e}"))
+}
+
+fn dedupe_paths(paths: Vec<String>) -> Vec<String> {
+    let mut unique = Vec::new();
+    for path in paths {
+        if !unique.contains(&path) {
+            unique.push(path);
+        }
+    }
+    unique
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn filters_sql_file_args_case_insensitively() {
+        let paths = sql_file_paths_from_args(["/tmp/a.sql", "--flag", "/tmp/b.SQL", "/tmp/c.txt"], Path::new("/work"));
+
+        assert_eq!(paths, vec!["/tmp/a.sql", "/tmp/b.SQL"]);
+    }
+
+    #[test]
+    fn resolves_relative_sql_file_args_against_cwd() {
+        let paths = sql_file_paths_from_args(["queries/report.sql"], Path::new("/work"));
+
+        assert_eq!(paths, vec!["/work/queries/report.sql"]);
+    }
+
+    #[test]
+    fn drains_pending_sql_file_paths_once() {
+        let state = ExternalSqlOpenState::default();
+        state.push(vec!["/tmp/a.sql".to_string()]);
+
+        assert_eq!(state.drain(), vec!["/tmp/a.sql"]);
+        assert!(state.drain().is_empty());
+    }
+
+    #[test]
+    fn reads_external_sql_file_content() {
+        let path = std::env::temp_dir().join(format!("dbx-test-{}.sql", uuid::Uuid::new_v4()));
+        std::fs::write(&path, "select 1;").unwrap();
+
+        let result = read_external_sql_file_content(&path);
+
+        let _ = std::fs::remove_file(&path);
+        assert_eq!(result.unwrap(), "select 1;");
+    }
+
+    #[test]
+    fn reads_gbk_external_sql_file_content() {
+        let path = std::env::temp_dir().join(format!("dbx-test-{}.sql", uuid::Uuid::new_v4()));
+        std::fs::write(&path, b"select '\xD6\xD0\xCE\xC4';").unwrap();
+
+        let result = read_external_sql_file_content(&path);
+
+        let _ = std::fs::remove_file(&path);
+        assert_eq!(result.unwrap(), "select '中文';");
+    }
+
+    #[test]
+    fn rejects_external_non_sql_file_content() {
+        let path = std::env::temp_dir().join(format!("dbx-test-{}.txt", uuid::Uuid::new_v4()));
+        std::fs::write(&path, "select 1;").unwrap();
+
+        let result = read_external_sql_file_content(&path);
+
+        let _ = std::fs::remove_file(&path);
+        assert!(result.unwrap_err().contains(".sql"));
+    }
+
+    #[test]
+    fn writes_external_sql_file_content() {
+        let path = std::env::temp_dir().join(format!("dbx-test-{}.sql", uuid::Uuid::new_v4()));
+
+        let result = write_external_sql_file_content(&path, "select 2;");
+
+        let content = std::fs::read_to_string(&path).unwrap();
+        let _ = std::fs::remove_file(&path);
+        assert!(result.is_ok());
+        assert_eq!(content, "select 2;");
+    }
+
+    #[test]
+    fn rejects_external_non_sql_file_save() {
+        let path = std::env::temp_dir().join(format!("dbx-test-{}.txt", uuid::Uuid::new_v4()));
+
+        let result = write_external_sql_file_content(&path, "select 2;");
+
+        assert!(result.unwrap_err().contains(".sql"));
+        assert!(!path.exists());
+    }
+}
diff --git a/src-tauri/src/commands/fs_open.rs b/src-tauri/src/commands/fs_open.rs
new file mode 100644
index 0000000..e23c457
--- /dev/null
+++ b/src-tauri/src/commands/fs_open.rs
@@ -0,0 +1,165 @@
+use std::path::{Path, PathBuf};
+
+use dbx_core::db::sqlite::path_has_sqlite_header;
+use dbx_core::path_utils::expand_tilde;
+
+/// Reveal a file in the platform's file manager.
+///
+/// - macOS: `open -R <path>` highlights the file in Finder.
+/// - Windows: `explorer.exe /select,<path>` opens Explorer with the file selected.
+/// - Linux: opens the parent directory with `xdg-open`. (DBus
+///   `org.freedesktop.FileManager1.ShowItems` would be a higher-fidelity
+///   alternative; deferred to a follow-up to avoid a new dependency.)
+///
+/// The caller MUST pass an absolute path that already exists. Path expansion
+/// (`~`) and existence checks happen one layer up in the Tauri command.
+pub fn reveal_in_file_manager(path: &Path) -> Result<(), String> {
+    #[cfg(target_os = "macos")]
+    {
+        dbx_core::process::new_std_command("open")
+            .arg("-R")
+            .arg(path)
+            .spawn()
+            .map(|_| ())
+            .map_err(|e| format!("failed to launch Finder: {e}"))
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        // `/select,<path>` must be passed as a single argument with no space
+        // after the comma. `Command::arg` does not invoke a shell, so the path
+        // is forwarded as-is — spaces and non-ASCII characters survive.
+        let arg = format!("/select,{}", path.display());
+        dbx_core::process::new_std_command("explorer")
+            .arg(arg)
+            .spawn()
+            .map(|_| ())
+            .map_err(|e| format!("failed to launch Explorer: {e}"))
+    }
+
+    #[cfg(all(not(target_os = "macos"), not(target_os = "windows")))]
+    {
+        let target: PathBuf = path.parent().map(|p| p.to_path_buf()).unwrap_or_else(|| path.to_path_buf());
+        dbx_core::process::new_std_command("xdg-open")
+            .arg(&target)
+            .spawn()
+            .map(|_| ())
+            .map_err(|e| format!("failed to launch xdg-open: {e}"))
+    }
+}
+
+fn validate_path(raw: &str) -> Result<PathBuf, String> {
+    let trimmed = raw.trim();
+    if trimmed.is_empty() {
+        return Err("path is empty".to_string());
+    }
+    if trimmed == ":memory:" {
+        return Err("in-memory database has no file to reveal".to_string());
+    }
+
+    let expanded = expand_tilde(trimmed);
+    let path = PathBuf::from(&expanded);
+    if !path.is_absolute() {
+        return Err(format!("path is not absolute: {expanded}"));
+    }
+    if !path.exists() {
+        return Err(format!("文件不存在: {expanded}"));
+    }
+    Ok(path)
+}
+
+/// Reveal an absolute file path in the OS file manager. The path may use a
+/// leading `~` which is expanded via `dbx_core::path_utils::expand_tilde`.
+#[tauri::command]
+pub async fn reveal_path_in_file_manager(path: String) -> Result<(), String> {
+    let resolved = validate_path(&path)?;
+    reveal_in_file_manager(&resolved)
+}
+
+#[tauri::command]
+pub async fn is_sqlite_database_file(path: String) -> Result<bool, String> {
+    let resolved = validate_path(&path)?;
+    path_has_sqlite_header(&resolved)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn empty_path_is_rejected() {
+        assert!(validate_path("").is_err());
+        assert!(validate_path("   ").is_err());
+    }
+
+    #[test]
+    fn memory_path_is_rejected() {
+        let err = validate_path(":memory:").unwrap_err();
+        assert!(err.contains("in-memory"));
+    }
+
+    #[test]
+    fn relative_path_is_rejected() {
+        let err = validate_path("relative/path/foo.sqlite").unwrap_err();
+        assert!(err.contains("not absolute"));
+    }
+
+    #[test]
+    fn nonexistent_absolute_path_is_rejected() {
+        // /this/path/should/not/exist on Unix; on Windows the same check fires
+        // because the literal also won't exist.
+        let probe = if cfg!(windows) {
+            "C:/__dbx_definitely_missing__/foo.sqlite".to_string()
+        } else {
+            "/__dbx_definitely_missing__/foo.sqlite".to_string()
+        };
+        let err = validate_path(&probe).unwrap_err();
+        assert!(err.contains("文件不存在"));
+    }
+
+    #[test]
+    fn existing_absolute_path_is_accepted() {
+        // The OS temp dir is always an existing absolute path.
+        let dir = std::env::temp_dir();
+        assert!(dir.is_absolute());
+        let dir_str = dir.to_string_lossy().to_string();
+        let resolved = validate_path(&dir_str).expect("temp dir should validate");
+        assert_eq!(resolved, dir);
+    }
+
+    #[test]
+    fn sqlite_header_is_detected() {
+        let path = std::env::temp_dir().join(format!("dbx-sqlite-header-{}.conf", uuid::Uuid::new_v4()));
+        std::fs::write(&path, b"SQLite format 3\0extra").unwrap();
+
+        assert!(path_has_sqlite_header(&path).unwrap());
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn non_sqlite_header_is_rejected() {
+        let path = std::env::temp_dir().join(format!("dbx-sqlite-header-{}.conf", uuid::Uuid::new_v4()));
+        std::fs::write(&path, b"not sqlite").unwrap();
+
+        assert!(!path_has_sqlite_header(&path).unwrap());
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn tilde_is_expanded_when_home_set() {
+        // Only run when HOME (or USERPROFILE) actually points somewhere we can
+        // use to validate. We do not require any specific file under it; we
+        // only assert that expansion happens (so the absolute-path check
+        // passes).
+        let home = std::env::var("HOME").or_else(|_| std::env::var("USERPROFILE"));
+        if let Ok(h) = home {
+            let p = std::path::Path::new(&h);
+            if p.is_absolute() && p.exists() {
+                let resolved = validate_path("~").expect("tilde should expand");
+                assert!(resolved.is_absolute());
+            }
+        }
+    }
+}
diff --git a/src-tauri/src/commands/history.rs b/src-tauri/src/commands/history.rs
new file mode 100644
index 0000000..05e00c7
--- /dev/null
+++ b/src-tauri/src/commands/history.rs
@@ -0,0 +1,30 @@
+use std::sync::Arc;
+use tauri::State;
+
+use super::connection::AppState;
+pub use dbx_core::history::HistoryEntry;
+
+#[tauri::command]
+pub async fn save_history(state: State<'_, Arc<AppState>>, entry: HistoryEntry) -> Result<(), String> {
+    state.storage.save_history_entry(&entry).await
+}
+
+#[tauri::command]
+pub async fn load_history(
+    state: State<'_, Arc<AppState>>,
+    limit: usize,
+    offset: usize,
+    activity_kind: Option<String>,
+) -> Result<Vec<HistoryEntry>, String> {
+    state.storage.load_history_entries(limit, offset, activity_kind).await
+}
+
+#[tauri::command]
+pub async fn clear_history(state: State<'_, Arc<AppState>>) -> Result<(), String> {
+    state.storage.clear_history().await
+}
+
+#[tauri::command]
+pub async fn delete_history_entry(state: State<'_, Arc<AppState>>, id: String) -> Result<(), String> {
+    state.storage.delete_history_entry(&id).await
+}
diff --git a/src-tauri/src/commands/keychain.rs b/src-tauri/src/commands/keychain.rs
new file mode 100644
index 0000000..6d99faa
--- /dev/null
+++ b/src-tauri/src/commands/keychain.rs
@@ -0,0 +1,57 @@
+/// Read a macOS Keychain generic password by service name.
+/// Triggers a system authorization dialog (Touch ID / password) for each unique service.
+#[tauri::command]
+pub async fn read_keychain_password(service: String, account: Option<String>) -> Result<String, String> {
+    #[cfg(not(target_os = "macos"))]
+    {
+        let _ = (service, account);
+        Err("Keychain access is only available on macOS".to_string())
+    }
+
+    #[cfg(target_os = "macos")]
+    {
+        tauri::async_runtime::spawn_blocking(move || read_keychain_password_blocking(service, account))
+            .await
+            .map_err(|err| err.to_string())?
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn read_keychain_password_blocking(service: String, account: Option<String>) -> Result<String, String> {
+    let mut cmd = dbx_core::process::new_std_command("security");
+    cmd.args(["find-generic-password", "-s", &service, "-w"]);
+    if let Some(ref acct) = account {
+        cmd.args(["-a", acct]);
+    }
+
+    let output = cmd.output().map_err(|e| format!("Failed to run security command: {e}"))?;
+
+    if output.status.success() {
+        let password = String::from_utf8_lossy(&output.stdout).trim().to_string();
+        Ok(password)
+    } else {
+        // Exit code 44 = user cancelled the authorization dialog
+        let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+        if output.status.code() == Some(44)
+            || stderr.contains("User canceled")
+            || stderr.contains("could not be found")
+            || stderr.contains("The specified item could not be found")
+        {
+            Ok(String::new())
+        } else {
+            Err(format!("Keychain read failed: {}", stderr.trim()))
+        }
+    }
+}
+
+/// Read multiple Keychain passwords in one call. Returns a map of service -> password.
+/// Services that fail or are cancelled get an empty string.
+#[tauri::command]
+pub async fn read_keychain_passwords(services: Vec<String>) -> Result<Vec<(String, String)>, String> {
+    let mut results = Vec::with_capacity(services.len());
+    for service in services {
+        let password = read_keychain_password(service.clone(), None).await.unwrap_or_default();
+        results.push((service, password));
+    }
+    Ok(results)
+}
diff --git a/src-tauri/src/commands/list_sql_files.rs b/src-tauri/src/commands/list_sql_files.rs
new file mode 100644
index 0000000..576ea5b
--- /dev/null
+++ b/src-tauri/src/commands/list_sql_files.rs
@@ -0,0 +1,118 @@
+use serde::Serialize;
+use std::collections::HashSet;
+use std::path::Path;
+
+const MAX_SCAN_DEPTH: usize = 10;
+
+/// Directories that are never interesting for SQL file browsing but are huge
+/// (often tens of thousands of entries), which makes a recursive scan take
+/// long enough to freeze the UI. Skipped outright.
+const PRUNED_DIRS: &[&str] = &[
+    ".git",
+    "node_modules",
+    "target",
+    ".venv",
+    "venv",
+    "__pycache__",
+    ".idea",
+    ".vscode",
+    "dist",
+    "build",
+    ".next",
+    ".nuxt",
+    ".gradle",
+    ".m2",
+    ".cache",
+];
+
+#[derive(Debug, Serialize)]
+pub struct SqlFileEntry {
+    pub name: String,
+    pub path: String,
+    pub is_dir: bool,
+    pub children: Vec<SqlFileEntry>,
+}
+
+fn is_pruned_dir(name: &str) -> bool {
+    PRUNED_DIRS.iter().any(|d| name.eq_ignore_ascii_case(d))
+}
+
+fn scan_sql_files(dir: &Path, depth: usize, visited: &mut HashSet<String>) -> Vec<SqlFileEntry> {
+    if depth > MAX_SCAN_DEPTH {
+        return vec![];
+    }
+
+    // Canonicalize only the top-level folder once per scan to guard against
+    // symlink loops; doing it for every subdir doubled the stat cost.
+    let canonical = std::fs::canonicalize(dir).ok();
+    if let Some(ref c) = canonical {
+        let c_str = c.to_string_lossy().to_string();
+        if !visited.insert(c_str) {
+            return vec![];
+        }
+    }
+
+    let mut entries = Vec::new();
+    let dir_entries = match std::fs::read_dir(dir) {
+        Ok(entries) => entries,
+        Err(_) => return entries,
+    };
+
+    for entry in dir_entries.flatten() {
+        let file_type = match entry.file_type() {
+            Ok(ft) => ft,
+            Err(_) => continue,
+        };
+        let path = entry.path();
+        let name = match path.file_name().and_then(|n| n.to_str()) {
+            Some(name) => name.to_string(),
+            None => continue,
+        };
+
+        if file_type.is_dir() {
+            if is_pruned_dir(&name) {
+                continue;
+            }
+            let children = scan_sql_files(&path, depth + 1, visited);
+            if !children.is_empty() {
+                entries.push(SqlFileEntry { name, path: path.to_string_lossy().to_string(), is_dir: true, children });
+            }
+        } else if file_type.is_file()
+            && path.extension().and_then(|e| e.to_str()).map(|e| e.eq_ignore_ascii_case("sql")).unwrap_or(false)
+        {
+            entries.push(SqlFileEntry {
+                name,
+                path: path.to_string_lossy().to_string(),
+                is_dir: false,
+                children: vec![],
+            });
+        }
+    }
+
+    entries.sort_by(|a, b| {
+        if a.is_dir != b.is_dir {
+            b.is_dir.cmp(&a.is_dir)
+        } else {
+            a.name.to_lowercase().cmp(&b.name.to_lowercase())
+        }
+    });
+
+    entries
+}
+
+#[tauri::command]
+pub async fn list_sql_files_in_folder(folder_path: String) -> Result<Vec<SqlFileEntry>, String> {
+    let path = Path::new(&folder_path).to_path_buf();
+    // Filesystem scanning is blocking work; run it on a thread pool so the
+    // Tauri main thread (and thus the webview) does not freeze while large
+    // folders are being walked.
+    tauri::async_runtime::spawn_blocking(move || {
+        if !path.is_dir() {
+            return Err(format!("Path is not a directory: {}", folder_path));
+        }
+        let mut visited = HashSet::new();
+        Ok(scan_sql_files(&path, 0, &mut visited))
+    })
+    .await
+    .map_err(|e| format!("Failed to scan folder: {e}"))?
+}
diff --git a/src-tauri/src/commands/mcp.rs b/src-tauri/src/commands/mcp.rs
new file mode 100644
index 0000000..38706d3
--- /dev/null
+++ b/src-tauri/src/commands/mcp.rs
@@ -0,0 +1,463 @@
+#[cfg(not(windows))]
+use std::env;
+use std::path::Path;
+use std::time::Duration;
+
+use serde::{Deserialize, Serialize};
+
+const MCP_PACKAGE_NAME: &str = "@dbx-app/mcp-server";
+const MCP_LATEST_URL: &str = "https://registry.npmjs.org/@dbx-app%2fmcp-server/latest";
+const MCP_INSTALL_COMMAND: &str = "npm install -g @dbx-app/mcp-server@latest --registry=https://registry.npmjs.org";
+const SHELL_COMMAND_MARKER: &str = "__DBX_MCP_COMMAND_OUTPUT_START__";
+
+#[derive(Debug, Serialize)]
+pub struct McpServerStatus {
+    pub installed: bool,
+    pub npm_available: bool,
+    pub node_path: Option<String>,
+    pub node_version: Option<String>,
+    pub current_version: Option<String>,
+    pub latest_version: Option<String>,
+    pub update_available: bool,
+    pub bin_path: Option<String>,
+    pub script_path: Option<String>,
+    pub install_command: String,
+    pub update_command: String,
+    pub error: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+struct NpmLatestPackage {
+    version: String,
+}
+
+#[tauri::command]
+pub async fn check_mcp_server_status() -> Result<McpServerStatus, String> {
+    let local_status = tauri::async_runtime::spawn_blocking(|| {
+        let npm_available = command_success("npm", &["--version"]);
+        let node_path = locate_command("node");
+        let node_command = node_path.as_deref().unwrap_or("node");
+        let node_version = command_stdout(node_command, &["--version"]).ok().and_then(first_non_empty_line);
+        let current_version = if npm_available { installed_mcp_version() } else { None };
+        let bin_path = locate_mcp_bin();
+        let script_path = if npm_available { installed_mcp_bin_script() } else { None };
+        (npm_available, node_path, node_version, current_version, bin_path, script_path)
+    });
+    let latest_version = fetch_latest_mcp_version();
+    let (local_status, latest_version) = tokio::join!(local_status, latest_version);
+    let (npm_available, node_path, node_version, current_version, bin_path, script_path) =
+        local_status.map_err(|err| err.to_string())?;
+    let latest_version = latest_version.ok();
+    let update_available = current_version
+        .as_deref()
+        .zip(latest_version.as_deref())
+        .is_some_and(|(current, latest)| dbx_core::update::is_newer_version(latest, current));
+    let error = if npm_available { None } else { Some("npm is not available in PATH.".to_string()) };
+
+    Ok(McpServerStatus {
+        installed: current_version.is_some() || bin_path.is_some() || script_path.is_some(),
+        npm_available,
+        node_path,
+        node_version,
+        current_version,
+        latest_version,
+        update_available,
+        bin_path,
+        script_path,
+        install_command: MCP_INSTALL_COMMAND.to_string(),
+        update_command: MCP_INSTALL_COMMAND.to_string(),
+        error,
+    })
+}
+
+#[tauri::command]
+pub async fn install_mcp_server() -> Result<String, String> {
+    tauri::async_runtime::spawn_blocking(|| {
+        let output = command_output(
+            "npm",
+            &["install", "-g", "@dbx-app/mcp-server@latest", "--registry=https://registry.npmjs.org"],
+        )?;
+
+        if !output.success {
+            let error_msg = if !output.stderr.is_empty() { output.stderr } else { output.stdout };
+            return Err(format!("Installation failed: {}", error_msg));
+        }
+
+        let version = installed_mcp_version().unwrap_or_else(|| "unknown".to_string());
+        Ok(format!("Successfully installed @dbx-app/mcp-server@{}", version))
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+async fn fetch_latest_mcp_version() -> Result<String, String> {
+    let mut builder = reqwest::Client::builder().timeout(Duration::from_secs(10)).user_agent("dbx-mcp-status-checker");
+    let proxy_url =
+        tauri::async_runtime::spawn_blocking(dbx_core::update::system_proxy_url).await.map_err(|e| e.to_string())?;
+    if let Some(proxy_url) = proxy_url {
+        let proxy = reqwest::Proxy::all(&proxy_url).map_err(|e| format!("Invalid system proxy URL: {e}"))?;
+        builder = builder.proxy(proxy);
+    }
+    let client = builder.build().map_err(|e| format!("Failed to create HTTP client: {e}"))?;
+    let package = client
+        .get(MCP_LATEST_URL)
+        .send()
+        .await
+        .and_then(|r| r.error_for_status())
+        .map_err(|e| format!("Failed to check MCP Server updates: {e}"))?
+        .json::<NpmLatestPackage>()
+        .await
+        .map_err(|e| format!("Failed to parse MCP Server update response: {e}"))?;
+    Ok(package.version)
+}
+
+fn installed_mcp_version() -> Option<String> {
+    let root = command_stdout("npm", &["root", "-g"]).ok()?;
+    let pkg_json_path = Path::new(root.trim()).join(MCP_PACKAGE_NAME).join("package.json");
+    let content = std::fs::read_to_string(pkg_json_path).ok()?;
+    let value: serde_json::Value = serde_json::from_str(&content).ok()?;
+    value.get("version")?.as_str().map(ToOwned::to_owned)
+}
+
+pub(crate) fn resolve_mcp_server_command() -> Option<(String, Vec<String>)> {
+    #[cfg(windows)]
+    {
+        // Node.js 18.20.2+ rejects direct spawn of .cmd/.bat files without a shell
+        // on Windows. Prefer the package's real JS entry point for Codex CLI.
+        return installed_mcp_bin_script()
+            .map(|script| (locate_command("node").unwrap_or_else(|| "node".to_string()), vec![script]))
+            .or_else(|| locate_mcp_bin().map(|path| (path, Vec::new())));
+    }
+
+    #[cfg(not(windows))]
+    {
+        locate_mcp_bin()
+            .map(|path| (path, Vec::new()))
+            .or_else(|| installed_mcp_bin_script().map(|script| ("node".to_string(), vec![script])))
+    }
+}
+
+pub(crate) fn locate_command(command: &str) -> Option<String> {
+    #[cfg(windows)]
+    {
+        return locate_windows_command(command);
+    }
+    #[cfg(not(windows))]
+    {
+        command_stdout("which", &[command]).ok().and_then(first_non_empty_line)
+    }
+}
+
+fn locate_mcp_bin() -> Option<String> {
+    locate_command("dbx-mcp-server")
+}
+
+fn installed_mcp_bin_script() -> Option<String> {
+    let root = command_stdout("npm", &["root", "-g"]).ok()?;
+    let script = Path::new(root.trim()).join(MCP_PACKAGE_NAME).join("dist").join("index.js");
+    script.is_file().then(|| script.to_string_lossy().to_string())
+}
+
+#[cfg(windows)]
+fn locate_windows_command(command: &str) -> Option<String> {
+    command_stdout("where", &[command])
+        .ok()
+        .and_then(first_windows_command_path)
+        .or_else(|| {
+            let script =
+                format!("(Get-Command -All {} -ErrorAction SilentlyContinue).Source", windows_shell_quote(command));
+            command_stdout("powershell.exe", &["-NoProfile", "-Command", &script])
+                .ok()
+                .and_then(first_windows_command_path)
+        })
+        .or_else(|| {
+            windows_command_candidates(command)
+                .into_iter()
+                .find(|candidate| is_windows_launchable_command(candidate) && Path::new(candidate).is_file())
+        })
+}
+
+#[cfg(windows)]
+fn first_windows_command_path(value: String) -> Option<String> {
+    let paths = value.lines().map(str::trim).filter(|line| !line.is_empty()).collect::<Vec<_>>();
+    paths
+        .into_iter()
+        .find(|path| is_windows_launchable_command(path) && Path::new(path).is_file())
+        .map(ToOwned::to_owned)
+}
+
+#[cfg(windows)]
+fn is_windows_launchable_command(path: &str) -> bool {
+    matches!(
+        Path::new(path).extension().and_then(|extension| extension.to_str()).map(str::to_ascii_lowercase).as_deref(),
+        Some("exe" | "cmd" | "bat" | "com")
+    )
+}
+
+fn command_success(command: &str, args: &[&str]) -> bool {
+    command_output(command, args).is_ok_and(|output| output.success)
+}
+
+fn command_stdout(command: &str, args: &[&str]) -> Result<String, String> {
+    let output = command_output(command, args)?;
+    if !output.success {
+        return Err(output.stderr.trim().to_string());
+    }
+    Ok(output.stdout.trim().to_string())
+}
+
+fn first_non_empty_line(value: String) -> Option<String> {
+    value.lines().map(str::trim).find(|line| !line.is_empty()).map(ToOwned::to_owned)
+}
+
+#[derive(Debug)]
+struct CommandOutput {
+    success: bool,
+    stdout: String,
+    stderr: String,
+}
+
+fn command_output(command: &str, args: &[&str]) -> Result<CommandOutput, String> {
+    let direct = run_command(command, args);
+    if direct.as_ref().is_ok_and(|output| output.success) {
+        return direct;
+    }
+
+    #[cfg(windows)]
+    {
+        return run_windows_command_candidates(command, args).or(direct);
+    }
+
+    #[cfg(not(windows))]
+    {
+        run_command_through_user_shell(command, args).or(direct)
+    }
+}
+
+fn run_command(command: &str, args: &[&str]) -> Result<CommandOutput, String> {
+    let mut cmd = dbx_core::process::new_std_command(command);
+    cmd.args(args);
+    let output = cmd.output().map_err(|e| e.to_string())?;
+    Ok(CommandOutput {
+        success: output.status.success(),
+        stdout: String::from_utf8_lossy(&output.stdout).trim().to_string(),
+        stderr: String::from_utf8_lossy(&output.stderr).trim().to_string(),
+    })
+}
+
+#[cfg(windows)]
+fn run_windows_command_candidates(command: &str, args: &[&str]) -> Result<CommandOutput, String> {
+    for candidate in windows_command_candidates(command) {
+        let output = run_command(&candidate, args);
+        if output.as_ref().is_ok_and(|output| output.success) {
+            return output;
+        }
+    }
+    run_command_through_user_shell(command, args)
+}
+
+#[cfg(windows)]
+fn windows_command_candidates(command: &str) -> Vec<String> {
+    if Path::new(command).extension().is_some() {
+        return Vec::new();
+    }
+    let names = ["cmd", "exe", "bat", "com", "ps1"].iter().map(|extension| format!("{command}.{extension}"));
+    names
+        .clone()
+        .chain(
+            windows_common_command_dirs()
+                .into_iter()
+                .flat_map(|dir| names.clone().map(move |name| dir.join(name).to_string_lossy().to_string())),
+        )
+        .collect()
+}
+
+#[cfg(windows)]
+fn windows_common_command_dirs() -> Vec<std::path::PathBuf> {
+    let mut dirs = Vec::new();
+    if let Ok(nvm_symlink) = std::env::var("NVM_SYMLINK") {
+        dirs.push(nvm_symlink.into());
+    }
+    if let Ok(app_data) = std::env::var("APPDATA") {
+        dirs.push(std::path::PathBuf::from(app_data).join("npm"));
+    }
+    if let Ok(program_files) = std::env::var("ProgramFiles") {
+        dirs.push(std::path::PathBuf::from(program_files).join("nodejs"));
+    }
+    if let Ok(program_files_x86) = std::env::var("ProgramFiles(x86)") {
+        dirs.push(std::path::PathBuf::from(program_files_x86).join("nodejs"));
+    }
+    dirs.push(std::path::PathBuf::from(r"C:\nvm4w\nodejs"));
+    dirs
+}
+
+#[cfg(windows)]
+fn run_command_through_user_shell(command: &str, args: &[&str]) -> Result<CommandOutput, String> {
+    let script = windows_command_script(command, args);
+    let mut output = run_command("powershell.exe", &["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", &script])?;
+    output.stdout = stdout_after_shell_marker(&output.stdout);
+    Ok(output)
+}
+
+#[cfg(windows)]
+fn windows_command_script(command: &str, args: &[&str]) -> String {
+    let mut words = Vec::with_capacity(args.len() + 1);
+    words.push(windows_shell_quote(command));
+    words.extend(args.iter().map(|arg| windows_shell_quote(arg)));
+    format!("Write-Output {}; & {}", windows_shell_quote(SHELL_COMMAND_MARKER), words.join(" "))
+}
+
+#[cfg(windows)]
+fn windows_shell_quote(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "''"))
+}
+
+#[cfg(not(windows))]
+fn run_command_through_user_shell(command: &str, args: &[&str]) -> Result<CommandOutput, String> {
+    let script = shell_command_script(command, args);
+    let (shell, shell_args) = user_shell_invocation_args(&script);
+    let shell_arg_refs = shell_args.iter().map(String::as_str).collect::<Vec<_>>();
+    let mut output = run_command(&shell, &shell_arg_refs)?;
+    output.stdout = stdout_after_shell_marker(&output.stdout);
+    Ok(output)
+}
+
+#[cfg(not(windows))]
+fn user_shell_invocation_args(script: &str) -> (String, Vec<String>) {
+    let shell = env::var("SHELL").ok().filter(|value| !value.trim().is_empty()).unwrap_or_else(default_user_shell);
+    let shell_name = Path::new(&shell).file_name().and_then(|value| value.to_str()).unwrap_or_default();
+    let args = match shell_name {
+        "fish" => vec!["-l".to_string(), "-i".to_string(), "-c".to_string(), script.to_string()],
+        "bash" => vec![
+            "--noprofile".to_string(),
+            "--norc".to_string(),
+            "-i".to_string(),
+            "-c".to_string(),
+            bash_login_script(script),
+        ],
+        "sh" | "dash" => vec!["-ic".to_string(), script.to_string()],
+        "zsh" => vec!["-ilc".to_string(), script.to_string()],
+        _ => vec!["-lc".to_string(), script.to_string()],
+    };
+    (shell, args)
+}
+
+#[cfg(not(windows))]
+fn bash_login_script(script: &str) -> String {
+    format!(
+        "for dbx_profile in ~/.bash_profile ~/.bash_login ~/.profile ~/.bashrc; do \
+         [ -r \"$dbx_profile\" ] && . \"$dbx_profile\"; \
+         done; unset dbx_profile; {script}"
+    )
+}
+
+#[cfg(not(windows))]
+fn default_user_shell() -> String {
+    if Path::new("/bin/zsh").exists() {
+        "/bin/zsh".to_string()
+    } else {
+        "/bin/sh".to_string()
+    }
+}
+
+#[cfg(not(windows))]
+fn shell_command_script(command: &str, args: &[&str]) -> String {
+    let mut words = Vec::with_capacity(args.len() + 1);
+    words.push(shell_quote(command));
+    words.extend(args.iter().map(|arg| shell_quote(arg)));
+    format!("printf '%s\\n' {}; {}", shell_quote(SHELL_COMMAND_MARKER), words.join(" "))
+}
+
+#[cfg(not(windows))]
+fn shell_quote(value: &str) -> String {
+    if value.is_empty() {
+        return "''".to_string();
+    }
+    format!("'{}'", value.replace('\'', "'\"'\"'"))
+}
+
+fn stdout_after_shell_marker(stdout: &str) -> String {
+    stdout
+        .find(SHELL_COMMAND_MARKER)
+        .map(|index| stdout[index + SHELL_COMMAND_MARKER.len()..].trim_start_matches(['\r', '\n']).to_string())
+        .unwrap_or_else(|| stdout.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(not(windows))]
+    use super::bash_login_script;
+    #[cfg(windows)]
+    use super::first_windows_command_path;
+    #[cfg(not(windows))]
+    use super::{shell_command_script, shell_quote};
+    use super::{stdout_after_shell_marker, SHELL_COMMAND_MARKER};
+
+    #[cfg(not(windows))]
+    #[test]
+    fn shell_quote_handles_empty_and_single_quotes() {
+        assert_eq!(shell_quote(""), "''");
+        assert_eq!(shell_quote("npm"), "'npm'");
+        assert_eq!(shell_quote("can't"), "'can'\"'\"'t'");
+    }
+
+    #[cfg(not(windows))]
+    #[test]
+    fn shell_command_script_marks_command_output_after_startup_noise() {
+        let script = shell_command_script("npm", &["list", "-g", "@dbx-app/mcp-server", "--json"]);
+
+        assert!(script.contains(SHELL_COMMAND_MARKER));
+        assert!(script.contains("'@dbx-app/mcp-server'"));
+    }
+
+    #[cfg(not(windows))]
+    #[test]
+    fn bash_login_script_sources_profile_and_rc_files() {
+        let script = bash_login_script("node --version");
+
+        assert!(script.contains("~/.bash_profile"));
+        assert!(script.contains("~/.bashrc"));
+        assert!(script.ends_with("node --version"));
+    }
+
+    #[test]
+    fn stdout_after_shell_marker_ignores_shell_startup_output() {
+        let stdout = format!("loading profile\n{SHELL_COMMAND_MARKER}\n22.19.0\n");
+
+        assert_eq!(stdout_after_shell_marker(&stdout), "22.19.0\n");
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn windows_command_lookup_prefers_cmd_over_extensionless_shim() {
+        let dir = std::env::temp_dir().join(format!("dbx-mcp-command-test-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let extensionless = dir.join("codex");
+        let cmd = dir.join("codex.cmd");
+        std::fs::write(&extensionless, "#!/bin/sh\n").unwrap();
+        std::fs::write(&cmd, "@echo off\n").unwrap();
+
+        let output = format!("{}\n{}\n", extensionless.display(), cmd.display());
+        let resolved = first_windows_command_path(output).unwrap();
+
+        assert_eq!(resolved, cmd.to_string_lossy().as_ref());
+        let _ = std::fs::remove_file(extensionless);
+        let _ = std::fs::remove_file(cmd);
+        let _ = std::fs::remove_dir(dir);
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn windows_command_lookup_rejects_extensionless_only_shim() {
+        let dir = std::env::temp_dir().join(format!("dbx-mcp-command-extensionless-test-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let extensionless = dir.join("codex");
+        std::fs::write(&extensionless, "#!/bin/sh\n").unwrap();
+
+        let resolved = first_windows_command_path(extensionless.display().to_string());
+
+        assert!(resolved.is_none());
+        let _ = std::fs::remove_file(extensionless);
+        let _ = std::fs::remove_dir(dir);
+    }
+}
diff --git a/src-tauri/src/commands/mcp_bridge.rs b/src-tauri/src/commands/mcp_bridge.rs
new file mode 100644
index 0000000..ad88530
--- /dev/null
+++ b/src-tauri/src/commands/mcp_bridge.rs
@@ -0,0 +1,849 @@
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use tauri::{AppHandle, Emitter};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpListener;
+
+use super::connection::AppState;
+
+use super::connection::ensure_connection_writable;
+
+const BIND_ADDR: &str = "127.0.0.1:0";
+const MCP_BRIDGE_PORT_FILE: &str = "mcp-bridge-port";
+
+#[derive(Deserialize)]
+struct OpenTableRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    schema: Option<String>,
+    table: String,
+}
+
+#[derive(Deserialize)]
+struct ExecuteQueryRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    sql: String,
+    schema: Option<String>,
+    allow_writes: Option<bool>,
+    allow_dangerous: Option<bool>,
+}
+
+#[derive(Deserialize)]
+struct ListTablesRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    schema: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct DescribeTableRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    schema: Option<String>,
+    table: String,
+}
+
+#[derive(Deserialize)]
+struct MongoFindDocumentsRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    collection: String,
+    skip: Option<u64>,
+    limit: Option<i64>,
+    filter: Option<String>,
+    projection: Option<String>,
+    sort: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct MongoServerVersionRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct MongoCollectionStatsRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    collection: String,
+    scale: Option<serde_json::Number>,
+}
+
+#[derive(Deserialize)]
+struct MongoAggregateDocumentsRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    collection: String,
+    pipeline_json: String,
+    max_rows: Option<usize>,
+}
+
+#[derive(Deserialize)]
+struct MongoCreateIndexRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    collection: String,
+    keys_json: String,
+    options_json: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct MongoDropIndexesRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    collection: String,
+    indexes_json: Option<String>,
+    single: bool,
+}
+
+#[derive(Deserialize)]
+struct MongoDropCollectionRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    collection: String,
+}
+
+#[derive(Deserialize)]
+struct MongoInsertDocumentsRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    collection: String,
+    docs_json: String,
+}
+
+#[derive(Deserialize)]
+struct MongoUpdateDocumentsRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    collection: String,
+    filter_json: String,
+    update_json: String,
+    many: bool,
+    options_json: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct MongoDeleteDocumentsRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    database: Option<String>,
+    collection: String,
+    filter_json: String,
+    many: bool,
+}
+
+#[derive(Deserialize)]
+struct RedisCommandRequest {
+    connection_name: String,
+    connection_id: Option<String>,
+    db: u32,
+    command: String,
+    skip_safety_check: Option<bool>,
+}
+
+#[derive(Clone, Serialize)]
+pub struct McpOpenTableEvent {
+    pub connection_id: String,
+    pub database: String,
+    pub schema: Option<String>,
+    pub table: String,
+}
+
+#[derive(Clone, Serialize)]
+pub struct McpExecuteQueryEvent {
+    pub connection_id: String,
+    pub database: String,
+    pub sql: String,
+    pub allow_writes: bool,
+    pub allow_dangerous: bool,
+}
+
+pub fn start(app_handle: AppHandle, state: Arc<AppState>, data_dir: PathBuf) {
+    tauri::async_runtime::spawn(async move {
+        let listener = match TcpListener::bind(BIND_ADDR).await {
+            Ok(l) => l,
+            Err(e) => {
+                log::warn!("MCP bridge failed to bind {BIND_ADDR}: {e}");
+                return;
+            }
+        };
+        log::info!("MCP bridge listening on {BIND_ADDR}");
+        let actual_port = listener.local_addr().map(|a| a.port()).unwrap_or(0);
+        log::info!("MCP bridge assigned port {actual_port}");
+        // Publish into DBX's resolved data dir so DBX_DATA_DIR and portable mode share the same discovery file.
+        if let Err(err) = write_port_file(&data_dir, actual_port) {
+            log::warn!("MCP bridge failed to write port file in {}: {err}", data_dir.display());
+        }
+        loop {
+            let (mut stream, _) = match listener.accept().await {
+                Ok(s) => s,
+                Err(_) => continue,
+            };
+            let app = app_handle.clone();
+            let st = state.clone();
+            tokio::spawn(async move {
+                let mut buf = vec![0u8; 65536];
+                let n = match stream.read(&mut buf).await {
+                    Ok(n) if n > 0 => n,
+                    _ => return,
+                };
+                let request = String::from_utf8_lossy(&buf[..n]);
+                let body = request.split("\r\n\r\n").nth(1).unwrap_or("");
+                let first_line = request.lines().next().unwrap_or("");
+
+                if first_line.starts_with("POST /open-table") {
+                    handle_open_table(&app, &st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/list-tables") {
+                    handle_list_tables_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/describe-table") {
+                    handle_describe_table_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/mongo/list-collections") {
+                    handle_mongo_list_collections_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/mongo/find-documents") {
+                    handle_mongo_find_documents_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/mongo/server-version") {
+                    handle_mongo_server_version_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/mongo/collection-stats") {
+                    handle_mongo_collection_stats_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/mongo/aggregate-documents") {
+                    handle_mongo_aggregate_documents_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/mongo/create-index") {
+                    handle_mongo_create_index_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/mongo/drop-indexes") {
+                    handle_mongo_drop_indexes_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/mongo/drop-collection") {
+                    handle_mongo_drop_collection_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/mongo/insert-documents") {
+                    handle_mongo_insert_documents_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/mongo/update-documents") {
+                    handle_mongo_update_documents_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/mongo/delete-documents") {
+                    handle_mongo_delete_documents_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/redis/execute-command") {
+                    handle_redis_execute_command_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /data/execute-query") {
+                    handle_execute_query_data(&st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /execute-query") {
+                    handle_execute_query(&app, &st, body, &mut stream).await;
+                } else if first_line.starts_with("POST /reload-connections") {
+                    let _ = app.emit("mcp-reload-connections", ());
+                    respond(&mut stream, "200 OK", "ok").await;
+                } else {
+                    let _ = stream.write_all(b"HTTP/1.1 404 Not Found\r\nContent-Length: 0\r\n\r\n").await;
+                }
+            });
+        }
+    });
+}
+
+fn write_port_file(data_dir: &Path, actual_port: u16) -> std::io::Result<PathBuf> {
+    std::fs::create_dir_all(data_dir)?;
+    let path = data_dir.join(MCP_BRIDGE_PORT_FILE);
+    std::fs::write(&path, actual_port.to_string())?;
+    Ok(path)
+}
+
+fn find_config_by_name<'a>(
+    configs: &'a [crate::models::connection::ConnectionConfig],
+    name: &str,
+) -> Option<&'a crate::models::connection::ConnectionConfig> {
+    configs.iter().find(|c| c.name.eq_ignore_ascii_case(name))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::write_port_file;
+
+    #[test]
+    fn writes_bridge_port_file_to_resolved_data_dir() {
+        let root = std::env::temp_dir().join(format!(
+            "dbx-mcp-bridge-port-test-{}-{}",
+            std::process::id(),
+            uuid::Uuid::new_v4()
+        ));
+        let default_data_dir = root.join("default-app-data");
+        let resolved_data_dir = root.join("resolved-data");
+        std::fs::create_dir_all(&default_data_dir).unwrap();
+
+        let port_file = write_port_file(&resolved_data_dir, 49152).unwrap();
+
+        assert_eq!(port_file, resolved_data_dir.join("mcp-bridge-port"));
+        assert_eq!(std::fs::read_to_string(port_file).unwrap(), "49152");
+        assert!(!default_data_dir.join("mcp-bridge-port").exists());
+
+        let _ = std::fs::remove_dir_all(root);
+    }
+}
+
+async fn respond(stream: &mut tokio::net::TcpStream, status: &str, body: &str) {
+    let resp = format!("HTTP/1.1 {status}\r\nContent-Length: {}\r\n\r\n{body}", body.len());
+    let _ = stream.write_all(resp.as_bytes()).await;
+}
+
+async fn respond_json<T: Serialize>(stream: &mut tokio::net::TcpStream, data: &T) {
+    let body = serde_json::to_string(data).unwrap_or_else(|_| "null".to_string());
+    let resp =
+        format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{body}", body.len());
+    let _ = stream.write_all(resp.as_bytes()).await;
+}
+
+async fn respond_error(stream: &mut tokio::net::TcpStream, status: &str, message: &str) {
+    let body = serde_json::json!({ "error": message }).to_string();
+    let resp =
+        format!("HTTP/1.1 {status}\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{body}", body.len());
+    let _ = stream.write_all(resp.as_bytes()).await;
+}
+
+async fn resolve_connection(
+    state: &Arc<AppState>,
+    connection_id: Option<&str>,
+    connection_name: &str,
+) -> Result<crate::models::connection::ConnectionConfig, String> {
+    let configs = state.storage.load_connections().await.map_err(|e| e.to_string())?;
+    let config = if let Some(id) = connection_id.filter(|s| !s.is_empty()) {
+        configs.iter().find(|c| c.id == id).ok_or_else(|| format!("Connection with id '{}' not found", id))?
+    } else {
+        find_config_by_name(&configs, connection_name).ok_or_else(|| "Connection not found".to_string())?
+    };
+    let mut state_configs = state.configs.write().await;
+    if !state_configs.contains_key(&config.id) {
+        state_configs.insert(config.id.clone(), config.clone());
+    }
+    drop(state_configs);
+    Ok(config.clone())
+}
+
+fn check_visible_database(config: &crate::models::connection::ConnectionConfig, database: &str) -> Result<(), String> {
+    if let Some(ref visible) = config.visible_databases {
+        if !visible.is_empty() && !visible.iter().any(|v| v == database) {
+            return Err(format!("Database '{}' is not in the visible databases list for this connection", database));
+        }
+    }
+    Ok(())
+}
+
+async fn resolve_mongo_pool_key(
+    state: &Arc<AppState>,
+    connection_id: Option<&str>,
+    connection_name: &str,
+    database: Option<String>,
+    stream: &mut tokio::net::TcpStream,
+) -> Option<(String, String, String)> {
+    let config = match resolve_connection(state, connection_id, connection_name).await {
+        Ok(c) => c,
+        Err(e) => {
+            respond_error(stream, "404 Not Found", &e).await;
+            return None;
+        }
+    };
+    let connection_id = config.id.clone();
+    let database = database.unwrap_or_else(|| config.database.clone().unwrap_or_default());
+    let pool_key = match state.get_or_create_pool(&config.id, Some(&database)).await {
+        Ok(key) => key,
+        Err(e) => {
+            respond_error(stream, "500 Internal Server Error", &e).await;
+            return None;
+        }
+    };
+    Some((pool_key, database, connection_id))
+}
+
+async fn handle_open_table(app: &AppHandle, state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: OpenTableRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond(stream, "400 Bad Request", "").await;
+            return;
+        }
+    };
+    let config = match resolve_connection(state, req.connection_id.as_deref(), &req.connection_name).await {
+        Ok(c) => c,
+        Err(e) => {
+            respond(stream, "404 Not Found", &e).await;
+            return;
+        }
+    };
+    let event = McpOpenTableEvent {
+        connection_id: config.id.clone(),
+        database: req.database.unwrap_or_else(|| config.database.clone().unwrap_or_default()),
+        schema: req.schema,
+        table: req.table,
+    };
+    let _ = app.emit("mcp-open-table", &event);
+    respond(stream, "200 OK", "ok").await;
+}
+
+async fn handle_execute_query(app: &AppHandle, state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: ExecuteQueryRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond(stream, "400 Bad Request", "").await;
+            return;
+        }
+    };
+    let config = match resolve_connection(state, req.connection_id.as_deref(), &req.connection_name).await {
+        Ok(c) => c,
+        Err(e) => {
+            respond(stream, "404 Not Found", &e).await;
+            return;
+        }
+    };
+    let event = McpExecuteQueryEvent {
+        connection_id: config.id.clone(),
+        database: req.database.unwrap_or_else(|| config.database.clone().unwrap_or_default()),
+        sql: req.sql,
+        allow_writes: req.allow_writes.unwrap_or(false),
+        allow_dangerous: req.allow_dangerous.unwrap_or(false),
+    };
+    let _ = app.emit("mcp-execute-query", &event);
+    respond(stream, "200 OK", "ok").await;
+}
+
+async fn handle_list_tables_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: ListTablesRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let config = match resolve_connection(state, req.connection_id.as_deref(), &req.connection_name).await {
+        Ok(c) => c,
+        Err(e) => {
+            respond_error(stream, "404 Not Found", &e).await;
+            return;
+        }
+    };
+    let database = req.database.unwrap_or_else(|| config.database.clone().unwrap_or_default());
+    let schema = req.schema.unwrap_or_default();
+    if let Err(e) = check_visible_database(&config, &database) {
+        respond_error(stream, "403 Forbidden", &e).await;
+        return;
+    }
+    match dbx_core::schema::list_tables_core(state, &config.id, &database, &schema, None, None, None, None).await {
+        Ok(tables) => respond_json(stream, &tables).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_describe_table_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: DescribeTableRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let config = match resolve_connection(state, req.connection_id.as_deref(), &req.connection_name).await {
+        Ok(c) => c,
+        Err(e) => {
+            respond_error(stream, "404 Not Found", &e).await;
+            return;
+        }
+    };
+    let database = req.database.unwrap_or_else(|| config.database.clone().unwrap_or_default());
+    let schema = req.schema.unwrap_or_default();
+    if let Err(e) = check_visible_database(&config, &database) {
+        respond_error(stream, "403 Forbidden", &e).await;
+        return;
+    }
+    match dbx_core::schema::get_columns_core(state, &config.id, &database, &schema, &req.table).await {
+        Ok(columns) => respond_json(stream, &columns).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_mongo_list_collections_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: ListTablesRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let Some((pool_key, database, _connection_id)) =
+        resolve_mongo_pool_key(state, req.connection_id.as_deref(), &req.connection_name, req.database, stream).await
+    else {
+        return;
+    };
+    match dbx_core::mongo_ops::mongo_list_collections_core(state, &pool_key, &database).await {
+        Ok(collections) => respond_json(stream, &collections).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_mongo_find_documents_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: MongoFindDocumentsRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let Some((pool_key, database, _connection_id)) =
+        resolve_mongo_pool_key(state, req.connection_id.as_deref(), &req.connection_name, req.database, stream).await
+    else {
+        return;
+    };
+    match dbx_core::mongo_ops::mongo_find_documents_core(
+        state,
+        &pool_key,
+        &database,
+        &req.collection,
+        req.skip.unwrap_or(0),
+        req.limit.unwrap_or(100),
+        req.filter.as_deref(),
+        req.projection.as_deref(),
+        req.sort.as_deref(),
+    )
+    .await
+    {
+        Ok(result) => respond_json(stream, &result).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_mongo_server_version_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: MongoServerVersionRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let Some((pool_key, database, _connection_id)) =
+        resolve_mongo_pool_key(state, req.connection_id.as_deref(), &req.connection_name, req.database, stream).await
+    else {
+        return;
+    };
+    match dbx_core::mongo_ops::mongo_server_version_core(state, &pool_key, &database).await {
+        Ok(version) => respond_json(stream, &version).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_mongo_collection_stats_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: MongoCollectionStatsRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let Some((pool_key, database, _connection_id)) =
+        resolve_mongo_pool_key(state, req.connection_id.as_deref(), &req.connection_name, req.database, stream).await
+    else {
+        return;
+    };
+    match dbx_core::mongo_ops::mongo_collection_stats_core(state, &pool_key, &database, &req.collection, req.scale)
+        .await
+    {
+        Ok(result) => respond_json(stream, &result).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_mongo_aggregate_documents_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: MongoAggregateDocumentsRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let Some((pool_key, database, _connection_id)) =
+        resolve_mongo_pool_key(state, req.connection_id.as_deref(), &req.connection_name, req.database, stream).await
+    else {
+        return;
+    };
+    match dbx_core::mongo_ops::mongo_aggregate_documents_core(
+        state,
+        &pool_key,
+        &database,
+        &req.collection,
+        &req.pipeline_json,
+        req.max_rows,
+    )
+    .await
+    {
+        Ok(result) => respond_json(stream, &result).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_mongo_create_index_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: MongoCreateIndexRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let Some((pool_key, database, connection_id)) =
+        resolve_mongo_pool_key(state, req.connection_id.as_deref(), &req.connection_name, req.database, stream).await
+    else {
+        return;
+    };
+    if let Err(e) = ensure_connection_writable(state, &connection_id, "Create index").await {
+        respond_error(stream, "403 Forbidden", &e).await;
+        return;
+    }
+    match dbx_core::mongo_ops::mongo_create_index_core(
+        state,
+        &pool_key,
+        &database,
+        &req.collection,
+        &req.keys_json,
+        req.options_json.as_deref(),
+    )
+    .await
+    {
+        Ok(name) => respond_json(stream, &serde_json::json!({ "name": name })).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_mongo_drop_indexes_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: MongoDropIndexesRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let Some((pool_key, database, connection_id)) =
+        resolve_mongo_pool_key(state, req.connection_id.as_deref(), &req.connection_name, req.database, stream).await
+    else {
+        return;
+    };
+    if let Err(e) = ensure_connection_writable(state, &connection_id, "Drop indexes").await {
+        respond_error(stream, "403 Forbidden", &e).await;
+        return;
+    }
+    match dbx_core::mongo_ops::mongo_drop_indexes_core(
+        state,
+        &pool_key,
+        &database,
+        &req.collection,
+        req.indexes_json.as_deref(),
+        req.single,
+    )
+    .await
+    {
+        Ok(result) => respond_json(stream, &result).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_mongo_drop_collection_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: MongoDropCollectionRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let Some((pool_key, database, connection_id)) =
+        resolve_mongo_pool_key(state, req.connection_id.as_deref(), &req.connection_name, req.database, stream).await
+    else {
+        return;
+    };
+    if let Err(e) = ensure_connection_writable(state, &connection_id, "Drop collection").await {
+        respond_error(stream, "403 Forbidden", &e).await;
+        return;
+    }
+    match dbx_core::mongo_ops::mongo_drop_collection_core(state, &pool_key, &database, &req.collection).await {
+        Ok(()) => respond_json(stream, &serde_json::json!({ "ok": true })).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_mongo_insert_documents_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: MongoInsertDocumentsRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let Some((pool_key, database, connection_id)) =
+        resolve_mongo_pool_key(state, req.connection_id.as_deref(), &req.connection_name, req.database, stream).await
+    else {
+        return;
+    };
+    if let Err(e) = ensure_connection_writable(state, &connection_id, "Insert").await {
+        respond_error(stream, "403 Forbidden", &e).await;
+        return;
+    }
+    match dbx_core::mongo_ops::mongo_insert_documents_core(state, &pool_key, &database, &req.collection, &req.docs_json)
+        .await
+    {
+        Ok(inserted) => respond_json(stream, &serde_json::json!({ "affected_rows": inserted })).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_mongo_update_documents_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: MongoUpdateDocumentsRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let Some((pool_key, database, connection_id)) =
+        resolve_mongo_pool_key(state, req.connection_id.as_deref(), &req.connection_name, req.database, stream).await
+    else {
+        return;
+    };
+    if let Err(e) = ensure_connection_writable(state, &connection_id, "Update").await {
+        respond_error(stream, "403 Forbidden", &e).await;
+        return;
+    }
+    match dbx_core::mongo_ops::mongo_update_documents_core(
+        state,
+        &pool_key,
+        &database,
+        &req.collection,
+        &req.filter_json,
+        &req.update_json,
+        req.many,
+        req.options_json.as_deref(),
+    )
+    .await
+    {
+        Ok(modified) => respond_json(stream, &serde_json::json!({ "affected_rows": modified })).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_mongo_delete_documents_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: MongoDeleteDocumentsRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let Some((pool_key, database, connection_id)) =
+        resolve_mongo_pool_key(state, req.connection_id.as_deref(), &req.connection_name, req.database, stream).await
+    else {
+        return;
+    };
+    if let Err(e) = ensure_connection_writable(state, &connection_id, "Delete").await {
+        respond_error(stream, "403 Forbidden", &e).await;
+        return;
+    }
+    match dbx_core::mongo_ops::mongo_delete_documents_core(
+        state,
+        &pool_key,
+        &database,
+        &req.collection,
+        &req.filter_json,
+        req.many,
+    )
+    .await
+    {
+        Ok(deleted) => respond_json(stream, &serde_json::json!({ "affected_rows": deleted })).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_redis_execute_command_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: RedisCommandRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let config = match resolve_connection(state, req.connection_id.as_deref(), &req.connection_name).await {
+        Ok(c) => c,
+        Err(e) => {
+            respond_error(stream, "404 Not Found", &e).await;
+            return;
+        }
+    };
+    let database = req.db.to_string();
+    if let Err(e) = check_visible_database(&config, &database) {
+        respond_error(stream, "403 Forbidden", &e).await;
+        return;
+    }
+    if let Some(name) = dbx_core::query::connection_readonly_name(state, &config.id).await {
+        let cmd_name = req.command.split_whitespace().next().unwrap_or("");
+        if dbx_core::db::redis_driver::classify_command(cmd_name)
+            != dbx_core::db::redis_driver::RedisCommandSafety::Allowed
+        {
+            respond_error(
+                stream,
+                "403 Forbidden",
+                &format!(
+                    "Read-only mode: connection '{}' has read-only protection enabled. Command '{}' blocked.",
+                    name, cmd_name
+                ),
+            )
+            .await;
+            return;
+        }
+    }
+    match dbx_core::redis_ops::redis_execute_command_core(
+        state,
+        &config.id,
+        req.db,
+        &req.command,
+        req.skip_safety_check.unwrap_or(false),
+    )
+    .await
+    {
+        Ok(result) => respond_json(stream, &result).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
+
+async fn handle_execute_query_data(state: &Arc<AppState>, body: &str, stream: &mut tokio::net::TcpStream) {
+    let req: ExecuteQueryRequest = match serde_json::from_str(body) {
+        Ok(r) => r,
+        Err(_) => {
+            respond_error(stream, "400 Bad Request", "Invalid JSON").await;
+            return;
+        }
+    };
+    let config = match resolve_connection(state, req.connection_id.as_deref(), &req.connection_name).await {
+        Ok(c) => c,
+        Err(e) => {
+            respond_error(stream, "404 Not Found", &e).await;
+            return;
+        }
+    };
+    let database = req.database.unwrap_or_else(|| config.database.clone().unwrap_or_default());
+    if let Err(e) = check_visible_database(&config, &database) {
+        respond_error(stream, "403 Forbidden", &e).await;
+        return;
+    }
+    // Read-only check: reject if the connection has read-only protection and the SQL is a write
+    if let Err(e) = dbx_core::query::check_read_only_for_connection(state, &config.id, &req.sql).await {
+        respond_error(stream, "403 Forbidden", &e).await;
+        return;
+    }
+    match dbx_core::query::execute_sql_statement(state, &config.id, &database, &req.sql, req.schema.as_deref(), None)
+        .await
+    {
+        Ok(result) => respond_json(stream, &result).await,
+        Err(e) => respond_error(stream, "500 Internal Server Error", &e).await,
+    }
+}
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
new file mode 100644
index 0000000..a219fb3
--- /dev/null
+++ b/src-tauri/src/commands/mod.rs
@@ -0,0 +1,50 @@
+pub mod agents;
+pub mod ai;
+pub mod app_settings;
+pub mod cloud_sync;
+pub mod connection;
+#[allow(dead_code, unused_imports)]
+mod connection_secrets;
+pub mod csv_export;
+pub mod data_compare;
+pub mod database_export;
+pub mod deep_link;
+pub mod document_cmd;
+pub mod etcd_cmd;
+pub mod external_db;
+pub mod external_sql;
+pub mod fs_open;
+pub mod history;
+pub mod keychain;
+pub mod list_sql_files;
+pub mod mcp;
+pub mod mcp_bridge;
+pub mod mongo_cmd;
+#[cfg(feature = "mq-admin")]
+pub mod mq_cmd;
+pub mod nacos_cmd;
+pub mod plugins;
+pub mod query;
+pub mod query_cancel;
+pub mod query_result_export;
+pub mod redis_cmd;
+pub mod redis_pubsub_server;
+pub mod saved_sql;
+pub mod schema;
+pub mod schema_cache;
+pub mod schema_diff;
+pub mod sql_file;
+pub mod sqlite_backup;
+pub mod ssh_config;
+pub mod support_info;
+pub mod system_fonts;
+pub mod tab_runtime_cache;
+pub mod table_export;
+pub mod table_import;
+pub mod text_export;
+pub mod transfer;
+pub mod tunnel_profiles;
+pub mod update;
+pub mod window_controls;
+pub mod xlsx_export;
+pub mod zookeeper_cmd;
diff --git a/src-tauri/src/commands/mongo_cmd.rs b/src-tauri/src/commands/mongo_cmd.rs
new file mode 100644
index 0000000..b3f29a0
--- /dev/null
+++ b/src-tauri/src/commands/mongo_cmd.rs
@@ -0,0 +1,307 @@
+use std::future::Future;
+use std::sync::Arc;
+use tauri::State;
+
+use crate::commands::connection::{ensure_connection_writable, AppState};
+use dbx_core::db::mongo_driver::MongoDocumentResult;
+
+async fn run_cancellable<T, F>(state: &Arc<AppState>, execution_id: Option<String>, future: F) -> Result<T, String>
+where
+    F: Future<Output = Result<T, String>>,
+{
+    let registered_query =
+        execution_id.as_ref().filter(|id| !id.trim().is_empty()).map(|id| state.running_queries.register(id.clone()));
+    if let Some(query) = registered_query.as_ref() {
+        let token = query.token();
+        tokio::select! {
+            biased;
+            _ = token.cancelled() => Err(dbx_core::query::canceled_error()),
+            result = future => result,
+        }
+    } else {
+        future.await
+    }
+}
+
+#[tauri::command]
+pub async fn mongo_list_databases(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<Vec<String>, String> {
+    dbx_core::mongo_ops::mongo_list_databases_core(&state, &connection_id).await
+}
+
+#[tauri::command]
+pub async fn mongo_list_collections(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+) -> Result<Vec<dbx_core::document_ops::CollectionInfo>, String> {
+    dbx_core::mongo_ops::mongo_list_collections_core(&state, &connection_id, &database).await
+}
+
+#[tauri::command]
+pub async fn vector_collection_detail(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+) -> Result<dbx_core::db::vector_driver::CollectionInfo, String> {
+    dbx_core::schema::get_vector_collection_detail_core(&state, &connection_id, &database, &collection).await
+}
+
+#[tauri::command]
+pub async fn mongo_create_database(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Create database").await?;
+    dbx_core::mongo_ops::mongo_create_database_core(&state, &connection_id, &database).await
+}
+
+#[tauri::command]
+pub async fn mongo_drop_database(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Drop database").await?;
+    dbx_core::mongo_ops::mongo_drop_database_core(&state, &connection_id, &database).await
+}
+
+#[tauri::command]
+pub async fn mongo_drop_collection(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Drop collection").await?;
+    dbx_core::mongo_ops::mongo_drop_collection_core(&state, &connection_id, &database, &collection).await
+}
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+pub async fn mongo_find_documents(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    skip: u64,
+    limit: i64,
+    filter: Option<String>,
+    projection: Option<String>,
+    sort: Option<String>,
+    execution_id: Option<String>,
+) -> Result<MongoDocumentResult, String> {
+    crate::commands::document_cmd::document_find_documents(
+        state,
+        connection_id,
+        database,
+        collection,
+        skip,
+        limit,
+        filter,
+        projection,
+        sort,
+        execution_id,
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn mongo_server_version(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    execution_id: Option<String>,
+) -> Result<String, String> {
+    let app = state.inner().clone();
+    run_cancellable(&app, execution_id, dbx_core::mongo_ops::mongo_server_version_core(&app, &connection_id, &database))
+        .await
+}
+
+#[tauri::command]
+pub async fn mongo_collection_stats(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    scale: Option<serde_json::Number>,
+    execution_id: Option<String>,
+) -> Result<dbx_core::db::mongo_driver::MongoCollectionStatsResult, String> {
+    let app = state.inner().clone();
+    run_cancellable(
+        &app,
+        execution_id,
+        dbx_core::mongo_ops::mongo_collection_stats_core(&app, &connection_id, &database, &collection, scale),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn mongo_aggregate_documents(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    pipeline_json: String,
+    max_rows: Option<usize>,
+    execution_id: Option<String>,
+) -> Result<MongoDocumentResult, String> {
+    let app = state.inner().clone();
+    run_cancellable(
+        &app,
+        execution_id,
+        dbx_core::mongo_ops::mongo_aggregate_documents_core(
+            &app,
+            &connection_id,
+            &database,
+            &collection,
+            &pipeline_json,
+            max_rows,
+        ),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn mongo_create_index(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    keys_json: String,
+    options_json: Option<String>,
+) -> Result<serde_json::Value, String> {
+    ensure_connection_writable(&state, &connection_id, "Create index").await?;
+    let name = dbx_core::mongo_ops::mongo_create_index_core(
+        &state,
+        &connection_id,
+        &database,
+        &collection,
+        &keys_json,
+        options_json.as_deref(),
+    )
+    .await?;
+    Ok(serde_json::json!({ "name": name }))
+}
+
+#[tauri::command]
+pub async fn mongo_drop_indexes(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    indexes_json: Option<String>,
+    single: bool,
+) -> Result<dbx_core::db::mongo_driver::MongoDropIndexesResult, String> {
+    ensure_connection_writable(&state, &connection_id, "Drop indexes").await?;
+    dbx_core::mongo_ops::mongo_drop_indexes_core(
+        &state,
+        &connection_id,
+        &database,
+        &collection,
+        indexes_json.as_deref(),
+        single,
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn mongo_insert_document(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    doc_json: String,
+) -> Result<String, String> {
+    crate::commands::document_cmd::document_insert_document(state, connection_id, database, collection, doc_json).await
+}
+
+#[tauri::command]
+pub async fn mongo_insert_documents(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    docs_json: String,
+) -> Result<u64, String> {
+    ensure_connection_writable(&state, &connection_id, "Insert").await?;
+    dbx_core::mongo_ops::mongo_insert_documents_core(&state, &connection_id, &database, &collection, &docs_json).await
+}
+
+#[tauri::command]
+pub async fn mongo_update_document(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    id: String,
+    doc_json: String,
+    routing: Option<String>,
+) -> Result<u64, String> {
+    crate::commands::document_cmd::document_update_document(
+        state,
+        connection_id,
+        database,
+        collection,
+        id,
+        doc_json,
+        routing,
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn mongo_update_documents(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    filter_json: String,
+    update_json: String,
+    many: bool,
+    options_json: Option<String>,
+) -> Result<u64, String> {
+    ensure_connection_writable(&state, &connection_id, "Update").await?;
+    dbx_core::mongo_ops::mongo_update_documents_core(
+        &state,
+        &connection_id,
+        &database,
+        &collection,
+        &filter_json,
+        &update_json,
+        many,
+        options_json.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn mongo_delete_document(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    id: String,
+    routing: Option<String>,
+) -> Result<u64, String> {
+    crate::commands::document_cmd::document_delete_document(state, connection_id, database, collection, id, routing)
+        .await
+}
+
+#[tauri::command]
+pub async fn mongo_delete_documents(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    collection: String,
+    filter_json: String,
+    many: bool,
+) -> Result<u64, String> {
+    ensure_connection_writable(&state, &connection_id, "Delete").await?;
+    dbx_core::mongo_ops::mongo_delete_documents_core(&state, &connection_id, &database, &collection, &filter_json, many)
+        .await
+}
diff --git a/src-tauri/src/commands/mq_cmd.rs b/src-tauri/src/commands/mq_cmd.rs
new file mode 100644
index 0000000..9c5ae21
--- /dev/null
+++ b/src-tauri/src/commands/mq_cmd.rs
@@ -0,0 +1,468 @@
+//! Desktop (Tauri) commands for message queue admin operations.
+//!
+//! These are thin wrappers around `dbx_core::mq::service::*_core` functions,
+//! with read-only protection (`ensure_connection_writable`) for mutating calls.
+
+use std::sync::Arc;
+
+use tauri::State;
+
+use crate::commands::connection::{ensure_connection_writable, AppState};
+
+// ---- Test connection ----
+
+#[tauri::command]
+pub async fn mq_test_connection(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<dbx_core::mq::MqClusterInfo, String> {
+    dbx_core::mq::service::mq_test_connection_core(&state, &connection_id).await
+}
+
+// ---- Tenants ----
+
+#[tauri::command]
+pub async fn mq_list_tenants(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<Vec<dbx_core::mq::TenantInfo>, String> {
+    dbx_core::mq::service::mq_list_tenants_core(&state, &connection_id).await
+}
+
+#[tauri::command]
+pub async fn mq_get_tenant(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    name: String,
+) -> Result<dbx_core::mq::TenantInfo, String> {
+    dbx_core::mq::service::mq_get_tenant_core(&state, &connection_id, &name).await
+}
+
+#[tauri::command]
+pub async fn mq_create_tenant(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    name: String,
+    config: dbx_core::mq::TenantConfig,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Create tenant").await?;
+    dbx_core::mq::service::mq_create_tenant_core(&state, &connection_id, &name, config).await
+}
+
+#[tauri::command]
+pub async fn mq_update_tenant(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    name: String,
+    config: dbx_core::mq::TenantConfig,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Update tenant").await?;
+    dbx_core::mq::service::mq_update_tenant_core(&state, &connection_id, &name, config).await
+}
+
+#[tauri::command]
+pub async fn mq_delete_tenant(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    name: String,
+    force: bool,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Delete tenant").await?;
+    dbx_core::mq::service::mq_delete_tenant_core(&state, &connection_id, &name, force).await
+}
+
+// ---- Namespaces ----
+
+#[tauri::command]
+pub async fn mq_list_namespaces(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    tenant: String,
+) -> Result<Vec<dbx_core::mq::NamespaceInfo>, String> {
+    dbx_core::mq::service::mq_list_namespaces_core(&state, &connection_id, &tenant).await
+}
+
+#[tauri::command]
+pub async fn mq_create_namespace(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    ns: dbx_core::mq::NamespaceRef,
+    config: dbx_core::mq::NamespaceConfig,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Create namespace").await?;
+    dbx_core::mq::service::mq_create_namespace_core(&state, &connection_id, ns, config).await
+}
+
+#[tauri::command]
+pub async fn mq_delete_namespace(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    ns: dbx_core::mq::NamespaceRef,
+    force: bool,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Delete namespace").await?;
+    dbx_core::mq::service::mq_delete_namespace_core(&state, &connection_id, ns, force).await
+}
+
+#[tauri::command]
+pub async fn mq_get_namespace_policies(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    ns: dbx_core::mq::NamespaceRef,
+) -> Result<serde_json::Value, String> {
+    dbx_core::mq::service::mq_get_namespace_policies_core(&state, &connection_id, ns).await
+}
+
+// ---- Topics ----
+
+#[tauri::command]
+pub async fn mq_list_topics(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    ns: dbx_core::mq::NamespaceRef,
+    opts: dbx_core::mq::ListTopicsOpts,
+) -> Result<Vec<dbx_core::mq::TopicInfo>, String> {
+    dbx_core::mq::service::mq_list_topics_core(&state, &connection_id, ns, opts).await
+}
+
+#[tauri::command]
+pub async fn mq_create_topic(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    partitions: Option<u32>,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Create topic").await?;
+    dbx_core::mq::service::mq_create_topic_core(&state, &connection_id, topic, partitions).await
+}
+
+#[tauri::command]
+pub async fn mq_delete_topic(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    force: bool,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Delete topic").await?;
+    dbx_core::mq::service::mq_delete_topic_core(&state, &connection_id, topic, force).await
+}
+
+#[tauri::command]
+pub async fn mq_update_partitions(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    partitions: u32,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Update partitions").await?;
+    dbx_core::mq::service::mq_update_partitions_core(&state, &connection_id, topic, partitions).await
+}
+
+#[tauri::command]
+pub async fn mq_get_topic_stats(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+) -> Result<dbx_core::mq::TopicStats, String> {
+    dbx_core::mq::service::mq_get_topic_stats_core(&state, &connection_id, topic).await
+}
+
+#[tauri::command]
+pub async fn mq_get_topic_internal_stats(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+) -> Result<serde_json::Value, String> {
+    dbx_core::mq::service::mq_get_topic_internal_stats_core(&state, &connection_id, topic).await
+}
+
+// ---- Subscriptions ----
+
+#[tauri::command]
+pub async fn mq_list_subscriptions(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+) -> Result<Vec<dbx_core::mq::SubscriptionInfo>, String> {
+    dbx_core::mq::service::mq_list_subscriptions_core(&state, &connection_id, topic).await
+}
+
+#[tauri::command]
+pub async fn mq_create_subscription(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    pos: dbx_core::mq::ResetPosition,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Create subscription").await?;
+    dbx_core::mq::service::mq_create_subscription_core(&state, &connection_id, topic, sub, pos).await
+}
+
+#[tauri::command]
+pub async fn mq_delete_subscription(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    force: bool,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Delete subscription").await?;
+    dbx_core::mq::service::mq_delete_subscription_core(&state, &connection_id, topic, sub, force).await
+}
+
+#[tauri::command]
+pub async fn mq_skip_messages(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    count: dbx_core::mq::SkipCount,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Skip messages").await?;
+    dbx_core::mq::service::mq_skip_messages_core(&state, &connection_id, topic, sub, count).await
+}
+
+#[tauri::command]
+pub async fn mq_reset_cursor(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    pos: dbx_core::mq::ResetPosition,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Reset cursor").await?;
+    dbx_core::mq::service::mq_reset_cursor_core(&state, &connection_id, topic, sub, pos).await
+}
+
+#[tauri::command]
+pub async fn mq_clear_backlog(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Clear backlog").await?;
+    dbx_core::mq::service::mq_clear_backlog_core(&state, &connection_id, topic, sub).await
+}
+
+#[tauri::command]
+pub async fn mq_peek_messages(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    count: u32,
+    options: Option<dbx_core::mq::PeekMessagesOptions>,
+) -> Result<Vec<dbx_core::mq::PeekedMessage>, String> {
+    dbx_core::mq::service::mq_peek_messages_core(&state, &connection_id, topic, sub, count, options).await
+}
+
+#[tauri::command]
+pub async fn mq_expire_messages(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+    expire_seconds: i64,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Expire messages").await?;
+    dbx_core::mq::service::mq_expire_messages_core(&state, &connection_id, topic, sub, expire_seconds).await
+}
+
+// ---- Producers / consumers ----
+
+#[tauri::command]
+pub async fn mq_list_producers(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+) -> Result<Vec<dbx_core::mq::ProducerInfo>, String> {
+    dbx_core::mq::service::mq_list_producers_core(&state, &connection_id, topic).await
+}
+
+#[tauri::command]
+pub async fn mq_list_consumers(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: String,
+) -> Result<Vec<dbx_core::mq::ConsumerInfo>, String> {
+    dbx_core::mq::service::mq_list_consumers_core(&state, &connection_id, topic, sub).await
+}
+
+#[tauri::command]
+pub async fn mq_unload_topic(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Unload topic").await?;
+    dbx_core::mq::service::mq_unload_topic_core(&state, &connection_id, topic).await
+}
+
+// ---- Rate limits / quotas / retention ----
+
+#[tauri::command]
+pub async fn mq_set_publish_rate(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    rate: dbx_core::mq::PublishRate,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Set publish rate").await?;
+    dbx_core::mq::service::mq_set_publish_rate_core(&state, &connection_id, scope, rate).await
+}
+
+#[tauri::command]
+pub async fn mq_set_dispatch_rate(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    rate: dbx_core::mq::DispatchRate,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Set dispatch rate").await?;
+    dbx_core::mq::service::mq_set_dispatch_rate_core(&state, &connection_id, scope, rate).await
+}
+
+#[tauri::command]
+pub async fn mq_set_subscribe_rate(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    rate: dbx_core::mq::SubscribeRate,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Set subscribe rate").await?;
+    dbx_core::mq::service::mq_set_subscribe_rate_core(&state, &connection_id, scope, rate).await
+}
+
+#[tauri::command]
+pub async fn mq_set_backlog_quota(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    quota: dbx_core::mq::BacklogQuota,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Set backlog quota").await?;
+    dbx_core::mq::service::mq_set_backlog_quota_core(&state, &connection_id, scope, quota).await
+}
+
+#[tauri::command]
+pub async fn mq_set_retention(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    retention: dbx_core::mq::RetentionPolicy,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Set retention").await?;
+    dbx_core::mq::service::mq_set_retention_core(&state, &connection_id, scope, retention).await
+}
+
+#[tauri::command]
+pub async fn mq_get_effective_policies(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+) -> Result<serde_json::Value, String> {
+    dbx_core::mq::service::mq_get_effective_policies_core(&state, &connection_id, scope).await
+}
+
+// ---- Permissions ----
+
+#[tauri::command]
+pub async fn mq_grant_permission(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    role: String,
+    actions: Vec<dbx_core::mq::AuthAction>,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Grant permission").await?;
+    dbx_core::mq::service::mq_grant_permission_core(&state, &connection_id, scope, role, actions).await
+}
+
+#[tauri::command]
+pub async fn mq_revoke_permission(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+    role: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Revoke permission").await?;
+    dbx_core::mq::service::mq_revoke_permission_core(&state, &connection_id, scope, role).await
+}
+
+#[tauri::command]
+pub async fn mq_list_permissions(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    scope: dbx_core::mq::PolicyScope,
+) -> Result<dbx_core::mq::PermissionMap, String> {
+    dbx_core::mq::service::mq_list_permissions_core(&state, &connection_id, scope).await
+}
+
+// ---- Client tokens ----
+
+#[tauri::command]
+pub async fn mq_issue_token(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::mq::MqTokenIssueRequest,
+) -> Result<dbx_core::mq::MqIssuedToken, String> {
+    ensure_connection_writable(&state, &connection_id, "Issue MQ token").await?;
+    dbx_core::mq::service::mq_issue_token_core(&state, &connection_id, req).await
+}
+
+#[tauri::command]
+pub async fn mq_list_token_records(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    subject: Option<String>,
+) -> Result<Vec<dbx_core::mq::MqTokenRecord>, String> {
+    dbx_core::mq::service::mq_list_token_records_core(&state, &connection_id, subject).await
+}
+
+// ---- Monitoring ----
+
+#[tauri::command]
+pub async fn mq_get_backlog(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    topic: dbx_core::mq::TopicRef,
+    sub: Option<String>,
+) -> Result<dbx_core::mq::BacklogStats, String> {
+    dbx_core::mq::service::mq_get_backlog_core(&state, &connection_id, topic, sub).await
+}
+
+#[tauri::command]
+pub async fn mq_get_cluster_info(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<dbx_core::mq::ClusterInfo, String> {
+    dbx_core::mq::service::mq_get_cluster_info_core(&state, &connection_id).await
+}
+
+// ---- Raw request (escape hatch) ----
+
+#[tauri::command]
+pub async fn mq_raw_request(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::mq::MqRawRequest,
+) -> Result<dbx_core::mq::MqRawResponse, String> {
+    if req.is_mutating() {
+        ensure_connection_writable(&state, &connection_id, "MQ admin write").await?;
+    }
+    dbx_core::mq::service::mq_raw_request_core(&state, &connection_id, req).await
+}
+
+// ---- Message production ----
+
+#[tauri::command]
+pub async fn mq_send_message(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::mq::SendMessageRequest,
+) -> Result<dbx_core::mq::SendMessageResponse, String> {
+    dbx_core::mq::service::mq_send_message_core(&state, &connection_id, req).await
+}
diff --git a/src-tauri/src/commands/nacos_cmd.rs b/src-tauri/src/commands/nacos_cmd.rs
new file mode 100644
index 0000000..e94ebea
--- /dev/null
+++ b/src-tauri/src/commands/nacos_cmd.rs
@@ -0,0 +1,138 @@
+use std::sync::Arc;
+
+use tauri::State;
+
+use crate::commands::connection::AppState;
+
+#[tauri::command]
+pub async fn nacos_test_connection(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<dbx_core::nacos::NacosConnectionInfo, String> {
+    dbx_core::nacos::service::nacos_test_connection_core(&state, &connection_id).await
+}
+
+#[tauri::command]
+pub async fn nacos_list_namespaces(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<Vec<dbx_core::nacos::NacosNamespaceInfo>, String> {
+    dbx_core::nacos::service::nacos_list_namespaces_core(&state, &connection_id).await
+}
+
+#[tauri::command]
+pub async fn nacos_create_namespace(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosNamespaceCreate,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_create_namespace_core(&state, &connection_id, req).await
+}
+
+#[tauri::command]
+pub async fn nacos_update_namespace(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosNamespaceUpdate,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_update_namespace_core(&state, &connection_id, req).await
+}
+
+#[tauri::command]
+pub async fn nacos_list_configs(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    query: dbx_core::nacos::NacosConfigQuery,
+) -> Result<dbx_core::nacos::NacosConfigList, String> {
+    dbx_core::nacos::service::nacos_list_configs_core(&state, &connection_id, query).await
+}
+
+#[tauri::command]
+pub async fn nacos_get_config(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: dbx_core::nacos::NacosConfigKey,
+) -> Result<dbx_core::nacos::NacosConfigItem, String> {
+    dbx_core::nacos::service::nacos_get_config_core(&state, &connection_id, key).await
+}
+
+#[tauri::command]
+pub async fn nacos_publish_config(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosConfigUpsert,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_publish_config_core(&state, &connection_id, req).await
+}
+
+#[tauri::command]
+pub async fn nacos_delete_config(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: dbx_core::nacos::NacosConfigKey,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_delete_config_core(&state, &connection_id, key).await
+}
+
+#[tauri::command]
+pub async fn nacos_list_config_history(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    query: dbx_core::nacos::NacosConfigHistoryQuery,
+) -> Result<dbx_core::nacos::NacosConfigHistoryList, String> {
+    dbx_core::nacos::service::nacos_list_config_history_core(&state, &connection_id, query).await
+}
+
+#[tauri::command]
+pub async fn nacos_get_config_history(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: dbx_core::nacos::NacosConfigHistoryKey,
+) -> Result<dbx_core::nacos::NacosConfigItem, String> {
+    dbx_core::nacos::service::nacos_get_config_history_core(&state, &connection_id, key).await
+}
+
+#[tauri::command]
+pub async fn nacos_rollback_config(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosConfigRollbackRequest,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_rollback_config_core(&state, &connection_id, req).await
+}
+
+#[tauri::command]
+pub async fn nacos_list_services(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    query: dbx_core::nacos::NacosServiceQuery,
+) -> Result<dbx_core::nacos::NacosServiceList, String> {
+    dbx_core::nacos::service::nacos_list_services_core(&state, &connection_id, query).await
+}
+
+#[tauri::command]
+pub async fn nacos_list_instances(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    query: dbx_core::nacos::NacosInstanceQuery,
+) -> Result<Vec<dbx_core::nacos::NacosInstanceInfo>, String> {
+    dbx_core::nacos::service::nacos_list_instances_core(&state, &connection_id, query).await
+}
+
+#[tauri::command]
+pub async fn nacos_update_instance(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosInstanceUpdate,
+) -> Result<(), String> {
+    dbx_core::nacos::service::nacos_update_instance_core(&state, &connection_id, req).await
+}
+
+#[tauri::command]
+pub async fn nacos_raw_request(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    req: dbx_core::nacos::NacosRawRequest,
+) -> Result<dbx_core::nacos::NacosRawResponse, String> {
+    dbx_core::nacos::service::nacos_raw_request_core(&state, &connection_id, req).await
+}
diff --git a/src-tauri/src/commands/plugins.rs b/src-tauri/src/commands/plugins.rs
new file mode 100644
index 0000000..b9fb457
--- /dev/null
+++ b/src-tauri/src/commands/plugins.rs
@@ -0,0 +1,137 @@
+use std::sync::Arc;
+use tauri::{Emitter, State};
+
+use dbx_core::agent_service::AgentProgressEvent;
+use dbx_core::jdbc::{
+    self, JdbcDriverInfo, JdbcLocalBundleInfo, JdbcMavenBundleInfo, JdbcMavenInstallRequest, JdbcPluginStatus,
+};
+use dbx_core::plugins::InstalledPlugin;
+
+use super::connection::AppState;
+
+#[tauri::command]
+pub async fn list_plugins(state: State<'_, Arc<AppState>>) -> Result<Vec<InstalledPlugin>, String> {
+    let root_dir = state.plugins.root_dir().to_path_buf();
+    tauri::async_runtime::spawn_blocking(move || dbx_core::plugins::PluginRegistry::new(root_dir).list_installed())
+        .await
+        .map_err(|err| err.to_string())?
+}
+
+#[tauri::command]
+pub async fn jdbc_plugin_status(state: State<'_, Arc<AppState>>) -> Result<JdbcPluginStatus, String> {
+    jdbc::get_jdbc_plugin_status(state.plugins.root_dir()).await
+}
+
+#[tauri::command]
+pub async fn install_jdbc_plugin(
+    app: tauri::AppHandle,
+    state: State<'_, Arc<AppState>>,
+) -> Result<JdbcPluginStatus, String> {
+    let app_handle = app.clone();
+    state.remove_external_driver_pools("jdbc").await;
+    jdbc::install_jdbc_plugin_with_progress(state.plugins.root_dir(), move |event| {
+        emit_agent_progress(&app_handle, event);
+    })
+    .await
+}
+
+#[tauri::command]
+pub async fn install_jdbc_plugin_local(
+    state: State<'_, Arc<AppState>>,
+    path: String,
+) -> Result<JdbcPluginStatus, String> {
+    state.remove_external_driver_pools("jdbc").await;
+    jdbc::install_jdbc_plugin_from_file(state.plugins.root_dir(), &path).await
+}
+
+#[tauri::command]
+pub async fn uninstall_jdbc_plugin(state: State<'_, Arc<AppState>>) -> Result<JdbcPluginStatus, String> {
+    state.remove_external_driver_pools("jdbc").await;
+    let root_dir = state.plugins.root_dir().to_path_buf();
+    tauri::async_runtime::spawn_blocking(move || jdbc::uninstall_jdbc_plugin(&root_dir))
+        .await
+        .map_err(|err| err.to_string())?
+}
+
+#[tauri::command]
+pub async fn list_jdbc_drivers(state: State<'_, Arc<AppState>>) -> Result<Vec<JdbcDriverInfo>, String> {
+    let root_dir = state.plugins.root_dir().to_path_buf();
+    tauri::async_runtime::spawn_blocking(move || jdbc::list_jdbc_drivers(&root_dir))
+        .await
+        .map_err(|err| err.to_string())?
+}
+
+#[tauri::command]
+pub async fn list_jdbc_maven_bundles(state: State<'_, Arc<AppState>>) -> Result<Vec<JdbcMavenBundleInfo>, String> {
+    let root_dir = state.plugins.root_dir().to_path_buf();
+    tauri::async_runtime::spawn_blocking(move || jdbc::list_jdbc_maven_bundles(&root_dir))
+        .await
+        .map_err(|err| err.to_string())?
+}
+
+#[tauri::command]
+pub async fn list_jdbc_local_bundles(state: State<'_, Arc<AppState>>) -> Result<Vec<JdbcLocalBundleInfo>, String> {
+    let root_dir = state.plugins.root_dir().to_path_buf();
+    tauri::async_runtime::spawn_blocking(move || jdbc::list_jdbc_local_bundles(&root_dir))
+        .await
+        .map_err(|err| err.to_string())?
+}
+
+#[tauri::command]
+pub async fn install_jdbc_driver_from_maven(
+    state: State<'_, Arc<AppState>>,
+    request: JdbcMavenInstallRequest,
+) -> Result<Vec<JdbcDriverInfo>, String> {
+    let env = state.external_driver_runtime_env("jdbc")?;
+    jdbc::install_jdbc_driver_from_maven(state.plugins.root_dir(), request, env).await
+}
+
+#[tauri::command]
+pub async fn install_prestosql_jdbc_driver(state: State<'_, Arc<AppState>>) -> Result<Vec<JdbcDriverInfo>, String> {
+    jdbc::install_prestosql_jdbc_driver(state.plugins.root_dir()).await
+}
+
+#[tauri::command]
+pub async fn import_jdbc_drivers(
+    state: State<'_, Arc<AppState>>,
+    paths: Vec<String>,
+) -> Result<Vec<JdbcDriverInfo>, String> {
+    let root_dir = state.plugins.root_dir().to_path_buf();
+    tauri::async_runtime::spawn_blocking(move || jdbc::import_jdbc_drivers(&root_dir, &paths))
+        .await
+        .map_err(|err| err.to_string())?
+}
+
+#[tauri::command]
+pub async fn delete_jdbc_driver(state: State<'_, Arc<AppState>>, path: String) -> Result<Vec<JdbcDriverInfo>, String> {
+    let root_dir = state.plugins.root_dir().to_path_buf();
+    tauri::async_runtime::spawn_blocking(move || jdbc::delete_jdbc_driver(&root_dir, &path))
+        .await
+        .map_err(|err| err.to_string())?
+}
+
+#[tauri::command]
+pub async fn delete_jdbc_maven_bundle(
+    state: State<'_, Arc<AppState>>,
+    bundle_id: String,
+) -> Result<Vec<JdbcDriverInfo>, String> {
+    let root_dir = state.plugins.root_dir().to_path_buf();
+    tauri::async_runtime::spawn_blocking(move || jdbc::delete_jdbc_maven_bundle(&root_dir, &bundle_id))
+        .await
+        .map_err(|err| err.to_string())?
+}
+
+#[tauri::command]
+pub async fn delete_jdbc_local_bundle(
+    state: State<'_, Arc<AppState>>,
+    bundle_id: String,
+) -> Result<Vec<JdbcDriverInfo>, String> {
+    let root_dir = state.plugins.root_dir().to_path_buf();
+    tauri::async_runtime::spawn_blocking(move || jdbc::delete_jdbc_local_bundle(&root_dir, &bundle_id))
+        .await
+        .map_err(|err| err.to_string())?
+}
+
+fn emit_agent_progress(app: &tauri::AppHandle, event: AgentProgressEvent) {
+    let _ = app.emit("agent-install-progress", event);
+}
diff --git a/src-tauri/src/commands/query.rs b/src-tauri/src/commands/query.rs
new file mode 100644
index 0000000..6a26d1f
--- /dev/null
+++ b/src-tauri/src/commands/query.rs
@@ -0,0 +1,629 @@
+use std::sync::Arc;
+use std::time::Instant;
+use tauri::State;
+
+use crate::commands::connection::AppState;
+use dbx_core::db;
+use dbx_core::models::connection::DatabaseType;
+use dbx_core::query_cancel::RunningTaskMetadata;
+use dbx_core::sql::split_sql_statements;
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+pub async fn execute_query(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    sql: String,
+    schema: Option<String>,
+    execution_id: Option<String>,
+    max_rows: Option<usize>,
+    fetch_size: Option<usize>,
+    page_size: Option<usize>,
+    result_session_id: Option<String>,
+    client_session_id: Option<String>,
+    timeout_secs: Option<u64>,
+) -> Result<db::QueryResult, String> {
+    let execution_id = execution_id.filter(|id| !id.trim().is_empty());
+    let registered_query = execution_id.as_ref().map(|id| {
+        state.running_queries.register_task(
+            id.clone(),
+            RunningTaskMetadata::query(connection_id.clone(), database.clone(), client_session_id.clone()),
+        )
+    });
+    let cancel_token = registered_query.as_ref().map(|query| query.token());
+
+    dbx_core::query::execute_sql_statement_with_options(
+        &state,
+        &connection_id,
+        &database,
+        &sql,
+        schema.as_deref(),
+        cancel_token,
+        dbx_core::query::QueryExecutionOptions {
+            max_rows,
+            fetch_size,
+            page_size,
+            result_session_id,
+            client_session_id,
+            timeout_secs,
+            execution_id,
+            ..Default::default()
+        },
+    )
+    .await
+}
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+pub async fn execute_multi(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    sql: String,
+    schema: Option<String>,
+    execution_id: Option<String>,
+    max_rows: Option<usize>,
+    fetch_size: Option<usize>,
+    page_size: Option<usize>,
+    result_session_id: Option<String>,
+    client_session_id: Option<String>,
+    timeout_secs: Option<u64>,
+    use_transaction: Option<bool>,
+) -> Result<Vec<dbx_core::query::ExecuteMultiResult>, String> {
+    let execution_id = execution_id.filter(|id| !id.trim().is_empty());
+    let registered_query = execution_id.as_ref().map(|id| {
+        state.running_queries.register_task(
+            id.clone(),
+            RunningTaskMetadata::query(connection_id.clone(), database.clone(), client_session_id.clone()),
+        )
+    });
+    let cancel_token = registered_query.as_ref().map(|query| query.token());
+    let trace_id = execution_id.as_deref().unwrap_or("no-execution-id").to_string();
+    let started_at = Instant::now();
+    log::info!(
+        "[query][execute_multi:start] trace_id={} connection_id={} database={} schema={:?} sql={}",
+        trace_id,
+        connection_id,
+        database,
+        schema,
+        sql
+    );
+
+    let result = dbx_core::query::execute_multi_core_with_options_for_client(
+        &state,
+        &connection_id,
+        &database,
+        &sql,
+        schema.as_deref(),
+        cancel_token,
+        dbx_core::query::QueryExecutionOptions {
+            max_rows,
+            fetch_size,
+            page_size,
+            result_session_id,
+            client_session_id,
+            timeout_secs,
+            execution_id,
+            use_transaction,
+        },
+    )
+    .await;
+    match &result {
+        Ok(results) => log::info!(
+            "[query][execute_multi:done] trace_id={} elapsed_ms={} result_count={} row_counts={:?} backend_execution_times_ms={:?}",
+            trace_id,
+            started_at.elapsed().as_millis(),
+            results.len(),
+            results.iter().map(|result| result.result.rows.len()).collect::<Vec<_>>(),
+            results.iter().map(|result| result.result.execution_time_ms).collect::<Vec<_>>()
+        ),
+        Err(error) => log::error!(
+            "[query][execute_multi:error] trace_id={} elapsed_ms={} error={}",
+            trace_id,
+            started_at.elapsed().as_millis(),
+            error
+        ),
+    }
+    result
+}
+
+#[tauri::command]
+pub async fn cancel_query(state: State<'_, Arc<AppState>>, execution_id: String) -> Result<bool, String> {
+    Ok(state.running_queries.cancel(&execution_id))
+}
+
+#[tauri::command]
+pub async fn close_query_session(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    session_id: String,
+    client_session_id: Option<String>,
+) -> Result<bool, String> {
+    dbx_core::query::close_query_session(&state, &connection_id, &database, &session_id, client_session_id.as_deref())
+        .await
+}
+
+#[tauri::command]
+pub async fn close_client_connection_session(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    client_session_id: String,
+) -> Result<bool, String> {
+    let database = if database.trim().is_empty() { None } else { Some(database.as_str()) };
+    state.close_client_session_pool(&connection_id, database, &client_session_id).await
+}
+
+#[tauri::command]
+pub async fn execute_batch(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    statements: Vec<String>,
+    schema: Option<String>,
+    timeout_secs: Option<u64>,
+) -> Result<db::QueryResult, String> {
+    dbx_core::query::execute_statements(&state, &connection_id, &database, &statements, schema.as_deref(), timeout_secs)
+        .await
+}
+
+#[tauri::command]
+pub async fn execute_script(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    sql: String,
+    schema: Option<String>,
+) -> Result<db::QueryResult, String> {
+    let db_type = {
+        let configs = state.configs.read().await;
+        configs.get(&connection_id).map(|config| config.db_type)
+    };
+
+    dbx_core::query::execute_statements(
+        &state,
+        &connection_id,
+        &database,
+        &db_type.map_or_else(
+            || split_sql_statements(&sql),
+            |db_type| dbx_core::sql::split_sql_statements_for_database(&sql, db_type),
+        ),
+        schema.as_deref(),
+        None,
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn execute_in_transaction(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    statements: Vec<String>,
+    schema: Option<String>,
+) -> Result<db::QueryResult, String> {
+    dbx_core::query::execute_statements_in_transaction(
+        &state,
+        &connection_id,
+        &database,
+        &statements,
+        schema.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn begin_manual_transaction(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: Option<String>,
+) -> Result<String, String> {
+    dbx_core::query::begin_manual_transaction(&state, &connection_id, &database, schema.as_deref()).await
+}
+
+#[tauri::command]
+pub async fn execute_in_manual_transaction(
+    state: State<'_, Arc<AppState>>,
+    txn_session_id: String,
+    sql: String,
+    database: String,
+    schema: Option<String>,
+    max_rows: Option<usize>,
+) -> Result<Vec<db::QueryResult>, String> {
+    dbx_core::query::execute_in_manual_transaction(
+        &state,
+        &txn_session_id,
+        &sql,
+        &database,
+        schema.as_deref(),
+        max_rows,
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn commit_manual_transaction(
+    state: State<'_, Arc<AppState>>,
+    txn_session_id: String,
+) -> Result<db::QueryResult, String> {
+    dbx_core::query::commit_manual_transaction(&state, &txn_session_id).await
+}
+
+#[tauri::command]
+pub async fn rollback_manual_transaction(
+    state: State<'_, Arc<AppState>>,
+    txn_session_id: String,
+) -> Result<db::QueryResult, String> {
+    dbx_core::query::rollback_manual_transaction(&state, &txn_session_id).await
+}
+
+#[tauri::command]
+pub async fn analyze_sql_references(
+    sql: String,
+    dialect: Option<String>,
+) -> Result<dbx_core::sql_analysis::SqlReferenceAnalysis, String> {
+    dbx_core::sql_analysis::analyze_sql_references(&sql, dialect.as_deref())
+}
+
+#[tauri::command]
+pub fn find_statement_at_cursor(
+    sql: String,
+    cursor_pos: usize,
+    database_type: Option<DatabaseType>,
+) -> Result<String, String> {
+    Ok(database_type
+        .map(|db_type| dbx_core::sql::find_statement_at_cursor_for_database(&sql, cursor_pos, db_type))
+        .unwrap_or_else(|| dbx_core::sql::find_statement_at_cursor(&sql, cursor_pos)))
+}
+
+#[tauri::command]
+pub fn prepare_query_pagination_execution_plan(
+    options: dbx_core::query_result_sql::QueryPaginationExecutionPlanOptions,
+) -> Result<dbx_core::query_result_sql::QueryPaginationExecutionPlan, String> {
+    Ok(dbx_core::query_result_sql::build_query_pagination_execution_plan(options))
+}
+
+#[tauri::command]
+pub fn build_sorted_query_sql(
+    options: dbx_core::query_result_sql::SortedQuerySqlOptions,
+) -> Result<dbx_core::query_result_sql::QuerySqlBuildResult, String> {
+    Ok(dbx_core::query_result_sql::build_sorted_query_sql(options))
+}
+
+#[tauri::command]
+pub fn build_explain_sql(
+    options: dbx_core::query_execution_sql::ExplainSqlOptions,
+) -> Result<dbx_core::query_execution_sql::ExplainSqlBuildResult, String> {
+    Ok(dbx_core::query_execution_sql::build_explain_sql(options))
+}
+
+#[tauri::command]
+pub fn build_dropped_file_preview_sql(
+    options: dbx_core::query_execution_sql::DroppedFilePreviewSqlOptions,
+) -> Result<Option<String>, String> {
+    Ok(dbx_core::query_execution_sql::build_dropped_file_preview_sql(options))
+}
+
+#[tauri::command]
+pub fn build_table_select_sql(options: dbx_core::sql_dialect::TableDataSelectSqlOptions) -> Result<String, String> {
+    Ok(dbx_core::sql_dialect::build_table_data_select_sql(options))
+}
+
+#[tauri::command]
+pub fn build_database_search_sql(
+    options: dbx_core::database_search_sql::DatabaseSearchSqlOptions,
+) -> Result<Option<dbx_core::database_search_sql::DatabaseSearchSql>, String> {
+    Ok(dbx_core::database_search_sql::build_database_search_sql(options))
+}
+
+#[tauri::command]
+pub fn build_search_result_where(
+    options: dbx_core::database_search_sql::SearchResultWhereOptions,
+) -> Result<String, String> {
+    Ok(dbx_core::database_search_sql::build_search_result_where(options))
+}
+
+#[tauri::command]
+pub fn build_rename_object_sql(options: dbx_core::db_admin_sql::RenameObjectSqlOptions) -> Result<String, String> {
+    dbx_core::db_admin_sql::build_rename_object_sql(options)
+}
+
+#[tauri::command]
+pub fn build_create_database_sql(options: dbx_core::db_admin_sql::CreateDatabaseSqlOptions) -> Result<String, String> {
+    dbx_core::db_admin_sql::build_create_database_sql(options)
+}
+
+#[cfg(feature = "duckdb-bundled")]
+#[tauri::command]
+pub fn build_duckdb_attach_database_sql(
+    options: dbx_core::db_admin_sql::DuckDbAttachDatabaseSqlOptions,
+) -> Result<String, String> {
+    Ok(dbx_core::db_admin_sql::build_duckdb_attach_database_sql(options))
+}
+
+#[tauri::command]
+pub fn build_drop_object_sql(options: dbx_core::db_admin_sql::DropObjectSqlOptions) -> Result<String, String> {
+    Ok(dbx_core::db_admin_sql::build_drop_object_sql(options))
+}
+
+#[tauri::command]
+pub fn build_drop_table_sql(options: dbx_core::db_admin_sql::TableAdminSqlOptions) -> Result<String, String> {
+    Ok(dbx_core::db_admin_sql::build_drop_table_sql(options))
+}
+
+#[tauri::command]
+pub fn build_drop_table_child_object_sql(
+    options: dbx_core::db_admin_sql::DropTableChildObjectSqlOptions,
+) -> Result<String, String> {
+    dbx_core::db_admin_sql::build_drop_table_child_object_sql(options)
+}
+
+#[tauri::command]
+pub fn build_empty_table_sql(options: dbx_core::db_admin_sql::TableAdminSqlOptions) -> Result<String, String> {
+    Ok(dbx_core::db_admin_sql::build_empty_table_sql(options))
+}
+
+#[tauri::command]
+pub fn build_truncate_table_sql(options: dbx_core::db_admin_sql::TableAdminSqlOptions) -> Result<String, String> {
+    Ok(dbx_core::db_admin_sql::build_truncate_table_sql(options))
+}
+
+#[tauri::command]
+pub fn build_drop_database_sql(options: dbx_core::db_admin_sql::DatabaseNameSqlOptions) -> Result<String, String> {
+    Ok(dbx_core::db_admin_sql::build_drop_database_sql(options))
+}
+
+#[tauri::command]
+pub fn build_create_schema_sql(options: dbx_core::db_admin_sql::SchemaNameSqlOptions) -> Result<String, String> {
+    dbx_core::db_admin_sql::build_create_schema_sql(options)
+}
+
+#[tauri::command]
+pub fn build_update_database_properties_sql(
+    options: dbx_core::db_admin_sql::DatabasePropertyEditSqlOptions,
+) -> Result<String, String> {
+    dbx_core::db_admin_sql::build_update_database_properties_sql(options)
+}
+
+#[tauri::command]
+pub fn build_drop_schema_sql(options: dbx_core::db_admin_sql::SchemaNameSqlOptions) -> Result<String, String> {
+    Ok(dbx_core::db_admin_sql::build_drop_schema_sql(options))
+}
+
+#[tauri::command]
+pub fn build_duplicate_table_structure_sql(
+    options: dbx_core::db_admin_sql::DuplicateTableStructureSqlOptions,
+) -> Result<String, String> {
+    Ok(dbx_core::db_admin_sql::build_duplicate_table_structure_sql(options))
+}
+
+#[tauri::command]
+pub fn build_copy_table_data_sql(options: dbx_core::db_admin_sql::CopyTableDataSqlOptions) -> Result<String, String> {
+    Ok(dbx_core::db_admin_sql::build_copy_table_data_sql(options))
+}
+
+#[tauri::command]
+pub fn build_executable_object_source_statements(
+    input: dbx_core::object_source_sql::EditableObjectSourceSqlInput,
+) -> Result<Vec<String>, String> {
+    dbx_core::object_source_sql::build_executable_object_source_statements(input)
+}
+
+#[tauri::command]
+pub fn build_executable_object_source_sql(
+    input: dbx_core::object_source_sql::EditableObjectSourceSqlInput,
+) -> Result<String, String> {
+    dbx_core::object_source_sql::build_executable_object_source_sql(input)
+}
+
+#[tauri::command]
+pub fn build_editable_object_source(
+    input: dbx_core::object_source_sql::EditableObjectSourceSqlInput,
+) -> Result<String, String> {
+    Ok(dbx_core::object_source_sql::build_editable_object_source(input))
+}
+
+#[tauri::command]
+pub fn build_routine_rename_object_source_statements(
+    input: dbx_core::object_source_sql::RoutineRenameObjectSourceInput,
+) -> Result<Vec<String>, String> {
+    dbx_core::object_source_sql::build_routine_rename_object_source_statements(input)
+}
+
+#[tauri::command]
+pub fn build_view_ddl_sql(input: dbx_core::object_source_sql::BuildViewDdlInput) -> Result<String, String> {
+    Ok(dbx_core::object_source_sql::build_view_ddl_sql(input))
+}
+
+#[tauri::command]
+pub fn build_table_structure_change_sql(
+    options: dbx_core::table_structure_sql::TableStructureSqlOptions,
+) -> Result<dbx_core::table_structure_sql::TableStructureSqlResult, String> {
+    Ok(dbx_core::table_structure_sql::build_table_structure_change_sql(options))
+}
+
+#[tauri::command]
+pub async fn preview_sqlite_table_structure_change(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    options: dbx_core::table_structure_sql::TableStructureSqlOptions,
+) -> Result<dbx_core::table_structure_sql::SqliteTableStructurePreview, String> {
+    dbx_core::table_structure_sql::preview_sqlite_table_structure_change(&state, &connection_id, &database, options)
+        .await
+}
+
+#[tauri::command]
+pub async fn apply_sqlite_table_structure_change(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    options: dbx_core::table_structure_sql::TableStructureSqlOptions,
+    schema_revision: String,
+) -> Result<db::QueryResult, String> {
+    dbx_core::table_structure_sql::apply_sqlite_table_structure_change(
+        &state,
+        &connection_id,
+        &database,
+        options,
+        &schema_revision,
+    )
+    .await
+}
+
+#[tauri::command]
+pub fn build_create_table_sql(
+    options: dbx_core::table_structure_sql::TableStructureSqlOptions,
+) -> Result<dbx_core::table_structure_sql::TableStructureSqlResult, String> {
+    Ok(dbx_core::table_structure_sql::build_create_table_sql(options))
+}
+
+#[tauri::command]
+pub fn build_single_column_alter_sql(
+    options: dbx_core::table_structure_sql::SingleColumnAlterSqlOptions,
+) -> Result<dbx_core::table_structure_sql::TableStructureSqlResult, String> {
+    Ok(dbx_core::table_structure_sql::build_single_column_alter_sql(options))
+}
+
+#[tauri::command]
+pub fn analyze_editable_query_editability(sql: String) -> Result<dbx_core::sql_editability::QueryEditability, String> {
+    Ok(dbx_core::sql_editability::analyze_editable_query_editability(&sql))
+}
+
+#[tauri::command]
+pub fn prepare_data_grid_save(
+    options: dbx_core::data_grid_sql::DataGridSaveStatementOptions,
+) -> Result<dbx_core::data_grid_sql::DataGridSavePreparation, String> {
+    Ok(dbx_core::data_grid_sql::prepare_data_grid_save(options))
+}
+
+#[tauri::command]
+pub fn build_data_grid_copy_update_statements(
+    options: dbx_core::data_grid_sql::DataGridCopyUpdateStatementOptions,
+) -> Result<Vec<String>, String> {
+    Ok(dbx_core::data_grid_sql::build_data_grid_copy_update_statements(options))
+}
+
+#[tauri::command]
+pub fn build_data_grid_copy_insert_statement(
+    options: dbx_core::data_grid_sql::DataGridCopyInsertStatementOptions,
+) -> Result<Option<String>, String> {
+    Ok(dbx_core::data_grid_sql::build_data_grid_copy_insert_statement(options))
+}
+
+#[tauri::command]
+pub fn build_data_grid_context_filter_condition(
+    options: dbx_core::data_grid_sql::DataGridContextFilterConditionOptions,
+) -> Result<Option<String>, String> {
+    Ok(dbx_core::data_grid_sql::build_data_grid_context_filter_condition(options))
+}
+
+#[tauri::command]
+pub fn build_data_grid_column_value_filter_condition(
+    options: dbx_core::data_grid_sql::DataGridColumnValueFilterConditionOptions,
+) -> Result<Option<String>, String> {
+    Ok(dbx_core::data_grid_sql::build_data_grid_column_value_filter_condition(options))
+}
+
+#[tauri::command]
+pub fn build_data_grid_column_values_filter_condition(
+    options: dbx_core::data_grid_sql::DataGridColumnValuesFilterConditionOptions,
+) -> Result<Option<String>, String> {
+    Ok(dbx_core::data_grid_sql::build_data_grid_column_values_filter_condition(options))
+}
+
+#[tauri::command]
+pub fn build_data_grid_column_distinct_values_sql(
+    options: dbx_core::data_grid_sql::DataGridColumnDistinctValuesSqlOptions,
+) -> Result<String, String> {
+    Ok(dbx_core::data_grid_sql::build_data_grid_column_distinct_values_sql(options))
+}
+
+#[tauri::command]
+pub fn build_data_grid_count_sql(options: dbx_core::data_grid_sql::DataGridCountSqlOptions) -> Result<String, String> {
+    Ok(dbx_core::data_grid_sql::build_data_grid_count_sql(options))
+}
+
+#[tauri::command]
+pub fn build_hive_table_properties_sql(
+    options: dbx_core::data_grid_sql::HiveTablePropertiesSqlOptions,
+) -> Result<String, String> {
+    Ok(dbx_core::data_grid_sql::build_hive_table_properties_sql(options))
+}
+
+#[tauri::command]
+pub fn build_export_insert_statements(
+    options: dbx_core::database_export::BuildExportInsertStatementsOptions,
+) -> Result<Vec<String>, String> {
+    dbx_core::database_export::build_export_insert_statements(options)
+}
+
+#[tauri::command]
+pub fn build_export_sql_insert(
+    options: dbx_core::database_export::BuildExportSqlInsertOptions,
+) -> Result<String, String> {
+    dbx_core::database_export::build_export_sql_insert(options)
+}
+
+#[tauri::command]
+pub async fn build_database_sql_export(
+    state: tauri::State<'_, std::sync::Arc<dbx_core::connection::AppState>>,
+    mut options: dbx_core::database_export::BuildDatabaseSqlExportOptions,
+) -> Result<String, String> {
+    // Sort tables by FK dependency when connection info is available.
+    if let (Some(ref conn_id), Some(ref database), Some(ref schema)) =
+        (&options.connection_id, &options.database, &options.schema)
+    {
+        if options.tables.len() > 1 {
+            let table_names: Vec<String> = options.tables.iter().filter_map(|t| t.table_name.clone()).collect();
+            if table_names.len() > 1 {
+                if let Ok(sorted_names) = dbx_core::transfer::sort_tables_by_fk_dependency(
+                    &state,
+                    conn_id,
+                    database,
+                    schema,
+                    &table_names,
+                    true,
+                )
+                .await
+                {
+                    options.tables.sort_by_key(|t| {
+                        sorted_names
+                            .iter()
+                            .position(|n| Some(n.as_str()) == t.table_name.as_deref())
+                            .unwrap_or(usize::MAX)
+                    });
+                }
+            }
+        }
+    }
+    dbx_core::database_export::build_database_sql_export(options)
+}
+
+#[tauri::command]
+pub async fn get_explain_info(
+    state: tauri::State<'_, std::sync::Arc<dbx_core::connection::AppState>>,
+    connection_id: String,
+    database: Option<String>,
+    schema: Option<String>,
+    sql: String,
+    mode: Option<String>,
+) -> Result<String, String> {
+    dbx_core::agent_explain::get_agent_explain_info_core(
+        &state,
+        &connection_id,
+        database.as_deref(),
+        schema.as_deref(),
+        &sql,
+        mode.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub fn build_create_user_sql(username: String, password: String, tablespace: String) -> Result<String, String> {
+    Ok(dbx_core::db_admin_sql::build_create_user_sql(&username, &password, &tablespace))
+}
diff --git a/src-tauri/src/commands/query_cancel.rs b/src-tauri/src/commands/query_cancel.rs
new file mode 100644
index 0000000..b5f8fd7
--- /dev/null
+++ b/src-tauri/src/commands/query_cancel.rs
@@ -0,0 +1,2 @@
+#[allow(unused_imports)]
+pub use dbx_core::query_cancel::*;
diff --git a/src-tauri/src/commands/query_result_export.rs b/src-tauri/src/commands/query_result_export.rs
new file mode 100644
index 0000000..15eb464
--- /dev/null
+++ b/src-tauri/src/commands/query_result_export.rs
@@ -0,0 +1,88 @@
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+
+use tauri::{AppHandle, Emitter, State};
+
+use crate::commands::connection::AppState;
+
+use dbx_core::query_cancel::RunningTaskMetadata;
+pub use dbx_core::query_result_export::QueryResultExportRequest;
+use dbx_core::table_export::ExportStatus;
+pub use dbx_core::table_export::TableExportProgress;
+
+fn emit_progress(app: &AppHandle, progress: TableExportProgress) {
+    let _ = app.emit("query-result-export-progress", progress);
+}
+
+#[tauri::command]
+pub async fn start_query_result_export(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    request: QueryResultExportRequest,
+) -> Result<(), String> {
+    let state = state.inner().clone();
+    let export_id = request.export_id.clone();
+    let file_path = request.file_path.clone();
+
+    tokio::spawn(async move {
+        let execution_id = request.execution_id.clone().filter(|id| !id.trim().is_empty());
+        let registered_query = execution_id.as_ref().map(|id| {
+            state.running_queries.register_task(
+                id.clone(),
+                RunningTaskMetadata::query(
+                    request.connection_id.clone(),
+                    request.database.clone(),
+                    request.client_session_id.clone(),
+                ),
+            )
+        });
+        let cancel_token = registered_query.as_ref().map(|query| query.token());
+        let cancelled = Arc::new(AtomicBool::new(false));
+        let cancelled_progress = cancelled.clone();
+        let result =
+            dbx_core::query_result_export::export_query_result_core(&state, &request, cancel_token, |progress| {
+                if matches!(progress.status, ExportStatus::Cancelled) {
+                    cancelled_progress.store(true, Ordering::SeqCst);
+                }
+                emit_progress(&app, progress);
+            })
+            .await;
+        drop(registered_query);
+
+        if let Err(e) = result {
+            let _ = tokio::fs::remove_file(&file_path).await;
+            emit_progress(
+                &app,
+                TableExportProgress {
+                    export_id: export_id.clone(),
+                    table_name: String::new(),
+                    rows_exported: 0,
+                    total_rows: None,
+                    status: ExportStatus::Error,
+                    error_message: Some(e),
+                },
+            );
+        } else if cancelled.load(Ordering::SeqCst) {
+            let _ = tokio::fs::remove_file(&file_path).await;
+        }
+
+        dbx_core::database_export::clear_export_cancelled(&export_id).await;
+    });
+
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn cancel_query_result_export(
+    state: State<'_, Arc<AppState>>,
+    export_id: String,
+    execution_id: Option<String>,
+) -> Result<(), String> {
+    dbx_core::database_export::set_export_cancelled(&export_id).await;
+    if let Some(execution_id) = execution_id.filter(|id| !id.trim().is_empty()) {
+        state.running_queries.cancel(&execution_id);
+    }
+    Ok(())
+}
diff --git a/src-tauri/src/commands/redis_cmd.rs b/src-tauri/src/commands/redis_cmd.rs
new file mode 100644
index 0000000..b3d480b
--- /dev/null
+++ b/src-tauri/src/commands/redis_cmd.rs
@@ -0,0 +1,371 @@
+use std::sync::Arc;
+use tauri::State;
+
+use crate::commands::connection::{ensure_connection_writable, AppState};
+use dbx_core::db::redis_driver::{
+    RedisCollectionPage, RedisCommandResult, RedisCommandSafety, RedisDatabaseInfo, RedisScanResult, RedisValue,
+};
+
+#[tauri::command]
+pub async fn redis_list_databases(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<Vec<RedisDatabaseInfo>, String> {
+    dbx_core::redis_ops::redis_list_databases_core(&state, &connection_id).await
+}
+
+#[tauri::command]
+pub async fn redis_scan_keys(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    cursor: u64,
+    pattern: String,
+    count: usize,
+) -> Result<RedisScanResult, String> {
+    dbx_core::redis_ops::redis_scan_keys_core(&state, &connection_id, db, cursor, &pattern, count).await
+}
+
+#[tauri::command]
+pub async fn redis_scan_keys_batch(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    cursor: u64,
+    pattern: String,
+    count: usize,
+    max_iterations: usize,
+    include_types: Option<bool>,
+) -> Result<RedisScanResult, String> {
+    dbx_core::redis_ops::redis_scan_keys_batch_core(
+        &state,
+        &connection_id,
+        db,
+        cursor,
+        &pattern,
+        count,
+        max_iterations,
+        include_types.unwrap_or(true),
+    )
+    .await
+}
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+pub async fn redis_scan_values(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    cursor: u64,
+    pattern: String,
+    query: String,
+    include_key_matches: Option<bool>,
+    count: usize,
+) -> Result<RedisScanResult, String> {
+    dbx_core::redis_ops::redis_scan_values_core(
+        &state,
+        &connection_id,
+        db,
+        cursor,
+        &pattern,
+        &query,
+        include_key_matches.unwrap_or(false),
+        count,
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn redis_get_value(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+) -> Result<RedisValue, String> {
+    dbx_core::redis_ops::redis_get_value_in_db_core(&state, &connection_id, db, &key_raw).await
+}
+
+#[tauri::command]
+pub async fn redis_set_string(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    value: String,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "SET").await?;
+    dbx_core::redis_ops::redis_set_string_in_db_core(&state, &connection_id, db, &key_raw, &value, ttl).await
+}
+
+#[tauri::command]
+pub async fn redis_delete_key(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "Delete key").await?;
+    dbx_core::redis_ops::redis_delete_key_in_db_core(&state, &connection_id, db, &key_raw).await
+}
+
+#[tauri::command]
+pub async fn redis_hash_set(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    field: String,
+    value: String,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "HSET").await?;
+    dbx_core::redis_ops::redis_hash_set_in_db_core(&state, &connection_id, db, &key_raw, &field, &value, ttl).await
+}
+
+#[tauri::command]
+pub async fn redis_hash_del(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    field: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "HDEL").await?;
+    dbx_core::redis_ops::redis_hash_del_in_db_core(&state, &connection_id, db, &key_raw, &field).await
+}
+
+#[tauri::command]
+pub async fn redis_list_push(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    value: String,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "LPUSH").await?;
+    dbx_core::redis_ops::redis_list_push_in_db_core(&state, &connection_id, db, &key_raw, &value, ttl).await
+}
+
+#[tauri::command]
+pub async fn redis_list_set(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    index: i64,
+    value: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "LSET").await?;
+    dbx_core::redis_ops::redis_list_set_in_db_core(&state, &connection_id, db, &key_raw, index, &value).await
+}
+
+#[tauri::command]
+pub async fn redis_list_remove(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    index: i64,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "LREM").await?;
+    dbx_core::redis_ops::redis_list_remove_in_db_core(&state, &connection_id, db, &key_raw, index).await
+}
+
+#[tauri::command]
+pub async fn redis_set_add(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    member: String,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "SADD").await?;
+    dbx_core::redis_ops::redis_set_add_in_db_core(&state, &connection_id, db, &key_raw, &member, ttl).await
+}
+
+#[tauri::command]
+pub async fn redis_set_remove(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    member: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "SREM").await?;
+    dbx_core::redis_ops::redis_set_remove_in_db_core(&state, &connection_id, db, &key_raw, &member).await
+}
+
+#[tauri::command]
+pub async fn redis_zadd(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    member: String,
+    score: f64,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "ZADD").await?;
+    dbx_core::redis_ops::redis_zadd_in_db_core(&state, &connection_id, db, &key_raw, &member, score, ttl).await
+}
+
+#[tauri::command]
+pub async fn redis_zrem(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    member: String,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "ZREM").await?;
+    dbx_core::redis_ops::redis_zrem_in_db_core(&state, &connection_id, db, &key_raw, &member).await
+}
+
+#[tauri::command]
+pub async fn redis_stream_add(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    entry_id: String,
+    fields: Vec<(String, String)>,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    dbx_core::redis_ops::redis_stream_add_in_db_core(&state, &connection_id, db, &key_raw, &entry_id, fields, ttl).await
+}
+
+#[tauri::command]
+pub async fn redis_json_set(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    value: String,
+    ttl: Option<i64>,
+) -> Result<(), String> {
+    dbx_core::redis_ops::redis_json_set_in_db_core(&state, &connection_id, db, &key_raw, &value, ttl).await
+}
+
+#[tauri::command]
+pub async fn redis_check_json_module(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+) -> Result<bool, String> {
+    dbx_core::redis_ops::redis_check_json_module_in_db_core(&state, &connection_id, db).await
+}
+
+#[tauri::command]
+pub async fn redis_set_ttl(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    ttl: i64,
+) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "EXPIRE").await?;
+    dbx_core::redis_ops::redis_set_ttl_in_db_core(&state, &connection_id, db, &key_raw, ttl).await
+}
+
+#[tauri::command]
+pub async fn redis_delete_keys(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raws: Vec<String>,
+) -> Result<u64, String> {
+    ensure_connection_writable(&state, &connection_id, "Delete keys").await?;
+    dbx_core::redis_ops::redis_delete_keys_in_db_core(&state, &connection_id, db, &key_raws).await
+}
+
+#[tauri::command]
+pub async fn redis_flush_db(state: State<'_, Arc<AppState>>, connection_id: String, db: u32) -> Result<(), String> {
+    ensure_connection_writable(&state, &connection_id, "FLUSHDB").await?;
+    dbx_core::redis_ops::redis_flush_db_core(&state, &connection_id, db).await
+}
+
+#[tauri::command]
+pub async fn redis_execute_command(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    command: String,
+    skip_safety_check: Option<bool>,
+) -> Result<RedisCommandResult, String> {
+    // In read-only mode, only allow safe read commands through the raw command interface
+    if let Some(name) = dbx_core::query::connection_readonly_name(&state, &connection_id).await {
+        let cmd_name = command.split_whitespace().next().unwrap_or("");
+        if dbx_core::db::redis_driver::classify_command(cmd_name) != RedisCommandSafety::Allowed {
+            return Err(format!(
+                "Read-only mode: connection '{}' has read-only protection enabled. Command '{}' blocked.",
+                name, cmd_name
+            ));
+        }
+    }
+    dbx_core::redis_ops::redis_execute_command_core(
+        &state,
+        &connection_id,
+        db,
+        &command,
+        skip_safety_check.unwrap_or(false),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn redis_load_more(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    key_raw: String,
+    key_type: String,
+    cursor: u64,
+    count: usize,
+    filter: Option<String>,
+) -> Result<RedisCollectionPage, String> {
+    dbx_core::redis_ops::redis_load_more_in_db_core(
+        &state,
+        &connection_id,
+        db,
+        &key_raw,
+        &key_type,
+        cursor,
+        count,
+        filter.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn redis_pubsub_publish(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    db: u32,
+    channel: String,
+    message: String,
+) -> Result<u64, String> {
+    ensure_connection_writable(&state, &connection_id, "PUBLISH").await?;
+    dbx_core::redis_ops::redis_publish_core(&state, &connection_id, db, &channel, &message).await
+}
+
+#[tauri::command]
+pub async fn redis_slowlog_get(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    count: usize,
+    node_host: Option<String>,
+    node_port: Option<u16>,
+) -> Result<Vec<dbx_core::db::redis_driver::RedisSlowlogEntry>, String> {
+    dbx_core::redis_ops::redis_slowlog_get_core(&state, &connection_id, count, node_host, node_port).await
+}
+
+#[tauri::command]
+pub async fn redis_cluster_master_nodes(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<Vec<dbx_core::db::redis_driver::RedisNodeEndpoint>, String> {
+    dbx_core::redis_ops::redis_cluster_master_nodes_core(&state, &connection_id).await
+}
diff --git a/src-tauri/src/commands/redis_pubsub_server.rs b/src-tauri/src/commands/redis_pubsub_server.rs
new file mode 100644
index 0000000..dff1208
--- /dev/null
+++ b/src-tauri/src/commands/redis_pubsub_server.rs
@@ -0,0 +1,164 @@
+use std::sync::Arc;
+
+use axum::extract::ws::{Message, WebSocket};
+use axum::extract::{Query, State, WebSocketUpgrade};
+use axum::response::IntoResponse;
+use axum::routing::get;
+use axum::Router;
+use futures::{SinkExt, StreamExt};
+use serde::Deserialize;
+
+use dbx_core::connection::AppState;
+
+const DEFAULT_PUBSUB_PORT: u16 = 4224;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct PubSubWsParams {
+    connection_id: String,
+}
+
+pub fn build_pubsub_router(state: Arc<AppState>) -> Router {
+    Router::new().route("/api/redis/pubsub/ws", get(ws_handler)).with_state(state)
+}
+
+fn pubsub_server_port() -> u16 {
+    std::env::var("DBX_PORT").ok().and_then(|p| p.parse().ok()).unwrap_or(DEFAULT_PUBSUB_PORT)
+}
+
+#[tauri::command]
+pub fn redis_pubsub_server_port() -> u16 {
+    pubsub_server_port()
+}
+
+async fn ws_handler(
+    ws: WebSocketUpgrade,
+    Query(params): Query<PubSubWsParams>,
+    State(state): State<Arc<AppState>>,
+) -> impl IntoResponse {
+    let connection_id = params.connection_id;
+    ws.on_upgrade(move |socket| handle_socket(socket, state, connection_id))
+}
+
+async fn handle_socket(socket: WebSocket, state: Arc<AppState>, connection_id: String) {
+    // Create PubSub connection
+    let pubsub = match dbx_core::redis_ops::redis_create_pubsub_core(&state, &connection_id).await {
+        Ok(p) => p,
+        Err(e) => {
+            let (mut sender, _) = socket.split();
+            let _ = sender.send(Message::Text(format!(r#"{{"error":"{e}"}}"#).into())).await;
+            return;
+        }
+    };
+
+    let (mut sink, mut stream) = pubsub.split();
+    let (mut ws_sender, mut ws_receiver) = socket.split();
+
+    // Channel for WebSocket commands -> PubSub sink
+    let (cmd_tx, mut cmd_rx) = tokio::sync::mpsc::unbounded_channel::<String>();
+
+    // Task: Read WebSocket commands
+    let ws_read = tokio::spawn(async move {
+        while let Some(Ok(msg)) = ws_receiver.next().await {
+            match msg {
+                Message::Text(text) => {
+                    if cmd_tx.send(text.to_string()).is_err() {
+                        break;
+                    }
+                }
+                Message::Close(_) => break,
+                _ => {}
+            }
+        }
+    });
+
+    // Task: Apply commands to PubSub sink
+    let sink_handle = tokio::spawn(async move {
+        while let Some(text) = cmd_rx.recv().await {
+            if let Err(e) = handle_command(&mut sink, &text).await {
+                log::warn!("PubSub command error: {e}");
+            }
+        }
+    });
+
+    // Forward Redis messages to WebSocket (uses ws_sender, no mutex contention)
+    while let Some(msg) = stream.next().await {
+        let payload: String = msg.get_payload().unwrap_or_default();
+        let channel = msg.get_channel_name().to_string();
+        let pattern: Option<String> = msg.get_pattern().ok();
+        let json = serde_json::json!({
+            "channel": channel,
+            "pattern": pattern,
+            "payload": payload,
+        });
+        let text = serde_json::to_string(&json).unwrap_or_default();
+        if ws_sender.send(Message::Text(text.into())).await.is_err() {
+            break;
+        }
+    }
+
+    ws_read.abort();
+    sink_handle.abort();
+}
+
+#[derive(Deserialize)]
+#[serde(tag = "type")]
+enum PubSubCommand {
+    #[serde(rename = "subscribe")]
+    Subscribe { channels: Vec<String> },
+    #[serde(rename = "psubscribe")]
+    Psubscribe { patterns: Vec<String> },
+    #[serde(rename = "unsubscribe")]
+    Unsubscribe { channels: Vec<String> },
+    #[serde(rename = "punsubscribe")]
+    Punsubscribe { patterns: Vec<String> },
+}
+
+async fn handle_command(sink: &mut redis::aio::PubSubSink, text: &str) -> Result<(), String> {
+    let cmd: PubSubCommand = serde_json::from_str(text).map_err(|e| format!("Invalid PubSub command: {e}"))?;
+
+    match cmd {
+        PubSubCommand::Subscribe { channels } => {
+            for ch in &channels {
+                sink.subscribe(ch).await.map_err(|e| format!("Subscribe error: {e}"))?;
+            }
+        }
+        PubSubCommand::Psubscribe { patterns } => {
+            for pat in &patterns {
+                sink.psubscribe(pat).await.map_err(|e| format!("PSubscribe error: {e}"))?;
+            }
+        }
+        PubSubCommand::Unsubscribe { channels } => {
+            for ch in &channels {
+                sink.unsubscribe(ch).await.map_err(|e| format!("Unsubscribe error: {e}"))?;
+            }
+        }
+        PubSubCommand::Punsubscribe { patterns } => {
+            for pat in &patterns {
+                sink.punsubscribe(pat).await.map_err(|e| format!("PUnsubscribe error: {e}"))?;
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Start the embedded web server for PubSub WebSocket support.
+/// Runs on a background task using the shared AppState.
+pub fn start_pubsub_server(state: Arc<AppState>) {
+    let router = build_pubsub_router(state);
+    tauri::async_runtime::spawn(async move {
+        let port = pubsub_server_port();
+        let addr = std::net::SocketAddr::from(([0, 0, 0, 0], port));
+        let listener = match tokio::net::TcpListener::bind(addr).await {
+            Ok(listener) => listener,
+            Err(error) => {
+                log::warn!("Failed to bind PubSub server on {addr}: {error}");
+                return;
+            }
+        };
+        log::info!("PubSub WebSocket server listening on {addr}");
+        if let Err(error) = axum::serve(listener, router).await {
+            log::warn!("PubSub server stopped with error: {error}");
+        }
+    });
+}
diff --git a/src-tauri/src/commands/saved_sql.rs b/src-tauri/src/commands/saved_sql.rs
new file mode 100644
index 0000000..9d99385
--- /dev/null
+++ b/src-tauri/src/commands/saved_sql.rs
@@ -0,0 +1,229 @@
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use tauri::State;
+
+use dbx_core::connection::AppState;
+use dbx_core::saved_sql::{SavedSqlFile, SavedSqlFolder, SavedSqlLibrary};
+
+#[derive(Clone)]
+pub struct SavedSqlStorageState {
+    pub data_dir: PathBuf,
+}
+
+const SYNC_MANIFEST_FILE: &str = ".dbx-sql-library-sync.json";
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SavedSqlSyncEntry {
+    pub folder_name: Option<String>,
+    pub file_name: String,
+    pub sql: String,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SavedSqlSyncRequest {
+    pub target_dir: String,
+    pub entries: Vec<SavedSqlSyncEntry>,
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+struct SavedSqlSyncManifest {
+    files: Vec<String>,
+}
+
+#[tauri::command]
+pub async fn load_saved_sql_library(state: State<'_, Arc<AppState>>) -> Result<SavedSqlLibrary, String> {
+    state.storage.load_saved_sql_library_summary().await
+}
+
+#[tauri::command]
+pub async fn load_saved_sql_file(state: State<'_, Arc<AppState>>, id: String) -> Result<Option<SavedSqlFile>, String> {
+    state.storage.load_saved_sql_file(&id).await
+}
+
+#[tauri::command]
+pub async fn save_saved_sql_folder(
+    state: State<'_, Arc<AppState>>,
+    folder: SavedSqlFolder,
+) -> Result<SavedSqlFolder, String> {
+    state.storage.save_saved_sql_folder(&folder).await?;
+    Ok(folder)
+}
+
+#[tauri::command]
+pub async fn delete_saved_sql_folder(state: State<'_, Arc<AppState>>, id: String) -> Result<(), String> {
+    state.storage.delete_saved_sql_folder(&id).await
+}
+
+#[tauri::command]
+pub async fn save_saved_sql_file(state: State<'_, Arc<AppState>>, file: SavedSqlFile) -> Result<SavedSqlFile, String> {
+    state.storage.save_saved_sql_file(&file).await?;
+    Ok(file)
+}
+
+#[tauri::command]
+pub async fn delete_saved_sql_file(state: State<'_, Arc<AppState>>, id: String) -> Result<(), String> {
+    state.storage.delete_saved_sql_file(&id).await
+}
+
+#[tauri::command]
+pub async fn saved_sql_storage_dir(state: State<'_, SavedSqlStorageState>) -> Result<String, String> {
+    Ok(state.data_dir.to_string_lossy().to_string())
+}
+
+#[tauri::command]
+pub async fn open_saved_sql_storage_dir(
+    state: State<'_, SavedSqlStorageState>,
+    dir: Option<String>,
+) -> Result<(), String> {
+    let target_dir = dir
+        .as_deref()
+        .map(str::trim)
+        .filter(|path| !path.is_empty())
+        .map(PathBuf::from)
+        .unwrap_or_else(|| state.data_dir.clone());
+    std::fs::create_dir_all(&target_dir).map_err(|e| e.to_string())?;
+    open_path(&target_dir)
+}
+
+#[tauri::command]
+pub async fn sync_saved_sql_directory(request: SavedSqlSyncRequest) -> Result<(), String> {
+    let target_dir = PathBuf::from(request.target_dir.trim());
+    if target_dir.as_os_str().is_empty() {
+        return Err("Target directory is empty".to_string());
+    }
+    tokio::task::spawn_blocking(move || sync_saved_sql_directory_blocking(&target_dir, &request.entries))
+        .await
+        .map_err(|e| e.to_string())?
+}
+
+fn sync_saved_sql_directory_blocking(target_dir: &Path, entries: &[SavedSqlSyncEntry]) -> Result<(), String> {
+    let sync_root = target_dir.join("dbx-sql-library");
+    std::fs::create_dir_all(&sync_root).map_err(|e| e.to_string())?;
+    remove_previous_sync_files(&sync_root)?;
+
+    let mut written_files = Vec::new();
+    for entry in entries {
+        let mut file_dir = sync_root.to_path_buf();
+        if let Some(folder_name) = entry.folder_name.as_deref().map(str::trim).filter(|name| !name.is_empty()) {
+            for segment in folder_name.split('/') {
+                let segment = segment.trim();
+                if !segment.is_empty() {
+                    file_dir.push(sanitize_file_segment(segment));
+                }
+            }
+        }
+        std::fs::create_dir_all(&file_dir).map_err(|e| e.to_string())?;
+
+        let file_name = ensure_sql_extension(&sanitize_file_segment(&entry.file_name));
+        let file_path = unique_file_path(&file_dir, &file_name);
+        std::fs::write(&file_path, &entry.sql).map_err(|e| e.to_string())?;
+        if let Ok(relative) = file_path.strip_prefix(&sync_root) {
+            written_files.push(relative.to_string_lossy().replace('\\', "/"));
+        }
+    }
+
+    let manifest = SavedSqlSyncManifest { files: written_files };
+    let manifest_json = serde_json::to_string_pretty(&manifest).map_err(|e| e.to_string())?;
+    std::fs::write(sync_root.join(SYNC_MANIFEST_FILE), manifest_json).map_err(|e| e.to_string())?;
+    Ok(())
+}
+
+fn remove_previous_sync_files(target_dir: &Path) -> Result<(), String> {
+    let manifest_path = target_dir.join(SYNC_MANIFEST_FILE);
+    let Ok(raw) = std::fs::read_to_string(&manifest_path) else {
+        return Ok(());
+    };
+    let manifest = serde_json::from_str::<SavedSqlSyncManifest>(&raw).unwrap_or_default();
+    for relative in manifest.files {
+        let file_path = target_dir.join(relative);
+        if file_path.is_file() {
+            std::fs::remove_file(&file_path).map_err(|e| e.to_string())?;
+            remove_empty_parent_dirs(target_dir, file_path.parent());
+        }
+    }
+    Ok(())
+}
+
+fn remove_empty_parent_dirs(root: &Path, parent: Option<&Path>) {
+    let Some(dir) = parent else {
+        return;
+    };
+    if dir == root {
+        return;
+    }
+    if std::fs::remove_dir(dir).is_ok() {
+        remove_empty_parent_dirs(root, dir.parent());
+    }
+}
+
+fn sanitize_file_segment(value: &str) -> String {
+    let sanitized = value
+        .chars()
+        .map(|ch| match ch {
+            '<' | '>' | ':' | '"' | '/' | '\\' | '|' | '?' | '*' => '_',
+            ch if ch.is_control() => '_',
+            ch => ch,
+        })
+        .collect::<String>()
+        .trim()
+        .trim_matches('.')
+        .to_string();
+    if sanitized.is_empty() {
+        "untitled".to_string()
+    } else {
+        sanitized
+    }
+}
+
+fn ensure_sql_extension(name: &str) -> String {
+    if name.to_lowercase().ends_with(".sql") {
+        name.to_string()
+    } else {
+        format!("{name}.sql")
+    }
+}
+
+fn unique_file_path(dir: &Path, file_name: &str) -> PathBuf {
+    let mut candidate = dir.join(file_name);
+    if !candidate.exists() {
+        return candidate;
+    }
+
+    let base = file_name.strip_suffix(".sql").unwrap_or(file_name);
+    let mut counter = 2;
+    loop {
+        candidate = dir.join(format!("{base} ({counter}).sql"));
+        if !candidate.exists() {
+            return candidate;
+        }
+        counter += 1;
+    }
+}
+
+fn open_path(path: &Path) -> Result<(), String> {
+    #[cfg(target_os = "macos")]
+    let mut command = {
+        let mut command = dbx_core::process::new_std_command("open");
+        command.arg(path);
+        command
+    };
+
+    #[cfg(target_os = "windows")]
+    let mut command = {
+        let mut command = dbx_core::process::new_std_command("explorer");
+        command.arg(path);
+        command
+    };
+
+    #[cfg(all(not(target_os = "macos"), not(target_os = "windows")))]
+    let mut command = {
+        let mut command = dbx_core::process::new_std_command("xdg-open");
+        command.arg(path);
+        command
+    };
+
+    command.spawn().map(|_| ()).map_err(|e| e.to_string())
+}
diff --git a/src-tauri/src/commands/schema.rs b/src-tauri/src/commands/schema.rs
new file mode 100644
index 0000000..6b0fbc3
--- /dev/null
+++ b/src-tauri/src/commands/schema.rs
@@ -0,0 +1,431 @@
+use std::sync::Arc;
+use tauri::State;
+
+use crate::commands::connection::AppState;
+use dbx_core::db;
+
+/// Resolve a non-internal catalog for dispatch to the Doris multi-catalog path.
+/// Thin wrapper around the shared dbx-core resolver so the Tauri and HTTP
+/// backends stay in sync.
+async fn external_doris_catalog(state: &AppState, connection_id: &str, catalog: Option<&str>) -> Option<String> {
+    dbx_core::schema::resolve_external_doris_catalog(state, connection_id, catalog).await
+}
+
+#[tauri::command]
+pub async fn list_databases(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<Vec<db::DatabaseInfo>, String> {
+    dbx_core::schema::list_databases_core(&state, &connection_id).await
+}
+
+#[tauri::command]
+pub async fn list_doris_catalogs(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<Vec<db::CatalogInfo>, String> {
+    dbx_core::schema::list_doris_catalogs_core(&state, &connection_id).await
+}
+
+#[tauri::command]
+pub async fn list_doris_catalog_databases(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    catalog: String,
+) -> Result<Vec<db::DatabaseInfo>, String> {
+    dbx_core::schema::list_doris_catalog_databases_core(&state, &connection_id, &catalog).await
+}
+
+#[tauri::command]
+pub async fn list_sqlserver_linked_servers(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+) -> Result<Vec<db::LinkedServerInfo>, String> {
+    dbx_core::schema::list_sqlserver_linked_servers_core(&state, &connection_id).await
+}
+
+#[tauri::command]
+pub async fn list_sqlserver_linked_server_catalogs(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    server: String,
+) -> Result<Vec<db::DatabaseInfo>, String> {
+    dbx_core::schema::list_sqlserver_linked_server_catalogs_core(&state, &connection_id, &server).await
+}
+
+#[tauri::command]
+pub async fn list_sqlserver_linked_server_schemas(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    server: String,
+    catalog: String,
+) -> Result<Vec<String>, String> {
+    dbx_core::schema::list_sqlserver_linked_server_schemas_core(&state, &connection_id, &server, &catalog).await
+}
+
+#[tauri::command]
+pub async fn list_sqlserver_linked_server_tables(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    server: String,
+    catalog: String,
+    schema: String,
+    filter: Option<String>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+) -> Result<Vec<db::TableInfo>, String> {
+    dbx_core::schema::list_sqlserver_linked_server_tables_core(
+        &state,
+        &connection_id,
+        &server,
+        &catalog,
+        &schema,
+        filter.as_deref(),
+        limit,
+        offset,
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn list_schemas(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    apply_visible_filter: Option<bool>,
+) -> Result<Vec<String>, String> {
+    dbx_core::schema::list_schemas_core_with_visible_filter(
+        &state,
+        &connection_id,
+        &database,
+        apply_visible_filter.unwrap_or(false),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn list_schema_infos(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+) -> Result<Vec<db::SchemaInfo>, String> {
+    dbx_core::schema::list_schema_infos_core(&state, &connection_id, &database).await
+}
+
+#[tauri::command]
+pub async fn list_data_types(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+) -> Result<Vec<String>, String> {
+    dbx_core::schema::list_data_types_core(&state, &connection_id, &database).await
+}
+
+#[tauri::command]
+pub async fn list_tables(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    filter: Option<String>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<Vec<String>>,
+    catalog: Option<String>,
+) -> Result<Vec<db::TableInfo>, String> {
+    if let Some(catalog) = external_doris_catalog(&state, &connection_id, catalog.as_deref()).await {
+        return dbx_core::schema::list_doris_catalog_tables_core(
+            &state,
+            &connection_id,
+            &catalog,
+            &database,
+            filter.as_deref(),
+            limit,
+            offset,
+            object_types.as_deref(),
+        )
+        .await;
+    }
+    dbx_core::schema::list_tables_core(
+        &state,
+        &connection_id,
+        &database,
+        &schema,
+        filter.as_deref(),
+        limit,
+        offset,
+        object_types.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn get_table_comment(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    table: String,
+    catalog: Option<String>,
+) -> Result<Option<String>, String> {
+    if let Some(catalog) = external_doris_catalog(&state, &connection_id, catalog.as_deref()).await {
+        return dbx_core::schema::get_doris_catalog_table_comment_core(
+            &state,
+            &connection_id,
+            &catalog,
+            &database,
+            &table,
+        )
+        .await;
+    }
+    dbx_core::schema::get_table_comment_core(&state, &connection_id, &database, &schema, &table).await
+}
+
+#[tauri::command]
+pub async fn list_objects(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    filter: Option<String>,
+    limit: Option<usize>,
+    offset: Option<usize>,
+    object_types: Option<Vec<String>>,
+    catalog: Option<String>,
+) -> Result<Vec<db::ObjectInfo>, String> {
+    if let Some(catalog) = external_doris_catalog(&state, &connection_id, catalog.as_deref()).await {
+        let tables = dbx_core::schema::list_doris_catalog_tables_core(
+            &state,
+            &connection_id,
+            &catalog,
+            &database,
+            filter.as_deref(),
+            limit,
+            offset,
+            object_types.as_deref(),
+        )
+        .await?;
+        return Ok(tables
+            .into_iter()
+            .map(|table| db::ObjectInfo {
+                name: table.name,
+                object_type: table.table_type,
+                schema: Some(database.clone()),
+                signature: None,
+                comment: table.comment,
+                created_at: None,
+                updated_at: None,
+                parent_schema: table.parent_schema,
+                parent_name: table.parent_name,
+            })
+            .collect());
+    }
+    dbx_core::schema::list_objects_core(
+        &state,
+        &connection_id,
+        &database,
+        &schema,
+        filter.as_deref(),
+        limit,
+        offset,
+        object_types.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn list_object_statistics(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+) -> Result<Vec<db::ObjectStatistics>, String> {
+    dbx_core::schema::list_object_statistics_core(&state, &connection_id, &database, &schema).await
+}
+
+#[tauri::command]
+pub async fn list_completion_objects(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+) -> Result<Vec<db::ObjectInfo>, String> {
+    dbx_core::schema::list_completion_objects_core(&state, &connection_id, &database, &schema).await
+}
+
+#[tauri::command]
+pub async fn completion_assistant_search(
+    state: State<'_, Arc<AppState>>,
+    request: db::CompletionAssistantRequest,
+) -> Result<db::CompletionAssistantResponse, String> {
+    dbx_core::schema::completion_assistant_search_core(&state, request).await
+}
+
+#[tauri::command]
+pub async fn get_object_source(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    name: String,
+    object_type: db::ObjectSourceKind,
+    signature: Option<String>,
+) -> Result<db::ObjectSource, String> {
+    dbx_core::schema::get_object_source_core(
+        &state,
+        &connection_id,
+        &database,
+        &schema,
+        &name,
+        object_type,
+        signature.as_deref(),
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn get_columns(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    table: String,
+    catalog: Option<String>,
+) -> Result<Vec<db::ColumnInfo>, String> {
+    if let Some(catalog) = external_doris_catalog(&state, &connection_id, catalog.as_deref()).await {
+        return dbx_core::schema::get_doris_catalog_columns_core(&state, &connection_id, &catalog, &database, &table)
+            .await;
+    }
+    dbx_core::schema::get_columns_core(&state, &connection_id, &database, &schema, &table).await
+}
+
+#[tauri::command]
+pub async fn list_indexes(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    table: String,
+    catalog: Option<String>,
+) -> Result<Vec<db::IndexInfo>, String> {
+    if let Some(catalog) = external_doris_catalog(&state, &connection_id, catalog.as_deref()).await {
+        return dbx_core::schema::list_doris_catalog_indexes_core(&state, &connection_id, &catalog, &database, &table)
+            .await;
+    }
+    dbx_core::schema::list_indexes_core(&state, &connection_id, &database, &schema, &table).await
+}
+
+#[tauri::command]
+pub async fn list_foreign_keys(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    table: String,
+    catalog: Option<String>,
+) -> Result<Vec<db::ForeignKeyInfo>, String> {
+    if let Some(catalog) = external_doris_catalog(&state, &connection_id, catalog.as_deref()).await {
+        return dbx_core::schema::list_doris_catalog_foreign_keys_core(
+            &state,
+            &connection_id,
+            &catalog,
+            &database,
+            &table,
+        )
+        .await;
+    }
+    dbx_core::schema::list_foreign_keys_core(&state, &connection_id, &database, &schema, &table).await
+}
+
+#[tauri::command]
+pub async fn list_triggers(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    table: String,
+    catalog: Option<String>,
+) -> Result<Vec<db::TriggerInfo>, String> {
+    if let Some(catalog) = external_doris_catalog(&state, &connection_id, catalog.as_deref()).await {
+        return dbx_core::schema::list_doris_catalog_triggers_core(&state, &connection_id, &catalog, &database, &table)
+            .await;
+    }
+    dbx_core::schema::list_triggers_core(&state, &connection_id, &database, &schema, &table).await
+}
+
+#[tauri::command]
+pub async fn get_table_ddl(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    table: String,
+    object_type: Option<db::ObjectSourceKind>,
+    catalog: Option<String>,
+) -> Result<String, String> {
+    if let Some(catalog) = external_doris_catalog(&state, &connection_id, catalog.as_deref()).await {
+        return dbx_core::schema::get_doris_catalog_table_ddl_core(&state, &connection_id, &catalog, &database, &table)
+            .await;
+    }
+    dbx_core::schema::get_table_ddl_core(&state, &connection_id, &database, &schema, &table, object_type).await
+}
+
+#[tauri::command]
+pub async fn list_functions(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+) -> Result<Vec<db::FunctionInfo>, String> {
+    dbx_core::schema::list_functions_core(&state, &connection_id, &database, &schema).await
+}
+
+#[tauri::command]
+pub async fn list_sequences(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    with_last_values: bool,
+) -> Result<Vec<db::SequenceInfo>, String> {
+    dbx_core::schema::list_sequences_core(&state, &connection_id, &database, &schema, with_last_values).await
+}
+
+#[tauri::command]
+pub async fn list_rules(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+) -> Result<Vec<db::RuleInfo>, String> {
+    dbx_core::schema::list_rules_core(&state, &connection_id, &database, &schema).await
+}
+
+#[tauri::command]
+pub async fn list_owners(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+) -> Result<Vec<db::OwnerInfo>, String> {
+    dbx_core::schema::list_owners_core(&state, &connection_id, &database, &schema).await
+}
+
+#[tauri::command]
+pub async fn list_extensions(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+) -> Result<Vec<db::ExtensionInfo>, String> {
+    dbx_core::schema::list_extensions_core(&state, &connection_id, &database, &schema).await
+}
+
+#[tauri::command]
+pub async fn list_available_extensions(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    database: String,
+) -> Result<Vec<db::ExtensionInfo>, String> {
+    dbx_core::schema::list_available_extensions_core(&state, &connection_id, &database).await
+}
diff --git a/src-tauri/src/commands/schema_cache.rs b/src-tauri/src/commands/schema_cache.rs
new file mode 100644
index 0000000..c92ea82
--- /dev/null
+++ b/src-tauri/src/commands/schema_cache.rs
@@ -0,0 +1,26 @@
+use std::sync::Arc;
+use tauri::State;
+
+use dbx_core::connection::AppState;
+
+#[tauri::command]
+pub async fn save_schema_cache(
+    state: State<'_, Arc<AppState>>,
+    cache_key: String,
+    payload: serde_json::Value,
+) -> Result<(), String> {
+    state.storage.save_schema_cache(&cache_key, &payload).await
+}
+
+#[tauri::command]
+pub async fn load_schema_cache(
+    state: State<'_, Arc<AppState>>,
+    cache_key: String,
+) -> Result<Option<serde_json::Value>, String> {
+    state.storage.load_schema_cache(&cache_key).await
+}
+
+#[tauri::command]
+pub async fn delete_schema_cache_prefix(state: State<'_, Arc<AppState>>, prefix: String) -> Result<(), String> {
+    state.storage.delete_schema_cache_prefix(&prefix).await
+}
diff --git a/src-tauri/src/commands/schema_diff.rs b/src-tauri/src/commands/schema_diff.rs
new file mode 100644
index 0000000..a2de22f
--- /dev/null
+++ b/src-tauri/src/commands/schema_diff.rs
@@ -0,0 +1,30 @@
+#[tauri::command]
+pub fn prepare_schema_diff(
+    options: dbx_core::schema_diff::SchemaDiffPreparationOptions,
+) -> Result<dbx_core::schema_diff::SchemaDiffPreparation, String> {
+    Ok(dbx_core::schema_diff::prepare_schema_diff(options))
+}
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+pub fn generate_schema_sync_sql(
+    diffs: Vec<dbx_core::schema_diff::TableDiff>,
+    function_diffs: Option<Vec<dbx_core::schema_diff::FunctionDiff>>,
+    sequence_diffs: Option<Vec<dbx_core::schema_diff::SequenceDiff>>,
+    rule_diffs: Option<Vec<dbx_core::schema_diff::RuleDiff>>,
+    owner_diffs: Option<Vec<dbx_core::schema_diff::OwnerDiff>>,
+    database_type: dbx_core::models::connection::DatabaseType,
+    target_schema: Option<String>,
+    cascade_delete: Option<bool>,
+) -> Result<String, String> {
+    Ok(dbx_core::schema_diff::generate_schema_sync_sql(
+        &diffs,
+        function_diffs.as_deref().unwrap_or_default(),
+        sequence_diffs.as_deref().unwrap_or_default(),
+        rule_diffs.as_deref().unwrap_or_default(),
+        owner_diffs.as_deref().unwrap_or_default(),
+        database_type,
+        target_schema.as_deref(),
+        cascade_delete.unwrap_or(false),
+    ))
+}
diff --git a/src-tauri/src/commands/sql_file.rs b/src-tauri/src/commands/sql_file.rs
new file mode 100644
index 0000000..410329e
--- /dev/null
+++ b/src-tauri/src/commands/sql_file.rs
@@ -0,0 +1,258 @@
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::{Arc, OnceLock};
+use std::time::Instant;
+
+use tauri::{AppHandle, Emitter, State};
+use tokio::sync::RwLock;
+use tokio_util::sync::CancellationToken;
+
+use crate::commands::connection::{ensure_connection_writable, AppState};
+use dbx_core::sql_file_import::{
+    execute_sql_file_path, mysql_like_sql_file_can_execute_without_selected_database, read_sql_file_preview,
+    sql_file_progress,
+};
+
+pub use dbx_core::sql::{SqlFilePreview, SqlFileRequest, SqlFileStatus};
+
+static SQL_FILE_EXECUTIONS: OnceLock<RwLock<HashMap<String, CancellationToken>>> = OnceLock::new();
+
+fn sql_file_executions() -> &'static RwLock<HashMap<String, CancellationToken>> {
+    SQL_FILE_EXECUTIONS.get_or_init(|| RwLock::new(HashMap::new()))
+}
+
+#[cfg(test)]
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct SqlFileSummary {
+    status: SqlFileStatus,
+    success_count: usize,
+    failure_count: usize,
+    failed_statement_index: Option<usize>,
+}
+
+#[tauri::command]
+pub async fn preview_sql_file(file_path: String) -> Result<SqlFilePreview, String> {
+    let path = PathBuf::from(&file_path);
+    let metadata = tokio::fs::metadata(&path).await.map_err(|e| e.to_string())?;
+    let prefix = read_sql_file_preview(&path, 1_000_000).await?;
+    let can_execute_without_selected_database = mysql_like_sql_file_can_execute_without_selected_database(&prefix);
+    let preview = prefix.chars().take(20_000).collect();
+
+    Ok(SqlFilePreview {
+        file_name: path.file_name().and_then(|name| name.to_str()).unwrap_or("script.sql").to_string(),
+        file_path,
+        size_bytes: metadata.len(),
+        preview,
+        can_execute_without_selected_database,
+    })
+}
+
+#[tauri::command]
+pub async fn execute_sql_file(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    request: SqlFileRequest,
+) -> Result<(), String> {
+    // Fast-fail: reject early if the connection is read-only (individual statements are also checked in do_execute)
+    ensure_connection_writable(&state, &request.connection_id, "SQL file execution").await?;
+    let token = CancellationToken::new();
+    {
+        let mut executions = sql_file_executions().write().await;
+        register_sql_file_execution(&mut executions, request.execution_id.clone(), token.clone())?;
+    }
+
+    let started_at = Instant::now();
+    emit_progress(&app, &request.execution_id, SqlFileStatus::Started, 0, 0, 0, 0, started_at, "", None);
+
+    let result = execute_sql_file_inner(&app, &state, &request, token, started_at).await;
+    {
+        let mut executions = sql_file_executions().write().await;
+        remove_sql_file_execution(&mut executions, &request.execution_id);
+    }
+    result
+}
+
+#[tauri::command]
+pub async fn cancel_sql_file_execution(execution_id: String) -> Result<bool, String> {
+    let executions = sql_file_executions().read().await;
+    if let Some(token) = executions.get(&execution_id) {
+        token.cancel();
+        Ok(true)
+    } else {
+        Ok(false)
+    }
+}
+
+async fn execute_sql_file_inner(
+    app: &AppHandle,
+    state: &State<'_, Arc<AppState>>,
+    request: &SqlFileRequest,
+    token: CancellationToken,
+    started_at: Instant,
+) -> Result<(), String> {
+    execute_sql_file_path(
+        state.inner().as_ref(),
+        request,
+        PathBuf::from(&request.file_path).as_path(),
+        token,
+        started_at,
+        |progress| {
+            let _ = app.emit("sql-file-progress", progress);
+        },
+    )
+    .await
+}
+
+fn register_sql_file_execution(
+    executions: &mut HashMap<String, CancellationToken>,
+    execution_id: String,
+    token: CancellationToken,
+) -> Result<(), String> {
+    if executions.contains_key(&execution_id) {
+        return Err(format!("SQL file execution '{execution_id}' already exists"));
+    }
+
+    executions.insert(execution_id, token);
+    Ok(())
+}
+
+fn remove_sql_file_execution(executions: &mut HashMap<String, CancellationToken>, execution_id: &str) {
+    executions.remove(execution_id);
+}
+
+#[allow(clippy::too_many_arguments)]
+fn emit_progress(
+    app: &AppHandle,
+    execution_id: &str,
+    status: SqlFileStatus,
+    statement_index: usize,
+    success_count: usize,
+    failure_count: usize,
+    affected_rows: u64,
+    started_at: Instant,
+    statement_summary: &str,
+    error: Option<String>,
+) {
+    let _ = app.emit(
+        "sql-file-progress",
+        sql_file_progress(
+            execution_id,
+            status,
+            statement_index,
+            success_count,
+            failure_count,
+            affected_rows,
+            started_at,
+            statement_summary,
+            error,
+        ),
+    );
+}
+
+#[cfg(test)]
+async fn run_statements_for_test(
+    statements: Vec<String>,
+    continue_on_error: bool,
+    token: CancellationToken,
+    cancel_after_successes: Option<usize>,
+) -> SqlFileSummary {
+    let mut success_count = 0;
+    let mut failure_count = 0;
+    let mut failed_statement_index = None;
+
+    for (idx, statement) in statements.iter().enumerate() {
+        if token.is_cancelled() {
+            return SqlFileSummary {
+                status: SqlFileStatus::Cancelled,
+                success_count,
+                failure_count,
+                failed_statement_index,
+            };
+        }
+
+        if statement.starts_with("fail") {
+            failure_count += 1;
+            failed_statement_index = Some(idx + 1);
+            if !continue_on_error {
+                return SqlFileSummary {
+                    status: SqlFileStatus::Error,
+                    success_count,
+                    failure_count,
+                    failed_statement_index,
+                };
+            }
+        } else {
+            success_count += 1;
+            if cancel_after_successes == Some(success_count) {
+                token.cancel();
+            }
+        }
+    }
+
+    SqlFileSummary {
+        status: if token.is_cancelled() { SqlFileStatus::Cancelled } else { SqlFileStatus::Done },
+        success_count,
+        failure_count,
+        failed_statement_index,
+    }
+}
+
+#[cfg(test)]
+mod execution_tests {
+    use super::*;
+    use tokio_util::sync::CancellationToken;
+
+    async fn run_fake_script(
+        statements: Vec<String>,
+        continue_on_error: bool,
+        cancel_after_successes: Option<usize>,
+    ) -> SqlFileSummary {
+        let token = CancellationToken::new();
+        run_statements_for_test(statements, continue_on_error, token, cancel_after_successes).await
+    }
+
+    #[tokio::test]
+    async fn stops_on_first_failure_by_default() {
+        let summary = run_fake_script(vec!["ok 1".into(), "fail 2".into(), "ok 3".into()], false, None).await;
+
+        assert_eq!(summary.success_count, 1);
+        assert_eq!(summary.failure_count, 1);
+        assert_eq!(summary.status, SqlFileStatus::Error);
+        assert_eq!(summary.failed_statement_index, Some(2));
+    }
+
+    #[tokio::test]
+    async fn continues_after_failure_when_enabled() {
+        let summary = run_fake_script(vec!["ok 1".into(), "fail 2".into(), "ok 3".into()], true, None).await;
+
+        assert_eq!(summary.success_count, 2);
+        assert_eq!(summary.failure_count, 1);
+        assert_eq!(summary.status, SqlFileStatus::Done);
+    }
+
+    #[tokio::test]
+    async fn cancellation_stops_before_next_statement() {
+        let summary = run_fake_script(vec!["ok 1".into(), "ok 2".into(), "ok 3".into()], true, Some(1)).await;
+
+        assert_eq!(summary.success_count, 1);
+        assert_eq!(summary.status, SqlFileStatus::Cancelled);
+    }
+
+    #[test]
+    #[test]
+    fn duplicate_execution_id_is_rejected_without_replacing_token() {
+        let mut executions = HashMap::new();
+        let original = CancellationToken::new();
+        let replacement = CancellationToken::new();
+        executions.insert("dup".to_string(), original.clone());
+
+        let result = register_sql_file_execution(&mut executions, "dup".to_string(), replacement.clone());
+
+        assert_eq!(result.unwrap_err(), "SQL file execution 'dup' already exists");
+        assert_eq!(executions.len(), 1);
+
+        executions.get("dup").unwrap().cancel();
+        assert!(original.is_cancelled());
+        assert!(!replacement.is_cancelled());
+    }
+}
diff --git a/src-tauri/src/commands/sqlite_backup.rs b/src-tauri/src/commands/sqlite_backup.rs
new file mode 100644
index 0000000..e7012c4
--- /dev/null
+++ b/src-tauri/src/commands/sqlite_backup.rs
@@ -0,0 +1,49 @@
+use std::sync::Arc;
+
+use tauri::State;
+
+use dbx_core::connection::{AppState, PoolKind};
+use dbx_core::db::sqlite::{is_memory_database_path, SqliteHandle};
+use dbx_core::models::connection::DatabaseType;
+use dbx_core::sqlite_backup::{backup_sqlite_database as backup_sqlite_database_core, SqliteBackupOptions};
+
+#[tauri::command]
+pub async fn backup_sqlite_database(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    destination_path: String,
+) -> Result<(), String> {
+    let source_path = sqlite_source_path(&state, &connection_id).await?;
+    let pool = if is_memory_database_path(&source_path) {
+        existing_sqlite_pool(&state, &connection_id)
+            .await?
+            .ok_or_else(|| "Open the in-memory SQLite connection before backing it up".to_string())?
+    } else {
+        let pool_key = state.get_or_create_pool(&connection_id, None).await?;
+        existing_sqlite_pool(&state, &pool_key).await?.ok_or_else(|| "Connection is not open".to_string())?
+    };
+
+    backup_sqlite_database_core(pool, SqliteBackupOptions { source_path, destination_path }).await
+}
+
+async fn sqlite_source_path(state: &Arc<AppState>, connection_id: &str) -> Result<String, String> {
+    let configs = state.configs.read().await;
+    let config = configs.get(connection_id).ok_or_else(|| format!("Connection config not found: {connection_id}"))?;
+    if config.db_type != DatabaseType::Sqlite {
+        return Err("SQLite backup is only available for SQLite connections".to_string());
+    }
+    let source = config.host.trim();
+    if source.is_empty() {
+        return Err("SQLite database path is empty".to_string());
+    }
+    Ok(source.to_string())
+}
+
+async fn existing_sqlite_pool(state: &Arc<AppState>, pool_key: &str) -> Result<Option<SqliteHandle>, String> {
+    let connections = state.connections.read().await;
+    match connections.get(pool_key) {
+        Some(PoolKind::Sqlite(pool)) => Ok(Some(pool.clone())),
+        Some(_) => Err("SQLite backup is only available for SQLite connections".to_string()),
+        None => Ok(None),
+    }
+}
diff --git a/src-tauri/src/commands/ssh_config.rs b/src-tauri/src/commands/ssh_config.rs
new file mode 100644
index 0000000..febca4b
--- /dev/null
+++ b/src-tauri/src/commands/ssh_config.rs
@@ -0,0 +1,6 @@
+use dbx_core::ssh_config::SshConfigHostEntry;
+
+#[tauri::command]
+pub async fn list_ssh_config_hosts() -> Result<Vec<SshConfigHostEntry>, String> {
+    tauri::async_runtime::spawn_blocking(dbx_core::ssh_config::list_hosts).await.map_err(|err| err.to_string())?
+}
diff --git a/src-tauri/src/commands/support_info.rs b/src-tauri/src/commands/support_info.rs
new file mode 100644
index 0000000..536b0d6
--- /dev/null
+++ b/src-tauri/src/commands/support_info.rs
@@ -0,0 +1,300 @@
+use serde::Serialize;
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AppSupportInfo {
+    pub app_version: String,
+    pub runtime: &'static str,
+    pub os_name: String,
+    pub os_version: Option<String>,
+    pub arch: String,
+}
+
+#[tauri::command]
+pub async fn get_app_support_info() -> AppSupportInfo {
+    current_app_support_info()
+}
+
+pub(crate) fn current_app_support_info() -> AppSupportInfo {
+    AppSupportInfo {
+        app_version: env!("CARGO_PKG_VERSION").to_string(),
+        runtime: "desktop",
+        os_name: os_name(),
+        os_version: os_version(),
+        arch: std::env::consts::ARCH.to_string(),
+    }
+}
+
+pub(crate) fn format_support_info_for_native_about() -> String {
+    let info = current_app_support_info();
+    let operating_system = format_operating_system(&info);
+
+    ["Desktop".to_string(), unknown_if_empty(&operating_system), unknown_if_empty(&info.arch)].join(" • ")
+}
+
+pub(crate) fn format_support_info_for_clipboard() -> String {
+    let info = current_app_support_info();
+    let operating_system = format_operating_system(&info);
+
+    [
+        format!("DBX Version: {}", normalize_app_version(&info.app_version)),
+        "Runtime: Desktop".to_string(),
+        format!("Operating System: {}", unknown_if_empty(&operating_system)),
+        format!("Architecture: {}", unknown_if_empty(&info.arch)),
+    ]
+    .join("\n")
+}
+
+fn format_operating_system(info: &AppSupportInfo) -> String {
+    let operating_system = [Some(info.os_name.as_str()), info.os_version.as_deref()]
+        .into_iter()
+        .flatten()
+        .filter(|part| !part.trim().is_empty())
+        .collect::<Vec<_>>()
+        .join(" ");
+    operating_system
+}
+
+fn normalize_app_version(version: &str) -> String {
+    let trimmed = version.trim();
+    if trimmed.is_empty() {
+        return "Unknown".to_string();
+    }
+    if trimmed.starts_with('v') || trimmed.starts_with('V') {
+        format!("v{}", &trimmed[1..])
+    } else {
+        format!("v{trimmed}")
+    }
+}
+
+fn unknown_if_empty(value: &str) -> String {
+    let trimmed = value.trim();
+    if trimmed.is_empty() {
+        "Unknown".to_string()
+    } else {
+        trimmed.to_string()
+    }
+}
+
+fn os_name() -> String {
+    platform_product_name().unwrap_or_else(|| std::env::consts::OS.to_string())
+}
+
+fn os_version() -> Option<String> {
+    platform_product_version()
+}
+
+#[cfg(target_os = "macos")]
+fn platform_product_name() -> Option<String> {
+    command_first_line("sw_vers", &["-productName"])
+}
+
+#[cfg(target_os = "macos")]
+fn platform_product_version() -> Option<String> {
+    command_first_line("sw_vers", &["-productVersion"])
+}
+
+#[cfg(target_os = "windows")]
+fn platform_product_name() -> Option<String> {
+    Some("Windows".to_string())
+}
+
+#[cfg(target_os = "windows")]
+fn platform_product_version() -> Option<String> {
+    command_first_line("cmd", &["/C", "ver"]).and_then(|line| extract_windows_version(&line))
+}
+
+#[cfg(any(target_os = "windows", test))]
+fn extract_windows_version(line: &str) -> Option<String> {
+    line.split(|ch: char| !ch.is_ascii_digit() && ch != '.')
+        .filter(|token| {
+            token.contains('.')
+                && token.split('.').all(|part| !part.is_empty() && part.bytes().all(|byte| byte.is_ascii_digit()))
+        })
+        .max_by_key(|token| token.len())
+        .map(ToOwned::to_owned)
+}
+
+#[cfg(target_os = "linux")]
+fn platform_product_name() -> Option<String> {
+    linux_os_release_value("/etc/os-release", "PRETTY_NAME")
+}
+
+#[cfg(target_os = "linux")]
+fn platform_product_version() -> Option<String> {
+    linux_os_release_value("/etc/os-release", "VERSION_ID")
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
+fn platform_product_name() -> Option<String> {
+    None
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
+fn platform_product_version() -> Option<String> {
+    None
+}
+
+#[cfg(any(target_os = "macos", target_os = "windows"))]
+fn command_first_line(command: &str, args: &[&str]) -> Option<String> {
+    let mut process = dbx_core::process::new_std_command(command);
+    process.args(args);
+    let output = process.output().ok()?;
+    if !output.status.success() {
+        return None;
+    }
+    String::from_utf8_lossy(&output.stdout).lines().map(str::trim).find(|line| !line.is_empty()).map(ToOwned::to_owned)
+}
+
+#[cfg(target_os = "linux")]
+fn linux_os_release_value(path: &str, key: &str) -> Option<String> {
+    let content = std::fs::read_to_string(path).ok()?;
+    parse_os_release_value(&content, key)
+}
+
+#[cfg(any(target_os = "linux", test))]
+fn parse_os_release_value(content: &str, key: &str) -> Option<String> {
+    for line in content.lines() {
+        let line = line.trim();
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        let Some((name, value)) = line.split_once('=') else {
+            continue;
+        };
+        if name != key {
+            continue;
+        }
+        return Some(unquote_os_release_value(value.trim()));
+    }
+    None
+}
+
+#[cfg(any(target_os = "linux", test))]
+fn unquote_os_release_value(value: &str) -> String {
+    let quoted = value
+        .strip_prefix('"')
+        .and_then(|inner| inner.strip_suffix('"'))
+        .or_else(|| value.strip_prefix('\'').and_then(|inner| inner.strip_suffix('\'')));
+    let Some(inner) = quoted else {
+        return value.to_string();
+    };
+    inner.replace("\\\"", "\"").replace("\\'", "'").replace("\\\\", "\\")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        extract_windows_version, format_support_info_for_clipboard, format_support_info_for_native_about,
+        normalize_app_version, parse_os_release_value, unknown_if_empty, unquote_os_release_value,
+    };
+
+    #[test]
+    fn normalizes_app_version_for_support_info() {
+        assert_eq!(normalize_app_version("0.5.50"), "v0.5.50");
+        assert_eq!(normalize_app_version("v0.5.50"), "v0.5.50");
+        assert_eq!(normalize_app_version("V0.5.50"), "v0.5.50");
+        assert_eq!(normalize_app_version(""), "Unknown");
+    }
+
+    #[test]
+    fn formats_unknown_for_empty_support_info_values() {
+        assert_eq!(unknown_if_empty(""), "Unknown");
+        assert_eq!(unknown_if_empty(" aarch64 "), "aarch64");
+    }
+
+    #[test]
+    fn formats_native_about_support_info_compactly() {
+        let text = format_support_info_for_native_about();
+        assert!(text.contains("Desktop"));
+        assert!(!text.contains("DBX Version:"));
+        assert!(!text.contains('\n'));
+    }
+
+    #[test]
+    fn formats_clipboard_support_info_with_labels() {
+        let text = format_support_info_for_clipboard();
+        assert!(text.contains("DBX Version:"));
+        assert!(text.contains("Runtime:"));
+        assert!(text.contains("Operating System:"));
+        assert!(text.contains("Architecture:"));
+    }
+
+    #[test]
+    fn parses_linux_os_release_values() {
+        let content = r#"
+NAME="Ubuntu"
+VERSION_ID="24.04"
+PRETTY_NAME="Ubuntu 24.04.1 LTS"
+"#;
+
+        assert_eq!(parse_os_release_value(content, "PRETTY_NAME").as_deref(), Some("Ubuntu 24.04.1 LTS"));
+        assert_eq!(parse_os_release_value(content, "VERSION_ID").as_deref(), Some("24.04"));
+    }
+
+    #[test]
+    fn returns_none_for_missing_linux_os_release_value() {
+        assert_eq!(parse_os_release_value("NAME=Ubuntu\n", "PRETTY_NAME"), None);
+    }
+
+    #[test]
+    fn extracts_windows_version_from_english_output() {
+        assert_eq!(
+            extract_windows_version("Microsoft Windows [Version 10.0.26200.8655]").as_deref(),
+            Some("10.0.26200.8655")
+        );
+    }
+
+    #[test]
+    fn extracts_windows_version_from_lossy_output() {
+        assert_eq!(
+            extract_windows_version("Microsoft Windows [�汾 10.0.26200.8655]").as_deref(),
+            Some("10.0.26200.8655")
+        );
+    }
+
+    #[test]
+    fn returns_none_for_missing_windows_version() {
+        assert_eq!(extract_windows_version("Microsoft Windows"), None);
+    }
+
+    #[test]
+    fn rejects_malformed_windows_version_tokens() {
+        assert_eq!(extract_windows_version(""), None);
+        assert_eq!(extract_windows_version("10."), None);
+        assert_eq!(extract_windows_version(".10"), None);
+        assert_eq!(extract_windows_version("1..2"), None);
+        assert_eq!(extract_windows_version("..."), None);
+    }
+
+    #[test]
+    fn picks_longest_windows_version_candidate() {
+        assert_eq!(extract_windows_version("cmd 1.0 build 10.0.26200.8655").as_deref(), Some("10.0.26200.8655"));
+    }
+
+    #[test]
+    fn extracts_windows_version_from_gbk_bytes_decoded_lossily() {
+        let mut raw = b"Microsoft Windows [".to_vec();
+        raw.extend_from_slice(&[0xB0, 0xE6, 0xB1, 0xBE]);
+        raw.extend_from_slice(b" 10.0.26200.8655]");
+        let line = String::from_utf8_lossy(&raw);
+        assert_eq!(extract_windows_version(&line).as_deref(), Some("10.0.26200.8655"));
+    }
+
+    #[test]
+    fn formats_windows_operating_system_without_duplicated_name() {
+        let info = super::AppSupportInfo {
+            app_version: "0.5.52".to_string(),
+            runtime: "desktop",
+            os_name: "Windows".to_string(),
+            os_version: Some("10.0.26200.8655".to_string()),
+            arch: "x86_64".to_string(),
+        };
+        assert_eq!(super::format_operating_system(&info), "Windows 10.0.26200.8655");
+    }
+
+    #[test]
+    fn unquotes_linux_os_release_escapes() {
+        assert_eq!(unquote_os_release_value(r#""A \"quoted\" value""#), "A \"quoted\" value");
+    }
+}
diff --git a/src-tauri/src/commands/system_fonts.rs b/src-tauri/src/commands/system_fonts.rs
new file mode 100644
index 0000000..051d2ac
--- /dev/null
+++ b/src-tauri/src/commands/system_fonts.rs
@@ -0,0 +1,6 @@
+#[tauri::command]
+pub async fn list_system_fonts() -> Result<Vec<String>, String> {
+    tauri::async_runtime::spawn_blocking(|| Ok(dbx_core::jdbc::list_system_fonts()))
+        .await
+        .map_err(|err| err.to_string())?
+}
diff --git a/src-tauri/src/commands/tab_runtime_cache.rs b/src-tauri/src/commands/tab_runtime_cache.rs
new file mode 100644
index 0000000..96fbb85
--- /dev/null
+++ b/src-tauri/src/commands/tab_runtime_cache.rs
@@ -0,0 +1,50 @@
+use std::sync::Arc;
+
+use base64::{engine::general_purpose::STANDARD as BASE64, Engine as _};
+use dbx_core::connection::AppState;
+use serde::Serialize;
+use tauri::State;
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LoadTabRuntimeCacheResponse {
+    pub key: String,
+    pub payload_base64: String,
+    pub row_count: i64,
+    pub column_count: i64,
+    pub byte_size: i64,
+    pub updated_at: String,
+}
+
+#[tauri::command]
+pub async fn save_tab_runtime_cache(
+    state: State<'_, Arc<AppState>>,
+    key: String,
+    payload_base64: String,
+    row_count: i64,
+    column_count: i64,
+) -> Result<(), String> {
+    let payload = BASE64.decode(payload_base64).map_err(|e| e.to_string())?;
+    state.storage.save_tab_runtime_cache(&key, payload, row_count, column_count).await
+}
+
+#[tauri::command]
+pub async fn load_tab_runtime_cache(
+    state: State<'_, Arc<AppState>>,
+    key: String,
+) -> Result<Option<LoadTabRuntimeCacheResponse>, String> {
+    let entry = state.storage.load_tab_runtime_cache(&key).await?;
+    Ok(entry.map(|entry| LoadTabRuntimeCacheResponse {
+        key: entry.key,
+        payload_base64: BASE64.encode(entry.payload),
+        row_count: entry.row_count,
+        column_count: entry.column_count,
+        byte_size: entry.byte_size,
+        updated_at: entry.updated_at,
+    }))
+}
+
+#[tauri::command]
+pub async fn delete_tab_runtime_cache(state: State<'_, Arc<AppState>>, key: String) -> Result<(), String> {
+    state.storage.delete_tab_runtime_cache(&key).await
+}
diff --git a/src-tauri/src/commands/table_export.rs b/src-tauri/src/commands/table_export.rs
new file mode 100644
index 0000000..9cdde5c
--- /dev/null
+++ b/src-tauri/src/commands/table_export.rs
@@ -0,0 +1,54 @@
+use std::sync::Arc;
+use tauri::{AppHandle, Emitter, State};
+
+use crate::commands::connection::AppState;
+
+pub use dbx_core::table_export::{ExportStatus, TableExportProgress, TableExportRequest};
+
+fn emit_progress(app: &AppHandle, progress: TableExportProgress) {
+    let _ = app.emit("table-export-progress", progress);
+}
+
+#[tauri::command]
+pub async fn start_table_export(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    request: TableExportRequest,
+) -> Result<(), String> {
+    let state = state.inner().clone();
+    let export_id = request.export_id.clone();
+
+    tokio::spawn(async move {
+        let result =
+            dbx_core::table_export::export_table_data_core(&state, &request, |progress| emit_progress(&app, progress))
+                .await;
+
+        let client_session_id = dbx_core::table_export::table_export_client_session_id(&export_id);
+        let _ =
+            state.close_client_session_pool(&request.connection_id, Some(&request.database), &client_session_id).await;
+
+        if let Err(e) = result {
+            emit_progress(
+                &app,
+                TableExportProgress {
+                    export_id: export_id.clone(),
+                    table_name: String::new(),
+                    rows_exported: 0,
+                    total_rows: None,
+                    status: ExportStatus::Error,
+                    error_message: Some(e),
+                },
+            );
+        }
+
+        dbx_core::database_export::clear_export_cancelled(&export_id).await;
+    });
+
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn cancel_table_export(export_id: String) -> Result<(), String> {
+    dbx_core::database_export::set_export_cancelled(&export_id).await;
+    Ok(())
+}
diff --git a/src-tauri/src/commands/table_import.rs b/src-tauri/src/commands/table_import.rs
new file mode 100644
index 0000000..9e28200
--- /dev/null
+++ b/src-tauri/src/commands/table_import.rs
@@ -0,0 +1,72 @@
+use std::collections::HashSet;
+use std::sync::{Arc, OnceLock};
+
+use tauri::{AppHandle, Emitter, State};
+use tokio::sync::RwLock;
+
+use crate::commands::connection::{ensure_connection_writable, AppState};
+use crate::commands::transfer::get_db_type;
+
+// Re-export types for backward compatibility
+pub use dbx_core::table_import::{
+    TableImportPreview, TableImportPreviewRequest, TableImportProgress, TableImportRequest, TableImportSummary,
+};
+
+static CANCELLED_IMPORTS: OnceLock<RwLock<HashSet<String>>> = OnceLock::new();
+
+fn cancelled_imports() -> &'static RwLock<HashSet<String>> {
+    CANCELLED_IMPORTS.get_or_init(|| RwLock::new(HashSet::new()))
+}
+
+fn emit_progress(app: &AppHandle, progress: TableImportProgress) {
+    let _ = app.emit("table-import-progress", progress);
+}
+
+async fn is_cancelled(import_id: &str) -> bool {
+    cancelled_imports().read().await.contains(import_id)
+}
+
+async fn clear_cancelled(import_id: &str) {
+    cancelled_imports().write().await.remove(import_id);
+}
+
+#[tauri::command]
+pub async fn preview_table_import_file(request: TableImportPreviewRequest) -> Result<TableImportPreview, String> {
+    dbx_core::table_import::preview_table_import_file_with_request(request).await
+}
+
+#[tauri::command]
+pub async fn import_table_file(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    request: TableImportRequest,
+) -> Result<TableImportSummary, String> {
+    clear_cancelled(&request.import_id).await;
+    // Reject import early if the connection is read-only — importing is inherently a write operation
+    ensure_connection_writable(&state, &request.connection_id, "Import").await?;
+    let db_type = get_db_type(&state, &request.connection_id).await?;
+    let database = (!request.database.trim().is_empty()).then_some(request.database.as_str());
+    let client_session_id = dbx_core::table_import::table_import_client_session_id(&request.import_id);
+    let pool_key =
+        state.get_or_create_pool_for_session(&request.connection_id, database, Some(&client_session_id)).await?;
+
+    let result = dbx_core::table_import::import_table_file_core(
+        &state,
+        &request,
+        &db_type,
+        &pool_key,
+        |import_id| Box::pin(is_cancelled(import_id)),
+        |progress| emit_progress(&app, progress),
+    )
+    .await;
+
+    let _ = state.close_client_session_pool(&request.connection_id, database, &client_session_id).await;
+    clear_cancelled(&request.import_id).await;
+    result
+}
+
+#[tauri::command]
+pub async fn cancel_table_import(import_id: String) -> Result<bool, String> {
+    cancelled_imports().write().await.insert(import_id);
+    Ok(true)
+}
diff --git a/src-tauri/src/commands/text_export.rs b/src-tauri/src/commands/text_export.rs
new file mode 100644
index 0000000..7e3267e
--- /dev/null
+++ b/src-tauri/src/commands/text_export.rs
@@ -0,0 +1,39 @@
+use dbx_core::text_export::{format_json, format_markdown, QueryResultTextExportData};
+use serde::Deserialize;
+use serde_json::Value;
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryResultTextExportRequest {
+    pub file_path: String,
+    pub columns: Vec<String>,
+    pub rows: Vec<Vec<Value>>,
+}
+
+impl QueryResultTextExportRequest {
+    fn into_data(self) -> QueryResultTextExportData {
+        QueryResultTextExportData { columns: self.columns, rows: self.rows }
+    }
+}
+
+#[tauri::command]
+pub async fn export_query_result_json(request: QueryResultTextExportRequest) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let file_path = request.file_path.clone();
+        let content = format_json(&request.into_data())?;
+        std::fs::write(file_path, format!("\u{FEFF}{content}")).map_err(|err| err.to_string())
+    })
+    .await
+    .map_err(|err| err.to_string())?
+}
+
+#[tauri::command]
+pub async fn export_query_result_markdown(request: QueryResultTextExportRequest) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let file_path = request.file_path.clone();
+        let content = format_markdown(&request.into_data());
+        std::fs::write(file_path, format!("\u{FEFF}{content}")).map_err(|err| err.to_string())
+    })
+    .await
+    .map_err(|err| err.to_string())?
+}
diff --git a/src-tauri/src/commands/transfer.rs b/src-tauri/src/commands/transfer.rs
new file mode 100644
index 0000000..6a94013
--- /dev/null
+++ b/src-tauri/src/commands/transfer.rs
@@ -0,0 +1,331 @@
+use std::sync::Arc;
+use tauri::{AppHandle, Emitter, State};
+
+use crate::commands::connection::{ensure_connection_writable, AppState};
+
+// Re-export types and functions used by other modules
+pub use dbx_core::transfer::{
+    get_db_type, TransferOwnershipPreview, TransferProgress, TransferRequest, TransferStatus,
+};
+
+fn emit_progress(app: &AppHandle, progress: TransferProgress) {
+    let _ = app.emit("transfer-progress", progress);
+}
+
+#[tauri::command]
+pub async fn start_transfer(
+    app: AppHandle,
+    state: State<'_, Arc<AppState>>,
+    request: TransferRequest,
+) -> Result<(), String> {
+    let state = state.inner().clone();
+    let transfer_id = request.transfer_id.clone();
+
+    // Reject transfer early if the target connection is read-only — writing to it is inherently required
+    ensure_connection_writable(&state, &request.target_connection_id, "Transfer").await?;
+
+    // Validate connections exist
+    let source_db_type = get_db_type(&state, &request.source_connection_id).await?;
+    let target_db_type = get_db_type(&state, &request.target_connection_id).await?;
+    dbx_core::transfer::validate_transfer_target_table_names(&request)?;
+
+    // Ensure pools
+    let source_pool_key =
+        state.get_or_create_pool(&request.source_connection_id, Some(&request.source_database)).await?;
+    let target_pool_key =
+        state.get_or_create_pool(&request.target_connection_id, Some(&request.target_database)).await?;
+
+    tokio::spawn(async move {
+        // Sort tables by FK dependency so referenced tables are transferred first.
+        let sorted_tables = dbx_core::transfer::sort_tables_by_fk_dependency(
+            &state,
+            &request.source_connection_id,
+            &request.source_database,
+            &request.source_schema,
+            &request.tables,
+            true,
+        )
+        .await
+        .unwrap_or_else(|e| {
+            log::warn!("[transfer] failed to sort tables by FK dependency, using original order: {e}");
+            request.tables.clone()
+        });
+
+        let total_tables = sorted_tables.len();
+        log::info!("[transfer] starting transfer_id={} tables={}", transfer_id, total_tables);
+
+        if matches!(source_db_type, dbx_core::models::connection::DatabaseType::Postgres)
+            && matches!(target_db_type, dbx_core::models::connection::DatabaseType::Postgres)
+        {
+            match dbx_core::transfer::transfer_postgres_schema_dependencies(
+                &state,
+                &request,
+                &source_pool_key,
+                &target_pool_key,
+                |progress| emit_progress(&app, progress),
+            )
+            .await
+            {
+                Ok(()) => {}
+                Err(e) if e == "Cancelled" => {
+                    emit_progress(
+                        &app,
+                        TransferProgress {
+                            transfer_id: transfer_id.clone(),
+                            table: "schema dependencies".to_string(),
+                            table_index: 0,
+                            total_tables,
+                            rows_transferred: 0,
+                            total_rows: None,
+                            status: TransferStatus::Cancelled,
+                            error: None,
+                            terminal: true,
+                        },
+                    );
+                    dbx_core::transfer::clear_cancelled(&transfer_id).await;
+                    return;
+                }
+                Err(e) => {
+                    emit_progress(
+                        &app,
+                        TransferProgress {
+                            transfer_id: transfer_id.clone(),
+                            table: "schema dependencies".to_string(),
+                            table_index: 0,
+                            total_tables,
+                            rows_transferred: 0,
+                            total_rows: None,
+                            status: TransferStatus::Error,
+                            error: Some(e),
+                            terminal: true,
+                        },
+                    );
+                    dbx_core::transfer::clear_cancelled(&transfer_id).await;
+                    return;
+                }
+            }
+        }
+
+        let mut failed_tables: Vec<String> = Vec::new();
+        for (i, table) in sorted_tables.iter().enumerate() {
+            if dbx_core::transfer::is_cancelled(&transfer_id).await {
+                emit_progress(
+                    &app,
+                    TransferProgress {
+                        transfer_id: transfer_id.clone(),
+                        table: table.clone(),
+                        table_index: i,
+                        total_tables,
+                        rows_transferred: 0,
+                        total_rows: None,
+                        status: TransferStatus::Cancelled,
+                        error: None,
+                        terminal: true,
+                    },
+                );
+                dbx_core::transfer::clear_cancelled(&transfer_id).await;
+                return;
+            }
+
+            log::info!("[transfer] table {}/{}: {}", i + 1, total_tables, table);
+
+            let mut last_rows_transferred = 0_u64;
+            let mut last_total_rows = None;
+
+            match dbx_core::transfer::transfer_table(
+                &state,
+                &request,
+                table,
+                i,
+                &source_db_type,
+                &target_db_type,
+                &source_pool_key,
+                &target_pool_key,
+                |progress| {
+                    last_rows_transferred = progress.rows_transferred;
+                    last_total_rows = progress.total_rows;
+                    emit_progress(&app, progress);
+                },
+            )
+            .await
+            {
+                Ok(rows) => {
+                    emit_progress(
+                        &app,
+                        TransferProgress {
+                            transfer_id: transfer_id.clone(),
+                            table: table.clone(),
+                            table_index: i,
+                            total_tables,
+                            rows_transferred: rows,
+                            total_rows: last_total_rows.or(Some(rows)),
+                            status: TransferStatus::TableDone,
+                            error: None,
+                            terminal: false,
+                        },
+                    );
+                }
+                Err(e) => {
+                    if e == "Cancelled" {
+                        emit_progress(
+                            &app,
+                            TransferProgress {
+                                transfer_id: transfer_id.clone(),
+                                table: table.clone(),
+                                table_index: i,
+                                total_tables,
+                                rows_transferred: 0,
+                                total_rows: None,
+                                status: TransferStatus::Cancelled,
+                                error: None,
+                                terminal: true,
+                            },
+                        );
+                        dbx_core::transfer::clear_cancelled(&transfer_id).await;
+                        return;
+                    }
+                    failed_tables.push(table.clone());
+                    emit_progress(
+                        &app,
+                        TransferProgress {
+                            transfer_id: transfer_id.clone(),
+                            table: table.clone(),
+                            table_index: i,
+                            total_tables,
+                            rows_transferred: last_rows_transferred,
+                            total_rows: last_total_rows,
+                            status: TransferStatus::Error,
+                            error: Some(e),
+                            terminal: false,
+                        },
+                    );
+                }
+            }
+        }
+
+        if matches!(source_db_type, dbx_core::models::connection::DatabaseType::Postgres)
+            && matches!(target_db_type, dbx_core::models::connection::DatabaseType::Postgres)
+        {
+            match dbx_core::transfer::transfer_postgres_schema_objects(
+                &state,
+                &request,
+                &source_pool_key,
+                &target_pool_key,
+                |progress| emit_progress(&app, progress),
+            )
+            .await
+            {
+                Ok(()) => {}
+                Err(e) if e == "Cancelled" => {
+                    emit_progress(
+                        &app,
+                        TransferProgress {
+                            transfer_id: transfer_id.clone(),
+                            table: "schema objects".to_string(),
+                            table_index: total_tables,
+                            total_tables,
+                            rows_transferred: 0,
+                            total_rows: None,
+                            status: TransferStatus::Cancelled,
+                            error: None,
+                            terminal: true,
+                        },
+                    );
+                    dbx_core::transfer::clear_cancelled(&transfer_id).await;
+                    return;
+                }
+                Err(e) => {
+                    failed_tables.push("schema objects".to_string());
+                    emit_progress(
+                        &app,
+                        TransferProgress {
+                            transfer_id: transfer_id.clone(),
+                            table: "schema objects".to_string(),
+                            table_index: total_tables,
+                            total_tables,
+                            rows_transferred: 0,
+                            total_rows: None,
+                            status: TransferStatus::Error,
+                            error: Some(e),
+                            terminal: false,
+                        },
+                    );
+                }
+            }
+        }
+
+        emit_progress(
+            &app,
+            TransferProgress {
+                transfer_id: transfer_id.clone(),
+                table: String::new(),
+                table_index: total_tables,
+                total_tables,
+                rows_transferred: 0,
+                total_rows: None,
+                status: if failed_tables.is_empty() { TransferStatus::Done } else { TransferStatus::Error },
+                error: if failed_tables.is_empty() {
+                    None
+                } else {
+                    Some(format!(
+                        "{} table(s) failed: {}",
+                        failed_tables.len(),
+                        failed_tables.iter().take(5).cloned().collect::<Vec<_>>().join(", ")
+                    ))
+                },
+                terminal: true,
+            },
+        );
+        dbx_core::transfer::clear_cancelled(&transfer_id).await;
+    });
+
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn preview_transfer_ownership(
+    state: State<'_, Arc<AppState>>,
+    request: TransferRequest,
+) -> Result<TransferOwnershipPreview, String> {
+    let state = state.inner().clone();
+    let source_db_type = get_db_type(&state, &request.source_connection_id).await?;
+    let target_db_type = get_db_type(&state, &request.target_connection_id).await?;
+    dbx_core::transfer::validate_transfer_target_table_names(&request)?;
+    let source_pool_key =
+        state.get_or_create_pool(&request.source_connection_id, Some(&request.source_database)).await?;
+    let target_pool_key =
+        state.get_or_create_pool(&request.target_connection_id, Some(&request.target_database)).await?;
+
+    dbx_core::transfer::preview_transfer_ownership(
+        &state,
+        &request,
+        &source_db_type,
+        &target_db_type,
+        &source_pool_key,
+        &target_pool_key,
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn cancel_transfer(transfer_id: String) -> Result<(), String> {
+    dbx_core::transfer::set_cancelled(&transfer_id).await;
+    Ok(())
+}
+
+/// Sort table names by foreign key dependency.
+/// `parents_first: true` → parent tables first (insert/export order).
+/// `parents_first: false` → child tables first (drop order).
+#[allow(dead_code)]
+#[tauri::command]
+pub async fn sort_tables_by_fk_dependency(
+    state: tauri::State<'_, std::sync::Arc<AppState>>,
+    connection_id: String,
+    database: String,
+    schema: String,
+    tables: Vec<String>,
+    parents_first: bool,
+) -> Result<Vec<String>, String> {
+    dbx_core::transfer::sort_tables_by_fk_dependency(&state, &connection_id, &database, &schema, &tables, parents_first)
+        .await
+}
diff --git a/src-tauri/src/commands/tunnel_profiles.rs b/src-tauri/src/commands/tunnel_profiles.rs
new file mode 100644
index 0000000..0213cc5
--- /dev/null
+++ b/src-tauri/src/commands/tunnel_profiles.rs
@@ -0,0 +1,19 @@
+use std::sync::Arc;
+
+use dbx_core::models::connection::TransportLayerConfig;
+use tauri::State;
+
+use super::connection::AppState;
+
+#[tauri::command]
+pub async fn load_tunnel_profiles(state: State<'_, Arc<AppState>>) -> Result<Vec<TransportLayerConfig>, String> {
+    state.storage.load_tunnel_profiles().await
+}
+
+#[tauri::command]
+pub async fn save_tunnel_profiles(
+    state: State<'_, Arc<AppState>>,
+    profiles: Vec<TransportLayerConfig>,
+) -> Result<(), String> {
+    state.storage.save_tunnel_profiles(&profiles).await
+}
diff --git a/src-tauri/src/commands/update.rs b/src-tauri/src/commands/update.rs
new file mode 100644
index 0000000..222e8b4
--- /dev/null
+++ b/src-tauri/src/commands/update.rs
@@ -0,0 +1,282 @@
+use std::sync::{
+    atomic::{AtomicU64, Ordering},
+    Arc,
+};
+
+pub use dbx_core::update::UpdateInfo;
+use serde::{Deserialize, Serialize};
+use tauri::{AppHandle, Emitter};
+use tauri_plugin_updater::UpdaterExt;
+
+const OFFICIAL_UPDATE_ENDPOINTS: [&str; 2] = [
+    "https://dl.dbxio.com/releases/latest/latest.json",
+    "https://github.com/t8y2/dbx/releases/latest/download/latest.json",
+];
+const R2_LATEST_RELEASE_DOWNLOAD_PREFIX: &str = "https://dl.dbxio.com/releases/latest/";
+const CNB_RELEASE_DOWNLOAD_PREFIX: &str = "https://cnb.cool/dbxio.com/dbx/-/releases/download/";
+const GITHUB_RELEASE_DOWNLOAD_PREFIX: &str = "https://github.com/t8y2/dbx/releases/download/";
+const ATOMGIT_RELEASE_DOWNLOAD_PREFIX: &str = "https://atomgit.com/t8y2/dbx/releases/download/";
+const UPDATE_DOWNLOAD_PROGRESS_EVENT: &str = "update-download-progress";
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum UpdateDownloadSource {
+    Official,
+    Cnb,
+    Atomgit,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct UpdateDownloadProgress {
+    pub downloaded: u64,
+    pub total: Option<u64>,
+}
+
+impl UpdateDownloadSource {
+    fn label(&self) -> &'static str {
+        match self {
+            Self::Official => "official",
+            Self::Cnb => "cnb",
+            Self::Atomgit => "atomgit",
+        }
+    }
+
+    fn endpoints(&self, latest_version: Option<&str>) -> Result<Vec<String>, String> {
+        match self {
+            Self::Official => Ok(OFFICIAL_UPDATE_ENDPOINTS.iter().map(|endpoint| endpoint.to_string()).collect()),
+            Self::Cnb => {
+                let version =
+                    latest_version.ok_or_else(|| "Latest version is required for CNB updates.".to_string())?;
+                Ok(vec![
+                    format!("{CNB_RELEASE_DOWNLOAD_PREFIX}{}/latest.json", tag_version(version)),
+                    OFFICIAL_UPDATE_ENDPOINTS[0].to_string(),
+                ])
+            }
+            Self::Atomgit => {
+                let version =
+                    latest_version.ok_or_else(|| "Latest version is required for AtomGit updates.".to_string())?;
+                Ok(vec![
+                    format!("{ATOMGIT_RELEASE_DOWNLOAD_PREFIX}{}/latest.json", tag_version(version)),
+                    OFFICIAL_UPDATE_ENDPOINTS[0].to_string(),
+                ])
+            }
+        }
+    }
+
+    fn rewrite_download_url(&self, url: &str) -> Result<Option<String>, String> {
+        let Some(target_prefix) = self.mirror_download_prefix() else { return Ok(None) };
+
+        if url.starts_with(target_prefix) {
+            return Ok(None);
+        }
+
+        // Mirror latest.json files still contain GitHub asset URLs, so rewrite only that known release prefix.
+        let rewritten = url
+            .strip_prefix(GITHUB_RELEASE_DOWNLOAD_PREFIX)
+            .map(|path| format!("{target_prefix}{path}"))
+            .ok_or_else(|| format!("Unsupported update download URL for {} source: {url}", self.label()))?;
+        Ok(Some(rewritten))
+    }
+
+    fn mirror_download_prefix(&self) -> Option<&'static str> {
+        match self {
+            Self::Cnb => Some(CNB_RELEASE_DOWNLOAD_PREFIX),
+            Self::Atomgit => Some(ATOMGIT_RELEASE_DOWNLOAD_PREFIX),
+            Self::Official => None,
+        }
+    }
+
+    fn r2_fallback_url(&self, url: &str) -> Result<Option<String>, String> {
+        if matches!(self, Self::Official) || url.starts_with(R2_LATEST_RELEASE_DOWNLOAD_PREFIX) {
+            return Ok(None);
+        }
+        let filename = url
+            .rsplit('/')
+            .next()
+            .filter(|name| !name.is_empty())
+            .ok_or_else(|| format!("Unsupported update download URL for {} source: {url}", self.label()))?;
+        Ok(Some(format!("{R2_LATEST_RELEASE_DOWNLOAD_PREFIX}{filename}")))
+    }
+}
+
+fn tag_version(version: &str) -> String {
+    let version = version.trim();
+    if version.starts_with('v') {
+        version.to_string()
+    } else {
+        format!("v{version}")
+    }
+}
+
+#[tauri::command]
+pub async fn check_for_updates(locale: Option<String>) -> Result<UpdateInfo, String> {
+    let locale = locale.unwrap_or_else(|| "zh-CN".to_string());
+    let release = dbx_core::update::fetch_latest_release(&locale).await?;
+    let current_version = env!("CARGO_PKG_VERSION");
+    let mut info = dbx_core::update::build_update_info(release, current_version);
+    info.portable_mode = crate::data_dir::is_portable_mode();
+    Ok(info)
+}
+
+#[tauri::command]
+pub async fn get_system_proxy_url() -> Option<String> {
+    tauri::async_runtime::spawn_blocking(dbx_core::update::system_proxy_url).await.ok().flatten()
+}
+
+#[tauri::command]
+pub async fn download_and_install_update(
+    app: AppHandle,
+    source: UpdateDownloadSource,
+    latest_version: Option<String>,
+) -> Result<(), String> {
+    if crate::data_dir::is_portable_mode() {
+        return Err("Portable builds cannot use the in-app installer.".to_string());
+    }
+
+    let endpoint_urls = source.endpoints(latest_version.as_deref())?;
+    println!("[DBX updater] checking from {} endpoints: {}", source.label(), endpoint_urls.join(", "));
+    let mut endpoints = Vec::with_capacity(endpoint_urls.len());
+    for endpoint_url in endpoint_urls {
+        endpoints.push(endpoint_url.parse().map_err(|e| format!("Invalid update endpoint: {e}"))?);
+    }
+    let mut builder =
+        app.updater_builder().endpoints(endpoints).map_err(|e| format!("Failed to configure updater endpoint: {e}"))?;
+
+    if let Some(proxy_url) = dbx_core::update::system_proxy_url() {
+        let proxy = proxy_url.parse().map_err(|e| format!("Invalid system proxy URL: {e}"))?;
+        builder = builder.proxy(proxy);
+    }
+
+    let updater = builder.build().map_err(|e| format!("Failed to create updater: {e}"))?;
+    let update = updater.check().await.map_err(|e| format!("Failed to check updates: {e}"))?;
+    let Some(mut update) = update else {
+        return Err("No update available.".to_string());
+    };
+    if let Some(download_url) = source.rewrite_download_url(update.download_url.as_str())? {
+        update.download_url = download_url.parse().map_err(|e| format!("Invalid CNB update download URL: {e}"))?;
+    }
+    if !update_url_is_available(update.download_url.as_str()).await {
+        if let Some(fallback_url) = source.r2_fallback_url(update.download_url.as_str())? {
+            println!("[DBX updater] {} asset unavailable; falling back to R2: {fallback_url}", source.label());
+            update.download_url = fallback_url.parse().map_err(|e| format!("Invalid R2 update download URL: {e}"))?;
+        }
+    }
+    println!("[DBX updater] downloading from {} URL: {}", source.label(), update.download_url);
+
+    let downloaded = Arc::new(AtomicU64::new(0));
+    let finished_downloaded = Arc::clone(&downloaded);
+    update
+        .download_and_install(
+            |chunk_len, total| {
+                let downloaded =
+                    downloaded.fetch_add(chunk_len as u64, Ordering::Relaxed).saturating_add(chunk_len as u64);
+                let _ = app.emit(UPDATE_DOWNLOAD_PROGRESS_EVENT, UpdateDownloadProgress { downloaded, total });
+            },
+            || {
+                let downloaded = finished_downloaded.load(Ordering::Relaxed);
+                let _ = app.emit(
+                    UPDATE_DOWNLOAD_PROGRESS_EVENT,
+                    UpdateDownloadProgress { downloaded, total: Some(downloaded) },
+                );
+            },
+        )
+        .await
+        .map_err(|e| format!("Failed to download and install update: {e}"))
+}
+
+async fn update_url_is_available(url: &str) -> bool {
+    let client = match reqwest::Client::builder().timeout(std::time::Duration::from_secs(10)).build() {
+        Ok(client) => client,
+        Err(_) => return false,
+    };
+    // Request only the first byte because some release hosts do not implement HEAD consistently.
+    client
+        .get(url)
+        .header(reqwest::header::RANGE, "bytes=0-0")
+        .send()
+        .await
+        .is_ok_and(|response| response.status().is_success())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        tag_version, UpdateDownloadSource, ATOMGIT_RELEASE_DOWNLOAD_PREFIX, CNB_RELEASE_DOWNLOAD_PREFIX,
+        OFFICIAL_UPDATE_ENDPOINTS, R2_LATEST_RELEASE_DOWNLOAD_PREFIX,
+    };
+
+    #[test]
+    fn normalizes_update_tag_versions() {
+        assert_eq!(tag_version("0.5.39"), "v0.5.39");
+        assert_eq!(tag_version("v0.5.39"), "v0.5.39");
+    }
+
+    #[test]
+    fn builds_official_update_endpoints() {
+        let endpoints = UpdateDownloadSource::Official.endpoints(None).unwrap();
+        assert_eq!(endpoints, OFFICIAL_UPDATE_ENDPOINTS);
+    }
+
+    #[test]
+    fn builds_cnb_update_endpoint_for_tag() {
+        let endpoints = UpdateDownloadSource::Cnb.endpoints(Some("0.5.39")).unwrap();
+        assert_eq!(
+            endpoints,
+            vec![format!("{CNB_RELEASE_DOWNLOAD_PREFIX}v0.5.39/latest.json"), OFFICIAL_UPDATE_ENDPOINTS[0].to_string()]
+        );
+    }
+
+    #[test]
+    fn builds_atomgit_update_endpoint_for_tag() {
+        let endpoints = UpdateDownloadSource::Atomgit.endpoints(Some("0.5.44")).unwrap();
+        assert_eq!(
+            endpoints,
+            vec![
+                format!("{ATOMGIT_RELEASE_DOWNLOAD_PREFIX}v0.5.44/latest.json"),
+                OFFICIAL_UPDATE_ENDPOINTS[0].to_string(),
+            ]
+        );
+    }
+
+    #[test]
+    fn rewrites_github_asset_url_to_cnb() {
+        let download_url = UpdateDownloadSource::Cnb
+            .rewrite_download_url("https://github.com/t8y2/dbx/releases/download/v0.5.39/DBX_0.5.39_aarch64.dmg")
+            .unwrap()
+            .unwrap();
+        assert_eq!(download_url, "https://cnb.cool/dbxio.com/dbx/-/releases/download/v0.5.39/DBX_0.5.39_aarch64.dmg");
+    }
+
+    #[test]
+    fn accepts_existing_cnb_asset_url() {
+        let download_url = UpdateDownloadSource::Cnb
+            .rewrite_download_url("https://cnb.cool/dbxio.com/dbx/-/releases/download/v0.5.39/DBX_0.5.39_aarch64.dmg")
+            .unwrap();
+        assert_eq!(download_url, None);
+    }
+
+    #[test]
+    fn rewrites_github_asset_url_to_atomgit() {
+        let download_url = UpdateDownloadSource::Atomgit
+            .rewrite_download_url("https://github.com/t8y2/dbx/releases/download/v0.5.44/DBX_0.5.44_x64.dmg")
+            .unwrap()
+            .unwrap();
+        assert_eq!(download_url, "https://atomgit.com/t8y2/dbx/releases/download/v0.5.44/DBX_0.5.44_x64.dmg");
+    }
+
+    #[test]
+    fn accepts_existing_atomgit_asset_url() {
+        let download_url = UpdateDownloadSource::Atomgit
+            .rewrite_download_url("https://atomgit.com/t8y2/dbx/releases/download/v0.5.44/DBX_0.5.44_x64.dmg")
+            .unwrap();
+        assert_eq!(download_url, None);
+    }
+
+    #[test]
+    fn builds_r2_fallback_for_mirror_asset() {
+        let fallback = UpdateDownloadSource::Atomgit
+            .r2_fallback_url("https://atomgit.com/t8y2/dbx/releases/download/v0.5.44/DBX_0.5.44_x64.dmg")
+            .unwrap();
+        assert_eq!(fallback, Some(format!("{R2_LATEST_RELEASE_DOWNLOAD_PREFIX}DBX_0.5.44_x64.dmg")));
+    }
+}
diff --git a/src-tauri/src/commands/window_controls.rs b/src-tauri/src/commands/window_controls.rs
new file mode 100644
index 0000000..0c60076
--- /dev/null
+++ b/src-tauri/src/commands/window_controls.rs
@@ -0,0 +1,133 @@
+#[cfg(target_os = "macos")]
+async fn set_macos_traffic_light_position_inner(
+    window: tauri::Window,
+    target_x: f64,
+    target_center_y: f64,
+    ui_scale: f64,
+) -> Result<MacosTrafficLightLayout, String> {
+    let ns_window = window.ns_window().map_err(|err| err.to_string())? as usize;
+    let (tx, rx) = tokio::sync::oneshot::channel();
+    window
+        .run_on_main_thread(move || unsafe {
+            use objc2_app_kit::{NSWindow, NSWindowButton};
+
+            let ns_window = &*(ns_window as *mut NSWindow);
+            let Some(close) = ns_window.standardWindowButton(NSWindowButton::CloseButton) else {
+                let _ = tx.send(None);
+                return;
+            };
+            let Some(miniaturize) = ns_window.standardWindowButton(NSWindowButton::MiniaturizeButton) else {
+                let _ = tx.send(None);
+                return;
+            };
+            let zoom = ns_window.standardWindowButton(NSWindowButton::ZoomButton);
+
+            let Some(title_bar_container_view) = close.superview().and_then(|view| view.superview()) else {
+                let _ = tx.send(None);
+                return;
+            };
+
+            let close_rect = close.frame();
+            let window_height = ns_window.frame().size.height;
+            let target_window_center_y = target_center_y * ui_scale;
+            let target_y = (target_window_center_y - close_rect.size.height / 2.0).max(0.0);
+            let title_bar_frame_height = close_rect.size.height + target_y;
+            let mut title_bar_rect = title_bar_container_view.frame();
+            title_bar_rect.size.height = title_bar_frame_height;
+            title_bar_rect.origin.y = window_height - title_bar_frame_height;
+            title_bar_container_view.setFrame(title_bar_rect);
+
+            let close_rect = close.frame();
+            let current_window_rect =
+                close.superview().map(|view| view.convertRect_toView(close_rect, None)).unwrap_or(close_rect);
+            let current_center_y =
+                window_height - (current_window_rect.origin.y + current_window_rect.size.height / 2.0);
+            let center_delta_y = target_window_center_y - current_center_y;
+            let space_between = miniaturize.frame().origin.x - close_rect.origin.x;
+            let mut buttons = vec![close, miniaturize];
+            if let Some(zoom) = zoom {
+                buttons.push(zoom);
+            }
+            for (index, button) in buttons.into_iter().enumerate() {
+                let mut rect = button.frame();
+                rect.origin.x = target_x + (index as f64 * space_between);
+                rect.origin.y -= center_delta_y;
+                button.setFrameOrigin(rect.origin);
+            }
+
+            let Some(close) = ns_window.standardWindowButton(NSWindowButton::CloseButton) else {
+                let _ = tx.send(None);
+                return;
+            };
+            let zoom = ns_window.standardWindowButton(NSWindowButton::ZoomButton);
+            let close_rect = close.frame();
+            let close_window_rect =
+                close.superview().map(|view| view.convertRect_toView(close_rect, None)).unwrap_or(close_rect);
+            let reserved_button_rect = zoom
+                .as_ref()
+                .and_then(|button| button.superview().map(|view| view.convertRect_toView(button.frame(), None)))
+                .unwrap_or(close_window_rect);
+            let button_center_y = window_height - (close_window_rect.origin.y + close_window_rect.size.height / 2.0);
+            let _ = tx.send(Some(MacosTrafficLightLayout {
+                x: close_window_rect.origin.x,
+                y: target_y,
+                center_y: button_center_y,
+                previous_center_y: current_center_y,
+                reserved_inset: reserved_button_rect.origin.x + reserved_button_rect.size.width + 8.0,
+            }));
+        })
+        .map_err(|err| err.to_string())?;
+    rx.await.map_err(|err| err.to_string())?.ok_or_else(|| "Unable to locate macOS traffic light buttons".to_string())
+}
+
+#[cfg(not(target_os = "macos"))]
+async fn set_macos_traffic_light_position_inner(
+    _window: tauri::Window,
+    x: f64,
+    target_center_y: f64,
+    ui_scale: f64,
+) -> Result<MacosTrafficLightLayout, String> {
+    let center_y = target_center_y * ui_scale;
+    Ok(MacosTrafficLightLayout { x, y: center_y, center_y, previous_center_y: center_y, reserved_inset: 0.0 })
+}
+
+fn validate_macos_traffic_light_position(x: f64, y: f64, scale: f64) -> Result<(), String> {
+    if !x.is_finite() || !y.is_finite() || !scale.is_finite() || scale <= 0.0 {
+        return Err("Invalid traffic light position".to_string());
+    }
+    Ok(())
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct MacosTrafficLightLayout {
+    x: f64,
+    y: f64,
+    center_y: f64,
+    previous_center_y: f64,
+    reserved_inset: f64,
+}
+
+#[tauri::command]
+pub async fn set_macos_traffic_light_position(
+    window: tauri::Window,
+    x: f64,
+    y: f64,
+    scale: f64,
+) -> Result<MacosTrafficLightLayout, String> {
+    validate_macos_traffic_light_position(x, y, scale)?;
+    // Await AppKit work asynchronously so the main thread can execute the scheduled closure.
+    set_macos_traffic_light_position_inner(window, x, y, scale).await
+}
+
+#[cfg(test)]
+mod tests {
+    use super::validate_macos_traffic_light_position;
+
+    #[test]
+    fn validates_macos_traffic_light_position_inputs() {
+        assert!(validate_macos_traffic_light_position(16.0, 18.0, 1.0).is_ok());
+        assert!(validate_macos_traffic_light_position(f64::NAN, 18.0, 1.0).is_err());
+        assert!(validate_macos_traffic_light_position(16.0, f64::INFINITY, 1.0).is_err());
+        assert!(validate_macos_traffic_light_position(16.0, 18.0, 0.0).is_err());
+    }
+}
diff --git a/src-tauri/src/commands/xlsx_export.rs b/src-tauri/src/commands/xlsx_export.rs
new file mode 100644
index 0000000..a7e52c9
--- /dev/null
+++ b/src-tauri/src/commands/xlsx_export.rs
@@ -0,0 +1,46 @@
+use dbx_core::xlsx_export::{build_xlsx_workbook, build_xlsx_workbook_multi, XlsxWorksheetData};
+use serde::Deserialize;
+use serde_json::Value;
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryResultXlsxExportRequest {
+    pub file_path: String,
+    pub sheet_name: Option<String>,
+    pub columns: Vec<String>,
+    #[serde(default)]
+    pub column_types: Vec<String>,
+    pub rows: Vec<Vec<Value>>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct QueryResultsXlsxExportRequest {
+    pub file_path: String,
+    pub worksheets: Vec<XlsxWorksheetData>,
+}
+
+#[tauri::command]
+pub async fn export_query_result_xlsx(request: QueryResultXlsxExportRequest) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let workbook = build_xlsx_workbook(&XlsxWorksheetData {
+            sheet_name: request.sheet_name,
+            columns: request.columns,
+            column_types: request.column_types,
+            rows: request.rows,
+        })?;
+        std::fs::write(&request.file_path, workbook).map_err(|err| err.to_string())
+    })
+    .await
+    .map_err(|err| err.to_string())?
+}
+
+#[tauri::command]
+pub async fn export_query_results_xlsx(request: QueryResultsXlsxExportRequest) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let workbook = build_xlsx_workbook_multi(&request.worksheets)?;
+        std::fs::write(&request.file_path, workbook).map_err(|err| err.to_string())
+    })
+    .await
+    .map_err(|err| err.to_string())?
+}
diff --git a/src-tauri/src/commands/zookeeper_cmd.rs b/src-tauri/src/commands/zookeeper_cmd.rs
new file mode 100644
index 0000000..8956a2a
--- /dev/null
+++ b/src-tauri/src/commands/zookeeper_cmd.rs
@@ -0,0 +1,57 @@
+use std::sync::Arc;
+
+use tauri::State;
+
+use crate::commands::connection::{ensure_connection_writable, AppState};
+use dbx_core::agent_kv::{KvDeleteResponse, KvGetResponse, KvListPrefixResponse, KvPutOptions, KvPutResponse, KvValue};
+
+#[tauri::command]
+pub async fn zookeeper_list_prefix(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    prefix: String,
+    limit: usize,
+    continuation: Option<String>,
+    recursive: Option<bool>,
+) -> Result<KvListPrefixResponse, String> {
+    dbx_core::agent_kv::kv_list_prefix_core_with_options(
+        &state,
+        &connection_id,
+        &prefix,
+        limit,
+        continuation.as_deref(),
+        recursive,
+    )
+    .await
+}
+
+#[tauri::command]
+pub async fn zookeeper_get(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: String,
+) -> Result<KvGetResponse, String> {
+    dbx_core::agent_kv::kv_get_core(&state, &connection_id, &key).await
+}
+
+#[tauri::command]
+pub async fn zookeeper_put(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: String,
+    value: KvValue,
+    options: Option<KvPutOptions>,
+) -> Result<KvPutResponse, String> {
+    ensure_connection_writable(&state, &connection_id, "Put").await?;
+    dbx_core::agent_kv::kv_put_core_with_options(&state, &connection_id, &key, value, options.unwrap_or_default()).await
+}
+
+#[tauri::command]
+pub async fn zookeeper_delete(
+    state: State<'_, Arc<AppState>>,
+    connection_id: String,
+    key: String,
+) -> Result<KvDeleteResponse, String> {
+    ensure_connection_writable(&state, &connection_id, "Delete").await?;
+    dbx_core::agent_kv::kv_delete_core(&state, &connection_id, &key).await
+}
diff --git a/src-tauri/src/data_dir.rs b/src-tauri/src/data_dir.rs
new file mode 100644
index 0000000..599bc5b
--- /dev/null
+++ b/src-tauri/src/data_dir.rs
@@ -0,0 +1,203 @@
+use std::path::{Path, PathBuf};
+
+#[cfg(target_os = "windows")]
+const PORTABLE_MARKER: &str = "portable.dbx";
+#[cfg(target_os = "windows")]
+const INSTALLER_MARKER: &str = "uninstall.exe";
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum DataDirMode {
+    Default,
+    EnvOverride,
+    Portable { exe_dir: PathBuf },
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DataDirResolution {
+    pub data_dir: PathBuf,
+    pub default_data_dir: PathBuf,
+    pub mode: DataDirMode,
+    portable_data_dir: Option<PathBuf>,
+}
+
+impl DataDirResolution {
+    pub fn uses_custom_data_dir(&self) -> bool {
+        matches!(self.mode, DataDirMode::EnvOverride | DataDirMode::Portable { .. })
+    }
+
+    pub fn is_portable_mode(&self) -> bool {
+        matches!(self.mode, DataDirMode::Portable { .. })
+    }
+}
+
+pub fn resolve_data_dir_with_mode(default_app_data_dir: PathBuf) -> DataDirResolution {
+    let env_data_dir = std::env::var_os("DBX_DATA_DIR").filter(|value| !value.is_empty()).map(PathBuf::from);
+
+    #[cfg(target_os = "windows")]
+    let exe_dir = current_exe_dir();
+    #[cfg(not(target_os = "windows"))]
+    let exe_dir = None;
+
+    let portable_marker_exists = exe_dir.as_deref().is_some_and(portable_marker_exists);
+    let installer_marker_exists = exe_dir.as_deref().is_some_and(installer_marker_exists);
+
+    resolve_data_dir_from_inputs(
+        default_app_data_dir,
+        exe_dir,
+        portable_marker_exists,
+        installer_marker_exists,
+        env_data_dir,
+    )
+}
+
+pub fn alternative_data_dir(resolution: &DataDirResolution) -> Option<PathBuf> {
+    match &resolution.mode {
+        DataDirMode::Portable { .. } => Some(resolution.default_data_dir.clone()),
+        DataDirMode::Default => resolution.portable_data_dir.clone(),
+        DataDirMode::EnvOverride => None,
+    }
+}
+
+pub fn is_portable_mode() -> bool {
+    resolve_data_dir_with_mode(PathBuf::new()).is_portable_mode()
+}
+
+#[cfg(target_os = "windows")]
+fn current_exe_dir() -> Option<PathBuf> {
+    std::env::current_exe().ok().and_then(|path| path.parent().map(Path::to_path_buf))
+}
+
+#[cfg(target_os = "windows")]
+fn portable_marker_exists(exe_dir: &Path) -> bool {
+    exe_dir.join(PORTABLE_MARKER).is_file()
+}
+
+#[cfg(not(target_os = "windows"))]
+fn portable_marker_exists(_exe_dir: &Path) -> bool {
+    false
+}
+
+#[cfg(target_os = "windows")]
+fn installer_marker_exists(exe_dir: &Path) -> bool {
+    exe_dir.join(INSTALLER_MARKER).is_file()
+}
+
+#[cfg(not(target_os = "windows"))]
+fn installer_marker_exists(_exe_dir: &Path) -> bool {
+    false
+}
+
+fn resolve_data_dir_from_inputs(
+    default_app_data_dir: PathBuf,
+    exe_dir: Option<PathBuf>,
+    portable_marker_exists: bool,
+    installer_marker_exists: bool,
+    env_data_dir: Option<PathBuf>,
+) -> DataDirResolution {
+    let portable_data_dir = exe_dir.as_ref().filter(|_| portable_marker_exists).map(|dir| dir.join("data"));
+
+    if let Some(env_dir) = env_data_dir {
+        return DataDirResolution {
+            data_dir: env_dir,
+            default_data_dir: default_app_data_dir,
+            mode: DataDirMode::EnvOverride,
+            portable_data_dir,
+        };
+    }
+
+    if portable_marker_exists && !installer_marker_exists {
+        if let Some(exe_dir) = exe_dir {
+            return DataDirResolution {
+                data_dir: exe_dir.join("data"),
+                default_data_dir: default_app_data_dir,
+                mode: DataDirMode::Portable { exe_dir },
+                portable_data_dir,
+            };
+        }
+    }
+
+    DataDirResolution {
+        data_dir: default_app_data_dir.clone(),
+        default_data_dir: default_app_data_dir,
+        mode: DataDirMode::Default,
+        portable_data_dir,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+
+    use super::{alternative_data_dir, resolve_data_dir_from_inputs, DataDirMode};
+
+    #[test]
+    fn uses_portable_data_dir_when_marker_exists_without_installer_marker() {
+        let default_dir = PathBuf::from(r"C:\Users\Administrator\AppData\Roaming\com.dbx.app");
+        let exe_dir = PathBuf::from(r"D:\Apps\DBX");
+
+        let resolution = resolve_data_dir_from_inputs(default_dir, Some(exe_dir.clone()), true, false, None);
+
+        assert_eq!(resolution.data_dir, exe_dir.join("data"));
+        assert_eq!(resolution.mode, DataDirMode::Portable { exe_dir });
+        assert!(resolution.uses_custom_data_dir());
+        assert!(resolution.is_portable_mode());
+    }
+
+    #[test]
+    fn installer_marker_keeps_installed_mode_even_when_portable_marker_exists() {
+        let default_dir = PathBuf::from(r"C:\Users\Administrator\AppData\Roaming\com.dbx.app");
+        let exe_dir = PathBuf::from(r"C:\Program Files\DBX");
+
+        let resolution = resolve_data_dir_from_inputs(default_dir.clone(), Some(exe_dir), true, true, None);
+
+        assert_eq!(resolution.data_dir, default_dir);
+        assert_eq!(resolution.mode, DataDirMode::Default);
+        assert!(!resolution.uses_custom_data_dir());
+        assert!(!resolution.is_portable_mode());
+    }
+
+    #[test]
+    fn env_override_wins_over_installer_and_portable_markers() {
+        let default_dir = PathBuf::from(r"C:\Users\Administrator\AppData\Roaming\com.dbx.app");
+        let exe_dir = PathBuf::from(r"C:\Program Files\DBX");
+        let env_dir = PathBuf::from(r"E:\DBXData");
+
+        let resolution = resolve_data_dir_from_inputs(default_dir, Some(exe_dir), true, true, Some(env_dir.clone()));
+
+        assert_eq!(resolution.data_dir, env_dir);
+        assert_eq!(resolution.mode, DataDirMode::EnvOverride);
+        assert!(resolution.uses_custom_data_dir());
+        assert!(!resolution.is_portable_mode());
+    }
+
+    #[test]
+    fn portable_mode_can_import_from_default_data_dir() {
+        let default_dir = PathBuf::from(r"C:\Users\Administrator\AppData\Roaming\com.dbx.app");
+        let exe_dir = PathBuf::from(r"D:\Apps\DBX");
+
+        let resolution = resolve_data_dir_from_inputs(default_dir.clone(), Some(exe_dir), true, false, None);
+
+        assert_eq!(alternative_data_dir(&resolution), Some(default_dir));
+    }
+
+    #[test]
+    fn installed_mode_can_import_from_leftover_portable_data_dir() {
+        let default_dir = PathBuf::from(r"C:\Users\Administrator\AppData\Roaming\com.dbx.app");
+        let exe_dir = PathBuf::from(r"C:\Program Files\DBX");
+
+        let resolution = resolve_data_dir_from_inputs(default_dir, Some(exe_dir.clone()), true, true, None);
+
+        assert_eq!(alternative_data_dir(&resolution), Some(exe_dir.join("data")));
+    }
+
+    #[test]
+    fn env_override_does_not_import_from_implicit_alternative_dir() {
+        let default_dir = PathBuf::from(r"C:\Users\Administrator\AppData\Roaming\com.dbx.app");
+        let exe_dir = PathBuf::from(r"D:\Apps\DBX");
+
+        let resolution =
+            resolve_data_dir_from_inputs(default_dir, Some(exe_dir), true, false, Some(PathBuf::from(r"E:\DBXData")));
+
+        assert_eq!(alternative_data_dir(&resolution), None);
+    }
+}
diff --git a/src-tauri/src/db/mod.rs b/src-tauri/src/db/mod.rs
new file mode 100644
index 0000000..a74beda
--- /dev/null
+++ b/src-tauri/src/db/mod.rs
@@ -0,0 +1,4 @@
+#[allow(unused_imports)]
+pub use dbx_core::db::*;
+#[allow(unused_imports)]
+pub use dbx_core::types::*;
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
new file mode 100644
index 0000000..6fc6afb
--- /dev/null
+++ b/src-tauri/src/lib.rs
@@ -0,0 +1,1361 @@
+mod commands;
+mod data_dir;
+mod db;
+#[cfg(target_os = "macos")]
+mod macos_app_delegate;
+mod models;
+mod window_state_guard;
+
+use commands::connection::AppState;
+use dbx_core::storage::{maybe_import_user_data_db, DesktopIconTheme, DesktopSettings, Storage};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::Instant;
+#[cfg(target_os = "macos")]
+use tauri::menu::Menu;
+#[cfg(target_os = "macos")]
+use tauri::menu::{AboutMetadata, MenuItem, PredefinedMenuItem, Submenu};
+use tauri::RunEvent;
+use tauri::{
+    menu::MenuBuilder,
+    tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
+};
+use tauri::{Emitter, Manager};
+#[cfg(target_os = "macos")]
+use tauri_plugin_clipboard_manager::ClipboardExt;
+#[cfg(any(windows, target_os = "linux"))]
+use tauri_plugin_deep_link::DeepLinkExt;
+
+const DESKTOP_TRAY_ID: &str = "main-tray";
+const APP_CLOSE_REQUESTED_EVENT: &str = "dbx-app-close-requested";
+#[cfg(target_os = "macos")]
+const APP_MENU_QUIT_ID: &str = "app-menu-quit";
+#[cfg(target_os = "macos")]
+const APP_MENU_COPY_SUPPORT_INFO_ID: &str = "app-menu-copy-support-info";
+
+pub struct CloseBehaviorState {
+    confirmed_exit: AtomicBool,
+}
+
+impl CloseBehaviorState {
+    fn new() -> Self {
+        Self { confirmed_exit: AtomicBool::new(false) }
+    }
+
+    pub(crate) fn allow_next_exit(&self) {
+        self.confirmed_exit.store(true, Ordering::Relaxed);
+    }
+
+    fn take_confirmed_exit(&self) -> bool {
+        self.confirmed_exit.swap(false, Ordering::Relaxed)
+    }
+}
+#[cfg(target_os = "macos")]
+const MACOS_TRAY_ICON: tauri::image::Image<'_> = tauri::include_image!("icons/tray-macos-template.png");
+#[cfg(target_os = "macos")]
+const ABOUT_APP_ICON: tauri::image::Image<'_> = tauri::include_image!("icons/icon.png");
+#[cfg(not(target_os = "macos"))]
+const BLACK_APP_ICON: tauri::image::Image<'_> = tauri::include_image!("icons/icon-black.png");
+#[cfg(target_os = "macos")]
+const MACOS_DEFAULT_APP_ICON: &[u8] = include_bytes!("../icons/icon.icns");
+#[cfg(target_os = "macos")]
+const MACOS_DARK_APP_ICON: &[u8] = include_bytes!("../icons/icon-macos-dark.icns");
+
+pub(crate) fn apply_debug_log_level(debug_logging_enabled: bool) {
+    log::set_max_level(if debug_logging_enabled { log::LevelFilter::Debug } else { log::LevelFilter::Off });
+}
+
+fn should_hide_window_on_close(target_os: &str) -> bool {
+    matches!(target_os, "macos" | "windows")
+}
+
+fn should_setup_desktop_tray(target_os: &str, show_tray_icon: bool, linux_appindicator_available: bool) -> bool {
+    show_tray_icon
+        && (matches!(target_os, "macos" | "windows") || (target_os == "linux" && linux_appindicator_available))
+}
+
+#[cfg(target_os = "linux")]
+fn linux_appindicator_available() -> bool {
+    const APPINDICATOR_LIBRARIES: &[&str] = &["libayatana-appindicator3.so.1", "libappindicator3.so.1"];
+
+    APPINDICATOR_LIBRARIES.iter().any(|library| {
+        // tray-icon loads AppIndicator dynamically and panics when neither ABI is
+        // installed, so probe the same libraries before entering that code path.
+        unsafe { libloading::Library::new(library).is_ok() }
+    })
+}
+
+#[cfg(not(target_os = "linux"))]
+fn linux_appindicator_available() -> bool {
+    false
+}
+
+#[cfg(test)]
+fn uses_application_level_icon(target_os: &str) -> bool {
+    target_os == "macos"
+}
+
+fn should_show_main_window_after_setup() -> bool {
+    true
+}
+
+fn should_confirm_app_exit_request(target_os: &str, exit_code: Option<i32>, confirmed_exit: bool) -> bool {
+    should_hide_window_on_close(target_os) && exit_code != Some(tauri::RESTART_EXIT_CODE) && !confirmed_exit
+}
+
+fn native_window_decorations_override(target_os: &str) -> Option<bool> {
+    match target_os {
+        "windows" | "linux" => Some(false),
+        _ => None,
+    }
+}
+
+#[cfg(target_os = "macos")]
+fn build_app_menu<R: tauri::Runtime>(app_handle: &tauri::AppHandle<R>) -> tauri::Result<Menu<R>> {
+    let pkg_info = app_handle.package_info();
+    let app_name = pkg_info.name.clone();
+    let about_metadata = AboutMetadata {
+        name: Some(app_name.clone()),
+        version: Some(pkg_info.version.to_string()),
+        copyright: Some(commands::support_info::format_support_info_for_native_about()),
+        icon: Some(ABOUT_APP_ICON),
+        ..Default::default()
+    };
+    let copy_support_info_item =
+        MenuItem::with_id(app_handle, APP_MENU_COPY_SUPPORT_INFO_ID, "Copy Support Info", true, None::<&str>)?;
+    let quit_item = MenuItem::with_id(app_handle, APP_MENU_QUIT_ID, format!("Quit {app_name}"), true, Some("Cmd+Q"))?;
+
+    Menu::with_items(
+        app_handle,
+        &[
+            &Submenu::with_items(
+                app_handle,
+                app_name,
+                true,
+                &[
+                    &PredefinedMenuItem::about(app_handle, None, Some(about_metadata))?,
+                    &copy_support_info_item,
+                    &PredefinedMenuItem::separator(app_handle)?,
+                    &PredefinedMenuItem::services(app_handle, None)?,
+                    &PredefinedMenuItem::separator(app_handle)?,
+                    &PredefinedMenuItem::hide(app_handle, None)?,
+                    &PredefinedMenuItem::hide_others(app_handle, None)?,
+                    &PredefinedMenuItem::separator(app_handle)?,
+                    &quit_item,
+                ],
+            )?,
+            &Submenu::with_items(app_handle, "File", true, &[&PredefinedMenuItem::close_window(app_handle, None)?])?,
+            &Submenu::with_items(
+                app_handle,
+                "Edit",
+                true,
+                &[
+                    &PredefinedMenuItem::undo(app_handle, None)?,
+                    &PredefinedMenuItem::redo(app_handle, None)?,
+                    &PredefinedMenuItem::separator(app_handle)?,
+                    &PredefinedMenuItem::cut(app_handle, None)?,
+                    &PredefinedMenuItem::copy(app_handle, None)?,
+                    &PredefinedMenuItem::paste(app_handle, None)?,
+                    &PredefinedMenuItem::select_all(app_handle, None)?,
+                ],
+            )?,
+            &Submenu::with_items(app_handle, "View", true, &[&PredefinedMenuItem::fullscreen(app_handle, None)?])?,
+            &Submenu::with_items(
+                app_handle,
+                "Window",
+                true,
+                &[
+                    &PredefinedMenuItem::minimize(app_handle, None)?,
+                    &PredefinedMenuItem::maximize(app_handle, None)?,
+                    &PredefinedMenuItem::separator(app_handle)?,
+                    &PredefinedMenuItem::close_window(app_handle, None)?,
+                ],
+            )?,
+            &Submenu::with_items(app_handle, "Help", true, &[])?,
+        ],
+    )
+}
+
+#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+fn linux_has_nvidia_gpu() -> bool {
+    // Detect the proprietary NVIDIA driver by checking for its kernel device
+    // node / proc entry. This is more reliable than parsing lspci output and
+    // has no external deps. Nouveau (open-source) does not create these nodes
+    // and falls through to the Mesa / DMABuf path, which is the desired behavior.
+    std::path::Path::new("/dev/nvidiactl").exists() || std::path::Path::new("/proc/driver/nvidia/version").exists()
+}
+
+#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+fn linux_webkit_rendering_workarounds(has_nvidia: bool) -> &'static [(&'static str, &'static str)] {
+    if has_nvidia {
+        // NVIDIA + Wayland: the DMABuf renderer triggers blank-window / Wayland
+        // protocol errors (EGL_EXT_image_dma_buf_import mismatch). Disable it
+        // and suppress explicit-sync to avoid a compositor crash.
+        &[("WEBKIT_DISABLE_DMABUF_RENDERER", "1"), ("__NV_DISABLE_EXPLICIT_SYNC", "1")]
+    } else {
+        // AMD / Intel / other Mesa drivers support DMABuf natively.
+        // Keeping DMABUF enabled lets WebKitGTK use GPU compositing, which
+        // dramatically reduces CPU usage and eliminates UI lag on Wayland.
+        &[]
+    }
+}
+
+#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+fn linux_system_gtk3_immodules_cache_path() -> Option<&'static str> {
+    [
+        "/usr/lib/x86_64-linux-gnu/gtk-3.0/3.0.0/immodules.cache",
+        "/usr/lib/aarch64-linux-gnu/gtk-3.0/3.0.0/immodules.cache",
+        "/usr/lib64/gtk-3.0/3.0.0/immodules.cache",
+        "/usr/lib/gtk-3.0/3.0.0/immodules.cache",
+    ]
+    .iter()
+    .copied()
+    .find(|path| std::path::Path::new(path).is_file())
+}
+
+#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+fn linux_appimage_wayland_backend_override(
+    appimage: Option<&std::ffi::OsStr>,
+    wayland_display: Option<&std::ffi::OsStr>,
+    gdk_backend: Option<&std::ffi::OsStr>,
+) -> Option<&'static str> {
+    if appimage.is_some() && wayland_display.is_some() && gdk_backend.is_none() {
+        // AppImage uses the host GTK/WebKitGTK stack. Prefer XWayland for the
+        // affected Wayland/EGL path, but keep Wayland and other compiled
+        // backends as fallbacks for systems without XWayland.
+        Some("x11,wayland,*")
+    } else {
+        None
+    }
+}
+
+#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
+fn linux_appimage_system_gtk_immodules_cache(
+    appimage: Option<&std::ffi::OsStr>,
+    appdir: Option<&std::ffi::OsStr>,
+    gtk_im_module: Option<&std::ffi::OsStr>,
+    gtk_im_module_file: Option<&std::ffi::OsStr>,
+    system_cache_path: Option<&'static str>,
+) -> Option<&'static str> {
+    let system_cache_path = system_cache_path?;
+    if appimage.is_none() || gtk_im_module.is_none() {
+        return None;
+    }
+
+    let Some(gtk_im_module_file) = gtk_im_module_file else {
+        return Some(system_cache_path);
+    };
+    let Some(appdir) = appdir else {
+        return None;
+    };
+
+    if std::path::Path::new(gtk_im_module_file).starts_with(std::path::Path::new(appdir)) {
+        Some(system_cache_path)
+    } else {
+        None
+    }
+}
+
+#[cfg(target_os = "linux")]
+fn apply_linux_webkit_rendering_workarounds() {
+    let has_nvidia = linux_has_nvidia_gpu();
+    for (key, value) in linux_webkit_rendering_workarounds(has_nvidia) {
+        if std::env::var_os(key).is_none() {
+            std::env::set_var(key, value);
+        }
+    }
+    if let Some(gdk_backend) = linux_appimage_wayland_backend_override(
+        std::env::var_os("APPIMAGE").as_deref(),
+        std::env::var_os("WAYLAND_DISPLAY").as_deref(),
+        std::env::var_os("GDK_BACKEND").as_deref(),
+    ) {
+        std::env::set_var("GDK_BACKEND", gdk_backend);
+    }
+    if let Some(gtk_im_module_file) = linux_appimage_system_gtk_immodules_cache(
+        std::env::var_os("APPIMAGE").as_deref(),
+        std::env::var_os("APPDIR").as_deref(),
+        std::env::var_os("GTK_IM_MODULE").as_deref(),
+        std::env::var_os("GTK_IM_MODULE_FILE").as_deref(),
+        linux_system_gtk3_immodules_cache_path(),
+    ) {
+        // linuxdeploy-plugin-gtk points GTK_IM_MODULE_FILE at the bundled
+        // cache. That hides host IM modules such as fcitx5/ibus, so prefer the
+        // host GTK cache when the user has configured a GTK input method.
+        std::env::set_var("GTK_IM_MODULE_FILE", gtk_im_module_file);
+    }
+}
+
+fn show_main_window<R: tauri::Runtime>(app: &tauri::AppHandle<R>) {
+    if let Some(window) = app.get_webview_window("main") {
+        let _ = window.show();
+        let _ = window.unminimize();
+        let _ = window.set_focus();
+    }
+}
+
+fn clear_main_webview_focus<R: tauri::Runtime>(app: &tauri::AppHandle<R>) {
+    if let Some(window) = app.get_webview_window("main") {
+        let _ = window.eval(
+            r#"
+            (() => {
+              const active = document.activeElement;
+              if (active instanceof HTMLElement) active.blur();
+              if (document.body) {
+                if (!document.body.hasAttribute("tabindex")) {
+                  document.body.setAttribute("tabindex", "-1");
+                }
+                document.body.focus({ preventScroll: true });
+              }
+            })();
+            "#,
+        );
+    }
+}
+
+pub(crate) fn hide_main_window_for_close<R: tauri::Runtime>(app: &tauri::AppHandle<R>, window: &tauri::Window<R>) {
+    clear_main_webview_focus(app);
+
+    #[cfg(target_os = "macos")]
+    {
+        if window.is_fullscreen().unwrap_or(false) {
+            let app = app.clone();
+            let window = window.clone();
+            let _ = window.set_fullscreen(false);
+            tauri::async_runtime::spawn(async move {
+                for _ in 0..40 {
+                    tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+                    if !window.is_fullscreen().unwrap_or(false) {
+                        tokio::time::sleep(std::time::Duration::from_millis(600)).await;
+                        let app_to_hide = app.clone();
+                        let window_to_hide = window.clone();
+                        let _ = app.run_on_main_thread(move || {
+                            let _ = window_to_hide.hide();
+                            let _ = app_to_hide.hide();
+                        });
+                        return;
+                    }
+                }
+                let app_to_hide = app.clone();
+                let window_to_hide = window.clone();
+                let _ = app.run_on_main_thread(move || {
+                    let _ = window_to_hide.hide();
+                    let _ = app_to_hide.hide();
+                });
+            });
+            return;
+        }
+    }
+
+    let _ = window.hide();
+}
+
+pub(crate) fn request_app_close<R: tauri::Runtime>(app: &tauri::AppHandle<R>, target: &str) {
+    show_main_window(app);
+    let _ = app.emit(APP_CLOSE_REQUESTED_EVENT, target);
+}
+
+fn open_connection_deep_links(app: &tauri::AppHandle, links: Vec<String>) {
+    if links.is_empty() {
+        return;
+    }
+    if let Some(state) = app.try_state::<commands::deep_link::DeepLinkOpenState>() {
+        state.push(links.clone());
+    }
+    let _ = app.emit("dbx-open-connection-links", links);
+    show_main_window(app);
+}
+
+#[cfg_attr(not(any(target_os = "macos", target_os = "windows")), allow(dead_code))]
+fn setup_desktop_tray<R: tauri::Runtime, M: Manager<R>>(
+    manager: &M,
+    _icon_theme: DesktopIconTheme,
+) -> tauri::Result<()> {
+    let menu = MenuBuilder::new(manager).text("show", "Show DBX").separator().text("quit", "Quit DBX").build()?;
+    let mut tray =
+        TrayIconBuilder::<R>::with_id(DESKTOP_TRAY_ID).tooltip("DBX").menu(&menu).show_menu_on_left_click(false);
+    #[cfg(target_os = "macos")]
+    {
+        tray = tray.icon(MACOS_TRAY_ICON).icon_as_template(true);
+    }
+    #[cfg(target_os = "windows")]
+    {
+        let icon = match _icon_theme {
+            DesktopIconTheme::Default => manager.app_handle().default_window_icon().cloned(),
+            DesktopIconTheme::Black => Some(BLACK_APP_ICON),
+        };
+        if let Some(icon) = icon {
+            tray = tray.icon(icon);
+        }
+    }
+    #[cfg(not(any(target_os = "macos", target_os = "windows")))]
+    {
+        if let Some(icon) = manager.app_handle().default_window_icon().cloned() {
+            tray = tray.icon(icon);
+        }
+    }
+
+    tray.on_menu_event(|app, event| {
+        if event.id() == "show" {
+            show_main_window(app);
+        } else if event.id() == "quit" {
+            request_app_close(app, "quit");
+        }
+    })
+    .on_tray_icon_event(|tray, event| match event {
+        TrayIconEvent::Click { button: MouseButton::Left, button_state: MouseButtonState::Up, .. }
+        | TrayIconEvent::DoubleClick { button: MouseButton::Left, .. } => show_main_window(tray.app_handle()),
+        _ => {}
+    })
+    .build(manager)?;
+
+    Ok(())
+}
+
+#[cfg(target_os = "macos")]
+fn apply_macos_app_icon_theme(app: &tauri::AppHandle, icon_theme: DesktopIconTheme) -> tauri::Result<()> {
+    use objc2::{AllocAnyThread, MainThreadMarker};
+    use objc2_app_kit::{NSApplication, NSImage};
+    use objc2_foundation::NSData;
+
+    let icon_bytes = match icon_theme {
+        DesktopIconTheme::Default => MACOS_DEFAULT_APP_ICON,
+        DesktopIconTheme::Black => MACOS_DARK_APP_ICON,
+    };
+    app.run_on_main_thread(move || {
+        // macOS has no per-window icon. Update NSApplication so the Dock and
+        // app switcher reflect the selected theme immediately.
+        let marker = unsafe { MainThreadMarker::new_unchecked() };
+        let application = NSApplication::sharedApplication(marker);
+        let data = NSData::with_bytes(icon_bytes);
+        if let Some(icon) = NSImage::initWithData(NSImage::alloc(), &data) {
+            unsafe { application.setApplicationIconImage(Some(&icon)) };
+        } else {
+            log::warn!("Failed to decode the selected macOS application icon");
+        }
+    })
+}
+
+fn apply_desktop_icon_theme(app: &tauri::AppHandle, icon_theme: DesktopIconTheme) -> tauri::Result<()> {
+    #[cfg(target_os = "macos")]
+    {
+        return apply_macos_app_icon_theme(app, icon_theme);
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    if let Some(window) = app.get_webview_window("main") {
+        match icon_theme {
+            DesktopIconTheme::Default => {
+                if let Some(icon) = app.default_window_icon().cloned() {
+                    window.set_icon(icon)?;
+                }
+            }
+            DesktopIconTheme::Black => window.set_icon(BLACK_APP_ICON)?,
+        }
+    }
+    #[cfg(not(target_os = "macos"))]
+    Ok(())
+}
+
+fn apply_desktop_tray_icon_theme(app: &tauri::AppHandle, _icon_theme: DesktopIconTheme) -> tauri::Result<()> {
+    if let Some(_tray) = app.tray_by_id(DESKTOP_TRAY_ID) {
+        #[cfg(target_os = "windows")]
+        {
+            let icon = match _icon_theme {
+                DesktopIconTheme::Default => app.default_window_icon().cloned(),
+                DesktopIconTheme::Black => Some(BLACK_APP_ICON),
+            };
+            _tray.set_icon(icon)?;
+        }
+        #[cfg(target_os = "linux")]
+        {
+            let icon = match _icon_theme {
+                DesktopIconTheme::Default => app.default_window_icon().cloned(),
+                DesktopIconTheme::Black => Some(BLACK_APP_ICON),
+            };
+            _tray.set_icon(icon)?;
+        }
+        #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
+        {
+            let _ = (_tray, _icon_theme);
+        }
+    }
+    Ok(())
+}
+
+pub(crate) fn apply_desktop_settings(app: &tauri::AppHandle, desktop_settings: &DesktopSettings) -> tauri::Result<()> {
+    apply_debug_log_level(desktop_settings.debug_logging_enabled);
+    apply_desktop_icon_theme(app, desktop_settings.icon_theme)?;
+    if should_setup_desktop_tray(std::env::consts::OS, desktop_settings.show_tray_icon, linux_appindicator_available())
+    {
+        if let Some(tray) = app.tray_by_id(DESKTOP_TRAY_ID) {
+            tray.set_visible(desktop_settings.show_tray_icon)?;
+            apply_desktop_tray_icon_theme(app, desktop_settings.icon_theme)?;
+        } else if desktop_settings.show_tray_icon {
+            setup_desktop_tray(app, desktop_settings.icon_theme)?;
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+#[allow(clippy::items_after_test_module)]
+mod tests {
+    use super::{
+        linux_appimage_system_gtk_immodules_cache, linux_appimage_wayland_backend_override,
+        linux_webkit_rendering_workarounds, native_window_decorations_override, should_confirm_app_exit_request,
+        should_hide_window_on_close, should_setup_desktop_tray, should_show_main_window_after_setup,
+        uses_application_level_icon,
+    };
+    use std::ffi::OsStr;
+
+    const TEST_GTK3_IMMODULES_CACHE: &str = "/usr/lib/test/gtk-3.0/3.0.0/immodules.cache";
+
+    #[test]
+    fn hides_window_on_close_for_windows_and_macos() {
+        assert!(should_hide_window_on_close("windows"));
+        assert!(should_hide_window_on_close("macos"));
+    }
+
+    #[test]
+    fn does_not_hide_window_on_close_for_other_platforms() {
+        assert!(!should_hide_window_on_close("linux"));
+    }
+
+    #[test]
+    fn sets_up_desktop_tray_for_windows_macos_and_linux() {
+        assert!(should_setup_desktop_tray("windows", true, false));
+        assert!(should_setup_desktop_tray("macos", true, false));
+        assert!(should_setup_desktop_tray("linux", true, true));
+        assert!(!should_setup_desktop_tray("linux", true, false));
+        assert!(!should_setup_desktop_tray("windows", false, true));
+        assert!(!should_setup_desktop_tray("macos", false, true));
+        assert!(!should_setup_desktop_tray("linux", false, true));
+    }
+
+    #[cfg(target_os = "macos")]
+    #[test]
+    fn macos_tray_icon_remains_a_system_template() {
+        // Menu bar template images are intentionally independent from the app
+        // icon theme so macOS can recolor them for light and dark menu bars.
+        assert_eq!(super::MACOS_TRAY_ICON.width(), 36);
+        assert_eq!(super::MACOS_TRAY_ICON.height(), 36);
+    }
+
+    #[cfg(target_os = "macos")]
+    #[test]
+    fn macos_icon_themes_use_packaged_dock_assets() {
+        use objc2::AllocAnyThread;
+        use objc2_app_kit::NSImage;
+        use objc2_foundation::NSData;
+
+        assert!(super::MACOS_DEFAULT_APP_ICON.starts_with(b"icns"));
+        assert!(super::MACOS_DARK_APP_ICON.starts_with(b"icns"));
+        for bytes in [super::MACOS_DEFAULT_APP_ICON, super::MACOS_DARK_APP_ICON] {
+            let data = NSData::with_bytes(bytes);
+            assert!(NSImage::initWithData(NSImage::alloc(), &data).is_some());
+        }
+    }
+
+    #[test]
+    fn macos_icon_theme_targets_the_application_instead_of_a_window() {
+        assert!(uses_application_level_icon("macos"));
+        assert!(!uses_application_level_icon("windows"));
+        assert!(!uses_application_level_icon("linux"));
+    }
+
+    #[test]
+    fn shows_main_window_after_regular_startup_setup() {
+        assert!(should_show_main_window_after_setup());
+    }
+
+    #[test]
+    fn only_user_requested_app_exit_needs_frontend_confirmation() {
+        assert!(should_confirm_app_exit_request("windows", None, false));
+        assert!(should_confirm_app_exit_request("macos", Some(0), false));
+        assert!(!should_confirm_app_exit_request("windows", Some(0), true));
+        assert!(!should_confirm_app_exit_request("windows", Some(tauri::RESTART_EXIT_CODE), false));
+        assert!(!should_confirm_app_exit_request("linux", Some(0), false));
+    }
+
+    #[test]
+    fn overrides_native_window_decorations_for_desktop_platforms() {
+        assert_eq!(native_window_decorations_override("windows"), Some(false));
+        assert_eq!(native_window_decorations_override("linux"), Some(false));
+        assert_eq!(native_window_decorations_override("macos"), None);
+    }
+
+    #[test]
+    fn applies_linux_webkit_rendering_workarounds_before_webkit_starts() {
+        // NVIDIA: DMABuf must be disabled to avoid blank window / Wayland protocol errors.
+        assert_eq!(
+            linux_webkit_rendering_workarounds(true),
+            &[("WEBKIT_DISABLE_DMABUF_RENDERER", "1"), ("__NV_DISABLE_EXPLICIT_SYNC", "1")]
+        );
+        // AMD / Intel / Mesa: DMABuf is supported — no workarounds needed.
+        assert_eq!(linux_webkit_rendering_workarounds(false), &[]);
+    }
+
+    #[test]
+    fn prefers_x11_for_appimage_wayland_when_backend_is_not_user_configured() {
+        assert_eq!(
+            linux_appimage_wayland_backend_override(
+                Some(OsStr::new("/tmp/DBX.AppImage")),
+                Some(OsStr::new("wayland-0")),
+                None
+            ),
+            Some("x11,wayland,*")
+        );
+        assert_eq!(
+            linux_appimage_wayland_backend_override(
+                Some(OsStr::new("/tmp/DBX.AppImage")),
+                Some(OsStr::new("wayland-0")),
+                Some(OsStr::new("wayland"))
+            ),
+            None
+        );
+        assert_eq!(linux_appimage_wayland_backend_override(Some(OsStr::new("/tmp/DBX.AppImage")), None, None), None);
+        assert_eq!(linux_appimage_wayland_backend_override(None, Some(OsStr::new("wayland-0")), None), None);
+    }
+
+    #[test]
+    fn prefers_system_gtk_immodules_cache_for_appimage_input_methods() {
+        assert_eq!(
+            linux_appimage_system_gtk_immodules_cache(
+                Some(OsStr::new("/tmp/DBX.AppImage")),
+                Some(OsStr::new("/tmp/.mount_DBX123")),
+                Some(OsStr::new("fcitx5")),
+                Some(OsStr::new("/tmp/.mount_DBX123/usr/lib/x86_64-linux-gnu/gtk-3.0/3.0.0/immodules.cache")),
+                Some(TEST_GTK3_IMMODULES_CACHE),
+            ),
+            Some(TEST_GTK3_IMMODULES_CACHE)
+        );
+        assert_eq!(
+            linux_appimage_system_gtk_immodules_cache(
+                Some(OsStr::new("/tmp/DBX.AppImage")),
+                Some(OsStr::new("/tmp/.mount_DBX123")),
+                Some(OsStr::new("ibus")),
+                None,
+                Some(TEST_GTK3_IMMODULES_CACHE),
+            ),
+            Some(TEST_GTK3_IMMODULES_CACHE)
+        );
+    }
+
+    #[test]
+    fn preserves_external_gtk_immodules_cache_overrides() {
+        assert_eq!(
+            linux_appimage_system_gtk_immodules_cache(
+                Some(OsStr::new("/tmp/DBX.AppImage")),
+                Some(OsStr::new("/tmp/.mount_DBX123")),
+                Some(OsStr::new("fcitx5")),
+                Some(OsStr::new("/opt/custom/immodules.cache")),
+                Some(TEST_GTK3_IMMODULES_CACHE),
+            ),
+            None
+        );
+    }
+
+    #[test]
+    fn skips_system_gtk_immodules_cache_without_required_context() {
+        assert_eq!(
+            linux_appimage_system_gtk_immodules_cache(
+                None,
+                Some(OsStr::new("/tmp/.mount_DBX123")),
+                Some(OsStr::new("fcitx5")),
+                Some(OsStr::new("/tmp/.mount_DBX123/usr/lib/x86_64-linux-gnu/gtk-3.0/3.0.0/immodules.cache")),
+                Some(TEST_GTK3_IMMODULES_CACHE),
+            ),
+            None
+        );
+        assert_eq!(
+            linux_appimage_system_gtk_immodules_cache(
+                Some(OsStr::new("/tmp/DBX.AppImage")),
+                Some(OsStr::new("/tmp/.mount_DBX123")),
+                None,
+                Some(OsStr::new("/tmp/.mount_DBX123/usr/lib/x86_64-linux-gnu/gtk-3.0/3.0.0/immodules.cache")),
+                Some(TEST_GTK3_IMMODULES_CACHE),
+            ),
+            None
+        );
+        assert_eq!(
+            linux_appimage_system_gtk_immodules_cache(
+                Some(OsStr::new("/tmp/DBX.AppImage")),
+                Some(OsStr::new("/tmp/.mount_DBX123")),
+                Some(OsStr::new("fcitx5")),
+                Some(OsStr::new("/tmp/.mount_DBX123/usr/lib/x86_64-linux-gnu/gtk-3.0/3.0.0/immodules.cache")),
+                None,
+            ),
+            None
+        );
+    }
+}
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    rustls::crypto::aws_lc_rs::default_provider().install_default().expect("Failed to install rustls crypto provider");
+    #[cfg(target_os = "linux")]
+    apply_linux_webkit_rendering_workarounds();
+
+    let startup_begin = Instant::now();
+
+    let builder = tauri::Builder::default()
+        .plugin(tauri_plugin_deep_link::init())
+        .plugin(tauri_plugin_clipboard_manager::init())
+        .plugin(tauri_plugin_dialog::init())
+        .plugin(tauri_plugin_fs::init())
+        .plugin(tauri_plugin_single_instance::init(|app, args, cwd| {
+            let links = commands::deep_link::connection_deep_links_from_args(args.clone());
+            open_connection_deep_links(app, links);
+
+            let paths = commands::external_sql::sql_file_paths_from_args(args.clone(), std::path::Path::new(&cwd));
+            if !paths.is_empty() {
+                if let Some(state) = app.try_state::<commands::external_sql::ExternalSqlOpenState>() {
+                    state.push(paths.clone());
+                }
+                let _ = app.emit("dbx-open-sql-files", paths);
+            }
+
+            let db_paths = commands::external_db::db_file_paths_from_args(args, std::path::Path::new(&cwd));
+            if !db_paths.is_empty() {
+                if let Some(state) = app.try_state::<commands::external_db::ExternalDbOpenState>() {
+                    state.push(db_paths.clone());
+                }
+                let _ = app.emit("dbx-open-db-files", db_paths);
+            }
+            show_main_window(app);
+        }))
+        .plugin(tauri_plugin_shell::init())
+        .plugin(tauri_plugin_updater::Builder::new().build())
+        .plugin(tauri_plugin_process::init())
+        .plugin(tauri_plugin_window_state::Builder::default().build());
+
+    // macOS app menu (Cmd+Q / Dock Quit). Skip on Linux/Windows so an empty menu bar
+    // is not installed where there was none before.
+    #[cfg(target_os = "macos")]
+    let builder = builder.menu(build_app_menu).on_menu_event(|app, event| {
+        if event.id() == APP_MENU_QUIT_ID {
+            request_app_close(app, "quit");
+        } else if event.id() == APP_MENU_COPY_SUPPORT_INFO_ID {
+            if let Err(err) = app.clipboard().write_text(commands::support_info::format_support_info_for_clipboard()) {
+                log::warn!("Failed to copy support info from app menu: {err}");
+            }
+        }
+    });
+
+    builder
+        .setup(move |app| {
+            let setup_start = Instant::now();
+            eprintln!("[STARTUP] plugins registered in {:?}", startup_begin.elapsed());
+
+            let default_data_dir =
+                app.path().app_data_dir().map_err(|e| e.to_string()).expect("Failed to resolve app data dir");
+            let data_dir_resolution = data_dir::resolve_data_dir_with_mode(default_data_dir);
+            let data_dir = data_dir_resolution.data_dir.clone();
+            std::fs::create_dir_all(&data_dir).expect("Failed to create data dir");
+            let alternative_data_dir = data_dir::alternative_data_dir(&data_dir_resolution);
+            match maybe_import_user_data_db(&data_dir, alternative_data_dir.as_deref()) {
+                Ok(result) => eprintln!("[STARTUP] data db fallback import: {result:?}"),
+                Err(err) => eprintln!("[STARTUP] data db fallback import failed: {err}"),
+            }
+            let db_path = data_dir.join("dbx.db");
+
+            let t = Instant::now();
+            let storage = tauri::async_runtime::block_on(async {
+                let s = Storage::open(&db_path).await.expect("Failed to open storage");
+                eprintln!("[STARTUP]   Storage::open in {:?}", t.elapsed());
+                let t2 = Instant::now();
+                s.migrate_from_json(&data_dir).await.expect("Failed to migrate JSON data");
+                eprintln!("[STARTUP]   migrate_from_json in {:?}", t2.elapsed());
+                s
+            });
+            let desktop_settings = tauri::async_runtime::block_on(storage.load_desktop_settings()).unwrap_or_default();
+            app.handle().plugin(
+                tauri_plugin_log::Builder::default()
+                    .timezone_strategy(tauri_plugin_log::TimezoneStrategy::UseLocal)
+                    .format(|out, message, record| {
+                        out.finish(format_args!(
+                            "[{}][{}][{}] {}",
+                            chrono::Local::now().format("%Y-%m-%d][%H:%M:%S%.3f"),
+                            record.level(),
+                            record.target(),
+                            message
+                        ));
+                    })
+                    .level(log::LevelFilter::Debug)
+                    .build(),
+            )?;
+            apply_debug_log_level(desktop_settings.debug_logging_enabled);
+            eprintln!("[STARTUP] storage ready in {:?}", t.elapsed());
+
+            let default_agent_dir = data_dir_resolution.uses_custom_data_dir().then(|| data_dir.join("agents"));
+            let (plugin_dir, agent_dir) = commands::app_settings::resolve_driver_store_dirs_from_settings(
+                &desktop_settings,
+                &data_dir,
+                default_agent_dir,
+            );
+
+            let state = if let Some(agent_dir) = agent_dir {
+                AppState::new_with_plugin_and_agent_dir_and_app_version(
+                    storage,
+                    plugin_dir,
+                    agent_dir,
+                    env!("CARGO_PKG_VERSION"),
+                )
+            } else {
+                AppState::new_with_plugin_dir_and_app_version(storage, plugin_dir, env!("CARGO_PKG_VERSION"))
+            };
+            state.set_duckdb_worker_process_isolation_enabled(desktop_settings.duckdb_worker_process_isolation);
+            state.set_duckdb_worker_max_processes(desktop_settings.duckdb_worker_max_processes);
+            let state = Arc::new(state);
+            app.manage(state.clone());
+            commands::redis_pubsub_server::start_pubsub_server(state.clone());
+            app.manage(commands::saved_sql::SavedSqlStorageState { data_dir: data_dir.clone() });
+            app.manage(commands::external_sql::ExternalSqlOpenState::default());
+            app.manage(commands::external_db::ExternalDbOpenState::default());
+            app.manage(commands::deep_link::DeepLinkOpenState::default());
+            app.manage(CloseBehaviorState::new());
+            #[cfg(target_os = "macos")]
+            macos_app_delegate::install_dock_quit_handler(app.handle());
+            let startup_links = commands::deep_link::connection_deep_links_from_args(std::env::args().skip(1));
+            open_connection_deep_links(app.handle(), startup_links);
+
+            let app_handle = app.handle().clone();
+            commands::mcp_bridge::start(app_handle, state, data_dir);
+            eprintln!("[STARTUP] setup complete in {:?} (total {:?})", setup_start.elapsed(), startup_begin.elapsed());
+
+            if let Some(decorations) = native_window_decorations_override(std::env::consts::OS) {
+                if let Some(window) = app.get_webview_window("main") {
+                    let _ = window.set_decorations(decorations);
+                }
+            }
+            if should_setup_desktop_tray(
+                std::env::consts::OS,
+                desktop_settings.show_tray_icon,
+                linux_appindicator_available(),
+            ) {
+                setup_desktop_tray(app, desktop_settings.icon_theme)?;
+            }
+            apply_desktop_icon_theme(app.handle(), desktop_settings.icon_theme)?;
+            window_state_guard::enforce_main_window_bounds(app.handle());
+            if should_show_main_window_after_setup() {
+                show_main_window(app.handle());
+            }
+            #[cfg(any(windows, target_os = "linux"))]
+            let _ = app.deep_link().register_all();
+
+            Ok(())
+        })
+        .on_window_event(|window, event| {
+            if let tauri::WindowEvent::CloseRequested { api, .. } = event {
+                if !should_hide_window_on_close(std::env::consts::OS) {
+                    return;
+                }
+                let app = window.app_handle();
+                if app.try_state::<CloseBehaviorState>().is_none() {
+                    api.prevent_close();
+                    hide_main_window_for_close(&app, window);
+                    return;
+                }
+                api.prevent_close();
+                request_app_close(&app, "settings");
+            }
+        })
+        .invoke_handler(tauri::generate_handler![
+            commands::ai::ai_complete,
+            commands::ai::ai_stream,
+            commands::ai::ai_agent_stream,
+            commands::ai::ai_cancel_stream,
+            commands::ai::ai_test_connection,
+            commands::ai::ai_list_models,
+            commands::ai::save_ai_config,
+            commands::ai::load_ai_config,
+            commands::ai::save_ai_provider_config,
+            commands::ai::load_ai_provider_configs,
+            commands::ai::save_ai_conversation,
+            commands::ai::load_ai_conversations,
+            commands::ai::delete_ai_conversation,
+            commands::app_settings::load_desktop_settings,
+            commands::app_settings::save_desktop_settings,
+            commands::app_settings::complete_app_close,
+            commands::app_settings::request_app_close_from_window_controls,
+            commands::window_controls::set_macos_traffic_light_position,
+            commands::app_settings::set_driver_store_dir,
+            commands::app_settings::set_plugin_store_dir,
+            commands::app_settings::set_agent_store_dir,
+            commands::app_settings::get_driver_store_path,
+            commands::app_settings::load_pinned_tree_node_ids,
+            commands::app_settings::save_pinned_tree_node_ids,
+            commands::app_settings::load_editor_settings,
+            commands::app_settings::save_editor_settings,
+            commands::app_settings::load_open_tabs_state,
+            commands::app_settings::save_open_tabs_state,
+            commands::app_settings::load_saved_sql_editor_positions,
+            commands::app_settings::save_saved_sql_editor_positions,
+            commands::app_settings::load_native_debug_logs,
+            commands::support_info::get_app_support_info,
+            commands::cloud_sync::webdav_sync_test,
+            commands::cloud_sync::webdav_password_status,
+            commands::cloud_sync::save_webdav_saved_password,
+            commands::cloud_sync::forget_webdav_saved_password,
+            commands::cloud_sync::webdav_sync_secrets_status,
+            commands::cloud_sync::save_webdav_sync_secrets_preference,
+            commands::cloud_sync::forget_webdav_sync_secrets_passphrase,
+            commands::cloud_sync::webdav_sync_upload,
+            commands::cloud_sync::webdav_sync_download,
+            commands::cloud_sync::snippet_sync_test,
+            commands::cloud_sync::snippet_token_status,
+            commands::cloud_sync::save_snippet_saved_token,
+            commands::cloud_sync::forget_snippet_saved_token,
+            commands::cloud_sync::snippet_sync_upload,
+            commands::cloud_sync::snippet_sync_download,
+            commands::connection::test_connection,
+            commands::connection::connect_db,
+            commands::connection::connection_final_proxy_port,
+            commands::connection::disconnect_db,
+            commands::connection::close_database_connection,
+            commands::connection::refresh_connections,
+            commands::connection::check_connection_health,
+            commands::connection::save_connections,
+            commands::connection::load_connections,
+            commands::connection::save_sidebar_layout,
+            commands::connection::load_sidebar_layout,
+            commands::plugins::list_plugins,
+            commands::plugins::list_jdbc_drivers,
+            commands::plugins::list_jdbc_maven_bundles,
+            commands::plugins::list_jdbc_local_bundles,
+            commands::plugins::import_jdbc_drivers,
+            commands::plugins::install_jdbc_driver_from_maven,
+            commands::plugins::install_prestosql_jdbc_driver,
+            commands::plugins::delete_jdbc_driver,
+            commands::plugins::delete_jdbc_maven_bundle,
+            commands::plugins::delete_jdbc_local_bundle,
+            commands::plugins::jdbc_plugin_status,
+            commands::plugins::install_jdbc_plugin,
+            commands::plugins::install_jdbc_plugin_local,
+            commands::plugins::uninstall_jdbc_plugin,
+            commands::schema::list_databases,
+            commands::schema::list_doris_catalogs,
+            commands::schema::list_doris_catalog_databases,
+            commands::schema::list_sqlserver_linked_servers,
+            commands::schema::list_sqlserver_linked_server_catalogs,
+            commands::schema::list_sqlserver_linked_server_schemas,
+            commands::schema::list_sqlserver_linked_server_tables,
+            commands::schema::list_tables,
+            commands::schema::get_table_comment,
+            commands::schema::list_objects,
+            commands::schema::list_object_statistics,
+            commands::schema::list_completion_objects,
+            commands::schema::completion_assistant_search,
+            commands::schema::get_object_source,
+            commands::schema::list_schemas,
+            commands::schema::list_schema_infos,
+            commands::schema::list_data_types,
+            commands::schema::get_columns,
+            commands::schema::list_indexes,
+            commands::schema::list_foreign_keys,
+            commands::schema::list_triggers,
+            commands::schema::get_table_ddl,
+            commands::schema::list_functions,
+            commands::schema::list_sequences,
+            commands::schema::list_rules,
+            commands::schema::list_owners,
+            commands::schema::list_extensions,
+            commands::schema::list_available_extensions,
+            commands::schema_diff::prepare_schema_diff,
+            commands::schema_diff::generate_schema_sync_sql,
+            commands::schema_cache::save_schema_cache,
+            commands::schema_cache::load_schema_cache,
+            commands::schema_cache::delete_schema_cache_prefix,
+            commands::tab_runtime_cache::save_tab_runtime_cache,
+            commands::tab_runtime_cache::load_tab_runtime_cache,
+            commands::tab_runtime_cache::delete_tab_runtime_cache,
+            commands::query::execute_query,
+            commands::query::execute_multi,
+            commands::query::cancel_query,
+            commands::query::close_query_session,
+            commands::query::close_client_connection_session,
+            commands::query::execute_batch,
+            commands::query::execute_script,
+            commands::query::execute_in_transaction,
+            commands::query::begin_manual_transaction,
+            commands::query::execute_in_manual_transaction,
+            commands::query::commit_manual_transaction,
+            commands::query::rollback_manual_transaction,
+            commands::query::analyze_sql_references,
+            commands::query::find_statement_at_cursor,
+            commands::query::prepare_query_pagination_execution_plan,
+            commands::query::build_sorted_query_sql,
+            commands::query::build_explain_sql,
+            commands::query::get_explain_info,
+            commands::query::build_create_user_sql,
+            commands::query::build_dropped_file_preview_sql,
+            commands::query::build_table_select_sql,
+            commands::query::build_database_search_sql,
+            commands::query::build_search_result_where,
+            commands::query::build_rename_object_sql,
+            commands::query::build_create_database_sql,
+            #[cfg(feature = "duckdb-bundled")]
+            commands::query::build_duckdb_attach_database_sql,
+            commands::query::build_drop_object_sql,
+            commands::query::build_drop_table_sql,
+            commands::query::build_drop_table_child_object_sql,
+            commands::query::build_empty_table_sql,
+            commands::query::build_truncate_table_sql,
+            commands::query::build_drop_database_sql,
+            commands::query::build_create_schema_sql,
+            commands::query::build_update_database_properties_sql,
+            commands::query::build_drop_schema_sql,
+            commands::query::build_duplicate_table_structure_sql,
+            commands::query::build_copy_table_data_sql,
+            commands::query::build_executable_object_source_statements,
+            commands::query::build_executable_object_source_sql,
+            commands::query::build_editable_object_source,
+            commands::query::build_routine_rename_object_source_statements,
+            commands::query::build_view_ddl_sql,
+            commands::query::build_table_structure_change_sql,
+            commands::query::preview_sqlite_table_structure_change,
+            commands::query::apply_sqlite_table_structure_change,
+            commands::query::build_create_table_sql,
+            commands::query::build_single_column_alter_sql,
+            commands::query::analyze_editable_query_editability,
+            commands::query::prepare_data_grid_save,
+            commands::query::build_data_grid_copy_update_statements,
+            commands::query::build_data_grid_copy_insert_statement,
+            commands::query::build_data_grid_context_filter_condition,
+            commands::query::build_data_grid_column_value_filter_condition,
+            commands::query::build_data_grid_column_values_filter_condition,
+            commands::query::build_data_grid_column_distinct_values_sql,
+            commands::query::build_data_grid_count_sql,
+            commands::query::build_hive_table_properties_sql,
+            commands::query::build_export_insert_statements,
+            commands::query::build_export_sql_insert,
+            commands::query::build_database_sql_export,
+            commands::data_compare::prepare_data_compare,
+            commands::data_compare::prepare_data_compare_from_tables,
+            commands::data_compare::prepare_data_compare_missing_target,
+            commands::data_compare::build_data_compare_sync_plan,
+            commands::sql_file::preview_sql_file,
+            commands::sql_file::execute_sql_file,
+            commands::sql_file::cancel_sql_file_execution,
+            commands::external_sql::pending_open_sql_files,
+            commands::external_sql::read_external_sql_file,
+            commands::external_sql::write_external_sql_file,
+            commands::list_sql_files::list_sql_files_in_folder,
+            commands::external_db::pending_open_db_files,
+            commands::keychain::read_keychain_password,
+            commands::keychain::read_keychain_passwords,
+            commands::deep_link::pending_open_connection_links,
+            commands::table_import::preview_table_import_file,
+            commands::table_import::import_table_file,
+            commands::table_import::cancel_table_import,
+            commands::redis_cmd::redis_list_databases,
+            commands::redis_cmd::redis_scan_keys,
+            commands::redis_cmd::redis_scan_keys_batch,
+            commands::redis_cmd::redis_scan_values,
+            commands::redis_cmd::redis_get_value,
+            commands::redis_cmd::redis_set_string,
+            commands::redis_cmd::redis_delete_key,
+            commands::redis_cmd::redis_hash_set,
+            commands::redis_cmd::redis_hash_del,
+            commands::redis_cmd::redis_list_push,
+            commands::redis_cmd::redis_list_set,
+            commands::redis_cmd::redis_list_remove,
+            commands::redis_cmd::redis_set_add,
+            commands::redis_cmd::redis_set_remove,
+            commands::redis_cmd::redis_zadd,
+            commands::redis_cmd::redis_zrem,
+            commands::redis_cmd::redis_stream_add,
+            commands::redis_cmd::redis_json_set,
+            commands::redis_cmd::redis_check_json_module,
+            commands::redis_cmd::redis_set_ttl,
+            commands::redis_cmd::redis_delete_keys,
+            commands::redis_cmd::redis_flush_db,
+            commands::redis_cmd::redis_execute_command,
+            commands::redis_cmd::redis_load_more,
+            commands::redis_cmd::redis_pubsub_publish,
+            commands::redis_pubsub_server::redis_pubsub_server_port,
+            commands::redis_cmd::redis_slowlog_get,
+            commands::redis_cmd::redis_cluster_master_nodes,
+            commands::etcd_cmd::etcd_list_prefix,
+            commands::etcd_cmd::etcd_get,
+            commands::etcd_cmd::etcd_put,
+            commands::etcd_cmd::etcd_delete,
+            commands::zookeeper_cmd::zookeeper_list_prefix,
+            commands::zookeeper_cmd::zookeeper_get,
+            commands::zookeeper_cmd::zookeeper_put,
+            commands::zookeeper_cmd::zookeeper_delete,
+            commands::nacos_cmd::nacos_test_connection,
+            commands::nacos_cmd::nacos_list_namespaces,
+            commands::nacos_cmd::nacos_create_namespace,
+            commands::nacos_cmd::nacos_update_namespace,
+            commands::nacos_cmd::nacos_list_configs,
+            commands::nacos_cmd::nacos_get_config,
+            commands::nacos_cmd::nacos_publish_config,
+            commands::nacos_cmd::nacos_delete_config,
+            commands::nacos_cmd::nacos_list_config_history,
+            commands::nacos_cmd::nacos_get_config_history,
+            commands::nacos_cmd::nacos_rollback_config,
+            commands::nacos_cmd::nacos_list_services,
+            commands::nacos_cmd::nacos_list_instances,
+            commands::nacos_cmd::nacos_update_instance,
+            commands::nacos_cmd::nacos_raw_request,
+            commands::saved_sql::load_saved_sql_library,
+            commands::saved_sql::load_saved_sql_file,
+            commands::saved_sql::save_saved_sql_folder,
+            commands::saved_sql::delete_saved_sql_folder,
+            commands::saved_sql::save_saved_sql_file,
+            commands::saved_sql::delete_saved_sql_file,
+            commands::saved_sql::saved_sql_storage_dir,
+            commands::saved_sql::open_saved_sql_storage_dir,
+            commands::saved_sql::sync_saved_sql_directory,
+            commands::fs_open::reveal_path_in_file_manager,
+            commands::fs_open::is_sqlite_database_file,
+            commands::sqlite_backup::backup_sqlite_database,
+            commands::mongo_cmd::mongo_list_databases,
+            commands::mongo_cmd::mongo_list_collections,
+            commands::mongo_cmd::vector_collection_detail,
+            commands::mongo_cmd::mongo_create_database,
+            commands::mongo_cmd::mongo_drop_database,
+            commands::mongo_cmd::mongo_drop_collection,
+            commands::document_cmd::document_list_databases,
+            commands::document_cmd::document_list_collections,
+            commands::document_cmd::document_find_documents,
+            commands::document_cmd::document_list_gridfs_buckets,
+            commands::document_cmd::document_create_gridfs_bucket,
+            commands::document_cmd::document_delete_gridfs_bucket,
+            commands::document_cmd::document_list_gridfs_files,
+            commands::document_cmd::document_download_gridfs_file,
+            commands::document_cmd::document_upload_gridfs_file,
+            commands::document_cmd::document_delete_gridfs_file,
+            commands::mongo_cmd::mongo_find_documents,
+            commands::mongo_cmd::mongo_server_version,
+            commands::mongo_cmd::mongo_collection_stats,
+            commands::mongo_cmd::mongo_aggregate_documents,
+            commands::mongo_cmd::mongo_create_index,
+            commands::mongo_cmd::mongo_drop_indexes,
+            commands::document_cmd::document_insert_document,
+            commands::mongo_cmd::mongo_insert_document,
+            commands::mongo_cmd::mongo_insert_documents,
+            commands::document_cmd::document_update_document,
+            commands::mongo_cmd::mongo_update_document,
+            commands::mongo_cmd::mongo_update_documents,
+            commands::document_cmd::document_delete_document,
+            commands::mongo_cmd::mongo_delete_document,
+            commands::mongo_cmd::mongo_delete_documents,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_test_connection,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_list_tenants,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_get_tenant,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_create_tenant,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_update_tenant,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_delete_tenant,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_list_namespaces,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_create_namespace,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_delete_namespace,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_get_namespace_policies,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_list_topics,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_create_topic,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_delete_topic,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_update_partitions,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_get_topic_stats,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_get_topic_internal_stats,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_list_subscriptions,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_create_subscription,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_delete_subscription,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_skip_messages,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_reset_cursor,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_clear_backlog,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_peek_messages,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_expire_messages,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_list_producers,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_list_consumers,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_unload_topic,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_set_publish_rate,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_set_dispatch_rate,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_set_subscribe_rate,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_set_backlog_quota,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_set_retention,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_get_effective_policies,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_grant_permission,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_revoke_permission,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_list_permissions,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_issue_token,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_list_token_records,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_get_backlog,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_get_cluster_info,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_raw_request,
+            #[cfg(feature = "mq-admin")]
+            commands::mq_cmd::mq_send_message,
+            commands::history::save_history,
+            commands::history::load_history,
+            commands::history::clear_history,
+            commands::history::delete_history_entry,
+            commands::mcp::check_mcp_server_status,
+            commands::mcp::install_mcp_server,
+            commands::update::check_for_updates,
+            commands::update::get_system_proxy_url,
+            commands::update::download_and_install_update,
+            commands::transfer::start_transfer,
+            commands::transfer::preview_transfer_ownership,
+            commands::transfer::cancel_transfer,
+            commands::database_export::export_database_sql,
+            commands::database_export::cancel_database_export,
+            commands::table_export::start_table_export,
+            commands::table_export::cancel_table_export,
+            commands::query_result_export::start_query_result_export,
+            commands::query_result_export::cancel_query_result_export,
+            commands::csv_export::export_query_result_csv,
+            commands::csv_export::export_table_data_csv,
+            commands::xlsx_export::export_query_result_xlsx,
+            commands::xlsx_export::export_query_results_xlsx,
+            commands::text_export::export_query_result_json,
+            commands::text_export::export_query_result_markdown,
+            commands::agents::list_installed_agents,
+            commands::agents::list_installed_agents_local,
+            commands::agents::is_agent_installed,
+            commands::agents::get_driver_store_usage,
+            commands::agents::clear_driver_download_cache,
+            commands::agents::get_driver_runtime_summary,
+            commands::agents::stop_driver_runtime,
+            commands::agents::restart_driver_runtime,
+            commands::agents::install_agent,
+            commands::agents::upgrade_all_agents,
+            commands::agents::check_agent_update_blockers,
+            commands::agents::uninstall_agent,
+            commands::agents::check_jre_installed,
+            commands::agents::get_agent_java_runtime_config,
+            commands::agents::set_agent_java_runtime_config,
+            commands::agents::uninstall_jre,
+            commands::agents::reinstall_jre,
+            commands::agents::invalidate_agent_registry_cache,
+            commands::agents::import_agents_from_zip,
+            commands::agents::import_agent_jar_cmd,
+            commands::system_fonts::list_system_fonts,
+            commands::ssh_config::list_ssh_config_hosts,
+            commands::tunnel_profiles::load_tunnel_profiles,
+            commands::tunnel_profiles::save_tunnel_profiles,
+        ])
+        .build(tauri::generate_context!())
+        .expect("error while building tauri application")
+        .run(|app_handle, event| {
+            #[cfg(not(target_os = "macos"))]
+            let _ = (&app_handle, &event);
+
+            if let RunEvent::ExitRequested { code, api, .. } = &event {
+                let confirmed_exit = app_handle
+                    .try_state::<CloseBehaviorState>()
+                    .map(|state| state.take_confirmed_exit())
+                    .unwrap_or(false);
+                if should_confirm_app_exit_request(std::env::consts::OS, *code, confirmed_exit) {
+                    api.prevent_exit();
+                    request_app_close(app_handle, "quit");
+                }
+            }
+
+            #[cfg(target_os = "macos")]
+            if let RunEvent::Opened { urls } = &event {
+                let links: Vec<String> = urls
+                    .iter()
+                    .map(|url| url.to_string())
+                    .filter_map(|url| commands::deep_link::connection_deep_link_from_arg(&url))
+                    .collect();
+                open_connection_deep_links(app_handle, links);
+
+                let paths: Vec<String> = urls
+                    .iter()
+                    .filter_map(|url| url.to_file_path().ok())
+                    .filter(|path| commands::external_sql::is_sql_file_path(path))
+                    .map(|path| path.to_string_lossy().to_string())
+                    .collect();
+                if !paths.is_empty() {
+                    if let Some(state) = app_handle.try_state::<commands::external_sql::ExternalSqlOpenState>() {
+                        state.push(paths.clone());
+                    }
+                    let _ = app_handle.emit("dbx-open-sql-files", paths);
+                    if let Some(window) = app_handle.get_webview_window("main") {
+                        let _ = window.show();
+                        let _ = window.set_focus();
+                    }
+                }
+
+                let db_paths: Vec<String> = urls
+                    .iter()
+                    .filter_map(|url| url.to_file_path().ok())
+                    .filter(|path| commands::external_db::is_db_file_path(path))
+                    .map(|path| path.to_string_lossy().to_string())
+                    .collect();
+                if !db_paths.is_empty() {
+                    if let Some(state) = app_handle.try_state::<commands::external_db::ExternalDbOpenState>() {
+                        state.push(db_paths.clone());
+                    }
+                    let _ = app_handle.emit("dbx-open-db-files", db_paths);
+                    if let Some(window) = app_handle.get_webview_window("main") {
+                        let _ = window.show();
+                        let _ = window.set_focus();
+                    }
+                }
+            }
+
+            #[cfg(target_os = "macos")]
+            if let RunEvent::Reopen { has_visible_windows, .. } = &event {
+                if !has_visible_windows {
+                    show_main_window(app_handle);
+                }
+                let app_handle = app_handle.clone();
+                tauri::async_runtime::spawn(async move {
+                    if let Some(state) = app_handle.try_state::<AppState>() {
+                        state.refresh_connections().await;
+                    }
+                });
+            }
+
+            if let RunEvent::Resumed = &event {
+                let app_handle = app_handle.clone();
+                tauri::async_runtime::spawn(async move {
+                    if let Some(state) = app_handle.try_state::<AppState>() {
+                        state.refresh_connections().await;
+                    }
+                });
+            }
+        });
+}
diff --git a/src-tauri/src/macos_app_delegate.rs b/src-tauri/src/macos_app_delegate.rs
new file mode 100644
index 0000000..de0f55f
--- /dev/null
+++ b/src-tauri/src/macos_app_delegate.rs
@@ -0,0 +1,69 @@
+use std::{
+    ffi::CStr,
+    sync::{Once, OnceLock},
+};
+
+use objc2::{
+    ffi,
+    runtime::{AnyClass, AnyObject, Imp, Sel},
+    sel,
+};
+use objc2_app_kit::NSApplicationTerminateReply;
+use tauri::{AppHandle, Manager};
+
+use crate::{request_app_close, CloseBehaviorState};
+
+static APP_HANDLE: OnceLock<AppHandle> = OnceLock::new();
+static INSTALL_DOCK_QUIT_HANDLER: Once = Once::new();
+
+pub(crate) fn install_dock_quit_handler(app: &AppHandle) {
+    let _ = APP_HANDLE.set(app.clone());
+    INSTALL_DOCK_QUIT_HANDLER.call_once(|| {
+        let Some(delegate_class) =
+            AnyClass::get(CStr::from_bytes_with_nul(b"TaoAppDelegateParent\0").expect("valid class name"))
+        else {
+            eprintln!("[WARN] failed to install macOS Dock quit handler: TaoAppDelegateParent not found");
+            return;
+        };
+
+        let imp: Imp = unsafe {
+            std::mem::transmute(
+                application_should_terminate
+                    as extern "C-unwind" fn(&AnyObject, Sel, &AnyObject) -> NSApplicationTerminateReply,
+            )
+        };
+        let method_types = CStr::from_bytes_with_nul(b"Q@:@\0").expect("valid Objective-C method type encoding");
+
+        // Tao's app delegate does not implement applicationShouldTerminate:, so Dock Quit can
+        // bypass Tauri's ExitRequested event. Add the method to Tao's registered delegate class
+        // and route that native quit request through DBX's normal close confirmation flow.
+        let added = unsafe {
+            ffi::class_addMethod(
+                delegate_class as *const AnyClass as *mut AnyClass,
+                sel!(applicationShouldTerminate:),
+                imp,
+                method_types.as_ptr(),
+            )
+        };
+        if !added.as_bool() {
+            eprintln!("[WARN] failed to install macOS Dock quit handler: applicationShouldTerminate: already exists");
+        }
+    });
+}
+
+extern "C-unwind" fn application_should_terminate(
+    _delegate: &AnyObject,
+    _selector: Sel,
+    _sender: &AnyObject,
+) -> NSApplicationTerminateReply {
+    let Some(app) = APP_HANDLE.get() else {
+        return NSApplicationTerminateReply::TerminateNow;
+    };
+
+    if app.try_state::<CloseBehaviorState>().map(|state| state.take_confirmed_exit()).unwrap_or(false) {
+        return NSApplicationTerminateReply::TerminateNow;
+    }
+
+    request_app_close(app, "quit");
+    NSApplicationTerminateReply::TerminateCancel
+}
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
new file mode 100644
index 0000000..fdfb97e
--- /dev/null
+++ b/src-tauri/src/main.rs
@@ -0,0 +1,16 @@
+// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+    #[cfg(feature = "duckdb-bundled")]
+    if std::env::args().any(|arg| arg == "--duckdb-worker") {
+        let runtime = tokio::runtime::Runtime::new().expect("Failed to create DuckDB worker runtime");
+        if let Err(err) = runtime.block_on(dbx_core::db::duckdb_worker_runtime::run_stdio_worker()) {
+            eprintln!("DuckDB worker failed: {err}");
+            std::process::exit(1);
+        }
+        return;
+    }
+
+    dbx_lib::run();
+}
diff --git a/src-tauri/src/models/connection.rs b/src-tauri/src/models/connection.rs
new file mode 100644
index 0000000..f0c6f5d
--- /dev/null
+++ b/src-tauri/src/models/connection.rs
@@ -0,0 +1 @@
+pub use dbx_core::models::connection::*;
diff --git a/src-tauri/src/models/mod.rs b/src-tauri/src/models/mod.rs
new file mode 100644
index 0000000..b3b606b
--- /dev/null
+++ b/src-tauri/src/models/mod.rs
@@ -0,0 +1 @@
+pub mod connection;
diff --git a/src-tauri/src/window_state_guard.rs b/src-tauri/src/window_state_guard.rs
new file mode 100644
index 0000000..56c3919
--- /dev/null
+++ b/src-tauri/src/window_state_guard.rs
@@ -0,0 +1,127 @@
+use tauri::{AppHandle, Manager, PhysicalPosition, PhysicalSize, Runtime, WebviewWindow};
+use tauri_plugin_window_state::{AppHandleExt, StateFlags};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct PhysicalWindowRect {
+    pub(crate) x: i32,
+    pub(crate) y: i32,
+    pub(crate) width: u32,
+    pub(crate) height: u32,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct PhysicalMonitorRect {
+    pub(crate) x: i32,
+    pub(crate) y: i32,
+    pub(crate) width: u32,
+    pub(crate) height: u32,
+}
+
+pub(crate) fn corrected_window_rect(
+    window: PhysicalWindowRect,
+    monitor: PhysicalMonitorRect,
+) -> Option<PhysicalWindowRect> {
+    let width = window.width.min(monitor.width);
+    let height = window.height.min(monitor.height);
+    let x = centered_axis_position(window.x, width, monitor.x, monitor.width);
+    let y = centered_axis_position(window.y, height, monitor.y, monitor.height);
+    let corrected = PhysicalWindowRect { x, y, width, height };
+
+    (corrected != window).then_some(corrected)
+}
+
+pub(crate) fn enforce_main_window_bounds<R: Runtime>(app: &AppHandle<R>) {
+    if let Some(window) = app.get_webview_window("main") {
+        if enforce_window_bounds(&window) {
+            let _ = app.save_window_state(StateFlags::all());
+        }
+    }
+}
+
+fn enforce_window_bounds<R: Runtime>(window: &WebviewWindow<R>) -> bool {
+    if window.is_maximized().unwrap_or(false) || window.is_fullscreen().unwrap_or(false) {
+        return false;
+    }
+
+    let monitor = match window.current_monitor().ok().flatten().or_else(|| window.primary_monitor().ok().flatten()) {
+        Some(monitor) => monitor,
+        None => return false,
+    };
+    let monitor_position = monitor.position();
+    let monitor_size = monitor.size();
+    let window_position = match window.outer_position() {
+        Ok(position) => position,
+        Err(_) => return false,
+    };
+    let window_size = match window.outer_size() {
+        Ok(size) => size,
+        Err(_) => return false,
+    };
+
+    let corrected = corrected_window_rect(
+        PhysicalWindowRect {
+            x: window_position.x,
+            y: window_position.y,
+            width: window_size.width,
+            height: window_size.height,
+        },
+        PhysicalMonitorRect {
+            x: monitor_position.x,
+            y: monitor_position.y,
+            width: monitor_size.width,
+            height: monitor_size.height,
+        },
+    );
+
+    if let Some(rect) = corrected {
+        let _ = window.set_size(PhysicalSize::new(rect.width, rect.height));
+        let _ = window.set_position(PhysicalPosition::new(rect.x, rect.y));
+        true
+    } else {
+        false
+    }
+}
+
+fn centered_axis_position(window_start: i32, window_length: u32, monitor_start: i32, monitor_length: u32) -> i32 {
+    let max_start = monitor_start + monitor_length.saturating_sub(window_length) as i32;
+    if window_start < monitor_start || window_start > max_start {
+        monitor_start + monitor_length.saturating_sub(window_length) as i32 / 2
+    } else {
+        window_start
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{corrected_window_rect, PhysicalMonitorRect, PhysicalWindowRect};
+
+    #[test]
+    fn moves_window_back_onto_monitor_when_restored_above_screen() {
+        let corrected = corrected_window_rect(
+            PhysicalWindowRect { x: 118, y: -1042, width: 1512, height: 866 },
+            PhysicalMonitorRect { x: 0, y: 0, width: 1512, height: 982 },
+        );
+
+        assert_eq!(corrected, Some(PhysicalWindowRect { x: 0, y: 58, width: 1512, height: 866 }));
+    }
+
+    #[test]
+    fn leaves_window_unchanged_when_it_fits_monitor() {
+        let corrected = corrected_window_rect(
+            PhysicalWindowRect { x: 80, y: 60, width: 1280, height: 800 },
+            PhysicalMonitorRect { x: 0, y: 0, width: 1512, height: 982 },
+        );
+
+        assert_eq!(corrected, None);
+    }
+
+    #[test]
+    fn shrinks_window_that_is_larger_than_monitor() {
+        let corrected = corrected_window_rect(
+            PhysicalWindowRect { x: -200, y: -120, width: 4096, height: 2160 },
+            PhysicalMonitorRect { x: 0, y: 0, width: 1440, height: 900 },
+        );
+
+        assert_eq!(corrected, Some(PhysicalWindowRect { x: 0, y: 0, width: 1440, height: 900 }));
+    }
+}
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
new file mode 100644
index 0000000..2e40774
--- /dev/null
+++ b/src-tauri/tauri.conf.json
@@ -0,0 +1,76 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "productName": "DBX",
+  "version": "0.5.55",
+  "identifier": "com.dbx.app",
+  "build": {
+    "frontendDist": "../dist",
+    "devUrl": "http://localhost:1420",
+    "beforeDevCommand": "pnpm dev",
+    "beforeBuildCommand": "pnpm build"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "DBX",
+        "width": 1280,
+        "height": 800,
+        "minWidth": 900,
+        "minHeight": 600,
+        "resizable": true,
+        "fullscreen": false,
+        "visible": false,
+        "titleBarStyle": "Overlay",
+        "trafficLightPosition": {
+          "x": 16,
+          "y": 18
+        },
+        "hiddenTitle": true
+      }
+    ],
+    "security": {
+      "csp": null
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "createUpdaterArtifacts": true,
+    "fileAssociations": [
+      {
+        "ext": ["sql"],
+        "name": "SQL Script",
+        "description": "SQL script",
+        "role": "Editor",
+        "mimeType": "application/sql"
+      },
+      {
+        "ext": ["db", "sqlite", "sqlite3", "duckdb"],
+        "name": "Database File",
+        "description": "Database file",
+        "role": "Editor"
+      }
+    ],
+    "macOS": {
+      "entitlements": "Entitlements.plist"
+    },
+    "windows": {
+      "nsis": {
+        "installMode": "currentUser",
+        "template": "windows/nsis/installer.nsi"
+      }
+    },
+    "icon": ["icons/32x32.png", "icons/128x128.png", "icons/128x128@2x.png", "icons/icon.icns", "icons/icon.ico"]
+  },
+  "plugins": {
+    "deep-link": {
+      "desktop": {
+        "schemes": ["dbx"]
+      }
+    },
+    "updater": {
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDkxNEYyMzE3QkJCNkM3REYKUldUZng3YTdGeU5Qa1NnTUZCRVhJVkxsOWZKQWFPVCtacUgySlNlcjRDU2RmZElCQnphd25pYUMK",
+      "endpoints": ["https://dl.dbxio.com/releases/latest/latest.json", "https://github.com/t8y2/dbx/releases/latest/download/latest.json"]
+    }
+  }
+}
diff --git a/src-tauri/tauri.webview2-offline.conf.json b/src-tauri/tauri.webview2-offline.conf.json
new file mode 100644
index 0000000..d41fa89
--- /dev/null
+++ b/src-tauri/tauri.webview2-offline.conf.json
@@ -0,0 +1,10 @@
+{
+  "bundle": {
+    "windows": {
+      "webviewInstallMode": {
+        "silent": true,
+        "type": "offlineInstaller"
+      }
+    }
+  }
+}
diff --git a/src-tauri/windows/nsis/installer.nsi b/src-tauri/windows/nsis/installer.nsi
new file mode 100644
index 0000000..52b51a9
--- /dev/null
+++ b/src-tauri/windows/nsis/installer.nsi
@@ -0,0 +1,978 @@
+Unicode true
+ManifestDPIAware true
+; Add in `dpiAwareness` `PerMonitorV2` to manifest for Windows 10 1607+ (note this should not affect lower versions since they should be able to ignore this and pick up `dpiAware` `true` set by `ManifestDPIAware true`)
+; Currently undocumented on NSIS's website but is in the Docs folder of source tree, see
+; https://github.com/kichik/nsis/blob/5fc0b87b819a9eec006df4967d08e522ddd651c9/Docs/src/attributes.but#L286-L300
+; https://github.com/tauri-apps/tauri/pull/10106
+ManifestDPIAwareness PerMonitorV2
+
+!if "{{compression}}" == "none"
+  SetCompress off
+!else
+  ; Set the compression algorithm. We default to LZMA.
+  SetCompressor /SOLID "{{compression}}"
+!endif
+
+!include MUI2.nsh
+!include FileFunc.nsh
+!include x64.nsh
+!include WordFunc.nsh
+!include "utils.nsh"
+!include "FileAssociation.nsh"
+!include "Win\COM.nsh"
+!include "Win\Propkey.nsh"
+!include "StrFunc.nsh"
+${StrCase}
+${StrLoc}
+
+{{#if installer_hooks}}
+!include "{{installer_hooks}}"
+{{/if}}
+
+!define WEBVIEW2APPGUID "{F3017226-FE2A-4295-8BDF-00C3A9A7E4C5}"
+
+!define MANUFACTURER "{{manufacturer}}"
+!define PRODUCTNAME "{{product_name}}"
+!define VERSION "{{version}}"
+!define VERSIONWITHBUILD "{{version_with_build}}"
+!define HOMEPAGE "{{homepage}}"
+!define INSTALLMODE "{{install_mode}}"
+!define LICENSE "{{license}}"
+!define INSTALLERICON "{{installer_icon}}"
+!define SIDEBARIMAGE "{{sidebar_image}}"
+!define HEADERIMAGE "{{header_image}}"
+!define UNINSTALLERICON "{{uninstaller_icon}}"
+!define UNINSTALLERHEADERIMAGE "{{uninstaller_header_image}}"
+!define MAINBINARYNAME "{{main_binary_name}}"
+!define MAINBINARYSRCPATH "{{main_binary_path}}"
+!define BUNDLEID "{{bundle_id}}"
+!define COPYRIGHT "{{copyright}}"
+!define OUTFILE "{{out_file}}"
+!define ARCH "{{arch}}"
+!define ADDITIONALPLUGINSPATH "{{additional_plugins_path}}"
+!define ALLOWDOWNGRADES "{{allow_downgrades}}"
+!define DISPLAYLANGUAGESELECTOR "{{display_language_selector}}"
+!define INSTALLWEBVIEW2MODE "{{install_webview2_mode}}"
+!define WEBVIEW2INSTALLERARGS "{{webview2_installer_args}}"
+!define WEBVIEW2BOOTSTRAPPERPATH "{{webview2_bootstrapper_path}}"
+!define WEBVIEW2INSTALLERPATH "{{webview2_installer_path}}"
+!define MINIMUMWEBVIEW2VERSION "{{minimum_webview2_version}}"
+!define UNINSTKEY "Software\Microsoft\Windows\CurrentVersion\Uninstall\${PRODUCTNAME}"
+!define MANUKEY "Software\${MANUFACTURER}"
+!define MANUPRODUCTKEY "${MANUKEY}\${PRODUCTNAME}"
+!define UNINSTALLERSIGNCOMMAND "{{uninstaller_sign_cmd}}"
+!define ESTIMATEDSIZE "{{estimated_size}}"
+!define STARTMENUFOLDER "{{start_menu_folder}}"
+!searchreplace WEBVIEW2LOADERSRCPATH "${MAINBINARYSRCPATH}" "\${MAINBINARYNAME}.exe" "\WebView2Loader.dll"
+
+Var PassiveMode
+Var UpdateMode
+Var NoShortcutMode
+Var WixMode
+Var OldMainBinaryName
+
+Name "${PRODUCTNAME}"
+BrandingText "${COPYRIGHT}"
+OutFile "${OUTFILE}"
+
+; We don't actually use this value as default install path,
+; it's just for nsis to append the product name folder in the directory selector
+; https://nsis.sourceforge.io/Reference/InstallDir
+!define PLACEHOLDER_INSTALL_DIR "placeholder\${PRODUCTNAME}"
+InstallDir "${PLACEHOLDER_INSTALL_DIR}"
+
+VIProductVersion "${VERSIONWITHBUILD}"
+VIAddVersionKey "ProductName" "${PRODUCTNAME}"
+VIAddVersionKey "FileDescription" "${PRODUCTNAME}"
+VIAddVersionKey "LegalCopyright" "${COPYRIGHT}"
+VIAddVersionKey "FileVersion" "${VERSION}"
+VIAddVersionKey "ProductVersion" "${VERSION}"
+
+# additional plugins
+!addplugindir "${ADDITIONALPLUGINSPATH}"
+
+; Uninstaller signing command
+!if "${UNINSTALLERSIGNCOMMAND}" != ""
+  !uninstfinalize '${UNINSTALLERSIGNCOMMAND}'
+!endif
+
+; Handle install mode, `perUser`, `perMachine` or `both`
+!if "${INSTALLMODE}" == "perMachine"
+  RequestExecutionLevel admin
+!endif
+
+!if "${INSTALLMODE}" == "currentUser"
+  RequestExecutionLevel user
+!endif
+
+!if "${INSTALLMODE}" == "both"
+  !define MULTIUSER_MUI
+  !define MULTIUSER_INSTALLMODE_INSTDIR "${PRODUCTNAME}"
+  !define MULTIUSER_INSTALLMODE_COMMANDLINE
+  !if "${ARCH}" == "x64"
+    !define MULTIUSER_USE_PROGRAMFILES64
+  !else if "${ARCH}" == "arm64"
+    !define MULTIUSER_USE_PROGRAMFILES64
+  !endif
+  !define MULTIUSER_INSTALLMODE_DEFAULT_REGISTRY_KEY "${UNINSTKEY}"
+  !define MULTIUSER_INSTALLMODE_DEFAULT_REGISTRY_VALUENAME "CurrentUser"
+  !define MULTIUSER_INSTALLMODEPAGE_SHOWUSERNAME
+  !define MULTIUSER_INSTALLMODE_FUNCTION RestorePreviousInstallLocation
+  !define MULTIUSER_EXECUTIONLEVEL Highest
+  !include MultiUser.nsh
+!endif
+
+; Installer icon
+!if "${INSTALLERICON}" != ""
+  !define MUI_ICON "${INSTALLERICON}"
+!endif
+
+; Installer sidebar image
+!if "${SIDEBARIMAGE}" != ""
+  !define MUI_WELCOMEFINISHPAGE_BITMAP "${SIDEBARIMAGE}"
+!endif
+
+; Enable header images for installer and uninstaller pages when either image is configured.
+!if "${HEADERIMAGE}" != ""
+  !define MUI_HEADERIMAGE
+!else if "${UNINSTALLERHEADERIMAGE}" != ""
+  !define MUI_HEADERIMAGE
+!endif
+
+; Installer header image
+!if "${HEADERIMAGE}" != ""
+  !define MUI_HEADERIMAGE_BITMAP "${HEADERIMAGE}"
+!endif
+
+; Uninstaller header image
+!if "${UNINSTALLERHEADERIMAGE}" != ""
+  !define MUI_HEADERIMAGE_UNBITMAP "${UNINSTALLERHEADERIMAGE}"
+!endif
+
+; Uninstaller icon
+!if "${UNINSTALLERICON}" != ""
+  !define MUI_UNICON "${UNINSTALLERICON}"
+!endif
+
+; Define registry key to store installer language
+!define MUI_LANGDLL_REGISTRY_ROOT "HKCU"
+!define MUI_LANGDLL_REGISTRY_KEY "${MANUPRODUCTKEY}"
+!define MUI_LANGDLL_REGISTRY_VALUENAME "Installer Language"
+
+; Installer pages, must be ordered as they appear
+; 1. Welcome Page
+!define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+!insertmacro MUI_PAGE_WELCOME
+
+; 2. License Page (if defined)
+!if "${LICENSE}" != ""
+  !define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+  !insertmacro MUI_PAGE_LICENSE "${LICENSE}"
+!endif
+
+; 3. Install mode (if it is set to `both`)
+!if "${INSTALLMODE}" == "both"
+  !define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+  !insertmacro MULTIUSER_PAGE_INSTALLMODE
+!endif
+
+; 4. Custom page to ask user if he wants to reinstall/uninstall
+;    only if a previous installation was detected
+Var ReinstallPageCheck
+Page custom PageReinstall PageLeaveReinstall
+Function PageReinstall
+  ; Uninstall previous WiX installation if exists.
+  ;
+  ; A WiX installer stores the installation info in registry
+  ; using a UUID and so we have to loop through all keys under
+  ; `HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall`
+  ; and check if `DisplayName` and `Publisher` keys match ${PRODUCTNAME} and ${MANUFACTURER}
+  ;
+  ; This has a potential issue that there maybe another installation that matches
+  ; our ${PRODUCTNAME} and ${MANUFACTURER} but wasn't installed by our WiX installer,
+  ; however, this should be fine since the user will have to confirm the uninstallation
+  ; and they can chose to abort it if doesn't make sense.
+  StrCpy $0 0
+  wix_loop:
+    EnumRegKey $1 HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall" $0
+    StrCmp $1 "" wix_loop_done ; Exit loop if there is no more keys to loop on
+    IntOp $0 $0 + 1
+    ReadRegStr $R0 HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$1" "DisplayName"
+    ReadRegStr $R1 HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$1" "Publisher"
+    StrCmp "$R0$R1" "${PRODUCTNAME}${MANUFACTURER}" 0 wix_loop
+    ReadRegStr $R0 HKLM "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$1" "UninstallString"
+    ${StrCase} $R1 $R0 "L"
+    ${StrLoc} $R0 $R1 "msiexec" ">"
+    StrCmp $R0 0 0 wix_loop_done
+    StrCpy $WixMode 1
+    StrCpy $R6 "SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\$1"
+    Goto compare_version
+  wix_loop_done:
+
+  ; Check if there is an existing installation, if not, abort the reinstall page
+  ReadRegStr $R0 SHCTX "${UNINSTKEY}" ""
+  ReadRegStr $R1 SHCTX "${UNINSTKEY}" "UninstallString"
+  ${IfThen} "$R0$R1" == "" ${|} Abort ${|}
+
+  ; Compare this installar version with the existing installation
+  ; and modify the messages presented to the user accordingly
+  compare_version:
+  StrCpy $R4 "$(older)"
+  ${If} $WixMode = 1
+    ReadRegStr $R0 HKLM "$R6" "DisplayVersion"
+  ${Else}
+    ReadRegStr $R0 SHCTX "${UNINSTKEY}" "DisplayVersion"
+  ${EndIf}
+  ${IfThen} $R0 == "" ${|} StrCpy $R4 "$(unknown)" ${|}
+
+  nsis_tauri_utils::SemverCompare "${VERSION}" $R0
+  Pop $R0
+  ; Reinstalling the same version
+  ${If} $R0 = 0
+    StrCpy $R1 "$(alreadyInstalledLong)"
+    StrCpy $R2 "$(addOrReinstall)"
+    StrCpy $R3 "$(uninstallApp)"
+    !insertmacro MUI_HEADER_TEXT "$(alreadyInstalled)" "$(chooseMaintenanceOption)"
+  ; Upgrading
+  ${ElseIf} $R0 = 1
+    StrCpy $R1 "$(olderOrUnknownVersionInstalled)"
+    StrCpy $R2 "$(uninstallBeforeInstalling)"
+    StrCpy $R3 "$(dontUninstall)"
+    !insertmacro MUI_HEADER_TEXT "$(alreadyInstalled)" "$(choowHowToInstall)"
+  ; Downgrading
+  ${ElseIf} $R0 = -1
+    StrCpy $R1 "$(newerVersionInstalled)"
+    StrCpy $R2 "$(uninstallBeforeInstalling)"
+    !if "${ALLOWDOWNGRADES}" == "true"
+      StrCpy $R3 "$(dontUninstall)"
+    !else
+      StrCpy $R3 "$(dontUninstallDowngrade)"
+    !endif
+    !insertmacro MUI_HEADER_TEXT "$(alreadyInstalled)" "$(choowHowToInstall)"
+  ${Else}
+    Abort
+  ${EndIf}
+
+  ; Skip showing the page if passive
+  ;
+  ; Note that we don't call this earlier at the begining
+  ; of this function because we need to populate some variables
+  ; related to current installed version if detected and whether
+  ; we are downgrading or not.
+  ${If} $PassiveMode = 1
+    Call PageLeaveReinstall
+  ${Else}
+    nsDialogs::Create 1018
+    Pop $R4
+    ${IfThen} $(^RTL) = 1 ${|} nsDialogs::SetRTL $(^RTL) ${|}
+
+    ${NSD_CreateLabel} 0 0 100% 24u $R1
+    Pop $R1
+
+    ${NSD_CreateRadioButton} 30u 50u -30u 8u $R2
+    Pop $R2
+    ${NSD_OnClick} $R2 PageReinstallUpdateSelection
+
+    ${NSD_CreateRadioButton} 30u 70u -30u 8u $R3
+    Pop $R3
+    ; Disable this radio button if downgrading and downgrades are disabled
+    !if "${ALLOWDOWNGRADES}" == "false"
+      ${IfThen} $R0 = -1 ${|} EnableWindow $R3 0 ${|}
+    !endif
+    ${NSD_OnClick} $R3 PageReinstallUpdateSelection
+
+    ; Check the first radio button if this the first time
+    ; we enter this page or if the second button wasn't
+    ; selected the last time we were on this page
+    ${If} $ReinstallPageCheck <> 2
+      SendMessage $R2 ${BM_SETCHECK} ${BST_CHECKED} 0
+    ${Else}
+      SendMessage $R3 ${BM_SETCHECK} ${BST_CHECKED} 0
+    ${EndIf}
+
+    ${NSD_SetFocus} $R2
+    nsDialogs::Show
+  ${EndIf}
+FunctionEnd
+Function PageReinstallUpdateSelection
+  ${NSD_GetState} $R2 $R1
+  ${If} $R1 == ${BST_CHECKED}
+    StrCpy $ReinstallPageCheck 1
+  ${Else}
+    StrCpy $ReinstallPageCheck 2
+  ${EndIf}
+FunctionEnd
+Function PageLeaveReinstall
+  ${NSD_GetState} $R2 $R1
+
+  ; If migrating from Wix, always uninstall
+  ${If} $WixMode = 1
+    Goto reinst_uninstall
+  ${EndIf}
+
+  ; In update mode, always proceeds without uninstalling
+  ${If} $UpdateMode = 1
+    Goto reinst_done
+  ${EndIf}
+
+  ; $R0 holds whether same(0)/upgrading(1)/downgrading(-1) version
+  ; $R1 holds the radio buttons state:
+  ;   1 => first choice was selected
+  ;   0 => second choice was selected
+  ${If} $R0 = 0 ; Same version, proceed
+    ${If} $R1 = 1              ; User chose to add/reinstall
+      Goto reinst_done
+    ${Else}                    ; User chose to uninstall
+      Goto reinst_uninstall
+    ${EndIf}
+  ${ElseIf} $R0 = 1 ; Upgrading
+    ${If} $R1 = 1              ; User chose to uninstall
+      Goto reinst_uninstall
+    ${Else}
+      Goto reinst_done         ; User chose NOT to uninstall
+    ${EndIf}
+  ${ElseIf} $R0 = -1 ; Downgrading
+    ${If} $R1 = 1              ; User chose to uninstall
+      Goto reinst_uninstall
+    ${Else}
+      Goto reinst_done         ; User chose NOT to uninstall
+    ${EndIf}
+  ${EndIf}
+
+  reinst_uninstall:
+    HideWindow
+    ClearErrors
+
+    ${If} $WixMode = 1
+      ReadRegStr $R1 HKLM "$R6" "UninstallString"
+      ExecWait '$R1' $0
+    ${Else}
+      ReadRegStr $4 SHCTX "${MANUPRODUCTKEY}" ""
+      ReadRegStr $R1 SHCTX "${UNINSTKEY}" "UninstallString"
+      ${If} $UpdateMode = 1
+      ${OrIf} $R0 = 1
+        StrCpy $R1 "$R1 /UPDATE"
+      ${EndIf}
+      ${IfThen} $PassiveMode = 1 ${|} StrCpy $R1 "$R1 /P" ${|} ; append /P
+      StrCpy $R1 "$R1 _?=$4" ; append uninstall directory
+      ExecWait '$R1' $0
+    ${EndIf}
+
+    BringToFront
+
+    ${IfThen} ${Errors} ${|} StrCpy $0 2 ${|} ; ExecWait failed, set fake exit code
+
+    ${If} $0 <> 0
+    ${OrIf} ${FileExists} "$INSTDIR\${MAINBINARYNAME}.exe"
+      ; User cancelled wix uninstaller? return to select un/reinstall page
+      ${If} $WixMode = 1
+      ${AndIf} $0 = 1602
+        Abort
+      ${EndIf}
+
+      ; User cancelled NSIS uninstaller? return to select un/reinstall page
+      ${If} $0 = 1
+        Abort
+      ${EndIf}
+
+      ; Other erros? show generic error message and return to select un/reinstall page
+      MessageBox MB_ICONEXCLAMATION "$(unableToUninstall)"
+      Abort
+    ${EndIf}
+  reinst_done:
+FunctionEnd
+
+; 5. Choose install directory page
+!define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+!insertmacro MUI_PAGE_DIRECTORY
+
+; 6. Start menu shortcut page
+Var AppStartMenuFolder
+!if "${STARTMENUFOLDER}" != ""
+  !define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+  !define MUI_STARTMENUPAGE_DEFAULTFOLDER "${STARTMENUFOLDER}"
+!else
+  !define MUI_PAGE_CUSTOMFUNCTION_PRE Skip
+!endif
+!insertmacro MUI_PAGE_STARTMENU Application $AppStartMenuFolder
+
+; 7. Installation page
+!insertmacro MUI_PAGE_INSTFILES
+
+; 8. Finish page
+;
+; Don't auto jump to finish page after installation page,
+; because the installation page has useful info that can be used debug any issues with the installer.
+!define MUI_FINISHPAGE_NOAUTOCLOSE
+; Use show readme button in the finish page as a button create a desktop shortcut
+!define MUI_FINISHPAGE_SHOWREADME
+!define MUI_FINISHPAGE_SHOWREADME_TEXT "$(createDesktop)"
+!define MUI_FINISHPAGE_SHOWREADME_FUNCTION CreateOrUpdateDesktopShortcut
+; Show run app after installation.
+!define MUI_FINISHPAGE_RUN
+!define MUI_FINISHPAGE_RUN_FUNCTION RunMainBinary
+!define MUI_PAGE_CUSTOMFUNCTION_PRE SkipIfPassive
+!insertmacro MUI_PAGE_FINISH
+
+Function RunMainBinary
+  nsis_tauri_utils::RunAsUser "$INSTDIR\${MAINBINARYNAME}.exe" ""
+FunctionEnd
+
+; Uninstaller Pages
+; 1. Confirm uninstall page
+Var DeleteAppDataCheckbox
+Var DeleteAppDataCheckboxState
+!define /ifndef WS_EX_LAYOUTRTL         0x00400000
+!define MUI_PAGE_CUSTOMFUNCTION_SHOW un.ConfirmShow
+Function un.ConfirmShow ; Add add a `Delete app data` check box
+  ; $1 inner dialog HWND
+  ; $2 window DPI
+  ; $3 style
+  ; $4 x
+  ; $5 y
+  ; $6 width
+  ; $7 height
+  FindWindow $1 "#32770" "" $HWNDPARENT ; Find inner dialog
+  System::Call "user32::GetDpiForWindow(p r1) i .r2"
+  ${If} $(^RTL) = 1
+    StrCpy $3 "${__NSD_CheckBox_EXSTYLE} | ${WS_EX_LAYOUTRTL}"
+    IntOp $4 50 * $2
+  ${Else}
+    StrCpy $3 "${__NSD_CheckBox_EXSTYLE}"
+    IntOp $4 0 * $2
+  ${EndIf}
+  IntOp $5 100 * $2
+  IntOp $6 400 * $2
+  IntOp $7 25 * $2
+  IntOp $4 $4 / 96
+  IntOp $5 $5 / 96
+  IntOp $6 $6 / 96
+  IntOp $7 $7 / 96
+  System::Call 'user32::CreateWindowEx(i r3, w "${__NSD_CheckBox_CLASS}", w "$(deleteAppData)", i ${__NSD_CheckBox_STYLE}, i r4, i r5, i r6, i r7, p r1, i0, i0, i0) i .s'
+  Pop $DeleteAppDataCheckbox
+  SendMessage $HWNDPARENT ${WM_GETFONT} 0 0 $1
+  SendMessage $DeleteAppDataCheckbox ${WM_SETFONT} $1 1
+FunctionEnd
+!define MUI_PAGE_CUSTOMFUNCTION_LEAVE un.ConfirmLeave
+Function un.ConfirmLeave
+  SendMessage $DeleteAppDataCheckbox ${BM_GETCHECK} 0 0 $DeleteAppDataCheckboxState
+FunctionEnd
+!define MUI_PAGE_CUSTOMFUNCTION_PRE un.SkipIfPassive
+!insertmacro MUI_UNPAGE_CONFIRM
+
+; 2. Uninstalling Page
+!insertmacro MUI_UNPAGE_INSTFILES
+
+;Languages
+{{#each languages}}
+!insertmacro MUI_LANGUAGE "{{this}}"
+{{/each}}
+!insertmacro MUI_RESERVEFILE_LANGDLL
+{{#each language_files}}
+  !include "{{this}}"
+{{/each}}
+
+Function .onInit
+  ${GetOptions} $CMDLINE "/P" $PassiveMode
+  ${IfNot} ${Errors}
+    StrCpy $PassiveMode 1
+  ${EndIf}
+
+  ${GetOptions} $CMDLINE "/NS" $NoShortcutMode
+  ${IfNot} ${Errors}
+    StrCpy $NoShortcutMode 1
+  ${EndIf}
+
+  ${GetOptions} $CMDLINE "/UPDATE" $UpdateMode
+  ${IfNot} ${Errors}
+    StrCpy $UpdateMode 1
+  ${EndIf}
+
+  !if "${DISPLAYLANGUAGESELECTOR}" == "true"
+    !insertmacro MUI_LANGDLL_DISPLAY
+  !endif
+
+  !insertmacro SetContext
+
+  ${If} $INSTDIR == "${PLACEHOLDER_INSTALL_DIR}"
+    ; Set default install location
+    !if "${INSTALLMODE}" == "perMachine"
+      ${If} ${RunningX64}
+        !if "${ARCH}" == "x64"
+          StrCpy $INSTDIR "$PROGRAMFILES64\${PRODUCTNAME}"
+        !else if "${ARCH}" == "arm64"
+          StrCpy $INSTDIR "$PROGRAMFILES64\${PRODUCTNAME}"
+        !else
+          StrCpy $INSTDIR "$PROGRAMFILES\${PRODUCTNAME}"
+        !endif
+      ${Else}
+        StrCpy $INSTDIR "$PROGRAMFILES\${PRODUCTNAME}"
+      ${EndIf}
+    !else if "${INSTALLMODE}" == "currentUser"
+      StrCpy $INSTDIR "$LOCALAPPDATA\${PRODUCTNAME}"
+    !endif
+
+    Call RestorePreviousInstallLocation
+  ${EndIf}
+
+
+  !if "${INSTALLMODE}" == "both"
+    !insertmacro MULTIUSER_INIT
+  !endif
+FunctionEnd
+
+
+Section EarlyChecks
+  ; Abort silent installer if downgrades is disabled
+  !if "${ALLOWDOWNGRADES}" == "false"
+  ${If} ${Silent}
+    ; If downgrading
+    ${If} $R0 = -1
+      System::Call 'kernel32::AttachConsole(i -1)i.r0'
+      ${If} $0 <> 0
+        System::Call 'kernel32::GetStdHandle(i -11)i.r0'
+        System::call 'kernel32::SetConsoleTextAttribute(i r0, i 0x0004)' ; set red color
+        FileWrite $0 "$(silentDowngrades)"
+      ${EndIf}
+      Abort
+    ${EndIf}
+  ${EndIf}
+  !endif
+
+SectionEnd
+
+Section WebView2
+  ; Check if Webview2 is already installed and skip this section
+  ${If} ${RunningX64}
+    ReadRegStr $4 HKLM "SOFTWARE\WOW6432Node\Microsoft\EdgeUpdate\Clients\${WEBVIEW2APPGUID}" "pv"
+  ${Else}
+    ReadRegStr $4 HKLM "SOFTWARE\Microsoft\EdgeUpdate\Clients\${WEBVIEW2APPGUID}" "pv"
+  ${EndIf}
+  ${If} $4 == ""
+    ReadRegStr $4 HKCU "SOFTWARE\Microsoft\EdgeUpdate\Clients\${WEBVIEW2APPGUID}" "pv"
+  ${EndIf}
+
+  ${If} $4 == ""
+    ; Webview2 installation
+    ;
+    ; Skip if updating
+    ${If} $UpdateMode <> 1
+      !if "${INSTALLWEBVIEW2MODE}" == "downloadBootstrapper"
+        Delete "$TEMP\MicrosoftEdgeWebview2Setup.exe"
+        DetailPrint "$(webview2Downloading)"
+        NSISdl::download "https://go.microsoft.com/fwlink/p/?LinkId=2124703" "$TEMP\MicrosoftEdgeWebview2Setup.exe"
+        Pop $0
+        ${If} $0 == "success"
+          DetailPrint "$(webview2DownloadSuccess)"
+        ${Else}
+          DetailPrint "$(webview2DownloadError)"
+          Abort "$(webview2AbortError)"
+        ${EndIf}
+        StrCpy $6 "$TEMP\MicrosoftEdgeWebview2Setup.exe"
+        Goto install_webview2
+      !endif
+
+      !if "${INSTALLWEBVIEW2MODE}" == "embedBootstrapper"
+        Delete "$TEMP\MicrosoftEdgeWebview2Setup.exe"
+        File "/oname=$TEMP\MicrosoftEdgeWebview2Setup.exe" "${WEBVIEW2BOOTSTRAPPERPATH}"
+        DetailPrint "$(installingWebview2)"
+        StrCpy $6 "$TEMP\MicrosoftEdgeWebview2Setup.exe"
+        Goto install_webview2
+      !endif
+
+      !if "${INSTALLWEBVIEW2MODE}" == "offlineInstaller"
+        Delete "$TEMP\MicrosoftEdgeWebView2RuntimeInstaller.exe"
+        File "/oname=$TEMP\MicrosoftEdgeWebView2RuntimeInstaller.exe" "${WEBVIEW2INSTALLERPATH}"
+        DetailPrint "$(installingWebview2)"
+        StrCpy $6 "$TEMP\MicrosoftEdgeWebView2RuntimeInstaller.exe"
+        Goto install_webview2
+      !endif
+
+      Goto webview2_done
+
+      install_webview2:
+        DetailPrint "$(installingWebview2)"
+        ; $6 holds the path to the webview2 installer
+        ExecWait "$6 ${WEBVIEW2INSTALLERARGS} /install" $1
+        ${If} $1 = 0
+          DetailPrint "$(webview2InstallSuccess)"
+        ${Else}
+          DetailPrint "$(webview2InstallError)"
+          Abort "$(webview2AbortError)"
+        ${EndIf}
+      webview2_done:
+    ${EndIf}
+  ${Else}
+    !if "${MINIMUMWEBVIEW2VERSION}" != ""
+      ${VersionCompare} "${MINIMUMWEBVIEW2VERSION}" "$4" $R0
+      ${If} $R0 = 1
+        update_webview:
+          DetailPrint "$(installingWebview2)"
+          ${If} ${RunningX64}
+            ReadRegStr $R1 HKLM "SOFTWARE\WOW6432Node\Microsoft\EdgeUpdate" "path"
+          ${Else}
+            ReadRegStr $R1 HKLM "SOFTWARE\Microsoft\EdgeUpdate" "path"
+          ${EndIf}
+          ${If} $R1 == ""
+            ReadRegStr $R1 HKCU "SOFTWARE\Microsoft\EdgeUpdate" "path"
+          ${EndIf}
+          ${If} $R1 != ""
+            ; Chromium updater docs: https://source.chromium.org/chromium/chromium/src/+/main:docs/updater/user_manual.md
+            ; Modified from "HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\Microsoft EdgeWebView\ModifyPath"
+            ExecWait `"$R1" /install appguid=${WEBVIEW2APPGUID}&needsadmin=true` $1
+            ${If} $1 = 0
+              DetailPrint "$(webview2InstallSuccess)"
+            ${Else}
+              MessageBox MB_ICONEXCLAMATION|MB_ABORTRETRYIGNORE "$(webview2InstallError)" IDIGNORE ignore IDRETRY update_webview
+              Quit
+              ignore:
+            ${EndIf}
+          ${EndIf}
+      ${EndIf}
+    !endif
+  ${EndIf}
+SectionEnd
+
+Section Install
+  SetOutPath $INSTDIR
+
+  !ifmacrodef NSIS_HOOK_PREINSTALL
+    !insertmacro NSIS_HOOK_PREINSTALL
+  !endif
+
+  !insertmacro CheckIfAppIsRunning "${MAINBINARYNAME}.exe" "${PRODUCTNAME}"
+
+  ; Copy main executable
+  File "${MAINBINARYSRCPATH}"
+  ; MSVC links WebView2Loader statically, while GNU builds may emit a DLL next to the binary.
+  File /nonfatal /a "/oname=WebView2Loader.dll" "${WEBVIEW2LOADERSRCPATH}"
+
+  ; Copy resources
+  {{#each resources_dirs}}
+    CreateDirectory "$INSTDIR\\{{this}}"
+  {{/each}}
+  {{#each resources}}
+    File /a "/oname={{this.[1]}}" "{{no-escape @key}}"
+  {{/each}}
+
+  ; Copy external binaries
+  {{#each binaries}}
+    File /a "/oname={{this}}" "{{no-escape @key}}"
+  {{/each}}
+
+  ; Create file associations
+  {{#each file_associations as |association| ~}}
+    {{#each association.ext as |ext| ~}}
+       !insertmacro APP_ASSOCIATE "{{ext}}" "{{or association.name ext}}" "{{association-description association.description ext}}" "$INSTDIR\${MAINBINARYNAME}.exe,0" "Open with ${PRODUCTNAME}" "$INSTDIR\${MAINBINARYNAME}.exe $\"%1$\""
+    {{/each}}
+  {{/each}}
+
+  ; Register deep links
+  {{#each deep_link_protocols as |protocol| ~}}
+    WriteRegStr SHCTX "Software\Classes\\{{protocol}}" "URL Protocol" ""
+    WriteRegStr SHCTX "Software\Classes\\{{protocol}}" "" "URL:${BUNDLEID} protocol"
+    WriteRegStr SHCTX "Software\Classes\\{{protocol}}\DefaultIcon" "" "$\"$INSTDIR\${MAINBINARYNAME}.exe$\",0"
+    WriteRegStr SHCTX "Software\Classes\\{{protocol}}\shell\open\command" "" "$\"$INSTDIR\${MAINBINARYNAME}.exe$\" $\"%1$\""
+  {{/each}}
+
+  ; Create uninstaller
+  WriteUninstaller "$INSTDIR\uninstall.exe"
+
+  ; Save $INSTDIR in registry for future installations
+  WriteRegStr SHCTX "${MANUPRODUCTKEY}" "" $INSTDIR
+
+  !if "${INSTALLMODE}" == "both"
+    ; Save install mode to be selected by default for the next installation such as updating
+    ; or when uninstalling
+    WriteRegStr SHCTX "${UNINSTKEY}" $MultiUser.InstallMode 1
+  !endif
+
+  ; Remove old main binary if it doesn't match new main binary name
+  ReadRegStr $OldMainBinaryName SHCTX "${UNINSTKEY}" "MainBinaryName"
+  ${If} $OldMainBinaryName != ""
+  ${AndIf} $OldMainBinaryName != "${MAINBINARYNAME}.exe"
+    Delete "$INSTDIR\$OldMainBinaryName"
+  ${EndIf}
+
+  ; Save current MAINBINARYNAME for future updates
+  WriteRegStr SHCTX "${UNINSTKEY}" "MainBinaryName" "${MAINBINARYNAME}.exe"
+
+  ; Registry information for add/remove programs
+  WriteRegStr SHCTX "${UNINSTKEY}" "DisplayName" "${PRODUCTNAME}"
+  WriteRegStr SHCTX "${UNINSTKEY}" "DisplayIcon" "$\"$INSTDIR\${MAINBINARYNAME}.exe$\""
+  WriteRegStr SHCTX "${UNINSTKEY}" "DisplayVersion" "${VERSION}"
+  WriteRegStr SHCTX "${UNINSTKEY}" "Publisher" "${MANUFACTURER}"
+  WriteRegStr SHCTX "${UNINSTKEY}" "InstallLocation" "$\"$INSTDIR$\""
+  WriteRegStr SHCTX "${UNINSTKEY}" "UninstallString" "$\"$INSTDIR\uninstall.exe$\""
+  WriteRegDWORD SHCTX "${UNINSTKEY}" "NoModify" "1"
+  WriteRegDWORD SHCTX "${UNINSTKEY}" "NoRepair" "1"
+
+  ${GetSize} "$INSTDIR" "/M=uninstall.exe /S=0K /G=0" $0 $1 $2
+  IntOp $0 $0 + ${ESTIMATEDSIZE}
+  IntFmt $0 "0x%08X" $0
+  WriteRegDWORD SHCTX "${UNINSTKEY}" "EstimatedSize" "$0"
+
+  !if "${HOMEPAGE}" != ""
+    WriteRegStr SHCTX "${UNINSTKEY}" "URLInfoAbout" "${HOMEPAGE}"
+    WriteRegStr SHCTX "${UNINSTKEY}" "URLUpdateInfo" "${HOMEPAGE}"
+    WriteRegStr SHCTX "${UNINSTKEY}" "HelpLink" "${HOMEPAGE}"
+  !endif
+
+  ; Create start menu shortcut
+  !insertmacro MUI_STARTMENU_WRITE_BEGIN Application
+    Call CreateOrUpdateStartMenuShortcut
+  !insertmacro MUI_STARTMENU_WRITE_END
+
+  ; Create desktop shortcut for silent and passive installers
+  ; because finish page will be skipped
+  ${If} $PassiveMode = 1
+  ${OrIf} ${Silent}
+    Call CreateOrUpdateDesktopShortcut
+  ${EndIf}
+
+  !ifmacrodef NSIS_HOOK_POSTINSTALL
+    !insertmacro NSIS_HOOK_POSTINSTALL
+  !endif
+
+  ; Auto close this page for passive mode
+  ${If} $PassiveMode = 1
+    SetAutoClose true
+  ${EndIf}
+SectionEnd
+
+Function .onInstSuccess
+  ; Check for `/R` flag only in silent and passive installers because
+  ; GUI installer has a toggle for the user to (re)start the app
+  ${If} $PassiveMode = 1
+  ${OrIf} ${Silent}
+    ${GetOptions} $CMDLINE "/R" $R0
+    ${IfNot} ${Errors}
+      ${GetOptions} $CMDLINE "/ARGS" $R0
+      nsis_tauri_utils::RunAsUser "$INSTDIR\${MAINBINARYNAME}.exe" "$R0"
+    ${EndIf}
+  ${EndIf}
+FunctionEnd
+
+Function un.onInit
+  !insertmacro SetContext
+
+  !if "${INSTALLMODE}" == "both"
+    !insertmacro MULTIUSER_UNINIT
+  !endif
+
+  !insertmacro MUI_UNGETLANGUAGE
+
+  ${GetOptions} $CMDLINE "/P" $PassiveMode
+  ${IfNot} ${Errors}
+    StrCpy $PassiveMode 1
+  ${EndIf}
+
+  ${GetOptions} $CMDLINE "/UPDATE" $UpdateMode
+  ${IfNot} ${Errors}
+    StrCpy $UpdateMode 1
+  ${EndIf}
+FunctionEnd
+
+Section Uninstall
+
+  !ifmacrodef NSIS_HOOK_PREUNINSTALL
+    !insertmacro NSIS_HOOK_PREUNINSTALL
+  !endif
+
+  !insertmacro CheckIfAppIsRunning "${MAINBINARYNAME}.exe" "${PRODUCTNAME}"
+
+  ; Delete the app directory and its content from disk
+  ; Copy main executable
+  Delete "$INSTDIR\${MAINBINARYNAME}.exe"
+  Delete "$INSTDIR\WebView2Loader.dll"
+
+  ; Delete resources
+  {{#each resources}}
+    Delete "$INSTDIR\\{{this.[1]}}"
+  {{/each}}
+
+  ; Delete external binaries
+  {{#each binaries}}
+    Delete "$INSTDIR\\{{this}}"
+  {{/each}}
+
+  ; Delete app associations
+  {{#each file_associations as |association| ~}}
+    {{#each association.ext as |ext| ~}}
+      !insertmacro APP_UNASSOCIATE "{{ext}}" "{{or association.name ext}}"
+    {{/each}}
+  {{/each}}
+
+  ; Delete deep links
+  {{#each deep_link_protocols as |protocol| ~}}
+    ReadRegStr $R7 SHCTX "Software\Classes\\{{protocol}}\shell\open\command" ""
+    ${If} $R7 == "$\"$INSTDIR\${MAINBINARYNAME}.exe$\" $\"%1$\""
+      DeleteRegKey SHCTX "Software\Classes\\{{protocol}}"
+    ${EndIf}
+  {{/each}}
+
+
+  ; Delete uninstaller
+  Delete "$INSTDIR\uninstall.exe"
+
+  {{#each resources_ancestors}}
+  RMDir /REBOOTOK "$INSTDIR\\{{this}}"
+  {{/each}}
+  RMDir "$INSTDIR"
+
+  ; Remove shortcuts if not updating
+  ${If} $UpdateMode <> 1
+    !insertmacro DeleteAppUserModelId
+
+    ; Remove start menu shortcut
+    !insertmacro MUI_STARTMENU_GETFOLDER Application $AppStartMenuFolder
+    !insertmacro IsShortcutTarget "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    Pop $0
+    ${If} $0 = 1
+      !insertmacro UnpinShortcut "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk"
+      Delete "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk"
+      RMDir "$SMPROGRAMS\$AppStartMenuFolder"
+    ${EndIf}
+    !insertmacro IsShortcutTarget "$SMPROGRAMS\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    Pop $0
+    ${If} $0 = 1
+      !insertmacro UnpinShortcut "$SMPROGRAMS\${PRODUCTNAME}.lnk"
+      Delete "$SMPROGRAMS\${PRODUCTNAME}.lnk"
+    ${EndIf}
+
+    ; Remove desktop shortcuts
+    !insertmacro IsShortcutTarget "$DESKTOP\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    Pop $0
+    ${If} $0 = 1
+      !insertmacro UnpinShortcut "$DESKTOP\${PRODUCTNAME}.lnk"
+      Delete "$DESKTOP\${PRODUCTNAME}.lnk"
+    ${EndIf}
+  ${EndIf}
+
+  ; Remove registry information for add/remove programs
+  !if "${INSTALLMODE}" == "both"
+    DeleteRegKey SHCTX "${UNINSTKEY}"
+  !else if "${INSTALLMODE}" == "perMachine"
+    DeleteRegKey HKLM "${UNINSTKEY}"
+  !else
+    DeleteRegKey HKCU "${UNINSTKEY}"
+  !endif
+
+  ; Removes the Autostart entry for ${PRODUCTNAME} from the HKCU Run key if it exists.
+  ; This ensures the program does not launch automatically after uninstallation if it exists.
+  ; If it doesn't exist, it does nothing.
+  ; We do this when not updating (to preserve the registry value on updates)
+  ${If} $UpdateMode <> 1
+    DeleteRegValue HKCU "Software\Microsoft\Windows\CurrentVersion\Run" "${PRODUCTNAME}"
+  ${EndIf}
+
+  ; Delete app data if the checkbox is selected
+  ; and if not updating
+  ${If} $DeleteAppDataCheckboxState = 1
+  ${AndIf} $UpdateMode <> 1
+    ; Clear the install location $INSTDIR from registry
+    DeleteRegKey SHCTX "${MANUPRODUCTKEY}"
+    DeleteRegKey /ifempty SHCTX "${MANUKEY}"
+
+    ; Clear the install language from registry
+    DeleteRegValue HKCU "${MANUPRODUCTKEY}" "Installer Language"
+    DeleteRegKey /ifempty HKCU "${MANUPRODUCTKEY}"
+    DeleteRegKey /ifempty HKCU "${MANUKEY}"
+
+    SetShellVarContext current
+    RmDir /r "$APPDATA\${BUNDLEID}"
+    RmDir /r "$LOCALAPPDATA\${BUNDLEID}"
+  ${EndIf}
+
+  !ifmacrodef NSIS_HOOK_POSTUNINSTALL
+    !insertmacro NSIS_HOOK_POSTUNINSTALL
+  !endif
+
+  ; Auto close if passive mode or updating
+  ${If} $PassiveMode = 1
+  ${OrIf} $UpdateMode = 1
+    SetAutoClose true
+  ${EndIf}
+SectionEnd
+
+Function RestorePreviousInstallLocation
+  ReadRegStr $4 SHCTX "${MANUPRODUCTKEY}" ""
+  StrCmp $4 "" +2 0
+    StrCpy $INSTDIR $4
+FunctionEnd
+
+Function Skip
+  Abort
+FunctionEnd
+
+Function SkipIfPassive
+  ${IfThen} $PassiveMode = 1  ${|} Abort ${|}
+FunctionEnd
+Function un.SkipIfPassive
+  ${IfThen} $PassiveMode = 1  ${|} Abort ${|}
+FunctionEnd
+
+Function CreateOrUpdateStartMenuShortcut
+  ; We used to use product name as MAINBINARYNAME
+  ; migrate old shortcuts to target the new MAINBINARYNAME
+  StrCpy $R0 0
+
+  !insertmacro IsShortcutTarget "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk" "$INSTDIR\$OldMainBinaryName"
+  Pop $0
+  ${If} $0 = 1
+    !insertmacro SetShortcutTarget "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    StrCpy $R0 1
+  ${EndIf}
+
+  !insertmacro IsShortcutTarget "$SMPROGRAMS\${PRODUCTNAME}.lnk" "$INSTDIR\$OldMainBinaryName"
+  Pop $0
+  ${If} $0 = 1
+    !insertmacro SetShortcutTarget "$SMPROGRAMS\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    StrCpy $R0 1
+  ${EndIf}
+
+  ${If} $R0 = 1
+    Return
+  ${EndIf}
+
+  ; Skip creating shortcut if in update mode or no shortcut mode
+  ; but always create if migrating from wix
+  ${If} $WixMode = 0
+    ${If} $UpdateMode = 1
+    ${OrIf} $NoShortcutMode = 1
+      Return
+    ${EndIf}
+  ${EndIf}
+
+  !if "${STARTMENUFOLDER}" != ""
+    CreateDirectory "$SMPROGRAMS\$AppStartMenuFolder"
+    CreateShortcut "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    !insertmacro SetLnkAppUserModelId "$SMPROGRAMS\$AppStartMenuFolder\${PRODUCTNAME}.lnk"
+  !else
+    CreateShortcut "$SMPROGRAMS\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    !insertmacro SetLnkAppUserModelId "$SMPROGRAMS\${PRODUCTNAME}.lnk"
+  !endif
+FunctionEnd
+
+Function CreateOrUpdateDesktopShortcut
+  ; We used to use product name as MAINBINARYNAME
+  ; migrate old shortcuts to target the new MAINBINARYNAME
+  !insertmacro IsShortcutTarget "$DESKTOP\${PRODUCTNAME}.lnk" "$INSTDIR\$OldMainBinaryName"
+  Pop $0
+  ${If} $0 = 1
+    !insertmacro SetShortcutTarget "$DESKTOP\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+    Return
+  ${EndIf}
+
+  ; Skip creating shortcut if in update mode or no shortcut mode
+  ; but always create if migrating from wix
+  ${If} $WixMode = 0
+    ${If} $UpdateMode = 1
+    ${OrIf} $NoShortcutMode = 1
+      Return
+    ${EndIf}
+  ${EndIf}
+
+  CreateShortcut "$DESKTOP\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+  !insertmacro SetLnkAppUserModelId "$DESKTOP\${PRODUCTNAME}.lnk"
+FunctionEnd
diff --git a/tests/fixtures/production-safety-corpus.json b/tests/fixtures/production-safety-corpus.json
new file mode 100644
index 0000000..3f1cc4c
--- /dev/null
+++ b/tests/fixtures/production-safety-corpus.json
@@ -0,0 +1,312 @@
+[
+  {
+    "name": "mysql qualified delete targets production database",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "DELETE FROM prod_app.users WHERE id = 1",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql use switch carries production target to unqualified mutation",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "USE `prod_app`; DELETE FROM users WHERE id = 1",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql executable comment can contain a production delete",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "/*! DELETE FROM prod_app.users WHERE id = 1 */",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql qualified procedure call targets production database",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "CALL prod_app.purge_users()",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql qualified grant targets production database",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "GRANT ALL ON prod_app.* TO 'u'@'%'",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql unqualified procedure call is ambiguous with production markers",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "CALL purge_users()",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql global privilege statement is ambiguous with production markers",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "GRANT PROCESS ON *.* TO 'u'@'%'",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql non-production procedure target does not trip production marker",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "CALL staging.purge_users()",
+    "active": false,
+    "isMutation": true,
+    "databases": []
+  },
+  {
+    "name": "mysql non-production privilege target does not trip production marker",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "GRANT ALL ON staging.* TO 'u'@'%'",
+    "active": false,
+    "isMutation": true,
+    "databases": []
+  },
+  {
+    "name": "mysql unqualified table DML resolves to the selected non-production database",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "UPDATE users SET active = 1 WHERE id = 1",
+    "active": false,
+    "isMutation": true,
+    "databases": []
+  },
+  {
+    "name": "mysql repeated unqualified table DML resolves per statement",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "UPDATE users SET active = 1 WHERE id = 1; DELETE FROM users WHERE id = 2",
+    "active": false,
+    "isMutation": true,
+    "databases": []
+  },
+  {
+    "name": "mysql unknown mutation without a resolved target is conservatively confirmed",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "MAINTAIN UNKNOWN THING",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql transaction statement does not target a production database",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "BEGIN",
+    "active": false,
+    "isMutation": true,
+    "databases": []
+  },
+  {
+    "name": "mysql qualified rename table source and destination target production database",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "RENAME TABLE prod_app.old_name TO prod_app.new_name",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql rename table into production database is detected",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "RENAME TABLE staging.old_name TO prod_app.new_name",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql resolved non-production rename table target stays non-production",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "RENAME TABLE staging.old_name TO staging.new_name",
+    "active": false,
+    "isMutation": true,
+    "databases": []
+  },
+  {
+    "name": "mysql multi-target rename conservatively protects unresolved production target",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "RENAME TABLE staging.a TO staging.b, prod_app.c TO prod_app.d",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql multi-target drop conservatively protects unresolved production target",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "DROP TABLE staging.a, prod_app.b",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql qualified truncate table targets production database",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "TRUNCATE TABLE prod_app.users",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql resolved non-production truncate table target stays non-production",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "TRUNCATE TABLE staging.users",
+    "active": false,
+    "isMutation": true,
+    "databases": []
+  },
+  {
+    "name": "mysql optimize table targets production database",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "OPTIMIZE TABLE prod_app.users",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql analyze table targets production database",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "ANALYZE TABLE prod_app.users",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql repair table targets production database",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "REPAIR TABLE prod_app.users",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "mysql check table resolves to selected non-production database",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "CHECK TABLE users",
+    "active": false,
+    "isMutation": true,
+    "databases": []
+  },
+  {
+    "name": "mysql read-only production reference before staging write stays non-production",
+    "dialect": "mysql",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "SELECT * FROM prod_app.orders; DELETE FROM staging.users WHERE id = 1",
+    "active": false,
+    "isMutation": true,
+    "databases": []
+  },
+  {
+    "name": "mysql quoted unicode database target is preserved",
+    "dialect": "mysql",
+    "productionDatabases": ["生产库"],
+    "activeDatabase": "staging",
+    "sql": "DELETE FROM `生产库`.users WHERE id = 1",
+    "active": true,
+    "isMutation": true,
+    "databases": ["生产库"]
+  },
+  {
+    "name": "mysql quoted database containing spaces is preserved in privilege target",
+    "dialect": "mysql",
+    "productionDatabases": ["prod app"],
+    "activeDatabase": "staging",
+    "sql": "GRANT ALL ON `prod app`.* TO 'u'@'%'",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod app"]
+  },
+  {
+    "name": "mysql quoted routine target with unicode database is preserved",
+    "dialect": "mysql",
+    "productionDatabases": ["生产库"],
+    "activeDatabase": "staging",
+    "sql": "CALL `生产库`.`purge users`()",
+    "active": true,
+    "isMutation": true,
+    "databases": ["生产库"]
+  },
+  {
+    "name": "mysql quoted database containing dot is not split as a qualifier",
+    "dialect": "mysql",
+    "productionDatabases": ["prod.app"],
+    "activeDatabase": "staging",
+    "sql": "DROP DATABASE IF EXISTS `prod.app`",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod.app"]
+  },
+  {
+    "name": "sqlserver three-part table name resolves production database",
+    "dialect": "sqlserver",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "DELETE FROM prod_app.dbo.users WHERE id = 1",
+    "active": true,
+    "isMutation": true,
+    "databases": ["prod_app"]
+  },
+  {
+    "name": "sqlserver two-part table name is schema-qualified, not database-qualified",
+    "dialect": "sqlserver",
+    "productionDatabases": ["prod_app"],
+    "activeDatabase": "staging",
+    "sql": "DELETE FROM prod_app.users WHERE id = 1",
+    "active": false,
+    "isMutation": true,
+    "databases": []
+  }
+]
diff --git a/vitest.config.ts b/vitest.config.ts
new file mode 100644
index 0000000..d8687fa
--- /dev/null
+++ b/vitest.config.ts
@@ -0,0 +1,14 @@
+import path from "node:path";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "apps/desktop/src"),
+    },
+  },
+  test: {
+    include: ["packages/app-tests/*.test.ts", "packages/node-core/tests/*.test.ts", "apps/desktop/src/**/*.spec.ts", "docs/lib/*.test.ts"],
+    globalSetup: "packages/test-globals.ts",
+  },
+});